From 3f2bf2853fec4355ef2f18e5bc3baaab6f3bd4a1 Mon Sep 17 00:00:00 2001 From: Anton Evangelatov Date: Fri, 3 Oct 2025 16:57:11 +0200 Subject: [PATCH 001/117] op-acceptance-tests: test that unsafe chain is stalled when ReqResSync is disabled (#17696) * op-acceptance-tests: test that unsafe chain is stalled when ReqResSync is disabled * address comments --- .../tests/depreqres/depreqres_test.go | 56 +++++++++++++++++++ .../tests/depreqres/init_test.go | 16 ++++++ op-devstack/presets/cl_config.go | 8 +++ op-devstack/sysgo/l2_cl.go | 4 ++ op-devstack/sysgo/l2_cl_opnode.go | 3 + 5 files changed, 87 insertions(+) create mode 100644 op-acceptance-tests/tests/depreqres/depreqres_test.go create mode 100644 op-acceptance-tests/tests/depreqres/init_test.go diff --git a/op-acceptance-tests/tests/depreqres/depreqres_test.go b/op-acceptance-tests/tests/depreqres/depreqres_test.go new file mode 100644 index 00000000000..79fa05817e0 --- /dev/null +++ b/op-acceptance-tests/tests/depreqres/depreqres_test.go @@ -0,0 +1,56 @@ +package depreqres + +import ( + "testing" + "time" + + "github.com/ethereum-optimism/optimism/op-devstack/devtest" + "github.com/ethereum-optimism/optimism/op-devstack/dsl" + "github.com/ethereum-optimism/optimism/op-devstack/presets" + "github.com/ethereum-optimism/optimism/op-supervisor/supervisor/types" +) + +func TestUnsafeChainStalling_DisabledReqRespSync(gt *testing.T) { + t := devtest.SerialT(gt) + sys := presets.NewSingleChainMultiNode(t) + require := t.Require() + l := t.Logger() + + l.Info("Confirm that the CL nodes are progressing the unsafe chain") + target := uint64(10) + dsl.CheckAll(t, + sys.L2CL.AdvancedFn(types.LocalUnsafe, target, 30), + sys.L2CLB.AdvancedFn(types.LocalUnsafe, target, 30), + ) + + l.Info("Stop the L2 batcher") + sys.L2Batcher.Stop() + + l.Info("Disconnect L2CL from L2CLB, and vice versa") + sys.L2CLB.DisconnectPeer(sys.L2CL) + sys.L2CL.DisconnectPeer(sys.L2CLB) + + ssA_before := sys.L2CL.SyncStatus() + ssB_before := sys.L2CLB.SyncStatus() + + l.Info("L2CL status before delay", "unsafeL2", ssA_before.UnsafeL2.ID(), "safeL2", ssA_before.SafeL2.ID()) + l.Info("L2CLB status before delay", "unsafeL2", ssB_before.UnsafeL2.ID(), "safeL2", ssB_before.SafeL2.ID()) + + time.Sleep(20 * time.Second) + + ssA_after := sys.L2CL.SyncStatus() + ssB_after := sys.L2CLB.SyncStatus() + + l.Info("L2CL status after delay", "unsafeL2", ssA_after.UnsafeL2.ID(), "safeL2", ssA_after.SafeL2.ID()) + l.Info("L2CLB status after delay", "unsafeL2", ssB_after.UnsafeL2.ID(), "safeL2", ssB_after.SafeL2.ID()) + + require.Greater(ssA_after.UnsafeL2.Number, ssA_before.UnsafeL2.Number, "unsafe chain for L2CL should have advanced") + require.Equal(ssB_after.UnsafeL2.Number, ssB_before.UnsafeL2.Number, "unsafe chain for L2CLB should have stalled") + + l.Info("Re-connect L2CL to L2CLB") + sys.L2CLB.ConnectPeer(sys.L2CL) + sys.L2CL.ConnectPeer(sys.L2CLB) + + l.Info("Confirm that the unsafe chain for L2CLB is stalled") + sys.L2CLB.NotAdvanced(types.LocalUnsafe, 10) +} diff --git a/op-acceptance-tests/tests/depreqres/init_test.go b/op-acceptance-tests/tests/depreqres/init_test.go new file mode 100644 index 00000000000..ff0f2710d95 --- /dev/null +++ b/op-acceptance-tests/tests/depreqres/init_test.go @@ -0,0 +1,16 @@ +package depreqres + +import ( + "testing" + + "github.com/ethereum-optimism/optimism/op-devstack/compat" + "github.com/ethereum-optimism/optimism/op-devstack/presets" +) + +func TestMain(m *testing.M) { + presets.DoMain(m, presets.WithSingleChainMultiNode(), + presets.WithExecutionLayerSyncOnVerifiers(), + presets.WithCompatibleTypes(compat.SysGo), + presets.WithReqRespSyncDisabled(), + ) +} diff --git a/op-devstack/presets/cl_config.go b/op-devstack/presets/cl_config.go index d56cbe4d48f..95a3d900ae6 100644 --- a/op-devstack/presets/cl_config.go +++ b/op-devstack/presets/cl_config.go @@ -31,3 +31,11 @@ func WithSafeDBEnabled() stack.CommonOption { cfg.SafeDBPath = p.TempDir() }))) } + +func WithReqRespSyncDisabled() stack.CommonOption { + return stack.MakeCommon( + sysgo.WithGlobalL2CLOption(sysgo.L2CLOptionFn( + func(_ devtest.P, id stack.L2CLNodeID, cfg *sysgo.L2CLConfig) { + cfg.EnableReqRespSync = false + }))) +} diff --git a/op-devstack/sysgo/l2_cl.go b/op-devstack/sysgo/l2_cl.go index a7f3a4366dc..32f16a679c9 100644 --- a/op-devstack/sysgo/l2_cl.go +++ b/op-devstack/sysgo/l2_cl.go @@ -27,6 +27,9 @@ type L2CLConfig struct { IsSequencer bool IndexingMode bool + + // EnableReqRespSync is the flag to enable/disable req-resp sync. + EnableReqRespSync bool } func L2CLSequencer() L2CLOption { @@ -48,6 +51,7 @@ func DefaultL2CLConfig() *L2CLConfig { SafeDBPath: "", IsSequencer: false, IndexingMode: false, + EnableReqRespSync: true, } } diff --git a/op-devstack/sysgo/l2_cl_opnode.go b/op-devstack/sysgo/l2_cl_opnode.go index 46bfdb916ec..99fcc60b066 100644 --- a/op-devstack/sysgo/l2_cl_opnode.go +++ b/op-devstack/sysgo/l2_cl_opnode.go @@ -241,6 +241,9 @@ func WithOpNode(l2CLID stack.L2CLNodeID, l1CLID stack.L1CLNodeID, l1ELID stack.L } } + // Set the req-resp sync flag as per config + p2pConfig.EnableReqRespSync = cfg.EnableReqRespSync + // Get the L2 engine address from the EL node (which can be a regular EL node or a SyncTesterEL) l2EngineAddr := l2EL.EngineRPC() From a21294bcca63f4b0685fb19d4d8a0a4997d968cd Mon Sep 17 00:00:00 2001 From: Maurelian Date: Fri, 3 Oct 2025 14:35:57 -0400 Subject: [PATCH 002/117] Full TimelockGuard implementation (#17584) MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit * feat: implement configureTimelockGuard function - Add configureTimelockGuard function to allow Safes to set timelock delays - Validate timelock delay between 1 second and 1 year - Check that guard is properly enabled on calling Safe using getStorageAt() - Store configuration per Safe with GuardConfigured event emission - Add comprehensive test suite covering all spec requirements - Implement IGuard interface for Safe compatibility 🤖 Generated with [Claude Code](https://claude.ai/code) Co-Authored-By: Claude * feat: implement clearTimelockGuard function - Add clearTimelockGuard function to allow Safes to clear timelock configuration - Validate that guard is disabled before allowing configuration clearing - Check that Safe was previously configured before clearing - Delete configuration data and emit GuardCleared event - Add comprehensive test suite covering all spec requirements - Add new errors: TimelockGuard_GuardNotConfigured, TimelockGuard_GuardStillEnabled 🤖 Generated with [Claude Code](https://claude.ai/code) Co-Authored-By: Claude * refactor: extract guard checking logic to internal helper function - Add internal _getGuard() helper to centralize guard address retrieval - Update configureTimelockGuard and clearTimelockGuard to use helper - Reduces code duplication and improves maintainability 🤖 Generated with [Claude Code](https://claude.ai/code) Co-Authored-By: Claude * feat: implement cancellationThreshold function - Add cancellationThreshold function to return current threshold for a Safe - Return 0 if guard not enabled or not configured - Initialize to 1 when Safe configures guard - Clear threshold when Safe clears guard configuration - Add comprehensive test suite covering all spec requirements - Function never reverts as per spec requirements 🤖 Generated with [Claude Code](https://claude.ai/code) Co-Authored-By: Claude * feat: add placeholder functions for remaining TimelockGuard functionality - Add scheduleTransaction placeholder (Function 4) - Add checkPendingTransactions placeholder (Function 6) - Add rejectTransaction placeholder (Function 7) - Add rejectTransactionWithSignature placeholder (Function 8) - Add cancelTransaction placeholder (Function 9) - Update checkTransaction placeholder (Function 5) - All placeholders have proper signatures and documentation 🤖 Generated with [Claude Code](https://claude.ai/code) Co-Authored-By: Claude * Self review fixes * Fix warnings on unimplemented functions * Fix names of test functions * Satisfy semgrep by removing revert with string * Remove arg names from unimplemented functions * Snapshots * Add interface * Simplify cancellationThreshold() getter * Replace _getGuard with isGuardEnabled * Allow a timelock delay of zero * TimelockGuard: Add scheduleTransaction() * Add todo note * Pseudocode draft of a non-nested timelock Simpler code Add cancelTransaction function relying on the Safe's internal logic undo type change Add note explaining getScheduledTransactions * Remove signatures field from ExecTransactionParams * Refactor tests with improve utils (_getDummyTx, _getSignaturesForTx) * Test for TransactionCancelled event * Further improve util functions * Add approve hash test case * fix warnings * Use correct typing for Safe addresses This is applied to function inputs/outputs as well as mappings and events * Add additional scheduleTransaction tests * Enable specifying which safeInstance in utility functions * Change cancelTransaction to accept a tx hash * Add increaseCancellationThreshold to cancelTransaction * Add configured boolean to guard config * Fix signature reuse vulnerability in cancelTransaction Include transaction hash in cancellation signature data to prevent signatures from being reused across different transactions with the same nonce. Updates both contract implementation and tests. * Move signature verification before existence check in scheduleTransaction * Remove unused console.logs * Fix increaseCancellationThreshold inputs * Separate cancellation threshold events from transaction cancellation Add CancellationThresholdUpdated event and emit it from threshold modification functions. Remove threshold parameter from TransactionCancelled event for cleaner separation of concerns. * Remove unused _txHash argument from resetCancellation function * Update ITimelockGuard to match implementation * Use configured flag instead of timelockDelay check in clearTimelockGuard * Add configuration check to scheduleTransaction and fix test names * Implement checkTransaction * Add itest placeholder contract * Add comment to checkAfterExecution body * pre-pr checks * Remove GuardConfig.configured boolean field We can simply use `timelock > 0` as an indicator of configuration * Remove clearTimelockGuard The right way to do this is now just to set timelockDelay to zero. * Refactor: Add TransactionBuilder library This library significantly reduces the amount of boilerplace required to setup a Safe transaction, then schedule, cancel, or execute it. * Add unreachable AlreadyExecuted error * Add integration tests * Add getPendingTransactions function and tests * Add tests for getScheduledTransaction * Add _ prefix in front of internal mappings * Rename viewTimelockGuard to timelockSafeConfigurationper specs * Add maxCancellationThreshold * Improve names on getter functions * Remove @dev tags with invariants Avoids duplicating logic between specs and implementation * Update configureTimelockGuard to accept and validate signatures outside of the Safe * Refactor: use a single struct to store all state for a given Safe * Do not unnecessarily reset cancellation threshold when config set to 0 * Revert "Update configureTimelockGuard to accept and validate signatures outside of the Safe" This reverts commit daad53b9090af05de64177680dfbe9baf7b2f9e8. * Move timelockDelay out of unnecessary struct * Add top level detail natspec, reorder functions by vis and mutability * Remove test that does not conform to spec * Add cancelTransactionOnSafe to interface as reverting function * Add many more comments * Apply suggestions from code review Co-authored-by: Alberto Cuesta Cañada <38806121+alcueca@users.noreply.github.com> * Fix ITimelockGuard iface to match impl * Rename arguments for consistency * Add/fixup @param on events * Small fixes * Fix ITimelockGuard declaration * Improve names on getter functions * Move ExecTransactionParams into TimelockGuard.sol * Address comment nits * Add TimelockGuard_MaxCancellationThreshold_Test and _deploySafe helper * Fix up iface and comment typos * Fix storage lookup in test * Add enum Transaction state and remove cancelled/executed booleans * add /// @custom:field on ScheduledTransaction struct * add /// @custom:field on ExecTransactionParams struct * Add SemverComp to enforce minimum Safe version * Rename empty function to signCancellationForSafe * Fix location of external view functions * Add some more comments where helpful. * Further expand on the maxCancellationThreshold rationale * Clarify blocking threshold * iFace fixes * Fix iface * Move update of tx state, event emission and cancellationThreshold into checkAfterExection * Simplified comment * remove unclear comments * fix semgrep sol-style-use-abi-encodecall * snapshots * Add course of actions table * Remove unnecessary address arg from signCancellation * Fix test names * Fix test name validation * Remove enabled guard check from configureTimelockGuard * Allow _Integration_Test in tests * Add isExcludedTest in checkContractNameFilePath() * Update semver-lock * Fix typo * fix typo in tests --------- Co-authored-by: Claude Co-authored-by: alcueca Co-authored-by: Alberto Cuesta Cañada <38806121+alcueca@users.noreply.github.com> --- .../interfaces/safe/ITimelockGuard.sol | 92 ++ .../checks/test-validation/exclusions.toml | 1 + .../scripts/checks/test-validation/main.go | 14 +- .../snapshots/abi/TimelockGuard.json | 623 +++++++++++++ .../snapshots/semver-lock.json | 4 + .../storageLayout/TimelockGuard.json | 9 + .../src/safe/TimelockGuard.sol | 615 ++++++++++++ .../test/safe/TimelockGuard.t.sol | 879 ++++++++++++++++++ 8 files changed, 2234 insertions(+), 3 deletions(-) create mode 100644 packages/contracts-bedrock/interfaces/safe/ITimelockGuard.sol create mode 100644 packages/contracts-bedrock/snapshots/abi/TimelockGuard.json create mode 100644 packages/contracts-bedrock/snapshots/storageLayout/TimelockGuard.json create mode 100644 packages/contracts-bedrock/src/safe/TimelockGuard.sol create mode 100644 packages/contracts-bedrock/test/safe/TimelockGuard.t.sol diff --git a/packages/contracts-bedrock/interfaces/safe/ITimelockGuard.sol b/packages/contracts-bedrock/interfaces/safe/ITimelockGuard.sol new file mode 100644 index 00000000000..ccf454985a9 --- /dev/null +++ b/packages/contracts-bedrock/interfaces/safe/ITimelockGuard.sol @@ -0,0 +1,92 @@ +// SPDX-License-Identifier: UNLICENSED +pragma solidity ^0.8.4; + +library Enum { + type Operation is uint8; +} + +interface ITimelockGuard { + enum TransactionState { + NotScheduled, + Pending, + Cancelled, + Executed + } + struct ScheduledTransaction { + uint256 executionTime; + TransactionState state; + ExecTransactionParams params; + } + + struct ExecTransactionParams { + address to; + uint256 value; + bytes data; + Enum.Operation operation; + uint256 safeTxGas; + uint256 baseGas; + uint256 gasPrice; + address gasToken; + address payable refundReceiver; + } + + error TimelockGuard_GuardNotConfigured(); + error TimelockGuard_GuardNotEnabled(); + error TimelockGuard_GuardStillEnabled(); + error TimelockGuard_InvalidTimelockDelay(); + error TimelockGuard_TransactionAlreadyCancelled(); + error TimelockGuard_TransactionAlreadyScheduled(); + error TimelockGuard_TransactionNotScheduled(); + error TimelockGuard_TransactionNotReady(); + error TimelockGuard_TransactionAlreadyExecuted(); + error TimelockGuard_InvalidVersion(); + + event CancellationThresholdUpdated(address indexed safe, uint256 oldThreshold, uint256 newThreshold); + event GuardConfigured(address indexed safe, uint256 timelockDelay); + event TransactionCancelled(address indexed safe, bytes32 indexed txHash); + event TransactionScheduled(address indexed safe, bytes32 indexed txHash, uint256 executionTime); + event TransactionExecuted(address indexed safe, bytes32 txHash); + event Message(string message); + + function cancelTransaction(address _safe, bytes32 _txHash, uint256 _nonce, bytes memory _signatures) external; + function signCancellation(bytes32 _txHash) external; + function cancellationThreshold(address _safe) external view returns (uint256); + function checkTransaction( + address _to, + uint256 _value, + bytes memory _data, + Enum.Operation _operation, + uint256 _safeTxGas, + uint256 _baseGas, + uint256 _gasPrice, + address _gasToken, + address payable _refundReceiver, + bytes memory _signatures, + address _msgSender + ) + external; + function checkAfterExecution(bytes32, bool) external; + function configureTimelockGuard(uint256 _timelockDelay) external; + function scheduledTransaction( + address _safe, + bytes32 _txHash + ) + external + view + returns (ScheduledTransaction memory); + function safeConfigs(address) external view returns (uint256 timelockDelay); + function scheduleTransaction( + address _safe, + uint256 _nonce, + ExecTransactionParams memory _params, + bytes memory _signatures + ) + external; + function version() external view returns (string memory); + function timelockConfiguration(address _safe) external view returns (uint256 timelockDelay); + function maxCancellationThreshold(address _safe) external view returns (uint256); + function pendingTransactions(address _safe) + external + view + returns (ScheduledTransaction[] memory); +} diff --git a/packages/contracts-bedrock/scripts/checks/test-validation/exclusions.toml b/packages/contracts-bedrock/scripts/checks/test-validation/exclusions.toml index dd174c68b58..6c332b4e8a3 100644 --- a/packages/contracts-bedrock/scripts/checks/test-validation/exclusions.toml +++ b/packages/contracts-bedrock/scripts/checks/test-validation/exclusions.toml @@ -92,5 +92,6 @@ contracts = [ "OptimismPortal2_MigrateLiquidity_Test", # Interop tests hosted in the OptimismPortal2 test file "OptimismPortal2_MigrateToSuperRoots_Test", # Interop tests hosted in the OptimismPortal2 test file "OptimismPortal2_UpgradeInterop_Test", # Interop tests hosted in the OptimismPortal2 test file + "TransactionBuilder", # Transaction builder helper library in TimelockGuard test file "Constants_Test", # Invalid naming pattern - doesn't specify function or Uncategorized ] diff --git a/packages/contracts-bedrock/scripts/checks/test-validation/main.go b/packages/contracts-bedrock/scripts/checks/test-validation/main.go index d752e256624..776e769ac3f 100644 --- a/packages/contracts-bedrock/scripts/checks/test-validation/main.go +++ b/packages/contracts-bedrock/scripts/checks/test-validation/main.go @@ -194,9 +194,12 @@ func checkTestStructure(artifact *solc.ForgeArtifact) []error { func checkTestMethodName(artifact *solc.ForgeArtifact, contractName string, functionName string, _ string) []error { // Check for uncategorized test pattern - if functionName == "Uncategorized" { - // Pattern: _Uncategorized_Test - return nil + allowedFunctionNames := []string{"Uncategorized", "Integration"} + for _, allowed := range allowedFunctionNames { + if functionName == allowed { + // Pattern: _Uncategorized_Test or _Integration_Test + return nil + } } // Pattern: __Test - validate function exists if !checkFunctionExists(artifact, functionName) { @@ -250,6 +253,11 @@ func checkSrcPath(artifact *solc.ForgeArtifact) bool { // Validates that contract name matches the file path func checkContractNameFilePath(artifact *solc.ForgeArtifact) bool { for filePath, contractName := range artifact.Metadata.Settings.CompilationTarget { + + if isExcludedTest(contractName) { + continue + } + // Split contract name to get the base contract name (before first underscore) contractParts := strings.Split(contractName, "_") // Split file path to get individual path components diff --git a/packages/contracts-bedrock/snapshots/abi/TimelockGuard.json b/packages/contracts-bedrock/snapshots/abi/TimelockGuard.json new file mode 100644 index 00000000000..15145753d43 --- /dev/null +++ b/packages/contracts-bedrock/snapshots/abi/TimelockGuard.json @@ -0,0 +1,623 @@ +[ + { + "inputs": [ + { + "internalType": "contract GnosisSafe", + "name": "_safe", + "type": "address" + }, + { + "internalType": "bytes32", + "name": "_txHash", + "type": "bytes32" + }, + { + "internalType": "uint256", + "name": "_nonce", + "type": "uint256" + }, + { + "internalType": "bytes", + "name": "_signatures", + "type": "bytes" + } + ], + "name": "cancelTransaction", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "contract GnosisSafe", + "name": "_safe", + "type": "address" + } + ], + "name": "cancellationThreshold", + "outputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "bytes32", + "name": "_txHash", + "type": "bytes32" + }, + { + "internalType": "bool", + "name": "_success", + "type": "bool" + } + ], + "name": "checkAfterExecution", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "_to", + "type": "address" + }, + { + "internalType": "uint256", + "name": "_value", + "type": "uint256" + }, + { + "internalType": "bytes", + "name": "_data", + "type": "bytes" + }, + { + "internalType": "enum Enum.Operation", + "name": "_operation", + "type": "uint8" + }, + { + "internalType": "uint256", + "name": "_safeTxGas", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "_baseGas", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "_gasPrice", + "type": "uint256" + }, + { + "internalType": "address", + "name": "_gasToken", + "type": "address" + }, + { + "internalType": "address payable", + "name": "_refundReceiver", + "type": "address" + }, + { + "internalType": "bytes", + "name": "", + "type": "bytes" + }, + { + "internalType": "address", + "name": "", + "type": "address" + } + ], + "name": "checkTransaction", + "outputs": [], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "_timelockDelay", + "type": "uint256" + } + ], + "name": "configureTimelockGuard", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "contract GnosisSafe", + "name": "_safe", + "type": "address" + } + ], + "name": "maxCancellationThreshold", + "outputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "contract GnosisSafe", + "name": "_safe", + "type": "address" + } + ], + "name": "pendingTransactions", + "outputs": [ + { + "components": [ + { + "internalType": "uint256", + "name": "executionTime", + "type": "uint256" + }, + { + "internalType": "enum TimelockGuard.TransactionState", + "name": "state", + "type": "uint8" + }, + { + "components": [ + { + "internalType": "address", + "name": "to", + "type": "address" + }, + { + "internalType": "uint256", + "name": "value", + "type": "uint256" + }, + { + "internalType": "bytes", + "name": "data", + "type": "bytes" + }, + { + "internalType": "enum Enum.Operation", + "name": "operation", + "type": "uint8" + }, + { + "internalType": "uint256", + "name": "safeTxGas", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "baseGas", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "gasPrice", + "type": "uint256" + }, + { + "internalType": "address", + "name": "gasToken", + "type": "address" + }, + { + "internalType": "address payable", + "name": "refundReceiver", + "type": "address" + } + ], + "internalType": "struct TimelockGuard.ExecTransactionParams", + "name": "params", + "type": "tuple" + } + ], + "internalType": "struct TimelockGuard.ScheduledTransaction[]", + "name": "", + "type": "tuple[]" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "contract GnosisSafe", + "name": "_safe", + "type": "address" + }, + { + "internalType": "uint256", + "name": "_nonce", + "type": "uint256" + }, + { + "components": [ + { + "internalType": "address", + "name": "to", + "type": "address" + }, + { + "internalType": "uint256", + "name": "value", + "type": "uint256" + }, + { + "internalType": "bytes", + "name": "data", + "type": "bytes" + }, + { + "internalType": "enum Enum.Operation", + "name": "operation", + "type": "uint8" + }, + { + "internalType": "uint256", + "name": "safeTxGas", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "baseGas", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "gasPrice", + "type": "uint256" + }, + { + "internalType": "address", + "name": "gasToken", + "type": "address" + }, + { + "internalType": "address payable", + "name": "refundReceiver", + "type": "address" + } + ], + "internalType": "struct TimelockGuard.ExecTransactionParams", + "name": "_params", + "type": "tuple" + }, + { + "internalType": "bytes", + "name": "_signatures", + "type": "bytes" + } + ], + "name": "scheduleTransaction", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "contract GnosisSafe", + "name": "_safe", + "type": "address" + }, + { + "internalType": "bytes32", + "name": "_txHash", + "type": "bytes32" + } + ], + "name": "scheduledTransaction", + "outputs": [ + { + "components": [ + { + "internalType": "uint256", + "name": "executionTime", + "type": "uint256" + }, + { + "internalType": "enum TimelockGuard.TransactionState", + "name": "state", + "type": "uint8" + }, + { + "components": [ + { + "internalType": "address", + "name": "to", + "type": "address" + }, + { + "internalType": "uint256", + "name": "value", + "type": "uint256" + }, + { + "internalType": "bytes", + "name": "data", + "type": "bytes" + }, + { + "internalType": "enum Enum.Operation", + "name": "operation", + "type": "uint8" + }, + { + "internalType": "uint256", + "name": "safeTxGas", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "baseGas", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "gasPrice", + "type": "uint256" + }, + { + "internalType": "address", + "name": "gasToken", + "type": "address" + }, + { + "internalType": "address payable", + "name": "refundReceiver", + "type": "address" + } + ], + "internalType": "struct TimelockGuard.ExecTransactionParams", + "name": "params", + "type": "tuple" + } + ], + "internalType": "struct TimelockGuard.ScheduledTransaction", + "name": "", + "type": "tuple" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "bytes32", + "name": "", + "type": "bytes32" + } + ], + "name": "signCancellation", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "contract GnosisSafe", + "name": "_safe", + "type": "address" + } + ], + "name": "timelockConfiguration", + "outputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [], + "name": "version", + "outputs": [ + { + "internalType": "string", + "name": "", + "type": "string" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "contract GnosisSafe", + "name": "safe", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "oldThreshold", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "newThreshold", + "type": "uint256" + } + ], + "name": "CancellationThresholdUpdated", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "contract GnosisSafe", + "name": "safe", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "timelockDelay", + "type": "uint256" + } + ], + "name": "GuardConfigured", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": false, + "internalType": "string", + "name": "message", + "type": "string" + } + ], + "name": "Message", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "contract GnosisSafe", + "name": "safe", + "type": "address" + }, + { + "indexed": true, + "internalType": "bytes32", + "name": "txHash", + "type": "bytes32" + } + ], + "name": "TransactionCancelled", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "contract GnosisSafe", + "name": "safe", + "type": "address" + }, + { + "indexed": false, + "internalType": "bytes32", + "name": "txHash", + "type": "bytes32" + } + ], + "name": "TransactionExecuted", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "contract GnosisSafe", + "name": "safe", + "type": "address" + }, + { + "indexed": true, + "internalType": "bytes32", + "name": "txHash", + "type": "bytes32" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "executionTime", + "type": "uint256" + } + ], + "name": "TransactionScheduled", + "type": "event" + }, + { + "inputs": [], + "name": "SemverComp_InvalidSemverParts", + "type": "error" + }, + { + "inputs": [], + "name": "TimelockGuard_GuardNotConfigured", + "type": "error" + }, + { + "inputs": [], + "name": "TimelockGuard_GuardNotEnabled", + "type": "error" + }, + { + "inputs": [], + "name": "TimelockGuard_InvalidTimelockDelay", + "type": "error" + }, + { + "inputs": [], + "name": "TimelockGuard_InvalidVersion", + "type": "error" + }, + { + "inputs": [], + "name": "TimelockGuard_TransactionAlreadyCancelled", + "type": "error" + }, + { + "inputs": [], + "name": "TimelockGuard_TransactionAlreadyExecuted", + "type": "error" + }, + { + "inputs": [], + "name": "TimelockGuard_TransactionAlreadyScheduled", + "type": "error" + }, + { + "inputs": [], + "name": "TimelockGuard_TransactionNotReady", + "type": "error" + }, + { + "inputs": [], + "name": "TimelockGuard_TransactionNotScheduled", + "type": "error" + } +] \ No newline at end of file diff --git a/packages/contracts-bedrock/snapshots/semver-lock.json b/packages/contracts-bedrock/snapshots/semver-lock.json index eb5f4a75cbf..4c4a77f3508 100644 --- a/packages/contracts-bedrock/snapshots/semver-lock.json +++ b/packages/contracts-bedrock/snapshots/semver-lock.json @@ -211,6 +211,10 @@ "initCodeHash": "0x4679b41e5648a955a883efd0271453c8b13ff4846f853d372527ebb1e0905ab5", "sourceCodeHash": "0xd3084fb5446782cb6d0adb4278ef0a12c418dd538b4b14b90407b971b44cc35b" }, + "src/safe/TimelockGuard.sol:TimelockGuard": { + "initCodeHash": "0x1f8188872de93ce59e8f0bd415d4fbf30209bc668c09623f61d6fe592eee895a", + "sourceCodeHash": "0x0dada93f051d29dabbb6de3e1c1ece14b95cd20dc854454926d19ea1ebcae436" + }, "src/universal/OptimismMintableERC20.sol:OptimismMintableERC20": { "initCodeHash": "0x3c85eed0d017dca8eda6396aa842ddc12492587b061e8c756a8d32c4610a9658", "sourceCodeHash": "0x7023665d461f173417d932b55010b8f6c34f2bbaf56cfe4e1b15862c08cbcaac" diff --git a/packages/contracts-bedrock/snapshots/storageLayout/TimelockGuard.json b/packages/contracts-bedrock/snapshots/storageLayout/TimelockGuard.json new file mode 100644 index 00000000000..97c754bfc8c --- /dev/null +++ b/packages/contracts-bedrock/snapshots/storageLayout/TimelockGuard.json @@ -0,0 +1,9 @@ +[ + { + "bytes": "32", + "label": "_safeState", + "offset": 0, + "slot": "0", + "type": "mapping(contract GnosisSafe => struct TimelockGuard.SafeState)" + } +] \ No newline at end of file diff --git a/packages/contracts-bedrock/src/safe/TimelockGuard.sol b/packages/contracts-bedrock/src/safe/TimelockGuard.sol new file mode 100644 index 00000000000..26dce92ce47 --- /dev/null +++ b/packages/contracts-bedrock/src/safe/TimelockGuard.sol @@ -0,0 +1,615 @@ +// SPDX-License-Identifier: MIT +pragma solidity 0.8.15; + +// Safe +import { GnosisSafe as Safe } from "safe-contracts/GnosisSafe.sol"; +import { Enum } from "safe-contracts/common/Enum.sol"; +import { Guard as IGuard } from "safe-contracts/base/GuardManager.sol"; + +// Libraries +import { EnumerableSet } from "@openzeppelin/contracts/utils/structs/EnumerableSet.sol"; +import { SemverComp } from "src/libraries/SemverComp.sol"; + +// Interfaces +import { ISemver } from "interfaces/universal/ISemver.sol"; + +/// @title TimelockGuard +/// @notice This guard provides timelock functionality for Safe transactions +/// @dev This is a singleton contract, any Safe on the network can use this guard to enforce a timelock delay, and +/// allow a subset of signers to cancel a transaction if they do not agree with the execution. This provides +/// significant security improvements over the Safe's default execution mechanism, which will allow any transaction +/// to be executed as long as it is fully signed, and with no mechanism for revealing the existence of said +/// signatures. +/// Usage: +/// In order to use this guard, the Safe must first enable it using Safe.setGuard(), and then configure it +/// by calling TimelockGuard.configureTimelockGuard(). +/// Scheduling and executing transactions: +/// Once enabled and configured, all transactions executed by the Safe's execTransaction() function will revert, +/// unless the transaction has first been scheduled by calling scheduleTransaction() on this contract. Because +/// scheduleTransaction() uses the Safe's own signature verification logic, the same signatures used +/// to execute a transaction can be used to schedule it. +/// Note: this guard does not apply a delay to transactions executed by modules which are installed on the Safe. +/// Cancelling transactions: +/// Once a transaction has been scheduled, so long as it has not already been executed, it can be +/// cancelled by calling cancelTransaction() on this contract. +/// This mechanism allows for a subset of signers to cancel a transaction if they do not agree with the execution. +/// As an 'anti-griefing' mechanism, the cancellation threshold (the number of signatures required to cancel a +/// transaction) starts at 1, and is automatically increased by 1 after each cancellation. +/// The cancellation threshold is reset to 1 after any transaction is executed successfully. +/// Safe Version Compatibility: +/// This guard is compatible with Safe versions 1.3.0 and higher. Earlier versions of the Safe do not expose +/// the checkSignatures or checkNSignatures functions required by this guard. +/// Threats Mitigated and Integration With LivenessModule: +/// This Guard is designed to protect against a number of well-defined scenarios, defined on +/// the two axes of amount of keys compromised, and type of compromise. +/// For scenarios where the keys compromised don't amount to a blocking threshold (the number of signers who must +/// refuse to sign a transaction in order to block it from being executed), regular transactions from the +/// multisig for removal or rotation is the preferred solution. +/// For scenarios where the keys compromised are at least a blocking threshold, but not as much as quorum, the +/// LivenessModule would be used. If there is a quorum of absent keys, but no significant malicious control, the +/// LivenessModule would also be used. +/// The TimelockGuard acts when there is malicious control of a quorum of keys. If the control is temporary, for +/// example by phishing a single set of signatures, then the TimelockGuard's cancellation is enough to stop the +/// attack entirely. If the malicious control would be permanent, then the TimelockGuard will buy some time to +/// execute remediations external to the compromised safe. +/// The following table summarizes the various scenarios and the course of action to take in each case. +/// +---------------------------------------------------------------------------+ +/// | Course of action when X Number of keys... | +/// +-------------------------------------------------------------------------------------------------+ +/// | | ... are Absent | ... are Maliciously Controlled | +/// | X Number of keys | (Honest signers cannot sign) | (Malicious signers can sign) | +/// +-------------------------------------------------------------------------------------------------+ +/// | 1+ | swapOwner | swapOwner | +/// +-------------------------------------------------------------------------------------------------+ +/// | Blocking Threshold+ | challenge + | challenge + | +/// | | changeOwnershipToFallback | changeOwnershipToFallback | +/// +-------------------------------------------------------------------------------------------------+ +/// | Quorum+ | challenge + | cancelTransaction | +/// | | changeOwnershipToFallback | | +/// +-------------------------------------------------------------------------------------------------+ +contract TimelockGuard is IGuard, ISemver { + using EnumerableSet for EnumerableSet.Bytes32Set; + + /// @notice Allowed states of a transaction + enum TransactionState { + NotScheduled, + Pending, + Cancelled, + Executed + } + + /// @notice Scheduled transaction + /// @custom:field executionTime The timestamp when execution becomes valid. + /// @custom:field state The state of the transaction. + /// @custom:field params The parameters of the transaction. + struct ScheduledTransaction { + uint256 executionTime; + TransactionState state; + ExecTransactionParams params; + } + + /// @notice Parameters for the Safe's execTransaction function + /// @custom:field to The address of the contract to call. + /// @custom:field value The value to send with the transaction. + /// @custom:field data The data to send with the transaction. + /// @custom:field operation The operation to perform with the transaction. + /// @custom:field safeTxGas The gas to use for the transaction. + /// @custom:field baseGas The base gas to use for the transaction. + /// @custom:field gasPrice The gas price to use for the transaction. + /// @custom:field gasToken The token to use for the transaction. + /// @custom:field refundReceiver The address to receive the refund for the transaction. + struct ExecTransactionParams { + address to; + uint256 value; + bytes data; + Enum.Operation operation; + uint256 safeTxGas; + uint256 baseGas; + uint256 gasPrice; + address gasToken; + address payable refundReceiver; + } + + /// @notice Aggregated state for each Safe using this guard. + /// @dev We have chosen for operational reasons to keep a list of pending transactions that can be easily retrieved + /// via a function call. This is done by maintaining a separate EnumerableSet with the hashes of pending + /// transactions. Transactions in the enumerable set need to be updated along with updates to the + /// ScheduledTransactions mapping. + struct SafeState { + uint256 timelockDelay; + uint256 cancellationThreshold; + mapping(bytes32 => ScheduledTransaction) scheduledTransactions; + EnumerableSet.Bytes32Set pendingTxHashes; + } + + /// @notice Mapping from Safe address to its timelock guard state. + mapping(Safe => SafeState) internal _safeState; + + /// @notice Semantic version. + /// @custom:semver 1.0.0 + string public constant version = "1.0.0"; + + /// @notice Error for when guard is not enabled for the Safe + error TimelockGuard_GuardNotEnabled(); + + /// @notice Error for when Safe is not configured for this guard + error TimelockGuard_GuardNotConfigured(); + + /// @notice Error for invalid timelock delay + error TimelockGuard_InvalidTimelockDelay(); + + /// @notice Error for when a transaction is already scheduled + error TimelockGuard_TransactionAlreadyScheduled(); + + /// @notice Error for when a transaction is already cancelled + error TimelockGuard_TransactionAlreadyCancelled(); + + /// @notice Error for when a transaction is not scheduled + error TimelockGuard_TransactionNotScheduled(); + + /// @notice Error for when a transaction is not ready to execute (timelock delay not passed) + error TimelockGuard_TransactionNotReady(); + + /// @notice Error for when a transaction has already been executed + error TimelockGuard_TransactionAlreadyExecuted(); + + /// @notice Error for when the contract is not at least version 1.3.0 + error TimelockGuard_InvalidVersion(); + + /// @notice Emitted when a Safe configures the guard + /// @param safe The Safe whose guard is configured. + /// @param timelockDelay The timelock delay in seconds. + event GuardConfigured(Safe indexed safe, uint256 timelockDelay); + + /// @notice Emitted when a transaction is scheduled for a Safe. + /// @param safe The Safe whose transaction is scheduled. + /// @param txHash The identifier of the scheduled transaction (nonce-independent). + /// @param executionTime The timestamp when execution becomes valid. + event TransactionScheduled(Safe indexed safe, bytes32 indexed txHash, uint256 executionTime); + + /// @notice Emitted when a transaction is cancelled for a Safe. + /// @param safe The Safe whose transaction is cancelled. + /// @param txHash The identifier of the cancelled transaction (nonce-independent). + event TransactionCancelled(Safe indexed safe, bytes32 indexed txHash); + + /// @notice Emitted when the cancellation threshold is updated + /// @param safe The Safe whose cancellation threshold is updated. + /// @param oldThreshold The old cancellation threshold. + /// @param newThreshold The new cancellation threshold. + event CancellationThresholdUpdated(Safe indexed safe, uint256 oldThreshold, uint256 newThreshold); + + /// @notice Emitted when a transaction is executed for a Safe. + /// @param safe The Safe whose transaction is executed. + /// @param txHash The identifier of the executed transaction (nonce-independent). + event TransactionExecuted(Safe indexed safe, bytes32 txHash); + + /// @notice Used to emit a message, primarily to ensure that the cancelTransaction function is + /// is not labelled as view so that it is treated as a state-changing function. + event Message(string message); + + //////////////////////////////////////////////////////////////// + // Internal View Functions // + //////////////////////////////////////////////////////////////// + + /// @notice Returns the blocking threshold, which is defined as the minimum number of owners that must coordinate to + /// block a transaction from being executed by refusing to sign. + /// @param _safe The Safe address to query + /// @return The current blocking threshold + function _blockingThreshold(Safe _safe) internal view returns (uint256) { + return _safe.getOwners().length - _safe.getThreshold() + 1; + } + + /// @notice Internal helper to get the guard address from a Safe + /// @param _safe The Safe address + /// @return The current guard address + function _isGuardEnabled(Safe _safe) internal view returns (bool) { + // keccak256("guard_manager.guard.address") from GuardManager + bytes32 guardSlot = 0x4a204f620c8c5ccdca3fd54d003badd85ba500436a431f0cbda4f558c93c34c8; + address guard = abi.decode(_safe.getStorageAt(uint256(guardSlot), 1), (address)); + return guard == address(this); + } + + //////////////////////////////////////////////////////////////// + // External View Functions // + //////////////////////////////////////////////////////////////// + + /// @notice Returns the cancellation threshold for a given safe + /// @param _safe The Safe address to query + /// @return The current cancellation threshold + function cancellationThreshold(Safe _safe) public view returns (uint256) { + // Return 0 if guard is not enabled + if (!_isGuardEnabled(_safe)) { + return 0; + } + + return _safeState[_safe].cancellationThreshold; + } + + /// @notice Returns the maximum cancellation threshold for a given safe + /// @dev The cancellation threshold must be capped in order to preserve the ability of honest users to cancel + /// malicious transactions. The rationale for the calculation of the maximum cancellation threshold is as + /// follows: + /// If the quorum is lower, then it is used as the maximum cancellation threshold, + /// so that even if an attacker has _joint control_ of a quorum of keys, the honest users can still + /// indefinitely cancel a malicious transaction. + /// If the blocking threshold is lower, then it is used as the maximum cancellation threshold, so that if an + /// attacker has less than a quorum of keys, honest users can still remove an attacker from the Safe by + /// refusing to respond to a malicious transaction. + /// @param _safe The Safe address to query + /// @return The maximum cancellation threshold + function maxCancellationThreshold(Safe _safe) public view returns (uint256) { + uint256 blockingThreshold = _blockingThreshold(_safe); + uint256 quorum = _safe.getThreshold(); + // Return the minimum of the blocking threshold and the quorum + return (blockingThreshold < quorum ? blockingThreshold : quorum); + } + + /// @notice Returns the timelock delay for a given Safe + /// @param _safe The Safe address to query + /// @return The timelock delay in seconds + function timelockConfiguration(Safe _safe) public view returns (uint256) { + return _safeState[_safe].timelockDelay; + } + + /// @notice Returns the scheduled transaction for a given Safe and tx hash + /// @dev This function is necessary to properly expose the scheduledTransactions mapping, as + /// simply making the mapping public will return a tuple instead of a struct. + function scheduledTransaction(Safe _safe, bytes32 _txHash) public view returns (ScheduledTransaction memory) { + return _safeState[_safe].scheduledTransactions[_txHash]; + } + + /// @notice Returns the list of all scheduled but not cancelled or executed transactions for + /// for a given safe + /// @dev WARNING: This operation will copy the entire set of pending transactions to memory, + /// which can be quite expensive. This is designed only to be used by view accessors that are + /// queried without any gas fees. Developers should keep in mind that this function has an + /// unbounded cost, and using it as part of a state-changing function may render the function + /// uncallable if the set grows to a point where copying to memory consumes too much gas to fit + /// in a block. + /// @return List of pending transaction hashes + function pendingTransactions(Safe _safe) external view returns (ScheduledTransaction[] memory) { + SafeState storage safeState = _safeState[_safe]; + + // Get the list of pending transaction hashes + bytes32[] memory hashes = safeState.pendingTxHashes.values(); + + // We want to provide the caller with the full parameters of each pending transaction, but mappings are not + // iterable, so we use the enumerable set of pending transaction hashes to retrieve the ScheduledTransaction + // struct for each hash, and then return an array of the ScheduledTransaction structs. + ScheduledTransaction[] memory scheduled = new ScheduledTransaction[](hashes.length); + for (uint256 i = 0; i < hashes.length; i++) { + scheduled[i] = safeState.scheduledTransactions[hashes[i]]; + } + return scheduled; + } + + //////////////////////////////////////////////////////////////// + // Guard Interface Functions // + //////////////////////////////////////////////////////////////// + + /// @notice Implementation of IGuard interface.Called by the Safe before executing a transaction + /// @dev This function is used to check that the transaction has been scheduled and is ready to execute. + /// It only reads the state of the contract, and potentially reverts in order to protect against execution of + /// unscheduled, early or cancelled transactions. + function checkTransaction( + address _to, + uint256 _value, + bytes memory _data, + Enum.Operation _operation, + uint256 _safeTxGas, + uint256 _baseGas, + uint256 _gasPrice, + address _gasToken, + address payable _refundReceiver, + bytes memory, /* signatures */ + address /* msgSender */ + ) + external + view + override + { + Safe callingSafe = Safe(payable(msg.sender)); + + if (_safeState[callingSafe].timelockDelay == 0) { + // We return immediately. This is important in order to allow a Safe which has the + // guard set, but not configured, to complete the setup process. + + // It is also just a reasonable thing to do, since an unconfigured Safe must have a + // delay of zero. + return; + } + + // Get the nonce of the Safe for the transaction being executed, + // since the Safe's nonce is incremented before the transaction is executed, + // we must subtract 1. + uint256 nonce = callingSafe.nonce() - 1; + + // Get the transaction hash from the Safe's getTransactionHash function + bytes32 txHash = callingSafe.getTransactionHash( + _to, _value, _data, _operation, _safeTxGas, _baseGas, _gasPrice, _gasToken, _refundReceiver, nonce + ); + + // Get the scheduled transaction + ScheduledTransaction storage scheduledTx = _safeState[callingSafe].scheduledTransactions[txHash]; + + // Check if the transaction was cancelled + if (scheduledTx.state == TransactionState.Cancelled) { + revert TimelockGuard_TransactionAlreadyCancelled(); + } + + // Check if the transaction has already been executed + // Note: this is of course enforced by the Safe itself, but we check it here for + // completeness + if (scheduledTx.state == TransactionState.Executed) { + revert TimelockGuard_TransactionAlreadyExecuted(); + } + + // Check if the transaction has been scheduled + if (scheduledTx.state == TransactionState.NotScheduled) { + revert TimelockGuard_TransactionNotScheduled(); + } + + // Check if the timelock delay has passed + if (scheduledTx.executionTime > block.timestamp) { + revert TimelockGuard_TransactionNotReady(); + } + } + + /// @notice Implementation of IGuard interface. Called by the Safe after executing a transaction + /// @dev This function is used to update the state of the contract after the transaction has been executed. + /// Although making state changes here is a violation of the Checks-Effects-Interactions pattern, it + /// safe to do in this case because we trust that the Safe does not enable arbitrary calls without + /// proper authorization checks. + function checkAfterExecution(bytes32 _txHash, bool _success) external override { + Safe callingSafe = Safe(payable(msg.sender)); + // If the timelock delay is zero, we return immediately. + // This is important in order to allow a Safe which has the guard set, but not configured, + // to complete the setup process. + // It is also just a reasonable thing to do, since an unconfigured Safe must have a delay of zero, and so + // we do not expect the transaction to have been scheduled. + if (_safeState[callingSafe].timelockDelay == 0) { + return; + } + + // If the transaction failed, then we return early and leave the transaction in its current state, + // which allows the transaction to be retried. + // This is consistent with the Safe's own behaviour, which does not increment the nonce if the + // call fails. + if (!_success) { + return; + } + + ScheduledTransaction storage scheduledTx = _safeState[callingSafe].scheduledTransactions[_txHash]; + + // Set the transaction as executed + scheduledTx.state = TransactionState.Executed; + _safeState[callingSafe].pendingTxHashes.remove(_txHash); + + // Reset the cancellation threshold + _resetCancellationThreshold(callingSafe); + + emit TransactionExecuted(callingSafe, _txHash); + } + + //////////////////////////////////////////////////////////////// + // Internal State-Changing Functions // + //////////////////////////////////////////////////////////////// + + /// @notice Increase the cancellation threshold for a safe + /// @dev This function must be called only once and only when calling cancel + /// @param _safe The Safe address to increase the cancellation threshold for. + function _increaseCancellationThreshold(Safe _safe) internal { + SafeState storage safeState = _safeState[_safe]; + + if (safeState.cancellationThreshold < maxCancellationThreshold(_safe)) { + uint256 oldThreshold = safeState.cancellationThreshold; + safeState.cancellationThreshold++; + emit CancellationThresholdUpdated(_safe, oldThreshold, safeState.cancellationThreshold); + } + } + + /// @notice Reset the cancellation threshold for a safe + /// @dev This function must be called only once and only when calling checkAfterExecution + /// @param _safe The Safe address to reset the cancellation threshold for. + function _resetCancellationThreshold(Safe _safe) internal { + SafeState storage safeState = _safeState[_safe]; + uint256 oldThreshold = safeState.cancellationThreshold; + safeState.cancellationThreshold = 1; + emit CancellationThresholdUpdated(_safe, oldThreshold, 1); + } + + //////////////////////////////////////////////////////////////// + // External State-Changing Functions // + //////////////////////////////////////////////////////////////// + + /// @notice Configure the contract as a timelock guard by setting the timelock delay + /// @dev This function is only callable by the Safe itself. + /// Requiring a call from the Safe itself (rather than accepting signatures directly as in cancelTransaction()) + /// is important to ensure that maliciously gathered signatures will not be able to instantly reconfigure + /// the delay to zero. This function does not check that the guard is enabled on the Safe, the recommended + /// approach is to atomically enable the guard and configure the delay in a single batched transaction. + /// @param _timelockDelay The timelock delay in seconds (0 to clear configuration) + function configureTimelockGuard(uint256 _timelockDelay) external { + // Record the calling Safe + Safe callingSafe = Safe(payable(msg.sender)); + + // Check that the contract is at least version 1.3.0 + // Prior to version 1.3.0, checkSignatures() was not exposed as a public function, so we need to check the + // version otherwise the safe will be bricked. + if (SemverComp.lt(callingSafe.VERSION(), "1.3.0")) { + revert TimelockGuard_InvalidVersion(); + } + + // Validate timelock delay - must not be longer than 1 year + if (_timelockDelay > 365 days) { + revert TimelockGuard_InvalidTimelockDelay(); + } + + // Store the timelock delay for this safe + _safeState[callingSafe].timelockDelay = _timelockDelay; + + // Initialize (or reset) the cancellation threshold to 1. + _resetCancellationThreshold(callingSafe); + emit GuardConfigured(callingSafe, _timelockDelay); + } + + /// @notice Schedule a transaction for execution after the timelock delay. + /// @dev This function validates signatures in the exact same way as the Safe's own execTransaction function, + /// meaning that the same signatures used to schedule a transaction can be used to execute it later. This + /// maintains compatibility with existing signature generation tools. Owners can use any method to sign the + /// a transaction, including signing with a private key, calling the Safe's approveHash function, or EIP1271 + /// contract signatures. + /// @param _safe The Safe address to schedule the transaction for. + /// @param _nonce The nonce of the Safe for the transaction being scheduled. + /// @param _params The parameters of the transaction being scheduled. + /// @param _signatures The signatures of the owners who are scheduling the transaction. + function scheduleTransaction( + Safe _safe, + uint256 _nonce, + ExecTransactionParams memory _params, + bytes memory _signatures + ) + external + { + // Check that this guard is enabled on the calling Safe + if (!_isGuardEnabled(_safe)) { + revert TimelockGuard_GuardNotEnabled(); + } + + // Check that the guard has been configured for the Safe + if (_safeState[_safe].timelockDelay == 0) { + revert TimelockGuard_GuardNotConfigured(); + } + + // Get the encoded transaction data as defined in the Safe + // The format of the string returned is: "0x1901{domainSeparator}{safeTxHash}" + bytes memory txHashData = _safe.encodeTransactionData( + _params.to, + _params.value, + _params.data, + _params.operation, + _params.safeTxGas, + _params.baseGas, + _params.gasPrice, + _params.gasToken, + _params.refundReceiver, + _nonce + ); + + // Get the transaction hash and data as defined in the Safe + // This value is identical to keccak256(txHashData), but we prefer to use the Safe's own + // internal logic as it is more future-proof in case future versions of the Safe change + // the transaction hash derivation. + bytes32 txHash = _safe.getTransactionHash( + _params.to, + _params.value, + _params.data, + _params.operation, + _params.safeTxGas, + _params.baseGas, + _params.gasPrice, + _params.gasToken, + _params.refundReceiver, + _nonce + ); + + // Check if the transaction exists + // A transaction can only be scheduled once, regardless of whether it has been cancelled or not, + // as otherwise an observer could reuse the same signatures to either: + // 1. Reschedule a transaction after it has been cancelled + // 2. Reschedule a pending transaction, which would update the execution time thus extending the delay + // for the original transaction. + if (_safeState[_safe].scheduledTransactions[txHash].executionTime != 0) { + revert TimelockGuard_TransactionAlreadyScheduled(); + } + + // Verify signatures using the Safe's signature checking logic + // This function call reverts if the signatures are invalid. + _safe.checkSignatures(txHash, txHashData, _signatures); + + // Calculate the execution time + uint256 executionTime = block.timestamp + _safeState[_safe].timelockDelay; + + // Schedule the transaction and add it to the pending transactions set + _safeState[_safe].scheduledTransactions[txHash] = + ScheduledTransaction({ executionTime: executionTime, state: TransactionState.Pending, params: _params }); + _safeState[_safe].pendingTxHashes.add(txHash); + + emit TransactionScheduled(_safe, txHash, executionTime); + } + + /// @notice Cancel a scheduled transaction if cancellation threshold is met + /// @dev This function aims to mimic the approach which would be used by a quorum of signers to + /// cancel a partially signed transaction, by signing and executing an empty + /// transaction at the same nonce. + /// This enables us to define a standard "cancellation transaction" format using the Safe address, nonce, + /// and hash of the transaction being cancelled. This is necessary to ensure that the cancellation transaction + /// is unique and cannot be used to cancel another transaction at the same nonce. + /// + /// Signature verification uses the Safe's checkNSignatures function, so that the number of signatures + /// can be set by the Safe's current cancellation threshold. Another benefit of checkNSignatures is that owners + /// can use any method to sign the cancellation transaction inputs, including signing with a private key, + /// calling the Safe's approveHash function, or EIP1271 contract signatures. + /// @param _safe The Safe address to cancel the transaction for. + /// @param _txHash The hash of the transaction being cancelled. + /// @param _nonce The nonce of the Safe for the transaction being cancelled. + /// @param _signatures The signatures of the owners who are cancelling the transaction. + function cancelTransaction(Safe _safe, bytes32 _txHash, uint256 _nonce, bytes memory _signatures) external { + // The following checks ensure that the transaction has: + // 1. Been scheduled + // 2. Not already been cancelled + // 3. Not already been executed + // There is nothing inherently wrong with cancelling a transaction a transaction that doesn't meet these + // criteria, but we revert in order to inform the user, and avoid emitting a misleading TransactionCancelled + // event. + if (_safeState[_safe].scheduledTransactions[_txHash].state == TransactionState.Cancelled) { + revert TimelockGuard_TransactionAlreadyCancelled(); + } + if (_safeState[_safe].scheduledTransactions[_txHash].state == TransactionState.Executed) { + revert TimelockGuard_TransactionAlreadyExecuted(); + } + if (_safeState[_safe].scheduledTransactions[_txHash].state == TransactionState.NotScheduled) { + revert TimelockGuard_TransactionNotScheduled(); + } + + // Generate the cancellation transaction data + bytes memory txData = abi.encodeCall(this.signCancellation, (_txHash)); + // Any nonce can be used here, as long as all of the signatures are for the same + // nonce. In practice we expect the nonce to be the same as the nonce of the transaction + // being cancelled, as this most closely mimics the behaviour of the Safe UI's transaction + // replacement feature. However we do not enforce that here, to allow for flexibility, + // and to avoid the need for logic to retrieve the nonce from the transaction being + // cancelled. + bytes memory cancellationTxData = _safe.encodeTransactionData( + address(this), 0, txData, Enum.Operation.Call, 0, 0, 0, address(0), address(0), _nonce + ); + bytes32 cancellationTxHash = _safe.getTransactionHash( + address(this), 0, txData, Enum.Operation.Call, 0, 0, 0, address(0), address(0), _nonce + ); + + // Verify signatures using the Safe's signature checking logic, with the cancellation threshold as + // the number of signatures required. + _safe.checkNSignatures( + cancellationTxHash, cancellationTxData, _signatures, _safeState[_safe].cancellationThreshold + ); + + // Set the transaction as cancelled, and remove it from the pending transactions set + _safeState[_safe].scheduledTransactions[_txHash].state = TransactionState.Cancelled; + _safeState[_safe].pendingTxHashes.remove(_txHash); + + // Increase the cancellation threshold + _increaseCancellationThreshold(_safe); + + emit TransactionCancelled(_safe, _txHash); + } + + //////////////////////////////////////////////////////////////// + // Dummy Functions // + //////////////////////////////////////////////////////////////// + + /// @notice Dummy function provided as a utility to facilitate signing cancelTransaction data in + /// the Safe UI. + function signCancellation(bytes32) public { + emit Message("This function is not meant to be called, did you mean to call cancelTransaction?"); + } +} diff --git a/packages/contracts-bedrock/test/safe/TimelockGuard.t.sol b/packages/contracts-bedrock/test/safe/TimelockGuard.t.sol new file mode 100644 index 00000000000..88e12657997 --- /dev/null +++ b/packages/contracts-bedrock/test/safe/TimelockGuard.t.sol @@ -0,0 +1,879 @@ +// SPDX-License-Identifier: MIT +pragma solidity 0.8.15; + +import { Test } from "forge-std/Test.sol"; +import { GnosisSafe as Safe } from "safe-contracts/GnosisSafe.sol"; +import { GuardManager } from "safe-contracts/base/GuardManager.sol"; +import "test/safe-tools/SafeTestTools.sol"; + +import { TimelockGuard } from "src/safe/TimelockGuard.sol"; + +using TransactionBuilder for TransactionBuilder.Transaction; + +/// @title TransactionBuilder +/// @notice Facilitates the construction of transactions and signatures, and provides helper methods +/// for scheduling, executing, and cancelling transactions. +library TransactionBuilder { + // A struct type used to construct a transaction for scheduling and execution + struct Transaction { + SafeInstance safeInstance; + TimelockGuard.ExecTransactionParams params; + uint256 nonce; + bytes32 hash; + bytes signatures; + } + + address internal constant VM_ADDR = 0x7109709ECfa91a80626fF3989D68f67F5b1DD12D; + + /// @notice Sets a nonce value on the provided transaction struct. + function setNonce(Transaction memory _tx, uint256 _nonce) internal pure { + _tx.nonce = _nonce; + } + + /// @notice Computes and stores the Safe transaction hash for the struct. + function setHash(Transaction memory _tx) internal view { + _tx.hash = _tx.safeInstance.safe.getTransactionHash({ + to: _tx.params.to, + value: _tx.params.value, + data: _tx.params.data, + operation: _tx.params.operation, + safeTxGas: _tx.params.safeTxGas, + baseGas: _tx.params.baseGas, + gasPrice: _tx.params.gasPrice, + gasToken: _tx.params.gasToken, + refundReceiver: _tx.params.refundReceiver, + _nonce: _tx.nonce + }); + } + + /// @notice Collects signatures from the first `_num` owners for the transaction. + function setSignatures(Transaction memory _tx, uint256 _num) internal pure { + bytes memory signatures = new bytes(0); + for (uint256 i; i < _num; ++i) { + (uint8 v, bytes32 r, bytes32 s) = Vm(VM_ADDR).sign(_tx.safeInstance.ownerPKs[i], _tx.hash); + + // The signature format is a compact form of: {bytes32 r}{bytes32 s}{uint8 v} + signatures = bytes.concat(signatures, abi.encodePacked(r, s, v)); + } + _tx.signatures = signatures; + } + + /// @notice Collects enough signatures to meet the Safe threshold. + function setSignatures(Transaction memory _tx) internal view { + uint256 num = _tx.safeInstance.safe.getThreshold(); + setSignatures(_tx, num); + } + + /// @notice Updates the hash and signatures for a specific approval count. + function updateTransaction(Transaction memory _tx, uint256 _num) internal view { + _tx.setHash(); + _tx.setSignatures(_num); + } + + /// @notice Updates the hash and threshold-based signatures on the transaction. + function updateTransaction(Transaction memory _tx) internal view { + _tx.setHash(); + _tx.setSignatures(); + } + + /// @notice Schedules the transaction with the supplied TimelockGuard instance. + function scheduleTransaction(Transaction memory _tx, TimelockGuard _timelockGuard) internal { + _timelockGuard.scheduleTransaction(_tx.safeInstance.safe, _tx.nonce, _tx.params, _tx.signatures); + } + + /// @notice Executes the transaction via the underlying Safe contract. + function executeTransaction(Transaction memory _tx) internal { + _tx.safeInstance.safe.execTransaction( + _tx.params.to, + _tx.params.value, + _tx.params.data, + _tx.params.operation, + _tx.params.safeTxGas, + _tx.params.baseGas, + _tx.params.gasPrice, + _tx.params.gasToken, + _tx.params.refundReceiver, + _tx.signatures + ); + } + + /// @notice Returns a fresh transaction struct copy with identical fields. + function deepCopy(Transaction memory _tx) internal pure returns (Transaction memory) { + return Transaction({ + safeInstance: _tx.safeInstance, + nonce: _tx.nonce, + params: _tx.params, + signatures: _tx.signatures, + hash: _tx.hash + }); + } + + /// @notice Builds the corresponding cancellation transaction for the provided data. + function makeCancellationTransaction( + Transaction memory _tx, + TimelockGuard _timelockGuard + ) + internal + view + returns (Transaction memory) + { + // Deep copy the transaction + Transaction memory cancellation = Transaction({ + safeInstance: _tx.safeInstance, + nonce: _tx.nonce, + params: _tx.params, + signatures: _tx.signatures, + hash: _tx.hash + }); + + // Empty out the params, then set based on the cancellation transaction format + delete cancellation.params; + cancellation.params.to = address(_timelockGuard); + cancellation.params.data = abi.encodeCall(TimelockGuard.signCancellation, (_tx.hash)); + + // Get only the number of signatures required for the cancellation transaction + uint256 cancellationThreshold = _timelockGuard.cancellationThreshold(_tx.safeInstance.safe); + + cancellation.updateTransaction(cancellationThreshold); + return cancellation; + } +} + +/// @title TimelockGuard_TestInit +/// @notice Reusable test initialization for `TimelockGuard` tests. +contract TimelockGuard_TestInit is Test, SafeTestTools { + // Events + event GuardConfigured(Safe indexed safe, uint256 timelockDelay); + event TransactionScheduled(Safe indexed safe, bytes32 indexed txId, uint256 when); + event TransactionCancelled(Safe indexed safe, bytes32 indexed txId); + event CancellationThresholdUpdated(Safe indexed safe, uint256 oldThreshold, uint256 newThreshold); + event TransactionExecuted(Safe indexed safe, bytes32 txHash); + event Message(string message); + + uint256 constant INIT_TIME = 10; + uint256 constant TIMELOCK_DELAY = 7 days; + uint256 constant NUM_OWNERS = 5; + uint256 constant THRESHOLD = 3; + uint256 constant ONE_YEAR = 365 days; + + TimelockGuard timelockGuard; + + // The Safe address will be the same as SafeInstance.safe, but it has the Safe type. + // This is useful for testing functions that take a Safe as an argument. + Safe safe; + SafeInstance safeInstance; + + SafeInstance unguardedSafe; + + /// @notice Deploys test fixtures and configures default Safe instances. + function setUp() public virtual { + vm.warp(INIT_TIME); + + // Deploy the singleton TimelockGuard + timelockGuard = new TimelockGuard(); + // Set up Safe with owners + safeInstance = _deploySafe("owners", NUM_OWNERS, THRESHOLD); + safe = Safe(payable(safeInstance.safe)); + + // Safe without guard enabled + unguardedSafe = _deploySafe("owners-unguarded", NUM_OWNERS, THRESHOLD); + + // Enable the guard on the Safe + _enableGuard(safeInstance); + } + + /// @notice Deploys a Safe with the given owners and threshold + function _deploySafe( + string memory _prefix, + uint256 _numOwners, + uint256 _threshold + ) + internal + returns (SafeInstance memory) + { + (, uint256[] memory keys) = SafeTestLib.makeAddrsAndKeys(_prefix, _numOwners); + return _setupSafe(keys, _threshold); + } + + /// @notice Builds an empty transaction wrapper for a Safe instance. + function _createEmptyTransaction(SafeInstance memory _safeInstance) + internal + view + returns (TransactionBuilder.Transaction memory) + { + TransactionBuilder.Transaction memory transaction; + // transaction.params will have null values + transaction.safeInstance = _safeInstance; + transaction.nonce = _safeInstance.safe.nonce(); + transaction.updateTransaction(); + return transaction; + } + + /// @notice Creates a dummy transaction populated with placeholder call data. + function _createDummyTransaction(SafeInstance memory _safeInstance) + internal + view + returns (TransactionBuilder.Transaction memory) + { + TransactionBuilder.Transaction memory transaction = _createEmptyTransaction(_safeInstance); + transaction.params.to = address(0xabba); + transaction.params.data = hex"acdc"; + transaction.updateTransaction(); + return transaction; + } + + /// @notice Helper to configure the TimelockGuard for a Safe + function _configureGuard(SafeInstance memory _safe, uint256 _delay) internal { + SafeTestLib.execTransaction( + _safe, address(timelockGuard), 0, abi.encodeCall(TimelockGuard.configureTimelockGuard, (_delay)) + ); + } + + /// @notice Helper to enable guard on a Safe + function _enableGuard(SafeInstance memory _safe) internal { + SafeTestLib.execTransaction( + _safe, address(_safe.safe), 0, abi.encodeCall(GuardManager.setGuard, (address(timelockGuard))) + ); + } +} + +/// @title TimelockGuard_TimelockConfiguration_Test +/// @notice Tests for timelockConfiguration function +contract TimelockGuard_TimelockConfiguration_Test is TimelockGuard_TestInit { + /// @notice Ensures an unconfigured Safe reports a zero timelock delay. + function test_timelockConfiguration_returnsZeroForUnconfiguredSafe_succeeds() external view { + uint256 delay = timelockGuard.timelockConfiguration(safeInstance.safe); + assertEq(delay, 0); + // configured is now determined by timelockDelay == 0 + assertEq(delay == 0, true); + } + + /// @notice Validates the configuration view reflects the stored timelock delay. + function test_timelockConfiguration_returnsConfigurationForConfiguredSafe_succeeds() external { + _configureGuard(safeInstance, TIMELOCK_DELAY); + uint256 delay = timelockGuard.timelockConfiguration(safeInstance.safe); + assertEq(delay, TIMELOCK_DELAY); + // configured is now determined by timelockDelay != 0 + assertEq(delay != 0, true); + } +} + +/// @title TimelockGuard_ConfigureTimelockGuard_Test +/// @notice Tests for configureTimelockGuard function +contract TimelockGuard_ConfigureTimelockGuard_Test is TimelockGuard_TestInit { + /// @notice Verifies the guard can be configured with a standard delay. + function test_configureTimelockGuard_succeeds() external { + vm.expectEmit(true, true, true, true); + emit GuardConfigured(safe, TIMELOCK_DELAY); + + _configureGuard(safeInstance, TIMELOCK_DELAY); + + uint256 delay = timelockGuard.timelockConfiguration(safe); + assertEq(delay, TIMELOCK_DELAY); + // configured is now determined by timelockDelay != 0 + assertEq(delay != 0, true); + } + + /// @notice Confirms delays above the maximum revert during configuration. + function test_configureTimelockGuard_revertsIfDelayTooLong_reverts() external { + uint256 tooLongDelay = ONE_YEAR + 1; + + vm.expectRevert(TimelockGuard.TimelockGuard_InvalidTimelockDelay.selector); + vm.prank(address(safeInstance.safe)); + timelockGuard.configureTimelockGuard(tooLongDelay); + } + + /// @notice Checks configuration reverts when the contract is too old. + function test_configureTimelockGuard_revertsIfVersionTooOld_reverts() external { + // nosemgrep: sol-style-use-abi-encodecall + vm.mockCall(address(safeInstance.safe), abi.encodeWithSignature("VERSION()"), abi.encode("1.2.0")); + vm.expectRevert(TimelockGuard.TimelockGuard_InvalidVersion.selector, address(timelockGuard)); + vm.prank(address(safeInstance.safe)); + timelockGuard.configureTimelockGuard(TIMELOCK_DELAY); + } + + /// @notice Asserts the maximum valid delay configures successfully. + function test_configureTimelockGuard_acceptsMaxValidDelay_succeeds() external { + vm.expectEmit(true, true, true, true); + emit GuardConfigured(safe, ONE_YEAR); + + _configureGuard(safeInstance, ONE_YEAR); + + uint256 delay = timelockGuard.timelockConfiguration(safe); + assertEq(delay, ONE_YEAR); + // configured is now determined by timelockDelay != 0 + assertEq(delay != 0, true); + } + + /// @notice Demonstrates the guard can be reconfigured to a new delay. + function test_configureTimelockGuard_allowsReconfiguration_succeeds() external { + // Initial configuration + _configureGuard(safeInstance, TIMELOCK_DELAY); + assertEq(timelockGuard.timelockConfiguration(safe), TIMELOCK_DELAY); + + uint256 newDelay = TIMELOCK_DELAY + 1; + + // Setup and schedule the reconfiguration transaction + TransactionBuilder.Transaction memory reconfigureGuardTx = _createEmptyTransaction(safeInstance); + reconfigureGuardTx.params.to = address(timelockGuard); + reconfigureGuardTx.params.data = abi.encodeCall(TimelockGuard.configureTimelockGuard, (newDelay)); + reconfigureGuardTx.updateTransaction(); + reconfigureGuardTx.scheduleTransaction(timelockGuard); + + vm.warp(block.timestamp + TIMELOCK_DELAY); + + // Reconfigure with different delay + vm.expectEmit(true, true, true, true); + emit GuardConfigured(safe, newDelay); + + _configureGuard(safeInstance, newDelay); + assertEq(timelockGuard.timelockConfiguration(safe), newDelay); + } + + /// @notice Ensures setting delay to zero clears the configuration. + function test_configureTimelockGuard_clearConfiguration_succeeds() external { + // First configure the guard + _configureGuard(safeInstance, TIMELOCK_DELAY); + assertEq(timelockGuard.timelockConfiguration(safe), TIMELOCK_DELAY); + + // Configure timelock delay to 0 should succeed and emit event + vm.expectEmit(true, true, true, true); + emit GuardConfigured(safe, 0); + vm.prank(address(safeInstance.safe)); + timelockGuard.configureTimelockGuard(0); + + // Timelock delay should be set to 0 + assertEq(timelockGuard.timelockConfiguration(safe), 0); + } + + /// @notice Checks clearing succeeds even if the guard was never configured. + function test_configureTimelockGuard_notConfigured_succeeds() external { + // Try to clear - should succeed even if not yet configured + vm.expectEmit(true, true, true, true); + emit GuardConfigured(safe, 0); + vm.prank(address(safeInstance.safe)); + timelockGuard.configureTimelockGuard(0); + } +} + +/// @title TimelockGuard_CancellationThreshold_Test +/// @notice Tests for cancellationThreshold function +contract TimelockGuard_CancellationThreshold_Test is TimelockGuard_TestInit { + /// @notice Validates cancellation threshold is zero when the guard is disabled. + function test_cancellationThreshold_returnsZeroIfGuardNotEnabled_succeeds() external view { + uint256 threshold = timelockGuard.cancellationThreshold(Safe(payable(unguardedSafe.safe))); + assertEq(threshold, 0); + } + + /// @notice Ensures an enabled but unconfigured guard yields a zero threshold. + function test_cancellationThreshold_returnsZeroIfGuardNotConfigured_succeeds() external view { + // Safe with guard enabled but not configured should return 0 + uint256 threshold = timelockGuard.cancellationThreshold(safe); + assertEq(threshold, 0); + } + + /// @notice Confirms the default threshold becomes one after configuration. + function test_cancellationThreshold_returnsOneAfterConfiguration_succeeds() external { + // Configure the guard + _configureGuard(safeInstance, TIMELOCK_DELAY); + + // Should default to 1 after configuration + uint256 threshold = timelockGuard.cancellationThreshold(safe); + assertEq(threshold, 1); + } + + // Note: Testing increment/decrement behavior will require scheduleTransaction, + // cancelTransaction and execution functions to be implemented first +} + +/// @title TimelockGuard_ScheduleTransaction_Test +/// @notice Tests for scheduleTransaction function +contract TimelockGuard_ScheduleTransaction_Test is TimelockGuard_TestInit { + /// @notice Configures the guard before each scheduleTransaction test. + function setUp() public override { + super.setUp(); + _configureGuard(safeInstance, TIMELOCK_DELAY); + } + + /// @notice Ensures scheduling emits the expected event and stores state. + function test_scheduleTransaction_succeeds() public { + TransactionBuilder.Transaction memory dummyTx = _createDummyTransaction(safeInstance); + + vm.expectEmit(true, true, true, true); + emit TransactionScheduled(safe, dummyTx.hash, INIT_TIME + TIMELOCK_DELAY); + dummyTx.scheduleTransaction(timelockGuard); + } + + // A test which demonstrates that if the guard is enabled but not explicitly configured, + // the timelock delay is set to 0. + /// @notice Checks scheduling reverts if the guard lacks configuration. + function test_scheduleTransaction_guardNotConfigured_reverts() external { + // Enable the guard on the unguarded Safe, but don't configure it + _enableGuard(unguardedSafe); + assertEq(timelockGuard.timelockConfiguration(unguardedSafe.safe), 0); + + TransactionBuilder.Transaction memory dummyTx = _createDummyTransaction(unguardedSafe); + vm.expectRevert(TimelockGuard.TimelockGuard_GuardNotConfigured.selector); + dummyTx.scheduleTransaction(timelockGuard); + } + + /// @notice Verifies rescheduling an identical pending transaction reverts. + function test_scheduleTransaction_reschedulingIdenticalTransaction_reverts() external { + TransactionBuilder.Transaction memory dummyTx = _createDummyTransaction(safeInstance); + + timelockGuard.scheduleTransaction(safeInstance.safe, dummyTx.nonce, dummyTx.params, dummyTx.signatures); + + vm.expectRevert(TimelockGuard.TimelockGuard_TransactionAlreadyScheduled.selector); + timelockGuard.scheduleTransaction(dummyTx.safeInstance.safe, dummyTx.nonce, dummyTx.params, dummyTx.signatures); + } + + /// @notice Confirms scheduling fails when the guard has not been enabled. + function test_scheduleTransaction_guardNotEnabled_reverts() external { + // Attempt to schedule a transaction with a Safe that has enabled the guard but + // has not configured it. + _enableGuard(unguardedSafe); + TransactionBuilder.Transaction memory dummyTx = _createDummyTransaction(unguardedSafe); + + vm.expectRevert(TimelockGuard.TimelockGuard_GuardNotConfigured.selector); + dummyTx.scheduleTransaction(timelockGuard); + } + + /// @notice Demonstrates identical payloads can be scheduled with distinct nonces. + function test_scheduleTransaction_canScheduleIdenticalWithDifferentNonce_succeeds() external { + // Schedule a transaction with a specific nonce + TransactionBuilder.Transaction memory dummyTx = _createDummyTransaction(safeInstance); + dummyTx.scheduleTransaction(timelockGuard); + + // Schedule an identical transaction with a different nonce (salt) + TransactionBuilder.Transaction memory newTx = dummyTx.deepCopy(); + newTx.nonce = dummyTx.nonce + 1; + newTx.updateTransaction(); + + vm.expectEmit(true, true, true, true); + emit TransactionScheduled(safe, newTx.hash, INIT_TIME + TIMELOCK_DELAY); + timelockGuard.scheduleTransaction(safeInstance.safe, newTx.nonce, newTx.params, newTx.signatures); + } +} + +/// @title TimelockGuard_ScheduledTransaction_Test +/// @notice Tests for scheduledTransaction function +contract TimelockGuard_ScheduledTransaction_Test is TimelockGuard_TestInit { + /// @notice Configures the guard before each scheduleTransaction test. + function setUp() public override { + super.setUp(); + _configureGuard(safeInstance, TIMELOCK_DELAY); + } + + function test_scheduledTransaction_succeeds() external { + // schedule a transaction + TransactionBuilder.Transaction memory dummyTx = _createDummyTransaction(safeInstance); + dummyTx.scheduleTransaction(timelockGuard); + + TimelockGuard.ScheduledTransaction memory scheduledTransaction = + timelockGuard.scheduledTransaction(safe, dummyTx.hash); + assertEq(scheduledTransaction.executionTime, INIT_TIME + TIMELOCK_DELAY); + assert(scheduledTransaction.state == TimelockGuard.TransactionState.Pending); + assertEq(keccak256(abi.encode(scheduledTransaction.params)), keccak256(abi.encode(dummyTx.params))); + } +} + +/// @title TimelockGuard_PendingTransactions_Test +/// @notice Tests for pendingTransactions function +contract TimelockGuard_PendingTransactions_Test is TimelockGuard_TestInit { + function setUp() public override { + super.setUp(); + _configureGuard(safeInstance, TIMELOCK_DELAY); + } + + function test_pendingTransactions_succeeds() external { + // schedule a transaction + TransactionBuilder.Transaction memory dummyTx = _createDummyTransaction(safeInstance); + dummyTx.scheduleTransaction(timelockGuard); + + TimelockGuard.ScheduledTransaction[] memory pendingTransactions = timelockGuard.pendingTransactions(safe); + assertEq(pendingTransactions.length, 1); + // ensure the hash of the transaction params are the same + assertEq(pendingTransactions[0].params.to, dummyTx.params.to); + assertEq(keccak256(abi.encode(pendingTransactions[0].params)), keccak256(abi.encode(dummyTx.params))); + } + + function test_pendingTransactions_removeTransactionAfterCancellation_succeeds() external { + // schedule a transaction + TransactionBuilder.Transaction memory dummyTx = _createDummyTransaction(safeInstance); + dummyTx.scheduleTransaction(timelockGuard); + + // cancel the transaction + TransactionBuilder.Transaction memory cancellationTx = dummyTx.makeCancellationTransaction(timelockGuard); + timelockGuard.cancelTransaction(safeInstance.safe, dummyTx.hash, dummyTx.nonce, cancellationTx.signatures); + + // get the pending transactions + TimelockGuard.ScheduledTransaction[] memory pendingTransactions = timelockGuard.pendingTransactions(safe); + assertEq(pendingTransactions.length, 0); + } + + function test_pendingTransactions_removeTransactionAfterExecution_succeeds() external { + // schedule a transaction + TransactionBuilder.Transaction memory dummyTx = _createDummyTransaction(safeInstance); + dummyTx.scheduleTransaction(timelockGuard); + + vm.warp(block.timestamp + TIMELOCK_DELAY); + + // execute the transaction + dummyTx.executeTransaction(); + + // get the pending transactions + TimelockGuard.ScheduledTransaction[] memory pendingTransactions = timelockGuard.pendingTransactions(safe); + assertEq(pendingTransactions.length, 0); + } +} + +/// @title TimelockGuard_signCancellation_Test +/// @notice Tests for signCancellation function +contract TimelockGuard_signCancellation_Test is TimelockGuard_TestInit { + function test_signCancellation_succeeds() external { + vm.expectEmit(true, true, true, true); + emit Message("This function is not meant to be called, did you mean to call cancelTransaction?"); + timelockGuard.signCancellation(bytes32(0)); + } +} + +contract TimelockGuard_CancelTransaction_Test is TimelockGuard_TestInit { + /// @notice Prepares a configured guard before cancellation tests run. + function setUp() public override { + super.setUp(); + + // Configure the guard and schedule a transaction + _configureGuard(safeInstance, TIMELOCK_DELAY); + } + + /// @notice Ensures cancellations succeed using owner signatures. + function test_cancelTransaction_withPrivKeySignature_succeeds() external { + TransactionBuilder.Transaction memory dummyTx = _createDummyTransaction(safeInstance); + dummyTx.scheduleTransaction(timelockGuard); + + // Get the cancellation transaction + TransactionBuilder.Transaction memory cancellationTx = dummyTx.makeCancellationTransaction(timelockGuard); + uint256 cancellationThreshold = timelockGuard.cancellationThreshold(dummyTx.safeInstance.safe); + + // Cancel the transaction + vm.expectEmit(true, true, true, true); + emit CancellationThresholdUpdated(safeInstance.safe, cancellationThreshold, cancellationThreshold + 1); + vm.expectEmit(true, true, true, true); + emit TransactionCancelled(safeInstance.safe, dummyTx.hash); + timelockGuard.cancelTransaction(safeInstance.safe, dummyTx.hash, dummyTx.nonce, cancellationTx.signatures); + + assert( + timelockGuard.scheduledTransaction(safeInstance.safe, dummyTx.hash).state + == TimelockGuard.TransactionState.Cancelled + ); + } + + /// @notice Confirms pre-approved hashes can authorise cancellations. + function test_cancelTransaction_withApproveHash_succeeds() external { + TransactionBuilder.Transaction memory dummyTx = _createDummyTransaction(safeInstance); + dummyTx.scheduleTransaction(timelockGuard); + + // Get the cancellation transaction hash + TransactionBuilder.Transaction memory cancellationTx = dummyTx.makeCancellationTransaction(timelockGuard); + + // Get the owner + address owner = dummyTx.safeInstance.safe.getOwners()[0]; + + // Approve the cancellation transaction hash + vm.prank(owner); + safeInstance.safe.approveHash(cancellationTx.hash); + + // Encode the prevalidated cancellation signature + bytes memory cancellationSignatures = abi.encodePacked(bytes32(uint256(uint160(owner))), bytes32(0), uint8(1)); + + // Get the cancellation threshold + uint256 cancellationThreshold = timelockGuard.cancellationThreshold(dummyTx.safeInstance.safe); + + // Cancel the transaction + vm.expectEmit(true, true, true, true); + emit CancellationThresholdUpdated(dummyTx.safeInstance.safe, cancellationThreshold, cancellationThreshold + 1); + vm.expectEmit(true, true, true, true); + emit TransactionCancelled(dummyTx.safeInstance.safe, dummyTx.hash); + timelockGuard.cancelTransaction(dummyTx.safeInstance.safe, dummyTx.hash, dummyTx.nonce, cancellationSignatures); + + // Confirm that the transaction is cancelled + TimelockGuard.ScheduledTransaction memory scheduledTransaction = + timelockGuard.scheduledTransaction(dummyTx.safeInstance.safe, dummyTx.hash); + assert(scheduledTransaction.state == TimelockGuard.TransactionState.Cancelled); + } + + /// @notice Verifies cancelling an unscheduled transaction reverts. + function test_cancelTransaction_revertsIfTransactionNotScheduled_reverts() external { + TransactionBuilder.Transaction memory dummyTx = _createDummyTransaction(safeInstance); + TransactionBuilder.Transaction memory cancellationTx = dummyTx.makeCancellationTransaction(timelockGuard); + + // Attempt to cancel the transaction + vm.expectRevert(TimelockGuard.TimelockGuard_TransactionNotScheduled.selector); + timelockGuard.cancelTransaction(safeInstance.safe, dummyTx.hash, dummyTx.nonce, cancellationTx.signatures); + } +} + +/// @title TimelockGuard_CheckTransaction_Test +/// @notice Tests for checkTransaction function +contract TimelockGuard_CheckTransaction_Test is TimelockGuard_TestInit { + /// @notice Establishes the configured guard before checkTransaction tests. + function setUp() public override { + super.setUp(); + _configureGuard(safeInstance, TIMELOCK_DELAY); + } + + /// @notice Test that checkTransaction reverts when scheduled transaction delay hasn't passed + function test_checkTransaction_scheduledTransactionNotReady_reverts() external { + TransactionBuilder.Transaction memory dummyTx = _createDummyTransaction(safeInstance); + + // Schedule the transaction but do not advance time past the timelock delay + dummyTx.scheduleTransaction(timelockGuard); + + // Increment the nonce, as would normally happen when the transaction is executed + vm.store(address(safeInstance.safe), bytes32(uint256(5)), bytes32(uint256(safeInstance.safe.nonce() + 1))); + + vm.expectRevert(TimelockGuard.TimelockGuard_TransactionNotReady.selector); + vm.prank(address(safeInstance.safe)); + timelockGuard.checkTransaction( + dummyTx.params.to, + dummyTx.params.value, + dummyTx.params.data, + dummyTx.params.operation, + dummyTx.params.safeTxGas, + dummyTx.params.baseGas, + dummyTx.params.gasPrice, + dummyTx.params.gasToken, + dummyTx.params.refundReceiver, + "", + address(0) + ); + } + + /// @notice Test that checkTransaction reverts when scheduled transaction was cancelled + function test_checkTransaction_scheduledTransactionCancelled_reverts() external { + // Schedule a transaction + TransactionBuilder.Transaction memory dummyTx = _createDummyTransaction(safeInstance); + dummyTx.scheduleTransaction(timelockGuard); + + // Cancel the transaction + TransactionBuilder.Transaction memory cancellationTx = dummyTx.makeCancellationTransaction(timelockGuard); + timelockGuard.cancelTransaction(safeInstance.safe, dummyTx.hash, dummyTx.nonce, cancellationTx.signatures); + + // Fast forward past the timelock delay + vm.warp(block.timestamp + TIMELOCK_DELAY); + // Increment the nonce, as would normally happen when the transaction is executed + vm.store(address(safeInstance.safe), bytes32(uint256(5)), bytes32(uint256(safeInstance.safe.nonce() + 1))); + + // Should revert because transaction was cancelled + vm.expectRevert(TimelockGuard.TimelockGuard_TransactionAlreadyCancelled.selector); + vm.prank(address(safeInstance.safe)); + timelockGuard.checkTransaction( + dummyTx.params.to, + dummyTx.params.value, + dummyTx.params.data, + dummyTx.params.operation, + dummyTx.params.safeTxGas, + dummyTx.params.baseGas, + dummyTx.params.gasPrice, + dummyTx.params.gasToken, + dummyTx.params.refundReceiver, + "", + address(0) + ); + } + + /// @notice Test that checkTransaction reverts when a transaction has not been scheduled + function test_checkTransaction_transactionNotScheduled_reverts() external { + // Get transaction parameters but don't schedule the transaction + TransactionBuilder.Transaction memory dummyTx = _createDummyTransaction(safeInstance); + + // Should revert because transaction was not scheduled + vm.expectRevert(TimelockGuard.TimelockGuard_TransactionNotScheduled.selector); + vm.prank(address(safeInstance.safe)); + timelockGuard.checkTransaction( + dummyTx.params.to, + dummyTx.params.value, + dummyTx.params.data, + dummyTx.params.operation, + dummyTx.params.safeTxGas, + dummyTx.params.baseGas, + dummyTx.params.gasPrice, + dummyTx.params.gasToken, + dummyTx.params.refundReceiver, + "", + address(0) + ); + } +} + +/// @title TimelockGuard_MaxCancellationThreshold_Test +/// @notice Tests for the maxCancellationThreshold function in TimelockGuard +contract TimelockGuard_MaxCancellationThreshold_Test is TimelockGuard_TestInit { + function setUp() public override { + super.setUp(); + _configureGuard(safeInstance, TIMELOCK_DELAY); + } + + /// @notice Test that maxCancellationThreshold returns the correct value + function test_maxCancellationThreshold_maxThresholdIsBlockingThreshold_succeeds() external { + // create a new Safe with 7 owners and quorum of 5 (blocking threshold is 3) + SafeInstance memory newSafeInstance = _deploySafe("owners", 7, 5); + _enableGuard(newSafeInstance); + _configureGuard(newSafeInstance, TIMELOCK_DELAY); + + // Set up a dummy transaction + TransactionBuilder.Transaction memory dummyTx = _createDummyTransaction(newSafeInstance); + dummyTx.scheduleTransaction(timelockGuard); + + // Calculate expected max cancellation threshold + uint256 blockingThreshold = newSafeInstance.safe.getOwners().length - newSafeInstance.safe.getThreshold() + 1; + uint256 quorum = newSafeInstance.safe.getThreshold(); + + // Ensure that the minimum is set by the blocking threshold + assertGt(quorum, blockingThreshold); + + // Assert that the maxCancellationThreshold function returns the expected value + assertEq(timelockGuard.maxCancellationThreshold(newSafeInstance.safe), blockingThreshold); + } + + /// @notice Test that maxCancellationThreshold returns the correct value + function test_maxCancellationThreshold_maxThresholdIsQuorum_succeeds() external { + // create a new Safe with 7 owners and quorum of 3 (blocking threshold is 5) + SafeInstance memory newSafeInstance = _deploySafe("owners", 7, 3); + _enableGuard(newSafeInstance); + _configureGuard(newSafeInstance, TIMELOCK_DELAY); + + // Set up a dummy transaction + TransactionBuilder.Transaction memory dummyTx = _createDummyTransaction(newSafeInstance); + dummyTx.scheduleTransaction(timelockGuard); + + // Calculate expected max cancellation threshold + uint256 blockingThreshold = newSafeInstance.safe.getOwners().length - newSafeInstance.safe.getThreshold() + 1; + uint256 quorum = newSafeInstance.safe.getThreshold(); + + // Ensure that the minimum is set by quorum + assertGt(blockingThreshold, quorum); + + // Assert that the maxCancellationThreshold function returns the expected value + assertEq(timelockGuard.maxCancellationThreshold(newSafeInstance.safe), quorum); + } +} + +/// @title TimelockGuard_Integration_Test +/// @notice Tests for integration between TimelockGuard and Safe +contract TimelockGuard_Integration_Test is TimelockGuard_TestInit { + using stdStorage for StdStorage; + + function setUp() public override { + super.setUp(); + _configureGuard(safeInstance, TIMELOCK_DELAY); + } + + /// @notice Test that scheduling a transaction and then executing it succeeds + function test_integration_scheduleThenExecute_succeeds() external { + TransactionBuilder.Transaction memory dummyTx = _createDummyTransaction(safeInstance); + dummyTx.scheduleTransaction(timelockGuard); + + vm.warp(block.timestamp + TIMELOCK_DELAY); + + // increment the cancellation threshold so that we can test that it is reset + uint256 slot = stdstore.target(address(timelockGuard)).sig("cancellationThreshold(address)").with_key( + address(safeInstance.safe) + ).find(); + vm.store( + address(timelockGuard), + bytes32(slot), + bytes32(uint256(timelockGuard.cancellationThreshold(safeInstance.safe) + 1)) + ); + + vm.expectEmit(true, true, true, true); + emit TransactionExecuted(safeInstance.safe, dummyTx.hash); + dummyTx.executeTransaction(); + + // Confirm that the transaction is executed + TimelockGuard.ScheduledTransaction memory scheduledTransaction = + timelockGuard.scheduledTransaction(safeInstance.safe, dummyTx.hash); + assert(scheduledTransaction.state == TimelockGuard.TransactionState.Executed); + + // Confirm that the cancellation threshold is reset + assertEq(timelockGuard.cancellationThreshold(safeInstance.safe), 1); + } + + /// @notice Test that scheduling a transaction and then executing it twice reverts + function test_integration_scheduleThenExecuteTwice_reverts() external { + TransactionBuilder.Transaction memory dummyTx = _createDummyTransaction(safeInstance); + dummyTx.scheduleTransaction(timelockGuard); + + vm.warp(block.timestamp + TIMELOCK_DELAY); + dummyTx.executeTransaction(); + + vm.expectRevert("GS026"); + dummyTx.executeTransaction(); + } + + function test_integration_scheduleThenExecuteThenCancel_reverts() external { + TransactionBuilder.Transaction memory dummyTx = _createDummyTransaction(safeInstance); + dummyTx.scheduleTransaction(timelockGuard); + + vm.warp(block.timestamp + TIMELOCK_DELAY); + dummyTx.executeTransaction(); + + TransactionBuilder.Transaction memory cancellationTx = dummyTx.makeCancellationTransaction(timelockGuard); + vm.expectRevert(TimelockGuard.TimelockGuard_TransactionAlreadyExecuted.selector); + timelockGuard.cancelTransaction(safeInstance.safe, dummyTx.hash, dummyTx.nonce, cancellationTx.signatures); + } + + /// @notice Test that rescheduling an identical previously cancelled transaction reverts + function test_integration_scheduleTransactionIdenticalToPreviouslyCancelled_reverts() external { + TransactionBuilder.Transaction memory dummyTx = _createDummyTransaction(safeInstance); + dummyTx.scheduleTransaction(timelockGuard); + + TransactionBuilder.Transaction memory cancellationTx = dummyTx.makeCancellationTransaction(timelockGuard); + timelockGuard.cancelTransaction(safeInstance.safe, dummyTx.hash, dummyTx.nonce, cancellationTx.signatures); + + vm.expectRevert(TimelockGuard.TimelockGuard_TransactionAlreadyScheduled.selector); + dummyTx.scheduleTransaction(timelockGuard); + } + + /// @notice Test that the guard can be reset while still enabled, and then can be disabled + function test_integration_resetThenDisableGuard_succeeds() external { + TransactionBuilder.Transaction memory resetGuardTx = _createEmptyTransaction(safeInstance); + resetGuardTx.params.to = address(timelockGuard); + resetGuardTx.params.data = abi.encodeCall(TimelockGuard.configureTimelockGuard, (0)); + resetGuardTx.updateTransaction(); + resetGuardTx.scheduleTransaction(timelockGuard); + + vm.warp(block.timestamp + TIMELOCK_DELAY); + resetGuardTx.executeTransaction(); + + TransactionBuilder.Transaction memory disableGuardTx = _createEmptyTransaction(safeInstance); + disableGuardTx.params.to = address(safeInstance.safe); + disableGuardTx.params.data = abi.encodeCall(GuardManager.setGuard, (address(0))); + disableGuardTx.updateTransaction(); + + vm.warp(block.timestamp + TIMELOCK_DELAY); + disableGuardTx.executeTransaction(); + } + + /// @notice Test that the max cancellation threshold is not exceeded + function test_integration_maxCancellationThresholdNotExceeded_succeeds() external { + uint256 maxThreshold = timelockGuard.maxCancellationThreshold(safeInstance.safe); + + // Schedule a transaction + TransactionBuilder.Transaction memory dummyTx = _createDummyTransaction(safeInstance); + + // schedule and cancel the transaction maxThreshold + 1 times + for (uint256 i = 0; i < maxThreshold + 1; i++) { + // modify the calldata slightly to make the txHash different + dummyTx.params.data = bytes.concat(dummyTx.params.data, abi.encodePacked(i)); + dummyTx.updateTransaction(); + dummyTx.scheduleTransaction(timelockGuard); + + // Cancel the transaction + TransactionBuilder.Transaction memory cancellationTx = dummyTx.makeCancellationTransaction(timelockGuard); + timelockGuard.cancelTransaction(safeInstance.safe, dummyTx.hash, dummyTx.nonce, cancellationTx.signatures); + } + + assertEq(timelockGuard.cancellationThreshold(safeInstance.safe), maxThreshold); + } +} From a79504421a8e026ff43e259b27a69250dadbe195 Mon Sep 17 00:00:00 2001 From: Adrian Sutton Date: Sat, 4 Oct 2025 05:13:09 +1000 Subject: [PATCH 003/117] opcm: Support cannon+kona games in updatePrestates (#17512) * opcm: Support cannon+kona games in updatePrestates * fmt; and check devfeatures flag at updatePrestate * update semver and snapshots * remove duplicate import * bump semver after rebase * fix addGameType for SUPER_CANNON_KONA; add more cannon-kona tests * remove proxyAdmin from UpdatePrestateInput * update IOPCM interface * update semver * check all topics in expectEmit * add updatePrestate helper function for testing * lint test * fix semgrep issues --------- Co-authored-by: inphi --- .../interfaces/L1/IOPContractsManager.sol | 13 +- .../snapshots/abi/OPContractsManager.json | 10 +- .../abi/OPContractsManagerGameTypeAdder.json | 10 +- .../snapshots/semver-lock.json | 4 +- .../src/L1/OPContractsManager.sol | 91 ++-- .../test/L1/OPContractsManager.t.sol | 503 ++++++++++++------ 6 files changed, 428 insertions(+), 203 deletions(-) diff --git a/packages/contracts-bedrock/interfaces/L1/IOPContractsManager.sol b/packages/contracts-bedrock/interfaces/L1/IOPContractsManager.sol index adb75fe8c8d..4ea27faef33 100644 --- a/packages/contracts-bedrock/interfaces/L1/IOPContractsManager.sol +++ b/packages/contracts-bedrock/interfaces/L1/IOPContractsManager.sol @@ -59,7 +59,7 @@ interface IOPContractsManagerGameTypeAdder { returns (IOPContractsManager.AddGameOutput[] memory); function updatePrestate( - IOPContractsManager.OpChainConfig[] memory _prestateUpdateInputs, + IOPContractsManager.UpdatePrestateInput[] memory _prestateUpdateInputs, address _superchainConfig ) external; @@ -225,6 +225,13 @@ interface IOPContractsManager { Claim absolutePrestate; } + /// @notice The input required to identify a chain for updating prestates + struct UpdatePrestateInput { + ISystemConfig systemConfigProxy; + Claim cannonPrestate; + Claim cannonKonaPrestate; + } + struct AddGameInput { string saltMixer; ISystemConfig systemConfig; @@ -345,8 +352,8 @@ interface IOPContractsManager { function addGameType(AddGameInput[] memory _gameConfigs) external returns (AddGameOutput[] memory); /// @notice Updates the prestate hash for a new game type while keeping all other parameters the same - /// @param _prestateUpdateInputs The new prestate hash to use - function updatePrestate(OpChainConfig[] memory _prestateUpdateInputs) external; + /// @param _prestateUpdateInputs The new prestates to use + function updatePrestate(UpdatePrestateInput[] memory _prestateUpdateInputs) external; /// @notice Migrates one or more OP Stack chains to use the Super Root dispute games and shared /// dispute game contracts. diff --git a/packages/contracts-bedrock/snapshots/abi/OPContractsManager.json b/packages/contracts-bedrock/snapshots/abi/OPContractsManager.json index f4ef1718aa4..651f9eb62c7 100644 --- a/packages/contracts-bedrock/snapshots/abi/OPContractsManager.json +++ b/packages/contracts-bedrock/snapshots/abi/OPContractsManager.json @@ -774,17 +774,17 @@ "type": "address" }, { - "internalType": "contract IProxyAdmin", - "name": "proxyAdmin", - "type": "address" + "internalType": "Claim", + "name": "cannonPrestate", + "type": "bytes32" }, { "internalType": "Claim", - "name": "absolutePrestate", + "name": "cannonKonaPrestate", "type": "bytes32" } ], - "internalType": "struct OPContractsManager.OpChainConfig[]", + "internalType": "struct OPContractsManager.UpdatePrestateInput[]", "name": "_prestateUpdateInputs", "type": "tuple[]" } diff --git a/packages/contracts-bedrock/snapshots/abi/OPContractsManagerGameTypeAdder.json b/packages/contracts-bedrock/snapshots/abi/OPContractsManagerGameTypeAdder.json index 80b80512aeb..6bf43934187 100644 --- a/packages/contracts-bedrock/snapshots/abi/OPContractsManagerGameTypeAdder.json +++ b/packages/contracts-bedrock/snapshots/abi/OPContractsManagerGameTypeAdder.json @@ -360,17 +360,17 @@ "type": "address" }, { - "internalType": "contract IProxyAdmin", - "name": "proxyAdmin", - "type": "address" + "internalType": "Claim", + "name": "cannonPrestate", + "type": "bytes32" }, { "internalType": "Claim", - "name": "absolutePrestate", + "name": "cannonKonaPrestate", "type": "bytes32" } ], - "internalType": "struct OPContractsManager.OpChainConfig[]", + "internalType": "struct OPContractsManager.UpdatePrestateInput[]", "name": "_prestateUpdateInputs", "type": "tuple[]" } diff --git a/packages/contracts-bedrock/snapshots/semver-lock.json b/packages/contracts-bedrock/snapshots/semver-lock.json index 4c4a77f3508..9553fc0033a 100644 --- a/packages/contracts-bedrock/snapshots/semver-lock.json +++ b/packages/contracts-bedrock/snapshots/semver-lock.json @@ -20,8 +20,8 @@ "sourceCodeHash": "0xfca613b5d055ffc4c3cbccb0773ddb9030abedc1aa6508c9e2e7727cc0cd617b" }, "src/L1/OPContractsManager.sol:OPContractsManager": { - "initCodeHash": "0xb0db1b8b4e24626c018dd524608256e57fbb2b71fa164a32e0553280d6ff52d7", - "sourceCodeHash": "0x4c1a80a787d42e49c0dab8903259e1d32f5a21d2990148ab92a9ff4c80c68548" + "initCodeHash": "0xfc9b6327dc3fae8c26ce9d3ae8072b53845f2b8d992bc77a50f04134f0b0a7cc", + "sourceCodeHash": "0xa11523c7a9e71e2acee453e84cc981070881050ae6100aea7453188e0ca48796" }, "src/L1/OPContractsManagerStandardValidator.sol:OPContractsManagerStandardValidator": { "initCodeHash": "0x57d6a6729d887ead009d518e8f17fa0d26bfc97b8efe1494ab4ef8dbb000d109", diff --git a/packages/contracts-bedrock/src/L1/OPContractsManager.sol b/packages/contracts-bedrock/src/L1/OPContractsManager.sol index 82d5df89149..8271cfb0de2 100644 --- a/packages/contracts-bedrock/src/L1/OPContractsManager.sol +++ b/packages/contracts-bedrock/src/L1/OPContractsManager.sol @@ -184,12 +184,9 @@ abstract contract OPContractsManagerBase { /// This method should be used as the salt mixer when deploying contracts when there is no user /// provided salt mixer. This protects against a situation where multiple chains with the same /// L2 chain ID exist, which would otherwise result in address collisions. - function reusableSaltMixer(OPContractsManager.OpChainConfig memory _opChainConfig) - internal - pure - returns (string memory) - { - return string(bytes.concat(bytes32(uint256(uint160(address(_opChainConfig.systemConfigProxy)))))); + /// @param _systemConfigProxy The SystemConfig contract found in the OpChainConfig of the chain being deployed to. + function reusableSaltMixer(ISystemConfig _systemConfigProxy) internal pure returns (string memory) { + return string(bytes.concat(bytes32(uint256(uint160(address(_systemConfigProxy)))))); } /// @notice Deterministically deploys a new proxy contract owned by the provided ProxyAdmin. @@ -335,6 +332,7 @@ abstract contract OPContractsManagerBase { if ( gameType.raw() == GameTypes.SUPER_CANNON.raw() || gameType.raw() == GameTypes.SUPER_PERMISSIONED_CANNON.raw() + || gameType.raw() == GameTypes.SUPER_CANNON_KONA.raw() ) { l2ChainId = 0; } else { @@ -565,28 +563,28 @@ contract OPContractsManagerGameTypeAdder is OPContractsManagerBase { return outputs; } - /// @notice Updates the prestate hash for a given game type while keeping all other game + /// @notice Updates the prestate hash for all deployed dispute games while keeping all other game /// parameters exactly the same. Currently requires deploying a new implementation /// as there is no way to update the prestate on an existing implementation. /// @param _prestateUpdateInputs The new prestate hash to use. - function updatePrestate(OPContractsManager.OpChainConfig[] memory _prestateUpdateInputs) public { + function updatePrestate(OPContractsManager.UpdatePrestateInput[] memory _prestateUpdateInputs) public { // Loop through each chain and prestate hash for (uint256 i = 0; i < _prestateUpdateInputs.length; i++) { - // Ensure that the prestate is not the zero hash. - if (Claim.unwrap(_prestateUpdateInputs[i].absolutePrestate) == bytes32(0)) { - revert OPContractsManager.PrestateRequired(); - } - // Grab the DisputeGameFactory. IDisputeGameFactory dgf = IDisputeGameFactory(_prestateUpdateInputs[i].systemConfigProxy.disputeGameFactory()); + uint256 numGameTypes = isDevFeatureEnabled(DevFeatures.CANNON_KONA) ? 6 : 4; // Create an array of all of the potential game types to update. - GameType[] memory gameTypes = new GameType[](4); + GameType[] memory gameTypes = new GameType[](numGameTypes); gameTypes[0] = GameTypes.CANNON; gameTypes[1] = GameTypes.PERMISSIONED_CANNON; gameTypes[2] = GameTypes.SUPER_CANNON; gameTypes[3] = GameTypes.SUPER_PERMISSIONED_CANNON; + if (isDevFeatureEnabled(DevFeatures.CANNON_KONA)) { + gameTypes[4] = GameTypes.CANNON_KONA; + gameTypes[5] = GameTypes.SUPER_CANNON_KONA; + } // Track if we have a legacy game, super game, or both. We will revert if this function // is ever called with a mix of legacy and super games. Should never happen in @@ -610,6 +608,7 @@ contract OPContractsManagerGameTypeAdder is OPContractsManagerBase { if ( gameType.raw() == GameTypes.SUPER_CANNON.raw() || gameType.raw() == GameTypes.SUPER_PERMISSIONED_CANNON.raw() + || gameType.raw() == GameTypes.SUPER_CANNON_KONA.raw() ) { hasSuperGame = true; } else { @@ -621,15 +620,26 @@ contract OPContractsManagerGameTypeAdder is OPContractsManagerBase { revert OPContractsManagerGameTypeAdder_MixedGameTypes(); } + // Select the prestate to use + Claim prestate = gameType.raw() == GameTypes.CANNON_KONA.raw() + || gameType.raw() == GameTypes.SUPER_CANNON_KONA.raw() + ? _prestateUpdateInputs[i].cannonKonaPrestate + : _prestateUpdateInputs[i].cannonPrestate; + + // Ensure that the prestate is not the zero hash. + if (Claim.unwrap(prestate) == bytes32(0)) { + revert OPContractsManager.PrestateRequired(); + } + // Grab the existing game constructor params and init bond. IFaultDisputeGame.GameConstructorParams memory gameParams = getGameConstructorParams(existingGame); // Create a new game input with the updated prestate. OPContractsManager.AddGameInput memory input = OPContractsManager.AddGameInput({ - disputeAbsolutePrestate: _prestateUpdateInputs[i].absolutePrestate, - saltMixer: reusableSaltMixer(_prestateUpdateInputs[i]), + disputeAbsolutePrestate: prestate, + saltMixer: reusableSaltMixer(_prestateUpdateInputs[i].systemConfigProxy), systemConfig: _prestateUpdateInputs[i].systemConfigProxy, - proxyAdmin: _prestateUpdateInputs[i].proxyAdmin, + proxyAdmin: _prestateUpdateInputs[i].systemConfigProxy.proxyAdmin(), delayedWETH: IDelayedWETH(payable(address(gameParams.weth))), disputeGameType: gameParams.gameType, disputeMaxGameDepth: gameParams.maxGameDepth, @@ -733,7 +743,7 @@ contract OPContractsManagerUpgrader is OPContractsManagerBase { deployProxy({ _l2ChainId: _l2ChainId, _proxyAdmin: _opChainConfig.proxyAdmin, - _saltMixer: reusableSaltMixer(_opChainConfig), + _saltMixer: reusableSaltMixer(_opChainConfig.systemConfigProxy), _contractName: "ETHLockbox-U16a" }) ); @@ -921,7 +931,9 @@ contract OPContractsManagerUpgrader is OPContractsManagerBase { Blueprint.deployFrom( bps.permissionedDisputeGame1, bps.permissionedDisputeGame2, - computeSalt(_l2ChainId, reusableSaltMixer(_opChainConfig), "PermissionedDisputeGame"), + computeSalt( + _l2ChainId, reusableSaltMixer(_opChainConfig.systemConfigProxy), "PermissionedDisputeGame" + ), encodePermissionedFDGConstructor(params, proposer, challenger) ) ); @@ -930,7 +942,9 @@ contract OPContractsManagerUpgrader is OPContractsManagerBase { Blueprint.deployFrom( bps.permissionlessDisputeGame1, bps.permissionlessDisputeGame2, - computeSalt(_l2ChainId, reusableSaltMixer(_opChainConfig), "PermissionlessDisputeGame"), + computeSalt( + _l2ChainId, reusableSaltMixer(_opChainConfig.systemConfigProxy), "PermissionlessDisputeGame" + ), encodePermissionlessFDGConstructor(params) ) ); @@ -1479,7 +1493,7 @@ contract OPContractsManagerInteropMigrator is OPContractsManagerBase { deployProxy({ _l2ChainId: block.timestamp, _proxyAdmin: _input.opChainConfigs[0].proxyAdmin, - _saltMixer: reusableSaltMixer(_input.opChainConfigs[0]), + _saltMixer: reusableSaltMixer(_input.opChainConfigs[0].systemConfigProxy), _contractName: "ETHLockbox-Interop" }) ); @@ -1507,7 +1521,7 @@ contract OPContractsManagerInteropMigrator is OPContractsManagerBase { deployProxy({ _l2ChainId: block.timestamp, _proxyAdmin: _input.opChainConfigs[0].proxyAdmin, - _saltMixer: reusableSaltMixer(_input.opChainConfigs[0]), + _saltMixer: reusableSaltMixer(_input.opChainConfigs[0].systemConfigProxy), _contractName: "DisputeGameFactory-Interop" }) ); @@ -1525,7 +1539,7 @@ contract OPContractsManagerInteropMigrator is OPContractsManagerBase { deployProxy({ _l2ChainId: block.timestamp, _proxyAdmin: _input.opChainConfigs[0].proxyAdmin, - _saltMixer: reusableSaltMixer(_input.opChainConfigs[0]), + _saltMixer: reusableSaltMixer(_input.opChainConfigs[0].systemConfigProxy), _contractName: "AnchorStateRegistry-Interop" }) ); @@ -1584,7 +1598,7 @@ contract OPContractsManagerInteropMigrator is OPContractsManagerBase { deployProxy({ _l2ChainId: block.timestamp, _proxyAdmin: _input.opChainConfigs[0].proxyAdmin, - _saltMixer: reusableSaltMixer(_input.opChainConfigs[0]), + _saltMixer: reusableSaltMixer(_input.opChainConfigs[0].systemConfigProxy), _contractName: "DelayedWETH-Interop-Permissioned" }) ) @@ -1608,7 +1622,9 @@ contract OPContractsManagerInteropMigrator is OPContractsManagerBase { blueprints().superPermissionedDisputeGame1, blueprints().superPermissionedDisputeGame2, computeSalt( - block.timestamp, reusableSaltMixer(_input.opChainConfigs[0]), "SuperPermissionedDisputeGame" + block.timestamp, + reusableSaltMixer(_input.opChainConfigs[0].systemConfigProxy), + "SuperPermissionedDisputeGame" ), encodePermissionedSuperFDGConstructor( ISuperFaultDisputeGame.GameConstructorParams({ @@ -1644,7 +1660,7 @@ contract OPContractsManagerInteropMigrator is OPContractsManagerBase { deployProxy({ _l2ChainId: block.timestamp, _proxyAdmin: _input.opChainConfigs[0].proxyAdmin, - _saltMixer: reusableSaltMixer(_input.opChainConfigs[0]), + _saltMixer: reusableSaltMixer(_input.opChainConfigs[0].systemConfigProxy), _contractName: "DelayedWETH-Interop-Permissionless" }) ) @@ -1663,7 +1679,11 @@ contract OPContractsManagerInteropMigrator is OPContractsManagerBase { Blueprint.deployFrom( blueprints().superPermissionlessDisputeGame1, blueprints().superPermissionlessDisputeGame2, - computeSalt(block.timestamp, reusableSaltMixer(_input.opChainConfigs[0]), "SuperFaultDisputeGame"), + computeSalt( + block.timestamp, + reusableSaltMixer(_input.opChainConfigs[0].systemConfigProxy), + "SuperFaultDisputeGame" + ), encodePermissionlessSuperFDGConstructor( ISuperFaultDisputeGame.GameConstructorParams({ gameType: GameTypes.SUPER_CANNON, @@ -1787,6 +1807,13 @@ contract OPContractsManager is ISemver { Claim absolutePrestate; } + /// @notice The input required to identify a chain for updating prestates + struct UpdatePrestateInput { + ISystemConfig systemConfigProxy; + Claim cannonPrestate; + Claim cannonKonaPrestate; + } + struct AddGameInput { string saltMixer; ISystemConfig systemConfig; @@ -1810,9 +1837,9 @@ contract OPContractsManager is ISemver { // -------- Constants and Variables -------- - /// @custom:semver 3.7.0 + /// @custom:semver 3.8.0 function version() public pure virtual returns (string memory) { - return "3.7.0"; + return "3.8.0"; } OPContractsManagerGameTypeAdder public immutable opcmGameTypeAdder; @@ -1984,9 +2011,9 @@ contract OPContractsManager is ISemver { return abi.decode(returnData, (AddGameOutput[])); } - /// @notice Updates the prestate hash for a new game type while keeping all other parameters the same - /// @param _prestateUpdateInputs The new prestate hash to use - function updatePrestate(OpChainConfig[] memory _prestateUpdateInputs) public { + /// @notice Updates the prestate hash for dispute games while keeping all other parameters the same + /// @param _prestateUpdateInputs The new prestate hashes to use + function updatePrestate(UpdatePrestateInput[] memory _prestateUpdateInputs) public { if (address(this) == address(thisOPCM)) revert OnlyDelegatecall(); bytes memory data = abi.encodeCall(OPContractsManagerGameTypeAdder.updatePrestate, (_prestateUpdateInputs)); diff --git a/packages/contracts-bedrock/test/L1/OPContractsManager.t.sol b/packages/contracts-bedrock/test/L1/OPContractsManager.t.sol index c3c0e7a6f59..c0f4065f613 100644 --- a/packages/contracts-bedrock/test/L1/OPContractsManager.t.sol +++ b/packages/contracts-bedrock/test/L1/OPContractsManager.t.sol @@ -28,8 +28,8 @@ import { IOptimismPortal2 } from "interfaces/L1/IOptimismPortal2.sol"; import { IProxyAdmin } from "interfaces/universal/IProxyAdmin.sol"; import { ISuperchainConfig } from "interfaces/L1/ISuperchainConfig.sol"; import { IProtocolVersions } from "interfaces/L1/IProtocolVersions.sol"; -import { IFaultDisputeGame } from "interfaces/dispute/IFaultDisputeGame.sol"; import { IPermissionedDisputeGame } from "interfaces/dispute/IPermissionedDisputeGame.sol"; +import { IFaultDisputeGame } from "interfaces/dispute/IFaultDisputeGame.sol"; import { IDelayedWETH } from "interfaces/dispute/IDelayedWETH.sol"; import { IDisputeGame } from "interfaces/dispute/IDisputeGame.sol"; import { IDisputeGameFactory } from "interfaces/dispute/IDisputeGameFactory.sol"; @@ -310,6 +310,10 @@ contract OPContractsManager_Upgrade_Harness is CommonTest { /// @title OPContractsManager_TestInit /// @notice Reusable test initialization for `OPContractsManager` tests. contract OPContractsManager_TestInit is CommonTest { + event GameTypeAdded( + uint256 indexed l2ChainId, GameType indexed gameType, IDisputeGame newDisputeGame, IDisputeGame oldDisputeGame + ); + IOPContractsManager.DeployOutput internal chainDeployOutput1; IOPContractsManager.DeployOutput internal chainDeployOutput2; @@ -367,6 +371,50 @@ contract OPContractsManager_TestInit is CommonTest { }) ); } + + function addGameType(IOPContractsManager.AddGameInput memory input) + internal + returns (IOPContractsManager.AddGameOutput memory) + { + IOPContractsManager.AddGameInput[] memory inputs = new IOPContractsManager.AddGameInput[](1); + inputs[0] = input; + + uint256 l2ChainId = IFaultDisputeGame( + address(IDisputeGameFactory(input.systemConfig.disputeGameFactory()).gameImpls(GameType.wrap(1))) + ).l2ChainId(); + + // Expect the GameTypeAdded event to be emitted. + vm.expectEmit(true, true, true, false, address(this)); + emit GameTypeAdded( + l2ChainId, input.disputeGameType, IDisputeGame(payable(address(0))), IDisputeGame(payable(address(0))) + ); + (bool success, bytes memory rawGameOut) = + address(opcm).delegatecall(abi.encodeCall(IOPContractsManager.addGameType, (inputs))); + assertTrue(success, "addGameType failed"); + + IOPContractsManager.AddGameOutput[] memory addGameOutAll = + abi.decode(rawGameOut, (IOPContractsManager.AddGameOutput[])); + return addGameOutAll[0]; + } + + function newGameInputFactory(GameType _gameType) internal view returns (IOPContractsManager.AddGameInput memory) { + return IOPContractsManager.AddGameInput({ + saltMixer: "hello", + systemConfig: chainDeployOutput1.systemConfigProxy, + proxyAdmin: chainDeployOutput1.opChainProxyAdmin, + delayedWETH: IDelayedWETH(payable(address(0))), + disputeGameType: _gameType, + disputeAbsolutePrestate: Claim.wrap(bytes32(hex"deadbeef1234")), + disputeMaxGameDepth: 73, + disputeSplitDepth: 30, + disputeClockExtension: Duration.wrap(10800), + disputeMaxClockDuration: Duration.wrap(302400), + initialBond: 1 ether, + vm: IBigStepper(address(opcm.implementations().mipsImpl)), + permissioned: _gameType.raw() == GameTypes.PERMISSIONED_CANNON.raw() + || _gameType.raw() == GameTypes.SUPER_PERMISSIONED_CANNON.raw() + }); + } } /// @title OPContractsManager_ChainIdToBatchInboxAddress_Test @@ -429,10 +477,6 @@ contract OPContractsManager_ChainIdToBatchInboxAddress_Test is Test { /// @title OPContractsManager_AddGameType_Test /// @notice Tests the `addGameType` function of the `OPContractsManager` contract. contract OPContractsManager_AddGameType_Test is OPContractsManager_TestInit { - event GameTypeAdded( - uint256 indexed l2ChainId, GameType indexed gameType, IDisputeGame newDisputeGame, IDisputeGame oldDisputeGame - ); - /// @notice Tests that we can add a PermissionedDisputeGame implementation with addGameType. function test_addGameType_permissioned_succeeds() public { // Create the input for the Permissioned game type. @@ -478,7 +522,6 @@ contract OPContractsManager_AddGameType_Test is OPContractsManager_TestInit { function test_addGameType_permissionedSuper_succeeds() public { // Create the input for the Super game type. IOPContractsManager.AddGameInput memory input = newGameInputFactory(GameTypes.SUPER_PERMISSIONED_CANNON); - input.disputeGameType = GameTypes.SUPER_PERMISSIONED_CANNON; // Since OPCM will start with the standard Permissioned (non-Super) game type we won't have // a Super dispute game to grab the proposer and challenger from. In production we'd either @@ -633,50 +676,6 @@ contract OPContractsManager_AddGameType_Test is OPContractsManager_TestInit { opcm.addGameType(inputs); } - function addGameType(IOPContractsManager.AddGameInput memory input) - internal - returns (IOPContractsManager.AddGameOutput memory) - { - IOPContractsManager.AddGameInput[] memory inputs = new IOPContractsManager.AddGameInput[](1); - inputs[0] = input; - - uint256 l2ChainId = IFaultDisputeGame( - address(IDisputeGameFactory(input.systemConfig.disputeGameFactory()).gameImpls(GameType.wrap(1))) - ).l2ChainId(); - - // Expect the GameTypeAdded event to be emitted. - vm.expectEmit(true, true, false, false, address(this)); - emit GameTypeAdded( - l2ChainId, input.disputeGameType, IDisputeGame(payable(address(0))), IDisputeGame(payable(address(0))) - ); - (bool success, bytes memory rawGameOut) = - address(opcm).delegatecall(abi.encodeCall(IOPContractsManager.addGameType, (inputs))); - assertTrue(success, "addGameType failed"); - - IOPContractsManager.AddGameOutput[] memory addGameOutAll = - abi.decode(rawGameOut, (IOPContractsManager.AddGameOutput[])); - return addGameOutAll[0]; - } - - function newGameInputFactory(GameType _gameType) internal view returns (IOPContractsManager.AddGameInput memory) { - return IOPContractsManager.AddGameInput({ - saltMixer: "hello", - systemConfig: chainDeployOutput1.systemConfigProxy, - proxyAdmin: chainDeployOutput1.opChainProxyAdmin, - delayedWETH: IDelayedWETH(payable(address(0))), - disputeGameType: _gameType, - disputeAbsolutePrestate: Claim.wrap(bytes32(hex"deadbeef1234")), - disputeMaxGameDepth: 73, - disputeSplitDepth: 30, - disputeClockExtension: Duration.wrap(10800), - disputeMaxClockDuration: Duration.wrap(302400), - initialBond: 1 ether, - vm: IBigStepper(address(opcm.implementations().mipsImpl)), - permissioned: _gameType.raw() == GameTypes.PERMISSIONED_CANNON.raw() - || _gameType.raw() == GameTypes.SUPER_PERMISSIONED_CANNON.raw() - }); - } - function assertValidGameType( IOPContractsManager.AddGameInput memory agi, IOPContractsManager.AddGameOutput memory ago @@ -783,29 +782,56 @@ contract OPContractsManager_UpdatePrestate_Test is OPContractsManager_TestInit { IOPContractsManager internal prestateUpdater; OPContractsManager.AddGameInput[] internal gameInput; - function setUp() public override { + function setUp() public virtual override { super.setUp(); prestateUpdater = opcm; } - /// @notice Tests that we can update the prestate when only the PermissionedDisputeGame exists. - function test_updatePrestate_pdgOnlyWithValidInput_succeeds() public { - // Create the input for the function call. - Claim prestate = Claim.wrap(bytes32(hex"ABBA")); - IOPContractsManager.OpChainConfig[] memory inputs = new IOPContractsManager.OpChainConfig[](1); - inputs[0] = IOPContractsManager.OpChainConfig( - chainDeployOutput1.systemConfigProxy, chainDeployOutput1.opChainProxyAdmin, prestate - ); + /// @notice Runs the OPCM updatePrestate function and checks the results. + /// @param _input The input to the OPCM updatePrestate function. + function _runUpdatePrestateAndChecks(IOPContractsManager.UpdatePrestateInput memory _input) internal { + _runUpdatePrestateAndChecks(_input, bytes("")); + } + + /// @notice Runs the OPCM updatePrestate function and checks the results. + /// @param _input The input to the OPCM updatePrestate function. + /// @param _revertBytes The bytes of the revert to expect, if any. + function _runUpdatePrestateAndChecks( + IOPContractsManager.UpdatePrestateInput memory _input, + bytes memory _revertBytes + ) + internal + { + bool expectCannonUpdated = address( + IDisputeGameFactory(chainDeployOutput1.systemConfigProxy.disputeGameFactory()).gameImpls(GameTypes.CANNON) + ) != address(0); + bool expectCannonKonaUpdated = address( + IDisputeGameFactory(chainDeployOutput1.systemConfigProxy.disputeGameFactory()).gameImpls( + GameTypes.CANNON_KONA + ) + ) != address(0); // Turn the ProxyAdmin owner into a DelegateCaller. address proxyAdminOwner = chainDeployOutput1.opChainProxyAdmin.owner(); vm.etch(address(proxyAdminOwner), vm.getDeployedCode("test/mocks/Callers.sol:DelegateCaller")); + IOPContractsManager.UpdatePrestateInput[] memory inputs = new IOPContractsManager.UpdatePrestateInput[](1); + inputs[0] = _input; + + if (_revertBytes.length > 0) { + vm.expectRevert(_revertBytes); + } + // Trigger the updatePrestate function. DelegateCaller(proxyAdminOwner).dcForward( address(prestateUpdater), abi.encodeCall(IOPContractsManager.updatePrestate, (inputs)) ); + // Return early if a revert was expected. Otherwise we'll get errors below. + if (_revertBytes.length > 0) { + return; + } + // Grab the PermissionedDisputeGame. IPermissionedDisputeGame pdg = IPermissionedDisputeGame( address( @@ -814,27 +840,123 @@ contract OPContractsManager_UpdatePrestate_Test is OPContractsManager_TestInit { ) ) ); + assertEq(pdg.absolutePrestate().raw(), _input.cannonPrestate.raw(), "permissioned game prestate mismatch"); + // Ensure that the WETH contracts are not reverting + pdg.weth().balanceOf(address(0)); - // Check the prestate value. - assertEq(pdg.absolutePrestate().raw(), prestate.raw(), "pdg prestate mismatch"); + if (expectCannonUpdated) { + IPermissionedDisputeGame game = IPermissionedDisputeGame( + address( + IDisputeGameFactory(chainDeployOutput1.systemConfigProxy.disputeGameFactory()).gameImpls( + GameTypes.CANNON + ) + ) + ); + assertEq(game.absolutePrestate().raw(), _input.cannonPrestate.raw(), "cannon game prestate mismatch"); + // Ensure that the WETH contracts are not reverting + game.weth().balanceOf(address(0)); + } else { + assertEq( + address( + IDisputeGameFactory(chainDeployOutput1.systemConfigProxy.disputeGameFactory()).gameImpls( + GameTypes.CANNON + ) + ), + (address(0)), + "cannon game should not exist" + ); + } - // Ensure that the WETH contract is not reverting. - pdg.weth().balanceOf(address(0)); + if (expectCannonKonaUpdated) { + IPermissionedDisputeGame game = IPermissionedDisputeGame( + address( + IDisputeGameFactory(chainDeployOutput1.systemConfigProxy.disputeGameFactory()).gameImpls( + GameTypes.CANNON_KONA + ) + ) + ); + assertEq(game.absolutePrestate().raw(), _input.cannonKonaPrestate.raw(), "cannon game prestate mismatch"); + // Ensure that the WETH contracts are not reverting + game.weth().balanceOf(address(0)); + } else { + assertEq( + address( + IDisputeGameFactory(chainDeployOutput1.systemConfigProxy.disputeGameFactory()).gameImpls( + GameTypes.CANNON_KONA + ) + ), + (address(0)), + "cannon_kona game should not exist" + ); + } + } + + /// @notice Tests that we can update the prestate when only the PermissionedDisputeGame exists. + function test_updatePrestate_pdgOnlyWithValidInput_succeeds() public { + Claim prestate = Claim.wrap(bytes32(hex"ABBA")); + _runUpdatePrestateAndChecks( + IOPContractsManager.UpdatePrestateInput( + chainDeployOutput1.systemConfigProxy, prestate, Claim.wrap(bytes32(0)) + ) + ); } /// @notice Tests that we can update the prestate when both the PermissionedDisputeGame and /// FaultDisputeGame exist. function test_updatePrestate_bothGamesWithValidInput_succeeds() public { // Add a FaultDisputeGame implementation via addGameType. - IOPContractsManager.AddGameInput memory input = newGameInputFactory({ permissioned: false }); - input.disputeGameType = GameTypes.CANNON; + IOPContractsManager.AddGameInput memory input = newGameInputFactory(GameTypes.CANNON); addGameType(input); + Claim prestate = Claim.wrap(bytes32(hex"ABBA")); + _runUpdatePrestateAndChecks( + IOPContractsManager.UpdatePrestateInput( + chainDeployOutput1.systemConfigProxy, prestate, Claim.wrap(bytes32(0)) + ) + ); + } + + /// @notice Tests that we can update the prestate when a SuperFaultDisputeGame exists. Note + /// that this test isn't ideal because the system starts with a PermissionedDisputeGame + /// and then adds a SuperPermissionedDisputeGame and SuperFaultDisputeGame. In the real + /// system we wouldn't have that PermissionedDisputeGame to start with, but it + /// shouldn't matter because the function is independent of other game types that + /// exist. + function test_updatePrestate_withSuperGame_succeeds() public { + // Mock out the existence of a previous SuperPermissionedDisputeGame so we can add a real + // SuperPermissionedDisputeGame implementation. + vm.mockCall( + address(chainDeployOutput1.disputeGameFactoryProxy), + abi.encodeCall(IDisputeGameFactory.gameImpls, (GameTypes.SUPER_PERMISSIONED_CANNON)), + abi.encode(chainDeployOutput1.permissionedDisputeGame) + ); + vm.mockCall( + address(chainDeployOutput1.permissionedDisputeGame), + abi.encodeCall(IDisputeGame.gameType, ()), + abi.encode(GameTypes.SUPER_PERMISSIONED_CANNON) + ); + + // Add a SuperPermissionedDisputeGame implementation via addGameType. + IOPContractsManager.AddGameInput memory input1 = newGameInputFactory(GameTypes.SUPER_PERMISSIONED_CANNON); + addGameType(input1); + vm.clearMockedCalls(); + + // Add a SuperFaultDisputeGame implementation via addGameType. + IOPContractsManager.AddGameInput memory input2 = newGameInputFactory(GameTypes.SUPER_CANNON); + addGameType(input2); + + // Clear out the PermissionedDisputeGame implementation. + address owner = chainDeployOutput1.disputeGameFactoryProxy.owner(); + vm.prank(owner); + chainDeployOutput1.disputeGameFactoryProxy.setImplementation( + GameTypes.PERMISSIONED_CANNON, IDisputeGame(payable(address(0))) + ); + // Create the input for the function call. Claim prestate = Claim.wrap(bytes32(hex"ABBA")); - IOPContractsManager.OpChainConfig[] memory inputs = new IOPContractsManager.OpChainConfig[](1); - inputs[0] = IOPContractsManager.OpChainConfig( - chainDeployOutput1.systemConfigProxy, chainDeployOutput1.opChainProxyAdmin, prestate + IOPContractsManager.UpdatePrestateInput[] memory inputs = new IOPContractsManager.UpdatePrestateInput[](1); + inputs[0] = IOPContractsManager.UpdatePrestateInput( + chainDeployOutput1.systemConfigProxy, prestate, Claim.wrap(bytes32(0)) ); // Turn the ProxyAdmin owner into a DelegateCaller. @@ -846,20 +968,20 @@ contract OPContractsManager_UpdatePrestate_Test is OPContractsManager_TestInit { address(prestateUpdater), abi.encodeCall(IOPContractsManager.updatePrestate, (inputs)) ); - // Grab the PermissionedDisputeGame. + // Grab the SuperPermissionedDisputeGame. IPermissionedDisputeGame pdg = IPermissionedDisputeGame( address( IDisputeGameFactory(chainDeployOutput1.systemConfigProxy.disputeGameFactory()).gameImpls( - GameTypes.PERMISSIONED_CANNON + GameTypes.SUPER_PERMISSIONED_CANNON ) ) ); - // Grab the FaultDisputeGame. + // Grab the SuperFaultDisputeGame. IPermissionedDisputeGame fdg = IPermissionedDisputeGame( address( IDisputeGameFactory(chainDeployOutput1.systemConfigProxy.disputeGameFactory()).gameImpls( - GameTypes.CANNON + GameTypes.SUPER_CANNON ) ) ); @@ -873,13 +995,81 @@ contract OPContractsManager_UpdatePrestate_Test is OPContractsManager_TestInit { fdg.weth().balanceOf(address(0)); } - /// @notice Tests that we can update the prestate when a SuperFaultDisputeGame exists. Note - /// that this test isn't ideal because the system starts with a PermissionedDisputeGame - /// and then adds a SuperPermissionedDisputeGame and SuperFaultDisputeGame. In the real - /// system we wouldn't have that PermissionedDisputeGame to start with, but it - /// shouldn't matter because the function is independent of other game types that - /// exist. - function test_updatePrestate_withSuperGame_succeeds() public { + /// @notice Tests that the updatePrestate function will revert if the provided prestate is for + /// mixed game types (i.e. CANNON and SUPER_CANNON). + function test_updatePrestate_mixedGameTypes_reverts() public { + // Add a SuperFaultDisputeGame implementation via addGameType. + IOPContractsManager.AddGameInput memory input = newGameInputFactory(GameTypes.SUPER_CANNON); + addGameType(input); + + // nosemgrep: sol-style-use-abi-encodecall + _runUpdatePrestateAndChecks( + IOPContractsManager.UpdatePrestateInput({ + systemConfigProxy: chainDeployOutput1.systemConfigProxy, + cannonPrestate: Claim.wrap(bytes32(hex"ABBA")), + cannonKonaPrestate: Claim.wrap(bytes32(0)) + }), + abi.encodeWithSelector( + IOPContractsManagerGameTypeAdder.OPContractsManagerGameTypeAdder_MixedGameTypes.selector + ) + ); + } + + /// @notice Tests that the updatePrestate function will revert if the provided prestate is the + /// zero hash. + function test_updatePrestate_whenPDGPrestateIsZero_reverts() public { + // nosemgrep: sol-style-use-abi-encodecall + _runUpdatePrestateAndChecks( + IOPContractsManager.UpdatePrestateInput({ + systemConfigProxy: chainDeployOutput1.systemConfigProxy, + cannonPrestate: Claim.wrap(bytes32(0)), + cannonKonaPrestate: Claim.wrap(bytes32(0)) + }), + abi.encodeWithSelector(IOPContractsManager.PrestateRequired.selector) + ); + } + + function test_updatePrestate_whenOnlyCannonPrestateIsZeroAndCannonGameTypeDisabled_reverts() public { + // nosemgrep: sol-style-use-abi-encodecall + _runUpdatePrestateAndChecks( + IOPContractsManager.UpdatePrestateInput({ + systemConfigProxy: chainDeployOutput1.systemConfigProxy, + cannonPrestate: Claim.wrap(bytes32(0)), + cannonKonaPrestate: Claim.wrap(bytes32(hex"ABBA")) + }), + abi.encodeWithSelector(IOPContractsManager.PrestateRequired.selector) + ); + } +} + +/// @title OPContractsManager_UpdatePrestate_CannonKonaEnabled_Test +/// @notice Tests the `updatePrestate` function of the `OPContractsManager` contract with CANNON_KONA enabled. +contract OPContractsManager_UpdatePrestate_CannonKonaEnabled_Test is OPContractsManager_UpdatePrestate_Test { + function setUp() public override { + setDevFeatureEnabled(DevFeatures.CANNON_KONA); + super.setUp(); + } + + /// @notice Tests that we can update the prestate for both CANNON and CANNON_KONA game types. + function test_updatePrestate_bothGamesAndCannonKonaWithValidInput_succeeds() public { + // Add a FaultDisputeGame implementation via addGameType. + IOPContractsManager.AddGameInput memory input = newGameInputFactory(GameTypes.CANNON); + addGameType(input); + input = newGameInputFactory(GameTypes.CANNON_KONA); + addGameType(input); + + Claim cannonPrestate = Claim.wrap(bytes32(hex"ABBA")); + Claim cannonKonaPrestate = Claim.wrap(bytes32(hex"ADDA")); + _runUpdatePrestateAndChecks( + IOPContractsManager.UpdatePrestateInput({ + systemConfigProxy: chainDeployOutput1.systemConfigProxy, + cannonPrestate: cannonPrestate, + cannonKonaPrestate: cannonKonaPrestate + }) + ); + } + + function test_updatePrestate_cannonKonaWithSuperGame_succeeds() public { // Mock out the existence of a previous SuperPermissionedDisputeGame so we can add a real // SuperPermissionedDisputeGame implementation. vm.mockCall( @@ -894,15 +1084,15 @@ contract OPContractsManager_UpdatePrestate_Test is OPContractsManager_TestInit { ); // Add a SuperPermissionedDisputeGame implementation via addGameType. - IOPContractsManager.AddGameInput memory input1 = newGameInputFactory({ permissioned: true }); - input1.disputeGameType = GameTypes.SUPER_PERMISSIONED_CANNON; + IOPContractsManager.AddGameInput memory input1 = newGameInputFactory(GameTypes.SUPER_PERMISSIONED_CANNON); addGameType(input1); vm.clearMockedCalls(); // Add a SuperFaultDisputeGame implementation via addGameType. - IOPContractsManager.AddGameInput memory input2 = newGameInputFactory({ permissioned: false }); - input2.disputeGameType = GameTypes.SUPER_CANNON; + IOPContractsManager.AddGameInput memory input2 = newGameInputFactory(GameTypes.SUPER_CANNON); addGameType(input2); + IOPContractsManager.AddGameInput memory input3 = newGameInputFactory(GameTypes.SUPER_CANNON_KONA); + addGameType(input3); // Clear out the PermissionedDisputeGame implementation. address owner = chainDeployOutput1.disputeGameFactoryProxy.owner(); @@ -912,11 +1102,14 @@ contract OPContractsManager_UpdatePrestate_Test is OPContractsManager_TestInit { ); // Create the input for the function call. - Claim prestate = Claim.wrap(bytes32(hex"ABBA")); - IOPContractsManager.OpChainConfig[] memory inputs = new IOPContractsManager.OpChainConfig[](1); - inputs[0] = IOPContractsManager.OpChainConfig( - chainDeployOutput1.systemConfigProxy, chainDeployOutput1.opChainProxyAdmin, prestate - ); + Claim cannonPrestate = Claim.wrap(bytes32(hex"ABBA")); + Claim cannonKonaPrestate = Claim.wrap(bytes32(hex"ABBA")); + IOPContractsManager.UpdatePrestateInput[] memory inputs = new IOPContractsManager.UpdatePrestateInput[](1); + inputs[0] = IOPContractsManager.UpdatePrestateInput({ + systemConfigProxy: chainDeployOutput1.systemConfigProxy, + cannonPrestate: cannonPrestate, + cannonKonaPrestate: cannonKonaPrestate + }); // Turn the ProxyAdmin owner into a DelegateCaller. address proxyAdminOwner = chainDeployOutput1.opChainProxyAdmin.owner(); @@ -927,7 +1120,6 @@ contract OPContractsManager_UpdatePrestate_Test is OPContractsManager_TestInit { address(prestateUpdater), abi.encodeCall(IOPContractsManager.updatePrestate, (inputs)) ); - // Grab the SuperPermissionedDisputeGame. IPermissionedDisputeGame pdg = IPermissionedDisputeGame( address( IDisputeGameFactory(chainDeployOutput1.systemConfigProxy.disputeGameFactory()).gameImpls( @@ -936,102 +1128,101 @@ contract OPContractsManager_UpdatePrestate_Test is OPContractsManager_TestInit { ) ); - // Grab the SuperFaultDisputeGame. - IPermissionedDisputeGame fdg = IPermissionedDisputeGame( + IFaultDisputeGame fdg = IFaultDisputeGame( address( IDisputeGameFactory(chainDeployOutput1.systemConfigProxy.disputeGameFactory()).gameImpls( GameTypes.SUPER_CANNON ) ) ); + IFaultDisputeGame fdgKona = IFaultDisputeGame( + address( + IDisputeGameFactory(chainDeployOutput1.systemConfigProxy.disputeGameFactory()).gameImpls( + GameTypes.SUPER_CANNON_KONA + ) + ) + ); // Check the prestate values. - assertEq(pdg.absolutePrestate().raw(), prestate.raw(), "pdg prestate mismatch"); - assertEq(fdg.absolutePrestate().raw(), prestate.raw(), "fdg prestate mismatch"); + assertEq(pdg.absolutePrestate().raw(), cannonPrestate.raw(), "pdg prestate mismatch"); + assertEq(fdg.absolutePrestate().raw(), cannonPrestate.raw(), "fdg prestate mismatch"); + assertEq(fdgKona.absolutePrestate().raw(), cannonKonaPrestate.raw(), "fdgKona prestate mismatch"); // Ensure that the WETH contracts are not reverting pdg.weth().balanceOf(address(0)); fdg.weth().balanceOf(address(0)); + fdgKona.weth().balanceOf(address(0)); } - function test_updatePrestate_mixedGameTypes_reverts() public { - // Add a SuperFaultDisputeGame implementation via addGameType. - IOPContractsManager.AddGameInput memory input = newGameInputFactory({ permissioned: false }); - input.disputeGameType = GameTypes.SUPER_CANNON; + /// @notice Tests that we can update the prestate when both the PermissionedDisputeGame and + /// FaultDisputeGame exist, and the FaultDisputeGame is of type CANNON_KONA. + function test_updatePrestate_pdgAndCannonKonaOnly_succeeds() public { + IOPContractsManager.AddGameInput memory input = newGameInputFactory(GameTypes.CANNON_KONA); addGameType(input); - // Create the input for the function call. - Claim prestate = Claim.wrap(bytes32(hex"ABBA")); - IOPContractsManager.OpChainConfig[] memory inputs = new IOPContractsManager.OpChainConfig[](1); - inputs[0] = IOPContractsManager.OpChainConfig( - chainDeployOutput1.systemConfigProxy, chainDeployOutput1.opChainProxyAdmin, prestate + _runUpdatePrestateAndChecks( + IOPContractsManager.UpdatePrestateInput({ + systemConfigProxy: chainDeployOutput1.systemConfigProxy, + cannonPrestate: Claim.wrap(bytes32(hex"ABBA")), + cannonKonaPrestate: Claim.wrap(bytes32(hex"ADDA")) + }) ); + } - // Turn the ProxyAdmin owner into a DelegateCaller. - address proxyAdminOwner = chainDeployOutput1.opChainProxyAdmin.owner(); - vm.etch(address(proxyAdminOwner), vm.getDeployedCode("test/mocks/Callers.sol:DelegateCaller")); + /// @notice Tests that the updatePrestate function will revert if the provided prestate is for + /// mixed game types (i.e. CANNON and SUPER_CANNON_KONA). + function test_updatePrestate_cannonKonaMixedGameTypes_reverts() public { + // Add a SuperFaultDisputeGame implementation via addGameType. + IOPContractsManager.AddGameInput memory input = newGameInputFactory(GameTypes.SUPER_CANNON_KONA); + addGameType(input); - // Trigger the updatePrestate function, should revert. - vm.expectRevert(IOPContractsManagerGameTypeAdder.OPContractsManagerGameTypeAdder_MixedGameTypes.selector); - DelegateCaller(proxyAdminOwner).dcForward( - address(prestateUpdater), abi.encodeCall(IOPContractsManager.updatePrestate, (inputs)) + // nosemgrep: sol-style-use-abi-encodecall + _runUpdatePrestateAndChecks( + IOPContractsManager.UpdatePrestateInput({ + systemConfigProxy: chainDeployOutput1.systemConfigProxy, + cannonPrestate: Claim.wrap(bytes32(hex"ABBA")), + cannonKonaPrestate: Claim.wrap(hex"ADDA") + }), + abi.encodeWithSelector( + IOPContractsManagerGameTypeAdder.OPContractsManagerGameTypeAdder_MixedGameTypes.selector + ) ); } /// @notice Tests that the updatePrestate function will revert if the provided prestate is the /// zero hash. - function test_updatePrestate_whenPDGPrestateIsZero_reverts() public { - // Create the input for the function call. - IOPContractsManager.OpChainConfig[] memory inputs = new IOPContractsManager.OpChainConfig[](1); - inputs[0] = IOPContractsManager.OpChainConfig({ - systemConfigProxy: chainDeployOutput1.systemConfigProxy, - proxyAdmin: chainDeployOutput1.opChainProxyAdmin, - absolutePrestate: Claim.wrap(bytes32(0)) - }); - - // Turn the ProxyAdmin owner into a DelegateCaller. - address proxyAdminOwner = chainDeployOutput1.opChainProxyAdmin.owner(); - vm.etch(address(proxyAdminOwner), vm.getDeployedCode("test/mocks/Callers.sol:DelegateCaller")); + function test_updatePrestate_presetCannonKonaWhenOnlyCannonPrestateIsZeroAndCannonGameTypeDisabled_reverts() + public + { + IOPContractsManager.AddGameInput memory input = newGameInputFactory(GameTypes.CANNON_KONA); + addGameType(input); - // Trigger the updatePrestate function, should revert. - vm.expectRevert(IOPContractsManager.PrestateRequired.selector); - DelegateCaller(proxyAdminOwner).dcForward( - address(prestateUpdater), abi.encodeCall(IOPContractsManager.updatePrestate, (inputs)) + // nosemgrep: sol-style-use-abi-encodecall + _runUpdatePrestateAndChecks( + IOPContractsManager.UpdatePrestateInput({ + systemConfigProxy: chainDeployOutput1.systemConfigProxy, + cannonPrestate: Claim.wrap(bytes32(0)), + cannonKonaPrestate: Claim.wrap(bytes32(hex"ABBA")) + }), + abi.encodeWithSelector(IOPContractsManager.PrestateRequired.selector) ); } - function addGameType(IOPContractsManager.AddGameInput memory input) - internal - returns (IOPContractsManager.AddGameOutput memory) - { - IOPContractsManager.AddGameInput[] memory inputs = new IOPContractsManager.AddGameInput[](1); - inputs[0] = input; - - (bool success, bytes memory rawGameOut) = - address(opcm).delegatecall(abi.encodeCall(IOPContractsManager.addGameType, (inputs))); - assertTrue(success, "addGameType failed"); - - IOPContractsManager.AddGameOutput[] memory addGameOutAll = - abi.decode(rawGameOut, (IOPContractsManager.AddGameOutput[])); - return addGameOutAll[0]; - } + /// @notice Tests that the updatePrestate function will revert if the provided prestate is the + /// zero hash. + function test_updatePrestate_whenCannonKonaPrestateIsZero_reverts() public { + IOPContractsManager.AddGameInput memory input = newGameInputFactory(GameTypes.CANNON_KONA); + addGameType(input); - function newGameInputFactory(bool permissioned) internal view returns (IOPContractsManager.AddGameInput memory) { - return IOPContractsManager.AddGameInput({ - saltMixer: "hello", - systemConfig: chainDeployOutput1.systemConfigProxy, - proxyAdmin: chainDeployOutput1.opChainProxyAdmin, - delayedWETH: IDelayedWETH(payable(address(0))), - disputeGameType: GameType.wrap(permissioned ? 1 : 0), - disputeAbsolutePrestate: Claim.wrap(bytes32(hex"deadbeef1234")), - disputeMaxGameDepth: 73, - disputeSplitDepth: 30, - disputeClockExtension: Duration.wrap(10800), - disputeMaxClockDuration: Duration.wrap(302400), - initialBond: 1 ether, - vm: IBigStepper(address(opcm.implementations().mipsImpl)), - permissioned: permissioned - }); + // nosemgrep: sol-style-use-abi-encodecall + _runUpdatePrestateAndChecks( + IOPContractsManager.UpdatePrestateInput({ + systemConfigProxy: chainDeployOutput1.systemConfigProxy, + cannonPrestate: Claim.wrap(bytes32(hex"ABBA")), + cannonKonaPrestate: Claim.wrap(bytes32(0)) + }), + abi.encodeWithSelector(IOPContractsManager.PrestateRequired.selector) + ); } } From 05ba528ae52a48efc2cde8e0e0390cf47ad5f4ad Mon Sep 17 00:00:00 2001 From: George Knee Date: Fri, 3 Oct 2025 21:35:44 +0100 Subject: [PATCH 004/117] op-service/L1BeaconClient: allow blob proof verification to be skipped via `l1.beacon.skip-blob-verification` flag (#17713) * op-service/L1BeaconClient: allow blob proof verification to be skipped via CLI flag * assign parameter correctly * add test at the L1BeaconClient level * move skip boolean into existing config struct * tweak flag description --- op-node/config/beacon.go | 16 ++-- op-node/flags/flags.go | 9 +++ op-node/node/node.go | 3 +- op-node/service.go | 11 +-- op-service/sources/l1_beacon_client.go | 15 ++-- op-service/sources/l1_beacon_client_test.go | 84 +++++++++++++++++++-- 6 files changed, 114 insertions(+), 24 deletions(-) diff --git a/op-node/config/beacon.go b/op-node/config/beacon.go index 2de46e217aa..679deba22d1 100644 --- a/op-node/config/beacon.go +++ b/op-node/config/beacon.go @@ -19,15 +19,17 @@ type L1BeaconEndpointSetup interface { // ShouldIgnoreBeaconCheck returns true if the Beacon-node version check should not halt startup. ShouldIgnoreBeaconCheck() bool ShouldFetchAllSidecars() bool + ShouldSkipBlobVerification() bool Check() error } type L1BeaconEndpointConfig struct { - BeaconAddr string // Address of L1 User Beacon-API endpoint to use (beacon namespace required) - BeaconHeader string // Optional HTTP header for all requests to L1 Beacon - BeaconFallbackAddrs []string // Addresses of L1 Beacon-API fallback endpoints (only for blob sidecars retrieval) - BeaconCheckIgnore bool // When false, halt startup if the beacon version endpoint fails - BeaconFetchAllSidecars bool // Whether to fetch all blob sidecars and filter locally + BeaconAddr string // Address of L1 User Beacon-API endpoint to use (beacon namespace required) + BeaconHeader string // Optional HTTP header for all requests to L1 Beacon + BeaconFallbackAddrs []string // Addresses of L1 Beacon-API fallback endpoints (only for blob sidecars retrieval) + BeaconCheckIgnore bool // When false, halt startup if the beacon version endpoint fails + BeaconFetchAllSidecars bool // Whether to fetch all blob sidecars and filter locally + BeaconSkipBlobVerification bool // Whether to skip the verification of the kzg_proof for each blob returned by the Beacon node } var _ L1BeaconEndpointSetup = (*L1BeaconEndpointConfig)(nil) @@ -66,6 +68,10 @@ func (cfg *L1BeaconEndpointConfig) ShouldFetchAllSidecars() bool { return cfg.BeaconFetchAllSidecars } +func (cfg *L1BeaconEndpointConfig) ShouldSkipBlobVerification() bool { + return cfg.BeaconSkipBlobVerification +} + func parseHTTPHeader(headerStr string) (http.Header, error) { h := make(http.Header, 1) s := strings.SplitN(headerStr, ": ", 2) diff --git a/op-node/flags/flags.go b/op-node/flags/flags.go index d98e959a295..d7ff28eb468 100644 --- a/op-node/flags/flags.go +++ b/op-node/flags/flags.go @@ -107,6 +107,14 @@ var ( EnvVars: prefixEnvVars("L1_BEACON_FETCH_ALL_SIDECARS"), Category: L1RPCCategory, } + BeaconSkipBlobVerification = &cli.BoolFlag{ + Name: "l1.beacon.skip-blob-verification", + Usage: "If true, skips the verification of the kzg_proof for each blob returned by the Beacon node. Not recommended unless the provided beacon endpoints are trusted.", + Required: false, + Value: false, + EnvVars: prefixEnvVars("L1_BEACON_SKIP_BLOB_VERIFICATION"), + Category: L1RPCCategory, + } SyncModeFlag = &cli.GenericFlag{ Name: "syncmode", Usage: fmt.Sprintf("Blockchain sync mode (options: %s)", openum.EnumString(sync.ModeStrings)), @@ -434,6 +442,7 @@ var optionalFlags = []cli.Flag{ BeaconFallbackAddrs, BeaconCheckIgnore, BeaconFetchAllSidecars, + BeaconSkipBlobVerification, SyncModeFlag, FetchWithdrawalRootFromState, L1TrustRPC, diff --git a/op-node/node/node.go b/op-node/node/node.go index 2cf93f6800e..960e822434e 100644 --- a/op-node/node/node.go +++ b/op-node/node/node.go @@ -362,7 +362,8 @@ func (n *OpNode) initL1BeaconAPI(ctx context.Context, cfg *config.Config) error return fmt.Errorf("failed to setup L1 Beacon API client: %w", err) } beaconCfg := sources.L1BeaconClientConfig{ - FetchAllSidecars: cfg.Beacon.ShouldFetchAllSidecars(), + FetchAllSidecars: cfg.Beacon.ShouldFetchAllSidecars(), + SkipBlobVerification: cfg.Beacon.ShouldSkipBlobVerification(), } n.beacon = sources.NewL1BeaconClient(beaconClient, beaconCfg, fallbacks...) diff --git a/op-node/service.go b/op-node/service.go index af72a6c4b78..875b366bee8 100644 --- a/op-node/service.go +++ b/op-node/service.go @@ -158,11 +158,12 @@ func NewSupervisorEndpointConfig(ctx *cli.Context) *interop.Config { func NewBeaconEndpointConfig(ctx *cli.Context) config.L1BeaconEndpointSetup { return &config.L1BeaconEndpointConfig{ - BeaconAddr: ctx.String(flags.BeaconAddr.Name), - BeaconHeader: ctx.String(flags.BeaconHeader.Name), - BeaconFallbackAddrs: ctx.StringSlice(flags.BeaconFallbackAddrs.Name), - BeaconCheckIgnore: ctx.Bool(flags.BeaconCheckIgnore.Name), - BeaconFetchAllSidecars: ctx.Bool(flags.BeaconFetchAllSidecars.Name), + BeaconAddr: ctx.String(flags.BeaconAddr.Name), + BeaconHeader: ctx.String(flags.BeaconHeader.Name), + BeaconFallbackAddrs: ctx.StringSlice(flags.BeaconFallbackAddrs.Name), + BeaconCheckIgnore: ctx.Bool(flags.BeaconCheckIgnore.Name), + BeaconFetchAllSidecars: ctx.Bool(flags.BeaconFetchAllSidecars.Name), + BeaconSkipBlobVerification: ctx.Bool(flags.BeaconSkipBlobVerification.Name), } } diff --git a/op-service/sources/l1_beacon_client.go b/op-service/sources/l1_beacon_client.go index 0999d279ddd..f6586de8d40 100644 --- a/op-service/sources/l1_beacon_client.go +++ b/op-service/sources/l1_beacon_client.go @@ -28,7 +28,8 @@ const ( ) type L1BeaconClientConfig struct { - FetchAllSidecars bool + FetchAllSidecars bool + SkipBlobVerification bool } // L1BeaconClient is a high level golang client for the Beacon API. @@ -271,14 +272,14 @@ func (cl *L1BeaconClient) GetBlobs(ctx context.Context, ref eth.L1BlockRef, hash if err != nil { return nil, fmt.Errorf("failed to get blob sidecars for L1BlockRef %s: %w", ref, err) } - blobs, err := blobsFromSidecars(blobSidecars, hashes) + blobs, err := blobsFromSidecars(blobSidecars, hashes, cl.cfg.SkipBlobVerification) if err != nil { return nil, fmt.Errorf("failed to get blobs from sidecars for L1BlockRef %s: %w", ref, err) } return blobs, nil } -func blobsFromSidecars(blobSidecars []*eth.BlobSidecar, hashes []eth.IndexedBlobHash) ([]*eth.Blob, error) { +func blobsFromSidecars(blobSidecars []*eth.BlobSidecar, hashes []eth.IndexedBlobHash, skipBlobVerification bool) ([]*eth.Blob, error) { if len(blobSidecars) != len(hashes) { return nil, fmt.Errorf("number of hashes and blobSidecars mismatch, %d != %d", len(hashes), len(blobSidecars)) } @@ -296,9 +297,11 @@ func blobsFromSidecars(blobSidecars []*eth.BlobSidecar, hashes []eth.IndexedBlob return nil, fmt.Errorf("expected hash %s for blob at index %d but got %s", ih.Hash, ih.Index, hash) } - // confirm blob data is valid by verifying its proof against the commitment - if err := eth.VerifyBlobProof(&sidecar.Blob, kzg4844.Commitment(sidecar.KZGCommitment), kzg4844.Proof(sidecar.KZGProof)); err != nil { - return nil, fmt.Errorf("blob at index %d failed verification: %w", i, err) + if !skipBlobVerification { + // confirm blob data is valid by verifying its proof against the commitment + if err := eth.VerifyBlobProof(&sidecar.Blob, kzg4844.Commitment(sidecar.KZGCommitment), kzg4844.Proof(sidecar.KZGProof)); err != nil { + return nil, fmt.Errorf("blob at index %d failed verification: %w", i, err) + } } out[i] = &sidecar.Blob } diff --git a/op-service/sources/l1_beacon_client_test.go b/op-service/sources/l1_beacon_client_test.go index 8e312f3c8eb..2a6cfafba0a 100644 --- a/op-service/sources/l1_beacon_client_test.go +++ b/op-service/sources/l1_beacon_client_test.go @@ -13,8 +13,10 @@ import ( "strconv" "testing" + "github.com/stretchr/testify/assert" "github.com/stretchr/testify/require" + "github.com/ethereum/go-ethereum/common/hexutil" "github.com/ethereum/go-ethereum/crypto/kzg4844" client_mocks "github.com/ethereum-optimism/optimism/op-service/client/mocks" @@ -61,17 +63,17 @@ func TestBlobsFromSidecars(t *testing.T) { // put the sidecars in scrambled order to confirm error sidecars := []*eth.BlobSidecar{sidecar2, sidecar0, sidecar1} - _, err := blobsFromSidecars(sidecars, hashes) + _, err := blobsFromSidecars(sidecars, hashes, false) require.Error(t, err) // too few sidecars should error sidecars = []*eth.BlobSidecar{sidecar0, sidecar1} - _, err = blobsFromSidecars(sidecars, hashes) + _, err = blobsFromSidecars(sidecars, hashes, false) require.Error(t, err) // correct order should work sidecars = []*eth.BlobSidecar{sidecar0, sidecar1, sidecar2} - blobs, err := blobsFromSidecars(sidecars, hashes) + blobs, err := blobsFromSidecars(sidecars, hashes, false) require.NoError(t, err) // confirm order by checking first blob byte against expected index for i := range blobs { @@ -82,27 +84,65 @@ func TestBlobsFromSidecars(t *testing.T) { badProof := *sidecar0 badProof.KZGProof[11]++ sidecars[1] = &badProof - _, err = blobsFromSidecars(sidecars, hashes) + _, err = blobsFromSidecars(sidecars, hashes, false) require.Error(t, err) // mangle a commitment to make sure it's detected badCommitment := *sidecar0 badCommitment.KZGCommitment[13]++ sidecars[1] = &badCommitment - _, err = blobsFromSidecars(sidecars, hashes) + _, err = blobsFromSidecars(sidecars, hashes, false) require.Error(t, err) // mangle a hash to make sure it's detected sidecars[1] = sidecar0 hashes[2].Hash[17]++ - _, err = blobsFromSidecars(sidecars, hashes) + _, err = blobsFromSidecars(sidecars, hashes, false) require.Error(t, err) + +} + +func KZGProofFromHex(s string) (kzg4844.Proof, error) { + var out kzg4844.Proof // underlying size is 48 bytes + b, err := hexutil.Decode(s) + if err != nil { + return out, err + } + if len(b) != 48 { + return out, fmt.Errorf("want 48 bytes, got %d", len(b)) + } + copy(out[:], b) + return out, nil +} + +var badProof, _ = KZGProofFromHex("0xc00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000") + +func TestBlobsFromSidecars_SkipBlobVerification(t *testing.T) { + indices := []uint64{5, 7, 2} + index0, sidecar0 := makeTestBlobSidecar(indices[0]) + index1, sidecar1 := makeTestBlobSidecar(indices[1]) + index2, sidecar2 := makeTestBlobSidecar(indices[2]) + hashes := []eth.IndexedBlobHash{index0, index1, index2} + + sidecars := []*eth.BlobSidecar{sidecar0, sidecar1, sidecar2} + + // Set proof to a bad / stubbed value + sidecars[1].KZGProof = eth.Bytes48(badProof) + + // Check that verification succeeds when skipBlobVerification is true + _, err := blobsFromSidecars(sidecars, hashes, true) + require.NoError(t, err) + + // Check that verification fails when skipBlobVerification is false + _, err = blobsFromSidecars(sidecars, hashes, false) + require.Error(t, err) + } func TestBlobsFromSidecars_EmptySidecarList(t *testing.T) { hashes := []eth.IndexedBlobHash{} sidecars := []*eth.BlobSidecar{} - blobs, err := blobsFromSidecars(sidecars, hashes) + blobs, err := blobsFromSidecars(sidecars, hashes, false) require.NoError(t, err) require.Empty(t, blobs, "blobs should be empty when no sidecars are provided") } @@ -186,7 +226,37 @@ func TestBeaconClientFallback(t *testing.T) { resp, err = c.GetBlobSidecars(ctx, eth.L1BlockRef{Time: 14}, hashes) require.Equal(t, sidecars, resp) require.NoError(t, err) +} + +func TestBeaconClientSkipBlobVerification(t *testing.T) { + indices := []uint64{5, 7, 2} + index0, sidecar0 := makeTestBlobSidecar(indices[0]) + index1, sidecar1 := makeTestBlobSidecar(indices[1]) + index2, sidecar2 := makeTestBlobSidecar(indices[2]) + + hashes := []eth.IndexedBlobHash{index0, index1, index2} + sidecars := []*eth.BlobSidecar{sidecar0, sidecar1, sidecar2} + + // invalidate proof + sidecar1.KZGProof = eth.Bytes48(badProof) + apiSidecars := toAPISideCars(sidecars) + ctx := context.Background() + p := mocks.NewBeaconClient(t) + + p.EXPECT().BeaconGenesis(ctx).Return(eth.APIGenesisResponse{Data: eth.ReducedGenesisData{GenesisTime: 10}}, nil) + p.EXPECT().ConfigSpec(ctx).Return(eth.APIConfigResponse{Data: eth.ReducedConfigData{SecondsPerSlot: 2}}, nil) + clientWithValidation := NewL1BeaconClient(p, L1BeaconClientConfig{SkipBlobVerification: false}) + p.EXPECT().BeaconBlobSideCars(ctx, false, uint64(1), hashes).Return(eth.APIGetBlobSidecarsResponse{Data: apiSidecars}, nil) + _, err := clientWithValidation.GetBlobs(ctx, eth.L1BlockRef{Time: 12}, hashes) + assert.Error(t, err) + + p.EXPECT().BeaconGenesis(ctx).Return(eth.APIGenesisResponse{Data: eth.ReducedGenesisData{GenesisTime: 10}}, nil) + p.EXPECT().ConfigSpec(ctx).Return(eth.APIConfigResponse{Data: eth.ReducedConfigData{SecondsPerSlot: 2}}, nil) + clientWithoutValidation := NewL1BeaconClient(p, L1BeaconClientConfig{SkipBlobVerification: true}) + p.EXPECT().BeaconBlobSideCars(ctx, false, uint64(1), hashes).Return(eth.APIGetBlobSidecarsResponse{Data: apiSidecars}, nil) + _, err = clientWithoutValidation.GetBlobs(ctx, eth.L1BlockRef{Time: 12}, hashes) + assert.NoError(t, err) } func TestBeaconHTTPClient(t *testing.T) { From 3ee883bcfb1b6ac4717ae430a84e92d08359c21f Mon Sep 17 00:00:00 2001 From: Paul Dowman Date: Fri, 3 Oct 2025 15:31:58 -0600 Subject: [PATCH 005/117] Add `skip-blob-verification` flag to op-program and op-challenger (#17718) * op-program: Add skip-blob-verification flag * op-challenger: add flag to skip blob verification * Soften warning message for skip blob verification --- op-challenger/config/config.go | 149 ++++++++------- op-challenger/flags/flags.go | 172 ++++++++++-------- op-challenger/game/fault/trace/vm/executor.go | 23 +-- .../fault/trace/vm/kona_server_executor.go | 4 + .../trace/vm/kona_server_executor_test.go | 73 ++++++++ .../trace/vm/kona_super_server_executor.go | 4 + .../trace/vm/op_program_server_executor.go | 3 + .../vm/op_program_server_executor_test.go | 18 +- op-program/host/config/config.go | 56 +++--- op-program/host/config/config_test.go | 21 +++ op-program/host/flags/flags.go | 7 + op-program/host/host.go | 5 +- 12 files changed, 345 insertions(+), 190 deletions(-) diff --git a/op-challenger/config/config.go b/op-challenger/config/config.go index 874acdcd145..d53eec9048d 100644 --- a/op-challenger/config/config.go +++ b/op-challenger/config/config.go @@ -65,16 +65,17 @@ const ( // This also contains config options for auxiliary services. // It is used to initialize the challenger. type Config struct { - L1EthRpc string // L1 RPC Url - L1Beacon string // L1 Beacon API Url - GameFactoryAddress common.Address // Address of the dispute game factory - GameAllowlist []common.Address // Allowlist of fault game addresses - GameWindow time.Duration // Maximum time duration to look for games to progress - Datadir string // Data Directory - MaxConcurrency uint // Maximum number of threads to use when progressing games - PollInterval time.Duration // Polling interval for latest-block subscription when using an HTTP RPC provider - AllowInvalidPrestate bool // Whether to allow responding to games where the prestate does not match - MinUpdateInterval time.Duration // Minimum duration the L1 head block time must advance before scheduling a new update cycle + L1EthRpc string // L1 RPC Url + L1Beacon string // L1 Beacon API Url + L1BeaconSkipBlobVerification bool // Skip verification of the KZG proof for each blob. Not recommended unless the provided beacon endpoints are trusted. + GameFactoryAddress common.Address // Address of the dispute game factory + GameAllowlist []common.Address // Allowlist of fault game addresses + GameWindow time.Duration // Maximum time duration to look for games to progress + Datadir string // Data Directory + MaxConcurrency uint // Maximum number of threads to use when progressing games + PollInterval time.Duration // Polling interval for latest-block subscription when using an HTTP RPC provider + AllowInvalidPrestate bool // Whether to allow responding to games where the prestate does not match + MinUpdateInterval time.Duration // Minimum duration the L1 head block time must advance before scheduling a new update cycle AdditionalBondClaimants []common.Address // List of addresses to claim bonds for in addition to the tx manager sender @@ -151,42 +152,46 @@ func NewInteropConfig( Datadir: datadir, Cannon: vm.Config{ - VmType: types.TraceTypeCannon, - L1: l1EthRpc, - L1Beacon: l1BeaconApi, - L2s: l2Rpcs, - SnapshotFreq: DefaultCannonSnapshotFreq, - InfoFreq: DefaultCannonInfoFreq, - DebugInfo: true, - BinarySnapshots: true, + VmType: types.TraceTypeCannon, + L1: l1EthRpc, + L1Beacon: l1BeaconApi, + L1BeaconSkipBlobVerification: false, + L2s: l2Rpcs, + SnapshotFreq: DefaultCannonSnapshotFreq, + InfoFreq: DefaultCannonInfoFreq, + DebugInfo: true, + BinarySnapshots: true, }, CannonKona: vm.Config{ - VmType: types.TraceTypeCannonKona, - L1: l1EthRpc, - L1Beacon: l1BeaconApi, - L2s: l2Rpcs, - SnapshotFreq: DefaultCannonSnapshotFreq, - InfoFreq: DefaultCannonInfoFreq, - DebugInfo: true, - BinarySnapshots: true, + VmType: types.TraceTypeCannonKona, + L1: l1EthRpc, + L1Beacon: l1BeaconApi, + L1BeaconSkipBlobVerification: false, + L2s: l2Rpcs, + SnapshotFreq: DefaultCannonSnapshotFreq, + InfoFreq: DefaultCannonInfoFreq, + DebugInfo: true, + BinarySnapshots: true, }, Asterisc: vm.Config{ - VmType: types.TraceTypeAsterisc, - L1: l1EthRpc, - L1Beacon: l1BeaconApi, - L2s: l2Rpcs, - SnapshotFreq: DefaultAsteriscSnapshotFreq, - InfoFreq: DefaultAsteriscInfoFreq, - BinarySnapshots: true, + VmType: types.TraceTypeAsterisc, + L1: l1EthRpc, + L1Beacon: l1BeaconApi, + L1BeaconSkipBlobVerification: false, + L2s: l2Rpcs, + SnapshotFreq: DefaultAsteriscSnapshotFreq, + InfoFreq: DefaultAsteriscInfoFreq, + BinarySnapshots: true, }, AsteriscKona: vm.Config{ - VmType: types.TraceTypeAsteriscKona, - L1: l1EthRpc, - L1Beacon: l1BeaconApi, - L2s: l2Rpcs, - SnapshotFreq: DefaultAsteriscSnapshotFreq, - InfoFreq: DefaultAsteriscInfoFreq, - BinarySnapshots: true, + VmType: types.TraceTypeAsteriscKona, + L1: l1EthRpc, + L1Beacon: l1BeaconApi, + L1BeaconSkipBlobVerification: false, + L2s: l2Rpcs, + SnapshotFreq: DefaultAsteriscSnapshotFreq, + InfoFreq: DefaultAsteriscInfoFreq, + BinarySnapshots: true, }, GameWindow: DefaultGameWindow, } @@ -221,42 +226,46 @@ func NewConfig( Datadir: datadir, Cannon: vm.Config{ - VmType: types.TraceTypeCannon, - L1: l1EthRpc, - L1Beacon: l1BeaconApi, - L2s: []string{l2EthRpc}, - SnapshotFreq: DefaultCannonSnapshotFreq, - InfoFreq: DefaultCannonInfoFreq, - DebugInfo: true, - BinarySnapshots: true, + VmType: types.TraceTypeCannon, + L1: l1EthRpc, + L1Beacon: l1BeaconApi, + L1BeaconSkipBlobVerification: false, + L2s: []string{l2EthRpc}, + SnapshotFreq: DefaultCannonSnapshotFreq, + InfoFreq: DefaultCannonInfoFreq, + DebugInfo: true, + BinarySnapshots: true, }, CannonKona: vm.Config{ - VmType: types.TraceTypeCannonKona, - L1: l1EthRpc, - L1Beacon: l1BeaconApi, - L2s: []string{l2EthRpc}, - SnapshotFreq: DefaultCannonSnapshotFreq, - InfoFreq: DefaultCannonInfoFreq, - DebugInfo: true, - BinarySnapshots: true, + VmType: types.TraceTypeCannonKona, + L1: l1EthRpc, + L1Beacon: l1BeaconApi, + L1BeaconSkipBlobVerification: false, + L2s: []string{l2EthRpc}, + SnapshotFreq: DefaultCannonSnapshotFreq, + InfoFreq: DefaultCannonInfoFreq, + DebugInfo: true, + BinarySnapshots: true, }, Asterisc: vm.Config{ - VmType: types.TraceTypeAsterisc, - L1: l1EthRpc, - L1Beacon: l1BeaconApi, - L2s: []string{l2EthRpc}, - SnapshotFreq: DefaultAsteriscSnapshotFreq, - InfoFreq: DefaultAsteriscInfoFreq, - BinarySnapshots: true, + VmType: types.TraceTypeAsterisc, + L1: l1EthRpc, + L1Beacon: l1BeaconApi, + L1BeaconSkipBlobVerification: false, + L2s: []string{l2EthRpc}, + SnapshotFreq: DefaultAsteriscSnapshotFreq, + InfoFreq: DefaultAsteriscInfoFreq, + BinarySnapshots: true, }, AsteriscKona: vm.Config{ - VmType: types.TraceTypeAsteriscKona, - L1: l1EthRpc, - L1Beacon: l1BeaconApi, - L2s: []string{l2EthRpc}, - SnapshotFreq: DefaultAsteriscSnapshotFreq, - InfoFreq: DefaultAsteriscInfoFreq, - BinarySnapshots: true, + VmType: types.TraceTypeAsteriscKona, + L1: l1EthRpc, + L1Beacon: l1BeaconApi, + L1BeaconSkipBlobVerification: false, + L2s: []string{l2EthRpc}, + SnapshotFreq: DefaultAsteriscSnapshotFreq, + InfoFreq: DefaultAsteriscInfoFreq, + BinarySnapshots: true, }, GameWindow: DefaultGameWindow, } diff --git a/op-challenger/flags/flags.go b/op-challenger/flags/flags.go index a911eaaf1bf..4f4a16ac08c 100644 --- a/op-challenger/flags/flags.go +++ b/op-challenger/flags/flags.go @@ -283,6 +283,13 @@ var ( EnvVars: prefixEnvVars("RESPONSE_DELAY_AFTER"), Value: config.DefaultResponseDelayAfter, } + L1BeaconSkipBlobVerificationFlag = &cli.BoolFlag{ + Name: "l1-beacon-skip-blob-verification", + Usage: "Skip verification of the KZG proof for each blob returned by the Beacon node. Not recommended unless the provided beacon endpoints are trusted.", + EnvVars: prefixEnvVars("L1_BEACON_SKIP_BLOB_VERIFICATION"), + Value: false, + Hidden: true, + } ) // requiredFlags are checked by [CheckRequired] @@ -330,6 +337,7 @@ var optionalFlags = []cli.Flag{ ResponseDelayFlag, ResponseDelayAfterFlag, L1GenesisFlag, + L1BeaconSkipBlobVerificationFlag, } func init() { @@ -695,103 +703,109 @@ func NewConfigFromCLI(ctx *cli.Context, logger log.Logger) (*config.Config, erro networks := ctx.StringSlice(flags.NetworkFlagName) l1EthRpc := ctx.String(L1EthRpcFlag.Name) l1Beacon := ctx.String(L1BeaconFlag.Name) + l1BeaconSkipBlobVerification := ctx.Bool(L1BeaconSkipBlobVerificationFlag.Name) l2Rpcs := ctx.StringSlice(L2EthRpcFlag.Name) l2Experimental := ctx.String(L2ExperimentalEthRpcFlag.Name) return &config.Config{ // Required Flags - L1EthRpc: l1EthRpc, - L1Beacon: l1Beacon, - TraceTypes: traceTypes, - GameFactoryAddress: gameFactoryAddress, - GameAllowlist: allowedGames, - GameWindow: ctx.Duration(GameWindowFlag.Name), - MaxConcurrency: maxConcurrency, - L2Rpcs: l2Rpcs, - MaxPendingTx: ctx.Uint64(MaxPendingTransactionsFlag.Name), - PollInterval: ctx.Duration(HTTPPollInterval.Name), - MinUpdateInterval: ctx.Duration(MinUpdateInterval.Name), - AdditionalBondClaimants: claimants, - RollupRpc: ctx.String(RollupRpcFlag.Name), - SupervisorRPC: ctx.String(SupervisorRpcFlag.Name), + L1EthRpc: l1EthRpc, + L1Beacon: l1Beacon, + L1BeaconSkipBlobVerification: l1BeaconSkipBlobVerification, + TraceTypes: traceTypes, + GameFactoryAddress: gameFactoryAddress, + GameAllowlist: allowedGames, + GameWindow: ctx.Duration(GameWindowFlag.Name), + MaxConcurrency: maxConcurrency, + L2Rpcs: l2Rpcs, + MaxPendingTx: ctx.Uint64(MaxPendingTransactionsFlag.Name), + PollInterval: ctx.Duration(HTTPPollInterval.Name), + MinUpdateInterval: ctx.Duration(MinUpdateInterval.Name), + AdditionalBondClaimants: claimants, + RollupRpc: ctx.String(RollupRpcFlag.Name), + SupervisorRPC: ctx.String(SupervisorRpcFlag.Name), Cannon: vm.Config{ - L1GenesisPath: ctx.String(L1GenesisFlag.Name), - VmType: types.TraceTypeCannon, - L1: l1EthRpc, - L1Beacon: l1Beacon, - L2s: l2Rpcs, - L2Experimental: l2Experimental, - VmBin: ctx.String(CannonBinFlag.Name), - Server: ctx.String(CannonServerFlag.Name), - Networks: networks, - L2Custom: ctx.Bool(CannonL2CustomFlag.Name), - RollupConfigPaths: RollupConfigFlag.StringSlice(ctx, types.TraceTypeCannon), - L2GenesisPaths: L2GenesisFlag.StringSlice(ctx, types.TraceTypeCannon), - DepsetConfigPath: DepsetConfigFlag.String(ctx, types.TraceTypeCannon), - SnapshotFreq: ctx.Uint(CannonSnapshotFreqFlag.Name), - InfoFreq: ctx.Uint(CannonInfoFreqFlag.Name), - DebugInfo: true, - BinarySnapshots: true, + L1GenesisPath: ctx.String(L1GenesisFlag.Name), + VmType: types.TraceTypeCannon, + L1: l1EthRpc, + L1Beacon: l1Beacon, + L1BeaconSkipBlobVerification: l1BeaconSkipBlobVerification, + L2s: l2Rpcs, + L2Experimental: l2Experimental, + VmBin: ctx.String(CannonBinFlag.Name), + Server: ctx.String(CannonServerFlag.Name), + Networks: networks, + L2Custom: ctx.Bool(CannonL2CustomFlag.Name), + RollupConfigPaths: RollupConfigFlag.StringSlice(ctx, types.TraceTypeCannon), + L2GenesisPaths: L2GenesisFlag.StringSlice(ctx, types.TraceTypeCannon), + DepsetConfigPath: DepsetConfigFlag.String(ctx, types.TraceTypeCannon), + SnapshotFreq: ctx.Uint(CannonSnapshotFreqFlag.Name), + InfoFreq: ctx.Uint(CannonInfoFreqFlag.Name), + DebugInfo: true, + BinarySnapshots: true, }, CannonAbsolutePreState: ctx.String(CannonPreStateFlag.Name), CannonAbsolutePreStateBaseURL: cannonPreStatesURL, CannonKona: vm.Config{ - L1GenesisPath: ctx.String(L1GenesisFlag.Name), - VmType: types.TraceTypeCannonKona, - L1: l1EthRpc, - L1Beacon: l1Beacon, - L2s: l2Rpcs, - L2Experimental: l2Experimental, - VmBin: ctx.String(CannonBinFlag.Name), - Server: ctx.String(CannonKonaServerFlag.Name), - Networks: networks, - L2Custom: ctx.Bool(CannonKonaL2CustomFlag.Name), - RollupConfigPaths: RollupConfigFlag.StringSlice(ctx, types.TraceTypeCannonKona), - L2GenesisPaths: L2GenesisFlag.StringSlice(ctx, types.TraceTypeCannonKona), - DepsetConfigPath: DepsetConfigFlag.String(ctx, types.TraceTypeCannonKona), - SnapshotFreq: ctx.Uint(CannonSnapshotFreqFlag.Name), - InfoFreq: ctx.Uint(CannonInfoFreqFlag.Name), - DebugInfo: true, - BinarySnapshots: true, + L1GenesisPath: ctx.String(L1GenesisFlag.Name), + VmType: types.TraceTypeCannonKona, + L1: l1EthRpc, + L1Beacon: l1Beacon, + L1BeaconSkipBlobVerification: l1BeaconSkipBlobVerification, + L2s: l2Rpcs, + L2Experimental: l2Experimental, + VmBin: ctx.String(CannonBinFlag.Name), + Server: ctx.String(CannonKonaServerFlag.Name), + Networks: networks, + L2Custom: ctx.Bool(CannonKonaL2CustomFlag.Name), + RollupConfigPaths: RollupConfigFlag.StringSlice(ctx, types.TraceTypeCannonKona), + L2GenesisPaths: L2GenesisFlag.StringSlice(ctx, types.TraceTypeCannonKona), + DepsetConfigPath: DepsetConfigFlag.String(ctx, types.TraceTypeCannonKona), + SnapshotFreq: ctx.Uint(CannonSnapshotFreqFlag.Name), + InfoFreq: ctx.Uint(CannonInfoFreqFlag.Name), + DebugInfo: true, + BinarySnapshots: true, }, CannonKonaAbsolutePreState: ctx.String(CannonKonaPreStateFlag.Name), CannonKonaAbsolutePreStateBaseURL: cannonKonaPreStatesURL, Datadir: ctx.String(DatadirFlag.Name), Asterisc: vm.Config{ - L1GenesisPath: ctx.String(L1GenesisFlag.Name), - VmType: types.TraceTypeAsterisc, - L1: l1EthRpc, - L1Beacon: l1Beacon, - L2s: l2Rpcs, - L2Experimental: l2Experimental, - VmBin: ctx.String(AsteriscBinFlag.Name), - Server: ctx.String(AsteriscServerFlag.Name), - Networks: networks, - RollupConfigPaths: RollupConfigFlag.StringSlice(ctx, types.TraceTypeAsterisc), - L2GenesisPaths: L2GenesisFlag.StringSlice(ctx, types.TraceTypeAsterisc), - DepsetConfigPath: DepsetConfigFlag.String(ctx, types.TraceTypeAsterisc), - SnapshotFreq: ctx.Uint(AsteriscSnapshotFreqFlag.Name), - InfoFreq: ctx.Uint(AsteriscInfoFreqFlag.Name), - BinarySnapshots: true, + L1GenesisPath: ctx.String(L1GenesisFlag.Name), + VmType: types.TraceTypeAsterisc, + L1: l1EthRpc, + L1Beacon: l1Beacon, + L1BeaconSkipBlobVerification: l1BeaconSkipBlobVerification, + L2s: l2Rpcs, + L2Experimental: l2Experimental, + VmBin: ctx.String(AsteriscBinFlag.Name), + Server: ctx.String(AsteriscServerFlag.Name), + Networks: networks, + RollupConfigPaths: RollupConfigFlag.StringSlice(ctx, types.TraceTypeAsterisc), + L2GenesisPaths: L2GenesisFlag.StringSlice(ctx, types.TraceTypeAsterisc), + DepsetConfigPath: DepsetConfigFlag.String(ctx, types.TraceTypeAsterisc), + SnapshotFreq: ctx.Uint(AsteriscSnapshotFreqFlag.Name), + InfoFreq: ctx.Uint(AsteriscInfoFreqFlag.Name), + BinarySnapshots: true, }, AsteriscAbsolutePreState: ctx.String(AsteriscPreStateFlag.Name), AsteriscAbsolutePreStateBaseURL: asteriscPreStatesURL, AsteriscKona: vm.Config{ - L1GenesisPath: ctx.String(L1GenesisFlag.Name), - VmType: types.TraceTypeAsteriscKona, - L1: l1EthRpc, - L1Beacon: l1Beacon, - L2s: l2Rpcs, - L2Experimental: l2Experimental, - VmBin: ctx.String(AsteriscBinFlag.Name), - Server: ctx.String(AsteriscKonaServerFlag.Name), - Networks: networks, - L2Custom: ctx.Bool(AsteriscKonaL2CustomFlag.Name), - RollupConfigPaths: RollupConfigFlag.StringSlice(ctx, types.TraceTypeAsteriscKona), - L2GenesisPaths: L2GenesisFlag.StringSlice(ctx, types.TraceTypeAsteriscKona), - DepsetConfigPath: DepsetConfigFlag.String(ctx, types.TraceTypeAsteriscKona), - SnapshotFreq: ctx.Uint(AsteriscSnapshotFreqFlag.Name), - InfoFreq: ctx.Uint(AsteriscInfoFreqFlag.Name), - BinarySnapshots: true, + L1GenesisPath: ctx.String(L1GenesisFlag.Name), + VmType: types.TraceTypeAsteriscKona, + L1: l1EthRpc, + L1Beacon: l1Beacon, + L1BeaconSkipBlobVerification: l1BeaconSkipBlobVerification, + L2s: l2Rpcs, + L2Experimental: l2Experimental, + VmBin: ctx.String(AsteriscBinFlag.Name), + Server: ctx.String(AsteriscKonaServerFlag.Name), + Networks: networks, + L2Custom: ctx.Bool(AsteriscKonaL2CustomFlag.Name), + RollupConfigPaths: RollupConfigFlag.StringSlice(ctx, types.TraceTypeAsteriscKona), + L2GenesisPaths: L2GenesisFlag.StringSlice(ctx, types.TraceTypeAsteriscKona), + DepsetConfigPath: DepsetConfigFlag.String(ctx, types.TraceTypeAsteriscKona), + SnapshotFreq: ctx.Uint(AsteriscSnapshotFreqFlag.Name), + InfoFreq: ctx.Uint(AsteriscInfoFreqFlag.Name), + BinarySnapshots: true, }, AsteriscKonaAbsolutePreState: ctx.String(AsteriscKonaPreStateFlag.Name), AsteriscKonaAbsolutePreStateBaseURL: asteriscKonaPreStatesURL, diff --git a/op-challenger/game/fault/trace/vm/executor.go b/op-challenger/game/fault/trace/vm/executor.go index 38fe3791c84..4aa2d7673e1 100644 --- a/op-challenger/game/fault/trace/vm/executor.go +++ b/op-challenger/game/fault/trace/vm/executor.go @@ -49,17 +49,18 @@ type Config struct { BinarySnapshots bool // Whether to use binary snapshots instead of JSON // Host Configuration - L1 string - L1Beacon string - L2s []string - L2Experimental string - Server string // Path to the executable that provides the pre-image oracle server - Networks []string - L2Custom bool - RollupConfigPaths []string - L1GenesisPath string - L2GenesisPaths []string - DepsetConfigPath string + L1 string + L1Beacon string + L1BeaconSkipBlobVerification bool // Skip verification of the KZG proof for each blob. Not recommended unless the provided beacon endpoints are trusted. + L2s []string + L2Experimental string + Server string // Path to the executable that provides the pre-image oracle server + Networks []string + L2Custom bool + RollupConfigPaths []string + L1GenesisPath string + L2GenesisPaths []string + DepsetConfigPath string } func (c *Config) Check() error { diff --git a/op-challenger/game/fault/trace/vm/kona_server_executor.go b/op-challenger/game/fault/trace/vm/kona_server_executor.go index 76da8269754..8d5337f9abe 100644 --- a/op-challenger/game/fault/trace/vm/kona_server_executor.go +++ b/op-challenger/game/fault/trace/vm/kona_server_executor.go @@ -61,5 +61,9 @@ func (s *KonaExecutor) OracleCommand(cfg Config, dataDir string, inputs utils.Lo args = append(args, "--l1-config-path", cfg.L1GenesisPath) } + if cfg.L1BeaconSkipBlobVerification { + args = append(args, "--l1-beacon-skip-blob-verification") + } + return args, nil } diff --git a/op-challenger/game/fault/trace/vm/kona_server_executor_test.go b/op-challenger/game/fault/trace/vm/kona_server_executor_test.go index 8894bfab8b2..e55fd59cb51 100644 --- a/op-challenger/game/fault/trace/vm/kona_server_executor_test.go +++ b/op-challenger/game/fault/trace/vm/kona_server_executor_test.go @@ -46,3 +46,76 @@ func TestKonaFillHostCommand(t *testing.T) { require.True(t, slices.Contains(args, "--claimed-l2-block-number")) require.True(t, slices.Contains(args, "--l1-config-path")) } + +func TestKonaL1BeaconSkipBlobVerification(t *testing.T) { + dir := "mockdir" + baseCfg := Config{ + L1: "http://localhost:8888", + L1Beacon: "http://localhost:9000", + L2s: []string{"http://localhost:9999"}, + Server: "./bin/mockserver", + Networks: []string{"op-mainnet"}, + L1GenesisPath: "mockdir/l1-genesis-1.json", + } + inputs := utils.LocalGameInputs{ + L1Head: common.Hash{0x11}, + L2Head: common.Hash{0x22}, + L2OutputRoot: common.Hash{0x33}, + L2Claim: common.Hash{0x44}, + L2SequenceNumber: big.NewInt(3333), + } + + t.Run("NotIncludedByDefault", func(t *testing.T) { + cfg := baseCfg + cfg.L1BeaconSkipBlobVerification = false + vmConfig := NewKonaExecutor() + args, err := vmConfig.OracleCommand(cfg, dir, inputs) + require.NoError(t, err) + require.False(t, slices.Contains(args, "--l1-beacon-skip-blob-verification")) + }) + + t.Run("IncludedWhenTrue", func(t *testing.T) { + cfg := baseCfg + cfg.L1BeaconSkipBlobVerification = true + vmConfig := NewKonaExecutor() + args, err := vmConfig.OracleCommand(cfg, dir, inputs) + require.NoError(t, err) + require.True(t, slices.Contains(args, "--l1-beacon-skip-blob-verification")) + }) +} + +func TestKonaSuperL1BeaconSkipBlobVerification(t *testing.T) { + dir := "mockdir" + baseCfg := Config{ + L1: "http://localhost:8888", + L1Beacon: "http://localhost:9000", + L2s: []string{"http://localhost:9999", "http://localhost:9998"}, + Server: "./bin/mockserver", + RollupConfigPaths: []string{"rollup1.json", "rollup2.json"}, + L1GenesisPath: "mockdir/l1-genesis-1.json", + } + inputs := utils.LocalGameInputs{ + L1Head: common.Hash{0x11}, + AgreedPreState: []byte{1, 2, 3, 4}, + L2Claim: common.Hash{0x44}, + L2SequenceNumber: big.NewInt(3333), + } + + t.Run("NotIncludedByDefault", func(t *testing.T) { + cfg := baseCfg + cfg.L1BeaconSkipBlobVerification = false + vmConfig := NewKonaSuperExecutor() + args, err := vmConfig.OracleCommand(cfg, dir, inputs) + require.NoError(t, err) + require.False(t, slices.Contains(args, "--l1-beacon-skip-blob-verification")) + }) + + t.Run("IncludedWhenTrue", func(t *testing.T) { + cfg := baseCfg + cfg.L1BeaconSkipBlobVerification = true + vmConfig := NewKonaSuperExecutor() + args, err := vmConfig.OracleCommand(cfg, dir, inputs) + require.NoError(t, err) + require.True(t, slices.Contains(args, "--l1-beacon-skip-blob-verification")) + }) +} diff --git a/op-challenger/game/fault/trace/vm/kona_super_server_executor.go b/op-challenger/game/fault/trace/vm/kona_super_server_executor.go index 5aa347f70e5..8843abf33de 100644 --- a/op-challenger/game/fault/trace/vm/kona_super_server_executor.go +++ b/op-challenger/game/fault/trace/vm/kona_super_server_executor.go @@ -54,5 +54,9 @@ func (s *KonaSuperExecutor) OracleCommand(cfg Config, dataDir string, inputs uti args = append(args, "--l1-config-path", cfg.L1GenesisPath) } + if cfg.L1BeaconSkipBlobVerification { + args = append(args, "--l1-beacon-skip-blob-verification") + } + return args, nil } diff --git a/op-challenger/game/fault/trace/vm/op_program_server_executor.go b/op-challenger/game/fault/trace/vm/op_program_server_executor.go index c56d3aa4b79..a89b3389434 100644 --- a/op-challenger/game/fault/trace/vm/op_program_server_executor.go +++ b/op-challenger/game/fault/trace/vm/op_program_server_executor.go @@ -75,5 +75,8 @@ func (s *OpProgramServerExecutor) OracleCommand(cfg Config, dataDir string, inpu if cfg.L1GenesisPath != "" { args = append(args, "--l1.config", cfg.L1GenesisPath) } + if cfg.L1BeaconSkipBlobVerification { + args = append(args, "--l1.beacon.skip-blob-verification") + } return args, nil } diff --git a/op-challenger/game/fault/trace/vm/op_program_server_executor_test.go b/op-challenger/game/fault/trace/vm/op_program_server_executor_test.go index 37fa6a26007..72f7b20a7be 100644 --- a/op-challenger/game/fault/trace/vm/op_program_server_executor_test.go +++ b/op-challenger/game/fault/trace/vm/op_program_server_executor_test.go @@ -20,8 +20,8 @@ func TestOpProgramFillHostCommand(t *testing.T) { toPairs := func(args []string) map[string]string { pairs := make(map[string]string, len(args)/2) for i := 0; i < len(args); i += 2 { - // l2.custom is a boolean flag so can't accept a value after a space - if args[i] == "--l2.custom" { + // Boolean flags can't accept a value after a space + if args[i] == "--l2.custom" || args[i] == "--l1.beacon.skip-blob-verification" { pairs[args[i]] = "true" i-- continue @@ -217,4 +217,18 @@ func TestOpProgramFillHostCommand(t *testing.T) { require.Equal(t, pairs["--log.level"], logTest.arg) }) } + + t.Run("WithoutL1BeaconSkipBlobVerification", func(t *testing.T) { + pairs := oracleCommand(t, log.LvlInfo, func(c *Config, _ *utils.LocalGameInputs) { + c.L1BeaconSkipBlobVerification = false + }) + require.NotContains(t, pairs, "--l1.beacon.skip-blob-verification") + }) + + t.Run("WithL1BeaconSkipBlobVerification", func(t *testing.T) { + pairs := oracleCommand(t, log.LvlInfo, func(c *Config, _ *utils.LocalGameInputs) { + c.L1BeaconSkipBlobVerification = true + }) + require.Equal(t, "true", pairs["--l1.beacon.skip-blob-verification"]) + }) } diff --git a/op-program/host/config/config.go b/op-program/host/config/config.go index 3aa5190bdcd..5dde48f8695 100644 --- a/op-program/host/config/config.go +++ b/op-program/host/config/config.go @@ -60,11 +60,12 @@ type Config struct { DataFormat types.DataFormat // L1Head is the block hash of the L1 chain head block - L1Head common.Hash - L1URL string - L1BeaconURL string - L1TrustRPC bool - L1RPCKind sources.RPCProviderKind + L1Head common.Hash + L1URL string + L1BeaconURL string + L1BeaconSkipBlobVerification bool // Skip verification of the KZG proof for each blob. Not recommended unless the provided beacon endpoints are trusted. + L1TrustRPC bool + L1RPCKind sources.RPCProviderKind // L2Head is the l2 block hash contained in the L2 Output referenced by the L2OutputRoot for pre-interop mode L2Head common.Hash @@ -396,28 +397,29 @@ func NewConfigFromCLI(log log.Logger, ctx *cli.Context) (*Config, error) { } return &Config{ - L2ChainID: l2ChainID, - Rollups: rollupCfgs, - L1ChainConfig: l1ChainConfig, - DataDir: ctx.String(flags.DataDir.Name), - DataFormat: dbFormat, - L2URLs: ctx.StringSlice(flags.L2NodeAddr.Name), - L2ExperimentalURLs: ctx.StringSlice(flags.L2NodeExperimentalAddr.Name), - L2ChainConfigs: l2ChainConfigs, - L2Head: l2Head, - L2OutputRoot: l2OutputRoot, - AgreedPrestate: agreedPrestate, - DependencySet: dependencySet, - L2Claim: l2Claim, - L2ClaimBlockNumber: l2ClaimBlockNum, - L1Head: l1Head, - L1URL: ctx.String(flags.L1NodeAddr.Name), - L1BeaconURL: ctx.String(flags.L1BeaconAddr.Name), - L1TrustRPC: ctx.Bool(flags.L1TrustRPC.Name), - L1RPCKind: sources.RPCProviderKind(ctx.String(flags.L1RPCProviderKind.Name)), - ExecCmd: ctx.String(flags.Exec.Name), - ServerMode: ctx.Bool(flags.Server.Name), - InteropEnabled: interopEnabled, + L2ChainID: l2ChainID, + Rollups: rollupCfgs, + L1ChainConfig: l1ChainConfig, + DataDir: ctx.String(flags.DataDir.Name), + DataFormat: dbFormat, + L2URLs: ctx.StringSlice(flags.L2NodeAddr.Name), + L2ExperimentalURLs: ctx.StringSlice(flags.L2NodeExperimentalAddr.Name), + L2ChainConfigs: l2ChainConfigs, + L2Head: l2Head, + L2OutputRoot: l2OutputRoot, + AgreedPrestate: agreedPrestate, + DependencySet: dependencySet, + L2Claim: l2Claim, + L2ClaimBlockNumber: l2ClaimBlockNum, + L1Head: l1Head, + L1URL: ctx.String(flags.L1NodeAddr.Name), + L1BeaconURL: ctx.String(flags.L1BeaconAddr.Name), + L1BeaconSkipBlobVerification: ctx.Bool(flags.L1BeaconSkipBlobVerification.Name), + L1TrustRPC: ctx.Bool(flags.L1TrustRPC.Name), + L1RPCKind: sources.RPCProviderKind(ctx.String(flags.L1RPCProviderKind.Name)), + ExecCmd: ctx.String(flags.Exec.Name), + ServerMode: ctx.Bool(flags.Server.Name), + InteropEnabled: interopEnabled, }, nil } diff --git a/op-program/host/config/config_test.go b/op-program/host/config/config_test.go index 0dc868adb6c..b66b4eb2787 100644 --- a/op-program/host/config/config_test.go +++ b/op-program/host/config/config_test.go @@ -310,3 +310,24 @@ func validInteropConfig() *Config { cfg.L2OutputRoot = crypto.Keccak256Hash(cfg.AgreedPrestate) return cfg } + +func TestL1BeaconSkipBlobVerification(t *testing.T) { + t.Run("DefaultIsFalse", func(t *testing.T) { + cfg := validConfig() + require.False(t, cfg.L1BeaconSkipBlobVerification, "L1BeaconSkipBlobVerification should default to false") + }) + + t.Run("CanBeSetToTrue", func(t *testing.T) { + cfg := validConfig() + cfg.L1BeaconSkipBlobVerification = true + require.True(t, cfg.L1BeaconSkipBlobVerification) + require.NoError(t, cfg.Check()) + }) + + t.Run("WorksWithInterop", func(t *testing.T) { + cfg := validInteropConfig() + cfg.L1BeaconSkipBlobVerification = true + require.True(t, cfg.L1BeaconSkipBlobVerification) + require.NoError(t, cfg.Check()) + }) +} diff --git a/op-program/host/flags/flags.go b/op-program/host/flags/flags.go index 01aab199071..cd666b97b2c 100644 --- a/op-program/host/flags/flags.go +++ b/op-program/host/flags/flags.go @@ -112,6 +112,12 @@ var ( Usage: "Address of L1 Beacon API endpoint to use", EnvVars: prefixEnvVars("L1_BEACON_API"), } + L1BeaconSkipBlobVerification = &cli.BoolFlag{ + Name: "l1.beacon.skip-blob-verification", + Usage: "Skip verification of the kzg_proof for each blob returned by the Beacon node. Not recommended unless the provided beacon endpoints are trusted.", + Value: false, + EnvVars: prefixEnvVars("L1_BEACON_SKIP_BLOB_VERIFICATION"), + } L1TrustRPC = &cli.BoolFlag{ Name: "l1.trustrpc", Usage: "Trust the L1 RPC, sync faster at risk of malicious/buggy RPC providing bad or inconsistent L1 data", @@ -169,6 +175,7 @@ var programFlags = []cli.Flag{ L2GenesisPath, L1NodeAddr, L1BeaconAddr, + L1BeaconSkipBlobVerification, L1TrustRPC, L1RPCProviderKind, DepsetConfig, diff --git a/op-program/host/host.go b/op-program/host/host.go index be9063f3169..5f3a3f54797 100644 --- a/op-program/host/host.go +++ b/op-program/host/host.go @@ -95,7 +95,10 @@ func makeDefaultPrefetcher(ctx context.Context, logger log.Logger, kv kvstore.KV logger.Info("Connecting to L1 beacon", "l1", cfg.L1BeaconURL) l1Beacon := sources.NewBeaconHTTPClient(client.NewBasicHTTPClient(cfg.L1BeaconURL, logger)) - l1BlobFetcher := sources.NewL1BeaconClient(l1Beacon, sources.L1BeaconClientConfig{FetchAllSidecars: false}) + l1BlobFetcher := sources.NewL1BeaconClient(l1Beacon, sources.L1BeaconClientConfig{ + FetchAllSidecars: false, + SkipBlobVerification: cfg.L1BeaconSkipBlobVerification, + }) logger.Info("Initializing L2 clients") sources, err := prefetcher.NewRetryingL2SourcesFromURLs(ctx, logger, cfg.Rollups, cfg.L2URLs, cfg.L2ExperimentalURLs) From 25032f2e17e8d0c085697a4ad75e13f3787ad535 Mon Sep 17 00:00:00 2001 From: Yashvardhan Kukreja Date: Mon, 6 Oct 2025 16:32:01 +0530 Subject: [PATCH 006/117] feat(op-conductor): rollup-boost partial unhealthiness tolerance (#17633) * feat(op-conductor): rollup-boost partial unhealthiness tolerance Signed-off-by: Yashvardhan Kukreja * rlock protection to currentValue function Signed-off-by: Yashvardhan Kukreja * timeboundcounter separate file and unit tests Signed-off-by: Yashvardhan Kukreja * comment about the concurrent access bad path testing Signed-off-by: Yashvardhan Kukreja * nit Signed-off-by: Yashvardhan Kukreja * shift the max value logic to health monitor Signed-off-by: Yashvardhan Kukreja * nit Signed-off-by: Yashvardhan Kukreja --------- Signed-off-by: Yashvardhan Kukreja --- op-conductor/conductor/config.go | 11 ++ op-conductor/conductor/service.go | 2 + op-conductor/flags/flags.go | 12 ++ op-conductor/health/monitor.go | 32 +++-- op-conductor/health/monitor_test.go | 81 ++++++++++++ op-conductor/health/timeboundcounter.go | 58 +++++++++ op-conductor/health/timeboundcounter_test.go | 127 +++++++++++++++++++ 7 files changed, 315 insertions(+), 8 deletions(-) create mode 100644 op-conductor/health/timeboundcounter.go create mode 100644 op-conductor/health/timeboundcounter_test.go diff --git a/op-conductor/conductor/config.go b/op-conductor/conductor/config.go index b41aed34a72..90700b5a914 100644 --- a/op-conductor/conductor/config.go +++ b/op-conductor/conductor/config.go @@ -185,6 +185,8 @@ func NewConfig(ctx *cli.Context, log log.Logger) (*Config, error) { ExecutionP2pMinPeerCount: ctx.Uint64(flags.HealthcheckExecutionP2pMinPeerCount.Name), ExecutionP2pRPCUrl: executionP2pRpcUrl, ExecutionP2pCheckApi: executionP2pCheckApi, + RollupBoostPartialHealthinessToleranceLimit: ctx.Uint64(flags.HealthCheckRollupBoostPartialHealthinessToleranceLimit.Name), + RollupBoostPartialHealthinessToleranceIntervalSeconds: ctx.Uint64(flags.HealthCheckRollupBoostPartialHealthinessToleranceIntervalSeconds.Name), }, RollupCfg: *rollupCfg, RPCEnableProxy: ctx.Bool(flags.RPCEnableProxy.Name), @@ -225,6 +227,12 @@ type HealthCheckConfig struct { // ExecutionP2pMinPeerCount is the minimum number of EL P2P peers required for the sequencer to be healthy. ExecutionP2pMinPeerCount uint64 + + // RollupBoostPartialHealthinessToleranceLimit is the amount of rollup-boost partial unhealthiness failures to tolerate within a configurable time frame + RollupBoostPartialHealthinessToleranceLimit uint64 + + // RollupBoostPartialHealthinessToleranceIntervalSeconds is the time frame within which `RollupBoostToleratePartialHealthinessToleranceIntervalLimit` is evaluated + RollupBoostPartialHealthinessToleranceIntervalSeconds uint64 } func (c *HealthCheckConfig) Check() error { @@ -251,5 +259,8 @@ func (c *HealthCheckConfig) Check() error { return fmt.Errorf("invalid el p2p check api") } } + if (c.RollupBoostPartialHealthinessToleranceLimit != 0 && c.RollupBoostPartialHealthinessToleranceIntervalSeconds == 0) || (c.RollupBoostPartialHealthinessToleranceLimit == 0 && c.RollupBoostPartialHealthinessToleranceIntervalSeconds != 0) { + return fmt.Errorf("only one of RollupBoostPartialHealthinessToleranceLimit or RollupBoostPartialHealthinessToleranceIntervalSeconds found to be defined. Either define both of them or none.") + } return nil } diff --git a/op-conductor/conductor/service.go b/op-conductor/conductor/service.go index e8e2ef3d35b..b9f25710c6b 100644 --- a/op-conductor/conductor/service.go +++ b/op-conductor/conductor/service.go @@ -263,6 +263,8 @@ func (c *OpConductor) initHealthMonitor(ctx context.Context) error { rb, elP2p, c.cfg.HealthCheck.ExecutionP2pMinPeerCount, + c.cfg.HealthCheck.RollupBoostPartialHealthinessToleranceLimit, + c.cfg.HealthCheck.RollupBoostPartialHealthinessToleranceIntervalSeconds, ) c.healthUpdateCh = c.hmon.Subscribe() diff --git a/op-conductor/flags/flags.go b/op-conductor/flags/flags.go index c4a6bc32d8c..96e6eeafd51 100644 --- a/op-conductor/flags/flags.go +++ b/op-conductor/flags/flags.go @@ -180,6 +180,16 @@ var ( EnvVars: opservice.PrefixEnvVar(EnvVarPrefix, "HEALTHCHECK_EXECUTION_P2P_CHECK_API"), Value: "net", } + HealthCheckRollupBoostPartialHealthinessToleranceLimit = &cli.Uint64Flag{ + Name: "healthcheck.rollup-boost-partial-healthiness-tolerance-limit", + Usage: "Sets the count of rollup-boost partial healthiness failures to occur before marking op-conducto as unhealthy. Default is 0 with which a single occurrence of rollup-boost partial healthiness is enough to set op-conductor as unhealthy", + EnvVars: opservice.PrefixEnvVar(EnvVarPrefix, "HEALTHCHECK_ROLLUP_BOOST_PARTIAL_HEALTHINESS_TOLERANCE_LIMIT"), + } + HealthCheckRollupBoostPartialHealthinessToleranceIntervalSeconds = &cli.Uint64Flag{ + Name: "healthcheck.rollup-boost-partial-healthiness-tolerance-interval-seconds", + Usage: "The time frame within which rollup-boost partial healthiness tolerance is evaluated", + EnvVars: opservice.PrefixEnvVar(EnvVarPrefix, "HEALTHCHECK_ROLLUP_BOOST_PARTIAL_HEALTHINESS_TOLERANCE_INTERVAL_SECONDS"), + } ) var requiredFlags = []cli.Flag{ @@ -213,6 +223,8 @@ var optionalFlags = []cli.Flag{ HealthcheckExecutionP2pMinPeerCount, HealthcheckExecutionP2pRPCUrl, HealthcheckExecutionP2pCheckApi, + HealthCheckRollupBoostPartialHealthinessToleranceLimit, + HealthCheckRollupBoostPartialHealthinessToleranceIntervalSeconds, } func init() { diff --git a/op-conductor/health/monitor.go b/op-conductor/health/monitor.go index 56091139989..dc5bd88fbd4 100644 --- a/op-conductor/health/monitor.go +++ b/op-conductor/health/monitor.go @@ -39,7 +39,7 @@ type HealthMonitor interface { // interval is the interval between health checks measured in seconds. // safeInterval is the interval between safe head progress measured in seconds. // minPeerCount is the minimum number of peers required for the sequencer to be healthy. -func NewSequencerHealthMonitor(log log.Logger, metrics metrics.Metricer, interval, unsafeInterval, safeInterval, minPeerCount uint64, safeEnabled bool, rollupCfg *rollup.Config, node dial.RollupClientInterface, p2p apis.P2PClient, supervisor SupervisorHealthAPI, rb client.RollupBoostClient, elP2pClient client.ElP2PClient, minElP2pPeers uint64) HealthMonitor { +func NewSequencerHealthMonitor(log log.Logger, metrics metrics.Metricer, interval, unsafeInterval, safeInterval, minPeerCount uint64, safeEnabled bool, rollupCfg *rollup.Config, node dial.RollupClientInterface, p2p apis.P2PClient, supervisor SupervisorHealthAPI, rb client.RollupBoostClient, elP2pClient client.ElP2PClient, minElP2pPeers uint64, rollupBoostToleratePartialHealthinessToleranceLimit uint64, rollupBoostToleratePartialHealthinessToleranceIntervalSeconds uint64) HealthMonitor { hm := &SequencerHealthMonitor{ log: log, metrics: metrics, @@ -50,7 +50,7 @@ func NewSequencerHealthMonitor(log log.Logger, metrics metrics.Metricer, interva safeEnabled: safeEnabled, safeInterval: safeInterval, minPeerCount: minPeerCount, - timeProviderFn: currentTimeProvicer, + timeProviderFn: currentTimeProvider, node: node, p2p: p2p, supervisor: supervisor, @@ -64,6 +64,14 @@ func NewSequencerHealthMonitor(log log.Logger, metrics metrics.Metricer, interva elP2pClient: elP2pClient, } } + if rollupBoostToleratePartialHealthinessToleranceLimit != 0 { + hm.rollupBoostPartialHealthinessToleranceLimit = rollupBoostToleratePartialHealthinessToleranceLimit + var err error + hm.rollupBoostPartialHealthinessToleranceCounter, err = NewTimeBoundedRotatingCounter(rollupBoostToleratePartialHealthinessToleranceIntervalSeconds) + if err != nil { + panic(fmt.Errorf("failed to setup health monitor: %w", err)) + } + } return hm } @@ -93,11 +101,13 @@ type SequencerHealthMonitor struct { timeProviderFn func() uint64 - node dial.RollupClientInterface - p2p apis.P2PClient - supervisor SupervisorHealthAPI - rb client.RollupBoostClient - elP2p *ElP2pHealthMonitor + node dial.RollupClientInterface + p2p apis.P2PClient + supervisor SupervisorHealthAPI + rb client.RollupBoostClient + elP2p *ElP2pHealthMonitor + rollupBoostPartialHealthinessToleranceLimit uint64 + rollupBoostPartialHealthinessToleranceCounter *timeBoundedRotatingCounter } var _ HealthMonitor = (*SequencerHealthMonitor)(nil) @@ -288,8 +298,14 @@ func (hm *SequencerHealthMonitor) checkRollupBoost(ctx context.Context) error { case client.HealthStatusHealthy: return nil case client.HealthStatusPartial: + if hm.rollupBoostPartialHealthinessToleranceCounter != nil && hm.rollupBoostPartialHealthinessToleranceCounter.CurrentValue() < hm.rollupBoostPartialHealthinessToleranceLimit { + latestValue := hm.rollupBoostPartialHealthinessToleranceCounter.Increment() + hm.log.Debug("Rollup boost partial unhealthiness failure tolerated", "currentValue", latestValue, "limit", hm.rollupBoostPartialHealthinessToleranceLimit) + return nil + } hm.log.Error("Rollup boost is partial failure, builder is down but fallback execution client is up", "err", ErrRollupBoostPartiallyHealthy) return ErrRollupBoostPartiallyHealthy + case client.HealthStatusUnhealthy: hm.log.Error("Rollup boost total failure, both builder and fallback execution client are down", "err", ErrRollupBoostNotHealthy) return ErrRollupBoostNotHealthy @@ -306,6 +322,6 @@ func calculateTimeDiff(now, then uint64) uint64 { return now - then } -func currentTimeProvicer() uint64 { +func currentTimeProvider() uint64 { return uint64(time.Now().Unix()) } diff --git a/op-conductor/health/monitor_test.go b/op-conductor/health/monitor_test.go index 9bbfd69d53f..af85b8ff427 100644 --- a/op-conductor/health/monitor_test.go +++ b/op-conductor/health/monitor_test.go @@ -97,6 +97,8 @@ func (s *HealthMonitorTestSuite) SetupMonitor( return monitor } +type monitorOpts func(*SequencerHealthMonitor) + // SetupMonitorWithRollupBoost creates a HealthMonitor that includes a RollupBoostClient func (s *HealthMonitorTestSuite) SetupMonitorWithRollupBoost( now, unsafeInterval, safeInterval uint64, @@ -104,6 +106,7 @@ func (s *HealthMonitorTestSuite) SetupMonitorWithRollupBoost( mockP2P *p2pMocks.API, mockRollupBoost *clientmocks.RollupBoostClient, elP2pClient client.ElP2PClient, + opts ...monitorOpts, ) *SequencerHealthMonitor { tp := &timeProvider{now: now} if mockP2P == nil { @@ -137,6 +140,9 @@ func (s *HealthMonitorTestSuite) SetupMonitorWithRollupBoost( elP2pClient: elP2pClient, } } + for _, opt := range opts { + opt(monitor) + } err := monitor.Start(context.Background()) s.NoError(err) return monitor @@ -442,6 +448,81 @@ func (s *HealthMonitorTestSuite) TestRollupBoostPartialStatus() { s.NoError(monitor.Stop()) } +func (s *HealthMonitorTestSuite) TestRollupBoostPartialStatusWithTolerance() { + s.T().Parallel() + now := uint64(time.Now().Unix()) + + // Setup healthy node conditions + rc := &testutils.MockRollupClient{} + ss1 := mockSyncStatus(now-1, 1, now-3, 0) + + // because 6 healthchecks are going to be expected cause 6 calls of sync status + for i := 0; i < 6; i++ { + rc.ExpectSyncStatus(ss1, nil) + } + + // Setup healthy peer count + pc := &p2pMocks.API{} + ps1 := &p2p.PeerStats{ + Connected: healthyPeerCount, + } + pc.EXPECT().PeerStats(mock.Anything).Return(ps1, nil) + + // Setup partial rollup boost status (treated as unhealthy) + rb := &clientmocks.RollupBoostClient{} + rb.EXPECT().Healthcheck(mock.Anything).Return(client.HealthStatusPartial, nil) + + toleranceLimit := uint64(2) + toleranceIntervalSeconds := uint64(6) + + timeBoundedRotatingCounter, err := NewTimeBoundedRotatingCounter(toleranceIntervalSeconds) + s.Nil(err) + + tp := &timeProvider{now: 1758792282} + + // Start monitor with all dependencies as well as tolerance of 2 rollup-boost partial unhealthiness per 3s period + monitor := s.SetupMonitorWithRollupBoost(now, 60, 60, rc, pc, rb, nil, func(shm *SequencerHealthMonitor) { + timeBoundedRotatingCounter.timeProviderFn = tp.Now + + // pollute the cache of timeBoundRotatingCounter with 998 elements so as to later test the lazy cleanup + // note: the 999th and 1000th element will be added by the first healthcheck run + for i := 0; i < 999; i++ { + timeBoundedRotatingCounter.temporalCache[int64(i)] = uint64(1) + } + + shm.rollupBoostPartialHealthinessToleranceCounter = timeBoundedRotatingCounter + shm.rollupBoostPartialHealthinessToleranceLimit = toleranceLimit + }) + + healthUpdateCh := monitor.Subscribe() + + s.Eventually(func() bool { + return len(timeBoundedRotatingCounter.temporalCache) == 1000 + }, time.Second*3, time.Second*1) + + firstHealthStatus := <-healthUpdateCh + secondHealthStatus := <-healthUpdateCh + thirdHealthStatus := <-healthUpdateCh + + s.Nil(firstHealthStatus) + s.Nil(secondHealthStatus) + s.Equal(ErrRollupBoostPartiallyHealthy, thirdHealthStatus) + + tp.Now() // simulate another second passing + // by now, because of three healthchecks, six seconds (CurrentValue + Increment + CurrentValue + Increment + CurrentValue + tp.Now()) have been simulated to pass (by the timeProviderFn) + // this should reset the time bound counter, thereby allowing partial unhealthiness failures to be tolerated again + + fourthHealthStatus := <-healthUpdateCh + fifthHealthStatus := <-healthUpdateCh + sixthHealthStatus := <-healthUpdateCh + + s.Nil(fourthHealthStatus) + s.Nil(fifthHealthStatus) + s.Equal(ErrRollupBoostPartiallyHealthy, sixthHealthStatus) + + s.NoError(monitor.Stop()) +} + func (s *HealthMonitorTestSuite) TestRollupBoostHealthy() { s.T().Parallel() now := uint64(time.Now().Unix()) diff --git a/op-conductor/health/timeboundcounter.go b/op-conductor/health/timeboundcounter.go new file mode 100644 index 00000000000..58918ead911 --- /dev/null +++ b/op-conductor/health/timeboundcounter.go @@ -0,0 +1,58 @@ +package health + +import ( + "fmt" + "sync" +) + +// this is a type of counter which keeps on incrementing until its reset interval is hit after which it resets to 0 +// this can be used to track time-based rate-limit, error counts, etc. +type timeBoundedRotatingCounter struct { + resetIntervalSeconds uint64 + timeProviderFn func() uint64 + + mut *sync.RWMutex + temporalCache map[int64]uint64 +} + +func NewTimeBoundedRotatingCounter(resetIntervalSeconds uint64) (*timeBoundedRotatingCounter, error) { + if resetIntervalSeconds == 0 { + return nil, fmt.Errorf("reset interval seconds must be more than 0") + } + return &timeBoundedRotatingCounter{ + resetIntervalSeconds: resetIntervalSeconds, + mut: &sync.RWMutex{}, + temporalCache: map[int64]uint64{}, + timeProviderFn: currentTimeProvider, + }, nil +} + +func (t *timeBoundedRotatingCounter) Increment() uint64 { + // let's take `resetIntervalSeconds` as 60s + // truncatedTimestamp is current timestamp rounded off by 60s (resetIntervalSeconds) + // thereby generating a value which stays same until the next 60s helping track and incrementing the counter corresponding to it for the next 60s + currentTsSeconds := t.timeProviderFn() + truncatedTimestamp := int64(currentTsSeconds / t.resetIntervalSeconds) + t.mut.Lock() + // a lazy cleanup subroutine to the clean the cache when it's grown enough, preventing memory leaks + defer func() { + defer t.mut.Unlock() + if len(t.temporalCache) > 1000 { + newCache := map[int64]uint64{ + truncatedTimestamp: t.temporalCache[truncatedTimestamp], + } + t.temporalCache = newCache // garbage collector should take care of the old cache + } + }() + + t.temporalCache[truncatedTimestamp]++ + return t.temporalCache[truncatedTimestamp] +} + +func (t *timeBoundedRotatingCounter) CurrentValue() uint64 { + currentTsSeconds := t.timeProviderFn() + truncatedTimestamp := int64(currentTsSeconds / t.resetIntervalSeconds) + t.mut.RLock() + defer t.mut.RUnlock() + return t.temporalCache[truncatedTimestamp] +} diff --git a/op-conductor/health/timeboundcounter_test.go b/op-conductor/health/timeboundcounter_test.go new file mode 100644 index 00000000000..f27c128bf0d --- /dev/null +++ b/op-conductor/health/timeboundcounter_test.go @@ -0,0 +1,127 @@ +package health + +import ( + "sync" + "testing" + + "github.com/stretchr/testify/require" +) + +func TestTimeBoundedRotatingCounterSetup(t *testing.T) { + t.Parallel() + t.Run("fail with 0 interval seconds value", func(t *testing.T) { + counter, err := NewTimeBoundedRotatingCounter(0) + require.Error(t, err) + require.Nil(t, counter) + }) + + t.Run("succeed with non-zero interval seconds value", func(t *testing.T) { + counter, err := NewTimeBoundedRotatingCounter(2) + require.NoError(t, err) + require.NotNil(t, counter) + }) +} + +func TestTimeBoundedRotatingCounterIncrement(t *testing.T) { + + mockTimeProvider := &timeProvider{now: 0} // every access to .Now() will increment its value simulating a one-second time passing + + resetInterval := uint64(6) + counter, err := NewTimeBoundedRotatingCounter(resetInterval) + require.NoError(t, err) + require.NotNil(t, counter) + counter.timeProviderFn = mockTimeProvider.Now + + require.Equal(t, int(mockTimeProvider.now), 0) + require.Equal(t, uint64(0), counter.CurrentValue()) + require.Equal(t, int(mockTimeProvider.now), 1) + + newValue := counter.Increment() + require.Equal(t, uint64(1), newValue) + require.Equal(t, int(mockTimeProvider.now), 2) + require.Equal(t, uint64(1), counter.CurrentValue()) + require.Equal(t, int(mockTimeProvider.now), 3) + + newValue = counter.Increment() + require.Equal(t, uint64(2), newValue) + require.Equal(t, int(mockTimeProvider.now), 4) + require.Equal(t, uint64(2), counter.CurrentValue()) + require.Equal(t, int(mockTimeProvider.now), 5) + + newValue = counter.Increment() + require.Equal(t, uint64(3), newValue) + require.Equal(t, int(mockTimeProvider.now), 6) + require.Equal(t, uint64(0), counter.CurrentValue()) // the next second counter rotates returning 0 as the current value + require.Equal(t, int(mockTimeProvider.now), 7) + + newValue = counter.Increment() + require.Equal(t, uint64(1), newValue) + require.Equal(t, int(mockTimeProvider.now), 8) + require.Equal(t, uint64(1), counter.CurrentValue()) + require.Equal(t, int(mockTimeProvider.now), 9) + + newValue = counter.Increment() + require.Equal(t, uint64(2), newValue) + require.Equal(t, int(mockTimeProvider.now), 10) + require.Equal(t, uint64(2), counter.CurrentValue()) + require.Equal(t, int(mockTimeProvider.now), 11) + + newValue = counter.Increment() + require.Equal(t, uint64(3), newValue) + require.Equal(t, int(mockTimeProvider.now), 12) + require.Equal(t, uint64(0), counter.CurrentValue()) // the next second counter rotates returning 0 as the current value + require.Equal(t, int(mockTimeProvider.now), 13) + +} + +// To test the bad path: comment out mut.RLock() and mut.RUnlock() in the CurrentValue() method, and run this test again +// you'll see a "fatal error: concurrent map read and map write" +func TestTimeBoundedRotatingCounterConcurrentAccess(t *testing.T) { + mockTimeProvider := &timeProvider{now: 0} + + counter, err := NewTimeBoundedRotatingCounter(1) + require.NoError(t, err) + require.NotNil(t, counter) + counter.timeProviderFn = mockTimeProvider.Now + + wg := &sync.WaitGroup{} + wg.Add(2000) + + write := func() { + defer wg.Done() + counter.Increment() + } + read := func() { + defer wg.Done() + counter.CurrentValue() + } + require.NotPanics(t, func() { + for i := 0; i < 1000; i++ { + go write() + go read() + } + wg.Wait() + }) +} + +func TestTimeBoundedRotatingCounterLazyCleanup(t *testing.T) { + mockTimeProvider := &timeProvider{now: 0} + + // a counter with a reset interval of 2 ensuring every two-seconds the counter's cache would track a new key:value + // we'll trigger the 2-second increment by calling .Increment() and .CurrentValue() because both under the hood, would call .Now() of the mockTimeProvider + counter, err := NewTimeBoundedRotatingCounter(2) + require.NoError(t, err) + require.NotNil(t, counter) + counter.timeProviderFn = mockTimeProvider.Now + + for i := 0; i < 1000; i++ { + counter.Increment() // trigger a 1-second time increase + counter.CurrentValue() // trigger another 1-second time increase, causing the counter interval to reset ensuring next Increment would write a new key in the cache + } + + require.Equal(t, 1000, len(counter.temporalCache)) + + // 1001th increment should trigger the lazy cleanup this time + counter.Increment() + require.Equal(t, 1, len(counter.temporalCache)) +} From 1fd459dabfd0121784d233f1f4c96e4e645597d1 Mon Sep 17 00:00:00 2001 From: George Knee Date: Mon, 6 Oct 2025 13:43:48 +0100 Subject: [PATCH 007/117] l1-beacon-client: verify blobs using commitment only (not the proof) (#17725) * recompute blob proof if skipBlobVerification * use even simpler verification * replace verification logic * refactor to make verification more direct This approach does not use any additional data from the beacon endpoint, aside from the blob itself, so anticipates future API changes where this will be the only data provided. * tweak comments * rename to verifyBlob * tweak test comments * Revert "op-service/L1BeaconClient: allow blob proof verification to be skipped via `l1.beacon.skip-blob-verification` flag (#17713)" This reverts commit 05ba528ae52a48efc2cde8e0e0390cf47ad5f4ad. * Revert "Add `skip-blob-verification` flag to op-program and op-challenger (#17718)" This reverts commit 3ee883bcfb1b6ac4717ae430a84e92d08359c21f. * add an extra unit test --- op-challenger/config/config.go | 149 +++++++-------- op-challenger/flags/flags.go | 172 ++++++++---------- op-challenger/game/fault/trace/vm/executor.go | 23 ++- .../fault/trace/vm/kona_server_executor.go | 4 - .../trace/vm/kona_server_executor_test.go | 73 -------- .../trace/vm/kona_super_server_executor.go | 4 - .../trace/vm/op_program_server_executor.go | 3 - .../vm/op_program_server_executor_test.go | 18 +- op-node/config/beacon.go | 16 +- op-node/flags/flags.go | 9 - op-node/node/node.go | 3 +- op-node/service.go | 11 +- op-program/host/config/config.go | 56 +++--- op-program/host/config/config_test.go | 21 --- op-program/host/flags/flags.go | 7 - op-program/host/host.go | 5 +- op-service/sources/l1_beacon_client.go | 38 ++-- op-service/sources/l1_beacon_client_test.go | 49 ++--- 18 files changed, 246 insertions(+), 415 deletions(-) diff --git a/op-challenger/config/config.go b/op-challenger/config/config.go index d53eec9048d..874acdcd145 100644 --- a/op-challenger/config/config.go +++ b/op-challenger/config/config.go @@ -65,17 +65,16 @@ const ( // This also contains config options for auxiliary services. // It is used to initialize the challenger. type Config struct { - L1EthRpc string // L1 RPC Url - L1Beacon string // L1 Beacon API Url - L1BeaconSkipBlobVerification bool // Skip verification of the KZG proof for each blob. Not recommended unless the provided beacon endpoints are trusted. - GameFactoryAddress common.Address // Address of the dispute game factory - GameAllowlist []common.Address // Allowlist of fault game addresses - GameWindow time.Duration // Maximum time duration to look for games to progress - Datadir string // Data Directory - MaxConcurrency uint // Maximum number of threads to use when progressing games - PollInterval time.Duration // Polling interval for latest-block subscription when using an HTTP RPC provider - AllowInvalidPrestate bool // Whether to allow responding to games where the prestate does not match - MinUpdateInterval time.Duration // Minimum duration the L1 head block time must advance before scheduling a new update cycle + L1EthRpc string // L1 RPC Url + L1Beacon string // L1 Beacon API Url + GameFactoryAddress common.Address // Address of the dispute game factory + GameAllowlist []common.Address // Allowlist of fault game addresses + GameWindow time.Duration // Maximum time duration to look for games to progress + Datadir string // Data Directory + MaxConcurrency uint // Maximum number of threads to use when progressing games + PollInterval time.Duration // Polling interval for latest-block subscription when using an HTTP RPC provider + AllowInvalidPrestate bool // Whether to allow responding to games where the prestate does not match + MinUpdateInterval time.Duration // Minimum duration the L1 head block time must advance before scheduling a new update cycle AdditionalBondClaimants []common.Address // List of addresses to claim bonds for in addition to the tx manager sender @@ -152,46 +151,42 @@ func NewInteropConfig( Datadir: datadir, Cannon: vm.Config{ - VmType: types.TraceTypeCannon, - L1: l1EthRpc, - L1Beacon: l1BeaconApi, - L1BeaconSkipBlobVerification: false, - L2s: l2Rpcs, - SnapshotFreq: DefaultCannonSnapshotFreq, - InfoFreq: DefaultCannonInfoFreq, - DebugInfo: true, - BinarySnapshots: true, + VmType: types.TraceTypeCannon, + L1: l1EthRpc, + L1Beacon: l1BeaconApi, + L2s: l2Rpcs, + SnapshotFreq: DefaultCannonSnapshotFreq, + InfoFreq: DefaultCannonInfoFreq, + DebugInfo: true, + BinarySnapshots: true, }, CannonKona: vm.Config{ - VmType: types.TraceTypeCannonKona, - L1: l1EthRpc, - L1Beacon: l1BeaconApi, - L1BeaconSkipBlobVerification: false, - L2s: l2Rpcs, - SnapshotFreq: DefaultCannonSnapshotFreq, - InfoFreq: DefaultCannonInfoFreq, - DebugInfo: true, - BinarySnapshots: true, + VmType: types.TraceTypeCannonKona, + L1: l1EthRpc, + L1Beacon: l1BeaconApi, + L2s: l2Rpcs, + SnapshotFreq: DefaultCannonSnapshotFreq, + InfoFreq: DefaultCannonInfoFreq, + DebugInfo: true, + BinarySnapshots: true, }, Asterisc: vm.Config{ - VmType: types.TraceTypeAsterisc, - L1: l1EthRpc, - L1Beacon: l1BeaconApi, - L1BeaconSkipBlobVerification: false, - L2s: l2Rpcs, - SnapshotFreq: DefaultAsteriscSnapshotFreq, - InfoFreq: DefaultAsteriscInfoFreq, - BinarySnapshots: true, + VmType: types.TraceTypeAsterisc, + L1: l1EthRpc, + L1Beacon: l1BeaconApi, + L2s: l2Rpcs, + SnapshotFreq: DefaultAsteriscSnapshotFreq, + InfoFreq: DefaultAsteriscInfoFreq, + BinarySnapshots: true, }, AsteriscKona: vm.Config{ - VmType: types.TraceTypeAsteriscKona, - L1: l1EthRpc, - L1Beacon: l1BeaconApi, - L1BeaconSkipBlobVerification: false, - L2s: l2Rpcs, - SnapshotFreq: DefaultAsteriscSnapshotFreq, - InfoFreq: DefaultAsteriscInfoFreq, - BinarySnapshots: true, + VmType: types.TraceTypeAsteriscKona, + L1: l1EthRpc, + L1Beacon: l1BeaconApi, + L2s: l2Rpcs, + SnapshotFreq: DefaultAsteriscSnapshotFreq, + InfoFreq: DefaultAsteriscInfoFreq, + BinarySnapshots: true, }, GameWindow: DefaultGameWindow, } @@ -226,46 +221,42 @@ func NewConfig( Datadir: datadir, Cannon: vm.Config{ - VmType: types.TraceTypeCannon, - L1: l1EthRpc, - L1Beacon: l1BeaconApi, - L1BeaconSkipBlobVerification: false, - L2s: []string{l2EthRpc}, - SnapshotFreq: DefaultCannonSnapshotFreq, - InfoFreq: DefaultCannonInfoFreq, - DebugInfo: true, - BinarySnapshots: true, + VmType: types.TraceTypeCannon, + L1: l1EthRpc, + L1Beacon: l1BeaconApi, + L2s: []string{l2EthRpc}, + SnapshotFreq: DefaultCannonSnapshotFreq, + InfoFreq: DefaultCannonInfoFreq, + DebugInfo: true, + BinarySnapshots: true, }, CannonKona: vm.Config{ - VmType: types.TraceTypeCannonKona, - L1: l1EthRpc, - L1Beacon: l1BeaconApi, - L1BeaconSkipBlobVerification: false, - L2s: []string{l2EthRpc}, - SnapshotFreq: DefaultCannonSnapshotFreq, - InfoFreq: DefaultCannonInfoFreq, - DebugInfo: true, - BinarySnapshots: true, + VmType: types.TraceTypeCannonKona, + L1: l1EthRpc, + L1Beacon: l1BeaconApi, + L2s: []string{l2EthRpc}, + SnapshotFreq: DefaultCannonSnapshotFreq, + InfoFreq: DefaultCannonInfoFreq, + DebugInfo: true, + BinarySnapshots: true, }, Asterisc: vm.Config{ - VmType: types.TraceTypeAsterisc, - L1: l1EthRpc, - L1Beacon: l1BeaconApi, - L1BeaconSkipBlobVerification: false, - L2s: []string{l2EthRpc}, - SnapshotFreq: DefaultAsteriscSnapshotFreq, - InfoFreq: DefaultAsteriscInfoFreq, - BinarySnapshots: true, + VmType: types.TraceTypeAsterisc, + L1: l1EthRpc, + L1Beacon: l1BeaconApi, + L2s: []string{l2EthRpc}, + SnapshotFreq: DefaultAsteriscSnapshotFreq, + InfoFreq: DefaultAsteriscInfoFreq, + BinarySnapshots: true, }, AsteriscKona: vm.Config{ - VmType: types.TraceTypeAsteriscKona, - L1: l1EthRpc, - L1Beacon: l1BeaconApi, - L1BeaconSkipBlobVerification: false, - L2s: []string{l2EthRpc}, - SnapshotFreq: DefaultAsteriscSnapshotFreq, - InfoFreq: DefaultAsteriscInfoFreq, - BinarySnapshots: true, + VmType: types.TraceTypeAsteriscKona, + L1: l1EthRpc, + L1Beacon: l1BeaconApi, + L2s: []string{l2EthRpc}, + SnapshotFreq: DefaultAsteriscSnapshotFreq, + InfoFreq: DefaultAsteriscInfoFreq, + BinarySnapshots: true, }, GameWindow: DefaultGameWindow, } diff --git a/op-challenger/flags/flags.go b/op-challenger/flags/flags.go index 4f4a16ac08c..a911eaaf1bf 100644 --- a/op-challenger/flags/flags.go +++ b/op-challenger/flags/flags.go @@ -283,13 +283,6 @@ var ( EnvVars: prefixEnvVars("RESPONSE_DELAY_AFTER"), Value: config.DefaultResponseDelayAfter, } - L1BeaconSkipBlobVerificationFlag = &cli.BoolFlag{ - Name: "l1-beacon-skip-blob-verification", - Usage: "Skip verification of the KZG proof for each blob returned by the Beacon node. Not recommended unless the provided beacon endpoints are trusted.", - EnvVars: prefixEnvVars("L1_BEACON_SKIP_BLOB_VERIFICATION"), - Value: false, - Hidden: true, - } ) // requiredFlags are checked by [CheckRequired] @@ -337,7 +330,6 @@ var optionalFlags = []cli.Flag{ ResponseDelayFlag, ResponseDelayAfterFlag, L1GenesisFlag, - L1BeaconSkipBlobVerificationFlag, } func init() { @@ -703,109 +695,103 @@ func NewConfigFromCLI(ctx *cli.Context, logger log.Logger) (*config.Config, erro networks := ctx.StringSlice(flags.NetworkFlagName) l1EthRpc := ctx.String(L1EthRpcFlag.Name) l1Beacon := ctx.String(L1BeaconFlag.Name) - l1BeaconSkipBlobVerification := ctx.Bool(L1BeaconSkipBlobVerificationFlag.Name) l2Rpcs := ctx.StringSlice(L2EthRpcFlag.Name) l2Experimental := ctx.String(L2ExperimentalEthRpcFlag.Name) return &config.Config{ // Required Flags - L1EthRpc: l1EthRpc, - L1Beacon: l1Beacon, - L1BeaconSkipBlobVerification: l1BeaconSkipBlobVerification, - TraceTypes: traceTypes, - GameFactoryAddress: gameFactoryAddress, - GameAllowlist: allowedGames, - GameWindow: ctx.Duration(GameWindowFlag.Name), - MaxConcurrency: maxConcurrency, - L2Rpcs: l2Rpcs, - MaxPendingTx: ctx.Uint64(MaxPendingTransactionsFlag.Name), - PollInterval: ctx.Duration(HTTPPollInterval.Name), - MinUpdateInterval: ctx.Duration(MinUpdateInterval.Name), - AdditionalBondClaimants: claimants, - RollupRpc: ctx.String(RollupRpcFlag.Name), - SupervisorRPC: ctx.String(SupervisorRpcFlag.Name), + L1EthRpc: l1EthRpc, + L1Beacon: l1Beacon, + TraceTypes: traceTypes, + GameFactoryAddress: gameFactoryAddress, + GameAllowlist: allowedGames, + GameWindow: ctx.Duration(GameWindowFlag.Name), + MaxConcurrency: maxConcurrency, + L2Rpcs: l2Rpcs, + MaxPendingTx: ctx.Uint64(MaxPendingTransactionsFlag.Name), + PollInterval: ctx.Duration(HTTPPollInterval.Name), + MinUpdateInterval: ctx.Duration(MinUpdateInterval.Name), + AdditionalBondClaimants: claimants, + RollupRpc: ctx.String(RollupRpcFlag.Name), + SupervisorRPC: ctx.String(SupervisorRpcFlag.Name), Cannon: vm.Config{ - L1GenesisPath: ctx.String(L1GenesisFlag.Name), - VmType: types.TraceTypeCannon, - L1: l1EthRpc, - L1Beacon: l1Beacon, - L1BeaconSkipBlobVerification: l1BeaconSkipBlobVerification, - L2s: l2Rpcs, - L2Experimental: l2Experimental, - VmBin: ctx.String(CannonBinFlag.Name), - Server: ctx.String(CannonServerFlag.Name), - Networks: networks, - L2Custom: ctx.Bool(CannonL2CustomFlag.Name), - RollupConfigPaths: RollupConfigFlag.StringSlice(ctx, types.TraceTypeCannon), - L2GenesisPaths: L2GenesisFlag.StringSlice(ctx, types.TraceTypeCannon), - DepsetConfigPath: DepsetConfigFlag.String(ctx, types.TraceTypeCannon), - SnapshotFreq: ctx.Uint(CannonSnapshotFreqFlag.Name), - InfoFreq: ctx.Uint(CannonInfoFreqFlag.Name), - DebugInfo: true, - BinarySnapshots: true, + L1GenesisPath: ctx.String(L1GenesisFlag.Name), + VmType: types.TraceTypeCannon, + L1: l1EthRpc, + L1Beacon: l1Beacon, + L2s: l2Rpcs, + L2Experimental: l2Experimental, + VmBin: ctx.String(CannonBinFlag.Name), + Server: ctx.String(CannonServerFlag.Name), + Networks: networks, + L2Custom: ctx.Bool(CannonL2CustomFlag.Name), + RollupConfigPaths: RollupConfigFlag.StringSlice(ctx, types.TraceTypeCannon), + L2GenesisPaths: L2GenesisFlag.StringSlice(ctx, types.TraceTypeCannon), + DepsetConfigPath: DepsetConfigFlag.String(ctx, types.TraceTypeCannon), + SnapshotFreq: ctx.Uint(CannonSnapshotFreqFlag.Name), + InfoFreq: ctx.Uint(CannonInfoFreqFlag.Name), + DebugInfo: true, + BinarySnapshots: true, }, CannonAbsolutePreState: ctx.String(CannonPreStateFlag.Name), CannonAbsolutePreStateBaseURL: cannonPreStatesURL, CannonKona: vm.Config{ - L1GenesisPath: ctx.String(L1GenesisFlag.Name), - VmType: types.TraceTypeCannonKona, - L1: l1EthRpc, - L1Beacon: l1Beacon, - L1BeaconSkipBlobVerification: l1BeaconSkipBlobVerification, - L2s: l2Rpcs, - L2Experimental: l2Experimental, - VmBin: ctx.String(CannonBinFlag.Name), - Server: ctx.String(CannonKonaServerFlag.Name), - Networks: networks, - L2Custom: ctx.Bool(CannonKonaL2CustomFlag.Name), - RollupConfigPaths: RollupConfigFlag.StringSlice(ctx, types.TraceTypeCannonKona), - L2GenesisPaths: L2GenesisFlag.StringSlice(ctx, types.TraceTypeCannonKona), - DepsetConfigPath: DepsetConfigFlag.String(ctx, types.TraceTypeCannonKona), - SnapshotFreq: ctx.Uint(CannonSnapshotFreqFlag.Name), - InfoFreq: ctx.Uint(CannonInfoFreqFlag.Name), - DebugInfo: true, - BinarySnapshots: true, + L1GenesisPath: ctx.String(L1GenesisFlag.Name), + VmType: types.TraceTypeCannonKona, + L1: l1EthRpc, + L1Beacon: l1Beacon, + L2s: l2Rpcs, + L2Experimental: l2Experimental, + VmBin: ctx.String(CannonBinFlag.Name), + Server: ctx.String(CannonKonaServerFlag.Name), + Networks: networks, + L2Custom: ctx.Bool(CannonKonaL2CustomFlag.Name), + RollupConfigPaths: RollupConfigFlag.StringSlice(ctx, types.TraceTypeCannonKona), + L2GenesisPaths: L2GenesisFlag.StringSlice(ctx, types.TraceTypeCannonKona), + DepsetConfigPath: DepsetConfigFlag.String(ctx, types.TraceTypeCannonKona), + SnapshotFreq: ctx.Uint(CannonSnapshotFreqFlag.Name), + InfoFreq: ctx.Uint(CannonInfoFreqFlag.Name), + DebugInfo: true, + BinarySnapshots: true, }, CannonKonaAbsolutePreState: ctx.String(CannonKonaPreStateFlag.Name), CannonKonaAbsolutePreStateBaseURL: cannonKonaPreStatesURL, Datadir: ctx.String(DatadirFlag.Name), Asterisc: vm.Config{ - L1GenesisPath: ctx.String(L1GenesisFlag.Name), - VmType: types.TraceTypeAsterisc, - L1: l1EthRpc, - L1Beacon: l1Beacon, - L1BeaconSkipBlobVerification: l1BeaconSkipBlobVerification, - L2s: l2Rpcs, - L2Experimental: l2Experimental, - VmBin: ctx.String(AsteriscBinFlag.Name), - Server: ctx.String(AsteriscServerFlag.Name), - Networks: networks, - RollupConfigPaths: RollupConfigFlag.StringSlice(ctx, types.TraceTypeAsterisc), - L2GenesisPaths: L2GenesisFlag.StringSlice(ctx, types.TraceTypeAsterisc), - DepsetConfigPath: DepsetConfigFlag.String(ctx, types.TraceTypeAsterisc), - SnapshotFreq: ctx.Uint(AsteriscSnapshotFreqFlag.Name), - InfoFreq: ctx.Uint(AsteriscInfoFreqFlag.Name), - BinarySnapshots: true, + L1GenesisPath: ctx.String(L1GenesisFlag.Name), + VmType: types.TraceTypeAsterisc, + L1: l1EthRpc, + L1Beacon: l1Beacon, + L2s: l2Rpcs, + L2Experimental: l2Experimental, + VmBin: ctx.String(AsteriscBinFlag.Name), + Server: ctx.String(AsteriscServerFlag.Name), + Networks: networks, + RollupConfigPaths: RollupConfigFlag.StringSlice(ctx, types.TraceTypeAsterisc), + L2GenesisPaths: L2GenesisFlag.StringSlice(ctx, types.TraceTypeAsterisc), + DepsetConfigPath: DepsetConfigFlag.String(ctx, types.TraceTypeAsterisc), + SnapshotFreq: ctx.Uint(AsteriscSnapshotFreqFlag.Name), + InfoFreq: ctx.Uint(AsteriscInfoFreqFlag.Name), + BinarySnapshots: true, }, AsteriscAbsolutePreState: ctx.String(AsteriscPreStateFlag.Name), AsteriscAbsolutePreStateBaseURL: asteriscPreStatesURL, AsteriscKona: vm.Config{ - L1GenesisPath: ctx.String(L1GenesisFlag.Name), - VmType: types.TraceTypeAsteriscKona, - L1: l1EthRpc, - L1Beacon: l1Beacon, - L1BeaconSkipBlobVerification: l1BeaconSkipBlobVerification, - L2s: l2Rpcs, - L2Experimental: l2Experimental, - VmBin: ctx.String(AsteriscBinFlag.Name), - Server: ctx.String(AsteriscKonaServerFlag.Name), - Networks: networks, - L2Custom: ctx.Bool(AsteriscKonaL2CustomFlag.Name), - RollupConfigPaths: RollupConfigFlag.StringSlice(ctx, types.TraceTypeAsteriscKona), - L2GenesisPaths: L2GenesisFlag.StringSlice(ctx, types.TraceTypeAsteriscKona), - DepsetConfigPath: DepsetConfigFlag.String(ctx, types.TraceTypeAsteriscKona), - SnapshotFreq: ctx.Uint(AsteriscSnapshotFreqFlag.Name), - InfoFreq: ctx.Uint(AsteriscInfoFreqFlag.Name), - BinarySnapshots: true, + L1GenesisPath: ctx.String(L1GenesisFlag.Name), + VmType: types.TraceTypeAsteriscKona, + L1: l1EthRpc, + L1Beacon: l1Beacon, + L2s: l2Rpcs, + L2Experimental: l2Experimental, + VmBin: ctx.String(AsteriscBinFlag.Name), + Server: ctx.String(AsteriscKonaServerFlag.Name), + Networks: networks, + L2Custom: ctx.Bool(AsteriscKonaL2CustomFlag.Name), + RollupConfigPaths: RollupConfigFlag.StringSlice(ctx, types.TraceTypeAsteriscKona), + L2GenesisPaths: L2GenesisFlag.StringSlice(ctx, types.TraceTypeAsteriscKona), + DepsetConfigPath: DepsetConfigFlag.String(ctx, types.TraceTypeAsteriscKona), + SnapshotFreq: ctx.Uint(AsteriscSnapshotFreqFlag.Name), + InfoFreq: ctx.Uint(AsteriscInfoFreqFlag.Name), + BinarySnapshots: true, }, AsteriscKonaAbsolutePreState: ctx.String(AsteriscKonaPreStateFlag.Name), AsteriscKonaAbsolutePreStateBaseURL: asteriscKonaPreStatesURL, diff --git a/op-challenger/game/fault/trace/vm/executor.go b/op-challenger/game/fault/trace/vm/executor.go index 4aa2d7673e1..38fe3791c84 100644 --- a/op-challenger/game/fault/trace/vm/executor.go +++ b/op-challenger/game/fault/trace/vm/executor.go @@ -49,18 +49,17 @@ type Config struct { BinarySnapshots bool // Whether to use binary snapshots instead of JSON // Host Configuration - L1 string - L1Beacon string - L1BeaconSkipBlobVerification bool // Skip verification of the KZG proof for each blob. Not recommended unless the provided beacon endpoints are trusted. - L2s []string - L2Experimental string - Server string // Path to the executable that provides the pre-image oracle server - Networks []string - L2Custom bool - RollupConfigPaths []string - L1GenesisPath string - L2GenesisPaths []string - DepsetConfigPath string + L1 string + L1Beacon string + L2s []string + L2Experimental string + Server string // Path to the executable that provides the pre-image oracle server + Networks []string + L2Custom bool + RollupConfigPaths []string + L1GenesisPath string + L2GenesisPaths []string + DepsetConfigPath string } func (c *Config) Check() error { diff --git a/op-challenger/game/fault/trace/vm/kona_server_executor.go b/op-challenger/game/fault/trace/vm/kona_server_executor.go index 8d5337f9abe..76da8269754 100644 --- a/op-challenger/game/fault/trace/vm/kona_server_executor.go +++ b/op-challenger/game/fault/trace/vm/kona_server_executor.go @@ -61,9 +61,5 @@ func (s *KonaExecutor) OracleCommand(cfg Config, dataDir string, inputs utils.Lo args = append(args, "--l1-config-path", cfg.L1GenesisPath) } - if cfg.L1BeaconSkipBlobVerification { - args = append(args, "--l1-beacon-skip-blob-verification") - } - return args, nil } diff --git a/op-challenger/game/fault/trace/vm/kona_server_executor_test.go b/op-challenger/game/fault/trace/vm/kona_server_executor_test.go index e55fd59cb51..8894bfab8b2 100644 --- a/op-challenger/game/fault/trace/vm/kona_server_executor_test.go +++ b/op-challenger/game/fault/trace/vm/kona_server_executor_test.go @@ -46,76 +46,3 @@ func TestKonaFillHostCommand(t *testing.T) { require.True(t, slices.Contains(args, "--claimed-l2-block-number")) require.True(t, slices.Contains(args, "--l1-config-path")) } - -func TestKonaL1BeaconSkipBlobVerification(t *testing.T) { - dir := "mockdir" - baseCfg := Config{ - L1: "http://localhost:8888", - L1Beacon: "http://localhost:9000", - L2s: []string{"http://localhost:9999"}, - Server: "./bin/mockserver", - Networks: []string{"op-mainnet"}, - L1GenesisPath: "mockdir/l1-genesis-1.json", - } - inputs := utils.LocalGameInputs{ - L1Head: common.Hash{0x11}, - L2Head: common.Hash{0x22}, - L2OutputRoot: common.Hash{0x33}, - L2Claim: common.Hash{0x44}, - L2SequenceNumber: big.NewInt(3333), - } - - t.Run("NotIncludedByDefault", func(t *testing.T) { - cfg := baseCfg - cfg.L1BeaconSkipBlobVerification = false - vmConfig := NewKonaExecutor() - args, err := vmConfig.OracleCommand(cfg, dir, inputs) - require.NoError(t, err) - require.False(t, slices.Contains(args, "--l1-beacon-skip-blob-verification")) - }) - - t.Run("IncludedWhenTrue", func(t *testing.T) { - cfg := baseCfg - cfg.L1BeaconSkipBlobVerification = true - vmConfig := NewKonaExecutor() - args, err := vmConfig.OracleCommand(cfg, dir, inputs) - require.NoError(t, err) - require.True(t, slices.Contains(args, "--l1-beacon-skip-blob-verification")) - }) -} - -func TestKonaSuperL1BeaconSkipBlobVerification(t *testing.T) { - dir := "mockdir" - baseCfg := Config{ - L1: "http://localhost:8888", - L1Beacon: "http://localhost:9000", - L2s: []string{"http://localhost:9999", "http://localhost:9998"}, - Server: "./bin/mockserver", - RollupConfigPaths: []string{"rollup1.json", "rollup2.json"}, - L1GenesisPath: "mockdir/l1-genesis-1.json", - } - inputs := utils.LocalGameInputs{ - L1Head: common.Hash{0x11}, - AgreedPreState: []byte{1, 2, 3, 4}, - L2Claim: common.Hash{0x44}, - L2SequenceNumber: big.NewInt(3333), - } - - t.Run("NotIncludedByDefault", func(t *testing.T) { - cfg := baseCfg - cfg.L1BeaconSkipBlobVerification = false - vmConfig := NewKonaSuperExecutor() - args, err := vmConfig.OracleCommand(cfg, dir, inputs) - require.NoError(t, err) - require.False(t, slices.Contains(args, "--l1-beacon-skip-blob-verification")) - }) - - t.Run("IncludedWhenTrue", func(t *testing.T) { - cfg := baseCfg - cfg.L1BeaconSkipBlobVerification = true - vmConfig := NewKonaSuperExecutor() - args, err := vmConfig.OracleCommand(cfg, dir, inputs) - require.NoError(t, err) - require.True(t, slices.Contains(args, "--l1-beacon-skip-blob-verification")) - }) -} diff --git a/op-challenger/game/fault/trace/vm/kona_super_server_executor.go b/op-challenger/game/fault/trace/vm/kona_super_server_executor.go index 8843abf33de..5aa347f70e5 100644 --- a/op-challenger/game/fault/trace/vm/kona_super_server_executor.go +++ b/op-challenger/game/fault/trace/vm/kona_super_server_executor.go @@ -54,9 +54,5 @@ func (s *KonaSuperExecutor) OracleCommand(cfg Config, dataDir string, inputs uti args = append(args, "--l1-config-path", cfg.L1GenesisPath) } - if cfg.L1BeaconSkipBlobVerification { - args = append(args, "--l1-beacon-skip-blob-verification") - } - return args, nil } diff --git a/op-challenger/game/fault/trace/vm/op_program_server_executor.go b/op-challenger/game/fault/trace/vm/op_program_server_executor.go index a89b3389434..c56d3aa4b79 100644 --- a/op-challenger/game/fault/trace/vm/op_program_server_executor.go +++ b/op-challenger/game/fault/trace/vm/op_program_server_executor.go @@ -75,8 +75,5 @@ func (s *OpProgramServerExecutor) OracleCommand(cfg Config, dataDir string, inpu if cfg.L1GenesisPath != "" { args = append(args, "--l1.config", cfg.L1GenesisPath) } - if cfg.L1BeaconSkipBlobVerification { - args = append(args, "--l1.beacon.skip-blob-verification") - } return args, nil } diff --git a/op-challenger/game/fault/trace/vm/op_program_server_executor_test.go b/op-challenger/game/fault/trace/vm/op_program_server_executor_test.go index 72f7b20a7be..37fa6a26007 100644 --- a/op-challenger/game/fault/trace/vm/op_program_server_executor_test.go +++ b/op-challenger/game/fault/trace/vm/op_program_server_executor_test.go @@ -20,8 +20,8 @@ func TestOpProgramFillHostCommand(t *testing.T) { toPairs := func(args []string) map[string]string { pairs := make(map[string]string, len(args)/2) for i := 0; i < len(args); i += 2 { - // Boolean flags can't accept a value after a space - if args[i] == "--l2.custom" || args[i] == "--l1.beacon.skip-blob-verification" { + // l2.custom is a boolean flag so can't accept a value after a space + if args[i] == "--l2.custom" { pairs[args[i]] = "true" i-- continue @@ -217,18 +217,4 @@ func TestOpProgramFillHostCommand(t *testing.T) { require.Equal(t, pairs["--log.level"], logTest.arg) }) } - - t.Run("WithoutL1BeaconSkipBlobVerification", func(t *testing.T) { - pairs := oracleCommand(t, log.LvlInfo, func(c *Config, _ *utils.LocalGameInputs) { - c.L1BeaconSkipBlobVerification = false - }) - require.NotContains(t, pairs, "--l1.beacon.skip-blob-verification") - }) - - t.Run("WithL1BeaconSkipBlobVerification", func(t *testing.T) { - pairs := oracleCommand(t, log.LvlInfo, func(c *Config, _ *utils.LocalGameInputs) { - c.L1BeaconSkipBlobVerification = true - }) - require.Equal(t, "true", pairs["--l1.beacon.skip-blob-verification"]) - }) } diff --git a/op-node/config/beacon.go b/op-node/config/beacon.go index 679deba22d1..2de46e217aa 100644 --- a/op-node/config/beacon.go +++ b/op-node/config/beacon.go @@ -19,17 +19,15 @@ type L1BeaconEndpointSetup interface { // ShouldIgnoreBeaconCheck returns true if the Beacon-node version check should not halt startup. ShouldIgnoreBeaconCheck() bool ShouldFetchAllSidecars() bool - ShouldSkipBlobVerification() bool Check() error } type L1BeaconEndpointConfig struct { - BeaconAddr string // Address of L1 User Beacon-API endpoint to use (beacon namespace required) - BeaconHeader string // Optional HTTP header for all requests to L1 Beacon - BeaconFallbackAddrs []string // Addresses of L1 Beacon-API fallback endpoints (only for blob sidecars retrieval) - BeaconCheckIgnore bool // When false, halt startup if the beacon version endpoint fails - BeaconFetchAllSidecars bool // Whether to fetch all blob sidecars and filter locally - BeaconSkipBlobVerification bool // Whether to skip the verification of the kzg_proof for each blob returned by the Beacon node + BeaconAddr string // Address of L1 User Beacon-API endpoint to use (beacon namespace required) + BeaconHeader string // Optional HTTP header for all requests to L1 Beacon + BeaconFallbackAddrs []string // Addresses of L1 Beacon-API fallback endpoints (only for blob sidecars retrieval) + BeaconCheckIgnore bool // When false, halt startup if the beacon version endpoint fails + BeaconFetchAllSidecars bool // Whether to fetch all blob sidecars and filter locally } var _ L1BeaconEndpointSetup = (*L1BeaconEndpointConfig)(nil) @@ -68,10 +66,6 @@ func (cfg *L1BeaconEndpointConfig) ShouldFetchAllSidecars() bool { return cfg.BeaconFetchAllSidecars } -func (cfg *L1BeaconEndpointConfig) ShouldSkipBlobVerification() bool { - return cfg.BeaconSkipBlobVerification -} - func parseHTTPHeader(headerStr string) (http.Header, error) { h := make(http.Header, 1) s := strings.SplitN(headerStr, ": ", 2) diff --git a/op-node/flags/flags.go b/op-node/flags/flags.go index d7ff28eb468..d98e959a295 100644 --- a/op-node/flags/flags.go +++ b/op-node/flags/flags.go @@ -107,14 +107,6 @@ var ( EnvVars: prefixEnvVars("L1_BEACON_FETCH_ALL_SIDECARS"), Category: L1RPCCategory, } - BeaconSkipBlobVerification = &cli.BoolFlag{ - Name: "l1.beacon.skip-blob-verification", - Usage: "If true, skips the verification of the kzg_proof for each blob returned by the Beacon node. Not recommended unless the provided beacon endpoints are trusted.", - Required: false, - Value: false, - EnvVars: prefixEnvVars("L1_BEACON_SKIP_BLOB_VERIFICATION"), - Category: L1RPCCategory, - } SyncModeFlag = &cli.GenericFlag{ Name: "syncmode", Usage: fmt.Sprintf("Blockchain sync mode (options: %s)", openum.EnumString(sync.ModeStrings)), @@ -442,7 +434,6 @@ var optionalFlags = []cli.Flag{ BeaconFallbackAddrs, BeaconCheckIgnore, BeaconFetchAllSidecars, - BeaconSkipBlobVerification, SyncModeFlag, FetchWithdrawalRootFromState, L1TrustRPC, diff --git a/op-node/node/node.go b/op-node/node/node.go index 960e822434e..2cf93f6800e 100644 --- a/op-node/node/node.go +++ b/op-node/node/node.go @@ -362,8 +362,7 @@ func (n *OpNode) initL1BeaconAPI(ctx context.Context, cfg *config.Config) error return fmt.Errorf("failed to setup L1 Beacon API client: %w", err) } beaconCfg := sources.L1BeaconClientConfig{ - FetchAllSidecars: cfg.Beacon.ShouldFetchAllSidecars(), - SkipBlobVerification: cfg.Beacon.ShouldSkipBlobVerification(), + FetchAllSidecars: cfg.Beacon.ShouldFetchAllSidecars(), } n.beacon = sources.NewL1BeaconClient(beaconClient, beaconCfg, fallbacks...) diff --git a/op-node/service.go b/op-node/service.go index 875b366bee8..af72a6c4b78 100644 --- a/op-node/service.go +++ b/op-node/service.go @@ -158,12 +158,11 @@ func NewSupervisorEndpointConfig(ctx *cli.Context) *interop.Config { func NewBeaconEndpointConfig(ctx *cli.Context) config.L1BeaconEndpointSetup { return &config.L1BeaconEndpointConfig{ - BeaconAddr: ctx.String(flags.BeaconAddr.Name), - BeaconHeader: ctx.String(flags.BeaconHeader.Name), - BeaconFallbackAddrs: ctx.StringSlice(flags.BeaconFallbackAddrs.Name), - BeaconCheckIgnore: ctx.Bool(flags.BeaconCheckIgnore.Name), - BeaconFetchAllSidecars: ctx.Bool(flags.BeaconFetchAllSidecars.Name), - BeaconSkipBlobVerification: ctx.Bool(flags.BeaconSkipBlobVerification.Name), + BeaconAddr: ctx.String(flags.BeaconAddr.Name), + BeaconHeader: ctx.String(flags.BeaconHeader.Name), + BeaconFallbackAddrs: ctx.StringSlice(flags.BeaconFallbackAddrs.Name), + BeaconCheckIgnore: ctx.Bool(flags.BeaconCheckIgnore.Name), + BeaconFetchAllSidecars: ctx.Bool(flags.BeaconFetchAllSidecars.Name), } } diff --git a/op-program/host/config/config.go b/op-program/host/config/config.go index 5dde48f8695..3aa5190bdcd 100644 --- a/op-program/host/config/config.go +++ b/op-program/host/config/config.go @@ -60,12 +60,11 @@ type Config struct { DataFormat types.DataFormat // L1Head is the block hash of the L1 chain head block - L1Head common.Hash - L1URL string - L1BeaconURL string - L1BeaconSkipBlobVerification bool // Skip verification of the KZG proof for each blob. Not recommended unless the provided beacon endpoints are trusted. - L1TrustRPC bool - L1RPCKind sources.RPCProviderKind + L1Head common.Hash + L1URL string + L1BeaconURL string + L1TrustRPC bool + L1RPCKind sources.RPCProviderKind // L2Head is the l2 block hash contained in the L2 Output referenced by the L2OutputRoot for pre-interop mode L2Head common.Hash @@ -397,29 +396,28 @@ func NewConfigFromCLI(log log.Logger, ctx *cli.Context) (*Config, error) { } return &Config{ - L2ChainID: l2ChainID, - Rollups: rollupCfgs, - L1ChainConfig: l1ChainConfig, - DataDir: ctx.String(flags.DataDir.Name), - DataFormat: dbFormat, - L2URLs: ctx.StringSlice(flags.L2NodeAddr.Name), - L2ExperimentalURLs: ctx.StringSlice(flags.L2NodeExperimentalAddr.Name), - L2ChainConfigs: l2ChainConfigs, - L2Head: l2Head, - L2OutputRoot: l2OutputRoot, - AgreedPrestate: agreedPrestate, - DependencySet: dependencySet, - L2Claim: l2Claim, - L2ClaimBlockNumber: l2ClaimBlockNum, - L1Head: l1Head, - L1URL: ctx.String(flags.L1NodeAddr.Name), - L1BeaconURL: ctx.String(flags.L1BeaconAddr.Name), - L1BeaconSkipBlobVerification: ctx.Bool(flags.L1BeaconSkipBlobVerification.Name), - L1TrustRPC: ctx.Bool(flags.L1TrustRPC.Name), - L1RPCKind: sources.RPCProviderKind(ctx.String(flags.L1RPCProviderKind.Name)), - ExecCmd: ctx.String(flags.Exec.Name), - ServerMode: ctx.Bool(flags.Server.Name), - InteropEnabled: interopEnabled, + L2ChainID: l2ChainID, + Rollups: rollupCfgs, + L1ChainConfig: l1ChainConfig, + DataDir: ctx.String(flags.DataDir.Name), + DataFormat: dbFormat, + L2URLs: ctx.StringSlice(flags.L2NodeAddr.Name), + L2ExperimentalURLs: ctx.StringSlice(flags.L2NodeExperimentalAddr.Name), + L2ChainConfigs: l2ChainConfigs, + L2Head: l2Head, + L2OutputRoot: l2OutputRoot, + AgreedPrestate: agreedPrestate, + DependencySet: dependencySet, + L2Claim: l2Claim, + L2ClaimBlockNumber: l2ClaimBlockNum, + L1Head: l1Head, + L1URL: ctx.String(flags.L1NodeAddr.Name), + L1BeaconURL: ctx.String(flags.L1BeaconAddr.Name), + L1TrustRPC: ctx.Bool(flags.L1TrustRPC.Name), + L1RPCKind: sources.RPCProviderKind(ctx.String(flags.L1RPCProviderKind.Name)), + ExecCmd: ctx.String(flags.Exec.Name), + ServerMode: ctx.Bool(flags.Server.Name), + InteropEnabled: interopEnabled, }, nil } diff --git a/op-program/host/config/config_test.go b/op-program/host/config/config_test.go index b66b4eb2787..0dc868adb6c 100644 --- a/op-program/host/config/config_test.go +++ b/op-program/host/config/config_test.go @@ -310,24 +310,3 @@ func validInteropConfig() *Config { cfg.L2OutputRoot = crypto.Keccak256Hash(cfg.AgreedPrestate) return cfg } - -func TestL1BeaconSkipBlobVerification(t *testing.T) { - t.Run("DefaultIsFalse", func(t *testing.T) { - cfg := validConfig() - require.False(t, cfg.L1BeaconSkipBlobVerification, "L1BeaconSkipBlobVerification should default to false") - }) - - t.Run("CanBeSetToTrue", func(t *testing.T) { - cfg := validConfig() - cfg.L1BeaconSkipBlobVerification = true - require.True(t, cfg.L1BeaconSkipBlobVerification) - require.NoError(t, cfg.Check()) - }) - - t.Run("WorksWithInterop", func(t *testing.T) { - cfg := validInteropConfig() - cfg.L1BeaconSkipBlobVerification = true - require.True(t, cfg.L1BeaconSkipBlobVerification) - require.NoError(t, cfg.Check()) - }) -} diff --git a/op-program/host/flags/flags.go b/op-program/host/flags/flags.go index cd666b97b2c..01aab199071 100644 --- a/op-program/host/flags/flags.go +++ b/op-program/host/flags/flags.go @@ -112,12 +112,6 @@ var ( Usage: "Address of L1 Beacon API endpoint to use", EnvVars: prefixEnvVars("L1_BEACON_API"), } - L1BeaconSkipBlobVerification = &cli.BoolFlag{ - Name: "l1.beacon.skip-blob-verification", - Usage: "Skip verification of the kzg_proof for each blob returned by the Beacon node. Not recommended unless the provided beacon endpoints are trusted.", - Value: false, - EnvVars: prefixEnvVars("L1_BEACON_SKIP_BLOB_VERIFICATION"), - } L1TrustRPC = &cli.BoolFlag{ Name: "l1.trustrpc", Usage: "Trust the L1 RPC, sync faster at risk of malicious/buggy RPC providing bad or inconsistent L1 data", @@ -175,7 +169,6 @@ var programFlags = []cli.Flag{ L2GenesisPath, L1NodeAddr, L1BeaconAddr, - L1BeaconSkipBlobVerification, L1TrustRPC, L1RPCProviderKind, DepsetConfig, diff --git a/op-program/host/host.go b/op-program/host/host.go index 5f3a3f54797..be9063f3169 100644 --- a/op-program/host/host.go +++ b/op-program/host/host.go @@ -95,10 +95,7 @@ func makeDefaultPrefetcher(ctx context.Context, logger log.Logger, kv kvstore.KV logger.Info("Connecting to L1 beacon", "l1", cfg.L1BeaconURL) l1Beacon := sources.NewBeaconHTTPClient(client.NewBasicHTTPClient(cfg.L1BeaconURL, logger)) - l1BlobFetcher := sources.NewL1BeaconClient(l1Beacon, sources.L1BeaconClientConfig{ - FetchAllSidecars: false, - SkipBlobVerification: cfg.L1BeaconSkipBlobVerification, - }) + l1BlobFetcher := sources.NewL1BeaconClient(l1Beacon, sources.L1BeaconClientConfig{FetchAllSidecars: false}) logger.Info("Initializing L2 clients") sources, err := prefetcher.NewRetryingL2SourcesFromURLs(ctx, logger, cfg.Rollups, cfg.L2URLs, cfg.L2ExperimentalURLs) diff --git a/op-service/sources/l1_beacon_client.go b/op-service/sources/l1_beacon_client.go index f6586de8d40..7400c7e9482 100644 --- a/op-service/sources/l1_beacon_client.go +++ b/op-service/sources/l1_beacon_client.go @@ -13,7 +13,7 @@ import ( "sync" "github.com/ethereum/go-ethereum" - "github.com/ethereum/go-ethereum/crypto/kzg4844" + "github.com/ethereum/go-ethereum/common" "github.com/ethereum-optimism/optimism/op-service/apis" "github.com/ethereum-optimism/optimism/op-service/client" @@ -28,8 +28,7 @@ const ( ) type L1BeaconClientConfig struct { - FetchAllSidecars bool - SkipBlobVerification bool + FetchAllSidecars bool } // L1BeaconClient is a high level golang client for the Beacon API. @@ -272,42 +271,45 @@ func (cl *L1BeaconClient) GetBlobs(ctx context.Context, ref eth.L1BlockRef, hash if err != nil { return nil, fmt.Errorf("failed to get blob sidecars for L1BlockRef %s: %w", ref, err) } - blobs, err := blobsFromSidecars(blobSidecars, hashes, cl.cfg.SkipBlobVerification) + blobs, err := blobsFromSidecars(blobSidecars, hashes) if err != nil { return nil, fmt.Errorf("failed to get blobs from sidecars for L1BlockRef %s: %w", ref, err) } return blobs, nil } -func blobsFromSidecars(blobSidecars []*eth.BlobSidecar, hashes []eth.IndexedBlobHash, skipBlobVerification bool) ([]*eth.Blob, error) { +func blobsFromSidecars(blobSidecars []*eth.BlobSidecar, hashes []eth.IndexedBlobHash) ([]*eth.Blob, error) { if len(blobSidecars) != len(hashes) { return nil, fmt.Errorf("number of hashes and blobSidecars mismatch, %d != %d", len(hashes), len(blobSidecars)) } - out := make([]*eth.Blob, len(hashes)) for i, ih := range hashes { sidecar := blobSidecars[i] if sidx := uint64(sidecar.Index); sidx != ih.Index { return nil, fmt.Errorf("expected sidecars to be ordered by hashes, but got %d != %d", sidx, ih.Index) } - - // make sure the blob's kzg commitment hashes to the expected value - hash := eth.KZGToVersionedHash(kzg4844.Commitment(sidecar.KZGCommitment)) - if hash != ih.Hash { - return nil, fmt.Errorf("expected hash %s for blob at index %d but got %s", ih.Hash, ih.Index, hash) - } - - if !skipBlobVerification { - // confirm blob data is valid by verifying its proof against the commitment - if err := eth.VerifyBlobProof(&sidecar.Blob, kzg4844.Commitment(sidecar.KZGCommitment), kzg4844.Proof(sidecar.KZGProof)); err != nil { - return nil, fmt.Errorf("blob at index %d failed verification: %w", i, err) - } + if err := verifyBlob(&sidecar.Blob, ih.Hash); err != nil { + return nil, fmt.Errorf("blob %d failed verification: %w", i, err) } out[i] = &sidecar.Blob } return out, nil } +// verifyBlob verifies that the blob data corresponds to the provided commitment. +// It recomputes the commitment from the blob data and checks it matches the expected commitment hash. +func verifyBlob(blob *eth.Blob, expectedCommitmentHash common.Hash) error { + recomputedCommitment, err := blob.ComputeKZGCommitment() + if err != nil { + return fmt.Errorf("cannot compute KZG commitment for blob: %w", err) + } + recomputedCommitmentHash := eth.KZGToVersionedHash(recomputedCommitment) + if recomputedCommitmentHash != expectedCommitmentHash { + return fmt.Errorf("recomputed commitment %s does not match expected commitment %s", recomputedCommitmentHash, expectedCommitmentHash) + } + return nil +} + // GetVersion fetches the version of the Beacon-node. func (cl *L1BeaconClient) GetVersion(ctx context.Context) (string, error) { return cl.cl.NodeVersion(ctx) diff --git a/op-service/sources/l1_beacon_client_test.go b/op-service/sources/l1_beacon_client_test.go index 2a6cfafba0a..0e39d192891 100644 --- a/op-service/sources/l1_beacon_client_test.go +++ b/op-service/sources/l1_beacon_client_test.go @@ -16,6 +16,7 @@ import ( "github.com/stretchr/testify/assert" "github.com/stretchr/testify/require" + "github.com/ethereum/go-ethereum/common" "github.com/ethereum/go-ethereum/common/hexutil" "github.com/ethereum/go-ethereum/crypto/kzg4844" @@ -63,17 +64,17 @@ func TestBlobsFromSidecars(t *testing.T) { // put the sidecars in scrambled order to confirm error sidecars := []*eth.BlobSidecar{sidecar2, sidecar0, sidecar1} - _, err := blobsFromSidecars(sidecars, hashes, false) + _, err := blobsFromSidecars(sidecars, hashes) require.Error(t, err) // too few sidecars should error sidecars = []*eth.BlobSidecar{sidecar0, sidecar1} - _, err = blobsFromSidecars(sidecars, hashes, false) + _, err = blobsFromSidecars(sidecars, hashes) require.Error(t, err) // correct order should work sidecars = []*eth.BlobSidecar{sidecar0, sidecar1, sidecar2} - blobs, err := blobsFromSidecars(sidecars, hashes, false) + blobs, err := blobsFromSidecars(sidecars, hashes) require.NoError(t, err) // confirm order by checking first blob byte against expected index for i := range blobs { @@ -84,20 +85,20 @@ func TestBlobsFromSidecars(t *testing.T) { badProof := *sidecar0 badProof.KZGProof[11]++ sidecars[1] = &badProof - _, err = blobsFromSidecars(sidecars, hashes, false) + _, err = blobsFromSidecars(sidecars, hashes) require.Error(t, err) // mangle a commitment to make sure it's detected badCommitment := *sidecar0 badCommitment.KZGCommitment[13]++ sidecars[1] = &badCommitment - _, err = blobsFromSidecars(sidecars, hashes, false) + _, err = blobsFromSidecars(sidecars, hashes) require.Error(t, err) // mangle a hash to make sure it's detected sidecars[1] = sidecar0 hashes[2].Hash[17]++ - _, err = blobsFromSidecars(sidecars, hashes, false) + _, err = blobsFromSidecars(sidecars, hashes) require.Error(t, err) } @@ -117,7 +118,7 @@ func KZGProofFromHex(s string) (kzg4844.Proof, error) { var badProof, _ = KZGProofFromHex("0xc00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000") -func TestBlobsFromSidecars_SkipBlobVerification(t *testing.T) { +func TestBlobsFromSidecars_BadProof(t *testing.T) { indices := []uint64{5, 7, 2} index0, sidecar0 := makeTestBlobSidecar(indices[0]) index1, sidecar1 := makeTestBlobSidecar(indices[1]) @@ -129,20 +130,16 @@ func TestBlobsFromSidecars_SkipBlobVerification(t *testing.T) { // Set proof to a bad / stubbed value sidecars[1].KZGProof = eth.Bytes48(badProof) - // Check that verification succeeds when skipBlobVerification is true - _, err := blobsFromSidecars(sidecars, hashes, true) + // Check that verification succeeds, the proof is not required + _, err := blobsFromSidecars(sidecars, hashes) require.NoError(t, err) - // Check that verification fails when skipBlobVerification is false - _, err = blobsFromSidecars(sidecars, hashes, false) - require.Error(t, err) - } func TestBlobsFromSidecars_EmptySidecarList(t *testing.T) { hashes := []eth.IndexedBlobHash{} sidecars := []*eth.BlobSidecar{} - blobs, err := blobsFromSidecars(sidecars, hashes, false) + blobs, err := blobsFromSidecars(sidecars, hashes) require.NoError(t, err) require.Empty(t, blobs, "blobs should be empty when no sidecars are provided") } @@ -228,7 +225,7 @@ func TestBeaconClientFallback(t *testing.T) { require.NoError(t, err) } -func TestBeaconClientSkipBlobVerification(t *testing.T) { +func TestBeaconClientBadProof(t *testing.T) { indices := []uint64{5, 7, 2} index0, sidecar0 := makeTestBlobSidecar(indices[0]) index1, sidecar1 := makeTestBlobSidecar(indices[1]) @@ -246,17 +243,10 @@ func TestBeaconClientSkipBlobVerification(t *testing.T) { p.EXPECT().BeaconGenesis(ctx).Return(eth.APIGenesisResponse{Data: eth.ReducedGenesisData{GenesisTime: 10}}, nil) p.EXPECT().ConfigSpec(ctx).Return(eth.APIConfigResponse{Data: eth.ReducedConfigData{SecondsPerSlot: 2}}, nil) - clientWithValidation := NewL1BeaconClient(p, L1BeaconClientConfig{SkipBlobVerification: false}) + clientWithValidation := NewL1BeaconClient(p, L1BeaconClientConfig{}) p.EXPECT().BeaconBlobSideCars(ctx, false, uint64(1), hashes).Return(eth.APIGetBlobSidecarsResponse{Data: apiSidecars}, nil) _, err := clientWithValidation.GetBlobs(ctx, eth.L1BlockRef{Time: 12}, hashes) - assert.Error(t, err) - - p.EXPECT().BeaconGenesis(ctx).Return(eth.APIGenesisResponse{Data: eth.ReducedGenesisData{GenesisTime: 10}}, nil) - p.EXPECT().ConfigSpec(ctx).Return(eth.APIConfigResponse{Data: eth.ReducedConfigData{SecondsPerSlot: 2}}, nil) - clientWithoutValidation := NewL1BeaconClient(p, L1BeaconClientConfig{SkipBlobVerification: true}) - p.EXPECT().BeaconBlobSideCars(ctx, false, uint64(1), hashes).Return(eth.APIGetBlobSidecarsResponse{Data: apiSidecars}, nil) - _, err = clientWithoutValidation.GetBlobs(ctx, eth.L1BlockRef{Time: 12}, hashes) - assert.NoError(t, err) + assert.NoError(t, err) // The verification flow does not require a valid proof } func TestBeaconHTTPClient(t *testing.T) { @@ -304,3 +294,14 @@ func TestClientPoolSeveral(t *testing.T) { p.MoveToNext() } } + +func TestVerifyBlob(t *testing.T) { + blob := eth.Blob{} + blob[0] = byte(7) + versionedHash := common.HexToHash("0x0164e32184169f11528f72aeb318f94d958aa28fba0731a52aead6df0104a98e") + require.NoError(t, verifyBlob(&blob, versionedHash)) + + differentBlob := eth.Blob{} + differentBlob[0] = byte(8) + require.Error(t, verifyBlob(&differentBlob, versionedHash)) +} From 4e726c6e6d81c82ca94bbbbd3b626a99e7e3a0d9 Mon Sep 17 00:00:00 2001 From: Josh Klopfenstein Date: Mon, 6 Oct 2025 06:45:26 -0700 Subject: [PATCH 008/117] sysgo: add Osaka activation test (#17529) * op-service/txplan: support blob txs * op-service/txinclude: handle future nonce gaps This can happen when we get mempool errors like "nonce too high", which itself can occur when we hit "account limit exceeded" errors in the blob pool. * sysgo: add Osaka activation test * sysext: infer L1 config when possible --- devnet-sdk/shell/env/devnet.go | 9 +- mise.toml | 1 + .../tests/interop/loadtest/schedule.go | 14 +- op-acceptance-tests/tests/osaka/osaka_test.go | 214 ++++++++++++++++++ .../deployer/pipeline/seal_l1_dev_genesis.go | 3 + op-deployer/pkg/deployer/state/intent.go | 11 + op-devstack/dsl/el.go | 12 + op-devstack/sysgo/engine_client.go | 4 + op-devstack/sysgo/l1_nodes_subprocess.go | 7 +- op-e2e/e2eutils/geth/fakepos.go | 11 +- op-e2e/e2eutils/intentbuilder/builder.go | 22 ++ op-e2e/e2eutils/intentbuilder/builder_test.go | 6 + op-service/txinclude/nonce_manager.go | 6 +- op-service/txinclude/nonce_manager_test.go | 24 ++ op-service/txplan/txplan.go | 52 ++++- 15 files changed, 386 insertions(+), 10 deletions(-) create mode 100644 op-acceptance-tests/tests/osaka/osaka_test.go diff --git a/devnet-sdk/shell/env/devnet.go b/devnet-sdk/shell/env/devnet.go index e766a0032ef..2f1d3baf6eb 100644 --- a/devnet-sdk/shell/env/devnet.go +++ b/devnet-sdk/shell/env/devnet.go @@ -11,6 +11,7 @@ import ( "github.com/ethereum-optimism/optimism/devnet-sdk/controller/surface" "github.com/ethereum-optimism/optimism/devnet-sdk/descriptors" "github.com/ethereum-optimism/optimism/op-node/rollup" + "github.com/ethereum-optimism/optimism/op-service/eth" "github.com/ethereum/go-ethereum/params" ) @@ -138,8 +139,12 @@ func fixupDevnetConfig(config *descriptors.DevnetEnvironment) error { return fmt.Errorf("invalid L1 ID: %s", config.L1.ID) } if config.L1.Config == nil { - config.L1.Config = ¶ms.ChainConfig{ - ChainID: l1ID, + if l1Config := eth.L1ChainConfigByChainID(eth.ChainIDFromBig(l1ID)); l1Config != nil { + config.L1.Config = l1Config + } else { + config.L1.Config = ¶ms.ChainConfig{ + ChainID: l1ID, + } } } for _, l2Chain := range config.L2 { diff --git a/mise.toml b/mise.toml index 76ca9d78a5c..6b8d56fd773 100644 --- a/mise.toml +++ b/mise.toml @@ -15,6 +15,7 @@ svm-rs = "0.5.19" # Go dependencies "go:github.com/ethereum/go-ethereum/cmd/abigen" = "1.15.10" +"go:github.com/ethereum/go-ethereum/cmd/geth" = "1.16.4" # Osaka release. "go:gotest.tools/gotestsum" = "1.12.1" "go:github.com/vektra/mockery/v2" = "2.46.0" "go:github.com/golangci/golangci-lint/cmd/golangci-lint" = "1.64.8" diff --git a/op-acceptance-tests/tests/interop/loadtest/schedule.go b/op-acceptance-tests/tests/interop/loadtest/schedule.go index 9420ba4119e..00aa0160229 100644 --- a/op-acceptance-tests/tests/interop/loadtest/schedule.go +++ b/op-acceptance-tests/tests/interop/loadtest/schedule.go @@ -171,6 +171,12 @@ type Spammer interface { Spam(devtest.T) error } +type SpammerFunc func(t devtest.T) error + +func (s SpammerFunc) Spam(t devtest.T) error { + return s(t) +} + // Schedule schedules a Spammer. It determines how often to spam and when to stop. type Schedule interface { Run(devtest.T, Spammer) @@ -326,12 +332,16 @@ func setupAIMD(t devtest.T, blockTime time.Duration, aimdOpts ...AIMDOption) *AI t.Require().NoError(err) } aimd := NewAIMD(targetMessagePassesPerBlock, blockTime, aimdOpts...) + ctx, cancel := context.WithCancel(t.Ctx()) var wg sync.WaitGroup - t.Cleanup(wg.Wait) + t.Cleanup(func() { + cancel() + wg.Wait() + }) wg.Add(1) go func() { defer wg.Done() - aimd.Start(t.Ctx()) + aimd.Start(ctx) }() return aimd } diff --git a/op-acceptance-tests/tests/osaka/osaka_test.go b/op-acceptance-tests/tests/osaka/osaka_test.go new file mode 100644 index 00000000000..eabd454749b --- /dev/null +++ b/op-acceptance-tests/tests/osaka/osaka_test.go @@ -0,0 +1,214 @@ +package osaka + +import ( + "bytes" + "context" + "crypto/rand" + "fmt" + "math/big" + "os" + "os/exec" + "strings" + "sync" + "testing" + "time" + + "github.com/ethereum-optimism/optimism/op-acceptance-tests/tests/interop/loadtest" + "github.com/ethereum-optimism/optimism/op-batcher/batcher" + "github.com/ethereum-optimism/optimism/op-batcher/flags" + "github.com/ethereum-optimism/optimism/op-chain-ops/devkeys" + "github.com/ethereum-optimism/optimism/op-devstack/devtest" + "github.com/ethereum-optimism/optimism/op-devstack/presets" + "github.com/ethereum-optimism/optimism/op-devstack/stack" + "github.com/ethereum-optimism/optimism/op-devstack/sysgo" + "github.com/ethereum-optimism/optimism/op-e2e/e2eutils/intentbuilder" + "github.com/ethereum-optimism/optimism/op-node/rollup/derive" + "github.com/ethereum-optimism/optimism/op-service/eth" + "github.com/ethereum-optimism/optimism/op-service/txinclude" + "github.com/ethereum-optimism/optimism/op-service/txplan" + "github.com/ethereum/go-ethereum/common" + "github.com/ethereum/go-ethereum/consensus/misc/eip4844" + "github.com/ethereum/go-ethereum/core/types" + "github.com/ethereum/go-ethereum/params" +) + +// configureDevstackEnvVars sets the appropriate env vars to use a mise-installed geth binary for +// the L1 EL. This is useful in Osaka acceptance tests since op-geth does not include full Osaka +// support. This is meant to run before presets.DoMain in a TestMain function. It will log to +// stdout. ResetDevstackEnvVars should be used to reset the environment variables when TestMain +// exits. +// +// Note that this is a no-op if either [sysgo.DevstackL1ELKindVar] or [sysgo.GethExecPathEnvVar] +// are set. +// +// The returned callback resets any modified environment variables. +func configureDevstackEnvVars() func() { + if _, ok := os.LookupEnv(sysgo.DevstackL1ELKindEnvVar); ok { + return func() {} + } + if _, ok := os.LookupEnv(sysgo.GethExecPathEnvVar); ok { + return func() {} + } + + cmd := exec.Command("mise", "which", "geth") + buf := bytes.NewBuffer([]byte{}) + cmd.Stdout = buf + if err := cmd.Run(); err != nil { + fmt.Printf("Failed to find mise-installed geth: %v\n", err) + return func() {} + } + execPath := strings.TrimSpace(buf.String()) + fmt.Println("Found mise-installed geth:", execPath) + _ = os.Setenv(sysgo.GethExecPathEnvVar, execPath) + _ = os.Setenv(sysgo.DevstackL1ELKindEnvVar, "geth") + return func() { + _ = os.Unsetenv(sysgo.GethExecPathEnvVar) + _ = os.Unsetenv(sysgo.DevstackL1ELKindEnvVar) + } +} + +func TestMain(m *testing.M) { + resetEnvVars := configureDevstackEnvVars() + defer resetEnvVars() + + presets.DoMain(m, stack.MakeCommon(stack.Combine[*sysgo.Orchestrator]( + sysgo.DefaultMinimalSystem(&sysgo.DefaultMinimalSystemIDs{}), + sysgo.WithDeployerOptions(func(_ devtest.P, _ devkeys.Keys, builder intentbuilder.Builder) { + _, l1Config := builder.WithL1(sysgo.DefaultL1ID) + l1Config.WithOsakaOffset(0) + l1Config.WithBPO1Offset(0) + l1Config.WithL1BlobSchedule(¶ms.BlobScheduleConfig{ + Cancun: params.DefaultCancunBlobConfig, + Osaka: params.DefaultOsakaBlobConfig, + Prague: params.DefaultPragueBlobConfig, + BPO1: params.DefaultBPO1BlobConfig, + }) + }), + sysgo.WithBatcherOption(func(_ stack.L2BatcherID, cfg *batcher.CLIConfig) { + cfg.DataAvailabilityType = flags.BlobsType + }), + ))) +} + +func TestBatcherUsesNewSidecarFormatAfterOsaka(gt *testing.T) { + t := devtest.SerialT(gt) + sys := presets.NewMinimal(t) + t.Log("Waiting for Osaka to activate") + t.Require().NotNil(sys.L1Network.Escape().ChainConfig().OsakaTime) + sys.L1EL.WaitForTime(*sys.L1Network.Escape().ChainConfig().OsakaTime) + t.Log("Osaka activated") + + // 1. Wait for the sequencer to build a block after Osaka is activated. This avoids a race + // condition where the unsafe head has been posted as part of a blob, but has not been + // marked as "safe" yet. + sys.L2EL.WaitForBlock() + + // 2. Wait for the batcher to include target in a batch and post it to L1. Because the batch is + // posted after Osaka has activated, it means the batcher must have successfully used the + // new format. + target := sys.L2EL.BlockRefByLabel(eth.Unsafe) + blockTime := time.Duration(sys.L2Chain.Escape().RollupConfig().BlockTime) * time.Second + for range time.Tick(blockTime) { + if sys.L2EL.BlockRefByLabel(eth.Safe).Number >= target.Number { + // If the safe head is ahead of the target height and the target block is part of the + // canonical chain, then the target block is safe. + _, err := sys.L2EL.Escape().EthClient().BlockRefByHash(t.Ctx(), target.Hash) + t.Require().NoError(err) + return + } + } +} + +func TestBlobBaseFeeIsCorrectAfterBPOFork(gt *testing.T) { + t := devtest.SerialT(gt) + sys := presets.NewMinimal(t) + t.Log("Waiting for BPO1 to activate") + t.Require().NotNil(sys.L1Network.Escape().ChainConfig().BPO1Time) + sys.L1EL.WaitForTime(*sys.L1Network.Escape().ChainConfig().BPO1Time) + t.Log("BPO1 activated") + + sys.L1EL.WaitForBlock() + l1BlockTime := sys.L1EL.EstimateBlockTime() + l1ChainConfig := sys.L1Network.Escape().ChainConfig() + + spamBlobs(t, sys) // Raise the blob base fee to make blob parameter changes visible. + + // Wait for the blob base fee to rise above 1 so the blob parameter changes will be visible. + for range time.Tick(l1BlockTime) { + info, _, err := sys.L1EL.EthClient().InfoAndTxsByLabel(t.Ctx(), eth.Unsafe) + t.Require().NoError(err) + if calcBlobBaseFee(l1ChainConfig, info).Cmp(big.NewInt(1)) > 0 { + break + } + t.Logf("Waiting for blob base fee to rise above 1") + } + + l2UnsafeRef := sys.L2CL.SyncStatus().UnsafeL2 + + // Get the L1 blob base fee. + l1OriginInfo, err := sys.L1EL.EthClient().InfoByHash(t.Ctx(), l2UnsafeRef.L1Origin.Hash) + t.Require().NoError(err) + l1BlobBaseFee := calcBlobBaseFee(l1ChainConfig, l1OriginInfo) + + // Get the L2 blob base fee from the system deposit tx. + info, txs, err := sys.L2EL.Escape().EthClient().InfoAndTxsByHash(t.Ctx(), l2UnsafeRef.Hash) + t.Require().NoError(err) + blockInfo, err := derive.L1BlockInfoFromBytes(sys.L2Chain.Escape().RollupConfig(), info.Time(), txs[0].Data()) + t.Require().NoError(err) + l2BlobBaseFee := blockInfo.BlobBaseFee + + t.Require().Equal(l1BlobBaseFee, l2BlobBaseFee) +} + +func spamBlobs(t devtest.T, sys *presets.Minimal) { + l1BlockTime := sys.L1EL.EstimateBlockTime() + l1ChainConfig := sys.L1Network.Escape().ChainConfig() + + eoa := sys.FunderL1.NewFundedEOA(eth.OneEther.Mul(5)) + signer := txinclude.NewPkSigner(eoa.Key().Priv(), sys.L1Network.ChainID().ToBig()) + l1ETHClient := sys.L1EL.EthClient() + syncEOA := loadtest.NewSyncEOA(txinclude.NewPersistent(signer, struct { + *txinclude.Monitor + *txinclude.Resubmitter + }{ + txinclude.NewMonitor(l1ETHClient, l1BlockTime), + txinclude.NewResubmitter(l1ETHClient, l1BlockTime), + }), eoa.Plan()) + + var blob eth.Blob + _, err := rand.Read(blob[:]) + t.Require().NoError(err) + // get the field-elements into a valid range + for i := range 4096 { + blob[32*i] &= 0b0011_1111 + } + + const maxBlobTxsPerAccountInMempool = 16 // Private policy param in geth. + spammer := loadtest.SpammerFunc(func(t devtest.T) error { + _, err := syncEOA.Include(t, txplan.WithBlobs([]*eth.Blob{&blob}, l1ChainConfig), txplan.WithTo(&common.Address{})) + return err + }) + txsPerSlot := min(l1ChainConfig.BlobScheduleConfig.BPO1.Max*3/4, maxBlobTxsPerAccountInMempool) + schedule := loadtest.NewConstant(l1BlockTime, loadtest.WithBaseRPS(uint64(txsPerSlot))) + + ctx, cancel := context.WithCancel(t.Ctx()) + var wg sync.WaitGroup + t.Cleanup(func() { + cancel() + wg.Wait() + }) + wg.Add(1) + go func() { + defer wg.Done() + schedule.Run(t.WithCtx(ctx), spammer) + }() +} + +func calcBlobBaseFee(cfg *params.ChainConfig, info eth.BlockInfo) *big.Int { + return eip4844.CalcBlobFee(cfg, &types.Header{ + // It's unfortunate that we can't build a proper header from a BlockInfo. + // We do our best to work around deficiencies in the BlockInfo implementation here. + Time: info.Time(), + ExcessBlobGas: info.ExcessBlobGas(), + }) +} diff --git a/op-deployer/pkg/deployer/pipeline/seal_l1_dev_genesis.go b/op-deployer/pkg/deployer/pipeline/seal_l1_dev_genesis.go index dec3e742a16..d267b841b13 100644 --- a/op-deployer/pkg/deployer/pipeline/seal_l1_dev_genesis.go +++ b/op-deployer/pkg/deployer/pipeline/seal_l1_dev_genesis.go @@ -48,6 +48,9 @@ func SealL1DevGenesis(env *Env, intent *state.Intent, st *state.State) error { }, L1ChainID: eth.ChainIDFromUInt64(intent.L1ChainID), L1PragueTimeOffset: l1DevParams.PragueTimeOffset, + L1OsakaTimeOffset: l1DevParams.OsakaTimeOffset, + L1BPO1TimeOffset: l1DevParams.BPO1TimeOffset, + BlobScheduleConfig: l1DevParams.BlobSchedule, }) if err != nil { return fmt.Errorf("failed to create dev L1 genesis template: %w", err) diff --git a/op-deployer/pkg/deployer/state/intent.go b/op-deployer/pkg/deployer/state/intent.go index e12c356a212..8c331e9f642 100644 --- a/op-deployer/pkg/deployer/state/intent.go +++ b/op-deployer/pkg/deployer/state/intent.go @@ -8,6 +8,7 @@ import ( "github.com/ethereum/go-ethereum/common" "github.com/ethereum/go-ethereum/common/hexutil" + "github.com/ethereum/go-ethereum/params" "github.com/ethereum-optimism/optimism/op-chain-ops/addresses" "github.com/ethereum-optimism/optimism/op-deployer/pkg/deployer/artifacts" @@ -55,6 +56,16 @@ type L1DevGenesisParams struct { // PragueTimeOffset configures Prague (aka Pectra) to be activated at the given time after L1 dev genesis time. PragueTimeOffset *uint64 `json:"pragueTimeOffset" toml:"pragueTimeOffset"` + // OsakaTimeOffset configures Osaka (the EL changes in the Fusaka Ethereum fork) to be + // activated at the given time after L1 dev genesis time. + OsakaTimeOffset *uint64 `json:"osakaTimeOffset" toml:"osakaTimeOffset"` + + // BPO1TimeOffset configures the BPO1 fork to be activated at the given time after L1 dev + // genesis time. + BPO1TimeOffset *uint64 `json:"bpo1TimeOffset" toml:"bpo1TimeOffset"` + + BlobSchedule *params.BlobScheduleConfig `json:"blobSchedule"` + // Prefund is a map of addresses to balances (in wei), to prefund in the L1 dev genesis state. // This is independent of the "Prefund" functionality that may fund a default 20 test accounts. Prefund map[common.Address]*hexutil.U256 `json:"prefund" toml:"prefund"` diff --git a/op-devstack/dsl/el.go b/op-devstack/dsl/el.go index 715c60e3087..b7e4d97251a 100644 --- a/op-devstack/dsl/el.go +++ b/op-devstack/dsl/el.go @@ -103,6 +103,18 @@ func (el *elNode) waitForNextBlock(blocksFromNow uint64) eth.BlockRef { return newRef } +// WaitForTime waits until the chain has reached or surpassed the given timestamp. +func (el *elNode) WaitForTime(timestamp uint64) eth.BlockRef { + for range time.Tick(500 * time.Millisecond) { + ref, err := el.inner.EthClient().BlockRefByLabel(el.ctx, eth.Unsafe) + el.require.NoError(err) + if ref.Time >= timestamp { + return ref + } + } + return eth.BlockRef{} // Should never be reached. +} + func (el *elNode) stackEL() stack.ELNode { return el.inner } diff --git a/op-devstack/sysgo/engine_client.go b/op-devstack/sysgo/engine_client.go index 225765b88a7..d825cd6c5df 100644 --- a/op-devstack/sysgo/engine_client.go +++ b/op-devstack/sysgo/engine_client.go @@ -64,6 +64,10 @@ func (e *engineClient) GetPayloadV4(id engine.PayloadID) (*engine.ExecutionPaylo return e.getPayload(id, "engine_getPayloadV4") } +func (e *engineClient) GetPayloadV5(id engine.PayloadID) (*engine.ExecutionPayloadEnvelope, error) { + return e.getPayload(id, "engine_getPayloadV5") +} + func (e *engineClient) NewPayloadV2(data engine.ExecutableData) (engine.PayloadStatusV1, error) { var result engine.PayloadStatusV1 if err := e.inner.CallContext(context.Background(), &result, "engine_newPayloadV2", data); err != nil { diff --git a/op-devstack/sysgo/l1_nodes_subprocess.go b/op-devstack/sysgo/l1_nodes_subprocess.go index 0edbc09af35..90ce7a4cfcf 100644 --- a/op-devstack/sysgo/l1_nodes_subprocess.go +++ b/op-devstack/sysgo/l1_nodes_subprocess.go @@ -182,8 +182,13 @@ func WithL1NodesSubprocess(id stack.L1ELNodeID, clID stack.L1CLNodeID) stack.Opt args := []string{ "--log.format", "json", "--datadir", dataDirPath, - "--ws", "--ws.addr", "127.0.0.1", "--ws.port", "0", + "--ws", "--ws.addr", "127.0.0.1", "--ws.port", "0", "--ws.origins", "*", "--ws.api", "admin,debug,eth,net,txpool", "--authrpc.addr", "127.0.0.1", "--authrpc.port", "0", "--authrpc.jwtsecret", jwtPath, + "--ipcdisable", + "--nodiscover", + "--verbosity", "5", + "--miner.recommit", "2s", + "--gcmode", "archive", } l1EL := &ExternalL1Geth{ diff --git a/op-e2e/e2eutils/geth/fakepos.go b/op-e2e/e2eutils/geth/fakepos.go index 6784fa7fea7..b84c9216a73 100644 --- a/op-e2e/e2eutils/geth/fakepos.go +++ b/op-e2e/e2eutils/geth/fakepos.go @@ -59,6 +59,7 @@ type EngineAPI interface { ForkchoiceUpdatedV3(engine.ForkchoiceStateV1, *engine.PayloadAttributes) (engine.ForkChoiceResponse, error) ForkchoiceUpdatedV2(engine.ForkchoiceStateV1, *engine.PayloadAttributes) (engine.ForkChoiceResponse, error) + GetPayloadV5(engine.PayloadID) (*engine.ExecutionPayloadEnvelope, error) GetPayloadV4(engine.PayloadID) (*engine.ExecutionPayloadEnvelope, error) GetPayloadV3(engine.PayloadID) (*engine.ExecutionPayloadEnvelope, error) GetPayloadV2(engine.PayloadID) (*engine.ExecutionPayloadEnvelope, error) @@ -157,8 +158,10 @@ func (f *FakePoS) Start() error { Withdrawals: withdrawals, } parentBeaconBlockRoot := f.FakeBeaconBlockRoot(head.Time) // parent beacon block root - isCancun := f.config.IsCancun(new(big.Int).SetUint64(head.Number.Uint64()+1), newBlockTime) - isPrague := f.config.IsPrague(new(big.Int).SetUint64(head.Number.Uint64()+1), newBlockTime) + nextHeight := new(big.Int).SetUint64(head.Number.Uint64() + 1) + isCancun := f.config.IsCancun(nextHeight, newBlockTime) + isPrague := f.config.IsPrague(nextHeight, newBlockTime) + isOsaka := f.config.IsOsaka(nextHeight, newBlockTime) if isCancun { attrs.BeaconRoot = &parentBeaconBlockRoot } @@ -192,7 +195,9 @@ func (f *FakePoS) Start() error { return nil } var envelope *engine.ExecutionPayloadEnvelope - if isPrague { + if isOsaka { + envelope, err = f.engineAPI.GetPayloadV5(*res.PayloadID) + } else if isPrague { envelope, err = f.engineAPI.GetPayloadV4(*res.PayloadID) } else if isCancun { envelope, err = f.engineAPI.GetPayloadV3(*res.PayloadID) diff --git a/op-e2e/e2eutils/intentbuilder/builder.go b/op-e2e/e2eutils/intentbuilder/builder.go index 448cb72e1c4..be8d4d8c8ea 100644 --- a/op-e2e/e2eutils/intentbuilder/builder.go +++ b/op-e2e/e2eutils/intentbuilder/builder.go @@ -10,6 +10,7 @@ import ( "github.com/ethereum/go-ethereum/common" "github.com/ethereum/go-ethereum/common/hexutil" + "github.com/ethereum/go-ethereum/params" "github.com/ethereum-optimism/optimism/op-chain-ops/addresses" "github.com/ethereum-optimism/optimism/op-chain-ops/devkeys" @@ -28,6 +29,9 @@ type L1Configurator interface { WithGasLimit(v uint64) L1Configurator WithExcessBlobGas(v uint64) L1Configurator WithPragueOffset(v uint64) L1Configurator + WithOsakaOffset(v uint64) L1Configurator + WithBPO1Offset(v uint64) L1Configurator + WithL1BlobSchedule(schedule *params.BlobScheduleConfig) L1Configurator WithPrefundedAccount(addr common.Address, amount uint256.Int) L1Configurator } @@ -303,6 +307,24 @@ func (c *l1Configurator) WithPragueOffset(v uint64) L1Configurator { return c } +func (c *l1Configurator) WithOsakaOffset(v uint64) L1Configurator { + c.initL1DevGenesisParams() + c.builder.intent.L1DevGenesisParams.OsakaTimeOffset = &v + return c +} + +func (c *l1Configurator) WithBPO1Offset(v uint64) L1Configurator { + c.initL1DevGenesisParams() + c.builder.intent.L1DevGenesisParams.BPO1TimeOffset = &v + return c +} + +func (c *l1Configurator) WithL1BlobSchedule(schedule *params.BlobScheduleConfig) L1Configurator { + c.initL1DevGenesisParams() + c.builder.intent.L1DevGenesisParams.BlobSchedule = schedule + return c +} + func (c *l1Configurator) WithPrefundedAccount(addr common.Address, amount uint256.Int) L1Configurator { c.initL1DevGenesisParams() c.builder.intent.L1DevGenesisParams.Prefund[addr] = (*hexutil.U256)(&amount) diff --git a/op-e2e/e2eutils/intentbuilder/builder_test.go b/op-e2e/e2eutils/intentbuilder/builder_test.go index ecf7e19d307..d98eec5ce38 100644 --- a/op-e2e/e2eutils/intentbuilder/builder_test.go +++ b/op-e2e/e2eutils/intentbuilder/builder_test.go @@ -36,6 +36,8 @@ func TestBuilder(t *testing.T) { // Configure L1 pragueOffset := uint64(100) + osakaOffset := uint64(200) + bpo1Offset := uint64(300) alice := common.HexToAddress("0xaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa") aliceFunds := uint256.NewInt(10000) l1Params := state.L1DevGenesisParams{ @@ -45,6 +47,8 @@ func TestBuilder(t *testing.T) { ExcessBlobGas: 123, }, PragueTimeOffset: &pragueOffset, + OsakaTimeOffset: &osakaOffset, + BPO1TimeOffset: &bpo1Offset, Prefund: map[common.Address]*hexutil.U256{ alice: (*hexutil.U256)(aliceFunds), }, @@ -55,6 +59,8 @@ func TestBuilder(t *testing.T) { l1Config.WithGasLimit(l1Params.BlockParams.GasLimit) l1Config.WithExcessBlobGas(l1Params.BlockParams.ExcessBlobGas) l1Config.WithPragueOffset(*l1Params.PragueTimeOffset) + l1Config.WithOsakaOffset(*l1Params.OsakaTimeOffset) + l1Config.WithBPO1Offset(*l1Params.BPO1TimeOffset) l1Config.WithPrefundedAccount(alice, *aliceFunds) // Configure L2 diff --git a/op-service/txinclude/nonce_manager.go b/op-service/txinclude/nonce_manager.go index 3b1eb64d51c..1bf546721a5 100644 --- a/op-service/txinclude/nonce_manager.go +++ b/op-service/txinclude/nonce_manager.go @@ -35,10 +35,14 @@ func (nm *nonceManager) Next() uint64 { return nonce } -// InsertGap inserts a nonce gap. It is a no-op if nonce is already a gap. +// InsertGap inserts a nonce gap. It is a no-op if nonce is already a gap or if it is ahead of the +// current nonce. func (nm *nonceManager) InsertGap(nonce uint64) { nm.mu.Lock() defer nm.mu.Unlock() + if nonce >= nm.nextNonce { + return + } i, exists := slices.BinarySearch(nm.gaps, nonce) if exists { return diff --git a/op-service/txinclude/nonce_manager_test.go b/op-service/txinclude/nonce_manager_test.go index 386859fe9b0..611f10f8d25 100644 --- a/op-service/txinclude/nonce_manager_test.go +++ b/op-service/txinclude/nonce_manager_test.go @@ -87,4 +87,28 @@ func TestNonceManagerInsertGap(t *testing.T) { require.Equal(t, uint64(30), nm.Next()) require.Equal(t, uint64(100), nm.Next()) }) + + t.Run("future gap is a no-op", func(t *testing.T) { + nm := newNonceManager(20) + + nm.InsertGap(21) + + require.Equal(t, uint64(20), nm.Next()) + require.Equal(t, uint64(21), nm.Next()) + require.Equal(t, uint64(22), nm.Next()) + }) + + t.Run("handles multiple future gaps", func(t *testing.T) { + nm := newNonceManager(20) + + nm.InsertGap(21) + nm.InsertGap(22) + nm.InsertGap(23) + + require.Equal(t, uint64(20), nm.Next()) + require.Equal(t, uint64(21), nm.Next()) + require.Equal(t, uint64(22), nm.Next()) + require.Equal(t, uint64(23), nm.Next()) + require.Equal(t, uint64(24), nm.Next()) + }) } diff --git a/op-service/txplan/txplan.go b/op-service/txplan/txplan.go index 07d802ad8a8..d4151c03dfc 100644 --- a/op-service/txplan/txplan.go +++ b/op-service/txplan/txplan.go @@ -8,6 +8,7 @@ import ( "math/big" "github.com/ethereum-optimism/optimism/op-service/retry" + "github.com/ethereum-optimism/optimism/op-service/txmgr" "github.com/holiman/uint256" "github.com/ethereum/go-ethereum" @@ -54,6 +55,9 @@ type PlannedTx struct { Value plan.Lazy[*big.Int] AccessList plan.Lazy[types.AccessList] // resolves to nil if not an attribute AuthList plan.Lazy[[]types.SetCodeAuthorization] // resolves to nil if not a 7702 tx + BlobFeeCap plan.Lazy[*uint256.Int] // resolves to nil if not a blob tx + BlobHashes plan.Lazy[[]common.Hash] // resolves to nil if not a blob tx + Sidecar plan.Lazy[*types.BlobTxSidecar] // resolves to nil if not a blob tx } func (ptx *PlannedTx) String() string { @@ -384,6 +388,29 @@ func WithChainID(cl ChainID) Option { } } +func WithBlobs(blobs []*eth.Blob, config *params.ChainConfig) Option { + return func(tx *PlannedTx) { + tx.Type.Set(types.BlobTxType) + tx.BlobFeeCap.DependOn(&tx.AgainstBlock) + tx.BlobFeeCap.Fn(func(_ context.Context) (*uint256.Int, error) { + return uint256.MustFromBig(tx.AgainstBlock.Value().BlobBaseFee(config)), nil + }) + var blobHashes []common.Hash + tx.Sidecar.Fn(func(_ context.Context) (*types.BlobTxSidecar, error) { + sidecar, hashes, err := txmgr.MakeSidecar(blobs, true) + if err != nil { + return nil, fmt.Errorf("make blob tx sidecar: %w", err) + } + blobHashes = hashes + return sidecar, nil + }) + tx.BlobHashes.DependOn(&tx.Sidecar) + tx.BlobHashes.Fn(func(_ context.Context) ([]common.Hash, error) { + return blobHashes, nil + }) + } +} + func (tx *PlannedTx) Defaults() { tx.Type.Set(types.DynamicFeeTxType) tx.To.Set(nil) @@ -421,6 +448,10 @@ func (tx *PlannedTx) Defaults() { return crypto.PubkeyToAddress(tx.Priv.Value().PublicKey), nil }) + tx.BlobFeeCap.Set(nil) + tx.BlobHashes.Set(nil) + tx.Sidecar.Set(nil) + // Automatically build tx from the individual attributes tx.Unsigned.DependOn( &tx.Sender, @@ -435,6 +466,9 @@ func (tx *PlannedTx) Defaults() { &tx.Value, &tx.AccessList, &tx.AuthList, + &tx.BlobFeeCap, + &tx.BlobHashes, + &tx.Sidecar, ) tx.Unsigned.Fn(func(ctx context.Context) (types.TxData, error) { chainID := tx.ChainID.Value() @@ -501,7 +535,23 @@ func (tx *PlannedTx) Defaults() { S: nil, }, nil case types.BlobTxType: - return nil, errors.New("blob tx not supported") + return &types.BlobTx{ + ChainID: uint256.MustFromBig(chainID.ToBig()), + Nonce: tx.Nonce.Value(), + GasTipCap: uint256.MustFromBig(tx.GasTipCap.Value()), + GasFeeCap: uint256.MustFromBig(tx.GasFeeCap.Value()), + Gas: tx.Gas.Value(), + To: *tx.To.Value(), + Value: uint256.MustFromBig(tx.Value.Value()), + Data: tx.Data.Value(), + AccessList: tx.AccessList.Value(), + BlobFeeCap: tx.BlobFeeCap.Value(), + BlobHashes: tx.BlobHashes.Value(), + Sidecar: tx.Sidecar.Value(), + V: nil, + R: nil, + S: nil, + }, nil case types.DepositTxType: return nil, errors.New("deposit tx not supported") default: From ad12b8da0785da6938ebdb9c477c0f55d6ae834d Mon Sep 17 00:00:00 2001 From: mbaxter Date: Mon, 6 Oct 2025 11:04:00 -0400 Subject: [PATCH 009/117] op-challenger: Convert l1-genesis flag to a vm flag (#17722) * op-challenger: convert l1 genesis flag to VMFlag * Disallow l1-genesis flag use with the network flag * typo * another typo --------- Co-authored-by: geoknee --- op-challenger/cmd/main_test.go | 112 ++++++++++++++------------------- op-challenger/flags/flags.go | 40 ++++++------ 2 files changed, 67 insertions(+), 85 deletions(-) diff --git a/op-challenger/cmd/main_test.go b/op-challenger/cmd/main_test.go index aa3b7ef3a20..94fff227f07 100644 --- a/op-challenger/cmd/main_test.go +++ b/op-challenger/cmd/main_test.go @@ -503,6 +503,48 @@ func TestAsteriscKonaRequiredArgs(t *testing.T) { }) } +// validateCustomNetworkFlagsProhibitedWithNetworkFlag ensures custom network flags are not used simultaneously with the network flag. +// It validates disallowed flag combinations for a given trace type and trace type prefix configuration. +func validateCustomNetworkFlagsProhibitedWithNetworkFlag(t *testing.T, traceType types.TraceType, traceTypeForFlagPrefix types.TraceType, customNetworkFlag string) { + expectedError := fmt.Sprintf("flag network can not be used with rollup-config/%v-rollup-config, l2-genesis/%v-l2-genesis, l1-genesis/%v-l1-genesis or %v", traceTypeForFlagPrefix, traceTypeForFlagPrefix, traceTypeForFlagPrefix, customNetworkFlag) + + // Test the custom l2 flag + t.Run(fmt.Sprintf("TestMustNotSpecifyNetworkAndCustomL2Flag-%v", traceType), func(t *testing.T) { + verifyArgsInvalid( + t, + expectedError, + addRequiredArgs(traceType, fmt.Sprintf("--%v=true", customNetworkFlag))) + }) + + // Now test flags with trace-specific permutations + customNetworkFlags := map[string]string{ + "RollupConfig": "rollup-config", + "L2Genesis": "l2-genesis", + "L1Genesis": "l1-genesis", + } + for testName, flag := range customNetworkFlags { + for _, withTraceSpecificPrefix := range []bool{true, false} { + var postFix string + if withTraceSpecificPrefix { + postFix = "-withTraceSpecificPrefix" + } + + t.Run(fmt.Sprintf("TestMustNotSpecifyNetworkAnd%v-%v%v", testName, traceType, postFix), func(t *testing.T) { + var prefix string + if withTraceSpecificPrefix { + prefix = fmt.Sprintf("%v-", traceTypeForFlagPrefix) + } + flagName := fmt.Sprintf("%v%v", prefix, flag) + + verifyArgsInvalid( + t, + expectedError, + addRequiredArgs(traceType, fmt.Sprintf("--%v=somevalue.json", flagName))) + }) + } + } +} + func TestAsteriscBaseRequiredArgs(t *testing.T) { for _, traceType := range []types.TraceType{types.TraceTypeAsterisc, types.TraceTypeAsteriscKona} { traceType := traceType @@ -581,12 +623,7 @@ func TestAsteriscBaseRequiredArgs(t *testing.T) { addRequiredArgsExcept(traceType, "--network", "--l2-genesis=gensis.json")) }) - t.Run(fmt.Sprintf("TestMustNotSpecifyNetworkAndRollup-%v", traceType), func(t *testing.T) { - verifyArgsInvalid( - t, - "flag network can not be used with rollup-config, l2-genesis or asterisc-kona-l2-custom", - addRequiredArgs(traceType, "--rollup-config=rollup.json")) - }) + validateCustomNetworkFlagsProhibitedWithNetworkFlag(t, traceType, types.TraceTypeAsteriscKona, "asterisc-kona-l2-custom") t.Run(fmt.Sprintf("TestNetwork-%v", traceType), func(t *testing.T) { t.Run("NotRequiredForAlphabetTrace", func(t *testing.T) { @@ -669,26 +706,7 @@ func TestCannonCustomConfigArgs(t *testing.T) { addRequiredArgsExcept(traceType, "--network", "--cannon-l2-genesis=gensis.json")) }) - t.Run(fmt.Sprintf("TestMustNotSpecifyNetworkAndRollup-%v", traceType), func(t *testing.T) { - verifyArgsInvalid( - t, - "flag network can not be used with cannon-rollup-config, l2-genesis or cannon-l2-custom", - addRequiredArgs(traceType, "--cannon-rollup-config=rollup.json")) - }) - - t.Run(fmt.Sprintf("TestMustNotSpecifyNetworkAndRollup-%v", traceType), func(t *testing.T) { - args := requiredArgs(traceType) - delete(args, "--network") - delete(args, "--game-factory-address") - args["--network"] = network - args["--cannon-rollup-config"] = "rollup.json" - args["--cannon-l2-genesis"] = "gensis.json" - args["--cannon-l2-custom"] = "true" - verifyArgsInvalid( - t, - "flag network can not be used with cannon-rollup-config, cannon-l2-genesis or cannon-l2-custom", - toArgList(args)) - }) + validateCustomNetworkFlagsProhibitedWithNetworkFlag(t, traceType, types.TraceTypeCannon, "cannon-l2-custom") t.Run(fmt.Sprintf("TestNetwork-%v", traceType), func(t *testing.T) { t.Run("NotRequiredWhenRollupAndGenesIsSpecified", func(t *testing.T) { @@ -762,26 +780,7 @@ func TestSuperCannonCustomConfigArgs(t *testing.T) { addRequiredArgsExcept(traceType, "--network", "--cannon-rollup-config=rollup.json", "--cannon-l2-genesis=gensis.json")) }) - t.Run(fmt.Sprintf("TestMustNotSpecifyNetworkAndRollup-%v", traceType), func(t *testing.T) { - verifyArgsInvalid( - t, - "flag network can not be used with cannon-rollup-config, l2-genesis or cannon-l2-custom", - addRequiredArgs(traceType, "--cannon-rollup-config=rollup.json")) - }) - - t.Run(fmt.Sprintf("TestMustNotSpecifyNetworkAndRollup-%v", traceType), func(t *testing.T) { - args := requiredArgs(traceType) - delete(args, "--network") - delete(args, "--game-factory-address") - args["--network"] = network - args["--cannon-rollup-config"] = "rollup.json" - args["--cannon-l2-genesis"] = "gensis.json" - args["--cannon-l2-custom"] = "true" - verifyArgsInvalid( - t, - "flag network can not be used with cannon-rollup-config, cannon-l2-genesis or cannon-l2-custom", - toArgList(args)) - }) + validateCustomNetworkFlagsProhibitedWithNetworkFlag(t, traceType, types.TraceTypeCannon, "cannon-l2-custom") t.Run(fmt.Sprintf("TestNetwork-%v", traceType), func(t *testing.T) { t.Run("NotRequiredWhenRollupGenesisAndDepsetIsSpecified", func(t *testing.T) { @@ -868,26 +867,7 @@ func TestSuperAsteriscKonaCustomConfigArgs(t *testing.T) { addRequiredArgsExcept(traceType, "--network", "--asterisc-kona-rollup-config=rollup.json", "--asterisc-kona-l2-genesis=gensis.json")) }) - t.Run(fmt.Sprintf("TestMustNotSpecifyNetworkAndRollup-%v", traceType), func(t *testing.T) { - verifyArgsInvalid( - t, - "flag network can not be used with asterisc-kona-rollup-config, l2-genesis or asterisc-kona-l2-custom", - addRequiredArgs(traceType, "--asterisc-kona-rollup-config=rollup.json")) - }) - - t.Run(fmt.Sprintf("TestMustNotSpecifyNetworkAndRollup-%v", traceType), func(t *testing.T) { - args := requiredArgs(traceType) - delete(args, "--network") - delete(args, "--game-factory-address") - args["--network"] = network - args["--asterisc-kona-rollup-config"] = "rollup.json" - args["--asterisc-kona-l2-genesis"] = "gensis.json" - args["--asterisc-kona-l2-custom"] = "true" - verifyArgsInvalid( - t, - "flag network can not be used with asterisc-kona-rollup-config, asterisc-kona-l2-genesis or asterisc-kona-l2-custom", - toArgList(args)) - }) + validateCustomNetworkFlagsProhibitedWithNetworkFlag(t, traceType, types.TraceTypeAsteriscKona, "asterisc-kona-l2-custom") t.Run(fmt.Sprintf("TestNetwork-%v", traceType), func(t *testing.T) { t.Run("NotRequiredWhenRollupGenesisAndDepsetIsSpecified", func(t *testing.T) { diff --git a/op-challenger/flags/flags.go b/op-challenger/flags/flags.go index a911eaaf1bf..20fa1980304 100644 --- a/op-challenger/flags/flags.go +++ b/op-challenger/flags/flags.go @@ -44,11 +44,6 @@ var ( Usage: "Address of L1 Beacon API endpoint to use", EnvVars: prefixEnvVars("L1_BEACON"), } - L1GenesisFlag = &cli.StringFlag{ - Name: "l1-genesis-path", - Usage: "Path to the L1 genesis file. Only required if the L1 is not mainnet, sepolia, holesky, or hoodi.", - EnvVars: prefixEnvVars("L1_GENESIS_PATH"), - } SupervisorRpcFlag = &cli.StringFlag{ Name: "supervisor-rpc", Usage: "Provider URL for supervisor RPC", @@ -148,6 +143,13 @@ var ( EnvVars: envVars, } }) + L1GenesisFlag = NewVMFlag("l1-genesis", EnvVarPrefix, faultDisputeVMs, func(name string, envVars []string, traceTypeInfo string) cli.Flag { + return &cli.StringFlag{ + Name: name, + Usage: "Path to the L1 genesis file. Only required if the L1 is not mainnet, sepolia, holesky, or hoodi.", + EnvVars: envVars, + } + }) DepsetConfigFlag = NewVMFlag("depset-config", EnvVarPrefix, faultDisputeVMs, func(name string, envVars []string, traceTypeInfo string) cli.Flag { return &cli.StringFlag{ Name: name, @@ -329,13 +331,13 @@ var optionalFlags = []cli.Flag{ UnsafeAllowInvalidPrestate, ResponseDelayFlag, ResponseDelayAfterFlag, - L1GenesisFlag, } func init() { optionalFlags = append(optionalFlags, oplog.CLIFlags(EnvVarPrefix)...) optionalFlags = append(optionalFlags, PreStatesURLFlag.Flags()...) optionalFlags = append(optionalFlags, RollupConfigFlag.Flags()...) + optionalFlags = append(optionalFlags, L1GenesisFlag.Flags()...) optionalFlags = append(optionalFlags, L2GenesisFlag.Flags()...) optionalFlags = append(optionalFlags, DepsetConfigFlag.Flags()...) optionalFlags = append(optionalFlags, txmgr.CLIFlagsWithDefaults(EnvVarPrefix, txmgr.DefaultChallengerFlagValues)...) @@ -357,9 +359,9 @@ func checkOutputProviderFlags(ctx *cli.Context) error { func CheckCannonBaseFlags(ctx *cli.Context) error { if ctx.IsSet(flags.NetworkFlagName) && - (RollupConfigFlag.IsSet(ctx, types.TraceTypeCannon) || L2GenesisFlag.IsSet(ctx, types.TraceTypeCannon) || ctx.Bool(CannonL2CustomFlag.Name)) { - return fmt.Errorf("flag %v can not be used with %v, %v or %v", - flags.NetworkFlagName, RollupConfigFlag.SourceFlagName(ctx, types.TraceTypeCannon), L2GenesisFlag.SourceFlagName(ctx, types.TraceTypeCannon), CannonL2CustomFlag.Name) + (RollupConfigFlag.IsSet(ctx, types.TraceTypeCannon) || L2GenesisFlag.IsSet(ctx, types.TraceTypeCannon) || L1GenesisFlag.IsSet(ctx, types.TraceTypeCannon) || ctx.Bool(CannonL2CustomFlag.Name)) { + return fmt.Errorf("flag %v can not be used with %v, %v, %v or %v", + flags.NetworkFlagName, RollupConfigFlag.EitherFlagName(types.TraceTypeCannon), L2GenesisFlag.EitherFlagName(types.TraceTypeCannon), L1GenesisFlag.EitherFlagName(types.TraceTypeCannon), CannonL2CustomFlag.Name) } if ctx.Bool(CannonL2CustomFlag.Name) && !(RollupConfigFlag.IsSet(ctx, types.TraceTypeCannon) && L2GenesisFlag.IsSet(ctx, types.TraceTypeCannon)) { return fmt.Errorf("flag %v and %v must be set when %v is true", @@ -417,9 +419,9 @@ func CheckCannonKonaBaseFlags(ctx *cli.Context, traceType types.TraceType) error flags.NetworkFlagName, RollupConfigFlag.EitherFlagName(traceType), L2GenesisFlag.EitherFlagName(traceType)) } if ctx.IsSet(flags.NetworkFlagName) && - (RollupConfigFlag.IsSet(ctx, types.TraceTypeCannonKona) || L2GenesisFlag.IsSet(ctx, types.TraceTypeCannonKona) || ctx.Bool(CannonKonaL2CustomFlag.Name)) { - return fmt.Errorf("flag %v can not be used with %v, %v or %v", - flags.NetworkFlagName, RollupConfigFlag.SourceFlagName(ctx, types.TraceTypeCannonKona), L2GenesisFlag.SourceFlagName(ctx, types.TraceTypeCannonKona), CannonKonaL2CustomFlag.Name) + (RollupConfigFlag.IsSet(ctx, types.TraceTypeCannonKona) || L2GenesisFlag.IsSet(ctx, types.TraceTypeCannonKona) || L1GenesisFlag.IsSet(ctx, types.TraceTypeCannonKona) || ctx.Bool(CannonKonaL2CustomFlag.Name)) { + return fmt.Errorf("flag %v can not be used with %v, %v, %v or %v", + flags.NetworkFlagName, RollupConfigFlag.EitherFlagName(types.TraceTypeCannonKona), L2GenesisFlag.EitherFlagName(types.TraceTypeCannonKona), L1GenesisFlag.EitherFlagName(types.TraceTypeCannonKona), CannonKonaL2CustomFlag.Name) } if !ctx.IsSet(CannonBinFlag.Name) { return fmt.Errorf("flag %s is required", CannonBinFlag.Name) @@ -450,9 +452,9 @@ func CheckAsteriscBaseFlags(ctx *cli.Context, traceType types.TraceType) error { flags.NetworkFlagName, RollupConfigFlag.EitherFlagName(traceType), L2GenesisFlag.EitherFlagName(traceType)) } if ctx.IsSet(flags.NetworkFlagName) && - (RollupConfigFlag.IsSet(ctx, types.TraceTypeAsteriscKona) || L2GenesisFlag.IsSet(ctx, types.TraceTypeAsteriscKona) || ctx.Bool(AsteriscKonaL2CustomFlag.Name)) { - return fmt.Errorf("flag %v can not be used with %v, %v or %v", - flags.NetworkFlagName, RollupConfigFlag.SourceFlagName(ctx, types.TraceTypeAsteriscKona), L2GenesisFlag.SourceFlagName(ctx, types.TraceTypeAsteriscKona), AsteriscKonaL2CustomFlag.Name) + (RollupConfigFlag.IsSet(ctx, types.TraceTypeAsteriscKona) || L2GenesisFlag.IsSet(ctx, types.TraceTypeAsteriscKona) || L1GenesisFlag.IsSet(ctx, types.TraceTypeAsteriscKona) || ctx.Bool(AsteriscKonaL2CustomFlag.Name)) { + return fmt.Errorf("flag %v can not be used with %v, %v, %v or %v", + flags.NetworkFlagName, RollupConfigFlag.EitherFlagName(types.TraceTypeAsteriscKona), L2GenesisFlag.EitherFlagName(types.TraceTypeAsteriscKona), L1GenesisFlag.EitherFlagName(types.TraceTypeAsteriscKona), AsteriscKonaL2CustomFlag.Name) } if !ctx.IsSet(AsteriscBinFlag.Name) { return fmt.Errorf("flag %s is required", AsteriscBinFlag.Name) @@ -714,7 +716,6 @@ func NewConfigFromCLI(ctx *cli.Context, logger log.Logger) (*config.Config, erro RollupRpc: ctx.String(RollupRpcFlag.Name), SupervisorRPC: ctx.String(SupervisorRpcFlag.Name), Cannon: vm.Config{ - L1GenesisPath: ctx.String(L1GenesisFlag.Name), VmType: types.TraceTypeCannon, L1: l1EthRpc, L1Beacon: l1Beacon, @@ -725,6 +726,7 @@ func NewConfigFromCLI(ctx *cli.Context, logger log.Logger) (*config.Config, erro Networks: networks, L2Custom: ctx.Bool(CannonL2CustomFlag.Name), RollupConfigPaths: RollupConfigFlag.StringSlice(ctx, types.TraceTypeCannon), + L1GenesisPath: L1GenesisFlag.String(ctx, types.TraceTypeCannon), L2GenesisPaths: L2GenesisFlag.StringSlice(ctx, types.TraceTypeCannon), DepsetConfigPath: DepsetConfigFlag.String(ctx, types.TraceTypeCannon), SnapshotFreq: ctx.Uint(CannonSnapshotFreqFlag.Name), @@ -735,7 +737,6 @@ func NewConfigFromCLI(ctx *cli.Context, logger log.Logger) (*config.Config, erro CannonAbsolutePreState: ctx.String(CannonPreStateFlag.Name), CannonAbsolutePreStateBaseURL: cannonPreStatesURL, CannonKona: vm.Config{ - L1GenesisPath: ctx.String(L1GenesisFlag.Name), VmType: types.TraceTypeCannonKona, L1: l1EthRpc, L1Beacon: l1Beacon, @@ -746,6 +747,7 @@ func NewConfigFromCLI(ctx *cli.Context, logger log.Logger) (*config.Config, erro Networks: networks, L2Custom: ctx.Bool(CannonKonaL2CustomFlag.Name), RollupConfigPaths: RollupConfigFlag.StringSlice(ctx, types.TraceTypeCannonKona), + L1GenesisPath: L1GenesisFlag.String(ctx, types.TraceTypeCannonKona), L2GenesisPaths: L2GenesisFlag.StringSlice(ctx, types.TraceTypeCannonKona), DepsetConfigPath: DepsetConfigFlag.String(ctx, types.TraceTypeCannonKona), SnapshotFreq: ctx.Uint(CannonSnapshotFreqFlag.Name), @@ -757,7 +759,6 @@ func NewConfigFromCLI(ctx *cli.Context, logger log.Logger) (*config.Config, erro CannonKonaAbsolutePreStateBaseURL: cannonKonaPreStatesURL, Datadir: ctx.String(DatadirFlag.Name), Asterisc: vm.Config{ - L1GenesisPath: ctx.String(L1GenesisFlag.Name), VmType: types.TraceTypeAsterisc, L1: l1EthRpc, L1Beacon: l1Beacon, @@ -767,6 +768,7 @@ func NewConfigFromCLI(ctx *cli.Context, logger log.Logger) (*config.Config, erro Server: ctx.String(AsteriscServerFlag.Name), Networks: networks, RollupConfigPaths: RollupConfigFlag.StringSlice(ctx, types.TraceTypeAsterisc), + L1GenesisPath: L1GenesisFlag.String(ctx, types.TraceTypeAsterisc), L2GenesisPaths: L2GenesisFlag.StringSlice(ctx, types.TraceTypeAsterisc), DepsetConfigPath: DepsetConfigFlag.String(ctx, types.TraceTypeAsterisc), SnapshotFreq: ctx.Uint(AsteriscSnapshotFreqFlag.Name), @@ -776,7 +778,6 @@ func NewConfigFromCLI(ctx *cli.Context, logger log.Logger) (*config.Config, erro AsteriscAbsolutePreState: ctx.String(AsteriscPreStateFlag.Name), AsteriscAbsolutePreStateBaseURL: asteriscPreStatesURL, AsteriscKona: vm.Config{ - L1GenesisPath: ctx.String(L1GenesisFlag.Name), VmType: types.TraceTypeAsteriscKona, L1: l1EthRpc, L1Beacon: l1Beacon, @@ -787,6 +788,7 @@ func NewConfigFromCLI(ctx *cli.Context, logger log.Logger) (*config.Config, erro Networks: networks, L2Custom: ctx.Bool(AsteriscKonaL2CustomFlag.Name), RollupConfigPaths: RollupConfigFlag.StringSlice(ctx, types.TraceTypeAsteriscKona), + L1GenesisPath: L1GenesisFlag.String(ctx, types.TraceTypeAsteriscKona), L2GenesisPaths: L2GenesisFlag.StringSlice(ctx, types.TraceTypeAsteriscKona), DepsetConfigPath: DepsetConfigFlag.String(ctx, types.TraceTypeAsteriscKona), SnapshotFreq: ctx.Uint(AsteriscSnapshotFreqFlag.Name), From 88fe2c41b1e79994c6e85a1a1de70d8b53e47a54 Mon Sep 17 00:00:00 2001 From: Changwan Park Date: Tue, 7 Oct 2025 00:59:21 +0900 Subject: [PATCH 010/117] op-devstack: L2EL Engine API support for op-geth (#17714) * op-service: Engine APIs * op-devstack: L2EL Engine API support: op-geth * Handle Read Only ELs * Move to different dir * op-devstack: DSL for ref by hash and FCU * op-acceptance-tests: Manual Verifier Sync * op-acceptance-tests: Manual Verifier Sync: Harden * op-devstack: godoc and better var naming --- .../sync/{ => elsync/gap_clp2p}/init_test.go | 2 +- .../sync/{ => elsync/gap_clp2p}/sync_test.go | 2 +- .../tests/sync/manual/init_test.go | 22 +++++++ .../tests/sync/manual/sync_test.go | 60 +++++++++++++++++++ op-devstack/dsl/engine.go | 54 +++++++++++++++++ op-devstack/dsl/l2_el.go | 26 ++++++++ op-devstack/shim/l2_el.go | 27 ++++++--- op-devstack/stack/l2_el.go | 1 + op-devstack/sysgo/l2_el.go | 5 +- op-devstack/sysgo/l2_el_opgeth.go | 18 +++++- op-service/apis/engine.go | 14 +++++ 11 files changed, 218 insertions(+), 13 deletions(-) rename op-acceptance-tests/tests/sync/{ => elsync/gap_clp2p}/init_test.go (97%) rename op-acceptance-tests/tests/sync/{ => elsync/gap_clp2p}/sync_test.go (99%) create mode 100644 op-acceptance-tests/tests/sync/manual/init_test.go create mode 100644 op-acceptance-tests/tests/sync/manual/sync_test.go create mode 100644 op-devstack/dsl/engine.go create mode 100644 op-service/apis/engine.go diff --git a/op-acceptance-tests/tests/sync/init_test.go b/op-acceptance-tests/tests/sync/elsync/gap_clp2p/init_test.go similarity index 97% rename from op-acceptance-tests/tests/sync/init_test.go rename to op-acceptance-tests/tests/sync/elsync/gap_clp2p/init_test.go index f4d6bf198a4..75dffe931e0 100644 --- a/op-acceptance-tests/tests/sync/init_test.go +++ b/op-acceptance-tests/tests/sync/elsync/gap_clp2p/init_test.go @@ -1,4 +1,4 @@ -package elsync +package gap_clp2p import ( "testing" diff --git a/op-acceptance-tests/tests/sync/sync_test.go b/op-acceptance-tests/tests/sync/elsync/gap_clp2p/sync_test.go similarity index 99% rename from op-acceptance-tests/tests/sync/sync_test.go rename to op-acceptance-tests/tests/sync/elsync/gap_clp2p/sync_test.go index f5d3b0bef69..21b4a3ed2cb 100644 --- a/op-acceptance-tests/tests/sync/sync_test.go +++ b/op-acceptance-tests/tests/sync/elsync/gap_clp2p/sync_test.go @@ -1,4 +1,4 @@ -package elsync +package gap_clp2p import ( "testing" diff --git a/op-acceptance-tests/tests/sync/manual/init_test.go b/op-acceptance-tests/tests/sync/manual/init_test.go new file mode 100644 index 00000000000..ac448c396b4 --- /dev/null +++ b/op-acceptance-tests/tests/sync/manual/init_test.go @@ -0,0 +1,22 @@ +package manual + +import ( + "testing" + + bss "github.com/ethereum-optimism/optimism/op-batcher/batcher" + "github.com/ethereum-optimism/optimism/op-devstack/compat" + "github.com/ethereum-optimism/optimism/op-devstack/presets" + "github.com/ethereum-optimism/optimism/op-devstack/stack" + "github.com/ethereum-optimism/optimism/op-devstack/sysgo" +) + +func TestMain(m *testing.M) { + // No ELP2P, CLP2P to control the supply of unsafe payload to the CL + presets.DoMain(m, presets.WithSingleChainMultiNodeWithoutP2P(), + presets.WithCompatibleTypes(compat.SysGo), + stack.MakeCommon(sysgo.WithBatcherOption(func(id stack.L2BatcherID, cfg *bss.CLIConfig) { + // For stopping derivation, not to advance safe heads + cfg.Stopped = true + })), + ) +} diff --git a/op-acceptance-tests/tests/sync/manual/sync_test.go b/op-acceptance-tests/tests/sync/manual/sync_test.go new file mode 100644 index 00000000000..65317f3c8a9 --- /dev/null +++ b/op-acceptance-tests/tests/sync/manual/sync_test.go @@ -0,0 +1,60 @@ +package manual + +import ( + "testing" + + "github.com/ethereum-optimism/optimism/op-devstack/devtest" + "github.com/ethereum-optimism/optimism/op-devstack/presets" + "github.com/ethereum-optimism/optimism/op-service/eth" + "github.com/ethereum-optimism/optimism/op-supervisor/supervisor/types" + "github.com/ethereum/go-ethereum" +) + +func TestVerifierManualSync(gt *testing.T) { + t := devtest.SerialT(gt) + + // Disable ELP2P and Batcher + sys := presets.NewSingleChainMultiNodeWithoutCheck(t) + require := t.Require() + logger := t.Logger() + + delta := uint64(7) + sys.L2CL.Advanced(types.LocalUnsafe, delta, 30) + + // Disable Derivation + sys.L2CLB.Stop() + + startBlockNum := sys.L2ELB.BlockRefByLabel(eth.Unsafe).Number + + // Manual Block insertion using engine APIs + for i := uint64(1); i <= delta; i++ { + blockNum := startBlockNum + i + block := sys.L2EL.BlockRefByNumber(blockNum) + // Validator does not have canonical nor noncanonical block for blockNum + _, err := sys.L2ELB.Escape().EthClient().BlockRefByNumber(t.Ctx(), blockNum) + require.Error(err, ethereum.NotFound) + _, err = sys.L2ELB.Escape().EthClient().BlockRefByHash(t.Ctx(), block.Hash) + require.Error(err, ethereum.NotFound) + + // Insert payload + logger.Info("NewPayload", "target", blockNum) + sys.L2ELB.NewPayload(sys.L2EL, blockNum).IsValid() + // Payload valid but not canonicalized. Cannot fetch block by number + _, err = sys.L2ELB.Escape().EthClient().BlockRefByNumber(t.Ctx(), blockNum) + require.Error(err, ethereum.NotFound) + // Now fetchable by hash + require.Equal(blockNum, sys.L2ELB.BlockRefByHash(block.Hash).Number) + + // FCU + logger.Info("ForkchoiceUpdate", "target", blockNum) + sys.L2ELB.ForkchoiceUpdate(sys.L2EL, blockNum, 0, 0, nil).IsValid() + // Payload valid and canonicalized + require.Equal(block.Hash, sys.L2ELB.BlockRefByNumber(blockNum).Hash) + require.Equal(blockNum, sys.L2ELB.BlockRefByHash(block.Hash).Number) + } + + // Check correctly synced by comparing with sequencer EL + res := sys.L2ELB.BlockRefByLabel(eth.Unsafe) + require.Equal(startBlockNum+delta, res.Number) + require.Equal(sys.L2EL.BlockRefByNumber(startBlockNum+delta).Hash, res.Hash) +} diff --git a/op-devstack/dsl/engine.go b/op-devstack/dsl/engine.go new file mode 100644 index 00000000000..8cb26507322 --- /dev/null +++ b/op-devstack/dsl/engine.go @@ -0,0 +1,54 @@ +package dsl + +import ( + "github.com/ethereum-optimism/optimism/op-devstack/devtest" + "github.com/ethereum-optimism/optimism/op-service/eth" +) + +type NewPayloadResult struct { + T devtest.T + Status *eth.PayloadStatusV1 + Err error +} + +func (r *NewPayloadResult) IsPayloadStatus(status eth.ExecutePayloadStatus) *NewPayloadResult { + r.T.Require().NotNil(r.Status, "payload status nil") + r.T.Require().Equal(status, r.Status.Status) + return r +} + +func (r *NewPayloadResult) IsSyncing() *NewPayloadResult { + r.IsPayloadStatus(eth.ExecutionSyncing) + r.T.Require().NoError(r.Err) + return r +} + +func (r *NewPayloadResult) IsValid() *NewPayloadResult { + r.IsPayloadStatus(eth.ExecutionValid) + r.T.Require().NoError(r.Err) + return r +} + +type ForkchoiceUpdateResult struct { + T devtest.T + Result *eth.ForkchoiceUpdatedResult + Err error +} + +func (r *ForkchoiceUpdateResult) IsForkchoiceUpdatedStatus(status eth.ExecutePayloadStatus) *ForkchoiceUpdateResult { + r.T.Require().NotNil(r.Result, "fcu result nil") + r.T.Require().Equal(status, r.Result.PayloadStatus.Status) + return r +} + +func (r *ForkchoiceUpdateResult) IsSyncing() *ForkchoiceUpdateResult { + r.IsForkchoiceUpdatedStatus(eth.ExecutionSyncing) + r.T.Require().NoError(r.Err) + return r +} + +func (r *ForkchoiceUpdateResult) IsValid() *ForkchoiceUpdateResult { + r.IsForkchoiceUpdatedStatus(eth.ExecutionValid) + r.T.Require().NoError(r.Err) + return r +} diff --git a/op-devstack/dsl/l2_el.go b/op-devstack/dsl/l2_el.go index d194e8a1b9e..af38089dfad 100644 --- a/op-devstack/dsl/l2_el.go +++ b/op-devstack/dsl/l2_el.go @@ -53,6 +53,14 @@ func (el *L2ELNode) BlockRefByLabel(label eth.BlockLabel) eth.L2BlockRef { return block } +func (el *L2ELNode) BlockRefByHash(hash common.Hash) eth.L2BlockRef { + ctx, cancel := context.WithTimeout(el.ctx, DefaultTimeout) + defer cancel() + block, err := el.inner.L2EthClient().L2BlockRefByHash(ctx, hash) + el.require.NoError(err, "block not found using block hash") + return block +} + func (el *L2ELNode) AdvancedFn(label eth.BlockLabel, block uint64) CheckFunc { return func() error { initial := el.BlockRefByLabel(label) @@ -215,3 +223,21 @@ func (el *L2ELNode) PayloadByNumber(number uint64) *eth.ExecutionPayloadEnvelope el.require.NoError(err, "failed to get payload") return payload } + +// NewPayload fetches payload for target number from the reference EL Node, and inserts the payload +func (el *L2ELNode) NewPayload(refNode *L2ELNode, number uint64) *NewPayloadResult { + payload := refNode.PayloadByNumber(number) + status, err := el.inner.L2EngineClient().NewPayload(el.ctx, payload.ExecutionPayload, payload.ParentBeaconBlockRoot) + return &NewPayloadResult{T: el.t, Status: status, Err: err} +} + +// ForkchoiceUpdate fetches FCU target hashes from the reference EL node, and FCU update with attributes +func (el *L2ELNode) ForkchoiceUpdate(refNode *L2ELNode, unsafe, safe, finalized uint64, attr *eth.PayloadAttributes) *ForkchoiceUpdateResult { + state := ð.ForkchoiceState{ + HeadBlockHash: refNode.BlockRefByNumber(unsafe).Hash, + SafeBlockHash: refNode.BlockRefByNumber(safe).Hash, + FinalizedBlockHash: refNode.BlockRefByNumber(finalized).Hash, + } + result, err := el.inner.L2EngineClient().ForkchoiceUpdate(el.ctx, state, attr) + return &ForkchoiceUpdateResult{T: el.t, Result: result, Err: err} +} diff --git a/op-devstack/shim/l2_el.go b/op-devstack/shim/l2_el.go index 118ca679f62..b43786af451 100644 --- a/op-devstack/shim/l2_el.go +++ b/op-devstack/shim/l2_el.go @@ -6,18 +6,21 @@ import ( "github.com/ethereum-optimism/optimism/op-devstack/stack" "github.com/ethereum-optimism/optimism/op-node/rollup" "github.com/ethereum-optimism/optimism/op-service/apis" + "github.com/ethereum-optimism/optimism/op-service/client" "github.com/ethereum-optimism/optimism/op-service/sources" ) type L2ELNodeConfig struct { ELNodeConfig - RollupCfg *rollup.Config - ID stack.L2ELNodeID + EngineClient client.RPC + RollupCfg *rollup.Config + ID stack.L2ELNodeID } type rpcL2ELNode struct { rpcELNode - l2Client *sources.L2Client + l2Client *sources.L2Client + l2EngineClient *sources.EngineClient id stack.L2ELNodeID } @@ -30,11 +33,17 @@ func NewL2ELNode(cfg L2ELNodeConfig) stack.L2ELNode { require.NotNil(cfg.T, cfg.RollupCfg, "rollup config must be configured") l2Client, err := sources.NewL2Client(cfg.ELNodeConfig.Client, cfg.T.Logger(), nil, sources.L2ClientSimpleConfig(cfg.RollupCfg, false, 10, 10)) require.NoError(cfg.T, err) - + engineClientConfig := &sources.EngineClientConfig{ + L2ClientConfig: *sources.L2ClientSimpleConfig(cfg.RollupCfg, false, 10, 10), + } + // initialize engine API client using different client + engineClient, err := sources.NewEngineClient(cfg.EngineClient, cfg.T.Logger(), nil, engineClientConfig) + require.NoError(cfg.T, err) return &rpcL2ELNode{ - rpcELNode: newRpcELNode(cfg.ELNodeConfig), - l2Client: l2Client, - id: cfg.ID, + rpcELNode: newRpcELNode(cfg.ELNodeConfig), + l2Client: l2Client, + l2EngineClient: engineClient, + id: cfg.ID, } } @@ -49,3 +58,7 @@ func (r *rpcL2ELNode) L2EthClient() apis.L2EthClient { func (r *rpcL2ELNode) L2EthExtendedClient() apis.L2EthExtendedClient { return r.l2Client } + +func (r *rpcL2ELNode) L2EngineClient() apis.EngineClient { + return r.l2EngineClient.EngineAPIClient +} diff --git a/op-devstack/stack/l2_el.go b/op-devstack/stack/l2_el.go index d3e9043ceb4..3616e399720 100644 --- a/op-devstack/stack/l2_el.go +++ b/op-devstack/stack/l2_el.go @@ -72,6 +72,7 @@ type L2ELNode interface { ID() L2ELNodeID L2EthClient() apis.L2EthClient L2EthExtendedClient() apis.L2EthExtendedClient + L2EngineClient() apis.EngineClient ELNode } diff --git a/op-devstack/sysgo/l2_el.go b/op-devstack/sysgo/l2_el.go index 9fb7be76fd3..19501a32766 100644 --- a/op-devstack/sysgo/l2_el.go +++ b/op-devstack/sysgo/l2_el.go @@ -80,8 +80,9 @@ func WithExtL2Node(id stack.L2ELNodeID, elRPCEndpoint string) stack.Option[*Orch // Create L2 EL node with external RPC l2ELNode := &OpGeth{ - id: id, - userRPC: elRPCEndpoint, + id: id, + userRPC: elRPCEndpoint, + readOnly: true, } require.True(orch.l2ELs.SetIfMissing(id, l2ELNode), "must not already exist") }) diff --git a/op-devstack/sysgo/l2_el_opgeth.go b/op-devstack/sysgo/l2_el_opgeth.go index af233b72d36..e53f07ff3ad 100644 --- a/op-devstack/sysgo/l2_el_opgeth.go +++ b/op-devstack/sysgo/l2_el_opgeth.go @@ -7,6 +7,7 @@ import ( "github.com/ethereum/go-ethereum/log" gn "github.com/ethereum/go-ethereum/node" "github.com/ethereum/go-ethereum/p2p" + "github.com/ethereum/go-ethereum/rpc" "github.com/ethereum-optimism/optimism/op-devstack/devtest" "github.com/ethereum-optimism/optimism/op-devstack/shim" @@ -25,8 +26,10 @@ type OpGeth struct { id stack.L2ELNodeID l2Net *L2Network jwtPath string + jwtSecret [32]byte supervisorRPC string l2Geth *geth.GethInstance + readOnly bool authRPC string userRPC string @@ -55,6 +58,15 @@ func (n *OpGeth) hydrate(system stack.ExtensibleSystem) { require.NoError(err) system.T().Cleanup(rpcCl.Close) + // ReadOnly cannot expose auth RPC + var engineCl client.RPC + if !n.readOnly { + auth := rpc.WithHTTPAuth(gn.NewJWTAuth(n.jwtSecret)) + engineCl, err = client.NewRPC(system.T().Ctx(), system.Logger(), n.authRPC, client.WithGethRPCOptions(auth)) + require.NoError(err) + system.T().Cleanup(engineCl.Close) + } + l2Net := system.L2Network(stack.L2NetworkID(n.id.ChainID())) sysL2EL := shim.NewL2ELNode(shim.L2ELNodeConfig{ RollupCfg: l2Net.RollupConfig(), @@ -63,7 +75,8 @@ func (n *OpGeth) hydrate(system stack.ExtensibleSystem) { Client: rpcCl, ChainID: n.id.ChainID(), }, - ID: n.id, + EngineClient: engineCl, + ID: n.id, }) sysL2EL.SetLabel(match.LabelVendor, string(match.OpGeth)) l2Net.(stack.ExtensibleL2Network).AddL2ELNode(sysL2EL) @@ -138,7 +151,7 @@ func WithOpGeth(id stack.L2ELNodeID, opts ...L2ELOption) stack.Option[*Orchestra orch.l2ELOptions.Apply(p, id, cfg) // apply global options L2ELOptionBundle(opts).Apply(p, id, cfg) // apply specific options - jwtPath, _ := orch.writeDefaultJWT() + jwtPath, jwtSecret := orch.writeDefaultJWT() useInterop := l2Net.genesis.Config.InteropTime != nil @@ -158,6 +171,7 @@ func WithOpGeth(id stack.L2ELNodeID, opts ...L2ELOption) stack.Option[*Orchestra logger: logger, l2Net: l2Net, jwtPath: jwtPath, + jwtSecret: jwtSecret, supervisorRPC: supervisorRPC, } l2EL.Start() diff --git a/op-service/apis/engine.go b/op-service/apis/engine.go new file mode 100644 index 00000000000..027f683cebf --- /dev/null +++ b/op-service/apis/engine.go @@ -0,0 +1,14 @@ +package apis + +import ( + "context" + + "github.com/ethereum-optimism/optimism/op-service/eth" + "github.com/ethereum/go-ethereum/common" +) + +type EngineClient interface { + GetPayload(ctx context.Context, payloadInfo eth.PayloadInfo) (*eth.ExecutionPayloadEnvelope, error) + ForkchoiceUpdate(ctx context.Context, state *eth.ForkchoiceState, attr *eth.PayloadAttributes) (*eth.ForkchoiceUpdatedResult, error) + NewPayload(ctx context.Context, payload *eth.ExecutionPayload, parentBeaconBlockRoot *common.Hash) (*eth.PayloadStatusV1, error) +} From 5e38a4fdbcb3e87e06555701d269aa74cd5bdc89 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Alberto=20Cuesta=20Ca=C3=B1ada?= <38806121+alcueca@users.noreply.github.com> Date: Mon, 6 Oct 2025 19:54:02 +0100 Subject: [PATCH 011/117] Remove upgrade controller from OPCM (#17660) * upgrade controller removed from OPCM * renamed upgradeController to l1PAO in DeployImplementations.Input * Update semver * Remove upgradeController from the docs * Fix VerifyOPCM * Did quite the find and replace here * The OPCM constructor only takes 24 slots now * Some straggler renamings * Fix: semver-lock * Doh * Snapshots? * lint * Fixed the last of the lint with the power of regex * fixed linting * L1PAO == SuperchainProxyAdminOwner * We shouldn't need to pass the upgrade controller to op-deployer to deploy opcm anymore * L1PAO != SuperchainPAO * Let's accept both the backwards compatible UPGRADE_CONTROLLER and the new L!_PROXY_ADMIN_OWNER * Maybe I'll need to drop UPGRADE_CONTROLLER * addressed comments from @bitwiseguy * Needed the three dots, it seems * Shortened form of L1PAO not used in code anymore * update semver-lock and opcm bytecode * *sigh* --- op-chain-ops/interopgen/deploy.go | 2 +- op-deployer/justfile | 4 +- op-deployer/pkg/deployer/bootstrap/flags.go | 11 +++--- .../pkg/deployer/bootstrap/implementations.go | 8 ++-- .../bootstrap/implementations_test.go | 2 +- .../deployer/integration_test/apply_test.go | 2 +- .../pkg/deployer/opcm/implementations.go | 2 +- .../pkg/deployer/opcm/implementations_test.go | 2 +- .../pkg/deployer/pipeline/implementations.go | 2 +- .../pkg/deployer/verify/constructors_test.go | 7 +--- op-e2e/bindings/opcontractsmanager.go | 39 ++----------------- .../book/src/contributing/opcm.md | 3 +- .../interfaces/L1/IOPContractsManager.sol | 5 +-- .../scripts/deploy/Deploy.s.sol | 2 +- .../deploy/DeployImplementations.s.sol | 9 ++--- .../scripts/deploy/VerifyOPCM.s.sol | 1 - .../snapshots/abi/OPContractsManager.json | 18 --------- .../snapshots/semver-lock.json | 4 +- .../src/L1/OPContractsManager.sol | 11 ++---- .../test/L1/OPContractsManager.t.sol | 12 ++---- .../test/opcm/DeployImplementations.t.sol | 10 ++--- .../test/opcm/DeployOPChain.t.sol | 2 +- .../test/scripts/VerifyOPCM.t.sol | 3 -- 23 files changed, 44 insertions(+), 117 deletions(-) diff --git a/op-chain-ops/interopgen/deploy.go b/op-chain-ops/interopgen/deploy.go index 1db0185abcd..8b52b2f4094 100644 --- a/op-chain-ops/interopgen/deploy.go +++ b/op-chain-ops/interopgen/deploy.go @@ -203,7 +203,7 @@ func DeploySuperchainToL1(l1Host *script.Host, opcmScripts *opcm.Scripts, superC SuperchainProxyAdmin: superDeployment.SuperchainProxyAdmin, SuperchainConfigProxy: superDeployment.SuperchainConfigProxy, ProtocolVersionsProxy: superDeployment.ProtocolVersionsProxy, - UpgradeController: superCfg.ProxyAdminOwner, + L1ProxyAdminOwner: superCfg.ProxyAdminOwner, Challenger: superCfg.Challenger, }) if err != nil { diff --git a/op-deployer/justfile b/op-deployer/justfile index 40b24ce2d25..e10fce3938e 100644 --- a/op-deployer/justfile +++ b/op-deployer/justfile @@ -64,7 +64,7 @@ export NETWORK := env_var_or_default("NETWORK", "sepolia") export PROTOCOL_VERSIONS_PROXY := if NETWORK == "mainnet" { "0x8062AbC286f5e7D9428a0Ccb9AbD71e50d93b935" } else if NETWORK == "sepolia" { "0x79ADD5713B383DAa0a138d3C4780C7A1804a8090" } else { "" } export SUPERCHAIN_CONFIG_PROXY := if NETWORK == "mainnet" { "0x95703e0982140D16f8ebA6d158FccEde42f04a4C" } else if NETWORK == "sepolia" { "0xC2Be75506d5724086DEB7245bd260Cc9753911Be" } else { "" } export SUPERCHAIN_PROXY_ADMIN := if NETWORK == "mainnet" { "0x543ba4aadbab8f9025686bd03993043599c6fb04" } else if NETWORK == "sepolia" { "0x189abaaaa82dfc015a588a7dbad6f13b1d3485bc" } else { "" } -export UPGRADE_CONTROLLER := if NETWORK == "mainnet" { "0x5a0Aae59D09fccBdDb6C6CcEB07B7279367C3d2A" } else if NETWORK == "sepolia" { "0x1Eb2fFc903729a0F03966B917003800b145F56E2" } else { "" } +export L1_PROXY_ADMIN_OWNER := if NETWORK == "mainnet" { "0x5a0Aae59D09fccBdDb6C6CcEB07B7279367C3d2A" } else if NETWORK == "sepolia" { "0x1Eb2fFc903729a0F03966B917003800b145F56E2" } else { "" } export CHALLENGER := if NETWORK == "mainnet" { "0x9BA6e03D8B90dE867373Db8cF1A58d2F7F006b3A" } else if NETWORK == "sepolia" { "0xfd1D2e729aE8eEe2E146c033bf4400fE75284301" } else { "" } # This command should be called before any deployment or verification commands. @@ -91,7 +91,7 @@ deploy-opcm release="dev" locator="$DEFAULT_LOCATOR": _validate_rpc --mips-version 7 \ --protocol-versions-proxy $PROTOCOL_VERSIONS_PROXY \ --superchain-config-proxy $SUPERCHAIN_CONFIG_PROXY \ - --upgrade-controller $UPGRADE_CONTROLLER \ + --l1-proxy-admin-owner $L1_PROXY_ADMIN_OWNER \ --l1-contracts-release {{release}} \ --superchain-proxy-admin $SUPERCHAIN_PROXY_ADMIN \ --challenger $CHALLENGER \ diff --git a/op-deployer/pkg/deployer/bootstrap/flags.go b/op-deployer/pkg/deployer/bootstrap/flags.go index b108d91900e..dbf4e0625e3 100644 --- a/op-deployer/pkg/deployer/bootstrap/flags.go +++ b/op-deployer/pkg/deployer/bootstrap/flags.go @@ -124,10 +124,11 @@ var ( Usage: "Protocol versions proxy.", EnvVars: deployer.PrefixEnvVar("PROTOCOL_VERSIONS_PROXY"), } - UpgradeControllerFlag = &cli.StringFlag{ - Name: "upgrade-controller", - Usage: "Upgrade controller.", - EnvVars: deployer.PrefixEnvVar("UPGRADE_CONTROLLER"), + L1ProxyAdminOwnerFlag = &cli.StringFlag{ + Name: "l1-proxy-admin-owner", + Aliases: []string{"upgrade-controller"}, + Usage: "L1 ProxyAdmin Owner.", + EnvVars: append(deployer.PrefixEnvVar("L1_PROXY_ADMIN_OWNER"), deployer.PrefixEnvVar("UPGRADE_CONTROLLER")...), } SuperchainProxyAdminFlag = &cli.StringFlag{ Name: "superchain-proxy-admin", @@ -160,7 +161,7 @@ var ImplementationsFlags = []cli.Flag{ DisputeGameFinalityDelaySecondsFlag, SuperchainConfigProxyFlag, ProtocolVersionsProxyFlag, - UpgradeControllerFlag, + L1ProxyAdminOwnerFlag, SuperchainProxyAdminFlag, ChallengerFlag, } diff --git a/op-deployer/pkg/deployer/bootstrap/implementations.go b/op-deployer/pkg/deployer/bootstrap/implementations.go index 0545af62324..13e57740730 100644 --- a/op-deployer/pkg/deployer/bootstrap/implementations.go +++ b/op-deployer/pkg/deployer/bootstrap/implementations.go @@ -45,7 +45,7 @@ type ImplementationsConfig struct { FaultGameMaxClockDuration uint64 `cli:"fault-game-max-clock-duration"` SuperchainConfigProxy common.Address `cli:"superchain-config-proxy"` ProtocolVersionsProxy common.Address `cli:"protocol-versions-proxy"` - UpgradeController common.Address `cli:"upgrade-controller"` + L1ProxyAdminOwner common.Address `cli:"l1-proxy-admin-owner"` SuperchainProxyAdmin common.Address `cli:"superchain-proxy-admin"` Challenger common.Address `cli:"challenger"` CacheDir string `cli:"cache-dir"` @@ -115,8 +115,8 @@ func (c *ImplementationsConfig) Check() error { if c.ProtocolVersionsProxy == (common.Address{}) { return errors.New("protocol versions proxy must be specified") } - if c.UpgradeController == (common.Address{}) { - return errors.New("upgrade controller must be specified") + if c.L1ProxyAdminOwner == (common.Address{}) { + return errors.New("l1 proxy admin owner must be specified") } if c.SuperchainProxyAdmin == (common.Address{}) { return errors.New("superchain proxy admin must be specified") @@ -232,7 +232,7 @@ func Implementations(ctx context.Context, cfg ImplementationsConfig) (opcm.Deplo SuperchainConfigProxy: cfg.SuperchainConfigProxy, ProtocolVersionsProxy: cfg.ProtocolVersionsProxy, SuperchainProxyAdmin: cfg.SuperchainProxyAdmin, - UpgradeController: cfg.UpgradeController, + L1ProxyAdminOwner: cfg.L1ProxyAdminOwner, Challenger: cfg.Challenger, }, ); err != nil { diff --git a/op-deployer/pkg/deployer/bootstrap/implementations_test.go b/op-deployer/pkg/deployer/bootstrap/implementations_test.go index 50a50c6cc96..bb08d8a3bad 100644 --- a/op-deployer/pkg/deployer/bootstrap/implementations_test.go +++ b/op-deployer/pkg/deployer/bootstrap/implementations_test.go @@ -83,7 +83,7 @@ func testImplementations(t *testing.T, forkRPCURL string, cacheDir string) { SuperchainConfigProxy: superchain.SuperchainConfigAddr, ProtocolVersionsProxy: superchain.ProtocolVersionsAddr, SuperchainProxyAdmin: proxyAdminOwner, - UpgradeController: proxyAdminOwner, + L1ProxyAdminOwner: proxyAdminOwner, Challenger: common.Address{'C'}, CacheDir: cacheDir, }) diff --git a/op-deployer/pkg/deployer/integration_test/apply_test.go b/op-deployer/pkg/deployer/integration_test/apply_test.go index 76cf010eaa8..390c37de144 100644 --- a/op-deployer/pkg/deployer/integration_test/apply_test.go +++ b/op-deployer/pkg/deployer/integration_test/apply_test.go @@ -103,7 +103,7 @@ func TestEndToEndBootstrapApply(t *testing.T) { DevFeatureBitmap: common.Hash{}, SuperchainConfigProxy: bstrap.SuperchainConfigProxy, ProtocolVersionsProxy: bstrap.ProtocolVersionsProxy, - UpgradeController: superchainPAO, + L1ProxyAdminOwner: superchainPAO, SuperchainProxyAdmin: bstrap.SuperchainProxyAdmin, CacheDir: testCacheDir, Logger: lgr, diff --git a/op-deployer/pkg/deployer/opcm/implementations.go b/op-deployer/pkg/deployer/opcm/implementations.go index c9fe5176b28..538df861898 100644 --- a/op-deployer/pkg/deployer/opcm/implementations.go +++ b/op-deployer/pkg/deployer/opcm/implementations.go @@ -23,7 +23,7 @@ type DeployImplementationsInput struct { SuperchainConfigProxy common.Address ProtocolVersionsProxy common.Address SuperchainProxyAdmin common.Address - UpgradeController common.Address + L1ProxyAdminOwner common.Address Challenger common.Address } diff --git a/op-deployer/pkg/deployer/opcm/implementations_test.go b/op-deployer/pkg/deployer/opcm/implementations_test.go index 4b9128a40c2..f42fd6a9714 100644 --- a/op-deployer/pkg/deployer/opcm/implementations_test.go +++ b/op-deployer/pkg/deployer/opcm/implementations_test.go @@ -73,7 +73,7 @@ func TestNewDeployImplementationsScript(t *testing.T) { SuperchainConfigProxy: proxyAddress, ProtocolVersionsProxy: protocolVersionsAddress, SuperchainProxyAdmin: proxyAdminAddress, - UpgradeController: common.BigToAddress(big.NewInt(13)), + L1ProxyAdminOwner: common.BigToAddress(big.NewInt(13)), Challenger: common.BigToAddress(big.NewInt(14)), }) diff --git a/op-deployer/pkg/deployer/pipeline/implementations.go b/op-deployer/pkg/deployer/pipeline/implementations.go index e9b849d8170..c12413f3814 100644 --- a/op-deployer/pkg/deployer/pipeline/implementations.go +++ b/op-deployer/pkg/deployer/pipeline/implementations.go @@ -55,7 +55,7 @@ func DeployImplementations(env *Env, intent *state.Intent, st *state.State) erro SuperchainConfigProxy: st.SuperchainDeployment.SuperchainConfigProxy, ProtocolVersionsProxy: st.SuperchainDeployment.ProtocolVersionsProxy, SuperchainProxyAdmin: st.SuperchainDeployment.SuperchainProxyAdminImpl, - UpgradeController: st.SuperchainRoles.SuperchainProxyAdminOwner, + L1ProxyAdminOwner: st.SuperchainRoles.SuperchainProxyAdminOwner, Challenger: st.SuperchainRoles.Challenger, }, ) diff --git a/op-deployer/pkg/deployer/verify/constructors_test.go b/op-deployer/pkg/deployer/verify/constructors_test.go index 51c1a4de38c..7a3d2757b89 100644 --- a/op-deployer/pkg/deployer/verify/constructors_test.go +++ b/op-deployer/pkg/deployer/verify/constructors_test.go @@ -144,11 +144,6 @@ func TestCalculateTypeSlots(t *testing.T) { "internalType": "address" } ] - }, - { - "name": "_upgradeController", - "type": "address", - "internalType": "address" } ]` @@ -161,6 +156,6 @@ func TestCalculateTypeSlots(t *testing.T) { totalSlots += calculateTypeSlots(arg.Type) } - require.Equal(t, 25, totalSlots) + require.Equal(t, 24, totalSlots) }) } diff --git a/op-e2e/bindings/opcontractsmanager.go b/op-e2e/bindings/opcontractsmanager.go index 155dd255ade..26dea347ff6 100644 --- a/op-e2e/bindings/opcontractsmanager.go +++ b/op-e2e/bindings/opcontractsmanager.go @@ -181,8 +181,8 @@ type Proposal struct { // OPContractsManagerMetaData contains all meta data concerning the OPContractsManager contract. var OPContractsManagerMetaData = &bind.MetaData{ - ABI: "[{\"type\":\"constructor\",\"inputs\":[{\"name\":\"_opcmGameTypeAdder\",\"type\":\"address\",\"internalType\":\"contractOPContractsManagerGameTypeAdder\"},{\"name\":\"_opcmDeployer\",\"type\":\"address\",\"internalType\":\"contractOPContractsManagerDeployer\"},{\"name\":\"_opcmUpgrader\",\"type\":\"address\",\"internalType\":\"contractOPContractsManagerUpgrader\"},{\"name\":\"_opcmInteropMigrator\",\"type\":\"address\",\"internalType\":\"contractOPContractsManagerInteropMigrator\"},{\"name\":\"_opcmStandardValidator\",\"type\":\"address\",\"internalType\":\"contractOPContractsManagerStandardValidator\"},{\"name\":\"_superchainConfig\",\"type\":\"address\",\"internalType\":\"contractISuperchainConfig\"},{\"name\":\"_protocolVersions\",\"type\":\"address\",\"internalType\":\"contractIProtocolVersions\"},{\"name\":\"_superchainProxyAdmin\",\"type\":\"address\",\"internalType\":\"contractIProxyAdmin\"},{\"name\":\"_upgradeController\",\"type\":\"address\",\"internalType\":\"address\"}],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"addGameType\",\"inputs\":[{\"name\":\"_gameConfigs\",\"type\":\"tuple[]\",\"internalType\":\"structOPContractsManager.AddGameInput[]\",\"components\":[{\"name\":\"saltMixer\",\"type\":\"string\",\"internalType\":\"string\"},{\"name\":\"systemConfig\",\"type\":\"address\",\"internalType\":\"contractISystemConfig\"},{\"name\":\"proxyAdmin\",\"type\":\"address\",\"internalType\":\"contractIProxyAdmin\"},{\"name\":\"delayedWETH\",\"type\":\"address\",\"internalType\":\"contractIDelayedWETH\"},{\"name\":\"disputeGameType\",\"type\":\"uint32\",\"internalType\":\"GameType\"},{\"name\":\"disputeAbsolutePrestate\",\"type\":\"bytes32\",\"internalType\":\"Claim\"},{\"name\":\"disputeMaxGameDepth\",\"type\":\"uint256\",\"internalType\":\"uint256\"},{\"name\":\"disputeSplitDepth\",\"type\":\"uint256\",\"internalType\":\"uint256\"},{\"name\":\"disputeClockExtension\",\"type\":\"uint64\",\"internalType\":\"Duration\"},{\"name\":\"disputeMaxClockDuration\",\"type\":\"uint64\",\"internalType\":\"Duration\"},{\"name\":\"initialBond\",\"type\":\"uint256\",\"internalType\":\"uint256\"},{\"name\":\"vm\",\"type\":\"address\",\"internalType\":\"contractIBigStepper\"},{\"name\":\"permissioned\",\"type\":\"bool\",\"internalType\":\"bool\"}]}],\"outputs\":[{\"name\":\"\",\"type\":\"tuple[]\",\"internalType\":\"structOPContractsManager.AddGameOutput[]\",\"components\":[{\"name\":\"delayedWETH\",\"type\":\"address\",\"internalType\":\"contractIDelayedWETH\"},{\"name\":\"faultDisputeGame\",\"type\":\"address\",\"internalType\":\"contractIFaultDisputeGame\"}]}],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"blueprints\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"tuple\",\"internalType\":\"structOPContractsManager.Blueprints\",\"components\":[{\"name\":\"addressManager\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"proxy\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"proxyAdmin\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"l1ChugSplashProxy\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"resolvedDelegateProxy\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"permissionedDisputeGame1\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"permissionedDisputeGame2\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"permissionlessDisputeGame1\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"permissionlessDisputeGame2\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"superPermissionedDisputeGame1\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"superPermissionedDisputeGame2\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"superPermissionlessDisputeGame1\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"superPermissionlessDisputeGame2\",\"type\":\"address\",\"internalType\":\"address\"}]}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"chainIdToBatchInboxAddress\",\"inputs\":[{\"name\":\"_l2ChainId\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"outputs\":[{\"name\":\"\",\"type\":\"address\",\"internalType\":\"address\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"deploy\",\"inputs\":[{\"name\":\"_input\",\"type\":\"tuple\",\"internalType\":\"structOPContractsManager.DeployInput\",\"components\":[{\"name\":\"roles\",\"type\":\"tuple\",\"internalType\":\"structOPContractsManager.Roles\",\"components\":[{\"name\":\"opChainProxyAdminOwner\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"systemConfigOwner\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"batcher\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"unsafeBlockSigner\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"proposer\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"challenger\",\"type\":\"address\",\"internalType\":\"address\"}]},{\"name\":\"basefeeScalar\",\"type\":\"uint32\",\"internalType\":\"uint32\"},{\"name\":\"blobBasefeeScalar\",\"type\":\"uint32\",\"internalType\":\"uint32\"},{\"name\":\"l2ChainId\",\"type\":\"uint256\",\"internalType\":\"uint256\"},{\"name\":\"startingAnchorRoot\",\"type\":\"bytes\",\"internalType\":\"bytes\"},{\"name\":\"saltMixer\",\"type\":\"string\",\"internalType\":\"string\"},{\"name\":\"gasLimit\",\"type\":\"uint64\",\"internalType\":\"uint64\"},{\"name\":\"disputeGameType\",\"type\":\"uint32\",\"internalType\":\"GameType\"},{\"name\":\"disputeAbsolutePrestate\",\"type\":\"bytes32\",\"internalType\":\"Claim\"},{\"name\":\"disputeMaxGameDepth\",\"type\":\"uint256\",\"internalType\":\"uint256\"},{\"name\":\"disputeSplitDepth\",\"type\":\"uint256\",\"internalType\":\"uint256\"},{\"name\":\"disputeClockExtension\",\"type\":\"uint64\",\"internalType\":\"Duration\"},{\"name\":\"disputeMaxClockDuration\",\"type\":\"uint64\",\"internalType\":\"Duration\"}]}],\"outputs\":[{\"name\":\"\",\"type\":\"tuple\",\"internalType\":\"structOPContractsManager.DeployOutput\",\"components\":[{\"name\":\"opChainProxyAdmin\",\"type\":\"address\",\"internalType\":\"contractIProxyAdmin\"},{\"name\":\"addressManager\",\"type\":\"address\",\"internalType\":\"contractIAddressManager\"},{\"name\":\"l1ERC721BridgeProxy\",\"type\":\"address\",\"internalType\":\"contractIL1ERC721Bridge\"},{\"name\":\"systemConfigProxy\",\"type\":\"address\",\"internalType\":\"contractISystemConfig\"},{\"name\":\"optimismMintableERC20FactoryProxy\",\"type\":\"address\",\"internalType\":\"contractIOptimismMintableERC20Factory\"},{\"name\":\"l1StandardBridgeProxy\",\"type\":\"address\",\"internalType\":\"contractIL1StandardBridge\"},{\"name\":\"l1CrossDomainMessengerProxy\",\"type\":\"address\",\"internalType\":\"contractIL1CrossDomainMessenger\"},{\"name\":\"ethLockboxProxy\",\"type\":\"address\",\"internalType\":\"contractIETHLockbox\"},{\"name\":\"optimismPortalProxy\",\"type\":\"address\",\"internalType\":\"contractIOptimismPortal2\"},{\"name\":\"disputeGameFactoryProxy\",\"type\":\"address\",\"internalType\":\"contractIDisputeGameFactory\"},{\"name\":\"anchorStateRegistryProxy\",\"type\":\"address\",\"internalType\":\"contractIAnchorStateRegistry\"},{\"name\":\"faultDisputeGame\",\"type\":\"address\",\"internalType\":\"contractIFaultDisputeGame\"},{\"name\":\"permissionedDisputeGame\",\"type\":\"address\",\"internalType\":\"contractIPermissionedDisputeGame\"},{\"name\":\"delayedWETHPermissionedGameProxy\",\"type\":\"address\",\"internalType\":\"contractIDelayedWETH\"},{\"name\":\"delayedWETHPermissionlessGameProxy\",\"type\":\"address\",\"internalType\":\"contractIDelayedWETH\"}]}],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"devFeatureBitmap\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"bytes32\",\"internalType\":\"bytes32\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"implementations\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"tuple\",\"internalType\":\"structOPContractsManager.Implementations\",\"components\":[{\"name\":\"superchainConfigImpl\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"protocolVersionsImpl\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"l1ERC721BridgeImpl\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"optimismPortalImpl\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"optimismPortalInteropImpl\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"ethLockboxImpl\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"systemConfigImpl\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"optimismMintableERC20FactoryImpl\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"l1CrossDomainMessengerImpl\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"l1StandardBridgeImpl\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"disputeGameFactoryImpl\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"anchorStateRegistryImpl\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"delayedWETHImpl\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"mipsImpl\",\"type\":\"address\",\"internalType\":\"address\"}]}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"isDevFeatureEnabled\",\"inputs\":[{\"name\":\"_feature\",\"type\":\"bytes32\",\"internalType\":\"bytes32\"}],\"outputs\":[{\"name\":\"\",\"type\":\"bool\",\"internalType\":\"bool\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"migrate\",\"inputs\":[{\"name\":\"_input\",\"type\":\"tuple\",\"internalType\":\"structOPContractsManagerInteropMigrator.MigrateInput\",\"components\":[{\"name\":\"usePermissionlessGame\",\"type\":\"bool\",\"internalType\":\"bool\"},{\"name\":\"startingAnchorRoot\",\"type\":\"tuple\",\"internalType\":\"structProposal\",\"components\":[{\"name\":\"root\",\"type\":\"bytes32\",\"internalType\":\"Hash\"},{\"name\":\"l2SequenceNumber\",\"type\":\"uint256\",\"internalType\":\"uint256\"}]},{\"name\":\"gameParameters\",\"type\":\"tuple\",\"internalType\":\"structOPContractsManagerInteropMigrator.GameParameters\",\"components\":[{\"name\":\"proposer\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"challenger\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"maxGameDepth\",\"type\":\"uint256\",\"internalType\":\"uint256\"},{\"name\":\"splitDepth\",\"type\":\"uint256\",\"internalType\":\"uint256\"},{\"name\":\"initBond\",\"type\":\"uint256\",\"internalType\":\"uint256\"},{\"name\":\"clockExtension\",\"type\":\"uint64\",\"internalType\":\"Duration\"},{\"name\":\"maxClockDuration\",\"type\":\"uint64\",\"internalType\":\"Duration\"}]},{\"name\":\"opChainConfigs\",\"type\":\"tuple[]\",\"internalType\":\"structOPContractsManager.OpChainConfig[]\",\"components\":[{\"name\":\"systemConfigProxy\",\"type\":\"address\",\"internalType\":\"contractISystemConfig\"},{\"name\":\"proxyAdmin\",\"type\":\"address\",\"internalType\":\"contractIProxyAdmin\"},{\"name\":\"absolutePrestate\",\"type\":\"bytes32\",\"internalType\":\"Claim\"}]}]}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"opcmDeployer\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"address\",\"internalType\":\"contractOPContractsManagerDeployer\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"opcmGameTypeAdder\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"address\",\"internalType\":\"contractOPContractsManagerGameTypeAdder\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"opcmInteropMigrator\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"address\",\"internalType\":\"contractOPContractsManagerInteropMigrator\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"opcmStandardValidator\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"address\",\"internalType\":\"contractOPContractsManagerStandardValidator\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"opcmUpgrader\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"address\",\"internalType\":\"contractOPContractsManagerUpgrader\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"protocolVersions\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"address\",\"internalType\":\"contractIProtocolVersions\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"superchainConfig\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"address\",\"internalType\":\"contractISuperchainConfig\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"superchainProxyAdmin\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"address\",\"internalType\":\"contractIProxyAdmin\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"updatePrestate\",\"inputs\":[{\"name\":\"_prestateUpdateInputs\",\"type\":\"tuple[]\",\"internalType\":\"structOPContractsManager.OpChainConfig[]\",\"components\":[{\"name\":\"systemConfigProxy\",\"type\":\"address\",\"internalType\":\"contractISystemConfig\"},{\"name\":\"proxyAdmin\",\"type\":\"address\",\"internalType\":\"contractIProxyAdmin\"},{\"name\":\"absolutePrestate\",\"type\":\"bytes32\",\"internalType\":\"Claim\"}]}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"upgrade\",\"inputs\":[{\"name\":\"_opChainConfigs\",\"type\":\"tuple[]\",\"internalType\":\"structOPContractsManager.OpChainConfig[]\",\"components\":[{\"name\":\"systemConfigProxy\",\"type\":\"address\",\"internalType\":\"contractISystemConfig\"},{\"name\":\"proxyAdmin\",\"type\":\"address\",\"internalType\":\"contractIProxyAdmin\"},{\"name\":\"absolutePrestate\",\"type\":\"bytes32\",\"internalType\":\"Claim\"}]}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"upgradeController\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"address\",\"internalType\":\"address\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"validate\",\"inputs\":[{\"name\":\"_input\",\"type\":\"tuple\",\"internalType\":\"structOPContractsManagerStandardValidator.ValidationInput\",\"components\":[{\"name\":\"proxyAdmin\",\"type\":\"address\",\"internalType\":\"contractIProxyAdmin\"},{\"name\":\"sysCfg\",\"type\":\"address\",\"internalType\":\"contractISystemConfig\"},{\"name\":\"absolutePrestate\",\"type\":\"bytes32\",\"internalType\":\"bytes32\"},{\"name\":\"l2ChainID\",\"type\":\"uint256\",\"internalType\":\"uint256\"}]},{\"name\":\"_allowFailure\",\"type\":\"bool\",\"internalType\":\"bool\"}],\"outputs\":[{\"name\":\"\",\"type\":\"string\",\"internalType\":\"string\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"validateWithOverrides\",\"inputs\":[{\"name\":\"_input\",\"type\":\"tuple\",\"internalType\":\"structOPContractsManagerStandardValidator.ValidationInput\",\"components\":[{\"name\":\"proxyAdmin\",\"type\":\"address\",\"internalType\":\"contractIProxyAdmin\"},{\"name\":\"sysCfg\",\"type\":\"address\",\"internalType\":\"contractISystemConfig\"},{\"name\":\"absolutePrestate\",\"type\":\"bytes32\",\"internalType\":\"bytes32\"},{\"name\":\"l2ChainID\",\"type\":\"uint256\",\"internalType\":\"uint256\"}]},{\"name\":\"_allowFailure\",\"type\":\"bool\",\"internalType\":\"bool\"},{\"name\":\"_overrides\",\"type\":\"tuple\",\"internalType\":\"structOPContractsManagerStandardValidator.ValidationOverrides\",\"components\":[{\"name\":\"l1PAOMultisig\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"challenger\",\"type\":\"address\",\"internalType\":\"address\"}]}],\"outputs\":[{\"name\":\"\",\"type\":\"string\",\"internalType\":\"string\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"version\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"string\",\"internalType\":\"string\"}],\"stateMutability\":\"pure\"},{\"type\":\"error\",\"name\":\"AddressHasNoCode\",\"inputs\":[{\"name\":\"who\",\"type\":\"address\",\"internalType\":\"address\"}]},{\"type\":\"error\",\"name\":\"AddressNotFound\",\"inputs\":[{\"name\":\"who\",\"type\":\"address\",\"internalType\":\"address\"}]},{\"type\":\"error\",\"name\":\"AlreadyReleased\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"InvalidChainId\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"InvalidGameConfigs\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"InvalidRoleAddress\",\"inputs\":[{\"name\":\"role\",\"type\":\"string\",\"internalType\":\"string\"}]},{\"type\":\"error\",\"name\":\"InvalidStartingAnchorRoot\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"LatestReleaseNotSet\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"OnlyDelegatecall\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"PrestateNotSet\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"PrestateRequired\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"SuperchainConfigMismatch\",\"inputs\":[{\"name\":\"systemConfig\",\"type\":\"address\",\"internalType\":\"contractISystemConfig\"}]},{\"type\":\"error\",\"name\":\"SuperchainProxyAdminMismatch\",\"inputs\":[]}]", - Bin: "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", + ABI: "[{\"type\":\"constructor\",\"inputs\":[{\"name\":\"_opcmGameTypeAdder\",\"type\":\"address\",\"internalType\":\"contractOPContractsManagerGameTypeAdder\"},{\"name\":\"_opcmDeployer\",\"type\":\"address\",\"internalType\":\"contractOPContractsManagerDeployer\"},{\"name\":\"_opcmUpgrader\",\"type\":\"address\",\"internalType\":\"contractOPContractsManagerUpgrader\"},{\"name\":\"_opcmInteropMigrator\",\"type\":\"address\",\"internalType\":\"contractOPContractsManagerInteropMigrator\"},{\"name\":\"_opcmStandardValidator\",\"type\":\"address\",\"internalType\":\"contractOPContractsManagerStandardValidator\"},{\"name\":\"_superchainConfig\",\"type\":\"address\",\"internalType\":\"contractISuperchainConfig\"},{\"name\":\"_protocolVersions\",\"type\":\"address\",\"internalType\":\"contractIProtocolVersions\"},{\"name\":\"_superchainProxyAdmin\",\"type\":\"address\",\"internalType\":\"contractIProxyAdmin\"}],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"addGameType\",\"inputs\":[{\"name\":\"_gameConfigs\",\"type\":\"tuple[]\",\"internalType\":\"structOPContractsManager.AddGameInput[]\",\"components\":[{\"name\":\"saltMixer\",\"type\":\"string\",\"internalType\":\"string\"},{\"name\":\"systemConfig\",\"type\":\"address\",\"internalType\":\"contractISystemConfig\"},{\"name\":\"proxyAdmin\",\"type\":\"address\",\"internalType\":\"contractIProxyAdmin\"},{\"name\":\"delayedWETH\",\"type\":\"address\",\"internalType\":\"contractIDelayedWETH\"},{\"name\":\"disputeGameType\",\"type\":\"uint32\",\"internalType\":\"GameType\"},{\"name\":\"disputeAbsolutePrestate\",\"type\":\"bytes32\",\"internalType\":\"Claim\"},{\"name\":\"disputeMaxGameDepth\",\"type\":\"uint256\",\"internalType\":\"uint256\"},{\"name\":\"disputeSplitDepth\",\"type\":\"uint256\",\"internalType\":\"uint256\"},{\"name\":\"disputeClockExtension\",\"type\":\"uint64\",\"internalType\":\"Duration\"},{\"name\":\"disputeMaxClockDuration\",\"type\":\"uint64\",\"internalType\":\"Duration\"},{\"name\":\"initialBond\",\"type\":\"uint256\",\"internalType\":\"uint256\"},{\"name\":\"vm\",\"type\":\"address\",\"internalType\":\"contractIBigStepper\"},{\"name\":\"permissioned\",\"type\":\"bool\",\"internalType\":\"bool\"}]}],\"outputs\":[{\"name\":\"\",\"type\":\"tuple[]\",\"internalType\":\"structOPContractsManager.AddGameOutput[]\",\"components\":[{\"name\":\"delayedWETH\",\"type\":\"address\",\"internalType\":\"contractIDelayedWETH\"},{\"name\":\"faultDisputeGame\",\"type\":\"address\",\"internalType\":\"contractIFaultDisputeGame\"}]}],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"blueprints\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"tuple\",\"internalType\":\"structOPContractsManager.Blueprints\",\"components\":[{\"name\":\"addressManager\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"proxy\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"proxyAdmin\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"l1ChugSplashProxy\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"resolvedDelegateProxy\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"permissionedDisputeGame1\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"permissionedDisputeGame2\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"permissionlessDisputeGame1\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"permissionlessDisputeGame2\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"superPermissionedDisputeGame1\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"superPermissionedDisputeGame2\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"superPermissionlessDisputeGame1\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"superPermissionlessDisputeGame2\",\"type\":\"address\",\"internalType\":\"address\"}]}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"chainIdToBatchInboxAddress\",\"inputs\":[{\"name\":\"_l2ChainId\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"outputs\":[{\"name\":\"\",\"type\":\"address\",\"internalType\":\"address\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"deploy\",\"inputs\":[{\"name\":\"_input\",\"type\":\"tuple\",\"internalType\":\"structOPContractsManager.DeployInput\",\"components\":[{\"name\":\"roles\",\"type\":\"tuple\",\"internalType\":\"structOPContractsManager.Roles\",\"components\":[{\"name\":\"opChainProxyAdminOwner\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"systemConfigOwner\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"batcher\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"unsafeBlockSigner\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"proposer\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"challenger\",\"type\":\"address\",\"internalType\":\"address\"}]},{\"name\":\"basefeeScalar\",\"type\":\"uint32\",\"internalType\":\"uint32\"},{\"name\":\"blobBasefeeScalar\",\"type\":\"uint32\",\"internalType\":\"uint32\"},{\"name\":\"l2ChainId\",\"type\":\"uint256\",\"internalType\":\"uint256\"},{\"name\":\"startingAnchorRoot\",\"type\":\"bytes\",\"internalType\":\"bytes\"},{\"name\":\"saltMixer\",\"type\":\"string\",\"internalType\":\"string\"},{\"name\":\"gasLimit\",\"type\":\"uint64\",\"internalType\":\"uint64\"},{\"name\":\"disputeGameType\",\"type\":\"uint32\",\"internalType\":\"GameType\"},{\"name\":\"disputeAbsolutePrestate\",\"type\":\"bytes32\",\"internalType\":\"Claim\"},{\"name\":\"disputeMaxGameDepth\",\"type\":\"uint256\",\"internalType\":\"uint256\"},{\"name\":\"disputeSplitDepth\",\"type\":\"uint256\",\"internalType\":\"uint256\"},{\"name\":\"disputeClockExtension\",\"type\":\"uint64\",\"internalType\":\"Duration\"},{\"name\":\"disputeMaxClockDuration\",\"type\":\"uint64\",\"internalType\":\"Duration\"}]}],\"outputs\":[{\"name\":\"\",\"type\":\"tuple\",\"internalType\":\"structOPContractsManager.DeployOutput\",\"components\":[{\"name\":\"opChainProxyAdmin\",\"type\":\"address\",\"internalType\":\"contractIProxyAdmin\"},{\"name\":\"addressManager\",\"type\":\"address\",\"internalType\":\"contractIAddressManager\"},{\"name\":\"l1ERC721BridgeProxy\",\"type\":\"address\",\"internalType\":\"contractIL1ERC721Bridge\"},{\"name\":\"systemConfigProxy\",\"type\":\"address\",\"internalType\":\"contractISystemConfig\"},{\"name\":\"optimismMintableERC20FactoryProxy\",\"type\":\"address\",\"internalType\":\"contractIOptimismMintableERC20Factory\"},{\"name\":\"l1StandardBridgeProxy\",\"type\":\"address\",\"internalType\":\"contractIL1StandardBridge\"},{\"name\":\"l1CrossDomainMessengerProxy\",\"type\":\"address\",\"internalType\":\"contractIL1CrossDomainMessenger\"},{\"name\":\"ethLockboxProxy\",\"type\":\"address\",\"internalType\":\"contractIETHLockbox\"},{\"name\":\"optimismPortalProxy\",\"type\":\"address\",\"internalType\":\"contractIOptimismPortal2\"},{\"name\":\"disputeGameFactoryProxy\",\"type\":\"address\",\"internalType\":\"contractIDisputeGameFactory\"},{\"name\":\"anchorStateRegistryProxy\",\"type\":\"address\",\"internalType\":\"contractIAnchorStateRegistry\"},{\"name\":\"faultDisputeGame\",\"type\":\"address\",\"internalType\":\"contractIFaultDisputeGame\"},{\"name\":\"permissionedDisputeGame\",\"type\":\"address\",\"internalType\":\"contractIPermissionedDisputeGame\"},{\"name\":\"delayedWETHPermissionedGameProxy\",\"type\":\"address\",\"internalType\":\"contractIDelayedWETH\"},{\"name\":\"delayedWETHPermissionlessGameProxy\",\"type\":\"address\",\"internalType\":\"contractIDelayedWETH\"}]}],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"devFeatureBitmap\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"bytes32\",\"internalType\":\"bytes32\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"implementations\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"tuple\",\"internalType\":\"structOPContractsManager.Implementations\",\"components\":[{\"name\":\"superchainConfigImpl\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"protocolVersionsImpl\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"l1ERC721BridgeImpl\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"optimismPortalImpl\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"optimismPortalInteropImpl\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"ethLockboxImpl\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"systemConfigImpl\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"optimismMintableERC20FactoryImpl\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"l1CrossDomainMessengerImpl\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"l1StandardBridgeImpl\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"disputeGameFactoryImpl\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"anchorStateRegistryImpl\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"delayedWETHImpl\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"mipsImpl\",\"type\":\"address\",\"internalType\":\"address\"}]}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"isDevFeatureEnabled\",\"inputs\":[{\"name\":\"_feature\",\"type\":\"bytes32\",\"internalType\":\"bytes32\"}],\"outputs\":[{\"name\":\"\",\"type\":\"bool\",\"internalType\":\"bool\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"migrate\",\"inputs\":[{\"name\":\"_input\",\"type\":\"tuple\",\"internalType\":\"structOPContractsManagerInteropMigrator.MigrateInput\",\"components\":[{\"name\":\"usePermissionlessGame\",\"type\":\"bool\",\"internalType\":\"bool\"},{\"name\":\"startingAnchorRoot\",\"type\":\"tuple\",\"internalType\":\"structProposal\",\"components\":[{\"name\":\"root\",\"type\":\"bytes32\",\"internalType\":\"Hash\"},{\"name\":\"l2SequenceNumber\",\"type\":\"uint256\",\"internalType\":\"uint256\"}]},{\"name\":\"gameParameters\",\"type\":\"tuple\",\"internalType\":\"structOPContractsManagerInteropMigrator.GameParameters\",\"components\":[{\"name\":\"proposer\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"challenger\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"maxGameDepth\",\"type\":\"uint256\",\"internalType\":\"uint256\"},{\"name\":\"splitDepth\",\"type\":\"uint256\",\"internalType\":\"uint256\"},{\"name\":\"initBond\",\"type\":\"uint256\",\"internalType\":\"uint256\"},{\"name\":\"clockExtension\",\"type\":\"uint64\",\"internalType\":\"Duration\"},{\"name\":\"maxClockDuration\",\"type\":\"uint64\",\"internalType\":\"Duration\"}]},{\"name\":\"opChainConfigs\",\"type\":\"tuple[]\",\"internalType\":\"structOPContractsManager.OpChainConfig[]\",\"components\":[{\"name\":\"systemConfigProxy\",\"type\":\"address\",\"internalType\":\"contractISystemConfig\"},{\"name\":\"proxyAdmin\",\"type\":\"address\",\"internalType\":\"contractIProxyAdmin\"},{\"name\":\"absolutePrestate\",\"type\":\"bytes32\",\"internalType\":\"Claim\"}]}]}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"opcmDeployer\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"address\",\"internalType\":\"contractOPContractsManagerDeployer\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"opcmGameTypeAdder\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"address\",\"internalType\":\"contractOPContractsManagerGameTypeAdder\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"opcmInteropMigrator\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"address\",\"internalType\":\"contractOPContractsManagerInteropMigrator\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"opcmStandardValidator\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"address\",\"internalType\":\"contractOPContractsManagerStandardValidator\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"opcmUpgrader\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"address\",\"internalType\":\"contractOPContractsManagerUpgrader\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"protocolVersions\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"address\",\"internalType\":\"contractIProtocolVersions\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"superchainConfig\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"address\",\"internalType\":\"contractISuperchainConfig\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"superchainProxyAdmin\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"address\",\"internalType\":\"contractIProxyAdmin\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"updatePrestate\",\"inputs\":[{\"name\":\"_prestateUpdateInputs\",\"type\":\"tuple[]\",\"internalType\":\"structOPContractsManager.OpChainConfig[]\",\"components\":[{\"name\":\"systemConfigProxy\",\"type\":\"address\",\"internalType\":\"contractISystemConfig\"},{\"name\":\"proxyAdmin\",\"type\":\"address\",\"internalType\":\"contractIProxyAdmin\"},{\"name\":\"absolutePrestate\",\"type\":\"bytes32\",\"internalType\":\"Claim\"}]}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"upgrade\",\"inputs\":[{\"name\":\"_opChainConfigs\",\"type\":\"tuple[]\",\"internalType\":\"structOPContractsManager.OpChainConfig[]\",\"components\":[{\"name\":\"systemConfigProxy\",\"type\":\"address\",\"internalType\":\"contractISystemConfig\"},{\"name\":\"proxyAdmin\",\"type\":\"address\",\"internalType\":\"contractIProxyAdmin\"},{\"name\":\"absolutePrestate\",\"type\":\"bytes32\",\"internalType\":\"Claim\"}]}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"validate\",\"inputs\":[{\"name\":\"_input\",\"type\":\"tuple\",\"internalType\":\"structOPContractsManagerStandardValidator.ValidationInput\",\"components\":[{\"name\":\"proxyAdmin\",\"type\":\"address\",\"internalType\":\"contractIProxyAdmin\"},{\"name\":\"sysCfg\",\"type\":\"address\",\"internalType\":\"contractISystemConfig\"},{\"name\":\"absolutePrestate\",\"type\":\"bytes32\",\"internalType\":\"bytes32\"},{\"name\":\"l2ChainID\",\"type\":\"uint256\",\"internalType\":\"uint256\"}]},{\"name\":\"_allowFailure\",\"type\":\"bool\",\"internalType\":\"bool\"}],\"outputs\":[{\"name\":\"\",\"type\":\"string\",\"internalType\":\"string\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"validateWithOverrides\",\"inputs\":[{\"name\":\"_input\",\"type\":\"tuple\",\"internalType\":\"structOPContractsManagerStandardValidator.ValidationInput\",\"components\":[{\"name\":\"proxyAdmin\",\"type\":\"address\",\"internalType\":\"contractIProxyAdmin\"},{\"name\":\"sysCfg\",\"type\":\"address\",\"internalType\":\"contractISystemConfig\"},{\"name\":\"absolutePrestate\",\"type\":\"bytes32\",\"internalType\":\"bytes32\"},{\"name\":\"l2ChainID\",\"type\":\"uint256\",\"internalType\":\"uint256\"}]},{\"name\":\"_allowFailure\",\"type\":\"bool\",\"internalType\":\"bool\"},{\"name\":\"_overrides\",\"type\":\"tuple\",\"internalType\":\"structOPContractsManagerStandardValidator.ValidationOverrides\",\"components\":[{\"name\":\"l1PAOMultisig\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"challenger\",\"type\":\"address\",\"internalType\":\"address\"}]}],\"outputs\":[{\"name\":\"\",\"type\":\"string\",\"internalType\":\"string\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"version\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"string\",\"internalType\":\"string\"}],\"stateMutability\":\"pure\"},{\"type\":\"error\",\"name\":\"AddressHasNoCode\",\"inputs\":[{\"name\":\"who\",\"type\":\"address\",\"internalType\":\"address\"}]},{\"type\":\"error\",\"name\":\"AddressNotFound\",\"inputs\":[{\"name\":\"who\",\"type\":\"address\",\"internalType\":\"address\"}]},{\"type\":\"error\",\"name\":\"AlreadyReleased\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"InvalidChainId\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"InvalidGameConfigs\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"InvalidRoleAddress\",\"inputs\":[{\"name\":\"role\",\"type\":\"string\",\"internalType\":\"string\"}]},{\"type\":\"error\",\"name\":\"InvalidStartingAnchorRoot\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"LatestReleaseNotSet\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"OnlyDelegatecall\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"PrestateNotSet\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"PrestateRequired\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"SuperchainConfigMismatch\",\"inputs\":[{\"name\":\"systemConfig\",\"type\":\"address\",\"internalType\":\"contractISystemConfig\"}]},{\"type\":\"error\",\"name\":\"SuperchainProxyAdminMismatch\",\"inputs\":[]}]", + Bin: "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", } // OPContractsManagerABI is the input ABI used to generate the binding from. @@ -194,7 +194,7 @@ var OPContractsManagerABI = OPContractsManagerMetaData.ABI var OPContractsManagerBin = OPContractsManagerMetaData.Bin // DeployOPContractsManager deploys a new Ethereum contract, binding an instance of OPContractsManager to it. -func DeployOPContractsManager(auth *bind.TransactOpts, backend bind.ContractBackend, _opcmGameTypeAdder common.Address, _opcmDeployer common.Address, _opcmUpgrader common.Address, _opcmInteropMigrator common.Address, _opcmStandardValidator common.Address, _superchainConfig common.Address, _protocolVersions common.Address, _superchainProxyAdmin common.Address, _upgradeController common.Address) (common.Address, *types.Transaction, *OPContractsManager, error) { +func DeployOPContractsManager(auth *bind.TransactOpts, backend bind.ContractBackend, _opcmGameTypeAdder common.Address, _opcmDeployer common.Address, _opcmUpgrader common.Address, _opcmInteropMigrator common.Address, _opcmStandardValidator common.Address, _superchainConfig common.Address, _protocolVersions common.Address, _superchainProxyAdmin common.Address, _l1PAO common.Address) (common.Address, *types.Transaction, *OPContractsManager, error) { parsed, err := OPContractsManagerMetaData.GetAbi() if err != nil { return common.Address{}, nil, nil, err @@ -203,7 +203,7 @@ func DeployOPContractsManager(auth *bind.TransactOpts, backend bind.ContractBack return common.Address{}, nil, nil, errors.New("GetABI returned nil") } - address, tx, contract, err := bind.DeployContract(auth, *parsed, common.FromHex(OPContractsManagerBin), backend, _opcmGameTypeAdder, _opcmDeployer, _opcmUpgrader, _opcmInteropMigrator, _opcmStandardValidator, _superchainConfig, _protocolVersions, _superchainProxyAdmin, _upgradeController) + address, tx, contract, err := bind.DeployContract(auth, *parsed, common.FromHex(OPContractsManagerBin), backend, _opcmGameTypeAdder, _opcmDeployer, _opcmUpgrader, _opcmInteropMigrator, _opcmStandardValidator, _superchainConfig, _protocolVersions, _superchainProxyAdmin, _l1PAO) if err != nil { return common.Address{}, nil, nil, err } @@ -755,37 +755,6 @@ func (_OPContractsManager *OPContractsManagerCallerSession) SuperchainProxyAdmin return _OPContractsManager.Contract.SuperchainProxyAdmin(&_OPContractsManager.CallOpts) } -// UpgradeController is a free data retrieval call binding the contract method 0x87543ef6. -// -// Solidity: function upgradeController() view returns(address) -func (_OPContractsManager *OPContractsManagerCaller) UpgradeController(opts *bind.CallOpts) (common.Address, error) { - var out []interface{} - err := _OPContractsManager.contract.Call(opts, &out, "upgradeController") - - if err != nil { - return *new(common.Address), err - } - - out0 := *abi.ConvertType(out[0], new(common.Address)).(*common.Address) - - return out0, err - -} - -// UpgradeController is a free data retrieval call binding the contract method 0x87543ef6. -// -// Solidity: function upgradeController() view returns(address) -func (_OPContractsManager *OPContractsManagerSession) UpgradeController() (common.Address, error) { - return _OPContractsManager.Contract.UpgradeController(&_OPContractsManager.CallOpts) -} - -// UpgradeController is a free data retrieval call binding the contract method 0x87543ef6. -// -// Solidity: function upgradeController() view returns(address) -func (_OPContractsManager *OPContractsManagerCallerSession) UpgradeController() (common.Address, error) { - return _OPContractsManager.Contract.UpgradeController(&_OPContractsManager.CallOpts) -} - // Validate is a free data retrieval call binding the contract method 0x30d14888. // // Solidity: function validate((address,address,bytes32,uint256) _input, bool _allowFailure) view returns(string) diff --git a/packages/contracts-bedrock/book/src/contributing/opcm.md b/packages/contracts-bedrock/book/src/contributing/opcm.md index 99148513899..9bd43d623aa 100644 --- a/packages/contracts-bedrock/book/src/contributing/opcm.md +++ b/packages/contracts-bedrock/book/src/contributing/opcm.md @@ -51,8 +51,7 @@ corresponding smart contract release, and upgrading existing chains from one ver smart contract release. Chains that are multiple versions behind must be upgraded in multiple stages across multiple OPCMs. -The OPCM supports upgrading Superchain-wide contracts like `ProtocolVersions` and the `SuperchainConfig`. The OPCM will -perform the upgrade when the user calling the `upgrade` method is also the `UpgradeController`. +The OPCM supports upgrading Superchain-wide contracts like `ProtocolVersions` and the `SuperchainConfig`. ## Usage diff --git a/packages/contracts-bedrock/interfaces/L1/IOPContractsManager.sol b/packages/contracts-bedrock/interfaces/L1/IOPContractsManager.sol index 4ea27faef33..aaffb5972a3 100644 --- a/packages/contracts-bedrock/interfaces/L1/IOPContractsManager.sol +++ b/packages/contracts-bedrock/interfaces/L1/IOPContractsManager.sol @@ -314,8 +314,7 @@ interface IOPContractsManager { IOPContractsManagerStandardValidator _opcmStandardValidator, ISuperchainConfig _superchainConfig, IProtocolVersions _protocolVersions, - IProxyAdmin _superchainProxyAdmin, - address _upgradeController + IProxyAdmin _superchainProxyAdmin ) external; @@ -390,6 +389,4 @@ interface IOPContractsManager { /// @notice Returns the implementation contract addresses. function implementations() external view returns (Implementations memory); - - function upgradeController() external view returns (address); } diff --git a/packages/contracts-bedrock/scripts/deploy/Deploy.s.sol b/packages/contracts-bedrock/scripts/deploy/Deploy.s.sol index ae4d7c3afef..fcf70f61cbb 100644 --- a/packages/contracts-bedrock/scripts/deploy/Deploy.s.sol +++ b/packages/contracts-bedrock/scripts/deploy/Deploy.s.sol @@ -281,7 +281,7 @@ contract Deploy is Deployer { protocolVersionsProxy: IProtocolVersions(artifacts.mustGetAddress("ProtocolVersionsProxy")), superchainConfigProxy: superchainConfigProxy, superchainProxyAdmin: superchainProxyAdmin, - upgradeController: superchainProxyAdmin.owner(), + l1ProxyAdminOwner: superchainProxyAdmin.owner(), challenger: cfg.l2OutputOracleChallenger() }) ); diff --git a/packages/contracts-bedrock/scripts/deploy/DeployImplementations.s.sol b/packages/contracts-bedrock/scripts/deploy/DeployImplementations.s.sol index 48d70e140ef..fef559ef973 100644 --- a/packages/contracts-bedrock/scripts/deploy/DeployImplementations.s.sol +++ b/packages/contracts-bedrock/scripts/deploy/DeployImplementations.s.sol @@ -60,7 +60,7 @@ contract DeployImplementations is Script { ISuperchainConfig superchainConfigProxy; IProtocolVersions protocolVersionsProxy; IProxyAdmin superchainProxyAdmin; - address upgradeController; + address l1ProxyAdminOwner; address challenger; } @@ -205,8 +205,7 @@ contract DeployImplementations is Script { _output.opcmStandardValidator, _input.superchainConfigProxy, _input.protocolVersionsProxy, - _input.superchainProxyAdmin, - _input.upgradeController + _input.superchainProxyAdmin ) ) ); @@ -632,7 +631,7 @@ contract DeployImplementations is Script { ( opcmImplementations, _input.superchainConfigProxy, - _input.upgradeController, // Proxy admin owner + _input.l1ProxyAdminOwner, _input.challenger, _input.withdrawalDelaySeconds, _input.devFeatureBitmap @@ -697,7 +696,7 @@ contract DeployImplementations is Script { require( address(_input.superchainProxyAdmin) != address(0), "DeployImplementations: superchainProxyAdmin not set" ); - require(address(_input.upgradeController) != address(0), "DeployImplementations: upgradeController not set"); + require(address(_input.l1ProxyAdminOwner) != address(0), "DeployImplementations: L1ProxyAdminOwner not set"); } function assertValidOutput(Input memory _input, Output memory _output) private { diff --git a/packages/contracts-bedrock/scripts/deploy/VerifyOPCM.s.sol b/packages/contracts-bedrock/scripts/deploy/VerifyOPCM.s.sol index 39ae8d5eb02..f67fd644849 100644 --- a/packages/contracts-bedrock/scripts/deploy/VerifyOPCM.s.sol +++ b/packages/contracts-bedrock/scripts/deploy/VerifyOPCM.s.sol @@ -147,7 +147,6 @@ contract VerifyOPCM is Script { expectedGetters["protocolVersions"] = "EXPECTED_PROTOCOL_VERSIONS"; expectedGetters["superchainConfig"] = "EXPECTED_SUPERCHAIN_CONFIG"; expectedGetters["superchainProxyAdmin"] = "EXPECTED_SUPERCHAIN_PROXY_ADMIN"; - expectedGetters["upgradeController"] = "EXPECTED_UPGRADE_CONTROLLER"; // Getters for OPCM sub-contracts (addresses verified via bytecode comparison) expectedGetters["opcmDeployer"] = "SKIP"; // Address verified via bytecode comparison diff --git a/packages/contracts-bedrock/snapshots/abi/OPContractsManager.json b/packages/contracts-bedrock/snapshots/abi/OPContractsManager.json index 651f9eb62c7..b9e54537a4d 100644 --- a/packages/contracts-bedrock/snapshots/abi/OPContractsManager.json +++ b/packages/contracts-bedrock/snapshots/abi/OPContractsManager.json @@ -40,11 +40,6 @@ "internalType": "contract IProxyAdmin", "name": "_superchainProxyAdmin", "type": "address" - }, - { - "internalType": "address", - "name": "_upgradeController", - "type": "address" } ], "stateMutability": "nonpayable", @@ -824,19 +819,6 @@ "stateMutability": "nonpayable", "type": "function" }, - { - "inputs": [], - "name": "upgradeController", - "outputs": [ - { - "internalType": "address", - "name": "", - "type": "address" - } - ], - "stateMutability": "view", - "type": "function" - }, { "inputs": [ { diff --git a/packages/contracts-bedrock/snapshots/semver-lock.json b/packages/contracts-bedrock/snapshots/semver-lock.json index 9553fc0033a..366cbca9da7 100644 --- a/packages/contracts-bedrock/snapshots/semver-lock.json +++ b/packages/contracts-bedrock/snapshots/semver-lock.json @@ -20,8 +20,8 @@ "sourceCodeHash": "0xfca613b5d055ffc4c3cbccb0773ddb9030abedc1aa6508c9e2e7727cc0cd617b" }, "src/L1/OPContractsManager.sol:OPContractsManager": { - "initCodeHash": "0xfc9b6327dc3fae8c26ce9d3ae8072b53845f2b8d992bc77a50f04134f0b0a7cc", - "sourceCodeHash": "0xa11523c7a9e71e2acee453e84cc981070881050ae6100aea7453188e0ca48796" + "initCodeHash": "0x9f9a3738b05cae6597ea9a5c5747f7dbd3a5328b05a319955054fbd8b1aaa791", + "sourceCodeHash": "0x154c764083f353e2a56337c0dd5cbcd6f2e12c21966cd0580c7a0f96c4e147dd" }, "src/L1/OPContractsManagerStandardValidator.sol:OPContractsManagerStandardValidator": { "initCodeHash": "0x57d6a6729d887ead009d518e8f17fa0d26bfc97b8efe1494ab4ef8dbb000d109", diff --git a/packages/contracts-bedrock/src/L1/OPContractsManager.sol b/packages/contracts-bedrock/src/L1/OPContractsManager.sol index 8271cfb0de2..142fa67ea35 100644 --- a/packages/contracts-bedrock/src/L1/OPContractsManager.sol +++ b/packages/contracts-bedrock/src/L1/OPContractsManager.sol @@ -1837,9 +1837,9 @@ contract OPContractsManager is ISemver { // -------- Constants and Variables -------- - /// @custom:semver 3.8.0 + /// @custom:semver 4.0.0 function version() public pure virtual returns (string memory) { - return "3.8.0"; + return "4.0.0"; } OPContractsManagerGameTypeAdder public immutable opcmGameTypeAdder; @@ -1865,9 +1865,6 @@ contract OPContractsManager is ISemver { /// which is intended to be DELEGATECALLed. OPContractsManager internal immutable thisOPCM; - /// @notice The address of the upgrade controller. - address public immutable upgradeController; - // -------- Errors -------- /// @notice Thrown when an address is the zero address. @@ -1919,8 +1916,7 @@ contract OPContractsManager is ISemver { OPContractsManagerStandardValidator _opcmStandardValidator, ISuperchainConfig _superchainConfig, IProtocolVersions _protocolVersions, - IProxyAdmin _superchainProxyAdmin, - address _upgradeController + IProxyAdmin _superchainProxyAdmin ) { _opcmDeployer.assertValidContractAddress(address(_superchainConfig)); _opcmDeployer.assertValidContractAddress(address(_protocolVersions)); @@ -1938,7 +1934,6 @@ contract OPContractsManager is ISemver { protocolVersions = _protocolVersions; superchainProxyAdmin = _superchainProxyAdmin; thisOPCM = this; - upgradeController = _upgradeController; } /// @notice Validates the configuration of the L1 contracts. diff --git a/packages/contracts-bedrock/test/L1/OPContractsManager.t.sol b/packages/contracts-bedrock/test/L1/OPContractsManager.t.sol index c0f4065f613..4d2056137fc 100644 --- a/packages/contracts-bedrock/test/L1/OPContractsManager.t.sol +++ b/packages/contracts-bedrock/test/L1/OPContractsManager.t.sol @@ -69,8 +69,7 @@ contract OPContractsManager_Harness is OPContractsManager { OPContractsManagerStandardValidator _opcmStandardValidator, ISuperchainConfig _superchainConfig, IProtocolVersions _protocolVersions, - IProxyAdmin _superchainProxyAdmin, - address _upgradeController + IProxyAdmin _superchainProxyAdmin ) OPContractsManager( _opcmGameTypeAdder, @@ -80,8 +79,7 @@ contract OPContractsManager_Harness is OPContractsManager { _opcmStandardValidator, _superchainConfig, _protocolVersions, - _superchainProxyAdmin, - _upgradeController + _superchainProxyAdmin ) { } @@ -332,7 +330,6 @@ contract OPContractsManager_TestInit is CommonTest { vm.setEnv("EXPECTED_SUPERCHAIN_CONFIG", vm.toString(address(opcm.superchainConfig()))); vm.setEnv("EXPECTED_PROTOCOL_VERSIONS", vm.toString(address(opcm.protocolVersions()))); vm.setEnv("EXPECTED_SUPERCHAIN_PROXY_ADMIN", vm.toString(address(opcm.superchainProxyAdmin()))); - vm.setEnv("EXPECTED_UPGRADE_CONTROLLER", vm.toString(opcm.upgradeController())); } /// @notice Helper function to deploy a new set of L1 contracts via OPCM. @@ -428,7 +425,6 @@ contract OPContractsManager_ChainIdToBatchInboxAddress_Test is Test { ISuperchainConfig superchainConfigProxy = ISuperchainConfig(makeAddr("superchainConfig")); IProtocolVersions protocolVersionsProxy = IProtocolVersions(makeAddr("protocolVersions")); IProxyAdmin superchainProxyAdmin = IProxyAdmin(makeAddr("superchainProxyAdmin")); - address upgradeController = makeAddr("upgradeController"); OPContractsManager.Blueprints memory emptyBlueprints; OPContractsManager.Implementations memory emptyImpls; vm.etch(address(superchainConfigProxy), hex"01"); @@ -453,8 +449,7 @@ contract OPContractsManager_ChainIdToBatchInboxAddress_Test is Test { ), _superchainConfig: superchainConfigProxy, _protocolVersions: protocolVersionsProxy, - _superchainProxyAdmin: superchainProxyAdmin, - _upgradeController: upgradeController + _superchainProxyAdmin: superchainProxyAdmin }); } @@ -1249,7 +1244,6 @@ contract OPContractsManager_Upgrade_Test is OPContractsManager_Upgrade_Harness { vm.setEnv("EXPECTED_SUPERCHAIN_CONFIG", vm.toString(address(opcm.superchainConfig()))); vm.setEnv("EXPECTED_PROTOCOL_VERSIONS", vm.toString(address(opcm.protocolVersions()))); vm.setEnv("EXPECTED_SUPERCHAIN_PROXY_ADMIN", vm.toString(address(opcm.superchainProxyAdmin()))); - vm.setEnv("EXPECTED_UPGRADE_CONTROLLER", vm.toString(opcm.upgradeController())); // Run the upgrade test and checks runCurrentUpgrade(upgrader); diff --git a/packages/contracts-bedrock/test/opcm/DeployImplementations.t.sol b/packages/contracts-bedrock/test/opcm/DeployImplementations.t.sol index 79cc81587f8..c0d2e784864 100644 --- a/packages/contracts-bedrock/test/opcm/DeployImplementations.t.sol +++ b/packages/contracts-bedrock/test/opcm/DeployImplementations.t.sol @@ -33,7 +33,7 @@ contract DeployImplementations_Test is Test { ISuperchainConfig superchainConfigProxy = ISuperchainConfig(makeAddr("superchainConfigProxy")); IProtocolVersions protocolVersionsProxy = IProtocolVersions(makeAddr("protocolVersionsProxy")); IProxyAdmin superchainProxyAdmin = IProxyAdmin(makeAddr("superchainProxyAdmin")); - address upgradeController = makeAddr("upgradeController"); + address l1ProxyAdminOwner = makeAddr("l1ProxyAdminOwner"); address challenger = makeAddr("challenger"); function setUp() public virtual { @@ -157,7 +157,7 @@ contract DeployImplementations_Test is Test { superchainConfigProxy, protocolVersionsProxy, superchainProxyAdmin, - upgradeController, + l1ProxyAdminOwner, challenger ); @@ -319,8 +319,8 @@ contract DeployImplementations_Test is Test { deployImplementations.run(input); input = defaultInput(); - input.upgradeController = address(0); - vm.expectRevert("DeployImplementations: upgradeController not set"); + input.l1ProxyAdminOwner = address(0); + vm.expectRevert("DeployImplementations: L1ProxyAdminOwner not set"); deployImplementations.run(input); } @@ -557,7 +557,7 @@ contract DeployImplementations_Test is Test { superchainConfigProxy, protocolVersionsProxy, superchainProxyAdmin, - upgradeController, + l1ProxyAdminOwner, challenger ); } diff --git a/packages/contracts-bedrock/test/opcm/DeployOPChain.t.sol b/packages/contracts-bedrock/test/opcm/DeployOPChain.t.sol index 4eebfb2863b..7b3753dc8f7 100644 --- a/packages/contracts-bedrock/test/opcm/DeployOPChain.t.sol +++ b/packages/contracts-bedrock/test/opcm/DeployOPChain.t.sol @@ -89,7 +89,7 @@ contract DeployOPChain_TestBase is Test { superchainConfigProxy: dso.superchainConfigProxy, protocolVersionsProxy: dso.protocolVersionsProxy, superchainProxyAdmin: dso.superchainProxyAdmin, - upgradeController: dso.superchainProxyAdmin.owner(), + l1ProxyAdminOwner: dso.superchainProxyAdmin.owner(), challenger: challenger, devFeatureBitmap: bytes32(0) }) diff --git a/packages/contracts-bedrock/test/scripts/VerifyOPCM.t.sol b/packages/contracts-bedrock/test/scripts/VerifyOPCM.t.sol index fd64d07b948..0c355899ddf 100644 --- a/packages/contracts-bedrock/test/scripts/VerifyOPCM.t.sol +++ b/packages/contracts-bedrock/test/scripts/VerifyOPCM.t.sol @@ -419,18 +419,15 @@ contract VerifyOPCM_Run_Test is VerifyOPCM_TestInit { address expectedSuperchainConfig = address(0x1111); address expectedProtocolVersions = address(0x2222); address expectedSuperchainProxyAdmin = address(0x3333); - address expectedUpgradeController = address(0x4444); vm.setEnv("EXPECTED_SUPERCHAIN_CONFIG", vm.toString(expectedSuperchainConfig)); vm.setEnv("EXPECTED_PROTOCOL_VERSIONS", vm.toString(expectedProtocolVersions)); vm.setEnv("EXPECTED_SUPERCHAIN_PROXY_ADMIN", vm.toString(expectedSuperchainProxyAdmin)); - vm.setEnv("EXPECTED_UPGRADE_CONTROLLER", vm.toString(expectedUpgradeController)); // Test that mocking each individual getter causes verification to fail _assertOnOpcmGetter(IOPContractsManager.superchainConfig.selector); _assertOnOpcmGetter(IOPContractsManager.protocolVersions.selector); _assertOnOpcmGetter(IOPContractsManager.superchainProxyAdmin.selector); - _assertOnOpcmGetter(IOPContractsManager.upgradeController.selector); // Reset environment variables to correct values (as set in setUp()) setupEnvVars(); From b69a6bb15719989616eecb3eacf6d59916040d09 Mon Sep 17 00:00:00 2001 From: Ariel Diaz <65925295+aliersh@users.noreply.github.com> Date: Mon, 6 Oct 2025 15:19:12 -0400 Subject: [PATCH 012/117] feat(ci): add manual workflow for AI contracts test maintenance system (#17730) * build(ci): add manual workflow for AI contracts test maintenance system - add ai_contracts_test_dispatch parameter for manual pipeline triggering - add ai-contracts-test job that runs just ai-contracts-test command - add ai-contracts-test-workflow with manual dispatch only - use devin-api context for Devin API credentials - set 60 minute timeout for AI contract test execution * build(ci): store log artifact in AI contracts test workflow - add store_artifacts step to save log.jsonl from test runs * fix: handle socket timeouts in devin API client - add TimeoutError exception handling in _make_request function - update version to 0.3.2 * docs(ci): add runbook reference to AI contracts test job --- .circleci/config.yml | 39 +++++++++++++++++++ ops/ai-eng/contracts-test-maintenance/VERSION | 2 +- .../components/devin-api/devin_client.py | 3 ++ 3 files changed, 43 insertions(+), 1 deletion(-) diff --git a/.circleci/config.yml b/.circleci/config.yml index 7f63bd7a356..786946b5182 100644 --- a/.circleci/config.yml +++ b/.circleci/config.yml @@ -59,6 +59,9 @@ parameters: sync_test_op_node_dispatch: type: boolean default: false + ai_contracts_test_dispatch: + type: boolean + default: false github-event-type: type: string default: "__not_set__" @@ -985,6 +988,28 @@ jobs: - "/root/.cache/go-build" - notify-failures-on-develop + # AI Contracts Test Maintenance System + # Runbook: https://github.com/ethereum-optimism/optimism/blob/develop/ops/ai-eng/contracts-test-maintenance/docs/runbook.md + ai-contracts-test: + circleci_ip_ranges: true + docker: + - image: <> + resource_class: xlarge + steps: + - checkout-from-workspace + - run: + name: Check Python version + command: python3 --version + - run: + name: Run AI Contracts Test System + command: just ai-contracts-test + working_directory: ops/ai-eng + no_output_timeout: 60m + - store_artifacts: + path: ops/ai-eng/contracts-test-maintenance/log.jsonl + destination: log.jsonl + - notify-failures-on-develop + contracts-bedrock-coverage: circleci_ip_ranges: true docker: @@ -3074,3 +3099,17 @@ workflows: context: - circleci-repo-readonly-authenticated-github-token - oplabs-tools-data-public-metrics-bucket + + ai-contracts-test-workflow: + when: + equal: [true, << pipeline.parameters.ai_contracts_test_dispatch >>] + jobs: + - initialize: + context: + - circleci-repo-readonly-authenticated-github-token + - ai-contracts-test: + context: + - circleci-repo-readonly-authenticated-github-token + - devin-api + requires: + - initialize diff --git a/ops/ai-eng/contracts-test-maintenance/VERSION b/ops/ai-eng/contracts-test-maintenance/VERSION index a2268e2de44..d15723fbe8d 100644 --- a/ops/ai-eng/contracts-test-maintenance/VERSION +++ b/ops/ai-eng/contracts-test-maintenance/VERSION @@ -1 +1 @@ -0.3.1 \ No newline at end of file +0.3.2 diff --git a/ops/ai-eng/contracts-test-maintenance/components/devin-api/devin_client.py b/ops/ai-eng/contracts-test-maintenance/components/devin-api/devin_client.py index 8623076e919..d30a716b9b9 100644 --- a/ops/ai-eng/contracts-test-maintenance/components/devin-api/devin_client.py +++ b/ops/ai-eng/contracts-test-maintenance/components/devin-api/devin_client.py @@ -105,6 +105,9 @@ def _make_request(url, headers, data=None, method="GET"): print(f"Request failed: {method} {url}") print(f"Error: {e}") raise + except TimeoutError as e: + print(f"Request timeout - will retry") + return None except Exception as e: print(f"Request failed: {method} {url}") print(f"Error: {e}") From 6036b918480f34745d83004701cc81aec0c627c0 Mon Sep 17 00:00:00 2001 From: Stefano Charissis Date: Tue, 7 Oct 2025 10:09:41 +1100 Subject: [PATCH 013/117] chore(op-acceptance-tests): op-acceptor v3.5.0 (#17739) --- mise.toml | 2 +- op-acceptance-tests/justfile | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/mise.toml b/mise.toml index 6b8d56fd773..09407762323 100644 --- a/mise.toml +++ b/mise.toml @@ -38,7 +38,7 @@ anvil = "1.1.0" codecov-uploader = "0.8.0" goreleaser-pro = "2.11.2" kurtosis = "1.8.1" -op-acceptor = "op-acceptor/v3.4.2" +op-acceptor = "op-acceptor/v3.5.0" # Fake dependencies # Put things here if you need to track versions of tools or projects that can't diff --git a/op-acceptance-tests/justfile b/op-acceptance-tests/justfile index 56ccc773b39..e9a108d337a 100644 --- a/op-acceptance-tests/justfile +++ b/op-acceptance-tests/justfile @@ -1,6 +1,6 @@ REPO_ROOT := `realpath ..` # path to the root of the optimism monorepo KURTOSIS_DIR := REPO_ROOT + "/kurtosis-devnet" -ACCEPTOR_VERSION := env_var_or_default("ACCEPTOR_VERSION", "v3.4.2") +ACCEPTOR_VERSION := env_var_or_default("ACCEPTOR_VERSION", "v3.5.0") DOCKER_REGISTRY := env_var_or_default("DOCKER_REGISTRY", "us-docker.pkg.dev/oplabs-tools-artifacts/images") ACCEPTOR_IMAGE := env_var_or_default("ACCEPTOR_IMAGE", DOCKER_REGISTRY + "/op-acceptor:" + ACCEPTOR_VERSION) From 0848196ba211faa87ed8aea426bb7419c8dd091f Mon Sep 17 00:00:00 2001 From: mbaxter Date: Mon, 6 Oct 2025 20:10:50 -0400 Subject: [PATCH 014/117] Fix cli arg typo in op-challenger executor for op-program server (#17737) --- op-challenger/game/fault/trace/vm/op_program_server_executor.go | 2 +- .../game/fault/trace/vm/op_program_server_executor_test.go | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/op-challenger/game/fault/trace/vm/op_program_server_executor.go b/op-challenger/game/fault/trace/vm/op_program_server_executor.go index c56d3aa4b79..1a5da6b9310 100644 --- a/op-challenger/game/fault/trace/vm/op_program_server_executor.go +++ b/op-challenger/game/fault/trace/vm/op_program_server_executor.go @@ -73,7 +73,7 @@ func (s *OpProgramServerExecutor) OracleCommand(cfg Config, dataDir string, inpu args = append(args, "--l2.custom") } if cfg.L1GenesisPath != "" { - args = append(args, "--l1.config", cfg.L1GenesisPath) + args = append(args, "--l1.chainconfig", cfg.L1GenesisPath) } return args, nil } diff --git a/op-challenger/game/fault/trace/vm/op_program_server_executor_test.go b/op-challenger/game/fault/trace/vm/op_program_server_executor_test.go index 37fa6a26007..473317878c6 100644 --- a/op-challenger/game/fault/trace/vm/op_program_server_executor_test.go +++ b/op-challenger/game/fault/trace/vm/op_program_server_executor_test.go @@ -61,7 +61,7 @@ func TestOpProgramFillHostCommand(t *testing.T) { require.Equal(t, inputs.L1Head.Hex(), pairs["--l1.head"]) require.Equal(t, inputs.L2Claim.Hex(), pairs["--l2.claim"]) require.Equal(t, inputs.L2SequenceNumber.String(), pairs["--l2.blocknumber"]) - require.Equal(t, cfg.L1GenesisPath, pairs["--l1.config"]) + require.Equal(t, cfg.L1GenesisPath, pairs["--l1.chainconfig"]) return pairs } From b9e928ab1cae7fd0b1bbe7f9a9da6b5429fabc9f Mon Sep 17 00:00:00 2001 From: Stefano Charissis Date: Tue, 7 Oct 2025 19:02:07 +1100 Subject: [PATCH 015/117] feat(op-acceptance-tests): flake-shake auto-promotions (#17692) Adds semi-automated promotions to our FlakeShake system, by: - Reviewing the flake-shake results for promotion candidates - Creating a PR for the promotion-ready tests - Notifying us of this on Slack --- .circleci/config.yml | 185 +-- go.mod | 5 + go.sum | 12 + op-acceptance-tests/README.md | 34 +- op-acceptance-tests/acceptance-tests.yaml | 20 +- .../cmd/flake-shake-aggregator/main.go | 124 +- .../cmd/flake-shake-aggregator/main_test.go | 106 ++ .../cmd/flake-shake-promoter/main.go | 1117 +++++++++++++++++ .../cmd/flake-shake-promoter/main_test.go | 112 ++ op-acceptance-tests/cmd/main.go | 5 + op-acceptance-tests/justfile | 23 + .../scripts/ci_flake_shake_calc_iterations.sh | 43 + .../ci_flake_shake_generate_summary.sh | 74 ++ .../scripts/ci_flake_shake_prepare_slack.sh | 85 ++ .../tests/base/dummy_flaky_test.go | 27 + 15 files changed, 1854 insertions(+), 118 deletions(-) create mode 100644 op-acceptance-tests/cmd/flake-shake-aggregator/main_test.go create mode 100644 op-acceptance-tests/cmd/flake-shake-promoter/main.go create mode 100644 op-acceptance-tests/cmd/flake-shake-promoter/main_test.go create mode 100644 op-acceptance-tests/scripts/ci_flake_shake_calc_iterations.sh create mode 100644 op-acceptance-tests/scripts/ci_flake_shake_generate_summary.sh create mode 100644 op-acceptance-tests/scripts/ci_flake_shake_prepare_slack.sh create mode 100644 op-acceptance-tests/tests/base/dummy_flaky_test.go diff --git a/.circleci/config.yml b/.circleci/config.yml index 786946b5182..557385d223a 100644 --- a/.circleci/config.yml +++ b/.circleci/config.yml @@ -87,7 +87,7 @@ parameters: orbs: go: circleci/go@1.8.0 gcp-cli: circleci/gcp-cli@3.0.1 - slack: circleci/slack@5.1.1 + slack: circleci/slack@6.0.0 shellcheck: circleci/shellcheck@3.2.0 codecov: codecov/codecov@5.0.3 utils: ethereum-optimism/circleci-utils@1.0.20 @@ -356,6 +356,11 @@ jobs: resource_class: <<# parameters.use_circleci_runner >>xlarge<><<^ parameters.use_circleci_runner >>ethereum-optimism/latitude-1<> steps: - checkout-from-workspace + - run: + name: Lint/Vet/Build op-acceptance-tests/cmd + working_directory: op-acceptance-tests + command: | + just cmd-check - run: name: Setup Kurtosis command: | @@ -1454,6 +1459,11 @@ jobs: name: Download Go dependencies working_directory: op-acceptance-tests command: go mod download + - run: + name: Lint/Vet/Build op-acceptance-tests/cmd + working_directory: op-acceptance-tests + command: | + just cmd-check # Persist schedule name into env var - run: name: Persist schedule name into env var @@ -1550,6 +1560,11 @@ jobs: name: Download Go dependencies working_directory: op-acceptance-tests command: go mod download + - run: + name: Lint/Vet/Build op-acceptance-tests/cmd + working_directory: op-acceptance-tests + command: | + just cmd-check # Prepare the test environment - run: name: Prepare test environment (compile tests and cache build results) @@ -1635,28 +1650,15 @@ jobs: name: Download Go dependencies working_directory: op-acceptance-tests command: go mod download + - run: + name: Lint/Vet/Build op-acceptance-tests/cmd + working_directory: op-acceptance-tests + command: | + just cmd-check - run: name: Calculate iterations for worker command: | - # Get total iterations and worker info from CircleCI parallelism - TOTAL_ITER=<< pipeline.parameters.flake-shake-iterations >> - WORKERS=${CIRCLE_NODE_TOTAL} - WORKER_ID=$((CIRCLE_NODE_INDEX + 1)) - - # Calculate how many iterations each worker should run - ITER_PER_WORKER=$((TOTAL_ITER / WORKERS)) - REMAINDER=$((TOTAL_ITER % WORKERS)) - - # Distribute the remainder (first $REMAINDER workers get one extra iteration) - if [ $WORKER_ID -le $REMAINDER ]; then - ITER_COUNT=$((ITER_PER_WORKER + 1)) - else - ITER_COUNT=$ITER_PER_WORKER - fi - - echo "Worker $WORKER_ID running $ITER_COUNT of $TOTAL_ITER iterations" - echo "export FLAKE_SHAKE_ITERATIONS=$ITER_COUNT" >> $BASH_ENV - echo "export FLAKE_SHAKE_WORKER_ID=$WORKER_ID" >> $BASH_ENV + bash ./op-acceptance-tests/scripts/ci_flake_shake_calc_iterations.sh << pipeline.parameters.flake-shake-iterations >> - run: name: Run flake-shake iterations no_output_timeout: 2h @@ -1664,7 +1666,6 @@ jobs: command: | OUTPUT_DIR="logs/flake-shake-results-worker-${FLAKE_SHAKE_WORKER_ID}" mkdir -p "$OUTPUT_DIR" - op-acceptor \ --validators ./acceptance-tests.yaml \ --gate << parameters.gate >> \ @@ -1689,6 +1690,11 @@ jobs: - checkout-from-workspace - attach_workspace: at: . + - run: + name: Lint/Vet/Build op-acceptance-tests/cmd + working_directory: op-acceptance-tests + command: | + just cmd-check - run: name: Build flake-shake aggregator working_directory: op-acceptance-tests @@ -1706,67 +1712,84 @@ jobs: - run: name: Generate summary command: | - if [ -f final-report/flake-shake-report.json ]; then - echo "=== Flake-Shake Results ===" - STABLE=$(jq '[.tests[] | select(.recommendation == "STABLE")] | length' final-report/flake-shake-report.json) - UNSTABLE=$(jq '[.tests[] | select(.recommendation == "UNSTABLE")] | length' final-report/flake-shake-report.json) - echo "✅ STABLE: $STABLE tests" - echo "⚠️ UNSTABLE: $UNSTABLE tests" - if [ "$UNSTABLE" -gt 0 ]; then - echo "Unstable tests:" - jq -r '.tests[] | select(.recommendation == "UNSTABLE") | " - \(.test_name) (\(.pass_rate)%)"' final-report/flake-shake-report.json - fi - # Write daily summary (include stable and unstable tests) - jq '{date, gate, total_runs, iterations, - totals: { - stable: ([.tests[] | select(.recommendation=="STABLE")] | length), - unstable: ([.tests[] | select(.recommendation=="UNSTABLE")] | length) - }, - stable_tests: [ - .tests[] | select(.recommendation=="STABLE") | - {test_name, package, total_runs, pass_rate} - ], - unstable_tests: [ - .tests[] | select(.recommendation=="UNSTABLE") | - {test_name, package, total_runs, passes, failures, pass_rate} - ] - }' final-report/flake-shake-report.json > final-report/daily-summary.json - - # Write promotion readiness (100% pass) - jq '{ready: [.tests[] | select(.recommendation=="STABLE") | {test_name, package, total_runs, pass_rate, avg_duration, min_duration, max_duration}]}' final-report/flake-shake-report.json > final-report/promotion-ready.json - - # Export UNSTABLE_COUNT for later steps - echo "export UNSTABLE_COUNT=$UNSTABLE" >> $BASH_ENV - else - echo "ERROR: No report found" - exit 1 + bash ./op-acceptance-tests/scripts/ci_flake_shake_generate_summary.sh final-report/flake-shake-report.json final-report + - store_artifacts: + path: ./final-report + destination: flake-shake-report + + op-acceptance-tests-flake-shake-promote: + machine: + image: ubuntu-2404:current + resource_class: large + steps: + - checkout-from-workspace + - run: + name: Lint/Vet/Build op-acceptance-tests/cmd + working_directory: op-acceptance-tests + command: | + just cmd-check + - run: + name: Build flake-shake promoter + working_directory: op-acceptance-tests + command: | + go mod download + go build -o ../flake-shake-promoter ./cmd/flake-shake-promoter/main.go + - run: + name: Set GH_TOKEN + command: | + if [ -n "${GITHUB_TOKEN_GOVERNANCE:-}" ]; then + echo "export GH_TOKEN=${GITHUB_TOKEN_GOVERNANCE}" >> "$BASH_ENV" fi - run: - name: Prepare Discord owner mentions + name: Validate GH_TOKEN is present command: | - # Build owner mentions for unstable tests - OWNERS_FILE=$(mktemp) - # Iterate over unstable tests and resolve owners from YAML metadata - jq -r '.tests[] | select(.recommendation=="UNSTABLE") | [.package, .test_name] | @tsv' final-report/flake-shake-report.json | while IFS=$'\t' read -r PKG NAME; do - OWNER=$(yq -r \ - ".gates[] | select(.id==\"flake-shake\") | .tests[] | select(.package==\"${PKG}\" and ((.name // \"\")==\"${NAME}\")) | (.metadata.owner // \"\")" \ - op-acceptance-tests/acceptance-tests.yaml) - if [ -n "$OWNER" ]; then echo "$OWNER" >> "$OWNERS_FILE"; fi - done - if [ -s "$OWNERS_FILE" ]; then - # unique list and prefix with @ for readability - OWNERS=$(sort -u "$OWNERS_FILE" | sed 's/^/@/') - echo "Resolved owners:" $OWNERS - echo "export EXTRA_DISCORD_MENTIONS=\"$OWNERS\"" >> $BASH_ENV - else - echo "No owners resolved" + if [ -z "${GH_TOKEN:-}" ]; then + echo "GH_TOKEN is required for PR creation" >&2 + exit 1 fi - - discord-notification-failures-on-develop: - message: "Flake-Shake report is ready. See artifacts for details." - mentions: "$EXTRA_DISCORD_MENTIONS" + - run: + name: Run flake-shake promoter + command: | + ./flake-shake-promoter \ + --org ethereum-optimism \ + --repo optimism \ + --branch "<< pipeline.git.branch >>" \ + --workflow scheduled-flake-shake \ + --report-job op-acceptance-tests-flake-shake-report \ + --days 3 \ + --gate flake-shake \ + --min-runs 300 \ + --max-failure-rate 0.01 \ + --min-age-days 3 \ + --dry-run=false \ + --require-clean-24h \ + --out ./final-promotion \ + --verbose - store_artifacts: - path: ./final-report - destination: flake-shake-report + path: ./final-promotion + destination: flake-shake-promotion + - run: + name: Prepare Slack message (promotion candidates) + command: | + bash ./op-acceptance-tests/scripts/ci_flake_shake_prepare_slack.sh ./final-promotion/promotion-ready.json + - run: + name: Slack - Sending Notification + command: | + set -euo pipefail + # The Slack orb conditionals evaluate at compile time; guard at runtime instead. + if [ -z "${SLACK_BLOCKS_PAYLOAD:-}" ] || [ "${SLACK_BLOCKS_PAYLOAD}" = "[]" ]; then + echo "SLACK_BLOCKS is empty or doesn't exist. Skipping it..." + exit 0 + fi + echo "$SLACK_BLOCKS_PAYLOAD" | jq '.' > /tmp/blocks.json + jq -c '{blocks: .}' /tmp/blocks.json > /tmp/slack_template.json + echo 'export SLACK_TEMPLATE=$(cat /tmp/slack_template.json)' >> $BASH_ENV + - slack/notify: + channel: notify-ci-failures + event: always + retries: 1 + retry_delay: 3 + template: SLACK_TEMPLATE sanitize-op-program: docker: @@ -2953,6 +2976,14 @@ workflows: - op-acceptance-tests-flake-shake-report: requires: - op-acceptance-tests-flake-shake + - op-acceptance-tests-flake-shake-promote: + requires: + - op-acceptance-tests-flake-shake-report + context: + - circleci-repo-readonly-authenticated-github-token + - circleci-repo-optimism + - circleci-api-token + - slack scheduled-preimage-reproducibility: when: diff --git a/go.mod b/go.mod index ebca09f917c..a445f5c01e3 100644 --- a/go.mod +++ b/go.mod @@ -28,6 +28,7 @@ require ( github.com/go-task/slim-sprig/v3 v3.0.0 github.com/golang/snappy v0.0.5-0.20220116011046-fa5810519dcb github.com/google/go-cmp v0.7.0 + github.com/google/go-github/v55 v55.0.0 github.com/google/gofuzz v1.2.1-0.20220503160820-4a35382e8fc8 github.com/google/uuid v1.6.0 github.com/gorilla/websocket v1.5.3 @@ -67,6 +68,7 @@ require ( golang.org/x/crypto v0.36.0 golang.org/x/exp v0.0.0-20241009180824-f66d83c29e7c golang.org/x/mod v0.22.0 + golang.org/x/oauth2 v0.25.0 golang.org/x/sync v0.14.0 golang.org/x/term v0.30.0 golang.org/x/text v0.25.0 @@ -82,6 +84,7 @@ require ( git.sr.ht/~sbinet/gg v0.6.0 // indirect github.com/DataDog/zstd v1.5.6-0.20230824185856-869dae002e5e // indirect github.com/Microsoft/go-winio v0.6.2 // indirect + github.com/ProtonMail/go-crypto v0.0.0-20230217124315-7d5c6f04bbb8 // indirect github.com/VictoriaMetrics/fastcache v1.12.2 // indirect github.com/adrg/xdg v0.4.0 // indirect github.com/ajstarks/svgo v0.0.0-20211024235047-1546f124cd8b // indirect @@ -97,6 +100,7 @@ require ( github.com/campoy/embedmd v1.0.0 // indirect github.com/cenkalti/backoff/v4 v4.3.0 // indirect github.com/cespare/xxhash/v2 v2.3.0 // indirect + github.com/cloudflare/circl v1.3.3 // indirect github.com/cockroachdb/errors v1.11.3 // indirect github.com/cockroachdb/fifo v0.0.0-20240606204812-0bbfbd93a7ce // indirect github.com/cockroachdb/logtags v0.0.0-20230118201751-21c54148d20b // indirect @@ -144,6 +148,7 @@ require ( github.com/gogo/protobuf v1.3.2 // indirect github.com/golang-jwt/jwt/v4 v4.5.2 // indirect github.com/golang/freetype v0.0.0-20170609003504-e2365dfdc4a0 // indirect + github.com/google/go-querystring v1.1.0 // indirect github.com/google/gopacket v1.1.19 // indirect github.com/google/pprof v0.0.0-20241009165004-a3522334989c // indirect github.com/graph-gophers/graphql-go v1.3.0 // indirect diff --git a/go.sum b/go.sum index e97993661bc..49a8082e08b 100644 --- a/go.sum +++ b/go.sum @@ -37,6 +37,8 @@ github.com/Masterminds/semver/v3 v3.3.1/go.mod h1:4V+yj/TJE1HU9XfppCwVMZq3I84lpr github.com/Microsoft/go-winio v0.6.2 h1:F2VQgta7ecxGYO8k3ZZz3RS8fVIXVxONVUPlNERoyfY= github.com/Microsoft/go-winio v0.6.2/go.mod h1:yd8OoFMLzJbo9gZq8j5qaps8bJ9aShtEA8Ipt1oGCvU= github.com/OneOfOne/xxhash v1.2.2/go.mod h1:HSdplMjZKSmBqAxg5vPj2TmRDmfkzw+cTzAElWljhcU= +github.com/ProtonMail/go-crypto v0.0.0-20230217124315-7d5c6f04bbb8 h1:wPbRQzjjwFc0ih8puEVAOFGELsn1zoIIYdxvML7mDxA= +github.com/ProtonMail/go-crypto v0.0.0-20230217124315-7d5c6f04bbb8/go.mod h1:I0gYDMZ6Z5GRU7l58bNFSkPTFN6Yl12dsUlAZ8xy98g= github.com/VictoriaMetrics/fastcache v1.12.2 h1:N0y9ASrJ0F6h0QaC3o6uJb3NIZ9VKLjCM7NQbSmF7WI= github.com/VictoriaMetrics/fastcache v1.12.2/go.mod h1:AmC+Nzz1+3G2eCPapF6UcsnkThDcMsQicp4xDukwJYI= github.com/adrg/xdg v0.4.0 h1:RzRqFcjH4nE5C6oTAxhBtoE2IRyjBSa62SCbyPidvls= @@ -106,6 +108,7 @@ github.com/btcsuite/snappy-go v1.0.0/go.mod h1:8woku9dyThutzjeg+3xrA5iCpBRH8XEEg github.com/btcsuite/websocket v0.0.0-20150119174127-31079b680792/go.mod h1:ghJtEyQwv5/p4Mg4C0fgbePVuGr935/5ddU9Z3TmDRY= github.com/btcsuite/winsvc v1.0.0/go.mod h1:jsenWakMcC0zFBFurPLEAyrnc/teJEM1O46fmI40EZs= github.com/buger/jsonparser v0.0.0-20181115193947-bf1c66bbce23/go.mod h1:bbYlZJ7hK1yFx9hf58LP0zeX7UjIGs20ufpu3evjr+s= +github.com/bwesterb/go-ristretto v1.2.0/go.mod h1:fUIoIZaG73pV5biE2Blr2xEzDoMj7NFEuV9ekS419A0= github.com/campoy/embedmd v1.0.0 h1:V4kI2qTJJLf4J29RzI/MAt2c3Bl4dQSYPuflzwFH2hY= github.com/campoy/embedmd v1.0.0/go.mod h1:oxyr9RCiSXg0M3VJ3ks0UGfp98BpSSGr0kpiX3MzVl8= github.com/cenkalti/backoff/v4 v4.3.0 h1:MyRJ/UdXutAwSAT+s3wNd7MfTIcy71VQueUuFK343L8= @@ -136,6 +139,9 @@ github.com/cilium/ebpf v0.2.0/go.mod h1:To2CFviqOWL/M0gIMsvSMlqe7em/l1ALkX1PyjrX github.com/circonus-labs/circonus-gometrics v2.3.1+incompatible/go.mod h1:nmEj6Dob7S7YxXgwXpfOuvO54S+tGdZdw9fuRZt25Ag= github.com/circonus-labs/circonusllhist v0.1.3/go.mod h1:kMXHVDlOchFAehlya5ePtbp5jckzBHf4XRpQvBOLI+I= github.com/client9/misspell v0.3.4/go.mod h1:qj6jICC3Q7zFZvVWo7KLAzC3yx5G7kyvSDkc90ppPyw= +github.com/cloudflare/circl v1.1.0/go.mod h1:prBCrKB9DV4poKZY1l9zBXg2QJY7mvgRvtMxxK7fi4I= +github.com/cloudflare/circl v1.3.3 h1:fE/Qz0QdIGqeWfnwq0RE0R7MI51s0M2E4Ga9kq5AEMs= +github.com/cloudflare/circl v1.3.3/go.mod h1:5XYMA4rFBvNIrhs50XuiBJ15vF2pZn4nnUKZrLbUZFA= github.com/cockroachdb/datadriven v1.0.3-0.20230413201302-be42291fc80f h1:otljaYPt5hWxV3MUfO5dFPFiOXg9CyG5/kCfayTqsJ4= github.com/cockroachdb/datadriven v1.0.3-0.20230413201302-be42291fc80f/go.mod h1:a9RdTaap04u637JoCzcUoIcDmvwSUtcUFtT/C3kJlTU= github.com/cockroachdb/errors v1.11.3 h1:5bA+k2Y6r+oz/6Z/RFlNeVCesGARKuC6YymtcDrbC/I= @@ -355,7 +361,11 @@ github.com/google/go-cmp v0.6.0/go.mod h1:17dUlkBOakJ0+DkrSSNjCkIjxS6bF9zb3elmeN github.com/google/go-cmp v0.7.0 h1:wk8382ETsv4JYUZwIsn6YpYiWiBsYLSJiTsyBybVuN8= github.com/google/go-cmp v0.7.0/go.mod h1:pXiqmnSA92OHEEa9HXL2W4E7lf9JzCmGVUdgjX3N/iU= github.com/google/go-github v17.0.0+incompatible/go.mod h1:zLgOLi98H3fifZn+44m+umXrS52loVEgC2AApnigrVQ= +github.com/google/go-github/v55 v55.0.0 h1:4pp/1tNMB9X/LuAhs5i0KQAE40NmiR/y6prLNb9x9cg= +github.com/google/go-github/v55 v55.0.0/go.mod h1:JLahOTA1DnXzhxEymmFF5PP2tSS9JVNj68mSZNDwskA= github.com/google/go-querystring v1.0.0/go.mod h1:odCYkC5MyYFN7vkCjXpyrEuKhc/BUO6wN/zVPAxq5ck= +github.com/google/go-querystring v1.1.0 h1:AnCroh3fv4ZBgVIf1Iwtovgjaw/GiKJo8M8yD/fhyJ8= +github.com/google/go-querystring v1.1.0/go.mod h1:Kcdr2DB4koayq7X8pmAG4sNG59So17icRSOU623lUBU= github.com/google/gofuzz v1.0.0/go.mod h1:dBl0BpW6vV/+mYPU4Po3pmUjxk6FQPldtuIdl/M65Eg= github.com/google/gofuzz v1.2.1-0.20220503160820-4a35382e8fc8 h1:Ep/joEub9YwcjRY6ND3+Y/w0ncE540RtGatVhtZL0/Q= github.com/google/gofuzz v1.2.1-0.20220503160820-4a35382e8fc8/go.mod h1:dBl0BpW6vV/+mYPU4Po3pmUjxk6FQPldtuIdl/M65Eg= @@ -1056,6 +1066,8 @@ golang.org/x/oauth2 v0.0.0-20180821212333-d2e6202438be/go.mod h1:N/0e6XlmueqKjAG golang.org/x/oauth2 v0.0.0-20181017192945-9dcd33a902f4/go.mod h1:N/0e6XlmueqKjAGxoOufVs8QHGRruUQn6yWY3a++T0U= golang.org/x/oauth2 v0.0.0-20181203162652-d668ce993890/go.mod h1:N/0e6XlmueqKjAGxoOufVs8QHGRruUQn6yWY3a++T0U= golang.org/x/oauth2 v0.0.0-20190226205417-e64efc72b421/go.mod h1:gOpvHmFTYa4IltrdGE7lF6nIHvwfUNPOp7c8zoXwtLw= +golang.org/x/oauth2 v0.25.0 h1:CY4y7XT9v0cRI9oupztF8AgiIu99L/ksR/Xp/6jrZ70= +golang.org/x/oauth2 v0.25.0/go.mod h1:XYTD2NtWslqkgxebSiOHnXEap4TF09sJSc7H1sXbhtI= golang.org/x/perf v0.0.0-20180704124530-6e6d33e29852/go.mod h1:JLpeXjPJfIyPr5TlbXLkXWLhP8nz10XfvxElABhCtcw= golang.org/x/sync v0.0.0-20180314180146-1d60e4601c6f/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= golang.org/x/sync v0.0.0-20181108010431-42b317875d0f/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= diff --git a/op-acceptance-tests/README.md b/op-acceptance-tests/README.md index 2d541c013a3..3b81565d398 100644 --- a/op-acceptance-tests/README.md +++ b/op-acceptance-tests/README.md @@ -212,21 +212,14 @@ gates: tests: - package: github.com/ethereum-optimism/optimism/op-acceptance-tests/tests/yourtest timeout: 10m - metadata: - target_gate: base # Where to promote once stable + metatada: + owner: stefano ``` ### Understanding Reports -Flake-shake generates comprehensive reports in two formats: -- **`flake-shake-report.json`**: Machine-readable results for automation -- **`flake-shake-report.html`**: Human-friendly visualization with charts - -Reports include: -- **Pass rate**: Percentage of successful runs per test -- **Timing statistics**: Min/avg/max execution duration -- **Failure patterns**: First few failure logs for debugging -- **Stability recommendation**: STABLE or UNSTABLE classification +Flake-shake stores a daily summary artifact per run: +- **`final-report/daily-summary.json`**: Aggregated counts of stable/unstable tests and per-test pass/fail tallies. ### CI Integration @@ -235,6 +228,25 @@ In CI, flake-shake runs tests across multiple parallel workers: - Results are aggregated using the `flake-shake-aggregator` tool - Reports are stored as CircleCI artifacts +### Automated Promotion (Promoter CLI) + +We provide a small CLI that aggregates the last N daily summaries from CircleCI and proposes YAML edits to promote stable tests out of the `flake-shake` gate: + +```bash +export CIRCLE_API_TOKEN=... # CircleCI API token (read artifacts) +go build -o ./op-acceptance-tests/flake-shake-promoter ./op-acceptance-tests/cmd/flake-shake-promoter/main.go +./op-acceptance-tests/flake-shake-promoter \ + --org ethereum-optimism --repo optimism --branch develop \ + --workflow scheduled-flake-shake --report-job op-acceptance-tests-flake-shake-report \ + --days 3 --gate flake-shake --min-runs 300 --max-failure-rate 0.01 --min-age-days 3 \ + --out ./final-promotion --dry-run +``` + +Outputs written to `--out`: +- `aggregate.json`: Per-test aggregated totals across days +- `promotion-ready.json`: Candidates and skip reasons +- `promotion.yaml`: Proposed edits to `op-acceptance-tests/acceptance-tests.yaml` + ### Promotion Criteria Tests should remain in flake-shake until they demonstrate consistent stability: diff --git a/op-acceptance-tests/acceptance-tests.yaml b/op-acceptance-tests/acceptance-tests.yaml index a0e1cfc5864..97d0f078858 100644 --- a/op-acceptance-tests/acceptance-tests.yaml +++ b/op-acceptance-tests/acceptance-tests.yaml @@ -5,36 +5,38 @@ # base gate as well as any earlier fork gates. gates: - # New tests should be added here first with target_gate metadata. - # Once we're confident they're not flaky, they will be promoted. + # New tests should be added here first with an owner metadata. + # Once we're confident they're not flaky, a PR will be automatically created to remove them from this gate. # Example entry format: # - package: github.com/ethereum-optimism/optimism/op-acceptance-tests/tests/parallelism # timeout: 10m # metadata: - # target_gate: base # Will be promoted to base gate once stable - # added_date: "2025-01-23" # owner: "team-infra" - id: flake-shake description: "Quarantine gate for new and potentially flaky tests requiring stability validation." tests: - - package: github.com/ethereum-optimism/optimism/op-acceptance-tests/tests/sync_tester/sync_tester_elsync - name: TestSyncTesterELSync + - package: github.com/ethereum-optimism/optimism/op-acceptance-tests/tests/sync_tester/sync_tester_hfs_ext + name: TestSyncTesterHFS_Isthmus_ELSync timeout: 10m metadata: - target_gate: sync-test-op-node owner: "changwan,anton" - package: github.com/ethereum-optimism/optimism/op-acceptance-tests/tests/jovian name: TestMinBaseFee timeout: 10m metadata: - target_gate: jovian owner: "george" - package: github.com/ethereum-optimism/optimism/op-acceptance-tests/tests/base/withdrawal name: TestWithdrawal timeout: 10m metadata: - target_gate: base owner: "stefano" + - package: github.com/ethereum-optimism/optimism/op-acceptance-tests/tests/base + name: TestDummyFlakyTest + timeout: 10m + metadata: + owner: "stefano" + - package: github.com/ethereum-optimism/optimism/op-acceptance-tests/tests/osaka + owner: "josh" - id: isthmus description: "Isthmus network tests." diff --git a/op-acceptance-tests/cmd/flake-shake-aggregator/main.go b/op-acceptance-tests/cmd/flake-shake-aggregator/main.go index 4a677edadab..98f5861a68b 100644 --- a/op-acceptance-tests/cmd/flake-shake-aggregator/main.go +++ b/op-acceptance-tests/cmd/flake-shake-aggregator/main.go @@ -3,12 +3,15 @@ package main import ( + "crypto/sha256" "encoding/json" "flag" "fmt" html_pkg "html" + "log" "os" "path/filepath" + "regexp" "strings" "time" ) @@ -78,6 +81,7 @@ func main() { } func run(inputPattern, outputDir string, verbose bool) error { + logger := log.New(os.Stdout, "[flake-shake-aggregator] ", log.LstdFlags) // Create output directory if err := os.MkdirAll(outputDir, 0755); err != nil { return fmt.Errorf("failed to create output directory: %w", err) @@ -109,9 +113,9 @@ func run(inputPattern, outputDir string, verbose bool) error { } if verbose { - fmt.Printf("Found %d report files to aggregate:\n", len(reportFiles)) + logger.Printf("Found %d report files to aggregate:", len(reportFiles)) for _, f := range reportFiles { - fmt.Printf(" - %s\n", f) + logger.Printf(" - %s", f) } } @@ -123,18 +127,18 @@ func run(inputPattern, outputDir string, verbose bool) error { for _, reportFile := range reportFiles { if verbose { - fmt.Printf("Processing %s...\n", reportFile) + logger.Printf("Processing %s...", reportFile) } data, err := os.ReadFile(reportFile) if err != nil { - fmt.Printf("Warning: failed to read %s: %v\n", reportFile, err) + logger.Printf("Warning: failed to read %s: %v", reportFile, err) continue } var report FlakeShakeReport if err := json.Unmarshal(data, &report); err != nil { - fmt.Printf("Warning: failed to parse %s: %v\n", reportFile, err) + logger.Printf("Warning: failed to parse %s: %v", reportFile, err) continue } @@ -168,10 +172,10 @@ func run(inputPattern, outputDir string, verbose bool) error { stats.durationSum += time.Duration(test.AvgDuration) * time.Duration(test.TotalRuns) stats.durationCount += test.TotalRuns - // Merge failure logs (keep first 10) + // Merge failure logs (keep first 50) stats.FailureLogs = append(stats.FailureLogs, test.FailureLogs...) - if len(stats.FailureLogs) > 10 { - stats.FailureLogs = stats.FailureLogs[:10] + if len(stats.FailureLogs) > 50 { + stats.FailureLogs = stats.FailureLogs[:50] } // Update last failure time @@ -268,13 +272,13 @@ func run(inputPattern, outputDir string, verbose bool) error { return fmt.Errorf("failed to write HTML report: %w", err) } - fmt.Printf("✅ Aggregation complete!\n") - fmt.Printf(" - Processed %d worker reports\n", len(reportFiles)) - fmt.Printf(" - Aggregated %d unique tests\n", len(finalTests)) - fmt.Printf(" - Total iterations: %d\n", totalIterations) - fmt.Printf(" - Reports saved to:\n") - fmt.Printf(" • %s\n", jsonFile) - fmt.Printf(" • %s\n", htmlFile) + logger.Printf("✅ Aggregation complete!") + logger.Printf(" - Processed %d worker reports", len(reportFiles)) + logger.Printf(" - Aggregated %d unique tests", len(finalTests)) + logger.Printf(" - Total iterations: %d", totalIterations) + logger.Printf(" - Reports saved to:") + logger.Printf(" • %s", jsonFile) + logger.Printf(" • %s", htmlFile) // Print summary statistics stableCount := 0 @@ -287,22 +291,22 @@ func run(inputPattern, outputDir string, verbose bool) error { } } - fmt.Printf("\n📊 Test Stability Summary:\n") + logger.Printf("\n📊 Test Stability Summary:") if len(finalTests) > 0 { - fmt.Printf(" - STABLE: %d tests (%.1f%%)\n", stableCount, + logger.Printf(" - STABLE: %d tests (%.1f%%)", stableCount, float64(stableCount)/float64(len(finalTests))*100) - fmt.Printf(" - UNSTABLE: %d tests (%.1f%%)\n", unstableCount, + logger.Printf(" - UNSTABLE: %d tests (%.1f%%)", unstableCount, float64(unstableCount)/float64(len(finalTests))*100) } else { - fmt.Printf(" - No tests found\n") + logger.Printf(" - No tests found") } // List unstable tests if any if unstableCount > 0 && verbose { - fmt.Printf("\n⚠️ Unstable tests:\n") + logger.Printf("\n⚠️ Unstable tests:") for _, test := range finalTests { if test.Recommendation == "UNSTABLE" { - fmt.Printf(" - %s (%.1f%% pass rate)\n", + logger.Printf(" - %s (%.1f%% pass rate)", strings.TrimPrefix(test.TestName, test.Package+"::"), test.PassRate) } @@ -450,6 +454,84 @@ func generateHTMLReport(report *FlakeShakeReport) string { html.WriteString(` +`) + + // Append grouped failure details + html.WriteString(` +

Failure Details

+`) + + normalizer := regexp.MustCompile(`(?m)^\s*\[?\d{4}-\d{2}-\d{2}.*$|\bt=\d{4}-\d{2}-\d{2}.*$|\b(duration|elapsed|took)[:=].*$`) + classify := func(s string) string { + ls := strings.ToLower(s) + switch { + case strings.Contains(ls, "context deadline exceeded"): + return "context deadline" + case strings.Contains(ls, "deadline exceeded"): + return "deadline exceeded" + case strings.Contains(ls, "timeout"): + return "timeout" + case strings.Contains(ls, "connection refused"): + return "connection refused" + case strings.Contains(ls, "connection reset"): + return "connection reset" + case strings.Contains(ls, "rpc error") || strings.Contains(ls, "rpc call failed"): + return "rpc error" + case strings.Contains(ls, "assert") || strings.Contains(ls, "require"): + return "assertion" + default: + return "unknown" + } + } + for _, test := range report.Tests { + if len(test.FailureLogs) == 0 { + continue + } + html.WriteString(fmt.Sprintf(`
%s — %s (failures: %d)`, + html_pkg.EscapeString(test.TestName), html_pkg.EscapeString(test.Package), test.Failures)) + + groups := map[string]struct { + Count int + Sample string + Type string + }{} + typeSummary := map[string]int{} + for _, raw := range test.FailureLogs { + norm := normalizer.ReplaceAllString(raw, "") + norm = strings.TrimSpace(norm) + sum := sha256.Sum256([]byte(norm)) + key := fmt.Sprintf("%x", sum[:]) + g := groups[key] + if g.Count == 0 { + g.Sample = norm + g.Type = classify(norm) + } + g.Count++ + groups[key] = g + } + // Build type summary + for _, g := range groups { + typeSummary[g.Type] += g.Count + } + // Render summary + html.WriteString(`
`) + html.WriteString(`Summary:
    `) + for t, c := range typeSummary { + html.WriteString(fmt.Sprintf(`
  • %s: %d
    • `, html_pkg.EscapeString(t), c)) + } + html.WriteString(`
`) + // Render groups + for _, g := range groups { + html.WriteString(`
`) + html.WriteString(fmt.Sprintf(`
Type: %s
`, html_pkg.EscapeString(g.Type))) + html.WriteString(fmt.Sprintf(`
Occurrences: %d
`, g.Count)) + html.WriteString(`
` + html_pkg.EscapeString(g.Sample) + `
`) + html.WriteString(`
`) + } + html.WriteString(`
`) + } + + html.WriteString(` `) diff --git a/op-acceptance-tests/cmd/flake-shake-aggregator/main_test.go b/op-acceptance-tests/cmd/flake-shake-aggregator/main_test.go new file mode 100644 index 00000000000..1f30f74afe5 --- /dev/null +++ b/op-acceptance-tests/cmd/flake-shake-aggregator/main_test.go @@ -0,0 +1,106 @@ +package main + +import ( + "encoding/json" + "os" + "path/filepath" + "strings" + "testing" + "time" +) + +func writeReport(t *testing.T, dir, name string, r FlakeShakeReport) string { + t.Helper() + b, err := json.Marshal(r) + if err != nil { + t.Fatalf("marshal: %v", err) + } + p := filepath.Join(dir, name) + if err := os.WriteFile(p, b, 0644); err != nil { + t.Fatalf("write: %v", err) + } + return p +} + +func TestRunAggregatesReports(t *testing.T) { + tmp := t.TempDir() + // create two worker reports + r1 := FlakeShakeReport{ + Date: "2025-01-01", + Gate: "flake-shake", + Iterations: 10, + Tests: []FlakeShakeResult{{ + TestName: "pkg::T1", + Package: "pkg", + TotalRuns: 10, + Passes: 9, + Failures: 1, + Skipped: 0, + AvgDuration: 100 * time.Millisecond, + MinDuration: 80 * time.Millisecond, + MaxDuration: 120 * time.Millisecond, + }}, + GeneratedAt: time.Now(), + RunID: "abc", + } + r2 := FlakeShakeReport{ + Date: "2025-01-01", + Gate: "flake-shake", + Iterations: 5, + Tests: []FlakeShakeResult{{ + TestName: "pkg::T1", + Package: "pkg", + TotalRuns: 5, + Passes: 5, + Failures: 0, + Skipped: 0, + AvgDuration: 90 * time.Millisecond, + MinDuration: 70 * time.Millisecond, + MaxDuration: 110 * time.Millisecond, + }}, + GeneratedAt: time.Now(), + RunID: "abc", + } + // Place files under pattern + d1 := filepath.Join(tmp, "flake-shake-results-worker-1") + d2 := filepath.Join(tmp, "flake-shake-results-worker-2") + if err := os.MkdirAll(d1, 0755); err != nil { + t.Fatal(err) + } + if err := os.MkdirAll(d2, 0755); err != nil { + t.Fatal(err) + } + writeReport(t, d1, "flake-shake-report.json", r1) + writeReport(t, d2, "flake-shake-report.json", r2) + + out := filepath.Join(tmp, "final") + if err := run(filepath.Join(tmp, "flake-shake-results-worker-*/flake-shake-report.json"), out, false); err != nil { + t.Fatalf("run error: %v", err) + } + // verify outputs exist + if _, err := os.Stat(filepath.Join(out, "flake-shake-report.json")); err != nil { + t.Fatalf("missing json report: %v", err) + } + if _, err := os.Stat(filepath.Join(out, "flake-shake-report.html")); err != nil { + t.Fatalf("missing html report: %v", err) + } +} + +func TestGenerateHTMLReportBasic(t *testing.T) { + r := &FlakeShakeReport{ + Gate: "flake-shake", + Iterations: 15, + Tests: []FlakeShakeResult{ + {TestName: "pkg::T1", Package: "pkg", TotalRuns: 10, Passes: 10, Failures: 0, PassRate: 100}, + {TestName: "pkg::T2", Package: "pkg", TotalRuns: 5, Passes: 4, Failures: 1, PassRate: 80}, + }, + GeneratedAt: time.Now(), + } + html := generateHTMLReport(r) + if len(html) == 0 { + t.Fatal("empty html") + } + if !strings.Contains(html, "Flake-Shake Report") { + t.Fatal("missing title") + } +} diff --git a/op-acceptance-tests/cmd/flake-shake-promoter/main.go b/op-acceptance-tests/cmd/flake-shake-promoter/main.go new file mode 100644 index 00000000000..77e57769a94 --- /dev/null +++ b/op-acceptance-tests/cmd/flake-shake-promoter/main.go @@ -0,0 +1,1117 @@ +package main + +import ( + "bytes" + "context" + "encoding/json" + "errors" + "flag" + "fmt" + "io" + "log" + "net/http" + "net/url" + "os" + "path/filepath" + "sort" + "strings" + "time" + + github "github.com/google/go-github/v55/github" // newer version of Go is needed for the latest GitHub API + "golang.org/x/oauth2" + yaml "gopkg.in/yaml.v3" +) + +var logger *log.Logger + +// CircleCI API models +type pipelineList struct { + Items []pipeline `json:"items"` + NextPageToken string `json:"next_page_token"` +} + +type pipeline struct { + ID string `json:"id"` + CreatedAt time.Time `json:"created_at"` +} + +type workflowList struct { + Items []workflow `json:"items"` + NextPageToken string `json:"next_page_token"` +} + +type workflow struct { + ID string `json:"id"` + Name string `json:"name"` +} + +type jobList struct { + Items []job `json:"items"` + NextPageToken string `json:"next_page_token"` +} + +type job struct { + Name string `json:"name"` + JobNumber int `json:"job_number"` +} + +type artifactsList struct { + Items []artifact `json:"items"` +} + +type artifact struct { + URL string `json:"url"` + Path string `json:"path"` +} + +// Daily summary (as produced in CI job) +type DailySummary struct { + Date string `json:"date"` + Gate string `json:"gate"` + TotalRuns int `json:"total_runs"` + Iterations int `json:"iterations"` + Totals struct { + Stable int `json:"stable"` + Unstable int `json:"unstable"` + } `json:"totals"` + StableTests []struct { + TestName string `json:"test_name"` + Package string `json:"package"` + TotalRuns int `json:"total_runs"` + PassRate float64 `json:"pass_rate"` + } `json:"stable_tests"` + UnstableTests []struct { + TestName string `json:"test_name"` + Package string `json:"package"` + TotalRuns int `json:"total_runs"` + Passes int `json:"passes"` + Failures int `json:"failures"` + PassRate float64 `json:"pass_rate"` + } `json:"unstable_tests"` +} + +// Acceptance tests YAML models +type acceptanceYAML struct { + Gates []gateYAML `yaml:"gates"` +} + +type gateYAML struct { + ID string `yaml:"id"` + Description string `yaml:"description,omitempty"` + Inherits []string `yaml:"inherits,omitempty"` + Tests []testEntry `yaml:"tests,omitempty"` +} + +type testEntry struct { + Name string `yaml:"name,omitempty"` + Package string `yaml:"package"` + Timeout string `yaml:"timeout,omitempty"` + Metadata map[string]interface{} `yaml:"metadata,omitempty"` +} + +// Aggregated per test across days +type aggStats struct { + Package string `json:"package"` + TestName string `json:"test_name"` + TotalRuns int `json:"total_runs"` + Passes int `json:"passes"` + Failures int `json:"failures"` + FirstSeenDay string `json:"first_seen_day"` + LastSeenDay string `json:"last_seen_day"` + LastFailureAt *time.Time `json:"last_failure_at,omitempty"` + DaysObserved []string `json:"days_observed"` +} + +type promoteCandidate struct { + Package string `json:"package"` + TestName string `json:"test_name"` + TotalRuns int `json:"total_runs"` + PassRate float64 `json:"pass_rate"` + Timeout string `json:"timeout"` + FirstSeenDay string `json:"first_seen_day"` +} + +// Map tests in flake-shake: key -> (timeout, name) +type testInfo struct { + Timeout string + Name string + Meta map[string]interface{} + GateIndex int + TestIndex int +} + +func main() { + opts := parsePromoterFlags() + + logger = log.New(os.Stdout, "[flake-shake-promoter] ", log.LstdFlags) + if opts.verbose { + logger.Printf("Flags: org=%s repo=%s branch=%s workflow=%s report_job=%s days=%d gate=%s min_runs=%d max_failure_rate=%.4f min_age_days=%d require_clean_24h=%t out=%s dry_run=%t", + opts.org, opts.repo, opts.branch, opts.workflowName, opts.reportJobName, opts.daysBack, opts.gateID, opts.minRuns, opts.maxFailureRate, opts.minAgeDays, opts.requireClean24h, opts.outDir, opts.dryRun, + ) + } + + token := requireEnv("CIRCLE_API_TOKEN") + if err := ensureDirExists(opts.outDir); err != nil { + fmt.Fprintf(os.Stderr, "failed to create out dir: %v\n", err) + os.Exit(1) + } + + now := time.Now().UTC() + since := now.AddDate(0, 0, -opts.daysBack) + + client := &http.Client{Timeout: 30 * time.Second} + ctx := &apiCtx{client: client, token: token} + + dailyReports, err := collectReports(ctx, opts.org, opts.repo, opts.branch, opts.workflowName, opts.reportJobName, since, opts.verbose) + if err != nil { + fmt.Fprintf(os.Stderr, "collection failed: %v\n", err) + os.Exit(1) + } + + agg := aggregate(dailyReports) + + logDailyReportSummary(dailyReports, opts.verbose) + + // Load acceptance-tests.yaml + yamlPath := filepath.Join("op-acceptance-tests", "acceptance-tests.yaml") + cfg, err := readAcceptanceYAML(yamlPath) + if err != nil { + fmt.Fprintf(os.Stderr, "failed reading %s: %v\n", yamlPath, err) + os.Exit(1) + } + + // Build indices for flake-shake tests and target gates + flakeTests, flakeGate, gateIndex := buildFlakeTests(&cfg, opts.gateID, yamlPath) + _ = gateIndex + + // Select promotion candidates + candidates, reasons := selectPromotionCandidates(agg, flakeTests, opts.minRuns, opts.maxFailureRate, opts.requireClean24h, opts.minAgeDays, now) + + // Write outputs + if err := writeJSON(filepath.Join(opts.outDir, "aggregate.json"), agg); err != nil { + fmt.Fprintf(os.Stderr, "failed writing aggregate: %v\n", err) + os.Exit(1) + } + sort.Slice(candidates, func(i, j int) bool { + if candidates[i].Package == candidates[j].Package { + return candidates[i].TestName < candidates[j].TestName + } + return candidates[i].Package < candidates[j].Package + }) + if err := writeJSON(filepath.Join(opts.outDir, "promotion-ready.json"), map[string]interface{}{"candidates": candidates, "skipped": reasons}); err != nil { + fmt.Fprintf(os.Stderr, "failed writing promotion-ready: %v\n", err) + os.Exit(1) + } + + if opts.verbose { + fmt.Printf("Promotion candidates: %d\n", len(candidates)) + for _, c := range candidates { + name := c.TestName + if strings.TrimSpace(name) == "" { + name = "(package)" + } + fmt.Printf(" - %s %s (runs=%d pass=%.2f%%)\n", c.Package, name, c.TotalRuns, c.PassRate) + } + } + + // Write metadata for downstream consumers (e.g., Slack) + meta := map[string]interface{}{ + "date": now.Format("2006-01-02"), + "candidates": len(candidates), + "flake_gate_tests": len(flakeGate.Tests), + } + if err := writeJSON(filepath.Join(opts.outDir, "metadata.json"), meta); err != nil { + fmt.Fprintf(os.Stderr, "failed writing metadata: %v\n", err) + os.Exit(1) + } + + // Generate updated YAML (proposal) + updated := computeUpdatedConfig(cfg, opts.gateID, candidates) + + // Write proposed YAML + outYAML := filepath.Join(opts.outDir, "promotion.yaml") + if err := writeYAML(outYAML, &updated); err != nil { + fmt.Fprintf(os.Stderr, "failed writing promotion.yaml: %v\n", err) + os.Exit(1) + } + + // Print short summary + if len(candidates) == 0 { + reason := buildNoCandidatesSummary(agg, flakeTests, opts.minAgeDays, opts.requireClean24h) + _ = os.WriteFile(filepath.Join(opts.outDir, "SUMMARY.txt"), []byte(reason+"\n"), 0o644) + logger.Println(reason) + return + } + var b bytes.Buffer + b.WriteString("Promotion candidates (dry-run):\n") + for _, c := range candidates { + b.WriteString(fmt.Sprintf("- %s %s (runs=%d, pass=%.2f%%)\n", c.Package, c.TestName, c.TotalRuns, c.PassRate)) + } + _ = os.WriteFile(filepath.Join(opts.outDir, "SUMMARY.txt"), b.Bytes(), 0o644) + logger.Print(b.String()) + + if opts.dryRun { + logger.Println("Dry-run enabled; skipping branch creation, file update, and PR creation.") + return + } + + // Prepare updated YAML content for PR by editing only the flake-shake gate in-place to preserve comments + var updatedYAMLBytes []byte + + prBranch := fmt.Sprintf("ci/flake-shake-promote/%s", time.Now().UTC().Format("2006-01-02-150405")) + + // Prepare commit message and PR body + title := "chore(op-acceptance-tests): flake-shake; test promotions" + var body bytes.Buffer + body.WriteString("## 🤖 Automated Flake-Shake Test Promotion\n\n") + body.WriteString(fmt.Sprintf("Promoting %d test(s) from gate `"+opts.gateID+"` based on stability criteria.\n\n", len(candidates))) + body.WriteString("### Tests Being Promoted\n\n") + body.WriteString("| Test | Package | Total Runs | Pass Rate |\n|---|---|---:|---:|\n") + for _, c := range candidates { + name := c.TestName + if strings.TrimSpace(name) == "" { + name = "(package)" + } + body.WriteString(fmt.Sprintf("| %s | %s | %d | %.2f%% |\n", name, c.Package, c.TotalRuns, c.PassRate)) + } + body.WriteString("\nThis PR was auto-generated by flake-shake promoter.\n") + + // Use GitHub API to create branch, update file, and open PR + ghToken := os.Getenv("GH_TOKEN") + if ghToken == "" { + fmt.Fprintln(os.Stderr, "GH_TOKEN is required for PR creation but not set") + os.Exit(1) + } + ghCtx := context.Background() + ts := oauth2.StaticTokenSource(&oauth2.Token{AccessToken: ghToken}) + tc := oauth2.NewClient(ghCtx, ts) + ghc := github.NewClient(tc) + + if opts.verbose { + logger.Printf("PR: starting creation process (base_branch=%s candidates=%d)", opts.branch, len(candidates)) + } + + // 1) Get base branch ref + baseRef, _, err := ghc.Git.GetRef(ghCtx, opts.org, opts.repo, "refs/heads/"+opts.branch) + if err != nil || baseRef.Object == nil || baseRef.Object.SHA == nil { + fmt.Fprintf(os.Stderr, "failed to get base ref: %v\n", err) + os.Exit(1) + } + if opts.verbose { + logger.Printf("PR: base ref resolved sha=%s", baseRef.GetObject().GetSHA()) + } + + // 2) Create new branch ref + newRef := &github.Reference{ + Ref: github.String("refs/heads/" + prBranch), + Object: &github.GitObject{SHA: baseRef.Object.SHA}, + } + if _, _, err := ghc.Git.CreateRef(ghCtx, opts.org, opts.repo, newRef); err != nil { + fmt.Fprintf(os.Stderr, "failed to create ref: %v\n", err) + os.Exit(1) + } + if opts.verbose { + logger.Printf("PR: created branch %s", prBranch) + } + + // 3) Read current file to fetch SHA (if exists) on base branch + path := yamlPath + var sha *string + var originalYAML []byte + if fileContent, _, resp, err := ghc.Repositories.GetContents(ghCtx, opts.org, opts.repo, path, &github.RepositoryContentGetOptions{Ref: opts.branch}); err == nil && fileContent != nil { + sha = fileContent.SHA + // Retrieve decoded file content via client helper + rawContent, gcErr := fileContent.GetContent() + if gcErr == nil && rawContent != "" { + originalYAML = []byte(rawContent) + } + } else if resp != nil && resp.StatusCode == 404 { + sha = nil + } else if err != nil { + fmt.Fprintf(os.Stderr, "failed to get contents: %v\n", err) + os.Exit(1) + } + + // Build updated YAML by removing promoted tests only from flake-shake gate, preserving comments + promoteKeys := map[string]promoteCandidate{} + for _, c := range candidates { + promoteKeys[keyFor(c.Package, c.TestName)] = c + } + updatedYAMLBytes, err = updateFlakeShakeGateOnly(originalYAML, opts.gateID, promoteKeys) + if err != nil { + fmt.Fprintf(os.Stderr, "failed to update YAML: %v\n", err) + os.Exit(1) + } + + // 4) Update file in new branch + commitMsg := title + if _, _, err = ghc.Repositories.UpdateFile(ghCtx, opts.org, opts.repo, path, &github.RepositoryContentFileOptions{ + Message: github.String(commitMsg), + Content: updatedYAMLBytes, + Branch: github.String(prBranch), + SHA: sha, + }); err != nil { + fmt.Fprintf(os.Stderr, "failed to update file: %v\n", err) + os.Exit(1) + } + if opts.verbose { + logger.Printf("PR: updated file %s on branch %s", path, prBranch) + } + + // 5) Create PR + prReq := &github.NewPullRequest{ + Title: github.String(title), + Head: github.String(prBranch), + Base: github.String(opts.branch), + Body: github.String(body.String()), + } + pr, _, err := ghc.PullRequests.Create(ghCtx, opts.org, opts.repo, prReq) + if err != nil { + fmt.Fprintf(os.Stderr, "failed to create PR: %v\n", err) + os.Exit(1) + } + logger.Printf("PR created: %s (number=%d)", pr.GetHTMLURL(), pr.GetNumber()) + + // Update metadata with PR details for downstream Slack notification + meta["pr_url"] = pr.GetHTMLURL() + meta["pr_number"] = pr.GetNumber() + if err := writeJSON(filepath.Join(opts.outDir, "metadata.json"), meta); err != nil { + fmt.Fprintf(os.Stderr, "failed updating metadata with PR info: %v\n", err) + } + + // 6) Add labels + if _, _, err := ghc.Issues.AddLabelsToIssue(ghCtx, opts.org, opts.repo, pr.GetNumber(), []string{"M-ci", "A-acceptance-tests"}); err != nil { + fmt.Fprintf(os.Stderr, "failed to add labels: %v\n", err) + } + + // 7) Request reviewers (user and team slug) + if _, _, err := ghc.PullRequests.RequestReviewers(ghCtx, opts.org, opts.repo, pr.GetNumber(), github.ReviewersRequest{ + Reviewers: []string{"scharissis"}, + TeamReviewers: []string{"platforms-team"}, + }); err != nil { + fmt.Fprintf(os.Stderr, "failed to request reviewers: %v\n", err) + } +} + +// promoterOpts holds command-line options for the promoter tool. +type promoterOpts struct { + org string + repo string + branch string + workflowName string + reportJobName string + daysBack int + gateID string + minRuns int + maxFailureRate float64 + minAgeDays int + outDir string + dryRun bool + requireClean24h bool + verbose bool +} + +func parsePromoterFlags() promoterOpts { + var opts promoterOpts + flag.StringVar(&opts.org, "org", "ethereum-optimism", "GitHub org") + flag.StringVar(&opts.repo, "repo", "optimism", "GitHub repo") + flag.StringVar(&opts.branch, "branch", "develop", "Branch to scan") + flag.StringVar(&opts.workflowName, "workflow", "scheduled-flake-shake", "Workflow name") + flag.StringVar(&opts.reportJobName, "report-job", "op-acceptance-tests-flake-shake-report", "Report job name") + flag.IntVar(&opts.daysBack, "days", 3, "Number of days to aggregate") + flag.StringVar(&opts.gateID, "gate", "flake-shake", "Gate id in acceptance-tests.yaml") + flag.IntVar(&opts.minRuns, "min-runs", 300, "Minimum total runs required") + flag.Float64Var(&opts.maxFailureRate, "max-failure-rate", 0.01, "Maximum allowed failure rate") + flag.IntVar(&opts.minAgeDays, "min-age-days", 2, "Minimum age in days in flake-shake") + flag.StringVar(&opts.outDir, "out", "./promotion-output", "Output directory") + flag.BoolVar(&opts.dryRun, "dry-run", true, "Do not modify repo or open PRs") + flag.BoolVar(&opts.requireClean24h, "require-clean-24h", false, "Require no failures in the last 24 hours") + flag.BoolVar(&opts.verbose, "verbose", false, "Enable verbose debug logging") + flag.Parse() + // Validate interdependent options early to avoid confusing outcomes later + if opts.daysBack < opts.minAgeDays { + fmt.Fprintf(os.Stderr, "invalid flags: --days (%d) must be >= --min-age-days (%d)\n", opts.daysBack, opts.minAgeDays) + os.Exit(2) + } + if opts.requireClean24h && opts.daysBack < 2 { + fmt.Fprintf(os.Stderr, "invalid flags: --days (%d) must be >= 2 when --require-clean-24h is set to ensure >24h coverage\n", opts.daysBack) + os.Exit(2) + } + return opts +} + +func requireEnv(name string) string { + v := os.Getenv(name) + if v == "" { + fmt.Fprintf(os.Stderr, "%s is not set\n", name) + os.Exit(1) + } + return v +} + +func ensureDirExists(dir string) error { + return os.MkdirAll(dir, 0o755) +} + +func logDailyReportSummary(dailyReports map[string]DailySummary, verbose bool) { + if !verbose { + return + } + logger.Printf("Collected %d day(s) of summaries.", len(dailyReports)) + totalTests := 0 + for date, ds := range dailyReports { + n := len(ds.StableTests) + len(ds.UnstableTests) + totalTests += n + logger.Printf(" - %s: %d tests (stable=%d unstable=%d)", date, n, len(ds.StableTests), len(ds.UnstableTests)) + } + logger.Printf("Total tests across days: %d", totalTests) +} + +// buildFlakeTests returns a map of tests in the flake-shake gate and also returns +// the flake gate reference and a gate index map for potential future use. +func buildFlakeTests(cfg *acceptanceYAML, gateID, yamlPath string) (map[string]testInfo, *gateYAML, map[string]*gateYAML) { + flakeGate := findGate(cfg, gateID) + if flakeGate == nil { + fmt.Fprintf(os.Stderr, "gate %s not found in %s\n", gateID, yamlPath) + os.Exit(1) + } + gateIndex := map[string]*gateYAML{} + for i := range cfg.Gates { + gateIndex[cfg.Gates[i].ID] = &cfg.Gates[i] + } + flakeTests := map[string]testInfo{} + for ti, t := range flakeGate.Tests { + key := keyFor(t.Package, t.Name) + flakeTests[key] = testInfo{Timeout: t.Timeout, Name: t.Name, Meta: t.Metadata, GateIndex: indexOfGate(cfg, gateID), TestIndex: ti} + } + return flakeTests, flakeGate, gateIndex +} + +func selectPromotionCandidates(agg map[string]*aggStats, flakeTests map[string]testInfo, minRuns int, maxFailureRate float64, requireClean24h bool, minAgeDays int, now time.Time) ([]promoteCandidate, map[string]string) { + candidates := []promoteCandidate{} + reasons := map[string]string{} + // Identify wildcard package entries (tests with empty name in the flake-shake gate) + wildcardPkgs := map[string]testInfo{} + for k, info := range flakeTests { + if strings.TrimSpace(info.Name) == "" && strings.HasSuffix(k, "::") { + pkg := strings.TrimSuffix(k, "::") + if pkg != "" { + wildcardPkgs[pkg] = info + } + } + } + + // Produce package-level candidates for wildcard entries by aggregating all tests in the package + for pkg, info := range wildcardPkgs { + totalRuns := 0 + totalPasses := 0 + totalFailures := 0 + earliest := "" + var lastFailureAt *time.Time + for _, s := range agg { + if s.Package != pkg { + continue + } + totalRuns += s.TotalRuns + totalPasses += s.Passes + totalFailures += s.Failures + if earliest == "" || (s.FirstSeenDay != "" && s.FirstSeenDay < earliest) { + earliest = s.FirstSeenDay + } + if s.LastFailureAt != nil { + if lastFailureAt == nil || s.LastFailureAt.After(*lastFailureAt) { + lastFailureAt = s.LastFailureAt + } + } + } + if totalRuns == 0 { + reasons[keyFor(pkg, "")] = "no runs observed for package" + continue + } + if totalRuns < minRuns { + reasons[keyFor(pkg, "")] = fmt.Sprintf("insufficient runs: %d < %d (pkg)", totalRuns, minRuns) + continue + } + failureRate := 0.0 + if totalRuns > 0 { + failureRate = float64(totalFailures) / float64(totalRuns) + } + if failureRate > maxFailureRate { + reasons[keyFor(pkg, "")] = fmt.Sprintf("failure rate %.4f exceeds max %.4f (pkg)", failureRate, maxFailureRate) + continue + } + if requireClean24h && lastFailureAt != nil { + if time.Since(*lastFailureAt) < 24*time.Hour { + reasons[keyFor(pkg, "")] = "failure within last 24h (pkg)" + continue + } + } + if earliest == "" { + reasons[keyFor(pkg, "")] = "no age information (pkg)" + continue + } + firstDay, _ := time.Parse("2006-01-02", earliest) + daysInGate := int(now.Sub(firstDay).Hours()/24) + 1 + if daysInGate < minAgeDays { + reasons[keyFor(pkg, "")] = fmt.Sprintf("min age %dd not met (have %dd) (pkg)", minAgeDays, daysInGate) + continue + } + passRate := 0.0 + if totalRuns > 0 { + passRate = float64(totalPasses) / float64(totalRuns) + } + candidates = append(candidates, promoteCandidate{ + Package: pkg, + TestName: "", + TotalRuns: totalRuns, + PassRate: passRate * 100.0, + Timeout: info.Timeout, + FirstSeenDay: earliest, + }) + } + for key, s := range agg { + // Skip per-test candidates for any package that is handled via wildcard aggregation + if _, hasWildcard := wildcardPkgs[s.Package]; hasWildcard { + continue + } + info, ok := flakeTests[key] + if !ok { + // Support wildcard package entries in the flake-shake gate where name is omitted. + // Treat a gate entry with empty name as a wildcard that matches all tests in that package. + if wi, wok := flakeTests[keyFor(s.Package, "")]; wok { + info = wi + } else { + continue + } + } + if s.TotalRuns < minRuns { + reasons[key] = fmt.Sprintf("insufficient runs: %d < %d", s.TotalRuns, minRuns) + continue + } + failureRate := 0.0 + if s.TotalRuns > 0 { + failureRate = float64(s.Failures) / float64(s.TotalRuns) + } + if failureRate > maxFailureRate { + reasons[key] = fmt.Sprintf("failure rate %.4f exceeds max %.4f", failureRate, maxFailureRate) + continue + } + if requireClean24h && s.LastFailureAt != nil { + if time.Since(*s.LastFailureAt) < 24*time.Hour { + reasons[key] = "failure within last 24h" + continue + } + } + if s.FirstSeenDay == "" { + reasons[key] = "no age information" + continue + } + firstDay, _ := time.Parse("2006-01-02", s.FirstSeenDay) + daysInGate := int(now.Sub(firstDay).Hours()/24) + 1 + if daysInGate < minAgeDays { + reasons[key] = fmt.Sprintf("min age %dd not met (have %dd)", minAgeDays, daysInGate) + continue + } + passRate := 0.0 + if s.TotalRuns > 0 { + passRate = float64(s.Passes) / float64(s.TotalRuns) + } + candidates = append(candidates, promoteCandidate{ + Package: s.Package, + TestName: s.TestName, + TotalRuns: s.TotalRuns, + PassRate: passRate * 100.0, + Timeout: info.Timeout, + FirstSeenDay: s.FirstSeenDay, + }) + } + return candidates, reasons +} + +func computeUpdatedConfig(cfg acceptanceYAML, gateID string, candidates []promoteCandidate) acceptanceYAML { + updated := cfg + flakeIdx := indexOfGate(&updated, gateID) + if flakeIdx < 0 { + fmt.Fprintf(os.Stderr, "gate %s not found when updating\n", gateID) + os.Exit(1) + } + promoteKeys := map[string]promoteCandidate{} + for _, c := range candidates { + promoteKeys[keyFor(c.Package, c.TestName)] = c + } + newFlakeTests := make([]testEntry, 0, len(updated.Gates[flakeIdx].Tests)) + for _, t := range updated.Gates[flakeIdx].Tests { + k := keyFor(t.Package, t.Name) + if _, ok := promoteKeys[k]; !ok { + newFlakeTests = append(newFlakeTests, t) + } + } + updated.Gates[flakeIdx].Tests = newFlakeTests + return updated +} + +func buildNoCandidatesSummary(agg map[string]*aggStats, flakeTests map[string]testInfo, minAgeDays int, requireClean24h bool) string { + earliest := "" + totalRuns := 0 + totalPass := 0 + totalFail := 0 + daySet := map[string]struct{}{} + for key, s := range agg { + if _, ok := flakeTests[key]; !ok { + continue + } + totalRuns += s.TotalRuns + totalPass += s.Passes + totalFail += s.Failures + if earliest == "" || (s.FirstSeenDay != "" && s.FirstSeenDay < earliest) { + earliest = s.FirstSeenDay + } + for _, d := range s.DaysObserved { + daySet[d] = struct{}{} + } + } + daysObserved := len(daySet) + return fmt.Sprintf( + "No promotion candidates. Reason: min_age_days=%d; earliest_observation=%s; days_observed=%d; require_clean_24h=%t; total_runs=%d; passes=%d; failures=%d.", + minAgeDays, earliest, daysObserved, requireClean24h, totalRuns, totalPass, totalFail, + ) +} + +// HTTP helper context +type apiCtx struct { + client *http.Client + token string +} + +func (c *apiCtx) getJSON(u string, v interface{}) error { + req, err := http.NewRequest("GET", u, nil) + if err != nil { + return err + } + req.Header.Set("Circle-Token", c.token) + req.Header.Set("Accept", "application/json") + resp, err := c.client.Do(req) + if err != nil { + return err + } + defer resp.Body.Close() + if resp.StatusCode >= 300 { + body, _ := io.ReadAll(resp.Body) + return fmt.Errorf("GET %s: status %d body=%s", u, resp.StatusCode, string(body)) + } + dec := json.NewDecoder(resp.Body) + return dec.Decode(v) +} + +func (c *apiCtx) getBytes(u string) ([]byte, error) { + req, err := http.NewRequest("GET", u, nil) + if err != nil { + return nil, err + } + req.Header.Set("Circle-Token", c.token) + req.Header.Set("Accept", "application/json") + resp, err := c.client.Do(req) + if err != nil { + return nil, err + } + defer resp.Body.Close() + if resp.StatusCode >= 300 { + body, _ := io.ReadAll(resp.Body) + return nil, fmt.Errorf("GET %s: status %d body=%s", u, resp.StatusCode, string(body)) + } + return io.ReadAll(resp.Body) +} + +// collectReports scans CircleCI pipelines for the given GitHub repo/branch, +// locates the specified workflow and report job, and downloads/merges the +// daily-summary.json artifacts into a map keyed by date (YYYY-MM-DD). +// Only runs created at or after 'since' are considered. When multiple +// summaries exist for the same day, totals are summed and test lists merged. +func collectReports(ctx *apiCtx, org, repo, branch, workflowName, reportJobName string, since time.Time, verbose bool) (map[string]DailySummary, error) { + dailyByDay := map[string]DailySummary{} + + basePipelines := fmt.Sprintf("https://circleci.com/api/v2/project/gh/%s/%s/pipeline?branch=%s", url.PathEscape(org), url.PathEscape(repo), url.QueryEscape(branch)) + pageURL := basePipelines + + for { + pl, nextToken, err := getPipelinesPage(ctx, pageURL) + if err != nil { + return nil, err + } + if verbose { + logger.Printf("Scanning pipelines page: %s", pageURL) + } + + stop, err := processPipelines(ctx, pl, org, repo, workflowName, reportJobName, since, verbose, dailyByDay) + if err != nil { + return nil, err + } + if stop { + break + } + if nextToken == "" { + break + } + pageURL = basePipelines + "&page-token=" + url.QueryEscape(nextToken) + } + return dailyByDay, nil +} + +// getPipelinesPage fetches a page of pipelines and returns the list along with the next page token. +func getPipelinesPage(ctx *apiCtx, pageURL string) (pipelineList, string, error) { + var pl pipelineList + if err := ctx.getJSON(pageURL, &pl); err != nil { + return pipelineList{}, "", err + } + return pl, pl.NextPageToken, nil +} + +// processPipelines iterates pipelines, filters by date/window, and merges daily summaries. +// It returns stop=true when it encounters pipelines older than the provided 'since' time. +func processPipelines(ctx *apiCtx, pl pipelineList, org, repo, workflowName, reportJobName string, since time.Time, verbose bool, dailyByDay map[string]DailySummary) (bool, error) { + for _, p := range pl.Items { + if verbose { + logger.Printf(" pipeline %s created_at=%s", p.ID, p.CreatedAt.Format(time.RFC3339)) + } + if p.CreatedAt.Before(since) { + return true, nil + } + + wfl, err := listWorkflows(ctx, p.ID) + if err != nil { + return false, err + } + for _, w := range wfl.Items { + if w.Name != workflowName { + continue + } + jl, err := listJobs(ctx, w.ID) + if err != nil { + return false, err + } + for _, j := range jl.Items { + if j.Name != reportJobName { + continue + } + al, err := listArtifacts(ctx, org, repo, j.JobNumber, verbose) + if err != nil { + return false, err + } + dailyURL := findDailySummaryArtifactURL(al) + if dailyURL == "" { + continue + } + if err := loadAndMergeDailySummary(ctx, dailyURL, dailyByDay, verbose); err != nil { + return false, err + } + } + } + } + return false, nil +} + +func listWorkflows(ctx *apiCtx, pipelineID string) (workflowList, error) { + wfURL := fmt.Sprintf("https://circleci.com/api/v2/pipeline/%s/workflow", pipelineID) + var wfl workflowList + if err := ctx.getJSON(wfURL, &wfl); err != nil { + return workflowList{}, err + } + return wfl, nil +} + +func listJobs(ctx *apiCtx, workflowID string) (jobList, error) { + jobsURL := fmt.Sprintf("https://circleci.com/api/v2/workflow/%s/job", workflowID) + var jl jobList + if err := ctx.getJSON(jobsURL, &jl); err != nil { + return jobList{}, err + } + return jl, nil +} + +func listArtifacts(ctx *apiCtx, org, repo string, jobNumber int, verbose bool) (artifactsList, error) { + artsURL := fmt.Sprintf("https://circleci.com/api/v2/project/gh/%s/%s/%d/artifacts", url.PathEscape(org), url.PathEscape(repo), jobNumber) + var al artifactsList + if err := ctx.getJSON(artsURL, &al); err != nil { + return artifactsList{}, err + } + if verbose { + logger.Printf(" job %d artifacts: %d", jobNumber, len(al.Items)) + for _, a := range al.Items { + logger.Printf(" - %s", a.Path) + } + } + return al, nil +} + +func findDailySummaryArtifactURL(al artifactsList) string { + for _, a := range al.Items { + // Accept any artifact path that ends with the filename, regardless of destination prefix + if strings.HasSuffix(a.Path, "daily-summary.json") { + return a.URL + } + } + return "" +} + +func loadAndMergeDailySummary(ctx *apiCtx, dailyURL string, dailyByDay map[string]DailySummary, verbose bool) error { + data, err := ctx.getBytes(dailyURL) + if err != nil { + return err + } + var ds DailySummary + if json.Unmarshal(data, &ds) != nil || ds.Date == "" { + return nil + } + if prev, seen := dailyByDay[ds.Date]; !seen { + dailyByDay[ds.Date] = ds + if verbose { + logger.Printf(" loaded daily summary for %s (runs=%d iterations=%d)", ds.Date, ds.TotalRuns, ds.Iterations) + } + return nil + } else { + merged := prev + merged.TotalRuns += ds.TotalRuns + merged.Iterations += ds.Iterations + merged.StableTests = append(merged.StableTests, ds.StableTests...) + merged.UnstableTests = append(merged.UnstableTests, ds.UnstableTests...) + dailyByDay[ds.Date] = merged + if verbose { + logger.Printf(" merged another run for %s (+runs=%d +iters=%d) now runs=%d iters=%d", ds.Date, ds.TotalRuns, ds.Iterations, merged.TotalRuns, merged.Iterations) + } + return nil + } +} + +// aggregate reduces per-day test summaries into a single map keyed by test, +// summing runs/passes/failures and tracking which days each test appeared. +// It also computes first/last seen day boundaries for each test. +func aggregate(daily map[string]DailySummary) map[string]*aggStats { + result := map[string]*aggStats{} + // Collect all days + days := make([]string, 0, len(daily)) + for d := range daily { + days = append(days, d) + } + sort.Strings(days) + + for _, day := range days { + if ds, ok := daily[day]; ok { + for _, t := range ds.StableTests { + k := keyFor(t.Package, t.TestName) + s := ensureAgg(result, k, t.Package, t.TestName, day) + s.TotalRuns += t.TotalRuns + s.Passes += t.TotalRuns + } + for _, t := range ds.UnstableTests { + k := keyFor(t.Package, t.TestName) + s := ensureAgg(result, k, t.Package, t.TestName, day) + s.TotalRuns += t.TotalRuns + s.Passes += t.Passes + s.Failures += t.Failures + approx := parseDayEnd(day) + if s.LastFailureAt == nil || approx.After(*s.LastFailureAt) { + s.LastFailureAt = &approx + } + } + } + } + return result +} + +// ensureAgg returns the aggregated stats bucket for the given test key, creating it +// if it does not exist. It also records the provided day in DaysObserved (without +// duplicates) and updates FirstSeenDay/LastSeenDay bounds accordingly. +func ensureAgg(m map[string]*aggStats, key, pkg, name, day string) *aggStats { + s, ok := m[key] + if !ok { + s = &aggStats{Package: pkg, TestName: name, DaysObserved: []string{}, FirstSeenDay: day, LastSeenDay: day} + m[key] = s + } + // Append day if new + found := false + for _, d := range s.DaysObserved { + if d == day { + found = true + break + } + } + if !found { + s.DaysObserved = append(s.DaysObserved, day) + if s.FirstSeenDay == "" || day < s.FirstSeenDay { + s.FirstSeenDay = day + } + if s.LastSeenDay == "" || day > s.LastSeenDay { + s.LastSeenDay = day + } + } + return s +} + +// parseDayEnd returns the exclusive end-of-day bound for the given date +// (YYYY-MM-DD) in UTC. This is the start of the next day, suitable for +// half-open intervals: [start, end). +func parseDayEnd(day string) time.Time { + t, err := time.Parse("2006-01-02", day) + if err != nil { + return time.Now().UTC() + } + return t.UTC().Add(24 * time.Hour) +} + +func keyFor(pkg, name string) string { + return pkg + "::" + strings.TrimSpace(name) +} + +func readAcceptanceYAML(path string) (acceptanceYAML, error) { + var acc acceptanceYAML + data, err := os.ReadFile(path) + if err != nil { + return acc, err + } + if err := yaml.Unmarshal(data, &acc); err != nil { + return acc, err + } + if len(acc.Gates) == 0 { + return acc, errors.New("no gates found") + } + return acc, nil +} + +func findGate(acc *acceptanceYAML, id string) *gateYAML { + for i, gate := range acc.Gates { + if gate.ID == id { + return &acc.Gates[i] + } + } + return nil +} + +func indexOfGate(acc *acceptanceYAML, id string) int { + for i := range acc.Gates { + if acc.Gates[i].ID == id { + return i + } + } + return -1 +} + +func writeJSON(path string, v interface{}) error { + f, err := os.Create(path) + if err != nil { + return err + } + defer f.Close() + enc := json.NewEncoder(f) + enc.SetEscapeHTML(false) + enc.SetIndent("", " ") + return enc.Encode(v) +} + +func writeYAML(path string, v interface{}) error { + data, err := yaml.Marshal(v) + if err != nil { + return err + } + // Normalize line endings + data = bytes.ReplaceAll(data, []byte("\r\n"), []byte("\n")) + return os.WriteFile(path, data, 0o644) +} + +// updateFlakeShakeGateOnly updates only the flake-shake gate tests list in the original YAML bytes, +// preserving all comments and formatting elsewhere. It removes any test entries matching promoteKeys. +func updateFlakeShakeGateOnly(original []byte, gateID string, promoteKeys map[string]promoteCandidate) ([]byte, error) { + if len(original) == 0 { + // Fallback to structured marshal if original missing (should not happen in CI) + return yaml.Marshal(nil) + } + lines := strings.Split(string(original), "\n") + var out []string + inGates := false + inFlake := false + indentGate := "" + indentTests := "" + // simple state machine: copy all lines except tests under flake-shake that match promoteKeys + for i := 0; i < len(lines); i++ { + line := lines[i] + trimmed := strings.TrimSpace(line) + // Detect top-level 'gates:' + if strings.HasPrefix(trimmed, "gates:") { + inGates = true + out = append(out, line) + continue + } + if inGates && strings.HasPrefix(trimmed, "- id:") { + // Entering a gate block + // Determine indentation + indentGate = line[:len(line)-len(strings.TrimLeft(line, " \t"))] + // Gate id value + id := strings.TrimSpace(strings.TrimPrefix(trimmed, "- id:")) + id = strings.Trim(id, "\"')") + inFlake = (id == gateID) + out = append(out, line) + continue + } + if !inFlake { + out = append(out, line) + continue + } + // Within flake-shake gate only + if strings.HasPrefix(strings.TrimSpace(line), "tests:") && indentTests == "" { + // Capture tests indent from next line if present + out = append(out, line) + // From here, filter list items until we leave tests list (deduce by indentation decrease or new key at gate level) + pos := i + 1 + for ; pos < len(lines); pos++ { + cur := lines[pos] + curTrim := strings.TrimSpace(cur) + if curTrim == "" { + out = append(out, cur) + continue + } + // end of this gate block if next key aligns to indentGate and not list item + if !strings.HasPrefix(cur, indentGate+" ") || strings.HasPrefix(strings.TrimSpace(cur), "- id:") { + // set i so that outer loop reprocesses this line next + i = pos - 1 + break + } + // If this is a list item under tests: starts with indentGate + two spaces + two more (tests indent) + '- ' + // We can't rely on exact spaces; detect package line to gather block + if strings.HasPrefix(strings.TrimSpace(cur), "- package:") { + // start of a test block; buffer until next '- package:' or gate-level boundary + block := []string{cur} + pkg := strings.TrimSpace(strings.TrimPrefix(curTrim, "- package:")) + name := "" + j := pos + 1 + for ; j < len(lines); j++ { + nt := strings.TrimSpace(lines[j]) + if nt == "" { + block = append(block, lines[j]) + continue + } + // next test or end of tests + if strings.HasPrefix(nt, "- package:") || (!strings.HasPrefix(lines[j], indentGate+" ")) { + j-- + break + } + block = append(block, lines[j]) + if strings.HasPrefix(nt, "name:") { + name = strings.TrimSpace(strings.TrimPrefix(nt, "name:")) + } + } + // Decide keep or drop + k := keyFor(pkg, name) + if _, toPromote := promoteKeys[k]; !toPromote { + out = append(out, block...) + } + pos = j + continue + } + // Non-test line under tests; keep + out = append(out, cur) + } + continue + } + out = append(out, line) + } + return []byte(strings.Join(out, "\n")), nil +} diff --git a/op-acceptance-tests/cmd/flake-shake-promoter/main_test.go b/op-acceptance-tests/cmd/flake-shake-promoter/main_test.go new file mode 100644 index 00000000000..6e2cb769885 --- /dev/null +++ b/op-acceptance-tests/cmd/flake-shake-promoter/main_test.go @@ -0,0 +1,112 @@ +package main + +import ( + "reflect" + "slices" + "sort" + "testing" + "time" +) + +func TestKeyFor(t *testing.T) { + if got := keyFor("pkg/a", ""); got != "pkg/a::" { + t.Fatalf("empty name => got %q", got) + } + if got := keyFor("pkg/a", " TestFoo "); got != "pkg/a::TestFoo" { + t.Fatalf("trim => got %q", got) + } +} + +func TestParseDayEnd(t *testing.T) { + end := parseDayEnd("2025-01-02") + want := time.Date(2025, 1, 3, 0, 0, 0, 0, time.UTC) + if !end.Equal(want) { + t.Fatalf("end != start-of-next-day: got %v want %v", end, want) + } +} + +func TestEnsureAggAndAggregate(t *testing.T) { + // ensureAgg behavior + m := map[string]*aggStats{} + s := ensureAgg(m, "pkg::T1", "pkg", "T1", "2025-01-01") + if s.FirstSeenDay != "2025-01-01" || s.LastSeenDay != "2025-01-01" { + t.Fatalf("first/last not set") + } + s2 := ensureAgg(m, "pkg::T1", "pkg", "T1", "2025-01-02") + if s2 != s { + t.Fatalf("ensureAgg did not return same pointer for same key") + } + if !slices.Contains(s.DaysObserved, "2025-01-01") || !slices.Contains(s.DaysObserved, "2025-01-02") { + t.Fatalf("days observed missing: %v", s.DaysObserved) + } + + // aggregate behavior across days + day1 := DailySummary{Date: "2025-01-01"} + day1.UnstableTests = append(day1.UnstableTests, struct { + TestName string `json:"test_name"` + Package string `json:"package"` + TotalRuns int `json:"total_runs"` + Passes int `json:"passes"` + Failures int `json:"failures"` + PassRate float64 `json:"pass_rate"` + }{TestName: "T1", Package: "pkg", TotalRuns: 10, Passes: 10, Failures: 0}) + + day2 := DailySummary{Date: "2025-01-02"} + day2.UnstableTests = append(day2.UnstableTests, struct { + TestName string `json:"test_name"` + Package string `json:"package"` + TotalRuns int `json:"total_runs"` + Passes int `json:"passes"` + Failures int `json:"failures"` + PassRate float64 `json:"pass_rate"` + }{TestName: "T1", Package: "pkg", TotalRuns: 5, Passes: 4, Failures: 1}) + + agg := aggregate(map[string]DailySummary{ + day1.Date: day1, + day2.Date: day2, + }) + a := agg["pkg::T1"] + if a == nil || a.TotalRuns != 15 || a.Passes != 14 || a.Failures != 1 { + t.Fatalf("bad aggregate: %+v", a) + } + // DaysObserved should be sorted and include both + wantDays := []string{"2025-01-01", "2025-01-02"} + gotDays := append([]string(nil), a.DaysObserved...) + sort.Strings(gotDays) + if !reflect.DeepEqual(gotDays, wantDays) { + t.Fatalf("days mismatch: got %v want %v", gotDays, wantDays) + } +} + +func TestSelectPromotionCandidates(t *testing.T) { + now := time.Date(2025, 1, 10, 0, 0, 0, 0, time.UTC) + flake := map[string]testInfo{"pkg::T1": {Timeout: "1m"}} + agg := map[string]*aggStats{ + "pkg::T1": { + Package: "pkg", + TestName: "T1", + TotalRuns: 100, + Passes: 100, + Failures: 0, + FirstSeenDay: "2025-01-01", + DaysObserved: []string{"2025-01-01", "2025-01-02"}, + }, + } + cands, reasons := selectPromotionCandidates(agg, flake, 50, 0.01, true, 3, now) + if len(reasons) != 0 { + t.Fatalf("unexpected reasons: %v", reasons) + } + if len(cands) != 1 || cands[0].Package != "pkg" || cands[0].TestName != "T1" { + t.Fatalf("unexpected candidates: %+v", cands) + } +} + +func TestComputeUpdatedConfig(t *testing.T) { + cfg := acceptanceYAML{Gates: []gateYAML{{ID: "flake-shake", Tests: []testEntry{{Package: "pkg", Name: "T1"}, {Package: "pkg", Name: "T2"}}}}} + cands := []promoteCandidate{{Package: "pkg", TestName: "T1"}} + updated := computeUpdatedConfig(cfg, "flake-shake", cands) + tests := updated.Gates[0].Tests + if len(tests) != 1 || tests[0].Name != "T2" { + t.Fatalf("expected only T2 to remain, got %+v", tests) + } +} diff --git a/op-acceptance-tests/cmd/main.go b/op-acceptance-tests/cmd/main.go index f8e6508deed..6bb15b918e8 100644 --- a/op-acceptance-tests/cmd/main.go +++ b/op-acceptance-tests/cmd/main.go @@ -298,6 +298,11 @@ func runOpAcceptor(ctx context.Context, tracer trace.Tracer, config AcceptorConf args = append(args, "--allow-skips") } + // Exclude quarantined tests by default in all runs except when explicitly running the flake-shake gate + if config.Gate != "flake-shake" { + args = append(args, "--exclude-gates", "flake-shake") + } + acceptorCmd := exec.CommandContext(ctx, config.Acceptor, args...) acceptorCmd.Env = env acceptorCmd.Stdout = os.Stdout diff --git a/op-acceptance-tests/justfile b/op-acceptance-tests/justfile index e9a108d337a..afdf3d4bafd 100644 --- a/op-acceptance-tests/justfile +++ b/op-acceptance-tests/justfile @@ -95,6 +95,8 @@ acceptance-test devnet="" gate="base": CMD_ARGS=( "$BINARY_PATH" "--testdir" "{{REPO_ROOT}}/op-acceptance-tests/..." + "--validators" "./acceptance-tests.yaml" + "--exclude-gates" "flake-shake" "--allow-skips" "--timeout" "90m" "--default-timeout" "10m" @@ -146,6 +148,7 @@ acceptance-test-docker devnet="simple" gate="base": --testdir "/go/src/github.com/ethereum-optimism/optimism" \ --gate {{gate}} \ --validators /acceptance-tests.yaml \ + $( [[ "{{gate}}" != "flake-shake" ]] && echo --exclude-gates flake-shake ) \ --log.level debug @@ -153,3 +156,23 @@ acceptance-test-docker devnet="simple" gate="base": clean: kurtosis clean --all rm -rf tests/interop/loadtest/artifacts + + +# Build, vet, lint and test Go code in ./cmd +cmd-check: + #!/usr/bin/env bash + set -euo pipefail + + cd {{REPO_ROOT}}/op-acceptance-tests + + echo "Downloading Go modules..." + go mod download + + echo "Building ./cmd/..." + go build ./cmd/... + + echo "Running go vet on ./cmd/..." + go vet ./cmd/... + + echo "Running unit tests for ./cmd/..." + go test -v ./cmd/... diff --git a/op-acceptance-tests/scripts/ci_flake_shake_calc_iterations.sh b/op-acceptance-tests/scripts/ci_flake_shake_calc_iterations.sh new file mode 100644 index 00000000000..46ddcfee910 --- /dev/null +++ b/op-acceptance-tests/scripts/ci_flake_shake_calc_iterations.sh @@ -0,0 +1,43 @@ +#!/usr/bin/env bash +set -euo pipefail + +# ci_flake_shake_calc_iterations.sh +# +# Purpose: +# Compute the number of iterations each CircleCI parallel worker should run +# and export FLAKE_SHAKE_ITERATIONS and FLAKE_SHAKE_WORKER_ID into $BASH_ENV. +# +# Usage: +# ci_flake_shake_calc_iterations.sh [WORKERS] [WORKER_ID] +# +# Arguments: +# TOTAL_ITER (required): total iterations across all workers. +# WORKERS (optional): number of parallel workers (defaults to $CIRCLE_NODE_TOTAL or 1). +# WORKER_ID (optional): 1-based worker id (defaults to $((CIRCLE_NODE_INDEX+1)) or 1). +# +# Notes: +# - Remainder iterations are distributed one-by-one to the first N workers. + +TOTAL_ITER=${1:?TOTAL_ITER is required} +WORKERS=${2:-${CIRCLE_NODE_TOTAL:-1}} +WORKER_ID=${3:-$((${CIRCLE_NODE_INDEX:-0} + 1))} + +ITER_PER_WORKER=$(( TOTAL_ITER / WORKERS )) +REMAINDER=$(( TOTAL_ITER % WORKERS )) + +# Distribute the remainder fairly: the first $REMAINDER workers get one extra iteration +if [ "$WORKER_ID" -le "$REMAINDER" ] && [ "$REMAINDER" -ne 0 ]; then + ITER_COUNT=$(( ITER_PER_WORKER + 1 )) +else + ITER_COUNT=$ITER_PER_WORKER +fi + +echo "Worker $WORKER_ID running $ITER_COUNT of $TOTAL_ITER iterations" +if [ -n "${BASH_ENV:-}" ]; then + echo "export FLAKE_SHAKE_ITERATIONS=$ITER_COUNT" >> "$BASH_ENV" + echo "export FLAKE_SHAKE_WORKER_ID=$WORKER_ID" >> "$BASH_ENV" +fi + +exit 0 + + diff --git a/op-acceptance-tests/scripts/ci_flake_shake_generate_summary.sh b/op-acceptance-tests/scripts/ci_flake_shake_generate_summary.sh new file mode 100644 index 00000000000..3da11928ce1 --- /dev/null +++ b/op-acceptance-tests/scripts/ci_flake_shake_generate_summary.sh @@ -0,0 +1,74 @@ +#!/usr/bin/env bash +set -euo pipefail + +# ci_flake_shake_generate_summary.sh +# +# Purpose: +# Used in CI by the flake-shake report job to transform the aggregated +# flake-shake report (JSON) into two derivative artifacts: +# 1) daily-summary.json – compact daily snapshot for downstream tooling +# 2) promotion-ready.json – list of tests with 100% pass rate (promotion candidates) +# +# Usage: ci_flake_shake_generate_summary.sh [REPORT_JSON] [OUT_DIR] +# $1 REPORT_JSON (optional) – path to flake-shake aggregated report JSON +# Default: final-report/flake-shake-report.json +# $2 OUT_DIR (optional) – directory where outputs will be written +# Default: final-report +# +# Side-effects (env): +# Exports UNSTABLE_COUNT into $BASH_ENV for later CI steps (if available). +# +# Requirements: +# - jq must be available in PATH +# +# Notes: +# - This script is intentionally simple and idempotent; it does not mutate +# the input report and only writes to OUT_DIR. + +REPORT_JSON=${1:-final-report/flake-shake-report.json} +OUT_DIR=${2:-final-report} + +if [ ! -f "$REPORT_JSON" ]; then + echo "ERROR: Report not found at $REPORT_JSON" >&2 + exit 1 +fi + +mkdir -p "$OUT_DIR" + +# Print a short human-readable summary to the job logs +echo "=== Flake-Shake Results ===" +STABLE=$(jq '[.tests[] | select(.recommendation == "STABLE")] | length' "$REPORT_JSON") +UNSTABLE=$(jq '[.tests[] | select(.recommendation == "UNSTABLE")] | length' "$REPORT_JSON") +echo "✅ STABLE: $STABLE tests" +echo "⚠️ UNSTABLE: $UNSTABLE tests" +if [ "$UNSTABLE" -gt 0 ]; then + echo "Unstable tests:" + jq -r '.tests[] | select(.recommendation == "UNSTABLE") | " - \(.test_name) (\(.pass_rate)%)"' "$REPORT_JSON" +fi + +# Write daily summary JSON (compact per-day snapshot) +jq '{date, gate, total_runs, iterations, + totals: { + stable: ([.tests[] | select(.recommendation=="STABLE")] | length), + unstable: ([.tests[] | select(.recommendation=="UNSTABLE")] | length) + }, + stable_tests: [ + .tests[] | select(.recommendation=="STABLE") | + {test_name, package, total_runs, pass_rate} + ], + unstable_tests: [ + .tests[] | select(.recommendation=="UNSTABLE") | + {test_name, package, total_runs, passes, failures, pass_rate} + ] + }' "$REPORT_JSON" > "$OUT_DIR/daily-summary.json" + +# Write promotion readiness (100% pass) JSON +jq '{ready: [.tests[] | select(.recommendation=="STABLE") | {test_name, package, total_runs, pass_rate, avg_duration, min_duration, max_duration}]}' "$REPORT_JSON" > "$OUT_DIR/promotion-ready.json" + +# Export UNSTABLE_COUNT for later CI steps (if BASH_ENV is present) +if [ -n "${BASH_ENV:-}" ]; then + echo "export UNSTABLE_COUNT=$UNSTABLE" >> "$BASH_ENV" +fi + +echo "Wrote: $OUT_DIR/daily-summary.json, $OUT_DIR/promotion-ready.json" + diff --git a/op-acceptance-tests/scripts/ci_flake_shake_prepare_slack.sh b/op-acceptance-tests/scripts/ci_flake_shake_prepare_slack.sh new file mode 100644 index 00000000000..33acc57194a --- /dev/null +++ b/op-acceptance-tests/scripts/ci_flake_shake_prepare_slack.sh @@ -0,0 +1,85 @@ +#!/usr/bin/env bash +set -euo pipefail + +# ci_flake_shake_prepare_slack.sh +# +# Purpose: +# Used in CI by the flake-shake promote job to parse the promoter output +# (`promotion-ready.json`) and prepare environment variables consumed by the +# Slack orb step. +# +# Inputs (positional): +# $1 PROMO_JSON – path to the promoter output `promotion-ready.json`. +# Default: ./final-promotion/promotion-ready.json +# +# Outputs (env): +# Exports into $BASH_ENV (for subsequent steps): +# - SLACK_BLOCKS_PAYLOAD: compact JSON array of Slack Block Kit blocks for the message body +# +# Requirements: +# - jq must be available in PATH +# +# Block count constraints: +# Slack allows max 50 blocks per message. Our layout uses: +# - 3 header/link/divider blocks +# - 4 blocks per candidate (2 sections + 1 context + 1 divider) +# - +1 optional overflow notice block +# This caps candidates at 11; if more, we add a final notice linking to the job. + +PROMO_JSON=${1:-./final-promotion/promotion-ready.json} + +SLACK_BLOCKS="[]" +if [ -f "$PROMO_JSON" ]; then + # Build Block Kit blocks (header + link + divider + per-candidate sections) + SLACK_BLOCKS=$(jq -c \ + --arg url "${CIRCLE_BUILD_URL:-}" \ + --slurpfile meta "${PROMO_JSON%/*}/metadata.json" ' + def name_or_pkg(t): (if ((t.test_name|tostring)|length) == 0 then "(package)" else t.test_name end); + def testblocks(t): [ + {"type":"section","fields":[ + {"type":"mrkdwn","text":"*Test:*\n\(name_or_pkg(t))"}, + {"type":"mrkdwn","text":"*Package:*\n\(t.package)"} + ]}, + {"type":"section","fields":[ + {"type":"mrkdwn","text":"*Runs:*\n\(t.total_runs)"}, + {"type":"mrkdwn","text":"*Pass Rate:*\n\((t.pass_rate|tostring))%"} + ]}, + {"type":"context","elements":[{"type":"mrkdwn","text": t.package }]}, + {"type":"divider"} + ]; + . as $root | + ($meta | if length>0 then .[0] else {} end) as $meta | + ($meta.date // "") as $date | + ($meta.gate // "flake-shake") as $gate | + ($meta.pr_url // "") as $pr_url | + ( if (($meta.flake_gate_tests // 0) == 0) then + [ + {"type":"header","text":{"type":"plain_text","text":":partywizard: Acceptance Tests: Flake-Shake — Gate Empty"}}, + {"type":"section","text":{"type":"mrkdwn","text":"No tests in flake-shake gate; nothing to promote. Artifacts: <\($url)|CircleCI Job>"}} + ] + elif ($root.candidates|length) == 0 then + [ + {"type":"header","text":{"type":"plain_text","text":":partywizard: Acceptance Tests: No Flake-Shake Promotion Candidates — \(if $date != "" then $date else (now|strftime("%Y-%m-%d")) end)"}}, + {"type":"section","text":{"type":"mrkdwn","text":"No promotions today. Artifacts: <\($url)|CircleCI Job>"}} + ] + else + ( + [ + {"type":"header","text":{"type":"plain_text","text":":partywizard: Acceptance Tests: Flake-Shake Promotion Candidates (\($root.candidates|length)) — \(if $date != "" then $date else (now|strftime("%Y-%m-%d")) end)"}}, + {"type":"section","text":{"type":"mrkdwn","text": (if $pr_url != "" then "PR: <\($pr_url)|Open PR> • Artifacts: <\($url)|CircleCI Job>" else "Artifacts: <\($url)|CircleCI Job>" end) }}, + {"type":"divider"} + ] + ) + + ( ($root.candidates[:11] | map(testblocks(.)) | add) ) + + ( if ($root.candidates|length) > 11 then + [ {"type":"section","text":{"type":"mrkdwn","text":"Too many tests; see the report: <\($url)|CircleCI Job>"}} ] + else [] end ) + end ) + ' "$PROMO_JSON") +fi + +echo "export SLACK_BLOCKS_PAYLOAD='$SLACK_BLOCKS'" >> "$BASH_ENV" + +echo "Prepared Slack env: blocks generated" + +echo "[debug] SLACK_BLOCKS: $SLACK_BLOCKS" diff --git a/op-acceptance-tests/tests/base/dummy_flaky_test.go b/op-acceptance-tests/tests/base/dummy_flaky_test.go new file mode 100644 index 00000000000..ab703a457c3 --- /dev/null +++ b/op-acceptance-tests/tests/base/dummy_flaky_test.go @@ -0,0 +1,27 @@ +package base + +import ( + "math/rand" + "testing" + + "github.com/ethereum-optimism/optimism/op-devstack/devtest" +) + +var dummyLogs = []string{ + "rpc error: code = DeadlineExceeded desc = context deadline exceeded while waiting for L2 block", + "assertion failed: expected balance to increase after funding, but it did not", + "unexpected revert: contract call failed with error 'insufficient funds for gas * price + value'", +} + +// This test only exists to be flaky, and is used to test the flake-shake system. +func TestDummyFlakyTest(gt *testing.T) { + t := devtest.SerialT(gt) + + t.Log("This test is flaky to test the flake-shake system") + + if rand.Float64() < 0.05 { + // provide a dummy log, from a pool of three messages + t.Log(dummyLogs[rand.Intn(len(dummyLogs))]) + t.Fail() + } +} From ae73e9a732b45b13c079620fb3ed2cd390fa092b Mon Sep 17 00:00:00 2001 From: Josh Klopfenstein Date: Tue, 7 Oct 2025 03:09:03 -0700 Subject: [PATCH 016/117] beacon client: use new fusaka endpoint to get blobs (#17736) * beacon client: use new fusaka endpoint to get blobs Fallback to old endpoint on error. * unexport method * tests: rename clientWithValidation -> client * remove comments * Update op-service/sources/l1_beacon_client.go --------- Co-authored-by: geoknee --- op-service/apis/beacon.go | 1 + op-service/sources/l1_beacon_client.go | 71 +++++++++++++++++---- op-service/sources/l1_beacon_client_test.go | 34 +++++++--- op-service/sources/mocks/BeaconClient.go | 60 +++++++++++++++++ 4 files changed, 146 insertions(+), 20 deletions(-) diff --git a/op-service/apis/beacon.go b/op-service/apis/beacon.go index 4be95f53f61..76f61ca01a3 100644 --- a/op-service/apis/beacon.go +++ b/op-service/apis/beacon.go @@ -11,6 +11,7 @@ type BeaconClient interface { NodeVersion(ctx context.Context) (string, error) ConfigSpec(ctx context.Context) (eth.APIConfigResponse, error) BeaconGenesis(ctx context.Context) (eth.APIGenesisResponse, error) + BeaconBlobs(ctx context.Context, slot uint64, hashes []eth.IndexedBlobHash) ([]*eth.Blob, error) BlobSideCarsClient } diff --git a/op-service/sources/l1_beacon_client.go b/op-service/sources/l1_beacon_client.go index 7400c7e9482..c5aa3afbb86 100644 --- a/op-service/sources/l1_beacon_client.go +++ b/op-service/sources/l1_beacon_client.go @@ -25,6 +25,7 @@ const ( specMethod = "eth/v1/config/spec" genesisMethod = "eth/v1/beacon/genesis" sidecarsMethodPrefix = "eth/v1/beacon/blob_sidecars/" + blobsMethodPrefix = "eth/v1/beacon/blobs/" ) type L1BeaconClientConfig struct { @@ -100,6 +101,19 @@ func (cl *BeaconHTTPClient) BeaconGenesis(ctx context.Context) (eth.APIGenesisRe return genesisResp, nil } +func (cl *BeaconHTTPClient) BeaconBlobs(ctx context.Context, slot uint64, hashes []eth.IndexedBlobHash) ([]*eth.Blob, error) { + reqQuery := url.Values{} + for _, hash := range hashes { + reqQuery.Add("versioned_hashes", hash.Hash.Hex()) + } + reqPath := path.Join(blobsMethodPrefix, strconv.FormatUint(slot, 10)) + var blobsResp []*eth.Blob + if err := cl.apiReq(ctx, &blobsResp, reqPath, reqQuery); err != nil { + return nil, err + } + return blobsResp, nil +} + func (cl *BeaconHTTPClient) BeaconBlobSideCars(ctx context.Context, fetchAllSidecars bool, slot uint64, hashes []eth.IndexedBlobHash) (eth.APIGetBlobSidecarsResponse, error) { reqPath := path.Join(sidecarsMethodPrefix, strconv.FormatUint(slot, 10)) var reqQuery url.Values @@ -170,8 +184,8 @@ func NewL1BeaconClient(cl apis.BeaconClient, cfg L1BeaconClientConfig, fallbacks type TimeToSlotFn func(timestamp uint64) (uint64, error) -// GetTimeToSlotFn returns a function that converts a timestamp to a slot number. -func (cl *L1BeaconClient) GetTimeToSlotFn(ctx context.Context) (TimeToSlotFn, error) { +// getTimeToSlotFn returns a function that converts a timestamp to a slot number. +func (cl *L1BeaconClient) getTimeToSlotFn(ctx context.Context) (TimeToSlotFn, error) { cl.initLock.Lock() defer cl.initLock.Unlock() if cl.timeToSlotFn != nil { @@ -202,6 +216,18 @@ func (cl *L1BeaconClient) GetTimeToSlotFn(ctx context.Context) (TimeToSlotFn, er return cl.timeToSlotFn, nil } +func (cl *L1BeaconClient) timeToSlot(ctx context.Context, timestamp uint64) (uint64, error) { + slotFn, err := cl.getTimeToSlotFn(ctx) + if err != nil { + return 0, fmt.Errorf("get time to slot fn: %w", err) + } + slot, err := slotFn(timestamp) + if err != nil { + return 0, fmt.Errorf("convert timestamp %d to slot number: %w", timestamp, err) + } + return slot, nil +} + func (cl *L1BeaconClient) fetchSidecars(ctx context.Context, slot uint64, hashes []eth.IndexedBlobHash) (eth.APIGetBlobSidecarsResponse, error) { var errs []error for i := 0; i < cl.pool.Len(); i++ { @@ -225,18 +251,21 @@ func (cl *L1BeaconClient) GetBlobSidecars(ctx context.Context, ref eth.L1BlockRe if len(hashes) == 0 { return []*eth.BlobSidecar{}, nil } - slotFn, err := cl.GetTimeToSlotFn(ctx) + slot, err := cl.timeToSlot(ctx, ref.Time) if err != nil { - return nil, fmt.Errorf("failed to get time to slot function: %w", err) + return nil, err } - slot, err := slotFn(ref.Time) + sidecars, err := cl.getBlobSidecars(ctx, slot, hashes) if err != nil { - return nil, fmt.Errorf("error in converting ref.Time to slot: %w", err) + return nil, fmt.Errorf("get blob sidecars for block %v: %w", ref, err) } + return sidecars, nil +} +func (cl *L1BeaconClient) getBlobSidecars(ctx context.Context, slot uint64, hashes []eth.IndexedBlobHash) ([]*eth.BlobSidecar, error) { resp, err := cl.fetchSidecars(ctx, slot, hashes) if err != nil { - return nil, fmt.Errorf("failed to fetch blob sidecars for slot %v block %v: %w", slot, ref, err) + return nil, fmt.Errorf("failed to fetch blob sidecars for slot %v: %w", slot, err) } apiscs := make([]*eth.APIBlobSidecar, 0, len(hashes)) @@ -267,17 +296,37 @@ func (cl *L1BeaconClient) GetBlobSidecars(ctx context.Context, ref eth.L1BlockRe // blob's validity by checking its proof against the commitment, and confirming the commitment // hashes to the expected value. Returns error if any blob is found invalid. func (cl *L1BeaconClient) GetBlobs(ctx context.Context, ref eth.L1BlockRef, hashes []eth.IndexedBlobHash) ([]*eth.Blob, error) { - blobSidecars, err := cl.GetBlobSidecars(ctx, ref, hashes) + if len(hashes) == 0 { + return []*eth.Blob{}, nil + } + slot, err := cl.timeToSlot(ctx, ref.Time) if err != nil { - return nil, fmt.Errorf("failed to get blob sidecars for L1BlockRef %s: %w", ref, err) + return nil, err } - blobs, err := blobsFromSidecars(blobSidecars, hashes) + blobs, err := cl.cl.BeaconBlobs(ctx, slot, hashes) if err != nil { - return nil, fmt.Errorf("failed to get blobs from sidecars for L1BlockRef %s: %w", ref, err) + // We would normally check for an explicit error like "method not found", but the Beacon + // API doesn't standardize such a response. Thus, we interpret all errors as + // "method not found" and fall back to fetching sidecars. + blobSidecars, err := cl.getBlobSidecars(ctx, slot, hashes) + if err != nil { + return nil, fmt.Errorf("failed to get blob sidecars for L1BlockRef %s: %w", ref, err) + } + blobs, err := blobsFromSidecars(blobSidecars, hashes) + if err != nil { + return nil, fmt.Errorf("failed to get blobs from sidecars for L1BlockRef %s: %w", ref, err) + } + return blobs, nil + } + for i, blob := range blobs { + if err := verifyBlob(blob, hashes[i].Hash); err != nil { + return nil, fmt.Errorf("blob %d failed verification: %w", i, err) + } } return blobs, nil } +// blobsFromSidecars pulls the blobs from the sidecars and verifies them against the supplied hashes. func blobsFromSidecars(blobSidecars []*eth.BlobSidecar, hashes []eth.IndexedBlobHash) ([]*eth.Blob, error) { if len(blobSidecars) != len(hashes) { return nil, fmt.Errorf("number of hashes and blobSidecars mismatch, %d != %d", len(hashes), len(blobSidecars)) diff --git a/op-service/sources/l1_beacon_client_test.go b/op-service/sources/l1_beacon_client_test.go index 0e39d192891..38c02b1de51 100644 --- a/op-service/sources/l1_beacon_client_test.go +++ b/op-service/sources/l1_beacon_client_test.go @@ -233,20 +233,36 @@ func TestBeaconClientBadProof(t *testing.T) { hashes := []eth.IndexedBlobHash{index0, index1, index2} sidecars := []*eth.BlobSidecar{sidecar0, sidecar1, sidecar2} + blobs := []*eth.Blob{&sidecar0.Blob, &sidecar1.Blob, &sidecar2.Blob} // invalidate proof sidecar1.KZGProof = eth.Bytes48(badProof) apiSidecars := toAPISideCars(sidecars) - ctx := context.Background() - p := mocks.NewBeaconClient(t) - - p.EXPECT().BeaconGenesis(ctx).Return(eth.APIGenesisResponse{Data: eth.ReducedGenesisData{GenesisTime: 10}}, nil) - p.EXPECT().ConfigSpec(ctx).Return(eth.APIConfigResponse{Data: eth.ReducedConfigData{SecondsPerSlot: 2}}, nil) - clientWithValidation := NewL1BeaconClient(p, L1BeaconClientConfig{}) - p.EXPECT().BeaconBlobSideCars(ctx, false, uint64(1), hashes).Return(eth.APIGetBlobSidecarsResponse{Data: apiSidecars}, nil) - _, err := clientWithValidation.GetBlobs(ctx, eth.L1BlockRef{Time: 12}, hashes) - assert.NoError(t, err) // The verification flow does not require a valid proof + t.Run("fallback to BeaconBlobSideCars", func(t *testing.T) { + ctx := context.Background() + p := mocks.NewBeaconClient(t) + p.EXPECT().BeaconGenesis(ctx).Return(eth.APIGenesisResponse{Data: eth.ReducedGenesisData{GenesisTime: 10}}, nil) + p.EXPECT().ConfigSpec(ctx).Return(eth.APIConfigResponse{Data: eth.ReducedConfigData{SecondsPerSlot: 2}}, nil) + client := NewL1BeaconClient(p, L1BeaconClientConfig{}) + ref := eth.L1BlockRef{Time: 12} + p.EXPECT().BeaconBlobs(ctx, uint64(1), hashes).Return(nil, errors.New("the sky is falling")) + p.EXPECT().BeaconBlobSideCars(ctx, false, uint64(1), hashes).Return(eth.APIGetBlobSidecarsResponse{Data: apiSidecars}, nil) + _, err := client.GetBlobs(ctx, ref, hashes) + assert.NoError(t, err) + }) + + t.Run("BeaconBlobs", func(t *testing.T) { + ctx := context.Background() + p := mocks.NewBeaconClient(t) + p.EXPECT().BeaconGenesis(ctx).Return(eth.APIGenesisResponse{Data: eth.ReducedGenesisData{GenesisTime: 10}}, nil) + p.EXPECT().ConfigSpec(ctx).Return(eth.APIConfigResponse{Data: eth.ReducedConfigData{SecondsPerSlot: 2}}, nil) + client := NewL1BeaconClient(p, L1BeaconClientConfig{}) + ref := eth.L1BlockRef{Time: 12} + p.EXPECT().BeaconBlobs(ctx, uint64(1), hashes).Return(blobs, nil) + _, err := client.GetBlobs(ctx, ref, hashes) + assert.NoError(t, err) + }) } func TestBeaconHTTPClient(t *testing.T) { diff --git a/op-service/sources/mocks/BeaconClient.go b/op-service/sources/mocks/BeaconClient.go index 89b07d0670c..18c06b6f22e 100644 --- a/op-service/sources/mocks/BeaconClient.go +++ b/op-service/sources/mocks/BeaconClient.go @@ -81,6 +81,66 @@ func (_c *BeaconClient_BeaconBlobSideCars_Call) RunAndReturn(run func(context.Co return _c } +// BeaconBlobs provides a mock function with given fields: ctx, slot, hashes +func (_m *BeaconClient) BeaconBlobs(ctx context.Context, slot uint64, hashes []eth.IndexedBlobHash) ([]*eth.Blob, error) { + ret := _m.Called(ctx, slot, hashes) + + if len(ret) == 0 { + panic("no return value specified for BeaconBlobs") + } + + var r0 []*eth.Blob + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, uint64, []eth.IndexedBlobHash) ([]*eth.Blob, error)); ok { + return rf(ctx, slot, hashes) + } + if rf, ok := ret.Get(0).(func(context.Context, uint64, []eth.IndexedBlobHash) []*eth.Blob); ok { + r0 = rf(ctx, slot, hashes) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).([]*eth.Blob) + } + } + + if rf, ok := ret.Get(1).(func(context.Context, uint64, []eth.IndexedBlobHash) error); ok { + r1 = rf(ctx, slot, hashes) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// BeaconClient_BeaconBlobs_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'BeaconBlobs' +type BeaconClient_BeaconBlobs_Call struct { + *mock.Call +} + +// BeaconBlobs is a helper method to define mock.On call +// - ctx context.Context +// - slot uint64 +// - hashes []eth.IndexedBlobHash +func (_e *BeaconClient_Expecter) BeaconBlobs(ctx interface{}, slot interface{}, hashes interface{}) *BeaconClient_BeaconBlobs_Call { + return &BeaconClient_BeaconBlobs_Call{Call: _e.mock.On("BeaconBlobs", ctx, slot, hashes)} +} + +func (_c *BeaconClient_BeaconBlobs_Call) Run(run func(ctx context.Context, slot uint64, hashes []eth.IndexedBlobHash)) *BeaconClient_BeaconBlobs_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(uint64), args[2].([]eth.IndexedBlobHash)) + }) + return _c +} + +func (_c *BeaconClient_BeaconBlobs_Call) Return(_a0 []*eth.Blob, _a1 error) *BeaconClient_BeaconBlobs_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *BeaconClient_BeaconBlobs_Call) RunAndReturn(run func(context.Context, uint64, []eth.IndexedBlobHash) ([]*eth.Blob, error)) *BeaconClient_BeaconBlobs_Call { + _c.Call.Return(run) + return _c +} + // BeaconGenesis provides a mock function with given fields: ctx func (_m *BeaconClient) BeaconGenesis(ctx context.Context) (eth.APIGenesisResponse, error) { ret := _m.Called(ctx) From 051a4295726a58ce373389b368ea47eedbd520fa Mon Sep 17 00:00:00 2001 From: Changwan Park Date: Tue, 7 Oct 2025 22:49:51 +0900 Subject: [PATCH 017/117] op-acceptance-tests: ELP2P for EL Syncing for unsafe gap (#17752) * op-devstack: engine: FCU retry helper * op-devstack: Helper for L2EL p2p removal * op-acceptance-tests: ELP2P for EL Syncing for unsafe gap * op-acceptance-tests: ELP2P newPayload not retained automatically * op-acceptance-tests: Better comments --- .../tests/sync/elsync/gap_elp2p/init_test.go | 22 ++ .../tests/sync/elsync/gap_elp2p/sync_test.go | 232 ++++++++++++++++++ op-devstack/dsl/engine.go | 27 +- op-devstack/dsl/l2_el.go | 25 +- op-devstack/sysgo/l2_el_p2p_util.go | 23 ++ 5 files changed, 320 insertions(+), 9 deletions(-) create mode 100644 op-acceptance-tests/tests/sync/elsync/gap_elp2p/init_test.go create mode 100644 op-acceptance-tests/tests/sync/elsync/gap_elp2p/sync_test.go diff --git a/op-acceptance-tests/tests/sync/elsync/gap_elp2p/init_test.go b/op-acceptance-tests/tests/sync/elsync/gap_elp2p/init_test.go new file mode 100644 index 00000000000..280fdd55ad5 --- /dev/null +++ b/op-acceptance-tests/tests/sync/elsync/gap_elp2p/init_test.go @@ -0,0 +1,22 @@ +package gap_elp2p + +import ( + "testing" + + bss "github.com/ethereum-optimism/optimism/op-batcher/batcher" + "github.com/ethereum-optimism/optimism/op-devstack/compat" + "github.com/ethereum-optimism/optimism/op-devstack/presets" + "github.com/ethereum-optimism/optimism/op-devstack/stack" + "github.com/ethereum-optimism/optimism/op-devstack/sysgo" +) + +func TestMain(m *testing.M) { + // No ELP2P, CLP2P to control the supply of unsafe payload to the CL + presets.DoMain(m, presets.WithSingleChainMultiNodeWithoutP2P(), + presets.WithCompatibleTypes(compat.SysGo), + stack.MakeCommon(sysgo.WithBatcherOption(func(id stack.L2BatcherID, cfg *bss.CLIConfig) { + // For stopping derivation, not to advance safe heads + cfg.Stopped = true + })), + ) +} diff --git a/op-acceptance-tests/tests/sync/elsync/gap_elp2p/sync_test.go b/op-acceptance-tests/tests/sync/elsync/gap_elp2p/sync_test.go new file mode 100644 index 00000000000..f3961fa94cc --- /dev/null +++ b/op-acceptance-tests/tests/sync/elsync/gap_elp2p/sync_test.go @@ -0,0 +1,232 @@ +package gap_elp2p + +import ( + "testing" + + "github.com/ethereum-optimism/optimism/op-devstack/devtest" + "github.com/ethereum-optimism/optimism/op-devstack/presets" + "github.com/ethereum-optimism/optimism/op-service/eth" + "github.com/ethereum-optimism/optimism/op-supervisor/supervisor/types" + "github.com/ethereum/go-ethereum" +) + +// TestL2ELP2PCanonicalChainAdvancedByFCU verifies the interaction between NewPayload, +// ForkchoiceUpdate (FCU), and ELP2P/EL sync in a multi-node L2 test network. +// +// Scenario +// - Start a single-chain, multi-node system without ELP2P connectivity for L2ELB. +// - Advance the reference node (L2EL) so it is ahead of L2ELB. +// +// Expectations covered by this test +// +// NewPayload without parents present: +// - Does NOT trigger EL sync. +// - Returns SYNCING for future blocks (startNum+3/5/4/6). +// +// NewPayload on a non canonical chain with available state: +// - Can extend a non canonical chain (startNum+1 then +2) and returns VALID. +// - These non canonical chain blocks are retrievable by hash but remain non-canonical +// (BlockRefByNumber returns NotFound) until FCU marks them valid. +// +// FCU promoting non canonical chain to canonical: +// - FCU to startNum+2 marks the previously imported non canonical blocks valid +// and advances L2ELB canonical head to startNum+2. +// +// FCU targeting a block that cannot yet be validated (missing ancestors): +// - Triggers EL sync on L2EL (skeleton/backfill logs), returns SYNCING, +// and does not advance the head while ELP2P is still unavailable. +// +// Enabling ELP2P and eventual validation: +// - After peering L2ELB with L2EL, FCU to startNum+4 eventually becomes VALID +// once EL sync completes; the test waits for canonicalization and confirms head advances. +// - Subsequent gaps (to startNum+6, then +8) are resolved by FCU with +// WaitUntilValid, advancing the canonical head each time. +// +// NewPayload still does not initiate EL sync: +// - A NewPayload to startNum+10 returns SYNCING and the block remains unknown by number +// until an FCU is issued, which initially returns SYNCING. +// +// Insights +// - NewPayload alone never initiates EL sync, but can build a non canonical chain if state exists. +// - FCU is the mechanism that (a) promotes non canonical chain blocks to canonical when they are +// already fully validated, and (b) triggers EL sync when ancestors are missing. +// - Previously submitted NewPayloads that returned SYNCING are not retained to automatically +// assemble a non canonical chain later. +// - With ELP2P enabled, repeated FCU attempts eventually validate and advance the canonical chain. +func TestL2ELP2PCanonicalChainAdvancedByFCU(gt *testing.T) { + t := devtest.SerialT(gt) + sys := presets.NewSingleChainMultiNodeWithoutCheck(t) + require := t.Require() + logger := t.Logger() + + // Advance few blocks to make sure reference node advanced + sys.L2CL.Advanced(types.LocalUnsafe, 10, 30) + + sys.L2CLB.Stop() + + // At this point, L2ELB has no ELP2P, and L2CL connection + startNum := sys.L2ELB.BlockRefByLabel(eth.Unsafe).Number + + // NewPayload does not trigger the EL Sync + // Example logs from L2EL(geth) + // New skeleton head announced + // Ignoring payload with missing parent + targetNum := startNum + 3 + sys.L2ELB.NewPayload(sys.L2EL, targetNum).IsSyncing() + + // NewPayload does not trigger the EL Sync + // Example logs from L2EL(geth) + // New skeleton head announced + // Ignoring payload with missing parent + targetNum = startNum + 5 + sys.L2ELB.NewPayload(sys.L2EL, targetNum).IsSyncing() + + // NewPayload does not trigger the EL Sync + // Example logs from L2EL(geth) + // New skeleton head announced + // Ignoring payload with missing parent + targetNum = startNum + 4 + sys.L2ELB.NewPayload(sys.L2EL, targetNum).IsSyncing() + + // NewPayload can extend non canonical chain because L2EL has state for startNum and can validate payload + // Example logs from L2EL(geth) + // Inserting block without sethead + // Persisted trie from memory database + // Imported new potential chain segment + targetNum = startNum + 1 + sys.L2ELB.NewPayload(sys.L2EL, targetNum).IsValid() + logger.Info("Non canonical chain advanced", "number", targetNum) + + // NewPayload can extend non canonical chain because L2EL has state for startNum+1 and can validate payload + // Example logs from L2EL(geth) + // Inserting block without sethead + // Persisted trie from memory database + // Imported new potential chain segment + targetNum = startNum + 2 + sys.L2ELB.NewPayload(sys.L2EL, targetNum).IsValid() + logger.Info("Non canonical chain advanced", "number", targetNum) + + // Non canonical chain can be fetched via blockhash + blockRef := sys.L2EL.BlockRefByNumber(targetNum) + nonCan := sys.L2ELB.BlockRefByHash(blockRef.Hash) + require.Equal(uint64(targetNum), nonCan.Number) + require.Equal(blockRef.Hash, nonCan.Hash) + // Still targetNum block is non canonicalized + _, err := sys.L2ELB.Escape().L2EthClient().BlockRefByNumber(t.Ctx(), targetNum) + require.ErrorIs(err, ethereum.NotFound) + + // Previously inserted payloads are not used to make non-canonical chain automatically + blockRef = sys.L2EL.BlockRefByNumber(startNum + 3) + _, err = sys.L2ELB.Escape().EthClient().BlockRefByHash(t.Ctx(), blockRef.Hash) + require.ErrorIs(err, ethereum.NotFound) + blockRef = sys.L2EL.BlockRefByNumber(startNum + 5) + _, err = sys.L2ELB.Escape().EthClient().BlockRefByHash(t.Ctx(), blockRef.Hash) + require.ErrorIs(err, ethereum.NotFound) + + // No FCU yet so head not advanced yet + require.Equal(startNum, sys.L2ELB.BlockRefByLabel(eth.Unsafe).Number) + + // NewPayload does not trigger the EL Sync + // Example logs from L2EL(geth) + // New skeleton head announced + // Ignoring payload with missing parent + targetNum = startNum + 6 + sys.L2ELB.NewPayload(sys.L2EL, targetNum).IsSyncing() + + // FCU marks startNum + 2 as valid, promoting non canonical blocks to canonical blocks + // Example logs from L2EL(geth) + // Extend chain + // Chain head was updated + targetNum = startNum + 2 + sys.L2ELB.ForkchoiceUpdate(sys.L2EL, targetNum, 0, 0, nil).IsValid() + logger.Info("Canonical chain advanced", "number", targetNum) + + // Head advanced, canonical head bumped + require.Equal(uint64(targetNum), sys.L2ELB.BlockRefByLabel(eth.Unsafe).Number) + + // FCU to target block which cannot be validated, triggers EL Sync but ELP2P not yet available + // Example logs from L2EL(geth) + // New skeleton head announced + // created initial skeleton subchain + // Starting reverse header sync cycle + // Block synchronisation started + // Backfilling with the network + targetNum = startNum + 3 + sys.L2ELB.ForkchoiceUpdate(sys.L2EL, targetNum, 0, 0, nil).IsSyncing() + + // head not advanced + require.Equal(uint64(startNum+2), sys.L2ELB.BlockRefByLabel(eth.Unsafe).Number) + + // FCU to target block which cannot be validated + // Example logs from L2EL(geth) + // New skeleton head announced + sys.L2ELB.ForkchoiceUpdate(sys.L2EL, targetNum, 0, 0, nil).IsSyncing() + + // head not advanced + require.Equal(uint64(startNum+2), sys.L2ELB.BlockRefByLabel(eth.Unsafe).Number) + + // FCU to target block which cannot be validated + // Example logs from L2EL(geth) + // New skeleton head announced + targetNum = startNum + 4 + sys.L2ELB.ForkchoiceUpdate(sys.L2EL, targetNum, 0, 0, nil).IsSyncing() + + // head not advanced + require.Equal(uint64(startNum+2), sys.L2ELB.BlockRefByLabel(eth.Unsafe).Number) + + // Finally peer for enabling ELP2P + sys.L2ELB.PeerWith(sys.L2EL) + + // We allow three attempts. Most of the time, two attempts are enough + // At first attempt, L2EL starts EL Sync, returing SYNCING. + // Before second attempt, L2EL finishes EL Sync, and updates targetNum as canonical + // At second attempt, L2EL returns VALID since targetNum is already canonical + attempts := 3 + + // FCU to target block which can be eventually validated, because ELP2P enabled + // Example logs from L2EL(geth) + // New skeleton head announced + // Backfilling with the network + sys.L2ELB.ForkchoiceUpdate(sys.L2EL, targetNum, 0, 0, nil).IsSyncing() + + // Wait until L2EL finishes EL Sync and canonicalizes until targetNum + sys.L2ELB.Reached(eth.Unsafe, targetNum, 3) + + sys.L2ELB.ForkchoiceUpdate(sys.L2EL, targetNum, 0, 0, nil).WaitUntilValid(attempts) + logger.Info("Canonical chain advanced", "number", targetNum) + + // head advanced + require.Equal(uint64(targetNum), sys.L2ELB.BlockRefByLabel(eth.Unsafe).Number) + + // FCU to target block which can be eventually validated, because ELP2P enabled + // Example logs from L2EL(geth) + // "Restarting sync cycle" reason="chain gapped, head: 4, newHead: 6" + targetNum = startNum + 6 + sys.L2ELB.ForkchoiceUpdate(sys.L2EL, targetNum, 0, 0, nil).WaitUntilValid(attempts) + logger.Info("Canonical chain advanced", "number", targetNum) + + // head advanced + require.Equal(uint64(targetNum), sys.L2ELB.BlockRefByLabel(eth.Unsafe).Number) + + // FCU to target block which can be eventually validated, because ELP2P enabled + // Example logs from L2EL(geth) + // "Restarting sync cycle" reason="chain gapped, head: 6, newHead: 8" + targetNum = startNum + 8 + sys.L2ELB.ForkchoiceUpdate(sys.L2EL, targetNum, 0, 0, nil).WaitUntilValid(attempts) + logger.Info("Canonical chain advanced", "number", targetNum) + + // head advanced + require.Equal(uint64(targetNum), sys.L2ELB.BlockRefByLabel(eth.Unsafe).Number) + + // NewPayload does not trigger EL Sync + targetNum = startNum + 10 + sys.L2ELB.NewPayload(sys.L2EL, targetNum).IsSyncing() + _, err = sys.L2ELB.Escape().L2EthClient().BlockRefByNumber(t.Ctx(), targetNum) + require.ErrorIs(err, ethereum.NotFound) + sys.L2ELB.ForkchoiceUpdate(sys.L2EL, targetNum, 0, 0, nil).IsSyncing() + + t.Cleanup(func() { + sys.L2CLB.Start() + sys.L2ELB.DisconnectPeerWith(sys.L2EL) + }) +} diff --git a/op-devstack/dsl/engine.go b/op-devstack/dsl/engine.go index 8cb26507322..b01659e7b6c 100644 --- a/op-devstack/dsl/engine.go +++ b/op-devstack/dsl/engine.go @@ -1,8 +1,12 @@ package dsl import ( + "errors" + "time" + "github.com/ethereum-optimism/optimism/op-devstack/devtest" "github.com/ethereum-optimism/optimism/op-service/eth" + "github.com/ethereum-optimism/optimism/op-service/retry" ) type NewPayloadResult struct { @@ -30,9 +34,10 @@ func (r *NewPayloadResult) IsValid() *NewPayloadResult { } type ForkchoiceUpdateResult struct { - T devtest.T - Result *eth.ForkchoiceUpdatedResult - Err error + T devtest.T + Refresh func() + Result *eth.ForkchoiceUpdatedResult + Err error } func (r *ForkchoiceUpdateResult) IsForkchoiceUpdatedStatus(status eth.ExecutePayloadStatus) *ForkchoiceUpdateResult { @@ -52,3 +57,19 @@ func (r *ForkchoiceUpdateResult) IsValid() *ForkchoiceUpdateResult { r.T.Require().NoError(r.Err) return r } + +func (r *ForkchoiceUpdateResult) WaitUntilValid(attempts int) *ForkchoiceUpdateResult { + tryCnt := 0 + err := retry.Do0(r.T.Ctx(), attempts, &retry.FixedStrategy{Dur: 1 * time.Second}, + func() error { + r.Refresh() + tryCnt += 1 + if r.Result.PayloadStatus.Status != eth.ExecutionValid { + r.T.Log("Wait for FCU to return valid", "status", r.Result.PayloadStatus.Status, "try_count", tryCnt) + return errors.New("still syncing") + } + return nil + }) + r.T.Require().NoError(err) + return r +} diff --git a/op-devstack/dsl/l2_el.go b/op-devstack/dsl/l2_el.go index af38089dfad..5d72ad4328b 100644 --- a/op-devstack/dsl/l2_el.go +++ b/op-devstack/dsl/l2_el.go @@ -218,6 +218,10 @@ func (el *L2ELNode) PeerWith(peer *L2ELNode) { sysgo.ConnectP2P(el.ctx, el.require, el.inner.L2EthClient().RPC(), peer.inner.L2EthClient().RPC()) } +func (el *L2ELNode) DisconnectPeerWith(peer *L2ELNode) { + sysgo.DisconnectP2P(el.ctx, el.require, el.inner.L2EthClient().RPC(), peer.inner.L2EthClient().RPC()) +} + func (el *L2ELNode) PayloadByNumber(number uint64) *eth.ExecutionPayloadEnvelope { payload, err := el.inner.L2EthExtendedClient().PayloadByNumber(el.ctx, number) el.require.NoError(err, "failed to get payload") @@ -226,6 +230,7 @@ func (el *L2ELNode) PayloadByNumber(number uint64) *eth.ExecutionPayloadEnvelope // NewPayload fetches payload for target number from the reference EL Node, and inserts the payload func (el *L2ELNode) NewPayload(refNode *L2ELNode, number uint64) *NewPayloadResult { + el.log.Info("NewPayload", "number", number, "refNode", refNode) payload := refNode.PayloadByNumber(number) status, err := el.inner.L2EngineClient().NewPayload(el.ctx, payload.ExecutionPayload, payload.ParentBeaconBlockRoot) return &NewPayloadResult{T: el.t, Status: status, Err: err} @@ -233,11 +238,19 @@ func (el *L2ELNode) NewPayload(refNode *L2ELNode, number uint64) *NewPayloadResu // ForkchoiceUpdate fetches FCU target hashes from the reference EL node, and FCU update with attributes func (el *L2ELNode) ForkchoiceUpdate(refNode *L2ELNode, unsafe, safe, finalized uint64, attr *eth.PayloadAttributes) *ForkchoiceUpdateResult { - state := ð.ForkchoiceState{ - HeadBlockHash: refNode.BlockRefByNumber(unsafe).Hash, - SafeBlockHash: refNode.BlockRefByNumber(safe).Hash, - FinalizedBlockHash: refNode.BlockRefByNumber(finalized).Hash, + result := &ForkchoiceUpdateResult{T: el.t} + refresh := func() { + el.log.Info("ForkchoiceUpdate", "unsafe", unsafe, "safe", safe, "finalized", finalized, "attr", attr, "refNode", refNode) + state := ð.ForkchoiceState{ + HeadBlockHash: refNode.BlockRefByNumber(unsafe).Hash, + SafeBlockHash: refNode.BlockRefByNumber(safe).Hash, + FinalizedBlockHash: refNode.BlockRefByNumber(finalized).Hash, + } + res, err := el.inner.L2EngineClient().ForkchoiceUpdate(el.ctx, state, attr) + result.Result = res + result.Err = err } - result, err := el.inner.L2EngineClient().ForkchoiceUpdate(el.ctx, state, attr) - return &ForkchoiceUpdateResult{T: el.t, Result: result, Err: err} + result.Refresh = refresh + result.Refresh() + return result } diff --git a/op-devstack/sysgo/l2_el_p2p_util.go b/op-devstack/sysgo/l2_el_p2p_util.go index fc7adf04f36..a97633d069f 100644 --- a/op-devstack/sysgo/l2_el_p2p_util.go +++ b/op-devstack/sysgo/l2_el_p2p_util.go @@ -64,6 +64,29 @@ func ConnectP2P(ctx context.Context, require *testreq.Assertions, initiator RpcC require.NoError(err, "The peer was not connected") } +// DisconnectP2P disconnects a p2p peer connection between node1 and node2. +func DisconnectP2P(ctx context.Context, require *testreq.Assertions, initiator RpcCaller, acceptor RpcCaller) { + var targetInfo p2p.NodeInfo + require.NoError(acceptor.CallContext(ctx, &targetInfo, "admin_nodeInfo"), "get node info") + + var peerRemoved bool + require.NoError(initiator.CallContext(ctx, &peerRemoved, "admin_removePeer", targetInfo.ENR), "add peer") + require.True(peerRemoved, "should have removed peer successfully") + + ctx, cancel := context.WithTimeout(context.Background(), 30*time.Second) + defer cancel() + err := wait.For(ctx, time.Second, func() (bool, error) { + var peers []peer + if err := initiator.CallContext(ctx, &peers, "admin_peers"); err != nil { + return false, err + } + return !slices.ContainsFunc(peers, func(p peer) bool { + return p.ID == targetInfo.ID + }), nil + }) + require.NoError(err, "The peer was not removed") +} + type peer struct { ID string `json:"id"` } From f8817418ba5716efada350b80ec59fdb4dee3ca6 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Alberto=20Cuesta=20Ca=C3=B1ada?= <38806121+alcueca@users.noreply.github.com> Date: Tue, 7 Oct 2025 14:58:28 +0100 Subject: [PATCH 018/117] Add file hashes to the u16a audit report (#17753) --- .../2025_09-U16a-Spearbit.pdf | Bin 177458 -> 180014 bytes 1 file changed, 0 insertions(+), 0 deletions(-) diff --git a/docs/security-reviews/2025_09-U16a-Spearbit.pdf b/docs/security-reviews/2025_09-U16a-Spearbit.pdf index 2e54c36dacf2c929e68dfd813b70c91dd9bf255a..1952120d83e895621d8c8fea0fa15e839d3e735f 100644 GIT binary patch delta 42448 zcmV)cK&Zd6>I$y@3Xl~6IFsQ&Cj&GzG?73Vf1EH7z4I&PXr$ov_}jU)Y8y35)po-z z%3;IO6g7w~AC1yq-@!nZt#U|&z{Z|=^WO7#lW)Hv+;@q9dk}E(>JjNH00Gf)s|;AB zI0^|xo%~LC@J{&{v6{xMC2wBXe6A&YXp-;rEYQcGOd9T$h73*M%GxpG=9aeh^j?DC zeA4DHsRy_wxMz@sVz%P=K2J8ElmaQZwbDq)e;g$ls_Hyw<+zas@)~Z~ z*F#^`Rad8(bdC*Z$BAdxWihl>|1|w=%M>;HQ_*19V|trkCLi;ao`Bp71dX0MFW;nQ zA&i3U5bG{ogZy_IRREl zY6x0d!(I)=uA2Zanrfu0S@risxO9R92QZe~pyqZe`X(wL6W#2p6w<`Z|1TRg(LbSQ z(w&nT1Rs+!0?7(7FfcYUGBh(XGm`}atphPIG?TOgcNj4+G$1e_Z(?c+JUk#TOl59o zbZ8(kFg24w1Xu$xFgCNB1UUE>=cmse$07rcvZB`e4olFxG1%% zuF}R+f4Nb?V{4xwK^m@~= zD8s>0H74g73DRX=RJyi*%1T!{)2enif7iNE3)QG^;V;L*)ttmZR&+G&1~S;{IzO@x z@Bd)`dm1jD*o&UYy&Om)3S6FWhXAYZK&Kd-nqt z_&o`oWgd-L<`N@8J0fqLx5BW3e^`b@&xLh(J0WlvXE#B-7M6NMYMcT+lA}aT*8b12+9CK>oQB5?jA^` zFk>vt@Bq$q_pd6gZk+6G+N>58pbDfiFM4bEo66ihlMoa@f3aQz_Si7@5OsP+?M2-# zm%45o%CC!s%LkxhOf5&o+taow`*X(gqUa@?mFfvX;fCEJUv_j7uDiMSF0GsKyy6ki zSV{f2c}{DYbm~y)ZcYu2#AO*f2EVj9TO<~=iPcQ1r?nE6Yl~!>OsgHN}0d)&v)HWo7~BDLZXNa@{v1A z?YEc9IWcF){aH$u_WmmJK6w%c(vNdtpk6rkErPq9s}aPe0!!1R7$^`Ip|9h6kMMT& zQvz#njohx8*6RxCcl-NMOzxJ82uVgC+wD%{drx#de;v;X=TLCBaKeNV4JZ{7J-k*r zarOS5h)MoWWQeHXzOLyBfJEkdLFkK^A)qf3Z77``SaaKfWZ)mWbt^smIzlZCuAjho z3Tro4-QaWQN^;N^N6U){B+1r>z9QmHMs>KS-J;4Eit(UGLsz6vMUqEoTl|SYhJZ+s zFVR9Ae}T<#90gBIjueLoIQer7QUZ%~OQcI27E#+~%|*LevLmpW^1lOT3lf~o88E7c zgImkJIF>=JIv~{MG}qGxNyj&5y@M}P-OZ&cYxjIo6}7u=%l&bFMhT1{k=?h~G7q+g zb!bYfN6wH5M?lqlWiQ0+b82kp$!Mn*wT^rno?6K{u zr)x5B$nZD@ns1I<#xCybMz4>G{5oBtS~tgboHs``|2ji?6c{58{f_yH|0hI$JWd?w zPwelP;7|D!zyN!&6g^$EpVrG#=Zo}i(zYi^$a7BQ89-$JaWd>rIFoT+9t1KsF*%a~5EOsKT3d6|NEUwgujogpnvwc` znW3l(Fkz^Lg-V#3*#RCLMyc26J$X09mIQ zZb>IF3$O(@tHD>90l{$2G7ITE1hIi>DIIfQjR%=iOglk%F&oSvDFDiYmGGDaGagL5 z#vI(hgS7CHdCx3>K{Cu>28~!50t<>+1tt)|YOa4E9AOEbq-56M3Km%tEG}?ntri1F zVXemnsNZ^MOF&09Xj%e*Lcy}0eTe5us{$5Yz@E1RxZ=(n#eLP6N3ixA2Bske&cS zR_Os`$Tdj-4wG6EpR`fA5BUd?h6F^6ZdR!2o+J~H6APvFK#+S0MY!n?O}I5FLjyQ* z5QdOe>NUVkq6kaMQMAg!$AzIM9jqyAr9FR&8R8~_v4cmCSboa#=d-snmOo<;mc^(X z&!(Ap$R0l)Jb161#Xt9+bACj_84WWURy33}yyu$Jd`iQdhJuD64U72DxLW^ku#=^1 zvwT6rG%{L5=I0T?DBc~%yVE^fRGZ65e0oX4r%jnE@>fxuWgM#YALC!6xTFu3)meXp z)1~Q3>`Bz-u#xjNVjVhs8S#9Irn!pOE+f#jUTNZ8uJDoNuoG z7|AR)FE8Wj&+)HC<6bm;-CTdwvA(*t+~Xsr%a9YOqZ{{jCz0mvI%`VCU#IxhKix+7WCrl>sN*Pz3r=Y68e%gHKERvo@pZL^amPDsdH?RCm!{hES zxfOHcUGr4rQ4H*1isoq=njcg3-q3AGUPO|OLW+HkmbybnGWsJjpQf=?q}hLUBT6=* zJxjfEoH#{m?&|s6>s3_8Oc@Z&|snQqSNnwldux2WHc|*s}@pPA?CcE#j zb@{9n3(Xceij>Y%Qz%kQV@uDeP@@4T;tw?eSV1v^qhnbNwsyzPr9xMR+K z9X0qb8lJ>!f3>#JBF$v0#-DH7F!t7DTU+#GX9?73zK5sCu5Dy1@P}#o-J#U)*IomE z)Ur*HiguRf?DJO9Ql`nY*~FJEd#ySa{L~^iPvtLLw3>TcCD(aJ!PI}=*%qnmd}`7E zl9IWMq#G%}q(QfA#q6}Z@LP2`>j5??+2!G<9qFQIMfWVN>$Vb2lGBsaPS#x+%7eJ4t(?qNT!Sm%HduSHDiRKJV`EPSS3njjBxZUfI2wB@Q}EgSTBA7P0gm zZ|S3#fjjn{S5dmFG+lrFytjP%2H#t>9DSJ@dD30MzDalA>lmI#k^ZC`RI^)8QxwZ6 z&N$+}B?RZYP$bXoLo-bCPgA~c$4V~~>K%pTejB`P`P-tS0dCu%-Menp_>FLPH(S=z zk$&w_4sNBRdB;9{)}6?@GI){^{@%P&HE-tba`&>e*|+&G(xy+L>@H5tkEnV(JI>D? zJHfJ*%RcYPbJIJQH!nLH(X-SvyFGkkQ|e_UyCWhGq5oBf{*!9u5UtJ*d+$h?t38kG zZx?@Qh0}1?kyg6`9Hx_YeRjub@H{=0+B&ej-rsfFt_H9< z{cP`ImuZo8xvv9wM=!iMJ7M|pxMUxQ53P9nbzZRi&F})_)7i8vrsaQ<1;1W-QY>ey z#i+m)x4!bKI3Ew6%&tL><3CGpw1NaVkXYbZCb+6rg1q!9R6KsWE}x&4!?IxX>te~P z`N=Dm|9iHW46lIm)o}TVeohI-5fdyQ4KY4`%<|!Sd3v?_zaqXV*guYIwzb%<7b}00Delt6q>roF;&eV76>KdOge=QqF=cZ7vk^>G7oc0Hu!4I` zZwa}mHLeW3UaJ)Y*00b03!7I9UrZzmHr{%(n2k=05;*fW&yHcA;`%mg2_?48MQ`lB z&0hJ@bULeuxf}bvtKM$X4|+qnp4VjQ)#iE@^(^aI)w8Z=Q_p|4o@;udrYCB8vZkl% z^|GcbYr3+gD{H#4UZ-lh@@B5-%QgKE8%nF>gQu;|%If#a@f05SWVSdj7Vn5X|B(Nl zzsR4y6V(q==ZNf3ITXF_b(z=Ii_DAzr{e(*X4!}Qh_Ssd6I0`THx36J^gdJZ%xJ@` zcbU{-KMr{S9GHKrH{d2@%F+vR#1K4jFAjB&I2_Nc7R+jyae7BAO{Pg7MrHJNxf@68 z{o_4@Q6dYbdQYAS`iww}Od8Pxj647s;WLU{2@t&c_#rb0oZGRe`}Yf@_2`g!Wd5Fjlpz=J|O$5jMEoT$bLcS9v*ZE^>CSKY}E$kltMjWghCed{nR7xcavNf zbUKJkBd&i1(hiC+!;t~G`zHX^D$>qp@MosI%CzzT$TO~ctLOkm)7E0PKxE-L^lja` zuIPzK9RQKhnI&rp?C4drp&?Seb)*k~2(^VpjiZr?JendxD7@;6$Q%F>sy_OZ@Fvs< zA$=^_6OlbYsELp{Mc;k`8T?11%#hCh6Nqkf#BG1(U?t^AS7bep9NF8C-2GP_3RMQD z&vXe1dKndHKe?r5xA(tmC{#azKDV?P!XB`w3c0=PuxUo5CYrv4ZFSM`Md$Pn>7w&v zw2ng61dr)sQKi4DiPr5VTHU#cHe#cRRy&)~F3WLfK{S>VRE<%=tdJDxlWNHkZuG@6 zdIo>AqaOy*A1Zgqj~+d$nB+&5@$%FBkCPYl@4;nR&X>RB`Ep(i7iZ%#8_gyU0Wq8{{!AZQs?DV{BjCw37wZ7q<%N+vH(ZOJp7^ z`szedcVzlXNjm@!rsrz3#~DS~kI5GFow`Xj-<2RtXe9{a?wTO1-bfIpKIJm?DVM2F zxlDb^W$bq(5Xq^TQq}pDMaLk~O-b~gbbck_?{`Qbv-#EVY>D(yXOI5_v-7Tmlfe%Y z0XLK3g($Q2G3pHgH?!bB_YDF#IFsQ&C$dgv5CS!D6`LO z3=RS@HIv~#C$j{5+zJ6Qv*CqT1OYaa;Xfw?F)=bRlK~JEf325IlNvV=hVT0;<_HJN z-L2MFZn0y#;)*M4@7^3A^oc3+u>mS3|2{pyx&ZImY=A0C3>vjwJ$k3r^ZfS1HFl%r z6?CHxx;Nk27q?f>Uu)eVE6tX=+jfQ00UdV6DjRg?h?QsQnRXuscK8edVDRhRU7eNj zdid$~?JfYSe_#x{2O`+uRlr>Ug}V^1$CEmIM$QdB$K~g`yboo%pn@gK4@Gi8p$^+n zx1TrT{h$ps4Ca%`e28Z7bvzqw!~O+86N$UI=j$*G>S8ycv=j#ajHLnTK^WAs?HSLu zx3BJF-!1C0&Q{xtIvd4Noyzqu8?~=)um1i{qGe@lf9Ue`>f{{ma2XYQ^Br6P z`aj?je<*|IQgF#AAIx@T?|#3&v3#?NtJ-@~E$5RHSRd*+fi;F7vfft&YuB15s*Qj` zi-}`pkBzXDkgH~}ppCZ4WRKMqvZW;(5?P-$HIsR>0Fh*R1%318;VlAE#?z&!g6q2u zsQ$amaWYvRfc=54Z+H)dosV~48mv>(ISaW)e-y2&C7U3w<_NV}Zcr)dM#;yhx!Mqo zmxN#hyW_}3gL&K^JFv#Hki1kbFaZ?YKZskfr@8b<#@QGTguohNf)vntaJex-g5b0^ zMLwWwX`mD9=)pS9$VI+6v$&H(_0=(*=u%^?ax(jcU^-F|>~;-*;LF8)x%_QDjpNz7 zf4Y?8V^kMI15a}6k-+mY?@NSrz-m(JpKpmmQ1u?^56(@9}eGi454|ZP~tXtLKf4zpL zC0E2KhnSK4+;k}|XsdlC@{}QEIlyX3hFnAp6-xkvi1tMLa$ptwr7AB2vKG6mbEG<0 z)#=Omtgrq@Px0)LsPob8%YrpF%z`m_$p~y}18~g=*wB!42_dJDbIOQf*_aa>(w^jm zOFooPs{N^F**OJ9UkECDQY_=PXP&(lpsPjyq7?IL`7X}l@sajJ*B(hb8|{HOSQjR_ zvRbBVtp?AvSdAeUs*I9}G3rcmq-m^GXKSR6z+7!E9()af9(~9cPx0GzDs?A*vSG?FeL zpqmZYQ3~h=5&-bJSp!tff88LdkO+2meqQ~5I4xt%El4I07;PqJ9)dI3{J;A^0)M9~OKXX1>8nX| zu>D>GfCJzGa&fi!-S)q@(L$I3{!oLYTDpK8{%HW9w{~-L5@2KV^z>x4a(8uO1-n?W zI@$ljPs`fI72pYWf3X8VK3zcepnrsMceH@W>1GZ3SApM~0#LFs2RXWeekaL*|K)Um zNC`=T*xmk33?hWv@0#}i3J17?K>yLk8tD2@u9BLX62Jjy_ zzD{5#fF;o0736PY34(ke`?>->Kma!vcaXpD-;V!8$Q--?3mbDc$e=?G3-UkJ*|?co|D)o+%<^tP$mokZ zTG@jjd-9J-`}b+Ghm0-c(PQ)b$pv8H;Nkr*A7moU?Hoa_t^gkXe_SAl3jf6yBK>c+ z05&;!e;GM7Ri^(lGXI20JDP(nY#glsoNsslKo=LFH!?e94mjVu0r+x2M%n`8_0OOH z*jOFGZjcm!le?Qgz!L0&{ChKb-T>Idf1Cb=cmQk?e-JN#P4W-o1F%W`LHqzV>3<_$ zb^x2qAH)G*ll_A@AuITUxBzVOe-Na*;vWR*f3EZgLAopdL6Cl`|3-X}erkUZq=UvE z1nHpp2XO<~wEiGSKkYvV(og3Pg7nkVq}!46r1#a|Gj8R*{-vXyNA4C5cYfBT)?f%bn`K-LM_SbLzu ze_vG~N?87>0*SD+@%XFkZ#UT8<*x)th}B;Z!qfT>YlvFb-cHsa$G;*VHk-d7L>Rlj zAVdTEzaT_}zu0j=mi(vG8%U}n z#?>C^YW-IUNYg(Q-aweSS-XJ#+6~AG+&sa5B|vJp|Cu02&wp-aS97q--!ecn_V^1z zWb*t2IUz;8{(_LM-hV-egg$>bLn`@zT>i!2KOa77zwh3Et`+t_Pow{NDftI$f4aGV z?LfLV7LXURze1FOZZ0-nhU}0#fdgWPeEsil#{bcP=FfHZSGI%%*vprN8zL187eqZ? zE{@*^gUA0rQqBMMdhpM61bJ%yFaCWu13(}zkU8?oBG_Co%r>JXqAEbTWTqO9hM)C& zExw4JLK5ss_DmNEp;X}x6-cx+f4D6uhqe@~Bqv}TkQVG%u16DwXaBs}o?173ZJ{o< z3k*;WAVHTFA1}~h)egx~UJk16p<*~zC@9vi;GWItNa`R5Xpf&r@^|&#zvG;G!MaSR zGOF%aFM{(do9Af7b+O0xTE-;qCRv{8hIV_o$4!U>4v4QX&Y2cR;EyZ7e>?T}Vj3`I z6l>|7^!aAC{iqowpO5}(z>S>CB~(@~malO}Qf8J-R%sZUUxEkiS{!3zZqOabOXsi6R6{sP*KEFBU?%b=BoZ6+Y>u3qZy&d@i$n; z^z|COX>S9$vquNi3wrY+e{B8wYIwLMUrIxX3+lxQNr&BdXE_WDCF59LM@}sTefXR~ z->ddGuaY17t4UU-t%?Fj>=#1nx|in!Yzc0vM0DUmpfx+`M8p0{%&meBEC3!aRBhWmTGp) z2kc25e7@cFnWM63M0il=NRQB&$l;;%L!F+=b9lL3zOn};f&lc#nLRbGxJ1wLpkN(* z(NcpO3p5K!iLae^e;hcj2{DD0I{BZ(F=Fvxo6B6*^t4B7>^GuPaz(0UR<{pDjs(lX zBTqMFp14O!w{E6zsz>LQN%iBZj2k+xbwki-HB9+ASrG-Q2PL*7688kAM??!}qpMwM zqe<64WA$K62gPs%!CTUG{ z23W4xtURQw)B>#zkrwb9nJ2}uT5B0u_Hd%ed7T~+G@(f|%b9!(ytJ1XjD+^oGsTBj zcnoqFWyK=Gwy$8&K2P5JDT|+7kyI z54?0`@hzK-N$MlEmgmXO5R8O%vkX$UtqKzNXi+S zHM&Us=PU6}sRB#?mGG7|&|8a@*PFrxRG}JhH_s#`dWi77h)T;IMM~ek1#^9oxID0} zju(5Fe?}bL5vB&=TO27meVhM`MG<)9=_&JwWQOg>MFfQk%DUV#GCj~ZcN3)?zp!|B zXJ@u3*k|G(*y>cDW8fChi<16X+xpOfyUtjdLv=zkI_z`=6+Xw2x@5;kek$%b<%Qx6 z;2MqRb7@9)lmW6rF_`F%JARll`Xg0FM9l19f0W&hKvAeLqeftVK}1?rfKMAL$*;_n zR;-z|r(+4YF(*^FrWR7>Af6wllIz2r2(1L=hwtykM_zJl=el5XgJ5?^GVd&so5Vw( zc0DVPpn5}2G0=>f_D5tt% ze{HGG;toKAh}ckx@{zpX#++O}aGxW(0(^{$G4Gcqtfnv298W{f#3na_Jv}qMpI~|2 z0lSClP?1w}t7$w(6iB+|)B%Q>Z|uQd(Uz}4kjWLAD^r^X%rJ6|GY-BWUf z7P0qkZ7bA!@$o0VH538&vm%46imu8DMg~am6;AIC-egH6zugMk70|Z|d1pEie}_tt zJarE>TLbMp7|Kea$s~i6{t8v1tEDL%sS1X9DW%U`-`Z1SMWi)Ol{qtoslf6V*@L1# z#h~9zVFNcKhd}rAA=^jf`s?|;a@P)d=I?6TBBg-*N~VyDzBVV0*AJA1g&lP5sN6H2 zduOL={pkGT9CEU1FyhRDjX^sve-E-95BGGaLxn0vTHH&V95IJUrz6C&mo@w)&z7`b z6xovezY@LHlj*#^FTaqQ7)-Bmo`52LC-oJp_FP`PZC^hg>j@{7M%)ll)m=)fwpVKX zI-SCL?Sq9 z`|}KVPmz=Ht!lQxbRI6sN2ae#I-z>L2`=U*7xi{Np7!Re8C zX2o5oSvWCj`+Yawo+}LNxkFjfjd7&1Z==$NH&jSY1qR?B*&TuA>4+1B0)mZp4I$iR z^oH65uTlx70!r~uliU|Zld{Xz!RVet0XjlF@nnwUS1_tk72QP1m`Q6T<7M7wjJ~%v zz>tA8B;M3)9c8J=e{XOMuE|Bbg5Cn3!;U`EigCr&T^YQ5-X?wX>Uu#$=llRMii`0L z&TTwy=Ia`*IHt4d`@+2!9UbTC_qBrrBGBfAElX)LS!pn2J*JAaz7`lOsV9)C)gX|D3MBT+>icm(lUe_#|wfAI_>uN@=^j8FWdW$oB zmg7SJf@%Vke-nZG+?(g-$g3sp17>m&R;D&rT%WB88WXs07OuFeb7zj@qOtl|n%;%k zCoPV*_y&^*ly8en7?dO;45zhH)W$IgOFF*ydOc6Ltda~DSoIckrMXTJZ!!O#W3al#V$Vz2ew%_{*f4&*csTuQ2!c>;>?>LaEg)zuU z{E6%}nJwtJa}bD)X;qQ0$W0YG!X-R?Ta}0y<#=_PzdiS{G@yLfa)~Ic!Y72MF%SDe zw1&2Ztg{@ZXCu_$kr`S~f(F*WVSGKUlXI^!8WZ5^YS?BPA)p#XqM0{8rE2z8SA3Os zCp#^SfBYQ*;dhUZ*mh*+pGJf3Tf(cCJ%zH?#fAhwT$IQ8$@kN%1zLnqw&I+|FzSd} z_YYhUf!XWJbiK=iSZP@tpN6Q$|5yNEjufI?6 zH(UPLhR@*khV2?#VmiFbqo{o1QZXy9uEgwZGz27Pagxim>)KpG_M0ZU75R1yw)FfTc!+@M2xa#hzyI@M{LAOqvQUwc! z0?z3u1Eh}Iz6P#_%y}t=ED{EXM`FBeL)GOs1(6O7oF9A+jey$@vm8b}Df~3J0pkis z$7Nj;O9?RIgYu8V6d%pu8UtklJUIsw~K zpl0S+Q++I|T`j&6iRMT)8&50iutfaJUY>cd@Zkxh6*Hq%eZgN?!RQXP!JbO7H^LD zWYw6ii(tFBgUh_0C6xn=#rI8x0HArMTkSWZ(LyWBz|?oe-_H(Z;hwjSU+l8>FOEM_ z6vl`}u~>MHPOlbm>8Cjb$d3kFyl8KoyK?>hk7UsFv-eE`LlL<`o0gT5e~LagY8hGY ziPrO5f<3CI*abbP$Em?a8s-TPpPB5cZ}i7@Wkbf>6-&Bu^hr=W5!O*O<`?LjZl6yv zbkoI}u!)BqGecXZF$ZzQ>`%hBJD%Z}YUfzKpG2f7ovEd?^I+UGD=;NEv^sYye!N_=cwfj#F2dA0lI0X+9j0 zW90~ueTo{|)kFBEUnukC{YWDFd(-X`e#3(46g?i{DZQWPVa+_cm`oVB#>FZ>rFVV4 zqkIQ9(CQ~mbGGtmF`y7qQ-X@uN;5*KT(jE7n4*UjfTd$+Y@|PU8EBQQU~O`K{2d9ThR=$F7_in{y2{tS!at( z82>a4OWQfx65n@2Mn4^vhoC{WixE^l{ZNZqw0$@6vLZ>#nmrk}8j$bhY+Pn#ty54L zV$(j@J=pmR7%;t#d3($M{Bm~&3jZ!7r`VgE{)el%`r zcWp=-hL_%FDG*=!eA-vL0t5DfSkrO7uTv}Mo{89dbOZ_d(`mYzJ5cwq9ODRxdePKm zOEeIYHu6Pu#QsVMrsc2ob48{y+$*LE{MR_>U*_5Dd0~QjiNuir_N%^LY&A9He`Za2c zAXAHAnWF=|e>wS6&m1ooPE*5geB6$2d_S%1C`(A!_R~c8tPeT&-(pm9+J&H;(pGjs zq50ydCl$!a%n6DrV??7_o~(@`8M{Q$kv}^Xnr^y|U+B+PVi3Gr=c&VtEK*Z2Z1HOx z>f+82vP?6%-utv^o1uo#>-Z?Rr3c;k(nM)iNYE&{oPzh)-`#CX9%RJMY88 zi{E1Ri%F7=p_%GQf*6y~pulvG2lJ6TVDgTXa4w;!>ziP<8vL}C4zk_}H5e~wf{}D! zXtAzI>%;8b@X#{SJyGS7LgHL5k8O_>9^HRh+mSzY13~WH1uZsioe_qtjBQtd#zx4Z$s^*VMD^=0o!7JS?9W zI=YuRhBiKpugNnO6p#TAYJgAP};!!o4A%>RllG1dT{c-x~o5Bj}it~FB z0ZecCEgT-_w_UukeC%JyKl9!B(L>^$*KRk81 z@AFIF;8ch-dyzx|-Ct!Z$LPyz*awm%~0`cp2g9*!0ZZB`?I(GbhECCGsc^Zd5_5oWLe>bS~ zKH;cs*KSv?S+})N(8MD2oVveEhwAGDou?hFT=ozB!EtOvY!6I^9baP8E;x9Yn^Q{` z=bpXl@8ub7P%aiIQ`kNtn8xV*V2-xiG_reXf8D)w7`YL;cA9o)m$7}kjFz88pt1iE zwDYo)cjxQXfqluz3J^BnXRJ;*2FO3USd91&pa0FKH2uJ(#MqZhVfcf`zy+1H4fBfuoql?8M zd575}&|s#_Gu(G|rg`+YeLq0L<>1tu*sjXq#HLFo77|7+r-1uFG<-UaP(e~NP|zb^)eV~o^BLN;Rc8Keg$j*Scs#I&9~BR{hr)tIx1 zck!D9Va%p5#>QQ?mDtuIs{&;u^t^1!zUtIttM9!>tP8+@eQlL{*#b2x`lPx!o*2Dp zG_cWvtSJTD?|a?PJ8~KU8p7~L(RA>3Pr0-mM5|(D$s`G1n-ihDe{|^B(MFrEEmS{2 zhGNI`@DR;U6u3DrsC0G@`C{hR;fAY(?-(&I?bPY4vrx zn_*rhKriXGi2xG0fBY5WMp9M-%tNDq`5o=U%*_-PuZJ#~kolzARm5Lku^$C&e}zL& zZFfY6)#J&)uxXCW>Hf6GQS#Qkx`4H@()lK8<}Q5np^F3bNzQ!q)Lv%Uz@*OOxk`uV zv-`k}+bc($N7Ayq53H_agh*Fo?aJZV#%iq!v?_x8`YO_Oe@FhGm+BbS*~SX8e)?K4 z$UUdOlB%wy@G#%t)P4HoZPIMAX~MUGNb2`-BeGY8!SW{P{j6TH5pFA{Wx zy`oX!|1R1bJFU0exr(Rwm?BpWTSxlELK>S6Ej3+iY*{cYJ~+vJ@Oa-jWE2TB|D{CR!Z}j4n>XP#tQ=F zCAmvcZ{hb3v{u^`JVH>WDK; z4}&h549;+%6ssNnC2DGN#HnogekpMArHtFw1HE%!e}$)ka8{0xX-e;;0NR*i@I5R= z4PPPp36KMYyOhrc0XuX|LnhFbl$rQE%?ms95XtL;Q!r1Cfvx+y_Iq~G*1Eg;LJM0l zj_>_=-;)c5b*r)?HrEMwA6K_%s&RE>S;ptX_H(~FE?tNGgagZ2oDApcMIbxo(qd>B za-;Qsf2KG!cwHpgZP_pXitdw|@HF{s8M1$Bpf>oF7=L9Zt)Mkf>*2P3e+665 zhqg%MV_l@zwXYjIM`1x)G@4&Qw#0bwC3=W^WkFk7hngV=fxO~A%Rq}MfaCo1sB})8 z5(&{;s^0jMl9r>1Bx+}f7b8A8D&{EnkiR^Ee--vmo>9YsnD=+Hxfx0ZgsX8;F4%?T zi9J2vM3!&YS>lF^o}{;2`#-9Z%xIf`&$rStMXog%{aV3C`W7iiXtMiQ#aH(Gwqb;( z%!eQg-#9|c=UXY9=3t|o>CZ`3VFf+Y(GB%Gx z2PM)zR9y@x^k04o?2^VM`nv2S_X`%^>6=uCk9-kovCFp%+~bkwc1>!ETuvUhE#NbZ zZyj$v675?%tOlkawXg;XI5$KkQvu|we>AQPAysBUmp62C#sfPX>DVBS0RzmAWBvjB z7)c(#cT4wSx9_fxKm7XT{H}5sGeul3A<;su&MBJFz4jzhF0&|Dz&= zj$RBWs+@2jmY!<$_njug-4dYYNmK=CrerWx2X9-AS`6hRsJCd*1kUr?Nj|1&f6t;@ zl||irY*V`WJY)Q|)XN8sGnS6T`gd^X*5a`7Zb(#4g! zCO|>@@aZ#pMz*m_8R*2V`k@&5fW3&`12LS5mXDMjd>R$dx*Ra<$h1;PDtH_h@4uLl zPSM9o+_P*T8Z-<~^kOphmn<~_8hBzCR=-u}zxsvu$+O`q;Q?`jM6tLVe^A3dtZuNI;VsNX`&X}!DA4JLjL%N*n9 zMHyTun7MfENOGuZwjk&Z*fvMJP|SY{-SIN1*LI&&8Nk{2;Gp^L+Bs9YQ;Iu1zn#HM7{+)qy{=(kxc+6f4_dprgIKukn1B# zV9+gkHO_`cpPYuD#;0{1$1y?h}uW_!YBJ59Ro~&>WljUPqGG?xtZXe*hhWXe$d}pJUtU(7HAE!2^epw3r&*yoB%7;P?f3Re$a5-J1Z@tbrNt-A1{8pJY z_Ok1aOW%ICddpl1(7=TGZ z%GhkleZToOA2FBCQCs zk8mE0T%pI|sIvLqLG%NwKGw$9CNhF@XzH_f<>RZVL=OIJ8V;%aK`4NcW4%3YF&5u9 zkDUD~H^>ujml=5wwnL#?7*{l)wuQePTvijTf8Wb>x-(%)=8$Gn{k-gB2&BE)`-x3@ z;Nq?&3pFvQT}FA%FxeSXt>yTQ{R}g`GDo`4`V;`DLhgRqR|tpOf*YO7KW4|FY&C4G+?jEm`f*ux;rLPOQfJan>V9(?05oWmb)GLXOO+{s?dZP$#;KvjW-S}y{3x@%k22?Yv8P!7$ zCZ9v^ehalN#P;GUnE-Vf3uSB1Yn=)ce_XUJmDe7@;5AjPnp%RR53A3LhWfPA25<*$ z$&UgIepnrdZxd_#{WVx-k$qh;s zZFgbQD4>1hrhVvfW4GDPM4@N#e?s<-Q_&?}jp39|n+^6%tyxr<%;Cvfj4&@?y#bL@ zt%_2=Y3%`eeYME7y6^U30}7Trt+!iDgGNxDBBxrVD=Ji-7I(eV|KM>=eKPr|!8!&Ys74aU-KoPgTgR4m?kBUlP{XWg3-08b62L>B5+ zV~sZOE^2|f3AT@67DT99f63;5OyI~d%RS-hbn=IRv?FfLcsi=gmbgyr$biPL^)l~~ zW0J&KRa#n?8VkL4Z1HtLXlmncM&!*yyCwU_`YzH2a?}K!LpDnd-Z8`EJuTXK=0+eL znJ7*lNfK!?35+f>&0`Z9(;=q5h|9n!yMBmgPx;`05;V1_FlXX^e_23C5dHLInUXg_ z*!?Z_IW`|{qo=vPUYFj{Yq?YHk`}AyiM34Rx=}P%XXV*wY=wXi-$^|gxi0`cK*GOA z%8MOdZ5ZxKfb)~TAJms`z#Wru>;`Oeg4=VB!8o=Yg#5YbTn@u3UGFc{rV3>RX^mOw z*=Y9I$d;7d)>#w_`l1{eRDVKQn!be4XA2h#MV5VwT6$6Ju~H+(`Tp)z>U`Pj;t2?k zi23oVLdZX&+grWbiJN|2h`nKq42(3~#}X78`V_YPa+fo%>PY$NvHOvlshH*PO3sjn z;*!#I&_Kc5+a@Z7>QaMkMHl^`<8AnLkkzXqEFvUOx)k$%W54w3PJat_ynT{T6sF@l zcGuOjyr@=_JzKfs!TEe=$B=i;OVw#eDxbxDR)6YzQsWQpTpx5@CRLmAF*qU$wHjGa z7*PY*tvOdqQr`tCHrAIgiYWJQUA?x&f}bS4w!d_X5jMBZN)NBO0y%F1nh3AMT5si{ zUfu2MeMa{u^q|apbbnx!pKogBI$*4=C3z+GYd?l~)}~uL^v65=p0Z7*qTBFQc^8&r zzmYum@0?~_abHAnhV_@s)__@(Ds1q+M-=&>MjgFYe?(FaitMHjdbIOuai8-JWy5Sx64VfFV~bpMcA zzo%vKJ8}Nkg5k1rl}9!`)fK}GgeuHK402TaKd>w=sJB+27q7c`@AU2m8*;K|s^x%;y^go%Xvfd~3`$C(-(ouF#D zNJ?vla2wG#U*f(o{q(QZB+;a?=Psk9c%Nco+h{N=%eV+)B%VX%ubZ;@wkc58FrubP zq}6Ldan$*}J0bLn*PD>tGE(7G57`6G=5*emwR( z9L=9Jyy|*>bLld41W&n_8hHh)1_NCNpA4Qf*lM$cyF!_c*F}*O|Kv`L`E1VxdsaJ& zHlQ)_z<)!hJe+^Ii26eBsw4b1Bu9%fz>c#O8pJE{)8 z(sDePnR1?b!bQK4cw}=JrT%9k#8v}JCe%!{?0@v^mt(%4i1nDeO(dD091W`RUXn=2 zQqT~TJxbmZMU(SMxQfP%QfziVnAEbDF_s)~w2B8(`l1}!f9Dj-iv^yL73t}rfQMzF zX>-#1f=pH!`zeERQ0pYllnS@WgMVic{`rC=FIBr>GMy61K&fQ?ay~Yi@tq#b zUI!z69TfPM*H69jg`Y8mO6o=%ZDZ%xtJJ9ZrN!R*GPln;!vM}}(}CK$OTr9YEtL?5 zpyKnmv27hy7SZF{@BAdXx%fSX$;v(w0G6rjCW~C?6id^&akKdc)8Hl;E$hrHKz}O< zv~6rl6W*pv_>cY}u@+ArU044GPo%l>B;J(GSGwINSnDkBwr_xO#YB`S2P&DbqT0T$ z0TQyIxs| zt&7Nk_4rdlIwWnBL%M-JJsGl8sDFcV9sQIgubffNt=8P`?_iq!$`#o6$l}?lQ*0G4p56_36q^_kzW5O-AoyDfyRXBhXy^u*yugvu9rABay62XM1MMeuj!|X z9*MTEOnA55q&;K3{C|yq-9c5UMEiS#RI~Ly&v(y4Z|+~2%RD5`T+mZi2)R9B$gTSM z?5}8cMlL|;7TKlE^6^VAL_Uvf8M|OX#RgT+r1v9izl0)GVGwnrv$V~ZC@o)kZ4}>s z>@o0Iy@Jx50vY&aD%v$AUe3e(9FK@33Buz*@tY(b}R9`FJ{uGqK54 zO(YB~G3f{lz<(r^+%Iv|+zd61=g>ySnypOBILA=afv;ya#oKLW{J%q+O|ESn3< zWkBNb^X@`ONg<~s)y+HVk2Pdc$=@GDeQrK|ujGZv5DX`@q|&cJonYsOE=KswK{H3! z=#jx_wANb-7o5owaOrDhWQRK>g(199(X3k9D8amp;eYL_IuFJBwtKp&i}z&r49%UL zbk$Tl0Ypu9CNGwYxrTtpMX;koEVINq0s|AB>wR2(fTm7tU2=JVmp?=YmT1#&|0XcZ z#&KWt=6LjySUEORV~bm_RB-;a<%0a#HVsIdAV3)G+!t_?;j8xmF7*dLEPWV>C&_(< z_^CvVEq~}x{rPfr{LMyAU^zNXy08g|-|y!h~q zR4Y=ZFD_8E7Ui69DOATs57+bI2`CG-*d;)!LVs(Ivl~d{3vIO~XY1*r@6$NTJu~QG z==k|wp#LQzl_BA-to~R5-dyYw*^ADjD@&(`1woz*rc9pc1bUoG^hD6Ubf)x`8s#{{ zg;3c`9Y3#M(I$()XVqg6%z~G*&m5Ie&?WMb+}6f=E=5ea{_vIq znSb^1ZB4U_@0_Bnl@P0&#G0=nr+q`s#3F&#jRJ<>85@pI81JYXw3)+A%C%?V5AQ+v zT-bB$ErPrSGS8RZI;P$z>m_mxTB4ISX%U3$KD=IXMVpFTaij5%ppI`1KZ%JgZQf=QH0>OrVx^y~ayFNgPZsN~t4*PXyRMd2=fD>V)Czlf-8H zn{I3N(TYb|oKHwRDx=0b1rClBN1x;lWx*mx2SlvlnO}HiK5*1Hv}(TlI+Y|6lz;Sr z99XVrfg28Cn5_cX~9Ht1mEMplOgQZc#du~U^D=c1--O75m#D6MWlgc>aWapVk+~BeB-p)4^eycH z7a>VlUMul-{;E%ZYW(5$5`9P#KYytvqEt7s%0tL1Q!A~IsTLF6uTPYDHbmb9qMV#O;}r=^Cm-$3pIre_JTTJNq=tSuKVo4 zrdh6!l_NvTyt|>l%D>(<@<*yZ16(RN5HKFp((W;AY(hG@=4D_QRdcfYy+xf5v-Ns@ zo-AN}Ch0eKuv2!RM^Oy(O!(zL>WOQ^_nFHQoHIfM1-tZOS?Y0~XQX@Gpg8HpWju7} zWuAMoyR#)a#O+Q>{hc%}hJWSR0Jh%ZBw3_Y#8Rcl_DOoku!DyL(%cTn5CuW zeK6NZcUhsJ@siEpk}9^w7X++Mr4uKR_fH)+y@VHp?9vSiDpuzCm(2A*@6qUqzKF4^ zN75%+r{*~?^hx|T6T6kcdu7%S9n~lY3J8dqf|&GYs_OxIHea@moPVX{H(B|xRWs|{ z(Uwzo;iq&mD}T+dbdczxbfZeB+16TFsjZ*QWF0t2M6*}QDa?;e+MdKoP9;3%5r50* zxG^pkWcyg@&{XZWC~!T7Sfum1*%hDW=bg~Yi8c#^cJ6n-%ho!LGck^w`{$rsoF1<@ zagnYM-_{-1Cu350{z+ z(tZv18KrR+3~^qmZ(A(0uBiiZpDG*RvpB7nEY5?xI6P(Tmkt-OLNpEQKj1dpr&q(l z^^46??~aisbEa-ER}3ZV4pB_Zr*xuw?d;rJA7z!TpX8OM9^6a4 zs?cNb2T4<1BOhi7%`o6IiOR-Mas^vNh2vnnikjRXik87VfBsdscFYsF6A+%^I_vJly>ar5&l%@l zR~S_tzuawiV1FJZu{_Obj?uj~@a%#lJc*>I4hePD|GN0mXv({oQQARHQG1c-?McF? z0ZwZxsf2L}c4bluC{_7B*-TSY#+dmIGldw7(${kD4O;Pe>>5Ew@R2qK3tIsK?!__K zHnv$5mL5o(=IbxkT26Uqu!>unjF^8M`%oOVSg!uFdiPSd6}>Un%CNv_A{C% zBhDvG)mAGx@zg!3usMp;#cayDr0~as#`9gm-R)Uoe!S>yD+JyHo?}V(Y$v`)M>M&K zT(-lr$;r)rNOg}p`Hbt967V1-Kb$R%_2tI|91d^j@W)Ae>| z^t%1jnSa^EGk&&)7o+aj?@b+CZ!r}kO66&yp-ieoP4#hDuOp6AQZwC)D$SYNCL}3I za==NLb#!TqR&#r4-ioX{!I$ceFNE7mf-o@$$3Pm*YArFhgmc_Egf`bxWG;HLt$ca(`Ol*UJneEfW8--m!^J;^DRKu*hnS zbp`f_<{vM?egCjaejfrrlcVy7QfZJUDClU`x?RKwq9r_x2mxOdxmBLwrJyA=^R0zf zp22ZtAU~yA_MEp`O!-YR$aQBDi{Kv}Gz49T7RU^ydlB=OgY`erVXa$7;{dxmk$+A*I@2r3hzp;p5(y2J%_&`L$UxuDUlm{V zMOINgy|pE!1}hv;j#!0&;-8Sx@rJ2H?4%7*7$J@@K39PTmenc>BcjvCqrAIoS zj)EhU?{>{TKRGM{-yMK-xi!USX1Mm=ajDJpQS)DMkKEV{;G_c_UjXa~G* z*{vnXz#XrheZ7z*G(Kx~%T?cD8bI)_p0vo7Jii3q^K*#62!uFeU3rGEzj+iOQT zXci2%F&==^HW`B(*2YxqUj!Fo^ti5UKiaGLMqk$)DpyI&?$<9!c{<jdK@jEnsDtT(vPo+IFR_`fqxgo1mE0*=beih z6g*jV;c)9`pCcdf>XK#h=#NA|xph`m0T(Q@)pNRX&qZ~Wdv=RFo^!QjybX!O1B>qD z(Q(=~(fE|0<=yU9u`Td~3YgchCq9De;-%VT`l&Lk3WF3W2;_9?i=|XcPZl=29j{~F zpGJcFGK*V z%FUJJ$J!qhKdOdC$eyn^2Av9i7~Hsg)ICX<3PPGgdv3^v`F|2uDigiGPF%HFBrD04 z`_tZtsk$s3UbjQQhvUTNl|LKiZdp?K7@cN0mawZgJ+ckiQ>4sBp7uyFlfW6~mgrhg zJDf6RWJRnj`Aoi}pDdANpflo#BedFKf3e7{YM**O-PhJaO`H|Jr{E-)VoffUlgVg> zNEX%R3n^@MxPPT?vdN>Fc{ms^Jc{5aG?(dHnkdFs+!oO$70k9+yJn~60!9+)a2pFn z%^#5+9_L!~J7EamEki&TK4#VG)d6nv59?lY%EYEZ<4tf_QXoNutVCTFC#BMKBfFX8_bSmtbISS z+R;Pa`qM!6$T?jcy0#Dsl#0Q^kN+&AghzUj{0%RSYA7*6Ow1tF8+P$W%oM-HrVIZy zkMqDm&VQ_I^kCEy!kj$0+ojhBo3$L4QoH*lwa1!wSjS>)FCX^%85;H5Eu-GP0XZEy zG{b@Ncl2HypQH}^MZUq+7JrQL`5eb@c3FlTs6ws0r%LfQMZvbLnGUJ)p?GhUx^FdJ zCfQra<3!%9=nGP(lu6!b-fnLrFGISK-oCL_E`Q9IpxLptmbDK@Q;Oy4?KmGXaN??L z@ayeGX-aqT#SrU^Z`zzfQOJzL81}r~n60TzC_Xgmb2eAK1l{We#98te?_*USf$V^Q zfcXB7AQBSS!W5vT&iXxA$flQc0p7L>|6Hnc1cylKJ&a*ToxzpbduN~cgAeXI-ocy; zV1JfA(MA4oN^KYCo27^kc4Al-7G8*K^mK876yz>$N997h^}Hlo!mG)9JZTEY^65}# zaOpwCGa58k8hmI98gxx)+S6K_cQqv+&;y^92BO&mbFDRGEBSbA*1DkQVJN`4z@qK{>?+V?<5$-JsH=rTqJlGz=7_O-&M8#CsfM z%A0oHC>%FMjl!H7%79Nxv+GiZ-2^R z0l-iq3zjfeuU~T}FB5B8%+|LrRW|3^9QbHQ%z=nO6~XF5oOjNquMLi~h=WJXKicXd zCuFi=_VF5(i1RFs!m?$zy|d5oH2i5UxA~AHB%uSj*>N)}pYakU6S&;37F zv|v$O&#Wum8|;{I+;Y&;Qe~)^=0{xxzgc#NE>l!s2WlM2m@4|TUmqFKZPNXrn4q%& zU!)aEwsi?Vr-xjII*7whNGjcR$yRX#*6F$sp$`$CN_AVv=9QCJNm*ic8h`7`tHWkl zn^tnqNj)nQ8n3EJN7C;@fhSYL(#mw-Ww4#L(Mps70W91So?B?A&7zJ>%1}09uMQb- zboU1D%Uv{NuWB0;;gq~_7pSed=wNT@|6c%KG@#2$7-=N&(}_DBC#UNK8*Gh?YdVSU zV-H~PlMFcoL)fb)g7%q(zi29ObxK8 z5(6V1tFB=5EtrxwEY8)XR50g|aANyAqhhkJY-xXij-dnbaybd@|9`s}&SZ-o&-*Z zs-7~t`Zg7l!%4+e1Apvu?%&j%URQrNkvJ`3Sn zMk>cLcN;RKIv%eysQUr4=bnzjVAO+oF_H>)IkH3FDc0NI$K@tuRV>Qp=y{;waO@Sz zo#ApFPH2DXu9E%>{abp>v=nu$$e6Yg-IngstH~7aY)w%Y0e{u?eO%VsVT9kDBUxt- zT5Dd7_~*A%Hy#M(lzdBS9T!Sx(a(JKK5ovG84W8*{fB<&1NqDVjRXYbq1H|u_+TZr zGIUw%^Xxuiw9R*;T+fr;re$OT%v`Fe&a}abnt7Mv;chdw=CV5-+H|NHxq3e%?fZhr zi2>b4wj%lW-E@kaBX4r)QvPeIzH$1-)MY5(68VClW z{1Ja3k9NOF@(z06BCeJad2Q>FI0c$a64En2+RJ;m<$q`*%^>h=T3m$z_@^*RH| zT>gz-i+^7|uuFPJ@!_aG3J97xL6E;5wKx!WObq>Z{N4MOG=6IEr5_A%4339w?LuYd zB|3^{8&NEL$~!*!40U6#=bYDRAF3TsQN+4SeHR-nV@yEpHtFVeRH0 z)I;F;48v_@)=IvDVSsqaQmN4=3PZSOjb&t-}zv}}OiZ9B&8<&{D!hh4*rbKKFhJU8;pBl&~`hb|Q--q9bKc4KKwifv{4y>xI z9y2hSfx7z-4#y)m$eC!d=!#?h(e2cOn_k(;(qcL{OpeFG)^_jz)<7x zDwa0rp7)h=N<)-Nav{`C*_WwLe&@=ZEVvC23UT{9NPWD1TliRe}2}n6(|fGVWF;$Zx8h z)|g9>I&xef#8_e8vA?ClXWyil{Jt|aH)J!@jQ=b$qN9#eos&iMwU29#J~s>z-^vG) z`WM{CR8^uN4ZMJ(tk#)QMh;SXTz@({cI98*%$8|lVrS6-09-0lI^5N1m?}ttmJuuv zXNa@zANCeLWxUGFKLme1WZfQ#N|)Fk=l9j-Q#!cqCd*&O&>>>0n z%+svs_hBI^?|w*VO7ed5z@Kyl^}xro(ah8%af+lhAyw{tTOg^Vz=RM~1b>{VJe!OG z?e62@?d|hnk6yjspTBecm1*^#Bb8Xp`;Ez>Fp(D%mzW=obj_8iYx|<_!D%ks;~GRY zbUQnNYnF}p;M*C;1tR~c&7Twk9Nu&g%eo|U^@g8_FU6+!Av{lwp5vra_~@wJf2Yoc z@Co$~_kbG@B~81pKvY&0hkwK3SCYPV`!NU!$~szH8a*C!rOcvJ^g&R=7s5)_wNrJR z2vD)^a?N19sDBuV#?x>!rHH3^(O_PttX38Tmf-@#`iJgKkTbMQtYRp|~Wf9mqZu!c_OFS`4CtzkhOTrW*|a1=pUI zUojC!C_*8tm{jXQSDV$y0)~C!jl`fig`T>t>zeo8g^^+^fq)h@$knmT5&e4d!BrKtDYR=#s$dR$Je?L3W@f4$v(079I|Q7;u7TUy;vy zxOco8*>!^Q{JFRAVxC40a`$$4=qom2TZ+%R9#&$bFfy~ z6#(t$8q?ABxM*D%bjL+an%ha?o%Lfe z=r>j^-_p6F3}i)vC!~)vUSy05&1NQL9@aRD93}0@$bWgs?&vhrx);XZ|8?N}N3fHZ z9JOmStCfTht1^IU?2VAl>Eo6>-C-F=tMxS0I1Wp^1;uT8cQ++$YJeLS$n6nSH>m22(RoCqIK4H)WXH1XQAR!!AP%aMy#`Gj0z-$ZIIT}qE;ChmueiL88OJ1 z`x^}BFf>hx2DUa3>)felMYKzR?QISiRvxf8Mt_$pCzQ%GkM($>9Sfkl`$Yt->xcTv zzj}Ihh;e6K3?Mz+BZ(eUK;uBGPl3-0hAQ-;TB{TNlP02W--WFPt~0IzYAxmvz-0MV z1jSnmGrE!;J^)j6cPuCmq+l_)(I4&64!Uh7(CL9i#Qd(*RXk3`g&r zTYu;<8>$U-a0wRjp1JjQ$X_g8v(<#Eg`BYDIH4LQ?pe&ORUBUgf(v&Ap+HERijGIT zZ1k~;`^&2P-1sCN&T`V~{9_x$FIyh+J4oV+-mLwUbS8wuB}cQ7eF7HZ>9^UPy4Jm! zfW>FGdcBLGXIL+G%;uUv!D>UTUGJ`Y;(sl|)m5Rsy#4<^t5(u#L)xxB&!u7RL4St5 z)jaJs1`E0+L%(X5|0JU;>!fq5MIaa(gY0o!&e|=G<&S!?#4_B$$Z7GZP(n#tGdqXQ zeoTI`In*q9k=vo?!01~KTkkn~_7+KR^j0I*wl`HLokNU_E@+xS41^-dGru#a-+yo| z77R2{((2y!!8jNGH+yx>sF+`PYi@jq-V6vhvoEoTYxQKk*ogC#)sRkEfiG;?_&*`f;URqTa&(Ki&2ct6qPNQ1Z)9D) zI)F6v6&REAs;W~o!S9%Jq$J6Yj(?C`ocIsNB;}bWFWFCxvDcofi!0u zurlutKrYxBaq0YWn*1JjiaY@=8!0?tXi0=a6i#hL)$L@d$u2bRj-j|@5Ak2M|@J5!tZ zBXft?g87))Y2}$=hwFnEPjru;TyA`xMaA4X?h*aqu5^=cu(7rB1lx(IfM1PwsWaaY zF~H)lP#K2%UrqzdZ9S|zjenwEl-_fUgK<)*PxD_vLW;3j9M~Q4x0VejxPaZ6KF^_$ z%QWeNI9N?}g##MrQ2%$!mRNg|`Z~zpd0408;~?!8-{);B!004ZOmt_PC0P##oeUnd z!_Ya@E9PI+lyupS{dSF2DVu)#g!Y)Xlb*k3sBrzJ{&6zU%6A_kfPY?1KJ^*OKUxAt zxhoEXiytV9+7r%1p{245+uZnI!l!VnIvxHgPLdGMf`k9Lp8o8MVn}%Cu|ATGdAyLr z8|ttv4%E8-5og?9AZB}x2ocbkPHa?Lmy_u!%zdXfrgNo?7abs(e%}QSaCuvmh*gaA zSeg(K9?KtIfCSn@g@3yK>IK>w23 z`)zU#iq?<&SxH0g0tjyyQ2V%oBJ1$DH?;Ssq6E2+loY%%<9^)kY5bM&>0FtbDtC1OgOO1ou>#o#c9ChZKG zk}*(&+#p8UC{yZ;D7;eN_9rfMXahw~jlhv`-{JaPrV^Cwkc2-{t%Y=YWexIN$49p_ zKxXN!ibGES8GA?$=noRtM2j(uLJ)xZvXZ!!j8JPsYJaue!hj$9$-scSP+4Y z)!^>1`b`VG0wfRA?}?0p93zhKP4~TXL$`89X|?T>UqX8^@rq|HG1@%(qg}Ep-VzWa zBpwR{h<{GCUoN4Wj3+B<4cG;_Gc0MNC}X`)$z-Q<@a^I}@f0iJWz(9dh&AvoSlyCs z?P2SEt!i#mJaY(%$dR(YqG;^E%z8blqGbyI2ai8pXW6W}zJ-+@qDY=^k8AYUwciuA zkk^RW^%6F|1a4#YH`!u?D6vO&8*v30dZ2I)Sbs7iAp$a|`cc&2T@EvJgA0I%vslu* zzr{F7-q(!&O4}v}4o3InQohTf{N~u(F9?r>sv{SRVC0V5dtAMQ@&HH4>&qKD0wj)` z3?voHv@XR;U>3S1rM7Bt8VZBy(wdkjz8PVzHyCK2t`b$iW2Km#L=XYFN|*%4JTQl{ z-GAAQ39N~I8Q*cPrTfn=FYNbM{(bac80X^5mVA}+8WVzsSpQJtJ({8O!EV-CGd-ho zD%v6oae4r6mgpJKTbJ_&bd?+@1}-uNRh)nxapCYDC`p!g-xKVx6oBy|$BL+AEf&l` z_kek1PdFdR>mN+`mBWDk^FTW($JsBG%zuK-9{PX09K*+Ytrg=MoW^T{ejD@njBaki z|5N#hA#gGklB6|C_kp#VU^=SClXU7V-`C^(VZJzYWFO!a>RqsVE+Fli~)a- z-Qg?hAn%Ig32tWOsDVzM%8IS;wZ+OhL*qt!N_ha@+jY;XE2O#&>Jum4Cp%d za_NqYvlWaCGE8iCF1;RhL1M5g%%xXyuajsvZU%2GiC6T;LwB7}&7V|xioh2Bx}?2o zlRLhw_gP5(bjY+UZm1REP~HbQ^b<%SaZ-FAm0oO`7z*cX;7@Y>xMV#_kAFNqt1pVA zj{`ec_WDm-pqzMuh^gp+oKalFg^DSaI%>u5B2~2G;2MM~sXT^TUmC@v8U%o@UVRi< zynwTOZEK1W?5A}u1b57Tlv=3DFzm>%5C|u1E;p2~Tf|>j7(s-4#($mbH4zL zH0Hzjt?05sBlWccQ-riMc&AeY^Sjt=;Su0RAZ!ON^l%jv8CpZA7=I?%xSYZ4`-jzB z!hTp;>Q*ix8gRYR61(-tH1)#xLi?I>!(`C>MA4@3A>|+U@l)EG-#zbwG@J9Hc_`>< zG_>#HnFQK1u3k>BtjMD1fhI%EO7ad!l#*-0LM8-OLcTGmv>EOR1`RO7LT+m-mDJ+u zaO(12oVFe*#mMI; zSm=K5Dr&aJhV}2lE<}KeL^g!-0BxmMU!M5UFaHrRwmo?8rEOUPsKt>3(cIm%H#yK= z?BTSFnZ@VCZA+C`v@3~i$(_EX3dwo|^6;_-a4FWyLm!gAK7ZH(ABNzNrT{`kpXM;D zb5GMS)DomhueJB=`*pPzKkZ@uh6)bt(^%VOiA#sW-G3kARmogak>D{8XJ@e+X~A6% zf~MVW=s4GX+xs^GJ0$GnL^+f0l%%u)Z$>ZbW4%cZ8-d5>~f(>>9^GR?){j#!NSS zic9z4)NWIquV1@*USTQ4kwq0`X=$xg6qMOSKG+1!O~{K%}qb)MLOxXXOEVovx!gY zZJ7m0G=E*aEB}fe>%UsZR~rX-!0FOcSlR}%4c|5Pp{tcpy(}uj8uB8n!oh zgJJf7D013jRWohQ?F|sRHlev?S}eQ8#34|Ujv|V3B?&{kS`&5e7pW5v5=v?^>}Vjc zq~_9O=wU1{Zyr{ZrhYvGs?12YaojmrOUI^mnc1;hH-6gBWMJCd`J+R3BeX+(1vd;< z4S%&4d(81ic+Y%gssmC5rss74vURX-h_&nE>!8Pw8a63`&{|rg20#OYyglWi%r&+~ ztk9x|Nwy`K=U+@_HqA?{Y@y)@H?-A|-~__LxU77ip}l4$8s7v^y{_3u&0l@kg25^0 zp|%buhG}Hzhb2Wd9Z?3ERVb~3xdmryyMJto`1W)Ejd)s5!KKZXH)l@{Qs@kVi*4Ke zL+%exSl zA)9<({YWkD;e5EMt3I8THjA6x9#07ArrUWu8y`E5lX~am&}o)abT+og>>&v zS%6fyCV}VnyC2ZuBeTzD1XfC~9@7`F$a9%2CiazB5;k8t#$X_rz`lO!@)9H~@Nx|foqs&YF=87bp7+Z3S~2OTZRO+SSIe+)-+{0IO}>J- zZT4r)K+rz-W=W>3lAX;z@N1vHV*3^}iL6=;Szvy2 zhR911Z{zjx{xVRQ_Mf` zr2Mn8@=hZD5YcNBIuZHgy9LF%vq zpzRWW?c76$-Ll~h^ZGf3?Z|FKmKA_n_$k$fpDb{&BQeNM~M|Otx{2t%4pSdobcMJHU=G7ne9vB${)+`1%2=1 zCYmx)v2I+Gakbt-(tnhMekZdL$?(f+#yh;g;k;evOXH{}0ICU#M8KpX(qGVit(RR) z6wBK4ub%l^4sA7d%ua^ze&v6lnv+cK2>y#|N9BJY4f=WG$t4mO{vc~!L~vp5i}fSb zksS>Z45|%DmiH+wHq^FGLnPfOpcbf@Wm^tSgSox~g2b!Z;(r?Q)@koqlydeOc$N+R z2(qC&#hioYuOAkmiRRe1r|9ZPPAi+kw3A^b&ZTB1Db{WllWXD>tcbr9%S6HuzeE%q zaw#6W6N!9{c>}P`)vhf3uR4Zv|1js1A=8I7ggCnfP`~DhR|B9qPg(SYvT?I>l7B48 zg5Mk_n`a@GrhiQm2CG@c{XKRYct}MRUk}|R{%n@LJKi%PzU3jVZV=CANkIDj=ZUne zoZT-8C7`BJk`G959bl5Hy@hM-1URH+cwJ^18O8|>BKhQrtl3Iw;@O*(rQlh0_EAV% zlrh9{oNS052=rSOKMN^Vy(WeT_y|jqx2Mr;-L`SeS%1FBs`N#`9BsNcOhmmFkUXqd zJfue~Bwf_eNHyhV)8(<2DEEQ0Gqhkc$}*KJ)_ZR7y{OJ?i`}-1>O0J`cW2E?77%>X zFkqb^tSr%WPsmIO-MrYW|0WS6+*o{F?~`?;yITibRK7m)wKr{d3Tbwt%RC>J;eh{C z@Zkd?&wrz``=5E<7kAv!x7>r~Vk&qETVR52rKDykyg{7Vl3%e2c34?zYvfL$ZDSAK z7z09lYr9Uc<-AVv1mZxyWg!|O@0uWDOV28{1k}UL9M{uyMcJ2vM}+g84bOXn)bFBo z(>~uli$v$=n0q2;u4b7jIX2HE)QpqRwa ziXc4FbEV|I)0k?VGVbG%af}~ zDSv04@e$DhT)k=k^{J<^hfBs=A4Z2`C@aJ_!!iap``xfXRNWjW7D9-jtEOsT;BAEG z77iC3`1R_w;90U%UiQ9W#6tS~P(0PhK-7t97(evmmFs$G+~I2XdD~w~Y7dwJ3-R7l zRrOaP4WWT&Ja;v5lN_aqZww5&<`IXl?tgRf(`oG&Ka5W3@DjU=Tap#NuX6A~@qJaa zn}PGuC!4)w4fP(6o8s1B@j1u-hoA&X?>+j*7%{RTBU5!yYhdkPp+4R)FwVxfn{!Tw zE9QsgaMJwZM^EK<8IA~&x*x3qMCYhF<4!m#18d9(%(7c6t^KxH^93OG1B5wGdjiTuI{#_`;|9 z8)e@P7nF10lJ|P500rUV;(UfDRDUSj&o-7v2*;ch|62V`>JW4z-BU<`n5fh$Ke|u5 z6#A{|Iy&L$Lgtd7Lm{Jq=USd~86c+r9kGnAcqa`nzTI;Jze+Mt_XeDySiT zNV2fHw&VI6GhN`^@PiBjzM^J)xT7DP9Hz%$tz_4mC5~SrxrnVVXXc{x*lh}F42rV@ z8~^>jbNKf8l~6cB1ha6UQmH3X`Z3G2gJT`o37I;QwqqsZ$Cmu8mMm-}-&=_*;fJsU zffP;@D+oG`yPhJ|53X1h9e;}Z4EW6Vg4n>iP;Fs}@D{QDtHB3_{_hV<5yxeUSXOGM8@PuX%kTs&5#Pg@b&aq^#CTIqB8VLA!`bJ zYl)8T>MpJ^+p07$Ux_<94gG1Ff*6y0{DI>B+=r_JUFa&Np$zGgn0d$6gnMn5K|t*hKss}WaFBhPwy^_bYF~wgjqt=2YG>O8lQe4tCNhnZI!`G z@2$B5fAr-JUXVKTdma8S(j7HHM@`yLhOKqOUN_8UH0}@xM9+8UJ9`480gBrdyyuUN z;&G$_Efal6;eVamM|NriN3LV8y_$-T(R!f*z#u3WE!{X@%=QI3n@B;#%I| zT7TjP#>SXSwwj-v!GY(q-meL4C-b4Xl}|3=j8$8OYhIwcGeCS+t)DIEt&uHem^9MIx_?}_K2M4?@u+5Ovmag(rQm&T1E7EgQlf@( zg)>3UKV!D}lNyhQb6^(lQ(5llVV(wP?+}+(Bic4{~;_k)e zHs_w?KHjWMvS#u>PqJ2KzCVvACkDy}(;5XNR69C)!yw{&xtg^mql9F+NiLpUNys#Q zKXKV6Y~FxfGbcPxQ;t_D$_xIu|Bjpo^pC74M%Y)234RG4zzdmk*C!pi#`|N} zkRJBuN6Ez;DP-}&k0r)Zf|!BeL+NdAP|9+O|0GfPtYs6D%H;mL7vlUp7?n&rrquEC z@HWmC`s?5?2M6Q;j|kOV0!0^~{r5Jch1cjbX@sc*3HkZez5c0hKFFkKJ_p*1!7P$B zJTE4YM!P}8oVQBT7c|Yh_$bgscg9m~tC+(MYT(GT`%e3-tcUNE@iA~6_j>wkpqcq# ztn$jqpn}us@Wnk126%_xNo772LXuifh}EAz|GquWGspToc33`!%6fL3N9d{R`%|%< z2-C6nSp%@2<@?eASs5WU9h`kO?E&q2@QTxhv1`mvd98IZkOx9s1(FM#wsvm^#p*Uj z@JJ%E;oi{9(i(6!@%qsay0yt{AWQ=@W$9*spt9r2x722mta&>oE5Y!4Nbu%uo6H3W zh8C=l#ArY7Gx}GLm)D^09B7<_86dW81qj^I8}9Pxzs0nIjPNTbYqWmXd@I`_LDJ@P}TvC=nLgC0`wowEy zsY0JB!)`uii)DCnCE?~mmlz#UWl*Jng4rLbDetIw-0A>uhy_2MYI)Z`|2i*@iflz* z0M{k&75DrGiVJo%$__gkYKIu@OZ=^Bn-UTk*&YXk$3i_!SzpbWPfUHWsWBu%Y~ahr zkFFtntnV{EBAjIXM3tnVjNc;0>mac^KFG8CG8MvU#cT?>cNPf{&+&uftn}6vZIr@7 zjwThx;P|df+I6`3c3200;EHgA;iG`O6D2~brgV@--yjFl3sszEyk_sKACz#Wh;e?j zLoX7+d?ME0ZqI%ea(6Sz`!QY7Ajhfg)Qw;PA@Klm_(%IY*kM`_tDszeL`mxI9o4xu zA+#NY@0MbZDjq5#gQf+JCdm10LPC}9F7Os4rGDoa$b@he1lh9|a8xMd+uJwmwParv zxj}17u@N`W6;+mA;ORq(dPGZ)g!qK4iZJUO`^(s!Yu~07HYRz;i~BNDg9g|pIFcU5 z2}wo^obW!=_ag+|FH)X-%86m;=y-MEkHQXR>4yv>(r=vp!WVeyBz(cKg^!MJ0wUFT zZ1J^6x~McXIxQZ)#&4L8=J#leQ><%8@g(=tT;GoVzBp+hL|^SC(x@Oz6Z4Wb>@}}< z`1Aa$KSMqIPxzN@MqFzFqjq>L)}WWH3&3G!U!M9eW@#KyID0j8f506I27@>Bm6<|t z=kR7%H_3f8YUH3pC7vbGQdTHc72F~VqUOD7D3fTe?W zqre+{q0Zoz&B}IhsFF0An82Yp&TXN*b~Chi1{)tndAZl~D35#2mb+-cYTgMfM57Kk|uU>;Hl$rr=Pgo<#0uIUq zk92KLhj}P}W))?Fr({{lOO>uF|HjT3u^5&sr$NJ*|H@CTFnY>B^ai!s&^Hd3M20nE zzi2J^w$56dQZ9f@as7MNyD*0Uf;aN;H)^39+AwujOMH}PW&D|QmA6t$CVA`mk!HUY z4J);O7D*Y9tj7ceW^Qblkc*J@y_8>}!AKIo2!l7r9!s`Dd7MZ>+n?BULMRl9m8)a| zWglp#EwY1d+b5ywjJ742BqSf$t>fibXD6^ z!N7oL?;HH*SRXILWoY}2_zA6OS%Qm`l4CCuuY?8(}v=DV( znLQxB5|xZVL>f9uyapu!Gk@)Qu#?4Q{vcC+HL60ZEuJoc@Qao`c2Ci-fE5;18zM*0 zvFU+LS zo*Z3DObfdd`Uh@Dhr@v6?(>k))KD&UIC!4;q+C99kbf`aH>gbCMoTlkl;N27&Z>3Q z-xrG)>w%HxFuxXoI9Jv{pT$jd;g$90n-ut>eSn|p%4rx-n(Li@}oGF@BXmagd) zKON2+RpKCHbBbVRcCURcABb$@JQqm@=gP1H0b#CSm6?kxx9?3s>4EgQ)KrR--YdyX zSx%fB1Hq|r4A%!_wd#jqX*tRPA;Tp}4(yG%t5vO|Uzx~NPvJu6w}vsnIb%g6XM>zR z(p-xTecA8CNXzetpgsH=n@@AW7 z!*sqP)wFIOb@n5wwQI}uj8b+UL@Z1anPp!0EixGrAdF;Z>DLpKlM?oV(MAtOI4*Nc z;r^0=1`mvJdK7$WB_Q z%GLUrj}Q({SogCdISL-Ao`Cyx$G#n;#XMAqlhN<}rMMI7Ub9oFph=NwBB&4LIg~|X zE3q8Btr;B@ucBBM_nXnIOnW}tC|0VZQk<79QAc+aJ)^mQ#2hjvX%F zHVM7lGt4+M{bwuWU*eraL1b`UL7#eO;{MR^?;XMT;Dt8*%tvKu;-|= z;F8MJm()=pIH1WBTI&P6?}T9WJfxoCWoLNId3sE*&rjrxVkBC1#tD3=bk(^bj{P$^ z&e$tPKj;1mrwR`u@Rh?=PF9iB#pSRFZ3#idg5_}*5RJCzksl%I(C)^Noq`iXn@zri zAMa(J2R^!*_QlfL`x~Ma}12c)&zZr=p6L%z3O&klRg6sms=YPzpIIN zPxc&|#`os%wu^Ks+wYVx>prw(bZ2q;S$7||iuz?7ntFo>y)81P5{n>SeeU)5-4ZYZ zG5l7IQ3Bwg$x~O1ofAS`RQ#OHFU(dlj5gMIay`h3bX4p++Ryn|sVz5{0}o@&WgqcZ z-1a!B#Tqqd1*5``{(T+>eB3prtcGGA>^h-zvWQh!@qV)%*_lVG_UKK5VDi9SdG(#} zv#w?^QYr^YI|9=07dtXwT!Jg5z@Hs`2Q7wP!y;&i%-ZjE6w|k>{;9dJ6~{Hnj}m>1 zy3`UXQNNDHwQovHAj^_S|Lyi3#c(f7e&lD?0VlN|86tsH%lgGe zc=T}oApw0;Cgv=ZWV>otbg!*@WK&I#3RAdft^F6YB(?X!OL)NC*j7c*);^3vX%4R>J?FQ@A^0>v~d}bYvmUk7f1xBV!o8Jzy!L zFZm4ejz(qjJfLp5aRANKuS)Y<^`CsipliuLD--OGy`K>@4=rHqp{zs`2l^?}9Et{@7jEMw;u%)4>8ws-~z2XoqQaMPv^qA5G|- zICMD|6k`{j2}+*SO?;baI_ebGSjvTVj2obx$R6v)C|dUA^>4~`Hi>F^^=Y43-zyiY z*D74KFUe8U=i<@suu9oKB21x6}DmLKi92S4-iubR>6VL zw@YV}%c(elj~ZitPc`Q;%A($eqnT6Zl@KIj-?d?gYzc7|I&dauzcE=0_!XDvj- zIwNa!L_%aF3$Mp{*pBq|_z5smT~XnxqJkI|R44})9ujdFy(ND%mvopC~_zJxNWwZ-sK2MX0hH*3&7YcK5 z^-A@1k+O~)Q^=T{;oTfCwB&?$qlX0Np}Kk|BL+ZQFKYR>CjnTd2c$P)kI96;6%C_q*Z^`2*-36MqBcvKt!Xd zC_|(Gjy*3LPQk|BM1IXa1_lm{3{2!d-pab-jM)TMN{IP5$Df;G@_q6^DT+MGe?%8v zU$QJK4EGytc6#PT9y%`uZJOr7j4T;iK@PW)t^AyOj43ZHzzcd12X$Nima_7xNFGnI zG%Z2KqBUvcMQ=jXX?QJY=N^g7*X`?F95-lQW(#*`gplbDE|YDZCq~B$o05 zd+;Y8GE|i44A^pUG9PXZE{dSM>?^jlmwvv}{ns$_;h(c&BIIdMV=80$=wmRASxI$4 zrW*rXyo4PlDs(`iMp;IzYiSepL^w+>eMT55$d)9)6y6ESsM3-#9V>gIVm@(@N0$V1 zzA~9zG(_=iT4-nXPxa0GJY_@>Zd^y;OU-G2;m%M{ayVb~jocTVQX)QNn3e6Mx#K{4 z<(7E%zCcUrDopE*NyHdD5lm}XuFzdL)meupQ8Bq%CI$vuB%IXaRk%~A2c(6BU%))Z zFK#eqGrXed-%;)owb}qU)PLd#Q3d+gg5hFm;6tu4kwof34rbARQWsHxQjBfLiPL`$ zNYdvSVq~OH&!D?C=aCiot_@fRqg7Sz_O$MVHF~ zYx+{C!T=?@a{VhkPU(!E zV^zaq0t{9PQUV3T4ME?NEx`y7TvG2b{2fhzv`r$U%U)V-Q>p6=lp$K-Bl#FiL`S=K z2tg`t19`cB9y8?h;e`kr&9s6>g*HpY)NZA}N63P*?NXJ6*q|XrN7c1c(y%M?=rbMyP$t$Hs6v z@1T0VNm!mlK`37kqajVt`mj4sl6`@Op^8dQ{_x<<;KcR1CTs8{xWt*?=sfff#AGlm z8$OUTLfVc3uA_-xVmj17WJ7Lv$T>?QSLl=Yk>;KA685ADbm1vbPFO@ND6K&2=1_~- zBwO9s_1l6aymf2Pm9HWun&|}FyEOB`;0*nn3wQp%mdxj??VuVG|V$_>{(Mq4t3}U zE}1fvA<=*aP@)t1Pi${>@M)3JU2rp~og2Ysh@QVZeYBKtAQ;rIHwNp>w ziqK~k?g^JO8=j%2iUU=_8l69F#inLbn;y4&cqHX-(3%}nHBzo-a&;WF(wUe`t@iDQ zB9nKg9TUt}B(;%X(V~qzw{MyUq^#Cge00_8Y#@V7W&Ramvi^lx4a{FX-5dItESz8H zJeQprHl>{Ru8G)V(wb&c9y9&R-AKxJ<=A8t!i8!hl$1S?nLgeT3SH~r3c7PfljvX> zxvG;%P{|xdw3f-ja^_z>za|=(G>*lZeXMh0R|Fp`*IQ&)ghgZP_)7jt|DQ?pJiKTM z2|Td-`xKYw!sLWt{V? z!iKR&G;on1%44sxu?-H=heYSTWRwuBsiFd*#CT2W5Ol>Uegs@dE8*BuXeB`Avv zQ#N4MFuJ31Hk%KS_6Z5X^uL7Nat+8mu8s(9&P;L?!WpEjx&IgmZZ{}aeR8zzBEFXg z&2i~63LLwJHX!+snk9TgxUU&8mhY<>h>Gj$daQRNj#QFiesSGN;i&oj%Iz)-I}LU9 zfXfG5g5Qi(TbrBLNMA}o%#^je=o86An7?fD%#=k$pM9;FDl*9&eNtGIJjK;9<4Mtk z9M$-Y4zmrp-Zk?pqh|GH zfEzO1)R!4ciR(p44ks+k`Hy6=*wL*X;x=oc1>cS`X>$pmZqJKFivD8I>=ufHXh?*Z zNEaBk^idoeCcgUes4)j*1rR;VHRh70ICOE~)zXi2jct3(Ri4!fJb{(I;=s+~91yy- z`9(%=Kk_}TncNWj?hE`wRp@UF4V2_;Szc#?pH;1DNKP39pL89pXR;dK-|36T%~CsR z%x9-Azq$b4vEopKSe73TnvnTHzScZR%ofr{71R^06zT;+6CTce68CCF1f>7CDmT7i zutszaaBm7B{sQ_JB(f9#IBZj!9~GPOUI=`i2OL)?n~`?p(_RKIKWmQVrRL|);?n(| z|IIHSTA;e2ksQ<2hUMiBrz~TeGQ^r&EbF&)O$-+-kjP zm~CG{i|K5a&96Ff$#`t|qrf&+adtGuRc$oAE#&|9R9ZNH zCk#CjqT-s)VIcFZf_*6tgj9ve6f6yYI-tDellDmG`(eCSgzx zahAZ+vs3VFp614hR{Ck`j}q2N|2>C{H_ zxu`lWF~j(Hqo{5$b{*~n@T#}WU zhf`C0o!~{s;cR|w!>W16sQ&3Od^5=|jYVnreGR62?6143Z^0?2qVNXIHSndJN47@p z6Dgc@Ohp?8+|w~|bT_5J|8?`B=TG~Ma~Aj`bLM$M@lE*^#HJ*y`u!R0azaWbK%=9j zZCtfU?TxE_?=YU}qtcZ-`g53eipHTf^PdI!!}Vgcl)GElRFzf+3}}Ye=iP6NRU?Q)YY#O>3z=? z&~74TT0_ySWXG7lu2m;=JtSb!3VrrSU`^`cA;K9{5w0G+^WcA7>N+M!X1?iwZ%u4|`$O2^gImTs0{Hm6UEkc$<@O&^ylz8johx=e482Zg z_UH@VWF-W@vNeuY4rXZZ$QfACpKW+KWHOKG3)suxaanBsm~BPJ_zQ{5pXxdH4tg2jNnUx`-Mrw(aH zK!M$6m6q9Giv+=Vlwdm55$WN&aTljdr_h6lWuJObZi$akqLA1$yd4jZIFp2(nVGxiz+sHc`(2w zCH0fEBUyd%Mkm3~&dSd9f0ESHYJfF>i#zou z2SA9-!9&I(Y2*6cjf{hp?cei_1d5G=GZ76NRIO#;w9bp>_q%qd&^PS2ZU7=YfYZj; zVUNneRTPE!HgCn2VWGt@QNQW)155!_<36wpgirt?r#23*VpBtzQIY52L6XB;lQGGB zp%Q76V9J*Wrs{)HncImeQpb>`kFyXfQ-%&q4;l^vOVOj{WueDns@oMLgxM%!)f{Gl zFv4`8SqoSd$-c5Fn%X8QkT>`7rZCJ^pzlf>>oZ^sVCTyed{Lc;9@CbkV+E#(aK&K2 zhO)ojx?VeY!zpg$mDmAjw!^_WmmI)dj zf6lscG=@6p8Iwn6KkR-*S2#}hn84$hvrlax=glT{nr``3x=4)=_vlQGd)NC&P}w9T zCDBU1zMVdt-fzgrq0%LN7Rp19AAhIod~x&tcy_c~d!^CC`Zs;iU5V5TJ1znT8sFhd z-ZV6l|9m+*u&DQ2S>Rc<RHFOWFSBv0c~^L2hB~mbvJNM(i3@OW*-SkEx-09R3teT@&UvLR%QJ+A$qZ9vo7^38S{6;so?Gdt zRA{8rloYXJbXkq9mUt|Z?ya-N;mf)5xW%5W0dAsfR2bGR32EO4m)|+x){ldJ*4S&x zA_Rdihi&l(QG_4gX7+F?^0aIubmpqnPy1v&zo&oNPgdH-OUft>qRfbZL@?C~yUN*# zOA;80&|f*{)|rPO32^2_LWesUP}>;h0wpD*Sh|NO9P176T{OJ3fZG~42*+{K>s;AH z>-|;BT(%Kgol~!lo-xdV@%BG_L)v-k*g3T&kPf$uQB*QKEYt%ZlgrCExUH_dPxqUq zBR}qbz1&X{{$9yH;yOP9T{hK?X={foM#xEeCO)&z+>5Zodk#|=DEX^c_tK$xAjaO~ z|8>t}?ZOx+n2}Z~V?ijRi#5PUhuCuB-RB7n@I2J(CBM(C5FdiMdL-{0}pg# zIC32_cBO=BcqS|~-v^vM`QxGv2%gcMM+VEZxit8;oA{9Js|lE+uAU2?G{JYc7d#q> zH8(Jh54jJQm`Ma6v0vKzr*`PJ($)~Hl=NR9n&8!?gK>gTD2pHmejx;LP8P&YQ9!8f zRWNF3ENqW70yUS1mQBI#>+X&2TLjk;tHf;)-B8F&sCJJ@_vDR~TM^Dm_Ou9|Lmmar zM!FrpbH`_j%#2^=lO0|RNU~06Zp7q z!B>A8E|ScnAIm1GO2v~#M-OJG#xbFq7G@9xIe#=Iq9{;QCyOU(OLL`R%2hngP-)5| zBMiVUDJmxkGObA=Ze%Wym&}^8l=!=9N2bjWb*K0cH#x*OSDMsNB@DL=BJwCo5$ zeVq5RGMIeIOHJs63&)L*Tt;ty8eWs$u4A@cn4Y$*3>zii`MK&H88{;-h>NF9 z&9r!@?(d)4|2y`@E#x%`vuGsgTEmV-<{j}|INZCX^1t1hD|M+JKmp?BCNm&oQM2)} zAY=b`XVD_lBV!}u_!s}ms!mRB|H>R>tYoTWEHaLkPX98_|7H^Zl;6a-*(7;+*m(I^ z#aa3I_;}dactyoH#JM=Hu%j|BEV8iW7zdTvhk1QBcyb+Ukxx(Zgh#!)YiU_oX1W*|bhFBEF+zSc7R)3AVqO+on#z=TZjDg5l&GZJxO+!PYYwggF z%G&?RT>500>rUdi-MAE!UVTMvsRHrXXCJ<>!7og>=$E)yT1G@=jDA6-flmh~XH8qC zstl<)6Q_0om0}D+u1>E&P!Dl$GE;x;hg>TYu`~5TBND3=wKLa-vYoY^CBRz>@@e94 zDnvpJA<`9GLk|Zu&V~-#S3vRd>CQAMpq5rz1NZjTWA7wq!%L)2i`!$5B?~Lnaluk& zqH3MYdDzvsu{^TtA_8k@8HUYJZUqVjE`%pGGhy7ZC3YZwsOf^Kyc3#EQPkt+^Ts1^ z)95fH&qO&t>dUGM?6@fKVY7JkdmbuMP_!|gK7ewEy$w(ktm2Fu6XfDdyaAE4Lz4z* z?Q>v-x(w_LJT4AdRq)p!gy|@VQV7R1CeVj?>^Ec0^foFdM(q=?>oW|yMyCt5s6&u7 zMzMG4$^nTsgqXv5qriM0Wd1a4{3XE4BJDyql$mqhWT$B|)Jn#wa*Y1b#9arFBlNT8$g4 zD1a3L7P1GJyWU7#y{8CO`hO>61{(A+T(*9fyB2;FG#1p$cKLAIN<-s?zlqHU{}xN% zszsSW4G@I}Jeoo6NbT4fn;ARoSWJe%)WNfIf;U<|kIM?yJ8>((n}i>}?Ylh&>dmJg zkC_!*O5sQ9Dc`(rB^NtrYqu?z{5H7Os-ZQ=Q14mta=QbLE^_>y5|}@*9$-*mnWL~$ Vzcd3#5c$|x`4Fh7fl87H{{y+STWbIS delta 40059 zcmZU)Q*@wB6RsUjY}>YNn={eGwmr!c+qP{@Y)ow1ww?U%x7Yel_CDx)byZjQQ5{rW zwYugDw&4sm4g-`qv7VR;oSmIJUKj^hU`Fmb)|i-$$E_9k3Y$cLP*<1ewX^$)v|dGn z63uxKSn=USsW>-TKp0Ulh~|AX={@~avf`WUuuTDWCDMCXDJ7#1idr<$_VY)T>TlSf z21Q?rjgH@KY4x!CbE;fQHiC=L*Ri8qUYI9psv#kK#UzRUoJ}t^9i8RmpuB1UVTXMJ z{(lF!?7TG}D`%i?5YO-p$`ilvw=qVK3RV3AbRvJ`zxXDYlv!U1S7za{D=#<X z)X>c~OFOoSbA!iU4|cMs{IYyo4^g*z>L}=|8-8eRl@&y%6VP*_BDXm8xVq_CpbsiO zl3i!(PFp`ocnC1K9DKH|fWSipegZa9th(f4&_@&yr}*x~wo}FPYM;kvyP8F)kk)Dq zxd^7Rx6_d_C$1|*lvD+vEXIeTSWmXEWKH#_&S*+k9V-5NY16jNdogpY44ME7DC5i( z#>_0rbeBZsG(O2a|7BLo#=9qYOFju5E9$J0rUG7u51tu;d-=n~>Ex(N36=rIoPS<9 z$Hk-aRR_$?oo2KPN99)*j1*mK0_M@~%049$;gpF-ycEJoG& z0$5W!6K5AEQ$yST?d*-LV7a*y$-ow1nR!@vnAzD`*|-xy!K=Y|I1}r^-7$GMiJ6K2 z7sby{%p`AWXYOJ_%)^x^4510e!`+w(!2<`z%JN@wP=j)&I+TK8CSo8{09Z##+->sg<%7Uf1acq)G?zOGrYcz50&r;vIDS(NDyArz@k*5vcXulV|kDe zYsZ??uhnoMv8<~rDw}TA0Xy{@>`~@B*O^<5>c7g8)G^}UX6Bc=v+B+ffljlO3fh>7 zCC%va>8Pl?%4=Nd9IiP_Tu&XS#w=>C*}lDLlxLO$Vy-Uh14a`A33+j&S|gC8gPx%z z`^Eu*?yuSu`*sxQ-SO{E7TrwDoI?CDQ0`1Zi9)$2RionAAwx<*fNi`WD7Lt6kPn!0 zCJ5DO^r%R7ab?5rC@QeyFy}qGm;T(h1gz=sPiEwfp&V3kmQ&+tn+qh{!azmxK-urj zl4QM=ZWn=4N9A8nD%F#lmst_Q1E{+qYa8p&4Sj`Ggq!Ta;>BM-^qh{%L6EvQ2zRJ% z)CXA#P#SStgR{AafMaBr>?Q@TN?Qx2HGU1s67JUAjrh`71<;&0)cP5U(z=w`d82sD zaj&&O;}?5A>;WP#)vJ%$chEYH#K`m(}2%uW&`h> zqO#b5x5~clrgkYfUrXYBu+}+)8YU;CqeYb|qg7fwZ_;at_N{cf6dyjHeegn!$Uo^T zVi=={NT<5dRy04;WAgQJe%&u(2q6>KVn>I3nLDq_Vw<0AZ|~7L?bjpF%UVxKU2@B( z-n3D%Ks(@je*njP5rD}yC5+ZOLM0Os7~ht+OO_ID>EC@%gg|3MHmY80KSo0G4V9%% zX?EJFNt8kp0qEN8&sNf*@9fOfSGn6^Ubv_D1(<}Ne%{*bygHOx4VHj$E=qgz2Vz#$ zw9kX7$tQl|t)ZprWVlt62-89YpTVU{fVoavpr43pNwWvrVV?aX)vhnQ?02)FMt9~1vvwynw5 znW|`be|R5|*pf>w*}8_+U95BgE=^#EA(lSh?YdF}BBuPp-Tm<&iA@lTC$`^?JM797 zt`2xfRK$P0jt~?-t&bmOr8Vw<(NoBI1IZG({NdoI!)?sUO!)7ZeVbE@&_-(h#g?k@ z=wXpF%eP%p9vyF5;MNY&8#U=m=dh>l@7{Ej?&A_c5K$cNj3< zs3}Zx?o2iVbtI^k6mLiRKy6pyvPsLDQiOyU`zbG|Z+TawR4d(%=fsMtP1lYsqGR)< zUTD-+A8&?x18>dHk|wVM_;d#d^+}B<(FwuQe<3+hZWS!>;nKkVJk9%^JQc6YIAevq*p4Ue z6B-{vByanUd%}Pb&;z0LBf>CG-sVRzmf`Goq9D45bK5f#_D=6%VjmKJBP*5<3@CeJ z9WmDrFbLp1|e2gz00r;!dG zu$yIyIp+y&1U|3Id(?}ImaZnxC*m=S_drYoG8UM8a{|dmDBmebwBZkBxl3_R3@IEJ ztVNN>rPO68;>YofjL}5`jLzDn1c#%K5DIe0M*>s1B+0@<=lzj zxnv2qCJw5BlYygxa%tZJvEirA(C}2du_zW=Pn1#tnU?^%mAQJq5G-^>uIu;cz4XupR zQ&??`2s3Q3DrshLgv1d{FO&+@2^#8P2(ko-phPYhuOpIhKe*ko8IJjBx$(uBi03$T z0lqw4rLmx-=!k4N>kZB7XaRizzD#RSX5Z?gFtD25H1p8fsw94vlvOAiTJrXkTQK`- zr(o@O%>D%hNA9v|#fZM7V@iGbzucip75q7?{yCL5I`8Df-@+sr4!`6NtNn%AVAyJ*LxIG+LZiu8Dt3hN4PX%+2lGKSkEGNyV; z+m5$c=C;-Dby^H@IVRMgr1N~EC8@RBZkRK!TMtje#kdIdo9(cw(>_NKVr4NGRt{KT zQ`vQMq@qkK9wgjVSBUw`(j)Y?X6l{zw~xw3&-g4h37d`bwMeDn=PWBeBnQV={@A~M zvg-n_8kQ&7Pk(PDp*hg!{Oi1ObD#kkgU zo%ARplF+F%mIPh9xutGPyhTD*PEp9%cuZM5Lt;&V@bPKE3g;F1CL9I>2504lXKeeM zZpEYLGvYP(CPR}-vgHth`HrWbL0SN%GN%D&jYK&aQi){tb2M%(euI!yolPwV9W(=#^2RDe3qR(7u*!Mo4J^Sto z`*_xl8!ffu$0^`GtPULOv#K!*jbxZIEBNdq=WlmbFYrcYvAyp110ZuzUmkT{&x-JqAPe=68*wj{l*~^2beT_sPX9sXIW~*bc0t5zo%2R6r`Gv zQuj&#t#B3B5mTwP?lPHoxg%cYHD;{b>EX!9c%g?BZ2%`YZimzQJ_lS!eUmT zh!$ofO`?VnUZ1!tct!9Jx>lxSqx_slRUAy0YD{Kdt`8>uHryvKQXu{Lc6Qc?lb1#| zZz5K&GsrQ*o-18ey55q`OW%#o_%L+-w5s5+Ci>Z5k93ZsORV!uVspG*!?pH&YoV*! zTjRO=%G#@-gv#oFa{gLSLTA;!_vWjhvEXv}cun_~yQHoj4qmH`Fn;!&d5gaFXw%Hi zfJqc4@SXIX(lZ6*0?3O;T?s}MUbbY1Zlya5KnPfZ| zs!Q7c?Qm?`S{7i&rf5*^3O`EEEB zuanQ;=v4v&AgYL0)dd130%U&Bk63?r_8(@E8}yOeL!mCk1b&-6kVJ}{7Ab>a=f^?% z2tAI3>XO$+a1n@?pe%z~LUBawj`(eS68KqRSRS*zu+8h4YI}kl;4F9jY=SDZw4T)= zZn(jJ!@sPkISH4(1dX3fr?7^pI{DeO8YS3v7A_53gQ8f$MdC`4p}p?V1@%{UhfNS7 z=btr-3@VcaJ@^^xit)a?6Sps+w4?_nCsFCfKk_@7*b6zu za=IlvFqm4qLwE6&0=-wvfJ`pM*g4e0XWqi|8h*vok@A+SbD2aVPf;vm%SC&8)Nnr7 zEHvZcntRYg)Kk)v%Q)uL z{XsFEdT&&R9W!pjp2-h3I9L|3z4wQhpljc6$6rz>*mQHGyHMum$$K;>v}R1S)ATI5 zd^3}s?5fD)P&F7QwUbaG#V=pFw=?lM&R*alIYE^`iu?gD+Q&dL7v?)m-SC9X+`0B5 zPmGSw!hQI{;6dAM<}p2{X4=WcC#CSb5#RPYUVyxmA+SQxlK#vnTp(}|F;dZzJnIv2 z)tIvfA3k-2;JkdlxfR_Cr%-gTII7oIZ3}9-xynt);-?BY*>AD=6%dnbMzCaTxRAs=SBr0FJo$jQ=`@4%d|0;{0EhL^!O7ygLUHIaxG-mZ0 z_j(p0>LWn=zo<&$3=#w=XX6YDDk2ysPvR^KbtAm+6ap9*_y0IrBehYlL_9E7uEwAWQd=rk zp8to;un@CyaIyUVoQ9S7zjB;C_3Hza7Lt{Rjf*+8E(R1G@Nm^!*j(b=B&Hw`b9Z-_ zm2pQRVHup+{LewL8OAP6M=+;L8tt;oC3x%;n{)s5sr#FGgYLz+Bo!?VT-g2zNg2E?Kx<<1H;G+d z;ooYqIM4)ANT)le`oGPf-+FlvbLa+-VN2n`2Oa`;IErAWMjbZDy{5`@7YpI<8#;> zkhT?2fVh@X*n3AP+R?cws0qym{9_rchYK>##2VDa1@cQV0rGSF6vUE(9L5OhTL-%c zWoO%Z?VApN2NvQBDmps-T&PXf%1RalicLp~d1iKE77P`d6TG7hO#ZuG#MeK?~og7*iYuG7*BGb^9*$Z_}HcsVWAIibW z32cQ#jCS9G2GYsFugp#2byLt%M>@Bc7>lX-n{C-Gh8RgI_uIOq!L_OBZPQbZi;5Fq zkkT>d$_se-78jGJ25gpunf(YrTz-HEFxag4&VRBo^i1OSOvZ7(ymI?zf&4Oisu32_ zp(8$k92#DnAbGsXSLLk4S;uIVJy5DSI z58wP{@NuOJs0S9;kaZB+`E})fy>Wnl-uL%?)+bhKRc2RLL^^ofSC7uywxbzh^ON2; z%BwyKZ|}DD=}%!sM6;*w!$#NSzmE{w6{`UZHeaWEJrl47Y$GRf+}i8lB;I$iGUw0p zCP+9sBeTZu?+0LY4mWq7sYtBxm~Jt`8X6$Ay+Vw{MR4E6SaWaNR-iV#UT?q}EwB8y zxyctyqGJkTggy<-PsjFrq=?XCOC-jT3-O z<)`q4vn%n0d;iWBFKV^0GTgz?ivwG+Wd^p+MKxfb`Y%yuqo_HAJFHCYp?zah(kUHdWeJOk7B{34>|P| zIfaLNNQpVu|GOpK@t+XB|0j7ptvtkc-`Wx2q}UIk@ThQ35MPHO)UI#)AqTwaB2ymT zc^EIT$@@UnH!sVVZHNtO(PDF6PsR{v`NAs`bos&|6Ew~E<96IJ7g+oEPcE(^MGbE@ zjm#cZVsd~Q@FbS)XYjgj9`3K>&jBG#@C&d8@UsM!}rf3|&OdWO0y-d7xP!hxWGib7XXKcm5!h*ob z)2IbcB|d3pxc2g~3RP&f16?;Yu5Hr1O*zzvUqbaH!>(d)RJaL>S4g- zn(mr5L$4Q>CuVJqr#x6?TLchqibs_YHGPVr0-ix$7&NN0t!ACmr|j`=8#34;q4#Mc z$#Z)%GYNecfV`67`^XT%9T{d8xh@4B_rr(hIXx+IRHI zN0<)muV<*nYA_-Nj)sE8LH1O)QHJV|ipniCNYQ`4Dd4sXsZY#YN(BMy!JT()b!A`q zouF6WdVb_*l*4|kM5F05G{wL;(mr!rshGMsxrasu@<@SA&pxcfj24k)!H#FA)jnXKi+oMy^tmEqN6~3_^&- z&&22yp;lZEUP%d*I9b2G8RleoQ!2(m+_(yEk+vyDEZC^fsm(Q8QlX$&+-%vuV@*0;%vGI?_Q3-Lfn+_t-CX7s&Q7k5SUgBYAdiZPzj|Z412XzW(6}DQ+UeC& zAJund6#dH?4F+%~zD_S+7;AAGH2X-{%vg{2PrY!TCvYGF+iebGvtvjUk_+PhyrEtX zJcAYV4Ze-HO;bFyPFCdl>6N%5C41l7yi7lL$F^t>U6Ap?SQ_%TF)DYUIZ3Tg6R$$8 zwQELLl#{*xw+U0?N#H%y6&ksQU(2r4M8~VjdAJ(K@IDZyzh_)2LP&_Cr{wU*&X1_W zKA-eoY3iKE^GLj_?1-Y)a&b4|5t|u}IGka^QfU0lNM|aI?)_&F#8^Sfi(aqJqt6H$ z#rH-L{wycmqGUh`^F#CandlW(xmaaMdX6Dw4x~PS?p@e}lzPSs&+)?8 zrzvJF#x8)EV189)Y;k@}DKJ|YBY&JUb#=tf?W2)85H_)~;P$A~$xS3`nr+NFM0tzr zFi!gD_UFT2iK6X$Gs!~e98cpALd?e`NVT+;AV+@GBr$r1D8Or}&#|Pi-r{9+-(6WP zd1mU9r0M`yzG39raF(1eLok#ib%1%g)J5lH)dMJFir^fsU^OpdKGfPw6zseuyME4| z_#T`bA$c)1O05PhesZEL9sH}{|0->()&w1=^AG*c+UDM%$fIz4?zZG|#6N-4`p+Xnr%4dEmsRz5cTafq-&tl=-MvTj6E*lx& z^B_RIz2P#|ouYKE@bj83TPiM5~Vd^-hr z@n4aAYgy9d@&#J3`eYK2Yv*vkRwyqWsZjyEY&zQ_7s}2U*NvnluhW@X9}&5JYpGDH zwS++ezAB{%nN|D6Y5bF(Hf7if>&jNN-$`D!c_ODmG&b&!1=~SO^nwey9j(o_mV%+G zX+3CMmL%@MpCXc3mEw8sM;?$r52V=I$2<&vR1Q@tD5{tHz3j3bIcSW=Kyt2gA|?UN znaedBx{tBZVu|&bUr20375dUp6=FsOoyVs_c)>s`%(QD5(OoPrXVw#EKSdbhEp8Ts zZO^U=yUOHT?ns}6t%0`r9OCSwj6*#)clF=prkYj3rz% z{hO5E`ucef!0o-xpApG1}A#p)!Z63kHKH#JCra;7l&14Pos#c;lB|Iub~ zeeSJlofanZ41t^7#lu{1IDkt991L4Z6qJhjjNa%gFL2zb1{2)UrrU)_icx7!om!YE z7!)*#CNuuIv=?1-0CSAAD+&c(=dGh=tCr$&IgHBcml+Y3eTLP~iF=>Skf0nigunC5*9Ea3bBq(>T|AynIk~=u6?{btT4c{%h zmr_^obLw}`Jo2=QYE3)dGNeQ^HMMdadfdV;W(g5$avA!W{dLGqidhJR7VjqKy3QPU z1eOYgNE@meOyrT{*fHm)7jWK1zx;!#;IIVEOsA;X$+Df&kx3fPZaG3%lAgLpR3ZA5@Mf*dJS4S>l@xUljrDy+)>b1ev8~z1Uz3iIo z+!Jcr)FSeyl$nLD3@*1%Xnb;$+tg(PwY*37Y!BgkFC^#tnc7v#fm!Nn4i8oGmp` zWN+L07!4U>I)-t}8K39di2JS{d~+|xOT5tN+k33&Ug6B27uN#N5npuC`ARusL`(Vs zj$!z5ures~P?XCu1f-Sk`ZhiYp|Ph?VIZjYy4wR-1v($R_t;i(_u4|r&Wssz2R1#m z?aLEl;{f0MsyGlK5|p*8~)=v0Y(hv-!0# zkkikUN5A47OQqr+o`Af%Fb$?m<;AvKaGCC>oD2AnpaJ_3Z67hdk?V8)V8`In{f6== z(y>sl=ca0JLOjc_f6wptCr>7`JktejoPvOfhK%#_rpW$OPW?0pjgt9iI?{O!7edK> zb{y)}UOrIcK>FXbI8!h*=#TU@RHmS|M-K8pLBmQu0vXZSI|k(+%qe_oIS92iPSB;m z`KItGlm{$MCl5N5QIi8VhR{{cA&>Ige_u>PuQaJN8iQv!EUfH9WyGe-89Na+^qzJwMOizO{Q$Q1LY#ch}b3=?Bo@joB_x4(2y-<|c}Myap&E64v{J$>-0hq5f#odKxhBkR}lf8JL6f^(Q31RSn!$h6XCN zHGlM!U;Dr6=XBh}v=!a=3haR*=wSOKQ~LrDjAgYuQtJKX$g8ZPv0bu@G$pVCCki?g zWn2dWtK?Czc`>gKlz)NW1wOm?sAbs3*37f|sI_$LO}Bzsw=&yv2N$LHlk)FwYp&F0 zGoSSH=}Gh~!Ok#77W!5U$jwWK`=}!G&&0;YfX-|&2D*tAZvSfed%Gt?|7=*cMlt1uR~Bkg1Pg@RBffsJ zYNy-e3B`!WksSI0Z<6J`lDl{i4IAX{YvW(~S|BW7YgT0WhfiNs(ys^h!c4eZfhg6_ zikDBaKHL^I6V124ChLr!g6FcY`2;|-odYqTV0r$f{6)wNTBZB3Wb~s>To&7BK(O)a zHBSDS+E&;A4^Lwc+suvTK<)H?*;}e2HdLi^Ps1^x%-$+QYWxM(NCU5qb{yv@evmPJ z2NqhzRV*C?m*p)XUf|E}T-`+wrsWmm91=NXD^#jdc}5K4VQrJTgvV7HRz#s|X1l~_Y`F8zByfs=i#Q~yGzdf_uz1A5Iw zPkAH`guI`X%5wOfpf9szywE`P!rl`EC+cwgWbU7jfXuIP6Vd(nlzLh_YFYyVYaKc>_m~h zr+utL1RPG{zY+@0q5e|CvyWKISY^G1TG#jw`08Urt9E7MdpCjEiE7%b zll(vIlM7+ITYTVMFW=_f2N7xanXIuwUwZ{(RfVzOX&6_i3N58m;-pW9i8r@S3s=xF zoBl_iTEIj@MLOBdzed4pSZ|lP`jCEIF*GwJC8W1o)hjG_q{_t>`n8tTu$GoiI9hub z$V!aFh;<6IHyJQZVxAPDfVz^uTS!Iv@tPWo!OBH~W=8;=*3C=s143RcA{l$~9q+s} z`pz}^9`#w**VOpt*(z!m`4m4Y3SYKaT~xaFiW4N2>9XoSBsaq|DuS=5By^HU(#Kn; zpnNv7K^k?eW~FhcWR2-40#{P(%%mkff_E$Z7z1j@`O^aw@3VIvBx>zJQHdV>;aWB} zs_Grj)=(hsA~mG>l@x97&`?Bl09$p>5^Jo(R12XMGz*_`_7~NKt03biyy)4gK^w<# zu!PgpfU$OJzgc1h5zjJyi$}^ahg>@c+A!y=V}aC zi&Cqd8dK?_y1vWGZHCJW^&+5xl(H;%jq;?e>kV*c@KhcfA-Ch_6sDM$Mg~EP-8)3y zHjj1Ch`|}-zN_>3QJgw_G`UGi?!KdN_zNC7rUw|-*I*8|x!OvC^j?{9IJ|vL$fz>| z_kMO|A(R=pR;e9EOnoXp z1XI|g@9nQBBcsIr=M6~wdETR=Apen83!PyyZnp*Ojle2v)GX)^X|NiYmHOXdvs-O= zwJhEiD(B-n_c17A9}k_aoqywF92ptrKmqh>W&|YlvTR&wk*z)U4ZVnd+473n)d_dr18H^aoy$ zM71AUQMg5OXMTn-A_Oh9oj+9!lh6@IiqiIgdXX)?g>t|z>5!gzWSXdt!Vv0)fE=Gh z#&X|QU1Uff9`C(9R1MnqAg18cbj}5ZYcgwTNjzut*KiZPW#Ez>+1hNYApH{pTiHI# z@6rq5<*6a&>c+a44A?DjwJ~|M!UR~qBEN{M{G&5?>39$v))ocY+O>L%7_gzOxFi0E zb*PFoCR342Fu6}qlVed!yQ+>>mX-?tIk)Rf(4j>GV-Q#;3my8?GtPmii)O?@k$W+p zJC_+z%GEHgt($Oz=o9>c`R|BIb>eOs;Sw{MSW8K)X(v`XwFN7Jlmdrh)f8~3UUVgy zJ(#X4FvNmyk&@9XWM9)=RGHG}cX8913`jp_LGHElog`IJ@H8w#@6`!Ug{KT>s?_EQ zxA*}GN8@k_y5U0_n3kKpt{nMBh+xEA$v&av7I89?zGZs<{wL_yyyJ6vY`itIXMQMM z*1)OB8U=+}QO>V~Ra=1wgKePC565klH(h8~Vg*HhT~awiYc{ZpsvGx^P@WcVwlutQ z-6ryP&QET_kMuj(Z-~R&UwL0)Dd({MRD1oR=;SwQRA=T@1Z^0k>0w5M^tkSSYRua| zZA+Xme>ogzsz?sOye{U4_Rn!H)<1$30N_DdkxaDOvc4@-MoMq+L;7_fN^Rw zeTlfWBnfvx=}_V{5>cG!KTUQS&)Z@_;Z;uDmmN}{i6X5uANLwoHVUf!?%dYxwMr+iNIxlpRu3J ze8ICA|GFcy0~0hEwCfhPdam&ev&UZe^%g(~Zp#@}=cl4KavYJ>Q_K~#1yhxQ87 z?}o}2j)tY;Q<~3NEBEoJ&g}8;A-;u#TCrxt-b8$AR*886wIx8qHcP~$vbxZP&5M|@ zC;zW!X7t;ys7-SS1R9H*q_V6zSdG#mk^S>epCGZZvSh zljs^m?MPE17o7oWQ;o;$di47ZSvYSB@XnNEtU6LGF^^w{zC!2cHxUOHV)c+SG>(-F z7IG+=sdvLEHNTjVX3d@PURBW9+*Z&O_=3x)J6&aV8h;W{#dRNjDWr8MJ&t!T zAMBXg$uneS`l>b$qQKbTaFw!@1*eR{27l!+dnM|q)ZPMYkKQ3-D6M*}kYPs<2DILD z^4lk-VpP5FzpBjHdrmfpRy_vB_og6qkr^w#?Sb zQlhFVSxEV=%OiGYz6~Y>q|a^zPI081Gdm&-uj%R=7p`tEu`5`N$Wn|AV={`SJiKQ0 zxXo|IV$gwpLl~JxTzugN@azgBJ>1iJwoHO652+*EO0F0~KP-W*4pfd!1qQ=6^gI_Z50MF8%PcQkmNM zD!FvxcQMNereDT25~s=PuFBDrigEnhENZ4X8PI_Y(6?5!I1A6DPJuQ)zdBv@`W{6& zEwOV?SRx-6y6Lnyu78V$0hC56rvbISq{2&b?GJGasqf+M=!%QB4By0mG~iMY9JRtr z-rq}DG_
    6Y`CbhSi~|3LdzuIC(A7#{Ii6i;Al*~e*{cx=tFV$rj`DsG!{n>j3e zY3&2QYVrkvasf1+CKBv3>*TpFu61U%qV>tFt#FL2>QIGN{W}svv5dbBk+c=P_p$(IkT@Fl{>LOp#2I-yqOm89LN%AiWUQV3 zWr?t|qM>L=#=AWG(YA~?`$fY0tsiAoiae4ts6)<#;re`GBj=uli48JR*DUCc5&}={ z>7=xisY(%Yn{GBFIh^gtXQ$(g6je)PC^^plJaCq=|2}mh?yfJ_KugcrH~y}z26h1~ z_VmGE&h;3jWH6jhdKC{|k-xb|EC~qRD)!Njs=KdGun)^tAPC0=K=!6t|HZj~7{@L7 zP&sfR7OC`(H;P~OY~Y0Kxrk^}M6=~8r@-~YTIt!j=_@S=e7{(YvbXR@Mtc&AhR^L| zRHHR*(a(Bz=+bBJ)W$7czG8hE3|;2R+ORG=@<0nY z=VZVvf-*j@fy+=;f?OS#2bX*vH)lO3hMikflBr8)9-cUj{_}zGIJ_3h_mXWc$diio zvh5P7TasH}NQnC*dP%pY=6vKo+)Bh;s*46e8i##ryWRtaZ`Mt)Z!V;u(^3x^hn>7zBCV{|oP ztP)^>qBi913}fyY+JcE!AeuFHdkD(dETWS7rm?T)WjKJgY5O3usbf1jUG;6*qVjX` z6G=(W2{Fr-n5(Pm!D?$Oy4?6TqL~SMScr<^`MJ(jD$u22BYCqHUmE$A?X!DYo^Q5R z7t8_YW>>N?u9pCx$IGfE2rX4;etg>J-!bc?p_oOe4@Sz6+Q}pv853?dun_4taCYcE zIYjte{$AdSZblh8w?wqwWC9ZcN`q z(uX85gY|Wn+GUUoLphmJUEO1#&-p8Z{QY5j*;%kSs3V}HqAWlk4(9;=j*feAF8TT}*$8DJ~)J1^+adMf}3SqT58DRdhZWB2t%VVP~1x??M!S@eblcO%22Y!vxtF@fnT4;k{OHt4en zr-F|=IH)?Lnx>#{^#@_ok-@w*Fn`-9grUE-uj?Ai>zcf{Ef_gh8QPe4w$t13&~EDO zjnnw}llodSlO3-&G3k_c7%1uet)yQ8`6L=hj)?;Hhs}NILD$tEjsy^khEXY_3>4VG zh=Tg)MEH*dh#uU)Va&T#wQrb|{hkOvmW_R_HA2 zQQCor9{AOA#Ly{5zl#ERw3Rmd0YNjujgu|=C~s})5Ct?Q#*%p0Ujx_ss4T3vN1b=? zcl!}oFo&U0ghO?`zpuhrZB(gL&rDx<+oswhwMNwD1H;RTe%`YaK%ECdv2KYS+9k;p zZutD>x3)jFX7n~PqYf3N&kn#`WHdPq{~`q{VkT{^$K3I9)%?&Ja0qcX)6^Rd`#92w z9Oa!{&vf`&H1pyhiz`bhdS-ArN}J}4-|#y3)d&8VzALsf7KV|0 zg|(Da%Ex-+4Eb226T1KdJ150~Zs&0MW~t<3@3pW}NP;v?MIFJMT!> zg;}SkWPaIOmFv@YU!tgEIqQKs2nqPmE-{Vxncm@$#2hiD8A%}$;~|MOwtb@~Z>eoD zuXDMVoJ_#!r1Ebi?^jFIocD$JRFP=w7TIs@fzoK*yP+f=ZUqzFfvSfrR`C4Y=eSb? z%#^Sev^R_%+=RFqicY*(AEdXa*&1mrmd0za%97|`*2nsPUoyr%I@)X}TJQh_;|&;) z#&xx;B87!9ow^}-_I@MhQ=d3}Nlokvg#nI|F9{E~<2SJ2U?0m=4P!a?hFb$HpBlOP zl$DZB;e691YSP(x9v@ts&gkO=^-fD#*m$I)NQ79_tP!>ma0Q)JnX5~S(NZEX>!z|n zUG=PwM$OhbyFIAwqNqJilq5jng)c{0HMPGmV9dF^I08Ij&jKp@+NV`9)5iKaN~n+y zLhjUkq)jF*^S`zzM{vjRcu}Gz#(*>*f4;9`q2K|&m_3>+^QQz|kvv^OTSuDZ7Mqh$ z(VAVXqB2otE75!N22^y(X|PtmVP!}>{bPTYqr%|;)--?*zoEg(vou&s zkjqEo_;%0l5ml2!(HazIfW@|?NjS#^8iCX%wZBb!+}OyoSQFYMx=m}y-8t(`B(*!I zQNY|Ys6aIvLgi&PFn`F%iW1*eTq5LP_%-_V^HEo(r4K2X{oLmXPady?TERw+KH!LS zKGu2;=lD&;TCCHedJ%}P)e@4ITVQ&w*!^W9uarXi=>`4v@+i;to~8)(J~>2YrLq#T z=2dip$9vAOrPxcDobcnu0w@8Ld`xV<3RK@MJQ^!r3v+0Yy$mbsvBIK|;P7+HpR-ofH5KU)a8}r%fIErP{>iu89n;RKdB|`UVDs!Ty71Mjt;SccHgWfV&q_ow-7O%B}Arqt(5ipwH2rlpG`aW)uL8e6bEiEi`iaf%eEGW0V?hWIg`XW>cAkuyv{^=%;Qup zB&8)3%aH6r0WYiZWk>(I5|2?#3nv`~27>pRLwfR)+`k#W*WYePB^l7^UetTW`HUO<;_c9pQVVm0QG@8hNqyTkeO`rZNcPKtV_p|snOOe1I z%bkXTRpWBS==}Vy>P2$=cwHY?iAQsGZ}OmEi2QErCB%wtF*_s-y<%W&MbG49DlCcf zFbJEm%L-8W%h8%uFEq9)#bC%Sm{Y=9Zjk}qH>+c|vE!butje;mL*&zyfn~Tq$}8;f zV+LrWbb+62s}@SX>i@7FGzZ0=9UVunoz6jZR21~C=+3jfJN=T+;t3;pew>xgWUzO?G^#kuM;rmQn0=SQQAbdf!eyY8J!3s(iyueB5)evRnNlL3k_OzEHsiS3=V1vcwJi&C0*A zCSckYL9dj7f7Vp;(_~_u!(8occ^R&5UPUX;OBQ7@eKHkNH`>_YxamU5U_^Uv_^~@D zRAAshtfYTDJaOi}5kP-&W+&u>w=M!^qOM$t!nT};Ym0mM&3V*YnjiVJWX4x+lB{EU8ogHJ*9 zHH&!RYh%g5PyDfchU=f}{>c7vQ;yzEB{$l&6%5qbHM95Qgk!VC&+TBWJDr>3GqrsR z?9nel`liEJxt;!eRY7;NiH`wLYy3+-^Z4Xze}who0Z}6AqRm0*!yE=Fr>85mfo}er z2hpBz+0nU~k)$sV>Pu8C6HO*o^)F@({OBoF?YRdBVg_GcNluRZil}k0DeC63+lM=v z#%Cn|6v;btfKi08+ ze~!M_H=E~#MlJ#vJ`v)#la@h~VFpb1Z=_#Oiy@~k4iif$B!G@&c@&c1z@~wnZ%$^w5RQ!9V8f}xiVPE~}%haE_ zgaknOnbnnNcLg7W1D)L1}Yei zHL##*2L{}!b#ae~l&tk>?7E<&dE6ymtVVW?d7x%vA1PHM8WS(o^Bckfg&H`|wqxW- z$~f&)o2lk0<8p(t{8jgZ9yvcx()HZ$K4)Fntngm>qW)0pGsj)x(x+Q;i#lnhe=?uU zIIzdD-WF)7wy{9_krUKi4v)#+zr`=;%H{e+%0f#QhYNZij;rg}{;25~^&wtc1`#8? z@9{J=8hFv2nRR@NaELRJE1>cyWOfgb##&Cv?YfWr-p=9w(8M8Kw_Y}8&X$elwQZq~ zIq^AnORf6V<_)(gq1bTKHio=jf3S!aX9Eh`k*{Yr`<$7ROY+aJB?oYiN9~)urn9`z z0#_EFDCybAKi!2F@38cFe+{hwPVm-UI+X*CxbsS6G2~PYU*U zyL5VMSn*?@eq>S~)ab3Zy(!~Hg*U7C+u3UUeAy5xcouB<_MP3-fB8pGvoWWlvk!77 zZ*oMaq^%f%ZNZ$t5g9HTCFH|GsK(hyHp&3w=jz$uAq~wykN0Uq<+f|OokJxLU%U7+ zr$=Su#(+a+>!s!Mf4V3=27@`+R@(38r|?JjulbMZ-+ayVzWrQN=%a(CkIv^l@|iM^ zbMjSYBit$;%)=;vc@WOta#FrvPv}rKz9OO4zNl9|^L?z@nQWKcsf1E^@3w?{&Zyz{ znWep%g9sla0*7}={e)I?QBdq9Y3Hh+gqs%xY_7Dk-Wi38e~CXM2=I7V>J3ugv&j#Y zNJiyXG}KSb?@%65Vv$huhvreDAUou$ny6kZ)k(zye-<2i)b7(M^@zKMdT)}1>L9$a zQ6&LRc|MFmmnab%tm@?Mv-Em&au^VBFvskt@%3%1xDfFYA6wH2BQXuY9$Vk0frQ;W zGUtc_@u9y`fAxXP!7y%mWuHUECLRXA{lr!~X9{g_ee^=fXixC?Zgx!>ggC_1#%U`~ zh{xITw(2J1&@_B8=iR(-iQ>oOZ(db*MWMtx-v>_L(_$S8E>+0G+-1%S+!Kk{Y_=Ei zX&TD8N0?!CvISmT`=7T*hTz?sgl0VHKYBHLj*4Gie~Wz#)qjgWUe{K9Yg7_lJE$K} z(31;*)4)h@zlPTaa3N#&A=`q-42a>=oWM&;KhvmH)KKV4>aiV%mJ{1dXHLgo;89p! z>Dt(TIpHZ=_pN81pLU*l?WhEY9&qn({sCXe*hlltIQoW-1R5L{Zc9vVlVG;em;jfPEtQ6u0HR5%ngV70u(7Tq|><;pBLHP z&GZFLQkT{pwLs-e_SOwerIJd6h{<3TMU^1+07qAaCn<+Y7rD2>RXrnSueo%$Rpm5` z_ytT{cN8$c_vXB=I_}qn%k!}a)bm73n4eo3e@wB_%-?T}5Ji(J4}?iHAUSjABabnR zjO$lz(?*oiH+vs?1v6o7oS>F#_}x9!X`z4@xyg>0qT4F&AUcv7%TQ<-LGH;$BR2ks za!)*1>6hXN)~3u9+nNyHb*BmUQ;*g`UGteKG4rdH+t+5KxEWKAl7!srv=%7_LnNiD ze;i!#c^Q^;`;WJkzMG@ce*QDri-xaF%^G6KbC~4=Rjr4D~XZD2K%NI=%uw_mgPcHX1ke3-<@y;3lrE z{s(TfBdE7Uzpkkx@X2a>&Atire-+n;1se%^yq5e1`Oe%-GKr~=`HzK=8!l};Kr|JUV`)hKKf0G%jHFD!X z%j!mw{8mAinZk-7t?6QE<%_wnE}yi#mJEwfh<=C7FIAMJsb)Ysvp>r`8$cOMLrd z*Oua0`_N6{X*%1HQ^N_Qy)v<2M?ZcO{hHv#J88vGr9cMCxcFsof<)ObflaC+;RuxX z`+iCUD^vLKDH?}{3mpdwNS;CPH?q;N;k85WX*^;-(Ef zSLG(SYZ}dJ99-Yc6{q#z{PZ@Whc67}dj_0o>^J?>tZC$8IqsJTe`*X@942LSxDVc? z3HEtOgKlcbxlIg#k&^xL>`%ywR2TeAGXXC%BmH;i6rAa>cN}N^ofP*`v?{P3zcl%I z+D9ljbH5MRebWZ3VXB#IOQ846d)SlY@hEd=%EWmDmll*BvpV|q?1uS#Y`u?SviJaZ zEK8(nbd^e()K-o`Oj`R8}I{UoIM_A5R^V`M-$J^H;I ziUcADpFBL$hZy~jVEQlF{y#Y{O?JjI+T(Y`@Z!E&mfxbrx+zStu@}joeJrhEBg~nm zEo<|Pc+HeQW=J3wVqc|`@z3}-09vJ7`tPZ-z#uRI;xe5!tH%JdECX& zv$H-$Oa0St5iRc5D_E>Ab;V7!U!Im>+#DTqqsCF^PSl)e(ll90$ak9+9xEtGbyDUM zK$-X{ZwR~Kf8}px!i*>SJY&Ck$3dmz!>B1v{vh-)_)_{4ZDK@>!YyiZYwsAO%D92u z2&#gXy0%mYQZ`vu%F;3?y()SGPB34h@pm57$iN2Vq14?dW>&8W)8AoGFY92kRqRWn z>Xy`Im&hxUU-GKHcRBktecj3`GHgXu^6<^tg~{71e`q|H7ok(>hm3ARnGAx%=v2?m zdg6y9-(=5>b~y%7du#=t08aRpC14o^e57X4kIAZ{_DN;AY*2>TmR#I`T}*WDf~Bk! z%9rU}k``3V&lDfhF`LDbVlUR^t+NaW!^?l*t-dY?;!d2lva~M6jv6V&>gtmbdp;zW z6|#xPe=Y)|tqPQP;pWsv6>loqs`ra-q#q(SZJ4V2&28 ze`bR(7jwCEl;YrCH_k(_3EZE-^yE5U{0;+sspT$a0rAzn&cqZvN*?%qdH}tJVQ#nC zt6OTv)(q&l6~0-qJo`*fjc|eLFYxX67)+>D5dwt>gptgfbm)5GImtpznZ3Q=m|99( zx|Pa$U(*OXa~F4B5`cU^zNXW!zc31Xf3-lW^)9Ve$O#Z82_-hg1&zsA1Y*9Rv!9`T z**;r*eQx=-&iu{Q+h@{z9fFfQ^Az>{z2wJ)@)x(yjqi;jvn@q?M)!vl-f?s0!fA{6 zk_QxG!`c>vD-*OSYS)CzE(3rlui{_5-ZMH(VztE_cS%N*4pgn6Y@c1KbcLIMe}9tT z1c-|&K|z%!AQtPyly*9NFfJp?TM4Ps(EMbEJr?vi>;3%GZi1k!zlOgr$OyMCdxS67 zhtSJMEv;=VjWRxUXEC(lL%%(ef#M`R2@OnEbCAcYb7m^6QBkI#F51={{9n1Libu#@ zWOa4(Y3*(swFJzcD~IZFBb}X5f2xrVQ?qqItzT3EhmsN1wm37PqTW!y6@owdxszb{ z;J6y)UW_SRe)CE{Q}0DJ?-D@6Q&D?hm}t`dy~x!&U`3yom!~E) z5!T=dMy-uu9Vrzf9eiOs)?Unwhh+#DG(Cw1MYjbA)F{4gAY-vXd5w$df6E&38PtmK zx~!CGFCXQNzy@EoD~8+Lv^nU3XL7#MD7d^u{*IH1a%QeO zjlXE*c5I#L^-IF*uWpltmZ{!-IK(5BT6e>z>>jNECe6C^pAnA|KfB+E-|OjutP#e{1&kfbZB=H%S6c z10g34x&am;0@L#A{LB`vMtRH4w$LigH|yE*USkW{Q*|ZhB?nmzWfWxVm<%<2i><+= zA}_14KU2ehIVJ19jJ}|(zBG-7wWhYiyvfiLltjYP&cv>j?4`A?hC9}I7b4Qihf97b$Oe}pc&!ZBFB*_GjDIXkfCK-r!@ERrRDv)sb=@Tg5v5sFE_GF3%| z%D`}@gK^byamfFf*J*NWi(+*>1JU3t*Eyc3ygjIqyq~S#HKG$yUP00#vYgzF(E~eP zdld>=0gu{xJk!!92q{x5V-q@S5>HHEfyEzxJs!Fue;{CmpSb4m4*a_GCK#^5 zkxSA$dHKQA?6#4hi$<%^wm=@$R+ToEPEoFc=!+?1Vq&!7-Y#bAwPucay(Z2mDPJJ$ zb{N+?E=s7EE6x|EQziil599)5P@8i-vb;{ZBUPkQdYY~5y_VVLhaOkHNWLjvF;$iQ z_Gz0Vd6?Nte`6d=UHU^T#vRXd<9G3N<|&5{C$Ev8Ka=tIKzW?CJt3Lhr)bw7rh8F6 z7Vd`&e7Hcp^B7Jm&o*Ukn^FEl5KQCbwS*XslkBqgMCw_9uM2WQZ9 zZT7_-Ug@lC8sY)+_ctoE9|N_FOW*H1HhQ3{T=0q$-4DlvT~%q-?@jFC;E4z#F%raZT0=gJhB~q-@1`>k{R!A|A4}ibzgT+`lBUN zRMqt*X=2+o{x&Lk0$u&%Ozm3fIU(7cMW@nH7F^lREY2#@>{;gBuh)fTqk5upOgi5+ zbL1i^j?14m19_)&Ocb7_xQ3Cwh;WZ)Ob}C@e}za0D(#}VNOyhyx#4H&-V%z67(Q6&-J6-Sgt=X`-W;h0LudgKL7O4yfhd0N%$G};a3BWw^3QeEK9+8$ z&yyYOo)|$Z?|=Sxn$dw|XZcw^XwGJme=E;Fk6g4egV{Ou^qfu;1Y(uXb2-U%5Sd2c z|JlyC|Cuz=@=rl5aRDmNl=cw0L^ovSrXhF6>ex6Fd_Y;4h4mz@0@yv{;nY$P>@5Ro z%gFVqd=Z+7NzLtKSn+IOLend?ethOun4g|e+S+nrkd(P8!QqX)2-$%1&sMOre^b^f z%?({THQxxe62h(H6T>w0^RqWRa9`gXv#KcS*^2RJX)mfFSvLP+G1SZ0hz|q+NOFx1 z;Snp&-?*y-(%QvxW!E8*R|xzrh|0Xk(4&kP=ps8aAk0y0!GwRVL@vKz^@?(NKArem z6civKE7CXaffz`gFi^gaBn(GxBK62QN175;8x*CSy-M1<3Xu;s%H$w5sLv)^x3?Lc=gI zblCzW60myA%+UOZ%KDjumMsGXE(ya8yTJ|+hGpBW?3aITct+Pd$$u9uf4a2VCQbLK zkHVczbX_FRYJBR(VN>aFOf~)lEQ_TlSGi$9QpIq@gQYhg@yc&e3NW5~(8}t>g<=}G zD#I*bYu^NUdn))4dsC^~?wRP+Gg%H)t)7Sa7Y-UDZH+(K(c0A3K$qPL1vILFkdw~x zAN`?JZ{2g$UAd^RCA+kie=}Fwl(wAXO)$4V$@_RUX48lt{^q9lzoe!^I%ak#5N}o= zVFJ;_FZM&Rr~Z3G1su%hv_fm}Pf5RISNx^4Qazy7jU?ns=hdon7z`bSz=oB_AlAzc zciIk2f_+}ZoYP1(j20_uq%uM9!T|ksq(CdWj+wg$*FsGUrRmZry zlRO3`6f84csw&qwp9Y1h`|9aWplQs%Raj2Ao<348OZUiy-`%H$HfmHy5_CS&Jtnz1 z%~5m#=2?b%NG{X}^73n0)&;LJhm7kb{%p`Y_vG&K!u_sGvYdli>J)@lAD2Qn4(MMJ z;vD0m?4jqjU=bY?f6-b8_yKToTC89)6^{eqw)T(nOlV^!DX;TYoxAvhDeaTd{U#*b zzt$N14)>8_2yop-re0hMXcUe(m2ye#*o7ZIkc=F7$t)g zIr-S@FV0=~=yR`<=cFD40K>1xZc$lzw4uRAyGDW=rYZG1f5I(}!4AaJgMu58sPQRh zNvAJ+>L1J4Su4^)Ng#owHG)OIZjpc@9^DE;WzqKgReCeyn)pV9VfSmT#4iYRh>!dc zC`C7rs$oNFDIx#%gPMc{3ffPN^rjxQjeO{K4sfCHV67=290|^y`*E+aK^2ftB`y;R zkn-b3v=*@ke-7;~hlW^c&BJ5v;rB&@-IxKvT-jl)#V%0vPE^SgCggz$JdluQy%d}` za#Xp2%H)H%$*2phs_c&z0?J9L-7*-fn|sLj1Ajw03b|tSAx9vMpN*Y;&7)tKfH-?a zcwFpd^@QwVc-L_Bdt?W)gT70}*GD~(%uxsU(-;7`e>e56{{s;e!&-gz680~`aI)S2 zA293%l;Tji>KLio0chO>5~b3 z9vzvyL_F+lE^eJ;bNA8LTD&%vEY5GKQ_Y}pi^ETIWdXcR3rIFYg>oj6`kNk zN058NU{6@*FCa?NW&JOsD>U6pMd5rh3pl1p1=PvnHlF8Y0va9aDyGC1cTt#z{jBqd ze}hXNZ{xg>L%ZJVHGmb^AYtxj^ZG|{xf~e5pQ!fp)`UZD-Ziaa^bVUnE7TGDo214e@;4;c zI}myI`UkJ#=oZNs@}9)??v<7j=TntejlqSNr9(yWe~E41>@XG+3%o$8(F`tOf4URp zW9E&CDSV@!9Y>rK3Vy;j))_3a3_t|v;CP-m0S0&qt7jeDYZQ~)?~0uFL45H5SHvzR zjA_!1rcp0_wquh`Qlw5c$3xsdv8DN8=a&>!Io;1AgaKRaR)L*bdiTpXo5hd}Lj~UC zr0u0~?%2J4&v+@b5JHoKwMl>Tf1fC?=u`CAN6vdFE#7|j+;1fPeSsMC4656%|1dOy zhsneGi!`TZRNZ>kl5i`p4yb)&wY*;{-Bri27gcTAq!9eSEJ44=n;r@PR# z9v+nu1LbYrwMsra-Ko(*+{+B6legph%kceKP7g)jds;Xj_~F51K7@Dof7T>T_Kf85 zMLoeU1Dn->*=x3*-BqVSlOlsdC!_x(qCeDzU>A#f3`u`jU=vuNL$9tHF#y(hZ?U1! z1=Vqktp?%iCs(E4Jz|owqeuER7SIx+!U1}wo~EC>Kw|;m+Djt^>AE2w;SIA{cby3< zzT@AvaJ9tG2f?7UFL?hge?D9aYzypZ6kUr3Dk?cc62un5D#Bqlci@?sv{%rzto^6~ zNh%CbZkZE3-4yW@E8%6+ny8Cd`q0=ppv+%DJg}dCDcD>pRsz9>O*CIppH^U%OVD>; zjU;u-RIJx;UF$(+eeZbN)Ugvbns64^Ky~DkE zP9hI<$l}zeYp6015Io)~u}*c{MJcEJ6hi+O4F%Ab%}|Sny3B*tCWt*<3esk-KZR3G z!LwM-Vfss&iY>vrf7CaF4)I_L41J3DIw1M=+Yk3glk>$UH&(?8v{=y^EC#{vdE|gB zLtP2Dq}P%6R_^_~vV65H8ZW8lALuo*`2Sk|tb5j_jVjub@*_dl?UN}$j-9Iwm>5NlhbvOHwUnU{(DVg~4ak8=OfP*YR zYP|%cA@L&adO?ja87{m<1hV|EVB}7RE%U$cME` z6z)8De~rq&Ey=3el`+#4asrM+ZFk8rOlXB3v}_q5cG+f)H0`CoP=^@5VME(n+yqkv0Yk!kRSu-4+N07~N=NtYH?tGk9 zg8W&==x0d_=IVwX5YLfL)A~qRsLi^~{Sa&&7{ zB5ViM*!>>mp>oiQIxMW)&$tVCyWg9ae-DAGHa|g+WZpBv7peG4A{tO4*}$QCo3NMN z=`R+EJji0Eb*)=L?QaNccgNk$7z1=<3#snU0c@1 zVlqd4A33K#e9dG)O2Sd-EN_jkd+>(=x*1JWZF=-iiC9Fi!nixOLfwvgtukN4;E&|M zLRJhqPpl|Q)eW7@+5%0tvd%MTf5dO3?rHwj$?blw}mVRaA&kx6kEPpiOp#j`%h?Be?t;DI9|FSzH<^k>csCD^UE95 z4UF^3TIdb+C8x09~S067^@Cg}3z#{UP-DEZFv4fTLsf5e~6P6=}NT(A%b zVHETODh!46ZCi*zaXsgRHyfW$_@IdNF*FW{qH{MtMck~W!EG@iIvr9XXrzhg8*r}c z2gS66;i};{HH{%#qaPSxp}jw}3x= ztT#8|s_3#t?q}~SgO(9Y!2In<9AkRQozxUzXqw-r0++WJ@*m6wN3OET5Q$ z%o&*28BR{o-#5z^&N5lNs2V8MxmeSx-zt7eadVATRlu@Ke~t?*9O!X`oy+SvyOOXI6lUkyxcp6B*C$g+GK-vkj~q*-`=59F1|!a>xs zU!@efx%U*8`wL%h;QNNf8>Q)pV6i{%?xPbg`Yl-qpKuF1H-O3mP6xcReHYN#rV%Uf zNoPiA!^awGaxG?eYEhQ(e$ajNAFTFuKLW0_)^ z`X%R6m8zo2Vo}1cCFSd*MAJ`<-@H5XF1rD}Y*r6Pf7+&GVMPQ#NE|J_u5As$9f23I#aeQ zb`AB3fBP;_pb^A^?kDFhqnvSIFF4SO-dGb-T3OfWa0M3q0x+M!|FWEb3TH_{drC>p z^d-C#OOkYFqbwk-IMMLSo}_fmH@mb}9=gnCoDM@wjUT%nu<7(E>D#Mmphtimj<52| z4yW${yW~fl&k4rPtv*=*$FFDlr(ovcpD0MtdQO9<(EThm5tXqN_5M)zejL5QB$ zy!IzGH=55g3EjoR^9|S2qj&>~#*8WKs~J2+_gsWhDz_<55%tuHD}n6V*r75-e{{;x z{RN|VM0uGgwAy!oP5&C9mD%ww14cP8&{{ol;pu}4!Jvp(L4;*(KFZ6tOd*S z$a~Ovj*HutNLt(vZli2%sW1GQJ>>C2ra#2FY;qdpj}oA@_?KBv$3u&+O)L5X9e~e< z2Ln1-O5!WGIpV+8Qxwv>Y13ane+Zv-TcAx{1E@dbmp!Hle3SAQ_))3iQN#!4Rms3G zLj*P(I`efoL0=u0{Du(GSM_;tRK>4vO~KCN$2f-yjjuJs2CxnBYCuozMlfIrlR^WofU+(ZZeTFZfEgZ42jk5)*2Bp?tO zavBj=0Xd?Beq1w$?Aha=#nqUdj5}Rw(H25t-ZdB;XtKMz|B-WwpUeI(?a#3*C^7#Z zT;=BEKIc?PYf+gUu4moNKI_<4#oQm!JzeRzK>gWca(SM=OrOR8f2%jrYYKwYb0*PF zfq(eJ@A+7as?q5fhQ@vN1W{=cn=Lw3Mb!}&7(L(r!ip7Y!kMe_DE=i8b0z|%h+1sY zgRMLmz0|;dc~t>KuQhry%|7Sbyd)8wM1@IjgG@%eDx&d4m#rZSRm5TQ^Rc=2giN%s zTs{6pO8b@{Xp4f*e_@LhS4W`ianu%`%-U%(uDSs2S==>Fn;cG&*K2zsiGz*~4`Lq0 z=sE-^E@pz7cK@9K@P(f!E54i`Y!FIT^J6BVMEZL1%_vBWA0RWLGua)GIVff9XA!rL zeoT@i3Kzs7l^EKTw$hU7o*26e<>o;7ojPn|V70}{{zM*te|52R8a>$~3QxlhHNeGu zUgj6aiec`FGhZ&A&_)I_Ku!pdj@kZsS?(_7DM{&-=kJkI09{Vbbm?^vNiZF4U;-rV z>9urGawy~Dt-zkTw@lEqYL~@`!kGCibEC?J)(%;3e=N&zr&eF~y6TKmtf|2-qUi*e z7z{4lvCY+Bf1ys30dSepMq^_;2D{|&(>C9VYJng@IYs>v0|L(c0+9guJIvfns?t;| zfN%)~K#+F?GS)jBkUmlg7@e|CHXz#3`i{&8vtf&azPbUt34IapQ0bCh*_=?6SzlMO zBM7enQ9Xk2>V&C|dHxn`gFYEloW4`AiDqZ)eGx5|e;K+0350ij!zDA(u~ax4qpaP# z+qUvNv)?s85k*UjNHI;y-s*g`;as#kIJUW^nT>1nSsB|VCmL}5RUg`0@#ulizNrl8 zjyrM8F03FK2e&_OBm#Fwn_o%O_H}VsAtzQvI zk>>the^q=(nWOkJg*>!nyNhPU2}pnhSdlA0(RA}i_3iVW&KO7UBXJcUdc!(_lz*t2 zkv_y$awIsLW^E8vYWHcX>sK z%@2bP2ND!DAab_6Z&zPCMr*z#;e6q?U@pyAe5^;2*ZI z)dxWkzZs%muqSO;$=(dwka3cQN!n9YYfOzLKHKGsHIaC=d={r;&&j^*Cuu~z>Lpi+ z?_bo=-k9yhk`FhSQZlc!E=QS<_?2fxmoSi^3OIaePjc=HSHJrTsBW&OP$RvY{m{up zfA%FK7!05!ddmD#!C1fZ9hD2G(SFaSp zuFhB)t5Iz34jg*(-5H3vW+S#A3PcpzcpXV{cA7UF6uR5VU?})EyC1)_RkUsQ;Tqs& zu^#{Z)$s)P(umql(8v~MbrWR{(g7-;e~|&L(IumVFIhWh$&((J+dRU2a)8DoQG*qqd!8R8?U7qyBTL^o@PLCA)?Ki5XrjM>QH4#z( z#@5ojouIn6+LoS@nx+n`K%r-bfA%C=kbZM;>hvZGX^Qtb#)oi+(1<3Gw1Yy+GGHMc z!=h`}E`Xh`vcawodXY-J1h(|)vjw7~q=mv)B{3nZ2oLg-}wOT(q%G;>qpfW9kZ{;o+5g#oFQGag+ z*{goo@_})tnK&?O`^dE1x1zmFQu9g7In$hl%PEmqOShSOX*&MTwQ69|p8nU?SiP80 zKO+plW_~W$mZ&8_1r7ahe@!HxtZ~0s43qXXAaPC|gL{HHAzq9)lila2vFa3c`+M*& zPPPR$0J+yG(Il=c)&q^Oi^g84&9xIgT3riJ8TsMVCWJC%ARI}txn8vWc-WpHXX$tA zj0AP&zk3Q~XoZqk*ZSqusFr#I7c!juPu;6@6wnyW&|FS#zS&s@f5RR#tS+QRz18@G z4Y$K<_v%_65R?FKk0@hPkGEE^k2;?2DyVGe$UC!cZZcZ!teqpfnYkF?#W;23L}$YHBOohPSjeBK5Tv|S$%CZ-eAF2NEU z|4;_vTc=PrEGi7&vFd66@K@ew?;aR&bTE<;E~){Z^79i&f7Fgh+^f-R3j;u+Xt3R~ zThWC5dBuF5sg&-mMC)c15jIeP%u82B*V?1V$2)lO@-@P*@?6@~JM4O{(e}F8WEp?l zYnV2K5S(5F+>mP8Qd4zvgY*H#7!)3B@I%Fk@}wLV9T>4nqYrv-7OpLtmc|UIX$)yJ zjpe*wL_WZ3e;dAzWPzlLo(VP-Q2zFL_TN1ZbX-f0tgymeTXk{akS7RnAzhUgGS9eSpp z;DzM8&ujbvT2#gIYCAwno0E3unt(JX@wfGED;{lee~nPi7!Vo-mYlECtjkf_W5tqZ ztw8a^n%^HboFVIC?L*y-=yEv_Amo5Qr(*ve&IP!I9v!l2d@)5vAmQT{n_(PUJZC$^awvZ!j9n!=3xs6O4M5^ zl<1Evf1!QB;oj0+ru=z6QuRb8M@slG7Ft#it)_hgQ?Es%P?F8=53xngejjaMRUo(r z+_XyuCB`fvST(ys9}PH{6)S$9d`vXbFe|-7%Yg%lo~TiJxWR`v>@TXl9#ZV?@y68U z2mWj*T_i+e;B1iJAD}AbGVcmmM{^vBV^u(de-U>^LrwF05N2EJd*kD;D1dTN@*Ez= zM=e(E3=^qknUi!~aasJ^u?u8bCqDfHQV%49spG$KO!oy-ClpH+KBqBGud`XIE$56{ z5ob5X4fjau-gGDd;1QaebhIO1uk-b5rZ`qbH2 ze;C>67tJttmhw*>JZK`BPhL!L7a>zk%S`Q&S0PDyv%Mt!mkg2S-xWX)HCnRswyets z+d|2Gx-d7~t{cM1uHE_b*@?C{Q)#yyON(aix?)er~XHY7X&F zeMily4`)=V)yL_kcuNuU-?PpLUV&vy`r--FGU^nuQ-FA<&GxAU-4os{DulwwqH2|0 zFdtZ-^vTIkXx%b4!CaG=IPDq{yT}^G&OhoOU3g5iL>OSqUmz)CM=LC{lc2kve@yj3 zPE&*-g+0JVcg7tOiRd<-Vb=2lJa6tSk_E%k9W>PS*Y1VM2=>u5x2|zP3-&Ilen1n< zhdt!=pzDCj2p9bJw1M}~f%OlDe~IA7`dQM4vA16ApBi)w*Wt90E_s1kbOi z^V{23NiK$?*M1TqcA-HB!4a!)*k-)yK!U?Xjxv0rr*mUjIiRMS=r0JTDzI#2A|G+# z@q^IWPAVVYpsVnH`qccL!?Xd(edt+@bF=xdZcC! ztBQo6-a7Mni$_5yhKV7se^fZ9fInmdk>8+lH=cGnJe|Tn^?lbw$*cU(m7$31@!Wy2 zzHkOIHhU)r@S8bd3Q!a?p8RK+^ww2wVp4&NW?1e3Yr{?W5?!yNtO7u+eRN_PL?5t6 z8l$ft2iG@p1{YPIE|WUWtOZ`ZZu|`2DDA4RJ0kSsW`)K+ljKNvf30ztgeTnra*@TX zU{yJ5#euyqqJLA9JZoauW4>Alo2F`0TcxND8){TCBc>aq6Zu3#(o89h>*|r zG=!J9iS&0Wr8%mRmr|^_%`J0%T~5x_x2s#QGpkCq2&A0frb)Te##Js&OQ^{T%~RTw0}jX5Hg!YFvJDjDf1oTh&dK|QE&KsHwG(9H z_Rvbs6ndxYRwP`P`mfTSKxBk^3XuLF! zaTli$g6Cv>iY!+XuoVA!Y_-Y7a2&gUc>r4X1S;YJC!m)Mhr<*WrH5TSAcC1>@hkC! zgp`;iO`kVY6vfm79=xGE*wyzzf-kpvy6Z7wzsy~3#tlU24i$1`CoLB{t3)<00e=Bd z{pK>)f6vyY{LGp=bx^?%Ab*FGuR^n$SSZ~dET2OHd9W26^lRB9KFSdfpI%tX&xj}N z1Q&M_b}xu<>ga`+C+pp{ zT1nd}_LD7h%56x&DdR!cWNm=QizE!;HAiR@AT>y7p)`$c;}&W-vG1f~0#H{ezTc%I zH;o6j#FyTgC?=#euSiaEhgzj#SsXcOcFt66={B44KWDaGm)s~FBSI=@qKvP|5W!~0 zf4E1kSFy;?I8h4GXuHPzHbBZDRCHibgn01>(#+G{y98=BibybYY^tT-{H=|?ra8#v zWF<-o#mg{ex=EG+K)iPYjWI#Lv-LJ90Xv4ifm*W<)YAM6$YThet(k1%;WYxxTwcHp zx4y47b4OqV3da=bWMit4HFL3iTf#}ce-zPM#6w6i7A^B}MnGXejK@Tj(W^sk{nVFT z^RwlC)EXM}U0=v;-_GB(K8?yfkC%KR6%L)mNI66`1SA(|w52IDXF3i3>Es|Nb{j6A z5lehf-yarsloL8KNLL=qjLYk`yY6|83B3VhqKt-CYe|_x8de1o8f7IC@ z;LTzEP_F}|71Tki`alS2XE1BDX!c>Rz;_ME#UQ9hkig3v;$y~zr)HlN;5EII)_B*% zbXnYqBH#UHDIqC>`95kyb`s$bS-=d(LDXIO$#DS{Ux;x-M(NToT3110I32m%+lTk` z;{&&W+M@OsdPm2_O+u}Cg3y@^e{dp1n|68)tF|c8bWP`HU%I6VY~CUdxwG-|3MgfQ z4o9f(*imC@pf}iw5ZSiLxe(IFZ_G!;{#4Z?s(8v&2`mp!`ja1h)~k12e|R^=P-mF+2thG3NYWfB46i=izw& za{^%NvaC6bDLZ|uX28p{01qiAWh&4dZ1^wSOEFv$dTdo54-sfAB+8rp5w@b0#PX3-52i~^?NXrO*24e zWLSoY2BCdMDFLXK!`N}Q|2;*zbWpbrLHQ%hTaX zw$BPaJ~<1xtSR$Yc#5FkVZer&gZ>Qh0cl?-420gZ8yl#NlXz{5l6okd-@~^NrL+l- z{{oXU<*_HtpO5sJSFU@!<@XDE5pN5~gV^SpT?WznS+4_yeN|8#K(r+cZiBlGFt`na zyASRV90I`!?m7ew4DJw|1eYWbEVu@T5D4xP+?|leld7%SeO234{c*d_NB`X0eY?)- zgXL-Qi%4$5M`-sHNtb#kMrQ`udb=~Qp;tj+%=bmj51Y&OmZc6-<&Rpdef%nQxlX|;(x&=7;KdW?KXjMDoz8I0#|ZHoJhaVxi3g6;8) z{6b<_$`f<1J6ORE?FcF@167T7t+U1iySZsZ;w@P8_ZoplW8!BrOqU2a@aKk*obfFb}Jh`5+^{qJ6PkD&Io%3ohYBAZ}y|x%K zCCj@$7ES*NA>Wx-))i^phPoKGf7&lNw909yoOsl6rB{PYavm~%NR@f?rlj{BSFo?u zP!qD%F4}uiy#M?c4e=fl47BY$(pTkWDS^k9hYuB@)7;~pg(ley#K_@Qsze`OrpxvO z7Q8bHtjXkTDE&@!H|I;z#47$ha?B?ulTM>-?ayS3!`4$6+HBG03>0l`L#lbJ-lwjK z`oIpwLRv>2NJJk{)8m`8RL(HA>NXswJ4Bm;Y2OwmjD#wn@{4GB@orZc5n+J8{b|ir>a5=rP7js1{bzqGJ=RUt>S`NliUG;lPiOxgWx+;uDis z-Gmz7r2*9^J)44&bNoJ5U=%K*GXQv=A3gYKY| z1#VWc{M2S& zeb0>)miX7dA6s8!vgCe-H4~H;-^nXC_z!GNivy60NUk?tT$@8G_*0}x%cYMA6)-?S z;x5~A4+ioIZ4Hmm50}Q_KU+DN7y1Gxi;Fdy{x~uUbKWsiJua|zej82UD|b2Qse9r5 z?|EcGdeBHLXp;p}{uwrm!arLq92dVrA4#jww|`qFuAUzH>g6{wTOs6`pHCtWS$Esg zpfLK8P^ZqHOs!^xJE2=USGE3S(9Rjxo8jdayZ1VL@?&Lsi51**`#H#gHcmf_!LJj` zi9$%b`Q8#6Zju|s$N#oAeO;(Uyih<5Og)qwt8J;^y6C&bT;saJfWd3XfL1>=@&z+M zu#!=%!;tpL{y#NE!lnN`zbZuU2lLpg#DoEl5_pM=lmWN+G2}gJDk0pTi6xHNlM>wKH{5Z`x9j>`a%AOJXH#op)A@{q(dOGzRL&lcX9mELI$QVZ!_?Gg| z9xtUwm1J?*2Fu29!F{K#{7vSS(&yORQ}!1B)xZ+R?M;AM=F>V2-rQkV-Gdl14Ks6R zHhz!dnD(<3;aH>W;|w}`>CPokF_&yewZC?J-9vva6E2$@PP@xHy|F1+7xXiJSUEX# zz)TC0Iy!GHQMtV3?aM=MZgVjbh=wJVL*pvEZ0dmcdet-ZH&)mm^Pyr(zmDTF4?B88 zl8y>v${Zre)iHC*S zcMo;s`{vh-8&5rb8z<`yvKy>-q#M6JgiSkXq~$gkTDep)$HU$@3amU2#;cn! zzL=fN$w!qCu#E6rHd8>TI`m&B729t=BKEVBMfe9{21eli>fHoi$L&B=h2OLHS|7pz zF$}Hu5j>v!|Cf=dwG%d!pRd_05jn^ez|Y^j@PzCy2H+QL))NLO@BsLQn{#XdD4YO( z(dL3=KnxkOU|JUo8$bk_rCko7M-dPbN<$_ffv=b@crFbRh5R;DpAAvrP<%}`<~zE> zVccXrbV0Fc8FQ-OE z8O*-ROq^mXC#o-*MpdrSpI+Q%H8S073oFec9K#vb?{D{2`W12cUNO1bBL~$}OV>ko z3T~WQJSA(?78~ylD<#l*=US@WkbKzw8ob6C1jbE2*W8G+O%)(XK`Bazi1 zdLx*Yh(l7;cAMu|F_B?4CF{YO^R7*BQ7&Ir6Zc)Y&`KU1iLaaRntWy5*v*2ie zl;4bsM1nu^J&6cYtw<`3gKE4sHnLH%c#euV(Gf%&ipNhj*W(yt5!b1VG`3#U0VhHC zodP38YbVmHY~%nfIm#p4T-ubr8GykHky2OWJX|8AYqtaH=l>JtdYR+RtzhjRf zCklN=e!-Jh;!?U_zC`1<9L0nkpx_ECW~pTQJ}xxQATS`eG48qWn?8QRPX7R1^T4_M zA{Q$4v~&1Gdz_fP6p?fvhX&ZU31G&e{eC}#ROY680UkwaW+Qg@*@tsm3Wb1NsuTy_ z$U!hzfB6}9SRZ)WHV3$sQE>ac=uhmAI_X=>M~X_)-PuteQ;vBGGQzX3D&_D zu4~Az(mp^Y>b3+5R=iV}-g@)ru0~$=a?1cyM%}%ThG27q+IA85&~@cXNWGQ7iIV3L zf_H|i6PY`@w7U1xw@5W-(%P0rkMAvw#=?#dVNAE86-;m!&w{oX7hmv4uk@a$H8P7CEn2BmgDvR5Zj-hsQrJbm69lgX}Wn^Xc+8(VQi zbhGIl6S?0^je^J9-WbQz2FPO2`$1($)e~e$JTHx$0*VIwFh6P5MG`stVKFDnS&jqe zzGZS~x4~VUD~n@at-bAZQz#uz`^Tt$Or4Ww9IMW=C=6{ivGE*0a@4R4u9jC|p`8k+ ztRra&Hta^Hd3R-*jH*@_j8T{(t}qdn@u}x$vk9)kkGGDA_rhGUjf1H_Xlzu#=E-gz zB-6Q!+2J~&R}Of$$Lnu=M7OVakn5-0Ox8ge>1A-+!yjj}$FT{u9z5^U|4N&#>o?aZ zO7q?#LK{zw5TOGju}yRcH;i z-Tz8uvURVcM^&aWui9M3v5|-TjSh*?T9Xfnab#gr0&{pvgNrE+p@Nvx0#y^1!%(NK zvkOY8#?stKMC-w0y_WMdkA&ihy!f^sW=JahaA!(slFJu6L{M*1@16lQHzG{yn6n^&)oR%Mivzbn=vkX~Uf+ud*m3phn}*xAeKWwbjQ9 z)_R*k+e`^0+d!Ppmsx=MtMBTOtV8O{U4@nv`duAVt7V3gH=%W&caUd+gQ2}HsUNoR z_TRevV*b@#D<*CyUB~O<7OiG<3JvUT9(~vHX3y=TJS*EjV`!aNWfuYVdFVn_x_8PC8zCSgR_iGTMB)!PTj<)F6?=oZgG5R*G1X# zfccWvmSbAdOH|}FV-Mogz_qdXR%{P$W;=i4?RL2N{fi?U!(>nU6W;A3Cz*dYMvn2j zbgxD)S89owt2oT$QmT*{ogu#^KDR=*Nzy`zE)?2+fY?PFLAJWN1@DW|CSpFlxuNb? z&2%Z(V?{bwzoDq<@4`C{HJ-XH9$KH9S6>gF%;&qPES)XqL=RQ=Z3pm48E=r`b?n7d z`h+Z*3|n~Jf5v_zS6`W7kmXmy)5tPH4&D@<=GE+cJJ6mGe$ZK%8#JG^V~+`>(0bhe zBc%4T?$-*3^P(RW;y)V_h20rt-Gq!a0zc~~FZbTrlS`T*d{A95`W5VA)+H76xH~*!IZ+^~#xiWo;=d;grF%;O z;x-q@MqqvDQdgY(xyvNbE-F_wp``5QF9`cleV)P~6n{!Fiv5e-4@fUd2xlAZ9pVZe z>E$QulySvopkTnUlt(}6>7~PYINn(Jk>EBb$}-ot>HGYPe!&ke1vg)$d?l4sZ@1;zHa!K1 zW+9t4^`?o6D*krsBfmEr1ux!EKg3HQ9j=QG)m?ZnwmrEV*{nCZvmZZMq0V+&%*W-x zd>9_rXqIDq7C8h&-g&{7J1WCk2mfU)9r~xfxhlregT^kszWx&KOa*6@o$>Gs%#X-2 zFXvORfwOYTgj#Q`q2+NsVf^#R74W$JzW#7>H;cf?_;=^~`PK8x3+LzizqgUIu*dEP zQ@n*e4a>#2w@J}+eI=qiGQ$XFHvMM;djw8JdX}eLeA@8s=D@K(x^8gZfZn2Lk#6ch z#Hzn+)(4$R?F49$yJD<)%f;sHW%;QSUlEcwv0*SJV41_v7YF&Ls+yF6Uq$bS%%=)E@Y<|;+Z-D9X75BFA#LH0KafjE&ZpMn`kyTy z2KK*NKKX$3OcK{(#ZYRBoV&^;6S*V?>Y%6B=X(o!D-y(g&*J*zO@*XcCx}k;U(q54QO-?y=m_p3( zQ5l9U%+Q5B)znoqes0U&A~(@9h%Q|Du%%JY;(BRep>$?w)QoXn_+pr_kU$TOXyN-= zrF@netTiD%5T5O2Ct8xrV}6%cWK4gR5#LMsT>tj|oP2vPHmhHY9S{Je)0U=%e_?eH+<2lw^=7~l{1@X75BX=OCgwFpIuXu z7SDl-!?J_a_K1*qr@D~nl{9}vSv{^^KVMo4hN1#V5g3OD#%Kp$fXz~N^Vpe^q z{;4>ZPY~bepfa@Vlb|u>_>bHgv%_@8>-H^7V#4ZGQ7OBfpuUXFwxerkg7mbT_~9H+ zpvXm){dMlmVu9_BsAP(tlY#oR7w&r<)Bg9l*{wqVP>Lf?z5kcSPe3GVtq~By4H1RD z3_&42K~4yi6#`*p2k~mS*(g|f+k)5>#GnwU;QxVS#eM@g00f|E-7M62P$-BO=IH6= z4dN5x|Ie0?4n;&rBt?c49%3-+x&$F;-{ZXbL*mZOV@X6n!A3>GwpgY}U(SdzV5e8| zbw|~6>M10PWI(&grW@a}MLaLxTs2n~T{Xh4NCff@gd;O3t11IvMyVsg!~>vV0!xy+ zaZGl*nb}e-Jdz|(S^M@@Jy@U{R(hNY1#R5pxGRmtl3pdMPlZZNi8s$PJ-F54}>)M%c5`Q_sW ziH{w%N$KByv0hEXUHE*1USC~Vmw*ZJ$S&mUoIdA4j1(f!K72gSNduIWn`w#7oU-fL zql>QQfb89)llB7y3X&3r*nWvm>V_7GNx!ANJCBqWOBz56%_Qq%MW=m3@4k$Y3B=Tl zCxacPjN5;0#21;yh!1%km|8ZON6=j|aFjX_|A{RA$*yt@F1xHQZG82Zy0ZT!N~7g3 z^lAnivgt5!I+E|W!OG=&IDTPjD6}F-(vdyzIB{gr;9Mooj3g$*isUC#fYghu2>9WA zAfJgeg4~g)*t-9=!}8^^ds@iu`;&q2=$u5(pzq{p98Xo|U2lL%Hr&qZ=qSy&X=tVH zZGj^pcltnOt)C$WUktS(?7kh zmZC|dbDtgMLN>eR&?r90(PTVOigHY0=VG4>%At zJ9p=4c|XXIC=-*=7c99z;Yk|HryzKq##ZHY)*zYv6&~<;HGr;YOa9}f>IGKb4G?g; zpFE#`tjT)L_5A$SRf!NxJG-FylYRXjRWn|Bw^yzH-@zkrj}B`S?&VtwSumR z=pG+>;I8Iu(S8ik!e>WedHl<{nZ4Tag-Meb@{_AyIjbM0B`N3=5Lmo1lS6f1gOYHy zRHZE_OpdmsXH6R(rgItQBj`sl0;N`#Yfcis-`K;**IqRr3R3f&{B|yp&i+enDYUIK z3$Mu=`Crpo6a>jydP2s^YWNNyhYLbL<{(}@$3R=qOCE!G4MCT<#nsO3B@+3cNZ|!3!6z##uc!zSfXT~=2#P`=B65m?f>2puc|oXvET14m z>i+{l|1XUBe-{TK2qeqB{bf_bo*GspQMXc_S450hB`WVDF=HKwN@5F?={1sJ+IH<> z?0&oL6 zwdlpzU03al?^BD@%VlI!adYo>HBZokrf%LT;VyMsL`$wS$ZN7Mlr^j)%loE3%Gz^< zJlm2SOEro!QJK-A#>~S#@W;Yh<8yf?>5$Be$Z3$3didOFuHJ>Z1M*N&)=5P0CXg%) zQnOOq(D2JIY?Wv4&;qbrOg}P9Ot!Dlz}UFDjeviO+OA0gVoL0 z>qv@IE|m_pBWLY!LvO8PlC=?eaqhz#jJlrsRQ#~6z%RtRB18nDpnkde+RXU-A&b3q z5#4#Vqs-$$VIMn*fIXj;utDtdsF_~JjYfBqNZGsU=Xm?IcD%``;a)mCoA$d6ED7=i zQc;2qa$lV9QSgLb607zjffHxU_4sIhi`)B(l=$1xW18`rf5%Q-m$o0O&&Qzy0SJY=G21FA4Fa0}YQrh|_ufez~J_Nor6G97dP9J`rb^8CFa$eq6 ap5FeRwszQj!a{ Date: Tue, 7 Oct 2025 11:15:02 -0400 Subject: [PATCH 019/117] cleanup(ctb): Remove unused MT_CANNON env (#17731) --- packages/contracts-bedrock/justfile | 1 - 1 file changed, 1 deletion(-) diff --git a/packages/contracts-bedrock/justfile b/packages/contracts-bedrock/justfile index 08bbc114411..6bc72727cd2 100644 --- a/packages/contracts-bedrock/justfile +++ b/packages/contracts-bedrock/justfile @@ -91,7 +91,6 @@ prepare-upgrade-env *ARGS : build-go-ffi export FORK_RETRIES=10 export FORK_BACKOFF=1000 export FORK_TEST=true - export USE_MT_CANNON=true {{ARGS}} \ --match-path "test/{L1,dispute,cannon}/**" From c292ece85197bbc3f43de2f1f67de6920316d673 Mon Sep 17 00:00:00 2001 From: Adrian Sutton Date: Wed, 8 Oct 2025 02:10:47 +1000 Subject: [PATCH 020/117] opcm: Switch cannon kona tests to depend on dev features being set through env vars. (#17746) Previously, the enabled case was tested by explicitly enabling the dev flag but CI has been updated to run all tests with and without the flag enabled. The explicit enabling gets in the way of testing creator pattern changes. --- .../test/L1/OPContractsManager.t.sol | 36 +++++-------------- 1 file changed, 9 insertions(+), 27 deletions(-) diff --git a/packages/contracts-bedrock/test/L1/OPContractsManager.t.sol b/packages/contracts-bedrock/test/L1/OPContractsManager.t.sol index 4d2056137fc..e2ffb7ed48f 100644 --- a/packages/contracts-bedrock/test/L1/OPContractsManager.t.sol +++ b/packages/contracts-bedrock/test/L1/OPContractsManager.t.sol @@ -719,18 +719,10 @@ contract OPContractsManager_AddGameType_Test is OPContractsManager_TestInit { chainDeployOutput1.disputeGameFactoryProxy.initBonds(agi.disputeGameType), agi.initialBond, "bond mismatch" ); } -} - -/// @title OPContractsManager_AddGameTypeCannonKonaEnabled_Test -/// @notice Tests the `addGameType` function of the `OPContractsManager` contract with CANNON_KONA enabled. -contract OPContractsManager_AddGameType_CannonKonaEnabled_Test is OPContractsManager_AddGameType_Test { - function setUp() public override { - setDevFeatureEnabled(DevFeatures.CANNON_KONA); - super.setUp(); - } /// @notice Tests that addGameType will revert if the game type is cannon-kona and the dev feature is not enabled function test_addGameType_cannonKonaGameType_succeeds() public { + skipIfDevFeatureDisabled(DevFeatures.CANNON_KONA); // Create the input for the cannon-kona game type. IOPContractsManager.AddGameInput memory input = newGameInputFactory(GameTypes.CANNON_KONA); @@ -751,6 +743,7 @@ contract OPContractsManager_AddGameType_CannonKonaEnabled_Test is OPContractsMan /// @notice Tests that addGameType will revert if the game type is cannon-kona and the dev feature is not enabled function test_addGameType_superCannonKonaGameType_succeeds() public { + skipIfDevFeatureDisabled(DevFeatures.CANNON_KONA); // Create the input for the cannon-kona game type. IOPContractsManager.AddGameInput memory input = newGameInputFactory(GameTypes.SUPER_CANNON_KONA); @@ -1035,18 +1028,10 @@ contract OPContractsManager_UpdatePrestate_Test is OPContractsManager_TestInit { abi.encodeWithSelector(IOPContractsManager.PrestateRequired.selector) ); } -} - -/// @title OPContractsManager_UpdatePrestate_CannonKonaEnabled_Test -/// @notice Tests the `updatePrestate` function of the `OPContractsManager` contract with CANNON_KONA enabled. -contract OPContractsManager_UpdatePrestate_CannonKonaEnabled_Test is OPContractsManager_UpdatePrestate_Test { - function setUp() public override { - setDevFeatureEnabled(DevFeatures.CANNON_KONA); - super.setUp(); - } /// @notice Tests that we can update the prestate for both CANNON and CANNON_KONA game types. function test_updatePrestate_bothGamesAndCannonKonaWithValidInput_succeeds() public { + skipIfDevFeatureDisabled(DevFeatures.CANNON_KONA); // Add a FaultDisputeGame implementation via addGameType. IOPContractsManager.AddGameInput memory input = newGameInputFactory(GameTypes.CANNON); addGameType(input); @@ -1065,6 +1050,7 @@ contract OPContractsManager_UpdatePrestate_CannonKonaEnabled_Test is OPContracts } function test_updatePrestate_cannonKonaWithSuperGame_succeeds() public { + skipIfDevFeatureDisabled(DevFeatures.CANNON_KONA); // Mock out the existence of a previous SuperPermissionedDisputeGame so we can add a real // SuperPermissionedDisputeGame implementation. vm.mockCall( @@ -1152,6 +1138,7 @@ contract OPContractsManager_UpdatePrestate_CannonKonaEnabled_Test is OPContracts /// @notice Tests that we can update the prestate when both the PermissionedDisputeGame and /// FaultDisputeGame exist, and the FaultDisputeGame is of type CANNON_KONA. function test_updatePrestate_pdgAndCannonKonaOnly_succeeds() public { + skipIfDevFeatureDisabled(DevFeatures.CANNON_KONA); IOPContractsManager.AddGameInput memory input = newGameInputFactory(GameTypes.CANNON_KONA); addGameType(input); @@ -1167,6 +1154,7 @@ contract OPContractsManager_UpdatePrestate_CannonKonaEnabled_Test is OPContracts /// @notice Tests that the updatePrestate function will revert if the provided prestate is for /// mixed game types (i.e. CANNON and SUPER_CANNON_KONA). function test_updatePrestate_cannonKonaMixedGameTypes_reverts() public { + skipIfDevFeatureDisabled(DevFeatures.CANNON_KONA); // Add a SuperFaultDisputeGame implementation via addGameType. IOPContractsManager.AddGameInput memory input = newGameInputFactory(GameTypes.SUPER_CANNON_KONA); addGameType(input); @@ -1189,6 +1177,7 @@ contract OPContractsManager_UpdatePrestate_CannonKonaEnabled_Test is OPContracts function test_updatePrestate_presetCannonKonaWhenOnlyCannonPrestateIsZeroAndCannonGameTypeDisabled_reverts() public { + skipIfDevFeatureDisabled(DevFeatures.CANNON_KONA); IOPContractsManager.AddGameInput memory input = newGameInputFactory(GameTypes.CANNON_KONA); addGameType(input); @@ -1206,6 +1195,7 @@ contract OPContractsManager_UpdatePrestate_CannonKonaEnabled_Test is OPContracts /// @notice Tests that the updatePrestate function will revert if the provided prestate is the /// zero hash. function test_updatePrestate_whenCannonKonaPrestateIsZero_reverts() public { + skipIfDevFeatureDisabled(DevFeatures.CANNON_KONA); IOPContractsManager.AddGameInput memory input = newGameInputFactory(GameTypes.CANNON_KONA); addGameType(input); @@ -1834,17 +1824,9 @@ contract OPContractsManager_Migrate_Test is OPContractsManager_TestInit { input, OPContractsManagerInteropMigrator.OPContractsManagerInteropMigrator_SuperchainConfigMismatch.selector ); } -} - -/// @title OPContractsManager_Migrate_CannonKonaEnabled_Test -/// @notice Tests the `migrate` function of the `OPContractsManager` contract. -contract OPContractsManager_Migrate_CannonKonaEnabled_Test is OPContractsManager_Migrate_Test { - function setUp() public override { - setDevFeatureEnabled(DevFeatures.CANNON_KONA); - super.setUp(); - } function test_migrate_zerosOutCannonKonaGameTypes_succeeds() public { + skipIfDevFeatureDisabled(DevFeatures.CANNON_KONA); IOPContractsManagerInteropMigrator.MigrateInput memory input = _getDefaultInput(); // Grab the existing DisputeGameFactory for each chain. From 0fd61ccb41a7bd5a8c5f174034aa743e206d23d2 Mon Sep 17 00:00:00 2001 From: "devin-ai-integration[bot]" <158243242+devin-ai-integration[bot]@users.noreply.github.com> Date: Tue, 7 Oct 2025 17:39:58 +0000 Subject: [PATCH 021/117] refactor(test): improve ProtocolVersions test coverage (#17721) - add test for version constant - ensure comprehensive coverage of all public elements Co-authored-by: Devin AI <158243242+devin-ai-integration[bot]@users.noreply.github.com> --- .../contracts-bedrock/test/L1/ProtocolVersions.t.sol | 10 ++++++++++ 1 file changed, 10 insertions(+) diff --git a/packages/contracts-bedrock/test/L1/ProtocolVersions.t.sol b/packages/contracts-bedrock/test/L1/ProtocolVersions.t.sol index 185eed02a6e..ec5c1ba2286 100644 --- a/packages/contracts-bedrock/test/L1/ProtocolVersions.t.sol +++ b/packages/contracts-bedrock/test/L1/ProtocolVersions.t.sol @@ -72,6 +72,16 @@ contract ProtocolVersions_Initialize_Test is ProtocolVersions_TestInit { } } +/// @title ProtocolVersions_Version_Test +/// @notice Test contract for ProtocolVersions `version` constant. +contract ProtocolVersions_Version_Test is ProtocolVersions_TestInit { + /// @notice Tests that the version function returns a valid string. We avoid testing + /// the specific value as it changes frequently. + function test_version_succeeds() external view { + assertGt(bytes(protocolVersions.version()).length, 0); + } +} + /// @title ProtocolVersions_SetRequired_Test /// @notice Test contract for ProtocolVersions `setRequired` function. contract ProtocolVersions_SetRequired_Test is ProtocolVersions_TestInit { From d24d691ba83b0e1ea5fa3a435aca74ddae0436d6 Mon Sep 17 00:00:00 2001 From: Maurelian Date: Tue, 7 Oct 2025 14:33:33 -0400 Subject: [PATCH 022/117] Add make gen-binding (#17761) Adds a new make gen-binding command for generating or updating go bindings for a contract. Also includes documentation in the op-e2e README. --- op-e2e/Makefile | 10 ++++++++++ op-e2e/README.md | 9 +++++++++ op-e2e/scripts/gen-binding.sh | 35 +++++++++++++++++++++++++++++++++++ 3 files changed, 54 insertions(+) create mode 100755 op-e2e/scripts/gen-binding.sh diff --git a/op-e2e/Makefile b/op-e2e/Makefile index e01a7ab27eb..73273e3e855 100644 --- a/op-e2e/Makefile +++ b/op-e2e/Makefile @@ -65,3 +65,13 @@ fuzz: "go test -run NOTAREALTEST -tags cgo_test -v -fuzztime 10s -fuzz FuzzFastLzGethSolidity ./opgeth" \ "go test -run NOTAREALTEST -tags cgo_test -v -fuzztime 10s -fuzz FuzzFastLzCgo ./opgeth" \ | parallel -j 8 {} + +ifndef CONTRACT +gen-binding: + $(error CONTRACT is required, usage: make gen-binding CONTRACT=OPContractsManager) +else +gen-binding: + cd ../packages/contracts-bedrock && just build + ./scripts/gen-binding.sh $(CONTRACT) +endif +.PHONY: gen-binding diff --git a/op-e2e/README.md b/op-e2e/README.md index 21d895d30e8..6c039bc6d82 100644 --- a/op-e2e/README.md +++ b/op-e2e/README.md @@ -39,6 +39,15 @@ make test-ws - `op-e2e/opgeth`: integration tests between test-mocks and op-geth execution-engine. - also includes upgrade-tests to ensure testing of op-stack Go components around a network upgrade. +### Generating Binding + +Bindings for a contract can be generated (or updated) using + +``` +make gen-binding CONTRACT=OPContractsManager +``` + + ### `action`-tests Action tests are set up in a compositional way: diff --git a/op-e2e/scripts/gen-binding.sh b/op-e2e/scripts/gen-binding.sh new file mode 100755 index 00000000000..2d16ec2b985 --- /dev/null +++ b/op-e2e/scripts/gen-binding.sh @@ -0,0 +1,35 @@ +#!/usr/bin/env bash + +set -euo pipefail + +REPO_ROOT="$(git rev-parse --show-toplevel)" +cd "${REPO_ROOT}" + +if [[ $# -lt 1 ]]; then + echo "usage: $0 CONTRACT_NAME" >&2 + exit 1 +fi + +CONTRACT="$1" +ARTIFACT_DIR="packages/contracts-bedrock/forge-artifacts/${CONTRACT}.sol" +ARTIFACT_PATH="${ARTIFACT_DIR}/${CONTRACT}.json" + +if [[ ! -f "${ARTIFACT_PATH}" ]]; then + echo "error: artifact not found at ${ARTIFACT_PATH}. Run the contracts build first." >&2 + exit 1 +fi + +OUTPUT_BASENAME="$(echo "${CONTRACT}" | tr '[:upper:]' '[:lower:]')" +OUTPUT_PATH="op-e2e/bindings/${OUTPUT_BASENAME}.go" + +TMPDIR="$(mktemp -d)" +trap 'rm -rf "${TMPDIR}"' EXIT + +ABI_PATH="${TMPDIR}/${CONTRACT}.abi.json" +BIN_PATH="${TMPDIR}/${CONTRACT}.bin" + +jq '.abi' "${ARTIFACT_PATH}" > "${ABI_PATH}" +jq -r '.bytecode.object' "${ARTIFACT_PATH}" > "${BIN_PATH}" + +abigen --pkg bindings --type "${CONTRACT}" --abi "${ABI_PATH}" --bin "${BIN_PATH}" --out "${OUTPUT_PATH}" +gofmt -w "${OUTPUT_PATH}" From 6b402806ea341a4eefdb39bd6e20d4372b3c0a18 Mon Sep 17 00:00:00 2001 From: Matthew Slipper Date: Tue, 7 Oct 2025 17:51:22 -0600 Subject: [PATCH 023/117] op-deployer: Do not create cache directory on import (#17776) * op-deployer: Do not create cache directory on import * create the one the flag makes --- op-deployer/pkg/cli/app.go | 6 ++++++ op-deployer/pkg/deployer/flags.go | 2 +- op-deployer/pkg/deployer/utils.go | 11 +++++++---- op-deployer/pkg/deployer/utils_test.go | 2 +- op-deployer/pkg/deployer/verify/verifier.go | 2 +- 5 files changed, 16 insertions(+), 7 deletions(-) diff --git a/op-deployer/pkg/cli/app.go b/op-deployer/pkg/cli/app.go index 099be7767f9..10968280d09 100644 --- a/op-deployer/pkg/cli/app.go +++ b/op-deployer/pkg/cli/app.go @@ -20,6 +20,12 @@ func NewApp(versionWithMeta string) *cli.App { app.Name = "op-deployer" app.Usage = "Tool to configure and deploy OP Chains." app.Flags = cliapp.ProtectFlags(deployer.GlobalFlags) + app.Before = func(context *cli.Context) error { + if err := deployer.CreateCacheDir(context.String(deployer.CacheDirFlagName)); err != nil { + return err + } + return nil + } app.Commands = []*cli.Command{ { Name: "init", diff --git a/op-deployer/pkg/deployer/flags.go b/op-deployer/pkg/deployer/flags.go index bcd3a71d49d..c4518c88fa1 100644 --- a/op-deployer/pkg/deployer/flags.go +++ b/op-deployer/pkg/deployer/flags.go @@ -48,7 +48,7 @@ var ( Usage: "Cache directory. " + "If set, the deployer will attempt to cache downloaded artifacts in the specified directory.", EnvVars: PrefixEnvVar("CACHE_DIR"), - Value: EnsureDefaultCacheDir(), + Value: DefaultCacheDir(), } L1ChainIDFlag = &cli.Uint64Flag{ Name: L1ChainIDFlagName, diff --git a/op-deployer/pkg/deployer/utils.go b/op-deployer/pkg/deployer/utils.go index 382fdcffd0e..09691e71c6a 100644 --- a/op-deployer/pkg/deployer/utils.go +++ b/op-deployer/pkg/deployer/utils.go @@ -39,7 +39,7 @@ func cwd() string { return dir } -func EnsureDefaultCacheDir() string { +func DefaultCacheDir() string { var cacheDir string homeDir, err := os.UserHomeDir() @@ -50,9 +50,12 @@ func EnsureDefaultCacheDir() string { cacheDir = path.Join(homeDir, ".op-deployer/cache") } + return cacheDir +} + +func CreateCacheDir(cacheDir string) error { if err := os.MkdirAll(cacheDir, 0755); err != nil { - panic(fmt.Sprintf("failed to create cache directory %s: %v", cacheDir, err)) + return fmt.Errorf("failed to create cache directory %s: %w", cacheDir, err) } - - return cacheDir + return nil } diff --git a/op-deployer/pkg/deployer/utils_test.go b/op-deployer/pkg/deployer/utils_test.go index a4ff0d5e7ef..9e13ff5d4d7 100644 --- a/op-deployer/pkg/deployer/utils_test.go +++ b/op-deployer/pkg/deployer/utils_test.go @@ -7,6 +7,6 @@ import ( ) func TestEnsureDefaultCacheDir(t *testing.T) { - cacheDir := EnsureDefaultCacheDir() + cacheDir := DefaultCacheDir() require.NotNil(t, cacheDir) } diff --git a/op-deployer/pkg/deployer/verify/verifier.go b/op-deployer/pkg/deployer/verify/verifier.go index 0bc9e3c3bf1..fe865d5da7a 100644 --- a/op-deployer/pkg/deployer/verify/verifier.go +++ b/op-deployer/pkg/deployer/verify/verifier.go @@ -88,7 +88,7 @@ func VerifyCLI(cliCtx *cli.Context) error { if err != nil { return fmt.Errorf("failed to parse l1 contracts release locator: %w", err) } - artifactsFS, err := artifacts.Download(ctx, locator, nil, deployer.EnsureDefaultCacheDir()) + artifactsFS, err := artifacts.Download(ctx, locator, nil, deployer.DefaultCacheDir()) if err != nil { return fmt.Errorf("failed to get artifacts: %w", err) } From 90134998ca40c5e4c45e8a49aa23c766b5221675 Mon Sep 17 00:00:00 2001 From: Inphi Date: Tue, 7 Oct 2025 20:19:38 -0400 Subject: [PATCH 024/117] op-acceptance-tests: Add smoke tests for disputegamev2 (#17775) * op-acceptance-tests: Add smoke tests for disputegamev2 * add missing skip --- .../tests/base/disputegame_v2/init_test.go | 11 ++++++++ .../tests/base/disputegame_v2/smoke_test.go | 27 +++++++++++++++++++ op-chain-ops/interopgen/deploy.go | 7 ++--- .../pkg/deployer/bootstrap/implementations.go | 2 +- op-deployer/pkg/deployer/devfeatures.go | 12 ++++----- .../dsl/proofs/dispute_game_factory.go | 8 +++++- op-devstack/dsl/proofs/game_helper.go | 2 +- op-devstack/presets/disputegame_v2.go | 11 ++++++++ op-devstack/presets/minimal.go | 5 ++++ op-devstack/sysgo/system.go | 4 +-- .../txintent/bindings/DisputeGameFactory.go | 1 + 11 files changed, 74 insertions(+), 16 deletions(-) create mode 100644 op-acceptance-tests/tests/base/disputegame_v2/init_test.go create mode 100644 op-acceptance-tests/tests/base/disputegame_v2/smoke_test.go create mode 100644 op-devstack/presets/disputegame_v2.go diff --git a/op-acceptance-tests/tests/base/disputegame_v2/init_test.go b/op-acceptance-tests/tests/base/disputegame_v2/init_test.go new file mode 100644 index 00000000000..7f14f8776a7 --- /dev/null +++ b/op-acceptance-tests/tests/base/disputegame_v2/init_test.go @@ -0,0 +1,11 @@ +package disputegame_v2 + +import ( + "testing" + + "github.com/ethereum-optimism/optimism/op-devstack/presets" +) + +func TestMain(m *testing.M) { + presets.DoMain(m, presets.WithMinimal(), presets.WithDisputeGameV2()) +} diff --git a/op-acceptance-tests/tests/base/disputegame_v2/smoke_test.go b/op-acceptance-tests/tests/base/disputegame_v2/smoke_test.go new file mode 100644 index 00000000000..3824d1e62e1 --- /dev/null +++ b/op-acceptance-tests/tests/base/disputegame_v2/smoke_test.go @@ -0,0 +1,27 @@ +package disputegame_v2 + +import ( + "testing" + + challengerTypes "github.com/ethereum-optimism/optimism/op-challenger/game/fault/types" + "github.com/ethereum-optimism/optimism/op-devstack/devtest" + "github.com/ethereum-optimism/optimism/op-devstack/presets" +) + +func TestSmoke(gt *testing.T) { + gt.Skip("TODO(#17257): Re-enable once opcm.deploy supports v2 dispute games") + t := devtest.SerialT(gt) + sys := presets.NewMinimal(t) + require := t.Require() + dgf := sys.DisputeGameFactory() + + gameArgs := dgf.GameArgs(challengerTypes.PermissionedGameType) + require.NotEmpty(gameArgs, "game args is must be set for permissioned v2 dispute games") + gameArgs = dgf.GameArgs(challengerTypes.CannonGameType) + require.NotEmpty(gameArgs, "game args is must be set for cannon v2 dispute games") + + permissionedGame := dgf.GameImpl(challengerTypes.PermissionedGameType) + require.NotEmpty(permissionedGame.Address, "permissioned game impl must be set") + cannonGame := dgf.GameImpl(challengerTypes.CannonGameType) + require.NotEmpty(cannonGame.Address, "cannon game impl must be set") +} diff --git a/op-chain-ops/interopgen/deploy.go b/op-chain-ops/interopgen/deploy.go index 8b52b2f4094..987e6683ae3 100644 --- a/op-chain-ops/interopgen/deploy.go +++ b/op-chain-ops/interopgen/deploy.go @@ -18,6 +18,7 @@ import ( "github.com/ethereum-optimism/optimism/op-chain-ops/genesis" "github.com/ethereum-optimism/optimism/op-chain-ops/genesis/beacondeposit" "github.com/ethereum-optimism/optimism/op-chain-ops/script" + "github.com/ethereum-optimism/optimism/op-deployer/pkg/deployer" "github.com/ethereum-optimism/optimism/op-deployer/pkg/deployer/manage" "github.com/ethereum-optimism/optimism/op-deployer/pkg/deployer/opcm" "github.com/ethereum-optimism/optimism/op-service/eth" @@ -27,10 +28,6 @@ var ( // sysGenesisDeployer is used as tx.origin/msg.sender on system genesis script calls. // At the end we verify none of the deployed contracts persist (there may be temporary ones, to insert bytecode). sysGenesisDeployer = common.Address(crypto.Keccak256([]byte("System genesis deployer"))[12:]) - - // OptimismPortalInteropDevFlag is the feature bitmap that enables the OptimismPortalInterop contract. - OptimismPortalInteropDevFlag = common.Hash{31: 0x01} // 0x0000000000000000000000000000000000000000000000000000000000000001 - ) func Deploy(logger log.Logger, fa *foundry.ArtifactsFS, srcFS *foundry.SourceMapFS, cfg *WorldConfig) (*WorldDeployment, *WorldOutput, error) { @@ -195,7 +192,7 @@ func DeploySuperchainToL1(l1Host *script.Host, opcmScripts *opcm.Scripts, superC ProofMaturityDelaySeconds: superCfg.Implementations.FaultProof.ProofMaturityDelaySeconds, DisputeGameFinalityDelaySeconds: superCfg.Implementations.FaultProof.DisputeGameFinalityDelaySeconds, MipsVersion: superCfg.Implementations.FaultProof.MipsVersion, - DevFeatureBitmap: OptimismPortalInteropDevFlag, + DevFeatureBitmap: deployer.OptimismPortalInteropDevFlag, FaultGameV2MaxGameDepth: big.NewInt(73), FaultGameV2SplitDepth: big.NewInt(30), FaultGameV2ClockExtension: big.NewInt(10800), diff --git a/op-deployer/pkg/deployer/bootstrap/implementations.go b/op-deployer/pkg/deployer/bootstrap/implementations.go index 13e57740730..f6e6d17e172 100644 --- a/op-deployer/pkg/deployer/bootstrap/implementations.go +++ b/op-deployer/pkg/deployer/bootstrap/implementations.go @@ -94,7 +94,7 @@ func (c *ImplementationsConfig) Check() error { return errors.New("dispute game finality delay in seconds must be specified") } // Check V2 fault game parameters only if V2 dispute games feature is enabled - deployV2Games := deployer.IsDevFeatureEnabled(c.DevFeatureBitmap, deployer.DeployV2DisputeGames) + deployV2Games := deployer.IsDevFeatureEnabled(c.DevFeatureBitmap, deployer.DeployV2DisputeGamesDevFlag) if deployV2Games { if c.FaultGameMaxGameDepth == 0 { return errors.New("fault game max game depth must be specified when V2 dispute games feature is enabled") diff --git a/op-deployer/pkg/deployer/devfeatures.go b/op-deployer/pkg/deployer/devfeatures.go index fff5b073fd3..8e62bb1a42f 100644 --- a/op-deployer/pkg/deployer/devfeatures.go +++ b/op-deployer/pkg/deployer/devfeatures.go @@ -9,14 +9,14 @@ import ( // Development feature flag constants that mirror the solidity DevFeatures library. // These use a 32 byte bitmap for easy integration between op-deployer and contracts. var ( - // OptimismPortalInterop enables the OptimismPortalInterop contract. - OptimismPortalInterop = common.HexToHash("0x0000000000000000000000000000000000000000000000000000000000000001") + // OptimismPortalInteropDevFlag enables the OptimismPortalInterop contract. + OptimismPortalInteropDevFlag = common.HexToHash("0x0000000000000000000000000000000000000000000000000000000000000001") - // CannonKona enables Kona as the default cannon prover. - CannonKona = common.HexToHash("0x0000000000000000000000000000000000000000000000000000000000000010") + // CannonKonaDevFlag enables Kona as the default cannon prover. + CannonKonaDevFlag = common.HexToHash("0x0000000000000000000000000000000000000000000000000000000000000010") - // DeployV2DisputeGames enables deployment of V2 dispute game contracts. - DeployV2DisputeGames = common.HexToHash("0x0000000000000000000000000000000000000000000000000000000000000100") + // DeployV2DisputeGamesDevFlag enables deployment of V2 dispute game contracts. + DeployV2DisputeGamesDevFlag = common.HexToHash("0x0000000000000000000000000000000000000000000000000000000000000100") ) // IsDevFeatureEnabled checks if a specific development feature is enabled in a feature bitmap. diff --git a/op-devstack/dsl/proofs/dispute_game_factory.go b/op-devstack/dsl/proofs/dispute_game_factory.go index d2c9f904dea..3dc0166df04 100644 --- a/op-devstack/dsl/proofs/dispute_game_factory.go +++ b/op-devstack/dsl/proofs/dispute_game_factory.go @@ -112,12 +112,16 @@ func (f *DisputeGameFactory) GameAtIndex(idx int64) *FaultDisputeGame { return NewFaultDisputeGame(f.t, f.require, gameInfo.Proxy, f.getGameHelper, game) } -func (f *DisputeGameFactory) gameImpl(gameType challengerTypes.GameType) *FaultDisputeGame { +func (f *DisputeGameFactory) GameImpl(gameType challengerTypes.GameType) *FaultDisputeGame { implAddr := contract.Read(f.dgf.GameImpls(uint32(gameType))) game := bindings.NewFaultDisputeGame(bindings.WithClient(f.ethClient), bindings.WithTo(implAddr), bindings.WithTest(f.t)) return NewFaultDisputeGame(f.t, f.require, implAddr, f.getGameHelper, game) } +func (f *DisputeGameFactory) GameArgs(gameType challengerTypes.GameType) []byte { + return contract.Read(f.dgf.GameArgs(uint32(gameType))) +} + func (f *DisputeGameFactory) WaitForGame() *FaultDisputeGame { initialCount := f.GameCount() f.t.Require().Eventually(func() bool { @@ -131,6 +135,7 @@ func (f *DisputeGameFactory) WaitForGame() *FaultDisputeGame { } func (f *DisputeGameFactory) StartSuperCannonGame(eoa *dsl.EOA, opts ...GameOpt) *SuperFaultDisputeGame { + f.require.NotNil(f.supervisor, "supervisor is required to start super games") proposalTimestamp := f.supervisor.FetchSyncStatus().SafeTimestamp return f.startSuperCannonGameOfType(eoa, proposalTimestamp, challengerTypes.SuperCannonGameType, opts...) @@ -151,6 +156,7 @@ func (f *DisputeGameFactory) startSuperCannonGameOfType(eoa *dsl.EOA, timestamp } func (f *DisputeGameFactory) createSuperGameExtraData(timestamp uint64, cfg *GameCfg) []byte { + f.require.NotNil(f.supervisor, "supervisor is required create super games") if !cfg.allowFuture { f.supervisor.AwaitMinCrossSafeTimestamp(timestamp) } diff --git a/op-devstack/dsl/proofs/game_helper.go b/op-devstack/dsl/proofs/game_helper.go index af076b7c9a9..a5075303958 100644 --- a/op-devstack/dsl/proofs/game_helper.go +++ b/op-devstack/dsl/proofs/game_helper.go @@ -142,7 +142,7 @@ func (gs *GameHelper) CreateGameWithClaims( data, err := gs.abi.Pack("createGameWithClaims", factory.Address(), gameType, rootClaim, extraData, moves) gs.require.NoError(err) - gameImpl := factory.gameImpl(gameType) + gameImpl := factory.GameImpl(gameType) bonds := factory.initBond(gameType) bonds = bonds.Add(gs.totalMoveBonds(gameImpl, moves)) diff --git a/op-devstack/presets/disputegame_v2.go b/op-devstack/presets/disputegame_v2.go new file mode 100644 index 00000000000..a47a1cf088b --- /dev/null +++ b/op-devstack/presets/disputegame_v2.go @@ -0,0 +1,11 @@ +package presets + +import ( + "github.com/ethereum-optimism/optimism/op-deployer/pkg/deployer" + "github.com/ethereum-optimism/optimism/op-devstack/stack" + "github.com/ethereum-optimism/optimism/op-devstack/sysgo" +) + +func WithDisputeGameV2() stack.CommonOption { + return stack.MakeCommon(sysgo.WithDeployerOptions(sysgo.WithDevFeatureBitmap(deployer.DeployV2DisputeGamesDevFlag))) +} diff --git a/op-devstack/presets/minimal.go b/op-devstack/presets/minimal.go index 2e0132f0152..d97d3b1c7ab 100644 --- a/op-devstack/presets/minimal.go +++ b/op-devstack/presets/minimal.go @@ -5,6 +5,7 @@ import ( "github.com/ethereum-optimism/optimism/op-devstack/devtest" "github.com/ethereum-optimism/optimism/op-devstack/dsl" + "github.com/ethereum-optimism/optimism/op-devstack/dsl/proofs" "github.com/ethereum-optimism/optimism/op-devstack/shim" "github.com/ethereum-optimism/optimism/op-devstack/stack" "github.com/ethereum-optimism/optimism/op-devstack/stack/match" @@ -42,6 +43,10 @@ func (m *Minimal) StandardBridge() *dsl.StandardBridge { return dsl.NewStandardBridge(m.T, m.L2Chain, nil, m.L1EL) } +func (m *Minimal) DisputeGameFactory() *proofs.DisputeGameFactory { + return proofs.NewDisputeGameFactory(m.T, m.L1Network, m.L1EL.EthClient(), m.L2Chain.DisputeGameFactoryProxyAddr(), nil) +} + func WithMinimal() stack.CommonOption { return stack.MakeCommon(sysgo.DefaultMinimalSystem(&sysgo.DefaultMinimalSystemIDs{})) } diff --git a/op-devstack/sysgo/system.go b/op-devstack/sysgo/system.go index 92b818b0a37..8ee74cbf080 100644 --- a/op-devstack/sysgo/system.go +++ b/op-devstack/sysgo/system.go @@ -2,7 +2,7 @@ package sysgo import ( "github.com/ethereum-optimism/optimism/op-chain-ops/devkeys" - "github.com/ethereum-optimism/optimism/op-chain-ops/interopgen" + "github.com/ethereum-optimism/optimism/op-deployer/pkg/deployer" "github.com/ethereum-optimism/optimism/op-devstack/stack" "github.com/ethereum-optimism/optimism/op-service/eth" ) @@ -332,7 +332,7 @@ func defaultSuperProofsSystem(dest *DefaultInteropSystemIDs, deployerOpts ...Dep WithCommons(ids.L1.ChainID()), WithPrefundedL2(ids.L1.ChainID(), ids.L2A.ChainID()), WithPrefundedL2(ids.L1.ChainID(), ids.L2B.ChainID()), - WithDevFeatureBitmap(interopgen.OptimismPortalInteropDevFlag), + WithDevFeatureBitmap(deployer.OptimismPortalInteropDevFlag), }, deployerOpts...)...)) opt.Add(WithL1Nodes(ids.L1EL, ids.L1CL)) diff --git a/op-service/txintent/bindings/DisputeGameFactory.go b/op-service/txintent/bindings/DisputeGameFactory.go index a04a8ca0b5b..553120b2039 100644 --- a/op-service/txintent/bindings/DisputeGameFactory.go +++ b/op-service/txintent/bindings/DisputeGameFactory.go @@ -30,6 +30,7 @@ type DisputeGameFactory struct { GameCount func() TypedCall[*big.Int] `sol:"gameCount"` GameAtIndex func(index *big.Int) TypedCall[DisputeGame] `sol:"gameAtIndex"` GameImpls func(gameType uint32) TypedCall[common.Address] `sol:"gameImpls"` + GameArgs func(gameType uint32) TypedCall[[]byte] `sol:"gameArgs"` Games func(gameType uint32, rootClaim common.Hash, extraData []byte) TypedCall[struct { Proxy common.Address Timestamp uint64 From c1081e3ad0004590435e3179e583cdfdbdd6bc61 Mon Sep 17 00:00:00 2001 From: Josh Klopfenstein Date: Tue, 7 Oct 2025 18:14:37 -0700 Subject: [PATCH 025/117] op-service: use correct response type in blob retrieval (#17779) --- op-service/apis/beacon.go | 2 +- op-service/eth/blobs_api.go | 6 ++++++ op-service/sources/l1_beacon_client.go | 15 ++++++++++----- op-service/sources/l1_beacon_client_test.go | 4 ++-- op-service/sources/mocks/BeaconClient.go | 16 +++++++--------- 5 files changed, 26 insertions(+), 17 deletions(-) diff --git a/op-service/apis/beacon.go b/op-service/apis/beacon.go index 76f61ca01a3..fd24f2c55b0 100644 --- a/op-service/apis/beacon.go +++ b/op-service/apis/beacon.go @@ -11,7 +11,7 @@ type BeaconClient interface { NodeVersion(ctx context.Context) (string, error) ConfigSpec(ctx context.Context) (eth.APIConfigResponse, error) BeaconGenesis(ctx context.Context) (eth.APIGenesisResponse, error) - BeaconBlobs(ctx context.Context, slot uint64, hashes []eth.IndexedBlobHash) ([]*eth.Blob, error) + BeaconBlobs(ctx context.Context, slot uint64, hashes []eth.IndexedBlobHash) (eth.APIBeaconBlobsResponse, error) BlobSideCarsClient } diff --git a/op-service/eth/blobs_api.go b/op-service/eth/blobs_api.go index 239f97528ed..9b7b8f5dee6 100644 --- a/op-service/eth/blobs_api.go +++ b/op-service/eth/blobs_api.go @@ -44,6 +44,12 @@ type APIGetBlobSidecarsResponse struct { Data []*APIBlobSidecar `json:"data"` } +type APIBeaconBlobsResponse struct { + // There are other fields but we only include the ones we're interested in. + + Data []*Blob `json:"data"` +} + type ReducedGenesisData struct { GenesisTime Uint64String `json:"genesis_time"` } diff --git a/op-service/sources/l1_beacon_client.go b/op-service/sources/l1_beacon_client.go index c5aa3afbb86..fa4bb1c8f29 100644 --- a/op-service/sources/l1_beacon_client.go +++ b/op-service/sources/l1_beacon_client.go @@ -101,15 +101,15 @@ func (cl *BeaconHTTPClient) BeaconGenesis(ctx context.Context) (eth.APIGenesisRe return genesisResp, nil } -func (cl *BeaconHTTPClient) BeaconBlobs(ctx context.Context, slot uint64, hashes []eth.IndexedBlobHash) ([]*eth.Blob, error) { +func (cl *BeaconHTTPClient) BeaconBlobs(ctx context.Context, slot uint64, hashes []eth.IndexedBlobHash) (eth.APIBeaconBlobsResponse, error) { reqQuery := url.Values{} for _, hash := range hashes { reqQuery.Add("versioned_hashes", hash.Hash.Hex()) } reqPath := path.Join(blobsMethodPrefix, strconv.FormatUint(slot, 10)) - var blobsResp []*eth.Blob + var blobsResp eth.APIBeaconBlobsResponse if err := cl.apiReq(ctx, &blobsResp, reqPath, reqQuery); err != nil { - return nil, err + return eth.APIBeaconBlobsResponse{}, err } return blobsResp, nil } @@ -303,7 +303,7 @@ func (cl *L1BeaconClient) GetBlobs(ctx context.Context, ref eth.L1BlockRef, hash if err != nil { return nil, err } - blobs, err := cl.cl.BeaconBlobs(ctx, slot, hashes) + resp, err := cl.cl.BeaconBlobs(ctx, slot, hashes) if err != nil { // We would normally check for an explicit error like "method not found", but the Beacon // API doesn't standardize such a response. Thus, we interpret all errors as @@ -318,10 +318,15 @@ func (cl *L1BeaconClient) GetBlobs(ctx context.Context, ref eth.L1BlockRef, hash } return blobs, nil } - for i, blob := range blobs { + if len(resp.Data) != len(hashes) { + return nil, fmt.Errorf("expected %d blobs but got %d", len(hashes), len(resp.Data)) + } + var blobs []*eth.Blob + for i, blob := range resp.Data { if err := verifyBlob(blob, hashes[i].Hash); err != nil { return nil, fmt.Errorf("blob %d failed verification: %w", i, err) } + blobs = append(blobs, blob) } return blobs, nil } diff --git a/op-service/sources/l1_beacon_client_test.go b/op-service/sources/l1_beacon_client_test.go index 38c02b1de51..009b3d82f78 100644 --- a/op-service/sources/l1_beacon_client_test.go +++ b/op-service/sources/l1_beacon_client_test.go @@ -246,7 +246,7 @@ func TestBeaconClientBadProof(t *testing.T) { p.EXPECT().ConfigSpec(ctx).Return(eth.APIConfigResponse{Data: eth.ReducedConfigData{SecondsPerSlot: 2}}, nil) client := NewL1BeaconClient(p, L1BeaconClientConfig{}) ref := eth.L1BlockRef{Time: 12} - p.EXPECT().BeaconBlobs(ctx, uint64(1), hashes).Return(nil, errors.New("the sky is falling")) + p.EXPECT().BeaconBlobs(ctx, uint64(1), hashes).Return(eth.APIBeaconBlobsResponse{}, errors.New("the sky is falling")) p.EXPECT().BeaconBlobSideCars(ctx, false, uint64(1), hashes).Return(eth.APIGetBlobSidecarsResponse{Data: apiSidecars}, nil) _, err := client.GetBlobs(ctx, ref, hashes) assert.NoError(t, err) @@ -259,7 +259,7 @@ func TestBeaconClientBadProof(t *testing.T) { p.EXPECT().ConfigSpec(ctx).Return(eth.APIConfigResponse{Data: eth.ReducedConfigData{SecondsPerSlot: 2}}, nil) client := NewL1BeaconClient(p, L1BeaconClientConfig{}) ref := eth.L1BlockRef{Time: 12} - p.EXPECT().BeaconBlobs(ctx, uint64(1), hashes).Return(blobs, nil) + p.EXPECT().BeaconBlobs(ctx, uint64(1), hashes).Return(eth.APIBeaconBlobsResponse{Data: blobs}, nil) _, err := client.GetBlobs(ctx, ref, hashes) assert.NoError(t, err) }) diff --git a/op-service/sources/mocks/BeaconClient.go b/op-service/sources/mocks/BeaconClient.go index 18c06b6f22e..bff9f84940a 100644 --- a/op-service/sources/mocks/BeaconClient.go +++ b/op-service/sources/mocks/BeaconClient.go @@ -82,24 +82,22 @@ func (_c *BeaconClient_BeaconBlobSideCars_Call) RunAndReturn(run func(context.Co } // BeaconBlobs provides a mock function with given fields: ctx, slot, hashes -func (_m *BeaconClient) BeaconBlobs(ctx context.Context, slot uint64, hashes []eth.IndexedBlobHash) ([]*eth.Blob, error) { +func (_m *BeaconClient) BeaconBlobs(ctx context.Context, slot uint64, hashes []eth.IndexedBlobHash) (eth.APIBeaconBlobsResponse, error) { ret := _m.Called(ctx, slot, hashes) if len(ret) == 0 { panic("no return value specified for BeaconBlobs") } - var r0 []*eth.Blob + var r0 eth.APIBeaconBlobsResponse var r1 error - if rf, ok := ret.Get(0).(func(context.Context, uint64, []eth.IndexedBlobHash) ([]*eth.Blob, error)); ok { + if rf, ok := ret.Get(0).(func(context.Context, uint64, []eth.IndexedBlobHash) (eth.APIBeaconBlobsResponse, error)); ok { return rf(ctx, slot, hashes) } - if rf, ok := ret.Get(0).(func(context.Context, uint64, []eth.IndexedBlobHash) []*eth.Blob); ok { + if rf, ok := ret.Get(0).(func(context.Context, uint64, []eth.IndexedBlobHash) eth.APIBeaconBlobsResponse); ok { r0 = rf(ctx, slot, hashes) } else { - if ret.Get(0) != nil { - r0 = ret.Get(0).([]*eth.Blob) - } + r0 = ret.Get(0).(eth.APIBeaconBlobsResponse) } if rf, ok := ret.Get(1).(func(context.Context, uint64, []eth.IndexedBlobHash) error); ok { @@ -131,12 +129,12 @@ func (_c *BeaconClient_BeaconBlobs_Call) Run(run func(ctx context.Context, slot return _c } -func (_c *BeaconClient_BeaconBlobs_Call) Return(_a0 []*eth.Blob, _a1 error) *BeaconClient_BeaconBlobs_Call { +func (_c *BeaconClient_BeaconBlobs_Call) Return(_a0 eth.APIBeaconBlobsResponse, _a1 error) *BeaconClient_BeaconBlobs_Call { _c.Call.Return(_a0, _a1) return _c } -func (_c *BeaconClient_BeaconBlobs_Call) RunAndReturn(run func(context.Context, uint64, []eth.IndexedBlobHash) ([]*eth.Blob, error)) *BeaconClient_BeaconBlobs_Call { +func (_c *BeaconClient_BeaconBlobs_Call) RunAndReturn(run func(context.Context, uint64, []eth.IndexedBlobHash) (eth.APIBeaconBlobsResponse, error)) *BeaconClient_BeaconBlobs_Call { _c.Call.Return(run) return _c } From 48e52dc5793a698b95f1ddbb8e7a951faa712614 Mon Sep 17 00:00:00 2001 From: George Knee Date: Wed, 8 Oct 2025 04:11:57 +0100 Subject: [PATCH 026/117] op-program/host: have prefetcher use new beacon API (not `blob_sidecars`) (#17778) * remove GetBlobSidecars from L1BlobSource * remove tests * tweak comments * fix test --- op-program/host/prefetcher/prefetcher.go | 24 ++++----- op-program/host/prefetcher/prefetcher_test.go | 3 +- op-program/host/prefetcher/retry.go | 10 ---- op-program/host/prefetcher/retry_test.go | 49 ------------------- 4 files changed, 14 insertions(+), 72 deletions(-) diff --git a/op-program/host/prefetcher/prefetcher.go b/op-program/host/prefetcher/prefetcher.go index 4bda552d69a..ece6fa7ad1b 100644 --- a/op-program/host/prefetcher/prefetcher.go +++ b/op-program/host/prefetcher/prefetcher.go @@ -54,7 +54,6 @@ type L1Source interface { } type L1BlobSource interface { - GetBlobSidecars(ctx context.Context, ref eth.L1BlockRef, hashes []eth.IndexedBlobHash) ([]*eth.BlobSidecar, error) GetBlobs(ctx context.Context, ref eth.L1BlockRef, hashes []eth.IndexedBlobHash) ([]*eth.Blob, error) } @@ -325,27 +324,30 @@ func (p *Prefetcher) prefetch(ctx context.Context, hint string) error { blobHashIndex := binary.BigEndian.Uint64(hintBytes[32:40]) refTimestamp := binary.BigEndian.Uint64(hintBytes[40:48]) - // Fetch the blob sidecar for the indexed blob hash passed in the hint. + // Fetch the blob for the indexed blob hash passed in the hint. indexedBlobHash := eth.IndexedBlobHash{ Hash: blobVersionHash, Index: blobHashIndex, } - // We pass an `eth.L1BlockRef`, but `GetBlobSidecars` only uses the timestamp, which we received in the hint. - sidecars, err := p.l1BlobFetcher.GetBlobSidecars(ctx, eth.L1BlockRef{Time: refTimestamp}, []eth.IndexedBlobHash{indexedBlobHash}) - if err != nil || len(sidecars) != 1 { - return fmt.Errorf("failed to fetch blob sidecars for %s %d: %w", blobVersionHash, blobHashIndex, err) + // We pass an `eth.L1BlockRef`, but `GetBlobs` only uses the timestamp, which we received in the hint. + blobs, err := p.l1BlobFetcher.GetBlobs(ctx, eth.L1BlockRef{Time: refTimestamp}, []eth.IndexedBlobHash{indexedBlobHash}) + if err != nil || len(blobs) != 1 { + return fmt.Errorf("failed to fetch blobs for %s %d: %w", blobVersionHash, blobHashIndex, err) + } + blob := blobs[0] + kzgCommitment, err := blob.ComputeKZGCommitment() + if err != nil { + return fmt.Errorf("failed to compute KZG commitment for blob: %w", err) } - sidecar := sidecars[0] - // Put the preimage for the versioned hash into the kv store - if err = p.kvStore.Put(preimage.Sha256Key(blobVersionHash).PreimageKey(), sidecar.KZGCommitment[:]); err != nil { + if err = p.kvStore.Put(preimage.Sha256Key(blobVersionHash).PreimageKey(), kzgCommitment[:]); err != nil { return err } // Put all of the blob's field elements into the kv store. There should be 4096. The preimage oracle key for // each field element is the keccak256 hash of `abi.encodePacked(sidecar.KZGCommitment, RootsOfUnity[i])` blobKey := make([]byte, 80) - copy(blobKey[:48], sidecar.KZGCommitment[:]) + copy(blobKey[:48], kzgCommitment[:]) for i := 0; i < params.BlobTxFieldElementsPerBlob; i++ { rootOfUnity := l1.RootsOfUnity[i].Bytes() copy(blobKey[48:], rootOfUnity[:]) @@ -353,7 +355,7 @@ func (p *Prefetcher) prefetch(ctx context.Context, hint string) error { if err := p.kvStore.Put(preimage.Keccak256Key(blobKeyHash).PreimageKey(), blobKey); err != nil { return err } - if err = p.kvStore.Put(preimage.BlobKey(blobKeyHash).PreimageKey(), sidecar.Blob[i<<5:(i+1)<<5]); err != nil { + if err = p.kvStore.Put(preimage.BlobKey(blobKeyHash).PreimageKey(), blob[i<<5:(i+1)<<5]); err != nil { return err } } diff --git a/op-program/host/prefetcher/prefetcher_test.go b/op-program/host/prefetcher/prefetcher_test.go index d8f4b01dd88..68a03e81cfa 100644 --- a/op-program/host/prefetcher/prefetcher_test.go +++ b/op-program/host/prefetcher/prefetcher_test.go @@ -204,11 +204,10 @@ func TestFetchL1Blob(t *testing.T) { prefetcher, _, blobFetcher, _, _ := createPrefetcher(t) oracle := l1.NewPreimageOracle(asOracleFn(t, prefetcher), asHinter(t, prefetcher)) - blobFetcher.ExpectOnGetBlobSidecars( + blobFetcher.ExpectOnGetBlobs( context.Background(), l1Ref, []eth.IndexedBlobHash{blobHash}, - (eth.Bytes48)(commitment), []*eth.Blob{&blob}, nil, ) diff --git a/op-program/host/prefetcher/retry.go b/op-program/host/prefetcher/retry.go index 6480a7f0f20..a5405e0223b 100644 --- a/op-program/host/prefetcher/retry.go +++ b/op-program/host/prefetcher/retry.go @@ -75,16 +75,6 @@ func NewRetryingL1BlobSource(logger log.Logger, source L1BlobSource) *RetryingL1 } } -func (s *RetryingL1BlobSource) GetBlobSidecars(ctx context.Context, ref eth.L1BlockRef, hashes []eth.IndexedBlobHash) ([]*eth.BlobSidecar, error) { - return retry.Do(ctx, maxAttempts, s.strategy, func() ([]*eth.BlobSidecar, error) { - sidecars, err := s.source.GetBlobSidecars(ctx, ref, hashes) - if err != nil { - s.logger.Warn("Failed to retrieve blob sidecars", "ref", ref, "err", err) - } - return sidecars, err - }) -} - func (s *RetryingL1BlobSource) GetBlobs(ctx context.Context, ref eth.L1BlockRef, hashes []eth.IndexedBlobHash) ([]*eth.Blob, error) { return retry.Do(ctx, maxAttempts, s.strategy, func() ([]*eth.Blob, error) { blobs, err := s.source.GetBlobs(ctx, ref, hashes) diff --git a/op-program/host/prefetcher/retry_test.go b/op-program/host/prefetcher/retry_test.go index b836d9236ef..90d5c153219 100644 --- a/op-program/host/prefetcher/retry_test.go +++ b/op-program/host/prefetcher/retry_test.go @@ -163,55 +163,6 @@ func TestRetryingL1BlobSource(t *testing.T) { require.Equal(t, len(result), 1) require.Equal(t, blob[:], result[0][:]) }) - - t.Run("GetBlobSidecars Success", func(t *testing.T) { - source, mock := createL1BlobSource(t) - defer mock.AssertExpectations(t) - mock.ExpectOnGetBlobSidecars( - ctx, - l1BlockRef, - []eth.IndexedBlobHash{blobHash}, - (eth.Bytes48)(commitment), - []*eth.Blob{(*eth.Blob)(&blob)}, - nil, - ) - - result, err := source.GetBlobSidecars(ctx, l1BlockRef, []eth.IndexedBlobHash{blobHash}) - require.NoError(t, err) - require.Equal(t, len(result), 1) - require.Equal(t, blob[:], result[0].Blob[:]) - require.Equal(t, blobHash.Index, uint64(result[0].Index)) - require.Equal(t, (eth.Bytes48)(commitment), result[0].KZGCommitment) - }) - - t.Run("GetBlobSidecars Error", func(t *testing.T) { - source, mock := createL1BlobSource(t) - defer mock.AssertExpectations(t) - expectedErr := errors.New("boom") - mock.ExpectOnGetBlobSidecars( - ctx, - l1BlockRef, - []eth.IndexedBlobHash{blobHash}, - (eth.Bytes48)(commitment), - []*eth.Blob{(*eth.Blob)(&blob)}, - expectedErr, - ) - mock.ExpectOnGetBlobSidecars( - ctx, - l1BlockRef, - []eth.IndexedBlobHash{blobHash}, - (eth.Bytes48)(commitment), - []*eth.Blob{(*eth.Blob)(&blob)}, - nil, - ) - - result, err := source.GetBlobSidecars(ctx, l1BlockRef, []eth.IndexedBlobHash{blobHash}) - require.NoError(t, err) - require.Equal(t, len(result), 1) - require.Equal(t, blob[:], result[0].Blob[:]) - require.Equal(t, blobHash.Index, uint64(result[0].Index)) - require.Equal(t, (eth.Bytes48)(commitment), result[0].KZGCommitment) - }) } func createL1BlobSource(t *testing.T) (*RetryingL1BlobSource, *testutils.MockBlobsFetcher) { From 6971ada2d9dcaa29b53ae5c2f9781c37a89d933b Mon Sep 17 00:00:00 2001 From: Stefano Charissis Date: Wed, 8 Oct 2025 14:33:19 +1100 Subject: [PATCH 027/117] feat(op-acceptance-tests): flake-shake; tweaks (#17780) * fix(op-acceptance-tests): flake-shake; job URL. Make the job URL in our Slack notification point to the artifacts tab of the report job URL. * fix(op-acceptance-tests): flake-shake; add job URL to PR body. * fix(op-acceptance-tests): flake-shake; report owner. * fix(op-acceptance-tests): flake-shake; tweaked defaults. --- .circleci/config.yml | 6 +- .../cmd/flake-shake-promoter/main.go | 103 +++++++++++++++++- .../scripts/ci_flake_shake_prepare_slack.sh | 32 +++++- 3 files changed, 135 insertions(+), 6 deletions(-) diff --git a/.circleci/config.yml b/.circleci/config.yml index 557385d223a..4a58863e537 100644 --- a/.circleci/config.yml +++ b/.circleci/config.yml @@ -79,7 +79,7 @@ parameters: default: false flake-shake-iterations: type: integer - default: 100 + default: 200 flake-shake-workers: type: integer default: 10 @@ -1759,8 +1759,8 @@ jobs: --days 3 \ --gate flake-shake \ --min-runs 300 \ - --max-failure-rate 0.01 \ - --min-age-days 3 \ + --max-failure-rate 0.0 \ + --min-age-days 2 \ --dry-run=false \ --require-clean-24h \ --out ./final-promotion \ diff --git a/op-acceptance-tests/cmd/flake-shake-promoter/main.go b/op-acceptance-tests/cmd/flake-shake-promoter/main.go index 77e57769a94..7d7d98315f8 100644 --- a/op-acceptance-tests/cmd/flake-shake-promoter/main.go +++ b/op-acceptance-tests/cmd/flake-shake-promoter/main.go @@ -53,6 +53,7 @@ type jobList struct { type job struct { Name string `json:"name"` JobNumber int `json:"job_number"` + WebURL string `json:"web_url"` } type artifactsList struct { @@ -107,6 +108,7 @@ type testEntry struct { Package string `yaml:"package"` Timeout string `yaml:"timeout,omitempty"` Metadata map[string]interface{} `yaml:"metadata,omitempty"` + Owner string `yaml:"owner,omitempty"` } // Aggregated per test across days @@ -129,6 +131,7 @@ type promoteCandidate struct { PassRate float64 `json:"pass_rate"` Timeout string `json:"timeout"` FirstSeenDay string `json:"first_seen_day"` + Owner string `json:"owner,omitempty"` } // Map tests in flake-shake: key -> (timeout, name) @@ -136,6 +139,7 @@ type testInfo struct { Timeout string Name string Meta map[string]interface{} + Owner string GateIndex int TestIndex int } @@ -264,7 +268,14 @@ func main() { title := "chore(op-acceptance-tests): flake-shake; test promotions" var body bytes.Buffer body.WriteString("## 🤖 Automated Flake-Shake Test Promotion\n\n") + + // Attempt to resolve the CircleCI report job web URL for artifacts page + reportArtifactsURL := resolveReportArtifactsURL(opts, ctx) + body.WriteString(fmt.Sprintf("Promoting %d test(s) from gate `"+opts.gateID+"` based on stability criteria.\n\n", len(candidates))) + if reportArtifactsURL != "" { + body.WriteString(fmt.Sprintf("Artifacts: %s\n\n", reportArtifactsURL)) + } body.WriteString("### Tests Being Promoted\n\n") body.WriteString("| Test | Package | Total Runs | Pass Rate |\n|---|---|---:|---:|\n") for _, c := range candidates { @@ -482,7 +493,14 @@ func buildFlakeTests(cfg *acceptanceYAML, gateID, yamlPath string) (map[string]t flakeTests := map[string]testInfo{} for ti, t := range flakeGate.Tests { key := keyFor(t.Package, t.Name) - flakeTests[key] = testInfo{Timeout: t.Timeout, Name: t.Name, Meta: t.Metadata, GateIndex: indexOfGate(cfg, gateID), TestIndex: ti} + // Prefer explicit YAML field owner; fallback to metadata.owner + owner := t.Owner + if owner == "" && t.Metadata != nil { + if v, ok := t.Metadata["owner"]; ok { + owner = fmt.Sprintf("%v", v) + } + } + flakeTests[key] = testInfo{Timeout: t.Timeout, Name: t.Name, Meta: t.Metadata, Owner: owner, GateIndex: indexOfGate(cfg, gateID), TestIndex: ti} } return flakeTests, flakeGate, gateIndex } @@ -560,6 +578,14 @@ func selectPromotionCandidates(agg map[string]*aggStats, flakeTests map[string]t if totalRuns > 0 { passRate = float64(totalPasses) / float64(totalRuns) } + owner := info.Owner + if owner == "" { + if info.Meta != nil { + if v, ok := info.Meta["owner"]; ok { + owner = fmt.Sprintf("%v", v) + } + } + } candidates = append(candidates, promoteCandidate{ Package: pkg, TestName: "", @@ -567,6 +593,7 @@ func selectPromotionCandidates(agg map[string]*aggStats, flakeTests map[string]t PassRate: passRate * 100.0, Timeout: info.Timeout, FirstSeenDay: earliest, + Owner: owner, }) } for key, s := range agg { @@ -616,6 +643,14 @@ func selectPromotionCandidates(agg map[string]*aggStats, flakeTests map[string]t if s.TotalRuns > 0 { passRate = float64(s.Passes) / float64(s.TotalRuns) } + owner := info.Owner + if owner == "" { + if info.Meta != nil { + if v, ok := info.Meta["owner"]; ok { + owner = fmt.Sprintf("%v", v) + } + } + } candidates = append(candidates, promoteCandidate{ Package: s.Package, TestName: s.TestName, @@ -623,6 +658,7 @@ func selectPromotionCandidates(agg map[string]*aggStats, flakeTests map[string]t PassRate: passRate * 100.0, Timeout: info.Timeout, FirstSeenDay: s.FirstSeenDay, + Owner: owner, }) } return candidates, reasons @@ -828,6 +864,71 @@ func listJobs(ctx *apiCtx, workflowID string) (jobList, error) { return jl, nil } +// resolveReportArtifactsURL attempts to find the web URL to the report job's artifacts page +// by scanning recent pipelines/workflows for the configured workflow/report job names. +// Returns an empty string if not found. +func resolveReportArtifactsURL(opts promoterOpts, ctx *apiCtx) string { + // Scan the latest pipelines on the given branch; reuse collectReports traversal but short-circuit on first match + basePipelines := fmt.Sprintf("https://circleci.com/api/v2/project/gh/%s/%s/pipeline?branch=%s", url.PathEscape(opts.org), url.PathEscape(opts.repo), url.QueryEscape(opts.branch)) + pageURL := basePipelines + now := time.Now().UTC() + since := now.AddDate(0, 0, -opts.daysBack) + for { + pl, nextToken, err := getPipelinesPage(ctx, pageURL) + if err != nil { + return "" + } + for _, p := range pl.Items { + if p.CreatedAt.Before(since) { + return "" + } + wfl, err := listWorkflows(ctx, p.ID) + if err != nil { + return "" + } + for _, w := range wfl.Items { + if w.Name != opts.workflowName { + continue + } + jl, err := listJobs(ctx, w.ID) + if err != nil { + return "" + } + for _, j := range jl.Items { + if j.Name != opts.reportJobName { + continue + } + if j.WebURL != "" { + url := j.WebURL + if !strings.Contains(url, "/artifacts") { + if strings.HasSuffix(url, "/") { + url = url + "artifacts" + } else { + url = url + "/artifacts" + } + } + return url + } + // Fallback: build URL from job number if web_url missing + if j.JobNumber != 0 { + url := fmt.Sprintf("https://app.circleci.com/pipelines/github/%s/%s?branch=%s", opts.org, opts.repo, url.QueryEscape(opts.branch)) + _ = url // keep for future; better to use job-specific URL + // More specific URL pattern commonly used in UI includes workflow id; not available here. + // As a fallback, return the legacy build URL on circleci.com if org/repo/job present. + legacy := fmt.Sprintf("https://circleci.com/gh/%s/%s/%d", opts.org, opts.repo, j.JobNumber) + return legacy + "/artifacts" + } + } + } + } + if nextToken == "" { + break + } + pageURL = basePipelines + "&page-token=" + url.QueryEscape(nextToken) + } + return "" +} + func listArtifacts(ctx *apiCtx, org, repo string, jobNumber int, verbose bool) (artifactsList, error) { artsURL := fmt.Sprintf("https://circleci.com/api/v2/project/gh/%s/%s/%d/artifacts", url.PathEscape(org), url.PathEscape(repo), jobNumber) var al artifactsList diff --git a/op-acceptance-tests/scripts/ci_flake_shake_prepare_slack.sh b/op-acceptance-tests/scripts/ci_flake_shake_prepare_slack.sh index 33acc57194a..b05bcb1b6fd 100644 --- a/op-acceptance-tests/scripts/ci_flake_shake_prepare_slack.sh +++ b/op-acceptance-tests/scripts/ci_flake_shake_prepare_slack.sh @@ -30,15 +30,43 @@ PROMO_JSON=${1:-./final-promotion/promotion-ready.json} SLACK_BLOCKS="[]" if [ -f "$PROMO_JSON" ]; then + # Determine URL to the flake-shake report job (artifacts live there), + # falling back to the current job URL if not resolvable. + REPORT_JOB_URL="${CIRCLE_BUILD_URL:-}" + if [ -n "${CIRCLE_WORKFLOW_ID:-}" ] && [ -n "${CIRCLE_API_TOKEN:-}" ]; then + JOBS_JSON=$(curl -sfL -H "Circle-Token: ${CIRCLE_API_TOKEN}" "https://circleci.com/api/v2/workflow/${CIRCLE_WORKFLOW_ID}/jobs?limit=100" || true) + if [ -n "${JOBS_JSON:-}" ]; then + # Prefer web_url if available; otherwise construct URL from job_number + REPORT_WEB_URL=$(printf '%s' "$JOBS_JSON" | jq -r '.items[] | select(.name=="op-acceptance-tests-flake-shake-report") | .web_url // empty' | head -n1) + if [ -n "$REPORT_WEB_URL" ] && [ "$REPORT_WEB_URL" != "null" ]; then + REPORT_JOB_URL="$REPORT_WEB_URL" + else + REPORT_JOB_NUM=$(printf '%s' "$JOBS_JSON" | jq -r '.items[] | select(.name=="op-acceptance-tests-flake-shake-report") | .job_number // empty' | head -n1) + if [ -n "$REPORT_JOB_NUM" ] && [ "$REPORT_JOB_NUM" != "null" ] && [ -n "${CIRCLE_PROJECT_USERNAME:-}" ] && [ -n "${CIRCLE_PROJECT_REPONAME:-}" ]; then + REPORT_JOB_URL="https://circleci.com/gh/${CIRCLE_PROJECT_USERNAME}/${CIRCLE_PROJECT_REPONAME}/${REPORT_JOB_NUM}" + fi + fi + fi + fi + + # Ensure URL points to the artifacts page of the report job + REPORT_ARTIFACTS_URL="$REPORT_JOB_URL" + if [ -n "$REPORT_ARTIFACTS_URL" ]; then + if ! printf '%s' "$REPORT_ARTIFACTS_URL" | grep -q '/artifacts\($\|[?#]\)'; then + REPORT_ARTIFACTS_URL="${REPORT_ARTIFACTS_URL%/}/artifacts" + fi + fi + # Build Block Kit blocks (header + link + divider + per-candidate sections) SLACK_BLOCKS=$(jq -c \ - --arg url "${CIRCLE_BUILD_URL:-}" \ + --arg url "${REPORT_ARTIFACTS_URL}" \ --slurpfile meta "${PROMO_JSON%/*}/metadata.json" ' def name_or_pkg(t): (if ((t.test_name|tostring)|length) == 0 then "(package)" else t.test_name end); + def owner_or_unknown(t): (if ((t.owner|tostring)|length) == 0 then "unknown" else t.owner end); def testblocks(t): [ {"type":"section","fields":[ {"type":"mrkdwn","text":"*Test:*\n\(name_or_pkg(t))"}, - {"type":"mrkdwn","text":"*Package:*\n\(t.package)"} + {"type":"mrkdwn","text":"*Owner:*\n\(owner_or_unknown(t))"} ]}, {"type":"section","fields":[ {"type":"mrkdwn","text":"*Runs:*\n\(t.total_runs)"}, From ca80499f9f9f72245e711007c78f4b384ddba7e8 Mon Sep 17 00:00:00 2001 From: Sam Stokes <35908605+bitwiseguy@users.noreply.github.com> Date: Wed, 8 Oct 2025 08:18:13 -0400 Subject: [PATCH 028/117] fix(circleci): always run contracts-bedrock-build before docker-build (#17781) * fix(circleci): always run contracts-bedrock-build before docker-build * fix(circleci): include op-deployer in scheduled-docker-publish --- .circleci/config.yml | 15 +++++++++++++++ 1 file changed, 15 insertions(+) diff --git a/.circleci/config.yml b/.circleci/config.yml index 4a58863e537..7996cc12167 100644 --- a/.circleci/config.yml +++ b/.circleci/config.yml @@ -2547,6 +2547,7 @@ workflows: - circleci-repo-readonly-authenticated-github-token requires: - initialize + - contracts-bedrock-build - cannon-prestate-quick: context: - circleci-repo-readonly-authenticated-github-token @@ -2670,6 +2671,11 @@ workflows: only: /^(da-server|cannon|ufm-[a-z0-9\-]*|op-[a-z0-9\-]*)\/v.*/ branches: ignore: /.*/ + - contracts-bedrock-build: + context: + - circleci-repo-readonly-authenticated-github-token + requires: + - initialize # Standard (medium) cross-platform docker images go here - docker-build: matrix: @@ -2704,6 +2710,7 @@ workflows: - oplabs-gcr-release requires: - initialize + - contracts-bedrock-build # Checks for cross-platform images go here - check-cross-platform: matrix: @@ -2895,12 +2902,18 @@ workflows: - initialize: context: - circleci-repo-readonly-authenticated-github-token + - contracts-bedrock-build: + context: + - circleci-repo-readonly-authenticated-github-token + requires: + - initialize - docker-build: matrix: parameters: docker_name: - op-node - op-batcher + - op-deployer - op-faucet - op-program - op-proposer @@ -2922,12 +2935,14 @@ workflows: - circleci-repo-readonly-authenticated-github-token requires: - initialize + - contracts-bedrock-build - check-cross-platform: matrix: parameters: op_component: - op-node - op-batcher + - op-deployer - op-faucet - op-program - op-proposer From d1a0c5e1c7cb2685519521bb15daba853d55715b Mon Sep 17 00:00:00 2001 From: Axel Kingsley Date: Thu, 9 Oct 2025 09:25:22 -0500 Subject: [PATCH 029/117] Interfaced CLI Context (#17759) --- op-node/p2p/cli/load_signer.go | 4 ++-- op-node/service.go | 33 +++++++++++++++++---------------- op-service/cliiface/context.go | 21 +++++++++++++++++++++ op-service/log/cli.go | 3 ++- op-service/metrics/cli.go | 3 ++- op-service/oppprof/cli.go | 3 ++- op-service/rpc/cli.go | 3 ++- op-service/signer/cli.go | 4 ++-- op-service/tls/cli.go | 3 ++- op-service/txmgr/cli.go | 3 ++- 10 files changed, 54 insertions(+), 26 deletions(-) create mode 100644 op-service/cliiface/context.go diff --git a/op-node/p2p/cli/load_signer.go b/op-node/p2p/cli/load_signer.go index 241e0a395e6..bec82a49382 100644 --- a/op-node/p2p/cli/load_signer.go +++ b/op-node/p2p/cli/load_signer.go @@ -6,15 +6,15 @@ import ( "github.com/ethereum/go-ethereum/crypto" "github.com/ethereum/go-ethereum/log" - "github.com/urfave/cli/v2" "github.com/ethereum-optimism/optimism/op-node/flags" "github.com/ethereum-optimism/optimism/op-node/p2p" + "github.com/ethereum-optimism/optimism/op-service/cliiface" opsigner "github.com/ethereum-optimism/optimism/op-service/signer" ) // LoadSignerSetup loads a configuration for a Signer to be set up later -func LoadSignerSetup(ctx *cli.Context, logger log.Logger) (p2p.SignerSetup, error) { +func LoadSignerSetup(ctx cliiface.Context, logger log.Logger) (p2p.SignerSetup, error) { key := ctx.String(flags.SequencerP2PKeyName) signerCfg := opsigner.ReadCLIConfig(ctx) if key != "" && signerCfg.Enabled() { diff --git a/op-node/service.go b/op-node/service.go index af72a6c4b78..ba002bb81aa 100644 --- a/op-node/service.go +++ b/op-node/service.go @@ -25,6 +25,7 @@ import ( "github.com/ethereum-optimism/optimism/op-node/rollup/engine" "github.com/ethereum-optimism/optimism/op-node/rollup/interop" "github.com/ethereum-optimism/optimism/op-node/rollup/sync" + "github.com/ethereum-optimism/optimism/op-service/cliiface" "github.com/ethereum-optimism/optimism/op-service/eth" opflags "github.com/ethereum-optimism/optimism/op-service/flags" "github.com/ethereum-optimism/optimism/op-service/jsonutil" @@ -51,7 +52,7 @@ func NewConfig(ctx *cli.Context, log log.Logger) (*config.Config, error) { return nil, err } - depSet, err := NewDependencySetFromCLI(ctx) + depSet, err := NewDependencySetFromCLI(ctx, ctx.Context) if err != nil { return nil, err } @@ -148,7 +149,7 @@ func NewConfig(ctx *cli.Context, log log.Logger) (*config.Config, error) { return cfg, nil } -func NewSupervisorEndpointConfig(ctx *cli.Context) *interop.Config { +func NewSupervisorEndpointConfig(ctx cliiface.Context) *interop.Config { return &interop.Config{ RPCAddr: ctx.String(flags.InteropRPCAddr.Name), RPCPort: ctx.Int(flags.InteropRPCPort.Name), @@ -156,7 +157,7 @@ func NewSupervisorEndpointConfig(ctx *cli.Context) *interop.Config { } } -func NewBeaconEndpointConfig(ctx *cli.Context) config.L1BeaconEndpointSetup { +func NewBeaconEndpointConfig(ctx cliiface.Context) config.L1BeaconEndpointSetup { return &config.L1BeaconEndpointConfig{ BeaconAddr: ctx.String(flags.BeaconAddr.Name), BeaconHeader: ctx.String(flags.BeaconHeader.Name), @@ -166,7 +167,7 @@ func NewBeaconEndpointConfig(ctx *cli.Context) config.L1BeaconEndpointSetup { } } -func NewL1EndpointConfig(ctx *cli.Context) *config.L1EndpointConfig { +func NewL1EndpointConfig(ctx cliiface.Context) *config.L1EndpointConfig { return &config.L1EndpointConfig{ L1NodeAddr: ctx.String(flags.L1NodeAddr.Name), L1TrustRPC: ctx.Bool(flags.L1TrustRPC.Name), @@ -179,7 +180,7 @@ func NewL1EndpointConfig(ctx *cli.Context) *config.L1EndpointConfig { } } -func NewL2EndpointConfig(ctx *cli.Context, logger log.Logger) (*config.L2EndpointConfig, error) { +func NewL2EndpointConfig(ctx cliiface.Context, logger log.Logger) (*config.L2EndpointConfig, error) { l2Addr := ctx.String(flags.L2EngineAddr.Name) fileName := ctx.String(flags.L2EngineJWTSecret.Name) secret, err := rpc.ObtainJWTSecret(logger, fileName, true) @@ -194,7 +195,7 @@ func NewL2EndpointConfig(ctx *cli.Context, logger log.Logger) (*config.L2Endpoin }, nil } -func NewConfigPersistence(ctx *cli.Context) config.ConfigPersistence { +func NewConfigPersistence(ctx cliiface.Context) config.ConfigPersistence { stateFile := ctx.String(flags.RPCAdminPersistence.Name) if stateFile == "" { return config.DisabledConfigPersistence{} @@ -202,7 +203,7 @@ func NewConfigPersistence(ctx *cli.Context) config.ConfigPersistence { return config.NewConfigPersistence(stateFile) } -func NewDriverConfig(ctx *cli.Context) *driver.Config { +func NewDriverConfig(ctx cliiface.Context) *driver.Config { return &driver.Config{ VerifierConfDepth: ctx.Uint64(flags.VerifierL1Confs.Name), SequencerConfDepth: ctx.Uint64(flags.SequencerL1Confs.Name), @@ -213,7 +214,7 @@ func NewDriverConfig(ctx *cli.Context) *driver.Config { } } -func NewRollupConfigFromCLI(log log.Logger, ctx *cli.Context) (*rollup.Config, error) { +func NewRollupConfigFromCLI(log log.Logger, ctx cliiface.Context) (*rollup.Config, error) { network := ctx.String(opflags.NetworkFlagName) rollupConfigPath := ctx.String(opflags.RollupConfigFlagName) if ctx.Bool(flags.BetaExtraNetworks.Name) { @@ -257,7 +258,7 @@ Conflicting configuration is deprecated, and will stop the op-node from starting return &rollupConfig, nil } -func applyOverrides(ctx *cli.Context, rollupConfig *rollup.Config) { +func applyOverrides(ctx cliiface.Context, rollupConfig *rollup.Config) { if ctx.IsSet(opflags.CanyonOverrideFlagName) { canyon := ctx.Uint64(opflags.CanyonOverrideFlagName) rollupConfig.CanyonTime = &canyon @@ -300,7 +301,7 @@ func applyOverrides(ctx *cli.Context, rollupConfig *rollup.Config) { } } -func NewL1ChainConfig(chainId *big.Int, ctx *cli.Context, log log.Logger) (*params.ChainConfig, error) { +func NewL1ChainConfig(chainId *big.Int, ctx cliiface.Context, log log.Logger) (*params.ChainConfig, error) { if chainId == nil { panic("l1 chain id is nil") } @@ -323,7 +324,7 @@ func NewL1ChainConfig(chainId *big.Int, ctx *cli.Context, log log.Logger) (*para return cf, nil } -func NewL1ChainConfigFromCLI(log log.Logger, ctx *cli.Context) (*params.ChainConfig, error) { +func NewL1ChainConfigFromCLI(log log.Logger, ctx cliiface.Context) (*params.ChainConfig, error) { l1ChainConfigPath := ctx.String(flags.L1ChainConfig.Name) file, err := os.Open(l1ChainConfigPath) if err != nil { @@ -344,15 +345,15 @@ func NewL1ChainConfigFromCLI(log log.Logger, ctx *cli.Context) (*params.ChainCon return jsonutil.LoadJSONFieldStrict[params.ChainConfig](l1ChainConfigPath, "config") } -func NewDependencySetFromCLI(ctx *cli.Context) (depset.DependencySet, error) { - if !ctx.IsSet(flags.InteropDependencySet.Name) { +func NewDependencySetFromCLI(cli cliiface.Context, ctx context.Context) (depset.DependencySet, error) { + if !cli.IsSet(flags.InteropDependencySet.Name) { return nil, nil } - loader := &depset.JSONDependencySetLoader{Path: ctx.Path(flags.InteropDependencySet.Name)} - return loader.LoadDependencySet(ctx.Context) + loader := &depset.JSONDependencySetLoader{Path: cli.Path(flags.InteropDependencySet.Name)} + return loader.LoadDependencySet(ctx) } -func NewSyncConfig(ctx *cli.Context, log log.Logger) (*sync.Config, error) { +func NewSyncConfig(ctx cliiface.Context, log log.Logger) (*sync.Config, error) { if ctx.IsSet(flags.L2EngineSyncEnabled.Name) && ctx.IsSet(flags.SyncModeFlag.Name) { return nil, errors.New("cannot set both --l2.engine-sync and --syncmode at the same time") } else if ctx.IsSet(flags.L2EngineSyncEnabled.Name) { diff --git a/op-service/cliiface/context.go b/op-service/cliiface/context.go new file mode 100644 index 00000000000..c60cba24f28 --- /dev/null +++ b/op-service/cliiface/context.go @@ -0,0 +1,21 @@ +package cliiface + +import ( + "time" +) + +// Context defines the minimal surface of urfave/cli.Context that our +// configuration constructors depend on, across services. +type Context interface { + String(name string) string + Bool(name string) bool + Int(name string) int + Uint(name string) uint + Uint64(name string) uint64 + Float64(name string) float64 + Duration(name string) time.Duration + StringSlice(name string) []string + IsSet(name string) bool + Path(name string) string + Generic(name string) any +} diff --git a/op-service/log/cli.go b/op-service/log/cli.go index 9f95f18cc2c..4056f22b944 100644 --- a/op-service/log/cli.go +++ b/op-service/log/cli.go @@ -16,6 +16,7 @@ import ( opservice "github.com/ethereum-optimism/optimism/op-service" "github.com/ethereum-optimism/optimism/op-service/cliapp" + "github.com/ethereum-optimism/optimism/op-service/cliiface" "github.com/ethereum-optimism/optimism/op-service/log/logfilter" ) @@ -263,7 +264,7 @@ func DefaultCLIConfig() CLIConfig { } } -func ReadCLIConfig(ctx *cli.Context) CLIConfig { +func ReadCLIConfig(ctx cliiface.Context) CLIConfig { cfg := DefaultCLIConfig() cfg.Level = ctx.Generic(LevelFlagName).(*LevelFlagValue).Level() cfg.Format = ctx.Generic(FormatFlagName).(*FormatFlagValue).FormatType() diff --git a/op-service/metrics/cli.go b/op-service/metrics/cli.go index 85a20da79d2..ddaf3d9b3c5 100644 --- a/op-service/metrics/cli.go +++ b/op-service/metrics/cli.go @@ -6,6 +6,7 @@ import ( opservice "github.com/ethereum-optimism/optimism/op-service" + "github.com/ethereum-optimism/optimism/op-service/cliiface" "github.com/urfave/cli/v2" ) @@ -74,7 +75,7 @@ func (m CLIConfig) Check() error { return nil } -func ReadCLIConfig(ctx *cli.Context) CLIConfig { +func ReadCLIConfig(ctx cliiface.Context) CLIConfig { return CLIConfig{ Enabled: ctx.Bool(EnabledFlagName), ListenAddr: ctx.String(ListenAddrFlagName), diff --git a/op-service/oppprof/cli.go b/op-service/oppprof/cli.go index 6c2c33a1471..abee024d984 100644 --- a/op-service/oppprof/cli.go +++ b/op-service/oppprof/cli.go @@ -7,6 +7,7 @@ import ( "strings" opservice "github.com/ethereum-optimism/optimism/op-service" + "github.com/ethereum-optimism/optimism/op-service/cliiface" openum "github.com/ethereum-optimism/optimism/op-service/enum" "github.com/ethereum-optimism/optimism/op-service/flags" "github.com/urfave/cli/v2" @@ -129,7 +130,7 @@ func (m CLIConfig) Check() error { return nil } -func ReadCLIConfig(ctx *cli.Context) CLIConfig { +func ReadCLIConfig(ctx cliiface.Context) CLIConfig { profilePathFlag := ctx.Generic(ProfilePathFlagName).(*flags.PathFlag) return CLIConfig{ ListenEnabled: ctx.Bool(EnabledFlagName), diff --git a/op-service/rpc/cli.go b/op-service/rpc/cli.go index ba185fc2b24..1bda38bfa49 100644 --- a/op-service/rpc/cli.go +++ b/op-service/rpc/cli.go @@ -5,6 +5,7 @@ import ( "math" opservice "github.com/ethereum-optimism/optimism/op-service" + "github.com/ethereum-optimism/optimism/op-service/cliiface" "github.com/urfave/cli/v2" ) @@ -72,7 +73,7 @@ func (c CLIConfig) Check() error { return nil } -func ReadCLIConfig(ctx *cli.Context) CLIConfig { +func ReadCLIConfig(ctx cliiface.Context) CLIConfig { return CLIConfig{ ListenAddr: ctx.String(ListenAddrFlagName), ListenPort: ctx.Int(PortFlagName), diff --git a/op-service/signer/cli.go b/op-service/signer/cli.go index 534fd09c97b..319efa3c117 100644 --- a/op-service/signer/cli.go +++ b/op-service/signer/cli.go @@ -8,6 +8,7 @@ import ( "github.com/urfave/cli/v2" opservice "github.com/ethereum-optimism/optimism/op-service" + "github.com/ethereum-optimism/optimism/op-service/cliiface" optls "github.com/ethereum-optimism/optimism/op-service/tls" ) @@ -70,7 +71,7 @@ func (c CLIConfig) Enabled() bool { return c.Endpoint != "" && c.Address != "" } -func ReadCLIConfig(ctx *cli.Context) CLIConfig { +func ReadCLIConfig(ctx cliiface.Context) CLIConfig { var headers = http.Header{} if ctx.StringSlice(HeadersFlagName) != nil { for _, header := range ctx.StringSlice(HeadersFlagName) { @@ -80,7 +81,6 @@ func ReadCLIConfig(ctx *cli.Context) CLIConfig { } } } - cfg := CLIConfig{ Endpoint: ctx.String(EndpointFlagName), Address: ctx.String(AddressFlagName), diff --git a/op-service/tls/cli.go b/op-service/tls/cli.go index c0b8a33f23d..024eb050f17 100644 --- a/op-service/tls/cli.go +++ b/op-service/tls/cli.go @@ -9,6 +9,7 @@ import ( "github.com/urfave/cli/v2" opservice "github.com/ethereum-optimism/optimism/op-service" + "github.com/ethereum-optimism/optimism/op-service/cliiface" ) const ( @@ -101,7 +102,7 @@ func (c CLIConfig) TLSEnabled() bool { // ReadCLIConfigWithPrefix reads tls cli configs with flag prefix // Should be used for client TLS configs when different from server on the same process -func ReadCLIConfigWithPrefix(ctx *cli.Context, flagPrefix string) CLIConfig { +func ReadCLIConfigWithPrefix(ctx cliiface.Context, flagPrefix string) CLIConfig { prefixFunc := func(flagName string) string { return strings.Trim(fmt.Sprintf("%s.%s", flagPrefix, flagName), ".") } diff --git a/op-service/txmgr/cli.go b/op-service/txmgr/cli.go index fa222ce5e0e..1e368fdd05a 100644 --- a/op-service/txmgr/cli.go +++ b/op-service/txmgr/cli.go @@ -9,6 +9,7 @@ import ( "time" opservice "github.com/ethereum-optimism/optimism/op-service" + "github.com/ethereum-optimism/optimism/op-service/cliiface" opcrypto "github.com/ethereum-optimism/optimism/op-service/crypto" "github.com/ethereum-optimism/optimism/op-service/eth" opsigner "github.com/ethereum-optimism/optimism/op-service/signer" @@ -352,7 +353,7 @@ func (m CLIConfig) Check() error { return nil } -func ReadCLIConfig(ctx *cli.Context) CLIConfig { +func ReadCLIConfig(ctx cliiface.Context) CLIConfig { return CLIConfig{ L1RPCURL: ctx.String(L1RPCFlagName), Mnemonic: ctx.String(MnemonicFlagName), From 1373e8346db2d71d2dc629eff66b78028ba830f4 Mon Sep 17 00:00:00 2001 From: Axel Kingsley Date: Thu, 9 Oct 2025 10:51:00 -0500 Subject: [PATCH 030/117] op-node: Initialization Control Refactor (#17766) * Interfaced CLI Context * No more side-effect initialization * Wire L1 and Server Overrides to Initialization * add permissable side-effects and mark with comments * Address Adrian's Comments --- op-node/node/node.go | 428 ++++++++++++++++++++++++++----------------- 1 file changed, 261 insertions(+), 167 deletions(-) diff --git a/op-node/node/node.go b/op-node/node/node.go index 2cf93f6800e..40598b9bc84 100644 --- a/op-node/node/node.go +++ b/op-node/node/node.go @@ -12,6 +12,8 @@ import ( "github.com/hashicorp/go-multierror" "github.com/ethereum/go-ethereum" + "github.com/ethereum/go-ethereum/common" + "github.com/ethereum/go-ethereum/core/types" gethevent "github.com/ethereum/go-ethereum/event" "github.com/ethereum/go-ethereum/log" "github.com/ethereum/go-ethereum/rpc" @@ -49,6 +51,24 @@ type closableSafeDB interface { io.Closer } +// L1Source provides the necessary L1 blockchain data for the node. +type L1Source interface { + L1BlockRefByLabel(ctx context.Context, label eth.BlockLabel) (eth.L1BlockRef, error) + L1BlockRefByNumber(ctx context.Context, num uint64) (eth.L1BlockRef, error) + L1BlockRefByHash(ctx context.Context, hash common.Hash) (eth.L1BlockRef, error) + SubscribeNewHead(ctx context.Context, ch chan<- *types.Header) (ethereum.Subscription, error) + ReadStorageAt(ctx context.Context, address common.Address, storageSlot common.Hash, blockHash common.Hash) (common.Hash, error) + InfoByHash(ctx context.Context, hash common.Hash) (eth.BlockInfo, error) + InfoAndTxsByHash(ctx context.Context, hash common.Hash) (eth.BlockInfo, types.Transactions, error) + FetchReceipts(ctx context.Context, blockHash common.Hash) (eth.BlockInfo, types.Receipts, error) + Close() +} + +// L1Beacon provides access to L1 beacon chain data, specifically for blob data retrieval. +type L1Beacon interface { + GetBlobs(ctx context.Context, ref eth.L1BlockRef, hashes []eth.IndexedBlobHash) ([]*eth.Blob, error) +} + type OpNode struct { // Retain the config to test for active features rather than test for runtime state. cfg *config.Config @@ -63,7 +83,7 @@ type OpNode struct { eventSys event.System eventDrain driver.Drain - l1Source *sources.L1Client // L1 Client to fetch data from + l1Source L1Source // L1 Client to fetch data from l2Driver *driver.Driver // L2 Engine to Sync l2Source *sources.EngineClient // L2 Execution Engine RPC bindings server *oprpc.Server // RPC server hosting the rollup-node API @@ -79,7 +99,7 @@ type OpNode struct { pprofService *oppprof.Service metricsSrv *httputil.HTTPServer - beacon *sources.L1BeaconClient + beacon L1Beacon interopSys interop.SubSystem @@ -120,7 +140,7 @@ func New(ctx context.Context, cfg *config.Config, log log.Logger, appVersion str // not a context leak, gossipsub is closed with a context. n.resourcesCtx, n.resourcesClose = context.WithCancel(context.Background()) - err := n.init(ctx, cfg) + err := n.init(ctx, cfg, initializationOverrides{}) if err != nil { log.Error("Error initializing the rollup node", "err", err) // ensure we always close the node resources if we fail to initialize the node. @@ -132,136 +152,199 @@ func New(ctx context.Context, cfg *config.Config, log log.Logger, appVersion str return n, nil } -func (n *OpNode) init(ctx context.Context, cfg *config.Config) error { +type initializationOverrides struct { + L1Source L1Source + Beacon L1Beacon + RPCHandler *oprpc.Handler +} + +// init progressively creates and sets up all the components of the OpNode +// some later initialization steps depend on the node being partially initialized with other components, +// so order is important to ensure that all resources are available when needed. +func (n *OpNode) init(ctx context.Context, cfg *config.Config, overrides initializationOverrides) error { n.log.Info("Initializing rollup node", "version", n.appVersion) - n.initEventSystem() - if err := n.initL1BeaconAPI(ctx, cfg); err != nil { - return err + + var err error + + n.eventSys, n.eventDrain, err = initEventSystem(n) + if err != nil { + return fmt.Errorf("failed to init event system: %w", err) } - if err := n.initL1Source(ctx, cfg); err != nil { - return fmt.Errorf("failed to init L1 Source: %w", err) + + if overrides.Beacon == nil { + beacon, err := initL1BeaconAPI(ctx, cfg, n) + if err != nil { + return err + } + n.beacon = beacon + } else { + n.beacon = overrides.Beacon } - if err := n.initL2(ctx, cfg); err != nil { + + if overrides.L1Source == nil { + l1Source, err := initL1Source(ctx, cfg, n) + if err != nil { + return fmt.Errorf("failed to init L1 Source: %w", err) + } + n.l1Source = l1Source + } else { + n.l1Source = overrides.L1Source + } + + // initL2 may use side effects to register interop subsystem to the node.EventSystem + n.l2Source, n.interopSys, n.l2Driver, n.safeDB, err = initL2(ctx, cfg, n) + if err != nil { return fmt.Errorf("failed to init L2: %w", err) } - if err := n.initL1Handlers(cfg); err != nil { - return fmt.Errorf("failed to init L1 Handlers: %w", err) + + n.l1HeadsSub, n.l1SafeSub, n.l1FinalizedSub, err = initL1Handlers(cfg, n) + if err != nil { + return fmt.Errorf("failed to init L1 Source: %w", err) } - if err := n.initRuntimeConfig(ctx, cfg); err != nil { // depends on L2, to signal initial runtime values to + + // initRuntimeConfig relies on side effects to set the runCfg, node.halted and call node.cancel if needed + if err := initRuntimeConfig(ctx, cfg, n); err != nil { return fmt.Errorf("failed to init the runtime config: %w", err) } - if err := n.initP2PSigner(ctx, cfg); err != nil { + + n.p2pSigner, err = initP2PSigner(ctx, cfg, n) + if err != nil { return fmt.Errorf("failed to init the P2P signer: %w", err) } - if err := n.initP2P(cfg); err != nil { + + n.p2pNode, err = initP2P(cfg, n) + if err != nil { return fmt.Errorf("failed to init the P2P stack: %w", err) } + // Only expose the server at the end, ensuring all RPC backend components are initialized. - if err := n.initRPCServer(cfg); err != nil { - return fmt.Errorf("failed to init the RPC server: %w", err) + if overrides.RPCHandler == nil { + n.server, err = initRPCServer(cfg, n) + if err != nil { + return fmt.Errorf("failed to init the RPC server: %w", err) + } + } else { + // the node registers to an existing RPC server's handler if provided + // the node assumes the RPC server is already started + n.server = nil + err := registerAPIs(cfg, n, overrides.RPCHandler) + if err != nil { + // panic here is to match the behavior of oprcp.Server.AddAPI, + // which wraps the Handler and panics if the API can't be added. + panic(fmt.Errorf("invalid API: %w", err)) + } } - if err := n.initMetricsServer(cfg); err != nil { + + n.metricsSrv, err = initMetricsServer(cfg, n) + if err != nil { return fmt.Errorf("failed to init the metrics server: %w", err) } + n.metrics.RecordInfo(n.appVersion) n.metrics.RecordUp() - if err := n.initPProf(cfg); err != nil { + + n.pprofService, err = initPProf(cfg, n) + if err != nil { return fmt.Errorf("failed to init profiling: %w", err) } + return nil } -func (n *OpNode) initEventSystem() { +func initEventSystem(node *OpNode) (event.System, driver.Drain, error) { // This executor will be configurable in the future, for parallel event processing - executor := event.NewGlobalSynchronous(n.resourcesCtx).WithMetrics(n.metrics) - sys := event.NewSystem(n.log, executor) - sys.AddTracer(event.NewMetricsTracer(n.metrics)) - sys.Register("node", event.DeriverFunc(n.onEvent)) - n.eventSys = sys - n.eventDrain = executor + executor := event.NewGlobalSynchronous(node.resourcesCtx).WithMetrics(node.metrics) + sys := event.NewSystem(node.log, executor) + sys.AddTracer(event.NewMetricsTracer(node.metrics)) + sys.Register("node", event.DeriverFunc(node.onEvent)) + return sys, executor, nil } -func (n *OpNode) initL1Source(ctx context.Context, cfg *config.Config) error { +func initL1Source(ctx context.Context, cfg *config.Config, node *OpNode) (*sources.L1Client, error) { // Cache 3/2 worth of sequencing window of receipts and txs defaultCacheSize := int(cfg.Rollup.SeqWindowSize) * 3 / 2 - l1RPC, l1Cfg, err := cfg.L1.Setup(ctx, n.log, defaultCacheSize, n.metrics) + l1RPC, l1Cfg, err := cfg.L1.Setup(ctx, node.log, defaultCacheSize, node.metrics) if err != nil { - return fmt.Errorf("failed to get L1 RPC client: %w", err) + return nil, fmt.Errorf("failed to get L1 RPC client: %w", err) } - n.l1Source, err = sources.NewL1Client(l1RPC, n.log, n.metrics.L1SourceCache, l1Cfg) + l1Source, err := sources.NewL1Client(l1RPC, node.log, node.metrics.L1SourceCache, l1Cfg) if err != nil { - return fmt.Errorf("failed to create L1 source: %w", err) + return nil, fmt.Errorf("failed to create L1 source: %w", err) } - if err := cfg.Rollup.ValidateL1Config(ctx, n.log, n.l1Source); err != nil { - return fmt.Errorf("failed to validate the L1 config: %w", err) + if err := cfg.Rollup.ValidateL1Config(ctx, node.log, l1Source); err != nil { + return nil, fmt.Errorf("failed to validate the L1 config: %w", err) } - return nil + return l1Source, nil } -func (n *OpNode) initL1Handlers(cfg *config.Config) error { - if n.l2Driver == nil { - return errors.New("l2 driver must be initialized") +func initL1Handlers(cfg *config.Config, node *OpNode) (ethereum.Subscription, ethereum.Subscription, ethereum.Subscription, error) { + if node.l2Driver == nil { + return nil, nil, nil, errors.New("l2 driver must be initialized") } onL1Head := func(ctx context.Context, sig eth.L1BlockRef) { // TODO(#16917) Remove Event System Refactor Comments // L1UnsafeEvent fan out is updated to procedural method calls - if n.cfg.Tracer != nil { - n.cfg.Tracer.OnNewL1Head(ctx, sig) + if node.cfg.Tracer != nil { + node.cfg.Tracer.OnNewL1Head(ctx, sig) } - n.l2Driver.SyncDeriver.L1Tracker.OnL1Unsafe(sig) - n.l2Driver.StatusTracker.OnL1Unsafe(sig) - n.l2Driver.SyncDeriver.OnL1Unsafe(ctx) + node.l2Driver.SyncDeriver.L1Tracker.OnL1Unsafe(sig) + node.l2Driver.StatusTracker.OnL1Unsafe(sig) + node.l2Driver.SyncDeriver.OnL1Unsafe(ctx) } onL1Safe := func(ctx context.Context, sig eth.L1BlockRef) { - n.l2Driver.StatusTracker.OnL1Safe(sig) + node.l2Driver.StatusTracker.OnL1Safe(sig) } onL1Finalized := func(ctx context.Context, sig eth.L1BlockRef) { // TODO(#16917) Remove Event System Refactor Comments // FinalizeL1Event fan out is updated to procedural method calls - n.l2Driver.StatusTracker.OnL1Finalized(sig) - n.l2Driver.Finalizer.OnL1Finalized(sig) - n.l2Driver.SyncDeriver.OnL1Finalized(ctx) + node.l2Driver.StatusTracker.OnL1Finalized(sig) + node.l2Driver.Finalizer.OnL1Finalized(sig) + node.l2Driver.SyncDeriver.OnL1Finalized(ctx) } // Keep subscribed to the L1 heads, which keeps the L1 maintainer pointing to the best headers to sync - n.l1HeadsSub = gethevent.ResubscribeErr(time.Second*10, func(ctx context.Context, err error) (gethevent.Subscription, error) { + l1HeadsSub := gethevent.ResubscribeErr(time.Second*10, func(ctx context.Context, err error) (gethevent.Subscription, error) { if err != nil { - n.log.Warn("resubscribing after failed L1 subscription", "err", err) + node.log.Warn("resubscribing after failed L1 subscription", "err", err) } - return eth.WatchHeadChanges(ctx, n.l1Source, onL1Head) + return eth.WatchHeadChanges(ctx, node.l1Source, onL1Head) }) go func() { - err, ok := <-n.l1HeadsSub.Err() + err, ok := <-l1HeadsSub.Err() if !ok { return } - n.log.Error("l1 heads subscription error", "err", err) + node.log.Error("l1 heads subscription error", "err", err) }() // Poll for the safe L1 block and finalized block, // which only change once per epoch at most and may be delayed. - n.l1SafeSub = eth.PollBlockChanges(n.log, n.l1Source, onL1Safe, eth.Safe, + l1SafeSub := eth.PollBlockChanges(node.log, node.l1Source, onL1Safe, eth.Safe, cfg.L1EpochPollInterval, time.Second*10) - n.l1FinalizedSub = eth.PollBlockChanges(n.log, n.l1Source, onL1Finalized, eth.Finalized, + l1FinalizedSub := eth.PollBlockChanges(node.log, node.l1Source, onL1Finalized, eth.Finalized, cfg.L1EpochPollInterval, time.Second*10) - return nil + return l1HeadsSub, l1SafeSub, l1FinalizedSub, nil } -func (n *OpNode) initRuntimeConfig(ctx context.Context, cfg *config.Config) error { +// initRuntimeConfig initializes the runtime config and starts a background loop to reload it at the configured interval. +// note: this function relies on side effects to set node.runCfg +func initRuntimeConfig(ctx context.Context, cfg *config.Config, node *OpNode) error { // attempt to load runtime config, repeat N times - n.runCfg = runcfg.NewRuntimeConfig(n.log, n.l1Source, &cfg.Rollup) + runCfg := runcfg.NewRuntimeConfig(node.log, node.l1Source, &cfg.Rollup) + // Set node.runCfg early so handleProtocolVersionsUpdate can access it during initialization + node.runCfg = runCfg confDepth := cfg.Driver.VerifierConfDepth reload := func(ctx context.Context) (eth.L1BlockRef, error) { fetchCtx, fetchCancel := context.WithTimeout(ctx, time.Second*10) - l1Head, err := n.l1Source.L1BlockRefByLabel(fetchCtx, eth.Unsafe) + l1Head, err := node.l1Source.L1BlockRefByLabel(fetchCtx, eth.Unsafe) fetchCancel() if err != nil { - n.log.Error("failed to fetch L1 head for runtime config initialization", "err", err) + node.log.Error("failed to fetch L1 head for runtime config initialization", "err", err) return eth.L1BlockRef{}, err } @@ -271,22 +354,22 @@ func (n *OpNode) initRuntimeConfig(ctx context.Context, cfg *config.Config) erro blNum -= confDepth } fetchCtx, fetchCancel = context.WithTimeout(ctx, time.Second*10) - confirmed, err := n.l1Source.L1BlockRefByNumber(fetchCtx, blNum) + confirmed, err := node.l1Source.L1BlockRefByNumber(fetchCtx, blNum) fetchCancel() if err != nil { - n.log.Error("failed to fetch confirmed L1 block for runtime config loading", "err", err, "number", blNum) + node.log.Error("failed to fetch confirmed L1 block for runtime config loading", "err", err, "number", blNum) return eth.L1BlockRef{}, err } fetchCtx, fetchCancel = context.WithTimeout(ctx, time.Second*10) - err = n.runCfg.Load(fetchCtx, confirmed) + err = runCfg.Load(fetchCtx, confirmed) fetchCancel() if err != nil { - n.log.Error("failed to fetch runtime config data", "err", err) + node.log.Error("failed to fetch runtime config data", "err", err) return l1Head, err } - err = n.handleProtocolVersionsUpdate(ctx) + err = node.handleProtocolVersionsUpdate(ctx) return l1Head, err } @@ -304,7 +387,7 @@ func (n *OpNode) initRuntimeConfig(ctx context.Context, cfg *config.Config) erro // start a background loop, to keep reloading it at the configured reload interval reloader := func(ctx context.Context, reloadInterval time.Duration) { if reloadInterval <= 0 { - n.log.Debug("not running runtime-config reloading background loop") + node.log.Debug("not running runtime-config reloading background loop") return } ticker := time.NewTicker(reloadInterval) @@ -317,18 +400,18 @@ func (n *OpNode) initRuntimeConfig(ctx context.Context, cfg *config.Config) erro l1Head, err := reload(ctx) if err != nil { if errors.Is(err, errNodeHalt) { - n.halted.Store(true) - if n.cancel != nil { // node cancellation is always available when started as CLI app - n.cancel(errNodeHalt) + node.halted.Store(true) + if node.cancel != nil { // node cancellation is always available when started as CLI app + node.cancel(errNodeHalt) return } else { - n.log.Debug("opted to halt, but cannot halt node", "l1_head", l1Head) + node.log.Debug("opted to halt, but cannot halt node", "l1_head", l1Head) } } else { - n.log.Warn("failed to reload runtime config", "err", err) + node.log.Warn("failed to reload runtime config", "err", err) } } else { - n.log.Debug("reloaded runtime config", "l1_head", l1Head) + node.log.Debug("reloaded runtime config", "l1_head", l1Head) } case <-ctx.Done(): return @@ -336,41 +419,39 @@ func (n *OpNode) initRuntimeConfig(ctx context.Context, cfg *config.Config) erro } } - n.runtimeConfigReloaderDone = make(chan struct{}) // Manages the lifetime of reloader. In order to safely Close the OpNode go func(ctx context.Context, reloadInterval time.Duration) { reloader(ctx, reloadInterval) - close(n.runtimeConfigReloaderDone) - }(n.resourcesCtx, cfg.RuntimeConfigReloadInterval) // this keeps running after initialization + }(node.resourcesCtx, cfg.RuntimeConfigReloadInterval) // this keeps running after initialization return nil } -func (n *OpNode) initL1BeaconAPI(ctx context.Context, cfg *config.Config) error { +func initL1BeaconAPI(ctx context.Context, cfg *config.Config, node *OpNode) (*sources.L1BeaconClient, error) { // If Ecotone upgrade is not scheduled yet, then there is no need for a Beacon API. if cfg.Rollup.EcotoneTime == nil { - return nil + return nil, nil } // Once the Ecotone upgrade is scheduled, we must have initialized the Beacon API settings. if cfg.Beacon == nil { - return fmt.Errorf("missing L1 Beacon Endpoint configuration: this API is mandatory for Ecotone upgrade at t=%d", *cfg.Rollup.EcotoneTime) + return nil, fmt.Errorf("missing L1 Beacon Endpoint configuration: this API is mandatory for Ecotone upgrade at t=%d", *cfg.Rollup.EcotoneTime) } // We always initialize a client. We will get an error on requests if the client does not work. // This way the op-node can continue non-L1 functionality when the user chooses to ignore the Beacon API requirement. - beaconClient, fallbacks, err := cfg.Beacon.Setup(ctx, n.log) + beaconClient, fallbacks, err := cfg.Beacon.Setup(ctx, node.log) if err != nil { - return fmt.Errorf("failed to setup L1 Beacon API client: %w", err) + return nil, fmt.Errorf("failed to setup L1 Beacon API client: %w", err) } beaconCfg := sources.L1BeaconClientConfig{ FetchAllSidecars: cfg.Beacon.ShouldFetchAllSidecars(), } - n.beacon = sources.NewL1BeaconClient(beaconClient, beaconCfg, fallbacks...) + beacon := sources.NewL1BeaconClient(beaconClient, beaconCfg, fallbacks...) // Retry retrieval of the Beacon API version, to be more robust on startup against Beacon API connection issues. beaconVersion, missingEndpoint, err := retry.Do2[string, bool](ctx, 5, retry.Exponential(), func() (string, bool, error) { ctx, cancel := context.WithTimeout(ctx, time.Second*10) defer cancel() - beaconVersion, err := n.beacon.GetVersion(ctx) + beaconVersion, err := beacon.GetVersion(ctx) if err != nil { if errors.Is(err, client.ErrNoEndpoint) { return "", true, nil // don't return an error, we do not have to retry when there is a config issue. @@ -382,148 +463,160 @@ func (n *OpNode) initL1BeaconAPI(ctx context.Context, cfg *config.Config) error if missingEndpoint { // Allow the user to continue if they explicitly ignore the requirement of the endpoint. if cfg.Beacon.ShouldIgnoreBeaconCheck() { - n.log.Warn("This endpoint is required for the Ecotone upgrade, but is missing, and configured to be ignored. " + + node.log.Warn("This endpoint is required for the Ecotone upgrade, but is missing, and configured to be ignored. " + "The node may be unable to retrieve EIP-4844 blobs data.") - return nil + return beacon, nil } else { // If the client tells us the endpoint was not configured, // then explain why we need it, and what the user can do to ignore this. - n.log.Error("The Ecotone upgrade requires a L1 Beacon API endpoint, to retrieve EIP-4844 blobs data. " + + node.log.Error("The Ecotone upgrade requires a L1 Beacon API endpoint, to retrieve EIP-4844 blobs data. " + "This can be ignored with the --l1.beacon.ignore option, " + "but the node may be unable to sync from L1 without this endpoint.") - return errors.New("missing L1 Beacon API endpoint") + return nil, errors.New("missing L1 Beacon API endpoint") } } else if err != nil { if cfg.Beacon.ShouldIgnoreBeaconCheck() { - n.log.Warn("Failed to check L1 Beacon API version, but configuration ignores results. "+ + node.log.Warn("Failed to check L1 Beacon API version, but configuration ignores results. "+ "The node may be unable to retrieve EIP-4844 blobs data.", "err", err) - return nil + return beacon, nil } else { - return fmt.Errorf("failed to check L1 Beacon API version: %w", err) + return nil, fmt.Errorf("failed to check L1 Beacon API version: %w", err) } } else { - n.log.Info("Connected to L1 Beacon API, ready for EIP-4844 blobs retrieval.", "version", beaconVersion) - return nil + node.log.Info("Connected to L1 Beacon API, ready for EIP-4844 blobs retrieval.", "version", beaconVersion) + return beacon, nil } } -func (n *OpNode) initL2(ctx context.Context, cfg *config.Config) error { - rpcClient, rpcCfg, err := cfg.L2.Setup(ctx, n.log, &cfg.Rollup, n.metrics) +func initL2(ctx context.Context, cfg *config.Config, node *OpNode) (*sources.EngineClient, interop.SubSystem, *driver.Driver, closableSafeDB, error) { + rpcClient, rpcCfg, err := cfg.L2.Setup(ctx, node.log, &cfg.Rollup, node.metrics) if err != nil { - return fmt.Errorf("failed to setup L2 execution-engine RPC client: %w", err) + return nil, nil, nil, nil, fmt.Errorf("failed to setup L2 execution-engine RPC client: %w", err) } rpcCfg.FetchWithdrawalRootFromState = cfg.FetchWithdrawalRootFromState - n.l2Source, err = sources.NewEngineClient(rpcClient, n.log, n.metrics.L2SourceCache, rpcCfg) + l2Source, err := sources.NewEngineClient(rpcClient, node.log, node.metrics.L2SourceCache, rpcCfg) if err != nil { - return fmt.Errorf("failed to create Engine client: %w", err) + return nil, nil, nil, nil, fmt.Errorf("failed to create Engine client: %w", err) } - if err := cfg.Rollup.ValidateL2Config(ctx, n.l2Source, cfg.Sync.SyncMode == sync.ELSync); err != nil { - return err + if err := cfg.Rollup.ValidateL2Config(ctx, l2Source, cfg.Sync.SyncMode == sync.ELSync); err != nil { + return nil, nil, nil, nil, err } indexingMode := false - sys, err := cfg.InteropConfig.Setup(ctx, n.log, &n.cfg.Rollup, n.l1Source, n.l2Source, n.metrics) + sys, err := cfg.InteropConfig.Setup(ctx, node.log, &node.cfg.Rollup, node.l1Source, l2Source, node.metrics) if err != nil { - return fmt.Errorf("failed to setup interop: %w", err) + return nil, nil, nil, nil, fmt.Errorf("failed to setup interop: %w", err) } else if sys != nil { // we continue with legacy mode if no interop sub-system is set up. _, indexingMode = sys.(*indexing.IndexingMode) - n.interopSys = sys - n.eventSys.Register("interop", n.interopSys) + node.eventSys.Register("interop", sys) } var sequencerConductor conductor.SequencerConductor = &conductor.NoOpConductor{} if cfg.ConductorEnabled { - sequencerConductor = NewConductorClient(cfg, n.log, n.metrics) + sequencerConductor = NewConductorClient(cfg, node.log, node.metrics) } // if altDA is not explicitly activated in the node CLI, the config + any error will be ignored. rpCfg, err := cfg.Rollup.GetOPAltDAConfig() if cfg.AltDA.Enabled && err != nil { - return fmt.Errorf("failed to get altDA config: %w", err) + return nil, nil, nil, nil, fmt.Errorf("failed to get altDA config: %w", err) } - altDA := altda.NewAltDA(n.log, cfg.AltDA, rpCfg, n.metrics.AltDAMetrics) + altDA := altda.NewAltDA(node.log, cfg.AltDA, rpCfg, node.metrics.AltDAMetrics) + var safeDB closableSafeDB if cfg.SafeDBPath != "" { - n.log.Info("Safe head database enabled", "path", cfg.SafeDBPath) - safeDB, err := safedb.NewSafeDB(n.log, cfg.SafeDBPath) + node.log.Info("Safe head database enabled", "path", cfg.SafeDBPath) + safeDB, err = safedb.NewSafeDB(node.log, cfg.SafeDBPath) if err != nil { - return fmt.Errorf("failed to create safe head database at %v: %w", cfg.SafeDBPath, err) + return nil, nil, nil, nil, fmt.Errorf("failed to create safe head database at %v: %w", cfg.SafeDBPath, err) } - n.safeDB = safeDB } else { - n.safeDB = safedb.Disabled + safeDB = safedb.Disabled } if cfg.Rollup.ChainOpConfig == nil { - return fmt.Errorf("cfg.Rollup.ChainOpConfig is nil. Please see https://github.com/ethereum-optimism/optimism/releases/tag/op-node/v1.11.0: %w", err) + return nil, nil, nil, nil, fmt.Errorf("cfg.Rollup.ChainOpConfig is nil. Please see https://github.com/ethereum-optimism/optimism/releases/tag/op-node/v1.11.0: %w", err) } - n.l2Driver = driver.NewDriver(n.eventSys, n.eventDrain, &cfg.Driver, &cfg.Rollup, cfg.L1ChainConfig, cfg.DependencySet, n.l2Source, n.l1Source, - n.beacon, n, n, n.log, n.metrics, cfg.ConfigPersistence, n.safeDB, &cfg.Sync, sequencerConductor, altDA, indexingMode) + l2Driver := driver.NewDriver(node.eventSys, node.eventDrain, &cfg.Driver, &cfg.Rollup, cfg.L1ChainConfig, cfg.DependencySet, l2Source, node.l1Source, + node.beacon, node, node, node.log, node.metrics, cfg.ConfigPersistence, safeDB, &cfg.Sync, sequencerConductor, altDA, indexingMode) // Wire up IndexingMode to engine controller for direct procedure call - if n.interopSys != nil { - if indexingMode, ok := n.interopSys.(*indexing.IndexingMode); ok { - indexingMode.SetEngineController(n.l2Driver.SyncDeriver.Engine) + if sys != nil { + if indexingMode, ok := sys.(*indexing.IndexingMode); ok { + indexingMode.SetEngineController(l2Driver.SyncDeriver.Engine) } } - return nil + return l2Source, sys, l2Driver, safeDB, nil } -func (n *OpNode) initRPCServer(cfg *config.Config) error { +func initRPCServer(cfg *config.Config, node *OpNode) (*oprpc.Server, error) { server := newRPCServer(&cfg.RPC, &cfg.Rollup, cfg.DependencySet, - n.l2Source.L2Client, n.l2Driver, n.safeDB, - n.log, n.metrics, n.appVersion) - if p2pNode := n.getP2PNodeIfEnabled(); p2pNode != nil { - server.AddAPI(rpc.API{ + node.l2Source.L2Client, node.l2Driver, node.safeDB, + node.log, node.metrics, node.appVersion) + if err := registerAPIs(cfg, node, server.Handler); err != nil { + // panic here is to match the behavior of oprcp.Server.AddAPI, + // which wraps the Handler and panics if the API can't be added. + panic(fmt.Errorf("invalid API: %w", err)) + } + node.log.Info("Starting JSON-RPC server") + if err := server.Start(); err != nil { + return nil, fmt.Errorf("unable to start RPC server: %w", err) + } + node.log.Info("Started JSON-RPC server", "addr", server.Endpoint()) + return server, nil +} + +func registerAPIs(cfg *config.Config, node *OpNode, handler *oprpc.Handler) error { + if p2pNode := node.getP2PNodeIfEnabled(); p2pNode != nil { + if err := handler.AddAPI(rpc.API{ Namespace: p2p.NamespaceRPC, - Service: p2p.NewP2PAPIBackend(p2pNode, n.log), - }) - n.log.Info("P2P RPC enabled") + Service: p2p.NewP2PAPIBackend(p2pNode, node.log), + }); err != nil { + return fmt.Errorf("failed to add P2P API: %w", err) + } + node.log.Info("P2P RPC enabled") } if cfg.ExperimentalOPStackAPI { - server.AddAPI(rpc.API{ + if err := handler.AddAPI(rpc.API{ Namespace: "opstack", - Service: NewOpstackAPI(n.l2Driver.SyncDeriver.Engine, n), - }) - n.log.Info("Experimental OP stack API enabled") + Service: NewOpstackAPI(node.l2Driver.SyncDeriver.Engine, node), + }); err != nil { + return fmt.Errorf("failed to add Experimental OP stack API: %w", err) + } + node.log.Info("Experimental OP stack API enabled") } if cfg.RPC.EnableAdmin { - server.AddAPI(rpc.API{ + if err := handler.AddAPI(rpc.API{ Namespace: "admin", - Service: NewAdminAPI(n.l2Driver, n.log), - }) - n.log.Info("Admin RPC enabled") - } - n.log.Info("Starting JSON-RPC server") - if err := server.Start(); err != nil { - return fmt.Errorf("unable to start RPC server: %w", err) + Service: NewAdminAPI(node.l2Driver, node.log), + }); err != nil { + return fmt.Errorf("failed to add Admin API: %w", err) + } + node.log.Info("Admin RPC enabled") } - n.log.Info("Started JSON-RPC server", "addr", server.Endpoint()) - n.server = server return nil } -func (n *OpNode) initMetricsServer(cfg *config.Config) error { +func initMetricsServer(cfg *config.Config, node *OpNode) (*httputil.HTTPServer, error) { if !cfg.Metrics.Enabled { - n.log.Info("metrics disabled") - return nil + node.log.Info("metrics disabled") + return nil, nil } - n.log.Debug("starting metrics server", "addr", cfg.Metrics.ListenAddr, "port", cfg.Metrics.ListenPort) - metricsSrv, err := n.metrics.StartServer(cfg.Metrics.ListenAddr, cfg.Metrics.ListenPort) + node.log.Debug("starting metrics server", "addr", cfg.Metrics.ListenAddr, "port", cfg.Metrics.ListenPort) + metricsSrv, err := node.metrics.StartServer(cfg.Metrics.ListenAddr, cfg.Metrics.ListenPort) if err != nil { - return fmt.Errorf("failed to start metrics server: %w", err) + return nil, fmt.Errorf("failed to start metrics server: %w", err) } - n.log.Info("started metrics server", "addr", metricsSrv.Addr()) - n.metricsSrv = metricsSrv - return nil + node.log.Info("started metrics server", "addr", metricsSrv.Addr()) + return metricsSrv, nil } -func (n *OpNode) initPProf(cfg *config.Config) error { - n.pprofService = oppprof.New( +func initPProf(cfg *config.Config, node *OpNode) (*oppprof.Service, error) { + pprofService := oppprof.New( cfg.Pprof.ListenEnabled, cfg.Pprof.ListenAddr, cfg.Pprof.ListenPort, @@ -532,48 +625,49 @@ func (n *OpNode) initPProf(cfg *config.Config) error { cfg.Pprof.ProfileFilename, ) - if err := n.pprofService.Start(); err != nil { - return fmt.Errorf("failed to start pprof service: %w", err) + if err := pprofService.Start(); err != nil { + return nil, fmt.Errorf("failed to start pprof service: %w", err) } - return nil + return pprofService, nil } func (n *OpNode) p2pEnabled() bool { return n.cfg.P2PEnabled() } -func (n *OpNode) initP2P(cfg *config.Config) (err error) { - n.p2pMu.Lock() - defer n.p2pMu.Unlock() - if n.p2pNode != nil { +func initP2P(cfg *config.Config, node *OpNode) (*p2p.NodeP2P, error) { + node.p2pMu.Lock() + defer node.p2pMu.Unlock() + if node.p2pNode != nil { panic("p2p node already initialized") } - if n.p2pEnabled() { - if n.l2Driver.SyncDeriver == nil { + if node.p2pEnabled() { + if node.l2Driver.SyncDeriver == nil { panic("SyncDeriver must be initialized") } // embed syncDeriver and tracer(optional) to the blockReceiver to handle unsafe payloads via p2p - rec := p2p.NewBlockReceiver(n.log, n.metrics, n.l2Driver.SyncDeriver, n.cfg.Tracer) - n.p2pNode, err = p2p.NewNodeP2P(n.resourcesCtx, &cfg.Rollup, n.log, cfg.P2P, rec, n.l2Source, n.runCfg, n.metrics) + rec := p2p.NewBlockReceiver(node.log, node.metrics, node.l2Driver.SyncDeriver, node.cfg.Tracer) + p2pNode, err := p2p.NewNodeP2P(node.resourcesCtx, &cfg.Rollup, node.log, cfg.P2P, rec, node.l2Source, node.runCfg, node.metrics) if err != nil { - return + return nil, err } - if n.p2pNode.Dv5Udp() != nil { - go n.p2pNode.DiscoveryProcess(n.resourcesCtx, n.log, &cfg.Rollup, cfg.P2P.TargetPeers()) + if p2pNode.Dv5Udp() != nil { + go p2pNode.DiscoveryProcess(node.resourcesCtx, node.log, &cfg.Rollup, cfg.P2P.TargetPeers()) } + return p2pNode, nil } - return nil + return nil, nil } -func (n *OpNode) initP2PSigner(ctx context.Context, cfg *config.Config) (err error) { +func initP2PSigner(ctx context.Context, cfg *config.Config, node *OpNode) (p2p.Signer, error) { // the p2p signer setup is optional if cfg.P2PSigner == nil { - return + return nil, nil } // p2pSigner may still be nil, the signer setup may not create any signer, the signer is optional - n.p2pSigner, err = cfg.P2PSigner.SetupSigner(ctx) - return + p2pSigner, err := cfg.P2PSigner.SetupSigner(ctx) + return p2pSigner, err } func (n *OpNode) Start(ctx context.Context) error { From 0d3505296b68f094538cb82c200d2a3a1afe9830 Mon Sep 17 00:00:00 2001 From: Inphi Date: Thu, 9 Oct 2025 12:00:58 -0400 Subject: [PATCH 031/117] vm-runner: Annotate logs with a trace id for runs (#17801) --- op-challenger/runner/runner.go | 34 +++++++++++++++++++++++----------- 1 file changed, 23 insertions(+), 11 deletions(-) diff --git a/op-challenger/runner/runner.go b/op-challenger/runner/runner.go index 648bc4f8a31..53ef8bcfc20 100644 --- a/op-challenger/runner/runner.go +++ b/op-challenger/runner/runner.go @@ -2,8 +2,11 @@ package runner import ( "context" + "crypto/rand" + "encoding/base32" "errors" "fmt" + "io" "os" "path/filepath" "regexp" @@ -124,7 +127,8 @@ func (r *Runner) loop(ctx context.Context, runConfig RunConfig, rollupClient *so t := time.NewTicker(1 * time.Minute) defer t.Stop() for { - r.runAndRecordOnce(ctx, runConfig, rollupClient, supervisorClient, caller) + baseLog := r.log.New("run_id", generateRunID()) + r.runAndRecordOnce(ctx, baseLog, runConfig, rollupClient, supervisorClient, caller) select { case <-t.C: case <-ctx.Done(): @@ -133,7 +137,7 @@ func (r *Runner) loop(ctx context.Context, runConfig RunConfig, rollupClient *so } } -func (r *Runner) runAndRecordOnce(ctx context.Context, runConfig RunConfig, rollupClient *sources.RollupClient, supervisorClient *sources.SupervisorClient, caller *batching.MultiCaller) { +func (r *Runner) runAndRecordOnce(ctx context.Context, rlog log.Logger, runConfig RunConfig, rollupClient *sources.RollupClient, supervisorClient *sources.SupervisorClient, caller *batching.MultiCaller) { recordError := func(err error, traceType string, m Metricer, log log.Logger) { if errors.Is(err, ErrUnexpectedStatusCode) { log.Error("Incorrect status code", "type", runConfig.Name, "err", err) @@ -153,13 +157,13 @@ func (r *Runner) runAndRecordOnce(ctx context.Context, runConfig RunConfig, roll var prestateSource prestateFetcher if strings.HasPrefix(runConfig.PrestateFilename, "file:") { path := runConfig.PrestateFilename[len("file:"):] - r.log.Info("Using local file prestate", "type", runConfig.TraceType, "path", path) + rlog.Info("Using local file prestate", "type", runConfig.TraceType, "path", path) prestateSource = &LocalPrestateFetcher{path: path} } else if runConfig.PrestateFilename != "" { - r.log.Info("Using named prestate", "type", runConfig.TraceType, "filename", runConfig.PrestateFilename) + rlog.Info("Using named prestate", "type", runConfig.TraceType, "filename", runConfig.PrestateFilename) prestateSource = &NamedPrestateFetcher{filename: runConfig.PrestateFilename} } else if runConfig.Prestate == (common.Hash{}) { - r.log.Info("Using on chain prestate", "type", runConfig.TraceType) + rlog.Info("Using on chain prestate", "type", runConfig.TraceType) prestateSource = &OnChainPrestateFetcher{ m: r.m, gameFactoryAddress: r.cfg.GameFactoryAddress, @@ -167,26 +171,26 @@ func (r *Runner) runAndRecordOnce(ctx context.Context, runConfig RunConfig, roll caller: caller, } } else { - r.log.Info("Using specific prestate", "type", runConfig.TraceType, "hash", runConfig.Prestate) + rlog.Info("Using specific prestate", "type", runConfig.TraceType, "hash", runConfig.Prestate) prestateSource = &HashPrestateFetcher{prestateHash: runConfig.Prestate} } - localInputs, err := createGameInputs(ctx, r.log, rollupClient, supervisorClient, runConfig.Name, runConfig.TraceType) + localInputs, err := createGameInputs(ctx, rlog, rollupClient, supervisorClient, runConfig.Name, runConfig.TraceType) if err != nil { - recordError(err, runConfig.Name, r.m, r.log) + recordError(err, runConfig.Name, r.m, rlog) return } - inputsLogger := r.log.New("l1", localInputs.L1Head, "l2", localInputs.L2Head, "l2Block", localInputs.L2SequenceNumber, "claim", localInputs.L2Claim) + inputsLogger := rlog.New("l1", localInputs.L1Head, "l2", localInputs.L2Head, "l2Block", localInputs.L2SequenceNumber, "claim", localInputs.L2Claim) // Sanitize the directory name. safeName := regexp.MustCompile("[^a-zA-Z0-9_-]").ReplaceAllString(runConfig.Name, "") dir, err := r.prepDatadir(safeName) if err != nil { - recordError(err, runConfig.Name, r.m, r.log) + recordError(err, runConfig.Name, r.m, rlog) return } err = r.runOnce(ctx, inputsLogger.With("type", runConfig.Name), runConfig.Name, runConfig.TraceType, prestateSource, localInputs, dir) - recordError(err, runConfig.Name, r.m, r.log) + recordError(err, runConfig.Name, r.m, rlog) } func (r *Runner) runOnce(ctx context.Context, logger log.Logger, name string, traceType types.TraceType, prestateSource prestateFetcher, localInputs utils.LocalGameInputs, dir string) error { @@ -251,4 +255,12 @@ func (r *Runner) initMetricsServer(cfg *opmetrics.CLIConfig) error { return nil } +var b32 = base32.StdEncoding.WithPadding(base32.NoPadding) + +func generateRunID() string { + var b [6]byte + _, _ = io.ReadFull(rand.Reader, b[:]) + return b32.EncodeToString(b[:]) +} + var _ cliapp.Lifecycle = (*Runner)(nil) From 1667684dd4563b325d34bcfd54feb09b43b44f2b Mon Sep 17 00:00:00 2001 From: Sam Stokes <35908605+bitwiseguy@users.noreply.github.com> Date: Thu, 9 Oct 2025 14:39:50 -0400 Subject: [PATCH 032/117] op-deployer: add cli-level bootstrap integration tests (#17803) --- .../integration_test/cli/bootstrap_test.go | 229 ++++++++++++++++++ 1 file changed, 229 insertions(+) create mode 100644 op-deployer/pkg/deployer/integration_test/cli/bootstrap_test.go diff --git a/op-deployer/pkg/deployer/integration_test/cli/bootstrap_test.go b/op-deployer/pkg/deployer/integration_test/cli/bootstrap_test.go new file mode 100644 index 00000000000..c3ac9b60328 --- /dev/null +++ b/op-deployer/pkg/deployer/integration_test/cli/bootstrap_test.go @@ -0,0 +1,229 @@ +package cli + +import ( + "encoding/json" + "math/big" + "os" + "path/filepath" + "strconv" + "testing" + + "github.com/ethereum-optimism/optimism/op-chain-ops/addresses" + "github.com/ethereum-optimism/optimism/op-chain-ops/devkeys" + "github.com/ethereum-optimism/optimism/op-deployer/pkg/deployer/integration_test/shared" + "github.com/ethereum-optimism/optimism/op-deployer/pkg/deployer/opcm" + "github.com/ethereum-optimism/optimism/op-deployer/pkg/deployer/standard" + "github.com/ethereum-optimism/optimism/op-service/testutils/devnet" + "github.com/ethereum/go-ethereum/common" + "github.com/ethereum/go-ethereum/params" + "github.com/stretchr/testify/require" +) + +// TestCLIBootstrap tests the bootstrap commands via CLI +func TestCLIBootstrap(t *testing.T) { + runner := NewCLITestRunnerWithNetwork(t) + workDir := runner.GetWorkDir() + + // Use the same chain ID that anvil runs on + l1ChainID := uint64(devnet.DefaultChainID) + l1ChainIDBig := big.NewInt(int64(l1ChainID)) + + // Get dev keys for role addresses + dk, err := devkeys.NewMnemonicDevKeys(devkeys.TestMnemonic) + require.NoError(t, err) + + // Get addresses for required roles + superchainProxyAdminOwner := shared.AddrFor(t, dk, devkeys.L1ProxyAdminOwnerRole.Key(l1ChainIDBig)) + protocolVersionsOwner := shared.AddrFor(t, dk, devkeys.SuperchainDeployerKey.Key(l1ChainIDBig)) + guardian := shared.AddrFor(t, dk, devkeys.SuperchainConfigGuardianKey.Key(l1ChainIDBig)) + challenger := shared.AddrFor(t, dk, devkeys.ChallengerRole.Key(l1ChainIDBig)) + + t.Run("bootstrap superchain", func(t *testing.T) { + superchainOutputFile := filepath.Join(workDir, "bootstrap_superchain.json") + + // Run bootstrap superchain command + output := runner.ExpectSuccessWithNetwork(t, []string{ + "bootstrap", "superchain", + "--outfile", superchainOutputFile, + "--superchain-proxy-admin-owner", superchainProxyAdminOwner.Hex(), + "--protocol-versions-owner", protocolVersionsOwner.Hex(), + "--guardian", guardian.Hex(), + }, nil) + + t.Logf("Bootstrap superchain output:\n%s", output) + + // Verify output file was created + require.FileExists(t, superchainOutputFile) + + // Parse and validate the output + var superchainOutput opcm.DeploySuperchainOutput + data, err := os.ReadFile(superchainOutputFile) + require.NoError(t, err) + err = json.Unmarshal(data, &superchainOutput) + require.NoError(t, err) + require.NoError(t, addresses.CheckNoZeroAddresses(superchainOutput)) + }) + + t.Run("bootstrap superchain with custom protocol versions", func(t *testing.T) { + superchainOutputFile := filepath.Join(workDir, "bootstrap_superchain_custom.json") + + // Use a custom protocol version - create v1.0.0 with custom build + customVersion := params.ProtocolVersionV0{ + Build: [8]byte{0, 0, 0, 0, 0, 0, 0, 1}, + Major: 1, + Minor: 0, + Patch: 0, + PreRelease: 0, + }.Encode() + + // Run bootstrap superchain command with custom versions + output := runner.ExpectSuccessWithNetwork(t, []string{ + "bootstrap", "superchain", + "--outfile", superchainOutputFile, + "--superchain-proxy-admin-owner", superchainProxyAdminOwner.Hex(), + "--protocol-versions-owner", protocolVersionsOwner.Hex(), + "--guardian", guardian.Hex(), + "--required-protocol-version", common.Hash(customVersion).Hex(), + "--recommended-protocol-version", common.Hash(customVersion).Hex(), + }, nil) + + t.Logf("Bootstrap superchain (custom protocol versions) output:\n%s", output) + + // Verify output file was created + require.FileExists(t, superchainOutputFile) + + // Parse and validate the output + var superchainOutput opcm.DeploySuperchainOutput + data, err := os.ReadFile(superchainOutputFile) + require.NoError(t, err) + err = json.Unmarshal(data, &superchainOutput) + require.NoError(t, err) + require.NoError(t, addresses.CheckNoZeroAddresses(superchainOutput)) + }) + + t.Run("bootstrap superchain paused", func(t *testing.T) { + superchainOutputFile := filepath.Join(workDir, "bootstrap_superchain_paused.json") + + // Run bootstrap superchain command with paused flag + output := runner.ExpectSuccessWithNetwork(t, []string{ + "bootstrap", "superchain", + "--outfile", superchainOutputFile, + "--superchain-proxy-admin-owner", superchainProxyAdminOwner.Hex(), + "--protocol-versions-owner", protocolVersionsOwner.Hex(), + "--guardian", guardian.Hex(), + "--paused", + }, nil) + + t.Logf("Bootstrap superchain (paused) output:\n%s", output) + + // Verify output file was created + require.FileExists(t, superchainOutputFile) + + // Parse and validate the output + var superchainOutput opcm.DeploySuperchainOutput + data, err := os.ReadFile(superchainOutputFile) + require.NoError(t, err) + err = json.Unmarshal(data, &superchainOutput) + require.NoError(t, err) + require.NoError(t, addresses.CheckNoZeroAddresses(superchainOutput)) + }) + + t.Run("bootstrap implementations", func(t *testing.T) { + // First, we need a superchain deployment + superchainOutputFile := filepath.Join(workDir, "bootstrap_superchain_for_impls.json") + runner.ExpectSuccessWithNetwork(t, []string{ + "bootstrap", "superchain", + "--outfile", superchainOutputFile, + "--superchain-proxy-admin-owner", superchainProxyAdminOwner.Hex(), + "--protocol-versions-owner", protocolVersionsOwner.Hex(), + "--guardian", guardian.Hex(), + }, nil) + + // Parse superchain output to get addresses + var superchainOutput opcm.DeploySuperchainOutput + data, err := os.ReadFile(superchainOutputFile) + require.NoError(t, err) + err = json.Unmarshal(data, &superchainOutput) + require.NoError(t, err) + require.NoError(t, addresses.CheckNoZeroAddresses(superchainOutput)) + + implsOutputFile := filepath.Join(workDir, "bootstrap_implementations.json") + + // Run bootstrap implementations command (use same key index as superchain deployment) + output := runner.ExpectSuccessWithNetwork(t, []string{ + "bootstrap", "implementations", + "--outfile", implsOutputFile, + "--mips-version", strconv.Itoa(int(standard.MIPSVersion)), + "--protocol-versions-proxy", superchainOutput.ProtocolVersionsProxy.Hex(), + "--superchain-config-proxy", superchainOutput.SuperchainConfigProxy.Hex(), + "--upgrade-controller", superchainProxyAdminOwner.Hex(), // Use proxy admin owner as upgrade controller + "--superchain-proxy-admin", superchainOutput.SuperchainProxyAdmin.Hex(), + "--challenger", challenger.Hex(), + }, nil) + + t.Logf("Bootstrap implementations output:\n%s", output) + + // Verify output file was created + require.FileExists(t, implsOutputFile) + + // Parse and validate the output + var implsOutput opcm.DeployImplementationsOutput + data, err = os.ReadFile(implsOutputFile) + require.NoError(t, err) + err = json.Unmarshal(data, &implsOutput) + require.NoError(t, err) + + // We only check specific addresses that are always set + require.NotEqual(t, common.Address{}, implsOutput.Opcm, "Opcm should be set") + require.NotEqual(t, common.Address{}, implsOutput.OpcmStandardValidator, "OpcmStandardValidator should be set") + require.NotEqual(t, common.Address{}, implsOutput.DelayedWETHImpl, "DelayedWETHImpl should be set") + require.NotEqual(t, common.Address{}, implsOutput.OptimismPortalImpl, "OptimismPortalImpl should be set") + require.NotEqual(t, common.Address{}, implsOutput.ETHLockboxImpl, "ETHLockboxImpl should be set") + require.NotEqual(t, common.Address{}, implsOutput.PreimageOracleSingleton, "PreimageOracleSingleton should be set") + require.NotEqual(t, common.Address{}, implsOutput.MipsSingleton, "MipsSingleton should be set") + require.NotEqual(t, common.Address{}, implsOutput.SystemConfigImpl, "SystemConfigImpl should be set") + require.NotEqual(t, common.Address{}, implsOutput.L1CrossDomainMessengerImpl, "L1CrossDomainMessengerImpl should be set") + require.NotEqual(t, common.Address{}, implsOutput.L1ERC721BridgeImpl, "L1ERC721BridgeImpl should be set") + require.NotEqual(t, common.Address{}, implsOutput.L1StandardBridgeImpl, "L1StandardBridgeImpl should be set") + require.NotEqual(t, common.Address{}, implsOutput.OptimismMintableERC20FactoryImpl, "OptimismMintableERC20FactoryImpl should be set") + require.NotEqual(t, common.Address{}, implsOutput.DisputeGameFactoryImpl, "DisputeGameFactoryImpl should be set") + require.NotEqual(t, common.Address{}, implsOutput.AnchorStateRegistryImpl, "AnchorStateRegistryImpl should be set") + require.NotEqual(t, common.Address{}, implsOutput.SuperchainConfigImpl, "SuperchainConfigImpl should be set") + require.NotEqual(t, common.Address{}, implsOutput.ProtocolVersionsImpl, "ProtocolVersionsImpl should be set") + }) + + t.Run("bootstrap proxy", func(t *testing.T) { + proxyOutputFile := filepath.Join(workDir, "bootstrap_proxy.json") + + // Run bootstrap proxy command + output := runner.ExpectSuccessWithNetwork(t, []string{ + "bootstrap", "proxy", + "--proxy-owner", superchainProxyAdminOwner.Hex(), + "--outfile", proxyOutputFile, + }, nil) + + t.Logf("Bootstrap proxy output:\n%s", output) + + // Verify output file was created + require.FileExists(t, proxyOutputFile) + + // Parse and validate the output + var proxyOutput opcm.DeployProxyOutput + data, err := os.ReadFile(proxyOutputFile) + require.NoError(t, err) + err = json.Unmarshal(data, &proxyOutput) + require.NoError(t, err) + require.NoError(t, addresses.CheckNoZeroAddresses(proxyOutput)) + }) + + t.Run("bootstrap with stdout output", func(t *testing.T) { + // Test that stdout output works (no --outfile flag) + output := runner.ExpectSuccessWithNetwork(t, []string{ + "bootstrap", "proxy", + "--proxy-owner", superchainProxyAdminOwner.Hex(), + "--outfile", "-", // stdout + }, nil) + + t.Logf("Bootstrap proxy (stdout) output:\n%s", output) + }) +} From 2d77b27e7b15c72f97b2b5030de961bee1fed696 Mon Sep 17 00:00:00 2001 From: Axel Kingsley Date: Thu, 9 Oct 2025 14:58:21 -0500 Subject: [PATCH 033/117] tests: Re-enable Interop Proof Acceptance Tests (#17770) * Re-enable Interop Proof Acceptance Tests * Flake Shake --- op-acceptance-tests/acceptance-tests.yaml | 10 ++++++++++ .../tests/interop/proofs/challenger_test.go | 1 - .../tests/interop/proofs/proposer_test.go | 1 - 3 files changed, 10 insertions(+), 2 deletions(-) diff --git a/op-acceptance-tests/acceptance-tests.yaml b/op-acceptance-tests/acceptance-tests.yaml index 97d0f078858..eb1043559b9 100644 --- a/op-acceptance-tests/acceptance-tests.yaml +++ b/op-acceptance-tests/acceptance-tests.yaml @@ -15,6 +15,16 @@ gates: - id: flake-shake description: "Quarantine gate for new and potentially flaky tests requiring stability validation." tests: + - package: github.com/ethereum-optimism/optimism/op-acceptance-tests/tests/interop/proofs + name: TestProposer + timeout: 10m + metadata: + owner: "axel,mofi" + - package: github.com/ethereum-optimism/optimism/op-acceptance-tests/tests/interop/proofs + name: TestChallengerPlaysGame + timeout: 10m + metadata: + owner: "axel,mofi" - package: github.com/ethereum-optimism/optimism/op-acceptance-tests/tests/sync_tester/sync_tester_hfs_ext name: TestSyncTesterHFS_Isthmus_ELSync timeout: 10m diff --git a/op-acceptance-tests/tests/interop/proofs/challenger_test.go b/op-acceptance-tests/tests/interop/proofs/challenger_test.go index 61a0fca513d..4d3bf8b21e8 100644 --- a/op-acceptance-tests/tests/interop/proofs/challenger_test.go +++ b/op-acceptance-tests/tests/interop/proofs/challenger_test.go @@ -15,7 +15,6 @@ import ( ) func TestChallengerPlaysGame(gt *testing.T) { - gt.Skip("Skipping Interop Acceptance Test") t := devtest.ParallelT(gt) sys := presets.NewSimpleInterop(t) dsl.CheckAll(t, diff --git a/op-acceptance-tests/tests/interop/proofs/proposer_test.go b/op-acceptance-tests/tests/interop/proofs/proposer_test.go index f56ae663597..da20c56ad97 100644 --- a/op-acceptance-tests/tests/interop/proofs/proposer_test.go +++ b/op-acceptance-tests/tests/interop/proofs/proposer_test.go @@ -8,7 +8,6 @@ import ( ) func TestProposer(gt *testing.T) { - gt.Skip("Skipping Interop Acceptance Test") t := devtest.SerialT(gt) sys := presets.NewSimpleInterop(t) From aa3728e79df0a0931ddd2c19ffd3e466b52a5012 Mon Sep 17 00:00:00 2001 From: opgitgovernance Date: Thu, 9 Oct 2025 23:46:40 +0200 Subject: [PATCH 034/117] chore(op-acceptance-tests): flake-shake; test promotions (#17804) --- op-acceptance-tests/acceptance-tests.yaml | 10 ---------- 1 file changed, 10 deletions(-) diff --git a/op-acceptance-tests/acceptance-tests.yaml b/op-acceptance-tests/acceptance-tests.yaml index eb1043559b9..c7cee95579d 100644 --- a/op-acceptance-tests/acceptance-tests.yaml +++ b/op-acceptance-tests/acceptance-tests.yaml @@ -30,16 +30,6 @@ gates: timeout: 10m metadata: owner: "changwan,anton" - - package: github.com/ethereum-optimism/optimism/op-acceptance-tests/tests/jovian - name: TestMinBaseFee - timeout: 10m - metadata: - owner: "george" - - package: github.com/ethereum-optimism/optimism/op-acceptance-tests/tests/base/withdrawal - name: TestWithdrawal - timeout: 10m - metadata: - owner: "stefano" - package: github.com/ethereum-optimism/optimism/op-acceptance-tests/tests/base name: TestDummyFlakyTest timeout: 10m From 0f7eac0717fe290f615f5716e869035856a66055 Mon Sep 17 00:00:00 2001 From: Ariel Diaz <65925295+aliersh@users.noreply.github.com> Date: Thu, 9 Oct 2025 18:07:27 -0400 Subject: [PATCH 035/117] feat(ai-eng): release v1.0.0 production-Ready Contracts Test Maintenance System (#17807) * refactor(ai-contracts-test): use CircleCI artifacts for test exclusion - replace log.jsonl with log.json and fetch via CircleCI API - add circleci-api-token context for artifact access - treat blocked status as success when PR exists - remove .env loading for CI-only execution - improve Devin setup logging to single message * fix(ai-eng): handle server errors and user-stopped sessions in devin client - handle 502 Bad Gateway errors as retryable (like 504) - add support for suspend_requested status when user stops session - fix AttributeError when status is None during blocked check - reduce resource_class from xlarge to large * fix(ai-eng): improve devin session monitoring and reduce noise - reduce timeout messages - remove "finished" status handling - clarify blocked status messages - handle expired status separately - reduce resource class from large to medium * fix(ai-eng): add debug logging and fix artifact parsing in test exclusion - add debug prints to trace CircleCI artifact fetching - fix artifact parsing: use selected_files.test_path instead of test_path * refactor(ai-contracts-test): integrate CircleCI API v2 for artifact-based test exclusion - implement CircleCI API v2 to fetch artifacts from previous runs - exclude test files processed in the last 2 weeks - extract helper functions following SRP - add debug logging for artifact fetching process * fix(ai-contracts-test): prevent crash when manually stopping devin sessions * chore(ai-contracts-test): release v1.0.0 with scheduled execution - add bi-weekly monday-thursday scheduled workflow trigger in CircleCI - update default branch from feature to develop for production use - enhance prompt guidance for test organization and source order matching --- .circleci/config.yml | 11 +- ops/ai-eng/contracts-test-maintenance/VERSION | 2 +- .../components/devin-api/devin_client.py | 73 +++++--- .../components/tests_ranker/test_ranker.py | 156 +++++++++++++++--- .../prompt/prompt.md | 15 +- 5 files changed, 203 insertions(+), 54 deletions(-) diff --git a/.circleci/config.yml b/.circleci/config.yml index 7996cc12167..83c3145cb50 100644 --- a/.circleci/config.yml +++ b/.circleci/config.yml @@ -999,7 +999,7 @@ jobs: circleci_ip_ranges: true docker: - image: <> - resource_class: xlarge + resource_class: medium steps: - checkout-from-workspace - run: @@ -1011,8 +1011,8 @@ jobs: working_directory: ops/ai-eng no_output_timeout: 60m - store_artifacts: - path: ops/ai-eng/contracts-test-maintenance/log.jsonl - destination: log.jsonl + path: ops/ai-eng/contracts-test-maintenance/log.json + destination: log.json - notify-failures-on-develop contracts-bedrock-coverage: @@ -3148,7 +3148,9 @@ workflows: ai-contracts-test-workflow: when: - equal: [true, << pipeline.parameters.ai_contracts_test_dispatch >>] + or: + - equal: [build_mon_thu, <>] + - equal: [true, << pipeline.parameters.ai_contracts_test_dispatch >>] jobs: - initialize: context: @@ -3156,6 +3158,7 @@ workflows: - ai-contracts-test: context: - circleci-repo-readonly-authenticated-github-token + - circleci-api-token - devin-api requires: - initialize diff --git a/ops/ai-eng/contracts-test-maintenance/VERSION b/ops/ai-eng/contracts-test-maintenance/VERSION index d15723fbe8d..3eefcb9dd5b 100644 --- a/ops/ai-eng/contracts-test-maintenance/VERSION +++ b/ops/ai-eng/contracts-test-maintenance/VERSION @@ -1 +1 @@ -0.3.2 +1.0.0 diff --git a/ops/ai-eng/contracts-test-maintenance/components/devin-api/devin_client.py b/ops/ai-eng/contracts-test-maintenance/components/devin-api/devin_client.py index d30a716b9b9..d35475a8010 100644 --- a/ops/ai-eng/contracts-test-maintenance/components/devin-api/devin_client.py +++ b/ops/ai-eng/contracts-test-maintenance/components/devin-api/devin_client.py @@ -12,14 +12,6 @@ import time import urllib.request -# Load .env file -if os.path.exists(".env"): - with open(".env") as f: - for line in f: - if "=" in line and not line.strip().startswith("#"): - key, value = line.strip().split("=", 1) - os.environ[key] = value.strip("\"'").strip() - def find_prompt_file(): """Find the latest generated prompt file from the prompt renderer output.""" @@ -41,9 +33,8 @@ def load_prompt_from_file(file_path): return f.read().strip() -def log_session(session_id, status, session_data): - """Log PR link and final status to JSONL file.""" - # Extract run_id and selected files from existing data +def write_log(session_id, status, session_data): + """Write log with full session information.""" try: prompt_file = find_prompt_file() run_id = os.path.basename(prompt_file).replace("_prompt.md", "") @@ -83,12 +74,13 @@ def log_session(session_id, status, session_data): # Only add PR link if status is finished if status == "finished" and session_data: - pr_url = session_data.get("pull_request", {}).get("url") + pr_data = session_data.get("pull_request") or {} + pr_url = pr_data.get("url") if pr_url: log_entry["pull_request_url"] = pr_url - with open("../../log.jsonl", "a") as f: - f.write(json.dumps(log_entry) + "\n") + with open("../../log.json", "w") as f: + json.dump(log_entry, f) def _make_request(url, headers, data=None, method="GET"): @@ -98,8 +90,8 @@ def _make_request(url, headers, data=None, method="GET"): with urllib.request.urlopen(req, timeout=30) as response: return json.loads(response.read().decode("utf-8")) except urllib.error.HTTPError as e: - if e.code == 504: - print(f"Server timeout (504) - will retry") + if e.code in [502, 504]: + print(f"Server error ({e.code}) - will retry") return None else: print(f"Request failed: {method} {url}") @@ -156,6 +148,8 @@ def monitor_session(session_id): headers = _create_headers(api_key) last_status = None retry_delay = 60 # Start with 1 minute + setup_printed = False + timeout_count = 0 while True: try: @@ -163,31 +157,62 @@ def monitor_session(session_id): # Handle server timeout (no response) - retry with backoff if status is None: - print(f"Retrying in {retry_delay} seconds...") + timeout_count += 1 + # Only print after 3rd consecutive timeout to reduce noise + if timeout_count >= 3: + print(f"API slow to respond, still monitoring session... (retry in {retry_delay}s)") time.sleep(retry_delay) retry_delay = min(retry_delay * 2, 480) # Cap at 8 minutes continue - # Reset retry delay on successful request + # Reset retry delay and timeout count on successful request retry_delay = 60 + if timeout_count > 0: + timeout_count = 0 + current_status = status.get("status_enum") # Handle Devin setup phase (status_enum is None but we got a response) if current_status is None: - print("Devin is setting up...") + if not setup_printed: + print("Devin is setting up...") + setup_printed = True time.sleep(5) continue + # Print setup completion message once + if setup_printed and current_status: + print("Devin finished setup") + setup_printed = False + # Only print when status changes and is meaningful if current_status and current_status != last_status: print(f"Status: {current_status}") last_status = current_status - # Stop monitoring for non-working statuses - if current_status in ["blocked", "expired", "finished"]: - print(f"Session finished with status: {current_status}") - log_session(session_id, current_status, status) - return + # Stop monitoring for terminal statuses (only if we have valid status data) + if status and current_status in ["blocked", "expired", "suspend_requested", "suspend_requested_frontend"]: + # Handle user stopping the session + if current_status in ["suspend_requested", "suspend_requested_frontend"]: + print("Session stopped by user") + return + + # Blocked = PR created successfully (can't auto-merge due to review policy) + if current_status == "blocked": + pr_data = status.get("pull_request") or {} + if pr_data.get("url"): + print("Session completed successfully - PR created") + write_log(session_id, "finished", status) + else: + print(f"Session blocked without PR - check Devin web interface") + write_log(session_id, "blocked", status) + return + + # Expired = session timed out + if current_status == "expired": + print(f"Session expired") + write_log(session_id, "expired", status) + return time.sleep(5) except KeyboardInterrupt: diff --git a/ops/ai-eng/contracts-test-maintenance/components/tests_ranker/test_ranker.py b/ops/ai-eng/contracts-test-maintenance/components/tests_ranker/test_ranker.py index 0698f816ea7..057d49039fe 100644 --- a/ops/ai-eng/contracts-test-maintenance/components/tests_ranker/test_ranker.py +++ b/ops/ai-eng/contracts-test-maintenance/components/tests_ranker/test_ranker.py @@ -7,11 +7,14 @@ from datetime import datetime, timezone import json +import os from pathlib import Path import subprocess import time import tomllib from typing import Optional +import urllib.request +import urllib.error # === Git Utilities === @@ -148,6 +151,134 @@ def find_source_contract( # === Exclusion Utilities === +def _get_test_path_from_artifact(artifact_url: str, headers: dict) -> Optional[str]: + """Download and parse log.json artifact to extract test path.""" + try: + req = urllib.request.Request(artifact_url, headers=headers) + with urllib.request.urlopen(req, timeout=10) as response: + data = json.loads(response.read().decode()) + return data.get("selected_files", {}).get("test_path") + except (urllib.error.URLError, json.JSONDecodeError, KeyError): + return None + + +def _get_job_artifacts(project_slug: str, job_number: int, headers: dict) -> list[dict]: + """Get artifacts list for a specific job.""" + try: + artifacts_url = f"https://circleci.com/api/v2/project/{project_slug}/{job_number}/artifacts" + req = urllib.request.Request(artifacts_url, headers=headers) + with urllib.request.urlopen(req, timeout=10) as response: + return json.loads(response.read().decode()).get("items", []) + except urllib.error.HTTPError as e: + print(f"Error fetching artifacts (job {job_number}): {e.code} {e.reason}") + print(f"Tried URL: {artifacts_url}") + return [] + + +def _get_successful_job_number(workflow_id: str, headers: dict) -> Optional[int]: + """Get job number for successful ai-contracts-test job in a workflow.""" + try: + jobs_url = f"https://circleci.com/api/v2/workflow/{workflow_id}/job" + req = urllib.request.Request(jobs_url, headers=headers) + with urllib.request.urlopen(req, timeout=10) as response: + jobs_data = json.loads(response.read().decode()) + + for job in jobs_data.get("items", []): + if job.get("name") == "ai-contracts-test" and job.get("status") == "success": + return job["job_number"] + return None + except urllib.error.HTTPError as e: + print(f"Error fetching jobs (workflow {workflow_id}): {e.code} {e.reason}") + return None + + +def _get_workflow_id(pipeline_id: str, headers: dict) -> Optional[str]: + """Get workflow ID from pipeline if successful.""" + try: + workflows_url = f"https://circleci.com/api/v2/pipeline/{pipeline_id}/workflow" + req = urllib.request.Request(workflows_url, headers=headers) + with urllib.request.urlopen(req, timeout=10) as response: + workflows_data = json.loads(response.read().decode()) + + workflows = workflows_data.get("items", []) + if workflows and workflows[0].get("status") == "success": + return workflows[0]["id"] + return None + except urllib.error.HTTPError as e: + print(f"Error fetching workflow (pipeline {pipeline_id}): {e.code} {e.reason}") + return None + + +def fetch_last_processed_from_circleci() -> list[Path]: + """Fetch recently processed test files from CircleCI artifacts. + + Returns: + List of test file paths from the last 3 successful runs. + """ + circleci_token = os.getenv("CIRCLE_API_TOKEN") + if not circleci_token: + print("CIRCLE_API_TOKEN not found - skipping artifact check") + return [] + + print("Checking CircleCI for previous run artifacts...") + excluded_paths = [] + + try: + headers = {"Circle-Token": circleci_token} + project_slug = "gh/ethereum-optimism/optimism" + branch = os.getenv("CIRCLE_BRANCH", "develop") + two_weeks_ago = time.time() - (14 * 24 * 3600) + + # Get recent pipelines + pipelines_url = f"https://circleci.com/api/v2/project/{project_slug}/pipeline?branch={branch}" + req = urllib.request.Request(pipelines_url, headers=headers) + with urllib.request.urlopen(req, timeout=10) as response: + pipelines = json.loads(response.read().decode()).get("items", []) + + if not pipelines: + print("No previous pipelines found") + return [] + + # Process recent pipelines (within 2 weeks) + from datetime import datetime as dt + for pipeline in pipelines: + # Check age + if pipeline.get("created_at"): + pipeline_time = dt.fromisoformat(pipeline["created_at"].replace("Z", "+00:00")).timestamp() + if pipeline_time < two_weeks_ago: + print(f"Reached pipelines older than 2 weeks, stopping search") + break + + # Get workflow → job → artifacts → test path + workflow_id = _get_workflow_id(pipeline["id"], headers) + if not workflow_id: + continue + + job_number = _get_successful_job_number(workflow_id, headers) + if not job_number: + continue + + artifacts = _get_job_artifacts(project_slug, job_number, headers) + for artifact in artifacts: + if artifact["path"].endswith("log.json"): + test_path = _get_test_path_from_artifact(artifact["url"], headers) + if test_path: + print(f"Excluding recently processed file: {test_path}") + excluded_paths.append(Path(test_path)) + break + + if excluded_paths: + print(f"Excluded {len(excluded_paths)} recently processed file(s)") + else: + print("No recent successful runs found") + + return excluded_paths + + except (urllib.error.URLError, json.JSONDecodeError, ValueError, KeyError) as e: + print(f"Could not fetch CircleCI artifacts: {e}") + return [] + + def load_exclusions(contracts_bedrock: Path) -> tuple[list[Path], set[Path]]: """Load and normalize exclusion paths from TOML configuration. @@ -184,27 +315,10 @@ def load_exclusions(contracts_bedrock: Path) -> tuple[list[Path], set[Path]]: # File exclusion - store as Path object in set for O(1) lookup excluded_files.add(Path(file_path)) - # Add recently processed files from log.jsonl (avoid immediate duplicates) - log_file = Path(__file__).parent.parent.parent / "log.jsonl" - if log_file.exists(): - cutoff = time.time() - (7 * 24 * 3600) # 7 days - try: - with open(log_file) as f: - for line in f: - entry = json.loads(line.strip()) - if ( - entry.get("status") in ["finished", "blocked", "failed"] - and entry.get("run_time") - and datetime.strptime( - entry["run_time"], "%Y-%m-%d %H:%M:%S" - ).timestamp() - > cutoff - ): - test_path = entry.get("selected_files", {}).get("test_path") - if test_path: - excluded_files.add(Path(test_path)) - except (json.JSONDecodeError, ValueError, KeyError): - pass + # Add recently processed files from CircleCI artifacts (avoid immediate duplicates) + last_processed_files = fetch_last_processed_from_circleci() + for test_file in last_processed_files: + excluded_files.add(test_file) return excluded_dirs, excluded_files diff --git a/ops/ai-eng/contracts-test-maintenance/prompt/prompt.md b/ops/ai-eng/contracts-test-maintenance/prompt/prompt.md index d039b93a989..a18a13581ae 100644 --- a/ops/ai-eng/contracts-test-maintenance/prompt/prompt.md +++ b/ops/ai-eng/contracts-test-maintenance/prompt/prompt.md @@ -90,6 +90,7 @@ This systematic approach ensures comprehensive test improvements without missing **Phase 4 - Organization & Finalization** *Goal: Clean structure that matches source code* +- Reorganize test contracts to match source function declaration order - Verify zero semgrep violations and compiler warnings - Final validation to ensure all tests pass @@ -119,6 +120,7 @@ This systematic approach ensures comprehensive test improvements without missing - Format: `[method]_[functionName]_[scenario]_[outcome]` - Methods: `test`, `testFuzz`, `testDiff` - Outcomes: `succeeds`, `reverts`, `fails` (never `works`) + - Scenarios: Keep concise (e.g., `expired` not `expiredPause`) - ALL parameters use underscore prefix: `_param` - Read-only tests MUST have `view` modifier @@ -152,8 +154,12 @@ Uncategorized_Test Contract: Ask yourself: "What is the PRIMARY behavior I'm testing?" The answer determines the categorization. -**Expected Structure:** -Helper contracts → TestInit → function tests (in source order) → Uncategorized_Test last +**Final Organization Structure:** +1. After all tests are implemented and passing +2. Map all functions from source contract in declaration order +3. Reorganize ALL test contracts to match this order +4. Structure: Helper contracts → TestInit → function tests (in source order) → Uncategorized last +5. NEVER delete existing tests - only enhance, rename, or reorganize CRITICAL: Organization happens LAST, after all improvements are complete @@ -477,8 +483,9 @@ contract Storage_Uncategorized_Test is Storage_TestInit { - Replace with `vm.expectRevert(ErrorName.selector)` or `vm.expectRevert(bytes("message"))` *Organization confusion:* -- Expected order: Helper contracts at top, Uncategorized last -- Function tests should follow source contract declaration order +- Read source contract function order first +- Move test contracts to match that exact order +- Keep helper contracts at top, Uncategorized last *Fuzz test failures:* - Check if constraints properly bound the values From 59b39f18b47ab4bb9bad76c8220c602d2935cfa6 Mon Sep 17 00:00:00 2001 From: Stefano Charissis Date: Fri, 10 Oct 2025 13:14:27 +1100 Subject: [PATCH 036/117] feat(op-acceptance-tests): flake-shake; fixes and improvements (#17811) * fix(op-acceptance-tests): flake-shake; artifacts URL. * fix(op-acceptance-tests): flake-shake; test URL. * fix(op-acceptance-tests): flake-shake; close old/stale PRs. * fix(op-acceptance-tests): flake-shake; updated flake-shake gate. * fix(op-acceptance-tests): flake-shake; upload logs. * fix(op-acceptance-tests): flake-shake; convert JSON logs to plaintext. * fix(op-acceptance-tests): flake-shake; use CircleCI static egress IPs. * clean(op-acceptance-tests): flake-shake; removed dummy test. --- .circleci/config.yml | 14 ++- op-acceptance-tests/acceptance-tests.yaml | 10 +- .../cmd/flake-shake-aggregator/main.go | 22 ++++- .../cmd/flake-shake-promoter/main.go | 99 ++++++++++++++----- .../scripts/ci_flake_shake_prepare_slack.sh | 10 +- .../tests/base/dummy_flaky_test.go | 27 ----- 6 files changed, 120 insertions(+), 62 deletions(-) delete mode 100644 op-acceptance-tests/tests/base/dummy_flaky_test.go diff --git a/.circleci/config.yml b/.circleci/config.yml index 83c3145cb50..33ee45f087e 100644 --- a/.circleci/config.yml +++ b/.circleci/config.yml @@ -1639,6 +1639,7 @@ jobs: machine: image: ubuntu-2404:current resource_class: large + circleci_ip_ranges: true parallelism: << pipeline.parameters.flake-shake-workers >> steps: - checkout-from-workspace @@ -1679,7 +1680,7 @@ jobs: paths: - logs/flake-shake-results-worker-*/ - store_artifacts: - path: ./op-acceptance-tests/logs/flake-shake-results-worker-* + path: ./op-acceptance-tests/logs destination: flake-shake-workers op-acceptance-tests-flake-shake-report: @@ -1713,6 +1714,17 @@ jobs: name: Generate summary command: | bash ./op-acceptance-tests/scripts/ci_flake_shake_generate_summary.sh final-report/flake-shake-report.json final-report + - run: + name: Bundle consolidated flake-shake worker logs + command: | + set -euo pipefail + # Create a single tarball with all worker logs, if any exist in the workspace + if compgen -G "op-acceptance-tests/logs/flake-shake-results-worker-*" > /dev/null; then + tar -czf final-report/flake-shake-workers-logs.tar.gz op-acceptance-tests/logs/flake-shake-results-worker-* + echo "Created final-report/flake-shake-workers-logs.tar.gz" + else + echo "No worker log directories found to bundle" + fi - store_artifacts: path: ./final-report destination: flake-shake-report diff --git a/op-acceptance-tests/acceptance-tests.yaml b/op-acceptance-tests/acceptance-tests.yaml index c7cee95579d..d11fc24f4b4 100644 --- a/op-acceptance-tests/acceptance-tests.yaml +++ b/op-acceptance-tests/acceptance-tests.yaml @@ -15,12 +15,12 @@ gates: - id: flake-shake description: "Quarantine gate for new and potentially flaky tests requiring stability validation." tests: - - package: github.com/ethereum-optimism/optimism/op-acceptance-tests/tests/interop/proofs + - package: github.com/ethereum-optimism/optimism/op-acceptance-tests/tests/interop/proofs name: TestProposer timeout: 10m metadata: owner: "axel,mofi" - - package: github.com/ethereum-optimism/optimism/op-acceptance-tests/tests/interop/proofs + - package: github.com/ethereum-optimism/optimism/op-acceptance-tests/tests/interop/proofs name: TestChallengerPlaysGame timeout: 10m metadata: @@ -30,12 +30,8 @@ gates: timeout: 10m metadata: owner: "changwan,anton" - - package: github.com/ethereum-optimism/optimism/op-acceptance-tests/tests/base - name: TestDummyFlakyTest - timeout: 10m - metadata: - owner: "stefano" - package: github.com/ethereum-optimism/optimism/op-acceptance-tests/tests/osaka + timeout: 15m owner: "josh" - id: isthmus diff --git a/op-acceptance-tests/cmd/flake-shake-aggregator/main.go b/op-acceptance-tests/cmd/flake-shake-aggregator/main.go index 98f5861a68b..5f7ad50b672 100644 --- a/op-acceptance-tests/cmd/flake-shake-aggregator/main.go +++ b/op-acceptance-tests/cmd/flake-shake-aggregator/main.go @@ -462,6 +462,7 @@ func generateHTMLReport(report *FlakeShakeReport) string { `) normalizer := regexp.MustCompile(`(?m)^\s*\[?\d{4}-\d{2}-\d{2}.*$|\bt=\d{4}-\d{2}-\d{2}.*$|\b(duration|elapsed|took)[:=].*$`) + ansiStrip := regexp.MustCompile("\x1b\\[[0-9;]*m") classify := func(s string) string { ls := strings.ToLower(s) switch { @@ -497,8 +498,27 @@ func generateHTMLReport(report *FlakeShakeReport) string { }{} typeSummary := map[string]int{} for _, raw := range test.FailureLogs { - norm := normalizer.ReplaceAllString(raw, "") + // Extract human-readable content from Go test JSON events by keeping only non-empty Output fields. + processed := strings.TrimSpace(raw) + if strings.HasPrefix(processed, "{") { + var ev struct { + Output string `json:"Output"` + } + if json.Unmarshal([]byte(processed), &ev) == nil { + processed = strings.TrimSpace(ev.Output) + } + } + if processed == "" { + continue + } + // Strip ANSI color codes for readability + processed = ansiStrip.ReplaceAllString(processed, "") + // Normalize noisy timestamps/durations and trim + norm := normalizer.ReplaceAllString(processed, "") norm = strings.TrimSpace(norm) + if norm == "" { + continue + } sum := sha256.Sum256([]byte(norm)) key := fmt.Sprintf("%x", sum[:]) g := groups[key] diff --git a/op-acceptance-tests/cmd/flake-shake-promoter/main.go b/op-acceptance-tests/cmd/flake-shake-promoter/main.go index 7d7d98315f8..b3616c54afc 100644 --- a/op-acceptance-tests/cmd/flake-shake-promoter/main.go +++ b/op-acceptance-tests/cmd/flake-shake-promoter/main.go @@ -24,6 +24,18 @@ import ( var logger *log.Logger +// Constants used across the promoter +const ( + flakeShakeGateID = "flake-shake" + flakeShakeWorkflowName = "scheduled-flake-shake" + flakeShakeReportJobName = "op-acceptance-tests-flake-shake-report" + flakeShakePRTitle = "chore(op-acceptance-tests): flake-shake; test promotions" + flakeShakePRBranchPrefix = "ci/flake-shake-promote/" + flakeShakeLabel = "M-ci" + flakeShakeBotAuthor = "opgitgovernance" + flakeShakeSupersedeDays = 2 +) + // CircleCI API models type pipelineList struct { Items []pipeline `json:"items"` @@ -33,6 +45,7 @@ type pipelineList struct { type pipeline struct { ID string `json:"id"` CreatedAt time.Time `json:"created_at"` + Number int `json:"number"` } type workflowList struct { @@ -262,10 +275,10 @@ func main() { // Prepare updated YAML content for PR by editing only the flake-shake gate in-place to preserve comments var updatedYAMLBytes []byte - prBranch := fmt.Sprintf("ci/flake-shake-promote/%s", time.Now().UTC().Format("2006-01-02-150405")) + prBranch := fmt.Sprintf("%s%s", flakeShakePRBranchPrefix, time.Now().UTC().Format("2006-01-02-150405")) // Prepare commit message and PR body - title := "chore(op-acceptance-tests): flake-shake; test promotions" + title := flakeShakePRTitle var body bytes.Buffer body.WriteString("## 🤖 Automated Flake-Shake Test Promotion\n\n") @@ -391,7 +404,7 @@ func main() { } // 6) Add labels - if _, _, err := ghc.Issues.AddLabelsToIssue(ghCtx, opts.org, opts.repo, pr.GetNumber(), []string{"M-ci", "A-acceptance-tests"}); err != nil { + if _, _, err := ghc.Issues.AddLabelsToIssue(ghCtx, opts.org, opts.repo, pr.GetNumber(), []string{flakeShakeLabel, "A-acceptance-tests"}); err != nil { fmt.Fprintf(os.Stderr, "failed to add labels: %v\n", err) } @@ -402,6 +415,11 @@ func main() { }); err != nil { fmt.Fprintf(os.Stderr, "failed to request reviewers: %v\n", err) } + + // 8) Close any older open flake-shake PRs by this bot as superseded + if err := closeSupersededFlakeShakePRs(ghCtx, ghc, opts.org, opts.repo, pr, title, opts.verbose); err != nil { + fmt.Fprintf(os.Stderr, "warning: failed to close superseded PRs: %v\n", err) + } } // promoterOpts holds command-line options for the promoter tool. @@ -427,10 +445,10 @@ func parsePromoterFlags() promoterOpts { flag.StringVar(&opts.org, "org", "ethereum-optimism", "GitHub org") flag.StringVar(&opts.repo, "repo", "optimism", "GitHub repo") flag.StringVar(&opts.branch, "branch", "develop", "Branch to scan") - flag.StringVar(&opts.workflowName, "workflow", "scheduled-flake-shake", "Workflow name") - flag.StringVar(&opts.reportJobName, "report-job", "op-acceptance-tests-flake-shake-report", "Report job name") + flag.StringVar(&opts.workflowName, "workflow", flakeShakeWorkflowName, "Workflow name") + flag.StringVar(&opts.reportJobName, "report-job", flakeShakeReportJobName, "Report job name") flag.IntVar(&opts.daysBack, "days", 3, "Number of days to aggregate") - flag.StringVar(&opts.gateID, "gate", "flake-shake", "Gate id in acceptance-tests.yaml") + flag.StringVar(&opts.gateID, "gate", flakeShakeGateID, "Gate id in acceptance-tests.yaml") flag.IntVar(&opts.minRuns, "min-runs", 300, "Minimum total runs required") flag.Float64Var(&opts.maxFailureRate, "max-failure-rate", 0.01, "Maximum allowed failure rate") flag.IntVar(&opts.minAgeDays, "min-age-days", 2, "Minimum age in days in flake-shake") @@ -864,6 +882,51 @@ func listJobs(ctx *apiCtx, workflowID string) (jobList, error) { return jl, nil } +// closeSupersededFlakeShakePRs finds any open flake-shake promotion PRs created by the bot +// and closes them with a comment pointing to the newly created PR. +func closeSupersededFlakeShakePRs(ctx context.Context, ghc *github.Client, org, repo string, newPR *github.PullRequest, title string, verbose bool) error { + // Search open PRs in this repo that match our title and bot author + // Using Issues.ListByRepo with filters + opt := &github.IssueListByRepoOptions{ + State: "open", + Labels: []string{flakeShakeLabel}, + Since: time.Now().AddDate(0, 0, -flakeShakeSupersedeDays), + ListOptions: github.ListOptions{PerPage: 50}, + } + for { + issues, resp, err := ghc.Issues.ListByRepo(ctx, org, repo, opt) + if err != nil { + return err + } + for _, is := range issues { + if is.IsPullRequest() && is.GetNumber() != newPR.GetNumber() { + // Check title contains our flake-shake marker; be robust to minor variations + // Use the provided title to derive a stable prefix (before the first ';') for matching + titlePrefix := strings.TrimSpace(strings.TrimSuffix(title, "; test promotions")) + if strings.Contains(strings.ToLower(is.GetTitle()), strings.ToLower(flakeShakeGateID)) && strings.Contains(is.GetTitle(), titlePrefix) { + // Author check + if is.User != nil && is.User.GetLogin() != flakeShakeBotAuthor { + continue + } + // Comment and close + msg := fmt.Sprintf("superseded by #%d", newPR.GetNumber()) + _, _, _ = ghc.Issues.CreateComment(ctx, org, repo, is.GetNumber(), &github.IssueComment{Body: github.String(msg)}) + state := "closed" + _, _, _ = ghc.PullRequests.Edit(ctx, org, repo, is.GetNumber(), &github.PullRequest{State: &state}) + if verbose { + logger.Printf("Closed superseded PR #%d: %s", is.GetNumber(), is.GetTitle()) + } + } + } + } + if resp.NextPage == 0 { + break + } + opt.Page = resp.NextPage + } + return nil +} + // resolveReportArtifactsURL attempts to find the web URL to the report job's artifacts page // by scanning recent pipelines/workflows for the configured workflow/report job names. // Returns an empty string if not found. @@ -898,26 +961,12 @@ func resolveReportArtifactsURL(opts promoterOpts, ctx *apiCtx) string { if j.Name != opts.reportJobName { continue } - if j.WebURL != "" { - url := j.WebURL - if !strings.Contains(url, "/artifacts") { - if strings.HasSuffix(url, "/") { - url = url + "artifacts" - } else { - url = url + "/artifacts" - } - } - return url - } - // Fallback: build URL from job number if web_url missing - if j.JobNumber != 0 { - url := fmt.Sprintf("https://app.circleci.com/pipelines/github/%s/%s?branch=%s", opts.org, opts.repo, url.QueryEscape(opts.branch)) - _ = url // keep for future; better to use job-specific URL - // More specific URL pattern commonly used in UI includes workflow id; not available here. - // As a fallback, return the legacy build URL on circleci.com if org/repo/job present. - legacy := fmt.Sprintf("https://circleci.com/gh/%s/%s/%d", opts.org, opts.repo, j.JobNumber) - return legacy + "/artifacts" + // Prefer constructing the app.circleci.com artifacts URL from pipeline number + workflow id + job number + if p.Number != 0 && j.JobNumber != 0 { + u := fmt.Sprintf("https://app.circleci.com/pipelines/github/%s/%s/%d/workflows/%s/jobs/%d/artifacts", opts.org, opts.repo, p.Number, w.ID, j.JobNumber) + return u } + return "" } } } diff --git a/op-acceptance-tests/scripts/ci_flake_shake_prepare_slack.sh b/op-acceptance-tests/scripts/ci_flake_shake_prepare_slack.sh index b05bcb1b6fd..13ee110642a 100644 --- a/op-acceptance-tests/scripts/ci_flake_shake_prepare_slack.sh +++ b/op-acceptance-tests/scripts/ci_flake_shake_prepare_slack.sh @@ -58,11 +58,19 @@ if [ -f "$PROMO_JSON" ]; then fi # Build Block Kit blocks (header + link + divider + per-candidate sections) + # See: https://docs.slack.dev/block-kit SLACK_BLOCKS=$(jq -c \ --arg url "${REPORT_ARTIFACTS_URL}" \ --slurpfile meta "${PROMO_JSON%/*}/metadata.json" ' def name_or_pkg(t): (if ((t.test_name|tostring)|length) == 0 then "(package)" else t.test_name end); def owner_or_unknown(t): (if ((t.owner|tostring)|length) == 0 then "unknown" else t.owner end); + def pkg_link(t): ( + (t.package|tostring) as $p | + (if ($p|test("^github\\.com/ethereum-optimism/optimism/")) then + ("https://github.com/ethereum-optimism/optimism/tree/develop/" + ($p | sub("^github\\.com/ethereum-optimism/optimism/"; ""))) + else "" end) as $u | + (if $u != "" then ("<" + $u + "|" + $p + ">") else $p end) + ); def testblocks(t): [ {"type":"section","fields":[ {"type":"mrkdwn","text":"*Test:*\n\(name_or_pkg(t))"}, @@ -72,7 +80,7 @@ if [ -f "$PROMO_JSON" ]; then {"type":"mrkdwn","text":"*Runs:*\n\(t.total_runs)"}, {"type":"mrkdwn","text":"*Pass Rate:*\n\((t.pass_rate|tostring))%"} ]}, - {"type":"context","elements":[{"type":"mrkdwn","text": t.package }]}, + {"type":"context","elements":[{"type":"mrkdwn","text": pkg_link(t) }]}, {"type":"divider"} ]; . as $root | diff --git a/op-acceptance-tests/tests/base/dummy_flaky_test.go b/op-acceptance-tests/tests/base/dummy_flaky_test.go deleted file mode 100644 index ab703a457c3..00000000000 --- a/op-acceptance-tests/tests/base/dummy_flaky_test.go +++ /dev/null @@ -1,27 +0,0 @@ -package base - -import ( - "math/rand" - "testing" - - "github.com/ethereum-optimism/optimism/op-devstack/devtest" -) - -var dummyLogs = []string{ - "rpc error: code = DeadlineExceeded desc = context deadline exceeded while waiting for L2 block", - "assertion failed: expected balance to increase after funding, but it did not", - "unexpected revert: contract call failed with error 'insufficient funds for gas * price + value'", -} - -// This test only exists to be flaky, and is used to test the flake-shake system. -func TestDummyFlakyTest(gt *testing.T) { - t := devtest.SerialT(gt) - - t.Log("This test is flaky to test the flake-shake system") - - if rand.Float64() < 0.05 { - // provide a dummy log, from a pool of three messages - t.Log(dummyLogs[rand.Intn(len(dummyLogs))]) - t.Fail() - } -} From c1d1f158ac660ed04819a268c0996db8aa66b083 Mon Sep 17 00:00:00 2001 From: George Knee Date: Fri, 10 Oct 2025 11:30:35 +0100 Subject: [PATCH 037/117] op-node: allow for L2 chain configs to be passed to NewL1ChainConfig (#17799) * do not error if l1 chain config has no BlobScheduleConfig, if it is an optimism config * op-node: allow for L2 chain configs to be passed to NewL1ChainConfig This should fix the problem where L3 nodes cannot start. Closes https://github.com/ethereum-optimism/optimism/issues/17798 * typos --- op-node/service.go | 3 ++- op-node/service_l1_chain_config_test.go | 18 ++++++++++++++++++ 2 files changed, 20 insertions(+), 1 deletion(-) diff --git a/op-node/service.go b/op-node/service.go index ba002bb81aa..991dad785e7 100644 --- a/op-node/service.go +++ b/op-node/service.go @@ -318,7 +318,8 @@ func NewL1ChainConfig(chainId *big.Int, ctx cliiface.Context, log log.Logger) (* if cf.ChainID.Cmp(chainId) != 0 { return nil, fmt.Errorf("l1 chain config chain ID mismatch: %v != %v", cf.ChainID, chainId) } - if cf.BlobScheduleConfig == nil { + if !cf.IsOptimism() && cf.BlobScheduleConfig == nil { + // No error if the chain config is an OP-Stack chain and doesn't have a blob schedule config return nil, fmt.Errorf("L1 chain config does not have a blob schedule config") } return cf, nil diff --git a/op-node/service_l1_chain_config_test.go b/op-node/service_l1_chain_config_test.go index 27e8d668324..e02ddfdff6e 100644 --- a/op-node/service_l1_chain_config_test.go +++ b/op-node/service_l1_chain_config_test.go @@ -50,6 +50,14 @@ func TestNewL1ChainConfig_CustomDirectAndEmbeddedAndNil(t *testing.T) { BlobScheduleConfig: nil, } + // Indicative of an L2 chain config + // Which is what L3 chains need to provide + customOPStack := ¶ms.ChainConfig{ + ChainID: testChainID, + BlobScheduleConfig: nil, + Optimism: ¶ms.OptimismConfig{}, + } + // Prepare temp dir dir := t.TempDir() @@ -76,6 +84,10 @@ func TestNewL1ChainConfig_CustomDirectAndEmbeddedAndNil(t *testing.T) { } encode(embeddedPath, wrapper{Config: custom}) + // Embedded JSON file that contains { "config": } + customOPStackPath := filepath.Join(dir, "optimism_chain.json") + encode(customOPStackPath, wrapper{Config: customOPStack}) + // Helper to run the CLI with a given file path runWithPath := func(path string) (*params.ChainConfig, error) { app := cli.NewApp() @@ -118,4 +130,10 @@ func TestNewL1ChainConfig_CustomDirectAndEmbeddedAndNil(t *testing.T) { require.Nil(t, cfg) require.Error(t, err) }) + + t.Run("nil-blob-schedule-config-returns-no-error-for-l2-chain-config", func(t *testing.T) { + cfg, err := runWithPath(customOPStackPath) + require.NotNil(t, cfg) + require.NoError(t, err) + }) } From d92bf308d362b361169694188fe2eada2058b04a Mon Sep 17 00:00:00 2001 From: Changwan Park Date: Fri, 10 Oct 2025 19:31:18 +0900 Subject: [PATCH 038/117] op-devstack: Error handle when direct FCU call errored (#17816) * op-acceptance-tests: Error handle when direct FCU call errored * op-devstack: Track target node when Engine API invoked --- op-devstack/dsl/engine.go | 7 +++++++ op-devstack/dsl/l2_el.go | 4 ++-- 2 files changed, 9 insertions(+), 2 deletions(-) diff --git a/op-devstack/dsl/engine.go b/op-devstack/dsl/engine.go index b01659e7b6c..e483224cf86 100644 --- a/op-devstack/dsl/engine.go +++ b/op-devstack/dsl/engine.go @@ -2,6 +2,7 @@ package dsl import ( "errors" + "fmt" "time" "github.com/ethereum-optimism/optimism/op-devstack/devtest" @@ -64,6 +65,12 @@ func (r *ForkchoiceUpdateResult) WaitUntilValid(attempts int) *ForkchoiceUpdateR func() error { r.Refresh() tryCnt += 1 + if r.Err != nil { + return fmt.Errorf("forkchoice returned error: %w", r.Err) + } + if r.Result == nil { + return errors.New("forkchoice has empty result") + } if r.Result.PayloadStatus.Status != eth.ExecutionValid { r.T.Log("Wait for FCU to return valid", "status", r.Result.PayloadStatus.Status, "try_count", tryCnt) return errors.New("still syncing") diff --git a/op-devstack/dsl/l2_el.go b/op-devstack/dsl/l2_el.go index 5d72ad4328b..52c225f1fd7 100644 --- a/op-devstack/dsl/l2_el.go +++ b/op-devstack/dsl/l2_el.go @@ -230,7 +230,7 @@ func (el *L2ELNode) PayloadByNumber(number uint64) *eth.ExecutionPayloadEnvelope // NewPayload fetches payload for target number from the reference EL Node, and inserts the payload func (el *L2ELNode) NewPayload(refNode *L2ELNode, number uint64) *NewPayloadResult { - el.log.Info("NewPayload", "number", number, "refNode", refNode) + el.log.Info("NewPayload", "number", number, "node", el, "refNode", refNode) payload := refNode.PayloadByNumber(number) status, err := el.inner.L2EngineClient().NewPayload(el.ctx, payload.ExecutionPayload, payload.ParentBeaconBlockRoot) return &NewPayloadResult{T: el.t, Status: status, Err: err} @@ -240,7 +240,7 @@ func (el *L2ELNode) NewPayload(refNode *L2ELNode, number uint64) *NewPayloadResu func (el *L2ELNode) ForkchoiceUpdate(refNode *L2ELNode, unsafe, safe, finalized uint64, attr *eth.PayloadAttributes) *ForkchoiceUpdateResult { result := &ForkchoiceUpdateResult{T: el.t} refresh := func() { - el.log.Info("ForkchoiceUpdate", "unsafe", unsafe, "safe", safe, "finalized", finalized, "attr", attr, "refNode", refNode) + el.log.Info("ForkchoiceUpdate", "unsafe", unsafe, "safe", safe, "finalized", finalized, "attr", attr, "node", el, "refNode", refNode) state := ð.ForkchoiceState{ HeadBlockHash: refNode.BlockRefByNumber(unsafe).Hash, SafeBlockHash: refNode.BlockRefByNumber(safe).Hash, From dc558e75e28ac1f37059cdc0eb60a1a78a0fe7a0 Mon Sep 17 00:00:00 2001 From: Maurelian Date: Fri, 10 Oct 2025 09:13:47 -0400 Subject: [PATCH 039/117] Add SaferSafes as child of the module and guard (#17767) * Add SaferSafes as child of the module and guard * Add ISaferSafes * Test comment and assertion fixes * Improve comments * Make LivenessModule2 and TimelockGuard abstract Move semver to SaferSafes semver lock * fix test contract name --- .../interfaces/safe/ILivenessModule2.sol | 4 +- .../interfaces/safe/ISaferSafes.sol | 164 ++++++++++ .../interfaces/safe/ITimelockGuard.sol | 1 - .../scripts/deploy/DeployOwnership.s.sol | 7 +- .../snapshots/abi/LivenessModule2.json | 286 ------------------ .../{TimelockGuard.json => SaferSafes.json} | 276 +++++++++++++++++ .../snapshots/semver-lock.json | 10 +- .../{LivenessModule2.json => SaferSafes.json} | 7 + .../storageLayout/TimelockGuard.json | 9 - .../src/safe/LivenessModule2.sol | 16 +- .../contracts-bedrock/src/safe/SaferSafes.sol | 63 ++++ .../src/safe/TimelockGuard.sol | 16 +- .../test/safe/LivenessModule2.t.sol | 7 +- .../test/safe/SaferSafes.t.sol | 146 +++++++++ .../test/safe/TimelockGuard.t.sol | 7 +- 15 files changed, 689 insertions(+), 330 deletions(-) create mode 100644 packages/contracts-bedrock/interfaces/safe/ISaferSafes.sol delete mode 100644 packages/contracts-bedrock/snapshots/abi/LivenessModule2.json rename packages/contracts-bedrock/snapshots/abi/{TimelockGuard.json => SaferSafes.json} (71%) rename packages/contracts-bedrock/snapshots/storageLayout/{LivenessModule2.json => SaferSafes.json} (65%) delete mode 100644 packages/contracts-bedrock/snapshots/storageLayout/TimelockGuard.json create mode 100644 packages/contracts-bedrock/src/safe/SaferSafes.sol create mode 100644 packages/contracts-bedrock/test/safe/SaferSafes.t.sol diff --git a/packages/contracts-bedrock/interfaces/safe/ILivenessModule2.sol b/packages/contracts-bedrock/interfaces/safe/ILivenessModule2.sol index 64b367c50d2..921d1a794c7 100644 --- a/packages/contracts-bedrock/interfaces/safe/ILivenessModule2.sol +++ b/packages/contracts-bedrock/interfaces/safe/ILivenessModule2.sol @@ -1,11 +1,9 @@ // SPDX-License-Identifier: MIT pragma solidity ^0.8.0; -import { ISemver } from "interfaces/universal/ISemver.sol"; - /// @title ILivenessModule2 /// @notice Interface for LivenessModule2, a singleton module for challenge-based ownership transfer -interface ILivenessModule2 is ISemver { +interface ILivenessModule2 { /// @notice Configuration for a Safe's liveness module struct ModuleConfig { uint256 livenessResponsePeriod; diff --git a/packages/contracts-bedrock/interfaces/safe/ISaferSafes.sol b/packages/contracts-bedrock/interfaces/safe/ISaferSafes.sol new file mode 100644 index 00000000000..7fc50d05eda --- /dev/null +++ b/packages/contracts-bedrock/interfaces/safe/ISaferSafes.sol @@ -0,0 +1,164 @@ +// SPDX-License-Identifier: MIT +pragma solidity 0.8.15; + +import {GnosisSafe} from "safe-contracts/GnosisSafe.sol"; +import {Enum} from "safe-contracts/common/Enum.sol"; +import {ISemver} from "interfaces/universal/ISemver.sol"; + +interface ISaferSafes is ISemver { + struct ModuleConfig { + uint256 livenessResponsePeriod; + address fallbackOwner; + } + + struct ExecTransactionParams { + address to; + uint256 value; + bytes data; + Enum.Operation operation; + uint256 safeTxGas; + uint256 baseGas; + uint256 gasPrice; + address gasToken; + address payable refundReceiver; + } + + enum TransactionState { + PENDING, + CANCELLED, + EXECUTED + } + + struct ScheduledTransaction { + uint256 executionTime; + TransactionState state; + ExecTransactionParams params; + } + + event CancellationThresholdUpdated( + GnosisSafe indexed safe, + uint256 oldThreshold, + uint256 newThreshold + ); + event ChallengeCancelled(address indexed safe); + event ChallengeStarted(address indexed safe, uint256 challengeStartTime); + event ChallengeSucceeded(address indexed safe, address fallbackOwner); + event GuardConfigured(GnosisSafe indexed safe, uint256 timelockDelay); + event Message(string message); + event ModuleCleared(address indexed safe); + event ModuleConfigured( + address indexed safe, + uint256 livenessResponsePeriod, + address fallbackOwner + ); + event TransactionCancelled(GnosisSafe indexed safe, bytes32 indexed txHash); + event TransactionExecuted(GnosisSafe indexed safe, bytes32 txHash); + event TransactionScheduled( + GnosisSafe indexed safe, + bytes32 indexed txHash, + uint256 executionTime + ); + + error LivenessModule2_ChallengeAlreadyExists(); + error LivenessModule2_ChallengeDoesNotExist(); + error LivenessModule2_InvalidFallbackOwner(); + error LivenessModule2_InvalidResponsePeriod(); + error LivenessModule2_ModuleNotConfigured(); + error LivenessModule2_ModuleNotEnabled(); + error LivenessModule2_ModuleStillEnabled(); + error LivenessModule2_OwnershipTransferFailed(); + error LivenessModule2_ResponsePeriodActive(); + error LivenessModule2_ResponsePeriodEnded(); + error LivenessModule2_UnauthorizedCaller(); + error SaferSafes_InsufficientLivenessResponsePeriod(); + error SemverComp_InvalidSemverParts(); + error TimelockGuard_GuardNotConfigured(); + error TimelockGuard_GuardNotEnabled(); + error TimelockGuard_InvalidTimelockDelay(); + error TimelockGuard_InvalidVersion(); + error TimelockGuard_TransactionAlreadyCancelled(); + error TimelockGuard_TransactionAlreadyExecuted(); + error TimelockGuard_TransactionAlreadyScheduled(); + error TimelockGuard_TransactionNotReady(); + error TimelockGuard_TransactionNotScheduled(); + + function cancelTransaction( + GnosisSafe _safe, + bytes32 _txHash, + uint256 _nonce, + bytes calldata _signatures + ) external; + + function cancellationThreshold( + GnosisSafe _safe + ) external view returns (uint256); + + function challenge(address _safe) external; + + function challengeStartTime(address _safe) external view returns (uint256); + + function changeOwnershipToFallback(address _safe) external; + + function checkAfterExecution(bytes32 _txHash, bool _success) external; + + function checkTransaction( + address _to, + uint256 _value, + bytes calldata _data, + Enum.Operation _operation, + uint256 _safeTxGas, + uint256 _baseGas, + uint256 _gasPrice, + address _gasToken, + address payable _refundReceiver, + bytes calldata, + address + ) external view; + + function clearLivenessModule() external; + + function configureLivenessModule(ModuleConfig calldata _config) external; + + function configureTimelockGuard(uint256 _timelockDelay) external; + + function getChallengePeriodEnd( + address _safe + ) external view returns (uint256); + + function livenessSafeConfiguration( + address _safe + ) + external + view + returns (uint256 livenessResponsePeriod, address fallbackOwner); + + function maxCancellationThreshold( + GnosisSafe _safe + ) external view returns (uint256); + + function pendingTransactions( + GnosisSafe _safe + ) external view returns (ScheduledTransaction[] memory); + + function respond() external; + + function scheduleTransaction( + GnosisSafe _safe, + uint256 _nonce, + ExecTransactionParams calldata _params, + bytes calldata _signatures + ) external; + + function scheduledTransaction( + GnosisSafe _safe, + bytes32 _txHash + ) external view returns (ScheduledTransaction memory); + + function signCancellation(bytes32 _txHash) external; + + function timelockConfiguration( + GnosisSafe _safe + ) external view returns (uint256); + + function version() external pure returns (string memory); +} diff --git a/packages/contracts-bedrock/interfaces/safe/ITimelockGuard.sol b/packages/contracts-bedrock/interfaces/safe/ITimelockGuard.sol index ccf454985a9..984309a87c4 100644 --- a/packages/contracts-bedrock/interfaces/safe/ITimelockGuard.sol +++ b/packages/contracts-bedrock/interfaces/safe/ITimelockGuard.sol @@ -82,7 +82,6 @@ interface ITimelockGuard { bytes memory _signatures ) external; - function version() external view returns (string memory); function timelockConfiguration(address _safe) external view returns (uint256 timelockDelay); function maxCancellationThreshold(address _safe) external view returns (uint256); function pendingTransactions(address _safe) diff --git a/packages/contracts-bedrock/scripts/deploy/DeployOwnership.s.sol b/packages/contracts-bedrock/scripts/deploy/DeployOwnership.s.sol index c93f547e4f0..ebbc244e9c3 100644 --- a/packages/contracts-bedrock/scripts/deploy/DeployOwnership.s.sol +++ b/packages/contracts-bedrock/scripts/deploy/DeployOwnership.s.sol @@ -12,6 +12,7 @@ import { Enum as SafeOps } from "safe-contracts/common/Enum.sol"; import { DeployUtils } from "scripts/libraries/DeployUtils.sol"; import { LivenessModule2 } from "src/safe/LivenessModule2.sol"; +import { SaferSafes } from "src/safe/SaferSafes.sol"; import { ISuperchainConfig } from "interfaces/L1/ISuperchainConfig.sol"; import { Deploy } from "./Deploy.s.sol"; @@ -241,11 +242,11 @@ contract DeployOwnership is Deploy { /// @notice Deploy a LivenessModule2 singleton for use on Security Council Safes /// Note this function does not have the broadcast modifier. function deployLivenessModule() public returns (address addr_) { - // Deploy the singleton LivenessModule2 (no parameters needed) - addr_ = address(new LivenessModule2()); + // Deploy the singleton SaferSafes contract which implements LivenessModule2 (no parameters needed) + addr_ = address(new SaferSafes()); artifacts.save("LivenessModule2", address(addr_)); - console.log("New LivenessModule2 deployed at %s", address(addr_)); + console.log("New SaferSafes (LivenessModule2) deployed at %s", address(addr_)); } /// @notice Deploy a Security Council Safe. diff --git a/packages/contracts-bedrock/snapshots/abi/LivenessModule2.json b/packages/contracts-bedrock/snapshots/abi/LivenessModule2.json deleted file mode 100644 index 8a4658b443d..00000000000 --- a/packages/contracts-bedrock/snapshots/abi/LivenessModule2.json +++ /dev/null @@ -1,286 +0,0 @@ -[ - { - "inputs": [ - { - "internalType": "address", - "name": "_safe", - "type": "address" - } - ], - "name": "challenge", - "outputs": [], - "stateMutability": "nonpayable", - "type": "function" - }, - { - "inputs": [ - { - "internalType": "address", - "name": "", - "type": "address" - } - ], - "name": "challengeStartTime", - "outputs": [ - { - "internalType": "uint256", - "name": "", - "type": "uint256" - } - ], - "stateMutability": "view", - "type": "function" - }, - { - "inputs": [ - { - "internalType": "address", - "name": "_safe", - "type": "address" - } - ], - "name": "changeOwnershipToFallback", - "outputs": [], - "stateMutability": "nonpayable", - "type": "function" - }, - { - "inputs": [], - "name": "clearLivenessModule", - "outputs": [], - "stateMutability": "nonpayable", - "type": "function" - }, - { - "inputs": [ - { - "components": [ - { - "internalType": "uint256", - "name": "livenessResponsePeriod", - "type": "uint256" - }, - { - "internalType": "address", - "name": "fallbackOwner", - "type": "address" - } - ], - "internalType": "struct LivenessModule2.ModuleConfig", - "name": "_config", - "type": "tuple" - } - ], - "name": "configureLivenessModule", - "outputs": [], - "stateMutability": "nonpayable", - "type": "function" - }, - { - "inputs": [ - { - "internalType": "address", - "name": "_safe", - "type": "address" - } - ], - "name": "getChallengePeriodEnd", - "outputs": [ - { - "internalType": "uint256", - "name": "", - "type": "uint256" - } - ], - "stateMutability": "view", - "type": "function" - }, - { - "inputs": [ - { - "internalType": "address", - "name": "", - "type": "address" - } - ], - "name": "livenessSafeConfiguration", - "outputs": [ - { - "internalType": "uint256", - "name": "livenessResponsePeriod", - "type": "uint256" - }, - { - "internalType": "address", - "name": "fallbackOwner", - "type": "address" - } - ], - "stateMutability": "view", - "type": "function" - }, - { - "inputs": [], - "name": "respond", - "outputs": [], - "stateMutability": "nonpayable", - "type": "function" - }, - { - "inputs": [], - "name": "version", - "outputs": [ - { - "internalType": "string", - "name": "", - "type": "string" - } - ], - "stateMutability": "view", - "type": "function" - }, - { - "anonymous": false, - "inputs": [ - { - "indexed": true, - "internalType": "address", - "name": "safe", - "type": "address" - } - ], - "name": "ChallengeCancelled", - "type": "event" - }, - { - "anonymous": false, - "inputs": [ - { - "indexed": true, - "internalType": "address", - "name": "safe", - "type": "address" - }, - { - "indexed": false, - "internalType": "uint256", - "name": "challengeStartTime", - "type": "uint256" - } - ], - "name": "ChallengeStarted", - "type": "event" - }, - { - "anonymous": false, - "inputs": [ - { - "indexed": true, - "internalType": "address", - "name": "safe", - "type": "address" - }, - { - "indexed": false, - "internalType": "address", - "name": "fallbackOwner", - "type": "address" - } - ], - "name": "ChallengeSucceeded", - "type": "event" - }, - { - "anonymous": false, - "inputs": [ - { - "indexed": true, - "internalType": "address", - "name": "safe", - "type": "address" - } - ], - "name": "ModuleCleared", - "type": "event" - }, - { - "anonymous": false, - "inputs": [ - { - "indexed": true, - "internalType": "address", - "name": "safe", - "type": "address" - }, - { - "indexed": false, - "internalType": "uint256", - "name": "livenessResponsePeriod", - "type": "uint256" - }, - { - "indexed": false, - "internalType": "address", - "name": "fallbackOwner", - "type": "address" - } - ], - "name": "ModuleConfigured", - "type": "event" - }, - { - "inputs": [], - "name": "LivenessModule2_ChallengeAlreadyExists", - "type": "error" - }, - { - "inputs": [], - "name": "LivenessModule2_ChallengeDoesNotExist", - "type": "error" - }, - { - "inputs": [], - "name": "LivenessModule2_InvalidFallbackOwner", - "type": "error" - }, - { - "inputs": [], - "name": "LivenessModule2_InvalidResponsePeriod", - "type": "error" - }, - { - "inputs": [], - "name": "LivenessModule2_ModuleNotConfigured", - "type": "error" - }, - { - "inputs": [], - "name": "LivenessModule2_ModuleNotEnabled", - "type": "error" - }, - { - "inputs": [], - "name": "LivenessModule2_ModuleStillEnabled", - "type": "error" - }, - { - "inputs": [], - "name": "LivenessModule2_OwnershipTransferFailed", - "type": "error" - }, - { - "inputs": [], - "name": "LivenessModule2_ResponsePeriodActive", - "type": "error" - }, - { - "inputs": [], - "name": "LivenessModule2_ResponsePeriodEnded", - "type": "error" - }, - { - "inputs": [], - "name": "LivenessModule2_UnauthorizedCaller", - "type": "error" - } -] \ No newline at end of file diff --git a/packages/contracts-bedrock/snapshots/abi/TimelockGuard.json b/packages/contracts-bedrock/snapshots/abi/SaferSafes.json similarity index 71% rename from packages/contracts-bedrock/snapshots/abi/TimelockGuard.json rename to packages/contracts-bedrock/snapshots/abi/SaferSafes.json index 15145753d43..c79f6fa7929 100644 --- a/packages/contracts-bedrock/snapshots/abi/TimelockGuard.json +++ b/packages/contracts-bedrock/snapshots/abi/SaferSafes.json @@ -46,6 +46,51 @@ "stateMutability": "view", "type": "function" }, + { + "inputs": [ + { + "internalType": "address", + "name": "_safe", + "type": "address" + } + ], + "name": "challenge", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "", + "type": "address" + } + ], + "name": "challengeStartTime", + "outputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "_safe", + "type": "address" + } + ], + "name": "changeOwnershipToFallback", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, { "inputs": [ { @@ -127,6 +172,38 @@ "stateMutability": "view", "type": "function" }, + { + "inputs": [], + "name": "clearLivenessModule", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "components": [ + { + "internalType": "uint256", + "name": "livenessResponsePeriod", + "type": "uint256" + }, + { + "internalType": "address", + "name": "fallbackOwner", + "type": "address" + } + ], + "internalType": "struct LivenessModule2.ModuleConfig", + "name": "_config", + "type": "tuple" + } + ], + "name": "configureLivenessModule", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, { "inputs": [ { @@ -140,6 +217,49 @@ "stateMutability": "nonpayable", "type": "function" }, + { + "inputs": [ + { + "internalType": "address", + "name": "_safe", + "type": "address" + } + ], + "name": "getChallengePeriodEnd", + "outputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "", + "type": "address" + } + ], + "name": "livenessSafeConfiguration", + "outputs": [ + { + "internalType": "uint256", + "name": "livenessResponsePeriod", + "type": "uint256" + }, + { + "internalType": "address", + "name": "fallbackOwner", + "type": "address" + } + ], + "stateMutability": "view", + "type": "function" + }, { "inputs": [ { @@ -242,6 +362,13 @@ "stateMutability": "view", "type": "function" }, + { + "inputs": [], + "name": "respond", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, { "inputs": [ { @@ -475,6 +602,57 @@ "name": "CancellationThresholdUpdated", "type": "event" }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "address", + "name": "safe", + "type": "address" + } + ], + "name": "ChallengeCancelled", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "address", + "name": "safe", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "challengeStartTime", + "type": "uint256" + } + ], + "name": "ChallengeStarted", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "address", + "name": "safe", + "type": "address" + }, + { + "indexed": false, + "internalType": "address", + "name": "fallbackOwner", + "type": "address" + } + ], + "name": "ChallengeSucceeded", + "type": "event" + }, { "anonymous": false, "inputs": [ @@ -507,6 +685,44 @@ "name": "Message", "type": "event" }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "address", + "name": "safe", + "type": "address" + } + ], + "name": "ModuleCleared", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "address", + "name": "safe", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "livenessResponsePeriod", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "address", + "name": "fallbackOwner", + "type": "address" + } + ], + "name": "ModuleConfigured", + "type": "event" + }, { "anonymous": false, "inputs": [ @@ -570,6 +786,66 @@ "name": "TransactionScheduled", "type": "event" }, + { + "inputs": [], + "name": "LivenessModule2_ChallengeAlreadyExists", + "type": "error" + }, + { + "inputs": [], + "name": "LivenessModule2_ChallengeDoesNotExist", + "type": "error" + }, + { + "inputs": [], + "name": "LivenessModule2_InvalidFallbackOwner", + "type": "error" + }, + { + "inputs": [], + "name": "LivenessModule2_InvalidResponsePeriod", + "type": "error" + }, + { + "inputs": [], + "name": "LivenessModule2_ModuleNotConfigured", + "type": "error" + }, + { + "inputs": [], + "name": "LivenessModule2_ModuleNotEnabled", + "type": "error" + }, + { + "inputs": [], + "name": "LivenessModule2_ModuleStillEnabled", + "type": "error" + }, + { + "inputs": [], + "name": "LivenessModule2_OwnershipTransferFailed", + "type": "error" + }, + { + "inputs": [], + "name": "LivenessModule2_ResponsePeriodActive", + "type": "error" + }, + { + "inputs": [], + "name": "LivenessModule2_ResponsePeriodEnded", + "type": "error" + }, + { + "inputs": [], + "name": "LivenessModule2_UnauthorizedCaller", + "type": "error" + }, + { + "inputs": [], + "name": "SaferSafes_InsufficientLivenessResponsePeriod", + "type": "error" + }, { "inputs": [], "name": "SemverComp_InvalidSemverParts", diff --git a/packages/contracts-bedrock/snapshots/semver-lock.json b/packages/contracts-bedrock/snapshots/semver-lock.json index 366cbca9da7..c0eb064250f 100644 --- a/packages/contracts-bedrock/snapshots/semver-lock.json +++ b/packages/contracts-bedrock/snapshots/semver-lock.json @@ -207,13 +207,9 @@ "initCodeHash": "0xa4a06e8778dbb6883ece8f56538ba15bc01b3031bba9a12ad9d187e7c8aaa942", "sourceCodeHash": "0x950725f8b9ad9bb3b6b5e836f67e18db824a7864bac547ee0eeba88ada3de0e9" }, - "src/safe/LivenessModule2.sol:LivenessModule2": { - "initCodeHash": "0x4679b41e5648a955a883efd0271453c8b13ff4846f853d372527ebb1e0905ab5", - "sourceCodeHash": "0xd3084fb5446782cb6d0adb4278ef0a12c418dd538b4b14b90407b971b44cc35b" - }, - "src/safe/TimelockGuard.sol:TimelockGuard": { - "initCodeHash": "0x1f8188872de93ce59e8f0bd415d4fbf30209bc668c09623f61d6fe592eee895a", - "sourceCodeHash": "0x0dada93f051d29dabbb6de3e1c1ece14b95cd20dc854454926d19ea1ebcae436" + "src/safe/SaferSafes.sol:SaferSafes": { + "initCodeHash": "0x22730f6ebe10e0d78b23b3e0f3d58f867f420039981455b09a508755e512c127", + "sourceCodeHash": "0xe3d2fd50724baf6d5e83e2c9d89fcfcbc678d966187bd38e2d9a840716bcafa3" }, "src/universal/OptimismMintableERC20.sol:OptimismMintableERC20": { "initCodeHash": "0x3c85eed0d017dca8eda6396aa842ddc12492587b061e8c756a8d32c4610a9658", diff --git a/packages/contracts-bedrock/snapshots/storageLayout/LivenessModule2.json b/packages/contracts-bedrock/snapshots/storageLayout/SaferSafes.json similarity index 65% rename from packages/contracts-bedrock/snapshots/storageLayout/LivenessModule2.json rename to packages/contracts-bedrock/snapshots/storageLayout/SaferSafes.json index 478b0b25136..17b7d237e9f 100644 --- a/packages/contracts-bedrock/snapshots/storageLayout/LivenessModule2.json +++ b/packages/contracts-bedrock/snapshots/storageLayout/SaferSafes.json @@ -12,5 +12,12 @@ "offset": 0, "slot": "1", "type": "mapping(address => uint256)" + }, + { + "bytes": "32", + "label": "_safeState", + "offset": 0, + "slot": "2", + "type": "mapping(contract GnosisSafe => struct TimelockGuard.SafeState)" } ] \ No newline at end of file diff --git a/packages/contracts-bedrock/snapshots/storageLayout/TimelockGuard.json b/packages/contracts-bedrock/snapshots/storageLayout/TimelockGuard.json deleted file mode 100644 index 97c754bfc8c..00000000000 --- a/packages/contracts-bedrock/snapshots/storageLayout/TimelockGuard.json +++ /dev/null @@ -1,9 +0,0 @@ -[ - { - "bytes": "32", - "label": "_safeState", - "offset": 0, - "slot": "0", - "type": "mapping(contract GnosisSafe => struct TimelockGuard.SafeState)" - } -] \ No newline at end of file diff --git a/packages/contracts-bedrock/src/safe/LivenessModule2.sol b/packages/contracts-bedrock/src/safe/LivenessModule2.sol index 457f8678910..ac9fe40839e 100644 --- a/packages/contracts-bedrock/src/safe/LivenessModule2.sol +++ b/packages/contracts-bedrock/src/safe/LivenessModule2.sol @@ -6,9 +6,6 @@ import { GnosisSafe as Safe } from "safe-contracts/GnosisSafe.sol"; import { Enum } from "safe-contracts/common/Enum.sol"; import { OwnerManager } from "safe-contracts/base/OwnerManager.sol"; -// Interfaces -import { ISemver } from "interfaces/universal/ISemver.sol"; - /// @title LivenessModule2 /// @notice This module allows challenge-based ownership transfer to a fallback owner /// when the Safe becomes unresponsive. The fallback owner can initiate a challenge, @@ -17,7 +14,7 @@ import { ISemver } from "interfaces/universal/ISemver.sol"; /// @dev This is a singleton contract. To use it: /// 1. The Safe must first enable this module using ModuleManager.enableModule() /// 2. The Safe must then configure the module by calling configure() with params -contract LivenessModule2 is ISemver { +abstract contract LivenessModule2 { /// @notice Configuration for a Safe's liveness module. /// @custom:field livenessResponsePeriod The duration in seconds that Safe owners have to /// respond to a challenge. @@ -97,10 +94,6 @@ contract LivenessModule2 is ISemver { /// @param fallbackOwner The address that claimed ownership if the Safe is unresponsive. event ChallengeSucceeded(address indexed safe, address fallbackOwner); - /// @notice Semantic version. - /// @custom:semver 2.0.0 - string public constant version = "2.0.0"; - /// @notice Returns challenge_start_time + liveness_response_period if challenge exists, or /// 0 if not. /// @param _safe The Safe address to query. @@ -146,8 +139,15 @@ contract LivenessModule2 is ISemver { _cancelChallenge(msg.sender); emit ModuleConfigured(msg.sender, _config.livenessResponsePeriod, _config.fallbackOwner); + + // Verify that any other extensions which are enabled on the Safe are configured correctly. + _checkCombinedConfig(Safe(payable(msg.sender))); } + /// @notice Internal helper function which can be overriden in a child contract to check if the guard's + /// configuration is valid in the context of other extensions that are enabled on the Safe. + function _checkCombinedConfig(Safe _safe) internal view virtual; + /// @notice Clears the module configuration for a Safe. /// @dev Note: Clearing the configuration also cancels any ongoing challenges. /// This function is intended for use when a Safe wants to permanently remove diff --git a/packages/contracts-bedrock/src/safe/SaferSafes.sol b/packages/contracts-bedrock/src/safe/SaferSafes.sol new file mode 100644 index 00000000000..e468652678a --- /dev/null +++ b/packages/contracts-bedrock/src/safe/SaferSafes.sol @@ -0,0 +1,63 @@ +// SPDX-License-Identifier: MIT +pragma solidity 0.8.15; + +// Safe +import { GnosisSafe as Safe } from "safe-contracts/GnosisSafe.sol"; + +// Safe Extensions +import { LivenessModule2 } from "./LivenessModule2.sol"; +import { TimelockGuard } from "./TimelockGuard.sol"; +import { ISemver } from "interfaces/universal/ISemver.sol"; + +/// @title SaferSafes +/// @notice Combined Safe extensions providing both liveness module and timelock guard functionality +/// @dev This contract can be enabled simultaneously as both a module and a guard on a Safe: +/// - As a module: provides liveness challenge functionality to prevent multisig deadlock +/// - As a guard: provides timelock functionality for transaction delays and cancellation +/// The two components in this contract are almost entirely independent of each other, and can be treated as +/// separate extensions to the Safe. The only shared logic is the _checkCombinedConfig which runs at the end of the +/// configuration functions for both components and ensures that the resulting configuration is valid. +/// Either component can be enabled or disabled independently of the other. +/// When installing either component, it should first be enabled, and then configured. If a component's +/// functionality is not desired, then there is no need to enable or configure it. +contract SaferSafes is LivenessModule2, TimelockGuard, ISemver { + /// @notice Semantic version. + /// @custom:semver 1.0.0 + string public constant version = "1.0.0"; + + /// @notice Error for when the liveness response period is insufficient. + error SaferSafes_InsufficientLivenessResponsePeriod(); + + /// @notice Internal helper function which can be overriden in a child contract to check if the guard's + /// configuration is valid in the context of other extensions that are enabled on the Safe. + /// This function acts as a FREI-PI invariant check to ensure the resulting config is valid, it MUST be + /// called at the end of any configuration functions in the parent contract. + function _checkCombinedConfig(Safe _safe) internal view override(LivenessModule2, TimelockGuard) { + // We only need to perform this check if both the guard and the module are enabled on the Safe + if (!(_isGuardEnabled(_safe) && _safe.isModuleEnabled(address(this)))) { + return; + } + + uint256 timelockDelay = _safeState[_safe].timelockDelay; + uint256 livenessResponsePeriod = livenessSafeConfiguration[address(_safe)].livenessResponsePeriod; + + // If the timelock delay is 0, then the timelock guard is enabled but not configured. + // No delay is applied to transactions, so we don't need to perform any further checks. + if (timelockDelay == 0) { + return; + } + + // If the liveness response period is 0, then the liveness module is enabled but not configured. + // Challenging is not possible, so we don't need to perform any further checks. + if (livenessResponsePeriod == 0) { + return; + } + + // The liveness response period must be at least twice the timelock delay, this is necessary to prevent a + // situation in which a Safe is not able to respond because there is insufficient time to respond to a challenge + // after the timelock delay has expired. + if (livenessResponsePeriod < 2 * timelockDelay) { + revert SaferSafes_InsufficientLivenessResponsePeriod(); + } + } +} diff --git a/packages/contracts-bedrock/src/safe/TimelockGuard.sol b/packages/contracts-bedrock/src/safe/TimelockGuard.sol index 26dce92ce47..183b2a46c8e 100644 --- a/packages/contracts-bedrock/src/safe/TimelockGuard.sol +++ b/packages/contracts-bedrock/src/safe/TimelockGuard.sol @@ -10,9 +10,6 @@ import { Guard as IGuard } from "safe-contracts/base/GuardManager.sol"; import { EnumerableSet } from "@openzeppelin/contracts/utils/structs/EnumerableSet.sol"; import { SemverComp } from "src/libraries/SemverComp.sol"; -// Interfaces -import { ISemver } from "interfaces/universal/ISemver.sol"; - /// @title TimelockGuard /// @notice This guard provides timelock functionality for Safe transactions /// @dev This is a singleton contract, any Safe on the network can use this guard to enforce a timelock delay, and @@ -67,7 +64,7 @@ import { ISemver } from "interfaces/universal/ISemver.sol"; /// | Quorum+ | challenge + | cancelTransaction | /// | | changeOwnershipToFallback | | /// +-------------------------------------------------------------------------------------------------+ -contract TimelockGuard is IGuard, ISemver { +abstract contract TimelockGuard is IGuard { using EnumerableSet for EnumerableSet.Bytes32Set; /// @notice Allowed states of a transaction @@ -125,10 +122,6 @@ contract TimelockGuard is IGuard, ISemver { /// @notice Mapping from Safe address to its timelock guard state. mapping(Safe => SafeState) internal _safeState; - /// @notice Semantic version. - /// @custom:semver 1.0.0 - string public constant version = "1.0.0"; - /// @notice Error for when guard is not enabled for the Safe error TimelockGuard_GuardNotEnabled(); @@ -209,6 +202,10 @@ contract TimelockGuard is IGuard, ISemver { return guard == address(this); } + /// @notice Internal helper function which can be overriden in a child contract to check if the guard's + /// configuration is valid in the context of other extensions that are enabled on the Safe. + function _checkCombinedConfig(Safe _safe) internal view virtual; + //////////////////////////////////////////////////////////////// // External View Functions // //////////////////////////////////////////////////////////////// @@ -451,6 +448,9 @@ contract TimelockGuard is IGuard, ISemver { // Initialize (or reset) the cancellation threshold to 1. _resetCancellationThreshold(callingSafe); emit GuardConfigured(callingSafe, _timelockDelay); + + // Verify that any other extensions which are enabled on the Safe are configured correctly. + _checkCombinedConfig(callingSafe); } /// @notice Schedule a transaction for execution after the timelock delay. diff --git a/packages/contracts-bedrock/test/safe/LivenessModule2.t.sol b/packages/contracts-bedrock/test/safe/LivenessModule2.t.sol index e552e6a00f2..e690228be13 100644 --- a/packages/contracts-bedrock/test/safe/LivenessModule2.t.sol +++ b/packages/contracts-bedrock/test/safe/LivenessModule2.t.sol @@ -6,6 +6,7 @@ import { Enum } from "safe-contracts/common/Enum.sol"; import "test/safe-tools/SafeTestTools.sol"; import { LivenessModule2 } from "src/safe/LivenessModule2.sol"; +import { SaferSafes } from "src/safe/SaferSafes.sol"; /// @title LivenessModule2_TestInit /// @notice Reusable test initialization for `LivenessModule2` tests. @@ -24,7 +25,7 @@ contract LivenessModule2_TestInit is Test, SafeTestTools { uint256 constant NUM_OWNERS = 5; uint256 constant THRESHOLD = 3; - LivenessModule2 livenessModule2; + SaferSafes livenessModule2; SafeInstance safeInstance; address fallbackOwner; address[] owners; @@ -33,8 +34,8 @@ contract LivenessModule2_TestInit is Test, SafeTestTools { function setUp() public virtual { vm.warp(INIT_TIME); - // Deploy the singleton LivenessModule2 - livenessModule2 = new LivenessModule2(); + // Deploy the combined SaferSafes contract which implements LivenessModule2 + livenessModule2 = new SaferSafes(); // Create Safe owners (address[] memory _owners, uint256[] memory _keys) = SafeTestLib.makeAddrsAndKeys("owners", NUM_OWNERS); diff --git a/packages/contracts-bedrock/test/safe/SaferSafes.t.sol b/packages/contracts-bedrock/test/safe/SaferSafes.t.sol new file mode 100644 index 00000000000..5bf77603675 --- /dev/null +++ b/packages/contracts-bedrock/test/safe/SaferSafes.t.sol @@ -0,0 +1,146 @@ +// SPDX-License-Identifier: MIT +pragma solidity 0.8.15; + +import { Test } from "forge-std/Test.sol"; +import "test/safe-tools/SafeTestTools.sol"; + +import { SaferSafes } from "src/safe/SaferSafes.sol"; +import { LivenessModule2 } from "src/safe/LivenessModule2.sol"; + +/// @title SaferSafes_TestInit +/// @notice Reusable test initialization for `SaferSafes` tests. +contract SaferSafes_TestInit is Test, SafeTestTools { + using SafeTestLib for SafeInstance; + + // Events + event ModuleConfigured(address indexed safe, uint256 livenessResponsePeriod, address fallbackOwner); + event GuardConfigured(address indexed safe, uint256 timelockDelay, uint256 cancellationThreshold); + + uint256 constant INIT_TIME = 10; + uint256 constant NUM_OWNERS = 5; + uint256 constant THRESHOLD = 3; + + SaferSafes saferSafes; + SafeInstance safeInstance; + address fallbackOwner; + address[] owners; + uint256[] ownerPKs; + + function setUp() public virtual { + vm.warp(INIT_TIME); + + // Deploy the SaferSafes contract + saferSafes = new SaferSafes(); + + // Create Safe owners + (address[] memory _owners, uint256[] memory _keys) = SafeTestLib.makeAddrsAndKeys("owners", NUM_OWNERS); + owners = _owners; + ownerPKs = _keys; + + // Set up Safe with owners + safeInstance = _setupSafe(ownerPKs, THRESHOLD); + + // Set fallback owner + fallbackOwner = makeAddr("fallbackOwner"); + + // Enable the module and guard on the Safe + safeInstance.enableModule(address(saferSafes)); + safeInstance.setGuard(address(saferSafes)); + } +} + +/// @title SaferSafes_Uncategorized_Test +/// @notice Tests for SaferSafes configuration functionality. +contract SaferSafes_Uncategorized_Test is SaferSafes_TestInit { + /// @notice Test successful configuration when liveness response period is at least 2x timelock delay. + function test_configure_livenessModuleFirst_succeeds() public { + uint256 timelockDelay = 7 days; + uint256 livenessResponsePeriod = 21 days; // Much greater than 2 * 7 days = 14 days (should succeed) + + // Configure the liveness module FIRST + LivenessModule2.ModuleConfig memory moduleConfig = LivenessModule2.ModuleConfig({ + livenessResponsePeriod: livenessResponsePeriod, + fallbackOwner: fallbackOwner + }); + + vm.prank(address(safeInstance.safe)); + saferSafes.configureLivenessModule(moduleConfig); + + // Configure the timelock guard SECOND (this will trigger the check) + vm.prank(address(safeInstance.safe)); + saferSafes.configureTimelockGuard(timelockDelay); + + // Verify configurations were set + (uint256 storedLivenessResponsePeriod, address storedFallbackOwner) = + saferSafes.livenessSafeConfiguration(address(safeInstance.safe)); + assertEq(storedLivenessResponsePeriod, livenessResponsePeriod); + assertEq(storedFallbackOwner, fallbackOwner); + assertEq(saferSafes.timelockConfiguration(safeInstance.safe), timelockDelay); + } + + function test_configure_timelockGuardFirst_succeeds() public { + uint256 timelockDelay = 7 days; + uint256 livenessResponsePeriod = 21 days; // Much greater than 2 * 7 days = 14 days (should succeed) + + // Configure the timelock guard FIRST + vm.prank(address(safeInstance.safe)); + saferSafes.configureTimelockGuard(timelockDelay); + + LivenessModule2.ModuleConfig memory moduleConfig = LivenessModule2.ModuleConfig({ + livenessResponsePeriod: livenessResponsePeriod, + fallbackOwner: fallbackOwner + }); + + // Configure the liveness module SECOND (this will trigger the check) + vm.prank(address(safeInstance.safe)); + saferSafes.configureLivenessModule(moduleConfig); + + // Verify configurations were set + (uint256 storedLivenessResponsePeriod, address storedFallbackOwner) = + saferSafes.livenessSafeConfiguration(address(safeInstance.safe)); + assertEq(storedLivenessResponsePeriod, livenessResponsePeriod); + assertEq(storedFallbackOwner, fallbackOwner); + assertEq(saferSafes.timelockConfiguration(safeInstance.safe), timelockDelay); + } + + /// @notice Test that attempting to incorrectly configure the timelock guard after first configuring the liveness + /// module fails. + /// @dev This test would fail if timelock guard configuration also triggered validation + function test_configure_livenessModuleFirstInvalidConfig_reverts() public { + uint256 timelockDelay = 7 days; + uint256 livenessResponsePeriod = 13 days; // This is invalid: 13 < 2*7 + + // Configure liveness module first + LivenessModule2.ModuleConfig memory moduleConfig = LivenessModule2.ModuleConfig({ + livenessResponsePeriod: livenessResponsePeriod, + fallbackOwner: fallbackOwner + }); + + vm.prank(address(safeInstance.safe)); + saferSafes.configureLivenessModule(moduleConfig); + + // Now configure timelock guard + vm.prank(address(safeInstance.safe)); + vm.expectRevert(SaferSafes.SaferSafes_InsufficientLivenessResponsePeriod.selector); + saferSafes.configureTimelockGuard(timelockDelay); + } + + function test_configure_timelockGuardFirstInvalidConfig_reverts() public { + uint256 timelockDelay = 7 days; + uint256 livenessResponsePeriod = 13 days; // This is invalid: 13 < 2*7 + + // Configure timelock guard first + vm.prank(address(safeInstance.safe)); + saferSafes.configureTimelockGuard(timelockDelay); + + LivenessModule2.ModuleConfig memory moduleConfig = LivenessModule2.ModuleConfig({ + livenessResponsePeriod: livenessResponsePeriod, + fallbackOwner: fallbackOwner + }); + + // Configure liveness module second - this will trigger the check + vm.expectRevert(SaferSafes.SaferSafes_InsufficientLivenessResponsePeriod.selector); + vm.prank(address(safeInstance.safe)); + saferSafes.configureLivenessModule(moduleConfig); + } +} diff --git a/packages/contracts-bedrock/test/safe/TimelockGuard.t.sol b/packages/contracts-bedrock/test/safe/TimelockGuard.t.sol index 88e12657997..22473fccb2f 100644 --- a/packages/contracts-bedrock/test/safe/TimelockGuard.t.sol +++ b/packages/contracts-bedrock/test/safe/TimelockGuard.t.sol @@ -7,6 +7,7 @@ import { GuardManager } from "safe-contracts/base/GuardManager.sol"; import "test/safe-tools/SafeTestTools.sol"; import { TimelockGuard } from "src/safe/TimelockGuard.sol"; +import { SaferSafes } from "src/safe/SaferSafes.sol"; using TransactionBuilder for TransactionBuilder.Transaction; @@ -169,8 +170,10 @@ contract TimelockGuard_TestInit is Test, SafeTestTools { function setUp() public virtual { vm.warp(INIT_TIME); - // Deploy the singleton TimelockGuard - timelockGuard = new TimelockGuard(); + // Deploy the combined SaferSafes contract which implements TimelockGuard + SaferSafes saferSafesImpl = new SaferSafes(); + timelockGuard = TimelockGuard(address(saferSafesImpl)); + // Set up Safe with owners safeInstance = _deploySafe("owners", NUM_OWNERS, THRESHOLD); safe = Safe(payable(safeInstance.safe)); From e4563403e57b4a655936f5d2b024f0c24aca5f28 Mon Sep 17 00:00:00 2001 From: George Knee Date: Fri, 10 Oct 2025 14:50:35 +0100 Subject: [PATCH 040/117] txmgr: replace `UseCellProofs` flag with `CellProofTime` flag (#17649) * txmgr: replace UseCellProofs flag with CellProofTime flag Closes https://github.com/ethereum-optimism/optimism/issues/17634 * use default CellProofTime in op-e2e/utils.NewTxMgrConfig * fix comparison * unit test the important bit * WIP * Apply suggestions from code review Co-authored-by: Sebastian Stammler * Revert "WIP" This reverts commit 1eb8a919576668dd2f124f051bc9bb866d63ba00. * improve handling of fallback to cover 4 L1 chains * fix test * add debug log * format * add 12s buffer * avoid overflow --------- Co-authored-by: Sebastian Stammler --- op-e2e/e2eutils/setuputils/utils.go | 2 ++ op-service/txmgr/cli.go | 50 +++++++++++++++++++---------- op-service/txmgr/cli_test.go | 21 ++++++++++++ op-service/txmgr/test_txmgr.go | 2 +- op-service/txmgr/txmgr.go | 10 ++++-- op-service/txmgr/txmgr_test.go | 2 ++ 6 files changed, 67 insertions(+), 20 deletions(-) diff --git a/op-e2e/e2eutils/setuputils/utils.go b/op-e2e/e2eutils/setuputils/utils.go index ef73476e6e5..df6a212ee8a 100644 --- a/op-e2e/e2eutils/setuputils/utils.go +++ b/op-e2e/e2eutils/setuputils/utils.go @@ -2,6 +2,7 @@ package setuputils import ( "crypto/ecdsa" + "math" "time" "github.com/ethereum-optimism/optimism/op-service/crypto" @@ -29,5 +30,6 @@ func NewTxMgrConfig(l1Addr endpoint.RPC, privKey *ecdsa.PrivateKey) txmgr.CLICon ReceiptQueryInterval: 50 * time.Millisecond, NetworkTimeout: 2 * time.Second, TxNotInMempoolTimeout: 2 * time.Minute, + CellProofTime: math.MaxUint64, } } diff --git a/op-service/txmgr/cli.go b/op-service/txmgr/cli.go index 1e368fdd05a..386ce7a28cd 100644 --- a/op-service/txmgr/cli.go +++ b/op-service/txmgr/cli.go @@ -4,6 +4,7 @@ import ( "context" "errors" "fmt" + "math" "math/big" "sync/atomic" "time" @@ -45,7 +46,7 @@ const ( TxNotInMempoolTimeoutFlagName = "txmgr.not-in-mempool-timeout" ReceiptQueryIntervalFlagName = "txmgr.receipt-query-interval" AlreadyPublishedCustomErrsFlagName = "txmgr.already-published-custom-errs" - EnableCellProofsFlagName = "txmgr.enable-cell-proofs" + CellProofTimeFlagName = "txmgr.cell-proof-time" ) var ( @@ -78,11 +79,12 @@ type DefaultFlagValues struct { TxSendTimeout time.Duration TxNotInMempoolTimeout time.Duration ReceiptQueryInterval time.Duration - EnableCellProofs bool + CellProofTime uint64 } var ( - DefaultBatcherFlagValues = DefaultFlagValues{ + defaultCellProofTime uint64 = math.MaxUint64 + DefaultBatcherFlagValues = DefaultFlagValues{ NumConfirmations: uint64(10), SafeAbortNonceTooLowCount: uint64(3), FeeLimitMultiplier: uint64(5), @@ -97,7 +99,7 @@ var ( TxSendTimeout: 0, // Try sending txs indefinitely, to preserve tx ordering for Holocene TxNotInMempoolTimeout: 2 * time.Minute, ReceiptQueryInterval: 12 * time.Second, - EnableCellProofs: false, // Ater Osaka activates on L1, this should be set to true + CellProofTime: defaultCellProofTime, } DefaultChallengerFlagValues = DefaultFlagValues{ NumConfirmations: uint64(3), @@ -113,6 +115,7 @@ var ( TxSendTimeout: 2 * time.Minute, TxNotInMempoolTimeout: 1 * time.Minute, ReceiptQueryInterval: 12 * time.Second, + CellProofTime: defaultCellProofTime, } // geth enforces a 1 gwei minimum for blob tx fee @@ -242,11 +245,11 @@ func CLIFlagsWithDefaults(envPrefix string, defaults DefaultFlagValues) []cli.Fl Usage: "List of custom RPC error messages that indicate that a transaction has already been published.", EnvVars: prefixEnvVars("TXMGR_ALREADY_PUBLISHED_CUSTOM_ERRS"), }, - &cli.BoolFlag{ - Name: EnableCellProofsFlagName, - Usage: "Enable cell proofs in blob transactions for Fusaka (EIP-7742) compatibility", - Value: false, - EnvVars: prefixEnvVars("TXMGR_ENABLE_CELL_PROOFS"), + &cli.Uint64Flag{ + Name: CellProofTimeFlagName, + Usage: "Enables cell proofs in blob transactions for Fusaka (EIP-7742) compatibility from the provided unix timestamp. Should be set to the L1 Fusaka time. May be left blank for Ethereum Mainnet, Sepolia, Holesky, or Hoodi L1s.", + EnvVars: prefixEnvVars("TXMGR_CELL_PROOF_TIME"), + Value: defaults.CellProofTime, }, }, opsigner.CLIFlags(envPrefix, "")...) } @@ -276,7 +279,7 @@ type CLIConfig struct { TxSendTimeout time.Duration TxNotInMempoolTimeout time.Duration AlreadyPublishedCustomErrs []string - EnableCellProofs bool + CellProofTime uint64 } func NewCLIConfig(l1RPCURL string, defaults DefaultFlagValues) CLIConfig { @@ -296,8 +299,8 @@ func NewCLIConfig(l1RPCURL string, defaults DefaultFlagValues) CLIConfig { TxSendTimeout: defaults.TxSendTimeout, TxNotInMempoolTimeout: defaults.TxNotInMempoolTimeout, ReceiptQueryInterval: defaults.ReceiptQueryInterval, - EnableCellProofs: defaults.EnableCellProofs, SignerCLIConfig: opsigner.NewCLIConfig(), + CellProofTime: defaults.CellProofTime, } } @@ -350,6 +353,7 @@ func (m CLIConfig) Check() error { if !atMostOneIsSet(m.PrivateKey != "", m.Mnemonic != "", m.SignerCLIConfig.Enabled()) { return errors.New("can only provide at most one of: [private key, mnemonic, remote signer]") } + return nil } @@ -379,7 +383,7 @@ func ReadCLIConfig(ctx cliiface.Context) CLIConfig { TxSendTimeout: ctx.Duration(TxSendTimeoutFlagName), TxNotInMempoolTimeout: ctx.Duration(TxNotInMempoolTimeoutFlagName), AlreadyPublishedCustomErrs: ctx.StringSlice(AlreadyPublishedCustomErrsFlagName), - EnableCellProofs: ctx.Bool(EnableCellProofsFlagName), + CellProofTime: ctx.Uint64(CellProofTimeFlagName), } } @@ -447,6 +451,8 @@ func NewConfig(cfg CLIConfig, l log.Logger) (*Config, error) { } } + cellProofTime := fallbackToOsakaCellProofTimeIfKnown(chainID, cfg.CellProofTime) + res := Config{ Backend: l1, ChainID: chainID, @@ -462,6 +468,7 @@ func NewConfig(cfg CLIConfig, l log.Logger) (*Config, error) { NumConfirmations: cfg.NumConfirmations, SafeAbortNonceTooLowCount: cfg.SafeAbortNonceTooLowCount, AlreadyPublishedCustomErrs: cfg.AlreadyPublishedCustomErrs, + CellProofTime: cellProofTime, } res.RebroadcastInterval.Store(int64(cfg.RebroadcastInterval)) @@ -473,11 +480,21 @@ func NewConfig(cfg CLIConfig, l log.Logger) (*Config, error) { res.MinTipCap.Store(minTipCap) res.MaxTipCap.Store(maxTipCap) res.MinBlobTxFee.Store(defaultMinBlobTxFee) - res.EnableCellProofs = cfg.EnableCellProofs return &res, nil } +func fallbackToOsakaCellProofTimeIfKnown(chainID *big.Int, cellProofTime uint64) uint64 { + if cellProofTime != defaultCellProofTime { + return cellProofTime // We only fallback if nothing is set + } + l1ChainConfig := eth.L1ChainConfigByChainID(eth.ChainIDFromBig(chainID)) + if l1ChainConfig != nil && l1ChainConfig.OsakaTime != nil { + return *l1ChainConfig.OsakaTime + } + return math.MaxUint64 // Network not known and no override specified, so we never use cell proofs +} + // Config houses parameters for altering the behavior of a SimpleTxManager. type Config struct { Backend ETHBackend @@ -512,10 +529,6 @@ type Config struct { MinBlobTxFee atomic.Pointer[big.Int] - // EnableCellProofs determines whether to use cell proofs (Version1 sidecars) - // for Fusaka (EIP-7742) compatibility. If false, uses legacy blob proofs (Version0). - EnableCellProofs bool - // ChainID is the chain ID of the L1 chain. ChainID *big.Int @@ -567,6 +580,9 @@ type Config struct { // List of custom RPC error messages that indicate that a transaction has // already been published. AlreadyPublishedCustomErrs []string + + // CellProofTime is the time at which cell proofs are enabled in blob transaction (for Fusaka (EIP-7742) compatibility). + CellProofTime uint64 } func (m *Config) Check() error { diff --git a/op-service/txmgr/cli_test.go b/op-service/txmgr/cli_test.go index dc12e55653b..892a9d498d5 100644 --- a/op-service/txmgr/cli_test.go +++ b/op-service/txmgr/cli_test.go @@ -1,6 +1,8 @@ package txmgr import ( + "math" + "math/big" "testing" "github.com/stretchr/testify/require" @@ -14,6 +16,7 @@ var ( func TestDefaultCLIOptionsMatchDefaultConfig(t *testing.T) { cfg := configForArgs() defaultCfg := NewCLIConfig(l1EthRpcValue, DefaultBatcherFlagValues) + require.Equal(t, defaultCfg, cfg) } @@ -39,3 +42,21 @@ func configForArgs(args ...string) CLIConfig { _ = app.Run(args) return config } + +func TestFallbackToOsakaCellProofTimeIfKnown(t *testing.T) { + // No override, but we detect the L1 is Mainnet (no Osaka time yet) + cellProofTime := fallbackToOsakaCellProofTimeIfKnown(big.NewInt(1), math.MaxUint64) + require.Equal(t, uint64(18446744073709551615), cellProofTime) + + // No override, but we detect the L1 is Sepolia + cellProofTime = fallbackToOsakaCellProofTimeIfKnown(big.NewInt(11155111), math.MaxUint64) + require.Equal(t, uint64(1760427360), cellProofTime) + + // Override is set, so we ignore known L1 config and use the override + cellProofTime = fallbackToOsakaCellProofTimeIfKnown(big.NewInt(1), 654321) + require.Equal(t, uint64(654321), cellProofTime) + + // No override set, but L1 Network is not known, so we never use cell proofs + cellProofTime = fallbackToOsakaCellProofTimeIfKnown(big.NewInt(33), math.MaxUint64) + require.Equal(t, uint64(18446744073709551615), cellProofTime) +} diff --git a/op-service/txmgr/test_txmgr.go b/op-service/txmgr/test_txmgr.go index 6d5c00d8834..9b885711d1d 100644 --- a/op-service/txmgr/test_txmgr.go +++ b/op-service/txmgr/test_txmgr.go @@ -52,7 +52,7 @@ func (m *TestTxManager) makeStuckTx(ctx context.Context, candidate TxCandidate) var sidecar *types.BlobTxSidecar var blobHashes []common.Hash if len(candidate.Blobs) > 0 { - if sidecar, blobHashes, err = MakeSidecar(candidate.Blobs, m.cfg.EnableCellProofs); err != nil { + if sidecar, blobHashes, err = MakeSidecar(candidate.Blobs, false); err != nil { return nil, err } } diff --git a/op-service/txmgr/txmgr.go b/op-service/txmgr/txmgr.go index 35ee2aaacce..cac9ca891e3 100644 --- a/op-service/txmgr/txmgr.go +++ b/op-service/txmgr/txmgr.go @@ -364,8 +364,14 @@ func (m *SimpleTxManager) craftTx(ctx context.Context, candidate TxCandidate) (* if candidate.To == nil { return nil, errors.New("blob txs cannot deploy contracts") } - // Use configuration to determine whether to enable cell proofs - if sidecar, blobHashes, err = MakeSidecar(candidate.Blobs, m.cfg.EnableCellProofs); err != nil { + + // Use configuration to determine whether to enable cell proofs. + // We add a 12s buffer, because cell proofs are likely _not_ + // supported before the Fusaka fork and legacy blob proofs + // may well be accepted after the Fusaka fork. + useCellProofs := m.cfg.CellProofTime < uint64(time.Now().Add(-12*time.Second).Unix()) + m.l.Debug("crafting Blob transaction", "useCellProofs", useCellProofs) + if sidecar, blobHashes, err = MakeSidecar(candidate.Blobs, useCellProofs); err != nil { return nil, fmt.Errorf("failed to make sidecar: %w", err) } } diff --git a/op-service/txmgr/txmgr_test.go b/op-service/txmgr/txmgr_test.go index 84747bf436e..652576f401b 100644 --- a/op-service/txmgr/txmgr_test.go +++ b/op-service/txmgr/txmgr_test.go @@ -5,6 +5,7 @@ import ( "crypto/rand" "errors" "fmt" + "math" "math/big" "sync" "testing" @@ -116,6 +117,7 @@ func configWithNumConfs(numConfirmations uint64) *Config { From: common.Address{}, RetryInterval: 1 * time.Millisecond, MaxRetries: 5, + CellProofTime: math.MaxUint64, } cfg.RebroadcastInterval.Store(int64(time.Second / 2)) From 9c985875685f42b916150127e0fa058bf32a2aad Mon Sep 17 00:00:00 2001 From: George Knee Date: Fri, 10 Oct 2025 15:39:01 +0100 Subject: [PATCH 041/117] acceptance-tests: force batcher to use cell proofs in osaka test (#17818) --- op-acceptance-tests/tests/osaka/osaka_test.go | 1 + 1 file changed, 1 insertion(+) diff --git a/op-acceptance-tests/tests/osaka/osaka_test.go b/op-acceptance-tests/tests/osaka/osaka_test.go index eabd454749b..f534bef9169 100644 --- a/op-acceptance-tests/tests/osaka/osaka_test.go +++ b/op-acceptance-tests/tests/osaka/osaka_test.go @@ -86,6 +86,7 @@ func TestMain(m *testing.M) { }), sysgo.WithBatcherOption(func(_ stack.L2BatcherID, cfg *batcher.CLIConfig) { cfg.DataAvailabilityType = flags.BlobsType + cfg.TxMgrConfig.CellProofTime = 0 // Force cell proofs to be used }), ))) } From 35b724552c7ca5ec6498f738da51d2e9a958125b Mon Sep 17 00:00:00 2001 From: Changwan Park Date: Sat, 11 Oct 2025 00:13:08 +0900 Subject: [PATCH 042/117] op-{sync-tester|devstack}: Support multiple EL Sync Runs (#17800) * op-{sync-tester|devstack} Support multiple EL Sync Runs * op-acceptance-tests: Increase Unsafe payload signaling for window policy * op-sync-tester: Async Set Canonical When EL Sync done * op-devstack: Enable Engine API for SyncTesterEL * op-acceptance-tests: Multiple EL Sync Runs for SyncTesterEL * op-sync-tester: Reorganize Default EL Sync Policy * op-sync-tester: ELSyncPolicy godoc and better initialization * op-sync-tester: WindowSyncPolicy unit tests * op-acceptance-tests: Comment for EL Sync Policy --- .../sync_tester_elsync/elsync_test.go | 30 +-- .../sync_tester_elsync/init_test.go | 2 +- .../sync_tester_elsync_multi/init_test.go | 24 +++ .../sync_tester_elsync_multi/sync_test.go | 78 ++++++++ .../sync_tester_ext_el_test.go | 7 +- .../sync_tester_hfs_ext_test.go | 7 +- op-devstack/presets/sync_tester_config.go | 3 +- op-devstack/sysgo/l2_el_synctester.go | 12 +- op-service/eth/synctester_session.go | 43 +++-- .../synctester/backend/elsync/el_sync.go | 89 +++++++++ .../synctester/backend/elsync/el_sync_test.go | 171 ++++++++++++++++++ .../synctester/backend/sync_tester.go | 56 +++--- op-sync-tester/synctester/middleware.go | 19 +- op-sync-tester/synctester/middleware_test.go | 21 +-- 14 files changed, 462 insertions(+), 100 deletions(-) create mode 100644 op-acceptance-tests/tests/sync_tester/sync_tester_elsync_multi/init_test.go create mode 100644 op-acceptance-tests/tests/sync_tester/sync_tester_elsync_multi/sync_test.go create mode 100644 op-sync-tester/synctester/backend/elsync/el_sync.go create mode 100644 op-sync-tester/synctester/backend/elsync/el_sync_test.go diff --git a/op-acceptance-tests/tests/sync_tester/sync_tester_elsync/elsync_test.go b/op-acceptance-tests/tests/sync_tester/sync_tester_elsync/elsync_test.go index 4de948305c5..82d6d9e4f01 100644 --- a/op-acceptance-tests/tests/sync_tester/sync_tester_elsync/elsync_test.go +++ b/op-acceptance-tests/tests/sync_tester/sync_tester_elsync/elsync_test.go @@ -6,6 +6,7 @@ import ( "github.com/ethereum-optimism/optimism/op-devstack/devtest" "github.com/ethereum-optimism/optimism/op-devstack/dsl" "github.com/ethereum-optimism/optimism/op-devstack/presets" + "github.com/ethereum-optimism/optimism/op-service/eth" "github.com/ethereum-optimism/optimism/op-supervisor/supervisor/types" ) @@ -16,10 +17,11 @@ func TestSyncTesterELSync(gt *testing.T) { logger := t.Logger() ctx := t.Ctx() - target := uint64(5) + startDelta := uint64(5) + attempts := 30 dsl.CheckAll(t, - sys.L2CL.AdvancedFn(types.LocalUnsafe, target, 30), - sys.L2CL2.AdvancedFn(types.LocalUnsafe, target, 30), + sys.L2CL.AdvancedFn(types.LocalUnsafe, startDelta, attempts), + sys.L2CL2.AdvancedFn(types.LocalUnsafe, startDelta, attempts), ) // Stop L2CL2 attached to Sync Tester EL Endpoint @@ -33,10 +35,14 @@ func TestSyncTesterELSync(gt *testing.T) { syncTesterClient := sys.SyncTester.Escape().APIWithSession(sessionID) require.NoError(syncTesterClient.ResetSession(ctx)) + // Reseted and L2CL2 not connected to sync tester session so unsafe head will not advance + require.Equal(uint64(0), sys.SyncTesterL2EL.BlockRefByLabel(eth.Unsafe).Number) + // Wait for L2CL to advance more unsafe blocks - sys.L2CL.Advanced(types.LocalUnsafe, target+5, 30) + delta := uint64(5) + sys.L2CL.Advanced(types.LocalUnsafe, startDelta+delta, attempts) - // EL Sync not done yet + // EL Sync active session, err := syncTesterClient.GetSession(ctx) require.NoError(err) require.True(session.ELSyncActive) @@ -47,13 +53,13 @@ func TestSyncTesterELSync(gt *testing.T) { // Wait until P2P is connected sys.L2CL2.IsP2PConnected(sys.L2CL) - // Reaches EL Sync Target and advances - target = uint64(40) - sys.L2CL2.Reached(types.LocalUnsafe, target, 30) - - session, err = syncTesterClient.GetSession(ctx) - require.NoError(err) - require.False(session.ELSyncActive) + // Sequencer EL and SyncTester EL advances together + target := sys.L2EL.BlockRefByLabel(eth.Unsafe).Number + 5 + dsl.CheckAll(t, + sys.L2CL2.ReachedFn(types.LocalUnsafe, target, attempts), + // EL Sync complete + sys.SyncTesterL2EL.ReachedFn(eth.Unsafe, target, attempts), + ) // Check CL2 view is consistent with read only EL unsafeHead := sys.L2CL2.SyncStatus().UnsafeL2 diff --git a/op-acceptance-tests/tests/sync_tester/sync_tester_elsync/init_test.go b/op-acceptance-tests/tests/sync_tester/sync_tester_elsync/init_test.go index 3b90eb66724..8125324daba 100644 --- a/op-acceptance-tests/tests/sync_tester/sync_tester_elsync/init_test.go +++ b/op-acceptance-tests/tests/sync_tester/sync_tester_elsync/init_test.go @@ -11,7 +11,7 @@ func TestMain(m *testing.M) { presets.DoMain(m, presets.WithExecutionLayerSyncOnVerifiers(), presets.WithSimpleWithSyncTester(), - presets.WithELSyncTarget(35), + presets.WithELSyncActive(), presets.WithCompatibleTypes(compat.SysGo), ) } diff --git a/op-acceptance-tests/tests/sync_tester/sync_tester_elsync_multi/init_test.go b/op-acceptance-tests/tests/sync_tester/sync_tester_elsync_multi/init_test.go new file mode 100644 index 00000000000..18563be5dfd --- /dev/null +++ b/op-acceptance-tests/tests/sync_tester/sync_tester_elsync_multi/init_test.go @@ -0,0 +1,24 @@ +package multi + +import ( + "testing" + + bss "github.com/ethereum-optimism/optimism/op-batcher/batcher" + "github.com/ethereum-optimism/optimism/op-devstack/compat" + "github.com/ethereum-optimism/optimism/op-devstack/presets" + "github.com/ethereum-optimism/optimism/op-devstack/stack" + "github.com/ethereum-optimism/optimism/op-devstack/sysgo" +) + +func TestMain(m *testing.M) { + presets.DoMain(m, + presets.WithExecutionLayerSyncOnVerifiers(), + presets.WithSimpleWithSyncTester(), + presets.WithELSyncActive(), + presets.WithCompatibleTypes(compat.SysGo), + stack.MakeCommon(sysgo.WithBatcherOption(func(id stack.L2BatcherID, cfg *bss.CLIConfig) { + // For stopping derivation, not to advance safe heads + cfg.Stopped = true + })), + ) +} diff --git a/op-acceptance-tests/tests/sync_tester/sync_tester_elsync_multi/sync_test.go b/op-acceptance-tests/tests/sync_tester/sync_tester_elsync_multi/sync_test.go new file mode 100644 index 00000000000..b8ae7dcd2c2 --- /dev/null +++ b/op-acceptance-tests/tests/sync_tester/sync_tester_elsync_multi/sync_test.go @@ -0,0 +1,78 @@ +package multi + +import ( + "testing" + + "github.com/ethereum-optimism/optimism/op-devstack/devtest" + "github.com/ethereum-optimism/optimism/op-devstack/presets" + "github.com/ethereum-optimism/optimism/op-service/eth" + "github.com/ethereum-optimism/optimism/op-supervisor/supervisor/types" +) + +func TestMultiELSync(gt *testing.T) { + t := devtest.SerialT(gt) + sys := presets.NewSimpleWithSyncTester(t) + require := t.Require() + + // Stop L2CL2 to control SyncTesterL2EL manually + sys.L2CL2.Stop() + + // Advance few blocks to make sure reference node advanced + sys.L2CL.Advanced(types.LocalUnsafe, 10, 30) + + // Manually trigger multiple EL Syncs using the engine API + startNum := sys.SyncTesterL2EL.BlockRefByLabel(eth.Unsafe).Number + + // Sync Tester will track all unsafe payloads which can not be appended to unsafe head + // Sync Tester will use the WindowSyncPolicy, and mocks completion of EL Sync when the consecutive + // payloads were previously observed + + targetNum := startNum + 5 + // Invoke consecutive FCU calls to mock L2CL2 behavior: + // L2CL2 will unsafe payloads from the sequencer and do newPayload, FCU call + // L2CL2 will push consecutive unsafe payloads, assuming sequencer sent payloads arrived in order + + // First Run of EL Sync: Scenario: Mock op-node with consecutive newPayload + FCU calls + // Start with targetNum-2=startNum + 3 to trigger EL Sync. SyncTesterEL unsafe head=startNum + sys.SyncTesterL2EL.NewPayload(sys.L2EL, targetNum-2).IsSyncing() + sys.SyncTesterL2EL.ForkchoiceUpdate(sys.L2EL, targetNum-2, 0, 0, nil).IsSyncing() + // Window filled: [startNum+3] + + sys.SyncTesterL2EL.NewPayload(sys.L2EL, targetNum-1).IsSyncing() + sys.SyncTesterL2EL.ForkchoiceUpdate(sys.L2EL, targetNum-1, 0, 0, nil).IsSyncing() + // Window filled: [startNum+3,startNum+4] + + // Consecutive window size(two) payloads were FCUed + // Sync Tester will mock by advancing the non canonical chain to make the next newPayload return VALID + sys.SyncTesterL2EL.NewPayload(sys.L2EL, targetNum).IsValid() + sys.SyncTesterL2EL.ForkchoiceUpdate(sys.L2EL, targetNum, 0, 0, nil).IsValid() + // EL Sync Completed to targetNum + + require.Equal(targetNum, sys.L2EL.BlockRefByHash(sys.SyncTesterL2EL.BlockRefByLabel(eth.Unsafe).Hash).Number) + + // Second Run of EL Sync: Scenario: Manaul FCU, different with engine API pattern + // Start with targetNum-2=startNum+8 to trigger EL Sync. SyncTesterEL unsafe head=startNum+5 + targetNum = startNum + 10 + sys.SyncTesterL2EL.NewPayload(sys.L2EL, targetNum-2).IsSyncing() + sys.SyncTesterL2EL.ForkchoiceUpdate(sys.L2EL, targetNum-2, 0, 0, nil).IsSyncing() + // Window filled: [targetNum+8] + + sys.SyncTesterL2EL.NewPayload(sys.L2EL, targetNum-1).IsSyncing() + sys.SyncTesterL2EL.ForkchoiceUpdate(sys.L2EL, targetNum-1, 0, 0, nil).IsSyncing() + // Window filled: [startNum+8,startNum+9] + + // Consecutive window size(two) payloads were FCUed + // Sync Tester will mock by advancing the non canonical chain to make the next newPayload return VALID + // If we call FCU targeting startNum again, it will return VALID, canonicalizing + sys.SyncTesterL2EL.ForkchoiceUpdate(sys.L2EL, targetNum-1, 0, 0, nil).IsValid() + + // Next call with newPayload, FCU will also VALID because the payload may be directly appended to the unsafe head + sys.SyncTesterL2EL.NewPayload(sys.L2EL, targetNum).IsValid() + sys.SyncTesterL2EL.ForkchoiceUpdate(sys.L2EL, targetNum, 0, 0, nil).IsValid() + + require.Equal(targetNum, sys.L2EL.BlockRefByHash(sys.SyncTesterL2EL.BlockRefByLabel(eth.Unsafe).Hash).Number) + + t.Cleanup(func() { + sys.L2CL2.Start() + }) +} diff --git a/op-acceptance-tests/tests/sync_tester/sync_tester_ext_el/sync_tester_ext_el_test.go b/op-acceptance-tests/tests/sync_tester/sync_tester_ext_el/sync_tester_ext_el_test.go index 28bdae54492..adb8366db00 100644 --- a/op-acceptance-tests/tests/sync_tester/sync_tester_ext_el/sync_tester_ext_el_test.go +++ b/op-acceptance-tests/tests/sync_tester/sync_tester_ext_el/sync_tester_ext_el_test.go @@ -98,7 +98,10 @@ func TestSyncTesterExtEL(gt *testing.T) { // After EL Sync is finished, the FCU state will advance to target immediately so less attempts attempts = 5 // Signal L2CL for triggering EL Sync - sys.L2CL.SignalTarget(sys.L2ELReadOnly, target) + // Must send consecutive three payloads due to default EL Sync policy + for i := 2; i >= 0; i-- { + sys.L2CL.SignalTarget(sys.L2ELReadOnly, target-uint64(i)) + } } // Test that we can get sync status from L2CL node @@ -219,7 +222,7 @@ func setupOrchestrator(gt *testing.T, t devtest.T, blocksToSync uint64) (*sysgo. } opt = stack.Combine(opt, presets.WithExecutionLayerSyncOnVerifiers(), - presets.WithELSyncTarget(target), + presets.WithELSyncActive(), presets.WithSyncTesterELInitialState(eth.FCUState{ Latest: initial, Safe: 0, diff --git a/op-acceptance-tests/tests/sync_tester/sync_tester_hfs_ext/sync_tester_hfs_ext_test.go b/op-acceptance-tests/tests/sync_tester/sync_tester_hfs_ext/sync_tester_hfs_ext_test.go index 1cb2a8dadf5..d58268b2079 100644 --- a/op-acceptance-tests/tests/sync_tester/sync_tester_hfs_ext/sync_tester_hfs_ext_test.go +++ b/op-acceptance-tests/tests/sync_tester/sync_tester_hfs_ext/sync_tester_hfs_ext_test.go @@ -191,7 +191,7 @@ func setupOrchestrator(gt *testing.T, t devtest.T, blk, targetBlock uint64, l2CL } opt = stack.Combine(opt, presets.WithExecutionLayerSyncOnVerifiers(), - presets.WithELSyncTarget(targetBlock), + presets.WithELSyncActive(), presets.WithSyncTesterELInitialState(eth.FCUState{ Latest: blk, Safe: 0, @@ -256,7 +256,10 @@ func hfsExt(gt *testing.T, upgradeName rollup.ForkName, l2CLSyncMode sync.Mode) // After EL Sync is finished, the FCU state will advance to target immediately so less attempts attempts = 5 // Signal L2CL for finishing EL Sync - sys.L2CL.SignalTarget(sys.L2ELReadOnly, targetBlock) + // Must send consecutive three payloads due to default EL Sync policy + for i := 2; i >= 0; i-- { + sys.L2CL.SignalTarget(sys.L2ELReadOnly, targetBlock-uint64(i)) + } } else { l2CLSyncStatus := sys.L2CL.WaitForNonZeroUnsafeTime(t.Ctx()) require.Less(l2CLSyncStatus.UnsafeL2.Time, *ft, "L2CL unsafe time should be less than fork timestamp before upgrade") diff --git a/op-devstack/presets/sync_tester_config.go b/op-devstack/presets/sync_tester_config.go index 8687952a005..08220e38e93 100644 --- a/op-devstack/presets/sync_tester_config.go +++ b/op-devstack/presets/sync_tester_config.go @@ -15,11 +15,10 @@ func WithSyncTesterELInitialState(fcu eth.FCUState) stack.CommonOption { }))) } -func WithELSyncTarget(elSyncTarget uint64) stack.CommonOption { +func WithELSyncActive() stack.CommonOption { return stack.MakeCommon( sysgo.WithGlobalSyncTesterELOption(sysgo.SyncTesterELOptionFn( func(_ devtest.P, id stack.L2ELNodeID, cfg *sysgo.SyncTesterELConfig) { cfg.ELSyncActive = true - cfg.ELSyncTarget = elSyncTarget }))) } diff --git a/op-devstack/sysgo/l2_el_synctester.go b/op-devstack/sysgo/l2_el_synctester.go index 5ee34116b08..7da5a13d10f 100644 --- a/op-devstack/sysgo/l2_el_synctester.go +++ b/op-devstack/sysgo/l2_el_synctester.go @@ -38,13 +38,12 @@ type SyncTesterEL struct { type SyncTesterELConfig struct { FCUState eth.FCUState ELSyncActive bool - ELSyncTarget uint64 } func (cfg *SyncTesterELConfig) Path() string { path := fmt.Sprintf("?latest=%d&safe=%d&finalized=%d", cfg.FCUState.Latest, cfg.FCUState.Safe, cfg.FCUState.Finalized) if cfg.ELSyncActive { - path += fmt.Sprintf("&el_sync_target=%d", cfg.ELSyncTarget) + path += "&el_sync_active=true" } return path } @@ -53,7 +52,6 @@ func DefaultSyncTesterELConfig() *SyncTesterELConfig { return &SyncTesterELConfig{ FCUState: eth.FCUState{Latest: 0, Safe: 0, Finalized: 0}, ELSyncActive: false, - ELSyncTarget: 0, } } @@ -96,6 +94,11 @@ func (n *SyncTesterEL) hydrate(system stack.ExtensibleSystem) { require.NoError(err) system.T().Cleanup(rpcCl.Close) + // Sync Tester EL is always writable, and needs no auth + engineCl, err := client.NewRPC(system.T().Ctx(), system.Logger(), n.authRPC) + require.NoError(err) + system.T().Cleanup(engineCl.Close) + l2Net := system.L2Network(stack.L2NetworkID(n.id.ChainID())) sysL2EL := shim.NewL2ELNode(shim.L2ELNodeConfig{ RollupCfg: l2Net.RollupConfig(), @@ -104,7 +107,8 @@ func (n *SyncTesterEL) hydrate(system stack.ExtensibleSystem) { Client: rpcCl, ChainID: n.id.ChainID(), }, - ID: n.id, + EngineClient: engineCl, + ID: n.id, }) sysL2EL.SetLabel(match.LabelVendor, "sync-tester") l2Net.(stack.ExtensibleL2Network).AddL2ELNode(sysL2EL) diff --git a/op-service/eth/synctester_session.go b/op-service/eth/synctester_session.go index 4cb4f937770..b76dc3b5658 100644 --- a/op-service/eth/synctester_session.go +++ b/op-service/eth/synctester_session.go @@ -11,6 +11,23 @@ type FCUState struct { Finalized uint64 `json:"finalized"` } +// ELSyncPolicy defines the policy for determining the synchronization status +// of the execution layer (EL) during EL Sync, as triggered exclusively by +// ForkchoiceUpdated (FCU) calls. +// +// In the EL Sync process, the consensus layer (CL) notifies the EL of the +// current head via FCU. The EL then evaluates its internal sync state and +// reports whether it is still syncing or fully in sync. An ELSyncPolicy +// implementation encapsulates this decision logic. +// +// The purpose of this interface is to provide a configurable or mockable +// strategy for how the EL responds to FCU-triggered sync checks—useful in +// testing, simulation, or devnet environments where the real EL behavior +// needs to be emulated. +type ELSyncPolicy interface { + ELSyncStatus(num uint64) ExecutePayloadStatus +} + type SyncTesterSession struct { sync.Mutex @@ -23,11 +40,10 @@ type SyncTesterSession struct { // payloads Payloads map[PayloadID]*ExecutionPayloadEnvelope `json:"-"` - ELSyncTarget uint64 `json:"el_sync_target"` - ELSyncActive bool `json:"el_sync_active"` + ELSyncPolicy ELSyncPolicy `json:"-"` + ELSyncActive bool `json:"el_sync_active"` - InitialState FCUState `json:"initial_state"` - InitialELSyncActive bool `json:"initial_el_sync_active"` + InitialState FCUState `json:"initial_state"` } func (s *SyncTesterSession) UpdateFCULatest(latest uint64) { @@ -42,23 +58,17 @@ func (s *SyncTesterSession) UpdateFCUFinalized(finalized uint64) { s.CurrentState.Finalized = finalized } -func (s *SyncTesterSession) FinishELSync(target uint64) { - s.ELSyncActive = false - s.Validated = target -} - -func (s *SyncTesterSession) IsELSyncFinished() bool { - return !s.ELSyncActive -} - func (s *SyncTesterSession) ResetSession() { s.CurrentState = s.InitialState s.Validated = s.InitialState.Latest s.Payloads = make(map[PayloadID]*ExecutionPayloadEnvelope) - s.ELSyncActive = s.InitialELSyncActive } -func NewSyncTesterSession(sessionID string, latest, safe, finalized, elSyncTarget uint64, elSyncActive bool) *SyncTesterSession { +func (s *SyncTesterSession) IsELSyncActive() bool { + return s.ELSyncActive +} + +func NewSyncTesterSession(sessionID string, latest, safe, finalized uint64, elSyncActive bool, elSyncState ELSyncPolicy) *SyncTesterSession { return &SyncTesterSession{ SessionID: sessionID, Validated: latest, @@ -68,13 +78,12 @@ func NewSyncTesterSession(sessionID string, latest, safe, finalized, elSyncTarge Finalized: finalized, }, Payloads: make(map[PayloadID]*ExecutionPayloadEnvelope), - ELSyncTarget: elSyncTarget, ELSyncActive: elSyncActive, + ELSyncPolicy: elSyncState, InitialState: FCUState{ Latest: latest, Safe: safe, Finalized: finalized, }, - InitialELSyncActive: elSyncActive, } } diff --git a/op-sync-tester/synctester/backend/elsync/el_sync.go b/op-sync-tester/synctester/backend/elsync/el_sync.go new file mode 100644 index 00000000000..9c6ba525e69 --- /dev/null +++ b/op-sync-tester/synctester/backend/elsync/el_sync.go @@ -0,0 +1,89 @@ +package elsync + +import ( + "fmt" + "slices" + + "github.com/ethereum-optimism/optimism/op-service/eth" +) + +var _ eth.ELSyncPolicy = (*WindowSyncPolicy)(nil) + +// WindowSyncPolicy implements eth.ELSyncPolicy by maintaining a sliding window +// of recently observed payload numbers (block heights) and determining when the +// execution layer (EL) should be considered fully synced. +// +// Conceptually, the policy tracks the most recent payload numbers in a sorted, +// duplicate-free cache. When a new payload number is reported, it is inserted +// into the cache while removing any entries greater than or equal to it - +// simulating a reorg or an out-of-order unsafe payload insertion. The cache size +// is capped by maxSize. +// +// The EL is considered SYNCING until the following conditions are met: +// 1. At least cnt payload numbers have been observed, and +// 2. The last cnt numbers in the cache form a consecutive sequence ending +// exactly at the most recent number. +// +// Once both conditions hold, ELSyncStatus(num) returns ExecutionValid. +// Otherwise, it returns ExecutionSyncing. +// +// Example: +// +// With cnt=3 and maxSize=5, the policy reports SYNCING until it has seen +// three consecutive payloads (for example 10, 11, 12). After that, it reports +// VALID for subsequent payloads unless a reorg or out-of-order insertion +// causes the cache to break the consecutive sequence. +type WindowSyncPolicy struct { + cache []uint64 + cnt uint64 + maxSize uint64 +} + +func DefaultELSyncPolicy() eth.ELSyncPolicy { + return NewWindowSyncPolicy(2, 5) +} + +func NewWindowSyncPolicy(cnt, maxSize uint64) *WindowSyncPolicy { + if cnt == 0 || maxSize == 0 { + panic(fmt.Sprintf("cache max size: %d or window size: %d is not positive", maxSize, cnt)) + } + if cnt > maxSize { + panic(fmt.Sprintf("cache max size: %d less than window size: %d", maxSize, cnt)) + } + return &WindowSyncPolicy{cnt: cnt, maxSize: maxSize} +} + +func (e *WindowSyncPolicy) insertNum(num uint64) { + if len(e.cache) == 0 { + e.cache = append(e.cache, num) + return + } + maxNum := slices.Max(e.cache) + if maxNum >= num { + e.cache = slices.DeleteFunc(e.cache, func(v uint64) bool { + return v >= num + }) + } + e.cache = append(e.cache, num) + slices.Sort(e.cache) + if e.maxSize < uint64(len(e.cache)) { + e.cache = e.cache[1:] + } + // Invariant: cache is sorted, no duplicates and size not larger than maxSize +} + +func (e *WindowSyncPolicy) ELSyncStatus(num uint64) eth.ExecutePayloadStatus { + e.insertNum(num) + if uint64(len(e.cache)) < e.cnt { + return eth.ExecutionSyncing + } + if e.cache[len(e.cache)-1] != num { + return eth.ExecutionSyncing + } + for i := range e.cnt { + if e.cache[uint64(len(e.cache))-1-i] != num-i { + return eth.ExecutionSyncing + } + } + return eth.ExecutionValid +} diff --git a/op-sync-tester/synctester/backend/elsync/el_sync_test.go b/op-sync-tester/synctester/backend/elsync/el_sync_test.go new file mode 100644 index 00000000000..e73d76a59da --- /dev/null +++ b/op-sync-tester/synctester/backend/elsync/el_sync_test.go @@ -0,0 +1,171 @@ +package elsync + +import ( + "fmt" + "testing" + + "github.com/ethereum-optimism/optimism/op-service/eth" + "github.com/stretchr/testify/require" +) + +func runStatuses(p eth.ELSyncPolicy, nums ...uint64) []eth.ExecutePayloadStatus { + out := make([]eth.ExecutePayloadStatus, 0, len(nums)) + for _, n := range nums { + out = append(out, p.ELSyncStatus(n)) + } + return out +} + +func TestWindowSyncPolicy_NewWindowSyncPolicy_PanicsOnInvalidArgs(t *testing.T) { + tests := []struct { + name string + cnt uint64 + maxSize uint64 + wantSubstring string + }{ + { + name: "cnt greater than maxSize", + cnt: uint64(3), + maxSize: uint64(2), + wantSubstring: "less than window size", + }, + { + name: "cnt is zero", + cnt: uint64(0), + maxSize: uint64(5), + wantSubstring: "not positive", + }, + { + name: "maxSize is zero", + cnt: uint64(2), + maxSize: uint64(0), + wantSubstring: "not positive", + }, + { + name: "both zero", + cnt: uint64(0), + maxSize: uint64(0), + wantSubstring: "not positive", + }, + } + + for _, tc := range tests { + t.Run(tc.name, func(t *testing.T) { + defer func() { + r := recover() + require.NotNil(t, r, "expected panic") + require.Contains(t, fmt.Sprint(r), tc.wantSubstring) + }() + NewWindowSyncPolicy(tc.cnt, tc.maxSize) + }) + } +} + +func TestWindowSyncPolicy_MonotonicConsecutive_DefaultCnt2(t *testing.T) { + p := DefaultELSyncPolicy() + + // Need two consecutive observations ending at current num to become VALID. + got := runStatuses(p, 10, 11, 12) + require.Equal(t, []eth.ExecutePayloadStatus{ + eth.ExecutionSyncing, // only 10 observed + eth.ExecutionValid, // [10,11] consecutive window ending at 11 + eth.ExecutionValid, // [11,12] consecutive window ending at 12 + }, got) +} + +func TestWindowSyncPolicy_GapThenFill_Cnt3(t *testing.T) { + p := NewWindowSyncPolicy(3, 5) + + // 10 -> SYNC, 12 -> SYNC (gap), 11 -> still SYNC (len < 3), + // 12 -> now have [10,11,12] ending at 12 => VALID + got := runStatuses(p, 10, 12, 11, 12) + require.Equal(t, []eth.ExecutePayloadStatus{ + eth.ExecutionSyncing, + eth.ExecutionSyncing, + eth.ExecutionSyncing, + eth.ExecutionValid, + }, got) +} + +func TestWindowSyncPolicy_Reorg_DropGreaterOrEqual_Current(t *testing.T) { + p := NewWindowSyncPolicy(2, 5) + + // Build up to 12 => VALID, then reorg to 9 (drop >= 9) => SYNC, + // then 10 => VALID with window [9,10]. + got := runStatuses(p, 10, 11, 12, 9, 10) + require.Equal(t, []eth.ExecutePayloadStatus{ + eth.ExecutionSyncing, // 10 + eth.ExecutionValid, // 11 + eth.ExecutionValid, // 12 + eth.ExecutionSyncing, // 9 (reorg down) + eth.ExecutionValid, // 10 [9,10] + }, got) +} + +func TestWindowSyncPolicy_Duplicates_DoNotAdvance(t *testing.T) { + p := NewWindowSyncPolicy(2, 5) + + // Duplicate 10 should not create validity; need 11 next. + got := runStatuses(p, 10, 10, 11) + require.Equal(t, []eth.ExecutePayloadStatus{ + eth.ExecutionSyncing, + eth.ExecutionSyncing, // duplicate doesn't satisfy window [9,10] or [10,11] + eth.ExecutionValid, // 11 with prior 10 + }, got) +} + +func TestWindowSyncPolicy_MaxSizeTrimming_DoesNotBreakValidity(t *testing.T) { + p := NewWindowSyncPolicy(3, 3) // window == maxSize + + // 5,6,7 => VALID at 7 (have [5,6,7]) + // 8 => cache should trim oldest (effectively [6,7,8]), still VALID + got := runStatuses(p, 5, 6, 7, 8) + require.Equal(t, []eth.ExecutePayloadStatus{ + eth.ExecutionSyncing, // 5 + eth.ExecutionSyncing, // 6 + eth.ExecutionValid, // 7 (have 5,6,7) + eth.ExecutionValid, // 8 (have 6,7,8 after trim) + }, got) +} + +func TestWindowSyncPolicy_LongerRun_StabilityAcrossAdvances(t *testing.T) { + p := NewWindowSyncPolicy(3, 5) + seq := []uint64{100, 101, 102, 103, 104} + want := []eth.ExecutePayloadStatus{ + eth.ExecutionSyncing, // 100 + eth.ExecutionSyncing, // 101 + eth.ExecutionValid, // 102 + eth.ExecutionValid, // 103 + eth.ExecutionValid, // 104 + } + require.Equal(t, want, runStatuses(p, seq...)) +} + +func TestWindowSyncPolicy_Cnt1_AlwaysValidAfterSingleObservation(t *testing.T) { + p := NewWindowSyncPolicy(1, 5) + + // With cnt=1, a single observation of the current head is enough to be VALID, + // regardless of gaps or reorg-like regressions. + got := runStatuses(p, 10, 12, 11, 50, 49) + require.Equal(t, []eth.ExecutePayloadStatus{ + eth.ExecutionValid, // 10 + eth.ExecutionValid, // 12 + eth.ExecutionValid, // 11 + eth.ExecutionValid, // 50 + eth.ExecutionValid, // 49 + }, got) +} + +func TestWindowSyncPolicy_MaxSize1_WithCnt1(t *testing.T) { + p := NewWindowSyncPolicy(1, 1) + + // Cache can only hold the last number, but with cnt=1 that's sufficient. + got := runStatuses(p, 5, 6, 4, 4, 7) + require.Equal(t, []eth.ExecutePayloadStatus{ + eth.ExecutionValid, // 5 + eth.ExecutionValid, // 6 + eth.ExecutionValid, // 4 (reorg-like; still VALID with cnt=1) + eth.ExecutionValid, // 4 (duplicate) + eth.ExecutionValid, // 7 + }, got) +} diff --git a/op-sync-tester/synctester/backend/sync_tester.go b/op-sync-tester/synctester/backend/sync_tester.go index 3dc2e18ea44..9e217eded0b 100644 --- a/op-sync-tester/synctester/backend/sync_tester.go +++ b/op-sync-tester/synctester/backend/sync_tester.go @@ -357,12 +357,33 @@ func (s *SyncTester) forkchoiceUpdated(ctx context.Context, session *eth.SyncTes // Consider as sync error if read only EL interaction fails because we cannot validate return ð.ForkchoiceUpdatedResult{PayloadStatus: eth.PayloadStatusV1{Status: eth.ExecutionSyncing}, PayloadID: nil}, nil } - if candLatest.NumberU64() > session.Validated { - // Let CL backfill via newPayload - return ð.ForkchoiceUpdatedResult{PayloadStatus: eth.PayloadStatusV1{Status: eth.ExecutionSyncing}, PayloadID: nil}, nil + candLatestNum := candLatest.NumberU64() + if session.Validated < candLatestNum { + if !session.IsELSyncActive() { + // Let CL backfill via newPayload + return ð.ForkchoiceUpdatedResult{PayloadStatus: eth.PayloadStatusV1{Status: eth.ExecutionSyncing}, PayloadID: nil}, nil + } + switch session.ELSyncPolicy.ELSyncStatus(candLatestNum) { + case eth.ExecutionValid: + // EL Sync complete so advance non canonical chain first + session.Validated = candLatestNum + logger.Info("Non canonical chain advanced because of EL Sync", "validated", session.Validated) + // Equivalent to SetCanonical + session.UpdateFCULatest(session.Validated) + logger.Info("Canonical chain advanced because of EL Sync", "latest", session.CurrentState.Latest) + // Still return SYNCING to mimic the asynchronous EL behavior + // The EL will eventually return VALID with the identical unsafe target with the next FCU call + return ð.ForkchoiceUpdatedResult{PayloadStatus: eth.PayloadStatusV1{Status: eth.ExecutionSyncing}, PayloadID: nil}, nil + case eth.ExecutionSyncing: + logger.Trace("EL Sync on progress", "target", candLatestNum) + return ð.ForkchoiceUpdatedResult{PayloadStatus: eth.PayloadStatusV1{Status: eth.ExecutionSyncing}, PayloadID: nil}, nil + default: + logger.Warn("EL Sync failure", "target", candLatestNum) + return ð.ForkchoiceUpdatedResult{PayloadStatus: eth.PayloadStatusV1{Status: eth.ExecutionInvalid}, PayloadID: nil}, fmt.Errorf("EL Sync failure with target block %d:%s", candLatest.NumberU64(), candLatest.Hash()) + } } // Equivalent to SetCanonical - session.UpdateFCULatest(candLatest.NumberU64()) + session.UpdateFCULatest(candLatestNum) logger.Debug("Updated FCU State", "latest", session.CurrentState.Latest) // Simulate db check for finalized head if state.FinalizedBlockHash != (common.Hash{}) { @@ -399,9 +420,8 @@ func (s *SyncTester) forkchoiceUpdated(ctx context.Context, session *eth.SyncTes var id *engine.PayloadID if attr != nil { // attr is the ingredient for the block built after the head block - candNum := int64(candLatest.NumberU64()) // Query read only EL to fetch block which is desired to be produced from attr - newBlock, err := s.elReader.GetBlockByNumber(ctx, rpc.BlockNumber(candNum+1)) + newBlock, err := s.elReader.GetBlockByNumber(ctx, rpc.BlockNumber(int64(candLatestNum)+1)) if err != nil { // Consider as sync error if read only EL interaction fails because we cannot validate return ð.ForkchoiceUpdatedResult{PayloadStatus: eth.PayloadStatusV1{Status: eth.ExecutionSyncing}, PayloadID: nil}, nil @@ -723,31 +743,11 @@ func (s *SyncTester) newPayload(ctx context.Context, session *eth.SyncTesterSess session.Validated += 1 logger.Debug("Advanced non canonical chain", "validated", session.Validated) } - if !session.IsELSyncFinished() && session.Validated == session.ELSyncTarget { - // Can reach here when not doing EL Sync on CL side but session is configured for EL Sync - logger.Debug("Non canonical chain reached EL Sync target", "validated", session.Validated) - session.FinishELSync(session.Validated) - } // https://github.com/ethereum/execution-apis/blob/584905270d8ad665718058060267061ecfd79ca5/src/engine/paris.md#payload-validation // Spec: If validation succeeds, the response MUST contain {status: VALID, latestValidHash: payload.blockHash} return ð.PayloadStatusV1{Status: eth.ExecutionValid, LatestValidHash: &blockHash}, nil - } else if !session.IsELSyncFinished() { - if blockNumber == session.ELSyncTarget { - logger.Debug("Attempting to finish EL Sync on non canonical chain", "target", session.ELSyncTarget) - if status, err := s.validatePayload(logger, isCanyon, isIsthmus, block, payload, beaconRoot); status != nil { - return status, err - } - session.FinishELSync(blockNumber) - logger.Debug("Finished EL Sync by advancing non canonical chain", "validated", session.Validated) - // https://github.com/ethereum/execution-apis/blob/584905270d8ad665718058060267061ecfd79ca5/src/engine/paris.md#payload-validation - // Spec: If validation succeeds, the response MUST contain {status: VALID, latestValidHash: payload.blockHash} - return ð.PayloadStatusV1{Status: eth.ExecutionValid, LatestValidHash: &blockHash}, nil - } else if blockNumber < session.ELSyncTarget { - logger.Trace("EL Sync on progress", "target", blockNumber) - } else if blockNumber > session.ELSyncTarget { - // L2CL may never reach the EL Sync Target because the current number may keep increasing - logger.Warn("Received payload which has larger block number than EL Sync target", "current", blockNumber, "target", session.ELSyncTarget) - } + } else { + logger.Debug("Received payload which cannot be used to extend non canonical chain", "current", blockNumber, "validated", session.Validated) } // Block not available so mark as syncing return ð.PayloadStatusV1{Status: eth.ExecutionSyncing}, nil diff --git a/op-sync-tester/synctester/middleware.go b/op-sync-tester/synctester/middleware.go index 522e37c0022..dc915a1ac75 100644 --- a/op-sync-tester/synctester/middleware.go +++ b/op-sync-tester/synctester/middleware.go @@ -8,15 +8,15 @@ import ( "strings" "github.com/ethereum-optimism/optimism/op-service/eth" + "github.com/ethereum-optimism/optimism/op-sync-tester/synctester/backend/elsync" "github.com/ethereum-optimism/optimism/op-sync-tester/synctester/backend/session" "github.com/google/uuid" ) var ErrInvalidSessionIDFormat = errors.New("invalid UUID") var ErrInvalidParams = errors.New("invalid param") -var ErrInvalidELSyncTarget = errors.New("invalid el sync target") -const ELSyncTargetKey = "el_sync_target" +const ELSyncActiveKey = "el_sync_active" func IsValidSessionID(sessionID string) error { u, err := uuid.Parse(sessionID) @@ -75,18 +75,9 @@ func parseSession(r *http.Request) (*http.Request, error) { if err != nil { return r, err } - elSyncTarget, err := parseParam(ELSyncTargetKey) - if err != nil { - return r, err - } - elSyncActive := false - if elSyncTarget != 0 { - if elSyncTarget < latest { - return r, ErrInvalidELSyncTarget - } - elSyncActive = true - } - sess := eth.NewSyncTesterSession(sessionID, latest, safe, finalized, elSyncTarget, elSyncActive) + elSyncActive := query.Get(ELSyncActiveKey) == "true" + elSyncState := elsync.DefaultELSyncPolicy() // May be configurable + sess := eth.NewSyncTesterSession(sessionID, latest, safe, finalized, elSyncActive, elSyncState) ctx := session.WithSyncTesterSession(r.Context(), sess) // remove uuid path for routing r.URL.Path = "/" + strings.Join(segments[:3], "/") diff --git a/op-sync-tester/synctester/middleware_test.go b/op-sync-tester/synctester/middleware_test.go index f37968ce2b9..7e4a9f95f08 100644 --- a/op-sync-tester/synctester/middleware_test.go +++ b/op-sync-tester/synctester/middleware_test.go @@ -3,7 +3,6 @@ package synctester import ( "net/http" "net/url" - "strconv" "testing" "github.com/ethereum-optimism/optimism/op-service/eth" @@ -64,11 +63,11 @@ func TestParseSession_DefaultsToZero(t *testing.T) { require.Equal(t, session.InitialState, session.CurrentState) } -func TestParseSession_ELSyncTarget(t *testing.T) { +func TestParseSession_ELSyncActive(t *testing.T) { id := uuid.New().String() query := url.Values{} - elSyncTarget := uint64(4) - query.Set(ELSyncTargetKey, strconv.Itoa(int(elSyncTarget))) + elSyncTarget := "true" + query.Set(ELSyncActiveKey, elSyncTarget) req := newRequest("/chain/1/synctest/"+id, query) @@ -86,7 +85,6 @@ func TestParseSession_ELSyncTarget(t *testing.T) { require.Equal(t, session.InitialState.Latest, session.Validated) require.Equal(t, session.InitialState, session.CurrentState) require.True(t, session.ELSyncActive) - require.Equal(t, session.ELSyncTarget, elSyncTarget) } func TestParseSession_NoSessionInitialized(t *testing.T) { @@ -115,16 +113,3 @@ func TestParseSession_InvalidQueryParam(t *testing.T) { _, err := parseSession(req) require.ErrorIs(t, err, ErrInvalidParams) } - -func TestParseSession_InvalidELSyncTarget(t *testing.T) { - id := uuid.New().String() - query := url.Values{} - latest := 4 - elSyncTarget := latest - 1 - query.Set(eth.Unsafe, strconv.Itoa(latest)) - query.Set(ELSyncTargetKey, strconv.Itoa(elSyncTarget)) - - req := newRequest("/chain/1/synctest/"+id, query) - _, err := parseSession(req) - require.ErrorIs(t, err, ErrInvalidELSyncTarget) -} From dfdf2923b5cd97e7ac65ab3b856f7ec840028bc6 Mon Sep 17 00:00:00 2001 From: Ariel Diaz <65925295+aliersh@users.noreply.github.com> Date: Fri, 10 Oct 2025 17:55:34 -0400 Subject: [PATCH 043/117] docs(ai-eng): update documentation for contract test maintenance system (#17820) * docs(ai-eng): document contract test maintenance system - add ai-eng and contracts-test-maintenance READMEs - add comprehensive operational runbook (601 lines) - cross-reference Notion docs (design doc, tech spec) * docs(ai-eng): remove external notion documentation references * docs(ai-eng): improve documentation clarity and add direct links * docs(ai-eng): update graphite status to active --- ops/ai-eng/README.md | 64 +++ .../contracts-test-maintenance/README.md | 122 ++++ .../docs/runbook.md | 519 +++++++++++++++++- 3 files changed, 690 insertions(+), 15 deletions(-) create mode 100644 ops/ai-eng/README.md create mode 100644 ops/ai-eng/contracts-test-maintenance/README.md diff --git a/ops/ai-eng/README.md b/ops/ai-eng/README.md new file mode 100644 index 00000000000..b134143a72a --- /dev/null +++ b/ops/ai-eng/README.md @@ -0,0 +1,64 @@ +# AI Engineering Tools + +> Collection of AI-driven automation systems for Optimism engineering workflows + +## Overview + +This directory contains AI-powered tools designed to automate and improve engineering processes across the Optimism monorepo. Each project uses AI to handle repetitive tasks, maintain code quality, and enhance developer productivity. + +## Projects + +### 🧪 [Contract Test Maintenance](contracts-test-maintenance/) + +Automated system for maintaining and improving Solidity test coverage in `contracts-bedrock`. + +- **Purpose**: Identify stale tests and improve coverage using AI +- **Status**: ✅ Active - Runs twice weekly +- **Tech**: Python + Devin AI API +- **Docs**: + - [README](contracts-test-maintenance/README.md) - Overview and quick start + - [Runbook](contracts-test-maintenance/docs/runbook.md) - Operational guide + +**Quick Start**: +```bash +just ai-contracts-test +``` + +### 💎 [Graphite Code Review](graphite/) + +AI-powered code review rules for Solidity files in pull requests. + +- **Purpose**: Automated PR reviews following project standards +- **Status**: ✅ Active +- **Tech**: Graphite + Diamond +- **Docs**: [graphite/rules.md](graphite/rules.md) + +## Adding New Projects + +When adding a new AI-driven engineering tool: + +1. Create a new directory: `ai-eng/your-project/` +2. Add project documentation: `your-project/README.md` +3. Update this file with project details +4. Add relevant commands to [justfile](justfile) +5. Follow existing patterns for CI integration + +## Philosophy + +These tools are designed to: +- ✅ **Automate repetitive tasks** that don't require human creativity +- ✅ **Maintain quality standards** consistently across the codebase +- ✅ **Free up engineering time** for high-value work +- ✅ **Run primarily in CI** with optional local execution for testing + +## Support + +Each project has its own documentation and support channels. See individual project READMEs for details. + +**General Questions**: Contact EVM Safety Team + +--- + +**Maintainer**: EVM Safety Team +**Projects**: 2 active + diff --git a/ops/ai-eng/contracts-test-maintenance/README.md b/ops/ai-eng/contracts-test-maintenance/README.md new file mode 100644 index 00000000000..c306be96ca3 --- /dev/null +++ b/ops/ai-eng/contracts-test-maintenance/README.md @@ -0,0 +1,122 @@ +# AI Contract Test Maintenance System + +> Automated system for maintaining and improving Solidity test coverage in `contracts-bedrock` using AI-powered analysis. + +## What It Does + +Automatically identifies stale test files and uses Devin AI to improve test quality, coverage, and organization. Runs twice weekly (Monday/Thursday) in CircleCI. + +**Three-Stage Pipeline**: +1. **Test Ranking** → Analyzes all available test files, calculates staleness scores +2. **Prompt Rendering** → Generates AI instructions for highest-priority test +3. **Devin Execution** → AI improves tests and creates PR + +## Quick Start + +### Running the System + +**Automatic (CI)** - No action needed, runs on schedule + +**Manual Trigger** - CircleCI UI: +1. Trigger Pipeline → ethereum-optimism/optimism +2. Set: `ai_contracts_test_dispatch: true`, `main_dispatch: false` + +**Local Testing** - For development only: +```bash +cd ops/ai-eng +just ai-contracts-test # Full pipeline +just rank # Test ranking only +``` + +> 📖 **Full usage instructions**: [Runbook - Usage](docs/runbook.md#usage) + +## Available Commands + +Commands available via `just` from `ops/ai-eng` directory: + +```bash +# Contract Test Maintenance +just rank # Rank tests by staleness +just render # Generate AI prompt +just devin # Execute with Devin +just ai-contracts-test # Full pipeline +``` + +> See [justfile](../justfile) for complete command list + +### Output + +- **PRs**: Branch `ai/improve-[contract-name]-coverage` with test improvements +- **Logs**: `log.json` with execution details (also in CircleCI artifacts) +- **Artifacts**: CircleCI stores logs for 30 days + +## Key Features + +- ✅ Smart prioritization using staleness scoring +- ✅ Duplicate prevention (2-week cooldown) +- ✅ Resilient session monitoring with retry logic +- ✅ Full audit trail in CI artifacts + +## Documentation + +| Document | Purpose | Location | +|----------|---------|----------| +| **[🛠️ Runbook](docs/runbook.md)** | Operational guide and troubleshooting | Repository | +| **[🎯 Prompt Template](prompt/prompt.md)** | AI instructions (~2000 lines) | Repository | +| **[⚙️ Exclusion Config](exclusion.toml)** | Configure excluded tests | Repository | + +### Quick Links + +**Operational Guide**: +- [CI Integration](docs/runbook.md#ci-integration) - How it runs in CircleCI +- [Configuration](docs/runbook.md#configuration) - Exclusions and scoring +- [Monitoring](docs/runbook.md#monitoring-and-debugging) - Check system health +- [Troubleshooting](docs/runbook.md#troubleshooting-guide) - Common issues +- [Maintenance](docs/runbook.md#maintenance) - Update prompts/exclusions + +## Configuration + +**Exclude Tests** - Edit `exclusion.toml`: +```toml +[exclusions] +directories = ["test/invariants/", "test/scripts/"] +files = ["test/vendor/Initializable.t.sol"] +``` + +**Environment** - CI contexts provide credentials automatically. For local testing, see [Runbook - Prerequisites](docs/runbook.md#prerequisites). + +## Monitoring + +**Latest Run**: +```bash +cat log.json | jq . +``` + +**CircleCI**: [View pipelines](https://app.circleci.com/pipelines/github/ethereum-optimism/optimism?branch=develop) → Find `ai-contracts-test-workflow` → Check `ai-contracts-test` job artifacts and console output + +**GitHub PRs**: [View AI-generated PRs](https://github.com/ethereum-optimism/optimism/pulls?q=is%3Aopen+is%3Apr+author%3Aapp%2Fdevin-ai-integration) + +> 📊 **Detailed monitoring**: [Runbook - Monitoring](docs/runbook.md#monitoring-and-debugging) + +## Troubleshooting + +**Common Issues**: +- No tests ranked → Check `exclusion.toml`, see [runbook](docs/runbook.md#no-tests-ranked) +- Session stuck → Check Devin dashboard, see [runbook](docs/runbook.md#devin-session-stuck-in-running) +- Tests fail after improvements → Review PR diff, see [runbook](docs/runbook.md#tests-fail-after-devin-improvements) + +> 🔧 **Full troubleshooting guide**: [Runbook - Troubleshooting](docs/runbook.md#troubleshooting-guide) + +## Support + +1. Check the [runbook](docs/runbook.md) +2. Review `log.json` and CircleCI artifacts +3. Contact EVM Safety Team + +--- + +**Status**: ✅ Active +**Schedule**: Monday & Thursday +**Maintainer**: EVM Safety Team +**Version**: 1.0.0 + diff --git a/ops/ai-eng/contracts-test-maintenance/docs/runbook.md b/ops/ai-eng/contracts-test-maintenance/docs/runbook.md index 3a8a37e3c30..6d39f30312b 100644 --- a/ops/ai-eng/contracts-test-maintenance/docs/runbook.md +++ b/ops/ai-eng/contracts-test-maintenance/docs/runbook.md @@ -1,25 +1,145 @@ -# AI Contract Test Maintenance System +# AI Contract Test Maintenance System - Runbook + +> **Operational guide** for using and maintaining the system. ## Overview -The AI Contract Test Maintenance System analyzes Solidity test files in the `contracts-bedrock` package and ranks them based on staleness metrics. It compares git commit timestamps between test files and their corresponding source contracts to identify which tests need attention most urgently. +The AI Contract Test Maintenance System is an automated CI workflow that identifies stale Solidity test files in the `contracts-bedrock` package and uses the Devin AI API to improve them. It ranks tests based on staleness metrics by comparing git commit timestamps between test files and their corresponding source contracts. + +The system uses a **two-branch scoring algorithm**: +- Tests whose contracts have moved ahead receive priority based on staleness days +- Up-to-date tests are ranked by age to ensure continuous coverage rotation + +### Key Features + +- **Automated CI Integration**: Runs twice weekly on schedule (Monday/Thursday) or on-demand +- **Smart Prioritization**: Focuses on tests that are most out of sync with their contracts +- **Duplicate Prevention**: Automatically excludes recently processed files (last 2 weeks) +- **Resilient Monitoring**: Handles long-running Devin sessions with retry logic +- **Full Audit Trail**: All runs logged with complete traceability + +## Architecture + +### System Components + +``` +contracts-test-maintenance/ +├── VERSION # System version +├── exclusion.toml # Static exclusions configuration +├── log.jsonl # Execution history and results +├── prompt/ +│ └── prompt.md # AI instruction template (~2000 lines) +├── components/ +│ ├── tests_ranker/ # Stage 1: Test ranking +│ │ ├── test_ranker.py +│ │ └── output/{run_id}_ranking.json +│ ├── prompt-renderer/ # Stage 2: Prompt generation +│ │ ├── render.py +│ │ └── output/{run_id}_prompt.md +│ └── devin-api/ # Stage 3: AI execution +│ └── devin_client.py +└── docs/ + └── runbook.md # This document +``` + +### Three-Stage Pipeline + +1. **Test Ranking** (`test_ranker.py`): Discovers tests, maps to contracts, calculates staleness +2. **Prompt Rendering** (`render.py`): Fills template with highest-priority test/contract paths +3. **Devin Execution** (`devin_client.py`): Creates AI session, monitors progress, logs results + +## CI Integration + +### CircleCI Workflow + +The system is integrated into CircleCI via the `ai-contracts-test-workflow` workflow: + +**Trigger Conditions** (from `.circleci/config.yml`): +- **Scheduled**: Runs twice weekly on `build_mon_thu` schedule (Monday/Thursday) +- **Manual Dispatch**: Can be triggered via CircleCI UI or API (see Usage section for details) + - Set `ai_contracts_test_dispatch=true` to enable this workflow + - Set `main_dispatch=false` to prevent the main workflow from also running + +**Job Configuration**: +```yaml +ai-contracts-test: + resource_class: medium + docker: + - image: cimg/base:2024.01 + steps: + - checkout-from-workspace + - run: just ai-contracts-test + - store_artifacts: log.json +``` -The system uses a two-branch scoring algorithm: tests whose contracts have moved ahead receive priority based on staleness days, while up-to-date tests are ranked by age to ensure continuous coverage. +**Required Contexts**: +- `circleci-repo-readonly-authenticated-github-token`: For git operations +- `circleci-api-token`: For fetching previous run artifacts +- `devin-api`: Contains Devin API credentials + +### Viewing Results + +**In CircleCI**: +1. Navigate to the `ai-contracts-test` job +2. Check "Artifacts" tab for `log.json` +3. Review console output for run details + +**In GitHub**: +- Completed sessions create PRs with branch name: `ai/improve-[contract-name]-coverage` +- PRs include comprehensive test improvements and documentation ## Usage +### Automatic Execution (CI) + +The system runs automatically on schedule. No manual intervention needed. + +### Manual Execution + +**Local Testing** (from `ops/ai-eng/` directory): + +⚠️ **Note**: Local execution is for testing/debugging only. The system is designed to run in CI. + ```bash -# From the ai-eng directory +# Prerequisites: Create components/devin-api/.env with credentials +# (See Prerequisites section above) + +# Full pipeline just ai-contracts-test + +# Individual stages (for debugging) +just rank # Stage 1: Rank tests by staleness +just render # Stage 2: Generate prompt for highest-priority test +just devin # Stage 3: Execute with Devin API (creates real session!) ``` -Individual steps (for debugging): +**Manual CI Trigger**: + +**Option 1: CircleCI UI** (Recommended) +1. Navigate to CircleCI → ethereum-optimism/optimism +2. Click "Trigger Pipeline" (top right) +3. Select branch (usually `develop`) +4. Add parameters: + - `ai_contracts_test_dispatch`: `true` + - `main_dispatch`: `false` (⚠️ Important: prevents main workflow from running) +5. Click "Trigger Pipeline" + +**Option 2: CircleCI API** ```bash -just rank # Rank tests by staleness -just render # Generate prompt for highest-priority test -just devin # Execute with Devin API +curl -X POST https://circleci.com/api/v2/project/gh/ethereum-optimism/optimism/pipeline \ + -H "Circle-Token: $CIRCLE_TOKEN" \ + -H "Content-Type: application/json" \ + -d '{ + "branch": "develop", + "parameters": { + "ai_contracts_test_dispatch": true, + "main_dispatch": false + } + }' ``` +**Note**: Setting `main_dispatch: false` is important to run ONLY the AI contracts test workflow. Otherwise, the main workflow will also execute (since `main_dispatch` defaults to `true`). + ## Output ### Test Ranking Output @@ -66,12 +186,21 @@ The Devin API client (`components/devin-api/devin_client.py`) automatically: 1. **Finds the latest prompt** from the prompt renderer output 2. **Creates a Devin session** with the generated prompt -3. **Monitors the session** until completion ("blocked", "expired", or "finished") -4. **Logs results** to `log.jsonl` in the project root +3. **Monitors the session** until terminal state ("blocked", "expired", or "suspend_requested") +4. **Logs results** to `log.json` in the project root #### Prerequisites -Devin API credentials in `components/devin-api/.env` +**For CI (automatic execution)**: +- Credentials are provided via CircleCI context (`devin-api`) +- No local configuration needed + +**For local testing only**: +- Create `components/devin-api/.env` with: + ``` + DEVIN_API_KEY=your_key_here + DEVIN_API_BASE_URL=https://api.devin.ai/v1 + ``` #### Session Monitoring @@ -82,7 +211,7 @@ The client monitors Devin sessions with resilient error handling: #### Session Logging -All Devin sessions are automatically logged to `log.jsonl` with: +All Devin sessions are automatically logged to `log.json` with: ```json { @@ -108,7 +237,367 @@ All Devin sessions are automatically logged to `log.jsonl` with: #### Duplicate Prevention -The ranking system automatically excludes files processed in the **last 7 days** to prevent duplicate work: -- Files with status `finished`, `blocked`, or `failed` are temporarily excluded -- After 7 days, files become available for ranking again (aligns with PR auto-close policy) +The ranking system automatically excludes files processed in the **last 2 weeks** to prevent duplicate work: +- Queries CircleCI API for recent successful runs +- Extracts test paths from stored `log.json` artifacts +- Temporarily excludes these files from ranking +- Files become available again after 2 weeks - This prevents immediate re-ranking of files still under review + +## Configuration + +### Exclusion Rules (`exclusion.toml`) + +Configure which test files should be permanently excluded from ranking: + +```toml +[exclusions] +# Exclude entire directories +directories = [ + "test/invariants/", + "test/opcm/", + "test/scripts/", + "test/setup/" +] + +# Exclude specific files +files = [ + "test/L1/OPContractsManagerContractsContainer.t.sol", + "test/dispute/lib/LibClock.t.sol", + # ... more files +] +``` + +**Why exclude files?**: +- **Invariant tests**: Complex fuzzing tests requiring specialized approach +- **Scripts**: Deployment/utility scripts, not traditional unit tests +- **Setup helpers**: Infrastructure code without test coverage needs +- **OPCM tests**: Large integration tests handled separately + +### Scoring Algorithm + +The two-branch scoring algorithm prioritizes work: + +```python +if contract_is_newer_than_test: + score = staleness_days # Higher staleness = higher priority +else: + score = test_age_days # Older tests need refresh +``` + +**Example Scenarios**: +- Contract updated 30 days after test → `score = 30` (high priority) +- Test updated yesterday, contract older → `score = 1` (low priority) +- Test last touched 200 days ago → `score = 200` (rotation priority) + +### Environment Variables + +**In CI (from CircleCI contexts)**: +- `CIRCLE_API_TOKEN`: For fetching artifacts from previous runs (from `circleci-api-token` context) +- `DEVIN_API_KEY`: Devin API authentication (from `devin-api` context) +- `DEVIN_API_BASE_URL`: Devin API endpoint (from `devin-api` context) + +**For local testing only**: +- Set above variables in `components/devin-api/.env` file +- `CIRCLE_BRANCH` (optional): Branch to check for artifacts (defaults to `develop`) + +## Workflow Details + +### Stage 1: Test Ranking + +**Process**: +1. Scan `packages/contracts-bedrock/test/` for `*.t.sol` files +2. For each test file, find corresponding source contract: + - Try matching directory structure: `test/L1/Foo.t.sol` → `src/L1/Foo.sol` + - Fall back to recursive search in `src/` directory +3. Get git commit timestamps using `git log -1 --format=%ct` +4. Calculate staleness: `contract_commit_ts - test_commit_ts` +5. Calculate priority score using two-branch algorithm +6. Apply exclusions (static from `exclusion.toml` + dynamic from CircleCI) +7. Sort by score (descending) and output to JSON + +**Output Fields**: +- `test_path`: Relative path from `contracts-bedrock/` +- `contract_path`: Relative path from `contracts-bedrock/` +- `test_commit_ts`: Unix timestamp (seconds since epoch) +- `contract_commit_ts`: Unix timestamp (seconds since epoch) +- `staleness_days`: Float, positive = contract is newer +- `score`: Float, higher = more urgent attention needed + +### Stage 2: Prompt Rendering + +**Process**: +1. Load ranking JSON from Stage 1 output +2. Extract first entry (highest priority test) +3. Load prompt template from `prompt/prompt.md` +4. Replace placeholders: + - `{TEST_PATH}` → test file path + - `{CONTRACT_PATH}` → contract file path +5. Save rendered prompt to `output/` with same `run_id` + +**The Prompt Template** contains: +- Role definition and task instructions +- Comprehensive testing methodology (4 phases) +- Naming conventions for test contracts and functions +- Fuzz testing decision trees +- Organization rules (function-specific vs uncategorized) +- Error handling patterns and semgrep rules +- Validation requirements (`just pre-pr` must pass) +- PR submission guidelines + +### Stage 3: Devin Execution + +**Process**: +1. Find latest prompt file from Stage 2 +2. Create Devin session via POST to `/sessions` endpoint +3. Monitor session with polling: + - Poll every 30 seconds for status updates + - Implement exponential backoff for server errors (502/504) + - Continue monitoring until terminal state reached +4. Log results to `log.json` with full session details + +**Devin API Terminal States**: +- `blocked`: Devin reached a blocking state (e.g., needs approval, PR created) +- `expired`: Session timeout reached +- `suspend_requested` / `suspend_requested_frontend`: User manually stopped session + +**Logged Status Values** (what gets written to `log.json`): +- `finished`: Devin status was "blocked" AND PR was successfully created +- `blocked`: Devin status was "blocked" but no PR URL found +- `expired`: Session timed out +- Note: User-stopped sessions are not logged + +**Error Handling**: +- 30-second timeout per HTTP request +- Retry with exponential backoff: 1min → 2min → 4min → 8min +- Patient monitoring for long-running CI operations (30+ minutes) + +## Monitoring and Debugging + +### Checking System Health + +**Via CircleCI**: +```bash +# View recent runs +circleci job list gh/ethereum-optimism/optimism + +# Check specific workflow +circleci workflow get WORKFLOW_ID +``` + +**Via Log Files**: +```bash +# View latest execution +cat ops/ai-eng/contracts-test-maintenance/log.json | jq . + +# Note: Only the latest run is stored (file is overwritten each time) +# For historical data, check CircleCI artifacts +``` + +### Common Issues + +#### No tests ranked + +**Symptoms**: Ranking JSON has empty `entries` array + +**Causes**: +- All tests excluded via `exclusion.toml` (misconfiguration) +- No test files found in `packages/contracts-bedrock/test/` +- Test-to-contract mapping failed (contract files moved/renamed) + +**Resolution**: +1. Check exclusion rules in `exclusion.toml` for overly broad patterns +2. Verify `packages/contracts-bedrock/test/` contains `*.t.sol` files +3. Run `just rank` locally to see detailed output and errors +4. Check if contracts were recently reorganized/renamed + +#### Devin session stuck in "running" + +**Symptoms**: Session never reaches terminal state + +**Causes**: +- Devin internal issue +- Test improvements taking longer than expected +- Network connectivity problems + +**Resolution**: +1. Check Devin dashboard for session status +2. Review session console output for progress +3. Wait for automatic timeout (typically 2 hours) +4. Contact Devin support if persistent + +#### Tests fail after Devin improvements + +**Symptoms**: PR shows failing CI checks + +**Causes**: +- Test improvements introduced syntax errors +- Fuzz test constraints too restrictive +- Contract behavior misunderstood + +**Resolution**: +1. Review PR diff for obvious issues +2. Check test output logs in CI +3. Devin will automatically attempt fixes +4. Manual intervention may be needed for edge cases + +#### Duplicate work on same test + +**Symptoms**: Same test file processed multiple times in short period + +**Causes**: +- CircleCI artifact API failures +- Recent runs not yet stored artifacts +- Manual runs bypassing exclusion logic + +**Resolution**: +1. Verify `CIRCLE_API_TOKEN` is set correctly +2. Check CircleCI artifacts are being stored +3. Wait for cooldown period (2 weeks) + +### Debug Mode + +Run individual stages locally to debug: + +```bash +cd ops/ai-eng/contracts-test-maintenance + +# Stage 1: See what tests are ranked +cd components/tests_ranker +python3 test_ranker.py +cat output/*_ranking.json | jq '.entries[0:5]' # Top 5 + +# Stage 2: Check prompt rendering +cd ../prompt-renderer +python3 render.py +head -50 output/*_prompt.md # Preview prompt + +# Stage 3: Test Devin client (dry-run mode not available) +# Only run if you want to create a real session +cd ../devin-api +# python3 devin_client.py # Creates real session! +``` + +### Logs and Artifacts + +**Location of outputs**: +``` +ops/ai-eng/contracts-test-maintenance/ +├── log.json # Latest execution log (overwritten) +├── components/tests_ranker/output/ +│ └── {run_id}_ranking.json # Latest test ranking +└── components/prompt-renderer/output/ + └── {run_id}_prompt.md # Latest generated prompt +``` + +**In CircleCI**: +- Job artifacts include `log.json` for each run +- Stored for 30 days by default +- Accessible via CircleCI API or web UI + +## Maintenance + +### Updating the Prompt Template + +The prompt template (`prompt/prompt.md`) defines how Devin improves tests: + +1. Edit the template file +2. Test changes locally: `just rank && just render` +3. Review generated prompt in `components/prompt-renderer/output/` +4. Commit changes to the repository +5. **Test the changes**: + - **Option A**: Manually trigger a CI run (see "Manual CI Trigger" in Usage section) + - **Option B**: Wait for next scheduled run (Monday/Thursday) +6. Monitor first few PRs to validate improvements + +**Key sections to update**: +- Testing methodology phases +- Naming conventions +- Fuzz testing criteria +- Validation requirements + +### Adding Exclusions + +To permanently exclude tests from ranking: + +1. Edit `exclusion.toml` +2. Add to `directories` array (for entire directories) +3. Or add to `files` array (for specific files) +4. Commit changes - next run will use updated exclusions + +### Updating System Version + +When making significant changes: + +1. Update `VERSION` file +2. System version is logged in `log.json` +3. Helps track which system version processed each test + +## Troubleshooting Guide + +### System Not Running + +**Check**: Is the schedule active? +```bash +# View CircleCI schedules +circleci schedule list gh/ethereum-optimism/optimism develop +``` + +**Verify**: Are contexts configured? +- `devin-api` context must exist with API credentials +- `circleci-api-token` context must have valid token + +### No PRs Being Created + +**Possible causes**: +1. Devin sessions blocked/failed (check Devin dashboard) +2. All high-priority tests recently processed +3. Devin API credentials expired + +**Investigation**: +```bash +# Check latest run +cat log.json | jq . + +# For historical data, check CircleCI artifacts +# Navigate to past builds and download log.json artifacts +``` + +### Understanding Score Values + +**High scores (>100)**: +- Contract significantly newer than test (multiple months) +- Test hasn't been touched in a long time +- **Action**: Urgent attention needed + +**Medium scores (10-100)**: +- Recent changes to contract +- Test moderately out of date +- **Action**: Normal priority + +**Low scores (<10)**: +- Test recently updated +- Contract stable +- **Action**: Routine maintenance rotation + +## Related Documentation + +**Repository Files**: +- **Prompt Template**: `prompt/prompt.md` - Complete AI instructions (~2000 lines) +- **CI Configuration**: `.circleci/config.yml` - Workflow definition +- **Exclusion Config**: `exclusion.toml` - Static exclusion rules +- **Justfile**: `ops/ai-eng/justfile` - Command definitions + +## Support + +For issues or questions: +1. Check this runbook first +2. Review latest `log.json` entry +3. Check CircleCI job output and artifacts for historical data +4. Contact EVM Safety Team via standard channels + +## Notes + +- The system overwrites `log.json` on each run (only latest execution is stored locally) +- For execution history, access CircleCI artifacts (stored for 30 days) +- Old output files in `components/*/output/` are automatically cleaned up on each run From 1784818746995603f2ae91f609713bdc66c35c41 Mon Sep 17 00:00:00 2001 From: Stefano Charissis Date: Sat, 11 Oct 2025 20:04:34 +1100 Subject: [PATCH 044/117] fix(op-acceptance-tests): flake-shake; fix ci. (#17823) --- .circleci/config.yml | 1 - op-acceptance-tests/acceptance-tests.yaml | 9 ++------- op-acceptance-tests/justfile | 2 +- 3 files changed, 3 insertions(+), 9 deletions(-) diff --git a/.circleci/config.yml b/.circleci/config.yml index 33ee45f087e..21e017eef4f 100644 --- a/.circleci/config.yml +++ b/.circleci/config.yml @@ -1639,7 +1639,6 @@ jobs: machine: image: ubuntu-2404:current resource_class: large - circleci_ip_ranges: true parallelism: << pipeline.parameters.flake-shake-workers >> steps: - checkout-from-workspace diff --git a/op-acceptance-tests/acceptance-tests.yaml b/op-acceptance-tests/acceptance-tests.yaml index d11fc24f4b4..08731e222f1 100644 --- a/op-acceptance-tests/acceptance-tests.yaml +++ b/op-acceptance-tests/acceptance-tests.yaml @@ -17,19 +17,14 @@ gates: tests: - package: github.com/ethereum-optimism/optimism/op-acceptance-tests/tests/interop/proofs name: TestProposer - timeout: 10m + timeout: 30m metadata: owner: "axel,mofi" - package: github.com/ethereum-optimism/optimism/op-acceptance-tests/tests/interop/proofs name: TestChallengerPlaysGame - timeout: 10m + timeout: 30m metadata: owner: "axel,mofi" - - package: github.com/ethereum-optimism/optimism/op-acceptance-tests/tests/sync_tester/sync_tester_hfs_ext - name: TestSyncTesterHFS_Isthmus_ELSync - timeout: 10m - metadata: - owner: "changwan,anton" - package: github.com/ethereum-optimism/optimism/op-acceptance-tests/tests/osaka timeout: 15m owner: "josh" diff --git a/op-acceptance-tests/justfile b/op-acceptance-tests/justfile index afdf3d4bafd..0149d86782b 100644 --- a/op-acceptance-tests/justfile +++ b/op-acceptance-tests/justfile @@ -99,7 +99,7 @@ acceptance-test devnet="" gate="base": "--exclude-gates" "flake-shake" "--allow-skips" "--timeout" "90m" - "--default-timeout" "10m" + "--default-timeout" "30m" "--orchestrator" "$ORCHESTRATOR" "--show-progress" ) From cbc343dc798290f5148b4ebfdf25f1ab2920fd29 Mon Sep 17 00:00:00 2001 From: Sam Stokes <35908605+bitwiseguy@users.noreply.github.com> Date: Sat, 11 Oct 2025 13:40:04 -0400 Subject: [PATCH 045/117] fix(circleci): ensure contracts-bedrock-build runs in release workflow (#17822) --- .circleci/config.yml | 9 ++++++++- 1 file changed, 8 insertions(+), 1 deletion(-) diff --git a/.circleci/config.yml b/.circleci/config.yml index 21e017eef4f..966155a6b3b 100644 --- a/.circleci/config.yml +++ b/.circleci/config.yml @@ -2687,6 +2687,11 @@ workflows: - circleci-repo-readonly-authenticated-github-token requires: - initialize + filters: + tags: + only: /^op-deployer.*/ # ensure contract artifacts are embedded in op-deployer binary + branches: + ignore: /.*/ # Standard (medium) cross-platform docker images go here - docker-build: matrix: @@ -2694,6 +2699,7 @@ workflows: docker_name: - op-node - op-batcher + - op-deployer - op-faucet - op-proposer - op-challenger @@ -2703,7 +2709,6 @@ workflows: - op-ufm - op-supervisor - op-test-sequencer - - op-deployer - cannon - op-dripper - op-interop-mon @@ -2729,6 +2734,7 @@ workflows: op_component: - op-node - op-batcher + - op-deployer - op-faucet - op-proposer - op-challenger @@ -2746,6 +2752,7 @@ workflows: requires: - op-node-docker-release - op-batcher-docker-release + - op-deployer-docker-release - op-faucet-docker-release - op-proposer-docker-release - op-challenger-docker-release From 0c68e87b7e949801069292e8a5fd8106b21a36e0 Mon Sep 17 00:00:00 2001 From: Paul Dowman Date: Sun, 12 Oct 2025 14:35:37 -0600 Subject: [PATCH 046/117] op-dispute-mon: distinguish 404 from output root not found (#17819) --- .../mon/extract/output_agreement_enricher.go | 13 +++++++---- .../extract/output_agreement_enricher_test.go | 23 +++++++++++++++---- 2 files changed, 27 insertions(+), 9 deletions(-) diff --git a/op-dispute-mon/mon/extract/output_agreement_enricher.go b/op-dispute-mon/mon/extract/output_agreement_enricher.go index f58e00447a5..d733d815dee 100644 --- a/op-dispute-mon/mon/extract/output_agreement_enricher.go +++ b/op-dispute-mon/mon/extract/output_agreement_enricher.go @@ -14,6 +14,7 @@ import ( "github.com/ethereum-optimism/optimism/op-service/sources/batching/rpcblock" "github.com/ethereum/go-ethereum/common" "github.com/ethereum/go-ethereum/log" + "github.com/ethereum/go-ethereum/rpc" ) var ( @@ -77,10 +78,14 @@ func (o *OutputAgreementEnricher) Enrich(ctx context.Context, block rpcblock.Blo defer wg.Done() output, err := client.OutputAtBlock(ctx, game.L2BlockNumber) if err != nil { - // string match as the error comes from the remote server so we can't use Errors.Is sadly. - if strings.Contains(err.Error(), "not found") { - results[i] = outputResult{notFound: true} - return + // Only treat JSON-RPC application-level "not found" as notFound. + // Transport/HTTP errors or other failures should be treated as errors. + var rpcErr rpc.Error + if errors.As(err, &rpcErr) { + if strings.Contains(strings.ToLower(rpcErr.Error()), "not found") { + results[i] = outputResult{notFound: true} + return + } } results[i] = outputResult{err: err} return diff --git a/op-dispute-mon/mon/extract/output_agreement_enricher_test.go b/op-dispute-mon/mon/extract/output_agreement_enricher_test.go index 7f5aa58d64b..d5d59383fa8 100644 --- a/op-dispute-mon/mon/extract/output_agreement_enricher_test.go +++ b/op-dispute-mon/mon/extract/output_agreement_enricher_test.go @@ -16,6 +16,7 @@ import ( "github.com/ethereum-optimism/optimism/op-service/testlog" "github.com/ethereum/go-ethereum/common" "github.com/ethereum/go-ethereum/log" + "github.com/ethereum/go-ethereum/rpc" "github.com/stretchr/testify/require" ) @@ -101,7 +102,7 @@ func TestOutputAgreementEnricher(t *testing.T) { t.Run("AllNodesReturnNotFound", func(t *testing.T) { validator, clients, metrics := setupMultiNodeTest(t, 3) for _, client := range clients { - client.outputErr = errors.New("not found") + client.outputErr = mockNotFoundRPCError() } game := &types.EnrichedGameData{ L1HeadNum: 100, @@ -117,7 +118,7 @@ func TestOutputAgreementEnricher(t *testing.T) { t.Run("SomeNodesOutOfSync", func(t *testing.T) { validator, clients, metrics := setupMultiNodeTest(t, 3) - clients[0].outputErr = errors.New("not found") + clients[0].outputErr = mockNotFoundRPCError() clients[1].outputErr = nil clients[2].outputErr = nil game := &types.EnrichedGameData{ @@ -134,8 +135,8 @@ func TestOutputAgreementEnricher(t *testing.T) { t.Run("MixedResponses_FoundNodesMatchClaimAndSafe", func(t *testing.T) { validator, clients, metrics := setupMultiNodeTest(t, 4) - clients[0].outputErr = errors.New("not found") - clients[1].outputErr = errors.New("not found") + clients[0].outputErr = mockNotFoundRPCError() + clients[1].outputErr = mockNotFoundRPCError() clients[2].outputRoot = mockRootClaim clients[2].safeHeadNum = 100 clients[3].outputRoot = mockRootClaim @@ -155,7 +156,7 @@ func TestOutputAgreementEnricher(t *testing.T) { t.Run("MixedResponses_FoundNodesDontMatchClaim", func(t *testing.T) { validator, clients, metrics := setupMultiNodeTest(t, 3) differentRoot := common.HexToHash("0x9999") - clients[0].outputErr = errors.New("not found") + clients[0].outputErr = mockNotFoundRPCError() clients[1].outputRoot = differentRoot clients[2].outputRoot = differentRoot game := &types.EnrichedGameData{ @@ -300,6 +301,18 @@ func TestOutputAgreementEnricher(t *testing.T) { }) } +// mockNotFoundRPCError creates a minimal rpc.Error that reports a "not found" message +// to exercise the JSON-RPC application error path in the enricher. +func mockNotFoundRPCError() rpc.Error { return testRPCError{msg: "not found", code: -32000} } + +type testRPCError struct { + msg string + code int +} + +func (e testRPCError) Error() string { return e.msg } +func (e testRPCError) ErrorCode() int { return e.code } + func setupOutputValidatorTest(t *testing.T) (*OutputAgreementEnricher, *stubRollupClient, *stubOutputMetrics) { logger := testlog.Logger(t, log.LvlInfo) client := &stubRollupClient{safeHeadNum: 99999999999} From 2ab9b681a6d9e42e62c2d8ace13e2edaa640aae9 Mon Sep 17 00:00:00 2001 From: Sam Stokes <35908605+bitwiseguy@users.noreply.github.com> Date: Sun, 12 Oct 2025 22:00:51 -0400 Subject: [PATCH 047/117] op-deployer: fix, support, test upgrades up to v4.1.0 (#17824) * op-deployer: add upgrade v4_1_0 command (#17790) * update superchain-registry/validation import * op-deployer: fix upgrader.ArtifactsURL and add tests * op-service: add WithForkBlock opt to anvil * op-deployer: add cli level upgrade tests --- go.mod | 2 +- go.sum | 4 +- op-deployer/pkg/deployer/artifacts/locator.go | 8 ++ .../pkg/deployer/artifacts/locator_test.go | 8 ++ .../integration_test/cli/cli_runner.go | 37 ++++-- .../integration_test/cli/upgrade_test.go | 121 ++++++++++++++++++ op-deployer/pkg/deployer/standard/standard.go | 5 +- .../pkg/deployer/upgrade/embedded/upgrade.go | 22 ++++ op-deployer/pkg/deployer/upgrade/flags.go | 34 ++++- op-deployer/pkg/deployer/upgrade/upgrader.go | 11 +- .../pkg/deployer/upgrade/v2_0_0/upgrade.go | 4 +- .../pkg/deployer/upgrade/v3_0_0/upgrade.go | 4 +- .../pkg/deployer/upgrade/v4_0_0/upgrade.go | 4 +- .../pkg/deployer/upgrade/v4_1_0/upgrade.go | 25 ++++ op-service/testutils/devnet/anvil.go | 6 + op-service/testutils/devnet/canned.go | 8 ++ 16 files changed, 277 insertions(+), 26 deletions(-) create mode 100644 op-deployer/pkg/deployer/integration_test/cli/upgrade_test.go create mode 100644 op-deployer/pkg/deployer/upgrade/embedded/upgrade.go create mode 100644 op-deployer/pkg/deployer/upgrade/v4_1_0/upgrade.go diff --git a/go.mod b/go.mod index a445f5c01e3..5858aacfee4 100644 --- a/go.mod +++ b/go.mod @@ -21,7 +21,7 @@ require ( github.com/docker/docker v27.5.1+incompatible github.com/docker/go-connections v0.5.0 github.com/ethereum-optimism/go-ethereum-hdwallet v0.1.4-0.20251001155152-4eb15ccedf7e - github.com/ethereum-optimism/superchain-registry/validation v0.0.0-20250603144016-9c45ca7d4508 + github.com/ethereum-optimism/superchain-registry/validation v0.0.0-20251009180028-9b4658b9b7af github.com/ethereum/go-ethereum v1.16.3 github.com/fatih/color v1.18.0 github.com/fsnotify/fsnotify v1.9.0 diff --git a/go.sum b/go.sum index 49a8082e08b..c95d97fad2a 100644 --- a/go.sum +++ b/go.sum @@ -240,8 +240,8 @@ github.com/ethereum-optimism/go-ethereum-hdwallet v0.1.4-0.20251001155152-4eb15c github.com/ethereum-optimism/go-ethereum-hdwallet v0.1.4-0.20251001155152-4eb15ccedf7e/go.mod h1:DYj7+vYJ4cIB7zera9mv4LcAynCL5u4YVfoeUu6Wa+w= github.com/ethereum-optimism/op-geth v1.101603.1-rc.1 h1:qH+BM+AHrHFWPonJEpapmyo/LJhqj9/TGsRaWg4RCYg= github.com/ethereum-optimism/op-geth v1.101603.1-rc.1/go.mod h1:Ct2QjqZ2UKgvvgKLLYzoh/DBicJZB8DXsv45DgEjcco= -github.com/ethereum-optimism/superchain-registry/validation v0.0.0-20250603144016-9c45ca7d4508 h1:A/3QVFt+Aa9ozpPVXxUTLui8honBjSusAaiCVRbafgs= -github.com/ethereum-optimism/superchain-registry/validation v0.0.0-20250603144016-9c45ca7d4508/go.mod h1:NZ816PzLU1TLv1RdAvYAb6KWOj4Zm5aInT0YpDVml2Y= +github.com/ethereum-optimism/superchain-registry/validation v0.0.0-20251009180028-9b4658b9b7af h1:WWz0gJM/boaUImtJnROecPirAerKCLpAU4m6Tx0ArOg= +github.com/ethereum-optimism/superchain-registry/validation v0.0.0-20251009180028-9b4658b9b7af/go.mod h1:NZ816PzLU1TLv1RdAvYAb6KWOj4Zm5aInT0YpDVml2Y= github.com/ethereum/c-kzg-4844/v2 v2.1.0 h1:gQropX9YFBhl3g4HYhwE70zq3IHFRgbbNPw0Shwzf5w= github.com/ethereum/c-kzg-4844/v2 v2.1.0/go.mod h1:TC48kOKjJKPbN7C++qIgt0TJzZ70QznYR7Ob+WXl57E= github.com/ethereum/go-verkle v0.2.2 h1:I2W0WjnrFUIzzVPwm8ykY+7pL2d4VhlsePn4j7cnFk8= diff --git a/op-deployer/pkg/deployer/artifacts/locator.go b/op-deployer/pkg/deployer/artifacts/locator.go index 5c2c00e9789..9aa01e17082 100644 --- a/op-deployer/pkg/deployer/artifacts/locator.go +++ b/op-deployer/pkg/deployer/artifacts/locator.go @@ -15,6 +15,10 @@ var schemeUnmarshalerDispatch = map[string]schemeUnmarshaler{ "https": unmarshalURL, } +func CreateHttpLocator(contentHash string) string { + return fmt.Sprintf("https://storage.googleapis.com/oplabs-contract-artifacts/artifacts-v1-%s.tar.gz", contentHash) +} + const EmbeddedLocatorString = "embedded" var embeddedURL = &url.URL{ @@ -30,6 +34,10 @@ var DefaultL1ContractsLocator = EmbeddedLocator var DefaultL2ContractsLocator = EmbeddedLocator func NewLocatorFromURL(u string) (*Locator, error) { + if u == EmbeddedLocatorString { + return EmbeddedLocator, nil + } + parsedURL, err := url.Parse(u) if err != nil { return nil, fmt.Errorf("failed to parse URL: %w", err) diff --git a/op-deployer/pkg/deployer/artifacts/locator_test.go b/op-deployer/pkg/deployer/artifacts/locator_test.go index e8433b94082..7cb1d8ec8b3 100644 --- a/op-deployer/pkg/deployer/artifacts/locator_test.go +++ b/op-deployer/pkg/deployer/artifacts/locator_test.go @@ -38,6 +38,14 @@ func TestLocator_Marshaling(t *testing.T) { }, err: false, }, + { + name: "deprecated tag URL", + in: "tag://op-contracts/v4.1.0", + out: &Locator{ + URL: parseUrl(t, "tag://op-contracts/v4.1.0"), + }, + err: true, + }, { name: "empty", in: "", diff --git a/op-deployer/pkg/deployer/integration_test/cli/cli_runner.go b/op-deployer/pkg/deployer/integration_test/cli/cli_runner.go index 573c16482e0..ba783344824 100644 --- a/op-deployer/pkg/deployer/integration_test/cli/cli_runner.go +++ b/op-deployer/pkg/deployer/integration_test/cli/cli_runner.go @@ -21,31 +21,50 @@ type CLITestRunner struct { privateKeyHex string } -// NewCLITestRunner creates a new CLI test runner -func NewCLITestRunner(t *testing.T) *CLITestRunner { - // Create a temporary working directory for tests - workDir := t.TempDir() +// CLITestRunnerOption is a functional option for configuring CLITestRunner +type CLITestRunnerOption func(*CLITestRunner) + +func WithL1RPC(rpcURL string) CLITestRunnerOption { + return func(r *CLITestRunner) { + r.l1RPC = rpcURL + } +} + +func WithPrivateKey(pkHex string) CLITestRunnerOption { + return func(r *CLITestRunner) { + r.privateKeyHex = pkHex + } +} +func NewCLITestRunner(t *testing.T, opts ...CLITestRunnerOption) *CLITestRunner { + workDir := t.TempDir() return &CLITestRunner{ workDir: workDir, } } -// NewCLITestRunnerWithNetwork creates a new CLI test runner with network setup -func NewCLITestRunnerWithNetwork(t *testing.T) *CLITestRunner { +// NewCLITestRunnerWithNetwork creates a new CLI test runner with default network setup. +// Defaults can be overridden using functional options. +func NewCLITestRunnerWithNetwork(t *testing.T, opts ...CLITestRunnerOption) *CLITestRunner { workDir := t.TempDir() + // Set up defaults lgr := testlog.Logger(t, slog.LevelDebug) l1RPC, _ := devnet.DefaultAnvilRPC(t, lgr) - - // Get private key pkHex, _, _ := shared.DefaultPrivkey(t) - return &CLITestRunner{ + runner := &CLITestRunner{ workDir: workDir, l1RPC: l1RPC, privateKeyHex: pkHex, } + + // Apply options to override defaults + for _, opt := range opts { + opt(runner) + } + + return runner } // GetWorkDir returns the working directory for this test runner diff --git a/op-deployer/pkg/deployer/integration_test/cli/upgrade_test.go b/op-deployer/pkg/deployer/integration_test/cli/upgrade_test.go new file mode 100644 index 00000000000..2bed07db89a --- /dev/null +++ b/op-deployer/pkg/deployer/integration_test/cli/upgrade_test.go @@ -0,0 +1,121 @@ +package cli + +import ( + "encoding/hex" + "encoding/json" + "log/slog" + "os" + "path/filepath" + "strings" + "testing" + + "github.com/ethereum-optimism/optimism/op-deployer/pkg/deployer/broadcaster" + "github.com/ethereum-optimism/optimism/op-deployer/pkg/deployer/standard" + "github.com/ethereum-optimism/optimism/op-deployer/pkg/deployer/upgrade/v2_0_0" + "github.com/ethereum-optimism/optimism/op-service/testlog" + "github.com/ethereum-optimism/optimism/op-service/testutils/devnet" + "github.com/ethereum/go-ethereum/common" + "github.com/stretchr/testify/require" +) + +// TestCLIUpgrade tests the upgrade CLI command for each standard opcm release +// - forks sepolia at the block immediately after the opcm deployment block +// - runs the upgrade CLI command using op-sepolia values to simulate its upgrade +func TestCLIUpgrade(t *testing.T) { + lgr := testlog.Logger(t, slog.LevelDebug) + + // op-sepolia values + l1ProxyAdminOwner := common.HexToAddress("0x1Eb2fFc903729a0F03966B917003800b145F56E2") + systemConfigProxy := common.HexToAddress("0x034edD2A225f7f429A63E0f1D2084B9E0A93b538") + proxyAdminImpl := common.HexToAddress("0x189aBAAaa82DfC015A588A7dbaD6F13b1D3485Bc") + + testCases := []struct { + contractTag string + version string + forkBlock uint64 // one block number past the opcm deployment block + }{ + { + contractTag: standard.ContractsV200Tag, + version: "v2.0.0", + forkBlock: 7792843, + }, + //{ + //contractTag: standard.ContractsV300Tag, + //version: "v3.0.0", + //forkBlock: 7853303, + //}, + { + contractTag: standard.ContractsV400Tag, + version: "v4.0.0", + forkBlock: 8577263, + }, + { + contractTag: standard.ContractsV410Tag, + version: "v4.1.0", + forkBlock: 9165154, + }, + } + + for _, tc := range testCases { + t.Run(tc.contractTag, func(t *testing.T) { + forkedL1, stopL1, err := devnet.NewForkedSepoliaFromBlock(lgr, tc.forkBlock) + require.NoError(t, err) + t.Cleanup(func() { + require.NoError(t, stopL1()) + }) + + runner := NewCLITestRunnerWithNetwork(t, WithL1RPC(forkedL1.RPCUrl())) + workDir := runner.GetWorkDir() + + opcm, err := standard.OPCMImplAddressFor(11155111, tc.contractTag) + require.NoError(t, err) + + testConfig := v2_0_0.UpgradeOPChainInput{ + Prank: l1ProxyAdminOwner, + Opcm: opcm, + EncodedChainConfigs: []v2_0_0.OPChainConfig{ + { + SystemConfigProxy: systemConfigProxy, + ProxyAdmin: proxyAdminImpl, + AbsolutePrestate: common.HexToHash("0x0abc"), + }, + }, + } + + configFile := filepath.Join(workDir, "upgrade_config_"+tc.version+".json") + outputFile := filepath.Join(workDir, "upgrade_output_"+tc.version+".json") + + configData, err := json.MarshalIndent(testConfig, "", " ") + require.NoError(t, err) + require.NoError(t, os.WriteFile(configFile, configData, 0644)) + + // Run full cli command to write calldata to outfile + output := runner.ExpectSuccess(t, []string{ + "upgrade", tc.version, + "--config", configFile, + "--l1-rpc-url", runner.l1RPC, + "--outfile", outputFile, + }, nil) + + t.Logf("Command output (logs):\n%s", output) + + // Read and parse calldata from outfile + require.FileExists(t, outputFile) + data, err := os.ReadFile(outputFile) + require.NoError(t, err) + + var dump []broadcaster.CalldataDump + require.NoError(t, json.Unmarshal(data, &dump)) + + t.Logf("Upgrade %s generated calldata: %s", tc.version, string(data)) + + // Verify the calldata + require.Len(t, dump, 1) + require.Equal(t, l1ProxyAdminOwner.Hex(), dump[0].To.Hex()) + dataHex := hex.EncodeToString(dump[0].Data) + require.True(t, strings.HasPrefix(dataHex, "ff2dd5a1"), + "calldata should have opcm.upgrade fcn selector ff2dd5a1, got: %s", dataHex[:8]) + + }) + } +} diff --git a/op-deployer/pkg/deployer/standard/standard.go b/op-deployer/pkg/deployer/standard/standard.go index ffcbe2eeade..daa76d45a4d 100644 --- a/op-deployer/pkg/deployer/standard/standard.go +++ b/op-deployer/pkg/deployer/standard/standard.go @@ -41,7 +41,8 @@ const ( ContractsV200Tag = "op-contracts/v2.0.0" ContractsV300Tag = "op-contracts/v3.0.0" ContractsV400Tag = "op-contracts/v4.0.0-rc.7" - CurrentTag = ContractsV400Tag + ContractsV410Tag = "op-contracts/v4.1.0" + CurrentTag = ContractsV410Tag ) var DisputeAbsolutePrestate = common.HexToHash("0x038512e02c4c3f7bdaec27d00edf55b7155e0905301e1a88083e4e0a6764d54c") @@ -180,7 +181,7 @@ func DefaultHardforkScheduleForTag(tag string) *genesis.UpgradeScheduleDeployCon return sched case ContractsV180Tag, ContractsV200Tag, ContractsV300Tag: sched.ActivateForkAtGenesis(rollup.Holocene) - case ContractsV400Tag: + case ContractsV400Tag, ContractsV410Tag: sched.ActivateForkAtGenesis(rollup.Holocene) sched.ActivateForkAtGenesis(rollup.Isthmus) default: diff --git a/op-deployer/pkg/deployer/upgrade/embedded/upgrade.go b/op-deployer/pkg/deployer/upgrade/embedded/upgrade.go new file mode 100644 index 00000000000..eaa7bad52d4 --- /dev/null +++ b/op-deployer/pkg/deployer/upgrade/embedded/upgrade.go @@ -0,0 +1,22 @@ +package embedded + +import ( + "encoding/json" + + "github.com/ethereum-optimism/optimism/op-chain-ops/script" + "github.com/ethereum-optimism/optimism/op-deployer/pkg/deployer/artifacts" + v200 "github.com/ethereum-optimism/optimism/op-deployer/pkg/deployer/upgrade/v2_0_0" +) + +type Upgrader struct { +} + +func (u *Upgrader) Upgrade(host *script.Host, input json.RawMessage) error { + return v200.DefaultUpgrader.Upgrade(host, input) +} + +func (u *Upgrader) ArtifactsURL() string { + return artifacts.EmbeddedLocatorString +} + +var DefaultUpgrader = new(Upgrader) diff --git a/op-deployer/pkg/deployer/upgrade/flags.go b/op-deployer/pkg/deployer/upgrade/flags.go index 0382faf35f6..71bfdd916a2 100644 --- a/op-deployer/pkg/deployer/upgrade/flags.go +++ b/op-deployer/pkg/deployer/upgrade/flags.go @@ -2,9 +2,11 @@ package upgrade import ( "github.com/ethereum-optimism/optimism/op-deployer/pkg/deployer" + embedded "github.com/ethereum-optimism/optimism/op-deployer/pkg/deployer/upgrade/embedded" v200 "github.com/ethereum-optimism/optimism/op-deployer/pkg/deployer/upgrade/v2_0_0" v300 "github.com/ethereum-optimism/optimism/op-deployer/pkg/deployer/upgrade/v3_0_0" v400 "github.com/ethereum-optimism/optimism/op-deployer/pkg/deployer/upgrade/v4_0_0" + v410 "github.com/ethereum-optimism/optimism/op-deployer/pkg/deployer/upgrade/v4_1_0" oplog "github.com/ethereum-optimism/optimism/op-service/log" "github.com/urfave/cli/v2" ) @@ -18,6 +20,11 @@ var ( Name: "override-artifacts-url", Usage: "override the artifacts URL", } + OutfileFlag = &cli.StringFlag{ + Name: "outfile", + Usage: "path to write the output to, or - for stdout", + Value: "-", + } ) var Commands = cli.Commands{ @@ -28,6 +35,7 @@ var Commands = cli.Commands{ deployer.L1RPCURLFlag, ConfigFlag, OverrideArtifactsURLFlag, + OutfileFlag, }, oplog.CLIFlags(deployer.EnvVarPrefix)...), Action: UpgradeCLI(v200.DefaultUpgrader), }, @@ -38,17 +46,41 @@ var Commands = cli.Commands{ deployer.L1RPCURLFlag, ConfigFlag, OverrideArtifactsURLFlag, + OutfileFlag, }, oplog.CLIFlags(deployer.EnvVarPrefix)...), Action: UpgradeCLI(v300.DefaultUpgrader), }, &cli.Command{ Name: "v4.0.0", - Usage: "upgrades a chain to version v4.0.0", + Usage: "upgrades a chain to version v4.0.0 (U16)", Flags: append([]cli.Flag{ deployer.L1RPCURLFlag, ConfigFlag, OverrideArtifactsURLFlag, + OutfileFlag, }, oplog.CLIFlags(deployer.EnvVarPrefix)...), Action: UpgradeCLI(v400.DefaultUpgrader), }, + &cli.Command{ + Name: "v4.1.0", + Usage: "upgrades a chain to version v4.1.0 (U16a)", + Flags: append([]cli.Flag{ + deployer.L1RPCURLFlag, + ConfigFlag, + OverrideArtifactsURLFlag, + OutfileFlag, + }, oplog.CLIFlags(deployer.EnvVarPrefix)...), + Action: UpgradeCLI(v410.DefaultUpgrader), + }, + &cli.Command{ + Name: "embedded", + Usage: "upgrades a chain to version of contracts embedded in op-deployer", + Flags: append([]cli.Flag{ + deployer.L1RPCURLFlag, + ConfigFlag, + OverrideArtifactsURLFlag, + OutfileFlag, + }, oplog.CLIFlags(deployer.EnvVarPrefix)...), + Action: UpgradeCLI(embedded.DefaultUpgrader), + }, } diff --git a/op-deployer/pkg/deployer/upgrade/upgrader.go b/op-deployer/pkg/deployer/upgrade/upgrader.go index b60c368bce9..9c11f5c7a96 100644 --- a/op-deployer/pkg/deployer/upgrade/upgrader.go +++ b/op-deployer/pkg/deployer/upgrade/upgrader.go @@ -7,6 +7,7 @@ import ( "os" "github.com/ethereum-optimism/optimism/op-service/ioutil" + "github.com/ethereum-optimism/optimism/op-service/jsonutil" "github.com/ethereum-optimism/optimism/op-chain-ops/script" "github.com/ethereum-optimism/optimism/op-deployer/pkg/deployer" @@ -59,7 +60,7 @@ func UpgradeCLI(upgrader Upgrader) func(*cli.Context) error { artifactsFS, err := artifacts.Download(ctx, artifactsLocator, ioutil.BarProgressor(), cacheDir) if err != nil { - return fmt.Errorf("failed to download L1 artifacts: %w", err) + return fmt.Errorf("failed to download L1 artifacts: %w, url: %s", err, artifactsLocator) } host, err := env.DefaultForkedScriptHost( @@ -91,12 +92,12 @@ func UpgradeCLI(upgrader Upgrader) func(*cli.Context) error { return fmt.Errorf("failed to dump calldata: %w", err) } - enc := json.NewEncoder(os.Stdout) - enc.SetIndent("", " ") - if err := enc.Encode(dump); err != nil { - return fmt.Errorf("failed to encode calldata: %w", err) + outfile := cliCtx.String(OutfileFlag.Name) + if err := jsonutil.WriteJSON(dump, ioutil.ToStdOutOrFileOrNoop(outfile, 0o666)); err != nil { + return fmt.Errorf("failed to write output: %w", err) } + lgr.Info("Success! opcm.upgrade calldata created") return nil } } diff --git a/op-deployer/pkg/deployer/upgrade/v2_0_0/upgrade.go b/op-deployer/pkg/deployer/upgrade/v2_0_0/upgrade.go index d59326f1e4d..3124853628f 100644 --- a/op-deployer/pkg/deployer/upgrade/v2_0_0/upgrade.go +++ b/op-deployer/pkg/deployer/upgrade/v2_0_0/upgrade.go @@ -4,7 +4,7 @@ import ( "encoding/json" "fmt" - "github.com/ethereum-optimism/optimism/op-deployer/pkg/deployer/standard" + "github.com/ethereum-optimism/optimism/op-deployer/pkg/deployer/artifacts" "github.com/ethereum-optimism/optimism/op-chain-ops/script" "github.com/ethereum-optimism/optimism/op-deployer/pkg/deployer/opcm" @@ -53,7 +53,7 @@ func (u *Upgrader) Upgrade(host *script.Host, input json.RawMessage) error { } func (u *Upgrader) ArtifactsURL() string { - return "tag://" + standard.ContractsV200Tag + return artifacts.CreateHttpLocator("1cec51ed629c0394b8fb17ff2c6fa45c406c30f94ebbd37d4c90ede6c29ad608") } var DefaultUpgrader = new(Upgrader) diff --git a/op-deployer/pkg/deployer/upgrade/v3_0_0/upgrade.go b/op-deployer/pkg/deployer/upgrade/v3_0_0/upgrade.go index f99866bcfb7..3f1a8184a6e 100644 --- a/op-deployer/pkg/deployer/upgrade/v3_0_0/upgrade.go +++ b/op-deployer/pkg/deployer/upgrade/v3_0_0/upgrade.go @@ -7,7 +7,7 @@ import ( "encoding/json" "github.com/ethereum-optimism/optimism/op-chain-ops/script" - "github.com/ethereum-optimism/optimism/op-deployer/pkg/deployer/standard" + "github.com/ethereum-optimism/optimism/op-deployer/pkg/deployer/artifacts" v200 "github.com/ethereum-optimism/optimism/op-deployer/pkg/deployer/upgrade/v2_0_0" ) @@ -19,7 +19,7 @@ func (u *Upgrader) Upgrade(host *script.Host, input json.RawMessage) error { } func (u *Upgrader) ArtifactsURL() string { - return "tag://" + standard.ContractsV300Tag + return artifacts.CreateHttpLocator("147b9fae70608da2975a01be3d98948306f89ba1930af7c917eea41a54d87cdb") } var DefaultUpgrader = new(Upgrader) diff --git a/op-deployer/pkg/deployer/upgrade/v4_0_0/upgrade.go b/op-deployer/pkg/deployer/upgrade/v4_0_0/upgrade.go index fe54b75782e..a81474d2187 100644 --- a/op-deployer/pkg/deployer/upgrade/v4_0_0/upgrade.go +++ b/op-deployer/pkg/deployer/upgrade/v4_0_0/upgrade.go @@ -7,7 +7,7 @@ import ( "encoding/json" "github.com/ethereum-optimism/optimism/op-chain-ops/script" - "github.com/ethereum-optimism/optimism/op-deployer/pkg/deployer/standard" + "github.com/ethereum-optimism/optimism/op-deployer/pkg/deployer/artifacts" v200 "github.com/ethereum-optimism/optimism/op-deployer/pkg/deployer/upgrade/v2_0_0" ) @@ -19,7 +19,7 @@ func (u *Upgrader) Upgrade(host *script.Host, input json.RawMessage) error { } func (u *Upgrader) ArtifactsURL() string { - return "tag://" + standard.ContractsV400Tag + return artifacts.CreateHttpLocator("67966a2cb9945e1d9ab40e9c61f499e73cdb31d21b8d29a5a5c909b2b13ecd70") } var DefaultUpgrader = new(Upgrader) diff --git a/op-deployer/pkg/deployer/upgrade/v4_1_0/upgrade.go b/op-deployer/pkg/deployer/upgrade/v4_1_0/upgrade.go new file mode 100644 index 00000000000..9318911f3f8 --- /dev/null +++ b/op-deployer/pkg/deployer/upgrade/v4_1_0/upgrade.go @@ -0,0 +1,25 @@ +// Package v4_1_0 implements the upgrade to v4.1.0 (U16a). The interface for the upgrade is identical +// to the upgrade for v2.0.0 (U13), so all this package does is implement the Upgrader interface and +// call into the v2.0.0 upgrade. +package v4_1_0 + +import ( + "encoding/json" + + "github.com/ethereum-optimism/optimism/op-chain-ops/script" + "github.com/ethereum-optimism/optimism/op-deployer/pkg/deployer/artifacts" + v200 "github.com/ethereum-optimism/optimism/op-deployer/pkg/deployer/upgrade/v2_0_0" +) + +type Upgrader struct { +} + +func (u *Upgrader) Upgrade(host *script.Host, input json.RawMessage) error { + return v200.DefaultUpgrader.Upgrade(host, input) +} + +func (u *Upgrader) ArtifactsURL() string { + return artifacts.CreateHttpLocator("579f43b5bbb43e74216b7ed33125280567df86eaf00f7621f354e4a68c07323e") +} + +var DefaultUpgrader = new(Upgrader) diff --git a/op-service/testutils/devnet/anvil.go b/op-service/testutils/devnet/anvil.go index 841e1267226..2440af5afd2 100644 --- a/op-service/testutils/devnet/anvil.go +++ b/op-service/testutils/devnet/anvil.go @@ -61,6 +61,12 @@ func WithChainID(id uint64) AnvilOption { } } +func WithForkBlockNumber(block uint64) AnvilOption { + return func(a *Anvil) { + a.args["--fork-block-number"] = strconv.FormatUint(block, 10) + } +} + func NewAnvil(logger log.Logger, opts ...AnvilOption) (*Anvil, error) { if _, err := exec.LookPath("anvil"); err != nil { return nil, fmt.Errorf("anvil not found in PATH: %w", err) diff --git a/op-service/testutils/devnet/canned.go b/op-service/testutils/devnet/canned.go index 8c787aa4a1c..621781e55ff 100644 --- a/op-service/testutils/devnet/canned.go +++ b/op-service/testutils/devnet/canned.go @@ -46,3 +46,11 @@ func NewForkedSepolia(lgr log.Logger) (*Anvil, CleanupFunc, error) { } return NewForked(lgr, url) } + +func NewForkedSepoliaFromBlock(lgr log.Logger, block uint64) (*Anvil, CleanupFunc, error) { + url := os.Getenv("SEPOLIA_RPC_URL") + if url == "" { + return nil, nil, fmt.Errorf("SEPOLIA_RPC_URL not set") + } + return NewForked(lgr, url, WithForkBlockNumber(block)) +} From bc567b96a7453c25f4aec004cd8b6039f8e11167 Mon Sep 17 00:00:00 2001 From: Stefano Charissis Date: Mon, 13 Oct 2025 13:02:56 +1100 Subject: [PATCH 048/117] fix(op-acceptance-tests): flake-shake; misc. fixes (#17830) --- .circleci/config.yml | 4 ++-- .../cmd/flake-shake-aggregator/main.go | 2 +- .../cmd/flake-shake-promoter/main.go | 18 +++++++++++------- .../scripts/ci_flake_shake_prepare_slack.sh | 5 +++-- 4 files changed, 17 insertions(+), 12 deletions(-) diff --git a/.circleci/config.yml b/.circleci/config.yml index 966155a6b3b..ccb3366013a 100644 --- a/.circleci/config.yml +++ b/.circleci/config.yml @@ -79,10 +79,10 @@ parameters: default: false flake-shake-iterations: type: integer - default: 200 + default: 400 flake-shake-workers: type: integer - default: 10 + default: 20 orbs: go: circleci/go@1.8.0 diff --git a/op-acceptance-tests/cmd/flake-shake-aggregator/main.go b/op-acceptance-tests/cmd/flake-shake-aggregator/main.go index 5f7ad50b672..dd08d037a14 100644 --- a/op-acceptance-tests/cmd/flake-shake-aggregator/main.go +++ b/op-acceptance-tests/cmd/flake-shake-aggregator/main.go @@ -445,7 +445,7 @@ func generateHTMLReport(report *FlakeShakeReport) string { test.TotalRuns, test.Passes, test.Failures, - test.AvgDuration.Round(time.Millisecond), + test.AvgDuration.Round(time.Second), strings.ToLower(test.Recommendation), test.Recommendation, )) diff --git a/op-acceptance-tests/cmd/flake-shake-promoter/main.go b/op-acceptance-tests/cmd/flake-shake-promoter/main.go index b3616c54afc..782305bada5 100644 --- a/op-acceptance-tests/cmd/flake-shake-promoter/main.go +++ b/op-acceptance-tests/cmd/flake-shake-promoter/main.go @@ -33,7 +33,7 @@ const ( flakeShakePRBranchPrefix = "ci/flake-shake-promote/" flakeShakeLabel = "M-ci" flakeShakeBotAuthor = "opgitgovernance" - flakeShakeSupersedeDays = 2 + flakeShakeSupersedeDays = 2 // lookback window (days) when closing older PRs as superseded ) // CircleCI API models @@ -572,9 +572,11 @@ func selectPromotionCandidates(agg map[string]*aggStats, flakeTests map[string]t if totalRuns > 0 { failureRate = float64(totalFailures) / float64(totalRuns) } - if failureRate > maxFailureRate { - reasons[keyFor(pkg, "")] = fmt.Sprintf("failure rate %.4f exceeds max %.4f (pkg)", failureRate, maxFailureRate) - continue + if !requireClean24h { + if failureRate > maxFailureRate { + reasons[keyFor(pkg, "")] = fmt.Sprintf("failure rate %.4f exceeds max %.4f (pkg)", failureRate, maxFailureRate) + continue + } } if requireClean24h && lastFailureAt != nil { if time.Since(*lastFailureAt) < 24*time.Hour { @@ -637,9 +639,11 @@ func selectPromotionCandidates(agg map[string]*aggStats, flakeTests map[string]t if s.TotalRuns > 0 { failureRate = float64(s.Failures) / float64(s.TotalRuns) } - if failureRate > maxFailureRate { - reasons[key] = fmt.Sprintf("failure rate %.4f exceeds max %.4f", failureRate, maxFailureRate) - continue + if !requireClean24h { + if failureRate > maxFailureRate { + reasons[key] = fmt.Sprintf("failure rate %.4f exceeds max %.4f", failureRate, maxFailureRate) + continue + } } if requireClean24h && s.LastFailureAt != nil { if time.Since(*s.LastFailureAt) < 24*time.Hour { diff --git a/op-acceptance-tests/scripts/ci_flake_shake_prepare_slack.sh b/op-acceptance-tests/scripts/ci_flake_shake_prepare_slack.sh index 13ee110642a..3cda0b59fb2 100644 --- a/op-acceptance-tests/scripts/ci_flake_shake_prepare_slack.sh +++ b/op-acceptance-tests/scripts/ci_flake_shake_prepare_slack.sh @@ -61,6 +61,7 @@ if [ -f "$PROMO_JSON" ]; then # See: https://docs.slack.dev/block-kit SLACK_BLOCKS=$(jq -c \ --arg url "${REPORT_ARTIFACTS_URL}" \ + --arg job "${REPORT_JOB_URL}" \ --slurpfile meta "${PROMO_JSON%/*}/metadata.json" ' def name_or_pkg(t): (if ((t.test_name|tostring)|length) == 0 then "(package)" else t.test_name end); def owner_or_unknown(t): (if ((t.owner|tostring)|length) == 0 then "unknown" else t.owner end); @@ -91,12 +92,12 @@ if [ -f "$PROMO_JSON" ]; then ( if (($meta.flake_gate_tests // 0) == 0) then [ {"type":"header","text":{"type":"plain_text","text":":partywizard: Acceptance Tests: Flake-Shake — Gate Empty"}}, - {"type":"section","text":{"type":"mrkdwn","text":"No tests in flake-shake gate; nothing to promote. Artifacts: <\($url)|CircleCI Job>"}} + {"type":"section","text":{"type":"mrkdwn","text":"No tests in flake-shake gate; nothing to promote. Artifacts: <\($job)|CircleCI Job>"}} ] elif ($root.candidates|length) == 0 then [ {"type":"header","text":{"type":"plain_text","text":":partywizard: Acceptance Tests: No Flake-Shake Promotion Candidates — \(if $date != "" then $date else (now|strftime("%Y-%m-%d")) end)"}}, - {"type":"section","text":{"type":"mrkdwn","text":"No promotions today. Artifacts: <\($url)|CircleCI Job>"}} + {"type":"section","text":{"type":"mrkdwn","text":"No promotions today. Artifacts: <\($job)|CircleCI Job>"}} ] else ( From 4fb04a2ef05d41d148c692b6ee4fa51ac01432da Mon Sep 17 00:00:00 2001 From: Stefano Charissis Date: Mon, 13 Oct 2025 13:23:06 +1100 Subject: [PATCH 049/117] chore(op-acceptance-tests): flake-shake; TestL2ELP2PCanonicalChainAdvancedByFCU (#17833) Run the new test 'TestL2ELP2PCanonicalChainAdvancedByFCU' through FlakeShake. --- op-acceptance-tests/acceptance-tests.yaml | 4 ++++ 1 file changed, 4 insertions(+) diff --git a/op-acceptance-tests/acceptance-tests.yaml b/op-acceptance-tests/acceptance-tests.yaml index 08731e222f1..592d7c5c361 100644 --- a/op-acceptance-tests/acceptance-tests.yaml +++ b/op-acceptance-tests/acceptance-tests.yaml @@ -28,6 +28,10 @@ gates: - package: github.com/ethereum-optimism/optimism/op-acceptance-tests/tests/osaka timeout: 15m owner: "josh" + - package: github.com/ethereum-optimism/optimism/op-acceptance-tests/tests/sync/elsync/gap_elp2p + name: TestL2ELP2PCanonicalChainAdvancedByFCU + timeout: 30m + owner: "changwan,anton" - id: isthmus description: "Isthmus network tests." From 96b920867c086b8568156d98b092246f5eccbb9d Mon Sep 17 00:00:00 2001 From: Stefano Charissis Date: Tue, 14 Oct 2025 11:55:25 +1100 Subject: [PATCH 050/117] chore(op-acceptance-tests): flake-shake; resource class (#17847) --- .circleci/config.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.circleci/config.yml b/.circleci/config.yml index ccb3366013a..7dd9292e676 100644 --- a/.circleci/config.yml +++ b/.circleci/config.yml @@ -1638,7 +1638,7 @@ jobs: default: "flake-shake" machine: image: ubuntu-2404:current - resource_class: large + resource_class: xlarge parallelism: << pipeline.parameters.flake-shake-workers >> steps: - checkout-from-workspace @@ -1661,7 +1661,7 @@ jobs: bash ./op-acceptance-tests/scripts/ci_flake_shake_calc_iterations.sh << pipeline.parameters.flake-shake-iterations >> - run: name: Run flake-shake iterations - no_output_timeout: 2h + no_output_timeout: 3h working_directory: op-acceptance-tests command: | OUTPUT_DIR="logs/flake-shake-results-worker-${FLAKE_SHAKE_WORKER_ID}" From 27a87b9c61d9314f72dbc3bc47a119eefcb10a90 Mon Sep 17 00:00:00 2001 From: Stefano Charissis Date: Wed, 15 Oct 2025 00:55:29 +1100 Subject: [PATCH 051/117] chore(op-acceptance-tests): flake-shake; tweaked default workers. (#17850) This should reduce the chance of CircleCI timeouts. --- .circleci/config.yml | 4 ++-- op-acceptance-tests/acceptance-tests.yaml | 2 +- 2 files changed, 3 insertions(+), 3 deletions(-) diff --git a/.circleci/config.yml b/.circleci/config.yml index 7dd9292e676..5999ac394c5 100644 --- a/.circleci/config.yml +++ b/.circleci/config.yml @@ -79,10 +79,10 @@ parameters: default: false flake-shake-iterations: type: integer - default: 400 + default: 300 flake-shake-workers: type: integer - default: 20 + default: 50 orbs: go: circleci/go@1.8.0 diff --git a/op-acceptance-tests/acceptance-tests.yaml b/op-acceptance-tests/acceptance-tests.yaml index 592d7c5c361..033403f8ccf 100644 --- a/op-acceptance-tests/acceptance-tests.yaml +++ b/op-acceptance-tests/acceptance-tests.yaml @@ -22,7 +22,7 @@ gates: owner: "axel,mofi" - package: github.com/ethereum-optimism/optimism/op-acceptance-tests/tests/interop/proofs name: TestChallengerPlaysGame - timeout: 30m + timeout: 60m metadata: owner: "axel,mofi" - package: github.com/ethereum-optimism/optimism/op-acceptance-tests/tests/osaka From b95dbc1bfec5be092a7114c858ba1c80aa161df5 Mon Sep 17 00:00:00 2001 From: Ariel Diaz <65925295+aliersh@users.noreply.github.com> Date: Tue, 14 Oct 2025 13:14:00 -0400 Subject: [PATCH 052/117] fix(ai-contracts-test): always fetch develop branch for artifact exclusions (#17840) - hardcode branch to "develop" to avoid CIRCLE_BRANCH env var issues --- .../components/tests_ranker/test_ranker.py | 5 +++-- 1 file changed, 3 insertions(+), 2 deletions(-) diff --git a/ops/ai-eng/contracts-test-maintenance/components/tests_ranker/test_ranker.py b/ops/ai-eng/contracts-test-maintenance/components/tests_ranker/test_ranker.py index 057d49039fe..d4b50f90218 100644 --- a/ops/ai-eng/contracts-test-maintenance/components/tests_ranker/test_ranker.py +++ b/ops/ai-eng/contracts-test-maintenance/components/tests_ranker/test_ranker.py @@ -226,7 +226,8 @@ def fetch_last_processed_from_circleci() -> list[Path]: try: headers = {"Circle-Token": circleci_token} project_slug = "gh/ethereum-optimism/optimism" - branch = os.getenv("CIRCLE_BRANCH", "develop") + # Always check develop branch for previous successful runs + branch = "develop" two_weeks_ago = time.time() - (14 * 24 * 3600) # Get recent pipelines @@ -246,7 +247,7 @@ def fetch_last_processed_from_circleci() -> list[Path]: if pipeline.get("created_at"): pipeline_time = dt.fromisoformat(pipeline["created_at"].replace("Z", "+00:00")).timestamp() if pipeline_time < two_weeks_ago: - print(f"Reached pipelines older than 2 weeks, stopping search") + print("Reached pipelines older than 2 weeks, stopping search") break # Get workflow → job → artifacts → test path From 3c82c3f7618b98e161ce0aff4a1901bed3a4abb9 Mon Sep 17 00:00:00 2001 From: Josh Klopfenstein Date: Tue, 14 Oct 2025 10:31:26 -0700 Subject: [PATCH 053/117] all: Add DA footprint configurability via SystemConfig (#17466) Co-authored-by: Sebastian Stammler Co-authored-by: Matt Solomon --- go.mod | 2 +- go.sum | 4 +- .../tests/jovian/da_footprint_test.go | 95 ++++ op-chain-ops/genesis/config.go | 5 +- op-chain-ops/genesis/layer_two.go | 2 +- .../testdata/test-deploy-config-full.json | 1 + .../pkg/deployer/state/chain_intent.go | 1 + .../pkg/deployer/state/deploy_config.go | 1 + op-devstack/sysgo/deployer.go | 15 + op-e2e/actions/proofs/helpers/matrix.go | 3 +- .../actions/proofs/jovian_activation_test.go | 37 +- op-e2e/bindings/systemconfig.go | 476 +++++++++++++++++- op-e2e/e2eutils/intentbuilder/builder.go | 5 + op-e2e/e2eutils/intentbuilder/builder_test.go | 2 + op-e2e/e2eutils/setup.go | 6 +- op-node/rollup/derive/attributes.go | 8 + .../derive/jovian_upgrade_transactions.go | 55 ++ op-node/rollup/derive/l1_block_info.go | 316 +++++++----- op-node/rollup/derive/l1_block_info_test.go | 54 +- op-node/rollup/derive/payload_util.go | 12 +- op-node/rollup/derive/system_config.go | 31 +- op-node/rollup/derive/system_config_test.go | 52 +- op-node/rollup/types.go | 6 +- .../client/l2/engineapi/block_processor.go | 11 +- .../client/l2/engineapi/l2_engine_api_test.go | 80 ++- op-service/eth/types.go | 18 +- op-service/eth/types_test.go | 15 +- op-service/solabi/util.go | 32 ++ .../interfaces/L1/ISystemConfig.sol | 5 +- .../interfaces/L2/IL1Block.sol | 2 + .../snapshots/abi/L1Block.json | 20 + .../snapshots/abi/SystemConfig.json | 26 + .../snapshots/semver-lock.json | 8 +- .../snapshots/storageLayout/L1Block.json | 7 + .../snapshots/storageLayout/SystemConfig.json | 7 + .../contracts-bedrock/src/L1/SystemConfig.sol | 29 +- packages/contracts-bedrock/src/L2/L1Block.sol | 73 +-- .../src/libraries/Encoding.sol | 44 ++ .../test/L1/SystemConfig.t.sol | 20 + .../contracts-bedrock/test/L2/L1Block.t.sol | 151 ++++-- 40 files changed, 1416 insertions(+), 321 deletions(-) create mode 100644 op-acceptance-tests/tests/jovian/da_footprint_test.go create mode 100644 op-node/rollup/derive/jovian_upgrade_transactions.go diff --git a/go.mod b/go.mod index 5858aacfee4..7e582724fa1 100644 --- a/go.mod +++ b/go.mod @@ -308,7 +308,7 @@ require ( lukechampine.com/blake3 v1.3.0 // indirect ) -replace github.com/ethereum/go-ethereum => github.com/ethereum-optimism/op-geth v1.101603.1-rc.1 +replace github.com/ethereum/go-ethereum => github.com/ethereum-optimism/op-geth v1.101603.2-0.20251014161648-ded9c88e417b // replace github.com/ethereum/go-ethereum => ../op-geth diff --git a/go.sum b/go.sum index c95d97fad2a..908b8bc83cc 100644 --- a/go.sum +++ b/go.sum @@ -238,8 +238,8 @@ github.com/emicklei/dot v1.6.2 h1:08GN+DD79cy/tzN6uLCT84+2Wk9u+wvqP+Hkx/dIR8A= github.com/emicklei/dot v1.6.2/go.mod h1:DeV7GvQtIw4h2u73RKBkkFdvVAz0D9fzeJrgPW6gy/s= github.com/ethereum-optimism/go-ethereum-hdwallet v0.1.4-0.20251001155152-4eb15ccedf7e h1:iy1vBIzACYUyOVyoADUwvAiq2eOPC0yVsDUdolPwQjk= github.com/ethereum-optimism/go-ethereum-hdwallet v0.1.4-0.20251001155152-4eb15ccedf7e/go.mod h1:DYj7+vYJ4cIB7zera9mv4LcAynCL5u4YVfoeUu6Wa+w= -github.com/ethereum-optimism/op-geth v1.101603.1-rc.1 h1:qH+BM+AHrHFWPonJEpapmyo/LJhqj9/TGsRaWg4RCYg= -github.com/ethereum-optimism/op-geth v1.101603.1-rc.1/go.mod h1:Ct2QjqZ2UKgvvgKLLYzoh/DBicJZB8DXsv45DgEjcco= +github.com/ethereum-optimism/op-geth v1.101603.2-0.20251014161648-ded9c88e417b h1:5FhpB8a0wXp/11jd6OnUIX3Blwy2Wh9aa+z+AA9amUM= +github.com/ethereum-optimism/op-geth v1.101603.2-0.20251014161648-ded9c88e417b/go.mod h1:Ct2QjqZ2UKgvvgKLLYzoh/DBicJZB8DXsv45DgEjcco= github.com/ethereum-optimism/superchain-registry/validation v0.0.0-20251009180028-9b4658b9b7af h1:WWz0gJM/boaUImtJnROecPirAerKCLpAU4m6Tx0ArOg= github.com/ethereum-optimism/superchain-registry/validation v0.0.0-20251009180028-9b4658b9b7af/go.mod h1:NZ816PzLU1TLv1RdAvYAb6KWOj4Zm5aInT0YpDVml2Y= github.com/ethereum/c-kzg-4844/v2 v2.1.0 h1:gQropX9YFBhl3g4HYhwE70zq3IHFRgbbNPw0Shwzf5w= diff --git a/op-acceptance-tests/tests/jovian/da_footprint_test.go b/op-acceptance-tests/tests/jovian/da_footprint_test.go new file mode 100644 index 00000000000..e3a8c83902a --- /dev/null +++ b/op-acceptance-tests/tests/jovian/da_footprint_test.go @@ -0,0 +1,95 @@ +package jovian + +import ( + "context" + "crypto/rand" + "sync" + "testing" + "time" + + "github.com/ethereum-optimism/optimism/op-acceptance-tests/tests/interop/loadtest" + "github.com/ethereum-optimism/optimism/op-devstack/devtest" + "github.com/ethereum-optimism/optimism/op-devstack/presets" + "github.com/ethereum-optimism/optimism/op-service/eth" + "github.com/ethereum-optimism/optimism/op-service/txinclude" + "github.com/ethereum-optimism/optimism/op-service/txplan" + "github.com/ethereum/go-ethereum/common" +) + +type CalldataSpammer struct { + eoa *loadtest.SyncEOA +} + +func NewCalldataSpammer(eoa *loadtest.SyncEOA) *CalldataSpammer { + return &CalldataSpammer{ + eoa: eoa, + } +} + +func (s *CalldataSpammer) Spam(t devtest.T) error { + data := make([]byte, 50_000) + _, err := rand.Read(data) + t.Require().NoError(err) + _, err = s.eoa.Include(t, txplan.WithTo(&common.Address{}), txplan.WithData(data)) + return err +} + +func TestDAFootprint(gt *testing.T) { + t := devtest.SerialT(gt) + sys := presets.NewMinimal(t) + l2BlockTime := time.Duration(sys.L2Chain.Escape().RollupConfig().BlockTime) * time.Second + ethClient := sys.L2EL.Escape().EthClient() + + sys.L2EL.WaitForOnline() + + var wg sync.WaitGroup + defer wg.Wait() + + ctx, cancel := context.WithTimeout(t.Ctx(), time.Minute) + defer cancel() + t = t.WithCtx(ctx) + + wg.Add(1) + go func() { + defer wg.Done() + eoa := sys.FunderL2.NewFundedEOA(eth.OneEther.Mul(100)) + includer := txinclude.NewPersistent(txinclude.NewPkSigner(eoa.Key().Priv(), eoa.ChainID().ToBig()), struct { + *txinclude.Resubmitter + *txinclude.Monitor + }{ + txinclude.NewResubmitter(ethClient, l2BlockTime), + txinclude.NewMonitor(ethClient, l2BlockTime), + }) + loadtest.NewBurst(l2BlockTime).Run(t, NewCalldataSpammer(loadtest.NewSyncEOA(includer, eoa.Plan()))) + }() + + for range time.Tick(l2BlockTime) { + info, txs, err := ethClient.InfoAndTxsByLabel(t.Ctx(), eth.Unsafe) + t.Require().NoError(err) + + blockGasUsed := info.GasUsed() + + receipt, err := ethClient.TransactionReceipt(t.Ctx(), txs[len(txs)-1].Hash()) + t.Require().NoError(err) + // The last tx's cumulative gas used is the block's total transaction gas used. + totalTxGasUsed := receipt.CumulativeGasUsed + if totalTxGasUsed == blockGasUsed { + t.Logf("Block %d:%s doesn't have excess gas used, trying next...", info.NumberU64(), info.Hash()) + continue + } + + var totalDAFootprint uint64 + for _, tx := range txs { + if tx.IsDepositTx() { + continue + } + totalDAFootprint += tx.RollupCostData().EstimatedDASize().Uint64() * eth.DAFootprintGasScalarDefault + } + t.Logf("Block %d:%s has DA footprint exceeding cumulative tx gas used, %d > %d", info.NumberU64(), info.Hash(), + totalDAFootprint, totalTxGasUsed) + t.Require().Less(totalTxGasUsed, blockGasUsed) + t.Require().Equal(totalDAFootprint, blockGasUsed) + return + } + t.Require().FailNow("Never saw a block with gasUsed > total transaction gasUsed.") +} diff --git a/op-chain-ops/genesis/config.go b/op-chain-ops/genesis/config.go index c4acf5d16d2..7dad290ea39 100644 --- a/op-chain-ops/genesis/config.go +++ b/op-chain-ops/genesis/config.go @@ -405,7 +405,6 @@ func offsetToUpgradeTime(offset *hexutil.Uint64, genesisTime uint64) *uint64 { } func (d *UpgradeScheduleDeployConfig) ForkTimeOffset(fork rollup.ForkName) *uint64 { - switch fork { case rollup.Regolith: return (*uint64)(d.L2GenesisRegolithTimeOffset) @@ -730,6 +729,7 @@ type L2InitializationConfig struct { UpgradeScheduleDeployConfig L2CoreDeployConfig AltDADeployConfig + DAFootprintGasScalar uint16 `json:"daFootprintGasScalar"` } func (d *L2InitializationConfig) Check(log log.Logger) error { @@ -1122,6 +1122,9 @@ func (d *DeployConfig) GenesisSystemConfig() eth.SystemConfig { Scalar: d.FeeScalar(), GasLimit: uint64(d.L2GenesisBlockGasLimit), OperatorFeeParams: d.OperatorFeeParams(), + // Note that we don't use SetDAFootprintGasScalar here because this SystemConfig is supposed to + // reflect the genesis state and is not used inside derivation. + DAFootprintGasScalar: d.DAFootprintGasScalar, } } diff --git a/op-chain-ops/genesis/layer_two.go b/op-chain-ops/genesis/layer_two.go index 9f0103e2815..5a89ac0bfd3 100644 --- a/op-chain-ops/genesis/layer_two.go +++ b/op-chain-ops/genesis/layer_two.go @@ -29,8 +29,8 @@ const ( L2AllocsGranite L2AllocsMode = "granite" L2AllocsHolocene L2AllocsMode = "holocene" L2AllocsIsthmus L2AllocsMode = "isthmus" - L2AllocsInterop L2AllocsMode = "interop" L2AllocsJovian L2AllocsMode = "jovian" + L2AllocsInterop L2AllocsMode = "interop" ) var ( diff --git a/op-chain-ops/genesis/testdata/test-deploy-config-full.json b/op-chain-ops/genesis/testdata/test-deploy-config-full.json index 0f332842204..7cbab4f3dae 100644 --- a/op-chain-ops/genesis/testdata/test-deploy-config-full.json +++ b/op-chain-ops/genesis/testdata/test-deploy-config-full.json @@ -59,6 +59,7 @@ "gasPriceOracleOperatorFeeConstant": 0, "gasPriceOracleOverhead": 2100, "gasPriceOracleScalar": 1000000, + "daFootprintGasScalar": 400, "enableGovernance": true, "governanceTokenSymbol": "OP", "governanceTokenName": "Optimism", diff --git a/op-deployer/pkg/deployer/state/chain_intent.go b/op-deployer/pkg/deployer/state/chain_intent.go index 819bc9e3f1f..3ca48014d31 100644 --- a/op-deployer/pkg/deployer/state/chain_intent.go +++ b/op-deployer/pkg/deployer/state/chain_intent.go @@ -73,6 +73,7 @@ type ChainIntent struct { OperatorFeeConstant uint64 `json:"operatorFeeConstant,omitempty" toml:"operatorFeeConstant,omitempty"` L1StartBlockHash *common.Hash `json:"l1StartBlockHash,omitempty" toml:"l1StartBlockHash,omitempty"` MinBaseFee uint64 `json:"minBaseFee,omitempty" toml:"minBaseFee,omitempty"` + DAFootprintGasScalar uint16 `json:"daFootprintGasScalar,omitempty" toml:"daFootprintGasScalar,omitempty"` // Optional. For development purposes only. Only enabled if the operation mode targets a genesis-file output. L2DevGenesisParams *L2DevGenesisParams `json:"l2DevGenesisParams,omitempty" toml:"l2DevGenesisParams,omitempty"` diff --git a/op-deployer/pkg/deployer/state/deploy_config.go b/op-deployer/pkg/deployer/state/deploy_config.go index d497e0d08eb..b441b662098 100644 --- a/op-deployer/pkg/deployer/state/deploy_config.go +++ b/op-deployer/pkg/deployer/state/deploy_config.go @@ -95,6 +95,7 @@ func CombineDeployConfig(intent *Intent, chainIntent *ChainIntent, state *State, ProxyAdminOwner: chainIntent.Roles.L2ProxyAdminOwner, FinalSystemOwner: chainIntent.Roles.L1ProxyAdminOwner, }, + DAFootprintGasScalar: chainIntent.DAFootprintGasScalar, }, FaultProofDeployConfig: genesis.FaultProofDeployConfig{ UseFaultProofs: true, diff --git a/op-devstack/sysgo/deployer.go b/op-devstack/sysgo/deployer.go index 4c204d5b9be..e6063489689 100644 --- a/op-devstack/sysgo/deployer.go +++ b/op-devstack/sysgo/deployer.go @@ -4,6 +4,7 @@ import ( "math/big" "os" "path/filepath" + "slices" "time" "github.com/ethereum/go-ethereum/common" @@ -47,6 +48,20 @@ func WithDeployerCacheDir(dirPath string) DeployerPipelineOption { } } +// WithDAFootprintGasScalar sets the DA footprint gas scalar with which the networks identified by +// l2IDs will be launched. If there are no l2IDs provided, all L2 networks are set with scalar. +func WithDAFootprintGasScalar(scalar uint16, l2IDs ...stack.L2NetworkID) DeployerOption { + return func(p devtest.P, _ devkeys.Keys, builder intentbuilder.Builder) { + for _, l2 := range builder.L2s() { + if len(l2IDs) == 0 || slices.ContainsFunc(l2IDs, func(id stack.L2NetworkID) bool { + return id.ChainID() == l2.ChainID() + }) { + l2.WithDAFootprintGasScalar(scalar) + } + } + } +} + func WithDeployerPipelineOption(opt DeployerPipelineOption) stack.Option[*Orchestrator] { return stack.BeforeDeploy(func(o *Orchestrator) { o.deployerPipelineOptions = append(o.deployerPipelineOptions, opt) diff --git a/op-e2e/actions/proofs/helpers/matrix.go b/op-e2e/actions/proofs/helpers/matrix.go index b13588d1954..025d8a96c45 100644 --- a/op-e2e/actions/proofs/helpers/matrix.go +++ b/op-e2e/actions/proofs/helpers/matrix.go @@ -125,10 +125,11 @@ var ( Granite = &Hardfork{Name: string(rollup.Granite), Precedence: 6} Holocene = &Hardfork{Name: string(rollup.Holocene), Precedence: 7} Isthmus = &Hardfork{Name: string(rollup.Isthmus), Precedence: 8} + Jovian = &Hardfork{Name: string(rollup.Jovian), Precedence: 9} ) var ( - Hardforks = ForkMatrix{Regolith, Canyon, Delta, Ecotone, Fjord, Granite, Holocene, Isthmus} + Hardforks = ForkMatrix{Regolith, Canyon, Delta, Ecotone, Fjord, Granite, Holocene, Isthmus, Jovian} LatestFork = Hardforks[len(Hardforks)-1] LatestForkOnly = ForkMatrix{LatestFork} ) diff --git a/op-e2e/actions/proofs/jovian_activation_test.go b/op-e2e/actions/proofs/jovian_activation_test.go index a36ba2947c2..4fcf82a58f2 100644 --- a/op-e2e/actions/proofs/jovian_activation_test.go +++ b/op-e2e/actions/proofs/jovian_activation_test.go @@ -8,11 +8,9 @@ import ( actionsHelpers "github.com/ethereum-optimism/optimism/op-e2e/actions/helpers" "github.com/ethereum-optimism/optimism/op-e2e/actions/proofs/helpers" "github.com/ethereum-optimism/optimism/op-e2e/bindings" - "github.com/ethereum-optimism/optimism/op-program/client/claim" + "github.com/ethereum-optimism/optimism/op-node/rollup" "github.com/ethereum-optimism/optimism/op-service/testlog" "github.com/ethereum/go-ethereum/accounts/abi/bind" - "github.com/ethereum/go-ethereum/common" - "github.com/ethereum/go-ethereum/common/hexutil" "github.com/ethereum/go-ethereum/consensus/misc/eip1559" "github.com/stretchr/testify/require" ) @@ -36,7 +34,6 @@ func setMinBaseFeeViaSystemConfig(t actionsHelpers.Testing, env *helpers.L2Fault } func Test_ProgramAction_JovianActivation(gt *testing.T) { - runJovianDerivationTest := func(gt *testing.T, testCfg *helpers.TestCfg[any], genesisConfigFn func(*genesis.DeployConfig), jovianAtGenesis bool, minBaseFee uint64) { t := actionsHelpers.NewDefaultTesting(gt) env := helpers.NewL2FaultProofEnv(t, testCfg, helpers.NewTestParams(), helpers.NewBatcherCfg(), genesisConfigFn) @@ -111,36 +108,28 @@ func Test_ProgramAction_JovianActivation(gt *testing.T) { }{ "JovianActivationAfterGenesis": { genesisConfigFn: func(dc *genesis.DeployConfig) { - // Activate Isthmus at genesis - zero := hexutil.Uint64(0) - dc.L2GenesisIsthmusTimeOffset = &zero - // Then set Jovian at 10s - ten := hexutil.Uint64(10) - dc.L2GenesisJovianTimeOffset = &ten + dc.ActivateForkAtOffset(rollup.Jovian, 10) }, jovianAtGenesis: false, minBaseFee: 0, }, "JovianActivationAtGenesisZeroMinBaseFee": { genesisConfigFn: func(dc *genesis.DeployConfig) { - zero := hexutil.Uint64(0) - dc.L2GenesisJovianTimeOffset = &zero + dc.ActivateForkAtGenesis(rollup.Jovian) }, jovianAtGenesis: true, minBaseFee: 0, }, "JovianActivationAtGenesisMinBaseFeeMedium": { genesisConfigFn: func(dc *genesis.DeployConfig) { - zero := hexutil.Uint64(0) - dc.L2GenesisJovianTimeOffset = &zero + dc.ActivateForkAtGenesis(rollup.Jovian) }, jovianAtGenesis: true, minBaseFee: 1_000_000_000, // 1 gwei }, "JovianActivationAtGenesisMinBaseFeeHigh": { genesisConfigFn: func(dc *genesis.DeployConfig) { - zero := hexutil.Uint64(0) - dc.L2GenesisJovianTimeOffset = &zero + dc.ActivateForkAtGenesis(rollup.Jovian) }, jovianAtGenesis: true, minBaseFee: 2_000_000_000, // 2 gwei @@ -150,27 +139,15 @@ func Test_ProgramAction_JovianActivation(gt *testing.T) { for name, tt := range tests { gt.Run(name, func(t *testing.T) { matrix := helpers.NewMatrix[any]() - defer matrix.Run(t) - - matrix.AddTestCase( + matrix.AddDefaultTestCasesWithName( "HonestClaim-"+name, nil, helpers.NewForkMatrix(helpers.Isthmus), func(gt *testing.T, testCfg *helpers.TestCfg[any]) { runJovianDerivationTest(gt, testCfg, tt.genesisConfigFn, tt.jovianAtGenesis, tt.minBaseFee) }, - helpers.ExpectNoError(), - ) - matrix.AddTestCase( - "JunkClaim-"+name, - nil, - helpers.NewForkMatrix(helpers.Isthmus), - func(gt *testing.T, testCfg *helpers.TestCfg[any]) { - runJovianDerivationTest(gt, testCfg, tt.genesisConfigFn, tt.jovianAtGenesis, tt.minBaseFee) - }, - helpers.ExpectError(claim.ErrClaimNotValid), - helpers.WithL2Claim(common.HexToHash("0xdeadbeef")), ) + matrix.Run(t) }) } } diff --git a/op-e2e/bindings/systemconfig.go b/op-e2e/bindings/systemconfig.go index 49be8b70df4..f0a407ed2c9 100644 --- a/op-e2e/bindings/systemconfig.go +++ b/op-e2e/bindings/systemconfig.go @@ -50,7 +50,7 @@ type SystemConfigAddresses struct { // SystemConfigMetaData contains all meta data concerning the SystemConfig contract. var SystemConfigMetaData = &bind.MetaData{ - ABI: "[{\"type\":\"constructor\",\"inputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"BATCH_INBOX_SLOT\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"bytes32\",\"internalType\":\"bytes32\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"L1_CROSS_DOMAIN_MESSENGER_SLOT\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"bytes32\",\"internalType\":\"bytes32\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"L1_ERC_721_BRIDGE_SLOT\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"bytes32\",\"internalType\":\"bytes32\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"L1_STANDARD_BRIDGE_SLOT\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"bytes32\",\"internalType\":\"bytes32\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"OPTIMISM_MINTABLE_ERC20_FACTORY_SLOT\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"bytes32\",\"internalType\":\"bytes32\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"OPTIMISM_PORTAL_SLOT\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"bytes32\",\"internalType\":\"bytes32\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"START_BLOCK_SLOT\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"bytes32\",\"internalType\":\"bytes32\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"UNSAFE_BLOCK_SIGNER_SLOT\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"bytes32\",\"internalType\":\"bytes32\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"VERSION\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"basefeeScalar\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"uint32\",\"internalType\":\"uint32\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"batchInbox\",\"inputs\":[],\"outputs\":[{\"name\":\"addr_\",\"type\":\"address\",\"internalType\":\"address\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"batcherHash\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"bytes32\",\"internalType\":\"bytes32\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"blobbasefeeScalar\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"uint32\",\"internalType\":\"uint32\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"disputeGameFactory\",\"inputs\":[],\"outputs\":[{\"name\":\"addr_\",\"type\":\"address\",\"internalType\":\"address\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"eip1559Denominator\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"uint32\",\"internalType\":\"uint32\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"eip1559Elasticity\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"uint32\",\"internalType\":\"uint32\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"gasLimit\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"uint64\",\"internalType\":\"uint64\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"getAddresses\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"tuple\",\"internalType\":\"structSystemConfig.Addresses\",\"components\":[{\"name\":\"l1CrossDomainMessenger\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"l1ERC721Bridge\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"l1StandardBridge\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"optimismPortal\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"optimismMintableERC20Factory\",\"type\":\"address\",\"internalType\":\"address\"}]}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"guardian\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"address\",\"internalType\":\"address\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"initVersion\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"uint8\",\"internalType\":\"uint8\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"initialize\",\"inputs\":[{\"name\":\"_owner\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"_basefeeScalar\",\"type\":\"uint32\",\"internalType\":\"uint32\"},{\"name\":\"_blobbasefeeScalar\",\"type\":\"uint32\",\"internalType\":\"uint32\"},{\"name\":\"_batcherHash\",\"type\":\"bytes32\",\"internalType\":\"bytes32\"},{\"name\":\"_gasLimit\",\"type\":\"uint64\",\"internalType\":\"uint64\"},{\"name\":\"_unsafeBlockSigner\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"_config\",\"type\":\"tuple\",\"internalType\":\"structIResourceMetering.ResourceConfig\",\"components\":[{\"name\":\"maxResourceLimit\",\"type\":\"uint32\",\"internalType\":\"uint32\"},{\"name\":\"elasticityMultiplier\",\"type\":\"uint8\",\"internalType\":\"uint8\"},{\"name\":\"baseFeeMaxChangeDenominator\",\"type\":\"uint8\",\"internalType\":\"uint8\"},{\"name\":\"minimumBaseFee\",\"type\":\"uint32\",\"internalType\":\"uint32\"},{\"name\":\"systemTxMaxGas\",\"type\":\"uint32\",\"internalType\":\"uint32\"},{\"name\":\"maximumBaseFee\",\"type\":\"uint128\",\"internalType\":\"uint128\"}]},{\"name\":\"_batchInbox\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"_addresses\",\"type\":\"tuple\",\"internalType\":\"structSystemConfig.Addresses\",\"components\":[{\"name\":\"l1CrossDomainMessenger\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"l1ERC721Bridge\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"l1StandardBridge\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"optimismPortal\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"optimismMintableERC20Factory\",\"type\":\"address\",\"internalType\":\"address\"}]},{\"name\":\"_l2ChainId\",\"type\":\"uint256\",\"internalType\":\"uint256\"},{\"name\":\"_superchainConfig\",\"type\":\"address\",\"internalType\":\"contractISuperchainConfig\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"isFeatureEnabled\",\"inputs\":[{\"name\":\"\",\"type\":\"bytes32\",\"internalType\":\"bytes32\"}],\"outputs\":[{\"name\":\"\",\"type\":\"bool\",\"internalType\":\"bool\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"l1CrossDomainMessenger\",\"inputs\":[],\"outputs\":[{\"name\":\"addr_\",\"type\":\"address\",\"internalType\":\"address\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"l1ERC721Bridge\",\"inputs\":[],\"outputs\":[{\"name\":\"addr_\",\"type\":\"address\",\"internalType\":\"address\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"l1StandardBridge\",\"inputs\":[],\"outputs\":[{\"name\":\"addr_\",\"type\":\"address\",\"internalType\":\"address\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"l2ChainId\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"maximumGasLimit\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"uint64\",\"internalType\":\"uint64\"}],\"stateMutability\":\"pure\"},{\"type\":\"function\",\"name\":\"minBaseFee\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"uint64\",\"internalType\":\"uint64\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"minimumGasLimit\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"uint64\",\"internalType\":\"uint64\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"operatorFeeConstant\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"uint64\",\"internalType\":\"uint64\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"operatorFeeScalar\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"uint32\",\"internalType\":\"uint32\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"optimismMintableERC20Factory\",\"inputs\":[],\"outputs\":[{\"name\":\"addr_\",\"type\":\"address\",\"internalType\":\"address\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"optimismPortal\",\"inputs\":[],\"outputs\":[{\"name\":\"addr_\",\"type\":\"address\",\"internalType\":\"address\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"overhead\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"owner\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"address\",\"internalType\":\"address\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"paused\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"bool\",\"internalType\":\"bool\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"proxyAdmin\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"address\",\"internalType\":\"contractIProxyAdmin\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"proxyAdminOwner\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"address\",\"internalType\":\"address\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"renounceOwnership\",\"inputs\":[],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"resourceConfig\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"tuple\",\"internalType\":\"structIResourceMetering.ResourceConfig\",\"components\":[{\"name\":\"maxResourceLimit\",\"type\":\"uint32\",\"internalType\":\"uint32\"},{\"name\":\"elasticityMultiplier\",\"type\":\"uint8\",\"internalType\":\"uint8\"},{\"name\":\"baseFeeMaxChangeDenominator\",\"type\":\"uint8\",\"internalType\":\"uint8\"},{\"name\":\"minimumBaseFee\",\"type\":\"uint32\",\"internalType\":\"uint32\"},{\"name\":\"systemTxMaxGas\",\"type\":\"uint32\",\"internalType\":\"uint32\"},{\"name\":\"maximumBaseFee\",\"type\":\"uint128\",\"internalType\":\"uint128\"}]}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"scalar\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"setBatcherHash\",\"inputs\":[{\"name\":\"_batcherHash\",\"type\":\"bytes32\",\"internalType\":\"bytes32\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"setEIP1559Params\",\"inputs\":[{\"name\":\"_denominator\",\"type\":\"uint32\",\"internalType\":\"uint32\"},{\"name\":\"_elasticity\",\"type\":\"uint32\",\"internalType\":\"uint32\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"setFeature\",\"inputs\":[{\"name\":\"_feature\",\"type\":\"bytes32\",\"internalType\":\"bytes32\"},{\"name\":\"_enabled\",\"type\":\"bool\",\"internalType\":\"bool\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"setGasConfig\",\"inputs\":[{\"name\":\"_overhead\",\"type\":\"uint256\",\"internalType\":\"uint256\"},{\"name\":\"_scalar\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"setGasConfigEcotone\",\"inputs\":[{\"name\":\"_basefeeScalar\",\"type\":\"uint32\",\"internalType\":\"uint32\"},{\"name\":\"_blobbasefeeScalar\",\"type\":\"uint32\",\"internalType\":\"uint32\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"setGasLimit\",\"inputs\":[{\"name\":\"_gasLimit\",\"type\":\"uint64\",\"internalType\":\"uint64\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"setMinBaseFee\",\"inputs\":[{\"name\":\"_minBaseFee\",\"type\":\"uint64\",\"internalType\":\"uint64\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"setOperatorFeeScalars\",\"inputs\":[{\"name\":\"_operatorFeeScalar\",\"type\":\"uint32\",\"internalType\":\"uint32\"},{\"name\":\"_operatorFeeConstant\",\"type\":\"uint64\",\"internalType\":\"uint64\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"setUnsafeBlockSigner\",\"inputs\":[{\"name\":\"_unsafeBlockSigner\",\"type\":\"address\",\"internalType\":\"address\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"startBlock\",\"inputs\":[],\"outputs\":[{\"name\":\"startBlock_\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"superchainConfig\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"address\",\"internalType\":\"contractISuperchainConfig\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"transferOwnership\",\"inputs\":[{\"name\":\"newOwner\",\"type\":\"address\",\"internalType\":\"address\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"unsafeBlockSigner\",\"inputs\":[],\"outputs\":[{\"name\":\"addr_\",\"type\":\"address\",\"internalType\":\"address\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"upgrade\",\"inputs\":[{\"name\":\"_l2ChainId\",\"type\":\"uint256\",\"internalType\":\"uint256\"},{\"name\":\"_superchainConfig\",\"type\":\"address\",\"internalType\":\"contractISuperchainConfig\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"version\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"string\",\"internalType\":\"string\"}],\"stateMutability\":\"pure\"},{\"type\":\"event\",\"name\":\"ConfigUpdate\",\"inputs\":[{\"name\":\"version\",\"type\":\"uint256\",\"indexed\":true,\"internalType\":\"uint256\"},{\"name\":\"updateType\",\"type\":\"uint8\",\"indexed\":true,\"internalType\":\"enumSystemConfig.UpdateType\"},{\"name\":\"data\",\"type\":\"bytes\",\"indexed\":false,\"internalType\":\"bytes\"}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"FeatureSet\",\"inputs\":[{\"name\":\"feature\",\"type\":\"bytes32\",\"indexed\":true,\"internalType\":\"bytes32\"},{\"name\":\"enabled\",\"type\":\"bool\",\"indexed\":true,\"internalType\":\"bool\"}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"Initialized\",\"inputs\":[{\"name\":\"version\",\"type\":\"uint8\",\"indexed\":false,\"internalType\":\"uint8\"}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"OwnershipTransferred\",\"inputs\":[{\"name\":\"previousOwner\",\"type\":\"address\",\"indexed\":true,\"internalType\":\"address\"},{\"name\":\"newOwner\",\"type\":\"address\",\"indexed\":true,\"internalType\":\"address\"}],\"anonymous\":false},{\"type\":\"error\",\"name\":\"ProxyAdminOwnedBase_NotProxyAdmin\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"ProxyAdminOwnedBase_NotProxyAdminOrProxyAdminOwner\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"ProxyAdminOwnedBase_NotProxyAdminOwner\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"ProxyAdminOwnedBase_NotResolvedDelegateProxy\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"ProxyAdminOwnedBase_NotSharedProxyAdminOwner\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"ProxyAdminOwnedBase_ProxyAdminNotFound\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"ReinitializableBase_ZeroInitVersion\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"SystemConfig_InvalidFeatureState\",\"inputs\":[]}]", + ABI: "[{\"type\":\"constructor\",\"inputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"BATCH_INBOX_SLOT\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"bytes32\",\"internalType\":\"bytes32\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"L1_CROSS_DOMAIN_MESSENGER_SLOT\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"bytes32\",\"internalType\":\"bytes32\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"L1_ERC_721_BRIDGE_SLOT\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"bytes32\",\"internalType\":\"bytes32\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"L1_STANDARD_BRIDGE_SLOT\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"bytes32\",\"internalType\":\"bytes32\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"OPTIMISM_MINTABLE_ERC20_FACTORY_SLOT\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"bytes32\",\"internalType\":\"bytes32\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"OPTIMISM_PORTAL_SLOT\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"bytes32\",\"internalType\":\"bytes32\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"START_BLOCK_SLOT\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"bytes32\",\"internalType\":\"bytes32\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"UNSAFE_BLOCK_SIGNER_SLOT\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"bytes32\",\"internalType\":\"bytes32\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"VERSION\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"basefeeScalar\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"uint32\",\"internalType\":\"uint32\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"batchInbox\",\"inputs\":[],\"outputs\":[{\"name\":\"addr_\",\"type\":\"address\",\"internalType\":\"address\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"batcherHash\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"bytes32\",\"internalType\":\"bytes32\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"blobbasefeeScalar\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"uint32\",\"internalType\":\"uint32\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"daFootprintGasScalar\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"uint16\",\"internalType\":\"uint16\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"disputeGameFactory\",\"inputs\":[],\"outputs\":[{\"name\":\"addr_\",\"type\":\"address\",\"internalType\":\"address\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"eip1559Denominator\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"uint32\",\"internalType\":\"uint32\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"eip1559Elasticity\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"uint32\",\"internalType\":\"uint32\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"gasLimit\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"uint64\",\"internalType\":\"uint64\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"getAddresses\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"tuple\",\"internalType\":\"structSystemConfig.Addresses\",\"components\":[{\"name\":\"l1CrossDomainMessenger\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"l1ERC721Bridge\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"l1StandardBridge\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"optimismPortal\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"optimismMintableERC20Factory\",\"type\":\"address\",\"internalType\":\"address\"}]}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"guardian\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"address\",\"internalType\":\"address\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"initVersion\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"uint8\",\"internalType\":\"uint8\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"initialize\",\"inputs\":[{\"name\":\"_owner\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"_basefeeScalar\",\"type\":\"uint32\",\"internalType\":\"uint32\"},{\"name\":\"_blobbasefeeScalar\",\"type\":\"uint32\",\"internalType\":\"uint32\"},{\"name\":\"_batcherHash\",\"type\":\"bytes32\",\"internalType\":\"bytes32\"},{\"name\":\"_gasLimit\",\"type\":\"uint64\",\"internalType\":\"uint64\"},{\"name\":\"_unsafeBlockSigner\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"_config\",\"type\":\"tuple\",\"internalType\":\"structIResourceMetering.ResourceConfig\",\"components\":[{\"name\":\"maxResourceLimit\",\"type\":\"uint32\",\"internalType\":\"uint32\"},{\"name\":\"elasticityMultiplier\",\"type\":\"uint8\",\"internalType\":\"uint8\"},{\"name\":\"baseFeeMaxChangeDenominator\",\"type\":\"uint8\",\"internalType\":\"uint8\"},{\"name\":\"minimumBaseFee\",\"type\":\"uint32\",\"internalType\":\"uint32\"},{\"name\":\"systemTxMaxGas\",\"type\":\"uint32\",\"internalType\":\"uint32\"},{\"name\":\"maximumBaseFee\",\"type\":\"uint128\",\"internalType\":\"uint128\"}]},{\"name\":\"_batchInbox\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"_addresses\",\"type\":\"tuple\",\"internalType\":\"structSystemConfig.Addresses\",\"components\":[{\"name\":\"l1CrossDomainMessenger\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"l1ERC721Bridge\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"l1StandardBridge\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"optimismPortal\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"optimismMintableERC20Factory\",\"type\":\"address\",\"internalType\":\"address\"}]},{\"name\":\"_l2ChainId\",\"type\":\"uint256\",\"internalType\":\"uint256\"},{\"name\":\"_superchainConfig\",\"type\":\"address\",\"internalType\":\"contractISuperchainConfig\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"isFeatureEnabled\",\"inputs\":[{\"name\":\"\",\"type\":\"bytes32\",\"internalType\":\"bytes32\"}],\"outputs\":[{\"name\":\"\",\"type\":\"bool\",\"internalType\":\"bool\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"l1CrossDomainMessenger\",\"inputs\":[],\"outputs\":[{\"name\":\"addr_\",\"type\":\"address\",\"internalType\":\"address\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"l1ERC721Bridge\",\"inputs\":[],\"outputs\":[{\"name\":\"addr_\",\"type\":\"address\",\"internalType\":\"address\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"l1StandardBridge\",\"inputs\":[],\"outputs\":[{\"name\":\"addr_\",\"type\":\"address\",\"internalType\":\"address\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"l2ChainId\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"maximumGasLimit\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"uint64\",\"internalType\":\"uint64\"}],\"stateMutability\":\"pure\"},{\"type\":\"function\",\"name\":\"minBaseFee\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"uint64\",\"internalType\":\"uint64\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"minimumGasLimit\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"uint64\",\"internalType\":\"uint64\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"operatorFeeConstant\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"uint64\",\"internalType\":\"uint64\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"operatorFeeScalar\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"uint32\",\"internalType\":\"uint32\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"optimismMintableERC20Factory\",\"inputs\":[],\"outputs\":[{\"name\":\"addr_\",\"type\":\"address\",\"internalType\":\"address\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"optimismPortal\",\"inputs\":[],\"outputs\":[{\"name\":\"addr_\",\"type\":\"address\",\"internalType\":\"address\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"overhead\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"owner\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"address\",\"internalType\":\"address\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"paused\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"bool\",\"internalType\":\"bool\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"proxyAdmin\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"address\",\"internalType\":\"contractIProxyAdmin\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"proxyAdminOwner\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"address\",\"internalType\":\"address\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"renounceOwnership\",\"inputs\":[],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"resourceConfig\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"tuple\",\"internalType\":\"structIResourceMetering.ResourceConfig\",\"components\":[{\"name\":\"maxResourceLimit\",\"type\":\"uint32\",\"internalType\":\"uint32\"},{\"name\":\"elasticityMultiplier\",\"type\":\"uint8\",\"internalType\":\"uint8\"},{\"name\":\"baseFeeMaxChangeDenominator\",\"type\":\"uint8\",\"internalType\":\"uint8\"},{\"name\":\"minimumBaseFee\",\"type\":\"uint32\",\"internalType\":\"uint32\"},{\"name\":\"systemTxMaxGas\",\"type\":\"uint32\",\"internalType\":\"uint32\"},{\"name\":\"maximumBaseFee\",\"type\":\"uint128\",\"internalType\":\"uint128\"}]}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"scalar\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"setBatcherHash\",\"inputs\":[{\"name\":\"_batcherHash\",\"type\":\"bytes32\",\"internalType\":\"bytes32\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"setDAFootprintGasScalar\",\"inputs\":[{\"name\":\"_daFootprintGasScalar\",\"type\":\"uint16\",\"internalType\":\"uint16\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"setEIP1559Params\",\"inputs\":[{\"name\":\"_denominator\",\"type\":\"uint32\",\"internalType\":\"uint32\"},{\"name\":\"_elasticity\",\"type\":\"uint32\",\"internalType\":\"uint32\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"setFeature\",\"inputs\":[{\"name\":\"_feature\",\"type\":\"bytes32\",\"internalType\":\"bytes32\"},{\"name\":\"_enabled\",\"type\":\"bool\",\"internalType\":\"bool\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"setGasConfig\",\"inputs\":[{\"name\":\"_overhead\",\"type\":\"uint256\",\"internalType\":\"uint256\"},{\"name\":\"_scalar\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"setGasConfigEcotone\",\"inputs\":[{\"name\":\"_basefeeScalar\",\"type\":\"uint32\",\"internalType\":\"uint32\"},{\"name\":\"_blobbasefeeScalar\",\"type\":\"uint32\",\"internalType\":\"uint32\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"setGasLimit\",\"inputs\":[{\"name\":\"_gasLimit\",\"type\":\"uint64\",\"internalType\":\"uint64\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"setMinBaseFee\",\"inputs\":[{\"name\":\"_minBaseFee\",\"type\":\"uint64\",\"internalType\":\"uint64\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"setOperatorFeeScalars\",\"inputs\":[{\"name\":\"_operatorFeeScalar\",\"type\":\"uint32\",\"internalType\":\"uint32\"},{\"name\":\"_operatorFeeConstant\",\"type\":\"uint64\",\"internalType\":\"uint64\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"setUnsafeBlockSigner\",\"inputs\":[{\"name\":\"_unsafeBlockSigner\",\"type\":\"address\",\"internalType\":\"address\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"startBlock\",\"inputs\":[],\"outputs\":[{\"name\":\"startBlock_\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"superchainConfig\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"address\",\"internalType\":\"contractISuperchainConfig\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"transferOwnership\",\"inputs\":[{\"name\":\"newOwner\",\"type\":\"address\",\"internalType\":\"address\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"unsafeBlockSigner\",\"inputs\":[],\"outputs\":[{\"name\":\"addr_\",\"type\":\"address\",\"internalType\":\"address\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"version\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"string\",\"internalType\":\"string\"}],\"stateMutability\":\"pure\"},{\"type\":\"event\",\"name\":\"ConfigUpdate\",\"inputs\":[{\"name\":\"version\",\"type\":\"uint256\",\"indexed\":true,\"internalType\":\"uint256\"},{\"name\":\"updateType\",\"type\":\"uint8\",\"indexed\":true,\"internalType\":\"enumSystemConfig.UpdateType\"},{\"name\":\"data\",\"type\":\"bytes\",\"indexed\":false,\"internalType\":\"bytes\"}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"FeatureSet\",\"inputs\":[{\"name\":\"feature\",\"type\":\"bytes32\",\"indexed\":true,\"internalType\":\"bytes32\"},{\"name\":\"enabled\",\"type\":\"bool\",\"indexed\":true,\"internalType\":\"bool\"}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"Initialized\",\"inputs\":[{\"name\":\"version\",\"type\":\"uint8\",\"indexed\":false,\"internalType\":\"uint8\"}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"OwnershipTransferred\",\"inputs\":[{\"name\":\"previousOwner\",\"type\":\"address\",\"indexed\":true,\"internalType\":\"address\"},{\"name\":\"newOwner\",\"type\":\"address\",\"indexed\":true,\"internalType\":\"address\"}],\"anonymous\":false},{\"type\":\"error\",\"name\":\"ProxyAdminOwnedBase_NotProxyAdmin\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"ProxyAdminOwnedBase_NotProxyAdminOrProxyAdminOwner\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"ProxyAdminOwnedBase_NotProxyAdminOwner\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"ProxyAdminOwnedBase_NotResolvedDelegateProxy\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"ProxyAdminOwnedBase_NotSharedProxyAdminOwner\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"ProxyAdminOwnedBase_ProxyAdminNotFound\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"ReinitializableBase_ZeroInitVersion\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"SystemConfig_InvalidFeatureState\",\"inputs\":[]}]", } // SystemConfigABI is the input ABI used to generate the binding from. @@ -602,6 +602,37 @@ func (_SystemConfig *SystemConfigCallerSession) BlobbasefeeScalar() (uint32, err return _SystemConfig.Contract.BlobbasefeeScalar(&_SystemConfig.CallOpts) } +// DaFootprintGasScalar is a free data retrieval call binding the contract method 0xfe3d5710. +// +// Solidity: function daFootprintGasScalar() view returns(uint16) +func (_SystemConfig *SystemConfigCaller) DaFootprintGasScalar(opts *bind.CallOpts) (uint16, error) { + var out []interface{} + err := _SystemConfig.contract.Call(opts, &out, "daFootprintGasScalar") + + if err != nil { + return *new(uint16), err + } + + out0 := *abi.ConvertType(out[0], new(uint16)).(*uint16) + + return out0, err + +} + +// DaFootprintGasScalar is a free data retrieval call binding the contract method 0xfe3d5710. +// +// Solidity: function daFootprintGasScalar() view returns(uint16) +func (_SystemConfig *SystemConfigSession) DaFootprintGasScalar() (uint16, error) { + return _SystemConfig.Contract.DaFootprintGasScalar(&_SystemConfig.CallOpts) +} + +// DaFootprintGasScalar is a free data retrieval call binding the contract method 0xfe3d5710. +// +// Solidity: function daFootprintGasScalar() view returns(uint16) +func (_SystemConfig *SystemConfigCallerSession) DaFootprintGasScalar() (uint16, error) { + return _SystemConfig.Contract.DaFootprintGasScalar(&_SystemConfig.CallOpts) +} + // DisputeGameFactory is a free data retrieval call binding the contract method 0xf2b4e617. // // Solidity: function disputeGameFactory() view returns(address addr_) @@ -757,6 +788,99 @@ func (_SystemConfig *SystemConfigCallerSession) GetAddresses() (SystemConfigAddr return _SystemConfig.Contract.GetAddresses(&_SystemConfig.CallOpts) } +// Guardian is a free data retrieval call binding the contract method 0x452a9320. +// +// Solidity: function guardian() view returns(address) +func (_SystemConfig *SystemConfigCaller) Guardian(opts *bind.CallOpts) (common.Address, error) { + var out []interface{} + err := _SystemConfig.contract.Call(opts, &out, "guardian") + + if err != nil { + return *new(common.Address), err + } + + out0 := *abi.ConvertType(out[0], new(common.Address)).(*common.Address) + + return out0, err + +} + +// Guardian is a free data retrieval call binding the contract method 0x452a9320. +// +// Solidity: function guardian() view returns(address) +func (_SystemConfig *SystemConfigSession) Guardian() (common.Address, error) { + return _SystemConfig.Contract.Guardian(&_SystemConfig.CallOpts) +} + +// Guardian is a free data retrieval call binding the contract method 0x452a9320. +// +// Solidity: function guardian() view returns(address) +func (_SystemConfig *SystemConfigCallerSession) Guardian() (common.Address, error) { + return _SystemConfig.Contract.Guardian(&_SystemConfig.CallOpts) +} + +// InitVersion is a free data retrieval call binding the contract method 0x38d38c97. +// +// Solidity: function initVersion() view returns(uint8) +func (_SystemConfig *SystemConfigCaller) InitVersion(opts *bind.CallOpts) (uint8, error) { + var out []interface{} + err := _SystemConfig.contract.Call(opts, &out, "initVersion") + + if err != nil { + return *new(uint8), err + } + + out0 := *abi.ConvertType(out[0], new(uint8)).(*uint8) + + return out0, err + +} + +// InitVersion is a free data retrieval call binding the contract method 0x38d38c97. +// +// Solidity: function initVersion() view returns(uint8) +func (_SystemConfig *SystemConfigSession) InitVersion() (uint8, error) { + return _SystemConfig.Contract.InitVersion(&_SystemConfig.CallOpts) +} + +// InitVersion is a free data retrieval call binding the contract method 0x38d38c97. +// +// Solidity: function initVersion() view returns(uint8) +func (_SystemConfig *SystemConfigCallerSession) InitVersion() (uint8, error) { + return _SystemConfig.Contract.InitVersion(&_SystemConfig.CallOpts) +} + +// IsFeatureEnabled is a free data retrieval call binding the contract method 0x47af267b. +// +// Solidity: function isFeatureEnabled(bytes32 ) view returns(bool) +func (_SystemConfig *SystemConfigCaller) IsFeatureEnabled(opts *bind.CallOpts, arg0 [32]byte) (bool, error) { + var out []interface{} + err := _SystemConfig.contract.Call(opts, &out, "isFeatureEnabled", arg0) + + if err != nil { + return *new(bool), err + } + + out0 := *abi.ConvertType(out[0], new(bool)).(*bool) + + return out0, err + +} + +// IsFeatureEnabled is a free data retrieval call binding the contract method 0x47af267b. +// +// Solidity: function isFeatureEnabled(bytes32 ) view returns(bool) +func (_SystemConfig *SystemConfigSession) IsFeatureEnabled(arg0 [32]byte) (bool, error) { + return _SystemConfig.Contract.IsFeatureEnabled(&_SystemConfig.CallOpts, arg0) +} + +// IsFeatureEnabled is a free data retrieval call binding the contract method 0x47af267b. +// +// Solidity: function isFeatureEnabled(bytes32 ) view returns(bool) +func (_SystemConfig *SystemConfigCallerSession) IsFeatureEnabled(arg0 [32]byte) (bool, error) { + return _SystemConfig.Contract.IsFeatureEnabled(&_SystemConfig.CallOpts, arg0) +} + // L1CrossDomainMessenger is a free data retrieval call binding the contract method 0xa7119869. // // Solidity: function l1CrossDomainMessenger() view returns(address addr_) @@ -850,6 +974,37 @@ func (_SystemConfig *SystemConfigCallerSession) L1StandardBridge() (common.Addre return _SystemConfig.Contract.L1StandardBridge(&_SystemConfig.CallOpts) } +// L2ChainId is a free data retrieval call binding the contract method 0xd6ae3cd5. +// +// Solidity: function l2ChainId() view returns(uint256) +func (_SystemConfig *SystemConfigCaller) L2ChainId(opts *bind.CallOpts) (*big.Int, error) { + var out []interface{} + err := _SystemConfig.contract.Call(opts, &out, "l2ChainId") + + if err != nil { + return *new(*big.Int), err + } + + out0 := *abi.ConvertType(out[0], new(*big.Int)).(**big.Int) + + return out0, err + +} + +// L2ChainId is a free data retrieval call binding the contract method 0xd6ae3cd5. +// +// Solidity: function l2ChainId() view returns(uint256) +func (_SystemConfig *SystemConfigSession) L2ChainId() (*big.Int, error) { + return _SystemConfig.Contract.L2ChainId(&_SystemConfig.CallOpts) +} + +// L2ChainId is a free data retrieval call binding the contract method 0xd6ae3cd5. +// +// Solidity: function l2ChainId() view returns(uint256) +func (_SystemConfig *SystemConfigCallerSession) L2ChainId() (*big.Int, error) { + return _SystemConfig.Contract.L2ChainId(&_SystemConfig.CallOpts) +} + // MaximumGasLimit is a free data retrieval call binding the contract method 0x0ae14b1b. // // Solidity: function maximumGasLimit() pure returns(uint64) @@ -1129,6 +1284,99 @@ func (_SystemConfig *SystemConfigCallerSession) Owner() (common.Address, error) return _SystemConfig.Contract.Owner(&_SystemConfig.CallOpts) } +// Paused is a free data retrieval call binding the contract method 0x5c975abb. +// +// Solidity: function paused() view returns(bool) +func (_SystemConfig *SystemConfigCaller) Paused(opts *bind.CallOpts) (bool, error) { + var out []interface{} + err := _SystemConfig.contract.Call(opts, &out, "paused") + + if err != nil { + return *new(bool), err + } + + out0 := *abi.ConvertType(out[0], new(bool)).(*bool) + + return out0, err + +} + +// Paused is a free data retrieval call binding the contract method 0x5c975abb. +// +// Solidity: function paused() view returns(bool) +func (_SystemConfig *SystemConfigSession) Paused() (bool, error) { + return _SystemConfig.Contract.Paused(&_SystemConfig.CallOpts) +} + +// Paused is a free data retrieval call binding the contract method 0x5c975abb. +// +// Solidity: function paused() view returns(bool) +func (_SystemConfig *SystemConfigCallerSession) Paused() (bool, error) { + return _SystemConfig.Contract.Paused(&_SystemConfig.CallOpts) +} + +// ProxyAdmin is a free data retrieval call binding the contract method 0x3e47158c. +// +// Solidity: function proxyAdmin() view returns(address) +func (_SystemConfig *SystemConfigCaller) ProxyAdmin(opts *bind.CallOpts) (common.Address, error) { + var out []interface{} + err := _SystemConfig.contract.Call(opts, &out, "proxyAdmin") + + if err != nil { + return *new(common.Address), err + } + + out0 := *abi.ConvertType(out[0], new(common.Address)).(*common.Address) + + return out0, err + +} + +// ProxyAdmin is a free data retrieval call binding the contract method 0x3e47158c. +// +// Solidity: function proxyAdmin() view returns(address) +func (_SystemConfig *SystemConfigSession) ProxyAdmin() (common.Address, error) { + return _SystemConfig.Contract.ProxyAdmin(&_SystemConfig.CallOpts) +} + +// ProxyAdmin is a free data retrieval call binding the contract method 0x3e47158c. +// +// Solidity: function proxyAdmin() view returns(address) +func (_SystemConfig *SystemConfigCallerSession) ProxyAdmin() (common.Address, error) { + return _SystemConfig.Contract.ProxyAdmin(&_SystemConfig.CallOpts) +} + +// ProxyAdminOwner is a free data retrieval call binding the contract method 0xdad544e0. +// +// Solidity: function proxyAdminOwner() view returns(address) +func (_SystemConfig *SystemConfigCaller) ProxyAdminOwner(opts *bind.CallOpts) (common.Address, error) { + var out []interface{} + err := _SystemConfig.contract.Call(opts, &out, "proxyAdminOwner") + + if err != nil { + return *new(common.Address), err + } + + out0 := *abi.ConvertType(out[0], new(common.Address)).(*common.Address) + + return out0, err + +} + +// ProxyAdminOwner is a free data retrieval call binding the contract method 0xdad544e0. +// +// Solidity: function proxyAdminOwner() view returns(address) +func (_SystemConfig *SystemConfigSession) ProxyAdminOwner() (common.Address, error) { + return _SystemConfig.Contract.ProxyAdminOwner(&_SystemConfig.CallOpts) +} + +// ProxyAdminOwner is a free data retrieval call binding the contract method 0xdad544e0. +// +// Solidity: function proxyAdminOwner() view returns(address) +func (_SystemConfig *SystemConfigCallerSession) ProxyAdminOwner() (common.Address, error) { + return _SystemConfig.Contract.ProxyAdminOwner(&_SystemConfig.CallOpts) +} + // ResourceConfig is a free data retrieval call binding the contract method 0xcc731b02. // // Solidity: function resourceConfig() view returns((uint32,uint8,uint8,uint32,uint32,uint128)) @@ -1222,6 +1470,37 @@ func (_SystemConfig *SystemConfigCallerSession) StartBlock() (*big.Int, error) { return _SystemConfig.Contract.StartBlock(&_SystemConfig.CallOpts) } +// SuperchainConfig is a free data retrieval call binding the contract method 0x35e80ab3. +// +// Solidity: function superchainConfig() view returns(address) +func (_SystemConfig *SystemConfigCaller) SuperchainConfig(opts *bind.CallOpts) (common.Address, error) { + var out []interface{} + err := _SystemConfig.contract.Call(opts, &out, "superchainConfig") + + if err != nil { + return *new(common.Address), err + } + + out0 := *abi.ConvertType(out[0], new(common.Address)).(*common.Address) + + return out0, err + +} + +// SuperchainConfig is a free data retrieval call binding the contract method 0x35e80ab3. +// +// Solidity: function superchainConfig() view returns(address) +func (_SystemConfig *SystemConfigSession) SuperchainConfig() (common.Address, error) { + return _SystemConfig.Contract.SuperchainConfig(&_SystemConfig.CallOpts) +} + +// SuperchainConfig is a free data retrieval call binding the contract method 0x35e80ab3. +// +// Solidity: function superchainConfig() view returns(address) +func (_SystemConfig *SystemConfigCallerSession) SuperchainConfig() (common.Address, error) { + return _SystemConfig.Contract.SuperchainConfig(&_SystemConfig.CallOpts) +} + // UnsafeBlockSigner is a free data retrieval call binding the contract method 0x1fd19ee1. // // Solidity: function unsafeBlockSigner() view returns(address addr_) @@ -1347,6 +1626,27 @@ func (_SystemConfig *SystemConfigTransactorSession) SetBatcherHash(_batcherHash return _SystemConfig.Contract.SetBatcherHash(&_SystemConfig.TransactOpts, _batcherHash) } +// SetDAFootprintGasScalar is a paid mutator transaction binding the contract method 0x20f06fdc. +// +// Solidity: function setDAFootprintGasScalar(uint16 _daFootprintGasScalar) returns() +func (_SystemConfig *SystemConfigTransactor) SetDAFootprintGasScalar(opts *bind.TransactOpts, _daFootprintGasScalar uint16) (*types.Transaction, error) { + return _SystemConfig.contract.Transact(opts, "setDAFootprintGasScalar", _daFootprintGasScalar) +} + +// SetDAFootprintGasScalar is a paid mutator transaction binding the contract method 0x20f06fdc. +// +// Solidity: function setDAFootprintGasScalar(uint16 _daFootprintGasScalar) returns() +func (_SystemConfig *SystemConfigSession) SetDAFootprintGasScalar(_daFootprintGasScalar uint16) (*types.Transaction, error) { + return _SystemConfig.Contract.SetDAFootprintGasScalar(&_SystemConfig.TransactOpts, _daFootprintGasScalar) +} + +// SetDAFootprintGasScalar is a paid mutator transaction binding the contract method 0x20f06fdc. +// +// Solidity: function setDAFootprintGasScalar(uint16 _daFootprintGasScalar) returns() +func (_SystemConfig *SystemConfigTransactorSession) SetDAFootprintGasScalar(_daFootprintGasScalar uint16) (*types.Transaction, error) { + return _SystemConfig.Contract.SetDAFootprintGasScalar(&_SystemConfig.TransactOpts, _daFootprintGasScalar) +} + // SetEIP1559Params is a paid mutator transaction binding the contract method 0xc0fd4b41. // // Solidity: function setEIP1559Params(uint32 _denominator, uint32 _elasticity) returns() @@ -1368,6 +1668,27 @@ func (_SystemConfig *SystemConfigTransactorSession) SetEIP1559Params(_denominato return _SystemConfig.Contract.SetEIP1559Params(&_SystemConfig.TransactOpts, _denominator, _elasticity) } +// SetFeature is a paid mutator transaction binding the contract method 0xf2c4bc9e. +// +// Solidity: function setFeature(bytes32 _feature, bool _enabled) returns() +func (_SystemConfig *SystemConfigTransactor) SetFeature(opts *bind.TransactOpts, _feature [32]byte, _enabled bool) (*types.Transaction, error) { + return _SystemConfig.contract.Transact(opts, "setFeature", _feature, _enabled) +} + +// SetFeature is a paid mutator transaction binding the contract method 0xf2c4bc9e. +// +// Solidity: function setFeature(bytes32 _feature, bool _enabled) returns() +func (_SystemConfig *SystemConfigSession) SetFeature(_feature [32]byte, _enabled bool) (*types.Transaction, error) { + return _SystemConfig.Contract.SetFeature(&_SystemConfig.TransactOpts, _feature, _enabled) +} + +// SetFeature is a paid mutator transaction binding the contract method 0xf2c4bc9e. +// +// Solidity: function setFeature(bytes32 _feature, bool _enabled) returns() +func (_SystemConfig *SystemConfigTransactorSession) SetFeature(_feature [32]byte, _enabled bool) (*types.Transaction, error) { + return _SystemConfig.Contract.SetFeature(&_SystemConfig.TransactOpts, _feature, _enabled) +} + // SetGasConfig is a paid mutator transaction binding the contract method 0x935f029e. // // Solidity: function setGasConfig(uint256 _overhead, uint256 _scalar) returns() @@ -1669,6 +1990,159 @@ func (_SystemConfig *SystemConfigFilterer) ParseConfigUpdate(log types.Log) (*Sy return event, nil } +// SystemConfigFeatureSetIterator is returned from FilterFeatureSet and is used to iterate over the raw logs and unpacked data for FeatureSet events raised by the SystemConfig contract. +type SystemConfigFeatureSetIterator struct { + Event *SystemConfigFeatureSet // Event containing the contract specifics and raw log + + contract *bind.BoundContract // Generic contract to use for unpacking event data + event string // Event name to use for unpacking event data + + logs chan types.Log // Log channel receiving the found contract events + sub ethereum.Subscription // Subscription for errors, completion and termination + done bool // Whether the subscription completed delivering logs + fail error // Occurred error to stop iteration +} + +// Next advances the iterator to the subsequent event, returning whether there +// are any more events found. In case of a retrieval or parsing error, false is +// returned and Error() can be queried for the exact failure. +func (it *SystemConfigFeatureSetIterator) Next() bool { + // If the iterator failed, stop iterating + if it.fail != nil { + return false + } + // If the iterator completed, deliver directly whatever's available + if it.done { + select { + case log := <-it.logs: + it.Event = new(SystemConfigFeatureSet) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + default: + return false + } + } + // Iterator still in progress, wait for either a data or an error event + select { + case log := <-it.logs: + it.Event = new(SystemConfigFeatureSet) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + case err := <-it.sub.Err(): + it.done = true + it.fail = err + return it.Next() + } +} + +// Error returns any retrieval or parsing error occurred during filtering. +func (it *SystemConfigFeatureSetIterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *SystemConfigFeatureSetIterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// SystemConfigFeatureSet represents a FeatureSet event raised by the SystemConfig contract. +type SystemConfigFeatureSet struct { + Feature [32]byte + Enabled bool + Raw types.Log // Blockchain specific contextual infos +} + +// FilterFeatureSet is a free log retrieval operation binding the contract event 0xb876f6594132c89891d2fd198e925e999be741ec809abb58bfe9b966876cc06c. +// +// Solidity: event FeatureSet(bytes32 indexed feature, bool indexed enabled) +func (_SystemConfig *SystemConfigFilterer) FilterFeatureSet(opts *bind.FilterOpts, feature [][32]byte, enabled []bool) (*SystemConfigFeatureSetIterator, error) { + + var featureRule []interface{} + for _, featureItem := range feature { + featureRule = append(featureRule, featureItem) + } + var enabledRule []interface{} + for _, enabledItem := range enabled { + enabledRule = append(enabledRule, enabledItem) + } + + logs, sub, err := _SystemConfig.contract.FilterLogs(opts, "FeatureSet", featureRule, enabledRule) + if err != nil { + return nil, err + } + return &SystemConfigFeatureSetIterator{contract: _SystemConfig.contract, event: "FeatureSet", logs: logs, sub: sub}, nil +} + +// WatchFeatureSet is a free log subscription operation binding the contract event 0xb876f6594132c89891d2fd198e925e999be741ec809abb58bfe9b966876cc06c. +// +// Solidity: event FeatureSet(bytes32 indexed feature, bool indexed enabled) +func (_SystemConfig *SystemConfigFilterer) WatchFeatureSet(opts *bind.WatchOpts, sink chan<- *SystemConfigFeatureSet, feature [][32]byte, enabled []bool) (event.Subscription, error) { + + var featureRule []interface{} + for _, featureItem := range feature { + featureRule = append(featureRule, featureItem) + } + var enabledRule []interface{} + for _, enabledItem := range enabled { + enabledRule = append(enabledRule, enabledItem) + } + + logs, sub, err := _SystemConfig.contract.WatchLogs(opts, "FeatureSet", featureRule, enabledRule) + if err != nil { + return nil, err + } + return event.NewSubscription(func(quit <-chan struct{}) error { + defer sub.Unsubscribe() + for { + select { + case log := <-logs: + // New log arrived, parse the event and forward to the user + event := new(SystemConfigFeatureSet) + if err := _SystemConfig.contract.UnpackLog(event, "FeatureSet", log); err != nil { + return err + } + event.Raw = log + + select { + case sink <- event: + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + } + }), nil +} + +// ParseFeatureSet is a log parse operation binding the contract event 0xb876f6594132c89891d2fd198e925e999be741ec809abb58bfe9b966876cc06c. +// +// Solidity: event FeatureSet(bytes32 indexed feature, bool indexed enabled) +func (_SystemConfig *SystemConfigFilterer) ParseFeatureSet(log types.Log) (*SystemConfigFeatureSet, error) { + event := new(SystemConfigFeatureSet) + if err := _SystemConfig.contract.UnpackLog(event, "FeatureSet", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +} + // SystemConfigInitializedIterator is returned from FilterInitialized and is used to iterate over the raw logs and unpacked data for Initialized events raised by the SystemConfig contract. type SystemConfigInitializedIterator struct { Event *SystemConfigInitialized // Event containing the contract specifics and raw log diff --git a/op-e2e/e2eutils/intentbuilder/builder.go b/op-e2e/e2eutils/intentbuilder/builder.go index be8d4d8c8ea..df30e53a082 100644 --- a/op-e2e/e2eutils/intentbuilder/builder.go +++ b/op-e2e/e2eutils/intentbuilder/builder.go @@ -58,6 +58,7 @@ type L2Configurator interface { L2FeesConfigurator L2HardforkConfigurator WithPrefundedAccount(addr common.Address, amount uint256.Int) L2Configurator + WithDAFootprintGasScalar(scalar uint16) } type ContractsConfigurator interface { @@ -417,6 +418,10 @@ func (c *l2Configurator) WithOperatorFeeScalar(value uint64) { c.builder.intent.Chains[c.chainIndex].OperatorFeeScalar = uint32(value) } +func (c *l2Configurator) WithDAFootprintGasScalar(value uint16) { + c.builder.intent.Chains[c.chainIndex].DAFootprintGasScalar = value +} + func (c *l2Configurator) WithOperatorFeeConstant(value uint64) { c.builder.intent.Chains[c.chainIndex].OperatorFeeConstant = value } diff --git a/op-e2e/e2eutils/intentbuilder/builder_test.go b/op-e2e/e2eutils/intentbuilder/builder_test.go index d98eec5ce38..7d8d9862c91 100644 --- a/op-e2e/e2eutils/intentbuilder/builder_test.go +++ b/op-e2e/e2eutils/intentbuilder/builder_test.go @@ -110,6 +110,7 @@ func TestBuilder(t *testing.T) { l2Config.WithEIP1559Elasticity(10) l2Config.WithOperatorFeeScalar(100) l2Config.WithOperatorFeeConstant(200) + l2Config.WithDAFootprintGasScalar(400) // Test L2HardforkConfigurator methods isthmusOffset := uint64(8000) @@ -152,6 +153,7 @@ func TestBuilder(t *testing.T) { BaseFeeVaultRecipient: baseFeeRecipient, SequencerFeeVaultRecipient: sequencerFeeRecipient, L1FeeVaultRecipient: l1FeeRecipient, + DAFootprintGasScalar: 400, Roles: state.ChainRoles{ L1ProxyAdminOwner: l1ProxyAdminOwner, L2ProxyAdminOwner: l2ProxyAdminOwner, diff --git a/op-e2e/e2eutils/setup.go b/op-e2e/e2eutils/setup.go index bfd1d123b48..d46831b63ef 100644 --- a/op-e2e/e2eutils/setup.go +++ b/op-e2e/e2eutils/setup.go @@ -109,12 +109,12 @@ func Ether(v uint64) *big.Int { } func GetL2AllocsMode(dc *genesis.DeployConfig, t uint64) genesis.L2AllocsMode { - if fork := dc.JovianTime(t); fork != nil && *fork <= 0 { - return genesis.L2AllocsJovian - } if fork := dc.InteropTime(t); fork != nil && *fork <= 0 { return genesis.L2AllocsInterop } + if fork := dc.JovianTime(t); fork != nil && *fork <= 0 { + return genesis.L2AllocsJovian + } if fork := dc.IsthmusTime(t); fork != nil && *fork <= 0 { return genesis.L2AllocsIsthmus } diff --git a/op-node/rollup/derive/attributes.go b/op-node/rollup/derive/attributes.go index d903bbdf7ab..7d9fedef07a 100644 --- a/op-node/rollup/derive/attributes.go +++ b/op-node/rollup/derive/attributes.go @@ -145,6 +145,14 @@ func (ba *FetchingAttributesBuilder) PreparePayloadAttributes(ctx context.Contex upgradeTxs = append(upgradeTxs, isthmus...) } + if ba.rollupCfg.IsJovianActivationBlock(nextL2Time) && ba.rollupCfg.IsDAFootprintBlockLimit(nextL2Time) { + jovian, err := DAFootprintNetworkUpgradeTransactions() + if err != nil { + return nil, NewCriticalError(fmt.Errorf("failed to build jovian network upgrade txs: %w", err)) + } + upgradeTxs = append(upgradeTxs, jovian...) + } + if ba.rollupCfg.IsInteropActivationBlock(nextL2Time) { interop, err := InteropNetworkUpgradeTransactions() if err != nil { diff --git a/op-node/rollup/derive/jovian_upgrade_transactions.go b/op-node/rollup/derive/jovian_upgrade_transactions.go new file mode 100644 index 00000000000..564b8ea7f70 --- /dev/null +++ b/op-node/rollup/derive/jovian_upgrade_transactions.go @@ -0,0 +1,55 @@ +package derive + +import ( + "fmt" + "math/big" + + "github.com/ethereum-optimism/optimism/op-service/predeploys" + "github.com/ethereum/go-ethereum/common" + "github.com/ethereum/go-ethereum/common/hexutil" + "github.com/ethereum/go-ethereum/core/types" + "github.com/ethereum/go-ethereum/crypto" +) + +var ( + // L1Block Parameters + deployJovianL1BlockSource = UpgradeDepositSource{Intent: "Jovian: L1 Block Deployment"} + updateJovianL1BlockProxySource = UpgradeDepositSource{Intent: "Jovian: L1 Block Proxy Update"} + L1BlockJovianDeployerAddress = common.HexToAddress("0x4210000000000000000000000000000000000006") + jovianL1BlockAddress = crypto.CreateAddress(L1BlockJovianDeployerAddress, 0) + + // Bytecode generated from commit 41614ab527df1cf74f9820f60d8f588ade769679 + l1BlockJovianDeploymentBytecode = common.FromHex("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") +) + +func DAFootprintNetworkUpgradeTransactions() ([]hexutil.Bytes, error) { + deployL1Block, err := types.NewTx(&types.DepositTx{ + SourceHash: deployJovianL1BlockSource.SourceHash(), + From: L1BlockJovianDeployerAddress, + To: nil, + Mint: big.NewInt(0), + Value: big.NewInt(0), + Gas: 450_371, + IsSystemTransaction: false, + Data: l1BlockJovianDeploymentBytecode, + }).MarshalBinary() + if err != nil { + return nil, fmt.Errorf("build tx to deploy L1 block transaction: %w", err) + } + + updateL1BlockProxy, err := types.NewTx(&types.DepositTx{ + SourceHash: updateJovianL1BlockProxySource.SourceHash(), + From: common.Address{}, + To: &predeploys.L1BlockAddr, + Mint: big.NewInt(0), + Value: big.NewInt(0), + Gas: 50_000, + IsSystemTransaction: false, + Data: upgradeToCalldata(jovianL1BlockAddress), + }).MarshalBinary() + if err != nil { + return nil, fmt.Errorf("build tx to the update L1 block proxy: %w", err) + } + + return []hexutil.Bytes{deployL1Block, updateL1BlockProxy}, nil +} diff --git a/op-node/rollup/derive/l1_block_info.go b/op-node/rollup/derive/l1_block_info.go index af063d65b33..25d79b1668c 100644 --- a/op-node/rollup/derive/l1_block_info.go +++ b/op-node/rollup/derive/l1_block_info.go @@ -5,6 +5,7 @@ import ( "encoding/binary" "errors" "fmt" + "io" "math/big" "github.com/ethereum/go-ethereum/common" @@ -22,20 +23,25 @@ const ( L1InfoFuncBedrockSignature = "setL1BlockValues(uint64,uint64,uint256,bytes32,uint64,bytes32,uint256,uint256)" L1InfoFuncEcotoneSignature = "setL1BlockValuesEcotone()" L1InfoFuncIsthmusSignature = "setL1BlockValuesIsthmus()" - L1InfoArguments = 8 - L1InfoBedrockLen = 4 + 32*L1InfoArguments - L1InfoEcotoneLen = 4 + 32*5 // after Ecotone upgrade, args are packed into 5 32-byte slots - L1InfoIsthmusLen = 4 + 32*5 + 4 + 8 // after Isthmus upgrade, additionally pack in operator fee scalar and constant + L1InfoFuncJovianSignature = "setL1BlockValuesJovian()" + + L1InfoArguments = 8 + L1InfoBedrockLen = 4 + 32*L1InfoArguments + L1InfoEcotoneLen = 4 + 32*5 // after Ecotone upgrade, args are packed into 5 32-byte slots + L1InfoIsthmusLen = 4 + 32*5 + 4 + 8 // after Isthmus upgrade, additionally pack in operator fee scalar and constant + L1InfoJovianLen = L1InfoIsthmusLen + 2 // after Jovian upgrade, additionally pack in DA footprint gas scalar ) var ( L1InfoFuncBedrockBytes4 = crypto.Keccak256([]byte(L1InfoFuncBedrockSignature))[:4] L1InfoFuncEcotoneBytes4 = crypto.Keccak256([]byte(L1InfoFuncEcotoneSignature))[:4] L1InfoFuncIsthmusBytes4 = crypto.Keccak256([]byte(L1InfoFuncIsthmusSignature))[:4] + L1InfoFuncJovianBytes4 = crypto.Keccak256([]byte(L1InfoFuncJovianSignature))[:4] L1InfoDepositerAddress = common.HexToAddress("0xdeaddeaddeaddeaddeaddeaddeaddeaddead0001") L1BlockAddress = predeploys.L1BlockAddr - ErrInvalidFormat = errors.New("invalid ecotone l1 block info format") + ErrInvalidEcotoneFormat = errors.New("invalid ecotone l1 block info format") ErrInvalidIsthmusFormat = errors.New("invalid isthmus l1 block info format") + ErrInvalidJovianFormat = errors.New("invalid jovian l1 block info format") ) const ( @@ -63,6 +69,8 @@ type L1BlockInfo struct { OperatorFeeScalar uint32 // added by Isthmus upgrade OperatorFeeConstant uint64 // added by Isthmus upgrade + + DAFootprintGasScalar uint16 // added by Jovian upgrade } // Bedrock Binary Format @@ -169,43 +177,53 @@ func (info *L1BlockInfo) unmarshalBinaryBedrock(data []byte) error { // +---------+--------------------------+ func (info *L1BlockInfo) marshalBinaryEcotone() ([]byte, error) { - w := bytes.NewBuffer(make([]byte, 0, L1InfoEcotoneLen)) // Ecotone and Interop have the same length + w := bytes.NewBuffer(make([]byte, 0, L1InfoEcotoneLen)) if err := solabi.WriteSignature(w, L1InfoFuncEcotoneBytes4); err != nil { return nil, err } - if err := binary.Write(w, binary.BigEndian, info.BaseFeeScalar); err != nil { + if err := info.writeBinaryEcotone(w); err != nil { return nil, err } + return w.Bytes(), nil +} + +// writeBinaryEcotone writes all fields up to the Ecotone fork into the [L1BlockInfo] struct. It does not write the +// first 4 function signature bytes. This is expected to be done by [L1BlockInfo.marshalBinaryEcotone]. Furthermore, +// writeBinaryEcotone can be called by future fork binary writer implementations that share the same initial fields. +func (info *L1BlockInfo) writeBinaryEcotone(w io.Writer) error { + if err := binary.Write(w, binary.BigEndian, info.BaseFeeScalar); err != nil { + return err + } if err := binary.Write(w, binary.BigEndian, info.BlobBaseFeeScalar); err != nil { - return nil, err + return err } if err := binary.Write(w, binary.BigEndian, info.SequenceNumber); err != nil { - return nil, err + return err } if err := binary.Write(w, binary.BigEndian, info.Time); err != nil { - return nil, err + return err } if err := binary.Write(w, binary.BigEndian, info.Number); err != nil { - return nil, err + return err } if err := solabi.WriteUint256(w, info.BaseFee); err != nil { - return nil, err + return err } blobBasefee := info.BlobBaseFee if blobBasefee == nil { blobBasefee = big.NewInt(1) // set to 1, to match the min blob basefee as defined in EIP-4844 } if err := solabi.WriteUint256(w, blobBasefee); err != nil { - return nil, err + return err } if err := solabi.WriteHash(w, info.BlockHash); err != nil { - return nil, err + return err } // ABI encoding will perform the left-padding with zeroes to 32 bytes, matching the "batcherHash" SystemConfig format and version 0 byte. if err := solabi.WriteAddress(w, info.BatcherAddr); err != nil { - return nil, err + return err } - return w.Bytes(), nil + return nil } func (info *L1BlockInfo) unmarshalBinaryEcotone(data []byte) error { @@ -213,25 +231,38 @@ func (info *L1BlockInfo) unmarshalBinaryEcotone(data []byte) error { return fmt.Errorf("data is unexpected length: %d", len(data)) } r := bytes.NewReader(data) - - var err error if _, err := solabi.ReadAndValidateSignature(r, L1InfoFuncEcotoneBytes4); err != nil { return err } + if err := info.readBinaryEcotone(r); err != nil { + return err + } + if !solabi.EmptyReader(r) { + return errors.New("too many bytes") + } + return nil +} + +// readBinaryEcotone reads all fields up to the Ecotone fork into the [L1BlockInfo] struct. It does not read or verify the +// first 4 function signature bytes, nor does it expect the reader to be empty at the end. This is expected to be done +// by [L1BlockInfo.unmarshalBinaryEcotone]. Furthermore, readBinaryEcotone can be called by future fork binary reader +// implementations that share the same initial fields. +func (info *L1BlockInfo) readBinaryEcotone(r io.Reader) error { + var err error if err := binary.Read(r, binary.BigEndian, &info.BaseFeeScalar); err != nil { - return ErrInvalidFormat + return ErrInvalidEcotoneFormat } if err := binary.Read(r, binary.BigEndian, &info.BlobBaseFeeScalar); err != nil { - return ErrInvalidFormat + return ErrInvalidEcotoneFormat } if err := binary.Read(r, binary.BigEndian, &info.SequenceNumber); err != nil { - return ErrInvalidFormat + return ErrInvalidEcotoneFormat } if err := binary.Read(r, binary.BigEndian, &info.Time); err != nil { - return ErrInvalidFormat + return ErrInvalidEcotoneFormat } if err := binary.Read(r, binary.BigEndian, &info.Number); err != nil { - return ErrInvalidFormat + return ErrInvalidEcotoneFormat } if info.BaseFee, err = solabi.ReadUint256(r); err != nil { return err @@ -246,13 +277,10 @@ func (info *L1BlockInfo) unmarshalBinaryEcotone(data []byte) error { if info.BatcherAddr, err = solabi.ReadAddress(r); err != nil { return err } - if !solabi.EmptyReader(r) { - return errors.New("too many bytes") - } return nil } -// Interop & Isthmus Binary Format +// Isthmus Binary Format // +---------+--------------------------+ // | Bytes | Field | // +---------+--------------------------+ @@ -271,102 +299,119 @@ func (info *L1BlockInfo) unmarshalBinaryEcotone(data []byte) error { // +---------+--------------------------+ func (info *L1BlockInfo) marshalBinaryIsthmus() ([]byte, error) { - out, err := marshalBinaryWithSignature(info, L1InfoFuncIsthmusBytes4) - if err != nil { - return nil, fmt.Errorf("failed to marshal Isthmus l1 block info: %w", err) - } - return out, nil -} - -func marshalBinaryWithSignature(info *L1BlockInfo, signature []byte) ([]byte, error) { w := bytes.NewBuffer(make([]byte, 0, L1InfoIsthmusLen)) - if err := solabi.WriteSignature(w, signature); err != nil { - return nil, err - } - if err := binary.Write(w, binary.BigEndian, info.BaseFeeScalar); err != nil { - return nil, err - } - if err := binary.Write(w, binary.BigEndian, info.BlobBaseFeeScalar); err != nil { - return nil, err - } - if err := binary.Write(w, binary.BigEndian, info.SequenceNumber); err != nil { - return nil, err - } - if err := binary.Write(w, binary.BigEndian, info.Time); err != nil { - return nil, err - } - if err := binary.Write(w, binary.BigEndian, info.Number); err != nil { - return nil, err - } - if err := solabi.WriteUint256(w, info.BaseFee); err != nil { - return nil, err - } - blobBasefee := info.BlobBaseFee - if blobBasefee == nil { - blobBasefee = big.NewInt(1) // set to 1, to match the min blob basefee as defined in EIP-4844 - } - if err := solabi.WriteUint256(w, blobBasefee); err != nil { + if err := solabi.WriteSignature(w, L1InfoFuncIsthmusBytes4); err != nil { return nil, err } - if err := solabi.WriteHash(w, info.BlockHash); err != nil { + if err := info.writeBinaryIsthmus(w); err != nil { return nil, err } - // ABI encoding will perform the left-padding with zeroes to 32 bytes, matching the "batcherHash" SystemConfig format and version 0 byte. - if err := solabi.WriteAddress(w, info.BatcherAddr); err != nil { - return nil, err + return w.Bytes(), nil +} + +// writeBinaryIsthmus writes all fields up to the Isthmus fork into the [L1BlockInfo] struct. It does not write the +// first 4 function signature bytes. This is expected to be done by [L1BlockInfo.marshalBinaryIsthmus]. Furthermore, +// writeBinaryIsthmus can be called by future fork binary writer implementations that share the same initial fields. +func (info *L1BlockInfo) writeBinaryIsthmus(w io.Writer) error { + if err := info.writeBinaryEcotone(w); err != nil { + return err } if err := binary.Write(w, binary.BigEndian, info.OperatorFeeScalar); err != nil { - return nil, err + return err } if err := binary.Write(w, binary.BigEndian, info.OperatorFeeConstant); err != nil { - return nil, err + return err } - return w.Bytes(), nil + return nil } -func unmarshalBinaryWithSignatureAndData(info *L1BlockInfo, signature []byte, data []byte) error { +func (info *L1BlockInfo) unmarshalBinaryIsthmus(data []byte) error { if len(data) != L1InfoIsthmusLen { return fmt.Errorf("data is unexpected length: %d", len(data)) } r := bytes.NewReader(data) - - var err error - if _, err := solabi.ReadAndValidateSignature(r, signature); err != nil { + if _, err := solabi.ReadAndValidateSignature(r, []byte(L1InfoFuncIsthmusBytes4)); err != nil { return err } - if err := binary.Read(r, binary.BigEndian, &info.BaseFeeScalar); err != nil { - return ErrInvalidIsthmusFormat + if err := info.readBinaryIsthmus(r); err != nil { + return err } - if err := binary.Read(r, binary.BigEndian, &info.BlobBaseFeeScalar); err != nil { - return ErrInvalidIsthmusFormat + if !solabi.EmptyReader(r) { + return errors.New("too many bytes") } - if err := binary.Read(r, binary.BigEndian, &info.SequenceNumber); err != nil { - return ErrInvalidIsthmusFormat + return nil +} + +// readBinaryIsthmus reads all fields up to the Isthmus fork into the [L1BlockInfo] struct. It does not read or verify the +// first 4 function signature bytes, nor does it expect the reader to be empty at the end. This is expected to be done +// by [L1BlockInfo.unmarshalBinaryIsthmus]. Furthermore, readBinaryIsthmus can be called by future fork binary reader +// implementations that share the same initial fields. +func (info *L1BlockInfo) readBinaryIsthmus(r io.Reader) error { + if err := info.readBinaryEcotone(r); err != nil { + return err } - if err := binary.Read(r, binary.BigEndian, &info.Time); err != nil { + if err := binary.Read(r, binary.BigEndian, &info.OperatorFeeScalar); err != nil { return ErrInvalidIsthmusFormat } - if err := binary.Read(r, binary.BigEndian, &info.Number); err != nil { + if err := binary.Read(r, binary.BigEndian, &info.OperatorFeeConstant); err != nil { return ErrInvalidIsthmusFormat } - if info.BaseFee, err = solabi.ReadUint256(r); err != nil { - return err + return nil +} + +// Interop & Jovian Binary Format +// +---------+--------------------------+ +// | Bytes | Field | +// +---------+--------------------------+ +// | 4 | Function signature | +// | 4 | BaseFeeScalar | +// | 4 | BlobBaseFeeScalar | +// | 8 | SequenceNumber | +// | 8 | Timestamp | +// | 8 | L1BlockNumber | +// | 32 | BaseFee | +// | 32 | BlobBaseFee | +// | 32 | BlockHash | +// | 32 | BatcherHash | +// | 4 | OperatorFeeScalar | +// | 8 | OperatorFeeConstant | +// | 2 | DAFootprintGasScalar | +// +---------+--------------------------+ + +func (info *L1BlockInfo) marshalBinaryJovian() ([]byte, error) { + w := bytes.NewBuffer(make([]byte, 0, L1InfoJovianLen)) + if err := solabi.WriteSignature(w, L1InfoFuncJovianBytes4); err != nil { + return nil, err } - if info.BlobBaseFee, err = solabi.ReadUint256(r); err != nil { - return err + if err := info.writeBinaryJovian(w); err != nil { + return nil, err } - if info.BlockHash, err = solabi.ReadHash(r); err != nil { + return w.Bytes(), nil +} + +// writeBinaryJovian writes all fields up to the Jovian fork into the [L1BlockInfo] struct. It does not write the +// first 4 function signature bytes. This is expected to be done by [L1BlockInfo.marshalBinaryJovian]. Furthermore, +// writeBinaryJovian can be called by future fork binary writer implementations that share the same initial fields. +func (info *L1BlockInfo) writeBinaryJovian(w io.Writer) error { + if err := info.writeBinaryIsthmus(w); err != nil { return err } - // The "batcherHash" will be correctly parsed as address, since the version 0 and left-padding matches the ABI encoding format. - if info.BatcherAddr, err = solabi.ReadAddress(r); err != nil { + if err := binary.Write(w, binary.BigEndian, info.DAFootprintGasScalar); err != nil { return err } - if err := binary.Read(r, binary.BigEndian, &info.OperatorFeeScalar); err != nil { - return ErrInvalidIsthmusFormat + return nil +} + +func (info *L1BlockInfo) unmarshalBinaryJovian(data []byte) error { + if len(data) != L1InfoJovianLen { + return fmt.Errorf("data is unexpected length: %d", len(data)) } - if err := binary.Read(r, binary.BigEndian, &info.OperatorFeeConstant); err != nil { - return ErrInvalidIsthmusFormat + r := bytes.NewReader(data) + if _, err := solabi.ReadAndValidateSignature(r, []byte(L1InfoFuncJovianBytes4)); err != nil { + return err + } + if err := info.readBinaryJovian(r); err != nil { + return err } if !solabi.EmptyReader(r) { return errors.New("too many bytes") @@ -374,8 +419,18 @@ func unmarshalBinaryWithSignatureAndData(info *L1BlockInfo, signature []byte, da return nil } -func (info *L1BlockInfo) unmarshalBinaryIsthmus(data []byte) error { - return unmarshalBinaryWithSignatureAndData(info, L1InfoFuncIsthmusBytes4, data) +// readBinaryJovian reads all fields up to the Jovian fork into the [L1BlockInfo] struct. It does not read or verify the +// first 4 function signature bytes, nor does it expect the reader to be empty at the end. This is expected to be done +// by [L1BlockInfo.unmarshalBinaryJovian]. Furthermore, readBinaryJovian can be called by future fork binary reader +// implementations that share the same initial fields. +func (info *L1BlockInfo) readBinaryJovian(r io.Reader) error { + if err := info.readBinaryIsthmus(r); err != nil { + return err + } + if err := binary.Read(r, binary.BigEndian, &info.DAFootprintGasScalar); err != nil { + return ErrInvalidJovianFormat + } + return nil } // isEcotoneButNotFirstBlock returns whether the specified block is subject to the Ecotone upgrade, @@ -390,10 +445,19 @@ func isIsthmusButNotFirstBlock(rollupCfg *rollup.Config, l2Timestamp uint64) boo return rollupCfg.IsIsthmus(l2Timestamp) && !rollupCfg.IsIsthmusActivationBlock(l2Timestamp) } +// isJovianButNotFirstBlock returns whether the specified block is subject to the Jovian upgrade, +// but is not the activation block itself. +func isJovianButNotFirstBlock(rollupCfg *rollup.Config, l2Timestamp uint64) bool { + return rollupCfg.IsDAFootprintBlockLimit(l2Timestamp) && !rollupCfg.IsJovianActivationBlock(l2Timestamp) +} + // L1BlockInfoFromBytes is the inverse of L1InfoDeposit, to see where the L2 chain is derived from func L1BlockInfoFromBytes(rollupCfg *rollup.Config, l2BlockTime uint64, data []byte) (*L1BlockInfo, error) { var info L1BlockInfo - // Important, this should be ordered from most recent to oldest + // Important, this must be ordered from most recent to oldest + if isJovianButNotFirstBlock(rollupCfg, l2BlockTime) { + return &info, info.unmarshalBinaryJovian(data) + } if isIsthmusButNotFirstBlock(rollupCfg, l2BlockTime) { return &info, info.unmarshalBinaryIsthmus(data) } @@ -414,9 +478,13 @@ func L1InfoDeposit(rollupCfg *rollup.Config, l1ChainConfig *params.ChainConfig, SequenceNumber: seqNumber, BatcherAddr: sysCfg.BatcherAddr, } - var data []byte - if isEcotoneButNotFirstBlock(rollupCfg, l2Timestamp) { - isIsthmusActivated := isIsthmusButNotFirstBlock(rollupCfg, l2Timestamp) + + isEcotoneActivated := isEcotoneButNotFirstBlock(rollupCfg, l2Timestamp) + isIsthmusActivated := isIsthmusButNotFirstBlock(rollupCfg, l2Timestamp) + isJovianActivated := isJovianButNotFirstBlock(rollupCfg, l2Timestamp) + + // 1. Set all fields according to active forks + if isEcotoneActivated { l1BlockInfo.BlobBaseFee = block.BlobBaseFee(l1ChainConfig) // Apply Cancun blob base fee calculation if this chain needs the L1 Pectra @@ -441,35 +509,43 @@ func L1InfoDeposit(rollupCfg *rollup.Config, l1ChainConfig *params.ChainConfig, } l1BlockInfo.BlobBaseFeeScalar = scalars.BlobBaseFeeScalar l1BlockInfo.BaseFeeScalar = scalars.BaseFeeScalar + } else { // Bedrock, pre-Ecotone + l1BlockInfo.L1FeeOverhead = sysCfg.Overhead + l1BlockInfo.L1FeeScalar = sysCfg.Scalar + } + if isIsthmusActivated { + operatorFee := sysCfg.OperatorFee() + l1BlockInfo.OperatorFeeScalar = operatorFee.Scalar + l1BlockInfo.OperatorFeeConstant = operatorFee.Constant + } + if isJovianActivated { + l1BlockInfo.DAFootprintGasScalar = sysCfg.DAFootprintGasScalar + } - if isIsthmusActivated { - operatorFee := sysCfg.OperatorFee() - l1BlockInfo.OperatorFeeScalar = operatorFee.Scalar - l1BlockInfo.OperatorFeeConstant = operatorFee.Constant + // 2. Now marshal actual data + var data []byte + var err error + switch { + case isJovianActivated: + data, err = l1BlockInfo.marshalBinaryJovian() + if err != nil { + return nil, fmt.Errorf("failed to marshal Jovian l1 block info: %w", err) } - - if isIsthmusActivated { - out, err := l1BlockInfo.marshalBinaryIsthmus() - if err != nil { - return nil, fmt.Errorf("failed to marshal Isthmus l1 block info: %w", err) - } - data = out - } else { - out, err := l1BlockInfo.marshalBinaryEcotone() - if err != nil { - return nil, fmt.Errorf("failed to marshal Ecotone l1 block info: %w", err) - } - data = out + case isIsthmusActivated: + data, err = l1BlockInfo.marshalBinaryIsthmus() + if err != nil { + return nil, fmt.Errorf("failed to marshal Isthmus l1 block info: %w", err) } - - } else { - l1BlockInfo.L1FeeOverhead = sysCfg.Overhead - l1BlockInfo.L1FeeScalar = sysCfg.Scalar - out, err := l1BlockInfo.marshalBinaryBedrock() + case isEcotoneActivated: + data, err = l1BlockInfo.marshalBinaryEcotone() + if err != nil { + return nil, fmt.Errorf("failed to marshal Ecotone l1 block info: %w", err) + } + default: + data, err = l1BlockInfo.marshalBinaryBedrock() if err != nil { return nil, fmt.Errorf("failed to marshal Bedrock l1 block info: %w", err) } - data = out } source := L1InfoDepositSource{ diff --git a/op-node/rollup/derive/l1_block_info_test.go b/op-node/rollup/derive/l1_block_info_test.go index 0a7def874f0..2644563632a 100644 --- a/op-node/rollup/derive/l1_block_info_test.go +++ b/op-node/rollup/derive/l1_block_info_test.go @@ -171,9 +171,9 @@ func TestParseL1InfoDepositTxData(t *testing.T) { rng := rand.New(rand.NewSource(1234)) info := testutils.MakeBlockInfo(nil)(rng) rollupCfg := rollup.Config{BlockTime: 2, Genesis: rollup.Genesis{L2Time: 1000}} - rollupCfg.ActivateAtGenesis(rollup.Granite) + rollupCfg.ActivateAtGenesis(rollup.Holocene) isthmusTime := rollupCfg.Genesis.L2Time + rollupCfg.BlockTime // activate isthmus just after genesis - rollupCfg.InteropTime = &isthmusTime + rollupCfg.IsthmusTime = &isthmusTime depTx, err := L1InfoDeposit(&rollupCfg, params.MergedTestChainConfig, randomL1Cfg(rng, info), randomSeqNr(rng), info, isthmusTime) require.NoError(t, err) require.False(t, depTx.IsSystemTransaction) @@ -193,6 +193,45 @@ func TestParseL1InfoDepositTxData(t *testing.T) { require.Equal(t, depTx.Gas, uint64(RegolithSystemTxGas)) require.Equal(t, L1InfoIsthmusLen, len(depTx.Data)) }) + t.Run("jovian", func(t *testing.T) { + rng := rand.New(rand.NewSource(1234)) + info := testutils.MakeBlockInfo(nil)(rng) + rollupCfg := rollup.Config{BlockTime: 2, Genesis: rollup.Genesis{L2Time: 1000}} + rollupCfg.ActivateAtGenesis(rollup.Jovian) + // run 1 block after Jovian transition + timestamp := rollupCfg.Genesis.L2Time + rollupCfg.BlockTime + depTx, err := L1InfoDeposit(&rollupCfg, params.MergedTestChainConfig, randomL1Cfg(rng, info), randomSeqNr(rng), info, timestamp) + require.NoError(t, err) + require.False(t, depTx.IsSystemTransaction) + require.Equal(t, depTx.Gas, uint64(RegolithSystemTxGas)) + require.Equal(t, L1InfoJovianLen, len(depTx.Data)) + }) + t.Run("activation-block jovian", func(t *testing.T) { + rng := rand.New(rand.NewSource(1234)) + info := testutils.MakeBlockInfo(nil)(rng) + rollupCfg := rollup.Config{BlockTime: 2, Genesis: rollup.Genesis{L2Time: 1000}} + rollupCfg.ActivateAtGenesis(rollup.Isthmus) + jovianTime := rollupCfg.Genesis.L2Time + rollupCfg.BlockTime // activate jovian just after genesis + rollupCfg.InteropTime = &jovianTime + depTx, err := L1InfoDeposit(&rollupCfg, params.MergedTestChainConfig, randomL1Cfg(rng, info), randomSeqNr(rng), info, jovianTime) + require.NoError(t, err) + require.False(t, depTx.IsSystemTransaction) + require.Equal(t, depTx.Gas, uint64(RegolithSystemTxGas)) + // Jovian activates, but Isthmus L1 info is still used at this upgrade block + require.Equal(t, L1InfoIsthmusLen, len(depTx.Data)) + require.Equal(t, L1InfoFuncIsthmusBytes4, depTx.Data[:4]) + }) + t.Run("genesis-block jovian", func(t *testing.T) { + rng := rand.New(rand.NewSource(1234)) + info := testutils.MakeBlockInfo(nil)(rng) + rollupCfg := rollup.Config{BlockTime: 2, Genesis: rollup.Genesis{L2Time: 1000}} + rollupCfg.ActivateAtGenesis(rollup.Jovian) + depTx, err := L1InfoDeposit(&rollupCfg, params.MergedTestChainConfig, randomL1Cfg(rng, info), randomSeqNr(rng), info, rollupCfg.Genesis.L2Time) + require.NoError(t, err) + require.False(t, depTx.IsSystemTransaction) + require.Equal(t, depTx.Gas, uint64(RegolithSystemTxGas)) + require.Equal(t, L1InfoJovianLen, len(depTx.Data)) + }) t.Run("interop", func(t *testing.T) { rng := rand.New(rand.NewSource(1234)) info := testutils.MakeBlockInfo(nil)(rng) @@ -204,22 +243,21 @@ func TestParseL1InfoDepositTxData(t *testing.T) { require.NoError(t, err) require.False(t, depTx.IsSystemTransaction) require.Equal(t, depTx.Gas, uint64(RegolithSystemTxGas)) - require.Equal(t, L1InfoIsthmusLen, len(depTx.Data), "the length is same in interop") + require.Equal(t, L1InfoJovianLen, len(depTx.Data), "the length is same in interop") }) t.Run("activation-block interop", func(t *testing.T) { rng := rand.New(rand.NewSource(1234)) info := testutils.MakeBlockInfo(nil)(rng) rollupCfg := rollup.Config{BlockTime: 2, Genesis: rollup.Genesis{L2Time: 1000}} - rollupCfg.ActivateAtGenesis(rollup.Isthmus) + rollupCfg.ActivateAtGenesis(rollup.Jovian) interopTime := rollupCfg.Genesis.L2Time + rollupCfg.BlockTime // activate interop just after genesis rollupCfg.InteropTime = &interopTime depTx, err := L1InfoDeposit(&rollupCfg, params.MergedTestChainConfig, randomL1Cfg(rng, info), randomSeqNr(rng), info, interopTime) require.NoError(t, err) require.False(t, depTx.IsSystemTransaction) require.Equal(t, depTx.Gas, uint64(RegolithSystemTxGas)) - // Interop activates, but isthmus L1 info is still used at this upgrade block - require.Equal(t, L1InfoIsthmusLen, len(depTx.Data)) - require.Equal(t, L1InfoFuncIsthmusBytes4, depTx.Data[:4]) + require.Equal(t, L1InfoJovianLen, len(depTx.Data)) + require.Equal(t, L1InfoFuncJovianBytes4, depTx.Data[:4]) }) t.Run("genesis-block interop", func(t *testing.T) { rng := rand.New(rand.NewSource(1234)) @@ -230,6 +268,6 @@ func TestParseL1InfoDepositTxData(t *testing.T) { require.NoError(t, err) require.False(t, depTx.IsSystemTransaction) require.Equal(t, depTx.Gas, uint64(RegolithSystemTxGas)) - require.Equal(t, L1InfoIsthmusLen, len(depTx.Data)) + require.Equal(t, L1InfoJovianLen, len(depTx.Data)) }) } diff --git a/op-node/rollup/derive/payload_util.go b/op-node/rollup/derive/payload_util.go index 6eec2ed135e..d4b6b58737d 100644 --- a/op-node/rollup/derive/payload_util.go +++ b/op-node/rollup/derive/payload_util.go @@ -96,10 +96,6 @@ func PayloadToSystemConfig(rollupCfg *rollup.Config, payload *eth.ExecutionPaylo } d, e, m := eip1559.DecodeOptimismExtraData(rollupCfg, uint64(payload.Timestamp), payload.ExtraData) copy(r.EIP1559Params[:], eip1559.EncodeHolocene1559Params(d, e)) - if rollupCfg.IsJovian(uint64(payload.Timestamp)) { - // ValidateOptimismExtraData returning a nil error guarantees that m is not nil - r.MinBaseFee = *m - } if rollupCfg.IsIsthmus(uint64(payload.Timestamp)) { r.OperatorFeeParams = eth.EncodeOperatorFeeParams(eth.OperatorFeeParams{ @@ -107,5 +103,13 @@ func PayloadToSystemConfig(rollupCfg *rollup.Config, payload *eth.ExecutionPaylo Constant: info.OperatorFeeConstant, }) } + + if rollupCfg.IsMinBaseFee(uint64(payload.Timestamp)) { + // ValidateOptimismExtraData returning a nil error guarantees that m is not nil + r.MinBaseFee = *m + } + if rollupCfg.IsDAFootprintBlockLimit(uint64(payload.Timestamp)) { + r.SetDAFootprintGasScalar(info.DAFootprintGasScalar) + } return r, nil } diff --git a/op-node/rollup/derive/system_config.go b/op-node/rollup/derive/system_config.go index bcb2a33b131..ffbe79a1d72 100644 --- a/op-node/rollup/derive/system_config.go +++ b/op-node/rollup/derive/system_config.go @@ -17,13 +17,14 @@ import ( ) var ( - SystemConfigUpdateBatcher = common.Hash{31: 0} - SystemConfigUpdateFeeScalars = common.Hash{31: 1} - SystemConfigUpdateGasLimit = common.Hash{31: 2} - SystemConfigUpdateUnsafeBlockSigner = common.Hash{31: 3} - SystemConfigUpdateEIP1559Params = common.Hash{31: 4} - SystemConfigUpdateOperatorFeeParams = common.Hash{31: 5} - SystemConfigUpdateMinBaseFee = common.Hash{31: 6} + SystemConfigUpdateBatcher = common.Hash{31: 0} + SystemConfigUpdateFeeScalars = common.Hash{31: 1} + SystemConfigUpdateGasLimit = common.Hash{31: 2} + SystemConfigUpdateUnsafeBlockSigner = common.Hash{31: 3} + SystemConfigUpdateEIP1559Params = common.Hash{31: 4} + SystemConfigUpdateOperatorFeeParams = common.Hash{31: 5} + SystemConfigUpdateMinBaseFee = common.Hash{31: 6} + SystemConfigUpdateDAFootprintGasScalar = common.Hash{31: 7} ) var ( @@ -194,6 +195,22 @@ func ProcessSystemConfigUpdateLogEvent(destSysCfg *eth.SystemConfig, ev *types.L } destSysCfg.MinBaseFee = minBaseFee return nil + case SystemConfigUpdateDAFootprintGasScalar: + if pointer, err := solabi.ReadUint64(reader); err != nil || pointer != 32 { + return NewCriticalError(errors.New("invalid pointer field")) + } + if length, err := solabi.ReadUint64(reader); err != nil || length != 32 { + return NewCriticalError(errors.New("invalid length field")) + } + daFootprintGasScalar, err := solabi.ReadUint16(reader) + if err != nil { + return NewCriticalError(errors.New("could not read DA footprint gas scalar")) + } + if !solabi.EmptyReader(reader) { + return NewCriticalError(errors.New("too many bytes")) + } + destSysCfg.SetDAFootprintGasScalar(daFootprintGasScalar) + return nil default: return fmt.Errorf("unrecognized L1 sysCfg update type: %s", updateType) } diff --git a/op-node/rollup/derive/system_config_test.go b/op-node/rollup/derive/system_config_test.go index e98b792d4cf..916ab16c4d0 100644 --- a/op-node/rollup/derive/system_config_test.go +++ b/op-node/rollup/derive/system_config_test.go @@ -18,6 +18,7 @@ var ( // ABI encoding helpers dynBytes, _ = abi.NewType("bytes", "", nil) address, _ = abi.NewType("address", "", nil) + uint16T, _ = abi.NewType("uint16", "", nil) uint256T, _ = abi.NewType("uint256", "", nil) addressArgs = abi.Arguments{ {Type: address}, @@ -29,6 +30,9 @@ var ( {Type: uint256T}, {Type: uint256T}, } + oneUint16 = abi.Arguments{ + {Type: uint16T}, + } oneUint256 = abi.Arguments{ {Type: uint256T}, } @@ -250,15 +254,57 @@ func TestProcessSystemConfigUpdateLogEvent(t *testing.T) { return log }, config: eth.SystemConfig{ - EIP1559Params: eth.Bytes8{0, 0, 0, 0, 0, 0, 0, 0}, - MinBaseFee: minBaseFee, + MinBaseFee: minBaseFee, + }, + err: false, + }, + { + name: "SystemConfigUpdateDAFootprintGasScalar", + log: &types.Log{ + Topics: []common.Hash{ + ConfigUpdateEventABIHash, + ConfigUpdateEventVersion0, + SystemConfigUpdateDAFootprintGasScalar, + }, + }, + hook: func(t *testing.T, log *types.Log) *types.Log { + numberData, err := oneUint16.Pack(uint16(100)) + require.NoError(t, err) + data, err := bytesArgs.Pack(numberData) + require.NoError(t, err) + log.Data = data + return log + }, + config: eth.SystemConfig{ + DAFootprintGasScalar: 100, + }, + err: false, + }, + { + name: "SystemConfigUpdateDAFootprintGasScalar_default", + log: &types.Log{ + Topics: []common.Hash{ + ConfigUpdateEventABIHash, + ConfigUpdateEventVersion0, + SystemConfigUpdateDAFootprintGasScalar, + }, + }, + hook: func(t *testing.T, log *types.Log) *types.Log { + numberData, err := oneUint16.Pack(uint16(0)) + require.NoError(t, err) + data, err := bytesArgs.Pack(numberData) + require.NoError(t, err) + log.Data = data + return log + }, + config: eth.SystemConfig{ + DAFootprintGasScalar: eth.DAFootprintGasScalarDefault, }, err: false, }, } for _, test := range tests { - test := test t.Run(test.name, func(t *testing.T) { config := eth.SystemConfig{} rollupCfg := rollup.Config{EcotoneTime: test.ecotoneTime} diff --git a/op-node/rollup/types.go b/op-node/rollup/types.go index 5a2ede09aba..e8a3a1863c3 100644 --- a/op-node/rollup/types.go +++ b/op-node/rollup/types.go @@ -626,12 +626,12 @@ func (c *Config) IsActivationBlockForFork(l2BlockTime uint64, forkName ForkName) func (c *Config) ActivateAtGenesis(hardfork ForkName) { // IMPORTANT! ordered from newest to oldest switch hardfork { - case Jovian: - c.JovianTime = new(uint64) - fallthrough case Interop: c.InteropTime = new(uint64) fallthrough + case Jovian: + c.JovianTime = new(uint64) + fallthrough case Isthmus: c.IsthmusTime = new(uint64) fallthrough diff --git a/op-program/client/l2/engineapi/block_processor.go b/op-program/client/l2/engineapi/block_processor.go index 26906d970ec..c6923842670 100644 --- a/op-program/client/l2/engineapi/block_processor.go +++ b/op-program/client/l2/engineapi/block_processor.go @@ -161,9 +161,10 @@ func (b *BlockProcessor) Assemble() (*types.Block, types.Receipts, error) { Transactions: b.transactions, } + cfg := b.evm.ChainConfig() // Processing for EIP-7685 requests would happen here, but is skipped on OP. // Kept here to minimize diff. - if b.dataProvider.Config().IsPrague(b.header.Number, b.header.Time) && !b.dataProvider.Config().IsIsthmus(b.header.Time) { + if cfg.IsPrague(b.header.Number, b.header.Time) && !cfg.IsIsthmus(b.header.Time) { _requests := [][]byte{} // EIP-6110 - no-op because we just ignore all deposit requests, so no need to parse logs // EIP-7002 @@ -176,6 +177,14 @@ func (b *BlockProcessor) Assemble() (*types.Block, types.Receipts, error) { } } + if cfg.IsJovian(b.header.Time) { + gasUsed, err := types.CalcGasUsedJovian(b.transactions, b.header.GasUsed) + if err != nil { + return nil, nil, fmt.Errorf("failed to calculate gas used for Jovian block: %w", err) + } + b.header.GasUsed = gasUsed + } + block, err := b.dataProvider.Engine().FinalizeAndAssemble(b.dataProvider, b.header, b.state, &body, b.receipts) if err != nil { return nil, nil, err diff --git a/op-program/client/l2/engineapi/l2_engine_api_test.go b/op-program/client/l2/engineapi/l2_engine_api_test.go index c717917f4f3..3828e3a28fd 100644 --- a/op-program/client/l2/engineapi/l2_engine_api_test.go +++ b/op-program/client/l2/engineapi/l2_engine_api_test.go @@ -6,6 +6,7 @@ import ( "testing" "github.com/ethereum-optimism/optimism/op-chain-ops/genesis" + "github.com/ethereum-optimism/optimism/op-node/rollup" "github.com/ethereum-optimism/optimism/op-service/eth" "github.com/ethereum-optimism/optimism/op-service/testlog" "github.com/ethereum/go-ethereum/beacon/engine" @@ -21,6 +22,8 @@ import ( "github.com/stretchr/testify/require" ) +// TestNewPayloadV4 tests the NewPayloadV4 behavior with pre- and post-Isthmus payload +// attributes. func TestNewPayloadV4(t *testing.T) { cases := []struct { isthmusTime uint64 @@ -35,7 +38,7 @@ func TestNewPayloadV4(t *testing.T) { logger, _ := testlog.CaptureLogger(t, log.LvlInfo) for _, c := range cases { - genesis := createGenesisWithForkTimeOffset(c.isthmusTime) + genesis := createGenesisWithIsthmusTimeOffset(c.isthmusTime) ethCfg := ðconfig.Config{ NetworkId: genesis.Config.ChainID.Uint64(), Genesis: genesis, @@ -47,25 +50,12 @@ func TestNewPayloadV4(t *testing.T) { require.NotNil(t, engineAPI) genesisBlock := backend.GetHeaderByNumber(0) genesisHash := genesisBlock.Hash() - eip1559Params := eth.Bytes8([]byte{0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7, 0x8}) - minBaseFee := uint64(1e9) - minBaseFeePtr := &minBaseFee - gasLimit := eth.Uint64Quantity(4712388) + attribs := createPayloadAttributes(genesisBlock.Time + c.blockTime) result, err := engineAPI.ForkchoiceUpdatedV3(context.Background(), ð.ForkchoiceState{ HeadBlockHash: genesisHash, SafeBlockHash: genesisHash, FinalizedBlockHash: genesisHash, - }, ð.PayloadAttributes{ - Timestamp: eth.Uint64Quantity(genesisBlock.Time + c.blockTime), - PrevRandao: eth.Bytes32{0x11}, - SuggestedFeeRecipient: common.Address{0x33}, - Withdrawals: &types.Withdrawals{}, - ParentBeaconBlockRoot: &common.Hash{0x22}, - NoTxPool: false, - GasLimit: &gasLimit, - EIP1559Params: &eip1559Params, - MinBaseFee: minBaseFeePtr, - }) + }, attribs) require.NoError(t, err) require.EqualValues(t, engine.VALID, result.PayloadStatus.Status) require.NotNil(t, result.PayloadID) @@ -86,11 +76,10 @@ func TestNewPayloadV4(t *testing.T) { newPayloadResult, err := engineAPI.NewPayloadV4(context.Background(), envelope.ExecutionPayload, []common.Hash{}, envelope.ParentBeaconBlockRoot, []hexutil.Bytes{}) if c.expectedError != "" { require.ErrorContains(t, err, c.expectedError) - continue } else { require.NoError(t, err) + require.EqualValues(t, engine.VALID, newPayloadResult.Status) } - require.EqualValues(t, engine.VALID, newPayloadResult.Status) } } @@ -102,25 +91,12 @@ func TestCreatedBlocksAreCached(t *testing.T) { require.NotNil(t, engineAPI) genesis := backend.GetHeaderByNumber(0) genesisHash := genesis.Hash() - eip1559Params := eth.Bytes8([]byte{0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7, 0x8}) - minBaseFee := uint64(1e9) - minBaseFeePtr := &minBaseFee - gasLimit := eth.Uint64Quantity(genesis.GasLimit) + attribs := createPayloadAttributes(genesis.Time + 1) result, err := engineAPI.ForkchoiceUpdatedV3(context.Background(), ð.ForkchoiceState{ HeadBlockHash: genesisHash, SafeBlockHash: genesisHash, FinalizedBlockHash: genesisHash, - }, ð.PayloadAttributes{ - Timestamp: eth.Uint64Quantity(genesis.Time + 1), - PrevRandao: eth.Bytes32{0x11}, - SuggestedFeeRecipient: common.Address{0x33}, - Withdrawals: &types.Withdrawals{}, - ParentBeaconBlockRoot: &common.Hash{0x22}, - NoTxPool: false, - GasLimit: &gasLimit, - EIP1559Params: &eip1559Params, - MinBaseFee: minBaseFeePtr, - }) + }, attribs) require.NoError(t, err) require.EqualValues(t, engine.VALID, result.PayloadStatus.Status) require.NotNil(t, result.PayloadID) @@ -137,6 +113,20 @@ func TestCreatedBlocksAreCached(t *testing.T) { require.Equal(t, envelope.ExecutionPayload.BlockHash, foundLog.AttrValue("hash")) } +func createPayloadAttributes(ts uint64) *eth.PayloadAttributes { + eip1559Params := eth.Bytes8([]byte{0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7, 0x8}) + gasLimit := eth.Uint64Quantity(30e6) + return ð.PayloadAttributes{ + Timestamp: eth.Uint64Quantity(ts), + PrevRandao: eth.Bytes32{0x11}, + SuggestedFeeRecipient: common.Address{0x33}, + Withdrawals: &types.Withdrawals{}, + ParentBeaconBlockRoot: &common.Hash{0x22}, + GasLimit: &gasLimit, + EIP1559Params: &eip1559Params, + } +} + func newStubBackendWithConfig(t *testing.T, ethCfg *ethconfig.Config) *stubCachingBackend { nodeCfg := &node.Config{ Name: "l2-geth", @@ -154,7 +144,7 @@ func newStubBackendWithConfig(t *testing.T, ethCfg *ethconfig.Config) *stubCachi } func newStubBackend(t *testing.T) *stubCachingBackend { - genesis := createGenesis() + genesis := createIsthmusGenesis() ethCfg := ðconfig.Config{ NetworkId: genesis.Config.ChainID.Uint64(), Genesis: genesis, @@ -164,11 +154,11 @@ func newStubBackend(t *testing.T) *stubCachingBackend { return newStubBackendWithConfig(t, ethCfg) } -func createGenesis() *core.Genesis { - return createGenesisWithForkTimeOffset(0) +func createIsthmusGenesis() *core.Genesis { + return createGenesisWithIsthmusTimeOffset(0) } -func createGenesisWithForkTimeOffset(forkTimeOffset uint64) *core.Genesis { +func createGenesisWithIsthmusTimeOffset(forkTimeOffset uint64) *core.Genesis { deployConfig := &genesis.DeployConfig{ L2InitializationConfig: genesis.L2InitializationConfig{ DevDeployConfig: genesis.DevDeployConfig{ @@ -189,21 +179,7 @@ func createGenesisWithForkTimeOffset(forkTimeOffset uint64) *core.Genesis { }, } - // Enable all forks up to the specified time - ts := hexutil.Uint64(0) - deployConfig.L2GenesisRegolithTimeOffset = &ts - deployConfig.L2GenesisCanyonTimeOffset = &ts - deployConfig.L2GenesisDeltaTimeOffset = &ts - deployConfig.L2GenesisEcotoneTimeOffset = &ts - deployConfig.L2GenesisFjordTimeOffset = &ts - deployConfig.L2GenesisGraniteTimeOffset = &ts - deployConfig.L2GenesisHoloceneTimeOffset = &ts - - // Set fork time for latest forks - offset := hexutil.Uint64(forkTimeOffset) - deployConfig.L2GenesisIsthmusTimeOffset = &offset - deployConfig.L2GenesisInteropTimeOffset = &offset - deployConfig.L2GenesisJovianTimeOffset = &offset + deployConfig.ActivateForkAtOffset(rollup.Isthmus, forkTimeOffset) l1Genesis, err := genesis.NewL1Genesis(deployConfig) if err != nil { diff --git a/op-service/eth/types.go b/op-service/eth/types.go index 9f71dc7d01c..b76e9f80e0d 100644 --- a/op-service/eth/types.go +++ b/op-service/eth/types.go @@ -591,6 +591,8 @@ type ForkchoiceUpdatedResult struct { PayloadID *PayloadID `json:"payloadId"` } +const DAFootprintGasScalarDefault = 400 + // SystemConfig represents the rollup system configuration that carries over in every L2 block, // and may be changed through L1 system config events. // The initial SystemConfig at rollup genesis is embedded in the rollup configuration. @@ -615,6 +617,8 @@ type SystemConfig struct { OperatorFeeParams Bytes32 `json:"operatorFeeParams"` // MinBaseFee identifies the minimum base fee. MinBaseFee uint64 `json:"minBaseFee"` + // DAFootprintGasScalar identifies the DA footprint gas scalar. + DAFootprintGasScalar uint16 `json:"daFootprintGasScalar"` // More fields can be added for future SystemConfig versions. // MarshalPreHolocene indicates whether or not this struct should be @@ -624,6 +628,14 @@ type SystemConfig struct { MarshalPreHolocene bool `json:"-"` } +func (sysCfg *SystemConfig) SetDAFootprintGasScalar(daFootprintGasScalar uint16) { + if daFootprintGasScalar == 0 { + sysCfg.DAFootprintGasScalar = DAFootprintGasScalarDefault + } else { + sysCfg.DAFootprintGasScalar = daFootprintGasScalar + } +} + func (sysCfg SystemConfig) MarshalJSON() ([]byte, error) { if sysCfg.MarshalPreHolocene { return jsonMarshalPreHolocene(sysCfg) @@ -703,7 +715,7 @@ func EncodeScalar(scalars EcotoneScalars) (scalar [32]byte) { scalar[0] = L1ScalarEcotone binary.BigEndian.PutUint32(scalar[24:28], scalars.BlobBaseFeeScalar) binary.BigEndian.PutUint32(scalar[28:32], scalars.BaseFeeScalar) - return + return scalar } func CheckEcotoneL1SystemConfigScalar(scalar [32]byte) error { @@ -747,7 +759,7 @@ func DecodeOperatorFeeParams(scalar [32]byte) OperatorFeeParams { func EncodeOperatorFeeParams(params OperatorFeeParams) (scalar [32]byte) { binary.BigEndian.PutUint32(scalar[20:24], params.Scalar) binary.BigEndian.PutUint64(scalar[24:32], params.Constant) - return + return scalar } type Bytes48 [48]byte @@ -779,7 +791,7 @@ type Uint64String uint64 func (v Uint64String) MarshalText() (out []byte, err error) { out = strconv.AppendUint(out, uint64(v), 10) - return + return out, err } func (v *Uint64String) UnmarshalText(b []byte) error { diff --git a/op-service/eth/types_test.go b/op-service/eth/types_test.go index 02d226ac03a..b8a5b391c20 100644 --- a/op-service/eth/types_test.go +++ b/op-service/eth/types_test.go @@ -95,18 +95,19 @@ func FuzzEncodeOperatorFeeParams(f *testing.F) { func TestSystemConfigMarshaling(t *testing.T) { sysConfig := SystemConfig{ - BatcherAddr: common.Address{'A'}, - Overhead: Bytes32{0x4, 0x5, 0x6}, - Scalar: Bytes32{0x7, 0x8, 0x9}, - OperatorFeeParams: Bytes32{0x1, 0x2, 0x3}, - GasLimit: 1234, - MinBaseFee: 0, + BatcherAddr: common.Address{'A'}, + Overhead: Bytes32{0x4, 0x5, 0x6}, + Scalar: Bytes32{0x7, 0x8, 0x9}, + OperatorFeeParams: Bytes32{0x1, 0x2, 0x3}, + GasLimit: 1234, + MinBaseFee: 0, + DAFootprintGasScalar: DAFootprintGasScalarDefault, // Leave EIP1559 params empty to prove that the // zero value is sent. } j, err := json.Marshal(sysConfig) require.NoError(t, err) - require.Equal(t, `{"batcherAddr":"0x4100000000000000000000000000000000000000","overhead":"0x0405060000000000000000000000000000000000000000000000000000000000","scalar":"0x0708090000000000000000000000000000000000000000000000000000000000","gasLimit":1234,"eip1559Params":"0x0000000000000000","operatorFeeParams":"0x0102030000000000000000000000000000000000000000000000000000000000","minBaseFee":0}`, string(j)) + require.Equal(t, `{"batcherAddr":"0x4100000000000000000000000000000000000000","overhead":"0x0405060000000000000000000000000000000000000000000000000000000000","scalar":"0x0708090000000000000000000000000000000000000000000000000000000000","gasLimit":1234,"eip1559Params":"0x0000000000000000","operatorFeeParams":"0x0102030000000000000000000000000000000000000000000000000000000000","minBaseFee":0,"daFootprintGasScalar":400}`, string(j)) sysConfig.MarshalPreHolocene = true j, err = json.Marshal(sysConfig) require.NoError(t, err) diff --git a/op-service/solabi/util.go b/op-service/solabi/util.go index f5d48a65769..1763400ee8c 100644 --- a/op-service/solabi/util.go +++ b/op-service/solabi/util.go @@ -16,6 +16,8 @@ import ( var ( addressEmptyPadding [12]byte = [12]byte{} uint64EmptyPadding [24]byte = [24]byte{} + uint32EmptyPadding [28]byte = [28]byte{} + uint16EmptyPadding [30]byte = [30]byte{} uint8EmptyPadding [31]byte = [31]byte{} ) @@ -75,6 +77,36 @@ func ReadUint64(r io.Reader) (uint64, error) { return n, nil } +// ReadUint16 reads a big endian uint16 from a 32 byte word +func ReadUint16(r io.Reader) (uint16, error) { + var readPadding [30]byte + var n uint16 + if _, err := io.ReadFull(r, readPadding[:]); err != nil { + return n, err + } else if !bytes.Equal(readPadding[:], uint16EmptyPadding[:]) { + return n, fmt.Errorf("number padding was not empty: %x", readPadding[:]) + } + if err := binary.Read(r, binary.BigEndian, &n); err != nil { + return 0, errors.New("expected number length to be 8 bytes") + } + return n, nil +} + +// ReadUint32 reads a big endian uint32 from a 32 byte word +func ReadUint32(r io.Reader) (uint32, error) { + var readPadding [28]byte + var n uint32 + if _, err := io.ReadFull(r, readPadding[:]); err != nil { + return n, err + } else if !bytes.Equal(readPadding[:], uint32EmptyPadding[:]) { + return n, fmt.Errorf("number padding was not empty: %x", readPadding[:]) + } + if err := binary.Read(r, binary.BigEndian, &n); err != nil { + return 0, errors.New("expected number length to be 8 bytes") + } + return n, nil +} + func ReadUint256(r io.Reader) (*big.Int, error) { var n [32]byte if _, err := io.ReadFull(r, n[:]); err != nil { diff --git a/packages/contracts-bedrock/interfaces/L1/ISystemConfig.sol b/packages/contracts-bedrock/interfaces/L1/ISystemConfig.sol index 4abb69a1c1a..5edb73d8ae7 100644 --- a/packages/contracts-bedrock/interfaces/L1/ISystemConfig.sol +++ b/packages/contracts-bedrock/interfaces/L1/ISystemConfig.sol @@ -13,7 +13,8 @@ interface ISystemConfig is IProxyAdminOwnedBase { UNSAFE_BLOCK_SIGNER, EIP_1559_PARAMS, OPERATOR_FEE_PARAMS, - MIN_BASE_FEE + MIN_BASE_FEE, + DA_FOOTPRINT_GAS_SCALAR } struct Addresses { @@ -74,6 +75,7 @@ interface ISystemConfig is IProxyAdminOwnedBase { function operatorFeeConstant() external view returns (uint64); function operatorFeeScalar() external view returns (uint32); function minBaseFee() external view returns (uint64); + function daFootprintGasScalar() external view returns (uint16); function optimismMintableERC20Factory() external view returns (address addr_); function optimismPortal() external view returns (address addr_); function overhead() external view returns (uint256); @@ -89,6 +91,7 @@ interface ISystemConfig is IProxyAdminOwnedBase { function setUnsafeBlockSigner(address _unsafeBlockSigner) external; function setEIP1559Params(uint32 _denominator, uint32 _elasticity) external; function setMinBaseFee(uint64 _minBaseFee) external; + function setDAFootprintGasScalar(uint16 _daFootprintGasScalar) external; function startBlock() external view returns (uint256 startBlock_); function transferOwnership(address newOwner) external; // nosemgrep function unsafeBlockSigner() external view returns (address addr_); diff --git a/packages/contracts-bedrock/interfaces/L2/IL1Block.sol b/packages/contracts-bedrock/interfaces/L2/IL1Block.sol index 30c42275adf..65b9ef0f202 100644 --- a/packages/contracts-bedrock/interfaces/L2/IL1Block.sol +++ b/packages/contracts-bedrock/interfaces/L2/IL1Block.sol @@ -18,6 +18,7 @@ interface IL1Block { function number() external view returns (uint64); function operatorFeeScalar() external view returns (uint32); function operatorFeeConstant() external view returns (uint64); + function daFootprintGasScalar() external view returns (uint16); function sequenceNumber() external view returns (uint64); function setL1BlockValues( uint64 _number, @@ -32,6 +33,7 @@ interface IL1Block { external; function setL1BlockValuesEcotone() external; function setL1BlockValuesIsthmus() external; + function setL1BlockValuesJovian() external; function timestamp() external view returns (uint64); function version() external pure returns (string memory); diff --git a/packages/contracts-bedrock/snapshots/abi/L1Block.json b/packages/contracts-bedrock/snapshots/abi/L1Block.json index 153d2676cf5..5f3ebef9dba 100644 --- a/packages/contracts-bedrock/snapshots/abi/L1Block.json +++ b/packages/contracts-bedrock/snapshots/abi/L1Block.json @@ -77,6 +77,19 @@ "stateMutability": "view", "type": "function" }, + { + "inputs": [], + "name": "daFootprintGasScalar", + "outputs": [ + { + "internalType": "uint16", + "name": "", + "type": "uint16" + } + ], + "stateMutability": "view", + "type": "function" + }, { "inputs": [], "name": "gasPayingToken", @@ -287,6 +300,13 @@ "stateMutability": "nonpayable", "type": "function" }, + { + "inputs": [], + "name": "setL1BlockValuesJovian", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, { "inputs": [], "name": "timestamp", diff --git a/packages/contracts-bedrock/snapshots/abi/SystemConfig.json b/packages/contracts-bedrock/snapshots/abi/SystemConfig.json index 10a956622f8..75a6ad7156b 100644 --- a/packages/contracts-bedrock/snapshots/abi/SystemConfig.json +++ b/packages/contracts-bedrock/snapshots/abi/SystemConfig.json @@ -173,6 +173,19 @@ "stateMutability": "view", "type": "function" }, + { + "inputs": [], + "name": "daFootprintGasScalar", + "outputs": [ + { + "internalType": "uint16", + "name": "", + "type": "uint16" + } + ], + "stateMutability": "view", + "type": "function" + }, { "inputs": [], "name": "disputeGameFactory", @@ -718,6 +731,19 @@ "stateMutability": "nonpayable", "type": "function" }, + { + "inputs": [ + { + "internalType": "uint16", + "name": "_daFootprintGasScalar", + "type": "uint16" + } + ], + "name": "setDAFootprintGasScalar", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, { "inputs": [ { diff --git a/packages/contracts-bedrock/snapshots/semver-lock.json b/packages/contracts-bedrock/snapshots/semver-lock.json index c0eb064250f..bb73996e593 100644 --- a/packages/contracts-bedrock/snapshots/semver-lock.json +++ b/packages/contracts-bedrock/snapshots/semver-lock.json @@ -44,8 +44,8 @@ "sourceCodeHash": "0xbf344c4369b8cb00ec7a3108f72795747f3bc59ab5b37ac18cf21e72e2979dbf" }, "src/L1/SystemConfig.sol:SystemConfig": { - "initCodeHash": "0x6e1e3cf76f08916bf6a3aed2b68772bd5ade935db4f0f876e682dc7a586334fb", - "sourceCodeHash": "0x006e3560f8b2e17133eb10a116916798ddc4345a7b006f8504dab69e810adb1c" + "initCodeHash": "0xe36ea91f876df8ee99f700cc691919e74a2f06b68c2774de58d5027f74ecb930", + "sourceCodeHash": "0x18ebe840a448ad52ca6f0864c90c475c8622958900f2296e8a7cdfb8cc5cc512" }, "src/L2/BaseFeeVault.sol:BaseFeeVault": { "initCodeHash": "0x9b664e3d84ad510091337b4aacaa494b142512e2f6f7fbcdb6210ed62ca9b885", @@ -64,8 +64,8 @@ "sourceCodeHash": "0x4351fe2ac1106c8c220b8cfe7839bc107c24d8084deb21259ac954f5a362725d" }, "src/L2/L1Block.sol:L1Block": { - "initCodeHash": "0xc35734387887a95f611888f3944546c6bcf82fd4c05dcdaa1e019779b628ad68", - "sourceCodeHash": "0x6e5349fd781d5f0127ff29ccea4d86a80240550cfa322364183a0f629abcb43e" + "initCodeHash": "0x1f054ff228ecad7f51772dd25084469192f7a33c522b87cd46ec5558d3c46aec", + "sourceCodeHash": "0xa45ec2f83b73ac7792d193098240e19e4b26e4102bd1e3c64bb7d0f91074be82" }, "src/L2/L1FeeVault.sol:L1FeeVault": { "initCodeHash": "0x9b664e3d84ad510091337b4aacaa494b142512e2f6f7fbcdb6210ed62ca9b885", diff --git a/packages/contracts-bedrock/snapshots/storageLayout/L1Block.json b/packages/contracts-bedrock/snapshots/storageLayout/L1Block.json index 2c23f063678..73d473edd39 100644 --- a/packages/contracts-bedrock/snapshots/storageLayout/L1Block.json +++ b/packages/contracts-bedrock/snapshots/storageLayout/L1Block.json @@ -89,5 +89,12 @@ "offset": 8, "slot": "8", "type": "uint32" + }, + { + "bytes": "2", + "label": "daFootprintGasScalar", + "offset": 12, + "slot": "8", + "type": "uint16" } ] \ No newline at end of file diff --git a/packages/contracts-bedrock/snapshots/storageLayout/SystemConfig.json b/packages/contracts-bedrock/snapshots/storageLayout/SystemConfig.json index 3a80e68ed8b..66f4c460a33 100644 --- a/packages/contracts-bedrock/snapshots/storageLayout/SystemConfig.json +++ b/packages/contracts-bedrock/snapshots/storageLayout/SystemConfig.json @@ -111,6 +111,13 @@ "slot": "106", "type": "uint64" }, + { + "bytes": "2", + "label": "daFootprintGasScalar", + "offset": 20, + "slot": "106", + "type": "uint16" + }, { "bytes": "32", "label": "l2ChainId", diff --git a/packages/contracts-bedrock/src/L1/SystemConfig.sol b/packages/contracts-bedrock/src/L1/SystemConfig.sol index 68b5dba6ef8..ae5a00f8aac 100644 --- a/packages/contracts-bedrock/src/L1/SystemConfig.sol +++ b/packages/contracts-bedrock/src/L1/SystemConfig.sol @@ -31,6 +31,7 @@ contract SystemConfig is ProxyAdminOwnedBase, OwnableUpgradeable, Reinitializabl /// @custom:value EIP_1559_PARAMS Represents an update to EIP-1559 parameters. /// @custom:value OPERATOR_FEE_PARAMS Represents an update to operator fee parameters. /// @custom:value MIN_BASE_FEE Represents an update to the minimum base fee. + /// @custom:value DA_FOOTPRINT_GAS_SCALAR Represents an update to the DA footprint gas scalar. enum UpdateType { BATCHER, FEE_SCALARS, @@ -38,7 +39,8 @@ contract SystemConfig is ProxyAdminOwnedBase, OwnableUpgradeable, Reinitializabl UNSAFE_BLOCK_SIGNER, EIP_1559_PARAMS, OPERATOR_FEE_PARAMS, - MIN_BASE_FEE + MIN_BASE_FEE, + DA_FOOTPRINT_GAS_SCALAR } /// @notice Struct representing the addresses of L1 system contracts. These should be the @@ -133,6 +135,9 @@ contract SystemConfig is ProxyAdminOwnedBase, OwnableUpgradeable, Reinitializabl /// @notice The operator fee constant. uint64 public operatorFeeConstant; + // @notice The DA footprint gas scalar. + uint16 public daFootprintGasScalar; + /// @notice The L2 chain ID that this SystemConfig configures. uint256 public l2ChainId; @@ -161,9 +166,9 @@ contract SystemConfig is ProxyAdminOwnedBase, OwnableUpgradeable, Reinitializabl error SystemConfig_InvalidFeatureState(); /// @notice Semantic version. - /// @custom:semver 3.10.0 + /// @custom:semver 3.11.0 function version() public pure virtual returns (string memory) { - return "3.10.0"; + return "3.11.0"; } /// @notice Constructs the SystemConfig contract. @@ -433,8 +438,8 @@ contract SystemConfig is ProxyAdminOwnedBase, OwnableUpgradeable, Reinitializabl } /// @notice Updates the operator fee parameters. Can only be called by the owner. - /// @param _operatorFeeScalar operator fee scalar. - /// @param _operatorFeeConstant operator fee constant. + /// @param _operatorFeeScalar New operator fee scalar. + /// @param _operatorFeeConstant New operator fee constant. function setOperatorFeeScalars(uint32 _operatorFeeScalar, uint64 _operatorFeeConstant) external onlyOwner { _setOperatorFeeScalars(_operatorFeeScalar, _operatorFeeConstant); } @@ -448,6 +453,20 @@ contract SystemConfig is ProxyAdminOwnedBase, OwnableUpgradeable, Reinitializabl emit ConfigUpdate(VERSION, UpdateType.OPERATOR_FEE_PARAMS, data); } + /// @notice Updates the DA footprint gas scalar. Can only be called by the owner. + /// @param _daFootprintGasScalar New DA footprint gas scalar. + function setDAFootprintGasScalar(uint16 _daFootprintGasScalar) external onlyOwner { + _setDAFootprintGasScalar(_daFootprintGasScalar); + } + + /// @notice Internal function for updating the DA footprint gas scalar. + function _setDAFootprintGasScalar(uint16 _dAFootprintGasScalar) internal { + daFootprintGasScalar = _dAFootprintGasScalar; + + bytes memory data = abi.encode(_dAFootprintGasScalar); + emit ConfigUpdate(VERSION, UpdateType.DA_FOOTPRINT_GAS_SCALAR, data); + } + /// @notice Sets the start block in a backwards compatible way. Proxies /// that were initialized before the startBlock existed in storage /// can have their start block set by a user provided override. diff --git a/packages/contracts-bedrock/src/L2/L1Block.sol b/packages/contracts-bedrock/src/L2/L1Block.sol index 31935dfab7e..fffce12bb51 100644 --- a/packages/contracts-bedrock/src/L2/L1Block.sol +++ b/packages/contracts-bedrock/src/L2/L1Block.sol @@ -61,9 +61,12 @@ contract L1Block is ISemver { /// @notice The scalar value applied to the operator fee. uint32 public operatorFeeScalar; - /// @custom:semver 1.6.1 + /// @notice The DA footprint gas scalar. + uint16 public daFootprintGasScalar; + + /// @custom:semver 1.7.0 function version() public pure virtual returns (string memory) { - return "1.6.1"; + return "1.7.0"; } /// @notice Returns the gas paying token, its decimals, name and symbol. @@ -139,22 +142,6 @@ contract L1Block is ISemver { /// 8. _hash L1 blockhash. /// 9. _batcherHash Versioned hash to authenticate batcher by. function setL1BlockValuesEcotone() public { - _setL1BlockValuesEcotone(); - } - - /// @notice Updates the L1 block values for an Ecotone upgraded chain. - /// Params are packed and passed in as raw msg.data instead of ABI to reduce calldata size. - /// Params are expected to be in the following order: - /// 1. _baseFeeScalar L1 base fee scalar - /// 2. _blobBaseFeeScalar L1 blob base fee scalar - /// 3. _sequenceNumber Number of L2 blocks since epoch start. - /// 4. _timestamp L1 timestamp. - /// 5. _number L1 blocknumber. - /// 6. _basefee L1 base fee. - /// 7. _blobBaseFee L1 blob base fee. - /// 8. _hash L1 blockhash. - /// 9. _batcherHash Versioned hash to authenticate batcher by. - function _setL1BlockValuesEcotone() internal { address depositor = DEPOSITOR_ACCOUNT(); assembly { // Revert if the caller is not the depositor account. @@ -188,28 +175,44 @@ contract L1Block is ISemver { /// 10. _operatorFeeScalar Operator fee scalar. /// 11. _operatorFeeConstant Operator fee constant. function setL1BlockValuesIsthmus() public { - _setL1BlockValuesIsthmus(); + setL1BlockValuesEcotone(); + assembly { + // operatorFeeScalar (uint32), operatorFeeConstant (uint64) + sstore(operatorFeeConstant.slot, shr(160, calldataload(164))) + } } - /// @notice Updates the L1 block values for an Isthmus upgraded chain. + /// @notice Updates the L1 block values for a Jovian upgraded chain. /// Params are packed and passed in as raw msg.data instead of ABI to reduce calldata size. /// Params are expected to be in the following order: - /// 1. _baseFeeScalar L1 base fee scalar - /// 2. _blobBaseFeeScalar L1 blob base fee scalar - /// 3. _sequenceNumber Number of L2 blocks since epoch start. - /// 4. _timestamp L1 timestamp. - /// 5. _number L1 blocknumber. - /// 6. _basefee L1 base fee. - /// 7. _blobBaseFee L1 blob base fee. - /// 8. _hash L1 blockhash. - /// 9. _batcherHash Versioned hash to authenticate batcher by. - /// 10. _operatorFeeScalar Operator fee scalar. - /// 11. _operatorFeeConstant Operator fee constant. - function _setL1BlockValuesIsthmus() internal { - _setL1BlockValuesEcotone(); + /// 1. _baseFeeScalar L1 base fee scalar + /// 2. _blobBaseFeeScalar L1 blob base fee scalar + /// 3. _sequenceNumber Number of L2 blocks since epoch start. + /// 4. _timestamp L1 timestamp. + /// 5. _number L1 blocknumber. + /// 6. _basefee L1 base fee. + /// 7. _blobBaseFee L1 blob base fee. + /// 8. _hash L1 blockhash. + /// 9. _batcherHash Versioned hash to authenticate batcher by. + /// 10. _operatorFeeScalar Operator fee scalar. + /// 11. _operatorFeeConstant Operator fee constant. + /// 12. _daFootprintGasScalar DA footprint gas scalar. + function setL1BlockValuesJovian() public { + setL1BlockValuesEcotone(); assembly { - // operatorFeeScalar (uint32), operatorFeeConstant (uint64) - sstore(operatorFeeConstant.slot, shr(160, calldataload(164))) + // Calldata layout: operatorFeeScalar (uint32), operatorFeeConstant (uint64), daFootprintGasScalar (uint16) + // Slot layout: daFootprintGasScalar (uint16), operatorFeeScalar (uint32), operatorFeeConstant (uint64) + + // Load operatorFeeScalar+operatorFeeConstant from calldata + let opFeeParams := shr(160, calldataload(164)) // 160 = 256 - (32 + 64) + + // Load daFootprintGasScalar from calldata + let daScalar := shr(240, calldataload(176)) // 240 = 256 - 16 + + // Combine full slot value, shifting daFootprintGasScalar left of operator fee params + let slotVal := or(shl(96, daScalar), opFeeParams) // 96 = 32 + 64 + + sstore(operatorFeeConstant.slot, slotVal) } } } diff --git a/packages/contracts-bedrock/src/libraries/Encoding.sol b/packages/contracts-bedrock/src/libraries/Encoding.sol index ec8c5623e7e..ce31d43c0b0 100644 --- a/packages/contracts-bedrock/src/libraries/Encoding.sol +++ b/packages/contracts-bedrock/src/libraries/Encoding.sol @@ -229,6 +229,50 @@ library Encoding { ); } + /// @notice Returns an appropriately encoded call to L1Block.setL1BlockValuesJovian + /// @param _baseFeeScalar L1 base fee Scalar + /// @param _blobBaseFeeScalar L1 blob base fee Scalar + /// @param _sequenceNumber Number of L2 blocks since epoch start. + /// @param _timestamp L1 timestamp. + /// @param _number L1 blocknumber. + /// @param _baseFee L1 base fee. + /// @param _blobBaseFee L1 blob base fee. + /// @param _hash L1 blockhash. + /// @param _batcherHash Versioned hash to authenticate batcher by. + /// @param _operatorFeeScalar Operator fee scalar. + /// @param _operatorFeeConstant Operator fee constant. + /// @param _daFootprintGasScalar DA Footprint scalar. + function encodeSetL1BlockValuesJovian( + uint32 _baseFeeScalar, + uint32 _blobBaseFeeScalar, + uint64 _sequenceNumber, + uint64 _timestamp, + uint64 _number, + uint256 _baseFee, + uint256 _blobBaseFee, + bytes32 _hash, + bytes32 _batcherHash, + uint32 _operatorFeeScalar, + uint64 _operatorFeeConstant, + uint16 _daFootprintGasScalar + ) + internal + pure + returns (bytes memory) + { + bytes4 functionSignature = bytes4(keccak256("setL1BlockValuesJovian()")); + + // Split up the encoding into multiple parts to avoid stack too deep. + return abi.encodePacked( + abi.encodePacked( + functionSignature, _baseFeeScalar, _blobBaseFeeScalar, _sequenceNumber, _timestamp, _number, _baseFee + ), + abi.encodePacked( + _blobBaseFee, _hash, _batcherHash, _operatorFeeScalar, _operatorFeeConstant, _daFootprintGasScalar + ) + ); + } + /// @notice Encodes a super root proof into the preimage of a Super Root. /// @param _superRootProof Super root proof to encode. /// @return Encoded super root proof. diff --git a/packages/contracts-bedrock/test/L1/SystemConfig.t.sol b/packages/contracts-bedrock/test/L1/SystemConfig.t.sol index cfa090517b1..0903cb2f37c 100644 --- a/packages/contracts-bedrock/test/L1/SystemConfig.t.sol +++ b/packages/contracts-bedrock/test/L1/SystemConfig.t.sol @@ -907,3 +907,23 @@ contract SystemConfig_SetMinBaseFee_Test is SystemConfig_TestInit { assertEq(systemConfig.minBaseFee(), newMinBaseFee); } } + +/// @title SystemConfig_SetDAFootprintGasScalar_Test +/// @notice Test contract for SystemConfig `setDAFootprintGasScalar` function. +contract SystemConfig_SetDAFootprintGasScalar_Test is SystemConfig_TestInit { + /// @notice Tests that `setDAFootprintGasScalar` reverts if the caller is not the owner. + function test_setDAFootprintGasScalar_notOwner_reverts() external { + vm.expectRevert("Ownable: caller is not the owner"); + systemConfig.setDAFootprintGasScalar(0); + } + + /// @notice Tests that `setDAFootprintGasScalar` updates the DA footprint gas scalar successfully. + function testFuzz_setDAFootprintGasScalar_succeeds(uint16 newScalar) external { + vm.expectEmit(address(systemConfig)); + emit ConfigUpdate(0, ISystemConfig.UpdateType.DA_FOOTPRINT_GAS_SCALAR, abi.encode(newScalar)); + + vm.prank(systemConfig.owner()); + systemConfig.setDAFootprintGasScalar(newScalar); + assertEq(systemConfig.daFootprintGasScalar(), newScalar); + } +} diff --git a/packages/contracts-bedrock/test/L2/L1Block.t.sol b/packages/contracts-bedrock/test/L2/L1Block.t.sol index 7a276b94df5..e89219c9e29 100644 --- a/packages/contracts-bedrock/test/L2/L1Block.t.sol +++ b/packages/contracts-bedrock/test/L2/L1Block.t.sol @@ -19,6 +19,18 @@ contract L1Block_TestInit is CommonTest { super.setUp(); depositor = l1Block.DEPOSITOR_ACCOUNT(); } + + /// @notice Asserts that legacy high 128-bit ranges in key storage slots remain zeroed. + function assertEmptyLegacySlotRanges() internal view { + // 128 high bits mask for 32-byte word + bytes32 mask128 = hex"FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF00000000000000000000000000000000"; + // Check scalars and sequenceNumber slot (slot 3) + bytes32 scalarsSlot = vm.load(address(l1Block), bytes32(uint256(3))); + assertEq(0, scalarsSlot & mask128); + // Check number and timestamp slot (slot 0) + bytes32 numberTimestampSlot = vm.load(address(l1Block), bytes32(uint256(0))); + assertEq(0, numberTimestampSlot & mask128); + } } /// @title L1Block_GasPayingToken_Test @@ -89,8 +101,8 @@ contract L1Block_SetL1BlockValues_Test is L1Block_TestInit { assertEq(l1Block.l1FeeScalar(), fs); } - /// @notice Tests that `setL1BlockValues` can set max values. - function test_setL1BlockValues_succeeds() external { + /// @notice Tests that `setL1BlockValues` succeeds with max values + function test_setL1BlockValuesMax_succeeds() external { vm.prank(depositor); l1Block.setL1BlockValues({ _number: type(uint64).max, @@ -155,21 +167,11 @@ contract L1Block_SetL1BlockValuesEcotone_Test is L1Block_TestInit { assertEq(l1Block.hash(), hash); assertEq(l1Block.batcherHash(), batcherHash); - // ensure we didn't accidentally pollute the 128 bits of the sequencenum+scalars slot that - // should be empty - bytes32 scalarsSlot = vm.load(address(l1Block), bytes32(uint256(3))); - bytes32 mask128 = hex"FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF00000000000000000000000000000000"; - - assertEq(0, scalarsSlot & mask128); - - // ensure we didn't accidentally pollute the 128 bits of the number & timestamp slot that - // should be empty - bytes32 numberTimestampSlot = vm.load(address(l1Block), bytes32(uint256(0))); - assertEq(0, numberTimestampSlot & mask128); + assertEmptyLegacySlotRanges(); } - /// @notice Tests that `setL1BlockValuesEcotone` succeeds if sender address is the depositor - function test_setL1BlockValuesEcotone_isDepositor_succeeds() external { + /// @notice Tests that `setL1BlockValuesEcotone` succeeds with max values + function test_setL1BlockValuesEcotone_isDepositorMax_succeeds() external { bytes memory functionCallDataPacked = Encoding.encodeSetL1BlockValuesEcotone( type(uint32).max, type(uint32).max, @@ -258,21 +260,11 @@ contract L1Block_SetL1BlockValuesIsthmus_Test is L1Block_TestInit { assertEq(l1Block.operatorFeeScalar(), operatorFeeScalar); assertEq(l1Block.operatorFeeConstant(), operatorFeeConstant); - // ensure we didn't accidentally pollute the 128 bits of the sequencenum+scalars slot that - // should be empty - bytes32 scalarsSlot = vm.load(address(l1Block), bytes32(uint256(3))); - bytes32 mask128 = hex"FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF00000000000000000000000000000000"; - - assertEq(0, scalarsSlot & mask128); - - // ensure we didn't accidentally pollute the 128 bits of the number & timestamp slot that - // should be empty - bytes32 numberTimestampSlot = vm.load(address(l1Block), bytes32(uint256(0))); - assertEq(0, numberTimestampSlot & mask128); + assertEmptyLegacySlotRanges(); } - /// @notice Tests that `setL1BlockValuesIsthmus` succeeds if sender address is the depositor - function test_setL1BlockValuesIsthmus_isDepositor_succeeds() external { + /// @notice Tests that `setL1BlockValuesIsthmus` succeeds with max values + function test_setL1BlockValuesIsthmus_isDepositorMax_succeeds() external { bytes memory functionCallDataPacked = Encoding.encodeSetL1BlockValuesIsthmus( type(uint32).max, type(uint32).max, @@ -315,3 +307,106 @@ contract L1Block_SetL1BlockValuesIsthmus_Test is L1Block_TestInit { assertEq(data, expReturn); } } + +/// @title L1Block_SetL1BlockValuesJovian_Test +/// @notice Tests the `setL1BlockValuesJovian` function of the `L1Block` contract. +contract L1Block_SetL1BlockValuesJovian_Test is L1Block_TestInit { + /// @notice Struct to group parameters for L1BlockValuesJovian to avoid stack too deep. + struct L1BlockValuesJovianParams { + uint32 baseFeeScalar; + uint32 blobBaseFeeScalar; + uint64 sequenceNumber; + uint64 timestamp; + uint64 number; + uint256 baseFee; + uint256 blobBaseFee; + bytes32 hash; + bytes32 batcherHash; + uint32 operatorFeeScalar; + uint64 operatorFeeConstant; + uint16 daFootprintGasScalar; + } + + /// @notice Tests that setL1BlockValuesJovian updates the values appropriately. + function testFuzz_setL1BlockValuesJovian_succeeds(L1BlockValuesJovianParams memory params) external { + bytes memory functionCallDataPacked = Encoding.encodeSetL1BlockValuesJovian( + params.baseFeeScalar, + params.blobBaseFeeScalar, + params.sequenceNumber, + params.timestamp, + params.number, + params.baseFee, + params.blobBaseFee, + params.hash, + params.batcherHash, + params.operatorFeeScalar, + params.operatorFeeConstant, + params.daFootprintGasScalar + ); + + vm.prank(depositor); + (bool success,) = address(l1Block).call(functionCallDataPacked); + assertTrue(success, "Function call failed"); + + assertEq(l1Block.baseFeeScalar(), params.baseFeeScalar); + assertEq(l1Block.blobBaseFeeScalar(), params.blobBaseFeeScalar); + assertEq(l1Block.sequenceNumber(), params.sequenceNumber); + assertEq(l1Block.timestamp(), params.timestamp); + assertEq(l1Block.number(), params.number); + assertEq(l1Block.basefee(), params.baseFee); + assertEq(l1Block.blobBaseFee(), params.blobBaseFee); + assertEq(l1Block.hash(), params.hash); + assertEq(l1Block.batcherHash(), params.batcherHash); + assertEq(l1Block.operatorFeeScalar(), params.operatorFeeScalar); + assertEq(l1Block.operatorFeeConstant(), params.operatorFeeConstant); + assertEq(l1Block.daFootprintGasScalar(), params.daFootprintGasScalar); + + assertEmptyLegacySlotRanges(); + } + + /// @notice Tests that `setL1BlockValuesJovian` succeeds with max values + function test_setL1BlockValuesJovian_isDepositorMax_succeeds() external { + bytes memory functionCallDataPacked = Encoding.encodeSetL1BlockValuesJovian( + type(uint32).max, + type(uint32).max, + type(uint64).max, + type(uint64).max, + type(uint64).max, + type(uint256).max, + type(uint256).max, + bytes32(type(uint256).max), + bytes32(type(uint256).max), + type(uint32).max, + type(uint64).max, + type(uint16).max + ); + + vm.prank(depositor); + (bool success,) = address(l1Block).call(functionCallDataPacked); + assertTrue(success, "function call failed"); + } + + /// @notice Tests that `setL1BlockValuesJovian` reverts if sender address is not the depositor + function test_setL1BlockValuesJovian_notDepositor_reverts() external { + bytes memory functionCallDataPacked = Encoding.encodeSetL1BlockValuesJovian( + type(uint32).max, + type(uint32).max, + type(uint64).max, + type(uint64).max, + type(uint64).max, + type(uint256).max, + type(uint256).max, + bytes32(type(uint256).max), + bytes32(type(uint256).max), + type(uint32).max, + type(uint64).max, + type(uint16).max + ); + + (bool success, bytes memory data) = address(l1Block).call(functionCallDataPacked); + assertTrue(!success, "function call should have failed"); + // make sure return value is the expected function selector for "NotDepositor()" + bytes memory expReturn = hex"3cc50b45"; + assertEq(data, expReturn); + } +} From 8b90c8f82e431d476f7027cc05ef23e0089a2231 Mon Sep 17 00:00:00 2001 From: steven <12021290+stevennevins@users.noreply.github.com> Date: Tue, 14 Oct 2025 13:43:31 -0400 Subject: [PATCH 054/117] opcm: Update OPCM.deploy to use v2 games (#17408) * feat: integrate v2 implementations into opcm * fix: skip v2 implementations if not deployed * chore: bump semver version * feat: conditionally set the v2 games based on feature flag * feat: add override for setup to re-deploy opcm with feature flag * test: improve test by deploying with the feature flag and asserting on output * test: add assertion that the deployment configuration on the dgf is correct * chore: improve test name * refactor: add helper function for feature toggled deployment of opcm * fix: bytecode size check failing * chore: run forge fmt * fix: address CI naming and semver bump * fix: rename setup contract name to align with ci checks * chore: comment out added fix * fix: verify opcm * fix: naming convention for test contracts * fix: move the updates for addGameType to the addGameType pr * fix: proposer removed * fix: rename function for clarity in VerifyOPCM script Rename _isV2Implementation to _isV2DisputeGameImplementation for better clarity about what types of contracts this function checks for. * fix: add proper gameArgs for V2 dispute game registration and fix setting output implementation on outupt struct * test: add helper functin for creating game proxies * test: refactor helper functions for test and remove impl from output struct * test: test args correct on created proxy games * chore: remove unused helper for now * fix: remove guard clause from local issue * chore: bump semver * chore: revert changes to ignore v2 implementations * fix: check bitmap and contract name for ref * test: with feature toggle on * chore: forge fmt * Revert "chore: forge fmt" This reverts commit d029fdb8dd12445a839026972e3859be7aae1470. * Revert "test: with feature toggle on" This reverts commit a932eb608d25f9acf486ce49aeb5318742c666de. * chore: forge fmt * fix: test compiler restriction fix * Revert "fix: test compiler restriction fix" This reverts commit 50282cf4fbf32b2a3615a4d9537e0887436f682d. * fix: compiler bump * fix: typo * test: add test for verify opcm with v2 dispute games deployed * test: add skips for v1 tests if v2 deployed * fix: skip standard validator until its implemented * fix: skip addGameType until its implemented * fix: skip updatePrestate until its implemented * fix: remove diff in natspec * chore: add TODO comments with issue tracking to skips * fix: bump semver * chore: bump semver * Fix silent merge conflicts with develop * Bump semver version * Run semver-lock * Reintroduce OPContractsManager_Version_Test * Cleanup - revert comment change * Remove v2 contracts from DeployOutput * Remove unused imports * Update DeployOPChain tests to run across feature flags (in progress) * Update OPCM tests to work with FeatureFlags options * Merge PermissionedDisputeGame tests, use feature flags * Merge FaultDisputeGame tests, use feature flag in setup * Remove redundant test * Fix test name * Fix anchorRootNotFound test - pass in extra data * Extend deployment test to check more fields * Add guards around new setImplementation call * Add new error to OPCM interface * Run semver-lock * Prefix var with underscore * Remove unused imports * Regenerate snapshots * Pass opcm as an argument to _verifyOpcmContractRef * Reorganize verifyOPCM v2 skip logic * Add TODO to fix acceptance test * Add function documentation for the new opcm param * Cleanup: add test assertion messages * Remove opcm param from runSingle script * Tweak method documentation * Cleanup dead code --------- Co-authored-by: mbaxter --- .../tests/base/disputegame_v2/init_test.go | 4 +- .../interfaces/L1/IOPContractsManager.sol | 4 + .../deploy/DeployImplementations.s.sol | 4 +- .../scripts/deploy/DeployOPChain.s.sol | 34 +- .../scripts/deploy/VerifyOPCM.s.sol | 49 +- .../snapshots/abi/OPContractsManager.json | 21 + .../OPContractsManagerContractsContainer.json | 20 + .../abi/OPContractsManagerDeployer.json | 21 + .../abi/OPContractsManagerGameTypeAdder.json | 10 + .../OPContractsManagerInteropMigrator.json | 10 + .../abi/OPContractsManagerUpgrader.json | 10 + .../snapshots/semver-lock.json | 4 +- .../OPContractsManagerContractsContainer.json | 2 +- .../src/L1/OPContractsManager.sol | 124 +- .../test/L1/OPContractsManager.t.sol | 119 +- .../OPContractsManagerStandardValidator.t.sol | 5 + .../test/dispute/DisputeGameFactory.t.sol | 41 +- .../test/dispute/FaultDisputeGame.t.sol | 252 +- .../dispute/PermissionedDisputeGame.t.sol | 190 +- .../test/dispute/v2/FaultDisputeGameV2.t.sol | 3207 ----------------- .../v2/PermissionedDisputeGameV2.t.sol | 417 --- .../test/opcm/DeployOPChain.t.sol | 88 +- .../test/scripts/VerifyOPCM.t.sol | 46 +- 23 files changed, 939 insertions(+), 3743 deletions(-) delete mode 100644 packages/contracts-bedrock/test/dispute/v2/FaultDisputeGameV2.t.sol delete mode 100644 packages/contracts-bedrock/test/dispute/v2/PermissionedDisputeGameV2.t.sol diff --git a/op-acceptance-tests/tests/base/disputegame_v2/init_test.go b/op-acceptance-tests/tests/base/disputegame_v2/init_test.go index 7f14f8776a7..c777264489c 100644 --- a/op-acceptance-tests/tests/base/disputegame_v2/init_test.go +++ b/op-acceptance-tests/tests/base/disputegame_v2/init_test.go @@ -7,5 +7,7 @@ import ( ) func TestMain(m *testing.M) { - presets.DoMain(m, presets.WithMinimal(), presets.WithDisputeGameV2()) + // TODO(#17810): Use the new v2 dispute game flag via presets.WithDisputeGameV2() + //presets.DoMain(m, presets.WithMinimal(), presets.WithDisputeGameV2()) + presets.DoMain(m, presets.WithMinimal()) } diff --git a/packages/contracts-bedrock/interfaces/L1/IOPContractsManager.sol b/packages/contracts-bedrock/interfaces/L1/IOPContractsManager.sol index aaffb5972a3..118829029ea 100644 --- a/packages/contracts-bedrock/interfaces/L1/IOPContractsManager.sol +++ b/packages/contracts-bedrock/interfaces/L1/IOPContractsManager.sol @@ -216,6 +216,8 @@ interface IOPContractsManager { address anchorStateRegistryImpl; address delayedWETHImpl; address mipsImpl; + address faultDisputeGameV2Impl; + address permissionedDisputeGameV2Impl; } /// @notice The input required to identify a chain for upgrading. @@ -304,6 +306,8 @@ interface IOPContractsManager { error PrestateRequired(); + error InvalidDevFeatureAccess(bytes32 devFeature); + // -------- Methods -------- function __constructor__( diff --git a/packages/contracts-bedrock/scripts/deploy/DeployImplementations.s.sol b/packages/contracts-bedrock/scripts/deploy/DeployImplementations.s.sol index fef559ef973..2503d23602e 100644 --- a/packages/contracts-bedrock/scripts/deploy/DeployImplementations.s.sol +++ b/packages/contracts-bedrock/scripts/deploy/DeployImplementations.s.sol @@ -157,7 +157,9 @@ contract DeployImplementations is Script { disputeGameFactoryImpl: address(_output.disputeGameFactoryImpl), anchorStateRegistryImpl: address(_output.anchorStateRegistryImpl), delayedWETHImpl: address(_output.delayedWETHImpl), - mipsImpl: address(_output.mipsSingleton) + mipsImpl: address(_output.mipsSingleton), + faultDisputeGameV2Impl: address(_output.faultDisputeGameV2Impl), + permissionedDisputeGameV2Impl: address(_output.permissionedDisputeGameV2Impl) }); deployOPCMBPImplsContainer(_input, _output, _blueprints, implementations); diff --git a/packages/contracts-bedrock/scripts/deploy/DeployOPChain.s.sol b/packages/contracts-bedrock/scripts/deploy/DeployOPChain.s.sol index 77a3d3d4351..7bf5c07456d 100644 --- a/packages/contracts-bedrock/scripts/deploy/DeployOPChain.s.sol +++ b/packages/contracts-bedrock/scripts/deploy/DeployOPChain.s.sol @@ -3,6 +3,7 @@ pragma solidity 0.8.15; import { Script } from "forge-std/Script.sol"; +import { DevFeatures } from "src/libraries/DevFeatures.sol"; import { DeployUtils } from "scripts/libraries/DeployUtils.sol"; import { Solarray } from "scripts/libraries/Solarray.sol"; import { ChainAssertions } from "scripts/deploy/ChainAssertions.sol"; @@ -24,6 +25,7 @@ import { IL1ERC721Bridge } from "interfaces/L1/IL1ERC721Bridge.sol"; import { IL1StandardBridge } from "interfaces/L1/IL1StandardBridge.sol"; import { IOptimismMintableERC20Factory } from "interfaces/universal/IOptimismMintableERC20Factory.sol"; import { IETHLockbox } from "interfaces/L1/IETHLockbox.sol"; +import { IOPContractsManager } from "../../interfaces/L1/IOPContractsManager.sol"; contract DeployOPChain is Script { struct Output { @@ -120,6 +122,13 @@ contract DeployOPChain is Script { checkOutput(_input, output_); } + // -------- Features -------- + + function isDevFeatureV2DisputeGamesEnabled(address _opcmAddr) internal view returns (bool) { + IOPContractsManager opcm = IOPContractsManager(_opcmAddr); + return DevFeatures.isDevFeatureEnabled(opcm.devFeatureBitmap(), DevFeatures.DEPLOY_V2_DISPUTE_GAMES); + } + // -------- Validations -------- function checkInput(Types.DeployOPChainInput memory _i) public view { @@ -162,13 +171,19 @@ contract DeployOPChain is Script { address(_o.optimismPortalProxy), address(_o.disputeGameFactoryProxy), address(_o.anchorStateRegistryProxy), - address(_o.permissionedDisputeGame), address(_o.delayedWETHPermissionedGameProxy), address(_o.ethLockboxProxy) ); - // TODO: Eventually switch from Permissioned to Permissionless. Add this address back in. - // address(_o.delayedWETHPermissionlessGameProxy) - // address(_o.faultDisputeGame()), + + if (!isDevFeatureV2DisputeGamesEnabled(_i.opcm)) { + // Only check dispute game contracts if v2 dispute games are not enabled. + // When v2 contracts are enabled, we no longer deploy dispute games per chain + addrs2 = Solarray.extend(addrs2, Solarray.addresses(address(_o.permissionedDisputeGame))); + + // TODO: Eventually switch from Permissioned to Permissionless. Add these addresses back in. + // address(_o.delayedWETHPermissionlessGameProxy) + // address(_o.faultDisputeGame()), + } DeployUtils.assertValidContractAddresses(Solarray.extend(addrs1, addrs2)); _assertValidDeploy(_i, _o); @@ -192,10 +207,17 @@ contract DeployOPChain is Script { SuperchainConfig: address(0) }); - ChainAssertions.checkAnchorStateRegistryProxy(_o.anchorStateRegistryProxy, true); + // Check dispute games + address expectedPDGImpl = address(_o.permissionedDisputeGame); + if (isDevFeatureV2DisputeGamesEnabled(_i.opcm)) { + // With v2 game contracts enabled, we use the predeployed pdg implementation + expectedPDGImpl = IOPContractsManager(_i.opcm).implementations().permissionedDisputeGameV2Impl; + } ChainAssertions.checkDisputeGameFactory( - _o.disputeGameFactoryProxy, _i.opChainProxyAdminOwner, address(_o.permissionedDisputeGame), true + _o.disputeGameFactoryProxy, _i.opChainProxyAdminOwner, expectedPDGImpl, true ); + + ChainAssertions.checkAnchorStateRegistryProxy(_o.anchorStateRegistryProxy, true); ChainAssertions.checkL1CrossDomainMessenger(_o.l1CrossDomainMessengerProxy, vm, true); ChainAssertions.checkOptimismPortal2({ _contracts: proxies, diff --git a/packages/contracts-bedrock/scripts/deploy/VerifyOPCM.s.sol b/packages/contracts-bedrock/scripts/deploy/VerifyOPCM.s.sol index f67fd644849..b8dc9a685b4 100644 --- a/packages/contracts-bedrock/scripts/deploy/VerifyOPCM.s.sol +++ b/packages/contracts-bedrock/scripts/deploy/VerifyOPCM.s.sol @@ -12,6 +12,7 @@ import { LibString } from "@solady/utils/LibString.sol"; import { Process } from "scripts/libraries/Process.sol"; import { Config } from "scripts/libraries/Config.sol"; import { Bytes } from "src/libraries/Bytes.sol"; +import { DevFeatures } from "src/libraries/DevFeatures.sol"; // Interfaces import { IOPContractsManager } from "interfaces/L1/IOPContractsManager.sol"; @@ -113,6 +114,8 @@ contract VerifyOPCM is Script { fieldNameOverrides["optimismPortalInteropImpl"] = "OptimismPortalInterop"; fieldNameOverrides["mipsImpl"] = "MIPS64"; fieldNameOverrides["ethLockboxImpl"] = "ETHLockbox"; + fieldNameOverrides["faultDisputeGameV2Impl"] = "FaultDisputeGameV2"; + fieldNameOverrides["permissionedDisputeGameV2Impl"] = "PermissionedDisputeGameV2"; fieldNameOverrides["permissionlessDisputeGame1"] = "FaultDisputeGame"; fieldNameOverrides["permissionlessDisputeGame2"] = "FaultDisputeGame"; fieldNameOverrides["permissionedDisputeGame1"] = "PermissionedDisputeGame"; @@ -177,8 +180,14 @@ contract VerifyOPCM is Script { /// @param _addr Address of the contract to verify. /// @param _skipConstructorVerification Whether to skip constructor verification. function runSingle(string memory _name, address _addr, bool _skipConstructorVerification) public { + // This function is used as part of the release checklist to verify new contracts. + // Rather than requiring an opcm input parameter, just pass in an empty reference + // as we really only need this for features that are in development. + IOPContractsManager emptyOpcm = IOPContractsManager(address(0)); _verifyOpcmContractRef( - OpcmContractRef({ field: _name, name: _name, addr: _addr, blueprint: false }), _skipConstructorVerification + emptyOpcm, + OpcmContractRef({ field: _name, name: _name, addr: _addr, blueprint: false }), + _skipConstructorVerification ); } @@ -213,7 +222,7 @@ contract VerifyOPCM is Script { // Verify each reference. bool success = true; for (uint256 i = 0; i < refs.length; i++) { - success = _verifyOpcmContractRef(refs[i], _skipConstructorVerification) && success; + success = _verifyOpcmContractRef(opcm, refs[i], _skipConstructorVerification) && success; } // Final Result @@ -381,16 +390,20 @@ contract VerifyOPCM is Script { } /// @notice Verifies a single OPCM contract reference (implementation or bytecode). + /// @param _opcm The OPCM contract that contains the target contract reference. /// @param _target The target contract reference to verify. /// @param _skipConstructorVerification Whether to skip constructor verification. /// @return True if the contract reference is verified, false otherwise. function _verifyOpcmContractRef( + IOPContractsManager _opcm, OpcmContractRef memory _target, bool _skipConstructorVerification ) internal returns (bool) { + bool success = true; + console.log(); console.log(string.concat("Checking Contract: ", _target.field)); console.log(string.concat(" Type: ", _target.blueprint ? "Blueprint" : "Implementation")); @@ -401,6 +414,20 @@ contract VerifyOPCM is Script { string memory artifactPath = _buildArtifactPath(_target.name); console.log(string.concat(" Expected Runtime Artifact: ", artifactPath)); + // Check if this is a V2 dispute game that should be skipped + if (_isV2DisputeGameImplementation(_target.name)) { + if (!_isV2DisputeGamesEnabled(_opcm)) { + if (_target.addr == address(0)) { + console.log("[SKIP] V2 dispute game not deployed (feature disabled)"); + return true; // Consider this "verified" when feature is off + } else { + console.log("[FAIL] ERROR: V2 dispute game deployed but feature disabled"); + success = false; + } + } + // If feature is enabled, continue with normal verification + } + // Load artifact information (bytecode, immutable refs) for detailed comparison ArtifactInfo memory artifact = _loadArtifactInfo(artifactPath); @@ -442,7 +469,7 @@ contract VerifyOPCM is Script { } // Perform detailed bytecode comparison. - bool success = _compareBytecode(actualCode, expectedCode, _target.name, artifact, !_target.blueprint); + success = _compareBytecode(actualCode, expectedCode, _target.name, artifact, !_target.blueprint) && success; // If requested and this is not a blueprint, we also need to check the creation code. if (!_target.blueprint && !_skipConstructorVerification) { @@ -497,6 +524,22 @@ contract VerifyOPCM is Script { return success; } + /// @notice Checks if V2 dispute games feature is enabled in the dev feature bitmap. + /// @param _opcm The OPContractsManager to check. + /// @return True if V2 dispute games are enabled. + function _isV2DisputeGamesEnabled(IOPContractsManager _opcm) internal view returns (bool) { + bytes32 bitmap = _opcm.devFeatureBitmap(); + return DevFeatures.isDevFeatureEnabled(bitmap, DevFeatures.DEPLOY_V2_DISPUTE_GAMES); + } + + /// @notice Checks if a contract is a V2 dispute game implementation. + /// @param _contractName The name to check. + /// @return True if this is a V2 dispute game. + function _isV2DisputeGameImplementation(string memory _contractName) internal pure returns (bool) { + return LibString.eq(_contractName, "FaultDisputeGameV2") + || LibString.eq(_contractName, "PermissionedDisputeGameV2"); + } + /// @notice Verifies that the immutable variables in the OPCM contract match expected values. /// @param _opcm The OPCM contract to verify immutable variables for. /// @return True if all immutable variables are verified, false otherwise. diff --git a/packages/contracts-bedrock/snapshots/abi/OPContractsManager.json b/packages/contracts-bedrock/snapshots/abi/OPContractsManager.json index b9e54537a4d..5372533426d 100644 --- a/packages/contracts-bedrock/snapshots/abi/OPContractsManager.json +++ b/packages/contracts-bedrock/snapshots/abi/OPContractsManager.json @@ -525,6 +525,16 @@ "internalType": "address", "name": "mipsImpl", "type": "address" + }, + { + "internalType": "address", + "name": "faultDisputeGameV2Impl", + "type": "address" + }, + { + "internalType": "address", + "name": "permissionedDisputeGameV2Impl", + "type": "address" } ], "internalType": "struct OPContractsManager.Implementations", @@ -991,6 +1001,17 @@ "name": "InvalidChainId", "type": "error" }, + { + "inputs": [ + { + "internalType": "bytes32", + "name": "devFeature", + "type": "bytes32" + } + ], + "name": "InvalidDevFeatureAccess", + "type": "error" + }, { "inputs": [], "name": "InvalidGameConfigs", diff --git a/packages/contracts-bedrock/snapshots/abi/OPContractsManagerContractsContainer.json b/packages/contracts-bedrock/snapshots/abi/OPContractsManagerContractsContainer.json index c49484fc722..6b4c6228c27 100644 --- a/packages/contracts-bedrock/snapshots/abi/OPContractsManagerContractsContainer.json +++ b/packages/contracts-bedrock/snapshots/abi/OPContractsManagerContractsContainer.json @@ -144,6 +144,16 @@ "internalType": "address", "name": "mipsImpl", "type": "address" + }, + { + "internalType": "address", + "name": "faultDisputeGameV2Impl", + "type": "address" + }, + { + "internalType": "address", + "name": "permissionedDisputeGameV2Impl", + "type": "address" } ], "internalType": "struct OPContractsManager.Implementations", @@ -340,6 +350,16 @@ "internalType": "address", "name": "mipsImpl", "type": "address" + }, + { + "internalType": "address", + "name": "faultDisputeGameV2Impl", + "type": "address" + }, + { + "internalType": "address", + "name": "permissionedDisputeGameV2Impl", + "type": "address" } ], "internalType": "struct OPContractsManager.Implementations", diff --git a/packages/contracts-bedrock/snapshots/abi/OPContractsManagerDeployer.json b/packages/contracts-bedrock/snapshots/abi/OPContractsManagerDeployer.json index 7cd7a44502c..08b6612c99a 100644 --- a/packages/contracts-bedrock/snapshots/abi/OPContractsManagerDeployer.json +++ b/packages/contracts-bedrock/snapshots/abi/OPContractsManagerDeployer.json @@ -428,6 +428,16 @@ "internalType": "address", "name": "mipsImpl", "type": "address" + }, + { + "internalType": "address", + "name": "faultDisputeGameV2Impl", + "type": "address" + }, + { + "internalType": "address", + "name": "permissionedDisputeGameV2Impl", + "type": "address" } ], "internalType": "struct OPContractsManager.Implementations", @@ -518,6 +528,17 @@ "name": "InvalidChainId", "type": "error" }, + { + "inputs": [ + { + "internalType": "bytes32", + "name": "devFeature", + "type": "bytes32" + } + ], + "name": "InvalidDevFeatureAccess", + "type": "error" + }, { "inputs": [ { diff --git a/packages/contracts-bedrock/snapshots/abi/OPContractsManagerGameTypeAdder.json b/packages/contracts-bedrock/snapshots/abi/OPContractsManagerGameTypeAdder.json index 6bf43934187..5a513822ef9 100644 --- a/packages/contracts-bedrock/snapshots/abi/OPContractsManagerGameTypeAdder.json +++ b/packages/contracts-bedrock/snapshots/abi/OPContractsManagerGameTypeAdder.json @@ -321,6 +321,16 @@ "internalType": "address", "name": "mipsImpl", "type": "address" + }, + { + "internalType": "address", + "name": "faultDisputeGameV2Impl", + "type": "address" + }, + { + "internalType": "address", + "name": "permissionedDisputeGameV2Impl", + "type": "address" } ], "internalType": "struct OPContractsManager.Implementations", diff --git a/packages/contracts-bedrock/snapshots/abi/OPContractsManagerInteropMigrator.json b/packages/contracts-bedrock/snapshots/abi/OPContractsManagerInteropMigrator.json index b06cd541bb3..e8d1dec02c2 100644 --- a/packages/contracts-bedrock/snapshots/abi/OPContractsManagerInteropMigrator.json +++ b/packages/contracts-bedrock/snapshots/abi/OPContractsManagerInteropMigrator.json @@ -223,6 +223,16 @@ "internalType": "address", "name": "mipsImpl", "type": "address" + }, + { + "internalType": "address", + "name": "faultDisputeGameV2Impl", + "type": "address" + }, + { + "internalType": "address", + "name": "permissionedDisputeGameV2Impl", + "type": "address" } ], "internalType": "struct OPContractsManager.Implementations", diff --git a/packages/contracts-bedrock/snapshots/abi/OPContractsManagerUpgrader.json b/packages/contracts-bedrock/snapshots/abi/OPContractsManagerUpgrader.json index 512a83ae75c..a092f317994 100644 --- a/packages/contracts-bedrock/snapshots/abi/OPContractsManagerUpgrader.json +++ b/packages/contracts-bedrock/snapshots/abi/OPContractsManagerUpgrader.json @@ -223,6 +223,16 @@ "internalType": "address", "name": "mipsImpl", "type": "address" + }, + { + "internalType": "address", + "name": "faultDisputeGameV2Impl", + "type": "address" + }, + { + "internalType": "address", + "name": "permissionedDisputeGameV2Impl", + "type": "address" } ], "internalType": "struct OPContractsManager.Implementations", diff --git a/packages/contracts-bedrock/snapshots/semver-lock.json b/packages/contracts-bedrock/snapshots/semver-lock.json index bb73996e593..0316ab9250b 100644 --- a/packages/contracts-bedrock/snapshots/semver-lock.json +++ b/packages/contracts-bedrock/snapshots/semver-lock.json @@ -20,8 +20,8 @@ "sourceCodeHash": "0xfca613b5d055ffc4c3cbccb0773ddb9030abedc1aa6508c9e2e7727cc0cd617b" }, "src/L1/OPContractsManager.sol:OPContractsManager": { - "initCodeHash": "0x9f9a3738b05cae6597ea9a5c5747f7dbd3a5328b05a319955054fbd8b1aaa791", - "sourceCodeHash": "0x154c764083f353e2a56337c0dd5cbcd6f2e12c21966cd0580c7a0f96c4e147dd" + "initCodeHash": "0x42721744f90fa46ee680fecc69da2e5caf7fdd8093c2a7f3b33958e574a15579", + "sourceCodeHash": "0x3eab23f3f034eec77afb620a122e51fded9214b5ed6a4c5663e0174714ae0f5e" }, "src/L1/OPContractsManagerStandardValidator.sol:OPContractsManagerStandardValidator": { "initCodeHash": "0x57d6a6729d887ead009d518e8f17fa0d26bfc97b8efe1494ab4ef8dbb000d109", diff --git a/packages/contracts-bedrock/snapshots/storageLayout/OPContractsManagerContractsContainer.json b/packages/contracts-bedrock/snapshots/storageLayout/OPContractsManagerContractsContainer.json index d87deb94bc7..21930538698 100644 --- a/packages/contracts-bedrock/snapshots/storageLayout/OPContractsManagerContractsContainer.json +++ b/packages/contracts-bedrock/snapshots/storageLayout/OPContractsManagerContractsContainer.json @@ -7,7 +7,7 @@ "type": "struct OPContractsManager.Blueprints" }, { - "bytes": "448", + "bytes": "512", "label": "implementation", "offset": 0, "slot": "13", diff --git a/packages/contracts-bedrock/src/L1/OPContractsManager.sol b/packages/contracts-bedrock/src/L1/OPContractsManager.sol index 142fa67ea35..f72daa376a2 100644 --- a/packages/contracts-bedrock/src/L1/OPContractsManager.sol +++ b/packages/contracts-bedrock/src/L1/OPContractsManager.sol @@ -306,6 +306,35 @@ abstract contract OPContractsManagerBase { return _disputeGame.challenger(); } + /// @notice Helper function to register permissioned game V2 implementation + /// @dev Extracted to avoid stack too deep error + /// @param _input The deployment input data containing all necessary parameters + /// @param _implementation The implementation addresses struct + /// @param _output The deployment output containing proxy addresses + function _registerPermissionedGameV2( + OPContractsManager.DeployInput calldata _input, + OPContractsManager.Implementations memory _implementation, + OPContractsManager.DeployOutput memory _output + ) + internal + { + bytes memory gameArgs = abi.encodePacked( + _input.disputeAbsolutePrestate, // 32 bytes + _implementation.mipsImpl, // 20 bytes + address(_output.anchorStateRegistryProxy), // 20 bytes + address(_output.delayedWETHPermissionedGameProxy), // 20 bytes + _input.l2ChainId, // 32 bytes + _input.roles.proposer, // 20 bytes + _input.roles.challenger // 20 bytes + ); + setDGFImplementation( + _output.disputeGameFactoryProxy, + GameTypes.PERMISSIONED_CANNON, + IDisputeGame(_implementation.permissionedDisputeGameV2Impl), + gameArgs + ); + } + /// @notice Retrieves the DisputeGameFactory address for a given SystemConfig function getDisputeGameFactory(ISystemConfig _systemConfig) internal view returns (IDisputeGameFactory) { return IDisputeGameFactory(_systemConfig.disputeGameFactory()); @@ -360,9 +389,31 @@ abstract contract OPContractsManagerBase { } /// @notice Sets a game implementation on the dispute game factory + /// @param _dgf The dispute game factory + /// @param _gameType The game type + /// @param _newGame The new game implementation function setDGFImplementation(IDisputeGameFactory _dgf, GameType _gameType, IDisputeGame _newGame) internal { _dgf.setImplementation(_gameType, _newGame); } + + /// @notice Sets a game implementation on the dispute game factory + /// @param _dgf The dispute game factory + /// @param _gameType The game type + /// @param _newGame The new game implementation + /// @param _gameArgs Game arguments for this game type + function setDGFImplementation( + IDisputeGameFactory _dgf, + GameType _gameType, + IDisputeGame _newGame, + bytes memory _gameArgs + ) + internal + { + if (!isDevFeatureEnabled(DevFeatures.DEPLOY_V2_DISPUTE_GAMES)) { + revert OPContractsManager.InvalidDevFeatureAccess(DevFeatures.DEPLOY_V2_DISPUTE_GAMES); + } + _dgf.setImplementation(_gameType, _newGame, _gameArgs); + } } contract OPContractsManagerGameTypeAdder is OPContractsManagerBase { @@ -1064,30 +1115,31 @@ contract OPContractsManagerDeployer is OPContractsManagerBase { ) ); - // While not a proxy, we deploy the PermissionedDisputeGame here as well because it's bespoke per chain. - output.permissionedDisputeGame = IPermissionedDisputeGame( - Blueprint.deployFrom( - blueprint.permissionedDisputeGame1, - blueprint.permissionedDisputeGame2, - computeSalt(_input.l2ChainId, _input.saltMixer, "PermissionedDisputeGame"), - encodePermissionedFDGConstructor( - IFaultDisputeGame.GameConstructorParams({ - gameType: GameTypes.PERMISSIONED_CANNON, - absolutePrestate: _input.disputeAbsolutePrestate, - maxGameDepth: _input.disputeMaxGameDepth, - splitDepth: _input.disputeSplitDepth, - clockExtension: _input.disputeClockExtension, - maxClockDuration: _input.disputeMaxClockDuration, - vm: IBigStepper(implementation.mipsImpl), - weth: IDelayedWETH(payable(address(output.delayedWETHPermissionedGameProxy))), - anchorStateRegistry: IAnchorStateRegistry(address(output.anchorStateRegistryProxy)), - l2ChainId: _input.l2ChainId - }), - _input.roles.proposer, - _input.roles.challenger + if (!isDevFeatureEnabled(DevFeatures.DEPLOY_V2_DISPUTE_GAMES)) { + output.permissionedDisputeGame = IPermissionedDisputeGame( + Blueprint.deployFrom( + blueprint.permissionedDisputeGame1, + blueprint.permissionedDisputeGame2, + computeSalt(_input.l2ChainId, _input.saltMixer, "PermissionedDisputeGame"), + encodePermissionedFDGConstructor( + IFaultDisputeGame.GameConstructorParams({ + gameType: GameTypes.PERMISSIONED_CANNON, + absolutePrestate: _input.disputeAbsolutePrestate, + maxGameDepth: _input.disputeMaxGameDepth, + splitDepth: _input.disputeSplitDepth, + clockExtension: _input.disputeClockExtension, + maxClockDuration: _input.disputeMaxClockDuration, + vm: IBigStepper(implementation.mipsImpl), + weth: IDelayedWETH(payable(address(output.delayedWETHPermissionedGameProxy))), + anchorStateRegistry: IAnchorStateRegistry(address(output.anchorStateRegistryProxy)), + l2ChainId: _input.l2ChainId + }), + _input.roles.proposer, + _input.roles.challenger + ) ) - ) - ); + ); + } // -------- Set and Initialize Proxy Implementations -------- bytes memory data; @@ -1173,11 +1225,18 @@ contract OPContractsManagerDeployer is OPContractsManagerBase { implementation.disputeGameFactoryImpl, data ); - setDGFImplementation( - output.disputeGameFactoryProxy, - GameTypes.PERMISSIONED_CANNON, - IDisputeGame(address(output.permissionedDisputeGame)) - ); + // Register the appropriate dispute game implementation based on the feature flag + if (isDevFeatureEnabled(DevFeatures.DEPLOY_V2_DISPUTE_GAMES)) { + // Extracted to helper function to avoid stack too deep error + _registerPermissionedGameV2(_input, implementation, output); + } else { + // Register v1 implementation for PERMISSIONED_CANNON game type + setDGFImplementation( + output.disputeGameFactoryProxy, + GameTypes.PERMISSIONED_CANNON, + IDisputeGame(address(output.permissionedDisputeGame)) + ); + } transferOwnership(address(output.disputeGameFactoryProxy), address(_input.roles.opChainProxyAdminOwner)); @@ -1798,6 +1857,8 @@ contract OPContractsManager is ISemver { address anchorStateRegistryImpl; address delayedWETHImpl; address mipsImpl; + address faultDisputeGameV2Impl; + address permissionedDisputeGameV2Impl; } /// @notice The input required to identify a chain for upgrading, along with new prestate hashes @@ -1837,9 +1898,9 @@ contract OPContractsManager is ISemver { // -------- Constants and Variables -------- - /// @custom:semver 4.0.0 + /// @custom:semver 4.1.0 function version() public pure virtual returns (string memory) { - return "4.0.0"; + return "4.1.0"; } OPContractsManagerGameTypeAdder public immutable opcmGameTypeAdder; @@ -1906,6 +1967,9 @@ contract OPContractsManager is ISemver { /// @notice Thrown when the prestate of a permissioned disputed game is 0. error PrestateRequired(); + /// @notice Thrown if logic gated by a dev feature flag is incorrectly accessed. + error InvalidDevFeatureAccess(bytes32 devFeature); + // -------- Methods -------- constructor( diff --git a/packages/contracts-bedrock/test/L1/OPContractsManager.t.sol b/packages/contracts-bedrock/test/L1/OPContractsManager.t.sol index e2ffb7ed48f..babd8742b5a 100644 --- a/packages/contracts-bedrock/test/L1/OPContractsManager.t.sol +++ b/packages/contracts-bedrock/test/L1/OPContractsManager.t.sol @@ -5,6 +5,7 @@ pragma solidity 0.8.15; import { Test, stdStorage, StdStorage } from "forge-std/Test.sol"; import { VmSafe } from "forge-std/Vm.sol"; import { CommonTest } from "test/setup/CommonTest.sol"; +import { FeatureFlags } from "test/setup/FeatureFlags.sol"; import { DeployOPChain_TestBase } from "test/opcm/DeployOPChain.t.sol"; import { DelegateCaller } from "test/mocks/Callers.sol"; @@ -417,7 +418,7 @@ contract OPContractsManager_TestInit is CommonTest { /// @title OPContractsManager_ChainIdToBatchInboxAddress_Test /// @notice Tests the `chainIdToBatchInboxAddress` function of the `OPContractsManager` contract. /// @dev These tests use the harness which exposes internal functions for testing. -contract OPContractsManager_ChainIdToBatchInboxAddress_Test is Test { +contract OPContractsManager_ChainIdToBatchInboxAddress_Test is Test, FeatureFlags { OPContractsManager_Harness opcmHarness; address challenger = makeAddr("challenger"); @@ -430,8 +431,9 @@ contract OPContractsManager_ChainIdToBatchInboxAddress_Test is Test { vm.etch(address(superchainConfigProxy), hex"01"); vm.etch(address(protocolVersionsProxy), hex"01"); + resolveFeaturesFromEnv(); OPContractsManagerContractsContainer container = - new OPContractsManagerContractsContainer(emptyBlueprints, emptyImpls, bytes32(0)); + new OPContractsManagerContractsContainer(emptyBlueprints, emptyImpls, devFeatureBitmap); OPContractsManager.Implementations memory __opcmImplementations = container.implementations(); OPContractsManagerStandardValidator.Implementations memory opcmImplementations; @@ -472,6 +474,14 @@ contract OPContractsManager_ChainIdToBatchInboxAddress_Test is Test { /// @title OPContractsManager_AddGameType_Test /// @notice Tests the `addGameType` function of the `OPContractsManager` contract. contract OPContractsManager_AddGameType_Test is OPContractsManager_TestInit { + function setUp() public virtual override { + super.setUp(); + + // Skip AddGameType tests when V2 dispute games are enabled + // TODO(#17260): Remove skip when V2 dispute game support for addGameType implemented + skipIfDevFeatureEnabled(DevFeatures.DEPLOY_V2_DISPUTE_GAMES); + } + /// @notice Tests that we can add a PermissionedDisputeGame implementation with addGameType. function test_addGameType_permissioned_succeeds() public { // Create the input for the Permissioned game type. @@ -772,6 +782,12 @@ contract OPContractsManager_UpdatePrestate_Test is OPContractsManager_TestInit { function setUp() public virtual override { super.setUp(); + + // Skip UpdatePrestate tests when V2 dispute games enabled + // UpdatePrestate feature not yet implemented for V2 + // TODO(#17261): Remove skip when V2 dispute game support for updatePrestate implemented + skipIfDevFeatureEnabled(DevFeatures.DEPLOY_V2_DISPUTE_GAMES); + prestateUpdater = opcm; } @@ -1893,6 +1909,35 @@ contract OPContractsManager_Deploy_Test is DeployOPChain_TestBase { }); } + /// @notice Helper function to create a permissioned game through the factory + function _createPermissionedGame( + IDisputeGameFactory factory, + address proposer, + Claim claim, + uint256 l2BlockNumber + ) + internal + returns (IPermissionedDisputeGame) + { + // Check if there's an init bond required for the game type + uint256 initBond = factory.initBonds(GameTypes.PERMISSIONED_CANNON); + + // Fund the proposer if needed + if (initBond > 0) { + vm.deal(proposer, initBond); + } + + // We use vm.startPrank to set both msg.sender and tx.origin to the proposer + vm.startPrank(proposer, proposer); + + IDisputeGame gameProxy = + factory.create{ value: initBond }(GameTypes.PERMISSIONED_CANNON, claim, abi.encode(bytes32(l2BlockNumber))); + + vm.stopPrank(); + + return IPermissionedDisputeGame(address(gameProxy)); + } + function test_deploy_l2ChainIdEqualsZero_reverts() public { IOPContractsManager.DeployInput memory input = toOPCMDeployInput(deployOPChainInput); input.l2ChainId = 0; @@ -1914,20 +1959,72 @@ contract OPContractsManager_Deploy_Test is DeployOPChain_TestBase { emit Deployed(deployOPChainInput.l2ChainId, address(this), bytes("")); opcm.deploy(toOPCMDeployInput(deployOPChainInput)); } + + /// @notice Test that deploy sets the permissioned dispute game implementation + function test_deployPermissioned_succeeds() public { + bool isV2 = isDevFeatureEnabled(DevFeatures.DEPLOY_V2_DISPUTE_GAMES); + + // Sanity-check setup is consistent with devFeatures flag + IOPContractsManager.Implementations memory impls = opcm.implementations(); + address pdgImpl = address(impls.permissionedDisputeGameV2Impl); + address fdgImpl = address(impls.faultDisputeGameV2Impl); + if (isV2) { + assertFalse(pdgImpl == address(0), "PDG implementation address should be non-zero"); + assertFalse(fdgImpl == address(0), "FDG implementation address should be non-zero"); + } else { + assertTrue(pdgImpl == address(0), "PDG implementation address should be zero"); + assertTrue(fdgImpl == address(0), "FDG implementation address should be zero"); + } + + // Run OPCM.deploy + IOPContractsManager.DeployInput memory opcmInput = toOPCMDeployInput(deployOPChainInput); + IOPContractsManager.DeployOutput memory opcmOutput = opcm.deploy(opcmInput); + + // Verify that the DisputeGameFactory has registered an implementation for the PERMISSIONED_CANNON game type + address expectedPDGAddress = isV2 ? pdgImpl : address(opcmOutput.permissionedDisputeGame); + address actualPDGAddress = address(opcmOutput.disputeGameFactoryProxy.gameImpls(GameTypes.PERMISSIONED_CANNON)); + assertNotEq(actualPDGAddress, address(0), "DisputeGameFactory should have a registered PERMISSIONED_CANNON"); + assertEq(actualPDGAddress, address(expectedPDGAddress), "PDG address should match"); + + // Create a game proxy to test immutable fields + Claim claim = Claim.wrap(bytes32(uint256(9876))); + uint256 l2BlockNumber = uint256(123); + IPermissionedDisputeGame pdg = + _createPermissionedGame(opcmOutput.disputeGameFactoryProxy, opcmInput.roles.proposer, claim, l2BlockNumber); + + // Verify immutable fields on the game proxy + // Constructor args + assertEq(pdg.gameType().raw(), GameTypes.PERMISSIONED_CANNON.raw(), "Game type should match"); + assertEq(pdg.clockExtension().raw(), opcmInput.disputeClockExtension.raw(), "Clock extension should match"); + assertEq( + pdg.maxClockDuration().raw(), opcmInput.disputeMaxClockDuration.raw(), "Max clock duration should match" + ); + assertEq(pdg.splitDepth(), opcmInput.disputeSplitDepth, "Split depth should match"); + assertEq(pdg.maxGameDepth(), opcmInput.disputeMaxGameDepth, "Max game depth should match"); + // Clone-with-immutable-args + assertEq(pdg.gameCreator(), opcmInput.roles.proposer, "Game creator should match"); + assertEq(pdg.rootClaim().raw(), claim.raw(), "Claim should match"); + assertEq(pdg.l1Head().raw(), blockhash(block.number - 1), "L1 head should match"); + assertEq(pdg.l2BlockNumber(), l2BlockNumber, "L2 Block number should match"); + assertEq( + pdg.absolutePrestate().raw(), + opcmInput.disputeAbsolutePrestate.raw(), + "Absolute prestate should match input" + ); + assertEq(address(pdg.vm()), address(impls.mipsImpl), "VM should match MIPS implementation"); + assertEq(address(pdg.anchorStateRegistry()), address(opcmOutput.anchorStateRegistryProxy), "ASR should match"); + assertEq(address(pdg.weth()), address(opcmOutput.delayedWETHPermissionedGameProxy), "WETH should match"); + assertEq(pdg.l2ChainId(), opcmInput.l2ChainId, "L2 chain ID should match"); + // For permissioned game, check proposer and challenger + assertEq(pdg.proposer(), opcmInput.roles.proposer, "Proposer should match"); + assertEq(pdg.challenger(), opcmInput.roles.challenger, "Challenger should match"); + } } /// @title OPContractsManager_Version_Test /// @notice Tests the `version` function of the `OPContractsManager` contract. contract OPContractsManager_Version_Test is OPContractsManager_TestInit { - IOPContractsManager internal prestateUpdater; - OPContractsManager.AddGameInput[] internal gameInput; - - function setUp() public override { - super.setUp(); - prestateUpdater = opcm; - } - function test_semver_works() public view { - assertNotEq(abi.encode(prestateUpdater.version()), abi.encode(0)); + assertNotEq(abi.encode(opcm.version()), abi.encode(0)); } } diff --git a/packages/contracts-bedrock/test/L1/OPContractsManagerStandardValidator.t.sol b/packages/contracts-bedrock/test/L1/OPContractsManagerStandardValidator.t.sol index 8bbbd9e8c2c..c516d46843f 100644 --- a/packages/contracts-bedrock/test/L1/OPContractsManagerStandardValidator.t.sol +++ b/packages/contracts-bedrock/test/L1/OPContractsManagerStandardValidator.t.sol @@ -10,6 +10,7 @@ import { GameTypes, Duration, Claim } from "src/dispute/lib/Types.sol"; import { DeployUtils } from "scripts/libraries/DeployUtils.sol"; import { ForgeArtifacts } from "scripts/libraries/ForgeArtifacts.sol"; import { Features } from "src/libraries/Features.sol"; +import { DevFeatures } from "src/libraries/DevFeatures.sol"; // Interfaces import { IOPContractsManager } from "interfaces/L1/IOPContractsManager.sol"; @@ -102,6 +103,10 @@ contract OPContractsManagerStandardValidator_TestInit is CommonTest { function setUp() public virtual override { super.setUp(); + // Skip V1 StandardValidator tests when V2 dispute games are enabled + // TODO(#17267): Remove skip when V2 dispute game support added to the StandardValidator is implemented + skipIfDevFeatureEnabled(DevFeatures.DEPLOY_V2_DISPUTE_GAMES); + // Grab the deploy input for later use. deployInput = deploy.getDeployInput(); diff --git a/packages/contracts-bedrock/test/dispute/DisputeGameFactory.t.sol b/packages/contracts-bedrock/test/dispute/DisputeGameFactory.t.sol index 58b4e6e624a..403f5b14288 100644 --- a/packages/contracts-bedrock/test/dispute/DisputeGameFactory.t.sol +++ b/packages/contracts-bedrock/test/dispute/DisputeGameFactory.t.sol @@ -11,6 +11,7 @@ import { DeployUtils } from "scripts/libraries/DeployUtils.sol"; // Libraries import "src/dispute/lib/Types.sol"; import "src/dispute/lib/Errors.sol"; +import { DevFeatures } from "src/libraries/DevFeatures.sol"; // Interfaces import { IDisputeGameFactory } from "interfaces/dispute/IDisputeGameFactory.sol"; @@ -82,7 +83,8 @@ contract DisputeGameFactory_TestInit is CommonTest { function _getGameConstructorParams( Claim _absolutePrestate, AlphabetVM _vm, - GameType _gameType + GameType _gameType, + uint256 _l2ChainId ) internal view @@ -98,7 +100,7 @@ contract DisputeGameFactory_TestInit is CommonTest { vm: _vm, weth: delayedWeth, anchorStateRegistry: anchorStateRegistry, - l2ChainId: 0 + l2ChainId: _l2ChainId }); } @@ -125,7 +127,7 @@ contract DisputeGameFactory_TestInit is CommonTest { view returns (ISuperFaultDisputeGame.GameConstructorParams memory params_) { - bytes memory args = abi.encode(_getGameConstructorParams(_absolutePrestate, _vm, _gameType)); + bytes memory args = abi.encode(_getGameConstructorParams(_absolutePrestate, _vm, _gameType, 0)); params_ = abi.decode(args, (ISuperFaultDisputeGame.GameConstructorParams)); } @@ -200,13 +202,26 @@ contract DisputeGameFactory_TestInit is CommonTest { function setupFaultDisputeGame(Claim _absolutePrestate) internal returns (address gameImpl_, AlphabetVM vm_, IPreimageOracle preimageOracle_) + { + if (isDevFeatureEnabled(DevFeatures.DEPLOY_V2_DISPUTE_GAMES)) { + return setupFaultDisputeGameV2(_absolutePrestate); + } else { + return setupFaultDisputeGameV1(_absolutePrestate); + } + } + + /// @notice Sets up a fault game implementation + function setupFaultDisputeGameV1(Claim _absolutePrestate) + internal + returns (address gameImpl_, AlphabetVM vm_, IPreimageOracle preimageOracle_) { (vm_, preimageOracle_) = _createVM(_absolutePrestate); gameImpl_ = DeployUtils.create1({ _name: "FaultDisputeGame", _args: DeployUtils.encodeConstructor( abi.encodeCall( - IFaultDisputeGame.__constructor__, (_getGameConstructorParams(_absolutePrestate, vm_, GameTypes.CANNON)) + IFaultDisputeGame.__constructor__, + (_getGameConstructorParams(_absolutePrestate, vm_, GameTypes.CANNON, l2ChainId)) ) ) }); @@ -258,6 +273,21 @@ contract DisputeGameFactory_TestInit is CommonTest { ) internal returns (address gameImpl_, AlphabetVM vm_, IPreimageOracle preimageOracle_) + { + if (isDevFeatureEnabled(DevFeatures.DEPLOY_V2_DISPUTE_GAMES)) { + return setupPermissionedDisputeGameV2(_absolutePrestate, _proposer, _challenger); + } else { + return setupPermissionedDisputeGameV1(_absolutePrestate, _proposer, _challenger); + } + } + + function setupPermissionedDisputeGameV1( + Claim _absolutePrestate, + address _proposer, + address _challenger + ) + internal + returns (address gameImpl_, AlphabetVM vm_, IPreimageOracle preimageOracle_) { (vm_, preimageOracle_) = _createVM(_absolutePrestate); gameImpl_ = DeployUtils.create1({ @@ -266,7 +296,7 @@ contract DisputeGameFactory_TestInit is CommonTest { abi.encodeCall( IPermissionedDisputeGame.__constructor__, ( - _getGameConstructorParams(_absolutePrestate, vm_, GameTypes.PERMISSIONED_CANNON), + _getGameConstructorParams(_absolutePrestate, vm_, GameTypes.PERMISSIONED_CANNON, l2ChainId), _proposer, _challenger ) @@ -576,7 +606,6 @@ contract DisputeGameFactory_SetImplementation_Test is DisputeGameFactory_TestIni AlphabetVM vm_; IPreimageOracle preimageOracle_; (vm_, preimageOracle_) = _createVM(absolutePrestate); - uint256 l2ChainId = 111; bytes memory args = abi.encodePacked( absolutePrestate, // 32 bytes diff --git a/packages/contracts-bedrock/test/dispute/FaultDisputeGame.t.sol b/packages/contracts-bedrock/test/dispute/FaultDisputeGame.t.sol index 686b4489f5d..a8a4b99e479 100644 --- a/packages/contracts-bedrock/test/dispute/FaultDisputeGame.t.sol +++ b/packages/contracts-bedrock/test/dispute/FaultDisputeGame.t.sol @@ -21,12 +21,14 @@ import { LibClock } from "src/dispute/lib/LibUDT.sol"; import { LibPosition } from "src/dispute/lib/LibPosition.sol"; import "src/dispute/lib/Types.sol"; import "src/dispute/lib/Errors.sol"; +import { DevFeatures } from "src/libraries/DevFeatures.sol"; // Interfaces import { IDisputeGame } from "interfaces/dispute/IDisputeGame.sol"; import { IPreimageOracle } from "interfaces/dispute/IBigStepper.sol"; import { IAnchorStateRegistry } from "interfaces/dispute/IAnchorStateRegistry.sol"; import { IFaultDisputeGame } from "interfaces/dispute/IFaultDisputeGame.sol"; +import { IFaultDisputeGameV2 } from "interfaces/dispute/v2/IFaultDisputeGameV2.sol"; import { IDelayedWETH } from "interfaces/dispute/IDelayedWETH.sol"; contract ClaimCreditReenter { @@ -119,6 +121,8 @@ contract BaseFaultDisputeGame_TestInit is DisputeGameFactory_TestInit { assertEq(address(gameProxy.weth()), address(delayedWeth)); assertEq(address(gameProxy.anchorStateRegistry()), address(anchorStateRegistry)); assertEq(address(gameProxy.vm()), address(_vm)); + assertEq(address(gameProxy.gameCreator()), address(this)); + assertEq(gameProxy.l2ChainId(), l2ChainId); // Label the proxy vm.label(address(gameProxy), "FaultDisputeGame_Clone"); @@ -127,6 +131,14 @@ contract BaseFaultDisputeGame_TestInit is DisputeGameFactory_TestInit { fallback() external payable { } receive() external payable { } + + function copyBytes(bytes memory src, bytes memory dest) internal pure returns (bytes memory) { + uint256 byteCount = src.length < dest.length ? src.length : dest.length; + for (uint256 i = 0; i < byteCount; i++) { + dest[i] = src[i]; + } + return dest; + } } /// @title FaultDisputeGame_TestInit @@ -224,6 +236,11 @@ contract FaultDisputeGame_Version_Test is FaultDisputeGame_TestInit { /// @title FaultDisputeGame_Constructor_Test /// @notice Tests the constructor of the `FaultDisputeGame` contract. contract FaultDisputeGame_Constructor_Test is FaultDisputeGame_TestInit { + function setUp() public virtual override { + super.setUp(); + skipIfDevFeatureEnabled(DevFeatures.DEPLOY_V2_DISPUTE_GAMES); + } + /// @notice Tests that the constructor of the `FaultDisputeGame` reverts when the /// `MAX_GAME_DEPTH` parameter is greater than `LibPosition.MAX_POSITION_BITLEN - 1`. function testFuzz_constructor_maxDepthTooLarge_reverts(uint256 _maxGameDepth) public { @@ -472,6 +489,145 @@ contract FaultDisputeGame_Constructor_Test is FaultDisputeGame_TestInit { } } +/// @title FaultDisputeGame_Constructor_Test +/// @notice Tests the constructor of the `FaultDisputeGame` contract. +contract FaultDisputeGameV2_Constructor_Test is FaultDisputeGame_TestInit { + function setUp() public virtual override { + super.setUp(); + skipIfDevFeatureDisabled(DevFeatures.DEPLOY_V2_DISPUTE_GAMES); + } + + /// @notice Tests that the constructor of the `FaultDisputeGame` reverts when the + /// `MAX_GAME_DEPTH` parameter is greater than `LibPosition.MAX_POSITION_BITLEN - 1`. + function testFuzz_constructor_maxDepthTooLarge_reverts(uint256 _maxGameDepth) public { + _maxGameDepth = bound(_maxGameDepth, LibPosition.MAX_POSITION_BITLEN, type(uint256).max - 1); + vm.expectRevert(MaxDepthTooLarge.selector); + DeployUtils.create1({ + _name: "FaultDisputeGameV2", + _args: DeployUtils.encodeConstructor( + abi.encodeCall( + IFaultDisputeGameV2.__constructor__, + ( + IFaultDisputeGameV2.GameConstructorParams({ + gameType: GAME_TYPE, + maxGameDepth: _maxGameDepth, + splitDepth: _maxGameDepth + 1, + clockExtension: Duration.wrap(3 hours), + maxClockDuration: Duration.wrap(3.5 days) + }) + ) + ) + ) + }); + } + + /// @notice Tests that the constructor of the `FaultDisputeGame` reverts when the `_splitDepth` + /// parameter is greater than or equal to the `MAX_GAME_DEPTH` + function testFuzz_constructor_invalidSplitDepth_reverts(uint256 _splitDepth) public { + uint256 maxGameDepth = 2 ** 3; + _splitDepth = bound(_splitDepth, maxGameDepth - 1, type(uint256).max); + vm.expectRevert(InvalidSplitDepth.selector); + DeployUtils.create1({ + _name: "FaultDisputeGameV2", + _args: DeployUtils.encodeConstructor( + abi.encodeCall( + IFaultDisputeGameV2.__constructor__, + ( + IFaultDisputeGameV2.GameConstructorParams({ + gameType: GAME_TYPE, + maxGameDepth: maxGameDepth, + splitDepth: _splitDepth, + clockExtension: Duration.wrap(3 hours), + maxClockDuration: Duration.wrap(3.5 days) + }) + ) + ) + ) + }); + } + + /// @notice Tests that the constructor of the `FaultDisputeGame` reverts when the `_splitDepth` + /// parameter is less than the minimum split depth (currently 2). + function testFuzz_constructor_lowSplitDepth_reverts(uint256 _splitDepth) public { + uint256 minSplitDepth = 2; + _splitDepth = bound(_splitDepth, 0, minSplitDepth - 1); + vm.expectRevert(InvalidSplitDepth.selector); + DeployUtils.create1({ + _name: "FaultDisputeGameV2", + _args: DeployUtils.encodeConstructor( + abi.encodeCall( + IFaultDisputeGameV2.__constructor__, + ( + IFaultDisputeGameV2.GameConstructorParams({ + gameType: GAME_TYPE, + maxGameDepth: 2 ** 3, + splitDepth: _splitDepth, + clockExtension: Duration.wrap(3 hours), + maxClockDuration: Duration.wrap(3.5 days) + }) + ) + ) + ) + }); + } + + /// @notice Tests that the constructor of the `FaultDisputeGame` reverts when clock + /// extension * 2 is greater than the max clock duration. + function testFuzz_constructor_clockExtensionTooLong_reverts( + uint64 _maxClockDuration, + uint64 _clockExtension + ) + public + { + // Force the clock extension * 2 to be greater than the max clock duration, but keep things + // within bounds of the uint64 type. + _maxClockDuration = uint64(bound(_maxClockDuration, 0, type(uint64).max / 2 - 1)); + _clockExtension = uint64(bound(_clockExtension, _maxClockDuration / 2 + 1, type(uint64).max / 2)); + + vm.expectRevert(InvalidClockExtension.selector); + DeployUtils.create1({ + _name: "FaultDisputeGameV2", + _args: DeployUtils.encodeConstructor( + abi.encodeCall( + IFaultDisputeGameV2.__constructor__, + ( + IFaultDisputeGameV2.GameConstructorParams({ + gameType: GAME_TYPE, + maxGameDepth: 16, + splitDepth: 8, + clockExtension: Duration.wrap(_clockExtension), + maxClockDuration: Duration.wrap(_maxClockDuration) + }) + ) + ) + ) + }); + } + + /// @notice Tests that the constructor of the `FaultDisputeGame` reverts when the `_gameType` + /// parameter is set to the reserved `type(uint32).max` game type. + function test_constructor_reservedGameType_reverts() public { + vm.expectRevert(ReservedGameType.selector); + DeployUtils.create1({ + _name: "FaultDisputeGameV2", + _args: DeployUtils.encodeConstructor( + abi.encodeCall( + IFaultDisputeGameV2.__constructor__, + ( + IFaultDisputeGameV2.GameConstructorParams({ + gameType: GameType.wrap(type(uint32).max), + maxGameDepth: 16, + splitDepth: 8, + clockExtension: Duration.wrap(3 hours), + maxClockDuration: Duration.wrap(3.5 days) + }) + ) + ) + ) + }); + } +} + /// @title FaultDisputeGame_Initialize_Test /// @notice Tests the initialization of the `FaultDisputeGame` contract. contract FaultDisputeGame_Initialize_Test is FaultDisputeGame_TestInit { @@ -507,9 +663,9 @@ contract FaultDisputeGame_Initialize_Test is FaultDisputeGame_TestInit { assertEq(delayedWeth.balanceOf(address(gameProxy)), _value); } - /// @notice Tests that the game cannot be initialized with extra data of the incorrect length - /// (must be 32 bytes) - function testFuzz_initialize_badExtraData_reverts(uint256 _extraDataLen) public { + /// @notice Tests that the game cannot be initialized with incorrect CWIA calldata length + /// caused by extraData of the wrong length + function test_initialize_wrongExtradataLength_reverts(uint256 _extraDataLen) public { // The `DisputeGameFactory` will pack the root claim and the extra data into a single // array, which is enforced to be at least 64 bytes long. // We bound the upper end to 23.5KB to ensure that the minimal proxy never surpasses the @@ -536,6 +692,55 @@ contract FaultDisputeGame_Initialize_Test is FaultDisputeGame_TestInit { ); } + /// @notice Tests that the game cannot be initialized with incorrect CWIA calldata length + /// caused by additional immutable args data + function test_initialize_extraImmutableArgsBytes_reverts(uint256 _extraByteCount) public { + skipIfDevFeatureDisabled(DevFeatures.DEPLOY_V2_DISPUTE_GAMES); + (bytes memory correctArgs,,) = getFaultDisputeGameV2ImmutableArgs(absolutePrestate); + + // We bound the upper end to 23.5KB to ensure that the minimal proxy never surpasses the + // contract size limit in this test, as CWIA proxies store the immutable args in their + // bytecode. + _extraByteCount = bound(_extraByteCount, 1, 23_500); + bytes memory immutableArgs = new bytes(_extraByteCount + correctArgs.length); + // Copy correct args into immutable args + copyBytes(correctArgs, immutableArgs); + + // Set up dispute game implementation with target immutableArgs + setupFaultDisputeGameV2(immutableArgs); + + Claim claim = _dummyClaim(); + vm.expectRevert(IFaultDisputeGame.BadExtraData.selector); + gameProxy = IFaultDisputeGame( + payable( + address(disputeGameFactory.create{ value: initBond }(GAME_TYPE, claim, abi.encode(validL2BlockNumber))) + ) + ); + } + + /// @notice Tests that the game cannot be initialized with incorrect CWIA calldata length + /// caused by missing immutable args data + function test_initialize_missingImmutableArgsBytes_reverts(uint256 _truncatedByteCount) public { + skipIfDevFeatureDisabled(DevFeatures.DEPLOY_V2_DISPUTE_GAMES); + (bytes memory correctArgs,,) = getFaultDisputeGameV2ImmutableArgs(absolutePrestate); + + _truncatedByteCount = (_truncatedByteCount % correctArgs.length) + 1; + bytes memory immutableArgs = new bytes(correctArgs.length - _truncatedByteCount); + // Copy correct args into immutable args + copyBytes(correctArgs, immutableArgs); + + // Set up dispute game implementation with target immutableArgs + setupFaultDisputeGameV2(immutableArgs); + + Claim claim = _dummyClaim(); + vm.expectRevert(IFaultDisputeGame.BadExtraData.selector); + gameProxy = IFaultDisputeGame( + payable( + address(disputeGameFactory.create{ value: initBond }(GAME_TYPE, claim, abi.encode(validL2BlockNumber))) + ) + ); + } + /// @notice Tests that the game is initialized with the correct data. function test_initialize_correctData_succeeds() public view { // Assert that the root claim is initialized correctly. @@ -575,7 +780,9 @@ contract FaultDisputeGame_Initialize_Test is FaultDisputeGame_TestInit { // Creation should fail. vm.expectRevert(AnchorRootNotFound.selector); gameProxy = IFaultDisputeGame( - payable(address(disputeGameFactory.create{ value: initBond }(GAME_TYPE, _dummyClaim(), hex""))) + payable( + address(disputeGameFactory.create{ value: initBond }(GAME_TYPE, _dummyClaim(), new bytes(uint256(32)))) + ) ); } @@ -584,6 +791,35 @@ contract FaultDisputeGame_Initialize_Test is FaultDisputeGame_TestInit { vm.expectRevert(AlreadyInitialized.selector); gameProxy.initialize(); } + + /// @notice Tests that initialization reverts when oracle challenge period is too large. + /// @dev V2 validates oracle challenge period during initialize(), not constructor + function testFuzz_initialize_oracleChallengePeriodTooLarge_reverts(uint256 _challengePeriod) public { + // Bound to values larger than uint64.max + _challengePeriod = bound(_challengePeriod, uint256(type(uint64).max) + 1, type(uint256).max); + + // Get the current AlphabetVM from the setup + (, AlphabetVM vm_,) = setupFaultDisputeGameV2(absolutePrestate); + + // Mock the VM's oracle to return invalid challenge period + vm.mockCall( + address(vm_.oracle()), abi.encodeCall(IPreimageOracle.challengePeriod, ()), abi.encode(_challengePeriod) + ); + + // Expect the initialize call to revert with InvalidChallengePeriod + vm.expectRevert(InvalidChallengePeriod.selector); + + // Create game via factory - initialize() is called automatically and should revert + gameProxy = IFaultDisputeGame( + payable( + address( + disputeGameFactory.create{ value: initBond }( + GAME_TYPE, _dummyClaim(), abi.encode(validL2BlockNumber) + ) + ) + ) + ); + } } /// @title FaultDisputeGame_Step_Test @@ -666,7 +902,7 @@ contract FaultDisputeGame_Step_Test is FaultDisputeGame_TestInit { gameProxy.attack{ value: _getRequiredBond(4) }(disputed, 4, _changeClaimStatus(_dummyClaim(), VMStatuses.PANIC)); bytes memory claimData7 = abi.encode(7, 7); - Claim postState_ = Claim.wrap(gameImpl.vm().step(claimData7, hex"", bytes32(0))); + Claim postState_ = Claim.wrap(gameProxy.vm().step(claimData7, hex"", bytes32(0))); (,,,, disputed,,) = gameProxy.claimData(5); gameProxy.attack{ value: _getRequiredBond(5) }(disputed, 5, _dummyClaim()); @@ -702,7 +938,7 @@ contract FaultDisputeGame_Step_Test is FaultDisputeGame_TestInit { gameProxy.attack{ value: _getRequiredBond(5) }(disputed, 5, claim5); (,,,, disputed,,) = gameProxy.claimData(6); gameProxy.defend{ value: _getRequiredBond(6) }(disputed, 6, _dummyClaim()); - Claim postState_ = Claim.wrap(gameImpl.vm().step(claimData5, hex"", bytes32(0))); + Claim postState_ = Claim.wrap(gameProxy.vm().step(claimData5, hex"", bytes32(0))); (,,,, disputed,,) = gameProxy.claimData(7); gameProxy.attack{ value: _getRequiredBond(7) }(disputed, 7, postState_); gameProxy.addLocalData(LocalPreimageKey.DISPUTED_L2_BLOCK_NUMBER, 8, 0); @@ -730,7 +966,7 @@ contract FaultDisputeGame_Step_Test is FaultDisputeGame_TestInit { gameProxy.attack{ value: _getRequiredBond(4) }(disputed, 4, _changeClaimStatus(_dummyClaim(), VMStatuses.PANIC)); bytes memory claimData7 = abi.encode(5, 5); - Claim postState_ = Claim.wrap(gameImpl.vm().step(claimData7, hex"", bytes32(0))); + Claim postState_ = Claim.wrap(gameProxy.vm().step(claimData7, hex"", bytes32(0))); (,,,, disputed,,) = gameProxy.claimData(5); gameProxy.attack{ value: _getRequiredBond(5) }(disputed, 5, postState_); @@ -766,7 +1002,7 @@ contract FaultDisputeGame_Step_Test is FaultDisputeGame_TestInit { bytes memory claimData7 = abi.encode(5, 5); Claim claim7 = Claim.wrap(keccak256(claimData7)); - Claim postState_ = Claim.wrap(gameImpl.vm().step(claimData7, hex"", bytes32(0))); + Claim postState_ = Claim.wrap(gameProxy.vm().step(claimData7, hex"", bytes32(0))); (,,,, disputed,,) = gameProxy.claimData(5); gameProxy.attack{ value: _getRequiredBond(5) }(disputed, 5, postState_); diff --git a/packages/contracts-bedrock/test/dispute/PermissionedDisputeGame.t.sol b/packages/contracts-bedrock/test/dispute/PermissionedDisputeGame.t.sol index 30c0e547a29..4fcf6f5b99b 100644 --- a/packages/contracts-bedrock/test/dispute/PermissionedDisputeGame.t.sol +++ b/packages/contracts-bedrock/test/dispute/PermissionedDisputeGame.t.sol @@ -4,11 +4,14 @@ pragma solidity ^0.8.15; // Testing import { DisputeGameFactory_TestInit } from "test/dispute/DisputeGameFactory.t.sol"; import { AlphabetVM } from "test/mocks/AlphabetVM.sol"; + // Libraries import "src/dispute/lib/Types.sol"; import "src/dispute/lib/Errors.sol"; +import { DevFeatures } from "src/libraries/DevFeatures.sol"; // Interfaces +import { IFaultDisputeGame } from "interfaces/dispute/IFaultDisputeGame.sol"; import { IPermissionedDisputeGame } from "interfaces/dispute/IPermissionedDisputeGame.sol"; /// @title PermissionedDisputeGame_TestInit @@ -21,6 +24,9 @@ contract PermissionedDisputeGame_TestInit is DisputeGameFactory_TestInit { /// @notice Mock challenger key address internal constant CHALLENGER = address(0xfacadec); + /// @dev The initial bond for the game. + uint256 internal initBond; + /// @notice The implementation of the game. IPermissionedDisputeGame internal gameImpl; /// @notice The `Clone` proxy of the game. @@ -60,11 +66,8 @@ contract PermissionedDisputeGame_TestInit is DisputeGameFactory_TestInit { (address _impl, AlphabetVM _vm,) = setupPermissionedDisputeGame(_absolutePrestate, PROPOSER, CHALLENGER); gameImpl = IPermissionedDisputeGame(_impl); - // Register the game implementation with the factory. - disputeGameFactory.setImplementation(GAME_TYPE, gameImpl); - // Create a new game. - uint256 bondAmount = disputeGameFactory.initBonds(GAME_TYPE); + initBond = disputeGameFactory.initBonds(GAME_TYPE); vm.mockCall( address(anchorStateRegistry), abi.encodeCall(anchorStateRegistry.anchors, (GAME_TYPE)), @@ -72,7 +75,7 @@ contract PermissionedDisputeGame_TestInit is DisputeGameFactory_TestInit { ); vm.prank(PROPOSER, PROPOSER); gameProxy = IPermissionedDisputeGame( - payable(address(disputeGameFactory.create{ value: bondAmount }(GAME_TYPE, _rootClaim, extraData))) + payable(address(disputeGameFactory.create{ value: initBond }(GAME_TYPE, _rootClaim, extraData))) ); // Check immutables @@ -82,8 +85,13 @@ contract PermissionedDisputeGame_TestInit is DisputeGameFactory_TestInit { assertEq(gameProxy.absolutePrestate().raw(), _absolutePrestate.raw()); assertEq(gameProxy.maxGameDepth(), 2 ** 3); assertEq(gameProxy.splitDepth(), 2 ** 2); + assertEq(gameProxy.clockExtension().raw(), 3 hours); assertEq(gameProxy.maxClockDuration().raw(), 3.5 days); + assertEq(address(gameProxy.weth()), address(delayedWeth)); + assertEq(address(gameProxy.anchorStateRegistry()), address(anchorStateRegistry)); assertEq(address(gameProxy.vm()), address(_vm)); + assertEq(address(gameProxy.gameCreator()), PROPOSER); + assertEq(gameProxy.l2ChainId(), l2ChainId); // Label the proxy vm.label(address(gameProxy), "PermissionedDisputeGame_Clone"); @@ -124,6 +132,14 @@ contract PermissionedDisputeGame_TestInit is DisputeGameFactory_TestInit { fallback() external payable { } receive() external payable { } + + function copyBytes(bytes memory src, bytes memory dest) internal pure returns (bytes memory) { + uint256 byteCount = src.length < dest.length ? src.length : dest.length; + for (uint256 i = 0; i < byteCount; i++) { + dest[i] = src[i]; + } + return dest; + } } /// @title PermissionedDisputeGame_Version_Test @@ -138,13 +154,59 @@ contract PermissionedDisputeGame_Version_Test is PermissionedDisputeGame_TestIni /// @title PermissionedDisputeGame_Step_Test /// @notice Tests the `step` function of the `PermissionedDisputeGame` contract. contract PermissionedDisputeGame_Step_Test is PermissionedDisputeGame_TestInit { - /// @notice Tests that step works properly. - function test_step_succeeds() public { - // Give the test contract some ether + /// @notice Tests that step works properly for the challenger. + function test_step_fromChallenger_succeeds() public { + validateStepForActor(CHALLENGER); + } + + /// @notice Tests that step works properly for the proposer. + function test_step_fromProposer_succeeds() public { + validateStepForActor(PROPOSER); + } + + function validateStepForActor(address actor) internal { + vm.deal(actor, 1_000 ether); + vm.startPrank(actor, actor); + + // Set up and perform the step + setupGameForStep(); + performStep(); + assertEq(gameProxy.claimDataLen(), 9); + + // Resolve the game and check that the expected actor countered the root claim + resolveGame(); + assertEq(uint256(gameProxy.status()), uint256(GameStatus.CHALLENGER_WINS)); + assertEq(gameProxy.resolvedAt().raw(), block.timestamp); + (, address counteredBy,,,,,) = gameProxy.claimData(0); + assertEq(counteredBy, actor); + + vm.stopPrank(); + } + + /// @notice Tests that step reverts for unauthorized addresses. + function test_step_notAuthorized_reverts(address _unauthorized) internal { + vm.assume(_unauthorized != PROPOSER && _unauthorized != CHALLENGER); + vm.deal(_unauthorized, 1_000 ether); vm.deal(CHALLENGER, 1_000 ether); + // Set up for the step using an authorized actor vm.startPrank(CHALLENGER, CHALLENGER); + setupGameForStep(); + vm.stopPrank(); + + // Perform step with the unauthorized actor + vm.startPrank(_unauthorized, _unauthorized); + vm.expectRevert(BadAuth.selector); + performStep(); + + // Game should still be in progress, leaf claim should be missing + assertEq(uint256(gameProxy.status()), uint256(GameStatus.CHALLENGER_WINS)); + assertEq(gameProxy.claimDataLen(), 8); + vm.stopPrank(); + } + + function setupGameForStep() internal { // Make claims all the way down the tree. (,,,, Claim disputed,,) = gameProxy.claimData(0); gameProxy.attack{ value: _getRequiredBond(0) }(disputed, 0, _dummyClaim()); @@ -163,12 +225,16 @@ contract PermissionedDisputeGame_Step_Test is PermissionedDisputeGame_TestInit { (,,,, disputed,,) = gameProxy.claimData(7); gameProxy.attack{ value: _getRequiredBond(7) }(disputed, 7, _dummyClaim()); - // Verify game state before step + // Verify game state and add local data assertEq(uint256(gameProxy.status()), uint256(GameStatus.IN_PROGRESS)); - gameProxy.addLocalData(LocalPreimageKey.DISPUTED_L2_BLOCK_NUMBER, 8, 0); + } + + function performStep() internal { gameProxy.step(8, true, absolutePrestateData, hex""); + } + function resolveGame() internal { vm.warp(block.timestamp + gameProxy.maxClockDuration().raw() + 1); gameProxy.resolveClaim(8, 0); gameProxy.resolveClaim(7, 0); @@ -181,11 +247,91 @@ contract PermissionedDisputeGame_Step_Test is PermissionedDisputeGame_TestInit { gameProxy.resolveClaim(0, 0); gameProxy.resolve(); + } +} - assertEq(uint256(gameProxy.status()), uint256(GameStatus.CHALLENGER_WINS)); - assertEq(gameProxy.resolvedAt().raw(), block.timestamp); - (, address counteredBy,,,,,) = gameProxy.claimData(0); - assertEq(counteredBy, CHALLENGER); +/// @title PermissionedDisputeGame_Initialize_Test +/// @notice Tests the initialization of the `PermissionedDisputeGame` contract. +contract PermissionedDisputeGame_Initialize_Test is PermissionedDisputeGame_TestInit { + /// @notice Tests that the game cannot be initialized with incorrect CWIA calldata length + /// caused by extraData of the wrong length + function test_initialize_wrongExtradataLength_reverts(uint256 _extraDataLen) public { + // The `DisputeGameFactory` will pack the root claim and the extra data into a single + // array, which is enforced to be at least 64 bytes long. + // We bound the upper end to 23.5KB to ensure that the minimal proxy never surpasses the + // contract size limit in this test, as CWIA proxies store the immutable args in their + // bytecode. + // [0 bytes, 31 bytes] u [33 bytes, 23.5 KB] + _extraDataLen = bound(_extraDataLen, 0, 23_500); + if (_extraDataLen == 32) { + _extraDataLen++; + } + bytes memory _extraData = new bytes(_extraDataLen); + + // Assign the first 32 bytes in `extraData` to a valid L2 block number passed the starting + // block. + (, uint256 startingL2Block) = gameProxy.startingOutputRoot(); + assembly { + mstore(add(_extraData, 0x20), add(startingL2Block, 1)) + } + + Claim claim = _dummyClaim(); + vm.prank(PROPOSER, PROPOSER); + vm.expectRevert(IFaultDisputeGame.BadExtraData.selector); + gameProxy = IPermissionedDisputeGame( + payable(address(disputeGameFactory.create{ value: initBond }(GAME_TYPE, claim, _extraData))) + ); + } + + /// @notice Tests that the game cannot be initialized with incorrect CWIA calldata length + /// caused by additional immutable args data + function test_initialize_extraImmutableArgsBytes_reverts(uint256 _extraByteCount) public { + skipIfDevFeatureDisabled(DevFeatures.DEPLOY_V2_DISPUTE_GAMES); + (bytes memory correctArgs,,) = getPermissionedDisputeGameV2ImmutableArgs(absolutePrestate, PROPOSER, CHALLENGER); + + // We bound the upper end to 23.5KB to ensure that the minimal proxy never surpasses the + // contract size limit in this test, as CWIA proxies store the immutable args in their + // bytecode. + _extraByteCount = bound(_extraByteCount, 1, 23_500); + bytes memory immutableArgs = new bytes(_extraByteCount + correctArgs.length); + // Copy correct args into immutable args + copyBytes(correctArgs, immutableArgs); + + // Set up dispute game implementation with target immutableArgs + setupPermissionedDisputeGameV2(immutableArgs); + + Claim claim = _dummyClaim(); + vm.prank(PROPOSER, PROPOSER); + vm.expectRevert(IFaultDisputeGame.BadExtraData.selector); + gameProxy = IPermissionedDisputeGame( + payable( + address(disputeGameFactory.create{ value: initBond }(GAME_TYPE, claim, abi.encode(validL2BlockNumber))) + ) + ); + } + + /// @notice Tests that the game cannot be initialized with incorrect CWIA calldata length + /// caused by missing immutable args data + function test_initialize_missingImmutableArgsBytes_reverts(uint256 _truncatedByteCount) public { + skipIfDevFeatureDisabled(DevFeatures.DEPLOY_V2_DISPUTE_GAMES); + (bytes memory correctArgs,,) = getPermissionedDisputeGameV2ImmutableArgs(absolutePrestate, PROPOSER, CHALLENGER); + + _truncatedByteCount = (_truncatedByteCount % correctArgs.length) + 1; + bytes memory immutableArgs = new bytes(correctArgs.length - _truncatedByteCount); + // Copy correct args into immutable args + copyBytes(correctArgs, immutableArgs); + + // Set up dispute game implementation with target immutableArgs + setupPermissionedDisputeGameV2(immutableArgs); + + Claim claim = _dummyClaim(); + vm.prank(PROPOSER, PROPOSER); + vm.expectRevert(IFaultDisputeGame.BadExtraData.selector); + gameProxy = IPermissionedDisputeGame( + payable( + address(disputeGameFactory.create{ value: initBond }(GAME_TYPE, claim, abi.encode(validL2BlockNumber))) + ) + ); } } @@ -195,9 +341,16 @@ contract PermissionedDisputeGame_Step_Test is PermissionedDisputeGame_TestInit { contract PermissionedDisputeGame_Uncategorized_Test is PermissionedDisputeGame_TestInit { /// @notice Tests that the proposer can create a permissioned dispute game. function test_createGame_proposer_succeeds() public { - uint256 bondAmount = disputeGameFactory.initBonds(GAME_TYPE); vm.prank(PROPOSER, PROPOSER); - disputeGameFactory.create{ value: bondAmount }(GAME_TYPE, arbitaryRootClaim, abi.encode(validL2BlockNumber)); + disputeGameFactory.create{ value: initBond }(GAME_TYPE, arbitaryRootClaim, abi.encode(validL2BlockNumber)); + } + + /// @notice Tests that the permissioned game cannot be created by the challenger. + function test_createGame_challenger_reverts() public { + vm.deal(CHALLENGER, initBond); + vm.prank(CHALLENGER, CHALLENGER); + vm.expectRevert(BadAuth.selector); + disputeGameFactory.create{ value: initBond }(GAME_TYPE, arbitaryRootClaim, abi.encode(validL2BlockNumber)); } /// @notice Tests that the permissioned game cannot be created by any address other than the @@ -205,11 +358,10 @@ contract PermissionedDisputeGame_Uncategorized_Test is PermissionedDisputeGame_T function testFuzz_createGame_notProposer_reverts(address _p) public { vm.assume(_p != PROPOSER); - uint256 bondAmount = disputeGameFactory.initBonds(GAME_TYPE); - vm.deal(_p, bondAmount); + vm.deal(_p, initBond); vm.prank(_p, _p); vm.expectRevert(BadAuth.selector); - disputeGameFactory.create{ value: bondAmount }(GAME_TYPE, arbitaryRootClaim, abi.encode(validL2BlockNumber)); + disputeGameFactory.create{ value: initBond }(GAME_TYPE, arbitaryRootClaim, abi.encode(validL2BlockNumber)); } /// @notice Tests that the challenger can participate in a permissioned dispute game. diff --git a/packages/contracts-bedrock/test/dispute/v2/FaultDisputeGameV2.t.sol b/packages/contracts-bedrock/test/dispute/v2/FaultDisputeGameV2.t.sol deleted file mode 100644 index feab8445631..00000000000 --- a/packages/contracts-bedrock/test/dispute/v2/FaultDisputeGameV2.t.sol +++ /dev/null @@ -1,3207 +0,0 @@ -// SPDX-License-Identifier: MIT -pragma solidity ^0.8.15; - -// Testing -import { Vm } from "forge-std/Vm.sol"; -import { DisputeGameFactory_TestInit } from "test/dispute/DisputeGameFactory.t.sol"; -import { AlphabetVM } from "test/mocks/AlphabetVM.sol"; -import { stdError } from "forge-std/StdError.sol"; - -// Scripts -import { DeployUtils } from "scripts/libraries/DeployUtils.sol"; - -// Contracts -import { DisputeActor, HonestDisputeActor } from "test/actors/FaultDisputeActors.sol"; - -// Libraries -import { Types } from "src/libraries/Types.sol"; -import { Hashing } from "src/libraries/Hashing.sol"; -import { RLPWriter } from "src/libraries/rlp/RLPWriter.sol"; -import { LibClock } from "src/dispute/lib/LibUDT.sol"; -import { LibPosition } from "src/dispute/lib/LibPosition.sol"; -import "src/dispute/lib/Types.sol"; -import "src/dispute/lib/Errors.sol"; - -// Interfaces -import { IDisputeGame } from "interfaces/dispute/IDisputeGame.sol"; -import { IPreimageOracle } from "interfaces/dispute/IBigStepper.sol"; -import { IAnchorStateRegistry } from "interfaces/dispute/IAnchorStateRegistry.sol"; -import { IFaultDisputeGame } from "interfaces/dispute/IFaultDisputeGame.sol"; -import { IFaultDisputeGameV2 } from "interfaces/dispute/v2/IFaultDisputeGameV2.sol"; - -contract ClaimCreditReenter { - Vm internal immutable vm; - IFaultDisputeGameV2 internal immutable GAME; - uint256 public numCalls; - - constructor(IFaultDisputeGameV2 _gameProxy, Vm _vm) { - GAME = _gameProxy; - vm = _vm; - } - - function claimCredit(address _recipient) public { - numCalls += 1; - if (numCalls > 1) { - vm.expectRevert(NoCreditToClaim.selector); - } - GAME.claimCredit(_recipient); - } - - receive() external payable { - if (numCalls == 5) { - return; - } - claimCredit(address(this)); - } -} - -/// @notice Helper to change the VM status byte of a claim. -function _changeClaimStatus(Claim _claim, VMStatus _status) pure returns (Claim out_) { - assembly { - out_ := or(and(not(shl(248, 0xFF)), _claim), shl(248, _status)) - } -} - -/// @title BaseFaultDisputeGameV2_TestInit -/// @notice Base test initializer that can be used by other contracts outside of this test suite. -contract BaseFaultDisputeGameV2_TestInit is DisputeGameFactory_TestInit { - /// @dev The type of the game being tested. - GameType internal immutable GAME_TYPE = GameTypes.CANNON; - - /// @dev The initial bond for the game. - uint256 internal initBond; - - /// @dev The implementation of the game. - IFaultDisputeGameV2 internal gameImpl; - /// @dev The `Clone` proxy of the game. - IFaultDisputeGameV2 internal gameProxy; - - /// @dev The extra data passed to the game for initialization. - bytes internal extraData; - - event Move(uint256 indexed parentIndex, Claim indexed pivot, address indexed claimant); - event GameClosed(BondDistributionMode bondDistributionMode); - - event ReceiveETH(uint256 amount); - - function init(Claim rootClaim, Claim absolutePrestate, uint256 l2BlockNumber) public { - // Set the time to a realistic date. - if (!isForkTest()) { - vm.warp(1690906994); - } - - // Set the extra data for the game creation - extraData = abi.encode(l2BlockNumber); - - (address _impl, AlphabetVM _vm,) = setupFaultDisputeGameV2(absolutePrestate); - gameImpl = IFaultDisputeGameV2(_impl); - - // Set the init bond for the given game type. - initBond = disputeGameFactory.initBonds(GAME_TYPE); - - // Warp ahead of the game retirement timestamp if needed. - if (block.timestamp <= anchorStateRegistry.retirementTimestamp()) { - vm.warp(anchorStateRegistry.retirementTimestamp() + 1); - } - - // Create a new game. - gameProxy = IFaultDisputeGameV2( - payable(address(disputeGameFactory.create{ value: initBond }(GAME_TYPE, rootClaim, extraData))) - ); - - // Check immutables - assertEq(gameProxy.gameType().raw(), GAME_TYPE.raw()); - assertEq(gameProxy.absolutePrestate().raw(), absolutePrestate.raw()); - assertEq(gameProxy.maxGameDepth(), 2 ** 3); - assertEq(gameProxy.splitDepth(), 2 ** 2); - assertEq(gameProxy.clockExtension().raw(), 3 hours); - assertEq(gameProxy.maxClockDuration().raw(), 3.5 days); - assertEq(address(gameProxy.weth()), address(delayedWeth)); - assertEq(address(gameProxy.anchorStateRegistry()), address(anchorStateRegistry)); - assertEq(address(gameProxy.vm()), address(_vm)); - assertEq(address(gameProxy.gameCreator()), address(this)); - assertEq(gameProxy.l2ChainId(), l2ChainId); - - // Label the proxy - vm.label(address(gameProxy), "FaultDisputeGame_Clone"); - } - - fallback() external payable { } - - receive() external payable { } - - function copyBytes(bytes memory src, bytes memory dest) internal pure returns (bytes memory) { - uint256 byteCount = src.length < dest.length ? src.length : dest.length; - for (uint256 i = 0; i < byteCount; i++) { - dest[i] = src[i]; - } - return dest; - } -} - -/// @title FaultDisputeGameV2_TestInit -/// @notice Reusable test initialization for `FaultDisputeGame` tests. -contract FaultDisputeGameV2_TestInit is BaseFaultDisputeGameV2_TestInit { - /// @dev The root claim of the game. - Claim internal ROOT_CLAIM; - /// @dev An arbitrary root claim for testing. - Claim internal arbitaryRootClaim = Claim.wrap(bytes32(uint256(123))); - - /// @dev The preimage of the absolute prestate claim - bytes internal absolutePrestateData; - /// @dev The absolute prestate of the trace. - Claim internal absolutePrestate; - /// @dev A valid l2BlockNumber that comes after the current anchor root block. - uint256 internal validL2BlockNumber; - - function setUp() public virtual override { - absolutePrestateData = abi.encode(0); - absolutePrestate = _changeClaimStatus(Claim.wrap(keccak256(absolutePrestateData)), VMStatuses.UNFINISHED); - - super.setUp(); - - // Get the actual anchor roots - (Hash root, uint256 l2Bn) = anchorStateRegistry.getAnchorRoot(); - validL2BlockNumber = l2Bn + 1; - - ROOT_CLAIM = Claim.wrap(Hash.unwrap(root)); - - super.init({ rootClaim: ROOT_CLAIM, absolutePrestate: absolutePrestate, l2BlockNumber: validL2BlockNumber }); - } - - /// @notice Helper to generate a mock RLP encoded header (with only a real block number) & an - /// output root proof. - function _generateOutputRootProof( - bytes32 _storageRoot, - bytes32 _withdrawalRoot, - bytes memory _l2BlockNumber - ) - internal - pure - returns (Types.OutputRootProof memory proof_, bytes32 root_, bytes memory rlp_) - { - // L2 Block header - bytes[] memory rawHeaderRLP = new bytes[](9); - rawHeaderRLP[0] = hex"83FACADE"; - rawHeaderRLP[1] = hex"83FACADE"; - rawHeaderRLP[2] = hex"83FACADE"; - rawHeaderRLP[3] = hex"83FACADE"; - rawHeaderRLP[4] = hex"83FACADE"; - rawHeaderRLP[5] = hex"83FACADE"; - rawHeaderRLP[6] = hex"83FACADE"; - rawHeaderRLP[7] = hex"83FACADE"; - rawHeaderRLP[8] = RLPWriter.writeBytes(_l2BlockNumber); - rlp_ = RLPWriter.writeList(rawHeaderRLP); - - // Output root - proof_ = Types.OutputRootProof({ - version: 0, - stateRoot: _storageRoot, - messagePasserStorageRoot: _withdrawalRoot, - latestBlockhash: keccak256(rlp_) - }); - root_ = Hashing.hashOutputRootProof(proof_); - } - - /// @notice Helper to get the required bond for the given claim index. - function _getRequiredBond(uint256 _claimIndex) internal view returns (uint256 bond_) { - (,,,,, Position parent,) = gameProxy.claimData(_claimIndex); - Position pos = parent.move(true); - bond_ = gameProxy.getRequiredBond(pos); - } - - /// @notice Helper to return a pseudo-random claim - function _dummyClaim() internal view returns (Claim) { - return Claim.wrap(keccak256(abi.encode(gasleft()))); - } - - /// @notice Helper to get the localized key for an identifier in the context of the game proxy. - function _getKey(uint256 _ident, bytes32 _localContext) internal view returns (bytes32) { - bytes32 h = keccak256(abi.encode(_ident | (1 << 248), address(gameProxy), _localContext)); - return bytes32((uint256(h) & ~uint256(0xFF << 248)) | (1 << 248)); - } -} - -/// @title FaultDisputeGame_Version_Test -/// @notice Tests the `version` function of the `FaultDisputeGame` contract. -contract FaultDisputeGameV2_Version_Test is FaultDisputeGameV2_TestInit { - /// @notice Tests that the game's version function returns a string. - function test_version_works() public view { - assertTrue(bytes(gameProxy.version()).length > 0); - } -} - -/// @title FaultDisputeGame_Constructor_Test -/// @notice Tests the constructor of the `FaultDisputeGame` contract. -contract FaultDisputeGameV2_Constructor_Test is FaultDisputeGameV2_TestInit { - /// @notice Tests that the constructor of the `FaultDisputeGame` reverts when the - /// `MAX_GAME_DEPTH` parameter is greater than `LibPosition.MAX_POSITION_BITLEN - 1`. - function testFuzz_constructor_maxDepthTooLarge_reverts(uint256 _maxGameDepth) public { - _maxGameDepth = bound(_maxGameDepth, LibPosition.MAX_POSITION_BITLEN, type(uint256).max - 1); - vm.expectRevert(MaxDepthTooLarge.selector); - DeployUtils.create1({ - _name: "FaultDisputeGameV2", - _args: DeployUtils.encodeConstructor( - abi.encodeCall( - IFaultDisputeGameV2.__constructor__, - ( - IFaultDisputeGameV2.GameConstructorParams({ - gameType: GAME_TYPE, - maxGameDepth: _maxGameDepth, - splitDepth: _maxGameDepth + 1, - clockExtension: Duration.wrap(3 hours), - maxClockDuration: Duration.wrap(3.5 days) - }) - ) - ) - ) - }); - } - - /// @notice Tests that the constructor of the `FaultDisputeGame` reverts when the `_splitDepth` - /// parameter is greater than or equal to the `MAX_GAME_DEPTH` - function testFuzz_constructor_invalidSplitDepth_reverts(uint256 _splitDepth) public { - uint256 maxGameDepth = 2 ** 3; - _splitDepth = bound(_splitDepth, maxGameDepth - 1, type(uint256).max); - vm.expectRevert(InvalidSplitDepth.selector); - DeployUtils.create1({ - _name: "FaultDisputeGameV2", - _args: DeployUtils.encodeConstructor( - abi.encodeCall( - IFaultDisputeGameV2.__constructor__, - ( - IFaultDisputeGameV2.GameConstructorParams({ - gameType: GAME_TYPE, - maxGameDepth: maxGameDepth, - splitDepth: _splitDepth, - clockExtension: Duration.wrap(3 hours), - maxClockDuration: Duration.wrap(3.5 days) - }) - ) - ) - ) - }); - } - - /// @notice Tests that the constructor of the `FaultDisputeGame` reverts when the `_splitDepth` - /// parameter is less than the minimum split depth (currently 2). - function testFuzz_constructor_lowSplitDepth_reverts(uint256 _splitDepth) public { - uint256 minSplitDepth = 2; - _splitDepth = bound(_splitDepth, 0, minSplitDepth - 1); - vm.expectRevert(InvalidSplitDepth.selector); - DeployUtils.create1({ - _name: "FaultDisputeGameV2", - _args: DeployUtils.encodeConstructor( - abi.encodeCall( - IFaultDisputeGameV2.__constructor__, - ( - IFaultDisputeGameV2.GameConstructorParams({ - gameType: GAME_TYPE, - maxGameDepth: 2 ** 3, - splitDepth: _splitDepth, - clockExtension: Duration.wrap(3 hours), - maxClockDuration: Duration.wrap(3.5 days) - }) - ) - ) - ) - }); - } - - /// @notice Tests that the constructor of the `FaultDisputeGame` reverts when clock - /// extension * 2 is greater than the max clock duration. - function testFuzz_constructor_clockExtensionTooLong_reverts( - uint64 _maxClockDuration, - uint64 _clockExtension - ) - public - { - // Force the clock extension * 2 to be greater than the max clock duration, but keep things - // within bounds of the uint64 type. - _maxClockDuration = uint64(bound(_maxClockDuration, 0, type(uint64).max / 2 - 1)); - _clockExtension = uint64(bound(_clockExtension, _maxClockDuration / 2 + 1, type(uint64).max / 2)); - - vm.expectRevert(InvalidClockExtension.selector); - DeployUtils.create1({ - _name: "FaultDisputeGameV2", - _args: DeployUtils.encodeConstructor( - abi.encodeCall( - IFaultDisputeGameV2.__constructor__, - ( - IFaultDisputeGameV2.GameConstructorParams({ - gameType: GAME_TYPE, - maxGameDepth: 16, - splitDepth: 8, - clockExtension: Duration.wrap(_clockExtension), - maxClockDuration: Duration.wrap(_maxClockDuration) - }) - ) - ) - ) - }); - } - - /// @notice Tests that the constructor of the `FaultDisputeGame` reverts when the `_gameType` - /// parameter is set to the reserved `type(uint32).max` game type. - function test_constructor_reservedGameType_reverts() public { - vm.expectRevert(ReservedGameType.selector); - DeployUtils.create1({ - _name: "FaultDisputeGameV2", - _args: DeployUtils.encodeConstructor( - abi.encodeCall( - IFaultDisputeGameV2.__constructor__, - ( - IFaultDisputeGameV2.GameConstructorParams({ - gameType: GameType.wrap(type(uint32).max), - maxGameDepth: 16, - splitDepth: 8, - clockExtension: Duration.wrap(3 hours), - maxClockDuration: Duration.wrap(3.5 days) - }) - ) - ) - ) - }); - } -} - -/// @title FaultDisputeGame_Initialize_Test -/// @notice Tests the initialization of the `FaultDisputeGame` contract. -contract FaultDisputeGameV2_Initialize_Test is FaultDisputeGameV2_TestInit { - /// @notice Tests that the game cannot be initialized with an output root that commits to <= - /// the configured starting block number - function testFuzz_initialize_cannotProposeGenesis_reverts(uint256 _blockNumber) public { - (, uint256 startingL2Block) = gameProxy.startingOutputRoot(); - _blockNumber = bound(_blockNumber, 0, startingL2Block); - - Claim claim = _dummyClaim(); - vm.expectRevert(abi.encodeWithSelector(UnexpectedRootClaim.selector, claim)); - gameProxy = IFaultDisputeGameV2( - payable(address(disputeGameFactory.create{ value: initBond }(GAME_TYPE, claim, abi.encode(_blockNumber)))) - ); - } - - /// @notice Tests that the proxy receives ETH from the dispute game factory. - function test_initialize_receivesETH_succeeds() public { - uint256 _value = disputeGameFactory.initBonds(GAME_TYPE); - vm.deal(address(this), _value); - - assertEq(address(gameProxy).balance, 0); - gameProxy = IFaultDisputeGameV2( - payable( - address( - disputeGameFactory.create{ value: _value }( - GAME_TYPE, arbitaryRootClaim, abi.encode(validL2BlockNumber) - ) - ) - ) - ); - assertEq(address(gameProxy).balance, 0); - assertEq(delayedWeth.balanceOf(address(gameProxy)), _value); - } - - /// @notice Tests that the game cannot be initialized with incorrect CWIA calldata length - /// caused by extraData of the wrong length - function test_initialize_wrongExtradataLength_reverts(uint256 _extraDataLen) public { - // The `DisputeGameFactory` will pack the root claim and the extra data into a single - // array, which is enforced to be at least 64 bytes long. - // We bound the upper end to 23.5KB to ensure that the minimal proxy never surpasses the - // contract size limit in this test, as CWIA proxies store the immutable args in their - // bytecode. - // [0 bytes, 31 bytes] u [33 bytes, 23.5 KB] - _extraDataLen = bound(_extraDataLen, 0, 23_500); - if (_extraDataLen == 32) { - _extraDataLen++; - } - bytes memory _extraData = new bytes(_extraDataLen); - - // Assign the first 32 bytes in `extraData` to a valid L2 block number passed the starting - // block. - (, uint256 startingL2Block) = gameProxy.startingOutputRoot(); - assembly { - mstore(add(_extraData, 0x20), add(startingL2Block, 1)) - } - - Claim claim = _dummyClaim(); - vm.expectRevert(IFaultDisputeGameV2.BadExtraData.selector); - gameProxy = IFaultDisputeGameV2( - payable(address(disputeGameFactory.create{ value: initBond }(GAME_TYPE, claim, _extraData))) - ); - } - - /// @notice Tests that the game cannot be initialized with incorrect CWIA calldata length - /// caused by additional immutable args data - function test_initialize_extraImmutableArgsBytes_reverts(uint256 _extraByteCount) public { - (bytes memory correctArgs,,) = getFaultDisputeGameV2ImmutableArgs(absolutePrestate); - - // We bound the upper end to 23.5KB to ensure that the minimal proxy never surpasses the - // contract size limit in this test, as CWIA proxies store the immutable args in their - // bytecode. - _extraByteCount = bound(_extraByteCount, 1, 23_500); - bytes memory immutableArgs = new bytes(_extraByteCount + correctArgs.length); - // Copy correct args into immutable args - copyBytes(correctArgs, immutableArgs); - - // Set up dispute game implementation with target immutableArgs - setupFaultDisputeGameV2(immutableArgs); - - Claim claim = _dummyClaim(); - vm.expectRevert(IFaultDisputeGameV2.BadExtraData.selector); - gameProxy = IFaultDisputeGameV2( - payable( - address(disputeGameFactory.create{ value: initBond }(GAME_TYPE, claim, abi.encode(validL2BlockNumber))) - ) - ); - } - - /// @notice Tests that the game cannot be initialized with incorrect CWIA calldata length - /// caused by missing immutable args data - function test_initialize_missingImmutableArgsBytes_reverts(uint256 _truncatedByteCount) public { - (bytes memory correctArgs,,) = getFaultDisputeGameV2ImmutableArgs(absolutePrestate); - - _truncatedByteCount = (_truncatedByteCount % correctArgs.length) + 1; - bytes memory immutableArgs = new bytes(correctArgs.length - _truncatedByteCount); - // Copy correct args into immutable args - copyBytes(correctArgs, immutableArgs); - - // Set up dispute game implementation with target immutableArgs - setupFaultDisputeGameV2(immutableArgs); - - Claim claim = _dummyClaim(); - vm.expectRevert(IFaultDisputeGameV2.BadExtraData.selector); - gameProxy = IFaultDisputeGameV2( - payable( - address(disputeGameFactory.create{ value: initBond }(GAME_TYPE, claim, abi.encode(validL2BlockNumber))) - ) - ); - } - - /// @notice Tests that the game is initialized with the correct data. - function test_initialize_correctData_succeeds() public view { - // Assert that the root claim is initialized correctly. - ( - uint32 parentIndex, - address counteredBy, - address claimant, - uint128 bond, - Claim claim, - Position position, - Clock clock - ) = gameProxy.claimData(0); - assertEq(parentIndex, type(uint32).max); - assertEq(counteredBy, address(0)); - assertEq(claimant, address(this)); - assertEq(bond, initBond); - assertEq(claim.raw(), ROOT_CLAIM.raw()); - assertEq(position.raw(), 1); - assertEq(clock.raw(), LibClock.wrap(Duration.wrap(0), Timestamp.wrap(uint64(block.timestamp))).raw()); - - // Assert that the `createdAt` timestamp is correct. - assertEq(gameProxy.createdAt().raw(), block.timestamp); - - // Assert that the blockhash provided is correct. - assertEq(gameProxy.l1Head().raw(), blockhash(block.number - 1)); - } - - /// @notice Tests that the game cannot be initialized when the anchor root is not found. - function test_initialize_anchorRootNotFound_reverts() public { - // Mock the AnchorStateRegistry to return a zero root. - vm.mockCall( - address(anchorStateRegistry), - abi.encodeCall(IAnchorStateRegistry.getAnchorRoot, ()), - abi.encode(Hash.wrap(bytes32(0)), 0) - ); - - // Creation should fail. - vm.expectRevert(AnchorRootNotFound.selector); - gameProxy = IFaultDisputeGameV2( - payable( - address(disputeGameFactory.create{ value: initBond }(GAME_TYPE, _dummyClaim(), new bytes(uint256(32)))) - ) - ); - } - - /// @notice Tests that the game cannot be initialized twice. - function test_initialize_onlyOnce_succeeds() public { - vm.expectRevert(AlreadyInitialized.selector); - gameProxy.initialize(); - } - - /// @notice Tests that initialization reverts when oracle challenge period is too large. - /// @dev V2 validates oracle challenge period during initialize(), not constructor - function testFuzz_initialize_oracleChallengePeriodTooLarge_reverts(uint256 _challengePeriod) public { - // Bound to values larger than uint64.max - _challengePeriod = bound(_challengePeriod, uint256(type(uint64).max) + 1, type(uint256).max); - - // Get the current AlphabetVM from the setup - (, AlphabetVM vm_,) = setupFaultDisputeGameV2(absolutePrestate); - - // Mock the VM's oracle to return invalid challenge period - vm.mockCall( - address(vm_.oracle()), abi.encodeCall(IPreimageOracle.challengePeriod, ()), abi.encode(_challengePeriod) - ); - - // Expect the initialize call to revert with InvalidChallengePeriod - vm.expectRevert(InvalidChallengePeriod.selector); - - // Create game via factory - initialize() is called automatically and should revert - gameProxy = IFaultDisputeGameV2( - payable( - address( - disputeGameFactory.create{ value: initBond }( - GAME_TYPE, _dummyClaim(), abi.encode(validL2BlockNumber) - ) - ) - ) - ); - } -} - -/// @title FaultDisputeGame_Step_Test -/// @notice Tests the step functionality of the `FaultDisputeGame` contract. -contract FaultDisputeGameV2_Step_Test is FaultDisputeGameV2_TestInit { - /// @notice Tests that a claim cannot be stepped against twice. - function test_step_duplicateStep_reverts() public { - // Give the test contract some ether - vm.deal(address(this), 1000 ether); - - // Make claims all the way down the tree. - (,,,, Claim disputed,,) = gameProxy.claimData(0); - gameProxy.attack{ value: _getRequiredBond(0) }(disputed, 0, _dummyClaim()); - (,,,, disputed,,) = gameProxy.claimData(1); - gameProxy.attack{ value: _getRequiredBond(1) }(disputed, 1, _dummyClaim()); - (,,,, disputed,,) = gameProxy.claimData(2); - gameProxy.attack{ value: _getRequiredBond(2) }(disputed, 2, _dummyClaim()); - (,,,, disputed,,) = gameProxy.claimData(3); - gameProxy.attack{ value: _getRequiredBond(3) }(disputed, 3, _dummyClaim()); - (,,,, disputed,,) = gameProxy.claimData(4); - gameProxy.attack{ value: _getRequiredBond(4) }(disputed, 4, _changeClaimStatus(_dummyClaim(), VMStatuses.PANIC)); - (,,,, disputed,,) = gameProxy.claimData(5); - gameProxy.attack{ value: _getRequiredBond(5) }(disputed, 5, _dummyClaim()); - (,,,, disputed,,) = gameProxy.claimData(6); - gameProxy.attack{ value: _getRequiredBond(6) }(disputed, 6, _dummyClaim()); - (,,,, disputed,,) = gameProxy.claimData(7); - gameProxy.attack{ value: _getRequiredBond(7) }(disputed, 7, _dummyClaim()); - gameProxy.addLocalData(LocalPreimageKey.DISPUTED_L2_BLOCK_NUMBER, 8, 0); - gameProxy.step(8, true, absolutePrestateData, hex""); - - vm.expectRevert(DuplicateStep.selector); - gameProxy.step(8, true, absolutePrestateData, hex""); - } - - /// @notice Tests that successfully step with true attacking claim when there is a true defend - /// claim(claim5) in the middle of the dispute game. - function test_stepAttackDummyClaim_defendTrueClaimInTheMiddle_succeeds() public { - // Give the test contract some ether - vm.deal(address(this), 1000 ether); - - // Make claims all the way down the tree. - (,,,, Claim disputed,,) = gameProxy.claimData(0); - gameProxy.attack{ value: _getRequiredBond(0) }(disputed, 0, _dummyClaim()); - (,,,, disputed,,) = gameProxy.claimData(1); - gameProxy.attack{ value: _getRequiredBond(1) }(disputed, 1, _dummyClaim()); - (,,,, disputed,,) = gameProxy.claimData(2); - gameProxy.attack{ value: _getRequiredBond(2) }(disputed, 2, _dummyClaim()); - (,,,, disputed,,) = gameProxy.claimData(3); - gameProxy.attack{ value: _getRequiredBond(3) }(disputed, 3, _dummyClaim()); - (,,,, disputed,,) = gameProxy.claimData(4); - gameProxy.attack{ value: _getRequiredBond(4) }(disputed, 4, _changeClaimStatus(_dummyClaim(), VMStatuses.PANIC)); - bytes memory claimData5 = abi.encode(5, 5); - Claim claim5 = Claim.wrap(keccak256(claimData5)); - (,,,, disputed,,) = gameProxy.claimData(5); - gameProxy.attack{ value: _getRequiredBond(5) }(disputed, 5, claim5); - (,,,, disputed,,) = gameProxy.claimData(6); - gameProxy.defend{ value: _getRequiredBond(6) }(disputed, 6, _dummyClaim()); - (,,,, disputed,,) = gameProxy.claimData(7); - gameProxy.attack{ value: _getRequiredBond(7) }(disputed, 7, _dummyClaim()); - gameProxy.addLocalData(LocalPreimageKey.DISPUTED_L2_BLOCK_NUMBER, 8, 0); - gameProxy.step(8, true, claimData5, hex""); - } - - /// @notice Tests that successfully step with true defend claim when there is a true defend - /// claim(claim7) in the middle of the dispute game. - function test_stepDefendDummyClaim_defendTrueClaimInTheMiddle_succeeds() public { - // Give the test contract some ether - vm.deal(address(this), 1000 ether); - - // Make claims all the way down the tree. - (,,,, Claim disputed,,) = gameProxy.claimData(0); - gameProxy.attack{ value: _getRequiredBond(0) }(disputed, 0, _dummyClaim()); - (,,,, disputed,,) = gameProxy.claimData(1); - gameProxy.attack{ value: _getRequiredBond(1) }(disputed, 1, _dummyClaim()); - (,,,, disputed,,) = gameProxy.claimData(2); - gameProxy.attack{ value: _getRequiredBond(2) }(disputed, 2, _dummyClaim()); - (,,,, disputed,,) = gameProxy.claimData(3); - gameProxy.attack{ value: _getRequiredBond(3) }(disputed, 3, _dummyClaim()); - (,,,, disputed,,) = gameProxy.claimData(4); - gameProxy.attack{ value: _getRequiredBond(4) }(disputed, 4, _changeClaimStatus(_dummyClaim(), VMStatuses.PANIC)); - - bytes memory claimData7 = abi.encode(7, 7); - Claim postState_ = Claim.wrap(gameProxy.vm().step(claimData7, hex"", bytes32(0))); - - (,,,, disputed,,) = gameProxy.claimData(5); - gameProxy.attack{ value: _getRequiredBond(5) }(disputed, 5, _dummyClaim()); - (,,,, disputed,,) = gameProxy.claimData(6); - gameProxy.defend{ value: _getRequiredBond(6) }(disputed, 6, postState_); - (,,,, disputed,,) = gameProxy.claimData(7); - - gameProxy.attack{ value: _getRequiredBond(7) }(disputed, 7, Claim.wrap(keccak256(claimData7))); - gameProxy.addLocalData(LocalPreimageKey.DISPUTED_L2_BLOCK_NUMBER, 8, 0); - gameProxy.step(8, false, claimData7, hex""); - } - - /// @notice Tests that step reverts with false attacking claim when there is a true defend - /// claim(claim5) in the middle of the dispute game. - function test_stepAttackTrueClaim_defendTrueClaimInTheMiddle_reverts() public { - // Give the test contract some ether - vm.deal(address(this), 1000 ether); - - // Make claims all the way down the tree. - (,,,, Claim disputed,,) = gameProxy.claimData(0); - gameProxy.attack{ value: _getRequiredBond(0) }(disputed, 0, _dummyClaim()); - (,,,, disputed,,) = gameProxy.claimData(1); - gameProxy.attack{ value: _getRequiredBond(1) }(disputed, 1, _dummyClaim()); - (,,,, disputed,,) = gameProxy.claimData(2); - gameProxy.attack{ value: _getRequiredBond(2) }(disputed, 2, _dummyClaim()); - (,,,, disputed,,) = gameProxy.claimData(3); - gameProxy.attack{ value: _getRequiredBond(3) }(disputed, 3, _dummyClaim()); - (,,,, disputed,,) = gameProxy.claimData(4); - gameProxy.attack{ value: _getRequiredBond(4) }(disputed, 4, _changeClaimStatus(_dummyClaim(), VMStatuses.PANIC)); - bytes memory claimData5 = abi.encode(5, 5); - Claim claim5 = Claim.wrap(keccak256(claimData5)); - (,,,, disputed,,) = gameProxy.claimData(5); - gameProxy.attack{ value: _getRequiredBond(5) }(disputed, 5, claim5); - (,,,, disputed,,) = gameProxy.claimData(6); - gameProxy.defend{ value: _getRequiredBond(6) }(disputed, 6, _dummyClaim()); - Claim postState_ = Claim.wrap(gameProxy.vm().step(claimData5, hex"", bytes32(0))); - (,,,, disputed,,) = gameProxy.claimData(7); - gameProxy.attack{ value: _getRequiredBond(7) }(disputed, 7, postState_); - gameProxy.addLocalData(LocalPreimageKey.DISPUTED_L2_BLOCK_NUMBER, 8, 0); - - vm.expectRevert(ValidStep.selector); - gameProxy.step(8, true, claimData5, hex""); - } - - /// @notice Tests that step reverts with false defending claim when there is a true defend - /// claim(postState_) in the middle of the dispute game. - function test_stepDefendDummyClaim_defendTrueClaimInTheMiddle_reverts() public { - // Give the test contract some ether - vm.deal(address(this), 1000 ether); - - // Make claims all the way down the tree. - (,,,, Claim disputed,,) = gameProxy.claimData(0); - gameProxy.attack{ value: _getRequiredBond(0) }(disputed, 0, _dummyClaim()); - (,,,, disputed,,) = gameProxy.claimData(1); - gameProxy.attack{ value: _getRequiredBond(1) }(disputed, 1, _dummyClaim()); - (,,,, disputed,,) = gameProxy.claimData(2); - gameProxy.attack{ value: _getRequiredBond(2) }(disputed, 2, _dummyClaim()); - (,,,, disputed,,) = gameProxy.claimData(3); - gameProxy.attack{ value: _getRequiredBond(3) }(disputed, 3, _dummyClaim()); - (,,,, disputed,,) = gameProxy.claimData(4); - gameProxy.attack{ value: _getRequiredBond(4) }(disputed, 4, _changeClaimStatus(_dummyClaim(), VMStatuses.PANIC)); - - bytes memory claimData7 = abi.encode(5, 5); - Claim postState_ = Claim.wrap(gameProxy.vm().step(claimData7, hex"", bytes32(0))); - - (,,,, disputed,,) = gameProxy.claimData(5); - gameProxy.attack{ value: _getRequiredBond(5) }(disputed, 5, postState_); - (,,,, disputed,,) = gameProxy.claimData(6); - gameProxy.defend{ value: _getRequiredBond(6) }(disputed, 6, _dummyClaim()); - - bytes memory _dummyClaimData = abi.encode(gasleft(), gasleft()); - Claim dummyClaim7 = Claim.wrap(keccak256(_dummyClaimData)); - (,,,, disputed,,) = gameProxy.claimData(7); - gameProxy.attack{ value: _getRequiredBond(7) }(disputed, 7, dummyClaim7); - gameProxy.addLocalData(LocalPreimageKey.DISPUTED_L2_BLOCK_NUMBER, 8, 0); - vm.expectRevert(ValidStep.selector); - gameProxy.step(8, false, _dummyClaimData, hex""); - } - - /// @notice Tests that step reverts with true defending claim when there is a true defend - /// claim(postState_) in the middle of the dispute game. - function test_stepDefendTrueClaim_defendTrueClaimInTheMiddle_reverts() public { - // Give the test contract some ether - vm.deal(address(this), 1000 ether); - - // Make claims all the way down the tree. - (,,,, Claim disputed,,) = gameProxy.claimData(0); - gameProxy.attack{ value: _getRequiredBond(0) }(disputed, 0, _dummyClaim()); - (,,,, disputed,,) = gameProxy.claimData(1); - gameProxy.attack{ value: _getRequiredBond(1) }(disputed, 1, _dummyClaim()); - (,,,, disputed,,) = gameProxy.claimData(2); - gameProxy.attack{ value: _getRequiredBond(2) }(disputed, 2, _dummyClaim()); - (,,,, disputed,,) = gameProxy.claimData(3); - gameProxy.attack{ value: _getRequiredBond(3) }(disputed, 3, _dummyClaim()); - (,,,, disputed,,) = gameProxy.claimData(4); - gameProxy.attack{ value: _getRequiredBond(4) }(disputed, 4, _changeClaimStatus(_dummyClaim(), VMStatuses.PANIC)); - - bytes memory claimData7 = abi.encode(5, 5); - Claim claim7 = Claim.wrap(keccak256(claimData7)); - Claim postState_ = Claim.wrap(gameProxy.vm().step(claimData7, hex"", bytes32(0))); - - (,,,, disputed,,) = gameProxy.claimData(5); - gameProxy.attack{ value: _getRequiredBond(5) }(disputed, 5, postState_); - (,,,, disputed,,) = gameProxy.claimData(6); - gameProxy.defend{ value: _getRequiredBond(6) }(disputed, 6, _dummyClaim()); - (,,,, disputed,,) = gameProxy.claimData(7); - gameProxy.attack{ value: _getRequiredBond(7) }(disputed, 7, claim7); - gameProxy.addLocalData(LocalPreimageKey.DISPUTED_L2_BLOCK_NUMBER, 8, 0); - - vm.expectRevert(ValidStep.selector); - gameProxy.step(8, false, claimData7, hex""); - } -} - -/// @title FaultDisputeGame_Move_Test -/// @notice Tests the move functionality of the `FaultDisputeGame` contract. -contract FaultDisputeGameV2_Move_Test is FaultDisputeGameV2_TestInit { - /// @notice Tests that a move while the game status is not `IN_PROGRESS` causes the call to - /// revert with the `GameNotInProgress` error - function test_move_gameNotInProgress_reverts() public { - uint256 chalWins = uint256(GameStatus.CHALLENGER_WINS); - - // Replace the game status in storage. It exists in slot 0 at offset 16. - uint256 slot = uint256(vm.load(address(gameProxy), bytes32(0))); - uint256 offset = 16 << 3; - uint256 mask = 0xFF << offset; - // Replace the byte in the slot value with the challenger wins status. - slot = (slot & ~mask) | (chalWins << offset); - vm.store(address(gameProxy), bytes32(0), bytes32(slot)); - - // Ensure that the game status was properly updated. - GameStatus status = gameProxy.status(); - assertEq(uint256(status), chalWins); - - (,,,, Claim root,,) = gameProxy.claimData(0); - // Attempt to make a move. Should revert. - vm.expectRevert(GameNotInProgress.selector); - gameProxy.attack(root, 0, Claim.wrap(0)); - } - - /// @notice Tests that an attempt to defend the root claim reverts with the - /// `CannotDefendRootClaim` error. - function test_move_defendRoot_reverts() public { - (,,,, Claim root,,) = gameProxy.claimData(0); - vm.expectRevert(CannotDefendRootClaim.selector); - gameProxy.defend(root, 0, _dummyClaim()); - } - - /// @notice Tests that an attempt to move against a claim that does not exist reverts with the - /// `ParentDoesNotExist` error. - function test_move_nonExistentParent_reverts() public { - Claim claim = _dummyClaim(); - - // Expect an out of bounds revert for an attack - vm.expectRevert(stdError.indexOOBError); - gameProxy.attack(_dummyClaim(), 1, claim); - - // Expect an out of bounds revert for a defense - vm.expectRevert(stdError.indexOOBError); - gameProxy.defend(_dummyClaim(), 1, claim); - } - - /// @notice Tests that an attempt to move at the maximum game depth reverts with the - /// `GameDepthExceeded` error. - function test_move_gameDepthExceeded_reverts() public { - Claim claim = _changeClaimStatus(_dummyClaim(), VMStatuses.PANIC); - - uint256 maxDepth = gameProxy.maxGameDepth(); - - for (uint256 i = 0; i <= maxDepth; i++) { - (,,,, Claim disputed,,) = gameProxy.claimData(i); - // At the max game depth, the `_move` function should revert with - // the `GameDepthExceeded` error. - if (i == maxDepth) { - vm.expectRevert(GameDepthExceeded.selector); - gameProxy.attack{ value: 100 ether }(disputed, i, claim); - } else { - gameProxy.attack{ value: _getRequiredBond(i) }(disputed, i, claim); - } - } - } - - /// @notice Tests that a move made after the clock time has exceeded reverts with the - /// `ClockTimeExceeded` error. - function test_move_clockTimeExceeded_reverts() public { - // Warp ahead past the clock time for the first move (3 1/2 days) - vm.warp(block.timestamp + 3 days + 12 hours + 1); - uint256 bond = _getRequiredBond(0); - (,,,, Claim disputed,,) = gameProxy.claimData(0); - vm.expectRevert(ClockTimeExceeded.selector); - gameProxy.attack{ value: bond }(disputed, 0, _dummyClaim()); - } - - /// @notice Static unit test for the correctness of the chess clock incrementation. - function test_move_clockCorrectness_succeeds() public { - (,,,,,, Clock clock) = gameProxy.claimData(0); - assertEq(clock.raw(), LibClock.wrap(Duration.wrap(0), Timestamp.wrap(uint64(block.timestamp))).raw()); - - Claim claim = _dummyClaim(); - - vm.warp(block.timestamp + 15); - uint256 bond = _getRequiredBond(0); - (,,,, Claim disputed,,) = gameProxy.claimData(0); - gameProxy.attack{ value: bond }(disputed, 0, claim); - (,,,,,, clock) = gameProxy.claimData(1); - assertEq(clock.raw(), LibClock.wrap(Duration.wrap(15), Timestamp.wrap(uint64(block.timestamp))).raw()); - - vm.warp(block.timestamp + 10); - bond = _getRequiredBond(1); - (,,,, disputed,,) = gameProxy.claimData(1); - gameProxy.attack{ value: bond }(disputed, 1, claim); - (,,,,,, clock) = gameProxy.claimData(2); - assertEq(clock.raw(), LibClock.wrap(Duration.wrap(10), Timestamp.wrap(uint64(block.timestamp))).raw()); - - // We are at the split depth, so we need to set the status byte of the claim for the next - // move. - claim = _changeClaimStatus(claim, VMStatuses.PANIC); - - vm.warp(block.timestamp + 10); - bond = _getRequiredBond(2); - (,,,, disputed,,) = gameProxy.claimData(2); - gameProxy.attack{ value: bond }(disputed, 2, claim); - (,,,,,, clock) = gameProxy.claimData(3); - assertEq(clock.raw(), LibClock.wrap(Duration.wrap(25), Timestamp.wrap(uint64(block.timestamp))).raw()); - - vm.warp(block.timestamp + 10); - bond = _getRequiredBond(3); - (,,,, disputed,,) = gameProxy.claimData(3); - gameProxy.attack{ value: bond }(disputed, 3, claim); - (,,,,,, clock) = gameProxy.claimData(4); - assertEq(clock.raw(), LibClock.wrap(Duration.wrap(20), Timestamp.wrap(uint64(block.timestamp))).raw()); - } - - /// @notice Tests that the standard clock extension is triggered for a move that is not the - /// split depth or the max game depth. - function test_move_standardClockExtension_succeeds() public { - (,,,,,, Clock clock) = gameProxy.claimData(0); - assertEq(clock.raw(), LibClock.wrap(Duration.wrap(0), Timestamp.wrap(uint64(block.timestamp))).raw()); - - uint256 bond; - Claim disputed; - Claim claim = _dummyClaim(); - uint256 splitDepth = gameProxy.splitDepth(); - uint64 halfGameDuration = gameProxy.maxClockDuration().raw(); - uint64 clockExtension = gameProxy.clockExtension().raw(); - - // Warp ahead so that the next move will trigger a clock extension. We warp to the very - // first timestamp where a clock extension should be triggered. - vm.warp(block.timestamp + halfGameDuration - clockExtension + 1 seconds); - - // Execute a move that should cause a clock extension. - bond = _getRequiredBond(0); - (,,,, disputed,,) = gameProxy.claimData(0); - gameProxy.attack{ value: bond }(disputed, 0, claim); - (,,,,,, clock) = gameProxy.claimData(1); - - // The clock should have been pushed back to the clock extension time. - assertEq(clock.duration().raw(), halfGameDuration - clockExtension); - - // Warp ahead again so that clock extensions will also trigger for the other team. Here we - // only warp to the clockExtension time because we'll be warping ahead by one second during - // each additional move. - vm.warp(block.timestamp + halfGameDuration - clockExtension); - - // Work our way down to the split depth. - for (uint256 i = 1; i < splitDepth - 2; i++) { - // Warp ahead by one second so that the next move will trigger a clock extension. - vm.warp(block.timestamp + 1 seconds); - - // Execute a move that should cause a clock extension. - bond = _getRequiredBond(i); - (,,,, disputed,,) = gameProxy.claimData(i); - gameProxy.attack{ value: bond }(disputed, i, claim); - (,,,,,, clock) = gameProxy.claimData(i + 1); - - // The clock should have been pushed back to the clock extension time. - assertEq(clock.duration().raw(), halfGameDuration - clockExtension); - } - } - - function test_move_splitDepthClockExtension_succeeds() public { - (,,,,,, Clock clock) = gameProxy.claimData(0); - assertEq(clock.raw(), LibClock.wrap(Duration.wrap(0), Timestamp.wrap(uint64(block.timestamp))).raw()); - - uint256 bond; - Claim disputed; - Claim claim = _dummyClaim(); - uint256 splitDepth = gameProxy.splitDepth(); - uint64 halfGameDuration = gameProxy.maxClockDuration().raw(); - uint64 clockExtension = gameProxy.clockExtension().raw(); - - // Work our way down to the split depth without moving ahead in time, we don't care about - // the exact clock here, just don't want take the clock below the clock extension time that - // we're trying to test here. - for (uint256 i = 0; i < splitDepth - 2; i++) { - bond = _getRequiredBond(i); - (,,,, disputed,,) = gameProxy.claimData(i); - gameProxy.attack{ value: bond }(disputed, i, claim); - } - - // Warp ahead to the very first timestamp where a clock extension should be triggered. - vm.warp(block.timestamp + halfGameDuration - clockExtension * 2 + 1 seconds); - - // Execute a move that should cause a clock extension. - bond = _getRequiredBond(splitDepth - 2); - (,,,, disputed,,) = gameProxy.claimData(splitDepth - 2); - gameProxy.attack{ value: bond }(disputed, splitDepth - 2, claim); - (,,,,,, clock) = gameProxy.claimData(splitDepth - 1); - - // The clock should have been pushed back to the clock extension time. - assertEq(clock.duration().raw(), halfGameDuration - clockExtension * 2); - } - - function test_move_maxGameDepthClockExtension_succeeds() public { - (,,,,,, Clock clock) = gameProxy.claimData(0); - assertEq(clock.raw(), LibClock.wrap(Duration.wrap(0), Timestamp.wrap(uint64(block.timestamp))).raw()); - - uint256 bond; - Claim disputed; - Claim claim = _dummyClaim(); - uint256 splitDepth = gameProxy.splitDepth(); - uint64 halfGameDuration = gameProxy.maxClockDuration().raw(); - uint64 clockExtension = gameProxy.clockExtension().raw(); - - // Work our way down to the split depth without moving ahead in time, we don't care about - // the exact clock here, just don't want take the clock below the clock extension time that - // we're trying to test here. - for (uint256 i = 0; i < gameProxy.maxGameDepth() - 2; i++) { - bond = _getRequiredBond(i); - (,,,, disputed,,) = gameProxy.claimData(i); - gameProxy.attack{ value: bond }(disputed, i, claim); - - // Change the claim status when we're crossing the split depth. - if (i == splitDepth - 2) { - claim = _changeClaimStatus(claim, VMStatuses.PANIC); - } - } - - // Warp ahead to the very first timestamp where a clock extension should be triggered. - vm.warp(block.timestamp + halfGameDuration - (clockExtension + gameProxy.vm().oracle().challengePeriod()) + 1); - - // Execute a move that should cause a clock extension. - bond = _getRequiredBond(gameProxy.maxGameDepth() - 2); - (,,,, disputed,,) = gameProxy.claimData(gameProxy.maxGameDepth() - 2); - gameProxy.attack{ value: bond }(disputed, gameProxy.maxGameDepth() - 2, claim); - (,,,,,, clock) = gameProxy.claimData(gameProxy.maxGameDepth() - 1); - - // The clock should have been pushed back to the clock extension time. - assertEq( - clock.duration().raw(), halfGameDuration - (clockExtension + gameProxy.vm().oracle().challengePeriod()) - ); - } - - /// @notice Tests that an identical claim cannot be made twice. The duplicate claim attempt - /// should revert with the `ClaimAlreadyExists` error. - function test_move_duplicateClaim_reverts() public { - Claim claim = _dummyClaim(); - - // Make the first move. This should succeed. - uint256 bond = _getRequiredBond(0); - (,,,, Claim disputed,,) = gameProxy.claimData(0); - gameProxy.attack{ value: bond }(disputed, 0, claim); - - // Attempt to make the same move again. - vm.expectRevert(ClaimAlreadyExists.selector); - gameProxy.attack{ value: bond }(disputed, 0, claim); - } - - /// @notice Static unit test asserting that identical claims at the same position can be made - /// in different subgames. - function test_move_duplicateClaimsDifferentSubgames_succeeds() public { - Claim claimA = _dummyClaim(); - Claim claimB = _dummyClaim(); - - // Make the first moves. This should succeed. - uint256 bond = _getRequiredBond(0); - (,,,, Claim disputed,,) = gameProxy.claimData(0); - gameProxy.attack{ value: bond }(disputed, 0, claimA); - gameProxy.attack{ value: bond }(disputed, 0, claimB); - - // Perform an attack at the same position with the same claim value in both subgames. - // These both should succeed. - bond = _getRequiredBond(1); - (,,,, disputed,,) = gameProxy.claimData(1); - gameProxy.attack{ value: bond }(disputed, 1, claimA); - bond = _getRequiredBond(2); - (,,,, disputed,,) = gameProxy.claimData(2); - gameProxy.attack{ value: bond }(disputed, 2, claimA); - } - - /// @notice Static unit test for the correctness of an opening attack. - function test_move_simpleAttack_succeeds() public { - // Warp ahead 5 seconds. - vm.warp(block.timestamp + 5); - - Claim counter = _dummyClaim(); - - // Perform the attack. - uint256 reqBond = _getRequiredBond(0); - vm.expectEmit(true, true, true, false); - emit Move(0, counter, address(this)); - (,,,, Claim disputed,,) = gameProxy.claimData(0); - gameProxy.attack{ value: reqBond }(disputed, 0, counter); - - // Grab the claim data of the attack. - ( - uint32 parentIndex, - address counteredBy, - address claimant, - uint128 bond, - Claim claim, - Position position, - Clock clock - ) = gameProxy.claimData(1); - - // Assert correctness of the attack claim's data. - assertEq(parentIndex, 0); - assertEq(counteredBy, address(0)); - assertEq(claimant, address(this)); - assertEq(bond, reqBond); - assertEq(claim.raw(), counter.raw()); - assertEq(position.raw(), Position.wrap(1).move(true).raw()); - assertEq(clock.raw(), LibClock.wrap(Duration.wrap(5), Timestamp.wrap(uint64(block.timestamp))).raw()); - - // Grab the claim data of the parent. - (parentIndex, counteredBy, claimant, bond, claim, position, clock) = gameProxy.claimData(0); - - // Assert correctness of the parent claim's data. - assertEq(parentIndex, type(uint32).max); - assertEq(counteredBy, address(0)); - assertEq(claimant, address(this)); - assertEq(bond, initBond); - assertEq(claim.raw(), ROOT_CLAIM.raw()); - assertEq(position.raw(), 1); - assertEq(clock.raw(), LibClock.wrap(Duration.wrap(0), Timestamp.wrap(uint64(block.timestamp - 5))).raw()); - } - - /// @notice Tests that making a claim at the execution trace bisection root level with an - /// invalid status byte reverts with the `UnexpectedRootClaim` error. - function test_move_incorrectStatusExecRoot_reverts() public { - Claim disputed; - for (uint256 i; i < 4; i++) { - (,,,, disputed,,) = gameProxy.claimData(i); - gameProxy.attack{ value: _getRequiredBond(i) }(disputed, i, _dummyClaim()); - } - - uint256 bond = _getRequiredBond(4); - (,,,, disputed,,) = gameProxy.claimData(4); - vm.expectRevert(abi.encodeWithSelector(UnexpectedRootClaim.selector, bytes32(0))); - gameProxy.attack{ value: bond }(disputed, 4, Claim.wrap(bytes32(0))); - } - - /// @notice Tests that making a claim at the execution trace bisection root level with a valid - /// status byte succeeds. - function test_move_correctStatusExecRoot_succeeds() public { - Claim disputed; - for (uint256 i; i < 4; i++) { - uint256 bond = _getRequiredBond(i); - (,,,, disputed,,) = gameProxy.claimData(i); - gameProxy.attack{ value: bond }(disputed, i, _dummyClaim()); - } - uint256 lastBond = _getRequiredBond(4); - (,,,, disputed,,) = gameProxy.claimData(4); - gameProxy.attack{ value: lastBond }(disputed, 4, _changeClaimStatus(_dummyClaim(), VMStatuses.PANIC)); - } - - /// @notice Static unit test asserting that a move reverts when the bonded amount is incorrect. - function test_move_incorrectBondAmount_reverts() public { - (,,,, Claim disputed,,) = gameProxy.claimData(0); - vm.expectRevert(IncorrectBondAmount.selector); - gameProxy.attack{ value: 0 }(disputed, 0, _dummyClaim()); - } - - /// @notice Static unit test asserting that a move reverts when the disputed claim does not - /// match its index. - function test_move_incorrectDisputedIndex_reverts() public { - (,,,, Claim disputed,,) = gameProxy.claimData(0); - gameProxy.attack{ value: _getRequiredBond(0) }(disputed, 0, _dummyClaim()); - uint256 bond = _getRequiredBond(1); - vm.expectRevert(InvalidDisputedClaimIndex.selector); - gameProxy.attack{ value: bond }(disputed, 1, _dummyClaim()); - } -} - -/// @title FaultDisputeGame_AddLocalData_Test -/// @notice Tests the addLocalData functionality of the `FaultDisputeGame` contract. -contract FaultDisputeGameV2_AddLocalData_Test is FaultDisputeGameV2_TestInit { - /// @notice Tests that adding local data with an out of bounds identifier reverts. - function testFuzz_addLocalData_oob_reverts(uint256 _ident) public { - Claim disputed; - // Get a claim below the split depth so that we can add local data for an execution trace - // subgame. - for (uint256 i; i < 4; i++) { - uint256 bond = _getRequiredBond(i); - (,,,, disputed,,) = gameProxy.claimData(i); - gameProxy.attack{ value: bond }(disputed, i, _dummyClaim()); - } - uint256 lastBond = _getRequiredBond(4); - (,,,, disputed,,) = gameProxy.claimData(4); - gameProxy.attack{ value: lastBond }(disputed, 4, _changeClaimStatus(_dummyClaim(), VMStatuses.PANIC)); - - // [1, 5] are valid local data identifiers. - if (_ident <= 5) _ident = 0; - - vm.expectRevert(InvalidLocalIdent.selector); - gameProxy.addLocalData(_ident, 5, 0); - } - - /// @notice Tests that local data is loaded into the preimage oracle correctly in the subgame - /// that is disputing the transition from `GENESIS -> GENESIS + 1` - function test_addLocalDataGenesisTransition_static_succeeds() public { - IPreimageOracle oracle = IPreimageOracle(address(gameProxy.vm().oracle())); - Claim disputed; - - // Get a claim below the split depth so that we can add local data for an execution trace - // subgame. - for (uint256 i; i < 4; i++) { - uint256 bond = _getRequiredBond(i); - (,,,, disputed,,) = gameProxy.claimData(i); - gameProxy.attack{ value: bond }(disputed, i, Claim.wrap(bytes32(i))); - } - uint256 lastBond = _getRequiredBond(4); - (,,,, disputed,,) = gameProxy.claimData(4); - gameProxy.attack{ value: lastBond }(disputed, 4, _changeClaimStatus(_dummyClaim(), VMStatuses.PANIC)); - - // Expected start/disputed claims - (Hash root,) = gameProxy.startingOutputRoot(); - bytes32 startingClaim = root.raw(); - bytes32 disputedClaim = bytes32(uint256(3)); - Position disputedPos = LibPosition.wrap(4, 0); - - // Expected local data - bytes32[5] memory data = [ - gameProxy.l1Head().raw(), - startingClaim, - disputedClaim, - bytes32(validL2BlockNumber << 0xC0), - bytes32(gameProxy.l2ChainId() << 0xC0) - ]; - - for (uint256 i = 1; i <= 5; i++) { - uint256 expectedLen = i > 3 ? 8 : 32; - bytes32 key = _getKey(i, keccak256(abi.encode(disputedClaim, disputedPos))); - - gameProxy.addLocalData(i, 5, 0); - (bytes32 dat, uint256 datLen) = oracle.readPreimage(key, 0); - assertEq(dat >> 0xC0, bytes32(expectedLen)); - // Account for the length prefix if i > 3 (the data stored at identifiers i <= 3 are - // 32 bytes long, so the expected length is already correct. If i > 3, the data is only - // 8 bytes long, so the length prefix + the data is 16 bytes total.) - assertEq(datLen, expectedLen + (i > 3 ? 8 : 0)); - - gameProxy.addLocalData(i, 5, 8); - (dat, datLen) = oracle.readPreimage(key, 8); - assertEq(dat, data[i - 1]); - assertEq(datLen, expectedLen); - } - } - - /// @notice Tests that local data is loaded into the preimage oracle correctly. - function test_addLocalDataMiddle_static_succeeds() public { - IPreimageOracle oracle = IPreimageOracle(address(gameProxy.vm().oracle())); - Claim disputed; - - // Get a claim below the split depth so that we can add local data for an execution trace - // subgame. - for (uint256 i; i < 4; i++) { - uint256 bond = _getRequiredBond(i); - (,,,, disputed,,) = gameProxy.claimData(i); - gameProxy.attack{ value: bond }(disputed, i, Claim.wrap(bytes32(i))); - } - uint256 lastBond = _getRequiredBond(4); - (,,,, disputed,,) = gameProxy.claimData(4); - gameProxy.defend{ value: lastBond }(disputed, 4, _changeClaimStatus(ROOT_CLAIM, VMStatuses.VALID)); - - // Expected start/disputed claims - bytes32 startingClaim = bytes32(uint256(3)); - Position startingPos = LibPosition.wrap(4, 0); - bytes32 disputedClaim = bytes32(uint256(2)); - Position disputedPos = LibPosition.wrap(3, 0); - - // Expected local data - bytes32[5] memory data = [ - gameProxy.l1Head().raw(), - startingClaim, - disputedClaim, - bytes32(validL2BlockNumber << 0xC0), - bytes32(gameProxy.l2ChainId() << 0xC0) - ]; - - for (uint256 i = 1; i <= 5; i++) { - uint256 expectedLen = i > 3 ? 8 : 32; - bytes32 key = _getKey(i, keccak256(abi.encode(startingClaim, startingPos, disputedClaim, disputedPos))); - - gameProxy.addLocalData(i, 5, 0); - (bytes32 dat, uint256 datLen) = oracle.readPreimage(key, 0); - assertEq(dat >> 0xC0, bytes32(expectedLen)); - // Account for the length prefix if i > 3 (the data stored at identifiers i <= 3 are - // 32 bytes long, so the expected length is already correct. If i > 3, the data is only - // 8 bytes long, so the length prefix + the data is 16 bytes total.) - assertEq(datLen, expectedLen + (i > 3 ? 8 : 0)); - - gameProxy.addLocalData(i, 5, 8); - (dat, datLen) = oracle.readPreimage(key, 8); - assertEq(dat, data[i - 1]); - assertEq(datLen, expectedLen); - } - } - - /// @notice Tests that the L2 block number claim is favored over the bisected-to block when - /// adding data. - function test_addLocalData_l2BlockNumberExtension_succeeds() public { - // Deploy a new dispute game with a L2 block number claim of 8. This is directly in the - // middle of the leaves in our output bisection test tree, at SPLIT_DEPTH = 2 ** 2 - IFaultDisputeGameV2 game = IFaultDisputeGameV2( - address( - disputeGameFactory.create{ value: initBond }( - GAME_TYPE, Claim.wrap(bytes32(uint256(0xFF))), abi.encode(validL2BlockNumber) - ) - ) - ); - - // Get a claim below the split depth so that we can add local data for an execution trace - // subgame. - { - Claim disputed; - Position parent; - Position pos; - - for (uint256 i; i < 4; i++) { - (,,,,, parent,) = game.claimData(i); - pos = parent.move(true); - uint256 bond = game.getRequiredBond(pos); - - (,,,, disputed,,) = game.claimData(i); - if (i == 0) { - game.attack{ value: bond }(disputed, i, Claim.wrap(bytes32(i))); - } else { - game.defend{ value: bond }(disputed, i, Claim.wrap(bytes32(i))); - } - } - (,,,,, parent,) = game.claimData(4); - pos = parent.move(true); - uint256 lastBond = game.getRequiredBond(pos); - (,,,, disputed,,) = game.claimData(4); - game.defend{ value: lastBond }(disputed, 4, _changeClaimStatus(ROOT_CLAIM, VMStatuses.INVALID)); - } - - // Expected start/disputed claims - bytes32 startingClaim = bytes32(uint256(3)); - Position startingPos = LibPosition.wrap(4, 14); - bytes32 disputedClaim = bytes32(uint256(0xFF)); - Position disputedPos = LibPosition.wrap(0, 0); - - // Expected local data. This should be `l2BlockNumber`, and not the actual bisected-to - // block, as we choose the minimum between the two. - bytes32 expectedNumber = bytes32(validL2BlockNumber << 0xC0); - uint256 expectedLen = 8; - uint256 l2NumberIdent = LocalPreimageKey.DISPUTED_L2_BLOCK_NUMBER; - - // Compute the preimage key for the local data - bytes32 localContext = keccak256(abi.encode(startingClaim, startingPos, disputedClaim, disputedPos)); - bytes32 rawKey = keccak256(abi.encode(l2NumberIdent | (1 << 248), address(game), localContext)); - bytes32 key = bytes32((uint256(rawKey) & ~uint256(0xFF << 248)) | (1 << 248)); - - IPreimageOracle oracle = IPreimageOracle(address(game.vm().oracle())); - game.addLocalData(l2NumberIdent, 5, 0); - - (bytes32 dat, uint256 datLen) = oracle.readPreimage(key, 0); - assertEq(dat >> 0xC0, bytes32(expectedLen)); - assertEq(datLen, expectedLen + 8); - - game.addLocalData(l2NumberIdent, 5, 8); - (dat, datLen) = oracle.readPreimage(key, 8); - assertEq(dat, expectedNumber); - assertEq(datLen, expectedLen); - } -} - -/// @title FaultDisputeGame_ChallengeRootL2Block_Test -/// @notice Tests the challengeRootL2Block functionality of the `FaultDisputeGame` contract. -contract FaultDisputeGameV2_ChallengeRootL2Block_Test is FaultDisputeGameV2_TestInit { - /// @notice Tests that challenging the root claim's L2 block number by providing the real - /// preimage of the output root succeeds. - function testFuzz_challengeRootL2Block_succeeds( - bytes32 _storageRoot, - bytes32 _withdrawalRoot, - uint256 _l2BlockNumber - ) - public - { - _l2BlockNumber = bound(_l2BlockNumber, validL2BlockNumber, type(uint256).max - 1); - - (Types.OutputRootProof memory outputRootProof, bytes32 outputRoot, bytes memory headerRLP) = - _generateOutputRootProof(_storageRoot, _withdrawalRoot, abi.encodePacked(_l2BlockNumber)); - - // Create the dispute game with the output root at the wrong L2 block number. - uint256 wrongL2BlockNumber = bound(vm.randomUint(), _l2BlockNumber + 1, type(uint256).max); - IDisputeGame game = disputeGameFactory.create{ value: initBond }( - GAME_TYPE, Claim.wrap(outputRoot), abi.encode(wrongL2BlockNumber) - ); - - // Challenge the L2 block number. - IFaultDisputeGameV2 fdg = IFaultDisputeGameV2(address(game)); - fdg.challengeRootL2Block(outputRootProof, headerRLP); - - // Ensure that a duplicate challenge reverts. - vm.expectRevert(L2BlockNumberChallenged.selector); - fdg.challengeRootL2Block(outputRootProof, headerRLP); - - // Warp past the clocks, resolve the game. - vm.warp(block.timestamp + 3 days + 12 hours + 1); - fdg.resolveClaim(0, 0); - fdg.resolve(); - - // Ensure the challenge was successful. - assertEq(uint8(fdg.status()), uint8(GameStatus.CHALLENGER_WINS)); - assertTrue(fdg.l2BlockNumberChallenged()); - } - - /// @notice Tests that challenging the root claim's L2 block number by providing the real - /// preimage of the output root succeeds. Also, this claim should always receive the - /// bond when there is another counter that is as far left as possible. - function testFuzz_challengeRootL2Block_receivesBond_succeeds( - bytes32 _storageRoot, - bytes32 _withdrawalRoot, - uint256 _l2BlockNumber - ) - public - { - vm.deal(address(0xb0b), 1 ether); - _l2BlockNumber = bound(_l2BlockNumber, validL2BlockNumber, type(uint256).max - 1); - - (Types.OutputRootProof memory outputRootProof, bytes32 outputRoot, bytes memory headerRLP) = - _generateOutputRootProof(_storageRoot, _withdrawalRoot, abi.encodePacked(_l2BlockNumber)); - - // Create the dispute game with the output root at the wrong L2 block number. - disputeGameFactory.setInitBond(GAME_TYPE, 0.1 ether); - uint256 balanceBefore = address(this).balance; - _l2BlockNumber = bound(vm.randomUint(), _l2BlockNumber + 1, type(uint256).max); - IDisputeGame game = - disputeGameFactory.create{ value: 0.1 ether }(GAME_TYPE, Claim.wrap(outputRoot), abi.encode(_l2BlockNumber)); - IFaultDisputeGameV2 fdg = IFaultDisputeGameV2(address(game)); - - // Attack the root as 0xb0b - uint256 bond = _getRequiredBond(0); - (,,,, Claim disputed,,) = fdg.claimData(0); - vm.prank(address(0xb0b)); - fdg.attack{ value: bond }(disputed, 0, Claim.wrap(0)); - - // Challenge the L2 block number as 0xace. This claim should receive the root claim's bond. - vm.prank(address(0xace)); - fdg.challengeRootL2Block(outputRootProof, headerRLP); - - // Warp past the clocks, resolve the game. - vm.warp(block.timestamp + 3 days + 12 hours + 1); - fdg.resolveClaim(1, 0); - fdg.resolveClaim(0, 0); - fdg.resolve(); - - // Ensure the challenge was successful. - assertEq(uint8(fdg.status()), uint8(GameStatus.CHALLENGER_WINS)); - - // Wait for finalization delay. - vm.warp(block.timestamp + 3.5 days + 1 seconds); - - // Close the game. - fdg.closeGame(); - - // Claim credit once to trigger unlock period. - fdg.claimCredit(address(this)); - fdg.claimCredit(address(0xb0b)); - fdg.claimCredit(address(0xace)); - - // Wait for the withdrawal delay. - vm.warp(block.timestamp + delayedWeth.delay() + 1 seconds); - - // Claim credit - vm.expectRevert(NoCreditToClaim.selector); - fdg.claimCredit(address(this)); - fdg.claimCredit(address(0xb0b)); - fdg.claimCredit(address(0xace)); - - // Ensure that the party who challenged the L2 block number with the special move received - // the bond. - // - Root claim loses their bond - // - 0xace receives the root claim's bond - // - 0xb0b receives their bond back - assertEq(address(this).balance, balanceBefore - 0.1 ether); - assertEq(address(0xb0b).balance, 1 ether); - assertEq(address(0xace).balance, 0.1 ether); - } - - /// @notice Tests that challenging the root claim's L2 block number by providing the real - /// preimage of the output root never succeeds. - function testFuzz_challengeRootL2Block_rightBlockNumber_reverts( - bytes32 _storageRoot, - bytes32 _withdrawalRoot, - uint256 _l2BlockNumber - ) - public - { - _l2BlockNumber = bound(_l2BlockNumber, validL2BlockNumber, type(uint256).max); - - (Types.OutputRootProof memory outputRootProof, bytes32 outputRoot, bytes memory headerRLP) = - _generateOutputRootProof(_storageRoot, _withdrawalRoot, abi.encodePacked(_l2BlockNumber)); - - // Create the dispute game with the output root at the wrong L2 block number. - IDisputeGame game = - disputeGameFactory.create{ value: initBond }(GAME_TYPE, Claim.wrap(outputRoot), abi.encode(_l2BlockNumber)); - - // Challenge the L2 block number. - IFaultDisputeGameV2 fdg = IFaultDisputeGameV2(address(game)); - vm.expectRevert(BlockNumberMatches.selector); - fdg.challengeRootL2Block(outputRootProof, headerRLP); - - // Warp past the clocks, resolve the game. - vm.warp(block.timestamp + 3 days + 12 hours + 1); - fdg.resolveClaim(0, 0); - fdg.resolve(); - - // Ensure the challenge was successful. - assertEq(uint8(fdg.status()), uint8(GameStatus.DEFENDER_WINS)); - } - - /// @notice Tests that challenging the root claim's L2 block number with a bad output root - /// proof reverts. - function test_challengeRootL2Block_badProof_reverts() public { - Types.OutputRootProof memory outputRootProof = - Types.OutputRootProof({ version: 0, stateRoot: 0, messagePasserStorageRoot: 0, latestBlockhash: 0 }); - - vm.expectRevert(InvalidOutputRootProof.selector); - gameProxy.challengeRootL2Block(outputRootProof, hex""); - } - - /// @notice Tests that challenging the root claim's L2 block number with a bad output root - /// proof reverts. - function test_challengeRootL2Block_badHeaderRLP_reverts() public { - Types.OutputRootProof memory outputRootProof = - Types.OutputRootProof({ version: 0, stateRoot: 0, messagePasserStorageRoot: 0, latestBlockhash: 0 }); - bytes32 outputRoot = Hashing.hashOutputRootProof(outputRootProof); - - // Create the dispute game with the output root at the wrong L2 block number. - IDisputeGame game = disputeGameFactory.create{ value: initBond }( - GAME_TYPE, Claim.wrap(outputRoot), abi.encode(validL2BlockNumber) - ); - IFaultDisputeGameV2 fdg = IFaultDisputeGameV2(address(game)); - - vm.expectRevert(InvalidHeaderRLP.selector); - fdg.challengeRootL2Block(outputRootProof, hex""); - } - - /// @notice Tests that challenging the root claim's L2 block number with a bad output root - /// proof reverts. - function test_challengeRootL2Block_badHeaderRLPBlockNumberLength_reverts() public { - (Types.OutputRootProof memory outputRootProof, bytes32 outputRoot,) = - _generateOutputRootProof(0, 0, new bytes(64)); - - // Create the dispute game with the output root at the wrong L2 block number. - IDisputeGame game = disputeGameFactory.create{ value: initBond }( - GAME_TYPE, Claim.wrap(outputRoot), abi.encode(validL2BlockNumber) - ); - IFaultDisputeGameV2 fdg = IFaultDisputeGameV2(address(game)); - - vm.expectRevert(InvalidHeaderRLP.selector); - fdg.challengeRootL2Block(outputRootProof, hex""); - } -} - -/// @title FaultDisputeGame_Resolve_Test -/// @notice Tests the resolve functionality of the `FaultDisputeGame` contract. -contract FaultDisputeGameV2_Resolve_Test is FaultDisputeGameV2_TestInit { - /// @notice Static unit test for the correctness an uncontested root resolution. - function test_resolve_rootUncontested_succeeds() public { - vm.warp(block.timestamp + 3 days + 12 hours); - gameProxy.resolveClaim(0, 0); - assertEq(uint8(gameProxy.resolve()), uint8(GameStatus.DEFENDER_WINS)); - } - - /// @notice Static unit test for the correctness an uncontested root resolution. - function test_resolve_rootUncontestedClockNotExpired_succeeds() public { - vm.warp(block.timestamp + 3 days + 12 hours - 1 seconds); - vm.expectRevert(ClockNotExpired.selector); - gameProxy.resolveClaim(0, 0); - } - - /// @notice Static unit test for the correctness of a multi-part resolution of a single claim. - function test_resolve_multiPart_succeeds() public { - vm.deal(address(this), 10_000 ether); - - uint256 bond = _getRequiredBond(0); - for (uint256 i = 0; i < 2048; i++) { - (,,,, Claim disputed,,) = gameProxy.claimData(0); - gameProxy.attack{ value: bond }(disputed, 0, Claim.wrap(bytes32(i))); - } - - // Warp past the clock period. - vm.warp(block.timestamp + 3 days + 12 hours + 1 seconds); - - // Resolve all children of the root subgame. Every single one of these will be uncontested. - for (uint256 i = 1; i <= 2048; i++) { - gameProxy.resolveClaim(i, 0); - } - - // Resolve the first half of the root claim subgame. - gameProxy.resolveClaim(0, 1024); - - // Fetch the resolution checkpoint for the root subgame and assert correctness. - (bool initCheckpoint, uint32 subgameIndex, Position leftmostPosition, address counteredBy) = - gameProxy.resolutionCheckpoints(0); - assertTrue(initCheckpoint); - assertEq(subgameIndex, 1024); - assertEq(leftmostPosition.raw(), Position.wrap(1).move(true).raw()); - assertEq(counteredBy, address(this)); - - // The root subgame should not be resolved. - assertFalse(gameProxy.resolvedSubgames(0)); - vm.expectRevert(OutOfOrderResolution.selector); - gameProxy.resolve(); - - // Resolve the second half of the root claim subgame. - uint256 numToResolve = gameProxy.getNumToResolve(0); - assertEq(numToResolve, 1024); - gameProxy.resolveClaim(0, numToResolve); - - // Fetch the resolution checkpoint for the root subgame and assert correctness. - (initCheckpoint, subgameIndex, leftmostPosition, counteredBy) = gameProxy.resolutionCheckpoints(0); - assertTrue(initCheckpoint); - assertEq(subgameIndex, 2048); - assertEq(leftmostPosition.raw(), Position.wrap(1).move(true).raw()); - assertEq(counteredBy, address(this)); - - // The root subgame should now be resolved - assertTrue(gameProxy.resolvedSubgames(0)); - assertEq(uint8(gameProxy.resolve()), uint8(GameStatus.CHALLENGER_WINS)); - } - - /// @notice Static unit test asserting that resolve reverts when the absolute root - /// subgame has not been resolved. - function test_resolve_rootUncontestedButUnresolved_reverts() public { - vm.warp(block.timestamp + 3 days + 12 hours); - vm.expectRevert(OutOfOrderResolution.selector); - gameProxy.resolve(); - } - - /// @notice Static unit test asserting that resolve reverts when the game state is - /// not in progress. - function test_resolve_notInProgress_reverts() public { - uint256 chalWins = uint256(GameStatus.CHALLENGER_WINS); - - // Replace the game status in storage. It exists in slot 0 at offset 16. - uint256 slot = uint256(vm.load(address(gameProxy), bytes32(0))); - uint256 offset = 16 << 3; - uint256 mask = 0xFF << offset; - // Replace the byte in the slot value with the challenger wins status. - slot = (slot & ~mask) | (chalWins << offset); - - vm.store(address(gameProxy), bytes32(uint256(0)), bytes32(slot)); - vm.expectRevert(GameNotInProgress.selector); - gameProxy.resolveClaim(0, 0); - } - - /// @notice Static unit test for the correctness of resolving a single attack game state. - function test_resolve_rootContested_succeeds() public { - (,,,, Claim disputed,,) = gameProxy.claimData(0); - gameProxy.attack{ value: _getRequiredBond(0) }(disputed, 0, _dummyClaim()); - - vm.warp(block.timestamp + 3 days + 12 hours); - - gameProxy.resolveClaim(1, 0); - gameProxy.resolveClaim(0, 0); - assertEq(uint8(gameProxy.resolve()), uint8(GameStatus.CHALLENGER_WINS)); - } - - /// @notice Static unit test for the correctness of resolving a game with a contested challenge - /// claim. - function test_resolve_challengeContested_succeeds() public { - (,,,, Claim disputed,,) = gameProxy.claimData(0); - gameProxy.attack{ value: _getRequiredBond(0) }(disputed, 0, _dummyClaim()); - (,,,, disputed,,) = gameProxy.claimData(1); - gameProxy.defend{ value: _getRequiredBond(1) }(disputed, 1, _dummyClaim()); - - vm.warp(block.timestamp + 3 days + 12 hours); - - gameProxy.resolveClaim(2, 0); - gameProxy.resolveClaim(1, 0); - gameProxy.resolveClaim(0, 0); - assertEq(uint8(gameProxy.resolve()), uint8(GameStatus.DEFENDER_WINS)); - } - - /// @notice Static unit test for the correctness of resolving a game with multiplayer moves. - function test_resolve_teamDeathmatch_succeeds() public { - (,,,, Claim disputed,,) = gameProxy.claimData(0); - gameProxy.attack{ value: _getRequiredBond(0) }(disputed, 0, _dummyClaim()); - gameProxy.attack{ value: _getRequiredBond(0) }(disputed, 0, _dummyClaim()); - (,,,, disputed,,) = gameProxy.claimData(1); - gameProxy.defend{ value: _getRequiredBond(1) }(disputed, 1, _dummyClaim()); - gameProxy.defend{ value: _getRequiredBond(1) }(disputed, 1, _dummyClaim()); - - vm.warp(block.timestamp + 3 days + 12 hours); - - gameProxy.resolveClaim(4, 0); - gameProxy.resolveClaim(3, 0); - gameProxy.resolveClaim(2, 0); - gameProxy.resolveClaim(1, 0); - gameProxy.resolveClaim(0, 0); - assertEq(uint8(gameProxy.resolve()), uint8(GameStatus.CHALLENGER_WINS)); - } - - /// @notice Static unit test for the correctness of resolving a game that reaches max game - /// depth. - function test_resolve_stepReached_succeeds() public { - Claim claim = _dummyClaim(); - for (uint256 i; i < gameProxy.splitDepth(); i++) { - (,,,, Claim disputed,,) = gameProxy.claimData(i); - gameProxy.attack{ value: _getRequiredBond(i) }(disputed, i, claim); - } - - claim = _changeClaimStatus(claim, VMStatuses.PANIC); - for (uint256 i = gameProxy.claimDataLen() - 1; i < gameProxy.maxGameDepth(); i++) { - (,,,, Claim disputed,,) = gameProxy.claimData(i); - gameProxy.attack{ value: _getRequiredBond(i) }(disputed, i, claim); - } - - vm.warp(block.timestamp + 3 days + 12 hours); - - for (uint256 i = 9; i > 0; i--) { - gameProxy.resolveClaim(i - 1, 0); - } - assertEq(uint8(gameProxy.resolve()), uint8(GameStatus.DEFENDER_WINS)); - } - - /// @notice Static unit test asserting that resolve reverts when attempting to resolve a - /// subgame multiple times - function test_resolve_claimAlreadyResolved_reverts() public { - Claim claim = _dummyClaim(); - uint256 firstBond = _getRequiredBond(0); - vm.deal(address(this), firstBond); - (,,,, Claim disputed,,) = gameProxy.claimData(0); - gameProxy.attack{ value: firstBond }(disputed, 0, claim); - uint256 secondBond = _getRequiredBond(1); - vm.deal(address(this), secondBond); - (,,,, disputed,,) = gameProxy.claimData(1); - gameProxy.attack{ value: secondBond }(disputed, 1, claim); - - vm.warp(block.timestamp + 3 days + 12 hours); - - gameProxy.resolveClaim(2, 0); - gameProxy.resolveClaim(1, 0); - - vm.expectRevert(ClaimAlreadyResolved.selector); - gameProxy.resolveClaim(1, 0); - } - - /// @notice Static unit test asserting that resolve reverts when attempting to resolve a - /// subgame at max depth - function test_resolve_claimAtMaxDepthAlreadyResolved_reverts() public { - Claim claim = _dummyClaim(); - for (uint256 i; i < gameProxy.splitDepth(); i++) { - (,,,, Claim disputed,,) = gameProxy.claimData(i); - gameProxy.attack{ value: _getRequiredBond(i) }(disputed, i, claim); - } - - vm.deal(address(this), 10000 ether); - claim = _changeClaimStatus(claim, VMStatuses.PANIC); - for (uint256 i = gameProxy.claimDataLen() - 1; i < gameProxy.maxGameDepth(); i++) { - (,,,, Claim disputed,,) = gameProxy.claimData(i); - gameProxy.attack{ value: _getRequiredBond(i) }(disputed, i, claim); - } - - vm.warp(block.timestamp + 3 days + 12 hours); - - gameProxy.resolveClaim(8, 0); - - vm.expectRevert(ClaimAlreadyResolved.selector); - gameProxy.resolveClaim(8, 0); - } - - /// @notice Static unit test asserting that resolve reverts when attempting to resolve - /// subgames out of order - function test_resolve_outOfOrderResolution_reverts() public { - (,,,, Claim disputed,,) = gameProxy.claimData(0); - gameProxy.attack{ value: _getRequiredBond(0) }(disputed, 0, _dummyClaim()); - (,,,, disputed,,) = gameProxy.claimData(1); - gameProxy.attack{ value: _getRequiredBond(1) }(disputed, 1, _dummyClaim()); - - vm.warp(block.timestamp + 3 days + 12 hours); - - vm.expectRevert(OutOfOrderResolution.selector); - gameProxy.resolveClaim(0, 0); - } - - /// @notice Static unit test asserting that resolve pays out bonds on step, output bisection, - /// and execution trace moves. - function test_resolve_bondPayouts_succeeds() public { - // Give the test contract some ether - uint256 bal = 1000 ether; - vm.deal(address(this), bal); - - // Make claims all the way down the tree. - uint256 bond = _getRequiredBond(0); - uint256 totalBonded = bond; - (,,,, Claim disputed,,) = gameProxy.claimData(0); - gameProxy.attack{ value: bond }(disputed, 0, _dummyClaim()); - bond = _getRequiredBond(1); - totalBonded += bond; - (,,,, disputed,,) = gameProxy.claimData(1); - gameProxy.attack{ value: bond }(disputed, 1, _dummyClaim()); - bond = _getRequiredBond(2); - totalBonded += bond; - (,,,, disputed,,) = gameProxy.claimData(2); - gameProxy.attack{ value: bond }(disputed, 2, _dummyClaim()); - bond = _getRequiredBond(3); - totalBonded += bond; - (,,,, disputed,,) = gameProxy.claimData(3); - gameProxy.attack{ value: bond }(disputed, 3, _dummyClaim()); - bond = _getRequiredBond(4); - totalBonded += bond; - (,,,, disputed,,) = gameProxy.claimData(4); - gameProxy.attack{ value: bond }(disputed, 4, _changeClaimStatus(_dummyClaim(), VMStatuses.PANIC)); - bond = _getRequiredBond(5); - totalBonded += bond; - (,,,, disputed,,) = gameProxy.claimData(5); - gameProxy.attack{ value: bond }(disputed, 5, _dummyClaim()); - bond = _getRequiredBond(6); - totalBonded += bond; - (,,,, disputed,,) = gameProxy.claimData(6); - gameProxy.attack{ value: bond }(disputed, 6, _dummyClaim()); - bond = _getRequiredBond(7); - totalBonded += bond; - (,,,, disputed,,) = gameProxy.claimData(7); - gameProxy.attack{ value: bond }(disputed, 7, _dummyClaim()); - gameProxy.addLocalData(LocalPreimageKey.DISPUTED_L2_BLOCK_NUMBER, 8, 0); - gameProxy.step(8, true, absolutePrestateData, hex""); - - // Ensure that the step successfully countered the leaf claim. - (, address counteredBy,,,,,) = gameProxy.claimData(8); - assertEq(counteredBy, address(this)); - - // Ensure we bonded the correct amounts - assertEq(address(this).balance, bal - totalBonded); - assertEq(address(gameProxy).balance, 0); - assertEq(delayedWeth.balanceOf(address(gameProxy)), initBond + totalBonded); - - // Resolve all claims - vm.warp(block.timestamp + 3 days + 12 hours); - for (uint256 i = gameProxy.claimDataLen(); i > 0; i--) { - (bool success,) = address(gameProxy).call(abi.encodeCall(gameProxy.resolveClaim, (i - 1, 0))); - assertTrue(success); - } - gameProxy.resolve(); - - // Wait for finalization delay - vm.warp(block.timestamp + 3.5 days + 1 seconds); - - // Close the game. - gameProxy.closeGame(); - - // Claim credit once to trigger unlock period. - gameProxy.claimCredit(address(this)); - - // Wait for the withdrawal delay. - vm.warp(block.timestamp + delayedWeth.delay() + 1 seconds); - - // Claim credit again to get the bond back. - gameProxy.claimCredit(address(this)); - - // Ensure that bonds were paid out correctly. - assertEq(address(this).balance, bal + initBond); - assertEq(address(gameProxy).balance, 0); - assertEq(delayedWeth.balanceOf(address(gameProxy)), 0); - - // Ensure that the init bond for the game is 0, in case we change it in the test suite in - // the future. - assertEq(disputeGameFactory.initBonds(GAME_TYPE), initBond); - } - - /// @notice Static unit test asserting that resolve pays out bonds on step, output bisection, - /// and execution trace moves with 2 actors and a dishonest root claim. - function test_resolve_bondPayoutsSeveralActors_succeeds() public { - // Give the test contract and bob some ether - // We use the "1000 ether" literal for `bal`, the initial balance, to avoid stack too deep - //uint256 bal = 1000 ether; - address bob = address(0xb0b); - vm.deal(address(this), 1000 ether); - vm.deal(bob, 1000 ether); - - // Make claims all the way down the tree, trading off between bob and the test contract. - uint256 firstBond = _getRequiredBond(0); - uint256 thisBonded = firstBond; - (,,,, Claim disputed,,) = gameProxy.claimData(0); - gameProxy.attack{ value: firstBond }(disputed, 0, _dummyClaim()); - - uint256 secondBond = _getRequiredBond(1); - uint256 bobBonded = secondBond; - (,,,, disputed,,) = gameProxy.claimData(1); - vm.prank(bob); - gameProxy.attack{ value: secondBond }(disputed, 1, _dummyClaim()); - - uint256 thirdBond = _getRequiredBond(2); - thisBonded += thirdBond; - (,,,, disputed,,) = gameProxy.claimData(2); - gameProxy.attack{ value: thirdBond }(disputed, 2, _dummyClaim()); - - uint256 fourthBond = _getRequiredBond(3); - bobBonded += fourthBond; - (,,,, disputed,,) = gameProxy.claimData(3); - vm.prank(bob); - gameProxy.attack{ value: fourthBond }(disputed, 3, _dummyClaim()); - - uint256 fifthBond = _getRequiredBond(4); - thisBonded += fifthBond; - (,,,, disputed,,) = gameProxy.claimData(4); - gameProxy.attack{ value: fifthBond }(disputed, 4, _changeClaimStatus(_dummyClaim(), VMStatuses.PANIC)); - - uint256 sixthBond = _getRequiredBond(5); - bobBonded += sixthBond; - (,,,, disputed,,) = gameProxy.claimData(5); - vm.prank(bob); - gameProxy.attack{ value: sixthBond }(disputed, 5, _dummyClaim()); - - uint256 seventhBond = _getRequiredBond(6); - thisBonded += seventhBond; - (,,,, disputed,,) = gameProxy.claimData(6); - gameProxy.attack{ value: seventhBond }(disputed, 6, _dummyClaim()); - - uint256 eighthBond = _getRequiredBond(7); - bobBonded += eighthBond; - (,,,, disputed,,) = gameProxy.claimData(7); - vm.prank(bob); - gameProxy.attack{ value: eighthBond }(disputed, 7, _dummyClaim()); - - gameProxy.addLocalData(LocalPreimageKey.DISPUTED_L2_BLOCK_NUMBER, 8, 0); - gameProxy.step(8, true, absolutePrestateData, hex""); - - // Ensure that the step successfully countered the leaf claim. - (, address counteredBy,,,,,) = gameProxy.claimData(8); - assertEq(counteredBy, address(this)); - - // Ensure we bonded the correct amounts - assertEq(address(this).balance, 1000 ether - thisBonded); - assertEq(bob.balance, 1000 ether - bobBonded); - assertEq(address(gameProxy).balance, 0); - assertEq(delayedWeth.balanceOf(address(gameProxy)), initBond + thisBonded + bobBonded); - - // Resolve all claims - vm.warp(block.timestamp + 3 days + 12 hours); - for (uint256 i = gameProxy.claimDataLen(); i > 0; i--) { - (bool success,) = address(gameProxy).call(abi.encodeCall(gameProxy.resolveClaim, (i - 1, 0))); - assertTrue(success); - } - - // Resolve the game. - gameProxy.resolve(); - - // Wait for finalization delay - vm.warp(block.timestamp + 3.5 days + 1 seconds); - - // Close the game. - gameProxy.closeGame(); - - // Claim credit once to trigger unlock period. - gameProxy.claimCredit(address(this)); - gameProxy.claimCredit(bob); - - // Wait for the withdrawal delay. - vm.warp(block.timestamp + delayedWeth.delay() + 1 seconds); - - // Claim credit again to get the bond back. - gameProxy.claimCredit(address(this)); - - // Bob's claim should revert since it's value is 0 - vm.expectRevert(NoCreditToClaim.selector); - gameProxy.claimCredit(bob); - - // Ensure that bonds were paid out correctly. - assertEq(address(this).balance, 1000 ether + initBond + bobBonded); - assertEq(bob.balance, 1000 ether - bobBonded); - assertEq(address(gameProxy).balance, 0); - assertEq(delayedWeth.balanceOf(address(gameProxy)), 0); - - // Ensure that the init bond for the game is 0, in case we change it in the test suite in - // the future. - assertEq(disputeGameFactory.initBonds(GAME_TYPE), initBond); - } - - /// @notice Static unit test asserting that resolve pays out bonds on moves to the leftmost - /// actor in subgames containing successful counters. - function test_resolve_leftmostBondPayout_succeeds() public { - uint256 bal = 1000 ether; - address alice = address(0xa11ce); - address bob = address(0xb0b); - address charlie = address(0xc0c); - vm.deal(address(this), bal); - vm.deal(alice, bal); - vm.deal(bob, bal); - vm.deal(charlie, bal); - - // Make claims with bob, charlie and the test contract on defense, and alice as the - // challenger charlie is successfully countered by alice alice is successfully countered by - // both bob and the test contract - uint256 firstBond = _getRequiredBond(0); - (,,,, Claim disputed,,) = gameProxy.claimData(0); - vm.prank(alice); - gameProxy.attack{ value: firstBond }(disputed, 0, _dummyClaim()); - - uint256 secondBond = _getRequiredBond(1); - (,,,, disputed,,) = gameProxy.claimData(1); - vm.prank(bob); - gameProxy.defend{ value: secondBond }(disputed, 1, _dummyClaim()); - vm.prank(charlie); - gameProxy.attack{ value: secondBond }(disputed, 1, _dummyClaim()); - gameProxy.attack{ value: secondBond }(disputed, 1, _dummyClaim()); - - uint256 thirdBond = _getRequiredBond(3); - (,,,, disputed,,) = gameProxy.claimData(3); - vm.prank(alice); - gameProxy.attack{ value: thirdBond }(disputed, 3, _dummyClaim()); - - // Resolve all claims - vm.warp(block.timestamp + 3 days + 12 hours); - for (uint256 i = gameProxy.claimDataLen(); i > 0; i--) { - (bool success,) = address(gameProxy).call(abi.encodeCall(gameProxy.resolveClaim, (i - 1, 0))); - assertTrue(success); - } - gameProxy.resolve(); - - // Wait for finalization delay - vm.warp(block.timestamp + 3.5 days + 1 seconds); - - // Close the game. - gameProxy.closeGame(); - - // Claim credit once to trigger unlock period. - gameProxy.claimCredit(address(this)); - gameProxy.claimCredit(alice); - gameProxy.claimCredit(bob); - gameProxy.claimCredit(charlie); - - // Wait for the withdrawal delay. - vm.warp(block.timestamp + delayedWeth.delay() + 1 seconds); - - // All of these claims should work. - gameProxy.claimCredit(address(this)); - gameProxy.claimCredit(alice); - gameProxy.claimCredit(bob); - - // Charlie's claim should revert since it's value is 0 - vm.expectRevert(NoCreditToClaim.selector); - gameProxy.claimCredit(charlie); - - // Ensure that bonds were paid out correctly. - uint256 aliceLosses = firstBond; - uint256 charlieLosses = secondBond; - assertEq(address(this).balance, bal + aliceLosses + initBond, "incorrect this balance"); - assertEq(alice.balance, bal - aliceLosses + charlieLosses, "incorrect alice balance"); - assertEq(bob.balance, bal, "incorrect bob balance"); - assertEq(charlie.balance, bal - charlieLosses, "incorrect charlie balance"); - assertEq(address(gameProxy).balance, 0); - - // Ensure that the init bond for the game is 0, in case we change it in the test suite in - // the future. - assertEq(disputeGameFactory.initBonds(GAME_TYPE), initBond); - } - - /// @notice Static unit test asserting that the anchor state updates when the game resolves in - /// favor of the defender and the anchor state is older than the game state. - function test_resolve_validNewerStateUpdatesAnchor_succeeds() public { - // Confirm that the anchor state is older than the game state. - (Hash root, uint256 l2BlockNumber) = anchorStateRegistry.anchors(gameProxy.gameType()); - assert(l2BlockNumber < gameProxy.l2BlockNumber()); - - // Resolve the game. - vm.warp(block.timestamp + 3 days + 12 hours); - gameProxy.resolveClaim(0, 0); - assertEq(uint8(gameProxy.resolve()), uint8(GameStatus.DEFENDER_WINS)); - - // Wait for finalization delay. - vm.warp(block.timestamp + 3.5 days + 1 seconds); - - // Close the game. - gameProxy.closeGame(); - - // Confirm that the anchor state is now the same as the game state. - (root, l2BlockNumber) = anchorStateRegistry.anchors(gameProxy.gameType()); - assertEq(l2BlockNumber, gameProxy.l2BlockNumber()); - assertEq(root.raw(), gameProxy.rootClaim().raw()); - } - - /// @notice Static unit test asserting that the anchor state does not change when the game - /// resolves in favor of the defender but the game state is not newer than the anchor - /// state. - function test_resolve_validOlderStateSameAnchor_succeeds() public { - // Mock the game block to be older than the game state. - vm.mockCall(address(gameProxy), abi.encodeCall(gameProxy.l2SequenceNumber, ()), abi.encode(0)); - - // Confirm that the anchor state is newer than the game state. - (Hash root, uint256 l2BlockNumber) = anchorStateRegistry.anchors(gameProxy.gameType()); - assert(l2BlockNumber >= gameProxy.l2SequenceNumber()); - - // Resolve the game. - vm.mockCall(address(gameProxy), abi.encodeCall(gameProxy.l2SequenceNumber, ()), abi.encode(0)); - vm.warp(block.timestamp + 3 days + 12 hours); - gameProxy.resolveClaim(0, 0); - assertEq(uint8(gameProxy.resolve()), uint8(GameStatus.DEFENDER_WINS)); - - // Wait for finalization delay. - vm.warp(block.timestamp + 3.5 days + 1 seconds); - - // Close the game. - gameProxy.closeGame(); - - // Confirm that the anchor state is the same as the initial anchor state. - (Hash updatedRoot, uint256 updatedL2BlockNumber) = anchorStateRegistry.anchors(gameProxy.gameType()); - assertEq(updatedL2BlockNumber, l2BlockNumber); - assertEq(updatedRoot.raw(), root.raw()); - } - - /// @notice Static unit test asserting that the anchor state does not change when the game - /// resolves in favor of the challenger, even if the game state is newer than the - /// anchor state. - function test_resolve_invalidStateSameAnchor_succeeds() public { - // Confirm that the anchor state is older than the game state. - (Hash root, uint256 l2BlockNumber) = anchorStateRegistry.anchors(gameProxy.gameType()); - assert(l2BlockNumber < gameProxy.l2BlockNumber()); - - // Challenge the claim and resolve it. - (,,,, Claim disputed,,) = gameProxy.claimData(0); - gameProxy.attack{ value: _getRequiredBond(0) }(disputed, 0, _dummyClaim()); - vm.warp(block.timestamp + 3 days + 12 hours); - gameProxy.resolveClaim(1, 0); - gameProxy.resolveClaim(0, 0); - assertEq(uint8(gameProxy.resolve()), uint8(GameStatus.CHALLENGER_WINS)); - - // Wait for finalization delay. - vm.warp(block.timestamp + 3.5 days + 1 seconds); - - // Close the game. - gameProxy.closeGame(); - - // Confirm that the anchor state is the same as the initial anchor state. - (Hash updatedRoot, uint256 updatedL2BlockNumber) = anchorStateRegistry.anchors(gameProxy.gameType()); - assertEq(updatedL2BlockNumber, l2BlockNumber); - assertEq(updatedRoot.raw(), root.raw()); - } -} - -/// @title FaultDisputeGame_GameType_Test -/// @notice Tests the `gameType` function of the `FaultDisputeGame` contract. -contract FaultDisputeGameV2_GameType_Test is FaultDisputeGameV2_TestInit { - /// @notice Tests that the game's type is set correctly. - function test_gameType_succeeds() public view { - assertEq(gameProxy.gameType().raw(), GAME_TYPE.raw()); - } -} - -/// @title FaultDisputeGame_RootClaim_Test -/// @notice Tests the `rootClaim` function of the `FaultDisputeGame` contract. -contract FaultDisputeGameV2_RootClaim_Test is FaultDisputeGameV2_TestInit { - /// @notice Tests that the game's root claim is set correctly. - function test_rootClaim_succeeds() public view { - assertEq(gameProxy.rootClaim().raw(), ROOT_CLAIM.raw()); - } -} - -/// @title FaultDisputeGame_ExtraData_Test -/// @notice Tests the `extraData` function of the `FaultDisputeGame` contract. -contract FaultDisputeGameV2_ExtraData_Test is FaultDisputeGameV2_TestInit { - /// @notice Tests that the game's extra data is set correctly. - function test_extraData_succeeds() public view { - assertEq(gameProxy.extraData(), extraData); - } -} - -/// @title FaultDisputeGame_GameData_Test -/// @notice Tests the `gameData` function of the `FaultDisputeGame` contract. -contract FaultDisputeGameV2_GameData_Test is FaultDisputeGameV2_TestInit { - /// @notice Tests that the game's data is set correctly. - function test_gameData_succeeds() public view { - (GameType gameType, Claim rootClaim, bytes memory _extraData) = gameProxy.gameData(); - - assertEq(gameType.raw(), GAME_TYPE.raw()); - assertEq(rootClaim.raw(), ROOT_CLAIM.raw()); - assertEq(_extraData, extraData); - } -} - -/// @title FaultDisputeGame_GetRequiredBond_Test -/// @notice Tests the `getRequiredBond` function of the `FaultDisputeGame` contract. -contract FaultDisputeGameV2_GetRequiredBond_Test is FaultDisputeGameV2_TestInit { - /// @notice Tests that the bond during the bisection game depths is correct. - function test_getRequiredBond_succeeds() public view { - for (uint8 i = 0; i < uint8(gameProxy.splitDepth()); i++) { - Position pos = LibPosition.wrap(i, 0); - uint256 bond = gameProxy.getRequiredBond(pos); - - // Reasonable approximation for a max depth of 8. - uint256 expected = 0.08 ether; - for (uint64 j = 0; j < i; j++) { - expected = expected * 22876; - expected = expected / 10000; - } - - assertApproxEqAbs(bond, expected, 0.01 ether); - } - } - - /// @notice Tests that the bond at a depth greater than the maximum game depth reverts. - function test_getRequiredBond_outOfBounds_reverts() public { - Position pos = LibPosition.wrap(uint8(gameProxy.maxGameDepth() + 1), 0); - vm.expectRevert(GameDepthExceeded.selector); - gameProxy.getRequiredBond(pos); - } -} - -/// @title FaultDisputeGame_ClaimCredit_Test -/// @notice Tests the claimCredit functionality of the `FaultDisputeGame` contract. -contract FaultDisputeGameV2_ClaimCredit_Test is FaultDisputeGameV2_TestInit { - function test_claimCredit_refundMode_succeeds() public { - // Set up actors. - address alice = address(0xa11ce); - address bob = address(0xb0b); - - // Give the game proxy 1 extra ether, unregistered. - vm.deal(address(gameProxy), 1 ether); - - // Perform a bonded move. - Claim claim = _dummyClaim(); - - // Bond the first claim. - uint256 firstBond = _getRequiredBond(0); - vm.deal(alice, firstBond); - (,,,, Claim disputed,,) = gameProxy.claimData(0); - vm.prank(alice); - gameProxy.attack{ value: firstBond }(disputed, 0, claim); - - // Bond the second claim. - uint256 secondBond = _getRequiredBond(1); - vm.deal(bob, secondBond); - (,,,, disputed,,) = gameProxy.claimData(1); - vm.prank(bob); - gameProxy.attack{ value: secondBond }(disputed, 1, claim); - - // Warp past the finalization period - vm.warp(block.timestamp + 3 days + 12 hours); - - // Resolve the game. - // Second claim wins, so bob should get alice's credit. - gameProxy.resolveClaim(2, 0); - gameProxy.resolveClaim(1, 0); - gameProxy.resolveClaim(0, 0); - gameProxy.resolve(); - - // Wait for finalization delay. - vm.warp(block.timestamp + 3.5 days + 1 seconds); - - // Mock that the game proxy is not proper, trigger refund mode. - vm.mockCall( - address(anchorStateRegistry), - abi.encodeCall(anchorStateRegistry.isGameProper, (gameProxy)), - abi.encode(false) - ); - - // Close the game. - gameProxy.closeGame(); - - // Assert bond distribution mode is refund mode. - assertTrue(gameProxy.bondDistributionMode() == BondDistributionMode.REFUND); - - // Claim credit once to trigger unlock period. - gameProxy.claimCredit(alice); - gameProxy.claimCredit(bob); - - // Wait for the withdrawal delay. - vm.warp(block.timestamp + delayedWeth.delay() + 1 seconds); - - // Grab balances before claim. - uint256 aliceBalanceBefore = alice.balance; - uint256 bobBalanceBefore = bob.balance; - - // Claim credit again to get the bond back. - gameProxy.claimCredit(alice); - gameProxy.claimCredit(bob); - - // Should have original balance again. - assertEq(alice.balance, aliceBalanceBefore + firstBond); - assertEq(bob.balance, bobBalanceBefore + secondBond); - } - - /// @notice Tests that claimCredit reverts if the game is paused. - function test_claimCredit_gamePaused_reverts() public { - // Pause the system with the Superchain-wide identifier (address(0)). - vm.prank(superchainConfig.guardian()); - superchainConfig.pause(address(0)); - - // Attempting to claim credit should now revert. - vm.expectRevert(GamePaused.selector); - gameProxy.claimCredit(address(0)); - } - - /// @notice Static unit test asserting that credit may not be drained past allowance through - /// reentrancy. - function test_claimCredit_claimAlreadyResolved_reverts() public { - ClaimCreditReenter reenter = new ClaimCreditReenter(gameProxy, vm); - vm.startPrank(address(reenter)); - - // Give the game proxy 1 extra ether, unregistered. - vm.deal(address(gameProxy), 1 ether); - - // Perform a bonded move. - Claim claim = _dummyClaim(); - uint256 firstBond = _getRequiredBond(0); - vm.deal(address(reenter), firstBond); - (,,,, Claim disputed,,) = gameProxy.claimData(0); - gameProxy.attack{ value: firstBond }(disputed, 0, claim); - uint256 secondBond = _getRequiredBond(1); - vm.deal(address(reenter), secondBond); - (,,,, disputed,,) = gameProxy.claimData(1); - gameProxy.attack{ value: secondBond }(disputed, 1, claim); - uint256 reenterBond = firstBond + secondBond; - - // Warp past the finalization period - vm.warp(block.timestamp + 3 days + 12 hours); - - // Ensure that we bonded all the test contract's ETH - assertEq(address(reenter).balance, 0); - // Ensure the game proxy has 1 ether in it. - assertEq(address(gameProxy).balance, 1 ether); - // Ensure the game has a balance of reenterBond in the delayedWeth contract. - assertEq(delayedWeth.balanceOf(address(gameProxy)), initBond + reenterBond); - - // Resolve the claim at index 2 first so that index 1 can be resolved. - gameProxy.resolveClaim(2, 0); - - // Resolve the claim at index 1 and claim the reenter contract's credit. - gameProxy.resolveClaim(1, 0); - - // Ensure that the game registered the `reenter` contract's credit. - assertEq(gameProxy.credit(address(reenter)), reenterBond); - - // Resolve the root claim. - gameProxy.resolveClaim(0, 0); - - // Resolve the game. - gameProxy.resolve(); - - // Wait for finalization delay. - vm.warp(block.timestamp + 3.5 days + 1 seconds); - - // Close the game. - gameProxy.closeGame(); - - // Claim credit once to trigger unlock period. - gameProxy.claimCredit(address(reenter)); - - // Wait for the withdrawal delay. - vm.warp(block.timestamp + delayedWeth.delay() + 1 seconds); - - // Initiate the reentrant credit claim. - reenter.claimCredit(address(reenter)); - - // The reenter contract should have performed 2 calls to `claimCredit`. - // Once all the credit is claimed, all subsequent calls will revert since there is 0 credit - // left to claim. - // The claimant must only have received the amount bonded for the gindex 1 subgame. - // The root claim bond and the unregistered ETH should still exist in the game proxy. - assertEq(reenter.numCalls(), 2); - assertEq(address(reenter).balance, reenterBond); - assertEq(address(gameProxy).balance, 1 ether); - assertEq(delayedWeth.balanceOf(address(gameProxy)), initBond); - - vm.stopPrank(); - } - - /// @notice Tests that claimCredit reverts when recipient can't receive value. - function test_claimCredit_recipientCantReceiveValue_reverts() public { - // Set up actors. - address alice = address(0xa11ce); - address bob = address(0xb0b); - - // Give the game proxy 1 extra ether, unregistered. - vm.deal(address(gameProxy), 1 ether); - - // Perform a bonded move. - Claim claim = _dummyClaim(); - - // Bond the first claim. - uint256 firstBond = _getRequiredBond(0); - vm.deal(alice, firstBond); - (,,,, Claim disputed,,) = gameProxy.claimData(0); - vm.prank(alice); - gameProxy.attack{ value: firstBond }(disputed, 0, claim); - - // Bond the second claim. - uint256 secondBond = _getRequiredBond(1); - vm.deal(bob, secondBond); - (,,,, disputed,,) = gameProxy.claimData(1); - vm.prank(bob); - gameProxy.attack{ value: secondBond }(disputed, 1, claim); - - // Warp past the finalization period - vm.warp(block.timestamp + 3 days + 12 hours); - - // Resolve the game. - // Second claim wins, so bob should get alice's credit. - gameProxy.resolveClaim(2, 0); - gameProxy.resolveClaim(1, 0); - gameProxy.resolveClaim(0, 0); - gameProxy.resolve(); - - // Wait for finalization delay. - vm.warp(block.timestamp + 3.5 days + 1 seconds); - - // Close the game. - gameProxy.closeGame(); - - // Claim credit once to trigger unlock period. - gameProxy.claimCredit(alice); - gameProxy.claimCredit(bob); - - // Wait for the withdrawal delay. - vm.warp(block.timestamp + delayedWeth.delay() + 1 seconds); - - // Make bob not be able to receive value by setting his contract code to something without - // `receive` - vm.etch(address(bob), address(L1Token).code); - - vm.expectRevert(BondTransferFailed.selector); - gameProxy.claimCredit(address(bob)); - } -} - -/// @title FaultDisputeGame_CloseGame_Test -/// @notice Tests the closeGame functionality of the `FaultDisputeGame` contract. -contract FaultDisputeGameV2_CloseGame_Test is FaultDisputeGameV2_TestInit { - /// @notice Tests that closeGame reverts if the game is not resolved - function test_closeGame_gameNotResolved_reverts() public { - vm.expectRevert(GameNotResolved.selector); - gameProxy.closeGame(); - } - - /// @notice Tests that closeGame reverts if the game is paused - function test_closeGame_gamePaused_reverts() public { - // Pause the system with the Superchain-wide identifier (address(0)). - vm.prank(superchainConfig.guardian()); - superchainConfig.pause(address(0)); - - // Attempting to close the game should now revert. - vm.expectRevert(GamePaused.selector); - gameProxy.closeGame(); - } - - /// @notice Tests that closeGame reverts if the game is not finalized - function test_closeGame_gameNotFinalized_reverts() public { - // Resolve the game - vm.warp(block.timestamp + 3 days + 12 hours); - gameProxy.resolveClaim(0, 0); - gameProxy.resolve(); - - // Don't wait the finalization delay - vm.expectRevert(GameNotFinalized.selector); - gameProxy.closeGame(); - } - - /// @notice Tests that closeGame succeeds for a proper game (normal distribution) - function test_closeGame_properGame_succeeds() public { - // Resolve the game - vm.warp(block.timestamp + 3 days + 12 hours); - gameProxy.resolveClaim(0, 0); - gameProxy.resolve(); - - // Wait for finalization delay - vm.warp(block.timestamp + 3.5 days + 1 seconds); - - // Close the game and verify normal distribution mode - vm.expectEmit(true, true, true, true); - emit GameClosed(BondDistributionMode.NORMAL); - gameProxy.closeGame(); - assertEq(uint8(gameProxy.bondDistributionMode()), uint8(BondDistributionMode.NORMAL)); - - // Check that the anchor state was set correctly. - assertEq(address(gameProxy.anchorStateRegistry().anchorGame()), address(gameProxy)); - } - - /// @notice Tests that closeGame succeeds for an improper game (refund mode) - function test_closeGame_improperGame_succeeds() public { - // Resolve the game - vm.warp(block.timestamp + 3 days + 12 hours); - gameProxy.resolveClaim(0, 0); - gameProxy.resolve(); - - // Wait for finalization delay - vm.warp(block.timestamp + 3.5 days + 1 seconds); - - // Mock the anchor registry to return improper game - vm.mockCall( - address(anchorStateRegistry), - abi.encodeCall(anchorStateRegistry.isGameProper, (IDisputeGame(address(gameProxy)))), - abi.encode(false, "") - ); - - // Close the game and verify refund mode - vm.expectEmit(true, true, true, true); - emit GameClosed(BondDistributionMode.REFUND); - gameProxy.closeGame(); - assertEq(uint8(gameProxy.bondDistributionMode()), uint8(BondDistributionMode.REFUND)); - } - - /// @notice Tests that multiple calls to closeGame succeed after initial distribution mode is - /// set - function test_closeGame_multipleCallsAfterSet_succeeds() public { - // Resolve and close the game first - vm.warp(block.timestamp + 3 days + 12 hours); - gameProxy.resolveClaim(0, 0); - gameProxy.resolve(); - - // Wait for finalization delay - vm.warp(block.timestamp + 3.5 days + 1 seconds); - - // First close sets the mode - gameProxy.closeGame(); - assertEq(uint8(gameProxy.bondDistributionMode()), uint8(BondDistributionMode.NORMAL)); - - // Subsequent closes should succeed without changing the mode - gameProxy.closeGame(); - assertEq(uint8(gameProxy.bondDistributionMode()), uint8(BondDistributionMode.NORMAL)); - - gameProxy.closeGame(); - assertEq(uint8(gameProxy.bondDistributionMode()), uint8(BondDistributionMode.NORMAL)); - } - - /// @notice Tests that closeGame called with any amount of gas either reverts (with OOG) or - /// updates the anchor state. This is specifically to verify that the try/catch inside - /// closeGame can't be called with just enough gas to OOG when calling the - /// AnchorStateRegistry but successfully execute the remainder of the function. - /// @param _gas Amount of gas to provide to closeGame. - function testFuzz_closeGame_canUpdateAnchorStateAndDoes_succeeds(uint256 _gas) public { - // Resolve and close the game first - vm.warp(block.timestamp + 3 days + 12 hours); - gameProxy.resolveClaim(0, 0); - gameProxy.resolve(); - - // Wait for finalization delay - vm.warp(block.timestamp + 3.5 days + 1 seconds); - - // Since providing *too* much gas isn't the issue here, bounding it to half the block gas - // limit is sufficient. We want to know that either (1) the function reverts or (2) the - // anchor state gets updated. If the function doesn't revert and the anchor state isn't - // updated then we have a problem. - _gas = bound(_gas, 0, block.gaslimit / 2); - - // The anchor state should not be the game proxy. - assert(address(gameProxy.anchorStateRegistry().anchorGame()) != address(gameProxy)); - - // Try closing the game. - try gameProxy.closeGame{ gas: _gas }() { - // If we got here, the function didn't revert, so the anchor state should have updated. - assert(address(gameProxy.anchorStateRegistry().anchorGame()) == address(gameProxy)); - } catch { - // Ok, function reverted. - } - } -} - -/// @title FaultDisputeGame_GetChallengerDuration_Test -/// @notice Tests the getChallengerDuration functionality and related resolution tests. -contract FaultDisputeGameV2_GetChallengerDuration_Test is FaultDisputeGameV2_TestInit { - /// @notice Tests that if the game is not in progress, querying of `getChallengerDuration` - /// reverts - function test_getChallengerDuration_gameNotInProgress_reverts() public { - // resolve the game - vm.warp(block.timestamp + gameProxy.maxClockDuration().raw()); - - gameProxy.resolveClaim(0, 0); - gameProxy.resolve(); - - vm.expectRevert(GameNotInProgress.selector); - gameProxy.getChallengerDuration(1); - } - - /// @notice Static unit test asserting that resolveClaim isn't possible if there's time left - /// for a counter. - function test_resolution_lastSecondDisputes_succeeds() public { - // The honest proposer created an honest root claim during setup - node 0 - - // Defender's turn - vm.warp(block.timestamp + 3.5 days - 1 seconds); - (,,,, Claim disputed,,) = gameProxy.claimData(0); - gameProxy.attack{ value: _getRequiredBond(0) }(disputed, 0, _dummyClaim()); - // Chess clock time accumulated: - assertEq(gameProxy.getChallengerDuration(0).raw(), 3.5 days - 1 seconds); - assertEq(gameProxy.getChallengerDuration(1).raw(), 0); - - // Advance time by 1 second, so that the root claim challenger clock is expired. - vm.warp(block.timestamp + 1 seconds); - // Attempt a second attack against the root claim. This should revert since the challenger - // clock is expired. - uint256 expectedBond = _getRequiredBond(0); - vm.expectRevert(ClockTimeExceeded.selector); - gameProxy.attack{ value: expectedBond }(disputed, 0, _dummyClaim()); - // Chess clock time accumulated: - assertEq(gameProxy.getChallengerDuration(0).raw(), 3.5 days); - assertEq(gameProxy.getChallengerDuration(1).raw(), 1 seconds); - - // Should not be able to resolve the root claim or second counter yet. - vm.expectRevert(ClockNotExpired.selector); - gameProxy.resolveClaim(1, 0); - vm.expectRevert(OutOfOrderResolution.selector); - gameProxy.resolveClaim(0, 0); - - // Warp to the last second of the root claim defender clock. - vm.warp(block.timestamp + 3.5 days - 2 seconds); - // Attack the challenge to the root claim. This should succeed, since the defender clock is - // not expired. - (,,,, disputed,,) = gameProxy.claimData(1); - gameProxy.attack{ value: _getRequiredBond(1) }(disputed, 1, _dummyClaim()); - // Chess clock time accumulated: - assertEq(gameProxy.getChallengerDuration(0).raw(), 3.5 days); - assertEq(gameProxy.getChallengerDuration(1).raw(), 3.5 days - 1 seconds); - assertEq(gameProxy.getChallengerDuration(2).raw(), 3.5 days - gameProxy.clockExtension().raw()); - - // Should not be able to resolve any claims yet. - vm.expectRevert(ClockNotExpired.selector); - gameProxy.resolveClaim(2, 0); - vm.expectRevert(ClockNotExpired.selector); - gameProxy.resolveClaim(1, 0); - vm.expectRevert(OutOfOrderResolution.selector); - gameProxy.resolveClaim(0, 0); - - vm.warp(block.timestamp + gameProxy.clockExtension().raw() - 1 seconds); - - // Should not be able to resolve any claims yet. - vm.expectRevert(ClockNotExpired.selector); - gameProxy.resolveClaim(2, 0); - vm.expectRevert(OutOfOrderResolution.selector); - gameProxy.resolveClaim(1, 0); - vm.expectRevert(OutOfOrderResolution.selector); - gameProxy.resolveClaim(0, 0); - - // Chess clock time accumulated: - assertEq(gameProxy.getChallengerDuration(0).raw(), 3.5 days); - assertEq(gameProxy.getChallengerDuration(1).raw(), 3.5 days); - assertEq(gameProxy.getChallengerDuration(2).raw(), 3.5 days - 1 seconds); - - // Warp past the challenge period for the root claim defender. Defending the root claim - // should now revert. - vm.warp(block.timestamp + 1 seconds); - expectedBond = _getRequiredBond(1); - vm.expectRevert(ClockTimeExceeded.selector); // no further move can be made - gameProxy.attack{ value: expectedBond }(disputed, 1, _dummyClaim()); - expectedBond = _getRequiredBond(2); - (,,,, disputed,,) = gameProxy.claimData(2); - vm.expectRevert(ClockTimeExceeded.selector); // no further move can be made - gameProxy.attack{ value: expectedBond }(disputed, 2, _dummyClaim()); - // Chess clock time accumulated: - assertEq(gameProxy.getChallengerDuration(0).raw(), 3.5 days); - assertEq(gameProxy.getChallengerDuration(1).raw(), 3.5 days); - assertEq(gameProxy.getChallengerDuration(2).raw(), 3.5 days); - - vm.expectRevert(OutOfOrderResolution.selector); - gameProxy.resolveClaim(1, 0); - vm.expectRevert(OutOfOrderResolution.selector); - gameProxy.resolveClaim(0, 0); - - // All clocks are expired. Resolve the game. - gameProxy.resolveClaim(2, 0); // Node 2 is resolved as UNCOUNTERED by default since it has no children - gameProxy.resolveClaim(1, 0); // Node 1 is resolved as COUNTERED since it has an UNCOUNTERED child - gameProxy.resolveClaim(0, 0); // Node 0 is resolved as UNCOUNTERED since it has no UNCOUNTERED children - - // Defender wins game since the root claim is uncountered - assertEq(uint8(gameProxy.resolve()), uint8(GameStatus.DEFENDER_WINS)); - } -} - -/// @title FaultDisputeGameV2_Uncategorized_Test -/// @notice General tests that are not testing any function directly of the `FaultDisputeGame` -/// contract or are testing multiple functions at once. -contract FaultDisputeGameV2_Uncategorized_Test is FaultDisputeGameV2_TestInit { - /// @notice Tests that the game's starting timestamp is set correctly. - function test_createdAt_succeeds() public view { - assertEq(gameProxy.createdAt().raw(), block.timestamp); - } - - /// @notice Tests that startingOutputRoot and it's getters are set correctly. - function test_startingOutputRootGetters_succeeds() public view { - (Hash root, uint256 l2BlockNumber) = gameProxy.startingOutputRoot(); - (Hash anchorRoot, uint256 anchorRootBlockNumber) = anchorStateRegistry.anchors(GAME_TYPE); - - assertEq(gameProxy.startingBlockNumber(), l2BlockNumber); - assertEq(gameProxy.startingBlockNumber(), anchorRootBlockNumber); - assertEq(Hash.unwrap(gameProxy.startingRootHash()), Hash.unwrap(root)); - assertEq(Hash.unwrap(gameProxy.startingRootHash()), Hash.unwrap(anchorRoot)); - } - - /// @notice Tests that the user cannot control the first 4 bytes of the CWIA data, disallowing - /// them to control the entrypoint when no calldata is provided to a call. - function test_cwiaCalldata_userCannotControlSelector_succeeds() public { - // Construct the expected CWIA data that the proxy will pass to the implementation, - // alongside any extra calldata passed by the user. - Hash l1Head = gameProxy.l1Head(); - bytes memory cwiaData = abi.encodePacked(address(this), gameProxy.rootClaim(), l1Head, gameProxy.extraData()); - - // We expect a `ReceiveETH` event to be emitted when 0 bytes of calldata are sent; The - // fallback is always reached *within the minimal proxy* in `LibClone`'s version of - // `clones-with-immutable-args` - vm.expectEmit(false, false, false, true); - emit ReceiveETH(0); - // We expect no delegatecall to the implementation contract if 0 bytes are sent. Assert - // that this happens 0 times. - vm.expectCall(address(gameImpl), cwiaData, 0); - (bool successA,) = address(gameProxy).call(hex""); - assertTrue(successA); - - // When calldata is forwarded, we do expect a delegatecall to the implementation. - bytes memory data = abi.encodePacked(gameProxy.l1Head.selector); - vm.expectCall(address(gameImpl), abi.encodePacked(data, cwiaData), 1); - (bool successB, bytes memory returnData) = address(gameProxy).call(data); - assertTrue(successB); - assertEq(returnData, abi.encode(l1Head)); - } -} - -contract FaultDispute_1v1_Actors_Test is FaultDisputeGameV2_TestInit { - /// @notice The honest actor - DisputeActor internal honest; - /// @notice The dishonest actor - DisputeActor internal dishonest; - - function setUp() public override { - // Setup the `FaultDisputeGame` - super.setUp(); - } - - /// @notice Fuzz test for a 1v1 output bisection dispute. - /// @notice The alphabet game has a constant status byte, and is not safe from someone being - /// dishonest in output bisection and then posting a correct execution trace bisection - /// root claim. This test does not cover this case (i.e. root claim of output bisection - /// is dishonest, root claim of execution trace bisection is made by the dishonest - /// actor but is honest, honest actor cannot attack it without risk of losing). - function testFuzz_outputBisection1v1honestRoot_succeeds(uint8 _divergeOutput, uint8 _divergeStep) public { - uint256[] memory honestL2Outputs = new uint256[](16); - for (uint256 i; i < honestL2Outputs.length; i++) { - honestL2Outputs[i] = i + 1; - } - bytes memory honestTrace = new bytes(256); - for (uint256 i; i < honestTrace.length; i++) { - honestTrace[i] = bytes1(uint8(i)); - } - - uint256 divergeAtOutput = bound(_divergeOutput, 0, 15); - uint256 divergeAtStep = bound(_divergeStep, 0, 7); - uint256 divergeStepOffset = (divergeAtOutput << 4) + divergeAtStep; - - uint256[] memory dishonestL2Outputs = new uint256[](16); - for (uint256 i; i < dishonestL2Outputs.length; i++) { - dishonestL2Outputs[i] = i >= divergeAtOutput ? 0xFF : i + 1; - } - bytes memory dishonestTrace = new bytes(256); - for (uint256 i; i < dishonestTrace.length; i++) { - dishonestTrace[i] = i >= divergeStepOffset ? bytes1(uint8(0xFF)) : bytes1(uint8(i)); - } - - // Run the actor test - _actorTest({ - _rootClaim: 16, - _absolutePrestateData: 0, - _honestTrace: honestTrace, - _honestL2Outputs: honestL2Outputs, - _dishonestTrace: dishonestTrace, - _dishonestL2Outputs: dishonestL2Outputs, - _expectedStatus: GameStatus.DEFENDER_WINS - }); - } - - /// @notice Static unit test for a 1v1 output bisection dispute. - function test_static_1v1honestRootGenesisAbsolutePrestate_succeeds() public { - // The honest l2 outputs are from [1, 16] in this game. - uint256[] memory honestL2Outputs = new uint256[](16); - for (uint256 i; i < honestL2Outputs.length; i++) { - honestL2Outputs[i] = i + 1; - } - // The honest trace covers all block -> block + 1 transitions, and is 256 bytes long, - // consisting of bytes [0, 255]. - bytes memory honestTrace = new bytes(256); - for (uint256 i; i < honestTrace.length; i++) { - honestTrace[i] = bytes1(uint8(i)); - } - - // The dishonest l2 outputs are from [2, 17] in this game. - uint256[] memory dishonestL2Outputs = new uint256[](16); - for (uint256 i; i < dishonestL2Outputs.length; i++) { - dishonestL2Outputs[i] = i + 2; - } - // The dishonest trace covers all block -> block + 1 transitions, and is 256 bytes long, - // consisting of all set bits. - bytes memory dishonestTrace = new bytes(256); - for (uint256 i; i < dishonestTrace.length; i++) { - dishonestTrace[i] = bytes1(0xFF); - } - - // Run the actor test - _actorTest({ - _rootClaim: 16, - _absolutePrestateData: 0, - _honestTrace: honestTrace, - _honestL2Outputs: honestL2Outputs, - _dishonestTrace: dishonestTrace, - _dishonestL2Outputs: dishonestL2Outputs, - _expectedStatus: GameStatus.DEFENDER_WINS - }); - } - - /// @notice Static unit test for a 1v1 output bisection dispute. - function test_static_1v1dishonestRootGenesisAbsolutePrestate_succeeds() public { - // The honest l2 outputs are from [1, 16] in this game. - uint256[] memory honestL2Outputs = new uint256[](16); - for (uint256 i; i < honestL2Outputs.length; i++) { - honestL2Outputs[i] = i + 1; - } - // The honest trace covers all block -> block + 1 transitions, and is 256 bytes long, - // consisting of bytes [0, 255]. - bytes memory honestTrace = new bytes(256); - for (uint256 i; i < honestTrace.length; i++) { - honestTrace[i] = bytes1(uint8(i)); - } - - // The dishonest l2 outputs are from [2, 17] in this game. - uint256[] memory dishonestL2Outputs = new uint256[](16); - for (uint256 i; i < dishonestL2Outputs.length; i++) { - dishonestL2Outputs[i] = i + 2; - } - // The dishonest trace covers all block -> block + 1 transitions, and is 256 bytes long, consisting - // of all set bits. - bytes memory dishonestTrace = new bytes(256); - for (uint256 i; i < dishonestTrace.length; i++) { - dishonestTrace[i] = bytes1(0xFF); - } - - // Run the actor test - _actorTest({ - _rootClaim: 17, - _absolutePrestateData: 0, - _honestTrace: honestTrace, - _honestL2Outputs: honestL2Outputs, - _dishonestTrace: dishonestTrace, - _dishonestL2Outputs: dishonestL2Outputs, - _expectedStatus: GameStatus.CHALLENGER_WINS - }); - } - - /// @notice Static unit test for a 1v1 output bisection dispute. - function test_static_1v1honestRoot_succeeds() public { - // The honest l2 outputs are from [1, 16] in this game. - uint256[] memory honestL2Outputs = new uint256[](16); - for (uint256 i; i < honestL2Outputs.length; i++) { - honestL2Outputs[i] = i + 1; - } - // The honest trace covers all block -> block + 1 transitions, and is 256 bytes long, consisting - // of bytes [0, 255]. - bytes memory honestTrace = new bytes(256); - for (uint256 i; i < honestTrace.length; i++) { - honestTrace[i] = bytes1(uint8(i)); - } - - // The dishonest l2 outputs are from [2, 17] in this game. - uint256[] memory dishonestL2Outputs = new uint256[](16); - for (uint256 i; i < dishonestL2Outputs.length; i++) { - dishonestL2Outputs[i] = i + 2; - } - // The dishonest trace covers all block -> block + 1 transitions, and is 256 bytes long, - // consisting of all zeros. - bytes memory dishonestTrace = new bytes(256); - - // Run the actor test - _actorTest({ - _rootClaim: 16, - _absolutePrestateData: 0, - _honestTrace: honestTrace, - _honestL2Outputs: honestL2Outputs, - _dishonestTrace: dishonestTrace, - _dishonestL2Outputs: dishonestL2Outputs, - _expectedStatus: GameStatus.DEFENDER_WINS - }); - } - - /// @notice Static unit test for a 1v1 output bisection dispute. - function test_static_1v1dishonestRoot_succeeds() public { - // The honest l2 outputs are from [1, 16] in this game. - uint256[] memory honestL2Outputs = new uint256[](16); - for (uint256 i; i < honestL2Outputs.length; i++) { - honestL2Outputs[i] = i + 1; - } - // The honest trace covers all block -> block + 1 transitions, and is 256 bytes long, - // consisting of bytes [0, 255]. - bytes memory honestTrace = new bytes(256); - for (uint256 i; i < honestTrace.length; i++) { - honestTrace[i] = bytes1(uint8(i)); - } - - // The dishonest l2 outputs are from [2, 17] in this game. - uint256[] memory dishonestL2Outputs = new uint256[](16); - for (uint256 i; i < dishonestL2Outputs.length; i++) { - dishonestL2Outputs[i] = i + 2; - } - // The dishonest trace covers all block -> block + 1 transitions, and is 256 bytes long, - // consisting of all zeros. - bytes memory dishonestTrace = new bytes(256); - - // Run the actor test - _actorTest({ - _rootClaim: 17, - _absolutePrestateData: 0, - _honestTrace: honestTrace, - _honestL2Outputs: honestL2Outputs, - _dishonestTrace: dishonestTrace, - _dishonestL2Outputs: dishonestL2Outputs, - _expectedStatus: GameStatus.CHALLENGER_WINS - }); - } - - /// @notice Static unit test for a 1v1 output bisection dispute. - function test_static_1v1correctRootHalfWay_succeeds() public { - // The honest l2 outputs are from [1, 16] in this game. - uint256[] memory honestL2Outputs = new uint256[](16); - for (uint256 i; i < honestL2Outputs.length; i++) { - honestL2Outputs[i] = i + 1; - } - // The honest trace covers all block -> block + 1 transitions, and is 256 bytes long, - // consisting of bytes [0, 255]. - bytes memory honestTrace = new bytes(256); - for (uint256 i; i < honestTrace.length; i++) { - honestTrace[i] = bytes1(uint8(i)); - } - - // The dishonest l2 outputs are half correct, half incorrect. - uint256[] memory dishonestL2Outputs = new uint256[](16); - for (uint256 i; i < dishonestL2Outputs.length; i++) { - dishonestL2Outputs[i] = i > 7 ? 0xFF : i + 1; - } - // The dishonest trace is half correct, half incorrect. - bytes memory dishonestTrace = new bytes(256); - for (uint256 i; i < dishonestTrace.length; i++) { - dishonestTrace[i] = i > (127 + 4) ? bytes1(0xFF) : bytes1(uint8(i)); - } - - // Run the actor test - _actorTest({ - _rootClaim: 16, - _absolutePrestateData: 0, - _honestTrace: honestTrace, - _honestL2Outputs: honestL2Outputs, - _dishonestTrace: dishonestTrace, - _dishonestL2Outputs: dishonestL2Outputs, - _expectedStatus: GameStatus.DEFENDER_WINS - }); - } - - /// @notice Static unit test for a 1v1 output bisection dispute. - function test_static_1v1dishonestRootHalfWay_succeeds() public { - // The honest l2 outputs are from [1, 16] in this game. - uint256[] memory honestL2Outputs = new uint256[](16); - for (uint256 i; i < honestL2Outputs.length; i++) { - honestL2Outputs[i] = i + 1; - } - // The honest trace covers all block -> block + 1 transitions, and is 256 bytes long, - // consisting of bytes [0, 255]. - bytes memory honestTrace = new bytes(256); - for (uint256 i; i < honestTrace.length; i++) { - honestTrace[i] = bytes1(uint8(i)); - } - - // The dishonest l2 outputs are half correct, half incorrect. - uint256[] memory dishonestL2Outputs = new uint256[](16); - for (uint256 i; i < dishonestL2Outputs.length; i++) { - dishonestL2Outputs[i] = i > 7 ? 0xFF : i + 1; - } - // The dishonest trace is half correct, half incorrect. - bytes memory dishonestTrace = new bytes(256); - for (uint256 i; i < dishonestTrace.length; i++) { - dishonestTrace[i] = i > (127 + 4) ? bytes1(0xFF) : bytes1(uint8(i)); - } - - // Run the actor test - _actorTest({ - _rootClaim: 0xFF, - _absolutePrestateData: 0, - _honestTrace: honestTrace, - _honestL2Outputs: honestL2Outputs, - _dishonestTrace: dishonestTrace, - _dishonestL2Outputs: dishonestL2Outputs, - _expectedStatus: GameStatus.CHALLENGER_WINS - }); - } - - /// @notice Static unit test for a 1v1 output bisection dispute. - function test_static_1v1correctAbsolutePrestate_succeeds() public { - // The honest l2 outputs are from [1, 16] in this game. - uint256[] memory honestL2Outputs = new uint256[](16); - for (uint256 i; i < honestL2Outputs.length; i++) { - honestL2Outputs[i] = i + 1; - } - // The honest trace covers all block -> block + 1 transitions, and is 256 bytes long, - // consisting of bytes [0, 255]. - bytes memory honestTrace = new bytes(256); - for (uint256 i; i < honestTrace.length; i++) { - honestTrace[i] = bytes1(uint8(i)); - } - - // The dishonest l2 outputs are half correct, half incorrect. - uint256[] memory dishonestL2Outputs = new uint256[](16); - for (uint256 i; i < dishonestL2Outputs.length; i++) { - dishonestL2Outputs[i] = i > 7 ? 0xFF : i + 1; - } - // The dishonest trace correct is half correct, half incorrect. - bytes memory dishonestTrace = new bytes(256); - for (uint256 i; i < dishonestTrace.length; i++) { - dishonestTrace[i] = i > 127 ? bytes1(0xFF) : bytes1(uint8(i)); - } - - // Run the actor test - _actorTest({ - _rootClaim: 16, - _absolutePrestateData: 0, - _honestTrace: honestTrace, - _honestL2Outputs: honestL2Outputs, - _dishonestTrace: dishonestTrace, - _dishonestL2Outputs: dishonestL2Outputs, - _expectedStatus: GameStatus.DEFENDER_WINS - }); - } - - /// @notice Static unit test for a 1v1 output bisection dispute. - function test_static_1v1dishonestAbsolutePrestate_succeeds() public { - // The honest l2 outputs are from [1, 16] in this game. - uint256[] memory honestL2Outputs = new uint256[](16); - for (uint256 i; i < honestL2Outputs.length; i++) { - honestL2Outputs[i] = i + 1; - } - // The honest trace covers all block -> block + 1 transitions, and is 256 bytes long, - // consisting of bytes [0, 255]. - bytes memory honestTrace = new bytes(256); - for (uint256 i; i < honestTrace.length; i++) { - honestTrace[i] = bytes1(uint8(i)); - } - - // The dishonest l2 outputs are half correct, half incorrect. - uint256[] memory dishonestL2Outputs = new uint256[](16); - for (uint256 i; i < dishonestL2Outputs.length; i++) { - dishonestL2Outputs[i] = i > 7 ? 0xFF : i + 1; - } - // The dishonest trace correct is half correct, half incorrect. - bytes memory dishonestTrace = new bytes(256); - for (uint256 i; i < dishonestTrace.length; i++) { - dishonestTrace[i] = i > 127 ? bytes1(0xFF) : bytes1(uint8(i)); - } - - // Run the actor test - _actorTest({ - _rootClaim: 0xFF, - _absolutePrestateData: 0, - _honestTrace: honestTrace, - _honestL2Outputs: honestL2Outputs, - _dishonestTrace: dishonestTrace, - _dishonestL2Outputs: dishonestL2Outputs, - _expectedStatus: GameStatus.CHALLENGER_WINS - }); - } - - /// @notice Static unit test for a 1v1 output bisection dispute. - function test_static_1v1honestRootFinalInstruction_succeeds() public { - // The honest l2 outputs are from [1, 16] in this game. - uint256[] memory honestL2Outputs = new uint256[](16); - for (uint256 i; i < honestL2Outputs.length; i++) { - honestL2Outputs[i] = i + 1; - } - // The honest trace covers all block -> block + 1 transitions, and is 256 bytes long, - // consisting of bytes [0, 255]. - bytes memory honestTrace = new bytes(256); - for (uint256 i; i < honestTrace.length; i++) { - honestTrace[i] = bytes1(uint8(i)); - } - - // The dishonest l2 outputs are half correct, half incorrect. - uint256[] memory dishonestL2Outputs = new uint256[](16); - for (uint256 i; i < dishonestL2Outputs.length; i++) { - dishonestL2Outputs[i] = i > 7 ? 0xFF : i + 1; - } - // The dishonest trace is half correct, and correct all the way up to the final instruction - // of the exec subgame. - bytes memory dishonestTrace = new bytes(256); - for (uint256 i; i < dishonestTrace.length; i++) { - dishonestTrace[i] = i > (127 + 7) ? bytes1(0xFF) : bytes1(uint8(i)); - } - - // Run the actor test - _actorTest({ - _rootClaim: 16, - _absolutePrestateData: 0, - _honestTrace: honestTrace, - _honestL2Outputs: honestL2Outputs, - _dishonestTrace: dishonestTrace, - _dishonestL2Outputs: dishonestL2Outputs, - _expectedStatus: GameStatus.DEFENDER_WINS - }); - } - - /// @notice Static unit test for a 1v1 output bisection dispute. - function test_static_1v1dishonestRootFinalInstruction_succeeds() public { - // The honest l2 outputs are from [1, 16] in this game. - uint256[] memory honestL2Outputs = new uint256[](16); - for (uint256 i; i < honestL2Outputs.length; i++) { - honestL2Outputs[i] = i + 1; - } - // The honest trace covers all block -> block + 1 transitions, and is 256 bytes long, - // consisting of bytes [0, 255]. - bytes memory honestTrace = new bytes(256); - for (uint256 i; i < honestTrace.length; i++) { - honestTrace[i] = bytes1(uint8(i)); - } - - // The dishonest l2 outputs are half correct, half incorrect. - uint256[] memory dishonestL2Outputs = new uint256[](16); - for (uint256 i; i < dishonestL2Outputs.length; i++) { - dishonestL2Outputs[i] = i > 7 ? 0xFF : i + 1; - } - // The dishonest trace is half correct, and correct all the way up to the final instruction - // of the exec subgame. - bytes memory dishonestTrace = new bytes(256); - for (uint256 i; i < dishonestTrace.length; i++) { - dishonestTrace[i] = i > (127 + 7) ? bytes1(0xFF) : bytes1(uint8(i)); - } - - // Run the actor test - _actorTest({ - _rootClaim: 0xFF, - _absolutePrestateData: 0, - _honestTrace: honestTrace, - _honestL2Outputs: honestL2Outputs, - _dishonestTrace: dishonestTrace, - _dishonestL2Outputs: dishonestL2Outputs, - _expectedStatus: GameStatus.CHALLENGER_WINS - }); - } - - //////////////////////////////////////////////////////////////// - // HELPERS // - //////////////////////////////////////////////////////////////// - - /// @notice Helper to run a 1v1 actor test - function _actorTest( - uint256 _rootClaim, - uint256 _absolutePrestateData, - bytes memory _honestTrace, - uint256[] memory _honestL2Outputs, - bytes memory _dishonestTrace, - uint256[] memory _dishonestL2Outputs, - GameStatus _expectedStatus - ) - internal - { - if (isForkTest()) { - // Mock the call anchorStateRegistry.getAnchorRoot() to return 0 as the block number - (Hash root,) = anchorStateRegistry.getAnchorRoot(); - vm.mockCall( - address(anchorStateRegistry), - abi.encodeCall(IAnchorStateRegistry.getAnchorRoot, ()), - abi.encode(root, 0) - ); - } - - // Setup the environment - bytes memory absolutePrestateData = - _setup({ _absolutePrestateData: _absolutePrestateData, _rootClaim: _rootClaim }); - - // Create actors - _createActors({ - _honestTrace: _honestTrace, - _honestPreStateData: absolutePrestateData, - _honestL2Outputs: _honestL2Outputs, - _dishonestTrace: _dishonestTrace, - _dishonestPreStateData: absolutePrestateData, - _dishonestL2Outputs: _dishonestL2Outputs - }); - - // Exhaust all moves from both actors - _exhaustMoves(); - - // Resolve the game and assert that the defender won - _warpAndResolve(); - assertEq(uint8(gameProxy.status()), uint8(_expectedStatus)); - } - - /// @notice Helper to setup the 1v1 test - function _setup( - uint256 _absolutePrestateData, - uint256 _rootClaim - ) - internal - returns (bytes memory absolutePrestateData_) - { - absolutePrestateData_ = abi.encode(_absolutePrestateData); - Claim absolutePrestateExec = - _changeClaimStatus(Claim.wrap(keccak256(absolutePrestateData_)), VMStatuses.UNFINISHED); - Claim rootClaim = Claim.wrap(bytes32(uint256(_rootClaim))); - super.init({ rootClaim: rootClaim, absolutePrestate: absolutePrestateExec, l2BlockNumber: _rootClaim }); - } - - /// @notice Helper to create actors for the 1v1 dispute. - function _createActors( - bytes memory _honestTrace, - bytes memory _honestPreStateData, - uint256[] memory _honestL2Outputs, - bytes memory _dishonestTrace, - bytes memory _dishonestPreStateData, - uint256[] memory _dishonestL2Outputs - ) - internal - { - honest = new HonestDisputeActor({ - _gameProxy: IFaultDisputeGame(address(gameProxy)), - _l2Outputs: _honestL2Outputs, - _trace: _honestTrace, - _preStateData: _honestPreStateData - }); - dishonest = new HonestDisputeActor({ - _gameProxy: IFaultDisputeGame(address(gameProxy)), - _l2Outputs: _dishonestL2Outputs, - _trace: _dishonestTrace, - _preStateData: _dishonestPreStateData - }); - - vm.deal(address(honest), 100 ether); - vm.deal(address(dishonest), 100 ether); - vm.label(address(honest), "HonestActor"); - vm.label(address(dishonest), "DishonestActor"); - } - - /// @notice Helper to exhaust all moves from both actors. - function _exhaustMoves() internal { - while (true) { - // Allow the dishonest actor to make their moves, and then the honest actor. - (uint256 numMovesA,) = dishonest.move(); - (uint256 numMovesB, bool success) = honest.move(); - - require(success, "FaultDispute_1v1_Actors_Test: Honest actor's moves should always be successful"); - - // If both actors have run out of moves, we're done. - if (numMovesA == 0 && numMovesB == 0) break; - } - } - - /// @notice Helper to warp past the chess clock and resolve all claims within the dispute game. - function _warpAndResolve() internal { - // Warp past the chess clock - vm.warp(block.timestamp + 3 days + 12 hours); - - // Resolve all claims in reverse order. We allow `resolveClaim` calls to fail due to the - // check that prevents claims with no subgames attached from being passed to - // `resolveClaim`. There's also a check in `resolve` to ensure all children have been - // resolved before global resolution, which catches any unresolved subgames here. - for (uint256 i = gameProxy.claimDataLen(); i > 0; i--) { - (bool success,) = address(gameProxy).call(abi.encodeCall(gameProxy.resolveClaim, (i - 1, 0))); - assertTrue(success); - } - gameProxy.resolve(); - } -} diff --git a/packages/contracts-bedrock/test/dispute/v2/PermissionedDisputeGameV2.t.sol b/packages/contracts-bedrock/test/dispute/v2/PermissionedDisputeGameV2.t.sol deleted file mode 100644 index 1e621ac8038..00000000000 --- a/packages/contracts-bedrock/test/dispute/v2/PermissionedDisputeGameV2.t.sol +++ /dev/null @@ -1,417 +0,0 @@ -// SPDX-License-Identifier: MIT -pragma solidity ^0.8.15; - -// Testing -import { DisputeGameFactory_TestInit } from "test/dispute/DisputeGameFactory.t.sol"; -import { AlphabetVM } from "test/mocks/AlphabetVM.sol"; - -// Libraries -import "src/dispute/lib/Types.sol"; -import "src/dispute/lib/Errors.sol"; - -// Interfaces -import { IPermissionedDisputeGameV2 } from "interfaces/dispute/v2/IPermissionedDisputeGameV2.sol"; -import { IFaultDisputeGameV2 } from "interfaces/dispute/v2/IFaultDisputeGameV2.sol"; - -/// @title PermissionedDisputeGameV2_TestInit -/// @notice Reusable test initialization for `PermissionedDisputeGame` tests. -contract PermissionedDisputeGameV2_TestInit is DisputeGameFactory_TestInit { - /// @notice The type of the game being tested. - GameType internal immutable GAME_TYPE = GameTypes.PERMISSIONED_CANNON; - /// @notice Mock proposer key - address internal constant PROPOSER = address(0xfacade9); - /// @notice Mock challenger key - address internal constant CHALLENGER = address(0xfacadec); - - /// @dev The initial bond for the game. - uint256 internal initBond; - - /// @notice The implementation of the game. - IPermissionedDisputeGameV2 internal gameImpl; - /// @notice The `Clone` proxy of the game. - IPermissionedDisputeGameV2 internal gameProxy; - - /// @notice The extra data passed to the game for initialization. - bytes internal extraData; - - /// @notice The root claim of the game. - Claim internal rootClaim; - /// @notice An arbitrary root claim for testing. - Claim internal arbitaryRootClaim = Claim.wrap(bytes32(uint256(123))); - /// @notice Minimum bond value that covers all possible moves. - uint256 internal constant MIN_BOND = 50 ether; - - /// @notice The preimage of the absolute prestate claim - bytes internal absolutePrestateData; - /// @notice The absolute prestate of the trace. - Claim internal absolutePrestate; - /// @notice A valid l2BlockNumber that comes after the current anchor root block. - uint256 validL2BlockNumber; - - event Move(uint256 indexed parentIndex, Claim indexed pivot, address indexed claimant); - - function init(Claim _rootClaim, Claim _absolutePrestate, uint256 _l2BlockNumber) public { - // Set the time to a realistic date. - if (!isForkTest()) { - vm.warp(1690906994); - } - - // Fund the proposer on this fork. - vm.deal(PROPOSER, 100 ether); - - // Set the extra data for the game creation - extraData = abi.encode(_l2BlockNumber); - - (address _impl, AlphabetVM _vm,) = setupPermissionedDisputeGameV2(_absolutePrestate, PROPOSER, CHALLENGER); - gameImpl = IPermissionedDisputeGameV2(_impl); - - // Create a new game. - initBond = disputeGameFactory.initBonds(GAME_TYPE); - vm.mockCall( - address(anchorStateRegistry), - abi.encodeCall(anchorStateRegistry.anchors, (GAME_TYPE)), - abi.encode(_rootClaim, 0) - ); - vm.prank(PROPOSER, PROPOSER); - gameProxy = IPermissionedDisputeGameV2( - payable(address(disputeGameFactory.create{ value: initBond }(GAME_TYPE, _rootClaim, extraData))) - ); - - // Check immutables - assertEq(gameProxy.proposer(), PROPOSER); - assertEq(gameProxy.challenger(), CHALLENGER); - assertEq(gameProxy.gameType().raw(), GAME_TYPE.raw()); - assertEq(gameProxy.absolutePrestate().raw(), _absolutePrestate.raw()); - assertEq(gameProxy.maxGameDepth(), 2 ** 3); - assertEq(gameProxy.splitDepth(), 2 ** 2); - assertEq(gameProxy.clockExtension().raw(), 3 hours); - assertEq(gameProxy.maxClockDuration().raw(), 3.5 days); - assertEq(address(gameProxy.weth()), address(delayedWeth)); - assertEq(address(gameProxy.anchorStateRegistry()), address(anchorStateRegistry)); - assertEq(address(gameProxy.vm()), address(_vm)); - assertEq(address(gameProxy.gameCreator()), PROPOSER); - assertEq(gameProxy.l2ChainId(), l2ChainId); - - // Label the proxy - vm.label(address(gameProxy), "PermissionedDisputeGame_Clone"); - } - - function setUp() public override { - absolutePrestateData = abi.encode(0); - absolutePrestate = _changeClaimStatus(Claim.wrap(keccak256(absolutePrestateData)), VMStatuses.UNFINISHED); - - super.setUp(); - - // Get the actual anchor roots - (Hash root, uint256 l2BlockNumber) = anchorStateRegistry.getAnchorRoot(); - validL2BlockNumber = l2BlockNumber + 1; - rootClaim = Claim.wrap(Hash.unwrap(root)); - init({ _rootClaim: rootClaim, _absolutePrestate: absolutePrestate, _l2BlockNumber: validL2BlockNumber }); - } - - /// @dev Helper to return a pseudo-random claim - function _dummyClaim() internal view returns (Claim) { - return Claim.wrap(keccak256(abi.encode(gasleft()))); - } - - /// @dev Helper to get the required bond for the given claim index. - function _getRequiredBond(uint256 _claimIndex) internal view returns (uint256 bond_) { - (,,,,, Position parent,) = gameProxy.claimData(_claimIndex); - Position pos = parent.move(true); - bond_ = gameProxy.getRequiredBond(pos); - } - - /// @dev Helper to change the VM status byte of a claim. - function _changeClaimStatus(Claim _claim, VMStatus _status) internal pure returns (Claim out_) { - assembly { - out_ := or(and(not(shl(248, 0xFF)), _claim), shl(248, _status)) - } - } - - fallback() external payable { } - - receive() external payable { } - - function copyBytes(bytes memory src, bytes memory dest) internal pure returns (bytes memory) { - uint256 byteCount = src.length < dest.length ? src.length : dest.length; - for (uint256 i = 0; i < byteCount; i++) { - dest[i] = src[i]; - } - return dest; - } -} - -/// @title PermissionedDisputeGameV2_Version_Test -/// @notice Tests the `version` function of the `PermissionedDisputeGame` contract. -contract PermissionedDisputeGameV2_Version_Test is PermissionedDisputeGameV2_TestInit { - /// @notice Tests that the game's version function returns a string. - function test_version_works() public view { - assertTrue(bytes(gameProxy.version()).length > 0); - } -} - -/// @title PermissionedDisputeGameV2_Step_Test -/// @notice Tests the `step` function of the `PermissionedDisputeGame` contract. -contract PermissionedDisputeGameV2_Step_Test is PermissionedDisputeGameV2_TestInit { - /// @notice Tests that step works properly for the challenger. - function test_step_fromChallenger_succeeds() public { - validateStepForActor(CHALLENGER); - } - - /// @notice Tests that step works properly for the proposer. - function test_step_fromProposer_succeeds() public { - validateStepForActor(PROPOSER); - } - - function validateStepForActor(address actor) internal { - vm.deal(actor, 1_000 ether); - vm.startPrank(actor, actor); - - // Set up and perform the step - setupGameForStep(); - performStep(); - assertEq(gameProxy.claimDataLen(), 9); - - // Resolve the game and check that the expected actor countered the root claim - resolveGame(); - assertEq(uint256(gameProxy.status()), uint256(GameStatus.CHALLENGER_WINS)); - assertEq(gameProxy.resolvedAt().raw(), block.timestamp); - (, address counteredBy,,,,,) = gameProxy.claimData(0); - assertEq(counteredBy, actor); - - vm.stopPrank(); - } - - /// @notice Tests that step reverts for unauthorized addresses. - function test_step_notAuthorized_reverts(address _unauthorized) internal { - vm.assume(_unauthorized != PROPOSER && _unauthorized != CHALLENGER); - vm.deal(_unauthorized, 1_000 ether); - vm.deal(CHALLENGER, 1_000 ether); - - // Set up for the step using an authorized actor - vm.startPrank(CHALLENGER, CHALLENGER); - setupGameForStep(); - vm.stopPrank(); - - // Perform step with the unauthorized actor - vm.startPrank(_unauthorized, _unauthorized); - vm.expectRevert(BadAuth.selector); - performStep(); - - // Game should still be in progress, leaf claim should be missing - assertEq(uint256(gameProxy.status()), uint256(GameStatus.CHALLENGER_WINS)); - assertEq(gameProxy.claimDataLen(), 8); - - vm.stopPrank(); - } - - function setupGameForStep() internal { - // Make claims all the way down the tree. - (,,,, Claim disputed,,) = gameProxy.claimData(0); - gameProxy.attack{ value: _getRequiredBond(0) }(disputed, 0, _dummyClaim()); - (,,,, disputed,,) = gameProxy.claimData(1); - gameProxy.attack{ value: _getRequiredBond(1) }(disputed, 1, _dummyClaim()); - (,,,, disputed,,) = gameProxy.claimData(2); - gameProxy.attack{ value: _getRequiredBond(2) }(disputed, 2, _dummyClaim()); - (,,,, disputed,,) = gameProxy.claimData(3); - gameProxy.attack{ value: _getRequiredBond(3) }(disputed, 3, _dummyClaim()); - (,,,, disputed,,) = gameProxy.claimData(4); - gameProxy.attack{ value: _getRequiredBond(4) }(disputed, 4, _changeClaimStatus(_dummyClaim(), VMStatuses.PANIC)); - (,,,, disputed,,) = gameProxy.claimData(5); - gameProxy.attack{ value: _getRequiredBond(5) }(disputed, 5, _dummyClaim()); - (,,,, disputed,,) = gameProxy.claimData(6); - gameProxy.attack{ value: _getRequiredBond(6) }(disputed, 6, _dummyClaim()); - (,,,, disputed,,) = gameProxy.claimData(7); - gameProxy.attack{ value: _getRequiredBond(7) }(disputed, 7, _dummyClaim()); - - // Verify game state and add local data - assertEq(uint256(gameProxy.status()), uint256(GameStatus.IN_PROGRESS)); - gameProxy.addLocalData(LocalPreimageKey.DISPUTED_L2_BLOCK_NUMBER, 8, 0); - } - - function performStep() internal { - gameProxy.step(8, true, absolutePrestateData, hex""); - } - - function resolveGame() internal { - vm.warp(block.timestamp + gameProxy.maxClockDuration().raw() + 1); - gameProxy.resolveClaim(8, 0); - gameProxy.resolveClaim(7, 0); - gameProxy.resolveClaim(6, 0); - gameProxy.resolveClaim(5, 0); - gameProxy.resolveClaim(4, 0); - gameProxy.resolveClaim(3, 0); - gameProxy.resolveClaim(2, 0); - gameProxy.resolveClaim(1, 0); - - gameProxy.resolveClaim(0, 0); - gameProxy.resolve(); - } -} - -/// @title PermissionedDisputeGame_Initialize_Test -/// @notice Tests the initialization of the `PermissionedDisputeGame` contract. -contract PermissionedDisputeGameV2_Initialize_Test is PermissionedDisputeGameV2_TestInit { - /// @notice Tests that the game cannot be initialized with incorrect CWIA calldata length - /// caused by extraData of the wrong length - function test_initialize_wrongExtradataLength_reverts(uint256 _extraDataLen) public { - // The `DisputeGameFactory` will pack the root claim and the extra data into a single - // array, which is enforced to be at least 64 bytes long. - // We bound the upper end to 23.5KB to ensure that the minimal proxy never surpasses the - // contract size limit in this test, as CWIA proxies store the immutable args in their - // bytecode. - // [0 bytes, 31 bytes] u [33 bytes, 23.5 KB] - _extraDataLen = bound(_extraDataLen, 0, 23_500); - if (_extraDataLen == 32) { - _extraDataLen++; - } - bytes memory _extraData = new bytes(_extraDataLen); - - // Assign the first 32 bytes in `extraData` to a valid L2 block number passed the starting - // block. - (, uint256 startingL2Block) = gameProxy.startingOutputRoot(); - assembly { - mstore(add(_extraData, 0x20), add(startingL2Block, 1)) - } - - Claim claim = _dummyClaim(); - vm.prank(PROPOSER, PROPOSER); - vm.expectRevert(IFaultDisputeGameV2.BadExtraData.selector); - gameProxy = IPermissionedDisputeGameV2( - payable(address(disputeGameFactory.create{ value: initBond }(GAME_TYPE, claim, _extraData))) - ); - } - - /// @notice Tests that the game cannot be initialized with incorrect CWIA calldata length - /// caused by additional immutable args data - function test_initialize_extraImmutableArgsBytes_reverts(uint256 _extraByteCount) public { - (bytes memory correctArgs,,) = getPermissionedDisputeGameV2ImmutableArgs(absolutePrestate, PROPOSER, CHALLENGER); - - // We bound the upper end to 23.5KB to ensure that the minimal proxy never surpasses the - // contract size limit in this test, as CWIA proxies store the immutable args in their - // bytecode. - _extraByteCount = bound(_extraByteCount, 1, 23_500); - bytes memory immutableArgs = new bytes(_extraByteCount + correctArgs.length); - // Copy correct args into immutable args - copyBytes(correctArgs, immutableArgs); - - // Set up dispute game implementation with target immutableArgs - setupPermissionedDisputeGameV2(immutableArgs); - - Claim claim = _dummyClaim(); - vm.prank(PROPOSER, PROPOSER); - vm.expectRevert(IFaultDisputeGameV2.BadExtraData.selector); - gameProxy = IPermissionedDisputeGameV2( - payable( - address(disputeGameFactory.create{ value: initBond }(GAME_TYPE, claim, abi.encode(validL2BlockNumber))) - ) - ); - } - - /// @notice Tests that the game cannot be initialized with incorrect CWIA calldata length - /// caused by missing immutable args data - function test_initialize_missingImmutableArgsBytes_reverts(uint256 _truncatedByteCount) public { - (bytes memory correctArgs,,) = getPermissionedDisputeGameV2ImmutableArgs(absolutePrestate, PROPOSER, CHALLENGER); - - _truncatedByteCount = (_truncatedByteCount % correctArgs.length) + 1; - bytes memory immutableArgs = new bytes(correctArgs.length - _truncatedByteCount); - // Copy correct args into immutable args - copyBytes(correctArgs, immutableArgs); - - // Set up dispute game implementation with target immutableArgs - setupPermissionedDisputeGameV2(immutableArgs); - - Claim claim = _dummyClaim(); - vm.prank(PROPOSER, PROPOSER); - vm.expectRevert(IFaultDisputeGameV2.BadExtraData.selector); - gameProxy = IPermissionedDisputeGameV2( - payable( - address(disputeGameFactory.create{ value: initBond }(GAME_TYPE, claim, abi.encode(validL2BlockNumber))) - ) - ); - } -} - -/// @title PermissionedDisputeGameV2_Uncategorized_Test -/// @notice General tests that are not testing any function directly of the -/// `PermissionedDisputeGame` contract or are testing multiple functions at once. -contract PermissionedDisputeGameV2_Uncategorized_Test is PermissionedDisputeGameV2_TestInit { - /// @notice Tests that the proposer can create a permissioned dispute game. - function test_createGame_proposer_succeeds() public { - vm.prank(PROPOSER, PROPOSER); - disputeGameFactory.create{ value: initBond }(GAME_TYPE, arbitaryRootClaim, abi.encode(validL2BlockNumber)); - } - - /// @notice Tests that the permissioned game cannot be created by the challenger. - function test_createGame_challenger_reverts() public { - vm.deal(CHALLENGER, initBond); - vm.prank(CHALLENGER, CHALLENGER); - vm.expectRevert(BadAuth.selector); - disputeGameFactory.create{ value: initBond }(GAME_TYPE, arbitaryRootClaim, abi.encode(validL2BlockNumber)); - } - - /// @notice Tests that the permissioned game cannot be created by any address other than the - /// proposer. - function testFuzz_createGame_notProposer_reverts(address _p) public { - vm.assume(_p != PROPOSER); - - vm.deal(_p, initBond); - vm.prank(_p, _p); - vm.expectRevert(BadAuth.selector); - disputeGameFactory.create{ value: initBond }(GAME_TYPE, arbitaryRootClaim, abi.encode(validL2BlockNumber)); - } - - /// @notice Tests that the challenger can participate in a permissioned dispute game. - function test_participateInGame_challenger_succeeds() public { - vm.startPrank(CHALLENGER, CHALLENGER); - uint256 firstBond = _getRequiredBond(0); - vm.deal(CHALLENGER, firstBond); - (,,,, Claim disputed,,) = gameProxy.claimData(0); - gameProxy.attack{ value: firstBond }(disputed, 0, Claim.wrap(0)); - uint256 secondBond = _getRequiredBond(1); - vm.deal(CHALLENGER, secondBond); - (,,,, disputed,,) = gameProxy.claimData(1); - gameProxy.defend{ value: secondBond }(disputed, 1, Claim.wrap(0)); - uint256 thirdBond = _getRequiredBond(2); - vm.deal(CHALLENGER, thirdBond); - (,,,, disputed,,) = gameProxy.claimData(2); - gameProxy.move{ value: thirdBond }(disputed, 2, Claim.wrap(0), true); - vm.stopPrank(); - } - - /// @notice Tests that the proposer can participate in a permissioned dispute game. - function test_participateInGame_proposer_succeeds() public { - vm.startPrank(PROPOSER, PROPOSER); - uint256 firstBond = _getRequiredBond(0); - vm.deal(PROPOSER, firstBond); - (,,,, Claim disputed,,) = gameProxy.claimData(0); - gameProxy.attack{ value: firstBond }(disputed, 0, Claim.wrap(0)); - uint256 secondBond = _getRequiredBond(1); - vm.deal(PROPOSER, secondBond); - (,,,, disputed,,) = gameProxy.claimData(1); - gameProxy.defend{ value: secondBond }(disputed, 1, Claim.wrap(0)); - uint256 thirdBond = _getRequiredBond(2); - vm.deal(PROPOSER, thirdBond); - (,,,, disputed,,) = gameProxy.claimData(2); - gameProxy.move{ value: thirdBond }(disputed, 2, Claim.wrap(0), true); - vm.stopPrank(); - } - - /// @notice Tests that addresses that are not the proposer or challenger cannot participate in - /// a permissioned dispute game. - function test_participateInGame_notAuthorized_reverts(address _p) public { - vm.assume(_p != PROPOSER && _p != CHALLENGER); - - vm.startPrank(_p, _p); - (,,,, Claim disputed,,) = gameProxy.claimData(0); - vm.expectRevert(BadAuth.selector); - gameProxy.attack(disputed, 0, Claim.wrap(0)); - vm.expectRevert(BadAuth.selector); - gameProxy.defend(disputed, 0, Claim.wrap(0)); - vm.expectRevert(BadAuth.selector); - gameProxy.move(disputed, 0, Claim.wrap(0), true); - vm.expectRevert(BadAuth.selector); - gameProxy.step(0, true, absolutePrestateData, hex""); - vm.stopPrank(); - } -} diff --git a/packages/contracts-bedrock/test/opcm/DeployOPChain.t.sol b/packages/contracts-bedrock/test/opcm/DeployOPChain.t.sol index 7b3753dc8f7..4c6c7667066 100644 --- a/packages/contracts-bedrock/test/opcm/DeployOPChain.t.sol +++ b/packages/contracts-bedrock/test/opcm/DeployOPChain.t.sol @@ -2,6 +2,8 @@ pragma solidity 0.8.15; import { Test } from "forge-std/Test.sol"; +import { FeatureFlags } from "test/setup/FeatureFlags.sol"; +import { DevFeatures } from "src/libraries/DevFeatures.sol"; import { DeploySuperchain } from "scripts/deploy/DeploySuperchain.s.sol"; import { DeployImplementations } from "scripts/deploy/DeployImplementations.s.sol"; @@ -11,8 +13,9 @@ import { Types } from "scripts/libraries/Types.sol"; import { IOPContractsManager } from "interfaces/L1/IOPContractsManager.sol"; import { Claim, Duration, GameType, GameTypes } from "src/dispute/lib/Types.sol"; +import { IPermissionedDisputeGame } from "interfaces/dispute/IPermissionedDisputeGame.sol"; -contract DeployOPChain_TestBase is Test { +contract DeployOPChain_TestBase is Test, FeatureFlags { DeploySuperchain deploySuperchain; DeployImplementations deployImplementations; DeployOPChain deployOPChain; @@ -57,6 +60,7 @@ contract DeployOPChain_TestBase is Test { IOPContractsManager opcm; function setUp() public virtual { + resolveFeaturesFromEnv(); deploySuperchain = new DeploySuperchain(); deployImplementations = new DeployImplementations(); deployOPChain = new DeployOPChain(); @@ -91,7 +95,7 @@ contract DeployOPChain_TestBase is Test { superchainProxyAdmin: dso.superchainProxyAdmin, l1ProxyAdminOwner: dso.superchainProxyAdmin.owner(), challenger: challenger, - devFeatureBitmap: bytes32(0) + devFeatureBitmap: devFeatureBitmap }) ); opcm = dio.opcm; @@ -134,25 +138,26 @@ contract DeployOPChain_Test is DeployOPChain_TestBase { // Basic non-zero and code checks are covered inside run->checkOutput. // Additonal targeted assertions added below. - assertEq(address(doo.permissionedDisputeGame.proposer()), proposer, "PDG proposer"); - assertEq(address(doo.permissionedDisputeGame.challenger()), challenger, "PDG challenger"); - assertEq(doo.permissionedDisputeGame.splitDepth(), disputeSplitDepth, "PDG splitDepth"); - assertEq(doo.permissionedDisputeGame.maxGameDepth(), disputeMaxGameDepth, "PDG maxGameDepth"); + IPermissionedDisputeGame pdg = getPermissionedDisputeGame(doo); + assertEq(pdg.splitDepth(), disputeSplitDepth, "PDG splitDepth"); + assertEq(pdg.maxGameDepth(), disputeMaxGameDepth, "PDG maxGameDepth"); + assertEq(Duration.unwrap(pdg.clockExtension()), Duration.unwrap(disputeClockExtension), "PDG clockExtension"); assertEq( - Duration.unwrap(doo.permissionedDisputeGame.clockExtension()), - Duration.unwrap(disputeClockExtension), - "PDG clockExtension" - ); - assertEq( - Duration.unwrap(doo.permissionedDisputeGame.maxClockDuration()), - Duration.unwrap(disputeMaxClockDuration), - "PDG maxClockDuration" - ); - assertEq( - Claim.unwrap(doo.permissionedDisputeGame.absolutePrestate()), - Claim.unwrap(disputeAbsolutePrestate), - "PDG absolutePrestate" + Duration.unwrap(pdg.maxClockDuration()), Duration.unwrap(disputeMaxClockDuration), "PDG maxClockDuration" ); + + if (isDevFeatureEnabled(DevFeatures.DEPLOY_V2_DISPUTE_GAMES)) { + // For v2 contracts, some immutable args are passed in at game creation time from DGF.gameArgs + assertEq(address(pdg.proposer()), address(0), "PDG proposer"); + assertEq(address(pdg.challenger()), address(0), "PDG challenger"); + assertEq(Claim.unwrap(pdg.absolutePrestate()), bytes32(0), "PDG absolutePrestate"); + } else { + assertEq(address(pdg.proposer()), proposer, "PDG proposer"); + assertEq(address(pdg.challenger()), challenger, "PDG challenger"); + assertEq( + Claim.unwrap(pdg.absolutePrestate()), Claim.unwrap(disputeAbsolutePrestate), "PDG absolutePrestate" + ); + } } function testFuzz_run_memory_succeeds(bytes32 _seed) public { @@ -172,22 +177,45 @@ contract DeployOPChain_Test is DeployOPChain_TestBase { assertEq(doo.disputeGameFactoryProxy.initBonds(GameTypes.CANNON), 0, "2700"); assertEq(doo.disputeGameFactoryProxy.initBonds(GameTypes.PERMISSIONED_CANNON), 0, "2800"); - assertEq(doo.permissionedDisputeGame.l2BlockNumber(), 0, "3000"); - assertEq( - Claim.unwrap(doo.permissionedDisputeGame.absolutePrestate()), - 0x038512e02c4c3f7bdaec27d00edf55b7155e0905301e1a88083e4e0a6764d54c, - "3100" - ); - assertEq(Duration.unwrap(doo.permissionedDisputeGame.clockExtension()), 10800, "3200"); - assertEq(Duration.unwrap(doo.permissionedDisputeGame.maxClockDuration()), 302400, "3300"); - assertEq(doo.permissionedDisputeGame.splitDepth(), 30, "3400"); - assertEq(doo.permissionedDisputeGame.maxGameDepth(), 73, "3500"); + // Check dispute game deployments + // Validate permissionedDisputeGame (PDG) address + bool isDeployV2Games = isDevFeatureEnabled(DevFeatures.DEPLOY_V2_DISPUTE_GAMES); + IOPContractsManager.Implementations memory impls = opcm.implementations(); + address expectedPDGAddress = + isDeployV2Games ? impls.permissionedDisputeGameV2Impl : address(doo.permissionedDisputeGame); + address actualPDGAddress = address(doo.disputeGameFactoryProxy.gameImpls(GameTypes.PERMISSIONED_CANNON)); + assertNotEq(actualPDGAddress, address(0), "PDG address should be non-zero"); + assertEq(actualPDGAddress, expectedPDGAddress, "PDG address should match expected address"); + + // Check PDG getters + IPermissionedDisputeGame pdg = IPermissionedDisputeGame(actualPDGAddress); + bytes32 expectedPrestate = + isDeployV2Games ? bytes32(0) : bytes32(0x038512e02c4c3f7bdaec27d00edf55b7155e0905301e1a88083e4e0a6764d54c); + assertEq(pdg.l2BlockNumber(), 0, "3000"); + assertEq(Claim.unwrap(pdg.absolutePrestate()), expectedPrestate, "3100"); + assertEq(Duration.unwrap(pdg.clockExtension()), 10800, "3200"); + assertEq(Duration.unwrap(pdg.maxClockDuration()), 302400, "3300"); + assertEq(pdg.splitDepth(), 30, "3400"); + assertEq(pdg.maxGameDepth(), 73, "3500"); } function test_customDisputeGame_customEnabled_succeeds() public { + // For v2 games, these parameters have already been configured at OPCM deploy time + skipIfDevFeatureEnabled(DevFeatures.DEPLOY_V2_DISPUTE_GAMES); + deployOPChainInput.allowCustomDisputeParameters = true; deployOPChainInput.disputeSplitDepth = disputeSplitDepth + 1; DeployOPChain.Output memory doo = deployOPChain.run(deployOPChainInput); - assertEq(doo.permissionedDisputeGame.splitDepth(), disputeSplitDepth + 1); + + IPermissionedDisputeGame pdg = getPermissionedDisputeGame(doo); + assertEq(pdg.splitDepth(), disputeSplitDepth + 1); + } + + function getPermissionedDisputeGame(DeployOPChain.Output memory doo) + internal + view + returns (IPermissionedDisputeGame) + { + return IPermissionedDisputeGame(address(doo.disputeGameFactoryProxy.gameImpls(GameTypes.PERMISSIONED_CANNON))); } } diff --git a/packages/contracts-bedrock/test/scripts/VerifyOPCM.t.sol b/packages/contracts-bedrock/test/scripts/VerifyOPCM.t.sol index 0c355899ddf..4090ab61fdd 100644 --- a/packages/contracts-bedrock/test/scripts/VerifyOPCM.t.sol +++ b/packages/contracts-bedrock/test/scripts/VerifyOPCM.t.sol @@ -3,6 +3,7 @@ pragma solidity 0.8.15; // Libraries import { LibString } from "@solady/utils/LibString.sol"; +import { DevFeatures } from "src/libraries/DevFeatures.sol"; // Tests import { OPContractsManager_TestInit } from "test/L1/OPContractsManager.t.sol"; @@ -87,6 +88,27 @@ contract VerifyOPCM_Run_Test is VerifyOPCM_TestInit { harness.run(address(opcm), true); } + /// @notice Tests that the runSingle script succeeds when run against production contracts. + function test_runSingle_succeeds() public { + VerifyOPCM.OpcmContractRef[][2] memory refsByType; + refsByType[0] = harness.getOpcmContractRefs(opcm, "implementations", false); + refsByType[1] = harness.getOpcmContractRefs(opcm, "blueprints", true); + + for (uint8 i = 0; i < refsByType.length; i++) { + for (uint256 j = 0; j < refsByType[i].length; j++) { + VerifyOPCM.OpcmContractRef memory ref = refsByType[i][j]; + + // TODO(#17262): Remove these skips once these contracts are no longer behind a feature flag + // This script doesn't work for features that are in-development, so skip for now + if (_isDisputeGameV2ContractRef(ref)) { + continue; + } + + harness.runSingle(ref.name, ref.addr, true); + } + } + } + function test_run_bitmapNotEmptyOnMainnet_reverts(bytes32 _devFeatureBitmap) public { // Coverage changes bytecode and causes failures, skip. skipIfCoverage(); @@ -120,12 +142,21 @@ contract VerifyOPCM_Run_Test is VerifyOPCM_TestInit { // Grab the list of implementations. VerifyOPCM.OpcmContractRef[] memory refs = harness.getOpcmContractRefs(opcm, "implementations", false); + // Check if V2 dispute games feature is enabled + bytes32 bitmap = opcm.devFeatureBitmap(); + bool v2FeatureEnabled = DevFeatures.isDevFeatureEnabled(bitmap, DevFeatures.DEPLOY_V2_DISPUTE_GAMES); + // Change 256 bytes at random. - for (uint8 i = 0; i < 255; i++) { + for (uint256 i = 0; i < 255; i++) { // Pick a random implementation to change. uint256 randomImplIndex = vm.randomUint(0, refs.length - 1); VerifyOPCM.OpcmContractRef memory ref = refs[randomImplIndex]; + // Skip V2 dispute games when feature disabled + if (_isDisputeGameV2ContractRef(ref) && !v2FeatureEnabled) { + continue; + } + // Get the code for the implementation. bytes memory implCode = ref.addr.code; @@ -180,12 +211,21 @@ contract VerifyOPCM_Run_Test is VerifyOPCM_TestInit { // Grab the list of implementations. VerifyOPCM.OpcmContractRef[] memory refs = harness.getOpcmContractRefs(opcm, "implementations", false); + // Check if V2 dispute games feature is enabled + bytes32 bitmap = opcm.devFeatureBitmap(); + bool v2FeatureEnabled = DevFeatures.isDevFeatureEnabled(bitmap, DevFeatures.DEPLOY_V2_DISPUTE_GAMES); + // Change 256 bytes at random. for (uint8 i = 0; i < 255; i++) { // Pick a random implementation to change. uint256 randomImplIndex = vm.randomUint(0, refs.length - 1); VerifyOPCM.OpcmContractRef memory ref = refs[randomImplIndex]; + // Skip V2 dispute games when feature disabled + if (_isDisputeGameV2ContractRef(ref) && !v2FeatureEnabled) { + continue; + } + // Get the code for the implementation. bytes memory implCode = ref.addr.code; @@ -332,6 +372,10 @@ contract VerifyOPCM_Run_Test is VerifyOPCM_TestInit { assertGt(componentsWithContainerTested, 0, "Should have tested at least one component"); } + function _isDisputeGameV2ContractRef(VerifyOPCM.OpcmContractRef memory ref) internal pure returns (bool) { + return LibString.eq(ref.name, "FaultDisputeGameV2") || LibString.eq(ref.name, "PermissionedDisputeGameV2"); + } + /// @notice Utility function to mock the first OPCM component's contractsContainer address. /// @param _propRefs Array of property references to search through. /// @param _mockAddress The address to mock the contractsContainer call to return. From 1b00fb5acd047835978908298e67b0d3958341ef Mon Sep 17 00:00:00 2001 From: Stefano Charissis Date: Wed, 15 Oct 2025 08:19:15 +1100 Subject: [PATCH 055/117] feat(op-acceptance-tests): moved notifications to Slack (#17843) --- .circleci/config.yml | 55 ++------------------------------------------ 1 file changed, 2 insertions(+), 53 deletions(-) diff --git a/.circleci/config.yml b/.circleci/config.yml index 5999ac394c5..f0a506cf85f 100644 --- a/.circleci/config.yml +++ b/.circleci/config.yml @@ -204,53 +204,6 @@ commands: branch_pattern: develop mentions: "<< parameters.mentions >>" - # Notifies us on Discord when a build fails on develop - # For Discord to properly trigger notifications, mentions need to be in the format: - # User mentions: <@USER_ID> - # Role mentions: <@&ROLE_ID> - # Example: <@&1346448413172170807> is how we'd tag the Protocol DevX Pod - discord-notification-failures-on-develop: - description: "Notify Discord" - parameters: - message: - type: string - default: "" - mentions: - type: string - default: "" - steps: - - run: - name: "Notify Discord" - command: | - if [ "${CIRCLE_BRANCH}" == "develop" ]; then - # Format message for Discord with better structure and formatting - DISCORD_MESSAGE="🚨 **CI Failure Detected** 🚨\n" - DISCORD_MESSAGE="${DISCORD_MESSAGE}> **Repository:** \`${CIRCLE_PROJECT_USERNAME}/${CIRCLE_PROJECT_REPONAME}\`\n" - DISCORD_MESSAGE="${DISCORD_MESSAGE}> **Branch:** \`${CIRCLE_BRANCH}\`\n" - DISCORD_MESSAGE="${DISCORD_MESSAGE}> **Job:** \`${CIRCLE_JOB}\`\n" - DISCORD_MESSAGE="${DISCORD_MESSAGE}> **Build Link:** ${CIRCLE_BUILD_URL}" - - # Add failure reason if provided - if [ ! -z "<< parameters.message >>" ]; then - DISCORD_MESSAGE="${DISCORD_MESSAGE}\n\n**Failure message:** << parameters.message >>" - fi - - # Add mentions if provided - if [ ! -z "<< parameters.mentions >>" ]; then - DISCORD_MESSAGE="${DISCORD_MESSAGE}\n\n**Attention:** << parameters.mentions >>" - fi - - # Add extra mentions from environment (e.g. owners from flake-shake) - if [ -n "${EXTRA_DISCORD_MENTIONS:-}" ]; then - DISCORD_MESSAGE="${DISCORD_MESSAGE}\n\n**Owners:** ${EXTRA_DISCORD_MENTIONS}" - fi - - # Post to Discord webhook - curl -X POST -H "Content-Type: application/json" \ - -d "{\"content\": \"${DISCORD_MESSAGE}\"}" "${notify_ci}" - fi - when: on_fail - get-target-branch: description: "Determine the PR target branch and export TARGET_BRANCH for subsequent steps" steps: @@ -448,9 +401,6 @@ jobs: steps: - store_artifacts: path: ./op-acceptance-tests/logs - - discord-notification-failures-on-develop: - mentions: "Platforms (<@&1346448413172170807>)" # Protocol DevX Pod - message: "Kurtosis acceptance tests failed for devnet <> gate <>" initialize: docker: - image: <> @@ -1627,9 +1577,8 @@ jobs: - when: condition: on_fail steps: - - discord-notification-failures-on-develop: - mentions: "Platforms (<@&1346448413172170807>) & Protocol (<@590878816004603924>)" # Protocol DevX Pod, changwan - message: "Acceptance tests failed for gate <>" + - notify-failures-on-develop: + mentions: "@protocol-devx-pod @changwan" op-acceptance-tests-flake-shake: parameters: From 197631a8c9d352fc9c51bca632f9212785dadb2c Mon Sep 17 00:00:00 2001 From: Stefano Charissis Date: Wed, 15 Oct 2025 08:19:30 +1100 Subject: [PATCH 056/117] chore(op-acceptance-tests): op-acceptor v3.6.0 (#17842) Updates op-acceptor to [v.3.6.0](https://github.com/ethereum-optimism/infra/releases/tag/op-acceptor%2Fv3.6.0). --- mise.toml | 2 +- op-acceptance-tests/justfile | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/mise.toml b/mise.toml index 09407762323..ce8918e75be 100644 --- a/mise.toml +++ b/mise.toml @@ -38,7 +38,7 @@ anvil = "1.1.0" codecov-uploader = "0.8.0" goreleaser-pro = "2.11.2" kurtosis = "1.8.1" -op-acceptor = "op-acceptor/v3.5.0" +op-acceptor = "op-acceptor/v3.6.0" # Fake dependencies # Put things here if you need to track versions of tools or projects that can't diff --git a/op-acceptance-tests/justfile b/op-acceptance-tests/justfile index 0149d86782b..6796d641831 100644 --- a/op-acceptance-tests/justfile +++ b/op-acceptance-tests/justfile @@ -1,6 +1,6 @@ REPO_ROOT := `realpath ..` # path to the root of the optimism monorepo KURTOSIS_DIR := REPO_ROOT + "/kurtosis-devnet" -ACCEPTOR_VERSION := env_var_or_default("ACCEPTOR_VERSION", "v3.5.0") +ACCEPTOR_VERSION := env_var_or_default("ACCEPTOR_VERSION", "v3.6.0") DOCKER_REGISTRY := env_var_or_default("DOCKER_REGISTRY", "us-docker.pkg.dev/oplabs-tools-artifacts/images") ACCEPTOR_IMAGE := env_var_or_default("ACCEPTOR_IMAGE", DOCKER_REGISTRY + "/op-acceptor:" + ACCEPTOR_VERSION) From 3714b32a320a15c2948583ae3b5420064bf18c77 Mon Sep 17 00:00:00 2001 From: Inphi Date: Tue, 14 Oct 2025 18:00:56 -0400 Subject: [PATCH 057/117] op-acceptance-tests: Integration test for op-deployer add-game-type (#17865) * op-acceptance-tests: Integration test for op-deployer add-game-type * more generic gameType adder fn in devstack --- .../tests/base/disputegame_v2/init_test.go | 4 +- op-devstack/presets/proof.go | 5 + op-devstack/sysgo/add_game_type.go | 116 ++++++++++++++++++ op-devstack/sysgo/deployer.go | 24 +++- op-devstack/sysgo/superroot.go | 8 +- op-devstack/sysgo/system.go | 12 +- 6 files changed, 158 insertions(+), 11 deletions(-) create mode 100644 op-devstack/sysgo/add_game_type.go diff --git a/op-acceptance-tests/tests/base/disputegame_v2/init_test.go b/op-acceptance-tests/tests/base/disputegame_v2/init_test.go index c777264489c..c7c2a440c95 100644 --- a/op-acceptance-tests/tests/base/disputegame_v2/init_test.go +++ b/op-acceptance-tests/tests/base/disputegame_v2/init_test.go @@ -8,6 +8,6 @@ import ( func TestMain(m *testing.M) { // TODO(#17810): Use the new v2 dispute game flag via presets.WithDisputeGameV2() - //presets.DoMain(m, presets.WithMinimal(), presets.WithDisputeGameV2()) - presets.DoMain(m, presets.WithMinimal()) + //presets.DoMain(m, presets.WithProofs(), presets.WithDisputeGameV2()) + presets.DoMain(m, presets.WithProofs()) } diff --git a/op-devstack/presets/proof.go b/op-devstack/presets/proof.go index 612d5179178..23202fd1805 100644 --- a/op-devstack/presets/proof.go +++ b/op-devstack/presets/proof.go @@ -83,3 +83,8 @@ func WithDisputeGameFinalityDelaySeconds(seconds uint64) stack.CommonOption { sysgo.WithDisputeGameFinalityDelaySeconds(seconds), )) } + +// WithProofs enables a minimal system with permissionless proofs enabled +func WithProofs() stack.CommonOption { + return stack.MakeCommon(sysgo.ProofSystem(&sysgo.DefaultMinimalSystemIDs{})) +} diff --git a/op-devstack/sysgo/add_game_type.go b/op-devstack/sysgo/add_game_type.go new file mode 100644 index 00000000000..05de1a0e02a --- /dev/null +++ b/op-devstack/sysgo/add_game_type.go @@ -0,0 +1,116 @@ +package sysgo + +import ( + "fmt" + "math/big" + "net/url" + "path" + "runtime" + + "github.com/ethereum-optimism/optimism/op-chain-ops/devkeys" + "github.com/ethereum-optimism/optimism/op-deployer/pkg/deployer/artifacts" + "github.com/ethereum-optimism/optimism/op-deployer/pkg/deployer/manage" + "github.com/ethereum-optimism/optimism/op-devstack/devtest" + "github.com/ethereum-optimism/optimism/op-devstack/stack" + "github.com/ethereum-optimism/optimism/op-e2e/e2eutils/wait" + op_service "github.com/ethereum-optimism/optimism/op-service" + "github.com/ethereum-optimism/optimism/op-service/eth" + "github.com/ethereum/go-ethereum/accounts/abi/bind" + "github.com/ethereum/go-ethereum/common" + "github.com/ethereum/go-ethereum/ethclient" + "github.com/ethereum/go-ethereum/rpc" +) + +func WithCannonGameTypeAdded(l1ELID stack.L1ELNodeID, l2ChainID eth.ChainID) stack.Option[*Orchestrator] { + return stack.FnOption[*Orchestrator]{ + FinallyFn: func(o *Orchestrator) { + // TODO(#17867): Rebuild the op-program prestate using the newly minted L2 chain configs before using it. + absolutePrestate := getAbsolutePrestate(o.P(), "op-program/bin/prestate-proof-mt64.json") + addGameType(o, absolutePrestate, 0 /* CANNON */, l1ELID, l2ChainID) + }, + } +} + +func addGameType(o *Orchestrator, absolutePrestate common.Hash, gameType uint32, l1ELID stack.L1ELNodeID, l2ChainID eth.ChainID) { + t := o.P() + require := t.Require() + require.NotNil(o.wb, "must have a world builder") + l1ChainID := l1ELID.ChainID() + + opcmAddr := o.wb.output.ImplementationsDeployment.OpcmImpl + + l1EL, ok := o.l1ELs.Get(l1ELID) + require.True(ok, "l1El must exist") + + rpcClient, err := rpc.DialContext(t.Ctx(), l1EL.UserRPC()) + require.NoError(err) + client := ethclient.NewClient(rpcClient) + + l1PAO, err := o.keys.Address(devkeys.ChainOperatorKeys(l1ChainID.ToBig())(devkeys.L1ProxyAdminOwnerRole)) + require.NoError(err, "failed to get l1 proxy admin owner address") + + cfg := manage.AddGameTypeConfig{ + L1RPCUrl: l1EL.UserRPC(), + Logger: t.Logger(), + ArtifactsLocator: LocalArtifacts(t), + CacheDir: t.TempDir(), + L1ProxyAdminOwner: l1PAO, + OPCMImpl: opcmAddr, + SystemConfigProxy: o.wb.outL2Deployment[l2ChainID].SystemConfigProxyAddr(), + OPChainProxyAdmin: o.wb.outL2Deployment[l2ChainID].ProxyAdminAddr(), + DelayedWETHProxy: o.wb.outL2Deployment[l2ChainID].PermissionlessDelayedWETHProxyAddr(), + DisputeGameType: gameType, + DisputeAbsolutePrestate: absolutePrestate, + DisputeMaxGameDepth: big.NewInt(73), + DisputeSplitDepth: big.NewInt(30), + DisputeClockExtension: 10800, + DisputeMaxClockDuration: 302400, + InitialBond: eth.GWei(80_000_000).ToBig(), // 0.08 ETH + VM: o.wb.output.ImplementationsDeployment.MipsImpl, + Permissionless: true, + SaltMixer: fmt.Sprintf("devstack-%s-%s", l2ChainID, absolutePrestate.Hex()), + } + + _, addGameTypeCalldata, err := manage.AddGameType(t.Ctx(), cfg) + require.NoError(err, "failed to create add game type calldata") + require.Len(addGameTypeCalldata, 1, "calldata must contain one entry") + + chainOps := devkeys.ChainOperatorKeys(l1ChainID.ToBig()) + l1PAOKey, err := o.keys.Secret(chainOps(devkeys.L1ProxyAdminOwnerRole)) + require.NoError(err, "failed to get l1 proxy admin owner key") + transactOpts, err := bind.NewKeyedTransactorWithChainID(l1PAOKey, l1ChainID.ToBig()) + require.NoError(err, "must have transact opts") + transactOpts.Context = t.Ctx() + + t.Log("Deploying delegate call proxy contract") + delegateCallProxy, proxyContract := deployDelegateCallProxy(t, transactOpts, client, l1PAO) + // transfer ownership to the proxy so that we can delegatecall the opcm + transferOwnership(t, l1PAOKey, client, cfg.OPChainProxyAdmin, delegateCallProxy) + dgf := o.wb.outL2Deployment[l2ChainID].DisputeGameFactoryProxyAddr() + transferOwnership(t, l1PAOKey, client, dgf, delegateCallProxy) + + t.Log("sending opcm.addGameType transaction") + tx, err := proxyContract.ExecuteDelegateCall(transactOpts, opcmAddr, addGameTypeCalldata[0].Data) + require.NoError(err, "failed to send add game type tx") + _, err = wait.ForReceiptOK(t.Ctx(), client, tx.Hash()) + require.NoError(err, "failed to wait for add game type receipt") + + // reset ProxyAdmin ownership transfers + transferOwnershipForDelegateCallProxy(t, l1ChainID.ToBig(), l1PAOKey, client, delegateCallProxy, cfg.OPChainProxyAdmin, l1PAO) + transferOwnershipForDelegateCallProxy(t, l1ChainID.ToBig(), l1PAOKey, client, delegateCallProxy, dgf, l1PAO) +} + +func LocalArtifacts(t devtest.P) *artifacts.Locator { + require := t.Require() + _, testFilename, _, ok := runtime.Caller(0) + require.Truef(ok, "failed to get test filename") + monorepoDir, err := op_service.FindMonorepoRoot(testFilename) + require.NoError(err, "failed to find monorepo root") + artifactsDir := path.Join(monorepoDir, "packages", "contracts-bedrock", "forge-artifacts") + artifactsURL, err := url.Parse(fmt.Sprintf("file://%s", artifactsDir)) + require.NoError(err, "failed to parse artifacts dir url") + loc := &artifacts.Locator{ + URL: artifactsURL, + } + return loc +} diff --git a/op-devstack/sysgo/deployer.go b/op-devstack/sysgo/deployer.go index e6063489689..36bae2539cc 100644 --- a/op-devstack/sysgo/deployer.go +++ b/op-devstack/sysgo/deployer.go @@ -134,9 +134,11 @@ func WithDeployer() stack.Option[*Orchestrator] { } type L2Deployment struct { - systemConfigProxyAddr common.Address - disputeGameFactoryProxy common.Address - l1StandardBridgeProxy common.Address + systemConfigProxyAddr common.Address + disputeGameFactoryProxy common.Address + l1StandardBridgeProxy common.Address + proxyAdmin common.Address + permissionlessDelayedWETHProxy common.Address } var _ stack.L2Deployment = &L2Deployment{} @@ -153,6 +155,14 @@ func (d *L2Deployment) L1StandardBridgeProxyAddr() common.Address { return d.l1StandardBridgeProxy } +func (d *L2Deployment) ProxyAdminAddr() common.Address { + return d.proxyAdmin +} + +func (d *L2Deployment) PermissionlessDelayedWETHProxyAddr() common.Address { + return d.permissionlessDelayedWETHProxy +} + type InteropMigration struct { DisputeGameFactory common.Address } @@ -384,9 +394,11 @@ func (wb *worldBuilder) buildL2DeploymentOutputs() { for _, ch := range wb.output.Chains { chainID := eth.ChainIDFromBytes32(ch.ID) wb.outL2Deployment[chainID] = &L2Deployment{ - systemConfigProxyAddr: ch.SystemConfigProxy, - disputeGameFactoryProxy: ch.DisputeGameFactoryProxy, - l1StandardBridgeProxy: ch.L1StandardBridgeProxy, + systemConfigProxyAddr: ch.SystemConfigProxy, + disputeGameFactoryProxy: ch.DisputeGameFactoryProxy, + l1StandardBridgeProxy: ch.L1StandardBridgeProxy, + proxyAdmin: ch.OpChainProxyAdminImpl, + permissionlessDelayedWETHProxy: ch.DelayedWethPermissionlessGameProxy, } } wb.outSuperchainDeployment = &SuperchainDeployment{ diff --git a/op-devstack/sysgo/superroot.go b/op-devstack/sysgo/superroot.go index f487acf9321..fd0398b923a 100644 --- a/op-devstack/sysgo/superroot.go +++ b/op-devstack/sysgo/superroot.go @@ -208,9 +208,13 @@ func getSuperRoot(t devtest.CommonT, o *Orchestrator, timestamp uint64, supervis } func getInteropAbsolutePrestate(t devtest.CommonT) common.Hash { - root, err := findMonorepoRoot("op-program/bin/prestate-proof-interop.json") + return getAbsolutePrestate(t, "op-program/bin/prestate-proof-interop.json") +} + +func getAbsolutePrestate(t devtest.CommonT, prestatePath string) common.Hash { + root, err := findMonorepoRoot(prestatePath) t.Require().NoError(err) - p := path.Join(root, "op-program/bin/prestate-proof-interop.json") + p := path.Join(root, prestatePath) file, err := os.Open(p) t.Require().NoError(err) decoder := json.NewDecoder(file) diff --git a/op-devstack/sysgo/system.go b/op-devstack/sysgo/system.go index 8ee74cbf080..43264dedaa4 100644 --- a/op-devstack/sysgo/system.go +++ b/op-devstack/sysgo/system.go @@ -47,7 +47,10 @@ func NewDefaultMinimalSystemIDs(l1ID, l2ID eth.ChainID) DefaultMinimalSystemIDs func DefaultMinimalSystem(dest *DefaultMinimalSystemIDs) stack.Option[*Orchestrator] { ids := NewDefaultMinimalSystemIDs(DefaultL1ID, DefaultL2AID) + return defaultMinimalSystemOpts(&ids, dest) +} +func defaultMinimalSystemOpts(ids *DefaultMinimalSystemIDs, dest *DefaultMinimalSystemIDs) stack.CombinedOption[*Orchestrator] { opt := stack.Combine[*Orchestrator]() opt.Add(stack.BeforeDeploy(func(o *Orchestrator) { o.P().Logger().Info("Setting up") @@ -80,7 +83,7 @@ func DefaultMinimalSystem(dest *DefaultMinimalSystemIDs) stack.Option[*Orchestra })) opt.Add(stack.Finally(func(orch *Orchestrator) { - *dest = ids + *dest = *ids })) return opt @@ -425,3 +428,10 @@ func MultiSupervisorInteropSystem(dest *MultiSupervisorInteropSystemIDs) stack.O return opt } + +func ProofSystem(dest *DefaultMinimalSystemIDs) stack.Option[*Orchestrator] { + ids := NewDefaultMinimalSystemIDs(DefaultL1ID, DefaultL2AID) + opt := defaultMinimalSystemOpts(&ids, dest) + opt.Add(WithCannonGameTypeAdded(ids.L1EL, ids.L2.ChainID())) + return opt +} From 1ea08032ccaf6861a358ddb60fad54fc9cd4ecb2 Mon Sep 17 00:00:00 2001 From: opgitgovernance Date: Wed, 15 Oct 2025 02:07:48 +0200 Subject: [PATCH 058/117] chore(op-acceptance-tests): flake-shake; test promotions (#17851) Co-authored-by: Stefano Charissis --- op-acceptance-tests/acceptance-tests.yaml | 13 ------------- 1 file changed, 13 deletions(-) diff --git a/op-acceptance-tests/acceptance-tests.yaml b/op-acceptance-tests/acceptance-tests.yaml index 033403f8ccf..4c920d1fea0 100644 --- a/op-acceptance-tests/acceptance-tests.yaml +++ b/op-acceptance-tests/acceptance-tests.yaml @@ -15,19 +15,6 @@ gates: - id: flake-shake description: "Quarantine gate for new and potentially flaky tests requiring stability validation." tests: - - package: github.com/ethereum-optimism/optimism/op-acceptance-tests/tests/interop/proofs - name: TestProposer - timeout: 30m - metadata: - owner: "axel,mofi" - - package: github.com/ethereum-optimism/optimism/op-acceptance-tests/tests/interop/proofs - name: TestChallengerPlaysGame - timeout: 60m - metadata: - owner: "axel,mofi" - - package: github.com/ethereum-optimism/optimism/op-acceptance-tests/tests/osaka - timeout: 15m - owner: "josh" - package: github.com/ethereum-optimism/optimism/op-acceptance-tests/tests/sync/elsync/gap_elp2p name: TestL2ELP2PCanonicalChainAdvancedByFCU timeout: 30m From 4b59c05aa3967291cefad2e0dda206abc9d76925 Mon Sep 17 00:00:00 2001 From: Michael Amadi Date: Wed, 15 Oct 2025 01:23:54 +0100 Subject: [PATCH 059/117] make solidity upgrade test run for base ink and unichain, update fork block and remove running of U16A upgrade (#17827) * make solidity upgrade test run for base ink and unichain, update fork block and remove running of U16A upgrade * fixes --- packages/contracts-bedrock/justfile | 4 +-- .../test/L1/OPContractsManager.t.sol | 33 ++++++++++++------- .../test/setup/ForkLive.s.sol | 4 +-- .../contracts-bedrock/test/setup/Setup.sol | 8 ----- 4 files changed, 25 insertions(+), 24 deletions(-) diff --git a/packages/contracts-bedrock/justfile b/packages/contracts-bedrock/justfile index 6bc72727cd2..176695cfb2d 100644 --- a/packages/contracts-bedrock/justfile +++ b/packages/contracts-bedrock/justfile @@ -62,8 +62,8 @@ test-dev *ARGS: build-go-ffi # Default block number for the forked upgrade path. -export sepoliaBlockNumber := "9118951" -export mainnetBlockNumber := "23327678" +export sepoliaBlockNumber := "9366100" +export mainnetBlockNumber := "23530400" export pinnedBlockNumber := if env_var_or_default("FORK_BASE_CHAIN", "") == "mainnet" { mainnetBlockNumber diff --git a/packages/contracts-bedrock/test/L1/OPContractsManager.t.sol b/packages/contracts-bedrock/test/L1/OPContractsManager.t.sol index babd8742b5a..66c421b1e8c 100644 --- a/packages/contracts-bedrock/test/L1/OPContractsManager.t.sol +++ b/packages/contracts-bedrock/test/L1/OPContractsManager.t.sol @@ -39,9 +39,9 @@ import { IOPContractsManager, IOPContractsManagerGameTypeAdder, IOPContractsManagerInteropMigrator, - IOPContractsManagerUpgrader + IOPContractsManagerUpgrader, + IOPContractsManagerStandardValidator } from "interfaces/L1/IOPContractsManager.sol"; -import { IOPContractsManagerStandardValidator } from "interfaces/L1/IOPContractsManagerStandardValidator.sol"; import { IETHLockbox } from "interfaces/L1/IETHLockbox.sol"; import { IBigStepper } from "interfaces/dispute/IBigStepper.sol"; import { ISuperFaultDisputeGame } from "interfaces/dispute/ISuperFaultDisputeGame.sol"; @@ -57,7 +57,6 @@ import { OPContractsManagerInteropMigrator, OPContractsManagerStandardValidator } from "src/L1/OPContractsManager.sol"; -import { OPContractsManagerStandardValidator } from "src/L1/OPContractsManagerStandardValidator.sol"; /// @title OPContractsManager_Harness /// @notice Exposes internal functions for testing. @@ -248,6 +247,14 @@ contract OPContractsManager_Upgrade_Harness is CommonTest { return; } + // Create validationOverrides + IOPContractsManagerStandardValidator.ValidationOverrides memory validationOverrides = + IOPContractsManagerStandardValidator.ValidationOverrides({ + l1PAOMultisig: opChainConfigs[0].proxyAdmin.owner(), + challenger: IPermissionedDisputeGame(address(disputeGameFactory.gameImpls(GameTypes.PERMISSIONED_CANNON))) + .challenger() + }); + // Grab the validator before we do the error assertion because otherwise the assertion will // try to apply to this function call instead. IOPContractsManagerStandardValidator validator = _opcm.opcmStandardValidator(); @@ -257,19 +264,23 @@ contract OPContractsManager_Upgrade_Harness is CommonTest { // user is requesting to use the existing prestate. We could avoid the error by grabbing // the prestate from the actual contracts, but that doesn't actually give us any valuable // checks. Easier to just expect the error in this case. + // We add the prefix of OVERRIDES-L1PAOMULTISIG,OVERRIDES-CHALLENGER because we use validationOverrides. if (opChainConfigs[0].absolutePrestate.raw() == bytes32(0)) { - vm.expectRevert("OPContractsManagerStandardValidator: PDDG-40,PLDG-40"); + vm.expectRevert( + "OPContractsManagerStandardValidator: OVERRIDES-L1PAOMULTISIG,OVERRIDES-CHALLENGER,PDDG-40,PLDG-40" + ); } // Run the StandardValidator checks. - validator.validate( + validator.validateWithOverrides( IOPContractsManagerStandardValidator.ValidationInput({ proxyAdmin: opChainConfigs[0].proxyAdmin, sysCfg: opChainConfigs[0].systemConfigProxy, absolutePrestate: opChainConfigs[0].absolutePrestate.raw(), l2ChainID: l2ChainId }), - false + false, + validationOverrides ); } @@ -279,14 +290,13 @@ contract OPContractsManager_Upgrade_Harness is CommonTest { /// upgrades from this function once they've been executed on mainnet and the /// simulation block has been bumped beyond the execution block. /// @param _delegateCaller The address of the delegate caller to use for the upgrade. - function runPastUpgrades(address _delegateCaller) internal { + function runPastUpgrades(address _delegateCaller) internal view { // Run past upgrades depending on network. if (block.chainid == 1) { // Mainnet - // U16a - _runOpcmUpgradeAndChecks( - IOPContractsManager(0x8123739C1368C2DEDc8C564255bc417FEEeBFF9D), _delegateCaller, bytes("") - ); + // This is empty because the block number in the justfile is after the most recent upgrade so there are no + // past upgrades to run. + _delegateCaller; } else { revert UnsupportedChainId(); } @@ -1231,7 +1241,6 @@ contract OPContractsManager_UpdatePrestate_Test is OPContractsManager_TestInit { /// @notice Tests the `upgrade` function of the `OPContractsManager` contract. contract OPContractsManager_Upgrade_Test is OPContractsManager_Upgrade_Harness { function setUp() public override { - skipIfNotOpFork("OPContractsManager_Upgrade_Test"); super.setUp(); // Run all past upgrades. diff --git a/packages/contracts-bedrock/test/setup/ForkLive.s.sol b/packages/contracts-bedrock/test/setup/ForkLive.s.sol index cb80df50bd0..146a25466b8 100644 --- a/packages/contracts-bedrock/test/setup/ForkLive.s.sol +++ b/packages/contracts-bedrock/test/setup/ForkLive.s.sol @@ -261,8 +261,8 @@ contract ForkLive is Deployer, StdAssertions { // Run past upgrades depending on network. if (block.chainid == 1) { // Mainnet - // U16a. - _doUpgrade(IOPContractsManager(0x8123739C1368C2DEDc8C564255bc417FEEeBFF9D), upgrader); + // This is empty because the block number in the justfile is after the most recent upgrade so there are no + // past upgrades to run. } else { revert UnsupportedChainId(); } diff --git a/packages/contracts-bedrock/test/setup/Setup.sol b/packages/contracts-bedrock/test/setup/Setup.sol index 4d645393279..5b5d0dfe586 100644 --- a/packages/contracts-bedrock/test/setup/Setup.sol +++ b/packages/contracts-bedrock/test/setup/Setup.sol @@ -216,14 +216,6 @@ contract Setup is FeatureFlags { } } - /// @dev Skips tests when running against a forked production network that is not OP. - function skipIfNotOpFork(string memory message) public { - if (isForkTest() && !isOpFork()) { - vm.skip(true); - console.log(string.concat("Skipping non-OP fork test: ", message)); - } - } - /// @dev Skips tests when running against a forked production network using the superchain ops repo. function skipIfOpsRepoTest(string memory message) public { if (forkLive.useOpsRepo()) { From 85d9c9b653674749f0d26978a09d96bbd44ec779 Mon Sep 17 00:00:00 2001 From: Axel Kingsley Date: Wed, 15 Oct 2025 10:07:48 -0500 Subject: [PATCH 060/117] op-supernode: Initial Chain Container Framework (#17659) * op-supernode: Initial Chain Container Framework * op-supernode: Shared L1 * Context Exit Cleanup * op-supernode: RPC Router Resource for Virtual Nodes * op-supernode: Virutal Node Lifecycle Fixes * op-supernode: Node and Chain Lifecycle Updates ; Unit Tests * just coverage * op-supernode minor 2-chain runtime fixes * op-supernode: Single Chain TestCLAdvance for Supernode * op-acceptance-tests: 2 L2 System ; Supernode Multi-Tenant-CL Test * remove e2e changes * README * Restructure Packages/Files * Rename Proxy to Router ; Rewrite Acceptance Tests * update to new op-node InitializationOverrides struct * Update to CLI Interface ; Related/Required Edits * Shared Metrics * Repair Acceptance Tests ; Register optimism handler for supernode * Flake Shake ; Remove Sample Flag * Delete unused preset * Remove Sample from Tests * Fix chain_container_test signatures * lint * remove unused * Review Comments * Use eth.ChainID * Use OP Service HTTP Server --- Makefile | 4 + op-acceptance-tests/acceptance-tests.yaml | 5 + .../tests/supernode/advance_multiple_test.go | 46 ++ .../tests/supernode/init_test.go | 14 + op-alt-da/cli.go | 3 +- op-devstack/presets/twol2.go | 63 ++ op-devstack/sysgo/l2_cl.go | 2 + op-devstack/sysgo/l2_cl_supernode.go | 327 ++++++++++ op-devstack/sysgo/system.go | 124 ++++ op-node/flags/flags.go | 3 +- op-node/metrics/metrics.go | 7 + op-node/node/node.go | 69 +- op-node/p2p/cli/load_config.go | 19 +- op-node/service.go | 10 +- op-service/flags/flags.go | 3 +- op-supernode/.gitignore | 1 + op-supernode/Makefile | 5 + op-supernode/README.md | 115 ++++ op-supernode/cmd/main.go | 111 ++++ op-supernode/config/config.go | 55 ++ op-supernode/flags/flags.go | 101 +++ op-supernode/flags/virtual_cli.go | 162 +++++ op-supernode/flags/virtual_flags.go | 171 +++++ op-supernode/flags/virtual_test.go | 202 ++++++ op-supernode/justfile | 28 + .../chain_container/chain_container.go | 181 ++++++ .../chain_container/chain_container_test.go | 608 ++++++++++++++++++ .../engine_controller/engine_controller.go | 11 + .../virtual_node/virtual_node.go | 176 +++++ .../virtual_node/virtual_node_test.go | 359 +++++++++++ .../supernode/resources/metrics_router.go | 83 +++ .../supernode/resources/metrics_service.go | 50 ++ .../supernode/resources/rpc_router.go | 98 +++ .../supernode/resources/rpc_router_test.go | 59 ++ .../supernode/resources/shared_clients.go | 75 +++ op-supernode/supernode/supernode.go | 257 ++++++++ .../supervisor/backend/depset/depset.go | 3 +- .../supervisor/backend/depset/depset_test.go | 5 +- .../backend/depset/full_config_set.go | 2 +- .../supervisor/backend/depset/json.go | 2 +- .../backend/depset/static_depset.go | 3 +- 41 files changed, 3588 insertions(+), 34 deletions(-) create mode 100644 op-acceptance-tests/tests/supernode/advance_multiple_test.go create mode 100644 op-acceptance-tests/tests/supernode/init_test.go create mode 100644 op-devstack/presets/twol2.go create mode 100644 op-devstack/sysgo/l2_cl_supernode.go create mode 100644 op-supernode/.gitignore create mode 100644 op-supernode/Makefile create mode 100644 op-supernode/README.md create mode 100644 op-supernode/cmd/main.go create mode 100644 op-supernode/config/config.go create mode 100644 op-supernode/flags/flags.go create mode 100644 op-supernode/flags/virtual_cli.go create mode 100644 op-supernode/flags/virtual_flags.go create mode 100644 op-supernode/flags/virtual_test.go create mode 100644 op-supernode/justfile create mode 100644 op-supernode/supernode/chain_container/chain_container.go create mode 100644 op-supernode/supernode/chain_container/chain_container_test.go create mode 100644 op-supernode/supernode/chain_container/engine_controller/engine_controller.go create mode 100644 op-supernode/supernode/chain_container/virtual_node/virtual_node.go create mode 100644 op-supernode/supernode/chain_container/virtual_node/virtual_node_test.go create mode 100644 op-supernode/supernode/resources/metrics_router.go create mode 100644 op-supernode/supernode/resources/metrics_service.go create mode 100644 op-supernode/supernode/resources/rpc_router.go create mode 100644 op-supernode/supernode/resources/rpc_router_test.go create mode 100644 op-supernode/supernode/resources/shared_clients.go create mode 100644 op-supernode/supernode/supernode.go diff --git a/Makefile b/Makefile index 4604e65be9a..44961c9df1b 100644 --- a/Makefile +++ b/Makefile @@ -119,6 +119,10 @@ op-dispute-mon: ## Builds op-dispute-mon binary make -C ./op-dispute-mon op-dispute-mon .PHONY: op-dispute-mon +op-supernode: ## Builds op-supernode binary + just $(JUSTFLAGS) ./op-supernode/op-supernode +.PHONY: op-supernode + op-program: ## Builds op-program binary make -C ./op-program op-program .PHONY: op-program diff --git a/op-acceptance-tests/acceptance-tests.yaml b/op-acceptance-tests/acceptance-tests.yaml index 4c920d1fea0..864bacdcb07 100644 --- a/op-acceptance-tests/acceptance-tests.yaml +++ b/op-acceptance-tests/acceptance-tests.yaml @@ -15,6 +15,11 @@ gates: - id: flake-shake description: "Quarantine gate for new and potentially flaky tests requiring stability validation." tests: + - package: github.com/ethereum-optimism/optimism/op-acceptance-tests/tests/supernode + name: TestCLAdvanceMultiple + timeout: 10m + metadata: + owner: "axel" - package: github.com/ethereum-optimism/optimism/op-acceptance-tests/tests/sync/elsync/gap_elp2p name: TestL2ELP2PCanonicalChainAdvancedByFCU timeout: 30m diff --git a/op-acceptance-tests/tests/supernode/advance_multiple_test.go b/op-acceptance-tests/tests/supernode/advance_multiple_test.go new file mode 100644 index 00000000000..2e8c30c9ae6 --- /dev/null +++ b/op-acceptance-tests/tests/supernode/advance_multiple_test.go @@ -0,0 +1,46 @@ +package supernode + +import ( + "net/url" + "testing" + "time" + + "github.com/ethereum-optimism/optimism/op-devstack/devtest" + "github.com/ethereum-optimism/optimism/op-devstack/presets" + "github.com/stretchr/testify/require" +) + +// TestCLAdvanceMultiple verifies two L2 chains advance when using a shared CL +// it confirms: +// - the two L2 chains are on different chains +// - the two CLs are using the same supernode +// - the two CLs are advancing +func TestCLAdvanceMultiple(gt *testing.T) { + t := devtest.ParallelT(gt) + sys := presets.NewTwoL2(t) + + blockTime := sys.L2A.Escape().RollupConfig().BlockTime + waitTime := time.Duration(blockTime+1) * time.Second + + // Check L2A advances + numA := sys.L2ACL.SyncStatus().UnsafeL2.Number + numB := sys.L2BCL.SyncStatus().UnsafeL2.Number + + // Check that the two CLs are on different chains + require.NotEqual(t, sys.L2ACL.ChainID(), sys.L2BCL.ChainID()) + + // Check that the two CLs are using the same supernode + uA, err := url.Parse(sys.L2ACL.Escape().UserRPC()) + require.NoError(t, err) + uB, err := url.Parse(sys.L2BCL.Escape().UserRPC()) + require.NoError(t, err) + require.Equal(t, uA.Scheme, uB.Scheme) + require.Equal(t, uA.Host, uB.Host) + + require.Eventually(t, func() bool { + newA := sys.L2ACL.SyncStatus().UnsafeL2.Number + newB := sys.L2BCL.SyncStatus().UnsafeL2.Number + return newA > numA && newB > numB + }, 30*time.Second, waitTime) + +} diff --git a/op-acceptance-tests/tests/supernode/init_test.go b/op-acceptance-tests/tests/supernode/init_test.go new file mode 100644 index 00000000000..b75a9dfe937 --- /dev/null +++ b/op-acceptance-tests/tests/supernode/init_test.go @@ -0,0 +1,14 @@ +package supernode + +import ( + "os" + "testing" + + "github.com/ethereum-optimism/optimism/op-devstack/presets" +) + +// TestMain creates a two-L2 setup against the shared backend +func TestMain(m *testing.M) { + _ = os.Setenv("DEVSTACK_L2CL_KIND", "supernode") + presets.DoMain(m, presets.WithTwoL2Supernode()) +} diff --git a/op-alt-da/cli.go b/op-alt-da/cli.go index 84364e47952..95bb800532b 100644 --- a/op-alt-da/cli.go +++ b/op-alt-da/cli.go @@ -5,6 +5,7 @@ import ( "net/url" "time" + "github.com/ethereum-optimism/optimism/op-service/cliiface" "github.com/urfave/cli/v2" ) @@ -106,7 +107,7 @@ func (c CLIConfig) NewDAClient() *DAClient { return &DAClient{url: c.DAServerURL, verify: c.VerifyOnRead, precompute: !c.GenericDA, getTimeout: c.GetTimeout, putTimeout: c.PutTimeout} } -func ReadCLIConfig(c *cli.Context) CLIConfig { +func ReadCLIConfig(c cliiface.Context) CLIConfig { return CLIConfig{ Enabled: c.Bool(EnabledFlagName), DAServerURL: c.String(DaServerAddressFlagName), diff --git a/op-devstack/presets/twol2.go b/op-devstack/presets/twol2.go new file mode 100644 index 00000000000..bcbd29edd7a --- /dev/null +++ b/op-devstack/presets/twol2.go @@ -0,0 +1,63 @@ +package presets + +import ( + "github.com/ethereum/go-ethereum/log" + "github.com/stretchr/testify/require" + + "github.com/ethereum-optimism/optimism/op-devstack/devtest" + "github.com/ethereum-optimism/optimism/op-devstack/dsl" + "github.com/ethereum-optimism/optimism/op-devstack/shim" + "github.com/ethereum-optimism/optimism/op-devstack/stack" + "github.com/ethereum-optimism/optimism/op-devstack/stack/match" + "github.com/ethereum-optimism/optimism/op-devstack/sysgo" +) + +// TwoL2 represents a two-L2 setup without interop considerations. +// It is useful for testing components which bridge multiple L2s without necessarily using interop. +type TwoL2 struct { + Log log.Logger + T devtest.T + ControlPlane stack.ControlPlane + + L1Network *dsl.L1Network + L1EL *dsl.L1ELNode + + L2A *dsl.L2Network + L2B *dsl.L2Network + L2ACL *dsl.L2CLNode + L2BCL *dsl.L2CLNode +} + +func WithTwoL2() stack.CommonOption { + return stack.MakeCommon(sysgo.DefaultTwoL2System(&sysgo.DefaultTwoL2SystemIDs{})) +} + +func WithTwoL2Supernode() stack.CommonOption { + return stack.MakeCommon(sysgo.DefaultSupernodeTwoL2System(&sysgo.DefaultTwoL2SystemIDs{})) +} + +func NewTwoL2(t devtest.T) *TwoL2 { + system := shim.NewSystem(t) + orch := Orchestrator() + orch.Hydrate(system) + + l1Net := system.L1Network(match.FirstL1Network) + l2a := system.L2Network(match.Assume(t, match.L2ChainA)) + l2b := system.L2Network(match.Assume(t, match.L2ChainB)) + l2aCL := l2a.L2CLNode(match.Assume(t, match.WithSequencerActive(t.Ctx()))) + l2bCL := l2b.L2CLNode(match.Assume(t, match.WithSequencerActive(t.Ctx()))) + + require.NotEqual(t, l2a.ChainID(), l2b.ChainID()) + + return &TwoL2{ + Log: t.Logger(), + T: t, + ControlPlane: orch.ControlPlane(), + L1Network: dsl.NewL1Network(l1Net), + L1EL: dsl.NewL1ELNode(l1Net.L1ELNode(match.Assume(t, match.FirstL1EL))), + L2A: dsl.NewL2Network(l2a, orch.ControlPlane()), + L2B: dsl.NewL2Network(l2b, orch.ControlPlane()), + L2ACL: dsl.NewL2CLNode(l2aCL, orch.ControlPlane()), + L2BCL: dsl.NewL2CLNode(l2bCL, orch.ControlPlane()), + } +} diff --git a/op-devstack/sysgo/l2_cl.go b/op-devstack/sysgo/l2_cl.go index 32f16a679c9..2c95439b693 100644 --- a/op-devstack/sysgo/l2_cl.go +++ b/op-devstack/sysgo/l2_cl.go @@ -93,6 +93,8 @@ func WithL2CLNode(l2CLID stack.L2CLNodeID, l1CLID stack.L1CLNodeID, l1ELID stack switch os.Getenv("DEVSTACK_L2CL_KIND") { case "kona": return WithKonaNode(l2CLID, l1CLID, l1ELID, l2ELID, opts...) + case "supernode": + return WithSuperNode(l2CLID, l1CLID, l1ELID, l2ELID, opts...) default: return WithOpNode(l2CLID, l1CLID, l1ELID, l2ELID, opts...) } diff --git a/op-devstack/sysgo/l2_cl_supernode.go b/op-devstack/sysgo/l2_cl_supernode.go new file mode 100644 index 00000000000..6b143e2d570 --- /dev/null +++ b/op-devstack/sysgo/l2_cl_supernode.go @@ -0,0 +1,327 @@ +package sysgo + +import ( + "context" + "fmt" + "strconv" + "sync" + "time" + + "github.com/ethereum/go-ethereum/log" + + altda "github.com/ethereum-optimism/optimism/op-alt-da" + "github.com/ethereum-optimism/optimism/op-devstack/devtest" + "github.com/ethereum-optimism/optimism/op-devstack/shim" + "github.com/ethereum-optimism/optimism/op-devstack/stack" + "github.com/ethereum-optimism/optimism/op-devstack/stack/match" + "github.com/ethereum-optimism/optimism/op-node/config" + "github.com/ethereum-optimism/optimism/op-node/rollup/driver" + "github.com/ethereum-optimism/optimism/op-node/rollup/interop" + nodeSync "github.com/ethereum-optimism/optimism/op-node/rollup/sync" + "github.com/ethereum-optimism/optimism/op-service/client" + "github.com/ethereum-optimism/optimism/op-service/eth" + opmetrics "github.com/ethereum-optimism/optimism/op-service/metrics" + "github.com/ethereum-optimism/optimism/op-service/oppprof" + oprpc "github.com/ethereum-optimism/optimism/op-service/rpc" + "github.com/ethereum-optimism/optimism/op-service/sources" + snconfig "github.com/ethereum-optimism/optimism/op-supernode/config" + "github.com/ethereum-optimism/optimism/op-supernode/supernode" +) + +type SuperNode struct { + mu sync.Mutex + + id stack.L2CLNodeID + sn *supernode.Supernode + cancel context.CancelFunc + userRPC string + interopEndpoint string + interopJwtSecret eth.Bytes32 + p devtest.P + logger log.Logger + el *stack.L2ELNodeID // Optional: nil when using SyncTester + l1UserRPC string + l1BeaconAddr string +} + +var _ L2CLNode = (*SuperNode)(nil) + +func (n *SuperNode) hydrate(system stack.ExtensibleSystem) { + require := system.T().Require() + rpcCl, err := client.NewRPC(system.T().Ctx(), system.Logger(), n.userRPC, client.WithLazyDial()) + require.NoError(err) + system.T().Cleanup(rpcCl.Close) + + sysL2CL := shim.NewL2CLNode(shim.L2CLNodeConfig{ + CommonConfig: shim.NewCommonConfig(system.T()), + ID: n.id, + Client: rpcCl, + UserRPC: n.userRPC, + InteropEndpoint: n.interopEndpoint, + InteropJwtSecret: n.interopJwtSecret, + }) + sysL2CL.SetLabel(match.LabelVendor, string(match.OpNode)) + l2Net := system.L2Network(stack.L2NetworkID(n.id.ChainID())) + l2Net.(stack.ExtensibleL2Network).AddL2CLNode(sysL2CL) + if n.el != nil { + sysL2CL.(stack.LinkableL2CLNode).LinkEL(l2Net.L2ELNode(n.el)) + } +} + +func (n *SuperNode) UserRPC() string { + return n.userRPC +} + +func (n *SuperNode) InteropRPC() (endpoint string, jwtSecret eth.Bytes32) { + return n.interopEndpoint, n.interopJwtSecret +} + +func (n *SuperNode) Start() { + n.mu.Lock() + defer n.mu.Unlock() + if n.sn != nil { + n.logger.Warn("Supernode already started") + return + } + + // Build CLI config for supernode (single-chain) + cfg := &snconfig.CLIConfig{ + Chains: []uint64{eth.EvilChainIDToUInt64(n.id.ChainID())}, + DataDir: n.p.TempDir(), + L1NodeAddr: n.l1UserRPC, + L1BeaconAddr: n.l1BeaconAddr, + RPCConfig: oprpc.CLIConfig{ + ListenAddr: "127.0.0.1", + ListenPort: 0, + EnableAdmin: true, + }, + // Other configs (Log/Metrics/Pprof) left default + } + + // Construct VN config map + vnCfgs := map[eth.ChainID]*config.Config{} + + // Create Supernode instance + ctx, cancel := context.WithCancel(n.p.Ctx()) + sn, err := supernode.New(ctx, n.logger, "devstack", func(err error) { n.p.Require().NoError(err, "supernode critical error") }, cfg, vnCfgs) + n.p.Require().NoError(err, "supernode failed to create") + n.sn = sn + n.cancel = cancel + + // Start Supernode in background + go func() { + _ = n.sn.Start(ctx) + }() + + // Wait for the RPC addr and save userRPC/interop endpoints + if addr, err := n.sn.WaitRPCAddr(ctx); err == nil { + base := "http://" + addr + // single-chain instance routes at root + n.userRPC = base + n.interopEndpoint = base + } else { + n.p.Require().NoError(err, "supernode failed to bind RPC address") + } + +} + +func (n *SuperNode) Stop() { + n.mu.Lock() + defer n.mu.Unlock() + if n.sn == nil { + n.logger.Warn("Supernode already stopped") + return + } + if n.cancel != nil { + n.cancel() + } + // Attempt graceful stop + stopCtx, cancel := context.WithTimeout(context.Background(), 5*time.Second) + defer cancel() + _ = n.sn.Stop(stopCtx) + n.sn = nil +} + +// WithSuperNode constructs a Supernode-based L2 CL node +func WithSuperNode(l2CLID stack.L2CLNodeID, l1CLID stack.L1CLNodeID, l1ELID stack.L1ELNodeID, l2ELID stack.L2ELNodeID, opts ...L2CLOption) stack.Option[*Orchestrator] { + args := []L2CLs{{CLID: l2CLID, ELID: l2ELID}} + return WithSharedSupernodeCLs(args, l1CLID, l1ELID) +} + +// SuperNodeProxy is a thin wrapper that points to a shared supernode instance. +type SuperNodeProxy struct { + id stack.L2CLNodeID + p devtest.P + logger log.Logger + userRPC string + interopEndpoint string + interopJwtSecret eth.Bytes32 + el *stack.L2ELNodeID +} + +var _ L2CLNode = (*SuperNodeProxy)(nil) + +func (n *SuperNodeProxy) hydrate(system stack.ExtensibleSystem) { + require := system.T().Require() + rpcCl, err := client.NewRPC(system.T().Ctx(), system.Logger(), n.userRPC, client.WithLazyDial()) + require.NoError(err) + system.T().Cleanup(rpcCl.Close) + + sysL2CL := shim.NewL2CLNode(shim.L2CLNodeConfig{ + CommonConfig: shim.NewCommonConfig(system.T()), + ID: n.id, + Client: rpcCl, + UserRPC: n.userRPC, + InteropEndpoint: n.interopEndpoint, + InteropJwtSecret: n.interopJwtSecret, + }) + sysL2CL.SetLabel(match.LabelVendor, string(match.OpNode)) + l2Net := system.L2Network(stack.L2NetworkID(n.id.ChainID())) + l2Net.(stack.ExtensibleL2Network).AddL2CLNode(sysL2CL) + if n.el != nil { + sysL2CL.(stack.LinkableL2CLNode).LinkEL(l2Net.L2ELNode(n.el)) + } +} + +func (n *SuperNodeProxy) Start() {} +func (n *SuperNodeProxy) Stop() {} +func (n *SuperNodeProxy) UserRPC() string { return n.userRPC } +func (n *SuperNodeProxy) InteropRPC() (endpoint string, jwtSecret eth.Bytes32) { + return n.interopEndpoint, n.interopJwtSecret +} + +type L2CLs struct { + CLID stack.L2CLNodeID + ELID stack.L2ELNodeID +} + +// WithSharedSupernodeCLs starts one supernode for N L2 chains and registers thin L2CL wrappers. +func WithSharedSupernodeCLs(cls []L2CLs, l1CLID stack.L1CLNodeID, l1ELID stack.L1ELNodeID) stack.Option[*Orchestrator] { + return stack.AfterDeploy(func(orch *Orchestrator) { + p := orch.P() + require := p.Require() + + l1EL, ok := orch.l1ELs.Get(l1ELID) + require.True(ok, "l1 EL node required") + l1CL, ok := orch.l1CLs.Get(l1CLID) + require.True(ok, "l1 CL node required") + + // Get L1 network to access L1 chain config + l1Net, ok := orch.l1Nets.Get(l1ELID.ChainID()) + require.True(ok, "l1 network required") + + _, jwtSecret := orch.writeDefaultJWT() + + logger := p.Logger() + + // Build per-chain op-node configs + makeNodeCfg := func(l2Net *L2Network, l2EL L2ELNode, isSequencer bool) *config.Config { + interopCfg := &interop.Config{} + l2EngineAddr := l2EL.EngineRPC() + return &config.Config{ + L1: &config.L1EndpointConfig{ + L1NodeAddr: l1EL.UserRPC(), + L1TrustRPC: false, + L1RPCKind: sources.RPCKindDebugGeth, + RateLimit: 0, + BatchSize: 20, + HttpPollInterval: time.Millisecond * 100, + MaxConcurrency: 10, + CacheSize: 0, + }, + L1ChainConfig: l1Net.genesis.Config, + L2: &config.L2EndpointConfig{ + L2EngineAddr: l2EngineAddr, + L2EngineJWTSecret: jwtSecret, + }, + Beacon: &config.L1BeaconEndpointConfig{BeaconAddr: l1CL.beaconHTTPAddr}, + Driver: driver.Config{SequencerEnabled: isSequencer, SequencerConfDepth: 2}, + Rollup: *l2Net.rollupCfg, + RPC: oprpc.CLIConfig{ListenAddr: "127.0.0.1", ListenPort: 0, EnableAdmin: true}, + InteropConfig: interopCfg, + P2P: nil, + L1EpochPollInterval: 2 * time.Second, + RuntimeConfigReloadInterval: 0, + Sync: nodeSync.Config{SyncMode: nodeSync.CLSync}, + ConfigPersistence: config.DisabledConfigPersistence{}, + Metrics: opmetrics.CLIConfig{}, + Pprof: oppprof.CLIConfig{}, + AltDA: altda.CLIConfig{}, + IgnoreMissingPectraBlobSchedule: false, + ExperimentalOPStackAPI: true, + } + } + + // Gather VN configs and chain IDs + vnCfgs := make(map[eth.ChainID]*config.Config) + chainIDs := make([]uint64, 0, len(cls)) + for _, a := range cls { + l2Net, ok := orch.l2Nets.Get(a.CLID.ChainID()) + require.True(ok, "l2 network required") + l2ELNode, ok := orch.l2ELs.Get(a.ELID) + require.True(ok, "l2 EL node required") + cfg := makeNodeCfg(l2Net, l2ELNode, true) + id := eth.EvilChainIDToUInt64(a.CLID.ChainID()) + chainIDs = append(chainIDs, id) + vnCfgs[eth.ChainIDFromUInt64(id)] = cfg + } + + // Start shared supernode with all chains + snCfg := &snconfig.CLIConfig{ + Chains: chainIDs, + DataDir: p.TempDir(), + L1NodeAddr: l1EL.UserRPC(), + L1BeaconAddr: l1CL.beaconHTTPAddr, + RPCConfig: oprpc.CLIConfig{ListenAddr: "127.0.0.1", ListenPort: 0, EnableAdmin: true}, + } + ctx, cancel := context.WithCancel(p.Ctx()) + exitFn := func(err error) { p.Require().NoError(err, "supernode critical error") } + sn, err := supernode.New(ctx, logger, "devstack", exitFn, snCfg, vnCfgs) + require.NoError(err) + go func() { _ = sn.Start(ctx) }() + // Resolve bound address + addr, err := sn.WaitRPCAddr(ctx) + require.NoError(err, "failed waiting for supernode RPC addr") + base := "http://" + addr + p.Cleanup(func() { + stopCtx, c := context.WithTimeout(context.Background(), 5*time.Second) + _ = sn.Stop(stopCtx) + c() + cancel() + }) + // Wait for per-chain RPC routes to serve optimism_rollupConfig and register proxies + waitReady := func(u string) { + deadline := time.Now().Add(15 * time.Second) + for { + if time.Now().After(deadline) { + require.FailNow(fmt.Sprintf("timed out waiting for RPC to be ready at %s", u)) + } + rpcCl, err := client.NewRPC(p.Ctx(), logger, u, client.WithLazyDial()) + if err == nil { + var v any + if callErr := rpcCl.CallContext(p.Ctx(), &v, "optimism_rollupConfig"); callErr == nil { + rpcCl.Close() + break + } + rpcCl.Close() + } + time.Sleep(200 * time.Millisecond) + } + } + for _, a := range cls { + // Multi-chain router exposes per-chain namespace paths + rpc := base + "/" + strconv.FormatUint(eth.EvilChainIDToUInt64(a.CLID.ChainID()), 10) + waitReady(rpc) + proxy := &SuperNodeProxy{ + id: a.CLID, + p: p, + logger: logger, + userRPC: rpc, + interopEndpoint: rpc, + interopJwtSecret: jwtSecret, + el: &a.ELID, + } + require.True(orch.l2CLs.SetIfMissing(a.CLID, proxy), fmt.Sprintf("must not already exist: %s", a.CLID)) + } + }) +} diff --git a/op-devstack/sysgo/system.go b/op-devstack/sysgo/system.go index 43264dedaa4..f2f3d9e316e 100644 --- a/op-devstack/sysgo/system.go +++ b/op-devstack/sysgo/system.go @@ -89,6 +89,130 @@ func defaultMinimalSystemOpts(ids *DefaultMinimalSystemIDs, dest *DefaultMinimal return opt } +// DefaultTwoL2System defines a minimal system with a single L1 and two L2 chains, +// without interop or supervisor: both L2s get their own ELs, and we attach L2CL nodes +// via the default L2CL selector (which can be set to supernode to share a single process). +type DefaultTwoL2SystemIDs struct { + L1 stack.L1NetworkID + L1EL stack.L1ELNodeID + L1CL stack.L1CLNodeID + + L2A stack.L2NetworkID + L2ACL stack.L2CLNodeID + L2AEL stack.L2ELNodeID + + L2B stack.L2NetworkID + L2BCL stack.L2CLNodeID + L2BEL stack.L2ELNodeID + + L2ABatcher stack.L2BatcherID + L2AProposer stack.L2ProposerID + L2BBatcher stack.L2BatcherID + L2BProposer stack.L2ProposerID +} + +func NewDefaultTwoL2SystemIDs(l1ID, l2AID, l2BID eth.ChainID) DefaultTwoL2SystemIDs { + return DefaultTwoL2SystemIDs{ + L1: stack.L1NetworkID(l1ID), + L1EL: stack.NewL1ELNodeID("l1", l1ID), + L1CL: stack.NewL1CLNodeID("l1", l1ID), + L2A: stack.L2NetworkID(l2AID), + L2ACL: stack.NewL2CLNodeID("sequencer", l2AID), + L2AEL: stack.NewL2ELNodeID("sequencer", l2AID), + L2B: stack.L2NetworkID(l2BID), + L2BCL: stack.NewL2CLNodeID("sequencer", l2BID), + L2BEL: stack.NewL2ELNodeID("sequencer", l2BID), + L2ABatcher: stack.NewL2BatcherID("main", l2AID), + L2AProposer: stack.NewL2ProposerID("main", l2AID), + L2BBatcher: stack.NewL2BatcherID("main", l2BID), + L2BProposer: stack.NewL2ProposerID("main", l2BID), + } +} + +func DefaultTwoL2System(dest *DefaultTwoL2SystemIDs) stack.Option[*Orchestrator] { + ids := NewDefaultTwoL2SystemIDs(DefaultL1ID, DefaultL2AID, DefaultL2BID) + opt := stack.Combine[*Orchestrator]() + opt.Add(stack.BeforeDeploy(func(o *Orchestrator) { + o.P().Logger().Info("Setting up") + })) + + opt.Add(WithMnemonicKeys(devkeys.TestMnemonic)) + + opt.Add(WithDeployer(), + WithDeployerOptions( + WithLocalContractSources(), + WithCommons(ids.L1.ChainID()), + WithPrefundedL2(ids.L1.ChainID(), ids.L2A.ChainID()), + WithPrefundedL2(ids.L1.ChainID(), ids.L2B.ChainID()), + ), + ) + + opt.Add(WithL1Nodes(ids.L1EL, ids.L1CL)) + + opt.Add(WithL2ELNode(ids.L2AEL)) + opt.Add(WithL2CLNode(ids.L2ACL, ids.L1CL, ids.L1EL, ids.L2AEL, L2CLSequencer())) + + opt.Add(WithL2ELNode(ids.L2BEL)) + opt.Add(WithL2CLNode(ids.L2BCL, ids.L1CL, ids.L1EL, ids.L2BEL, L2CLSequencer())) + + opt.Add(WithBatcher(ids.L2ABatcher, ids.L1EL, ids.L2ACL, ids.L2AEL)) + opt.Add(WithProposer(ids.L2AProposer, ids.L1EL, &ids.L2ACL, nil)) + + opt.Add(WithBatcher(ids.L2BBatcher, ids.L1EL, ids.L2BCL, ids.L2BEL)) + opt.Add(WithProposer(ids.L2BProposer, ids.L1EL, &ids.L2BCL, nil)) + + opt.Add(WithFaucets([]stack.L1ELNodeID{ids.L1EL}, []stack.L2ELNodeID{ids.L2AEL, ids.L2BEL})) + + opt.Add(stack.Finally(func(orch *Orchestrator) { + *dest = ids + })) + + return opt +} + +// DefaultSupernodeTwoL2System runs two L2 chains that share a single supernode instance for their CL, +// wiring thin L2CL wrappers that route via the supernode RPC router. +func DefaultSupernodeTwoL2System(dest *DefaultTwoL2SystemIDs) stack.Option[*Orchestrator] { + ids := NewDefaultTwoL2SystemIDs(DefaultL1ID, DefaultL2AID, DefaultL2BID) + opt := stack.Combine[*Orchestrator]() + opt.Add(stack.BeforeDeploy(func(o *Orchestrator) { + o.P().Logger().Info("Setting up (supernode)") + })) + + opt.Add(WithMnemonicKeys(devkeys.TestMnemonic)) + + opt.Add(WithDeployer(), + WithDeployerOptions( + WithLocalContractSources(), + WithCommons(ids.L1.ChainID()), + WithPrefundedL2(ids.L1.ChainID(), ids.L2A.ChainID()), + WithPrefundedL2(ids.L1.ChainID(), ids.L2B.ChainID()), + ), + ) + + opt.Add(WithL1Nodes(ids.L1EL, ids.L1CL)) + + opt.Add(WithL2ELNode(ids.L2AEL)) + opt.Add(WithL2ELNode(ids.L2BEL)) + + // Shared supernode for both L2 chains + opt.Add(WithSharedSupernodeCLs([]L2CLs{{CLID: ids.L2ACL, ELID: ids.L2AEL}, {CLID: ids.L2BCL, ELID: ids.L2BEL}}, ids.L1CL, ids.L1EL)) + + opt.Add(WithBatcher(ids.L2ABatcher, ids.L1EL, ids.L2ACL, ids.L2AEL)) + opt.Add(WithProposer(ids.L2AProposer, ids.L1EL, &ids.L2ACL, nil)) + + opt.Add(WithBatcher(ids.L2BBatcher, ids.L1EL, ids.L2BCL, ids.L2BEL)) + opt.Add(WithProposer(ids.L2BProposer, ids.L1EL, &ids.L2BCL, nil)) + + opt.Add(WithFaucets([]stack.L1ELNodeID{ids.L1EL}, []stack.L2ELNodeID{ids.L2AEL, ids.L2BEL})) + + opt.Add(stack.Finally(func(orch *Orchestrator) { + *dest = ids + })) + + return opt +} + type DefaultMinimalSystemWithSyncTesterIDs struct { DefaultMinimalSystemIDs diff --git a/op-node/flags/flags.go b/op-node/flags/flags.go index d98e959a295..e7238352723 100644 --- a/op-node/flags/flags.go +++ b/op-node/flags/flags.go @@ -9,6 +9,7 @@ import ( altda "github.com/ethereum-optimism/optimism/op-alt-da" "github.com/ethereum-optimism/optimism/op-node/rollup/engine" "github.com/ethereum-optimism/optimism/op-node/rollup/sync" + "github.com/ethereum-optimism/optimism/op-service/cliiface" openum "github.com/ethereum-optimism/optimism/op-service/enum" opflags "github.com/ethereum-optimism/optimism/op-service/flags" oplog "github.com/ethereum-optimism/optimism/op-service/log" @@ -504,7 +505,7 @@ func init() { Flags = append(requiredFlags, optionalFlags...) } -func CheckRequired(ctx *cli.Context) error { +func CheckRequired(ctx cliiface.Context) error { for _, f := range requiredFlags { if !ctx.IsSet(f.Names()[0]) { return fmt.Errorf("flag %s is required", f.Names()[0]) diff --git a/op-node/metrics/metrics.go b/op-node/metrics/metrics.go index 4c1a5ff932c..7bc8079c540 100644 --- a/op-node/metrics/metrics.go +++ b/op-node/metrics/metrics.go @@ -559,6 +559,13 @@ func (m *Metrics) StartServer(hostname string, port int) (*ophttp.HTTPServer, er return ophttp.StartHTTPServer(addr, h) } +// Registry returns the underlying Prometheus registry used by this metrics instance. +// This enables external services (e.g. a supervising process) to expose metrics +// without starting an internal HTTP server per node. +func (m *Metrics) Registry() *prometheus.Registry { + return m.registry +} + func (m *Metrics) Document() []metrics.DocumentedMetric { return m.factory.Document() } diff --git a/op-node/node/node.go b/op-node/node/node.go index 40598b9bc84..b0ea946651d 100644 --- a/op-node/node/node.go +++ b/op-node/node/node.go @@ -5,6 +5,7 @@ import ( "errors" "fmt" "io" + "math/big" gosync "sync" "sync/atomic" "time" @@ -41,10 +42,39 @@ import ( oprpc "github.com/ethereum-optimism/optimism/op-service/rpc" opsigner "github.com/ethereum-optimism/optimism/op-service/signer" "github.com/ethereum-optimism/optimism/op-service/sources" + "github.com/prometheus/client_golang/prometheus" ) var ErrAlreadyClosed = errors.New("node is already closed") +// L1Client is the interface that op-node uses to interact with L1. +// This allows wrapped or mocked clients to be used +type L1Client interface { + L1BlockRefByLabel(ctx context.Context, label eth.BlockLabel) (eth.L1BlockRef, error) + L1BlockRefByNumber(ctx context.Context, num uint64) (eth.L1BlockRef, error) + L1BlockRefByHash(ctx context.Context, hash common.Hash) (eth.L1BlockRef, error) + InfoByHash(ctx context.Context, hash common.Hash) (eth.BlockInfo, error) + InfoByNumber(ctx context.Context, number uint64) (eth.BlockInfo, error) + InfoByLabel(ctx context.Context, label eth.BlockLabel) (eth.BlockInfo, error) + InfoAndTxsByHash(ctx context.Context, hash common.Hash) (eth.BlockInfo, types.Transactions, error) + InfoAndTxsByNumber(ctx context.Context, number uint64) (eth.BlockInfo, types.Transactions, error) + InfoAndTxsByLabel(ctx context.Context, label eth.BlockLabel) (eth.BlockInfo, types.Transactions, error) + FetchReceipts(ctx context.Context, blockHash common.Hash) (eth.BlockInfo, types.Receipts, error) + GetProof(ctx context.Context, address common.Address, storage []common.Hash, blockTag string) (*eth.AccountResult, error) + GetStorageAt(ctx context.Context, address common.Address, storageSlot common.Hash, blockTag string) (common.Hash, error) + ReadStorageAt(ctx context.Context, address common.Address, storageSlot common.Hash, blockHash common.Hash) (common.Hash, error) + SubscribeNewHead(ctx context.Context, ch chan<- *types.Header) (ethereum.Subscription, error) + ChainID(ctx context.Context) (*big.Int, error) + Close() +} + +// BeaconClient is the interface that op-node uses to interact with L1 Beacon. +// This allows wrapped or mocked clients to be used +type BeaconClient interface { + GetVersion(ctx context.Context) (string, error) + GetBlobs(ctx context.Context, ref eth.L1BlockRef, hashes []eth.IndexedBlobHash) ([]*eth.Blob, error) +} + type closableSafeDB interface { rollup.SafeHeadListener SafeDBReader @@ -124,6 +154,14 @@ type OpNode struct { // The provided ctx argument is for the span of initialization only; // the node will immediately Stop(ctx) before finishing initialization if the context is canceled during initialization. func New(ctx context.Context, cfg *config.Config, log log.Logger, appVersion string, m *metrics.Metrics) (*OpNode, error) { + return NewWithOverride(ctx, cfg, log, appVersion, m, InitializationOverrides{}) +} + +// NewWithOverride creates a new OpNode instance with optional initialization overrides. +// This allows callers to override specific initialization steps, enabling resource sharing +// (e.g., shared L1Client across multiple nodes) without duplicating connections or caches. +// If override is nil or any of its fields are nil, the default initialization is used for those steps. +func NewWithOverride(ctx context.Context, cfg *config.Config, log log.Logger, appVersion string, m *metrics.Metrics, override InitializationOverrides) (*OpNode, error) { if err := cfg.Check(); err != nil { return nil, err } @@ -140,7 +178,7 @@ func New(ctx context.Context, cfg *config.Config, log log.Logger, appVersion str // not a context leak, gossipsub is closed with a context. n.resourcesCtx, n.resourcesClose = context.WithCancel(context.Background()) - err := n.init(ctx, cfg, initializationOverrides{}) + err := n.init(ctx, cfg, override) if err != nil { log.Error("Error initializing the rollup node", "err", err) // ensure we always close the node resources if we fail to initialize the node. @@ -152,16 +190,18 @@ func New(ctx context.Context, cfg *config.Config, log log.Logger, appVersion str return n, nil } -type initializationOverrides struct { - L1Source L1Source - Beacon L1Beacon - RPCHandler *oprpc.Handler +type InitializationOverrides struct { + L1Source L1Source + Beacon L1Beacon + RPCHandler *oprpc.Handler + MetricsRegistry func(*prometheus.Registry) } // init progressively creates and sets up all the components of the OpNode // some later initialization steps depend on the node being partially initialized with other components, // so order is important to ensure that all resources are available when needed. -func (n *OpNode) init(ctx context.Context, cfg *config.Config, overrides initializationOverrides) error { +func (n *OpNode) init(ctx context.Context, cfg *config.Config, overrides InitializationOverrides) error { + n.log.Info("Initializing rollup node", "version", n.appVersion) var err error @@ -235,6 +275,13 @@ func (n *OpNode) init(ctx context.Context, cfg *config.Config, overrides initial } } + // Expose metrics registry to provided registry if requested + if overrides.MetricsRegistry != nil && n.metrics != nil { + if reg := n.metrics.Registry(); reg != nil { + overrides.MetricsRegistry(reg) + } + } + n.metricsSrv, err = initMetricsServer(cfg, n) if err != nil { return fmt.Errorf("failed to init the metrics server: %w", err) @@ -571,6 +618,16 @@ func initRPCServer(cfg *config.Config, node *OpNode) (*oprpc.Server, error) { } func registerAPIs(cfg *config.Config, node *OpNode, handler *oprpc.Handler) error { + // Register the main optimism namespace API + // The optimism namespace may already be registered + api := NewNodeAPI(&cfg.Rollup, cfg.DependencySet, node.l2Source.L2Client, node.l2Driver, node.safeDB, node.log) + if err := handler.AddAPI(rpc.API{ + Namespace: "optimism", + Service: api, + }); err != nil { + return fmt.Errorf("failed to add Optimism API: %w", err) + } + if p2pNode := node.getP2PNodeIfEnabled(); p2pNode != nil { if err := handler.AddAPI(rpc.API{ Namespace: p2p.NamespaceRPC, diff --git a/op-node/p2p/cli/load_config.go b/op-node/p2p/cli/load_config.go index 26cc75f8d25..e7403dbd2ef 100644 --- a/op-node/p2p/cli/load_config.go +++ b/op-node/p2p/cli/load_config.go @@ -19,15 +19,14 @@ import ( "github.com/ethereum-optimism/optimism/op-node/flags" "github.com/ethereum-optimism/optimism/op-node/p2p" - - "github.com/urfave/cli/v2" + "github.com/ethereum-optimism/optimism/op-service/cliiface" "github.com/ethereum/go-ethereum/log" "github.com/ethereum/go-ethereum/p2p/enode" "github.com/ethereum/go-ethereum/p2p/netutil" ) -func NewConfig(ctx *cli.Context, blockTime uint64) (*p2p.Config, error) { +func NewConfig(ctx cliiface.Context, blockTime uint64) (*p2p.Config, error) { conf := &p2p.Config{} if ctx.Bool(flags.DisableP2PName) { @@ -86,7 +85,7 @@ func validatePort(p uint) (uint16, error) { } // loadScoringParams loads the peer scoring options from the CLI context. -func loadScoringParams(conf *p2p.Config, ctx *cli.Context, blockTime uint64) error { +func loadScoringParams(conf *p2p.Config, ctx cliiface.Context, blockTime uint64) error { scoringLevel := ctx.String(flags.ScoringName) // Check old names for backwards compatibility if scoringLevel == "" { @@ -107,14 +106,14 @@ func loadScoringParams(conf *p2p.Config, ctx *cli.Context, blockTime uint64) err } // loadBanningOptions loads whether or not to ban peers from the CLI context. -func loadBanningOptions(conf *p2p.Config, ctx *cli.Context) error { +func loadBanningOptions(conf *p2p.Config, ctx cliiface.Context) error { conf.BanningEnabled = ctx.Bool(flags.BanningName) conf.BanningThreshold = ctx.Float64(flags.BanningThresholdName) conf.BanningDuration = ctx.Duration(flags.BanningDurationName) return nil } -func loadListenOpts(conf *p2p.Config, ctx *cli.Context) error { +func loadListenOpts(conf *p2p.Config, ctx cliiface.Context) error { listenIP := ctx.String(flags.ListenIPName) if listenIP != "" { // optional conf.ListenIP = net.ParseIP(listenIP) @@ -134,7 +133,7 @@ func loadListenOpts(conf *p2p.Config, ctx *cli.Context) error { return nil } -func loadDiscoveryOpts(conf *p2p.Config, ctx *cli.Context) error { +func loadDiscoveryOpts(conf *p2p.Config, ctx cliiface.Context) error { if ctx.Bool(flags.NoDiscoveryName) { conf.NoDiscovery = true } @@ -244,7 +243,7 @@ func resolveURLIP(rawurl string, lookupIP func(name string) ([]net.IP, error)) ( return u.String(), nil } -func loadLibp2pOpts(conf *p2p.Config, ctx *cli.Context) error { +func loadLibp2pOpts(conf *p2p.Config, ctx cliiface.Context) error { addrs := strings.Split(ctx.String(flags.StaticPeersName), ",") for i, addr := range addrs { addr = strings.TrimSpace(addr) @@ -317,7 +316,7 @@ func loadLibp2pOpts(conf *p2p.Config, ctx *cli.Context) error { return nil } -func loadNetworkPrivKey(ctx *cli.Context) (*crypto.Secp256k1PrivateKey, error) { +func loadNetworkPrivKey(ctx cliiface.Context) (*crypto.Secp256k1PrivateKey, error) { raw := ctx.String(flags.P2PPrivRawName) if raw != "" { return parsePriv(raw) @@ -371,7 +370,7 @@ func parsePriv(data string) (*crypto.Secp256k1PrivateKey, error) { return (p).(*crypto.Secp256k1PrivateKey), nil } -func loadGossipOptions(conf *p2p.Config, ctx *cli.Context) error { +func loadGossipOptions(conf *p2p.Config, ctx cliiface.Context) error { conf.MeshD = ctx.Int(flags.GossipMeshDName) conf.MeshDLo = ctx.Int(flags.GossipMeshDloName) conf.MeshDHi = ctx.Int(flags.GossipMeshDhiName) diff --git a/op-node/service.go b/op-node/service.go index 991dad785e7..c87f61af6f7 100644 --- a/op-node/service.go +++ b/op-node/service.go @@ -9,8 +9,6 @@ import ( "os" "strings" - "github.com/urfave/cli/v2" - "github.com/ethereum/go-ethereum/common" "github.com/ethereum/go-ethereum/log" "github.com/ethereum/go-ethereum/params" @@ -37,7 +35,7 @@ import ( ) // NewConfig creates a Config from the provided flags or environment variables. -func NewConfig(ctx *cli.Context, log log.Logger) (*config.Config, error) { +func NewConfig(ctx cliiface.Context, log log.Logger) (*config.Config, error) { if err := flags.CheckRequired(ctx); err != nil { return nil, err } @@ -52,7 +50,7 @@ func NewConfig(ctx *cli.Context, log log.Logger) (*config.Config, error) { return nil, err } - depSet, err := NewDependencySetFromCLI(ctx, ctx.Context) + depSet, err := NewDependencySetFromCLI(ctx) if err != nil { return nil, err } @@ -346,12 +344,12 @@ func NewL1ChainConfigFromCLI(log log.Logger, ctx cliiface.Context) (*params.Chai return jsonutil.LoadJSONFieldStrict[params.ChainConfig](l1ChainConfigPath, "config") } -func NewDependencySetFromCLI(cli cliiface.Context, ctx context.Context) (depset.DependencySet, error) { +func NewDependencySetFromCLI(cli cliiface.Context) (depset.DependencySet, error) { if !cli.IsSet(flags.InteropDependencySet.Name) { return nil, nil } loader := &depset.JSONDependencySetLoader{Path: cli.Path(flags.InteropDependencySet.Name)} - return loader.LoadDependencySet(ctx) + return loader.LoadDependencySet() } func NewSyncConfig(ctx cliiface.Context, log log.Logger) (*sync.Config, error) { diff --git a/op-service/flags/flags.go b/op-service/flags/flags.go index 2f51794b57d..4ec4e59a918 100644 --- a/op-service/flags/flags.go +++ b/op-service/flags/flags.go @@ -8,6 +8,7 @@ import ( "github.com/ethereum-optimism/optimism/op-node/chaincfg" opservice "github.com/ethereum-optimism/optimism/op-service" + "github.com/ethereum-optimism/optimism/op-service/cliiface" ) const ( @@ -130,7 +131,7 @@ var requiredXorFlags = [][]string{ // }, } -func CheckRequiredXor(ctx *cli.Context) error { +func CheckRequiredXor(ctx cliiface.Context) error { for _, flagSet := range requiredXorFlags { var setCount int for _, flagName := range flagSet { diff --git a/op-supernode/.gitignore b/op-supernode/.gitignore new file mode 100644 index 00000000000..ba077a4031a --- /dev/null +++ b/op-supernode/.gitignore @@ -0,0 +1 @@ +bin diff --git a/op-supernode/Makefile b/op-supernode/Makefile new file mode 100644 index 00000000000..eaa27248cf0 --- /dev/null +++ b/op-supernode/Makefile @@ -0,0 +1,5 @@ +DEPRECATED_TARGETS := op-supernode clean test + +include ../justfiles/deprecated.mk + + diff --git a/op-supernode/README.md b/op-supernode/README.md new file mode 100644 index 00000000000..f2cf91c2fec --- /dev/null +++ b/op-supernode/README.md @@ -0,0 +1,115 @@ +## OP Supernode + +Run multiple OP Stack chains in a single process. OP Supernode virtualizes OP Node so each chain runs as an isolated in-memory worker with per-chain config, data, and logs. + +### Highlights +- Multi-chain in one binary; lightweight per-chain workers +- Per-chain config via `-vn.*` flag prefixing +- Isolated data directories per chain +- Structured logs with `chain_id` and `vn_id` +- Shared L1 RPC and Beacon clients with non-closeable wrappers + +### How it works +``` +Supernode: Runs Containers + ├── ChainContainer (901) Manages: + ├── VirtualNode ── In Memory OP Node (901) + └── (FUTURE) Engine Controller (901) + ├── ChainContainer (902) Manages: + ├── VirtualNode ── In Memory OP Node (902) + └── (FUTURE) Engine Controller (902) + └── ChainContainer (903) Manages: + ├── VirtualNode ── In Memory OP Node (903) + └── (FUTURE) Engine Controller (903) +``` +- Supernode orchestrates chain containers (start/stop/restart, pause/resume, shutdown) +- ChainContainer applies per-chain config and passes shared resources +- VirtualNode runs OP Node with isolated resources and context-rich logging + +### Quickstart +Build: +```bash +just op-supernode +``` + +Run multiple chains: +```bash +./bin/op-supernode \ + --chains 901,902 \ + --data-dir ./supernode-data \ + --l1 http://localhost:8545 \ + --l1.beacon http://localhost:5052 \ + -vn.901.l2=http://localhost:9001 \ + -vn.901.rollup.config=./rollup-901.json \ + -vn.902.l2=http://localhost:9002 \ + -vn.902.rollup.config=./rollup-902.json \ + -vn.all.l2.jwt-secret=./jwt-902.txt +``` + +Environment variables: +```bash +export OP_SUPERNODE_CHAINS=901,902,903 +export OP_SUPERNODE_DATA_DIR=/var/lib/supernode +export OP_SUPERNODE_L1_ETH_RPC=$L1_RPC +export OP_SUPERNODE_L1_BEACON=$L1_BEACON + +./bin/op-supernode \ + -vn.901.l2=$CHAIN_901_RPC \ + -vn.902.l2=$CHAIN_902_RPC \ + -vn.903.l2=$CHAIN_903_RPC +``` + +### Configuration +- Required: `--chains`, `--l1` +- Optional: `--l1.beacon`, `--data-dir` (default `./datadir`), standard op-service flags (logging, metrics, pprof, RPC) + +Per-chain flags are prefixed: +- `-vn.all.` applies to all chains +- `-vn..` applies to one chain + +Common examples: +```bash +# Supernode-level L1 +--l1 http://l1:8545 +--l1.beacon http://l1:5052 + +# Per-chain L2 execution engines +-vn.901.l2=http://op-geth-901:8551 +-vn.902.l2=http://op-geth-902:8551 + +# Per-chain rollup configs +-vn.901.rollup.config=./rollup-901.json +-vn.902.rollup.config=./rollup-902.json + +# Apply to all chains +-vn.all.syncmode=execution-layer +``` + +### Data and logs +Data layout: +``` +/ + ├── 901/ + │ └── safe_db/ + ├── 902/ + │ └── safe_db/ + └── 903/ + └── safe_db/ +``` + +Logs include `chain_id` and a short-lived `vn_id` for filtering and debugging. + +### RPC Routing +RPC Clients are created in namespaced paths, so the supernode has a single RPC URL which acts as an RPC router to the virtual nodes +``` +/ + ├── 901/ + ├── 902/ + └── 903/ +``` +calling RPC methods on `/901` will route the method to the Virtual Node for that chain. + +### Limitations +- P2P disabled for Virtual Nodes (unsafe head sync possible later) +- Pause/resume exists but not yet exposed via API +- Virtual Node metrics are untested and expected non-functional currently diff --git a/op-supernode/cmd/main.go b/op-supernode/cmd/main.go new file mode 100644 index 00000000000..2743a401a53 --- /dev/null +++ b/op-supernode/cmd/main.go @@ -0,0 +1,111 @@ +package main + +import ( + "context" + "fmt" + "os" + + "github.com/ethereum-optimism/optimism/op-service/ctxinterrupt" + + opservice "github.com/ethereum-optimism/optimism/op-service" + "github.com/urfave/cli/v2" + + opnode "github.com/ethereum-optimism/optimism/op-node" + opnodecfg "github.com/ethereum-optimism/optimism/op-node/config" + opnodeflags "github.com/ethereum-optimism/optimism/op-node/flags" + "github.com/ethereum-optimism/optimism/op-service/cliapp" + "github.com/ethereum-optimism/optimism/op-service/eth" + oplog "github.com/ethereum-optimism/optimism/op-service/log" + "github.com/ethereum-optimism/optimism/op-supernode/config" + "github.com/ethereum-optimism/optimism/op-supernode/flags" + "github.com/ethereum-optimism/optimism/op-supernode/supernode" + "github.com/ethereum/go-ethereum/log" +) + +var ( + Version = "v0.0.0" + GitCommit = "" + GitDate = "" +) + +func main() { + oplog.SetupDefaults() + + // First parse the chains only args + chains, err := flags.ParseChains(os.Args) + if err != nil { + fmt.Fprintf(os.Stderr, "error: %v\n", err) + os.Exit(1) + } + // Build the full dynamic flags for the supernode using the chains + dynamicFlags := flags.FullDynamicFlags(chains) + + // Build the app with the full dynamic flags + app := cli.NewApp() + app.Flags = cliapp.ProtectFlags(dynamicFlags) + app.Version = opservice.FormatVersion(Version, GitCommit, GitDate, "") + app.Name = "op-supernode" + app.Usage = "Supernode" + app.Description = "Supernode service that starts up, prints, and exits" + + // Lifecycle Action for the app + app.Action = cliapp.LifecycleCmd(func(cliCtx *cli.Context, close context.CancelCauseFunc) (cliapp.Lifecycle, error) { + // Confirm top level supernode flags are set + if err := flags.CheckRequired(cliCtx); err != nil { + return nil, err + } + + // Create supernode the config from the CLI context + cfg := config.NewConfig(cliCtx) + if err := cfg.Check(); err != nil { + return nil, fmt.Errorf("invalid CLI flags: %w", err) + } + + // Create the logger for the app + l := oplog.NewLogger(oplog.AppOut(cliCtx), cfg.LogConfig) + oplog.SetGlobalLogHandler(l.Handler()) + + // Validate the environment variables for the app (requres logs so has to be later) + opservice.ValidateEnvVars(flags.EnvVarPrefix, dynamicFlags, l) + + // Build virtual Configs from the CLI Context for each chain + vnCfgs := make(map[eth.ChainID]*opnodecfg.Config) + for _, chainID := range cfg.Chains { + // Create a new VirtualCLI for the chain which will serve as an opnode config + vcli := flags.NewVirtualCLI(cliCtx, chainID) + // Override the L1 and Beacon addresses for the virtual node + // Based on the top level L1 and Beacon addresses + vcli.WithStringOverride(opnodeflags.L1NodeAddr.Name, cfg.L1NodeAddr) + vcli.WithStringOverride(opnodeflags.BeaconAddr.Name, cfg.L1BeaconAddr) + // Disable P2P for virtual nodes and set the peerstore and discovery paths to memory + // this is disabled at the CLI level to allow config construction + vcli.WithBoolOverride(opnodeflags.DisableP2PName, true) + vcli.WithStringOverride(opnodeflags.PeerstorePathName, "memory") + vcli.WithStringOverride(opnodeflags.DiscoveryPathName, "memory") + cfg, err := opnode.NewConfig(vcli, l) + if err != nil { + return nil, fmt.Errorf("failed to create virtual node config: %w", err) + } + vnCfgs[eth.ChainIDFromUInt64(chainID)] = cfg + } + + // Create the supernode, supplying the logger, version, and close function + // as well as the config and virtual node configs for each chain + ctx := cliCtx.Context + sn, err := supernode.New(ctx, + l, + Version, + close, + cfg, + vnCfgs) + if err != nil { + return nil, fmt.Errorf("failed to create supernode: %w", err) + } + return sn, nil + }) + + ctx := ctxinterrupt.WithSignalWaiterMain(context.Background()) + if err := app.RunContext(ctx, os.Args); err != nil { + log.Crit("Application failed", "message", err) + } +} diff --git a/op-supernode/config/config.go b/op-supernode/config/config.go new file mode 100644 index 00000000000..8d2c8be904c --- /dev/null +++ b/op-supernode/config/config.go @@ -0,0 +1,55 @@ +package config + +import ( + "errors" + + "github.com/urfave/cli/v2" + + oplog "github.com/ethereum-optimism/optimism/op-service/log" + opmetrics "github.com/ethereum-optimism/optimism/op-service/metrics" + "github.com/ethereum-optimism/optimism/op-service/oppprof" + oprpc "github.com/ethereum-optimism/optimism/op-service/rpc" + "github.com/ethereum-optimism/optimism/op-supernode/flags" +) + +type CLIConfig struct { + Chains []uint64 + DataDir string + L1NodeAddr string + L1BeaconAddr string + RPCConfig oprpc.CLIConfig + LogConfig oplog.CLIConfig + MetricsConfig opmetrics.CLIConfig + PprofConfig oppprof.CLIConfig + RawCtx *cli.Context +} + +func (c *CLIConfig) Check() error { + if err := c.RPCConfig.Check(); err != nil { + return err + } + if err := c.MetricsConfig.Check(); err != nil { + return err + } + if err := c.PprofConfig.Check(); err != nil { + return err + } + if c.L1NodeAddr == "" { + return errors.New("l1 node address is required") + } + return nil +} + +func NewConfig(ctx *cli.Context) *CLIConfig { + return &CLIConfig{ + Chains: ctx.Uint64Slice(flags.ChainsFlag.Name), + DataDir: ctx.String(flags.DataDirFlag.Name), + L1NodeAddr: ctx.String(flags.L1NodeAddr.Name), + L1BeaconAddr: ctx.String(flags.L1BeaconAddr.Name), + RPCConfig: oprpc.ReadCLIConfig(ctx), + LogConfig: oplog.ReadCLIConfig(ctx), + MetricsConfig: opmetrics.ReadCLIConfig(ctx), + PprofConfig: oppprof.ReadCLIConfig(ctx), + RawCtx: ctx, + } +} diff --git a/op-supernode/flags/flags.go b/op-supernode/flags/flags.go new file mode 100644 index 00000000000..e5fa3100618 --- /dev/null +++ b/op-supernode/flags/flags.go @@ -0,0 +1,101 @@ +package flags + +import ( + "fmt" + + "github.com/urfave/cli/v2" + + opnodeflags "github.com/ethereum-optimism/optimism/op-node/flags" + opservice "github.com/ethereum-optimism/optimism/op-service" + oplog "github.com/ethereum-optimism/optimism/op-service/log" + opmetrics "github.com/ethereum-optimism/optimism/op-service/metrics" + "github.com/ethereum-optimism/optimism/op-service/oppprof" + oprpc "github.com/ethereum-optimism/optimism/op-service/rpc" +) + +const EnvVarPrefix = "OP_SUPERNODE" + +func prefixEnvVars(name string) []string { + return opservice.PrefixEnvVar(EnvVarPrefix, name) +} + +var ( + ChainsFlag = &cli.Uint64SliceFlag{ + Name: "chains", + Usage: "List of chain IDs to run (repeatable or comma-separated)", + EnvVars: prefixEnvVars("CHAINS"), + Value: cli.NewUint64Slice(), + } + DataDirFlag = &cli.StringFlag{ + Name: "data-dir", + Usage: "Data directory for op-supernode", + EnvVars: prefixEnvVars("DATA_DIR"), + Value: "./datadir", + Required: false, + } + L1NodeAddr = &cli.StringFlag{ + Name: "l1", + Usage: "Address of L1 User JSON-RPC endpoint to use (eth namespace required)", + EnvVars: prefixEnvVars("L1_ETH_RPC"), + Required: true, + } + L1BeaconAddr = &cli.StringFlag{ + Name: "l1.beacon", + Usage: "Address of L1 Beacon-node HTTP endpoint to use", + EnvVars: prefixEnvVars("L1_BEACON"), + Required: false, + } +) + +var requiredFlags = []cli.Flag{ + ChainsFlag, + L1NodeAddr, +} + +var optionalFlags []cli.Flag + +func init() { + optionalFlags = append(optionalFlags, L1BeaconAddr) + optionalFlags = append(optionalFlags, DataDirFlag) + optionalFlags = append(optionalFlags, oprpc.CLIFlags(EnvVarPrefix)...) + optionalFlags = append(optionalFlags, oplog.CLIFlags(EnvVarPrefix)...) + optionalFlags = append(optionalFlags, opmetrics.CLIFlags(EnvVarPrefix)...) + optionalFlags = append(optionalFlags, oppprof.CLIFlags(EnvVarPrefix)...) + + Flags = append(requiredFlags, optionalFlags...) +} + +var Flags []cli.Flag + +func CheckRequired(ctx *cli.Context) error { + for _, f := range requiredFlags { + if !ctx.IsSet(f.Names()[0]) { + return fmt.Errorf("flag %s is required", f.Names()[0]) + } + } + return nil +} + +// FullDynamicFlags returns the base supernode flags plus dynamically-generated +// vn.* flags cloned from op-node flags for all-chains and per-chain IDs. +func FullDynamicFlags(chains []uint64) []cli.Flag { + // start with the base supernode flags + final := make([]cli.Flag, 0, len(Flags)+len(opnodeflags.Flags)*(1+len(chains))) + final = append(final, Flags...) + + // for each op-node flag, add vn.all. and vn.. variants + for _, f := range opnodeflags.Flags { + baseName := f.Names()[0] + // vn.all.* env var/alias prefixing + allEnvs := prefixEnvVar(f, "VN_ALL_") + allAliases := prefixAliases(f, VNFlagGlobalPrefix) + final = append(final, renameFlagWithEnv(f, VNFlagGlobalPrefix+baseName, allEnvs, allAliases)) + // per-chain + for _, id := range chains { + perChainEnvs := prefixEnvVar(f, fmt.Sprintf("VN_%d_", id)) + perAliases := prefixAliases(f, fmt.Sprintf("%s%d.", VNFlagNamePrefix, id)) + final = append(final, renameFlagWithEnv(f, fmt.Sprintf("%s%d.%s", VNFlagNamePrefix, id, baseName), perChainEnvs, perAliases)) + } + } + return final +} diff --git a/op-supernode/flags/virtual_cli.go b/op-supernode/flags/virtual_cli.go new file mode 100644 index 00000000000..e4a5328cc46 --- /dev/null +++ b/op-supernode/flags/virtual_cli.go @@ -0,0 +1,162 @@ +package flags + +import ( + "fmt" + "time" + + "github.com/urfave/cli/v2" +) + +// VirtualCLI wraps a base CLI context and returns namespaced values for flags +// and supports overriding values for specific flags +type VirtualCLI struct { + inner *cli.Context + chainID uint64 + // overrides allow for the apparent CLI context to be overridden with custom values + // this is useful for enforcing defaults or disabling features which aren't supported by the virtual node + stringOverrides map[string]string + boolOverrides map[string]bool +} + +func NewVirtualCLI(base *cli.Context, chainID uint64) *VirtualCLI { + return &VirtualCLI{inner: base, chainID: chainID, stringOverrides: make(map[string]string), boolOverrides: make(map[string]bool)} +} + +func (v *VirtualCLI) chainName(name string) string { + return fmt.Sprintf("%s%d.%s", VNFlagNamePrefix, v.chainID, name) +} + +func (v *VirtualCLI) globalName(name string) string { + return VNFlagGlobalPrefix + name +} + +// IsSet satisfies the cliiface.Context interface +// if an override is set, or if any namespaced version is set, return true +// otherwise defer to the inner context +func (v *VirtualCLI) IsSet(name string) bool { + if _, ok := v.stringOverrides[name]; ok { + return true + } + if _, ok := v.boolOverrides[name]; ok { + return true + } + if v.inner.IsSet(v.chainName(name)) { + return true + } + return v.inner.IsSet(v.globalName(name)) +} + +func (v *VirtualCLI) String(name string) string { + if val, ok := v.stringOverrides[name]; ok { + return val + } + cName := v.chainName(name) + if s := v.inner.String(cName); s != "" { + return s + } + gName := v.globalName(name) + if s := v.inner.String(gName); s != "" { + return s + } + // if there is generic content, return it as a string + if g := v.inner.Generic(gName); g != nil { + return fmt.Sprintf("%v", g) + } + return "" +} + +func (v *VirtualCLI) Bool(name string) bool { + if val, ok := v.boolOverrides[name]; ok { + return val + } + cName := v.chainName(name) + if v.inner.IsSet(cName) { + return v.inner.Bool(cName) + } + gName := v.globalName(name) + return v.inner.Bool(gName) +} + +func (v *VirtualCLI) Int(name string) int { + cName := v.chainName(name) + if v.inner.IsSet(cName) { + return v.inner.Int(cName) + } + gName := v.globalName(name) + return v.inner.Int(gName) +} + +func (v *VirtualCLI) Uint(name string) uint { + cName := v.chainName(name) + if v.inner.IsSet(cName) { + return v.inner.Uint(cName) + } + gName := v.globalName(name) + return v.inner.Uint(gName) +} + +func (v *VirtualCLI) Uint64(name string) uint64 { + cName := v.chainName(name) + if v.inner.IsSet(cName) { + return v.inner.Uint64(cName) + } + gName := v.globalName(name) + return v.inner.Uint64(gName) +} + +func (v *VirtualCLI) Float64(name string) float64 { + cName := v.chainName(name) + if v.inner.IsSet(cName) { + return v.inner.Float64(cName) + } + gName := v.globalName(name) + return v.inner.Float64(gName) +} + +func (v *VirtualCLI) Duration(name string) time.Duration { + cName := v.chainName(name) + if v.inner.IsSet(cName) { + return v.inner.Duration(cName) + } + gName := v.globalName(name) + return v.inner.Duration(gName) +} + +func (v *VirtualCLI) StringSlice(name string) []string { + cName := v.chainName(name) + if v.inner.IsSet(cName) { + return v.inner.StringSlice(cName) + } + gName := v.globalName(name) + return v.inner.StringSlice(gName) +} + +func (v *VirtualCLI) Path(name string) string { + cName := v.chainName(name) + if v.inner.IsSet(cName) { + return v.inner.Path(cName) + } + gName := v.globalName(name) + return v.inner.Path(gName) +} + +func (v *VirtualCLI) Generic(name string) any { + cName := v.chainName(name) + if v.inner.IsSet(cName) { + return v.inner.Generic(cName) + } + gName := v.globalName(name) + return v.inner.Generic(gName) +} + +// WithStringOverride sets a string override for the given base flag name +func (v *VirtualCLI) WithStringOverride(name, value string) *VirtualCLI { + v.stringOverrides[name] = value + return v +} + +// WithBoolOverride sets a bool override for the given base flag name +func (v *VirtualCLI) WithBoolOverride(name string, value bool) *VirtualCLI { + v.boolOverrides[name] = value + return v +} diff --git a/op-supernode/flags/virtual_flags.go b/op-supernode/flags/virtual_flags.go new file mode 100644 index 00000000000..4c5ff50caf1 --- /dev/null +++ b/op-supernode/flags/virtual_flags.go @@ -0,0 +1,171 @@ +package flags + +import ( + "fmt" + "strconv" + "strings" + + "github.com/urfave/cli/v2" +) + +// VN flag prefixes for dynamically cloned flags +const VNFlagNamePrefix = "vn." +const VNFlagGlobalPrefix = "vn.all." + +// ParseChains finds the chains flag in the given args and returns the chains. +// This is used to construct the dynamic flags for the supernode at runtime. +func ParseChains(args []string) ([]uint64, error) { + var chains []uint64 + for i := 0; i < len(args); i++ { + a := args[i] + // support --chains=..., -chains=... + if strings.HasPrefix(a, "--"+ChainsFlag.Name+"=") || strings.HasPrefix(a, "-"+ChainsFlag.Name+"=") { + eq := strings.IndexByte(a, '=') + if eq >= 0 && eq+1 < len(a) { + if err := appendChains(&chains, a[eq+1:]); err != nil { + return nil, err + } + } + continue + } + // support --chains , -chains + if a == "--"+ChainsFlag.Name || a == "-"+ChainsFlag.Name { + if i+1 < len(args) { + if err := appendChains(&chains, args[i+1]); err != nil { + return nil, err + } + i++ + } + continue + } + } + return chains, nil +} + +// appendChains extracts the chain IDs from the given comma-separated string and appends them to the given slice. +func appendChains(dst *[]uint64, csv string) error { + parts := strings.Split(csv, ",") + for _, part := range parts { + p := strings.TrimSpace(part) + if p == "" { + continue + } + v, err := strconv.ParseUint(p, 10, 64) + if err != nil { + return fmt.Errorf("invalid chain id %q: %w", p, err) + } + *dst = append(*dst, v) + } + return nil +} + +// renameFlagWithEnv produces a shallow copy of the given flag with a new name, env vars, and aliases. +// Destination pointers are intentionally not copied to avoid cross-ctx pollution. +func renameFlagWithEnv(f cli.Flag, name string, envs []string, aliases []string) cli.Flag { + switch t := f.(type) { + case *cli.StringFlag: + c := *t + c.Name = name + c.EnvVars = envs + c.Aliases = aliases + c.Destination = nil + return &c + case *cli.PathFlag: + c := *t + c.Name = name + c.EnvVars = envs + c.Aliases = aliases + c.Destination = nil + return &c + case *cli.StringSliceFlag: + c := *t + c.Name = name + c.EnvVars = envs + c.Aliases = aliases + return &c + case *cli.BoolFlag: + c := *t + c.Name = name + c.EnvVars = envs + c.Aliases = aliases + c.Destination = nil + return &c + case *cli.IntFlag: + c := *t + c.Name = name + c.EnvVars = envs + c.Aliases = aliases + c.Destination = nil + return &c + case *cli.UintFlag: + c := *t + c.Name = name + c.EnvVars = envs + c.Aliases = aliases + c.Destination = nil + return &c + case *cli.Uint64Flag: + c := *t + c.Name = name + c.EnvVars = envs + c.Aliases = aliases + c.Destination = nil + return &c + case *cli.Float64Flag: + c := *t + c.Name = name + c.EnvVars = envs + c.Aliases = aliases + c.Destination = nil + return &c + case *cli.DurationFlag: + c := *t + c.Name = name + c.EnvVars = envs + c.Aliases = aliases + c.Destination = nil + return &c + case *cli.GenericFlag: + c := *t + c.Name = name + c.EnvVars = envs + c.Aliases = aliases + c.Destination = nil + return &c + default: + return f + } +} + +// prefixEnvVar prefixes the env vars of the given flag with the given middle string +// e.g. "VN_ALL_" or "VN_123_". +func prefixEnvVar(f cli.Flag, mid string) []string { + envs := f.(interface{ GetEnvVars() []string }).GetEnvVars() + if len(envs) == 0 { + return nil + } + out := make([]string, 0, len(envs)) + for _, e := range envs { + idx := strings.Index(e, "_") + if idx < 0 { + continue + } + suffix := e[idx+1:] + out = append(out, EnvVarPrefix+"_"+mid+suffix) + } + return out +} + +// prefixAliases derives alias list from the original flag (excluding primary name) +// and prefixes each alias with the given prefix, e.g. "vn.all.". +func prefixAliases(f cli.Flag, prefix string) []string { + names := f.Names() + if len(names) <= 1 { + return nil + } + out := make([]string, 0, len(names)-1) + for _, a := range names[1:] { + out = append(out, prefix+a) + } + return out +} diff --git a/op-supernode/flags/virtual_test.go b/op-supernode/flags/virtual_test.go new file mode 100644 index 00000000000..fb7058ae751 --- /dev/null +++ b/op-supernode/flags/virtual_test.go @@ -0,0 +1,202 @@ +package flags + +import ( + "flag" + "fmt" + "reflect" + "testing" + + "github.com/urfave/cli/v2" + + opnodeflags "github.com/ethereum-optimism/optimism/op-node/flags" +) + +func newTestContext(t *testing.T, flags []cli.Flag, args []string) *cli.Context { + t.Helper() + app := &cli.App{Flags: flags} + set := flag.NewFlagSet("test", flag.ContinueOnError) + for _, f := range flags { + if err := f.Apply(set); err != nil { + t.Fatalf("failed to apply flag %q: %v", f.Names()[0], err) + } + } + if err := set.Parse(args); err != nil { + t.Fatalf("failed to parse args %v: %v", args, err) + } + return cli.NewContext(app, set, nil) +} + +func TestParseChainsVariants(t *testing.T) { + tcs := []struct { + name string + args []string + want []uint64 + wantErr bool + }{ + { + name: "equals csv", + args: []string{"--chains=1,2,3"}, + want: []uint64{1, 2, 3}, + }, + { + name: "space csv with whitespace", + args: []string{"--chains", "1, 2,3"}, + want: []uint64{1, 2, 3}, + }, + { + name: "short equals", + args: []string{"-chains=4"}, + want: []uint64{4}, + }, + { + name: "repeated flags accumulate", + args: []string{"--chains=5,6", "--chains", "7"}, + want: []uint64{5, 6, 7}, + }, + { + name: "empty entries ignored", + args: []string{"--chains=8,, 9, ,10"}, + want: []uint64{8, 9, 10}, + }, + { + name: "invalid value errors", + args: []string{"--chains=abc"}, + wantErr: true, + }, + } + + for _, tc := range tcs { + t.Run(tc.name, func(t *testing.T) { + got, err := ParseChains(tc.args) + if tc.wantErr { + if err == nil { + t.Fatalf("expected error, got none (chains=%v)", got) + } + return + } + if err != nil { + t.Fatalf("unexpected error: %v", err) + } + if !reflect.DeepEqual(got, tc.want) { + t.Fatalf("chains mismatch: got %v want %v", got, tc.want) + } + }) + } +} + +func TestFullDynamicFlags_ClonesAllFlagsForChainsAndGlobal(t *testing.T) { + chains := []uint64{100, 200} + flagsOut := FullDynamicFlags(chains) + // collect primary names + seen := make(map[string]struct{}) + for _, f := range flagsOut { + name := f.Names()[0] + seen[name] = struct{}{} + } + + // For every op-node flag, we expect vn.all. and vn.. + for _, f := range opnodeflags.Flags { + base := f.Names()[0] + globalName := VNFlagGlobalPrefix + base + if _, ok := seen[globalName]; !ok { + t.Fatalf("missing global clone for %q: expected flag %q", base, globalName) + } + for _, id := range chains { + perName := fmt.Sprintf("%s%d.%s", VNFlagNamePrefix, id, base) + if _, ok := seen[perName]; !ok { + t.Fatalf("missing per-chain clone for %q: expected flag %q", base, perName) + } + } + } +} + +func TestVirtualCLI_Precedence_String(t *testing.T) { + flags := []cli.Flag{ + &cli.StringFlag{Name: VNFlagGlobalPrefix + "color", Value: "blue"}, + &cli.StringFlag{Name: "vn.1.color"}, // no default + } + + // only defaults + ctx := newTestContext(t, flags, []string{}) + v := NewVirtualCLI(ctx, 1) + if got := v.String("color"); got != "blue" { + t.Fatalf("default precedence failed: got %q want %q", got, "blue") + } + + // set global value -> overrides default + ctx = newTestContext(t, flags, []string{"--" + VNFlagGlobalPrefix + "color=green"}) + v = NewVirtualCLI(ctx, 1) + if got := v.String("color"); got != "green" { + t.Fatalf("global precedence failed: got %q want %q", got, "green") + } + + // set chain-specific -> overrides global + ctx = newTestContext(t, flags, []string{ + "--" + VNFlagGlobalPrefix + "color=green", + "--vn.1.color=red", + }) + v = NewVirtualCLI(ctx, 1) + if got := v.String("color"); got != "red" { + t.Fatalf("chain precedence failed: got %q want %q", got, "red") + } + + // override -> overrides chain-specific + v = v.WithStringOverride("color", "orange") + if got := v.String("color"); got != "orange" { + t.Fatalf("override precedence failed: got %q want %q", got, "orange") + } +} + +func TestVirtualCLI_Precedence_Bool(t *testing.T) { + flags := []cli.Flag{ + &cli.BoolFlag{Name: VNFlagGlobalPrefix + "switch", Value: true}, + &cli.BoolFlag{Name: "vn.1.switch"}, // no default + } + + // only defaults + ctx := newTestContext(t, flags, []string{}) + v := NewVirtualCLI(ctx, 1) + if got := v.Bool("switch"); got != true { + t.Fatalf("default bool precedence failed: got %v want %v", got, true) + } + + // set global value -> overrides default + ctx = newTestContext(t, flags, []string{"--" + VNFlagGlobalPrefix + "switch=false"}) + v = NewVirtualCLI(ctx, 1) + if got := v.Bool("switch"); got != false { + t.Fatalf("global bool precedence failed: got %v want %v", got, false) + } + + // set chain-specific -> overrides global + ctx = newTestContext(t, flags, []string{ + "--" + VNFlagGlobalPrefix + "switch=false", + "--vn.1.switch=true", + }) + v = NewVirtualCLI(ctx, 1) + if got := v.Bool("switch"); got != true { + t.Fatalf("chain bool precedence failed: got %v want %v", got, true) + } + + // override -> overrides chain-specific + v = v.WithBoolOverride("switch", false) + if got := v.Bool("switch"); got != false { + t.Fatalf("override bool precedence failed: got %v want %v", got, false) + } +} + +func TestVirtualCLI_PerChainIsolation(t *testing.T) { + flags := []cli.Flag{ + &cli.StringFlag{Name: VNFlagGlobalPrefix + "color", Value: "blue"}, + &cli.StringFlag{Name: "vn.1.color"}, + &cli.StringFlag{Name: "vn.2.color"}, + } + ctx := newTestContext(t, flags, []string{"--vn.1.color=red", "--vn.2.color=green"}) + v1 := NewVirtualCLI(ctx, 1) + v2 := NewVirtualCLI(ctx, 2) + if got := v1.String("color"); got != "red" { + t.Fatalf("chain 1 value mismatch: got %q want %q", got, "red") + } + if got := v2.String("color"); got != "green" { + t.Fatalf("chain 2 value mismatch: got %q want %q", got, "green") + } +} diff --git a/op-supernode/justfile b/op-supernode/justfile new file mode 100644 index 00000000000..97834da91c3 --- /dev/null +++ b/op-supernode/justfile @@ -0,0 +1,28 @@ +import '../justfiles/go.just' + +# Build ldflags string +_LDFLAGSSTRING := "'" + trim( + "-X main.GitCommit=" + GITCOMMIT + " " + \ + "-X main.GitDate=" + GITDATE + " " + \ + "-X main.Version=" + VERSION + " " + \ + "") + "'" + +BINARY := "./bin/op-supernode" + +# Build op-supernode binary +op-supernode: (go_build BINARY "./cmd" "-ldflags" _LDFLAGSSTRING) + +# Clean build artifacts +clean: + rm -f {{BINARY}} + +# Run tests +test: (go_test "./...") + +# Run tests with coverage report +coverage: + @go test ./... -coverprofile=coverage.out + @go tool cover -func=coverage.out | grep '^total:' + @go tool cover -func=coverage.out | grep -v '^total:' + + diff --git a/op-supernode/supernode/chain_container/chain_container.go b/op-supernode/supernode/chain_container/chain_container.go new file mode 100644 index 00000000000..71b259de4a7 --- /dev/null +++ b/op-supernode/supernode/chain_container/chain_container.go @@ -0,0 +1,181 @@ +package chain_container + +import ( + "context" + "net/http" + "path/filepath" + "sync/atomic" + "time" + + opnodecfg "github.com/ethereum-optimism/optimism/op-node/config" + rollupNode "github.com/ethereum-optimism/optimism/op-node/node" + p2p "github.com/ethereum-optimism/optimism/op-node/p2p" + "github.com/ethereum-optimism/optimism/op-service/eth" + oprpc "github.com/ethereum-optimism/optimism/op-service/rpc" + "github.com/ethereum-optimism/optimism/op-supernode/config" + "github.com/ethereum-optimism/optimism/op-supernode/supernode/chain_container/virtual_node" + gethlog "github.com/ethereum/go-ethereum/log" + "github.com/prometheus/client_golang/prometheus" + "github.com/prometheus/client_golang/prometheus/promhttp" +) + +const virtualNodeVersion = "0.0.0" + +type ChainContainer interface { + Start(ctx context.Context) error + Stop(ctx context.Context) error + Pause(ctx context.Context) error + Resume(ctx context.Context) error +} + +type virtualNodeFactory func(cfg *opnodecfg.Config, log gethlog.Logger, initOverrides *rollupNode.InitializationOverrides, appVersion string) virtual_node.VirtualNode + +type simpleChainContainer struct { + vn virtual_node.VirtualNode + vncfg *opnodecfg.Config + cfg config.CLIConfig + pause atomic.Bool + stop atomic.Bool + stopped chan struct{} + log gethlog.Logger + chainID eth.ChainID + initOverload *rollupNode.InitializationOverrides // Base shared resources for all virtual nodes + rpcHandler *oprpc.Handler // Current per-chain RPC handler instance + setHandler func(chainID string, h http.Handler) // Set the RPC handler on the router for the chain + setMetricsHandler func(chainID string, h http.Handler) // Set the metrics handler on the router for the chain + appVersion string + virtualNodeFactory virtualNodeFactory // Factory function to create virtual node (for testing) +} + +func NewChainContainer( + chainID eth.ChainID, + vncfg *opnodecfg.Config, + log gethlog.Logger, + cfg config.CLIConfig, + initOverload *rollupNode.InitializationOverrides, + rpcHandler *oprpc.Handler, + setHandler func(chainID string, h http.Handler), + setMetricsHandler func(chainID string, h http.Handler), +) ChainContainer { + c := &simpleChainContainer{ + vncfg: vncfg, + cfg: cfg, + chainID: chainID, + log: log, + stopped: make(chan struct{}, 1), + initOverload: initOverload, + rpcHandler: rpcHandler, + setHandler: setHandler, + setMetricsHandler: setMetricsHandler, + appVersion: virtualNodeVersion, + virtualNodeFactory: defaultVirtualNodeFactory, + } + // Disable P2P and inherit paths from supernode base config + vncfg.P2P = &p2p.Config{DisableP2P: true} + vncfg.SafeDBPath = c.subPath("safe_db") + vncfg.RPC = cfg.RPCConfig + return c +} + +// defaultVirtualNodeFactory is the default factory that creates a real VirtualNode +func defaultVirtualNodeFactory(cfg *opnodecfg.Config, log gethlog.Logger, initOverload *rollupNode.InitializationOverrides, appVersion string) virtual_node.VirtualNode { + return virtual_node.NewVirtualNode(cfg, log, initOverload, appVersion) +} + +func (c *simpleChainContainer) subPath(path string) string { + return filepath.Join(c.cfg.DataDir, c.chainID.String(), path) +} + +func (c *simpleChainContainer) Start(ctx context.Context) error { + defer func() { c.stopped <- struct{}{} }() + for { + // Refresh per-start derived fields + c.vncfg.P2P = &p2p.Config{DisableP2P: true} + c.vncfg.SafeDBPath = c.subPath("safe_db") + c.vncfg.RPC = c.cfg.RPCConfig + // create a fresh handler per (re)start, swap it into the router, and inject into overload + h := oprpc.NewHandler("", oprpc.WithLogger(c.log.New("chain_id", c.chainID.String()))) + if c.setHandler != nil { + c.setHandler(c.chainID.String(), h) + } + c.initOverload.RPCHandler = h + c.rpcHandler = h + + // Disable per-VN metrics server and provide metrics registry hook + c.vncfg.Metrics.Enabled = false + if c.initOverload != nil { + chainID := c.chainID.String() + c.initOverload.MetricsRegistry = func(reg *prometheus.Registry) { + if c.setMetricsHandler != nil { + // Mount per-chain metrics handler at /{chain}/metrics via router + handler := promhttp.HandlerFor(reg, promhttp.HandlerOpts{}) + c.setMetricsHandler(chainID, handler) + } + } + } + c.vn = c.virtualNodeFactory(c.vncfg, c.log, c.initOverload, c.appVersion) + if c.pause.Load() { + c.log.Info("chain container paused") + time.Sleep(1 * time.Second) + continue + } + if c.stop.Load() { + break + } + + // start the virtual node + err := c.vn.Start(ctx) + if err != nil { + c.log.Warn("virtual node exited with error", "error", err) + } + + // always stop the virtual node after it exits + stopCtx, cancel := context.WithTimeout(context.Background(), 10*time.Second) + if stopErr := c.vn.Stop(stopCtx); stopErr != nil { + c.log.Error("error stopping virtual node", "error", stopErr) + } + cancel() + if ctx.Err() != nil { + c.log.Info("chain container context cancelled, stopping restart loop", "ctx_err", ctx.Err()) + break + } + + // check if the chain container was stopped + if c.stop.Load() { + c.log.Info("chain container stop requested, stopping restart loop") + break + } + + } + c.log.Info("chain container exiting") + return nil +} + +func (c *simpleChainContainer) Stop(ctx context.Context) error { + c.stop.Store(true) + stopCtx, cancel := context.WithTimeout(context.Background(), 30*time.Second) + defer cancel() + + if c.vn != nil { + if err := c.vn.Stop(stopCtx); err != nil { + c.log.Error("error stopping virtual node", "error", err) + } + } + + select { + case <-c.stopped: + return nil + case <-stopCtx.Done(): + return stopCtx.Err() + } +} + +func (c *simpleChainContainer) Pause(ctx context.Context) error { + c.pause.Store(true) + return nil +} + +func (c *simpleChainContainer) Resume(ctx context.Context) error { + c.pause.Store(false) + return nil +} diff --git a/op-supernode/supernode/chain_container/chain_container_test.go b/op-supernode/supernode/chain_container/chain_container_test.go new file mode 100644 index 00000000000..8d8373897de --- /dev/null +++ b/op-supernode/supernode/chain_container/chain_container_test.go @@ -0,0 +1,608 @@ +package chain_container + +import ( + "context" + "math/big" + "net/http" + "path/filepath" + "sync" + "testing" + "time" + + opnodecfg "github.com/ethereum-optimism/optimism/op-node/config" + rollupNode "github.com/ethereum-optimism/optimism/op-node/node" + "github.com/ethereum-optimism/optimism/op-node/rollup" + "github.com/ethereum-optimism/optimism/op-service/eth" + oprpc "github.com/ethereum-optimism/optimism/op-service/rpc" + "github.com/ethereum-optimism/optimism/op-supernode/config" + "github.com/ethereum-optimism/optimism/op-supernode/supernode/chain_container/virtual_node" + gethlog "github.com/ethereum/go-ethereum/log" + "github.com/stretchr/testify/require" +) + +// mockVirtualNode is a mock implementation of virtual_node.VirtualNode interface +type mockVirtualNode struct { + mu sync.Mutex + startCalled int + stopCalled int + startErr error + stopErr error + startFunc func(ctx context.Context) error + stopFunc func(ctx context.Context) error + blockOnStart bool + startSignal chan struct{} +} + +func newMockVirtualNode() *mockVirtualNode { + return &mockVirtualNode{ + startSignal: make(chan struct{}), + } +} + +func (m *mockVirtualNode) Start(ctx context.Context) error { + m.mu.Lock() + m.startCalled++ + callCount := m.startCalled + m.mu.Unlock() + + // Only close startSignal on first call to avoid panic + if callCount == 1 { + close(m.startSignal) + } + + if m.startFunc != nil { + return m.startFunc(ctx) + } + + if m.blockOnStart { + <-ctx.Done() + return ctx.Err() + } + + return m.startErr +} + +func (m *mockVirtualNode) Stop(ctx context.Context) error { + m.mu.Lock() + m.stopCalled++ + m.mu.Unlock() + + if m.stopFunc != nil { + return m.stopFunc(ctx) + } + return m.stopErr +} + +// Test helpers +func createTestVNConfig() *opnodecfg.Config { + return &opnodecfg.Config{ + Rollup: rollup.Config{ + L2ChainID: big.NewInt(420), + }, + } +} + +func createTestCLIConfig() config.CLIConfig { + return config.CLIConfig{ + DataDir: "/tmp/test", + RPCConfig: oprpc.CLIConfig{ + ListenAddr: "0.0.0.0", + ListenPort: 8545, + }, + } +} + +func createTestLogger() gethlog.Logger { + return gethlog.New() +} + +// TestChainContainer_Constructor tests initialization and configuration +func TestChainContainer_Constructor(t *testing.T) { + t.Parallel() + + chainID := eth.ChainIDFromUInt64(420) + vncfg := createTestVNConfig() + log := createTestLogger() + cfg := createTestCLIConfig() + initOverload := &rollupNode.InitializationOverrides{} + + t.Run("creates container with correct config", func(t *testing.T) { + container := NewChainContainer(chainID, vncfg, log, cfg, initOverload, nil, nil, nil) + + require.NotNil(t, container) + + impl, ok := container.(*simpleChainContainer) + require.True(t, ok) + + require.Equal(t, chainID, impl.chainID) + require.Equal(t, vncfg, impl.vncfg) + require.Equal(t, cfg, impl.cfg) + require.Equal(t, log, impl.log) + require.NotNil(t, impl.stopped) + require.Equal(t, 1, cap(impl.stopped)) + }) + + t.Run("P2P disabled for virtual nodes", func(t *testing.T) { + vncfgCopy := createTestVNConfig() + container := NewChainContainer(chainID, vncfgCopy, log, cfg, initOverload, nil, nil, nil) + + impl, ok := container.(*simpleChainContainer) + require.True(t, ok) + + require.NotNil(t, impl.vncfg.P2P) + require.True(t, impl.vncfg.P2P.Disabled()) + }) + + t.Run("SafeDBPath uses subPath", func(t *testing.T) { + cfg := config.CLIConfig{ + DataDir: "/tmp/datadir", + } + container := NewChainContainer(eth.ChainIDFromUInt64(420), vncfg, log, cfg, initOverload, nil, nil, nil) + + impl, ok := container.(*simpleChainContainer) + require.True(t, ok) + + expectedPath := filepath.Join("/tmp/datadir", "420", "safe_db") + require.Equal(t, expectedPath, impl.vncfg.SafeDBPath) + }) + + t.Run("RPC config inherited from supernode config", func(t *testing.T) { + cfg := config.CLIConfig{ + DataDir: "/tmp/test", + RPCConfig: oprpc.CLIConfig{ + ListenAddr: "127.0.0.1", + ListenPort: 9545, + }, + } + container := NewChainContainer(chainID, vncfg, log, cfg, initOverload, nil, nil, nil) + + impl, ok := container.(*simpleChainContainer) + require.True(t, ok) + + require.Equal(t, cfg.RPCConfig, impl.vncfg.RPC) + }) + + t.Run("appVersion set correctly", func(t *testing.T) { + container := NewChainContainer(chainID, vncfg, log, cfg, initOverload, nil, nil, nil) + impl, ok := container.(*simpleChainContainer) + require.True(t, ok) + + require.Equal(t, virtualNodeVersion, impl.appVersion) + }) + + t.Run("subPath combines DataDir, chainID, and path correctly", func(t *testing.T) { + cfg := config.CLIConfig{ + DataDir: "/data", + } + container := NewChainContainer(eth.ChainIDFromUInt64(420), vncfg, log, cfg, initOverload, nil, nil, nil) + impl, ok := container.(*simpleChainContainer) + require.True(t, ok) + + result := impl.subPath("safe_db") + expected := filepath.Join("/data", "420", "safe_db") + require.Equal(t, expected, result) + }) + + t.Run("subPath works with various chain IDs", func(t *testing.T) { + cfg := config.CLIConfig{ + DataDir: "/data", + } + + testCases := []struct { + chainID eth.ChainID + path string + expected string + }{ + {eth.ChainIDFromUInt64(10), "safe_db", "/data/10/safe_db"}, + {eth.ChainIDFromUInt64(11155420), "safe_db", "/data/11155420/safe_db"}, + {eth.ChainIDFromUInt64(8453), "peerstore", "/data/8453/peerstore"}, + } + + for _, tc := range testCases { + container := NewChainContainer(tc.chainID, vncfg, log, cfg, initOverload, nil, nil, nil) + impl, ok := container.(*simpleChainContainer) + require.True(t, ok) + + result := impl.subPath(tc.path) + expected := filepath.Join(cfg.DataDir, tc.chainID.String(), tc.path) + require.Equal(t, expected, result, "subPath should work for chain %d", tc.chainID) + } + }) +} + +// TestChainContainer_Lifecycle tests Start/Stop behavior +func TestChainContainer_Lifecycle(t *testing.T) { + t.Parallel() + + chainID := eth.ChainIDFromUInt64(420) + vncfg := createTestVNConfig() + log := createTestLogger() + cfg := createTestCLIConfig() + initOverload := &rollupNode.InitializationOverrides{} + + t.Run("Start respects stop flag", func(t *testing.T) { + container := NewChainContainer(chainID, vncfg, log, cfg, initOverload, nil, nil, nil) + impl, ok := container.(*simpleChainContainer) + require.True(t, ok) + + // Set stop flag before starting + impl.stop.Store(true) + + ctx := context.Background() + startDone := make(chan struct{}) + + go func() { + _ = container.Start(ctx) + close(startDone) + }() + + // Start should exit immediately due to stop flag + select { + case <-startDone: + // Success + case <-time.After(500 * time.Millisecond): + t.Fatal("Start should exit immediately when stop flag is set") + } + }) + + t.Run("Stop sets stop flag", func(t *testing.T) { + container := NewChainContainer(chainID, vncfg, log, cfg, initOverload, nil, nil, nil) + impl, ok := container.(*simpleChainContainer) + require.True(t, ok) + + require.False(t, impl.stop.Load()) + + ctx := context.Background() + _ = container.Stop(ctx) + + require.True(t, impl.stop.Load()) + }) + + t.Run("signals stopped channel on exit", func(t *testing.T) { + container := NewChainContainer(chainID, vncfg, log, cfg, initOverload, nil, nil, nil) + impl, ok := container.(*simpleChainContainer) + require.True(t, ok) + + mockVN := newMockVirtualNode() + mockVN.blockOnStart = true + impl.virtualNodeFactory = func(cfg *opnodecfg.Config, log gethlog.Logger, initOverload *rollupNode.InitializationOverrides, appVersion string) virtual_node.VirtualNode { + return mockVN + } + + ctx, cancel := context.WithCancel(context.Background()) + + go func() { + _ = container.Start(ctx) + }() + + <-mockVN.startSignal + cancel() + + select { + case <-impl.stopped: + // Success + case <-time.After(2 * time.Second): + t.Fatal("Should receive signal on stopped channel") + } + }) + + t.Run("context cancellation stops restart loop", func(t *testing.T) { + container := NewChainContainer(chainID, vncfg, log, cfg, initOverload, nil, nil, nil) + impl, ok := container.(*simpleChainContainer) + require.True(t, ok) + + mockVN := newMockVirtualNode() + mockVN.startFunc = func(ctx context.Context) error { + return nil // Exit immediately to trigger restart + } + + impl.virtualNodeFactory = func(cfg *opnodecfg.Config, log gethlog.Logger, initOverload *rollupNode.InitializationOverrides, appVersion string) virtual_node.VirtualNode { + return mockVN + } + + ctx, cancel := context.WithCancel(context.Background()) + + startDone := make(chan struct{}) + go func() { + _ = container.Start(ctx) + close(startDone) + }() + + // Wait for some restarts + require.Eventually(t, func() bool { + mockVN.mu.Lock() + defer mockVN.mu.Unlock() + return mockVN.startCalled >= 2 + }, 1*time.Second, 10*time.Millisecond) + + cancel() + + select { + case <-startDone: + // Success + case <-time.After(2 * time.Second): + t.Fatal("Start should exit after context cancellation") + } + }) + + t.Run("Stop flag stops restart loop", func(t *testing.T) { + container := NewChainContainer(chainID, vncfg, log, cfg, initOverload, nil, nil, nil) + impl, ok := container.(*simpleChainContainer) + require.True(t, ok) + + mockVN := newMockVirtualNode() + mockVN.startFunc = func(ctx context.Context) error { + return nil // Exit immediately + } + + impl.virtualNodeFactory = func(cfg *opnodecfg.Config, log gethlog.Logger, initOverload *rollupNode.InitializationOverrides, appVersion string) virtual_node.VirtualNode { + return mockVN + } + + ctx, cancel := context.WithCancel(context.Background()) + defer cancel() + + go func() { + _ = container.Start(ctx) + }() + + // Wait for at least one start + require.Eventually(t, func() bool { + mockVN.mu.Lock() + defer mockVN.mu.Unlock() + return mockVN.startCalled >= 1 + }, 1*time.Second, 10*time.Millisecond) + + stopCtx := context.Background() + _ = container.Stop(stopCtx) + + require.Eventually(t, func() bool { + return impl.stop.Load() + }, 1*time.Second, 10*time.Millisecond) + }) +} + +// TestChainContainer_PauseResume tests pause/resume functionality +func TestChainContainer_PauseResume(t *testing.T) { + t.Parallel() + + chainID := eth.ChainIDFromUInt64(420) + vncfg := createTestVNConfig() + log := createTestLogger() + cfg := createTestCLIConfig() + initOverload := &rollupNode.InitializationOverrides{} + + t.Run("Pause sets pause flag", func(t *testing.T) { + container := NewChainContainer(chainID, vncfg, log, cfg, initOverload, nil, nil, nil) + impl, ok := container.(*simpleChainContainer) + require.True(t, ok) + + ctx := context.Background() + err := container.Pause(ctx) + + require.NoError(t, err) + require.True(t, impl.pause.Load()) + }) + + t.Run("Resume clears pause flag", func(t *testing.T) { + container := NewChainContainer(chainID, vncfg, log, cfg, initOverload, nil, nil, nil) + impl, ok := container.(*simpleChainContainer) + require.True(t, ok) + + impl.pause.Store(true) + + ctx := context.Background() + err := container.Resume(ctx) + + require.NoError(t, err) + require.False(t, impl.pause.Load()) + }) + + t.Run("paused container doesn't start VN, resumed does", func(t *testing.T) { + container := NewChainContainer(chainID, vncfg, log, cfg, initOverload, nil, nil, nil) + impl, ok := container.(*simpleChainContainer) + require.True(t, ok) + + var startedSignal = make(chan struct{}) + var totalStartCalls int + var mu sync.Mutex + + impl.virtualNodeFactory = func(cfg *opnodecfg.Config, log gethlog.Logger, initOverload *rollupNode.InitializationOverrides, appVersion string) virtual_node.VirtualNode { + mockVN := newMockVirtualNode() + mockVN.blockOnStart = true + mockVN.startFunc = func(ctx context.Context) error { + mu.Lock() + totalStartCalls++ + mu.Unlock() + select { + case startedSignal <- struct{}{}: + default: + } + <-ctx.Done() + return ctx.Err() + } + return mockVN + } + + // Pause the container + impl.pause.Store(true) + + ctx, cancel := context.WithTimeout(context.Background(), 500*time.Millisecond) + defer cancel() + + go func() { + _ = container.Start(ctx) + }() + + // Wait for VN to be created + require.Eventually(t, func() bool { + return impl.vn != nil + }, 1*time.Second, 10*time.Millisecond) + + // VN should be created but not started + mu.Lock() + require.Equal(t, 0, totalStartCalls) + mu.Unlock() + + // Now resume + impl.pause.Store(false) + + select { + case <-startedSignal: + // Success + case <-time.After(2 * time.Second): + mu.Lock() + calls := totalStartCalls + mu.Unlock() + t.Fatalf("VN should be started after resume (got %d start calls)", calls) + } + + mu.Lock() + require.Equal(t, 1, totalStartCalls) + mu.Unlock() + }) +} + +// TestChainContainer_VirtualNodeIntegration tests interaction with VirtualNode +func TestChainContainer_VirtualNodeIntegration(t *testing.T) { + t.Parallel() + + chainID := eth.ChainIDFromUInt64(420) + vncfg := createTestVNConfig() + log := createTestLogger() + cfg := createTestCLIConfig() + initOverload := &rollupNode.InitializationOverrides{} + + t.Run("Start creates and starts virtual node", func(t *testing.T) { + container := NewChainContainer(chainID, vncfg, log, cfg, initOverload, nil, nil, nil) + impl, ok := container.(*simpleChainContainer) + require.True(t, ok) + + mockVN := newMockVirtualNode() + mockVN.blockOnStart = true + + impl.virtualNodeFactory = func(cfg *opnodecfg.Config, log gethlog.Logger, initOverload *rollupNode.InitializationOverrides, appVersion string) virtual_node.VirtualNode { + return mockVN + } + + ctx, cancel := context.WithTimeout(context.Background(), 200*time.Millisecond) + defer cancel() + + go func() { + _ = container.Start(ctx) + }() + + select { + case <-mockVN.startSignal: + // Success + case <-time.After(500 * time.Millisecond): + t.Fatal("VN Start should have been called") + } + + require.Equal(t, 1, mockVN.startCalled) + }) + + t.Run("auto-restart virtual node on exit", func(t *testing.T) { + container := NewChainContainer(chainID, vncfg, log, cfg, initOverload, nil, nil, nil) + impl, ok := container.(*simpleChainContainer) + require.True(t, ok) + + restartCount := 0 + mockVN := &mockVirtualNode{ + startSignal: make(chan struct{}), + } + + mockVN.startFunc = func(ctx context.Context) error { + restartCount++ + if restartCount < 3 { + return nil // Exit immediately to trigger restart + } + <-ctx.Done() + return ctx.Err() + } + + impl.virtualNodeFactory = func(cfg *opnodecfg.Config, log gethlog.Logger, initOverload *rollupNode.InitializationOverrides, appVersion string) virtual_node.VirtualNode { + return mockVN + } + + ctx, cancel := context.WithTimeout(context.Background(), 300*time.Millisecond) + defer cancel() + + go func() { + _ = container.Start(ctx) + }() + + require.Eventually(t, func() bool { + return restartCount >= 3 + }, 1*time.Second, 10*time.Millisecond) + }) + + t.Run("Stop calls virtual node Stop", func(t *testing.T) { + container := NewChainContainer(chainID, vncfg, log, cfg, initOverload, nil, nil, nil) + impl, ok := container.(*simpleChainContainer) + require.True(t, ok) + + mockVN := newMockVirtualNode() + mockVN.blockOnStart = true + + impl.virtualNodeFactory = func(cfg *opnodecfg.Config, log gethlog.Logger, initOverload *rollupNode.InitializationOverrides, appVersion string) virtual_node.VirtualNode { + return mockVN + } + + ctx, cancel := context.WithCancel(context.Background()) + go func() { + _ = container.Start(ctx) + }() + + <-mockVN.startSignal + + // Ensure VN is set in container + require.Eventually(t, func() bool { + return impl.vn != nil + }, 1*time.Second, 10*time.Millisecond) + + stopCtx := context.Background() + _ = container.Stop(stopCtx) + + require.Eventually(t, func() bool { + mockVN.mu.Lock() + defer mockVN.mu.Unlock() + return mockVN.stopCalled >= 1 + }, 2*time.Second, 10*time.Millisecond) + + cancel() + }) + + t.Run("registers handler with reverse proxy", func(t *testing.T) { + var setHandlerCalled bool + var calledChainID string + + setHandler := func(id string, h http.Handler) { + setHandlerCalled = true + calledChainID = id + } + + container := NewChainContainer(chainID, vncfg, log, cfg, initOverload, nil, setHandler, nil) + impl, ok := container.(*simpleChainContainer) + require.True(t, ok) + + mockVN := newMockVirtualNode() + mockVN.blockOnStart = true + impl.virtualNodeFactory = func(cfg *opnodecfg.Config, log gethlog.Logger, initOverload *rollupNode.InitializationOverrides, appVersion string) virtual_node.VirtualNode { + return mockVN + } + + ctx, cancel := context.WithTimeout(context.Background(), 200*time.Millisecond) + defer cancel() + + go func() { + _ = container.Start(ctx) + }() + + <-mockVN.startSignal + + require.Eventually(t, func() bool { + return setHandlerCalled && calledChainID == "420" + }, 1*time.Second, 10*time.Millisecond) + }) +} diff --git a/op-supernode/supernode/chain_container/engine_controller/engine_controller.go b/op-supernode/supernode/chain_container/engine_controller/engine_controller.go new file mode 100644 index 00000000000..2dc77e163c1 --- /dev/null +++ b/op-supernode/supernode/chain_container/engine_controller/engine_controller.go @@ -0,0 +1,11 @@ +package engine_controller + +type EngineController interface { +} + +type simpleEngineController struct { +} + +func NewEngineController() EngineController { + return &simpleEngineController{} +} diff --git a/op-supernode/supernode/chain_container/virtual_node/virtual_node.go b/op-supernode/supernode/chain_container/virtual_node/virtual_node.go new file mode 100644 index 00000000000..596f62a5456 --- /dev/null +++ b/op-supernode/supernode/chain_container/virtual_node/virtual_node.go @@ -0,0 +1,176 @@ +package virtual_node + +import ( + "context" + "errors" + "sync" + + opnodecfg "github.com/ethereum-optimism/optimism/op-node/config" + opmetrics "github.com/ethereum-optimism/optimism/op-node/metrics" + rollupNode "github.com/ethereum-optimism/optimism/op-node/node" + gethlog "github.com/ethereum/go-ethereum/log" + "github.com/google/uuid" +) + +// defaultInnerNodeFactory is the default factory that creates a real op-node +func defaultInnerNodeFactory(ctx context.Context, cfg *opnodecfg.Config, log gethlog.Logger, appVersion string, m *opmetrics.Metrics, initOverload *rollupNode.InitializationOverrides) (innerNode, error) { + var overrides rollupNode.InitializationOverrides + if initOverload != nil { + overrides = *initOverload + } + return rollupNode.NewWithOverride(ctx, cfg, log, appVersion, m, overrides) +} + +var ( + ErrVirtualNodeConfigNil = errors.New("virtual node config is nil") + ErrVirtualNodeAlreadyRunning = errors.New("virtual node already running") + ErrVirtualNodeNotRunning = errors.New("virtual node not running") + ErrVirtualNodeCantStart = errors.New("virtual node cannot be started in this state") +) + +type VirtualNode interface { + Start(ctx context.Context) error + Stop(ctx context.Context) error +} + +type innerNode interface { + Start(ctx context.Context) error + Stop(ctx context.Context) error +} + +type innerNodeFactory func(ctx context.Context, cfg *opnodecfg.Config, log gethlog.Logger, appVersion string, m *opmetrics.Metrics, initOverload *rollupNode.InitializationOverrides) (innerNode, error) + +type VNState int + +const ( + VNStateNotStarted VNState = iota + VNStateRunning + VNStateStopped +) + +type simpleVirtualNode struct { + log gethlog.Logger + vnID string + appVersion string + + inner innerNode // Inner node instance + cfg *opnodecfg.Config // op-node config for the virtual node + initOverload *rollupNode.InitializationOverrides // Shared resources which are overridden by the supernode + innerNodeFactory innerNodeFactory // Factory function to create inner node (overloadable for testing) + + mu sync.Mutex // Protects state transitions + state VNState // Current lifecycle state + cancel context.CancelFunc // Cancels the running context +} + +func generateVirtualNodeID() string { + return uuid.New().String()[:4] +} + +func NewVirtualNode(cfg *opnodecfg.Config, log gethlog.Logger, initOverload *rollupNode.InitializationOverrides, appVersion string) *simpleVirtualNode { + vnID := generateVirtualNodeID() + l := log.New("chain_id", cfg.Rollup.L2ChainID.String(), "vn_id", vnID) + return &simpleVirtualNode{ + vnID: vnID, + cfg: cfg, + log: l, + initOverload: initOverload, + appVersion: appVersion, + innerNodeFactory: defaultInnerNodeFactory, + state: VNStateNotStarted, + } +} + +func (v *simpleVirtualNode) Start(ctx context.Context) error { + // Accquire lock while setting up inner node + v.mu.Lock() + if v.state != VNStateNotStarted { + v.mu.Unlock() + v.log.Debug("virtual node not in a valid state to start", "state", v.state) + return ErrVirtualNodeCantStart + } + if v.cfg == nil { + v.mu.Unlock() + return ErrVirtualNodeConfigNil + } + + runCtx, cancel := context.WithCancel(ctx) + v.cancel = cancel + + // Capture inner node errors via cancel callback + var innerErr error + v.cfg.Cancel = func(err error) { + innerErr = err + cancel() // Cancel the run context when inner node fails + } + + // Create and start the inner node + m := opmetrics.NewMetrics("supernode") + n, err := v.innerNodeFactory(runCtx, v.cfg, v.log, v.appVersion, m, v.initOverload) + if err != nil { + v.state = VNStateStopped + v.mu.Unlock() + return err + } + v.inner = n + // Release the lock once the inner node is created + v.state = VNStateRunning + v.mu.Unlock() + // Don't hold the lock while running or waiting for inner node to stop + + // Run inner node in goroutine + // and await any signal to exit (Stop(), parent ctx, or inner error) + go func() { + innerErr = v.inner.Start(runCtx) + }() + <-runCtx.Done() + + // Clean up with lock to end of function + v.mu.Lock() + defer v.mu.Unlock() + v.state = VNStateStopped + v.cancel = nil + + // Stop the inner node if it's still running + if v.inner != nil { + stopCtx := context.Background() + if err := v.inner.Stop(stopCtx); err != nil { + v.log.Error("error stopping inner node", "err", err) + } + } + + // Return inner error if that's what caused the cancellation, otherwise context error + if innerErr != nil { + v.log.Warn("virtual node stopped due to inner error", "err", innerErr) + return innerErr + } + if ctx.Err() != nil { + v.log.Warn("virtual node stopped due to context cancellation", "err", ctx.Err()) + return ctx.Err() + } + v.log.Info("virtual node stopped") + return nil +} + +func (v *simpleVirtualNode) Stop(ctx context.Context) error { + v.mu.Lock() + defer v.mu.Unlock() + + if v.state != VNStateRunning { + return nil // Already stopped or not started + } + + // Cancel the run context to trigger shutdown + if v.cancel != nil { + v.cancel() + } + + return nil +} + +// State returns the current state of the virtual node (for testing and monitoring) +func (v *simpleVirtualNode) State() VNState { + v.mu.Lock() + defer v.mu.Unlock() + return v.state +} diff --git a/op-supernode/supernode/chain_container/virtual_node/virtual_node_test.go b/op-supernode/supernode/chain_container/virtual_node/virtual_node_test.go new file mode 100644 index 00000000000..5b6e89feec8 --- /dev/null +++ b/op-supernode/supernode/chain_container/virtual_node/virtual_node_test.go @@ -0,0 +1,359 @@ +package virtual_node + +import ( + "context" + "errors" + "math/big" + "regexp" + "testing" + "time" + + opnodecfg "github.com/ethereum-optimism/optimism/op-node/config" + opmetrics "github.com/ethereum-optimism/optimism/op-node/metrics" + rollupNode "github.com/ethereum-optimism/optimism/op-node/node" + "github.com/ethereum-optimism/optimism/op-node/rollup" + gethlog "github.com/ethereum/go-ethereum/log" + "github.com/stretchr/testify/require" +) + +// mockInnerNode is a mock implementation of innerNode interface for testing +type mockInnerNode struct { + startCh chan struct{} + stopCh chan struct{} + startErr error + stopErr error + startFunc func(ctx context.Context) + started bool +} + +func newMockInnerNode() *mockInnerNode { + return &mockInnerNode{ + startCh: make(chan struct{}), + stopCh: make(chan struct{}), + } +} + +func (m *mockInnerNode) Start(ctx context.Context) error { + m.started = true + if m.startCh != nil { + close(m.startCh) + } + if m.startFunc != nil { + m.startFunc(ctx) + } + return m.startErr +} + +func (m *mockInnerNode) Stop(ctx context.Context) error { + if m.stopCh != nil { + close(m.stopCh) + } + return m.stopErr +} + +// Test helpers +func createTestConfig() *opnodecfg.Config { + return &opnodecfg.Config{ + Rollup: rollup.Config{ + L2ChainID: big.NewInt(420), + }, + } +} + +func createTestLogger() gethlog.Logger { + return gethlog.New() +} + +func createMockFactory(mock *mockInnerNode) innerNodeFactory { + return func(ctx context.Context, cfg *opnodecfg.Config, log gethlog.Logger, appVersion string, m *opmetrics.Metrics, initOverload *rollupNode.InitializationOverrides) (innerNode, error) { + return mock, nil + } +} + +// TestVirtualNode_Constructor tests constructor and initialization +func TestVirtualNode_Constructor(t *testing.T) { + t.Parallel() + + cfg := createTestConfig() + log := createTestLogger() + initOverload := &rollupNode.InitializationOverrides{} + appVersion := "v1.0.0" + + t.Run("creates node with correct config", func(t *testing.T) { + vn := NewVirtualNode(cfg, log, initOverload, appVersion) + + require.NotNil(t, vn) + require.Equal(t, cfg, vn.cfg) + require.Equal(t, initOverload, vn.initOverload) + require.Equal(t, appVersion, vn.appVersion) + require.Len(t, vn.vnID, 4) + require.Equal(t, VNStateNotStarted, vn.State()) + }) + + t.Run("generates unique 4-character IDs", func(t *testing.T) { + id1 := generateVirtualNodeID() + id2 := generateVirtualNodeID() + id3 := generateVirtualNodeID() + + require.Len(t, id1, 4) + require.NotEqual(t, id1, id2) + require.NotEqual(t, id2, id3) + + matched, err := regexp.MatchString("^[0-9a-f-]{4}$", id1) + require.NoError(t, err) + require.True(t, matched) + }) + + t.Run("sets custom appVersion", func(t *testing.T) { + customVersion := "v2.3.4" + vn := NewVirtualNode(cfg, log, initOverload, customVersion) + require.Equal(t, customVersion, vn.appVersion) + }) +} + +// TestVirtualNode_Lifecycle tests the complete Start/Stop lifecycle +func TestVirtualNode_Lifecycle(t *testing.T) { + t.Parallel() + + log := createTestLogger() + cfg := createTestConfig() + initOverload := &rollupNode.InitializationOverrides{} + appVersion := "test" + + t.Run("Start with nil config returns error", func(t *testing.T) { + vn := NewVirtualNode(cfg, log, initOverload, appVersion) + vn.cfg = nil + + err := vn.Start(context.Background()) + require.ErrorIs(t, err, ErrVirtualNodeConfigNil) + }) + + t.Run("Start transitions through states correctly", func(t *testing.T) { + mock := newMockInnerNode() + mock.startFunc = func(ctx context.Context) { + <-ctx.Done() + } + + vn := NewVirtualNode(cfg, log, initOverload, appVersion) + vn.innerNodeFactory = createMockFactory(mock) + + require.Equal(t, VNStateNotStarted, vn.State()) + + ctx, cancel := context.WithCancel(context.Background()) + defer cancel() + + go func() { + _ = vn.Start(ctx) + }() + + // Wait for it to be running + require.Eventually(t, func() bool { + return vn.State() == VNStateRunning + }, 1*time.Second, 10*time.Millisecond) + + // Cancel and wait for stopped + cancel() + require.Eventually(t, func() bool { + return vn.State() == VNStateStopped + }, 1*time.Second, 10*time.Millisecond) + }) + + t.Run("Start on already running node returns error", func(t *testing.T) { + mock := newMockInnerNode() + mock.startFunc = func(ctx context.Context) { + <-ctx.Done() + } + + vn := NewVirtualNode(cfg, log, initOverload, appVersion) + vn.innerNodeFactory = createMockFactory(mock) + + // Start it first + ctx, cancel := context.WithCancel(context.Background()) + defer cancel() + + go func() { + _ = vn.Start(ctx) + }() + + require.Eventually(t, func() bool { + return vn.State() == VNStateRunning + }, 1*time.Second, 10*time.Millisecond) + + // Try to start again while running + err := vn.Start(context.Background()) + require.Error(t, err) + require.Contains(t, err.Error(), "cannot be started in this state") + + cancel() + }) + + t.Run("Stop on non-running node is no-op", func(t *testing.T) { + vn := NewVirtualNode(cfg, log, initOverload, appVersion) + require.Equal(t, VNStateNotStarted, vn.State()) + + err := vn.Stop(context.Background()) + require.NoError(t, err) + }) + + t.Run("Stop causes Start to exit", func(t *testing.T) { + mock := newMockInnerNode() + mock.startFunc = func(ctx context.Context) { + <-ctx.Done() + } + + vn := NewVirtualNode(cfg, log, initOverload, appVersion) + vn.innerNodeFactory = createMockFactory(mock) + + ctx := context.Background() + startDone := make(chan error, 1) + + go func() { + startDone <- vn.Start(ctx) + }() + + // Wait for running state + require.Eventually(t, func() bool { + return vn.State() == VNStateRunning + }, 1*time.Second, 10*time.Millisecond) + + // Stop it + err := vn.Stop(ctx) + require.NoError(t, err) + + // Start should exit + select { + case <-startDone: + require.Equal(t, VNStateStopped, vn.State()) + case <-time.After(2 * time.Second): + t.Fatal("Start should exit after Stop") + } + }) + + t.Run("Stop is idempotent", func(t *testing.T) { + vn := NewVirtualNode(cfg, log, initOverload, appVersion) + ctx := context.Background() + + // Multiple stops should all succeed + require.NoError(t, vn.Stop(ctx)) + require.NoError(t, vn.Stop(ctx)) + require.NoError(t, vn.Stop(ctx)) + }) + +} + +// TestVirtualNode_InnerNodeIntegration tests interaction with inner node +func TestVirtualNode_InnerNodeIntegration(t *testing.T) { + t.Parallel() + + log := createTestLogger() + cfg := createTestConfig() + initOverload := &rollupNode.InitializationOverrides{} + appVersion := "test" + + t.Run("Start calls inner node Start", func(t *testing.T) { + mock := newMockInnerNode() + mock.startFunc = func(ctx context.Context) { + <-ctx.Done() + } + + vn := NewVirtualNode(cfg, log, initOverload, appVersion) + vn.innerNodeFactory = createMockFactory(mock) + + ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second) + defer cancel() + + go func() { + _ = vn.Start(ctx) + }() + + require.Eventually(t, func() bool { + return vn.State() == VNStateRunning && mock.started + }, 1*time.Second, 10*time.Millisecond) + }) + + t.Run("Stop calls inner node Stop", func(t *testing.T) { + mock := newMockInnerNode() + mock.startFunc = func(ctx context.Context) { + <-ctx.Done() + } + + vn := NewVirtualNode(cfg, log, initOverload, appVersion) + vn.innerNodeFactory = createMockFactory(mock) + + ctx, cancel := context.WithCancel(context.Background()) + defer cancel() + + startDone := make(chan struct{}) + go func() { + _ = vn.Start(ctx) + close(startDone) + }() + + // Wait for it to be running + require.Eventually(t, func() bool { + return vn.State() == VNStateRunning + }, 1*time.Second, 10*time.Millisecond) + + _ = vn.Stop(ctx) + + select { + case <-startDone: + // Verify inner Stop was called + select { + case <-mock.stopCh: + // Success + default: + t.Fatal("inner node Stop should be called") + } + case <-time.After(2 * time.Second): + t.Fatal("Start should complete after Stop") + } + }) + + t.Run("inner node error propagates through cancel callback", func(t *testing.T) { + mock := newMockInnerNode() + vn := NewVirtualNode(cfg, log, initOverload, appVersion) + + mock.startFunc = func(ctx context.Context) { + if vn.cfg.Cancel != nil { + vn.cfg.Cancel(errors.New("inner node error")) + } + } + + vn.innerNodeFactory = createMockFactory(mock) + + ctx, cancel := context.WithTimeout(context.Background(), 500*time.Millisecond) + defer cancel() + + err := vn.Start(ctx) + + require.Error(t, err) + require.Contains(t, err.Error(), "inner node error") + }) + + t.Run("cancel callback is configured", func(t *testing.T) { + mock := newMockInnerNode() + mock.startFunc = func(ctx context.Context) { + <-ctx.Done() + } + + // Create fresh config to ensure Cancel is nil + freshCfg := createTestConfig() + vn := NewVirtualNode(freshCfg, log, initOverload, appVersion) + vn.innerNodeFactory = createMockFactory(mock) + + require.Nil(t, vn.cfg.Cancel, "Cancel should be nil initially") + + ctx, cancel := context.WithCancel(context.Background()) + defer cancel() + + go func() { + _ = vn.Start(ctx) + }() + + require.Eventually(t, func() bool { + return vn.cfg.Cancel != nil + }, 1*time.Second, 10*time.Millisecond) + cancel() + }) +} diff --git a/op-supernode/supernode/resources/metrics_router.go b/op-supernode/supernode/resources/metrics_router.go new file mode 100644 index 00000000000..3192c2cf089 --- /dev/null +++ b/op-supernode/supernode/resources/metrics_router.go @@ -0,0 +1,83 @@ +package resources + +import ( + "io" + "net/http" + "sync" + + gethlog "github.com/ethereum/go-ethereum/log" +) + +// MetricsRouter multiplexes Prometheus metrics by the first path segment (chainID), +// and then requires the next segment to be 'metrics'. Effective paths: +// +// /{chain}/metrics +// +// The wrapped handler is expected to serve on '/'. +type MetricsRouter struct { + log gethlog.Logger + mu sync.RWMutex + paths map[string]http.Handler // chainID -> handler + // optional resource closers + closers []io.Closer +} + +func NewMetricsRouter(log gethlog.Logger) *MetricsRouter { + return &MetricsRouter{log: log, paths: make(map[string]http.Handler)} +} + +func (r *MetricsRouter) Close() error { + var firstErr error + for _, c := range r.closers { + if err := c.Close(); err != nil && firstErr == nil { + firstErr = err + } + } + return firstErr +} + +func (r *MetricsRouter) SetHandler(chainID string, h http.Handler) { + r.mu.Lock() + defer r.mu.Unlock() + if r.paths == nil { + r.paths = make(map[string]http.Handler) + } + r.paths[chainID] = h +} + +func (r *MetricsRouter) ServeHTTP(w http.ResponseWriter, req *http.Request) { + chainID, remainder := splitFirstSegment(req.URL.Path) + if chainID == "" { + http.NotFound(w, req) + return + } + // next segment must be 'metrics' + seg, _ := splitFirstSegment(remainder) + if seg != "metrics" { + http.NotFound(w, req) + return + } + + r.mu.RLock() + h, ok := r.paths[chainID] + r.mu.RUnlock() + if !ok { + http.NotFound(w, req) + return + } + + // Normalize path to '/' + origPath := req.URL.Path + origReqURI := req.RequestURI + req.URL.Path = "/" + if req.URL.RawQuery != "" { + req.RequestURI = "/?" + req.URL.RawQuery + } else { + req.RequestURI = "/" + } + defer func() { + req.URL.Path = origPath + req.RequestURI = origReqURI + }() + h.ServeHTTP(w, req) +} diff --git a/op-supernode/supernode/resources/metrics_service.go b/op-supernode/supernode/resources/metrics_service.go new file mode 100644 index 00000000000..91596c3a0b7 --- /dev/null +++ b/op-supernode/supernode/resources/metrics_service.go @@ -0,0 +1,50 @@ +package resources + +import ( + "context" + "net" + "net/http" + "strconv" + + gethlog "github.com/ethereum/go-ethereum/log" +) + +// MetricsService encapsulates an HTTP server that serves the MetricsRouter. +type MetricsService struct { + log gethlog.Logger + server *http.Server +} + +// NewMetricsService constructs a metrics HTTP server bound to the given address/port using the provided handler. +func NewMetricsService(log gethlog.Logger, listenAddr string, port int, handler http.Handler) *MetricsService { + addr := net.JoinHostPort(listenAddr, strconv.Itoa(port)) + return &MetricsService{ + log: log, + server: &http.Server{Addr: addr, Handler: handler}, + } +} + +// Start begins serving metrics in a background goroutine. If the server exits with an error, +// the optional onError callback is invoked. +func (s *MetricsService) Start(onError func(error)) { + if s.server == nil { + return + } + go func() { + s.log.Info("starting metrics router server", "addr", s.server.Addr) + if err := s.server.ListenAndServe(); err != nil && err != http.ErrServerClosed { + s.log.Error("metrics server error", "error", err) + if onError != nil { + onError(err) + } + } + }() +} + +// Stop gracefully shuts down the metrics server. +func (s *MetricsService) Stop(ctx context.Context) error { + if s.server == nil { + return nil + } + return s.server.Shutdown(ctx) +} diff --git a/op-supernode/supernode/resources/rpc_router.go b/op-supernode/supernode/resources/rpc_router.go new file mode 100644 index 00000000000..06b71a071f4 --- /dev/null +++ b/op-supernode/supernode/resources/rpc_router.go @@ -0,0 +1,98 @@ +package resources + +import ( + "io" + "net/http" + "strings" + "sync" + + gethlog "github.com/ethereum/go-ethereum/log" +) + +// RouterConfig defines runtime options for the RPC router server. +type RouterConfig struct { + EnableWebsockets bool + MaxBodyBytes int64 +} + +// Router multiplexes JSON-RPC requests by the first path segment which represents the chainID. +type Router struct { + log gethlog.Logger + cfg RouterConfig + mu sync.RWMutex + paths map[string]http.Handler // chainID -> handler + closers []io.Closer +} + +// NewRouter constructs an empty Router. Handlers can be added later via SetHandler. +func NewRouter(log gethlog.Logger, cfg RouterConfig) *Router { + return &Router{log: log, cfg: cfg, paths: make(map[string]http.Handler)} +} + +// Close releases any resources created by the factory. +func (r *Router) Close() error { + var firstErr error + for _, c := range r.closers { + if err := c.Close(); err != nil && firstErr == nil { + firstErr = err + } + } + return firstErr +} + +// SetHandler replaces or adds the handler for a given chainID at runtime. +func (r *Router) SetHandler(chainID string, h http.Handler) { + r.mu.Lock() + defer r.mu.Unlock() + if r.paths == nil { + r.paths = make(map[string]http.Handler) + } + r.paths[chainID] = h +} + +// ServeHTTP routes requests to the chain-specific handler, after stripping the chain prefix. +func (r *Router) ServeHTTP(w http.ResponseWriter, req *http.Request) { + chainID, remainder := splitFirstSegment(req.URL.Path) + if chainID == "" { + http.NotFound(w, req) + return + } + + r.mu.RLock() + h, ok := r.paths[chainID] + r.mu.RUnlock() + if !ok { + http.NotFound(w, req) + return + } + + // Rewrite path so the downstream handler sees root or the remaining path after the chainID + // We only touch URL.Path and RequestURI for correctness; leave the body and headers intact. + origPath := req.URL.Path + origReqURI := req.RequestURI + req.URL.Path = remainder + if req.URL.RawQuery != "" { + req.RequestURI = remainder + "?" + req.URL.RawQuery + } else { + req.RequestURI = remainder + } + defer func() { + req.URL.Path = origPath + req.RequestURI = origReqURI + }() + + h.ServeHTTP(w, req) +} + +// splitFirstSegment returns the first non-empty path segment and the remainder path starting with '/'. +func splitFirstSegment(p string) (seg string, remainder string) { + p = strings.TrimPrefix(p, "/") + if p == "" { + return "", "/" + } + idx := strings.IndexByte(p, '/') + if idx == -1 { + return p, "/" + } + return p[:idx], "/" + p[idx+1:] +} diff --git a/op-supernode/supernode/resources/rpc_router_test.go b/op-supernode/supernode/resources/rpc_router_test.go new file mode 100644 index 00000000000..95726c3bee7 --- /dev/null +++ b/op-supernode/supernode/resources/rpc_router_test.go @@ -0,0 +1,59 @@ +package resources + +import ( + "net/http" + "net/http/httptest" + "testing" + + gethlog "github.com/ethereum/go-ethereum/log" +) + +func rpcEchoHandler(t *testing.T, name string) http.Handler { + return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { + w.Header().Set("X-Chain", name) + _, _ = w.Write([]byte(r.URL.Path)) + }) +} + +func TestDispatchToCorrectChain(t *testing.T) { + l := gethlog.Root() + router := NewRouter(l, RouterConfig{}) + router.SetHandler("10", rpcEchoHandler(t, "10")) + router.SetHandler("20", rpcEchoHandler(t, "20")) + + rec := httptest.NewRecorder() + req := httptest.NewRequest(http.MethodPost, "/10", nil) + router.ServeHTTP(rec, req) + if got := rec.Header().Get("X-Chain"); got != "10" { + t.Fatalf("expected chain 10, got %q", got) + } + if body := rec.Body.String(); body != "/" { + t.Fatalf("expected path /, got %q", body) + } +} + +func TestPathRewriting(t *testing.T) { + l := gethlog.Root() + router := NewRouter(l, RouterConfig{}) + router.SetHandler("10", http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { + _, _ = w.Write([]byte(r.URL.Path)) + })) + rec := httptest.NewRecorder() + req := httptest.NewRequest(http.MethodGet, "/10/eth_blockNumber", nil) + router.ServeHTTP(rec, req) + if body := rec.Body.String(); body != "/eth_blockNumber" { + t.Fatalf("expected path /eth_blockNumber, got %q", body) + } +} + +func TestUnknownChain(t *testing.T) { + l := gethlog.Root() + router := NewRouter(l, RouterConfig{}) + router.SetHandler("10", http.NotFoundHandler()) + rec := httptest.NewRecorder() + req := httptest.NewRequest(http.MethodPost, "/999", nil) + router.ServeHTTP(rec, req) + if rec.Code != http.StatusNotFound { + t.Fatalf("expected 404, got %d", rec.Code) + } +} diff --git a/op-supernode/supernode/resources/shared_clients.go b/op-supernode/supernode/resources/shared_clients.go new file mode 100644 index 00000000000..683308f4d89 --- /dev/null +++ b/op-supernode/supernode/resources/shared_clients.go @@ -0,0 +1,75 @@ +package resources + +import ( + "context" + + "github.com/ethereum-optimism/optimism/op-service/client" + "github.com/ethereum-optimism/optimism/op-service/sources" + "github.com/ethereum/go-ethereum" + "github.com/ethereum/go-ethereum/rpc" +) + +// NonCloseableL1Client wraps an L1Client to prevent it from being closed. +// This is used when sharing a single L1Client across multiple virtual nodes, +// where we don't want any individual node to close the shared resource. +type NonCloseableL1Client struct { + *sources.L1Client +} + +// NewNonCloseableL1Client wraps an L1Client to prevent closure. +func NewNonCloseableL1Client(client *sources.L1Client) *NonCloseableL1Client { + return &NonCloseableL1Client{L1Client: client} +} + +// Close is a no-op for the non-closeable wrapper. +// The underlying client should only be closed when the supernode itself shuts down. +func (c *NonCloseableL1Client) Close() { +} + +// NonCloseableL1BeaconClient wraps an L1BeaconClient to prevent it from being closed. +// This is used when sharing a single beacon client across multiple virtual nodes. +type NonCloseableL1BeaconClient struct { + *sources.L1BeaconClient +} + +// NewNonCloseableL1BeaconClient wraps an L1BeaconClient to prevent closure. +// Returns nil if the input client is nil (beacon client is optional). +func NewNonCloseableL1BeaconClient(client *sources.L1BeaconClient) *NonCloseableL1BeaconClient { + if client == nil { + return nil + } + return &NonCloseableL1BeaconClient{L1BeaconClient: client} +} + +func (c *NonCloseableL1BeaconClient) Close() { +} + +// NonCloseableRPC wraps an RPC client to prevent it from being closed. +// This is used when sharing a single RPC connection across multiple clients. +type NonCloseableRPC struct { + client.RPC +} + +// NewNonCloseableRPC wraps an RPC client to prevent closure. +func NewNonCloseableRPC(rpcClient client.RPC) *NonCloseableRPC { + return &NonCloseableRPC{RPC: rpcClient} +} + +// Close is a no-op for the non-closeable wrapper. +func (c *NonCloseableRPC) Close() { +} + +// CallContext delegates to the underlying RPC client +func (c *NonCloseableRPC) CallContext(ctx context.Context, result any, method string, args ...any) error { + return c.RPC.CallContext(ctx, result, method, args...) +} + +// BatchCallContext delegates to the underlying RPC client +func (c *NonCloseableRPC) BatchCallContext(ctx context.Context, b []rpc.BatchElem) error { + return c.RPC.BatchCallContext(ctx, b) +} + +// Subscribe delegates to the underlying RPC client +func (c *NonCloseableRPC) Subscribe(ctx context.Context, namespace string, channel any, args ...any) (ethereum.Subscription, error) { + return c.RPC.Subscribe(ctx, namespace, channel, args...) +} diff --git a/op-supernode/supernode/supernode.go b/op-supernode/supernode/supernode.go new file mode 100644 index 00000000000..494d25f7b9c --- /dev/null +++ b/op-supernode/supernode/supernode.go @@ -0,0 +1,257 @@ +package supernode + +import ( + "context" + "fmt" + "net" + "strconv" + "sync" + "time" + + opnodecfg "github.com/ethereum-optimism/optimism/op-node/config" + rollupNode "github.com/ethereum-optimism/optimism/op-node/node" + "github.com/ethereum-optimism/optimism/op-service/client" + "github.com/ethereum-optimism/optimism/op-service/eth" + "github.com/ethereum-optimism/optimism/op-service/httputil" + "github.com/ethereum-optimism/optimism/op-service/sources" + cc "github.com/ethereum-optimism/optimism/op-supernode/supernode/chain_container" + "github.com/ethereum-optimism/optimism/op-supernode/supernode/resources" + gethlog "github.com/ethereum/go-ethereum/log" + + "github.com/ethereum-optimism/optimism/op-supernode/config" +) + +type Supernode struct { + log gethlog.Logger + version string + requestStop context.CancelCauseFunc + stopped bool + cfg *config.CLIConfig + chains map[eth.ChainID]cc.ChainContainer + wg sync.WaitGroup + l1Client *sources.L1Client + beaconClient *sources.L1BeaconClient + httpServer *httputil.HTTPServer + rpcRouter *resources.Router + // Metrics router/server for per-chain metrics + metrics *resources.MetricsService + metricsRouter *resources.MetricsRouter + // cached address when available + rpcAddr string +} + +func New(ctx context.Context, log gethlog.Logger, version string, requestStop context.CancelCauseFunc, cfg *config.CLIConfig, vnCfgs map[eth.ChainID]*opnodecfg.Config) (*Supernode, error) { + s := &Supernode{log: log, version: version, requestStop: requestStop, cfg: cfg, chains: make(map[eth.ChainID]cc.ChainContainer)} + + // Initialize L1 client + if err := s.initL1Client(ctx, cfg); err != nil { + return nil, fmt.Errorf("failed to initialize L1 client: %w", err) + } + + // Initialize L1 Beacon client (optional) + if err := s.initBeaconClient(ctx, cfg); err != nil { + return nil, fmt.Errorf("failed to initialize L1 Beacon client: %w", err) + } + + // Initialize chain containers for each configured chain ID + // Pass shared resources via InitializationOverrides to all containers + // Build RPC router first; we'll attach per-chain handlers at runtime via SetHandler + s.rpcRouter = resources.NewRouter(log, resources.RouterConfig{}) + // Build metrics router; attach per-chain registries later + s.metricsRouter = resources.NewMetricsRouter(log) + for _, id := range cfg.Chains { + chainID := eth.ChainIDFromUInt64(id) + initOverrides := &rollupNode.InitializationOverrides{ + L1Source: resources.NewNonCloseableL1Client(s.l1Client), + Beacon: resources.NewNonCloseableL1BeaconClient(s.beaconClient), + } + // no rpc handler is passed to the chain container, it will create a new one per (re)start using rpcRouter.SetHandler + if vnCfgs[chainID] == nil { + log.Error("missing virtual node config for chain", "chain", id) + continue + } + s.chains[chainID] = cc.NewChainContainer(chainID, vnCfgs[chainID], log, *cfg, initOverrides, nil, s.rpcRouter.SetHandler, s.metricsRouter.SetHandler) + } + addr := net.JoinHostPort(cfg.RPCConfig.ListenAddr, strconv.Itoa(cfg.RPCConfig.ListenPort)) + s.httpServer = httputil.NewHTTPServer(addr, s.rpcRouter) + + // Optionally build metrics service + if cfg.MetricsConfig.Enabled { + s.metrics = resources.NewMetricsService(log, cfg.MetricsConfig.ListenAddr, cfg.MetricsConfig.ListenPort, s.metricsRouter) + } + return s, nil +} + +func (s *Supernode) Start(ctx context.Context) error { + s.log.Info("supernode starting", "version", s.version) + if s.httpServer != nil { + s.wg.Add(1) + go func() { + defer s.wg.Done() + if err := s.httpServer.Start(); err != nil { + s.log.Error("rpc server error", "error", err) + if s.requestStop != nil { + s.requestStop(err) + } + return + } + // cache bound address for quick reads + if addr := s.httpServer.Addr(); addr != nil { + s.rpcAddr = addr.String() + s.log.Info("starting RPC router server", "addr", s.rpcAddr) + } + }() + } + // Start metrics service + if s.metrics != nil { + s.wg.Add(1) + s.metrics.Start(func(err error) { + defer s.wg.Done() + if s.requestStop != nil { + s.requestStop(err) + } + }) + } + for chainID, chain := range s.chains { + s.wg.Add(1) + go func(chainID eth.ChainID, chain cc.ChainContainer) { + defer s.wg.Done() + if err := chain.Start(ctx); err != nil { + s.log.Error("error starting chain", "chain_id", chainID.String(), "error", err) + } + }(chainID, chain) + } + <-ctx.Done() + s.log.Info("supernode received stop signal") + return ctx.Err() +} + +func (s *Supernode) Stop(ctx context.Context) error { + s.log.Info("supernode stopping") + s.stopped = true + + // Stop RPC server first, then close router resources + if s.httpServer != nil { + shutdownCtx, cancel := context.WithTimeout(ctx, 0) + defer cancel() + if err := s.httpServer.Shutdown(shutdownCtx); err != nil { + s.log.Error("error shutting down rpc server", "error", err) + } + } + if s.metrics != nil { + shutdownCtx, cancel := context.WithTimeout(ctx, 0) + defer cancel() + if err := s.metrics.Stop(shutdownCtx); err != nil { + s.log.Error("error shutting down metrics server", "error", err) + } + } + if s.rpcRouter != nil { + if err := s.rpcRouter.Close(); err != nil { + s.log.Error("error closing rpc router", "error", err) + } + } + if s.metricsRouter != nil { + if err := s.metricsRouter.Close(); err != nil { + s.log.Error("error closing metrics router", "error", err) + } + } + + for chainID, chain := range s.chains { + if err := chain.Stop(ctx); err != nil { + s.log.Error("error stopping chain container", "chain_id", chainID.String(), "error", err) + } + } + + s.wg.Wait() + + if s.l1Client != nil { + s.l1Client.Close() + } + + return nil +} + +func (s *Supernode) Stopped() bool { return s.stopped } + +// RPCAddr returns the bound RPC address (host:port) if the server is listening. +// ok is false if the listener has not been created yet. +func (s *Supernode) RPCAddr() (addr string, ok bool) { + if s.httpServer == nil || s.httpServer.Addr() == nil { + return "", false + } + return s.httpServer.Addr().String(), true +} + +// WaitRPCAddr blocks until the RPC server has a bound address or the context is done. +func (s *Supernode) WaitRPCAddr(ctx context.Context) (string, error) { + // Fast-path + if addr, ok := s.RPCAddr(); ok { + return addr, nil + } + // Poll until listener is set or context done + ticker := time.NewTicker(100 * time.Millisecond) + defer ticker.Stop() + for { + select { + case <-ctx.Done(): + return "", ctx.Err() + case <-ticker.C: + if addr, ok := s.RPCAddr(); ok { + return addr, nil + } + } + } +} + +// L1Client returns the L1 client instance +func (s *Supernode) L1Client() *sources.L1Client { + return s.l1Client +} + +// BeaconClient returns the L1 Beacon client instance (may be nil if not configured) +func (s *Supernode) BeaconClient() *sources.L1BeaconClient { + return s.beaconClient +} + +func (s *Supernode) initL1Client(ctx context.Context, cfg *config.CLIConfig) error { + s.log.Info("initializing shared L1 client", "l1_addr", cfg.L1NodeAddr) + + // Create L1 RPC client with basic configuration + l1RPC, err := client.NewRPC(ctx, s.log, cfg.L1NodeAddr, client.WithDialAttempts(10)) + if err != nil { + return fmt.Errorf("failed to dial L1 address (%s): %w", cfg.L1NodeAddr, err) + } + + nonCloseableRPC := resources.NewNonCloseableRPC(l1RPC) + + l1ClientCfg := sources.L1ClientSimpleConfig(false, sources.RPCKindStandard, 100) + s.l1Client, err = sources.NewL1Client(nonCloseableRPC, s.log, nil, l1ClientCfg) + if err != nil { + return fmt.Errorf("failed to create L1 client: %w", err) + } + + s.log.Info("L1 client initialized successfully") + return nil +} + +func (s *Supernode) initBeaconClient(ctx context.Context, cfg *config.CLIConfig) error { + if cfg.L1BeaconAddr == "" { + s.log.Info("L1 Beacon address not configured, skipping beacon client initialization") + return nil + } + + s.log.Info("initializing L1 Beacon client", "beacon_addr", cfg.L1BeaconAddr) + + // Create beacon client + basicClient := client.NewBasicHTTPClient(cfg.L1BeaconAddr, s.log) + beaconHTTPClient := sources.NewBeaconHTTPClient(basicClient) + + // Create L1 Beacon client with default config + beaconCfg := sources.L1BeaconClientConfig{ + FetchAllSidecars: false, + } + s.beaconClient = sources.NewL1BeaconClient(beaconHTTPClient, beaconCfg) + + s.log.Info("L1 Beacon client initialized successfully") + return nil +} diff --git a/op-supervisor/supervisor/backend/depset/depset.go b/op-supervisor/supervisor/backend/depset/depset.go index 1b823ede0b3..447185e48da 100644 --- a/op-supervisor/supervisor/backend/depset/depset.go +++ b/op-supervisor/supervisor/backend/depset/depset.go @@ -1,7 +1,6 @@ package depset import ( - "context" "fmt" "github.com/ethereum-optimism/optimism/op-service/eth" @@ -10,7 +9,7 @@ import ( ) type DependencySetSource interface { - LoadDependencySet(ctx context.Context) (DependencySet, error) + LoadDependencySet() (DependencySet, error) } // DependencySet is an initialized dependency set, ready to answer queries diff --git a/op-supervisor/supervisor/backend/depset/depset_test.go b/op-supervisor/supervisor/backend/depset/depset_test.go index 0bee31be155..d09f2d6229e 100644 --- a/op-supervisor/supervisor/backend/depset/depset_test.go +++ b/op-supervisor/supervisor/backend/depset/depset_test.go @@ -2,7 +2,6 @@ package depset import ( "bytes" - "context" "encoding/json" "os" "path" @@ -73,7 +72,7 @@ func testDependencySetSerialization( var result DependencySet if fileExt == "json" { loader := &JSONDependencySetLoader{Path: d} - result, err = loader.LoadDependencySet(context.Background()) + result, err = loader.LoadDependencySet() require.NoError(t, err) } else { fileData, err := os.ReadFile(d) @@ -104,7 +103,7 @@ func testDependencySetSerialization( var result DependencySet if fileExt == "json" { loader := &JSONDependencySetLoader{Path: d} - result, err = loader.LoadDependencySet(context.Background()) + result, err = loader.LoadDependencySet() require.NoError(t, err) } else { fileData, err := os.ReadFile(d) diff --git a/op-supervisor/supervisor/backend/depset/full_config_set.go b/op-supervisor/supervisor/backend/depset/full_config_set.go index dfd2b87cc6c..77f09d55dbd 100644 --- a/op-supervisor/supervisor/backend/depset/full_config_set.go +++ b/op-supervisor/supervisor/backend/depset/full_config_set.go @@ -87,7 +87,7 @@ func (l *FullConfigSetSourceMerged) LoadFullConfigSet(ctx context.Context) (Full if err != nil { return nil, fmt.Errorf("failed to load rollup config set: %w", err) } - dependencySet, err := l.DependencySetSource.LoadDependencySet(ctx) + dependencySet, err := l.DependencySetSource.LoadDependencySet() if err != nil { return nil, fmt.Errorf("failed to load dependency set: %w", err) } diff --git a/op-supervisor/supervisor/backend/depset/json.go b/op-supervisor/supervisor/backend/depset/json.go index a1af71f42ab..b4d66494e8a 100644 --- a/op-supervisor/supervisor/backend/depset/json.go +++ b/op-supervisor/supervisor/backend/depset/json.go @@ -26,7 +26,7 @@ type JSONDependencySetLoader struct { Path string } -func (j *JSONDependencySetLoader) LoadDependencySet(ctx context.Context) (DependencySet, error) { +func (j *JSONDependencySetLoader) LoadDependencySet() (DependencySet, error) { f, err := os.Open(j.Path) if err != nil { return nil, fmt.Errorf("failed to open dependency set: %w", err) diff --git a/op-supervisor/supervisor/backend/depset/static_depset.go b/op-supervisor/supervisor/backend/depset/static_depset.go index 50ea16f9993..0e396711c5e 100644 --- a/op-supervisor/supervisor/backend/depset/static_depset.go +++ b/op-supervisor/supervisor/backend/depset/static_depset.go @@ -2,7 +2,6 @@ package depset import ( "bytes" - "context" "encoding/json" "fmt" "slices" @@ -148,7 +147,7 @@ var _ DependencySetSource = (*StaticConfigDependencySet)(nil) var _ DependencySet = (*StaticConfigDependencySet)(nil) -func (ds *StaticConfigDependencySet) LoadDependencySet(ctx context.Context) (DependencySet, error) { +func (ds *StaticConfigDependencySet) LoadDependencySet() (DependencySet, error) { return ds, nil } From 1350f38667aa15118cb8afd7d168f0a4c207d23e Mon Sep 17 00:00:00 2001 From: Michael Amadi Date: Wed, 15 Oct 2025 18:19:54 +0100 Subject: [PATCH 061/117] remove unused superchainProxyAdmin immutable variable from OPCM (#17828) * remove unused protocolVersions and superchainProxyAdmin immutable variables * keep protocolVersions * fixes --- .../interfaces/L1/IOPContractsManager.sol | 6 +----- .../scripts/deploy/ChainAssertions.sol | 5 +---- .../scripts/deploy/Deploy.s.sol | 3 +-- .../scripts/deploy/DeployImplementations.s.sol | 6 ++---- .../deploy/ReadSuperchainDeployment.s.sol | 3 ++- .../scripts/deploy/VerifyOPCM.s.sol | 1 - .../snapshots/abi/OPContractsManager.json | 18 ------------------ .../snapshots/semver-lock.json | 4 ++-- .../src/L1/OPContractsManager.sol | 11 +++-------- .../test/L1/OPContractsManager.t.sol | 11 +++-------- .../test/scripts/VerifyOPCM.t.sol | 3 --- 11 files changed, 15 insertions(+), 56 deletions(-) diff --git a/packages/contracts-bedrock/interfaces/L1/IOPContractsManager.sol b/packages/contracts-bedrock/interfaces/L1/IOPContractsManager.sol index 118829029ea..7b0c94669fb 100644 --- a/packages/contracts-bedrock/interfaces/L1/IOPContractsManager.sol +++ b/packages/contracts-bedrock/interfaces/L1/IOPContractsManager.sol @@ -265,9 +265,6 @@ interface IOPContractsManager { /// @notice Address of the ProtocolVersions contract shared by all chains. function protocolVersions() external view returns (IProtocolVersions); - /// @notice Address of the ProxyAdmin contract shared by all chains. - function superchainProxyAdmin() external view returns (IProxyAdmin); - // -------- Errors -------- /// @notice Thrown when an address is the zero address. @@ -317,8 +314,7 @@ interface IOPContractsManager { IOPContractsManagerInteropMigrator _opcmInteropMigrator, IOPContractsManagerStandardValidator _opcmStandardValidator, ISuperchainConfig _superchainConfig, - IProtocolVersions _protocolVersions, - IProxyAdmin _superchainProxyAdmin + IProtocolVersions _protocolVersions ) external; diff --git a/packages/contracts-bedrock/scripts/deploy/ChainAssertions.sol b/packages/contracts-bedrock/scripts/deploy/ChainAssertions.sol index 0f14886ecdc..0b001229186 100644 --- a/packages/contracts-bedrock/scripts/deploy/ChainAssertions.sol +++ b/packages/contracts-bedrock/scripts/deploy/ChainAssertions.sol @@ -32,7 +32,6 @@ import { IDelayedWETH } from "interfaces/dispute/IDelayedWETH.sol"; import { IOptimismMintableERC20Factory } from "interfaces/universal/IOptimismMintableERC20Factory.sol"; import { IPreimageOracle } from "interfaces/cannon/IPreimageOracle.sol"; import { IMIPS64 } from "interfaces/cannon/IMIPS64.sol"; -import { IProxyAdmin } from "interfaces/universal/IProxyAdmin.sol"; import { IETHLockbox } from "interfaces/L1/IETHLockbox.sol"; import { IProxyAdminOwnedBase } from "interfaces/L1/IProxyAdminOwnedBase.sol"; import { IAnchorStateRegistry } from "interfaces/dispute/IAnchorStateRegistry.sol"; @@ -377,8 +376,7 @@ library ChainAssertions { Types.ContractSet memory _impls, Types.ContractSet memory _proxies, IOPContractsManager _opcm, - IMIPS64 _mips, - IProxyAdmin _superchainProxyAdmin + IMIPS64 _mips ) internal view @@ -388,7 +386,6 @@ library ChainAssertions { require(bytes(_opcm.version()).length > 0, "CHECK-OPCM-15"); require(address(_opcm.protocolVersions()) == _proxies.ProtocolVersions, "CHECK-OPCM-17"); - require(address(_opcm.superchainProxyAdmin()) == address(_superchainProxyAdmin), "CHECK-OPCM-18"); require(address(_opcm.superchainConfig()) == _proxies.SuperchainConfig, "CHECK-OPCM-19"); // Ensure that the OPCM impls are correctly saved diff --git a/packages/contracts-bedrock/scripts/deploy/Deploy.s.sol b/packages/contracts-bedrock/scripts/deploy/Deploy.s.sol index fcf70f61cbb..fd91f93a2ea 100644 --- a/packages/contracts-bedrock/scripts/deploy/Deploy.s.sol +++ b/packages/contracts-bedrock/scripts/deploy/Deploy.s.sol @@ -323,8 +323,7 @@ contract Deploy is Deployer { _impls: impls, _proxies: _proxies(), _opcm: IOPContractsManager(address(dio.opcm)), - _mips: IMIPS64(address(dio.mipsSingleton)), - _superchainProxyAdmin: superchainProxyAdmin + _mips: IMIPS64(address(dio.mipsSingleton)) }); ChainAssertions.checkSystemConfigImpls(impls); ChainAssertions.checkAnchorStateRegistryProxy(IAnchorStateRegistry(impls.AnchorStateRegistry), false); diff --git a/packages/contracts-bedrock/scripts/deploy/DeployImplementations.s.sol b/packages/contracts-bedrock/scripts/deploy/DeployImplementations.s.sol index 2503d23602e..bc76955c48f 100644 --- a/packages/contracts-bedrock/scripts/deploy/DeployImplementations.s.sol +++ b/packages/contracts-bedrock/scripts/deploy/DeployImplementations.s.sol @@ -206,8 +206,7 @@ contract DeployImplementations is Script { _output.opcmInteropMigrator, _output.opcmStandardValidator, _input.superchainConfigProxy, - _input.protocolVersionsProxy, - _input.superchainProxyAdmin + _input.protocolVersionsProxy ) ) ); @@ -769,8 +768,7 @@ contract DeployImplementations is Script { _impls: impls, _proxies: proxies, _opcm: IOPContractsManager(address(_output.opcm)), - _mips: IMIPS64(address(_output.mipsSingleton)), - _superchainProxyAdmin: _input.superchainProxyAdmin + _mips: IMIPS64(address(_output.mipsSingleton)) }); ChainAssertions.checkOptimismMintableERC20FactoryImpl(_output.optimismMintableERC20FactoryImpl); diff --git a/packages/contracts-bedrock/scripts/deploy/ReadSuperchainDeployment.s.sol b/packages/contracts-bedrock/scripts/deploy/ReadSuperchainDeployment.s.sol index ee678b9d9ea..6c7b60a714f 100644 --- a/packages/contracts-bedrock/scripts/deploy/ReadSuperchainDeployment.s.sol +++ b/packages/contracts-bedrock/scripts/deploy/ReadSuperchainDeployment.s.sol @@ -8,6 +8,7 @@ import { IProtocolVersions, ProtocolVersion } from "interfaces/L1/IProtocolVersi import { IProxyAdmin } from "interfaces/universal/IProxyAdmin.sol"; import { IProxy } from "interfaces/universal/IProxy.sol"; import { IOPContractsManager } from "interfaces/L1/IOPContractsManager.sol"; +import { EIP1967Helper } from "test/mocks/EIP1967Helper.sol"; contract ReadSuperchainDeployment is Script { struct Input { @@ -34,7 +35,7 @@ contract ReadSuperchainDeployment is Script { output_.protocolVersionsProxy = IProtocolVersions(opcm.protocolVersions()); output_.superchainConfigProxy = ISuperchainConfig(opcm.superchainConfig()); - output_.superchainProxyAdmin = IProxyAdmin(opcm.superchainProxyAdmin()); + output_.superchainProxyAdmin = IProxyAdmin(EIP1967Helper.getAdmin(address(output_.superchainConfigProxy))); IProxy protocolVersionsProxy = IProxy(payable(address(output_.protocolVersionsProxy))); IProxy superchainConfigProxy = IProxy(payable(address(output_.superchainConfigProxy))); diff --git a/packages/contracts-bedrock/scripts/deploy/VerifyOPCM.s.sol b/packages/contracts-bedrock/scripts/deploy/VerifyOPCM.s.sol index b8dc9a685b4..3da017d5b70 100644 --- a/packages/contracts-bedrock/scripts/deploy/VerifyOPCM.s.sol +++ b/packages/contracts-bedrock/scripts/deploy/VerifyOPCM.s.sol @@ -149,7 +149,6 @@ contract VerifyOPCM is Script { // Getters verified via environment variables in _verifyOpcmImmutableVariables() expectedGetters["protocolVersions"] = "EXPECTED_PROTOCOL_VERSIONS"; expectedGetters["superchainConfig"] = "EXPECTED_SUPERCHAIN_CONFIG"; - expectedGetters["superchainProxyAdmin"] = "EXPECTED_SUPERCHAIN_PROXY_ADMIN"; // Getters for OPCM sub-contracts (addresses verified via bytecode comparison) expectedGetters["opcmDeployer"] = "SKIP"; // Address verified via bytecode comparison diff --git a/packages/contracts-bedrock/snapshots/abi/OPContractsManager.json b/packages/contracts-bedrock/snapshots/abi/OPContractsManager.json index 5372533426d..f90d2adb170 100644 --- a/packages/contracts-bedrock/snapshots/abi/OPContractsManager.json +++ b/packages/contracts-bedrock/snapshots/abi/OPContractsManager.json @@ -35,11 +35,6 @@ "internalType": "contract IProtocolVersions", "name": "_protocolVersions", "type": "address" - }, - { - "internalType": "contract IProxyAdmin", - "name": "_superchainProxyAdmin", - "type": "address" } ], "stateMutability": "nonpayable", @@ -756,19 +751,6 @@ "stateMutability": "view", "type": "function" }, - { - "inputs": [], - "name": "superchainProxyAdmin", - "outputs": [ - { - "internalType": "contract IProxyAdmin", - "name": "", - "type": "address" - } - ], - "stateMutability": "view", - "type": "function" - }, { "inputs": [ { diff --git a/packages/contracts-bedrock/snapshots/semver-lock.json b/packages/contracts-bedrock/snapshots/semver-lock.json index 0316ab9250b..caa8ace5ae4 100644 --- a/packages/contracts-bedrock/snapshots/semver-lock.json +++ b/packages/contracts-bedrock/snapshots/semver-lock.json @@ -20,8 +20,8 @@ "sourceCodeHash": "0xfca613b5d055ffc4c3cbccb0773ddb9030abedc1aa6508c9e2e7727cc0cd617b" }, "src/L1/OPContractsManager.sol:OPContractsManager": { - "initCodeHash": "0x42721744f90fa46ee680fecc69da2e5caf7fdd8093c2a7f3b33958e574a15579", - "sourceCodeHash": "0x3eab23f3f034eec77afb620a122e51fded9214b5ed6a4c5663e0174714ae0f5e" + "initCodeHash": "0x4025118658a1c56c4fc2d0166081e6d27da980318e749e7811c7178115e4413e", + "sourceCodeHash": "0xdb243ac7475b0214b8f662aa04f696d9ff213dade6b1bdade379e84df419b75a" }, "src/L1/OPContractsManagerStandardValidator.sol:OPContractsManagerStandardValidator": { "initCodeHash": "0x57d6a6729d887ead009d518e8f17fa0d26bfc97b8efe1494ab4ef8dbb000d109", diff --git a/packages/contracts-bedrock/src/L1/OPContractsManager.sol b/packages/contracts-bedrock/src/L1/OPContractsManager.sol index f72daa376a2..d87b903c86e 100644 --- a/packages/contracts-bedrock/src/L1/OPContractsManager.sol +++ b/packages/contracts-bedrock/src/L1/OPContractsManager.sol @@ -1898,9 +1898,9 @@ contract OPContractsManager is ISemver { // -------- Constants and Variables -------- - /// @custom:semver 4.1.0 + /// @custom:semver 4.2.0 function version() public pure virtual returns (string memory) { - return "4.1.0"; + return "4.2.0"; } OPContractsManagerGameTypeAdder public immutable opcmGameTypeAdder; @@ -1919,9 +1919,6 @@ contract OPContractsManager is ISemver { /// @notice Address of the ProtocolVersions contract shared by all chains. IProtocolVersions public immutable protocolVersions; - /// @notice Address of the SuperchainProxyAdmin contract shared by all chains. - IProxyAdmin public immutable superchainProxyAdmin; - /// @notice The OPContractsManager contract that is currently being used. This is needed in the upgrade function /// which is intended to be DELEGATECALLed. OPContractsManager internal immutable thisOPCM; @@ -1979,8 +1976,7 @@ contract OPContractsManager is ISemver { OPContractsManagerInteropMigrator _opcmInteropMigrator, OPContractsManagerStandardValidator _opcmStandardValidator, ISuperchainConfig _superchainConfig, - IProtocolVersions _protocolVersions, - IProxyAdmin _superchainProxyAdmin + IProtocolVersions _protocolVersions ) { _opcmDeployer.assertValidContractAddress(address(_superchainConfig)); _opcmDeployer.assertValidContractAddress(address(_protocolVersions)); @@ -1996,7 +1992,6 @@ contract OPContractsManager is ISemver { opcmStandardValidator = _opcmStandardValidator; superchainConfig = _superchainConfig; protocolVersions = _protocolVersions; - superchainProxyAdmin = _superchainProxyAdmin; thisOPCM = this; } diff --git a/packages/contracts-bedrock/test/L1/OPContractsManager.t.sol b/packages/contracts-bedrock/test/L1/OPContractsManager.t.sol index 66c421b1e8c..bd0951c487e 100644 --- a/packages/contracts-bedrock/test/L1/OPContractsManager.t.sol +++ b/packages/contracts-bedrock/test/L1/OPContractsManager.t.sol @@ -68,8 +68,7 @@ contract OPContractsManager_Harness is OPContractsManager { OPContractsManagerInteropMigrator _opcmInteropMigrator, OPContractsManagerStandardValidator _opcmStandardValidator, ISuperchainConfig _superchainConfig, - IProtocolVersions _protocolVersions, - IProxyAdmin _superchainProxyAdmin + IProtocolVersions _protocolVersions ) OPContractsManager( _opcmGameTypeAdder, @@ -78,8 +77,7 @@ contract OPContractsManager_Harness is OPContractsManager { _opcmInteropMigrator, _opcmStandardValidator, _superchainConfig, - _protocolVersions, - _superchainProxyAdmin + _protocolVersions ) { } @@ -340,7 +338,6 @@ contract OPContractsManager_TestInit is CommonTest { function setupEnvVars() public { vm.setEnv("EXPECTED_SUPERCHAIN_CONFIG", vm.toString(address(opcm.superchainConfig()))); vm.setEnv("EXPECTED_PROTOCOL_VERSIONS", vm.toString(address(opcm.protocolVersions()))); - vm.setEnv("EXPECTED_SUPERCHAIN_PROXY_ADMIN", vm.toString(address(opcm.superchainProxyAdmin()))); } /// @notice Helper function to deploy a new set of L1 contracts via OPCM. @@ -460,8 +457,7 @@ contract OPContractsManager_ChainIdToBatchInboxAddress_Test is Test, FeatureFlag opcmImplementations, superchainConfigProxy, address(superchainProxyAdmin), challenger, 100, bytes32(0) ), _superchainConfig: superchainConfigProxy, - _protocolVersions: protocolVersionsProxy, - _superchainProxyAdmin: superchainProxyAdmin + _protocolVersions: protocolVersionsProxy }); } @@ -1258,7 +1254,6 @@ contract OPContractsManager_Upgrade_Test is OPContractsManager_Upgrade_Harness { // Set up environment variables with the actual OPCM addresses for tests that need themqq vm.setEnv("EXPECTED_SUPERCHAIN_CONFIG", vm.toString(address(opcm.superchainConfig()))); vm.setEnv("EXPECTED_PROTOCOL_VERSIONS", vm.toString(address(opcm.protocolVersions()))); - vm.setEnv("EXPECTED_SUPERCHAIN_PROXY_ADMIN", vm.toString(address(opcm.superchainProxyAdmin()))); // Run the upgrade test and checks runCurrentUpgrade(upgrader); diff --git a/packages/contracts-bedrock/test/scripts/VerifyOPCM.t.sol b/packages/contracts-bedrock/test/scripts/VerifyOPCM.t.sol index 4090ab61fdd..7d1a05864cc 100644 --- a/packages/contracts-bedrock/test/scripts/VerifyOPCM.t.sol +++ b/packages/contracts-bedrock/test/scripts/VerifyOPCM.t.sol @@ -462,16 +462,13 @@ contract VerifyOPCM_Run_Test is VerifyOPCM_TestInit { // Set expected addresses via environment variables address expectedSuperchainConfig = address(0x1111); address expectedProtocolVersions = address(0x2222); - address expectedSuperchainProxyAdmin = address(0x3333); vm.setEnv("EXPECTED_SUPERCHAIN_CONFIG", vm.toString(expectedSuperchainConfig)); vm.setEnv("EXPECTED_PROTOCOL_VERSIONS", vm.toString(expectedProtocolVersions)); - vm.setEnv("EXPECTED_SUPERCHAIN_PROXY_ADMIN", vm.toString(expectedSuperchainProxyAdmin)); // Test that mocking each individual getter causes verification to fail _assertOnOpcmGetter(IOPContractsManager.superchainConfig.selector); _assertOnOpcmGetter(IOPContractsManager.protocolVersions.selector); - _assertOnOpcmGetter(IOPContractsManager.superchainProxyAdmin.selector); // Reset environment variables to correct values (as set in setUp()) setupEnvVars(); From 66e1ddc1b79688c713676553516e9a59dc845cc0 Mon Sep 17 00:00:00 2001 From: "devin-ai-integration[bot]" <158243242+devin-ai-integration[bot]@users.noreply.github.com> Date: Wed, 15 Oct 2025 18:31:36 +0100 Subject: [PATCH 062/117] refactor(test): improve ResourceMetering test coverage and quality (#17812) * refactor(test): improve ResourceMetering test coverage and quality - convert 3 duplicate empty block tests to single fuzz test - add test for block.basefee = 0 protection - add test for below-target gas usage (fee decrease) - add test for minimum base fee configuration - reorganize test contracts to match source declaration order * test: add explicit assertion for base fee protection in zero basefee test - Add assertGt(prevBaseFee, 0) to verify Math.max protection works - Addresses automated PR review feedback --------- Co-authored-by: Devin AI <158243242+devin-ai-integration[bot]@users.noreply.github.com> --- .../test/L1/ResourceMetering.t.sol | 191 ++++++++++-------- 1 file changed, 109 insertions(+), 82 deletions(-) diff --git a/packages/contracts-bedrock/test/L1/ResourceMetering.t.sol b/packages/contracts-bedrock/test/L1/ResourceMetering.t.sol index 7ed242423ab..e2c3c085a9f 100644 --- a/packages/contracts-bedrock/test/L1/ResourceMetering.t.sol +++ b/packages/contracts-bedrock/test/L1/ResourceMetering.t.sol @@ -56,6 +56,40 @@ contract MeterUser is ResourceMetering { } } +/// @title CustomMeterUser +/// @notice A simple wrapper around `ResourceMetering` that allows the initial params to be set in +/// the constructor. +contract CustomMeterUser is ResourceMetering { + uint256 public startGas; + uint256 public endGas; + + constructor(uint128 _prevBaseFee, uint64 _prevBoughtGas, uint64 _prevBlockNum) { + params = ResourceMetering.ResourceParams({ + prevBaseFee: _prevBaseFee, + prevBoughtGas: _prevBoughtGas, + prevBlockNum: _prevBlockNum + }); + } + + function _resourceConfig() internal pure override returns (ResourceMetering.ResourceConfig memory) { + IResourceMetering.ResourceConfig memory rcfg = Constants.DEFAULT_RESOURCE_CONFIG(); + return ResourceMetering.ResourceConfig({ + maxResourceLimit: rcfg.maxResourceLimit, + elasticityMultiplier: rcfg.elasticityMultiplier, + baseFeeMaxChangeDenominator: rcfg.baseFeeMaxChangeDenominator, + minimumBaseFee: rcfg.minimumBaseFee, + systemTxMaxGas: rcfg.systemTxMaxGas, + maximumBaseFee: rcfg.maximumBaseFee + }); + } + + function use(uint64 _amount) public returns (uint256) { + uint256 initialGas = gasleft(); + _metered(_amount, initialGas); + return initialGas - gasleft(); + } +} + /// @title ResourceMetering_TestInit /// @notice Reusable test initialization for `ResourceMetering` tests. contract ResourceMetering_TestInit is Test { @@ -69,34 +103,6 @@ contract ResourceMetering_TestInit is Test { } } -/// @title ResourceMetering_ResourceMeteringInit_Test -/// @notice Tests the `__ResourceMeteringInit` contract's initialization. -contract ResourceMetering_ResourceMeteringInit_Test is ResourceMetering_TestInit { - /// @notice Tests that the initial resource params are set correctly. - function test_resourceMeteringInit_initialResourceParams_succeeds() external view { - (uint128 prevBaseFee, uint64 prevBoughtGas, uint64 prevBlockNum) = meter.params(); - ResourceMetering.ResourceConfig memory rcfg = meter.resourceConfig(); - - assertEq(prevBaseFee, rcfg.minimumBaseFee); - assertEq(prevBoughtGas, 0); - assertEq(prevBlockNum, initialBlockNum); - } - - /// @notice Tests that reinitializing the resource params are set correctly. - function test_resourceMeteringInit_reinitializedResourceParams_succeeds() external { - (uint128 prevBaseFee, uint64 prevBoughtGas, uint64 prevBlockNum) = meter.params(); - - // Reset the initialized slot to enable reinitialization. - vm.store(address(meter), bytes32(uint256(0)), bytes32(uint256(0))); - meter.initialize(); - - (uint128 postBaseFee, uint64 postBoughtGas, uint64 postBlockNum) = meter.params(); - assertEq(prevBaseFee, postBaseFee); - assertEq(prevBoughtGas, postBoughtGas); - assertEq(prevBlockNum, postBlockNum); - } -} - /// @title ResourceMetering_Metered_Test /// @notice Tests the `metered` modifier on the `ResourceMetering` contract. /// @dev Tests are based on the default config values. It is expected that these config values are @@ -114,37 +120,16 @@ contract ResourceMetering_Metered_Test is ResourceMetering_TestInit { assertEq(postBlockNum, prevBlockNum); } - /// @notice Tests that updating the initial block number sets the meter params correctly. - function test_metered_updateOneEmptyBlock_succeeds() external { - vm.roll(initialBlockNum + 1); - meter.use(0); - (uint128 prevBaseFee, uint64 prevBoughtGas, uint64 prevBlockNum) = meter.params(); - - assertEq(prevBaseFee, 1 gwei); - assertEq(prevBoughtGas, 0); - assertEq(prevBlockNum, initialBlockNum + 1); - } - - /// @notice Tests that updating the initial block number sets the meter params correctly. - function test_metered_updateTwoEmptyBlocks_succeeds() external { - vm.roll(initialBlockNum + 2); - meter.use(0); - (uint128 prevBaseFee, uint64 prevBoughtGas, uint64 prevBlockNum) = meter.params(); - - assertEq(prevBaseFee, 1 gwei); - assertEq(prevBoughtGas, 0); - assertEq(prevBlockNum, initialBlockNum + 2); - } - - /// @notice Tests that updating the initial block number sets the meter params correctly. - function test_metered_updateTenEmptyBlocks_succeeds() external { - vm.roll(initialBlockNum + 10); + /// @notice Tests that updating after multiple empty blocks maintains correct base fee. + function testFuzz_metered_emptyBlocks_succeeds(uint256 _blockDiff) external { + _blockDiff = bound(_blockDiff, 1, 100); + vm.roll(initialBlockNum + _blockDiff); meter.use(0); (uint128 prevBaseFee, uint64 prevBoughtGas, uint64 prevBlockNum) = meter.params(); assertEq(prevBaseFee, 1 gwei); assertEq(prevBoughtGas, 0); - assertEq(prevBlockNum, initialBlockNum + 10); + assertEq(prevBlockNum, initialBlockNum + _blockDiff); } /// @notice Tests that updating the gas delta sets the meter params correctly. @@ -232,43 +217,85 @@ contract ResourceMetering_Metered_Test is ResourceMetering_TestInit { (, uint64 postPrevBoughtGas,) = meter.params(); assertEq(postPrevBoughtGas, prevBoughtGas + _amount); } -} -/// @title CustomMeterUser -/// @notice A simple wrapper around `ResourceMetering` that allows the initial params to be set in -/// the constructor. -contract CustomMeterUser is ResourceMetering { - uint256 public startGas; - uint256 public endGas; + /// @notice Tests that metering works correctly when block.basefee is 0. + function test_metered_zeroBlockBaseFee_succeeds() external { + ResourceMetering.ResourceConfig memory rcfg = meter.resourceConfig(); + uint64 target = uint64(rcfg.maxResourceLimit) / uint64(rcfg.elasticityMultiplier); - constructor(uint128 _prevBaseFee, uint64 _prevBoughtGas, uint64 _prevBlockNum) { - params = ResourceMetering.ResourceParams({ - prevBaseFee: _prevBaseFee, - prevBoughtGas: _prevBoughtGas, - prevBlockNum: _prevBlockNum - }); + vm.fee(0); + + meter.use(target / 2); + + (uint128 prevBaseFee, uint64 prevBoughtGas,) = meter.params(); + assertEq(prevBoughtGas, target / 2); + assertGt(prevBaseFee, 0); } - function _resourceConfig() internal pure override returns (ResourceMetering.ResourceConfig memory) { - IResourceMetering.ResourceConfig memory rcfg = Constants.DEFAULT_RESOURCE_CONFIG(); - return ResourceMetering.ResourceConfig({ - maxResourceLimit: rcfg.maxResourceLimit, - elasticityMultiplier: rcfg.elasticityMultiplier, - baseFeeMaxChangeDenominator: rcfg.baseFeeMaxChangeDenominator, - minimumBaseFee: rcfg.minimumBaseFee, - systemTxMaxGas: rcfg.systemTxMaxGas, - maximumBaseFee: rcfg.maximumBaseFee - }); + /// @notice Tests that base fee decreases when gas usage is below target. + function test_metered_belowTargetUsage_succeeds() external { + ResourceMetering.ResourceConfig memory rcfg = meter.resourceConfig(); + uint64 target = uint64(rcfg.maxResourceLimit) / uint64(rcfg.elasticityMultiplier); + + meter.use(target * 2); + vm.roll(block.number + 1); + meter.use(target * 2); + vm.roll(block.number + 1); + meter.use(0); + + (uint128 baselineBaseFee,,) = meter.params(); + + vm.roll(block.number + 1); + meter.use(target / 2); + vm.roll(block.number + 1); + meter.use(0); + + (uint128 newBaseFee,,) = meter.params(); + + assertLt(newBaseFee, baselineBaseFee); } - function use(uint64 _amount) public returns (uint256) { - uint256 initialGas = gasleft(); - _metered(_amount, initialGas); - return initialGas - gasleft(); + /// @notice Tests metering with minimum base fee configuration. + function test_metered_minimumBaseFee_succeeds() external { + ResourceMetering.ResourceConfig memory rcfg = meter.resourceConfig(); + + meter.set(uint128(rcfg.minimumBaseFee), 0, uint64(block.number)); + + meter.use(100); + + (, uint64 prevBoughtGas,) = meter.params(); + assertEq(prevBoughtGas, 100); + } +} + +/// @title ResourceMetering_ResourceMeteringInit_Test +/// @notice Tests the `__ResourceMeteringInit` contract's initialization. +contract ResourceMetering_ResourceMeteringInit_Test is ResourceMetering_TestInit { + /// @notice Tests that the initial resource params are set correctly. + function test_resourceMeteringInit_initialResourceParams_succeeds() external view { + (uint128 prevBaseFee, uint64 prevBoughtGas, uint64 prevBlockNum) = meter.params(); + ResourceMetering.ResourceConfig memory rcfg = meter.resourceConfig(); + + assertEq(prevBaseFee, rcfg.minimumBaseFee); + assertEq(prevBoughtGas, 0); + assertEq(prevBlockNum, initialBlockNum); + } + + /// @notice Tests that reinitializing the resource params are set correctly. + function test_resourceMeteringInit_reinitializedResourceParams_succeeds() external { + (uint128 prevBaseFee, uint64 prevBoughtGas, uint64 prevBlockNum) = meter.params(); + + vm.store(address(meter), bytes32(uint256(0)), bytes32(uint256(0))); + meter.initialize(); + + (uint128 postBaseFee, uint64 postBoughtGas, uint64 postBlockNum) = meter.params(); + assertEq(prevBaseFee, postBaseFee); + assertEq(prevBoughtGas, postBoughtGas); + assertEq(prevBlockNum, postBlockNum); } } -/// @title ArtifactResourceMetering_Test +/// @title ArtifactResourceMetering_Metered_Test /// @notice A table test that sets the state of the ResourceParams and then requests various /// amounts of gas. This test ensures that a wide range of values can safely be used with /// the `ResourceMetering` contract. It also writes a CSV file to disk that includes useful From a34c18b5668ce42111ef567a08b8f7e278378124 Mon Sep 17 00:00:00 2001 From: Ariel Diaz <65925295+aliersh@users.noreply.github.com> Date: Wed, 15 Oct 2025 13:57:02 -0400 Subject: [PATCH 063/117] feat(ai-contracts-test): add Slack notifications and bug fixes (v1.1.0) (#17876) MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit * feat(ai-contracts-test): add Slack notification for PR creation * fix(ai-contracts-test): add pagination to fetch enough pipelines - paginate through CircleCI API to fetch up to 200 pipelines - add debug logging to troubleshoot artifact exclusion - temporarily exclude ReinitializableBase * fix(ai-contracts-test): exit with error when devin session blocked without PR * fix(ai-contracts-test): use Slack orb pattern for PR notifications * fix(ai-contracts-test): fix user tag formar in slack message * docs(ai-contracts-test): enhance prompt with constructor and assertion guidelines - Add zero tolerance rule for constructor parameter test organization - Add TargetContract_Constructor_Test naming pattern for constructor tests - Require explicit assertions beyond non-reversion checks - Add examples for proper assertion usage and constructor test structure - Fix typo in avoid section ("contex" → "context") * docs(ai-contracts-test): update documentation for v1.1.0 release * Update ops/ai-eng/contracts-test-maintenance/prompt/prompt.md Co-authored-by: graphite-app[bot] <96075541+graphite-app[bot]@users.noreply.github.com> * Update ops/ai-eng/contracts-test-maintenance/prompt/prompt.md Co-authored-by: smartcontracts <14298799+smartcontracts@users.noreply.github.com> * chore(ai-contracts-test): remove ReinitializableBase test file from exclusion list --------- Co-authored-by: graphite-app[bot] <96075541+graphite-app[bot]@users.noreply.github.com> Co-authored-by: smartcontracts <14298799+smartcontracts@users.noreply.github.com> --- .circleci/config.yml | 23 +++++++++++ .../contracts-test-maintenance/README.md | 4 +- ops/ai-eng/contracts-test-maintenance/VERSION | 2 +- .../components/devin-api/devin_client.py | 6 ++- .../components/tests_ranker/test_ranker.py | 40 +++++++++++++++---- .../docs/runbook.md | 10 +++++ .../prompt/prompt.md | 37 ++++++++++++++++- 7 files changed, 109 insertions(+), 13 deletions(-) diff --git a/.circleci/config.yml b/.circleci/config.yml index f0a506cf85f..a1197113b85 100644 --- a/.circleci/config.yml +++ b/.circleci/config.yml @@ -963,6 +963,28 @@ jobs: - store_artifacts: path: ops/ai-eng/contracts-test-maintenance/log.json destination: log.json + - run: + name: Prepare Slack notification + command: | + set -eo pipefail + LOG_FILE="ops/ai-eng/contracts-test-maintenance/log.json" + + PR_URL=$(jq -r '.pull_request_url // empty' "$LOG_FILE") + TEST_FILE=$(jq -r '.selected_files.test_path | split("/") | .[-1]' "$LOG_FILE") + + if [ -n "$PR_URL" ]; then + MESSAGE=$' AI Contracts Test Maintenance System created a PR for '"${TEST_FILE}"$'\n<'"${PR_URL}"$'|View PR> | ' + SLACK_JSON=$(jq -n --arg msg "$MESSAGE" '{"text": $msg}') + echo "export AI_PR_SLACK_TEMPLATE='${SLACK_JSON}'" >> $BASH_ENV + else + echo "No PR created, skipping notification" + echo "export AI_PR_SLACK_TEMPLATE=''" >> $BASH_ENV + fi + when: always + - slack/notify: + channel: C050F1GUHDG + event: always + template: AI_PR_SLACK_TEMPLATE - notify-failures-on-develop contracts-bedrock-coverage: @@ -3127,5 +3149,6 @@ workflows: - circleci-repo-readonly-authenticated-github-token - circleci-api-token - devin-api + - slack requires: - initialize diff --git a/ops/ai-eng/contracts-test-maintenance/README.md b/ops/ai-eng/contracts-test-maintenance/README.md index c306be96ca3..146fc6c8609 100644 --- a/ops/ai-eng/contracts-test-maintenance/README.md +++ b/ops/ai-eng/contracts-test-maintenance/README.md @@ -87,6 +87,8 @@ files = ["test/vendor/Initializable.t.sol"] ## Monitoring +**Slack Notifications**: Automatic notifications posted to #evm-safety Slack channel when PRs are created + **Latest Run**: ```bash cat log.json | jq . @@ -118,5 +120,5 @@ cat log.json | jq . **Status**: ✅ Active **Schedule**: Monday & Thursday **Maintainer**: EVM Safety Team -**Version**: 1.0.0 +**Version**: 1.1.0 diff --git a/ops/ai-eng/contracts-test-maintenance/VERSION b/ops/ai-eng/contracts-test-maintenance/VERSION index 3eefcb9dd5b..9084fa2f716 100644 --- a/ops/ai-eng/contracts-test-maintenance/VERSION +++ b/ops/ai-eng/contracts-test-maintenance/VERSION @@ -1 +1 @@ -1.0.0 +1.1.0 diff --git a/ops/ai-eng/contracts-test-maintenance/components/devin-api/devin_client.py b/ops/ai-eng/contracts-test-maintenance/components/devin-api/devin_client.py index d35475a8010..adcdbba7e3e 100644 --- a/ops/ai-eng/contracts-test-maintenance/components/devin-api/devin_client.py +++ b/ops/ai-eng/contracts-test-maintenance/components/devin-api/devin_client.py @@ -9,6 +9,7 @@ import json import os from pathlib import Path +import sys import time import urllib.request @@ -203,10 +204,11 @@ def monitor_session(session_id): if pr_data.get("url"): print("Session completed successfully - PR created") write_log(session_id, "finished", status) + return else: print(f"Session blocked without PR - check Devin web interface") - write_log(session_id, "blocked", status) - return + # Don't write log.json so artifact won't be stored for failed sessions + sys.exit(1) # Exit with error code to mark job as failed # Expired = session timed out if current_status == "expired": diff --git a/ops/ai-eng/contracts-test-maintenance/components/tests_ranker/test_ranker.py b/ops/ai-eng/contracts-test-maintenance/components/tests_ranker/test_ranker.py index d4b50f90218..49de537d94c 100644 --- a/ops/ai-eng/contracts-test-maintenance/components/tests_ranker/test_ranker.py +++ b/ops/ai-eng/contracts-test-maintenance/components/tests_ranker/test_ranker.py @@ -230,19 +230,42 @@ def fetch_last_processed_from_circleci() -> list[Path]: branch = "develop" two_weeks_ago = time.time() - (14 * 24 * 3600) - # Get recent pipelines - pipelines_url = f"https://circleci.com/api/v2/project/{project_slug}/pipeline?branch={branch}" - req = urllib.request.Request(pipelines_url, headers=headers) - with urllib.request.urlopen(req, timeout=10) as response: - pipelines = json.loads(response.read().decode()).get("items", []) + # Get recent pipelines with pagination (API returns max 20 by default) + # Keep fetching until we've checked enough pipelines within the 2-week window + all_pipelines = [] + next_page_token = None + + while True: + pipelines_url = f"https://circleci.com/api/v2/project/{project_slug}/pipeline?branch={branch}" + if next_page_token: + pipelines_url += f"&page-token={next_page_token}" + + req = urllib.request.Request(pipelines_url, headers=headers) + with urllib.request.urlopen(req, timeout=10) as response: + data = json.loads(response.read().decode()) + pipelines = data.get("items", []) + next_page_token = data.get("next_page_token") + + if not pipelines: + break - if not pipelines: + all_pipelines.extend(pipelines) + + # Stop paginating if we have no more pages or we've collected enough + if not next_page_token or len(all_pipelines) >= 600: + break + + if not all_pipelines: print("No previous pipelines found") return [] + print(f"Found {len(all_pipelines)} pipelines on {branch}, checking for successful runs...") + # Process recent pipelines (within 2 weeks) from datetime import datetime as dt - for pipeline in pipelines: + pipelines_checked = 0 + for pipeline in all_pipelines: + pipelines_checked += 1 # Check age if pipeline.get("created_at"): pipeline_time = dt.fromisoformat(pipeline["created_at"].replace("Z", "+00:00")).timestamp() @@ -259,6 +282,7 @@ def fetch_last_processed_from_circleci() -> list[Path]: if not job_number: continue + print(f"Found successful job {job_number}, checking for artifacts...") artifacts = _get_job_artifacts(project_slug, job_number, headers) for artifact in artifacts: if artifact["path"].endswith("log.json"): @@ -268,6 +292,8 @@ def fetch_last_processed_from_circleci() -> list[Path]: excluded_paths.append(Path(test_path)) break + print(f"Checked {pipelines_checked} pipelines") + if excluded_paths: print(f"Excluded {len(excluded_paths)} recently processed file(s)") else: diff --git a/ops/ai-eng/contracts-test-maintenance/docs/runbook.md b/ops/ai-eng/contracts-test-maintenance/docs/runbook.md index 6d39f30312b..0b153cf7419 100644 --- a/ops/ai-eng/contracts-test-maintenance/docs/runbook.md +++ b/ops/ai-eng/contracts-test-maintenance/docs/runbook.md @@ -79,6 +79,11 @@ ai-contracts-test: ### Viewing Results +**Slack Notifications**: +- Automatic notification posted to #evm-safety Slack channel when PR is created +- Includes PR URL, test file information, and link to reviewer guide +- Helps expedite review process by alerting reviewers immediately + **In CircleCI**: 1. Navigate to the `ai-contracts-test` job 2. Check "Artifacts" tab for `log.json` @@ -376,6 +381,11 @@ else: ### Checking System Health +**Via Slack**: +- Monitor #evm-safety Slack channel for PR creation notifications +- Each notification includes PR URL and test file information +- Successful runs will always post to Slack when PR is created + **Via CircleCI**: ```bash # View recent runs diff --git a/ops/ai-eng/contracts-test-maintenance/prompt/prompt.md b/ops/ai-eng/contracts-test-maintenance/prompt/prompt.md index a18a13581ae..be9b4ad41e0 100644 --- a/ops/ai-eng/contracts-test-maintenance/prompt/prompt.md +++ b/ops/ai-eng/contracts-test-maintenance/prompt/prompt.md @@ -30,8 +30,9 @@ Don't guess or assume - if unsure, examine the source contract carefully. 1. NO creating NEW tests for inherited functions - only test functions declared in target contract -2. NO failing tests kept - all must pass or task fails -3. NO removing ANY existing tests - even if they test inherited functions (enhance/modify instead) +2. NO creating test contracts for constructor parameters - use Constructor_Test instead +3. NO failing tests kept - all must pass or task fails +4. NO removing ANY existing tests - even if they test inherited functions (enhance/modify instead) @@ -107,6 +108,7 @@ This systematic approach ensures comprehensive test improvements without missing **Test Contract Names:** - `TargetContract_FunctionName_Test` - ONE contract per function (no exceptions) +- `TargetContract_Constructor_Test` - For constructor tests - `TargetContract_Uncategorized_Test` - For multi-function integration tests only (NEVER use "Unclassified") - `TargetContract_TestInit` - Shared setup contract - Constants/ALL CAPS: Convert to PascalCase (e.g., `MAX_LIMIT` → `TargetContract_MaxLimit_Test`) @@ -273,6 +275,7 @@ NEVER fuzz a parameter if you need a specific value - just use that value direct - Tests that are logically equivalent despite using different numbers - Tests that cannot fail or always pass regardless of input - Testing undefined behavior without proper setup or context +- Tests that only verify non-reversion without asserting actual state changes or return values @@ -299,6 +302,7 @@ A test provides value only if: - It has clear success and failure conditions - It validates specific, expected behavior - It could catch real bugs or regressions +- It uses explicit assertions to verify outcomes (non-reversion alone is insufficient) @@ -446,6 +450,35 @@ contract Storage_Uncategorized_Test is Storage_TestInit { // No empty Storage_Uncategorized_Test remains + +Missing explicit assertion for protection mechanism + +function test_zeroProtection_succeeds() { + vm.fee(0); + contract.method(); // ❌ Only checks doesn't revert +} + + +function test_zeroProtection_succeeds() { + vm.fee(0); + contract.method(); + assertEq(contract.getValue(), 1); // ✓ Verifies protection worked +} + + + +Constructor parameter treated as function + +contract Base_InitVersion_Test { // ❌ Constructor param, not a function + function testFuzz_initVersion_succeeds(uint8 _version) { ... } +} + + +contract Base_Constructor_Test { // ✓ All constructor tests together + function testFuzz_constructor_validVersion_succeeds(uint8 _version) { ... } +} + + From c49b1169e49cc4f87a283807a2589672c15a0cbf Mon Sep 17 00:00:00 2001 From: smartcontracts <14298799+smartcontracts@users.noreply.github.com> Date: Wed, 15 Oct 2025 16:18:37 -0400 Subject: [PATCH 064/117] feat: reduce lite profile fuzz runs (#17877) Reduces lite profile fuzz and invariant runs to 8 across the board. We now run heavier fuzz runs in CI, so it's generally nicer and easier if we run significantly reduced runs locally. --- packages/contracts-bedrock/foundry.toml | 7 +++++++ 1 file changed, 7 insertions(+) diff --git a/packages/contracts-bedrock/foundry.toml b/packages/contracts-bedrock/foundry.toml index 12d9cb5f206..3d70386ac74 100644 --- a/packages/contracts-bedrock/foundry.toml +++ b/packages/contracts-bedrock/foundry.toml @@ -134,6 +134,13 @@ timeout = 300 optimizer = false optimizer_runs = 0 +[profile.lite.fuzz] +runs = 8 + +[profile.lite.invariant] +runs = 8 +depth = 8 + # IMPORTANT: # See the info in the "DEFAULT" profile to understand this section. additional_compiler_profiles = [ From 4f3da82763a846739fd4ca6f0ed2c5267d5b4d99 Mon Sep 17 00:00:00 2001 From: theo <80177219+theochap@users.noreply.github.com> Date: Wed, 15 Oct 2025 16:47:48 -0400 Subject: [PATCH 065/117] fix(acceptance-tests/op-reth): fix acceptance tests for op-reth (#17882) --- op-devstack/dsl/l2_el.go | 4 ++-- op-devstack/sysgo/l2_el_opreth.go | 1 + 2 files changed, 3 insertions(+), 2 deletions(-) diff --git a/op-devstack/dsl/l2_el.go b/op-devstack/dsl/l2_el.go index 52c225f1fd7..c55e934df52 100644 --- a/op-devstack/dsl/l2_el.go +++ b/op-devstack/dsl/l2_el.go @@ -187,10 +187,10 @@ func (el *L2ELNode) VerifyWithdrawalHashChangedIn(blockHash common.Hash) { parentBlockInfo, err := l2Client.InfoByHash(el.ctx, postBlockWithdrawalInfo.ParentHash()) el.require.NoError(err, "failed to get parent block info") - postProof, err := l2Client.GetProof(el.ctx, predeploys.L2ToL1MessagePasserAddr, nil, blockHash.String()) + postProof, err := l2Client.GetProof(el.ctx, predeploys.L2ToL1MessagePasserAddr, []common.Hash{}, blockHash.String()) el.require.NoError(err, "failed to get post-withdrawal storage proof") - parentProof, err := l2Client.GetProof(el.ctx, predeploys.L2ToL1MessagePasserAddr, nil, postBlockWithdrawalInfo.ParentHash().String()) + parentProof, err := l2Client.GetProof(el.ctx, predeploys.L2ToL1MessagePasserAddr, []common.Hash{}, postBlockWithdrawalInfo.ParentHash().String()) el.require.NoError(err, "failed to get parent storage proof") el.require.NotEqual(parentProof.StorageHash, postProof.StorageHash, "withdrawal hash should have changed between parent and current block") diff --git a/op-devstack/sysgo/l2_el_opreth.go b/op-devstack/sysgo/l2_el_opreth.go index 45a221bb9d7..55f4682fa4d 100644 --- a/op-devstack/sysgo/l2_el_opreth.go +++ b/op-devstack/sysgo/l2_el_opreth.go @@ -217,6 +217,7 @@ func WithOpReth(id stack.L2ELNodeID, opts ...L2ELOption) stack.Option[*Orchestra "--ipcdisable", "--authrpc.addr=127.0.0.1", "--authrpc.port=0", + "--rpc.eth-proof-window=30", "--authrpc.jwtsecret=" + jwtPath, "--txpool.minimum-priority-fee=1", "--txpool.nolocals", From 4554c9fb14705c0011a4eae2710348db67dc7b4b Mon Sep 17 00:00:00 2001 From: Adrian Sutton Date: Thu, 16 Oct 2025 07:32:03 +1000 Subject: [PATCH 066/117] op-dispute-mon: Consider node invalid if it has not processed L1 past the game head (#17831) --- .../mon/extract/output_agreement_enricher.go | 25 ++++++-- .../extract/output_agreement_enricher_test.go | 59 +++++++++++++++++-- 2 files changed, 74 insertions(+), 10 deletions(-) diff --git a/op-dispute-mon/mon/extract/output_agreement_enricher.go b/op-dispute-mon/mon/extract/output_agreement_enricher.go index d733d815dee..1d69520a1b9 100644 --- a/op-dispute-mon/mon/extract/output_agreement_enricher.go +++ b/op-dispute-mon/mon/extract/output_agreement_enricher.go @@ -23,6 +23,7 @@ var ( ) type OutputRollupClient interface { + SyncStatus(ctx context.Context) (*eth.SyncStatus, error) OutputAtBlock(ctx context.Context, blockNum uint64) (*eth.OutputResponse, error) SafeHeadAtL1Block(ctx context.Context, blockNum uint64) (*eth.SafeHeadResponse, error) } @@ -48,10 +49,11 @@ func NewOutputAgreementEnricher(logger log.Logger, metrics OutputMetrics, client } type outputResult struct { - outputRoot common.Hash - isSafe bool - notFound bool - err error + outputRoot common.Hash + gameL1HeadUnprocessed bool + isSafe bool + notFound bool + err error } // Enrich validates the specified root claim against the output at the given block number. @@ -76,6 +78,18 @@ func (o *OutputAgreementEnricher) Enrich(ctx context.Context, block rpcblock.Blo wg.Add(1) go func(i int, client OutputRollupClient) { defer wg.Done() + + syncStatus, err := client.SyncStatus(ctx) + if err != nil { + results[i] = outputResult{err: fmt.Errorf("failed to fetch sync status: %w", err)} + return + } + if syncStatus.CurrentL1.Number <= game.L1HeadNum { + o.log.Warn("Rollup node out of sync", "gameL1HeadNum", game.L1HeadNum, "nodeCurrentL1", syncStatus.CurrentL1.Number) + results[i] = outputResult{gameL1HeadUnprocessed: true} + return + } + output, err := client.OutputAtBlock(ctx, game.L2BlockNumber) if err != nil { // Only treat JSON-RPC application-level "not found" as notFound. @@ -117,6 +131,9 @@ func (o *OutputAgreementEnricher) Enrich(ctx context.Context, block rpcblock.Blo o.log.Error("Failed to fetch output root", "clientIndex", idx, "l2BlockNum", game.L2BlockNumber, "err", result.err) continue } + if result.gameL1HeadUnprocessed { + continue + } validResults = append(validResults, result) diff --git a/op-dispute-mon/mon/extract/output_agreement_enricher_test.go b/op-dispute-mon/mon/extract/output_agreement_enricher_test.go index d5d59383fa8..d92f15bf0fe 100644 --- a/op-dispute-mon/mon/extract/output_agreement_enricher_test.go +++ b/op-dispute-mon/mon/extract/output_agreement_enricher_test.go @@ -116,7 +116,41 @@ func TestOutputAgreementEnricher(t *testing.T) { require.Zero(t, metrics.fetchTime) }) + t.Run("AllNodesOutOfSync", func(t *testing.T) { + validator, clients, metrics := setupMultiNodeTest(t, 3) + clients[0].currentL1 = 99 + clients[1].currentL1 = 100 // Out of sync because it is only equal to the game L1 head + clients[2].currentL1 = 0 + game := &types.EnrichedGameData{ + L1HeadNum: 100, + L2BlockNumber: 0, + RootClaim: mockRootClaim, + } + err := validator.Enrich(context.Background(), rpcblock.Latest, nil, game) + require.ErrorIs(t, err, ErrAllNodesUnavailable) + require.Equal(t, common.Hash{}, game.ExpectedRootClaim) + require.False(t, game.AgreeWithClaim) + require.Zero(t, metrics.fetchTime) + }) + t.Run("SomeNodesOutOfSync", func(t *testing.T) { + validator, clients, metrics := setupMultiNodeTest(t, 3) + clients[0].currentL1 = 99 + // Would disagree but will be ignored because node is not in sync + clients[0].outputRoot = common.Hash{0xaa, 0xbb, 0xcc, 0xdd} + game := &types.EnrichedGameData{ + L1HeadNum: 100, + L2BlockNumber: 0, + RootClaim: mockRootClaim, + } + err := validator.Enrich(context.Background(), rpcblock.Latest, nil, game) + require.NoError(t, err) + require.Equal(t, mockRootClaim, game.ExpectedRootClaim) + require.True(t, game.AgreeWithClaim) // Agree with the claim because all in-sync nodes returned the same result + require.NotZero(t, metrics.fetchTime) + }) + + t.Run("SomeNodesReturnNotFound", func(t *testing.T) { validator, clients, metrics := setupMultiNodeTest(t, 3) clients[0].outputErr = mockNotFoundRPCError() clients[1].outputErr = nil @@ -315,7 +349,10 @@ func (e testRPCError) ErrorCode() int { return e.code } func setupOutputValidatorTest(t *testing.T) (*OutputAgreementEnricher, *stubRollupClient, *stubOutputMetrics) { logger := testlog.Logger(t, log.LvlInfo) - client := &stubRollupClient{safeHeadNum: 99999999999} + client := &stubRollupClient{ + currentL1: math.MaxUint64, + safeHeadNum: 99999999999, + } metrics := &stubOutputMetrics{} validator := NewOutputAgreementEnricher(logger, metrics, []OutputRollupClient{client}, clock.NewDeterministicClock(time.Unix(9824924, 499))) return validator, client, metrics @@ -327,6 +364,7 @@ func setupMultiNodeTest(t *testing.T, numNodes int) (*OutputAgreementEnricher, [ rollupClients := make([]OutputRollupClient, numNodes) for i := range clients { clients[i] = &stubRollupClient{ + currentL1: math.MaxUint64, safeHeadNum: 99999999999, outputRoot: mockRootClaim, } @@ -346,11 +384,20 @@ func (s *stubOutputMetrics) RecordOutputFetchTime(fetchTime float64) { } type stubRollupClient struct { - blockNum uint64 - outputErr error - safeHeadErr error - safeHeadNum uint64 - outputRoot common.Hash + blockNum uint64 + outputErr error + safeHeadErr error + safeHeadNum uint64 + outputRoot common.Hash + currentL1 uint64 + syncStatusErr error +} + +func (s *stubRollupClient) SyncStatus(_ context.Context) (*eth.SyncStatus, error) { + if s.syncStatusErr != nil { + return nil, s.syncStatusErr + } + return ð.SyncStatus{CurrentL1: eth.L1BlockRef{Number: s.currentL1}}, nil } func (s *stubRollupClient) OutputAtBlock(_ context.Context, blockNum uint64) (*eth.OutputResponse, error) { From a40c1556cd7e78bd88f01af828f5838fd1ffd50d Mon Sep 17 00:00:00 2001 From: Paul Dowman Date: Wed, 15 Oct 2025 15:35:12 -0600 Subject: [PATCH 067/117] Update TODO with more granular issue number (#17885) --- op-acceptance-tests/tests/base/disputegame_v2/smoke_test.go | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/op-acceptance-tests/tests/base/disputegame_v2/smoke_test.go b/op-acceptance-tests/tests/base/disputegame_v2/smoke_test.go index 3824d1e62e1..0646fc06d96 100644 --- a/op-acceptance-tests/tests/base/disputegame_v2/smoke_test.go +++ b/op-acceptance-tests/tests/base/disputegame_v2/smoke_test.go @@ -9,7 +9,7 @@ import ( ) func TestSmoke(gt *testing.T) { - gt.Skip("TODO(#17257): Re-enable once opcm.deploy supports v2 dispute games") + gt.Skip("TODO(#17810): Re-enable once opcm.deploy supports v2 dispute games") t := devtest.SerialT(gt) sys := presets.NewMinimal(t) require := t.Require() From a30a00ac95fdb3387303c1709374bfd1f8c71e1b Mon Sep 17 00:00:00 2001 From: "devin-ai-integration[bot]" <158243242+devin-ai-integration[bot]@users.noreply.github.com> Date: Thu, 16 Oct 2025 07:43:20 -0400 Subject: [PATCH 068/117] refactor(test): improve ReinitializableBase test organization (#17839) * refactor(test): improve ReinitializableBase test organization - Split tests into separate contracts per function - ReinitializableBase_Constructor_Test for constructor validation - ReinitializableBase_InitVersion_Test for initVersion getter - Fixed comment length to comply with <100 char standard - Tests organized to match source declaration order * refactor(test): consolidate tests into Constructor test suite Per review feedback, move initVersion fuzz test into Constructor test contract since initVersion() just returns the immutable value set by the constructor. Delete separate InitVersion test contract. * refactor(test): rename test function to match container contract Per review feedback, rename testFuzz_initVersion_validVersion_succeeds to testFuzz_constructor_validVersion_succeeds since the test is now in the Constructor_Test contract. Test names should match their container. * refactor(test): improve test comment clarity - update comment to better describe constructor validation test - comment now matches function naming convention --------- Co-authored-by: Devin AI <158243242+devin-ai-integration[bot]@users.noreply.github.com> --- .../test/universal/ReinitializableBase.t.sol | 30 ++++++++----------- 1 file changed, 12 insertions(+), 18 deletions(-) diff --git a/packages/contracts-bedrock/test/universal/ReinitializableBase.t.sol b/packages/contracts-bedrock/test/universal/ReinitializableBase.t.sol index f5014311dcf..805da5b5fab 100644 --- a/packages/contracts-bedrock/test/universal/ReinitializableBase.t.sol +++ b/packages/contracts-bedrock/test/universal/ReinitializableBase.t.sol @@ -14,26 +14,20 @@ contract ReinitializableBase_Harness is ReinitializableBase { constructor(uint8 _initVersion) ReinitializableBase(_initVersion) { } } -/// @title ReinitializableBase_InitVersion_Test -/// @notice Tests the `initVersion` function of the `ReinitializableBase` contract. -contract ReinitializableBase_InitVersion_Test is Test { - /// @notice Tests that the contract is created correctly and initVersion returns the right - /// value when the provided init version is non-zero. - /// @param _initVersion The init version to use when creating the contract. - function testFuzz_initVersion_validVersion_succeeds(uint8 _initVersion) public { - // Zero version not allowed. - _initVersion = uint8(bound(_initVersion, 1, type(uint8).max)); +/// @title ReinitializableBase_Constructor_Test +/// @notice Tests the constructor of the `ReinitializableBase` contract. +contract ReinitializableBase_Constructor_Test is Test { + /// @notice Tests that the contract creation reverts when init version is zero. + function test_constructor_zeroVersion_reverts() public { + vm.expectRevert(ReinitializableBase.ReinitializableBase_ZeroInitVersion.selector); + new ReinitializableBase_Harness(0); + } - // Deploy the reinitializable contract. + /// @notice Tests that constructor succeeds with valid non-zero init versions. + /// @param _initVersion Init version to use when creating the contract. + function testFuzz_constructor_validVersion_succeeds(uint8 _initVersion) public { + _initVersion = uint8(bound(_initVersion, 1, type(uint8).max)); ReinitializableBase_Harness harness = new ReinitializableBase_Harness(_initVersion); - - // Check the init version. assertEq(harness.initVersion(), _initVersion); } - - /// @notice Tests that the contract creation reverts when the init version is zero. - function test_initVersion_zeroVersion_reverts() public { - vm.expectRevert(ReinitializableBase.ReinitializableBase_ZeroInitVersion.selector); - new ReinitializableBase_Harness(0); - } } From 4b102be537be55fcb013bbe9a2691ff45234f71c Mon Sep 17 00:00:00 2001 From: Changwan Park Date: Thu, 16 Oct 2025 22:31:06 +0900 Subject: [PATCH 069/117] op-acceptance-tests: Retry FCU for triggering EL Sync (#17894) --- .../tests/sync/elsync/gap_elp2p/sync_test.go | 6 +++--- op-devstack/dsl/l2_el.go | 19 +++++++++++++++++++ 2 files changed, 22 insertions(+), 3 deletions(-) diff --git a/op-acceptance-tests/tests/sync/elsync/gap_elp2p/sync_test.go b/op-acceptance-tests/tests/sync/elsync/gap_elp2p/sync_test.go index f3961fa94cc..f52bf78be79 100644 --- a/op-acceptance-tests/tests/sync/elsync/gap_elp2p/sync_test.go +++ b/op-acceptance-tests/tests/sync/elsync/gap_elp2p/sync_test.go @@ -184,10 +184,10 @@ func TestL2ELP2PCanonicalChainAdvancedByFCU(gt *testing.T) { attempts := 3 // FCU to target block which can be eventually validated, because ELP2P enabled - // Example logs from L2EL(geth) - // New skeleton head announced - // Backfilling with the network sys.L2ELB.ForkchoiceUpdate(sys.L2EL, targetNum, 0, 0, nil).IsSyncing() + // In rare cases, EL is not ready to trigger EL Sync even though peers attached + // Retry a few times until the first EL Sync is complete + sys.L2ELB.FinishedELSync(sys.L2EL, targetNum, 0, 0) // Wait until L2EL finishes EL Sync and canonicalizes until targetNum sys.L2ELB.Reached(eth.Unsafe, targetNum, 3) diff --git a/op-devstack/dsl/l2_el.go b/op-devstack/dsl/l2_el.go index c55e934df52..33b8b73fd6f 100644 --- a/op-devstack/dsl/l2_el.go +++ b/op-devstack/dsl/l2_el.go @@ -2,6 +2,7 @@ package dsl import ( "context" + "errors" "fmt" "strings" "time" @@ -254,3 +255,21 @@ func (el *L2ELNode) ForkchoiceUpdate(refNode *L2ELNode, unsafe, safe, finalized result.Refresh() return result } + +func (el *L2ELNode) FinishedELSync(refNode *L2ELNode, unsafe, safe, finalized uint64) { + el.log.Info("Start EL Sync", "unsafe", unsafe, "safe", safe, "finalized", finalized) + trial := 1 + el.require.NoError(retry.Do0(el.ctx, 5, &retry.FixedStrategy{Dur: 2 * time.Second}, func() error { + el.log.Info("FCU to activate EL Sync", "trial", trial) + res := el.ForkchoiceUpdate(refNode, unsafe, safe, finalized, nil) + // If EL Sync triggered, Example logs from L2EL(geth) + // New skeleton head announced + // Backfilling with the network + if res.Result.PayloadStatus.Status == eth.ExecutionValid { + el.log.Info("Finished EL Sync") + return nil + } + trial += 1 + return errors.New("EL Sync not yet triggered") + })) +} From aeed7033f7f739d8ecd4bd70a42ff09013bbc91e Mon Sep 17 00:00:00 2001 From: Taehoon Kim Date: Thu, 16 Oct 2025 07:37:42 -0700 Subject: [PATCH 070/117] feat: implement Operator Fee Fix (Jovian) (#17366) * fix!: multiply operatorFeeScalar by 100 instead of dividing by 1e6 * chore: bump to 1.5.0 * chore: bump to 2.0.0 * refac: gate at Jovian * missing changes * update * reduce diff * snapshot abi + storage layout + remove unncessary change * apply comments * make ci green * chore: update go.mod * fix: activate Jovian in e2e tests * feat: add Jovian upgrate transactions * fix: update GPO bytecode * use IsOperatorFeeFix * add jovian operator fee acceptance test * chore: add commit hash for GPO bytecode * chore: remove useless replace in go.mod * acceptance-tests: push common code for operator fee into dsl Also use block timestamp to infer isJovian and assert consistency in GPO. * tweak * refactor IsthmusCostOracle * fix link * tag TODO for followup * update op-geth * lint * lint * revert changes to op-service/txinclude According to @joshklop we don't need to make any changes here at the current time, the code is not actually being used anywhere apart from some skipped tests. * regenerate l1block bytecode and resolve nonce clash * decouple upgrade transactions, change API to getter and fix tests * update op-geth reference * Update packages/contracts-bedrock/test/L2/GasPriceOracle.t.sol Co-authored-by: Matt Solomon * jovian upgrade transactions: reorder deployer addresses * just update-op-geth 5c6d276814f2cce1d4dda25ed9e5a3a1c52e59a4 * explicitly disallow user transactions in jovian activation block * assert on receipts in operator fee acceptance test * op-e2e/actions: remove jovianActivationBlock test case replace with running the normalTx test case on the jovian fork --------- Co-authored-by: leruaa Co-authored-by: geoknee Co-authored-by: Matt Solomon --- go.mod | 2 +- go.sum | 4 +- .../isthmus/operator_fee/operator_fee_test.go | 51 +-------- .../tests/jovian/operator_fee_test.go | 18 ++++ op-devstack/dsl/bridge.go | 55 ++++++++-- op-devstack/dsl/l2_network.go | 4 + op-devstack/dsl/operator_fee.go | 86 ++++++++++++++- op-e2e/actions/proofs/operator_fee_test.go | 37 +++++-- op-e2e/bindings/gaspriceoracle.go | 61 ++++++++++- op-e2e/system/e2esys/setup.go | 3 - op-e2e/system/fees/fees_test.go | 44 ++++++-- op-node/rollup/derive/attributes.go | 4 +- .../derive/jovian_upgrade_transactions.go | 102 +++++++++++++++++- .../jovian_upgrade_transactions_test.go | 53 +++++++++ op-node/rollup/derive/l1_block_info.go | 2 +- op-node/rollup/sequencing/sequencer.go | 6 ++ op-service/txinclude/txbudget.go | 4 +- .../txintent/bindings/GasPriceOracle.go | 2 + .../interfaces/L2/IGasPriceOracle.sol | 2 + .../contracts-bedrock/scripts/L2Genesis.s.sol | 11 +- .../snapshots/abi/GasPriceOracle.json | 20 ++++ .../snapshots/semver-lock.json | 4 +- .../storageLayout/GasPriceOracle.json | 7 ++ .../src/L2/GasPriceOracle.sol | 37 +++++-- .../test/L2/GasPriceOracle.t.sol | 93 +++++++++++++++- 25 files changed, 600 insertions(+), 112 deletions(-) create mode 100644 op-acceptance-tests/tests/jovian/operator_fee_test.go create mode 100644 op-node/rollup/derive/jovian_upgrade_transactions_test.go diff --git a/go.mod b/go.mod index 7e582724fa1..789e145b6fe 100644 --- a/go.mod +++ b/go.mod @@ -308,7 +308,7 @@ require ( lukechampine.com/blake3 v1.3.0 // indirect ) -replace github.com/ethereum/go-ethereum => github.com/ethereum-optimism/op-geth v1.101603.2-0.20251014161648-ded9c88e417b +replace github.com/ethereum/go-ethereum => github.com/ethereum-optimism/op-geth v1.101603.2-0.20251016091451-5c6d276814f2 // replace github.com/ethereum/go-ethereum => ../op-geth diff --git a/go.sum b/go.sum index 908b8bc83cc..58101d03573 100644 --- a/go.sum +++ b/go.sum @@ -238,8 +238,8 @@ github.com/emicklei/dot v1.6.2 h1:08GN+DD79cy/tzN6uLCT84+2Wk9u+wvqP+Hkx/dIR8A= github.com/emicklei/dot v1.6.2/go.mod h1:DeV7GvQtIw4h2u73RKBkkFdvVAz0D9fzeJrgPW6gy/s= github.com/ethereum-optimism/go-ethereum-hdwallet v0.1.4-0.20251001155152-4eb15ccedf7e h1:iy1vBIzACYUyOVyoADUwvAiq2eOPC0yVsDUdolPwQjk= github.com/ethereum-optimism/go-ethereum-hdwallet v0.1.4-0.20251001155152-4eb15ccedf7e/go.mod h1:DYj7+vYJ4cIB7zera9mv4LcAynCL5u4YVfoeUu6Wa+w= -github.com/ethereum-optimism/op-geth v1.101603.2-0.20251014161648-ded9c88e417b h1:5FhpB8a0wXp/11jd6OnUIX3Blwy2Wh9aa+z+AA9amUM= -github.com/ethereum-optimism/op-geth v1.101603.2-0.20251014161648-ded9c88e417b/go.mod h1:Ct2QjqZ2UKgvvgKLLYzoh/DBicJZB8DXsv45DgEjcco= +github.com/ethereum-optimism/op-geth v1.101603.2-0.20251016091451-5c6d276814f2 h1:fvYTR+KOcvSDd/gJuh+ALG/Fx7Y0xU3ZaDkgT/kqVi0= +github.com/ethereum-optimism/op-geth v1.101603.2-0.20251016091451-5c6d276814f2/go.mod h1:Ct2QjqZ2UKgvvgKLLYzoh/DBicJZB8DXsv45DgEjcco= github.com/ethereum-optimism/superchain-registry/validation v0.0.0-20251009180028-9b4658b9b7af h1:WWz0gJM/boaUImtJnROecPirAerKCLpAU4m6Tx0ArOg= github.com/ethereum-optimism/superchain-registry/validation v0.0.0-20251009180028-9b4658b9b7af/go.mod h1:NZ816PzLU1TLv1RdAvYAb6KWOj4Zm5aInT0YpDVml2Y= github.com/ethereum/c-kzg-4844/v2 v2.1.0 h1:gQropX9YFBhl3g4HYhwE70zq3IHFRgbbNPw0Shwzf5w= diff --git a/op-acceptance-tests/tests/isthmus/operator_fee/operator_fee_test.go b/op-acceptance-tests/tests/isthmus/operator_fee/operator_fee_test.go index e9a3f192b16..856aebeba48 100644 --- a/op-acceptance-tests/tests/isthmus/operator_fee/operator_fee_test.go +++ b/op-acceptance-tests/tests/isthmus/operator_fee/operator_fee_test.go @@ -1,65 +1,18 @@ package operatorfee import ( - "math/big" "testing" "github.com/ethereum-optimism/optimism/op-devstack/devtest" "github.com/ethereum-optimism/optimism/op-devstack/dsl" "github.com/ethereum-optimism/optimism/op-devstack/presets" "github.com/ethereum-optimism/optimism/op-node/rollup" - "github.com/ethereum-optimism/optimism/op-service/eth" ) func TestOperatorFee(gt *testing.T) { t := devtest.SerialT(gt) sys := presets.NewMinimal(t) - require := t.Require() - err := dsl.RequiresL2Fork(t.Ctx(), sys, 0, rollup.Isthmus) - require.NoError(err, "Isthmus fork must be active for this test") - - fundAmount := eth.OneTenthEther - alice := sys.FunderL2.NewFundedEOA(fundAmount) - - alice.WaitForBalance(fundAmount) - bob := sys.Wallet.NewEOA(sys.L2EL) - - operatorFee := dsl.NewOperatorFee(t, sys.L2Chain, sys.L1EL) - - operatorFee.CheckCompatibility() - systemOwner := operatorFee.GetSystemOwner() - sys.FunderL1.FundAtLeast(systemOwner, fundAmount) - - // First, ensure L2 is synced with current L1 state before starting tests - t.Log("Ensuring L2 is synced with current L1 state...") - operatorFee.WaitForL2SyncWithCurrentL1State() - - testCases := []struct { - name string - scalar uint32 - constant uint64 - }{ - {"ZeroFees", 0, 0}, - {"NonZeroFees", 300, 400}, - } - - for _, tc := range testCases { - t.Run(tc.name, func(t devtest.T) { - operatorFee.SetOperatorFee(tc.scalar, tc.constant) - operatorFee.WaitForL2Sync(tc.scalar, tc.constant) - operatorFee.VerifyL2Config(tc.scalar, tc.constant) - - result := operatorFee.ValidateTransactionFees(alice, bob, big.NewInt(1000), tc.scalar, tc.constant) - - t.Log("Test completed successfully:", - "testCase", tc.name, - "gasUsed", result.TransactionReceipt.GasUsed, - "actualTotalFee", result.ActualTotalFee.String(), - "expectedOperatorFee", result.ExpectedOperatorFee.String(), - "vaultBalanceIncrease", result.VaultBalanceIncrease.String()) - }) - } - - operatorFee.RestoreOriginalConfig() + t.Require().NoError(err, "Isthmus fork must be active for this test") + dsl.RunOperatorFeeTest(t, sys.L2Chain, sys.L1EL, sys.FunderL1, sys.FunderL2) } diff --git a/op-acceptance-tests/tests/jovian/operator_fee_test.go b/op-acceptance-tests/tests/jovian/operator_fee_test.go new file mode 100644 index 00000000000..e2e9e046a4b --- /dev/null +++ b/op-acceptance-tests/tests/jovian/operator_fee_test.go @@ -0,0 +1,18 @@ +package jovian + +import ( + "testing" + + "github.com/ethereum-optimism/optimism/op-devstack/devtest" + "github.com/ethereum-optimism/optimism/op-devstack/dsl" + "github.com/ethereum-optimism/optimism/op-devstack/presets" + "github.com/ethereum-optimism/optimism/op-node/rollup" +) + +func TestOperatorFee(gt *testing.T) { + t := devtest.SerialT(gt) + sys := presets.NewMinimal(t) + err := dsl.RequiresL2Fork(t.Ctx(), sys, 0, rollup.Jovian) + t.Require().NoError(err, "Jovian fork must be active for this test") + dsl.RunOperatorFeeTest(t, sys.L2Chain, sys.L1EL, sys.FunderL1, sys.FunderL2) +} diff --git a/op-devstack/dsl/bridge.go b/op-devstack/dsl/bridge.go index 8f59070d7d5..238abcffb54 100644 --- a/op-devstack/dsl/bridge.go +++ b/op-devstack/dsl/bridge.go @@ -149,11 +149,15 @@ func (b *StandardBridge) UsesSuperRoots() bool { } type Deposit struct { + bridge *StandardBridge l1Receipt *types.Receipt } func (d Deposit) GasCost() eth.ETH { - return gasCost(d.l1Receipt) + if d.bridge == nil { + panic("bridge reference not set on deposit") + } + return d.bridge.gasCost(d.l1Receipt, d.bridge.l1Client) } func (b *StandardBridge) Deposit(amount eth.ETH, from *EOA) Deposit { @@ -175,6 +179,7 @@ func (b *StandardBridge) Deposit(amount eth.ETH, from *EOA) Deposit { }, 60*time.Second, 500*time.Millisecond, "L2 Deposit never found") b.require.Equal(types.ReceiptStatusSuccessful, l2DepositReceipt.Status) return Deposit{ + bridge: b, l1Receipt: l1DepositReceipt, } } @@ -220,6 +225,7 @@ func (b *StandardBridge) ERC20Deposit(l1TokenAddr common.Address, l2TokenAddr co b.require.Equal(types.ReceiptStatusSuccessful, l2DepositReceipt.Status, "L2 ERC20 deposit should succeed") return &Deposit{ + bridge: b, l1Receipt: depositReceipt, } } @@ -345,17 +351,17 @@ type Withdrawal struct { } func (w *Withdrawal) InitiateGasCost() eth.ETH { - return gasCost(w.initReceipt) + return w.bridge.gasCost(w.initReceipt, w.bridge.l2Client) } func (w *Withdrawal) ProveGasCost() eth.ETH { w.require.NotNil(w.proveReceipt, "Must have proven withdrawal before calculating gas cost") - return gasCost(w.proveReceipt) + return w.bridge.gasCost(w.proveReceipt, w.bridge.l1Client) } func (w *Withdrawal) FinalizeGasCost() eth.ETH { w.require.NotNil(w.finalizeReceipt, "Must have finalized withdrawal before calculating gas cost") - return gasCost(w.finalizeReceipt) + return w.bridge.gasCost(w.finalizeReceipt, w.bridge.l1Client) } func (w *Withdrawal) InitiateBlockHash() common.Hash { @@ -563,18 +569,47 @@ func (w *Withdrawal) WaitForDisputeGameResolved() { }, 60*time.Second, 100*time.Millisecond, "wait for dispute game resolved") } -func gasCost(rcpt *types.Receipt) eth.ETH { +func (b *StandardBridge) gasCost(rcpt *types.Receipt, client apis.EthClient) eth.ETH { + var blockTimestamp *uint64 + if hasOperatorFee(rcpt) { + b.require.NotNil(client, "client is required to resolve operator fee timestamp") + blockTimestamp = b.receiptTimestamp(rcpt, client) + } + return gasCost(rcpt, b.rollupCfg, blockTimestamp) +} + +func hasOperatorFee(rcpt *types.Receipt) bool { + return rcpt.OperatorFeeConstant != nil && rcpt.OperatorFeeScalar != nil +} + +func (b *StandardBridge) receiptTimestamp(rcpt *types.Receipt, client apis.EthClient) *uint64 { + b.require.NotNil(rcpt.BlockNumber, "receipt missing block number") + blockInfo, err := client.InfoByNumber(b.ctx, rcpt.BlockNumber.Uint64()) + b.require.NoError(err, "failed to fetch block info for receipt") + ts := blockInfo.Time() + return &ts +} + +func gasCost(rcpt *types.Receipt, rollupCfg *rollup.Config, blockTimestamp *uint64) eth.ETH { cost := eth.WeiBig(new(big.Int).Mul(new(big.Int).SetUint64(rcpt.GasUsed), rcpt.EffectiveGasPrice)) if rcpt.L1Fee != nil { cost = cost.Add(eth.WeiBig(rcpt.L1Fee)) } - if rcpt.OperatorFeeConstant != nil && rcpt.OperatorFeeScalar != nil { - // https://github.com/ethereum-optimism/op-geth/blob/6005dd53e1b50fe5a3f59764e3e2056a639eff2f/core/types/rollup_cost.go#L244-L247 - // Also see: https://specs.optimism.io/protocol/isthmus/exec-engine.html#operator-operatorCost + if hasOperatorFee(rcpt) { + if rollupCfg == nil { + panic("rollup config is required to compute operator fee") + } + if blockTimestamp == nil { + panic("block timestamp is required to compute operator fee") + } operatorCost := new(big.Int).SetUint64(rcpt.GasUsed) operatorCost.Mul(operatorCost, new(big.Int).SetUint64(*rcpt.OperatorFeeScalar)) - operatorCost = operatorCost.Div(operatorCost, big.NewInt(1_000_000)) - operatorCost = operatorCost.Add(operatorCost, new(big.Int).SetUint64(*rcpt.OperatorFeeConstant)) + if rollupCfg.IsOperatorFeeFix(*blockTimestamp) { + operatorCost.Mul(operatorCost, big.NewInt(100)) + } else { + operatorCost.Div(operatorCost, big.NewInt(1_000_000)) + } + operatorCost.Add(operatorCost, new(big.Int).SetUint64(*rcpt.OperatorFeeConstant)) cost = cost.Add(eth.WeiBig(operatorCost)) } return cost diff --git a/op-devstack/dsl/l2_network.go b/op-devstack/dsl/l2_network.go index fa0572da126..bdba587724a 100644 --- a/op-devstack/dsl/l2_network.go +++ b/op-devstack/dsl/l2_network.go @@ -192,6 +192,10 @@ func (n *L2Network) IsActivated(timestamp uint64) bool { return head.Number >= blockNum } +func (n *L2Network) IsForkActive(forkName rollup.ForkName, timestamp uint64) bool { + return n.Escape().RollupConfig().IsForkActive(forkName, timestamp) +} + // LatestBlockBeforeTimestamp finds the latest block before fork activation func (n *L2Network) LatestBlockBeforeTimestamp(t devtest.T, timestamp uint64) eth.BlockRef { require := t.Require() diff --git a/op-devstack/dsl/operator_fee.go b/op-devstack/dsl/operator_fee.go index e9232b15af3..71559ddc700 100644 --- a/op-devstack/dsl/operator_fee.go +++ b/op-devstack/dsl/operator_fee.go @@ -7,6 +7,7 @@ import ( "github.com/ethereum-optimism/optimism/op-chain-ops/devkeys" "github.com/ethereum-optimism/optimism/op-devstack/devtest" "github.com/ethereum-optimism/optimism/op-devstack/stack/match" + "github.com/ethereum-optimism/optimism/op-node/rollup" "github.com/ethereum-optimism/optimism/op-service/eth" "github.com/ethereum-optimism/optimism/op-service/predeploys" "github.com/ethereum-optimism/optimism/op-service/txintent/bindings" @@ -17,10 +18,11 @@ import ( type OperatorFee struct { commonImpl - l1Client *L1ELNode - l2Network *L2Network - systemConfig bindings.SystemConfig - l1Block bindings.L1Block + l1Client *L1ELNode + l2Network *L2Network + systemConfig bindings.SystemConfig + l1Block bindings.L1Block + gasPriceOracle bindings.GasPriceOracle originalScalar uint32 originalConstant uint64 @@ -44,6 +46,11 @@ func NewOperatorFee(t devtest.T, l2Network *L2Network, l1EL *L1ELNode) *Operator bindings.WithTo(predeploys.L1BlockAddr), bindings.WithTest(t)) + gasPriceOracle := bindings.NewBindings[bindings.GasPriceOracle]( + bindings.WithClient(l2Network.inner.L2ELNode(match.FirstL2EL).EthClient()), + bindings.WithTo(predeploys.GasPriceOracleAddr), + bindings.WithTest(t)) + originalScalar, err := contractio.Read(systemConfig.OperatorFeeScalar(), t.Ctx()) t.Require().NoError(err) originalConstant, err := contractio.Read(systemConfig.OperatorFeeConstant(), t.Ctx()) @@ -55,6 +62,7 @@ func NewOperatorFee(t devtest.T, l2Network *L2Network, l1EL *L1ELNode) *Operator l2Network: l2Network, systemConfig: systemConfig, l1Block: l1Block, + gasPriceOracle: gasPriceOracle, originalScalar: originalScalar, originalConstant: originalConstant, } @@ -131,6 +139,11 @@ func (of *OperatorFee) ValidateTransactionFees(from *EOA, to *EOA, amount *big.I of.require.NoError(err) of.require.Equal(types.ReceiptStatusSuccessful, receipt.Status) + blockHash := receipt.BlockHash + blockRef, err := from.el.stackEL().EthClient().BlockRefByHash(of.ctx, blockHash) + of.require.NoError(err) + isJovian := of.l2Network.IsForkActive(rollup.Jovian, blockRef.Time) + vaultAfter, err := from.el.stackEL().EthClient().BalanceAt(of.ctx, predeploys.OperatorFeeVaultAddr, nil) of.require.NoError(err) @@ -140,8 +153,19 @@ func (of *OperatorFee) ValidateTransactionFees(from *EOA, to *EOA, amount *big.I if expectedScalar == 0 && expectedConstant == 0 { expectedOperatorFee = big.NewInt(0) } else { + isJovianinGPO, err := contractio.Read(of.gasPriceOracle.IsJovian(), of.ctx) + of.require.NoError(err) + operatorFee := new(big.Int).Mul(big.NewInt(int64(receipt.GasUsed)), big.NewInt(int64(expectedScalar))) - operatorFee.Div(operatorFee, big.NewInt(1000000)) + if isJovian { + of.require.Equal(isJovianinGPO, true) + // Jovian formula: (gasUsed * operatorFeeScalar * 100) + operatorFeeConstant + operatorFee.Mul(operatorFee, big.NewInt(100)) + } else { + of.require.Equal(isJovianinGPO, false) + // Isthmus formula: (gasUsed * operatorFeeScalar / 1e6) + operatorFeeConstant + operatorFee.Div(operatorFee, big.NewInt(1000000)) + } operatorFee.Add(operatorFee, big.NewInt(int64(expectedConstant))) expectedOperatorFee = operatorFee } @@ -156,6 +180,14 @@ func (of *OperatorFee) ValidateTransactionFees(from *EOA, to *EOA, amount *big.I actualTotalFee.Add(actualTotalFee, receipt.L1Fee) } + if expectedScalar != 0 || expectedConstant != 0 { + of.require.NotNil(receipt.OperatorFeeScalar) + of.require.NotNil(receipt.OperatorFeeConstant) + + of.require.Equal(expectedScalar, uint32(*receipt.OperatorFeeScalar)) + of.require.Equal(expectedConstant, *receipt.OperatorFeeConstant) + } + return OperatorFeeValidationResult{ TransactionReceipt: receipt, ExpectedOperatorFee: expectedOperatorFee, @@ -167,3 +199,47 @@ func (of *OperatorFee) ValidateTransactionFees(from *EOA, to *EOA, amount *big.I func (of *OperatorFee) RestoreOriginalConfig() { of.SetOperatorFee(of.originalScalar, of.originalConstant) } + +func RunOperatorFeeTest(t devtest.T, l2Chain *L2Network, l1EL *L1ELNode, funderL1, funderL2 *Funder) { + fundAmount := eth.OneTenthEther + alice := funderL2.NewFundedEOA(fundAmount) + alice.WaitForBalance(fundAmount) + bob := funderL2.NewFundedEOA(eth.ZeroWei) + + operatorFee := NewOperatorFee(t, l2Chain, l1EL) + operatorFee.CheckCompatibility() + systemOwner := operatorFee.GetSystemOwner() + funderL1.FundAtLeast(systemOwner, fundAmount) + + // First, ensure L2 is synced with current L1 state before starting tests + t.Log("Ensuring L2 is synced with current L1 state...") + operatorFee.WaitForL2SyncWithCurrentL1State() + + testCases := []struct { + name string + scalar uint32 + constant uint64 + }{ + {"ZeroFees", 0, 0}, + {"NonZeroFees", 300, 400}, + } + + for _, tc := range testCases { + t.Run(tc.name, func(t devtest.T) { + operatorFee.SetOperatorFee(tc.scalar, tc.constant) + operatorFee.WaitForL2Sync(tc.scalar, tc.constant) + operatorFee.VerifyL2Config(tc.scalar, tc.constant) + + result := operatorFee.ValidateTransactionFees(alice, bob, big.NewInt(1000), tc.scalar, tc.constant) + + t.Log("Test completed successfully:", + "testCase", tc.name, + "gasUsed", result.TransactionReceipt.GasUsed, + "actualTotalFee", result.ActualTotalFee.String(), + "expectedOperatorFee", result.ExpectedOperatorFee.String(), + "vaultBalanceIncrease", result.VaultBalanceIncrease.String()) + }) + } + + operatorFee.RestoreOriginalConfig() +} diff --git a/op-e2e/actions/proofs/operator_fee_test.go b/op-e2e/actions/proofs/operator_fee_test.go index 157f55929ba..b024be821a9 100644 --- a/op-e2e/actions/proofs/operator_fee_test.go +++ b/op-e2e/actions/proofs/operator_fee_test.go @@ -41,7 +41,7 @@ func Test_ProgramAction_OperatorFeeConsistency(gt *testing.T) { // The deployed bytecode below is from the contract above testStorageUpdateContractCode := common.FromHex("0x6080604052348015600e575f80fd5b50600436106026575f3560e01c806360fe47b114602a575b5f80fd5b60406004803603810190603c9190607d565b6042565b005b805f8190555050565b5f80fd5b5f819050919050565b605f81604f565b81146068575f80fd5b50565b5f813590506077816058565b92915050565b5f60208284031215608f57608e604b565b5b5f609a84828501606b565b9150509291505056fea26469706673582212201712a1e6e9c5e2ba1f8f7403f5d6e00090c6fa2b70c632beea4be8009331bd2064736f6c63430008190033") - runIsthmusDerivationTest := func(gt *testing.T, testCfg *helpers.TestCfg[testCase]) { + runJovianDerivationTest := func(gt *testing.T, testCfg *helpers.TestCfg[testCase]) { t := actionsHelpers.NewDefaultTesting(gt) deployConfigOverrides := func(dp *genesis.DeployConfig) {} @@ -297,8 +297,23 @@ func Test_ProgramAction_OperatorFeeConsistency(gt *testing.T) { require.Equal(t, testOperatorFeeConstant, *receipt.OperatorFeeConstant) // Check that the operator fee sent to the vault is correct - require.Equal(t, - new(big.Int).Add( + // Determine which formula to use based on whether Jovian is active + var expectedOperatorFee *big.Int + if env.Sd.RollupCfg.IsJovian(l2UnsafeHead.Time) { + // Jovian formula: (gasUsed * operatorFeeScalar * 100) + operatorFeeConstant + expectedOperatorFee = new(big.Int).Add( + new(big.Int).Mul( + new(big.Int).Mul( + new(big.Int).SetUint64(receipt.GasUsed), + new(big.Int).SetUint64(uint64(testOperatorFeeScalar)), + ), + new(big.Int).SetUint64(100), + ), + new(big.Int).SetUint64(testOperatorFeeConstant), + ) + } else { + // Isthmus formula: (gasUsed * operatorFeeScalar / 1e6) + operatorFeeConstant + expectedOperatorFee = new(big.Int).Add( new(big.Int).Div( new(big.Int).Mul( new(big.Int).SetUint64(receipt.GasUsed), @@ -307,7 +322,11 @@ func Test_ProgramAction_OperatorFeeConsistency(gt *testing.T) { new(big.Int).SetUint64(1e6), ), new(big.Int).SetUint64(testOperatorFeeConstant), - ), + ) + } + + require.Equal(t, + expectedOperatorFee, new(big.Int).Sub(operatorFeeVaultFinalBalance, operatorFeeVaultInitialBalance), ) } @@ -373,11 +392,11 @@ func Test_ProgramAction_OperatorFeeConsistency(gt *testing.T) { } matrix := helpers.NewMatrix[testCase]() - matrix.AddDefaultTestCasesWithName("NormalTx", NormalTx, helpers.NewForkMatrix(helpers.Isthmus), runIsthmusDerivationTest) - matrix.AddDefaultTestCasesWithName("DepositTx", DepositTx, helpers.NewForkMatrix(helpers.Isthmus), runIsthmusDerivationTest) - matrix.AddDefaultTestCasesWithName("StateRefund", StateRefund, helpers.NewForkMatrix(helpers.Isthmus), runIsthmusDerivationTest) - matrix.AddDefaultTestCasesWithName("NotEnoughFundsInBatchMissingOpFee", NotEnoughFundsInBatchMissingOpFee, helpers.NewForkMatrix(helpers.Holocene, helpers.Isthmus), runIsthmusDerivationTest) - matrix.AddDefaultTestCasesWithName("IsthmusTransitionBlock", IsthmusTransitionBlock, helpers.NewForkMatrix(helpers.Holocene), runIsthmusDerivationTest) + matrix.AddDefaultTestCasesWithName("NormalTx", NormalTx, helpers.NewForkMatrix(helpers.Isthmus, helpers.Jovian), runJovianDerivationTest) + matrix.AddDefaultTestCasesWithName("DepositTx", DepositTx, helpers.NewForkMatrix(helpers.Isthmus, helpers.Jovian), runJovianDerivationTest) + matrix.AddDefaultTestCasesWithName("StateRefund", StateRefund, helpers.NewForkMatrix(helpers.Isthmus, helpers.Jovian), runJovianDerivationTest) + matrix.AddDefaultTestCasesWithName("NotEnoughFundsInBatchMissingOpFee", NotEnoughFundsInBatchMissingOpFee, helpers.NewForkMatrix(helpers.Holocene, helpers.Isthmus, helpers.Jovian), runJovianDerivationTest) + matrix.AddDefaultTestCasesWithName("IsthmusTransitionBlock", IsthmusTransitionBlock, helpers.NewForkMatrix(helpers.Holocene), runJovianDerivationTest) matrix.Run(gt) } diff --git a/op-e2e/bindings/gaspriceoracle.go b/op-e2e/bindings/gaspriceoracle.go index c50bf674be9..0e0ba67a4c8 100644 --- a/op-e2e/bindings/gaspriceoracle.go +++ b/op-e2e/bindings/gaspriceoracle.go @@ -26,12 +26,13 @@ var ( _ = common.Big1 _ = types.BloomLookup _ = event.NewSubscription + _ = abi.ConvertType ) // GasPriceOracleMetaData contains all meta data concerning the GasPriceOracle contract. var GasPriceOracleMetaData = &bind.MetaData{ - ABI: "[{\"inputs\":[],\"name\":\"DECIMALS\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"baseFee\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"baseFeeScalar\",\"outputs\":[{\"internalType\":\"uint32\",\"name\":\"\",\"type\":\"uint32\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"blobBaseFee\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"blobBaseFeeScalar\",\"outputs\":[{\"internalType\":\"uint32\",\"name\":\"\",\"type\":\"uint32\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"decimals\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"gasPrice\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes\",\"name\":\"_data\",\"type\":\"bytes\"}],\"name\":\"getL1Fee\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"_unsignedTxSize\",\"type\":\"uint256\"}],\"name\":\"getL1FeeUpperBound\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes\",\"name\":\"_data\",\"type\":\"bytes\"}],\"name\":\"getL1GasUsed\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"_gasUsed\",\"type\":\"uint256\"}],\"name\":\"getOperatorFee\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"isEcotone\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"isFjord\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"isIsthmus\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"l1BaseFee\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"overhead\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"scalar\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"setEcotone\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"setFjord\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"setIsthmus\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"version\",\"outputs\":[{\"internalType\":\"string\",\"name\":\"\",\"type\":\"string\"}],\"stateMutability\":\"view\",\"type\":\"function\"}]", - Bin: "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", + ABI: "[{\"type\":\"function\",\"name\":\"DECIMALS\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"baseFee\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"baseFeeScalar\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"uint32\",\"internalType\":\"uint32\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"blobBaseFee\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"blobBaseFeeScalar\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"uint32\",\"internalType\":\"uint32\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"decimals\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"stateMutability\":\"pure\"},{\"type\":\"function\",\"name\":\"gasPrice\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"getL1Fee\",\"inputs\":[{\"name\":\"_data\",\"type\":\"bytes\",\"internalType\":\"bytes\"}],\"outputs\":[{\"name\":\"\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"getL1FeeUpperBound\",\"inputs\":[{\"name\":\"_unsignedTxSize\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"outputs\":[{\"name\":\"\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"getL1GasUsed\",\"inputs\":[{\"name\":\"_data\",\"type\":\"bytes\",\"internalType\":\"bytes\"}],\"outputs\":[{\"name\":\"\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"getOperatorFee\",\"inputs\":[{\"name\":\"_gasUsed\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"outputs\":[{\"name\":\"\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"isEcotone\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"bool\",\"internalType\":\"bool\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"isFjord\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"bool\",\"internalType\":\"bool\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"isIsthmus\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"bool\",\"internalType\":\"bool\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"isJovian\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"bool\",\"internalType\":\"bool\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"l1BaseFee\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"overhead\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"scalar\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"setEcotone\",\"inputs\":[],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"setFjord\",\"inputs\":[],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"setIsthmus\",\"inputs\":[],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"setJovian\",\"inputs\":[],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"version\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"string\",\"internalType\":\"string\"}],\"stateMutability\":\"view\"}]", + Bin: "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", } // GasPriceOracleABI is the input ABI used to generate the binding from. @@ -156,11 +157,11 @@ func NewGasPriceOracleFilterer(address common.Address, filterer bind.ContractFil // bindGasPriceOracle binds a generic wrapper to an already deployed contract. func bindGasPriceOracle(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor, filterer bind.ContractFilterer) (*bind.BoundContract, error) { - parsed, err := abi.JSON(strings.NewReader(GasPriceOracleABI)) + parsed, err := GasPriceOracleMetaData.GetAbi() if err != nil { return nil, err } - return bind.NewBoundContract(address, parsed, caller, transactor, filterer), nil + return bind.NewBoundContract(address, *parsed, caller, transactor, filterer), nil } // Call invokes the (constant) contract method with params as input values and @@ -635,6 +636,37 @@ func (_GasPriceOracle *GasPriceOracleCallerSession) IsIsthmus() (bool, error) { return _GasPriceOracle.Contract.IsIsthmus(&_GasPriceOracle.CallOpts) } +// IsJovian is a free data retrieval call binding the contract method 0x105d0b81. +// +// Solidity: function isJovian() view returns(bool) +func (_GasPriceOracle *GasPriceOracleCaller) IsJovian(opts *bind.CallOpts) (bool, error) { + var out []interface{} + err := _GasPriceOracle.contract.Call(opts, &out, "isJovian") + + if err != nil { + return *new(bool), err + } + + out0 := *abi.ConvertType(out[0], new(bool)).(*bool) + + return out0, err + +} + +// IsJovian is a free data retrieval call binding the contract method 0x105d0b81. +// +// Solidity: function isJovian() view returns(bool) +func (_GasPriceOracle *GasPriceOracleSession) IsJovian() (bool, error) { + return _GasPriceOracle.Contract.IsJovian(&_GasPriceOracle.CallOpts) +} + +// IsJovian is a free data retrieval call binding the contract method 0x105d0b81. +// +// Solidity: function isJovian() view returns(bool) +func (_GasPriceOracle *GasPriceOracleCallerSession) IsJovian() (bool, error) { + return _GasPriceOracle.Contract.IsJovian(&_GasPriceOracle.CallOpts) +} + // L1BaseFee is a free data retrieval call binding the contract method 0x519b4bd3. // // Solidity: function l1BaseFee() view returns(uint256) @@ -821,3 +853,24 @@ func (_GasPriceOracle *GasPriceOracleSession) SetIsthmus() (*types.Transaction, func (_GasPriceOracle *GasPriceOracleTransactorSession) SetIsthmus() (*types.Transaction, error) { return _GasPriceOracle.Contract.SetIsthmus(&_GasPriceOracle.TransactOpts) } + +// SetJovian is a paid mutator transaction binding the contract method 0xb3d72079. +// +// Solidity: function setJovian() returns() +func (_GasPriceOracle *GasPriceOracleTransactor) SetJovian(opts *bind.TransactOpts) (*types.Transaction, error) { + return _GasPriceOracle.contract.Transact(opts, "setJovian") +} + +// SetJovian is a paid mutator transaction binding the contract method 0xb3d72079. +// +// Solidity: function setJovian() returns() +func (_GasPriceOracle *GasPriceOracleSession) SetJovian() (*types.Transaction, error) { + return _GasPriceOracle.Contract.SetJovian(&_GasPriceOracle.TransactOpts) +} + +// SetJovian is a paid mutator transaction binding the contract method 0xb3d72079. +// +// Solidity: function setJovian() returns() +func (_GasPriceOracle *GasPriceOracleTransactorSession) SetJovian() (*types.Transaction, error) { + return _GasPriceOracle.Contract.SetJovian(&_GasPriceOracle.TransactOpts) +} diff --git a/op-e2e/system/e2esys/setup.go b/op-e2e/system/e2esys/setup.go index 68fbc23c0c1..0843fdf4ca3 100644 --- a/op-e2e/system/e2esys/setup.go +++ b/op-e2e/system/e2esys/setup.go @@ -617,9 +617,6 @@ func (cfg SystemConfig) Start(t *testing.T, startOpts ...StartOption) (*System, c = sys.TimeTravelClock } - // sanity-check the deploy config - require.Nil(t, cfg.DeployConfig.L2GenesisJovianTimeOffset, "Jovian is not supported in op-e2e tests yet") - if err := cfg.DeployConfig.Check(testlog.Logger(t, log.LevelInfo)); err != nil { return nil, err } diff --git a/op-e2e/system/fees/fees_test.go b/op-e2e/system/fees/fees_test.go index 80f5febc19e..c3a243fe48b 100644 --- a/op-e2e/system/fees/fees_test.go +++ b/op-e2e/system/fees/fees_test.go @@ -91,6 +91,16 @@ func TestFees(t *testing.T) { testFees(t, cfg) }) + + t.Run("jovian", func(t *testing.T) { + op_e2e.InitParallel(t) + cfg := e2esys.JovianSystemConfig(t, new(hexutil.Uint64)) + cfg.DeployConfig.L1GenesisBlockBaseFeePerGas = (*hexutil.Big)(big.NewInt(7)) + cfg.DeployConfig.GasPriceOracleOperatorFeeScalar = 1439103868 + cfg.DeployConfig.GasPriceOracleOperatorFeeConstant = 12564178266093314607 + + testFees(t, cfg) + }) } func testFees(t *testing.T, cfg e2esys.SystemConfig) { @@ -244,6 +254,10 @@ func testFees(t *testing.T, cfg e2esys.SystemConfig) { require.NoError(t, err) require.Equal(t, sys.RollupConfig.IsIsthmus(header.Time), gpoIsthmus, "GPO and chain must have same isthmus view") + gpoJovian, err := gpoContract.IsJovian(nil) + require.NoError(t, err) + require.Equal(t, sys.RollupConfig.IsJovian(header.Time), gpoJovian, "GPO and chain must have same jovian view") + gpoL1Fee, err := gpoContract.GetL1Fee(&bind.CallOpts{}, bytes) require.Nil(t, err) @@ -277,18 +291,26 @@ func testFees(t *testing.T, cfg e2esys.SystemConfig) { new(big.Float).SetInt(receipt.L1Fee), "fee field in receipt matches gas used times scalar times base fee") } - expectedOperatorFee := new(big.Int).Add( - new(big.Int).Div( - new(big.Int).Mul( - gasUsed, - new(big.Int).SetUint64(uint64(cfg.DeployConfig.GasPriceOracleOperatorFeeScalar)), - ), - new(big.Int).SetUint64(uint64(1e6)), - ), - new(big.Int).SetUint64(cfg.DeployConfig.GasPriceOracleOperatorFeeConstant), - ) - if sys.RollupConfig.IsIsthmus(header.Time) { + baseOperatorFee := new(big.Int).Mul( + gasUsed, + new(big.Int).SetUint64(uint64(cfg.DeployConfig.GasPriceOracleOperatorFeeScalar)), + ) + + scaledOperatorFee := new(big.Int) + if sys.RollupConfig.IsJovian(header.Time) { + // For Jovian, multiply by 100. + scaledOperatorFee.Mul(baseOperatorFee, new(big.Int).SetUint64(uint64(100))) + } else { + // For Isthmus, divide by 1e6. + scaledOperatorFee.Div(baseOperatorFee, new(big.Int).SetUint64(uint64(1e6))) + } + + expectedOperatorFee := new(big.Int).Add( + scaledOperatorFee, + new(big.Int).SetUint64(cfg.DeployConfig.GasPriceOracleOperatorFeeConstant), + ) + require.True(t, expectedOperatorFee.Cmp(operatorFee.ToBig()) == 0, "operator fee is correct", ) diff --git a/op-node/rollup/derive/attributes.go b/op-node/rollup/derive/attributes.go index 7d9fedef07a..59f6d2dbb2f 100644 --- a/op-node/rollup/derive/attributes.go +++ b/op-node/rollup/derive/attributes.go @@ -145,8 +145,8 @@ func (ba *FetchingAttributesBuilder) PreparePayloadAttributes(ctx context.Contex upgradeTxs = append(upgradeTxs, isthmus...) } - if ba.rollupCfg.IsJovianActivationBlock(nextL2Time) && ba.rollupCfg.IsDAFootprintBlockLimit(nextL2Time) { - jovian, err := DAFootprintNetworkUpgradeTransactions() + if ba.rollupCfg.IsJovianActivationBlock(nextL2Time) { + jovian, err := JovianNetworkUpgradeTransactions(ba.rollupCfg.IsDAFootprintBlockLimit(nextL2Time), ba.rollupCfg.IsOperatorFeeFix(nextL2Time)) if err != nil { return nil, NewCriticalError(fmt.Errorf("failed to build jovian network upgrade txs: %w", err)) } diff --git a/op-node/rollup/derive/jovian_upgrade_transactions.go b/op-node/rollup/derive/jovian_upgrade_transactions.go index 564b8ea7f70..5adc79f0cd9 100644 --- a/op-node/rollup/derive/jovian_upgrade_transactions.go +++ b/op-node/rollup/derive/jovian_upgrade_transactions.go @@ -18,8 +18,22 @@ var ( L1BlockJovianDeployerAddress = common.HexToAddress("0x4210000000000000000000000000000000000006") jovianL1BlockAddress = crypto.CreateAddress(L1BlockJovianDeployerAddress, 0) - // Bytecode generated from commit 41614ab527df1cf74f9820f60d8f588ade769679 - l1BlockJovianDeploymentBytecode = common.FromHex("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") + // Bytecode generated from commit b3299e0ddb55442e6496512084d16c439ea2da77 + l1BlockJovianDeploymentBytecode = common.FromHex("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") + + // Gas Price Oracle Parameters + deployJovianGasPriceOracleSource = UpgradeDepositSource{Intent: "Jovian: Gas Price Oracle Deployment"} + updateJovianGasPriceOracleSource = UpgradeDepositSource{Intent: "Jovian: Gas Price Oracle Proxy Update"} + GasPriceOracleJovianDeployerAddress = common.HexToAddress("0x4210000000000000000000000000000000000007") + jovianGasPriceOracleAddress = crypto.CreateAddress(GasPriceOracleJovianDeployerAddress, 0) + + // Bytecodes + // GPO from commit b3299e0ddb55442e6496512084d16c439ea2da77 + gasPriceOracleJovianDeploymentBytecode = common.FromHex("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") + + // Enable Jovian Parameters + enableJovianSource = UpgradeDepositSource{Intent: "Jovian: Gas Price Oracle Set Jovian"} + enableJovianInput = crypto.Keccak256([]byte("setJovian()"))[:4] ) func DAFootprintNetworkUpgradeTransactions() ([]hexutil.Bytes, error) { @@ -29,7 +43,7 @@ func DAFootprintNetworkUpgradeTransactions() ([]hexutil.Bytes, error) { To: nil, Mint: big.NewInt(0), Value: big.NewInt(0), - Gas: 450_371, + Gas: 447_315, IsSystemTransaction: false, Data: l1BlockJovianDeploymentBytecode, }).MarshalBinary() @@ -53,3 +67,85 @@ func DAFootprintNetworkUpgradeTransactions() ([]hexutil.Bytes, error) { return []hexutil.Bytes{deployL1Block, updateL1BlockProxy}, nil } + +func OperatorFeeFixUpgradeTransactions() ([]hexutil.Bytes, error) { + upgradeTxns := make([]hexutil.Bytes, 0, 8) + + // Deploy Gas Price Oracle transaction + deployGasPriceOracle, err := types.NewTx(&types.DepositTx{ + SourceHash: deployJovianGasPriceOracleSource.SourceHash(), + From: GasPriceOracleJovianDeployerAddress, + To: nil, + Mint: big.NewInt(0), + Value: big.NewInt(0), + Gas: 1_625_000, + IsSystemTransaction: false, + Data: gasPriceOracleJovianDeploymentBytecode, + }).MarshalBinary() + + if err != nil { + return nil, err + } + + upgradeTxns = append(upgradeTxns, deployGasPriceOracle) + + // Deploy Gas Price Oracle Proxy upgrade transaction + updateGasPriceOracleProxy, err := types.NewTx(&types.DepositTx{ + SourceHash: updateJovianGasPriceOracleSource.SourceHash(), + From: common.Address{}, + To: &predeploys.GasPriceOracleAddr, + Mint: big.NewInt(0), + Value: big.NewInt(0), + Gas: 50_000, + IsSystemTransaction: false, + Data: upgradeToCalldata(jovianGasPriceOracleAddress), + }).MarshalBinary() + + if err != nil { + return nil, err + } + + upgradeTxns = append(upgradeTxns, updateGasPriceOracleProxy) + + // Enable Jovian transaction + enableJovian, err := types.NewTx(&types.DepositTx{ + SourceHash: enableJovianSource.SourceHash(), + From: L1InfoDepositerAddress, + To: &predeploys.GasPriceOracleAddr, + Mint: big.NewInt(0), + Value: big.NewInt(0), + Gas: 90_000, + IsSystemTransaction: false, + Data: enableJovianInput, + }).MarshalBinary() + + if err != nil { + return nil, err + } + + upgradeTxns = append(upgradeTxns, enableJovian) + + return upgradeTxns, nil +} + +func JovianNetworkUpgradeTransactions(IsDAFootprintBlockLimit, IsOperatorFeeFix bool) ([]hexutil.Bytes, error) { + upgradeTxs := make([]hexutil.Bytes, 0) + + if IsDAFootprintBlockLimit { + txs, err := DAFootprintNetworkUpgradeTransactions() + if err != nil { + return nil, err + } + upgradeTxs = append(upgradeTxs, txs...) + } + + if IsOperatorFeeFix { + txs, err := OperatorFeeFixUpgradeTransactions() + if err != nil { + return nil, err + } + upgradeTxs = append(upgradeTxs, txs...) + } + + return upgradeTxs, nil +} diff --git a/op-node/rollup/derive/jovian_upgrade_transactions_test.go b/op-node/rollup/derive/jovian_upgrade_transactions_test.go new file mode 100644 index 00000000000..b9f73ee804a --- /dev/null +++ b/op-node/rollup/derive/jovian_upgrade_transactions_test.go @@ -0,0 +1,53 @@ +package derive + +import ( + "testing" + + "github.com/ethereum/go-ethereum/common" + "github.com/ethereum/go-ethereum/common/hexutil" + "github.com/stretchr/testify/require" +) + +func TestJovianNetworkTransactions(t *testing.T) { + upgradeTxns, err := JovianNetworkUpgradeTransactions(true, true) + require.NoError(t, err) + require.Len(t, upgradeTxns, 5) + + deployL1BlockSender, deployL1Block := toDepositTxn(t, upgradeTxns[0]) + require.Equal(t, deployL1BlockSender, common.HexToAddress("0x4210000000000000000000000000000000000006")) + require.Equal(t, deployJovianL1BlockSource.SourceHash(), deployL1Block.SourceHash()) + require.Nil(t, deployL1Block.To()) + require.Equal(t, uint64(447_315), deployL1Block.Gas()) + require.Equal(t, l1BlockJovianDeploymentBytecode, deployL1Block.Data()) + + updateL1BlockProxySender, updateL1BlockProxy := toDepositTxn(t, upgradeTxns[1]) + require.Equal(t, updateL1BlockProxySender, common.Address{}) + require.Equal(t, updateJovianL1BlockProxySource.SourceHash(), updateL1BlockProxy.SourceHash()) + require.NotNil(t, updateL1BlockProxy.To()) + require.Equal(t, *updateL1BlockProxy.To(), common.HexToAddress("0x4200000000000000000000000000000000000015")) + require.Equal(t, uint64(50_000), updateL1BlockProxy.Gas()) + require.Equal(t, "0x3659cfe60000000000000000000000003ba4007f5c922fbb33c454b41ea7a1f11e83df2c", hexutil.Encode(updateL1BlockProxy.Data())) + + deployGasPriceOracleSender, deployGasPriceOracle := toDepositTxn(t, upgradeTxns[2]) + require.Equal(t, deployGasPriceOracleSender, common.HexToAddress("0x4210000000000000000000000000000000000007")) + require.Equal(t, deployJovianGasPriceOracleSource.SourceHash(), deployGasPriceOracle.SourceHash()) + require.Nil(t, deployGasPriceOracle.To()) + require.Equal(t, uint64(1_625_000), deployGasPriceOracle.Gas()) + require.Equal(t, gasPriceOracleJovianDeploymentBytecode, deployGasPriceOracle.Data()) + + updateGasPriceOracleSender, updateGasPriceOracle := toDepositTxn(t, upgradeTxns[3]) + require.Equal(t, updateGasPriceOracleSender, common.Address{}) + require.Equal(t, updateJovianGasPriceOracleSource.SourceHash(), updateGasPriceOracle.SourceHash()) + require.NotNil(t, updateGasPriceOracle.To()) + require.Equal(t, *updateGasPriceOracle.To(), common.HexToAddress("0x420000000000000000000000000000000000000F")) + require.Equal(t, uint64(50_000), updateGasPriceOracle.Gas()) + require.Equal(t, "0x3659cfe60000000000000000000000004f1db3c6abd250ba86e0928471a8f7db3afd88f1", hexutil.Encode(updateGasPriceOracle.Data())) + + gpoSetJovianSender, gpoSetJovian := toDepositTxn(t, upgradeTxns[4]) + require.Equal(t, gpoSetJovianSender, common.HexToAddress("0xDeaDDEaDDeAdDeAdDEAdDEaddeAddEAdDEAd0001")) + require.Equal(t, enableJovianSource.SourceHash(), gpoSetJovian.SourceHash()) + require.NotNil(t, gpoSetJovian.To()) + require.Equal(t, *gpoSetJovian.To(), common.HexToAddress("0x420000000000000000000000000000000000000F")) + require.Equal(t, uint64(90_000), gpoSetJovian.Gas()) + require.Equal(t, "0xb3d72079", hexutil.Encode(gpoSetJovian.Data())) +} diff --git a/op-node/rollup/derive/l1_block_info.go b/op-node/rollup/derive/l1_block_info.go index 25d79b1668c..33d19dfd485 100644 --- a/op-node/rollup/derive/l1_block_info.go +++ b/op-node/rollup/derive/l1_block_info.go @@ -448,7 +448,7 @@ func isIsthmusButNotFirstBlock(rollupCfg *rollup.Config, l2Timestamp uint64) boo // isJovianButNotFirstBlock returns whether the specified block is subject to the Jovian upgrade, // but is not the activation block itself. func isJovianButNotFirstBlock(rollupCfg *rollup.Config, l2Timestamp uint64) bool { - return rollupCfg.IsDAFootprintBlockLimit(l2Timestamp) && !rollupCfg.IsJovianActivationBlock(l2Timestamp) + return rollupCfg.IsJovian(l2Timestamp) && !rollupCfg.IsJovianActivationBlock(l2Timestamp) } // L1BlockInfoFromBytes is the inverse of L1InfoDeposit, to see where the L2 chain is derived from diff --git a/op-node/rollup/sequencing/sequencer.go b/op-node/rollup/sequencing/sequencer.go index ca323110947..c536c5bc8b2 100644 --- a/op-node/rollup/sequencing/sequencer.go +++ b/op-node/rollup/sequencing/sequencer.go @@ -571,6 +571,12 @@ func (d *Sequencer) startBuildingBlock() { d.log.Info("Sequencing Isthmus upgrade block") } + // For the Jovian activation block we must not include any sequencer transactions. + if d.rollupCfg.IsJovianActivationBlock(uint64(attrs.Timestamp)) { + attrs.NoTxPool = true + d.log.Info("Sequencing Jovian upgrade block") + } + // For the Interop activation block we must not include any sequencer transactions. if d.rollupCfg.IsInteropActivationBlock(uint64(attrs.Timestamp)) { attrs.NoTxPool = true diff --git a/op-service/txinclude/txbudget.go b/op-service/txinclude/txbudget.go index 50f11900fbc..4582b90853a 100644 --- a/op-service/txinclude/txbudget.go +++ b/op-service/txinclude/txbudget.go @@ -96,7 +96,9 @@ func (b *TxBudget) AfterIncluded(budgetedCost eth.ETH, tx *IncludedTx) { // operatorCost if receipt.OperatorFeeScalar != nil { // https://github.com/ethereum-optimism/op-geth/blob/6005dd53e1b50fe5a3f59764e3e2056a639eff2f/core/types/rollup_cost.go#L244-L247 - // Also see: https://specs.optimism.io/protocol/isthmus/exec-engine.html#operator-operatorCost + // Also see: https://specs.optimism.io/protocol/isthmus/exec-engine.html#operator-fee + // TODO(17817): This currently uses the Isthmus formula (divide by 1e6). Need to update to handle both + // Isthmus and Jovian formulas based on fork activation. Jovian formula multiplies by 100 instead. operatorCost := new(big.Int).SetUint64(receipt.GasUsed) operatorCost.Mul(operatorCost, new(big.Int).SetUint64(*receipt.OperatorFeeScalar)) operatorCost = operatorCost.Div(operatorCost, oneMillion) diff --git a/op-service/txintent/bindings/GasPriceOracle.go b/op-service/txintent/bindings/GasPriceOracle.go index 8f08620451b..a2ca8745164 100644 --- a/op-service/txintent/bindings/GasPriceOracle.go +++ b/op-service/txintent/bindings/GasPriceOracle.go @@ -13,6 +13,8 @@ type GasPriceOracle struct { L1BaseFee func() TypedCall[*eth.ETH] `sol:"l1BaseFee"` BlobBaseFee func() TypedCall[*eth.ETH] `sol:"blobBaseFee"` IsFjord func() TypedCall[bool] `sol:"isFjord"` + IsIsthmus func() TypedCall[bool] `sol:"isIsthmus"` + IsJovian func() TypedCall[bool] `sol:"isJovian"` GetL1Fee func(data []byte) TypedCall[eth.ETH] `sol:"getL1Fee"` GetL1GasUsed func(data []byte) TypedCall[uint64] `sol:"getL1GasUsed"` GetL1FeeUpperBound func(unsignedTxSize *big.Int) TypedCall[eth.ETH] `sol:"getL1FeeUpperBound"` diff --git a/packages/contracts-bedrock/interfaces/L2/IGasPriceOracle.sol b/packages/contracts-bedrock/interfaces/L2/IGasPriceOracle.sol index 8e1b4255a07..4112af3fc8b 100644 --- a/packages/contracts-bedrock/interfaces/L2/IGasPriceOracle.sol +++ b/packages/contracts-bedrock/interfaces/L2/IGasPriceOracle.sol @@ -16,12 +16,14 @@ interface IGasPriceOracle { function isEcotone() external view returns (bool); function isFjord() external view returns (bool); function isIsthmus() external view returns (bool); + function isJovian() external view returns (bool); function l1BaseFee() external view returns (uint256); function overhead() external view returns (uint256); function scalar() external view returns (uint256); function setEcotone() external; function setFjord() external; function setIsthmus() external; + function setJovian() external; function version() external view returns (string memory); function __constructor__() external; diff --git a/packages/contracts-bedrock/scripts/L2Genesis.s.sol b/packages/contracts-bedrock/scripts/L2Genesis.s.sol index de75c6b99cf..5708dfe33c7 100644 --- a/packages/contracts-bedrock/scripts/L2Genesis.s.sol +++ b/packages/contracts-bedrock/scripts/L2Genesis.s.sol @@ -154,11 +154,13 @@ contract L2Genesis is Script { return; } - if (forkEquals(_fork, Fork.INTEROP)) { + activateJovian(); + + if (forkEquals(_fork, Fork.JOVIAN)) { return; } - if (forkEquals(_fork, Fork.JOVIAN)) { + if (forkEquals(_fork, Fork.INTEROP)) { return; } } @@ -571,6 +573,11 @@ contract L2Genesis is Script { IGasPriceOracle(Predeploys.GAS_PRICE_ORACLE).setIsthmus(); } + function activateJovian() internal { + vm.prank(IL1Block(Predeploys.L1_BLOCK_ATTRIBUTES).DEPOSITOR_ACCOUNT()); + IGasPriceOracle(Predeploys.GAS_PRICE_ORACLE).setJovian(); + } + /// @notice Sets the bytecode in state function _setImplementationCode(address _addr) internal returns (address) { string memory cname = Predeploys.getName(_addr); diff --git a/packages/contracts-bedrock/snapshots/abi/GasPriceOracle.json b/packages/contracts-bedrock/snapshots/abi/GasPriceOracle.json index 36efa6c5768..26d8dcd1834 100644 --- a/packages/contracts-bedrock/snapshots/abi/GasPriceOracle.json +++ b/packages/contracts-bedrock/snapshots/abi/GasPriceOracle.json @@ -205,6 +205,19 @@ "stateMutability": "view", "type": "function" }, + { + "inputs": [], + "name": "isJovian", + "outputs": [ + { + "internalType": "bool", + "name": "", + "type": "bool" + } + ], + "stateMutability": "view", + "type": "function" + }, { "inputs": [], "name": "l1BaseFee", @@ -265,6 +278,13 @@ "stateMutability": "nonpayable", "type": "function" }, + { + "inputs": [], + "name": "setJovian", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, { "inputs": [], "name": "version", diff --git a/packages/contracts-bedrock/snapshots/semver-lock.json b/packages/contracts-bedrock/snapshots/semver-lock.json index caa8ace5ae4..c7a4462d581 100644 --- a/packages/contracts-bedrock/snapshots/semver-lock.json +++ b/packages/contracts-bedrock/snapshots/semver-lock.json @@ -60,8 +60,8 @@ "sourceCodeHash": "0x6d137fef431d75a8bf818444915fc39c8b1d93434a9af9971d96fb3170bc72b7" }, "src/L2/GasPriceOracle.sol:GasPriceOracle": { - "initCodeHash": "0x38ef70b2783dd45ad807afcf57972c7df4abaaeb5d16d17cdb451b9e931a9cbb", - "sourceCodeHash": "0x4351fe2ac1106c8c220b8cfe7839bc107c24d8084deb21259ac954f5a362725d" + "initCodeHash": "0xedc721584d43025c515186d4d5879d2b8e4abaf3a69181b99b6bf90c684df442", + "sourceCodeHash": "0x0074761fc0f893a2418b4e1197c7f29ee59f407df31b99c420bf2fd82d14d583" }, "src/L2/L1Block.sol:L1Block": { "initCodeHash": "0x1f054ff228ecad7f51772dd25084469192f7a33c522b87cd46ec5558d3c46aec", diff --git a/packages/contracts-bedrock/snapshots/storageLayout/GasPriceOracle.json b/packages/contracts-bedrock/snapshots/storageLayout/GasPriceOracle.json index 8e4127173dc..c1eed282c46 100644 --- a/packages/contracts-bedrock/snapshots/storageLayout/GasPriceOracle.json +++ b/packages/contracts-bedrock/snapshots/storageLayout/GasPriceOracle.json @@ -19,5 +19,12 @@ "offset": 2, "slot": "0", "type": "bool" + }, + { + "bytes": "1", + "label": "isJovian", + "offset": 3, + "slot": "0", + "type": "bool" } ] \ No newline at end of file diff --git a/packages/contracts-bedrock/src/L2/GasPriceOracle.sol b/packages/contracts-bedrock/src/L2/GasPriceOracle.sol index 5af0b0e9de0..75814f65cd9 100644 --- a/packages/contracts-bedrock/src/L2/GasPriceOracle.sol +++ b/packages/contracts-bedrock/src/L2/GasPriceOracle.sol @@ -30,8 +30,8 @@ contract GasPriceOracle is ISemver { uint256 public constant DECIMALS = 6; /// @notice Semantic version. - /// @custom:semver 1.4.0 - string public constant version = "1.4.0"; + /// @custom:semver 1.5.0 + string public constant version = "1.5.0"; /// @notice This is the intercept value for the linear regression used to estimate the final size of the /// compressed transaction. @@ -54,6 +54,9 @@ contract GasPriceOracle is ISemver { /// @notice Indicates whether the network has gone through the Isthmus upgrade. bool public isIsthmus; + /// @notice Indicates whether the network has gone through the Jovian upgrade. + bool public isJovian; + /// @notice Computes the L1 portion of the fee based on the size of the rlp encoded input /// transaction, the current L1 base fee, and the various dynamic parameters. /// @param _data Unsigned fully RLP-encoded transaction to get the L1 fee for. @@ -115,6 +118,17 @@ contract GasPriceOracle is ISemver { isIsthmus = true; } + /// @notice Set chain to be Jovian chain (callable by depositor account) + function setJovian() external { + require( + msg.sender == Constants.DEPOSITOR_ACCOUNT, + "GasPriceOracle: only the depositor account can set isJovian flag" + ); + require(isIsthmus, "GasPriceOracle: Jovian can only be activated after Isthmus"); + require(isJovian == false, "GasPriceOracle: Jovian already active"); + isJovian = true; + } + /// @notice Retrieves the current gas price (base fee). /// @return Current L2 gas price (base fee). function gasPrice() public view returns (uint256) { @@ -194,15 +208,26 @@ contract GasPriceOracle is ISemver { return l1GasUsed + IL1Block(Predeploys.L1_BLOCK_ATTRIBUTES).l1FeeOverhead(); } + /// @notice Calculates the operator fee for a given gas usage. + /// @dev Formula varies based on fork activation: + /// - Pre-Isthmus: Returns 0 (no operator fee) + /// - Isthmus (pre-Jovian): operatorFee = (gasUsed * operatorFeeScalar / 1e6) + operatorFeeConstant + /// - Jovian and after: operatorFee = (gasUsed * operatorFeeScalar * 100) + operatorFeeConstant + /// @param _gasUsed The amount of gas used by the transaction + /// @return The calculated operator fee function getOperatorFee(uint256 _gasUsed) public view returns (uint256) { if (!isIsthmus) { return 0; } - return Arithmetic.saturatingAdd( - Arithmetic.saturatingMul(_gasUsed, IL1Block(Predeploys.L1_BLOCK_ATTRIBUTES).operatorFeeScalar()) / 1e6, - IL1Block(Predeploys.L1_BLOCK_ATTRIBUTES).operatorFeeConstant() - ); + uint256 operatorScalar = IL1Block(Predeploys.L1_BLOCK_ATTRIBUTES).operatorFeeScalar(); + uint256 operatorConstant = IL1Block(Predeploys.L1_BLOCK_ATTRIBUTES).operatorFeeConstant(); + + if (isJovian) { + return Arithmetic.saturatingAdd(Arithmetic.saturatingMul(_gasUsed, operatorScalar) * 100, operatorConstant); + } else { + return Arithmetic.saturatingAdd(Arithmetic.saturatingMul(_gasUsed, operatorScalar) / 1e6, operatorConstant); + } } /// @notice Computation of the L1 portion of the fee for Bedrock. diff --git a/packages/contracts-bedrock/test/L2/GasPriceOracle.t.sol b/packages/contracts-bedrock/test/L2/GasPriceOracle.t.sol index 95053e369da..11b9918c9cf 100644 --- a/packages/contracts-bedrock/test/L2/GasPriceOracle.t.sol +++ b/packages/contracts-bedrock/test/L2/GasPriceOracle.t.sol @@ -116,6 +116,13 @@ contract GasPriceOracleBedrock_Test is GasPriceOracle_Test { gasPriceOracle.setFjord(); } + /// @dev Tests that Jovian activation requires Isthmus to be active first. + function test_setJovian_requiresIsthmus_reverts() external { + vm.prank(depositor); + vm.expectRevert("GasPriceOracle: Jovian can only be activated after Isthmus"); + gasPriceOracle.setJovian(); + } + /// @dev Tests that `getL1Fee` returns the expected value when both fjord and ecotone are not active function test_getL1Fee_whenFjordAndEcotoneNotActive_succeeds() external { vm.store(address(gasPriceOracle), bytes32(uint256(0)), bytes32(0)); @@ -382,7 +389,7 @@ contract GasPriceOracleIsthmus_Test is GasPriceOracle_Test { require(success, "GasPriceOracleIsthmus_Test: Function call failed"); } - /// @dev Tests that `operatorFee` is set correctly. + /// @dev Tests that `operatorFee` is set correctly using the Isthmus formula (divide by 1e6). function test_getOperatorFee_succeeds() external view { assertEq(gasPriceOracle.getOperatorFee(10), 10 * operatorFeeScalar / 1e6 + operatorFeeConstant); } @@ -392,4 +399,88 @@ contract GasPriceOracleIsthmus_Test is GasPriceOracle_Test { vm.expectRevert("GasPriceOracle: only the depositor account can set isIsthmus flag"); gasPriceOracle.setIsthmus(); } + + /// @dev Tests that Jovian cannot be activated yet (since it's not activated by default). + function test_setJovian_notActivated_succeeds() external { + assertEq(gasPriceOracle.isJovian(), false); + + // Activate Jovian + vm.prank(depositor); + gasPriceOracle.setJovian(); + + assertEq(gasPriceOracle.isJovian(), true); + } +} + +contract GasPriceOracleJovian_Test is GasPriceOracle_Test { + /// @dev Sets up the test suite with Isthmus parameters configured. + function setUp() public virtual override { + l2Fork = Fork.ISTHMUS; + super.setUp(); + + // Configure Isthmus state on the L1 block. + bytes memory calldataPacked = Encoding.encodeSetL1BlockValuesIsthmus( + baseFeeScalar, + blobBaseFeeScalar, + sequenceNumber, + timestamp, + number, + baseFee, + blobBaseFee, + hash, + batcherHash, + operatorFeeScalar, + operatorFeeConstant + ); + + vm.prank(depositor); + (bool success,) = address(l1Block).call(calldataPacked); + require(success, "GasPriceOracleJovian_Test: L1Block setup failed"); + + assertEq(gasPriceOracle.isIsthmus(), true, "Isthmus should be active before enabling Jovian"); + assertEq(gasPriceOracle.isJovian(), false, "Jovian starts active"); + } + + function _activateJovian() internal { + vm.prank(depositor); + gasPriceOracle.setJovian(); + assertEq(gasPriceOracle.isJovian(), true, "Jovian activation failed"); + } + + /// @dev Tests that `operatorFee` is set correctly using the new Jovian formula (multiply by 100). + function test_getOperatorFee_succeeds() external { + _activateJovian(); + assertEq(gasPriceOracle.getOperatorFee(10), 10 * operatorFeeScalar * 100 + operatorFeeConstant); + } + + /// @dev Tests that `setJovian` is only callable by the depositor. + function test_setJovian_wrongCaller_reverts() external { + vm.expectRevert("GasPriceOracle: only the depositor account can set isJovian flag"); + gasPriceOracle.setJovian(); + } + + /// @dev Tests that `setJovian` cannot be activated twice. + function test_setJovian_alreadyActive_reverts() external { + _activateJovian(); + vm.prank(depositor); + vm.expectRevert("GasPriceOracle: Jovian already active"); + gasPriceOracle.setJovian(); + } + + /// @dev Tests the transition from Isthmus formula to Jovian formula. + function test_formulaTransition_succeeds() external { + // Check Isthmus formula (divide by 1e6) + uint256 isthmusFee = gasPriceOracle.getOperatorFee(10); + assertEq(isthmusFee, 10 * operatorFeeScalar / 1e6 + operatorFeeConstant); + + // Activate Jovian + _activateJovian(); + + // Check Jovian formula (multiply by 100) + uint256 jovianFee = gasPriceOracle.getOperatorFee(10); + assertEq(jovianFee, 10 * operatorFeeScalar * 100 + operatorFeeConstant); + + // Verify the fee increased significantly + assertGt(jovianFee, isthmusFee); + } } From c3bc858146b4332624bcd7708cf34c76df8fc560 Mon Sep 17 00:00:00 2001 From: Changwan Park Date: Fri, 17 Oct 2025 00:18:17 +0900 Subject: [PATCH 071/117] op-acceptance-tests: Reorg then gap filling tests (#17893) * op-devstack: SingleChain MultiNode preset with TestSequencer * op-devstack: Add L2CL NoDiscovery preset * op-devstack: Additional DSLs for L2CL, L2EL * op-acceptance-tests: Reorg then gap filling tests * op-node WithNoDiscovery for deflake clp2p --- .../tests/sync/elsync/reorg/init_test.go | 16 + .../tests/sync/elsync/reorg/sync_test.go | 392 ++++++++++++++++++ op-devstack/dsl/l2_cl.go | 12 + op-devstack/dsl/l2_el.go | 25 ++ op-devstack/presets/cl_config.go | 8 + op-devstack/presets/singlechain_multinode.go | 37 ++ op-devstack/sysgo/l2_cl.go | 4 + op-devstack/sysgo/l2_cl_opnode.go | 1 + .../sysgo/system_singlechain_multinode.go | 26 ++ 9 files changed, 521 insertions(+) create mode 100644 op-acceptance-tests/tests/sync/elsync/reorg/init_test.go create mode 100644 op-acceptance-tests/tests/sync/elsync/reorg/sync_test.go diff --git a/op-acceptance-tests/tests/sync/elsync/reorg/init_test.go b/op-acceptance-tests/tests/sync/elsync/reorg/init_test.go new file mode 100644 index 00000000000..d0a15b5d4d0 --- /dev/null +++ b/op-acceptance-tests/tests/sync/elsync/reorg/init_test.go @@ -0,0 +1,16 @@ +package reorg + +import ( + "testing" + + "github.com/ethereum-optimism/optimism/op-devstack/compat" + "github.com/ethereum-optimism/optimism/op-devstack/presets" +) + +func TestMain(m *testing.M) { + presets.DoMain(m, + presets.WithNewSingleChainMultiNodeWithTestSeq(), + presets.WithCompatibleTypes(compat.SysGo), + presets.WithNoDiscovery(), + ) +} diff --git a/op-acceptance-tests/tests/sync/elsync/reorg/sync_test.go b/op-acceptance-tests/tests/sync/elsync/reorg/sync_test.go new file mode 100644 index 00000000000..d7b10d8c47e --- /dev/null +++ b/op-acceptance-tests/tests/sync/elsync/reorg/sync_test.go @@ -0,0 +1,392 @@ +package reorg + +import ( + "testing" + "time" + + "github.com/ethereum-optimism/optimism/op-devstack/devtest" + "github.com/ethereum-optimism/optimism/op-devstack/presets" + "github.com/ethereum-optimism/optimism/op-devstack/stack" + "github.com/ethereum-optimism/optimism/op-devstack/stack/match" + "github.com/ethereum-optimism/optimism/op-service/eth" + "github.com/ethereum-optimism/optimism/op-supervisor/supervisor/types" + "github.com/ethereum-optimism/optimism/op-test-sequencer/sequencer/seqtypes" + "github.com/ethereum/go-ethereum/common" +) + +// TestUnsafeGapFillAfterSafeReorg demonstrates the sequence: +// 1. Verifier CLP2P is disconnected and Verifier CL is stopped. +// 2. Safe reorg occurs because L1 reorged. +// 3. Verifier restarts, and consolidation drops the verifier previously-unsafe blocks. +// 4. CLP2P is restored, the verifier backfills and the unsafe gap is closed. +func TestUnsafeGapFillAfterSafeReorg(gt *testing.T) { + t := devtest.SerialT(gt) + sys := presets.NewSingleChainMultiNodeWithTestSeq(t) + require := t.Require() + logger := t.Logger() + ctx := t.Ctx() + + ts := sys.TestSequencer.Escape().ControlAPI(sys.L1Network.ChainID()) + cl := sys.L1Network.Escape().L1CLNode(match.FirstL1CL) + + // Pass the L1 genesis + sys.L1Network.WaitForBlock() + + // Stop auto advancing L1 + sys.ControlPlane.FakePoSState(cl.ID(), stack.Stop) + + startL1Block := sys.L1EL.BlockRefByLabel(eth.Unsafe) + + require.Eventually(func() bool { + // Advance single L1 block + require.NoError(ts.New(ctx, seqtypes.BuildOpts{Parent: common.Hash{}})) + require.NoError(ts.Next(ctx)) + l1head := sys.L1EL.BlockRefByLabel(eth.Unsafe) + l2Safe := sys.L2EL.BlockRefByLabel(eth.Safe) + logger.Info("l1 info", "l1_head", l1head, "l1_origin", l2Safe.L1Origin, "l2Safe", l2Safe) + // Wait until safe L2 block has L1 origin point after the startL1Block + return l2Safe.Number > 0 && l2Safe.L1Origin.Number > startL1Block.Number + }, 120*time.Second, 2*time.Second) + + l2BlockBeforeReorg := sys.L2EL.BlockRefByLabel(eth.Safe) + logger.Info("Target L2 Block to reorg", "l2", l2BlockBeforeReorg, "l1_origin", l2BlockBeforeReorg.L1Origin) + + // Make sure verifier safe head is also advanced from reorgL2Block or matched + sys.L2ELB.Reached(eth.Safe, l2BlockBeforeReorg.Number, 3) + + // Disconnect CLP2P + sys.L2CLB.DisconnectPeer(sys.L2CL) + sys.L2CL.DisconnectPeer(sys.L2CLB) + + // Stop verifier CL + sys.L2CLB.Stop() + + // Reorg L1 block which safe block L1 Origin points to + l1BlockBeforeReorg := sys.L1EL.BlockRefByNumber(l2BlockBeforeReorg.L1Origin.Number) + logger.Info("Triggering L1 reorg", "l1", l1BlockBeforeReorg) + require.NoError(ts.New(ctx, seqtypes.BuildOpts{Parent: l1BlockBeforeReorg.ParentHash})) + require.NoError(ts.Next(ctx)) + + // Start advancing L1 + sys.ControlPlane.FakePoSState(cl.ID(), stack.Start) + + // Make sure L1 reorged + sys.L1EL.WaitForBlockNumber(l1BlockBeforeReorg.Number) + l1BlockAfterReorg := sys.L1EL.BlockRefByNumber(l1BlockBeforeReorg.Number) + logger.Info("Triggered L1 reorg", "l1", l1BlockAfterReorg) + require.NotEqual(l1BlockAfterReorg.Hash, l1BlockBeforeReorg.Hash) + + // Need to poll until the L2CL detects L1 Reorg and trigger L2 Reorg + // What happens: + // L2CL detects L1 Reorg and reset the pipeline. op-node example logs: "reset: detected L1 reorg" + // L2EL detects L2 Reorg and reorgs. op-geth example logs: "Chain reorg detected" + sys.L2EL.ReorgTriggered(l2BlockBeforeReorg, 30) + l2BlockAfterReorg := sys.L2EL.BlockRefByNumber(l2BlockBeforeReorg.Number) + require.NotEqual(l2BlockAfterReorg.Hash, l2BlockBeforeReorg.Hash) + logger.Info("Triggered L2 reorg", "l2", l2BlockAfterReorg) + // Batcher re-submits batch using updated L1 view + sys.L2EL.Reached(eth.Safe, l2BlockAfterReorg.Number, 30) + require.GreaterOrEqual(sys.L1EL.BlockRefByNumber(l2BlockAfterReorg.L1Origin.Number).Number, l1BlockAfterReorg.Number) + + // Check the divergence before restarting verifier L2CLB + verUnsafe := sys.L2ELB.BlockRefByLabel(eth.Unsafe) + seqUnsafe := sys.L2EL.BlockRefByLabel(eth.Unsafe) + logger.Info("Unsafe heads", "seq", seqUnsafe, "ver", verUnsafe) + // Verifier unsafe head cannot advance yet because L2CLB is down + require.Greater(seqUnsafe.Number, verUnsafe.Number) + // Verifier unsafe head diverged + canonicalFromSeq := sys.L2EL.BlockRefByNumber(verUnsafe.Number) + require.NotEqual(canonicalFromSeq.Hash, verUnsafe.Hash) + logger.Info("Verifer unsafe head diverged", "verUnsafe", verUnsafe, "canonical", canonicalFromSeq) + var rewindTo eth.L2BlockRef + for i := verUnsafe.Number; i > 0; i-- { + ver := sys.L2ELB.BlockRefByNumber(i) + seq := sys.L2EL.BlockRefByNumber(i) + if ver.Hash == seq.Hash { + rewindTo = ver + break + } + } + logger.Info("Verifier diverged", "rewindTo", rewindTo) + require.Greater(l1BlockAfterReorg.Number, rewindTo.L1Origin.Number) + + // Restart verifier L2CL. CLP2P disabled + sys.L2CLB.Start() + + // Safe block reorged. Verifier L2CL will read the new L1 and reorg the safe chain + // Unsafe head will also be updated because safe chain reorged + sys.L2ELB.ReorgTriggered(l2BlockBeforeReorg, 10) + logger.Info("Triggered L2 safe reorg at verifier", "l2", l2BlockAfterReorg) + + sys.L2ELB.Matched(sys.L2EL, eth.Safe, 5) + + // L2CLB has no P2P connection, so unsafe gap always exists + seqUnsafe = sys.L2EL.BlockRefByLabel(eth.Unsafe) + verUnsafe = sys.L2ELB.BlockRefByLabel(eth.Unsafe) + logger.Info("Verifier unsafe gap", "gap", seqUnsafe.Number-verUnsafe.Number, "seqUnsafe", seqUnsafe.Number, "verUnsafe", verUnsafe.Number) + + // Reenable CLP2P + // L2CLB will receive unsafe payloads from sequencer + // Unsafe gap will be observed by the L2CLB, and it will be smart enough to close the gap, + // using RR Sync(soon be deprecated), or rely on EL Sync(desired) + sys.L2CLB.ConnectPeer(sys.L2CL) + sys.L2CL.ConnectPeer(sys.L2CLB) + + // Unsafe gap is closed + sys.L2ELB.Matched(sys.L2EL, types.LocalUnsafe, 50) + + seqUnsafe = sys.L2EL.BlockRefByLabel(eth.Unsafe) + verUnsafe = sys.L2ELB.BlockRefByLabel(eth.Unsafe) + logger.Info("Verifier unsafe gap closed", "gap", seqUnsafe.Number-verUnsafe.Number, "seqUnsafe", seqUnsafe.Number, "verUnsafe", verUnsafe.Number) + + gt.Cleanup(func() { + sys.L2CLB.Start() + sys.L2CLB.ConnectPeer(sys.L2CL) + sys.L2CL.ConnectPeer(sys.L2CLB) + }) +} + +// TestUnsafeGapFillAfterUnsafeReorg_RestartL2CL demonstrates the flow where: +// 1. Verifier L2CL is stopped. +// 2. Unsafe reorg occurs because L1 reorged, +// 3. Verifier restarts and detects the L1 reorg, triggering its own unsafe reorg, +// 4. Verifier then backfills and closes the unsafe gap once reconnected via CLP2P. +func TestUnsafeGapFillAfterUnsafeReorg_RestartL2CL(gt *testing.T) { + t := devtest.SerialT(gt) + sys := presets.NewSingleChainMultiNodeWithTestSeq(t) + require := t.Require() + logger := t.Logger() + ctx := t.Ctx() + + // Stop the batcher not to advance safe head + sys.L2Batcher.Stop() + + ts := sys.TestSequencer.Escape().ControlAPI(sys.L1Network.ChainID()) + cl := sys.L1Network.Escape().L1CLNode(match.FirstL1CL) + + // Pass the L1 genesis + sys.L1Network.WaitForBlock() + + // Stop auto advancing L1 + sys.ControlPlane.FakePoSState(cl.ID(), stack.Stop) + + startL1Block := sys.L1EL.BlockRefByLabel(eth.Unsafe) + + require.Eventually(func() bool { + // Advance single L1 block + require.NoError(ts.New(ctx, seqtypes.BuildOpts{Parent: common.Hash{}})) + require.NoError(ts.Next(ctx)) + l1head := sys.L1EL.BlockRefByLabel(eth.Unsafe) + l2Unsafe := sys.L2EL.BlockRefByLabel(eth.Unsafe) + logger.Info("l1 info", "l1_head", l1head, "l1_origin", l2Unsafe.L1Origin, "l2Unsafe", l2Unsafe) + // Wait until unsafe L2 block has L1 origin point after the startL1Block + return l2Unsafe.Number > 0 && l2Unsafe.L1Origin.Number > startL1Block.Number + }, 120*time.Second, 2*time.Second) + + sys.L2ELB.Matched(sys.L2EL, types.LocalUnsafe, 5) + + // Pick reorg block + l2BlockBeforeReorg := sys.L2EL.BlockRefByLabel(eth.Unsafe) + logger.Info("Target L2 Block to reorg", "l2", l2BlockBeforeReorg, "l1_origin", l2BlockBeforeReorg.L1Origin) + + // Make few more unsafe blocks which will be reorged out + sys.L2EL.Advanced(eth.Unsafe, 4) + sys.L2ELB.Matched(sys.L2EL, types.LocalUnsafe, 5) + + // Stop Verifier CL + sys.L2CLB.Stop() + + // Reorg L1 block which unsafe block L1 Origin points to + l1BlockBeforeReorg := sys.L1EL.BlockRefByNumber(l2BlockBeforeReorg.L1Origin.Number) + logger.Info("Triggering L1 reorg", "l1", l1BlockBeforeReorg) + require.NoError(ts.New(ctx, seqtypes.BuildOpts{Parent: l1BlockBeforeReorg.ParentHash})) + require.NoError(ts.Next(ctx)) + + // Start advancing L1 + sys.ControlPlane.FakePoSState(cl.ID(), stack.Start) + + // Make sure L1 reorged + sys.L1EL.WaitForBlockNumber(l1BlockBeforeReorg.Number) + l1BlockAfterReorg := sys.L1EL.BlockRefByNumber(l1BlockBeforeReorg.Number) + logger.Info("Triggered L1 reorg", "l1", l1BlockAfterReorg) + require.NotEqual(l1BlockAfterReorg.Hash, l1BlockBeforeReorg.Hash) + + // Need to poll until the L2CL detects L1 Reorg and trigger L2 Reorg + // What happens: + // L2CL detects L1 Reorg and reset the pipeline. op-node example logs: "reset: detected L1 reorg" + // L2EL detects L2 Reorg and reorgs. op-geth example logs: "Chain reorg detected" + sys.L2EL.ReorgTriggered(l2BlockBeforeReorg, 30) + l2BlockAfterReorg := sys.L2EL.BlockRefByNumber(l2BlockBeforeReorg.Number) + require.NotEqual(l2BlockAfterReorg.Hash, l2BlockBeforeReorg.Hash) + logger.Info("Triggered L2 reorg", "l2", l2BlockAfterReorg) + + // Check the divergence before restarting verifier L2CLB + verUnsafe := sys.L2ELB.BlockRefByLabel(eth.Unsafe) + seqUnsafe := sys.L2EL.BlockRefByLabel(eth.Unsafe) + logger.Info("Unsafe heads", "seq", seqUnsafe, "ver", verUnsafe) + // Verifier unsafe head cannot advance yet because L2CLB is down + require.Greater(seqUnsafe.Number, verUnsafe.Number) + // Verifier unsafe head diverged + canonicalFromSeq := sys.L2EL.BlockRefByNumber(verUnsafe.Number) + require.NotEqual(canonicalFromSeq.Hash, verUnsafe.Hash) + logger.Info("Verifer unsafe head diverged", "verUnsafe", verUnsafe, "canonical", canonicalFromSeq) + var rewindTo eth.L2BlockRef + for i := verUnsafe.Number; i > 0; i-- { + ver := sys.L2ELB.BlockRefByNumber(i) + seq := sys.L2EL.BlockRefByNumber(i) + if ver.Hash == seq.Hash { + rewindTo = ver + break + } + } + logger.Info("Verifier diverged", "rewindTo", rewindTo) + require.Greater(l1BlockAfterReorg.Number, rewindTo.L1Origin.Number) + + // Restart verifier L2CL + // L2CL walks back. op-node example logs "walking sync start" + // Dropping L2 blocks which has invalid L1 origin, until we reach rewindTo + sys.L2CLB.Start() + + // Make sure CLP2P is connected + sys.L2CLB.ConnectPeer(sys.L2CL) + sys.L2CL.ConnectPeer(sys.L2CLB) + + // L2CLB will receive unsafe payloads from sequencer + // Unsafe gap will be observed by the L2CLB, and it will be smart enough to close the gap, + // using RR Sync(soon be deprecated), or rely on EL Sync(desired) + + // Unsafe gap is closed + sys.L2ELB.Matched(sys.L2EL, types.LocalUnsafe, 50) + + seqUnsafe = sys.L2EL.BlockRefByLabel(eth.Unsafe) + verUnsafe = sys.L2ELB.BlockRefByLabel(eth.Unsafe) + logger.Info("Verifier unsafe gap closed", "gap", seqUnsafe.Number-verUnsafe.Number, "seqUnsafe", seqUnsafe.Number, "verUnsafe", verUnsafe.Number) + + gt.Cleanup(func() { + sys.L2Batcher.Start() + sys.L2CLB.Start() + sys.L2CLB.ConnectPeer(sys.L2CL) + sys.L2CL.ConnectPeer(sys.L2CLB) + }) +} + +// TestUnsafeGapFillAfterUnsafeReorg_RestartCLP2P demonstrates the flow where: +// 1. Verifier CLP2P is disconnected. +// 2. Unsafe reorg occurs because L1 reorged. +// 3. Verifier detects the L1 reorg, triggering its own unsafe reorg. +// 4. CLP2P is restored Verifier, the verifier backfills and the unsafe gap is closed. +func TestUnsafeGapFillAfterUnsafeReorg_RestartCLP2P(gt *testing.T) { + t := devtest.SerialT(gt) + sys := presets.NewSingleChainMultiNodeWithTestSeq(t) + require := t.Require() + logger := t.Logger() + ctx := t.Ctx() + + // Stop the batcher not to advance safe head + sys.L2Batcher.Stop() + + ts := sys.TestSequencer.Escape().ControlAPI(sys.L1Network.ChainID()) + cl := sys.L1Network.Escape().L1CLNode(match.FirstL1CL) + + // Pass the L1 genesis + sys.L1Network.WaitForBlock() + + // Stop auto advancing L1 + sys.ControlPlane.FakePoSState(cl.ID(), stack.Stop) + + startL1Block := sys.L1EL.BlockRefByLabel(eth.Unsafe) + + require.Eventually(func() bool { + // Advance single L1 block + require.NoError(ts.New(ctx, seqtypes.BuildOpts{Parent: common.Hash{}})) + require.NoError(ts.Next(ctx)) + l1head := sys.L1EL.BlockRefByLabel(eth.Unsafe) + l2Unsafe := sys.L2EL.BlockRefByLabel(eth.Unsafe) + logger.Info("l1 info", "l1_head", l1head, "l1_origin", l2Unsafe.L1Origin, "l2Unsafe", l2Unsafe) + // Wait until unsafe L2 block has L1 origin point after the startL1Block + return l2Unsafe.Number > 0 && l2Unsafe.L1Origin.Number > startL1Block.Number + }, 120*time.Second, 2*time.Second) + + sys.L2ELB.Matched(sys.L2EL, types.LocalUnsafe, 5) + + // Pick reorg block + l2BlockBeforeReorg := sys.L2EL.BlockRefByLabel(eth.Unsafe) + logger.Info("Target L2 Block to reorg", "l2", l2BlockBeforeReorg, "l1_origin", l2BlockBeforeReorg.L1Origin) + + // Make few more unsafe blocks which will be reorged out + sys.L2EL.Advanced(eth.Unsafe, 4) + sys.L2ELB.Matched(sys.L2EL, types.LocalUnsafe, 5) + + // Disconnect CLP2P + sys.L2CLB.DisconnectPeer(sys.L2CL) + sys.L2CL.DisconnectPeer(sys.L2CLB) + + // verUnsafe will eventually reorged out + verUnsafe := sys.L2ELB.BlockRefByLabel(eth.Unsafe) + + // Reorg L1 block which unsafe block L1 Origin points to + l1BlockBeforeReorg := sys.L1EL.BlockRefByNumber(l2BlockBeforeReorg.L1Origin.Number) + logger.Info("Triggering L1 reorg", "l1", l1BlockBeforeReorg) + require.NoError(ts.New(ctx, seqtypes.BuildOpts{Parent: l1BlockBeforeReorg.ParentHash})) + require.NoError(ts.Next(ctx)) + + // Start advancing L1 + sys.ControlPlane.FakePoSState(cl.ID(), stack.Start) + + // Make sure L1 reorged + sys.L1EL.WaitForBlockNumber(l1BlockBeforeReorg.Number) + l1BlockAfterReorg := sys.L1EL.BlockRefByNumber(l1BlockBeforeReorg.Number) + logger.Info("Triggered L1 reorg", "l1", l1BlockAfterReorg) + require.NotEqual(l1BlockAfterReorg.Hash, l1BlockBeforeReorg.Hash) + + // Need to poll until the L2CL detects L1 Reorg and trigger L2 Reorg + // What happens: + // L2CL detects L1 Reorg and reset the pipeline. op-node example logs: "reset: detected L1 reorg" + // L2EL detects L2 Reorg and reorgs. op-geth example logs: "Chain reorg detected" + sys.L2EL.ReorgTriggered(l2BlockBeforeReorg, 30) + l2BlockAfterReorg := sys.L2EL.BlockRefByNumber(l2BlockBeforeReorg.Number) + require.NotEqual(l2BlockAfterReorg.Hash, l2BlockBeforeReorg.Hash) + logger.Info("Triggered L2 reorg", "l2", l2BlockAfterReorg) + + // L2CLB is still up but only have access to L1 to update canonical view + // verifier cannot advance unsafe head, but only reorging out blocks + // Test can still independently find rewindTo + rewindTo := sys.L2ELB.BlockRefByNumber(0) + for i := verUnsafe.Number; i > 0; i-- { + ref, err := sys.L2ELB.Escape().L2EthClient().L2BlockRefByNumber(ctx, i) + if err != nil { + // May be not found since verifier EL reorging + continue + } + if ref.L1Origin.Number < l1BlockAfterReorg.Number { + rewindTo = ref + break + } + } + logger.Info("Verifier diverged", "rewindTo", rewindTo) + + // Wait until verifier reset and dropped all reorg blocks + sys.L2CLB.Reset(types.LocalUnsafe, rewindTo) + logger.Info("Verifier rewind done", "rewindTo", rewindTo) + + // Make sure CLP2P is connected + sys.L2CLB.ConnectPeer(sys.L2CL) + sys.L2CL.ConnectPeer(sys.L2CLB) + + // L2CLB will receive unsafe payloads from sequencer + // Unsafe gap will be observed by the L2CLB, and it will be smart enough to close the gap, + // using RR Sync(soon be deprecated), or rely on EL Sync(desired) + + // Unsafe gap is closed + sys.L2ELB.Matched(sys.L2EL, types.LocalUnsafe, 50) + + seqUnsafe := sys.L2EL.BlockRefByLabel(eth.Unsafe) + verUnsafe = sys.L2ELB.BlockRefByLabel(eth.Unsafe) + logger.Info("Verifier unsafe gap closed", "gap", seqUnsafe.Number-verUnsafe.Number, "seqUnsafe", seqUnsafe.Number, "verUnsafe", verUnsafe.Number) + + gt.Cleanup(func() { + sys.L2Batcher.Start() + sys.L2CLB.ConnectPeer(sys.L2CL) + sys.L2CL.ConnectPeer(sys.L2CLB) + }) +} diff --git a/op-devstack/dsl/l2_cl.go b/op-devstack/dsl/l2_cl.go index d064f0019b1..2c565f19eff 100644 --- a/op-devstack/dsl/l2_cl.go +++ b/op-devstack/dsl/l2_cl.go @@ -375,3 +375,15 @@ func (cl *L2CLNode) SignalTarget(el *L2ELNode, targetNum uint64) { }) cl.require.NoErrorf(err, "failed to post unsafe payload via admin API: target %d", targetNum) } + +func (cl *L2CLNode) Reset(lvl types.SafetyLevel, target eth.L2BlockRef) { + cl.require.NoError(retry.Do0(cl.ctx, 5, &retry.FixedStrategy{Dur: 2 * time.Second}, + func() error { + res := cl.HeadBlockRef(lvl) + cl.log.Info("Chain sync Status", lvl, res) + if res.Hash == target.Hash { + return nil + } + return errors.New("waiting to reset") + })) +} diff --git a/op-devstack/dsl/l2_el.go b/op-devstack/dsl/l2_el.go index 33b8b73fd6f..fe0c2518eab 100644 --- a/op-devstack/dsl/l2_el.go +++ b/op-devstack/dsl/l2_el.go @@ -12,6 +12,7 @@ import ( "github.com/ethereum-optimism/optimism/op-service/eth" "github.com/ethereum-optimism/optimism/op-service/predeploys" "github.com/ethereum-optimism/optimism/op-service/retry" + "github.com/ethereum-optimism/optimism/op-supervisor/supervisor/types" "github.com/ethereum/go-ethereum/common" ) @@ -273,3 +274,27 @@ func (el *L2ELNode) FinishedELSync(refNode *L2ELNode, unsafe, safe, finalized ui return errors.New("EL Sync not yet triggered") })) } + +func (el *L2ELNode) ChainSyncStatus(chainID eth.ChainID, lvl types.SafetyLevel) eth.BlockID { + el.require.Equal(chainID, el.inner.ID().ChainID(), "chain ID mismatch") + var blockRef eth.L2BlockRef + switch lvl { + case types.Finalized: + blockRef = el.BlockRefByLabel(eth.Finalized) + case types.CrossSafe, types.LocalSafe: + blockRef = el.BlockRefByLabel(eth.Safe) + case types.CrossUnsafe, types.LocalUnsafe: + blockRef = el.BlockRefByLabel(eth.Unsafe) + default: + el.require.NoError(errors.New("invalid safety level")) + } + return blockRef.ID() +} + +func (el *L2ELNode) MatchedFn(refNode SyncStatusProvider, lvl types.SafetyLevel, attempts int) CheckFunc { + return MatchedFn(el, refNode, el.log, el.ctx, lvl, el.ChainID(), attempts) +} + +func (el *L2ELNode) Matched(refNode SyncStatusProvider, lvl types.SafetyLevel, attempts int) { + el.require.NoError(el.MatchedFn(refNode, lvl, attempts)()) +} diff --git a/op-devstack/presets/cl_config.go b/op-devstack/presets/cl_config.go index 95a3d900ae6..1a425dfc8de 100644 --- a/op-devstack/presets/cl_config.go +++ b/op-devstack/presets/cl_config.go @@ -39,3 +39,11 @@ func WithReqRespSyncDisabled() stack.CommonOption { cfg.EnableReqRespSync = false }))) } + +func WithNoDiscovery() stack.CommonOption { + return stack.MakeCommon( + sysgo.WithGlobalL2CLOption(sysgo.L2CLOptionFn( + func(_ devtest.P, id stack.L2CLNodeID, cfg *sysgo.L2CLConfig) { + cfg.NoDiscovery = true + }))) +} diff --git a/op-devstack/presets/singlechain_multinode.go b/op-devstack/presets/singlechain_multinode.go index c417b435f67..e51ca6ea8a1 100644 --- a/op-devstack/presets/singlechain_multinode.go +++ b/op-devstack/presets/singlechain_multinode.go @@ -57,3 +57,40 @@ func NewSingleChainMultiNodeWithoutCheck(t devtest.T) *SingleChainMultiNode { func WithSingleChainMultiNodeWithoutP2P() stack.CommonOption { return stack.MakeCommon(sysgo.DefaultSingleChainMultiNodeSystemWithoutP2P(&sysgo.DefaultSingleChainMultiNodeSystemIDs{})) } + +type SingleChainMultiNodeWithTestSeq struct { + SingleChainMultiNode + + TestSequencer *dsl.TestSequencer +} + +func NewSingleChainMultiNodeWithTestSeq(t devtest.T) *SingleChainMultiNodeWithTestSeq { + system := shim.NewSystem(t) + orch := Orchestrator() + orch.Hydrate(system) + minimal := minimalFromSystem(t, system, orch) + l2 := system.L2Network(match.Assume(t, match.L2ChainA)) + verifierCL := l2.L2CLNode(match.Assume(t, + match.And( + match.Not(match.WithSequencerActive(t.Ctx())), + match.Not[stack.L2CLNodeID, stack.L2CLNode](minimal.L2CL.ID()), + ))) + verifierEL := l2.L2ELNode(match.Assume(t, + match.And( + match.EngineFor(verifierCL), + match.Not[stack.L2ELNodeID, stack.L2ELNode](minimal.L2EL.ID())))) + preset := &SingleChainMultiNode{ + Minimal: *minimal, + L2ELB: dsl.NewL2ELNode(verifierEL, orch.ControlPlane()), + L2CLB: dsl.NewL2CLNode(verifierCL, orch.ControlPlane()), + } + out := &SingleChainMultiNodeWithTestSeq{ + SingleChainMultiNode: *preset, + TestSequencer: dsl.NewTestSequencer(system.TestSequencer(match.Assume(t, match.FirstTestSequencer))), + } + return out +} + +func WithNewSingleChainMultiNodeWithTestSeq() stack.CommonOption { + return stack.MakeCommon(sysgo.DefaultSingleChainMultiNodeWithTestSeqSystem(&sysgo.DefaultSingleChainMultiNodeWithTestSeqSystemIDs{})) +} diff --git a/op-devstack/sysgo/l2_cl.go b/op-devstack/sysgo/l2_cl.go index 2c95439b693..8e69113d8eb 100644 --- a/op-devstack/sysgo/l2_cl.go +++ b/op-devstack/sysgo/l2_cl.go @@ -30,6 +30,9 @@ type L2CLConfig struct { // EnableReqRespSync is the flag to enable/disable req-resp sync. EnableReqRespSync bool + + // NoDiscovery is the flag to enable/disable discovery + NoDiscovery bool } func L2CLSequencer() L2CLOption { @@ -52,6 +55,7 @@ func DefaultL2CLConfig() *L2CLConfig { IsSequencer: false, IndexingMode: false, EnableReqRespSync: true, + NoDiscovery: false, } } diff --git a/op-devstack/sysgo/l2_cl_opnode.go b/op-devstack/sysgo/l2_cl_opnode.go index 99fcc60b066..dbcf1465cd5 100644 --- a/op-devstack/sysgo/l2_cl_opnode.go +++ b/op-devstack/sysgo/l2_cl_opnode.go @@ -226,6 +226,7 @@ func WithOpNode(l2CLID stack.L2CLNodeID, l1CLID stack.L1CLNodeID, l1ELID stack.L } p2pConfig, err = p2pcli.NewConfig(cliCtx, l2Net.rollupCfg.BlockTime) require.NoError(err, "failed to load p2p config") + p2pConfig.NoDiscovery = cfg.NoDiscovery } // specify interop config, but do not configure anything, to disable indexing mode diff --git a/op-devstack/sysgo/system_singlechain_multinode.go b/op-devstack/sysgo/system_singlechain_multinode.go index 93bf33ae013..c4892038369 100644 --- a/op-devstack/sysgo/system_singlechain_multinode.go +++ b/op-devstack/sysgo/system_singlechain_multinode.go @@ -12,6 +12,12 @@ type DefaultSingleChainMultiNodeSystemIDs struct { L2ELB stack.L2ELNodeID } +type DefaultSingleChainMultiNodeWithTestSeqSystemIDs struct { + DefaultSingleChainMultiNodeSystemIDs + + TestSequencer stack.TestSequencerID +} + func NewDefaultSingleChainMultiNodeSystemIDs(l1ID, l2ID eth.ChainID) DefaultSingleChainMultiNodeSystemIDs { minimal := NewDefaultMinimalSystemIDs(l1ID, l2ID) return DefaultSingleChainMultiNodeSystemIDs{ @@ -21,6 +27,13 @@ func NewDefaultSingleChainMultiNodeSystemIDs(l1ID, l2ID eth.ChainID) DefaultSing } } +func NewDefaultSingleChainMultiNodeWithTestSeqSystemIDs(l1ID, l2ID eth.ChainID) DefaultSingleChainMultiNodeWithTestSeqSystemIDs { + return DefaultSingleChainMultiNodeWithTestSeqSystemIDs{ + DefaultSingleChainMultiNodeSystemIDs: NewDefaultSingleChainMultiNodeSystemIDs(l1ID, l2ID), + TestSequencer: "dev", + } +} + func DefaultSingleChainMultiNodeSystem(dest *DefaultSingleChainMultiNodeSystemIDs) stack.Option[*Orchestrator] { ids := NewDefaultSingleChainMultiNodeSystemIDs(DefaultL1ID, DefaultL2AID) @@ -40,6 +53,19 @@ func DefaultSingleChainMultiNodeSystem(dest *DefaultSingleChainMultiNodeSystemID return opt } +func DefaultSingleChainMultiNodeWithTestSeqSystem(dest *DefaultSingleChainMultiNodeWithTestSeqSystemIDs) stack.Option[*Orchestrator] { + ids := NewDefaultSingleChainMultiNodeWithTestSeqSystemIDs(DefaultL1ID, DefaultL2AID) + opt := stack.Combine[*Orchestrator]() + opt.Add(DefaultSingleChainMultiNodeSystem(&dest.DefaultSingleChainMultiNodeSystemIDs)) + + opt.Add(WithTestSequencer(ids.TestSequencer, ids.L1CL, ids.L2CL, ids.L1EL, ids.L2EL)) + + opt.Add(stack.Finally(func(orch *Orchestrator) { + *dest = ids + })) + return opt +} + func DefaultSingleChainMultiNodeSystemWithoutP2P(dest *DefaultSingleChainMultiNodeSystemIDs) stack.Option[*Orchestrator] { ids := NewDefaultSingleChainMultiNodeSystemIDs(DefaultL1ID, DefaultL2AID) From 06a14a05781285e6fe8a5679eb69a03bfd3628e5 Mon Sep 17 00:00:00 2001 From: Michael Amadi Date: Thu, 16 Oct 2025 16:55:28 +0100 Subject: [PATCH 072/117] add TestEndToEndBootstrapApplyWithUpgrade and UpgradeSuperchainConfig scripts (#17826) * add TestEndToEndBootstrapApplyWithUpgrade and UpgradeSuperchainConfig scripts * Update packages/contracts-bedrock/scripts/deploy/UpgradeSuperchainConfig.s.sol Co-authored-by: graphite-app[bot] <96075541+graphite-app[bot]@users.noreply.github.com> * add comment * fixes * fixes * Update op-deployer/pkg/deployer/integration_test/apply_test.go Co-authored-by: Maurelian * fixes... * add comments to solidity code * add comments to solidity code --------- Co-authored-by: graphite-app[bot] <96075541+graphite-app[bot]@users.noreply.github.com> Co-authored-by: Maurelian --- .../deployer/integration_test/apply_test.go | 110 ++++++++++++++++++ .../embedded/upgrade_superchainconfig.go | 43 +++++++ .../deploy/UpgradeSuperchainConfig.s.sol | 73 ++++++++++++ .../test/opcm/UpgradeSuperchainConfig.t.sol | 81 +++++++++++++ 4 files changed, 307 insertions(+) create mode 100644 op-deployer/pkg/deployer/upgrade/embedded/upgrade_superchainconfig.go create mode 100644 packages/contracts-bedrock/scripts/deploy/UpgradeSuperchainConfig.s.sol create mode 100644 packages/contracts-bedrock/test/opcm/UpgradeSuperchainConfig.t.sol diff --git a/op-deployer/pkg/deployer/integration_test/apply_test.go b/op-deployer/pkg/deployer/integration_test/apply_test.go index 390c37de144..706a9b94fcc 100644 --- a/op-deployer/pkg/deployer/integration_test/apply_test.go +++ b/op-deployer/pkg/deployer/integration_test/apply_test.go @@ -4,6 +4,7 @@ import ( "bytes" "context" "encoding/hex" + "encoding/json" "log/slog" "math/big" "strings" @@ -11,8 +12,10 @@ import ( "time" "github.com/ethereum-optimism/optimism/op-deployer/pkg/deployer/bootstrap" + "github.com/ethereum-optimism/optimism/op-deployer/pkg/deployer/broadcaster" "github.com/ethereum-optimism/optimism/op-deployer/pkg/deployer/inspect" "github.com/ethereum-optimism/optimism/op-deployer/pkg/deployer/integration_test/shared" + "github.com/ethereum-optimism/optimism/op-deployer/pkg/env" "github.com/ethereum/go-ethereum/params" "github.com/ethereum-optimism/optimism/op-service/testutils" @@ -30,7 +33,10 @@ import ( "github.com/ethereum-optimism/optimism/op-deployer/pkg/deployer/testutil" "github.com/ethereum/go-ethereum/common/hexutil" "github.com/ethereum/go-ethereum/crypto" + "github.com/ethereum/go-ethereum/rpc" + "github.com/ethereum-optimism/optimism/op-deployer/pkg/deployer/upgrade/embedded" + "github.com/ethereum-optimism/optimism/op-deployer/pkg/deployer/upgrade/v2_0_0" op_e2e "github.com/ethereum-optimism/optimism/op-e2e" "github.com/holiman/uint256" @@ -143,6 +149,110 @@ func TestEndToEndBootstrapApply(t *testing.T) { }) } +// TestEndToEndBootstrapApplyWithUpgrade tests upgrading from a previous contracts release +// to embedded version of contracts by executing the following sequence: +// 1. create an anvil env that is a fork of op-sepolia +// 2. bootstrap.Implementations of the latest/embedded version of contracts, which will produce a new opcm +// 3. call opcm.upgradeSuperchainConfig on the opcm deployed in [2] (prerequisite for opcm.upgrade) +// 4. call opcm.upgrade on the opcm deployed in [2] +func TestEndToEndBootstrapApplyWithUpgrade(t *testing.T) { + op_e2e.InitParallel(t) + + lgr := testlog.Logger(t, slog.LevelDebug) + + forkedL1, stopL1, err := devnet.NewForkedSepolia(lgr) + pkHex, _, _ := shared.DefaultPrivkey(t) + require.NoError(t, err) + t.Cleanup(func() { + require.NoError(t, stopL1()) + }) + loc, afactsFS := testutil.LocalArtifacts(t) + ctx, cancel := context.WithTimeout(context.Background(), 90*time.Second) + defer cancel() + testCacheDir := testutils.IsolatedTestDirWithAutoCleanup(t) + + superchain, err := standard.SuperchainFor(11155111) + require.NoError(t, err) + + superchainProxyAdmin, err := standard.SuperchainProxyAdminAddrFor(11155111) + require.NoError(t, err) + + superchainProxyAdminOwner, err := standard.L1ProxyAdminOwner(11155111) + require.NoError(t, err) + + impls, err := bootstrap.Implementations(ctx, bootstrap.ImplementationsConfig{ + L1RPCUrl: forkedL1.RPCUrl(), + PrivateKey: pkHex, + ArtifactsLocator: loc, + MIPSVersion: int(standard.MIPSVersion), + WithdrawalDelaySeconds: standard.WithdrawalDelaySeconds, + MinProposalSizeBytes: standard.MinProposalSizeBytes, + ChallengePeriodSeconds: standard.ChallengePeriodSeconds, + ProofMaturityDelaySeconds: standard.ProofMaturityDelaySeconds, + DisputeGameFinalityDelaySeconds: standard.DisputeGameFinalityDelaySeconds, + DevFeatureBitmap: common.Hash{}, + SuperchainConfigProxy: superchain.SuperchainConfigAddr, + ProtocolVersionsProxy: superchain.ProtocolVersionsAddr, + L1ProxyAdminOwner: superchainProxyAdminOwner, + SuperchainProxyAdmin: superchainProxyAdmin, + CacheDir: testCacheDir, + Logger: lgr, + Challenger: common.Address{'C'}, + }) + require.NoError(t, err) + + // Now test the OPCM upgrade using the deployed impls.Opcm + t.Run("opcm upgrade test", func(t *testing.T) { + // Create script host for the upgrade + rpcClient, err := rpc.Dial(forkedL1.RPCUrl()) + require.NoError(t, err) + + host, err := env.DefaultForkedScriptHost( + ctx, + broadcaster.NoopBroadcaster(), + lgr, + superchainProxyAdminOwner, + afactsFS, + rpcClient, + ) + require.NoError(t, err) + + // First run upgradeSuperchainConfig because the version on the fork is < than that + // of the contracts-bedrock folder so upgrading directly would revert. + t.Run("upgrade superchain config", func(t *testing.T) { + upgradeConfig := embedded.UpgradeSuperchainConfigInput{ + Prank: superchainProxyAdminOwner, + Opcm: impls.Opcm, + SuperchainConfig: superchain.SuperchainConfigAddr, + SuperchainProxyAdmin: superchainProxyAdmin, + } + + err = embedded.UpgradeSuperchainConfig(host, upgradeConfig) + require.NoError(t, err, "Superchain config upgrade should succeed") + }) + + // Then run the OPCM upgrade + t.Run("upgrade opcm", func(t *testing.T) { + upgradeConfig := v2_0_0.UpgradeOPChainInput{ + Prank: superchainProxyAdminOwner, + Opcm: impls.Opcm, + EncodedChainConfigs: []v2_0_0.OPChainConfig{ + { + SystemConfigProxy: common.HexToAddress("034edD2A225f7f429A63E0f1D2084B9E0A93b538"), + ProxyAdmin: superchainProxyAdmin, + AbsolutePrestate: common.Hash{'A', 'P'}, + }, + }, + } + // Test the upgrade + upgradeConfigBytes, err := json.Marshal(upgradeConfig) + require.NoError(t, err, "UpgradeOPChainInput should marshal to JSON") + err = embedded.DefaultUpgrader.Upgrade(host, upgradeConfigBytes) + require.NoError(t, err, "OPCM upgrade should succeed") + }) + }) +} + func TestEndToEndApply(t *testing.T) { op_e2e.InitParallel(t) diff --git a/op-deployer/pkg/deployer/upgrade/embedded/upgrade_superchainconfig.go b/op-deployer/pkg/deployer/upgrade/embedded/upgrade_superchainconfig.go new file mode 100644 index 00000000000..eb008f92dd4 --- /dev/null +++ b/op-deployer/pkg/deployer/upgrade/embedded/upgrade_superchainconfig.go @@ -0,0 +1,43 @@ +package embedded + +import ( + "encoding/json" + "fmt" + + "github.com/ethereum-optimism/optimism/op-chain-ops/script" + "github.com/ethereum/go-ethereum/common" +) + +type UpgradeSuperchainConfigInput struct { + Prank common.Address `json:"prank"` + Opcm common.Address `json:"opcm"` + SuperchainConfig common.Address `json:"superchainConfig"` + SuperchainProxyAdmin common.Address `json:"superchainProxyAdmin"` +} + +type UpgradeSuperchainConfigScript script.DeployScriptWithoutOutput[UpgradeSuperchainConfigInput] + +// NewDeployImplementationsScript loads and validates the DeployImplementations script contract +func NewUpgradeSuperchainConfigScript(host *script.Host) (UpgradeSuperchainConfigScript, error) { + return script.NewDeployScriptWithoutOutputFromFile[UpgradeSuperchainConfigInput](host, "UpgradeSuperchainConfig.s.sol", "UpgradeSuperchainConfig") +} + +func UpgradeSuperchainConfig(host *script.Host, input UpgradeSuperchainConfigInput) error { + upgradeScript, err := NewUpgradeSuperchainConfigScript(host) + if err != nil { + return fmt.Errorf("failed to load UpgradeSuperchainConfig script: %w", err) + } + err = upgradeScript.Run(input) + if err != nil { + return fmt.Errorf("failed to run UpgradeSuperchainConfig script: %w", err) + } + return nil +} + +func (u *Upgrader) UpgradeSuperchainConfig(host *script.Host, input json.RawMessage) error { + var upgradeInput UpgradeSuperchainConfigInput + if err := json.Unmarshal(input, &upgradeInput); err != nil { + return fmt.Errorf("failed to unmarshal input: %w", err) + } + return UpgradeSuperchainConfig(host, upgradeInput) +} diff --git a/packages/contracts-bedrock/scripts/deploy/UpgradeSuperchainConfig.s.sol b/packages/contracts-bedrock/scripts/deploy/UpgradeSuperchainConfig.s.sol new file mode 100644 index 00000000000..6d61677a5f3 --- /dev/null +++ b/packages/contracts-bedrock/scripts/deploy/UpgradeSuperchainConfig.s.sol @@ -0,0 +1,73 @@ +// SPDX-License-Identifier: MIT +pragma solidity ^0.8.0; + +import { Script } from "forge-std/Script.sol"; +import { IOPContractsManager } from "interfaces/L1/IOPContractsManager.sol"; +import { ISuperchainConfig } from "interfaces/L1/ISuperchainConfig.sol"; +import { IProxyAdmin } from "interfaces/universal/IProxyAdmin.sol"; + +contract UpgradeSuperchainConfig is Script { + struct Input { + address prank; + IOPContractsManager opcm; + ISuperchainConfig superchainConfig; + IProxyAdmin superchainProxyAdmin; + } + + /// @notice Delegate calls upgradeSuperchainConfig on the OPCM from the input.prank address. + function run(Input memory _input) external { + // Make sure the input is valid + assertValidInput(_input); + + IOPContractsManager opcm = _input.opcm; + + // Etch DummyCaller contract. This contract is used to mimic the contract that is used + // as the source of the delegatecall to the OPCM. In practice this will be the governance + // 2/2 or similar. + address prank = _input.prank; + + bytes memory code = vm.getDeployedCode("UpgradeSuperchainConfig.s.sol:DummyCaller"); + vm.etch(prank, code); + + vm.store(prank, bytes32(0), bytes32(uint256(uint160(address(opcm))))); + vm.label(prank, "DummyCaller"); + + ISuperchainConfig superchainConfig = _input.superchainConfig; + IProxyAdmin superchainProxyAdmin = _input.superchainProxyAdmin; + + // Call into the DummyCaller to perform the delegatecall + vm.broadcast(msg.sender); + + (bool success,) = DummyCaller(prank).upgradeSuperchainConfig(superchainConfig, superchainProxyAdmin); + require(success, "UpgradeSuperchainConfig: upgradeSuperchainConfig failed"); + } + + /// @notice Asserts that the input is valid. + function assertValidInput(Input memory _input) internal pure { + require(_input.prank != address(0), "UpgradeSuperchainConfig: prank not set"); + require(address(_input.opcm) != address(0), "UpgradeSuperchainConfig: opcm not set"); + require(address(_input.superchainConfig) != address(0), "UpgradeSuperchainConfig: superchainConfig not set"); + require( + address(_input.superchainProxyAdmin) != address(0), "UpgradeSuperchainConfig: superchainProxyAdmin not set" + ); + } +} + +/// @title DummyCaller +/// @notice This contract is used to mimic the contract that is used as the source of the delegatecall to the OPCM. +contract DummyCaller { + address internal _opcmAddr; + + function upgradeSuperchainConfig( + ISuperchainConfig _superchainConfig, + IProxyAdmin _superchainProxyAdmin + ) + external + returns (bool, bytes memory) + { + bytes memory data = + abi.encodeCall(IOPContractsManager.upgradeSuperchainConfig, (_superchainConfig, _superchainProxyAdmin)); + (bool success, bytes memory result) = _opcmAddr.delegatecall(data); + return (success, result); + } +} diff --git a/packages/contracts-bedrock/test/opcm/UpgradeSuperchainConfig.t.sol b/packages/contracts-bedrock/test/opcm/UpgradeSuperchainConfig.t.sol new file mode 100644 index 00000000000..41a479a69b3 --- /dev/null +++ b/packages/contracts-bedrock/test/opcm/UpgradeSuperchainConfig.t.sol @@ -0,0 +1,81 @@ +// SPDX-License-Identifier: MIT +pragma solidity 0.8.15; + +import { Test } from "forge-std/Test.sol"; + +import { ISuperchainConfig } from "interfaces/L1/ISuperchainConfig.sol"; +import { IProxyAdmin } from "interfaces/universal/IProxyAdmin.sol"; + +import { UpgradeSuperchainConfig } from "scripts/deploy/UpgradeSuperchainConfig.s.sol"; +import { IOPContractsManager } from "interfaces/L1/IOPContractsManager.sol"; + +/// @title MockOPCM +/// @notice This contract is used to mock the OPCM contract and emit an event which we check for in the test. +contract MockOPCM { + event UpgradeCalled(address indexed superchainConfig, address indexed superchainProxyAdmin); + + function upgradeSuperchainConfig(ISuperchainConfig _superchainConfig, IProxyAdmin _superchainProxyAdmin) public { + emit UpgradeCalled(address(_superchainConfig), address(_superchainProxyAdmin)); + } +} + +/// @title UpgradeSuperchainConfig_Test +/// @notice This test is used to test the UpgradeSuperchainConfig script. +contract UpgradeSuperchainConfig_Run_Test is Test { + MockOPCM mockOPCM; + UpgradeSuperchainConfig.Input input; + UpgradeSuperchainConfig upgradeSuperchainConfig; + address prank; + ISuperchainConfig superchainConfig; + IProxyAdmin superchainProxyAdmin; + + event UpgradeCalled(address indexed superchainConfig, address indexed superchainProxyAdmin); + + /// @notice Sets up the test suite. + function setUp() public virtual { + mockOPCM = new MockOPCM(); + + input.opcm = IOPContractsManager(address(mockOPCM)); + + superchainConfig = ISuperchainConfig(makeAddr("superchainConfig")); + superchainProxyAdmin = IProxyAdmin(makeAddr("superchainProxyAdmin")); + prank = makeAddr("prank"); + + input.superchainConfig = superchainConfig; + input.superchainProxyAdmin = superchainProxyAdmin; + input.prank = prank; + + upgradeSuperchainConfig = new UpgradeSuperchainConfig(); + } + + /// @notice Tests that the UpgradeSuperchainConfig script succeeds when called with non-zero input values. + function test_upgrade_succeeds() public { + // UpgradeCalled should be emitted by the prank since it's a delegate call. + vm.expectEmit(address(prank)); + emit UpgradeCalled(address(superchainConfig), address(superchainProxyAdmin)); + upgradeSuperchainConfig.run(input); + } + + /// @notice Tests that the UpgradeSuperchainConfig script reverts when called with zero input values. + function test_run_nullInput_reverts() public { + input.prank = address(0); + vm.expectRevert("UpgradeSuperchainConfig: prank not set"); + upgradeSuperchainConfig.run(input); + input.prank = prank; + + input.opcm = IOPContractsManager(address(0)); + vm.expectRevert("UpgradeSuperchainConfig: opcm not set"); + upgradeSuperchainConfig.run(input); + input.opcm = IOPContractsManager(address(mockOPCM)); + + input.superchainConfig = ISuperchainConfig(address(0)); + vm.expectRevert("UpgradeSuperchainConfig: superchainConfig not set"); + upgradeSuperchainConfig.run(input); + input.superchainConfig = ISuperchainConfig(address(superchainConfig)); + + input.superchainProxyAdmin = IProxyAdmin(address(0)); + vm.expectRevert("UpgradeSuperchainConfig: superchainProxyAdmin not set"); + upgradeSuperchainConfig.run(input); + input.superchainProxyAdmin = IProxyAdmin(address(superchainProxyAdmin)); + } +} From 823ebfb9125f915ed9c3ca050e17bc4eee6799e2 Mon Sep 17 00:00:00 2001 From: "devin-ai-integration[bot]" <158243242+devin-ai-integration[bot]@users.noreply.github.com> Date: Thu, 16 Oct 2025 15:59:16 +0000 Subject: [PATCH 073/117] refactor(test): improve SafeSend test coverage and quality (#17896) * refactor(test): improve SafeSend test coverage and quality - Convert 2 tests to fuzz tests for broader coverage - Add test for zero address recipient edge case - Fuzz ETH amounts from 0 to type(uint128).max - All assertions verify contract self-destruct and balance transfers * Remove uint128 bound from fuzz tests per reviewer feedback * Fix overflow issue: bound fuzz tests to uint192 max Prevents arithmetic overflow in balance calculations while still testing a very large range (~6.3e57 vs total ETH supply ~1.2e26) --------- Co-authored-by: Devin AI <158243242+devin-ai-integration[bot]@users.noreply.github.com> --- .../test/universal/SafeSend.t.sol | 55 +++++++++++++++---- 1 file changed, 43 insertions(+), 12 deletions(-) diff --git a/packages/contracts-bedrock/test/universal/SafeSend.t.sol b/packages/contracts-bedrock/test/universal/SafeSend.t.sol index 2e0ac7abe1e..f1fc16e9fa6 100644 --- a/packages/contracts-bedrock/test/universal/SafeSend.t.sol +++ b/packages/contracts-bedrock/test/universal/SafeSend.t.sol @@ -7,41 +7,72 @@ import { CommonTest } from "test/setup/CommonTest.sol"; /// @title SafeSend_Constructor_Test /// @notice Tests the `constructor` function of the `SafeSend` contract. contract SafeSend_Constructor_Test is CommonTest { - /// @notice Tests that sending to an EOA succeeds. - function test_constructor_toEOA_succeeds() public { + /// @notice Tests that sending various ETH amounts to an EOA succeeds. + /// @param _amount Amount of ETH to send (avoid overflow in balance arithmetic) + function testFuzz_constructor_toEOA_succeeds(uint256 _amount) public { + // Bound to avoid arithmetic overflow in balance calculations + // while still testing a very large range (up to ~6.3e57) + _amount = bound(_amount, 0, type(uint192).max); + assertNotEq(alice, address(0)); assertNotEq(bob, address(0)); assertEq(bob.code.length, 0); - vm.deal(alice, 100 ether); + vm.deal(alice, _amount); uint256 aliceBalanceBefore = alice.balance; uint256 bobBalanceBefore = bob.balance; vm.prank(alice); - SafeSend safeSend = new SafeSend{ value: 100 ether }(payable(bob)); + SafeSend safeSend = new SafeSend{ value: _amount }(payable(bob)); assertEq(address(safeSend).code.length, 0); assertEq(address(safeSend).balance, 0); - assertEq(alice.balance, aliceBalanceBefore - 100 ether); - assertEq(bob.balance, bobBalanceBefore + 100 ether); + assertEq(alice.balance, aliceBalanceBefore - _amount); + assertEq(bob.balance, bobBalanceBefore + _amount); } - /// @notice Tests that sending to a contract succeeds without executing the contract's code - function test_constructor_toContract_succeeds() public { + /// @notice Tests that sending various ETH amounts to a contract with reverting code succeeds. + /// @param _amount Amount of ETH to send (avoid overflow in balance arithmetic) + function testFuzz_constructor_toContract_succeeds(uint256 _amount) public { + // Bound to avoid arithmetic overflow in balance calculations + // while still testing a very large range (up to ~6.3e57) + _amount = bound(_amount, 0, type(uint192).max); + // Etch reverting code into bob vm.etch(bob, hex"fe"); - vm.deal(alice, 100 ether); + vm.deal(alice, _amount); uint256 aliceBalanceBefore = alice.balance; uint256 bobBalanceBefore = bob.balance; vm.prank(alice); - SafeSend safeSend = new SafeSend{ value: 100 ether }(payable(bob)); + SafeSend safeSend = new SafeSend{ value: _amount }(payable(bob)); + + assertEq(address(safeSend).code.length, 0); + assertEq(address(safeSend).balance, 0); + assertEq(alice.balance, aliceBalanceBefore - _amount); + assertEq(bob.balance, bobBalanceBefore + _amount); + } + + /// @notice Tests that sending to address(0) succeeds. + /// @param _amount Amount of ETH to send (avoid overflow in balance arithmetic) + function testFuzz_constructor_toZeroAddress_succeeds(uint256 _amount) public { + // Bound to avoid arithmetic overflow in balance calculations + // while still testing a very large range (up to ~6.3e57) + _amount = bound(_amount, 0, type(uint192).max); + + vm.deal(alice, _amount); + + uint256 aliceBalanceBefore = alice.balance; + uint256 zeroBalanceBefore = address(0).balance; + + vm.prank(alice); + SafeSend safeSend = new SafeSend{ value: _amount }(payable(address(0))); assertEq(address(safeSend).code.length, 0); assertEq(address(safeSend).balance, 0); - assertEq(alice.balance, aliceBalanceBefore - 100 ether); - assertEq(bob.balance, bobBalanceBefore + 100 ether); + assertEq(alice.balance, aliceBalanceBefore - _amount); + assertEq(address(0).balance, zeroBalanceBefore + _amount); } } From 10a76401652cac2cf4ff91fd74927a81c9475c84 Mon Sep 17 00:00:00 2001 From: Axel Kingsley Date: Thu, 16 Oct 2025 11:38:45 -0500 Subject: [PATCH 074/117] supernode: update readme (#17878) Updated README.md to clarify virtual node configuration and metrics routing. --- op-supernode/README.md | 13 ++++++++++++- 1 file changed, 12 insertions(+), 1 deletion(-) diff --git a/op-supernode/README.md b/op-supernode/README.md index f2cf91c2fec..1f70e48ebb6 100644 --- a/op-supernode/README.md +++ b/op-supernode/README.md @@ -67,6 +67,8 @@ Per-chain flags are prefixed: - `-vn.all.` applies to all chains - `-vn..` applies to one chain +All virtual node configuration flags can also be set by environment variable, prefixed with `VN_ALL_` or `VN__`. + Common examples: ```bash # Supernode-level L1 @@ -109,7 +111,16 @@ RPC Clients are created in namespaced paths, so the supernode has a single RPC U ``` calling RPC methods on `/901` will route the method to the Virtual Node for that chain. +### Metrics Routing +Prometheus Metrics are exposed in namespaced paths, so the supernode has a single RPC URL which acts as an RPC router to the virtual nodes +``` +/ + ├── 901/metrics + ├── 902/metrics + └── 903/metrics +``` +All metrics are available at the supernode-configured metrics port. + ### Limitations - P2P disabled for Virtual Nodes (unsafe head sync possible later) - Pause/resume exists but not yet exposed via API -- Virtual Node metrics are untested and expected non-functional currently From 3bdc740ec9d092813a5d26d55708209754068fd0 Mon Sep 17 00:00:00 2001 From: Maurelian Date: Thu, 16 Oct 2025 12:52:19 -0400 Subject: [PATCH 075/117] make all _TestInit contracts abstract (#17889) * make all _TestInit contracts abstract These contracts don't need to run, so they can all be abstract. Local testing suggests this saves about 30 seconds during the build. * Make test setup contracts abstract --- .../contracts-bedrock/test/L1/DataAvailabilityChallenge.t.sol | 2 +- packages/contracts-bedrock/test/L1/ETHLockbox.t.sol | 2 +- .../contracts-bedrock/test/L1/L1CrossDomainMessenger.t.sol | 2 +- packages/contracts-bedrock/test/L1/L1ERC721Bridge.t.sol | 2 +- packages/contracts-bedrock/test/L1/L1StandardBridge.t.sol | 2 +- packages/contracts-bedrock/test/L1/OPContractsManager.t.sol | 2 +- .../test/L1/OPContractsManagerStandardValidator.t.sol | 2 +- packages/contracts-bedrock/test/L1/OptimismPortal2.t.sol | 2 +- packages/contracts-bedrock/test/L1/ProtocolVersions.t.sol | 2 +- packages/contracts-bedrock/test/L1/ProxyAdminOwnedBase.t.sol | 2 +- packages/contracts-bedrock/test/L1/ResourceMetering.t.sol | 2 +- packages/contracts-bedrock/test/L1/SuperchainConfig.t.sol | 2 +- packages/contracts-bedrock/test/L1/SystemConfig.t.sol | 2 +- packages/contracts-bedrock/test/L2/CrossDomainOwnable.t.sol | 2 +- packages/contracts-bedrock/test/L2/CrossDomainOwnable2.t.sol | 2 +- packages/contracts-bedrock/test/L2/CrossDomainOwnable3.t.sol | 2 +- packages/contracts-bedrock/test/L2/CrossL2Inbox.t.sol | 2 +- packages/contracts-bedrock/test/L2/ETHLiquidity.t.sol | 2 +- packages/contracts-bedrock/test/L2/L1Block.t.sol | 2 +- .../contracts-bedrock/test/L2/L2CrossDomainMessenger.t.sol | 2 +- packages/contracts-bedrock/test/L2/L2ERC721Bridge.t.sol | 2 +- packages/contracts-bedrock/test/L2/L2StandardBridge.t.sol | 2 +- .../contracts-bedrock/test/L2/L2StandardBridgeInterop.t.sol | 2 +- .../test/L2/L2ToL2CrossDomainMessenger.t.sol | 2 +- .../contracts-bedrock/test/L2/OptimismMintableERC721.t.sol | 2 +- .../test/L2/OptimismMintableERC721Factory.t.sol | 2 +- .../contracts-bedrock/test/L2/OptimismSuperchainERC20.t.sol | 2 +- .../test/L2/OptimismSuperchainERC20Beacon.t.sol | 2 +- .../test/L2/OptimismSuperchainERC20Factory.t.sol | 2 +- packages/contracts-bedrock/test/L2/SequencerFeeVault.t.sol | 2 +- packages/contracts-bedrock/test/L2/SuperchainERC20.t.sol | 2 +- packages/contracts-bedrock/test/L2/SuperchainETHBridge.t.sol | 2 +- .../contracts-bedrock/test/L2/SuperchainTokenBridge.t.sol | 2 +- packages/contracts-bedrock/test/cannon/MIPS64.t.sol | 2 +- packages/contracts-bedrock/test/cannon/MIPS64Memory.t.sol | 2 +- packages/contracts-bedrock/test/cannon/PreimageOracle.t.sol | 2 +- .../contracts-bedrock/test/dispute/AnchorStateRegistry.t.sol | 2 +- packages/contracts-bedrock/test/dispute/DelayedWETH.t.sol | 2 +- .../contracts-bedrock/test/dispute/DisputeGameFactory.t.sol | 2 +- .../contracts-bedrock/test/dispute/FaultDisputeGame.t.sol | 4 ++-- .../test/dispute/PermissionedDisputeGame.t.sol | 2 +- .../test/dispute/SuperFaultDisputeGame.t.sol | 4 ++-- .../test/dispute/SuperPermissionedDisputeGame.t.sol | 2 +- packages/contracts-bedrock/test/dispute/lib/LibPosition.t.sol | 2 +- .../contracts-bedrock/test/governance/GovernanceToken.t.sol | 2 +- packages/contracts-bedrock/test/governance/MintManager.t.sol | 2 +- packages/contracts-bedrock/test/integration/EventLogger.t.sol | 2 +- .../contracts-bedrock/test/legacy/DeployerWhitelist.t.sol | 2 +- packages/contracts-bedrock/test/legacy/L1BlockNumber.t.sol | 2 +- .../contracts-bedrock/test/legacy/L1ChugSplashProxy.t.sol | 2 +- .../contracts-bedrock/test/legacy/LegacyMintableERC20.t.sol | 2 +- .../contracts-bedrock/test/legacy/ResolvedDelegateProxy.t.sol | 2 +- packages/contracts-bedrock/test/libraries/Blueprint.t.sol | 2 +- packages/contracts-bedrock/test/libraries/Bytes.t.sol | 2 +- packages/contracts-bedrock/test/libraries/DeployUtils.t.sol | 2 +- packages/contracts-bedrock/test/libraries/EOA.t.sol | 2 +- packages/contracts-bedrock/test/libraries/Encoding.t.sol | 2 +- .../contracts-bedrock/test/libraries/GasPayingToken.t.sol | 2 +- packages/contracts-bedrock/test/libraries/Predeploys.t.sol | 2 +- packages/contracts-bedrock/test/libraries/Preinstalls.t.sol | 2 +- packages/contracts-bedrock/test/libraries/SafeCall.t.sol | 2 +- packages/contracts-bedrock/test/libraries/SemverComp.t.sol | 2 +- packages/contracts-bedrock/test/libraries/StaticConfig.t.sol | 2 +- packages/contracts-bedrock/test/libraries/Storage.t.sol | 2 +- .../contracts-bedrock/test/libraries/TransientContext.t.sol | 2 +- .../contracts-bedrock/test/libraries/trie/MerkleTrie.t.sol | 2 +- packages/contracts-bedrock/test/periphery/AssetReceiver.t.sol | 2 +- packages/contracts-bedrock/test/periphery/Transactor.t.sol | 2 +- packages/contracts-bedrock/test/periphery/TransferOnion.t.sol | 2 +- .../contracts-bedrock/test/periphery/drippie/Drippie.t.sol | 2 +- .../test/periphery/drippie/dripchecks/CheckBalanceLow.t.sol | 2 +- .../test/periphery/drippie/dripchecks/CheckSecrets.t.sol | 2 +- .../test/periphery/drippie/dripchecks/CheckTrue.t.sol | 2 +- packages/contracts-bedrock/test/periphery/faucet/Faucet.t.sol | 2 +- .../periphery/faucet/authmodules/AdminFaucetAuthModule.t.sol | 2 +- .../test/periphery/monitoring/DisputeMonitorHelper.t.sol | 2 +- packages/contracts-bedrock/test/safe/DeputyPauseModule.t.sol | 2 +- packages/contracts-bedrock/test/safe/LivenessGuard.t.sol | 2 +- packages/contracts-bedrock/test/safe/LivenessModule.t.sol | 2 +- packages/contracts-bedrock/test/safe/LivenessModule2.t.sol | 2 +- packages/contracts-bedrock/test/safe/SafeSigners.t.sol | 2 +- packages/contracts-bedrock/test/safe/SaferSafes.t.sol | 2 +- packages/contracts-bedrock/test/safe/TimelockGuard.t.sol | 2 +- packages/contracts-bedrock/test/scripts/L2Genesis.t.sol | 2 +- packages/contracts-bedrock/test/scripts/VerifyOPCM.t.sol | 2 +- packages/contracts-bedrock/test/setup/CommonTest.sol | 2 +- packages/contracts-bedrock/test/setup/Events.sol | 2 +- packages/contracts-bedrock/test/setup/FeatureFlags.sol | 2 +- packages/contracts-bedrock/test/setup/Setup.sol | 2 +- .../test/universal/CrossDomainMessenger.t.sol | 2 +- .../test/universal/OptimismMintableERC20.t.sol | 2 +- .../test/universal/OptimismMintableERC20Factory.t.sol | 2 +- packages/contracts-bedrock/test/universal/Proxy.t.sol | 2 +- packages/contracts-bedrock/test/universal/ProxyAdmin.t.sol | 2 +- .../contracts-bedrock/test/universal/StandardBridge.t.sol | 2 +- packages/contracts-bedrock/test/universal/WETH98.t.sol | 2 +- 96 files changed, 98 insertions(+), 98 deletions(-) diff --git a/packages/contracts-bedrock/test/L1/DataAvailabilityChallenge.t.sol b/packages/contracts-bedrock/test/L1/DataAvailabilityChallenge.t.sol index d6a778224d1..b4a1b08100a 100644 --- a/packages/contracts-bedrock/test/L1/DataAvailabilityChallenge.t.sol +++ b/packages/contracts-bedrock/test/L1/DataAvailabilityChallenge.t.sol @@ -13,7 +13,7 @@ import { Preinstalls } from "src/libraries/Preinstalls.sol"; /// @title DataAvailabilityChallenge Test Init /// @notice Test initialization for DataAvailabilityChallenge tests. -contract DataAvailabilityChallenge_TestInit is CommonTest { +abstract contract DataAvailabilityChallenge_TestInit is CommonTest { function setUp() public virtual override { super.enableAltDA(); super.setUp(); diff --git a/packages/contracts-bedrock/test/L1/ETHLockbox.t.sol b/packages/contracts-bedrock/test/L1/ETHLockbox.t.sol index 3e4d3965e9a..3646771051a 100644 --- a/packages/contracts-bedrock/test/L1/ETHLockbox.t.sol +++ b/packages/contracts-bedrock/test/L1/ETHLockbox.t.sol @@ -20,7 +20,7 @@ import { IOptimismPortal2 } from "interfaces/L1/IOptimismPortal2.sol"; /// @title ETHLockbox_TestInit /// @notice Base contract that sets up the testing environment for ETHLockbox tests. -contract ETHLockbox_TestInit is CommonTest { +abstract contract ETHLockbox_TestInit is CommonTest { error InvalidInitialization(); event ETHLocked(IOptimismPortal2 indexed portal, uint256 amount); diff --git a/packages/contracts-bedrock/test/L1/L1CrossDomainMessenger.t.sol b/packages/contracts-bedrock/test/L1/L1CrossDomainMessenger.t.sol index a28e54eafe0..ad1833ebb48 100644 --- a/packages/contracts-bedrock/test/L1/L1CrossDomainMessenger.t.sol +++ b/packages/contracts-bedrock/test/L1/L1CrossDomainMessenger.t.sol @@ -40,7 +40,7 @@ contract L1CrossDomainMessenger_Encoding_Harness { /// @title L1CrossDomainMessenger_TestInit /// @notice Reusable test initialization for L1CrossDomainMessenger tests. -contract L1CrossDomainMessenger_TestInit is CommonTest { +abstract contract L1CrossDomainMessenger_TestInit is CommonTest { /// @dev The receiver address address recipient = address(0xabbaacdc); diff --git a/packages/contracts-bedrock/test/L1/L1ERC721Bridge.t.sol b/packages/contracts-bedrock/test/L1/L1ERC721Bridge.t.sol index 8bf3d99f0f6..c52f9a21e67 100644 --- a/packages/contracts-bedrock/test/L1/L1ERC721Bridge.t.sol +++ b/packages/contracts-bedrock/test/L1/L1ERC721Bridge.t.sol @@ -30,7 +30,7 @@ contract L1ERC721Bridge_TestERC721_Harness is ERC721 { /// @title L1ERC721Bridge_TestInit /// @notice Test contract for L1ERC721Bridge initialization and setup. -contract L1ERC721Bridge_TestInit is CommonTest { +abstract contract L1ERC721Bridge_TestInit is CommonTest { L1ERC721Bridge_TestERC721_Harness internal localToken; L1ERC721Bridge_TestERC721_Harness internal remoteToken; uint256 internal constant tokenId = 1; diff --git a/packages/contracts-bedrock/test/L1/L1StandardBridge.t.sol b/packages/contracts-bedrock/test/L1/L1StandardBridge.t.sol index 03ebb729696..1eac8cfb86e 100644 --- a/packages/contracts-bedrock/test/L1/L1StandardBridge.t.sol +++ b/packages/contracts-bedrock/test/L1/L1StandardBridge.t.sol @@ -25,7 +25,7 @@ import { IProxyAdminOwnedBase } from "interfaces/L1/IProxyAdminOwnedBase.sol"; /// @title L1StandardBridge_TestInit /// @notice Reusable test initialization for `L1StandardBridge` tests. -contract L1StandardBridge_TestInit is CommonTest { +abstract contract L1StandardBridge_TestInit is CommonTest { /// @notice Asserts the expected calls and events for bridging ETH depending on whether the /// bridge call is legacy or not. function _preBridgeETH(bool isLegacy, uint256 value) internal { diff --git a/packages/contracts-bedrock/test/L1/OPContractsManager.t.sol b/packages/contracts-bedrock/test/L1/OPContractsManager.t.sol index bd0951c487e..edf1b531b9c 100644 --- a/packages/contracts-bedrock/test/L1/OPContractsManager.t.sol +++ b/packages/contracts-bedrock/test/L1/OPContractsManager.t.sol @@ -316,7 +316,7 @@ contract OPContractsManager_Upgrade_Harness is CommonTest { /// @title OPContractsManager_TestInit /// @notice Reusable test initialization for `OPContractsManager` tests. -contract OPContractsManager_TestInit is CommonTest { +abstract contract OPContractsManager_TestInit is CommonTest { event GameTypeAdded( uint256 indexed l2ChainId, GameType indexed gameType, IDisputeGame newDisputeGame, IDisputeGame oldDisputeGame ); diff --git a/packages/contracts-bedrock/test/L1/OPContractsManagerStandardValidator.t.sol b/packages/contracts-bedrock/test/L1/OPContractsManagerStandardValidator.t.sol index c516d46843f..f2b1908b485 100644 --- a/packages/contracts-bedrock/test/L1/OPContractsManagerStandardValidator.t.sol +++ b/packages/contracts-bedrock/test/L1/OPContractsManagerStandardValidator.t.sol @@ -77,7 +77,7 @@ contract BadDisputeGameFactoryReturner { /// @title OPContractsManagerStandardValidator_TestInit /// @notice Base contract for `OPContractsManagerStandardValidator` tests, handles common setup. -contract OPContractsManagerStandardValidator_TestInit is CommonTest { +abstract contract OPContractsManagerStandardValidator_TestInit is CommonTest { /// @notice Deploy input that was used to deploy the contracts being tested. IOPContractsManager.DeployInput deployInput; diff --git a/packages/contracts-bedrock/test/L1/OptimismPortal2.t.sol b/packages/contracts-bedrock/test/L1/OptimismPortal2.t.sol index 90691b95afa..b8fe141ddfc 100644 --- a/packages/contracts-bedrock/test/L1/OptimismPortal2.t.sol +++ b/packages/contracts-bedrock/test/L1/OptimismPortal2.t.sol @@ -34,7 +34,7 @@ import { IAnchorStateRegistry } from "interfaces/dispute/IAnchorStateRegistry.so import { IETHLockbox } from "interfaces/L1/IETHLockbox.sol"; import { IProxyAdminOwnedBase } from "interfaces/L1/IProxyAdminOwnedBase.sol"; -contract OptimismPortal2_TestInit is DisputeGameFactory_TestInit { +abstract contract OptimismPortal2_TestInit is DisputeGameFactory_TestInit { address depositor; Types.WithdrawalTransaction _defaultTx; diff --git a/packages/contracts-bedrock/test/L1/ProtocolVersions.t.sol b/packages/contracts-bedrock/test/L1/ProtocolVersions.t.sol index ec5c1ba2286..23c7bce9de9 100644 --- a/packages/contracts-bedrock/test/L1/ProtocolVersions.t.sol +++ b/packages/contracts-bedrock/test/L1/ProtocolVersions.t.sol @@ -11,7 +11,7 @@ import { IProtocolVersions, ProtocolVersion } from "interfaces/L1/IProtocolVersi /// @title ProtocolVersions Test Init /// @notice Test initialization for ProtocolVersions tests. -contract ProtocolVersions_TestInit is CommonTest { +abstract contract ProtocolVersions_TestInit is CommonTest { event ConfigUpdate(uint256 indexed version, IProtocolVersions.UpdateType indexed updateType, bytes data); ProtocolVersion required; diff --git a/packages/contracts-bedrock/test/L1/ProxyAdminOwnedBase.t.sol b/packages/contracts-bedrock/test/L1/ProxyAdminOwnedBase.t.sol index 9a6525998aa..9b56f17eb21 100644 --- a/packages/contracts-bedrock/test/L1/ProxyAdminOwnedBase.t.sol +++ b/packages/contracts-bedrock/test/L1/ProxyAdminOwnedBase.t.sol @@ -50,7 +50,7 @@ contract ProxyAdminOwnedBase_Harness is ProxyAdminOwnedBase { } } -contract ProxyAdminOwnedBase_TestInit is CommonTest { +abstract contract ProxyAdminOwnedBase_TestInit is CommonTest { /// @notice Harness for the `ProxyAdminOwnedBase` contract. ProxyAdminOwnedBase_Harness public harness; diff --git a/packages/contracts-bedrock/test/L1/ResourceMetering.t.sol b/packages/contracts-bedrock/test/L1/ResourceMetering.t.sol index e2c3c085a9f..8e64d609e9e 100644 --- a/packages/contracts-bedrock/test/L1/ResourceMetering.t.sol +++ b/packages/contracts-bedrock/test/L1/ResourceMetering.t.sol @@ -92,7 +92,7 @@ contract CustomMeterUser is ResourceMetering { /// @title ResourceMetering_TestInit /// @notice Reusable test initialization for `ResourceMetering` tests. -contract ResourceMetering_TestInit is Test { +abstract contract ResourceMetering_TestInit is Test { MeterUser internal meter; uint64 initialBlockNum; diff --git a/packages/contracts-bedrock/test/L1/SuperchainConfig.t.sol b/packages/contracts-bedrock/test/L1/SuperchainConfig.t.sol index ce63b4a5037..352d8b5b8fb 100644 --- a/packages/contracts-bedrock/test/L1/SuperchainConfig.t.sol +++ b/packages/contracts-bedrock/test/L1/SuperchainConfig.t.sol @@ -15,7 +15,7 @@ import { IProxyAdminOwnedBase } from "interfaces/L1/IProxyAdminOwnedBase.sol"; /// @title SuperchainConfig_TestInit /// @notice Initialization contract for SuperchainConfig tests. -contract SuperchainConfig_TestInit is CommonTest { +abstract contract SuperchainConfig_TestInit is CommonTest { function setUp() public virtual override { super.setUp(); skipIfForkTest("SuperchainConfig_TestInit: cannot test initialization on forked network"); diff --git a/packages/contracts-bedrock/test/L1/SystemConfig.t.sol b/packages/contracts-bedrock/test/L1/SystemConfig.t.sol index 0903cb2f37c..74668601bb7 100644 --- a/packages/contracts-bedrock/test/L1/SystemConfig.t.sol +++ b/packages/contracts-bedrock/test/L1/SystemConfig.t.sol @@ -20,7 +20,7 @@ import { IProxyAdminOwnedBase } from "interfaces/L1/IProxyAdminOwnedBase.sol"; /// @title SystemConfig Test Init /// @notice Reusable test initialization for SystemConfig tests. -contract SystemConfig_TestInit is CommonTest { +abstract contract SystemConfig_TestInit is CommonTest { event ConfigUpdate(uint256 indexed version, ISystemConfig.UpdateType indexed updateType, bytes data); bytes32 public constant EXAMPLE_FEATURE = "EXAMPLE_FEATURE"; diff --git a/packages/contracts-bedrock/test/L2/CrossDomainOwnable.t.sol b/packages/contracts-bedrock/test/L2/CrossDomainOwnable.t.sol index 238d30f12b2..56c3f74dda1 100644 --- a/packages/contracts-bedrock/test/L2/CrossDomainOwnable.t.sol +++ b/packages/contracts-bedrock/test/L2/CrossDomainOwnable.t.sol @@ -27,7 +27,7 @@ contract XDomainSetter is CrossDomainOwnable { /// @title CrossDomainOwnable_TestInit /// @notice Reusable test initialization for `CrossDomainOwnable` tests. -contract CrossDomainOwnable_TestInit is Test { +abstract contract CrossDomainOwnable_TestInit is Test { XDomainSetter setter; function setUp() public virtual { diff --git a/packages/contracts-bedrock/test/L2/CrossDomainOwnable2.t.sol b/packages/contracts-bedrock/test/L2/CrossDomainOwnable2.t.sol index 0e5fca45101..d11a47a2cff 100644 --- a/packages/contracts-bedrock/test/L2/CrossDomainOwnable2.t.sol +++ b/packages/contracts-bedrock/test/L2/CrossDomainOwnable2.t.sol @@ -27,7 +27,7 @@ contract XDomainSetter2 is CrossDomainOwnable2 { /// @title CrossDomainOwnable2_TestInit /// @notice Reusable test initialization for `CrossDomainOwnable2` tests. -contract CrossDomainOwnable2_TestInit is CommonTest { +abstract contract CrossDomainOwnable2_TestInit is CommonTest { XDomainSetter2 setter; function setUp() public virtual override { diff --git a/packages/contracts-bedrock/test/L2/CrossDomainOwnable3.t.sol b/packages/contracts-bedrock/test/L2/CrossDomainOwnable3.t.sol index b466c3fdf39..60bb098836c 100644 --- a/packages/contracts-bedrock/test/L2/CrossDomainOwnable3.t.sol +++ b/packages/contracts-bedrock/test/L2/CrossDomainOwnable3.t.sol @@ -27,7 +27,7 @@ contract XDomainSetter3 is CrossDomainOwnable3 { /// @title CrossDomainOwnable3_TestInit /// @notice Reusable test initialization for `CrossDomainOwnable3` tests. -contract CrossDomainOwnable3_TestInit is CommonTest { +abstract contract CrossDomainOwnable3_TestInit is CommonTest { XDomainSetter3 setter; /// @notice CrossDomainOwnable3.sol transferOwnership event diff --git a/packages/contracts-bedrock/test/L2/CrossL2Inbox.t.sol b/packages/contracts-bedrock/test/L2/CrossL2Inbox.t.sol index cf791e211b6..323ac2c5b06 100644 --- a/packages/contracts-bedrock/test/L2/CrossL2Inbox.t.sol +++ b/packages/contracts-bedrock/test/L2/CrossL2Inbox.t.sol @@ -41,7 +41,7 @@ contract CrossL2Inbox_ValidateMessageRelayer_Harness is Test { /// @title CrossL2Inbox_Test_Init /// @notice Reusable test initialization for `CrossL2Inbox` tests. -contract CrossL2Inbox_TestInit is CommonTest { +abstract contract CrossL2Inbox_TestInit is CommonTest { event ExecutingMessage(bytes32 indexed msgHash, Identifier id); CrossL2Inbox_ValidateMessageRelayer_Harness public validateMessageRelayer; diff --git a/packages/contracts-bedrock/test/L2/ETHLiquidity.t.sol b/packages/contracts-bedrock/test/L2/ETHLiquidity.t.sol index e1ce20a70ac..fdef5e443c7 100644 --- a/packages/contracts-bedrock/test/L2/ETHLiquidity.t.sol +++ b/packages/contracts-bedrock/test/L2/ETHLiquidity.t.sol @@ -10,7 +10,7 @@ import { InvalidAmount } from "src/libraries/errors/CommonErrors.sol"; /// @title ETHLiquidity_TestInit /// @notice Reusable test initialization for `ETHLiquidity` tests. -contract ETHLiquidity_TestInit is CommonTest { +abstract contract ETHLiquidity_TestInit is CommonTest { /// @notice Emitted when an address burns ETH liquidity. event LiquidityBurned(address indexed caller, uint256 value); diff --git a/packages/contracts-bedrock/test/L2/L1Block.t.sol b/packages/contracts-bedrock/test/L2/L1Block.t.sol index e89219c9e29..8a7d22cae8d 100644 --- a/packages/contracts-bedrock/test/L2/L1Block.t.sol +++ b/packages/contracts-bedrock/test/L2/L1Block.t.sol @@ -11,7 +11,7 @@ import "src/libraries/L1BlockErrors.sol"; /// @title L1Block_ TestInit /// @notice Reusable test initialization for `L1Block` tests. -contract L1Block_TestInit is CommonTest { +abstract contract L1Block_TestInit is CommonTest { address depositor; /// @notice Sets up the test suite. diff --git a/packages/contracts-bedrock/test/L2/L2CrossDomainMessenger.t.sol b/packages/contracts-bedrock/test/L2/L2CrossDomainMessenger.t.sol index 61ce9d09696..de316318cc9 100644 --- a/packages/contracts-bedrock/test/L2/L2CrossDomainMessenger.t.sol +++ b/packages/contracts-bedrock/test/L2/L2CrossDomainMessenger.t.sol @@ -20,7 +20,7 @@ import { IL2ToL1MessagePasser } from "interfaces/L2/IL2ToL1MessagePasser.sol"; /// @title L2CrossDomainMessenger_TestInit /// @notice Reusable test initialization for `L2CrossDomainMessenger` tests. -contract L2CrossDomainMessenger_TestInit is CommonTest { +abstract contract L2CrossDomainMessenger_TestInit is CommonTest { /// @notice Receiver address for testing address recipient = address(0xabbaacdc); } diff --git a/packages/contracts-bedrock/test/L2/L2ERC721Bridge.t.sol b/packages/contracts-bedrock/test/L2/L2ERC721Bridge.t.sol index 4dce986d31a..86266c564ff 100644 --- a/packages/contracts-bedrock/test/L2/L2ERC721Bridge.t.sol +++ b/packages/contracts-bedrock/test/L2/L2ERC721Bridge.t.sol @@ -67,7 +67,7 @@ contract L2ERC721Bridge_NonCompliantERC721_Harness { /// @title L2ERC721Bridge_TestInit /// @notice Reusable test initialization for `L2ERC721Bridge` tests. -contract L2ERC721Bridge_TestInit is CommonTest { +abstract contract L2ERC721Bridge_TestInit is CommonTest { L2ERC721Bridge_TestMintableERC721_Harness internal localToken; L2ERC721Bridge_TestERC721_Harness internal remoteToken; uint256 internal constant tokenId = 1; diff --git a/packages/contracts-bedrock/test/L2/L2StandardBridge.t.sol b/packages/contracts-bedrock/test/L2/L2StandardBridge.t.sol index a3f7297426b..365a8730452 100644 --- a/packages/contracts-bedrock/test/L2/L2StandardBridge.t.sol +++ b/packages/contracts-bedrock/test/L2/L2StandardBridge.t.sol @@ -23,7 +23,7 @@ import { IL2StandardBridge } from "interfaces/L2/IL2StandardBridge.sol"; /// @title L2StandardBridge_TestInit /// @notice Reusable test initialization for `L2StandardBridge` tests. -contract L2StandardBridge_TestInit is CommonTest { +abstract contract L2StandardBridge_TestInit is CommonTest { /// @notice Sets up expected calls and emits for a successful ERC20 withdrawal. function _preBridgeERC20(bool _isLegacy, address _l2Token) internal { // Alice has 100 L2Token diff --git a/packages/contracts-bedrock/test/L2/L2StandardBridgeInterop.t.sol b/packages/contracts-bedrock/test/L2/L2StandardBridgeInterop.t.sol index 50f1f5e34b2..dbe264f37ac 100644 --- a/packages/contracts-bedrock/test/L2/L2StandardBridgeInterop.t.sol +++ b/packages/contracts-bedrock/test/L2/L2StandardBridgeInterop.t.sol @@ -15,7 +15,7 @@ import { IOptimismERC20Factory } from "interfaces/L2/IOptimismERC20Factory.sol"; /// @title L2StandardBridgeInterop_TestInit /// @notice Reusable test initialization for `L2StandardBridgeInterop` tests. -contract L2StandardBridgeInterop_TestInit is CommonTest { +abstract contract L2StandardBridgeInterop_TestInit is CommonTest { /// @notice Emitted when a conversion is made. event Converted(address indexed from, address indexed to, address indexed caller, uint256 amount); diff --git a/packages/contracts-bedrock/test/L2/L2ToL2CrossDomainMessenger.t.sol b/packages/contracts-bedrock/test/L2/L2ToL2CrossDomainMessenger.t.sol index 1fb3d238690..9b2d8642360 100644 --- a/packages/contracts-bedrock/test/L2/L2ToL2CrossDomainMessenger.t.sol +++ b/packages/contracts-bedrock/test/L2/L2ToL2CrossDomainMessenger.t.sol @@ -63,7 +63,7 @@ contract L2ToL2CrossDomainMessenger_WithModifiableTransientStorage_Harness is L2 /// @title L2ToL2CrossDomainMessenger_TestInit /// @notice Reusable test initialization for `L2ToL2CrossDomainMessenger` tests. -contract L2ToL2CrossDomainMessenger_TestInit is Test { +abstract contract L2ToL2CrossDomainMessenger_TestInit is Test { address internal foundryVMAddress = 0x7109709ECfa91a80626fF3989D68f67F5b1DD12D; /// @notice L2ToL2CrossDomainMessenger contract instance with modifiable transient storage. diff --git a/packages/contracts-bedrock/test/L2/OptimismMintableERC721.t.sol b/packages/contracts-bedrock/test/L2/OptimismMintableERC721.t.sol index 42420046af5..d66a702d01a 100644 --- a/packages/contracts-bedrock/test/L2/OptimismMintableERC721.t.sol +++ b/packages/contracts-bedrock/test/L2/OptimismMintableERC721.t.sol @@ -10,7 +10,7 @@ import { OptimismMintableERC721, IOptimismMintableERC721 } from "src/L2/Optimism /// @title OptimismMintableERC721_TestInit /// @notice Reusable test initialization for `OptimismMintableERC721` tests. -contract OptimismMintableERC721_TestInit is CommonTest { +abstract contract OptimismMintableERC721_TestInit is CommonTest { ERC721 internal L1NFT; OptimismMintableERC721 internal L2NFT; diff --git a/packages/contracts-bedrock/test/L2/OptimismMintableERC721Factory.t.sol b/packages/contracts-bedrock/test/L2/OptimismMintableERC721Factory.t.sol index 9da1cc48723..76e1ca7cdc9 100644 --- a/packages/contracts-bedrock/test/L2/OptimismMintableERC721Factory.t.sol +++ b/packages/contracts-bedrock/test/L2/OptimismMintableERC721Factory.t.sol @@ -6,7 +6,7 @@ import { OptimismMintableERC721 } from "src/L2/OptimismMintableERC721.sol"; /// @title OptimismMintableERC721Factory_TestInit /// @notice Reusable test initialization for `OptimismMintableERC721Factory` tests. -contract OptimismMintableERC721Factory_TestInit is CommonTest { +abstract contract OptimismMintableERC721Factory_TestInit is CommonTest { event OptimismMintableERC721Created(address indexed localToken, address indexed remoteToken, address deployer); function calculateTokenAddress( diff --git a/packages/contracts-bedrock/test/L2/OptimismSuperchainERC20.t.sol b/packages/contracts-bedrock/test/L2/OptimismSuperchainERC20.t.sol index b59bd897fee..3479ec0330d 100644 --- a/packages/contracts-bedrock/test/L2/OptimismSuperchainERC20.t.sol +++ b/packages/contracts-bedrock/test/L2/OptimismSuperchainERC20.t.sol @@ -23,7 +23,7 @@ import { DeployUtils } from "scripts/libraries/DeployUtils.sol"; /// @title OptimismSuperchainERC20_TestInit /// @notice Reusable test initialization for `OptimismSuperchainERC20` tests. -contract OptimismSuperchainERC20_TestInit is Test { +abstract contract OptimismSuperchainERC20_TestInit is Test { address internal constant ZERO_ADDRESS = address(0); address internal constant REMOTE_TOKEN = address(0x123); string internal constant NAME = "OptimismSuperchainERC20"; diff --git a/packages/contracts-bedrock/test/L2/OptimismSuperchainERC20Beacon.t.sol b/packages/contracts-bedrock/test/L2/OptimismSuperchainERC20Beacon.t.sol index ed6a223a4d7..261ed1da68c 100644 --- a/packages/contracts-bedrock/test/L2/OptimismSuperchainERC20Beacon.t.sol +++ b/packages/contracts-bedrock/test/L2/OptimismSuperchainERC20Beacon.t.sol @@ -10,7 +10,7 @@ import { IBeacon } from "@openzeppelin/contracts/proxy/beacon/IBeacon.sol"; /// @title OptimismSuperchainERC20Beacon_TestInit /// @notice Reusable test initialization for `OptimismSuperchainERC20Beacon` tests. -contract OptimismSuperchainERC20Beacon_TestInit is CommonTest { +abstract contract OptimismSuperchainERC20Beacon_TestInit is CommonTest { /// @notice Sets up the test suite. function setUp() public override { // Skip the test until OptimismSuperchainERC20Beacon is integrated again diff --git a/packages/contracts-bedrock/test/L2/OptimismSuperchainERC20Factory.t.sol b/packages/contracts-bedrock/test/L2/OptimismSuperchainERC20Factory.t.sol index ef742a757fe..f2a87f9e141 100644 --- a/packages/contracts-bedrock/test/L2/OptimismSuperchainERC20Factory.t.sol +++ b/packages/contracts-bedrock/test/L2/OptimismSuperchainERC20Factory.t.sol @@ -13,7 +13,7 @@ import { IERC20Metadata } from "@openzeppelin/contracts/interfaces/IERC20Metadat /// @title OptimismSuperchainERC20Factory_TestInit /// @notice Reusable test initialization for `OptimismSuperchainERC20Factory` tests. -contract OptimismSuperchainERC20Factory_TestInit is CommonTest { +abstract contract OptimismSuperchainERC20Factory_TestInit is CommonTest { using Bytes32AddressLib for bytes32; event OptimismSuperchainERC20Created( diff --git a/packages/contracts-bedrock/test/L2/SequencerFeeVault.t.sol b/packages/contracts-bedrock/test/L2/SequencerFeeVault.t.sol index 55c5a7eb729..ba72e946990 100644 --- a/packages/contracts-bedrock/test/L2/SequencerFeeVault.t.sol +++ b/packages/contracts-bedrock/test/L2/SequencerFeeVault.t.sol @@ -17,7 +17,7 @@ import { DeployUtils } from "scripts/libraries/DeployUtils.sol"; /// @title SequencerFeeVault_TestInit /// @notice Reusable test initialization for `SequencerFeeVault` tests. -contract SequencerFeeVault_TestInit is CommonTest { +abstract contract SequencerFeeVault_TestInit is CommonTest { address recipient; /// @dev Sets up the test suite. diff --git a/packages/contracts-bedrock/test/L2/SuperchainERC20.t.sol b/packages/contracts-bedrock/test/L2/SuperchainERC20.t.sol index 65e01de70cd..b409c2c42bd 100644 --- a/packages/contracts-bedrock/test/L2/SuperchainERC20.t.sol +++ b/packages/contracts-bedrock/test/L2/SuperchainERC20.t.sol @@ -16,7 +16,7 @@ import { MockSuperchainERC20Implementation } from "test/mocks/SuperchainERC20Imp /// @title SuperchainERC20_TestInit /// @notice Reusable test initialization for `SuperchainERC20` tests. -contract SuperchainERC20_TestInit is Test { +abstract contract SuperchainERC20_TestInit is Test { address internal constant ZERO_ADDRESS = address(0); address internal constant SUPERCHAIN_TOKEN_BRIDGE = Predeploys.SUPERCHAIN_TOKEN_BRIDGE; address internal constant MESSENGER = Predeploys.L2_TO_L2_CROSS_DOMAIN_MESSENGER; diff --git a/packages/contracts-bedrock/test/L2/SuperchainETHBridge.t.sol b/packages/contracts-bedrock/test/L2/SuperchainETHBridge.t.sol index 0fbfd22d29d..7d10c2d86c7 100644 --- a/packages/contracts-bedrock/test/L2/SuperchainETHBridge.t.sol +++ b/packages/contracts-bedrock/test/L2/SuperchainETHBridge.t.sol @@ -15,7 +15,7 @@ import { IL2ToL2CrossDomainMessenger } from "interfaces/L2/IL2ToL2CrossDomainMes /// @title SuperchainETHBridge_TestInit /// @notice Reusable test initialization for `SuperchainETHBridge` tests. -contract SuperchainETHBridge_TestInit is CommonTest { +abstract contract SuperchainETHBridge_TestInit is CommonTest { event SendETH(address indexed from, address indexed to, uint256 amount, uint256 destination); event RelayETH(address indexed from, address indexed to, uint256 amount, uint256 source); diff --git a/packages/contracts-bedrock/test/L2/SuperchainTokenBridge.t.sol b/packages/contracts-bedrock/test/L2/SuperchainTokenBridge.t.sol index 389244f01ad..059d66cc9c1 100644 --- a/packages/contracts-bedrock/test/L2/SuperchainTokenBridge.t.sol +++ b/packages/contracts-bedrock/test/L2/SuperchainTokenBridge.t.sol @@ -18,7 +18,7 @@ import { MockSuperchainERC20Implementation } from "test/mocks/SuperchainERC20Imp /// @title SuperchainTokenBridge_TestInit /// @notice Reusable test initialization for `SuperchainTokenBridge` tests. -contract SuperchainTokenBridge_TestInit is Test { +abstract contract SuperchainTokenBridge_TestInit is Test { address internal constant ZERO_ADDRESS = address(0); string internal constant NAME = "SuperchainERC20"; string internal constant SYMBOL = "OSE"; diff --git a/packages/contracts-bedrock/test/cannon/MIPS64.t.sol b/packages/contracts-bedrock/test/cannon/MIPS64.t.sol index fdcf0671ab2..6e3caaa1695 100644 --- a/packages/contracts-bedrock/test/cannon/MIPS64.t.sol +++ b/packages/contracts-bedrock/test/cannon/MIPS64.t.sol @@ -10,7 +10,7 @@ import { IMIPS64 } from "interfaces/cannon/IMIPS64.sol"; /// @title MIPS64_TestInit /// @notice Reusable test initialization for `MIPS64` tests. -contract MIPS64_TestInit is Test { +abstract contract MIPS64_TestInit is Test { IPreimageOracle oracle; // Store some data about acceptable versions diff --git a/packages/contracts-bedrock/test/cannon/MIPS64Memory.t.sol b/packages/contracts-bedrock/test/cannon/MIPS64Memory.t.sol index 2173d1e6b75..1c816410ea8 100644 --- a/packages/contracts-bedrock/test/cannon/MIPS64Memory.t.sol +++ b/packages/contracts-bedrock/test/cannon/MIPS64Memory.t.sol @@ -39,7 +39,7 @@ contract MIPS64MemoryWithCalldata { /// @title MIPS64Memory_TestInit /// @notice Reusable test initialization for `MIPS64Memory` tests. -contract MIPS64Memory_TestInit is CommonTest { +abstract contract MIPS64Memory_TestInit is CommonTest { MIPS64MemoryWithCalldata mem; error InvalidAddress(); diff --git a/packages/contracts-bedrock/test/cannon/PreimageOracle.t.sol b/packages/contracts-bedrock/test/cannon/PreimageOracle.t.sol index cc487bc92ee..59cef2f3653 100644 --- a/packages/contracts-bedrock/test/cannon/PreimageOracle.t.sol +++ b/packages/contracts-bedrock/test/cannon/PreimageOracle.t.sol @@ -38,7 +38,7 @@ function precompilePreimageKey(address _precompile, uint64 _gas, bytes memory _i /// @title PreimageOracle_TestInit /// @notice Reusable test initialization for `PreimageOracle` tests. -contract PreimageOracle_TestInit is Test { +abstract contract PreimageOracle_TestInit is Test { /// @notice The PreimageOracle contract to test. IPreimageOracle internal oracle; diff --git a/packages/contracts-bedrock/test/dispute/AnchorStateRegistry.t.sol b/packages/contracts-bedrock/test/dispute/AnchorStateRegistry.t.sol index 21ad6316fd4..bb52883f063 100644 --- a/packages/contracts-bedrock/test/dispute/AnchorStateRegistry.t.sol +++ b/packages/contracts-bedrock/test/dispute/AnchorStateRegistry.t.sol @@ -16,7 +16,7 @@ import { IProxyAdminOwnedBase } from "interfaces/L1/IProxyAdminOwnedBase.sol"; /// @title AnchorStateRegistry_TestInit /// @notice Reusable test initialization for `AnchorStateRegistry` tests. -contract AnchorStateRegistry_TestInit is BaseFaultDisputeGame_TestInit { +abstract contract AnchorStateRegistry_TestInit is BaseFaultDisputeGame_TestInit { /// @dev A valid l2BlockNumber that comes after the current anchor root block. uint256 validL2BlockNumber; diff --git a/packages/contracts-bedrock/test/dispute/DelayedWETH.t.sol b/packages/contracts-bedrock/test/dispute/DelayedWETH.t.sol index 7dc30873dbb..15ec4e7c2d7 100644 --- a/packages/contracts-bedrock/test/dispute/DelayedWETH.t.sol +++ b/packages/contracts-bedrock/test/dispute/DelayedWETH.t.sol @@ -53,7 +53,7 @@ contract DelayedWETH_FallbackReverter_Harness { /// @title DelayedWETH_TestInit /// @notice Reusable test initialization for `DelayedWETH` tests. -contract DelayedWETH_TestInit is CommonTest { +abstract contract DelayedWETH_TestInit is CommonTest { event Approval(address indexed src, address indexed guy, uint256 wad); event Transfer(address indexed src, address indexed dst, uint256 wad); event Deposit(address indexed dst, uint256 wad); diff --git a/packages/contracts-bedrock/test/dispute/DisputeGameFactory.t.sol b/packages/contracts-bedrock/test/dispute/DisputeGameFactory.t.sol index 403f5b14288..9822612a61c 100644 --- a/packages/contracts-bedrock/test/dispute/DisputeGameFactory.t.sol +++ b/packages/contracts-bedrock/test/dispute/DisputeGameFactory.t.sol @@ -48,7 +48,7 @@ contract DisputeGameFactory_FakeClone_Harness { /// @title DisputeGameFactory_TestInit /// @notice Reusable test initialization for `DisputeGameFactory` tests. -contract DisputeGameFactory_TestInit is CommonTest { +abstract contract DisputeGameFactory_TestInit is CommonTest { DisputeGameFactory_FakeClone_Harness fakeClone; event DisputeGameCreated(address indexed disputeProxy, GameType indexed gameType, Claim indexed rootClaim); diff --git a/packages/contracts-bedrock/test/dispute/FaultDisputeGame.t.sol b/packages/contracts-bedrock/test/dispute/FaultDisputeGame.t.sol index a8a4b99e479..026c1187e3f 100644 --- a/packages/contracts-bedrock/test/dispute/FaultDisputeGame.t.sol +++ b/packages/contracts-bedrock/test/dispute/FaultDisputeGame.t.sol @@ -66,7 +66,7 @@ function _changeClaimStatus(Claim _claim, VMStatus _status) pure returns (Claim /// @title BaseFaultDisputeGame_TestInit /// @notice Base test initializer that can be used by other contracts outside of this test suite. -contract BaseFaultDisputeGame_TestInit is DisputeGameFactory_TestInit { +abstract contract BaseFaultDisputeGame_TestInit is DisputeGameFactory_TestInit { /// @dev The type of the game being tested. GameType internal immutable GAME_TYPE = GameTypes.CANNON; @@ -143,7 +143,7 @@ contract BaseFaultDisputeGame_TestInit is DisputeGameFactory_TestInit { /// @title FaultDisputeGame_TestInit /// @notice Reusable test initialization for `FaultDisputeGame` tests. -contract FaultDisputeGame_TestInit is BaseFaultDisputeGame_TestInit { +abstract contract FaultDisputeGame_TestInit is BaseFaultDisputeGame_TestInit { /// @dev The root claim of the game. Claim internal ROOT_CLAIM; /// @dev An arbitrary root claim for testing. diff --git a/packages/contracts-bedrock/test/dispute/PermissionedDisputeGame.t.sol b/packages/contracts-bedrock/test/dispute/PermissionedDisputeGame.t.sol index 4fcf6f5b99b..f2876bc39da 100644 --- a/packages/contracts-bedrock/test/dispute/PermissionedDisputeGame.t.sol +++ b/packages/contracts-bedrock/test/dispute/PermissionedDisputeGame.t.sol @@ -16,7 +16,7 @@ import { IPermissionedDisputeGame } from "interfaces/dispute/IPermissionedDisput /// @title PermissionedDisputeGame_TestInit /// @notice Reusable test initialization for `PermissionedDisputeGame` tests. -contract PermissionedDisputeGame_TestInit is DisputeGameFactory_TestInit { +abstract contract PermissionedDisputeGame_TestInit is DisputeGameFactory_TestInit { /// @notice The type of the game being tested. GameType internal immutable GAME_TYPE = GameTypes.PERMISSIONED_CANNON; /// @notice Mock proposer key diff --git a/packages/contracts-bedrock/test/dispute/SuperFaultDisputeGame.t.sol b/packages/contracts-bedrock/test/dispute/SuperFaultDisputeGame.t.sol index 48e839adb9b..be97b1c1bb2 100644 --- a/packages/contracts-bedrock/test/dispute/SuperFaultDisputeGame.t.sol +++ b/packages/contracts-bedrock/test/dispute/SuperFaultDisputeGame.t.sol @@ -58,7 +58,7 @@ contract ClaimCreditReenter { /// @title BaseSuperFaultDisputeGame_TestInit /// @notice Base test initializer that can be used by other contracts outside of this test suite. -contract BaseSuperFaultDisputeGame_TestInit is DisputeGameFactory_TestInit { +abstract contract BaseSuperFaultDisputeGame_TestInit is DisputeGameFactory_TestInit { /// @dev The type of the game being tested. GameType internal immutable GAME_TYPE = GameTypes.SUPER_CANNON; @@ -127,7 +127,7 @@ contract BaseSuperFaultDisputeGame_TestInit is DisputeGameFactory_TestInit { /// @title SuperFaultDisputeGame_TestInit /// @notice Reusable test initialization for `SuperFaultDisputeGame` tests. -contract SuperFaultDisputeGame_TestInit is BaseSuperFaultDisputeGame_TestInit { +abstract contract SuperFaultDisputeGame_TestInit is BaseSuperFaultDisputeGame_TestInit { /// @dev The root claim of the game. Claim internal ROOT_CLAIM; diff --git a/packages/contracts-bedrock/test/dispute/SuperPermissionedDisputeGame.t.sol b/packages/contracts-bedrock/test/dispute/SuperPermissionedDisputeGame.t.sol index 69369c18e47..14c13330faa 100644 --- a/packages/contracts-bedrock/test/dispute/SuperPermissionedDisputeGame.t.sol +++ b/packages/contracts-bedrock/test/dispute/SuperPermissionedDisputeGame.t.sol @@ -14,7 +14,7 @@ import { IPermissionedDisputeGame } from "interfaces/dispute/IPermissionedDisput /// @title SuperPermissionedDisputeGame_TestInit /// @notice Reusable test initialization for `SuperPermissionedDisputeGame` tests. -contract SuperPermissionedDisputeGame_TestInit is DisputeGameFactory_TestInit { +abstract contract SuperPermissionedDisputeGame_TestInit is DisputeGameFactory_TestInit { /// @notice The type of the game being tested. GameType internal constant GAME_TYPE = GameType.wrap(5); /// @notice Mock proposer key diff --git a/packages/contracts-bedrock/test/dispute/lib/LibPosition.t.sol b/packages/contracts-bedrock/test/dispute/lib/LibPosition.t.sol index b14975378a5..8d392fa49c5 100644 --- a/packages/contracts-bedrock/test/dispute/lib/LibPosition.t.sol +++ b/packages/contracts-bedrock/test/dispute/lib/LibPosition.t.sol @@ -7,7 +7,7 @@ import "src/dispute/lib/Types.sol"; /// @title LibPosition_TestInit /// @notice Reusable test initialization for `LibPosition` tests. -contract LibPosition_TestInit is Test { +abstract contract LibPosition_TestInit is Test { /// @dev Assumes a MAX depth of 126 for the Position type. Any greater depth can cause /// overflows. /// @dev At the lowest level of the tree, this allows for 2 ** 126 leaves. In reality, the max diff --git a/packages/contracts-bedrock/test/governance/GovernanceToken.t.sol b/packages/contracts-bedrock/test/governance/GovernanceToken.t.sol index b046f30f71a..237f13fb094 100644 --- a/packages/contracts-bedrock/test/governance/GovernanceToken.t.sol +++ b/packages/contracts-bedrock/test/governance/GovernanceToken.t.sol @@ -6,7 +6,7 @@ import { CommonTest } from "test/setup/CommonTest.sol"; /// @title GovernanceToken_TestInit /// @notice Reusable test initialization for `GovernanceToken` tests. -contract GovernanceToken_TestInit is CommonTest { +abstract contract GovernanceToken_TestInit is CommonTest { address owner; address rando; diff --git a/packages/contracts-bedrock/test/governance/MintManager.t.sol b/packages/contracts-bedrock/test/governance/MintManager.t.sol index 9fc2593e794..b7e1f1a8b14 100644 --- a/packages/contracts-bedrock/test/governance/MintManager.t.sol +++ b/packages/contracts-bedrock/test/governance/MintManager.t.sol @@ -11,7 +11,7 @@ import { DeployUtils } from "scripts/libraries/DeployUtils.sol"; /// @title MintManager_TestInit /// @notice Reusable test initialization for `MintManager` tests. -contract MintManager_TestInit is CommonTest { +abstract contract MintManager_TestInit is CommonTest { address constant owner = address(0x1234); address constant rando = address(0x5678); IGovernanceToken internal gov; diff --git a/packages/contracts-bedrock/test/integration/EventLogger.t.sol b/packages/contracts-bedrock/test/integration/EventLogger.t.sol index 647ae1c12a5..51ecccc1a4e 100644 --- a/packages/contracts-bedrock/test/integration/EventLogger.t.sol +++ b/packages/contracts-bedrock/test/integration/EventLogger.t.sol @@ -15,7 +15,7 @@ import { CrossL2Inbox } from "src/L2/CrossL2Inbox.sol"; /// @title EventLogger_TestInit /// @notice Reusable test initialization for `EventLogger` tests. -contract EventLogger_TestInit is Test { +abstract contract EventLogger_TestInit is Test { event ExecutingMessage(bytes32 indexed msgHash, ImplIdentifier id); EventLogger eventLogger; diff --git a/packages/contracts-bedrock/test/legacy/DeployerWhitelist.t.sol b/packages/contracts-bedrock/test/legacy/DeployerWhitelist.t.sol index 1703e560077..764e9ef8897 100644 --- a/packages/contracts-bedrock/test/legacy/DeployerWhitelist.t.sol +++ b/packages/contracts-bedrock/test/legacy/DeployerWhitelist.t.sol @@ -10,7 +10,7 @@ import { DeployUtils } from "scripts/libraries/DeployUtils.sol"; /// @title DeployerWhitelist_TestInit /// @notice Reusable test initialization for `DeployerWhitelist` tests. -contract DeployerWhitelist_TestInit is Test { +abstract contract DeployerWhitelist_TestInit is Test { IDeployerWhitelist list; address owner = address(12345); diff --git a/packages/contracts-bedrock/test/legacy/L1BlockNumber.t.sol b/packages/contracts-bedrock/test/legacy/L1BlockNumber.t.sol index 19c0beb2a4b..d536ad006e1 100644 --- a/packages/contracts-bedrock/test/legacy/L1BlockNumber.t.sol +++ b/packages/contracts-bedrock/test/legacy/L1BlockNumber.t.sol @@ -14,7 +14,7 @@ import { IL1Block } from "interfaces/L2/IL1Block.sol"; /// @title L1BlockNumber_TestInit /// @notice Reusable test initialization for `L1BlockNumber` tests. -contract L1BlockNumber_TestInit is Test { +abstract contract L1BlockNumber_TestInit is Test { IL1Block lb; IL1BlockNumber bn; diff --git a/packages/contracts-bedrock/test/legacy/L1ChugSplashProxy.t.sol b/packages/contracts-bedrock/test/legacy/L1ChugSplashProxy.t.sol index bf7888e8502..aebc7e30725 100644 --- a/packages/contracts-bedrock/test/legacy/L1ChugSplashProxy.t.sol +++ b/packages/contracts-bedrock/test/legacy/L1ChugSplashProxy.t.sol @@ -47,7 +47,7 @@ contract L1ChugSplashProxy_Implementation_Harness { /// @title L1ChugSplashProxy_TestInit /// @notice Reusable test initialization for `L1ChugSplashProxy` tests. -contract L1ChugSplashProxy_TestInit is Test { +abstract contract L1ChugSplashProxy_TestInit is Test { IL1ChugSplashProxy proxy; address impl; address owner = makeAddr("owner"); diff --git a/packages/contracts-bedrock/test/legacy/LegacyMintableERC20.t.sol b/packages/contracts-bedrock/test/legacy/LegacyMintableERC20.t.sol index f4be7820bdf..d4f1dd7d10d 100644 --- a/packages/contracts-bedrock/test/legacy/LegacyMintableERC20.t.sol +++ b/packages/contracts-bedrock/test/legacy/LegacyMintableERC20.t.sol @@ -9,7 +9,7 @@ import { ILegacyMintableERC20 } from "interfaces/legacy/ILegacyMintableERC20.sol /// @title LegacyMintableERC20_TestInit /// @notice Reusable test initialization for `LegacyMintableERC20` tests. -contract LegacyMintableERC20_TestInit is CommonTest { +abstract contract LegacyMintableERC20_TestInit is CommonTest { LegacyMintableERC20 legacyMintableERC20; function setUp() public override { diff --git a/packages/contracts-bedrock/test/legacy/ResolvedDelegateProxy.t.sol b/packages/contracts-bedrock/test/legacy/ResolvedDelegateProxy.t.sol index a7358fec43c..9df666980ae 100644 --- a/packages/contracts-bedrock/test/legacy/ResolvedDelegateProxy.t.sol +++ b/packages/contracts-bedrock/test/legacy/ResolvedDelegateProxy.t.sol @@ -23,7 +23,7 @@ contract ResolvedDelegateProxy_SimpleImplementation_Harness { /// @title ResolvedDelegateProxy_TestInit /// @notice Reusable test initialization for `ResolvedDelegateProxy` tests. -contract ResolvedDelegateProxy_TestInit is Test { +abstract contract ResolvedDelegateProxy_TestInit is Test { IAddressManager internal addressManager; ResolvedDelegateProxy_SimpleImplementation_Harness internal impl; ResolvedDelegateProxy_SimpleImplementation_Harness internal proxy; diff --git a/packages/contracts-bedrock/test/libraries/Blueprint.t.sol b/packages/contracts-bedrock/test/libraries/Blueprint.t.sol index ac3ae1248eb..433271f4cf3 100644 --- a/packages/contracts-bedrock/test/libraries/Blueprint.t.sol +++ b/packages/contracts-bedrock/test/libraries/Blueprint.t.sol @@ -42,7 +42,7 @@ contract BlueprintHarness { /// @title Blueprint_TestInit /// @notice Reusable test initialization for `Blueprint` tests. -contract Blueprint_TestInit is Test { +abstract contract Blueprint_TestInit is Test { BlueprintHarness blueprint; function setUp() public { diff --git a/packages/contracts-bedrock/test/libraries/Bytes.t.sol b/packages/contracts-bedrock/test/libraries/Bytes.t.sol index 1ac412f8b7a..aa919f19a0b 100644 --- a/packages/contracts-bedrock/test/libraries/Bytes.t.sol +++ b/packages/contracts-bedrock/test/libraries/Bytes.t.sol @@ -15,7 +15,7 @@ contract Bytes_Harness { /// @title Bytes_TestInit /// @notice Reusable test initialization for `Bytes` tests. -contract Bytes_TestInit is Test { +abstract contract Bytes_TestInit is Test { Bytes_Harness harness; /// @notice Manually checks equality of two dynamic `bytes` arrays in memory. diff --git a/packages/contracts-bedrock/test/libraries/DeployUtils.t.sol b/packages/contracts-bedrock/test/libraries/DeployUtils.t.sol index 976cbb0a61c..1b1af20cf53 100644 --- a/packages/contracts-bedrock/test/libraries/DeployUtils.t.sol +++ b/packages/contracts-bedrock/test/libraries/DeployUtils.t.sol @@ -10,7 +10,7 @@ import { Solarray } from "scripts/libraries/Solarray.sol"; /// @title DeployUtils_TestInit /// @notice Reusable test initialization for `DeployUtils` tests. -contract DeployUtils_TestInit is Test { +abstract contract DeployUtils_TestInit is Test { /// @notice Helper function to test the revert message of assertUniqueAddresses with duplicate /// addresses. /// @dev This function only exists because expectRevert only accepts a calldata argument but diff --git a/packages/contracts-bedrock/test/libraries/EOA.t.sol b/packages/contracts-bedrock/test/libraries/EOA.t.sol index 823f71a03fb..69a894c90a6 100644 --- a/packages/contracts-bedrock/test/libraries/EOA.t.sol +++ b/packages/contracts-bedrock/test/libraries/EOA.t.sol @@ -19,7 +19,7 @@ contract EOA_Harness { /// @title EOA_TestInit /// @notice Reusable test initialization for `EOA` tests. -contract EOA_TestInit is Test { +abstract contract EOA_TestInit is Test { EOA_Harness harness; /// @notice Sets up the test. diff --git a/packages/contracts-bedrock/test/libraries/Encoding.t.sol b/packages/contracts-bedrock/test/libraries/Encoding.t.sol index 9ae152ae9f6..0402e54ebbd 100644 --- a/packages/contracts-bedrock/test/libraries/Encoding.t.sol +++ b/packages/contracts-bedrock/test/libraries/Encoding.t.sol @@ -32,7 +32,7 @@ contract Encoding_Harness { /// @title Encoding_TestInit /// @notice Reusable test initialization for `Encoding` tests. -contract Encoding_TestInit is CommonTest { +abstract contract Encoding_TestInit is CommonTest { Encoding_Harness encoding; function setUp() public override { diff --git a/packages/contracts-bedrock/test/libraries/GasPayingToken.t.sol b/packages/contracts-bedrock/test/libraries/GasPayingToken.t.sol index e495a758b8f..c20ade9a9d6 100644 --- a/packages/contracts-bedrock/test/libraries/GasPayingToken.t.sol +++ b/packages/contracts-bedrock/test/libraries/GasPayingToken.t.sol @@ -15,7 +15,7 @@ contract GasPayingToken_Harness { /// @title GasPayingToken_TestInit /// @notice Reusable test initialization for `GasPayingToken` tests. -contract GasPayingToken_TestInit is Test { +abstract contract GasPayingToken_TestInit is Test { GasPayingToken_Harness harness; function setUp() public { diff --git a/packages/contracts-bedrock/test/libraries/Predeploys.t.sol b/packages/contracts-bedrock/test/libraries/Predeploys.t.sol index bbce4e1d7d6..548c178050f 100644 --- a/packages/contracts-bedrock/test/libraries/Predeploys.t.sol +++ b/packages/contracts-bedrock/test/libraries/Predeploys.t.sol @@ -12,7 +12,7 @@ import { Fork } from "scripts/libraries/Config.sol"; /// @title Predeploys_TestInit /// @notice Reusable test initialization for `Predeploys` tests. -contract Predeploys_TestInit is CommonTest { +abstract contract Predeploys_TestInit is CommonTest { ////////////////////////////////////////////////////// /// Internal helpers ////////////////////////////////////////////////////// diff --git a/packages/contracts-bedrock/test/libraries/Preinstalls.t.sol b/packages/contracts-bedrock/test/libraries/Preinstalls.t.sol index 3941ed83bb1..2a2592dbe05 100644 --- a/packages/contracts-bedrock/test/libraries/Preinstalls.t.sol +++ b/packages/contracts-bedrock/test/libraries/Preinstalls.t.sol @@ -8,7 +8,7 @@ import { IEIP712 } from "interfaces/universal/IEIP712.sol"; /// @title Preinstalls_TestInit /// @notice Reusable test initialization for `Preinstalls` tests. -contract Preinstalls_TestInit is CommonTest { +abstract contract Preinstalls_TestInit is CommonTest { function assertPreinstall(address _addr, bytes memory _code) internal view { assertNotEq(_code.length, 0, "must have code"); assertNotEq(_addr.code.length, 0, "deployed preinstall account must have code"); diff --git a/packages/contracts-bedrock/test/libraries/SafeCall.t.sol b/packages/contracts-bedrock/test/libraries/SafeCall.t.sol index 1e9db1f4372..084c601cbcb 100644 --- a/packages/contracts-bedrock/test/libraries/SafeCall.t.sol +++ b/packages/contracts-bedrock/test/libraries/SafeCall.t.sol @@ -31,7 +31,7 @@ contract SimpleSafeCaller { /// @title SafeCall_TestInit /// @notice Reusable test initialization for `SafeCall` tests. -contract SafeCall_TestInit is Test { +abstract contract SafeCall_TestInit is Test { /// @notice Helper function to deduplicate code. Makes all assumptions required for these /// tests. function assumeNot(address _addr) internal { diff --git a/packages/contracts-bedrock/test/libraries/SemverComp.t.sol b/packages/contracts-bedrock/test/libraries/SemverComp.t.sol index 3bdf2b2cc9b..b182af378ff 100644 --- a/packages/contracts-bedrock/test/libraries/SemverComp.t.sol +++ b/packages/contracts-bedrock/test/libraries/SemverComp.t.sol @@ -26,7 +26,7 @@ contract SemverComp_Harness { /// @title SemverComp_TestInit /// @notice Reusable test initialization for `SemverComp` tests. -contract SemverComp_TestInit is Test { +abstract contract SemverComp_TestInit is Test { SemverComp_Harness internal harness; /// @notice Sets up the test environment. diff --git a/packages/contracts-bedrock/test/libraries/StaticConfig.t.sol b/packages/contracts-bedrock/test/libraries/StaticConfig.t.sol index 66ecd3ca043..00c8fe20957 100644 --- a/packages/contracts-bedrock/test/libraries/StaticConfig.t.sol +++ b/packages/contracts-bedrock/test/libraries/StaticConfig.t.sol @@ -10,7 +10,7 @@ import { StaticConfig } from "src/libraries/StaticConfig.sol"; /// @title StaticConfig_TestInit /// @notice Reusable test initialization for `StaticConfig` tests. -contract StaticConfig_TestInit is Test { +abstract contract StaticConfig_TestInit is Test { FFIInterface constant ffi = FFIInterface(address(uint160(uint256(keccak256(abi.encode("optimism.ffi")))))); function setUp() public { diff --git a/packages/contracts-bedrock/test/libraries/Storage.t.sol b/packages/contracts-bedrock/test/libraries/Storage.t.sol index 16c1e8727b7..5a801c24afc 100644 --- a/packages/contracts-bedrock/test/libraries/Storage.t.sol +++ b/packages/contracts-bedrock/test/libraries/Storage.t.sol @@ -7,7 +7,7 @@ import { Test } from "forge-std/Test.sol"; /// @title Storage_TestInit /// @notice Reusable test initialization for `Storage` tests. -contract Storage_TestInit is Test { +abstract contract Storage_TestInit is Test { StorageSetter setter; function setUp() public { diff --git a/packages/contracts-bedrock/test/libraries/TransientContext.t.sol b/packages/contracts-bedrock/test/libraries/TransientContext.t.sol index 0df917ef898..99d6264e2ba 100644 --- a/packages/contracts-bedrock/test/libraries/TransientContext.t.sol +++ b/packages/contracts-bedrock/test/libraries/TransientContext.t.sol @@ -10,7 +10,7 @@ import { TransientReentrancyAware } from "src/libraries/TransientContext.sol"; /// @title TransientContext_TestInit /// @notice Reusable test initialization for `TransientContext` tests. -contract TransientContext_TestInit is Test { +abstract contract TransientContext_TestInit is Test { /// @notice Slot for call depth. bytes32 internal callDepthSlot = bytes32(uint256(keccak256("transient.calldepth")) - 1); } diff --git a/packages/contracts-bedrock/test/libraries/trie/MerkleTrie.t.sol b/packages/contracts-bedrock/test/libraries/trie/MerkleTrie.t.sol index aa7765312a5..d746933990d 100644 --- a/packages/contracts-bedrock/test/libraries/trie/MerkleTrie.t.sol +++ b/packages/contracts-bedrock/test/libraries/trie/MerkleTrie.t.sol @@ -15,7 +15,7 @@ contract MerkleTrie_Harness { /// @title MerkleTrie_TestInit /// @notice Reusable test initialization for `MerkleTrie` tests. -contract MerkleTrie_TestInit is Test { +abstract contract MerkleTrie_TestInit is Test { FFIInterface constant ffi = FFIInterface(address(uint160(uint256(keccak256(abi.encode("optimism.ffi")))))); MerkleTrie_Harness harness; diff --git a/packages/contracts-bedrock/test/periphery/AssetReceiver.t.sol b/packages/contracts-bedrock/test/periphery/AssetReceiver.t.sol index 542ba74dc44..3e493984df1 100644 --- a/packages/contracts-bedrock/test/periphery/AssetReceiver.t.sol +++ b/packages/contracts-bedrock/test/periphery/AssetReceiver.t.sol @@ -9,7 +9,7 @@ import { AssetReceiver } from "src/periphery/AssetReceiver.sol"; /// @title AssetReceiver_TestInit /// @notice Reusable test initialization for `AssetReceiver` tests. -contract AssetReceiver_TestInit is Test { +abstract contract AssetReceiver_TestInit is Test { address alice = address(128); address bob = address(256); diff --git a/packages/contracts-bedrock/test/periphery/Transactor.t.sol b/packages/contracts-bedrock/test/periphery/Transactor.t.sol index d9de2a57d10..c32d6253fdc 100644 --- a/packages/contracts-bedrock/test/periphery/Transactor.t.sol +++ b/packages/contracts-bedrock/test/periphery/Transactor.t.sol @@ -8,7 +8,7 @@ import { Transactor } from "src/periphery/Transactor.sol"; /// @title Transactor_TestInit /// @notice Reusable test initialization for `Transactor` tests. -contract Transactor_TestInit is Test { +abstract contract Transactor_TestInit is Test { address alice = address(128); address bob = address(256); diff --git a/packages/contracts-bedrock/test/periphery/TransferOnion.t.sol b/packages/contracts-bedrock/test/periphery/TransferOnion.t.sol index 694a5b4bbc4..2d4261cc93d 100644 --- a/packages/contracts-bedrock/test/periphery/TransferOnion.t.sol +++ b/packages/contracts-bedrock/test/periphery/TransferOnion.t.sol @@ -10,7 +10,7 @@ import { TransferOnion } from "src/periphery/TransferOnion.sol"; /// @title TransferOnion_TestInit /// @notice Reusable test initialization for `TransferOnion` tests. -contract TransferOnion_TestInit is Test { +abstract contract TransferOnion_TestInit is Test { /// @notice TransferOnion TransferOnion internal onion; diff --git a/packages/contracts-bedrock/test/periphery/drippie/Drippie.t.sol b/packages/contracts-bedrock/test/periphery/drippie/Drippie.t.sol index 9639cbd7b87..e230f705902 100644 --- a/packages/contracts-bedrock/test/periphery/drippie/Drippie.t.sol +++ b/packages/contracts-bedrock/test/periphery/drippie/Drippie.t.sol @@ -38,7 +38,7 @@ contract Drippie_Test_Harness is Drippie { /// @title Drippie_TestInit /// @notice Reusable test initialization for `Drippie` tests. -contract Drippie_TestInit is Test { +abstract contract Drippie_TestInit is Test { /// @notice Emitted when a drip is executed. event DripExecuted(string indexed nameref, string name, address executor, uint256 timestamp); diff --git a/packages/contracts-bedrock/test/periphery/drippie/dripchecks/CheckBalanceLow.t.sol b/packages/contracts-bedrock/test/periphery/drippie/dripchecks/CheckBalanceLow.t.sol index c891c44f1bf..bfc051c9eac 100644 --- a/packages/contracts-bedrock/test/periphery/drippie/dripchecks/CheckBalanceLow.t.sol +++ b/packages/contracts-bedrock/test/periphery/drippie/dripchecks/CheckBalanceLow.t.sol @@ -6,7 +6,7 @@ import { CheckBalanceLow } from "src/periphery/drippie/dripchecks/CheckBalanceLo /// @title CheckBalanceLow_TestInit /// @notice Reusable test initialization for `CheckBalanceLow` tests. -contract CheckBalanceLow_TestInit is Test { +abstract contract CheckBalanceLow_TestInit is Test { /// @notice An instance of the CheckBalanceLow contract. CheckBalanceLow c; diff --git a/packages/contracts-bedrock/test/periphery/drippie/dripchecks/CheckSecrets.t.sol b/packages/contracts-bedrock/test/periphery/drippie/dripchecks/CheckSecrets.t.sol index c83fab0e054..9da99bfcd97 100644 --- a/packages/contracts-bedrock/test/periphery/drippie/dripchecks/CheckSecrets.t.sol +++ b/packages/contracts-bedrock/test/periphery/drippie/dripchecks/CheckSecrets.t.sol @@ -6,7 +6,7 @@ import { CheckSecrets } from "src/periphery/drippie/dripchecks/CheckSecrets.sol" /// @title CheckSecrets_TestInit /// @notice Reusable test initialization for `CheckSecrets` tests. -contract CheckSecrets_TestInit is Test { +abstract contract CheckSecrets_TestInit is Test { /// @notice Event emitted when a secret is revealed. event SecretRevealed(bytes32 indexed secretHash, bytes secret); diff --git a/packages/contracts-bedrock/test/periphery/drippie/dripchecks/CheckTrue.t.sol b/packages/contracts-bedrock/test/periphery/drippie/dripchecks/CheckTrue.t.sol index c787158c631..4fc04862b87 100644 --- a/packages/contracts-bedrock/test/periphery/drippie/dripchecks/CheckTrue.t.sol +++ b/packages/contracts-bedrock/test/periphery/drippie/dripchecks/CheckTrue.t.sol @@ -6,7 +6,7 @@ import { CheckTrue } from "src/periphery/drippie/dripchecks/CheckTrue.sol"; /// @title CheckTrue_TestInit /// @notice Reusable test initialization for `CheckTrue` tests. -contract CheckTrue_TestInit is Test { +abstract contract CheckTrue_TestInit is Test { /// @notice An instance of the CheckTrue contract. CheckTrue c; diff --git a/packages/contracts-bedrock/test/periphery/faucet/Faucet.t.sol b/packages/contracts-bedrock/test/periphery/faucet/Faucet.t.sol index 3434d4470b2..98c97df6556 100644 --- a/packages/contracts-bedrock/test/periphery/faucet/Faucet.t.sol +++ b/packages/contracts-bedrock/test/periphery/faucet/Faucet.t.sol @@ -8,7 +8,7 @@ import { FaucetHelper } from "test/mocks/FaucetHelper.sol"; /// @title Faucet_TestInit /// @notice Reusable test initialization for `Faucet` tests. -contract Faucet_TestInit is Test { +abstract contract Faucet_TestInit is Test { event Drip(string indexed authModule, bytes32 indexed userId, uint256 amount, address indexed recipient); address internal faucetContractAdmin; diff --git a/packages/contracts-bedrock/test/periphery/faucet/authmodules/AdminFaucetAuthModule.t.sol b/packages/contracts-bedrock/test/periphery/faucet/authmodules/AdminFaucetAuthModule.t.sol index d9b2e07c6d1..2bc5e7b4d56 100644 --- a/packages/contracts-bedrock/test/periphery/faucet/authmodules/AdminFaucetAuthModule.t.sol +++ b/packages/contracts-bedrock/test/periphery/faucet/authmodules/AdminFaucetAuthModule.t.sol @@ -8,7 +8,7 @@ import { FaucetHelper } from "test/mocks/FaucetHelper.sol"; /// @title AdminFaucetAuthModule_TestInit /// @notice Reusable test initialization for `AdminFaucetAuthModule` tests. -contract AdminFaucetAuthModule_TestInit is Test { +abstract contract AdminFaucetAuthModule_TestInit is Test { /// @notice The admin of the `AdminFaucetAuthModule` contract. address internal admin; diff --git a/packages/contracts-bedrock/test/periphery/monitoring/DisputeMonitorHelper.t.sol b/packages/contracts-bedrock/test/periphery/monitoring/DisputeMonitorHelper.t.sol index acb0c101602..3ec886c33b1 100644 --- a/packages/contracts-bedrock/test/periphery/monitoring/DisputeMonitorHelper.t.sol +++ b/packages/contracts-bedrock/test/periphery/monitoring/DisputeMonitorHelper.t.sol @@ -12,7 +12,7 @@ import { IDisputeGame } from "interfaces/dispute/IDisputeGame.sol"; /// @title DisputeMonitorHelper_TestInit /// @notice Reusable test initialization for `DisputeMonitorHelper` tests. -contract DisputeMonitorHelper_TestInit is DisputeGameFactory_TestInit { +abstract contract DisputeMonitorHelper_TestInit is DisputeGameFactory_TestInit { DisputeMonitorHelper helper; function setUp() public override { diff --git a/packages/contracts-bedrock/test/safe/DeputyPauseModule.t.sol b/packages/contracts-bedrock/test/safe/DeputyPauseModule.t.sol index 996502234f2..b20074f5b34 100644 --- a/packages/contracts-bedrock/test/safe/DeputyPauseModule.t.sol +++ b/packages/contracts-bedrock/test/safe/DeputyPauseModule.t.sol @@ -14,7 +14,7 @@ import { ISuperchainConfig } from "interfaces/L1/ISuperchainConfig.sol"; /// @title DeputyPauseModule_TestInit /// @notice Reusable test initialization for `DeputyPauseModule` tests. -contract DeputyPauseModule_TestInit is CommonTest, SafeTestTools { +abstract contract DeputyPauseModule_TestInit is CommonTest, SafeTestTools { using SafeTestLib for SafeInstance; event ExecutionFromModuleSuccess(address indexed module); diff --git a/packages/contracts-bedrock/test/safe/LivenessGuard.t.sol b/packages/contracts-bedrock/test/safe/LivenessGuard.t.sol index 00596d59ac7..e683f1e7eb1 100644 --- a/packages/contracts-bedrock/test/safe/LivenessGuard.t.sol +++ b/packages/contracts-bedrock/test/safe/LivenessGuard.t.sol @@ -25,7 +25,7 @@ contract LivenessGuard_WrappedGuard_Harness is LivenessGuard { /// @title LivenessGuard_TestInit /// @notice Reusable test initialization for `LivenessGuard` tests. -contract LivenessGuard_TestInit is Test, SafeTestTools { +abstract contract LivenessGuard_TestInit is Test, SafeTestTools { using SafeTestLib for SafeInstance; event OwnerRecorded(address owner); diff --git a/packages/contracts-bedrock/test/safe/LivenessModule.t.sol b/packages/contracts-bedrock/test/safe/LivenessModule.t.sol index 9e878c70b89..0b46f01b6ac 100644 --- a/packages/contracts-bedrock/test/safe/LivenessModule.t.sol +++ b/packages/contracts-bedrock/test/safe/LivenessModule.t.sol @@ -11,7 +11,7 @@ import { LivenessGuard } from "src/safe/LivenessGuard.sol"; /// @title LivenessModule_TestInit /// @notice Reusable test initialization for `LivenessModule` tests. -contract LivenessModule_TestInit is Test, SafeTestTools { +abstract contract LivenessModule_TestInit is Test, SafeTestTools { using SafeTestLib for SafeInstance; error OwnerRemovalFailed(string reason); diff --git a/packages/contracts-bedrock/test/safe/LivenessModule2.t.sol b/packages/contracts-bedrock/test/safe/LivenessModule2.t.sol index e690228be13..b3a0e429044 100644 --- a/packages/contracts-bedrock/test/safe/LivenessModule2.t.sol +++ b/packages/contracts-bedrock/test/safe/LivenessModule2.t.sol @@ -10,7 +10,7 @@ import { SaferSafes } from "src/safe/SaferSafes.sol"; /// @title LivenessModule2_TestInit /// @notice Reusable test initialization for `LivenessModule2` tests. -contract LivenessModule2_TestInit is Test, SafeTestTools { +abstract contract LivenessModule2_TestInit is Test, SafeTestTools { using SafeTestLib for SafeInstance; // Events diff --git a/packages/contracts-bedrock/test/safe/SafeSigners.t.sol b/packages/contracts-bedrock/test/safe/SafeSigners.t.sol index 8a70e983c3a..f59ad036064 100644 --- a/packages/contracts-bedrock/test/safe/SafeSigners.t.sol +++ b/packages/contracts-bedrock/test/safe/SafeSigners.t.sol @@ -7,7 +7,7 @@ import "test/safe-tools/SafeTestTools.sol"; /// @title SafeSigners_TestInit /// @notice Reusable test initialization for `SafeSigners` tests. -contract SafeSigners_TestInit is Test { +abstract contract SafeSigners_TestInit is Test { bytes4 internal constant EIP1271_MAGIC_VALUE = 0x20c13b0b; enum SigTypes { diff --git a/packages/contracts-bedrock/test/safe/SaferSafes.t.sol b/packages/contracts-bedrock/test/safe/SaferSafes.t.sol index 5bf77603675..f17dfc47abf 100644 --- a/packages/contracts-bedrock/test/safe/SaferSafes.t.sol +++ b/packages/contracts-bedrock/test/safe/SaferSafes.t.sol @@ -9,7 +9,7 @@ import { LivenessModule2 } from "src/safe/LivenessModule2.sol"; /// @title SaferSafes_TestInit /// @notice Reusable test initialization for `SaferSafes` tests. -contract SaferSafes_TestInit is Test, SafeTestTools { +abstract contract SaferSafes_TestInit is Test, SafeTestTools { using SafeTestLib for SafeInstance; // Events diff --git a/packages/contracts-bedrock/test/safe/TimelockGuard.t.sol b/packages/contracts-bedrock/test/safe/TimelockGuard.t.sol index 22473fccb2f..53594f52570 100644 --- a/packages/contracts-bedrock/test/safe/TimelockGuard.t.sol +++ b/packages/contracts-bedrock/test/safe/TimelockGuard.t.sol @@ -142,7 +142,7 @@ library TransactionBuilder { /// @title TimelockGuard_TestInit /// @notice Reusable test initialization for `TimelockGuard` tests. -contract TimelockGuard_TestInit is Test, SafeTestTools { +abstract contract TimelockGuard_TestInit is Test, SafeTestTools { // Events event GuardConfigured(Safe indexed safe, uint256 timelockDelay); event TransactionScheduled(Safe indexed safe, bytes32 indexed txId, uint256 when); diff --git a/packages/contracts-bedrock/test/scripts/L2Genesis.t.sol b/packages/contracts-bedrock/test/scripts/L2Genesis.t.sol index 400f3285bf5..ffd6a60d4d1 100644 --- a/packages/contracts-bedrock/test/scripts/L2Genesis.t.sol +++ b/packages/contracts-bedrock/test/scripts/L2Genesis.t.sol @@ -18,7 +18,7 @@ import { IGasPriceOracle } from "interfaces/L2/IGasPriceOracle.sol"; /// @title L2Genesis_TestInit /// @notice Reusable test initialization for `L2Genesis` tests. -contract L2Genesis_TestInit is Test { +abstract contract L2Genesis_TestInit is Test { L2Genesis.Input internal input; L2Genesis internal genesis; diff --git a/packages/contracts-bedrock/test/scripts/VerifyOPCM.t.sol b/packages/contracts-bedrock/test/scripts/VerifyOPCM.t.sol index 7d1a05864cc..abdd6d75c4e 100644 --- a/packages/contracts-bedrock/test/scripts/VerifyOPCM.t.sol +++ b/packages/contracts-bedrock/test/scripts/VerifyOPCM.t.sol @@ -61,7 +61,7 @@ contract VerifyOPCM_Harness is VerifyOPCM { /// @title VerifyOPCM_TestInit /// @notice Reusable test initialization for `VerifyOPCM` tests. -contract VerifyOPCM_TestInit is OPContractsManager_TestInit { +abstract contract VerifyOPCM_TestInit is OPContractsManager_TestInit { VerifyOPCM_Harness internal harness; function setUp() public virtual override { diff --git a/packages/contracts-bedrock/test/setup/CommonTest.sol b/packages/contracts-bedrock/test/setup/CommonTest.sol index a117be29a50..71f55ec3867 100644 --- a/packages/contracts-bedrock/test/setup/CommonTest.sol +++ b/packages/contracts-bedrock/test/setup/CommonTest.sol @@ -24,7 +24,7 @@ import { ILegacyMintableERC20Full } from "interfaces/legacy/ILegacyMintableERC20 /// @title CommonTest /// @dev An extension to `Test` that sets up the optimism smart contracts. -contract CommonTest is Test, Setup, Events { +abstract contract CommonTest is Test, Setup, Events { address alice; address bob; diff --git a/packages/contracts-bedrock/test/setup/Events.sol b/packages/contracts-bedrock/test/setup/Events.sol index eebc6e65bcb..7a87a29dc27 100644 --- a/packages/contracts-bedrock/test/setup/Events.sol +++ b/packages/contracts-bedrock/test/setup/Events.sol @@ -12,7 +12,7 @@ import { IDisputeGame } from "interfaces/dispute/IDisputeGame.sol"; /// @dev Contains various events that are tested against. This contract needs to /// exist until we either modularize the implementations or use a newer version of /// solc that allows for referencing events from other contracts. -contract Events { +abstract contract Events { /// @dev OpenZeppelin Ownable.sol transferOwnership event event OwnershipTransferred(address indexed previousOwner, address indexed newOwner); event TransactionDeposited(address indexed from, address indexed to, uint256 indexed version, bytes opaqueData); diff --git a/packages/contracts-bedrock/test/setup/FeatureFlags.sol b/packages/contracts-bedrock/test/setup/FeatureFlags.sol index 7ab1e368539..8a376473ec6 100644 --- a/packages/contracts-bedrock/test/setup/FeatureFlags.sol +++ b/packages/contracts-bedrock/test/setup/FeatureFlags.sol @@ -14,7 +14,7 @@ import { ISystemConfig } from "interfaces/L1/ISystemConfig.sol"; /// @notice FeatureFlags manages the feature bitmap by either direct user input or via environment /// variables. -contract FeatureFlags { +abstract contract FeatureFlags { /// @notice The address of the foundry Vm contract. Vm private constant vm = Vm(0x7109709ECfa91a80626fF3989D68f67F5b1DD12D); diff --git a/packages/contracts-bedrock/test/setup/Setup.sol b/packages/contracts-bedrock/test/setup/Setup.sol index 5b5d0dfe586..92fb55b6485 100644 --- a/packages/contracts-bedrock/test/setup/Setup.sol +++ b/packages/contracts-bedrock/test/setup/Setup.sol @@ -68,7 +68,7 @@ import { ICrossL2Inbox } from "interfaces/L2/ICrossL2Inbox.sol"; /// sets the L2 contracts directly at the predeploy addresses instead of setting them /// up behind proxies. In the future we will migrate to importing the genesis JSON /// file that is created to set up the L2 contracts instead of setting them up manually. -contract Setup is FeatureFlags { +abstract contract Setup is FeatureFlags { using ForkUtils for Fork; /// @notice The address of the foundry Vm contract. diff --git a/packages/contracts-bedrock/test/universal/CrossDomainMessenger.t.sol b/packages/contracts-bedrock/test/universal/CrossDomainMessenger.t.sol index ec744a7981c..dd9cf4eb1e3 100644 --- a/packages/contracts-bedrock/test/universal/CrossDomainMessenger.t.sol +++ b/packages/contracts-bedrock/test/universal/CrossDomainMessenger.t.sol @@ -85,7 +85,7 @@ contract CrossDomainMessenger_ExternalRelay_Harness is Test { /// @title CrossDomainMessenger_TestInit /// @notice Reusable test initialization for `CrossDomainMessenger` tests. -contract CrossDomainMessenger_TestInit is CommonTest { +abstract contract CrossDomainMessenger_TestInit is CommonTest { // Storage slot of the l2Sender uint256 constant senderSlotIndex = 50; diff --git a/packages/contracts-bedrock/test/universal/OptimismMintableERC20.t.sol b/packages/contracts-bedrock/test/universal/OptimismMintableERC20.t.sol index 017aa47f68e..025b43ee89f 100644 --- a/packages/contracts-bedrock/test/universal/OptimismMintableERC20.t.sol +++ b/packages/contracts-bedrock/test/universal/OptimismMintableERC20.t.sol @@ -8,7 +8,7 @@ import { IERC165 } from "@openzeppelin/contracts/utils/introspection/IERC165.sol /// @title OptimismMintableERC20_TestInit /// @notice Reusable test initialization for `OptimismMintableERC20` tests. -contract OptimismMintableERC20_TestInit is CommonTest { +abstract contract OptimismMintableERC20_TestInit is CommonTest { event Mint(address indexed account, uint256 amount); event Burn(address indexed account, uint256 amount); } diff --git a/packages/contracts-bedrock/test/universal/OptimismMintableERC20Factory.t.sol b/packages/contracts-bedrock/test/universal/OptimismMintableERC20Factory.t.sol index 3772953c540..930a1a28676 100644 --- a/packages/contracts-bedrock/test/universal/OptimismMintableERC20Factory.t.sol +++ b/packages/contracts-bedrock/test/universal/OptimismMintableERC20Factory.t.sol @@ -16,7 +16,7 @@ import { IOptimismMintableERC20Factory } from "interfaces/universal/IOptimismMin /// @title OptimismMintableERC20Factory_TestInit /// @notice Reusable test initialization for `OptimismMintableERC20Factory` tests. -contract OptimismMintableERC20Factory_TestInit is CommonTest { +abstract contract OptimismMintableERC20Factory_TestInit is CommonTest { event StandardL2TokenCreated(address indexed remoteToken, address indexed localToken); event OptimismMintableERC20Created(address indexed localToken, address indexed remoteToken, address deployer); diff --git a/packages/contracts-bedrock/test/universal/Proxy.t.sol b/packages/contracts-bedrock/test/universal/Proxy.t.sol index 2ad098881c4..a19cb26d8af 100644 --- a/packages/contracts-bedrock/test/universal/Proxy.t.sol +++ b/packages/contracts-bedrock/test/universal/Proxy.t.sol @@ -26,7 +26,7 @@ contract Proxy_Clasher_Harness { /// @title Proxy_TestInit /// @notice Reusable test initialization for `Proxy` tests. -contract Proxy_TestInit is Test { +abstract contract Proxy_TestInit is Test { event Upgraded(address indexed implementation); event AdminChanged(address previousAdmin, address newAdmin); diff --git a/packages/contracts-bedrock/test/universal/ProxyAdmin.t.sol b/packages/contracts-bedrock/test/universal/ProxyAdmin.t.sol index 160bb6ffefc..b86196e60bb 100644 --- a/packages/contracts-bedrock/test/universal/ProxyAdmin.t.sol +++ b/packages/contracts-bedrock/test/universal/ProxyAdmin.t.sol @@ -16,7 +16,7 @@ import { DeployUtils } from "scripts/libraries/DeployUtils.sol"; /// @title ProxyAdmin_TestInit /// @notice Reusable test initialization for `ProxyAdmin` tests. -contract ProxyAdmin_TestInit is Test { +abstract contract ProxyAdmin_TestInit is Test { address alice = address(64); IProxy proxy; diff --git a/packages/contracts-bedrock/test/universal/StandardBridge.t.sol b/packages/contracts-bedrock/test/universal/StandardBridge.t.sol index dc36b175ce0..4cd950df868 100644 --- a/packages/contracts-bedrock/test/universal/StandardBridge.t.sol +++ b/packages/contracts-bedrock/test/universal/StandardBridge.t.sol @@ -52,7 +52,7 @@ contract LegacyMintable is ERC20 { /// @notice Reusable test initialization for `StandardBridge` tests. /// @dev This setup is primarily for tests focusing on internal stateless logic or default states /// of the `StandardBridge` contract. -contract StandardBridge_TestInit is CommonTest { +abstract contract StandardBridge_TestInit is CommonTest { StandardBridgeTester internal bridge; OptimismMintableERC20 internal mintable; ERC20 internal erc20; diff --git a/packages/contracts-bedrock/test/universal/WETH98.t.sol b/packages/contracts-bedrock/test/universal/WETH98.t.sol index ca1158da307..96065c8c890 100644 --- a/packages/contracts-bedrock/test/universal/WETH98.t.sol +++ b/packages/contracts-bedrock/test/universal/WETH98.t.sol @@ -10,7 +10,7 @@ import { DeployUtils } from "scripts/libraries/DeployUtils.sol"; /// @title WETH98_TestInit /// @notice Reusable test initialization for `WETH98` tests. -contract WETH98_TestInit is Test { +abstract contract WETH98_TestInit is Test { event Approval(address indexed src, address indexed guy, uint256 wad); event Transfer(address indexed src, address indexed dst, uint256 wad); event Deposit(address indexed dst, uint256 wad); From fde644120293dbc60ebce6326c68d0d5202e8771 Mon Sep 17 00:00:00 2001 From: Stefano Charissis Date: Fri, 17 Oct 2025 04:02:23 +1100 Subject: [PATCH 076/117] fix(op-acceptance-tests): flaky tests; less filtering (#17891) --- .../scripts/generate-flaky-tests-report.sh | 69 ++----------------- 1 file changed, 6 insertions(+), 63 deletions(-) diff --git a/op-acceptance-tests/scripts/generate-flaky-tests-report.sh b/op-acceptance-tests/scripts/generate-flaky-tests-report.sh index 1f4730ee6b1..a521da458b3 100755 --- a/op-acceptance-tests/scripts/generate-flaky-tests-report.sh +++ b/op-acceptance-tests/scripts/generate-flaky-tests-report.sh @@ -95,54 +95,12 @@ API_RESPONSE=$(echo "$API_RESPONSE" | jq '.flaky_tests = (.flaky_tests | map(sel echo "$API_RESPONSE" > "$OUTPUT_DIR/flaky_tests.json" echo "Raw API response saved to $OUTPUT_DIR/flaky_tests.json" -# Verify that each flaky test's job belongs to the target branch by checking its pipeline branch -echo "Verifying pipeline branches for each flaky test..." +# Use acceptance-tests fresponse directly +echo "Using acceptance-tests filtered response without additional branch verification..." FILTERED_JSON="$OUTPUT_DIR/flaky_tests.filtered.json" -PIPELINE_BRANCH_CACHE=$(mktemp) -FILTERED_ENTRIES=$(mktemp) - -cleanup_branch_filter() { - rm -f "$PIPELINE_BRANCH_CACHE" "$FILTERED_ENTRIES" || true -} -trap cleanup_branch_filter EXIT - -get_branch_for_pipeline_number() { - local pipeline_number="$1" - # Check cache - local cached - cached=$(awk -v num="$pipeline_number" '$1==num {print $2; found=1} END{ if(!found) exit 1 }' "$PIPELINE_BRANCH_CACHE" 2>/dev/null || true) - if [ -n "$cached" ]; then - echo "$cached" - return 0 - fi - # Fetch from CircleCI API (project pipeline by number) - local resp - resp=$(curl -s -H "Circle-Token: $CIRCLE_API_TOKEN" "https://circleci.com/api/v2/project/gh/$ORG_NAME/$REPO_NAME/pipeline/$pipeline_number") - if [ -z "$resp" ]; then - echo "" - return 0 - fi - local branch - branch=$(echo "$resp" | jq -r '.vcs.branch // .branch // empty') - printf "%s %s\n" "$pipeline_number" "${branch}" >> "$PIPELINE_BRANCH_CACHE" - echo "$branch" -} - -: > "$FILTERED_ENTRIES" -while IFS= read -r entry; do - pipeline_number=$(echo "$entry" | jq -r '.pipeline_number // empty') - if [ -z "$pipeline_number" ]; then - continue - fi - branch=$(get_branch_for_pipeline_number "$pipeline_number") - if [ "$branch" = "$BRANCH" ]; then - echo "$entry" >> "$FILTERED_ENTRIES" - fi -done < <(jq -c '.flaky_tests[]' "$OUTPUT_DIR/flaky_tests.json") - -jq -s '{flaky_tests: .}' "$FILTERED_ENTRIES" > "$FILTERED_JSON" +cp "$OUTPUT_DIR/flaky_tests.json" "$FILTERED_JSON" API_RESPONSE=$(cat "$FILTERED_JSON") -echo "Filtered API response saved to $FILTERED_JSON" +echo "Filtered response saved to $FILTERED_JSON" # Check if the response contains flaky_tests if ! echo "$API_RESPONSE" | jq -e '.flaky_tests' > /dev/null 2>&1; then @@ -152,20 +110,13 @@ if ! echo "$API_RESPONSE" | jq -e '.flaky_tests' > /dev/null 2>&1; then exit 1 fi -# Check if we have any flaky tests after branch verification -if ! jq -e '.flaky_tests | length > 0' "$FILTERED_JSON" > /dev/null 2>&1; then - echo "No flaky tests found for branch $BRANCH after verifying pipeline branches" - echo "Filtered Response:" - cat "$FILTERED_JSON" - exit 0 -fi - # Print the number of flaky tests found NUM_TESTS=$(jq '.flaky_tests | length' "$FILTERED_JSON") echo "Found $NUM_TESTS flaky tests" # Generate CSV report echo "Generating CSV report..." +echo '"times_flaked","test_name","classname","job_name","workflow_name","job_number","pipeline_number","job_url","first_flaked_at","last_flaked_at"' > "$OUTPUT_DIR/flaky_tests.csv" jq -r '.flaky_tests | sort_by(.times_flaked) | reverse | .[] | [ .times_flaked, (.test_name | @json), @@ -177,15 +128,7 @@ jq -r '.flaky_tests | sort_by(.times_flaked) | reverse | .[] | [ ("https://app.circleci.com/pipelines/github/" + "'"$ORG_NAME"'" + "/" + "'"$REPO_NAME"'" + "/" + (.pipeline_number | tostring) + "/workflows/" + .workflow_id + "/jobs/" + (.job_number | tostring) | @json), (.workflow_created_at | @json), (.workflow_created_at | @json) -] | @csv' "$FILTERED_JSON" > "$OUTPUT_DIR/flaky_tests.csv" - -# Check if CSV file was generated and has content -if [ ! -s "$OUTPUT_DIR/flaky_tests.csv" ]; then - echo "Error: CSV file is empty or was not generated" - echo "Contents of flaky_tests.json:" - cat "$OUTPUT_DIR/flaky_tests.json" - exit 1 -fi +] | @csv' "$FILTERED_JSON" >> "$OUTPUT_DIR/flaky_tests.csv" # Generate HTML report echo "Generating HTML report..." From be7bd42751c164513748834f02f4c6c086cbc77d Mon Sep 17 00:00:00 2001 From: Josh Klopfenstein Date: Thu, 16 Oct 2025 10:32:48 -0700 Subject: [PATCH 077/117] op-devstack: dynamically assign geth subprocess p2p listening port (#17904) Otherwise it defaults to 30303, which can cause test flakes if the port is already taken. --- op-devstack/sysgo/l1_nodes_subprocess.go | 1 + 1 file changed, 1 insertion(+) diff --git a/op-devstack/sysgo/l1_nodes_subprocess.go b/op-devstack/sysgo/l1_nodes_subprocess.go index 90ce7a4cfcf..56183becbbe 100644 --- a/op-devstack/sysgo/l1_nodes_subprocess.go +++ b/op-devstack/sysgo/l1_nodes_subprocess.go @@ -185,6 +185,7 @@ func WithL1NodesSubprocess(id stack.L1ELNodeID, clID stack.L1CLNodeID) stack.Opt "--ws", "--ws.addr", "127.0.0.1", "--ws.port", "0", "--ws.origins", "*", "--ws.api", "admin,debug,eth,net,txpool", "--authrpc.addr", "127.0.0.1", "--authrpc.port", "0", "--authrpc.jwtsecret", jwtPath, "--ipcdisable", + "--port", "0", "--nodiscover", "--verbosity", "5", "--miner.recommit", "2s", From 515f0c196f7e4b4e67acd67552ae17a680ea0984 Mon Sep 17 00:00:00 2001 From: smartcontracts <14298799+smartcontracts@users.noreply.github.com> Date: Thu, 16 Oct 2025 14:26:58 -0400 Subject: [PATCH 078/117] fix: no env var manipulation in VerifyOPCM tests (#17813) * fix: no env var manipulation in VerifyOPCM tests * Update packages/contracts-bedrock/test/scripts/VerifyOPCM.t.sol Co-authored-by: Maurelian * fix: remove old variable --------- Co-authored-by: Maurelian --- .../test/scripts/VerifyOPCM.t.sol | 23 ++++++++++++------- 1 file changed, 15 insertions(+), 8 deletions(-) diff --git a/packages/contracts-bedrock/test/scripts/VerifyOPCM.t.sol b/packages/contracts-bedrock/test/scripts/VerifyOPCM.t.sol index abdd6d75c4e..63cb4c7a6b2 100644 --- a/packages/contracts-bedrock/test/scripts/VerifyOPCM.t.sol +++ b/packages/contracts-bedrock/test/scripts/VerifyOPCM.t.sol @@ -430,9 +430,6 @@ contract VerifyOPCM_Run_Test is VerifyOPCM_TestInit { // Coverage changes bytecode and causes failures, skip. skipIfCoverage(); - // Ensure environment variables are set correctly (in case other tests modified them) - setupEnvVars(); - // Test that the immutable variables are correctly verified. // Environment variables are set in setUp() to match the actual OPCM addresses. bool result = harness.verifyOpcmImmutableVariables(opcm); @@ -463,15 +460,25 @@ contract VerifyOPCM_Run_Test is VerifyOPCM_TestInit { address expectedSuperchainConfig = address(0x1111); address expectedProtocolVersions = address(0x2222); - vm.setEnv("EXPECTED_SUPERCHAIN_CONFIG", vm.toString(expectedSuperchainConfig)); - vm.setEnv("EXPECTED_PROTOCOL_VERSIONS", vm.toString(expectedProtocolVersions)); + // Use vm.mockCall instead of vm.setEnv to avoid global env mutation. We need to ignore + // semgrep here because envAddress has multiple potential signatures so we can't use + // abi.encodeCall. + // nosemgrep: sol-style-use-abi-encodecall + vm.mockCall( + address(vm), + abi.encodeWithSignature("envAddress(string)", "EXPECTED_SUPERCHAIN_CONFIG"), + abi.encode(expectedSuperchainConfig) + ); + // nosemgrep: sol-style-use-abi-encodecall + vm.mockCall( + address(vm), + abi.encodeWithSignature("envAddress(string)", "EXPECTED_PROTOCOL_VERSIONS"), + abi.encode(expectedProtocolVersions) + ); // Test that mocking each individual getter causes verification to fail _assertOnOpcmGetter(IOPContractsManager.superchainConfig.selector); _assertOnOpcmGetter(IOPContractsManager.protocolVersions.selector); - - // Reset environment variables to correct values (as set in setUp()) - setupEnvVars(); } /// @notice Tests that the ABI getter validation succeeds when all getters are accounted for. From 8d7ef29fb29eb7f8bc5bfcbbaf826e589deef7c8 Mon Sep 17 00:00:00 2001 From: Sam Stokes <35908605+bitwiseguy@users.noreply.github.com> Date: Thu, 16 Oct 2025 15:44:11 -0400 Subject: [PATCH 079/117] op-deployer: re-enable v3 upgrade test with new fork blockNum (#17852) --- .../integration_test/cli/upgrade_test.go | 20 +++++++++---------- 1 file changed, 10 insertions(+), 10 deletions(-) diff --git a/op-deployer/pkg/deployer/integration_test/cli/upgrade_test.go b/op-deployer/pkg/deployer/integration_test/cli/upgrade_test.go index 2bed07db89a..5e5f5a36124 100644 --- a/op-deployer/pkg/deployer/integration_test/cli/upgrade_test.go +++ b/op-deployer/pkg/deployer/integration_test/cli/upgrade_test.go @@ -19,7 +19,7 @@ import ( ) // TestCLIUpgrade tests the upgrade CLI command for each standard opcm release -// - forks sepolia at the block immediately after the opcm deployment block +// - forks sepolia at a block before op-sepolia was upgraded // - runs the upgrade CLI command using op-sepolia values to simulate its upgrade func TestCLIUpgrade(t *testing.T) { lgr := testlog.Logger(t, slog.LevelDebug) @@ -32,27 +32,27 @@ func TestCLIUpgrade(t *testing.T) { testCases := []struct { contractTag string version string - forkBlock uint64 // one block number past the opcm deployment block + forkBlock uint64 }{ { contractTag: standard.ContractsV200Tag, version: "v2.0.0", - forkBlock: 7792843, + forkBlock: 7792843, // one block past the opcm deployment block + }, + { + contractTag: standard.ContractsV300Tag, + version: "v3.0.0", + forkBlock: 8092886, // one block before op-sepolia was upgraded }, - //{ - //contractTag: standard.ContractsV300Tag, - //version: "v3.0.0", - //forkBlock: 7853303, - //}, { contractTag: standard.ContractsV400Tag, version: "v4.0.0", - forkBlock: 8577263, + forkBlock: 8577263, // one block past the opcm deployment block }, { contractTag: standard.ContractsV410Tag, version: "v4.1.0", - forkBlock: 9165154, + forkBlock: 9165154, // one block past the opcm deployment block }, } From 55150e4898ccf845735de83e98a76871922e0ef0 Mon Sep 17 00:00:00 2001 From: Axel Kingsley Date: Thu, 16 Oct 2025 15:03:05 -0500 Subject: [PATCH 080/117] Set v0.1.0 and Docker Image Target (#17906) --- .circleci/config.yml | 3 +++ docker-bake.hcl | 17 +++++++++++++++++ op-supernode/cmd/main.go | 2 +- .../chain_container/chain_container.go | 2 +- ops/docker/op-stack-go/Dockerfile | 9 +++++++++ ops/docker/op-stack-go/Dockerfile.dockerignore | 1 + 6 files changed, 32 insertions(+), 2 deletions(-) diff --git a/.circleci/config.yml b/.circleci/config.yml index a1197113b85..5c9f71c6b91 100644 --- a/.circleci/config.yml +++ b/.circleci/config.yml @@ -2521,6 +2521,7 @@ workflows: - op-conductor - da-server - op-supervisor + - op-supernode - op-test-sequencer - cannon - op-dripper @@ -2679,6 +2680,7 @@ workflows: - da-server - op-ufm - op-supervisor + - op-supernode - op-test-sequencer - cannon - op-dripper @@ -2714,6 +2716,7 @@ workflows: - da-server - op-ufm - op-supervisor + - op-supernode - op-test-sequencer - op-deployer - cannon diff --git a/docker-bake.hcl b/docker-bake.hcl index 290d6462654..294292c6155 100644 --- a/docker-bake.hcl +++ b/docker-bake.hcl @@ -69,6 +69,10 @@ variable "OP_SUPERVISOR_VERSION" { default = "${GIT_VERSION}" } +variable "OP_SUPERNODE_VERSION" { + default = "${GIT_VERSION}" +} + variable "OP_TEST_SEQUENCER_VERSION" { default = "${GIT_VERSION}" } @@ -216,6 +220,19 @@ target "op-supervisor" { tags = [for tag in split(",", IMAGE_TAGS) : "${REGISTRY}/${REPOSITORY}/op-supervisor:${tag}"] } +target "op-supernode" { + dockerfile = "ops/docker/op-stack-go/Dockerfile" + context = "." + args = { + GIT_COMMIT = "${GIT_COMMIT}" + GIT_DATE = "${GIT_DATE}" + OP_SUPERNODE_VERSION = "${OP_SUPERNODE_VERSION}" + } + target = "op-supernode-target" + platforms = split(",", PLATFORMS) + tags = [for tag in split(",", IMAGE_TAGS) : "${REGISTRY}/${REPOSITORY}/op-supernode:${tag}"] +} + target "op-test-sequencer" { dockerfile = "ops/docker/op-stack-go/Dockerfile" context = "." diff --git a/op-supernode/cmd/main.go b/op-supernode/cmd/main.go index 2743a401a53..885bcf7498e 100644 --- a/op-supernode/cmd/main.go +++ b/op-supernode/cmd/main.go @@ -23,7 +23,7 @@ import ( ) var ( - Version = "v0.0.0" + Version = "v0.1.0" GitCommit = "" GitDate = "" ) diff --git a/op-supernode/supernode/chain_container/chain_container.go b/op-supernode/supernode/chain_container/chain_container.go index 71b259de4a7..8a153eb2e68 100644 --- a/op-supernode/supernode/chain_container/chain_container.go +++ b/op-supernode/supernode/chain_container/chain_container.go @@ -19,7 +19,7 @@ import ( "github.com/prometheus/client_golang/prometheus/promhttp" ) -const virtualNodeVersion = "0.0.0" +const virtualNodeVersion = "0.1.0" type ChainContainer interface { Start(ctx context.Context) error diff --git a/ops/docker/op-stack-go/Dockerfile b/ops/docker/op-stack-go/Dockerfile index b91cff25674..56116e6deaa 100644 --- a/ops/docker/op-stack-go/Dockerfile +++ b/ops/docker/op-stack-go/Dockerfile @@ -157,6 +157,11 @@ ARG OP_SUPERVISOR_VERSION=v0.0.0 RUN --mount=type=cache,target=/go/pkg/mod --mount=type=cache,target=/root/.cache/go-build cd op-supervisor && make op-supervisor \ GOOS=$TARGETOS GOARCH=$TARGETARCH GITCOMMIT=$GIT_COMMIT GITDATE=$GIT_DATE VERSION="$OP_SUPERVISOR_VERSION" +FROM --platform=$BUILDPLATFORM builder AS op-supernode-builder +ARG OP_SUPERNODE_VERSION=v0.0.0 +RUN --mount=type=cache,target=/go/pkg/mod --mount=type=cache,target=/root/.cache/go-build cd op-supernode && make op-supernode \ + GOOS=$TARGETOS GOARCH=$TARGETARCH GITCOMMIT=$GIT_COMMIT GITDATE=$GIT_DATE VERSION="$OP_SUPERNODE_VERSION" + FROM --platform=$BUILDPLATFORM builder AS op-test-sequencer-builder ARG OP_TEST_SEQUENCER_VERSION=v0.0.0 RUN --mount=type=cache,target=/go/pkg/mod --mount=type=cache,target=/root/.cache/go-build cd op-test-sequencer && make op-test-sequencer \ @@ -249,6 +254,10 @@ FROM $TARGET_BASE_IMAGE AS op-supervisor-target COPY --from=op-supervisor-builder /app/op-supervisor/bin/op-supervisor /usr/local/bin/ CMD ["op-supervisor"] +FROM $TARGET_BASE_IMAGE AS op-supernode-target +COPY --from=op-supernode-builder /app/op-supernode/bin/op-supernode /usr/local/bin/ +CMD ["op-supernode"] + FROM $TARGET_BASE_IMAGE AS op-test-sequencer-target COPY --from=op-test-sequencer-builder /app/op-test-sequencer/bin/op-test-sequencer /usr/local/bin/ CMD ["op-test-sequencer"] diff --git a/ops/docker/op-stack-go/Dockerfile.dockerignore b/ops/docker/op-stack-go/Dockerfile.dockerignore index afe2a467ecb..343892972f7 100644 --- a/ops/docker/op-stack-go/Dockerfile.dockerignore +++ b/ops/docker/op-stack-go/Dockerfile.dockerignore @@ -18,6 +18,7 @@ !/op-proposer !/op-service !/op-supervisor +!/op-supernode !/op-test-sequencer !/op-wheel !/op-alt-da From 4b371370eb5e0e3bf986377603d6e47a0f2d3988 Mon Sep 17 00:00:00 2001 From: Changwan Park Date: Fri, 17 Oct 2025 23:50:41 +0900 Subject: [PATCH 081/117] op-acceptance-tests: ELP2P down but payload appendable till chain tip (#17895) * op-acceptance-tests: ELP2P down but payload appendable till chain tip * Make sure batcher is still down * Verifier at least reached once the tip of the chain * remove safe head check * better err msg --- .../tests/sync/elsync/gap_clp2p/sync_test.go | 51 +++++++++++++------ op-devstack/dsl/l2_cl.go | 17 +++++++ 2 files changed, 52 insertions(+), 16 deletions(-) diff --git a/op-acceptance-tests/tests/sync/elsync/gap_clp2p/sync_test.go b/op-acceptance-tests/tests/sync/elsync/gap_clp2p/sync_test.go index 21b4a3ed2cb..a90137f4c3b 100644 --- a/op-acceptance-tests/tests/sync/elsync/gap_clp2p/sync_test.go +++ b/op-acceptance-tests/tests/sync/elsync/gap_clp2p/sync_test.go @@ -19,33 +19,52 @@ func TestSyncAfterInitialELSync(gt *testing.T) { // batcher down so safe not advanced require.Equal(uint64(0), sys.L2CL.HeadBlockRef(types.LocalSafe).Number) require.Equal(uint64(0), sys.L2CLB.HeadBlockRef(types.LocalSafe).Number) - // verifier not advanced unsafe head - require.Equal(uint64(0), sys.L2CLB.HeadBlockRef(types.LocalUnsafe).Number) + + startNum := sys.L2CLB.HeadBlockRef(types.LocalUnsafe).Number // Finish EL sync by supplying the first block - // EL Sync finished because underlying EL has states to validate the payload for block 1 - sys.L2CLB.SignalTarget(sys.L2EL, 1) + // EL Sync finished because underlying EL has states to validate the payload for block startNum+1 + sys.L2CLB.SignalTarget(sys.L2EL, startNum+1) - // Send payloads for block 3, 4, 5, 7 which will fill in unsafe payload queue, block 2 missed + // Send payloads for block startNum+3, startNum+4, startNum+5, startNum+7 which will fill in unsafe payload queue, block startNum+2 missed // Non-canonical payloads will be not sent to L2EL // Order does not matter - for _, target := range []uint64{5, 3, 4, 7} { + for _, delta := range []uint64{5, 3, 4, 7} { + target := startNum + delta sys.L2CLB.SignalTarget(sys.L2EL, target) // Canonical unsafe head never advances because of the gap - require.Equal(uint64(1), sys.L2ELB.BlockRefByLabel(eth.Unsafe).Number) + require.Equal(startNum+1, sys.L2ELB.BlockRefByLabel(eth.Unsafe).Number) } - // Send missing gap, payload 2, still not sending FCU since unsafe gap exists - sys.L2CLB.SignalTarget(sys.L2EL, 2) + // Send missing gap, payload startNum+2, still not sending FCU since unsafe gap exists + sys.L2CLB.SignalTarget(sys.L2EL, startNum+2) retries := 2 - // Gap filled and payload 2, 3, 4, 5 became canonical by relaying to ELB. - // Payload 7 is still in the unsafe payload queue because of unsafe gap - sys.L2ELB.Reached(eth.Unsafe, 5, retries) + // Gap filled and payload startNum+2, startNum+3, startNum+4, startNum+5 became canonical by relaying to ELB. + // Payload startNum+7 is still in the unsafe payload queue because of unsafe gap + sys.L2ELB.Reached(eth.Unsafe, startNum+5, retries) + + // Send missing gap, payload startNum+6 + sys.L2CLB.SignalTarget(sys.L2EL, startNum+6) + + // Gap filled and block startNum+6, startNum+7 became canonical by relaying to ELB. + sys.L2ELB.Reached(eth.Unsafe, startNum+7, retries) +} - // Send missing gap, payload 6 - sys.L2CLB.SignalTarget(sys.L2EL, 6) +func TestReachUnsafeTipByAppendingUnsafePayload(gt *testing.T) { + t := devtest.SerialT(gt) + sys := presets.NewSingleChainMultiNodeWithoutCheck(t) + logger := t.Logger() + + sys.L2CL.Advanced(types.LocalUnsafe, 7, 30) + + // First make verifier reach unsafe tip + logger.Info("Initial trial for appending payload until tip") + sys.L2CLB.AppendUnsafePayloadUntilTip(sys.L2ELB, sys.L2EL, 400) + + sys.L2CL.Advanced(types.LocalUnsafe, 7, 30) - // Gap filled and block 6, 7 became canonical by relaying to ELB. - sys.L2ELB.Reached(eth.Unsafe, 7, retries) + // Try once more to check that filling in the gap works again + logger.Info("Second trial for appending payload until tip") + sys.L2CLB.AppendUnsafePayloadUntilTip(sys.L2ELB, sys.L2EL, 400) } diff --git a/op-devstack/dsl/l2_cl.go b/op-devstack/dsl/l2_cl.go index 2c565f19eff..c667a9e625f 100644 --- a/op-devstack/dsl/l2_cl.go +++ b/op-devstack/dsl/l2_cl.go @@ -387,3 +387,20 @@ func (cl *L2CLNode) Reset(lvl types.SafetyLevel, target eth.L2BlockRef) { return errors.New("waiting to reset") })) } + +func (cl *L2CLNode) AppendUnsafePayloadUntilTip(verEL, seqEL *L2ELNode, maxAttempts int) { + trial := 0 + cl.require.NoError( + retry.Do0(cl.ctx, 200, &retry.FixedStrategy{Dur: 250 * time.Millisecond}, func() error { + verUnsafe := verEL.BlockRefByLabel(eth.Unsafe) + seqUnsafe := seqEL.BlockRefByLabel(eth.Unsafe) + gap := seqUnsafe.Number - verUnsafe.Number + cl.log.Info("Filling in the gap by appending unsafe payload", "gap", gap, "ver", verUnsafe, "seq", seqUnsafe, "trial", trial) + if gap == 0 { + return nil + } + trial += 1 + cl.SignalTarget(seqEL, verUnsafe.Number+1) + return fmt.Errorf("unsafe gap with size %d still exists", gap) + })) +} From d7d8791dada09faf722bee5d204113463501e84b Mon Sep 17 00:00:00 2001 From: Dense D Date: Fri, 17 Oct 2025 16:07:30 +0000 Subject: [PATCH 082/117] add KONA_LOG_LEVEL (#17496) --- op-devstack/sysgo/supervisor_kona.go | 1 + 1 file changed, 1 insertion(+) diff --git a/op-devstack/sysgo/supervisor_kona.go b/op-devstack/sysgo/supervisor_kona.go index b34df575bd8..a42079b50c0 100644 --- a/op-devstack/sysgo/supervisor_kona.go +++ b/op-devstack/sysgo/supervisor_kona.go @@ -154,6 +154,7 @@ func WithKonaSupervisor(supervisorID stack.SupervisorID, clusterID stack.Cluster "RPC_ENABLE_ADMIN=true", "L2_CONSENSUS_NODES=", "L2_CONSENSUS_JWT_SECRET=", + "KONA_LOG_LEVEL=3", // info level, consistent with l2_cl_kona.go "KONA_LOG_STDOUT_FORMAT=json", } From 1261c431c58ee3ef50030df0b9d22b584bbb21a5 Mon Sep 17 00:00:00 2001 From: Anton Evangelatov Date: Fri, 17 Oct 2025 18:37:55 +0200 Subject: [PATCH 083/117] op-acceptance-tests: disable discovery for test (#17918) --- op-acceptance-tests/tests/depreqres/init_test.go | 1 + 1 file changed, 1 insertion(+) diff --git a/op-acceptance-tests/tests/depreqres/init_test.go b/op-acceptance-tests/tests/depreqres/init_test.go index ff0f2710d95..373e0a49778 100644 --- a/op-acceptance-tests/tests/depreqres/init_test.go +++ b/op-acceptance-tests/tests/depreqres/init_test.go @@ -12,5 +12,6 @@ func TestMain(m *testing.M) { presets.WithExecutionLayerSyncOnVerifiers(), presets.WithCompatibleTypes(compat.SysGo), presets.WithReqRespSyncDisabled(), + presets.WithNoDiscovery(), ) } From 69bd381d1b0e99ad52d4dee48fe17acc646a1963 Mon Sep 17 00:00:00 2001 From: Sebastian Stammler Date: Fri, 17 Oct 2025 20:11:37 +0200 Subject: [PATCH 084/117] all: Update op-geth to use blobGasUsed field for DA footprint (#17861) --- go.mod | 2 +- go.sum | 4 +- .../tests/jovian/da_footprint_test.go | 234 ++++++++++++++---- op-devstack/dsl/el.go | 95 +++---- op-devstack/dsl/l2_el.go | 23 ++ op-devstack/dsl/l2_network.go | 8 +- .../client/l2/engineapi/block_processor.go | 8 - op-service/eth/block_info.go | 5 + op-service/testutils/l1info.go | 5 + 9 files changed, 262 insertions(+), 122 deletions(-) diff --git a/go.mod b/go.mod index 789e145b6fe..225b380f14e 100644 --- a/go.mod +++ b/go.mod @@ -308,7 +308,7 @@ require ( lukechampine.com/blake3 v1.3.0 // indirect ) -replace github.com/ethereum/go-ethereum => github.com/ethereum-optimism/op-geth v1.101603.2-0.20251016091451-5c6d276814f2 +replace github.com/ethereum/go-ethereum => github.com/ethereum-optimism/op-geth v1.101603.2-0.20251017174928-6658a36c9862 // replace github.com/ethereum/go-ethereum => ../op-geth diff --git a/go.sum b/go.sum index 58101d03573..61aeed136a4 100644 --- a/go.sum +++ b/go.sum @@ -238,8 +238,8 @@ github.com/emicklei/dot v1.6.2 h1:08GN+DD79cy/tzN6uLCT84+2Wk9u+wvqP+Hkx/dIR8A= github.com/emicklei/dot v1.6.2/go.mod h1:DeV7GvQtIw4h2u73RKBkkFdvVAz0D9fzeJrgPW6gy/s= github.com/ethereum-optimism/go-ethereum-hdwallet v0.1.4-0.20251001155152-4eb15ccedf7e h1:iy1vBIzACYUyOVyoADUwvAiq2eOPC0yVsDUdolPwQjk= github.com/ethereum-optimism/go-ethereum-hdwallet v0.1.4-0.20251001155152-4eb15ccedf7e/go.mod h1:DYj7+vYJ4cIB7zera9mv4LcAynCL5u4YVfoeUu6Wa+w= -github.com/ethereum-optimism/op-geth v1.101603.2-0.20251016091451-5c6d276814f2 h1:fvYTR+KOcvSDd/gJuh+ALG/Fx7Y0xU3ZaDkgT/kqVi0= -github.com/ethereum-optimism/op-geth v1.101603.2-0.20251016091451-5c6d276814f2/go.mod h1:Ct2QjqZ2UKgvvgKLLYzoh/DBicJZB8DXsv45DgEjcco= +github.com/ethereum-optimism/op-geth v1.101603.2-0.20251017174928-6658a36c9862 h1:15VLb6evTBOzznvwZxesXxLFI34gHjFfIlU+Oaga3sc= +github.com/ethereum-optimism/op-geth v1.101603.2-0.20251017174928-6658a36c9862/go.mod h1:Ct2QjqZ2UKgvvgKLLYzoh/DBicJZB8DXsv45DgEjcco= github.com/ethereum-optimism/superchain-registry/validation v0.0.0-20251009180028-9b4658b9b7af h1:WWz0gJM/boaUImtJnROecPirAerKCLpAU4m6Tx0ArOg= github.com/ethereum-optimism/superchain-registry/validation v0.0.0-20251009180028-9b4658b9b7af/go.mod h1:NZ816PzLU1TLv1RdAvYAb6KWOj4Zm5aInT0YpDVml2Y= github.com/ethereum/c-kzg-4844/v2 v2.1.0 h1:gQropX9YFBhl3g4HYhwE70zq3IHFRgbbNPw0Shwzf5w= diff --git a/op-acceptance-tests/tests/jovian/da_footprint_test.go b/op-acceptance-tests/tests/jovian/da_footprint_test.go index e3a8c83902a..d778b7ca1fa 100644 --- a/op-acceptance-tests/tests/jovian/da_footprint_test.go +++ b/op-acceptance-tests/tests/jovian/da_footprint_test.go @@ -3,17 +3,25 @@ package jovian import ( "context" "crypto/rand" + "math/big" "sync" "testing" "time" "github.com/ethereum-optimism/optimism/op-acceptance-tests/tests/interop/loadtest" + "github.com/ethereum-optimism/optimism/op-chain-ops/devkeys" "github.com/ethereum-optimism/optimism/op-devstack/devtest" + "github.com/ethereum-optimism/optimism/op-devstack/dsl" "github.com/ethereum-optimism/optimism/op-devstack/presets" + "github.com/ethereum-optimism/optimism/op-node/rollup" "github.com/ethereum-optimism/optimism/op-service/eth" "github.com/ethereum-optimism/optimism/op-service/txinclude" + "github.com/ethereum-optimism/optimism/op-service/txintent/bindings" + "github.com/ethereum-optimism/optimism/op-service/txintent/contractio" "github.com/ethereum-optimism/optimism/op-service/txplan" + "github.com/ethereum/go-ethereum/common" + "github.com/ethereum/go-ethereum/core/types" ) type CalldataSpammer struct { @@ -34,62 +42,190 @@ func (s *CalldataSpammer) Spam(t devtest.T) error { return err } +type daFootprintSystemConfig struct { + SetDAFootprintGasScalar func(scalar uint16) bindings.TypedCall[any] `sol:"setDAFootprintGasScalar"` + DAFootprintGasScalar func() bindings.TypedCall[uint16] `sol:"daFootprintGasScalar"` +} + +type daFootprintL1Block struct { + DAFootprintGasScalar func() bindings.TypedCall[uint16] `sol:"daFootprintGasScalar"` +} + +type daFootprintEnv struct { + l1Client *dsl.L1ELNode + l2Network *dsl.L2Network + l2EL *dsl.L2ELNode + systemConfig daFootprintSystemConfig + l1Block daFootprintL1Block +} + +func newDAFootprintEnv(t devtest.T, l2Network *dsl.L2Network, l1EL *dsl.L1ELNode, l2EL *dsl.L2ELNode) *daFootprintEnv { + systemConfig := bindings.NewBindings[daFootprintSystemConfig]( + bindings.WithClient(l1EL.EthClient()), + bindings.WithTo(l2Network.Escape().Deployment().SystemConfigProxyAddr()), + bindings.WithTest(t), + ) + + l1Block := bindings.NewBindings[daFootprintL1Block]( + bindings.WithClient(l2EL.Escape().EthClient()), + bindings.WithTo(common.HexToAddress("0x4200000000000000000000000000000000000015")), + bindings.WithTest(t), + ) + + return &daFootprintEnv{ + l1Client: l1EL, + l2Network: l2Network, + l2EL: l2EL, + systemConfig: systemConfig, + l1Block: l1Block, + } +} + +func (env *daFootprintEnv) checkCompatibility(t devtest.T) { + // Ensure getters exist on both L1 SystemConfig and L2 L1Block + _, err := contractio.Read(env.systemConfig.DAFootprintGasScalar(), t.Ctx()) + t.Require().NoError(err) + _, err = contractio.Read(env.l1Block.DAFootprintGasScalar(), t.Ctx()) + t.Require().NoError(err) +} + +func (env *daFootprintEnv) getSystemConfigOwner(t devtest.T) *dsl.EOA { + priv := env.l2Network.Escape().Keys().Secret(devkeys.SystemConfigOwner.Key(env.l2Network.ChainID().ToBig())) + return dsl.NewKey(t, priv).User(env.l1Client) +} + +func (env *daFootprintEnv) setDAFootprintGasScalarViaSystemConfig(t devtest.T, scalar uint16) *types.Receipt { + owner := env.getSystemConfigOwner(t) + rec, err := contractio.Write(env.systemConfig.SetDAFootprintGasScalar(scalar), t.Ctx(), owner.Plan()) + t.Require().NoError(err, "SetDAFootprintGasScalar transaction failed") + t.Logf("Set DA footprint gas scalar on L1: scalar=%d", scalar) + return rec +} + +// expectL1BlockDAFootprintGasScalar expects the given DA footprint gas scalar to be set in the L1Block contract. +func (env *daFootprintEnv) expectL1BlockDAFootprintGasScalar(t devtest.T, expected uint16) { + current, err := contractio.Read(env.l1Block.DAFootprintGasScalar(), t.Ctx()) + t.Require().NoError(err, "Failed to read DA footprint gas scalar from L1Block") + t.Require().Equal(expected, current) +} + func TestDAFootprint(gt *testing.T) { t := devtest.SerialT(gt) sys := presets.NewMinimal(t) + require := t.Require() + + err := dsl.RequiresL2Fork(t.Ctx(), sys, 0, rollup.Jovian) + require.NoError(err, "Jovian fork must be active for this test") + + env := newDAFootprintEnv(t, sys.L2Chain, sys.L1EL, sys.L2EL) + env.checkCompatibility(t) + + systemOwner := env.getSystemConfigOwner(t) + sys.FunderL1.FundAtLeast(systemOwner, eth.OneTenthEther) l2BlockTime := time.Duration(sys.L2Chain.Escape().RollupConfig().BlockTime) * time.Second + sys.L2EL.WaitForOnline() ethClient := sys.L2EL.Escape().EthClient() - sys.L2EL.WaitForOnline() + s1000 := uint16(1000) + s0 := uint16(0) + cases := []struct { + name string + setScalar *uint16 + expected uint16 + }{ + {"DefaultScalar", nil, uint16(eth.DAFootprintGasScalarDefault)}, + {"Scalar1000", &s1000, uint16(1000)}, + {"ScalarZeroUsesDefault", &s0, uint16(eth.DAFootprintGasScalarDefault)}, + } - var wg sync.WaitGroup - defer wg.Wait() - - ctx, cancel := context.WithTimeout(t.Ctx(), time.Minute) - defer cancel() - t = t.WithCtx(ctx) - - wg.Add(1) - go func() { - defer wg.Done() - eoa := sys.FunderL2.NewFundedEOA(eth.OneEther.Mul(100)) - includer := txinclude.NewPersistent(txinclude.NewPkSigner(eoa.Key().Priv(), eoa.ChainID().ToBig()), struct { - *txinclude.Resubmitter - *txinclude.Monitor - }{ - txinclude.NewResubmitter(ethClient, l2BlockTime), - txinclude.NewMonitor(ethClient, l2BlockTime), - }) - loadtest.NewBurst(l2BlockTime).Run(t, NewCalldataSpammer(loadtest.NewSyncEOA(includer, eoa.Plan()))) - }() - - for range time.Tick(l2BlockTime) { - info, txs, err := ethClient.InfoAndTxsByLabel(t.Ctx(), eth.Unsafe) - t.Require().NoError(err) - - blockGasUsed := info.GasUsed() - - receipt, err := ethClient.TransactionReceipt(t.Ctx(), txs[len(txs)-1].Hash()) - t.Require().NoError(err) - // The last tx's cumulative gas used is the block's total transaction gas used. - totalTxGasUsed := receipt.CumulativeGasUsed - if totalTxGasUsed == blockGasUsed { - t.Logf("Block %d:%s doesn't have excess gas used, trying next...", info.NumberU64(), info.Hash()) - continue - } - - var totalDAFootprint uint64 - for _, tx := range txs { - if tx.IsDepositTx() { - continue + for _, tc := range cases { + t.Run(tc.name, func(t devtest.T) { + if tc.setScalar != nil { + rec := env.setDAFootprintGasScalarViaSystemConfig(t, *tc.setScalar) + // Wait for change to propagate to L2 + env.l2EL.WaitL1OriginReached(eth.Unsafe, rec.BlockNumber.Uint64(), 20) + } else { + sys.L2EL.WaitForBlockNumber(2) // make sure we don't assert on genesis or first block + } + env.expectL1BlockDAFootprintGasScalar(t, tc.expected) + + var wg sync.WaitGroup + defer wg.Wait() + + ctx, cancel := context.WithTimeout(t.Ctx(), time.Minute) + defer cancel() + t = t.WithCtx(ctx) + + wg.Add(1) + go func() { + defer wg.Done() + eoa := sys.FunderL2.NewFundedEOA(eth.OneEther.Mul(100)) + includer := txinclude.NewPersistent(txinclude.NewPkSigner(eoa.Key().Priv(), eoa.ChainID().ToBig()), struct { + *txinclude.Resubmitter + *txinclude.Monitor + }{ + txinclude.NewResubmitter(ethClient, l2BlockTime), + txinclude.NewMonitor(ethClient, l2BlockTime), + }) + loadtest.NewBurst(l2BlockTime).Run(t, NewCalldataSpammer(loadtest.NewSyncEOA(includer, eoa.Plan()))) + }() + + rollupCfg := sys.L2Chain.Escape().RollupConfig() + gasTarget := rollupCfg.Genesis.SystemConfig.GasLimit / rollupCfg.ChainOpConfig.EIP1559Elasticity + + var blockDAFootprint uint64 + info := sys.L2EL.WaitForUnsafe(func(info eth.BlockInfo) (bool, error) { + blockGasUsed := info.GasUsed() + blobGasUsed := info.BlobGasUsed() + t.Require().NotNil(blobGasUsed, "blobGasUsed must not be nil for Jovian chains") + blockDAFootprint = *blobGasUsed + if blockDAFootprint <= blockGasUsed { + t.Logf("Block %s has DA footprint (%d) <= gasUsed (%d), trying next...", + eth.ToBlockID(info), blockDAFootprint, blockGasUsed) + return false, nil + } + if blockDAFootprint <= gasTarget { + t.Logf("Block %s has DA footprint (%d) <= gasTarget (%d), trying next...", + eth.ToBlockID(info), blockDAFootprint, gasTarget) + return false, nil + } + return true, nil + }) + + _, txs, err := ethClient.InfoAndTxsByHash(t.Ctx(), info.Hash()) + t.Require().NoError(err) + + var totalDAFootprint uint64 + for _, tx := range txs { + if tx.IsDepositTx() { + continue + } + totalDAFootprint += tx.RollupCostData().EstimatedDASize().Uint64() * uint64(tc.expected) + } + t.Logf("Block %s has header/calculated DA footprint %d/%d", + eth.ToBlockID(info), blockDAFootprint, totalDAFootprint) + t.Require().Equal(totalDAFootprint, blockDAFootprint, "Calculated DA footprint doesn't match block header DA footprint") + + // Check base fee calculation of next block + // Calculate expected base fee as: + // parentBaseFee + max(1, parentBaseFee * gasUsedDelta / parentGasTarget / baseFeeChangeDenominator) + var ( + baseFee = new(big.Int) + denom = new(big.Int) + ) + baseFee.SetUint64(blockDAFootprint - gasTarget) // gasUsedDelta + baseFee.Mul(baseFee, info.BaseFee()) + baseFee.Div(baseFee, denom.SetUint64(gasTarget)) + baseFee.Div(baseFee, denom.SetUint64(*rollupCfg.ChainOpConfig.EIP1559DenominatorCanyon)) + if baseFee.Cmp(common.Big1) < 0 { + baseFee.Add(info.BaseFee(), common.Big1) + } else { + baseFee.Add(info.BaseFee(), baseFee) } - totalDAFootprint += tx.RollupCostData().EstimatedDASize().Uint64() * eth.DAFootprintGasScalarDefault - } - t.Logf("Block %d:%s has DA footprint exceeding cumulative tx gas used, %d > %d", info.NumberU64(), info.Hash(), - totalDAFootprint, totalTxGasUsed) - t.Require().Less(totalTxGasUsed, blockGasUsed) - t.Require().Equal(totalDAFootprint, blockGasUsed) - return + t.Logf("Expected base fee: %s", baseFee) + + next := sys.L2EL.WaitForBlockNumber(info.NumberU64() + 1) + t.Require().Equal(baseFee, next.BaseFee(), "Wrong base fee") + }) } - t.Require().FailNow("Never saw a block with gasUsed > total transaction gasUsed.") } diff --git a/op-devstack/dsl/el.go b/op-devstack/dsl/el.go index b7e4d97251a..d727120a008 100644 --- a/op-devstack/dsl/el.go +++ b/op-devstack/dsl/el.go @@ -36,24 +36,42 @@ func (el *elNode) WaitForBlock() eth.BlockRef { return el.waitForNextBlock(1) } -func (el *elNode) WaitForBlockNumber(targetBlock uint64) eth.BlockRef { - var newRef eth.BlockRef - +func (el *elNode) WaitForLabel(label eth.BlockLabel, predicate func(eth.BlockInfo) (bool, error)) eth.BlockInfo { + var block eth.BlockInfo err := wait.For(el.ctx, 500*time.Millisecond, func() (bool, error) { - newBlock, err := el.inner.EthClient().InfoByLabel(el.ctx, eth.Unsafe) + var err error + block, err = el.inner.EthClient().InfoByLabel(el.ctx, label) if err != nil { return false, err } - - newRef = eth.InfoToL1BlockRef(newBlock) - if newBlock.NumberU64() >= targetBlock { - el.log.Info("Target block reached", "chain", el.ChainID(), "block", newRef) - return true, nil + ok, err := predicate(block) + if ok { + el.log.Info("Target block reached", "chain", el.ChainID(), "block", eth.ToBlockID(block)) + } else if err == nil { + el.log.Debug("Target block not reached yet", "chain", el.ChainID(), "block", eth.ToBlockID(block)) } - return false, nil + return ok, err + }) + el.require.NoError(err, "Failed to find block") + return block +} + +func (el *elNode) WaitForLabelRef(label eth.BlockLabel, predicate func(eth.BlockInfo) (bool, error)) eth.BlockRef { + return eth.InfoToL1BlockRef(el.WaitForLabel(label, predicate)) +} + +func (el *elNode) WaitForUnsafe(predicate func(eth.BlockInfo) (bool, error)) eth.BlockInfo { + return el.WaitForLabel(eth.Unsafe, predicate) +} + +func (el *elNode) WaitForUnsafeRef(predicate func(eth.BlockInfo) (bool, error)) eth.BlockRef { + return eth.InfoToL1BlockRef(el.WaitForUnsafe(predicate)) +} + +func (el *elNode) WaitForBlockNumber(targetBlock uint64) eth.BlockInfo { + return el.WaitForUnsafe(func(info eth.BlockInfo) (bool, error) { + return info.NumberU64() >= targetBlock, nil }) - el.require.NoError(err, "Expected to reach target block") - return newRef } func (el *elNode) WaitForOnline() { @@ -76,43 +94,17 @@ func (el *elNode) waitForNextBlock(blocksFromNow uint64) eth.BlockRef { initial, err := el.inner.EthClient().InfoByLabel(el.ctx, eth.Unsafe) el.require.NoError(err, "Expected to get latest block from execution client") targetBlock := initial.NumberU64() + blocksFromNow - initialRef := eth.InfoToL1BlockRef(initial) - var newRef eth.BlockRef - - err = wait.For(el.ctx, 500*time.Millisecond, func() (bool, error) { - newBlock, err := el.inner.EthClient().InfoByLabel(el.ctx, eth.Unsafe) - if err != nil { - return false, err - } - - newRef = eth.InfoToL1BlockRef(newBlock) - if newBlock.NumberU64() >= targetBlock { - el.log.Info("Target block reached", "block", newRef) - return true, nil - } - if initialRef == newRef { - el.log.Info("Still same block detected as initial", "block", initialRef) - return false, nil - } else { - el.log.Info("New block detected", "new_block", newRef, "prev_block", initialRef) - } - return false, nil + return el.WaitForUnsafeRef(func(info eth.BlockInfo) (bool, error) { + return info.NumberU64() >= targetBlock, nil }) - el.require.NoError(err, "Expected to reach target block") - return newRef } // WaitForTime waits until the chain has reached or surpassed the given timestamp. func (el *elNode) WaitForTime(timestamp uint64) eth.BlockRef { - for range time.Tick(500 * time.Millisecond) { - ref, err := el.inner.EthClient().BlockRefByLabel(el.ctx, eth.Unsafe) - el.require.NoError(err) - if ref.Time >= timestamp { - return ref - } - } - return eth.BlockRef{} // Should never be reached. + return el.WaitForUnsafeRef(func(info eth.BlockInfo) (bool, error) { + return info.Time() >= timestamp, nil + }) } func (el *elNode) stackEL() stack.ELNode { @@ -127,18 +119,7 @@ func (el *elNode) WaitForFinalization() eth.BlockRef { currentBlock, err := el.inner.EthClient().InfoByLabel(el.ctx, eth.Unsafe) el.require.NoError(err, "Expected to get current block from execution client") - var finalizedBlock eth.BlockRef - el.require.Eventually(func() bool { - el.log.Info("Waiting for finalization") - block, err := el.inner.EthClient().InfoByLabel(el.ctx, eth.Finalized) - if err != nil { - return false - } - if block.NumberU64() >= currentBlock.NumberU64() { - finalizedBlock = eth.InfoToL1BlockRef(block) - return true - } - return false - }, 5*time.Minute, 500*time.Millisecond, "Expected to be online") - return finalizedBlock + return el.WaitForLabelRef(eth.Finalized, func(info eth.BlockInfo) (bool, error) { + return info.NumberU64() >= currentBlock.NumberU64(), nil + }) } diff --git a/op-devstack/dsl/l2_el.go b/op-devstack/dsl/l2_el.go index fe0c2518eab..ad8e89fbabf 100644 --- a/op-devstack/dsl/l2_el.go +++ b/op-devstack/dsl/l2_el.go @@ -178,6 +178,29 @@ func (el *L2ELNode) TransactionTimeout() time.Duration { return el.inner.TransactionTimeout() } +// L1OriginReachedFn returns a lambda that waits for the L1 origin to reach the target block number. +func (el *L2ELNode) L1OriginReachedFn(label eth.BlockLabel, l1OriginTarget uint64, attempts int) CheckFunc { + return func() error { + logger := el.log.With("id", el.inner.ID(), "chain", el.ChainID(), "label", label, "l1OriginTarget", l1OriginTarget) + logger.Info("Expecting L2EL to reach L1 origin") + return retry.Do0(el.ctx, attempts, &retry.FixedStrategy{Dur: 1 * time.Second}, + func() error { + head := el.BlockRefByLabel(label) + if head.L1Origin.Number >= l1OriginTarget { + logger.Info("L2EL advanced L1 origin", "l1OriginTarget", l1OriginTarget) + return nil + } + logger.Debug("L2EL sync status", "head", head.ID()) + return fmt.Errorf("L1 origin of %s not advanced yet", label) + }) + } +} + +// WaitL1OriginReached waits for the L1 origin to reach the target block number. +func (el *L2ELNode) WaitL1OriginReached(label eth.BlockLabel, l1OriginTarget uint64, attempts int) { + el.require.NoError(el.L1OriginReachedFn(label, l1OriginTarget, attempts)()) +} + // VerifyWithdrawalHashChangedIn verifies that the withdrawal hash changed between the parent and current block // This is used to verify that the withdrawal hash changed in the block where the withdrawal was initiated func (el *L2ELNode) VerifyWithdrawalHashChangedIn(blockHash common.Hash) { diff --git a/op-devstack/dsl/l2_network.go b/op-devstack/dsl/l2_network.go index bdba587724a..92751f231ec 100644 --- a/op-devstack/dsl/l2_network.go +++ b/op-devstack/dsl/l2_network.go @@ -241,11 +241,9 @@ func (n *L2Network) AwaitActivation(t devtest.T, forkName rollup.ForkName) eth.B } blockNum, err := rollupCfg.TargetBlockNumber(activationTime) require.NoError(err) - NewL2ELNode(el, n.control).WaitForBlockNumber(blockNum).ID() - activationBlock, err := el.EthClient().BlockRefByNumber(t.Ctx(), blockNum) - require.NoError(err, "Failed to get activation block") - t.Logger().Info("Activation block", "block", activationBlock.ID()) - return activationBlock.ID() + activationBlock := eth.ToBlockID(NewL2ELNode(el, n.control).WaitForBlockNumber(blockNum)) + t.Logger().Info("Activation block", "block", activationBlock) + return activationBlock } diff --git a/op-program/client/l2/engineapi/block_processor.go b/op-program/client/l2/engineapi/block_processor.go index c6923842670..be7178b32ed 100644 --- a/op-program/client/l2/engineapi/block_processor.go +++ b/op-program/client/l2/engineapi/block_processor.go @@ -177,14 +177,6 @@ func (b *BlockProcessor) Assemble() (*types.Block, types.Receipts, error) { } } - if cfg.IsJovian(b.header.Time) { - gasUsed, err := types.CalcGasUsedJovian(b.transactions, b.header.GasUsed) - if err != nil { - return nil, nil, fmt.Errorf("failed to calculate gas used for Jovian block: %w", err) - } - b.header.GasUsed = gasUsed - } - block, err := b.dataProvider.Engine().FinalizeAndAssemble(b.dataProvider, b.header, b.state, &body, b.receipts) if err != nil { return nil, nil, err diff --git a/op-service/eth/block_info.go b/op-service/eth/block_info.go index 10e6f5761f3..3d09d8ba535 100644 --- a/op-service/eth/block_info.go +++ b/op-service/eth/block_info.go @@ -26,6 +26,7 @@ type BlockInfo interface { ExcessBlobGas() *uint64 ReceiptHash() common.Hash GasUsed() uint64 + BlobGasUsed() *uint64 GasLimit() uint64 ParentBeaconRoot() *common.Hash // Dencun extension WithdrawalsRoot() *common.Hash // Isthmus extension @@ -145,6 +146,10 @@ func (h *headerBlockInfo) GasUsed() uint64 { return h.header.GasUsed } +func (h *headerBlockInfo) BlobGasUsed() *uint64 { + return h.header.BlobGasUsed +} + func (h *headerBlockInfo) GasLimit() uint64 { return h.header.GasLimit } diff --git a/op-service/testutils/l1info.go b/op-service/testutils/l1info.go index 39b03f4e005..d15c9790c61 100644 --- a/op-service/testutils/l1info.go +++ b/op-service/testutils/l1info.go @@ -28,6 +28,7 @@ type MockBlockInfo struct { InfoExcessBlobGas *uint64 InfoReceiptRoot common.Hash InfoGasUsed uint64 + InfoBlobGasUsed *uint64 InfoGasLimit uint64 InfoHeaderRLP []byte @@ -83,6 +84,10 @@ func (l *MockBlockInfo) GasUsed() uint64 { return l.InfoGasUsed } +func (l *MockBlockInfo) BlobGasUsed() *uint64 { + return l.InfoBlobGasUsed +} + func (l *MockBlockInfo) GasLimit() uint64 { return l.InfoGasLimit } From 9e29ba4186c6cff7f2801c4c9a69918ed9e2c2b1 Mon Sep 17 00:00:00 2001 From: Inphi Date: Fri, 17 Oct 2025 14:46:45 -0400 Subject: [PATCH 085/117] op-fetcher: Support the CANNON_KONA FaultDisputeGame (#17656) * op-fetcher: Support the CANNON_KONA FaultDisputeGame * cleanup; add test cases for missing cannon-kona --- op-chain-ops/addresses/contracts.go | 1 + .../FetchChainInfo.s.sol/FetchChainInfo.json | 2 +- .../FetchChainInfoInput.json | 2 +- .../FetchChainInfoOutput.json | 2 +- .../FetchChainInfo.s.sol/IFetcher.json | 2 +- .../scripts/FetchChainInfo.s.sol | 30 +++- .../test/scripts/FetchChainInfo.t.sol | 139 ++++++++++++------ 7 files changed, 125 insertions(+), 53 deletions(-) diff --git a/op-chain-ops/addresses/contracts.go b/op-chain-ops/addresses/contracts.go index c531fa27be2..ffe99d26d80 100644 --- a/op-chain-ops/addresses/contracts.go +++ b/op-chain-ops/addresses/contracts.go @@ -78,6 +78,7 @@ type OpChainFaultProofsContracts struct { DisputeGameFactoryProxy common.Address AnchorStateRegistryProxy common.Address FaultDisputeGameImpl common.Address + FaultDisputeGameCannonKonaImpl common.Address PermissionedDisputeGameImpl common.Address DelayedWethPermissionedGameProxy common.Address DelayedWethPermissionlessGameProxy common.Address diff --git a/op-fetcher/pkg/fetcher/fetch/forge-artifacts/FetchChainInfo.s.sol/FetchChainInfo.json b/op-fetcher/pkg/fetcher/fetch/forge-artifacts/FetchChainInfo.s.sol/FetchChainInfo.json index c642731ef1c..2d9b0ae681e 100644 --- a/op-fetcher/pkg/fetcher/fetch/forge-artifacts/FetchChainInfo.s.sol/FetchChainInfo.json +++ b/op-fetcher/pkg/fetcher/fetch/forge-artifacts/FetchChainInfo.s.sol/FetchChainInfo.json @@ -1 +1 @@ -{"abi":[{"type":"function","name":"IS_SCRIPT","inputs":[],"outputs":[{"name":"","type":"bool","internalType":"bool"}],"stateMutability":"view"},{"type":"function","name":"run","inputs":[{"name":"_fi","type":"address","internalType":"contract FetchChainInfoInput"},{"name":"_fo","type":"address","internalType":"contract FetchChainInfoOutput"}],"outputs":[],"stateMutability":"nonpayable"}],"bytecode":{"object":"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","sourceMap":"13140:10848:120:-:0;;;3166:4:43;3126:44;;;;;;;;;;;;;;;;;;;;873:4:41;849:28;;;;;;;;;;;;;;;;;;;;13140:10848:120;;;;;;;;;;;;;;;;","linkReferences":{}},"deployedBytecode":{"object":"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","sourceMap":"13140:10848:120:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;849:28:41;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;13180:198:120;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;849:28:41;;;;;;;;;;;;;:::o;13180:198:120:-;13261:30;13282:3;13287;13261:20;:30::i;:::-;13301:36;13328:3;13333;13301:26;:36::i;:::-;13347:24;13367:3;13347:19;:24::i;:::-;13180:198;;:::o;13384:1336::-;13484:25;13512:3;:21;;;:23;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;13484:51;;13545:3;:7;;;13553:30;;;13585:17;13545:58;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;13614:25;13651:17;13642:33;;;:35;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;13614:63;;13687:3;:7;;;13695:30;;;13727:17;13687:58;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;13756:25;13793:17;13784:45;;;:47;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;13756:75;;13841:3;:7;;;13849:30;;;13881:17;13841:58;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;13910:22;13935:37;13954:17;13935:18;:37::i;:::-;13910:62;;13982:3;:7;;;13990:27;;;14019:14;13982:52;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;14045:29;14077:33;14092:17;14077:14;:33::i;:::-;14045:65;;14120:3;:7;;;14128:34;;;14164:21;14120:66;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;14197:30;14239:21;14230:37;;;:39;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;14197:72;;14279:3;:7;;;14287:35;;;14324:22;14279:68;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;14358:27;14388:42;14412:17;14388:23;:42::i;:::-;14358:72;;14440:3;:7;;;14448:32;;;14482:19;14440:62;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;14513:41;14557:56;14595:17;14557:37;:56::i;:::-;14513:100;;14623:3;:7;;;14631:46;;;14679:33;14623:90;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;13474:1246;;;;;;;;13384:1336;;:::o;14726:1190::-;14832:29;14864:3;:25;;;:27;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;14832:59;;14901:3;:7;;;14909:34;;;14945:21;14901:66;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;14978:35;15025:21;15016:41;;;:43;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;14978:81;;15069:3;:7;;;15077:40;;;15119:27;15069:78;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;15158:26;15187:47;15206:27;15187:18;:47::i;:::-;15158:76;;15244:3;:7;;;15252:31;;;15285:18;15244:60;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;15315:27;15345:52;15369:27;15345:23;:52::i;:::-;15315:82;;15407:3;:7;;;15415:32;;;15449:19;15407:62;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;15480:23;15506:33;15519:19;15506:12;:33::i;:::-;15480:59;;15549:3;:7;;;15557:28;;;15587:15;15549:54;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;15614:23;15640:40;15660:19;15640;:40::i;:::-;15614:66;;15690:3;:7;;;15698:28;;;15728:15;15690:54;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;15755:29;15787:46;15813:19;15787:25;:46::i;:::-;15755:78;;15843:3;:7;;;15851:34;;;15887:21;15843:66;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;14822:1094;;;;;;;14726:1190;;:::o;15922:3713::-;15996:25;16024:3;:21;;;:23;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;15996:51;;16057:27;16087:3;:23;;;:25;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;16057:55;;16136:19;16127:47;;;:49;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;16123:909;;16375:3;:7;;;16383:30;;;16429:16;16375:72;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;16461:27;16515:19;16506:38;;;:40;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;16502:240;;16695:19;16686:39;;;:41;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;16664:63;;16502:240;;;16615:9;16593:31;;16547:92;16502:240;16755:3;:7;;;16763:32;;;16797:19;16755:62;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;16832:16;16860:19;16851:38;;;:40;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;16832:59;;16905:3;:7;;;16913:21;;;16936:8;16905:40;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;17015:7;;;;;;16123:909;16220:3;:7;;;16228:30;;;16260:9;16220:50;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;16177:104;17042:31;17076:46;17104:17;17076:27;:46::i;:::-;17042:80;;17171:1;17136:37;;:23;:37;;;17132:2497;;17189:3;:7;;;17197:36;;;17235:23;17189:70;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;17274:35;17312:52;17340:23;17312:27;:52::i;:::-;17274:90;;17421:1;17382:41;;:27;:41;;;17378:1278;;17498:3;:7;;;17506:25;;;17533:4;17498:40;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;17556:3;:7;;;17564:40;;;17606:27;17556:78;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;17653:18;17683:27;17674:48;;;:50;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;17653:71;;17742:3;:7;;;17750:23;;;17775:10;17742:44;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;17805:32;17849:27;17840:57;;;:59;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;17805:94;;17917:3;:7;;;17925:37;;;17964:24;17917:72;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;18008:16;18036:27;18027:46;;;:48;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;18008:67;;18093:3;:7;;;18101:21;;;18124:8;18093:40;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;18152;18195:49;18216:27;18195:20;:49::i;:::-;18152:92;;18262:3;:7;;;18270:45;;;18317:32;18262:88;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;18369:16;18397:27;18388:40;;;:42;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;18369:61;;18448:3;:7;;;18456:21;;;18479:8;18448:40;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;18507:26;18545:8;18536:25;;;:27;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;18507:56;;18581:3;:7;;;18589:31;;;18622:18;18581:60;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;17425:1231;;;;;;17378:1278;18670:28;18701:45;18722:23;18701:20;:45::i;:::-;18670:76;;18796:1;18764:34;;:20;:34;;;18760:470;;18875:3;:7;;;18883:33;;;18918:20;18875:64;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;18957:3;:7;;;18965:27;;;18994:4;18957:42;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;19018;19063;19084:20;19063;:42::i;:::-;19018:87;;19123:3;:7;;;19131:47;;;19180:34;19123:92;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;18800:430;18760:470;17175:2065;;17132:2497;;;19344:27;19383:19;19374:39;;;:41;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;19344:71;;19429:3;:7;;;19437:32;;;19471:19;19429:62;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;19505:16;19533:19;19524:38;;;:40;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;19505:59;;19578:3;:7;;;19586:21;;;19609:8;19578:40;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;19246:383;;17132:2497;15986:3649;;;15922:3713;;:::o;23587:224::-;23666:7;23685:19;23716:18;23707:40;;;:42;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;23685:64;;23790:11;23782:20;;23759:45;;;23587:224;;;:::o;23817:169::-;23887:7;336:42:40;23906:8:120;;;23923:1;23906:20;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;23952:18;23943:34;;;:36;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;23936:43;;23817:169;;;:::o;20891:299::-;20975:7;21007:18;20998:43;;;:45;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;20994:190;;21171:1;21156:17;;;;20994:190;21104:20;21097:27;;;20891:299;;;;:::o;21196:377::-;21294:7;21326:18;21317:57;;;:59;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;21313:254;;21554:1;21539:17;;;;21313:254;21473:34;21466:41;;;21196:377;;;;:::o;20535:350::-;20624:7;20643:36;20682:1;20643:40;;20693:12;20729:28;20759;20718:70;;;;;;;;;:::i;:::-;;;;;;;;;;;;;20708:81;;;;;;20693:96;;336:42:40;20831:7:120;;;20839:28;20869:4;20831:43;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;20822:54;;20799:79;;;;20535:350;;;:::o;20191:338::-;20285:7;20317:28;20308:45;;;:47;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;20304:219;;20474:28;20465:45;;;:47;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;20458:54;;;;20304:219;20411:15;20404:22;;;20191:338;;;;:::o;19641:256::-;19703:7;19735;19726:26;;;:28;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;19722:169;;19861:7;19852:26;;;:28;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;19845:35;;;;19722:169;19804:9;19797:16;;;19641:256;;;;:::o;22994:277::-;23076:7;23108:20;23099:41;;;:43;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;23095:170;;23252:1;23237:17;;;;23095:170;23194:11;23187:18;;;22994:277;;;;:::o;21983:311::-;22071:7;22103:20;22094:47;;;:49;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;22090:198;;22275:1;22260:17;;;;22090:198;22206:22;22199:29;;;21983:311;;;;:::o;21579:398::-;21667:7;21699:18;21690:47;;;:49;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;21686:285;;21958:1;21943:17;;;;21686:285;21804:24;21797:31;;;21579:398;;;;:::o;22619:369::-;22713:7;22745:24;22736:44;;;1677:1:155;22736:75:120;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;22732:250;;22969:1;22954:17;;;;22732:250;22898:24;22891:31;;;22619:369;;;;:::o;23277:304::-;23352:7;23372;23381:17;23410:12;23402:32;;23435:33;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;23402:67;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;23371:98;;;;23483:2;:23;;;;;23504:2;23489:4;:11;:17;23483:23;23479:95;;;23526:4;23515:27;;;;;;;;;;;;:::i;:::-;23508:34;;;;;;23479:95;23572:1;23557:17;;;;23277:304;;;;:::o;22300:313::-;22387:7;22419:24;22410:44;;;1534:1:155;22410:62:120;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;22406:201;;22594:1;22579:17;;;;22406:201;22530:17;22523:24;;;22300:313;;;;:::o;7:90:207:-;41:7;84:5;77:13;70:21;59:32;;7:90;;;:::o;103:109::-;184:21;199:5;184:21;:::i;:::-;179:3;172:34;103:109;;:::o;218:210::-;305:4;343:2;332:9;328:18;320:26;;356:65;418:1;407:9;403:17;394:6;356:65;:::i;:::-;218:210;;;;:::o;515:117::-;624:1;621;614:12;761:126;798:7;838:42;831:5;827:54;816:65;;761:126;;;:::o;893:96::-;930:7;959:24;977:5;959:24;:::i;:::-;948:35;;893:96;;;:::o;995:125::-;1061:7;1090:24;1108:5;1090:24;:::i;:::-;1079:35;;995:125;;;:::o;1126:180::-;1228:53;1275:5;1228:53;:::i;:::-;1221:5;1218:64;1208:92;;1296:1;1293;1286:12;1208:92;1126:180;:::o;1312:197::-;1387:5;1425:6;1412:20;1403:29;;1441:62;1497:5;1441:62;:::i;:::-;1312:197;;;;:::o;1515:126::-;1582:7;1611:24;1629:5;1611:24;:::i;:::-;1600:35;;1515:126;;;:::o;1647:182::-;1750:54;1798:5;1750:54;:::i;:::-;1743:5;1740:65;1730:93;;1819:1;1816;1809:12;1730:93;1647:182;:::o;1835:199::-;1911:5;1949:6;1936:20;1927:29;;1965:63;2022:5;1965:63;:::i;:::-;1835:199;;;;:::o;2040:592::-;2167:6;2175;2224:2;2212:9;2203:7;2199:23;2195:32;2192:119;;;2230:79;;:::i;:::-;2192:119;2350:1;2375:82;2449:7;2440:6;2429:9;2425:22;2375:82;:::i;:::-;2365:92;;2321:146;2506:2;2532:83;2607:7;2598:6;2587:9;2583:22;2532:83;:::i;:::-;2522:93;;2477:148;2040:592;;;;;:::o;2638:122::-;2711:24;2729:5;2711:24;:::i;:::-;2704:5;2701:35;2691:63;;2750:1;2747;2740:12;2691:63;2638:122;:::o;2766:143::-;2823:5;2854:6;2848:13;2839:22;;2870:33;2897:5;2870:33;:::i;:::-;2766:143;;;;:::o;2915:351::-;2985:6;3034:2;3022:9;3013:7;3009:23;3005:32;3002:119;;;3040:79;;:::i;:::-;3002:119;3160:1;3185:64;3241:7;3232:6;3221:9;3217:22;3185:64;:::i;:::-;3175:74;;3131:128;2915:351;;;;:::o;3272:149::-;3308:7;3348:66;3341:5;3337:78;3326:89;;3272:149;;;:::o;3427:115::-;3512:23;3529:5;3512:23;:::i;:::-;3507:3;3500:36;3427:115;;:::o;3548:118::-;3635:24;3653:5;3635:24;:::i;:::-;3630:3;3623:37;3548:118;;:::o;3672:328::-;3791:4;3829:2;3818:9;3814:18;3806:26;;3842:69;3908:1;3897:9;3893:17;3884:6;3842:69;:::i;:::-;3921:72;3989:2;3978:9;3974:18;3965:6;3921:72;:::i;:::-;3672:328;;;;;:::o;4006:93::-;4042:7;4082:10;4075:5;4071:22;4060:33;;4006:93;;;:::o;4105:151::-;4208:23;4225:5;4208:23;:::i;:::-;4201:5;4198:34;4188:62;;4246:1;4243;4236:12;4188:62;4105:151;:::o;4262:203::-;4349:5;4380:6;4374:13;4365:22;;4396:63;4453:5;4396:63;:::i;:::-;4262:203;;;;:::o;4471:411::-;4571:6;4620:2;4608:9;4599:7;4595:23;4591:32;4588:119;;;4626:79;;:::i;:::-;4588:119;4746:1;4771:94;4857:7;4848:6;4837:9;4833:22;4771:94;:::i;:::-;4761:104;;4717:158;4471:411;;;;:::o;4888:60::-;4916:3;4937:5;4930:12;;4888:60;;;:::o;4954:138::-;5002:9;5035:51;5052:33;5061:23;5078:5;5061:23;:::i;:::-;5052:33;:::i;:::-;5035:51;:::i;:::-;5022:64;;4954:138;;;:::o;5098:158::-;5214:35;5243:5;5214:35;:::i;:::-;5209:3;5202:48;5098:158;;:::o;5262:386::-;5410:4;5448:2;5437:9;5433:18;5425:26;;5461:69;5527:1;5516:9;5512:17;5503:6;5461:69;:::i;:::-;5540:101;5637:2;5626:9;5622:18;5613:6;5540:101;:::i;:::-;5262:386;;;;;:::o;5654:316::-;5767:4;5805:2;5794:9;5790:18;5782:26;;5818:69;5884:1;5873:9;5869:17;5860:6;5818:69;:::i;:::-;5897:66;5959:2;5948:9;5944:18;5935:6;5897:66;:::i;:::-;5654:316;;;;;:::o;5976:77::-;6013:7;6042:5;6031:16;;5976:77;;;:::o;6059:122::-;6132:24;6150:5;6132:24;:::i;:::-;6125:5;6122:35;6112:63;;6171:1;6168;6161:12;6112:63;6059:122;:::o;6187:143::-;6244:5;6275:6;6269:13;6260:22;;6291:33;6318:5;6291:33;:::i;:::-;6187:143;;;;:::o;6336:351::-;6406:6;6455:2;6443:9;6434:7;6430:23;6426:32;6423:119;;;6461:79;;:::i;:::-;6423:119;6581:1;6606:64;6662:7;6653:6;6642:9;6638:22;6606:64;:::i;:::-;6596:74;;6552:128;6336:351;;;;:::o;6693:222::-;6786:4;6824:2;6813:9;6809:18;6801:26;;6837:71;6905:1;6894:9;6890:17;6881:6;6837:71;:::i;:::-;6693:222;;;;:::o;6921:77::-;6958:7;6987:5;6976:16;;6921:77;;;:::o;7004:118::-;7091:24;7109:5;7091:24;:::i;:::-;7086:3;7079:37;7004:118;;:::o;7128:332::-;7249:4;7287:2;7276:9;7272:18;7264:26;;7300:71;7368:1;7357:9;7353:17;7344:6;7300:71;:::i;:::-;7381:72;7449:2;7438:9;7434:18;7425:6;7381:72;:::i;:::-;7128:332;;;;;:::o;7466:118::-;7553:24;7571:5;7553:24;:::i;:::-;7548:3;7541:37;7466:118;;:::o;7590:332::-;7711:4;7749:2;7738:9;7734:18;7726:26;;7762:71;7830:1;7819:9;7815:17;7806:6;7762:71;:::i;:::-;7843:72;7911:2;7900:9;7896:18;7887:6;7843:72;:::i;:::-;7590:332;;;;;:::o;7928:280::-;8050:4;8088:2;8077:9;8073:18;8065:26;;8101:100;8198:1;8187:9;8183:17;8174:6;8101:100;:::i;:::-;7928:280;;;;:::o;8214:98::-;8265:6;8299:5;8293:12;8283:22;;8214:98;;;:::o;8318:147::-;8419:11;8456:3;8441:18;;8318:147;;;;:::o;8471:139::-;8560:6;8555:3;8550;8544:23;8601:1;8592:6;8587:3;8583:16;8576:27;8471:139;;;:::o;8616:386::-;8720:3;8748:38;8780:5;8748:38;:::i;:::-;8802:88;8883:6;8878:3;8802:88;:::i;:::-;8795:95;;8899:65;8957:6;8952:3;8945:4;8938:5;8934:16;8899:65;:::i;:::-;8989:6;8984:3;8980:16;8973:23;;8724:278;8616:386;;;;:::o;9008:271::-;9138:3;9160:93;9249:3;9240:6;9160:93;:::i;:::-;9153:100;;9270:3;9263:10;;9008:271;;;;:::o;9285:104::-;9330:7;9359:24;9377:5;9359:24;:::i;:::-;9348:35;;9285:104;;;:::o;9395:138::-;9476:32;9502:5;9476:32;:::i;:::-;9469:5;9466:43;9456:71;;9523:1;9520;9513:12;9456:71;9395:138;:::o;9539:159::-;9604:5;9635:6;9629:13;9620:22;;9651:41;9686:5;9651:41;:::i;:::-;9539:159;;;;:::o;9704:367::-;9782:6;9831:2;9819:9;9810:7;9806:23;9802:32;9799:119;;;9837:79;;:::i;:::-;9799:119;9957:1;9982:72;10046:7;10037:6;10026:9;10022:22;9982:72;:::i;:::-;9972:82;;9928:136;9704:367;;;;:::o","linkReferences":{}},"methodIdentifiers":{"IS_SCRIPT()":"f8ccbf47","run(address,address)":"fc4dcacb"},"rawMetadata":"{\"compiler\":{\"version\":\"0.8.25+commit.b61c2a91\"},\"language\":\"Solidity\",\"output\":{\"abi\":[{\"inputs\":[],\"name\":\"IS_SCRIPT\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"contract FetchChainInfoInput\",\"name\":\"_fi\",\"type\":\"address\"},{\"internalType\":\"contract FetchChainInfoOutput\",\"name\":\"_fo\",\"type\":\"address\"}],\"name\":\"run\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"}],\"devdoc\":{\"kind\":\"dev\",\"methods\":{},\"version\":1},\"userdoc\":{\"kind\":\"user\",\"methods\":{},\"version\":1}},\"settings\":{\"compilationTarget\":{\"scripts/FetchChainInfo.s.sol\":\"FetchChainInfo\"},\"evmVersion\":\"cancun\",\"libraries\":{},\"metadata\":{\"bytecodeHash\":\"none\",\"useLiteralContent\":true},\"optimizer\":{\"enabled\":false,\"runs\":999999},\"remappings\":[\":@lib-keccak/=lib/lib-keccak/contracts/lib/\",\":@openzeppelin/contracts-upgradeable/=lib/openzeppelin-contracts-upgradeable/contracts/\",\":@openzeppelin/contracts-v5/=lib/openzeppelin-contracts-v5/contracts/\",\":@openzeppelin/contracts/=lib/openzeppelin-contracts/contracts/\",\":@rari-capital/solmate/=lib/solmate/\",\":@solady-test/=lib/lib-keccak/lib/solady/test/\",\":@solady-v0.0.245/=lib/solady-v0.0.245/src/\",\":@solady/=lib/solady/src/\",\":ds-test/=lib/forge-std/lib/ds-test/src/\",\":erc4626-tests/=lib/openzeppelin-contracts-v5/lib/erc4626-tests/\",\":forge-std/=lib/forge-std/src/\",\":interfaces/=interfaces/\",\":kontrol-cheatcodes/=lib/kontrol-cheatcodes/src/\",\":lib-keccak/=lib/lib-keccak/contracts/\",\":openzeppelin-contracts-upgradeable/=lib/openzeppelin-contracts-upgradeable/\",\":openzeppelin-contracts-v5/=lib/openzeppelin-contracts-v5/\",\":openzeppelin-contracts/=lib/openzeppelin-contracts/\",\":safe-contracts/=lib/safe-contracts/contracts/\",\":solady-v0.0.245/=lib/solady-v0.0.245/src/\",\":solady/=lib/solady/\",\":solmate/=lib/solmate/src/\"]},\"sources\":{\"lib/forge-std/src/Base.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity >=0.6.2 <0.9.0;\\n\\nimport {StdStorage} from \\\"./StdStorage.sol\\\";\\nimport {Vm, VmSafe} from \\\"./Vm.sol\\\";\\n\\nabstract contract CommonBase {\\n /// @dev Cheat code address.\\n /// Calculated as `address(uint160(uint256(keccak256(\\\"hevm cheat code\\\"))))`.\\n address internal constant VM_ADDRESS = 0x7109709ECfa91a80626fF3989D68f67F5b1DD12D;\\n /// @dev console.sol and console2.sol work by executing a staticcall to this address.\\n /// Calculated as `address(uint160(uint88(bytes11(\\\"console.log\\\"))))`.\\n address internal constant CONSOLE = 0x000000000000000000636F6e736F6c652e6c6f67;\\n /// @dev Used when deploying with create2.\\n /// Taken from https://github.com/Arachnid/deterministic-deployment-proxy.\\n address internal constant CREATE2_FACTORY = 0x4e59b44847b379578588920cA78FbF26c0B4956C;\\n /// @dev The default address for tx.origin and msg.sender.\\n /// Calculated as `address(uint160(uint256(keccak256(\\\"foundry default caller\\\"))))`.\\n address internal constant DEFAULT_SENDER = 0x1804c8AB1F12E6bbf3894d4083f33e07309d1f38;\\n /// @dev The address of the first contract `CREATE`d by a running test contract.\\n /// When running tests, each test contract is `CREATE`d by `DEFAULT_SENDER` with nonce 1.\\n /// Calculated as `VM.computeCreateAddress(VM.computeCreateAddress(DEFAULT_SENDER, 1), 1)`.\\n address internal constant DEFAULT_TEST_CONTRACT = 0x5615dEB798BB3E4dFa0139dFa1b3D433Cc23b72f;\\n /// @dev Deterministic deployment address of the Multicall3 contract.\\n /// Taken from https://www.multicall3.com.\\n address internal constant MULTICALL3_ADDRESS = 0xcA11bde05977b3631167028862bE2a173976CA11;\\n /// @dev The order of the secp256k1 curve.\\n uint256 internal constant SECP256K1_ORDER =\\n 115792089237316195423570985008687907852837564279074904382605163141518161494337;\\n\\n uint256 internal constant UINT256_MAX =\\n 115792089237316195423570985008687907853269984665640564039457584007913129639935;\\n\\n Vm internal constant vm = Vm(VM_ADDRESS);\\n StdStorage internal stdstore;\\n}\\n\\nabstract contract TestBase is CommonBase {}\\n\\nabstract contract ScriptBase is CommonBase {\\n VmSafe internal constant vmSafe = VmSafe(VM_ADDRESS);\\n}\\n\",\"keccak256\":\"0xa3735a6618a3014e42bb4329ad143e3b2c59cd95094350202e4c4a06c9d585dd\",\"license\":\"MIT\"},\"lib/forge-std/src/Script.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity >=0.6.2 <0.9.0;\\n\\n// \\ud83d\\udcac ABOUT\\n// Forge Std's default Script.\\n\\n// \\ud83e\\udde9 MODULES\\nimport {console} from \\\"./console.sol\\\";\\nimport {console2} from \\\"./console2.sol\\\";\\nimport {safeconsole} from \\\"./safeconsole.sol\\\";\\nimport {StdChains} from \\\"./StdChains.sol\\\";\\nimport {StdCheatsSafe} from \\\"./StdCheats.sol\\\";\\nimport {StdConstants} from \\\"./StdConstants.sol\\\";\\nimport {stdJson} from \\\"./StdJson.sol\\\";\\nimport {stdMath} from \\\"./StdMath.sol\\\";\\nimport {StdStorage, stdStorageSafe} from \\\"./StdStorage.sol\\\";\\nimport {StdStyle} from \\\"./StdStyle.sol\\\";\\nimport {StdUtils} from \\\"./StdUtils.sol\\\";\\nimport {VmSafe} from \\\"./Vm.sol\\\";\\n\\n// \\ud83d\\udce6 BOILERPLATE\\nimport {ScriptBase} from \\\"./Base.sol\\\";\\n\\n// \\u2b50\\ufe0f SCRIPT\\nabstract contract Script is ScriptBase, StdChains, StdCheatsSafe, StdUtils {\\n // Note: IS_SCRIPT() must return true.\\n bool public IS_SCRIPT = true;\\n}\\n\",\"keccak256\":\"0xc942e27c7baae499beb01afbbae99f24d42af9a6e4aae675bc6901b704aa8e9b\",\"license\":\"MIT\"},\"lib/forge-std/src/StdChains.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity >=0.6.2 <0.9.0;\\n\\nimport {VmSafe} from \\\"./Vm.sol\\\";\\n\\n/**\\n * StdChains provides information about EVM compatible chains that can be used in scripts/tests.\\n * For each chain, the chain's name, chain ID, and a default RPC URL are provided. Chains are\\n * identified by their alias, which is the same as the alias in the `[rpc_endpoints]` section of\\n * the `foundry.toml` file. For best UX, ensure the alias in the `foundry.toml` file match the\\n * alias used in this contract, which can be found as the first argument to the\\n * `setChainWithDefaultRpcUrl` call in the `initializeStdChains` function.\\n *\\n * There are two main ways to use this contract:\\n * 1. Set a chain with `setChain(string memory chainAlias, ChainData memory chain)` or\\n * `setChain(string memory chainAlias, Chain memory chain)`\\n * 2. Get a chain with `getChain(string memory chainAlias)` or `getChain(uint256 chainId)`.\\n *\\n * The first time either of those are used, chains are initialized with the default set of RPC URLs.\\n * This is done in `initializeStdChains`, which uses `setChainWithDefaultRpcUrl`. Defaults are recorded in\\n * `defaultRpcUrls`.\\n *\\n * The `setChain` function is straightforward, and it simply saves off the given chain data.\\n *\\n * The `getChain` methods use `getChainWithUpdatedRpcUrl` to return a chain. For example, let's say\\n * we want to retrieve the RPC URL for `mainnet`:\\n * - If you have specified data with `setChain`, it will return that.\\n * - If you have configured a mainnet RPC URL in `foundry.toml`, it will return the URL, provided it\\n * is valid (e.g. a URL is specified, or an environment variable is given and exists).\\n * - If neither of the above conditions is met, the default data is returned.\\n *\\n * Summarizing the above, the prioritization hierarchy is `setChain` -> `foundry.toml` -> environment variable -> defaults.\\n */\\nabstract contract StdChains {\\n VmSafe private constant vm = VmSafe(address(uint160(uint256(keccak256(\\\"hevm cheat code\\\")))));\\n\\n bool private stdChainsInitialized;\\n\\n struct ChainData {\\n string name;\\n uint256 chainId;\\n string rpcUrl;\\n }\\n\\n struct Chain {\\n // The chain name.\\n string name;\\n // The chain's Chain ID.\\n uint256 chainId;\\n // The chain's alias. (i.e. what gets specified in `foundry.toml`).\\n string chainAlias;\\n // A default RPC endpoint for this chain.\\n // NOTE: This default RPC URL is included for convenience to facilitate quick tests and\\n // experimentation. Do not use this RPC URL for production test suites, CI, or other heavy\\n // usage as you will be throttled and this is a disservice to others who need this endpoint.\\n string rpcUrl;\\n }\\n\\n // Maps from the chain's alias (matching the alias in the `foundry.toml` file) to chain data.\\n mapping(string => Chain) private chains;\\n // Maps from the chain's alias to it's default RPC URL.\\n mapping(string => string) private defaultRpcUrls;\\n // Maps from a chain ID to it's alias.\\n mapping(uint256 => string) private idToAlias;\\n\\n bool private fallbackToDefaultRpcUrls = true;\\n\\n // The RPC URL will be fetched from config or defaultRpcUrls if possible.\\n function getChain(string memory chainAlias) internal virtual returns (Chain memory chain) {\\n require(bytes(chainAlias).length != 0, \\\"StdChains getChain(string): Chain alias cannot be the empty string.\\\");\\n\\n initializeStdChains();\\n chain = chains[chainAlias];\\n require(\\n chain.chainId != 0,\\n string(abi.encodePacked(\\\"StdChains getChain(string): Chain with alias \\\\\\\"\\\", chainAlias, \\\"\\\\\\\" not found.\\\"))\\n );\\n\\n chain = getChainWithUpdatedRpcUrl(chainAlias, chain);\\n }\\n\\n function getChain(uint256 chainId) internal virtual returns (Chain memory chain) {\\n require(chainId != 0, \\\"StdChains getChain(uint256): Chain ID cannot be 0.\\\");\\n initializeStdChains();\\n string memory chainAlias = idToAlias[chainId];\\n\\n chain = chains[chainAlias];\\n\\n require(\\n chain.chainId != 0,\\n string(abi.encodePacked(\\\"StdChains getChain(uint256): Chain with ID \\\", vm.toString(chainId), \\\" not found.\\\"))\\n );\\n\\n chain = getChainWithUpdatedRpcUrl(chainAlias, chain);\\n }\\n\\n // set chain info, with priority to argument's rpcUrl field.\\n function setChain(string memory chainAlias, ChainData memory chain) internal virtual {\\n require(\\n bytes(chainAlias).length != 0,\\n \\\"StdChains setChain(string,ChainData): Chain alias cannot be the empty string.\\\"\\n );\\n\\n require(chain.chainId != 0, \\\"StdChains setChain(string,ChainData): Chain ID cannot be 0.\\\");\\n\\n initializeStdChains();\\n string memory foundAlias = idToAlias[chain.chainId];\\n\\n require(\\n bytes(foundAlias).length == 0 || keccak256(bytes(foundAlias)) == keccak256(bytes(chainAlias)),\\n string(\\n abi.encodePacked(\\n \\\"StdChains setChain(string,ChainData): Chain ID \\\",\\n vm.toString(chain.chainId),\\n \\\" already used by \\\\\\\"\\\",\\n foundAlias,\\n \\\"\\\\\\\".\\\"\\n )\\n )\\n );\\n\\n uint256 oldChainId = chains[chainAlias].chainId;\\n delete idToAlias[oldChainId];\\n\\n chains[chainAlias] =\\n Chain({name: chain.name, chainId: chain.chainId, chainAlias: chainAlias, rpcUrl: chain.rpcUrl});\\n idToAlias[chain.chainId] = chainAlias;\\n }\\n\\n // set chain info, with priority to argument's rpcUrl field.\\n function setChain(string memory chainAlias, Chain memory chain) internal virtual {\\n setChain(chainAlias, ChainData({name: chain.name, chainId: chain.chainId, rpcUrl: chain.rpcUrl}));\\n }\\n\\n function _toUpper(string memory str) private pure returns (string memory) {\\n bytes memory strb = bytes(str);\\n bytes memory copy = new bytes(strb.length);\\n for (uint256 i = 0; i < strb.length; i++) {\\n bytes1 b = strb[i];\\n if (b >= 0x61 && b <= 0x7A) {\\n copy[i] = bytes1(uint8(b) - 32);\\n } else {\\n copy[i] = b;\\n }\\n }\\n return string(copy);\\n }\\n\\n // lookup rpcUrl, in descending order of priority:\\n // current -> config (foundry.toml) -> environment variable -> default\\n function getChainWithUpdatedRpcUrl(string memory chainAlias, Chain memory chain)\\n private\\n view\\n returns (Chain memory)\\n {\\n if (bytes(chain.rpcUrl).length == 0) {\\n try vm.rpcUrl(chainAlias) returns (string memory configRpcUrl) {\\n chain.rpcUrl = configRpcUrl;\\n } catch (bytes memory err) {\\n string memory envName = string(abi.encodePacked(_toUpper(chainAlias), \\\"_RPC_URL\\\"));\\n if (fallbackToDefaultRpcUrls) {\\n chain.rpcUrl = vm.envOr(envName, defaultRpcUrls[chainAlias]);\\n } else {\\n chain.rpcUrl = vm.envString(envName);\\n }\\n // Distinguish 'not found' from 'cannot read'\\n // The upstream error thrown by forge for failing cheats changed so we check both the old and new versions\\n bytes memory oldNotFoundError =\\n abi.encodeWithSignature(\\\"CheatCodeError\\\", string(abi.encodePacked(\\\"invalid rpc url \\\", chainAlias)));\\n bytes memory newNotFoundError = abi.encodeWithSignature(\\n \\\"CheatcodeError(string)\\\", string(abi.encodePacked(\\\"invalid rpc url: \\\", chainAlias))\\n );\\n bytes32 errHash = keccak256(err);\\n if (\\n (errHash != keccak256(oldNotFoundError) && errHash != keccak256(newNotFoundError))\\n || bytes(chain.rpcUrl).length == 0\\n ) {\\n /// @solidity memory-safe-assembly\\n assembly {\\n revert(add(32, err), mload(err))\\n }\\n }\\n }\\n }\\n return chain;\\n }\\n\\n function setFallbackToDefaultRpcUrls(bool useDefault) internal {\\n fallbackToDefaultRpcUrls = useDefault;\\n }\\n\\n function initializeStdChains() private {\\n if (stdChainsInitialized) return;\\n\\n stdChainsInitialized = true;\\n\\n // If adding an RPC here, make sure to test the default RPC URL in `test_Rpcs` in `StdChains.t.sol`\\n setChainWithDefaultRpcUrl(\\\"anvil\\\", ChainData(\\\"Anvil\\\", 31337, \\\"http://127.0.0.1:8545\\\"));\\n setChainWithDefaultRpcUrl(\\\"mainnet\\\", ChainData(\\\"Mainnet\\\", 1, \\\"https://eth.llamarpc.com\\\"));\\n setChainWithDefaultRpcUrl(\\n \\\"sepolia\\\", ChainData(\\\"Sepolia\\\", 11155111, \\\"https://sepolia.infura.io/v3/b9794ad1ddf84dfb8c34d6bb5dca2001\\\")\\n );\\n setChainWithDefaultRpcUrl(\\\"holesky\\\", ChainData(\\\"Holesky\\\", 17000, \\\"https://rpc.holesky.ethpandaops.io\\\"));\\n setChainWithDefaultRpcUrl(\\\"optimism\\\", ChainData(\\\"Optimism\\\", 10, \\\"https://mainnet.optimism.io\\\"));\\n setChainWithDefaultRpcUrl(\\n \\\"optimism_sepolia\\\", ChainData(\\\"Optimism Sepolia\\\", 11155420, \\\"https://sepolia.optimism.io\\\")\\n );\\n setChainWithDefaultRpcUrl(\\\"arbitrum_one\\\", ChainData(\\\"Arbitrum One\\\", 42161, \\\"https://arb1.arbitrum.io/rpc\\\"));\\n setChainWithDefaultRpcUrl(\\n \\\"arbitrum_one_sepolia\\\", ChainData(\\\"Arbitrum One Sepolia\\\", 421614, \\\"https://sepolia-rollup.arbitrum.io/rpc\\\")\\n );\\n setChainWithDefaultRpcUrl(\\\"arbitrum_nova\\\", ChainData(\\\"Arbitrum Nova\\\", 42170, \\\"https://nova.arbitrum.io/rpc\\\"));\\n setChainWithDefaultRpcUrl(\\\"polygon\\\", ChainData(\\\"Polygon\\\", 137, \\\"https://polygon-rpc.com\\\"));\\n setChainWithDefaultRpcUrl(\\n \\\"polygon_amoy\\\", ChainData(\\\"Polygon Amoy\\\", 80002, \\\"https://rpc-amoy.polygon.technology\\\")\\n );\\n setChainWithDefaultRpcUrl(\\\"avalanche\\\", ChainData(\\\"Avalanche\\\", 43114, \\\"https://api.avax.network/ext/bc/C/rpc\\\"));\\n setChainWithDefaultRpcUrl(\\n \\\"avalanche_fuji\\\", ChainData(\\\"Avalanche Fuji\\\", 43113, \\\"https://api.avax-test.network/ext/bc/C/rpc\\\")\\n );\\n setChainWithDefaultRpcUrl(\\n \\\"bnb_smart_chain\\\", ChainData(\\\"BNB Smart Chain\\\", 56, \\\"https://bsc-dataseed1.binance.org\\\")\\n );\\n setChainWithDefaultRpcUrl(\\n \\\"bnb_smart_chain_testnet\\\",\\n ChainData(\\\"BNB Smart Chain Testnet\\\", 97, \\\"https://rpc.ankr.com/bsc_testnet_chapel\\\")\\n );\\n setChainWithDefaultRpcUrl(\\\"gnosis_chain\\\", ChainData(\\\"Gnosis Chain\\\", 100, \\\"https://rpc.gnosischain.com\\\"));\\n setChainWithDefaultRpcUrl(\\\"moonbeam\\\", ChainData(\\\"Moonbeam\\\", 1284, \\\"https://rpc.api.moonbeam.network\\\"));\\n setChainWithDefaultRpcUrl(\\n \\\"moonriver\\\", ChainData(\\\"Moonriver\\\", 1285, \\\"https://rpc.api.moonriver.moonbeam.network\\\")\\n );\\n setChainWithDefaultRpcUrl(\\\"moonbase\\\", ChainData(\\\"Moonbase\\\", 1287, \\\"https://rpc.testnet.moonbeam.network\\\"));\\n setChainWithDefaultRpcUrl(\\\"base_sepolia\\\", ChainData(\\\"Base Sepolia\\\", 84532, \\\"https://sepolia.base.org\\\"));\\n setChainWithDefaultRpcUrl(\\\"base\\\", ChainData(\\\"Base\\\", 8453, \\\"https://mainnet.base.org\\\"));\\n setChainWithDefaultRpcUrl(\\\"blast_sepolia\\\", ChainData(\\\"Blast Sepolia\\\", 168587773, \\\"https://sepolia.blast.io\\\"));\\n setChainWithDefaultRpcUrl(\\\"blast\\\", ChainData(\\\"Blast\\\", 81457, \\\"https://rpc.blast.io\\\"));\\n setChainWithDefaultRpcUrl(\\\"fantom_opera\\\", ChainData(\\\"Fantom Opera\\\", 250, \\\"https://rpc.ankr.com/fantom/\\\"));\\n setChainWithDefaultRpcUrl(\\n \\\"fantom_opera_testnet\\\", ChainData(\\\"Fantom Opera Testnet\\\", 4002, \\\"https://rpc.ankr.com/fantom_testnet/\\\")\\n );\\n setChainWithDefaultRpcUrl(\\\"fraxtal\\\", ChainData(\\\"Fraxtal\\\", 252, \\\"https://rpc.frax.com\\\"));\\n setChainWithDefaultRpcUrl(\\\"fraxtal_testnet\\\", ChainData(\\\"Fraxtal Testnet\\\", 2522, \\\"https://rpc.testnet.frax.com\\\"));\\n setChainWithDefaultRpcUrl(\\n \\\"berachain_bartio_testnet\\\", ChainData(\\\"Berachain bArtio Testnet\\\", 80084, \\\"https://bartio.rpc.berachain.com\\\")\\n );\\n setChainWithDefaultRpcUrl(\\\"flare\\\", ChainData(\\\"Flare\\\", 14, \\\"https://flare-api.flare.network/ext/C/rpc\\\"));\\n setChainWithDefaultRpcUrl(\\n \\\"flare_coston2\\\", ChainData(\\\"Flare Coston2\\\", 114, \\\"https://coston2-api.flare.network/ext/C/rpc\\\")\\n );\\n\\n setChainWithDefaultRpcUrl(\\\"mode\\\", ChainData(\\\"Mode\\\", 34443, \\\"https://mode.drpc.org\\\"));\\n setChainWithDefaultRpcUrl(\\\"mode_sepolia\\\", ChainData(\\\"Mode Sepolia\\\", 919, \\\"https://sepolia.mode.network\\\"));\\n\\n setChainWithDefaultRpcUrl(\\\"zora\\\", ChainData(\\\"Zora\\\", 7777777, \\\"https://zora.drpc.org\\\"));\\n setChainWithDefaultRpcUrl(\\n \\\"zora_sepolia\\\", ChainData(\\\"Zora Sepolia\\\", 999999999, \\\"https://sepolia.rpc.zora.energy\\\")\\n );\\n\\n setChainWithDefaultRpcUrl(\\\"race\\\", ChainData(\\\"Race\\\", 6805, \\\"https://racemainnet.io\\\"));\\n setChainWithDefaultRpcUrl(\\\"race_sepolia\\\", ChainData(\\\"Race Sepolia\\\", 6806, \\\"https://racemainnet.io\\\"));\\n\\n setChainWithDefaultRpcUrl(\\\"metal\\\", ChainData(\\\"Metal\\\", 1750, \\\"https://metall2.drpc.org\\\"));\\n setChainWithDefaultRpcUrl(\\\"metal_sepolia\\\", ChainData(\\\"Metal Sepolia\\\", 1740, \\\"https://testnet.rpc.metall2.com\\\"));\\n\\n setChainWithDefaultRpcUrl(\\\"binary\\\", ChainData(\\\"Binary\\\", 624, \\\"https://rpc.zero.thebinaryholdings.com\\\"));\\n setChainWithDefaultRpcUrl(\\n \\\"binary_sepolia\\\", ChainData(\\\"Binary Sepolia\\\", 625, \\\"https://rpc.zero.thebinaryholdings.com\\\")\\n );\\n\\n setChainWithDefaultRpcUrl(\\\"orderly\\\", ChainData(\\\"Orderly\\\", 291, \\\"https://rpc.orderly.network\\\"));\\n setChainWithDefaultRpcUrl(\\n \\\"orderly_sepolia\\\", ChainData(\\\"Orderly Sepolia\\\", 4460, \\\"https://testnet-rpc.orderly.org\\\")\\n );\\n }\\n\\n // set chain info, with priority to chainAlias' rpc url in foundry.toml\\n function setChainWithDefaultRpcUrl(string memory chainAlias, ChainData memory chain) private {\\n string memory rpcUrl = chain.rpcUrl;\\n defaultRpcUrls[chainAlias] = rpcUrl;\\n chain.rpcUrl = \\\"\\\";\\n setChain(chainAlias, chain);\\n chain.rpcUrl = rpcUrl; // restore argument\\n }\\n}\\n\",\"keccak256\":\"0x200b597cd01c229633b4a2317846cac7d36d337e2381b4a2e81faac23c2ad1cf\",\"license\":\"MIT\"},\"lib/forge-std/src/StdCheats.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity >=0.6.2 <0.9.0;\\n\\npragma experimental ABIEncoderV2;\\n\\nimport {StdStorage, stdStorage} from \\\"./StdStorage.sol\\\";\\nimport {console2} from \\\"./console2.sol\\\";\\nimport {Vm} from \\\"./Vm.sol\\\";\\n\\nabstract contract StdCheatsSafe {\\n Vm private constant vm = Vm(address(uint160(uint256(keccak256(\\\"hevm cheat code\\\")))));\\n\\n uint256 private constant UINT256_MAX =\\n 115792089237316195423570985008687907853269984665640564039457584007913129639935;\\n\\n bool private gasMeteringOff;\\n\\n // Data structures to parse Transaction objects from the broadcast artifact\\n // that conform to EIP1559. The Raw structs is what is parsed from the JSON\\n // and then converted to the one that is used by the user for better UX.\\n\\n struct RawTx1559 {\\n string[] arguments;\\n address contractAddress;\\n string contractName;\\n // json value name = function\\n string functionSig;\\n bytes32 hash;\\n // json value name = tx\\n RawTx1559Detail txDetail;\\n // json value name = type\\n string opcode;\\n }\\n\\n struct RawTx1559Detail {\\n AccessList[] accessList;\\n bytes data;\\n address from;\\n bytes gas;\\n bytes nonce;\\n address to;\\n bytes txType;\\n bytes value;\\n }\\n\\n struct Tx1559 {\\n string[] arguments;\\n address contractAddress;\\n string contractName;\\n string functionSig;\\n bytes32 hash;\\n Tx1559Detail txDetail;\\n string opcode;\\n }\\n\\n struct Tx1559Detail {\\n AccessList[] accessList;\\n bytes data;\\n address from;\\n uint256 gas;\\n uint256 nonce;\\n address to;\\n uint256 txType;\\n uint256 value;\\n }\\n\\n // Data structures to parse Transaction objects from the broadcast artifact\\n // that DO NOT conform to EIP1559. The Raw structs is what is parsed from the JSON\\n // and then converted to the one that is used by the user for better UX.\\n\\n struct TxLegacy {\\n string[] arguments;\\n address contractAddress;\\n string contractName;\\n string functionSig;\\n string hash;\\n string opcode;\\n TxDetailLegacy transaction;\\n }\\n\\n struct TxDetailLegacy {\\n AccessList[] accessList;\\n uint256 chainId;\\n bytes data;\\n address from;\\n uint256 gas;\\n uint256 gasPrice;\\n bytes32 hash;\\n uint256 nonce;\\n bytes1 opcode;\\n bytes32 r;\\n bytes32 s;\\n uint256 txType;\\n address to;\\n uint8 v;\\n uint256 value;\\n }\\n\\n struct AccessList {\\n address accessAddress;\\n bytes32[] storageKeys;\\n }\\n\\n // Data structures to parse Receipt objects from the broadcast artifact.\\n // The Raw structs is what is parsed from the JSON\\n // and then converted to the one that is used by the user for better UX.\\n\\n struct RawReceipt {\\n bytes32 blockHash;\\n bytes blockNumber;\\n address contractAddress;\\n bytes cumulativeGasUsed;\\n bytes effectiveGasPrice;\\n address from;\\n bytes gasUsed;\\n RawReceiptLog[] logs;\\n bytes logsBloom;\\n bytes status;\\n address to;\\n bytes32 transactionHash;\\n bytes transactionIndex;\\n }\\n\\n struct Receipt {\\n bytes32 blockHash;\\n uint256 blockNumber;\\n address contractAddress;\\n uint256 cumulativeGasUsed;\\n uint256 effectiveGasPrice;\\n address from;\\n uint256 gasUsed;\\n ReceiptLog[] logs;\\n bytes logsBloom;\\n uint256 status;\\n address to;\\n bytes32 transactionHash;\\n uint256 transactionIndex;\\n }\\n\\n // Data structures to parse the entire broadcast artifact, assuming the\\n // transactions conform to EIP1559.\\n\\n struct EIP1559ScriptArtifact {\\n string[] libraries;\\n string path;\\n string[] pending;\\n Receipt[] receipts;\\n uint256 timestamp;\\n Tx1559[] transactions;\\n TxReturn[] txReturns;\\n }\\n\\n struct RawEIP1559ScriptArtifact {\\n string[] libraries;\\n string path;\\n string[] pending;\\n RawReceipt[] receipts;\\n TxReturn[] txReturns;\\n uint256 timestamp;\\n RawTx1559[] transactions;\\n }\\n\\n struct RawReceiptLog {\\n // json value = address\\n address logAddress;\\n bytes32 blockHash;\\n bytes blockNumber;\\n bytes data;\\n bytes logIndex;\\n bool removed;\\n bytes32[] topics;\\n bytes32 transactionHash;\\n bytes transactionIndex;\\n bytes transactionLogIndex;\\n }\\n\\n struct ReceiptLog {\\n // json value = address\\n address logAddress;\\n bytes32 blockHash;\\n uint256 blockNumber;\\n bytes data;\\n uint256 logIndex;\\n bytes32[] topics;\\n uint256 transactionIndex;\\n uint256 transactionLogIndex;\\n bool removed;\\n }\\n\\n struct TxReturn {\\n string internalType;\\n string value;\\n }\\n\\n struct Account {\\n address addr;\\n uint256 key;\\n }\\n\\n enum AddressType {\\n Payable,\\n NonPayable,\\n ZeroAddress,\\n Precompile,\\n ForgeAddress\\n }\\n\\n // Checks that `addr` is not blacklisted by token contracts that have a blacklist.\\n function assumeNotBlacklisted(address token, address addr) internal view virtual {\\n // Nothing to check if `token` is not a contract.\\n uint256 tokenCodeSize;\\n assembly {\\n tokenCodeSize := extcodesize(token)\\n }\\n require(tokenCodeSize > 0, \\\"StdCheats assumeNotBlacklisted(address,address): Token address is not a contract.\\\");\\n\\n bool success;\\n bytes memory returnData;\\n\\n // 4-byte selector for `isBlacklisted(address)`, used by USDC.\\n (success, returnData) = token.staticcall(abi.encodeWithSelector(0xfe575a87, addr));\\n vm.assume(!success || abi.decode(returnData, (bool)) == false);\\n\\n // 4-byte selector for `isBlackListed(address)`, used by USDT.\\n (success, returnData) = token.staticcall(abi.encodeWithSelector(0xe47d6060, addr));\\n vm.assume(!success || abi.decode(returnData, (bool)) == false);\\n }\\n\\n // Checks that `addr` is not blacklisted by token contracts that have a blacklist.\\n // This is identical to `assumeNotBlacklisted(address,address)` but with a different name, for\\n // backwards compatibility, since this name was used in the original PR which already has\\n // a release. This function can be removed in a future release once we want a breaking change.\\n function assumeNoBlacklisted(address token, address addr) internal view virtual {\\n assumeNotBlacklisted(token, addr);\\n }\\n\\n function assumeAddressIsNot(address addr, AddressType addressType) internal virtual {\\n if (addressType == AddressType.Payable) {\\n assumeNotPayable(addr);\\n } else if (addressType == AddressType.NonPayable) {\\n assumePayable(addr);\\n } else if (addressType == AddressType.ZeroAddress) {\\n assumeNotZeroAddress(addr);\\n } else if (addressType == AddressType.Precompile) {\\n assumeNotPrecompile(addr);\\n } else if (addressType == AddressType.ForgeAddress) {\\n assumeNotForgeAddress(addr);\\n }\\n }\\n\\n function assumeAddressIsNot(address addr, AddressType addressType1, AddressType addressType2) internal virtual {\\n assumeAddressIsNot(addr, addressType1);\\n assumeAddressIsNot(addr, addressType2);\\n }\\n\\n function assumeAddressIsNot(\\n address addr,\\n AddressType addressType1,\\n AddressType addressType2,\\n AddressType addressType3\\n ) internal virtual {\\n assumeAddressIsNot(addr, addressType1);\\n assumeAddressIsNot(addr, addressType2);\\n assumeAddressIsNot(addr, addressType3);\\n }\\n\\n function assumeAddressIsNot(\\n address addr,\\n AddressType addressType1,\\n AddressType addressType2,\\n AddressType addressType3,\\n AddressType addressType4\\n ) internal virtual {\\n assumeAddressIsNot(addr, addressType1);\\n assumeAddressIsNot(addr, addressType2);\\n assumeAddressIsNot(addr, addressType3);\\n assumeAddressIsNot(addr, addressType4);\\n }\\n\\n // This function checks whether an address, `addr`, is payable. It works by sending 1 wei to\\n // `addr` and checking the `success` return value.\\n // NOTE: This function may result in state changes depending on the fallback/receive logic\\n // implemented by `addr`, which should be taken into account when this function is used.\\n function _isPayable(address addr) private returns (bool) {\\n require(\\n addr.balance < UINT256_MAX,\\n \\\"StdCheats _isPayable(address): Balance equals max uint256, so it cannot receive any more funds\\\"\\n );\\n uint256 origBalanceTest = address(this).balance;\\n uint256 origBalanceAddr = address(addr).balance;\\n\\n vm.deal(address(this), 1);\\n (bool success,) = payable(addr).call{value: 1}(\\\"\\\");\\n\\n // reset balances\\n vm.deal(address(this), origBalanceTest);\\n vm.deal(addr, origBalanceAddr);\\n\\n return success;\\n }\\n\\n // NOTE: This function may result in state changes depending on the fallback/receive logic\\n // implemented by `addr`, which should be taken into account when this function is used. See the\\n // `_isPayable` method for more information.\\n function assumePayable(address addr) internal virtual {\\n vm.assume(_isPayable(addr));\\n }\\n\\n function assumeNotPayable(address addr) internal virtual {\\n vm.assume(!_isPayable(addr));\\n }\\n\\n function assumeNotZeroAddress(address addr) internal pure virtual {\\n vm.assume(addr != address(0));\\n }\\n\\n function assumeNotPrecompile(address addr) internal pure virtual {\\n assumeNotPrecompile(addr, _pureChainId());\\n }\\n\\n function assumeNotPrecompile(address addr, uint256 chainId) internal pure virtual {\\n // Note: For some chains like Optimism these are technically predeploys (i.e. bytecode placed at a specific\\n // address), but the same rationale for excluding them applies so we include those too.\\n\\n // These are reserved by Ethereum and may be on all EVM-compatible chains.\\n vm.assume(addr < address(0x1) || addr > address(0xff));\\n\\n // forgefmt: disable-start\\n if (chainId == 10 || chainId == 420) {\\n // https://github.com/ethereum-optimism/optimism/blob/eaa371a0184b56b7ca6d9eb9cb0a2b78b2ccd864/op-bindings/predeploys/addresses.go#L6-L21\\n vm.assume(addr < address(0x4200000000000000000000000000000000000000) || addr > address(0x4200000000000000000000000000000000000800));\\n } else if (chainId == 42161 || chainId == 421613) {\\n // https://developer.arbitrum.io/useful-addresses#arbitrum-precompiles-l2-same-on-all-arb-chains\\n vm.assume(addr < address(0x0000000000000000000000000000000000000064) || addr > address(0x0000000000000000000000000000000000000068));\\n } else if (chainId == 43114 || chainId == 43113) {\\n // https://github.com/ava-labs/subnet-evm/blob/47c03fd007ecaa6de2c52ea081596e0a88401f58/precompile/params.go#L18-L59\\n vm.assume(addr < address(0x0100000000000000000000000000000000000000) || addr > address(0x01000000000000000000000000000000000000ff));\\n vm.assume(addr < address(0x0200000000000000000000000000000000000000) || addr > address(0x02000000000000000000000000000000000000FF));\\n vm.assume(addr < address(0x0300000000000000000000000000000000000000) || addr > address(0x03000000000000000000000000000000000000Ff));\\n }\\n // forgefmt: disable-end\\n }\\n\\n function assumeNotForgeAddress(address addr) internal pure virtual {\\n // vm, console, and Create2Deployer addresses\\n vm.assume(\\n addr != address(vm) && addr != 0x000000000000000000636F6e736F6c652e6c6f67\\n && addr != 0x4e59b44847b379578588920cA78FbF26c0B4956C\\n );\\n }\\n\\n function assumeUnusedAddress(address addr) internal view virtual {\\n uint256 size;\\n assembly {\\n size := extcodesize(addr)\\n }\\n vm.assume(size == 0);\\n\\n assumeNotPrecompile(addr);\\n assumeNotZeroAddress(addr);\\n assumeNotForgeAddress(addr);\\n }\\n\\n function readEIP1559ScriptArtifact(string memory path)\\n internal\\n view\\n virtual\\n returns (EIP1559ScriptArtifact memory)\\n {\\n string memory data = vm.readFile(path);\\n bytes memory parsedData = vm.parseJson(data);\\n RawEIP1559ScriptArtifact memory rawArtifact = abi.decode(parsedData, (RawEIP1559ScriptArtifact));\\n EIP1559ScriptArtifact memory artifact;\\n artifact.libraries = rawArtifact.libraries;\\n artifact.path = rawArtifact.path;\\n artifact.timestamp = rawArtifact.timestamp;\\n artifact.pending = rawArtifact.pending;\\n artifact.txReturns = rawArtifact.txReturns;\\n artifact.receipts = rawToConvertedReceipts(rawArtifact.receipts);\\n artifact.transactions = rawToConvertedEIPTx1559s(rawArtifact.transactions);\\n return artifact;\\n }\\n\\n function rawToConvertedEIPTx1559s(RawTx1559[] memory rawTxs) internal pure virtual returns (Tx1559[] memory) {\\n Tx1559[] memory txs = new Tx1559[](rawTxs.length);\\n for (uint256 i; i < rawTxs.length; i++) {\\n txs[i] = rawToConvertedEIPTx1559(rawTxs[i]);\\n }\\n return txs;\\n }\\n\\n function rawToConvertedEIPTx1559(RawTx1559 memory rawTx) internal pure virtual returns (Tx1559 memory) {\\n Tx1559 memory transaction;\\n transaction.arguments = rawTx.arguments;\\n transaction.contractName = rawTx.contractName;\\n transaction.functionSig = rawTx.functionSig;\\n transaction.hash = rawTx.hash;\\n transaction.txDetail = rawToConvertedEIP1559Detail(rawTx.txDetail);\\n transaction.opcode = rawTx.opcode;\\n return transaction;\\n }\\n\\n function rawToConvertedEIP1559Detail(RawTx1559Detail memory rawDetail)\\n internal\\n pure\\n virtual\\n returns (Tx1559Detail memory)\\n {\\n Tx1559Detail memory txDetail;\\n txDetail.data = rawDetail.data;\\n txDetail.from = rawDetail.from;\\n txDetail.to = rawDetail.to;\\n txDetail.nonce = _bytesToUint(rawDetail.nonce);\\n txDetail.txType = _bytesToUint(rawDetail.txType);\\n txDetail.value = _bytesToUint(rawDetail.value);\\n txDetail.gas = _bytesToUint(rawDetail.gas);\\n txDetail.accessList = rawDetail.accessList;\\n return txDetail;\\n }\\n\\n function readTx1559s(string memory path) internal view virtual returns (Tx1559[] memory) {\\n string memory deployData = vm.readFile(path);\\n bytes memory parsedDeployData = vm.parseJson(deployData, \\\".transactions\\\");\\n RawTx1559[] memory rawTxs = abi.decode(parsedDeployData, (RawTx1559[]));\\n return rawToConvertedEIPTx1559s(rawTxs);\\n }\\n\\n function readTx1559(string memory path, uint256 index) internal view virtual returns (Tx1559 memory) {\\n string memory deployData = vm.readFile(path);\\n string memory key = string(abi.encodePacked(\\\".transactions[\\\", vm.toString(index), \\\"]\\\"));\\n bytes memory parsedDeployData = vm.parseJson(deployData, key);\\n RawTx1559 memory rawTx = abi.decode(parsedDeployData, (RawTx1559));\\n return rawToConvertedEIPTx1559(rawTx);\\n }\\n\\n // Analogous to readTransactions, but for receipts.\\n function readReceipts(string memory path) internal view virtual returns (Receipt[] memory) {\\n string memory deployData = vm.readFile(path);\\n bytes memory parsedDeployData = vm.parseJson(deployData, \\\".receipts\\\");\\n RawReceipt[] memory rawReceipts = abi.decode(parsedDeployData, (RawReceipt[]));\\n return rawToConvertedReceipts(rawReceipts);\\n }\\n\\n function readReceipt(string memory path, uint256 index) internal view virtual returns (Receipt memory) {\\n string memory deployData = vm.readFile(path);\\n string memory key = string(abi.encodePacked(\\\".receipts[\\\", vm.toString(index), \\\"]\\\"));\\n bytes memory parsedDeployData = vm.parseJson(deployData, key);\\n RawReceipt memory rawReceipt = abi.decode(parsedDeployData, (RawReceipt));\\n return rawToConvertedReceipt(rawReceipt);\\n }\\n\\n function rawToConvertedReceipts(RawReceipt[] memory rawReceipts) internal pure virtual returns (Receipt[] memory) {\\n Receipt[] memory receipts = new Receipt[](rawReceipts.length);\\n for (uint256 i; i < rawReceipts.length; i++) {\\n receipts[i] = rawToConvertedReceipt(rawReceipts[i]);\\n }\\n return receipts;\\n }\\n\\n function rawToConvertedReceipt(RawReceipt memory rawReceipt) internal pure virtual returns (Receipt memory) {\\n Receipt memory receipt;\\n receipt.blockHash = rawReceipt.blockHash;\\n receipt.to = rawReceipt.to;\\n receipt.from = rawReceipt.from;\\n receipt.contractAddress = rawReceipt.contractAddress;\\n receipt.effectiveGasPrice = _bytesToUint(rawReceipt.effectiveGasPrice);\\n receipt.cumulativeGasUsed = _bytesToUint(rawReceipt.cumulativeGasUsed);\\n receipt.gasUsed = _bytesToUint(rawReceipt.gasUsed);\\n receipt.status = _bytesToUint(rawReceipt.status);\\n receipt.transactionIndex = _bytesToUint(rawReceipt.transactionIndex);\\n receipt.blockNumber = _bytesToUint(rawReceipt.blockNumber);\\n receipt.logs = rawToConvertedReceiptLogs(rawReceipt.logs);\\n receipt.logsBloom = rawReceipt.logsBloom;\\n receipt.transactionHash = rawReceipt.transactionHash;\\n return receipt;\\n }\\n\\n function rawToConvertedReceiptLogs(RawReceiptLog[] memory rawLogs)\\n internal\\n pure\\n virtual\\n returns (ReceiptLog[] memory)\\n {\\n ReceiptLog[] memory logs = new ReceiptLog[](rawLogs.length);\\n for (uint256 i; i < rawLogs.length; i++) {\\n logs[i].logAddress = rawLogs[i].logAddress;\\n logs[i].blockHash = rawLogs[i].blockHash;\\n logs[i].blockNumber = _bytesToUint(rawLogs[i].blockNumber);\\n logs[i].data = rawLogs[i].data;\\n logs[i].logIndex = _bytesToUint(rawLogs[i].logIndex);\\n logs[i].topics = rawLogs[i].topics;\\n logs[i].transactionIndex = _bytesToUint(rawLogs[i].transactionIndex);\\n logs[i].transactionLogIndex = _bytesToUint(rawLogs[i].transactionLogIndex);\\n logs[i].removed = rawLogs[i].removed;\\n }\\n return logs;\\n }\\n\\n // Deploy a contract by fetching the contract bytecode from\\n // the artifacts directory\\n // e.g. `deployCode(code, abi.encode(arg1,arg2,arg3))`\\n function deployCode(string memory what, bytes memory args) internal virtual returns (address addr) {\\n bytes memory bytecode = abi.encodePacked(vm.getCode(what), args);\\n /// @solidity memory-safe-assembly\\n assembly {\\n addr := create(0, add(bytecode, 0x20), mload(bytecode))\\n }\\n\\n require(addr != address(0), \\\"StdCheats deployCode(string,bytes): Deployment failed.\\\");\\n }\\n\\n function deployCode(string memory what) internal virtual returns (address addr) {\\n bytes memory bytecode = vm.getCode(what);\\n /// @solidity memory-safe-assembly\\n assembly {\\n addr := create(0, add(bytecode, 0x20), mload(bytecode))\\n }\\n\\n require(addr != address(0), \\\"StdCheats deployCode(string): Deployment failed.\\\");\\n }\\n\\n /// @dev deploy contract with value on construction\\n function deployCode(string memory what, bytes memory args, uint256 val) internal virtual returns (address addr) {\\n bytes memory bytecode = abi.encodePacked(vm.getCode(what), args);\\n /// @solidity memory-safe-assembly\\n assembly {\\n addr := create(val, add(bytecode, 0x20), mload(bytecode))\\n }\\n\\n require(addr != address(0), \\\"StdCheats deployCode(string,bytes,uint256): Deployment failed.\\\");\\n }\\n\\n function deployCode(string memory what, uint256 val) internal virtual returns (address addr) {\\n bytes memory bytecode = vm.getCode(what);\\n /// @solidity memory-safe-assembly\\n assembly {\\n addr := create(val, add(bytecode, 0x20), mload(bytecode))\\n }\\n\\n require(addr != address(0), \\\"StdCheats deployCode(string,uint256): Deployment failed.\\\");\\n }\\n\\n // creates a labeled address and the corresponding private key\\n function makeAddrAndKey(string memory name) internal virtual returns (address addr, uint256 privateKey) {\\n privateKey = uint256(keccak256(abi.encodePacked(name)));\\n addr = vm.addr(privateKey);\\n vm.label(addr, name);\\n }\\n\\n // creates a labeled address\\n function makeAddr(string memory name) internal virtual returns (address addr) {\\n (addr,) = makeAddrAndKey(name);\\n }\\n\\n // Destroys an account immediately, sending the balance to beneficiary.\\n // Destroying means: balance will be zero, code will be empty, and nonce will be 0\\n // This is similar to selfdestruct but not identical: selfdestruct destroys code and nonce\\n // only after tx ends, this will run immediately.\\n function destroyAccount(address who, address beneficiary) internal virtual {\\n uint256 currBalance = who.balance;\\n vm.etch(who, abi.encode());\\n vm.deal(who, 0);\\n vm.resetNonce(who);\\n\\n uint256 beneficiaryBalance = beneficiary.balance;\\n vm.deal(beneficiary, currBalance + beneficiaryBalance);\\n }\\n\\n // creates a struct containing both a labeled address and the corresponding private key\\n function makeAccount(string memory name) internal virtual returns (Account memory account) {\\n (account.addr, account.key) = makeAddrAndKey(name);\\n }\\n\\n function deriveRememberKey(string memory mnemonic, uint32 index)\\n internal\\n virtual\\n returns (address who, uint256 privateKey)\\n {\\n privateKey = vm.deriveKey(mnemonic, index);\\n who = vm.rememberKey(privateKey);\\n }\\n\\n function _bytesToUint(bytes memory b) private pure returns (uint256) {\\n require(b.length <= 32, \\\"StdCheats _bytesToUint(bytes): Bytes length exceeds 32.\\\");\\n return abi.decode(abi.encodePacked(new bytes(32 - b.length), b), (uint256));\\n }\\n\\n function isFork() internal view virtual returns (bool status) {\\n try vm.activeFork() {\\n status = true;\\n } catch (bytes memory) {}\\n }\\n\\n modifier skipWhenForking() {\\n if (!isFork()) {\\n _;\\n }\\n }\\n\\n modifier skipWhenNotForking() {\\n if (isFork()) {\\n _;\\n }\\n }\\n\\n modifier noGasMetering() {\\n vm.pauseGasMetering();\\n // To prevent turning gas monitoring back on with nested functions that use this modifier,\\n // we check if gasMetering started in the off position. If it did, we don't want to turn\\n // it back on until we exit the top level function that used the modifier\\n //\\n // i.e. funcA() noGasMetering { funcB() }, where funcB has noGasMetering as well.\\n // funcA will have `gasStartedOff` as false, funcB will have it as true,\\n // so we only turn metering back on at the end of the funcA\\n bool gasStartedOff = gasMeteringOff;\\n gasMeteringOff = true;\\n\\n _;\\n\\n // if gas metering was on when this modifier was called, turn it back on at the end\\n if (!gasStartedOff) {\\n gasMeteringOff = false;\\n vm.resumeGasMetering();\\n }\\n }\\n\\n // We use this complex approach of `_viewChainId` and `_pureChainId` to ensure there are no\\n // compiler warnings when accessing chain ID in any solidity version supported by forge-std. We\\n // can't simply access the chain ID in a normal view or pure function because the solc View Pure\\n // Checker changed `chainid` from pure to view in 0.8.0.\\n function _viewChainId() private view returns (uint256 chainId) {\\n // Assembly required since `block.chainid` was introduced in 0.8.0.\\n assembly {\\n chainId := chainid()\\n }\\n\\n address(this); // Silence warnings in older Solc versions.\\n }\\n\\n function _pureChainId() private pure returns (uint256 chainId) {\\n function() internal view returns (uint256) fnIn = _viewChainId;\\n function() internal pure returns (uint256) pureChainId;\\n assembly {\\n pureChainId := fnIn\\n }\\n chainId = pureChainId();\\n }\\n}\\n\\n// Wrappers around cheatcodes to avoid footguns\\nabstract contract StdCheats is StdCheatsSafe {\\n using stdStorage for StdStorage;\\n\\n StdStorage private stdstore;\\n Vm private constant vm = Vm(address(uint160(uint256(keccak256(\\\"hevm cheat code\\\")))));\\n address private constant CONSOLE2_ADDRESS = 0x000000000000000000636F6e736F6c652e6c6f67;\\n\\n // Skip forward or rewind time by the specified number of seconds\\n function skip(uint256 time) internal virtual {\\n vm.warp(vm.getBlockTimestamp() + time);\\n }\\n\\n function rewind(uint256 time) internal virtual {\\n vm.warp(vm.getBlockTimestamp() - time);\\n }\\n\\n // Setup a prank from an address that has some ether\\n function hoax(address msgSender) internal virtual {\\n vm.deal(msgSender, 1 << 128);\\n vm.prank(msgSender);\\n }\\n\\n function hoax(address msgSender, uint256 give) internal virtual {\\n vm.deal(msgSender, give);\\n vm.prank(msgSender);\\n }\\n\\n function hoax(address msgSender, address origin) internal virtual {\\n vm.deal(msgSender, 1 << 128);\\n vm.prank(msgSender, origin);\\n }\\n\\n function hoax(address msgSender, address origin, uint256 give) internal virtual {\\n vm.deal(msgSender, give);\\n vm.prank(msgSender, origin);\\n }\\n\\n // Start perpetual prank from an address that has some ether\\n function startHoax(address msgSender) internal virtual {\\n vm.deal(msgSender, 1 << 128);\\n vm.startPrank(msgSender);\\n }\\n\\n function startHoax(address msgSender, uint256 give) internal virtual {\\n vm.deal(msgSender, give);\\n vm.startPrank(msgSender);\\n }\\n\\n // Start perpetual prank from an address that has some ether\\n // tx.origin is set to the origin parameter\\n function startHoax(address msgSender, address origin) internal virtual {\\n vm.deal(msgSender, 1 << 128);\\n vm.startPrank(msgSender, origin);\\n }\\n\\n function startHoax(address msgSender, address origin, uint256 give) internal virtual {\\n vm.deal(msgSender, give);\\n vm.startPrank(msgSender, origin);\\n }\\n\\n function changePrank(address msgSender) internal virtual {\\n console2_log_StdCheats(\\\"changePrank is deprecated. Please use vm.startPrank instead.\\\");\\n vm.stopPrank();\\n vm.startPrank(msgSender);\\n }\\n\\n function changePrank(address msgSender, address txOrigin) internal virtual {\\n vm.stopPrank();\\n vm.startPrank(msgSender, txOrigin);\\n }\\n\\n // The same as Vm's `deal`\\n // Use the alternative signature for ERC20 tokens\\n function deal(address to, uint256 give) internal virtual {\\n vm.deal(to, give);\\n }\\n\\n // Set the balance of an account for any ERC20 token\\n // Use the alternative signature to update `totalSupply`\\n function deal(address token, address to, uint256 give) internal virtual {\\n deal(token, to, give, false);\\n }\\n\\n // Set the balance of an account for any ERC1155 token\\n // Use the alternative signature to update `totalSupply`\\n function dealERC1155(address token, address to, uint256 id, uint256 give) internal virtual {\\n dealERC1155(token, to, id, give, false);\\n }\\n\\n function deal(address token, address to, uint256 give, bool adjust) internal virtual {\\n // get current balance\\n (, bytes memory balData) = token.staticcall(abi.encodeWithSelector(0x70a08231, to));\\n uint256 prevBal = abi.decode(balData, (uint256));\\n\\n // update balance\\n stdstore.target(token).sig(0x70a08231).with_key(to).checked_write(give);\\n\\n // update total supply\\n if (adjust) {\\n (, bytes memory totSupData) = token.staticcall(abi.encodeWithSelector(0x18160ddd));\\n uint256 totSup = abi.decode(totSupData, (uint256));\\n if (give < prevBal) {\\n totSup -= (prevBal - give);\\n } else {\\n totSup += (give - prevBal);\\n }\\n stdstore.target(token).sig(0x18160ddd).checked_write(totSup);\\n }\\n }\\n\\n function dealERC1155(address token, address to, uint256 id, uint256 give, bool adjust) internal virtual {\\n // get current balance\\n (, bytes memory balData) = token.staticcall(abi.encodeWithSelector(0x00fdd58e, to, id));\\n uint256 prevBal = abi.decode(balData, (uint256));\\n\\n // update balance\\n stdstore.target(token).sig(0x00fdd58e).with_key(to).with_key(id).checked_write(give);\\n\\n // update total supply\\n if (adjust) {\\n (, bytes memory totSupData) = token.staticcall(abi.encodeWithSelector(0xbd85b039, id));\\n require(\\n totSupData.length != 0,\\n \\\"StdCheats deal(address,address,uint,uint,bool): target contract is not ERC1155Supply.\\\"\\n );\\n uint256 totSup = abi.decode(totSupData, (uint256));\\n if (give < prevBal) {\\n totSup -= (prevBal - give);\\n } else {\\n totSup += (give - prevBal);\\n }\\n stdstore.target(token).sig(0xbd85b039).with_key(id).checked_write(totSup);\\n }\\n }\\n\\n function dealERC721(address token, address to, uint256 id) internal virtual {\\n // check if token id is already minted and the actual owner.\\n (bool successMinted, bytes memory ownerData) = token.staticcall(abi.encodeWithSelector(0x6352211e, id));\\n require(successMinted, \\\"StdCheats deal(address,address,uint,bool): id not minted.\\\");\\n\\n // get owner current balance\\n (, bytes memory fromBalData) =\\n token.staticcall(abi.encodeWithSelector(0x70a08231, abi.decode(ownerData, (address))));\\n uint256 fromPrevBal = abi.decode(fromBalData, (uint256));\\n\\n // get new user current balance\\n (, bytes memory toBalData) = token.staticcall(abi.encodeWithSelector(0x70a08231, to));\\n uint256 toPrevBal = abi.decode(toBalData, (uint256));\\n\\n // update balances\\n stdstore.target(token).sig(0x70a08231).with_key(abi.decode(ownerData, (address))).checked_write(--fromPrevBal);\\n stdstore.target(token).sig(0x70a08231).with_key(to).checked_write(++toPrevBal);\\n\\n // update owner\\n stdstore.target(token).sig(0x6352211e).with_key(id).checked_write(to);\\n }\\n\\n function deployCodeTo(string memory what, address where) internal virtual {\\n deployCodeTo(what, \\\"\\\", 0, where);\\n }\\n\\n function deployCodeTo(string memory what, bytes memory args, address where) internal virtual {\\n deployCodeTo(what, args, 0, where);\\n }\\n\\n function deployCodeTo(string memory what, bytes memory args, uint256 value, address where) internal virtual {\\n bytes memory creationCode = vm.getCode(what);\\n vm.etch(where, abi.encodePacked(creationCode, args));\\n (bool success, bytes memory runtimeBytecode) = where.call{value: value}(\\\"\\\");\\n require(success, \\\"StdCheats deployCodeTo(string,bytes,uint256,address): Failed to create runtime bytecode.\\\");\\n vm.etch(where, runtimeBytecode);\\n }\\n\\n // Used to prevent the compilation of console, which shortens the compilation time when console is not used elsewhere.\\n function console2_log_StdCheats(string memory p0) private view {\\n (bool status,) = address(CONSOLE2_ADDRESS).staticcall(abi.encodeWithSignature(\\\"log(string)\\\", p0));\\n status;\\n }\\n}\\n\",\"keccak256\":\"0x0fa6ec03602648b62cce41aab2096e6b7e052f2846075d967b6958dd586db746\",\"license\":\"MIT\"},\"lib/forge-std/src/StdConstants.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity >=0.6.2 <0.9.0;\\n\\nimport {IMulticall3} from \\\"./interfaces/IMulticall3.sol\\\";\\nimport {Vm} from \\\"./Vm.sol\\\";\\n\\nlibrary StdConstants {\\n /// @dev Cheat code address.\\n /// Calculated as `address(uint160(uint256(keccak256(\\\"hevm cheat code\\\"))))`.\\n Vm internal constant VM = Vm(0x7109709ECfa91a80626fF3989D68f67F5b1DD12D);\\n /// @dev console.sol and console2.sol work by executing a staticcall to this address.\\n /// Calculated as `address(uint160(uint88(bytes11(\\\"console.log\\\"))))`.\\n address internal constant CONSOLE = 0x000000000000000000636F6e736F6c652e6c6f67;\\n /// @dev Used when deploying with create2.\\n /// Taken from https://github.com/Arachnid/deterministic-deployment-proxy.\\n address internal constant CREATE2_FACTORY = 0x4e59b44847b379578588920cA78FbF26c0B4956C;\\n /// @dev The default address for tx.origin and msg.sender.\\n /// Calculated as `address(uint160(uint256(keccak256(\\\"foundry default caller\\\"))))`.\\n address internal constant DEFAULT_SENDER = 0x1804c8AB1F12E6bbf3894d4083f33e07309d1f38;\\n /// @dev The address of the first contract `CREATE`d by a running test contract.\\n /// When running tests, each test contract is `CREATE`d by `DEFAULT_SENDER` with nonce 1.\\n /// Calculated as `VM.computeCreateAddress(VM.computeCreateAddress(DEFAULT_SENDER, 1), 1)`.\\n address internal constant DEFAULT_TEST_CONTRACT = 0x5615dEB798BB3E4dFa0139dFa1b3D433Cc23b72f;\\n /// @dev Deterministic deployment address of the Multicall3 contract.\\n /// Taken from https://www.multicall3.com.\\n IMulticall3 internal constant MULTICALL3_ADDRESS = IMulticall3(0xcA11bde05977b3631167028862bE2a173976CA11);\\n /// @dev The order of the secp256k1 curve.\\n uint256 internal constant SECP256K1_ORDER =\\n 115792089237316195423570985008687907852837564279074904382605163141518161494337;\\n}\\n\",\"keccak256\":\"0x319ccdabfa2c0b2428301445873270ffea20f0e039d4fd5e6eeba65158e4e534\",\"license\":\"MIT\"},\"lib/forge-std/src/StdJson.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity >=0.6.0 <0.9.0;\\n\\npragma experimental ABIEncoderV2;\\n\\nimport {VmSafe} from \\\"./Vm.sol\\\";\\n\\n// Helpers for parsing and writing JSON files\\n// To parse:\\n// ```\\n// using stdJson for string;\\n// string memory json = vm.readFile(\\\"\\\");\\n// json.readUint(\\\"\\\");\\n// ```\\n// To write:\\n// ```\\n// using stdJson for string;\\n// string memory json = \\\"json\\\";\\n// json.serialize(\\\"a\\\", uint256(123));\\n// string memory semiFinal = json.serialize(\\\"b\\\", string(\\\"test\\\"));\\n// string memory finalJson = json.serialize(\\\"c\\\", semiFinal);\\n// finalJson.write(\\\"\\\");\\n// ```\\n\\nlibrary stdJson {\\n VmSafe private constant vm = VmSafe(address(uint160(uint256(keccak256(\\\"hevm cheat code\\\")))));\\n\\n function keyExists(string memory json, string memory key) internal view returns (bool) {\\n return vm.keyExistsJson(json, key);\\n }\\n\\n function parseRaw(string memory json, string memory key) internal pure returns (bytes memory) {\\n return vm.parseJson(json, key);\\n }\\n\\n function readUint(string memory json, string memory key) internal pure returns (uint256) {\\n return vm.parseJsonUint(json, key);\\n }\\n\\n function readUintArray(string memory json, string memory key) internal pure returns (uint256[] memory) {\\n return vm.parseJsonUintArray(json, key);\\n }\\n\\n function readInt(string memory json, string memory key) internal pure returns (int256) {\\n return vm.parseJsonInt(json, key);\\n }\\n\\n function readIntArray(string memory json, string memory key) internal pure returns (int256[] memory) {\\n return vm.parseJsonIntArray(json, key);\\n }\\n\\n function readBytes32(string memory json, string memory key) internal pure returns (bytes32) {\\n return vm.parseJsonBytes32(json, key);\\n }\\n\\n function readBytes32Array(string memory json, string memory key) internal pure returns (bytes32[] memory) {\\n return vm.parseJsonBytes32Array(json, key);\\n }\\n\\n function readString(string memory json, string memory key) internal pure returns (string memory) {\\n return vm.parseJsonString(json, key);\\n }\\n\\n function readStringArray(string memory json, string memory key) internal pure returns (string[] memory) {\\n return vm.parseJsonStringArray(json, key);\\n }\\n\\n function readAddress(string memory json, string memory key) internal pure returns (address) {\\n return vm.parseJsonAddress(json, key);\\n }\\n\\n function readAddressArray(string memory json, string memory key) internal pure returns (address[] memory) {\\n return vm.parseJsonAddressArray(json, key);\\n }\\n\\n function readBool(string memory json, string memory key) internal pure returns (bool) {\\n return vm.parseJsonBool(json, key);\\n }\\n\\n function readBoolArray(string memory json, string memory key) internal pure returns (bool[] memory) {\\n return vm.parseJsonBoolArray(json, key);\\n }\\n\\n function readBytes(string memory json, string memory key) internal pure returns (bytes memory) {\\n return vm.parseJsonBytes(json, key);\\n }\\n\\n function readBytesArray(string memory json, string memory key) internal pure returns (bytes[] memory) {\\n return vm.parseJsonBytesArray(json, key);\\n }\\n\\n function readUintOr(string memory json, string memory key, uint256 defaultValue) internal view returns (uint256) {\\n return keyExists(json, key) ? readUint(json, key) : defaultValue;\\n }\\n\\n function readUintArrayOr(string memory json, string memory key, uint256[] memory defaultValue)\\n internal\\n view\\n returns (uint256[] memory)\\n {\\n return keyExists(json, key) ? readUintArray(json, key) : defaultValue;\\n }\\n\\n function readIntOr(string memory json, string memory key, int256 defaultValue) internal view returns (int256) {\\n return keyExists(json, key) ? readInt(json, key) : defaultValue;\\n }\\n\\n function readIntArrayOr(string memory json, string memory key, int256[] memory defaultValue)\\n internal\\n view\\n returns (int256[] memory)\\n {\\n return keyExists(json, key) ? readIntArray(json, key) : defaultValue;\\n }\\n\\n function readBytes32Or(string memory json, string memory key, bytes32 defaultValue)\\n internal\\n view\\n returns (bytes32)\\n {\\n return keyExists(json, key) ? readBytes32(json, key) : defaultValue;\\n }\\n\\n function readBytes32ArrayOr(string memory json, string memory key, bytes32[] memory defaultValue)\\n internal\\n view\\n returns (bytes32[] memory)\\n {\\n return keyExists(json, key) ? readBytes32Array(json, key) : defaultValue;\\n }\\n\\n function readStringOr(string memory json, string memory key, string memory defaultValue)\\n internal\\n view\\n returns (string memory)\\n {\\n return keyExists(json, key) ? readString(json, key) : defaultValue;\\n }\\n\\n function readStringArrayOr(string memory json, string memory key, string[] memory defaultValue)\\n internal\\n view\\n returns (string[] memory)\\n {\\n return keyExists(json, key) ? readStringArray(json, key) : defaultValue;\\n }\\n\\n function readAddressOr(string memory json, string memory key, address defaultValue)\\n internal\\n view\\n returns (address)\\n {\\n return keyExists(json, key) ? readAddress(json, key) : defaultValue;\\n }\\n\\n function readAddressArrayOr(string memory json, string memory key, address[] memory defaultValue)\\n internal\\n view\\n returns (address[] memory)\\n {\\n return keyExists(json, key) ? readAddressArray(json, key) : defaultValue;\\n }\\n\\n function readBoolOr(string memory json, string memory key, bool defaultValue) internal view returns (bool) {\\n return keyExists(json, key) ? readBool(json, key) : defaultValue;\\n }\\n\\n function readBoolArrayOr(string memory json, string memory key, bool[] memory defaultValue)\\n internal\\n view\\n returns (bool[] memory)\\n {\\n return keyExists(json, key) ? readBoolArray(json, key) : defaultValue;\\n }\\n\\n function readBytesOr(string memory json, string memory key, bytes memory defaultValue)\\n internal\\n view\\n returns (bytes memory)\\n {\\n return keyExists(json, key) ? readBytes(json, key) : defaultValue;\\n }\\n\\n function readBytesArrayOr(string memory json, string memory key, bytes[] memory defaultValue)\\n internal\\n view\\n returns (bytes[] memory)\\n {\\n return keyExists(json, key) ? readBytesArray(json, key) : defaultValue;\\n }\\n\\n function serialize(string memory jsonKey, string memory rootObject) internal returns (string memory) {\\n return vm.serializeJson(jsonKey, rootObject);\\n }\\n\\n function serialize(string memory jsonKey, string memory key, bool value) internal returns (string memory) {\\n return vm.serializeBool(jsonKey, key, value);\\n }\\n\\n function serialize(string memory jsonKey, string memory key, bool[] memory value)\\n internal\\n returns (string memory)\\n {\\n return vm.serializeBool(jsonKey, key, value);\\n }\\n\\n function serialize(string memory jsonKey, string memory key, uint256 value) internal returns (string memory) {\\n return vm.serializeUint(jsonKey, key, value);\\n }\\n\\n function serialize(string memory jsonKey, string memory key, uint256[] memory value)\\n internal\\n returns (string memory)\\n {\\n return vm.serializeUint(jsonKey, key, value);\\n }\\n\\n function serialize(string memory jsonKey, string memory key, int256 value) internal returns (string memory) {\\n return vm.serializeInt(jsonKey, key, value);\\n }\\n\\n function serialize(string memory jsonKey, string memory key, int256[] memory value)\\n internal\\n returns (string memory)\\n {\\n return vm.serializeInt(jsonKey, key, value);\\n }\\n\\n function serialize(string memory jsonKey, string memory key, address value) internal returns (string memory) {\\n return vm.serializeAddress(jsonKey, key, value);\\n }\\n\\n function serialize(string memory jsonKey, string memory key, address[] memory value)\\n internal\\n returns (string memory)\\n {\\n return vm.serializeAddress(jsonKey, key, value);\\n }\\n\\n function serialize(string memory jsonKey, string memory key, bytes32 value) internal returns (string memory) {\\n return vm.serializeBytes32(jsonKey, key, value);\\n }\\n\\n function serialize(string memory jsonKey, string memory key, bytes32[] memory value)\\n internal\\n returns (string memory)\\n {\\n return vm.serializeBytes32(jsonKey, key, value);\\n }\\n\\n function serialize(string memory jsonKey, string memory key, bytes memory value) internal returns (string memory) {\\n return vm.serializeBytes(jsonKey, key, value);\\n }\\n\\n function serialize(string memory jsonKey, string memory key, bytes[] memory value)\\n internal\\n returns (string memory)\\n {\\n return vm.serializeBytes(jsonKey, key, value);\\n }\\n\\n function serialize(string memory jsonKey, string memory key, string memory value)\\n internal\\n returns (string memory)\\n {\\n return vm.serializeString(jsonKey, key, value);\\n }\\n\\n function serialize(string memory jsonKey, string memory key, string[] memory value)\\n internal\\n returns (string memory)\\n {\\n return vm.serializeString(jsonKey, key, value);\\n }\\n\\n function write(string memory jsonKey, string memory path) internal {\\n vm.writeJson(jsonKey, path);\\n }\\n\\n function write(string memory jsonKey, string memory path, string memory valueKey) internal {\\n vm.writeJson(jsonKey, path, valueKey);\\n }\\n}\\n\",\"keccak256\":\"0xbc0132abe1c2accc2867c0f03667afffdf92f3e95a581bb03c9557eaa38ea500\",\"license\":\"MIT\"},\"lib/forge-std/src/StdMath.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity >=0.6.2 <0.9.0;\\n\\nlibrary stdMath {\\n int256 private constant INT256_MIN = -57896044618658097711785492504343953926634992332820282019728792003956564819968;\\n\\n function abs(int256 a) internal pure returns (uint256) {\\n // Required or it will fail when `a = type(int256).min`\\n if (a == INT256_MIN) {\\n return 57896044618658097711785492504343953926634992332820282019728792003956564819968;\\n }\\n\\n return uint256(a > 0 ? a : -a);\\n }\\n\\n function delta(uint256 a, uint256 b) internal pure returns (uint256) {\\n return a > b ? a - b : b - a;\\n }\\n\\n function delta(int256 a, int256 b) internal pure returns (uint256) {\\n // a and b are of the same sign\\n // this works thanks to two's complement, the left-most bit is the sign bit\\n if ((a ^ b) > -1) {\\n return delta(abs(a), abs(b));\\n }\\n\\n // a and b are of opposite signs\\n return abs(a) + abs(b);\\n }\\n\\n function percentDelta(uint256 a, uint256 b) internal pure returns (uint256) {\\n uint256 absDelta = delta(a, b);\\n\\n return absDelta * 1e18 / b;\\n }\\n\\n function percentDelta(int256 a, int256 b) internal pure returns (uint256) {\\n uint256 absDelta = delta(a, b);\\n uint256 absB = abs(b);\\n\\n return absDelta * 1e18 / absB;\\n }\\n}\\n\",\"keccak256\":\"0xd90ad4fd8aeaeb8929964e686e769fdedd5eded3fc3815df194a0ab9f91a3fb2\",\"license\":\"MIT\"},\"lib/forge-std/src/StdStorage.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity >=0.6.2 <0.9.0;\\n\\nimport {Vm} from \\\"./Vm.sol\\\";\\n\\nstruct FindData {\\n uint256 slot;\\n uint256 offsetLeft;\\n uint256 offsetRight;\\n bool found;\\n}\\n\\nstruct StdStorage {\\n mapping(address => mapping(bytes4 => mapping(bytes32 => FindData))) finds;\\n bytes32[] _keys;\\n bytes4 _sig;\\n uint256 _depth;\\n address _target;\\n bytes32 _set;\\n bool _enable_packed_slots;\\n bytes _calldata;\\n}\\n\\nlibrary stdStorageSafe {\\n event SlotFound(address who, bytes4 fsig, bytes32 keysHash, uint256 slot);\\n event WARNING_UninitedSlot(address who, uint256 slot);\\n\\n Vm private constant vm = Vm(address(uint160(uint256(keccak256(\\\"hevm cheat code\\\")))));\\n uint256 constant UINT256_MAX = 115792089237316195423570985008687907853269984665640564039457584007913129639935;\\n\\n function sigs(string memory sigStr) internal pure returns (bytes4) {\\n return bytes4(keccak256(bytes(sigStr)));\\n }\\n\\n function getCallParams(StdStorage storage self) internal view returns (bytes memory) {\\n if (self._calldata.length == 0) {\\n return flatten(self._keys);\\n } else {\\n return self._calldata;\\n }\\n }\\n\\n // Calls target contract with configured parameters\\n function callTarget(StdStorage storage self) internal view returns (bool, bytes32) {\\n bytes memory cald = abi.encodePacked(self._sig, getCallParams(self));\\n (bool success, bytes memory rdat) = self._target.staticcall(cald);\\n bytes32 result = bytesToBytes32(rdat, 32 * self._depth);\\n\\n return (success, result);\\n }\\n\\n // Tries mutating slot value to determine if the targeted value is stored in it.\\n // If current value is 0, then we are setting slot value to type(uint256).max\\n // Otherwise, we set it to 0. That way, return value should always be affected.\\n function checkSlotMutatesCall(StdStorage storage self, bytes32 slot) internal returns (bool) {\\n bytes32 prevSlotValue = vm.load(self._target, slot);\\n (bool success, bytes32 prevReturnValue) = callTarget(self);\\n\\n bytes32 testVal = prevReturnValue == bytes32(0) ? bytes32(UINT256_MAX) : bytes32(0);\\n vm.store(self._target, slot, testVal);\\n\\n (, bytes32 newReturnValue) = callTarget(self);\\n\\n vm.store(self._target, slot, prevSlotValue);\\n\\n return (success && (prevReturnValue != newReturnValue));\\n }\\n\\n // Tries setting one of the bits in slot to 1 until return value changes.\\n // Index of resulted bit is an offset packed slot has from left/right side\\n function findOffset(StdStorage storage self, bytes32 slot, bool left) internal returns (bool, uint256) {\\n for (uint256 offset = 0; offset < 256; offset++) {\\n uint256 valueToPut = left ? (1 << (255 - offset)) : (1 << offset);\\n vm.store(self._target, slot, bytes32(valueToPut));\\n\\n (bool success, bytes32 data) = callTarget(self);\\n\\n if (success && (uint256(data) > 0)) {\\n return (true, offset);\\n }\\n }\\n return (false, 0);\\n }\\n\\n function findOffsets(StdStorage storage self, bytes32 slot) internal returns (bool, uint256, uint256) {\\n bytes32 prevSlotValue = vm.load(self._target, slot);\\n\\n (bool foundLeft, uint256 offsetLeft) = findOffset(self, slot, true);\\n (bool foundRight, uint256 offsetRight) = findOffset(self, slot, false);\\n\\n // `findOffset` may mutate slot value, so we are setting it to initial value\\n vm.store(self._target, slot, prevSlotValue);\\n return (foundLeft && foundRight, offsetLeft, offsetRight);\\n }\\n\\n function find(StdStorage storage self) internal returns (FindData storage) {\\n return find(self, true);\\n }\\n\\n /// @notice find an arbitrary storage slot given a function sig, input data, address of the contract and a value to check against\\n // slot complexity:\\n // if flat, will be bytes32(uint256(uint));\\n // if map, will be keccak256(abi.encode(key, uint(slot)));\\n // if deep map, will be keccak256(abi.encode(key1, keccak256(abi.encode(key0, uint(slot)))));\\n // if map struct, will be bytes32(uint256(keccak256(abi.encode(key1, keccak256(abi.encode(key0, uint(slot)))))) + structFieldDepth);\\n function find(StdStorage storage self, bool _clear) internal returns (FindData storage) {\\n address who = self._target;\\n bytes4 fsig = self._sig;\\n uint256 field_depth = self._depth;\\n bytes memory params = getCallParams(self);\\n\\n // calldata to test against\\n if (self.finds[who][fsig][keccak256(abi.encodePacked(params, field_depth))].found) {\\n if (_clear) {\\n clear(self);\\n }\\n return self.finds[who][fsig][keccak256(abi.encodePacked(params, field_depth))];\\n }\\n vm.record();\\n (, bytes32 callResult) = callTarget(self);\\n (bytes32[] memory reads,) = vm.accesses(address(who));\\n\\n if (reads.length == 0) {\\n revert(\\\"stdStorage find(StdStorage): No storage use detected for target.\\\");\\n } else {\\n for (uint256 i = reads.length; --i >= 0;) {\\n bytes32 prev = vm.load(who, reads[i]);\\n if (prev == bytes32(0)) {\\n emit WARNING_UninitedSlot(who, uint256(reads[i]));\\n }\\n\\n if (!checkSlotMutatesCall(self, reads[i])) {\\n continue;\\n }\\n\\n (uint256 offsetLeft, uint256 offsetRight) = (0, 0);\\n\\n if (self._enable_packed_slots) {\\n bool found;\\n (found, offsetLeft, offsetRight) = findOffsets(self, reads[i]);\\n if (!found) {\\n continue;\\n }\\n }\\n\\n // Check that value between found offsets is equal to the current call result\\n uint256 curVal = (uint256(prev) & getMaskByOffsets(offsetLeft, offsetRight)) >> offsetRight;\\n\\n if (uint256(callResult) != curVal) {\\n continue;\\n }\\n\\n emit SlotFound(who, fsig, keccak256(abi.encodePacked(params, field_depth)), uint256(reads[i]));\\n self.finds[who][fsig][keccak256(abi.encodePacked(params, field_depth))] =\\n FindData(uint256(reads[i]), offsetLeft, offsetRight, true);\\n break;\\n }\\n }\\n\\n require(\\n self.finds[who][fsig][keccak256(abi.encodePacked(params, field_depth))].found,\\n \\\"stdStorage find(StdStorage): Slot(s) not found.\\\"\\n );\\n\\n if (_clear) {\\n clear(self);\\n }\\n return self.finds[who][fsig][keccak256(abi.encodePacked(params, field_depth))];\\n }\\n\\n function target(StdStorage storage self, address _target) internal returns (StdStorage storage) {\\n self._target = _target;\\n return self;\\n }\\n\\n function sig(StdStorage storage self, bytes4 _sig) internal returns (StdStorage storage) {\\n self._sig = _sig;\\n return self;\\n }\\n\\n function sig(StdStorage storage self, string memory _sig) internal returns (StdStorage storage) {\\n self._sig = sigs(_sig);\\n return self;\\n }\\n\\n function with_calldata(StdStorage storage self, bytes memory _calldata) internal returns (StdStorage storage) {\\n self._calldata = _calldata;\\n return self;\\n }\\n\\n function with_key(StdStorage storage self, address who) internal returns (StdStorage storage) {\\n self._keys.push(bytes32(uint256(uint160(who))));\\n return self;\\n }\\n\\n function with_key(StdStorage storage self, uint256 amt) internal returns (StdStorage storage) {\\n self._keys.push(bytes32(amt));\\n return self;\\n }\\n\\n function with_key(StdStorage storage self, bytes32 key) internal returns (StdStorage storage) {\\n self._keys.push(key);\\n return self;\\n }\\n\\n function enable_packed_slots(StdStorage storage self) internal returns (StdStorage storage) {\\n self._enable_packed_slots = true;\\n return self;\\n }\\n\\n function depth(StdStorage storage self, uint256 _depth) internal returns (StdStorage storage) {\\n self._depth = _depth;\\n return self;\\n }\\n\\n function read(StdStorage storage self) private returns (bytes memory) {\\n FindData storage data = find(self, false);\\n uint256 mask = getMaskByOffsets(data.offsetLeft, data.offsetRight);\\n uint256 value = (uint256(vm.load(self._target, bytes32(data.slot))) & mask) >> data.offsetRight;\\n clear(self);\\n return abi.encode(value);\\n }\\n\\n function read_bytes32(StdStorage storage self) internal returns (bytes32) {\\n return abi.decode(read(self), (bytes32));\\n }\\n\\n function read_bool(StdStorage storage self) internal returns (bool) {\\n int256 v = read_int(self);\\n if (v == 0) return false;\\n if (v == 1) return true;\\n revert(\\\"stdStorage read_bool(StdStorage): Cannot decode. Make sure you are reading a bool.\\\");\\n }\\n\\n function read_address(StdStorage storage self) internal returns (address) {\\n return abi.decode(read(self), (address));\\n }\\n\\n function read_uint(StdStorage storage self) internal returns (uint256) {\\n return abi.decode(read(self), (uint256));\\n }\\n\\n function read_int(StdStorage storage self) internal returns (int256) {\\n return abi.decode(read(self), (int256));\\n }\\n\\n function parent(StdStorage storage self) internal returns (uint256, bytes32) {\\n address who = self._target;\\n uint256 field_depth = self._depth;\\n vm.startMappingRecording();\\n uint256 child = find(self, true).slot - field_depth;\\n (bool found, bytes32 key, bytes32 parent_slot) = vm.getMappingKeyAndParentOf(who, bytes32(child));\\n if (!found) {\\n revert(\\n \\\"stdStorage read_bool(StdStorage): Cannot find parent. Make sure you give a slot and startMappingRecording() has been called.\\\"\\n );\\n }\\n return (uint256(parent_slot), key);\\n }\\n\\n function root(StdStorage storage self) internal returns (uint256) {\\n address who = self._target;\\n uint256 field_depth = self._depth;\\n vm.startMappingRecording();\\n uint256 child = find(self, true).slot - field_depth;\\n bool found;\\n bytes32 root_slot;\\n bytes32 parent_slot;\\n (found,, parent_slot) = vm.getMappingKeyAndParentOf(who, bytes32(child));\\n if (!found) {\\n revert(\\n \\\"stdStorage read_bool(StdStorage): Cannot find parent. Make sure you give a slot and startMappingRecording() has been called.\\\"\\n );\\n }\\n while (found) {\\n root_slot = parent_slot;\\n (found,, parent_slot) = vm.getMappingKeyAndParentOf(who, bytes32(root_slot));\\n }\\n return uint256(root_slot);\\n }\\n\\n function bytesToBytes32(bytes memory b, uint256 offset) private pure returns (bytes32) {\\n bytes32 out;\\n\\n uint256 max = b.length > 32 ? 32 : b.length;\\n for (uint256 i = 0; i < max; i++) {\\n out |= bytes32(b[offset + i] & 0xFF) >> (i * 8);\\n }\\n return out;\\n }\\n\\n function flatten(bytes32[] memory b) private pure returns (bytes memory) {\\n bytes memory result = new bytes(b.length * 32);\\n for (uint256 i = 0; i < b.length; i++) {\\n bytes32 k = b[i];\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(add(result, add(32, mul(32, i))), k)\\n }\\n }\\n\\n return result;\\n }\\n\\n function clear(StdStorage storage self) internal {\\n delete self._target;\\n delete self._sig;\\n delete self._keys;\\n delete self._depth;\\n delete self._enable_packed_slots;\\n delete self._calldata;\\n }\\n\\n // Returns mask which contains non-zero bits for values between `offsetLeft` and `offsetRight`\\n // (slotValue & mask) >> offsetRight will be the value of the given packed variable\\n function getMaskByOffsets(uint256 offsetLeft, uint256 offsetRight) internal pure returns (uint256 mask) {\\n // mask = ((1 << (256 - (offsetRight + offsetLeft))) - 1) << offsetRight;\\n // using assembly because (1 << 256) causes overflow\\n assembly {\\n mask := shl(offsetRight, sub(shl(sub(256, add(offsetRight, offsetLeft)), 1), 1))\\n }\\n }\\n\\n // Returns slot value with updated packed variable.\\n function getUpdatedSlotValue(bytes32 curValue, uint256 varValue, uint256 offsetLeft, uint256 offsetRight)\\n internal\\n pure\\n returns (bytes32 newValue)\\n {\\n return bytes32((uint256(curValue) & ~getMaskByOffsets(offsetLeft, offsetRight)) | (varValue << offsetRight));\\n }\\n}\\n\\nlibrary stdStorage {\\n Vm private constant vm = Vm(address(uint160(uint256(keccak256(\\\"hevm cheat code\\\")))));\\n\\n function sigs(string memory sigStr) internal pure returns (bytes4) {\\n return stdStorageSafe.sigs(sigStr);\\n }\\n\\n function find(StdStorage storage self) internal returns (uint256) {\\n return find(self, true);\\n }\\n\\n function find(StdStorage storage self, bool _clear) internal returns (uint256) {\\n return stdStorageSafe.find(self, _clear).slot;\\n }\\n\\n function target(StdStorage storage self, address _target) internal returns (StdStorage storage) {\\n return stdStorageSafe.target(self, _target);\\n }\\n\\n function sig(StdStorage storage self, bytes4 _sig) internal returns (StdStorage storage) {\\n return stdStorageSafe.sig(self, _sig);\\n }\\n\\n function sig(StdStorage storage self, string memory _sig) internal returns (StdStorage storage) {\\n return stdStorageSafe.sig(self, _sig);\\n }\\n\\n function with_key(StdStorage storage self, address who) internal returns (StdStorage storage) {\\n return stdStorageSafe.with_key(self, who);\\n }\\n\\n function with_key(StdStorage storage self, uint256 amt) internal returns (StdStorage storage) {\\n return stdStorageSafe.with_key(self, amt);\\n }\\n\\n function with_key(StdStorage storage self, bytes32 key) internal returns (StdStorage storage) {\\n return stdStorageSafe.with_key(self, key);\\n }\\n\\n function with_calldata(StdStorage storage self, bytes memory _calldata) internal returns (StdStorage storage) {\\n return stdStorageSafe.with_calldata(self, _calldata);\\n }\\n\\n function enable_packed_slots(StdStorage storage self) internal returns (StdStorage storage) {\\n return stdStorageSafe.enable_packed_slots(self);\\n }\\n\\n function depth(StdStorage storage self, uint256 _depth) internal returns (StdStorage storage) {\\n return stdStorageSafe.depth(self, _depth);\\n }\\n\\n function clear(StdStorage storage self) internal {\\n stdStorageSafe.clear(self);\\n }\\n\\n function checked_write(StdStorage storage self, address who) internal {\\n checked_write(self, bytes32(uint256(uint160(who))));\\n }\\n\\n function checked_write(StdStorage storage self, uint256 amt) internal {\\n checked_write(self, bytes32(amt));\\n }\\n\\n function checked_write_int(StdStorage storage self, int256 val) internal {\\n checked_write(self, bytes32(uint256(val)));\\n }\\n\\n function checked_write(StdStorage storage self, bool write) internal {\\n bytes32 t;\\n /// @solidity memory-safe-assembly\\n assembly {\\n t := write\\n }\\n checked_write(self, t);\\n }\\n\\n function checked_write(StdStorage storage self, bytes32 set) internal {\\n address who = self._target;\\n bytes4 fsig = self._sig;\\n uint256 field_depth = self._depth;\\n bytes memory params = stdStorageSafe.getCallParams(self);\\n\\n if (!self.finds[who][fsig][keccak256(abi.encodePacked(params, field_depth))].found) {\\n find(self, false);\\n }\\n FindData storage data = self.finds[who][fsig][keccak256(abi.encodePacked(params, field_depth))];\\n if ((data.offsetLeft + data.offsetRight) > 0) {\\n uint256 maxVal = 2 ** (256 - (data.offsetLeft + data.offsetRight));\\n require(\\n uint256(set) < maxVal,\\n string(\\n abi.encodePacked(\\n \\\"stdStorage find(StdStorage): Packed slot. We can't fit value greater than \\\",\\n vm.toString(maxVal)\\n )\\n )\\n );\\n }\\n bytes32 curVal = vm.load(who, bytes32(data.slot));\\n bytes32 valToSet = stdStorageSafe.getUpdatedSlotValue(curVal, uint256(set), data.offsetLeft, data.offsetRight);\\n\\n vm.store(who, bytes32(data.slot), valToSet);\\n\\n (bool success, bytes32 callResult) = stdStorageSafe.callTarget(self);\\n\\n if (!success || callResult != set) {\\n vm.store(who, bytes32(data.slot), curVal);\\n revert(\\\"stdStorage find(StdStorage): Failed to write value.\\\");\\n }\\n clear(self);\\n }\\n\\n function read_bytes32(StdStorage storage self) internal returns (bytes32) {\\n return stdStorageSafe.read_bytes32(self);\\n }\\n\\n function read_bool(StdStorage storage self) internal returns (bool) {\\n return stdStorageSafe.read_bool(self);\\n }\\n\\n function read_address(StdStorage storage self) internal returns (address) {\\n return stdStorageSafe.read_address(self);\\n }\\n\\n function read_uint(StdStorage storage self) internal returns (uint256) {\\n return stdStorageSafe.read_uint(self);\\n }\\n\\n function read_int(StdStorage storage self) internal returns (int256) {\\n return stdStorageSafe.read_int(self);\\n }\\n\\n function parent(StdStorage storage self) internal returns (uint256, bytes32) {\\n return stdStorageSafe.parent(self);\\n }\\n\\n function root(StdStorage storage self) internal returns (uint256) {\\n return stdStorageSafe.root(self);\\n }\\n}\\n\",\"keccak256\":\"0xb91ab24383a5872b894fc93325eef1add6cbbf981628f18e860068bf88bb7dcc\",\"license\":\"MIT\"},\"lib/forge-std/src/StdStyle.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity >=0.4.22 <0.9.0;\\n\\nimport {VmSafe} from \\\"./Vm.sol\\\";\\n\\nlibrary StdStyle {\\n VmSafe private constant vm = VmSafe(address(uint160(uint256(keccak256(\\\"hevm cheat code\\\")))));\\n\\n string constant RED = \\\"\\\\u001b[91m\\\";\\n string constant GREEN = \\\"\\\\u001b[92m\\\";\\n string constant YELLOW = \\\"\\\\u001b[93m\\\";\\n string constant BLUE = \\\"\\\\u001b[94m\\\";\\n string constant MAGENTA = \\\"\\\\u001b[95m\\\";\\n string constant CYAN = \\\"\\\\u001b[96m\\\";\\n string constant BOLD = \\\"\\\\u001b[1m\\\";\\n string constant DIM = \\\"\\\\u001b[2m\\\";\\n string constant ITALIC = \\\"\\\\u001b[3m\\\";\\n string constant UNDERLINE = \\\"\\\\u001b[4m\\\";\\n string constant INVERSE = \\\"\\\\u001b[7m\\\";\\n string constant RESET = \\\"\\\\u001b[0m\\\";\\n\\n function styleConcat(string memory style, string memory self) private pure returns (string memory) {\\n return string(abi.encodePacked(style, self, RESET));\\n }\\n\\n function red(string memory self) internal pure returns (string memory) {\\n return styleConcat(RED, self);\\n }\\n\\n function red(uint256 self) internal pure returns (string memory) {\\n return red(vm.toString(self));\\n }\\n\\n function red(int256 self) internal pure returns (string memory) {\\n return red(vm.toString(self));\\n }\\n\\n function red(address self) internal pure returns (string memory) {\\n return red(vm.toString(self));\\n }\\n\\n function red(bool self) internal pure returns (string memory) {\\n return red(vm.toString(self));\\n }\\n\\n function redBytes(bytes memory self) internal pure returns (string memory) {\\n return red(vm.toString(self));\\n }\\n\\n function redBytes32(bytes32 self) internal pure returns (string memory) {\\n return red(vm.toString(self));\\n }\\n\\n function green(string memory self) internal pure returns (string memory) {\\n return styleConcat(GREEN, self);\\n }\\n\\n function green(uint256 self) internal pure returns (string memory) {\\n return green(vm.toString(self));\\n }\\n\\n function green(int256 self) internal pure returns (string memory) {\\n return green(vm.toString(self));\\n }\\n\\n function green(address self) internal pure returns (string memory) {\\n return green(vm.toString(self));\\n }\\n\\n function green(bool self) internal pure returns (string memory) {\\n return green(vm.toString(self));\\n }\\n\\n function greenBytes(bytes memory self) internal pure returns (string memory) {\\n return green(vm.toString(self));\\n }\\n\\n function greenBytes32(bytes32 self) internal pure returns (string memory) {\\n return green(vm.toString(self));\\n }\\n\\n function yellow(string memory self) internal pure returns (string memory) {\\n return styleConcat(YELLOW, self);\\n }\\n\\n function yellow(uint256 self) internal pure returns (string memory) {\\n return yellow(vm.toString(self));\\n }\\n\\n function yellow(int256 self) internal pure returns (string memory) {\\n return yellow(vm.toString(self));\\n }\\n\\n function yellow(address self) internal pure returns (string memory) {\\n return yellow(vm.toString(self));\\n }\\n\\n function yellow(bool self) internal pure returns (string memory) {\\n return yellow(vm.toString(self));\\n }\\n\\n function yellowBytes(bytes memory self) internal pure returns (string memory) {\\n return yellow(vm.toString(self));\\n }\\n\\n function yellowBytes32(bytes32 self) internal pure returns (string memory) {\\n return yellow(vm.toString(self));\\n }\\n\\n function blue(string memory self) internal pure returns (string memory) {\\n return styleConcat(BLUE, self);\\n }\\n\\n function blue(uint256 self) internal pure returns (string memory) {\\n return blue(vm.toString(self));\\n }\\n\\n function blue(int256 self) internal pure returns (string memory) {\\n return blue(vm.toString(self));\\n }\\n\\n function blue(address self) internal pure returns (string memory) {\\n return blue(vm.toString(self));\\n }\\n\\n function blue(bool self) internal pure returns (string memory) {\\n return blue(vm.toString(self));\\n }\\n\\n function blueBytes(bytes memory self) internal pure returns (string memory) {\\n return blue(vm.toString(self));\\n }\\n\\n function blueBytes32(bytes32 self) internal pure returns (string memory) {\\n return blue(vm.toString(self));\\n }\\n\\n function magenta(string memory self) internal pure returns (string memory) {\\n return styleConcat(MAGENTA, self);\\n }\\n\\n function magenta(uint256 self) internal pure returns (string memory) {\\n return magenta(vm.toString(self));\\n }\\n\\n function magenta(int256 self) internal pure returns (string memory) {\\n return magenta(vm.toString(self));\\n }\\n\\n function magenta(address self) internal pure returns (string memory) {\\n return magenta(vm.toString(self));\\n }\\n\\n function magenta(bool self) internal pure returns (string memory) {\\n return magenta(vm.toString(self));\\n }\\n\\n function magentaBytes(bytes memory self) internal pure returns (string memory) {\\n return magenta(vm.toString(self));\\n }\\n\\n function magentaBytes32(bytes32 self) internal pure returns (string memory) {\\n return magenta(vm.toString(self));\\n }\\n\\n function cyan(string memory self) internal pure returns (string memory) {\\n return styleConcat(CYAN, self);\\n }\\n\\n function cyan(uint256 self) internal pure returns (string memory) {\\n return cyan(vm.toString(self));\\n }\\n\\n function cyan(int256 self) internal pure returns (string memory) {\\n return cyan(vm.toString(self));\\n }\\n\\n function cyan(address self) internal pure returns (string memory) {\\n return cyan(vm.toString(self));\\n }\\n\\n function cyan(bool self) internal pure returns (string memory) {\\n return cyan(vm.toString(self));\\n }\\n\\n function cyanBytes(bytes memory self) internal pure returns (string memory) {\\n return cyan(vm.toString(self));\\n }\\n\\n function cyanBytes32(bytes32 self) internal pure returns (string memory) {\\n return cyan(vm.toString(self));\\n }\\n\\n function bold(string memory self) internal pure returns (string memory) {\\n return styleConcat(BOLD, self);\\n }\\n\\n function bold(uint256 self) internal pure returns (string memory) {\\n return bold(vm.toString(self));\\n }\\n\\n function bold(int256 self) internal pure returns (string memory) {\\n return bold(vm.toString(self));\\n }\\n\\n function bold(address self) internal pure returns (string memory) {\\n return bold(vm.toString(self));\\n }\\n\\n function bold(bool self) internal pure returns (string memory) {\\n return bold(vm.toString(self));\\n }\\n\\n function boldBytes(bytes memory self) internal pure returns (string memory) {\\n return bold(vm.toString(self));\\n }\\n\\n function boldBytes32(bytes32 self) internal pure returns (string memory) {\\n return bold(vm.toString(self));\\n }\\n\\n function dim(string memory self) internal pure returns (string memory) {\\n return styleConcat(DIM, self);\\n }\\n\\n function dim(uint256 self) internal pure returns (string memory) {\\n return dim(vm.toString(self));\\n }\\n\\n function dim(int256 self) internal pure returns (string memory) {\\n return dim(vm.toString(self));\\n }\\n\\n function dim(address self) internal pure returns (string memory) {\\n return dim(vm.toString(self));\\n }\\n\\n function dim(bool self) internal pure returns (string memory) {\\n return dim(vm.toString(self));\\n }\\n\\n function dimBytes(bytes memory self) internal pure returns (string memory) {\\n return dim(vm.toString(self));\\n }\\n\\n function dimBytes32(bytes32 self) internal pure returns (string memory) {\\n return dim(vm.toString(self));\\n }\\n\\n function italic(string memory self) internal pure returns (string memory) {\\n return styleConcat(ITALIC, self);\\n }\\n\\n function italic(uint256 self) internal pure returns (string memory) {\\n return italic(vm.toString(self));\\n }\\n\\n function italic(int256 self) internal pure returns (string memory) {\\n return italic(vm.toString(self));\\n }\\n\\n function italic(address self) internal pure returns (string memory) {\\n return italic(vm.toString(self));\\n }\\n\\n function italic(bool self) internal pure returns (string memory) {\\n return italic(vm.toString(self));\\n }\\n\\n function italicBytes(bytes memory self) internal pure returns (string memory) {\\n return italic(vm.toString(self));\\n }\\n\\n function italicBytes32(bytes32 self) internal pure returns (string memory) {\\n return italic(vm.toString(self));\\n }\\n\\n function underline(string memory self) internal pure returns (string memory) {\\n return styleConcat(UNDERLINE, self);\\n }\\n\\n function underline(uint256 self) internal pure returns (string memory) {\\n return underline(vm.toString(self));\\n }\\n\\n function underline(int256 self) internal pure returns (string memory) {\\n return underline(vm.toString(self));\\n }\\n\\n function underline(address self) internal pure returns (string memory) {\\n return underline(vm.toString(self));\\n }\\n\\n function underline(bool self) internal pure returns (string memory) {\\n return underline(vm.toString(self));\\n }\\n\\n function underlineBytes(bytes memory self) internal pure returns (string memory) {\\n return underline(vm.toString(self));\\n }\\n\\n function underlineBytes32(bytes32 self) internal pure returns (string memory) {\\n return underline(vm.toString(self));\\n }\\n\\n function inverse(string memory self) internal pure returns (string memory) {\\n return styleConcat(INVERSE, self);\\n }\\n\\n function inverse(uint256 self) internal pure returns (string memory) {\\n return inverse(vm.toString(self));\\n }\\n\\n function inverse(int256 self) internal pure returns (string memory) {\\n return inverse(vm.toString(self));\\n }\\n\\n function inverse(address self) internal pure returns (string memory) {\\n return inverse(vm.toString(self));\\n }\\n\\n function inverse(bool self) internal pure returns (string memory) {\\n return inverse(vm.toString(self));\\n }\\n\\n function inverseBytes(bytes memory self) internal pure returns (string memory) {\\n return inverse(vm.toString(self));\\n }\\n\\n function inverseBytes32(bytes32 self) internal pure returns (string memory) {\\n return inverse(vm.toString(self));\\n }\\n}\\n\",\"keccak256\":\"0x43e2a8a9b9c2574dabe74f11adf6f782df218f463540e3b5b563609fe108597d\",\"license\":\"MIT\"},\"lib/forge-std/src/StdUtils.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity >=0.6.2 <0.9.0;\\n\\npragma experimental ABIEncoderV2;\\n\\nimport {IMulticall3} from \\\"./interfaces/IMulticall3.sol\\\";\\nimport {VmSafe} from \\\"./Vm.sol\\\";\\n\\nabstract contract StdUtils {\\n /*//////////////////////////////////////////////////////////////////////////\\n CONSTANTS\\n //////////////////////////////////////////////////////////////////////////*/\\n\\n IMulticall3 private constant multicall = IMulticall3(0xcA11bde05977b3631167028862bE2a173976CA11);\\n VmSafe private constant vm = VmSafe(address(uint160(uint256(keccak256(\\\"hevm cheat code\\\")))));\\n address private constant CONSOLE2_ADDRESS = 0x000000000000000000636F6e736F6c652e6c6f67;\\n uint256 private constant INT256_MIN_ABS =\\n 57896044618658097711785492504343953926634992332820282019728792003956564819968;\\n uint256 private constant SECP256K1_ORDER =\\n 115792089237316195423570985008687907852837564279074904382605163141518161494337;\\n uint256 private constant UINT256_MAX =\\n 115792089237316195423570985008687907853269984665640564039457584007913129639935;\\n\\n // Used by default when deploying with create2, https://github.com/Arachnid/deterministic-deployment-proxy.\\n address private constant CREATE2_FACTORY = 0x4e59b44847b379578588920cA78FbF26c0B4956C;\\n\\n /*//////////////////////////////////////////////////////////////////////////\\n INTERNAL FUNCTIONS\\n //////////////////////////////////////////////////////////////////////////*/\\n\\n function _bound(uint256 x, uint256 min, uint256 max) internal pure virtual returns (uint256 result) {\\n require(min <= max, \\\"StdUtils bound(uint256,uint256,uint256): Max is less than min.\\\");\\n // If x is between min and max, return x directly. This is to ensure that dictionary values\\n // do not get shifted if the min is nonzero. More info: https://github.com/foundry-rs/forge-std/issues/188\\n if (x >= min && x <= max) return x;\\n\\n uint256 size = max - min + 1;\\n\\n // If the value is 0, 1, 2, 3, wrap that to min, min+1, min+2, min+3. Similarly for the UINT256_MAX side.\\n // This helps ensure coverage of the min/max values.\\n if (x <= 3 && size > x) return min + x;\\n if (x >= UINT256_MAX - 3 && size > UINT256_MAX - x) return max - (UINT256_MAX - x);\\n\\n // Otherwise, wrap x into the range [min, max], i.e. the range is inclusive.\\n if (x > max) {\\n uint256 diff = x - max;\\n uint256 rem = diff % size;\\n if (rem == 0) return max;\\n result = min + rem - 1;\\n } else if (x < min) {\\n uint256 diff = min - x;\\n uint256 rem = diff % size;\\n if (rem == 0) return min;\\n result = max - rem + 1;\\n }\\n }\\n\\n function bound(uint256 x, uint256 min, uint256 max) internal pure virtual returns (uint256 result) {\\n result = _bound(x, min, max);\\n console2_log_StdUtils(\\\"Bound result\\\", result);\\n }\\n\\n function _bound(int256 x, int256 min, int256 max) internal pure virtual returns (int256 result) {\\n require(min <= max, \\\"StdUtils bound(int256,int256,int256): Max is less than min.\\\");\\n\\n // Shifting all int256 values to uint256 to use _bound function. The range of two types are:\\n // int256 : -(2**255) ~ (2**255 - 1)\\n // uint256: 0 ~ (2**256 - 1)\\n // So, add 2**255, INT256_MIN_ABS to the integer values.\\n //\\n // If the given integer value is -2**255, we cannot use `-uint256(-x)` because of the overflow.\\n // So, use `~uint256(x) + 1` instead.\\n uint256 _x = x < 0 ? (INT256_MIN_ABS - ~uint256(x) - 1) : (uint256(x) + INT256_MIN_ABS);\\n uint256 _min = min < 0 ? (INT256_MIN_ABS - ~uint256(min) - 1) : (uint256(min) + INT256_MIN_ABS);\\n uint256 _max = max < 0 ? (INT256_MIN_ABS - ~uint256(max) - 1) : (uint256(max) + INT256_MIN_ABS);\\n\\n uint256 y = _bound(_x, _min, _max);\\n\\n // To move it back to int256 value, subtract INT256_MIN_ABS at here.\\n result = y < INT256_MIN_ABS ? int256(~(INT256_MIN_ABS - y) + 1) : int256(y - INT256_MIN_ABS);\\n }\\n\\n function bound(int256 x, int256 min, int256 max) internal pure virtual returns (int256 result) {\\n result = _bound(x, min, max);\\n console2_log_StdUtils(\\\"Bound result\\\", vm.toString(result));\\n }\\n\\n function boundPrivateKey(uint256 privateKey) internal pure virtual returns (uint256 result) {\\n result = _bound(privateKey, 1, SECP256K1_ORDER - 1);\\n }\\n\\n function bytesToUint(bytes memory b) internal pure virtual returns (uint256) {\\n require(b.length <= 32, \\\"StdUtils bytesToUint(bytes): Bytes length exceeds 32.\\\");\\n return abi.decode(abi.encodePacked(new bytes(32 - b.length), b), (uint256));\\n }\\n\\n /// @dev Compute the address a contract will be deployed at for a given deployer address and nonce\\n /// @notice adapted from Solmate implementation (https://github.com/Rari-Capital/solmate/blob/main/src/utils/LibRLP.sol)\\n function computeCreateAddress(address deployer, uint256 nonce) internal pure virtual returns (address) {\\n console2_log_StdUtils(\\\"computeCreateAddress is deprecated. Please use vm.computeCreateAddress instead.\\\");\\n return vm.computeCreateAddress(deployer, nonce);\\n }\\n\\n function computeCreate2Address(bytes32 salt, bytes32 initcodeHash, address deployer)\\n internal\\n pure\\n virtual\\n returns (address)\\n {\\n console2_log_StdUtils(\\\"computeCreate2Address is deprecated. Please use vm.computeCreate2Address instead.\\\");\\n return vm.computeCreate2Address(salt, initcodeHash, deployer);\\n }\\n\\n /// @dev returns the address of a contract created with CREATE2 using the default CREATE2 deployer\\n function computeCreate2Address(bytes32 salt, bytes32 initCodeHash) internal pure returns (address) {\\n console2_log_StdUtils(\\\"computeCreate2Address is deprecated. Please use vm.computeCreate2Address instead.\\\");\\n return vm.computeCreate2Address(salt, initCodeHash);\\n }\\n\\n /// @dev returns the hash of the init code (creation code + no args) used in CREATE2 with no constructor arguments\\n /// @param creationCode the creation code of a contract C, as returned by type(C).creationCode\\n function hashInitCode(bytes memory creationCode) internal pure returns (bytes32) {\\n return hashInitCode(creationCode, \\\"\\\");\\n }\\n\\n /// @dev returns the hash of the init code (creation code + ABI-encoded args) used in CREATE2\\n /// @param creationCode the creation code of a contract C, as returned by type(C).creationCode\\n /// @param args the ABI-encoded arguments to the constructor of C\\n function hashInitCode(bytes memory creationCode, bytes memory args) internal pure returns (bytes32) {\\n return keccak256(abi.encodePacked(creationCode, args));\\n }\\n\\n // Performs a single call with Multicall3 to query the ERC-20 token balances of the given addresses.\\n function getTokenBalances(address token, address[] memory addresses)\\n internal\\n virtual\\n returns (uint256[] memory balances)\\n {\\n uint256 tokenCodeSize;\\n assembly {\\n tokenCodeSize := extcodesize(token)\\n }\\n require(tokenCodeSize > 0, \\\"StdUtils getTokenBalances(address,address[]): Token address is not a contract.\\\");\\n\\n // ABI encode the aggregate call to Multicall3.\\n uint256 length = addresses.length;\\n IMulticall3.Call[] memory calls = new IMulticall3.Call[](length);\\n for (uint256 i = 0; i < length; ++i) {\\n // 0x70a08231 = bytes4(\\\"balanceOf(address)\\\"))\\n calls[i] = IMulticall3.Call({target: token, callData: abi.encodeWithSelector(0x70a08231, (addresses[i]))});\\n }\\n\\n // Make the aggregate call.\\n (, bytes[] memory returnData) = multicall.aggregate(calls);\\n\\n // ABI decode the return data and return the balances.\\n balances = new uint256[](length);\\n for (uint256 i = 0; i < length; ++i) {\\n balances[i] = abi.decode(returnData[i], (uint256));\\n }\\n }\\n\\n /*//////////////////////////////////////////////////////////////////////////\\n PRIVATE FUNCTIONS\\n //////////////////////////////////////////////////////////////////////////*/\\n\\n function addressFromLast20Bytes(bytes32 bytesValue) private pure returns (address) {\\n return address(uint160(uint256(bytesValue)));\\n }\\n\\n // This section is used to prevent the compilation of console, which shortens the compilation time when console is\\n // not used elsewhere. We also trick the compiler into letting us make the console log methods as `pure` to avoid\\n // any breaking changes to function signatures.\\n function _castLogPayloadViewToPure(function(bytes memory) internal view fnIn)\\n internal\\n pure\\n returns (function(bytes memory) internal pure fnOut)\\n {\\n assembly {\\n fnOut := fnIn\\n }\\n }\\n\\n function _sendLogPayload(bytes memory payload) internal pure {\\n _castLogPayloadViewToPure(_sendLogPayloadView)(payload);\\n }\\n\\n function _sendLogPayloadView(bytes memory payload) private view {\\n uint256 payloadLength = payload.length;\\n address consoleAddress = CONSOLE2_ADDRESS;\\n /// @solidity memory-safe-assembly\\n assembly {\\n let payloadStart := add(payload, 32)\\n let r := staticcall(gas(), consoleAddress, payloadStart, payloadLength, 0, 0)\\n }\\n }\\n\\n function console2_log_StdUtils(string memory p0) private pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string)\\\", p0));\\n }\\n\\n function console2_log_StdUtils(string memory p0, uint256 p1) private pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,uint256)\\\", p0, p1));\\n }\\n\\n function console2_log_StdUtils(string memory p0, string memory p1) private pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,string)\\\", p0, p1));\\n }\\n}\\n\",\"keccak256\":\"0x7274081e11c05164fd8eadde4de8305c033e58a43008dea58065f3170ccf0737\",\"license\":\"MIT\"},\"lib/forge-std/src/Vm.sol\":{\"content\":\"// Automatically @generated by scripts/vm.py. Do not modify manually.\\n\\n// SPDX-License-Identifier: MIT OR Apache-2.0\\npragma solidity >=0.6.2 <0.9.0;\\npragma experimental ABIEncoderV2;\\n\\n/// The `VmSafe` interface does not allow manipulation of the EVM state or other actions that may\\n/// result in Script simulations differing from on-chain execution. It is recommended to only use\\n/// these cheats in scripts.\\ninterface VmSafe {\\n /// A modification applied to either `msg.sender` or `tx.origin`. Returned by `readCallers`.\\n enum CallerMode {\\n // No caller modification is currently active.\\n None,\\n // A one time broadcast triggered by a `vm.broadcast()` call is currently active.\\n Broadcast,\\n // A recurrent broadcast triggered by a `vm.startBroadcast()` call is currently active.\\n RecurrentBroadcast,\\n // A one time prank triggered by a `vm.prank()` call is currently active.\\n Prank,\\n // A recurrent prank triggered by a `vm.startPrank()` call is currently active.\\n RecurrentPrank\\n }\\n\\n /// The kind of account access that occurred.\\n enum AccountAccessKind {\\n // The account was called.\\n Call,\\n // The account was called via delegatecall.\\n DelegateCall,\\n // The account was called via callcode.\\n CallCode,\\n // The account was called via staticcall.\\n StaticCall,\\n // The account was created.\\n Create,\\n // The account was selfdestructed.\\n SelfDestruct,\\n // Synthetic access indicating the current context has resumed after a previous sub-context (AccountAccess).\\n Resume,\\n // The account's balance was read.\\n Balance,\\n // The account's codesize was read.\\n Extcodesize,\\n // The account's codehash was read.\\n Extcodehash,\\n // The account's code was copied.\\n Extcodecopy\\n }\\n\\n /// Forge execution contexts.\\n enum ForgeContext {\\n // Test group execution context (test, coverage or snapshot).\\n TestGroup,\\n // `forge test` execution context.\\n Test,\\n // `forge coverage` execution context.\\n Coverage,\\n // `forge snapshot` execution context.\\n Snapshot,\\n // Script group execution context (dry run, broadcast or resume).\\n ScriptGroup,\\n // `forge script` execution context.\\n ScriptDryRun,\\n // `forge script --broadcast` execution context.\\n ScriptBroadcast,\\n // `forge script --resume` execution context.\\n ScriptResume,\\n // Unknown `forge` execution context.\\n Unknown\\n }\\n\\n /// The transaction type (`txType`) of the broadcast.\\n enum BroadcastTxType {\\n // Represents a CALL broadcast tx.\\n Call,\\n // Represents a CREATE broadcast tx.\\n Create,\\n // Represents a CREATE2 broadcast tx.\\n Create2\\n }\\n\\n /// An Ethereum log. Returned by `getRecordedLogs`.\\n struct Log {\\n // The topics of the log, including the signature, if any.\\n bytes32[] topics;\\n // The raw data of the log.\\n bytes data;\\n // The address of the log's emitter.\\n address emitter;\\n }\\n\\n /// An RPC URL and its alias. Returned by `rpcUrlStructs`.\\n struct Rpc {\\n // The alias of the RPC URL.\\n string key;\\n // The RPC URL.\\n string url;\\n }\\n\\n /// An RPC log object. Returned by `eth_getLogs`.\\n struct EthGetLogs {\\n // The address of the log's emitter.\\n address emitter;\\n // The topics of the log, including the signature, if any.\\n bytes32[] topics;\\n // The raw data of the log.\\n bytes data;\\n // The block hash.\\n bytes32 blockHash;\\n // The block number.\\n uint64 blockNumber;\\n // The transaction hash.\\n bytes32 transactionHash;\\n // The transaction index in the block.\\n uint64 transactionIndex;\\n // The log index.\\n uint256 logIndex;\\n // Whether the log was removed.\\n bool removed;\\n }\\n\\n /// A single entry in a directory listing. Returned by `readDir`.\\n struct DirEntry {\\n // The error message, if any.\\n string errorMessage;\\n // The path of the entry.\\n string path;\\n // The depth of the entry.\\n uint64 depth;\\n // Whether the entry is a directory.\\n bool isDir;\\n // Whether the entry is a symlink.\\n bool isSymlink;\\n }\\n\\n /// Metadata information about a file.\\n /// This structure is returned from the `fsMetadata` function and represents known\\n /// metadata about a file such as its permissions, size, modification\\n /// times, etc.\\n struct FsMetadata {\\n // True if this metadata is for a directory.\\n bool isDir;\\n // True if this metadata is for a symlink.\\n bool isSymlink;\\n // The size of the file, in bytes, this metadata is for.\\n uint256 length;\\n // True if this metadata is for a readonly (unwritable) file.\\n bool readOnly;\\n // The last modification time listed in this metadata.\\n uint256 modified;\\n // The last access time of this metadata.\\n uint256 accessed;\\n // The creation time listed in this metadata.\\n uint256 created;\\n }\\n\\n /// A wallet with a public and private key.\\n struct Wallet {\\n // The wallet's address.\\n address addr;\\n // The wallet's public key `X`.\\n uint256 publicKeyX;\\n // The wallet's public key `Y`.\\n uint256 publicKeyY;\\n // The wallet's private key.\\n uint256 privateKey;\\n }\\n\\n /// The result of a `tryFfi` call.\\n struct FfiResult {\\n // The exit code of the call.\\n int32 exitCode;\\n // The optionally hex-decoded `stdout` data.\\n bytes stdout;\\n // The `stderr` data.\\n bytes stderr;\\n }\\n\\n /// Information on the chain and fork.\\n struct ChainInfo {\\n // The fork identifier. Set to zero if no fork is active.\\n uint256 forkId;\\n // The chain ID of the current fork.\\n uint256 chainId;\\n }\\n\\n /// The result of a `stopAndReturnStateDiff` call.\\n struct AccountAccess {\\n // The chain and fork the access occurred.\\n ChainInfo chainInfo;\\n // The kind of account access that determines what the account is.\\n // If kind is Call, DelegateCall, StaticCall or CallCode, then the account is the callee.\\n // If kind is Create, then the account is the newly created account.\\n // If kind is SelfDestruct, then the account is the selfdestruct recipient.\\n // If kind is a Resume, then account represents a account context that has resumed.\\n AccountAccessKind kind;\\n // The account that was accessed.\\n // It's either the account created, callee or a selfdestruct recipient for CREATE, CALL or SELFDESTRUCT.\\n address account;\\n // What accessed the account.\\n address accessor;\\n // If the account was initialized or empty prior to the access.\\n // An account is considered initialized if it has code, a\\n // non-zero nonce, or a non-zero balance.\\n bool initialized;\\n // The previous balance of the accessed account.\\n uint256 oldBalance;\\n // The potential new balance of the accessed account.\\n // That is, all balance changes are recorded here, even if reverts occurred.\\n uint256 newBalance;\\n // Code of the account deployed by CREATE.\\n bytes deployedCode;\\n // Value passed along with the account access\\n uint256 value;\\n // Input data provided to the CREATE or CALL\\n bytes data;\\n // If this access reverted in either the current or parent context.\\n bool reverted;\\n // An ordered list of storage accesses made during an account access operation.\\n StorageAccess[] storageAccesses;\\n // Call depth traversed during the recording of state differences\\n uint64 depth;\\n }\\n\\n /// The storage accessed during an `AccountAccess`.\\n struct StorageAccess {\\n // The account whose storage was accessed.\\n address account;\\n // The slot that was accessed.\\n bytes32 slot;\\n // If the access was a write.\\n bool isWrite;\\n // The previous value of the slot.\\n bytes32 previousValue;\\n // The new value of the slot.\\n bytes32 newValue;\\n // If the access was reverted.\\n bool reverted;\\n }\\n\\n /// Gas used. Returned by `lastCallGas`.\\n struct Gas {\\n // The gas limit of the call.\\n uint64 gasLimit;\\n // The total gas used.\\n uint64 gasTotalUsed;\\n // DEPRECATED: The amount of gas used for memory expansion. Ref: \\n uint64 gasMemoryUsed;\\n // The amount of gas refunded.\\n int64 gasRefunded;\\n // The amount of gas remaining.\\n uint64 gasRemaining;\\n }\\n\\n /// The result of the `stopDebugTraceRecording` call\\n struct DebugStep {\\n // The stack before executing the step of the run.\\n // stack\\\\[0\\\\] represents the top of the stack.\\n // and only stack data relevant to the opcode execution is contained.\\n uint256[] stack;\\n // The memory input data before executing the step of the run.\\n // only input data relevant to the opcode execution is contained.\\n // e.g. for MLOAD, it will have memory\\\\[offset:offset+32\\\\] copied here.\\n // the offset value can be get by the stack data.\\n bytes memoryInput;\\n // The opcode that was accessed.\\n uint8 opcode;\\n // The call depth of the step.\\n uint64 depth;\\n // Whether the call end up with out of gas error.\\n bool isOutOfGas;\\n // The contract address where the opcode is running\\n address contractAddr;\\n }\\n\\n /// Represents a transaction's broadcast details.\\n struct BroadcastTxSummary {\\n // The hash of the transaction that was broadcasted\\n bytes32 txHash;\\n // Represent the type of transaction among CALL, CREATE, CREATE2\\n BroadcastTxType txType;\\n // The address of the contract that was called or created.\\n // This is address of the contract that is created if the txType is CREATE or CREATE2.\\n address contractAddress;\\n // The block number the transaction landed in.\\n uint64 blockNumber;\\n // Status of the transaction, retrieved from the transaction receipt.\\n bool success;\\n }\\n\\n /// Holds a signed EIP-7702 authorization for an authority account to delegate to an implementation.\\n struct SignedDelegation {\\n // The y-parity of the recovered secp256k1 signature (0 or 1).\\n uint8 v;\\n // First 32 bytes of the signature.\\n bytes32 r;\\n // Second 32 bytes of the signature.\\n bytes32 s;\\n // The current nonce of the authority account at signing time.\\n // Used to ensure signature can't be replayed after account nonce changes.\\n uint64 nonce;\\n // Address of the contract implementation that will be delegated to.\\n // Gets encoded into delegation code: 0xef0100 || implementation.\\n address implementation;\\n }\\n\\n /// Represents a \\\"potential\\\" revert reason from a single subsequent call when using `vm.assumeNoReverts`.\\n /// Reverts that match will result in a FOUNDRY::ASSUME rejection, whereas unmatched reverts will be surfaced\\n /// as normal.\\n struct PotentialRevert {\\n // The allowed origin of the revert opcode; address(0) allows reverts from any address\\n address reverter;\\n // When true, only matches on the beginning of the revert data, otherwise, matches on entire revert data\\n bool partialMatch;\\n // The data to use to match encountered reverts\\n bytes revertData;\\n }\\n\\n /// An EIP-2930 access list item.\\n struct AccessListItem {\\n // The address to be added in access list.\\n address target;\\n // The storage keys to be added in access list.\\n bytes32[] storageKeys;\\n }\\n\\n // ======== Crypto ========\\n\\n /// Derives a private key from the name, labels the account with that name, and returns the wallet.\\n function createWallet(string calldata walletLabel) external returns (Wallet memory wallet);\\n\\n /// Generates a wallet from the private key and returns the wallet.\\n function createWallet(uint256 privateKey) external returns (Wallet memory wallet);\\n\\n /// Generates a wallet from the private key, labels the account with that name, and returns the wallet.\\n function createWallet(uint256 privateKey, string calldata walletLabel) external returns (Wallet memory wallet);\\n\\n /// Derive a private key from a provided mnenomic string (or mnenomic file path)\\n /// at the derivation path `m/44'/60'/0'/0/{index}`.\\n function deriveKey(string calldata mnemonic, uint32 index) external pure returns (uint256 privateKey);\\n\\n /// Derive a private key from a provided mnenomic string (or mnenomic file path)\\n /// at `{derivationPath}{index}`.\\n function deriveKey(string calldata mnemonic, string calldata derivationPath, uint32 index)\\n external\\n pure\\n returns (uint256 privateKey);\\n\\n /// Derive a private key from a provided mnenomic string (or mnenomic file path) in the specified language\\n /// at the derivation path `m/44'/60'/0'/0/{index}`.\\n function deriveKey(string calldata mnemonic, uint32 index, string calldata language)\\n external\\n pure\\n returns (uint256 privateKey);\\n\\n /// Derive a private key from a provided mnenomic string (or mnenomic file path) in the specified language\\n /// at `{derivationPath}{index}`.\\n function deriveKey(string calldata mnemonic, string calldata derivationPath, uint32 index, string calldata language)\\n external\\n pure\\n returns (uint256 privateKey);\\n\\n /// Derives secp256r1 public key from the provided `privateKey`.\\n function publicKeyP256(uint256 privateKey) external pure returns (uint256 publicKeyX, uint256 publicKeyY);\\n\\n /// Adds a private key to the local forge wallet and returns the address.\\n function rememberKey(uint256 privateKey) external returns (address keyAddr);\\n\\n /// Derive a set number of wallets from a mnemonic at the derivation path `m/44'/60'/0'/0/{0..count}`.\\n /// The respective private keys are saved to the local forge wallet for later use and their addresses are returned.\\n function rememberKeys(string calldata mnemonic, string calldata derivationPath, uint32 count)\\n external\\n returns (address[] memory keyAddrs);\\n\\n /// Derive a set number of wallets from a mnemonic in the specified language at the derivation path `m/44'/60'/0'/0/{0..count}`.\\n /// The respective private keys are saved to the local forge wallet for later use and their addresses are returned.\\n function rememberKeys(\\n string calldata mnemonic,\\n string calldata derivationPath,\\n string calldata language,\\n uint32 count\\n ) external returns (address[] memory keyAddrs);\\n\\n /// Signs data with a `Wallet`.\\n /// Returns a compact signature (`r`, `vs`) as per EIP-2098, where `vs` encodes both the\\n /// signature's `s` value, and the recovery id `v` in a single bytes32.\\n /// This format reduces the signature size from 65 to 64 bytes.\\n function signCompact(Wallet calldata wallet, bytes32 digest) external returns (bytes32 r, bytes32 vs);\\n\\n /// Signs `digest` with `privateKey` using the secp256k1 curve.\\n /// Returns a compact signature (`r`, `vs`) as per EIP-2098, where `vs` encodes both the\\n /// signature's `s` value, and the recovery id `v` in a single bytes32.\\n /// This format reduces the signature size from 65 to 64 bytes.\\n function signCompact(uint256 privateKey, bytes32 digest) external pure returns (bytes32 r, bytes32 vs);\\n\\n /// Signs `digest` with signer provided to script using the secp256k1 curve.\\n /// Returns a compact signature (`r`, `vs`) as per EIP-2098, where `vs` encodes both the\\n /// signature's `s` value, and the recovery id `v` in a single bytes32.\\n /// This format reduces the signature size from 65 to 64 bytes.\\n /// If `--sender` is provided, the signer with provided address is used, otherwise,\\n /// if exactly one signer is provided to the script, that signer is used.\\n /// Raises error if signer passed through `--sender` does not match any unlocked signers or\\n /// if `--sender` is not provided and not exactly one signer is passed to the script.\\n function signCompact(bytes32 digest) external pure returns (bytes32 r, bytes32 vs);\\n\\n /// Signs `digest` with signer provided to script using the secp256k1 curve.\\n /// Returns a compact signature (`r`, `vs`) as per EIP-2098, where `vs` encodes both the\\n /// signature's `s` value, and the recovery id `v` in a single bytes32.\\n /// This format reduces the signature size from 65 to 64 bytes.\\n /// Raises error if none of the signers passed into the script have provided address.\\n function signCompact(address signer, bytes32 digest) external pure returns (bytes32 r, bytes32 vs);\\n\\n /// Signs `digest` with `privateKey` using the secp256r1 curve.\\n function signP256(uint256 privateKey, bytes32 digest) external pure returns (bytes32 r, bytes32 s);\\n\\n /// Signs data with a `Wallet`.\\n function sign(Wallet calldata wallet, bytes32 digest) external returns (uint8 v, bytes32 r, bytes32 s);\\n\\n /// Signs `digest` with `privateKey` using the secp256k1 curve.\\n function sign(uint256 privateKey, bytes32 digest) external pure returns (uint8 v, bytes32 r, bytes32 s);\\n\\n /// Signs `digest` with signer provided to script using the secp256k1 curve.\\n /// If `--sender` is provided, the signer with provided address is used, otherwise,\\n /// if exactly one signer is provided to the script, that signer is used.\\n /// Raises error if signer passed through `--sender` does not match any unlocked signers or\\n /// if `--sender` is not provided and not exactly one signer is passed to the script.\\n function sign(bytes32 digest) external pure returns (uint8 v, bytes32 r, bytes32 s);\\n\\n /// Signs `digest` with signer provided to script using the secp256k1 curve.\\n /// Raises error if none of the signers passed into the script have provided address.\\n function sign(address signer, bytes32 digest) external pure returns (uint8 v, bytes32 r, bytes32 s);\\n\\n // ======== Environment ========\\n\\n /// Gets the environment variable `name` and parses it as `address`.\\n /// Reverts if the variable was not found or could not be parsed.\\n function envAddress(string calldata name) external view returns (address value);\\n\\n /// Gets the environment variable `name` and parses it as an array of `address`, delimited by `delim`.\\n /// Reverts if the variable was not found or could not be parsed.\\n function envAddress(string calldata name, string calldata delim) external view returns (address[] memory value);\\n\\n /// Gets the environment variable `name` and parses it as `bool`.\\n /// Reverts if the variable was not found or could not be parsed.\\n function envBool(string calldata name) external view returns (bool value);\\n\\n /// Gets the environment variable `name` and parses it as an array of `bool`, delimited by `delim`.\\n /// Reverts if the variable was not found or could not be parsed.\\n function envBool(string calldata name, string calldata delim) external view returns (bool[] memory value);\\n\\n /// Gets the environment variable `name` and parses it as `bytes32`.\\n /// Reverts if the variable was not found or could not be parsed.\\n function envBytes32(string calldata name) external view returns (bytes32 value);\\n\\n /// Gets the environment variable `name` and parses it as an array of `bytes32`, delimited by `delim`.\\n /// Reverts if the variable was not found or could not be parsed.\\n function envBytes32(string calldata name, string calldata delim) external view returns (bytes32[] memory value);\\n\\n /// Gets the environment variable `name` and parses it as `bytes`.\\n /// Reverts if the variable was not found or could not be parsed.\\n function envBytes(string calldata name) external view returns (bytes memory value);\\n\\n /// Gets the environment variable `name` and parses it as an array of `bytes`, delimited by `delim`.\\n /// Reverts if the variable was not found or could not be parsed.\\n function envBytes(string calldata name, string calldata delim) external view returns (bytes[] memory value);\\n\\n /// Gets the environment variable `name` and returns true if it exists, else returns false.\\n function envExists(string calldata name) external view returns (bool result);\\n\\n /// Gets the environment variable `name` and parses it as `int256`.\\n /// Reverts if the variable was not found or could not be parsed.\\n function envInt(string calldata name) external view returns (int256 value);\\n\\n /// Gets the environment variable `name` and parses it as an array of `int256`, delimited by `delim`.\\n /// Reverts if the variable was not found or could not be parsed.\\n function envInt(string calldata name, string calldata delim) external view returns (int256[] memory value);\\n\\n /// Gets the environment variable `name` and parses it as `bool`.\\n /// Reverts if the variable could not be parsed.\\n /// Returns `defaultValue` if the variable was not found.\\n function envOr(string calldata name, bool defaultValue) external view returns (bool value);\\n\\n /// Gets the environment variable `name` and parses it as `uint256`.\\n /// Reverts if the variable could not be parsed.\\n /// Returns `defaultValue` if the variable was not found.\\n function envOr(string calldata name, uint256 defaultValue) external view returns (uint256 value);\\n\\n /// Gets the environment variable `name` and parses it as an array of `address`, delimited by `delim`.\\n /// Reverts if the variable could not be parsed.\\n /// Returns `defaultValue` if the variable was not found.\\n function envOr(string calldata name, string calldata delim, address[] calldata defaultValue)\\n external\\n view\\n returns (address[] memory value);\\n\\n /// Gets the environment variable `name` and parses it as an array of `bytes32`, delimited by `delim`.\\n /// Reverts if the variable could not be parsed.\\n /// Returns `defaultValue` if the variable was not found.\\n function envOr(string calldata name, string calldata delim, bytes32[] calldata defaultValue)\\n external\\n view\\n returns (bytes32[] memory value);\\n\\n /// Gets the environment variable `name` and parses it as an array of `string`, delimited by `delim`.\\n /// Reverts if the variable could not be parsed.\\n /// Returns `defaultValue` if the variable was not found.\\n function envOr(string calldata name, string calldata delim, string[] calldata defaultValue)\\n external\\n view\\n returns (string[] memory value);\\n\\n /// Gets the environment variable `name` and parses it as an array of `bytes`, delimited by `delim`.\\n /// Reverts if the variable could not be parsed.\\n /// Returns `defaultValue` if the variable was not found.\\n function envOr(string calldata name, string calldata delim, bytes[] calldata defaultValue)\\n external\\n view\\n returns (bytes[] memory value);\\n\\n /// Gets the environment variable `name` and parses it as `int256`.\\n /// Reverts if the variable could not be parsed.\\n /// Returns `defaultValue` if the variable was not found.\\n function envOr(string calldata name, int256 defaultValue) external view returns (int256 value);\\n\\n /// Gets the environment variable `name` and parses it as `address`.\\n /// Reverts if the variable could not be parsed.\\n /// Returns `defaultValue` if the variable was not found.\\n function envOr(string calldata name, address defaultValue) external view returns (address value);\\n\\n /// Gets the environment variable `name` and parses it as `bytes32`.\\n /// Reverts if the variable could not be parsed.\\n /// Returns `defaultValue` if the variable was not found.\\n function envOr(string calldata name, bytes32 defaultValue) external view returns (bytes32 value);\\n\\n /// Gets the environment variable `name` and parses it as `string`.\\n /// Reverts if the variable could not be parsed.\\n /// Returns `defaultValue` if the variable was not found.\\n function envOr(string calldata name, string calldata defaultValue) external view returns (string memory value);\\n\\n /// Gets the environment variable `name` and parses it as `bytes`.\\n /// Reverts if the variable could not be parsed.\\n /// Returns `defaultValue` if the variable was not found.\\n function envOr(string calldata name, bytes calldata defaultValue) external view returns (bytes memory value);\\n\\n /// Gets the environment variable `name` and parses it as an array of `bool`, delimited by `delim`.\\n /// Reverts if the variable could not be parsed.\\n /// Returns `defaultValue` if the variable was not found.\\n function envOr(string calldata name, string calldata delim, bool[] calldata defaultValue)\\n external\\n view\\n returns (bool[] memory value);\\n\\n /// Gets the environment variable `name` and parses it as an array of `uint256`, delimited by `delim`.\\n /// Reverts if the variable could not be parsed.\\n /// Returns `defaultValue` if the variable was not found.\\n function envOr(string calldata name, string calldata delim, uint256[] calldata defaultValue)\\n external\\n view\\n returns (uint256[] memory value);\\n\\n /// Gets the environment variable `name` and parses it as an array of `int256`, delimited by `delim`.\\n /// Reverts if the variable could not be parsed.\\n /// Returns `defaultValue` if the variable was not found.\\n function envOr(string calldata name, string calldata delim, int256[] calldata defaultValue)\\n external\\n view\\n returns (int256[] memory value);\\n\\n /// Gets the environment variable `name` and parses it as `string`.\\n /// Reverts if the variable was not found or could not be parsed.\\n function envString(string calldata name) external view returns (string memory value);\\n\\n /// Gets the environment variable `name` and parses it as an array of `string`, delimited by `delim`.\\n /// Reverts if the variable was not found or could not be parsed.\\n function envString(string calldata name, string calldata delim) external view returns (string[] memory value);\\n\\n /// Gets the environment variable `name` and parses it as `uint256`.\\n /// Reverts if the variable was not found or could not be parsed.\\n function envUint(string calldata name) external view returns (uint256 value);\\n\\n /// Gets the environment variable `name` and parses it as an array of `uint256`, delimited by `delim`.\\n /// Reverts if the variable was not found or could not be parsed.\\n function envUint(string calldata name, string calldata delim) external view returns (uint256[] memory value);\\n\\n /// Returns true if `forge` command was executed in given context.\\n function isContext(ForgeContext context) external view returns (bool result);\\n\\n /// Sets environment variables.\\n function setEnv(string calldata name, string calldata value) external;\\n\\n // ======== EVM ========\\n\\n /// Gets all accessed reads and write slot from a `vm.record` session, for a given address.\\n function accesses(address target) external returns (bytes32[] memory readSlots, bytes32[] memory writeSlots);\\n\\n /// Gets the address for a given private key.\\n function addr(uint256 privateKey) external pure returns (address keyAddr);\\n\\n /// Gets all the logs according to specified filter.\\n function eth_getLogs(uint256 fromBlock, uint256 toBlock, address target, bytes32[] calldata topics)\\n external\\n returns (EthGetLogs[] memory logs);\\n\\n /// Gets the current `block.blobbasefee`.\\n /// You should use this instead of `block.blobbasefee` if you use `vm.blobBaseFee`, as `block.blobbasefee` is assumed to be constant across a transaction,\\n /// and as a result will get optimized out by the compiler.\\n /// See https://github.com/foundry-rs/foundry/issues/6180\\n function getBlobBaseFee() external view returns (uint256 blobBaseFee);\\n\\n /// Gets the current `block.number`.\\n /// You should use this instead of `block.number` if you use `vm.roll`, as `block.number` is assumed to be constant across a transaction,\\n /// and as a result will get optimized out by the compiler.\\n /// See https://github.com/foundry-rs/foundry/issues/6180\\n function getBlockNumber() external view returns (uint256 height);\\n\\n /// Gets the current `block.timestamp`.\\n /// You should use this instead of `block.timestamp` if you use `vm.warp`, as `block.timestamp` is assumed to be constant across a transaction,\\n /// and as a result will get optimized out by the compiler.\\n /// See https://github.com/foundry-rs/foundry/issues/6180\\n function getBlockTimestamp() external view returns (uint256 timestamp);\\n\\n /// Gets the map key and parent of a mapping at a given slot, for a given address.\\n function getMappingKeyAndParentOf(address target, bytes32 elementSlot)\\n external\\n returns (bool found, bytes32 key, bytes32 parent);\\n\\n /// Gets the number of elements in the mapping at the given slot, for a given address.\\n function getMappingLength(address target, bytes32 mappingSlot) external returns (uint256 length);\\n\\n /// Gets the elements at index idx of the mapping at the given slot, for a given address. The\\n /// index must be less than the length of the mapping (i.e. the number of keys in the mapping).\\n function getMappingSlotAt(address target, bytes32 mappingSlot, uint256 idx) external returns (bytes32 value);\\n\\n /// Gets the nonce of an account.\\n function getNonce(address account) external view returns (uint64 nonce);\\n\\n /// Get the nonce of a `Wallet`.\\n function getNonce(Wallet calldata wallet) external returns (uint64 nonce);\\n\\n /// Gets all the recorded logs.\\n function getRecordedLogs() external returns (Log[] memory logs);\\n\\n /// Returns state diffs from current `vm.startStateDiffRecording` session.\\n function getStateDiff() external view returns (string memory diff);\\n\\n /// Returns state diffs from current `vm.startStateDiffRecording` session, in json format.\\n function getStateDiffJson() external view returns (string memory diff);\\n\\n /// Gets the gas used in the last call from the callee perspective.\\n function lastCallGas() external view returns (Gas memory gas);\\n\\n /// Loads a storage slot from an address.\\n function load(address target, bytes32 slot) external view returns (bytes32 data);\\n\\n /// Pauses gas metering (i.e. gas usage is not counted). Noop if already paused.\\n function pauseGasMetering() external;\\n\\n /// Records all storage reads and writes.\\n function record() external;\\n\\n /// Record all the transaction logs.\\n function recordLogs() external;\\n\\n /// Reset gas metering (i.e. gas usage is set to gas limit).\\n function resetGasMetering() external;\\n\\n /// Resumes gas metering (i.e. gas usage is counted again). Noop if already on.\\n function resumeGasMetering() external;\\n\\n /// Performs an Ethereum JSON-RPC request to the current fork URL.\\n function rpc(string calldata method, string calldata params) external returns (bytes memory data);\\n\\n /// Performs an Ethereum JSON-RPC request to the given endpoint.\\n function rpc(string calldata urlOrAlias, string calldata method, string calldata params)\\n external\\n returns (bytes memory data);\\n\\n /// Records the debug trace during the run.\\n function startDebugTraceRecording() external;\\n\\n /// Starts recording all map SSTOREs for later retrieval.\\n function startMappingRecording() external;\\n\\n /// Record all account accesses as part of CREATE, CALL or SELFDESTRUCT opcodes in order,\\n /// along with the context of the calls\\n function startStateDiffRecording() external;\\n\\n /// Stop debug trace recording and returns the recorded debug trace.\\n function stopAndReturnDebugTraceRecording() external returns (DebugStep[] memory step);\\n\\n /// Returns an ordered array of all account accesses from a `vm.startStateDiffRecording` session.\\n function stopAndReturnStateDiff() external returns (AccountAccess[] memory accountAccesses);\\n\\n /// Stops recording all map SSTOREs for later retrieval and clears the recorded data.\\n function stopMappingRecording() external;\\n\\n // ======== Filesystem ========\\n\\n /// Closes file for reading, resetting the offset and allowing to read it from beginning with readLine.\\n /// `path` is relative to the project root.\\n function closeFile(string calldata path) external;\\n\\n /// Copies the contents of one file to another. This function will **overwrite** the contents of `to`.\\n /// On success, the total number of bytes copied is returned and it is equal to the length of the `to` file as reported by `metadata`.\\n /// Both `from` and `to` are relative to the project root.\\n function copyFile(string calldata from, string calldata to) external returns (uint64 copied);\\n\\n /// Creates a new, empty directory at the provided path.\\n /// This cheatcode will revert in the following situations, but is not limited to just these cases:\\n /// - User lacks permissions to modify `path`.\\n /// - A parent of the given path doesn't exist and `recursive` is false.\\n /// - `path` already exists and `recursive` is false.\\n /// `path` is relative to the project root.\\n function createDir(string calldata path, bool recursive) external;\\n\\n /// Deploys a contract from an artifact file. Takes in the relative path to the json file or the path to the\\n /// artifact in the form of :: where and parts are optional.\\n function deployCode(string calldata artifactPath) external returns (address deployedAddress);\\n\\n /// Deploys a contract from an artifact file. Takes in the relative path to the json file or the path to the\\n /// artifact in the form of :: where and parts are optional.\\n /// Additionally accepts abi-encoded constructor arguments.\\n function deployCode(string calldata artifactPath, bytes calldata constructorArgs)\\n external\\n returns (address deployedAddress);\\n\\n /// Returns true if the given path points to an existing entity, else returns false.\\n function exists(string calldata path) external view returns (bool result);\\n\\n /// Performs a foreign function call via the terminal.\\n function ffi(string[] calldata commandInput) external returns (bytes memory result);\\n\\n /// Given a path, query the file system to get information about a file, directory, etc.\\n function fsMetadata(string calldata path) external view returns (FsMetadata memory metadata);\\n\\n /// Gets the artifact path from code (aka. creation code).\\n function getArtifactPathByCode(bytes calldata code) external view returns (string memory path);\\n\\n /// Gets the artifact path from deployed code (aka. runtime code).\\n function getArtifactPathByDeployedCode(bytes calldata deployedCode) external view returns (string memory path);\\n\\n /// Returns the most recent broadcast for the given contract on `chainId` matching `txType`.\\n /// For example:\\n /// The most recent deployment can be fetched by passing `txType` as `CREATE` or `CREATE2`.\\n /// The most recent call can be fetched by passing `txType` as `CALL`.\\n function getBroadcast(string calldata contractName, uint64 chainId, BroadcastTxType txType)\\n external\\n view\\n returns (BroadcastTxSummary memory);\\n\\n /// Returns all broadcasts for the given contract on `chainId` with the specified `txType`.\\n /// Sorted such that the most recent broadcast is the first element, and the oldest is the last. i.e descending order of BroadcastTxSummary.blockNumber.\\n function getBroadcasts(string calldata contractName, uint64 chainId, BroadcastTxType txType)\\n external\\n view\\n returns (BroadcastTxSummary[] memory);\\n\\n /// Returns all broadcasts for the given contract on `chainId`.\\n /// Sorted such that the most recent broadcast is the first element, and the oldest is the last. i.e descending order of BroadcastTxSummary.blockNumber.\\n function getBroadcasts(string calldata contractName, uint64 chainId)\\n external\\n view\\n returns (BroadcastTxSummary[] memory);\\n\\n /// Gets the creation bytecode from an artifact file. Takes in the relative path to the json file or the path to the\\n /// artifact in the form of :: where and parts are optional.\\n function getCode(string calldata artifactPath) external view returns (bytes memory creationBytecode);\\n\\n /// Gets the deployed bytecode from an artifact file. Takes in the relative path to the json file or the path to the\\n /// artifact in the form of :: where and parts are optional.\\n function getDeployedCode(string calldata artifactPath) external view returns (bytes memory runtimeBytecode);\\n\\n /// Returns the most recent deployment for the current `chainId`.\\n function getDeployment(string calldata contractName) external view returns (address deployedAddress);\\n\\n /// Returns the most recent deployment for the given contract on `chainId`\\n function getDeployment(string calldata contractName, uint64 chainId)\\n external\\n view\\n returns (address deployedAddress);\\n\\n /// Returns all deployments for the given contract on `chainId`\\n /// Sorted in descending order of deployment time i.e descending order of BroadcastTxSummary.blockNumber.\\n /// The most recent deployment is the first element, and the oldest is the last.\\n function getDeployments(string calldata contractName, uint64 chainId)\\n external\\n view\\n returns (address[] memory deployedAddresses);\\n\\n /// Returns true if the path exists on disk and is pointing at a directory, else returns false.\\n function isDir(string calldata path) external view returns (bool result);\\n\\n /// Returns true if the path exists on disk and is pointing at a regular file, else returns false.\\n function isFile(string calldata path) external view returns (bool result);\\n\\n /// Get the path of the current project root.\\n function projectRoot() external view returns (string memory path);\\n\\n /// Prompts the user for a string value in the terminal.\\n function prompt(string calldata promptText) external returns (string memory input);\\n\\n /// Prompts the user for an address in the terminal.\\n function promptAddress(string calldata promptText) external returns (address);\\n\\n /// Prompts the user for a hidden string value in the terminal.\\n function promptSecret(string calldata promptText) external returns (string memory input);\\n\\n /// Prompts the user for hidden uint256 in the terminal (usually pk).\\n function promptSecretUint(string calldata promptText) external returns (uint256);\\n\\n /// Prompts the user for uint256 in the terminal.\\n function promptUint(string calldata promptText) external returns (uint256);\\n\\n /// Reads the directory at the given path recursively, up to `maxDepth`.\\n /// `maxDepth` defaults to 1, meaning only the direct children of the given directory will be returned.\\n /// Follows symbolic links if `followLinks` is true.\\n function readDir(string calldata path) external view returns (DirEntry[] memory entries);\\n\\n /// See `readDir(string)`.\\n function readDir(string calldata path, uint64 maxDepth) external view returns (DirEntry[] memory entries);\\n\\n /// See `readDir(string)`.\\n function readDir(string calldata path, uint64 maxDepth, bool followLinks)\\n external\\n view\\n returns (DirEntry[] memory entries);\\n\\n /// Reads the entire content of file to string. `path` is relative to the project root.\\n function readFile(string calldata path) external view returns (string memory data);\\n\\n /// Reads the entire content of file as binary. `path` is relative to the project root.\\n function readFileBinary(string calldata path) external view returns (bytes memory data);\\n\\n /// Reads next line of file to string.\\n function readLine(string calldata path) external view returns (string memory line);\\n\\n /// Reads a symbolic link, returning the path that the link points to.\\n /// This cheatcode will revert in the following situations, but is not limited to just these cases:\\n /// - `path` is not a symbolic link.\\n /// - `path` does not exist.\\n function readLink(string calldata linkPath) external view returns (string memory targetPath);\\n\\n /// Removes a directory at the provided path.\\n /// This cheatcode will revert in the following situations, but is not limited to just these cases:\\n /// - `path` doesn't exist.\\n /// - `path` isn't a directory.\\n /// - User lacks permissions to modify `path`.\\n /// - The directory is not empty and `recursive` is false.\\n /// `path` is relative to the project root.\\n function removeDir(string calldata path, bool recursive) external;\\n\\n /// Removes a file from the filesystem.\\n /// This cheatcode will revert in the following situations, but is not limited to just these cases:\\n /// - `path` points to a directory.\\n /// - The file doesn't exist.\\n /// - The user lacks permissions to remove the file.\\n /// `path` is relative to the project root.\\n function removeFile(string calldata path) external;\\n\\n /// Performs a foreign function call via terminal and returns the exit code, stdout, and stderr.\\n function tryFfi(string[] calldata commandInput) external returns (FfiResult memory result);\\n\\n /// Returns the time since unix epoch in milliseconds.\\n function unixTime() external view returns (uint256 milliseconds);\\n\\n /// Writes data to file, creating a file if it does not exist, and entirely replacing its contents if it does.\\n /// `path` is relative to the project root.\\n function writeFile(string calldata path, string calldata data) external;\\n\\n /// Writes binary data to a file, creating a file if it does not exist, and entirely replacing its contents if it does.\\n /// `path` is relative to the project root.\\n function writeFileBinary(string calldata path, bytes calldata data) external;\\n\\n /// Writes line to file, creating a file if it does not exist.\\n /// `path` is relative to the project root.\\n function writeLine(string calldata path, string calldata data) external;\\n\\n // ======== JSON ========\\n\\n /// Checks if `key` exists in a JSON object.\\n function keyExistsJson(string calldata json, string calldata key) external view returns (bool);\\n\\n /// Parses a string of JSON data at `key` and coerces it to `address`.\\n function parseJsonAddress(string calldata json, string calldata key) external pure returns (address);\\n\\n /// Parses a string of JSON data at `key` and coerces it to `address[]`.\\n function parseJsonAddressArray(string calldata json, string calldata key)\\n external\\n pure\\n returns (address[] memory);\\n\\n /// Parses a string of JSON data at `key` and coerces it to `bool`.\\n function parseJsonBool(string calldata json, string calldata key) external pure returns (bool);\\n\\n /// Parses a string of JSON data at `key` and coerces it to `bool[]`.\\n function parseJsonBoolArray(string calldata json, string calldata key) external pure returns (bool[] memory);\\n\\n /// Parses a string of JSON data at `key` and coerces it to `bytes`.\\n function parseJsonBytes(string calldata json, string calldata key) external pure returns (bytes memory);\\n\\n /// Parses a string of JSON data at `key` and coerces it to `bytes32`.\\n function parseJsonBytes32(string calldata json, string calldata key) external pure returns (bytes32);\\n\\n /// Parses a string of JSON data at `key` and coerces it to `bytes32[]`.\\n function parseJsonBytes32Array(string calldata json, string calldata key)\\n external\\n pure\\n returns (bytes32[] memory);\\n\\n /// Parses a string of JSON data at `key` and coerces it to `bytes[]`.\\n function parseJsonBytesArray(string calldata json, string calldata key) external pure returns (bytes[] memory);\\n\\n /// Parses a string of JSON data at `key` and coerces it to `int256`.\\n function parseJsonInt(string calldata json, string calldata key) external pure returns (int256);\\n\\n /// Parses a string of JSON data at `key` and coerces it to `int256[]`.\\n function parseJsonIntArray(string calldata json, string calldata key) external pure returns (int256[] memory);\\n\\n /// Returns an array of all the keys in a JSON object.\\n function parseJsonKeys(string calldata json, string calldata key) external pure returns (string[] memory keys);\\n\\n /// Parses a string of JSON data at `key` and coerces it to `string`.\\n function parseJsonString(string calldata json, string calldata key) external pure returns (string memory);\\n\\n /// Parses a string of JSON data at `key` and coerces it to `string[]`.\\n function parseJsonStringArray(string calldata json, string calldata key) external pure returns (string[] memory);\\n\\n /// Parses a string of JSON data at `key` and coerces it to type array corresponding to `typeDescription`.\\n function parseJsonTypeArray(string calldata json, string calldata key, string calldata typeDescription)\\n external\\n pure\\n returns (bytes memory);\\n\\n /// Parses a string of JSON data and coerces it to type corresponding to `typeDescription`.\\n function parseJsonType(string calldata json, string calldata typeDescription)\\n external\\n pure\\n returns (bytes memory);\\n\\n /// Parses a string of JSON data at `key` and coerces it to type corresponding to `typeDescription`.\\n function parseJsonType(string calldata json, string calldata key, string calldata typeDescription)\\n external\\n pure\\n returns (bytes memory);\\n\\n /// Parses a string of JSON data at `key` and coerces it to `uint256`.\\n function parseJsonUint(string calldata json, string calldata key) external pure returns (uint256);\\n\\n /// Parses a string of JSON data at `key` and coerces it to `uint256[]`.\\n function parseJsonUintArray(string calldata json, string calldata key) external pure returns (uint256[] memory);\\n\\n /// ABI-encodes a JSON object.\\n function parseJson(string calldata json) external pure returns (bytes memory abiEncodedData);\\n\\n /// ABI-encodes a JSON object at `key`.\\n function parseJson(string calldata json, string calldata key) external pure returns (bytes memory abiEncodedData);\\n\\n /// See `serializeJson`.\\n function serializeAddress(string calldata objectKey, string calldata valueKey, address value)\\n external\\n returns (string memory json);\\n\\n /// See `serializeJson`.\\n function serializeAddress(string calldata objectKey, string calldata valueKey, address[] calldata values)\\n external\\n returns (string memory json);\\n\\n /// See `serializeJson`.\\n function serializeBool(string calldata objectKey, string calldata valueKey, bool value)\\n external\\n returns (string memory json);\\n\\n /// See `serializeJson`.\\n function serializeBool(string calldata objectKey, string calldata valueKey, bool[] calldata values)\\n external\\n returns (string memory json);\\n\\n /// See `serializeJson`.\\n function serializeBytes32(string calldata objectKey, string calldata valueKey, bytes32 value)\\n external\\n returns (string memory json);\\n\\n /// See `serializeJson`.\\n function serializeBytes32(string calldata objectKey, string calldata valueKey, bytes32[] calldata values)\\n external\\n returns (string memory json);\\n\\n /// See `serializeJson`.\\n function serializeBytes(string calldata objectKey, string calldata valueKey, bytes calldata value)\\n external\\n returns (string memory json);\\n\\n /// See `serializeJson`.\\n function serializeBytes(string calldata objectKey, string calldata valueKey, bytes[] calldata values)\\n external\\n returns (string memory json);\\n\\n /// See `serializeJson`.\\n function serializeInt(string calldata objectKey, string calldata valueKey, int256 value)\\n external\\n returns (string memory json);\\n\\n /// See `serializeJson`.\\n function serializeInt(string calldata objectKey, string calldata valueKey, int256[] calldata values)\\n external\\n returns (string memory json);\\n\\n /// Serializes a key and value to a JSON object stored in-memory that can be later written to a file.\\n /// Returns the stringified version of the specific JSON file up to that moment.\\n function serializeJson(string calldata objectKey, string calldata value) external returns (string memory json);\\n\\n /// See `serializeJson`.\\n function serializeJsonType(string calldata typeDescription, bytes calldata value)\\n external\\n pure\\n returns (string memory json);\\n\\n /// See `serializeJson`.\\n function serializeJsonType(\\n string calldata objectKey,\\n string calldata valueKey,\\n string calldata typeDescription,\\n bytes calldata value\\n ) external returns (string memory json);\\n\\n /// See `serializeJson`.\\n function serializeString(string calldata objectKey, string calldata valueKey, string calldata value)\\n external\\n returns (string memory json);\\n\\n /// See `serializeJson`.\\n function serializeString(string calldata objectKey, string calldata valueKey, string[] calldata values)\\n external\\n returns (string memory json);\\n\\n /// See `serializeJson`.\\n function serializeUintToHex(string calldata objectKey, string calldata valueKey, uint256 value)\\n external\\n returns (string memory json);\\n\\n /// See `serializeJson`.\\n function serializeUint(string calldata objectKey, string calldata valueKey, uint256 value)\\n external\\n returns (string memory json);\\n\\n /// See `serializeJson`.\\n function serializeUint(string calldata objectKey, string calldata valueKey, uint256[] calldata values)\\n external\\n returns (string memory json);\\n\\n /// Write a serialized JSON object to a file. If the file exists, it will be overwritten.\\n function writeJson(string calldata json, string calldata path) external;\\n\\n /// Write a serialized JSON object to an **existing** JSON file, replacing a value with key = \\n /// This is useful to replace a specific value of a JSON file, without having to parse the entire thing.\\n function writeJson(string calldata json, string calldata path, string calldata valueKey) external;\\n\\n /// Checks if `key` exists in a JSON object\\n /// `keyExists` is being deprecated in favor of `keyExistsJson`. It will be removed in future versions.\\n function keyExists(string calldata json, string calldata key) external view returns (bool);\\n\\n // ======== Scripting ========\\n\\n /// Designate the next call as an EIP-7702 transaction\\n function attachDelegation(SignedDelegation calldata signedDelegation) external;\\n\\n /// Takes a signed transaction and broadcasts it to the network.\\n function broadcastRawTransaction(bytes calldata data) external;\\n\\n /// Has the next call (at this call depth only) create transactions that can later be signed and sent onchain.\\n /// Broadcasting address is determined by checking the following in order:\\n /// 1. If `--sender` argument was provided, that address is used.\\n /// 2. If exactly one signer (e.g. private key, hw wallet, keystore) is set when `forge broadcast` is invoked, that signer is used.\\n /// 3. Otherwise, default foundry sender (1804c8AB1F12E6bbf3894d4083f33e07309d1f38) is used.\\n function broadcast() external;\\n\\n /// Has the next call (at this call depth only) create a transaction with the address provided\\n /// as the sender that can later be signed and sent onchain.\\n function broadcast(address signer) external;\\n\\n /// Has the next call (at this call depth only) create a transaction with the private key\\n /// provided as the sender that can later be signed and sent onchain.\\n function broadcast(uint256 privateKey) external;\\n\\n /// Returns addresses of available unlocked wallets in the script environment.\\n function getWallets() external returns (address[] memory wallets);\\n\\n /// Sign an EIP-7702 authorization and designate the next call as an EIP-7702 transaction\\n function signAndAttachDelegation(address implementation, uint256 privateKey)\\n external\\n returns (SignedDelegation memory signedDelegation);\\n\\n /// Sign an EIP-7702 authorization for delegation\\n function signDelegation(address implementation, uint256 privateKey)\\n external\\n returns (SignedDelegation memory signedDelegation);\\n\\n /// Has all subsequent calls (at this call depth only) create transactions that can later be signed and sent onchain.\\n /// Broadcasting address is determined by checking the following in order:\\n /// 1. If `--sender` argument was provided, that address is used.\\n /// 2. If exactly one signer (e.g. private key, hw wallet, keystore) is set when `forge broadcast` is invoked, that signer is used.\\n /// 3. Otherwise, default foundry sender (1804c8AB1F12E6bbf3894d4083f33e07309d1f38) is used.\\n function startBroadcast() external;\\n\\n /// Has all subsequent calls (at this call depth only) create transactions with the address\\n /// provided that can later be signed and sent onchain.\\n function startBroadcast(address signer) external;\\n\\n /// Has all subsequent calls (at this call depth only) create transactions with the private key\\n /// provided that can later be signed and sent onchain.\\n function startBroadcast(uint256 privateKey) external;\\n\\n /// Stops collecting onchain transactions.\\n function stopBroadcast() external;\\n\\n // ======== String ========\\n\\n /// Returns true if `search` is found in `subject`, false otherwise.\\n function contains(string calldata subject, string calldata search) external returns (bool result);\\n\\n /// Returns the index of the first occurrence of a `key` in an `input` string.\\n /// Returns `NOT_FOUND` (i.e. `type(uint256).max`) if the `key` is not found.\\n /// Returns 0 in case of an empty `key`.\\n function indexOf(string calldata input, string calldata key) external pure returns (uint256);\\n\\n /// Parses the given `string` into an `address`.\\n function parseAddress(string calldata stringifiedValue) external pure returns (address parsedValue);\\n\\n /// Parses the given `string` into a `bool`.\\n function parseBool(string calldata stringifiedValue) external pure returns (bool parsedValue);\\n\\n /// Parses the given `string` into `bytes`.\\n function parseBytes(string calldata stringifiedValue) external pure returns (bytes memory parsedValue);\\n\\n /// Parses the given `string` into a `bytes32`.\\n function parseBytes32(string calldata stringifiedValue) external pure returns (bytes32 parsedValue);\\n\\n /// Parses the given `string` into a `int256`.\\n function parseInt(string calldata stringifiedValue) external pure returns (int256 parsedValue);\\n\\n /// Parses the given `string` into a `uint256`.\\n function parseUint(string calldata stringifiedValue) external pure returns (uint256 parsedValue);\\n\\n /// Replaces occurrences of `from` in the given `string` with `to`.\\n function replace(string calldata input, string calldata from, string calldata to)\\n external\\n pure\\n returns (string memory output);\\n\\n /// Splits the given `string` into an array of strings divided by the `delimiter`.\\n function split(string calldata input, string calldata delimiter) external pure returns (string[] memory outputs);\\n\\n /// Converts the given `string` value to Lowercase.\\n function toLowercase(string calldata input) external pure returns (string memory output);\\n\\n /// Converts the given value to a `string`.\\n function toString(address value) external pure returns (string memory stringifiedValue);\\n\\n /// Converts the given value to a `string`.\\n function toString(bytes calldata value) external pure returns (string memory stringifiedValue);\\n\\n /// Converts the given value to a `string`.\\n function toString(bytes32 value) external pure returns (string memory stringifiedValue);\\n\\n /// Converts the given value to a `string`.\\n function toString(bool value) external pure returns (string memory stringifiedValue);\\n\\n /// Converts the given value to a `string`.\\n function toString(uint256 value) external pure returns (string memory stringifiedValue);\\n\\n /// Converts the given value to a `string`.\\n function toString(int256 value) external pure returns (string memory stringifiedValue);\\n\\n /// Converts the given `string` value to Uppercase.\\n function toUppercase(string calldata input) external pure returns (string memory output);\\n\\n /// Trims leading and trailing whitespace from the given `string` value.\\n function trim(string calldata input) external pure returns (string memory output);\\n\\n // ======== Testing ========\\n\\n /// Compares two `uint256` values. Expects difference to be less than or equal to `maxDelta`.\\n /// Formats values with decimals in failure message.\\n function assertApproxEqAbsDecimal(uint256 left, uint256 right, uint256 maxDelta, uint256 decimals) external pure;\\n\\n /// Compares two `uint256` values. Expects difference to be less than or equal to `maxDelta`.\\n /// Formats values with decimals in failure message. Includes error message into revert string on failure.\\n function assertApproxEqAbsDecimal(\\n uint256 left,\\n uint256 right,\\n uint256 maxDelta,\\n uint256 decimals,\\n string calldata error\\n ) external pure;\\n\\n /// Compares two `int256` values. Expects difference to be less than or equal to `maxDelta`.\\n /// Formats values with decimals in failure message.\\n function assertApproxEqAbsDecimal(int256 left, int256 right, uint256 maxDelta, uint256 decimals) external pure;\\n\\n /// Compares two `int256` values. Expects difference to be less than or equal to `maxDelta`.\\n /// Formats values with decimals in failure message. Includes error message into revert string on failure.\\n function assertApproxEqAbsDecimal(\\n int256 left,\\n int256 right,\\n uint256 maxDelta,\\n uint256 decimals,\\n string calldata error\\n ) external pure;\\n\\n /// Compares two `uint256` values. Expects difference to be less than or equal to `maxDelta`.\\n function assertApproxEqAbs(uint256 left, uint256 right, uint256 maxDelta) external pure;\\n\\n /// Compares two `uint256` values. Expects difference to be less than or equal to `maxDelta`.\\n /// Includes error message into revert string on failure.\\n function assertApproxEqAbs(uint256 left, uint256 right, uint256 maxDelta, string calldata error) external pure;\\n\\n /// Compares two `int256` values. Expects difference to be less than or equal to `maxDelta`.\\n function assertApproxEqAbs(int256 left, int256 right, uint256 maxDelta) external pure;\\n\\n /// Compares two `int256` values. Expects difference to be less than or equal to `maxDelta`.\\n /// Includes error message into revert string on failure.\\n function assertApproxEqAbs(int256 left, int256 right, uint256 maxDelta, string calldata error) external pure;\\n\\n /// Compares two `uint256` values. Expects relative difference in percents to be less than or equal to `maxPercentDelta`.\\n /// `maxPercentDelta` is an 18 decimal fixed point number, where 1e18 == 100%\\n /// Formats values with decimals in failure message.\\n function assertApproxEqRelDecimal(uint256 left, uint256 right, uint256 maxPercentDelta, uint256 decimals)\\n external\\n pure;\\n\\n /// Compares two `uint256` values. Expects relative difference in percents to be less than or equal to `maxPercentDelta`.\\n /// `maxPercentDelta` is an 18 decimal fixed point number, where 1e18 == 100%\\n /// Formats values with decimals in failure message. Includes error message into revert string on failure.\\n function assertApproxEqRelDecimal(\\n uint256 left,\\n uint256 right,\\n uint256 maxPercentDelta,\\n uint256 decimals,\\n string calldata error\\n ) external pure;\\n\\n /// Compares two `int256` values. Expects relative difference in percents to be less than or equal to `maxPercentDelta`.\\n /// `maxPercentDelta` is an 18 decimal fixed point number, where 1e18 == 100%\\n /// Formats values with decimals in failure message.\\n function assertApproxEqRelDecimal(int256 left, int256 right, uint256 maxPercentDelta, uint256 decimals)\\n external\\n pure;\\n\\n /// Compares two `int256` values. Expects relative difference in percents to be less than or equal to `maxPercentDelta`.\\n /// `maxPercentDelta` is an 18 decimal fixed point number, where 1e18 == 100%\\n /// Formats values with decimals in failure message. Includes error message into revert string on failure.\\n function assertApproxEqRelDecimal(\\n int256 left,\\n int256 right,\\n uint256 maxPercentDelta,\\n uint256 decimals,\\n string calldata error\\n ) external pure;\\n\\n /// Compares two `uint256` values. Expects relative difference in percents to be less than or equal to `maxPercentDelta`.\\n /// `maxPercentDelta` is an 18 decimal fixed point number, where 1e18 == 100%\\n function assertApproxEqRel(uint256 left, uint256 right, uint256 maxPercentDelta) external pure;\\n\\n /// Compares two `uint256` values. Expects relative difference in percents to be less than or equal to `maxPercentDelta`.\\n /// `maxPercentDelta` is an 18 decimal fixed point number, where 1e18 == 100%\\n /// Includes error message into revert string on failure.\\n function assertApproxEqRel(uint256 left, uint256 right, uint256 maxPercentDelta, string calldata error)\\n external\\n pure;\\n\\n /// Compares two `int256` values. Expects relative difference in percents to be less than or equal to `maxPercentDelta`.\\n /// `maxPercentDelta` is an 18 decimal fixed point number, where 1e18 == 100%\\n function assertApproxEqRel(int256 left, int256 right, uint256 maxPercentDelta) external pure;\\n\\n /// Compares two `int256` values. Expects relative difference in percents to be less than or equal to `maxPercentDelta`.\\n /// `maxPercentDelta` is an 18 decimal fixed point number, where 1e18 == 100%\\n /// Includes error message into revert string on failure.\\n function assertApproxEqRel(int256 left, int256 right, uint256 maxPercentDelta, string calldata error)\\n external\\n pure;\\n\\n /// Asserts that two `uint256` values are equal, formatting them with decimals in failure message.\\n function assertEqDecimal(uint256 left, uint256 right, uint256 decimals) external pure;\\n\\n /// Asserts that two `uint256` values are equal, formatting them with decimals in failure message.\\n /// Includes error message into revert string on failure.\\n function assertEqDecimal(uint256 left, uint256 right, uint256 decimals, string calldata error) external pure;\\n\\n /// Asserts that two `int256` values are equal, formatting them with decimals in failure message.\\n function assertEqDecimal(int256 left, int256 right, uint256 decimals) external pure;\\n\\n /// Asserts that two `int256` values are equal, formatting them with decimals in failure message.\\n /// Includes error message into revert string on failure.\\n function assertEqDecimal(int256 left, int256 right, uint256 decimals, string calldata error) external pure;\\n\\n /// Asserts that two `bool` values are equal.\\n function assertEq(bool left, bool right) external pure;\\n\\n /// Asserts that two `bool` values are equal and includes error message into revert string on failure.\\n function assertEq(bool left, bool right, string calldata error) external pure;\\n\\n /// Asserts that two `string` values are equal.\\n function assertEq(string calldata left, string calldata right) external pure;\\n\\n /// Asserts that two `string` values are equal and includes error message into revert string on failure.\\n function assertEq(string calldata left, string calldata right, string calldata error) external pure;\\n\\n /// Asserts that two `bytes` values are equal.\\n function assertEq(bytes calldata left, bytes calldata right) external pure;\\n\\n /// Asserts that two `bytes` values are equal and includes error message into revert string on failure.\\n function assertEq(bytes calldata left, bytes calldata right, string calldata error) external pure;\\n\\n /// Asserts that two arrays of `bool` values are equal.\\n function assertEq(bool[] calldata left, bool[] calldata right) external pure;\\n\\n /// Asserts that two arrays of `bool` values are equal and includes error message into revert string on failure.\\n function assertEq(bool[] calldata left, bool[] calldata right, string calldata error) external pure;\\n\\n /// Asserts that two arrays of `uint256 values are equal.\\n function assertEq(uint256[] calldata left, uint256[] calldata right) external pure;\\n\\n /// Asserts that two arrays of `uint256` values are equal and includes error message into revert string on failure.\\n function assertEq(uint256[] calldata left, uint256[] calldata right, string calldata error) external pure;\\n\\n /// Asserts that two arrays of `int256` values are equal.\\n function assertEq(int256[] calldata left, int256[] calldata right) external pure;\\n\\n /// Asserts that two arrays of `int256` values are equal and includes error message into revert string on failure.\\n function assertEq(int256[] calldata left, int256[] calldata right, string calldata error) external pure;\\n\\n /// Asserts that two `uint256` values are equal.\\n function assertEq(uint256 left, uint256 right) external pure;\\n\\n /// Asserts that two arrays of `address` values are equal.\\n function assertEq(address[] calldata left, address[] calldata right) external pure;\\n\\n /// Asserts that two arrays of `address` values are equal and includes error message into revert string on failure.\\n function assertEq(address[] calldata left, address[] calldata right, string calldata error) external pure;\\n\\n /// Asserts that two arrays of `bytes32` values are equal.\\n function assertEq(bytes32[] calldata left, bytes32[] calldata right) external pure;\\n\\n /// Asserts that two arrays of `bytes32` values are equal and includes error message into revert string on failure.\\n function assertEq(bytes32[] calldata left, bytes32[] calldata right, string calldata error) external pure;\\n\\n /// Asserts that two arrays of `string` values are equal.\\n function assertEq(string[] calldata left, string[] calldata right) external pure;\\n\\n /// Asserts that two arrays of `string` values are equal and includes error message into revert string on failure.\\n function assertEq(string[] calldata left, string[] calldata right, string calldata error) external pure;\\n\\n /// Asserts that two arrays of `bytes` values are equal.\\n function assertEq(bytes[] calldata left, bytes[] calldata right) external pure;\\n\\n /// Asserts that two arrays of `bytes` values are equal and includes error message into revert string on failure.\\n function assertEq(bytes[] calldata left, bytes[] calldata right, string calldata error) external pure;\\n\\n /// Asserts that two `uint256` values are equal and includes error message into revert string on failure.\\n function assertEq(uint256 left, uint256 right, string calldata error) external pure;\\n\\n /// Asserts that two `int256` values are equal.\\n function assertEq(int256 left, int256 right) external pure;\\n\\n /// Asserts that two `int256` values are equal and includes error message into revert string on failure.\\n function assertEq(int256 left, int256 right, string calldata error) external pure;\\n\\n /// Asserts that two `address` values are equal.\\n function assertEq(address left, address right) external pure;\\n\\n /// Asserts that two `address` values are equal and includes error message into revert string on failure.\\n function assertEq(address left, address right, string calldata error) external pure;\\n\\n /// Asserts that two `bytes32` values are equal.\\n function assertEq(bytes32 left, bytes32 right) external pure;\\n\\n /// Asserts that two `bytes32` values are equal and includes error message into revert string on failure.\\n function assertEq(bytes32 left, bytes32 right, string calldata error) external pure;\\n\\n /// Asserts that the given condition is false.\\n function assertFalse(bool condition) external pure;\\n\\n /// Asserts that the given condition is false and includes error message into revert string on failure.\\n function assertFalse(bool condition, string calldata error) external pure;\\n\\n /// Compares two `uint256` values. Expects first value to be greater than or equal to second.\\n /// Formats values with decimals in failure message.\\n function assertGeDecimal(uint256 left, uint256 right, uint256 decimals) external pure;\\n\\n /// Compares two `uint256` values. Expects first value to be greater than or equal to second.\\n /// Formats values with decimals in failure message. Includes error message into revert string on failure.\\n function assertGeDecimal(uint256 left, uint256 right, uint256 decimals, string calldata error) external pure;\\n\\n /// Compares two `int256` values. Expects first value to be greater than or equal to second.\\n /// Formats values with decimals in failure message.\\n function assertGeDecimal(int256 left, int256 right, uint256 decimals) external pure;\\n\\n /// Compares two `int256` values. Expects first value to be greater than or equal to second.\\n /// Formats values with decimals in failure message. Includes error message into revert string on failure.\\n function assertGeDecimal(int256 left, int256 right, uint256 decimals, string calldata error) external pure;\\n\\n /// Compares two `uint256` values. Expects first value to be greater than or equal to second.\\n function assertGe(uint256 left, uint256 right) external pure;\\n\\n /// Compares two `uint256` values. Expects first value to be greater than or equal to second.\\n /// Includes error message into revert string on failure.\\n function assertGe(uint256 left, uint256 right, string calldata error) external pure;\\n\\n /// Compares two `int256` values. Expects first value to be greater than or equal to second.\\n function assertGe(int256 left, int256 right) external pure;\\n\\n /// Compares two `int256` values. Expects first value to be greater than or equal to second.\\n /// Includes error message into revert string on failure.\\n function assertGe(int256 left, int256 right, string calldata error) external pure;\\n\\n /// Compares two `uint256` values. Expects first value to be greater than second.\\n /// Formats values with decimals in failure message.\\n function assertGtDecimal(uint256 left, uint256 right, uint256 decimals) external pure;\\n\\n /// Compares two `uint256` values. Expects first value to be greater than second.\\n /// Formats values with decimals in failure message. Includes error message into revert string on failure.\\n function assertGtDecimal(uint256 left, uint256 right, uint256 decimals, string calldata error) external pure;\\n\\n /// Compares two `int256` values. Expects first value to be greater than second.\\n /// Formats values with decimals in failure message.\\n function assertGtDecimal(int256 left, int256 right, uint256 decimals) external pure;\\n\\n /// Compares two `int256` values. Expects first value to be greater than second.\\n /// Formats values with decimals in failure message. Includes error message into revert string on failure.\\n function assertGtDecimal(int256 left, int256 right, uint256 decimals, string calldata error) external pure;\\n\\n /// Compares two `uint256` values. Expects first value to be greater than second.\\n function assertGt(uint256 left, uint256 right) external pure;\\n\\n /// Compares two `uint256` values. Expects first value to be greater than second.\\n /// Includes error message into revert string on failure.\\n function assertGt(uint256 left, uint256 right, string calldata error) external pure;\\n\\n /// Compares two `int256` values. Expects first value to be greater than second.\\n function assertGt(int256 left, int256 right) external pure;\\n\\n /// Compares two `int256` values. Expects first value to be greater than second.\\n /// Includes error message into revert string on failure.\\n function assertGt(int256 left, int256 right, string calldata error) external pure;\\n\\n /// Compares two `uint256` values. Expects first value to be less than or equal to second.\\n /// Formats values with decimals in failure message.\\n function assertLeDecimal(uint256 left, uint256 right, uint256 decimals) external pure;\\n\\n /// Compares two `uint256` values. Expects first value to be less than or equal to second.\\n /// Formats values with decimals in failure message. Includes error message into revert string on failure.\\n function assertLeDecimal(uint256 left, uint256 right, uint256 decimals, string calldata error) external pure;\\n\\n /// Compares two `int256` values. Expects first value to be less than or equal to second.\\n /// Formats values with decimals in failure message.\\n function assertLeDecimal(int256 left, int256 right, uint256 decimals) external pure;\\n\\n /// Compares two `int256` values. Expects first value to be less than or equal to second.\\n /// Formats values with decimals in failure message. Includes error message into revert string on failure.\\n function assertLeDecimal(int256 left, int256 right, uint256 decimals, string calldata error) external pure;\\n\\n /// Compares two `uint256` values. Expects first value to be less than or equal to second.\\n function assertLe(uint256 left, uint256 right) external pure;\\n\\n /// Compares two `uint256` values. Expects first value to be less than or equal to second.\\n /// Includes error message into revert string on failure.\\n function assertLe(uint256 left, uint256 right, string calldata error) external pure;\\n\\n /// Compares two `int256` values. Expects first value to be less than or equal to second.\\n function assertLe(int256 left, int256 right) external pure;\\n\\n /// Compares two `int256` values. Expects first value to be less than or equal to second.\\n /// Includes error message into revert string on failure.\\n function assertLe(int256 left, int256 right, string calldata error) external pure;\\n\\n /// Compares two `uint256` values. Expects first value to be less than second.\\n /// Formats values with decimals in failure message.\\n function assertLtDecimal(uint256 left, uint256 right, uint256 decimals) external pure;\\n\\n /// Compares two `uint256` values. Expects first value to be less than second.\\n /// Formats values with decimals in failure message. Includes error message into revert string on failure.\\n function assertLtDecimal(uint256 left, uint256 right, uint256 decimals, string calldata error) external pure;\\n\\n /// Compares two `int256` values. Expects first value to be less than second.\\n /// Formats values with decimals in failure message.\\n function assertLtDecimal(int256 left, int256 right, uint256 decimals) external pure;\\n\\n /// Compares two `int256` values. Expects first value to be less than second.\\n /// Formats values with decimals in failure message. Includes error message into revert string on failure.\\n function assertLtDecimal(int256 left, int256 right, uint256 decimals, string calldata error) external pure;\\n\\n /// Compares two `uint256` values. Expects first value to be less than second.\\n function assertLt(uint256 left, uint256 right) external pure;\\n\\n /// Compares two `uint256` values. Expects first value to be less than second.\\n /// Includes error message into revert string on failure.\\n function assertLt(uint256 left, uint256 right, string calldata error) external pure;\\n\\n /// Compares two `int256` values. Expects first value to be less than second.\\n function assertLt(int256 left, int256 right) external pure;\\n\\n /// Compares two `int256` values. Expects first value to be less than second.\\n /// Includes error message into revert string on failure.\\n function assertLt(int256 left, int256 right, string calldata error) external pure;\\n\\n /// Asserts that two `uint256` values are not equal, formatting them with decimals in failure message.\\n function assertNotEqDecimal(uint256 left, uint256 right, uint256 decimals) external pure;\\n\\n /// Asserts that two `uint256` values are not equal, formatting them with decimals in failure message.\\n /// Includes error message into revert string on failure.\\n function assertNotEqDecimal(uint256 left, uint256 right, uint256 decimals, string calldata error) external pure;\\n\\n /// Asserts that two `int256` values are not equal, formatting them with decimals in failure message.\\n function assertNotEqDecimal(int256 left, int256 right, uint256 decimals) external pure;\\n\\n /// Asserts that two `int256` values are not equal, formatting them with decimals in failure message.\\n /// Includes error message into revert string on failure.\\n function assertNotEqDecimal(int256 left, int256 right, uint256 decimals, string calldata error) external pure;\\n\\n /// Asserts that two `bool` values are not equal.\\n function assertNotEq(bool left, bool right) external pure;\\n\\n /// Asserts that two `bool` values are not equal and includes error message into revert string on failure.\\n function assertNotEq(bool left, bool right, string calldata error) external pure;\\n\\n /// Asserts that two `string` values are not equal.\\n function assertNotEq(string calldata left, string calldata right) external pure;\\n\\n /// Asserts that two `string` values are not equal and includes error message into revert string on failure.\\n function assertNotEq(string calldata left, string calldata right, string calldata error) external pure;\\n\\n /// Asserts that two `bytes` values are not equal.\\n function assertNotEq(bytes calldata left, bytes calldata right) external pure;\\n\\n /// Asserts that two `bytes` values are not equal and includes error message into revert string on failure.\\n function assertNotEq(bytes calldata left, bytes calldata right, string calldata error) external pure;\\n\\n /// Asserts that two arrays of `bool` values are not equal.\\n function assertNotEq(bool[] calldata left, bool[] calldata right) external pure;\\n\\n /// Asserts that two arrays of `bool` values are not equal and includes error message into revert string on failure.\\n function assertNotEq(bool[] calldata left, bool[] calldata right, string calldata error) external pure;\\n\\n /// Asserts that two arrays of `uint256` values are not equal.\\n function assertNotEq(uint256[] calldata left, uint256[] calldata right) external pure;\\n\\n /// Asserts that two arrays of `uint256` values are not equal and includes error message into revert string on failure.\\n function assertNotEq(uint256[] calldata left, uint256[] calldata right, string calldata error) external pure;\\n\\n /// Asserts that two arrays of `int256` values are not equal.\\n function assertNotEq(int256[] calldata left, int256[] calldata right) external pure;\\n\\n /// Asserts that two arrays of `int256` values are not equal and includes error message into revert string on failure.\\n function assertNotEq(int256[] calldata left, int256[] calldata right, string calldata error) external pure;\\n\\n /// Asserts that two `uint256` values are not equal.\\n function assertNotEq(uint256 left, uint256 right) external pure;\\n\\n /// Asserts that two arrays of `address` values are not equal.\\n function assertNotEq(address[] calldata left, address[] calldata right) external pure;\\n\\n /// Asserts that two arrays of `address` values are not equal and includes error message into revert string on failure.\\n function assertNotEq(address[] calldata left, address[] calldata right, string calldata error) external pure;\\n\\n /// Asserts that two arrays of `bytes32` values are not equal.\\n function assertNotEq(bytes32[] calldata left, bytes32[] calldata right) external pure;\\n\\n /// Asserts that two arrays of `bytes32` values are not equal and includes error message into revert string on failure.\\n function assertNotEq(bytes32[] calldata left, bytes32[] calldata right, string calldata error) external pure;\\n\\n /// Asserts that two arrays of `string` values are not equal.\\n function assertNotEq(string[] calldata left, string[] calldata right) external pure;\\n\\n /// Asserts that two arrays of `string` values are not equal and includes error message into revert string on failure.\\n function assertNotEq(string[] calldata left, string[] calldata right, string calldata error) external pure;\\n\\n /// Asserts that two arrays of `bytes` values are not equal.\\n function assertNotEq(bytes[] calldata left, bytes[] calldata right) external pure;\\n\\n /// Asserts that two arrays of `bytes` values are not equal and includes error message into revert string on failure.\\n function assertNotEq(bytes[] calldata left, bytes[] calldata right, string calldata error) external pure;\\n\\n /// Asserts that two `uint256` values are not equal and includes error message into revert string on failure.\\n function assertNotEq(uint256 left, uint256 right, string calldata error) external pure;\\n\\n /// Asserts that two `int256` values are not equal.\\n function assertNotEq(int256 left, int256 right) external pure;\\n\\n /// Asserts that two `int256` values are not equal and includes error message into revert string on failure.\\n function assertNotEq(int256 left, int256 right, string calldata error) external pure;\\n\\n /// Asserts that two `address` values are not equal.\\n function assertNotEq(address left, address right) external pure;\\n\\n /// Asserts that two `address` values are not equal and includes error message into revert string on failure.\\n function assertNotEq(address left, address right, string calldata error) external pure;\\n\\n /// Asserts that two `bytes32` values are not equal.\\n function assertNotEq(bytes32 left, bytes32 right) external pure;\\n\\n /// Asserts that two `bytes32` values are not equal and includes error message into revert string on failure.\\n function assertNotEq(bytes32 left, bytes32 right, string calldata error) external pure;\\n\\n /// Asserts that the given condition is true.\\n function assertTrue(bool condition) external pure;\\n\\n /// Asserts that the given condition is true and includes error message into revert string on failure.\\n function assertTrue(bool condition, string calldata error) external pure;\\n\\n /// If the condition is false, discard this run's fuzz inputs and generate new ones.\\n function assume(bool condition) external pure;\\n\\n /// Discard this run's fuzz inputs and generate new ones if next call reverted.\\n function assumeNoRevert() external pure;\\n\\n /// Discard this run's fuzz inputs and generate new ones if next call reverts with the potential revert parameters.\\n function assumeNoRevert(PotentialRevert calldata potentialRevert) external pure;\\n\\n /// Discard this run's fuzz inputs and generate new ones if next call reverts with the any of the potential revert parameters.\\n function assumeNoRevert(PotentialRevert[] calldata potentialReverts) external pure;\\n\\n /// Writes a breakpoint to jump to in the debugger.\\n function breakpoint(string calldata char) external pure;\\n\\n /// Writes a conditional breakpoint to jump to in the debugger.\\n function breakpoint(string calldata char, bool value) external pure;\\n\\n /// Returns true if the current Foundry version is greater than or equal to the given version.\\n /// The given version string must be in the format `major.minor.patch`.\\n /// This is equivalent to `foundryVersionCmp(version) >= 0`.\\n function foundryVersionAtLeast(string calldata version) external view returns (bool);\\n\\n /// Compares the current Foundry version with the given version string.\\n /// The given version string must be in the format `major.minor.patch`.\\n /// Returns:\\n /// -1 if current Foundry version is less than the given version\\n /// 0 if current Foundry version equals the given version\\n /// 1 if current Foundry version is greater than the given version\\n /// This result can then be used with a comparison operator against `0`.\\n /// For example, to check if the current Foundry version is greater than or equal to `1.0.0`:\\n /// `if (foundryVersionCmp(\\\"1.0.0\\\") >= 0) { ... }`\\n function foundryVersionCmp(string calldata version) external view returns (int256);\\n\\n /// Returns the Foundry version.\\n /// Format: -+..\\n /// Sample output: 0.3.0-nightly+3cb96bde9b.1737036656.debug\\n /// Note: Build timestamps may vary slightly across platforms due to separate CI jobs.\\n /// For reliable version comparisons, use UNIX format (e.g., >= 1700000000)\\n /// to compare timestamps while ignoring minor time differences.\\n function getFoundryVersion() external view returns (string memory version);\\n\\n /// Returns the RPC url for the given alias.\\n function rpcUrl(string calldata rpcAlias) external view returns (string memory json);\\n\\n /// Returns all rpc urls and their aliases as structs.\\n function rpcUrlStructs() external view returns (Rpc[] memory urls);\\n\\n /// Returns all rpc urls and their aliases `[alias, url][]`.\\n function rpcUrls() external view returns (string[2][] memory urls);\\n\\n /// Suspends execution of the main thread for `duration` milliseconds.\\n function sleep(uint256 duration) external;\\n\\n // ======== Toml ========\\n\\n /// Checks if `key` exists in a TOML table.\\n function keyExistsToml(string calldata toml, string calldata key) external view returns (bool);\\n\\n /// Parses a string of TOML data at `key` and coerces it to `address`.\\n function parseTomlAddress(string calldata toml, string calldata key) external pure returns (address);\\n\\n /// Parses a string of TOML data at `key` and coerces it to `address[]`.\\n function parseTomlAddressArray(string calldata toml, string calldata key)\\n external\\n pure\\n returns (address[] memory);\\n\\n /// Parses a string of TOML data at `key` and coerces it to `bool`.\\n function parseTomlBool(string calldata toml, string calldata key) external pure returns (bool);\\n\\n /// Parses a string of TOML data at `key` and coerces it to `bool[]`.\\n function parseTomlBoolArray(string calldata toml, string calldata key) external pure returns (bool[] memory);\\n\\n /// Parses a string of TOML data at `key` and coerces it to `bytes`.\\n function parseTomlBytes(string calldata toml, string calldata key) external pure returns (bytes memory);\\n\\n /// Parses a string of TOML data at `key` and coerces it to `bytes32`.\\n function parseTomlBytes32(string calldata toml, string calldata key) external pure returns (bytes32);\\n\\n /// Parses a string of TOML data at `key` and coerces it to `bytes32[]`.\\n function parseTomlBytes32Array(string calldata toml, string calldata key)\\n external\\n pure\\n returns (bytes32[] memory);\\n\\n /// Parses a string of TOML data at `key` and coerces it to `bytes[]`.\\n function parseTomlBytesArray(string calldata toml, string calldata key) external pure returns (bytes[] memory);\\n\\n /// Parses a string of TOML data at `key` and coerces it to `int256`.\\n function parseTomlInt(string calldata toml, string calldata key) external pure returns (int256);\\n\\n /// Parses a string of TOML data at `key` and coerces it to `int256[]`.\\n function parseTomlIntArray(string calldata toml, string calldata key) external pure returns (int256[] memory);\\n\\n /// Returns an array of all the keys in a TOML table.\\n function parseTomlKeys(string calldata toml, string calldata key) external pure returns (string[] memory keys);\\n\\n /// Parses a string of TOML data at `key` and coerces it to `string`.\\n function parseTomlString(string calldata toml, string calldata key) external pure returns (string memory);\\n\\n /// Parses a string of TOML data at `key` and coerces it to `string[]`.\\n function parseTomlStringArray(string calldata toml, string calldata key) external pure returns (string[] memory);\\n\\n /// Parses a string of TOML data at `key` and coerces it to type array corresponding to `typeDescription`.\\n function parseTomlTypeArray(string calldata toml, string calldata key, string calldata typeDescription)\\n external\\n pure\\n returns (bytes memory);\\n\\n /// Parses a string of TOML data and coerces it to type corresponding to `typeDescription`.\\n function parseTomlType(string calldata toml, string calldata typeDescription)\\n external\\n pure\\n returns (bytes memory);\\n\\n /// Parses a string of TOML data at `key` and coerces it to type corresponding to `typeDescription`.\\n function parseTomlType(string calldata toml, string calldata key, string calldata typeDescription)\\n external\\n pure\\n returns (bytes memory);\\n\\n /// Parses a string of TOML data at `key` and coerces it to `uint256`.\\n function parseTomlUint(string calldata toml, string calldata key) external pure returns (uint256);\\n\\n /// Parses a string of TOML data at `key` and coerces it to `uint256[]`.\\n function parseTomlUintArray(string calldata toml, string calldata key) external pure returns (uint256[] memory);\\n\\n /// ABI-encodes a TOML table.\\n function parseToml(string calldata toml) external pure returns (bytes memory abiEncodedData);\\n\\n /// ABI-encodes a TOML table at `key`.\\n function parseToml(string calldata toml, string calldata key) external pure returns (bytes memory abiEncodedData);\\n\\n /// Takes serialized JSON, converts to TOML and write a serialized TOML to a file.\\n function writeToml(string calldata json, string calldata path) external;\\n\\n /// Takes serialized JSON, converts to TOML and write a serialized TOML table to an **existing** TOML file, replacing a value with key = \\n /// This is useful to replace a specific value of a TOML file, without having to parse the entire thing.\\n function writeToml(string calldata json, string calldata path, string calldata valueKey) external;\\n\\n // ======== Utilities ========\\n\\n /// Compute the address of a contract created with CREATE2 using the given CREATE2 deployer.\\n function computeCreate2Address(bytes32 salt, bytes32 initCodeHash, address deployer)\\n external\\n pure\\n returns (address);\\n\\n /// Compute the address of a contract created with CREATE2 using the default CREATE2 deployer.\\n function computeCreate2Address(bytes32 salt, bytes32 initCodeHash) external pure returns (address);\\n\\n /// Compute the address a contract will be deployed at for a given deployer address and nonce.\\n function computeCreateAddress(address deployer, uint256 nonce) external pure returns (address);\\n\\n /// Utility cheatcode to copy storage of `from` contract to another `to` contract.\\n function copyStorage(address from, address to) external;\\n\\n /// Returns ENS namehash for provided string.\\n function ensNamehash(string calldata name) external pure returns (bytes32);\\n\\n /// Gets the label for the specified address.\\n function getLabel(address account) external view returns (string memory currentLabel);\\n\\n /// Labels an address in call traces.\\n function label(address account, string calldata newLabel) external;\\n\\n /// Pauses collection of call traces. Useful in cases when you want to skip tracing of\\n /// complex calls which are not useful for debugging.\\n function pauseTracing() external view;\\n\\n /// Returns a random `address`.\\n function randomAddress() external returns (address);\\n\\n /// Returns a random `bool`.\\n function randomBool() external view returns (bool);\\n\\n /// Returns a random byte array value of the given length.\\n function randomBytes(uint256 len) external view returns (bytes memory);\\n\\n /// Returns a random fixed-size byte array of length 4.\\n function randomBytes4() external view returns (bytes4);\\n\\n /// Returns a random fixed-size byte array of length 8.\\n function randomBytes8() external view returns (bytes8);\\n\\n /// Returns a random `int256` value.\\n function randomInt() external view returns (int256);\\n\\n /// Returns a random `int256` value of given bits.\\n function randomInt(uint256 bits) external view returns (int256);\\n\\n /// Returns a random uint256 value.\\n function randomUint() external returns (uint256);\\n\\n /// Returns random uint256 value between the provided range (=min..=max).\\n function randomUint(uint256 min, uint256 max) external returns (uint256);\\n\\n /// Returns a random `uint256` value of given bits.\\n function randomUint(uint256 bits) external view returns (uint256);\\n\\n /// Unpauses collection of call traces.\\n function resumeTracing() external view;\\n\\n /// Utility cheatcode to set arbitrary storage for given target address.\\n function setArbitraryStorage(address target) external;\\n\\n /// Encodes a `bytes` value to a base64url string.\\n function toBase64URL(bytes calldata data) external pure returns (string memory);\\n\\n /// Encodes a `string` value to a base64url string.\\n function toBase64URL(string calldata data) external pure returns (string memory);\\n\\n /// Encodes a `bytes` value to a base64 string.\\n function toBase64(bytes calldata data) external pure returns (string memory);\\n\\n /// Encodes a `string` value to a base64 string.\\n function toBase64(string calldata data) external pure returns (string memory);\\n}\\n\\n/// The `Vm` interface does allow manipulation of the EVM state. These are all intended to be used\\n/// in tests, but it is not recommended to use these cheats in scripts.\\ninterface Vm is VmSafe {\\n // ======== EVM ========\\n\\n /// Utility cheatcode to set an EIP-2930 access list for all subsequent transactions.\\n function accessList(AccessListItem[] calldata access) external;\\n\\n /// Returns the identifier of the currently active fork. Reverts if no fork is currently active.\\n function activeFork() external view returns (uint256 forkId);\\n\\n /// In forking mode, explicitly grant the given address cheatcode access.\\n function allowCheatcodes(address account) external;\\n\\n /// Sets `block.blobbasefee`\\n function blobBaseFee(uint256 newBlobBaseFee) external;\\n\\n /// Sets the blobhashes in the transaction.\\n /// Not available on EVM versions before Cancun.\\n /// If used on unsupported EVM versions it will revert.\\n function blobhashes(bytes32[] calldata hashes) external;\\n\\n /// Sets `block.chainid`.\\n function chainId(uint256 newChainId) external;\\n\\n /// Clears all mocked calls.\\n function clearMockedCalls() external;\\n\\n /// Clones a source account code, state, balance and nonce to a target account and updates in-memory EVM state.\\n function cloneAccount(address source, address target) external;\\n\\n /// Sets `block.coinbase`.\\n function coinbase(address newCoinbase) external;\\n\\n /// Marks the slots of an account and the account address as cold.\\n function cool(address target) external;\\n\\n /// Utility cheatcode to mark specific storage slot as cold, simulating no prior read.\\n function coolSlot(address target, bytes32 slot) external;\\n\\n /// Creates a new fork with the given endpoint and the _latest_ block and returns the identifier of the fork.\\n function createFork(string calldata urlOrAlias) external returns (uint256 forkId);\\n\\n /// Creates a new fork with the given endpoint and block and returns the identifier of the fork.\\n function createFork(string calldata urlOrAlias, uint256 blockNumber) external returns (uint256 forkId);\\n\\n /// Creates a new fork with the given endpoint and at the block the given transaction was mined in,\\n /// replays all transaction mined in the block before the transaction, and returns the identifier of the fork.\\n function createFork(string calldata urlOrAlias, bytes32 txHash) external returns (uint256 forkId);\\n\\n /// Creates and also selects a new fork with the given endpoint and the latest block and returns the identifier of the fork.\\n function createSelectFork(string calldata urlOrAlias) external returns (uint256 forkId);\\n\\n /// Creates and also selects a new fork with the given endpoint and block and returns the identifier of the fork.\\n function createSelectFork(string calldata urlOrAlias, uint256 blockNumber) external returns (uint256 forkId);\\n\\n /// Creates and also selects new fork with the given endpoint and at the block the given transaction was mined in,\\n /// replays all transaction mined in the block before the transaction, returns the identifier of the fork.\\n function createSelectFork(string calldata urlOrAlias, bytes32 txHash) external returns (uint256 forkId);\\n\\n /// Sets an address' balance.\\n function deal(address account, uint256 newBalance) external;\\n\\n /// Removes the snapshot with the given ID created by `snapshot`.\\n /// Takes the snapshot ID to delete.\\n /// Returns `true` if the snapshot was successfully deleted.\\n /// Returns `false` if the snapshot does not exist.\\n function deleteStateSnapshot(uint256 snapshotId) external returns (bool success);\\n\\n /// Removes _all_ snapshots previously created by `snapshot`.\\n function deleteStateSnapshots() external;\\n\\n /// Sets `block.difficulty`.\\n /// Not available on EVM versions from Paris onwards. Use `prevrandao` instead.\\n /// Reverts if used on unsupported EVM versions.\\n function difficulty(uint256 newDifficulty) external;\\n\\n /// Dump a genesis JSON file's `allocs` to disk.\\n function dumpState(string calldata pathToStateJson) external;\\n\\n /// Sets an address' code.\\n function etch(address target, bytes calldata newRuntimeBytecode) external;\\n\\n /// Sets `block.basefee`.\\n function fee(uint256 newBasefee) external;\\n\\n /// Gets the blockhashes from the current transaction.\\n /// Not available on EVM versions before Cancun.\\n /// If used on unsupported EVM versions it will revert.\\n function getBlobhashes() external view returns (bytes32[] memory hashes);\\n\\n /// Returns true if the account is marked as persistent.\\n function isPersistent(address account) external view returns (bool persistent);\\n\\n /// Load a genesis JSON file's `allocs` into the in-memory EVM state.\\n function loadAllocs(string calldata pathToAllocsJson) external;\\n\\n /// Marks that the account(s) should use persistent storage across fork swaps in a multifork setup\\n /// Meaning, changes made to the state of this account will be kept when switching forks.\\n function makePersistent(address account) external;\\n\\n /// See `makePersistent(address)`.\\n function makePersistent(address account0, address account1) external;\\n\\n /// See `makePersistent(address)`.\\n function makePersistent(address account0, address account1, address account2) external;\\n\\n /// See `makePersistent(address)`.\\n function makePersistent(address[] calldata accounts) external;\\n\\n /// Reverts a call to an address with specified revert data.\\n function mockCallRevert(address callee, bytes calldata data, bytes calldata revertData) external;\\n\\n /// Reverts a call to an address with a specific `msg.value`, with specified revert data.\\n function mockCallRevert(address callee, uint256 msgValue, bytes calldata data, bytes calldata revertData)\\n external;\\n\\n /// Reverts a call to an address with specified revert data.\\n /// Overload to pass the function selector directly `token.approve.selector` instead of `abi.encodeWithSelector(token.approve.selector)`.\\n function mockCallRevert(address callee, bytes4 data, bytes calldata revertData) external;\\n\\n /// Reverts a call to an address with a specific `msg.value`, with specified revert data.\\n /// Overload to pass the function selector directly `token.approve.selector` instead of `abi.encodeWithSelector(token.approve.selector)`.\\n function mockCallRevert(address callee, uint256 msgValue, bytes4 data, bytes calldata revertData) external;\\n\\n /// Mocks a call to an address, returning specified data.\\n /// Calldata can either be strict or a partial match, e.g. if you only\\n /// pass a Solidity selector to the expected calldata, then the entire Solidity\\n /// function will be mocked.\\n function mockCall(address callee, bytes calldata data, bytes calldata returnData) external;\\n\\n /// Mocks a call to an address with a specific `msg.value`, returning specified data.\\n /// Calldata match takes precedence over `msg.value` in case of ambiguity.\\n function mockCall(address callee, uint256 msgValue, bytes calldata data, bytes calldata returnData) external;\\n\\n /// Mocks a call to an address, returning specified data.\\n /// Calldata can either be strict or a partial match, e.g. if you only\\n /// pass a Solidity selector to the expected calldata, then the entire Solidity\\n /// function will be mocked.\\n /// Overload to pass the function selector directly `token.approve.selector` instead of `abi.encodeWithSelector(token.approve.selector)`.\\n function mockCall(address callee, bytes4 data, bytes calldata returnData) external;\\n\\n /// Mocks a call to an address with a specific `msg.value`, returning specified data.\\n /// Calldata match takes precedence over `msg.value` in case of ambiguity.\\n /// Overload to pass the function selector directly `token.approve.selector` instead of `abi.encodeWithSelector(token.approve.selector)`.\\n function mockCall(address callee, uint256 msgValue, bytes4 data, bytes calldata returnData) external;\\n\\n /// Mocks multiple calls to an address, returning specified data for each call.\\n function mockCalls(address callee, bytes calldata data, bytes[] calldata returnData) external;\\n\\n /// Mocks multiple calls to an address with a specific `msg.value`, returning specified data for each call.\\n function mockCalls(address callee, uint256 msgValue, bytes calldata data, bytes[] calldata returnData) external;\\n\\n /// Whenever a call is made to `callee` with calldata `data`, this cheatcode instead calls\\n /// `target` with the same calldata. This functionality is similar to a delegate call made to\\n /// `target` contract from `callee`.\\n /// Can be used to substitute a call to a function with another implementation that captures\\n /// the primary logic of the original function but is easier to reason about.\\n /// If calldata is not a strict match then partial match by selector is attempted.\\n function mockFunction(address callee, address target, bytes calldata data) external;\\n\\n /// Utility cheatcode to remove any EIP-2930 access list set by `accessList` cheatcode.\\n function noAccessList() external;\\n\\n /// Sets the *next* call's `msg.sender` to be the input address.\\n function prank(address msgSender) external;\\n\\n /// Sets the *next* call's `msg.sender` to be the input address, and the `tx.origin` to be the second input.\\n function prank(address msgSender, address txOrigin) external;\\n\\n /// Sets the *next* delegate call's `msg.sender` to be the input address.\\n function prank(address msgSender, bool delegateCall) external;\\n\\n /// Sets the *next* delegate call's `msg.sender` to be the input address, and the `tx.origin` to be the second input.\\n function prank(address msgSender, address txOrigin, bool delegateCall) external;\\n\\n /// Sets `block.prevrandao`.\\n /// Not available on EVM versions before Paris. Use `difficulty` instead.\\n /// If used on unsupported EVM versions it will revert.\\n function prevrandao(bytes32 newPrevrandao) external;\\n\\n /// Sets `block.prevrandao`.\\n /// Not available on EVM versions before Paris. Use `difficulty` instead.\\n /// If used on unsupported EVM versions it will revert.\\n function prevrandao(uint256 newPrevrandao) external;\\n\\n /// Reads the current `msg.sender` and `tx.origin` from state and reports if there is any active caller modification.\\n function readCallers() external returns (CallerMode callerMode, address msgSender, address txOrigin);\\n\\n /// Resets the nonce of an account to 0 for EOAs and 1 for contract accounts.\\n function resetNonce(address account) external;\\n\\n /// Revert the state of the EVM to a previous snapshot\\n /// Takes the snapshot ID to revert to.\\n /// Returns `true` if the snapshot was successfully reverted.\\n /// Returns `false` if the snapshot does not exist.\\n /// **Note:** This does not automatically delete the snapshot. To delete the snapshot use `deleteStateSnapshot`.\\n function revertToState(uint256 snapshotId) external returns (bool success);\\n\\n /// Revert the state of the EVM to a previous snapshot and automatically deletes the snapshots\\n /// Takes the snapshot ID to revert to.\\n /// Returns `true` if the snapshot was successfully reverted and deleted.\\n /// Returns `false` if the snapshot does not exist.\\n function revertToStateAndDelete(uint256 snapshotId) external returns (bool success);\\n\\n /// Revokes persistent status from the address, previously added via `makePersistent`.\\n function revokePersistent(address account) external;\\n\\n /// See `revokePersistent(address)`.\\n function revokePersistent(address[] calldata accounts) external;\\n\\n /// Sets `block.height`.\\n function roll(uint256 newHeight) external;\\n\\n /// Updates the currently active fork to given block number\\n /// This is similar to `roll` but for the currently active fork.\\n function rollFork(uint256 blockNumber) external;\\n\\n /// Updates the currently active fork to given transaction. This will `rollFork` with the number\\n /// of the block the transaction was mined in and replays all transaction mined before it in the block.\\n function rollFork(bytes32 txHash) external;\\n\\n /// Updates the given fork to given block number.\\n function rollFork(uint256 forkId, uint256 blockNumber) external;\\n\\n /// Updates the given fork to block number of the given transaction and replays all transaction mined before it in the block.\\n function rollFork(uint256 forkId, bytes32 txHash) external;\\n\\n /// Takes a fork identifier created by `createFork` and sets the corresponding forked state as active.\\n function selectFork(uint256 forkId) external;\\n\\n /// Set blockhash for the current block.\\n /// It only sets the blockhash for blocks where `block.number - 256 <= number < block.number`.\\n function setBlockhash(uint256 blockNumber, bytes32 blockHash) external;\\n\\n /// Sets the nonce of an account. Must be higher than the current nonce of the account.\\n function setNonce(address account, uint64 newNonce) external;\\n\\n /// Sets the nonce of an account to an arbitrary value.\\n function setNonceUnsafe(address account, uint64 newNonce) external;\\n\\n /// Snapshot capture the gas usage of the last call by name from the callee perspective.\\n function snapshotGasLastCall(string calldata name) external returns (uint256 gasUsed);\\n\\n /// Snapshot capture the gas usage of the last call by name in a group from the callee perspective.\\n function snapshotGasLastCall(string calldata group, string calldata name) external returns (uint256 gasUsed);\\n\\n /// Snapshot the current state of the evm.\\n /// Returns the ID of the snapshot that was created.\\n /// To revert a snapshot use `revertToState`.\\n function snapshotState() external returns (uint256 snapshotId);\\n\\n /// Snapshot capture an arbitrary numerical value by name.\\n /// The group name is derived from the contract name.\\n function snapshotValue(string calldata name, uint256 value) external;\\n\\n /// Snapshot capture an arbitrary numerical value by name in a group.\\n function snapshotValue(string calldata group, string calldata name, uint256 value) external;\\n\\n /// Sets all subsequent calls' `msg.sender` to be the input address until `stopPrank` is called.\\n function startPrank(address msgSender) external;\\n\\n /// Sets all subsequent calls' `msg.sender` to be the input address until `stopPrank` is called, and the `tx.origin` to be the second input.\\n function startPrank(address msgSender, address txOrigin) external;\\n\\n /// Sets all subsequent delegate calls' `msg.sender` to be the input address until `stopPrank` is called.\\n function startPrank(address msgSender, bool delegateCall) external;\\n\\n /// Sets all subsequent delegate calls' `msg.sender` to be the input address until `stopPrank` is called, and the `tx.origin` to be the second input.\\n function startPrank(address msgSender, address txOrigin, bool delegateCall) external;\\n\\n /// Start a snapshot capture of the current gas usage by name.\\n /// The group name is derived from the contract name.\\n function startSnapshotGas(string calldata name) external;\\n\\n /// Start a snapshot capture of the current gas usage by name in a group.\\n function startSnapshotGas(string calldata group, string calldata name) external;\\n\\n /// Resets subsequent calls' `msg.sender` to be `address(this)`.\\n function stopPrank() external;\\n\\n /// Stop the snapshot capture of the current gas by latest snapshot name, capturing the gas used since the start.\\n function stopSnapshotGas() external returns (uint256 gasUsed);\\n\\n /// Stop the snapshot capture of the current gas usage by name, capturing the gas used since the start.\\n /// The group name is derived from the contract name.\\n function stopSnapshotGas(string calldata name) external returns (uint256 gasUsed);\\n\\n /// Stop the snapshot capture of the current gas usage by name in a group, capturing the gas used since the start.\\n function stopSnapshotGas(string calldata group, string calldata name) external returns (uint256 gasUsed);\\n\\n /// Stores a value to an address' storage slot.\\n function store(address target, bytes32 slot, bytes32 value) external;\\n\\n /// Fetches the given transaction from the active fork and executes it on the current state.\\n function transact(bytes32 txHash) external;\\n\\n /// Fetches the given transaction from the given fork and executes it on the current state.\\n function transact(uint256 forkId, bytes32 txHash) external;\\n\\n /// Sets `tx.gasprice`.\\n function txGasPrice(uint256 newGasPrice) external;\\n\\n /// Utility cheatcode to mark specific storage slot as warm, simulating a prior read.\\n function warmSlot(address target, bytes32 slot) external;\\n\\n /// Sets `block.timestamp`.\\n function warp(uint256 newTimestamp) external;\\n\\n /// `deleteSnapshot` is being deprecated in favor of `deleteStateSnapshot`. It will be removed in future versions.\\n function deleteSnapshot(uint256 snapshotId) external returns (bool success);\\n\\n /// `deleteSnapshots` is being deprecated in favor of `deleteStateSnapshots`. It will be removed in future versions.\\n function deleteSnapshots() external;\\n\\n /// `revertToAndDelete` is being deprecated in favor of `revertToStateAndDelete`. It will be removed in future versions.\\n function revertToAndDelete(uint256 snapshotId) external returns (bool success);\\n\\n /// `revertTo` is being deprecated in favor of `revertToState`. It will be removed in future versions.\\n function revertTo(uint256 snapshotId) external returns (bool success);\\n\\n /// `snapshot` is being deprecated in favor of `snapshotState`. It will be removed in future versions.\\n function snapshot() external returns (uint256 snapshotId);\\n\\n // ======== Testing ========\\n\\n /// Expect a call to an address with the specified `msg.value` and calldata, and a *minimum* amount of gas.\\n function expectCallMinGas(address callee, uint256 msgValue, uint64 minGas, bytes calldata data) external;\\n\\n /// Expect given number of calls to an address with the specified `msg.value` and calldata, and a *minimum* amount of gas.\\n function expectCallMinGas(address callee, uint256 msgValue, uint64 minGas, bytes calldata data, uint64 count)\\n external;\\n\\n /// Expects a call to an address with the specified calldata.\\n /// Calldata can either be a strict or a partial match.\\n function expectCall(address callee, bytes calldata data) external;\\n\\n /// Expects given number of calls to an address with the specified calldata.\\n function expectCall(address callee, bytes calldata data, uint64 count) external;\\n\\n /// Expects a call to an address with the specified `msg.value` and calldata.\\n function expectCall(address callee, uint256 msgValue, bytes calldata data) external;\\n\\n /// Expects given number of calls to an address with the specified `msg.value` and calldata.\\n function expectCall(address callee, uint256 msgValue, bytes calldata data, uint64 count) external;\\n\\n /// Expect a call to an address with the specified `msg.value`, gas, and calldata.\\n function expectCall(address callee, uint256 msgValue, uint64 gas, bytes calldata data) external;\\n\\n /// Expects given number of calls to an address with the specified `msg.value`, gas, and calldata.\\n function expectCall(address callee, uint256 msgValue, uint64 gas, bytes calldata data, uint64 count) external;\\n\\n /// Expects the deployment of the specified bytecode by the specified address using the CREATE opcode\\n function expectCreate(bytes calldata bytecode, address deployer) external;\\n\\n /// Expects the deployment of the specified bytecode by the specified address using the CREATE2 opcode\\n function expectCreate2(bytes calldata bytecode, address deployer) external;\\n\\n /// Prepare an expected anonymous log with (bool checkTopic1, bool checkTopic2, bool checkTopic3, bool checkData.).\\n /// Call this function, then emit an anonymous event, then call a function. Internally after the call, we check if\\n /// logs were emitted in the expected order with the expected topics and data (as specified by the booleans).\\n function expectEmitAnonymous(bool checkTopic0, bool checkTopic1, bool checkTopic2, bool checkTopic3, bool checkData)\\n external;\\n\\n /// Same as the previous method, but also checks supplied address against emitting contract.\\n function expectEmitAnonymous(\\n bool checkTopic0,\\n bool checkTopic1,\\n bool checkTopic2,\\n bool checkTopic3,\\n bool checkData,\\n address emitter\\n ) external;\\n\\n /// Prepare an expected anonymous log with all topic and data checks enabled.\\n /// Call this function, then emit an anonymous event, then call a function. Internally after the call, we check if\\n /// logs were emitted in the expected order with the expected topics and data.\\n function expectEmitAnonymous() external;\\n\\n /// Same as the previous method, but also checks supplied address against emitting contract.\\n function expectEmitAnonymous(address emitter) external;\\n\\n /// Prepare an expected log with (bool checkTopic1, bool checkTopic2, bool checkTopic3, bool checkData.).\\n /// Call this function, then emit an event, then call a function. Internally after the call, we check if\\n /// logs were emitted in the expected order with the expected topics and data (as specified by the booleans).\\n function expectEmit(bool checkTopic1, bool checkTopic2, bool checkTopic3, bool checkData) external;\\n\\n /// Same as the previous method, but also checks supplied address against emitting contract.\\n function expectEmit(bool checkTopic1, bool checkTopic2, bool checkTopic3, bool checkData, address emitter)\\n external;\\n\\n /// Prepare an expected log with all topic and data checks enabled.\\n /// Call this function, then emit an event, then call a function. Internally after the call, we check if\\n /// logs were emitted in the expected order with the expected topics and data.\\n function expectEmit() external;\\n\\n /// Same as the previous method, but also checks supplied address against emitting contract.\\n function expectEmit(address emitter) external;\\n\\n /// Expect a given number of logs with the provided topics.\\n function expectEmit(bool checkTopic1, bool checkTopic2, bool checkTopic3, bool checkData, uint64 count) external;\\n\\n /// Expect a given number of logs from a specific emitter with the provided topics.\\n function expectEmit(\\n bool checkTopic1,\\n bool checkTopic2,\\n bool checkTopic3,\\n bool checkData,\\n address emitter,\\n uint64 count\\n ) external;\\n\\n /// Expect a given number of logs with all topic and data checks enabled.\\n function expectEmit(uint64 count) external;\\n\\n /// Expect a given number of logs from a specific emitter with all topic and data checks enabled.\\n function expectEmit(address emitter, uint64 count) external;\\n\\n /// Expects an error on next call that starts with the revert data.\\n function expectPartialRevert(bytes4 revertData) external;\\n\\n /// Expects an error on next call to reverter address, that starts with the revert data.\\n function expectPartialRevert(bytes4 revertData, address reverter) external;\\n\\n /// Expects an error on next call with any revert data.\\n function expectRevert() external;\\n\\n /// Expects an error on next call that exactly matches the revert data.\\n function expectRevert(bytes4 revertData) external;\\n\\n /// Expects a `count` number of reverts from the upcoming calls from the reverter address that match the revert data.\\n function expectRevert(bytes4 revertData, address reverter, uint64 count) external;\\n\\n /// Expects a `count` number of reverts from the upcoming calls from the reverter address that exactly match the revert data.\\n function expectRevert(bytes calldata revertData, address reverter, uint64 count) external;\\n\\n /// Expects an error on next call that exactly matches the revert data.\\n function expectRevert(bytes calldata revertData) external;\\n\\n /// Expects an error with any revert data on next call to reverter address.\\n function expectRevert(address reverter) external;\\n\\n /// Expects an error from reverter address on next call, with any revert data.\\n function expectRevert(bytes4 revertData, address reverter) external;\\n\\n /// Expects an error from reverter address on next call, that exactly matches the revert data.\\n function expectRevert(bytes calldata revertData, address reverter) external;\\n\\n /// Expects a `count` number of reverts from the upcoming calls with any revert data or reverter.\\n function expectRevert(uint64 count) external;\\n\\n /// Expects a `count` number of reverts from the upcoming calls that match the revert data.\\n function expectRevert(bytes4 revertData, uint64 count) external;\\n\\n /// Expects a `count` number of reverts from the upcoming calls that exactly match the revert data.\\n function expectRevert(bytes calldata revertData, uint64 count) external;\\n\\n /// Expects a `count` number of reverts from the upcoming calls from the reverter address.\\n function expectRevert(address reverter, uint64 count) external;\\n\\n /// Only allows memory writes to offsets [0x00, 0x60) \\u222a [min, max) in the current subcontext. If any other\\n /// memory is written to, the test will fail. Can be called multiple times to add more ranges to the set.\\n function expectSafeMemory(uint64 min, uint64 max) external;\\n\\n /// Only allows memory writes to offsets [0x00, 0x60) \\u222a [min, max) in the next created subcontext.\\n /// If any other memory is written to, the test will fail. Can be called multiple times to add more ranges\\n /// to the set.\\n function expectSafeMemoryCall(uint64 min, uint64 max) external;\\n\\n /// Marks a test as skipped. Must be called at the top level of a test.\\n function skip(bool skipTest) external;\\n\\n /// Marks a test as skipped with a reason. Must be called at the top level of a test.\\n function skip(bool skipTest, string calldata reason) external;\\n\\n /// Stops all safe memory expectation in the current subcontext.\\n function stopExpectSafeMemory() external;\\n}\\n\",\"keccak256\":\"0xd91fb0df409fbd22463e937b48b9682d9333c5d4528d8fe7b36102a0323c44bf\",\"license\":\"MIT OR Apache-2.0\"},\"lib/forge-std/src/console.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity >=0.4.22 <0.9.0;\\n\\nlibrary console {\\n address constant CONSOLE_ADDRESS =\\n 0x000000000000000000636F6e736F6c652e6c6f67;\\n\\n function _sendLogPayloadImplementation(bytes memory payload) internal view {\\n address consoleAddress = CONSOLE_ADDRESS;\\n /// @solidity memory-safe-assembly\\n assembly {\\n pop(\\n staticcall(\\n gas(),\\n consoleAddress,\\n add(payload, 32),\\n mload(payload),\\n 0,\\n 0\\n )\\n )\\n }\\n }\\n\\n function _castToPure(\\n function(bytes memory) internal view fnIn\\n ) internal pure returns (function(bytes memory) pure fnOut) {\\n assembly {\\n fnOut := fnIn\\n }\\n }\\n\\n function _sendLogPayload(bytes memory payload) internal pure {\\n _castToPure(_sendLogPayloadImplementation)(payload);\\n }\\n\\n function log() internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log()\\\"));\\n }\\n\\n function logInt(int256 p0) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(int256)\\\", p0));\\n }\\n\\n function logUint(uint256 p0) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256)\\\", p0));\\n }\\n\\n function logString(string memory p0) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string)\\\", p0));\\n }\\n\\n function logBool(bool p0) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool)\\\", p0));\\n }\\n\\n function logAddress(address p0) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address)\\\", p0));\\n }\\n\\n function logBytes(bytes memory p0) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bytes)\\\", p0));\\n }\\n\\n function logBytes1(bytes1 p0) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bytes1)\\\", p0));\\n }\\n\\n function logBytes2(bytes2 p0) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bytes2)\\\", p0));\\n }\\n\\n function logBytes3(bytes3 p0) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bytes3)\\\", p0));\\n }\\n\\n function logBytes4(bytes4 p0) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bytes4)\\\", p0));\\n }\\n\\n function logBytes5(bytes5 p0) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bytes5)\\\", p0));\\n }\\n\\n function logBytes6(bytes6 p0) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bytes6)\\\", p0));\\n }\\n\\n function logBytes7(bytes7 p0) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bytes7)\\\", p0));\\n }\\n\\n function logBytes8(bytes8 p0) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bytes8)\\\", p0));\\n }\\n\\n function logBytes9(bytes9 p0) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bytes9)\\\", p0));\\n }\\n\\n function logBytes10(bytes10 p0) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bytes10)\\\", p0));\\n }\\n\\n function logBytes11(bytes11 p0) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bytes11)\\\", p0));\\n }\\n\\n function logBytes12(bytes12 p0) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bytes12)\\\", p0));\\n }\\n\\n function logBytes13(bytes13 p0) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bytes13)\\\", p0));\\n }\\n\\n function logBytes14(bytes14 p0) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bytes14)\\\", p0));\\n }\\n\\n function logBytes15(bytes15 p0) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bytes15)\\\", p0));\\n }\\n\\n function logBytes16(bytes16 p0) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bytes16)\\\", p0));\\n }\\n\\n function logBytes17(bytes17 p0) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bytes17)\\\", p0));\\n }\\n\\n function logBytes18(bytes18 p0) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bytes18)\\\", p0));\\n }\\n\\n function logBytes19(bytes19 p0) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bytes19)\\\", p0));\\n }\\n\\n function logBytes20(bytes20 p0) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bytes20)\\\", p0));\\n }\\n\\n function logBytes21(bytes21 p0) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bytes21)\\\", p0));\\n }\\n\\n function logBytes22(bytes22 p0) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bytes22)\\\", p0));\\n }\\n\\n function logBytes23(bytes23 p0) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bytes23)\\\", p0));\\n }\\n\\n function logBytes24(bytes24 p0) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bytes24)\\\", p0));\\n }\\n\\n function logBytes25(bytes25 p0) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bytes25)\\\", p0));\\n }\\n\\n function logBytes26(bytes26 p0) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bytes26)\\\", p0));\\n }\\n\\n function logBytes27(bytes27 p0) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bytes27)\\\", p0));\\n }\\n\\n function logBytes28(bytes28 p0) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bytes28)\\\", p0));\\n }\\n\\n function logBytes29(bytes29 p0) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bytes29)\\\", p0));\\n }\\n\\n function logBytes30(bytes30 p0) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bytes30)\\\", p0));\\n }\\n\\n function logBytes31(bytes31 p0) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bytes31)\\\", p0));\\n }\\n\\n function logBytes32(bytes32 p0) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bytes32)\\\", p0));\\n }\\n\\n function log(uint256 p0) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256)\\\", p0));\\n }\\n\\n function log(int256 p0) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(int256)\\\", p0));\\n }\\n\\n function log(string memory p0) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string)\\\", p0));\\n }\\n\\n function log(bool p0) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool)\\\", p0));\\n }\\n\\n function log(address p0) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address)\\\", p0));\\n }\\n\\n function log(uint256 p0, uint256 p1) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,uint256)\\\", p0, p1));\\n }\\n\\n function log(uint256 p0, string memory p1) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,string)\\\", p0, p1));\\n }\\n\\n function log(uint256 p0, bool p1) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,bool)\\\", p0, p1));\\n }\\n\\n function log(uint256 p0, address p1) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,address)\\\", p0, p1));\\n }\\n\\n function log(string memory p0, uint256 p1) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,uint256)\\\", p0, p1));\\n }\\n\\n function log(string memory p0, int256 p1) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,int256)\\\", p0, p1));\\n }\\n\\n function log(string memory p0, string memory p1) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,string)\\\", p0, p1));\\n }\\n\\n function log(string memory p0, bool p1) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,bool)\\\", p0, p1));\\n }\\n\\n function log(string memory p0, address p1) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,address)\\\", p0, p1));\\n }\\n\\n function log(bool p0, uint256 p1) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,uint256)\\\", p0, p1));\\n }\\n\\n function log(bool p0, string memory p1) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,string)\\\", p0, p1));\\n }\\n\\n function log(bool p0, bool p1) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,bool)\\\", p0, p1));\\n }\\n\\n function log(bool p0, address p1) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,address)\\\", p0, p1));\\n }\\n\\n function log(address p0, uint256 p1) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,uint256)\\\", p0, p1));\\n }\\n\\n function log(address p0, string memory p1) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,string)\\\", p0, p1));\\n }\\n\\n function log(address p0, bool p1) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,bool)\\\", p0, p1));\\n }\\n\\n function log(address p0, address p1) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,address)\\\", p0, p1));\\n }\\n\\n function log(uint256 p0, uint256 p1, uint256 p2) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,uint256,uint256)\\\", p0, p1, p2));\\n }\\n\\n function log(uint256 p0, uint256 p1, string memory p2) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,uint256,string)\\\", p0, p1, p2));\\n }\\n\\n function log(uint256 p0, uint256 p1, bool p2) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,uint256,bool)\\\", p0, p1, p2));\\n }\\n\\n function log(uint256 p0, uint256 p1, address p2) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,uint256,address)\\\", p0, p1, p2));\\n }\\n\\n function log(uint256 p0, string memory p1, uint256 p2) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,string,uint256)\\\", p0, p1, p2));\\n }\\n\\n function log(uint256 p0, string memory p1, string memory p2) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,string,string)\\\", p0, p1, p2));\\n }\\n\\n function log(uint256 p0, string memory p1, bool p2) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,string,bool)\\\", p0, p1, p2));\\n }\\n\\n function log(uint256 p0, string memory p1, address p2) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,string,address)\\\", p0, p1, p2));\\n }\\n\\n function log(uint256 p0, bool p1, uint256 p2) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,bool,uint256)\\\", p0, p1, p2));\\n }\\n\\n function log(uint256 p0, bool p1, string memory p2) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,bool,string)\\\", p0, p1, p2));\\n }\\n\\n function log(uint256 p0, bool p1, bool p2) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,bool,bool)\\\", p0, p1, p2));\\n }\\n\\n function log(uint256 p0, bool p1, address p2) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,bool,address)\\\", p0, p1, p2));\\n }\\n\\n function log(uint256 p0, address p1, uint256 p2) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,address,uint256)\\\", p0, p1, p2));\\n }\\n\\n function log(uint256 p0, address p1, string memory p2) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,address,string)\\\", p0, p1, p2));\\n }\\n\\n function log(uint256 p0, address p1, bool p2) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,address,bool)\\\", p0, p1, p2));\\n }\\n\\n function log(uint256 p0, address p1, address p2) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,address,address)\\\", p0, p1, p2));\\n }\\n\\n function log(string memory p0, uint256 p1, uint256 p2) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,uint256,uint256)\\\", p0, p1, p2));\\n }\\n\\n function log(string memory p0, uint256 p1, string memory p2) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,uint256,string)\\\", p0, p1, p2));\\n }\\n\\n function log(string memory p0, uint256 p1, bool p2) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,uint256,bool)\\\", p0, p1, p2));\\n }\\n\\n function log(string memory p0, uint256 p1, address p2) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,uint256,address)\\\", p0, p1, p2));\\n }\\n\\n function log(string memory p0, string memory p1, uint256 p2) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,string,uint256)\\\", p0, p1, p2));\\n }\\n\\n function log(string memory p0, string memory p1, string memory p2) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,string,string)\\\", p0, p1, p2));\\n }\\n\\n function log(string memory p0, string memory p1, bool p2) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,string,bool)\\\", p0, p1, p2));\\n }\\n\\n function log(string memory p0, string memory p1, address p2) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,string,address)\\\", p0, p1, p2));\\n }\\n\\n function log(string memory p0, bool p1, uint256 p2) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,bool,uint256)\\\", p0, p1, p2));\\n }\\n\\n function log(string memory p0, bool p1, string memory p2) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,bool,string)\\\", p0, p1, p2));\\n }\\n\\n function log(string memory p0, bool p1, bool p2) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,bool,bool)\\\", p0, p1, p2));\\n }\\n\\n function log(string memory p0, bool p1, address p2) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,bool,address)\\\", p0, p1, p2));\\n }\\n\\n function log(string memory p0, address p1, uint256 p2) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,address,uint256)\\\", p0, p1, p2));\\n }\\n\\n function log(string memory p0, address p1, string memory p2) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,address,string)\\\", p0, p1, p2));\\n }\\n\\n function log(string memory p0, address p1, bool p2) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,address,bool)\\\", p0, p1, p2));\\n }\\n\\n function log(string memory p0, address p1, address p2) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,address,address)\\\", p0, p1, p2));\\n }\\n\\n function log(bool p0, uint256 p1, uint256 p2) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,uint256,uint256)\\\", p0, p1, p2));\\n }\\n\\n function log(bool p0, uint256 p1, string memory p2) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,uint256,string)\\\", p0, p1, p2));\\n }\\n\\n function log(bool p0, uint256 p1, bool p2) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,uint256,bool)\\\", p0, p1, p2));\\n }\\n\\n function log(bool p0, uint256 p1, address p2) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,uint256,address)\\\", p0, p1, p2));\\n }\\n\\n function log(bool p0, string memory p1, uint256 p2) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,string,uint256)\\\", p0, p1, p2));\\n }\\n\\n function log(bool p0, string memory p1, string memory p2) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,string,string)\\\", p0, p1, p2));\\n }\\n\\n function log(bool p0, string memory p1, bool p2) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,string,bool)\\\", p0, p1, p2));\\n }\\n\\n function log(bool p0, string memory p1, address p2) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,string,address)\\\", p0, p1, p2));\\n }\\n\\n function log(bool p0, bool p1, uint256 p2) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,bool,uint256)\\\", p0, p1, p2));\\n }\\n\\n function log(bool p0, bool p1, string memory p2) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,bool,string)\\\", p0, p1, p2));\\n }\\n\\n function log(bool p0, bool p1, bool p2) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,bool,bool)\\\", p0, p1, p2));\\n }\\n\\n function log(bool p0, bool p1, address p2) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,bool,address)\\\", p0, p1, p2));\\n }\\n\\n function log(bool p0, address p1, uint256 p2) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,address,uint256)\\\", p0, p1, p2));\\n }\\n\\n function log(bool p0, address p1, string memory p2) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,address,string)\\\", p0, p1, p2));\\n }\\n\\n function log(bool p0, address p1, bool p2) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,address,bool)\\\", p0, p1, p2));\\n }\\n\\n function log(bool p0, address p1, address p2) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,address,address)\\\", p0, p1, p2));\\n }\\n\\n function log(address p0, uint256 p1, uint256 p2) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,uint256,uint256)\\\", p0, p1, p2));\\n }\\n\\n function log(address p0, uint256 p1, string memory p2) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,uint256,string)\\\", p0, p1, p2));\\n }\\n\\n function log(address p0, uint256 p1, bool p2) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,uint256,bool)\\\", p0, p1, p2));\\n }\\n\\n function log(address p0, uint256 p1, address p2) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,uint256,address)\\\", p0, p1, p2));\\n }\\n\\n function log(address p0, string memory p1, uint256 p2) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,string,uint256)\\\", p0, p1, p2));\\n }\\n\\n function log(address p0, string memory p1, string memory p2) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,string,string)\\\", p0, p1, p2));\\n }\\n\\n function log(address p0, string memory p1, bool p2) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,string,bool)\\\", p0, p1, p2));\\n }\\n\\n function log(address p0, string memory p1, address p2) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,string,address)\\\", p0, p1, p2));\\n }\\n\\n function log(address p0, bool p1, uint256 p2) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,bool,uint256)\\\", p0, p1, p2));\\n }\\n\\n function log(address p0, bool p1, string memory p2) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,bool,string)\\\", p0, p1, p2));\\n }\\n\\n function log(address p0, bool p1, bool p2) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,bool,bool)\\\", p0, p1, p2));\\n }\\n\\n function log(address p0, bool p1, address p2) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,bool,address)\\\", p0, p1, p2));\\n }\\n\\n function log(address p0, address p1, uint256 p2) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,address,uint256)\\\", p0, p1, p2));\\n }\\n\\n function log(address p0, address p1, string memory p2) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,address,string)\\\", p0, p1, p2));\\n }\\n\\n function log(address p0, address p1, bool p2) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,address,bool)\\\", p0, p1, p2));\\n }\\n\\n function log(address p0, address p1, address p2) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,address,address)\\\", p0, p1, p2));\\n }\\n\\n function log(uint256 p0, uint256 p1, uint256 p2, uint256 p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,uint256,uint256,uint256)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(uint256 p0, uint256 p1, uint256 p2, string memory p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,uint256,uint256,string)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(uint256 p0, uint256 p1, uint256 p2, bool p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,uint256,uint256,bool)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(uint256 p0, uint256 p1, uint256 p2, address p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,uint256,uint256,address)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(uint256 p0, uint256 p1, string memory p2, uint256 p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,uint256,string,uint256)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(uint256 p0, uint256 p1, string memory p2, string memory p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,uint256,string,string)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(uint256 p0, uint256 p1, string memory p2, bool p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,uint256,string,bool)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(uint256 p0, uint256 p1, string memory p2, address p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,uint256,string,address)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(uint256 p0, uint256 p1, bool p2, uint256 p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,uint256,bool,uint256)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(uint256 p0, uint256 p1, bool p2, string memory p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,uint256,bool,string)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(uint256 p0, uint256 p1, bool p2, bool p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,uint256,bool,bool)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(uint256 p0, uint256 p1, bool p2, address p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,uint256,bool,address)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(uint256 p0, uint256 p1, address p2, uint256 p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,uint256,address,uint256)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(uint256 p0, uint256 p1, address p2, string memory p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,uint256,address,string)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(uint256 p0, uint256 p1, address p2, bool p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,uint256,address,bool)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(uint256 p0, uint256 p1, address p2, address p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,uint256,address,address)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(uint256 p0, string memory p1, uint256 p2, uint256 p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,string,uint256,uint256)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(uint256 p0, string memory p1, uint256 p2, string memory p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,string,uint256,string)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(uint256 p0, string memory p1, uint256 p2, bool p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,string,uint256,bool)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(uint256 p0, string memory p1, uint256 p2, address p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,string,uint256,address)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(uint256 p0, string memory p1, string memory p2, uint256 p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,string,string,uint256)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(uint256 p0, string memory p1, string memory p2, string memory p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,string,string,string)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(uint256 p0, string memory p1, string memory p2, bool p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,string,string,bool)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(uint256 p0, string memory p1, string memory p2, address p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,string,string,address)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(uint256 p0, string memory p1, bool p2, uint256 p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,string,bool,uint256)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(uint256 p0, string memory p1, bool p2, string memory p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,string,bool,string)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(uint256 p0, string memory p1, bool p2, bool p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,string,bool,bool)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(uint256 p0, string memory p1, bool p2, address p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,string,bool,address)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(uint256 p0, string memory p1, address p2, uint256 p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,string,address,uint256)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(uint256 p0, string memory p1, address p2, string memory p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,string,address,string)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(uint256 p0, string memory p1, address p2, bool p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,string,address,bool)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(uint256 p0, string memory p1, address p2, address p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,string,address,address)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(uint256 p0, bool p1, uint256 p2, uint256 p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,bool,uint256,uint256)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(uint256 p0, bool p1, uint256 p2, string memory p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,bool,uint256,string)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(uint256 p0, bool p1, uint256 p2, bool p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,bool,uint256,bool)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(uint256 p0, bool p1, uint256 p2, address p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,bool,uint256,address)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(uint256 p0, bool p1, string memory p2, uint256 p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,bool,string,uint256)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(uint256 p0, bool p1, string memory p2, string memory p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,bool,string,string)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(uint256 p0, bool p1, string memory p2, bool p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,bool,string,bool)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(uint256 p0, bool p1, string memory p2, address p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,bool,string,address)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(uint256 p0, bool p1, bool p2, uint256 p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,bool,bool,uint256)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(uint256 p0, bool p1, bool p2, string memory p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,bool,bool,string)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(uint256 p0, bool p1, bool p2, bool p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,bool,bool,bool)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(uint256 p0, bool p1, bool p2, address p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,bool,bool,address)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(uint256 p0, bool p1, address p2, uint256 p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,bool,address,uint256)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(uint256 p0, bool p1, address p2, string memory p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,bool,address,string)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(uint256 p0, bool p1, address p2, bool p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,bool,address,bool)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(uint256 p0, bool p1, address p2, address p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,bool,address,address)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(uint256 p0, address p1, uint256 p2, uint256 p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,address,uint256,uint256)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(uint256 p0, address p1, uint256 p2, string memory p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,address,uint256,string)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(uint256 p0, address p1, uint256 p2, bool p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,address,uint256,bool)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(uint256 p0, address p1, uint256 p2, address p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,address,uint256,address)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(uint256 p0, address p1, string memory p2, uint256 p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,address,string,uint256)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(uint256 p0, address p1, string memory p2, string memory p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,address,string,string)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(uint256 p0, address p1, string memory p2, bool p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,address,string,bool)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(uint256 p0, address p1, string memory p2, address p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,address,string,address)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(uint256 p0, address p1, bool p2, uint256 p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,address,bool,uint256)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(uint256 p0, address p1, bool p2, string memory p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,address,bool,string)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(uint256 p0, address p1, bool p2, bool p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,address,bool,bool)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(uint256 p0, address p1, bool p2, address p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,address,bool,address)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(uint256 p0, address p1, address p2, uint256 p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,address,address,uint256)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(uint256 p0, address p1, address p2, string memory p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,address,address,string)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(uint256 p0, address p1, address p2, bool p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,address,address,bool)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(uint256 p0, address p1, address p2, address p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,address,address,address)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(string memory p0, uint256 p1, uint256 p2, uint256 p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,uint256,uint256,uint256)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(string memory p0, uint256 p1, uint256 p2, string memory p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,uint256,uint256,string)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(string memory p0, uint256 p1, uint256 p2, bool p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,uint256,uint256,bool)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(string memory p0, uint256 p1, uint256 p2, address p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,uint256,uint256,address)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(string memory p0, uint256 p1, string memory p2, uint256 p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,uint256,string,uint256)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(string memory p0, uint256 p1, string memory p2, string memory p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,uint256,string,string)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(string memory p0, uint256 p1, string memory p2, bool p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,uint256,string,bool)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(string memory p0, uint256 p1, string memory p2, address p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,uint256,string,address)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(string memory p0, uint256 p1, bool p2, uint256 p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,uint256,bool,uint256)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(string memory p0, uint256 p1, bool p2, string memory p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,uint256,bool,string)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(string memory p0, uint256 p1, bool p2, bool p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,uint256,bool,bool)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(string memory p0, uint256 p1, bool p2, address p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,uint256,bool,address)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(string memory p0, uint256 p1, address p2, uint256 p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,uint256,address,uint256)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(string memory p0, uint256 p1, address p2, string memory p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,uint256,address,string)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(string memory p0, uint256 p1, address p2, bool p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,uint256,address,bool)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(string memory p0, uint256 p1, address p2, address p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,uint256,address,address)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(string memory p0, string memory p1, uint256 p2, uint256 p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,string,uint256,uint256)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(string memory p0, string memory p1, uint256 p2, string memory p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,string,uint256,string)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(string memory p0, string memory p1, uint256 p2, bool p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,string,uint256,bool)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(string memory p0, string memory p1, uint256 p2, address p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,string,uint256,address)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(string memory p0, string memory p1, string memory p2, uint256 p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,string,string,uint256)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(string memory p0, string memory p1, string memory p2, string memory p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,string,string,string)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(string memory p0, string memory p1, string memory p2, bool p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,string,string,bool)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(string memory p0, string memory p1, string memory p2, address p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,string,string,address)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(string memory p0, string memory p1, bool p2, uint256 p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,string,bool,uint256)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(string memory p0, string memory p1, bool p2, string memory p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,string,bool,string)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(string memory p0, string memory p1, bool p2, bool p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,string,bool,bool)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(string memory p0, string memory p1, bool p2, address p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,string,bool,address)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(string memory p0, string memory p1, address p2, uint256 p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,string,address,uint256)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(string memory p0, string memory p1, address p2, string memory p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,string,address,string)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(string memory p0, string memory p1, address p2, bool p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,string,address,bool)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(string memory p0, string memory p1, address p2, address p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,string,address,address)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(string memory p0, bool p1, uint256 p2, uint256 p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,bool,uint256,uint256)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(string memory p0, bool p1, uint256 p2, string memory p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,bool,uint256,string)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(string memory p0, bool p1, uint256 p2, bool p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,bool,uint256,bool)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(string memory p0, bool p1, uint256 p2, address p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,bool,uint256,address)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(string memory p0, bool p1, string memory p2, uint256 p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,bool,string,uint256)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(string memory p0, bool p1, string memory p2, string memory p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,bool,string,string)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(string memory p0, bool p1, string memory p2, bool p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,bool,string,bool)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(string memory p0, bool p1, string memory p2, address p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,bool,string,address)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(string memory p0, bool p1, bool p2, uint256 p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,bool,bool,uint256)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(string memory p0, bool p1, bool p2, string memory p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,bool,bool,string)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(string memory p0, bool p1, bool p2, bool p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,bool,bool,bool)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(string memory p0, bool p1, bool p2, address p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,bool,bool,address)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(string memory p0, bool p1, address p2, uint256 p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,bool,address,uint256)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(string memory p0, bool p1, address p2, string memory p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,bool,address,string)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(string memory p0, bool p1, address p2, bool p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,bool,address,bool)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(string memory p0, bool p1, address p2, address p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,bool,address,address)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(string memory p0, address p1, uint256 p2, uint256 p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,address,uint256,uint256)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(string memory p0, address p1, uint256 p2, string memory p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,address,uint256,string)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(string memory p0, address p1, uint256 p2, bool p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,address,uint256,bool)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(string memory p0, address p1, uint256 p2, address p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,address,uint256,address)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(string memory p0, address p1, string memory p2, uint256 p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,address,string,uint256)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(string memory p0, address p1, string memory p2, string memory p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,address,string,string)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(string memory p0, address p1, string memory p2, bool p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,address,string,bool)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(string memory p0, address p1, string memory p2, address p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,address,string,address)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(string memory p0, address p1, bool p2, uint256 p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,address,bool,uint256)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(string memory p0, address p1, bool p2, string memory p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,address,bool,string)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(string memory p0, address p1, bool p2, bool p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,address,bool,bool)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(string memory p0, address p1, bool p2, address p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,address,bool,address)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(string memory p0, address p1, address p2, uint256 p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,address,address,uint256)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(string memory p0, address p1, address p2, string memory p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,address,address,string)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(string memory p0, address p1, address p2, bool p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,address,address,bool)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(string memory p0, address p1, address p2, address p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,address,address,address)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(bool p0, uint256 p1, uint256 p2, uint256 p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,uint256,uint256,uint256)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(bool p0, uint256 p1, uint256 p2, string memory p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,uint256,uint256,string)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(bool p0, uint256 p1, uint256 p2, bool p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,uint256,uint256,bool)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(bool p0, uint256 p1, uint256 p2, address p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,uint256,uint256,address)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(bool p0, uint256 p1, string memory p2, uint256 p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,uint256,string,uint256)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(bool p0, uint256 p1, string memory p2, string memory p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,uint256,string,string)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(bool p0, uint256 p1, string memory p2, bool p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,uint256,string,bool)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(bool p0, uint256 p1, string memory p2, address p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,uint256,string,address)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(bool p0, uint256 p1, bool p2, uint256 p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,uint256,bool,uint256)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(bool p0, uint256 p1, bool p2, string memory p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,uint256,bool,string)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(bool p0, uint256 p1, bool p2, bool p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,uint256,bool,bool)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(bool p0, uint256 p1, bool p2, address p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,uint256,bool,address)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(bool p0, uint256 p1, address p2, uint256 p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,uint256,address,uint256)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(bool p0, uint256 p1, address p2, string memory p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,uint256,address,string)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(bool p0, uint256 p1, address p2, bool p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,uint256,address,bool)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(bool p0, uint256 p1, address p2, address p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,uint256,address,address)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(bool p0, string memory p1, uint256 p2, uint256 p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,string,uint256,uint256)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(bool p0, string memory p1, uint256 p2, string memory p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,string,uint256,string)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(bool p0, string memory p1, uint256 p2, bool p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,string,uint256,bool)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(bool p0, string memory p1, uint256 p2, address p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,string,uint256,address)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(bool p0, string memory p1, string memory p2, uint256 p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,string,string,uint256)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(bool p0, string memory p1, string memory p2, string memory p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,string,string,string)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(bool p0, string memory p1, string memory p2, bool p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,string,string,bool)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(bool p0, string memory p1, string memory p2, address p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,string,string,address)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(bool p0, string memory p1, bool p2, uint256 p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,string,bool,uint256)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(bool p0, string memory p1, bool p2, string memory p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,string,bool,string)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(bool p0, string memory p1, bool p2, bool p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,string,bool,bool)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(bool p0, string memory p1, bool p2, address p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,string,bool,address)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(bool p0, string memory p1, address p2, uint256 p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,string,address,uint256)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(bool p0, string memory p1, address p2, string memory p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,string,address,string)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(bool p0, string memory p1, address p2, bool p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,string,address,bool)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(bool p0, string memory p1, address p2, address p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,string,address,address)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(bool p0, bool p1, uint256 p2, uint256 p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,bool,uint256,uint256)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(bool p0, bool p1, uint256 p2, string memory p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,bool,uint256,string)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(bool p0, bool p1, uint256 p2, bool p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,bool,uint256,bool)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(bool p0, bool p1, uint256 p2, address p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,bool,uint256,address)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(bool p0, bool p1, string memory p2, uint256 p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,bool,string,uint256)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(bool p0, bool p1, string memory p2, string memory p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,bool,string,string)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(bool p0, bool p1, string memory p2, bool p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,bool,string,bool)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(bool p0, bool p1, string memory p2, address p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,bool,string,address)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(bool p0, bool p1, bool p2, uint256 p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,bool,bool,uint256)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(bool p0, bool p1, bool p2, string memory p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,bool,bool,string)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(bool p0, bool p1, bool p2, bool p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,bool,bool,bool)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(bool p0, bool p1, bool p2, address p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,bool,bool,address)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(bool p0, bool p1, address p2, uint256 p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,bool,address,uint256)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(bool p0, bool p1, address p2, string memory p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,bool,address,string)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(bool p0, bool p1, address p2, bool p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,bool,address,bool)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(bool p0, bool p1, address p2, address p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,bool,address,address)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(bool p0, address p1, uint256 p2, uint256 p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,address,uint256,uint256)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(bool p0, address p1, uint256 p2, string memory p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,address,uint256,string)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(bool p0, address p1, uint256 p2, bool p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,address,uint256,bool)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(bool p0, address p1, uint256 p2, address p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,address,uint256,address)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(bool p0, address p1, string memory p2, uint256 p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,address,string,uint256)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(bool p0, address p1, string memory p2, string memory p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,address,string,string)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(bool p0, address p1, string memory p2, bool p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,address,string,bool)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(bool p0, address p1, string memory p2, address p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,address,string,address)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(bool p0, address p1, bool p2, uint256 p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,address,bool,uint256)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(bool p0, address p1, bool p2, string memory p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,address,bool,string)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(bool p0, address p1, bool p2, bool p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,address,bool,bool)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(bool p0, address p1, bool p2, address p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,address,bool,address)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(bool p0, address p1, address p2, uint256 p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,address,address,uint256)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(bool p0, address p1, address p2, string memory p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,address,address,string)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(bool p0, address p1, address p2, bool p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,address,address,bool)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(bool p0, address p1, address p2, address p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,address,address,address)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(address p0, uint256 p1, uint256 p2, uint256 p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,uint256,uint256,uint256)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(address p0, uint256 p1, uint256 p2, string memory p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,uint256,uint256,string)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(address p0, uint256 p1, uint256 p2, bool p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,uint256,uint256,bool)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(address p0, uint256 p1, uint256 p2, address p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,uint256,uint256,address)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(address p0, uint256 p1, string memory p2, uint256 p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,uint256,string,uint256)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(address p0, uint256 p1, string memory p2, string memory p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,uint256,string,string)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(address p0, uint256 p1, string memory p2, bool p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,uint256,string,bool)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(address p0, uint256 p1, string memory p2, address p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,uint256,string,address)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(address p0, uint256 p1, bool p2, uint256 p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,uint256,bool,uint256)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(address p0, uint256 p1, bool p2, string memory p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,uint256,bool,string)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(address p0, uint256 p1, bool p2, bool p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,uint256,bool,bool)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(address p0, uint256 p1, bool p2, address p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,uint256,bool,address)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(address p0, uint256 p1, address p2, uint256 p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,uint256,address,uint256)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(address p0, uint256 p1, address p2, string memory p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,uint256,address,string)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(address p0, uint256 p1, address p2, bool p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,uint256,address,bool)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(address p0, uint256 p1, address p2, address p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,uint256,address,address)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(address p0, string memory p1, uint256 p2, uint256 p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,string,uint256,uint256)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(address p0, string memory p1, uint256 p2, string memory p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,string,uint256,string)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(address p0, string memory p1, uint256 p2, bool p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,string,uint256,bool)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(address p0, string memory p1, uint256 p2, address p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,string,uint256,address)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(address p0, string memory p1, string memory p2, uint256 p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,string,string,uint256)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(address p0, string memory p1, string memory p2, string memory p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,string,string,string)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(address p0, string memory p1, string memory p2, bool p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,string,string,bool)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(address p0, string memory p1, string memory p2, address p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,string,string,address)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(address p0, string memory p1, bool p2, uint256 p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,string,bool,uint256)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(address p0, string memory p1, bool p2, string memory p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,string,bool,string)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(address p0, string memory p1, bool p2, bool p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,string,bool,bool)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(address p0, string memory p1, bool p2, address p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,string,bool,address)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(address p0, string memory p1, address p2, uint256 p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,string,address,uint256)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(address p0, string memory p1, address p2, string memory p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,string,address,string)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(address p0, string memory p1, address p2, bool p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,string,address,bool)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(address p0, string memory p1, address p2, address p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,string,address,address)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(address p0, bool p1, uint256 p2, uint256 p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,bool,uint256,uint256)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(address p0, bool p1, uint256 p2, string memory p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,bool,uint256,string)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(address p0, bool p1, uint256 p2, bool p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,bool,uint256,bool)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(address p0, bool p1, uint256 p2, address p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,bool,uint256,address)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(address p0, bool p1, string memory p2, uint256 p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,bool,string,uint256)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(address p0, bool p1, string memory p2, string memory p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,bool,string,string)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(address p0, bool p1, string memory p2, bool p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,bool,string,bool)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(address p0, bool p1, string memory p2, address p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,bool,string,address)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(address p0, bool p1, bool p2, uint256 p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,bool,bool,uint256)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(address p0, bool p1, bool p2, string memory p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,bool,bool,string)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(address p0, bool p1, bool p2, bool p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,bool,bool,bool)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(address p0, bool p1, bool p2, address p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,bool,bool,address)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(address p0, bool p1, address p2, uint256 p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,bool,address,uint256)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(address p0, bool p1, address p2, string memory p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,bool,address,string)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(address p0, bool p1, address p2, bool p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,bool,address,bool)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(address p0, bool p1, address p2, address p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,bool,address,address)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(address p0, address p1, uint256 p2, uint256 p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,address,uint256,uint256)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(address p0, address p1, uint256 p2, string memory p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,address,uint256,string)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(address p0, address p1, uint256 p2, bool p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,address,uint256,bool)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(address p0, address p1, uint256 p2, address p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,address,uint256,address)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(address p0, address p1, string memory p2, uint256 p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,address,string,uint256)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(address p0, address p1, string memory p2, string memory p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,address,string,string)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(address p0, address p1, string memory p2, bool p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,address,string,bool)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(address p0, address p1, string memory p2, address p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,address,string,address)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(address p0, address p1, bool p2, uint256 p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,address,bool,uint256)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(address p0, address p1, bool p2, string memory p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,address,bool,string)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(address p0, address p1, bool p2, bool p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,address,bool,bool)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(address p0, address p1, bool p2, address p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,address,bool,address)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(address p0, address p1, address p2, uint256 p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,address,address,uint256)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(address p0, address p1, address p2, string memory p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,address,address,string)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(address p0, address p1, address p2, bool p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,address,address,bool)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(address p0, address p1, address p2, address p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,address,address,address)\\\", p0, p1, p2, p3));\\n }\\n}\\n\",\"keccak256\":\"0x4bbf47eb762cef93729d6ef15e78789957147039b113e5d4df48e3d3fd16d0f5\",\"license\":\"MIT\"},\"lib/forge-std/src/console2.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity >=0.4.22 <0.9.0;\\n\\nimport {console as console2} from \\\"./console.sol\\\";\\n\",\"keccak256\":\"0x3b8fe79f48f065a4e4d35362171304a33784c3a90febae5f2787805a438de12f\",\"license\":\"MIT\"},\"lib/forge-std/src/interfaces/IMulticall3.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity >=0.6.2 <0.9.0;\\n\\npragma experimental ABIEncoderV2;\\n\\ninterface IMulticall3 {\\n struct Call {\\n address target;\\n bytes callData;\\n }\\n\\n struct Call3 {\\n address target;\\n bool allowFailure;\\n bytes callData;\\n }\\n\\n struct Call3Value {\\n address target;\\n bool allowFailure;\\n uint256 value;\\n bytes callData;\\n }\\n\\n struct Result {\\n bool success;\\n bytes returnData;\\n }\\n\\n function aggregate(Call[] calldata calls)\\n external\\n payable\\n returns (uint256 blockNumber, bytes[] memory returnData);\\n\\n function aggregate3(Call3[] calldata calls) external payable returns (Result[] memory returnData);\\n\\n function aggregate3Value(Call3Value[] calldata calls) external payable returns (Result[] memory returnData);\\n\\n function blockAndAggregate(Call[] calldata calls)\\n external\\n payable\\n returns (uint256 blockNumber, bytes32 blockHash, Result[] memory returnData);\\n\\n function getBasefee() external view returns (uint256 basefee);\\n\\n function getBlockHash(uint256 blockNumber) external view returns (bytes32 blockHash);\\n\\n function getBlockNumber() external view returns (uint256 blockNumber);\\n\\n function getChainId() external view returns (uint256 chainid);\\n\\n function getCurrentBlockCoinbase() external view returns (address coinbase);\\n\\n function getCurrentBlockDifficulty() external view returns (uint256 difficulty);\\n\\n function getCurrentBlockGasLimit() external view returns (uint256 gaslimit);\\n\\n function getCurrentBlockTimestamp() external view returns (uint256 timestamp);\\n\\n function getEthBalance(address addr) external view returns (uint256 balance);\\n\\n function getLastBlockHash() external view returns (bytes32 blockHash);\\n\\n function tryAggregate(bool requireSuccess, Call[] calldata calls)\\n external\\n payable\\n returns (Result[] memory returnData);\\n\\n function tryBlockAndAggregate(bool requireSuccess, Call[] calldata calls)\\n external\\n payable\\n returns (uint256 blockNumber, bytes32 blockHash, Result[] memory returnData);\\n}\\n\",\"keccak256\":\"0x7aac1389150499a922d1f9ef5749c908cef127cb2075b92fa17e9cb611263d0a\",\"license\":\"MIT\"},\"lib/forge-std/src/safeconsole.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity >=0.6.2 <0.9.0;\\n\\n/// @author philogy \\n/// @dev Code generated automatically by script.\\nlibrary safeconsole {\\n uint256 constant CONSOLE_ADDR = 0x000000000000000000000000000000000000000000636F6e736F6c652e6c6f67;\\n\\n // Credit to [0age](https://twitter.com/z0age/status/1654922202930888704) and [0xdapper](https://github.com/foundry-rs/forge-std/pull/374)\\n // for the view-to-pure log trick.\\n function _sendLogPayload(uint256 offset, uint256 size) private pure {\\n function(uint256, uint256) internal view fnIn = _sendLogPayloadView;\\n function(uint256, uint256) internal pure pureSendLogPayload;\\n /// @solidity memory-safe-assembly\\n assembly {\\n pureSendLogPayload := fnIn\\n }\\n pureSendLogPayload(offset, size);\\n }\\n\\n function _sendLogPayloadView(uint256 offset, uint256 size) private view {\\n /// @solidity memory-safe-assembly\\n assembly {\\n pop(staticcall(gas(), CONSOLE_ADDR, offset, size, 0x0, 0x0))\\n }\\n }\\n\\n function _memcopy(uint256 fromOffset, uint256 toOffset, uint256 length) private pure {\\n function(uint256, uint256, uint256) internal view fnIn = _memcopyView;\\n function(uint256, uint256, uint256) internal pure pureMemcopy;\\n /// @solidity memory-safe-assembly\\n assembly {\\n pureMemcopy := fnIn\\n }\\n pureMemcopy(fromOffset, toOffset, length);\\n }\\n\\n function _memcopyView(uint256 fromOffset, uint256 toOffset, uint256 length) private view {\\n /// @solidity memory-safe-assembly\\n assembly {\\n pop(staticcall(gas(), 0x4, fromOffset, length, toOffset, length))\\n }\\n }\\n\\n function logMemory(uint256 offset, uint256 length) internal pure {\\n if (offset >= 0x60) {\\n // Sufficient memory before slice to prepare call header.\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(sub(offset, 0x60))\\n m1 := mload(sub(offset, 0x40))\\n m2 := mload(sub(offset, 0x20))\\n // Selector of `log(bytes)`.\\n mstore(sub(offset, 0x60), 0x0be77f56)\\n mstore(sub(offset, 0x40), 0x20)\\n mstore(sub(offset, 0x20), length)\\n }\\n _sendLogPayload(offset - 0x44, length + 0x44);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(sub(offset, 0x60), m0)\\n mstore(sub(offset, 0x40), m1)\\n mstore(sub(offset, 0x20), m2)\\n }\\n } else {\\n // Insufficient space, so copy slice forward, add header and reverse.\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n uint256 endOffset = offset + length;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(add(endOffset, 0x00))\\n m1 := mload(add(endOffset, 0x20))\\n m2 := mload(add(endOffset, 0x40))\\n }\\n _memcopy(offset, offset + 0x60, length);\\n /// @solidity memory-safe-assembly\\n assembly {\\n // Selector of `log(bytes)`.\\n mstore(add(offset, 0x00), 0x0be77f56)\\n mstore(add(offset, 0x20), 0x20)\\n mstore(add(offset, 0x40), length)\\n }\\n _sendLogPayload(offset + 0x1c, length + 0x44);\\n _memcopy(offset + 0x60, offset, length);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(add(endOffset, 0x00), m0)\\n mstore(add(endOffset, 0x20), m1)\\n mstore(add(endOffset, 0x40), m2)\\n }\\n }\\n }\\n\\n function log(address p0) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n // Selector of `log(address)`.\\n mstore(0x00, 0x2c2ecbc2)\\n mstore(0x20, p0)\\n }\\n _sendLogPayload(0x1c, 0x24);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n }\\n }\\n\\n function log(bool p0) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n // Selector of `log(bool)`.\\n mstore(0x00, 0x32458eed)\\n mstore(0x20, p0)\\n }\\n _sendLogPayload(0x1c, 0x24);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n }\\n }\\n\\n function log(uint256 p0) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n // Selector of `log(uint256)`.\\n mstore(0x00, 0xf82c50f1)\\n mstore(0x20, p0)\\n }\\n _sendLogPayload(0x1c, 0x24);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n }\\n }\\n\\n function log(bytes32 p0) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n // Selector of `log(string)`.\\n mstore(0x00, 0x41304fac)\\n mstore(0x20, 0x20)\\n writeString(0x40, p0)\\n }\\n _sendLogPayload(0x1c, 0x64);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n }\\n }\\n\\n function log(address p0, address p1) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n // Selector of `log(address,address)`.\\n mstore(0x00, 0xdaf0d4aa)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n }\\n _sendLogPayload(0x1c, 0x44);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n }\\n }\\n\\n function log(address p0, bool p1) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n // Selector of `log(address,bool)`.\\n mstore(0x00, 0x75b605d3)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n }\\n _sendLogPayload(0x1c, 0x44);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n }\\n }\\n\\n function log(address p0, uint256 p1) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n // Selector of `log(address,uint256)`.\\n mstore(0x00, 0x8309e8a8)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n }\\n _sendLogPayload(0x1c, 0x44);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n }\\n }\\n\\n function log(address p0, bytes32 p1) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(address,string)`.\\n mstore(0x00, 0x759f86bb)\\n mstore(0x20, p0)\\n mstore(0x40, 0x40)\\n writeString(0x60, p1)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(bool p0, address p1) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n // Selector of `log(bool,address)`.\\n mstore(0x00, 0x853c4849)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n }\\n _sendLogPayload(0x1c, 0x44);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n }\\n }\\n\\n function log(bool p0, bool p1) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n // Selector of `log(bool,bool)`.\\n mstore(0x00, 0x2a110e83)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n }\\n _sendLogPayload(0x1c, 0x44);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n }\\n }\\n\\n function log(bool p0, uint256 p1) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n // Selector of `log(bool,uint256)`.\\n mstore(0x00, 0x399174d3)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n }\\n _sendLogPayload(0x1c, 0x44);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n }\\n }\\n\\n function log(bool p0, bytes32 p1) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(bool,string)`.\\n mstore(0x00, 0x8feac525)\\n mstore(0x20, p0)\\n mstore(0x40, 0x40)\\n writeString(0x60, p1)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(uint256 p0, address p1) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n // Selector of `log(uint256,address)`.\\n mstore(0x00, 0x69276c86)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n }\\n _sendLogPayload(0x1c, 0x44);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n }\\n }\\n\\n function log(uint256 p0, bool p1) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n // Selector of `log(uint256,bool)`.\\n mstore(0x00, 0x1c9d7eb3)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n }\\n _sendLogPayload(0x1c, 0x44);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n }\\n }\\n\\n function log(uint256 p0, uint256 p1) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n // Selector of `log(uint256,uint256)`.\\n mstore(0x00, 0xf666715a)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n }\\n _sendLogPayload(0x1c, 0x44);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n }\\n }\\n\\n function log(uint256 p0, bytes32 p1) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(uint256,string)`.\\n mstore(0x00, 0x643fd0df)\\n mstore(0x20, p0)\\n mstore(0x40, 0x40)\\n writeString(0x60, p1)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(bytes32 p0, address p1) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(string,address)`.\\n mstore(0x00, 0x319af333)\\n mstore(0x20, 0x40)\\n mstore(0x40, p1)\\n writeString(0x60, p0)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(bytes32 p0, bool p1) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(string,bool)`.\\n mstore(0x00, 0xc3b55635)\\n mstore(0x20, 0x40)\\n mstore(0x40, p1)\\n writeString(0x60, p0)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(bytes32 p0, uint256 p1) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(string,uint256)`.\\n mstore(0x00, 0xb60e72cc)\\n mstore(0x20, 0x40)\\n mstore(0x40, p1)\\n writeString(0x60, p0)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(bytes32 p0, bytes32 p1) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(string,string)`.\\n mstore(0x00, 0x4b5c4277)\\n mstore(0x20, 0x40)\\n mstore(0x40, 0x80)\\n writeString(0x60, p0)\\n writeString(0xa0, p1)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(address p0, address p1, address p2) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n // Selector of `log(address,address,address)`.\\n mstore(0x00, 0x018c84c2)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n }\\n _sendLogPayload(0x1c, 0x64);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n }\\n }\\n\\n function log(address p0, address p1, bool p2) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n // Selector of `log(address,address,bool)`.\\n mstore(0x00, 0xf2a66286)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n }\\n _sendLogPayload(0x1c, 0x64);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n }\\n }\\n\\n function log(address p0, address p1, uint256 p2) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n // Selector of `log(address,address,uint256)`.\\n mstore(0x00, 0x17fe6185)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n }\\n _sendLogPayload(0x1c, 0x64);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n }\\n }\\n\\n function log(address p0, address p1, bytes32 p2) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n // Selector of `log(address,address,string)`.\\n mstore(0x00, 0x007150be)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, 0x60)\\n writeString(0x80, p2)\\n }\\n _sendLogPayload(0x1c, 0xa4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n }\\n }\\n\\n function log(address p0, bool p1, address p2) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n // Selector of `log(address,bool,address)`.\\n mstore(0x00, 0xf11699ed)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n }\\n _sendLogPayload(0x1c, 0x64);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n }\\n }\\n\\n function log(address p0, bool p1, bool p2) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n // Selector of `log(address,bool,bool)`.\\n mstore(0x00, 0xeb830c92)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n }\\n _sendLogPayload(0x1c, 0x64);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n }\\n }\\n\\n function log(address p0, bool p1, uint256 p2) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n // Selector of `log(address,bool,uint256)`.\\n mstore(0x00, 0x9c4f99fb)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n }\\n _sendLogPayload(0x1c, 0x64);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n }\\n }\\n\\n function log(address p0, bool p1, bytes32 p2) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n // Selector of `log(address,bool,string)`.\\n mstore(0x00, 0x212255cc)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, 0x60)\\n writeString(0x80, p2)\\n }\\n _sendLogPayload(0x1c, 0xa4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n }\\n }\\n\\n function log(address p0, uint256 p1, address p2) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n // Selector of `log(address,uint256,address)`.\\n mstore(0x00, 0x7bc0d848)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n }\\n _sendLogPayload(0x1c, 0x64);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n }\\n }\\n\\n function log(address p0, uint256 p1, bool p2) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n // Selector of `log(address,uint256,bool)`.\\n mstore(0x00, 0x678209a8)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n }\\n _sendLogPayload(0x1c, 0x64);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n }\\n }\\n\\n function log(address p0, uint256 p1, uint256 p2) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n // Selector of `log(address,uint256,uint256)`.\\n mstore(0x00, 0xb69bcaf6)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n }\\n _sendLogPayload(0x1c, 0x64);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n }\\n }\\n\\n function log(address p0, uint256 p1, bytes32 p2) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n // Selector of `log(address,uint256,string)`.\\n mstore(0x00, 0xa1f2e8aa)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, 0x60)\\n writeString(0x80, p2)\\n }\\n _sendLogPayload(0x1c, 0xa4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n }\\n }\\n\\n function log(address p0, bytes32 p1, address p2) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n // Selector of `log(address,string,address)`.\\n mstore(0x00, 0xf08744e8)\\n mstore(0x20, p0)\\n mstore(0x40, 0x60)\\n mstore(0x60, p2)\\n writeString(0x80, p1)\\n }\\n _sendLogPayload(0x1c, 0xa4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n }\\n }\\n\\n function log(address p0, bytes32 p1, bool p2) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n // Selector of `log(address,string,bool)`.\\n mstore(0x00, 0xcf020fb1)\\n mstore(0x20, p0)\\n mstore(0x40, 0x60)\\n mstore(0x60, p2)\\n writeString(0x80, p1)\\n }\\n _sendLogPayload(0x1c, 0xa4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n }\\n }\\n\\n function log(address p0, bytes32 p1, uint256 p2) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n // Selector of `log(address,string,uint256)`.\\n mstore(0x00, 0x67dd6ff1)\\n mstore(0x20, p0)\\n mstore(0x40, 0x60)\\n mstore(0x60, p2)\\n writeString(0x80, p1)\\n }\\n _sendLogPayload(0x1c, 0xa4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n }\\n }\\n\\n function log(address p0, bytes32 p1, bytes32 p2) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n // Selector of `log(address,string,string)`.\\n mstore(0x00, 0xfb772265)\\n mstore(0x20, p0)\\n mstore(0x40, 0x60)\\n mstore(0x60, 0xa0)\\n writeString(0x80, p1)\\n writeString(0xc0, p2)\\n }\\n _sendLogPayload(0x1c, 0xe4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n }\\n }\\n\\n function log(bool p0, address p1, address p2) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n // Selector of `log(bool,address,address)`.\\n mstore(0x00, 0xd2763667)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n }\\n _sendLogPayload(0x1c, 0x64);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n }\\n }\\n\\n function log(bool p0, address p1, bool p2) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n // Selector of `log(bool,address,bool)`.\\n mstore(0x00, 0x18c9c746)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n }\\n _sendLogPayload(0x1c, 0x64);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n }\\n }\\n\\n function log(bool p0, address p1, uint256 p2) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n // Selector of `log(bool,address,uint256)`.\\n mstore(0x00, 0x5f7b9afb)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n }\\n _sendLogPayload(0x1c, 0x64);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n }\\n }\\n\\n function log(bool p0, address p1, bytes32 p2) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n // Selector of `log(bool,address,string)`.\\n mstore(0x00, 0xde9a9270)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, 0x60)\\n writeString(0x80, p2)\\n }\\n _sendLogPayload(0x1c, 0xa4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n }\\n }\\n\\n function log(bool p0, bool p1, address p2) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n // Selector of `log(bool,bool,address)`.\\n mstore(0x00, 0x1078f68d)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n }\\n _sendLogPayload(0x1c, 0x64);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n }\\n }\\n\\n function log(bool p0, bool p1, bool p2) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n // Selector of `log(bool,bool,bool)`.\\n mstore(0x00, 0x50709698)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n }\\n _sendLogPayload(0x1c, 0x64);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n }\\n }\\n\\n function log(bool p0, bool p1, uint256 p2) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n // Selector of `log(bool,bool,uint256)`.\\n mstore(0x00, 0x12f21602)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n }\\n _sendLogPayload(0x1c, 0x64);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n }\\n }\\n\\n function log(bool p0, bool p1, bytes32 p2) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n // Selector of `log(bool,bool,string)`.\\n mstore(0x00, 0x2555fa46)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, 0x60)\\n writeString(0x80, p2)\\n }\\n _sendLogPayload(0x1c, 0xa4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n }\\n }\\n\\n function log(bool p0, uint256 p1, address p2) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n // Selector of `log(bool,uint256,address)`.\\n mstore(0x00, 0x088ef9d2)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n }\\n _sendLogPayload(0x1c, 0x64);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n }\\n }\\n\\n function log(bool p0, uint256 p1, bool p2) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n // Selector of `log(bool,uint256,bool)`.\\n mstore(0x00, 0xe8defba9)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n }\\n _sendLogPayload(0x1c, 0x64);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n }\\n }\\n\\n function log(bool p0, uint256 p1, uint256 p2) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n // Selector of `log(bool,uint256,uint256)`.\\n mstore(0x00, 0x37103367)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n }\\n _sendLogPayload(0x1c, 0x64);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n }\\n }\\n\\n function log(bool p0, uint256 p1, bytes32 p2) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n // Selector of `log(bool,uint256,string)`.\\n mstore(0x00, 0xc3fc3970)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, 0x60)\\n writeString(0x80, p2)\\n }\\n _sendLogPayload(0x1c, 0xa4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n }\\n }\\n\\n function log(bool p0, bytes32 p1, address p2) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n // Selector of `log(bool,string,address)`.\\n mstore(0x00, 0x9591b953)\\n mstore(0x20, p0)\\n mstore(0x40, 0x60)\\n mstore(0x60, p2)\\n writeString(0x80, p1)\\n }\\n _sendLogPayload(0x1c, 0xa4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n }\\n }\\n\\n function log(bool p0, bytes32 p1, bool p2) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n // Selector of `log(bool,string,bool)`.\\n mstore(0x00, 0xdbb4c247)\\n mstore(0x20, p0)\\n mstore(0x40, 0x60)\\n mstore(0x60, p2)\\n writeString(0x80, p1)\\n }\\n _sendLogPayload(0x1c, 0xa4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n }\\n }\\n\\n function log(bool p0, bytes32 p1, uint256 p2) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n // Selector of `log(bool,string,uint256)`.\\n mstore(0x00, 0x1093ee11)\\n mstore(0x20, p0)\\n mstore(0x40, 0x60)\\n mstore(0x60, p2)\\n writeString(0x80, p1)\\n }\\n _sendLogPayload(0x1c, 0xa4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n }\\n }\\n\\n function log(bool p0, bytes32 p1, bytes32 p2) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n // Selector of `log(bool,string,string)`.\\n mstore(0x00, 0xb076847f)\\n mstore(0x20, p0)\\n mstore(0x40, 0x60)\\n mstore(0x60, 0xa0)\\n writeString(0x80, p1)\\n writeString(0xc0, p2)\\n }\\n _sendLogPayload(0x1c, 0xe4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n }\\n }\\n\\n function log(uint256 p0, address p1, address p2) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n // Selector of `log(uint256,address,address)`.\\n mstore(0x00, 0xbcfd9be0)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n }\\n _sendLogPayload(0x1c, 0x64);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n }\\n }\\n\\n function log(uint256 p0, address p1, bool p2) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n // Selector of `log(uint256,address,bool)`.\\n mstore(0x00, 0x9b6ec042)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n }\\n _sendLogPayload(0x1c, 0x64);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n }\\n }\\n\\n function log(uint256 p0, address p1, uint256 p2) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n // Selector of `log(uint256,address,uint256)`.\\n mstore(0x00, 0x5a9b5ed5)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n }\\n _sendLogPayload(0x1c, 0x64);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n }\\n }\\n\\n function log(uint256 p0, address p1, bytes32 p2) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n // Selector of `log(uint256,address,string)`.\\n mstore(0x00, 0x63cb41f9)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, 0x60)\\n writeString(0x80, p2)\\n }\\n _sendLogPayload(0x1c, 0xa4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n }\\n }\\n\\n function log(uint256 p0, bool p1, address p2) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n // Selector of `log(uint256,bool,address)`.\\n mstore(0x00, 0x35085f7b)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n }\\n _sendLogPayload(0x1c, 0x64);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n }\\n }\\n\\n function log(uint256 p0, bool p1, bool p2) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n // Selector of `log(uint256,bool,bool)`.\\n mstore(0x00, 0x20718650)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n }\\n _sendLogPayload(0x1c, 0x64);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n }\\n }\\n\\n function log(uint256 p0, bool p1, uint256 p2) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n // Selector of `log(uint256,bool,uint256)`.\\n mstore(0x00, 0x20098014)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n }\\n _sendLogPayload(0x1c, 0x64);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n }\\n }\\n\\n function log(uint256 p0, bool p1, bytes32 p2) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n // Selector of `log(uint256,bool,string)`.\\n mstore(0x00, 0x85775021)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, 0x60)\\n writeString(0x80, p2)\\n }\\n _sendLogPayload(0x1c, 0xa4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n }\\n }\\n\\n function log(uint256 p0, uint256 p1, address p2) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n // Selector of `log(uint256,uint256,address)`.\\n mstore(0x00, 0x5c96b331)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n }\\n _sendLogPayload(0x1c, 0x64);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n }\\n }\\n\\n function log(uint256 p0, uint256 p1, bool p2) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n // Selector of `log(uint256,uint256,bool)`.\\n mstore(0x00, 0x4766da72)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n }\\n _sendLogPayload(0x1c, 0x64);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n }\\n }\\n\\n function log(uint256 p0, uint256 p1, uint256 p2) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n // Selector of `log(uint256,uint256,uint256)`.\\n mstore(0x00, 0xd1ed7a3c)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n }\\n _sendLogPayload(0x1c, 0x64);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n }\\n }\\n\\n function log(uint256 p0, uint256 p1, bytes32 p2) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n // Selector of `log(uint256,uint256,string)`.\\n mstore(0x00, 0x71d04af2)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, 0x60)\\n writeString(0x80, p2)\\n }\\n _sendLogPayload(0x1c, 0xa4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n }\\n }\\n\\n function log(uint256 p0, bytes32 p1, address p2) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n // Selector of `log(uint256,string,address)`.\\n mstore(0x00, 0x7afac959)\\n mstore(0x20, p0)\\n mstore(0x40, 0x60)\\n mstore(0x60, p2)\\n writeString(0x80, p1)\\n }\\n _sendLogPayload(0x1c, 0xa4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n }\\n }\\n\\n function log(uint256 p0, bytes32 p1, bool p2) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n // Selector of `log(uint256,string,bool)`.\\n mstore(0x00, 0x4ceda75a)\\n mstore(0x20, p0)\\n mstore(0x40, 0x60)\\n mstore(0x60, p2)\\n writeString(0x80, p1)\\n }\\n _sendLogPayload(0x1c, 0xa4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n }\\n }\\n\\n function log(uint256 p0, bytes32 p1, uint256 p2) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n // Selector of `log(uint256,string,uint256)`.\\n mstore(0x00, 0x37aa7d4c)\\n mstore(0x20, p0)\\n mstore(0x40, 0x60)\\n mstore(0x60, p2)\\n writeString(0x80, p1)\\n }\\n _sendLogPayload(0x1c, 0xa4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n }\\n }\\n\\n function log(uint256 p0, bytes32 p1, bytes32 p2) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n // Selector of `log(uint256,string,string)`.\\n mstore(0x00, 0xb115611f)\\n mstore(0x20, p0)\\n mstore(0x40, 0x60)\\n mstore(0x60, 0xa0)\\n writeString(0x80, p1)\\n writeString(0xc0, p2)\\n }\\n _sendLogPayload(0x1c, 0xe4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n }\\n }\\n\\n function log(bytes32 p0, address p1, address p2) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n // Selector of `log(string,address,address)`.\\n mstore(0x00, 0xfcec75e0)\\n mstore(0x20, 0x60)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n writeString(0x80, p0)\\n }\\n _sendLogPayload(0x1c, 0xa4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n }\\n }\\n\\n function log(bytes32 p0, address p1, bool p2) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n // Selector of `log(string,address,bool)`.\\n mstore(0x00, 0xc91d5ed4)\\n mstore(0x20, 0x60)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n writeString(0x80, p0)\\n }\\n _sendLogPayload(0x1c, 0xa4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n }\\n }\\n\\n function log(bytes32 p0, address p1, uint256 p2) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n // Selector of `log(string,address,uint256)`.\\n mstore(0x00, 0x0d26b925)\\n mstore(0x20, 0x60)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n writeString(0x80, p0)\\n }\\n _sendLogPayload(0x1c, 0xa4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n }\\n }\\n\\n function log(bytes32 p0, address p1, bytes32 p2) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n // Selector of `log(string,address,string)`.\\n mstore(0x00, 0xe0e9ad4f)\\n mstore(0x20, 0x60)\\n mstore(0x40, p1)\\n mstore(0x60, 0xa0)\\n writeString(0x80, p0)\\n writeString(0xc0, p2)\\n }\\n _sendLogPayload(0x1c, 0xe4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n }\\n }\\n\\n function log(bytes32 p0, bool p1, address p2) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n // Selector of `log(string,bool,address)`.\\n mstore(0x00, 0x932bbb38)\\n mstore(0x20, 0x60)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n writeString(0x80, p0)\\n }\\n _sendLogPayload(0x1c, 0xa4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n }\\n }\\n\\n function log(bytes32 p0, bool p1, bool p2) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n // Selector of `log(string,bool,bool)`.\\n mstore(0x00, 0x850b7ad6)\\n mstore(0x20, 0x60)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n writeString(0x80, p0)\\n }\\n _sendLogPayload(0x1c, 0xa4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n }\\n }\\n\\n function log(bytes32 p0, bool p1, uint256 p2) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n // Selector of `log(string,bool,uint256)`.\\n mstore(0x00, 0xc95958d6)\\n mstore(0x20, 0x60)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n writeString(0x80, p0)\\n }\\n _sendLogPayload(0x1c, 0xa4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n }\\n }\\n\\n function log(bytes32 p0, bool p1, bytes32 p2) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n // Selector of `log(string,bool,string)`.\\n mstore(0x00, 0xe298f47d)\\n mstore(0x20, 0x60)\\n mstore(0x40, p1)\\n mstore(0x60, 0xa0)\\n writeString(0x80, p0)\\n writeString(0xc0, p2)\\n }\\n _sendLogPayload(0x1c, 0xe4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n }\\n }\\n\\n function log(bytes32 p0, uint256 p1, address p2) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n // Selector of `log(string,uint256,address)`.\\n mstore(0x00, 0x1c7ec448)\\n mstore(0x20, 0x60)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n writeString(0x80, p0)\\n }\\n _sendLogPayload(0x1c, 0xa4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n }\\n }\\n\\n function log(bytes32 p0, uint256 p1, bool p2) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n // Selector of `log(string,uint256,bool)`.\\n mstore(0x00, 0xca7733b1)\\n mstore(0x20, 0x60)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n writeString(0x80, p0)\\n }\\n _sendLogPayload(0x1c, 0xa4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n }\\n }\\n\\n function log(bytes32 p0, uint256 p1, uint256 p2) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n // Selector of `log(string,uint256,uint256)`.\\n mstore(0x00, 0xca47c4eb)\\n mstore(0x20, 0x60)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n writeString(0x80, p0)\\n }\\n _sendLogPayload(0x1c, 0xa4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n }\\n }\\n\\n function log(bytes32 p0, uint256 p1, bytes32 p2) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n // Selector of `log(string,uint256,string)`.\\n mstore(0x00, 0x5970e089)\\n mstore(0x20, 0x60)\\n mstore(0x40, p1)\\n mstore(0x60, 0xa0)\\n writeString(0x80, p0)\\n writeString(0xc0, p2)\\n }\\n _sendLogPayload(0x1c, 0xe4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n }\\n }\\n\\n function log(bytes32 p0, bytes32 p1, address p2) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n // Selector of `log(string,string,address)`.\\n mstore(0x00, 0x95ed0195)\\n mstore(0x20, 0x60)\\n mstore(0x40, 0xa0)\\n mstore(0x60, p2)\\n writeString(0x80, p0)\\n writeString(0xc0, p1)\\n }\\n _sendLogPayload(0x1c, 0xe4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n }\\n }\\n\\n function log(bytes32 p0, bytes32 p1, bool p2) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n // Selector of `log(string,string,bool)`.\\n mstore(0x00, 0xb0e0f9b5)\\n mstore(0x20, 0x60)\\n mstore(0x40, 0xa0)\\n mstore(0x60, p2)\\n writeString(0x80, p0)\\n writeString(0xc0, p1)\\n }\\n _sendLogPayload(0x1c, 0xe4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n }\\n }\\n\\n function log(bytes32 p0, bytes32 p1, uint256 p2) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n // Selector of `log(string,string,uint256)`.\\n mstore(0x00, 0x5821efa1)\\n mstore(0x20, 0x60)\\n mstore(0x40, 0xa0)\\n mstore(0x60, p2)\\n writeString(0x80, p0)\\n writeString(0xc0, p1)\\n }\\n _sendLogPayload(0x1c, 0xe4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n }\\n }\\n\\n function log(bytes32 p0, bytes32 p1, bytes32 p2) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n bytes32 m9;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n m9 := mload(0x120)\\n // Selector of `log(string,string,string)`.\\n mstore(0x00, 0x2ced7cef)\\n mstore(0x20, 0x60)\\n mstore(0x40, 0xa0)\\n mstore(0x60, 0xe0)\\n writeString(0x80, p0)\\n writeString(0xc0, p1)\\n writeString(0x100, p2)\\n }\\n _sendLogPayload(0x1c, 0x124);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n mstore(0x120, m9)\\n }\\n }\\n\\n function log(address p0, address p1, address p2, address p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(address,address,address,address)`.\\n mstore(0x00, 0x665bf134)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(address p0, address p1, address p2, bool p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(address,address,address,bool)`.\\n mstore(0x00, 0x0e378994)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(address p0, address p1, address p2, uint256 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(address,address,address,uint256)`.\\n mstore(0x00, 0x94250d77)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(address p0, address p1, address p2, bytes32 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(address,address,address,string)`.\\n mstore(0x00, 0xf808da20)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, 0x80)\\n writeString(0xa0, p3)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(address p0, address p1, bool p2, address p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(address,address,bool,address)`.\\n mstore(0x00, 0x9f1bc36e)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(address p0, address p1, bool p2, bool p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(address,address,bool,bool)`.\\n mstore(0x00, 0x2cd4134a)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(address p0, address p1, bool p2, uint256 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(address,address,bool,uint256)`.\\n mstore(0x00, 0x3971e78c)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(address p0, address p1, bool p2, bytes32 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(address,address,bool,string)`.\\n mstore(0x00, 0xaa6540c8)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, 0x80)\\n writeString(0xa0, p3)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(address p0, address p1, uint256 p2, address p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(address,address,uint256,address)`.\\n mstore(0x00, 0x8da6def5)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(address p0, address p1, uint256 p2, bool p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(address,address,uint256,bool)`.\\n mstore(0x00, 0x9b4254e2)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(address p0, address p1, uint256 p2, uint256 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(address,address,uint256,uint256)`.\\n mstore(0x00, 0xbe553481)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(address p0, address p1, uint256 p2, bytes32 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(address,address,uint256,string)`.\\n mstore(0x00, 0xfdb4f990)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, 0x80)\\n writeString(0xa0, p3)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(address p0, address p1, bytes32 p2, address p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(address,address,string,address)`.\\n mstore(0x00, 0x8f736d16)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, 0x80)\\n mstore(0x80, p3)\\n writeString(0xa0, p2)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(address p0, address p1, bytes32 p2, bool p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(address,address,string,bool)`.\\n mstore(0x00, 0x6f1a594e)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, 0x80)\\n mstore(0x80, p3)\\n writeString(0xa0, p2)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(address p0, address p1, bytes32 p2, uint256 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(address,address,string,uint256)`.\\n mstore(0x00, 0xef1cefe7)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, 0x80)\\n mstore(0x80, p3)\\n writeString(0xa0, p2)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(address p0, address p1, bytes32 p2, bytes32 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n // Selector of `log(address,address,string,string)`.\\n mstore(0x00, 0x21bdaf25)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, 0x80)\\n mstore(0x80, 0xc0)\\n writeString(0xa0, p2)\\n writeString(0xe0, p3)\\n }\\n _sendLogPayload(0x1c, 0x104);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n }\\n }\\n\\n function log(address p0, bool p1, address p2, address p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(address,bool,address,address)`.\\n mstore(0x00, 0x660375dd)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(address p0, bool p1, address p2, bool p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(address,bool,address,bool)`.\\n mstore(0x00, 0xa6f50b0f)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(address p0, bool p1, address p2, uint256 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(address,bool,address,uint256)`.\\n mstore(0x00, 0xa75c59de)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(address p0, bool p1, address p2, bytes32 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(address,bool,address,string)`.\\n mstore(0x00, 0x2dd778e6)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, 0x80)\\n writeString(0xa0, p3)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(address p0, bool p1, bool p2, address p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(address,bool,bool,address)`.\\n mstore(0x00, 0xcf394485)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(address p0, bool p1, bool p2, bool p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(address,bool,bool,bool)`.\\n mstore(0x00, 0xcac43479)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(address p0, bool p1, bool p2, uint256 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(address,bool,bool,uint256)`.\\n mstore(0x00, 0x8c4e5de6)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(address p0, bool p1, bool p2, bytes32 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(address,bool,bool,string)`.\\n mstore(0x00, 0xdfc4a2e8)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, 0x80)\\n writeString(0xa0, p3)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(address p0, bool p1, uint256 p2, address p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(address,bool,uint256,address)`.\\n mstore(0x00, 0xccf790a1)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(address p0, bool p1, uint256 p2, bool p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(address,bool,uint256,bool)`.\\n mstore(0x00, 0xc4643e20)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(address p0, bool p1, uint256 p2, uint256 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(address,bool,uint256,uint256)`.\\n mstore(0x00, 0x386ff5f4)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(address p0, bool p1, uint256 p2, bytes32 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(address,bool,uint256,string)`.\\n mstore(0x00, 0x0aa6cfad)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, 0x80)\\n writeString(0xa0, p3)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(address p0, bool p1, bytes32 p2, address p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(address,bool,string,address)`.\\n mstore(0x00, 0x19fd4956)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, 0x80)\\n mstore(0x80, p3)\\n writeString(0xa0, p2)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(address p0, bool p1, bytes32 p2, bool p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(address,bool,string,bool)`.\\n mstore(0x00, 0x50ad461d)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, 0x80)\\n mstore(0x80, p3)\\n writeString(0xa0, p2)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(address p0, bool p1, bytes32 p2, uint256 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(address,bool,string,uint256)`.\\n mstore(0x00, 0x80e6a20b)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, 0x80)\\n mstore(0x80, p3)\\n writeString(0xa0, p2)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(address p0, bool p1, bytes32 p2, bytes32 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n // Selector of `log(address,bool,string,string)`.\\n mstore(0x00, 0x475c5c33)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, 0x80)\\n mstore(0x80, 0xc0)\\n writeString(0xa0, p2)\\n writeString(0xe0, p3)\\n }\\n _sendLogPayload(0x1c, 0x104);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n }\\n }\\n\\n function log(address p0, uint256 p1, address p2, address p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(address,uint256,address,address)`.\\n mstore(0x00, 0x478d1c62)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(address p0, uint256 p1, address p2, bool p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(address,uint256,address,bool)`.\\n mstore(0x00, 0xa1bcc9b3)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(address p0, uint256 p1, address p2, uint256 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(address,uint256,address,uint256)`.\\n mstore(0x00, 0x100f650e)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(address p0, uint256 p1, address p2, bytes32 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(address,uint256,address,string)`.\\n mstore(0x00, 0x1da986ea)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, 0x80)\\n writeString(0xa0, p3)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(address p0, uint256 p1, bool p2, address p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(address,uint256,bool,address)`.\\n mstore(0x00, 0xa31bfdcc)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(address p0, uint256 p1, bool p2, bool p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(address,uint256,bool,bool)`.\\n mstore(0x00, 0x3bf5e537)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(address p0, uint256 p1, bool p2, uint256 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(address,uint256,bool,uint256)`.\\n mstore(0x00, 0x22f6b999)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(address p0, uint256 p1, bool p2, bytes32 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(address,uint256,bool,string)`.\\n mstore(0x00, 0xc5ad85f9)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, 0x80)\\n writeString(0xa0, p3)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(address p0, uint256 p1, uint256 p2, address p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(address,uint256,uint256,address)`.\\n mstore(0x00, 0x20e3984d)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(address p0, uint256 p1, uint256 p2, bool p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(address,uint256,uint256,bool)`.\\n mstore(0x00, 0x66f1bc67)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(address p0, uint256 p1, uint256 p2, uint256 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(address,uint256,uint256,uint256)`.\\n mstore(0x00, 0x34f0e636)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(address p0, uint256 p1, uint256 p2, bytes32 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(address,uint256,uint256,string)`.\\n mstore(0x00, 0x4a28c017)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, 0x80)\\n writeString(0xa0, p3)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(address p0, uint256 p1, bytes32 p2, address p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(address,uint256,string,address)`.\\n mstore(0x00, 0x5c430d47)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, 0x80)\\n mstore(0x80, p3)\\n writeString(0xa0, p2)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(address p0, uint256 p1, bytes32 p2, bool p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(address,uint256,string,bool)`.\\n mstore(0x00, 0xcf18105c)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, 0x80)\\n mstore(0x80, p3)\\n writeString(0xa0, p2)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(address p0, uint256 p1, bytes32 p2, uint256 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(address,uint256,string,uint256)`.\\n mstore(0x00, 0xbf01f891)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, 0x80)\\n mstore(0x80, p3)\\n writeString(0xa0, p2)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(address p0, uint256 p1, bytes32 p2, bytes32 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n // Selector of `log(address,uint256,string,string)`.\\n mstore(0x00, 0x88a8c406)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, 0x80)\\n mstore(0x80, 0xc0)\\n writeString(0xa0, p2)\\n writeString(0xe0, p3)\\n }\\n _sendLogPayload(0x1c, 0x104);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n }\\n }\\n\\n function log(address p0, bytes32 p1, address p2, address p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(address,string,address,address)`.\\n mstore(0x00, 0x0d36fa20)\\n mstore(0x20, p0)\\n mstore(0x40, 0x80)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n writeString(0xa0, p1)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(address p0, bytes32 p1, address p2, bool p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(address,string,address,bool)`.\\n mstore(0x00, 0x0df12b76)\\n mstore(0x20, p0)\\n mstore(0x40, 0x80)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n writeString(0xa0, p1)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(address p0, bytes32 p1, address p2, uint256 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(address,string,address,uint256)`.\\n mstore(0x00, 0x457fe3cf)\\n mstore(0x20, p0)\\n mstore(0x40, 0x80)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n writeString(0xa0, p1)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(address p0, bytes32 p1, address p2, bytes32 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n // Selector of `log(address,string,address,string)`.\\n mstore(0x00, 0xf7e36245)\\n mstore(0x20, p0)\\n mstore(0x40, 0x80)\\n mstore(0x60, p2)\\n mstore(0x80, 0xc0)\\n writeString(0xa0, p1)\\n writeString(0xe0, p3)\\n }\\n _sendLogPayload(0x1c, 0x104);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n }\\n }\\n\\n function log(address p0, bytes32 p1, bool p2, address p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(address,string,bool,address)`.\\n mstore(0x00, 0x205871c2)\\n mstore(0x20, p0)\\n mstore(0x40, 0x80)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n writeString(0xa0, p1)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(address p0, bytes32 p1, bool p2, bool p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(address,string,bool,bool)`.\\n mstore(0x00, 0x5f1d5c9f)\\n mstore(0x20, p0)\\n mstore(0x40, 0x80)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n writeString(0xa0, p1)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(address p0, bytes32 p1, bool p2, uint256 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(address,string,bool,uint256)`.\\n mstore(0x00, 0x515e38b6)\\n mstore(0x20, p0)\\n mstore(0x40, 0x80)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n writeString(0xa0, p1)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(address p0, bytes32 p1, bool p2, bytes32 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n // Selector of `log(address,string,bool,string)`.\\n mstore(0x00, 0xbc0b61fe)\\n mstore(0x20, p0)\\n mstore(0x40, 0x80)\\n mstore(0x60, p2)\\n mstore(0x80, 0xc0)\\n writeString(0xa0, p1)\\n writeString(0xe0, p3)\\n }\\n _sendLogPayload(0x1c, 0x104);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n }\\n }\\n\\n function log(address p0, bytes32 p1, uint256 p2, address p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(address,string,uint256,address)`.\\n mstore(0x00, 0x63183678)\\n mstore(0x20, p0)\\n mstore(0x40, 0x80)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n writeString(0xa0, p1)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(address p0, bytes32 p1, uint256 p2, bool p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(address,string,uint256,bool)`.\\n mstore(0x00, 0x0ef7e050)\\n mstore(0x20, p0)\\n mstore(0x40, 0x80)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n writeString(0xa0, p1)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(address p0, bytes32 p1, uint256 p2, uint256 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(address,string,uint256,uint256)`.\\n mstore(0x00, 0x1dc8e1b8)\\n mstore(0x20, p0)\\n mstore(0x40, 0x80)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n writeString(0xa0, p1)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(address p0, bytes32 p1, uint256 p2, bytes32 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n // Selector of `log(address,string,uint256,string)`.\\n mstore(0x00, 0x448830a8)\\n mstore(0x20, p0)\\n mstore(0x40, 0x80)\\n mstore(0x60, p2)\\n mstore(0x80, 0xc0)\\n writeString(0xa0, p1)\\n writeString(0xe0, p3)\\n }\\n _sendLogPayload(0x1c, 0x104);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n }\\n }\\n\\n function log(address p0, bytes32 p1, bytes32 p2, address p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n // Selector of `log(address,string,string,address)`.\\n mstore(0x00, 0xa04e2f87)\\n mstore(0x20, p0)\\n mstore(0x40, 0x80)\\n mstore(0x60, 0xc0)\\n mstore(0x80, p3)\\n writeString(0xa0, p1)\\n writeString(0xe0, p2)\\n }\\n _sendLogPayload(0x1c, 0x104);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n }\\n }\\n\\n function log(address p0, bytes32 p1, bytes32 p2, bool p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n // Selector of `log(address,string,string,bool)`.\\n mstore(0x00, 0x35a5071f)\\n mstore(0x20, p0)\\n mstore(0x40, 0x80)\\n mstore(0x60, 0xc0)\\n mstore(0x80, p3)\\n writeString(0xa0, p1)\\n writeString(0xe0, p2)\\n }\\n _sendLogPayload(0x1c, 0x104);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n }\\n }\\n\\n function log(address p0, bytes32 p1, bytes32 p2, uint256 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n // Selector of `log(address,string,string,uint256)`.\\n mstore(0x00, 0x159f8927)\\n mstore(0x20, p0)\\n mstore(0x40, 0x80)\\n mstore(0x60, 0xc0)\\n mstore(0x80, p3)\\n writeString(0xa0, p1)\\n writeString(0xe0, p2)\\n }\\n _sendLogPayload(0x1c, 0x104);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n }\\n }\\n\\n function log(address p0, bytes32 p1, bytes32 p2, bytes32 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n bytes32 m9;\\n bytes32 m10;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n m9 := mload(0x120)\\n m10 := mload(0x140)\\n // Selector of `log(address,string,string,string)`.\\n mstore(0x00, 0x5d02c50b)\\n mstore(0x20, p0)\\n mstore(0x40, 0x80)\\n mstore(0x60, 0xc0)\\n mstore(0x80, 0x100)\\n writeString(0xa0, p1)\\n writeString(0xe0, p2)\\n writeString(0x120, p3)\\n }\\n _sendLogPayload(0x1c, 0x144);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n mstore(0x120, m9)\\n mstore(0x140, m10)\\n }\\n }\\n\\n function log(bool p0, address p1, address p2, address p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(bool,address,address,address)`.\\n mstore(0x00, 0x1d14d001)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(bool p0, address p1, address p2, bool p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(bool,address,address,bool)`.\\n mstore(0x00, 0x46600be0)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(bool p0, address p1, address p2, uint256 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(bool,address,address,uint256)`.\\n mstore(0x00, 0x0c66d1be)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(bool p0, address p1, address p2, bytes32 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(bool,address,address,string)`.\\n mstore(0x00, 0xd812a167)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, 0x80)\\n writeString(0xa0, p3)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(bool p0, address p1, bool p2, address p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(bool,address,bool,address)`.\\n mstore(0x00, 0x1c41a336)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(bool p0, address p1, bool p2, bool p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(bool,address,bool,bool)`.\\n mstore(0x00, 0x6a9c478b)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(bool p0, address p1, bool p2, uint256 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(bool,address,bool,uint256)`.\\n mstore(0x00, 0x07831502)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(bool p0, address p1, bool p2, bytes32 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(bool,address,bool,string)`.\\n mstore(0x00, 0x4a66cb34)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, 0x80)\\n writeString(0xa0, p3)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(bool p0, address p1, uint256 p2, address p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(bool,address,uint256,address)`.\\n mstore(0x00, 0x136b05dd)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(bool p0, address p1, uint256 p2, bool p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(bool,address,uint256,bool)`.\\n mstore(0x00, 0xd6019f1c)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(bool p0, address p1, uint256 p2, uint256 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(bool,address,uint256,uint256)`.\\n mstore(0x00, 0x7bf181a1)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(bool p0, address p1, uint256 p2, bytes32 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(bool,address,uint256,string)`.\\n mstore(0x00, 0x51f09ff8)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, 0x80)\\n writeString(0xa0, p3)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(bool p0, address p1, bytes32 p2, address p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(bool,address,string,address)`.\\n mstore(0x00, 0x6f7c603e)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, 0x80)\\n mstore(0x80, p3)\\n writeString(0xa0, p2)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(bool p0, address p1, bytes32 p2, bool p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(bool,address,string,bool)`.\\n mstore(0x00, 0xe2bfd60b)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, 0x80)\\n mstore(0x80, p3)\\n writeString(0xa0, p2)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(bool p0, address p1, bytes32 p2, uint256 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(bool,address,string,uint256)`.\\n mstore(0x00, 0xc21f64c7)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, 0x80)\\n mstore(0x80, p3)\\n writeString(0xa0, p2)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(bool p0, address p1, bytes32 p2, bytes32 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n // Selector of `log(bool,address,string,string)`.\\n mstore(0x00, 0xa73c1db6)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, 0x80)\\n mstore(0x80, 0xc0)\\n writeString(0xa0, p2)\\n writeString(0xe0, p3)\\n }\\n _sendLogPayload(0x1c, 0x104);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n }\\n }\\n\\n function log(bool p0, bool p1, address p2, address p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(bool,bool,address,address)`.\\n mstore(0x00, 0xf4880ea4)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(bool p0, bool p1, address p2, bool p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(bool,bool,address,bool)`.\\n mstore(0x00, 0xc0a302d8)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(bool p0, bool p1, address p2, uint256 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(bool,bool,address,uint256)`.\\n mstore(0x00, 0x4c123d57)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(bool p0, bool p1, address p2, bytes32 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(bool,bool,address,string)`.\\n mstore(0x00, 0xa0a47963)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, 0x80)\\n writeString(0xa0, p3)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(bool p0, bool p1, bool p2, address p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(bool,bool,bool,address)`.\\n mstore(0x00, 0x8c329b1a)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(bool p0, bool p1, bool p2, bool p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(bool,bool,bool,bool)`.\\n mstore(0x00, 0x3b2a5ce0)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(bool p0, bool p1, bool p2, uint256 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(bool,bool,bool,uint256)`.\\n mstore(0x00, 0x6d7045c1)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(bool p0, bool p1, bool p2, bytes32 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(bool,bool,bool,string)`.\\n mstore(0x00, 0x2ae408d4)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, 0x80)\\n writeString(0xa0, p3)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(bool p0, bool p1, uint256 p2, address p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(bool,bool,uint256,address)`.\\n mstore(0x00, 0x54a7a9a0)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(bool p0, bool p1, uint256 p2, bool p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(bool,bool,uint256,bool)`.\\n mstore(0x00, 0x619e4d0e)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(bool p0, bool p1, uint256 p2, uint256 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(bool,bool,uint256,uint256)`.\\n mstore(0x00, 0x0bb00eab)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(bool p0, bool p1, uint256 p2, bytes32 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(bool,bool,uint256,string)`.\\n mstore(0x00, 0x7dd4d0e0)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, 0x80)\\n writeString(0xa0, p3)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(bool p0, bool p1, bytes32 p2, address p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(bool,bool,string,address)`.\\n mstore(0x00, 0xf9ad2b89)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, 0x80)\\n mstore(0x80, p3)\\n writeString(0xa0, p2)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(bool p0, bool p1, bytes32 p2, bool p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(bool,bool,string,bool)`.\\n mstore(0x00, 0xb857163a)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, 0x80)\\n mstore(0x80, p3)\\n writeString(0xa0, p2)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(bool p0, bool p1, bytes32 p2, uint256 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(bool,bool,string,uint256)`.\\n mstore(0x00, 0xe3a9ca2f)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, 0x80)\\n mstore(0x80, p3)\\n writeString(0xa0, p2)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(bool p0, bool p1, bytes32 p2, bytes32 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n // Selector of `log(bool,bool,string,string)`.\\n mstore(0x00, 0x6d1e8751)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, 0x80)\\n mstore(0x80, 0xc0)\\n writeString(0xa0, p2)\\n writeString(0xe0, p3)\\n }\\n _sendLogPayload(0x1c, 0x104);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n }\\n }\\n\\n function log(bool p0, uint256 p1, address p2, address p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(bool,uint256,address,address)`.\\n mstore(0x00, 0x26f560a8)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(bool p0, uint256 p1, address p2, bool p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(bool,uint256,address,bool)`.\\n mstore(0x00, 0xb4c314ff)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(bool p0, uint256 p1, address p2, uint256 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(bool,uint256,address,uint256)`.\\n mstore(0x00, 0x1537dc87)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(bool p0, uint256 p1, address p2, bytes32 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(bool,uint256,address,string)`.\\n mstore(0x00, 0x1bb3b09a)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, 0x80)\\n writeString(0xa0, p3)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(bool p0, uint256 p1, bool p2, address p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(bool,uint256,bool,address)`.\\n mstore(0x00, 0x9acd3616)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(bool p0, uint256 p1, bool p2, bool p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(bool,uint256,bool,bool)`.\\n mstore(0x00, 0xceb5f4d7)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(bool p0, uint256 p1, bool p2, uint256 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(bool,uint256,bool,uint256)`.\\n mstore(0x00, 0x7f9bbca2)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(bool p0, uint256 p1, bool p2, bytes32 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(bool,uint256,bool,string)`.\\n mstore(0x00, 0x9143dbb1)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, 0x80)\\n writeString(0xa0, p3)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(bool p0, uint256 p1, uint256 p2, address p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(bool,uint256,uint256,address)`.\\n mstore(0x00, 0x00dd87b9)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(bool p0, uint256 p1, uint256 p2, bool p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(bool,uint256,uint256,bool)`.\\n mstore(0x00, 0xbe984353)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(bool p0, uint256 p1, uint256 p2, uint256 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(bool,uint256,uint256,uint256)`.\\n mstore(0x00, 0x374bb4b2)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(bool p0, uint256 p1, uint256 p2, bytes32 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(bool,uint256,uint256,string)`.\\n mstore(0x00, 0x8e69fb5d)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, 0x80)\\n writeString(0xa0, p3)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(bool p0, uint256 p1, bytes32 p2, address p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(bool,uint256,string,address)`.\\n mstore(0x00, 0xfedd1fff)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, 0x80)\\n mstore(0x80, p3)\\n writeString(0xa0, p2)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(bool p0, uint256 p1, bytes32 p2, bool p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(bool,uint256,string,bool)`.\\n mstore(0x00, 0xe5e70b2b)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, 0x80)\\n mstore(0x80, p3)\\n writeString(0xa0, p2)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(bool p0, uint256 p1, bytes32 p2, uint256 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(bool,uint256,string,uint256)`.\\n mstore(0x00, 0x6a1199e2)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, 0x80)\\n mstore(0x80, p3)\\n writeString(0xa0, p2)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(bool p0, uint256 p1, bytes32 p2, bytes32 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n // Selector of `log(bool,uint256,string,string)`.\\n mstore(0x00, 0xf5bc2249)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, 0x80)\\n mstore(0x80, 0xc0)\\n writeString(0xa0, p2)\\n writeString(0xe0, p3)\\n }\\n _sendLogPayload(0x1c, 0x104);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n }\\n }\\n\\n function log(bool p0, bytes32 p1, address p2, address p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(bool,string,address,address)`.\\n mstore(0x00, 0x2b2b18dc)\\n mstore(0x20, p0)\\n mstore(0x40, 0x80)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n writeString(0xa0, p1)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(bool p0, bytes32 p1, address p2, bool p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(bool,string,address,bool)`.\\n mstore(0x00, 0x6dd434ca)\\n mstore(0x20, p0)\\n mstore(0x40, 0x80)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n writeString(0xa0, p1)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(bool p0, bytes32 p1, address p2, uint256 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(bool,string,address,uint256)`.\\n mstore(0x00, 0xa5cada94)\\n mstore(0x20, p0)\\n mstore(0x40, 0x80)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n writeString(0xa0, p1)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(bool p0, bytes32 p1, address p2, bytes32 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n // Selector of `log(bool,string,address,string)`.\\n mstore(0x00, 0x12d6c788)\\n mstore(0x20, p0)\\n mstore(0x40, 0x80)\\n mstore(0x60, p2)\\n mstore(0x80, 0xc0)\\n writeString(0xa0, p1)\\n writeString(0xe0, p3)\\n }\\n _sendLogPayload(0x1c, 0x104);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n }\\n }\\n\\n function log(bool p0, bytes32 p1, bool p2, address p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(bool,string,bool,address)`.\\n mstore(0x00, 0x538e06ab)\\n mstore(0x20, p0)\\n mstore(0x40, 0x80)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n writeString(0xa0, p1)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(bool p0, bytes32 p1, bool p2, bool p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(bool,string,bool,bool)`.\\n mstore(0x00, 0xdc5e935b)\\n mstore(0x20, p0)\\n mstore(0x40, 0x80)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n writeString(0xa0, p1)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(bool p0, bytes32 p1, bool p2, uint256 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(bool,string,bool,uint256)`.\\n mstore(0x00, 0x1606a393)\\n mstore(0x20, p0)\\n mstore(0x40, 0x80)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n writeString(0xa0, p1)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(bool p0, bytes32 p1, bool p2, bytes32 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n // Selector of `log(bool,string,bool,string)`.\\n mstore(0x00, 0x483d0416)\\n mstore(0x20, p0)\\n mstore(0x40, 0x80)\\n mstore(0x60, p2)\\n mstore(0x80, 0xc0)\\n writeString(0xa0, p1)\\n writeString(0xe0, p3)\\n }\\n _sendLogPayload(0x1c, 0x104);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n }\\n }\\n\\n function log(bool p0, bytes32 p1, uint256 p2, address p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(bool,string,uint256,address)`.\\n mstore(0x00, 0x1596a1ce)\\n mstore(0x20, p0)\\n mstore(0x40, 0x80)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n writeString(0xa0, p1)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(bool p0, bytes32 p1, uint256 p2, bool p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(bool,string,uint256,bool)`.\\n mstore(0x00, 0x6b0e5d53)\\n mstore(0x20, p0)\\n mstore(0x40, 0x80)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n writeString(0xa0, p1)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(bool p0, bytes32 p1, uint256 p2, uint256 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(bool,string,uint256,uint256)`.\\n mstore(0x00, 0x28863fcb)\\n mstore(0x20, p0)\\n mstore(0x40, 0x80)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n writeString(0xa0, p1)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(bool p0, bytes32 p1, uint256 p2, bytes32 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n // Selector of `log(bool,string,uint256,string)`.\\n mstore(0x00, 0x1ad96de6)\\n mstore(0x20, p0)\\n mstore(0x40, 0x80)\\n mstore(0x60, p2)\\n mstore(0x80, 0xc0)\\n writeString(0xa0, p1)\\n writeString(0xe0, p3)\\n }\\n _sendLogPayload(0x1c, 0x104);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n }\\n }\\n\\n function log(bool p0, bytes32 p1, bytes32 p2, address p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n // Selector of `log(bool,string,string,address)`.\\n mstore(0x00, 0x97d394d8)\\n mstore(0x20, p0)\\n mstore(0x40, 0x80)\\n mstore(0x60, 0xc0)\\n mstore(0x80, p3)\\n writeString(0xa0, p1)\\n writeString(0xe0, p2)\\n }\\n _sendLogPayload(0x1c, 0x104);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n }\\n }\\n\\n function log(bool p0, bytes32 p1, bytes32 p2, bool p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n // Selector of `log(bool,string,string,bool)`.\\n mstore(0x00, 0x1e4b87e5)\\n mstore(0x20, p0)\\n mstore(0x40, 0x80)\\n mstore(0x60, 0xc0)\\n mstore(0x80, p3)\\n writeString(0xa0, p1)\\n writeString(0xe0, p2)\\n }\\n _sendLogPayload(0x1c, 0x104);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n }\\n }\\n\\n function log(bool p0, bytes32 p1, bytes32 p2, uint256 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n // Selector of `log(bool,string,string,uint256)`.\\n mstore(0x00, 0x7be0c3eb)\\n mstore(0x20, p0)\\n mstore(0x40, 0x80)\\n mstore(0x60, 0xc0)\\n mstore(0x80, p3)\\n writeString(0xa0, p1)\\n writeString(0xe0, p2)\\n }\\n _sendLogPayload(0x1c, 0x104);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n }\\n }\\n\\n function log(bool p0, bytes32 p1, bytes32 p2, bytes32 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n bytes32 m9;\\n bytes32 m10;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n m9 := mload(0x120)\\n m10 := mload(0x140)\\n // Selector of `log(bool,string,string,string)`.\\n mstore(0x00, 0x1762e32a)\\n mstore(0x20, p0)\\n mstore(0x40, 0x80)\\n mstore(0x60, 0xc0)\\n mstore(0x80, 0x100)\\n writeString(0xa0, p1)\\n writeString(0xe0, p2)\\n writeString(0x120, p3)\\n }\\n _sendLogPayload(0x1c, 0x144);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n mstore(0x120, m9)\\n mstore(0x140, m10)\\n }\\n }\\n\\n function log(uint256 p0, address p1, address p2, address p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(uint256,address,address,address)`.\\n mstore(0x00, 0x2488b414)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(uint256 p0, address p1, address p2, bool p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(uint256,address,address,bool)`.\\n mstore(0x00, 0x091ffaf5)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(uint256 p0, address p1, address p2, uint256 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(uint256,address,address,uint256)`.\\n mstore(0x00, 0x736efbb6)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(uint256 p0, address p1, address p2, bytes32 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(uint256,address,address,string)`.\\n mstore(0x00, 0x031c6f73)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, 0x80)\\n writeString(0xa0, p3)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(uint256 p0, address p1, bool p2, address p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(uint256,address,bool,address)`.\\n mstore(0x00, 0xef72c513)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(uint256 p0, address p1, bool p2, bool p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(uint256,address,bool,bool)`.\\n mstore(0x00, 0xe351140f)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(uint256 p0, address p1, bool p2, uint256 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(uint256,address,bool,uint256)`.\\n mstore(0x00, 0x5abd992a)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(uint256 p0, address p1, bool p2, bytes32 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(uint256,address,bool,string)`.\\n mstore(0x00, 0x90fb06aa)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, 0x80)\\n writeString(0xa0, p3)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(uint256 p0, address p1, uint256 p2, address p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(uint256,address,uint256,address)`.\\n mstore(0x00, 0x15c127b5)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(uint256 p0, address p1, uint256 p2, bool p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(uint256,address,uint256,bool)`.\\n mstore(0x00, 0x5f743a7c)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(uint256 p0, address p1, uint256 p2, uint256 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(uint256,address,uint256,uint256)`.\\n mstore(0x00, 0x0c9cd9c1)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(uint256 p0, address p1, uint256 p2, bytes32 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(uint256,address,uint256,string)`.\\n mstore(0x00, 0xddb06521)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, 0x80)\\n writeString(0xa0, p3)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(uint256 p0, address p1, bytes32 p2, address p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(uint256,address,string,address)`.\\n mstore(0x00, 0x9cba8fff)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, 0x80)\\n mstore(0x80, p3)\\n writeString(0xa0, p2)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(uint256 p0, address p1, bytes32 p2, bool p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(uint256,address,string,bool)`.\\n mstore(0x00, 0xcc32ab07)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, 0x80)\\n mstore(0x80, p3)\\n writeString(0xa0, p2)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(uint256 p0, address p1, bytes32 p2, uint256 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(uint256,address,string,uint256)`.\\n mstore(0x00, 0x46826b5d)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, 0x80)\\n mstore(0x80, p3)\\n writeString(0xa0, p2)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(uint256 p0, address p1, bytes32 p2, bytes32 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n // Selector of `log(uint256,address,string,string)`.\\n mstore(0x00, 0x3e128ca3)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, 0x80)\\n mstore(0x80, 0xc0)\\n writeString(0xa0, p2)\\n writeString(0xe0, p3)\\n }\\n _sendLogPayload(0x1c, 0x104);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n }\\n }\\n\\n function log(uint256 p0, bool p1, address p2, address p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(uint256,bool,address,address)`.\\n mstore(0x00, 0xa1ef4cbb)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(uint256 p0, bool p1, address p2, bool p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(uint256,bool,address,bool)`.\\n mstore(0x00, 0x454d54a5)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(uint256 p0, bool p1, address p2, uint256 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(uint256,bool,address,uint256)`.\\n mstore(0x00, 0x078287f5)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(uint256 p0, bool p1, address p2, bytes32 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(uint256,bool,address,string)`.\\n mstore(0x00, 0xade052c7)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, 0x80)\\n writeString(0xa0, p3)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(uint256 p0, bool p1, bool p2, address p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(uint256,bool,bool,address)`.\\n mstore(0x00, 0x69640b59)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(uint256 p0, bool p1, bool p2, bool p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(uint256,bool,bool,bool)`.\\n mstore(0x00, 0xb6f577a1)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(uint256 p0, bool p1, bool p2, uint256 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(uint256,bool,bool,uint256)`.\\n mstore(0x00, 0x7464ce23)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(uint256 p0, bool p1, bool p2, bytes32 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(uint256,bool,bool,string)`.\\n mstore(0x00, 0xdddb9561)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, 0x80)\\n writeString(0xa0, p3)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(uint256 p0, bool p1, uint256 p2, address p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(uint256,bool,uint256,address)`.\\n mstore(0x00, 0x88cb6041)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(uint256 p0, bool p1, uint256 p2, bool p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(uint256,bool,uint256,bool)`.\\n mstore(0x00, 0x91a02e2a)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(uint256 p0, bool p1, uint256 p2, uint256 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(uint256,bool,uint256,uint256)`.\\n mstore(0x00, 0xc6acc7a8)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(uint256 p0, bool p1, uint256 p2, bytes32 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(uint256,bool,uint256,string)`.\\n mstore(0x00, 0xde03e774)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, 0x80)\\n writeString(0xa0, p3)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(uint256 p0, bool p1, bytes32 p2, address p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(uint256,bool,string,address)`.\\n mstore(0x00, 0xef529018)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, 0x80)\\n mstore(0x80, p3)\\n writeString(0xa0, p2)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(uint256 p0, bool p1, bytes32 p2, bool p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(uint256,bool,string,bool)`.\\n mstore(0x00, 0xeb928d7f)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, 0x80)\\n mstore(0x80, p3)\\n writeString(0xa0, p2)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(uint256 p0, bool p1, bytes32 p2, uint256 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(uint256,bool,string,uint256)`.\\n mstore(0x00, 0x2c1d0746)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, 0x80)\\n mstore(0x80, p3)\\n writeString(0xa0, p2)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(uint256 p0, bool p1, bytes32 p2, bytes32 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n // Selector of `log(uint256,bool,string,string)`.\\n mstore(0x00, 0x68c8b8bd)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, 0x80)\\n mstore(0x80, 0xc0)\\n writeString(0xa0, p2)\\n writeString(0xe0, p3)\\n }\\n _sendLogPayload(0x1c, 0x104);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n }\\n }\\n\\n function log(uint256 p0, uint256 p1, address p2, address p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(uint256,uint256,address,address)`.\\n mstore(0x00, 0x56a5d1b1)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(uint256 p0, uint256 p1, address p2, bool p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(uint256,uint256,address,bool)`.\\n mstore(0x00, 0x15cac476)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(uint256 p0, uint256 p1, address p2, uint256 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(uint256,uint256,address,uint256)`.\\n mstore(0x00, 0x88f6e4b2)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(uint256 p0, uint256 p1, address p2, bytes32 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(uint256,uint256,address,string)`.\\n mstore(0x00, 0x6cde40b8)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, 0x80)\\n writeString(0xa0, p3)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(uint256 p0, uint256 p1, bool p2, address p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(uint256,uint256,bool,address)`.\\n mstore(0x00, 0x9a816a83)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(uint256 p0, uint256 p1, bool p2, bool p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(uint256,uint256,bool,bool)`.\\n mstore(0x00, 0xab085ae6)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(uint256 p0, uint256 p1, bool p2, uint256 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(uint256,uint256,bool,uint256)`.\\n mstore(0x00, 0xeb7f6fd2)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(uint256 p0, uint256 p1, bool p2, bytes32 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(uint256,uint256,bool,string)`.\\n mstore(0x00, 0xa5b4fc99)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, 0x80)\\n writeString(0xa0, p3)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(uint256 p0, uint256 p1, uint256 p2, address p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(uint256,uint256,uint256,address)`.\\n mstore(0x00, 0xfa8185af)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(uint256 p0, uint256 p1, uint256 p2, bool p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(uint256,uint256,uint256,bool)`.\\n mstore(0x00, 0xc598d185)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(uint256 p0, uint256 p1, uint256 p2, uint256 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(uint256,uint256,uint256,uint256)`.\\n mstore(0x00, 0x193fb800)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(uint256 p0, uint256 p1, uint256 p2, bytes32 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(uint256,uint256,uint256,string)`.\\n mstore(0x00, 0x59cfcbe3)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, 0x80)\\n writeString(0xa0, p3)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(uint256 p0, uint256 p1, bytes32 p2, address p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(uint256,uint256,string,address)`.\\n mstore(0x00, 0x42d21db7)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, 0x80)\\n mstore(0x80, p3)\\n writeString(0xa0, p2)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(uint256 p0, uint256 p1, bytes32 p2, bool p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(uint256,uint256,string,bool)`.\\n mstore(0x00, 0x7af6ab25)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, 0x80)\\n mstore(0x80, p3)\\n writeString(0xa0, p2)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(uint256 p0, uint256 p1, bytes32 p2, uint256 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(uint256,uint256,string,uint256)`.\\n mstore(0x00, 0x5da297eb)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, 0x80)\\n mstore(0x80, p3)\\n writeString(0xa0, p2)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(uint256 p0, uint256 p1, bytes32 p2, bytes32 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n // Selector of `log(uint256,uint256,string,string)`.\\n mstore(0x00, 0x27d8afd2)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, 0x80)\\n mstore(0x80, 0xc0)\\n writeString(0xa0, p2)\\n writeString(0xe0, p3)\\n }\\n _sendLogPayload(0x1c, 0x104);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n }\\n }\\n\\n function log(uint256 p0, bytes32 p1, address p2, address p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(uint256,string,address,address)`.\\n mstore(0x00, 0x6168ed61)\\n mstore(0x20, p0)\\n mstore(0x40, 0x80)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n writeString(0xa0, p1)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(uint256 p0, bytes32 p1, address p2, bool p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(uint256,string,address,bool)`.\\n mstore(0x00, 0x90c30a56)\\n mstore(0x20, p0)\\n mstore(0x40, 0x80)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n writeString(0xa0, p1)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(uint256 p0, bytes32 p1, address p2, uint256 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(uint256,string,address,uint256)`.\\n mstore(0x00, 0xe8d3018d)\\n mstore(0x20, p0)\\n mstore(0x40, 0x80)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n writeString(0xa0, p1)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(uint256 p0, bytes32 p1, address p2, bytes32 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n // Selector of `log(uint256,string,address,string)`.\\n mstore(0x00, 0x9c3adfa1)\\n mstore(0x20, p0)\\n mstore(0x40, 0x80)\\n mstore(0x60, p2)\\n mstore(0x80, 0xc0)\\n writeString(0xa0, p1)\\n writeString(0xe0, p3)\\n }\\n _sendLogPayload(0x1c, 0x104);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n }\\n }\\n\\n function log(uint256 p0, bytes32 p1, bool p2, address p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(uint256,string,bool,address)`.\\n mstore(0x00, 0xae2ec581)\\n mstore(0x20, p0)\\n mstore(0x40, 0x80)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n writeString(0xa0, p1)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(uint256 p0, bytes32 p1, bool p2, bool p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(uint256,string,bool,bool)`.\\n mstore(0x00, 0xba535d9c)\\n mstore(0x20, p0)\\n mstore(0x40, 0x80)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n writeString(0xa0, p1)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(uint256 p0, bytes32 p1, bool p2, uint256 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(uint256,string,bool,uint256)`.\\n mstore(0x00, 0xcf009880)\\n mstore(0x20, p0)\\n mstore(0x40, 0x80)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n writeString(0xa0, p1)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(uint256 p0, bytes32 p1, bool p2, bytes32 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n // Selector of `log(uint256,string,bool,string)`.\\n mstore(0x00, 0xd2d423cd)\\n mstore(0x20, p0)\\n mstore(0x40, 0x80)\\n mstore(0x60, p2)\\n mstore(0x80, 0xc0)\\n writeString(0xa0, p1)\\n writeString(0xe0, p3)\\n }\\n _sendLogPayload(0x1c, 0x104);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n }\\n }\\n\\n function log(uint256 p0, bytes32 p1, uint256 p2, address p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(uint256,string,uint256,address)`.\\n mstore(0x00, 0x3b2279b4)\\n mstore(0x20, p0)\\n mstore(0x40, 0x80)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n writeString(0xa0, p1)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(uint256 p0, bytes32 p1, uint256 p2, bool p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(uint256,string,uint256,bool)`.\\n mstore(0x00, 0x691a8f74)\\n mstore(0x20, p0)\\n mstore(0x40, 0x80)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n writeString(0xa0, p1)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(uint256 p0, bytes32 p1, uint256 p2, uint256 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(uint256,string,uint256,uint256)`.\\n mstore(0x00, 0x82c25b74)\\n mstore(0x20, p0)\\n mstore(0x40, 0x80)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n writeString(0xa0, p1)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(uint256 p0, bytes32 p1, uint256 p2, bytes32 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n // Selector of `log(uint256,string,uint256,string)`.\\n mstore(0x00, 0xb7b914ca)\\n mstore(0x20, p0)\\n mstore(0x40, 0x80)\\n mstore(0x60, p2)\\n mstore(0x80, 0xc0)\\n writeString(0xa0, p1)\\n writeString(0xe0, p3)\\n }\\n _sendLogPayload(0x1c, 0x104);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n }\\n }\\n\\n function log(uint256 p0, bytes32 p1, bytes32 p2, address p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n // Selector of `log(uint256,string,string,address)`.\\n mstore(0x00, 0xd583c602)\\n mstore(0x20, p0)\\n mstore(0x40, 0x80)\\n mstore(0x60, 0xc0)\\n mstore(0x80, p3)\\n writeString(0xa0, p1)\\n writeString(0xe0, p2)\\n }\\n _sendLogPayload(0x1c, 0x104);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n }\\n }\\n\\n function log(uint256 p0, bytes32 p1, bytes32 p2, bool p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n // Selector of `log(uint256,string,string,bool)`.\\n mstore(0x00, 0xb3a6b6bd)\\n mstore(0x20, p0)\\n mstore(0x40, 0x80)\\n mstore(0x60, 0xc0)\\n mstore(0x80, p3)\\n writeString(0xa0, p1)\\n writeString(0xe0, p2)\\n }\\n _sendLogPayload(0x1c, 0x104);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n }\\n }\\n\\n function log(uint256 p0, bytes32 p1, bytes32 p2, uint256 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n // Selector of `log(uint256,string,string,uint256)`.\\n mstore(0x00, 0xb028c9bd)\\n mstore(0x20, p0)\\n mstore(0x40, 0x80)\\n mstore(0x60, 0xc0)\\n mstore(0x80, p3)\\n writeString(0xa0, p1)\\n writeString(0xe0, p2)\\n }\\n _sendLogPayload(0x1c, 0x104);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n }\\n }\\n\\n function log(uint256 p0, bytes32 p1, bytes32 p2, bytes32 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n bytes32 m9;\\n bytes32 m10;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n m9 := mload(0x120)\\n m10 := mload(0x140)\\n // Selector of `log(uint256,string,string,string)`.\\n mstore(0x00, 0x21ad0683)\\n mstore(0x20, p0)\\n mstore(0x40, 0x80)\\n mstore(0x60, 0xc0)\\n mstore(0x80, 0x100)\\n writeString(0xa0, p1)\\n writeString(0xe0, p2)\\n writeString(0x120, p3)\\n }\\n _sendLogPayload(0x1c, 0x144);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n mstore(0x120, m9)\\n mstore(0x140, m10)\\n }\\n }\\n\\n function log(bytes32 p0, address p1, address p2, address p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(string,address,address,address)`.\\n mstore(0x00, 0xed8f28f6)\\n mstore(0x20, 0x80)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n writeString(0xa0, p0)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(bytes32 p0, address p1, address p2, bool p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(string,address,address,bool)`.\\n mstore(0x00, 0xb59dbd60)\\n mstore(0x20, 0x80)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n writeString(0xa0, p0)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(bytes32 p0, address p1, address p2, uint256 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(string,address,address,uint256)`.\\n mstore(0x00, 0x8ef3f399)\\n mstore(0x20, 0x80)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n writeString(0xa0, p0)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(bytes32 p0, address p1, address p2, bytes32 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n // Selector of `log(string,address,address,string)`.\\n mstore(0x00, 0x800a1c67)\\n mstore(0x20, 0x80)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, 0xc0)\\n writeString(0xa0, p0)\\n writeString(0xe0, p3)\\n }\\n _sendLogPayload(0x1c, 0x104);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n }\\n }\\n\\n function log(bytes32 p0, address p1, bool p2, address p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(string,address,bool,address)`.\\n mstore(0x00, 0x223603bd)\\n mstore(0x20, 0x80)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n writeString(0xa0, p0)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(bytes32 p0, address p1, bool p2, bool p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(string,address,bool,bool)`.\\n mstore(0x00, 0x79884c2b)\\n mstore(0x20, 0x80)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n writeString(0xa0, p0)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(bytes32 p0, address p1, bool p2, uint256 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(string,address,bool,uint256)`.\\n mstore(0x00, 0x3e9f866a)\\n mstore(0x20, 0x80)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n writeString(0xa0, p0)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(bytes32 p0, address p1, bool p2, bytes32 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n // Selector of `log(string,address,bool,string)`.\\n mstore(0x00, 0x0454c079)\\n mstore(0x20, 0x80)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, 0xc0)\\n writeString(0xa0, p0)\\n writeString(0xe0, p3)\\n }\\n _sendLogPayload(0x1c, 0x104);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n }\\n }\\n\\n function log(bytes32 p0, address p1, uint256 p2, address p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(string,address,uint256,address)`.\\n mstore(0x00, 0x63fb8bc5)\\n mstore(0x20, 0x80)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n writeString(0xa0, p0)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(bytes32 p0, address p1, uint256 p2, bool p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(string,address,uint256,bool)`.\\n mstore(0x00, 0xfc4845f0)\\n mstore(0x20, 0x80)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n writeString(0xa0, p0)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(bytes32 p0, address p1, uint256 p2, uint256 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(string,address,uint256,uint256)`.\\n mstore(0x00, 0xf8f51b1e)\\n mstore(0x20, 0x80)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n writeString(0xa0, p0)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(bytes32 p0, address p1, uint256 p2, bytes32 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n // Selector of `log(string,address,uint256,string)`.\\n mstore(0x00, 0x5a477632)\\n mstore(0x20, 0x80)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, 0xc0)\\n writeString(0xa0, p0)\\n writeString(0xe0, p3)\\n }\\n _sendLogPayload(0x1c, 0x104);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n }\\n }\\n\\n function log(bytes32 p0, address p1, bytes32 p2, address p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n // Selector of `log(string,address,string,address)`.\\n mstore(0x00, 0xaabc9a31)\\n mstore(0x20, 0x80)\\n mstore(0x40, p1)\\n mstore(0x60, 0xc0)\\n mstore(0x80, p3)\\n writeString(0xa0, p0)\\n writeString(0xe0, p2)\\n }\\n _sendLogPayload(0x1c, 0x104);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n }\\n }\\n\\n function log(bytes32 p0, address p1, bytes32 p2, bool p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n // Selector of `log(string,address,string,bool)`.\\n mstore(0x00, 0x5f15d28c)\\n mstore(0x20, 0x80)\\n mstore(0x40, p1)\\n mstore(0x60, 0xc0)\\n mstore(0x80, p3)\\n writeString(0xa0, p0)\\n writeString(0xe0, p2)\\n }\\n _sendLogPayload(0x1c, 0x104);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n }\\n }\\n\\n function log(bytes32 p0, address p1, bytes32 p2, uint256 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n // Selector of `log(string,address,string,uint256)`.\\n mstore(0x00, 0x91d1112e)\\n mstore(0x20, 0x80)\\n mstore(0x40, p1)\\n mstore(0x60, 0xc0)\\n mstore(0x80, p3)\\n writeString(0xa0, p0)\\n writeString(0xe0, p2)\\n }\\n _sendLogPayload(0x1c, 0x104);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n }\\n }\\n\\n function log(bytes32 p0, address p1, bytes32 p2, bytes32 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n bytes32 m9;\\n bytes32 m10;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n m9 := mload(0x120)\\n m10 := mload(0x140)\\n // Selector of `log(string,address,string,string)`.\\n mstore(0x00, 0x245986f2)\\n mstore(0x20, 0x80)\\n mstore(0x40, p1)\\n mstore(0x60, 0xc0)\\n mstore(0x80, 0x100)\\n writeString(0xa0, p0)\\n writeString(0xe0, p2)\\n writeString(0x120, p3)\\n }\\n _sendLogPayload(0x1c, 0x144);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n mstore(0x120, m9)\\n mstore(0x140, m10)\\n }\\n }\\n\\n function log(bytes32 p0, bool p1, address p2, address p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(string,bool,address,address)`.\\n mstore(0x00, 0x33e9dd1d)\\n mstore(0x20, 0x80)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n writeString(0xa0, p0)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(bytes32 p0, bool p1, address p2, bool p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(string,bool,address,bool)`.\\n mstore(0x00, 0x958c28c6)\\n mstore(0x20, 0x80)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n writeString(0xa0, p0)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(bytes32 p0, bool p1, address p2, uint256 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(string,bool,address,uint256)`.\\n mstore(0x00, 0x5d08bb05)\\n mstore(0x20, 0x80)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n writeString(0xa0, p0)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(bytes32 p0, bool p1, address p2, bytes32 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n // Selector of `log(string,bool,address,string)`.\\n mstore(0x00, 0x2d8e33a4)\\n mstore(0x20, 0x80)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, 0xc0)\\n writeString(0xa0, p0)\\n writeString(0xe0, p3)\\n }\\n _sendLogPayload(0x1c, 0x104);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n }\\n }\\n\\n function log(bytes32 p0, bool p1, bool p2, address p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(string,bool,bool,address)`.\\n mstore(0x00, 0x7190a529)\\n mstore(0x20, 0x80)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n writeString(0xa0, p0)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(bytes32 p0, bool p1, bool p2, bool p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(string,bool,bool,bool)`.\\n mstore(0x00, 0x895af8c5)\\n mstore(0x20, 0x80)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n writeString(0xa0, p0)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(bytes32 p0, bool p1, bool p2, uint256 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(string,bool,bool,uint256)`.\\n mstore(0x00, 0x8e3f78a9)\\n mstore(0x20, 0x80)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n writeString(0xa0, p0)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(bytes32 p0, bool p1, bool p2, bytes32 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n // Selector of `log(string,bool,bool,string)`.\\n mstore(0x00, 0x9d22d5dd)\\n mstore(0x20, 0x80)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, 0xc0)\\n writeString(0xa0, p0)\\n writeString(0xe0, p3)\\n }\\n _sendLogPayload(0x1c, 0x104);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n }\\n }\\n\\n function log(bytes32 p0, bool p1, uint256 p2, address p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(string,bool,uint256,address)`.\\n mstore(0x00, 0x935e09bf)\\n mstore(0x20, 0x80)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n writeString(0xa0, p0)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(bytes32 p0, bool p1, uint256 p2, bool p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(string,bool,uint256,bool)`.\\n mstore(0x00, 0x8af7cf8a)\\n mstore(0x20, 0x80)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n writeString(0xa0, p0)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(bytes32 p0, bool p1, uint256 p2, uint256 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(string,bool,uint256,uint256)`.\\n mstore(0x00, 0x64b5bb67)\\n mstore(0x20, 0x80)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n writeString(0xa0, p0)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(bytes32 p0, bool p1, uint256 p2, bytes32 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n // Selector of `log(string,bool,uint256,string)`.\\n mstore(0x00, 0x742d6ee7)\\n mstore(0x20, 0x80)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, 0xc0)\\n writeString(0xa0, p0)\\n writeString(0xe0, p3)\\n }\\n _sendLogPayload(0x1c, 0x104);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n }\\n }\\n\\n function log(bytes32 p0, bool p1, bytes32 p2, address p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n // Selector of `log(string,bool,string,address)`.\\n mstore(0x00, 0xe0625b29)\\n mstore(0x20, 0x80)\\n mstore(0x40, p1)\\n mstore(0x60, 0xc0)\\n mstore(0x80, p3)\\n writeString(0xa0, p0)\\n writeString(0xe0, p2)\\n }\\n _sendLogPayload(0x1c, 0x104);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n }\\n }\\n\\n function log(bytes32 p0, bool p1, bytes32 p2, bool p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n // Selector of `log(string,bool,string,bool)`.\\n mstore(0x00, 0x3f8a701d)\\n mstore(0x20, 0x80)\\n mstore(0x40, p1)\\n mstore(0x60, 0xc0)\\n mstore(0x80, p3)\\n writeString(0xa0, p0)\\n writeString(0xe0, p2)\\n }\\n _sendLogPayload(0x1c, 0x104);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n }\\n }\\n\\n function log(bytes32 p0, bool p1, bytes32 p2, uint256 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n // Selector of `log(string,bool,string,uint256)`.\\n mstore(0x00, 0x24f91465)\\n mstore(0x20, 0x80)\\n mstore(0x40, p1)\\n mstore(0x60, 0xc0)\\n mstore(0x80, p3)\\n writeString(0xa0, p0)\\n writeString(0xe0, p2)\\n }\\n _sendLogPayload(0x1c, 0x104);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n }\\n }\\n\\n function log(bytes32 p0, bool p1, bytes32 p2, bytes32 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n bytes32 m9;\\n bytes32 m10;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n m9 := mload(0x120)\\n m10 := mload(0x140)\\n // Selector of `log(string,bool,string,string)`.\\n mstore(0x00, 0xa826caeb)\\n mstore(0x20, 0x80)\\n mstore(0x40, p1)\\n mstore(0x60, 0xc0)\\n mstore(0x80, 0x100)\\n writeString(0xa0, p0)\\n writeString(0xe0, p2)\\n writeString(0x120, p3)\\n }\\n _sendLogPayload(0x1c, 0x144);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n mstore(0x120, m9)\\n mstore(0x140, m10)\\n }\\n }\\n\\n function log(bytes32 p0, uint256 p1, address p2, address p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(string,uint256,address,address)`.\\n mstore(0x00, 0x5ea2b7ae)\\n mstore(0x20, 0x80)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n writeString(0xa0, p0)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(bytes32 p0, uint256 p1, address p2, bool p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(string,uint256,address,bool)`.\\n mstore(0x00, 0x82112a42)\\n mstore(0x20, 0x80)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n writeString(0xa0, p0)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(bytes32 p0, uint256 p1, address p2, uint256 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(string,uint256,address,uint256)`.\\n mstore(0x00, 0x4f04fdc6)\\n mstore(0x20, 0x80)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n writeString(0xa0, p0)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(bytes32 p0, uint256 p1, address p2, bytes32 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n // Selector of `log(string,uint256,address,string)`.\\n mstore(0x00, 0x9ffb2f93)\\n mstore(0x20, 0x80)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, 0xc0)\\n writeString(0xa0, p0)\\n writeString(0xe0, p3)\\n }\\n _sendLogPayload(0x1c, 0x104);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n }\\n }\\n\\n function log(bytes32 p0, uint256 p1, bool p2, address p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(string,uint256,bool,address)`.\\n mstore(0x00, 0xe0e95b98)\\n mstore(0x20, 0x80)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n writeString(0xa0, p0)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(bytes32 p0, uint256 p1, bool p2, bool p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(string,uint256,bool,bool)`.\\n mstore(0x00, 0x354c36d6)\\n mstore(0x20, 0x80)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n writeString(0xa0, p0)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(bytes32 p0, uint256 p1, bool p2, uint256 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(string,uint256,bool,uint256)`.\\n mstore(0x00, 0xe41b6f6f)\\n mstore(0x20, 0x80)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n writeString(0xa0, p0)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(bytes32 p0, uint256 p1, bool p2, bytes32 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n // Selector of `log(string,uint256,bool,string)`.\\n mstore(0x00, 0xabf73a98)\\n mstore(0x20, 0x80)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, 0xc0)\\n writeString(0xa0, p0)\\n writeString(0xe0, p3)\\n }\\n _sendLogPayload(0x1c, 0x104);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n }\\n }\\n\\n function log(bytes32 p0, uint256 p1, uint256 p2, address p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(string,uint256,uint256,address)`.\\n mstore(0x00, 0xe21de278)\\n mstore(0x20, 0x80)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n writeString(0xa0, p0)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(bytes32 p0, uint256 p1, uint256 p2, bool p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(string,uint256,uint256,bool)`.\\n mstore(0x00, 0x7626db92)\\n mstore(0x20, 0x80)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n writeString(0xa0, p0)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(bytes32 p0, uint256 p1, uint256 p2, uint256 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(string,uint256,uint256,uint256)`.\\n mstore(0x00, 0xa7a87853)\\n mstore(0x20, 0x80)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n writeString(0xa0, p0)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(bytes32 p0, uint256 p1, uint256 p2, bytes32 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n // Selector of `log(string,uint256,uint256,string)`.\\n mstore(0x00, 0x854b3496)\\n mstore(0x20, 0x80)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, 0xc0)\\n writeString(0xa0, p0)\\n writeString(0xe0, p3)\\n }\\n _sendLogPayload(0x1c, 0x104);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n }\\n }\\n\\n function log(bytes32 p0, uint256 p1, bytes32 p2, address p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n // Selector of `log(string,uint256,string,address)`.\\n mstore(0x00, 0x7c4632a4)\\n mstore(0x20, 0x80)\\n mstore(0x40, p1)\\n mstore(0x60, 0xc0)\\n mstore(0x80, p3)\\n writeString(0xa0, p0)\\n writeString(0xe0, p2)\\n }\\n _sendLogPayload(0x1c, 0x104);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n }\\n }\\n\\n function log(bytes32 p0, uint256 p1, bytes32 p2, bool p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n // Selector of `log(string,uint256,string,bool)`.\\n mstore(0x00, 0x7d24491d)\\n mstore(0x20, 0x80)\\n mstore(0x40, p1)\\n mstore(0x60, 0xc0)\\n mstore(0x80, p3)\\n writeString(0xa0, p0)\\n writeString(0xe0, p2)\\n }\\n _sendLogPayload(0x1c, 0x104);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n }\\n }\\n\\n function log(bytes32 p0, uint256 p1, bytes32 p2, uint256 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n // Selector of `log(string,uint256,string,uint256)`.\\n mstore(0x00, 0xc67ea9d1)\\n mstore(0x20, 0x80)\\n mstore(0x40, p1)\\n mstore(0x60, 0xc0)\\n mstore(0x80, p3)\\n writeString(0xa0, p0)\\n writeString(0xe0, p2)\\n }\\n _sendLogPayload(0x1c, 0x104);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n }\\n }\\n\\n function log(bytes32 p0, uint256 p1, bytes32 p2, bytes32 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n bytes32 m9;\\n bytes32 m10;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n m9 := mload(0x120)\\n m10 := mload(0x140)\\n // Selector of `log(string,uint256,string,string)`.\\n mstore(0x00, 0x5ab84e1f)\\n mstore(0x20, 0x80)\\n mstore(0x40, p1)\\n mstore(0x60, 0xc0)\\n mstore(0x80, 0x100)\\n writeString(0xa0, p0)\\n writeString(0xe0, p2)\\n writeString(0x120, p3)\\n }\\n _sendLogPayload(0x1c, 0x144);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n mstore(0x120, m9)\\n mstore(0x140, m10)\\n }\\n }\\n\\n function log(bytes32 p0, bytes32 p1, address p2, address p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n // Selector of `log(string,string,address,address)`.\\n mstore(0x00, 0x439c7bef)\\n mstore(0x20, 0x80)\\n mstore(0x40, 0xc0)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n writeString(0xa0, p0)\\n writeString(0xe0, p1)\\n }\\n _sendLogPayload(0x1c, 0x104);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n }\\n }\\n\\n function log(bytes32 p0, bytes32 p1, address p2, bool p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n // Selector of `log(string,string,address,bool)`.\\n mstore(0x00, 0x5ccd4e37)\\n mstore(0x20, 0x80)\\n mstore(0x40, 0xc0)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n writeString(0xa0, p0)\\n writeString(0xe0, p1)\\n }\\n _sendLogPayload(0x1c, 0x104);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n }\\n }\\n\\n function log(bytes32 p0, bytes32 p1, address p2, uint256 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n // Selector of `log(string,string,address,uint256)`.\\n mstore(0x00, 0x7cc3c607)\\n mstore(0x20, 0x80)\\n mstore(0x40, 0xc0)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n writeString(0xa0, p0)\\n writeString(0xe0, p1)\\n }\\n _sendLogPayload(0x1c, 0x104);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n }\\n }\\n\\n function log(bytes32 p0, bytes32 p1, address p2, bytes32 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n bytes32 m9;\\n bytes32 m10;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n m9 := mload(0x120)\\n m10 := mload(0x140)\\n // Selector of `log(string,string,address,string)`.\\n mstore(0x00, 0xeb1bff80)\\n mstore(0x20, 0x80)\\n mstore(0x40, 0xc0)\\n mstore(0x60, p2)\\n mstore(0x80, 0x100)\\n writeString(0xa0, p0)\\n writeString(0xe0, p1)\\n writeString(0x120, p3)\\n }\\n _sendLogPayload(0x1c, 0x144);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n mstore(0x120, m9)\\n mstore(0x140, m10)\\n }\\n }\\n\\n function log(bytes32 p0, bytes32 p1, bool p2, address p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n // Selector of `log(string,string,bool,address)`.\\n mstore(0x00, 0xc371c7db)\\n mstore(0x20, 0x80)\\n mstore(0x40, 0xc0)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n writeString(0xa0, p0)\\n writeString(0xe0, p1)\\n }\\n _sendLogPayload(0x1c, 0x104);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n }\\n }\\n\\n function log(bytes32 p0, bytes32 p1, bool p2, bool p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n // Selector of `log(string,string,bool,bool)`.\\n mstore(0x00, 0x40785869)\\n mstore(0x20, 0x80)\\n mstore(0x40, 0xc0)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n writeString(0xa0, p0)\\n writeString(0xe0, p1)\\n }\\n _sendLogPayload(0x1c, 0x104);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n }\\n }\\n\\n function log(bytes32 p0, bytes32 p1, bool p2, uint256 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n // Selector of `log(string,string,bool,uint256)`.\\n mstore(0x00, 0xd6aefad2)\\n mstore(0x20, 0x80)\\n mstore(0x40, 0xc0)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n writeString(0xa0, p0)\\n writeString(0xe0, p1)\\n }\\n _sendLogPayload(0x1c, 0x104);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n }\\n }\\n\\n function log(bytes32 p0, bytes32 p1, bool p2, bytes32 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n bytes32 m9;\\n bytes32 m10;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n m9 := mload(0x120)\\n m10 := mload(0x140)\\n // Selector of `log(string,string,bool,string)`.\\n mstore(0x00, 0x5e84b0ea)\\n mstore(0x20, 0x80)\\n mstore(0x40, 0xc0)\\n mstore(0x60, p2)\\n mstore(0x80, 0x100)\\n writeString(0xa0, p0)\\n writeString(0xe0, p1)\\n writeString(0x120, p3)\\n }\\n _sendLogPayload(0x1c, 0x144);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n mstore(0x120, m9)\\n mstore(0x140, m10)\\n }\\n }\\n\\n function log(bytes32 p0, bytes32 p1, uint256 p2, address p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n // Selector of `log(string,string,uint256,address)`.\\n mstore(0x00, 0x1023f7b2)\\n mstore(0x20, 0x80)\\n mstore(0x40, 0xc0)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n writeString(0xa0, p0)\\n writeString(0xe0, p1)\\n }\\n _sendLogPayload(0x1c, 0x104);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n }\\n }\\n\\n function log(bytes32 p0, bytes32 p1, uint256 p2, bool p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n // Selector of `log(string,string,uint256,bool)`.\\n mstore(0x00, 0xc3a8a654)\\n mstore(0x20, 0x80)\\n mstore(0x40, 0xc0)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n writeString(0xa0, p0)\\n writeString(0xe0, p1)\\n }\\n _sendLogPayload(0x1c, 0x104);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n }\\n }\\n\\n function log(bytes32 p0, bytes32 p1, uint256 p2, uint256 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n // Selector of `log(string,string,uint256,uint256)`.\\n mstore(0x00, 0xf45d7d2c)\\n mstore(0x20, 0x80)\\n mstore(0x40, 0xc0)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n writeString(0xa0, p0)\\n writeString(0xe0, p1)\\n }\\n _sendLogPayload(0x1c, 0x104);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n }\\n }\\n\\n function log(bytes32 p0, bytes32 p1, uint256 p2, bytes32 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n bytes32 m9;\\n bytes32 m10;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n m9 := mload(0x120)\\n m10 := mload(0x140)\\n // Selector of `log(string,string,uint256,string)`.\\n mstore(0x00, 0x5d1a971a)\\n mstore(0x20, 0x80)\\n mstore(0x40, 0xc0)\\n mstore(0x60, p2)\\n mstore(0x80, 0x100)\\n writeString(0xa0, p0)\\n writeString(0xe0, p1)\\n writeString(0x120, p3)\\n }\\n _sendLogPayload(0x1c, 0x144);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n mstore(0x120, m9)\\n mstore(0x140, m10)\\n }\\n }\\n\\n function log(bytes32 p0, bytes32 p1, bytes32 p2, address p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n bytes32 m9;\\n bytes32 m10;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n m9 := mload(0x120)\\n m10 := mload(0x140)\\n // Selector of `log(string,string,string,address)`.\\n mstore(0x00, 0x6d572f44)\\n mstore(0x20, 0x80)\\n mstore(0x40, 0xc0)\\n mstore(0x60, 0x100)\\n mstore(0x80, p3)\\n writeString(0xa0, p0)\\n writeString(0xe0, p1)\\n writeString(0x120, p2)\\n }\\n _sendLogPayload(0x1c, 0x144);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n mstore(0x120, m9)\\n mstore(0x140, m10)\\n }\\n }\\n\\n function log(bytes32 p0, bytes32 p1, bytes32 p2, bool p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n bytes32 m9;\\n bytes32 m10;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n m9 := mload(0x120)\\n m10 := mload(0x140)\\n // Selector of `log(string,string,string,bool)`.\\n mstore(0x00, 0x2c1754ed)\\n mstore(0x20, 0x80)\\n mstore(0x40, 0xc0)\\n mstore(0x60, 0x100)\\n mstore(0x80, p3)\\n writeString(0xa0, p0)\\n writeString(0xe0, p1)\\n writeString(0x120, p2)\\n }\\n _sendLogPayload(0x1c, 0x144);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n mstore(0x120, m9)\\n mstore(0x140, m10)\\n }\\n }\\n\\n function log(bytes32 p0, bytes32 p1, bytes32 p2, uint256 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n bytes32 m9;\\n bytes32 m10;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n m9 := mload(0x120)\\n m10 := mload(0x140)\\n // Selector of `log(string,string,string,uint256)`.\\n mstore(0x00, 0x8eafb02b)\\n mstore(0x20, 0x80)\\n mstore(0x40, 0xc0)\\n mstore(0x60, 0x100)\\n mstore(0x80, p3)\\n writeString(0xa0, p0)\\n writeString(0xe0, p1)\\n writeString(0x120, p2)\\n }\\n _sendLogPayload(0x1c, 0x144);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n mstore(0x120, m9)\\n mstore(0x140, m10)\\n }\\n }\\n\\n function log(bytes32 p0, bytes32 p1, bytes32 p2, bytes32 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n bytes32 m9;\\n bytes32 m10;\\n bytes32 m11;\\n bytes32 m12;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n m9 := mload(0x120)\\n m10 := mload(0x140)\\n m11 := mload(0x160)\\n m12 := mload(0x180)\\n // Selector of `log(string,string,string,string)`.\\n mstore(0x00, 0xde68f20a)\\n mstore(0x20, 0x80)\\n mstore(0x40, 0xc0)\\n mstore(0x60, 0x100)\\n mstore(0x80, 0x140)\\n writeString(0xa0, p0)\\n writeString(0xe0, p1)\\n writeString(0x120, p2)\\n writeString(0x160, p3)\\n }\\n _sendLogPayload(0x1c, 0x184);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n mstore(0x120, m9)\\n mstore(0x140, m10)\\n mstore(0x160, m11)\\n mstore(0x180, m12)\\n }\\n }\\n}\\n\",\"keccak256\":\"0xbef9786cb49d3eade757bad87568c49c8c8f35721f0193c95ffb055d9e466e11\",\"license\":\"MIT\"},\"scripts/FetchChainInfo.s.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\nimport { Script } from \\\"forge-std/Script.sol\\\";\\nimport { GameTypes, GameType } from \\\"src/dispute/lib/Types.sol\\\";\\n\\n/// @notice Contains getters for arbitrary methods from all L1 contracts, including legacy getters\\n/// that have since been deprecated.\\ninterface IFetcher {\\n function guardian() external view returns (address);\\n function GUARDIAN() external view returns (address);\\n function systemConfig() external view returns (address);\\n function SYSTEM_CONFIG() external view returns (address);\\n function disputeGameFactory() external view returns (address);\\n function ethLockbox() external view returns (address);\\n function superchainConfig() external view returns (address);\\n function messenger() external view returns (address);\\n function addressManager() external view returns (address);\\n function PORTAL() external view returns (address);\\n function portal() external view returns (address);\\n function l1ERC721Bridge() external view returns (address);\\n function optimismMintableERC20Factory() external view returns (address);\\n function gameImpls(GameType _gameType) external view returns (address);\\n function respectedGameType() external view returns (GameType);\\n function anchorStateRegistry() external view returns (address);\\n function L2_ORACLE() external view returns (address);\\n function l2Oracle() external view returns (address);\\n function vm() external view returns (address);\\n function oracle() external view returns (address);\\n function challenger() external view returns (address);\\n function proposer() external view returns (address);\\n function PROPOSER() external view returns (address);\\n function batcherHash() external view returns (bytes32);\\n function admin() external view returns (address);\\n function owner() external view returns (address);\\n function unsafeBlockSigner() external view returns (address);\\n function weth() external view returns (address);\\n}\\n\\ncontract FetchChainInfoInput {\\n address internal _systemConfigProxy;\\n address internal _l1StandardBridgeProxy;\\n\\n function set(bytes4 _sel, address _addr) public {\\n require(_addr != address(0), \\\"FetchChainInfoInput: cannot set zero address\\\");\\n if (_sel == this.systemConfigProxy.selector) _systemConfigProxy = _addr;\\n else if (_sel == this.l1StandardBridgeProxy.selector) _l1StandardBridgeProxy = _addr;\\n else revert(\\\"FetchChainInfoInput: unknown selector\\\");\\n }\\n\\n function systemConfigProxy() public view returns (address) {\\n require(_systemConfigProxy != address(0), \\\"FetchChainInfoInput: systemConfigProxy not set\\\");\\n return _systemConfigProxy;\\n }\\n\\n function l1StandardBridgeProxy() public view returns (address) {\\n require(_l1StandardBridgeProxy != address(0), \\\"FetchChainInfoInput: l1StandardBridgeProxy not set\\\");\\n return _l1StandardBridgeProxy;\\n }\\n}\\n\\ncontract FetchChainInfoOutput {\\n // contract addresses\\n // - SuperchainContracts\\n address internal _superchainConfigProxy;\\n // - ImplementationsContracts\\n address internal _mipsImpl;\\n address internal _preimageOracleImpl;\\n // - OpChainContracts\\n address internal _addressManagerImpl;\\n address internal _ethLockboxProxy;\\n address internal _l1CrossDomainMessengerProxy;\\n address internal _l1Erc721BridgeProxy;\\n address internal _l1StandardBridgeProxy;\\n address internal _l2OutputOracleProxy;\\n address internal _optimismMintableErc20FactoryProxy;\\n address internal _optimismPortalProxy;\\n address internal _systemConfigProxy;\\n address internal _opChainProxyAdminImpl;\\n address internal _anchorStateRegistryProxy;\\n address internal _delayedWethPermissionedGameProxy;\\n address internal _delayedWethPermissionlessGameProxy;\\n address internal _disputeGameFactoryProxy;\\n address internal _faultDisputeGameImpl;\\n address internal _permissionedDisputeGameImpl;\\n\\n // roles\\n address internal _systemConfigOwner;\\n address internal _opChainProxyAdminOwner;\\n address internal _opChainGuardian;\\n address internal _challenger;\\n address internal _proposer;\\n address internal _unsafeBlockSigner;\\n address internal _batchSubmitter;\\n\\n // fault proof status\\n bool internal _permissioned;\\n bool internal _permissionless;\\n GameType internal _respectedGameType;\\n\\n function set(bytes4 _sel, address _addr) public {\\n // SuperchainContracts\\n if (_sel == this.superchainConfigProxy.selector) _superchainConfigProxy = _addr;\\n // - ImplementationsContracts\\n else if (_sel == this.mipsImpl.selector) _mipsImpl = _addr;\\n else if (_sel == this.preimageOracleImpl.selector) _preimageOracleImpl = _addr;\\n // - OpChainContracts\\n else if (_sel == this.addressManagerImpl.selector) _addressManagerImpl = _addr;\\n else if (_sel == this.ethLockboxProxy.selector) _ethLockboxProxy = _addr;\\n else if (_sel == this.l1CrossDomainMessengerProxy.selector) _l1CrossDomainMessengerProxy = _addr;\\n else if (_sel == this.l1Erc721BridgeProxy.selector) _l1Erc721BridgeProxy = _addr;\\n else if (_sel == this.l1StandardBridgeProxy.selector) _l1StandardBridgeProxy = _addr;\\n else if (_sel == this.l2OutputOracleProxy.selector) _l2OutputOracleProxy = _addr;\\n else if (_sel == this.optimismMintableErc20FactoryProxy.selector) _optimismMintableErc20FactoryProxy = _addr;\\n else if (_sel == this.optimismPortalProxy.selector) _optimismPortalProxy = _addr;\\n else if (_sel == this.systemConfigProxy.selector) _systemConfigProxy = _addr;\\n else if (_sel == this.opChainProxyAdminImpl.selector) _opChainProxyAdminImpl = _addr;\\n else if (_sel == this.anchorStateRegistryProxy.selector) _anchorStateRegistryProxy = _addr;\\n else if (_sel == this.delayedWethPermissionedGameProxy.selector) _delayedWethPermissionedGameProxy = _addr;\\n else if (_sel == this.delayedWethPermissionlessGameProxy.selector) _delayedWethPermissionlessGameProxy = _addr;\\n else if (_sel == this.disputeGameFactoryProxy.selector) _disputeGameFactoryProxy = _addr;\\n else if (_sel == this.faultDisputeGameImpl.selector) _faultDisputeGameImpl = _addr;\\n else if (_sel == this.permissionedDisputeGameImpl.selector) _permissionedDisputeGameImpl = _addr;\\n // roles\\n else if (_sel == this.systemConfigOwner.selector) _systemConfigOwner = _addr;\\n else if (_sel == this.opChainProxyAdminOwner.selector) _opChainProxyAdminOwner = _addr;\\n else if (_sel == this.opChainGuardian.selector) _opChainGuardian = _addr;\\n else if (_sel == this.challenger.selector) _challenger = _addr;\\n else if (_sel == this.proposer.selector) _proposer = _addr;\\n else if (_sel == this.unsafeBlockSigner.selector) _unsafeBlockSigner = _addr;\\n else if (_sel == this.batchSubmitter.selector) _batchSubmitter = _addr;\\n else revert(\\\"FetchChainInfoOutput: unknown address selector test\\\");\\n }\\n\\n function set(bytes4 _sel, bool _bool) public {\\n if (_sel == this.permissioned.selector) _permissioned = _bool;\\n else if (_sel == this.permissionless.selector) _permissionless = _bool;\\n else revert(\\\"FetchChainInfoOutput: unknown bool selector\\\");\\n }\\n\\n function set(bytes4 _sel, GameType _gameType) public {\\n if (_sel == this.respectedGameType.selector) _respectedGameType = _gameType;\\n else revert(\\\"FetchChainInfoOutput: unknown GameType selector\\\");\\n }\\n\\n function addressManagerImpl() public view returns (address) {\\n require(_addressManagerImpl != address(0), \\\"FetchChainInfoOutput: addressManagerImpl not set\\\");\\n return _addressManagerImpl;\\n }\\n\\n function ethLockboxProxy() public view returns (address) {\\n return _ethLockboxProxy;\\n }\\n\\n function l1CrossDomainMessengerProxy() public view returns (address) {\\n require(_l1CrossDomainMessengerProxy != address(0), \\\"FetchChainInfoOutput: l1CrossDomainMessengerProxy not set\\\");\\n return _l1CrossDomainMessengerProxy;\\n }\\n\\n function l1Erc721BridgeProxy() public view returns (address) {\\n require(_l1Erc721BridgeProxy != address(0), \\\"FetchChainInfoOutput: l1Erc721BridgeProxy not set\\\");\\n return _l1Erc721BridgeProxy;\\n }\\n\\n function l1StandardBridgeProxy() public view returns (address) {\\n require(_l1StandardBridgeProxy != address(0), \\\"FetchChainInfoOutput: l1StandardBridgeProxy not set\\\");\\n return _l1StandardBridgeProxy;\\n }\\n\\n function l2OutputOracleProxy() public view returns (address) {\\n require(_l2OutputOracleProxy != address(0), \\\"FetchChainInfoOutput: l2OutputOracleProxy not set\\\");\\n return _l2OutputOracleProxy;\\n }\\n\\n function optimismMintableErc20FactoryProxy() public view returns (address) {\\n require(\\n _optimismMintableErc20FactoryProxy != address(0),\\n \\\"FetchChainInfoOutput: optimismMintableErc20FactoryProxy not set\\\"\\n );\\n return _optimismMintableErc20FactoryProxy;\\n }\\n\\n function optimismPortalProxy() public view returns (address) {\\n require(_optimismPortalProxy != address(0), \\\"FetchChainInfoOutput: optimismPortalProxy not set\\\");\\n return _optimismPortalProxy;\\n }\\n\\n function systemConfigProxy() public view returns (address) {\\n require(_systemConfigProxy != address(0), \\\"FetchChainInfoOutput: systemConfigProxy not set\\\");\\n return _systemConfigProxy;\\n }\\n\\n function opChainProxyAdminImpl() public view returns (address) {\\n require(_opChainProxyAdminImpl != address(0), \\\"FetchChainInfoOutput: opChainProxyAdminImpl not set\\\");\\n return _opChainProxyAdminImpl;\\n }\\n\\n function superchainConfigProxy() public view returns (address) {\\n require(_superchainConfigProxy != address(0), \\\"FetchChainInfoOutput: superchainConfigProxy not set\\\");\\n return _superchainConfigProxy;\\n }\\n\\n function anchorStateRegistryProxy() public view returns (address) {\\n require(_anchorStateRegistryProxy != address(0), \\\"FetchChainInfoOutput: anchorStateRegistryProxy not set\\\");\\n return _anchorStateRegistryProxy;\\n }\\n\\n function delayedWethPermissionedGameProxy() public view returns (address) {\\n return _delayedWethPermissionedGameProxy;\\n }\\n\\n function delayedWethPermissionlessGameProxy() public view returns (address) {\\n return _delayedWethPermissionlessGameProxy;\\n }\\n\\n function disputeGameFactoryProxy() public view returns (address) {\\n return _disputeGameFactoryProxy;\\n }\\n\\n function faultDisputeGameImpl() public view returns (address) {\\n require(_faultDisputeGameImpl != address(0), \\\"FetchChainInfoOutput: faultDisputeGameImpl not set\\\");\\n return _faultDisputeGameImpl;\\n }\\n\\n function mipsImpl() public view returns (address) {\\n require(_mipsImpl != address(0), \\\"FetchChainInfoOutput: mipsImpl not set\\\");\\n return _mipsImpl;\\n }\\n\\n function permissionedDisputeGameImpl() public view returns (address) {\\n require(_permissionedDisputeGameImpl != address(0), \\\"FetchChainInfoOutput: permissionedDisputeGameImpl not set\\\");\\n return _permissionedDisputeGameImpl;\\n }\\n\\n function preimageOracleImpl() public view returns (address) {\\n require(_preimageOracleImpl != address(0), \\\"FetchChainInfoOutput: preimageOracleImpl not set\\\");\\n return _preimageOracleImpl;\\n }\\n\\n function systemConfigOwner() public view returns (address) {\\n require(_systemConfigOwner != address(0), \\\"FetchChainInfoOutput: systemConfigOwner not set\\\");\\n return _systemConfigOwner;\\n }\\n\\n function opChainProxyAdminOwner() public view returns (address) {\\n require(_opChainProxyAdminOwner != address(0), \\\"FetchChainInfoOutput: opChainProxyAdminOwner not set\\\");\\n return _opChainProxyAdminOwner;\\n }\\n\\n function opChainGuardian() public view returns (address) {\\n require(_opChainGuardian != address(0), \\\"FetchChainInfoOutput: opChainGuardian not set\\\");\\n return _opChainGuardian;\\n }\\n\\n function challenger() public view returns (address) {\\n require(_challenger != address(0), \\\"FetchChainInfoOutput: challenger not set\\\");\\n return _challenger;\\n }\\n\\n function proposer() public view returns (address) {\\n require(_proposer != address(0), \\\"FetchChainInfoOutput: proposer not set\\\");\\n return _proposer;\\n }\\n\\n function unsafeBlockSigner() public view returns (address) {\\n require(_unsafeBlockSigner != address(0), \\\"FetchChainInfoOutput: unsafeBlockSigner not set\\\");\\n return _unsafeBlockSigner;\\n }\\n\\n function batchSubmitter() public view returns (address) {\\n require(_batchSubmitter != address(0), \\\"FetchChainInfoOutput: batchSubmitter not set\\\");\\n return _batchSubmitter;\\n }\\n\\n function permissioned() public view returns (bool) {\\n return _permissioned;\\n }\\n\\n function permissionless() public view returns (bool) {\\n return _permissionless;\\n }\\n\\n function respectedGameType() public view returns (GameType) {\\n return _respectedGameType;\\n }\\n}\\n\\ncontract FetchChainInfo is Script {\\n function run(FetchChainInfoInput _fi, FetchChainInfoOutput _fo) public {\\n _processSystemConfig(_fi, _fo);\\n _processMessengerAndPortal(_fi, _fo);\\n _processFaultProofs(_fo);\\n }\\n\\n function _processSystemConfig(FetchChainInfoInput _fi, FetchChainInfoOutput _fo) internal {\\n address systemConfigProxy = _fi.systemConfigProxy();\\n _fo.set(_fo.systemConfigProxy.selector, systemConfigProxy);\\n\\n address systemConfigOwner = IFetcher(systemConfigProxy).owner();\\n _fo.set(_fo.systemConfigOwner.selector, systemConfigOwner);\\n\\n address unsafeBlockSigner = IFetcher(systemConfigProxy).unsafeBlockSigner();\\n _fo.set(_fo.unsafeBlockSigner.selector, unsafeBlockSigner);\\n\\n address batchSubmitter = _getBatchSubmitter(systemConfigProxy);\\n _fo.set(_fo.batchSubmitter.selector, batchSubmitter);\\n\\n address opChainProxyAdminImpl = _getProxyAdmin(systemConfigProxy);\\n _fo.set(_fo.opChainProxyAdminImpl.selector, opChainProxyAdminImpl);\\n\\n address opChainProxyAdminOwner = IFetcher(opChainProxyAdminImpl).owner();\\n _fo.set(_fo.opChainProxyAdminOwner.selector, opChainProxyAdminOwner);\\n\\n address l1Erc721BridgeProxy = _getL1ERC721BridgeProxy(systemConfigProxy);\\n _fo.set(_fo.l1Erc721BridgeProxy.selector, l1Erc721BridgeProxy);\\n\\n address optimismMintableErc20FactoryProxy = _getOptimismMintableERC20FactoryProxy(systemConfigProxy);\\n _fo.set(_fo.optimismMintableErc20FactoryProxy.selector, optimismMintableErc20FactoryProxy);\\n }\\n\\n function _processMessengerAndPortal(FetchChainInfoInput _fi, FetchChainInfoOutput _fo) internal {\\n address l1StandardBridgeProxy = _fi.l1StandardBridgeProxy();\\n _fo.set(_fo.l1StandardBridgeProxy.selector, l1StandardBridgeProxy);\\n\\n address l1CrossDomainMessengerProxy = IFetcher(l1StandardBridgeProxy).messenger();\\n _fo.set(_fo.l1CrossDomainMessengerProxy.selector, l1CrossDomainMessengerProxy);\\n\\n address addressManagerImpl = _getAddressManager(l1CrossDomainMessengerProxy);\\n _fo.set(_fo.addressManagerImpl.selector, addressManagerImpl);\\n\\n address optimismPortalProxy = _getOptimismPortalProxy(l1CrossDomainMessengerProxy);\\n _fo.set(_fo.optimismPortalProxy.selector, optimismPortalProxy);\\n\\n address opChainGuardian = _getGuardian(optimismPortalProxy);\\n _fo.set(_fo.opChainGuardian.selector, opChainGuardian);\\n\\n address ethLockboxProxy = _getEthLockboxProxy(optimismPortalProxy);\\n _fo.set(_fo.ethLockboxProxy.selector, ethLockboxProxy);\\n\\n address superchainConfigProxy = _getSuperchainConfigProxy(optimismPortalProxy);\\n _fo.set(_fo.superchainConfigProxy.selector, superchainConfigProxy);\\n }\\n\\n function _processFaultProofs(FetchChainInfoOutput _fo) internal {\\n address systemConfigProxy = _fo.systemConfigProxy();\\n address optimismPortalProxy = _fo.optimismPortalProxy();\\n\\n try IFetcher(optimismPortalProxy).respectedGameType() returns (GameType gameType_) {\\n _fo.set(_fo.respectedGameType.selector, gameType_);\\n } catch {\\n // default respectedGameType to uint32.max since 0 == CANNON\\n _fo.set(_fo.respectedGameType.selector, GameType.wrap(type(uint32).max));\\n address l2OutputOracleProxy;\\n try IFetcher(optimismPortalProxy).l2Oracle() returns (address l2Oracle_) {\\n l2OutputOracleProxy = l2Oracle_;\\n } catch {\\n l2OutputOracleProxy = IFetcher(optimismPortalProxy).L2_ORACLE();\\n }\\n _fo.set(_fo.l2OutputOracleProxy.selector, l2OutputOracleProxy);\\n\\n address proposer = IFetcher(l2OutputOracleProxy).PROPOSER();\\n _fo.set(_fo.proposer.selector, proposer);\\n\\n // no fault proofs installed so we're done\\n return;\\n }\\n\\n address disputeGameFactoryProxy = _getDisputeGameFactoryProxy(systemConfigProxy);\\n if (disputeGameFactoryProxy != address(0)) {\\n _fo.set(_fo.disputeGameFactoryProxy.selector, disputeGameFactoryProxy);\\n\\n address permissionedDisputeGameImpl = _getPermissionedDisputeGame(disputeGameFactoryProxy);\\n if (permissionedDisputeGameImpl != address(0)) {\\n // permissioned fault proofs installed\\n _fo.set(_fo.permissioned.selector, true);\\n _fo.set(_fo.permissionedDisputeGameImpl.selector, permissionedDisputeGameImpl);\\n\\n address challenger = IFetcher(permissionedDisputeGameImpl).challenger();\\n _fo.set(_fo.challenger.selector, challenger);\\n\\n address anchorStateRegistryProxy = IFetcher(permissionedDisputeGameImpl).anchorStateRegistry();\\n _fo.set(_fo.anchorStateRegistryProxy.selector, anchorStateRegistryProxy);\\n\\n address proposer = IFetcher(permissionedDisputeGameImpl).proposer();\\n _fo.set(_fo.proposer.selector, proposer);\\n\\n address delayedWethPermissionedGameProxy = _getDelayedWETHProxy(permissionedDisputeGameImpl);\\n _fo.set(_fo.delayedWethPermissionedGameProxy.selector, delayedWethPermissionedGameProxy);\\n\\n address mipsImpl = IFetcher(permissionedDisputeGameImpl).vm();\\n _fo.set(_fo.mipsImpl.selector, mipsImpl);\\n\\n address preimageOracleImpl = IFetcher(mipsImpl).oracle();\\n _fo.set(_fo.preimageOracleImpl.selector, preimageOracleImpl);\\n }\\n\\n address faultDisputeGameImpl = _getFaultDisputeGame(disputeGameFactoryProxy);\\n if (faultDisputeGameImpl != address(0)) {\\n // permissionless fault proofs installed\\n _fo.set(_fo.faultDisputeGameImpl.selector, faultDisputeGameImpl);\\n _fo.set(_fo.permissionless.selector, true);\\n\\n address delayedWethPermissionlessGameProxy = _getDelayedWETHProxy(faultDisputeGameImpl);\\n _fo.set(_fo.delayedWethPermissionlessGameProxy.selector, delayedWethPermissionlessGameProxy);\\n }\\n } else {\\n // some older chains have L2OutputOracle instead of DisputeGameFactory.\\n address l2OutputOracleProxy = IFetcher(optimismPortalProxy).L2_ORACLE();\\n _fo.set(_fo.l2OutputOracleProxy.selector, l2OutputOracleProxy);\\n address proposer = IFetcher(l2OutputOracleProxy).PROPOSER();\\n _fo.set(_fo.proposer.selector, proposer);\\n }\\n }\\n\\n function _getGuardian(address _portal) internal view returns (address) {\\n try IFetcher(_portal).guardian() returns (address guardian_) {\\n return guardian_;\\n } catch {\\n return IFetcher(_portal).GUARDIAN();\\n }\\n }\\n\\n function _getSystemConfigProxy(address _portal) internal view returns (address) {\\n try IFetcher(_portal).systemConfig() returns (address systemConfig_) {\\n return systemConfig_;\\n } catch {\\n return IFetcher(_portal).SYSTEM_CONFIG();\\n }\\n }\\n\\n function _getOptimismPortalProxy(address _l1CrossDomainMessengerProxy) internal view returns (address) {\\n try IFetcher(_l1CrossDomainMessengerProxy).portal() returns (address optimismPortal_) {\\n return optimismPortal_;\\n } catch {\\n return IFetcher(_l1CrossDomainMessengerProxy).PORTAL();\\n }\\n }\\n\\n function _getAddressManager(address _l1CrossDomainMessengerProxy) internal view returns (address) {\\n uint256 ADDRESS_MANAGER_MAPPING_SLOT = 1;\\n bytes32 slot = keccak256(abi.encode(_l1CrossDomainMessengerProxy, ADDRESS_MANAGER_MAPPING_SLOT));\\n return address(uint160(uint256((vm.load(_l1CrossDomainMessengerProxy, slot)))));\\n }\\n\\n function _getL1ERC721BridgeProxy(address _systemConfigProxy) internal view returns (address) {\\n try IFetcher(_systemConfigProxy).l1ERC721Bridge() returns (address l1ERC721BridgeProxy_) {\\n return l1ERC721BridgeProxy_;\\n } catch {\\n return address(0);\\n }\\n }\\n\\n function _getOptimismMintableERC20FactoryProxy(address _systemConfigProxy) internal view returns (address) {\\n try IFetcher(_systemConfigProxy).optimismMintableERC20Factory() returns (\\n address optimismMintableERC20FactoryProxy_\\n ) {\\n return optimismMintableERC20FactoryProxy_;\\n } catch {\\n return address(0);\\n }\\n }\\n\\n function _getDisputeGameFactoryProxy(address _systemConfigProxy) internal view returns (address) {\\n try IFetcher(_systemConfigProxy).disputeGameFactory() returns (address disputeGameFactoryProxy_) {\\n return disputeGameFactoryProxy_;\\n } catch {\\n // Some older chains have L2OutputOracle instead of DisputeGameFactory\\n return address(0);\\n }\\n }\\n\\n function _getSuperchainConfigProxy(address _optimismPortalProxy) internal view returns (address) {\\n try IFetcher(_optimismPortalProxy).superchainConfig() returns (address superchainConfigProxy_) {\\n return superchainConfigProxy_;\\n } catch {\\n return address(0);\\n }\\n }\\n\\n function _getFaultDisputeGame(address _disputeGameFactoryProxy) internal view returns (address) {\\n try IFetcher(_disputeGameFactoryProxy).gameImpls(GameTypes.CANNON) returns (address faultDisputeGame_) {\\n return faultDisputeGame_;\\n } catch {\\n return address(0);\\n }\\n }\\n\\n function _getPermissionedDisputeGame(address _disputeGameFactoryProxy) internal view returns (address) {\\n try IFetcher(_disputeGameFactoryProxy).gameImpls(GameTypes.PERMISSIONED_CANNON) returns (\\n address permissionedDisputeGame_\\n ) {\\n return permissionedDisputeGame_;\\n } catch {\\n return address(0);\\n }\\n }\\n\\n function _getEthLockboxProxy(address _optimismPortalProxy) internal view returns (address) {\\n try IFetcher(_optimismPortalProxy).ethLockbox() returns (address ethLockbox_) {\\n return ethLockbox_;\\n } catch {\\n return address(0);\\n }\\n }\\n\\n function _getDelayedWETHProxy(address _disputeGame) internal view returns (address) {\\n (bool ok, bytes memory data) = address(_disputeGame).staticcall(abi.encodeCall(IFetcher.weth, ()));\\n if (ok && data.length == 32) return abi.decode(data, (address));\\n else return address(0);\\n }\\n\\n function _getBatchSubmitter(address _systemConfigProxy) internal view returns (address) {\\n bytes32 batcherHash = IFetcher(_systemConfigProxy).batcherHash();\\n return address(uint160(uint256(batcherHash)));\\n }\\n\\n function _getProxyAdmin(address _systemConfigProxy) internal returns (address) {\\n vm.prank(address(0));\\n return IFetcher(_systemConfigProxy).admin();\\n }\\n}\\n\",\"keccak256\":\"0x202fb27a5a78b7d8c96c3a4ea69981dc4eeda765aa2747699ac80b8499feb709\",\"license\":\"MIT\"},\"src/dispute/lib/LibPosition.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.15;\\n\\nusing LibPosition for Position global;\\n\\n/// @notice A `Position` represents a position of a claim within the game tree.\\n/// @dev This is represented as a \\\"generalized index\\\" where the high-order bit\\n/// is the level in the tree and the remaining bits is a unique bit pattern, allowing\\n/// a unique identifier for each node in the tree. Mathematically, it is calculated\\n/// as 2^{depth} + indexAtDepth.\\ntype Position is uint128;\\n\\n/// @title LibPosition\\n/// @notice This library contains helper functions for working with the `Position` type.\\nlibrary LibPosition {\\n /// @notice the `MAX_POSITION_BITLEN` is the number of bits that the `Position` type, and the implementation of\\n /// its behavior within this library, can safely support.\\n uint8 internal constant MAX_POSITION_BITLEN = 126;\\n\\n /// @notice Computes a generalized index (2^{depth} + indexAtDepth).\\n /// @param _depth The depth of the position.\\n /// @param _indexAtDepth The index at the depth of the position.\\n /// @return position_ The computed generalized index.\\n function wrap(uint8 _depth, uint128 _indexAtDepth) internal pure returns (Position position_) {\\n assembly {\\n // gindex = 2^{_depth} + _indexAtDepth\\n position_ := add(shl(_depth, 1), _indexAtDepth)\\n }\\n }\\n\\n /// @notice Pulls the `depth` out of a `Position` type.\\n /// @param _position The generalized index to get the `depth` of.\\n /// @return depth_ The `depth` of the `position` gindex.\\n /// @custom:attribution Solady \\n function depth(Position _position) internal pure returns (uint8 depth_) {\\n // Return the most significant bit offset, which signifies the depth of the gindex.\\n assembly {\\n depth_ := or(depth_, shl(6, lt(0xffffffffffffffff, shr(depth_, _position))))\\n depth_ := or(depth_, shl(5, lt(0xffffffff, shr(depth_, _position))))\\n\\n // For the remaining 32 bits, use a De Bruijn lookup.\\n _position := shr(depth_, _position)\\n _position := or(_position, shr(1, _position))\\n _position := or(_position, shr(2, _position))\\n _position := or(_position, shr(4, _position))\\n _position := or(_position, shr(8, _position))\\n _position := or(_position, shr(16, _position))\\n\\n depth_ :=\\n or(\\n depth_,\\n byte(\\n shr(251, mul(_position, shl(224, 0x07c4acdd))),\\n 0x0009010a0d15021d0b0e10121619031e080c141c0f111807131b17061a05041f\\n )\\n )\\n }\\n }\\n\\n /// @notice Pulls the `indexAtDepth` out of a `Position` type.\\n /// The `indexAtDepth` is the left/right index of a position at a specific depth within\\n /// the binary tree, starting from index 0. For example, at gindex 2, the `depth` = 1\\n /// and the `indexAtDepth` = 0.\\n /// @param _position The generalized index to get the `indexAtDepth` of.\\n /// @return indexAtDepth_ The `indexAtDepth` of the `position` gindex.\\n function indexAtDepth(Position _position) internal pure returns (uint128 indexAtDepth_) {\\n // Return bits p_{msb-1}...p_{0}. This effectively pulls the 2^{depth} out of the gindex,\\n // leaving only the `indexAtDepth`.\\n uint256 msb = depth(_position);\\n assembly {\\n indexAtDepth_ := sub(_position, shl(msb, 1))\\n }\\n }\\n\\n /// @notice Get the left child of `_position`.\\n /// @param _position The position to get the left position of.\\n /// @return left_ The position to the left of `position`.\\n function left(Position _position) internal pure returns (Position left_) {\\n assembly {\\n left_ := shl(1, _position)\\n }\\n }\\n\\n /// @notice Get the right child of `_position`\\n /// @param _position The position to get the right position of.\\n /// @return right_ The position to the right of `position`.\\n function right(Position _position) internal pure returns (Position right_) {\\n assembly {\\n right_ := or(1, shl(1, _position))\\n }\\n }\\n\\n /// @notice Get the parent position of `_position`.\\n /// @param _position The position to get the parent position of.\\n /// @return parent_ The parent position of `position`.\\n function parent(Position _position) internal pure returns (Position parent_) {\\n assembly {\\n parent_ := shr(1, _position)\\n }\\n }\\n\\n /// @notice Get the deepest, right most gindex relative to the `position`. This is equivalent to\\n /// calling `right` on a position until the maximum depth is reached.\\n /// @param _position The position to get the relative deepest, right most gindex of.\\n /// @param _maxDepth The maximum depth of the game.\\n /// @return rightIndex_ The deepest, right most gindex relative to the `position`.\\n function rightIndex(Position _position, uint256 _maxDepth) internal pure returns (Position rightIndex_) {\\n uint256 msb = depth(_position);\\n assembly {\\n let remaining := sub(_maxDepth, msb)\\n rightIndex_ := or(shl(remaining, _position), sub(shl(remaining, 1), 1))\\n }\\n }\\n\\n /// @notice Get the deepest, right most trace index relative to the `position`. This is\\n /// equivalent to calling `right` on a position until the maximum depth is reached and\\n /// then finding its index at depth.\\n /// @param _position The position to get the relative trace index of.\\n /// @param _maxDepth The maximum depth of the game.\\n /// @return traceIndex_ The trace index relative to the `position`.\\n function traceIndex(Position _position, uint256 _maxDepth) internal pure returns (uint256 traceIndex_) {\\n uint256 msb = depth(_position);\\n assembly {\\n let remaining := sub(_maxDepth, msb)\\n traceIndex_ := sub(or(shl(remaining, _position), sub(shl(remaining, 1), 1)), shl(_maxDepth, 1))\\n }\\n }\\n\\n /// @notice Gets the position of the highest ancestor of `_position` that commits to the same\\n /// trace index.\\n /// @param _position The position to get the highest ancestor of.\\n /// @return ancestor_ The highest ancestor of `position` that commits to the same trace index.\\n function traceAncestor(Position _position) internal pure returns (Position ancestor_) {\\n // Create a field with only the lowest unset bit of `_position` set.\\n Position lsb;\\n assembly {\\n lsb := and(not(_position), add(_position, 1))\\n }\\n // Find the index of the lowest unset bit within the field.\\n uint256 msb = depth(lsb);\\n // The highest ancestor that commits to the same trace index is the original position\\n // shifted right by the index of the lowest unset bit.\\n assembly {\\n let a := shr(msb, _position)\\n // Bound the ancestor to the minimum gindex, 1.\\n ancestor_ := or(a, iszero(a))\\n }\\n }\\n\\n /// @notice Gets the position of the highest ancestor of `_position` that commits to the same\\n /// trace index, while still being below `_upperBoundExclusive`.\\n /// @param _position The position to get the highest ancestor of.\\n /// @param _upperBoundExclusive The exclusive upper depth bound, used to inform where to stop in order\\n /// to not escape a sub-tree.\\n /// @return ancestor_ The highest ancestor of `position` that commits to the same trace index.\\n function traceAncestorBounded(\\n Position _position,\\n uint256 _upperBoundExclusive\\n )\\n internal\\n pure\\n returns (Position ancestor_)\\n {\\n // This function only works for positions that are below the upper bound.\\n if (_position.depth() <= _upperBoundExclusive) {\\n assembly {\\n // Revert with `ClaimAboveSplit()`\\n mstore(0x00, 0xb34b5c22)\\n revert(0x1C, 0x04)\\n }\\n }\\n\\n // Grab the global trace ancestor.\\n ancestor_ = traceAncestor(_position);\\n\\n // If the ancestor is above or at the upper bound, shift it to be below the upper bound.\\n // This should be a special case that only covers positions that commit to the final leaf\\n // in a sub-tree.\\n if (ancestor_.depth() <= _upperBoundExclusive) {\\n ancestor_ = ancestor_.rightIndex(_upperBoundExclusive + 1);\\n }\\n }\\n\\n /// @notice Get the move position of `_position`, which is the left child of:\\n /// 1. `_position` if `_isAttack` is true.\\n /// 2. `_position | 1` if `_isAttack` is false.\\n /// @param _position The position to get the relative attack/defense position of.\\n /// @param _isAttack Whether or not the move is an attack move.\\n /// @return move_ The move position relative to `position`.\\n function move(Position _position, bool _isAttack) internal pure returns (Position move_) {\\n assembly {\\n move_ := shl(1, or(iszero(_isAttack), _position))\\n }\\n }\\n\\n /// @notice Get the value of a `Position` type in the form of the underlying uint128.\\n /// @param _position The position to get the value of.\\n /// @return raw_ The value of the `position` as a uint128 type.\\n function raw(Position _position) internal pure returns (uint128 raw_) {\\n assembly {\\n raw_ := _position\\n }\\n }\\n}\\n\",\"keccak256\":\"0x7c5f19f8f54f06de2ce1c6cdcc5c7af65ac405130a4066cdaf146ca315818241\",\"license\":\"MIT\"},\"src/dispute/lib/LibUDT.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.15;\\n\\n// Libraries\\nimport { Position } from \\\"src/dispute/lib/LibPosition.sol\\\";\\n\\nusing LibClaim for Claim global;\\nusing LibHash for Hash global;\\nusing LibDuration for Duration global;\\nusing LibClock for Clock global;\\nusing LibGameId for GameId global;\\nusing LibTimestamp for Timestamp global;\\nusing LibVMStatus for VMStatus global;\\nusing LibGameType for GameType global;\\n\\n/// @notice A `Clock` represents a packed `Duration` and `Timestamp`\\n/// @dev The packed layout of this type is as follows:\\n/// \\u250c\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u252c\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2510\\n/// \\u2502 Bits \\u2502 Value \\u2502\\n/// \\u251c\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u253c\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2524\\n/// \\u2502 [0, 64) \\u2502 Duration \\u2502\\n/// \\u2502 [64, 128) \\u2502 Timestamp \\u2502\\n/// \\u2514\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2534\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2518\\ntype Clock is uint128;\\n\\n/// @title LibClock\\n/// @notice This library contains helper functions for working with the `Clock` type.\\nlibrary LibClock {\\n /// @notice Packs a `Duration` and `Timestamp` into a `Clock` type.\\n /// @param _duration The `Duration` to pack into the `Clock` type.\\n /// @param _timestamp The `Timestamp` to pack into the `Clock` type.\\n /// @return clock_ The `Clock` containing the `_duration` and `_timestamp`.\\n function wrap(Duration _duration, Timestamp _timestamp) internal pure returns (Clock clock_) {\\n assembly {\\n clock_ := or(shl(0x40, _duration), _timestamp)\\n }\\n }\\n\\n /// @notice Pull the `Duration` out of a `Clock` type.\\n /// @param _clock The `Clock` type to pull the `Duration` out of.\\n /// @return duration_ The `Duration` pulled out of `_clock`.\\n function duration(Clock _clock) internal pure returns (Duration duration_) {\\n // Shift the high-order 64 bits into the low-order 64 bits, leaving only the `duration`.\\n assembly {\\n duration_ := shr(0x40, _clock)\\n }\\n }\\n\\n /// @notice Pull the `Timestamp` out of a `Clock` type.\\n /// @param _clock The `Clock` type to pull the `Timestamp` out of.\\n /// @return timestamp_ The `Timestamp` pulled out of `_clock`.\\n function timestamp(Clock _clock) internal pure returns (Timestamp timestamp_) {\\n // Clean the high-order 192 bits by shifting the clock left and then right again, leaving\\n // only the `timestamp`.\\n assembly {\\n timestamp_ := shr(0xC0, shl(0xC0, _clock))\\n }\\n }\\n\\n /// @notice Get the value of a `Clock` type in the form of the underlying uint128.\\n /// @param _clock The `Clock` type to get the value of.\\n /// @return clock_ The value of the `Clock` type as a uint128 type.\\n function raw(Clock _clock) internal pure returns (uint128 clock_) {\\n assembly {\\n clock_ := _clock\\n }\\n }\\n}\\n\\n/// @notice A `GameId` represents a packed 4 byte game ID, a 8 byte timestamp, and a 20 byte address.\\n/// @dev The packed layout of this type is as follows:\\n/// \\u250c\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u252c\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2510\\n/// \\u2502 Bits \\u2502 Value \\u2502\\n/// \\u251c\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u253c\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2524\\n/// \\u2502 [0, 32) \\u2502 Game Type \\u2502\\n/// \\u2502 [32, 96) \\u2502 Timestamp \\u2502\\n/// \\u2502 [96, 256) \\u2502 Address \\u2502\\n/// \\u2514\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2534\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2518\\ntype GameId is bytes32;\\n\\n/// @title LibGameId\\n/// @notice Utility functions for packing and unpacking GameIds.\\nlibrary LibGameId {\\n /// @notice Packs values into a 32 byte GameId type.\\n /// @param _gameType The game type.\\n /// @param _timestamp The timestamp of the game's creation.\\n /// @param _gameProxy The game proxy address.\\n /// @return gameId_ The packed GameId.\\n function pack(\\n GameType _gameType,\\n Timestamp _timestamp,\\n address _gameProxy\\n )\\n internal\\n pure\\n returns (GameId gameId_)\\n {\\n assembly {\\n gameId_ := or(or(shl(224, _gameType), shl(160, _timestamp)), _gameProxy)\\n }\\n }\\n\\n /// @notice Unpacks values from a 32 byte GameId type.\\n /// @param _gameId The packed GameId.\\n /// @return gameType_ The game type.\\n /// @return timestamp_ The timestamp of the game's creation.\\n /// @return gameProxy_ The game proxy address.\\n function unpack(GameId _gameId)\\n internal\\n pure\\n returns (GameType gameType_, Timestamp timestamp_, address gameProxy_)\\n {\\n assembly {\\n gameType_ := shr(224, _gameId)\\n timestamp_ := and(shr(160, _gameId), 0xFFFFFFFFFFFFFFFF)\\n gameProxy_ := and(_gameId, 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF)\\n }\\n }\\n}\\n\\n/// @notice A claim represents an MPT root representing the state of the fault proof program.\\ntype Claim is bytes32;\\n\\n/// @title LibClaim\\n/// @notice This library contains helper functions for working with the `Claim` type.\\nlibrary LibClaim {\\n /// @notice Get the value of a `Claim` type in the form of the underlying bytes32.\\n /// @param _claim The `Claim` type to get the value of.\\n /// @return claim_ The value of the `Claim` type as a bytes32 type.\\n function raw(Claim _claim) internal pure returns (bytes32 claim_) {\\n assembly {\\n claim_ := _claim\\n }\\n }\\n\\n /// @notice Hashes a claim and a position together.\\n /// @param _claim A Claim type.\\n /// @param _position The position of `claim`.\\n /// @param _challengeIndex The index of the claim being moved against.\\n /// @return claimHash_ A hash of abi.encodePacked(claim, position|challengeIndex);\\n function hashClaimPos(\\n Claim _claim,\\n Position _position,\\n uint256 _challengeIndex\\n )\\n internal\\n pure\\n returns (Hash claimHash_)\\n {\\n assembly {\\n mstore(0x00, _claim)\\n mstore(0x20, or(shl(128, _position), and(0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF, _challengeIndex)))\\n claimHash_ := keccak256(0x00, 0x40)\\n }\\n }\\n}\\n\\n/// @notice A dedicated duration type.\\n/// @dev Unit: seconds\\ntype Duration is uint64;\\n\\n/// @title LibDuration\\n/// @notice This library contains helper functions for working with the `Duration` type.\\nlibrary LibDuration {\\n /// @notice Get the value of a `Duration` type in the form of the underlying uint64.\\n /// @param _duration The `Duration` type to get the value of.\\n /// @return duration_ The value of the `Duration` type as a uint64 type.\\n function raw(Duration _duration) internal pure returns (uint64 duration_) {\\n assembly {\\n duration_ := _duration\\n }\\n }\\n}\\n\\n/// @notice A custom type for a generic hash.\\ntype Hash is bytes32;\\n\\n/// @title LibHash\\n/// @notice This library contains helper functions for working with the `Hash` type.\\nlibrary LibHash {\\n /// @notice Get the value of a `Hash` type in the form of the underlying bytes32.\\n /// @param _hash The `Hash` type to get the value of.\\n /// @return hash_ The value of the `Hash` type as a bytes32 type.\\n function raw(Hash _hash) internal pure returns (bytes32 hash_) {\\n assembly {\\n hash_ := _hash\\n }\\n }\\n}\\n\\n/// @notice A dedicated timestamp type.\\ntype Timestamp is uint64;\\n\\n/// @title LibTimestamp\\n/// @notice This library contains helper functions for working with the `Timestamp` type.\\nlibrary LibTimestamp {\\n /// @notice Get the value of a `Timestamp` type in the form of the underlying uint64.\\n /// @param _timestamp The `Timestamp` type to get the value of.\\n /// @return timestamp_ The value of the `Timestamp` type as a uint64 type.\\n function raw(Timestamp _timestamp) internal pure returns (uint64 timestamp_) {\\n assembly {\\n timestamp_ := _timestamp\\n }\\n }\\n}\\n\\n/// @notice A `VMStatus` represents the status of a VM execution.\\ntype VMStatus is uint8;\\n\\n/// @title LibVMStatus\\n/// @notice This library contains helper functions for working with the `VMStatus` type.\\nlibrary LibVMStatus {\\n /// @notice Get the value of a `VMStatus` type in the form of the underlying uint8.\\n /// @param _vmstatus The `VMStatus` type to get the value of.\\n /// @return vmstatus_ The value of the `VMStatus` type as a uint8 type.\\n function raw(VMStatus _vmstatus) internal pure returns (uint8 vmstatus_) {\\n assembly {\\n vmstatus_ := _vmstatus\\n }\\n }\\n}\\n\\n/// @notice A `GameType` represents the type of game being played.\\ntype GameType is uint32;\\n\\n/// @title LibGameType\\n/// @notice This library contains helper functions for working with the `GameType` type.\\nlibrary LibGameType {\\n /// @notice Get the value of a `GameType` type in the form of the underlying uint32.\\n /// @param _gametype The `GameType` type to get the value of.\\n /// @return gametype_ The value of the `GameType` type as a uint32 type.\\n function raw(GameType _gametype) internal pure returns (uint32 gametype_) {\\n assembly {\\n gametype_ := _gametype\\n }\\n }\\n}\\n\",\"keccak256\":\"0x41d55e9c74d979b5b797198e38449e7cef4f925e04d61f7699e9c150c4a659d3\",\"license\":\"MIT\"},\"src/dispute/lib/Types.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.15;\\n\\n// Libraries\\nimport {\\n Position,\\n Hash,\\n GameType,\\n VMStatus,\\n Timestamp,\\n Duration,\\n Clock,\\n GameId,\\n Claim,\\n LibGameId,\\n LibClock\\n} from \\\"src/dispute/lib/LibUDT.sol\\\";\\n\\n/// @notice The current status of the dispute game.\\nenum GameStatus {\\n // The game is currently in progress, and has not been resolved.\\n IN_PROGRESS,\\n // The game has concluded, and the `rootClaim` was challenged successfully.\\n CHALLENGER_WINS,\\n // The game has concluded, and the `rootClaim` could not be contested.\\n DEFENDER_WINS\\n}\\n\\n/// @notice The game's bond distribution type. Games are expected to start in the `UNDECIDED`\\n/// state, and then choose either `NORMAL` or `REFUND`.\\nenum BondDistributionMode {\\n // Bond distribution strategy has not been chosen.\\n UNDECIDED,\\n // Bonds should be distributed as normal.\\n NORMAL,\\n // Bonds should be refunded to claimants.\\n REFUND\\n}\\n\\n/// @notice Represents an L2 root and the L2 sequence number at which it was generated.\\n/// @custom:field root The output root.\\n/// @custom:field l2SequenceNumber The L2 Sequence Number ( e.g. block number / timestamp) at which the root was\\n/// generated.\\nstruct Proposal {\\n Hash root;\\n uint256 l2SequenceNumber;\\n}\\n\\n/// @title GameTypes\\n/// @notice A library that defines the IDs of games that can be played.\\nlibrary GameTypes {\\n /// @dev A dispute game type the uses the cannon vm.\\n GameType internal constant CANNON = GameType.wrap(0);\\n\\n /// @dev A permissioned dispute game type that uses the cannon vm.\\n GameType internal constant PERMISSIONED_CANNON = GameType.wrap(1);\\n\\n /// @notice A dispute game type that uses the asterisc vm.\\n GameType internal constant ASTERISC = GameType.wrap(2);\\n\\n /// @notice A dispute game type that uses the asterisc vm with Kona.\\n GameType internal constant ASTERISC_KONA = GameType.wrap(3);\\n\\n /// @notice A dispute game type that uses the cannon vm (Super Roots).\\n GameType internal constant SUPER_CANNON = GameType.wrap(4);\\n\\n /// @notice A dispute game type that uses the permissioned cannon vm (Super Roots).\\n GameType internal constant SUPER_PERMISSIONED_CANNON = GameType.wrap(5);\\n\\n /// @notice A dispute game type that uses OP Succinct\\n GameType internal constant OP_SUCCINCT = GameType.wrap(6);\\n\\n /// @notice A dispute game type with short game duration for testing withdrawals.\\n /// Not intended for production use.\\n GameType internal constant FAST = GameType.wrap(254);\\n\\n /// @notice A dispute game type that uses an alphabet vm.\\n /// Not intended for production use.\\n GameType internal constant ALPHABET = GameType.wrap(255);\\n\\n /// @notice A dispute game type that uses RISC Zero's Kailua\\n GameType internal constant KAILUA = GameType.wrap(1337);\\n}\\n\\n/// @title VMStatuses\\n/// @notice Named type aliases for the various valid VM status bytes.\\nlibrary VMStatuses {\\n /// @notice The VM has executed successfully and the outcome is valid.\\n VMStatus internal constant VALID = VMStatus.wrap(0);\\n\\n /// @notice The VM has executed successfully and the outcome is invalid.\\n VMStatus internal constant INVALID = VMStatus.wrap(1);\\n\\n /// @notice The VM has paniced.\\n VMStatus internal constant PANIC = VMStatus.wrap(2);\\n\\n /// @notice The VM execution is still in progress.\\n VMStatus internal constant UNFINISHED = VMStatus.wrap(3);\\n}\\n\\n/// @title LocalPreimageKey\\n/// @notice Named type aliases for local `PreimageOracle` key identifiers.\\nlibrary LocalPreimageKey {\\n /// @notice The identifier for the L1 head hash.\\n uint256 internal constant L1_HEAD_HASH = 0x01;\\n\\n /// @notice The identifier for the starting output root.\\n uint256 internal constant STARTING_OUTPUT_ROOT = 0x02;\\n\\n /// @notice The identifier for the disputed output root.\\n uint256 internal constant DISPUTED_OUTPUT_ROOT = 0x03;\\n\\n /// @notice The identifier for the disputed L2 block number.\\n uint256 internal constant DISPUTED_L2_BLOCK_NUMBER = 0x04;\\n\\n /// @notice The identifier for the chain ID.\\n uint256 internal constant CHAIN_ID = 0x05;\\n}\\n\",\"keccak256\":\"0x7cc2960ea5c5223d81ae2156a966fa0226b70f9666932aca63a0a2a45c9182ae\",\"license\":\"MIT\"}},\"version\":1}","metadata":{"compiler":{"version":"0.8.25+commit.b61c2a91"},"language":"Solidity","output":{"abi":[{"inputs":[],"stateMutability":"view","type":"function","name":"IS_SCRIPT","outputs":[{"internalType":"bool","name":"","type":"bool"}]},{"inputs":[{"internalType":"contract FetchChainInfoInput","name":"_fi","type":"address"},{"internalType":"contract FetchChainInfoOutput","name":"_fo","type":"address"}],"stateMutability":"nonpayable","type":"function","name":"run"}],"devdoc":{"kind":"dev","methods":{},"version":1},"userdoc":{"kind":"user","methods":{},"version":1}},"settings":{"remappings":["@lib-keccak/=lib/lib-keccak/contracts/lib/","@openzeppelin/contracts-upgradeable/=lib/openzeppelin-contracts-upgradeable/contracts/","@openzeppelin/contracts-v5/=lib/openzeppelin-contracts-v5/contracts/","@openzeppelin/contracts/=lib/openzeppelin-contracts/contracts/","@rari-capital/solmate/=lib/solmate/","@solady-test/=lib/lib-keccak/lib/solady/test/","@solady-v0.0.245/=lib/solady-v0.0.245/src/","@solady/=lib/solady/src/","ds-test/=lib/forge-std/lib/ds-test/src/","erc4626-tests/=lib/openzeppelin-contracts-v5/lib/erc4626-tests/","forge-std/=lib/forge-std/src/","interfaces/=interfaces/","kontrol-cheatcodes/=lib/kontrol-cheatcodes/src/","lib-keccak/=lib/lib-keccak/contracts/","openzeppelin-contracts-upgradeable/=lib/openzeppelin-contracts-upgradeable/","openzeppelin-contracts-v5/=lib/openzeppelin-contracts-v5/","openzeppelin-contracts/=lib/openzeppelin-contracts/","safe-contracts/=lib/safe-contracts/contracts/","solady-v0.0.245/=lib/solady-v0.0.245/src/","solady/=lib/solady/","solmate/=lib/solmate/src/"],"optimizer":{"enabled":false,"runs":999999},"metadata":{"useLiteralContent":true,"bytecodeHash":"none"},"compilationTarget":{"scripts/FetchChainInfo.s.sol":"FetchChainInfo"},"evmVersion":"cancun","libraries":{}},"sources":{"lib/forge-std/src/Base.sol":{"keccak256":"0xa3735a6618a3014e42bb4329ad143e3b2c59cd95094350202e4c4a06c9d585dd","urls":[],"content":"// SPDX-License-Identifier: MIT\npragma solidity >=0.6.2 <0.9.0;\n\nimport {StdStorage} from \"./StdStorage.sol\";\nimport {Vm, VmSafe} from \"./Vm.sol\";\n\nabstract contract CommonBase {\n /// @dev Cheat code address.\n /// Calculated as `address(uint160(uint256(keccak256(\"hevm cheat code\"))))`.\n address internal constant VM_ADDRESS = 0x7109709ECfa91a80626fF3989D68f67F5b1DD12D;\n /// @dev console.sol and console2.sol work by executing a staticcall to this address.\n /// Calculated as `address(uint160(uint88(bytes11(\"console.log\"))))`.\n address internal constant CONSOLE = 0x000000000000000000636F6e736F6c652e6c6f67;\n /// @dev Used when deploying with create2.\n /// Taken from https://github.com/Arachnid/deterministic-deployment-proxy.\n address internal constant CREATE2_FACTORY = 0x4e59b44847b379578588920cA78FbF26c0B4956C;\n /// @dev The default address for tx.origin and msg.sender.\n /// Calculated as `address(uint160(uint256(keccak256(\"foundry default caller\"))))`.\n address internal constant DEFAULT_SENDER = 0x1804c8AB1F12E6bbf3894d4083f33e07309d1f38;\n /// @dev The address of the first contract `CREATE`d by a running test contract.\n /// When running tests, each test contract is `CREATE`d by `DEFAULT_SENDER` with nonce 1.\n /// Calculated as `VM.computeCreateAddress(VM.computeCreateAddress(DEFAULT_SENDER, 1), 1)`.\n address internal constant DEFAULT_TEST_CONTRACT = 0x5615dEB798BB3E4dFa0139dFa1b3D433Cc23b72f;\n /// @dev Deterministic deployment address of the Multicall3 contract.\n /// Taken from https://www.multicall3.com.\n address internal constant MULTICALL3_ADDRESS = 0xcA11bde05977b3631167028862bE2a173976CA11;\n /// @dev The order of the secp256k1 curve.\n uint256 internal constant SECP256K1_ORDER =\n 115792089237316195423570985008687907852837564279074904382605163141518161494337;\n\n uint256 internal constant UINT256_MAX =\n 115792089237316195423570985008687907853269984665640564039457584007913129639935;\n\n Vm internal constant vm = Vm(VM_ADDRESS);\n StdStorage internal stdstore;\n}\n\nabstract contract TestBase is CommonBase {}\n\nabstract contract ScriptBase is CommonBase {\n VmSafe internal constant vmSafe = VmSafe(VM_ADDRESS);\n}\n","license":"MIT"},"lib/forge-std/src/Script.sol":{"keccak256":"0xc942e27c7baae499beb01afbbae99f24d42af9a6e4aae675bc6901b704aa8e9b","urls":[],"content":"// SPDX-License-Identifier: MIT\npragma solidity >=0.6.2 <0.9.0;\n\n// 💬 ABOUT\n// Forge Std's default Script.\n\n// 🧩 MODULES\nimport {console} from \"./console.sol\";\nimport {console2} from \"./console2.sol\";\nimport {safeconsole} from \"./safeconsole.sol\";\nimport {StdChains} from \"./StdChains.sol\";\nimport {StdCheatsSafe} from \"./StdCheats.sol\";\nimport {StdConstants} from \"./StdConstants.sol\";\nimport {stdJson} from \"./StdJson.sol\";\nimport {stdMath} from \"./StdMath.sol\";\nimport {StdStorage, stdStorageSafe} from \"./StdStorage.sol\";\nimport {StdStyle} from \"./StdStyle.sol\";\nimport {StdUtils} from \"./StdUtils.sol\";\nimport {VmSafe} from \"./Vm.sol\";\n\n// 📦 BOILERPLATE\nimport {ScriptBase} from \"./Base.sol\";\n\n// ⭐️ SCRIPT\nabstract contract Script is ScriptBase, StdChains, StdCheatsSafe, StdUtils {\n // Note: IS_SCRIPT() must return true.\n bool public IS_SCRIPT = true;\n}\n","license":"MIT"},"lib/forge-std/src/StdChains.sol":{"keccak256":"0x200b597cd01c229633b4a2317846cac7d36d337e2381b4a2e81faac23c2ad1cf","urls":[],"content":"// SPDX-License-Identifier: MIT\npragma solidity >=0.6.2 <0.9.0;\n\nimport {VmSafe} from \"./Vm.sol\";\n\n/**\n * StdChains provides information about EVM compatible chains that can be used in scripts/tests.\n * For each chain, the chain's name, chain ID, and a default RPC URL are provided. Chains are\n * identified by their alias, which is the same as the alias in the `[rpc_endpoints]` section of\n * the `foundry.toml` file. For best UX, ensure the alias in the `foundry.toml` file match the\n * alias used in this contract, which can be found as the first argument to the\n * `setChainWithDefaultRpcUrl` call in the `initializeStdChains` function.\n *\n * There are two main ways to use this contract:\n * 1. Set a chain with `setChain(string memory chainAlias, ChainData memory chain)` or\n * `setChain(string memory chainAlias, Chain memory chain)`\n * 2. Get a chain with `getChain(string memory chainAlias)` or `getChain(uint256 chainId)`.\n *\n * The first time either of those are used, chains are initialized with the default set of RPC URLs.\n * This is done in `initializeStdChains`, which uses `setChainWithDefaultRpcUrl`. Defaults are recorded in\n * `defaultRpcUrls`.\n *\n * The `setChain` function is straightforward, and it simply saves off the given chain data.\n *\n * The `getChain` methods use `getChainWithUpdatedRpcUrl` to return a chain. For example, let's say\n * we want to retrieve the RPC URL for `mainnet`:\n * - If you have specified data with `setChain`, it will return that.\n * - If you have configured a mainnet RPC URL in `foundry.toml`, it will return the URL, provided it\n * is valid (e.g. a URL is specified, or an environment variable is given and exists).\n * - If neither of the above conditions is met, the default data is returned.\n *\n * Summarizing the above, the prioritization hierarchy is `setChain` -> `foundry.toml` -> environment variable -> defaults.\n */\nabstract contract StdChains {\n VmSafe private constant vm = VmSafe(address(uint160(uint256(keccak256(\"hevm cheat code\")))));\n\n bool private stdChainsInitialized;\n\n struct ChainData {\n string name;\n uint256 chainId;\n string rpcUrl;\n }\n\n struct Chain {\n // The chain name.\n string name;\n // The chain's Chain ID.\n uint256 chainId;\n // The chain's alias. (i.e. what gets specified in `foundry.toml`).\n string chainAlias;\n // A default RPC endpoint for this chain.\n // NOTE: This default RPC URL is included for convenience to facilitate quick tests and\n // experimentation. Do not use this RPC URL for production test suites, CI, or other heavy\n // usage as you will be throttled and this is a disservice to others who need this endpoint.\n string rpcUrl;\n }\n\n // Maps from the chain's alias (matching the alias in the `foundry.toml` file) to chain data.\n mapping(string => Chain) private chains;\n // Maps from the chain's alias to it's default RPC URL.\n mapping(string => string) private defaultRpcUrls;\n // Maps from a chain ID to it's alias.\n mapping(uint256 => string) private idToAlias;\n\n bool private fallbackToDefaultRpcUrls = true;\n\n // The RPC URL will be fetched from config or defaultRpcUrls if possible.\n function getChain(string memory chainAlias) internal virtual returns (Chain memory chain) {\n require(bytes(chainAlias).length != 0, \"StdChains getChain(string): Chain alias cannot be the empty string.\");\n\n initializeStdChains();\n chain = chains[chainAlias];\n require(\n chain.chainId != 0,\n string(abi.encodePacked(\"StdChains getChain(string): Chain with alias \\\"\", chainAlias, \"\\\" not found.\"))\n );\n\n chain = getChainWithUpdatedRpcUrl(chainAlias, chain);\n }\n\n function getChain(uint256 chainId) internal virtual returns (Chain memory chain) {\n require(chainId != 0, \"StdChains getChain(uint256): Chain ID cannot be 0.\");\n initializeStdChains();\n string memory chainAlias = idToAlias[chainId];\n\n chain = chains[chainAlias];\n\n require(\n chain.chainId != 0,\n string(abi.encodePacked(\"StdChains getChain(uint256): Chain with ID \", vm.toString(chainId), \" not found.\"))\n );\n\n chain = getChainWithUpdatedRpcUrl(chainAlias, chain);\n }\n\n // set chain info, with priority to argument's rpcUrl field.\n function setChain(string memory chainAlias, ChainData memory chain) internal virtual {\n require(\n bytes(chainAlias).length != 0,\n \"StdChains setChain(string,ChainData): Chain alias cannot be the empty string.\"\n );\n\n require(chain.chainId != 0, \"StdChains setChain(string,ChainData): Chain ID cannot be 0.\");\n\n initializeStdChains();\n string memory foundAlias = idToAlias[chain.chainId];\n\n require(\n bytes(foundAlias).length == 0 || keccak256(bytes(foundAlias)) == keccak256(bytes(chainAlias)),\n string(\n abi.encodePacked(\n \"StdChains setChain(string,ChainData): Chain ID \",\n vm.toString(chain.chainId),\n \" already used by \\\"\",\n foundAlias,\n \"\\\".\"\n )\n )\n );\n\n uint256 oldChainId = chains[chainAlias].chainId;\n delete idToAlias[oldChainId];\n\n chains[chainAlias] =\n Chain({name: chain.name, chainId: chain.chainId, chainAlias: chainAlias, rpcUrl: chain.rpcUrl});\n idToAlias[chain.chainId] = chainAlias;\n }\n\n // set chain info, with priority to argument's rpcUrl field.\n function setChain(string memory chainAlias, Chain memory chain) internal virtual {\n setChain(chainAlias, ChainData({name: chain.name, chainId: chain.chainId, rpcUrl: chain.rpcUrl}));\n }\n\n function _toUpper(string memory str) private pure returns (string memory) {\n bytes memory strb = bytes(str);\n bytes memory copy = new bytes(strb.length);\n for (uint256 i = 0; i < strb.length; i++) {\n bytes1 b = strb[i];\n if (b >= 0x61 && b <= 0x7A) {\n copy[i] = bytes1(uint8(b) - 32);\n } else {\n copy[i] = b;\n }\n }\n return string(copy);\n }\n\n // lookup rpcUrl, in descending order of priority:\n // current -> config (foundry.toml) -> environment variable -> default\n function getChainWithUpdatedRpcUrl(string memory chainAlias, Chain memory chain)\n private\n view\n returns (Chain memory)\n {\n if (bytes(chain.rpcUrl).length == 0) {\n try vm.rpcUrl(chainAlias) returns (string memory configRpcUrl) {\n chain.rpcUrl = configRpcUrl;\n } catch (bytes memory err) {\n string memory envName = string(abi.encodePacked(_toUpper(chainAlias), \"_RPC_URL\"));\n if (fallbackToDefaultRpcUrls) {\n chain.rpcUrl = vm.envOr(envName, defaultRpcUrls[chainAlias]);\n } else {\n chain.rpcUrl = vm.envString(envName);\n }\n // Distinguish 'not found' from 'cannot read'\n // The upstream error thrown by forge for failing cheats changed so we check both the old and new versions\n bytes memory oldNotFoundError =\n abi.encodeWithSignature(\"CheatCodeError\", string(abi.encodePacked(\"invalid rpc url \", chainAlias)));\n bytes memory newNotFoundError = abi.encodeWithSignature(\n \"CheatcodeError(string)\", string(abi.encodePacked(\"invalid rpc url: \", chainAlias))\n );\n bytes32 errHash = keccak256(err);\n if (\n (errHash != keccak256(oldNotFoundError) && errHash != keccak256(newNotFoundError))\n || bytes(chain.rpcUrl).length == 0\n ) {\n /// @solidity memory-safe-assembly\n assembly {\n revert(add(32, err), mload(err))\n }\n }\n }\n }\n return chain;\n }\n\n function setFallbackToDefaultRpcUrls(bool useDefault) internal {\n fallbackToDefaultRpcUrls = useDefault;\n }\n\n function initializeStdChains() private {\n if (stdChainsInitialized) return;\n\n stdChainsInitialized = true;\n\n // If adding an RPC here, make sure to test the default RPC URL in `test_Rpcs` in `StdChains.t.sol`\n setChainWithDefaultRpcUrl(\"anvil\", ChainData(\"Anvil\", 31337, \"http://127.0.0.1:8545\"));\n setChainWithDefaultRpcUrl(\"mainnet\", ChainData(\"Mainnet\", 1, \"https://eth.llamarpc.com\"));\n setChainWithDefaultRpcUrl(\n \"sepolia\", ChainData(\"Sepolia\", 11155111, \"https://sepolia.infura.io/v3/b9794ad1ddf84dfb8c34d6bb5dca2001\")\n );\n setChainWithDefaultRpcUrl(\"holesky\", ChainData(\"Holesky\", 17000, \"https://rpc.holesky.ethpandaops.io\"));\n setChainWithDefaultRpcUrl(\"optimism\", ChainData(\"Optimism\", 10, \"https://mainnet.optimism.io\"));\n setChainWithDefaultRpcUrl(\n \"optimism_sepolia\", ChainData(\"Optimism Sepolia\", 11155420, \"https://sepolia.optimism.io\")\n );\n setChainWithDefaultRpcUrl(\"arbitrum_one\", ChainData(\"Arbitrum One\", 42161, \"https://arb1.arbitrum.io/rpc\"));\n setChainWithDefaultRpcUrl(\n \"arbitrum_one_sepolia\", ChainData(\"Arbitrum One Sepolia\", 421614, \"https://sepolia-rollup.arbitrum.io/rpc\")\n );\n setChainWithDefaultRpcUrl(\"arbitrum_nova\", ChainData(\"Arbitrum Nova\", 42170, \"https://nova.arbitrum.io/rpc\"));\n setChainWithDefaultRpcUrl(\"polygon\", ChainData(\"Polygon\", 137, \"https://polygon-rpc.com\"));\n setChainWithDefaultRpcUrl(\n \"polygon_amoy\", ChainData(\"Polygon Amoy\", 80002, \"https://rpc-amoy.polygon.technology\")\n );\n setChainWithDefaultRpcUrl(\"avalanche\", ChainData(\"Avalanche\", 43114, \"https://api.avax.network/ext/bc/C/rpc\"));\n setChainWithDefaultRpcUrl(\n \"avalanche_fuji\", ChainData(\"Avalanche Fuji\", 43113, \"https://api.avax-test.network/ext/bc/C/rpc\")\n );\n setChainWithDefaultRpcUrl(\n \"bnb_smart_chain\", ChainData(\"BNB Smart Chain\", 56, \"https://bsc-dataseed1.binance.org\")\n );\n setChainWithDefaultRpcUrl(\n \"bnb_smart_chain_testnet\",\n ChainData(\"BNB Smart Chain Testnet\", 97, \"https://rpc.ankr.com/bsc_testnet_chapel\")\n );\n setChainWithDefaultRpcUrl(\"gnosis_chain\", ChainData(\"Gnosis Chain\", 100, \"https://rpc.gnosischain.com\"));\n setChainWithDefaultRpcUrl(\"moonbeam\", ChainData(\"Moonbeam\", 1284, \"https://rpc.api.moonbeam.network\"));\n setChainWithDefaultRpcUrl(\n \"moonriver\", ChainData(\"Moonriver\", 1285, \"https://rpc.api.moonriver.moonbeam.network\")\n );\n setChainWithDefaultRpcUrl(\"moonbase\", ChainData(\"Moonbase\", 1287, \"https://rpc.testnet.moonbeam.network\"));\n setChainWithDefaultRpcUrl(\"base_sepolia\", ChainData(\"Base Sepolia\", 84532, \"https://sepolia.base.org\"));\n setChainWithDefaultRpcUrl(\"base\", ChainData(\"Base\", 8453, \"https://mainnet.base.org\"));\n setChainWithDefaultRpcUrl(\"blast_sepolia\", ChainData(\"Blast Sepolia\", 168587773, \"https://sepolia.blast.io\"));\n setChainWithDefaultRpcUrl(\"blast\", ChainData(\"Blast\", 81457, \"https://rpc.blast.io\"));\n setChainWithDefaultRpcUrl(\"fantom_opera\", ChainData(\"Fantom Opera\", 250, \"https://rpc.ankr.com/fantom/\"));\n setChainWithDefaultRpcUrl(\n \"fantom_opera_testnet\", ChainData(\"Fantom Opera Testnet\", 4002, \"https://rpc.ankr.com/fantom_testnet/\")\n );\n setChainWithDefaultRpcUrl(\"fraxtal\", ChainData(\"Fraxtal\", 252, \"https://rpc.frax.com\"));\n setChainWithDefaultRpcUrl(\"fraxtal_testnet\", ChainData(\"Fraxtal Testnet\", 2522, \"https://rpc.testnet.frax.com\"));\n setChainWithDefaultRpcUrl(\n \"berachain_bartio_testnet\", ChainData(\"Berachain bArtio Testnet\", 80084, \"https://bartio.rpc.berachain.com\")\n );\n setChainWithDefaultRpcUrl(\"flare\", ChainData(\"Flare\", 14, \"https://flare-api.flare.network/ext/C/rpc\"));\n setChainWithDefaultRpcUrl(\n \"flare_coston2\", ChainData(\"Flare Coston2\", 114, \"https://coston2-api.flare.network/ext/C/rpc\")\n );\n\n setChainWithDefaultRpcUrl(\"mode\", ChainData(\"Mode\", 34443, \"https://mode.drpc.org\"));\n setChainWithDefaultRpcUrl(\"mode_sepolia\", ChainData(\"Mode Sepolia\", 919, \"https://sepolia.mode.network\"));\n\n setChainWithDefaultRpcUrl(\"zora\", ChainData(\"Zora\", 7777777, \"https://zora.drpc.org\"));\n setChainWithDefaultRpcUrl(\n \"zora_sepolia\", ChainData(\"Zora Sepolia\", 999999999, \"https://sepolia.rpc.zora.energy\")\n );\n\n setChainWithDefaultRpcUrl(\"race\", ChainData(\"Race\", 6805, \"https://racemainnet.io\"));\n setChainWithDefaultRpcUrl(\"race_sepolia\", ChainData(\"Race Sepolia\", 6806, \"https://racemainnet.io\"));\n\n setChainWithDefaultRpcUrl(\"metal\", ChainData(\"Metal\", 1750, \"https://metall2.drpc.org\"));\n setChainWithDefaultRpcUrl(\"metal_sepolia\", ChainData(\"Metal Sepolia\", 1740, \"https://testnet.rpc.metall2.com\"));\n\n setChainWithDefaultRpcUrl(\"binary\", ChainData(\"Binary\", 624, \"https://rpc.zero.thebinaryholdings.com\"));\n setChainWithDefaultRpcUrl(\n \"binary_sepolia\", ChainData(\"Binary Sepolia\", 625, \"https://rpc.zero.thebinaryholdings.com\")\n );\n\n setChainWithDefaultRpcUrl(\"orderly\", ChainData(\"Orderly\", 291, \"https://rpc.orderly.network\"));\n setChainWithDefaultRpcUrl(\n \"orderly_sepolia\", ChainData(\"Orderly Sepolia\", 4460, \"https://testnet-rpc.orderly.org\")\n );\n }\n\n // set chain info, with priority to chainAlias' rpc url in foundry.toml\n function setChainWithDefaultRpcUrl(string memory chainAlias, ChainData memory chain) private {\n string memory rpcUrl = chain.rpcUrl;\n defaultRpcUrls[chainAlias] = rpcUrl;\n chain.rpcUrl = \"\";\n setChain(chainAlias, chain);\n chain.rpcUrl = rpcUrl; // restore argument\n }\n}\n","license":"MIT"},"lib/forge-std/src/StdCheats.sol":{"keccak256":"0x0fa6ec03602648b62cce41aab2096e6b7e052f2846075d967b6958dd586db746","urls":[],"content":"// SPDX-License-Identifier: MIT\npragma solidity >=0.6.2 <0.9.0;\n\npragma experimental ABIEncoderV2;\n\nimport {StdStorage, stdStorage} from \"./StdStorage.sol\";\nimport {console2} from \"./console2.sol\";\nimport {Vm} from \"./Vm.sol\";\n\nabstract contract StdCheatsSafe {\n Vm private constant vm = Vm(address(uint160(uint256(keccak256(\"hevm cheat code\")))));\n\n uint256 private constant UINT256_MAX =\n 115792089237316195423570985008687907853269984665640564039457584007913129639935;\n\n bool private gasMeteringOff;\n\n // Data structures to parse Transaction objects from the broadcast artifact\n // that conform to EIP1559. The Raw structs is what is parsed from the JSON\n // and then converted to the one that is used by the user for better UX.\n\n struct RawTx1559 {\n string[] arguments;\n address contractAddress;\n string contractName;\n // json value name = function\n string functionSig;\n bytes32 hash;\n // json value name = tx\n RawTx1559Detail txDetail;\n // json value name = type\n string opcode;\n }\n\n struct RawTx1559Detail {\n AccessList[] accessList;\n bytes data;\n address from;\n bytes gas;\n bytes nonce;\n address to;\n bytes txType;\n bytes value;\n }\n\n struct Tx1559 {\n string[] arguments;\n address contractAddress;\n string contractName;\n string functionSig;\n bytes32 hash;\n Tx1559Detail txDetail;\n string opcode;\n }\n\n struct Tx1559Detail {\n AccessList[] accessList;\n bytes data;\n address from;\n uint256 gas;\n uint256 nonce;\n address to;\n uint256 txType;\n uint256 value;\n }\n\n // Data structures to parse Transaction objects from the broadcast artifact\n // that DO NOT conform to EIP1559. The Raw structs is what is parsed from the JSON\n // and then converted to the one that is used by the user for better UX.\n\n struct TxLegacy {\n string[] arguments;\n address contractAddress;\n string contractName;\n string functionSig;\n string hash;\n string opcode;\n TxDetailLegacy transaction;\n }\n\n struct TxDetailLegacy {\n AccessList[] accessList;\n uint256 chainId;\n bytes data;\n address from;\n uint256 gas;\n uint256 gasPrice;\n bytes32 hash;\n uint256 nonce;\n bytes1 opcode;\n bytes32 r;\n bytes32 s;\n uint256 txType;\n address to;\n uint8 v;\n uint256 value;\n }\n\n struct AccessList {\n address accessAddress;\n bytes32[] storageKeys;\n }\n\n // Data structures to parse Receipt objects from the broadcast artifact.\n // The Raw structs is what is parsed from the JSON\n // and then converted to the one that is used by the user for better UX.\n\n struct RawReceipt {\n bytes32 blockHash;\n bytes blockNumber;\n address contractAddress;\n bytes cumulativeGasUsed;\n bytes effectiveGasPrice;\n address from;\n bytes gasUsed;\n RawReceiptLog[] logs;\n bytes logsBloom;\n bytes status;\n address to;\n bytes32 transactionHash;\n bytes transactionIndex;\n }\n\n struct Receipt {\n bytes32 blockHash;\n uint256 blockNumber;\n address contractAddress;\n uint256 cumulativeGasUsed;\n uint256 effectiveGasPrice;\n address from;\n uint256 gasUsed;\n ReceiptLog[] logs;\n bytes logsBloom;\n uint256 status;\n address to;\n bytes32 transactionHash;\n uint256 transactionIndex;\n }\n\n // Data structures to parse the entire broadcast artifact, assuming the\n // transactions conform to EIP1559.\n\n struct EIP1559ScriptArtifact {\n string[] libraries;\n string path;\n string[] pending;\n Receipt[] receipts;\n uint256 timestamp;\n Tx1559[] transactions;\n TxReturn[] txReturns;\n }\n\n struct RawEIP1559ScriptArtifact {\n string[] libraries;\n string path;\n string[] pending;\n RawReceipt[] receipts;\n TxReturn[] txReturns;\n uint256 timestamp;\n RawTx1559[] transactions;\n }\n\n struct RawReceiptLog {\n // json value = address\n address logAddress;\n bytes32 blockHash;\n bytes blockNumber;\n bytes data;\n bytes logIndex;\n bool removed;\n bytes32[] topics;\n bytes32 transactionHash;\n bytes transactionIndex;\n bytes transactionLogIndex;\n }\n\n struct ReceiptLog {\n // json value = address\n address logAddress;\n bytes32 blockHash;\n uint256 blockNumber;\n bytes data;\n uint256 logIndex;\n bytes32[] topics;\n uint256 transactionIndex;\n uint256 transactionLogIndex;\n bool removed;\n }\n\n struct TxReturn {\n string internalType;\n string value;\n }\n\n struct Account {\n address addr;\n uint256 key;\n }\n\n enum AddressType {\n Payable,\n NonPayable,\n ZeroAddress,\n Precompile,\n ForgeAddress\n }\n\n // Checks that `addr` is not blacklisted by token contracts that have a blacklist.\n function assumeNotBlacklisted(address token, address addr) internal view virtual {\n // Nothing to check if `token` is not a contract.\n uint256 tokenCodeSize;\n assembly {\n tokenCodeSize := extcodesize(token)\n }\n require(tokenCodeSize > 0, \"StdCheats assumeNotBlacklisted(address,address): Token address is not a contract.\");\n\n bool success;\n bytes memory returnData;\n\n // 4-byte selector for `isBlacklisted(address)`, used by USDC.\n (success, returnData) = token.staticcall(abi.encodeWithSelector(0xfe575a87, addr));\n vm.assume(!success || abi.decode(returnData, (bool)) == false);\n\n // 4-byte selector for `isBlackListed(address)`, used by USDT.\n (success, returnData) = token.staticcall(abi.encodeWithSelector(0xe47d6060, addr));\n vm.assume(!success || abi.decode(returnData, (bool)) == false);\n }\n\n // Checks that `addr` is not blacklisted by token contracts that have a blacklist.\n // This is identical to `assumeNotBlacklisted(address,address)` but with a different name, for\n // backwards compatibility, since this name was used in the original PR which already has\n // a release. This function can be removed in a future release once we want a breaking change.\n function assumeNoBlacklisted(address token, address addr) internal view virtual {\n assumeNotBlacklisted(token, addr);\n }\n\n function assumeAddressIsNot(address addr, AddressType addressType) internal virtual {\n if (addressType == AddressType.Payable) {\n assumeNotPayable(addr);\n } else if (addressType == AddressType.NonPayable) {\n assumePayable(addr);\n } else if (addressType == AddressType.ZeroAddress) {\n assumeNotZeroAddress(addr);\n } else if (addressType == AddressType.Precompile) {\n assumeNotPrecompile(addr);\n } else if (addressType == AddressType.ForgeAddress) {\n assumeNotForgeAddress(addr);\n }\n }\n\n function assumeAddressIsNot(address addr, AddressType addressType1, AddressType addressType2) internal virtual {\n assumeAddressIsNot(addr, addressType1);\n assumeAddressIsNot(addr, addressType2);\n }\n\n function assumeAddressIsNot(\n address addr,\n AddressType addressType1,\n AddressType addressType2,\n AddressType addressType3\n ) internal virtual {\n assumeAddressIsNot(addr, addressType1);\n assumeAddressIsNot(addr, addressType2);\n assumeAddressIsNot(addr, addressType3);\n }\n\n function assumeAddressIsNot(\n address addr,\n AddressType addressType1,\n AddressType addressType2,\n AddressType addressType3,\n AddressType addressType4\n ) internal virtual {\n assumeAddressIsNot(addr, addressType1);\n assumeAddressIsNot(addr, addressType2);\n assumeAddressIsNot(addr, addressType3);\n assumeAddressIsNot(addr, addressType4);\n }\n\n // This function checks whether an address, `addr`, is payable. It works by sending 1 wei to\n // `addr` and checking the `success` return value.\n // NOTE: This function may result in state changes depending on the fallback/receive logic\n // implemented by `addr`, which should be taken into account when this function is used.\n function _isPayable(address addr) private returns (bool) {\n require(\n addr.balance < UINT256_MAX,\n \"StdCheats _isPayable(address): Balance equals max uint256, so it cannot receive any more funds\"\n );\n uint256 origBalanceTest = address(this).balance;\n uint256 origBalanceAddr = address(addr).balance;\n\n vm.deal(address(this), 1);\n (bool success,) = payable(addr).call{value: 1}(\"\");\n\n // reset balances\n vm.deal(address(this), origBalanceTest);\n vm.deal(addr, origBalanceAddr);\n\n return success;\n }\n\n // NOTE: This function may result in state changes depending on the fallback/receive logic\n // implemented by `addr`, which should be taken into account when this function is used. See the\n // `_isPayable` method for more information.\n function assumePayable(address addr) internal virtual {\n vm.assume(_isPayable(addr));\n }\n\n function assumeNotPayable(address addr) internal virtual {\n vm.assume(!_isPayable(addr));\n }\n\n function assumeNotZeroAddress(address addr) internal pure virtual {\n vm.assume(addr != address(0));\n }\n\n function assumeNotPrecompile(address addr) internal pure virtual {\n assumeNotPrecompile(addr, _pureChainId());\n }\n\n function assumeNotPrecompile(address addr, uint256 chainId) internal pure virtual {\n // Note: For some chains like Optimism these are technically predeploys (i.e. bytecode placed at a specific\n // address), but the same rationale for excluding them applies so we include those too.\n\n // These are reserved by Ethereum and may be on all EVM-compatible chains.\n vm.assume(addr < address(0x1) || addr > address(0xff));\n\n // forgefmt: disable-start\n if (chainId == 10 || chainId == 420) {\n // https://github.com/ethereum-optimism/optimism/blob/eaa371a0184b56b7ca6d9eb9cb0a2b78b2ccd864/op-bindings/predeploys/addresses.go#L6-L21\n vm.assume(addr < address(0x4200000000000000000000000000000000000000) || addr > address(0x4200000000000000000000000000000000000800));\n } else if (chainId == 42161 || chainId == 421613) {\n // https://developer.arbitrum.io/useful-addresses#arbitrum-precompiles-l2-same-on-all-arb-chains\n vm.assume(addr < address(0x0000000000000000000000000000000000000064) || addr > address(0x0000000000000000000000000000000000000068));\n } else if (chainId == 43114 || chainId == 43113) {\n // https://github.com/ava-labs/subnet-evm/blob/47c03fd007ecaa6de2c52ea081596e0a88401f58/precompile/params.go#L18-L59\n vm.assume(addr < address(0x0100000000000000000000000000000000000000) || addr > address(0x01000000000000000000000000000000000000ff));\n vm.assume(addr < address(0x0200000000000000000000000000000000000000) || addr > address(0x02000000000000000000000000000000000000FF));\n vm.assume(addr < address(0x0300000000000000000000000000000000000000) || addr > address(0x03000000000000000000000000000000000000Ff));\n }\n // forgefmt: disable-end\n }\n\n function assumeNotForgeAddress(address addr) internal pure virtual {\n // vm, console, and Create2Deployer addresses\n vm.assume(\n addr != address(vm) && addr != 0x000000000000000000636F6e736F6c652e6c6f67\n && addr != 0x4e59b44847b379578588920cA78FbF26c0B4956C\n );\n }\n\n function assumeUnusedAddress(address addr) internal view virtual {\n uint256 size;\n assembly {\n size := extcodesize(addr)\n }\n vm.assume(size == 0);\n\n assumeNotPrecompile(addr);\n assumeNotZeroAddress(addr);\n assumeNotForgeAddress(addr);\n }\n\n function readEIP1559ScriptArtifact(string memory path)\n internal\n view\n virtual\n returns (EIP1559ScriptArtifact memory)\n {\n string memory data = vm.readFile(path);\n bytes memory parsedData = vm.parseJson(data);\n RawEIP1559ScriptArtifact memory rawArtifact = abi.decode(parsedData, (RawEIP1559ScriptArtifact));\n EIP1559ScriptArtifact memory artifact;\n artifact.libraries = rawArtifact.libraries;\n artifact.path = rawArtifact.path;\n artifact.timestamp = rawArtifact.timestamp;\n artifact.pending = rawArtifact.pending;\n artifact.txReturns = rawArtifact.txReturns;\n artifact.receipts = rawToConvertedReceipts(rawArtifact.receipts);\n artifact.transactions = rawToConvertedEIPTx1559s(rawArtifact.transactions);\n return artifact;\n }\n\n function rawToConvertedEIPTx1559s(RawTx1559[] memory rawTxs) internal pure virtual returns (Tx1559[] memory) {\n Tx1559[] memory txs = new Tx1559[](rawTxs.length);\n for (uint256 i; i < rawTxs.length; i++) {\n txs[i] = rawToConvertedEIPTx1559(rawTxs[i]);\n }\n return txs;\n }\n\n function rawToConvertedEIPTx1559(RawTx1559 memory rawTx) internal pure virtual returns (Tx1559 memory) {\n Tx1559 memory transaction;\n transaction.arguments = rawTx.arguments;\n transaction.contractName = rawTx.contractName;\n transaction.functionSig = rawTx.functionSig;\n transaction.hash = rawTx.hash;\n transaction.txDetail = rawToConvertedEIP1559Detail(rawTx.txDetail);\n transaction.opcode = rawTx.opcode;\n return transaction;\n }\n\n function rawToConvertedEIP1559Detail(RawTx1559Detail memory rawDetail)\n internal\n pure\n virtual\n returns (Tx1559Detail memory)\n {\n Tx1559Detail memory txDetail;\n txDetail.data = rawDetail.data;\n txDetail.from = rawDetail.from;\n txDetail.to = rawDetail.to;\n txDetail.nonce = _bytesToUint(rawDetail.nonce);\n txDetail.txType = _bytesToUint(rawDetail.txType);\n txDetail.value = _bytesToUint(rawDetail.value);\n txDetail.gas = _bytesToUint(rawDetail.gas);\n txDetail.accessList = rawDetail.accessList;\n return txDetail;\n }\n\n function readTx1559s(string memory path) internal view virtual returns (Tx1559[] memory) {\n string memory deployData = vm.readFile(path);\n bytes memory parsedDeployData = vm.parseJson(deployData, \".transactions\");\n RawTx1559[] memory rawTxs = abi.decode(parsedDeployData, (RawTx1559[]));\n return rawToConvertedEIPTx1559s(rawTxs);\n }\n\n function readTx1559(string memory path, uint256 index) internal view virtual returns (Tx1559 memory) {\n string memory deployData = vm.readFile(path);\n string memory key = string(abi.encodePacked(\".transactions[\", vm.toString(index), \"]\"));\n bytes memory parsedDeployData = vm.parseJson(deployData, key);\n RawTx1559 memory rawTx = abi.decode(parsedDeployData, (RawTx1559));\n return rawToConvertedEIPTx1559(rawTx);\n }\n\n // Analogous to readTransactions, but for receipts.\n function readReceipts(string memory path) internal view virtual returns (Receipt[] memory) {\n string memory deployData = vm.readFile(path);\n bytes memory parsedDeployData = vm.parseJson(deployData, \".receipts\");\n RawReceipt[] memory rawReceipts = abi.decode(parsedDeployData, (RawReceipt[]));\n return rawToConvertedReceipts(rawReceipts);\n }\n\n function readReceipt(string memory path, uint256 index) internal view virtual returns (Receipt memory) {\n string memory deployData = vm.readFile(path);\n string memory key = string(abi.encodePacked(\".receipts[\", vm.toString(index), \"]\"));\n bytes memory parsedDeployData = vm.parseJson(deployData, key);\n RawReceipt memory rawReceipt = abi.decode(parsedDeployData, (RawReceipt));\n return rawToConvertedReceipt(rawReceipt);\n }\n\n function rawToConvertedReceipts(RawReceipt[] memory rawReceipts) internal pure virtual returns (Receipt[] memory) {\n Receipt[] memory receipts = new Receipt[](rawReceipts.length);\n for (uint256 i; i < rawReceipts.length; i++) {\n receipts[i] = rawToConvertedReceipt(rawReceipts[i]);\n }\n return receipts;\n }\n\n function rawToConvertedReceipt(RawReceipt memory rawReceipt) internal pure virtual returns (Receipt memory) {\n Receipt memory receipt;\n receipt.blockHash = rawReceipt.blockHash;\n receipt.to = rawReceipt.to;\n receipt.from = rawReceipt.from;\n receipt.contractAddress = rawReceipt.contractAddress;\n receipt.effectiveGasPrice = _bytesToUint(rawReceipt.effectiveGasPrice);\n receipt.cumulativeGasUsed = _bytesToUint(rawReceipt.cumulativeGasUsed);\n receipt.gasUsed = _bytesToUint(rawReceipt.gasUsed);\n receipt.status = _bytesToUint(rawReceipt.status);\n receipt.transactionIndex = _bytesToUint(rawReceipt.transactionIndex);\n receipt.blockNumber = _bytesToUint(rawReceipt.blockNumber);\n receipt.logs = rawToConvertedReceiptLogs(rawReceipt.logs);\n receipt.logsBloom = rawReceipt.logsBloom;\n receipt.transactionHash = rawReceipt.transactionHash;\n return receipt;\n }\n\n function rawToConvertedReceiptLogs(RawReceiptLog[] memory rawLogs)\n internal\n pure\n virtual\n returns (ReceiptLog[] memory)\n {\n ReceiptLog[] memory logs = new ReceiptLog[](rawLogs.length);\n for (uint256 i; i < rawLogs.length; i++) {\n logs[i].logAddress = rawLogs[i].logAddress;\n logs[i].blockHash = rawLogs[i].blockHash;\n logs[i].blockNumber = _bytesToUint(rawLogs[i].blockNumber);\n logs[i].data = rawLogs[i].data;\n logs[i].logIndex = _bytesToUint(rawLogs[i].logIndex);\n logs[i].topics = rawLogs[i].topics;\n logs[i].transactionIndex = _bytesToUint(rawLogs[i].transactionIndex);\n logs[i].transactionLogIndex = _bytesToUint(rawLogs[i].transactionLogIndex);\n logs[i].removed = rawLogs[i].removed;\n }\n return logs;\n }\n\n // Deploy a contract by fetching the contract bytecode from\n // the artifacts directory\n // e.g. `deployCode(code, abi.encode(arg1,arg2,arg3))`\n function deployCode(string memory what, bytes memory args) internal virtual returns (address addr) {\n bytes memory bytecode = abi.encodePacked(vm.getCode(what), args);\n /// @solidity memory-safe-assembly\n assembly {\n addr := create(0, add(bytecode, 0x20), mload(bytecode))\n }\n\n require(addr != address(0), \"StdCheats deployCode(string,bytes): Deployment failed.\");\n }\n\n function deployCode(string memory what) internal virtual returns (address addr) {\n bytes memory bytecode = vm.getCode(what);\n /// @solidity memory-safe-assembly\n assembly {\n addr := create(0, add(bytecode, 0x20), mload(bytecode))\n }\n\n require(addr != address(0), \"StdCheats deployCode(string): Deployment failed.\");\n }\n\n /// @dev deploy contract with value on construction\n function deployCode(string memory what, bytes memory args, uint256 val) internal virtual returns (address addr) {\n bytes memory bytecode = abi.encodePacked(vm.getCode(what), args);\n /// @solidity memory-safe-assembly\n assembly {\n addr := create(val, add(bytecode, 0x20), mload(bytecode))\n }\n\n require(addr != address(0), \"StdCheats deployCode(string,bytes,uint256): Deployment failed.\");\n }\n\n function deployCode(string memory what, uint256 val) internal virtual returns (address addr) {\n bytes memory bytecode = vm.getCode(what);\n /// @solidity memory-safe-assembly\n assembly {\n addr := create(val, add(bytecode, 0x20), mload(bytecode))\n }\n\n require(addr != address(0), \"StdCheats deployCode(string,uint256): Deployment failed.\");\n }\n\n // creates a labeled address and the corresponding private key\n function makeAddrAndKey(string memory name) internal virtual returns (address addr, uint256 privateKey) {\n privateKey = uint256(keccak256(abi.encodePacked(name)));\n addr = vm.addr(privateKey);\n vm.label(addr, name);\n }\n\n // creates a labeled address\n function makeAddr(string memory name) internal virtual returns (address addr) {\n (addr,) = makeAddrAndKey(name);\n }\n\n // Destroys an account immediately, sending the balance to beneficiary.\n // Destroying means: balance will be zero, code will be empty, and nonce will be 0\n // This is similar to selfdestruct but not identical: selfdestruct destroys code and nonce\n // only after tx ends, this will run immediately.\n function destroyAccount(address who, address beneficiary) internal virtual {\n uint256 currBalance = who.balance;\n vm.etch(who, abi.encode());\n vm.deal(who, 0);\n vm.resetNonce(who);\n\n uint256 beneficiaryBalance = beneficiary.balance;\n vm.deal(beneficiary, currBalance + beneficiaryBalance);\n }\n\n // creates a struct containing both a labeled address and the corresponding private key\n function makeAccount(string memory name) internal virtual returns (Account memory account) {\n (account.addr, account.key) = makeAddrAndKey(name);\n }\n\n function deriveRememberKey(string memory mnemonic, uint32 index)\n internal\n virtual\n returns (address who, uint256 privateKey)\n {\n privateKey = vm.deriveKey(mnemonic, index);\n who = vm.rememberKey(privateKey);\n }\n\n function _bytesToUint(bytes memory b) private pure returns (uint256) {\n require(b.length <= 32, \"StdCheats _bytesToUint(bytes): Bytes length exceeds 32.\");\n return abi.decode(abi.encodePacked(new bytes(32 - b.length), b), (uint256));\n }\n\n function isFork() internal view virtual returns (bool status) {\n try vm.activeFork() {\n status = true;\n } catch (bytes memory) {}\n }\n\n modifier skipWhenForking() {\n if (!isFork()) {\n _;\n }\n }\n\n modifier skipWhenNotForking() {\n if (isFork()) {\n _;\n }\n }\n\n modifier noGasMetering() {\n vm.pauseGasMetering();\n // To prevent turning gas monitoring back on with nested functions that use this modifier,\n // we check if gasMetering started in the off position. If it did, we don't want to turn\n // it back on until we exit the top level function that used the modifier\n //\n // i.e. funcA() noGasMetering { funcB() }, where funcB has noGasMetering as well.\n // funcA will have `gasStartedOff` as false, funcB will have it as true,\n // so we only turn metering back on at the end of the funcA\n bool gasStartedOff = gasMeteringOff;\n gasMeteringOff = true;\n\n _;\n\n // if gas metering was on when this modifier was called, turn it back on at the end\n if (!gasStartedOff) {\n gasMeteringOff = false;\n vm.resumeGasMetering();\n }\n }\n\n // We use this complex approach of `_viewChainId` and `_pureChainId` to ensure there are no\n // compiler warnings when accessing chain ID in any solidity version supported by forge-std. We\n // can't simply access the chain ID in a normal view or pure function because the solc View Pure\n // Checker changed `chainid` from pure to view in 0.8.0.\n function _viewChainId() private view returns (uint256 chainId) {\n // Assembly required since `block.chainid` was introduced in 0.8.0.\n assembly {\n chainId := chainid()\n }\n\n address(this); // Silence warnings in older Solc versions.\n }\n\n function _pureChainId() private pure returns (uint256 chainId) {\n function() internal view returns (uint256) fnIn = _viewChainId;\n function() internal pure returns (uint256) pureChainId;\n assembly {\n pureChainId := fnIn\n }\n chainId = pureChainId();\n }\n}\n\n// Wrappers around cheatcodes to avoid footguns\nabstract contract StdCheats is StdCheatsSafe {\n using stdStorage for StdStorage;\n\n StdStorage private stdstore;\n Vm private constant vm = Vm(address(uint160(uint256(keccak256(\"hevm cheat code\")))));\n address private constant CONSOLE2_ADDRESS = 0x000000000000000000636F6e736F6c652e6c6f67;\n\n // Skip forward or rewind time by the specified number of seconds\n function skip(uint256 time) internal virtual {\n vm.warp(vm.getBlockTimestamp() + time);\n }\n\n function rewind(uint256 time) internal virtual {\n vm.warp(vm.getBlockTimestamp() - time);\n }\n\n // Setup a prank from an address that has some ether\n function hoax(address msgSender) internal virtual {\n vm.deal(msgSender, 1 << 128);\n vm.prank(msgSender);\n }\n\n function hoax(address msgSender, uint256 give) internal virtual {\n vm.deal(msgSender, give);\n vm.prank(msgSender);\n }\n\n function hoax(address msgSender, address origin) internal virtual {\n vm.deal(msgSender, 1 << 128);\n vm.prank(msgSender, origin);\n }\n\n function hoax(address msgSender, address origin, uint256 give) internal virtual {\n vm.deal(msgSender, give);\n vm.prank(msgSender, origin);\n }\n\n // Start perpetual prank from an address that has some ether\n function startHoax(address msgSender) internal virtual {\n vm.deal(msgSender, 1 << 128);\n vm.startPrank(msgSender);\n }\n\n function startHoax(address msgSender, uint256 give) internal virtual {\n vm.deal(msgSender, give);\n vm.startPrank(msgSender);\n }\n\n // Start perpetual prank from an address that has some ether\n // tx.origin is set to the origin parameter\n function startHoax(address msgSender, address origin) internal virtual {\n vm.deal(msgSender, 1 << 128);\n vm.startPrank(msgSender, origin);\n }\n\n function startHoax(address msgSender, address origin, uint256 give) internal virtual {\n vm.deal(msgSender, give);\n vm.startPrank(msgSender, origin);\n }\n\n function changePrank(address msgSender) internal virtual {\n console2_log_StdCheats(\"changePrank is deprecated. Please use vm.startPrank instead.\");\n vm.stopPrank();\n vm.startPrank(msgSender);\n }\n\n function changePrank(address msgSender, address txOrigin) internal virtual {\n vm.stopPrank();\n vm.startPrank(msgSender, txOrigin);\n }\n\n // The same as Vm's `deal`\n // Use the alternative signature for ERC20 tokens\n function deal(address to, uint256 give) internal virtual {\n vm.deal(to, give);\n }\n\n // Set the balance of an account for any ERC20 token\n // Use the alternative signature to update `totalSupply`\n function deal(address token, address to, uint256 give) internal virtual {\n deal(token, to, give, false);\n }\n\n // Set the balance of an account for any ERC1155 token\n // Use the alternative signature to update `totalSupply`\n function dealERC1155(address token, address to, uint256 id, uint256 give) internal virtual {\n dealERC1155(token, to, id, give, false);\n }\n\n function deal(address token, address to, uint256 give, bool adjust) internal virtual {\n // get current balance\n (, bytes memory balData) = token.staticcall(abi.encodeWithSelector(0x70a08231, to));\n uint256 prevBal = abi.decode(balData, (uint256));\n\n // update balance\n stdstore.target(token).sig(0x70a08231).with_key(to).checked_write(give);\n\n // update total supply\n if (adjust) {\n (, bytes memory totSupData) = token.staticcall(abi.encodeWithSelector(0x18160ddd));\n uint256 totSup = abi.decode(totSupData, (uint256));\n if (give < prevBal) {\n totSup -= (prevBal - give);\n } else {\n totSup += (give - prevBal);\n }\n stdstore.target(token).sig(0x18160ddd).checked_write(totSup);\n }\n }\n\n function dealERC1155(address token, address to, uint256 id, uint256 give, bool adjust) internal virtual {\n // get current balance\n (, bytes memory balData) = token.staticcall(abi.encodeWithSelector(0x00fdd58e, to, id));\n uint256 prevBal = abi.decode(balData, (uint256));\n\n // update balance\n stdstore.target(token).sig(0x00fdd58e).with_key(to).with_key(id).checked_write(give);\n\n // update total supply\n if (adjust) {\n (, bytes memory totSupData) = token.staticcall(abi.encodeWithSelector(0xbd85b039, id));\n require(\n totSupData.length != 0,\n \"StdCheats deal(address,address,uint,uint,bool): target contract is not ERC1155Supply.\"\n );\n uint256 totSup = abi.decode(totSupData, (uint256));\n if (give < prevBal) {\n totSup -= (prevBal - give);\n } else {\n totSup += (give - prevBal);\n }\n stdstore.target(token).sig(0xbd85b039).with_key(id).checked_write(totSup);\n }\n }\n\n function dealERC721(address token, address to, uint256 id) internal virtual {\n // check if token id is already minted and the actual owner.\n (bool successMinted, bytes memory ownerData) = token.staticcall(abi.encodeWithSelector(0x6352211e, id));\n require(successMinted, \"StdCheats deal(address,address,uint,bool): id not minted.\");\n\n // get owner current balance\n (, bytes memory fromBalData) =\n token.staticcall(abi.encodeWithSelector(0x70a08231, abi.decode(ownerData, (address))));\n uint256 fromPrevBal = abi.decode(fromBalData, (uint256));\n\n // get new user current balance\n (, bytes memory toBalData) = token.staticcall(abi.encodeWithSelector(0x70a08231, to));\n uint256 toPrevBal = abi.decode(toBalData, (uint256));\n\n // update balances\n stdstore.target(token).sig(0x70a08231).with_key(abi.decode(ownerData, (address))).checked_write(--fromPrevBal);\n stdstore.target(token).sig(0x70a08231).with_key(to).checked_write(++toPrevBal);\n\n // update owner\n stdstore.target(token).sig(0x6352211e).with_key(id).checked_write(to);\n }\n\n function deployCodeTo(string memory what, address where) internal virtual {\n deployCodeTo(what, \"\", 0, where);\n }\n\n function deployCodeTo(string memory what, bytes memory args, address where) internal virtual {\n deployCodeTo(what, args, 0, where);\n }\n\n function deployCodeTo(string memory what, bytes memory args, uint256 value, address where) internal virtual {\n bytes memory creationCode = vm.getCode(what);\n vm.etch(where, abi.encodePacked(creationCode, args));\n (bool success, bytes memory runtimeBytecode) = where.call{value: value}(\"\");\n require(success, \"StdCheats deployCodeTo(string,bytes,uint256,address): Failed to create runtime bytecode.\");\n vm.etch(where, runtimeBytecode);\n }\n\n // Used to prevent the compilation of console, which shortens the compilation time when console is not used elsewhere.\n function console2_log_StdCheats(string memory p0) private view {\n (bool status,) = address(CONSOLE2_ADDRESS).staticcall(abi.encodeWithSignature(\"log(string)\", p0));\n status;\n }\n}\n","license":"MIT"},"lib/forge-std/src/StdConstants.sol":{"keccak256":"0x319ccdabfa2c0b2428301445873270ffea20f0e039d4fd5e6eeba65158e4e534","urls":[],"content":"// SPDX-License-Identifier: MIT\npragma solidity >=0.6.2 <0.9.0;\n\nimport {IMulticall3} from \"./interfaces/IMulticall3.sol\";\nimport {Vm} from \"./Vm.sol\";\n\nlibrary StdConstants {\n /// @dev Cheat code address.\n /// Calculated as `address(uint160(uint256(keccak256(\"hevm cheat code\"))))`.\n Vm internal constant VM = Vm(0x7109709ECfa91a80626fF3989D68f67F5b1DD12D);\n /// @dev console.sol and console2.sol work by executing a staticcall to this address.\n /// Calculated as `address(uint160(uint88(bytes11(\"console.log\"))))`.\n address internal constant CONSOLE = 0x000000000000000000636F6e736F6c652e6c6f67;\n /// @dev Used when deploying with create2.\n /// Taken from https://github.com/Arachnid/deterministic-deployment-proxy.\n address internal constant CREATE2_FACTORY = 0x4e59b44847b379578588920cA78FbF26c0B4956C;\n /// @dev The default address for tx.origin and msg.sender.\n /// Calculated as `address(uint160(uint256(keccak256(\"foundry default caller\"))))`.\n address internal constant DEFAULT_SENDER = 0x1804c8AB1F12E6bbf3894d4083f33e07309d1f38;\n /// @dev The address of the first contract `CREATE`d by a running test contract.\n /// When running tests, each test contract is `CREATE`d by `DEFAULT_SENDER` with nonce 1.\n /// Calculated as `VM.computeCreateAddress(VM.computeCreateAddress(DEFAULT_SENDER, 1), 1)`.\n address internal constant DEFAULT_TEST_CONTRACT = 0x5615dEB798BB3E4dFa0139dFa1b3D433Cc23b72f;\n /// @dev Deterministic deployment address of the Multicall3 contract.\n /// Taken from https://www.multicall3.com.\n IMulticall3 internal constant MULTICALL3_ADDRESS = IMulticall3(0xcA11bde05977b3631167028862bE2a173976CA11);\n /// @dev The order of the secp256k1 curve.\n uint256 internal constant SECP256K1_ORDER =\n 115792089237316195423570985008687907852837564279074904382605163141518161494337;\n}\n","license":"MIT"},"lib/forge-std/src/StdJson.sol":{"keccak256":"0xbc0132abe1c2accc2867c0f03667afffdf92f3e95a581bb03c9557eaa38ea500","urls":[],"content":"// SPDX-License-Identifier: MIT\npragma solidity >=0.6.0 <0.9.0;\n\npragma experimental ABIEncoderV2;\n\nimport {VmSafe} from \"./Vm.sol\";\n\n// Helpers for parsing and writing JSON files\n// To parse:\n// ```\n// using stdJson for string;\n// string memory json = vm.readFile(\"\");\n// json.readUint(\"\");\n// ```\n// To write:\n// ```\n// using stdJson for string;\n// string memory json = \"json\";\n// json.serialize(\"a\", uint256(123));\n// string memory semiFinal = json.serialize(\"b\", string(\"test\"));\n// string memory finalJson = json.serialize(\"c\", semiFinal);\n// finalJson.write(\"\");\n// ```\n\nlibrary stdJson {\n VmSafe private constant vm = VmSafe(address(uint160(uint256(keccak256(\"hevm cheat code\")))));\n\n function keyExists(string memory json, string memory key) internal view returns (bool) {\n return vm.keyExistsJson(json, key);\n }\n\n function parseRaw(string memory json, string memory key) internal pure returns (bytes memory) {\n return vm.parseJson(json, key);\n }\n\n function readUint(string memory json, string memory key) internal pure returns (uint256) {\n return vm.parseJsonUint(json, key);\n }\n\n function readUintArray(string memory json, string memory key) internal pure returns (uint256[] memory) {\n return vm.parseJsonUintArray(json, key);\n }\n\n function readInt(string memory json, string memory key) internal pure returns (int256) {\n return vm.parseJsonInt(json, key);\n }\n\n function readIntArray(string memory json, string memory key) internal pure returns (int256[] memory) {\n return vm.parseJsonIntArray(json, key);\n }\n\n function readBytes32(string memory json, string memory key) internal pure returns (bytes32) {\n return vm.parseJsonBytes32(json, key);\n }\n\n function readBytes32Array(string memory json, string memory key) internal pure returns (bytes32[] memory) {\n return vm.parseJsonBytes32Array(json, key);\n }\n\n function readString(string memory json, string memory key) internal pure returns (string memory) {\n return vm.parseJsonString(json, key);\n }\n\n function readStringArray(string memory json, string memory key) internal pure returns (string[] memory) {\n return vm.parseJsonStringArray(json, key);\n }\n\n function readAddress(string memory json, string memory key) internal pure returns (address) {\n return vm.parseJsonAddress(json, key);\n }\n\n function readAddressArray(string memory json, string memory key) internal pure returns (address[] memory) {\n return vm.parseJsonAddressArray(json, key);\n }\n\n function readBool(string memory json, string memory key) internal pure returns (bool) {\n return vm.parseJsonBool(json, key);\n }\n\n function readBoolArray(string memory json, string memory key) internal pure returns (bool[] memory) {\n return vm.parseJsonBoolArray(json, key);\n }\n\n function readBytes(string memory json, string memory key) internal pure returns (bytes memory) {\n return vm.parseJsonBytes(json, key);\n }\n\n function readBytesArray(string memory json, string memory key) internal pure returns (bytes[] memory) {\n return vm.parseJsonBytesArray(json, key);\n }\n\n function readUintOr(string memory json, string memory key, uint256 defaultValue) internal view returns (uint256) {\n return keyExists(json, key) ? readUint(json, key) : defaultValue;\n }\n\n function readUintArrayOr(string memory json, string memory key, uint256[] memory defaultValue)\n internal\n view\n returns (uint256[] memory)\n {\n return keyExists(json, key) ? readUintArray(json, key) : defaultValue;\n }\n\n function readIntOr(string memory json, string memory key, int256 defaultValue) internal view returns (int256) {\n return keyExists(json, key) ? readInt(json, key) : defaultValue;\n }\n\n function readIntArrayOr(string memory json, string memory key, int256[] memory defaultValue)\n internal\n view\n returns (int256[] memory)\n {\n return keyExists(json, key) ? readIntArray(json, key) : defaultValue;\n }\n\n function readBytes32Or(string memory json, string memory key, bytes32 defaultValue)\n internal\n view\n returns (bytes32)\n {\n return keyExists(json, key) ? readBytes32(json, key) : defaultValue;\n }\n\n function readBytes32ArrayOr(string memory json, string memory key, bytes32[] memory defaultValue)\n internal\n view\n returns (bytes32[] memory)\n {\n return keyExists(json, key) ? readBytes32Array(json, key) : defaultValue;\n }\n\n function readStringOr(string memory json, string memory key, string memory defaultValue)\n internal\n view\n returns (string memory)\n {\n return keyExists(json, key) ? readString(json, key) : defaultValue;\n }\n\n function readStringArrayOr(string memory json, string memory key, string[] memory defaultValue)\n internal\n view\n returns (string[] memory)\n {\n return keyExists(json, key) ? readStringArray(json, key) : defaultValue;\n }\n\n function readAddressOr(string memory json, string memory key, address defaultValue)\n internal\n view\n returns (address)\n {\n return keyExists(json, key) ? readAddress(json, key) : defaultValue;\n }\n\n function readAddressArrayOr(string memory json, string memory key, address[] memory defaultValue)\n internal\n view\n returns (address[] memory)\n {\n return keyExists(json, key) ? readAddressArray(json, key) : defaultValue;\n }\n\n function readBoolOr(string memory json, string memory key, bool defaultValue) internal view returns (bool) {\n return keyExists(json, key) ? readBool(json, key) : defaultValue;\n }\n\n function readBoolArrayOr(string memory json, string memory key, bool[] memory defaultValue)\n internal\n view\n returns (bool[] memory)\n {\n return keyExists(json, key) ? readBoolArray(json, key) : defaultValue;\n }\n\n function readBytesOr(string memory json, string memory key, bytes memory defaultValue)\n internal\n view\n returns (bytes memory)\n {\n return keyExists(json, key) ? readBytes(json, key) : defaultValue;\n }\n\n function readBytesArrayOr(string memory json, string memory key, bytes[] memory defaultValue)\n internal\n view\n returns (bytes[] memory)\n {\n return keyExists(json, key) ? readBytesArray(json, key) : defaultValue;\n }\n\n function serialize(string memory jsonKey, string memory rootObject) internal returns (string memory) {\n return vm.serializeJson(jsonKey, rootObject);\n }\n\n function serialize(string memory jsonKey, string memory key, bool value) internal returns (string memory) {\n return vm.serializeBool(jsonKey, key, value);\n }\n\n function serialize(string memory jsonKey, string memory key, bool[] memory value)\n internal\n returns (string memory)\n {\n return vm.serializeBool(jsonKey, key, value);\n }\n\n function serialize(string memory jsonKey, string memory key, uint256 value) internal returns (string memory) {\n return vm.serializeUint(jsonKey, key, value);\n }\n\n function serialize(string memory jsonKey, string memory key, uint256[] memory value)\n internal\n returns (string memory)\n {\n return vm.serializeUint(jsonKey, key, value);\n }\n\n function serialize(string memory jsonKey, string memory key, int256 value) internal returns (string memory) {\n return vm.serializeInt(jsonKey, key, value);\n }\n\n function serialize(string memory jsonKey, string memory key, int256[] memory value)\n internal\n returns (string memory)\n {\n return vm.serializeInt(jsonKey, key, value);\n }\n\n function serialize(string memory jsonKey, string memory key, address value) internal returns (string memory) {\n return vm.serializeAddress(jsonKey, key, value);\n }\n\n function serialize(string memory jsonKey, string memory key, address[] memory value)\n internal\n returns (string memory)\n {\n return vm.serializeAddress(jsonKey, key, value);\n }\n\n function serialize(string memory jsonKey, string memory key, bytes32 value) internal returns (string memory) {\n return vm.serializeBytes32(jsonKey, key, value);\n }\n\n function serialize(string memory jsonKey, string memory key, bytes32[] memory value)\n internal\n returns (string memory)\n {\n return vm.serializeBytes32(jsonKey, key, value);\n }\n\n function serialize(string memory jsonKey, string memory key, bytes memory value) internal returns (string memory) {\n return vm.serializeBytes(jsonKey, key, value);\n }\n\n function serialize(string memory jsonKey, string memory key, bytes[] memory value)\n internal\n returns (string memory)\n {\n return vm.serializeBytes(jsonKey, key, value);\n }\n\n function serialize(string memory jsonKey, string memory key, string memory value)\n internal\n returns (string memory)\n {\n return vm.serializeString(jsonKey, key, value);\n }\n\n function serialize(string memory jsonKey, string memory key, string[] memory value)\n internal\n returns (string memory)\n {\n return vm.serializeString(jsonKey, key, value);\n }\n\n function write(string memory jsonKey, string memory path) internal {\n vm.writeJson(jsonKey, path);\n }\n\n function write(string memory jsonKey, string memory path, string memory valueKey) internal {\n vm.writeJson(jsonKey, path, valueKey);\n }\n}\n","license":"MIT"},"lib/forge-std/src/StdMath.sol":{"keccak256":"0xd90ad4fd8aeaeb8929964e686e769fdedd5eded3fc3815df194a0ab9f91a3fb2","urls":[],"content":"// SPDX-License-Identifier: MIT\npragma solidity >=0.6.2 <0.9.0;\n\nlibrary stdMath {\n int256 private constant INT256_MIN = -57896044618658097711785492504343953926634992332820282019728792003956564819968;\n\n function abs(int256 a) internal pure returns (uint256) {\n // Required or it will fail when `a = type(int256).min`\n if (a == INT256_MIN) {\n return 57896044618658097711785492504343953926634992332820282019728792003956564819968;\n }\n\n return uint256(a > 0 ? a : -a);\n }\n\n function delta(uint256 a, uint256 b) internal pure returns (uint256) {\n return a > b ? a - b : b - a;\n }\n\n function delta(int256 a, int256 b) internal pure returns (uint256) {\n // a and b are of the same sign\n // this works thanks to two's complement, the left-most bit is the sign bit\n if ((a ^ b) > -1) {\n return delta(abs(a), abs(b));\n }\n\n // a and b are of opposite signs\n return abs(a) + abs(b);\n }\n\n function percentDelta(uint256 a, uint256 b) internal pure returns (uint256) {\n uint256 absDelta = delta(a, b);\n\n return absDelta * 1e18 / b;\n }\n\n function percentDelta(int256 a, int256 b) internal pure returns (uint256) {\n uint256 absDelta = delta(a, b);\n uint256 absB = abs(b);\n\n return absDelta * 1e18 / absB;\n }\n}\n","license":"MIT"},"lib/forge-std/src/StdStorage.sol":{"keccak256":"0xb91ab24383a5872b894fc93325eef1add6cbbf981628f18e860068bf88bb7dcc","urls":[],"content":"// SPDX-License-Identifier: MIT\npragma solidity >=0.6.2 <0.9.0;\n\nimport {Vm} from \"./Vm.sol\";\n\nstruct FindData {\n uint256 slot;\n uint256 offsetLeft;\n uint256 offsetRight;\n bool found;\n}\n\nstruct StdStorage {\n mapping(address => mapping(bytes4 => mapping(bytes32 => FindData))) finds;\n bytes32[] _keys;\n bytes4 _sig;\n uint256 _depth;\n address _target;\n bytes32 _set;\n bool _enable_packed_slots;\n bytes _calldata;\n}\n\nlibrary stdStorageSafe {\n event SlotFound(address who, bytes4 fsig, bytes32 keysHash, uint256 slot);\n event WARNING_UninitedSlot(address who, uint256 slot);\n\n Vm private constant vm = Vm(address(uint160(uint256(keccak256(\"hevm cheat code\")))));\n uint256 constant UINT256_MAX = 115792089237316195423570985008687907853269984665640564039457584007913129639935;\n\n function sigs(string memory sigStr) internal pure returns (bytes4) {\n return bytes4(keccak256(bytes(sigStr)));\n }\n\n function getCallParams(StdStorage storage self) internal view returns (bytes memory) {\n if (self._calldata.length == 0) {\n return flatten(self._keys);\n } else {\n return self._calldata;\n }\n }\n\n // Calls target contract with configured parameters\n function callTarget(StdStorage storage self) internal view returns (bool, bytes32) {\n bytes memory cald = abi.encodePacked(self._sig, getCallParams(self));\n (bool success, bytes memory rdat) = self._target.staticcall(cald);\n bytes32 result = bytesToBytes32(rdat, 32 * self._depth);\n\n return (success, result);\n }\n\n // Tries mutating slot value to determine if the targeted value is stored in it.\n // If current value is 0, then we are setting slot value to type(uint256).max\n // Otherwise, we set it to 0. That way, return value should always be affected.\n function checkSlotMutatesCall(StdStorage storage self, bytes32 slot) internal returns (bool) {\n bytes32 prevSlotValue = vm.load(self._target, slot);\n (bool success, bytes32 prevReturnValue) = callTarget(self);\n\n bytes32 testVal = prevReturnValue == bytes32(0) ? bytes32(UINT256_MAX) : bytes32(0);\n vm.store(self._target, slot, testVal);\n\n (, bytes32 newReturnValue) = callTarget(self);\n\n vm.store(self._target, slot, prevSlotValue);\n\n return (success && (prevReturnValue != newReturnValue));\n }\n\n // Tries setting one of the bits in slot to 1 until return value changes.\n // Index of resulted bit is an offset packed slot has from left/right side\n function findOffset(StdStorage storage self, bytes32 slot, bool left) internal returns (bool, uint256) {\n for (uint256 offset = 0; offset < 256; offset++) {\n uint256 valueToPut = left ? (1 << (255 - offset)) : (1 << offset);\n vm.store(self._target, slot, bytes32(valueToPut));\n\n (bool success, bytes32 data) = callTarget(self);\n\n if (success && (uint256(data) > 0)) {\n return (true, offset);\n }\n }\n return (false, 0);\n }\n\n function findOffsets(StdStorage storage self, bytes32 slot) internal returns (bool, uint256, uint256) {\n bytes32 prevSlotValue = vm.load(self._target, slot);\n\n (bool foundLeft, uint256 offsetLeft) = findOffset(self, slot, true);\n (bool foundRight, uint256 offsetRight) = findOffset(self, slot, false);\n\n // `findOffset` may mutate slot value, so we are setting it to initial value\n vm.store(self._target, slot, prevSlotValue);\n return (foundLeft && foundRight, offsetLeft, offsetRight);\n }\n\n function find(StdStorage storage self) internal returns (FindData storage) {\n return find(self, true);\n }\n\n /// @notice find an arbitrary storage slot given a function sig, input data, address of the contract and a value to check against\n // slot complexity:\n // if flat, will be bytes32(uint256(uint));\n // if map, will be keccak256(abi.encode(key, uint(slot)));\n // if deep map, will be keccak256(abi.encode(key1, keccak256(abi.encode(key0, uint(slot)))));\n // if map struct, will be bytes32(uint256(keccak256(abi.encode(key1, keccak256(abi.encode(key0, uint(slot)))))) + structFieldDepth);\n function find(StdStorage storage self, bool _clear) internal returns (FindData storage) {\n address who = self._target;\n bytes4 fsig = self._sig;\n uint256 field_depth = self._depth;\n bytes memory params = getCallParams(self);\n\n // calldata to test against\n if (self.finds[who][fsig][keccak256(abi.encodePacked(params, field_depth))].found) {\n if (_clear) {\n clear(self);\n }\n return self.finds[who][fsig][keccak256(abi.encodePacked(params, field_depth))];\n }\n vm.record();\n (, bytes32 callResult) = callTarget(self);\n (bytes32[] memory reads,) = vm.accesses(address(who));\n\n if (reads.length == 0) {\n revert(\"stdStorage find(StdStorage): No storage use detected for target.\");\n } else {\n for (uint256 i = reads.length; --i >= 0;) {\n bytes32 prev = vm.load(who, reads[i]);\n if (prev == bytes32(0)) {\n emit WARNING_UninitedSlot(who, uint256(reads[i]));\n }\n\n if (!checkSlotMutatesCall(self, reads[i])) {\n continue;\n }\n\n (uint256 offsetLeft, uint256 offsetRight) = (0, 0);\n\n if (self._enable_packed_slots) {\n bool found;\n (found, offsetLeft, offsetRight) = findOffsets(self, reads[i]);\n if (!found) {\n continue;\n }\n }\n\n // Check that value between found offsets is equal to the current call result\n uint256 curVal = (uint256(prev) & getMaskByOffsets(offsetLeft, offsetRight)) >> offsetRight;\n\n if (uint256(callResult) != curVal) {\n continue;\n }\n\n emit SlotFound(who, fsig, keccak256(abi.encodePacked(params, field_depth)), uint256(reads[i]));\n self.finds[who][fsig][keccak256(abi.encodePacked(params, field_depth))] =\n FindData(uint256(reads[i]), offsetLeft, offsetRight, true);\n break;\n }\n }\n\n require(\n self.finds[who][fsig][keccak256(abi.encodePacked(params, field_depth))].found,\n \"stdStorage find(StdStorage): Slot(s) not found.\"\n );\n\n if (_clear) {\n clear(self);\n }\n return self.finds[who][fsig][keccak256(abi.encodePacked(params, field_depth))];\n }\n\n function target(StdStorage storage self, address _target) internal returns (StdStorage storage) {\n self._target = _target;\n return self;\n }\n\n function sig(StdStorage storage self, bytes4 _sig) internal returns (StdStorage storage) {\n self._sig = _sig;\n return self;\n }\n\n function sig(StdStorage storage self, string memory _sig) internal returns (StdStorage storage) {\n self._sig = sigs(_sig);\n return self;\n }\n\n function with_calldata(StdStorage storage self, bytes memory _calldata) internal returns (StdStorage storage) {\n self._calldata = _calldata;\n return self;\n }\n\n function with_key(StdStorage storage self, address who) internal returns (StdStorage storage) {\n self._keys.push(bytes32(uint256(uint160(who))));\n return self;\n }\n\n function with_key(StdStorage storage self, uint256 amt) internal returns (StdStorage storage) {\n self._keys.push(bytes32(amt));\n return self;\n }\n\n function with_key(StdStorage storage self, bytes32 key) internal returns (StdStorage storage) {\n self._keys.push(key);\n return self;\n }\n\n function enable_packed_slots(StdStorage storage self) internal returns (StdStorage storage) {\n self._enable_packed_slots = true;\n return self;\n }\n\n function depth(StdStorage storage self, uint256 _depth) internal returns (StdStorage storage) {\n self._depth = _depth;\n return self;\n }\n\n function read(StdStorage storage self) private returns (bytes memory) {\n FindData storage data = find(self, false);\n uint256 mask = getMaskByOffsets(data.offsetLeft, data.offsetRight);\n uint256 value = (uint256(vm.load(self._target, bytes32(data.slot))) & mask) >> data.offsetRight;\n clear(self);\n return abi.encode(value);\n }\n\n function read_bytes32(StdStorage storage self) internal returns (bytes32) {\n return abi.decode(read(self), (bytes32));\n }\n\n function read_bool(StdStorage storage self) internal returns (bool) {\n int256 v = read_int(self);\n if (v == 0) return false;\n if (v == 1) return true;\n revert(\"stdStorage read_bool(StdStorage): Cannot decode. Make sure you are reading a bool.\");\n }\n\n function read_address(StdStorage storage self) internal returns (address) {\n return abi.decode(read(self), (address));\n }\n\n function read_uint(StdStorage storage self) internal returns (uint256) {\n return abi.decode(read(self), (uint256));\n }\n\n function read_int(StdStorage storage self) internal returns (int256) {\n return abi.decode(read(self), (int256));\n }\n\n function parent(StdStorage storage self) internal returns (uint256, bytes32) {\n address who = self._target;\n uint256 field_depth = self._depth;\n vm.startMappingRecording();\n uint256 child = find(self, true).slot - field_depth;\n (bool found, bytes32 key, bytes32 parent_slot) = vm.getMappingKeyAndParentOf(who, bytes32(child));\n if (!found) {\n revert(\n \"stdStorage read_bool(StdStorage): Cannot find parent. Make sure you give a slot and startMappingRecording() has been called.\"\n );\n }\n return (uint256(parent_slot), key);\n }\n\n function root(StdStorage storage self) internal returns (uint256) {\n address who = self._target;\n uint256 field_depth = self._depth;\n vm.startMappingRecording();\n uint256 child = find(self, true).slot - field_depth;\n bool found;\n bytes32 root_slot;\n bytes32 parent_slot;\n (found,, parent_slot) = vm.getMappingKeyAndParentOf(who, bytes32(child));\n if (!found) {\n revert(\n \"stdStorage read_bool(StdStorage): Cannot find parent. Make sure you give a slot and startMappingRecording() has been called.\"\n );\n }\n while (found) {\n root_slot = parent_slot;\n (found,, parent_slot) = vm.getMappingKeyAndParentOf(who, bytes32(root_slot));\n }\n return uint256(root_slot);\n }\n\n function bytesToBytes32(bytes memory b, uint256 offset) private pure returns (bytes32) {\n bytes32 out;\n\n uint256 max = b.length > 32 ? 32 : b.length;\n for (uint256 i = 0; i < max; i++) {\n out |= bytes32(b[offset + i] & 0xFF) >> (i * 8);\n }\n return out;\n }\n\n function flatten(bytes32[] memory b) private pure returns (bytes memory) {\n bytes memory result = new bytes(b.length * 32);\n for (uint256 i = 0; i < b.length; i++) {\n bytes32 k = b[i];\n /// @solidity memory-safe-assembly\n assembly {\n mstore(add(result, add(32, mul(32, i))), k)\n }\n }\n\n return result;\n }\n\n function clear(StdStorage storage self) internal {\n delete self._target;\n delete self._sig;\n delete self._keys;\n delete self._depth;\n delete self._enable_packed_slots;\n delete self._calldata;\n }\n\n // Returns mask which contains non-zero bits for values between `offsetLeft` and `offsetRight`\n // (slotValue & mask) >> offsetRight will be the value of the given packed variable\n function getMaskByOffsets(uint256 offsetLeft, uint256 offsetRight) internal pure returns (uint256 mask) {\n // mask = ((1 << (256 - (offsetRight + offsetLeft))) - 1) << offsetRight;\n // using assembly because (1 << 256) causes overflow\n assembly {\n mask := shl(offsetRight, sub(shl(sub(256, add(offsetRight, offsetLeft)), 1), 1))\n }\n }\n\n // Returns slot value with updated packed variable.\n function getUpdatedSlotValue(bytes32 curValue, uint256 varValue, uint256 offsetLeft, uint256 offsetRight)\n internal\n pure\n returns (bytes32 newValue)\n {\n return bytes32((uint256(curValue) & ~getMaskByOffsets(offsetLeft, offsetRight)) | (varValue << offsetRight));\n }\n}\n\nlibrary stdStorage {\n Vm private constant vm = Vm(address(uint160(uint256(keccak256(\"hevm cheat code\")))));\n\n function sigs(string memory sigStr) internal pure returns (bytes4) {\n return stdStorageSafe.sigs(sigStr);\n }\n\n function find(StdStorage storage self) internal returns (uint256) {\n return find(self, true);\n }\n\n function find(StdStorage storage self, bool _clear) internal returns (uint256) {\n return stdStorageSafe.find(self, _clear).slot;\n }\n\n function target(StdStorage storage self, address _target) internal returns (StdStorage storage) {\n return stdStorageSafe.target(self, _target);\n }\n\n function sig(StdStorage storage self, bytes4 _sig) internal returns (StdStorage storage) {\n return stdStorageSafe.sig(self, _sig);\n }\n\n function sig(StdStorage storage self, string memory _sig) internal returns (StdStorage storage) {\n return stdStorageSafe.sig(self, _sig);\n }\n\n function with_key(StdStorage storage self, address who) internal returns (StdStorage storage) {\n return stdStorageSafe.with_key(self, who);\n }\n\n function with_key(StdStorage storage self, uint256 amt) internal returns (StdStorage storage) {\n return stdStorageSafe.with_key(self, amt);\n }\n\n function with_key(StdStorage storage self, bytes32 key) internal returns (StdStorage storage) {\n return stdStorageSafe.with_key(self, key);\n }\n\n function with_calldata(StdStorage storage self, bytes memory _calldata) internal returns (StdStorage storage) {\n return stdStorageSafe.with_calldata(self, _calldata);\n }\n\n function enable_packed_slots(StdStorage storage self) internal returns (StdStorage storage) {\n return stdStorageSafe.enable_packed_slots(self);\n }\n\n function depth(StdStorage storage self, uint256 _depth) internal returns (StdStorage storage) {\n return stdStorageSafe.depth(self, _depth);\n }\n\n function clear(StdStorage storage self) internal {\n stdStorageSafe.clear(self);\n }\n\n function checked_write(StdStorage storage self, address who) internal {\n checked_write(self, bytes32(uint256(uint160(who))));\n }\n\n function checked_write(StdStorage storage self, uint256 amt) internal {\n checked_write(self, bytes32(amt));\n }\n\n function checked_write_int(StdStorage storage self, int256 val) internal {\n checked_write(self, bytes32(uint256(val)));\n }\n\n function checked_write(StdStorage storage self, bool write) internal {\n bytes32 t;\n /// @solidity memory-safe-assembly\n assembly {\n t := write\n }\n checked_write(self, t);\n }\n\n function checked_write(StdStorage storage self, bytes32 set) internal {\n address who = self._target;\n bytes4 fsig = self._sig;\n uint256 field_depth = self._depth;\n bytes memory params = stdStorageSafe.getCallParams(self);\n\n if (!self.finds[who][fsig][keccak256(abi.encodePacked(params, field_depth))].found) {\n find(self, false);\n }\n FindData storage data = self.finds[who][fsig][keccak256(abi.encodePacked(params, field_depth))];\n if ((data.offsetLeft + data.offsetRight) > 0) {\n uint256 maxVal = 2 ** (256 - (data.offsetLeft + data.offsetRight));\n require(\n uint256(set) < maxVal,\n string(\n abi.encodePacked(\n \"stdStorage find(StdStorage): Packed slot. We can't fit value greater than \",\n vm.toString(maxVal)\n )\n )\n );\n }\n bytes32 curVal = vm.load(who, bytes32(data.slot));\n bytes32 valToSet = stdStorageSafe.getUpdatedSlotValue(curVal, uint256(set), data.offsetLeft, data.offsetRight);\n\n vm.store(who, bytes32(data.slot), valToSet);\n\n (bool success, bytes32 callResult) = stdStorageSafe.callTarget(self);\n\n if (!success || callResult != set) {\n vm.store(who, bytes32(data.slot), curVal);\n revert(\"stdStorage find(StdStorage): Failed to write value.\");\n }\n clear(self);\n }\n\n function read_bytes32(StdStorage storage self) internal returns (bytes32) {\n return stdStorageSafe.read_bytes32(self);\n }\n\n function read_bool(StdStorage storage self) internal returns (bool) {\n return stdStorageSafe.read_bool(self);\n }\n\n function read_address(StdStorage storage self) internal returns (address) {\n return stdStorageSafe.read_address(self);\n }\n\n function read_uint(StdStorage storage self) internal returns (uint256) {\n return stdStorageSafe.read_uint(self);\n }\n\n function read_int(StdStorage storage self) internal returns (int256) {\n return stdStorageSafe.read_int(self);\n }\n\n function parent(StdStorage storage self) internal returns (uint256, bytes32) {\n return stdStorageSafe.parent(self);\n }\n\n function root(StdStorage storage self) internal returns (uint256) {\n return stdStorageSafe.root(self);\n }\n}\n","license":"MIT"},"lib/forge-std/src/StdStyle.sol":{"keccak256":"0x43e2a8a9b9c2574dabe74f11adf6f782df218f463540e3b5b563609fe108597d","urls":[],"content":"// SPDX-License-Identifier: MIT\npragma solidity >=0.4.22 <0.9.0;\n\nimport {VmSafe} from \"./Vm.sol\";\n\nlibrary StdStyle {\n VmSafe private constant vm = VmSafe(address(uint160(uint256(keccak256(\"hevm cheat code\")))));\n\n string constant RED = \"\\u001b[91m\";\n string constant GREEN = \"\\u001b[92m\";\n string constant YELLOW = \"\\u001b[93m\";\n string constant BLUE = \"\\u001b[94m\";\n string constant MAGENTA = \"\\u001b[95m\";\n string constant CYAN = \"\\u001b[96m\";\n string constant BOLD = \"\\u001b[1m\";\n string constant DIM = \"\\u001b[2m\";\n string constant ITALIC = \"\\u001b[3m\";\n string constant UNDERLINE = \"\\u001b[4m\";\n string constant INVERSE = \"\\u001b[7m\";\n string constant RESET = \"\\u001b[0m\";\n\n function styleConcat(string memory style, string memory self) private pure returns (string memory) {\n return string(abi.encodePacked(style, self, RESET));\n }\n\n function red(string memory self) internal pure returns (string memory) {\n return styleConcat(RED, self);\n }\n\n function red(uint256 self) internal pure returns (string memory) {\n return red(vm.toString(self));\n }\n\n function red(int256 self) internal pure returns (string memory) {\n return red(vm.toString(self));\n }\n\n function red(address self) internal pure returns (string memory) {\n return red(vm.toString(self));\n }\n\n function red(bool self) internal pure returns (string memory) {\n return red(vm.toString(self));\n }\n\n function redBytes(bytes memory self) internal pure returns (string memory) {\n return red(vm.toString(self));\n }\n\n function redBytes32(bytes32 self) internal pure returns (string memory) {\n return red(vm.toString(self));\n }\n\n function green(string memory self) internal pure returns (string memory) {\n return styleConcat(GREEN, self);\n }\n\n function green(uint256 self) internal pure returns (string memory) {\n return green(vm.toString(self));\n }\n\n function green(int256 self) internal pure returns (string memory) {\n return green(vm.toString(self));\n }\n\n function green(address self) internal pure returns (string memory) {\n return green(vm.toString(self));\n }\n\n function green(bool self) internal pure returns (string memory) {\n return green(vm.toString(self));\n }\n\n function greenBytes(bytes memory self) internal pure returns (string memory) {\n return green(vm.toString(self));\n }\n\n function greenBytes32(bytes32 self) internal pure returns (string memory) {\n return green(vm.toString(self));\n }\n\n function yellow(string memory self) internal pure returns (string memory) {\n return styleConcat(YELLOW, self);\n }\n\n function yellow(uint256 self) internal pure returns (string memory) {\n return yellow(vm.toString(self));\n }\n\n function yellow(int256 self) internal pure returns (string memory) {\n return yellow(vm.toString(self));\n }\n\n function yellow(address self) internal pure returns (string memory) {\n return yellow(vm.toString(self));\n }\n\n function yellow(bool self) internal pure returns (string memory) {\n return yellow(vm.toString(self));\n }\n\n function yellowBytes(bytes memory self) internal pure returns (string memory) {\n return yellow(vm.toString(self));\n }\n\n function yellowBytes32(bytes32 self) internal pure returns (string memory) {\n return yellow(vm.toString(self));\n }\n\n function blue(string memory self) internal pure returns (string memory) {\n return styleConcat(BLUE, self);\n }\n\n function blue(uint256 self) internal pure returns (string memory) {\n return blue(vm.toString(self));\n }\n\n function blue(int256 self) internal pure returns (string memory) {\n return blue(vm.toString(self));\n }\n\n function blue(address self) internal pure returns (string memory) {\n return blue(vm.toString(self));\n }\n\n function blue(bool self) internal pure returns (string memory) {\n return blue(vm.toString(self));\n }\n\n function blueBytes(bytes memory self) internal pure returns (string memory) {\n return blue(vm.toString(self));\n }\n\n function blueBytes32(bytes32 self) internal pure returns (string memory) {\n return blue(vm.toString(self));\n }\n\n function magenta(string memory self) internal pure returns (string memory) {\n return styleConcat(MAGENTA, self);\n }\n\n function magenta(uint256 self) internal pure returns (string memory) {\n return magenta(vm.toString(self));\n }\n\n function magenta(int256 self) internal pure returns (string memory) {\n return magenta(vm.toString(self));\n }\n\n function magenta(address self) internal pure returns (string memory) {\n return magenta(vm.toString(self));\n }\n\n function magenta(bool self) internal pure returns (string memory) {\n return magenta(vm.toString(self));\n }\n\n function magentaBytes(bytes memory self) internal pure returns (string memory) {\n return magenta(vm.toString(self));\n }\n\n function magentaBytes32(bytes32 self) internal pure returns (string memory) {\n return magenta(vm.toString(self));\n }\n\n function cyan(string memory self) internal pure returns (string memory) {\n return styleConcat(CYAN, self);\n }\n\n function cyan(uint256 self) internal pure returns (string memory) {\n return cyan(vm.toString(self));\n }\n\n function cyan(int256 self) internal pure returns (string memory) {\n return cyan(vm.toString(self));\n }\n\n function cyan(address self) internal pure returns (string memory) {\n return cyan(vm.toString(self));\n }\n\n function cyan(bool self) internal pure returns (string memory) {\n return cyan(vm.toString(self));\n }\n\n function cyanBytes(bytes memory self) internal pure returns (string memory) {\n return cyan(vm.toString(self));\n }\n\n function cyanBytes32(bytes32 self) internal pure returns (string memory) {\n return cyan(vm.toString(self));\n }\n\n function bold(string memory self) internal pure returns (string memory) {\n return styleConcat(BOLD, self);\n }\n\n function bold(uint256 self) internal pure returns (string memory) {\n return bold(vm.toString(self));\n }\n\n function bold(int256 self) internal pure returns (string memory) {\n return bold(vm.toString(self));\n }\n\n function bold(address self) internal pure returns (string memory) {\n return bold(vm.toString(self));\n }\n\n function bold(bool self) internal pure returns (string memory) {\n return bold(vm.toString(self));\n }\n\n function boldBytes(bytes memory self) internal pure returns (string memory) {\n return bold(vm.toString(self));\n }\n\n function boldBytes32(bytes32 self) internal pure returns (string memory) {\n return bold(vm.toString(self));\n }\n\n function dim(string memory self) internal pure returns (string memory) {\n return styleConcat(DIM, self);\n }\n\n function dim(uint256 self) internal pure returns (string memory) {\n return dim(vm.toString(self));\n }\n\n function dim(int256 self) internal pure returns (string memory) {\n return dim(vm.toString(self));\n }\n\n function dim(address self) internal pure returns (string memory) {\n return dim(vm.toString(self));\n }\n\n function dim(bool self) internal pure returns (string memory) {\n return dim(vm.toString(self));\n }\n\n function dimBytes(bytes memory self) internal pure returns (string memory) {\n return dim(vm.toString(self));\n }\n\n function dimBytes32(bytes32 self) internal pure returns (string memory) {\n return dim(vm.toString(self));\n }\n\n function italic(string memory self) internal pure returns (string memory) {\n return styleConcat(ITALIC, self);\n }\n\n function italic(uint256 self) internal pure returns (string memory) {\n return italic(vm.toString(self));\n }\n\n function italic(int256 self) internal pure returns (string memory) {\n return italic(vm.toString(self));\n }\n\n function italic(address self) internal pure returns (string memory) {\n return italic(vm.toString(self));\n }\n\n function italic(bool self) internal pure returns (string memory) {\n return italic(vm.toString(self));\n }\n\n function italicBytes(bytes memory self) internal pure returns (string memory) {\n return italic(vm.toString(self));\n }\n\n function italicBytes32(bytes32 self) internal pure returns (string memory) {\n return italic(vm.toString(self));\n }\n\n function underline(string memory self) internal pure returns (string memory) {\n return styleConcat(UNDERLINE, self);\n }\n\n function underline(uint256 self) internal pure returns (string memory) {\n return underline(vm.toString(self));\n }\n\n function underline(int256 self) internal pure returns (string memory) {\n return underline(vm.toString(self));\n }\n\n function underline(address self) internal pure returns (string memory) {\n return underline(vm.toString(self));\n }\n\n function underline(bool self) internal pure returns (string memory) {\n return underline(vm.toString(self));\n }\n\n function underlineBytes(bytes memory self) internal pure returns (string memory) {\n return underline(vm.toString(self));\n }\n\n function underlineBytes32(bytes32 self) internal pure returns (string memory) {\n return underline(vm.toString(self));\n }\n\n function inverse(string memory self) internal pure returns (string memory) {\n return styleConcat(INVERSE, self);\n }\n\n function inverse(uint256 self) internal pure returns (string memory) {\n return inverse(vm.toString(self));\n }\n\n function inverse(int256 self) internal pure returns (string memory) {\n return inverse(vm.toString(self));\n }\n\n function inverse(address self) internal pure returns (string memory) {\n return inverse(vm.toString(self));\n }\n\n function inverse(bool self) internal pure returns (string memory) {\n return inverse(vm.toString(self));\n }\n\n function inverseBytes(bytes memory self) internal pure returns (string memory) {\n return inverse(vm.toString(self));\n }\n\n function inverseBytes32(bytes32 self) internal pure returns (string memory) {\n return inverse(vm.toString(self));\n }\n}\n","license":"MIT"},"lib/forge-std/src/StdUtils.sol":{"keccak256":"0x7274081e11c05164fd8eadde4de8305c033e58a43008dea58065f3170ccf0737","urls":[],"content":"// SPDX-License-Identifier: MIT\npragma solidity >=0.6.2 <0.9.0;\n\npragma experimental ABIEncoderV2;\n\nimport {IMulticall3} from \"./interfaces/IMulticall3.sol\";\nimport {VmSafe} from \"./Vm.sol\";\n\nabstract contract StdUtils {\n /*//////////////////////////////////////////////////////////////////////////\n CONSTANTS\n //////////////////////////////////////////////////////////////////////////*/\n\n IMulticall3 private constant multicall = IMulticall3(0xcA11bde05977b3631167028862bE2a173976CA11);\n VmSafe private constant vm = VmSafe(address(uint160(uint256(keccak256(\"hevm cheat code\")))));\n address private constant CONSOLE2_ADDRESS = 0x000000000000000000636F6e736F6c652e6c6f67;\n uint256 private constant INT256_MIN_ABS =\n 57896044618658097711785492504343953926634992332820282019728792003956564819968;\n uint256 private constant SECP256K1_ORDER =\n 115792089237316195423570985008687907852837564279074904382605163141518161494337;\n uint256 private constant UINT256_MAX =\n 115792089237316195423570985008687907853269984665640564039457584007913129639935;\n\n // Used by default when deploying with create2, https://github.com/Arachnid/deterministic-deployment-proxy.\n address private constant CREATE2_FACTORY = 0x4e59b44847b379578588920cA78FbF26c0B4956C;\n\n /*//////////////////////////////////////////////////////////////////////////\n INTERNAL FUNCTIONS\n //////////////////////////////////////////////////////////////////////////*/\n\n function _bound(uint256 x, uint256 min, uint256 max) internal pure virtual returns (uint256 result) {\n require(min <= max, \"StdUtils bound(uint256,uint256,uint256): Max is less than min.\");\n // If x is between min and max, return x directly. This is to ensure that dictionary values\n // do not get shifted if the min is nonzero. More info: https://github.com/foundry-rs/forge-std/issues/188\n if (x >= min && x <= max) return x;\n\n uint256 size = max - min + 1;\n\n // If the value is 0, 1, 2, 3, wrap that to min, min+1, min+2, min+3. Similarly for the UINT256_MAX side.\n // This helps ensure coverage of the min/max values.\n if (x <= 3 && size > x) return min + x;\n if (x >= UINT256_MAX - 3 && size > UINT256_MAX - x) return max - (UINT256_MAX - x);\n\n // Otherwise, wrap x into the range [min, max], i.e. the range is inclusive.\n if (x > max) {\n uint256 diff = x - max;\n uint256 rem = diff % size;\n if (rem == 0) return max;\n result = min + rem - 1;\n } else if (x < min) {\n uint256 diff = min - x;\n uint256 rem = diff % size;\n if (rem == 0) return min;\n result = max - rem + 1;\n }\n }\n\n function bound(uint256 x, uint256 min, uint256 max) internal pure virtual returns (uint256 result) {\n result = _bound(x, min, max);\n console2_log_StdUtils(\"Bound result\", result);\n }\n\n function _bound(int256 x, int256 min, int256 max) internal pure virtual returns (int256 result) {\n require(min <= max, \"StdUtils bound(int256,int256,int256): Max is less than min.\");\n\n // Shifting all int256 values to uint256 to use _bound function. The range of two types are:\n // int256 : -(2**255) ~ (2**255 - 1)\n // uint256: 0 ~ (2**256 - 1)\n // So, add 2**255, INT256_MIN_ABS to the integer values.\n //\n // If the given integer value is -2**255, we cannot use `-uint256(-x)` because of the overflow.\n // So, use `~uint256(x) + 1` instead.\n uint256 _x = x < 0 ? (INT256_MIN_ABS - ~uint256(x) - 1) : (uint256(x) + INT256_MIN_ABS);\n uint256 _min = min < 0 ? (INT256_MIN_ABS - ~uint256(min) - 1) : (uint256(min) + INT256_MIN_ABS);\n uint256 _max = max < 0 ? (INT256_MIN_ABS - ~uint256(max) - 1) : (uint256(max) + INT256_MIN_ABS);\n\n uint256 y = _bound(_x, _min, _max);\n\n // To move it back to int256 value, subtract INT256_MIN_ABS at here.\n result = y < INT256_MIN_ABS ? int256(~(INT256_MIN_ABS - y) + 1) : int256(y - INT256_MIN_ABS);\n }\n\n function bound(int256 x, int256 min, int256 max) internal pure virtual returns (int256 result) {\n result = _bound(x, min, max);\n console2_log_StdUtils(\"Bound result\", vm.toString(result));\n }\n\n function boundPrivateKey(uint256 privateKey) internal pure virtual returns (uint256 result) {\n result = _bound(privateKey, 1, SECP256K1_ORDER - 1);\n }\n\n function bytesToUint(bytes memory b) internal pure virtual returns (uint256) {\n require(b.length <= 32, \"StdUtils bytesToUint(bytes): Bytes length exceeds 32.\");\n return abi.decode(abi.encodePacked(new bytes(32 - b.length), b), (uint256));\n }\n\n /// @dev Compute the address a contract will be deployed at for a given deployer address and nonce\n /// @notice adapted from Solmate implementation (https://github.com/Rari-Capital/solmate/blob/main/src/utils/LibRLP.sol)\n function computeCreateAddress(address deployer, uint256 nonce) internal pure virtual returns (address) {\n console2_log_StdUtils(\"computeCreateAddress is deprecated. Please use vm.computeCreateAddress instead.\");\n return vm.computeCreateAddress(deployer, nonce);\n }\n\n function computeCreate2Address(bytes32 salt, bytes32 initcodeHash, address deployer)\n internal\n pure\n virtual\n returns (address)\n {\n console2_log_StdUtils(\"computeCreate2Address is deprecated. Please use vm.computeCreate2Address instead.\");\n return vm.computeCreate2Address(salt, initcodeHash, deployer);\n }\n\n /// @dev returns the address of a contract created with CREATE2 using the default CREATE2 deployer\n function computeCreate2Address(bytes32 salt, bytes32 initCodeHash) internal pure returns (address) {\n console2_log_StdUtils(\"computeCreate2Address is deprecated. Please use vm.computeCreate2Address instead.\");\n return vm.computeCreate2Address(salt, initCodeHash);\n }\n\n /// @dev returns the hash of the init code (creation code + no args) used in CREATE2 with no constructor arguments\n /// @param creationCode the creation code of a contract C, as returned by type(C).creationCode\n function hashInitCode(bytes memory creationCode) internal pure returns (bytes32) {\n return hashInitCode(creationCode, \"\");\n }\n\n /// @dev returns the hash of the init code (creation code + ABI-encoded args) used in CREATE2\n /// @param creationCode the creation code of a contract C, as returned by type(C).creationCode\n /// @param args the ABI-encoded arguments to the constructor of C\n function hashInitCode(bytes memory creationCode, bytes memory args) internal pure returns (bytes32) {\n return keccak256(abi.encodePacked(creationCode, args));\n }\n\n // Performs a single call with Multicall3 to query the ERC-20 token balances of the given addresses.\n function getTokenBalances(address token, address[] memory addresses)\n internal\n virtual\n returns (uint256[] memory balances)\n {\n uint256 tokenCodeSize;\n assembly {\n tokenCodeSize := extcodesize(token)\n }\n require(tokenCodeSize > 0, \"StdUtils getTokenBalances(address,address[]): Token address is not a contract.\");\n\n // ABI encode the aggregate call to Multicall3.\n uint256 length = addresses.length;\n IMulticall3.Call[] memory calls = new IMulticall3.Call[](length);\n for (uint256 i = 0; i < length; ++i) {\n // 0x70a08231 = bytes4(\"balanceOf(address)\"))\n calls[i] = IMulticall3.Call({target: token, callData: abi.encodeWithSelector(0x70a08231, (addresses[i]))});\n }\n\n // Make the aggregate call.\n (, bytes[] memory returnData) = multicall.aggregate(calls);\n\n // ABI decode the return data and return the balances.\n balances = new uint256[](length);\n for (uint256 i = 0; i < length; ++i) {\n balances[i] = abi.decode(returnData[i], (uint256));\n }\n }\n\n /*//////////////////////////////////////////////////////////////////////////\n PRIVATE FUNCTIONS\n //////////////////////////////////////////////////////////////////////////*/\n\n function addressFromLast20Bytes(bytes32 bytesValue) private pure returns (address) {\n return address(uint160(uint256(bytesValue)));\n }\n\n // This section is used to prevent the compilation of console, which shortens the compilation time when console is\n // not used elsewhere. We also trick the compiler into letting us make the console log methods as `pure` to avoid\n // any breaking changes to function signatures.\n function _castLogPayloadViewToPure(function(bytes memory) internal view fnIn)\n internal\n pure\n returns (function(bytes memory) internal pure fnOut)\n {\n assembly {\n fnOut := fnIn\n }\n }\n\n function _sendLogPayload(bytes memory payload) internal pure {\n _castLogPayloadViewToPure(_sendLogPayloadView)(payload);\n }\n\n function _sendLogPayloadView(bytes memory payload) private view {\n uint256 payloadLength = payload.length;\n address consoleAddress = CONSOLE2_ADDRESS;\n /// @solidity memory-safe-assembly\n assembly {\n let payloadStart := add(payload, 32)\n let r := staticcall(gas(), consoleAddress, payloadStart, payloadLength, 0, 0)\n }\n }\n\n function console2_log_StdUtils(string memory p0) private pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string)\", p0));\n }\n\n function console2_log_StdUtils(string memory p0, uint256 p1) private pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,uint256)\", p0, p1));\n }\n\n function console2_log_StdUtils(string memory p0, string memory p1) private pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,string)\", p0, p1));\n }\n}\n","license":"MIT"},"lib/forge-std/src/Vm.sol":{"keccak256":"0xd91fb0df409fbd22463e937b48b9682d9333c5d4528d8fe7b36102a0323c44bf","urls":[],"content":"// Automatically @generated by scripts/vm.py. Do not modify manually.\n\n// SPDX-License-Identifier: MIT OR Apache-2.0\npragma solidity >=0.6.2 <0.9.0;\npragma experimental ABIEncoderV2;\n\n/// The `VmSafe` interface does not allow manipulation of the EVM state or other actions that may\n/// result in Script simulations differing from on-chain execution. It is recommended to only use\n/// these cheats in scripts.\ninterface VmSafe {\n /// A modification applied to either `msg.sender` or `tx.origin`. Returned by `readCallers`.\n enum CallerMode {\n // No caller modification is currently active.\n None,\n // A one time broadcast triggered by a `vm.broadcast()` call is currently active.\n Broadcast,\n // A recurrent broadcast triggered by a `vm.startBroadcast()` call is currently active.\n RecurrentBroadcast,\n // A one time prank triggered by a `vm.prank()` call is currently active.\n Prank,\n // A recurrent prank triggered by a `vm.startPrank()` call is currently active.\n RecurrentPrank\n }\n\n /// The kind of account access that occurred.\n enum AccountAccessKind {\n // The account was called.\n Call,\n // The account was called via delegatecall.\n DelegateCall,\n // The account was called via callcode.\n CallCode,\n // The account was called via staticcall.\n StaticCall,\n // The account was created.\n Create,\n // The account was selfdestructed.\n SelfDestruct,\n // Synthetic access indicating the current context has resumed after a previous sub-context (AccountAccess).\n Resume,\n // The account's balance was read.\n Balance,\n // The account's codesize was read.\n Extcodesize,\n // The account's codehash was read.\n Extcodehash,\n // The account's code was copied.\n Extcodecopy\n }\n\n /// Forge execution contexts.\n enum ForgeContext {\n // Test group execution context (test, coverage or snapshot).\n TestGroup,\n // `forge test` execution context.\n Test,\n // `forge coverage` execution context.\n Coverage,\n // `forge snapshot` execution context.\n Snapshot,\n // Script group execution context (dry run, broadcast or resume).\n ScriptGroup,\n // `forge script` execution context.\n ScriptDryRun,\n // `forge script --broadcast` execution context.\n ScriptBroadcast,\n // `forge script --resume` execution context.\n ScriptResume,\n // Unknown `forge` execution context.\n Unknown\n }\n\n /// The transaction type (`txType`) of the broadcast.\n enum BroadcastTxType {\n // Represents a CALL broadcast tx.\n Call,\n // Represents a CREATE broadcast tx.\n Create,\n // Represents a CREATE2 broadcast tx.\n Create2\n }\n\n /// An Ethereum log. Returned by `getRecordedLogs`.\n struct Log {\n // The topics of the log, including the signature, if any.\n bytes32[] topics;\n // The raw data of the log.\n bytes data;\n // The address of the log's emitter.\n address emitter;\n }\n\n /// An RPC URL and its alias. Returned by `rpcUrlStructs`.\n struct Rpc {\n // The alias of the RPC URL.\n string key;\n // The RPC URL.\n string url;\n }\n\n /// An RPC log object. Returned by `eth_getLogs`.\n struct EthGetLogs {\n // The address of the log's emitter.\n address emitter;\n // The topics of the log, including the signature, if any.\n bytes32[] topics;\n // The raw data of the log.\n bytes data;\n // The block hash.\n bytes32 blockHash;\n // The block number.\n uint64 blockNumber;\n // The transaction hash.\n bytes32 transactionHash;\n // The transaction index in the block.\n uint64 transactionIndex;\n // The log index.\n uint256 logIndex;\n // Whether the log was removed.\n bool removed;\n }\n\n /// A single entry in a directory listing. Returned by `readDir`.\n struct DirEntry {\n // The error message, if any.\n string errorMessage;\n // The path of the entry.\n string path;\n // The depth of the entry.\n uint64 depth;\n // Whether the entry is a directory.\n bool isDir;\n // Whether the entry is a symlink.\n bool isSymlink;\n }\n\n /// Metadata information about a file.\n /// This structure is returned from the `fsMetadata` function and represents known\n /// metadata about a file such as its permissions, size, modification\n /// times, etc.\n struct FsMetadata {\n // True if this metadata is for a directory.\n bool isDir;\n // True if this metadata is for a symlink.\n bool isSymlink;\n // The size of the file, in bytes, this metadata is for.\n uint256 length;\n // True if this metadata is for a readonly (unwritable) file.\n bool readOnly;\n // The last modification time listed in this metadata.\n uint256 modified;\n // The last access time of this metadata.\n uint256 accessed;\n // The creation time listed in this metadata.\n uint256 created;\n }\n\n /// A wallet with a public and private key.\n struct Wallet {\n // The wallet's address.\n address addr;\n // The wallet's public key `X`.\n uint256 publicKeyX;\n // The wallet's public key `Y`.\n uint256 publicKeyY;\n // The wallet's private key.\n uint256 privateKey;\n }\n\n /// The result of a `tryFfi` call.\n struct FfiResult {\n // The exit code of the call.\n int32 exitCode;\n // The optionally hex-decoded `stdout` data.\n bytes stdout;\n // The `stderr` data.\n bytes stderr;\n }\n\n /// Information on the chain and fork.\n struct ChainInfo {\n // The fork identifier. Set to zero if no fork is active.\n uint256 forkId;\n // The chain ID of the current fork.\n uint256 chainId;\n }\n\n /// The result of a `stopAndReturnStateDiff` call.\n struct AccountAccess {\n // The chain and fork the access occurred.\n ChainInfo chainInfo;\n // The kind of account access that determines what the account is.\n // If kind is Call, DelegateCall, StaticCall or CallCode, then the account is the callee.\n // If kind is Create, then the account is the newly created account.\n // If kind is SelfDestruct, then the account is the selfdestruct recipient.\n // If kind is a Resume, then account represents a account context that has resumed.\n AccountAccessKind kind;\n // The account that was accessed.\n // It's either the account created, callee or a selfdestruct recipient for CREATE, CALL or SELFDESTRUCT.\n address account;\n // What accessed the account.\n address accessor;\n // If the account was initialized or empty prior to the access.\n // An account is considered initialized if it has code, a\n // non-zero nonce, or a non-zero balance.\n bool initialized;\n // The previous balance of the accessed account.\n uint256 oldBalance;\n // The potential new balance of the accessed account.\n // That is, all balance changes are recorded here, even if reverts occurred.\n uint256 newBalance;\n // Code of the account deployed by CREATE.\n bytes deployedCode;\n // Value passed along with the account access\n uint256 value;\n // Input data provided to the CREATE or CALL\n bytes data;\n // If this access reverted in either the current or parent context.\n bool reverted;\n // An ordered list of storage accesses made during an account access operation.\n StorageAccess[] storageAccesses;\n // Call depth traversed during the recording of state differences\n uint64 depth;\n }\n\n /// The storage accessed during an `AccountAccess`.\n struct StorageAccess {\n // The account whose storage was accessed.\n address account;\n // The slot that was accessed.\n bytes32 slot;\n // If the access was a write.\n bool isWrite;\n // The previous value of the slot.\n bytes32 previousValue;\n // The new value of the slot.\n bytes32 newValue;\n // If the access was reverted.\n bool reverted;\n }\n\n /// Gas used. Returned by `lastCallGas`.\n struct Gas {\n // The gas limit of the call.\n uint64 gasLimit;\n // The total gas used.\n uint64 gasTotalUsed;\n // DEPRECATED: The amount of gas used for memory expansion. Ref: \n uint64 gasMemoryUsed;\n // The amount of gas refunded.\n int64 gasRefunded;\n // The amount of gas remaining.\n uint64 gasRemaining;\n }\n\n /// The result of the `stopDebugTraceRecording` call\n struct DebugStep {\n // The stack before executing the step of the run.\n // stack\\[0\\] represents the top of the stack.\n // and only stack data relevant to the opcode execution is contained.\n uint256[] stack;\n // The memory input data before executing the step of the run.\n // only input data relevant to the opcode execution is contained.\n // e.g. for MLOAD, it will have memory\\[offset:offset+32\\] copied here.\n // the offset value can be get by the stack data.\n bytes memoryInput;\n // The opcode that was accessed.\n uint8 opcode;\n // The call depth of the step.\n uint64 depth;\n // Whether the call end up with out of gas error.\n bool isOutOfGas;\n // The contract address where the opcode is running\n address contractAddr;\n }\n\n /// Represents a transaction's broadcast details.\n struct BroadcastTxSummary {\n // The hash of the transaction that was broadcasted\n bytes32 txHash;\n // Represent the type of transaction among CALL, CREATE, CREATE2\n BroadcastTxType txType;\n // The address of the contract that was called or created.\n // This is address of the contract that is created if the txType is CREATE or CREATE2.\n address contractAddress;\n // The block number the transaction landed in.\n uint64 blockNumber;\n // Status of the transaction, retrieved from the transaction receipt.\n bool success;\n }\n\n /// Holds a signed EIP-7702 authorization for an authority account to delegate to an implementation.\n struct SignedDelegation {\n // The y-parity of the recovered secp256k1 signature (0 or 1).\n uint8 v;\n // First 32 bytes of the signature.\n bytes32 r;\n // Second 32 bytes of the signature.\n bytes32 s;\n // The current nonce of the authority account at signing time.\n // Used to ensure signature can't be replayed after account nonce changes.\n uint64 nonce;\n // Address of the contract implementation that will be delegated to.\n // Gets encoded into delegation code: 0xef0100 || implementation.\n address implementation;\n }\n\n /// Represents a \"potential\" revert reason from a single subsequent call when using `vm.assumeNoReverts`.\n /// Reverts that match will result in a FOUNDRY::ASSUME rejection, whereas unmatched reverts will be surfaced\n /// as normal.\n struct PotentialRevert {\n // The allowed origin of the revert opcode; address(0) allows reverts from any address\n address reverter;\n // When true, only matches on the beginning of the revert data, otherwise, matches on entire revert data\n bool partialMatch;\n // The data to use to match encountered reverts\n bytes revertData;\n }\n\n /// An EIP-2930 access list item.\n struct AccessListItem {\n // The address to be added in access list.\n address target;\n // The storage keys to be added in access list.\n bytes32[] storageKeys;\n }\n\n // ======== Crypto ========\n\n /// Derives a private key from the name, labels the account with that name, and returns the wallet.\n function createWallet(string calldata walletLabel) external returns (Wallet memory wallet);\n\n /// Generates a wallet from the private key and returns the wallet.\n function createWallet(uint256 privateKey) external returns (Wallet memory wallet);\n\n /// Generates a wallet from the private key, labels the account with that name, and returns the wallet.\n function createWallet(uint256 privateKey, string calldata walletLabel) external returns (Wallet memory wallet);\n\n /// Derive a private key from a provided mnenomic string (or mnenomic file path)\n /// at the derivation path `m/44'/60'/0'/0/{index}`.\n function deriveKey(string calldata mnemonic, uint32 index) external pure returns (uint256 privateKey);\n\n /// Derive a private key from a provided mnenomic string (or mnenomic file path)\n /// at `{derivationPath}{index}`.\n function deriveKey(string calldata mnemonic, string calldata derivationPath, uint32 index)\n external\n pure\n returns (uint256 privateKey);\n\n /// Derive a private key from a provided mnenomic string (or mnenomic file path) in the specified language\n /// at the derivation path `m/44'/60'/0'/0/{index}`.\n function deriveKey(string calldata mnemonic, uint32 index, string calldata language)\n external\n pure\n returns (uint256 privateKey);\n\n /// Derive a private key from a provided mnenomic string (or mnenomic file path) in the specified language\n /// at `{derivationPath}{index}`.\n function deriveKey(string calldata mnemonic, string calldata derivationPath, uint32 index, string calldata language)\n external\n pure\n returns (uint256 privateKey);\n\n /// Derives secp256r1 public key from the provided `privateKey`.\n function publicKeyP256(uint256 privateKey) external pure returns (uint256 publicKeyX, uint256 publicKeyY);\n\n /// Adds a private key to the local forge wallet and returns the address.\n function rememberKey(uint256 privateKey) external returns (address keyAddr);\n\n /// Derive a set number of wallets from a mnemonic at the derivation path `m/44'/60'/0'/0/{0..count}`.\n /// The respective private keys are saved to the local forge wallet for later use and their addresses are returned.\n function rememberKeys(string calldata mnemonic, string calldata derivationPath, uint32 count)\n external\n returns (address[] memory keyAddrs);\n\n /// Derive a set number of wallets from a mnemonic in the specified language at the derivation path `m/44'/60'/0'/0/{0..count}`.\n /// The respective private keys are saved to the local forge wallet for later use and their addresses are returned.\n function rememberKeys(\n string calldata mnemonic,\n string calldata derivationPath,\n string calldata language,\n uint32 count\n ) external returns (address[] memory keyAddrs);\n\n /// Signs data with a `Wallet`.\n /// Returns a compact signature (`r`, `vs`) as per EIP-2098, where `vs` encodes both the\n /// signature's `s` value, and the recovery id `v` in a single bytes32.\n /// This format reduces the signature size from 65 to 64 bytes.\n function signCompact(Wallet calldata wallet, bytes32 digest) external returns (bytes32 r, bytes32 vs);\n\n /// Signs `digest` with `privateKey` using the secp256k1 curve.\n /// Returns a compact signature (`r`, `vs`) as per EIP-2098, where `vs` encodes both the\n /// signature's `s` value, and the recovery id `v` in a single bytes32.\n /// This format reduces the signature size from 65 to 64 bytes.\n function signCompact(uint256 privateKey, bytes32 digest) external pure returns (bytes32 r, bytes32 vs);\n\n /// Signs `digest` with signer provided to script using the secp256k1 curve.\n /// Returns a compact signature (`r`, `vs`) as per EIP-2098, where `vs` encodes both the\n /// signature's `s` value, and the recovery id `v` in a single bytes32.\n /// This format reduces the signature size from 65 to 64 bytes.\n /// If `--sender` is provided, the signer with provided address is used, otherwise,\n /// if exactly one signer is provided to the script, that signer is used.\n /// Raises error if signer passed through `--sender` does not match any unlocked signers or\n /// if `--sender` is not provided and not exactly one signer is passed to the script.\n function signCompact(bytes32 digest) external pure returns (bytes32 r, bytes32 vs);\n\n /// Signs `digest` with signer provided to script using the secp256k1 curve.\n /// Returns a compact signature (`r`, `vs`) as per EIP-2098, where `vs` encodes both the\n /// signature's `s` value, and the recovery id `v` in a single bytes32.\n /// This format reduces the signature size from 65 to 64 bytes.\n /// Raises error if none of the signers passed into the script have provided address.\n function signCompact(address signer, bytes32 digest) external pure returns (bytes32 r, bytes32 vs);\n\n /// Signs `digest` with `privateKey` using the secp256r1 curve.\n function signP256(uint256 privateKey, bytes32 digest) external pure returns (bytes32 r, bytes32 s);\n\n /// Signs data with a `Wallet`.\n function sign(Wallet calldata wallet, bytes32 digest) external returns (uint8 v, bytes32 r, bytes32 s);\n\n /// Signs `digest` with `privateKey` using the secp256k1 curve.\n function sign(uint256 privateKey, bytes32 digest) external pure returns (uint8 v, bytes32 r, bytes32 s);\n\n /// Signs `digest` with signer provided to script using the secp256k1 curve.\n /// If `--sender` is provided, the signer with provided address is used, otherwise,\n /// if exactly one signer is provided to the script, that signer is used.\n /// Raises error if signer passed through `--sender` does not match any unlocked signers or\n /// if `--sender` is not provided and not exactly one signer is passed to the script.\n function sign(bytes32 digest) external pure returns (uint8 v, bytes32 r, bytes32 s);\n\n /// Signs `digest` with signer provided to script using the secp256k1 curve.\n /// Raises error if none of the signers passed into the script have provided address.\n function sign(address signer, bytes32 digest) external pure returns (uint8 v, bytes32 r, bytes32 s);\n\n // ======== Environment ========\n\n /// Gets the environment variable `name` and parses it as `address`.\n /// Reverts if the variable was not found or could not be parsed.\n function envAddress(string calldata name) external view returns (address value);\n\n /// Gets the environment variable `name` and parses it as an array of `address`, delimited by `delim`.\n /// Reverts if the variable was not found or could not be parsed.\n function envAddress(string calldata name, string calldata delim) external view returns (address[] memory value);\n\n /// Gets the environment variable `name` and parses it as `bool`.\n /// Reverts if the variable was not found or could not be parsed.\n function envBool(string calldata name) external view returns (bool value);\n\n /// Gets the environment variable `name` and parses it as an array of `bool`, delimited by `delim`.\n /// Reverts if the variable was not found or could not be parsed.\n function envBool(string calldata name, string calldata delim) external view returns (bool[] memory value);\n\n /// Gets the environment variable `name` and parses it as `bytes32`.\n /// Reverts if the variable was not found or could not be parsed.\n function envBytes32(string calldata name) external view returns (bytes32 value);\n\n /// Gets the environment variable `name` and parses it as an array of `bytes32`, delimited by `delim`.\n /// Reverts if the variable was not found or could not be parsed.\n function envBytes32(string calldata name, string calldata delim) external view returns (bytes32[] memory value);\n\n /// Gets the environment variable `name` and parses it as `bytes`.\n /// Reverts if the variable was not found or could not be parsed.\n function envBytes(string calldata name) external view returns (bytes memory value);\n\n /// Gets the environment variable `name` and parses it as an array of `bytes`, delimited by `delim`.\n /// Reverts if the variable was not found or could not be parsed.\n function envBytes(string calldata name, string calldata delim) external view returns (bytes[] memory value);\n\n /// Gets the environment variable `name` and returns true if it exists, else returns false.\n function envExists(string calldata name) external view returns (bool result);\n\n /// Gets the environment variable `name` and parses it as `int256`.\n /// Reverts if the variable was not found or could not be parsed.\n function envInt(string calldata name) external view returns (int256 value);\n\n /// Gets the environment variable `name` and parses it as an array of `int256`, delimited by `delim`.\n /// Reverts if the variable was not found or could not be parsed.\n function envInt(string calldata name, string calldata delim) external view returns (int256[] memory value);\n\n /// Gets the environment variable `name` and parses it as `bool`.\n /// Reverts if the variable could not be parsed.\n /// Returns `defaultValue` if the variable was not found.\n function envOr(string calldata name, bool defaultValue) external view returns (bool value);\n\n /// Gets the environment variable `name` and parses it as `uint256`.\n /// Reverts if the variable could not be parsed.\n /// Returns `defaultValue` if the variable was not found.\n function envOr(string calldata name, uint256 defaultValue) external view returns (uint256 value);\n\n /// Gets the environment variable `name` and parses it as an array of `address`, delimited by `delim`.\n /// Reverts if the variable could not be parsed.\n /// Returns `defaultValue` if the variable was not found.\n function envOr(string calldata name, string calldata delim, address[] calldata defaultValue)\n external\n view\n returns (address[] memory value);\n\n /// Gets the environment variable `name` and parses it as an array of `bytes32`, delimited by `delim`.\n /// Reverts if the variable could not be parsed.\n /// Returns `defaultValue` if the variable was not found.\n function envOr(string calldata name, string calldata delim, bytes32[] calldata defaultValue)\n external\n view\n returns (bytes32[] memory value);\n\n /// Gets the environment variable `name` and parses it as an array of `string`, delimited by `delim`.\n /// Reverts if the variable could not be parsed.\n /// Returns `defaultValue` if the variable was not found.\n function envOr(string calldata name, string calldata delim, string[] calldata defaultValue)\n external\n view\n returns (string[] memory value);\n\n /// Gets the environment variable `name` and parses it as an array of `bytes`, delimited by `delim`.\n /// Reverts if the variable could not be parsed.\n /// Returns `defaultValue` if the variable was not found.\n function envOr(string calldata name, string calldata delim, bytes[] calldata defaultValue)\n external\n view\n returns (bytes[] memory value);\n\n /// Gets the environment variable `name` and parses it as `int256`.\n /// Reverts if the variable could not be parsed.\n /// Returns `defaultValue` if the variable was not found.\n function envOr(string calldata name, int256 defaultValue) external view returns (int256 value);\n\n /// Gets the environment variable `name` and parses it as `address`.\n /// Reverts if the variable could not be parsed.\n /// Returns `defaultValue` if the variable was not found.\n function envOr(string calldata name, address defaultValue) external view returns (address value);\n\n /// Gets the environment variable `name` and parses it as `bytes32`.\n /// Reverts if the variable could not be parsed.\n /// Returns `defaultValue` if the variable was not found.\n function envOr(string calldata name, bytes32 defaultValue) external view returns (bytes32 value);\n\n /// Gets the environment variable `name` and parses it as `string`.\n /// Reverts if the variable could not be parsed.\n /// Returns `defaultValue` if the variable was not found.\n function envOr(string calldata name, string calldata defaultValue) external view returns (string memory value);\n\n /// Gets the environment variable `name` and parses it as `bytes`.\n /// Reverts if the variable could not be parsed.\n /// Returns `defaultValue` if the variable was not found.\n function envOr(string calldata name, bytes calldata defaultValue) external view returns (bytes memory value);\n\n /// Gets the environment variable `name` and parses it as an array of `bool`, delimited by `delim`.\n /// Reverts if the variable could not be parsed.\n /// Returns `defaultValue` if the variable was not found.\n function envOr(string calldata name, string calldata delim, bool[] calldata defaultValue)\n external\n view\n returns (bool[] memory value);\n\n /// Gets the environment variable `name` and parses it as an array of `uint256`, delimited by `delim`.\n /// Reverts if the variable could not be parsed.\n /// Returns `defaultValue` if the variable was not found.\n function envOr(string calldata name, string calldata delim, uint256[] calldata defaultValue)\n external\n view\n returns (uint256[] memory value);\n\n /// Gets the environment variable `name` and parses it as an array of `int256`, delimited by `delim`.\n /// Reverts if the variable could not be parsed.\n /// Returns `defaultValue` if the variable was not found.\n function envOr(string calldata name, string calldata delim, int256[] calldata defaultValue)\n external\n view\n returns (int256[] memory value);\n\n /// Gets the environment variable `name` and parses it as `string`.\n /// Reverts if the variable was not found or could not be parsed.\n function envString(string calldata name) external view returns (string memory value);\n\n /// Gets the environment variable `name` and parses it as an array of `string`, delimited by `delim`.\n /// Reverts if the variable was not found or could not be parsed.\n function envString(string calldata name, string calldata delim) external view returns (string[] memory value);\n\n /// Gets the environment variable `name` and parses it as `uint256`.\n /// Reverts if the variable was not found or could not be parsed.\n function envUint(string calldata name) external view returns (uint256 value);\n\n /// Gets the environment variable `name` and parses it as an array of `uint256`, delimited by `delim`.\n /// Reverts if the variable was not found or could not be parsed.\n function envUint(string calldata name, string calldata delim) external view returns (uint256[] memory value);\n\n /// Returns true if `forge` command was executed in given context.\n function isContext(ForgeContext context) external view returns (bool result);\n\n /// Sets environment variables.\n function setEnv(string calldata name, string calldata value) external;\n\n // ======== EVM ========\n\n /// Gets all accessed reads and write slot from a `vm.record` session, for a given address.\n function accesses(address target) external returns (bytes32[] memory readSlots, bytes32[] memory writeSlots);\n\n /// Gets the address for a given private key.\n function addr(uint256 privateKey) external pure returns (address keyAddr);\n\n /// Gets all the logs according to specified filter.\n function eth_getLogs(uint256 fromBlock, uint256 toBlock, address target, bytes32[] calldata topics)\n external\n returns (EthGetLogs[] memory logs);\n\n /// Gets the current `block.blobbasefee`.\n /// You should use this instead of `block.blobbasefee` if you use `vm.blobBaseFee`, as `block.blobbasefee` is assumed to be constant across a transaction,\n /// and as a result will get optimized out by the compiler.\n /// See https://github.com/foundry-rs/foundry/issues/6180\n function getBlobBaseFee() external view returns (uint256 blobBaseFee);\n\n /// Gets the current `block.number`.\n /// You should use this instead of `block.number` if you use `vm.roll`, as `block.number` is assumed to be constant across a transaction,\n /// and as a result will get optimized out by the compiler.\n /// See https://github.com/foundry-rs/foundry/issues/6180\n function getBlockNumber() external view returns (uint256 height);\n\n /// Gets the current `block.timestamp`.\n /// You should use this instead of `block.timestamp` if you use `vm.warp`, as `block.timestamp` is assumed to be constant across a transaction,\n /// and as a result will get optimized out by the compiler.\n /// See https://github.com/foundry-rs/foundry/issues/6180\n function getBlockTimestamp() external view returns (uint256 timestamp);\n\n /// Gets the map key and parent of a mapping at a given slot, for a given address.\n function getMappingKeyAndParentOf(address target, bytes32 elementSlot)\n external\n returns (bool found, bytes32 key, bytes32 parent);\n\n /// Gets the number of elements in the mapping at the given slot, for a given address.\n function getMappingLength(address target, bytes32 mappingSlot) external returns (uint256 length);\n\n /// Gets the elements at index idx of the mapping at the given slot, for a given address. The\n /// index must be less than the length of the mapping (i.e. the number of keys in the mapping).\n function getMappingSlotAt(address target, bytes32 mappingSlot, uint256 idx) external returns (bytes32 value);\n\n /// Gets the nonce of an account.\n function getNonce(address account) external view returns (uint64 nonce);\n\n /// Get the nonce of a `Wallet`.\n function getNonce(Wallet calldata wallet) external returns (uint64 nonce);\n\n /// Gets all the recorded logs.\n function getRecordedLogs() external returns (Log[] memory logs);\n\n /// Returns state diffs from current `vm.startStateDiffRecording` session.\n function getStateDiff() external view returns (string memory diff);\n\n /// Returns state diffs from current `vm.startStateDiffRecording` session, in json format.\n function getStateDiffJson() external view returns (string memory diff);\n\n /// Gets the gas used in the last call from the callee perspective.\n function lastCallGas() external view returns (Gas memory gas);\n\n /// Loads a storage slot from an address.\n function load(address target, bytes32 slot) external view returns (bytes32 data);\n\n /// Pauses gas metering (i.e. gas usage is not counted). Noop if already paused.\n function pauseGasMetering() external;\n\n /// Records all storage reads and writes.\n function record() external;\n\n /// Record all the transaction logs.\n function recordLogs() external;\n\n /// Reset gas metering (i.e. gas usage is set to gas limit).\n function resetGasMetering() external;\n\n /// Resumes gas metering (i.e. gas usage is counted again). Noop if already on.\n function resumeGasMetering() external;\n\n /// Performs an Ethereum JSON-RPC request to the current fork URL.\n function rpc(string calldata method, string calldata params) external returns (bytes memory data);\n\n /// Performs an Ethereum JSON-RPC request to the given endpoint.\n function rpc(string calldata urlOrAlias, string calldata method, string calldata params)\n external\n returns (bytes memory data);\n\n /// Records the debug trace during the run.\n function startDebugTraceRecording() external;\n\n /// Starts recording all map SSTOREs for later retrieval.\n function startMappingRecording() external;\n\n /// Record all account accesses as part of CREATE, CALL or SELFDESTRUCT opcodes in order,\n /// along with the context of the calls\n function startStateDiffRecording() external;\n\n /// Stop debug trace recording and returns the recorded debug trace.\n function stopAndReturnDebugTraceRecording() external returns (DebugStep[] memory step);\n\n /// Returns an ordered array of all account accesses from a `vm.startStateDiffRecording` session.\n function stopAndReturnStateDiff() external returns (AccountAccess[] memory accountAccesses);\n\n /// Stops recording all map SSTOREs for later retrieval and clears the recorded data.\n function stopMappingRecording() external;\n\n // ======== Filesystem ========\n\n /// Closes file for reading, resetting the offset and allowing to read it from beginning with readLine.\n /// `path` is relative to the project root.\n function closeFile(string calldata path) external;\n\n /// Copies the contents of one file to another. This function will **overwrite** the contents of `to`.\n /// On success, the total number of bytes copied is returned and it is equal to the length of the `to` file as reported by `metadata`.\n /// Both `from` and `to` are relative to the project root.\n function copyFile(string calldata from, string calldata to) external returns (uint64 copied);\n\n /// Creates a new, empty directory at the provided path.\n /// This cheatcode will revert in the following situations, but is not limited to just these cases:\n /// - User lacks permissions to modify `path`.\n /// - A parent of the given path doesn't exist and `recursive` is false.\n /// - `path` already exists and `recursive` is false.\n /// `path` is relative to the project root.\n function createDir(string calldata path, bool recursive) external;\n\n /// Deploys a contract from an artifact file. Takes in the relative path to the json file or the path to the\n /// artifact in the form of :: where and parts are optional.\n function deployCode(string calldata artifactPath) external returns (address deployedAddress);\n\n /// Deploys a contract from an artifact file. Takes in the relative path to the json file or the path to the\n /// artifact in the form of :: where and parts are optional.\n /// Additionally accepts abi-encoded constructor arguments.\n function deployCode(string calldata artifactPath, bytes calldata constructorArgs)\n external\n returns (address deployedAddress);\n\n /// Returns true if the given path points to an existing entity, else returns false.\n function exists(string calldata path) external view returns (bool result);\n\n /// Performs a foreign function call via the terminal.\n function ffi(string[] calldata commandInput) external returns (bytes memory result);\n\n /// Given a path, query the file system to get information about a file, directory, etc.\n function fsMetadata(string calldata path) external view returns (FsMetadata memory metadata);\n\n /// Gets the artifact path from code (aka. creation code).\n function getArtifactPathByCode(bytes calldata code) external view returns (string memory path);\n\n /// Gets the artifact path from deployed code (aka. runtime code).\n function getArtifactPathByDeployedCode(bytes calldata deployedCode) external view returns (string memory path);\n\n /// Returns the most recent broadcast for the given contract on `chainId` matching `txType`.\n /// For example:\n /// The most recent deployment can be fetched by passing `txType` as `CREATE` or `CREATE2`.\n /// The most recent call can be fetched by passing `txType` as `CALL`.\n function getBroadcast(string calldata contractName, uint64 chainId, BroadcastTxType txType)\n external\n view\n returns (BroadcastTxSummary memory);\n\n /// Returns all broadcasts for the given contract on `chainId` with the specified `txType`.\n /// Sorted such that the most recent broadcast is the first element, and the oldest is the last. i.e descending order of BroadcastTxSummary.blockNumber.\n function getBroadcasts(string calldata contractName, uint64 chainId, BroadcastTxType txType)\n external\n view\n returns (BroadcastTxSummary[] memory);\n\n /// Returns all broadcasts for the given contract on `chainId`.\n /// Sorted such that the most recent broadcast is the first element, and the oldest is the last. i.e descending order of BroadcastTxSummary.blockNumber.\n function getBroadcasts(string calldata contractName, uint64 chainId)\n external\n view\n returns (BroadcastTxSummary[] memory);\n\n /// Gets the creation bytecode from an artifact file. Takes in the relative path to the json file or the path to the\n /// artifact in the form of :: where and parts are optional.\n function getCode(string calldata artifactPath) external view returns (bytes memory creationBytecode);\n\n /// Gets the deployed bytecode from an artifact file. Takes in the relative path to the json file or the path to the\n /// artifact in the form of :: where and parts are optional.\n function getDeployedCode(string calldata artifactPath) external view returns (bytes memory runtimeBytecode);\n\n /// Returns the most recent deployment for the current `chainId`.\n function getDeployment(string calldata contractName) external view returns (address deployedAddress);\n\n /// Returns the most recent deployment for the given contract on `chainId`\n function getDeployment(string calldata contractName, uint64 chainId)\n external\n view\n returns (address deployedAddress);\n\n /// Returns all deployments for the given contract on `chainId`\n /// Sorted in descending order of deployment time i.e descending order of BroadcastTxSummary.blockNumber.\n /// The most recent deployment is the first element, and the oldest is the last.\n function getDeployments(string calldata contractName, uint64 chainId)\n external\n view\n returns (address[] memory deployedAddresses);\n\n /// Returns true if the path exists on disk and is pointing at a directory, else returns false.\n function isDir(string calldata path) external view returns (bool result);\n\n /// Returns true if the path exists on disk and is pointing at a regular file, else returns false.\n function isFile(string calldata path) external view returns (bool result);\n\n /// Get the path of the current project root.\n function projectRoot() external view returns (string memory path);\n\n /// Prompts the user for a string value in the terminal.\n function prompt(string calldata promptText) external returns (string memory input);\n\n /// Prompts the user for an address in the terminal.\n function promptAddress(string calldata promptText) external returns (address);\n\n /// Prompts the user for a hidden string value in the terminal.\n function promptSecret(string calldata promptText) external returns (string memory input);\n\n /// Prompts the user for hidden uint256 in the terminal (usually pk).\n function promptSecretUint(string calldata promptText) external returns (uint256);\n\n /// Prompts the user for uint256 in the terminal.\n function promptUint(string calldata promptText) external returns (uint256);\n\n /// Reads the directory at the given path recursively, up to `maxDepth`.\n /// `maxDepth` defaults to 1, meaning only the direct children of the given directory will be returned.\n /// Follows symbolic links if `followLinks` is true.\n function readDir(string calldata path) external view returns (DirEntry[] memory entries);\n\n /// See `readDir(string)`.\n function readDir(string calldata path, uint64 maxDepth) external view returns (DirEntry[] memory entries);\n\n /// See `readDir(string)`.\n function readDir(string calldata path, uint64 maxDepth, bool followLinks)\n external\n view\n returns (DirEntry[] memory entries);\n\n /// Reads the entire content of file to string. `path` is relative to the project root.\n function readFile(string calldata path) external view returns (string memory data);\n\n /// Reads the entire content of file as binary. `path` is relative to the project root.\n function readFileBinary(string calldata path) external view returns (bytes memory data);\n\n /// Reads next line of file to string.\n function readLine(string calldata path) external view returns (string memory line);\n\n /// Reads a symbolic link, returning the path that the link points to.\n /// This cheatcode will revert in the following situations, but is not limited to just these cases:\n /// - `path` is not a symbolic link.\n /// - `path` does not exist.\n function readLink(string calldata linkPath) external view returns (string memory targetPath);\n\n /// Removes a directory at the provided path.\n /// This cheatcode will revert in the following situations, but is not limited to just these cases:\n /// - `path` doesn't exist.\n /// - `path` isn't a directory.\n /// - User lacks permissions to modify `path`.\n /// - The directory is not empty and `recursive` is false.\n /// `path` is relative to the project root.\n function removeDir(string calldata path, bool recursive) external;\n\n /// Removes a file from the filesystem.\n /// This cheatcode will revert in the following situations, but is not limited to just these cases:\n /// - `path` points to a directory.\n /// - The file doesn't exist.\n /// - The user lacks permissions to remove the file.\n /// `path` is relative to the project root.\n function removeFile(string calldata path) external;\n\n /// Performs a foreign function call via terminal and returns the exit code, stdout, and stderr.\n function tryFfi(string[] calldata commandInput) external returns (FfiResult memory result);\n\n /// Returns the time since unix epoch in milliseconds.\n function unixTime() external view returns (uint256 milliseconds);\n\n /// Writes data to file, creating a file if it does not exist, and entirely replacing its contents if it does.\n /// `path` is relative to the project root.\n function writeFile(string calldata path, string calldata data) external;\n\n /// Writes binary data to a file, creating a file if it does not exist, and entirely replacing its contents if it does.\n /// `path` is relative to the project root.\n function writeFileBinary(string calldata path, bytes calldata data) external;\n\n /// Writes line to file, creating a file if it does not exist.\n /// `path` is relative to the project root.\n function writeLine(string calldata path, string calldata data) external;\n\n // ======== JSON ========\n\n /// Checks if `key` exists in a JSON object.\n function keyExistsJson(string calldata json, string calldata key) external view returns (bool);\n\n /// Parses a string of JSON data at `key` and coerces it to `address`.\n function parseJsonAddress(string calldata json, string calldata key) external pure returns (address);\n\n /// Parses a string of JSON data at `key` and coerces it to `address[]`.\n function parseJsonAddressArray(string calldata json, string calldata key)\n external\n pure\n returns (address[] memory);\n\n /// Parses a string of JSON data at `key` and coerces it to `bool`.\n function parseJsonBool(string calldata json, string calldata key) external pure returns (bool);\n\n /// Parses a string of JSON data at `key` and coerces it to `bool[]`.\n function parseJsonBoolArray(string calldata json, string calldata key) external pure returns (bool[] memory);\n\n /// Parses a string of JSON data at `key` and coerces it to `bytes`.\n function parseJsonBytes(string calldata json, string calldata key) external pure returns (bytes memory);\n\n /// Parses a string of JSON data at `key` and coerces it to `bytes32`.\n function parseJsonBytes32(string calldata json, string calldata key) external pure returns (bytes32);\n\n /// Parses a string of JSON data at `key` and coerces it to `bytes32[]`.\n function parseJsonBytes32Array(string calldata json, string calldata key)\n external\n pure\n returns (bytes32[] memory);\n\n /// Parses a string of JSON data at `key` and coerces it to `bytes[]`.\n function parseJsonBytesArray(string calldata json, string calldata key) external pure returns (bytes[] memory);\n\n /// Parses a string of JSON data at `key` and coerces it to `int256`.\n function parseJsonInt(string calldata json, string calldata key) external pure returns (int256);\n\n /// Parses a string of JSON data at `key` and coerces it to `int256[]`.\n function parseJsonIntArray(string calldata json, string calldata key) external pure returns (int256[] memory);\n\n /// Returns an array of all the keys in a JSON object.\n function parseJsonKeys(string calldata json, string calldata key) external pure returns (string[] memory keys);\n\n /// Parses a string of JSON data at `key` and coerces it to `string`.\n function parseJsonString(string calldata json, string calldata key) external pure returns (string memory);\n\n /// Parses a string of JSON data at `key` and coerces it to `string[]`.\n function parseJsonStringArray(string calldata json, string calldata key) external pure returns (string[] memory);\n\n /// Parses a string of JSON data at `key` and coerces it to type array corresponding to `typeDescription`.\n function parseJsonTypeArray(string calldata json, string calldata key, string calldata typeDescription)\n external\n pure\n returns (bytes memory);\n\n /// Parses a string of JSON data and coerces it to type corresponding to `typeDescription`.\n function parseJsonType(string calldata json, string calldata typeDescription)\n external\n pure\n returns (bytes memory);\n\n /// Parses a string of JSON data at `key` and coerces it to type corresponding to `typeDescription`.\n function parseJsonType(string calldata json, string calldata key, string calldata typeDescription)\n external\n pure\n returns (bytes memory);\n\n /// Parses a string of JSON data at `key` and coerces it to `uint256`.\n function parseJsonUint(string calldata json, string calldata key) external pure returns (uint256);\n\n /// Parses a string of JSON data at `key` and coerces it to `uint256[]`.\n function parseJsonUintArray(string calldata json, string calldata key) external pure returns (uint256[] memory);\n\n /// ABI-encodes a JSON object.\n function parseJson(string calldata json) external pure returns (bytes memory abiEncodedData);\n\n /// ABI-encodes a JSON object at `key`.\n function parseJson(string calldata json, string calldata key) external pure returns (bytes memory abiEncodedData);\n\n /// See `serializeJson`.\n function serializeAddress(string calldata objectKey, string calldata valueKey, address value)\n external\n returns (string memory json);\n\n /// See `serializeJson`.\n function serializeAddress(string calldata objectKey, string calldata valueKey, address[] calldata values)\n external\n returns (string memory json);\n\n /// See `serializeJson`.\n function serializeBool(string calldata objectKey, string calldata valueKey, bool value)\n external\n returns (string memory json);\n\n /// See `serializeJson`.\n function serializeBool(string calldata objectKey, string calldata valueKey, bool[] calldata values)\n external\n returns (string memory json);\n\n /// See `serializeJson`.\n function serializeBytes32(string calldata objectKey, string calldata valueKey, bytes32 value)\n external\n returns (string memory json);\n\n /// See `serializeJson`.\n function serializeBytes32(string calldata objectKey, string calldata valueKey, bytes32[] calldata values)\n external\n returns (string memory json);\n\n /// See `serializeJson`.\n function serializeBytes(string calldata objectKey, string calldata valueKey, bytes calldata value)\n external\n returns (string memory json);\n\n /// See `serializeJson`.\n function serializeBytes(string calldata objectKey, string calldata valueKey, bytes[] calldata values)\n external\n returns (string memory json);\n\n /// See `serializeJson`.\n function serializeInt(string calldata objectKey, string calldata valueKey, int256 value)\n external\n returns (string memory json);\n\n /// See `serializeJson`.\n function serializeInt(string calldata objectKey, string calldata valueKey, int256[] calldata values)\n external\n returns (string memory json);\n\n /// Serializes a key and value to a JSON object stored in-memory that can be later written to a file.\n /// Returns the stringified version of the specific JSON file up to that moment.\n function serializeJson(string calldata objectKey, string calldata value) external returns (string memory json);\n\n /// See `serializeJson`.\n function serializeJsonType(string calldata typeDescription, bytes calldata value)\n external\n pure\n returns (string memory json);\n\n /// See `serializeJson`.\n function serializeJsonType(\n string calldata objectKey,\n string calldata valueKey,\n string calldata typeDescription,\n bytes calldata value\n ) external returns (string memory json);\n\n /// See `serializeJson`.\n function serializeString(string calldata objectKey, string calldata valueKey, string calldata value)\n external\n returns (string memory json);\n\n /// See `serializeJson`.\n function serializeString(string calldata objectKey, string calldata valueKey, string[] calldata values)\n external\n returns (string memory json);\n\n /// See `serializeJson`.\n function serializeUintToHex(string calldata objectKey, string calldata valueKey, uint256 value)\n external\n returns (string memory json);\n\n /// See `serializeJson`.\n function serializeUint(string calldata objectKey, string calldata valueKey, uint256 value)\n external\n returns (string memory json);\n\n /// See `serializeJson`.\n function serializeUint(string calldata objectKey, string calldata valueKey, uint256[] calldata values)\n external\n returns (string memory json);\n\n /// Write a serialized JSON object to a file. If the file exists, it will be overwritten.\n function writeJson(string calldata json, string calldata path) external;\n\n /// Write a serialized JSON object to an **existing** JSON file, replacing a value with key = \n /// This is useful to replace a specific value of a JSON file, without having to parse the entire thing.\n function writeJson(string calldata json, string calldata path, string calldata valueKey) external;\n\n /// Checks if `key` exists in a JSON object\n /// `keyExists` is being deprecated in favor of `keyExistsJson`. It will be removed in future versions.\n function keyExists(string calldata json, string calldata key) external view returns (bool);\n\n // ======== Scripting ========\n\n /// Designate the next call as an EIP-7702 transaction\n function attachDelegation(SignedDelegation calldata signedDelegation) external;\n\n /// Takes a signed transaction and broadcasts it to the network.\n function broadcastRawTransaction(bytes calldata data) external;\n\n /// Has the next call (at this call depth only) create transactions that can later be signed and sent onchain.\n /// Broadcasting address is determined by checking the following in order:\n /// 1. If `--sender` argument was provided, that address is used.\n /// 2. If exactly one signer (e.g. private key, hw wallet, keystore) is set when `forge broadcast` is invoked, that signer is used.\n /// 3. Otherwise, default foundry sender (1804c8AB1F12E6bbf3894d4083f33e07309d1f38) is used.\n function broadcast() external;\n\n /// Has the next call (at this call depth only) create a transaction with the address provided\n /// as the sender that can later be signed and sent onchain.\n function broadcast(address signer) external;\n\n /// Has the next call (at this call depth only) create a transaction with the private key\n /// provided as the sender that can later be signed and sent onchain.\n function broadcast(uint256 privateKey) external;\n\n /// Returns addresses of available unlocked wallets in the script environment.\n function getWallets() external returns (address[] memory wallets);\n\n /// Sign an EIP-7702 authorization and designate the next call as an EIP-7702 transaction\n function signAndAttachDelegation(address implementation, uint256 privateKey)\n external\n returns (SignedDelegation memory signedDelegation);\n\n /// Sign an EIP-7702 authorization for delegation\n function signDelegation(address implementation, uint256 privateKey)\n external\n returns (SignedDelegation memory signedDelegation);\n\n /// Has all subsequent calls (at this call depth only) create transactions that can later be signed and sent onchain.\n /// Broadcasting address is determined by checking the following in order:\n /// 1. If `--sender` argument was provided, that address is used.\n /// 2. If exactly one signer (e.g. private key, hw wallet, keystore) is set when `forge broadcast` is invoked, that signer is used.\n /// 3. Otherwise, default foundry sender (1804c8AB1F12E6bbf3894d4083f33e07309d1f38) is used.\n function startBroadcast() external;\n\n /// Has all subsequent calls (at this call depth only) create transactions with the address\n /// provided that can later be signed and sent onchain.\n function startBroadcast(address signer) external;\n\n /// Has all subsequent calls (at this call depth only) create transactions with the private key\n /// provided that can later be signed and sent onchain.\n function startBroadcast(uint256 privateKey) external;\n\n /// Stops collecting onchain transactions.\n function stopBroadcast() external;\n\n // ======== String ========\n\n /// Returns true if `search` is found in `subject`, false otherwise.\n function contains(string calldata subject, string calldata search) external returns (bool result);\n\n /// Returns the index of the first occurrence of a `key` in an `input` string.\n /// Returns `NOT_FOUND` (i.e. `type(uint256).max`) if the `key` is not found.\n /// Returns 0 in case of an empty `key`.\n function indexOf(string calldata input, string calldata key) external pure returns (uint256);\n\n /// Parses the given `string` into an `address`.\n function parseAddress(string calldata stringifiedValue) external pure returns (address parsedValue);\n\n /// Parses the given `string` into a `bool`.\n function parseBool(string calldata stringifiedValue) external pure returns (bool parsedValue);\n\n /// Parses the given `string` into `bytes`.\n function parseBytes(string calldata stringifiedValue) external pure returns (bytes memory parsedValue);\n\n /// Parses the given `string` into a `bytes32`.\n function parseBytes32(string calldata stringifiedValue) external pure returns (bytes32 parsedValue);\n\n /// Parses the given `string` into a `int256`.\n function parseInt(string calldata stringifiedValue) external pure returns (int256 parsedValue);\n\n /// Parses the given `string` into a `uint256`.\n function parseUint(string calldata stringifiedValue) external pure returns (uint256 parsedValue);\n\n /// Replaces occurrences of `from` in the given `string` with `to`.\n function replace(string calldata input, string calldata from, string calldata to)\n external\n pure\n returns (string memory output);\n\n /// Splits the given `string` into an array of strings divided by the `delimiter`.\n function split(string calldata input, string calldata delimiter) external pure returns (string[] memory outputs);\n\n /// Converts the given `string` value to Lowercase.\n function toLowercase(string calldata input) external pure returns (string memory output);\n\n /// Converts the given value to a `string`.\n function toString(address value) external pure returns (string memory stringifiedValue);\n\n /// Converts the given value to a `string`.\n function toString(bytes calldata value) external pure returns (string memory stringifiedValue);\n\n /// Converts the given value to a `string`.\n function toString(bytes32 value) external pure returns (string memory stringifiedValue);\n\n /// Converts the given value to a `string`.\n function toString(bool value) external pure returns (string memory stringifiedValue);\n\n /// Converts the given value to a `string`.\n function toString(uint256 value) external pure returns (string memory stringifiedValue);\n\n /// Converts the given value to a `string`.\n function toString(int256 value) external pure returns (string memory stringifiedValue);\n\n /// Converts the given `string` value to Uppercase.\n function toUppercase(string calldata input) external pure returns (string memory output);\n\n /// Trims leading and trailing whitespace from the given `string` value.\n function trim(string calldata input) external pure returns (string memory output);\n\n // ======== Testing ========\n\n /// Compares two `uint256` values. Expects difference to be less than or equal to `maxDelta`.\n /// Formats values with decimals in failure message.\n function assertApproxEqAbsDecimal(uint256 left, uint256 right, uint256 maxDelta, uint256 decimals) external pure;\n\n /// Compares two `uint256` values. Expects difference to be less than or equal to `maxDelta`.\n /// Formats values with decimals in failure message. Includes error message into revert string on failure.\n function assertApproxEqAbsDecimal(\n uint256 left,\n uint256 right,\n uint256 maxDelta,\n uint256 decimals,\n string calldata error\n ) external pure;\n\n /// Compares two `int256` values. Expects difference to be less than or equal to `maxDelta`.\n /// Formats values with decimals in failure message.\n function assertApproxEqAbsDecimal(int256 left, int256 right, uint256 maxDelta, uint256 decimals) external pure;\n\n /// Compares two `int256` values. Expects difference to be less than or equal to `maxDelta`.\n /// Formats values with decimals in failure message. Includes error message into revert string on failure.\n function assertApproxEqAbsDecimal(\n int256 left,\n int256 right,\n uint256 maxDelta,\n uint256 decimals,\n string calldata error\n ) external pure;\n\n /// Compares two `uint256` values. Expects difference to be less than or equal to `maxDelta`.\n function assertApproxEqAbs(uint256 left, uint256 right, uint256 maxDelta) external pure;\n\n /// Compares two `uint256` values. Expects difference to be less than or equal to `maxDelta`.\n /// Includes error message into revert string on failure.\n function assertApproxEqAbs(uint256 left, uint256 right, uint256 maxDelta, string calldata error) external pure;\n\n /// Compares two `int256` values. Expects difference to be less than or equal to `maxDelta`.\n function assertApproxEqAbs(int256 left, int256 right, uint256 maxDelta) external pure;\n\n /// Compares two `int256` values. Expects difference to be less than or equal to `maxDelta`.\n /// Includes error message into revert string on failure.\n function assertApproxEqAbs(int256 left, int256 right, uint256 maxDelta, string calldata error) external pure;\n\n /// Compares two `uint256` values. Expects relative difference in percents to be less than or equal to `maxPercentDelta`.\n /// `maxPercentDelta` is an 18 decimal fixed point number, where 1e18 == 100%\n /// Formats values with decimals in failure message.\n function assertApproxEqRelDecimal(uint256 left, uint256 right, uint256 maxPercentDelta, uint256 decimals)\n external\n pure;\n\n /// Compares two `uint256` values. Expects relative difference in percents to be less than or equal to `maxPercentDelta`.\n /// `maxPercentDelta` is an 18 decimal fixed point number, where 1e18 == 100%\n /// Formats values with decimals in failure message. Includes error message into revert string on failure.\n function assertApproxEqRelDecimal(\n uint256 left,\n uint256 right,\n uint256 maxPercentDelta,\n uint256 decimals,\n string calldata error\n ) external pure;\n\n /// Compares two `int256` values. Expects relative difference in percents to be less than or equal to `maxPercentDelta`.\n /// `maxPercentDelta` is an 18 decimal fixed point number, where 1e18 == 100%\n /// Formats values with decimals in failure message.\n function assertApproxEqRelDecimal(int256 left, int256 right, uint256 maxPercentDelta, uint256 decimals)\n external\n pure;\n\n /// Compares two `int256` values. Expects relative difference in percents to be less than or equal to `maxPercentDelta`.\n /// `maxPercentDelta` is an 18 decimal fixed point number, where 1e18 == 100%\n /// Formats values with decimals in failure message. Includes error message into revert string on failure.\n function assertApproxEqRelDecimal(\n int256 left,\n int256 right,\n uint256 maxPercentDelta,\n uint256 decimals,\n string calldata error\n ) external pure;\n\n /// Compares two `uint256` values. Expects relative difference in percents to be less than or equal to `maxPercentDelta`.\n /// `maxPercentDelta` is an 18 decimal fixed point number, where 1e18 == 100%\n function assertApproxEqRel(uint256 left, uint256 right, uint256 maxPercentDelta) external pure;\n\n /// Compares two `uint256` values. Expects relative difference in percents to be less than or equal to `maxPercentDelta`.\n /// `maxPercentDelta` is an 18 decimal fixed point number, where 1e18 == 100%\n /// Includes error message into revert string on failure.\n function assertApproxEqRel(uint256 left, uint256 right, uint256 maxPercentDelta, string calldata error)\n external\n pure;\n\n /// Compares two `int256` values. Expects relative difference in percents to be less than or equal to `maxPercentDelta`.\n /// `maxPercentDelta` is an 18 decimal fixed point number, where 1e18 == 100%\n function assertApproxEqRel(int256 left, int256 right, uint256 maxPercentDelta) external pure;\n\n /// Compares two `int256` values. Expects relative difference in percents to be less than or equal to `maxPercentDelta`.\n /// `maxPercentDelta` is an 18 decimal fixed point number, where 1e18 == 100%\n /// Includes error message into revert string on failure.\n function assertApproxEqRel(int256 left, int256 right, uint256 maxPercentDelta, string calldata error)\n external\n pure;\n\n /// Asserts that two `uint256` values are equal, formatting them with decimals in failure message.\n function assertEqDecimal(uint256 left, uint256 right, uint256 decimals) external pure;\n\n /// Asserts that two `uint256` values are equal, formatting them with decimals in failure message.\n /// Includes error message into revert string on failure.\n function assertEqDecimal(uint256 left, uint256 right, uint256 decimals, string calldata error) external pure;\n\n /// Asserts that two `int256` values are equal, formatting them with decimals in failure message.\n function assertEqDecimal(int256 left, int256 right, uint256 decimals) external pure;\n\n /// Asserts that two `int256` values are equal, formatting them with decimals in failure message.\n /// Includes error message into revert string on failure.\n function assertEqDecimal(int256 left, int256 right, uint256 decimals, string calldata error) external pure;\n\n /// Asserts that two `bool` values are equal.\n function assertEq(bool left, bool right) external pure;\n\n /// Asserts that two `bool` values are equal and includes error message into revert string on failure.\n function assertEq(bool left, bool right, string calldata error) external pure;\n\n /// Asserts that two `string` values are equal.\n function assertEq(string calldata left, string calldata right) external pure;\n\n /// Asserts that two `string` values are equal and includes error message into revert string on failure.\n function assertEq(string calldata left, string calldata right, string calldata error) external pure;\n\n /// Asserts that two `bytes` values are equal.\n function assertEq(bytes calldata left, bytes calldata right) external pure;\n\n /// Asserts that two `bytes` values are equal and includes error message into revert string on failure.\n function assertEq(bytes calldata left, bytes calldata right, string calldata error) external pure;\n\n /// Asserts that two arrays of `bool` values are equal.\n function assertEq(bool[] calldata left, bool[] calldata right) external pure;\n\n /// Asserts that two arrays of `bool` values are equal and includes error message into revert string on failure.\n function assertEq(bool[] calldata left, bool[] calldata right, string calldata error) external pure;\n\n /// Asserts that two arrays of `uint256 values are equal.\n function assertEq(uint256[] calldata left, uint256[] calldata right) external pure;\n\n /// Asserts that two arrays of `uint256` values are equal and includes error message into revert string on failure.\n function assertEq(uint256[] calldata left, uint256[] calldata right, string calldata error) external pure;\n\n /// Asserts that two arrays of `int256` values are equal.\n function assertEq(int256[] calldata left, int256[] calldata right) external pure;\n\n /// Asserts that two arrays of `int256` values are equal and includes error message into revert string on failure.\n function assertEq(int256[] calldata left, int256[] calldata right, string calldata error) external pure;\n\n /// Asserts that two `uint256` values are equal.\n function assertEq(uint256 left, uint256 right) external pure;\n\n /// Asserts that two arrays of `address` values are equal.\n function assertEq(address[] calldata left, address[] calldata right) external pure;\n\n /// Asserts that two arrays of `address` values are equal and includes error message into revert string on failure.\n function assertEq(address[] calldata left, address[] calldata right, string calldata error) external pure;\n\n /// Asserts that two arrays of `bytes32` values are equal.\n function assertEq(bytes32[] calldata left, bytes32[] calldata right) external pure;\n\n /// Asserts that two arrays of `bytes32` values are equal and includes error message into revert string on failure.\n function assertEq(bytes32[] calldata left, bytes32[] calldata right, string calldata error) external pure;\n\n /// Asserts that two arrays of `string` values are equal.\n function assertEq(string[] calldata left, string[] calldata right) external pure;\n\n /// Asserts that two arrays of `string` values are equal and includes error message into revert string on failure.\n function assertEq(string[] calldata left, string[] calldata right, string calldata error) external pure;\n\n /// Asserts that two arrays of `bytes` values are equal.\n function assertEq(bytes[] calldata left, bytes[] calldata right) external pure;\n\n /// Asserts that two arrays of `bytes` values are equal and includes error message into revert string on failure.\n function assertEq(bytes[] calldata left, bytes[] calldata right, string calldata error) external pure;\n\n /// Asserts that two `uint256` values are equal and includes error message into revert string on failure.\n function assertEq(uint256 left, uint256 right, string calldata error) external pure;\n\n /// Asserts that two `int256` values are equal.\n function assertEq(int256 left, int256 right) external pure;\n\n /// Asserts that two `int256` values are equal and includes error message into revert string on failure.\n function assertEq(int256 left, int256 right, string calldata error) external pure;\n\n /// Asserts that two `address` values are equal.\n function assertEq(address left, address right) external pure;\n\n /// Asserts that two `address` values are equal and includes error message into revert string on failure.\n function assertEq(address left, address right, string calldata error) external pure;\n\n /// Asserts that two `bytes32` values are equal.\n function assertEq(bytes32 left, bytes32 right) external pure;\n\n /// Asserts that two `bytes32` values are equal and includes error message into revert string on failure.\n function assertEq(bytes32 left, bytes32 right, string calldata error) external pure;\n\n /// Asserts that the given condition is false.\n function assertFalse(bool condition) external pure;\n\n /// Asserts that the given condition is false and includes error message into revert string on failure.\n function assertFalse(bool condition, string calldata error) external pure;\n\n /// Compares two `uint256` values. Expects first value to be greater than or equal to second.\n /// Formats values with decimals in failure message.\n function assertGeDecimal(uint256 left, uint256 right, uint256 decimals) external pure;\n\n /// Compares two `uint256` values. Expects first value to be greater than or equal to second.\n /// Formats values with decimals in failure message. Includes error message into revert string on failure.\n function assertGeDecimal(uint256 left, uint256 right, uint256 decimals, string calldata error) external pure;\n\n /// Compares two `int256` values. Expects first value to be greater than or equal to second.\n /// Formats values with decimals in failure message.\n function assertGeDecimal(int256 left, int256 right, uint256 decimals) external pure;\n\n /// Compares two `int256` values. Expects first value to be greater than or equal to second.\n /// Formats values with decimals in failure message. Includes error message into revert string on failure.\n function assertGeDecimal(int256 left, int256 right, uint256 decimals, string calldata error) external pure;\n\n /// Compares two `uint256` values. Expects first value to be greater than or equal to second.\n function assertGe(uint256 left, uint256 right) external pure;\n\n /// Compares two `uint256` values. Expects first value to be greater than or equal to second.\n /// Includes error message into revert string on failure.\n function assertGe(uint256 left, uint256 right, string calldata error) external pure;\n\n /// Compares two `int256` values. Expects first value to be greater than or equal to second.\n function assertGe(int256 left, int256 right) external pure;\n\n /// Compares two `int256` values. Expects first value to be greater than or equal to second.\n /// Includes error message into revert string on failure.\n function assertGe(int256 left, int256 right, string calldata error) external pure;\n\n /// Compares two `uint256` values. Expects first value to be greater than second.\n /// Formats values with decimals in failure message.\n function assertGtDecimal(uint256 left, uint256 right, uint256 decimals) external pure;\n\n /// Compares two `uint256` values. Expects first value to be greater than second.\n /// Formats values with decimals in failure message. Includes error message into revert string on failure.\n function assertGtDecimal(uint256 left, uint256 right, uint256 decimals, string calldata error) external pure;\n\n /// Compares two `int256` values. Expects first value to be greater than second.\n /// Formats values with decimals in failure message.\n function assertGtDecimal(int256 left, int256 right, uint256 decimals) external pure;\n\n /// Compares two `int256` values. Expects first value to be greater than second.\n /// Formats values with decimals in failure message. Includes error message into revert string on failure.\n function assertGtDecimal(int256 left, int256 right, uint256 decimals, string calldata error) external pure;\n\n /// Compares two `uint256` values. Expects first value to be greater than second.\n function assertGt(uint256 left, uint256 right) external pure;\n\n /// Compares two `uint256` values. Expects first value to be greater than second.\n /// Includes error message into revert string on failure.\n function assertGt(uint256 left, uint256 right, string calldata error) external pure;\n\n /// Compares two `int256` values. Expects first value to be greater than second.\n function assertGt(int256 left, int256 right) external pure;\n\n /// Compares two `int256` values. Expects first value to be greater than second.\n /// Includes error message into revert string on failure.\n function assertGt(int256 left, int256 right, string calldata error) external pure;\n\n /// Compares two `uint256` values. Expects first value to be less than or equal to second.\n /// Formats values with decimals in failure message.\n function assertLeDecimal(uint256 left, uint256 right, uint256 decimals) external pure;\n\n /// Compares two `uint256` values. Expects first value to be less than or equal to second.\n /// Formats values with decimals in failure message. Includes error message into revert string on failure.\n function assertLeDecimal(uint256 left, uint256 right, uint256 decimals, string calldata error) external pure;\n\n /// Compares two `int256` values. Expects first value to be less than or equal to second.\n /// Formats values with decimals in failure message.\n function assertLeDecimal(int256 left, int256 right, uint256 decimals) external pure;\n\n /// Compares two `int256` values. Expects first value to be less than or equal to second.\n /// Formats values with decimals in failure message. Includes error message into revert string on failure.\n function assertLeDecimal(int256 left, int256 right, uint256 decimals, string calldata error) external pure;\n\n /// Compares two `uint256` values. Expects first value to be less than or equal to second.\n function assertLe(uint256 left, uint256 right) external pure;\n\n /// Compares two `uint256` values. Expects first value to be less than or equal to second.\n /// Includes error message into revert string on failure.\n function assertLe(uint256 left, uint256 right, string calldata error) external pure;\n\n /// Compares two `int256` values. Expects first value to be less than or equal to second.\n function assertLe(int256 left, int256 right) external pure;\n\n /// Compares two `int256` values. Expects first value to be less than or equal to second.\n /// Includes error message into revert string on failure.\n function assertLe(int256 left, int256 right, string calldata error) external pure;\n\n /// Compares two `uint256` values. Expects first value to be less than second.\n /// Formats values with decimals in failure message.\n function assertLtDecimal(uint256 left, uint256 right, uint256 decimals) external pure;\n\n /// Compares two `uint256` values. Expects first value to be less than second.\n /// Formats values with decimals in failure message. Includes error message into revert string on failure.\n function assertLtDecimal(uint256 left, uint256 right, uint256 decimals, string calldata error) external pure;\n\n /// Compares two `int256` values. Expects first value to be less than second.\n /// Formats values with decimals in failure message.\n function assertLtDecimal(int256 left, int256 right, uint256 decimals) external pure;\n\n /// Compares two `int256` values. Expects first value to be less than second.\n /// Formats values with decimals in failure message. Includes error message into revert string on failure.\n function assertLtDecimal(int256 left, int256 right, uint256 decimals, string calldata error) external pure;\n\n /// Compares two `uint256` values. Expects first value to be less than second.\n function assertLt(uint256 left, uint256 right) external pure;\n\n /// Compares two `uint256` values. Expects first value to be less than second.\n /// Includes error message into revert string on failure.\n function assertLt(uint256 left, uint256 right, string calldata error) external pure;\n\n /// Compares two `int256` values. Expects first value to be less than second.\n function assertLt(int256 left, int256 right) external pure;\n\n /// Compares two `int256` values. Expects first value to be less than second.\n /// Includes error message into revert string on failure.\n function assertLt(int256 left, int256 right, string calldata error) external pure;\n\n /// Asserts that two `uint256` values are not equal, formatting them with decimals in failure message.\n function assertNotEqDecimal(uint256 left, uint256 right, uint256 decimals) external pure;\n\n /// Asserts that two `uint256` values are not equal, formatting them with decimals in failure message.\n /// Includes error message into revert string on failure.\n function assertNotEqDecimal(uint256 left, uint256 right, uint256 decimals, string calldata error) external pure;\n\n /// Asserts that two `int256` values are not equal, formatting them with decimals in failure message.\n function assertNotEqDecimal(int256 left, int256 right, uint256 decimals) external pure;\n\n /// Asserts that two `int256` values are not equal, formatting them with decimals in failure message.\n /// Includes error message into revert string on failure.\n function assertNotEqDecimal(int256 left, int256 right, uint256 decimals, string calldata error) external pure;\n\n /// Asserts that two `bool` values are not equal.\n function assertNotEq(bool left, bool right) external pure;\n\n /// Asserts that two `bool` values are not equal and includes error message into revert string on failure.\n function assertNotEq(bool left, bool right, string calldata error) external pure;\n\n /// Asserts that two `string` values are not equal.\n function assertNotEq(string calldata left, string calldata right) external pure;\n\n /// Asserts that two `string` values are not equal and includes error message into revert string on failure.\n function assertNotEq(string calldata left, string calldata right, string calldata error) external pure;\n\n /// Asserts that two `bytes` values are not equal.\n function assertNotEq(bytes calldata left, bytes calldata right) external pure;\n\n /// Asserts that two `bytes` values are not equal and includes error message into revert string on failure.\n function assertNotEq(bytes calldata left, bytes calldata right, string calldata error) external pure;\n\n /// Asserts that two arrays of `bool` values are not equal.\n function assertNotEq(bool[] calldata left, bool[] calldata right) external pure;\n\n /// Asserts that two arrays of `bool` values are not equal and includes error message into revert string on failure.\n function assertNotEq(bool[] calldata left, bool[] calldata right, string calldata error) external pure;\n\n /// Asserts that two arrays of `uint256` values are not equal.\n function assertNotEq(uint256[] calldata left, uint256[] calldata right) external pure;\n\n /// Asserts that two arrays of `uint256` values are not equal and includes error message into revert string on failure.\n function assertNotEq(uint256[] calldata left, uint256[] calldata right, string calldata error) external pure;\n\n /// Asserts that two arrays of `int256` values are not equal.\n function assertNotEq(int256[] calldata left, int256[] calldata right) external pure;\n\n /// Asserts that two arrays of `int256` values are not equal and includes error message into revert string on failure.\n function assertNotEq(int256[] calldata left, int256[] calldata right, string calldata error) external pure;\n\n /// Asserts that two `uint256` values are not equal.\n function assertNotEq(uint256 left, uint256 right) external pure;\n\n /// Asserts that two arrays of `address` values are not equal.\n function assertNotEq(address[] calldata left, address[] calldata right) external pure;\n\n /// Asserts that two arrays of `address` values are not equal and includes error message into revert string on failure.\n function assertNotEq(address[] calldata left, address[] calldata right, string calldata error) external pure;\n\n /// Asserts that two arrays of `bytes32` values are not equal.\n function assertNotEq(bytes32[] calldata left, bytes32[] calldata right) external pure;\n\n /// Asserts that two arrays of `bytes32` values are not equal and includes error message into revert string on failure.\n function assertNotEq(bytes32[] calldata left, bytes32[] calldata right, string calldata error) external pure;\n\n /// Asserts that two arrays of `string` values are not equal.\n function assertNotEq(string[] calldata left, string[] calldata right) external pure;\n\n /// Asserts that two arrays of `string` values are not equal and includes error message into revert string on failure.\n function assertNotEq(string[] calldata left, string[] calldata right, string calldata error) external pure;\n\n /// Asserts that two arrays of `bytes` values are not equal.\n function assertNotEq(bytes[] calldata left, bytes[] calldata right) external pure;\n\n /// Asserts that two arrays of `bytes` values are not equal and includes error message into revert string on failure.\n function assertNotEq(bytes[] calldata left, bytes[] calldata right, string calldata error) external pure;\n\n /// Asserts that two `uint256` values are not equal and includes error message into revert string on failure.\n function assertNotEq(uint256 left, uint256 right, string calldata error) external pure;\n\n /// Asserts that two `int256` values are not equal.\n function assertNotEq(int256 left, int256 right) external pure;\n\n /// Asserts that two `int256` values are not equal and includes error message into revert string on failure.\n function assertNotEq(int256 left, int256 right, string calldata error) external pure;\n\n /// Asserts that two `address` values are not equal.\n function assertNotEq(address left, address right) external pure;\n\n /// Asserts that two `address` values are not equal and includes error message into revert string on failure.\n function assertNotEq(address left, address right, string calldata error) external pure;\n\n /// Asserts that two `bytes32` values are not equal.\n function assertNotEq(bytes32 left, bytes32 right) external pure;\n\n /// Asserts that two `bytes32` values are not equal and includes error message into revert string on failure.\n function assertNotEq(bytes32 left, bytes32 right, string calldata error) external pure;\n\n /// Asserts that the given condition is true.\n function assertTrue(bool condition) external pure;\n\n /// Asserts that the given condition is true and includes error message into revert string on failure.\n function assertTrue(bool condition, string calldata error) external pure;\n\n /// If the condition is false, discard this run's fuzz inputs and generate new ones.\n function assume(bool condition) external pure;\n\n /// Discard this run's fuzz inputs and generate new ones if next call reverted.\n function assumeNoRevert() external pure;\n\n /// Discard this run's fuzz inputs and generate new ones if next call reverts with the potential revert parameters.\n function assumeNoRevert(PotentialRevert calldata potentialRevert) external pure;\n\n /// Discard this run's fuzz inputs and generate new ones if next call reverts with the any of the potential revert parameters.\n function assumeNoRevert(PotentialRevert[] calldata potentialReverts) external pure;\n\n /// Writes a breakpoint to jump to in the debugger.\n function breakpoint(string calldata char) external pure;\n\n /// Writes a conditional breakpoint to jump to in the debugger.\n function breakpoint(string calldata char, bool value) external pure;\n\n /// Returns true if the current Foundry version is greater than or equal to the given version.\n /// The given version string must be in the format `major.minor.patch`.\n /// This is equivalent to `foundryVersionCmp(version) >= 0`.\n function foundryVersionAtLeast(string calldata version) external view returns (bool);\n\n /// Compares the current Foundry version with the given version string.\n /// The given version string must be in the format `major.minor.patch`.\n /// Returns:\n /// -1 if current Foundry version is less than the given version\n /// 0 if current Foundry version equals the given version\n /// 1 if current Foundry version is greater than the given version\n /// This result can then be used with a comparison operator against `0`.\n /// For example, to check if the current Foundry version is greater than or equal to `1.0.0`:\n /// `if (foundryVersionCmp(\"1.0.0\") >= 0) { ... }`\n function foundryVersionCmp(string calldata version) external view returns (int256);\n\n /// Returns the Foundry version.\n /// Format: -+..\n /// Sample output: 0.3.0-nightly+3cb96bde9b.1737036656.debug\n /// Note: Build timestamps may vary slightly across platforms due to separate CI jobs.\n /// For reliable version comparisons, use UNIX format (e.g., >= 1700000000)\n /// to compare timestamps while ignoring minor time differences.\n function getFoundryVersion() external view returns (string memory version);\n\n /// Returns the RPC url for the given alias.\n function rpcUrl(string calldata rpcAlias) external view returns (string memory json);\n\n /// Returns all rpc urls and their aliases as structs.\n function rpcUrlStructs() external view returns (Rpc[] memory urls);\n\n /// Returns all rpc urls and their aliases `[alias, url][]`.\n function rpcUrls() external view returns (string[2][] memory urls);\n\n /// Suspends execution of the main thread for `duration` milliseconds.\n function sleep(uint256 duration) external;\n\n // ======== Toml ========\n\n /// Checks if `key` exists in a TOML table.\n function keyExistsToml(string calldata toml, string calldata key) external view returns (bool);\n\n /// Parses a string of TOML data at `key` and coerces it to `address`.\n function parseTomlAddress(string calldata toml, string calldata key) external pure returns (address);\n\n /// Parses a string of TOML data at `key` and coerces it to `address[]`.\n function parseTomlAddressArray(string calldata toml, string calldata key)\n external\n pure\n returns (address[] memory);\n\n /// Parses a string of TOML data at `key` and coerces it to `bool`.\n function parseTomlBool(string calldata toml, string calldata key) external pure returns (bool);\n\n /// Parses a string of TOML data at `key` and coerces it to `bool[]`.\n function parseTomlBoolArray(string calldata toml, string calldata key) external pure returns (bool[] memory);\n\n /// Parses a string of TOML data at `key` and coerces it to `bytes`.\n function parseTomlBytes(string calldata toml, string calldata key) external pure returns (bytes memory);\n\n /// Parses a string of TOML data at `key` and coerces it to `bytes32`.\n function parseTomlBytes32(string calldata toml, string calldata key) external pure returns (bytes32);\n\n /// Parses a string of TOML data at `key` and coerces it to `bytes32[]`.\n function parseTomlBytes32Array(string calldata toml, string calldata key)\n external\n pure\n returns (bytes32[] memory);\n\n /// Parses a string of TOML data at `key` and coerces it to `bytes[]`.\n function parseTomlBytesArray(string calldata toml, string calldata key) external pure returns (bytes[] memory);\n\n /// Parses a string of TOML data at `key` and coerces it to `int256`.\n function parseTomlInt(string calldata toml, string calldata key) external pure returns (int256);\n\n /// Parses a string of TOML data at `key` and coerces it to `int256[]`.\n function parseTomlIntArray(string calldata toml, string calldata key) external pure returns (int256[] memory);\n\n /// Returns an array of all the keys in a TOML table.\n function parseTomlKeys(string calldata toml, string calldata key) external pure returns (string[] memory keys);\n\n /// Parses a string of TOML data at `key` and coerces it to `string`.\n function parseTomlString(string calldata toml, string calldata key) external pure returns (string memory);\n\n /// Parses a string of TOML data at `key` and coerces it to `string[]`.\n function parseTomlStringArray(string calldata toml, string calldata key) external pure returns (string[] memory);\n\n /// Parses a string of TOML data at `key` and coerces it to type array corresponding to `typeDescription`.\n function parseTomlTypeArray(string calldata toml, string calldata key, string calldata typeDescription)\n external\n pure\n returns (bytes memory);\n\n /// Parses a string of TOML data and coerces it to type corresponding to `typeDescription`.\n function parseTomlType(string calldata toml, string calldata typeDescription)\n external\n pure\n returns (bytes memory);\n\n /// Parses a string of TOML data at `key` and coerces it to type corresponding to `typeDescription`.\n function parseTomlType(string calldata toml, string calldata key, string calldata typeDescription)\n external\n pure\n returns (bytes memory);\n\n /// Parses a string of TOML data at `key` and coerces it to `uint256`.\n function parseTomlUint(string calldata toml, string calldata key) external pure returns (uint256);\n\n /// Parses a string of TOML data at `key` and coerces it to `uint256[]`.\n function parseTomlUintArray(string calldata toml, string calldata key) external pure returns (uint256[] memory);\n\n /// ABI-encodes a TOML table.\n function parseToml(string calldata toml) external pure returns (bytes memory abiEncodedData);\n\n /// ABI-encodes a TOML table at `key`.\n function parseToml(string calldata toml, string calldata key) external pure returns (bytes memory abiEncodedData);\n\n /// Takes serialized JSON, converts to TOML and write a serialized TOML to a file.\n function writeToml(string calldata json, string calldata path) external;\n\n /// Takes serialized JSON, converts to TOML and write a serialized TOML table to an **existing** TOML file, replacing a value with key = \n /// This is useful to replace a specific value of a TOML file, without having to parse the entire thing.\n function writeToml(string calldata json, string calldata path, string calldata valueKey) external;\n\n // ======== Utilities ========\n\n /// Compute the address of a contract created with CREATE2 using the given CREATE2 deployer.\n function computeCreate2Address(bytes32 salt, bytes32 initCodeHash, address deployer)\n external\n pure\n returns (address);\n\n /// Compute the address of a contract created with CREATE2 using the default CREATE2 deployer.\n function computeCreate2Address(bytes32 salt, bytes32 initCodeHash) external pure returns (address);\n\n /// Compute the address a contract will be deployed at for a given deployer address and nonce.\n function computeCreateAddress(address deployer, uint256 nonce) external pure returns (address);\n\n /// Utility cheatcode to copy storage of `from` contract to another `to` contract.\n function copyStorage(address from, address to) external;\n\n /// Returns ENS namehash for provided string.\n function ensNamehash(string calldata name) external pure returns (bytes32);\n\n /// Gets the label for the specified address.\n function getLabel(address account) external view returns (string memory currentLabel);\n\n /// Labels an address in call traces.\n function label(address account, string calldata newLabel) external;\n\n /// Pauses collection of call traces. Useful in cases when you want to skip tracing of\n /// complex calls which are not useful for debugging.\n function pauseTracing() external view;\n\n /// Returns a random `address`.\n function randomAddress() external returns (address);\n\n /// Returns a random `bool`.\n function randomBool() external view returns (bool);\n\n /// Returns a random byte array value of the given length.\n function randomBytes(uint256 len) external view returns (bytes memory);\n\n /// Returns a random fixed-size byte array of length 4.\n function randomBytes4() external view returns (bytes4);\n\n /// Returns a random fixed-size byte array of length 8.\n function randomBytes8() external view returns (bytes8);\n\n /// Returns a random `int256` value.\n function randomInt() external view returns (int256);\n\n /// Returns a random `int256` value of given bits.\n function randomInt(uint256 bits) external view returns (int256);\n\n /// Returns a random uint256 value.\n function randomUint() external returns (uint256);\n\n /// Returns random uint256 value between the provided range (=min..=max).\n function randomUint(uint256 min, uint256 max) external returns (uint256);\n\n /// Returns a random `uint256` value of given bits.\n function randomUint(uint256 bits) external view returns (uint256);\n\n /// Unpauses collection of call traces.\n function resumeTracing() external view;\n\n /// Utility cheatcode to set arbitrary storage for given target address.\n function setArbitraryStorage(address target) external;\n\n /// Encodes a `bytes` value to a base64url string.\n function toBase64URL(bytes calldata data) external pure returns (string memory);\n\n /// Encodes a `string` value to a base64url string.\n function toBase64URL(string calldata data) external pure returns (string memory);\n\n /// Encodes a `bytes` value to a base64 string.\n function toBase64(bytes calldata data) external pure returns (string memory);\n\n /// Encodes a `string` value to a base64 string.\n function toBase64(string calldata data) external pure returns (string memory);\n}\n\n/// The `Vm` interface does allow manipulation of the EVM state. These are all intended to be used\n/// in tests, but it is not recommended to use these cheats in scripts.\ninterface Vm is VmSafe {\n // ======== EVM ========\n\n /// Utility cheatcode to set an EIP-2930 access list for all subsequent transactions.\n function accessList(AccessListItem[] calldata access) external;\n\n /// Returns the identifier of the currently active fork. Reverts if no fork is currently active.\n function activeFork() external view returns (uint256 forkId);\n\n /// In forking mode, explicitly grant the given address cheatcode access.\n function allowCheatcodes(address account) external;\n\n /// Sets `block.blobbasefee`\n function blobBaseFee(uint256 newBlobBaseFee) external;\n\n /// Sets the blobhashes in the transaction.\n /// Not available on EVM versions before Cancun.\n /// If used on unsupported EVM versions it will revert.\n function blobhashes(bytes32[] calldata hashes) external;\n\n /// Sets `block.chainid`.\n function chainId(uint256 newChainId) external;\n\n /// Clears all mocked calls.\n function clearMockedCalls() external;\n\n /// Clones a source account code, state, balance and nonce to a target account and updates in-memory EVM state.\n function cloneAccount(address source, address target) external;\n\n /// Sets `block.coinbase`.\n function coinbase(address newCoinbase) external;\n\n /// Marks the slots of an account and the account address as cold.\n function cool(address target) external;\n\n /// Utility cheatcode to mark specific storage slot as cold, simulating no prior read.\n function coolSlot(address target, bytes32 slot) external;\n\n /// Creates a new fork with the given endpoint and the _latest_ block and returns the identifier of the fork.\n function createFork(string calldata urlOrAlias) external returns (uint256 forkId);\n\n /// Creates a new fork with the given endpoint and block and returns the identifier of the fork.\n function createFork(string calldata urlOrAlias, uint256 blockNumber) external returns (uint256 forkId);\n\n /// Creates a new fork with the given endpoint and at the block the given transaction was mined in,\n /// replays all transaction mined in the block before the transaction, and returns the identifier of the fork.\n function createFork(string calldata urlOrAlias, bytes32 txHash) external returns (uint256 forkId);\n\n /// Creates and also selects a new fork with the given endpoint and the latest block and returns the identifier of the fork.\n function createSelectFork(string calldata urlOrAlias) external returns (uint256 forkId);\n\n /// Creates and also selects a new fork with the given endpoint and block and returns the identifier of the fork.\n function createSelectFork(string calldata urlOrAlias, uint256 blockNumber) external returns (uint256 forkId);\n\n /// Creates and also selects new fork with the given endpoint and at the block the given transaction was mined in,\n /// replays all transaction mined in the block before the transaction, returns the identifier of the fork.\n function createSelectFork(string calldata urlOrAlias, bytes32 txHash) external returns (uint256 forkId);\n\n /// Sets an address' balance.\n function deal(address account, uint256 newBalance) external;\n\n /// Removes the snapshot with the given ID created by `snapshot`.\n /// Takes the snapshot ID to delete.\n /// Returns `true` if the snapshot was successfully deleted.\n /// Returns `false` if the snapshot does not exist.\n function deleteStateSnapshot(uint256 snapshotId) external returns (bool success);\n\n /// Removes _all_ snapshots previously created by `snapshot`.\n function deleteStateSnapshots() external;\n\n /// Sets `block.difficulty`.\n /// Not available on EVM versions from Paris onwards. Use `prevrandao` instead.\n /// Reverts if used on unsupported EVM versions.\n function difficulty(uint256 newDifficulty) external;\n\n /// Dump a genesis JSON file's `allocs` to disk.\n function dumpState(string calldata pathToStateJson) external;\n\n /// Sets an address' code.\n function etch(address target, bytes calldata newRuntimeBytecode) external;\n\n /// Sets `block.basefee`.\n function fee(uint256 newBasefee) external;\n\n /// Gets the blockhashes from the current transaction.\n /// Not available on EVM versions before Cancun.\n /// If used on unsupported EVM versions it will revert.\n function getBlobhashes() external view returns (bytes32[] memory hashes);\n\n /// Returns true if the account is marked as persistent.\n function isPersistent(address account) external view returns (bool persistent);\n\n /// Load a genesis JSON file's `allocs` into the in-memory EVM state.\n function loadAllocs(string calldata pathToAllocsJson) external;\n\n /// Marks that the account(s) should use persistent storage across fork swaps in a multifork setup\n /// Meaning, changes made to the state of this account will be kept when switching forks.\n function makePersistent(address account) external;\n\n /// See `makePersistent(address)`.\n function makePersistent(address account0, address account1) external;\n\n /// See `makePersistent(address)`.\n function makePersistent(address account0, address account1, address account2) external;\n\n /// See `makePersistent(address)`.\n function makePersistent(address[] calldata accounts) external;\n\n /// Reverts a call to an address with specified revert data.\n function mockCallRevert(address callee, bytes calldata data, bytes calldata revertData) external;\n\n /// Reverts a call to an address with a specific `msg.value`, with specified revert data.\n function mockCallRevert(address callee, uint256 msgValue, bytes calldata data, bytes calldata revertData)\n external;\n\n /// Reverts a call to an address with specified revert data.\n /// Overload to pass the function selector directly `token.approve.selector` instead of `abi.encodeWithSelector(token.approve.selector)`.\n function mockCallRevert(address callee, bytes4 data, bytes calldata revertData) external;\n\n /// Reverts a call to an address with a specific `msg.value`, with specified revert data.\n /// Overload to pass the function selector directly `token.approve.selector` instead of `abi.encodeWithSelector(token.approve.selector)`.\n function mockCallRevert(address callee, uint256 msgValue, bytes4 data, bytes calldata revertData) external;\n\n /// Mocks a call to an address, returning specified data.\n /// Calldata can either be strict or a partial match, e.g. if you only\n /// pass a Solidity selector to the expected calldata, then the entire Solidity\n /// function will be mocked.\n function mockCall(address callee, bytes calldata data, bytes calldata returnData) external;\n\n /// Mocks a call to an address with a specific `msg.value`, returning specified data.\n /// Calldata match takes precedence over `msg.value` in case of ambiguity.\n function mockCall(address callee, uint256 msgValue, bytes calldata data, bytes calldata returnData) external;\n\n /// Mocks a call to an address, returning specified data.\n /// Calldata can either be strict or a partial match, e.g. if you only\n /// pass a Solidity selector to the expected calldata, then the entire Solidity\n /// function will be mocked.\n /// Overload to pass the function selector directly `token.approve.selector` instead of `abi.encodeWithSelector(token.approve.selector)`.\n function mockCall(address callee, bytes4 data, bytes calldata returnData) external;\n\n /// Mocks a call to an address with a specific `msg.value`, returning specified data.\n /// Calldata match takes precedence over `msg.value` in case of ambiguity.\n /// Overload to pass the function selector directly `token.approve.selector` instead of `abi.encodeWithSelector(token.approve.selector)`.\n function mockCall(address callee, uint256 msgValue, bytes4 data, bytes calldata returnData) external;\n\n /// Mocks multiple calls to an address, returning specified data for each call.\n function mockCalls(address callee, bytes calldata data, bytes[] calldata returnData) external;\n\n /// Mocks multiple calls to an address with a specific `msg.value`, returning specified data for each call.\n function mockCalls(address callee, uint256 msgValue, bytes calldata data, bytes[] calldata returnData) external;\n\n /// Whenever a call is made to `callee` with calldata `data`, this cheatcode instead calls\n /// `target` with the same calldata. This functionality is similar to a delegate call made to\n /// `target` contract from `callee`.\n /// Can be used to substitute a call to a function with another implementation that captures\n /// the primary logic of the original function but is easier to reason about.\n /// If calldata is not a strict match then partial match by selector is attempted.\n function mockFunction(address callee, address target, bytes calldata data) external;\n\n /// Utility cheatcode to remove any EIP-2930 access list set by `accessList` cheatcode.\n function noAccessList() external;\n\n /// Sets the *next* call's `msg.sender` to be the input address.\n function prank(address msgSender) external;\n\n /// Sets the *next* call's `msg.sender` to be the input address, and the `tx.origin` to be the second input.\n function prank(address msgSender, address txOrigin) external;\n\n /// Sets the *next* delegate call's `msg.sender` to be the input address.\n function prank(address msgSender, bool delegateCall) external;\n\n /// Sets the *next* delegate call's `msg.sender` to be the input address, and the `tx.origin` to be the second input.\n function prank(address msgSender, address txOrigin, bool delegateCall) external;\n\n /// Sets `block.prevrandao`.\n /// Not available on EVM versions before Paris. Use `difficulty` instead.\n /// If used on unsupported EVM versions it will revert.\n function prevrandao(bytes32 newPrevrandao) external;\n\n /// Sets `block.prevrandao`.\n /// Not available on EVM versions before Paris. Use `difficulty` instead.\n /// If used on unsupported EVM versions it will revert.\n function prevrandao(uint256 newPrevrandao) external;\n\n /// Reads the current `msg.sender` and `tx.origin` from state and reports if there is any active caller modification.\n function readCallers() external returns (CallerMode callerMode, address msgSender, address txOrigin);\n\n /// Resets the nonce of an account to 0 for EOAs and 1 for contract accounts.\n function resetNonce(address account) external;\n\n /// Revert the state of the EVM to a previous snapshot\n /// Takes the snapshot ID to revert to.\n /// Returns `true` if the snapshot was successfully reverted.\n /// Returns `false` if the snapshot does not exist.\n /// **Note:** This does not automatically delete the snapshot. To delete the snapshot use `deleteStateSnapshot`.\n function revertToState(uint256 snapshotId) external returns (bool success);\n\n /// Revert the state of the EVM to a previous snapshot and automatically deletes the snapshots\n /// Takes the snapshot ID to revert to.\n /// Returns `true` if the snapshot was successfully reverted and deleted.\n /// Returns `false` if the snapshot does not exist.\n function revertToStateAndDelete(uint256 snapshotId) external returns (bool success);\n\n /// Revokes persistent status from the address, previously added via `makePersistent`.\n function revokePersistent(address account) external;\n\n /// See `revokePersistent(address)`.\n function revokePersistent(address[] calldata accounts) external;\n\n /// Sets `block.height`.\n function roll(uint256 newHeight) external;\n\n /// Updates the currently active fork to given block number\n /// This is similar to `roll` but for the currently active fork.\n function rollFork(uint256 blockNumber) external;\n\n /// Updates the currently active fork to given transaction. This will `rollFork` with the number\n /// of the block the transaction was mined in and replays all transaction mined before it in the block.\n function rollFork(bytes32 txHash) external;\n\n /// Updates the given fork to given block number.\n function rollFork(uint256 forkId, uint256 blockNumber) external;\n\n /// Updates the given fork to block number of the given transaction and replays all transaction mined before it in the block.\n function rollFork(uint256 forkId, bytes32 txHash) external;\n\n /// Takes a fork identifier created by `createFork` and sets the corresponding forked state as active.\n function selectFork(uint256 forkId) external;\n\n /// Set blockhash for the current block.\n /// It only sets the blockhash for blocks where `block.number - 256 <= number < block.number`.\n function setBlockhash(uint256 blockNumber, bytes32 blockHash) external;\n\n /// Sets the nonce of an account. Must be higher than the current nonce of the account.\n function setNonce(address account, uint64 newNonce) external;\n\n /// Sets the nonce of an account to an arbitrary value.\n function setNonceUnsafe(address account, uint64 newNonce) external;\n\n /// Snapshot capture the gas usage of the last call by name from the callee perspective.\n function snapshotGasLastCall(string calldata name) external returns (uint256 gasUsed);\n\n /// Snapshot capture the gas usage of the last call by name in a group from the callee perspective.\n function snapshotGasLastCall(string calldata group, string calldata name) external returns (uint256 gasUsed);\n\n /// Snapshot the current state of the evm.\n /// Returns the ID of the snapshot that was created.\n /// To revert a snapshot use `revertToState`.\n function snapshotState() external returns (uint256 snapshotId);\n\n /// Snapshot capture an arbitrary numerical value by name.\n /// The group name is derived from the contract name.\n function snapshotValue(string calldata name, uint256 value) external;\n\n /// Snapshot capture an arbitrary numerical value by name in a group.\n function snapshotValue(string calldata group, string calldata name, uint256 value) external;\n\n /// Sets all subsequent calls' `msg.sender` to be the input address until `stopPrank` is called.\n function startPrank(address msgSender) external;\n\n /// Sets all subsequent calls' `msg.sender` to be the input address until `stopPrank` is called, and the `tx.origin` to be the second input.\n function startPrank(address msgSender, address txOrigin) external;\n\n /// Sets all subsequent delegate calls' `msg.sender` to be the input address until `stopPrank` is called.\n function startPrank(address msgSender, bool delegateCall) external;\n\n /// Sets all subsequent delegate calls' `msg.sender` to be the input address until `stopPrank` is called, and the `tx.origin` to be the second input.\n function startPrank(address msgSender, address txOrigin, bool delegateCall) external;\n\n /// Start a snapshot capture of the current gas usage by name.\n /// The group name is derived from the contract name.\n function startSnapshotGas(string calldata name) external;\n\n /// Start a snapshot capture of the current gas usage by name in a group.\n function startSnapshotGas(string calldata group, string calldata name) external;\n\n /// Resets subsequent calls' `msg.sender` to be `address(this)`.\n function stopPrank() external;\n\n /// Stop the snapshot capture of the current gas by latest snapshot name, capturing the gas used since the start.\n function stopSnapshotGas() external returns (uint256 gasUsed);\n\n /// Stop the snapshot capture of the current gas usage by name, capturing the gas used since the start.\n /// The group name is derived from the contract name.\n function stopSnapshotGas(string calldata name) external returns (uint256 gasUsed);\n\n /// Stop the snapshot capture of the current gas usage by name in a group, capturing the gas used since the start.\n function stopSnapshotGas(string calldata group, string calldata name) external returns (uint256 gasUsed);\n\n /// Stores a value to an address' storage slot.\n function store(address target, bytes32 slot, bytes32 value) external;\n\n /// Fetches the given transaction from the active fork and executes it on the current state.\n function transact(bytes32 txHash) external;\n\n /// Fetches the given transaction from the given fork and executes it on the current state.\n function transact(uint256 forkId, bytes32 txHash) external;\n\n /// Sets `tx.gasprice`.\n function txGasPrice(uint256 newGasPrice) external;\n\n /// Utility cheatcode to mark specific storage slot as warm, simulating a prior read.\n function warmSlot(address target, bytes32 slot) external;\n\n /// Sets `block.timestamp`.\n function warp(uint256 newTimestamp) external;\n\n /// `deleteSnapshot` is being deprecated in favor of `deleteStateSnapshot`. It will be removed in future versions.\n function deleteSnapshot(uint256 snapshotId) external returns (bool success);\n\n /// `deleteSnapshots` is being deprecated in favor of `deleteStateSnapshots`. It will be removed in future versions.\n function deleteSnapshots() external;\n\n /// `revertToAndDelete` is being deprecated in favor of `revertToStateAndDelete`. It will be removed in future versions.\n function revertToAndDelete(uint256 snapshotId) external returns (bool success);\n\n /// `revertTo` is being deprecated in favor of `revertToState`. It will be removed in future versions.\n function revertTo(uint256 snapshotId) external returns (bool success);\n\n /// `snapshot` is being deprecated in favor of `snapshotState`. It will be removed in future versions.\n function snapshot() external returns (uint256 snapshotId);\n\n // ======== Testing ========\n\n /// Expect a call to an address with the specified `msg.value` and calldata, and a *minimum* amount of gas.\n function expectCallMinGas(address callee, uint256 msgValue, uint64 minGas, bytes calldata data) external;\n\n /// Expect given number of calls to an address with the specified `msg.value` and calldata, and a *minimum* amount of gas.\n function expectCallMinGas(address callee, uint256 msgValue, uint64 minGas, bytes calldata data, uint64 count)\n external;\n\n /// Expects a call to an address with the specified calldata.\n /// Calldata can either be a strict or a partial match.\n function expectCall(address callee, bytes calldata data) external;\n\n /// Expects given number of calls to an address with the specified calldata.\n function expectCall(address callee, bytes calldata data, uint64 count) external;\n\n /// Expects a call to an address with the specified `msg.value` and calldata.\n function expectCall(address callee, uint256 msgValue, bytes calldata data) external;\n\n /// Expects given number of calls to an address with the specified `msg.value` and calldata.\n function expectCall(address callee, uint256 msgValue, bytes calldata data, uint64 count) external;\n\n /// Expect a call to an address with the specified `msg.value`, gas, and calldata.\n function expectCall(address callee, uint256 msgValue, uint64 gas, bytes calldata data) external;\n\n /// Expects given number of calls to an address with the specified `msg.value`, gas, and calldata.\n function expectCall(address callee, uint256 msgValue, uint64 gas, bytes calldata data, uint64 count) external;\n\n /// Expects the deployment of the specified bytecode by the specified address using the CREATE opcode\n function expectCreate(bytes calldata bytecode, address deployer) external;\n\n /// Expects the deployment of the specified bytecode by the specified address using the CREATE2 opcode\n function expectCreate2(bytes calldata bytecode, address deployer) external;\n\n /// Prepare an expected anonymous log with (bool checkTopic1, bool checkTopic2, bool checkTopic3, bool checkData.).\n /// Call this function, then emit an anonymous event, then call a function. Internally after the call, we check if\n /// logs were emitted in the expected order with the expected topics and data (as specified by the booleans).\n function expectEmitAnonymous(bool checkTopic0, bool checkTopic1, bool checkTopic2, bool checkTopic3, bool checkData)\n external;\n\n /// Same as the previous method, but also checks supplied address against emitting contract.\n function expectEmitAnonymous(\n bool checkTopic0,\n bool checkTopic1,\n bool checkTopic2,\n bool checkTopic3,\n bool checkData,\n address emitter\n ) external;\n\n /// Prepare an expected anonymous log with all topic and data checks enabled.\n /// Call this function, then emit an anonymous event, then call a function. Internally after the call, we check if\n /// logs were emitted in the expected order with the expected topics and data.\n function expectEmitAnonymous() external;\n\n /// Same as the previous method, but also checks supplied address against emitting contract.\n function expectEmitAnonymous(address emitter) external;\n\n /// Prepare an expected log with (bool checkTopic1, bool checkTopic2, bool checkTopic3, bool checkData.).\n /// Call this function, then emit an event, then call a function. Internally after the call, we check if\n /// logs were emitted in the expected order with the expected topics and data (as specified by the booleans).\n function expectEmit(bool checkTopic1, bool checkTopic2, bool checkTopic3, bool checkData) external;\n\n /// Same as the previous method, but also checks supplied address against emitting contract.\n function expectEmit(bool checkTopic1, bool checkTopic2, bool checkTopic3, bool checkData, address emitter)\n external;\n\n /// Prepare an expected log with all topic and data checks enabled.\n /// Call this function, then emit an event, then call a function. Internally after the call, we check if\n /// logs were emitted in the expected order with the expected topics and data.\n function expectEmit() external;\n\n /// Same as the previous method, but also checks supplied address against emitting contract.\n function expectEmit(address emitter) external;\n\n /// Expect a given number of logs with the provided topics.\n function expectEmit(bool checkTopic1, bool checkTopic2, bool checkTopic3, bool checkData, uint64 count) external;\n\n /// Expect a given number of logs from a specific emitter with the provided topics.\n function expectEmit(\n bool checkTopic1,\n bool checkTopic2,\n bool checkTopic3,\n bool checkData,\n address emitter,\n uint64 count\n ) external;\n\n /// Expect a given number of logs with all topic and data checks enabled.\n function expectEmit(uint64 count) external;\n\n /// Expect a given number of logs from a specific emitter with all topic and data checks enabled.\n function expectEmit(address emitter, uint64 count) external;\n\n /// Expects an error on next call that starts with the revert data.\n function expectPartialRevert(bytes4 revertData) external;\n\n /// Expects an error on next call to reverter address, that starts with the revert data.\n function expectPartialRevert(bytes4 revertData, address reverter) external;\n\n /// Expects an error on next call with any revert data.\n function expectRevert() external;\n\n /// Expects an error on next call that exactly matches the revert data.\n function expectRevert(bytes4 revertData) external;\n\n /// Expects a `count` number of reverts from the upcoming calls from the reverter address that match the revert data.\n function expectRevert(bytes4 revertData, address reverter, uint64 count) external;\n\n /// Expects a `count` number of reverts from the upcoming calls from the reverter address that exactly match the revert data.\n function expectRevert(bytes calldata revertData, address reverter, uint64 count) external;\n\n /// Expects an error on next call that exactly matches the revert data.\n function expectRevert(bytes calldata revertData) external;\n\n /// Expects an error with any revert data on next call to reverter address.\n function expectRevert(address reverter) external;\n\n /// Expects an error from reverter address on next call, with any revert data.\n function expectRevert(bytes4 revertData, address reverter) external;\n\n /// Expects an error from reverter address on next call, that exactly matches the revert data.\n function expectRevert(bytes calldata revertData, address reverter) external;\n\n /// Expects a `count` number of reverts from the upcoming calls with any revert data or reverter.\n function expectRevert(uint64 count) external;\n\n /// Expects a `count` number of reverts from the upcoming calls that match the revert data.\n function expectRevert(bytes4 revertData, uint64 count) external;\n\n /// Expects a `count` number of reverts from the upcoming calls that exactly match the revert data.\n function expectRevert(bytes calldata revertData, uint64 count) external;\n\n /// Expects a `count` number of reverts from the upcoming calls from the reverter address.\n function expectRevert(address reverter, uint64 count) external;\n\n /// Only allows memory writes to offsets [0x00, 0x60) ∪ [min, max) in the current subcontext. If any other\n /// memory is written to, the test will fail. Can be called multiple times to add more ranges to the set.\n function expectSafeMemory(uint64 min, uint64 max) external;\n\n /// Only allows memory writes to offsets [0x00, 0x60) ∪ [min, max) in the next created subcontext.\n /// If any other memory is written to, the test will fail. Can be called multiple times to add more ranges\n /// to the set.\n function expectSafeMemoryCall(uint64 min, uint64 max) external;\n\n /// Marks a test as skipped. Must be called at the top level of a test.\n function skip(bool skipTest) external;\n\n /// Marks a test as skipped with a reason. Must be called at the top level of a test.\n function skip(bool skipTest, string calldata reason) external;\n\n /// Stops all safe memory expectation in the current subcontext.\n function stopExpectSafeMemory() external;\n}\n","license":"MIT OR Apache-2.0"},"lib/forge-std/src/console.sol":{"keccak256":"0x4bbf47eb762cef93729d6ef15e78789957147039b113e5d4df48e3d3fd16d0f5","urls":[],"content":"// SPDX-License-Identifier: MIT\npragma solidity >=0.4.22 <0.9.0;\n\nlibrary console {\n address constant CONSOLE_ADDRESS =\n 0x000000000000000000636F6e736F6c652e6c6f67;\n\n function _sendLogPayloadImplementation(bytes memory payload) internal view {\n address consoleAddress = CONSOLE_ADDRESS;\n /// @solidity memory-safe-assembly\n assembly {\n pop(\n staticcall(\n gas(),\n consoleAddress,\n add(payload, 32),\n mload(payload),\n 0,\n 0\n )\n )\n }\n }\n\n function _castToPure(\n function(bytes memory) internal view fnIn\n ) internal pure returns (function(bytes memory) pure fnOut) {\n assembly {\n fnOut := fnIn\n }\n }\n\n function _sendLogPayload(bytes memory payload) internal pure {\n _castToPure(_sendLogPayloadImplementation)(payload);\n }\n\n function log() internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log()\"));\n }\n\n function logInt(int256 p0) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(int256)\", p0));\n }\n\n function logUint(uint256 p0) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256)\", p0));\n }\n\n function logString(string memory p0) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string)\", p0));\n }\n\n function logBool(bool p0) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool)\", p0));\n }\n\n function logAddress(address p0) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address)\", p0));\n }\n\n function logBytes(bytes memory p0) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bytes)\", p0));\n }\n\n function logBytes1(bytes1 p0) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bytes1)\", p0));\n }\n\n function logBytes2(bytes2 p0) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bytes2)\", p0));\n }\n\n function logBytes3(bytes3 p0) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bytes3)\", p0));\n }\n\n function logBytes4(bytes4 p0) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bytes4)\", p0));\n }\n\n function logBytes5(bytes5 p0) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bytes5)\", p0));\n }\n\n function logBytes6(bytes6 p0) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bytes6)\", p0));\n }\n\n function logBytes7(bytes7 p0) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bytes7)\", p0));\n }\n\n function logBytes8(bytes8 p0) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bytes8)\", p0));\n }\n\n function logBytes9(bytes9 p0) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bytes9)\", p0));\n }\n\n function logBytes10(bytes10 p0) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bytes10)\", p0));\n }\n\n function logBytes11(bytes11 p0) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bytes11)\", p0));\n }\n\n function logBytes12(bytes12 p0) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bytes12)\", p0));\n }\n\n function logBytes13(bytes13 p0) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bytes13)\", p0));\n }\n\n function logBytes14(bytes14 p0) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bytes14)\", p0));\n }\n\n function logBytes15(bytes15 p0) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bytes15)\", p0));\n }\n\n function logBytes16(bytes16 p0) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bytes16)\", p0));\n }\n\n function logBytes17(bytes17 p0) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bytes17)\", p0));\n }\n\n function logBytes18(bytes18 p0) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bytes18)\", p0));\n }\n\n function logBytes19(bytes19 p0) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bytes19)\", p0));\n }\n\n function logBytes20(bytes20 p0) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bytes20)\", p0));\n }\n\n function logBytes21(bytes21 p0) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bytes21)\", p0));\n }\n\n function logBytes22(bytes22 p0) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bytes22)\", p0));\n }\n\n function logBytes23(bytes23 p0) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bytes23)\", p0));\n }\n\n function logBytes24(bytes24 p0) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bytes24)\", p0));\n }\n\n function logBytes25(bytes25 p0) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bytes25)\", p0));\n }\n\n function logBytes26(bytes26 p0) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bytes26)\", p0));\n }\n\n function logBytes27(bytes27 p0) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bytes27)\", p0));\n }\n\n function logBytes28(bytes28 p0) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bytes28)\", p0));\n }\n\n function logBytes29(bytes29 p0) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bytes29)\", p0));\n }\n\n function logBytes30(bytes30 p0) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bytes30)\", p0));\n }\n\n function logBytes31(bytes31 p0) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bytes31)\", p0));\n }\n\n function logBytes32(bytes32 p0) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bytes32)\", p0));\n }\n\n function log(uint256 p0) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256)\", p0));\n }\n\n function log(int256 p0) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(int256)\", p0));\n }\n\n function log(string memory p0) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string)\", p0));\n }\n\n function log(bool p0) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool)\", p0));\n }\n\n function log(address p0) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address)\", p0));\n }\n\n function log(uint256 p0, uint256 p1) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,uint256)\", p0, p1));\n }\n\n function log(uint256 p0, string memory p1) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,string)\", p0, p1));\n }\n\n function log(uint256 p0, bool p1) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,bool)\", p0, p1));\n }\n\n function log(uint256 p0, address p1) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,address)\", p0, p1));\n }\n\n function log(string memory p0, uint256 p1) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,uint256)\", p0, p1));\n }\n\n function log(string memory p0, int256 p1) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,int256)\", p0, p1));\n }\n\n function log(string memory p0, string memory p1) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,string)\", p0, p1));\n }\n\n function log(string memory p0, bool p1) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,bool)\", p0, p1));\n }\n\n function log(string memory p0, address p1) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,address)\", p0, p1));\n }\n\n function log(bool p0, uint256 p1) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,uint256)\", p0, p1));\n }\n\n function log(bool p0, string memory p1) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,string)\", p0, p1));\n }\n\n function log(bool p0, bool p1) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,bool)\", p0, p1));\n }\n\n function log(bool p0, address p1) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,address)\", p0, p1));\n }\n\n function log(address p0, uint256 p1) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,uint256)\", p0, p1));\n }\n\n function log(address p0, string memory p1) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,string)\", p0, p1));\n }\n\n function log(address p0, bool p1) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,bool)\", p0, p1));\n }\n\n function log(address p0, address p1) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,address)\", p0, p1));\n }\n\n function log(uint256 p0, uint256 p1, uint256 p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,uint256,uint256)\", p0, p1, p2));\n }\n\n function log(uint256 p0, uint256 p1, string memory p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,uint256,string)\", p0, p1, p2));\n }\n\n function log(uint256 p0, uint256 p1, bool p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,uint256,bool)\", p0, p1, p2));\n }\n\n function log(uint256 p0, uint256 p1, address p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,uint256,address)\", p0, p1, p2));\n }\n\n function log(uint256 p0, string memory p1, uint256 p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,string,uint256)\", p0, p1, p2));\n }\n\n function log(uint256 p0, string memory p1, string memory p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,string,string)\", p0, p1, p2));\n }\n\n function log(uint256 p0, string memory p1, bool p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,string,bool)\", p0, p1, p2));\n }\n\n function log(uint256 p0, string memory p1, address p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,string,address)\", p0, p1, p2));\n }\n\n function log(uint256 p0, bool p1, uint256 p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,bool,uint256)\", p0, p1, p2));\n }\n\n function log(uint256 p0, bool p1, string memory p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,bool,string)\", p0, p1, p2));\n }\n\n function log(uint256 p0, bool p1, bool p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,bool,bool)\", p0, p1, p2));\n }\n\n function log(uint256 p0, bool p1, address p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,bool,address)\", p0, p1, p2));\n }\n\n function log(uint256 p0, address p1, uint256 p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,address,uint256)\", p0, p1, p2));\n }\n\n function log(uint256 p0, address p1, string memory p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,address,string)\", p0, p1, p2));\n }\n\n function log(uint256 p0, address p1, bool p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,address,bool)\", p0, p1, p2));\n }\n\n function log(uint256 p0, address p1, address p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,address,address)\", p0, p1, p2));\n }\n\n function log(string memory p0, uint256 p1, uint256 p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,uint256,uint256)\", p0, p1, p2));\n }\n\n function log(string memory p0, uint256 p1, string memory p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,uint256,string)\", p0, p1, p2));\n }\n\n function log(string memory p0, uint256 p1, bool p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,uint256,bool)\", p0, p1, p2));\n }\n\n function log(string memory p0, uint256 p1, address p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,uint256,address)\", p0, p1, p2));\n }\n\n function log(string memory p0, string memory p1, uint256 p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,string,uint256)\", p0, p1, p2));\n }\n\n function log(string memory p0, string memory p1, string memory p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,string,string)\", p0, p1, p2));\n }\n\n function log(string memory p0, string memory p1, bool p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,string,bool)\", p0, p1, p2));\n }\n\n function log(string memory p0, string memory p1, address p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,string,address)\", p0, p1, p2));\n }\n\n function log(string memory p0, bool p1, uint256 p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,bool,uint256)\", p0, p1, p2));\n }\n\n function log(string memory p0, bool p1, string memory p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,bool,string)\", p0, p1, p2));\n }\n\n function log(string memory p0, bool p1, bool p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,bool,bool)\", p0, p1, p2));\n }\n\n function log(string memory p0, bool p1, address p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,bool,address)\", p0, p1, p2));\n }\n\n function log(string memory p0, address p1, uint256 p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,address,uint256)\", p0, p1, p2));\n }\n\n function log(string memory p0, address p1, string memory p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,address,string)\", p0, p1, p2));\n }\n\n function log(string memory p0, address p1, bool p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,address,bool)\", p0, p1, p2));\n }\n\n function log(string memory p0, address p1, address p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,address,address)\", p0, p1, p2));\n }\n\n function log(bool p0, uint256 p1, uint256 p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,uint256,uint256)\", p0, p1, p2));\n }\n\n function log(bool p0, uint256 p1, string memory p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,uint256,string)\", p0, p1, p2));\n }\n\n function log(bool p0, uint256 p1, bool p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,uint256,bool)\", p0, p1, p2));\n }\n\n function log(bool p0, uint256 p1, address p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,uint256,address)\", p0, p1, p2));\n }\n\n function log(bool p0, string memory p1, uint256 p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,string,uint256)\", p0, p1, p2));\n }\n\n function log(bool p0, string memory p1, string memory p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,string,string)\", p0, p1, p2));\n }\n\n function log(bool p0, string memory p1, bool p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,string,bool)\", p0, p1, p2));\n }\n\n function log(bool p0, string memory p1, address p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,string,address)\", p0, p1, p2));\n }\n\n function log(bool p0, bool p1, uint256 p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,bool,uint256)\", p0, p1, p2));\n }\n\n function log(bool p0, bool p1, string memory p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,bool,string)\", p0, p1, p2));\n }\n\n function log(bool p0, bool p1, bool p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,bool,bool)\", p0, p1, p2));\n }\n\n function log(bool p0, bool p1, address p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,bool,address)\", p0, p1, p2));\n }\n\n function log(bool p0, address p1, uint256 p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,address,uint256)\", p0, p1, p2));\n }\n\n function log(bool p0, address p1, string memory p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,address,string)\", p0, p1, p2));\n }\n\n function log(bool p0, address p1, bool p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,address,bool)\", p0, p1, p2));\n }\n\n function log(bool p0, address p1, address p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,address,address)\", p0, p1, p2));\n }\n\n function log(address p0, uint256 p1, uint256 p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,uint256,uint256)\", p0, p1, p2));\n }\n\n function log(address p0, uint256 p1, string memory p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,uint256,string)\", p0, p1, p2));\n }\n\n function log(address p0, uint256 p1, bool p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,uint256,bool)\", p0, p1, p2));\n }\n\n function log(address p0, uint256 p1, address p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,uint256,address)\", p0, p1, p2));\n }\n\n function log(address p0, string memory p1, uint256 p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,string,uint256)\", p0, p1, p2));\n }\n\n function log(address p0, string memory p1, string memory p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,string,string)\", p0, p1, p2));\n }\n\n function log(address p0, string memory p1, bool p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,string,bool)\", p0, p1, p2));\n }\n\n function log(address p0, string memory p1, address p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,string,address)\", p0, p1, p2));\n }\n\n function log(address p0, bool p1, uint256 p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,bool,uint256)\", p0, p1, p2));\n }\n\n function log(address p0, bool p1, string memory p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,bool,string)\", p0, p1, p2));\n }\n\n function log(address p0, bool p1, bool p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,bool,bool)\", p0, p1, p2));\n }\n\n function log(address p0, bool p1, address p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,bool,address)\", p0, p1, p2));\n }\n\n function log(address p0, address p1, uint256 p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,address,uint256)\", p0, p1, p2));\n }\n\n function log(address p0, address p1, string memory p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,address,string)\", p0, p1, p2));\n }\n\n function log(address p0, address p1, bool p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,address,bool)\", p0, p1, p2));\n }\n\n function log(address p0, address p1, address p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,address,address)\", p0, p1, p2));\n }\n\n function log(uint256 p0, uint256 p1, uint256 p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,uint256,uint256,uint256)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, uint256 p1, uint256 p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,uint256,uint256,string)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, uint256 p1, uint256 p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,uint256,uint256,bool)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, uint256 p1, uint256 p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,uint256,uint256,address)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, uint256 p1, string memory p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,uint256,string,uint256)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, uint256 p1, string memory p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,uint256,string,string)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, uint256 p1, string memory p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,uint256,string,bool)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, uint256 p1, string memory p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,uint256,string,address)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, uint256 p1, bool p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,uint256,bool,uint256)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, uint256 p1, bool p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,uint256,bool,string)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, uint256 p1, bool p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,uint256,bool,bool)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, uint256 p1, bool p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,uint256,bool,address)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, uint256 p1, address p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,uint256,address,uint256)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, uint256 p1, address p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,uint256,address,string)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, uint256 p1, address p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,uint256,address,bool)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, uint256 p1, address p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,uint256,address,address)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, string memory p1, uint256 p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,string,uint256,uint256)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, string memory p1, uint256 p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,string,uint256,string)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, string memory p1, uint256 p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,string,uint256,bool)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, string memory p1, uint256 p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,string,uint256,address)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, string memory p1, string memory p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,string,string,uint256)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, string memory p1, string memory p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,string,string,string)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, string memory p1, string memory p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,string,string,bool)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, string memory p1, string memory p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,string,string,address)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, string memory p1, bool p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,string,bool,uint256)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, string memory p1, bool p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,string,bool,string)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, string memory p1, bool p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,string,bool,bool)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, string memory p1, bool p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,string,bool,address)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, string memory p1, address p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,string,address,uint256)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, string memory p1, address p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,string,address,string)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, string memory p1, address p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,string,address,bool)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, string memory p1, address p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,string,address,address)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, bool p1, uint256 p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,bool,uint256,uint256)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, bool p1, uint256 p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,bool,uint256,string)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, bool p1, uint256 p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,bool,uint256,bool)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, bool p1, uint256 p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,bool,uint256,address)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, bool p1, string memory p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,bool,string,uint256)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, bool p1, string memory p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,bool,string,string)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, bool p1, string memory p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,bool,string,bool)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, bool p1, string memory p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,bool,string,address)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, bool p1, bool p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,bool,bool,uint256)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, bool p1, bool p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,bool,bool,string)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, bool p1, bool p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,bool,bool,bool)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, bool p1, bool p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,bool,bool,address)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, bool p1, address p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,bool,address,uint256)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, bool p1, address p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,bool,address,string)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, bool p1, address p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,bool,address,bool)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, bool p1, address p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,bool,address,address)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, address p1, uint256 p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,address,uint256,uint256)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, address p1, uint256 p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,address,uint256,string)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, address p1, uint256 p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,address,uint256,bool)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, address p1, uint256 p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,address,uint256,address)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, address p1, string memory p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,address,string,uint256)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, address p1, string memory p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,address,string,string)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, address p1, string memory p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,address,string,bool)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, address p1, string memory p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,address,string,address)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, address p1, bool p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,address,bool,uint256)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, address p1, bool p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,address,bool,string)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, address p1, bool p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,address,bool,bool)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, address p1, bool p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,address,bool,address)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, address p1, address p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,address,address,uint256)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, address p1, address p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,address,address,string)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, address p1, address p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,address,address,bool)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, address p1, address p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,address,address,address)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, uint256 p1, uint256 p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,uint256,uint256,uint256)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, uint256 p1, uint256 p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,uint256,uint256,string)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, uint256 p1, uint256 p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,uint256,uint256,bool)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, uint256 p1, uint256 p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,uint256,uint256,address)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, uint256 p1, string memory p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,uint256,string,uint256)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, uint256 p1, string memory p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,uint256,string,string)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, uint256 p1, string memory p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,uint256,string,bool)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, uint256 p1, string memory p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,uint256,string,address)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, uint256 p1, bool p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,uint256,bool,uint256)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, uint256 p1, bool p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,uint256,bool,string)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, uint256 p1, bool p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,uint256,bool,bool)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, uint256 p1, bool p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,uint256,bool,address)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, uint256 p1, address p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,uint256,address,uint256)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, uint256 p1, address p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,uint256,address,string)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, uint256 p1, address p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,uint256,address,bool)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, uint256 p1, address p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,uint256,address,address)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, string memory p1, uint256 p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,string,uint256,uint256)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, string memory p1, uint256 p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,string,uint256,string)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, string memory p1, uint256 p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,string,uint256,bool)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, string memory p1, uint256 p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,string,uint256,address)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, string memory p1, string memory p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,string,string,uint256)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, string memory p1, string memory p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,string,string,string)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, string memory p1, string memory p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,string,string,bool)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, string memory p1, string memory p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,string,string,address)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, string memory p1, bool p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,string,bool,uint256)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, string memory p1, bool p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,string,bool,string)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, string memory p1, bool p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,string,bool,bool)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, string memory p1, bool p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,string,bool,address)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, string memory p1, address p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,string,address,uint256)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, string memory p1, address p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,string,address,string)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, string memory p1, address p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,string,address,bool)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, string memory p1, address p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,string,address,address)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, bool p1, uint256 p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,bool,uint256,uint256)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, bool p1, uint256 p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,bool,uint256,string)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, bool p1, uint256 p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,bool,uint256,bool)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, bool p1, uint256 p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,bool,uint256,address)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, bool p1, string memory p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,bool,string,uint256)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, bool p1, string memory p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,bool,string,string)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, bool p1, string memory p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,bool,string,bool)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, bool p1, string memory p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,bool,string,address)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, bool p1, bool p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,bool,bool,uint256)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, bool p1, bool p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,bool,bool,string)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, bool p1, bool p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,bool,bool,bool)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, bool p1, bool p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,bool,bool,address)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, bool p1, address p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,bool,address,uint256)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, bool p1, address p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,bool,address,string)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, bool p1, address p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,bool,address,bool)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, bool p1, address p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,bool,address,address)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, address p1, uint256 p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,address,uint256,uint256)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, address p1, uint256 p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,address,uint256,string)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, address p1, uint256 p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,address,uint256,bool)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, address p1, uint256 p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,address,uint256,address)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, address p1, string memory p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,address,string,uint256)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, address p1, string memory p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,address,string,string)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, address p1, string memory p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,address,string,bool)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, address p1, string memory p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,address,string,address)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, address p1, bool p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,address,bool,uint256)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, address p1, bool p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,address,bool,string)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, address p1, bool p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,address,bool,bool)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, address p1, bool p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,address,bool,address)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, address p1, address p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,address,address,uint256)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, address p1, address p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,address,address,string)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, address p1, address p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,address,address,bool)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, address p1, address p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,address,address,address)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, uint256 p1, uint256 p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,uint256,uint256,uint256)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, uint256 p1, uint256 p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,uint256,uint256,string)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, uint256 p1, uint256 p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,uint256,uint256,bool)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, uint256 p1, uint256 p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,uint256,uint256,address)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, uint256 p1, string memory p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,uint256,string,uint256)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, uint256 p1, string memory p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,uint256,string,string)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, uint256 p1, string memory p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,uint256,string,bool)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, uint256 p1, string memory p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,uint256,string,address)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, uint256 p1, bool p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,uint256,bool,uint256)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, uint256 p1, bool p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,uint256,bool,string)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, uint256 p1, bool p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,uint256,bool,bool)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, uint256 p1, bool p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,uint256,bool,address)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, uint256 p1, address p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,uint256,address,uint256)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, uint256 p1, address p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,uint256,address,string)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, uint256 p1, address p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,uint256,address,bool)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, uint256 p1, address p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,uint256,address,address)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, string memory p1, uint256 p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,string,uint256,uint256)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, string memory p1, uint256 p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,string,uint256,string)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, string memory p1, uint256 p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,string,uint256,bool)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, string memory p1, uint256 p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,string,uint256,address)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, string memory p1, string memory p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,string,string,uint256)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, string memory p1, string memory p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,string,string,string)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, string memory p1, string memory p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,string,string,bool)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, string memory p1, string memory p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,string,string,address)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, string memory p1, bool p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,string,bool,uint256)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, string memory p1, bool p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,string,bool,string)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, string memory p1, bool p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,string,bool,bool)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, string memory p1, bool p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,string,bool,address)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, string memory p1, address p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,string,address,uint256)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, string memory p1, address p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,string,address,string)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, string memory p1, address p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,string,address,bool)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, string memory p1, address p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,string,address,address)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, bool p1, uint256 p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,bool,uint256,uint256)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, bool p1, uint256 p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,bool,uint256,string)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, bool p1, uint256 p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,bool,uint256,bool)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, bool p1, uint256 p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,bool,uint256,address)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, bool p1, string memory p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,bool,string,uint256)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, bool p1, string memory p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,bool,string,string)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, bool p1, string memory p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,bool,string,bool)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, bool p1, string memory p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,bool,string,address)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, bool p1, bool p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,bool,bool,uint256)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, bool p1, bool p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,bool,bool,string)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, bool p1, bool p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,bool,bool,bool)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, bool p1, bool p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,bool,bool,address)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, bool p1, address p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,bool,address,uint256)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, bool p1, address p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,bool,address,string)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, bool p1, address p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,bool,address,bool)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, bool p1, address p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,bool,address,address)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, address p1, uint256 p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,address,uint256,uint256)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, address p1, uint256 p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,address,uint256,string)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, address p1, uint256 p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,address,uint256,bool)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, address p1, uint256 p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,address,uint256,address)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, address p1, string memory p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,address,string,uint256)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, address p1, string memory p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,address,string,string)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, address p1, string memory p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,address,string,bool)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, address p1, string memory p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,address,string,address)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, address p1, bool p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,address,bool,uint256)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, address p1, bool p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,address,bool,string)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, address p1, bool p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,address,bool,bool)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, address p1, bool p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,address,bool,address)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, address p1, address p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,address,address,uint256)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, address p1, address p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,address,address,string)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, address p1, address p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,address,address,bool)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, address p1, address p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,address,address,address)\", p0, p1, p2, p3));\n }\n\n function log(address p0, uint256 p1, uint256 p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,uint256,uint256,uint256)\", p0, p1, p2, p3));\n }\n\n function log(address p0, uint256 p1, uint256 p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,uint256,uint256,string)\", p0, p1, p2, p3));\n }\n\n function log(address p0, uint256 p1, uint256 p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,uint256,uint256,bool)\", p0, p1, p2, p3));\n }\n\n function log(address p0, uint256 p1, uint256 p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,uint256,uint256,address)\", p0, p1, p2, p3));\n }\n\n function log(address p0, uint256 p1, string memory p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,uint256,string,uint256)\", p0, p1, p2, p3));\n }\n\n function log(address p0, uint256 p1, string memory p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,uint256,string,string)\", p0, p1, p2, p3));\n }\n\n function log(address p0, uint256 p1, string memory p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,uint256,string,bool)\", p0, p1, p2, p3));\n }\n\n function log(address p0, uint256 p1, string memory p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,uint256,string,address)\", p0, p1, p2, p3));\n }\n\n function log(address p0, uint256 p1, bool p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,uint256,bool,uint256)\", p0, p1, p2, p3));\n }\n\n function log(address p0, uint256 p1, bool p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,uint256,bool,string)\", p0, p1, p2, p3));\n }\n\n function log(address p0, uint256 p1, bool p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,uint256,bool,bool)\", p0, p1, p2, p3));\n }\n\n function log(address p0, uint256 p1, bool p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,uint256,bool,address)\", p0, p1, p2, p3));\n }\n\n function log(address p0, uint256 p1, address p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,uint256,address,uint256)\", p0, p1, p2, p3));\n }\n\n function log(address p0, uint256 p1, address p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,uint256,address,string)\", p0, p1, p2, p3));\n }\n\n function log(address p0, uint256 p1, address p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,uint256,address,bool)\", p0, p1, p2, p3));\n }\n\n function log(address p0, uint256 p1, address p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,uint256,address,address)\", p0, p1, p2, p3));\n }\n\n function log(address p0, string memory p1, uint256 p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,string,uint256,uint256)\", p0, p1, p2, p3));\n }\n\n function log(address p0, string memory p1, uint256 p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,string,uint256,string)\", p0, p1, p2, p3));\n }\n\n function log(address p0, string memory p1, uint256 p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,string,uint256,bool)\", p0, p1, p2, p3));\n }\n\n function log(address p0, string memory p1, uint256 p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,string,uint256,address)\", p0, p1, p2, p3));\n }\n\n function log(address p0, string memory p1, string memory p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,string,string,uint256)\", p0, p1, p2, p3));\n }\n\n function log(address p0, string memory p1, string memory p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,string,string,string)\", p0, p1, p2, p3));\n }\n\n function log(address p0, string memory p1, string memory p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,string,string,bool)\", p0, p1, p2, p3));\n }\n\n function log(address p0, string memory p1, string memory p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,string,string,address)\", p0, p1, p2, p3));\n }\n\n function log(address p0, string memory p1, bool p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,string,bool,uint256)\", p0, p1, p2, p3));\n }\n\n function log(address p0, string memory p1, bool p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,string,bool,string)\", p0, p1, p2, p3));\n }\n\n function log(address p0, string memory p1, bool p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,string,bool,bool)\", p0, p1, p2, p3));\n }\n\n function log(address p0, string memory p1, bool p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,string,bool,address)\", p0, p1, p2, p3));\n }\n\n function log(address p0, string memory p1, address p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,string,address,uint256)\", p0, p1, p2, p3));\n }\n\n function log(address p0, string memory p1, address p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,string,address,string)\", p0, p1, p2, p3));\n }\n\n function log(address p0, string memory p1, address p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,string,address,bool)\", p0, p1, p2, p3));\n }\n\n function log(address p0, string memory p1, address p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,string,address,address)\", p0, p1, p2, p3));\n }\n\n function log(address p0, bool p1, uint256 p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,bool,uint256,uint256)\", p0, p1, p2, p3));\n }\n\n function log(address p0, bool p1, uint256 p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,bool,uint256,string)\", p0, p1, p2, p3));\n }\n\n function log(address p0, bool p1, uint256 p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,bool,uint256,bool)\", p0, p1, p2, p3));\n }\n\n function log(address p0, bool p1, uint256 p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,bool,uint256,address)\", p0, p1, p2, p3));\n }\n\n function log(address p0, bool p1, string memory p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,bool,string,uint256)\", p0, p1, p2, p3));\n }\n\n function log(address p0, bool p1, string memory p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,bool,string,string)\", p0, p1, p2, p3));\n }\n\n function log(address p0, bool p1, string memory p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,bool,string,bool)\", p0, p1, p2, p3));\n }\n\n function log(address p0, bool p1, string memory p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,bool,string,address)\", p0, p1, p2, p3));\n }\n\n function log(address p0, bool p1, bool p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,bool,bool,uint256)\", p0, p1, p2, p3));\n }\n\n function log(address p0, bool p1, bool p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,bool,bool,string)\", p0, p1, p2, p3));\n }\n\n function log(address p0, bool p1, bool p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,bool,bool,bool)\", p0, p1, p2, p3));\n }\n\n function log(address p0, bool p1, bool p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,bool,bool,address)\", p0, p1, p2, p3));\n }\n\n function log(address p0, bool p1, address p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,bool,address,uint256)\", p0, p1, p2, p3));\n }\n\n function log(address p0, bool p1, address p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,bool,address,string)\", p0, p1, p2, p3));\n }\n\n function log(address p0, bool p1, address p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,bool,address,bool)\", p0, p1, p2, p3));\n }\n\n function log(address p0, bool p1, address p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,bool,address,address)\", p0, p1, p2, p3));\n }\n\n function log(address p0, address p1, uint256 p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,address,uint256,uint256)\", p0, p1, p2, p3));\n }\n\n function log(address p0, address p1, uint256 p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,address,uint256,string)\", p0, p1, p2, p3));\n }\n\n function log(address p0, address p1, uint256 p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,address,uint256,bool)\", p0, p1, p2, p3));\n }\n\n function log(address p0, address p1, uint256 p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,address,uint256,address)\", p0, p1, p2, p3));\n }\n\n function log(address p0, address p1, string memory p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,address,string,uint256)\", p0, p1, p2, p3));\n }\n\n function log(address p0, address p1, string memory p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,address,string,string)\", p0, p1, p2, p3));\n }\n\n function log(address p0, address p1, string memory p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,address,string,bool)\", p0, p1, p2, p3));\n }\n\n function log(address p0, address p1, string memory p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,address,string,address)\", p0, p1, p2, p3));\n }\n\n function log(address p0, address p1, bool p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,address,bool,uint256)\", p0, p1, p2, p3));\n }\n\n function log(address p0, address p1, bool p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,address,bool,string)\", p0, p1, p2, p3));\n }\n\n function log(address p0, address p1, bool p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,address,bool,bool)\", p0, p1, p2, p3));\n }\n\n function log(address p0, address p1, bool p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,address,bool,address)\", p0, p1, p2, p3));\n }\n\n function log(address p0, address p1, address p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,address,address,uint256)\", p0, p1, p2, p3));\n }\n\n function log(address p0, address p1, address p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,address,address,string)\", p0, p1, p2, p3));\n }\n\n function log(address p0, address p1, address p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,address,address,bool)\", p0, p1, p2, p3));\n }\n\n function log(address p0, address p1, address p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,address,address,address)\", p0, p1, p2, p3));\n }\n}\n","license":"MIT"},"lib/forge-std/src/console2.sol":{"keccak256":"0x3b8fe79f48f065a4e4d35362171304a33784c3a90febae5f2787805a438de12f","urls":[],"content":"// SPDX-License-Identifier: MIT\npragma solidity >=0.4.22 <0.9.0;\n\nimport {console as console2} from \"./console.sol\";\n","license":"MIT"},"lib/forge-std/src/interfaces/IMulticall3.sol":{"keccak256":"0x7aac1389150499a922d1f9ef5749c908cef127cb2075b92fa17e9cb611263d0a","urls":[],"content":"// SPDX-License-Identifier: MIT\npragma solidity >=0.6.2 <0.9.0;\n\npragma experimental ABIEncoderV2;\n\ninterface IMulticall3 {\n struct Call {\n address target;\n bytes callData;\n }\n\n struct Call3 {\n address target;\n bool allowFailure;\n bytes callData;\n }\n\n struct Call3Value {\n address target;\n bool allowFailure;\n uint256 value;\n bytes callData;\n }\n\n struct Result {\n bool success;\n bytes returnData;\n }\n\n function aggregate(Call[] calldata calls)\n external\n payable\n returns (uint256 blockNumber, bytes[] memory returnData);\n\n function aggregate3(Call3[] calldata calls) external payable returns (Result[] memory returnData);\n\n function aggregate3Value(Call3Value[] calldata calls) external payable returns (Result[] memory returnData);\n\n function blockAndAggregate(Call[] calldata calls)\n external\n payable\n returns (uint256 blockNumber, bytes32 blockHash, Result[] memory returnData);\n\n function getBasefee() external view returns (uint256 basefee);\n\n function getBlockHash(uint256 blockNumber) external view returns (bytes32 blockHash);\n\n function getBlockNumber() external view returns (uint256 blockNumber);\n\n function getChainId() external view returns (uint256 chainid);\n\n function getCurrentBlockCoinbase() external view returns (address coinbase);\n\n function getCurrentBlockDifficulty() external view returns (uint256 difficulty);\n\n function getCurrentBlockGasLimit() external view returns (uint256 gaslimit);\n\n function getCurrentBlockTimestamp() external view returns (uint256 timestamp);\n\n function getEthBalance(address addr) external view returns (uint256 balance);\n\n function getLastBlockHash() external view returns (bytes32 blockHash);\n\n function tryAggregate(bool requireSuccess, Call[] calldata calls)\n external\n payable\n returns (Result[] memory returnData);\n\n function tryBlockAndAggregate(bool requireSuccess, Call[] calldata calls)\n external\n payable\n returns (uint256 blockNumber, bytes32 blockHash, Result[] memory returnData);\n}\n","license":"MIT"},"lib/forge-std/src/safeconsole.sol":{"keccak256":"0xbef9786cb49d3eade757bad87568c49c8c8f35721f0193c95ffb055d9e466e11","urls":[],"content":"// SPDX-License-Identifier: MIT\npragma solidity >=0.6.2 <0.9.0;\n\n/// @author philogy \n/// @dev Code generated automatically by script.\nlibrary safeconsole {\n uint256 constant CONSOLE_ADDR = 0x000000000000000000000000000000000000000000636F6e736F6c652e6c6f67;\n\n // Credit to [0age](https://twitter.com/z0age/status/1654922202930888704) and [0xdapper](https://github.com/foundry-rs/forge-std/pull/374)\n // for the view-to-pure log trick.\n function _sendLogPayload(uint256 offset, uint256 size) private pure {\n function(uint256, uint256) internal view fnIn = _sendLogPayloadView;\n function(uint256, uint256) internal pure pureSendLogPayload;\n /// @solidity memory-safe-assembly\n assembly {\n pureSendLogPayload := fnIn\n }\n pureSendLogPayload(offset, size);\n }\n\n function _sendLogPayloadView(uint256 offset, uint256 size) private view {\n /// @solidity memory-safe-assembly\n assembly {\n pop(staticcall(gas(), CONSOLE_ADDR, offset, size, 0x0, 0x0))\n }\n }\n\n function _memcopy(uint256 fromOffset, uint256 toOffset, uint256 length) private pure {\n function(uint256, uint256, uint256) internal view fnIn = _memcopyView;\n function(uint256, uint256, uint256) internal pure pureMemcopy;\n /// @solidity memory-safe-assembly\n assembly {\n pureMemcopy := fnIn\n }\n pureMemcopy(fromOffset, toOffset, length);\n }\n\n function _memcopyView(uint256 fromOffset, uint256 toOffset, uint256 length) private view {\n /// @solidity memory-safe-assembly\n assembly {\n pop(staticcall(gas(), 0x4, fromOffset, length, toOffset, length))\n }\n }\n\n function logMemory(uint256 offset, uint256 length) internal pure {\n if (offset >= 0x60) {\n // Sufficient memory before slice to prepare call header.\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(sub(offset, 0x60))\n m1 := mload(sub(offset, 0x40))\n m2 := mload(sub(offset, 0x20))\n // Selector of `log(bytes)`.\n mstore(sub(offset, 0x60), 0x0be77f56)\n mstore(sub(offset, 0x40), 0x20)\n mstore(sub(offset, 0x20), length)\n }\n _sendLogPayload(offset - 0x44, length + 0x44);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(sub(offset, 0x60), m0)\n mstore(sub(offset, 0x40), m1)\n mstore(sub(offset, 0x20), m2)\n }\n } else {\n // Insufficient space, so copy slice forward, add header and reverse.\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n uint256 endOffset = offset + length;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(add(endOffset, 0x00))\n m1 := mload(add(endOffset, 0x20))\n m2 := mload(add(endOffset, 0x40))\n }\n _memcopy(offset, offset + 0x60, length);\n /// @solidity memory-safe-assembly\n assembly {\n // Selector of `log(bytes)`.\n mstore(add(offset, 0x00), 0x0be77f56)\n mstore(add(offset, 0x20), 0x20)\n mstore(add(offset, 0x40), length)\n }\n _sendLogPayload(offset + 0x1c, length + 0x44);\n _memcopy(offset + 0x60, offset, length);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(add(endOffset, 0x00), m0)\n mstore(add(endOffset, 0x20), m1)\n mstore(add(endOffset, 0x40), m2)\n }\n }\n }\n\n function log(address p0) internal pure {\n bytes32 m0;\n bytes32 m1;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n // Selector of `log(address)`.\n mstore(0x00, 0x2c2ecbc2)\n mstore(0x20, p0)\n }\n _sendLogPayload(0x1c, 0x24);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n }\n }\n\n function log(bool p0) internal pure {\n bytes32 m0;\n bytes32 m1;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n // Selector of `log(bool)`.\n mstore(0x00, 0x32458eed)\n mstore(0x20, p0)\n }\n _sendLogPayload(0x1c, 0x24);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n }\n }\n\n function log(uint256 p0) internal pure {\n bytes32 m0;\n bytes32 m1;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n // Selector of `log(uint256)`.\n mstore(0x00, 0xf82c50f1)\n mstore(0x20, p0)\n }\n _sendLogPayload(0x1c, 0x24);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n }\n }\n\n function log(bytes32 p0) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n // Selector of `log(string)`.\n mstore(0x00, 0x41304fac)\n mstore(0x20, 0x20)\n writeString(0x40, p0)\n }\n _sendLogPayload(0x1c, 0x64);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n }\n }\n\n function log(address p0, address p1) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n // Selector of `log(address,address)`.\n mstore(0x00, 0xdaf0d4aa)\n mstore(0x20, p0)\n mstore(0x40, p1)\n }\n _sendLogPayload(0x1c, 0x44);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n }\n }\n\n function log(address p0, bool p1) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n // Selector of `log(address,bool)`.\n mstore(0x00, 0x75b605d3)\n mstore(0x20, p0)\n mstore(0x40, p1)\n }\n _sendLogPayload(0x1c, 0x44);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n }\n }\n\n function log(address p0, uint256 p1) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n // Selector of `log(address,uint256)`.\n mstore(0x00, 0x8309e8a8)\n mstore(0x20, p0)\n mstore(0x40, p1)\n }\n _sendLogPayload(0x1c, 0x44);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n }\n }\n\n function log(address p0, bytes32 p1) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(address,string)`.\n mstore(0x00, 0x759f86bb)\n mstore(0x20, p0)\n mstore(0x40, 0x40)\n writeString(0x60, p1)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(bool p0, address p1) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n // Selector of `log(bool,address)`.\n mstore(0x00, 0x853c4849)\n mstore(0x20, p0)\n mstore(0x40, p1)\n }\n _sendLogPayload(0x1c, 0x44);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n }\n }\n\n function log(bool p0, bool p1) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n // Selector of `log(bool,bool)`.\n mstore(0x00, 0x2a110e83)\n mstore(0x20, p0)\n mstore(0x40, p1)\n }\n _sendLogPayload(0x1c, 0x44);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n }\n }\n\n function log(bool p0, uint256 p1) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n // Selector of `log(bool,uint256)`.\n mstore(0x00, 0x399174d3)\n mstore(0x20, p0)\n mstore(0x40, p1)\n }\n _sendLogPayload(0x1c, 0x44);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n }\n }\n\n function log(bool p0, bytes32 p1) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(bool,string)`.\n mstore(0x00, 0x8feac525)\n mstore(0x20, p0)\n mstore(0x40, 0x40)\n writeString(0x60, p1)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(uint256 p0, address p1) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n // Selector of `log(uint256,address)`.\n mstore(0x00, 0x69276c86)\n mstore(0x20, p0)\n mstore(0x40, p1)\n }\n _sendLogPayload(0x1c, 0x44);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n }\n }\n\n function log(uint256 p0, bool p1) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n // Selector of `log(uint256,bool)`.\n mstore(0x00, 0x1c9d7eb3)\n mstore(0x20, p0)\n mstore(0x40, p1)\n }\n _sendLogPayload(0x1c, 0x44);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n }\n }\n\n function log(uint256 p0, uint256 p1) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n // Selector of `log(uint256,uint256)`.\n mstore(0x00, 0xf666715a)\n mstore(0x20, p0)\n mstore(0x40, p1)\n }\n _sendLogPayload(0x1c, 0x44);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n }\n }\n\n function log(uint256 p0, bytes32 p1) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(uint256,string)`.\n mstore(0x00, 0x643fd0df)\n mstore(0x20, p0)\n mstore(0x40, 0x40)\n writeString(0x60, p1)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(bytes32 p0, address p1) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(string,address)`.\n mstore(0x00, 0x319af333)\n mstore(0x20, 0x40)\n mstore(0x40, p1)\n writeString(0x60, p0)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(bytes32 p0, bool p1) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(string,bool)`.\n mstore(0x00, 0xc3b55635)\n mstore(0x20, 0x40)\n mstore(0x40, p1)\n writeString(0x60, p0)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(bytes32 p0, uint256 p1) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(string,uint256)`.\n mstore(0x00, 0xb60e72cc)\n mstore(0x20, 0x40)\n mstore(0x40, p1)\n writeString(0x60, p0)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(bytes32 p0, bytes32 p1) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(string,string)`.\n mstore(0x00, 0x4b5c4277)\n mstore(0x20, 0x40)\n mstore(0x40, 0x80)\n writeString(0x60, p0)\n writeString(0xa0, p1)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(address p0, address p1, address p2) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n // Selector of `log(address,address,address)`.\n mstore(0x00, 0x018c84c2)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n }\n _sendLogPayload(0x1c, 0x64);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n }\n }\n\n function log(address p0, address p1, bool p2) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n // Selector of `log(address,address,bool)`.\n mstore(0x00, 0xf2a66286)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n }\n _sendLogPayload(0x1c, 0x64);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n }\n }\n\n function log(address p0, address p1, uint256 p2) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n // Selector of `log(address,address,uint256)`.\n mstore(0x00, 0x17fe6185)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n }\n _sendLogPayload(0x1c, 0x64);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n }\n }\n\n function log(address p0, address p1, bytes32 p2) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n // Selector of `log(address,address,string)`.\n mstore(0x00, 0x007150be)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, 0x60)\n writeString(0x80, p2)\n }\n _sendLogPayload(0x1c, 0xa4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n }\n }\n\n function log(address p0, bool p1, address p2) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n // Selector of `log(address,bool,address)`.\n mstore(0x00, 0xf11699ed)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n }\n _sendLogPayload(0x1c, 0x64);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n }\n }\n\n function log(address p0, bool p1, bool p2) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n // Selector of `log(address,bool,bool)`.\n mstore(0x00, 0xeb830c92)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n }\n _sendLogPayload(0x1c, 0x64);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n }\n }\n\n function log(address p0, bool p1, uint256 p2) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n // Selector of `log(address,bool,uint256)`.\n mstore(0x00, 0x9c4f99fb)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n }\n _sendLogPayload(0x1c, 0x64);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n }\n }\n\n function log(address p0, bool p1, bytes32 p2) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n // Selector of `log(address,bool,string)`.\n mstore(0x00, 0x212255cc)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, 0x60)\n writeString(0x80, p2)\n }\n _sendLogPayload(0x1c, 0xa4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n }\n }\n\n function log(address p0, uint256 p1, address p2) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n // Selector of `log(address,uint256,address)`.\n mstore(0x00, 0x7bc0d848)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n }\n _sendLogPayload(0x1c, 0x64);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n }\n }\n\n function log(address p0, uint256 p1, bool p2) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n // Selector of `log(address,uint256,bool)`.\n mstore(0x00, 0x678209a8)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n }\n _sendLogPayload(0x1c, 0x64);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n }\n }\n\n function log(address p0, uint256 p1, uint256 p2) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n // Selector of `log(address,uint256,uint256)`.\n mstore(0x00, 0xb69bcaf6)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n }\n _sendLogPayload(0x1c, 0x64);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n }\n }\n\n function log(address p0, uint256 p1, bytes32 p2) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n // Selector of `log(address,uint256,string)`.\n mstore(0x00, 0xa1f2e8aa)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, 0x60)\n writeString(0x80, p2)\n }\n _sendLogPayload(0x1c, 0xa4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n }\n }\n\n function log(address p0, bytes32 p1, address p2) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n // Selector of `log(address,string,address)`.\n mstore(0x00, 0xf08744e8)\n mstore(0x20, p0)\n mstore(0x40, 0x60)\n mstore(0x60, p2)\n writeString(0x80, p1)\n }\n _sendLogPayload(0x1c, 0xa4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n }\n }\n\n function log(address p0, bytes32 p1, bool p2) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n // Selector of `log(address,string,bool)`.\n mstore(0x00, 0xcf020fb1)\n mstore(0x20, p0)\n mstore(0x40, 0x60)\n mstore(0x60, p2)\n writeString(0x80, p1)\n }\n _sendLogPayload(0x1c, 0xa4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n }\n }\n\n function log(address p0, bytes32 p1, uint256 p2) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n // Selector of `log(address,string,uint256)`.\n mstore(0x00, 0x67dd6ff1)\n mstore(0x20, p0)\n mstore(0x40, 0x60)\n mstore(0x60, p2)\n writeString(0x80, p1)\n }\n _sendLogPayload(0x1c, 0xa4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n }\n }\n\n function log(address p0, bytes32 p1, bytes32 p2) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n // Selector of `log(address,string,string)`.\n mstore(0x00, 0xfb772265)\n mstore(0x20, p0)\n mstore(0x40, 0x60)\n mstore(0x60, 0xa0)\n writeString(0x80, p1)\n writeString(0xc0, p2)\n }\n _sendLogPayload(0x1c, 0xe4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n }\n }\n\n function log(bool p0, address p1, address p2) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n // Selector of `log(bool,address,address)`.\n mstore(0x00, 0xd2763667)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n }\n _sendLogPayload(0x1c, 0x64);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n }\n }\n\n function log(bool p0, address p1, bool p2) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n // Selector of `log(bool,address,bool)`.\n mstore(0x00, 0x18c9c746)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n }\n _sendLogPayload(0x1c, 0x64);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n }\n }\n\n function log(bool p0, address p1, uint256 p2) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n // Selector of `log(bool,address,uint256)`.\n mstore(0x00, 0x5f7b9afb)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n }\n _sendLogPayload(0x1c, 0x64);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n }\n }\n\n function log(bool p0, address p1, bytes32 p2) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n // Selector of `log(bool,address,string)`.\n mstore(0x00, 0xde9a9270)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, 0x60)\n writeString(0x80, p2)\n }\n _sendLogPayload(0x1c, 0xa4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n }\n }\n\n function log(bool p0, bool p1, address p2) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n // Selector of `log(bool,bool,address)`.\n mstore(0x00, 0x1078f68d)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n }\n _sendLogPayload(0x1c, 0x64);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n }\n }\n\n function log(bool p0, bool p1, bool p2) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n // Selector of `log(bool,bool,bool)`.\n mstore(0x00, 0x50709698)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n }\n _sendLogPayload(0x1c, 0x64);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n }\n }\n\n function log(bool p0, bool p1, uint256 p2) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n // Selector of `log(bool,bool,uint256)`.\n mstore(0x00, 0x12f21602)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n }\n _sendLogPayload(0x1c, 0x64);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n }\n }\n\n function log(bool p0, bool p1, bytes32 p2) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n // Selector of `log(bool,bool,string)`.\n mstore(0x00, 0x2555fa46)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, 0x60)\n writeString(0x80, p2)\n }\n _sendLogPayload(0x1c, 0xa4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n }\n }\n\n function log(bool p0, uint256 p1, address p2) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n // Selector of `log(bool,uint256,address)`.\n mstore(0x00, 0x088ef9d2)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n }\n _sendLogPayload(0x1c, 0x64);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n }\n }\n\n function log(bool p0, uint256 p1, bool p2) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n // Selector of `log(bool,uint256,bool)`.\n mstore(0x00, 0xe8defba9)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n }\n _sendLogPayload(0x1c, 0x64);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n }\n }\n\n function log(bool p0, uint256 p1, uint256 p2) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n // Selector of `log(bool,uint256,uint256)`.\n mstore(0x00, 0x37103367)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n }\n _sendLogPayload(0x1c, 0x64);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n }\n }\n\n function log(bool p0, uint256 p1, bytes32 p2) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n // Selector of `log(bool,uint256,string)`.\n mstore(0x00, 0xc3fc3970)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, 0x60)\n writeString(0x80, p2)\n }\n _sendLogPayload(0x1c, 0xa4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n }\n }\n\n function log(bool p0, bytes32 p1, address p2) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n // Selector of `log(bool,string,address)`.\n mstore(0x00, 0x9591b953)\n mstore(0x20, p0)\n mstore(0x40, 0x60)\n mstore(0x60, p2)\n writeString(0x80, p1)\n }\n _sendLogPayload(0x1c, 0xa4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n }\n }\n\n function log(bool p0, bytes32 p1, bool p2) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n // Selector of `log(bool,string,bool)`.\n mstore(0x00, 0xdbb4c247)\n mstore(0x20, p0)\n mstore(0x40, 0x60)\n mstore(0x60, p2)\n writeString(0x80, p1)\n }\n _sendLogPayload(0x1c, 0xa4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n }\n }\n\n function log(bool p0, bytes32 p1, uint256 p2) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n // Selector of `log(bool,string,uint256)`.\n mstore(0x00, 0x1093ee11)\n mstore(0x20, p0)\n mstore(0x40, 0x60)\n mstore(0x60, p2)\n writeString(0x80, p1)\n }\n _sendLogPayload(0x1c, 0xa4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n }\n }\n\n function log(bool p0, bytes32 p1, bytes32 p2) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n // Selector of `log(bool,string,string)`.\n mstore(0x00, 0xb076847f)\n mstore(0x20, p0)\n mstore(0x40, 0x60)\n mstore(0x60, 0xa0)\n writeString(0x80, p1)\n writeString(0xc0, p2)\n }\n _sendLogPayload(0x1c, 0xe4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n }\n }\n\n function log(uint256 p0, address p1, address p2) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n // Selector of `log(uint256,address,address)`.\n mstore(0x00, 0xbcfd9be0)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n }\n _sendLogPayload(0x1c, 0x64);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n }\n }\n\n function log(uint256 p0, address p1, bool p2) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n // Selector of `log(uint256,address,bool)`.\n mstore(0x00, 0x9b6ec042)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n }\n _sendLogPayload(0x1c, 0x64);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n }\n }\n\n function log(uint256 p0, address p1, uint256 p2) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n // Selector of `log(uint256,address,uint256)`.\n mstore(0x00, 0x5a9b5ed5)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n }\n _sendLogPayload(0x1c, 0x64);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n }\n }\n\n function log(uint256 p0, address p1, bytes32 p2) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n // Selector of `log(uint256,address,string)`.\n mstore(0x00, 0x63cb41f9)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, 0x60)\n writeString(0x80, p2)\n }\n _sendLogPayload(0x1c, 0xa4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n }\n }\n\n function log(uint256 p0, bool p1, address p2) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n // Selector of `log(uint256,bool,address)`.\n mstore(0x00, 0x35085f7b)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n }\n _sendLogPayload(0x1c, 0x64);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n }\n }\n\n function log(uint256 p0, bool p1, bool p2) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n // Selector of `log(uint256,bool,bool)`.\n mstore(0x00, 0x20718650)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n }\n _sendLogPayload(0x1c, 0x64);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n }\n }\n\n function log(uint256 p0, bool p1, uint256 p2) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n // Selector of `log(uint256,bool,uint256)`.\n mstore(0x00, 0x20098014)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n }\n _sendLogPayload(0x1c, 0x64);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n }\n }\n\n function log(uint256 p0, bool p1, bytes32 p2) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n // Selector of `log(uint256,bool,string)`.\n mstore(0x00, 0x85775021)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, 0x60)\n writeString(0x80, p2)\n }\n _sendLogPayload(0x1c, 0xa4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n }\n }\n\n function log(uint256 p0, uint256 p1, address p2) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n // Selector of `log(uint256,uint256,address)`.\n mstore(0x00, 0x5c96b331)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n }\n _sendLogPayload(0x1c, 0x64);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n }\n }\n\n function log(uint256 p0, uint256 p1, bool p2) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n // Selector of `log(uint256,uint256,bool)`.\n mstore(0x00, 0x4766da72)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n }\n _sendLogPayload(0x1c, 0x64);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n }\n }\n\n function log(uint256 p0, uint256 p1, uint256 p2) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n // Selector of `log(uint256,uint256,uint256)`.\n mstore(0x00, 0xd1ed7a3c)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n }\n _sendLogPayload(0x1c, 0x64);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n }\n }\n\n function log(uint256 p0, uint256 p1, bytes32 p2) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n // Selector of `log(uint256,uint256,string)`.\n mstore(0x00, 0x71d04af2)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, 0x60)\n writeString(0x80, p2)\n }\n _sendLogPayload(0x1c, 0xa4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n }\n }\n\n function log(uint256 p0, bytes32 p1, address p2) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n // Selector of `log(uint256,string,address)`.\n mstore(0x00, 0x7afac959)\n mstore(0x20, p0)\n mstore(0x40, 0x60)\n mstore(0x60, p2)\n writeString(0x80, p1)\n }\n _sendLogPayload(0x1c, 0xa4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n }\n }\n\n function log(uint256 p0, bytes32 p1, bool p2) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n // Selector of `log(uint256,string,bool)`.\n mstore(0x00, 0x4ceda75a)\n mstore(0x20, p0)\n mstore(0x40, 0x60)\n mstore(0x60, p2)\n writeString(0x80, p1)\n }\n _sendLogPayload(0x1c, 0xa4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n }\n }\n\n function log(uint256 p0, bytes32 p1, uint256 p2) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n // Selector of `log(uint256,string,uint256)`.\n mstore(0x00, 0x37aa7d4c)\n mstore(0x20, p0)\n mstore(0x40, 0x60)\n mstore(0x60, p2)\n writeString(0x80, p1)\n }\n _sendLogPayload(0x1c, 0xa4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n }\n }\n\n function log(uint256 p0, bytes32 p1, bytes32 p2) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n // Selector of `log(uint256,string,string)`.\n mstore(0x00, 0xb115611f)\n mstore(0x20, p0)\n mstore(0x40, 0x60)\n mstore(0x60, 0xa0)\n writeString(0x80, p1)\n writeString(0xc0, p2)\n }\n _sendLogPayload(0x1c, 0xe4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n }\n }\n\n function log(bytes32 p0, address p1, address p2) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n // Selector of `log(string,address,address)`.\n mstore(0x00, 0xfcec75e0)\n mstore(0x20, 0x60)\n mstore(0x40, p1)\n mstore(0x60, p2)\n writeString(0x80, p0)\n }\n _sendLogPayload(0x1c, 0xa4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n }\n }\n\n function log(bytes32 p0, address p1, bool p2) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n // Selector of `log(string,address,bool)`.\n mstore(0x00, 0xc91d5ed4)\n mstore(0x20, 0x60)\n mstore(0x40, p1)\n mstore(0x60, p2)\n writeString(0x80, p0)\n }\n _sendLogPayload(0x1c, 0xa4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n }\n }\n\n function log(bytes32 p0, address p1, uint256 p2) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n // Selector of `log(string,address,uint256)`.\n mstore(0x00, 0x0d26b925)\n mstore(0x20, 0x60)\n mstore(0x40, p1)\n mstore(0x60, p2)\n writeString(0x80, p0)\n }\n _sendLogPayload(0x1c, 0xa4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n }\n }\n\n function log(bytes32 p0, address p1, bytes32 p2) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n // Selector of `log(string,address,string)`.\n mstore(0x00, 0xe0e9ad4f)\n mstore(0x20, 0x60)\n mstore(0x40, p1)\n mstore(0x60, 0xa0)\n writeString(0x80, p0)\n writeString(0xc0, p2)\n }\n _sendLogPayload(0x1c, 0xe4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n }\n }\n\n function log(bytes32 p0, bool p1, address p2) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n // Selector of `log(string,bool,address)`.\n mstore(0x00, 0x932bbb38)\n mstore(0x20, 0x60)\n mstore(0x40, p1)\n mstore(0x60, p2)\n writeString(0x80, p0)\n }\n _sendLogPayload(0x1c, 0xa4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n }\n }\n\n function log(bytes32 p0, bool p1, bool p2) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n // Selector of `log(string,bool,bool)`.\n mstore(0x00, 0x850b7ad6)\n mstore(0x20, 0x60)\n mstore(0x40, p1)\n mstore(0x60, p2)\n writeString(0x80, p0)\n }\n _sendLogPayload(0x1c, 0xa4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n }\n }\n\n function log(bytes32 p0, bool p1, uint256 p2) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n // Selector of `log(string,bool,uint256)`.\n mstore(0x00, 0xc95958d6)\n mstore(0x20, 0x60)\n mstore(0x40, p1)\n mstore(0x60, p2)\n writeString(0x80, p0)\n }\n _sendLogPayload(0x1c, 0xa4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n }\n }\n\n function log(bytes32 p0, bool p1, bytes32 p2) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n // Selector of `log(string,bool,string)`.\n mstore(0x00, 0xe298f47d)\n mstore(0x20, 0x60)\n mstore(0x40, p1)\n mstore(0x60, 0xa0)\n writeString(0x80, p0)\n writeString(0xc0, p2)\n }\n _sendLogPayload(0x1c, 0xe4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n }\n }\n\n function log(bytes32 p0, uint256 p1, address p2) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n // Selector of `log(string,uint256,address)`.\n mstore(0x00, 0x1c7ec448)\n mstore(0x20, 0x60)\n mstore(0x40, p1)\n mstore(0x60, p2)\n writeString(0x80, p0)\n }\n _sendLogPayload(0x1c, 0xa4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n }\n }\n\n function log(bytes32 p0, uint256 p1, bool p2) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n // Selector of `log(string,uint256,bool)`.\n mstore(0x00, 0xca7733b1)\n mstore(0x20, 0x60)\n mstore(0x40, p1)\n mstore(0x60, p2)\n writeString(0x80, p0)\n }\n _sendLogPayload(0x1c, 0xa4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n }\n }\n\n function log(bytes32 p0, uint256 p1, uint256 p2) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n // Selector of `log(string,uint256,uint256)`.\n mstore(0x00, 0xca47c4eb)\n mstore(0x20, 0x60)\n mstore(0x40, p1)\n mstore(0x60, p2)\n writeString(0x80, p0)\n }\n _sendLogPayload(0x1c, 0xa4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n }\n }\n\n function log(bytes32 p0, uint256 p1, bytes32 p2) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n // Selector of `log(string,uint256,string)`.\n mstore(0x00, 0x5970e089)\n mstore(0x20, 0x60)\n mstore(0x40, p1)\n mstore(0x60, 0xa0)\n writeString(0x80, p0)\n writeString(0xc0, p2)\n }\n _sendLogPayload(0x1c, 0xe4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n }\n }\n\n function log(bytes32 p0, bytes32 p1, address p2) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n // Selector of `log(string,string,address)`.\n mstore(0x00, 0x95ed0195)\n mstore(0x20, 0x60)\n mstore(0x40, 0xa0)\n mstore(0x60, p2)\n writeString(0x80, p0)\n writeString(0xc0, p1)\n }\n _sendLogPayload(0x1c, 0xe4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n }\n }\n\n function log(bytes32 p0, bytes32 p1, bool p2) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n // Selector of `log(string,string,bool)`.\n mstore(0x00, 0xb0e0f9b5)\n mstore(0x20, 0x60)\n mstore(0x40, 0xa0)\n mstore(0x60, p2)\n writeString(0x80, p0)\n writeString(0xc0, p1)\n }\n _sendLogPayload(0x1c, 0xe4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n }\n }\n\n function log(bytes32 p0, bytes32 p1, uint256 p2) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n // Selector of `log(string,string,uint256)`.\n mstore(0x00, 0x5821efa1)\n mstore(0x20, 0x60)\n mstore(0x40, 0xa0)\n mstore(0x60, p2)\n writeString(0x80, p0)\n writeString(0xc0, p1)\n }\n _sendLogPayload(0x1c, 0xe4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n }\n }\n\n function log(bytes32 p0, bytes32 p1, bytes32 p2) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n bytes32 m9;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n m9 := mload(0x120)\n // Selector of `log(string,string,string)`.\n mstore(0x00, 0x2ced7cef)\n mstore(0x20, 0x60)\n mstore(0x40, 0xa0)\n mstore(0x60, 0xe0)\n writeString(0x80, p0)\n writeString(0xc0, p1)\n writeString(0x100, p2)\n }\n _sendLogPayload(0x1c, 0x124);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n mstore(0x120, m9)\n }\n }\n\n function log(address p0, address p1, address p2, address p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(address,address,address,address)`.\n mstore(0x00, 0x665bf134)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(address p0, address p1, address p2, bool p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(address,address,address,bool)`.\n mstore(0x00, 0x0e378994)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(address p0, address p1, address p2, uint256 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(address,address,address,uint256)`.\n mstore(0x00, 0x94250d77)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(address p0, address p1, address p2, bytes32 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(address,address,address,string)`.\n mstore(0x00, 0xf808da20)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, 0x80)\n writeString(0xa0, p3)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(address p0, address p1, bool p2, address p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(address,address,bool,address)`.\n mstore(0x00, 0x9f1bc36e)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(address p0, address p1, bool p2, bool p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(address,address,bool,bool)`.\n mstore(0x00, 0x2cd4134a)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(address p0, address p1, bool p2, uint256 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(address,address,bool,uint256)`.\n mstore(0x00, 0x3971e78c)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(address p0, address p1, bool p2, bytes32 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(address,address,bool,string)`.\n mstore(0x00, 0xaa6540c8)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, 0x80)\n writeString(0xa0, p3)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(address p0, address p1, uint256 p2, address p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(address,address,uint256,address)`.\n mstore(0x00, 0x8da6def5)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(address p0, address p1, uint256 p2, bool p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(address,address,uint256,bool)`.\n mstore(0x00, 0x9b4254e2)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(address p0, address p1, uint256 p2, uint256 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(address,address,uint256,uint256)`.\n mstore(0x00, 0xbe553481)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(address p0, address p1, uint256 p2, bytes32 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(address,address,uint256,string)`.\n mstore(0x00, 0xfdb4f990)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, 0x80)\n writeString(0xa0, p3)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(address p0, address p1, bytes32 p2, address p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(address,address,string,address)`.\n mstore(0x00, 0x8f736d16)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, 0x80)\n mstore(0x80, p3)\n writeString(0xa0, p2)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(address p0, address p1, bytes32 p2, bool p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(address,address,string,bool)`.\n mstore(0x00, 0x6f1a594e)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, 0x80)\n mstore(0x80, p3)\n writeString(0xa0, p2)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(address p0, address p1, bytes32 p2, uint256 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(address,address,string,uint256)`.\n mstore(0x00, 0xef1cefe7)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, 0x80)\n mstore(0x80, p3)\n writeString(0xa0, p2)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(address p0, address p1, bytes32 p2, bytes32 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n // Selector of `log(address,address,string,string)`.\n mstore(0x00, 0x21bdaf25)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, 0x80)\n mstore(0x80, 0xc0)\n writeString(0xa0, p2)\n writeString(0xe0, p3)\n }\n _sendLogPayload(0x1c, 0x104);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n }\n }\n\n function log(address p0, bool p1, address p2, address p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(address,bool,address,address)`.\n mstore(0x00, 0x660375dd)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(address p0, bool p1, address p2, bool p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(address,bool,address,bool)`.\n mstore(0x00, 0xa6f50b0f)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(address p0, bool p1, address p2, uint256 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(address,bool,address,uint256)`.\n mstore(0x00, 0xa75c59de)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(address p0, bool p1, address p2, bytes32 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(address,bool,address,string)`.\n mstore(0x00, 0x2dd778e6)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, 0x80)\n writeString(0xa0, p3)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(address p0, bool p1, bool p2, address p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(address,bool,bool,address)`.\n mstore(0x00, 0xcf394485)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(address p0, bool p1, bool p2, bool p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(address,bool,bool,bool)`.\n mstore(0x00, 0xcac43479)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(address p0, bool p1, bool p2, uint256 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(address,bool,bool,uint256)`.\n mstore(0x00, 0x8c4e5de6)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(address p0, bool p1, bool p2, bytes32 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(address,bool,bool,string)`.\n mstore(0x00, 0xdfc4a2e8)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, 0x80)\n writeString(0xa0, p3)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(address p0, bool p1, uint256 p2, address p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(address,bool,uint256,address)`.\n mstore(0x00, 0xccf790a1)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(address p0, bool p1, uint256 p2, bool p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(address,bool,uint256,bool)`.\n mstore(0x00, 0xc4643e20)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(address p0, bool p1, uint256 p2, uint256 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(address,bool,uint256,uint256)`.\n mstore(0x00, 0x386ff5f4)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(address p0, bool p1, uint256 p2, bytes32 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(address,bool,uint256,string)`.\n mstore(0x00, 0x0aa6cfad)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, 0x80)\n writeString(0xa0, p3)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(address p0, bool p1, bytes32 p2, address p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(address,bool,string,address)`.\n mstore(0x00, 0x19fd4956)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, 0x80)\n mstore(0x80, p3)\n writeString(0xa0, p2)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(address p0, bool p1, bytes32 p2, bool p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(address,bool,string,bool)`.\n mstore(0x00, 0x50ad461d)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, 0x80)\n mstore(0x80, p3)\n writeString(0xa0, p2)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(address p0, bool p1, bytes32 p2, uint256 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(address,bool,string,uint256)`.\n mstore(0x00, 0x80e6a20b)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, 0x80)\n mstore(0x80, p3)\n writeString(0xa0, p2)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(address p0, bool p1, bytes32 p2, bytes32 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n // Selector of `log(address,bool,string,string)`.\n mstore(0x00, 0x475c5c33)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, 0x80)\n mstore(0x80, 0xc0)\n writeString(0xa0, p2)\n writeString(0xe0, p3)\n }\n _sendLogPayload(0x1c, 0x104);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n }\n }\n\n function log(address p0, uint256 p1, address p2, address p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(address,uint256,address,address)`.\n mstore(0x00, 0x478d1c62)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(address p0, uint256 p1, address p2, bool p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(address,uint256,address,bool)`.\n mstore(0x00, 0xa1bcc9b3)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(address p0, uint256 p1, address p2, uint256 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(address,uint256,address,uint256)`.\n mstore(0x00, 0x100f650e)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(address p0, uint256 p1, address p2, bytes32 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(address,uint256,address,string)`.\n mstore(0x00, 0x1da986ea)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, 0x80)\n writeString(0xa0, p3)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(address p0, uint256 p1, bool p2, address p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(address,uint256,bool,address)`.\n mstore(0x00, 0xa31bfdcc)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(address p0, uint256 p1, bool p2, bool p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(address,uint256,bool,bool)`.\n mstore(0x00, 0x3bf5e537)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(address p0, uint256 p1, bool p2, uint256 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(address,uint256,bool,uint256)`.\n mstore(0x00, 0x22f6b999)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(address p0, uint256 p1, bool p2, bytes32 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(address,uint256,bool,string)`.\n mstore(0x00, 0xc5ad85f9)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, 0x80)\n writeString(0xa0, p3)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(address p0, uint256 p1, uint256 p2, address p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(address,uint256,uint256,address)`.\n mstore(0x00, 0x20e3984d)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(address p0, uint256 p1, uint256 p2, bool p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(address,uint256,uint256,bool)`.\n mstore(0x00, 0x66f1bc67)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(address p0, uint256 p1, uint256 p2, uint256 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(address,uint256,uint256,uint256)`.\n mstore(0x00, 0x34f0e636)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(address p0, uint256 p1, uint256 p2, bytes32 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(address,uint256,uint256,string)`.\n mstore(0x00, 0x4a28c017)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, 0x80)\n writeString(0xa0, p3)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(address p0, uint256 p1, bytes32 p2, address p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(address,uint256,string,address)`.\n mstore(0x00, 0x5c430d47)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, 0x80)\n mstore(0x80, p3)\n writeString(0xa0, p2)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(address p0, uint256 p1, bytes32 p2, bool p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(address,uint256,string,bool)`.\n mstore(0x00, 0xcf18105c)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, 0x80)\n mstore(0x80, p3)\n writeString(0xa0, p2)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(address p0, uint256 p1, bytes32 p2, uint256 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(address,uint256,string,uint256)`.\n mstore(0x00, 0xbf01f891)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, 0x80)\n mstore(0x80, p3)\n writeString(0xa0, p2)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(address p0, uint256 p1, bytes32 p2, bytes32 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n // Selector of `log(address,uint256,string,string)`.\n mstore(0x00, 0x88a8c406)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, 0x80)\n mstore(0x80, 0xc0)\n writeString(0xa0, p2)\n writeString(0xe0, p3)\n }\n _sendLogPayload(0x1c, 0x104);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n }\n }\n\n function log(address p0, bytes32 p1, address p2, address p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(address,string,address,address)`.\n mstore(0x00, 0x0d36fa20)\n mstore(0x20, p0)\n mstore(0x40, 0x80)\n mstore(0x60, p2)\n mstore(0x80, p3)\n writeString(0xa0, p1)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(address p0, bytes32 p1, address p2, bool p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(address,string,address,bool)`.\n mstore(0x00, 0x0df12b76)\n mstore(0x20, p0)\n mstore(0x40, 0x80)\n mstore(0x60, p2)\n mstore(0x80, p3)\n writeString(0xa0, p1)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(address p0, bytes32 p1, address p2, uint256 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(address,string,address,uint256)`.\n mstore(0x00, 0x457fe3cf)\n mstore(0x20, p0)\n mstore(0x40, 0x80)\n mstore(0x60, p2)\n mstore(0x80, p3)\n writeString(0xa0, p1)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(address p0, bytes32 p1, address p2, bytes32 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n // Selector of `log(address,string,address,string)`.\n mstore(0x00, 0xf7e36245)\n mstore(0x20, p0)\n mstore(0x40, 0x80)\n mstore(0x60, p2)\n mstore(0x80, 0xc0)\n writeString(0xa0, p1)\n writeString(0xe0, p3)\n }\n _sendLogPayload(0x1c, 0x104);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n }\n }\n\n function log(address p0, bytes32 p1, bool p2, address p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(address,string,bool,address)`.\n mstore(0x00, 0x205871c2)\n mstore(0x20, p0)\n mstore(0x40, 0x80)\n mstore(0x60, p2)\n mstore(0x80, p3)\n writeString(0xa0, p1)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(address p0, bytes32 p1, bool p2, bool p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(address,string,bool,bool)`.\n mstore(0x00, 0x5f1d5c9f)\n mstore(0x20, p0)\n mstore(0x40, 0x80)\n mstore(0x60, p2)\n mstore(0x80, p3)\n writeString(0xa0, p1)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(address p0, bytes32 p1, bool p2, uint256 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(address,string,bool,uint256)`.\n mstore(0x00, 0x515e38b6)\n mstore(0x20, p0)\n mstore(0x40, 0x80)\n mstore(0x60, p2)\n mstore(0x80, p3)\n writeString(0xa0, p1)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(address p0, bytes32 p1, bool p2, bytes32 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n // Selector of `log(address,string,bool,string)`.\n mstore(0x00, 0xbc0b61fe)\n mstore(0x20, p0)\n mstore(0x40, 0x80)\n mstore(0x60, p2)\n mstore(0x80, 0xc0)\n writeString(0xa0, p1)\n writeString(0xe0, p3)\n }\n _sendLogPayload(0x1c, 0x104);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n }\n }\n\n function log(address p0, bytes32 p1, uint256 p2, address p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(address,string,uint256,address)`.\n mstore(0x00, 0x63183678)\n mstore(0x20, p0)\n mstore(0x40, 0x80)\n mstore(0x60, p2)\n mstore(0x80, p3)\n writeString(0xa0, p1)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(address p0, bytes32 p1, uint256 p2, bool p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(address,string,uint256,bool)`.\n mstore(0x00, 0x0ef7e050)\n mstore(0x20, p0)\n mstore(0x40, 0x80)\n mstore(0x60, p2)\n mstore(0x80, p3)\n writeString(0xa0, p1)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(address p0, bytes32 p1, uint256 p2, uint256 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(address,string,uint256,uint256)`.\n mstore(0x00, 0x1dc8e1b8)\n mstore(0x20, p0)\n mstore(0x40, 0x80)\n mstore(0x60, p2)\n mstore(0x80, p3)\n writeString(0xa0, p1)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(address p0, bytes32 p1, uint256 p2, bytes32 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n // Selector of `log(address,string,uint256,string)`.\n mstore(0x00, 0x448830a8)\n mstore(0x20, p0)\n mstore(0x40, 0x80)\n mstore(0x60, p2)\n mstore(0x80, 0xc0)\n writeString(0xa0, p1)\n writeString(0xe0, p3)\n }\n _sendLogPayload(0x1c, 0x104);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n }\n }\n\n function log(address p0, bytes32 p1, bytes32 p2, address p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n // Selector of `log(address,string,string,address)`.\n mstore(0x00, 0xa04e2f87)\n mstore(0x20, p0)\n mstore(0x40, 0x80)\n mstore(0x60, 0xc0)\n mstore(0x80, p3)\n writeString(0xa0, p1)\n writeString(0xe0, p2)\n }\n _sendLogPayload(0x1c, 0x104);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n }\n }\n\n function log(address p0, bytes32 p1, bytes32 p2, bool p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n // Selector of `log(address,string,string,bool)`.\n mstore(0x00, 0x35a5071f)\n mstore(0x20, p0)\n mstore(0x40, 0x80)\n mstore(0x60, 0xc0)\n mstore(0x80, p3)\n writeString(0xa0, p1)\n writeString(0xe0, p2)\n }\n _sendLogPayload(0x1c, 0x104);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n }\n }\n\n function log(address p0, bytes32 p1, bytes32 p2, uint256 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n // Selector of `log(address,string,string,uint256)`.\n mstore(0x00, 0x159f8927)\n mstore(0x20, p0)\n mstore(0x40, 0x80)\n mstore(0x60, 0xc0)\n mstore(0x80, p3)\n writeString(0xa0, p1)\n writeString(0xe0, p2)\n }\n _sendLogPayload(0x1c, 0x104);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n }\n }\n\n function log(address p0, bytes32 p1, bytes32 p2, bytes32 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n bytes32 m9;\n bytes32 m10;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n m9 := mload(0x120)\n m10 := mload(0x140)\n // Selector of `log(address,string,string,string)`.\n mstore(0x00, 0x5d02c50b)\n mstore(0x20, p0)\n mstore(0x40, 0x80)\n mstore(0x60, 0xc0)\n mstore(0x80, 0x100)\n writeString(0xa0, p1)\n writeString(0xe0, p2)\n writeString(0x120, p3)\n }\n _sendLogPayload(0x1c, 0x144);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n mstore(0x120, m9)\n mstore(0x140, m10)\n }\n }\n\n function log(bool p0, address p1, address p2, address p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(bool,address,address,address)`.\n mstore(0x00, 0x1d14d001)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(bool p0, address p1, address p2, bool p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(bool,address,address,bool)`.\n mstore(0x00, 0x46600be0)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(bool p0, address p1, address p2, uint256 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(bool,address,address,uint256)`.\n mstore(0x00, 0x0c66d1be)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(bool p0, address p1, address p2, bytes32 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(bool,address,address,string)`.\n mstore(0x00, 0xd812a167)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, 0x80)\n writeString(0xa0, p3)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(bool p0, address p1, bool p2, address p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(bool,address,bool,address)`.\n mstore(0x00, 0x1c41a336)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(bool p0, address p1, bool p2, bool p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(bool,address,bool,bool)`.\n mstore(0x00, 0x6a9c478b)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(bool p0, address p1, bool p2, uint256 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(bool,address,bool,uint256)`.\n mstore(0x00, 0x07831502)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(bool p0, address p1, bool p2, bytes32 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(bool,address,bool,string)`.\n mstore(0x00, 0x4a66cb34)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, 0x80)\n writeString(0xa0, p3)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(bool p0, address p1, uint256 p2, address p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(bool,address,uint256,address)`.\n mstore(0x00, 0x136b05dd)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(bool p0, address p1, uint256 p2, bool p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(bool,address,uint256,bool)`.\n mstore(0x00, 0xd6019f1c)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(bool p0, address p1, uint256 p2, uint256 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(bool,address,uint256,uint256)`.\n mstore(0x00, 0x7bf181a1)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(bool p0, address p1, uint256 p2, bytes32 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(bool,address,uint256,string)`.\n mstore(0x00, 0x51f09ff8)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, 0x80)\n writeString(0xa0, p3)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(bool p0, address p1, bytes32 p2, address p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(bool,address,string,address)`.\n mstore(0x00, 0x6f7c603e)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, 0x80)\n mstore(0x80, p3)\n writeString(0xa0, p2)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(bool p0, address p1, bytes32 p2, bool p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(bool,address,string,bool)`.\n mstore(0x00, 0xe2bfd60b)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, 0x80)\n mstore(0x80, p3)\n writeString(0xa0, p2)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(bool p0, address p1, bytes32 p2, uint256 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(bool,address,string,uint256)`.\n mstore(0x00, 0xc21f64c7)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, 0x80)\n mstore(0x80, p3)\n writeString(0xa0, p2)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(bool p0, address p1, bytes32 p2, bytes32 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n // Selector of `log(bool,address,string,string)`.\n mstore(0x00, 0xa73c1db6)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, 0x80)\n mstore(0x80, 0xc0)\n writeString(0xa0, p2)\n writeString(0xe0, p3)\n }\n _sendLogPayload(0x1c, 0x104);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n }\n }\n\n function log(bool p0, bool p1, address p2, address p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(bool,bool,address,address)`.\n mstore(0x00, 0xf4880ea4)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(bool p0, bool p1, address p2, bool p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(bool,bool,address,bool)`.\n mstore(0x00, 0xc0a302d8)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(bool p0, bool p1, address p2, uint256 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(bool,bool,address,uint256)`.\n mstore(0x00, 0x4c123d57)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(bool p0, bool p1, address p2, bytes32 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(bool,bool,address,string)`.\n mstore(0x00, 0xa0a47963)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, 0x80)\n writeString(0xa0, p3)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(bool p0, bool p1, bool p2, address p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(bool,bool,bool,address)`.\n mstore(0x00, 0x8c329b1a)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(bool p0, bool p1, bool p2, bool p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(bool,bool,bool,bool)`.\n mstore(0x00, 0x3b2a5ce0)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(bool p0, bool p1, bool p2, uint256 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(bool,bool,bool,uint256)`.\n mstore(0x00, 0x6d7045c1)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(bool p0, bool p1, bool p2, bytes32 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(bool,bool,bool,string)`.\n mstore(0x00, 0x2ae408d4)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, 0x80)\n writeString(0xa0, p3)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(bool p0, bool p1, uint256 p2, address p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(bool,bool,uint256,address)`.\n mstore(0x00, 0x54a7a9a0)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(bool p0, bool p1, uint256 p2, bool p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(bool,bool,uint256,bool)`.\n mstore(0x00, 0x619e4d0e)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(bool p0, bool p1, uint256 p2, uint256 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(bool,bool,uint256,uint256)`.\n mstore(0x00, 0x0bb00eab)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(bool p0, bool p1, uint256 p2, bytes32 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(bool,bool,uint256,string)`.\n mstore(0x00, 0x7dd4d0e0)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, 0x80)\n writeString(0xa0, p3)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(bool p0, bool p1, bytes32 p2, address p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(bool,bool,string,address)`.\n mstore(0x00, 0xf9ad2b89)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, 0x80)\n mstore(0x80, p3)\n writeString(0xa0, p2)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(bool p0, bool p1, bytes32 p2, bool p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(bool,bool,string,bool)`.\n mstore(0x00, 0xb857163a)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, 0x80)\n mstore(0x80, p3)\n writeString(0xa0, p2)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(bool p0, bool p1, bytes32 p2, uint256 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(bool,bool,string,uint256)`.\n mstore(0x00, 0xe3a9ca2f)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, 0x80)\n mstore(0x80, p3)\n writeString(0xa0, p2)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(bool p0, bool p1, bytes32 p2, bytes32 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n // Selector of `log(bool,bool,string,string)`.\n mstore(0x00, 0x6d1e8751)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, 0x80)\n mstore(0x80, 0xc0)\n writeString(0xa0, p2)\n writeString(0xe0, p3)\n }\n _sendLogPayload(0x1c, 0x104);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n }\n }\n\n function log(bool p0, uint256 p1, address p2, address p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(bool,uint256,address,address)`.\n mstore(0x00, 0x26f560a8)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(bool p0, uint256 p1, address p2, bool p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(bool,uint256,address,bool)`.\n mstore(0x00, 0xb4c314ff)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(bool p0, uint256 p1, address p2, uint256 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(bool,uint256,address,uint256)`.\n mstore(0x00, 0x1537dc87)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(bool p0, uint256 p1, address p2, bytes32 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(bool,uint256,address,string)`.\n mstore(0x00, 0x1bb3b09a)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, 0x80)\n writeString(0xa0, p3)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(bool p0, uint256 p1, bool p2, address p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(bool,uint256,bool,address)`.\n mstore(0x00, 0x9acd3616)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(bool p0, uint256 p1, bool p2, bool p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(bool,uint256,bool,bool)`.\n mstore(0x00, 0xceb5f4d7)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(bool p0, uint256 p1, bool p2, uint256 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(bool,uint256,bool,uint256)`.\n mstore(0x00, 0x7f9bbca2)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(bool p0, uint256 p1, bool p2, bytes32 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(bool,uint256,bool,string)`.\n mstore(0x00, 0x9143dbb1)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, 0x80)\n writeString(0xa0, p3)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(bool p0, uint256 p1, uint256 p2, address p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(bool,uint256,uint256,address)`.\n mstore(0x00, 0x00dd87b9)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(bool p0, uint256 p1, uint256 p2, bool p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(bool,uint256,uint256,bool)`.\n mstore(0x00, 0xbe984353)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(bool p0, uint256 p1, uint256 p2, uint256 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(bool,uint256,uint256,uint256)`.\n mstore(0x00, 0x374bb4b2)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(bool p0, uint256 p1, uint256 p2, bytes32 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(bool,uint256,uint256,string)`.\n mstore(0x00, 0x8e69fb5d)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, 0x80)\n writeString(0xa0, p3)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(bool p0, uint256 p1, bytes32 p2, address p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(bool,uint256,string,address)`.\n mstore(0x00, 0xfedd1fff)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, 0x80)\n mstore(0x80, p3)\n writeString(0xa0, p2)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(bool p0, uint256 p1, bytes32 p2, bool p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(bool,uint256,string,bool)`.\n mstore(0x00, 0xe5e70b2b)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, 0x80)\n mstore(0x80, p3)\n writeString(0xa0, p2)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(bool p0, uint256 p1, bytes32 p2, uint256 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(bool,uint256,string,uint256)`.\n mstore(0x00, 0x6a1199e2)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, 0x80)\n mstore(0x80, p3)\n writeString(0xa0, p2)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(bool p0, uint256 p1, bytes32 p2, bytes32 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n // Selector of `log(bool,uint256,string,string)`.\n mstore(0x00, 0xf5bc2249)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, 0x80)\n mstore(0x80, 0xc0)\n writeString(0xa0, p2)\n writeString(0xe0, p3)\n }\n _sendLogPayload(0x1c, 0x104);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n }\n }\n\n function log(bool p0, bytes32 p1, address p2, address p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(bool,string,address,address)`.\n mstore(0x00, 0x2b2b18dc)\n mstore(0x20, p0)\n mstore(0x40, 0x80)\n mstore(0x60, p2)\n mstore(0x80, p3)\n writeString(0xa0, p1)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(bool p0, bytes32 p1, address p2, bool p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(bool,string,address,bool)`.\n mstore(0x00, 0x6dd434ca)\n mstore(0x20, p0)\n mstore(0x40, 0x80)\n mstore(0x60, p2)\n mstore(0x80, p3)\n writeString(0xa0, p1)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(bool p0, bytes32 p1, address p2, uint256 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(bool,string,address,uint256)`.\n mstore(0x00, 0xa5cada94)\n mstore(0x20, p0)\n mstore(0x40, 0x80)\n mstore(0x60, p2)\n mstore(0x80, p3)\n writeString(0xa0, p1)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(bool p0, bytes32 p1, address p2, bytes32 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n // Selector of `log(bool,string,address,string)`.\n mstore(0x00, 0x12d6c788)\n mstore(0x20, p0)\n mstore(0x40, 0x80)\n mstore(0x60, p2)\n mstore(0x80, 0xc0)\n writeString(0xa0, p1)\n writeString(0xe0, p3)\n }\n _sendLogPayload(0x1c, 0x104);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n }\n }\n\n function log(bool p0, bytes32 p1, bool p2, address p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(bool,string,bool,address)`.\n mstore(0x00, 0x538e06ab)\n mstore(0x20, p0)\n mstore(0x40, 0x80)\n mstore(0x60, p2)\n mstore(0x80, p3)\n writeString(0xa0, p1)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(bool p0, bytes32 p1, bool p2, bool p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(bool,string,bool,bool)`.\n mstore(0x00, 0xdc5e935b)\n mstore(0x20, p0)\n mstore(0x40, 0x80)\n mstore(0x60, p2)\n mstore(0x80, p3)\n writeString(0xa0, p1)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(bool p0, bytes32 p1, bool p2, uint256 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(bool,string,bool,uint256)`.\n mstore(0x00, 0x1606a393)\n mstore(0x20, p0)\n mstore(0x40, 0x80)\n mstore(0x60, p2)\n mstore(0x80, p3)\n writeString(0xa0, p1)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(bool p0, bytes32 p1, bool p2, bytes32 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n // Selector of `log(bool,string,bool,string)`.\n mstore(0x00, 0x483d0416)\n mstore(0x20, p0)\n mstore(0x40, 0x80)\n mstore(0x60, p2)\n mstore(0x80, 0xc0)\n writeString(0xa0, p1)\n writeString(0xe0, p3)\n }\n _sendLogPayload(0x1c, 0x104);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n }\n }\n\n function log(bool p0, bytes32 p1, uint256 p2, address p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(bool,string,uint256,address)`.\n mstore(0x00, 0x1596a1ce)\n mstore(0x20, p0)\n mstore(0x40, 0x80)\n mstore(0x60, p2)\n mstore(0x80, p3)\n writeString(0xa0, p1)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(bool p0, bytes32 p1, uint256 p2, bool p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(bool,string,uint256,bool)`.\n mstore(0x00, 0x6b0e5d53)\n mstore(0x20, p0)\n mstore(0x40, 0x80)\n mstore(0x60, p2)\n mstore(0x80, p3)\n writeString(0xa0, p1)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(bool p0, bytes32 p1, uint256 p2, uint256 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(bool,string,uint256,uint256)`.\n mstore(0x00, 0x28863fcb)\n mstore(0x20, p0)\n mstore(0x40, 0x80)\n mstore(0x60, p2)\n mstore(0x80, p3)\n writeString(0xa0, p1)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(bool p0, bytes32 p1, uint256 p2, bytes32 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n // Selector of `log(bool,string,uint256,string)`.\n mstore(0x00, 0x1ad96de6)\n mstore(0x20, p0)\n mstore(0x40, 0x80)\n mstore(0x60, p2)\n mstore(0x80, 0xc0)\n writeString(0xa0, p1)\n writeString(0xe0, p3)\n }\n _sendLogPayload(0x1c, 0x104);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n }\n }\n\n function log(bool p0, bytes32 p1, bytes32 p2, address p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n // Selector of `log(bool,string,string,address)`.\n mstore(0x00, 0x97d394d8)\n mstore(0x20, p0)\n mstore(0x40, 0x80)\n mstore(0x60, 0xc0)\n mstore(0x80, p3)\n writeString(0xa0, p1)\n writeString(0xe0, p2)\n }\n _sendLogPayload(0x1c, 0x104);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n }\n }\n\n function log(bool p0, bytes32 p1, bytes32 p2, bool p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n // Selector of `log(bool,string,string,bool)`.\n mstore(0x00, 0x1e4b87e5)\n mstore(0x20, p0)\n mstore(0x40, 0x80)\n mstore(0x60, 0xc0)\n mstore(0x80, p3)\n writeString(0xa0, p1)\n writeString(0xe0, p2)\n }\n _sendLogPayload(0x1c, 0x104);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n }\n }\n\n function log(bool p0, bytes32 p1, bytes32 p2, uint256 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n // Selector of `log(bool,string,string,uint256)`.\n mstore(0x00, 0x7be0c3eb)\n mstore(0x20, p0)\n mstore(0x40, 0x80)\n mstore(0x60, 0xc0)\n mstore(0x80, p3)\n writeString(0xa0, p1)\n writeString(0xe0, p2)\n }\n _sendLogPayload(0x1c, 0x104);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n }\n }\n\n function log(bool p0, bytes32 p1, bytes32 p2, bytes32 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n bytes32 m9;\n bytes32 m10;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n m9 := mload(0x120)\n m10 := mload(0x140)\n // Selector of `log(bool,string,string,string)`.\n mstore(0x00, 0x1762e32a)\n mstore(0x20, p0)\n mstore(0x40, 0x80)\n mstore(0x60, 0xc0)\n mstore(0x80, 0x100)\n writeString(0xa0, p1)\n writeString(0xe0, p2)\n writeString(0x120, p3)\n }\n _sendLogPayload(0x1c, 0x144);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n mstore(0x120, m9)\n mstore(0x140, m10)\n }\n }\n\n function log(uint256 p0, address p1, address p2, address p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(uint256,address,address,address)`.\n mstore(0x00, 0x2488b414)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(uint256 p0, address p1, address p2, bool p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(uint256,address,address,bool)`.\n mstore(0x00, 0x091ffaf5)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(uint256 p0, address p1, address p2, uint256 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(uint256,address,address,uint256)`.\n mstore(0x00, 0x736efbb6)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(uint256 p0, address p1, address p2, bytes32 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(uint256,address,address,string)`.\n mstore(0x00, 0x031c6f73)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, 0x80)\n writeString(0xa0, p3)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(uint256 p0, address p1, bool p2, address p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(uint256,address,bool,address)`.\n mstore(0x00, 0xef72c513)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(uint256 p0, address p1, bool p2, bool p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(uint256,address,bool,bool)`.\n mstore(0x00, 0xe351140f)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(uint256 p0, address p1, bool p2, uint256 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(uint256,address,bool,uint256)`.\n mstore(0x00, 0x5abd992a)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(uint256 p0, address p1, bool p2, bytes32 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(uint256,address,bool,string)`.\n mstore(0x00, 0x90fb06aa)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, 0x80)\n writeString(0xa0, p3)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(uint256 p0, address p1, uint256 p2, address p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(uint256,address,uint256,address)`.\n mstore(0x00, 0x15c127b5)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(uint256 p0, address p1, uint256 p2, bool p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(uint256,address,uint256,bool)`.\n mstore(0x00, 0x5f743a7c)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(uint256 p0, address p1, uint256 p2, uint256 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(uint256,address,uint256,uint256)`.\n mstore(0x00, 0x0c9cd9c1)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(uint256 p0, address p1, uint256 p2, bytes32 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(uint256,address,uint256,string)`.\n mstore(0x00, 0xddb06521)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, 0x80)\n writeString(0xa0, p3)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(uint256 p0, address p1, bytes32 p2, address p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(uint256,address,string,address)`.\n mstore(0x00, 0x9cba8fff)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, 0x80)\n mstore(0x80, p3)\n writeString(0xa0, p2)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(uint256 p0, address p1, bytes32 p2, bool p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(uint256,address,string,bool)`.\n mstore(0x00, 0xcc32ab07)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, 0x80)\n mstore(0x80, p3)\n writeString(0xa0, p2)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(uint256 p0, address p1, bytes32 p2, uint256 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(uint256,address,string,uint256)`.\n mstore(0x00, 0x46826b5d)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, 0x80)\n mstore(0x80, p3)\n writeString(0xa0, p2)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(uint256 p0, address p1, bytes32 p2, bytes32 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n // Selector of `log(uint256,address,string,string)`.\n mstore(0x00, 0x3e128ca3)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, 0x80)\n mstore(0x80, 0xc0)\n writeString(0xa0, p2)\n writeString(0xe0, p3)\n }\n _sendLogPayload(0x1c, 0x104);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n }\n }\n\n function log(uint256 p0, bool p1, address p2, address p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(uint256,bool,address,address)`.\n mstore(0x00, 0xa1ef4cbb)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(uint256 p0, bool p1, address p2, bool p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(uint256,bool,address,bool)`.\n mstore(0x00, 0x454d54a5)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(uint256 p0, bool p1, address p2, uint256 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(uint256,bool,address,uint256)`.\n mstore(0x00, 0x078287f5)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(uint256 p0, bool p1, address p2, bytes32 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(uint256,bool,address,string)`.\n mstore(0x00, 0xade052c7)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, 0x80)\n writeString(0xa0, p3)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(uint256 p0, bool p1, bool p2, address p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(uint256,bool,bool,address)`.\n mstore(0x00, 0x69640b59)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(uint256 p0, bool p1, bool p2, bool p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(uint256,bool,bool,bool)`.\n mstore(0x00, 0xb6f577a1)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(uint256 p0, bool p1, bool p2, uint256 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(uint256,bool,bool,uint256)`.\n mstore(0x00, 0x7464ce23)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(uint256 p0, bool p1, bool p2, bytes32 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(uint256,bool,bool,string)`.\n mstore(0x00, 0xdddb9561)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, 0x80)\n writeString(0xa0, p3)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(uint256 p0, bool p1, uint256 p2, address p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(uint256,bool,uint256,address)`.\n mstore(0x00, 0x88cb6041)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(uint256 p0, bool p1, uint256 p2, bool p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(uint256,bool,uint256,bool)`.\n mstore(0x00, 0x91a02e2a)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(uint256 p0, bool p1, uint256 p2, uint256 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(uint256,bool,uint256,uint256)`.\n mstore(0x00, 0xc6acc7a8)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(uint256 p0, bool p1, uint256 p2, bytes32 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(uint256,bool,uint256,string)`.\n mstore(0x00, 0xde03e774)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, 0x80)\n writeString(0xa0, p3)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(uint256 p0, bool p1, bytes32 p2, address p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(uint256,bool,string,address)`.\n mstore(0x00, 0xef529018)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, 0x80)\n mstore(0x80, p3)\n writeString(0xa0, p2)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(uint256 p0, bool p1, bytes32 p2, bool p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(uint256,bool,string,bool)`.\n mstore(0x00, 0xeb928d7f)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, 0x80)\n mstore(0x80, p3)\n writeString(0xa0, p2)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(uint256 p0, bool p1, bytes32 p2, uint256 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(uint256,bool,string,uint256)`.\n mstore(0x00, 0x2c1d0746)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, 0x80)\n mstore(0x80, p3)\n writeString(0xa0, p2)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(uint256 p0, bool p1, bytes32 p2, bytes32 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n // Selector of `log(uint256,bool,string,string)`.\n mstore(0x00, 0x68c8b8bd)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, 0x80)\n mstore(0x80, 0xc0)\n writeString(0xa0, p2)\n writeString(0xe0, p3)\n }\n _sendLogPayload(0x1c, 0x104);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n }\n }\n\n function log(uint256 p0, uint256 p1, address p2, address p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(uint256,uint256,address,address)`.\n mstore(0x00, 0x56a5d1b1)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(uint256 p0, uint256 p1, address p2, bool p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(uint256,uint256,address,bool)`.\n mstore(0x00, 0x15cac476)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(uint256 p0, uint256 p1, address p2, uint256 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(uint256,uint256,address,uint256)`.\n mstore(0x00, 0x88f6e4b2)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(uint256 p0, uint256 p1, address p2, bytes32 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(uint256,uint256,address,string)`.\n mstore(0x00, 0x6cde40b8)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, 0x80)\n writeString(0xa0, p3)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(uint256 p0, uint256 p1, bool p2, address p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(uint256,uint256,bool,address)`.\n mstore(0x00, 0x9a816a83)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(uint256 p0, uint256 p1, bool p2, bool p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(uint256,uint256,bool,bool)`.\n mstore(0x00, 0xab085ae6)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(uint256 p0, uint256 p1, bool p2, uint256 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(uint256,uint256,bool,uint256)`.\n mstore(0x00, 0xeb7f6fd2)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(uint256 p0, uint256 p1, bool p2, bytes32 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(uint256,uint256,bool,string)`.\n mstore(0x00, 0xa5b4fc99)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, 0x80)\n writeString(0xa0, p3)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(uint256 p0, uint256 p1, uint256 p2, address p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(uint256,uint256,uint256,address)`.\n mstore(0x00, 0xfa8185af)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(uint256 p0, uint256 p1, uint256 p2, bool p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(uint256,uint256,uint256,bool)`.\n mstore(0x00, 0xc598d185)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(uint256 p0, uint256 p1, uint256 p2, uint256 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(uint256,uint256,uint256,uint256)`.\n mstore(0x00, 0x193fb800)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(uint256 p0, uint256 p1, uint256 p2, bytes32 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(uint256,uint256,uint256,string)`.\n mstore(0x00, 0x59cfcbe3)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, 0x80)\n writeString(0xa0, p3)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(uint256 p0, uint256 p1, bytes32 p2, address p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(uint256,uint256,string,address)`.\n mstore(0x00, 0x42d21db7)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, 0x80)\n mstore(0x80, p3)\n writeString(0xa0, p2)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(uint256 p0, uint256 p1, bytes32 p2, bool p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(uint256,uint256,string,bool)`.\n mstore(0x00, 0x7af6ab25)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, 0x80)\n mstore(0x80, p3)\n writeString(0xa0, p2)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(uint256 p0, uint256 p1, bytes32 p2, uint256 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(uint256,uint256,string,uint256)`.\n mstore(0x00, 0x5da297eb)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, 0x80)\n mstore(0x80, p3)\n writeString(0xa0, p2)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(uint256 p0, uint256 p1, bytes32 p2, bytes32 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n // Selector of `log(uint256,uint256,string,string)`.\n mstore(0x00, 0x27d8afd2)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, 0x80)\n mstore(0x80, 0xc0)\n writeString(0xa0, p2)\n writeString(0xe0, p3)\n }\n _sendLogPayload(0x1c, 0x104);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n }\n }\n\n function log(uint256 p0, bytes32 p1, address p2, address p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(uint256,string,address,address)`.\n mstore(0x00, 0x6168ed61)\n mstore(0x20, p0)\n mstore(0x40, 0x80)\n mstore(0x60, p2)\n mstore(0x80, p3)\n writeString(0xa0, p1)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(uint256 p0, bytes32 p1, address p2, bool p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(uint256,string,address,bool)`.\n mstore(0x00, 0x90c30a56)\n mstore(0x20, p0)\n mstore(0x40, 0x80)\n mstore(0x60, p2)\n mstore(0x80, p3)\n writeString(0xa0, p1)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(uint256 p0, bytes32 p1, address p2, uint256 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(uint256,string,address,uint256)`.\n mstore(0x00, 0xe8d3018d)\n mstore(0x20, p0)\n mstore(0x40, 0x80)\n mstore(0x60, p2)\n mstore(0x80, p3)\n writeString(0xa0, p1)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(uint256 p0, bytes32 p1, address p2, bytes32 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n // Selector of `log(uint256,string,address,string)`.\n mstore(0x00, 0x9c3adfa1)\n mstore(0x20, p0)\n mstore(0x40, 0x80)\n mstore(0x60, p2)\n mstore(0x80, 0xc0)\n writeString(0xa0, p1)\n writeString(0xe0, p3)\n }\n _sendLogPayload(0x1c, 0x104);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n }\n }\n\n function log(uint256 p0, bytes32 p1, bool p2, address p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(uint256,string,bool,address)`.\n mstore(0x00, 0xae2ec581)\n mstore(0x20, p0)\n mstore(0x40, 0x80)\n mstore(0x60, p2)\n mstore(0x80, p3)\n writeString(0xa0, p1)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(uint256 p0, bytes32 p1, bool p2, bool p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(uint256,string,bool,bool)`.\n mstore(0x00, 0xba535d9c)\n mstore(0x20, p0)\n mstore(0x40, 0x80)\n mstore(0x60, p2)\n mstore(0x80, p3)\n writeString(0xa0, p1)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(uint256 p0, bytes32 p1, bool p2, uint256 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(uint256,string,bool,uint256)`.\n mstore(0x00, 0xcf009880)\n mstore(0x20, p0)\n mstore(0x40, 0x80)\n mstore(0x60, p2)\n mstore(0x80, p3)\n writeString(0xa0, p1)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(uint256 p0, bytes32 p1, bool p2, bytes32 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n // Selector of `log(uint256,string,bool,string)`.\n mstore(0x00, 0xd2d423cd)\n mstore(0x20, p0)\n mstore(0x40, 0x80)\n mstore(0x60, p2)\n mstore(0x80, 0xc0)\n writeString(0xa0, p1)\n writeString(0xe0, p3)\n }\n _sendLogPayload(0x1c, 0x104);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n }\n }\n\n function log(uint256 p0, bytes32 p1, uint256 p2, address p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(uint256,string,uint256,address)`.\n mstore(0x00, 0x3b2279b4)\n mstore(0x20, p0)\n mstore(0x40, 0x80)\n mstore(0x60, p2)\n mstore(0x80, p3)\n writeString(0xa0, p1)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(uint256 p0, bytes32 p1, uint256 p2, bool p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(uint256,string,uint256,bool)`.\n mstore(0x00, 0x691a8f74)\n mstore(0x20, p0)\n mstore(0x40, 0x80)\n mstore(0x60, p2)\n mstore(0x80, p3)\n writeString(0xa0, p1)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(uint256 p0, bytes32 p1, uint256 p2, uint256 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(uint256,string,uint256,uint256)`.\n mstore(0x00, 0x82c25b74)\n mstore(0x20, p0)\n mstore(0x40, 0x80)\n mstore(0x60, p2)\n mstore(0x80, p3)\n writeString(0xa0, p1)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(uint256 p0, bytes32 p1, uint256 p2, bytes32 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n // Selector of `log(uint256,string,uint256,string)`.\n mstore(0x00, 0xb7b914ca)\n mstore(0x20, p0)\n mstore(0x40, 0x80)\n mstore(0x60, p2)\n mstore(0x80, 0xc0)\n writeString(0xa0, p1)\n writeString(0xe0, p3)\n }\n _sendLogPayload(0x1c, 0x104);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n }\n }\n\n function log(uint256 p0, bytes32 p1, bytes32 p2, address p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n // Selector of `log(uint256,string,string,address)`.\n mstore(0x00, 0xd583c602)\n mstore(0x20, p0)\n mstore(0x40, 0x80)\n mstore(0x60, 0xc0)\n mstore(0x80, p3)\n writeString(0xa0, p1)\n writeString(0xe0, p2)\n }\n _sendLogPayload(0x1c, 0x104);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n }\n }\n\n function log(uint256 p0, bytes32 p1, bytes32 p2, bool p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n // Selector of `log(uint256,string,string,bool)`.\n mstore(0x00, 0xb3a6b6bd)\n mstore(0x20, p0)\n mstore(0x40, 0x80)\n mstore(0x60, 0xc0)\n mstore(0x80, p3)\n writeString(0xa0, p1)\n writeString(0xe0, p2)\n }\n _sendLogPayload(0x1c, 0x104);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n }\n }\n\n function log(uint256 p0, bytes32 p1, bytes32 p2, uint256 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n // Selector of `log(uint256,string,string,uint256)`.\n mstore(0x00, 0xb028c9bd)\n mstore(0x20, p0)\n mstore(0x40, 0x80)\n mstore(0x60, 0xc0)\n mstore(0x80, p3)\n writeString(0xa0, p1)\n writeString(0xe0, p2)\n }\n _sendLogPayload(0x1c, 0x104);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n }\n }\n\n function log(uint256 p0, bytes32 p1, bytes32 p2, bytes32 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n bytes32 m9;\n bytes32 m10;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n m9 := mload(0x120)\n m10 := mload(0x140)\n // Selector of `log(uint256,string,string,string)`.\n mstore(0x00, 0x21ad0683)\n mstore(0x20, p0)\n mstore(0x40, 0x80)\n mstore(0x60, 0xc0)\n mstore(0x80, 0x100)\n writeString(0xa0, p1)\n writeString(0xe0, p2)\n writeString(0x120, p3)\n }\n _sendLogPayload(0x1c, 0x144);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n mstore(0x120, m9)\n mstore(0x140, m10)\n }\n }\n\n function log(bytes32 p0, address p1, address p2, address p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(string,address,address,address)`.\n mstore(0x00, 0xed8f28f6)\n mstore(0x20, 0x80)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n writeString(0xa0, p0)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(bytes32 p0, address p1, address p2, bool p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(string,address,address,bool)`.\n mstore(0x00, 0xb59dbd60)\n mstore(0x20, 0x80)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n writeString(0xa0, p0)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(bytes32 p0, address p1, address p2, uint256 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(string,address,address,uint256)`.\n mstore(0x00, 0x8ef3f399)\n mstore(0x20, 0x80)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n writeString(0xa0, p0)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(bytes32 p0, address p1, address p2, bytes32 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n // Selector of `log(string,address,address,string)`.\n mstore(0x00, 0x800a1c67)\n mstore(0x20, 0x80)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, 0xc0)\n writeString(0xa0, p0)\n writeString(0xe0, p3)\n }\n _sendLogPayload(0x1c, 0x104);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n }\n }\n\n function log(bytes32 p0, address p1, bool p2, address p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(string,address,bool,address)`.\n mstore(0x00, 0x223603bd)\n mstore(0x20, 0x80)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n writeString(0xa0, p0)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(bytes32 p0, address p1, bool p2, bool p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(string,address,bool,bool)`.\n mstore(0x00, 0x79884c2b)\n mstore(0x20, 0x80)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n writeString(0xa0, p0)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(bytes32 p0, address p1, bool p2, uint256 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(string,address,bool,uint256)`.\n mstore(0x00, 0x3e9f866a)\n mstore(0x20, 0x80)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n writeString(0xa0, p0)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(bytes32 p0, address p1, bool p2, bytes32 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n // Selector of `log(string,address,bool,string)`.\n mstore(0x00, 0x0454c079)\n mstore(0x20, 0x80)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, 0xc0)\n writeString(0xa0, p0)\n writeString(0xe0, p3)\n }\n _sendLogPayload(0x1c, 0x104);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n }\n }\n\n function log(bytes32 p0, address p1, uint256 p2, address p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(string,address,uint256,address)`.\n mstore(0x00, 0x63fb8bc5)\n mstore(0x20, 0x80)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n writeString(0xa0, p0)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(bytes32 p0, address p1, uint256 p2, bool p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(string,address,uint256,bool)`.\n mstore(0x00, 0xfc4845f0)\n mstore(0x20, 0x80)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n writeString(0xa0, p0)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(bytes32 p0, address p1, uint256 p2, uint256 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(string,address,uint256,uint256)`.\n mstore(0x00, 0xf8f51b1e)\n mstore(0x20, 0x80)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n writeString(0xa0, p0)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(bytes32 p0, address p1, uint256 p2, bytes32 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n // Selector of `log(string,address,uint256,string)`.\n mstore(0x00, 0x5a477632)\n mstore(0x20, 0x80)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, 0xc0)\n writeString(0xa0, p0)\n writeString(0xe0, p3)\n }\n _sendLogPayload(0x1c, 0x104);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n }\n }\n\n function log(bytes32 p0, address p1, bytes32 p2, address p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n // Selector of `log(string,address,string,address)`.\n mstore(0x00, 0xaabc9a31)\n mstore(0x20, 0x80)\n mstore(0x40, p1)\n mstore(0x60, 0xc0)\n mstore(0x80, p3)\n writeString(0xa0, p0)\n writeString(0xe0, p2)\n }\n _sendLogPayload(0x1c, 0x104);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n }\n }\n\n function log(bytes32 p0, address p1, bytes32 p2, bool p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n // Selector of `log(string,address,string,bool)`.\n mstore(0x00, 0x5f15d28c)\n mstore(0x20, 0x80)\n mstore(0x40, p1)\n mstore(0x60, 0xc0)\n mstore(0x80, p3)\n writeString(0xa0, p0)\n writeString(0xe0, p2)\n }\n _sendLogPayload(0x1c, 0x104);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n }\n }\n\n function log(bytes32 p0, address p1, bytes32 p2, uint256 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n // Selector of `log(string,address,string,uint256)`.\n mstore(0x00, 0x91d1112e)\n mstore(0x20, 0x80)\n mstore(0x40, p1)\n mstore(0x60, 0xc0)\n mstore(0x80, p3)\n writeString(0xa0, p0)\n writeString(0xe0, p2)\n }\n _sendLogPayload(0x1c, 0x104);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n }\n }\n\n function log(bytes32 p0, address p1, bytes32 p2, bytes32 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n bytes32 m9;\n bytes32 m10;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n m9 := mload(0x120)\n m10 := mload(0x140)\n // Selector of `log(string,address,string,string)`.\n mstore(0x00, 0x245986f2)\n mstore(0x20, 0x80)\n mstore(0x40, p1)\n mstore(0x60, 0xc0)\n mstore(0x80, 0x100)\n writeString(0xa0, p0)\n writeString(0xe0, p2)\n writeString(0x120, p3)\n }\n _sendLogPayload(0x1c, 0x144);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n mstore(0x120, m9)\n mstore(0x140, m10)\n }\n }\n\n function log(bytes32 p0, bool p1, address p2, address p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(string,bool,address,address)`.\n mstore(0x00, 0x33e9dd1d)\n mstore(0x20, 0x80)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n writeString(0xa0, p0)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(bytes32 p0, bool p1, address p2, bool p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(string,bool,address,bool)`.\n mstore(0x00, 0x958c28c6)\n mstore(0x20, 0x80)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n writeString(0xa0, p0)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(bytes32 p0, bool p1, address p2, uint256 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(string,bool,address,uint256)`.\n mstore(0x00, 0x5d08bb05)\n mstore(0x20, 0x80)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n writeString(0xa0, p0)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(bytes32 p0, bool p1, address p2, bytes32 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n // Selector of `log(string,bool,address,string)`.\n mstore(0x00, 0x2d8e33a4)\n mstore(0x20, 0x80)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, 0xc0)\n writeString(0xa0, p0)\n writeString(0xe0, p3)\n }\n _sendLogPayload(0x1c, 0x104);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n }\n }\n\n function log(bytes32 p0, bool p1, bool p2, address p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(string,bool,bool,address)`.\n mstore(0x00, 0x7190a529)\n mstore(0x20, 0x80)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n writeString(0xa0, p0)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(bytes32 p0, bool p1, bool p2, bool p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(string,bool,bool,bool)`.\n mstore(0x00, 0x895af8c5)\n mstore(0x20, 0x80)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n writeString(0xa0, p0)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(bytes32 p0, bool p1, bool p2, uint256 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(string,bool,bool,uint256)`.\n mstore(0x00, 0x8e3f78a9)\n mstore(0x20, 0x80)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n writeString(0xa0, p0)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(bytes32 p0, bool p1, bool p2, bytes32 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n // Selector of `log(string,bool,bool,string)`.\n mstore(0x00, 0x9d22d5dd)\n mstore(0x20, 0x80)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, 0xc0)\n writeString(0xa0, p0)\n writeString(0xe0, p3)\n }\n _sendLogPayload(0x1c, 0x104);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n }\n }\n\n function log(bytes32 p0, bool p1, uint256 p2, address p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(string,bool,uint256,address)`.\n mstore(0x00, 0x935e09bf)\n mstore(0x20, 0x80)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n writeString(0xa0, p0)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(bytes32 p0, bool p1, uint256 p2, bool p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(string,bool,uint256,bool)`.\n mstore(0x00, 0x8af7cf8a)\n mstore(0x20, 0x80)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n writeString(0xa0, p0)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(bytes32 p0, bool p1, uint256 p2, uint256 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(string,bool,uint256,uint256)`.\n mstore(0x00, 0x64b5bb67)\n mstore(0x20, 0x80)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n writeString(0xa0, p0)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(bytes32 p0, bool p1, uint256 p2, bytes32 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n // Selector of `log(string,bool,uint256,string)`.\n mstore(0x00, 0x742d6ee7)\n mstore(0x20, 0x80)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, 0xc0)\n writeString(0xa0, p0)\n writeString(0xe0, p3)\n }\n _sendLogPayload(0x1c, 0x104);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n }\n }\n\n function log(bytes32 p0, bool p1, bytes32 p2, address p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n // Selector of `log(string,bool,string,address)`.\n mstore(0x00, 0xe0625b29)\n mstore(0x20, 0x80)\n mstore(0x40, p1)\n mstore(0x60, 0xc0)\n mstore(0x80, p3)\n writeString(0xa0, p0)\n writeString(0xe0, p2)\n }\n _sendLogPayload(0x1c, 0x104);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n }\n }\n\n function log(bytes32 p0, bool p1, bytes32 p2, bool p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n // Selector of `log(string,bool,string,bool)`.\n mstore(0x00, 0x3f8a701d)\n mstore(0x20, 0x80)\n mstore(0x40, p1)\n mstore(0x60, 0xc0)\n mstore(0x80, p3)\n writeString(0xa0, p0)\n writeString(0xe0, p2)\n }\n _sendLogPayload(0x1c, 0x104);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n }\n }\n\n function log(bytes32 p0, bool p1, bytes32 p2, uint256 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n // Selector of `log(string,bool,string,uint256)`.\n mstore(0x00, 0x24f91465)\n mstore(0x20, 0x80)\n mstore(0x40, p1)\n mstore(0x60, 0xc0)\n mstore(0x80, p3)\n writeString(0xa0, p0)\n writeString(0xe0, p2)\n }\n _sendLogPayload(0x1c, 0x104);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n }\n }\n\n function log(bytes32 p0, bool p1, bytes32 p2, bytes32 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n bytes32 m9;\n bytes32 m10;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n m9 := mload(0x120)\n m10 := mload(0x140)\n // Selector of `log(string,bool,string,string)`.\n mstore(0x00, 0xa826caeb)\n mstore(0x20, 0x80)\n mstore(0x40, p1)\n mstore(0x60, 0xc0)\n mstore(0x80, 0x100)\n writeString(0xa0, p0)\n writeString(0xe0, p2)\n writeString(0x120, p3)\n }\n _sendLogPayload(0x1c, 0x144);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n mstore(0x120, m9)\n mstore(0x140, m10)\n }\n }\n\n function log(bytes32 p0, uint256 p1, address p2, address p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(string,uint256,address,address)`.\n mstore(0x00, 0x5ea2b7ae)\n mstore(0x20, 0x80)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n writeString(0xa0, p0)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(bytes32 p0, uint256 p1, address p2, bool p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(string,uint256,address,bool)`.\n mstore(0x00, 0x82112a42)\n mstore(0x20, 0x80)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n writeString(0xa0, p0)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(bytes32 p0, uint256 p1, address p2, uint256 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(string,uint256,address,uint256)`.\n mstore(0x00, 0x4f04fdc6)\n mstore(0x20, 0x80)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n writeString(0xa0, p0)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(bytes32 p0, uint256 p1, address p2, bytes32 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n // Selector of `log(string,uint256,address,string)`.\n mstore(0x00, 0x9ffb2f93)\n mstore(0x20, 0x80)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, 0xc0)\n writeString(0xa0, p0)\n writeString(0xe0, p3)\n }\n _sendLogPayload(0x1c, 0x104);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n }\n }\n\n function log(bytes32 p0, uint256 p1, bool p2, address p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(string,uint256,bool,address)`.\n mstore(0x00, 0xe0e95b98)\n mstore(0x20, 0x80)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n writeString(0xa0, p0)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(bytes32 p0, uint256 p1, bool p2, bool p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(string,uint256,bool,bool)`.\n mstore(0x00, 0x354c36d6)\n mstore(0x20, 0x80)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n writeString(0xa0, p0)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(bytes32 p0, uint256 p1, bool p2, uint256 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(string,uint256,bool,uint256)`.\n mstore(0x00, 0xe41b6f6f)\n mstore(0x20, 0x80)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n writeString(0xa0, p0)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(bytes32 p0, uint256 p1, bool p2, bytes32 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n // Selector of `log(string,uint256,bool,string)`.\n mstore(0x00, 0xabf73a98)\n mstore(0x20, 0x80)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, 0xc0)\n writeString(0xa0, p0)\n writeString(0xe0, p3)\n }\n _sendLogPayload(0x1c, 0x104);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n }\n }\n\n function log(bytes32 p0, uint256 p1, uint256 p2, address p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(string,uint256,uint256,address)`.\n mstore(0x00, 0xe21de278)\n mstore(0x20, 0x80)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n writeString(0xa0, p0)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(bytes32 p0, uint256 p1, uint256 p2, bool p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(string,uint256,uint256,bool)`.\n mstore(0x00, 0x7626db92)\n mstore(0x20, 0x80)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n writeString(0xa0, p0)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(bytes32 p0, uint256 p1, uint256 p2, uint256 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(string,uint256,uint256,uint256)`.\n mstore(0x00, 0xa7a87853)\n mstore(0x20, 0x80)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n writeString(0xa0, p0)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(bytes32 p0, uint256 p1, uint256 p2, bytes32 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n // Selector of `log(string,uint256,uint256,string)`.\n mstore(0x00, 0x854b3496)\n mstore(0x20, 0x80)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, 0xc0)\n writeString(0xa0, p0)\n writeString(0xe0, p3)\n }\n _sendLogPayload(0x1c, 0x104);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n }\n }\n\n function log(bytes32 p0, uint256 p1, bytes32 p2, address p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n // Selector of `log(string,uint256,string,address)`.\n mstore(0x00, 0x7c4632a4)\n mstore(0x20, 0x80)\n mstore(0x40, p1)\n mstore(0x60, 0xc0)\n mstore(0x80, p3)\n writeString(0xa0, p0)\n writeString(0xe0, p2)\n }\n _sendLogPayload(0x1c, 0x104);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n }\n }\n\n function log(bytes32 p0, uint256 p1, bytes32 p2, bool p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n // Selector of `log(string,uint256,string,bool)`.\n mstore(0x00, 0x7d24491d)\n mstore(0x20, 0x80)\n mstore(0x40, p1)\n mstore(0x60, 0xc0)\n mstore(0x80, p3)\n writeString(0xa0, p0)\n writeString(0xe0, p2)\n }\n _sendLogPayload(0x1c, 0x104);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n }\n }\n\n function log(bytes32 p0, uint256 p1, bytes32 p2, uint256 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n // Selector of `log(string,uint256,string,uint256)`.\n mstore(0x00, 0xc67ea9d1)\n mstore(0x20, 0x80)\n mstore(0x40, p1)\n mstore(0x60, 0xc0)\n mstore(0x80, p3)\n writeString(0xa0, p0)\n writeString(0xe0, p2)\n }\n _sendLogPayload(0x1c, 0x104);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n }\n }\n\n function log(bytes32 p0, uint256 p1, bytes32 p2, bytes32 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n bytes32 m9;\n bytes32 m10;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n m9 := mload(0x120)\n m10 := mload(0x140)\n // Selector of `log(string,uint256,string,string)`.\n mstore(0x00, 0x5ab84e1f)\n mstore(0x20, 0x80)\n mstore(0x40, p1)\n mstore(0x60, 0xc0)\n mstore(0x80, 0x100)\n writeString(0xa0, p0)\n writeString(0xe0, p2)\n writeString(0x120, p3)\n }\n _sendLogPayload(0x1c, 0x144);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n mstore(0x120, m9)\n mstore(0x140, m10)\n }\n }\n\n function log(bytes32 p0, bytes32 p1, address p2, address p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n // Selector of `log(string,string,address,address)`.\n mstore(0x00, 0x439c7bef)\n mstore(0x20, 0x80)\n mstore(0x40, 0xc0)\n mstore(0x60, p2)\n mstore(0x80, p3)\n writeString(0xa0, p0)\n writeString(0xe0, p1)\n }\n _sendLogPayload(0x1c, 0x104);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n }\n }\n\n function log(bytes32 p0, bytes32 p1, address p2, bool p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n // Selector of `log(string,string,address,bool)`.\n mstore(0x00, 0x5ccd4e37)\n mstore(0x20, 0x80)\n mstore(0x40, 0xc0)\n mstore(0x60, p2)\n mstore(0x80, p3)\n writeString(0xa0, p0)\n writeString(0xe0, p1)\n }\n _sendLogPayload(0x1c, 0x104);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n }\n }\n\n function log(bytes32 p0, bytes32 p1, address p2, uint256 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n // Selector of `log(string,string,address,uint256)`.\n mstore(0x00, 0x7cc3c607)\n mstore(0x20, 0x80)\n mstore(0x40, 0xc0)\n mstore(0x60, p2)\n mstore(0x80, p3)\n writeString(0xa0, p0)\n writeString(0xe0, p1)\n }\n _sendLogPayload(0x1c, 0x104);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n }\n }\n\n function log(bytes32 p0, bytes32 p1, address p2, bytes32 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n bytes32 m9;\n bytes32 m10;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n m9 := mload(0x120)\n m10 := mload(0x140)\n // Selector of `log(string,string,address,string)`.\n mstore(0x00, 0xeb1bff80)\n mstore(0x20, 0x80)\n mstore(0x40, 0xc0)\n mstore(0x60, p2)\n mstore(0x80, 0x100)\n writeString(0xa0, p0)\n writeString(0xe0, p1)\n writeString(0x120, p3)\n }\n _sendLogPayload(0x1c, 0x144);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n mstore(0x120, m9)\n mstore(0x140, m10)\n }\n }\n\n function log(bytes32 p0, bytes32 p1, bool p2, address p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n // Selector of `log(string,string,bool,address)`.\n mstore(0x00, 0xc371c7db)\n mstore(0x20, 0x80)\n mstore(0x40, 0xc0)\n mstore(0x60, p2)\n mstore(0x80, p3)\n writeString(0xa0, p0)\n writeString(0xe0, p1)\n }\n _sendLogPayload(0x1c, 0x104);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n }\n }\n\n function log(bytes32 p0, bytes32 p1, bool p2, bool p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n // Selector of `log(string,string,bool,bool)`.\n mstore(0x00, 0x40785869)\n mstore(0x20, 0x80)\n mstore(0x40, 0xc0)\n mstore(0x60, p2)\n mstore(0x80, p3)\n writeString(0xa0, p0)\n writeString(0xe0, p1)\n }\n _sendLogPayload(0x1c, 0x104);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n }\n }\n\n function log(bytes32 p0, bytes32 p1, bool p2, uint256 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n // Selector of `log(string,string,bool,uint256)`.\n mstore(0x00, 0xd6aefad2)\n mstore(0x20, 0x80)\n mstore(0x40, 0xc0)\n mstore(0x60, p2)\n mstore(0x80, p3)\n writeString(0xa0, p0)\n writeString(0xe0, p1)\n }\n _sendLogPayload(0x1c, 0x104);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n }\n }\n\n function log(bytes32 p0, bytes32 p1, bool p2, bytes32 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n bytes32 m9;\n bytes32 m10;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n m9 := mload(0x120)\n m10 := mload(0x140)\n // Selector of `log(string,string,bool,string)`.\n mstore(0x00, 0x5e84b0ea)\n mstore(0x20, 0x80)\n mstore(0x40, 0xc0)\n mstore(0x60, p2)\n mstore(0x80, 0x100)\n writeString(0xa0, p0)\n writeString(0xe0, p1)\n writeString(0x120, p3)\n }\n _sendLogPayload(0x1c, 0x144);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n mstore(0x120, m9)\n mstore(0x140, m10)\n }\n }\n\n function log(bytes32 p0, bytes32 p1, uint256 p2, address p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n // Selector of `log(string,string,uint256,address)`.\n mstore(0x00, 0x1023f7b2)\n mstore(0x20, 0x80)\n mstore(0x40, 0xc0)\n mstore(0x60, p2)\n mstore(0x80, p3)\n writeString(0xa0, p0)\n writeString(0xe0, p1)\n }\n _sendLogPayload(0x1c, 0x104);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n }\n }\n\n function log(bytes32 p0, bytes32 p1, uint256 p2, bool p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n // Selector of `log(string,string,uint256,bool)`.\n mstore(0x00, 0xc3a8a654)\n mstore(0x20, 0x80)\n mstore(0x40, 0xc0)\n mstore(0x60, p2)\n mstore(0x80, p3)\n writeString(0xa0, p0)\n writeString(0xe0, p1)\n }\n _sendLogPayload(0x1c, 0x104);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n }\n }\n\n function log(bytes32 p0, bytes32 p1, uint256 p2, uint256 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n // Selector of `log(string,string,uint256,uint256)`.\n mstore(0x00, 0xf45d7d2c)\n mstore(0x20, 0x80)\n mstore(0x40, 0xc0)\n mstore(0x60, p2)\n mstore(0x80, p3)\n writeString(0xa0, p0)\n writeString(0xe0, p1)\n }\n _sendLogPayload(0x1c, 0x104);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n }\n }\n\n function log(bytes32 p0, bytes32 p1, uint256 p2, bytes32 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n bytes32 m9;\n bytes32 m10;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n m9 := mload(0x120)\n m10 := mload(0x140)\n // Selector of `log(string,string,uint256,string)`.\n mstore(0x00, 0x5d1a971a)\n mstore(0x20, 0x80)\n mstore(0x40, 0xc0)\n mstore(0x60, p2)\n mstore(0x80, 0x100)\n writeString(0xa0, p0)\n writeString(0xe0, p1)\n writeString(0x120, p3)\n }\n _sendLogPayload(0x1c, 0x144);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n mstore(0x120, m9)\n mstore(0x140, m10)\n }\n }\n\n function log(bytes32 p0, bytes32 p1, bytes32 p2, address p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n bytes32 m9;\n bytes32 m10;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n m9 := mload(0x120)\n m10 := mload(0x140)\n // Selector of `log(string,string,string,address)`.\n mstore(0x00, 0x6d572f44)\n mstore(0x20, 0x80)\n mstore(0x40, 0xc0)\n mstore(0x60, 0x100)\n mstore(0x80, p3)\n writeString(0xa0, p0)\n writeString(0xe0, p1)\n writeString(0x120, p2)\n }\n _sendLogPayload(0x1c, 0x144);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n mstore(0x120, m9)\n mstore(0x140, m10)\n }\n }\n\n function log(bytes32 p0, bytes32 p1, bytes32 p2, bool p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n bytes32 m9;\n bytes32 m10;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n m9 := mload(0x120)\n m10 := mload(0x140)\n // Selector of `log(string,string,string,bool)`.\n mstore(0x00, 0x2c1754ed)\n mstore(0x20, 0x80)\n mstore(0x40, 0xc0)\n mstore(0x60, 0x100)\n mstore(0x80, p3)\n writeString(0xa0, p0)\n writeString(0xe0, p1)\n writeString(0x120, p2)\n }\n _sendLogPayload(0x1c, 0x144);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n mstore(0x120, m9)\n mstore(0x140, m10)\n }\n }\n\n function log(bytes32 p0, bytes32 p1, bytes32 p2, uint256 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n bytes32 m9;\n bytes32 m10;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n m9 := mload(0x120)\n m10 := mload(0x140)\n // Selector of `log(string,string,string,uint256)`.\n mstore(0x00, 0x8eafb02b)\n mstore(0x20, 0x80)\n mstore(0x40, 0xc0)\n mstore(0x60, 0x100)\n mstore(0x80, p3)\n writeString(0xa0, p0)\n writeString(0xe0, p1)\n writeString(0x120, p2)\n }\n _sendLogPayload(0x1c, 0x144);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n mstore(0x120, m9)\n mstore(0x140, m10)\n }\n }\n\n function log(bytes32 p0, bytes32 p1, bytes32 p2, bytes32 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n bytes32 m9;\n bytes32 m10;\n bytes32 m11;\n bytes32 m12;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n m9 := mload(0x120)\n m10 := mload(0x140)\n m11 := mload(0x160)\n m12 := mload(0x180)\n // Selector of `log(string,string,string,string)`.\n mstore(0x00, 0xde68f20a)\n mstore(0x20, 0x80)\n mstore(0x40, 0xc0)\n mstore(0x60, 0x100)\n mstore(0x80, 0x140)\n writeString(0xa0, p0)\n writeString(0xe0, p1)\n writeString(0x120, p2)\n writeString(0x160, p3)\n }\n _sendLogPayload(0x1c, 0x184);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n mstore(0x120, m9)\n mstore(0x140, m10)\n mstore(0x160, m11)\n mstore(0x180, m12)\n }\n }\n}\n","license":"MIT"},"scripts/FetchChainInfo.s.sol":{"keccak256":"0x202fb27a5a78b7d8c96c3a4ea69981dc4eeda765aa2747699ac80b8499feb709","urls":[],"content":"// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\nimport { Script } from \"forge-std/Script.sol\";\nimport { GameTypes, GameType } from \"src/dispute/lib/Types.sol\";\n\n/// @notice Contains getters for arbitrary methods from all L1 contracts, including legacy getters\n/// that have since been deprecated.\ninterface IFetcher {\n function guardian() external view returns (address);\n function GUARDIAN() external view returns (address);\n function systemConfig() external view returns (address);\n function SYSTEM_CONFIG() external view returns (address);\n function disputeGameFactory() external view returns (address);\n function ethLockbox() external view returns (address);\n function superchainConfig() external view returns (address);\n function messenger() external view returns (address);\n function addressManager() external view returns (address);\n function PORTAL() external view returns (address);\n function portal() external view returns (address);\n function l1ERC721Bridge() external view returns (address);\n function optimismMintableERC20Factory() external view returns (address);\n function gameImpls(GameType _gameType) external view returns (address);\n function respectedGameType() external view returns (GameType);\n function anchorStateRegistry() external view returns (address);\n function L2_ORACLE() external view returns (address);\n function l2Oracle() external view returns (address);\n function vm() external view returns (address);\n function oracle() external view returns (address);\n function challenger() external view returns (address);\n function proposer() external view returns (address);\n function PROPOSER() external view returns (address);\n function batcherHash() external view returns (bytes32);\n function admin() external view returns (address);\n function owner() external view returns (address);\n function unsafeBlockSigner() external view returns (address);\n function weth() external view returns (address);\n}\n\ncontract FetchChainInfoInput {\n address internal _systemConfigProxy;\n address internal _l1StandardBridgeProxy;\n\n function set(bytes4 _sel, address _addr) public {\n require(_addr != address(0), \"FetchChainInfoInput: cannot set zero address\");\n if (_sel == this.systemConfigProxy.selector) _systemConfigProxy = _addr;\n else if (_sel == this.l1StandardBridgeProxy.selector) _l1StandardBridgeProxy = _addr;\n else revert(\"FetchChainInfoInput: unknown selector\");\n }\n\n function systemConfigProxy() public view returns (address) {\n require(_systemConfigProxy != address(0), \"FetchChainInfoInput: systemConfigProxy not set\");\n return _systemConfigProxy;\n }\n\n function l1StandardBridgeProxy() public view returns (address) {\n require(_l1StandardBridgeProxy != address(0), \"FetchChainInfoInput: l1StandardBridgeProxy not set\");\n return _l1StandardBridgeProxy;\n }\n}\n\ncontract FetchChainInfoOutput {\n // contract addresses\n // - SuperchainContracts\n address internal _superchainConfigProxy;\n // - ImplementationsContracts\n address internal _mipsImpl;\n address internal _preimageOracleImpl;\n // - OpChainContracts\n address internal _addressManagerImpl;\n address internal _ethLockboxProxy;\n address internal _l1CrossDomainMessengerProxy;\n address internal _l1Erc721BridgeProxy;\n address internal _l1StandardBridgeProxy;\n address internal _l2OutputOracleProxy;\n address internal _optimismMintableErc20FactoryProxy;\n address internal _optimismPortalProxy;\n address internal _systemConfigProxy;\n address internal _opChainProxyAdminImpl;\n address internal _anchorStateRegistryProxy;\n address internal _delayedWethPermissionedGameProxy;\n address internal _delayedWethPermissionlessGameProxy;\n address internal _disputeGameFactoryProxy;\n address internal _faultDisputeGameImpl;\n address internal _permissionedDisputeGameImpl;\n\n // roles\n address internal _systemConfigOwner;\n address internal _opChainProxyAdminOwner;\n address internal _opChainGuardian;\n address internal _challenger;\n address internal _proposer;\n address internal _unsafeBlockSigner;\n address internal _batchSubmitter;\n\n // fault proof status\n bool internal _permissioned;\n bool internal _permissionless;\n GameType internal _respectedGameType;\n\n function set(bytes4 _sel, address _addr) public {\n // SuperchainContracts\n if (_sel == this.superchainConfigProxy.selector) _superchainConfigProxy = _addr;\n // - ImplementationsContracts\n else if (_sel == this.mipsImpl.selector) _mipsImpl = _addr;\n else if (_sel == this.preimageOracleImpl.selector) _preimageOracleImpl = _addr;\n // - OpChainContracts\n else if (_sel == this.addressManagerImpl.selector) _addressManagerImpl = _addr;\n else if (_sel == this.ethLockboxProxy.selector) _ethLockboxProxy = _addr;\n else if (_sel == this.l1CrossDomainMessengerProxy.selector) _l1CrossDomainMessengerProxy = _addr;\n else if (_sel == this.l1Erc721BridgeProxy.selector) _l1Erc721BridgeProxy = _addr;\n else if (_sel == this.l1StandardBridgeProxy.selector) _l1StandardBridgeProxy = _addr;\n else if (_sel == this.l2OutputOracleProxy.selector) _l2OutputOracleProxy = _addr;\n else if (_sel == this.optimismMintableErc20FactoryProxy.selector) _optimismMintableErc20FactoryProxy = _addr;\n else if (_sel == this.optimismPortalProxy.selector) _optimismPortalProxy = _addr;\n else if (_sel == this.systemConfigProxy.selector) _systemConfigProxy = _addr;\n else if (_sel == this.opChainProxyAdminImpl.selector) _opChainProxyAdminImpl = _addr;\n else if (_sel == this.anchorStateRegistryProxy.selector) _anchorStateRegistryProxy = _addr;\n else if (_sel == this.delayedWethPermissionedGameProxy.selector) _delayedWethPermissionedGameProxy = _addr;\n else if (_sel == this.delayedWethPermissionlessGameProxy.selector) _delayedWethPermissionlessGameProxy = _addr;\n else if (_sel == this.disputeGameFactoryProxy.selector) _disputeGameFactoryProxy = _addr;\n else if (_sel == this.faultDisputeGameImpl.selector) _faultDisputeGameImpl = _addr;\n else if (_sel == this.permissionedDisputeGameImpl.selector) _permissionedDisputeGameImpl = _addr;\n // roles\n else if (_sel == this.systemConfigOwner.selector) _systemConfigOwner = _addr;\n else if (_sel == this.opChainProxyAdminOwner.selector) _opChainProxyAdminOwner = _addr;\n else if (_sel == this.opChainGuardian.selector) _opChainGuardian = _addr;\n else if (_sel == this.challenger.selector) _challenger = _addr;\n else if (_sel == this.proposer.selector) _proposer = _addr;\n else if (_sel == this.unsafeBlockSigner.selector) _unsafeBlockSigner = _addr;\n else if (_sel == this.batchSubmitter.selector) _batchSubmitter = _addr;\n else revert(\"FetchChainInfoOutput: unknown address selector test\");\n }\n\n function set(bytes4 _sel, bool _bool) public {\n if (_sel == this.permissioned.selector) _permissioned = _bool;\n else if (_sel == this.permissionless.selector) _permissionless = _bool;\n else revert(\"FetchChainInfoOutput: unknown bool selector\");\n }\n\n function set(bytes4 _sel, GameType _gameType) public {\n if (_sel == this.respectedGameType.selector) _respectedGameType = _gameType;\n else revert(\"FetchChainInfoOutput: unknown GameType selector\");\n }\n\n function addressManagerImpl() public view returns (address) {\n require(_addressManagerImpl != address(0), \"FetchChainInfoOutput: addressManagerImpl not set\");\n return _addressManagerImpl;\n }\n\n function ethLockboxProxy() public view returns (address) {\n return _ethLockboxProxy;\n }\n\n function l1CrossDomainMessengerProxy() public view returns (address) {\n require(_l1CrossDomainMessengerProxy != address(0), \"FetchChainInfoOutput: l1CrossDomainMessengerProxy not set\");\n return _l1CrossDomainMessengerProxy;\n }\n\n function l1Erc721BridgeProxy() public view returns (address) {\n require(_l1Erc721BridgeProxy != address(0), \"FetchChainInfoOutput: l1Erc721BridgeProxy not set\");\n return _l1Erc721BridgeProxy;\n }\n\n function l1StandardBridgeProxy() public view returns (address) {\n require(_l1StandardBridgeProxy != address(0), \"FetchChainInfoOutput: l1StandardBridgeProxy not set\");\n return _l1StandardBridgeProxy;\n }\n\n function l2OutputOracleProxy() public view returns (address) {\n require(_l2OutputOracleProxy != address(0), \"FetchChainInfoOutput: l2OutputOracleProxy not set\");\n return _l2OutputOracleProxy;\n }\n\n function optimismMintableErc20FactoryProxy() public view returns (address) {\n require(\n _optimismMintableErc20FactoryProxy != address(0),\n \"FetchChainInfoOutput: optimismMintableErc20FactoryProxy not set\"\n );\n return _optimismMintableErc20FactoryProxy;\n }\n\n function optimismPortalProxy() public view returns (address) {\n require(_optimismPortalProxy != address(0), \"FetchChainInfoOutput: optimismPortalProxy not set\");\n return _optimismPortalProxy;\n }\n\n function systemConfigProxy() public view returns (address) {\n require(_systemConfigProxy != address(0), \"FetchChainInfoOutput: systemConfigProxy not set\");\n return _systemConfigProxy;\n }\n\n function opChainProxyAdminImpl() public view returns (address) {\n require(_opChainProxyAdminImpl != address(0), \"FetchChainInfoOutput: opChainProxyAdminImpl not set\");\n return _opChainProxyAdminImpl;\n }\n\n function superchainConfigProxy() public view returns (address) {\n require(_superchainConfigProxy != address(0), \"FetchChainInfoOutput: superchainConfigProxy not set\");\n return _superchainConfigProxy;\n }\n\n function anchorStateRegistryProxy() public view returns (address) {\n require(_anchorStateRegistryProxy != address(0), \"FetchChainInfoOutput: anchorStateRegistryProxy not set\");\n return _anchorStateRegistryProxy;\n }\n\n function delayedWethPermissionedGameProxy() public view returns (address) {\n return _delayedWethPermissionedGameProxy;\n }\n\n function delayedWethPermissionlessGameProxy() public view returns (address) {\n return _delayedWethPermissionlessGameProxy;\n }\n\n function disputeGameFactoryProxy() public view returns (address) {\n return _disputeGameFactoryProxy;\n }\n\n function faultDisputeGameImpl() public view returns (address) {\n require(_faultDisputeGameImpl != address(0), \"FetchChainInfoOutput: faultDisputeGameImpl not set\");\n return _faultDisputeGameImpl;\n }\n\n function mipsImpl() public view returns (address) {\n require(_mipsImpl != address(0), \"FetchChainInfoOutput: mipsImpl not set\");\n return _mipsImpl;\n }\n\n function permissionedDisputeGameImpl() public view returns (address) {\n require(_permissionedDisputeGameImpl != address(0), \"FetchChainInfoOutput: permissionedDisputeGameImpl not set\");\n return _permissionedDisputeGameImpl;\n }\n\n function preimageOracleImpl() public view returns (address) {\n require(_preimageOracleImpl != address(0), \"FetchChainInfoOutput: preimageOracleImpl not set\");\n return _preimageOracleImpl;\n }\n\n function systemConfigOwner() public view returns (address) {\n require(_systemConfigOwner != address(0), \"FetchChainInfoOutput: systemConfigOwner not set\");\n return _systemConfigOwner;\n }\n\n function opChainProxyAdminOwner() public view returns (address) {\n require(_opChainProxyAdminOwner != address(0), \"FetchChainInfoOutput: opChainProxyAdminOwner not set\");\n return _opChainProxyAdminOwner;\n }\n\n function opChainGuardian() public view returns (address) {\n require(_opChainGuardian != address(0), \"FetchChainInfoOutput: opChainGuardian not set\");\n return _opChainGuardian;\n }\n\n function challenger() public view returns (address) {\n require(_challenger != address(0), \"FetchChainInfoOutput: challenger not set\");\n return _challenger;\n }\n\n function proposer() public view returns (address) {\n require(_proposer != address(0), \"FetchChainInfoOutput: proposer not set\");\n return _proposer;\n }\n\n function unsafeBlockSigner() public view returns (address) {\n require(_unsafeBlockSigner != address(0), \"FetchChainInfoOutput: unsafeBlockSigner not set\");\n return _unsafeBlockSigner;\n }\n\n function batchSubmitter() public view returns (address) {\n require(_batchSubmitter != address(0), \"FetchChainInfoOutput: batchSubmitter not set\");\n return _batchSubmitter;\n }\n\n function permissioned() public view returns (bool) {\n return _permissioned;\n }\n\n function permissionless() public view returns (bool) {\n return _permissionless;\n }\n\n function respectedGameType() public view returns (GameType) {\n return _respectedGameType;\n }\n}\n\ncontract FetchChainInfo is Script {\n function run(FetchChainInfoInput _fi, FetchChainInfoOutput _fo) public {\n _processSystemConfig(_fi, _fo);\n _processMessengerAndPortal(_fi, _fo);\n _processFaultProofs(_fo);\n }\n\n function _processSystemConfig(FetchChainInfoInput _fi, FetchChainInfoOutput _fo) internal {\n address systemConfigProxy = _fi.systemConfigProxy();\n _fo.set(_fo.systemConfigProxy.selector, systemConfigProxy);\n\n address systemConfigOwner = IFetcher(systemConfigProxy).owner();\n _fo.set(_fo.systemConfigOwner.selector, systemConfigOwner);\n\n address unsafeBlockSigner = IFetcher(systemConfigProxy).unsafeBlockSigner();\n _fo.set(_fo.unsafeBlockSigner.selector, unsafeBlockSigner);\n\n address batchSubmitter = _getBatchSubmitter(systemConfigProxy);\n _fo.set(_fo.batchSubmitter.selector, batchSubmitter);\n\n address opChainProxyAdminImpl = _getProxyAdmin(systemConfigProxy);\n _fo.set(_fo.opChainProxyAdminImpl.selector, opChainProxyAdminImpl);\n\n address opChainProxyAdminOwner = IFetcher(opChainProxyAdminImpl).owner();\n _fo.set(_fo.opChainProxyAdminOwner.selector, opChainProxyAdminOwner);\n\n address l1Erc721BridgeProxy = _getL1ERC721BridgeProxy(systemConfigProxy);\n _fo.set(_fo.l1Erc721BridgeProxy.selector, l1Erc721BridgeProxy);\n\n address optimismMintableErc20FactoryProxy = _getOptimismMintableERC20FactoryProxy(systemConfigProxy);\n _fo.set(_fo.optimismMintableErc20FactoryProxy.selector, optimismMintableErc20FactoryProxy);\n }\n\n function _processMessengerAndPortal(FetchChainInfoInput _fi, FetchChainInfoOutput _fo) internal {\n address l1StandardBridgeProxy = _fi.l1StandardBridgeProxy();\n _fo.set(_fo.l1StandardBridgeProxy.selector, l1StandardBridgeProxy);\n\n address l1CrossDomainMessengerProxy = IFetcher(l1StandardBridgeProxy).messenger();\n _fo.set(_fo.l1CrossDomainMessengerProxy.selector, l1CrossDomainMessengerProxy);\n\n address addressManagerImpl = _getAddressManager(l1CrossDomainMessengerProxy);\n _fo.set(_fo.addressManagerImpl.selector, addressManagerImpl);\n\n address optimismPortalProxy = _getOptimismPortalProxy(l1CrossDomainMessengerProxy);\n _fo.set(_fo.optimismPortalProxy.selector, optimismPortalProxy);\n\n address opChainGuardian = _getGuardian(optimismPortalProxy);\n _fo.set(_fo.opChainGuardian.selector, opChainGuardian);\n\n address ethLockboxProxy = _getEthLockboxProxy(optimismPortalProxy);\n _fo.set(_fo.ethLockboxProxy.selector, ethLockboxProxy);\n\n address superchainConfigProxy = _getSuperchainConfigProxy(optimismPortalProxy);\n _fo.set(_fo.superchainConfigProxy.selector, superchainConfigProxy);\n }\n\n function _processFaultProofs(FetchChainInfoOutput _fo) internal {\n address systemConfigProxy = _fo.systemConfigProxy();\n address optimismPortalProxy = _fo.optimismPortalProxy();\n\n try IFetcher(optimismPortalProxy).respectedGameType() returns (GameType gameType_) {\n _fo.set(_fo.respectedGameType.selector, gameType_);\n } catch {\n // default respectedGameType to uint32.max since 0 == CANNON\n _fo.set(_fo.respectedGameType.selector, GameType.wrap(type(uint32).max));\n address l2OutputOracleProxy;\n try IFetcher(optimismPortalProxy).l2Oracle() returns (address l2Oracle_) {\n l2OutputOracleProxy = l2Oracle_;\n } catch {\n l2OutputOracleProxy = IFetcher(optimismPortalProxy).L2_ORACLE();\n }\n _fo.set(_fo.l2OutputOracleProxy.selector, l2OutputOracleProxy);\n\n address proposer = IFetcher(l2OutputOracleProxy).PROPOSER();\n _fo.set(_fo.proposer.selector, proposer);\n\n // no fault proofs installed so we're done\n return;\n }\n\n address disputeGameFactoryProxy = _getDisputeGameFactoryProxy(systemConfigProxy);\n if (disputeGameFactoryProxy != address(0)) {\n _fo.set(_fo.disputeGameFactoryProxy.selector, disputeGameFactoryProxy);\n\n address permissionedDisputeGameImpl = _getPermissionedDisputeGame(disputeGameFactoryProxy);\n if (permissionedDisputeGameImpl != address(0)) {\n // permissioned fault proofs installed\n _fo.set(_fo.permissioned.selector, true);\n _fo.set(_fo.permissionedDisputeGameImpl.selector, permissionedDisputeGameImpl);\n\n address challenger = IFetcher(permissionedDisputeGameImpl).challenger();\n _fo.set(_fo.challenger.selector, challenger);\n\n address anchorStateRegistryProxy = IFetcher(permissionedDisputeGameImpl).anchorStateRegistry();\n _fo.set(_fo.anchorStateRegistryProxy.selector, anchorStateRegistryProxy);\n\n address proposer = IFetcher(permissionedDisputeGameImpl).proposer();\n _fo.set(_fo.proposer.selector, proposer);\n\n address delayedWethPermissionedGameProxy = _getDelayedWETHProxy(permissionedDisputeGameImpl);\n _fo.set(_fo.delayedWethPermissionedGameProxy.selector, delayedWethPermissionedGameProxy);\n\n address mipsImpl = IFetcher(permissionedDisputeGameImpl).vm();\n _fo.set(_fo.mipsImpl.selector, mipsImpl);\n\n address preimageOracleImpl = IFetcher(mipsImpl).oracle();\n _fo.set(_fo.preimageOracleImpl.selector, preimageOracleImpl);\n }\n\n address faultDisputeGameImpl = _getFaultDisputeGame(disputeGameFactoryProxy);\n if (faultDisputeGameImpl != address(0)) {\n // permissionless fault proofs installed\n _fo.set(_fo.faultDisputeGameImpl.selector, faultDisputeGameImpl);\n _fo.set(_fo.permissionless.selector, true);\n\n address delayedWethPermissionlessGameProxy = _getDelayedWETHProxy(faultDisputeGameImpl);\n _fo.set(_fo.delayedWethPermissionlessGameProxy.selector, delayedWethPermissionlessGameProxy);\n }\n } else {\n // some older chains have L2OutputOracle instead of DisputeGameFactory.\n address l2OutputOracleProxy = IFetcher(optimismPortalProxy).L2_ORACLE();\n _fo.set(_fo.l2OutputOracleProxy.selector, l2OutputOracleProxy);\n address proposer = IFetcher(l2OutputOracleProxy).PROPOSER();\n _fo.set(_fo.proposer.selector, proposer);\n }\n }\n\n function _getGuardian(address _portal) internal view returns (address) {\n try IFetcher(_portal).guardian() returns (address guardian_) {\n return guardian_;\n } catch {\n return IFetcher(_portal).GUARDIAN();\n }\n }\n\n function _getSystemConfigProxy(address _portal) internal view returns (address) {\n try IFetcher(_portal).systemConfig() returns (address systemConfig_) {\n return systemConfig_;\n } catch {\n return IFetcher(_portal).SYSTEM_CONFIG();\n }\n }\n\n function _getOptimismPortalProxy(address _l1CrossDomainMessengerProxy) internal view returns (address) {\n try IFetcher(_l1CrossDomainMessengerProxy).portal() returns (address optimismPortal_) {\n return optimismPortal_;\n } catch {\n return IFetcher(_l1CrossDomainMessengerProxy).PORTAL();\n }\n }\n\n function _getAddressManager(address _l1CrossDomainMessengerProxy) internal view returns (address) {\n uint256 ADDRESS_MANAGER_MAPPING_SLOT = 1;\n bytes32 slot = keccak256(abi.encode(_l1CrossDomainMessengerProxy, ADDRESS_MANAGER_MAPPING_SLOT));\n return address(uint160(uint256((vm.load(_l1CrossDomainMessengerProxy, slot)))));\n }\n\n function _getL1ERC721BridgeProxy(address _systemConfigProxy) internal view returns (address) {\n try IFetcher(_systemConfigProxy).l1ERC721Bridge() returns (address l1ERC721BridgeProxy_) {\n return l1ERC721BridgeProxy_;\n } catch {\n return address(0);\n }\n }\n\n function _getOptimismMintableERC20FactoryProxy(address _systemConfigProxy) internal view returns (address) {\n try IFetcher(_systemConfigProxy).optimismMintableERC20Factory() returns (\n address optimismMintableERC20FactoryProxy_\n ) {\n return optimismMintableERC20FactoryProxy_;\n } catch {\n return address(0);\n }\n }\n\n function _getDisputeGameFactoryProxy(address _systemConfigProxy) internal view returns (address) {\n try IFetcher(_systemConfigProxy).disputeGameFactory() returns (address disputeGameFactoryProxy_) {\n return disputeGameFactoryProxy_;\n } catch {\n // Some older chains have L2OutputOracle instead of DisputeGameFactory\n return address(0);\n }\n }\n\n function _getSuperchainConfigProxy(address _optimismPortalProxy) internal view returns (address) {\n try IFetcher(_optimismPortalProxy).superchainConfig() returns (address superchainConfigProxy_) {\n return superchainConfigProxy_;\n } catch {\n return address(0);\n }\n }\n\n function _getFaultDisputeGame(address _disputeGameFactoryProxy) internal view returns (address) {\n try IFetcher(_disputeGameFactoryProxy).gameImpls(GameTypes.CANNON) returns (address faultDisputeGame_) {\n return faultDisputeGame_;\n } catch {\n return address(0);\n }\n }\n\n function _getPermissionedDisputeGame(address _disputeGameFactoryProxy) internal view returns (address) {\n try IFetcher(_disputeGameFactoryProxy).gameImpls(GameTypes.PERMISSIONED_CANNON) returns (\n address permissionedDisputeGame_\n ) {\n return permissionedDisputeGame_;\n } catch {\n return address(0);\n }\n }\n\n function _getEthLockboxProxy(address _optimismPortalProxy) internal view returns (address) {\n try IFetcher(_optimismPortalProxy).ethLockbox() returns (address ethLockbox_) {\n return ethLockbox_;\n } catch {\n return address(0);\n }\n }\n\n function _getDelayedWETHProxy(address _disputeGame) internal view returns (address) {\n (bool ok, bytes memory data) = address(_disputeGame).staticcall(abi.encodeCall(IFetcher.weth, ()));\n if (ok && data.length == 32) return abi.decode(data, (address));\n else return address(0);\n }\n\n function _getBatchSubmitter(address _systemConfigProxy) internal view returns (address) {\n bytes32 batcherHash = IFetcher(_systemConfigProxy).batcherHash();\n return address(uint160(uint256(batcherHash)));\n }\n\n function _getProxyAdmin(address _systemConfigProxy) internal returns (address) {\n vm.prank(address(0));\n return IFetcher(_systemConfigProxy).admin();\n }\n}\n","license":"MIT"},"src/dispute/lib/LibPosition.sol":{"keccak256":"0x7c5f19f8f54f06de2ce1c6cdcc5c7af65ac405130a4066cdaf146ca315818241","urls":[],"content":"// SPDX-License-Identifier: MIT\npragma solidity ^0.8.15;\n\nusing LibPosition for Position global;\n\n/// @notice A `Position` represents a position of a claim within the game tree.\n/// @dev This is represented as a \"generalized index\" where the high-order bit\n/// is the level in the tree and the remaining bits is a unique bit pattern, allowing\n/// a unique identifier for each node in the tree. Mathematically, it is calculated\n/// as 2^{depth} + indexAtDepth.\ntype Position is uint128;\n\n/// @title LibPosition\n/// @notice This library contains helper functions for working with the `Position` type.\nlibrary LibPosition {\n /// @notice the `MAX_POSITION_BITLEN` is the number of bits that the `Position` type, and the implementation of\n /// its behavior within this library, can safely support.\n uint8 internal constant MAX_POSITION_BITLEN = 126;\n\n /// @notice Computes a generalized index (2^{depth} + indexAtDepth).\n /// @param _depth The depth of the position.\n /// @param _indexAtDepth The index at the depth of the position.\n /// @return position_ The computed generalized index.\n function wrap(uint8 _depth, uint128 _indexAtDepth) internal pure returns (Position position_) {\n assembly {\n // gindex = 2^{_depth} + _indexAtDepth\n position_ := add(shl(_depth, 1), _indexAtDepth)\n }\n }\n\n /// @notice Pulls the `depth` out of a `Position` type.\n /// @param _position The generalized index to get the `depth` of.\n /// @return depth_ The `depth` of the `position` gindex.\n /// @custom:attribution Solady \n function depth(Position _position) internal pure returns (uint8 depth_) {\n // Return the most significant bit offset, which signifies the depth of the gindex.\n assembly {\n depth_ := or(depth_, shl(6, lt(0xffffffffffffffff, shr(depth_, _position))))\n depth_ := or(depth_, shl(5, lt(0xffffffff, shr(depth_, _position))))\n\n // For the remaining 32 bits, use a De Bruijn lookup.\n _position := shr(depth_, _position)\n _position := or(_position, shr(1, _position))\n _position := or(_position, shr(2, _position))\n _position := or(_position, shr(4, _position))\n _position := or(_position, shr(8, _position))\n _position := or(_position, shr(16, _position))\n\n depth_ :=\n or(\n depth_,\n byte(\n shr(251, mul(_position, shl(224, 0x07c4acdd))),\n 0x0009010a0d15021d0b0e10121619031e080c141c0f111807131b17061a05041f\n )\n )\n }\n }\n\n /// @notice Pulls the `indexAtDepth` out of a `Position` type.\n /// The `indexAtDepth` is the left/right index of a position at a specific depth within\n /// the binary tree, starting from index 0. For example, at gindex 2, the `depth` = 1\n /// and the `indexAtDepth` = 0.\n /// @param _position The generalized index to get the `indexAtDepth` of.\n /// @return indexAtDepth_ The `indexAtDepth` of the `position` gindex.\n function indexAtDepth(Position _position) internal pure returns (uint128 indexAtDepth_) {\n // Return bits p_{msb-1}...p_{0}. This effectively pulls the 2^{depth} out of the gindex,\n // leaving only the `indexAtDepth`.\n uint256 msb = depth(_position);\n assembly {\n indexAtDepth_ := sub(_position, shl(msb, 1))\n }\n }\n\n /// @notice Get the left child of `_position`.\n /// @param _position The position to get the left position of.\n /// @return left_ The position to the left of `position`.\n function left(Position _position) internal pure returns (Position left_) {\n assembly {\n left_ := shl(1, _position)\n }\n }\n\n /// @notice Get the right child of `_position`\n /// @param _position The position to get the right position of.\n /// @return right_ The position to the right of `position`.\n function right(Position _position) internal pure returns (Position right_) {\n assembly {\n right_ := or(1, shl(1, _position))\n }\n }\n\n /// @notice Get the parent position of `_position`.\n /// @param _position The position to get the parent position of.\n /// @return parent_ The parent position of `position`.\n function parent(Position _position) internal pure returns (Position parent_) {\n assembly {\n parent_ := shr(1, _position)\n }\n }\n\n /// @notice Get the deepest, right most gindex relative to the `position`. This is equivalent to\n /// calling `right` on a position until the maximum depth is reached.\n /// @param _position The position to get the relative deepest, right most gindex of.\n /// @param _maxDepth The maximum depth of the game.\n /// @return rightIndex_ The deepest, right most gindex relative to the `position`.\n function rightIndex(Position _position, uint256 _maxDepth) internal pure returns (Position rightIndex_) {\n uint256 msb = depth(_position);\n assembly {\n let remaining := sub(_maxDepth, msb)\n rightIndex_ := or(shl(remaining, _position), sub(shl(remaining, 1), 1))\n }\n }\n\n /// @notice Get the deepest, right most trace index relative to the `position`. This is\n /// equivalent to calling `right` on a position until the maximum depth is reached and\n /// then finding its index at depth.\n /// @param _position The position to get the relative trace index of.\n /// @param _maxDepth The maximum depth of the game.\n /// @return traceIndex_ The trace index relative to the `position`.\n function traceIndex(Position _position, uint256 _maxDepth) internal pure returns (uint256 traceIndex_) {\n uint256 msb = depth(_position);\n assembly {\n let remaining := sub(_maxDepth, msb)\n traceIndex_ := sub(or(shl(remaining, _position), sub(shl(remaining, 1), 1)), shl(_maxDepth, 1))\n }\n }\n\n /// @notice Gets the position of the highest ancestor of `_position` that commits to the same\n /// trace index.\n /// @param _position The position to get the highest ancestor of.\n /// @return ancestor_ The highest ancestor of `position` that commits to the same trace index.\n function traceAncestor(Position _position) internal pure returns (Position ancestor_) {\n // Create a field with only the lowest unset bit of `_position` set.\n Position lsb;\n assembly {\n lsb := and(not(_position), add(_position, 1))\n }\n // Find the index of the lowest unset bit within the field.\n uint256 msb = depth(lsb);\n // The highest ancestor that commits to the same trace index is the original position\n // shifted right by the index of the lowest unset bit.\n assembly {\n let a := shr(msb, _position)\n // Bound the ancestor to the minimum gindex, 1.\n ancestor_ := or(a, iszero(a))\n }\n }\n\n /// @notice Gets the position of the highest ancestor of `_position` that commits to the same\n /// trace index, while still being below `_upperBoundExclusive`.\n /// @param _position The position to get the highest ancestor of.\n /// @param _upperBoundExclusive The exclusive upper depth bound, used to inform where to stop in order\n /// to not escape a sub-tree.\n /// @return ancestor_ The highest ancestor of `position` that commits to the same trace index.\n function traceAncestorBounded(\n Position _position,\n uint256 _upperBoundExclusive\n )\n internal\n pure\n returns (Position ancestor_)\n {\n // This function only works for positions that are below the upper bound.\n if (_position.depth() <= _upperBoundExclusive) {\n assembly {\n // Revert with `ClaimAboveSplit()`\n mstore(0x00, 0xb34b5c22)\n revert(0x1C, 0x04)\n }\n }\n\n // Grab the global trace ancestor.\n ancestor_ = traceAncestor(_position);\n\n // If the ancestor is above or at the upper bound, shift it to be below the upper bound.\n // This should be a special case that only covers positions that commit to the final leaf\n // in a sub-tree.\n if (ancestor_.depth() <= _upperBoundExclusive) {\n ancestor_ = ancestor_.rightIndex(_upperBoundExclusive + 1);\n }\n }\n\n /// @notice Get the move position of `_position`, which is the left child of:\n /// 1. `_position` if `_isAttack` is true.\n /// 2. `_position | 1` if `_isAttack` is false.\n /// @param _position The position to get the relative attack/defense position of.\n /// @param _isAttack Whether or not the move is an attack move.\n /// @return move_ The move position relative to `position`.\n function move(Position _position, bool _isAttack) internal pure returns (Position move_) {\n assembly {\n move_ := shl(1, or(iszero(_isAttack), _position))\n }\n }\n\n /// @notice Get the value of a `Position` type in the form of the underlying uint128.\n /// @param _position The position to get the value of.\n /// @return raw_ The value of the `position` as a uint128 type.\n function raw(Position _position) internal pure returns (uint128 raw_) {\n assembly {\n raw_ := _position\n }\n }\n}\n","license":"MIT"},"src/dispute/lib/LibUDT.sol":{"keccak256":"0x41d55e9c74d979b5b797198e38449e7cef4f925e04d61f7699e9c150c4a659d3","urls":[],"content":"// SPDX-License-Identifier: MIT\npragma solidity ^0.8.15;\n\n// Libraries\nimport { Position } from \"src/dispute/lib/LibPosition.sol\";\n\nusing LibClaim for Claim global;\nusing LibHash for Hash global;\nusing LibDuration for Duration global;\nusing LibClock for Clock global;\nusing LibGameId for GameId global;\nusing LibTimestamp for Timestamp global;\nusing LibVMStatus for VMStatus global;\nusing LibGameType for GameType global;\n\n/// @notice A `Clock` represents a packed `Duration` and `Timestamp`\n/// @dev The packed layout of this type is as follows:\n/// ┌────────────┬────────────────┐\n/// │ Bits │ Value │\n/// ├────────────┼────────────────┤\n/// │ [0, 64) │ Duration │\n/// │ [64, 128) │ Timestamp │\n/// └────────────┴────────────────┘\ntype Clock is uint128;\n\n/// @title LibClock\n/// @notice This library contains helper functions for working with the `Clock` type.\nlibrary LibClock {\n /// @notice Packs a `Duration` and `Timestamp` into a `Clock` type.\n /// @param _duration The `Duration` to pack into the `Clock` type.\n /// @param _timestamp The `Timestamp` to pack into the `Clock` type.\n /// @return clock_ The `Clock` containing the `_duration` and `_timestamp`.\n function wrap(Duration _duration, Timestamp _timestamp) internal pure returns (Clock clock_) {\n assembly {\n clock_ := or(shl(0x40, _duration), _timestamp)\n }\n }\n\n /// @notice Pull the `Duration` out of a `Clock` type.\n /// @param _clock The `Clock` type to pull the `Duration` out of.\n /// @return duration_ The `Duration` pulled out of `_clock`.\n function duration(Clock _clock) internal pure returns (Duration duration_) {\n // Shift the high-order 64 bits into the low-order 64 bits, leaving only the `duration`.\n assembly {\n duration_ := shr(0x40, _clock)\n }\n }\n\n /// @notice Pull the `Timestamp` out of a `Clock` type.\n /// @param _clock The `Clock` type to pull the `Timestamp` out of.\n /// @return timestamp_ The `Timestamp` pulled out of `_clock`.\n function timestamp(Clock _clock) internal pure returns (Timestamp timestamp_) {\n // Clean the high-order 192 bits by shifting the clock left and then right again, leaving\n // only the `timestamp`.\n assembly {\n timestamp_ := shr(0xC0, shl(0xC0, _clock))\n }\n }\n\n /// @notice Get the value of a `Clock` type in the form of the underlying uint128.\n /// @param _clock The `Clock` type to get the value of.\n /// @return clock_ The value of the `Clock` type as a uint128 type.\n function raw(Clock _clock) internal pure returns (uint128 clock_) {\n assembly {\n clock_ := _clock\n }\n }\n}\n\n/// @notice A `GameId` represents a packed 4 byte game ID, a 8 byte timestamp, and a 20 byte address.\n/// @dev The packed layout of this type is as follows:\n/// ┌───────────┬───────────┐\n/// │ Bits │ Value │\n/// ├───────────┼───────────┤\n/// │ [0, 32) │ Game Type │\n/// │ [32, 96) │ Timestamp │\n/// │ [96, 256) │ Address │\n/// └───────────┴───────────┘\ntype GameId is bytes32;\n\n/// @title LibGameId\n/// @notice Utility functions for packing and unpacking GameIds.\nlibrary LibGameId {\n /// @notice Packs values into a 32 byte GameId type.\n /// @param _gameType The game type.\n /// @param _timestamp The timestamp of the game's creation.\n /// @param _gameProxy The game proxy address.\n /// @return gameId_ The packed GameId.\n function pack(\n GameType _gameType,\n Timestamp _timestamp,\n address _gameProxy\n )\n internal\n pure\n returns (GameId gameId_)\n {\n assembly {\n gameId_ := or(or(shl(224, _gameType), shl(160, _timestamp)), _gameProxy)\n }\n }\n\n /// @notice Unpacks values from a 32 byte GameId type.\n /// @param _gameId The packed GameId.\n /// @return gameType_ The game type.\n /// @return timestamp_ The timestamp of the game's creation.\n /// @return gameProxy_ The game proxy address.\n function unpack(GameId _gameId)\n internal\n pure\n returns (GameType gameType_, Timestamp timestamp_, address gameProxy_)\n {\n assembly {\n gameType_ := shr(224, _gameId)\n timestamp_ := and(shr(160, _gameId), 0xFFFFFFFFFFFFFFFF)\n gameProxy_ := and(_gameId, 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF)\n }\n }\n}\n\n/// @notice A claim represents an MPT root representing the state of the fault proof program.\ntype Claim is bytes32;\n\n/// @title LibClaim\n/// @notice This library contains helper functions for working with the `Claim` type.\nlibrary LibClaim {\n /// @notice Get the value of a `Claim` type in the form of the underlying bytes32.\n /// @param _claim The `Claim` type to get the value of.\n /// @return claim_ The value of the `Claim` type as a bytes32 type.\n function raw(Claim _claim) internal pure returns (bytes32 claim_) {\n assembly {\n claim_ := _claim\n }\n }\n\n /// @notice Hashes a claim and a position together.\n /// @param _claim A Claim type.\n /// @param _position The position of `claim`.\n /// @param _challengeIndex The index of the claim being moved against.\n /// @return claimHash_ A hash of abi.encodePacked(claim, position|challengeIndex);\n function hashClaimPos(\n Claim _claim,\n Position _position,\n uint256 _challengeIndex\n )\n internal\n pure\n returns (Hash claimHash_)\n {\n assembly {\n mstore(0x00, _claim)\n mstore(0x20, or(shl(128, _position), and(0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF, _challengeIndex)))\n claimHash_ := keccak256(0x00, 0x40)\n }\n }\n}\n\n/// @notice A dedicated duration type.\n/// @dev Unit: seconds\ntype Duration is uint64;\n\n/// @title LibDuration\n/// @notice This library contains helper functions for working with the `Duration` type.\nlibrary LibDuration {\n /// @notice Get the value of a `Duration` type in the form of the underlying uint64.\n /// @param _duration The `Duration` type to get the value of.\n /// @return duration_ The value of the `Duration` type as a uint64 type.\n function raw(Duration _duration) internal pure returns (uint64 duration_) {\n assembly {\n duration_ := _duration\n }\n }\n}\n\n/// @notice A custom type for a generic hash.\ntype Hash is bytes32;\n\n/// @title LibHash\n/// @notice This library contains helper functions for working with the `Hash` type.\nlibrary LibHash {\n /// @notice Get the value of a `Hash` type in the form of the underlying bytes32.\n /// @param _hash The `Hash` type to get the value of.\n /// @return hash_ The value of the `Hash` type as a bytes32 type.\n function raw(Hash _hash) internal pure returns (bytes32 hash_) {\n assembly {\n hash_ := _hash\n }\n }\n}\n\n/// @notice A dedicated timestamp type.\ntype Timestamp is uint64;\n\n/// @title LibTimestamp\n/// @notice This library contains helper functions for working with the `Timestamp` type.\nlibrary LibTimestamp {\n /// @notice Get the value of a `Timestamp` type in the form of the underlying uint64.\n /// @param _timestamp The `Timestamp` type to get the value of.\n /// @return timestamp_ The value of the `Timestamp` type as a uint64 type.\n function raw(Timestamp _timestamp) internal pure returns (uint64 timestamp_) {\n assembly {\n timestamp_ := _timestamp\n }\n }\n}\n\n/// @notice A `VMStatus` represents the status of a VM execution.\ntype VMStatus is uint8;\n\n/// @title LibVMStatus\n/// @notice This library contains helper functions for working with the `VMStatus` type.\nlibrary LibVMStatus {\n /// @notice Get the value of a `VMStatus` type in the form of the underlying uint8.\n /// @param _vmstatus The `VMStatus` type to get the value of.\n /// @return vmstatus_ The value of the `VMStatus` type as a uint8 type.\n function raw(VMStatus _vmstatus) internal pure returns (uint8 vmstatus_) {\n assembly {\n vmstatus_ := _vmstatus\n }\n }\n}\n\n/// @notice A `GameType` represents the type of game being played.\ntype GameType is uint32;\n\n/// @title LibGameType\n/// @notice This library contains helper functions for working with the `GameType` type.\nlibrary LibGameType {\n /// @notice Get the value of a `GameType` type in the form of the underlying uint32.\n /// @param _gametype The `GameType` type to get the value of.\n /// @return gametype_ The value of the `GameType` type as a uint32 type.\n function raw(GameType _gametype) internal pure returns (uint32 gametype_) {\n assembly {\n gametype_ := _gametype\n }\n }\n}\n","license":"MIT"},"src/dispute/lib/Types.sol":{"keccak256":"0x7cc2960ea5c5223d81ae2156a966fa0226b70f9666932aca63a0a2a45c9182ae","urls":[],"content":"// SPDX-License-Identifier: MIT\npragma solidity ^0.8.15;\n\n// Libraries\nimport {\n Position,\n Hash,\n GameType,\n VMStatus,\n Timestamp,\n Duration,\n Clock,\n GameId,\n Claim,\n LibGameId,\n LibClock\n} from \"src/dispute/lib/LibUDT.sol\";\n\n/// @notice The current status of the dispute game.\nenum GameStatus {\n // The game is currently in progress, and has not been resolved.\n IN_PROGRESS,\n // The game has concluded, and the `rootClaim` was challenged successfully.\n CHALLENGER_WINS,\n // The game has concluded, and the `rootClaim` could not be contested.\n DEFENDER_WINS\n}\n\n/// @notice The game's bond distribution type. Games are expected to start in the `UNDECIDED`\n/// state, and then choose either `NORMAL` or `REFUND`.\nenum BondDistributionMode {\n // Bond distribution strategy has not been chosen.\n UNDECIDED,\n // Bonds should be distributed as normal.\n NORMAL,\n // Bonds should be refunded to claimants.\n REFUND\n}\n\n/// @notice Represents an L2 root and the L2 sequence number at which it was generated.\n/// @custom:field root The output root.\n/// @custom:field l2SequenceNumber The L2 Sequence Number ( e.g. block number / timestamp) at which the root was\n/// generated.\nstruct Proposal {\n Hash root;\n uint256 l2SequenceNumber;\n}\n\n/// @title GameTypes\n/// @notice A library that defines the IDs of games that can be played.\nlibrary GameTypes {\n /// @dev A dispute game type the uses the cannon vm.\n GameType internal constant CANNON = GameType.wrap(0);\n\n /// @dev A permissioned dispute game type that uses the cannon vm.\n GameType internal constant PERMISSIONED_CANNON = GameType.wrap(1);\n\n /// @notice A dispute game type that uses the asterisc vm.\n GameType internal constant ASTERISC = GameType.wrap(2);\n\n /// @notice A dispute game type that uses the asterisc vm with Kona.\n GameType internal constant ASTERISC_KONA = GameType.wrap(3);\n\n /// @notice A dispute game type that uses the cannon vm (Super Roots).\n GameType internal constant SUPER_CANNON = GameType.wrap(4);\n\n /// @notice A dispute game type that uses the permissioned cannon vm (Super Roots).\n GameType internal constant SUPER_PERMISSIONED_CANNON = GameType.wrap(5);\n\n /// @notice A dispute game type that uses OP Succinct\n GameType internal constant OP_SUCCINCT = GameType.wrap(6);\n\n /// @notice A dispute game type with short game duration for testing withdrawals.\n /// Not intended for production use.\n GameType internal constant FAST = GameType.wrap(254);\n\n /// @notice A dispute game type that uses an alphabet vm.\n /// Not intended for production use.\n GameType internal constant ALPHABET = GameType.wrap(255);\n\n /// @notice A dispute game type that uses RISC Zero's Kailua\n GameType internal constant KAILUA = GameType.wrap(1337);\n}\n\n/// @title VMStatuses\n/// @notice Named type aliases for the various valid VM status bytes.\nlibrary VMStatuses {\n /// @notice The VM has executed successfully and the outcome is valid.\n VMStatus internal constant VALID = VMStatus.wrap(0);\n\n /// @notice The VM has executed successfully and the outcome is invalid.\n VMStatus internal constant INVALID = VMStatus.wrap(1);\n\n /// @notice The VM has paniced.\n VMStatus internal constant PANIC = VMStatus.wrap(2);\n\n /// @notice The VM execution is still in progress.\n VMStatus internal constant UNFINISHED = VMStatus.wrap(3);\n}\n\n/// @title LocalPreimageKey\n/// @notice Named type aliases for local `PreimageOracle` key identifiers.\nlibrary LocalPreimageKey {\n /// @notice The identifier for the L1 head hash.\n uint256 internal constant L1_HEAD_HASH = 0x01;\n\n /// @notice The identifier for the starting output root.\n uint256 internal constant STARTING_OUTPUT_ROOT = 0x02;\n\n /// @notice The identifier for the disputed output root.\n uint256 internal constant DISPUTED_OUTPUT_ROOT = 0x03;\n\n /// @notice The identifier for the disputed L2 block number.\n uint256 internal constant DISPUTED_L2_BLOCK_NUMBER = 0x04;\n\n /// @notice The identifier for the chain ID.\n uint256 internal constant CHAIN_ID = 0x05;\n}\n","license":"MIT"}},"version":1},"storageLayout":{"storage":[{"astId":5983,"contract":"scripts/FetchChainInfo.s.sol:FetchChainInfo","label":"stdstore","offset":0,"slot":"0","type":"t_struct(StdStorage)14021_storage"},{"astId":8682,"contract":"scripts/FetchChainInfo.s.sol:FetchChainInfo","label":"stdChainsInitialized","offset":0,"slot":"8","type":"t_bool"},{"astId":8703,"contract":"scripts/FetchChainInfo.s.sol:FetchChainInfo","label":"chains","offset":0,"slot":"9","type":"t_mapping(t_string_memory_ptr,t_struct(Chain)8698_storage)"},{"astId":8707,"contract":"scripts/FetchChainInfo.s.sol:FetchChainInfo","label":"defaultRpcUrls","offset":0,"slot":"10","type":"t_mapping(t_string_memory_ptr,t_string_storage)"},{"astId":8711,"contract":"scripts/FetchChainInfo.s.sol:FetchChainInfo","label":"idToAlias","offset":0,"slot":"11","type":"t_mapping(t_uint256,t_string_storage)"},{"astId":8714,"contract":"scripts/FetchChainInfo.s.sol:FetchChainInfo","label":"fallbackToDefaultRpcUrls","offset":0,"slot":"12","type":"t_bool"},{"astId":9643,"contract":"scripts/FetchChainInfo.s.sol:FetchChainInfo","label":"gasMeteringOff","offset":1,"slot":"12","type":"t_bool"},{"astId":6036,"contract":"scripts/FetchChainInfo.s.sol:FetchChainInfo","label":"IS_SCRIPT","offset":2,"slot":"12","type":"t_bool"}],"types":{"t_address":{"encoding":"inplace","label":"address","numberOfBytes":"20"},"t_array(t_bytes32)dyn_storage":{"encoding":"dynamic_array","label":"bytes32[]","numberOfBytes":"32","base":"t_bytes32"},"t_bool":{"encoding":"inplace","label":"bool","numberOfBytes":"1"},"t_bytes32":{"encoding":"inplace","label":"bytes32","numberOfBytes":"32"},"t_bytes4":{"encoding":"inplace","label":"bytes4","numberOfBytes":"4"},"t_bytes_storage":{"encoding":"bytes","label":"bytes","numberOfBytes":"32"},"t_mapping(t_address,t_mapping(t_bytes4,t_mapping(t_bytes32,t_struct(FindData)13996_storage)))":{"encoding":"mapping","key":"t_address","label":"mapping(address => mapping(bytes4 => mapping(bytes32 => struct FindData)))","numberOfBytes":"32","value":"t_mapping(t_bytes4,t_mapping(t_bytes32,t_struct(FindData)13996_storage))"},"t_mapping(t_bytes32,t_struct(FindData)13996_storage)":{"encoding":"mapping","key":"t_bytes32","label":"mapping(bytes32 => struct FindData)","numberOfBytes":"32","value":"t_struct(FindData)13996_storage"},"t_mapping(t_bytes4,t_mapping(t_bytes32,t_struct(FindData)13996_storage))":{"encoding":"mapping","key":"t_bytes4","label":"mapping(bytes4 => mapping(bytes32 => struct FindData))","numberOfBytes":"32","value":"t_mapping(t_bytes32,t_struct(FindData)13996_storage)"},"t_mapping(t_string_memory_ptr,t_string_storage)":{"encoding":"mapping","key":"t_string_memory_ptr","label":"mapping(string => string)","numberOfBytes":"32","value":"t_string_storage"},"t_mapping(t_string_memory_ptr,t_struct(Chain)8698_storage)":{"encoding":"mapping","key":"t_string_memory_ptr","label":"mapping(string => struct StdChains.Chain)","numberOfBytes":"32","value":"t_struct(Chain)8698_storage"},"t_mapping(t_uint256,t_string_storage)":{"encoding":"mapping","key":"t_uint256","label":"mapping(uint256 => string)","numberOfBytes":"32","value":"t_string_storage"},"t_string_memory_ptr":{"encoding":"bytes","label":"string","numberOfBytes":"32"},"t_string_storage":{"encoding":"bytes","label":"string","numberOfBytes":"32"},"t_struct(Chain)8698_storage":{"encoding":"inplace","label":"struct StdChains.Chain","numberOfBytes":"128","members":[{"astId":8691,"contract":"scripts/FetchChainInfo.s.sol:FetchChainInfo","label":"name","offset":0,"slot":"0","type":"t_string_storage"},{"astId":8693,"contract":"scripts/FetchChainInfo.s.sol:FetchChainInfo","label":"chainId","offset":0,"slot":"1","type":"t_uint256"},{"astId":8695,"contract":"scripts/FetchChainInfo.s.sol:FetchChainInfo","label":"chainAlias","offset":0,"slot":"2","type":"t_string_storage"},{"astId":8697,"contract":"scripts/FetchChainInfo.s.sol:FetchChainInfo","label":"rpcUrl","offset":0,"slot":"3","type":"t_string_storage"}]},"t_struct(FindData)13996_storage":{"encoding":"inplace","label":"struct FindData","numberOfBytes":"128","members":[{"astId":13989,"contract":"scripts/FetchChainInfo.s.sol:FetchChainInfo","label":"slot","offset":0,"slot":"0","type":"t_uint256"},{"astId":13991,"contract":"scripts/FetchChainInfo.s.sol:FetchChainInfo","label":"offsetLeft","offset":0,"slot":"1","type":"t_uint256"},{"astId":13993,"contract":"scripts/FetchChainInfo.s.sol:FetchChainInfo","label":"offsetRight","offset":0,"slot":"2","type":"t_uint256"},{"astId":13995,"contract":"scripts/FetchChainInfo.s.sol:FetchChainInfo","label":"found","offset":0,"slot":"3","type":"t_bool"}]},"t_struct(StdStorage)14021_storage":{"encoding":"inplace","label":"struct StdStorage","numberOfBytes":"256","members":[{"astId":14005,"contract":"scripts/FetchChainInfo.s.sol:FetchChainInfo","label":"finds","offset":0,"slot":"0","type":"t_mapping(t_address,t_mapping(t_bytes4,t_mapping(t_bytes32,t_struct(FindData)13996_storage)))"},{"astId":14008,"contract":"scripts/FetchChainInfo.s.sol:FetchChainInfo","label":"_keys","offset":0,"slot":"1","type":"t_array(t_bytes32)dyn_storage"},{"astId":14010,"contract":"scripts/FetchChainInfo.s.sol:FetchChainInfo","label":"_sig","offset":0,"slot":"2","type":"t_bytes4"},{"astId":14012,"contract":"scripts/FetchChainInfo.s.sol:FetchChainInfo","label":"_depth","offset":0,"slot":"3","type":"t_uint256"},{"astId":14014,"contract":"scripts/FetchChainInfo.s.sol:FetchChainInfo","label":"_target","offset":0,"slot":"4","type":"t_address"},{"astId":14016,"contract":"scripts/FetchChainInfo.s.sol:FetchChainInfo","label":"_set","offset":0,"slot":"5","type":"t_bytes32"},{"astId":14018,"contract":"scripts/FetchChainInfo.s.sol:FetchChainInfo","label":"_enable_packed_slots","offset":0,"slot":"6","type":"t_bool"},{"astId":14020,"contract":"scripts/FetchChainInfo.s.sol:FetchChainInfo","label":"_calldata","offset":0,"slot":"7","type":"t_bytes_storage"}]},"t_uint256":{"encoding":"inplace","label":"uint256","numberOfBytes":"32"}}},"userdoc":{"version":1,"kind":"user"},"devdoc":{"version":1,"kind":"dev"},"ast":{"absolutePath":"scripts/FetchChainInfo.s.sol","id":59300,"exportedSymbols":{"FetchChainInfo":[59299],"FetchChainInfoInput":[57409],"FetchChainInfoOutput":[58249],"GameType":[75355],"GameTypes":[75481],"IFetcher":[57326],"Script":[6037]},"nodeType":"SourceUnit","src":"32:23957:120","nodes":[{"id":57175,"nodeType":"PragmaDirective","src":"32:23:120","nodes":[],"literals":["solidity","^","0.8",".0"]},{"id":57177,"nodeType":"ImportDirective","src":"57:46:120","nodes":[],"absolutePath":"lib/forge-std/src/Script.sol","file":"forge-std/Script.sol","nameLocation":"-1:-1:-1","scope":59300,"sourceUnit":6038,"symbolAliases":[{"foreign":{"id":57176,"name":"Script","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":6037,"src":"66:6:120","typeDescriptions":{}},"nameLocation":"-1:-1:-1"}],"unitAlias":""},{"id":57180,"nodeType":"ImportDirective","src":"104:64:120","nodes":[],"absolutePath":"src/dispute/lib/Types.sol","file":"src/dispute/lib/Types.sol","nameLocation":"-1:-1:-1","scope":59300,"sourceUnit":75538,"symbolAliases":[{"foreign":{"id":57178,"name":"GameTypes","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":75481,"src":"113:9:120","typeDescriptions":{}},"nameLocation":"-1:-1:-1"},{"foreign":{"id":57179,"name":"GameType","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":75355,"src":"124:8:120","typeDescriptions":{}},"nameLocation":"-1:-1:-1"}],"unitAlias":""},{"id":57326,"nodeType":"ContractDefinition","src":"306:1713:120","nodes":[{"id":57186,"nodeType":"FunctionDefinition","src":"331:52:120","nodes":[],"functionSelector":"452a9320","implemented":false,"kind":"function","modifiers":[],"name":"guardian","nameLocation":"340:8:120","parameters":{"id":57182,"nodeType":"ParameterList","parameters":[],"src":"348:2:120"},"returnParameters":{"id":57185,"nodeType":"ParameterList","parameters":[{"constant":false,"id":57184,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":57186,"src":"374:7:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":57183,"name":"address","nodeType":"ElementaryTypeName","src":"374:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"373:9:120"},"scope":57326,"stateMutability":"view","virtual":false,"visibility":"external"},{"id":57191,"nodeType":"FunctionDefinition","src":"388:52:120","nodes":[],"functionSelector":"724c184c","implemented":false,"kind":"function","modifiers":[],"name":"GUARDIAN","nameLocation":"397:8:120","parameters":{"id":57187,"nodeType":"ParameterList","parameters":[],"src":"405:2:120"},"returnParameters":{"id":57190,"nodeType":"ParameterList","parameters":[{"constant":false,"id":57189,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":57191,"src":"431:7:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":57188,"name":"address","nodeType":"ElementaryTypeName","src":"431:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"430:9:120"},"scope":57326,"stateMutability":"view","virtual":false,"visibility":"external"},{"id":57196,"nodeType":"FunctionDefinition","src":"445:56:120","nodes":[],"functionSelector":"33d7e2bd","implemented":false,"kind":"function","modifiers":[],"name":"systemConfig","nameLocation":"454:12:120","parameters":{"id":57192,"nodeType":"ParameterList","parameters":[],"src":"466:2:120"},"returnParameters":{"id":57195,"nodeType":"ParameterList","parameters":[{"constant":false,"id":57194,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":57196,"src":"492:7:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":57193,"name":"address","nodeType":"ElementaryTypeName","src":"492:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"491:9:120"},"scope":57326,"stateMutability":"view","virtual":false,"visibility":"external"},{"id":57201,"nodeType":"FunctionDefinition","src":"506:57:120","nodes":[],"functionSelector":"f0498750","implemented":false,"kind":"function","modifiers":[],"name":"SYSTEM_CONFIG","nameLocation":"515:13:120","parameters":{"id":57197,"nodeType":"ParameterList","parameters":[],"src":"528:2:120"},"returnParameters":{"id":57200,"nodeType":"ParameterList","parameters":[{"constant":false,"id":57199,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":57201,"src":"554:7:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":57198,"name":"address","nodeType":"ElementaryTypeName","src":"554:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"553:9:120"},"scope":57326,"stateMutability":"view","virtual":false,"visibility":"external"},{"id":57206,"nodeType":"FunctionDefinition","src":"568:62:120","nodes":[],"functionSelector":"f2b4e617","implemented":false,"kind":"function","modifiers":[],"name":"disputeGameFactory","nameLocation":"577:18:120","parameters":{"id":57202,"nodeType":"ParameterList","parameters":[],"src":"595:2:120"},"returnParameters":{"id":57205,"nodeType":"ParameterList","parameters":[{"constant":false,"id":57204,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":57206,"src":"621:7:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":57203,"name":"address","nodeType":"ElementaryTypeName","src":"621:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"620:9:120"},"scope":57326,"stateMutability":"view","virtual":false,"visibility":"external"},{"id":57211,"nodeType":"FunctionDefinition","src":"635:54:120","nodes":[],"functionSelector":"b682c444","implemented":false,"kind":"function","modifiers":[],"name":"ethLockbox","nameLocation":"644:10:120","parameters":{"id":57207,"nodeType":"ParameterList","parameters":[],"src":"654:2:120"},"returnParameters":{"id":57210,"nodeType":"ParameterList","parameters":[{"constant":false,"id":57209,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":57211,"src":"680:7:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":57208,"name":"address","nodeType":"ElementaryTypeName","src":"680:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"679:9:120"},"scope":57326,"stateMutability":"view","virtual":false,"visibility":"external"},{"id":57216,"nodeType":"FunctionDefinition","src":"694:60:120","nodes":[],"functionSelector":"35e80ab3","implemented":false,"kind":"function","modifiers":[],"name":"superchainConfig","nameLocation":"703:16:120","parameters":{"id":57212,"nodeType":"ParameterList","parameters":[],"src":"719:2:120"},"returnParameters":{"id":57215,"nodeType":"ParameterList","parameters":[{"constant":false,"id":57214,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":57216,"src":"745:7:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":57213,"name":"address","nodeType":"ElementaryTypeName","src":"745:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"744:9:120"},"scope":57326,"stateMutability":"view","virtual":false,"visibility":"external"},{"id":57221,"nodeType":"FunctionDefinition","src":"759:53:120","nodes":[],"functionSelector":"3cb747bf","implemented":false,"kind":"function","modifiers":[],"name":"messenger","nameLocation":"768:9:120","parameters":{"id":57217,"nodeType":"ParameterList","parameters":[],"src":"777:2:120"},"returnParameters":{"id":57220,"nodeType":"ParameterList","parameters":[{"constant":false,"id":57219,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":57221,"src":"803:7:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":57218,"name":"address","nodeType":"ElementaryTypeName","src":"803:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"802:9:120"},"scope":57326,"stateMutability":"view","virtual":false,"visibility":"external"},{"id":57226,"nodeType":"FunctionDefinition","src":"817:58:120","nodes":[],"functionSelector":"3ab76e9f","implemented":false,"kind":"function","modifiers":[],"name":"addressManager","nameLocation":"826:14:120","parameters":{"id":57222,"nodeType":"ParameterList","parameters":[],"src":"840:2:120"},"returnParameters":{"id":57225,"nodeType":"ParameterList","parameters":[{"constant":false,"id":57224,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":57226,"src":"866:7:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":57223,"name":"address","nodeType":"ElementaryTypeName","src":"866:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"865:9:120"},"scope":57326,"stateMutability":"view","virtual":false,"visibility":"external"},{"id":57231,"nodeType":"FunctionDefinition","src":"880:50:120","nodes":[],"functionSelector":"0ff754ea","implemented":false,"kind":"function","modifiers":[],"name":"PORTAL","nameLocation":"889:6:120","parameters":{"id":57227,"nodeType":"ParameterList","parameters":[],"src":"895:2:120"},"returnParameters":{"id":57230,"nodeType":"ParameterList","parameters":[{"constant":false,"id":57229,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":57231,"src":"921:7:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":57228,"name":"address","nodeType":"ElementaryTypeName","src":"921:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"920:9:120"},"scope":57326,"stateMutability":"view","virtual":false,"visibility":"external"},{"id":57236,"nodeType":"FunctionDefinition","src":"935:50:120","nodes":[],"functionSelector":"6425666b","implemented":false,"kind":"function","modifiers":[],"name":"portal","nameLocation":"944:6:120","parameters":{"id":57232,"nodeType":"ParameterList","parameters":[],"src":"950:2:120"},"returnParameters":{"id":57235,"nodeType":"ParameterList","parameters":[{"constant":false,"id":57234,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":57236,"src":"976:7:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":57233,"name":"address","nodeType":"ElementaryTypeName","src":"976:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"975:9:120"},"scope":57326,"stateMutability":"view","virtual":false,"visibility":"external"},{"id":57241,"nodeType":"FunctionDefinition","src":"990:58:120","nodes":[],"functionSelector":"c4e8ddfa","implemented":false,"kind":"function","modifiers":[],"name":"l1ERC721Bridge","nameLocation":"999:14:120","parameters":{"id":57237,"nodeType":"ParameterList","parameters":[],"src":"1013:2:120"},"returnParameters":{"id":57240,"nodeType":"ParameterList","parameters":[{"constant":false,"id":57239,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":57241,"src":"1039:7:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":57238,"name":"address","nodeType":"ElementaryTypeName","src":"1039:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"1038:9:120"},"scope":57326,"stateMutability":"view","virtual":false,"visibility":"external"},{"id":57246,"nodeType":"FunctionDefinition","src":"1053:72:120","nodes":[],"functionSelector":"9b7d7f0a","implemented":false,"kind":"function","modifiers":[],"name":"optimismMintableERC20Factory","nameLocation":"1062:28:120","parameters":{"id":57242,"nodeType":"ParameterList","parameters":[],"src":"1090:2:120"},"returnParameters":{"id":57245,"nodeType":"ParameterList","parameters":[{"constant":false,"id":57244,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":57246,"src":"1116:7:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":57243,"name":"address","nodeType":"ElementaryTypeName","src":"1116:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"1115:9:120"},"scope":57326,"stateMutability":"view","virtual":false,"visibility":"external"},{"id":57254,"nodeType":"FunctionDefinition","src":"1130:71:120","nodes":[],"functionSelector":"1b685b9e","implemented":false,"kind":"function","modifiers":[],"name":"gameImpls","nameLocation":"1139:9:120","parameters":{"id":57250,"nodeType":"ParameterList","parameters":[{"constant":false,"id":57249,"mutability":"mutable","name":"_gameType","nameLocation":"1158:9:120","nodeType":"VariableDeclaration","scope":57254,"src":"1149:18:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_userDefinedValueType$_GameType_$75355","typeString":"GameType"},"typeName":{"id":57248,"nodeType":"UserDefinedTypeName","pathNode":{"id":57247,"name":"GameType","nameLocations":["1149:8:120"],"nodeType":"IdentifierPath","referencedDeclaration":75355,"src":"1149:8:120"},"referencedDeclaration":75355,"src":"1149:8:120","typeDescriptions":{"typeIdentifier":"t_userDefinedValueType$_GameType_$75355","typeString":"GameType"}},"visibility":"internal"}],"src":"1148:20:120"},"returnParameters":{"id":57253,"nodeType":"ParameterList","parameters":[{"constant":false,"id":57252,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":57254,"src":"1192:7:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":57251,"name":"address","nodeType":"ElementaryTypeName","src":"1192:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"1191:9:120"},"scope":57326,"stateMutability":"view","virtual":false,"visibility":"external"},{"id":57260,"nodeType":"FunctionDefinition","src":"1206:62:120","nodes":[],"functionSelector":"3c9f397c","implemented":false,"kind":"function","modifiers":[],"name":"respectedGameType","nameLocation":"1215:17:120","parameters":{"id":57255,"nodeType":"ParameterList","parameters":[],"src":"1232:2:120"},"returnParameters":{"id":57259,"nodeType":"ParameterList","parameters":[{"constant":false,"id":57258,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":57260,"src":"1258:8:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_userDefinedValueType$_GameType_$75355","typeString":"GameType"},"typeName":{"id":57257,"nodeType":"UserDefinedTypeName","pathNode":{"id":57256,"name":"GameType","nameLocations":["1258:8:120"],"nodeType":"IdentifierPath","referencedDeclaration":75355,"src":"1258:8:120"},"referencedDeclaration":75355,"src":"1258:8:120","typeDescriptions":{"typeIdentifier":"t_userDefinedValueType$_GameType_$75355","typeString":"GameType"}},"visibility":"internal"}],"src":"1257:10:120"},"scope":57326,"stateMutability":"view","virtual":false,"visibility":"external"},{"id":57265,"nodeType":"FunctionDefinition","src":"1273:63:120","nodes":[],"functionSelector":"5c0cba33","implemented":false,"kind":"function","modifiers":[],"name":"anchorStateRegistry","nameLocation":"1282:19:120","parameters":{"id":57261,"nodeType":"ParameterList","parameters":[],"src":"1301:2:120"},"returnParameters":{"id":57264,"nodeType":"ParameterList","parameters":[{"constant":false,"id":57263,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":57265,"src":"1327:7:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":57262,"name":"address","nodeType":"ElementaryTypeName","src":"1327:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"1326:9:120"},"scope":57326,"stateMutability":"view","virtual":false,"visibility":"external"},{"id":57270,"nodeType":"FunctionDefinition","src":"1341:53:120","nodes":[],"functionSelector":"001c2ff6","implemented":false,"kind":"function","modifiers":[],"name":"L2_ORACLE","nameLocation":"1350:9:120","parameters":{"id":57266,"nodeType":"ParameterList","parameters":[],"src":"1359:2:120"},"returnParameters":{"id":57269,"nodeType":"ParameterList","parameters":[{"constant":false,"id":57268,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":57270,"src":"1385:7:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":57267,"name":"address","nodeType":"ElementaryTypeName","src":"1385:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"1384:9:120"},"scope":57326,"stateMutability":"view","virtual":false,"visibility":"external"},{"id":57275,"nodeType":"FunctionDefinition","src":"1399:52:120","nodes":[],"functionSelector":"9b5f694a","implemented":false,"kind":"function","modifiers":[],"name":"l2Oracle","nameLocation":"1408:8:120","parameters":{"id":57271,"nodeType":"ParameterList","parameters":[],"src":"1416:2:120"},"returnParameters":{"id":57274,"nodeType":"ParameterList","parameters":[{"constant":false,"id":57273,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":57275,"src":"1442:7:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":57272,"name":"address","nodeType":"ElementaryTypeName","src":"1442:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"1441:9:120"},"scope":57326,"stateMutability":"view","virtual":false,"visibility":"external"},{"id":57280,"nodeType":"FunctionDefinition","src":"1456:46:120","nodes":[],"functionSelector":"3a768463","implemented":false,"kind":"function","modifiers":[],"name":"vm","nameLocation":"1465:2:120","parameters":{"id":57276,"nodeType":"ParameterList","parameters":[],"src":"1467:2:120"},"returnParameters":{"id":57279,"nodeType":"ParameterList","parameters":[{"constant":false,"id":57278,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":57280,"src":"1493:7:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":57277,"name":"address","nodeType":"ElementaryTypeName","src":"1493:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"1492:9:120"},"scope":57326,"stateMutability":"view","virtual":false,"visibility":"external"},{"id":57285,"nodeType":"FunctionDefinition","src":"1507:50:120","nodes":[],"functionSelector":"7dc0d1d0","implemented":false,"kind":"function","modifiers":[],"name":"oracle","nameLocation":"1516:6:120","parameters":{"id":57281,"nodeType":"ParameterList","parameters":[],"src":"1522:2:120"},"returnParameters":{"id":57284,"nodeType":"ParameterList","parameters":[{"constant":false,"id":57283,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":57285,"src":"1548:7:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":57282,"name":"address","nodeType":"ElementaryTypeName","src":"1548:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"1547:9:120"},"scope":57326,"stateMutability":"view","virtual":false,"visibility":"external"},{"id":57290,"nodeType":"FunctionDefinition","src":"1562:54:120","nodes":[],"functionSelector":"534db0e2","implemented":false,"kind":"function","modifiers":[],"name":"challenger","nameLocation":"1571:10:120","parameters":{"id":57286,"nodeType":"ParameterList","parameters":[],"src":"1581:2:120"},"returnParameters":{"id":57289,"nodeType":"ParameterList","parameters":[{"constant":false,"id":57288,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":57290,"src":"1607:7:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":57287,"name":"address","nodeType":"ElementaryTypeName","src":"1607:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"1606:9:120"},"scope":57326,"stateMutability":"view","virtual":false,"visibility":"external"},{"id":57295,"nodeType":"FunctionDefinition","src":"1621:52:120","nodes":[],"functionSelector":"a8e4fb90","implemented":false,"kind":"function","modifiers":[],"name":"proposer","nameLocation":"1630:8:120","parameters":{"id":57291,"nodeType":"ParameterList","parameters":[],"src":"1638:2:120"},"returnParameters":{"id":57294,"nodeType":"ParameterList","parameters":[{"constant":false,"id":57293,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":57295,"src":"1664:7:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":57292,"name":"address","nodeType":"ElementaryTypeName","src":"1664:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"1663:9:120"},"scope":57326,"stateMutability":"view","virtual":false,"visibility":"external"},{"id":57300,"nodeType":"FunctionDefinition","src":"1678:52:120","nodes":[],"functionSelector":"bffa7f0f","implemented":false,"kind":"function","modifiers":[],"name":"PROPOSER","nameLocation":"1687:8:120","parameters":{"id":57296,"nodeType":"ParameterList","parameters":[],"src":"1695:2:120"},"returnParameters":{"id":57299,"nodeType":"ParameterList","parameters":[{"constant":false,"id":57298,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":57300,"src":"1721:7:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":57297,"name":"address","nodeType":"ElementaryTypeName","src":"1721:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"1720:9:120"},"scope":57326,"stateMutability":"view","virtual":false,"visibility":"external"},{"id":57305,"nodeType":"FunctionDefinition","src":"1735:55:120","nodes":[],"functionSelector":"e81b2c6d","implemented":false,"kind":"function","modifiers":[],"name":"batcherHash","nameLocation":"1744:11:120","parameters":{"id":57301,"nodeType":"ParameterList","parameters":[],"src":"1755:2:120"},"returnParameters":{"id":57304,"nodeType":"ParameterList","parameters":[{"constant":false,"id":57303,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":57305,"src":"1781:7:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_bytes32","typeString":"bytes32"},"typeName":{"id":57302,"name":"bytes32","nodeType":"ElementaryTypeName","src":"1781:7:120","typeDescriptions":{"typeIdentifier":"t_bytes32","typeString":"bytes32"}},"visibility":"internal"}],"src":"1780:9:120"},"scope":57326,"stateMutability":"view","virtual":false,"visibility":"external"},{"id":57310,"nodeType":"FunctionDefinition","src":"1795:49:120","nodes":[],"functionSelector":"f851a440","implemented":false,"kind":"function","modifiers":[],"name":"admin","nameLocation":"1804:5:120","parameters":{"id":57306,"nodeType":"ParameterList","parameters":[],"src":"1809:2:120"},"returnParameters":{"id":57309,"nodeType":"ParameterList","parameters":[{"constant":false,"id":57308,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":57310,"src":"1835:7:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":57307,"name":"address","nodeType":"ElementaryTypeName","src":"1835:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"1834:9:120"},"scope":57326,"stateMutability":"view","virtual":false,"visibility":"external"},{"id":57315,"nodeType":"FunctionDefinition","src":"1849:49:120","nodes":[],"functionSelector":"8da5cb5b","implemented":false,"kind":"function","modifiers":[],"name":"owner","nameLocation":"1858:5:120","parameters":{"id":57311,"nodeType":"ParameterList","parameters":[],"src":"1863:2:120"},"returnParameters":{"id":57314,"nodeType":"ParameterList","parameters":[{"constant":false,"id":57313,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":57315,"src":"1889:7:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":57312,"name":"address","nodeType":"ElementaryTypeName","src":"1889:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"1888:9:120"},"scope":57326,"stateMutability":"view","virtual":false,"visibility":"external"},{"id":57320,"nodeType":"FunctionDefinition","src":"1903:61:120","nodes":[],"functionSelector":"1fd19ee1","implemented":false,"kind":"function","modifiers":[],"name":"unsafeBlockSigner","nameLocation":"1912:17:120","parameters":{"id":57316,"nodeType":"ParameterList","parameters":[],"src":"1929:2:120"},"returnParameters":{"id":57319,"nodeType":"ParameterList","parameters":[{"constant":false,"id":57318,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":57320,"src":"1955:7:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":57317,"name":"address","nodeType":"ElementaryTypeName","src":"1955:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"1954:9:120"},"scope":57326,"stateMutability":"view","virtual":false,"visibility":"external"},{"id":57325,"nodeType":"FunctionDefinition","src":"1969:48:120","nodes":[],"functionSelector":"3fc8cef3","implemented":false,"kind":"function","modifiers":[],"name":"weth","nameLocation":"1978:4:120","parameters":{"id":57321,"nodeType":"ParameterList","parameters":[],"src":"1982:2:120"},"returnParameters":{"id":57324,"nodeType":"ParameterList","parameters":[{"constant":false,"id":57323,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":57325,"src":"2008:7:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":57322,"name":"address","nodeType":"ElementaryTypeName","src":"2008:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"2007:9:120"},"scope":57326,"stateMutability":"view","virtual":false,"visibility":"external"}],"abstract":false,"baseContracts":[],"canonicalName":"IFetcher","contractDependencies":[],"contractKind":"interface","documentation":{"id":57181,"nodeType":"StructuredDocumentation","src":"170:136:120","text":"@notice Contains getters for arbitrary methods from all L1 contracts, including legacy getters\n that have since been deprecated."},"fullyImplemented":false,"linearizedBaseContracts":[57326],"name":"IFetcher","nameLocation":"316:8:120","scope":59300,"usedErrors":[],"usedEvents":[]},{"id":57409,"nodeType":"ContractDefinition","src":"2021:934:120","nodes":[{"id":57328,"nodeType":"VariableDeclaration","src":"2056:35:120","nodes":[],"constant":false,"mutability":"mutable","name":"_systemConfigProxy","nameLocation":"2073:18:120","scope":57409,"stateVariable":true,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":57327,"name":"address","nodeType":"ElementaryTypeName","src":"2056:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"},{"id":57330,"nodeType":"VariableDeclaration","src":"2097:39:120","nodes":[],"constant":false,"mutability":"mutable","name":"_l1StandardBridgeProxy","nameLocation":"2114:22:120","scope":57409,"stateVariable":true,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":57329,"name":"address","nodeType":"ElementaryTypeName","src":"2097:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"},{"id":57372,"nodeType":"FunctionDefinition","src":"2143:378:120","nodes":[],"body":{"id":57371,"nodeType":"Block","src":"2191:330:120","nodes":[],"statements":[{"expression":{"arguments":[{"commonType":{"typeIdentifier":"t_address","typeString":"address"},"id":57343,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftExpression":{"id":57338,"name":"_addr","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57334,"src":"2209:5:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"BinaryOperation","operator":"!=","rightExpression":{"arguments":[{"hexValue":"30","id":57341,"isConstant":false,"isLValue":false,"isPure":true,"kind":"number","lValueRequested":false,"nodeType":"Literal","src":"2226:1:120","typeDescriptions":{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"},"value":"0"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"}],"id":57340,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"nodeType":"ElementaryTypeNameExpression","src":"2218:7:120","typeDescriptions":{"typeIdentifier":"t_type$_t_address_$","typeString":"type(address)"},"typeName":{"id":57339,"name":"address","nodeType":"ElementaryTypeName","src":"2218:7:120","typeDescriptions":{}}},"id":57342,"isConstant":false,"isLValue":false,"isPure":true,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"2218:10:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"src":"2209:19:120","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},{"hexValue":"4665746368436861696e496e666f496e7075743a2063616e6e6f7420736574207a65726f2061646472657373","id":57344,"isConstant":false,"isLValue":false,"isPure":true,"kind":"string","lValueRequested":false,"nodeType":"Literal","src":"2230:46:120","typeDescriptions":{"typeIdentifier":"t_stringliteral_0336126ace187312d69da4c7cf05307af6a6596e8c75de2974f56108baf24145","typeString":"literal_string \"FetchChainInfoInput: cannot set zero address\""},"value":"FetchChainInfoInput: cannot set zero address"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_bool","typeString":"bool"},{"typeIdentifier":"t_stringliteral_0336126ace187312d69da4c7cf05307af6a6596e8c75de2974f56108baf24145","typeString":"literal_string \"FetchChainInfoInput: cannot set zero address\""}],"id":57337,"name":"require","nodeType":"Identifier","overloadedDeclarations":[-18,-18],"referencedDeclaration":-18,"src":"2201:7:120","typeDescriptions":{"typeIdentifier":"t_function_require_pure$_t_bool_$_t_string_memory_ptr_$returns$__$","typeString":"function (bool,string memory) pure"}},"id":57345,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"2201:76:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":57346,"nodeType":"ExpressionStatement","src":"2201:76:120"},{"condition":{"commonType":{"typeIdentifier":"t_bytes4","typeString":"bytes4"},"id":57351,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftExpression":{"id":57347,"name":"_sel","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57332,"src":"2291:4:120","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},"nodeType":"BinaryOperation","operator":"==","rightExpression":{"expression":{"expression":{"id":57348,"name":"this","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":-28,"src":"2299:4:120","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoInput_$57409","typeString":"contract FetchChainInfoInput"}},"id":57349,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"2304:17:120","memberName":"systemConfigProxy","nodeType":"MemberAccess","referencedDeclaration":57390,"src":"2299:22:120","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":57350,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"memberLocation":"2322:8:120","memberName":"selector","nodeType":"MemberAccess","src":"2299:31:120","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},"src":"2291:39:120","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},"falseBody":{"condition":{"commonType":{"typeIdentifier":"t_bytes4","typeString":"bytes4"},"id":57360,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftExpression":{"id":57356,"name":"_sel","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57332,"src":"2377:4:120","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},"nodeType":"BinaryOperation","operator":"==","rightExpression":{"expression":{"expression":{"id":57357,"name":"this","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":-28,"src":"2385:4:120","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoInput_$57409","typeString":"contract FetchChainInfoInput"}},"id":57358,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"2390:21:120","memberName":"l1StandardBridgeProxy","nodeType":"MemberAccess","referencedDeclaration":57408,"src":"2385:26:120","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":57359,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"memberLocation":"2412:8:120","memberName":"selector","nodeType":"MemberAccess","src":"2385:35:120","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},"src":"2377:43:120","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},"falseBody":{"expression":{"arguments":[{"hexValue":"4665746368436861696e496e666f496e7075743a20756e6b6e6f776e2073656c6563746f72","id":57366,"isConstant":false,"isLValue":false,"isPure":true,"kind":"string","lValueRequested":false,"nodeType":"Literal","src":"2474:39:120","typeDescriptions":{"typeIdentifier":"t_stringliteral_3ec062448196d68b2d186fadb5ffe52c72f0a2b929c9d178cd6e6612281f066b","typeString":"literal_string \"FetchChainInfoInput: unknown selector\""},"value":"FetchChainInfoInput: unknown selector"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_stringliteral_3ec062448196d68b2d186fadb5ffe52c72f0a2b929c9d178cd6e6612281f066b","typeString":"literal_string \"FetchChainInfoInput: unknown selector\""}],"id":57365,"name":"revert","nodeType":"Identifier","overloadedDeclarations":[-19,-19],"referencedDeclaration":-19,"src":"2467:6:120","typeDescriptions":{"typeIdentifier":"t_function_revert_pure$_t_string_memory_ptr_$returns$__$","typeString":"function (string memory) pure"}},"id":57367,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"2467:47:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":57368,"nodeType":"ExpressionStatement","src":"2467:47:120"},"id":57369,"nodeType":"IfStatement","src":"2373:141:120","trueBody":{"expression":{"id":57363,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftHandSide":{"id":57361,"name":"_l1StandardBridgeProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57330,"src":"2422:22:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"Assignment","operator":"=","rightHandSide":{"id":57362,"name":"_addr","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57334,"src":"2447:5:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"src":"2422:30:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"id":57364,"nodeType":"ExpressionStatement","src":"2422:30:120"}},"id":57370,"nodeType":"IfStatement","src":"2287:227:120","trueBody":{"expression":{"id":57354,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftHandSide":{"id":57352,"name":"_systemConfigProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57328,"src":"2332:18:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"Assignment","operator":"=","rightHandSide":{"id":57353,"name":"_addr","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57334,"src":"2353:5:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"src":"2332:26:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"id":57355,"nodeType":"ExpressionStatement","src":"2332:26:120"}}]},"functionSelector":"c3e39250","implemented":true,"kind":"function","modifiers":[],"name":"set","nameLocation":"2152:3:120","parameters":{"id":57335,"nodeType":"ParameterList","parameters":[{"constant":false,"id":57332,"mutability":"mutable","name":"_sel","nameLocation":"2163:4:120","nodeType":"VariableDeclaration","scope":57372,"src":"2156:11:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"},"typeName":{"id":57331,"name":"bytes4","nodeType":"ElementaryTypeName","src":"2156:6:120","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},"visibility":"internal"},{"constant":false,"id":57334,"mutability":"mutable","name":"_addr","nameLocation":"2177:5:120","nodeType":"VariableDeclaration","scope":57372,"src":"2169:13:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":57333,"name":"address","nodeType":"ElementaryTypeName","src":"2169:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"2155:28:120"},"returnParameters":{"id":57336,"nodeType":"ParameterList","parameters":[],"src":"2191:0:120"},"scope":57409,"stateMutability":"nonpayable","virtual":false,"visibility":"public"},{"id":57390,"nodeType":"FunctionDefinition","src":"2527:202:120","nodes":[],"body":{"id":57389,"nodeType":"Block","src":"2586:143:120","nodes":[],"statements":[{"expression":{"arguments":[{"commonType":{"typeIdentifier":"t_address","typeString":"address"},"id":57383,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftExpression":{"id":57378,"name":"_systemConfigProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57328,"src":"2604:18:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"BinaryOperation","operator":"!=","rightExpression":{"arguments":[{"hexValue":"30","id":57381,"isConstant":false,"isLValue":false,"isPure":true,"kind":"number","lValueRequested":false,"nodeType":"Literal","src":"2634:1:120","typeDescriptions":{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"},"value":"0"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"}],"id":57380,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"nodeType":"ElementaryTypeNameExpression","src":"2626:7:120","typeDescriptions":{"typeIdentifier":"t_type$_t_address_$","typeString":"type(address)"},"typeName":{"id":57379,"name":"address","nodeType":"ElementaryTypeName","src":"2626:7:120","typeDescriptions":{}}},"id":57382,"isConstant":false,"isLValue":false,"isPure":true,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"2626:10:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"src":"2604:32:120","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},{"hexValue":"4665746368436861696e496e666f496e7075743a2073797374656d436f6e66696750726f7879206e6f7420736574","id":57384,"isConstant":false,"isLValue":false,"isPure":true,"kind":"string","lValueRequested":false,"nodeType":"Literal","src":"2638:48:120","typeDescriptions":{"typeIdentifier":"t_stringliteral_cefeeda9841ab81b734a3e4f7bf39aeeab7704e02e2040531bd67ea944e4d5d3","typeString":"literal_string \"FetchChainInfoInput: systemConfigProxy not set\""},"value":"FetchChainInfoInput: systemConfigProxy not set"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_bool","typeString":"bool"},{"typeIdentifier":"t_stringliteral_cefeeda9841ab81b734a3e4f7bf39aeeab7704e02e2040531bd67ea944e4d5d3","typeString":"literal_string \"FetchChainInfoInput: systemConfigProxy not set\""}],"id":57377,"name":"require","nodeType":"Identifier","overloadedDeclarations":[-18,-18],"referencedDeclaration":-18,"src":"2596:7:120","typeDescriptions":{"typeIdentifier":"t_function_require_pure$_t_bool_$_t_string_memory_ptr_$returns$__$","typeString":"function (bool,string memory) pure"}},"id":57385,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"2596:91:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":57386,"nodeType":"ExpressionStatement","src":"2596:91:120"},{"expression":{"id":57387,"name":"_systemConfigProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57328,"src":"2704:18:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"functionReturnParameters":57376,"id":57388,"nodeType":"Return","src":"2697:25:120"}]},"functionSelector":"c17db6e3","implemented":true,"kind":"function","modifiers":[],"name":"systemConfigProxy","nameLocation":"2536:17:120","parameters":{"id":57373,"nodeType":"ParameterList","parameters":[],"src":"2553:2:120"},"returnParameters":{"id":57376,"nodeType":"ParameterList","parameters":[{"constant":false,"id":57375,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":57390,"src":"2577:7:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":57374,"name":"address","nodeType":"ElementaryTypeName","src":"2577:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"2576:9:120"},"scope":57409,"stateMutability":"view","virtual":false,"visibility":"public"},{"id":57408,"nodeType":"FunctionDefinition","src":"2735:218:120","nodes":[],"body":{"id":57407,"nodeType":"Block","src":"2798:155:120","nodes":[],"statements":[{"expression":{"arguments":[{"commonType":{"typeIdentifier":"t_address","typeString":"address"},"id":57401,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftExpression":{"id":57396,"name":"_l1StandardBridgeProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57330,"src":"2816:22:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"BinaryOperation","operator":"!=","rightExpression":{"arguments":[{"hexValue":"30","id":57399,"isConstant":false,"isLValue":false,"isPure":true,"kind":"number","lValueRequested":false,"nodeType":"Literal","src":"2850:1:120","typeDescriptions":{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"},"value":"0"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"}],"id":57398,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"nodeType":"ElementaryTypeNameExpression","src":"2842:7:120","typeDescriptions":{"typeIdentifier":"t_type$_t_address_$","typeString":"type(address)"},"typeName":{"id":57397,"name":"address","nodeType":"ElementaryTypeName","src":"2842:7:120","typeDescriptions":{}}},"id":57400,"isConstant":false,"isLValue":false,"isPure":true,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"2842:10:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"src":"2816:36:120","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},{"hexValue":"4665746368436861696e496e666f496e7075743a206c315374616e6461726442726964676550726f7879206e6f7420736574","id":57402,"isConstant":false,"isLValue":false,"isPure":true,"kind":"string","lValueRequested":false,"nodeType":"Literal","src":"2854:52:120","typeDescriptions":{"typeIdentifier":"t_stringliteral_be85b0ed3fc58e97f8b79e4d9fb1c191539515cae509acde6becd9338254d33b","typeString":"literal_string \"FetchChainInfoInput: l1StandardBridgeProxy not set\""},"value":"FetchChainInfoInput: l1StandardBridgeProxy not set"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_bool","typeString":"bool"},{"typeIdentifier":"t_stringliteral_be85b0ed3fc58e97f8b79e4d9fb1c191539515cae509acde6becd9338254d33b","typeString":"literal_string \"FetchChainInfoInput: l1StandardBridgeProxy not set\""}],"id":57395,"name":"require","nodeType":"Identifier","overloadedDeclarations":[-18,-18],"referencedDeclaration":-18,"src":"2808:7:120","typeDescriptions":{"typeIdentifier":"t_function_require_pure$_t_bool_$_t_string_memory_ptr_$returns$__$","typeString":"function (bool,string memory) pure"}},"id":57403,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"2808:99:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":57404,"nodeType":"ExpressionStatement","src":"2808:99:120"},{"expression":{"id":57405,"name":"_l1StandardBridgeProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57330,"src":"2924:22:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"functionReturnParameters":57394,"id":57406,"nodeType":"Return","src":"2917:29:120"}]},"functionSelector":"102b6069","implemented":true,"kind":"function","modifiers":[],"name":"l1StandardBridgeProxy","nameLocation":"2744:21:120","parameters":{"id":57391,"nodeType":"ParameterList","parameters":[],"src":"2765:2:120"},"returnParameters":{"id":57394,"nodeType":"ParameterList","parameters":[{"constant":false,"id":57393,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":57408,"src":"2789:7:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":57392,"name":"address","nodeType":"ElementaryTypeName","src":"2789:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"2788:9:120"},"scope":57409,"stateMutability":"view","virtual":false,"visibility":"public"}],"abstract":false,"baseContracts":[],"canonicalName":"FetchChainInfoInput","contractDependencies":[],"contractKind":"contract","fullyImplemented":true,"linearizedBaseContracts":[57409],"name":"FetchChainInfoInput","nameLocation":"2030:19:120","scope":59300,"usedErrors":[],"usedEvents":[]},{"id":58249,"nodeType":"ContractDefinition","src":"2957:10181:120","nodes":[{"id":57411,"nodeType":"VariableDeclaration","src":"3049:39:120","nodes":[],"constant":false,"mutability":"mutable","name":"_superchainConfigProxy","nameLocation":"3066:22:120","scope":58249,"stateVariable":true,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":57410,"name":"address","nodeType":"ElementaryTypeName","src":"3049:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"},{"id":57413,"nodeType":"VariableDeclaration","src":"3129:26:120","nodes":[],"constant":false,"mutability":"mutable","name":"_mipsImpl","nameLocation":"3146:9:120","scope":58249,"stateVariable":true,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":57412,"name":"address","nodeType":"ElementaryTypeName","src":"3129:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"},{"id":57415,"nodeType":"VariableDeclaration","src":"3161:36:120","nodes":[],"constant":false,"mutability":"mutable","name":"_preimageOracleImpl","nameLocation":"3178:19:120","scope":58249,"stateVariable":true,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":57414,"name":"address","nodeType":"ElementaryTypeName","src":"3161:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"},{"id":57417,"nodeType":"VariableDeclaration","src":"3230:36:120","nodes":[],"constant":false,"mutability":"mutable","name":"_addressManagerImpl","nameLocation":"3247:19:120","scope":58249,"stateVariable":true,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":57416,"name":"address","nodeType":"ElementaryTypeName","src":"3230:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"},{"id":57419,"nodeType":"VariableDeclaration","src":"3272:33:120","nodes":[],"constant":false,"mutability":"mutable","name":"_ethLockboxProxy","nameLocation":"3289:16:120","scope":58249,"stateVariable":true,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":57418,"name":"address","nodeType":"ElementaryTypeName","src":"3272:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"},{"id":57421,"nodeType":"VariableDeclaration","src":"3311:45:120","nodes":[],"constant":false,"mutability":"mutable","name":"_l1CrossDomainMessengerProxy","nameLocation":"3328:28:120","scope":58249,"stateVariable":true,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":57420,"name":"address","nodeType":"ElementaryTypeName","src":"3311:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"},{"id":57423,"nodeType":"VariableDeclaration","src":"3362:37:120","nodes":[],"constant":false,"mutability":"mutable","name":"_l1Erc721BridgeProxy","nameLocation":"3379:20:120","scope":58249,"stateVariable":true,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":57422,"name":"address","nodeType":"ElementaryTypeName","src":"3362:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"},{"id":57425,"nodeType":"VariableDeclaration","src":"3405:39:120","nodes":[],"constant":false,"mutability":"mutable","name":"_l1StandardBridgeProxy","nameLocation":"3422:22:120","scope":58249,"stateVariable":true,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":57424,"name":"address","nodeType":"ElementaryTypeName","src":"3405:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"},{"id":57427,"nodeType":"VariableDeclaration","src":"3450:37:120","nodes":[],"constant":false,"mutability":"mutable","name":"_l2OutputOracleProxy","nameLocation":"3467:20:120","scope":58249,"stateVariable":true,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":57426,"name":"address","nodeType":"ElementaryTypeName","src":"3450:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"},{"id":57429,"nodeType":"VariableDeclaration","src":"3493:51:120","nodes":[],"constant":false,"mutability":"mutable","name":"_optimismMintableErc20FactoryProxy","nameLocation":"3510:34:120","scope":58249,"stateVariable":true,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":57428,"name":"address","nodeType":"ElementaryTypeName","src":"3493:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"},{"id":57431,"nodeType":"VariableDeclaration","src":"3550:37:120","nodes":[],"constant":false,"mutability":"mutable","name":"_optimismPortalProxy","nameLocation":"3567:20:120","scope":58249,"stateVariable":true,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":57430,"name":"address","nodeType":"ElementaryTypeName","src":"3550:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"},{"id":57433,"nodeType":"VariableDeclaration","src":"3593:35:120","nodes":[],"constant":false,"mutability":"mutable","name":"_systemConfigProxy","nameLocation":"3610:18:120","scope":58249,"stateVariable":true,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":57432,"name":"address","nodeType":"ElementaryTypeName","src":"3593:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"},{"id":57435,"nodeType":"VariableDeclaration","src":"3634:39:120","nodes":[],"constant":false,"mutability":"mutable","name":"_opChainProxyAdminImpl","nameLocation":"3651:22:120","scope":58249,"stateVariable":true,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":57434,"name":"address","nodeType":"ElementaryTypeName","src":"3634:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"},{"id":57437,"nodeType":"VariableDeclaration","src":"3679:42:120","nodes":[],"constant":false,"mutability":"mutable","name":"_anchorStateRegistryProxy","nameLocation":"3696:25:120","scope":58249,"stateVariable":true,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":57436,"name":"address","nodeType":"ElementaryTypeName","src":"3679:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"},{"id":57439,"nodeType":"VariableDeclaration","src":"3727:50:120","nodes":[],"constant":false,"mutability":"mutable","name":"_delayedWethPermissionedGameProxy","nameLocation":"3744:33:120","scope":58249,"stateVariable":true,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":57438,"name":"address","nodeType":"ElementaryTypeName","src":"3727:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"},{"id":57441,"nodeType":"VariableDeclaration","src":"3783:52:120","nodes":[],"constant":false,"mutability":"mutable","name":"_delayedWethPermissionlessGameProxy","nameLocation":"3800:35:120","scope":58249,"stateVariable":true,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":57440,"name":"address","nodeType":"ElementaryTypeName","src":"3783:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"},{"id":57443,"nodeType":"VariableDeclaration","src":"3841:41:120","nodes":[],"constant":false,"mutability":"mutable","name":"_disputeGameFactoryProxy","nameLocation":"3858:24:120","scope":58249,"stateVariable":true,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":57442,"name":"address","nodeType":"ElementaryTypeName","src":"3841:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"},{"id":57445,"nodeType":"VariableDeclaration","src":"3888:38:120","nodes":[],"constant":false,"mutability":"mutable","name":"_faultDisputeGameImpl","nameLocation":"3905:21:120","scope":58249,"stateVariable":true,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":57444,"name":"address","nodeType":"ElementaryTypeName","src":"3888:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"},{"id":57447,"nodeType":"VariableDeclaration","src":"3932:45:120","nodes":[],"constant":false,"mutability":"mutable","name":"_permissionedDisputeGameImpl","nameLocation":"3949:28:120","scope":58249,"stateVariable":true,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":57446,"name":"address","nodeType":"ElementaryTypeName","src":"3932:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"},{"id":57449,"nodeType":"VariableDeclaration","src":"3997:35:120","nodes":[],"constant":false,"mutability":"mutable","name":"_systemConfigOwner","nameLocation":"4014:18:120","scope":58249,"stateVariable":true,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":57448,"name":"address","nodeType":"ElementaryTypeName","src":"3997:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"},{"id":57451,"nodeType":"VariableDeclaration","src":"4038:40:120","nodes":[],"constant":false,"mutability":"mutable","name":"_opChainProxyAdminOwner","nameLocation":"4055:23:120","scope":58249,"stateVariable":true,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":57450,"name":"address","nodeType":"ElementaryTypeName","src":"4038:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"},{"id":57453,"nodeType":"VariableDeclaration","src":"4084:33:120","nodes":[],"constant":false,"mutability":"mutable","name":"_opChainGuardian","nameLocation":"4101:16:120","scope":58249,"stateVariable":true,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":57452,"name":"address","nodeType":"ElementaryTypeName","src":"4084:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"},{"id":57455,"nodeType":"VariableDeclaration","src":"4123:28:120","nodes":[],"constant":false,"mutability":"mutable","name":"_challenger","nameLocation":"4140:11:120","scope":58249,"stateVariable":true,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":57454,"name":"address","nodeType":"ElementaryTypeName","src":"4123:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"},{"id":57457,"nodeType":"VariableDeclaration","src":"4157:26:120","nodes":[],"constant":false,"mutability":"mutable","name":"_proposer","nameLocation":"4174:9:120","scope":58249,"stateVariable":true,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":57456,"name":"address","nodeType":"ElementaryTypeName","src":"4157:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"},{"id":57459,"nodeType":"VariableDeclaration","src":"4189:35:120","nodes":[],"constant":false,"mutability":"mutable","name":"_unsafeBlockSigner","nameLocation":"4206:18:120","scope":58249,"stateVariable":true,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":57458,"name":"address","nodeType":"ElementaryTypeName","src":"4189:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"},{"id":57461,"nodeType":"VariableDeclaration","src":"4230:32:120","nodes":[],"constant":false,"mutability":"mutable","name":"_batchSubmitter","nameLocation":"4247:15:120","scope":58249,"stateVariable":true,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":57460,"name":"address","nodeType":"ElementaryTypeName","src":"4230:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"},{"id":57463,"nodeType":"VariableDeclaration","src":"4295:27:120","nodes":[],"constant":false,"mutability":"mutable","name":"_permissioned","nameLocation":"4309:13:120","scope":58249,"stateVariable":true,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"},"typeName":{"id":57462,"name":"bool","nodeType":"ElementaryTypeName","src":"4295:4:120","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},"visibility":"internal"},{"id":57465,"nodeType":"VariableDeclaration","src":"4328:29:120","nodes":[],"constant":false,"mutability":"mutable","name":"_permissionless","nameLocation":"4342:15:120","scope":58249,"stateVariable":true,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"},"typeName":{"id":57464,"name":"bool","nodeType":"ElementaryTypeName","src":"4328:4:120","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},"visibility":"internal"},{"id":57468,"nodeType":"VariableDeclaration","src":"4363:36:120","nodes":[],"constant":false,"mutability":"mutable","name":"_respectedGameType","nameLocation":"4381:18:120","scope":58249,"stateVariable":true,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_userDefinedValueType$_GameType_$75355","typeString":"GameType"},"typeName":{"id":57467,"nodeType":"UserDefinedTypeName","pathNode":{"id":57466,"name":"GameType","nameLocations":["4363:8:120"],"nodeType":"IdentifierPath","referencedDeclaration":75355,"src":"4363:8:120"},"referencedDeclaration":75355,"src":"4363:8:120","typeDescriptions":{"typeIdentifier":"t_userDefinedValueType$_GameType_$75355","typeString":"GameType"}},"visibility":"internal"},{"id":57740,"nodeType":"FunctionDefinition","src":"4406:2634:120","nodes":[],"body":{"id":57739,"nodeType":"Block","src":"4454:2586:120","nodes":[],"statements":[{"condition":{"commonType":{"typeIdentifier":"t_bytes4","typeString":"bytes4"},"id":57479,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftExpression":{"id":57475,"name":"_sel","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57470,"src":"4499:4:120","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},"nodeType":"BinaryOperation","operator":"==","rightExpression":{"expression":{"expression":{"id":57476,"name":"this","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":-28,"src":"4507:4:120","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$58249","typeString":"contract FetchChainInfoOutput"}},"id":57477,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"4512:21:120","memberName":"superchainConfigProxy","nodeType":"MemberAccess","referencedDeclaration":57983,"src":"4507:26:120","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":57478,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"memberLocation":"4534:8:120","memberName":"selector","nodeType":"MemberAccess","src":"4507:35:120","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},"src":"4499:43:120","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},"falseBody":{"condition":{"commonType":{"typeIdentifier":"t_bytes4","typeString":"bytes4"},"id":57488,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftExpression":{"id":57484,"name":"_sel","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57470,"src":"4632:4:120","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},"nodeType":"BinaryOperation","operator":"==","rightExpression":{"expression":{"expression":{"id":57485,"name":"this","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":-28,"src":"4640:4:120","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$58249","typeString":"contract FetchChainInfoOutput"}},"id":57486,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"4645:8:120","memberName":"mipsImpl","nodeType":"MemberAccess","referencedDeclaration":58061,"src":"4640:13:120","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":57487,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"memberLocation":"4654:8:120","memberName":"selector","nodeType":"MemberAccess","src":"4640:22:120","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},"src":"4632:30:120","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},"falseBody":{"condition":{"commonType":{"typeIdentifier":"t_bytes4","typeString":"bytes4"},"id":57497,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftExpression":{"id":57493,"name":"_sel","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57470,"src":"4700:4:120","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},"nodeType":"BinaryOperation","operator":"==","rightExpression":{"expression":{"expression":{"id":57494,"name":"this","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":-28,"src":"4708:4:120","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$58249","typeString":"contract FetchChainInfoOutput"}},"id":57495,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"4713:18:120","memberName":"preimageOracleImpl","nodeType":"MemberAccess","referencedDeclaration":58097,"src":"4708:23:120","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":57496,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"memberLocation":"4732:8:120","memberName":"selector","nodeType":"MemberAccess","src":"4708:32:120","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},"src":"4700:40:120","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},"falseBody":{"condition":{"commonType":{"typeIdentifier":"t_bytes4","typeString":"bytes4"},"id":57506,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftExpression":{"id":57502,"name":"_sel","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57470,"src":"4819:4:120","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},"nodeType":"BinaryOperation","operator":"==","rightExpression":{"expression":{"expression":{"id":57503,"name":"this","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":-28,"src":"4827:4:120","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$58249","typeString":"contract FetchChainInfoOutput"}},"id":57504,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"4832:18:120","memberName":"addressManagerImpl","nodeType":"MemberAccess","referencedDeclaration":57813,"src":"4827:23:120","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":57505,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"memberLocation":"4851:8:120","memberName":"selector","nodeType":"MemberAccess","src":"4827:32:120","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},"src":"4819:40:120","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},"falseBody":{"condition":{"commonType":{"typeIdentifier":"t_bytes4","typeString":"bytes4"},"id":57515,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftExpression":{"id":57511,"name":"_sel","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57470,"src":"4907:4:120","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},"nodeType":"BinaryOperation","operator":"==","rightExpression":{"expression":{"expression":{"id":57512,"name":"this","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":-28,"src":"4915:4:120","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$58249","typeString":"contract FetchChainInfoOutput"}},"id":57513,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"4920:15:120","memberName":"ethLockboxProxy","nodeType":"MemberAccess","referencedDeclaration":57821,"src":"4915:20:120","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":57514,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"memberLocation":"4936:8:120","memberName":"selector","nodeType":"MemberAccess","src":"4915:29:120","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},"src":"4907:37:120","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},"falseBody":{"condition":{"commonType":{"typeIdentifier":"t_bytes4","typeString":"bytes4"},"id":57524,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftExpression":{"id":57520,"name":"_sel","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57470,"src":"4989:4:120","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},"nodeType":"BinaryOperation","operator":"==","rightExpression":{"expression":{"expression":{"id":57521,"name":"this","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":-28,"src":"4997:4:120","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$58249","typeString":"contract FetchChainInfoOutput"}},"id":57522,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"5002:27:120","memberName":"l1CrossDomainMessengerProxy","nodeType":"MemberAccess","referencedDeclaration":57839,"src":"4997:32:120","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":57523,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"memberLocation":"5030:8:120","memberName":"selector","nodeType":"MemberAccess","src":"4997:41:120","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},"src":"4989:49:120","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},"falseBody":{"condition":{"commonType":{"typeIdentifier":"t_bytes4","typeString":"bytes4"},"id":57533,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftExpression":{"id":57529,"name":"_sel","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57470,"src":"5095:4:120","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},"nodeType":"BinaryOperation","operator":"==","rightExpression":{"expression":{"expression":{"id":57530,"name":"this","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":-28,"src":"5103:4:120","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$58249","typeString":"contract FetchChainInfoOutput"}},"id":57531,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"5108:19:120","memberName":"l1Erc721BridgeProxy","nodeType":"MemberAccess","referencedDeclaration":57857,"src":"5103:24:120","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":57532,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"memberLocation":"5128:8:120","memberName":"selector","nodeType":"MemberAccess","src":"5103:33:120","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},"src":"5095:41:120","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},"falseBody":{"condition":{"commonType":{"typeIdentifier":"t_bytes4","typeString":"bytes4"},"id":57542,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftExpression":{"id":57538,"name":"_sel","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57470,"src":"5185:4:120","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},"nodeType":"BinaryOperation","operator":"==","rightExpression":{"expression":{"expression":{"id":57539,"name":"this","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":-28,"src":"5193:4:120","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$58249","typeString":"contract FetchChainInfoOutput"}},"id":57540,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"5198:21:120","memberName":"l1StandardBridgeProxy","nodeType":"MemberAccess","referencedDeclaration":57875,"src":"5193:26:120","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":57541,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"memberLocation":"5220:8:120","memberName":"selector","nodeType":"MemberAccess","src":"5193:35:120","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},"src":"5185:43:120","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},"falseBody":{"condition":{"commonType":{"typeIdentifier":"t_bytes4","typeString":"bytes4"},"id":57551,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftExpression":{"id":57547,"name":"_sel","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57470,"src":"5279:4:120","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},"nodeType":"BinaryOperation","operator":"==","rightExpression":{"expression":{"expression":{"id":57548,"name":"this","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":-28,"src":"5287:4:120","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$58249","typeString":"contract FetchChainInfoOutput"}},"id":57549,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"5292:19:120","memberName":"l2OutputOracleProxy","nodeType":"MemberAccess","referencedDeclaration":57893,"src":"5287:24:120","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":57550,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"memberLocation":"5312:8:120","memberName":"selector","nodeType":"MemberAccess","src":"5287:33:120","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},"src":"5279:41:120","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},"falseBody":{"condition":{"commonType":{"typeIdentifier":"t_bytes4","typeString":"bytes4"},"id":57560,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftExpression":{"id":57556,"name":"_sel","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57470,"src":"5369:4:120","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},"nodeType":"BinaryOperation","operator":"==","rightExpression":{"expression":{"expression":{"id":57557,"name":"this","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":-28,"src":"5377:4:120","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$58249","typeString":"contract FetchChainInfoOutput"}},"id":57558,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"5382:33:120","memberName":"optimismMintableErc20FactoryProxy","nodeType":"MemberAccess","referencedDeclaration":57911,"src":"5377:38:120","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":57559,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"memberLocation":"5416:8:120","memberName":"selector","nodeType":"MemberAccess","src":"5377:47:120","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},"src":"5369:55:120","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},"falseBody":{"condition":{"commonType":{"typeIdentifier":"t_bytes4","typeString":"bytes4"},"id":57569,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftExpression":{"id":57565,"name":"_sel","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57470,"src":"5487:4:120","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},"nodeType":"BinaryOperation","operator":"==","rightExpression":{"expression":{"expression":{"id":57566,"name":"this","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":-28,"src":"5495:4:120","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$58249","typeString":"contract FetchChainInfoOutput"}},"id":57567,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"5500:19:120","memberName":"optimismPortalProxy","nodeType":"MemberAccess","referencedDeclaration":57929,"src":"5495:24:120","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":57568,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"memberLocation":"5520:8:120","memberName":"selector","nodeType":"MemberAccess","src":"5495:33:120","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},"src":"5487:41:120","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},"falseBody":{"condition":{"commonType":{"typeIdentifier":"t_bytes4","typeString":"bytes4"},"id":57578,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftExpression":{"id":57574,"name":"_sel","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57470,"src":"5577:4:120","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},"nodeType":"BinaryOperation","operator":"==","rightExpression":{"expression":{"expression":{"id":57575,"name":"this","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":-28,"src":"5585:4:120","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$58249","typeString":"contract FetchChainInfoOutput"}},"id":57576,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"5590:17:120","memberName":"systemConfigProxy","nodeType":"MemberAccess","referencedDeclaration":57947,"src":"5585:22:120","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":57577,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"memberLocation":"5608:8:120","memberName":"selector","nodeType":"MemberAccess","src":"5585:31:120","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},"src":"5577:39:120","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},"falseBody":{"condition":{"commonType":{"typeIdentifier":"t_bytes4","typeString":"bytes4"},"id":57587,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftExpression":{"id":57583,"name":"_sel","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57470,"src":"5663:4:120","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},"nodeType":"BinaryOperation","operator":"==","rightExpression":{"expression":{"expression":{"id":57584,"name":"this","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":-28,"src":"5671:4:120","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$58249","typeString":"contract FetchChainInfoOutput"}},"id":57585,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"5676:21:120","memberName":"opChainProxyAdminImpl","nodeType":"MemberAccess","referencedDeclaration":57965,"src":"5671:26:120","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":57586,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"memberLocation":"5698:8:120","memberName":"selector","nodeType":"MemberAccess","src":"5671:35:120","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},"src":"5663:43:120","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},"falseBody":{"condition":{"commonType":{"typeIdentifier":"t_bytes4","typeString":"bytes4"},"id":57596,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftExpression":{"id":57592,"name":"_sel","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57470,"src":"5757:4:120","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},"nodeType":"BinaryOperation","operator":"==","rightExpression":{"expression":{"expression":{"id":57593,"name":"this","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":-28,"src":"5765:4:120","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$58249","typeString":"contract FetchChainInfoOutput"}},"id":57594,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"5770:24:120","memberName":"anchorStateRegistryProxy","nodeType":"MemberAccess","referencedDeclaration":58001,"src":"5765:29:120","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":57595,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"memberLocation":"5795:8:120","memberName":"selector","nodeType":"MemberAccess","src":"5765:38:120","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},"src":"5757:46:120","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},"falseBody":{"condition":{"commonType":{"typeIdentifier":"t_bytes4","typeString":"bytes4"},"id":57605,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftExpression":{"id":57601,"name":"_sel","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57470,"src":"5857:4:120","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},"nodeType":"BinaryOperation","operator":"==","rightExpression":{"expression":{"expression":{"id":57602,"name":"this","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":-28,"src":"5865:4:120","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$58249","typeString":"contract FetchChainInfoOutput"}},"id":57603,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"5870:32:120","memberName":"delayedWethPermissionedGameProxy","nodeType":"MemberAccess","referencedDeclaration":58009,"src":"5865:37:120","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":57604,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"memberLocation":"5903:8:120","memberName":"selector","nodeType":"MemberAccess","src":"5865:46:120","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},"src":"5857:54:120","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},"falseBody":{"condition":{"commonType":{"typeIdentifier":"t_bytes4","typeString":"bytes4"},"id":57614,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftExpression":{"id":57610,"name":"_sel","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57470,"src":"5973:4:120","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},"nodeType":"BinaryOperation","operator":"==","rightExpression":{"expression":{"expression":{"id":57611,"name":"this","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":-28,"src":"5981:4:120","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$58249","typeString":"contract FetchChainInfoOutput"}},"id":57612,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"5986:34:120","memberName":"delayedWethPermissionlessGameProxy","nodeType":"MemberAccess","referencedDeclaration":58017,"src":"5981:39:120","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":57613,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"memberLocation":"6021:8:120","memberName":"selector","nodeType":"MemberAccess","src":"5981:48:120","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},"src":"5973:56:120","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},"falseBody":{"condition":{"commonType":{"typeIdentifier":"t_bytes4","typeString":"bytes4"},"id":57623,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftExpression":{"id":57619,"name":"_sel","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57470,"src":"6093:4:120","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},"nodeType":"BinaryOperation","operator":"==","rightExpression":{"expression":{"expression":{"id":57620,"name":"this","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":-28,"src":"6101:4:120","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$58249","typeString":"contract FetchChainInfoOutput"}},"id":57621,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"6106:23:120","memberName":"disputeGameFactoryProxy","nodeType":"MemberAccess","referencedDeclaration":58025,"src":"6101:28:120","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":57622,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"memberLocation":"6130:8:120","memberName":"selector","nodeType":"MemberAccess","src":"6101:37:120","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},"src":"6093:45:120","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},"falseBody":{"condition":{"commonType":{"typeIdentifier":"t_bytes4","typeString":"bytes4"},"id":57632,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftExpression":{"id":57628,"name":"_sel","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57470,"src":"6191:4:120","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},"nodeType":"BinaryOperation","operator":"==","rightExpression":{"expression":{"expression":{"id":57629,"name":"this","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":-28,"src":"6199:4:120","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$58249","typeString":"contract FetchChainInfoOutput"}},"id":57630,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"6204:20:120","memberName":"faultDisputeGameImpl","nodeType":"MemberAccess","referencedDeclaration":58043,"src":"6199:25:120","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":57631,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"memberLocation":"6225:8:120","memberName":"selector","nodeType":"MemberAccess","src":"6199:34:120","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},"src":"6191:42:120","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},"falseBody":{"condition":{"commonType":{"typeIdentifier":"t_bytes4","typeString":"bytes4"},"id":57641,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftExpression":{"id":57637,"name":"_sel","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57470,"src":"6283:4:120","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},"nodeType":"BinaryOperation","operator":"==","rightExpression":{"expression":{"expression":{"id":57638,"name":"this","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":-28,"src":"6291:4:120","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$58249","typeString":"contract FetchChainInfoOutput"}},"id":57639,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"6296:27:120","memberName":"permissionedDisputeGameImpl","nodeType":"MemberAccess","referencedDeclaration":58079,"src":"6291:32:120","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":57640,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"memberLocation":"6324:8:120","memberName":"selector","nodeType":"MemberAccess","src":"6291:41:120","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},"src":"6283:49:120","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},"falseBody":{"condition":{"commonType":{"typeIdentifier":"t_bytes4","typeString":"bytes4"},"id":57650,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftExpression":{"id":57646,"name":"_sel","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57470,"src":"6406:4:120","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},"nodeType":"BinaryOperation","operator":"==","rightExpression":{"expression":{"expression":{"id":57647,"name":"this","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":-28,"src":"6414:4:120","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$58249","typeString":"contract FetchChainInfoOutput"}},"id":57648,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"6419:17:120","memberName":"systemConfigOwner","nodeType":"MemberAccess","referencedDeclaration":58115,"src":"6414:22:120","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":57649,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"memberLocation":"6437:8:120","memberName":"selector","nodeType":"MemberAccess","src":"6414:31:120","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},"src":"6406:39:120","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},"falseBody":{"condition":{"commonType":{"typeIdentifier":"t_bytes4","typeString":"bytes4"},"id":57659,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftExpression":{"id":57655,"name":"_sel","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57470,"src":"6492:4:120","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},"nodeType":"BinaryOperation","operator":"==","rightExpression":{"expression":{"expression":{"id":57656,"name":"this","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":-28,"src":"6500:4:120","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$58249","typeString":"contract FetchChainInfoOutput"}},"id":57657,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"6505:22:120","memberName":"opChainProxyAdminOwner","nodeType":"MemberAccess","referencedDeclaration":58133,"src":"6500:27:120","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":57658,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"memberLocation":"6528:8:120","memberName":"selector","nodeType":"MemberAccess","src":"6500:36:120","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},"src":"6492:44:120","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},"falseBody":{"condition":{"commonType":{"typeIdentifier":"t_bytes4","typeString":"bytes4"},"id":57668,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftExpression":{"id":57664,"name":"_sel","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57470,"src":"6588:4:120","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},"nodeType":"BinaryOperation","operator":"==","rightExpression":{"expression":{"expression":{"id":57665,"name":"this","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":-28,"src":"6596:4:120","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$58249","typeString":"contract FetchChainInfoOutput"}},"id":57666,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"6601:15:120","memberName":"opChainGuardian","nodeType":"MemberAccess","referencedDeclaration":58151,"src":"6596:20:120","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":57667,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"memberLocation":"6617:8:120","memberName":"selector","nodeType":"MemberAccess","src":"6596:29:120","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},"src":"6588:37:120","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},"falseBody":{"condition":{"commonType":{"typeIdentifier":"t_bytes4","typeString":"bytes4"},"id":57677,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftExpression":{"id":57673,"name":"_sel","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57470,"src":"6670:4:120","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},"nodeType":"BinaryOperation","operator":"==","rightExpression":{"expression":{"expression":{"id":57674,"name":"this","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":-28,"src":"6678:4:120","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$58249","typeString":"contract FetchChainInfoOutput"}},"id":57675,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"6683:10:120","memberName":"challenger","nodeType":"MemberAccess","referencedDeclaration":58169,"src":"6678:15:120","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":57676,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"memberLocation":"6694:8:120","memberName":"selector","nodeType":"MemberAccess","src":"6678:24:120","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},"src":"6670:32:120","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},"falseBody":{"condition":{"commonType":{"typeIdentifier":"t_bytes4","typeString":"bytes4"},"id":57686,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftExpression":{"id":57682,"name":"_sel","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57470,"src":"6742:4:120","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},"nodeType":"BinaryOperation","operator":"==","rightExpression":{"expression":{"expression":{"id":57683,"name":"this","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":-28,"src":"6750:4:120","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$58249","typeString":"contract FetchChainInfoOutput"}},"id":57684,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"6755:8:120","memberName":"proposer","nodeType":"MemberAccess","referencedDeclaration":58187,"src":"6750:13:120","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":57685,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"memberLocation":"6764:8:120","memberName":"selector","nodeType":"MemberAccess","src":"6750:22:120","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},"src":"6742:30:120","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},"falseBody":{"condition":{"commonType":{"typeIdentifier":"t_bytes4","typeString":"bytes4"},"id":57695,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftExpression":{"id":57691,"name":"_sel","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57470,"src":"6810:4:120","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},"nodeType":"BinaryOperation","operator":"==","rightExpression":{"expression":{"expression":{"id":57692,"name":"this","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":-28,"src":"6818:4:120","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$58249","typeString":"contract FetchChainInfoOutput"}},"id":57693,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"6823:17:120","memberName":"unsafeBlockSigner","nodeType":"MemberAccess","referencedDeclaration":58205,"src":"6818:22:120","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":57694,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"memberLocation":"6841:8:120","memberName":"selector","nodeType":"MemberAccess","src":"6818:31:120","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},"src":"6810:39:120","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},"falseBody":{"condition":{"commonType":{"typeIdentifier":"t_bytes4","typeString":"bytes4"},"id":57704,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftExpression":{"id":57700,"name":"_sel","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57470,"src":"6896:4:120","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},"nodeType":"BinaryOperation","operator":"==","rightExpression":{"expression":{"expression":{"id":57701,"name":"this","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":-28,"src":"6904:4:120","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$58249","typeString":"contract FetchChainInfoOutput"}},"id":57702,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"6909:14:120","memberName":"batchSubmitter","nodeType":"MemberAccess","referencedDeclaration":58223,"src":"6904:19:120","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":57703,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"memberLocation":"6924:8:120","memberName":"selector","nodeType":"MemberAccess","src":"6904:28:120","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},"src":"6896:36:120","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},"falseBody":{"expression":{"arguments":[{"hexValue":"4665746368436861696e496e666f4f75747075743a20756e6b6e6f776e20616464726573732073656c6563746f722074657374","id":57710,"isConstant":false,"isLValue":false,"isPure":true,"kind":"string","lValueRequested":false,"nodeType":"Literal","src":"6979:53:120","typeDescriptions":{"typeIdentifier":"t_stringliteral_8be6a92cba5443877e2b6bededc383e178c3f2718dce3f3864f1721c31f5c065","typeString":"literal_string \"FetchChainInfoOutput: unknown address selector test\""},"value":"FetchChainInfoOutput: unknown address selector test"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_stringliteral_8be6a92cba5443877e2b6bededc383e178c3f2718dce3f3864f1721c31f5c065","typeString":"literal_string \"FetchChainInfoOutput: unknown address selector test\""}],"id":57709,"name":"revert","nodeType":"Identifier","overloadedDeclarations":[-19,-19],"referencedDeclaration":-19,"src":"6972:6:120","typeDescriptions":{"typeIdentifier":"t_function_revert_pure$_t_string_memory_ptr_$returns$__$","typeString":"function (string memory) pure"}},"id":57711,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"6972:61:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":57712,"nodeType":"ExpressionStatement","src":"6972:61:120"},"id":57713,"nodeType":"IfStatement","src":"6892:141:120","trueBody":{"expression":{"id":57707,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftHandSide":{"id":57705,"name":"_batchSubmitter","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57461,"src":"6934:15:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"Assignment","operator":"=","rightHandSide":{"id":57706,"name":"_addr","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57472,"src":"6952:5:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"src":"6934:23:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"id":57708,"nodeType":"ExpressionStatement","src":"6934:23:120"}},"id":57714,"nodeType":"IfStatement","src":"6806:227:120","trueBody":{"expression":{"id":57698,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftHandSide":{"id":57696,"name":"_unsafeBlockSigner","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57459,"src":"6851:18:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"Assignment","operator":"=","rightHandSide":{"id":57697,"name":"_addr","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57472,"src":"6872:5:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"src":"6851:26:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"id":57699,"nodeType":"ExpressionStatement","src":"6851:26:120"}},"id":57715,"nodeType":"IfStatement","src":"6738:295:120","trueBody":{"expression":{"id":57689,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftHandSide":{"id":57687,"name":"_proposer","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57457,"src":"6774:9:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"Assignment","operator":"=","rightHandSide":{"id":57688,"name":"_addr","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57472,"src":"6786:5:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"src":"6774:17:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"id":57690,"nodeType":"ExpressionStatement","src":"6774:17:120"}},"id":57716,"nodeType":"IfStatement","src":"6666:367:120","trueBody":{"expression":{"id":57680,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftHandSide":{"id":57678,"name":"_challenger","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57455,"src":"6704:11:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"Assignment","operator":"=","rightHandSide":{"id":57679,"name":"_addr","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57472,"src":"6718:5:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"src":"6704:19:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"id":57681,"nodeType":"ExpressionStatement","src":"6704:19:120"}},"id":57717,"nodeType":"IfStatement","src":"6584:449:120","trueBody":{"expression":{"id":57671,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftHandSide":{"id":57669,"name":"_opChainGuardian","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57453,"src":"6627:16:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"Assignment","operator":"=","rightHandSide":{"id":57670,"name":"_addr","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57472,"src":"6646:5:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"src":"6627:24:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"id":57672,"nodeType":"ExpressionStatement","src":"6627:24:120"}},"id":57718,"nodeType":"IfStatement","src":"6488:545:120","trueBody":{"expression":{"id":57662,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftHandSide":{"id":57660,"name":"_opChainProxyAdminOwner","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57451,"src":"6538:23:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"Assignment","operator":"=","rightHandSide":{"id":57661,"name":"_addr","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57472,"src":"6564:5:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"src":"6538:31:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"id":57663,"nodeType":"ExpressionStatement","src":"6538:31:120"}},"id":57719,"nodeType":"IfStatement","src":"6402:631:120","trueBody":{"expression":{"id":57653,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftHandSide":{"id":57651,"name":"_systemConfigOwner","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57449,"src":"6447:18:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"Assignment","operator":"=","rightHandSide":{"id":57652,"name":"_addr","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57472,"src":"6468:5:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"src":"6447:26:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"id":57654,"nodeType":"ExpressionStatement","src":"6447:26:120"}},"id":57720,"nodeType":"IfStatement","src":"6279:754:120","trueBody":{"expression":{"id":57644,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftHandSide":{"id":57642,"name":"_permissionedDisputeGameImpl","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57447,"src":"6334:28:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"Assignment","operator":"=","rightHandSide":{"id":57643,"name":"_addr","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57472,"src":"6365:5:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"src":"6334:36:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"id":57645,"nodeType":"ExpressionStatement","src":"6334:36:120"}},"id":57721,"nodeType":"IfStatement","src":"6187:846:120","trueBody":{"expression":{"id":57635,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftHandSide":{"id":57633,"name":"_faultDisputeGameImpl","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57445,"src":"6235:21:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"Assignment","operator":"=","rightHandSide":{"id":57634,"name":"_addr","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57472,"src":"6259:5:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"src":"6235:29:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"id":57636,"nodeType":"ExpressionStatement","src":"6235:29:120"}},"id":57722,"nodeType":"IfStatement","src":"6089:944:120","trueBody":{"expression":{"id":57626,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftHandSide":{"id":57624,"name":"_disputeGameFactoryProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57443,"src":"6140:24:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"Assignment","operator":"=","rightHandSide":{"id":57625,"name":"_addr","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57472,"src":"6167:5:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"src":"6140:32:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"id":57627,"nodeType":"ExpressionStatement","src":"6140:32:120"}},"id":57723,"nodeType":"IfStatement","src":"5969:1064:120","trueBody":{"expression":{"id":57617,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftHandSide":{"id":57615,"name":"_delayedWethPermissionlessGameProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57441,"src":"6031:35:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"Assignment","operator":"=","rightHandSide":{"id":57616,"name":"_addr","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57472,"src":"6069:5:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"src":"6031:43:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"id":57618,"nodeType":"ExpressionStatement","src":"6031:43:120"}},"id":57724,"nodeType":"IfStatement","src":"5853:1180:120","trueBody":{"expression":{"id":57608,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftHandSide":{"id":57606,"name":"_delayedWethPermissionedGameProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57439,"src":"5913:33:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"Assignment","operator":"=","rightHandSide":{"id":57607,"name":"_addr","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57472,"src":"5949:5:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"src":"5913:41:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"id":57609,"nodeType":"ExpressionStatement","src":"5913:41:120"}},"id":57725,"nodeType":"IfStatement","src":"5753:1280:120","trueBody":{"expression":{"id":57599,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftHandSide":{"id":57597,"name":"_anchorStateRegistryProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57437,"src":"5805:25:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"Assignment","operator":"=","rightHandSide":{"id":57598,"name":"_addr","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57472,"src":"5833:5:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"src":"5805:33:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"id":57600,"nodeType":"ExpressionStatement","src":"5805:33:120"}},"id":57726,"nodeType":"IfStatement","src":"5659:1374:120","trueBody":{"expression":{"id":57590,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftHandSide":{"id":57588,"name":"_opChainProxyAdminImpl","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57435,"src":"5708:22:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"Assignment","operator":"=","rightHandSide":{"id":57589,"name":"_addr","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57472,"src":"5733:5:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"src":"5708:30:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"id":57591,"nodeType":"ExpressionStatement","src":"5708:30:120"}},"id":57727,"nodeType":"IfStatement","src":"5573:1460:120","trueBody":{"expression":{"id":57581,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftHandSide":{"id":57579,"name":"_systemConfigProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57433,"src":"5618:18:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"Assignment","operator":"=","rightHandSide":{"id":57580,"name":"_addr","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57472,"src":"5639:5:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"src":"5618:26:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"id":57582,"nodeType":"ExpressionStatement","src":"5618:26:120"}},"id":57728,"nodeType":"IfStatement","src":"5483:1550:120","trueBody":{"expression":{"id":57572,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftHandSide":{"id":57570,"name":"_optimismPortalProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57431,"src":"5530:20:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"Assignment","operator":"=","rightHandSide":{"id":57571,"name":"_addr","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57472,"src":"5553:5:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"src":"5530:28:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"id":57573,"nodeType":"ExpressionStatement","src":"5530:28:120"}},"id":57729,"nodeType":"IfStatement","src":"5365:1668:120","trueBody":{"expression":{"id":57563,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftHandSide":{"id":57561,"name":"_optimismMintableErc20FactoryProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57429,"src":"5426:34:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"Assignment","operator":"=","rightHandSide":{"id":57562,"name":"_addr","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57472,"src":"5463:5:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"src":"5426:42:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"id":57564,"nodeType":"ExpressionStatement","src":"5426:42:120"}},"id":57730,"nodeType":"IfStatement","src":"5275:1758:120","trueBody":{"expression":{"id":57554,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftHandSide":{"id":57552,"name":"_l2OutputOracleProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57427,"src":"5322:20:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"Assignment","operator":"=","rightHandSide":{"id":57553,"name":"_addr","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57472,"src":"5345:5:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"src":"5322:28:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"id":57555,"nodeType":"ExpressionStatement","src":"5322:28:120"}},"id":57731,"nodeType":"IfStatement","src":"5181:1852:120","trueBody":{"expression":{"id":57545,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftHandSide":{"id":57543,"name":"_l1StandardBridgeProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57425,"src":"5230:22:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"Assignment","operator":"=","rightHandSide":{"id":57544,"name":"_addr","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57472,"src":"5255:5:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"src":"5230:30:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"id":57546,"nodeType":"ExpressionStatement","src":"5230:30:120"}},"id":57732,"nodeType":"IfStatement","src":"5091:1942:120","trueBody":{"expression":{"id":57536,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftHandSide":{"id":57534,"name":"_l1Erc721BridgeProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57423,"src":"5138:20:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"Assignment","operator":"=","rightHandSide":{"id":57535,"name":"_addr","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57472,"src":"5161:5:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"src":"5138:28:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"id":57537,"nodeType":"ExpressionStatement","src":"5138:28:120"}},"id":57733,"nodeType":"IfStatement","src":"4985:2048:120","trueBody":{"expression":{"id":57527,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftHandSide":{"id":57525,"name":"_l1CrossDomainMessengerProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57421,"src":"5040:28:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"Assignment","operator":"=","rightHandSide":{"id":57526,"name":"_addr","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57472,"src":"5071:5:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"src":"5040:36:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"id":57528,"nodeType":"ExpressionStatement","src":"5040:36:120"}},"id":57734,"nodeType":"IfStatement","src":"4903:2130:120","trueBody":{"expression":{"id":57518,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftHandSide":{"id":57516,"name":"_ethLockboxProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57419,"src":"4946:16:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"Assignment","operator":"=","rightHandSide":{"id":57517,"name":"_addr","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57472,"src":"4965:5:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"src":"4946:24:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"id":57519,"nodeType":"ExpressionStatement","src":"4946:24:120"}},"id":57735,"nodeType":"IfStatement","src":"4815:2218:120","trueBody":{"expression":{"id":57509,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftHandSide":{"id":57507,"name":"_addressManagerImpl","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57417,"src":"4861:19:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"Assignment","operator":"=","rightHandSide":{"id":57508,"name":"_addr","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57472,"src":"4883:5:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"src":"4861:27:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"id":57510,"nodeType":"ExpressionStatement","src":"4861:27:120"}},"id":57736,"nodeType":"IfStatement","src":"4696:2337:120","trueBody":{"expression":{"id":57500,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftHandSide":{"id":57498,"name":"_preimageOracleImpl","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57415,"src":"4742:19:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"Assignment","operator":"=","rightHandSide":{"id":57499,"name":"_addr","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57472,"src":"4764:5:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"src":"4742:27:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"id":57501,"nodeType":"ExpressionStatement","src":"4742:27:120"}},"id":57737,"nodeType":"IfStatement","src":"4628:2405:120","trueBody":{"expression":{"id":57491,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftHandSide":{"id":57489,"name":"_mipsImpl","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57413,"src":"4664:9:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"Assignment","operator":"=","rightHandSide":{"id":57490,"name":"_addr","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57472,"src":"4676:5:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"src":"4664:17:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"id":57492,"nodeType":"ExpressionStatement","src":"4664:17:120"}},"id":57738,"nodeType":"IfStatement","src":"4495:2538:120","trueBody":{"expression":{"id":57482,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftHandSide":{"id":57480,"name":"_superchainConfigProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57411,"src":"4544:22:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"Assignment","operator":"=","rightHandSide":{"id":57481,"name":"_addr","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57472,"src":"4569:5:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"src":"4544:30:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"id":57483,"nodeType":"ExpressionStatement","src":"4544:30:120"}}]},"functionSelector":"c3e39250","implemented":true,"kind":"function","modifiers":[],"name":"set","nameLocation":"4415:3:120","parameters":{"id":57473,"nodeType":"ParameterList","parameters":[{"constant":false,"id":57470,"mutability":"mutable","name":"_sel","nameLocation":"4426:4:120","nodeType":"VariableDeclaration","scope":57740,"src":"4419:11:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"},"typeName":{"id":57469,"name":"bytes4","nodeType":"ElementaryTypeName","src":"4419:6:120","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},"visibility":"internal"},{"constant":false,"id":57472,"mutability":"mutable","name":"_addr","nameLocation":"4440:5:120","nodeType":"VariableDeclaration","scope":57740,"src":"4432:13:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":57471,"name":"address","nodeType":"ElementaryTypeName","src":"4432:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"4418:28:120"},"returnParameters":{"id":57474,"nodeType":"ParameterList","parameters":[],"src":"4454:0:120"},"scope":58249,"stateMutability":"nonpayable","virtual":false,"visibility":"public"},{"id":57772,"nodeType":"FunctionDefinition","src":"7046:271:120","nodes":[],"body":{"id":57771,"nodeType":"Block","src":"7091:226:120","nodes":[],"statements":[{"condition":{"commonType":{"typeIdentifier":"t_bytes4","typeString":"bytes4"},"id":57751,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftExpression":{"id":57747,"name":"_sel","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57742,"src":"7105:4:120","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},"nodeType":"BinaryOperation","operator":"==","rightExpression":{"expression":{"expression":{"id":57748,"name":"this","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":-28,"src":"7113:4:120","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$58249","typeString":"contract FetchChainInfoOutput"}},"id":57749,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"7118:12:120","memberName":"permissioned","nodeType":"MemberAccess","referencedDeclaration":58231,"src":"7113:17:120","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_bool_$","typeString":"function () view external returns (bool)"}},"id":57750,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"memberLocation":"7131:8:120","memberName":"selector","nodeType":"MemberAccess","src":"7113:26:120","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},"src":"7105:34:120","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},"falseBody":{"condition":{"commonType":{"typeIdentifier":"t_bytes4","typeString":"bytes4"},"id":57760,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftExpression":{"id":57756,"name":"_sel","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57742,"src":"7181:4:120","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},"nodeType":"BinaryOperation","operator":"==","rightExpression":{"expression":{"expression":{"id":57757,"name":"this","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":-28,"src":"7189:4:120","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$58249","typeString":"contract FetchChainInfoOutput"}},"id":57758,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"7194:14:120","memberName":"permissionless","nodeType":"MemberAccess","referencedDeclaration":58239,"src":"7189:19:120","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_bool_$","typeString":"function () view external returns (bool)"}},"id":57759,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"memberLocation":"7209:8:120","memberName":"selector","nodeType":"MemberAccess","src":"7189:28:120","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},"src":"7181:36:120","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},"falseBody":{"expression":{"arguments":[{"hexValue":"4665746368436861696e496e666f4f75747075743a20756e6b6e6f776e20626f6f6c2073656c6563746f72","id":57766,"isConstant":false,"isLValue":false,"isPure":true,"kind":"string","lValueRequested":false,"nodeType":"Literal","src":"7264:45:120","typeDescriptions":{"typeIdentifier":"t_stringliteral_b43e73201a672ac9d292be9f8dc7215ba0fae6d34ae76c7f77ffd9b31af48fae","typeString":"literal_string \"FetchChainInfoOutput: unknown bool selector\""},"value":"FetchChainInfoOutput: unknown bool selector"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_stringliteral_b43e73201a672ac9d292be9f8dc7215ba0fae6d34ae76c7f77ffd9b31af48fae","typeString":"literal_string \"FetchChainInfoOutput: unknown bool selector\""}],"id":57765,"name":"revert","nodeType":"Identifier","overloadedDeclarations":[-19,-19],"referencedDeclaration":-19,"src":"7257:6:120","typeDescriptions":{"typeIdentifier":"t_function_revert_pure$_t_string_memory_ptr_$returns$__$","typeString":"function (string memory) pure"}},"id":57767,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"7257:53:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":57768,"nodeType":"ExpressionStatement","src":"7257:53:120"},"id":57769,"nodeType":"IfStatement","src":"7177:133:120","trueBody":{"expression":{"id":57763,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftHandSide":{"id":57761,"name":"_permissionless","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57465,"src":"7219:15:120","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},"nodeType":"Assignment","operator":"=","rightHandSide":{"id":57762,"name":"_bool","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57744,"src":"7237:5:120","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},"src":"7219:23:120","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},"id":57764,"nodeType":"ExpressionStatement","src":"7219:23:120"}},"id":57770,"nodeType":"IfStatement","src":"7101:209:120","trueBody":{"expression":{"id":57754,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftHandSide":{"id":57752,"name":"_permissioned","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57463,"src":"7141:13:120","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},"nodeType":"Assignment","operator":"=","rightHandSide":{"id":57753,"name":"_bool","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57744,"src":"7157:5:120","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},"src":"7141:21:120","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},"id":57755,"nodeType":"ExpressionStatement","src":"7141:21:120"}}]},"functionSelector":"baa1e15e","implemented":true,"kind":"function","modifiers":[],"name":"set","nameLocation":"7055:3:120","parameters":{"id":57745,"nodeType":"ParameterList","parameters":[{"constant":false,"id":57742,"mutability":"mutable","name":"_sel","nameLocation":"7066:4:120","nodeType":"VariableDeclaration","scope":57772,"src":"7059:11:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"},"typeName":{"id":57741,"name":"bytes4","nodeType":"ElementaryTypeName","src":"7059:6:120","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},"visibility":"internal"},{"constant":false,"id":57744,"mutability":"mutable","name":"_bool","nameLocation":"7077:5:120","nodeType":"VariableDeclaration","scope":57772,"src":"7072:10:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"},"typeName":{"id":57743,"name":"bool","nodeType":"ElementaryTypeName","src":"7072:4:120","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},"visibility":"internal"}],"src":"7058:25:120"},"returnParameters":{"id":57746,"nodeType":"ParameterList","parameters":[],"src":"7091:0:120"},"scope":58249,"stateMutability":"nonpayable","virtual":false,"visibility":"public"},{"id":57795,"nodeType":"FunctionDefinition","src":"7323:217:120","nodes":[],"body":{"id":57794,"nodeType":"Block","src":"7376:164:120","nodes":[],"statements":[{"condition":{"commonType":{"typeIdentifier":"t_bytes4","typeString":"bytes4"},"id":57784,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftExpression":{"id":57780,"name":"_sel","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57774,"src":"7390:4:120","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},"nodeType":"BinaryOperation","operator":"==","rightExpression":{"expression":{"expression":{"id":57781,"name":"this","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":-28,"src":"7398:4:120","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$58249","typeString":"contract FetchChainInfoOutput"}},"id":57782,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"7403:17:120","memberName":"respectedGameType","nodeType":"MemberAccess","referencedDeclaration":58248,"src":"7398:22:120","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_userDefinedValueType$_GameType_$75355_$","typeString":"function () view external returns (GameType)"}},"id":57783,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"memberLocation":"7421:8:120","memberName":"selector","nodeType":"MemberAccess","src":"7398:31:120","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},"src":"7390:39:120","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},"falseBody":{"expression":{"arguments":[{"hexValue":"4665746368436861696e496e666f4f75747075743a20756e6b6e6f776e2047616d65547970652073656c6563746f72","id":57790,"isConstant":false,"isLValue":false,"isPure":true,"kind":"string","lValueRequested":false,"nodeType":"Literal","src":"7483:49:120","typeDescriptions":{"typeIdentifier":"t_stringliteral_520d3d0cced140fee76c803f92d1db783b790e13f72de1e8f8c229c8c8783afc","typeString":"literal_string \"FetchChainInfoOutput: unknown GameType selector\""},"value":"FetchChainInfoOutput: unknown GameType selector"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_stringliteral_520d3d0cced140fee76c803f92d1db783b790e13f72de1e8f8c229c8c8783afc","typeString":"literal_string \"FetchChainInfoOutput: unknown GameType selector\""}],"id":57789,"name":"revert","nodeType":"Identifier","overloadedDeclarations":[-19,-19],"referencedDeclaration":-19,"src":"7476:6:120","typeDescriptions":{"typeIdentifier":"t_function_revert_pure$_t_string_memory_ptr_$returns$__$","typeString":"function (string memory) pure"}},"id":57791,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"7476:57:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":57792,"nodeType":"ExpressionStatement","src":"7476:57:120"},"id":57793,"nodeType":"IfStatement","src":"7386:147:120","trueBody":{"expression":{"id":57787,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftHandSide":{"id":57785,"name":"_respectedGameType","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57468,"src":"7431:18:120","typeDescriptions":{"typeIdentifier":"t_userDefinedValueType$_GameType_$75355","typeString":"GameType"}},"nodeType":"Assignment","operator":"=","rightHandSide":{"id":57786,"name":"_gameType","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57777,"src":"7452:9:120","typeDescriptions":{"typeIdentifier":"t_userDefinedValueType$_GameType_$75355","typeString":"GameType"}},"src":"7431:30:120","typeDescriptions":{"typeIdentifier":"t_userDefinedValueType$_GameType_$75355","typeString":"GameType"}},"id":57788,"nodeType":"ExpressionStatement","src":"7431:30:120"}}]},"functionSelector":"d08d6066","implemented":true,"kind":"function","modifiers":[],"name":"set","nameLocation":"7332:3:120","parameters":{"id":57778,"nodeType":"ParameterList","parameters":[{"constant":false,"id":57774,"mutability":"mutable","name":"_sel","nameLocation":"7343:4:120","nodeType":"VariableDeclaration","scope":57795,"src":"7336:11:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"},"typeName":{"id":57773,"name":"bytes4","nodeType":"ElementaryTypeName","src":"7336:6:120","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},"visibility":"internal"},{"constant":false,"id":57777,"mutability":"mutable","name":"_gameType","nameLocation":"7358:9:120","nodeType":"VariableDeclaration","scope":57795,"src":"7349:18:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_userDefinedValueType$_GameType_$75355","typeString":"GameType"},"typeName":{"id":57776,"nodeType":"UserDefinedTypeName","pathNode":{"id":57775,"name":"GameType","nameLocations":["7349:8:120"],"nodeType":"IdentifierPath","referencedDeclaration":75355,"src":"7349:8:120"},"referencedDeclaration":75355,"src":"7349:8:120","typeDescriptions":{"typeIdentifier":"t_userDefinedValueType$_GameType_$75355","typeString":"GameType"}},"visibility":"internal"}],"src":"7335:33:120"},"returnParameters":{"id":57779,"nodeType":"ParameterList","parameters":[],"src":"7376:0:120"},"scope":58249,"stateMutability":"nonpayable","virtual":false,"visibility":"public"},{"id":57813,"nodeType":"FunctionDefinition","src":"7546:207:120","nodes":[],"body":{"id":57812,"nodeType":"Block","src":"7606:147:120","nodes":[],"statements":[{"expression":{"arguments":[{"commonType":{"typeIdentifier":"t_address","typeString":"address"},"id":57806,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftExpression":{"id":57801,"name":"_addressManagerImpl","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57417,"src":"7624:19:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"BinaryOperation","operator":"!=","rightExpression":{"arguments":[{"hexValue":"30","id":57804,"isConstant":false,"isLValue":false,"isPure":true,"kind":"number","lValueRequested":false,"nodeType":"Literal","src":"7655:1:120","typeDescriptions":{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"},"value":"0"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"}],"id":57803,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"nodeType":"ElementaryTypeNameExpression","src":"7647:7:120","typeDescriptions":{"typeIdentifier":"t_type$_t_address_$","typeString":"type(address)"},"typeName":{"id":57802,"name":"address","nodeType":"ElementaryTypeName","src":"7647:7:120","typeDescriptions":{}}},"id":57805,"isConstant":false,"isLValue":false,"isPure":true,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"7647:10:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"src":"7624:33:120","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},{"hexValue":"4665746368436861696e496e666f4f75747075743a20616464726573734d616e61676572496d706c206e6f7420736574","id":57807,"isConstant":false,"isLValue":false,"isPure":true,"kind":"string","lValueRequested":false,"nodeType":"Literal","src":"7659:50:120","typeDescriptions":{"typeIdentifier":"t_stringliteral_b154041fe6470d62d16e8ad5c6d8e6c50a46e3e155a380b02703b07321b83f6a","typeString":"literal_string \"FetchChainInfoOutput: addressManagerImpl not set\""},"value":"FetchChainInfoOutput: addressManagerImpl not set"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_bool","typeString":"bool"},{"typeIdentifier":"t_stringliteral_b154041fe6470d62d16e8ad5c6d8e6c50a46e3e155a380b02703b07321b83f6a","typeString":"literal_string \"FetchChainInfoOutput: addressManagerImpl not set\""}],"id":57800,"name":"require","nodeType":"Identifier","overloadedDeclarations":[-18,-18],"referencedDeclaration":-18,"src":"7616:7:120","typeDescriptions":{"typeIdentifier":"t_function_require_pure$_t_bool_$_t_string_memory_ptr_$returns$__$","typeString":"function (bool,string memory) pure"}},"id":57808,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"7616:94:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":57809,"nodeType":"ExpressionStatement","src":"7616:94:120"},{"expression":{"id":57810,"name":"_addressManagerImpl","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57417,"src":"7727:19:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"functionReturnParameters":57799,"id":57811,"nodeType":"Return","src":"7720:26:120"}]},"functionSelector":"bd366b8f","implemented":true,"kind":"function","modifiers":[],"name":"addressManagerImpl","nameLocation":"7555:18:120","parameters":{"id":57796,"nodeType":"ParameterList","parameters":[],"src":"7573:2:120"},"returnParameters":{"id":57799,"nodeType":"ParameterList","parameters":[{"constant":false,"id":57798,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":57813,"src":"7597:7:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":57797,"name":"address","nodeType":"ElementaryTypeName","src":"7597:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"7596:9:120"},"scope":58249,"stateMutability":"view","virtual":false,"visibility":"public"},{"id":57821,"nodeType":"FunctionDefinition","src":"7759:97:120","nodes":[],"body":{"id":57820,"nodeType":"Block","src":"7816:40:120","nodes":[],"statements":[{"expression":{"id":57818,"name":"_ethLockboxProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57419,"src":"7833:16:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"functionReturnParameters":57817,"id":57819,"nodeType":"Return","src":"7826:23:120"}]},"functionSelector":"f646b07c","implemented":true,"kind":"function","modifiers":[],"name":"ethLockboxProxy","nameLocation":"7768:15:120","parameters":{"id":57814,"nodeType":"ParameterList","parameters":[],"src":"7783:2:120"},"returnParameters":{"id":57817,"nodeType":"ParameterList","parameters":[{"constant":false,"id":57816,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":57821,"src":"7807:7:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":57815,"name":"address","nodeType":"ElementaryTypeName","src":"7807:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"7806:9:120"},"scope":58249,"stateMutability":"view","virtual":false,"visibility":"public"},{"id":57839,"nodeType":"FunctionDefinition","src":"7862:243:120","nodes":[],"body":{"id":57838,"nodeType":"Block","src":"7931:174:120","nodes":[],"statements":[{"expression":{"arguments":[{"commonType":{"typeIdentifier":"t_address","typeString":"address"},"id":57832,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftExpression":{"id":57827,"name":"_l1CrossDomainMessengerProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57421,"src":"7949:28:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"BinaryOperation","operator":"!=","rightExpression":{"arguments":[{"hexValue":"30","id":57830,"isConstant":false,"isLValue":false,"isPure":true,"kind":"number","lValueRequested":false,"nodeType":"Literal","src":"7989:1:120","typeDescriptions":{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"},"value":"0"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"}],"id":57829,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"nodeType":"ElementaryTypeNameExpression","src":"7981:7:120","typeDescriptions":{"typeIdentifier":"t_type$_t_address_$","typeString":"type(address)"},"typeName":{"id":57828,"name":"address","nodeType":"ElementaryTypeName","src":"7981:7:120","typeDescriptions":{}}},"id":57831,"isConstant":false,"isLValue":false,"isPure":true,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"7981:10:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"src":"7949:42:120","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},{"hexValue":"4665746368436861696e496e666f4f75747075743a206c3143726f7373446f6d61696e4d657373656e67657250726f7879206e6f7420736574","id":57833,"isConstant":false,"isLValue":false,"isPure":true,"kind":"string","lValueRequested":false,"nodeType":"Literal","src":"7993:59:120","typeDescriptions":{"typeIdentifier":"t_stringliteral_c51216a9bdef996dd7040e19ba4fe817587273a187f1f145abfd19b1308df5eb","typeString":"literal_string \"FetchChainInfoOutput: l1CrossDomainMessengerProxy not set\""},"value":"FetchChainInfoOutput: l1CrossDomainMessengerProxy not set"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_bool","typeString":"bool"},{"typeIdentifier":"t_stringliteral_c51216a9bdef996dd7040e19ba4fe817587273a187f1f145abfd19b1308df5eb","typeString":"literal_string \"FetchChainInfoOutput: l1CrossDomainMessengerProxy not set\""}],"id":57826,"name":"require","nodeType":"Identifier","overloadedDeclarations":[-18,-18],"referencedDeclaration":-18,"src":"7941:7:120","typeDescriptions":{"typeIdentifier":"t_function_require_pure$_t_bool_$_t_string_memory_ptr_$returns$__$","typeString":"function (bool,string memory) pure"}},"id":57834,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"7941:112:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":57835,"nodeType":"ExpressionStatement","src":"7941:112:120"},{"expression":{"id":57836,"name":"_l1CrossDomainMessengerProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57421,"src":"8070:28:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"functionReturnParameters":57825,"id":57837,"nodeType":"Return","src":"8063:35:120"}]},"functionSelector":"54729cfb","implemented":true,"kind":"function","modifiers":[],"name":"l1CrossDomainMessengerProxy","nameLocation":"7871:27:120","parameters":{"id":57822,"nodeType":"ParameterList","parameters":[],"src":"7898:2:120"},"returnParameters":{"id":57825,"nodeType":"ParameterList","parameters":[{"constant":false,"id":57824,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":57839,"src":"7922:7:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":57823,"name":"address","nodeType":"ElementaryTypeName","src":"7922:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"7921:9:120"},"scope":58249,"stateMutability":"view","virtual":false,"visibility":"public"},{"id":57857,"nodeType":"FunctionDefinition","src":"8111:211:120","nodes":[],"body":{"id":57856,"nodeType":"Block","src":"8172:150:120","nodes":[],"statements":[{"expression":{"arguments":[{"commonType":{"typeIdentifier":"t_address","typeString":"address"},"id":57850,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftExpression":{"id":57845,"name":"_l1Erc721BridgeProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57423,"src":"8190:20:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"BinaryOperation","operator":"!=","rightExpression":{"arguments":[{"hexValue":"30","id":57848,"isConstant":false,"isLValue":false,"isPure":true,"kind":"number","lValueRequested":false,"nodeType":"Literal","src":"8222:1:120","typeDescriptions":{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"},"value":"0"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"}],"id":57847,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"nodeType":"ElementaryTypeNameExpression","src":"8214:7:120","typeDescriptions":{"typeIdentifier":"t_type$_t_address_$","typeString":"type(address)"},"typeName":{"id":57846,"name":"address","nodeType":"ElementaryTypeName","src":"8214:7:120","typeDescriptions":{}}},"id":57849,"isConstant":false,"isLValue":false,"isPure":true,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"8214:10:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"src":"8190:34:120","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},{"hexValue":"4665746368436861696e496e666f4f75747075743a206c3145726337323142726964676550726f7879206e6f7420736574","id":57851,"isConstant":false,"isLValue":false,"isPure":true,"kind":"string","lValueRequested":false,"nodeType":"Literal","src":"8226:51:120","typeDescriptions":{"typeIdentifier":"t_stringliteral_bdf5319949d8561b59a02fe667aa58fca11f5f8571bc18997b0bc0ac582aece7","typeString":"literal_string \"FetchChainInfoOutput: l1Erc721BridgeProxy not set\""},"value":"FetchChainInfoOutput: l1Erc721BridgeProxy not set"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_bool","typeString":"bool"},{"typeIdentifier":"t_stringliteral_bdf5319949d8561b59a02fe667aa58fca11f5f8571bc18997b0bc0ac582aece7","typeString":"literal_string \"FetchChainInfoOutput: l1Erc721BridgeProxy not set\""}],"id":57844,"name":"require","nodeType":"Identifier","overloadedDeclarations":[-18,-18],"referencedDeclaration":-18,"src":"8182:7:120","typeDescriptions":{"typeIdentifier":"t_function_require_pure$_t_bool_$_t_string_memory_ptr_$returns$__$","typeString":"function (bool,string memory) pure"}},"id":57852,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"8182:96:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":57853,"nodeType":"ExpressionStatement","src":"8182:96:120"},{"expression":{"id":57854,"name":"_l1Erc721BridgeProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57423,"src":"8295:20:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"functionReturnParameters":57843,"id":57855,"nodeType":"Return","src":"8288:27:120"}]},"functionSelector":"ebfa8409","implemented":true,"kind":"function","modifiers":[],"name":"l1Erc721BridgeProxy","nameLocation":"8120:19:120","parameters":{"id":57840,"nodeType":"ParameterList","parameters":[],"src":"8139:2:120"},"returnParameters":{"id":57843,"nodeType":"ParameterList","parameters":[{"constant":false,"id":57842,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":57857,"src":"8163:7:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":57841,"name":"address","nodeType":"ElementaryTypeName","src":"8163:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"8162:9:120"},"scope":58249,"stateMutability":"view","virtual":false,"visibility":"public"},{"id":57875,"nodeType":"FunctionDefinition","src":"8328:219:120","nodes":[],"body":{"id":57874,"nodeType":"Block","src":"8391:156:120","nodes":[],"statements":[{"expression":{"arguments":[{"commonType":{"typeIdentifier":"t_address","typeString":"address"},"id":57868,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftExpression":{"id":57863,"name":"_l1StandardBridgeProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57425,"src":"8409:22:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"BinaryOperation","operator":"!=","rightExpression":{"arguments":[{"hexValue":"30","id":57866,"isConstant":false,"isLValue":false,"isPure":true,"kind":"number","lValueRequested":false,"nodeType":"Literal","src":"8443:1:120","typeDescriptions":{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"},"value":"0"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"}],"id":57865,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"nodeType":"ElementaryTypeNameExpression","src":"8435:7:120","typeDescriptions":{"typeIdentifier":"t_type$_t_address_$","typeString":"type(address)"},"typeName":{"id":57864,"name":"address","nodeType":"ElementaryTypeName","src":"8435:7:120","typeDescriptions":{}}},"id":57867,"isConstant":false,"isLValue":false,"isPure":true,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"8435:10:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"src":"8409:36:120","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},{"hexValue":"4665746368436861696e496e666f4f75747075743a206c315374616e6461726442726964676550726f7879206e6f7420736574","id":57869,"isConstant":false,"isLValue":false,"isPure":true,"kind":"string","lValueRequested":false,"nodeType":"Literal","src":"8447:53:120","typeDescriptions":{"typeIdentifier":"t_stringliteral_ab3776e760de395cff3bb935602469d5b7c0bd9b5cfaefde9d221be6524302e1","typeString":"literal_string \"FetchChainInfoOutput: l1StandardBridgeProxy not set\""},"value":"FetchChainInfoOutput: l1StandardBridgeProxy not set"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_bool","typeString":"bool"},{"typeIdentifier":"t_stringliteral_ab3776e760de395cff3bb935602469d5b7c0bd9b5cfaefde9d221be6524302e1","typeString":"literal_string \"FetchChainInfoOutput: l1StandardBridgeProxy not set\""}],"id":57862,"name":"require","nodeType":"Identifier","overloadedDeclarations":[-18,-18],"referencedDeclaration":-18,"src":"8401:7:120","typeDescriptions":{"typeIdentifier":"t_function_require_pure$_t_bool_$_t_string_memory_ptr_$returns$__$","typeString":"function (bool,string memory) pure"}},"id":57870,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"8401:100:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":57871,"nodeType":"ExpressionStatement","src":"8401:100:120"},{"expression":{"id":57872,"name":"_l1StandardBridgeProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57425,"src":"8518:22:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"functionReturnParameters":57861,"id":57873,"nodeType":"Return","src":"8511:29:120"}]},"functionSelector":"102b6069","implemented":true,"kind":"function","modifiers":[],"name":"l1StandardBridgeProxy","nameLocation":"8337:21:120","parameters":{"id":57858,"nodeType":"ParameterList","parameters":[],"src":"8358:2:120"},"returnParameters":{"id":57861,"nodeType":"ParameterList","parameters":[{"constant":false,"id":57860,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":57875,"src":"8382:7:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":57859,"name":"address","nodeType":"ElementaryTypeName","src":"8382:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"8381:9:120"},"scope":58249,"stateMutability":"view","virtual":false,"visibility":"public"},{"id":57893,"nodeType":"FunctionDefinition","src":"8553:211:120","nodes":[],"body":{"id":57892,"nodeType":"Block","src":"8614:150:120","nodes":[],"statements":[{"expression":{"arguments":[{"commonType":{"typeIdentifier":"t_address","typeString":"address"},"id":57886,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftExpression":{"id":57881,"name":"_l2OutputOracleProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57427,"src":"8632:20:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"BinaryOperation","operator":"!=","rightExpression":{"arguments":[{"hexValue":"30","id":57884,"isConstant":false,"isLValue":false,"isPure":true,"kind":"number","lValueRequested":false,"nodeType":"Literal","src":"8664:1:120","typeDescriptions":{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"},"value":"0"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"}],"id":57883,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"nodeType":"ElementaryTypeNameExpression","src":"8656:7:120","typeDescriptions":{"typeIdentifier":"t_type$_t_address_$","typeString":"type(address)"},"typeName":{"id":57882,"name":"address","nodeType":"ElementaryTypeName","src":"8656:7:120","typeDescriptions":{}}},"id":57885,"isConstant":false,"isLValue":false,"isPure":true,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"8656:10:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"src":"8632:34:120","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},{"hexValue":"4665746368436861696e496e666f4f75747075743a206c324f75747075744f7261636c6550726f7879206e6f7420736574","id":57887,"isConstant":false,"isLValue":false,"isPure":true,"kind":"string","lValueRequested":false,"nodeType":"Literal","src":"8668:51:120","typeDescriptions":{"typeIdentifier":"t_stringliteral_2f861759874f8f3e0cfa53ef8dfb0556f88f877edbaf1dbc485fc820d67ac86a","typeString":"literal_string \"FetchChainInfoOutput: l2OutputOracleProxy not set\""},"value":"FetchChainInfoOutput: l2OutputOracleProxy not set"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_bool","typeString":"bool"},{"typeIdentifier":"t_stringliteral_2f861759874f8f3e0cfa53ef8dfb0556f88f877edbaf1dbc485fc820d67ac86a","typeString":"literal_string \"FetchChainInfoOutput: l2OutputOracleProxy not set\""}],"id":57880,"name":"require","nodeType":"Identifier","overloadedDeclarations":[-18,-18],"referencedDeclaration":-18,"src":"8624:7:120","typeDescriptions":{"typeIdentifier":"t_function_require_pure$_t_bool_$_t_string_memory_ptr_$returns$__$","typeString":"function (bool,string memory) pure"}},"id":57888,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"8624:96:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":57889,"nodeType":"ExpressionStatement","src":"8624:96:120"},{"expression":{"id":57890,"name":"_l2OutputOracleProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57427,"src":"8737:20:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"functionReturnParameters":57879,"id":57891,"nodeType":"Return","src":"8730:27:120"}]},"functionSelector":"a2c9a89f","implemented":true,"kind":"function","modifiers":[],"name":"l2OutputOracleProxy","nameLocation":"8562:19:120","parameters":{"id":57876,"nodeType":"ParameterList","parameters":[],"src":"8581:2:120"},"returnParameters":{"id":57879,"nodeType":"ParameterList","parameters":[{"constant":false,"id":57878,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":57893,"src":"8605:7:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":57877,"name":"address","nodeType":"ElementaryTypeName","src":"8605:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"8604:9:120"},"scope":58249,"stateMutability":"view","virtual":false,"visibility":"public"},{"id":57911,"nodeType":"FunctionDefinition","src":"8770:301:120","nodes":[],"body":{"id":57910,"nodeType":"Block","src":"8845:226:120","nodes":[],"statements":[{"expression":{"arguments":[{"commonType":{"typeIdentifier":"t_address","typeString":"address"},"id":57904,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftExpression":{"id":57899,"name":"_optimismMintableErc20FactoryProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57429,"src":"8876:34:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"BinaryOperation","operator":"!=","rightExpression":{"arguments":[{"hexValue":"30","id":57902,"isConstant":false,"isLValue":false,"isPure":true,"kind":"number","lValueRequested":false,"nodeType":"Literal","src":"8922:1:120","typeDescriptions":{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"},"value":"0"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"}],"id":57901,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"nodeType":"ElementaryTypeNameExpression","src":"8914:7:120","typeDescriptions":{"typeIdentifier":"t_type$_t_address_$","typeString":"type(address)"},"typeName":{"id":57900,"name":"address","nodeType":"ElementaryTypeName","src":"8914:7:120","typeDescriptions":{}}},"id":57903,"isConstant":false,"isLValue":false,"isPure":true,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"8914:10:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"src":"8876:48:120","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},{"hexValue":"4665746368436861696e496e666f4f75747075743a206f7074696d69736d4d696e7461626c654572633230466163746f727950726f7879206e6f7420736574","id":57905,"isConstant":false,"isLValue":false,"isPure":true,"kind":"string","lValueRequested":false,"nodeType":"Literal","src":"8938:65:120","typeDescriptions":{"typeIdentifier":"t_stringliteral_58c040fbde84bd4afd9f21f5ba3150dab029d767b65aafdf14512bdafdbd9954","typeString":"literal_string \"FetchChainInfoOutput: optimismMintableErc20FactoryProxy not set\""},"value":"FetchChainInfoOutput: optimismMintableErc20FactoryProxy not set"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_bool","typeString":"bool"},{"typeIdentifier":"t_stringliteral_58c040fbde84bd4afd9f21f5ba3150dab029d767b65aafdf14512bdafdbd9954","typeString":"literal_string \"FetchChainInfoOutput: optimismMintableErc20FactoryProxy not set\""}],"id":57898,"name":"require","nodeType":"Identifier","overloadedDeclarations":[-18,-18],"referencedDeclaration":-18,"src":"8855:7:120","typeDescriptions":{"typeIdentifier":"t_function_require_pure$_t_bool_$_t_string_memory_ptr_$returns$__$","typeString":"function (bool,string memory) pure"}},"id":57906,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"8855:158:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":57907,"nodeType":"ExpressionStatement","src":"8855:158:120"},{"expression":{"id":57908,"name":"_optimismMintableErc20FactoryProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57429,"src":"9030:34:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"functionReturnParameters":57897,"id":57909,"nodeType":"Return","src":"9023:41:120"}]},"functionSelector":"8f20c7e4","implemented":true,"kind":"function","modifiers":[],"name":"optimismMintableErc20FactoryProxy","nameLocation":"8779:33:120","parameters":{"id":57894,"nodeType":"ParameterList","parameters":[],"src":"8812:2:120"},"returnParameters":{"id":57897,"nodeType":"ParameterList","parameters":[{"constant":false,"id":57896,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":57911,"src":"8836:7:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":57895,"name":"address","nodeType":"ElementaryTypeName","src":"8836:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"8835:9:120"},"scope":58249,"stateMutability":"view","virtual":false,"visibility":"public"},{"id":57929,"nodeType":"FunctionDefinition","src":"9077:211:120","nodes":[],"body":{"id":57928,"nodeType":"Block","src":"9138:150:120","nodes":[],"statements":[{"expression":{"arguments":[{"commonType":{"typeIdentifier":"t_address","typeString":"address"},"id":57922,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftExpression":{"id":57917,"name":"_optimismPortalProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57431,"src":"9156:20:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"BinaryOperation","operator":"!=","rightExpression":{"arguments":[{"hexValue":"30","id":57920,"isConstant":false,"isLValue":false,"isPure":true,"kind":"number","lValueRequested":false,"nodeType":"Literal","src":"9188:1:120","typeDescriptions":{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"},"value":"0"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"}],"id":57919,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"nodeType":"ElementaryTypeNameExpression","src":"9180:7:120","typeDescriptions":{"typeIdentifier":"t_type$_t_address_$","typeString":"type(address)"},"typeName":{"id":57918,"name":"address","nodeType":"ElementaryTypeName","src":"9180:7:120","typeDescriptions":{}}},"id":57921,"isConstant":false,"isLValue":false,"isPure":true,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"9180:10:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"src":"9156:34:120","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},{"hexValue":"4665746368436861696e496e666f4f75747075743a206f7074696d69736d506f7274616c50726f7879206e6f7420736574","id":57923,"isConstant":false,"isLValue":false,"isPure":true,"kind":"string","lValueRequested":false,"nodeType":"Literal","src":"9192:51:120","typeDescriptions":{"typeIdentifier":"t_stringliteral_ef003bab75ab0cfa4ca81f99eb20b37a3fded08fa7502df7d991f596c8680642","typeString":"literal_string \"FetchChainInfoOutput: optimismPortalProxy not set\""},"value":"FetchChainInfoOutput: optimismPortalProxy not set"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_bool","typeString":"bool"},{"typeIdentifier":"t_stringliteral_ef003bab75ab0cfa4ca81f99eb20b37a3fded08fa7502df7d991f596c8680642","typeString":"literal_string \"FetchChainInfoOutput: optimismPortalProxy not set\""}],"id":57916,"name":"require","nodeType":"Identifier","overloadedDeclarations":[-18,-18],"referencedDeclaration":-18,"src":"9148:7:120","typeDescriptions":{"typeIdentifier":"t_function_require_pure$_t_bool_$_t_string_memory_ptr_$returns$__$","typeString":"function (bool,string memory) pure"}},"id":57924,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"9148:96:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":57925,"nodeType":"ExpressionStatement","src":"9148:96:120"},{"expression":{"id":57926,"name":"_optimismPortalProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57431,"src":"9261:20:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"functionReturnParameters":57915,"id":57927,"nodeType":"Return","src":"9254:27:120"}]},"functionSelector":"04451c49","implemented":true,"kind":"function","modifiers":[],"name":"optimismPortalProxy","nameLocation":"9086:19:120","parameters":{"id":57912,"nodeType":"ParameterList","parameters":[],"src":"9105:2:120"},"returnParameters":{"id":57915,"nodeType":"ParameterList","parameters":[{"constant":false,"id":57914,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":57929,"src":"9129:7:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":57913,"name":"address","nodeType":"ElementaryTypeName","src":"9129:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"9128:9:120"},"scope":58249,"stateMutability":"view","virtual":false,"visibility":"public"},{"id":57947,"nodeType":"FunctionDefinition","src":"9294:203:120","nodes":[],"body":{"id":57946,"nodeType":"Block","src":"9353:144:120","nodes":[],"statements":[{"expression":{"arguments":[{"commonType":{"typeIdentifier":"t_address","typeString":"address"},"id":57940,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftExpression":{"id":57935,"name":"_systemConfigProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57433,"src":"9371:18:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"BinaryOperation","operator":"!=","rightExpression":{"arguments":[{"hexValue":"30","id":57938,"isConstant":false,"isLValue":false,"isPure":true,"kind":"number","lValueRequested":false,"nodeType":"Literal","src":"9401:1:120","typeDescriptions":{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"},"value":"0"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"}],"id":57937,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"nodeType":"ElementaryTypeNameExpression","src":"9393:7:120","typeDescriptions":{"typeIdentifier":"t_type$_t_address_$","typeString":"type(address)"},"typeName":{"id":57936,"name":"address","nodeType":"ElementaryTypeName","src":"9393:7:120","typeDescriptions":{}}},"id":57939,"isConstant":false,"isLValue":false,"isPure":true,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"9393:10:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"src":"9371:32:120","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},{"hexValue":"4665746368436861696e496e666f4f75747075743a2073797374656d436f6e66696750726f7879206e6f7420736574","id":57941,"isConstant":false,"isLValue":false,"isPure":true,"kind":"string","lValueRequested":false,"nodeType":"Literal","src":"9405:49:120","typeDescriptions":{"typeIdentifier":"t_stringliteral_09ada010329fb4e012f4c857519ec176efea734f55c01f382f1b6c7bd752716b","typeString":"literal_string \"FetchChainInfoOutput: systemConfigProxy not set\""},"value":"FetchChainInfoOutput: systemConfigProxy not set"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_bool","typeString":"bool"},{"typeIdentifier":"t_stringliteral_09ada010329fb4e012f4c857519ec176efea734f55c01f382f1b6c7bd752716b","typeString":"literal_string \"FetchChainInfoOutput: systemConfigProxy not set\""}],"id":57934,"name":"require","nodeType":"Identifier","overloadedDeclarations":[-18,-18],"referencedDeclaration":-18,"src":"9363:7:120","typeDescriptions":{"typeIdentifier":"t_function_require_pure$_t_bool_$_t_string_memory_ptr_$returns$__$","typeString":"function (bool,string memory) pure"}},"id":57942,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"9363:92:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":57943,"nodeType":"ExpressionStatement","src":"9363:92:120"},{"expression":{"id":57944,"name":"_systemConfigProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57433,"src":"9472:18:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"functionReturnParameters":57933,"id":57945,"nodeType":"Return","src":"9465:25:120"}]},"functionSelector":"c17db6e3","implemented":true,"kind":"function","modifiers":[],"name":"systemConfigProxy","nameLocation":"9303:17:120","parameters":{"id":57930,"nodeType":"ParameterList","parameters":[],"src":"9320:2:120"},"returnParameters":{"id":57933,"nodeType":"ParameterList","parameters":[{"constant":false,"id":57932,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":57947,"src":"9344:7:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":57931,"name":"address","nodeType":"ElementaryTypeName","src":"9344:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"9343:9:120"},"scope":58249,"stateMutability":"view","virtual":false,"visibility":"public"},{"id":57965,"nodeType":"FunctionDefinition","src":"9503:219:120","nodes":[],"body":{"id":57964,"nodeType":"Block","src":"9566:156:120","nodes":[],"statements":[{"expression":{"arguments":[{"commonType":{"typeIdentifier":"t_address","typeString":"address"},"id":57958,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftExpression":{"id":57953,"name":"_opChainProxyAdminImpl","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57435,"src":"9584:22:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"BinaryOperation","operator":"!=","rightExpression":{"arguments":[{"hexValue":"30","id":57956,"isConstant":false,"isLValue":false,"isPure":true,"kind":"number","lValueRequested":false,"nodeType":"Literal","src":"9618:1:120","typeDescriptions":{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"},"value":"0"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"}],"id":57955,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"nodeType":"ElementaryTypeNameExpression","src":"9610:7:120","typeDescriptions":{"typeIdentifier":"t_type$_t_address_$","typeString":"type(address)"},"typeName":{"id":57954,"name":"address","nodeType":"ElementaryTypeName","src":"9610:7:120","typeDescriptions":{}}},"id":57957,"isConstant":false,"isLValue":false,"isPure":true,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"9610:10:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"src":"9584:36:120","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},{"hexValue":"4665746368436861696e496e666f4f75747075743a206f70436861696e50726f787941646d696e496d706c206e6f7420736574","id":57959,"isConstant":false,"isLValue":false,"isPure":true,"kind":"string","lValueRequested":false,"nodeType":"Literal","src":"9622:53:120","typeDescriptions":{"typeIdentifier":"t_stringliteral_8ebc3647bde8a1129bfd827c7ef2e2d4fea82292bcad8a3c8e3918d70fed8ea8","typeString":"literal_string \"FetchChainInfoOutput: opChainProxyAdminImpl not set\""},"value":"FetchChainInfoOutput: opChainProxyAdminImpl not set"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_bool","typeString":"bool"},{"typeIdentifier":"t_stringliteral_8ebc3647bde8a1129bfd827c7ef2e2d4fea82292bcad8a3c8e3918d70fed8ea8","typeString":"literal_string \"FetchChainInfoOutput: opChainProxyAdminImpl not set\""}],"id":57952,"name":"require","nodeType":"Identifier","overloadedDeclarations":[-18,-18],"referencedDeclaration":-18,"src":"9576:7:120","typeDescriptions":{"typeIdentifier":"t_function_require_pure$_t_bool_$_t_string_memory_ptr_$returns$__$","typeString":"function (bool,string memory) pure"}},"id":57960,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"9576:100:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":57961,"nodeType":"ExpressionStatement","src":"9576:100:120"},{"expression":{"id":57962,"name":"_opChainProxyAdminImpl","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57435,"src":"9693:22:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"functionReturnParameters":57951,"id":57963,"nodeType":"Return","src":"9686:29:120"}]},"functionSelector":"5643665f","implemented":true,"kind":"function","modifiers":[],"name":"opChainProxyAdminImpl","nameLocation":"9512:21:120","parameters":{"id":57948,"nodeType":"ParameterList","parameters":[],"src":"9533:2:120"},"returnParameters":{"id":57951,"nodeType":"ParameterList","parameters":[{"constant":false,"id":57950,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":57965,"src":"9557:7:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":57949,"name":"address","nodeType":"ElementaryTypeName","src":"9557:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"9556:9:120"},"scope":58249,"stateMutability":"view","virtual":false,"visibility":"public"},{"id":57983,"nodeType":"FunctionDefinition","src":"9728:219:120","nodes":[],"body":{"id":57982,"nodeType":"Block","src":"9791:156:120","nodes":[],"statements":[{"expression":{"arguments":[{"commonType":{"typeIdentifier":"t_address","typeString":"address"},"id":57976,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftExpression":{"id":57971,"name":"_superchainConfigProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57411,"src":"9809:22:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"BinaryOperation","operator":"!=","rightExpression":{"arguments":[{"hexValue":"30","id":57974,"isConstant":false,"isLValue":false,"isPure":true,"kind":"number","lValueRequested":false,"nodeType":"Literal","src":"9843:1:120","typeDescriptions":{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"},"value":"0"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"}],"id":57973,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"nodeType":"ElementaryTypeNameExpression","src":"9835:7:120","typeDescriptions":{"typeIdentifier":"t_type$_t_address_$","typeString":"type(address)"},"typeName":{"id":57972,"name":"address","nodeType":"ElementaryTypeName","src":"9835:7:120","typeDescriptions":{}}},"id":57975,"isConstant":false,"isLValue":false,"isPure":true,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"9835:10:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"src":"9809:36:120","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},{"hexValue":"4665746368436861696e496e666f4f75747075743a207375706572636861696e436f6e66696750726f7879206e6f7420736574","id":57977,"isConstant":false,"isLValue":false,"isPure":true,"kind":"string","lValueRequested":false,"nodeType":"Literal","src":"9847:53:120","typeDescriptions":{"typeIdentifier":"t_stringliteral_1b8ad3d2e627aa065fd0fee387bc2d1e5e640177323f7f86733cd157b788a1ce","typeString":"literal_string \"FetchChainInfoOutput: superchainConfigProxy not set\""},"value":"FetchChainInfoOutput: superchainConfigProxy not set"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_bool","typeString":"bool"},{"typeIdentifier":"t_stringliteral_1b8ad3d2e627aa065fd0fee387bc2d1e5e640177323f7f86733cd157b788a1ce","typeString":"literal_string \"FetchChainInfoOutput: superchainConfigProxy not set\""}],"id":57970,"name":"require","nodeType":"Identifier","overloadedDeclarations":[-18,-18],"referencedDeclaration":-18,"src":"9801:7:120","typeDescriptions":{"typeIdentifier":"t_function_require_pure$_t_bool_$_t_string_memory_ptr_$returns$__$","typeString":"function (bool,string memory) pure"}},"id":57978,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"9801:100:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":57979,"nodeType":"ExpressionStatement","src":"9801:100:120"},{"expression":{"id":57980,"name":"_superchainConfigProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57411,"src":"9918:22:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"functionReturnParameters":57969,"id":57981,"nodeType":"Return","src":"9911:29:120"}]},"functionSelector":"84cf2c97","implemented":true,"kind":"function","modifiers":[],"name":"superchainConfigProxy","nameLocation":"9737:21:120","parameters":{"id":57966,"nodeType":"ParameterList","parameters":[],"src":"9758:2:120"},"returnParameters":{"id":57969,"nodeType":"ParameterList","parameters":[{"constant":false,"id":57968,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":57983,"src":"9782:7:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":57967,"name":"address","nodeType":"ElementaryTypeName","src":"9782:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"9781:9:120"},"scope":58249,"stateMutability":"view","virtual":false,"visibility":"public"},{"id":58001,"nodeType":"FunctionDefinition","src":"9953:231:120","nodes":[],"body":{"id":58000,"nodeType":"Block","src":"10019:165:120","nodes":[],"statements":[{"expression":{"arguments":[{"commonType":{"typeIdentifier":"t_address","typeString":"address"},"id":57994,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftExpression":{"id":57989,"name":"_anchorStateRegistryProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57437,"src":"10037:25:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"BinaryOperation","operator":"!=","rightExpression":{"arguments":[{"hexValue":"30","id":57992,"isConstant":false,"isLValue":false,"isPure":true,"kind":"number","lValueRequested":false,"nodeType":"Literal","src":"10074:1:120","typeDescriptions":{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"},"value":"0"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"}],"id":57991,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"nodeType":"ElementaryTypeNameExpression","src":"10066:7:120","typeDescriptions":{"typeIdentifier":"t_type$_t_address_$","typeString":"type(address)"},"typeName":{"id":57990,"name":"address","nodeType":"ElementaryTypeName","src":"10066:7:120","typeDescriptions":{}}},"id":57993,"isConstant":false,"isLValue":false,"isPure":true,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"10066:10:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"src":"10037:39:120","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},{"hexValue":"4665746368436861696e496e666f4f75747075743a20616e63686f725374617465526567697374727950726f7879206e6f7420736574","id":57995,"isConstant":false,"isLValue":false,"isPure":true,"kind":"string","lValueRequested":false,"nodeType":"Literal","src":"10078:56:120","typeDescriptions":{"typeIdentifier":"t_stringliteral_6391076785d7152b9570ce8338ca2e43a749144cb3dbb7f9e5e1de5fabfbae48","typeString":"literal_string \"FetchChainInfoOutput: anchorStateRegistryProxy not set\""},"value":"FetchChainInfoOutput: anchorStateRegistryProxy not set"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_bool","typeString":"bool"},{"typeIdentifier":"t_stringliteral_6391076785d7152b9570ce8338ca2e43a749144cb3dbb7f9e5e1de5fabfbae48","typeString":"literal_string \"FetchChainInfoOutput: anchorStateRegistryProxy not set\""}],"id":57988,"name":"require","nodeType":"Identifier","overloadedDeclarations":[-18,-18],"referencedDeclaration":-18,"src":"10029:7:120","typeDescriptions":{"typeIdentifier":"t_function_require_pure$_t_bool_$_t_string_memory_ptr_$returns$__$","typeString":"function (bool,string memory) pure"}},"id":57996,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"10029:106:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":57997,"nodeType":"ExpressionStatement","src":"10029:106:120"},{"expression":{"id":57998,"name":"_anchorStateRegistryProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57437,"src":"10152:25:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"functionReturnParameters":57987,"id":57999,"nodeType":"Return","src":"10145:32:120"}]},"functionSelector":"35596f76","implemented":true,"kind":"function","modifiers":[],"name":"anchorStateRegistryProxy","nameLocation":"9962:24:120","parameters":{"id":57984,"nodeType":"ParameterList","parameters":[],"src":"9986:2:120"},"returnParameters":{"id":57987,"nodeType":"ParameterList","parameters":[{"constant":false,"id":57986,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":58001,"src":"10010:7:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":57985,"name":"address","nodeType":"ElementaryTypeName","src":"10010:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"10009:9:120"},"scope":58249,"stateMutability":"view","virtual":false,"visibility":"public"},{"id":58009,"nodeType":"FunctionDefinition","src":"10190:131:120","nodes":[],"body":{"id":58008,"nodeType":"Block","src":"10264:57:120","nodes":[],"statements":[{"expression":{"id":58006,"name":"_delayedWethPermissionedGameProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57439,"src":"10281:33:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"functionReturnParameters":58005,"id":58007,"nodeType":"Return","src":"10274:40:120"}]},"functionSelector":"794836d7","implemented":true,"kind":"function","modifiers":[],"name":"delayedWethPermissionedGameProxy","nameLocation":"10199:32:120","parameters":{"id":58002,"nodeType":"ParameterList","parameters":[],"src":"10231:2:120"},"returnParameters":{"id":58005,"nodeType":"ParameterList","parameters":[{"constant":false,"id":58004,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":58009,"src":"10255:7:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":58003,"name":"address","nodeType":"ElementaryTypeName","src":"10255:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"10254:9:120"},"scope":58249,"stateMutability":"view","virtual":false,"visibility":"public"},{"id":58017,"nodeType":"FunctionDefinition","src":"10327:135:120","nodes":[],"body":{"id":58016,"nodeType":"Block","src":"10403:59:120","nodes":[],"statements":[{"expression":{"id":58014,"name":"_delayedWethPermissionlessGameProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57441,"src":"10420:35:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"functionReturnParameters":58013,"id":58015,"nodeType":"Return","src":"10413:42:120"}]},"functionSelector":"97068797","implemented":true,"kind":"function","modifiers":[],"name":"delayedWethPermissionlessGameProxy","nameLocation":"10336:34:120","parameters":{"id":58010,"nodeType":"ParameterList","parameters":[],"src":"10370:2:120"},"returnParameters":{"id":58013,"nodeType":"ParameterList","parameters":[{"constant":false,"id":58012,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":58017,"src":"10394:7:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":58011,"name":"address","nodeType":"ElementaryTypeName","src":"10394:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"10393:9:120"},"scope":58249,"stateMutability":"view","virtual":false,"visibility":"public"},{"id":58025,"nodeType":"FunctionDefinition","src":"10468:113:120","nodes":[],"body":{"id":58024,"nodeType":"Block","src":"10533:48:120","nodes":[],"statements":[{"expression":{"id":58022,"name":"_disputeGameFactoryProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57443,"src":"10550:24:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"functionReturnParameters":58021,"id":58023,"nodeType":"Return","src":"10543:31:120"}]},"functionSelector":"6c4568d1","implemented":true,"kind":"function","modifiers":[],"name":"disputeGameFactoryProxy","nameLocation":"10477:23:120","parameters":{"id":58018,"nodeType":"ParameterList","parameters":[],"src":"10500:2:120"},"returnParameters":{"id":58021,"nodeType":"ParameterList","parameters":[{"constant":false,"id":58020,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":58025,"src":"10524:7:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":58019,"name":"address","nodeType":"ElementaryTypeName","src":"10524:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"10523:9:120"},"scope":58249,"stateMutability":"view","virtual":false,"visibility":"public"},{"id":58043,"nodeType":"FunctionDefinition","src":"10587:215:120","nodes":[],"body":{"id":58042,"nodeType":"Block","src":"10649:153:120","nodes":[],"statements":[{"expression":{"arguments":[{"commonType":{"typeIdentifier":"t_address","typeString":"address"},"id":58036,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftExpression":{"id":58031,"name":"_faultDisputeGameImpl","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57445,"src":"10667:21:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"BinaryOperation","operator":"!=","rightExpression":{"arguments":[{"hexValue":"30","id":58034,"isConstant":false,"isLValue":false,"isPure":true,"kind":"number","lValueRequested":false,"nodeType":"Literal","src":"10700:1:120","typeDescriptions":{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"},"value":"0"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"}],"id":58033,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"nodeType":"ElementaryTypeNameExpression","src":"10692:7:120","typeDescriptions":{"typeIdentifier":"t_type$_t_address_$","typeString":"type(address)"},"typeName":{"id":58032,"name":"address","nodeType":"ElementaryTypeName","src":"10692:7:120","typeDescriptions":{}}},"id":58035,"isConstant":false,"isLValue":false,"isPure":true,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"10692:10:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"src":"10667:35:120","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},{"hexValue":"4665746368436861696e496e666f4f75747075743a206661756c744469737075746547616d65496d706c206e6f7420736574","id":58037,"isConstant":false,"isLValue":false,"isPure":true,"kind":"string","lValueRequested":false,"nodeType":"Literal","src":"10704:52:120","typeDescriptions":{"typeIdentifier":"t_stringliteral_baae18cd0fbc1fbf3c566f5918a7a4a780bb1a3d403d2b65d908417b87c06457","typeString":"literal_string \"FetchChainInfoOutput: faultDisputeGameImpl not set\""},"value":"FetchChainInfoOutput: faultDisputeGameImpl not set"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_bool","typeString":"bool"},{"typeIdentifier":"t_stringliteral_baae18cd0fbc1fbf3c566f5918a7a4a780bb1a3d403d2b65d908417b87c06457","typeString":"literal_string \"FetchChainInfoOutput: faultDisputeGameImpl not set\""}],"id":58030,"name":"require","nodeType":"Identifier","overloadedDeclarations":[-18,-18],"referencedDeclaration":-18,"src":"10659:7:120","typeDescriptions":{"typeIdentifier":"t_function_require_pure$_t_bool_$_t_string_memory_ptr_$returns$__$","typeString":"function (bool,string memory) pure"}},"id":58038,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"10659:98:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":58039,"nodeType":"ExpressionStatement","src":"10659:98:120"},{"expression":{"id":58040,"name":"_faultDisputeGameImpl","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57445,"src":"10774:21:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"functionReturnParameters":58029,"id":58041,"nodeType":"Return","src":"10767:28:120"}]},"functionSelector":"dea21984","implemented":true,"kind":"function","modifiers":[],"name":"faultDisputeGameImpl","nameLocation":"10596:20:120","parameters":{"id":58026,"nodeType":"ParameterList","parameters":[],"src":"10616:2:120"},"returnParameters":{"id":58029,"nodeType":"ParameterList","parameters":[{"constant":false,"id":58028,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":58043,"src":"10640:7:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":58027,"name":"address","nodeType":"ElementaryTypeName","src":"10640:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"10639:9:120"},"scope":58249,"stateMutability":"view","virtual":false,"visibility":"public"},{"id":58061,"nodeType":"FunctionDefinition","src":"10808:167:120","nodes":[],"body":{"id":58060,"nodeType":"Block","src":"10858:117:120","nodes":[],"statements":[{"expression":{"arguments":[{"commonType":{"typeIdentifier":"t_address","typeString":"address"},"id":58054,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftExpression":{"id":58049,"name":"_mipsImpl","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57413,"src":"10876:9:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"BinaryOperation","operator":"!=","rightExpression":{"arguments":[{"hexValue":"30","id":58052,"isConstant":false,"isLValue":false,"isPure":true,"kind":"number","lValueRequested":false,"nodeType":"Literal","src":"10897:1:120","typeDescriptions":{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"},"value":"0"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"}],"id":58051,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"nodeType":"ElementaryTypeNameExpression","src":"10889:7:120","typeDescriptions":{"typeIdentifier":"t_type$_t_address_$","typeString":"type(address)"},"typeName":{"id":58050,"name":"address","nodeType":"ElementaryTypeName","src":"10889:7:120","typeDescriptions":{}}},"id":58053,"isConstant":false,"isLValue":false,"isPure":true,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"10889:10:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"src":"10876:23:120","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},{"hexValue":"4665746368436861696e496e666f4f75747075743a206d697073496d706c206e6f7420736574","id":58055,"isConstant":false,"isLValue":false,"isPure":true,"kind":"string","lValueRequested":false,"nodeType":"Literal","src":"10901:40:120","typeDescriptions":{"typeIdentifier":"t_stringliteral_178867f585ae7eaee2b47a35fdf118ac2b037c387c5937f3b39b1c51f05d7497","typeString":"literal_string \"FetchChainInfoOutput: mipsImpl not set\""},"value":"FetchChainInfoOutput: mipsImpl not set"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_bool","typeString":"bool"},{"typeIdentifier":"t_stringliteral_178867f585ae7eaee2b47a35fdf118ac2b037c387c5937f3b39b1c51f05d7497","typeString":"literal_string \"FetchChainInfoOutput: mipsImpl not set\""}],"id":58048,"name":"require","nodeType":"Identifier","overloadedDeclarations":[-18,-18],"referencedDeclaration":-18,"src":"10868:7:120","typeDescriptions":{"typeIdentifier":"t_function_require_pure$_t_bool_$_t_string_memory_ptr_$returns$__$","typeString":"function (bool,string memory) pure"}},"id":58056,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"10868:74:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":58057,"nodeType":"ExpressionStatement","src":"10868:74:120"},{"expression":{"id":58058,"name":"_mipsImpl","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57413,"src":"10959:9:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"functionReturnParameters":58047,"id":58059,"nodeType":"Return","src":"10952:16:120"}]},"functionSelector":"e303272c","implemented":true,"kind":"function","modifiers":[],"name":"mipsImpl","nameLocation":"10817:8:120","parameters":{"id":58044,"nodeType":"ParameterList","parameters":[],"src":"10825:2:120"},"returnParameters":{"id":58047,"nodeType":"ParameterList","parameters":[{"constant":false,"id":58046,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":58061,"src":"10849:7:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":58045,"name":"address","nodeType":"ElementaryTypeName","src":"10849:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"10848:9:120"},"scope":58249,"stateMutability":"view","virtual":false,"visibility":"public"},{"id":58079,"nodeType":"FunctionDefinition","src":"10981:243:120","nodes":[],"body":{"id":58078,"nodeType":"Block","src":"11050:174:120","nodes":[],"statements":[{"expression":{"arguments":[{"commonType":{"typeIdentifier":"t_address","typeString":"address"},"id":58072,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftExpression":{"id":58067,"name":"_permissionedDisputeGameImpl","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57447,"src":"11068:28:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"BinaryOperation","operator":"!=","rightExpression":{"arguments":[{"hexValue":"30","id":58070,"isConstant":false,"isLValue":false,"isPure":true,"kind":"number","lValueRequested":false,"nodeType":"Literal","src":"11108:1:120","typeDescriptions":{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"},"value":"0"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"}],"id":58069,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"nodeType":"ElementaryTypeNameExpression","src":"11100:7:120","typeDescriptions":{"typeIdentifier":"t_type$_t_address_$","typeString":"type(address)"},"typeName":{"id":58068,"name":"address","nodeType":"ElementaryTypeName","src":"11100:7:120","typeDescriptions":{}}},"id":58071,"isConstant":false,"isLValue":false,"isPure":true,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"11100:10:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"src":"11068:42:120","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},{"hexValue":"4665746368436861696e496e666f4f75747075743a207065726d697373696f6e65644469737075746547616d65496d706c206e6f7420736574","id":58073,"isConstant":false,"isLValue":false,"isPure":true,"kind":"string","lValueRequested":false,"nodeType":"Literal","src":"11112:59:120","typeDescriptions":{"typeIdentifier":"t_stringliteral_234858b97aab3865b03b564f238f9977c62296b1532cb4f809e12678629cae92","typeString":"literal_string \"FetchChainInfoOutput: permissionedDisputeGameImpl not set\""},"value":"FetchChainInfoOutput: permissionedDisputeGameImpl not set"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_bool","typeString":"bool"},{"typeIdentifier":"t_stringliteral_234858b97aab3865b03b564f238f9977c62296b1532cb4f809e12678629cae92","typeString":"literal_string \"FetchChainInfoOutput: permissionedDisputeGameImpl not set\""}],"id":58066,"name":"require","nodeType":"Identifier","overloadedDeclarations":[-18,-18],"referencedDeclaration":-18,"src":"11060:7:120","typeDescriptions":{"typeIdentifier":"t_function_require_pure$_t_bool_$_t_string_memory_ptr_$returns$__$","typeString":"function (bool,string memory) pure"}},"id":58074,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"11060:112:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":58075,"nodeType":"ExpressionStatement","src":"11060:112:120"},{"expression":{"id":58076,"name":"_permissionedDisputeGameImpl","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57447,"src":"11189:28:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"functionReturnParameters":58065,"id":58077,"nodeType":"Return","src":"11182:35:120"}]},"functionSelector":"98ccec3e","implemented":true,"kind":"function","modifiers":[],"name":"permissionedDisputeGameImpl","nameLocation":"10990:27:120","parameters":{"id":58062,"nodeType":"ParameterList","parameters":[],"src":"11017:2:120"},"returnParameters":{"id":58065,"nodeType":"ParameterList","parameters":[{"constant":false,"id":58064,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":58079,"src":"11041:7:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":58063,"name":"address","nodeType":"ElementaryTypeName","src":"11041:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"11040:9:120"},"scope":58249,"stateMutability":"view","virtual":false,"visibility":"public"},{"id":58097,"nodeType":"FunctionDefinition","src":"11230:207:120","nodes":[],"body":{"id":58096,"nodeType":"Block","src":"11290:147:120","nodes":[],"statements":[{"expression":{"arguments":[{"commonType":{"typeIdentifier":"t_address","typeString":"address"},"id":58090,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftExpression":{"id":58085,"name":"_preimageOracleImpl","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57415,"src":"11308:19:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"BinaryOperation","operator":"!=","rightExpression":{"arguments":[{"hexValue":"30","id":58088,"isConstant":false,"isLValue":false,"isPure":true,"kind":"number","lValueRequested":false,"nodeType":"Literal","src":"11339:1:120","typeDescriptions":{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"},"value":"0"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"}],"id":58087,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"nodeType":"ElementaryTypeNameExpression","src":"11331:7:120","typeDescriptions":{"typeIdentifier":"t_type$_t_address_$","typeString":"type(address)"},"typeName":{"id":58086,"name":"address","nodeType":"ElementaryTypeName","src":"11331:7:120","typeDescriptions":{}}},"id":58089,"isConstant":false,"isLValue":false,"isPure":true,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"11331:10:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"src":"11308:33:120","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},{"hexValue":"4665746368436861696e496e666f4f75747075743a20707265696d6167654f7261636c65496d706c206e6f7420736574","id":58091,"isConstant":false,"isLValue":false,"isPure":true,"kind":"string","lValueRequested":false,"nodeType":"Literal","src":"11343:50:120","typeDescriptions":{"typeIdentifier":"t_stringliteral_2434e23032e7627ba1a13e989a9fbe735952d0d6f49e2760e1b1064b8728d538","typeString":"literal_string \"FetchChainInfoOutput: preimageOracleImpl not set\""},"value":"FetchChainInfoOutput: preimageOracleImpl not set"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_bool","typeString":"bool"},{"typeIdentifier":"t_stringliteral_2434e23032e7627ba1a13e989a9fbe735952d0d6f49e2760e1b1064b8728d538","typeString":"literal_string \"FetchChainInfoOutput: preimageOracleImpl not set\""}],"id":58084,"name":"require","nodeType":"Identifier","overloadedDeclarations":[-18,-18],"referencedDeclaration":-18,"src":"11300:7:120","typeDescriptions":{"typeIdentifier":"t_function_require_pure$_t_bool_$_t_string_memory_ptr_$returns$__$","typeString":"function (bool,string memory) pure"}},"id":58092,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"11300:94:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":58093,"nodeType":"ExpressionStatement","src":"11300:94:120"},{"expression":{"id":58094,"name":"_preimageOracleImpl","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57415,"src":"11411:19:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"functionReturnParameters":58083,"id":58095,"nodeType":"Return","src":"11404:26:120"}]},"functionSelector":"d030d2e8","implemented":true,"kind":"function","modifiers":[],"name":"preimageOracleImpl","nameLocation":"11239:18:120","parameters":{"id":58080,"nodeType":"ParameterList","parameters":[],"src":"11257:2:120"},"returnParameters":{"id":58083,"nodeType":"ParameterList","parameters":[{"constant":false,"id":58082,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":58097,"src":"11281:7:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":58081,"name":"address","nodeType":"ElementaryTypeName","src":"11281:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"11280:9:120"},"scope":58249,"stateMutability":"view","virtual":false,"visibility":"public"},{"id":58115,"nodeType":"FunctionDefinition","src":"11443:203:120","nodes":[],"body":{"id":58114,"nodeType":"Block","src":"11502:144:120","nodes":[],"statements":[{"expression":{"arguments":[{"commonType":{"typeIdentifier":"t_address","typeString":"address"},"id":58108,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftExpression":{"id":58103,"name":"_systemConfigOwner","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57449,"src":"11520:18:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"BinaryOperation","operator":"!=","rightExpression":{"arguments":[{"hexValue":"30","id":58106,"isConstant":false,"isLValue":false,"isPure":true,"kind":"number","lValueRequested":false,"nodeType":"Literal","src":"11550:1:120","typeDescriptions":{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"},"value":"0"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"}],"id":58105,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"nodeType":"ElementaryTypeNameExpression","src":"11542:7:120","typeDescriptions":{"typeIdentifier":"t_type$_t_address_$","typeString":"type(address)"},"typeName":{"id":58104,"name":"address","nodeType":"ElementaryTypeName","src":"11542:7:120","typeDescriptions":{}}},"id":58107,"isConstant":false,"isLValue":false,"isPure":true,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"11542:10:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"src":"11520:32:120","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},{"hexValue":"4665746368436861696e496e666f4f75747075743a2073797374656d436f6e6669674f776e6572206e6f7420736574","id":58109,"isConstant":false,"isLValue":false,"isPure":true,"kind":"string","lValueRequested":false,"nodeType":"Literal","src":"11554:49:120","typeDescriptions":{"typeIdentifier":"t_stringliteral_fc7a67f4775c5e19ca3731b64db9f9f8895dcd37a01bc895f1d1806a7f21c916","typeString":"literal_string \"FetchChainInfoOutput: systemConfigOwner not set\""},"value":"FetchChainInfoOutput: systemConfigOwner not set"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_bool","typeString":"bool"},{"typeIdentifier":"t_stringliteral_fc7a67f4775c5e19ca3731b64db9f9f8895dcd37a01bc895f1d1806a7f21c916","typeString":"literal_string \"FetchChainInfoOutput: systemConfigOwner not set\""}],"id":58102,"name":"require","nodeType":"Identifier","overloadedDeclarations":[-18,-18],"referencedDeclaration":-18,"src":"11512:7:120","typeDescriptions":{"typeIdentifier":"t_function_require_pure$_t_bool_$_t_string_memory_ptr_$returns$__$","typeString":"function (bool,string memory) pure"}},"id":58110,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"11512:92:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":58111,"nodeType":"ExpressionStatement","src":"11512:92:120"},{"expression":{"id":58112,"name":"_systemConfigOwner","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57449,"src":"11621:18:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"functionReturnParameters":58101,"id":58113,"nodeType":"Return","src":"11614:25:120"}]},"functionSelector":"1e229b20","implemented":true,"kind":"function","modifiers":[],"name":"systemConfigOwner","nameLocation":"11452:17:120","parameters":{"id":58098,"nodeType":"ParameterList","parameters":[],"src":"11469:2:120"},"returnParameters":{"id":58101,"nodeType":"ParameterList","parameters":[{"constant":false,"id":58100,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":58115,"src":"11493:7:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":58099,"name":"address","nodeType":"ElementaryTypeName","src":"11493:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"11492:9:120"},"scope":58249,"stateMutability":"view","virtual":false,"visibility":"public"},{"id":58133,"nodeType":"FunctionDefinition","src":"11652:223:120","nodes":[],"body":{"id":58132,"nodeType":"Block","src":"11716:159:120","nodes":[],"statements":[{"expression":{"arguments":[{"commonType":{"typeIdentifier":"t_address","typeString":"address"},"id":58126,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftExpression":{"id":58121,"name":"_opChainProxyAdminOwner","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57451,"src":"11734:23:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"BinaryOperation","operator":"!=","rightExpression":{"arguments":[{"hexValue":"30","id":58124,"isConstant":false,"isLValue":false,"isPure":true,"kind":"number","lValueRequested":false,"nodeType":"Literal","src":"11769:1:120","typeDescriptions":{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"},"value":"0"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"}],"id":58123,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"nodeType":"ElementaryTypeNameExpression","src":"11761:7:120","typeDescriptions":{"typeIdentifier":"t_type$_t_address_$","typeString":"type(address)"},"typeName":{"id":58122,"name":"address","nodeType":"ElementaryTypeName","src":"11761:7:120","typeDescriptions":{}}},"id":58125,"isConstant":false,"isLValue":false,"isPure":true,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"11761:10:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"src":"11734:37:120","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},{"hexValue":"4665746368436861696e496e666f4f75747075743a206f70436861696e50726f787941646d696e4f776e6572206e6f7420736574","id":58127,"isConstant":false,"isLValue":false,"isPure":true,"kind":"string","lValueRequested":false,"nodeType":"Literal","src":"11773:54:120","typeDescriptions":{"typeIdentifier":"t_stringliteral_cc12cbf05d2d853ebebe6e25c8b02d2f78d6af131087a61088362ca7d0befc81","typeString":"literal_string \"FetchChainInfoOutput: opChainProxyAdminOwner not set\""},"value":"FetchChainInfoOutput: opChainProxyAdminOwner not set"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_bool","typeString":"bool"},{"typeIdentifier":"t_stringliteral_cc12cbf05d2d853ebebe6e25c8b02d2f78d6af131087a61088362ca7d0befc81","typeString":"literal_string \"FetchChainInfoOutput: opChainProxyAdminOwner not set\""}],"id":58120,"name":"require","nodeType":"Identifier","overloadedDeclarations":[-18,-18],"referencedDeclaration":-18,"src":"11726:7:120","typeDescriptions":{"typeIdentifier":"t_function_require_pure$_t_bool_$_t_string_memory_ptr_$returns$__$","typeString":"function (bool,string memory) pure"}},"id":58128,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"11726:102:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":58129,"nodeType":"ExpressionStatement","src":"11726:102:120"},{"expression":{"id":58130,"name":"_opChainProxyAdminOwner","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57451,"src":"11845:23:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"functionReturnParameters":58119,"id":58131,"nodeType":"Return","src":"11838:30:120"}]},"functionSelector":"1480f0cc","implemented":true,"kind":"function","modifiers":[],"name":"opChainProxyAdminOwner","nameLocation":"11661:22:120","parameters":{"id":58116,"nodeType":"ParameterList","parameters":[],"src":"11683:2:120"},"returnParameters":{"id":58119,"nodeType":"ParameterList","parameters":[{"constant":false,"id":58118,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":58133,"src":"11707:7:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":58117,"name":"address","nodeType":"ElementaryTypeName","src":"11707:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"11706:9:120"},"scope":58249,"stateMutability":"view","virtual":false,"visibility":"public"},{"id":58151,"nodeType":"FunctionDefinition","src":"11881:195:120","nodes":[],"body":{"id":58150,"nodeType":"Block","src":"11938:138:120","nodes":[],"statements":[{"expression":{"arguments":[{"commonType":{"typeIdentifier":"t_address","typeString":"address"},"id":58144,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftExpression":{"id":58139,"name":"_opChainGuardian","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57453,"src":"11956:16:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"BinaryOperation","operator":"!=","rightExpression":{"arguments":[{"hexValue":"30","id":58142,"isConstant":false,"isLValue":false,"isPure":true,"kind":"number","lValueRequested":false,"nodeType":"Literal","src":"11984:1:120","typeDescriptions":{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"},"value":"0"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"}],"id":58141,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"nodeType":"ElementaryTypeNameExpression","src":"11976:7:120","typeDescriptions":{"typeIdentifier":"t_type$_t_address_$","typeString":"type(address)"},"typeName":{"id":58140,"name":"address","nodeType":"ElementaryTypeName","src":"11976:7:120","typeDescriptions":{}}},"id":58143,"isConstant":false,"isLValue":false,"isPure":true,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"11976:10:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"src":"11956:30:120","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},{"hexValue":"4665746368436861696e496e666f4f75747075743a206f70436861696e477561726469616e206e6f7420736574","id":58145,"isConstant":false,"isLValue":false,"isPure":true,"kind":"string","lValueRequested":false,"nodeType":"Literal","src":"11988:47:120","typeDescriptions":{"typeIdentifier":"t_stringliteral_ab71487628da5c56ff40f228ee915a62d6c0a28ab899f48f84343df6dbc48bb7","typeString":"literal_string \"FetchChainInfoOutput: opChainGuardian not set\""},"value":"FetchChainInfoOutput: opChainGuardian not set"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_bool","typeString":"bool"},{"typeIdentifier":"t_stringliteral_ab71487628da5c56ff40f228ee915a62d6c0a28ab899f48f84343df6dbc48bb7","typeString":"literal_string \"FetchChainInfoOutput: opChainGuardian not set\""}],"id":58138,"name":"require","nodeType":"Identifier","overloadedDeclarations":[-18,-18],"referencedDeclaration":-18,"src":"11948:7:120","typeDescriptions":{"typeIdentifier":"t_function_require_pure$_t_bool_$_t_string_memory_ptr_$returns$__$","typeString":"function (bool,string memory) pure"}},"id":58146,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"11948:88:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":58147,"nodeType":"ExpressionStatement","src":"11948:88:120"},{"expression":{"id":58148,"name":"_opChainGuardian","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57453,"src":"12053:16:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"functionReturnParameters":58137,"id":58149,"nodeType":"Return","src":"12046:23:120"}]},"functionSelector":"4bc2695f","implemented":true,"kind":"function","modifiers":[],"name":"opChainGuardian","nameLocation":"11890:15:120","parameters":{"id":58134,"nodeType":"ParameterList","parameters":[],"src":"11905:2:120"},"returnParameters":{"id":58137,"nodeType":"ParameterList","parameters":[{"constant":false,"id":58136,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":58151,"src":"11929:7:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":58135,"name":"address","nodeType":"ElementaryTypeName","src":"11929:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"11928:9:120"},"scope":58249,"stateMutability":"view","virtual":false,"visibility":"public"},{"id":58169,"nodeType":"FunctionDefinition","src":"12082:175:120","nodes":[],"body":{"id":58168,"nodeType":"Block","src":"12134:123:120","nodes":[],"statements":[{"expression":{"arguments":[{"commonType":{"typeIdentifier":"t_address","typeString":"address"},"id":58162,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftExpression":{"id":58157,"name":"_challenger","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57455,"src":"12152:11:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"BinaryOperation","operator":"!=","rightExpression":{"arguments":[{"hexValue":"30","id":58160,"isConstant":false,"isLValue":false,"isPure":true,"kind":"number","lValueRequested":false,"nodeType":"Literal","src":"12175:1:120","typeDescriptions":{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"},"value":"0"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"}],"id":58159,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"nodeType":"ElementaryTypeNameExpression","src":"12167:7:120","typeDescriptions":{"typeIdentifier":"t_type$_t_address_$","typeString":"type(address)"},"typeName":{"id":58158,"name":"address","nodeType":"ElementaryTypeName","src":"12167:7:120","typeDescriptions":{}}},"id":58161,"isConstant":false,"isLValue":false,"isPure":true,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"12167:10:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"src":"12152:25:120","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},{"hexValue":"4665746368436861696e496e666f4f75747075743a206368616c6c656e676572206e6f7420736574","id":58163,"isConstant":false,"isLValue":false,"isPure":true,"kind":"string","lValueRequested":false,"nodeType":"Literal","src":"12179:42:120","typeDescriptions":{"typeIdentifier":"t_stringliteral_d1dd717c39956ee86b1eb77b9f3cb6dbeca6df99b330f67dd364a35a1174c2ce","typeString":"literal_string \"FetchChainInfoOutput: challenger not set\""},"value":"FetchChainInfoOutput: challenger not set"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_bool","typeString":"bool"},{"typeIdentifier":"t_stringliteral_d1dd717c39956ee86b1eb77b9f3cb6dbeca6df99b330f67dd364a35a1174c2ce","typeString":"literal_string \"FetchChainInfoOutput: challenger not set\""}],"id":58156,"name":"require","nodeType":"Identifier","overloadedDeclarations":[-18,-18],"referencedDeclaration":-18,"src":"12144:7:120","typeDescriptions":{"typeIdentifier":"t_function_require_pure$_t_bool_$_t_string_memory_ptr_$returns$__$","typeString":"function (bool,string memory) pure"}},"id":58164,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"12144:78:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":58165,"nodeType":"ExpressionStatement","src":"12144:78:120"},{"expression":{"id":58166,"name":"_challenger","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57455,"src":"12239:11:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"functionReturnParameters":58155,"id":58167,"nodeType":"Return","src":"12232:18:120"}]},"functionSelector":"534db0e2","implemented":true,"kind":"function","modifiers":[],"name":"challenger","nameLocation":"12091:10:120","parameters":{"id":58152,"nodeType":"ParameterList","parameters":[],"src":"12101:2:120"},"returnParameters":{"id":58155,"nodeType":"ParameterList","parameters":[{"constant":false,"id":58154,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":58169,"src":"12125:7:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":58153,"name":"address","nodeType":"ElementaryTypeName","src":"12125:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"12124:9:120"},"scope":58249,"stateMutability":"view","virtual":false,"visibility":"public"},{"id":58187,"nodeType":"FunctionDefinition","src":"12263:167:120","nodes":[],"body":{"id":58186,"nodeType":"Block","src":"12313:117:120","nodes":[],"statements":[{"expression":{"arguments":[{"commonType":{"typeIdentifier":"t_address","typeString":"address"},"id":58180,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftExpression":{"id":58175,"name":"_proposer","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57457,"src":"12331:9:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"BinaryOperation","operator":"!=","rightExpression":{"arguments":[{"hexValue":"30","id":58178,"isConstant":false,"isLValue":false,"isPure":true,"kind":"number","lValueRequested":false,"nodeType":"Literal","src":"12352:1:120","typeDescriptions":{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"},"value":"0"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"}],"id":58177,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"nodeType":"ElementaryTypeNameExpression","src":"12344:7:120","typeDescriptions":{"typeIdentifier":"t_type$_t_address_$","typeString":"type(address)"},"typeName":{"id":58176,"name":"address","nodeType":"ElementaryTypeName","src":"12344:7:120","typeDescriptions":{}}},"id":58179,"isConstant":false,"isLValue":false,"isPure":true,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"12344:10:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"src":"12331:23:120","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},{"hexValue":"4665746368436861696e496e666f4f75747075743a2070726f706f736572206e6f7420736574","id":58181,"isConstant":false,"isLValue":false,"isPure":true,"kind":"string","lValueRequested":false,"nodeType":"Literal","src":"12356:40:120","typeDescriptions":{"typeIdentifier":"t_stringliteral_c4910753f64240b424591ec2bc873e5a728ff321d57cb1a353788ad2c385da71","typeString":"literal_string \"FetchChainInfoOutput: proposer not set\""},"value":"FetchChainInfoOutput: proposer not set"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_bool","typeString":"bool"},{"typeIdentifier":"t_stringliteral_c4910753f64240b424591ec2bc873e5a728ff321d57cb1a353788ad2c385da71","typeString":"literal_string \"FetchChainInfoOutput: proposer not set\""}],"id":58174,"name":"require","nodeType":"Identifier","overloadedDeclarations":[-18,-18],"referencedDeclaration":-18,"src":"12323:7:120","typeDescriptions":{"typeIdentifier":"t_function_require_pure$_t_bool_$_t_string_memory_ptr_$returns$__$","typeString":"function (bool,string memory) pure"}},"id":58182,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"12323:74:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":58183,"nodeType":"ExpressionStatement","src":"12323:74:120"},{"expression":{"id":58184,"name":"_proposer","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57457,"src":"12414:9:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"functionReturnParameters":58173,"id":58185,"nodeType":"Return","src":"12407:16:120"}]},"functionSelector":"a8e4fb90","implemented":true,"kind":"function","modifiers":[],"name":"proposer","nameLocation":"12272:8:120","parameters":{"id":58170,"nodeType":"ParameterList","parameters":[],"src":"12280:2:120"},"returnParameters":{"id":58173,"nodeType":"ParameterList","parameters":[{"constant":false,"id":58172,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":58187,"src":"12304:7:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":58171,"name":"address","nodeType":"ElementaryTypeName","src":"12304:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"12303:9:120"},"scope":58249,"stateMutability":"view","virtual":false,"visibility":"public"},{"id":58205,"nodeType":"FunctionDefinition","src":"12436:203:120","nodes":[],"body":{"id":58204,"nodeType":"Block","src":"12495:144:120","nodes":[],"statements":[{"expression":{"arguments":[{"commonType":{"typeIdentifier":"t_address","typeString":"address"},"id":58198,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftExpression":{"id":58193,"name":"_unsafeBlockSigner","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57459,"src":"12513:18:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"BinaryOperation","operator":"!=","rightExpression":{"arguments":[{"hexValue":"30","id":58196,"isConstant":false,"isLValue":false,"isPure":true,"kind":"number","lValueRequested":false,"nodeType":"Literal","src":"12543:1:120","typeDescriptions":{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"},"value":"0"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"}],"id":58195,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"nodeType":"ElementaryTypeNameExpression","src":"12535:7:120","typeDescriptions":{"typeIdentifier":"t_type$_t_address_$","typeString":"type(address)"},"typeName":{"id":58194,"name":"address","nodeType":"ElementaryTypeName","src":"12535:7:120","typeDescriptions":{}}},"id":58197,"isConstant":false,"isLValue":false,"isPure":true,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"12535:10:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"src":"12513:32:120","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},{"hexValue":"4665746368436861696e496e666f4f75747075743a20756e73616665426c6f636b5369676e6572206e6f7420736574","id":58199,"isConstant":false,"isLValue":false,"isPure":true,"kind":"string","lValueRequested":false,"nodeType":"Literal","src":"12547:49:120","typeDescriptions":{"typeIdentifier":"t_stringliteral_c0c85432d1596fb73656e29b64f6ea745166dde4a7fa6163bfe6b285aea851d7","typeString":"literal_string \"FetchChainInfoOutput: unsafeBlockSigner not set\""},"value":"FetchChainInfoOutput: unsafeBlockSigner not set"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_bool","typeString":"bool"},{"typeIdentifier":"t_stringliteral_c0c85432d1596fb73656e29b64f6ea745166dde4a7fa6163bfe6b285aea851d7","typeString":"literal_string \"FetchChainInfoOutput: unsafeBlockSigner not set\""}],"id":58192,"name":"require","nodeType":"Identifier","overloadedDeclarations":[-18,-18],"referencedDeclaration":-18,"src":"12505:7:120","typeDescriptions":{"typeIdentifier":"t_function_require_pure$_t_bool_$_t_string_memory_ptr_$returns$__$","typeString":"function (bool,string memory) pure"}},"id":58200,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"12505:92:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":58201,"nodeType":"ExpressionStatement","src":"12505:92:120"},{"expression":{"id":58202,"name":"_unsafeBlockSigner","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57459,"src":"12614:18:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"functionReturnParameters":58191,"id":58203,"nodeType":"Return","src":"12607:25:120"}]},"functionSelector":"1fd19ee1","implemented":true,"kind":"function","modifiers":[],"name":"unsafeBlockSigner","nameLocation":"12445:17:120","parameters":{"id":58188,"nodeType":"ParameterList","parameters":[],"src":"12462:2:120"},"returnParameters":{"id":58191,"nodeType":"ParameterList","parameters":[{"constant":false,"id":58190,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":58205,"src":"12486:7:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":58189,"name":"address","nodeType":"ElementaryTypeName","src":"12486:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"12485:9:120"},"scope":58249,"stateMutability":"view","virtual":false,"visibility":"public"},{"id":58223,"nodeType":"FunctionDefinition","src":"12645:191:120","nodes":[],"body":{"id":58222,"nodeType":"Block","src":"12701:135:120","nodes":[],"statements":[{"expression":{"arguments":[{"commonType":{"typeIdentifier":"t_address","typeString":"address"},"id":58216,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftExpression":{"id":58211,"name":"_batchSubmitter","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57461,"src":"12719:15:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"BinaryOperation","operator":"!=","rightExpression":{"arguments":[{"hexValue":"30","id":58214,"isConstant":false,"isLValue":false,"isPure":true,"kind":"number","lValueRequested":false,"nodeType":"Literal","src":"12746:1:120","typeDescriptions":{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"},"value":"0"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"}],"id":58213,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"nodeType":"ElementaryTypeNameExpression","src":"12738:7:120","typeDescriptions":{"typeIdentifier":"t_type$_t_address_$","typeString":"type(address)"},"typeName":{"id":58212,"name":"address","nodeType":"ElementaryTypeName","src":"12738:7:120","typeDescriptions":{}}},"id":58215,"isConstant":false,"isLValue":false,"isPure":true,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"12738:10:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"src":"12719:29:120","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},{"hexValue":"4665746368436861696e496e666f4f75747075743a2062617463685375626d6974746572206e6f7420736574","id":58217,"isConstant":false,"isLValue":false,"isPure":true,"kind":"string","lValueRequested":false,"nodeType":"Literal","src":"12750:46:120","typeDescriptions":{"typeIdentifier":"t_stringliteral_dc2094d90bbe21c62e4087e13d121e3f8b0b046ea0a70d61432535290d56a2cc","typeString":"literal_string \"FetchChainInfoOutput: batchSubmitter not set\""},"value":"FetchChainInfoOutput: batchSubmitter not set"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_bool","typeString":"bool"},{"typeIdentifier":"t_stringliteral_dc2094d90bbe21c62e4087e13d121e3f8b0b046ea0a70d61432535290d56a2cc","typeString":"literal_string \"FetchChainInfoOutput: batchSubmitter not set\""}],"id":58210,"name":"require","nodeType":"Identifier","overloadedDeclarations":[-18,-18],"referencedDeclaration":-18,"src":"12711:7:120","typeDescriptions":{"typeIdentifier":"t_function_require_pure$_t_bool_$_t_string_memory_ptr_$returns$__$","typeString":"function (bool,string memory) pure"}},"id":58218,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"12711:86:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":58219,"nodeType":"ExpressionStatement","src":"12711:86:120"},{"expression":{"id":58220,"name":"_batchSubmitter","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57461,"src":"12814:15:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"functionReturnParameters":58209,"id":58221,"nodeType":"Return","src":"12807:22:120"}]},"functionSelector":"fb951e9d","implemented":true,"kind":"function","modifiers":[],"name":"batchSubmitter","nameLocation":"12654:14:120","parameters":{"id":58206,"nodeType":"ParameterList","parameters":[],"src":"12668:2:120"},"returnParameters":{"id":58209,"nodeType":"ParameterList","parameters":[{"constant":false,"id":58208,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":58223,"src":"12692:7:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":58207,"name":"address","nodeType":"ElementaryTypeName","src":"12692:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"12691:9:120"},"scope":58249,"stateMutability":"view","virtual":false,"visibility":"public"},{"id":58231,"nodeType":"FunctionDefinition","src":"12842:88:120","nodes":[],"body":{"id":58230,"nodeType":"Block","src":"12893:37:120","nodes":[],"statements":[{"expression":{"id":58228,"name":"_permissioned","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57463,"src":"12910:13:120","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},"functionReturnParameters":58227,"id":58229,"nodeType":"Return","src":"12903:20:120"}]},"functionSelector":"3cc162f1","implemented":true,"kind":"function","modifiers":[],"name":"permissioned","nameLocation":"12851:12:120","parameters":{"id":58224,"nodeType":"ParameterList","parameters":[],"src":"12863:2:120"},"returnParameters":{"id":58227,"nodeType":"ParameterList","parameters":[{"constant":false,"id":58226,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":58231,"src":"12887:4:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"},"typeName":{"id":58225,"name":"bool","nodeType":"ElementaryTypeName","src":"12887:4:120","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},"visibility":"internal"}],"src":"12886:6:120"},"scope":58249,"stateMutability":"view","virtual":false,"visibility":"public"},{"id":58239,"nodeType":"FunctionDefinition","src":"12936:92:120","nodes":[],"body":{"id":58238,"nodeType":"Block","src":"12989:39:120","nodes":[],"statements":[{"expression":{"id":58236,"name":"_permissionless","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57465,"src":"13006:15:120","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},"functionReturnParameters":58235,"id":58237,"nodeType":"Return","src":"12999:22:120"}]},"functionSelector":"a1256f9f","implemented":true,"kind":"function","modifiers":[],"name":"permissionless","nameLocation":"12945:14:120","parameters":{"id":58232,"nodeType":"ParameterList","parameters":[],"src":"12959:2:120"},"returnParameters":{"id":58235,"nodeType":"ParameterList","parameters":[{"constant":false,"id":58234,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":58239,"src":"12983:4:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"},"typeName":{"id":58233,"name":"bool","nodeType":"ElementaryTypeName","src":"12983:4:120","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},"visibility":"internal"}],"src":"12982:6:120"},"scope":58249,"stateMutability":"view","virtual":false,"visibility":"public"},{"id":58248,"nodeType":"FunctionDefinition","src":"13034:102:120","nodes":[],"body":{"id":58247,"nodeType":"Block","src":"13094:42:120","nodes":[],"statements":[{"expression":{"id":58245,"name":"_respectedGameType","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57468,"src":"13111:18:120","typeDescriptions":{"typeIdentifier":"t_userDefinedValueType$_GameType_$75355","typeString":"GameType"}},"functionReturnParameters":58244,"id":58246,"nodeType":"Return","src":"13104:25:120"}]},"functionSelector":"3c9f397c","implemented":true,"kind":"function","modifiers":[],"name":"respectedGameType","nameLocation":"13043:17:120","parameters":{"id":58240,"nodeType":"ParameterList","parameters":[],"src":"13060:2:120"},"returnParameters":{"id":58244,"nodeType":"ParameterList","parameters":[{"constant":false,"id":58243,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":58248,"src":"13084:8:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_userDefinedValueType$_GameType_$75355","typeString":"GameType"},"typeName":{"id":58242,"nodeType":"UserDefinedTypeName","pathNode":{"id":58241,"name":"GameType","nameLocations":["13084:8:120"],"nodeType":"IdentifierPath","referencedDeclaration":75355,"src":"13084:8:120"},"referencedDeclaration":75355,"src":"13084:8:120","typeDescriptions":{"typeIdentifier":"t_userDefinedValueType$_GameType_$75355","typeString":"GameType"}},"visibility":"internal"}],"src":"13083:10:120"},"scope":58249,"stateMutability":"view","virtual":false,"visibility":"public"}],"abstract":false,"baseContracts":[],"canonicalName":"FetchChainInfoOutput","contractDependencies":[],"contractKind":"contract","fullyImplemented":true,"linearizedBaseContracts":[58249],"name":"FetchChainInfoOutput","nameLocation":"2966:20:120","scope":59300,"usedErrors":[],"usedEvents":[]},{"id":59299,"nodeType":"ContractDefinition","src":"13140:10848:120","nodes":[{"id":58275,"nodeType":"FunctionDefinition","src":"13180:198:120","nodes":[],"body":{"id":58274,"nodeType":"Block","src":"13251:127:120","nodes":[],"statements":[{"expression":{"arguments":[{"id":58261,"name":"_fi","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58254,"src":"13282:3:120","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoInput_$57409","typeString":"contract FetchChainInfoInput"}},{"id":58262,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58257,"src":"13287:3:120","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$58249","typeString":"contract FetchChainInfoOutput"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_contract$_FetchChainInfoInput_$57409","typeString":"contract FetchChainInfoInput"},{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$58249","typeString":"contract FetchChainInfoOutput"}],"id":58260,"name":"_processSystemConfig","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58411,"src":"13261:20:120","typeDescriptions":{"typeIdentifier":"t_function_internal_nonpayable$_t_contract$_FetchChainInfoInput_$57409_$_t_contract$_FetchChainInfoOutput_$58249_$returns$__$","typeString":"function (contract FetchChainInfoInput,contract FetchChainInfoOutput)"}},"id":58263,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"13261:30:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":58264,"nodeType":"ExpressionStatement","src":"13261:30:120"},{"expression":{"arguments":[{"id":58266,"name":"_fi","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58254,"src":"13328:3:120","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoInput_$57409","typeString":"contract FetchChainInfoInput"}},{"id":58267,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58257,"src":"13333:3:120","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$58249","typeString":"contract FetchChainInfoOutput"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_contract$_FetchChainInfoInput_$57409","typeString":"contract FetchChainInfoInput"},{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$58249","typeString":"contract FetchChainInfoOutput"}],"id":58265,"name":"_processMessengerAndPortal","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58528,"src":"13301:26:120","typeDescriptions":{"typeIdentifier":"t_function_internal_nonpayable$_t_contract$_FetchChainInfoInput_$57409_$_t_contract$_FetchChainInfoOutput_$58249_$returns$__$","typeString":"function (contract FetchChainInfoInput,contract FetchChainInfoOutput)"}},"id":58268,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"13301:36:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":58269,"nodeType":"ExpressionStatement","src":"13301:36:120"},{"expression":{"arguments":[{"id":58271,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58257,"src":"13367:3:120","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$58249","typeString":"contract FetchChainInfoOutput"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$58249","typeString":"contract FetchChainInfoOutput"}],"id":58270,"name":"_processFaultProofs","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58878,"src":"13347:19:120","typeDescriptions":{"typeIdentifier":"t_function_internal_nonpayable$_t_contract$_FetchChainInfoOutput_$58249_$returns$__$","typeString":"function (contract FetchChainInfoOutput)"}},"id":58272,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"13347:24:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":58273,"nodeType":"ExpressionStatement","src":"13347:24:120"}]},"functionSelector":"fc4dcacb","implemented":true,"kind":"function","modifiers":[],"name":"run","nameLocation":"13189:3:120","parameters":{"id":58258,"nodeType":"ParameterList","parameters":[{"constant":false,"id":58254,"mutability":"mutable","name":"_fi","nameLocation":"13213:3:120","nodeType":"VariableDeclaration","scope":58275,"src":"13193:23:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoInput_$57409","typeString":"contract FetchChainInfoInput"},"typeName":{"id":58253,"nodeType":"UserDefinedTypeName","pathNode":{"id":58252,"name":"FetchChainInfoInput","nameLocations":["13193:19:120"],"nodeType":"IdentifierPath","referencedDeclaration":57409,"src":"13193:19:120"},"referencedDeclaration":57409,"src":"13193:19:120","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoInput_$57409","typeString":"contract FetchChainInfoInput"}},"visibility":"internal"},{"constant":false,"id":58257,"mutability":"mutable","name":"_fo","nameLocation":"13239:3:120","nodeType":"VariableDeclaration","scope":58275,"src":"13218:24:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$58249","typeString":"contract FetchChainInfoOutput"},"typeName":{"id":58256,"nodeType":"UserDefinedTypeName","pathNode":{"id":58255,"name":"FetchChainInfoOutput","nameLocations":["13218:20:120"],"nodeType":"IdentifierPath","referencedDeclaration":58249,"src":"13218:20:120"},"referencedDeclaration":58249,"src":"13218:20:120","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$58249","typeString":"contract FetchChainInfoOutput"}},"visibility":"internal"}],"src":"13192:51:120"},"returnParameters":{"id":58259,"nodeType":"ParameterList","parameters":[],"src":"13251:0:120"},"scope":59299,"stateMutability":"nonpayable","virtual":false,"visibility":"public"},{"id":58411,"nodeType":"FunctionDefinition","src":"13384:1336:120","nodes":[],"body":{"id":58410,"nodeType":"Block","src":"13474:1246:120","nodes":[],"statements":[{"assignments":[58285],"declarations":[{"constant":false,"id":58285,"mutability":"mutable","name":"systemConfigProxy","nameLocation":"13492:17:120","nodeType":"VariableDeclaration","scope":58410,"src":"13484:25:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":58284,"name":"address","nodeType":"ElementaryTypeName","src":"13484:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"id":58289,"initialValue":{"arguments":[],"expression":{"argumentTypes":[],"expression":{"id":58286,"name":"_fi","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58278,"src":"13512:3:120","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoInput_$57409","typeString":"contract FetchChainInfoInput"}},"id":58287,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"13516:17:120","memberName":"systemConfigProxy","nodeType":"MemberAccess","referencedDeclaration":57390,"src":"13512:21:120","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":58288,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"13512:23:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"VariableDeclarationStatement","src":"13484:51:120"},{"expression":{"arguments":[{"expression":{"expression":{"id":58293,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58281,"src":"13553:3:120","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$58249","typeString":"contract FetchChainInfoOutput"}},"id":58294,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"13557:17:120","memberName":"systemConfigProxy","nodeType":"MemberAccess","referencedDeclaration":57947,"src":"13553:21:120","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":58295,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"13575:8:120","memberName":"selector","nodeType":"MemberAccess","src":"13553:30:120","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},{"id":58296,"name":"systemConfigProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58285,"src":"13585:17:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_bytes4","typeString":"bytes4"},{"typeIdentifier":"t_address","typeString":"address"}],"expression":{"id":58290,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58281,"src":"13545:3:120","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$58249","typeString":"contract FetchChainInfoOutput"}},"id":58292,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"13549:3:120","memberName":"set","nodeType":"MemberAccess","referencedDeclaration":57740,"src":"13545:7:120","typeDescriptions":{"typeIdentifier":"t_function_external_nonpayable$_t_bytes4_$_t_address_$returns$__$","typeString":"function (bytes4,address) external"}},"id":58297,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"13545:58:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":58298,"nodeType":"ExpressionStatement","src":"13545:58:120"},{"assignments":[58300],"declarations":[{"constant":false,"id":58300,"mutability":"mutable","name":"systemConfigOwner","nameLocation":"13622:17:120","nodeType":"VariableDeclaration","scope":58410,"src":"13614:25:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":58299,"name":"address","nodeType":"ElementaryTypeName","src":"13614:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"id":58306,"initialValue":{"arguments":[],"expression":{"argumentTypes":[],"expression":{"arguments":[{"id":58302,"name":"systemConfigProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58285,"src":"13651:17:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_address","typeString":"address"}],"id":58301,"name":"IFetcher","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57326,"src":"13642:8:120","typeDescriptions":{"typeIdentifier":"t_type$_t_contract$_IFetcher_$57326_$","typeString":"type(contract IFetcher)"}},"id":58303,"isConstant":false,"isLValue":false,"isPure":false,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"13642:27:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_contract$_IFetcher_$57326","typeString":"contract IFetcher"}},"id":58304,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"13670:5:120","memberName":"owner","nodeType":"MemberAccess","referencedDeclaration":57315,"src":"13642:33:120","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":58305,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"13642:35:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"VariableDeclarationStatement","src":"13614:63:120"},{"expression":{"arguments":[{"expression":{"expression":{"id":58310,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58281,"src":"13695:3:120","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$58249","typeString":"contract FetchChainInfoOutput"}},"id":58311,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"13699:17:120","memberName":"systemConfigOwner","nodeType":"MemberAccess","referencedDeclaration":58115,"src":"13695:21:120","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":58312,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"13717:8:120","memberName":"selector","nodeType":"MemberAccess","src":"13695:30:120","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},{"id":58313,"name":"systemConfigOwner","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58300,"src":"13727:17:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_bytes4","typeString":"bytes4"},{"typeIdentifier":"t_address","typeString":"address"}],"expression":{"id":58307,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58281,"src":"13687:3:120","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$58249","typeString":"contract FetchChainInfoOutput"}},"id":58309,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"13691:3:120","memberName":"set","nodeType":"MemberAccess","referencedDeclaration":57740,"src":"13687:7:120","typeDescriptions":{"typeIdentifier":"t_function_external_nonpayable$_t_bytes4_$_t_address_$returns$__$","typeString":"function (bytes4,address) external"}},"id":58314,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"13687:58:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":58315,"nodeType":"ExpressionStatement","src":"13687:58:120"},{"assignments":[58317],"declarations":[{"constant":false,"id":58317,"mutability":"mutable","name":"unsafeBlockSigner","nameLocation":"13764:17:120","nodeType":"VariableDeclaration","scope":58410,"src":"13756:25:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":58316,"name":"address","nodeType":"ElementaryTypeName","src":"13756:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"id":58323,"initialValue":{"arguments":[],"expression":{"argumentTypes":[],"expression":{"arguments":[{"id":58319,"name":"systemConfigProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58285,"src":"13793:17:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_address","typeString":"address"}],"id":58318,"name":"IFetcher","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57326,"src":"13784:8:120","typeDescriptions":{"typeIdentifier":"t_type$_t_contract$_IFetcher_$57326_$","typeString":"type(contract IFetcher)"}},"id":58320,"isConstant":false,"isLValue":false,"isPure":false,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"13784:27:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_contract$_IFetcher_$57326","typeString":"contract IFetcher"}},"id":58321,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"13812:17:120","memberName":"unsafeBlockSigner","nodeType":"MemberAccess","referencedDeclaration":57320,"src":"13784:45:120","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":58322,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"13784:47:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"VariableDeclarationStatement","src":"13756:75:120"},{"expression":{"arguments":[{"expression":{"expression":{"id":58327,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58281,"src":"13849:3:120","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$58249","typeString":"contract FetchChainInfoOutput"}},"id":58328,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"13853:17:120","memberName":"unsafeBlockSigner","nodeType":"MemberAccess","referencedDeclaration":58205,"src":"13849:21:120","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":58329,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"13871:8:120","memberName":"selector","nodeType":"MemberAccess","src":"13849:30:120","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},{"id":58330,"name":"unsafeBlockSigner","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58317,"src":"13881:17:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_bytes4","typeString":"bytes4"},{"typeIdentifier":"t_address","typeString":"address"}],"expression":{"id":58324,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58281,"src":"13841:3:120","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$58249","typeString":"contract FetchChainInfoOutput"}},"id":58326,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"13845:3:120","memberName":"set","nodeType":"MemberAccess","referencedDeclaration":57740,"src":"13841:7:120","typeDescriptions":{"typeIdentifier":"t_function_external_nonpayable$_t_bytes4_$_t_address_$returns$__$","typeString":"function (bytes4,address) external"}},"id":58331,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"13841:58:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":58332,"nodeType":"ExpressionStatement","src":"13841:58:120"},{"assignments":[58334],"declarations":[{"constant":false,"id":58334,"mutability":"mutable","name":"batchSubmitter","nameLocation":"13918:14:120","nodeType":"VariableDeclaration","scope":58410,"src":"13910:22:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":58333,"name":"address","nodeType":"ElementaryTypeName","src":"13910:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"id":58338,"initialValue":{"arguments":[{"id":58336,"name":"systemConfigProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58285,"src":"13954:17:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_address","typeString":"address"}],"id":58335,"name":"_getBatchSubmitter","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":59275,"src":"13935:18:120","typeDescriptions":{"typeIdentifier":"t_function_internal_view$_t_address_$returns$_t_address_$","typeString":"function (address) view returns (address)"}},"id":58337,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"13935:37:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"VariableDeclarationStatement","src":"13910:62:120"},{"expression":{"arguments":[{"expression":{"expression":{"id":58342,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58281,"src":"13990:3:120","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$58249","typeString":"contract FetchChainInfoOutput"}},"id":58343,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"13994:14:120","memberName":"batchSubmitter","nodeType":"MemberAccess","referencedDeclaration":58223,"src":"13990:18:120","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":58344,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"14009:8:120","memberName":"selector","nodeType":"MemberAccess","src":"13990:27:120","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},{"id":58345,"name":"batchSubmitter","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58334,"src":"14019:14:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_bytes4","typeString":"bytes4"},{"typeIdentifier":"t_address","typeString":"address"}],"expression":{"id":58339,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58281,"src":"13982:3:120","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$58249","typeString":"contract FetchChainInfoOutput"}},"id":58341,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"13986:3:120","memberName":"set","nodeType":"MemberAccess","referencedDeclaration":57740,"src":"13982:7:120","typeDescriptions":{"typeIdentifier":"t_function_external_nonpayable$_t_bytes4_$_t_address_$returns$__$","typeString":"function (bytes4,address) external"}},"id":58346,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"13982:52:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":58347,"nodeType":"ExpressionStatement","src":"13982:52:120"},{"assignments":[58349],"declarations":[{"constant":false,"id":58349,"mutability":"mutable","name":"opChainProxyAdminImpl","nameLocation":"14053:21:120","nodeType":"VariableDeclaration","scope":58410,"src":"14045:29:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":58348,"name":"address","nodeType":"ElementaryTypeName","src":"14045:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"id":58353,"initialValue":{"arguments":[{"id":58351,"name":"systemConfigProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58285,"src":"14092:17:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_address","typeString":"address"}],"id":58350,"name":"_getProxyAdmin","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":59298,"src":"14077:14:120","typeDescriptions":{"typeIdentifier":"t_function_internal_nonpayable$_t_address_$returns$_t_address_$","typeString":"function (address) returns (address)"}},"id":58352,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"14077:33:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"VariableDeclarationStatement","src":"14045:65:120"},{"expression":{"arguments":[{"expression":{"expression":{"id":58357,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58281,"src":"14128:3:120","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$58249","typeString":"contract FetchChainInfoOutput"}},"id":58358,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"14132:21:120","memberName":"opChainProxyAdminImpl","nodeType":"MemberAccess","referencedDeclaration":57965,"src":"14128:25:120","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":58359,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"14154:8:120","memberName":"selector","nodeType":"MemberAccess","src":"14128:34:120","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},{"id":58360,"name":"opChainProxyAdminImpl","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58349,"src":"14164:21:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_bytes4","typeString":"bytes4"},{"typeIdentifier":"t_address","typeString":"address"}],"expression":{"id":58354,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58281,"src":"14120:3:120","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$58249","typeString":"contract FetchChainInfoOutput"}},"id":58356,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"14124:3:120","memberName":"set","nodeType":"MemberAccess","referencedDeclaration":57740,"src":"14120:7:120","typeDescriptions":{"typeIdentifier":"t_function_external_nonpayable$_t_bytes4_$_t_address_$returns$__$","typeString":"function (bytes4,address) external"}},"id":58361,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"14120:66:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":58362,"nodeType":"ExpressionStatement","src":"14120:66:120"},{"assignments":[58364],"declarations":[{"constant":false,"id":58364,"mutability":"mutable","name":"opChainProxyAdminOwner","nameLocation":"14205:22:120","nodeType":"VariableDeclaration","scope":58410,"src":"14197:30:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":58363,"name":"address","nodeType":"ElementaryTypeName","src":"14197:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"id":58370,"initialValue":{"arguments":[],"expression":{"argumentTypes":[],"expression":{"arguments":[{"id":58366,"name":"opChainProxyAdminImpl","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58349,"src":"14239:21:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_address","typeString":"address"}],"id":58365,"name":"IFetcher","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57326,"src":"14230:8:120","typeDescriptions":{"typeIdentifier":"t_type$_t_contract$_IFetcher_$57326_$","typeString":"type(contract IFetcher)"}},"id":58367,"isConstant":false,"isLValue":false,"isPure":false,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"14230:31:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_contract$_IFetcher_$57326","typeString":"contract IFetcher"}},"id":58368,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"14262:5:120","memberName":"owner","nodeType":"MemberAccess","referencedDeclaration":57315,"src":"14230:37:120","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":58369,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"14230:39:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"VariableDeclarationStatement","src":"14197:72:120"},{"expression":{"arguments":[{"expression":{"expression":{"id":58374,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58281,"src":"14287:3:120","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$58249","typeString":"contract FetchChainInfoOutput"}},"id":58375,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"14291:22:120","memberName":"opChainProxyAdminOwner","nodeType":"MemberAccess","referencedDeclaration":58133,"src":"14287:26:120","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":58376,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"14314:8:120","memberName":"selector","nodeType":"MemberAccess","src":"14287:35:120","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},{"id":58377,"name":"opChainProxyAdminOwner","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58364,"src":"14324:22:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_bytes4","typeString":"bytes4"},{"typeIdentifier":"t_address","typeString":"address"}],"expression":{"id":58371,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58281,"src":"14279:3:120","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$58249","typeString":"contract FetchChainInfoOutput"}},"id":58373,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"14283:3:120","memberName":"set","nodeType":"MemberAccess","referencedDeclaration":57740,"src":"14279:7:120","typeDescriptions":{"typeIdentifier":"t_function_external_nonpayable$_t_bytes4_$_t_address_$returns$__$","typeString":"function (bytes4,address) external"}},"id":58378,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"14279:68:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":58379,"nodeType":"ExpressionStatement","src":"14279:68:120"},{"assignments":[58381],"declarations":[{"constant":false,"id":58381,"mutability":"mutable","name":"l1Erc721BridgeProxy","nameLocation":"14366:19:120","nodeType":"VariableDeclaration","scope":58410,"src":"14358:27:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":58380,"name":"address","nodeType":"ElementaryTypeName","src":"14358:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"id":58385,"initialValue":{"arguments":[{"id":58383,"name":"systemConfigProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58285,"src":"14412:17:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_address","typeString":"address"}],"id":58382,"name":"_getL1ERC721BridgeProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":59031,"src":"14388:23:120","typeDescriptions":{"typeIdentifier":"t_function_internal_view$_t_address_$returns$_t_address_$","typeString":"function (address) view returns (address)"}},"id":58384,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"14388:42:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"VariableDeclarationStatement","src":"14358:72:120"},{"expression":{"arguments":[{"expression":{"expression":{"id":58389,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58281,"src":"14448:3:120","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$58249","typeString":"contract FetchChainInfoOutput"}},"id":58390,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"14452:19:120","memberName":"l1Erc721BridgeProxy","nodeType":"MemberAccess","referencedDeclaration":57857,"src":"14448:23:120","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":58391,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"14472:8:120","memberName":"selector","nodeType":"MemberAccess","src":"14448:32:120","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},{"id":58392,"name":"l1Erc721BridgeProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58381,"src":"14482:19:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_bytes4","typeString":"bytes4"},{"typeIdentifier":"t_address","typeString":"address"}],"expression":{"id":58386,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58281,"src":"14440:3:120","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$58249","typeString":"contract FetchChainInfoOutput"}},"id":58388,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"14444:3:120","memberName":"set","nodeType":"MemberAccess","referencedDeclaration":57740,"src":"14440:7:120","typeDescriptions":{"typeIdentifier":"t_function_external_nonpayable$_t_bytes4_$_t_address_$returns$__$","typeString":"function (bytes4,address) external"}},"id":58393,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"14440:62:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":58394,"nodeType":"ExpressionStatement","src":"14440:62:120"},{"assignments":[58396],"declarations":[{"constant":false,"id":58396,"mutability":"mutable","name":"optimismMintableErc20FactoryProxy","nameLocation":"14521:33:120","nodeType":"VariableDeclaration","scope":58410,"src":"14513:41:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":58395,"name":"address","nodeType":"ElementaryTypeName","src":"14513:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"id":58400,"initialValue":{"arguments":[{"id":58398,"name":"systemConfigProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58285,"src":"14595:17:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_address","typeString":"address"}],"id":58397,"name":"_getOptimismMintableERC20FactoryProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":59059,"src":"14557:37:120","typeDescriptions":{"typeIdentifier":"t_function_internal_view$_t_address_$returns$_t_address_$","typeString":"function (address) view returns (address)"}},"id":58399,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"14557:56:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"VariableDeclarationStatement","src":"14513:100:120"},{"expression":{"arguments":[{"expression":{"expression":{"id":58404,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58281,"src":"14631:3:120","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$58249","typeString":"contract FetchChainInfoOutput"}},"id":58405,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"14635:33:120","memberName":"optimismMintableErc20FactoryProxy","nodeType":"MemberAccess","referencedDeclaration":57911,"src":"14631:37:120","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":58406,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"14669:8:120","memberName":"selector","nodeType":"MemberAccess","src":"14631:46:120","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},{"id":58407,"name":"optimismMintableErc20FactoryProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58396,"src":"14679:33:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_bytes4","typeString":"bytes4"},{"typeIdentifier":"t_address","typeString":"address"}],"expression":{"id":58401,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58281,"src":"14623:3:120","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$58249","typeString":"contract FetchChainInfoOutput"}},"id":58403,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"14627:3:120","memberName":"set","nodeType":"MemberAccess","referencedDeclaration":57740,"src":"14623:7:120","typeDescriptions":{"typeIdentifier":"t_function_external_nonpayable$_t_bytes4_$_t_address_$returns$__$","typeString":"function (bytes4,address) external"}},"id":58408,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"14623:90:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":58409,"nodeType":"ExpressionStatement","src":"14623:90:120"}]},"implemented":true,"kind":"function","modifiers":[],"name":"_processSystemConfig","nameLocation":"13393:20:120","parameters":{"id":58282,"nodeType":"ParameterList","parameters":[{"constant":false,"id":58278,"mutability":"mutable","name":"_fi","nameLocation":"13434:3:120","nodeType":"VariableDeclaration","scope":58411,"src":"13414:23:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoInput_$57409","typeString":"contract FetchChainInfoInput"},"typeName":{"id":58277,"nodeType":"UserDefinedTypeName","pathNode":{"id":58276,"name":"FetchChainInfoInput","nameLocations":["13414:19:120"],"nodeType":"IdentifierPath","referencedDeclaration":57409,"src":"13414:19:120"},"referencedDeclaration":57409,"src":"13414:19:120","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoInput_$57409","typeString":"contract FetchChainInfoInput"}},"visibility":"internal"},{"constant":false,"id":58281,"mutability":"mutable","name":"_fo","nameLocation":"13460:3:120","nodeType":"VariableDeclaration","scope":58411,"src":"13439:24:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$58249","typeString":"contract FetchChainInfoOutput"},"typeName":{"id":58280,"nodeType":"UserDefinedTypeName","pathNode":{"id":58279,"name":"FetchChainInfoOutput","nameLocations":["13439:20:120"],"nodeType":"IdentifierPath","referencedDeclaration":58249,"src":"13439:20:120"},"referencedDeclaration":58249,"src":"13439:20:120","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$58249","typeString":"contract FetchChainInfoOutput"}},"visibility":"internal"}],"src":"13413:51:120"},"returnParameters":{"id":58283,"nodeType":"ParameterList","parameters":[],"src":"13474:0:120"},"scope":59299,"stateMutability":"nonpayable","virtual":false,"visibility":"internal"},{"id":58528,"nodeType":"FunctionDefinition","src":"14726:1190:120","nodes":[],"body":{"id":58527,"nodeType":"Block","src":"14822:1094:120","nodes":[],"statements":[{"assignments":[58421],"declarations":[{"constant":false,"id":58421,"mutability":"mutable","name":"l1StandardBridgeProxy","nameLocation":"14840:21:120","nodeType":"VariableDeclaration","scope":58527,"src":"14832:29:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":58420,"name":"address","nodeType":"ElementaryTypeName","src":"14832:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"id":58425,"initialValue":{"arguments":[],"expression":{"argumentTypes":[],"expression":{"id":58422,"name":"_fi","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58414,"src":"14864:3:120","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoInput_$57409","typeString":"contract FetchChainInfoInput"}},"id":58423,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"14868:21:120","memberName":"l1StandardBridgeProxy","nodeType":"MemberAccess","referencedDeclaration":57408,"src":"14864:25:120","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":58424,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"14864:27:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"VariableDeclarationStatement","src":"14832:59:120"},{"expression":{"arguments":[{"expression":{"expression":{"id":58429,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58417,"src":"14909:3:120","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$58249","typeString":"contract FetchChainInfoOutput"}},"id":58430,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"14913:21:120","memberName":"l1StandardBridgeProxy","nodeType":"MemberAccess","referencedDeclaration":57875,"src":"14909:25:120","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":58431,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"14935:8:120","memberName":"selector","nodeType":"MemberAccess","src":"14909:34:120","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},{"id":58432,"name":"l1StandardBridgeProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58421,"src":"14945:21:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_bytes4","typeString":"bytes4"},{"typeIdentifier":"t_address","typeString":"address"}],"expression":{"id":58426,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58417,"src":"14901:3:120","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$58249","typeString":"contract FetchChainInfoOutput"}},"id":58428,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"14905:3:120","memberName":"set","nodeType":"MemberAccess","referencedDeclaration":57740,"src":"14901:7:120","typeDescriptions":{"typeIdentifier":"t_function_external_nonpayable$_t_bytes4_$_t_address_$returns$__$","typeString":"function (bytes4,address) external"}},"id":58433,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"14901:66:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":58434,"nodeType":"ExpressionStatement","src":"14901:66:120"},{"assignments":[58436],"declarations":[{"constant":false,"id":58436,"mutability":"mutable","name":"l1CrossDomainMessengerProxy","nameLocation":"14986:27:120","nodeType":"VariableDeclaration","scope":58527,"src":"14978:35:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":58435,"name":"address","nodeType":"ElementaryTypeName","src":"14978:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"id":58442,"initialValue":{"arguments":[],"expression":{"argumentTypes":[],"expression":{"arguments":[{"id":58438,"name":"l1StandardBridgeProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58421,"src":"15025:21:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_address","typeString":"address"}],"id":58437,"name":"IFetcher","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57326,"src":"15016:8:120","typeDescriptions":{"typeIdentifier":"t_type$_t_contract$_IFetcher_$57326_$","typeString":"type(contract IFetcher)"}},"id":58439,"isConstant":false,"isLValue":false,"isPure":false,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"15016:31:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_contract$_IFetcher_$57326","typeString":"contract IFetcher"}},"id":58440,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"15048:9:120","memberName":"messenger","nodeType":"MemberAccess","referencedDeclaration":57221,"src":"15016:41:120","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":58441,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"15016:43:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"VariableDeclarationStatement","src":"14978:81:120"},{"expression":{"arguments":[{"expression":{"expression":{"id":58446,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58417,"src":"15077:3:120","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$58249","typeString":"contract FetchChainInfoOutput"}},"id":58447,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"15081:27:120","memberName":"l1CrossDomainMessengerProxy","nodeType":"MemberAccess","referencedDeclaration":57839,"src":"15077:31:120","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":58448,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"15109:8:120","memberName":"selector","nodeType":"MemberAccess","src":"15077:40:120","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},{"id":58449,"name":"l1CrossDomainMessengerProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58436,"src":"15119:27:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_bytes4","typeString":"bytes4"},{"typeIdentifier":"t_address","typeString":"address"}],"expression":{"id":58443,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58417,"src":"15069:3:120","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$58249","typeString":"contract FetchChainInfoOutput"}},"id":58445,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"15073:3:120","memberName":"set","nodeType":"MemberAccess","referencedDeclaration":57740,"src":"15069:7:120","typeDescriptions":{"typeIdentifier":"t_function_external_nonpayable$_t_bytes4_$_t_address_$returns$__$","typeString":"function (bytes4,address) external"}},"id":58450,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"15069:78:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":58451,"nodeType":"ExpressionStatement","src":"15069:78:120"},{"assignments":[58453],"declarations":[{"constant":false,"id":58453,"mutability":"mutable","name":"addressManagerImpl","nameLocation":"15166:18:120","nodeType":"VariableDeclaration","scope":58527,"src":"15158:26:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":58452,"name":"address","nodeType":"ElementaryTypeName","src":"15158:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"id":58457,"initialValue":{"arguments":[{"id":58455,"name":"l1CrossDomainMessengerProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58436,"src":"15206:27:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_address","typeString":"address"}],"id":58454,"name":"_getAddressManager","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":59003,"src":"15187:18:120","typeDescriptions":{"typeIdentifier":"t_function_internal_view$_t_address_$returns$_t_address_$","typeString":"function (address) view returns (address)"}},"id":58456,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"15187:47:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"VariableDeclarationStatement","src":"15158:76:120"},{"expression":{"arguments":[{"expression":{"expression":{"id":58461,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58417,"src":"15252:3:120","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$58249","typeString":"contract FetchChainInfoOutput"}},"id":58462,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"15256:18:120","memberName":"addressManagerImpl","nodeType":"MemberAccess","referencedDeclaration":57813,"src":"15252:22:120","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":58463,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"15275:8:120","memberName":"selector","nodeType":"MemberAccess","src":"15252:31:120","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},{"id":58464,"name":"addressManagerImpl","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58453,"src":"15285:18:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_bytes4","typeString":"bytes4"},{"typeIdentifier":"t_address","typeString":"address"}],"expression":{"id":58458,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58417,"src":"15244:3:120","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$58249","typeString":"contract FetchChainInfoOutput"}},"id":58460,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"15248:3:120","memberName":"set","nodeType":"MemberAccess","referencedDeclaration":57740,"src":"15244:7:120","typeDescriptions":{"typeIdentifier":"t_function_external_nonpayable$_t_bytes4_$_t_address_$returns$__$","typeString":"function (bytes4,address) external"}},"id":58465,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"15244:60:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":58466,"nodeType":"ExpressionStatement","src":"15244:60:120"},{"assignments":[58468],"declarations":[{"constant":false,"id":58468,"mutability":"mutable","name":"optimismPortalProxy","nameLocation":"15323:19:120","nodeType":"VariableDeclaration","scope":58527,"src":"15315:27:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":58467,"name":"address","nodeType":"ElementaryTypeName","src":"15315:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"id":58472,"initialValue":{"arguments":[{"id":58470,"name":"l1CrossDomainMessengerProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58436,"src":"15369:27:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_address","typeString":"address"}],"id":58469,"name":"_getOptimismPortalProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58965,"src":"15345:23:120","typeDescriptions":{"typeIdentifier":"t_function_internal_view$_t_address_$returns$_t_address_$","typeString":"function (address) view returns (address)"}},"id":58471,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"15345:52:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"VariableDeclarationStatement","src":"15315:82:120"},{"expression":{"arguments":[{"expression":{"expression":{"id":58476,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58417,"src":"15415:3:120","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$58249","typeString":"contract FetchChainInfoOutput"}},"id":58477,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"15419:19:120","memberName":"optimismPortalProxy","nodeType":"MemberAccess","referencedDeclaration":57929,"src":"15415:23:120","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":58478,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"15439:8:120","memberName":"selector","nodeType":"MemberAccess","src":"15415:32:120","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},{"id":58479,"name":"optimismPortalProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58468,"src":"15449:19:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_bytes4","typeString":"bytes4"},{"typeIdentifier":"t_address","typeString":"address"}],"expression":{"id":58473,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58417,"src":"15407:3:120","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$58249","typeString":"contract FetchChainInfoOutput"}},"id":58475,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"15411:3:120","memberName":"set","nodeType":"MemberAccess","referencedDeclaration":57740,"src":"15407:7:120","typeDescriptions":{"typeIdentifier":"t_function_external_nonpayable$_t_bytes4_$_t_address_$returns$__$","typeString":"function (bytes4,address) external"}},"id":58480,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"15407:62:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":58481,"nodeType":"ExpressionStatement","src":"15407:62:120"},{"assignments":[58483],"declarations":[{"constant":false,"id":58483,"mutability":"mutable","name":"opChainGuardian","nameLocation":"15488:15:120","nodeType":"VariableDeclaration","scope":58527,"src":"15480:23:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":58482,"name":"address","nodeType":"ElementaryTypeName","src":"15480:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"id":58487,"initialValue":{"arguments":[{"id":58485,"name":"optimismPortalProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58468,"src":"15519:19:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_address","typeString":"address"}],"id":58484,"name":"_getGuardian","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58907,"src":"15506:12:120","typeDescriptions":{"typeIdentifier":"t_function_internal_view$_t_address_$returns$_t_address_$","typeString":"function (address) view returns (address)"}},"id":58486,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"15506:33:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"VariableDeclarationStatement","src":"15480:59:120"},{"expression":{"arguments":[{"expression":{"expression":{"id":58491,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58417,"src":"15557:3:120","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$58249","typeString":"contract FetchChainInfoOutput"}},"id":58492,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"15561:15:120","memberName":"opChainGuardian","nodeType":"MemberAccess","referencedDeclaration":58151,"src":"15557:19:120","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":58493,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"15577:8:120","memberName":"selector","nodeType":"MemberAccess","src":"15557:28:120","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},{"id":58494,"name":"opChainGuardian","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58483,"src":"15587:15:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_bytes4","typeString":"bytes4"},{"typeIdentifier":"t_address","typeString":"address"}],"expression":{"id":58488,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58417,"src":"15549:3:120","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$58249","typeString":"contract FetchChainInfoOutput"}},"id":58490,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"15553:3:120","memberName":"set","nodeType":"MemberAccess","referencedDeclaration":57740,"src":"15549:7:120","typeDescriptions":{"typeIdentifier":"t_function_external_nonpayable$_t_bytes4_$_t_address_$returns$__$","typeString":"function (bytes4,address) external"}},"id":58495,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"15549:54:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":58496,"nodeType":"ExpressionStatement","src":"15549:54:120"},{"assignments":[58498],"declarations":[{"constant":false,"id":58498,"mutability":"mutable","name":"ethLockboxProxy","nameLocation":"15622:15:120","nodeType":"VariableDeclaration","scope":58527,"src":"15614:23:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":58497,"name":"address","nodeType":"ElementaryTypeName","src":"15614:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"id":58502,"initialValue":{"arguments":[{"id":58500,"name":"optimismPortalProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58468,"src":"15660:19:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_address","typeString":"address"}],"id":58499,"name":"_getEthLockboxProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":59203,"src":"15640:19:120","typeDescriptions":{"typeIdentifier":"t_function_internal_view$_t_address_$returns$_t_address_$","typeString":"function (address) view returns (address)"}},"id":58501,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"15640:40:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"VariableDeclarationStatement","src":"15614:66:120"},{"expression":{"arguments":[{"expression":{"expression":{"id":58506,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58417,"src":"15698:3:120","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$58249","typeString":"contract FetchChainInfoOutput"}},"id":58507,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"15702:15:120","memberName":"ethLockboxProxy","nodeType":"MemberAccess","referencedDeclaration":57821,"src":"15698:19:120","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":58508,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"15718:8:120","memberName":"selector","nodeType":"MemberAccess","src":"15698:28:120","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},{"id":58509,"name":"ethLockboxProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58498,"src":"15728:15:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_bytes4","typeString":"bytes4"},{"typeIdentifier":"t_address","typeString":"address"}],"expression":{"id":58503,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58417,"src":"15690:3:120","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$58249","typeString":"contract FetchChainInfoOutput"}},"id":58505,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"15694:3:120","memberName":"set","nodeType":"MemberAccess","referencedDeclaration":57740,"src":"15690:7:120","typeDescriptions":{"typeIdentifier":"t_function_external_nonpayable$_t_bytes4_$_t_address_$returns$__$","typeString":"function (bytes4,address) external"}},"id":58510,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"15690:54:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":58511,"nodeType":"ExpressionStatement","src":"15690:54:120"},{"assignments":[58513],"declarations":[{"constant":false,"id":58513,"mutability":"mutable","name":"superchainConfigProxy","nameLocation":"15763:21:120","nodeType":"VariableDeclaration","scope":58527,"src":"15755:29:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":58512,"name":"address","nodeType":"ElementaryTypeName","src":"15755:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"id":58517,"initialValue":{"arguments":[{"id":58515,"name":"optimismPortalProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58468,"src":"15813:19:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_address","typeString":"address"}],"id":58514,"name":"_getSuperchainConfigProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":59115,"src":"15787:25:120","typeDescriptions":{"typeIdentifier":"t_function_internal_view$_t_address_$returns$_t_address_$","typeString":"function (address) view returns (address)"}},"id":58516,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"15787:46:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"VariableDeclarationStatement","src":"15755:78:120"},{"expression":{"arguments":[{"expression":{"expression":{"id":58521,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58417,"src":"15851:3:120","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$58249","typeString":"contract FetchChainInfoOutput"}},"id":58522,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"15855:21:120","memberName":"superchainConfigProxy","nodeType":"MemberAccess","referencedDeclaration":57983,"src":"15851:25:120","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":58523,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"15877:8:120","memberName":"selector","nodeType":"MemberAccess","src":"15851:34:120","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},{"id":58524,"name":"superchainConfigProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58513,"src":"15887:21:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_bytes4","typeString":"bytes4"},{"typeIdentifier":"t_address","typeString":"address"}],"expression":{"id":58518,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58417,"src":"15843:3:120","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$58249","typeString":"contract FetchChainInfoOutput"}},"id":58520,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"15847:3:120","memberName":"set","nodeType":"MemberAccess","referencedDeclaration":57740,"src":"15843:7:120","typeDescriptions":{"typeIdentifier":"t_function_external_nonpayable$_t_bytes4_$_t_address_$returns$__$","typeString":"function (bytes4,address) external"}},"id":58525,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"15843:66:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":58526,"nodeType":"ExpressionStatement","src":"15843:66:120"}]},"implemented":true,"kind":"function","modifiers":[],"name":"_processMessengerAndPortal","nameLocation":"14735:26:120","parameters":{"id":58418,"nodeType":"ParameterList","parameters":[{"constant":false,"id":58414,"mutability":"mutable","name":"_fi","nameLocation":"14782:3:120","nodeType":"VariableDeclaration","scope":58528,"src":"14762:23:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoInput_$57409","typeString":"contract FetchChainInfoInput"},"typeName":{"id":58413,"nodeType":"UserDefinedTypeName","pathNode":{"id":58412,"name":"FetchChainInfoInput","nameLocations":["14762:19:120"],"nodeType":"IdentifierPath","referencedDeclaration":57409,"src":"14762:19:120"},"referencedDeclaration":57409,"src":"14762:19:120","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoInput_$57409","typeString":"contract FetchChainInfoInput"}},"visibility":"internal"},{"constant":false,"id":58417,"mutability":"mutable","name":"_fo","nameLocation":"14808:3:120","nodeType":"VariableDeclaration","scope":58528,"src":"14787:24:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$58249","typeString":"contract FetchChainInfoOutput"},"typeName":{"id":58416,"nodeType":"UserDefinedTypeName","pathNode":{"id":58415,"name":"FetchChainInfoOutput","nameLocations":["14787:20:120"],"nodeType":"IdentifierPath","referencedDeclaration":58249,"src":"14787:20:120"},"referencedDeclaration":58249,"src":"14787:20:120","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$58249","typeString":"contract FetchChainInfoOutput"}},"visibility":"internal"}],"src":"14761:51:120"},"returnParameters":{"id":58419,"nodeType":"ParameterList","parameters":[],"src":"14822:0:120"},"scope":59299,"stateMutability":"nonpayable","virtual":false,"visibility":"internal"},{"id":58878,"nodeType":"FunctionDefinition","src":"15922:3713:120","nodes":[],"body":{"id":58877,"nodeType":"Block","src":"15986:3649:120","nodes":[],"statements":[{"assignments":[58535],"declarations":[{"constant":false,"id":58535,"mutability":"mutable","name":"systemConfigProxy","nameLocation":"16004:17:120","nodeType":"VariableDeclaration","scope":58877,"src":"15996:25:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":58534,"name":"address","nodeType":"ElementaryTypeName","src":"15996:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"id":58539,"initialValue":{"arguments":[],"expression":{"argumentTypes":[],"expression":{"id":58536,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58531,"src":"16024:3:120","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$58249","typeString":"contract FetchChainInfoOutput"}},"id":58537,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"16028:17:120","memberName":"systemConfigProxy","nodeType":"MemberAccess","referencedDeclaration":57947,"src":"16024:21:120","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":58538,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"16024:23:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"VariableDeclarationStatement","src":"15996:51:120"},{"assignments":[58541],"declarations":[{"constant":false,"id":58541,"mutability":"mutable","name":"optimismPortalProxy","nameLocation":"16065:19:120","nodeType":"VariableDeclaration","scope":58877,"src":"16057:27:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":58540,"name":"address","nodeType":"ElementaryTypeName","src":"16057:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"id":58545,"initialValue":{"arguments":[],"expression":{"argumentTypes":[],"expression":{"id":58542,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58531,"src":"16087:3:120","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$58249","typeString":"contract FetchChainInfoOutput"}},"id":58543,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"16091:19:120","memberName":"optimismPortalProxy","nodeType":"MemberAccess","referencedDeclaration":57929,"src":"16087:23:120","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":58544,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"16087:25:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"VariableDeclarationStatement","src":"16057:55:120"},{"clauses":[{"block":{"id":58564,"nodeType":"Block","src":"16206:75:120","statements":[{"expression":{"arguments":[{"expression":{"expression":{"id":58558,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58531,"src":"16228:3:120","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$58249","typeString":"contract FetchChainInfoOutput"}},"id":58559,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"16232:17:120","memberName":"respectedGameType","nodeType":"MemberAccess","referencedDeclaration":58248,"src":"16228:21:120","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_userDefinedValueType$_GameType_$75355_$","typeString":"function () view external returns (GameType)"}},"id":58560,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"16250:8:120","memberName":"selector","nodeType":"MemberAccess","src":"16228:30:120","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},{"id":58561,"name":"gameType_","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58553,"src":"16260:9:120","typeDescriptions":{"typeIdentifier":"t_userDefinedValueType$_GameType_$75355","typeString":"GameType"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_bytes4","typeString":"bytes4"},{"typeIdentifier":"t_userDefinedValueType$_GameType_$75355","typeString":"GameType"}],"expression":{"id":58555,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58531,"src":"16220:3:120","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$58249","typeString":"contract FetchChainInfoOutput"}},"id":58557,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"16224:3:120","memberName":"set","nodeType":"MemberAccess","referencedDeclaration":57795,"src":"16220:7:120","typeDescriptions":{"typeIdentifier":"t_function_external_nonpayable$_t_bytes4_$_t_userDefinedValueType$_GameType_$75355_$returns$__$","typeString":"function (bytes4,GameType) external"}},"id":58562,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"16220:50:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":58563,"nodeType":"ExpressionStatement","src":"16220:50:120"}]},"errorName":"","id":58565,"nodeType":"TryCatchClause","parameters":{"id":58554,"nodeType":"ParameterList","parameters":[{"constant":false,"id":58553,"mutability":"mutable","name":"gameType_","nameLocation":"16195:9:120","nodeType":"VariableDeclaration","scope":58565,"src":"16186:18:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_userDefinedValueType$_GameType_$75355","typeString":"GameType"},"typeName":{"id":58552,"nodeType":"UserDefinedTypeName","pathNode":{"id":58551,"name":"GameType","nameLocations":["16186:8:120"],"nodeType":"IdentifierPath","referencedDeclaration":75355,"src":"16186:8:120"},"referencedDeclaration":75355,"src":"16186:8:120","typeDescriptions":{"typeIdentifier":"t_userDefinedValueType$_GameType_$75355","typeString":"GameType"}},"visibility":"internal"}],"src":"16185:20:120"},"src":"16177:104:120"},{"block":{"id":58637,"nodeType":"Block","src":"16288:744:120","statements":[{"expression":{"arguments":[{"expression":{"expression":{"id":58569,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58531,"src":"16383:3:120","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$58249","typeString":"contract FetchChainInfoOutput"}},"id":58570,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"16387:17:120","memberName":"respectedGameType","nodeType":"MemberAccess","referencedDeclaration":58248,"src":"16383:21:120","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_userDefinedValueType$_GameType_$75355_$","typeString":"function () view external returns (GameType)"}},"id":58571,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"16405:8:120","memberName":"selector","nodeType":"MemberAccess","src":"16383:30:120","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},{"arguments":[{"expression":{"arguments":[{"id":58576,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"nodeType":"ElementaryTypeNameExpression","src":"16434:6:120","typeDescriptions":{"typeIdentifier":"t_type$_t_uint32_$","typeString":"type(uint32)"},"typeName":{"id":58575,"name":"uint32","nodeType":"ElementaryTypeName","src":"16434:6:120","typeDescriptions":{}}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_type$_t_uint32_$","typeString":"type(uint32)"}],"id":58574,"name":"type","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":-27,"src":"16429:4:120","typeDescriptions":{"typeIdentifier":"t_function_metatype_pure$__$returns$__$","typeString":"function () pure"}},"id":58577,"isConstant":false,"isLValue":false,"isPure":true,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"16429:12:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_magic_meta_type_t_uint32","typeString":"type(uint32)"}},"id":58578,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"memberLocation":"16442:3:120","memberName":"max","nodeType":"MemberAccess","src":"16429:16:120","typeDescriptions":{"typeIdentifier":"t_uint32","typeString":"uint32"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_uint32","typeString":"uint32"}],"expression":{"id":58572,"name":"GameType","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":75355,"src":"16415:8:120","typeDescriptions":{"typeIdentifier":"t_type$_t_userDefinedValueType$_GameType_$75355_$","typeString":"type(GameType)"}},"id":58573,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"memberLocation":"16424:4:120","memberName":"wrap","nodeType":"MemberAccess","src":"16415:13:120","typeDescriptions":{"typeIdentifier":"t_function_wrap_pure$_t_uint32_$returns$_t_userDefinedValueType$_GameType_$75355_$","typeString":"function (uint32) pure returns (GameType)"}},"id":58579,"isConstant":false,"isLValue":false,"isPure":true,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"16415:31:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_userDefinedValueType$_GameType_$75355","typeString":"GameType"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_bytes4","typeString":"bytes4"},{"typeIdentifier":"t_userDefinedValueType$_GameType_$75355","typeString":"GameType"}],"expression":{"id":58566,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58531,"src":"16375:3:120","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$58249","typeString":"contract FetchChainInfoOutput"}},"id":58568,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"16379:3:120","memberName":"set","nodeType":"MemberAccess","referencedDeclaration":57795,"src":"16375:7:120","typeDescriptions":{"typeIdentifier":"t_function_external_nonpayable$_t_bytes4_$_t_userDefinedValueType$_GameType_$75355_$returns$__$","typeString":"function (bytes4,GameType) external"}},"id":58580,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"16375:72:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":58581,"nodeType":"ExpressionStatement","src":"16375:72:120"},{"assignments":[58583],"declarations":[{"constant":false,"id":58583,"mutability":"mutable","name":"l2OutputOracleProxy","nameLocation":"16469:19:120","nodeType":"VariableDeclaration","scope":58637,"src":"16461:27:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":58582,"name":"address","nodeType":"ElementaryTypeName","src":"16461:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"id":58584,"nodeType":"VariableDeclarationStatement","src":"16461:27:120"},{"clauses":[{"block":{"id":58597,"nodeType":"Block","src":"16575:64:120","statements":[{"expression":{"id":58595,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftHandSide":{"id":58593,"name":"l2OutputOracleProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58583,"src":"16593:19:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"Assignment","operator":"=","rightHandSide":{"id":58594,"name":"l2Oracle_","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58591,"src":"16615:9:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"src":"16593:31:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"id":58596,"nodeType":"ExpressionStatement","src":"16593:31:120"}]},"errorName":"","id":58598,"nodeType":"TryCatchClause","parameters":{"id":58592,"nodeType":"ParameterList","parameters":[{"constant":false,"id":58591,"mutability":"mutable","name":"l2Oracle_","nameLocation":"16564:9:120","nodeType":"VariableDeclaration","scope":58598,"src":"16556:17:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":58590,"name":"address","nodeType":"ElementaryTypeName","src":"16556:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"16555:19:120"},"src":"16547:92:120"},{"block":{"id":58607,"nodeType":"Block","src":"16646:96:120","statements":[{"expression":{"id":58605,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftHandSide":{"id":58599,"name":"l2OutputOracleProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58583,"src":"16664:19:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"Assignment","operator":"=","rightHandSide":{"arguments":[],"expression":{"argumentTypes":[],"expression":{"arguments":[{"id":58601,"name":"optimismPortalProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58541,"src":"16695:19:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_address","typeString":"address"}],"id":58600,"name":"IFetcher","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57326,"src":"16686:8:120","typeDescriptions":{"typeIdentifier":"t_type$_t_contract$_IFetcher_$57326_$","typeString":"type(contract IFetcher)"}},"id":58602,"isConstant":false,"isLValue":false,"isPure":false,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"16686:29:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_contract$_IFetcher_$57326","typeString":"contract IFetcher"}},"id":58603,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"16716:9:120","memberName":"L2_ORACLE","nodeType":"MemberAccess","referencedDeclaration":57270,"src":"16686:39:120","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":58604,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"16686:41:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"src":"16664:63:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"id":58606,"nodeType":"ExpressionStatement","src":"16664:63:120"}]},"errorName":"","id":58608,"nodeType":"TryCatchClause","src":"16640:102:120"}],"externalCall":{"arguments":[],"expression":{"argumentTypes":[],"expression":{"arguments":[{"id":58586,"name":"optimismPortalProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58541,"src":"16515:19:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_address","typeString":"address"}],"id":58585,"name":"IFetcher","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57326,"src":"16506:8:120","typeDescriptions":{"typeIdentifier":"t_type$_t_contract$_IFetcher_$57326_$","typeString":"type(contract IFetcher)"}},"id":58587,"isConstant":false,"isLValue":false,"isPure":false,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"16506:29:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_contract$_IFetcher_$57326","typeString":"contract IFetcher"}},"id":58588,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"16536:8:120","memberName":"l2Oracle","nodeType":"MemberAccess","referencedDeclaration":57275,"src":"16506:38:120","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":58589,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"16506:40:120","tryCall":true,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"id":58609,"nodeType":"TryStatement","src":"16502:240:120"},{"expression":{"arguments":[{"expression":{"expression":{"id":58613,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58531,"src":"16763:3:120","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$58249","typeString":"contract FetchChainInfoOutput"}},"id":58614,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"16767:19:120","memberName":"l2OutputOracleProxy","nodeType":"MemberAccess","referencedDeclaration":57893,"src":"16763:23:120","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":58615,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"16787:8:120","memberName":"selector","nodeType":"MemberAccess","src":"16763:32:120","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},{"id":58616,"name":"l2OutputOracleProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58583,"src":"16797:19:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_bytes4","typeString":"bytes4"},{"typeIdentifier":"t_address","typeString":"address"}],"expression":{"id":58610,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58531,"src":"16755:3:120","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$58249","typeString":"contract FetchChainInfoOutput"}},"id":58612,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"16759:3:120","memberName":"set","nodeType":"MemberAccess","referencedDeclaration":57740,"src":"16755:7:120","typeDescriptions":{"typeIdentifier":"t_function_external_nonpayable$_t_bytes4_$_t_address_$returns$__$","typeString":"function (bytes4,address) external"}},"id":58617,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"16755:62:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":58618,"nodeType":"ExpressionStatement","src":"16755:62:120"},{"assignments":[58620],"declarations":[{"constant":false,"id":58620,"mutability":"mutable","name":"proposer","nameLocation":"16840:8:120","nodeType":"VariableDeclaration","scope":58637,"src":"16832:16:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":58619,"name":"address","nodeType":"ElementaryTypeName","src":"16832:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"id":58626,"initialValue":{"arguments":[],"expression":{"argumentTypes":[],"expression":{"arguments":[{"id":58622,"name":"l2OutputOracleProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58583,"src":"16860:19:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_address","typeString":"address"}],"id":58621,"name":"IFetcher","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57326,"src":"16851:8:120","typeDescriptions":{"typeIdentifier":"t_type$_t_contract$_IFetcher_$57326_$","typeString":"type(contract IFetcher)"}},"id":58623,"isConstant":false,"isLValue":false,"isPure":false,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"16851:29:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_contract$_IFetcher_$57326","typeString":"contract IFetcher"}},"id":58624,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"16881:8:120","memberName":"PROPOSER","nodeType":"MemberAccess","referencedDeclaration":57300,"src":"16851:38:120","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":58625,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"16851:40:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"VariableDeclarationStatement","src":"16832:59:120"},{"expression":{"arguments":[{"expression":{"expression":{"id":58630,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58531,"src":"16913:3:120","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$58249","typeString":"contract FetchChainInfoOutput"}},"id":58631,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"16917:8:120","memberName":"proposer","nodeType":"MemberAccess","referencedDeclaration":58187,"src":"16913:12:120","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":58632,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"16926:8:120","memberName":"selector","nodeType":"MemberAccess","src":"16913:21:120","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},{"id":58633,"name":"proposer","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58620,"src":"16936:8:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_bytes4","typeString":"bytes4"},{"typeIdentifier":"t_address","typeString":"address"}],"expression":{"id":58627,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58531,"src":"16905:3:120","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$58249","typeString":"contract FetchChainInfoOutput"}},"id":58629,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"16909:3:120","memberName":"set","nodeType":"MemberAccess","referencedDeclaration":57740,"src":"16905:7:120","typeDescriptions":{"typeIdentifier":"t_function_external_nonpayable$_t_bytes4_$_t_address_$returns$__$","typeString":"function (bytes4,address) external"}},"id":58634,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"16905:40:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":58635,"nodeType":"ExpressionStatement","src":"16905:40:120"},{"functionReturnParameters":58533,"id":58636,"nodeType":"Return","src":"17015:7:120"}]},"errorName":"","id":58638,"nodeType":"TryCatchClause","src":"16282:750:120"}],"externalCall":{"arguments":[],"expression":{"argumentTypes":[],"expression":{"arguments":[{"id":58547,"name":"optimismPortalProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58541,"src":"16136:19:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_address","typeString":"address"}],"id":58546,"name":"IFetcher","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57326,"src":"16127:8:120","typeDescriptions":{"typeIdentifier":"t_type$_t_contract$_IFetcher_$57326_$","typeString":"type(contract IFetcher)"}},"id":58548,"isConstant":false,"isLValue":false,"isPure":false,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"16127:29:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_contract$_IFetcher_$57326","typeString":"contract IFetcher"}},"id":58549,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"16157:17:120","memberName":"respectedGameType","nodeType":"MemberAccess","referencedDeclaration":57260,"src":"16127:47:120","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_userDefinedValueType$_GameType_$75355_$","typeString":"function () view external returns (GameType)"}},"id":58550,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"16127:49:120","tryCall":true,"typeDescriptions":{"typeIdentifier":"t_userDefinedValueType$_GameType_$75355","typeString":"GameType"}},"id":58639,"nodeType":"TryStatement","src":"16123:909:120"},{"assignments":[58641],"declarations":[{"constant":false,"id":58641,"mutability":"mutable","name":"disputeGameFactoryProxy","nameLocation":"17050:23:120","nodeType":"VariableDeclaration","scope":58877,"src":"17042:31:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":58640,"name":"address","nodeType":"ElementaryTypeName","src":"17042:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"id":58645,"initialValue":{"arguments":[{"id":58643,"name":"systemConfigProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58535,"src":"17104:17:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_address","typeString":"address"}],"id":58642,"name":"_getDisputeGameFactoryProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":59087,"src":"17076:27:120","typeDescriptions":{"typeIdentifier":"t_function_internal_view$_t_address_$returns$_t_address_$","typeString":"function (address) view returns (address)"}},"id":58644,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"17076:46:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"VariableDeclarationStatement","src":"17042:80:120"},{"condition":{"commonType":{"typeIdentifier":"t_address","typeString":"address"},"id":58651,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftExpression":{"id":58646,"name":"disputeGameFactoryProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58641,"src":"17136:23:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"BinaryOperation","operator":"!=","rightExpression":{"arguments":[{"hexValue":"30","id":58649,"isConstant":false,"isLValue":false,"isPure":true,"kind":"number","lValueRequested":false,"nodeType":"Literal","src":"17171:1:120","typeDescriptions":{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"},"value":"0"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"}],"id":58648,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"nodeType":"ElementaryTypeNameExpression","src":"17163:7:120","typeDescriptions":{"typeIdentifier":"t_type$_t_address_$","typeString":"type(address)"},"typeName":{"id":58647,"name":"address","nodeType":"ElementaryTypeName","src":"17163:7:120","typeDescriptions":{}}},"id":58650,"isConstant":false,"isLValue":false,"isPure":true,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"17163:10:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"src":"17136:37:120","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},"falseBody":{"id":58875,"nodeType":"Block","src":"19246:383:120","statements":[{"assignments":[58842],"declarations":[{"constant":false,"id":58842,"mutability":"mutable","name":"l2OutputOracleProxy","nameLocation":"19352:19:120","nodeType":"VariableDeclaration","scope":58875,"src":"19344:27:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":58841,"name":"address","nodeType":"ElementaryTypeName","src":"19344:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"id":58848,"initialValue":{"arguments":[],"expression":{"argumentTypes":[],"expression":{"arguments":[{"id":58844,"name":"optimismPortalProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58541,"src":"19383:19:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_address","typeString":"address"}],"id":58843,"name":"IFetcher","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57326,"src":"19374:8:120","typeDescriptions":{"typeIdentifier":"t_type$_t_contract$_IFetcher_$57326_$","typeString":"type(contract IFetcher)"}},"id":58845,"isConstant":false,"isLValue":false,"isPure":false,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"19374:29:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_contract$_IFetcher_$57326","typeString":"contract IFetcher"}},"id":58846,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"19404:9:120","memberName":"L2_ORACLE","nodeType":"MemberAccess","referencedDeclaration":57270,"src":"19374:39:120","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":58847,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"19374:41:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"VariableDeclarationStatement","src":"19344:71:120"},{"expression":{"arguments":[{"expression":{"expression":{"id":58852,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58531,"src":"19437:3:120","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$58249","typeString":"contract FetchChainInfoOutput"}},"id":58853,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"19441:19:120","memberName":"l2OutputOracleProxy","nodeType":"MemberAccess","referencedDeclaration":57893,"src":"19437:23:120","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":58854,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"19461:8:120","memberName":"selector","nodeType":"MemberAccess","src":"19437:32:120","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},{"id":58855,"name":"l2OutputOracleProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58842,"src":"19471:19:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_bytes4","typeString":"bytes4"},{"typeIdentifier":"t_address","typeString":"address"}],"expression":{"id":58849,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58531,"src":"19429:3:120","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$58249","typeString":"contract FetchChainInfoOutput"}},"id":58851,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"19433:3:120","memberName":"set","nodeType":"MemberAccess","referencedDeclaration":57740,"src":"19429:7:120","typeDescriptions":{"typeIdentifier":"t_function_external_nonpayable$_t_bytes4_$_t_address_$returns$__$","typeString":"function (bytes4,address) external"}},"id":58856,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"19429:62:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":58857,"nodeType":"ExpressionStatement","src":"19429:62:120"},{"assignments":[58859],"declarations":[{"constant":false,"id":58859,"mutability":"mutable","name":"proposer","nameLocation":"19513:8:120","nodeType":"VariableDeclaration","scope":58875,"src":"19505:16:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":58858,"name":"address","nodeType":"ElementaryTypeName","src":"19505:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"id":58865,"initialValue":{"arguments":[],"expression":{"argumentTypes":[],"expression":{"arguments":[{"id":58861,"name":"l2OutputOracleProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58842,"src":"19533:19:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_address","typeString":"address"}],"id":58860,"name":"IFetcher","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57326,"src":"19524:8:120","typeDescriptions":{"typeIdentifier":"t_type$_t_contract$_IFetcher_$57326_$","typeString":"type(contract IFetcher)"}},"id":58862,"isConstant":false,"isLValue":false,"isPure":false,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"19524:29:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_contract$_IFetcher_$57326","typeString":"contract IFetcher"}},"id":58863,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"19554:8:120","memberName":"PROPOSER","nodeType":"MemberAccess","referencedDeclaration":57300,"src":"19524:38:120","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":58864,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"19524:40:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"VariableDeclarationStatement","src":"19505:59:120"},{"expression":{"arguments":[{"expression":{"expression":{"id":58869,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58531,"src":"19586:3:120","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$58249","typeString":"contract FetchChainInfoOutput"}},"id":58870,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"19590:8:120","memberName":"proposer","nodeType":"MemberAccess","referencedDeclaration":58187,"src":"19586:12:120","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":58871,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"19599:8:120","memberName":"selector","nodeType":"MemberAccess","src":"19586:21:120","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},{"id":58872,"name":"proposer","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58859,"src":"19609:8:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_bytes4","typeString":"bytes4"},{"typeIdentifier":"t_address","typeString":"address"}],"expression":{"id":58866,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58531,"src":"19578:3:120","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$58249","typeString":"contract FetchChainInfoOutput"}},"id":58868,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"19582:3:120","memberName":"set","nodeType":"MemberAccess","referencedDeclaration":57740,"src":"19578:7:120","typeDescriptions":{"typeIdentifier":"t_function_external_nonpayable$_t_bytes4_$_t_address_$returns$__$","typeString":"function (bytes4,address) external"}},"id":58873,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"19578:40:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":58874,"nodeType":"ExpressionStatement","src":"19578:40:120"}]},"id":58876,"nodeType":"IfStatement","src":"17132:2497:120","trueBody":{"id":58840,"nodeType":"Block","src":"17175:2065:120","statements":[{"expression":{"arguments":[{"expression":{"expression":{"id":58655,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58531,"src":"17197:3:120","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$58249","typeString":"contract FetchChainInfoOutput"}},"id":58656,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"17201:23:120","memberName":"disputeGameFactoryProxy","nodeType":"MemberAccess","referencedDeclaration":58025,"src":"17197:27:120","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":58657,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"17225:8:120","memberName":"selector","nodeType":"MemberAccess","src":"17197:36:120","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},{"id":58658,"name":"disputeGameFactoryProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58641,"src":"17235:23:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_bytes4","typeString":"bytes4"},{"typeIdentifier":"t_address","typeString":"address"}],"expression":{"id":58652,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58531,"src":"17189:3:120","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$58249","typeString":"contract FetchChainInfoOutput"}},"id":58654,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"17193:3:120","memberName":"set","nodeType":"MemberAccess","referencedDeclaration":57740,"src":"17189:7:120","typeDescriptions":{"typeIdentifier":"t_function_external_nonpayable$_t_bytes4_$_t_address_$returns$__$","typeString":"function (bytes4,address) external"}},"id":58659,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"17189:70:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":58660,"nodeType":"ExpressionStatement","src":"17189:70:120"},{"assignments":[58662],"declarations":[{"constant":false,"id":58662,"mutability":"mutable","name":"permissionedDisputeGameImpl","nameLocation":"17282:27:120","nodeType":"VariableDeclaration","scope":58840,"src":"17274:35:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":58661,"name":"address","nodeType":"ElementaryTypeName","src":"17274:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"id":58666,"initialValue":{"arguments":[{"id":58664,"name":"disputeGameFactoryProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58641,"src":"17340:23:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_address","typeString":"address"}],"id":58663,"name":"_getPermissionedDisputeGame","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":59175,"src":"17312:27:120","typeDescriptions":{"typeIdentifier":"t_function_internal_view$_t_address_$returns$_t_address_$","typeString":"function (address) view returns (address)"}},"id":58665,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"17312:52:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"VariableDeclarationStatement","src":"17274:90:120"},{"condition":{"commonType":{"typeIdentifier":"t_address","typeString":"address"},"id":58672,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftExpression":{"id":58667,"name":"permissionedDisputeGameImpl","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58662,"src":"17382:27:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"BinaryOperation","operator":"!=","rightExpression":{"arguments":[{"hexValue":"30","id":58670,"isConstant":false,"isLValue":false,"isPure":true,"kind":"number","lValueRequested":false,"nodeType":"Literal","src":"17421:1:120","typeDescriptions":{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"},"value":"0"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"}],"id":58669,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"nodeType":"ElementaryTypeNameExpression","src":"17413:7:120","typeDescriptions":{"typeIdentifier":"t_type$_t_address_$","typeString":"type(address)"},"typeName":{"id":58668,"name":"address","nodeType":"ElementaryTypeName","src":"17413:7:120","typeDescriptions":{}}},"id":58671,"isConstant":false,"isLValue":false,"isPure":true,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"17413:10:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"src":"17382:41:120","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},"id":58792,"nodeType":"IfStatement","src":"17378:1278:120","trueBody":{"id":58791,"nodeType":"Block","src":"17425:1231:120","statements":[{"expression":{"arguments":[{"expression":{"expression":{"id":58676,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58531,"src":"17506:3:120","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$58249","typeString":"contract FetchChainInfoOutput"}},"id":58677,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"17510:12:120","memberName":"permissioned","nodeType":"MemberAccess","referencedDeclaration":58231,"src":"17506:16:120","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_bool_$","typeString":"function () view external returns (bool)"}},"id":58678,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"17523:8:120","memberName":"selector","nodeType":"MemberAccess","src":"17506:25:120","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},{"hexValue":"74727565","id":58679,"isConstant":false,"isLValue":false,"isPure":true,"kind":"bool","lValueRequested":false,"nodeType":"Literal","src":"17533:4:120","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"},"value":"true"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_bytes4","typeString":"bytes4"},{"typeIdentifier":"t_bool","typeString":"bool"}],"expression":{"id":58673,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58531,"src":"17498:3:120","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$58249","typeString":"contract FetchChainInfoOutput"}},"id":58675,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"17502:3:120","memberName":"set","nodeType":"MemberAccess","referencedDeclaration":57772,"src":"17498:7:120","typeDescriptions":{"typeIdentifier":"t_function_external_nonpayable$_t_bytes4_$_t_bool_$returns$__$","typeString":"function (bytes4,bool) external"}},"id":58680,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"17498:40:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":58681,"nodeType":"ExpressionStatement","src":"17498:40:120"},{"expression":{"arguments":[{"expression":{"expression":{"id":58685,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58531,"src":"17564:3:120","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$58249","typeString":"contract FetchChainInfoOutput"}},"id":58686,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"17568:27:120","memberName":"permissionedDisputeGameImpl","nodeType":"MemberAccess","referencedDeclaration":58079,"src":"17564:31:120","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":58687,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"17596:8:120","memberName":"selector","nodeType":"MemberAccess","src":"17564:40:120","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},{"id":58688,"name":"permissionedDisputeGameImpl","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58662,"src":"17606:27:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_bytes4","typeString":"bytes4"},{"typeIdentifier":"t_address","typeString":"address"}],"expression":{"id":58682,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58531,"src":"17556:3:120","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$58249","typeString":"contract FetchChainInfoOutput"}},"id":58684,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"17560:3:120","memberName":"set","nodeType":"MemberAccess","referencedDeclaration":57740,"src":"17556:7:120","typeDescriptions":{"typeIdentifier":"t_function_external_nonpayable$_t_bytes4_$_t_address_$returns$__$","typeString":"function (bytes4,address) external"}},"id":58689,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"17556:78:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":58690,"nodeType":"ExpressionStatement","src":"17556:78:120"},{"assignments":[58692],"declarations":[{"constant":false,"id":58692,"mutability":"mutable","name":"challenger","nameLocation":"17661:10:120","nodeType":"VariableDeclaration","scope":58791,"src":"17653:18:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":58691,"name":"address","nodeType":"ElementaryTypeName","src":"17653:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"id":58698,"initialValue":{"arguments":[],"expression":{"argumentTypes":[],"expression":{"arguments":[{"id":58694,"name":"permissionedDisputeGameImpl","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58662,"src":"17683:27:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_address","typeString":"address"}],"id":58693,"name":"IFetcher","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57326,"src":"17674:8:120","typeDescriptions":{"typeIdentifier":"t_type$_t_contract$_IFetcher_$57326_$","typeString":"type(contract IFetcher)"}},"id":58695,"isConstant":false,"isLValue":false,"isPure":false,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"17674:37:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_contract$_IFetcher_$57326","typeString":"contract IFetcher"}},"id":58696,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"17712:10:120","memberName":"challenger","nodeType":"MemberAccess","referencedDeclaration":57290,"src":"17674:48:120","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":58697,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"17674:50:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"VariableDeclarationStatement","src":"17653:71:120"},{"expression":{"arguments":[{"expression":{"expression":{"id":58702,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58531,"src":"17750:3:120","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$58249","typeString":"contract FetchChainInfoOutput"}},"id":58703,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"17754:10:120","memberName":"challenger","nodeType":"MemberAccess","referencedDeclaration":58169,"src":"17750:14:120","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":58704,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"17765:8:120","memberName":"selector","nodeType":"MemberAccess","src":"17750:23:120","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},{"id":58705,"name":"challenger","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58692,"src":"17775:10:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_bytes4","typeString":"bytes4"},{"typeIdentifier":"t_address","typeString":"address"}],"expression":{"id":58699,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58531,"src":"17742:3:120","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$58249","typeString":"contract FetchChainInfoOutput"}},"id":58701,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"17746:3:120","memberName":"set","nodeType":"MemberAccess","referencedDeclaration":57740,"src":"17742:7:120","typeDescriptions":{"typeIdentifier":"t_function_external_nonpayable$_t_bytes4_$_t_address_$returns$__$","typeString":"function (bytes4,address) external"}},"id":58706,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"17742:44:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":58707,"nodeType":"ExpressionStatement","src":"17742:44:120"},{"assignments":[58709],"declarations":[{"constant":false,"id":58709,"mutability":"mutable","name":"anchorStateRegistryProxy","nameLocation":"17813:24:120","nodeType":"VariableDeclaration","scope":58791,"src":"17805:32:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":58708,"name":"address","nodeType":"ElementaryTypeName","src":"17805:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"id":58715,"initialValue":{"arguments":[],"expression":{"argumentTypes":[],"expression":{"arguments":[{"id":58711,"name":"permissionedDisputeGameImpl","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58662,"src":"17849:27:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_address","typeString":"address"}],"id":58710,"name":"IFetcher","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57326,"src":"17840:8:120","typeDescriptions":{"typeIdentifier":"t_type$_t_contract$_IFetcher_$57326_$","typeString":"type(contract IFetcher)"}},"id":58712,"isConstant":false,"isLValue":false,"isPure":false,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"17840:37:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_contract$_IFetcher_$57326","typeString":"contract IFetcher"}},"id":58713,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"17878:19:120","memberName":"anchorStateRegistry","nodeType":"MemberAccess","referencedDeclaration":57265,"src":"17840:57:120","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":58714,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"17840:59:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"VariableDeclarationStatement","src":"17805:94:120"},{"expression":{"arguments":[{"expression":{"expression":{"id":58719,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58531,"src":"17925:3:120","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$58249","typeString":"contract FetchChainInfoOutput"}},"id":58720,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"17929:24:120","memberName":"anchorStateRegistryProxy","nodeType":"MemberAccess","referencedDeclaration":58001,"src":"17925:28:120","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":58721,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"17954:8:120","memberName":"selector","nodeType":"MemberAccess","src":"17925:37:120","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},{"id":58722,"name":"anchorStateRegistryProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58709,"src":"17964:24:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_bytes4","typeString":"bytes4"},{"typeIdentifier":"t_address","typeString":"address"}],"expression":{"id":58716,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58531,"src":"17917:3:120","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$58249","typeString":"contract FetchChainInfoOutput"}},"id":58718,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"17921:3:120","memberName":"set","nodeType":"MemberAccess","referencedDeclaration":57740,"src":"17917:7:120","typeDescriptions":{"typeIdentifier":"t_function_external_nonpayable$_t_bytes4_$_t_address_$returns$__$","typeString":"function (bytes4,address) external"}},"id":58723,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"17917:72:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":58724,"nodeType":"ExpressionStatement","src":"17917:72:120"},{"assignments":[58726],"declarations":[{"constant":false,"id":58726,"mutability":"mutable","name":"proposer","nameLocation":"18016:8:120","nodeType":"VariableDeclaration","scope":58791,"src":"18008:16:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":58725,"name":"address","nodeType":"ElementaryTypeName","src":"18008:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"id":58732,"initialValue":{"arguments":[],"expression":{"argumentTypes":[],"expression":{"arguments":[{"id":58728,"name":"permissionedDisputeGameImpl","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58662,"src":"18036:27:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_address","typeString":"address"}],"id":58727,"name":"IFetcher","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57326,"src":"18027:8:120","typeDescriptions":{"typeIdentifier":"t_type$_t_contract$_IFetcher_$57326_$","typeString":"type(contract IFetcher)"}},"id":58729,"isConstant":false,"isLValue":false,"isPure":false,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"18027:37:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_contract$_IFetcher_$57326","typeString":"contract IFetcher"}},"id":58730,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"18065:8:120","memberName":"proposer","nodeType":"MemberAccess","referencedDeclaration":57295,"src":"18027:46:120","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":58731,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"18027:48:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"VariableDeclarationStatement","src":"18008:67:120"},{"expression":{"arguments":[{"expression":{"expression":{"id":58736,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58531,"src":"18101:3:120","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$58249","typeString":"contract FetchChainInfoOutput"}},"id":58737,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"18105:8:120","memberName":"proposer","nodeType":"MemberAccess","referencedDeclaration":58187,"src":"18101:12:120","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":58738,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"18114:8:120","memberName":"selector","nodeType":"MemberAccess","src":"18101:21:120","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},{"id":58739,"name":"proposer","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58726,"src":"18124:8:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_bytes4","typeString":"bytes4"},{"typeIdentifier":"t_address","typeString":"address"}],"expression":{"id":58733,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58531,"src":"18093:3:120","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$58249","typeString":"contract FetchChainInfoOutput"}},"id":58735,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"18097:3:120","memberName":"set","nodeType":"MemberAccess","referencedDeclaration":57740,"src":"18093:7:120","typeDescriptions":{"typeIdentifier":"t_function_external_nonpayable$_t_bytes4_$_t_address_$returns$__$","typeString":"function (bytes4,address) external"}},"id":58740,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"18093:40:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":58741,"nodeType":"ExpressionStatement","src":"18093:40:120"},{"assignments":[58743],"declarations":[{"constant":false,"id":58743,"mutability":"mutable","name":"delayedWethPermissionedGameProxy","nameLocation":"18160:32:120","nodeType":"VariableDeclaration","scope":58791,"src":"18152:40:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":58742,"name":"address","nodeType":"ElementaryTypeName","src":"18152:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"id":58747,"initialValue":{"arguments":[{"id":58745,"name":"permissionedDisputeGameImpl","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58662,"src":"18216:27:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_address","typeString":"address"}],"id":58744,"name":"_getDelayedWETHProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":59248,"src":"18195:20:120","typeDescriptions":{"typeIdentifier":"t_function_internal_view$_t_address_$returns$_t_address_$","typeString":"function (address) view returns (address)"}},"id":58746,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"18195:49:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"VariableDeclarationStatement","src":"18152:92:120"},{"expression":{"arguments":[{"expression":{"expression":{"id":58751,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58531,"src":"18270:3:120","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$58249","typeString":"contract FetchChainInfoOutput"}},"id":58752,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"18274:32:120","memberName":"delayedWethPermissionedGameProxy","nodeType":"MemberAccess","referencedDeclaration":58009,"src":"18270:36:120","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":58753,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"18307:8:120","memberName":"selector","nodeType":"MemberAccess","src":"18270:45:120","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},{"id":58754,"name":"delayedWethPermissionedGameProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58743,"src":"18317:32:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_bytes4","typeString":"bytes4"},{"typeIdentifier":"t_address","typeString":"address"}],"expression":{"id":58748,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58531,"src":"18262:3:120","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$58249","typeString":"contract FetchChainInfoOutput"}},"id":58750,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"18266:3:120","memberName":"set","nodeType":"MemberAccess","referencedDeclaration":57740,"src":"18262:7:120","typeDescriptions":{"typeIdentifier":"t_function_external_nonpayable$_t_bytes4_$_t_address_$returns$__$","typeString":"function (bytes4,address) external"}},"id":58755,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"18262:88:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":58756,"nodeType":"ExpressionStatement","src":"18262:88:120"},{"assignments":[58758],"declarations":[{"constant":false,"id":58758,"mutability":"mutable","name":"mipsImpl","nameLocation":"18377:8:120","nodeType":"VariableDeclaration","scope":58791,"src":"18369:16:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":58757,"name":"address","nodeType":"ElementaryTypeName","src":"18369:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"id":58764,"initialValue":{"arguments":[],"expression":{"argumentTypes":[],"expression":{"arguments":[{"id":58760,"name":"permissionedDisputeGameImpl","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58662,"src":"18397:27:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_address","typeString":"address"}],"id":58759,"name":"IFetcher","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57326,"src":"18388:8:120","typeDescriptions":{"typeIdentifier":"t_type$_t_contract$_IFetcher_$57326_$","typeString":"type(contract IFetcher)"}},"id":58761,"isConstant":false,"isLValue":false,"isPure":false,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"18388:37:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_contract$_IFetcher_$57326","typeString":"contract IFetcher"}},"id":58762,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"18426:2:120","memberName":"vm","nodeType":"MemberAccess","referencedDeclaration":57280,"src":"18388:40:120","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":58763,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"18388:42:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"VariableDeclarationStatement","src":"18369:61:120"},{"expression":{"arguments":[{"expression":{"expression":{"id":58768,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58531,"src":"18456:3:120","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$58249","typeString":"contract FetchChainInfoOutput"}},"id":58769,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"18460:8:120","memberName":"mipsImpl","nodeType":"MemberAccess","referencedDeclaration":58061,"src":"18456:12:120","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":58770,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"18469:8:120","memberName":"selector","nodeType":"MemberAccess","src":"18456:21:120","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},{"id":58771,"name":"mipsImpl","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58758,"src":"18479:8:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_bytes4","typeString":"bytes4"},{"typeIdentifier":"t_address","typeString":"address"}],"expression":{"id":58765,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58531,"src":"18448:3:120","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$58249","typeString":"contract FetchChainInfoOutput"}},"id":58767,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"18452:3:120","memberName":"set","nodeType":"MemberAccess","referencedDeclaration":57740,"src":"18448:7:120","typeDescriptions":{"typeIdentifier":"t_function_external_nonpayable$_t_bytes4_$_t_address_$returns$__$","typeString":"function (bytes4,address) external"}},"id":58772,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"18448:40:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":58773,"nodeType":"ExpressionStatement","src":"18448:40:120"},{"assignments":[58775],"declarations":[{"constant":false,"id":58775,"mutability":"mutable","name":"preimageOracleImpl","nameLocation":"18515:18:120","nodeType":"VariableDeclaration","scope":58791,"src":"18507:26:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":58774,"name":"address","nodeType":"ElementaryTypeName","src":"18507:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"id":58781,"initialValue":{"arguments":[],"expression":{"argumentTypes":[],"expression":{"arguments":[{"id":58777,"name":"mipsImpl","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58758,"src":"18545:8:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_address","typeString":"address"}],"id":58776,"name":"IFetcher","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57326,"src":"18536:8:120","typeDescriptions":{"typeIdentifier":"t_type$_t_contract$_IFetcher_$57326_$","typeString":"type(contract IFetcher)"}},"id":58778,"isConstant":false,"isLValue":false,"isPure":false,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"18536:18:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_contract$_IFetcher_$57326","typeString":"contract IFetcher"}},"id":58779,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"18555:6:120","memberName":"oracle","nodeType":"MemberAccess","referencedDeclaration":57285,"src":"18536:25:120","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":58780,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"18536:27:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"VariableDeclarationStatement","src":"18507:56:120"},{"expression":{"arguments":[{"expression":{"expression":{"id":58785,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58531,"src":"18589:3:120","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$58249","typeString":"contract FetchChainInfoOutput"}},"id":58786,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"18593:18:120","memberName":"preimageOracleImpl","nodeType":"MemberAccess","referencedDeclaration":58097,"src":"18589:22:120","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":58787,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"18612:8:120","memberName":"selector","nodeType":"MemberAccess","src":"18589:31:120","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},{"id":58788,"name":"preimageOracleImpl","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58775,"src":"18622:18:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_bytes4","typeString":"bytes4"},{"typeIdentifier":"t_address","typeString":"address"}],"expression":{"id":58782,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58531,"src":"18581:3:120","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$58249","typeString":"contract FetchChainInfoOutput"}},"id":58784,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"18585:3:120","memberName":"set","nodeType":"MemberAccess","referencedDeclaration":57740,"src":"18581:7:120","typeDescriptions":{"typeIdentifier":"t_function_external_nonpayable$_t_bytes4_$_t_address_$returns$__$","typeString":"function (bytes4,address) external"}},"id":58789,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"18581:60:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":58790,"nodeType":"ExpressionStatement","src":"18581:60:120"}]}},{"assignments":[58794],"declarations":[{"constant":false,"id":58794,"mutability":"mutable","name":"faultDisputeGameImpl","nameLocation":"18678:20:120","nodeType":"VariableDeclaration","scope":58840,"src":"18670:28:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":58793,"name":"address","nodeType":"ElementaryTypeName","src":"18670:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"id":58798,"initialValue":{"arguments":[{"id":58796,"name":"disputeGameFactoryProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58641,"src":"18722:23:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_address","typeString":"address"}],"id":58795,"name":"_getFaultDisputeGame","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":59145,"src":"18701:20:120","typeDescriptions":{"typeIdentifier":"t_function_internal_view$_t_address_$returns$_t_address_$","typeString":"function (address) view returns (address)"}},"id":58797,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"18701:45:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"VariableDeclarationStatement","src":"18670:76:120"},{"condition":{"commonType":{"typeIdentifier":"t_address","typeString":"address"},"id":58804,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftExpression":{"id":58799,"name":"faultDisputeGameImpl","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58794,"src":"18764:20:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"BinaryOperation","operator":"!=","rightExpression":{"arguments":[{"hexValue":"30","id":58802,"isConstant":false,"isLValue":false,"isPure":true,"kind":"number","lValueRequested":false,"nodeType":"Literal","src":"18796:1:120","typeDescriptions":{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"},"value":"0"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"}],"id":58801,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"nodeType":"ElementaryTypeNameExpression","src":"18788:7:120","typeDescriptions":{"typeIdentifier":"t_type$_t_address_$","typeString":"type(address)"},"typeName":{"id":58800,"name":"address","nodeType":"ElementaryTypeName","src":"18788:7:120","typeDescriptions":{}}},"id":58803,"isConstant":false,"isLValue":false,"isPure":true,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"18788:10:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"src":"18764:34:120","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},"id":58839,"nodeType":"IfStatement","src":"18760:470:120","trueBody":{"id":58838,"nodeType":"Block","src":"18800:430:120","statements":[{"expression":{"arguments":[{"expression":{"expression":{"id":58808,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58531,"src":"18883:3:120","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$58249","typeString":"contract FetchChainInfoOutput"}},"id":58809,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"18887:20:120","memberName":"faultDisputeGameImpl","nodeType":"MemberAccess","referencedDeclaration":58043,"src":"18883:24:120","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":58810,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"18908:8:120","memberName":"selector","nodeType":"MemberAccess","src":"18883:33:120","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},{"id":58811,"name":"faultDisputeGameImpl","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58794,"src":"18918:20:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_bytes4","typeString":"bytes4"},{"typeIdentifier":"t_address","typeString":"address"}],"expression":{"id":58805,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58531,"src":"18875:3:120","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$58249","typeString":"contract FetchChainInfoOutput"}},"id":58807,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"18879:3:120","memberName":"set","nodeType":"MemberAccess","referencedDeclaration":57740,"src":"18875:7:120","typeDescriptions":{"typeIdentifier":"t_function_external_nonpayable$_t_bytes4_$_t_address_$returns$__$","typeString":"function (bytes4,address) external"}},"id":58812,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"18875:64:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":58813,"nodeType":"ExpressionStatement","src":"18875:64:120"},{"expression":{"arguments":[{"expression":{"expression":{"id":58817,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58531,"src":"18965:3:120","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$58249","typeString":"contract FetchChainInfoOutput"}},"id":58818,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"18969:14:120","memberName":"permissionless","nodeType":"MemberAccess","referencedDeclaration":58239,"src":"18965:18:120","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_bool_$","typeString":"function () view external returns (bool)"}},"id":58819,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"18984:8:120","memberName":"selector","nodeType":"MemberAccess","src":"18965:27:120","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},{"hexValue":"74727565","id":58820,"isConstant":false,"isLValue":false,"isPure":true,"kind":"bool","lValueRequested":false,"nodeType":"Literal","src":"18994:4:120","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"},"value":"true"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_bytes4","typeString":"bytes4"},{"typeIdentifier":"t_bool","typeString":"bool"}],"expression":{"id":58814,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58531,"src":"18957:3:120","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$58249","typeString":"contract FetchChainInfoOutput"}},"id":58816,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"18961:3:120","memberName":"set","nodeType":"MemberAccess","referencedDeclaration":57772,"src":"18957:7:120","typeDescriptions":{"typeIdentifier":"t_function_external_nonpayable$_t_bytes4_$_t_bool_$returns$__$","typeString":"function (bytes4,bool) external"}},"id":58821,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"18957:42:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":58822,"nodeType":"ExpressionStatement","src":"18957:42:120"},{"assignments":[58824],"declarations":[{"constant":false,"id":58824,"mutability":"mutable","name":"delayedWethPermissionlessGameProxy","nameLocation":"19026:34:120","nodeType":"VariableDeclaration","scope":58838,"src":"19018:42:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":58823,"name":"address","nodeType":"ElementaryTypeName","src":"19018:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"id":58828,"initialValue":{"arguments":[{"id":58826,"name":"faultDisputeGameImpl","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58794,"src":"19084:20:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_address","typeString":"address"}],"id":58825,"name":"_getDelayedWETHProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":59248,"src":"19063:20:120","typeDescriptions":{"typeIdentifier":"t_function_internal_view$_t_address_$returns$_t_address_$","typeString":"function (address) view returns (address)"}},"id":58827,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"19063:42:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"VariableDeclarationStatement","src":"19018:87:120"},{"expression":{"arguments":[{"expression":{"expression":{"id":58832,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58531,"src":"19131:3:120","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$58249","typeString":"contract FetchChainInfoOutput"}},"id":58833,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"19135:34:120","memberName":"delayedWethPermissionlessGameProxy","nodeType":"MemberAccess","referencedDeclaration":58017,"src":"19131:38:120","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":58834,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"19170:8:120","memberName":"selector","nodeType":"MemberAccess","src":"19131:47:120","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},{"id":58835,"name":"delayedWethPermissionlessGameProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58824,"src":"19180:34:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_bytes4","typeString":"bytes4"},{"typeIdentifier":"t_address","typeString":"address"}],"expression":{"id":58829,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58531,"src":"19123:3:120","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$58249","typeString":"contract FetchChainInfoOutput"}},"id":58831,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"19127:3:120","memberName":"set","nodeType":"MemberAccess","referencedDeclaration":57740,"src":"19123:7:120","typeDescriptions":{"typeIdentifier":"t_function_external_nonpayable$_t_bytes4_$_t_address_$returns$__$","typeString":"function (bytes4,address) external"}},"id":58836,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"19123:92:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":58837,"nodeType":"ExpressionStatement","src":"19123:92:120"}]}}]}}]},"implemented":true,"kind":"function","modifiers":[],"name":"_processFaultProofs","nameLocation":"15931:19:120","parameters":{"id":58532,"nodeType":"ParameterList","parameters":[{"constant":false,"id":58531,"mutability":"mutable","name":"_fo","nameLocation":"15972:3:120","nodeType":"VariableDeclaration","scope":58878,"src":"15951:24:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$58249","typeString":"contract FetchChainInfoOutput"},"typeName":{"id":58530,"nodeType":"UserDefinedTypeName","pathNode":{"id":58529,"name":"FetchChainInfoOutput","nameLocations":["15951:20:120"],"nodeType":"IdentifierPath","referencedDeclaration":58249,"src":"15951:20:120"},"referencedDeclaration":58249,"src":"15951:20:120","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$58249","typeString":"contract FetchChainInfoOutput"}},"visibility":"internal"}],"src":"15950:26:120"},"returnParameters":{"id":58533,"nodeType":"ParameterList","parameters":[],"src":"15986:0:120"},"scope":59299,"stateMutability":"nonpayable","virtual":false,"visibility":"internal"},{"id":58907,"nodeType":"FunctionDefinition","src":"19641:256:120","nodes":[],"body":{"id":58906,"nodeType":"Block","src":"19712:185:120","nodes":[],"statements":[{"clauses":[{"block":{"id":58895,"nodeType":"Block","src":"19783:41:120","statements":[{"expression":{"id":58893,"name":"guardian_","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58891,"src":"19804:9:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"functionReturnParameters":58884,"id":58894,"nodeType":"Return","src":"19797:16:120"}]},"errorName":"","id":58896,"nodeType":"TryCatchClause","parameters":{"id":58892,"nodeType":"ParameterList","parameters":[{"constant":false,"id":58891,"mutability":"mutable","name":"guardian_","nameLocation":"19772:9:120","nodeType":"VariableDeclaration","scope":58896,"src":"19764:17:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":58890,"name":"address","nodeType":"ElementaryTypeName","src":"19764:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"19763:19:120"},"src":"19755:69:120"},{"block":{"id":58903,"nodeType":"Block","src":"19831:60:120","statements":[{"expression":{"arguments":[],"expression":{"argumentTypes":[],"expression":{"arguments":[{"id":58898,"name":"_portal","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58880,"src":"19861:7:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_address","typeString":"address"}],"id":58897,"name":"IFetcher","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57326,"src":"19852:8:120","typeDescriptions":{"typeIdentifier":"t_type$_t_contract$_IFetcher_$57326_$","typeString":"type(contract IFetcher)"}},"id":58899,"isConstant":false,"isLValue":false,"isPure":false,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"19852:17:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_contract$_IFetcher_$57326","typeString":"contract IFetcher"}},"id":58900,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"19870:8:120","memberName":"GUARDIAN","nodeType":"MemberAccess","referencedDeclaration":57191,"src":"19852:26:120","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":58901,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"19852:28:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"functionReturnParameters":58884,"id":58902,"nodeType":"Return","src":"19845:35:120"}]},"errorName":"","id":58904,"nodeType":"TryCatchClause","src":"19825:66:120"}],"externalCall":{"arguments":[],"expression":{"argumentTypes":[],"expression":{"arguments":[{"id":58886,"name":"_portal","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58880,"src":"19735:7:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_address","typeString":"address"}],"id":58885,"name":"IFetcher","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57326,"src":"19726:8:120","typeDescriptions":{"typeIdentifier":"t_type$_t_contract$_IFetcher_$57326_$","typeString":"type(contract IFetcher)"}},"id":58887,"isConstant":false,"isLValue":false,"isPure":false,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"19726:17:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_contract$_IFetcher_$57326","typeString":"contract IFetcher"}},"id":58888,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"19744:8:120","memberName":"guardian","nodeType":"MemberAccess","referencedDeclaration":57186,"src":"19726:26:120","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":58889,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"19726:28:120","tryCall":true,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"id":58905,"nodeType":"TryStatement","src":"19722:169:120"}]},"implemented":true,"kind":"function","modifiers":[],"name":"_getGuardian","nameLocation":"19650:12:120","parameters":{"id":58881,"nodeType":"ParameterList","parameters":[{"constant":false,"id":58880,"mutability":"mutable","name":"_portal","nameLocation":"19671:7:120","nodeType":"VariableDeclaration","scope":58907,"src":"19663:15:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":58879,"name":"address","nodeType":"ElementaryTypeName","src":"19663:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"19662:17:120"},"returnParameters":{"id":58884,"nodeType":"ParameterList","parameters":[{"constant":false,"id":58883,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":58907,"src":"19703:7:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":58882,"name":"address","nodeType":"ElementaryTypeName","src":"19703:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"19702:9:120"},"scope":59299,"stateMutability":"view","virtual":false,"visibility":"internal"},{"id":58936,"nodeType":"FunctionDefinition","src":"19903:282:120","nodes":[],"body":{"id":58935,"nodeType":"Block","src":"19983:202:120","nodes":[],"statements":[{"clauses":[{"block":{"id":58924,"nodeType":"Block","src":"20062:45:120","statements":[{"expression":{"id":58922,"name":"systemConfig_","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58920,"src":"20083:13:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"functionReturnParameters":58913,"id":58923,"nodeType":"Return","src":"20076:20:120"}]},"errorName":"","id":58925,"nodeType":"TryCatchClause","parameters":{"id":58921,"nodeType":"ParameterList","parameters":[{"constant":false,"id":58920,"mutability":"mutable","name":"systemConfig_","nameLocation":"20047:13:120","nodeType":"VariableDeclaration","scope":58925,"src":"20039:21:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":58919,"name":"address","nodeType":"ElementaryTypeName","src":"20039:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"20038:23:120"},"src":"20030:77:120"},{"block":{"id":58932,"nodeType":"Block","src":"20114:65:120","statements":[{"expression":{"arguments":[],"expression":{"argumentTypes":[],"expression":{"arguments":[{"id":58927,"name":"_portal","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58909,"src":"20144:7:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_address","typeString":"address"}],"id":58926,"name":"IFetcher","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57326,"src":"20135:8:120","typeDescriptions":{"typeIdentifier":"t_type$_t_contract$_IFetcher_$57326_$","typeString":"type(contract IFetcher)"}},"id":58928,"isConstant":false,"isLValue":false,"isPure":false,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"20135:17:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_contract$_IFetcher_$57326","typeString":"contract IFetcher"}},"id":58929,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"20153:13:120","memberName":"SYSTEM_CONFIG","nodeType":"MemberAccess","referencedDeclaration":57201,"src":"20135:31:120","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":58930,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"20135:33:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"functionReturnParameters":58913,"id":58931,"nodeType":"Return","src":"20128:40:120"}]},"errorName":"","id":58933,"nodeType":"TryCatchClause","src":"20108:71:120"}],"externalCall":{"arguments":[],"expression":{"argumentTypes":[],"expression":{"arguments":[{"id":58915,"name":"_portal","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58909,"src":"20006:7:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_address","typeString":"address"}],"id":58914,"name":"IFetcher","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57326,"src":"19997:8:120","typeDescriptions":{"typeIdentifier":"t_type$_t_contract$_IFetcher_$57326_$","typeString":"type(contract IFetcher)"}},"id":58916,"isConstant":false,"isLValue":false,"isPure":false,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"19997:17:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_contract$_IFetcher_$57326","typeString":"contract IFetcher"}},"id":58917,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"20015:12:120","memberName":"systemConfig","nodeType":"MemberAccess","referencedDeclaration":57196,"src":"19997:30:120","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":58918,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"19997:32:120","tryCall":true,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"id":58934,"nodeType":"TryStatement","src":"19993:186:120"}]},"implemented":true,"kind":"function","modifiers":[],"name":"_getSystemConfigProxy","nameLocation":"19912:21:120","parameters":{"id":58910,"nodeType":"ParameterList","parameters":[{"constant":false,"id":58909,"mutability":"mutable","name":"_portal","nameLocation":"19942:7:120","nodeType":"VariableDeclaration","scope":58936,"src":"19934:15:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":58908,"name":"address","nodeType":"ElementaryTypeName","src":"19934:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"19933:17:120"},"returnParameters":{"id":58913,"nodeType":"ParameterList","parameters":[{"constant":false,"id":58912,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":58936,"src":"19974:7:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":58911,"name":"address","nodeType":"ElementaryTypeName","src":"19974:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"19973:9:120"},"scope":59299,"stateMutability":"view","virtual":false,"visibility":"internal"},{"id":58965,"nodeType":"FunctionDefinition","src":"20191:338:120","nodes":[],"body":{"id":58964,"nodeType":"Block","src":"20294:235:120","nodes":[],"statements":[{"clauses":[{"block":{"id":58953,"nodeType":"Block","src":"20390:47:120","statements":[{"expression":{"id":58951,"name":"optimismPortal_","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58949,"src":"20411:15:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"functionReturnParameters":58942,"id":58952,"nodeType":"Return","src":"20404:22:120"}]},"errorName":"","id":58954,"nodeType":"TryCatchClause","parameters":{"id":58950,"nodeType":"ParameterList","parameters":[{"constant":false,"id":58949,"mutability":"mutable","name":"optimismPortal_","nameLocation":"20373:15:120","nodeType":"VariableDeclaration","scope":58954,"src":"20365:23:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":58948,"name":"address","nodeType":"ElementaryTypeName","src":"20365:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"20364:25:120"},"src":"20356:81:120"},{"block":{"id":58961,"nodeType":"Block","src":"20444:79:120","statements":[{"expression":{"arguments":[],"expression":{"argumentTypes":[],"expression":{"arguments":[{"id":58956,"name":"_l1CrossDomainMessengerProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58938,"src":"20474:28:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_address","typeString":"address"}],"id":58955,"name":"IFetcher","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57326,"src":"20465:8:120","typeDescriptions":{"typeIdentifier":"t_type$_t_contract$_IFetcher_$57326_$","typeString":"type(contract IFetcher)"}},"id":58957,"isConstant":false,"isLValue":false,"isPure":false,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"20465:38:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_contract$_IFetcher_$57326","typeString":"contract IFetcher"}},"id":58958,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"20504:6:120","memberName":"PORTAL","nodeType":"MemberAccess","referencedDeclaration":57231,"src":"20465:45:120","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":58959,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"20465:47:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"functionReturnParameters":58942,"id":58960,"nodeType":"Return","src":"20458:54:120"}]},"errorName":"","id":58962,"nodeType":"TryCatchClause","src":"20438:85:120"}],"externalCall":{"arguments":[],"expression":{"argumentTypes":[],"expression":{"arguments":[{"id":58944,"name":"_l1CrossDomainMessengerProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58938,"src":"20317:28:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_address","typeString":"address"}],"id":58943,"name":"IFetcher","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57326,"src":"20308:8:120","typeDescriptions":{"typeIdentifier":"t_type$_t_contract$_IFetcher_$57326_$","typeString":"type(contract IFetcher)"}},"id":58945,"isConstant":false,"isLValue":false,"isPure":false,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"20308:38:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_contract$_IFetcher_$57326","typeString":"contract IFetcher"}},"id":58946,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"20347:6:120","memberName":"portal","nodeType":"MemberAccess","referencedDeclaration":57236,"src":"20308:45:120","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":58947,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"20308:47:120","tryCall":true,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"id":58963,"nodeType":"TryStatement","src":"20304:219:120"}]},"implemented":true,"kind":"function","modifiers":[],"name":"_getOptimismPortalProxy","nameLocation":"20200:23:120","parameters":{"id":58939,"nodeType":"ParameterList","parameters":[{"constant":false,"id":58938,"mutability":"mutable","name":"_l1CrossDomainMessengerProxy","nameLocation":"20232:28:120","nodeType":"VariableDeclaration","scope":58965,"src":"20224:36:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":58937,"name":"address","nodeType":"ElementaryTypeName","src":"20224:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"20223:38:120"},"returnParameters":{"id":58942,"nodeType":"ParameterList","parameters":[{"constant":false,"id":58941,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":58965,"src":"20285:7:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":58940,"name":"address","nodeType":"ElementaryTypeName","src":"20285:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"20284:9:120"},"scope":59299,"stateMutability":"view","virtual":false,"visibility":"internal"},{"id":59003,"nodeType":"FunctionDefinition","src":"20535:350:120","nodes":[],"body":{"id":59002,"nodeType":"Block","src":"20633:252:120","nodes":[],"statements":[{"assignments":[58973],"declarations":[{"constant":false,"id":58973,"mutability":"mutable","name":"ADDRESS_MANAGER_MAPPING_SLOT","nameLocation":"20651:28:120","nodeType":"VariableDeclaration","scope":59002,"src":"20643:36:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_uint256","typeString":"uint256"},"typeName":{"id":58972,"name":"uint256","nodeType":"ElementaryTypeName","src":"20643:7:120","typeDescriptions":{"typeIdentifier":"t_uint256","typeString":"uint256"}},"visibility":"internal"}],"id":58975,"initialValue":{"hexValue":"31","id":58974,"isConstant":false,"isLValue":false,"isPure":true,"kind":"number","lValueRequested":false,"nodeType":"Literal","src":"20682:1:120","typeDescriptions":{"typeIdentifier":"t_rational_1_by_1","typeString":"int_const 1"},"value":"1"},"nodeType":"VariableDeclarationStatement","src":"20643:40:120"},{"assignments":[58977],"declarations":[{"constant":false,"id":58977,"mutability":"mutable","name":"slot","nameLocation":"20701:4:120","nodeType":"VariableDeclaration","scope":59002,"src":"20693:12:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_bytes32","typeString":"bytes32"},"typeName":{"id":58976,"name":"bytes32","nodeType":"ElementaryTypeName","src":"20693:7:120","typeDescriptions":{"typeIdentifier":"t_bytes32","typeString":"bytes32"}},"visibility":"internal"}],"id":58985,"initialValue":{"arguments":[{"arguments":[{"id":58981,"name":"_l1CrossDomainMessengerProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58967,"src":"20729:28:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},{"id":58982,"name":"ADDRESS_MANAGER_MAPPING_SLOT","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58973,"src":"20759:28:120","typeDescriptions":{"typeIdentifier":"t_uint256","typeString":"uint256"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_address","typeString":"address"},{"typeIdentifier":"t_uint256","typeString":"uint256"}],"expression":{"id":58979,"name":"abi","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":-1,"src":"20718:3:120","typeDescriptions":{"typeIdentifier":"t_magic_abi","typeString":"abi"}},"id":58980,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"memberLocation":"20722:6:120","memberName":"encode","nodeType":"MemberAccess","src":"20718:10:120","typeDescriptions":{"typeIdentifier":"t_function_abiencode_pure$__$returns$_t_bytes_memory_ptr_$","typeString":"function () pure returns (bytes memory)"}},"id":58983,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"20718:70:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_bytes_memory_ptr","typeString":"bytes memory"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_bytes_memory_ptr","typeString":"bytes memory"}],"id":58978,"name":"keccak256","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":-8,"src":"20708:9:120","typeDescriptions":{"typeIdentifier":"t_function_keccak256_pure$_t_bytes_memory_ptr_$returns$_t_bytes32_$","typeString":"function (bytes memory) pure returns (bytes32)"}},"id":58984,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"20708:81:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_bytes32","typeString":"bytes32"}},"nodeType":"VariableDeclarationStatement","src":"20693:96:120"},{"expression":{"arguments":[{"arguments":[{"arguments":[{"components":[{"arguments":[{"id":58994,"name":"_l1CrossDomainMessengerProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58967,"src":"20839:28:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},{"id":58995,"name":"slot","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58977,"src":"20869:4:120","typeDescriptions":{"typeIdentifier":"t_bytes32","typeString":"bytes32"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_address","typeString":"address"},{"typeIdentifier":"t_bytes32","typeString":"bytes32"}],"expression":{"id":58992,"name":"vm","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":5980,"src":"20831:2:120","typeDescriptions":{"typeIdentifier":"t_contract$_Vm_$23767","typeString":"contract Vm"}},"id":58993,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"20834:4:120","memberName":"load","nodeType":"MemberAccess","referencedDeclaration":19863,"src":"20831:7:120","typeDescriptions":{"typeIdentifier":"t_function_external_view$_t_address_$_t_bytes32_$returns$_t_bytes32_$","typeString":"function (address,bytes32) view external returns (bytes32)"}},"id":58996,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"20831:43:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_bytes32","typeString":"bytes32"}}],"id":58997,"isConstant":false,"isInlineArray":false,"isLValue":false,"isPure":false,"lValueRequested":false,"nodeType":"TupleExpression","src":"20830:45:120","typeDescriptions":{"typeIdentifier":"t_bytes32","typeString":"bytes32"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_bytes32","typeString":"bytes32"}],"id":58991,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"nodeType":"ElementaryTypeNameExpression","src":"20822:7:120","typeDescriptions":{"typeIdentifier":"t_type$_t_uint256_$","typeString":"type(uint256)"},"typeName":{"id":58990,"name":"uint256","nodeType":"ElementaryTypeName","src":"20822:7:120","typeDescriptions":{}}},"id":58998,"isConstant":false,"isLValue":false,"isPure":false,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"20822:54:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_uint256","typeString":"uint256"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_uint256","typeString":"uint256"}],"id":58989,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"nodeType":"ElementaryTypeNameExpression","src":"20814:7:120","typeDescriptions":{"typeIdentifier":"t_type$_t_uint160_$","typeString":"type(uint160)"},"typeName":{"id":58988,"name":"uint160","nodeType":"ElementaryTypeName","src":"20814:7:120","typeDescriptions":{}}},"id":58999,"isConstant":false,"isLValue":false,"isPure":false,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"20814:63:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_uint160","typeString":"uint160"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_uint160","typeString":"uint160"}],"id":58987,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"nodeType":"ElementaryTypeNameExpression","src":"20806:7:120","typeDescriptions":{"typeIdentifier":"t_type$_t_address_$","typeString":"type(address)"},"typeName":{"id":58986,"name":"address","nodeType":"ElementaryTypeName","src":"20806:7:120","typeDescriptions":{}}},"id":59000,"isConstant":false,"isLValue":false,"isPure":false,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"20806:72:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"functionReturnParameters":58971,"id":59001,"nodeType":"Return","src":"20799:79:120"}]},"implemented":true,"kind":"function","modifiers":[],"name":"_getAddressManager","nameLocation":"20544:18:120","parameters":{"id":58968,"nodeType":"ParameterList","parameters":[{"constant":false,"id":58967,"mutability":"mutable","name":"_l1CrossDomainMessengerProxy","nameLocation":"20571:28:120","nodeType":"VariableDeclaration","scope":59003,"src":"20563:36:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":58966,"name":"address","nodeType":"ElementaryTypeName","src":"20563:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"20562:38:120"},"returnParameters":{"id":58971,"nodeType":"ParameterList","parameters":[{"constant":false,"id":58970,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":59003,"src":"20624:7:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":58969,"name":"address","nodeType":"ElementaryTypeName","src":"20624:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"20623:9:120"},"scope":59299,"stateMutability":"view","virtual":false,"visibility":"internal"},{"id":59031,"nodeType":"FunctionDefinition","src":"20891:299:120","nodes":[],"body":{"id":59030,"nodeType":"Block","src":"20984:206:120","nodes":[],"statements":[{"clauses":[{"block":{"id":59020,"nodeType":"Block","src":"21083:52:120","statements":[{"expression":{"id":59018,"name":"l1ERC721BridgeProxy_","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":59016,"src":"21104:20:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"functionReturnParameters":59009,"id":59019,"nodeType":"Return","src":"21097:27:120"}]},"errorName":"","id":59021,"nodeType":"TryCatchClause","parameters":{"id":59017,"nodeType":"ParameterList","parameters":[{"constant":false,"id":59016,"mutability":"mutable","name":"l1ERC721BridgeProxy_","nameLocation":"21061:20:120","nodeType":"VariableDeclaration","scope":59021,"src":"21053:28:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":59015,"name":"address","nodeType":"ElementaryTypeName","src":"21053:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"21052:30:120"},"src":"21044:91:120"},{"block":{"id":59027,"nodeType":"Block","src":"21142:42:120","statements":[{"expression":{"arguments":[{"hexValue":"30","id":59024,"isConstant":false,"isLValue":false,"isPure":true,"kind":"number","lValueRequested":false,"nodeType":"Literal","src":"21171:1:120","typeDescriptions":{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"},"value":"0"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"}],"id":59023,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"nodeType":"ElementaryTypeNameExpression","src":"21163:7:120","typeDescriptions":{"typeIdentifier":"t_type$_t_address_$","typeString":"type(address)"},"typeName":{"id":59022,"name":"address","nodeType":"ElementaryTypeName","src":"21163:7:120","typeDescriptions":{}}},"id":59025,"isConstant":false,"isLValue":false,"isPure":true,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"21163:10:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"functionReturnParameters":59009,"id":59026,"nodeType":"Return","src":"21156:17:120"}]},"errorName":"","id":59028,"nodeType":"TryCatchClause","src":"21136:48:120"}],"externalCall":{"arguments":[],"expression":{"argumentTypes":[],"expression":{"arguments":[{"id":59011,"name":"_systemConfigProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":59005,"src":"21007:18:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_address","typeString":"address"}],"id":59010,"name":"IFetcher","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57326,"src":"20998:8:120","typeDescriptions":{"typeIdentifier":"t_type$_t_contract$_IFetcher_$57326_$","typeString":"type(contract IFetcher)"}},"id":59012,"isConstant":false,"isLValue":false,"isPure":false,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"20998:28:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_contract$_IFetcher_$57326","typeString":"contract IFetcher"}},"id":59013,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"21027:14:120","memberName":"l1ERC721Bridge","nodeType":"MemberAccess","referencedDeclaration":57241,"src":"20998:43:120","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":59014,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"20998:45:120","tryCall":true,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"id":59029,"nodeType":"TryStatement","src":"20994:190:120"}]},"implemented":true,"kind":"function","modifiers":[],"name":"_getL1ERC721BridgeProxy","nameLocation":"20900:23:120","parameters":{"id":59006,"nodeType":"ParameterList","parameters":[{"constant":false,"id":59005,"mutability":"mutable","name":"_systemConfigProxy","nameLocation":"20932:18:120","nodeType":"VariableDeclaration","scope":59031,"src":"20924:26:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":59004,"name":"address","nodeType":"ElementaryTypeName","src":"20924:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"20923:28:120"},"returnParameters":{"id":59009,"nodeType":"ParameterList","parameters":[{"constant":false,"id":59008,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":59031,"src":"20975:7:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":59007,"name":"address","nodeType":"ElementaryTypeName","src":"20975:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"20974:9:120"},"scope":59299,"stateMutability":"view","virtual":false,"visibility":"internal"},{"id":59059,"nodeType":"FunctionDefinition","src":"21196:377:120","nodes":[],"body":{"id":59058,"nodeType":"Block","src":"21303:270:120","nodes":[],"statements":[{"clauses":[{"block":{"id":59048,"nodeType":"Block","src":"21452:66:120","statements":[{"expression":{"id":59046,"name":"optimismMintableERC20FactoryProxy_","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":59044,"src":"21473:34:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"functionReturnParameters":59037,"id":59047,"nodeType":"Return","src":"21466:41:120"}]},"errorName":"","id":59049,"nodeType":"TryCatchClause","parameters":{"id":59045,"nodeType":"ParameterList","parameters":[{"constant":false,"id":59044,"mutability":"mutable","name":"optimismMintableERC20FactoryProxy_","nameLocation":"21407:34:120","nodeType":"VariableDeclaration","scope":59049,"src":"21399:42:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":59043,"name":"address","nodeType":"ElementaryTypeName","src":"21399:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"21385:66:120"},"src":"21377:141:120"},{"block":{"id":59055,"nodeType":"Block","src":"21525:42:120","statements":[{"expression":{"arguments":[{"hexValue":"30","id":59052,"isConstant":false,"isLValue":false,"isPure":true,"kind":"number","lValueRequested":false,"nodeType":"Literal","src":"21554:1:120","typeDescriptions":{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"},"value":"0"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"}],"id":59051,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"nodeType":"ElementaryTypeNameExpression","src":"21546:7:120","typeDescriptions":{"typeIdentifier":"t_type$_t_address_$","typeString":"type(address)"},"typeName":{"id":59050,"name":"address","nodeType":"ElementaryTypeName","src":"21546:7:120","typeDescriptions":{}}},"id":59053,"isConstant":false,"isLValue":false,"isPure":true,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"21546:10:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"functionReturnParameters":59037,"id":59054,"nodeType":"Return","src":"21539:17:120"}]},"errorName":"","id":59056,"nodeType":"TryCatchClause","src":"21519:48:120"}],"externalCall":{"arguments":[],"expression":{"argumentTypes":[],"expression":{"arguments":[{"id":59039,"name":"_systemConfigProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":59033,"src":"21326:18:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_address","typeString":"address"}],"id":59038,"name":"IFetcher","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57326,"src":"21317:8:120","typeDescriptions":{"typeIdentifier":"t_type$_t_contract$_IFetcher_$57326_$","typeString":"type(contract IFetcher)"}},"id":59040,"isConstant":false,"isLValue":false,"isPure":false,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"21317:28:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_contract$_IFetcher_$57326","typeString":"contract IFetcher"}},"id":59041,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"21346:28:120","memberName":"optimismMintableERC20Factory","nodeType":"MemberAccess","referencedDeclaration":57246,"src":"21317:57:120","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":59042,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"21317:59:120","tryCall":true,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"id":59057,"nodeType":"TryStatement","src":"21313:254:120"}]},"implemented":true,"kind":"function","modifiers":[],"name":"_getOptimismMintableERC20FactoryProxy","nameLocation":"21205:37:120","parameters":{"id":59034,"nodeType":"ParameterList","parameters":[{"constant":false,"id":59033,"mutability":"mutable","name":"_systemConfigProxy","nameLocation":"21251:18:120","nodeType":"VariableDeclaration","scope":59059,"src":"21243:26:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":59032,"name":"address","nodeType":"ElementaryTypeName","src":"21243:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"21242:28:120"},"returnParameters":{"id":59037,"nodeType":"ParameterList","parameters":[{"constant":false,"id":59036,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":59059,"src":"21294:7:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":59035,"name":"address","nodeType":"ElementaryTypeName","src":"21294:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"21293:9:120"},"scope":59299,"stateMutability":"view","virtual":false,"visibility":"internal"},{"id":59087,"nodeType":"FunctionDefinition","src":"21579:398:120","nodes":[],"body":{"id":59086,"nodeType":"Block","src":"21676:301:120","nodes":[],"statements":[{"clauses":[{"block":{"id":59076,"nodeType":"Block","src":"21783:56:120","statements":[{"expression":{"id":59074,"name":"disputeGameFactoryProxy_","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":59072,"src":"21804:24:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"functionReturnParameters":59065,"id":59075,"nodeType":"Return","src":"21797:31:120"}]},"errorName":"","id":59077,"nodeType":"TryCatchClause","parameters":{"id":59073,"nodeType":"ParameterList","parameters":[{"constant":false,"id":59072,"mutability":"mutable","name":"disputeGameFactoryProxy_","nameLocation":"21757:24:120","nodeType":"VariableDeclaration","scope":59077,"src":"21749:32:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":59071,"name":"address","nodeType":"ElementaryTypeName","src":"21749:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"21748:34:120"},"src":"21740:99:120"},{"block":{"id":59083,"nodeType":"Block","src":"21846:125:120","statements":[{"expression":{"arguments":[{"hexValue":"30","id":59080,"isConstant":false,"isLValue":false,"isPure":true,"kind":"number","lValueRequested":false,"nodeType":"Literal","src":"21958:1:120","typeDescriptions":{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"},"value":"0"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"}],"id":59079,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"nodeType":"ElementaryTypeNameExpression","src":"21950:7:120","typeDescriptions":{"typeIdentifier":"t_type$_t_address_$","typeString":"type(address)"},"typeName":{"id":59078,"name":"address","nodeType":"ElementaryTypeName","src":"21950:7:120","typeDescriptions":{}}},"id":59081,"isConstant":false,"isLValue":false,"isPure":true,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"21950:10:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"functionReturnParameters":59065,"id":59082,"nodeType":"Return","src":"21943:17:120"}]},"errorName":"","id":59084,"nodeType":"TryCatchClause","src":"21840:131:120"}],"externalCall":{"arguments":[],"expression":{"argumentTypes":[],"expression":{"arguments":[{"id":59067,"name":"_systemConfigProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":59061,"src":"21699:18:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_address","typeString":"address"}],"id":59066,"name":"IFetcher","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57326,"src":"21690:8:120","typeDescriptions":{"typeIdentifier":"t_type$_t_contract$_IFetcher_$57326_$","typeString":"type(contract IFetcher)"}},"id":59068,"isConstant":false,"isLValue":false,"isPure":false,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"21690:28:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_contract$_IFetcher_$57326","typeString":"contract IFetcher"}},"id":59069,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"21719:18:120","memberName":"disputeGameFactory","nodeType":"MemberAccess","referencedDeclaration":57206,"src":"21690:47:120","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":59070,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"21690:49:120","tryCall":true,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"id":59085,"nodeType":"TryStatement","src":"21686:285:120"}]},"implemented":true,"kind":"function","modifiers":[],"name":"_getDisputeGameFactoryProxy","nameLocation":"21588:27:120","parameters":{"id":59062,"nodeType":"ParameterList","parameters":[{"constant":false,"id":59061,"mutability":"mutable","name":"_systemConfigProxy","nameLocation":"21624:18:120","nodeType":"VariableDeclaration","scope":59087,"src":"21616:26:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":59060,"name":"address","nodeType":"ElementaryTypeName","src":"21616:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"21615:28:120"},"returnParameters":{"id":59065,"nodeType":"ParameterList","parameters":[{"constant":false,"id":59064,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":59087,"src":"21667:7:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":59063,"name":"address","nodeType":"ElementaryTypeName","src":"21667:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"21666:9:120"},"scope":59299,"stateMutability":"view","virtual":false,"visibility":"internal"},{"id":59115,"nodeType":"FunctionDefinition","src":"21983:311:120","nodes":[],"body":{"id":59114,"nodeType":"Block","src":"22080:214:120","nodes":[],"statements":[{"clauses":[{"block":{"id":59104,"nodeType":"Block","src":"22185:54:120","statements":[{"expression":{"id":59102,"name":"superchainConfigProxy_","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":59100,"src":"22206:22:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"functionReturnParameters":59093,"id":59103,"nodeType":"Return","src":"22199:29:120"}]},"errorName":"","id":59105,"nodeType":"TryCatchClause","parameters":{"id":59101,"nodeType":"ParameterList","parameters":[{"constant":false,"id":59100,"mutability":"mutable","name":"superchainConfigProxy_","nameLocation":"22161:22:120","nodeType":"VariableDeclaration","scope":59105,"src":"22153:30:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":59099,"name":"address","nodeType":"ElementaryTypeName","src":"22153:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"22152:32:120"},"src":"22144:95:120"},{"block":{"id":59111,"nodeType":"Block","src":"22246:42:120","statements":[{"expression":{"arguments":[{"hexValue":"30","id":59108,"isConstant":false,"isLValue":false,"isPure":true,"kind":"number","lValueRequested":false,"nodeType":"Literal","src":"22275:1:120","typeDescriptions":{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"},"value":"0"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"}],"id":59107,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"nodeType":"ElementaryTypeNameExpression","src":"22267:7:120","typeDescriptions":{"typeIdentifier":"t_type$_t_address_$","typeString":"type(address)"},"typeName":{"id":59106,"name":"address","nodeType":"ElementaryTypeName","src":"22267:7:120","typeDescriptions":{}}},"id":59109,"isConstant":false,"isLValue":false,"isPure":true,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"22267:10:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"functionReturnParameters":59093,"id":59110,"nodeType":"Return","src":"22260:17:120"}]},"errorName":"","id":59112,"nodeType":"TryCatchClause","src":"22240:48:120"}],"externalCall":{"arguments":[],"expression":{"argumentTypes":[],"expression":{"arguments":[{"id":59095,"name":"_optimismPortalProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":59089,"src":"22103:20:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_address","typeString":"address"}],"id":59094,"name":"IFetcher","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57326,"src":"22094:8:120","typeDescriptions":{"typeIdentifier":"t_type$_t_contract$_IFetcher_$57326_$","typeString":"type(contract IFetcher)"}},"id":59096,"isConstant":false,"isLValue":false,"isPure":false,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"22094:30:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_contract$_IFetcher_$57326","typeString":"contract IFetcher"}},"id":59097,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"22125:16:120","memberName":"superchainConfig","nodeType":"MemberAccess","referencedDeclaration":57216,"src":"22094:47:120","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":59098,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"22094:49:120","tryCall":true,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"id":59113,"nodeType":"TryStatement","src":"22090:198:120"}]},"implemented":true,"kind":"function","modifiers":[],"name":"_getSuperchainConfigProxy","nameLocation":"21992:25:120","parameters":{"id":59090,"nodeType":"ParameterList","parameters":[{"constant":false,"id":59089,"mutability":"mutable","name":"_optimismPortalProxy","nameLocation":"22026:20:120","nodeType":"VariableDeclaration","scope":59115,"src":"22018:28:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":59088,"name":"address","nodeType":"ElementaryTypeName","src":"22018:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"22017:30:120"},"returnParameters":{"id":59093,"nodeType":"ParameterList","parameters":[{"constant":false,"id":59092,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":59115,"src":"22071:7:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":59091,"name":"address","nodeType":"ElementaryTypeName","src":"22071:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"22070:9:120"},"scope":59299,"stateMutability":"view","virtual":false,"visibility":"internal"},{"id":59145,"nodeType":"FunctionDefinition","src":"22300:313:120","nodes":[],"body":{"id":59144,"nodeType":"Block","src":"22396:217:120","nodes":[],"statements":[{"clauses":[{"block":{"id":59134,"nodeType":"Block","src":"22509:49:120","statements":[{"expression":{"id":59132,"name":"faultDisputeGame_","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":59130,"src":"22530:17:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"functionReturnParameters":59121,"id":59133,"nodeType":"Return","src":"22523:24:120"}]},"errorName":"","id":59135,"nodeType":"TryCatchClause","parameters":{"id":59131,"nodeType":"ParameterList","parameters":[{"constant":false,"id":59130,"mutability":"mutable","name":"faultDisputeGame_","nameLocation":"22490:17:120","nodeType":"VariableDeclaration","scope":59135,"src":"22482:25:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":59129,"name":"address","nodeType":"ElementaryTypeName","src":"22482:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"22481:27:120"},"src":"22473:85:120"},{"block":{"id":59141,"nodeType":"Block","src":"22565:42:120","statements":[{"expression":{"arguments":[{"hexValue":"30","id":59138,"isConstant":false,"isLValue":false,"isPure":true,"kind":"number","lValueRequested":false,"nodeType":"Literal","src":"22594:1:120","typeDescriptions":{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"},"value":"0"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"}],"id":59137,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"nodeType":"ElementaryTypeNameExpression","src":"22586:7:120","typeDescriptions":{"typeIdentifier":"t_type$_t_address_$","typeString":"type(address)"},"typeName":{"id":59136,"name":"address","nodeType":"ElementaryTypeName","src":"22586:7:120","typeDescriptions":{}}},"id":59139,"isConstant":false,"isLValue":false,"isPure":true,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"22586:10:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"functionReturnParameters":59121,"id":59140,"nodeType":"Return","src":"22579:17:120"}]},"errorName":"","id":59142,"nodeType":"TryCatchClause","src":"22559:48:120"}],"externalCall":{"arguments":[{"expression":{"id":59126,"name":"GameTypes","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":75481,"src":"22455:9:120","typeDescriptions":{"typeIdentifier":"t_type$_t_contract$_GameTypes_$75481_$","typeString":"type(library GameTypes)"}},"id":59127,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"memberLocation":"22465:6:120","memberName":"CANNON","nodeType":"MemberAccess","referencedDeclaration":75408,"src":"22455:16:120","typeDescriptions":{"typeIdentifier":"t_userDefinedValueType$_GameType_$75355","typeString":"GameType"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_userDefinedValueType$_GameType_$75355","typeString":"GameType"}],"expression":{"arguments":[{"id":59123,"name":"_disputeGameFactoryProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":59117,"src":"22419:24:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_address","typeString":"address"}],"id":59122,"name":"IFetcher","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57326,"src":"22410:8:120","typeDescriptions":{"typeIdentifier":"t_type$_t_contract$_IFetcher_$57326_$","typeString":"type(contract IFetcher)"}},"id":59124,"isConstant":false,"isLValue":false,"isPure":false,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"22410:34:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_contract$_IFetcher_$57326","typeString":"contract IFetcher"}},"id":59125,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"22445:9:120","memberName":"gameImpls","nodeType":"MemberAccess","referencedDeclaration":57254,"src":"22410:44:120","typeDescriptions":{"typeIdentifier":"t_function_external_view$_t_userDefinedValueType$_GameType_$75355_$returns$_t_address_$","typeString":"function (GameType) view external returns (address)"}},"id":59128,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"22410:62:120","tryCall":true,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"id":59143,"nodeType":"TryStatement","src":"22406:201:120"}]},"implemented":true,"kind":"function","modifiers":[],"name":"_getFaultDisputeGame","nameLocation":"22309:20:120","parameters":{"id":59118,"nodeType":"ParameterList","parameters":[{"constant":false,"id":59117,"mutability":"mutable","name":"_disputeGameFactoryProxy","nameLocation":"22338:24:120","nodeType":"VariableDeclaration","scope":59145,"src":"22330:32:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":59116,"name":"address","nodeType":"ElementaryTypeName","src":"22330:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"22329:34:120"},"returnParameters":{"id":59121,"nodeType":"ParameterList","parameters":[{"constant":false,"id":59120,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":59145,"src":"22387:7:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":59119,"name":"address","nodeType":"ElementaryTypeName","src":"22387:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"22386:9:120"},"scope":59299,"stateMutability":"view","virtual":false,"visibility":"internal"},{"id":59175,"nodeType":"FunctionDefinition","src":"22619:369:120","nodes":[],"body":{"id":59174,"nodeType":"Block","src":"22722:266:120","nodes":[],"statements":[{"clauses":[{"block":{"id":59164,"nodeType":"Block","src":"22877:56:120","statements":[{"expression":{"id":59162,"name":"permissionedDisputeGame_","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":59160,"src":"22898:24:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"functionReturnParameters":59151,"id":59163,"nodeType":"Return","src":"22891:31:120"}]},"errorName":"","id":59165,"nodeType":"TryCatchClause","parameters":{"id":59161,"nodeType":"ParameterList","parameters":[{"constant":false,"id":59160,"mutability":"mutable","name":"permissionedDisputeGame_","nameLocation":"22842:24:120","nodeType":"VariableDeclaration","scope":59165,"src":"22834:32:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":59159,"name":"address","nodeType":"ElementaryTypeName","src":"22834:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"22820:56:120"},"src":"22812:121:120"},{"block":{"id":59171,"nodeType":"Block","src":"22940:42:120","statements":[{"expression":{"arguments":[{"hexValue":"30","id":59168,"isConstant":false,"isLValue":false,"isPure":true,"kind":"number","lValueRequested":false,"nodeType":"Literal","src":"22969:1:120","typeDescriptions":{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"},"value":"0"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"}],"id":59167,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"nodeType":"ElementaryTypeNameExpression","src":"22961:7:120","typeDescriptions":{"typeIdentifier":"t_type$_t_address_$","typeString":"type(address)"},"typeName":{"id":59166,"name":"address","nodeType":"ElementaryTypeName","src":"22961:7:120","typeDescriptions":{}}},"id":59169,"isConstant":false,"isLValue":false,"isPure":true,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"22961:10:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"functionReturnParameters":59151,"id":59170,"nodeType":"Return","src":"22954:17:120"}]},"errorName":"","id":59172,"nodeType":"TryCatchClause","src":"22934:48:120"}],"externalCall":{"arguments":[{"expression":{"id":59156,"name":"GameTypes","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":75481,"src":"22781:9:120","typeDescriptions":{"typeIdentifier":"t_type$_t_contract$_GameTypes_$75481_$","typeString":"type(library GameTypes)"}},"id":59157,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"memberLocation":"22791:19:120","memberName":"PERMISSIONED_CANNON","nodeType":"MemberAccess","referencedDeclaration":75416,"src":"22781:29:120","typeDescriptions":{"typeIdentifier":"t_userDefinedValueType$_GameType_$75355","typeString":"GameType"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_userDefinedValueType$_GameType_$75355","typeString":"GameType"}],"expression":{"arguments":[{"id":59153,"name":"_disputeGameFactoryProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":59147,"src":"22745:24:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_address","typeString":"address"}],"id":59152,"name":"IFetcher","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57326,"src":"22736:8:120","typeDescriptions":{"typeIdentifier":"t_type$_t_contract$_IFetcher_$57326_$","typeString":"type(contract IFetcher)"}},"id":59154,"isConstant":false,"isLValue":false,"isPure":false,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"22736:34:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_contract$_IFetcher_$57326","typeString":"contract IFetcher"}},"id":59155,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"22771:9:120","memberName":"gameImpls","nodeType":"MemberAccess","referencedDeclaration":57254,"src":"22736:44:120","typeDescriptions":{"typeIdentifier":"t_function_external_view$_t_userDefinedValueType$_GameType_$75355_$returns$_t_address_$","typeString":"function (GameType) view external returns (address)"}},"id":59158,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"22736:75:120","tryCall":true,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"id":59173,"nodeType":"TryStatement","src":"22732:250:120"}]},"implemented":true,"kind":"function","modifiers":[],"name":"_getPermissionedDisputeGame","nameLocation":"22628:27:120","parameters":{"id":59148,"nodeType":"ParameterList","parameters":[{"constant":false,"id":59147,"mutability":"mutable","name":"_disputeGameFactoryProxy","nameLocation":"22664:24:120","nodeType":"VariableDeclaration","scope":59175,"src":"22656:32:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":59146,"name":"address","nodeType":"ElementaryTypeName","src":"22656:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"22655:34:120"},"returnParameters":{"id":59151,"nodeType":"ParameterList","parameters":[{"constant":false,"id":59150,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":59175,"src":"22713:7:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":59149,"name":"address","nodeType":"ElementaryTypeName","src":"22713:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"22712:9:120"},"scope":59299,"stateMutability":"view","virtual":false,"visibility":"internal"},{"id":59203,"nodeType":"FunctionDefinition","src":"22994:277:120","nodes":[],"body":{"id":59202,"nodeType":"Block","src":"23085:186:120","nodes":[],"statements":[{"clauses":[{"block":{"id":59192,"nodeType":"Block","src":"23173:43:120","statements":[{"expression":{"id":59190,"name":"ethLockbox_","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":59188,"src":"23194:11:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"functionReturnParameters":59181,"id":59191,"nodeType":"Return","src":"23187:18:120"}]},"errorName":"","id":59193,"nodeType":"TryCatchClause","parameters":{"id":59189,"nodeType":"ParameterList","parameters":[{"constant":false,"id":59188,"mutability":"mutable","name":"ethLockbox_","nameLocation":"23160:11:120","nodeType":"VariableDeclaration","scope":59193,"src":"23152:19:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":59187,"name":"address","nodeType":"ElementaryTypeName","src":"23152:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"23151:21:120"},"src":"23143:73:120"},{"block":{"id":59199,"nodeType":"Block","src":"23223:42:120","statements":[{"expression":{"arguments":[{"hexValue":"30","id":59196,"isConstant":false,"isLValue":false,"isPure":true,"kind":"number","lValueRequested":false,"nodeType":"Literal","src":"23252:1:120","typeDescriptions":{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"},"value":"0"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"}],"id":59195,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"nodeType":"ElementaryTypeNameExpression","src":"23244:7:120","typeDescriptions":{"typeIdentifier":"t_type$_t_address_$","typeString":"type(address)"},"typeName":{"id":59194,"name":"address","nodeType":"ElementaryTypeName","src":"23244:7:120","typeDescriptions":{}}},"id":59197,"isConstant":false,"isLValue":false,"isPure":true,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"23244:10:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"functionReturnParameters":59181,"id":59198,"nodeType":"Return","src":"23237:17:120"}]},"errorName":"","id":59200,"nodeType":"TryCatchClause","src":"23217:48:120"}],"externalCall":{"arguments":[],"expression":{"argumentTypes":[],"expression":{"arguments":[{"id":59183,"name":"_optimismPortalProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":59177,"src":"23108:20:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_address","typeString":"address"}],"id":59182,"name":"IFetcher","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57326,"src":"23099:8:120","typeDescriptions":{"typeIdentifier":"t_type$_t_contract$_IFetcher_$57326_$","typeString":"type(contract IFetcher)"}},"id":59184,"isConstant":false,"isLValue":false,"isPure":false,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"23099:30:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_contract$_IFetcher_$57326","typeString":"contract IFetcher"}},"id":59185,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"23130:10:120","memberName":"ethLockbox","nodeType":"MemberAccess","referencedDeclaration":57211,"src":"23099:41:120","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":59186,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"23099:43:120","tryCall":true,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"id":59201,"nodeType":"TryStatement","src":"23095:170:120"}]},"implemented":true,"kind":"function","modifiers":[],"name":"_getEthLockboxProxy","nameLocation":"23003:19:120","parameters":{"id":59178,"nodeType":"ParameterList","parameters":[{"constant":false,"id":59177,"mutability":"mutable","name":"_optimismPortalProxy","nameLocation":"23031:20:120","nodeType":"VariableDeclaration","scope":59203,"src":"23023:28:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":59176,"name":"address","nodeType":"ElementaryTypeName","src":"23023:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"23022:30:120"},"returnParameters":{"id":59181,"nodeType":"ParameterList","parameters":[{"constant":false,"id":59180,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":59203,"src":"23076:7:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":59179,"name":"address","nodeType":"ElementaryTypeName","src":"23076:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"23075:9:120"},"scope":59299,"stateMutability":"view","virtual":false,"visibility":"internal"},{"id":59248,"nodeType":"FunctionDefinition","src":"23277:304:120","nodes":[],"body":{"id":59247,"nodeType":"Block","src":"23361:220:120","nodes":[],"statements":[{"assignments":[59211,59213],"declarations":[{"constant":false,"id":59211,"mutability":"mutable","name":"ok","nameLocation":"23377:2:120","nodeType":"VariableDeclaration","scope":59247,"src":"23372:7:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"},"typeName":{"id":59210,"name":"bool","nodeType":"ElementaryTypeName","src":"23372:4:120","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},"visibility":"internal"},{"constant":false,"id":59213,"mutability":"mutable","name":"data","nameLocation":"23394:4:120","nodeType":"VariableDeclaration","scope":59247,"src":"23381:17:120","stateVariable":false,"storageLocation":"memory","typeDescriptions":{"typeIdentifier":"t_bytes_memory_ptr","typeString":"bytes"},"typeName":{"id":59212,"name":"bytes","nodeType":"ElementaryTypeName","src":"23381:5:120","typeDescriptions":{"typeIdentifier":"t_bytes_storage_ptr","typeString":"bytes"}},"visibility":"internal"}],"id":59226,"initialValue":{"arguments":[{"arguments":[{"expression":{"id":59221,"name":"IFetcher","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57326,"src":"23450:8:120","typeDescriptions":{"typeIdentifier":"t_type$_t_contract$_IFetcher_$57326_$","typeString":"type(contract IFetcher)"}},"id":59222,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"memberLocation":"23459:4:120","memberName":"weth","nodeType":"MemberAccess","referencedDeclaration":57325,"src":"23450:13:120","typeDescriptions":{"typeIdentifier":"t_function_declaration_view$__$returns$_t_address_$","typeString":"function IFetcher.weth() view returns (address)"}},{"components":[],"id":59223,"isConstant":false,"isInlineArray":false,"isLValue":false,"isPure":true,"lValueRequested":false,"nodeType":"TupleExpression","src":"23465:2:120","typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_function_declaration_view$__$returns$_t_address_$","typeString":"function IFetcher.weth() view returns (address)"},{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}],"expression":{"id":59219,"name":"abi","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":-1,"src":"23435:3:120","typeDescriptions":{"typeIdentifier":"t_magic_abi","typeString":"abi"}},"id":59220,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"memberLocation":"23439:10:120","memberName":"encodeCall","nodeType":"MemberAccess","src":"23435:14:120","typeDescriptions":{"typeIdentifier":"t_function_abiencodecall_pure$__$returns$_t_bytes_memory_ptr_$","typeString":"function () pure returns (bytes memory)"}},"id":59224,"isConstant":false,"isLValue":false,"isPure":true,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"23435:33:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_bytes_memory_ptr","typeString":"bytes memory"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_bytes_memory_ptr","typeString":"bytes memory"}],"expression":{"arguments":[{"id":59216,"name":"_disputeGame","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":59205,"src":"23410:12:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_address","typeString":"address"}],"id":59215,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"nodeType":"ElementaryTypeNameExpression","src":"23402:7:120","typeDescriptions":{"typeIdentifier":"t_type$_t_address_$","typeString":"type(address)"},"typeName":{"id":59214,"name":"address","nodeType":"ElementaryTypeName","src":"23402:7:120","typeDescriptions":{}}},"id":59217,"isConstant":false,"isLValue":false,"isPure":false,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"23402:21:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"id":59218,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"23424:10:120","memberName":"staticcall","nodeType":"MemberAccess","src":"23402:32:120","typeDescriptions":{"typeIdentifier":"t_function_barestaticcall_view$_t_bytes_memory_ptr_$returns$_t_bool_$_t_bytes_memory_ptr_$","typeString":"function (bytes memory) view returns (bool,bytes memory)"}},"id":59225,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"23402:67:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$_t_bool_$_t_bytes_memory_ptr_$","typeString":"tuple(bool,bytes memory)"}},"nodeType":"VariableDeclarationStatement","src":"23371:98:120"},{"condition":{"commonType":{"typeIdentifier":"t_bool","typeString":"bool"},"id":59232,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftExpression":{"id":59227,"name":"ok","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":59211,"src":"23483:2:120","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},"nodeType":"BinaryOperation","operator":"&&","rightExpression":{"commonType":{"typeIdentifier":"t_uint256","typeString":"uint256"},"id":59231,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftExpression":{"expression":{"id":59228,"name":"data","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":59213,"src":"23489:4:120","typeDescriptions":{"typeIdentifier":"t_bytes_memory_ptr","typeString":"bytes memory"}},"id":59229,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"23494:6:120","memberName":"length","nodeType":"MemberAccess","src":"23489:11:120","typeDescriptions":{"typeIdentifier":"t_uint256","typeString":"uint256"}},"nodeType":"BinaryOperation","operator":"==","rightExpression":{"hexValue":"3332","id":59230,"isConstant":false,"isLValue":false,"isPure":true,"kind":"number","lValueRequested":false,"nodeType":"Literal","src":"23504:2:120","typeDescriptions":{"typeIdentifier":"t_rational_32_by_1","typeString":"int_const 32"},"value":"32"},"src":"23489:17:120","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},"src":"23483:23:120","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},"falseBody":{"expression":{"arguments":[{"hexValue":"30","id":59243,"isConstant":false,"isLValue":false,"isPure":true,"kind":"number","lValueRequested":false,"nodeType":"Literal","src":"23572:1:120","typeDescriptions":{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"},"value":"0"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"}],"id":59242,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"nodeType":"ElementaryTypeNameExpression","src":"23564:7:120","typeDescriptions":{"typeIdentifier":"t_type$_t_address_$","typeString":"type(address)"},"typeName":{"id":59241,"name":"address","nodeType":"ElementaryTypeName","src":"23564:7:120","typeDescriptions":{}}},"id":59244,"isConstant":false,"isLValue":false,"isPure":true,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"23564:10:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"functionReturnParameters":59209,"id":59245,"nodeType":"Return","src":"23557:17:120"},"id":59246,"nodeType":"IfStatement","src":"23479:95:120","trueBody":{"expression":{"arguments":[{"id":59235,"name":"data","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":59213,"src":"23526:4:120","typeDescriptions":{"typeIdentifier":"t_bytes_memory_ptr","typeString":"bytes memory"}},{"components":[{"id":59237,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"nodeType":"ElementaryTypeNameExpression","src":"23533:7:120","typeDescriptions":{"typeIdentifier":"t_type$_t_address_$","typeString":"type(address)"},"typeName":{"id":59236,"name":"address","nodeType":"ElementaryTypeName","src":"23533:7:120","typeDescriptions":{}}}],"id":59238,"isConstant":false,"isInlineArray":false,"isLValue":false,"isPure":true,"lValueRequested":false,"nodeType":"TupleExpression","src":"23532:9:120","typeDescriptions":{"typeIdentifier":"t_type$_t_address_$","typeString":"type(address)"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_bytes_memory_ptr","typeString":"bytes memory"},{"typeIdentifier":"t_type$_t_address_$","typeString":"type(address)"}],"expression":{"id":59233,"name":"abi","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":-1,"src":"23515:3:120","typeDescriptions":{"typeIdentifier":"t_magic_abi","typeString":"abi"}},"id":59234,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"memberLocation":"23519:6:120","memberName":"decode","nodeType":"MemberAccess","src":"23515:10:120","typeDescriptions":{"typeIdentifier":"t_function_abidecode_pure$__$returns$__$","typeString":"function () pure"}},"id":59239,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"23515:27:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address_payable","typeString":"address payable"}},"functionReturnParameters":59209,"id":59240,"nodeType":"Return","src":"23508:34:120"}}]},"implemented":true,"kind":"function","modifiers":[],"name":"_getDelayedWETHProxy","nameLocation":"23286:20:120","parameters":{"id":59206,"nodeType":"ParameterList","parameters":[{"constant":false,"id":59205,"mutability":"mutable","name":"_disputeGame","nameLocation":"23315:12:120","nodeType":"VariableDeclaration","scope":59248,"src":"23307:20:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":59204,"name":"address","nodeType":"ElementaryTypeName","src":"23307:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"23306:22:120"},"returnParameters":{"id":59209,"nodeType":"ParameterList","parameters":[{"constant":false,"id":59208,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":59248,"src":"23352:7:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":59207,"name":"address","nodeType":"ElementaryTypeName","src":"23352:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"23351:9:120"},"scope":59299,"stateMutability":"view","virtual":false,"visibility":"internal"},{"id":59275,"nodeType":"FunctionDefinition","src":"23587:224:120","nodes":[],"body":{"id":59274,"nodeType":"Block","src":"23675:136:120","nodes":[],"statements":[{"assignments":[59256],"declarations":[{"constant":false,"id":59256,"mutability":"mutable","name":"batcherHash","nameLocation":"23693:11:120","nodeType":"VariableDeclaration","scope":59274,"src":"23685:19:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_bytes32","typeString":"bytes32"},"typeName":{"id":59255,"name":"bytes32","nodeType":"ElementaryTypeName","src":"23685:7:120","typeDescriptions":{"typeIdentifier":"t_bytes32","typeString":"bytes32"}},"visibility":"internal"}],"id":59262,"initialValue":{"arguments":[],"expression":{"argumentTypes":[],"expression":{"arguments":[{"id":59258,"name":"_systemConfigProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":59250,"src":"23716:18:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_address","typeString":"address"}],"id":59257,"name":"IFetcher","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57326,"src":"23707:8:120","typeDescriptions":{"typeIdentifier":"t_type$_t_contract$_IFetcher_$57326_$","typeString":"type(contract IFetcher)"}},"id":59259,"isConstant":false,"isLValue":false,"isPure":false,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"23707:28:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_contract$_IFetcher_$57326","typeString":"contract IFetcher"}},"id":59260,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"23736:11:120","memberName":"batcherHash","nodeType":"MemberAccess","referencedDeclaration":57305,"src":"23707:40:120","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_bytes32_$","typeString":"function () view external returns (bytes32)"}},"id":59261,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"23707:42:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_bytes32","typeString":"bytes32"}},"nodeType":"VariableDeclarationStatement","src":"23685:64:120"},{"expression":{"arguments":[{"arguments":[{"arguments":[{"id":59269,"name":"batcherHash","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":59256,"src":"23790:11:120","typeDescriptions":{"typeIdentifier":"t_bytes32","typeString":"bytes32"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_bytes32","typeString":"bytes32"}],"id":59268,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"nodeType":"ElementaryTypeNameExpression","src":"23782:7:120","typeDescriptions":{"typeIdentifier":"t_type$_t_uint256_$","typeString":"type(uint256)"},"typeName":{"id":59267,"name":"uint256","nodeType":"ElementaryTypeName","src":"23782:7:120","typeDescriptions":{}}},"id":59270,"isConstant":false,"isLValue":false,"isPure":false,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"23782:20:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_uint256","typeString":"uint256"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_uint256","typeString":"uint256"}],"id":59266,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"nodeType":"ElementaryTypeNameExpression","src":"23774:7:120","typeDescriptions":{"typeIdentifier":"t_type$_t_uint160_$","typeString":"type(uint160)"},"typeName":{"id":59265,"name":"uint160","nodeType":"ElementaryTypeName","src":"23774:7:120","typeDescriptions":{}}},"id":59271,"isConstant":false,"isLValue":false,"isPure":false,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"23774:29:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_uint160","typeString":"uint160"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_uint160","typeString":"uint160"}],"id":59264,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"nodeType":"ElementaryTypeNameExpression","src":"23766:7:120","typeDescriptions":{"typeIdentifier":"t_type$_t_address_$","typeString":"type(address)"},"typeName":{"id":59263,"name":"address","nodeType":"ElementaryTypeName","src":"23766:7:120","typeDescriptions":{}}},"id":59272,"isConstant":false,"isLValue":false,"isPure":false,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"23766:38:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"functionReturnParameters":59254,"id":59273,"nodeType":"Return","src":"23759:45:120"}]},"implemented":true,"kind":"function","modifiers":[],"name":"_getBatchSubmitter","nameLocation":"23596:18:120","parameters":{"id":59251,"nodeType":"ParameterList","parameters":[{"constant":false,"id":59250,"mutability":"mutable","name":"_systemConfigProxy","nameLocation":"23623:18:120","nodeType":"VariableDeclaration","scope":59275,"src":"23615:26:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":59249,"name":"address","nodeType":"ElementaryTypeName","src":"23615:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"23614:28:120"},"returnParameters":{"id":59254,"nodeType":"ParameterList","parameters":[{"constant":false,"id":59253,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":59275,"src":"23666:7:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":59252,"name":"address","nodeType":"ElementaryTypeName","src":"23666:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"23665:9:120"},"scope":59299,"stateMutability":"view","virtual":false,"visibility":"internal"},{"id":59298,"nodeType":"FunctionDefinition","src":"23817:169:120","nodes":[],"body":{"id":59297,"nodeType":"Block","src":"23896:90:120","nodes":[],"statements":[{"expression":{"arguments":[{"arguments":[{"hexValue":"30","id":59287,"isConstant":false,"isLValue":false,"isPure":true,"kind":"number","lValueRequested":false,"nodeType":"Literal","src":"23923:1:120","typeDescriptions":{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"},"value":"0"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"}],"id":59286,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"nodeType":"ElementaryTypeNameExpression","src":"23915:7:120","typeDescriptions":{"typeIdentifier":"t_type$_t_address_$","typeString":"type(address)"},"typeName":{"id":59285,"name":"address","nodeType":"ElementaryTypeName","src":"23915:7:120","typeDescriptions":{}}},"id":59288,"isConstant":false,"isLValue":false,"isPure":true,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"23915:10:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_address","typeString":"address"}],"expression":{"id":59282,"name":"vm","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":5980,"src":"23906:2:120","typeDescriptions":{"typeIdentifier":"t_contract$_Vm_$23767","typeString":"contract Vm"}},"id":59284,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"23909:5:120","memberName":"prank","nodeType":"MemberAccess","referencedDeclaration":23060,"src":"23906:8:120","typeDescriptions":{"typeIdentifier":"t_function_external_nonpayable$_t_address_$returns$__$","typeString":"function (address) external"}},"id":59289,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"23906:20:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":59290,"nodeType":"ExpressionStatement","src":"23906:20:120"},{"expression":{"arguments":[],"expression":{"argumentTypes":[],"expression":{"arguments":[{"id":59292,"name":"_systemConfigProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":59277,"src":"23952:18:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_address","typeString":"address"}],"id":59291,"name":"IFetcher","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57326,"src":"23943:8:120","typeDescriptions":{"typeIdentifier":"t_type$_t_contract$_IFetcher_$57326_$","typeString":"type(contract IFetcher)"}},"id":59293,"isConstant":false,"isLValue":false,"isPure":false,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"23943:28:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_contract$_IFetcher_$57326","typeString":"contract IFetcher"}},"id":59294,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"23972:5:120","memberName":"admin","nodeType":"MemberAccess","referencedDeclaration":57310,"src":"23943:34:120","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":59295,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"23943:36:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"functionReturnParameters":59281,"id":59296,"nodeType":"Return","src":"23936:43:120"}]},"implemented":true,"kind":"function","modifiers":[],"name":"_getProxyAdmin","nameLocation":"23826:14:120","parameters":{"id":59278,"nodeType":"ParameterList","parameters":[{"constant":false,"id":59277,"mutability":"mutable","name":"_systemConfigProxy","nameLocation":"23849:18:120","nodeType":"VariableDeclaration","scope":59298,"src":"23841:26:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":59276,"name":"address","nodeType":"ElementaryTypeName","src":"23841:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"23840:28:120"},"returnParameters":{"id":59281,"nodeType":"ParameterList","parameters":[{"constant":false,"id":59280,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":59298,"src":"23887:7:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":59279,"name":"address","nodeType":"ElementaryTypeName","src":"23887:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"23886:9:120"},"scope":59299,"stateMutability":"nonpayable","virtual":false,"visibility":"internal"}],"abstract":false,"baseContracts":[{"baseName":{"id":58250,"name":"Script","nameLocations":["13167:6:120"],"nodeType":"IdentifierPath","referencedDeclaration":6037,"src":"13167:6:120"},"id":58251,"nodeType":"InheritanceSpecifier","src":"13167:6:120"}],"canonicalName":"FetchChainInfo","contractDependencies":[],"contractKind":"contract","fullyImplemented":true,"linearizedBaseContracts":[59299,6037,18860,11701,9611,5996,5984],"name":"FetchChainInfo","nameLocation":"13149:14:120","scope":59300,"usedErrors":[],"usedEvents":[]}],"license":"MIT"},"id":120} \ No newline at end of file +{"abi":[{"type":"function","name":"IS_SCRIPT","inputs":[],"outputs":[{"name":"","type":"bool","internalType":"bool"}],"stateMutability":"view"},{"type":"function","name":"run","inputs":[{"name":"_fi","type":"address","internalType":"contract FetchChainInfoInput"},{"name":"_fo","type":"address","internalType":"contract FetchChainInfoOutput"}],"outputs":[],"stateMutability":"nonpayable"}],"bytecode":{"object":"0x60806040526001600c5f6101000a81548160ff0219169083151502179055506001600c60026101000a81548160ff0219169083151502179055503480156043575f5ffd5b5061273a806100515f395ff3fe608060405234801561000f575f5ffd5b5060043610610034575f3560e01c8063f8ccbf4714610038578063fc4dcacb14610056575b5f5ffd5b610040610072565b60405161004d91906122a9565b60405180910390f35b610070600480360381019061006b919061236c565b610085565b005b600c60029054906101000a900460ff1681565b61008f82826100a6565b610099828261061a565b6100a281610a4a565b5050565b5f8273ffffffffffffffffffffffffffffffffffffffff1663c17db6e36040518163ffffffff1660e01b8152600401602060405180830381865afa1580156100f0573d5f5f3e3d5ffd5b505050506040513d601f19601f8201168201806040525081019061011491906123d4565b90508173ffffffffffffffffffffffffffffffffffffffff1663c3e3925063c17db6e360e01b836040518363ffffffff1660e01b8152600401610158929190612448565b5f604051808303815f87803b15801561016f575f5ffd5b505af1158015610181573d5f5f3e3d5ffd5b505050505f8173ffffffffffffffffffffffffffffffffffffffff16638da5cb5b6040518163ffffffff1660e01b8152600401602060405180830381865afa1580156101cf573d5f5f3e3d5ffd5b505050506040513d601f19601f820116820180604052508101906101f391906123d4565b90508273ffffffffffffffffffffffffffffffffffffffff1663c3e39250631e229b2060e01b836040518363ffffffff1660e01b8152600401610237929190612448565b5f604051808303815f87803b15801561024e575f5ffd5b505af1158015610260573d5f5f3e3d5ffd5b505050505f8273ffffffffffffffffffffffffffffffffffffffff16631fd19ee16040518163ffffffff1660e01b8152600401602060405180830381865afa1580156102ae573d5f5f3e3d5ffd5b505050506040513d601f19601f820116820180604052508101906102d291906123d4565b90508373ffffffffffffffffffffffffffffffffffffffff1663c3e39250631fd19ee160e01b836040518363ffffffff1660e01b8152600401610316929190612448565b5f604051808303815f87803b15801561032d575f5ffd5b505af115801561033f573d5f5f3e3d5ffd5b505050505f61034d84611979565b90508473ffffffffffffffffffffffffffffffffffffffff1663c3e3925063fb951e9d60e01b836040518363ffffffff1660e01b8152600401610391929190612448565b5f604051808303815f87803b1580156103a8575f5ffd5b505af11580156103ba573d5f5f3e3d5ffd5b505050505f6103c8856119f5565b90508573ffffffffffffffffffffffffffffffffffffffff1663c3e39250635643665f60e01b836040518363ffffffff1660e01b815260040161040c929190612448565b5f604051808303815f87803b158015610423575f5ffd5b505af1158015610435573d5f5f3e3d5ffd5b505050505f8173ffffffffffffffffffffffffffffffffffffffff16638da5cb5b6040518163ffffffff1660e01b8152600401602060405180830381865afa158015610483573d5f5f3e3d5ffd5b505050506040513d601f19601f820116820180604052508101906104a791906123d4565b90508673ffffffffffffffffffffffffffffffffffffffff1663c3e39250631480f0cc60e01b836040518363ffffffff1660e01b81526004016104eb929190612448565b5f604051808303815f87803b158015610502575f5ffd5b505af1158015610514573d5f5f3e3d5ffd5b505050505f61052287611ae4565b90508773ffffffffffffffffffffffffffffffffffffffff1663c3e3925063ebfa840960e01b836040518363ffffffff1660e01b8152600401610566929190612448565b5f604051808303815f87803b15801561057d575f5ffd5b505af115801561058f573d5f5f3e3d5ffd5b505050505f61059d88611b63565b90508873ffffffffffffffffffffffffffffffffffffffff1663c3e39250638f20c7e460e01b836040518363ffffffff1660e01b81526004016105e1929190612448565b5f604051808303815f87803b1580156105f8575f5ffd5b505af115801561060a573d5f5f3e3d5ffd5b5050505050505050505050505050565b5f8273ffffffffffffffffffffffffffffffffffffffff1663102b60696040518163ffffffff1660e01b8152600401602060405180830381865afa158015610664573d5f5f3e3d5ffd5b505050506040513d601f19601f8201168201806040525081019061068891906123d4565b90508173ffffffffffffffffffffffffffffffffffffffff1663c3e3925063102b606960e01b836040518363ffffffff1660e01b81526004016106cc929190612448565b5f604051808303815f87803b1580156106e3575f5ffd5b505af11580156106f5573d5f5f3e3d5ffd5b505050505f8173ffffffffffffffffffffffffffffffffffffffff16633cb747bf6040518163ffffffff1660e01b8152600401602060405180830381865afa158015610743573d5f5f3e3d5ffd5b505050506040513d601f19601f8201168201806040525081019061076791906123d4565b90508273ffffffffffffffffffffffffffffffffffffffff1663c3e392506354729cfb60e01b836040518363ffffffff1660e01b81526004016107ab929190612448565b5f604051808303815f87803b1580156107c2575f5ffd5b505af11580156107d4573d5f5f3e3d5ffd5b505050505f6107e282611be2565b90508373ffffffffffffffffffffffffffffffffffffffff1663c3e3925063bd366b8f60e01b836040518363ffffffff1660e01b8152600401610826929190612448565b5f604051808303815f87803b15801561083d575f5ffd5b505af115801561084f573d5f5f3e3d5ffd5b505050505f61085d83611cad565b90508473ffffffffffffffffffffffffffffffffffffffff1663c3e392506304451c4960e01b836040518363ffffffff1660e01b81526004016108a1929190612448565b5f604051808303815f87803b1580156108b8575f5ffd5b505af11580156108ca573d5f5f3e3d5ffd5b505050505f6108d882611d98565b90508573ffffffffffffffffffffffffffffffffffffffff1663c3e39250634bc2695f60e01b836040518363ffffffff1660e01b815260040161091c929190612448565b5f604051808303815f87803b158015610933575f5ffd5b505af1158015610945573d5f5f3e3d5ffd5b505050505f61095383611e83565b90508673ffffffffffffffffffffffffffffffffffffffff1663c3e3925063f646b07c60e01b836040518363ffffffff1660e01b8152600401610997929190612448565b5f604051808303815f87803b1580156109ae575f5ffd5b505af11580156109c0573d5f5f3e3d5ffd5b505050505f6109ce84611f02565b90508773ffffffffffffffffffffffffffffffffffffffff1663c3e392506384cf2c9760e01b836040518363ffffffff1660e01b8152600401610a12929190612448565b5f604051808303815f87803b158015610a29575f5ffd5b505af1158015610a3b573d5f5f3e3d5ffd5b50505050505050505050505050565b5f8173ffffffffffffffffffffffffffffffffffffffff1663c17db6e36040518163ffffffff1660e01b8152600401602060405180830381865afa158015610a94573d5f5f3e3d5ffd5b505050506040513d601f19601f82011682018060405250810190610ab891906123d4565b90505f8273ffffffffffffffffffffffffffffffffffffffff166304451c496040518163ffffffff1660e01b8152600401602060405180830381865afa158015610b04573d5f5f3e3d5ffd5b505050506040513d601f19601f82011682018060405250810190610b2891906123d4565b90508073ffffffffffffffffffffffffffffffffffffffff16633c9f397c6040518163ffffffff1660e01b8152600401602060405180830381865afa925050508015610b9257506040513d601f19601f82011682018060405250810190610b8f91906124a8565b60015b610e45578273ffffffffffffffffffffffffffffffffffffffff1663d08d6066633c9f397c60e01b63ffffffff6040518363ffffffff1660e01b8152600401610bdc92919061250c565b5f604051808303815f87803b158015610bf3575f5ffd5b505af1158015610c05573d5f5f3e3d5ffd5b505050505f8173ffffffffffffffffffffffffffffffffffffffff16639b5f694a6040518163ffffffff1660e01b8152600401602060405180830381865afa925050508015610c7257506040513d601f19601f82011682018060405250810190610c6f91906123d4565b60015b610ce9578173ffffffffffffffffffffffffffffffffffffffff16621c2ff66040518163ffffffff1660e01b8152600401602060405180830381865afa158015610cbe573d5f5f3e3d5ffd5b505050506040513d601f19601f82011682018060405250810190610ce291906123d4565b9050610cee565b809150505b8373ffffffffffffffffffffffffffffffffffffffff1663c3e3925063a2c9a89f60e01b836040518363ffffffff1660e01b8152600401610d30929190612448565b5f604051808303815f87803b158015610d47575f5ffd5b505af1158015610d59573d5f5f3e3d5ffd5b505050505f8173ffffffffffffffffffffffffffffffffffffffff1663bffa7f0f6040518163ffffffff1660e01b8152600401602060405180830381865afa158015610da7573d5f5f3e3d5ffd5b505050506040513d601f19601f82011682018060405250810190610dcb91906123d4565b90508473ffffffffffffffffffffffffffffffffffffffff1663c3e3925063a8e4fb9060e01b836040518363ffffffff1660e01b8152600401610e0f929190612448565b5f604051808303815f87803b158015610e26575f5ffd5b505af1158015610e38573d5f5f3e3d5ffd5b5050505050505050611976565b8373ffffffffffffffffffffffffffffffffffffffff1663d08d6066633c9f397c60e01b836040518363ffffffff1660e01b8152600401610e8792919061250c565b5f604051808303815f87803b158015610e9e575f5ffd5b505af1158015610eb0573d5f5f3e3d5ffd5b50505050505f610ebf83611f81565b90505f73ffffffffffffffffffffffffffffffffffffffff168173ffffffffffffffffffffffffffffffffffffffff16146117b2578373ffffffffffffffffffffffffffffffffffffffff1663c3e39250636c4568d160e01b836040518363ffffffff1660e01b8152600401610f36929190612448565b5f604051808303815f87803b158015610f4d575f5ffd5b505af1158015610f5f573d5f5f3e3d5ffd5b505050505f610f6d82612000565b90505f73ffffffffffffffffffffffffffffffffffffffff168173ffffffffffffffffffffffffffffffffffffffff161461155e578473ffffffffffffffffffffffffffffffffffffffff1663baa1e15e633cc162f160e01b60016040518363ffffffff1660e01b8152600401610fe5929190612533565b5f604051808303815f87803b158015610ffc575f5ffd5b505af115801561100e573d5f5f3e3d5ffd5b505050508473ffffffffffffffffffffffffffffffffffffffff1663c3e392506398ccec3e60e01b836040518363ffffffff1660e01b8152600401611054929190612448565b5f604051808303815f87803b15801561106b575f5ffd5b505af115801561107d573d5f5f3e3d5ffd5b505050505f8173ffffffffffffffffffffffffffffffffffffffff1663534db0e26040518163ffffffff1660e01b8152600401602060405180830381865afa1580156110cb573d5f5f3e3d5ffd5b505050506040513d601f19601f820116820180604052508101906110ef91906123d4565b90508573ffffffffffffffffffffffffffffffffffffffff1663c3e3925063534db0e260e01b836040518363ffffffff1660e01b8152600401611133929190612448565b5f604051808303815f87803b15801561114a575f5ffd5b505af115801561115c573d5f5f3e3d5ffd5b505050505f8273ffffffffffffffffffffffffffffffffffffffff16635c0cba336040518163ffffffff1660e01b8152600401602060405180830381865afa1580156111aa573d5f5f3e3d5ffd5b505050506040513d601f19601f820116820180604052508101906111ce91906123d4565b90508673ffffffffffffffffffffffffffffffffffffffff1663c3e392506335596f7660e01b836040518363ffffffff1660e01b8152600401611212929190612448565b5f604051808303815f87803b158015611229575f5ffd5b505af115801561123b573d5f5f3e3d5ffd5b505050505f8373ffffffffffffffffffffffffffffffffffffffff1663a8e4fb906040518163ffffffff1660e01b8152600401602060405180830381865afa158015611289573d5f5f3e3d5ffd5b505050506040513d601f19601f820116820180604052508101906112ad91906123d4565b90508773ffffffffffffffffffffffffffffffffffffffff1663c3e3925063a8e4fb9060e01b836040518363ffffffff1660e01b81526004016112f1929190612448565b5f604051808303815f87803b158015611308575f5ffd5b505af115801561131a573d5f5f3e3d5ffd5b505050505f6113288561208b565b90508873ffffffffffffffffffffffffffffffffffffffff1663c3e3925063794836d760e01b836040518363ffffffff1660e01b815260040161136c929190612448565b5f604051808303815f87803b158015611383575f5ffd5b505af1158015611395573d5f5f3e3d5ffd5b505050505f8573ffffffffffffffffffffffffffffffffffffffff16633a7684636040518163ffffffff1660e01b8152600401602060405180830381865afa1580156113e3573d5f5f3e3d5ffd5b505050506040513d601f19601f8201168201806040525081019061140791906123d4565b90508973ffffffffffffffffffffffffffffffffffffffff1663c3e3925063e303272c60e01b836040518363ffffffff1660e01b815260040161144b929190612448565b5f604051808303815f87803b158015611462575f5ffd5b505af1158015611474573d5f5f3e3d5ffd5b505050505f8173ffffffffffffffffffffffffffffffffffffffff16637dc0d1d06040518163ffffffff1660e01b8152600401602060405180830381865afa1580156114c2573d5f5f3e3d5ffd5b505050506040513d601f19601f820116820180604052508101906114e691906123d4565b90508a73ffffffffffffffffffffffffffffffffffffffff1663c3e3925063d030d2e860e01b836040518363ffffffff1660e01b815260040161152a929190612448565b5f604051808303815f87803b158015611541575f5ffd5b505af1158015611553573d5f5f3e3d5ffd5b505050505050505050505b5f6115688361217a565b90505f73ffffffffffffffffffffffffffffffffffffffff168173ffffffffffffffffffffffffffffffffffffffff16146116f9578573ffffffffffffffffffffffffffffffffffffffff1663c3e3925063dea2198460e01b836040518363ffffffff1660e01b81526004016115df929190612448565b5f604051808303815f87803b1580156115f6575f5ffd5b505af1158015611608573d5f5f3e3d5ffd5b505050508573ffffffffffffffffffffffffffffffffffffffff1663baa1e15e63a1256f9f60e01b60016040518363ffffffff1660e01b815260040161164f929190612533565b5f604051808303815f87803b158015611666575f5ffd5b505af1158015611678573d5f5f3e3d5ffd5b505050505f6116868261208b565b90508673ffffffffffffffffffffffffffffffffffffffff1663c3e39250639706879760e01b836040518363ffffffff1660e01b81526004016116ca929190612448565b5f604051808303815f87803b1580156116e1575f5ffd5b505af11580156116f3573d5f5f3e3d5ffd5b50505050505b5f611705846008612204565b90505f73ffffffffffffffffffffffffffffffffffffffff168173ffffffffffffffffffffffffffffffffffffffff16146117aa578673ffffffffffffffffffffffffffffffffffffffff1663c3e39250635d25b21d60e01b836040518363ffffffff1660e01b815260040161177c929190612448565b5f604051808303815f87803b158015611793575f5ffd5b505af11580156117a5573d5f5f3e3d5ffd5b505050505b505050611972565b5f8273ffffffffffffffffffffffffffffffffffffffff16621c2ff66040518163ffffffff1660e01b8152600401602060405180830381865afa1580156117fb573d5f5f3e3d5ffd5b505050506040513d601f19601f8201168201806040525081019061181f91906123d4565b90508473ffffffffffffffffffffffffffffffffffffffff1663c3e3925063a2c9a89f60e01b836040518363ffffffff1660e01b8152600401611863929190612448565b5f604051808303815f87803b15801561187a575f5ffd5b505af115801561188c573d5f5f3e3d5ffd5b505050505f8173ffffffffffffffffffffffffffffffffffffffff1663bffa7f0f6040518163ffffffff1660e01b8152600401602060405180830381865afa1580156118da573d5f5f3e3d5ffd5b505050506040513d601f19601f820116820180604052508101906118fe91906123d4565b90508573ffffffffffffffffffffffffffffffffffffffff1663c3e3925063a8e4fb9060e01b836040518363ffffffff1660e01b8152600401611942929190612448565b5f604051808303815f87803b158015611959575f5ffd5b505af115801561196b573d5f5f3e3d5ffd5b5050505050505b5050505b50565b5f5f8273ffffffffffffffffffffffffffffffffffffffff1663e81b2c6d6040518163ffffffff1660e01b8152600401602060405180830381865afa1580156119c4573d5f5f3e3d5ffd5b505050506040513d601f19601f820116820180604052508101906119e8919061258d565b9050805f1c915050919050565b5f737109709ecfa91a80626ff3989d68f67f5b1dd12d73ffffffffffffffffffffffffffffffffffffffff1663ca669fa75f6040518263ffffffff1660e01b8152600401611a4391906125b8565b5f604051808303815f87803b158015611a5a575f5ffd5b505af1158015611a6c573d5f5f3e3d5ffd5b505050508173ffffffffffffffffffffffffffffffffffffffff1663f851a4406040518163ffffffff1660e01b8152600401602060405180830381865afa158015611ab9573d5f5f3e3d5ffd5b505050506040513d601f19601f82011682018060405250810190611add91906123d4565b9050919050565b5f8173ffffffffffffffffffffffffffffffffffffffff1663c4e8ddfa6040518163ffffffff1660e01b8152600401602060405180830381865afa925050508015611b4d57506040513d601f19601f82011682018060405250810190611b4a91906123d4565b60015b611b59575f9050611b5e565b809150505b919050565b5f8173ffffffffffffffffffffffffffffffffffffffff16639b7d7f0a6040518163ffffffff1660e01b8152600401602060405180830381865afa925050508015611bcc57506040513d601f19601f82011682018060405250810190611bc991906123d4565b60015b611bd8575f9050611bdd565b809150505b919050565b5f5f600190505f8382604051602001611bfc9291906125e9565b604051602081830303815290604052805190602001209050737109709ecfa91a80626ff3989d68f67f5b1dd12d73ffffffffffffffffffffffffffffffffffffffff1663667f9d7085836040518363ffffffff1660e01b8152600401611c6392919061261f565b602060405180830381865afa158015611c7e573d5f5f3e3d5ffd5b505050506040513d601f19601f82011682018060405250810190611ca2919061258d565b5f1c92505050919050565b5f8173ffffffffffffffffffffffffffffffffffffffff16636425666b6040518163ffffffff1660e01b8152600401602060405180830381865afa925050508015611d1657506040513d601f19601f82011682018060405250810190611d1391906123d4565b60015b611d8e578173ffffffffffffffffffffffffffffffffffffffff16630ff754ea6040518163ffffffff1660e01b8152600401602060405180830381865afa158015611d63573d5f5f3e3d5ffd5b505050506040513d601f19601f82011682018060405250810190611d8791906123d4565b9050611d93565b809150505b919050565b5f8173ffffffffffffffffffffffffffffffffffffffff1663452a93206040518163ffffffff1660e01b8152600401602060405180830381865afa925050508015611e0157506040513d601f19601f82011682018060405250810190611dfe91906123d4565b60015b611e79578173ffffffffffffffffffffffffffffffffffffffff1663724c184c6040518163ffffffff1660e01b8152600401602060405180830381865afa158015611e4e573d5f5f3e3d5ffd5b505050506040513d601f19601f82011682018060405250810190611e7291906123d4565b9050611e7e565b809150505b919050565b5f8173ffffffffffffffffffffffffffffffffffffffff1663b682c4446040518163ffffffff1660e01b8152600401602060405180830381865afa925050508015611eec57506040513d601f19601f82011682018060405250810190611ee991906123d4565b60015b611ef8575f9050611efd565b809150505b919050565b5f8173ffffffffffffffffffffffffffffffffffffffff166335e80ab36040518163ffffffff1660e01b8152600401602060405180830381865afa925050508015611f6b57506040513d601f19601f82011682018060405250810190611f6891906123d4565b60015b611f77575f9050611f7c565b809150505b919050565b5f8173ffffffffffffffffffffffffffffffffffffffff1663f2b4e6176040518163ffffffff1660e01b8152600401602060405180830381865afa925050508015611fea57506040513d601f19601f82011682018060405250810190611fe791906123d4565b60015b611ff6575f9050611ffb565b809150505b919050565b5f8173ffffffffffffffffffffffffffffffffffffffff16631b685b9e60016040518263ffffffff1660e01b815260040161203b9190612646565b602060405180830381865afa92505050801561207557506040513d601f19601f8201168201806040525081019061207291906123d4565b60015b612081575f9050612086565b809150505b919050565b5f5f5f8373ffffffffffffffffffffffffffffffffffffffff16604051602401604051602081830303815290604052633fc8cef360e01b6020820180517bffffffffffffffffffffffffffffffffffffffffffffffffffffffff83818316178352505050506040516120fd91906126b1565b5f60405180830381855afa9150503d805f8114612135576040519150601f19603f3d011682016040523d82523d5f602084013e61213a565b606091505b509150915081801561214d575060208151145b1561216f57808060200190518101906121669190612702565b92505050612175565b5f925050505b919050565b5f8173ffffffffffffffffffffffffffffffffffffffff16631b685b9e5f6040518263ffffffff1660e01b81526004016121b49190612646565b602060405180830381865afa9250505080156121ee57506040513d601f19601f820116820180604052508101906121eb91906123d4565b60015b6121fa575f90506121ff565b809150505b919050565b5f8273ffffffffffffffffffffffffffffffffffffffff16631b685b9e836040518263ffffffff1660e01b815260040161223e9190612646565b602060405180830381865afa92505050801561227857506040513d601f19601f8201168201806040525081019061227591906123d4565b60015b612284575f9050612289565b809150505b92915050565b5f8115159050919050565b6122a38161228f565b82525050565b5f6020820190506122bc5f83018461229a565b92915050565b5f5ffd5b5f73ffffffffffffffffffffffffffffffffffffffff82169050919050565b5f6122ef826122c6565b9050919050565b5f612300826122e5565b9050919050565b612310816122f6565b811461231a575f5ffd5b50565b5f8135905061232b81612307565b92915050565b5f61233b826122e5565b9050919050565b61234b81612331565b8114612355575f5ffd5b50565b5f8135905061236681612342565b92915050565b5f5f60408385031215612382576123816122c2565b5b5f61238f8582860161231d565b92505060206123a085828601612358565b9150509250929050565b6123b3816122e5565b81146123bd575f5ffd5b50565b5f815190506123ce816123aa565b92915050565b5f602082840312156123e9576123e86122c2565b5b5f6123f6848285016123c0565b91505092915050565b5f7fffffffff0000000000000000000000000000000000000000000000000000000082169050919050565b612433816123ff565b82525050565b612442816122e5565b82525050565b5f60408201905061245b5f83018561242a565b6124686020830184612439565b9392505050565b5f63ffffffff82169050919050565b6124878161246f565b8114612491575f5ffd5b50565b5f815190506124a28161247e565b92915050565b5f602082840312156124bd576124bc6122c2565b5b5f6124ca84828501612494565b91505092915050565b5f819050919050565b5f6124f66124f16124ec8461246f565b6124d3565b61246f565b9050919050565b612506816124dc565b82525050565b5f60408201905061251f5f83018561242a565b61252c60208301846124fd565b9392505050565b5f6040820190506125465f83018561242a565b612553602083018461229a565b9392505050565b5f819050919050565b61256c8161255a565b8114612576575f5ffd5b50565b5f8151905061258781612563565b92915050565b5f602082840312156125a2576125a16122c2565b5b5f6125af84828501612579565b91505092915050565b5f6020820190506125cb5f830184612439565b92915050565b5f819050919050565b6125e3816125d1565b82525050565b5f6040820190506125fc5f830185612439565b61260960208301846125da565b9392505050565b6126198161255a565b82525050565b5f6040820190506126325f830185612439565b61263f6020830184612610565b9392505050565b5f6020820190506126595f8301846124fd565b92915050565b5f81519050919050565b5f81905092915050565b8281835e5f83830152505050565b5f61268b8261265f565b6126958185612669565b93506126a5818560208601612673565b80840191505092915050565b5f6126bc8284612681565b915081905092915050565b5f6126d1826122c6565b9050919050565b6126e1816126c7565b81146126eb575f5ffd5b50565b5f815190506126fc816126d8565b92915050565b5f60208284031215612717576127166122c2565b5b5f612724848285016126ee565b9150509291505056fea164736f6c634300081b000a","sourceMap":"13601:11550:100:-:0;;;3166:4:39;3126:44;;;;;;;;;;;;;;;;;;;;873:4:37;849:28;;;;;;;;;;;;;;;;;;;;13601:11550:100;;;;;;;;;;;;;;;;","linkReferences":{}},"deployedBytecode":{"object":"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","sourceMap":"13601:11550:100:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;849:28:37;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;13641:198:100;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;849:28:37;;;;;;;;;;;;;:::o;13641:198:100:-;13722:30;13743:3;13748;13722:20;:30::i;:::-;13762:36;13789:3;13794;13762:26;:36::i;:::-;13808:24;13828:3;13808:19;:24::i;:::-;13641:198;;:::o;13845:1336::-;13945:25;13973:3;:21;;;:23;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;13945:51;;14006:3;:7;;;14014:30;;;14046:17;14006:58;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;14075:25;14112:17;14103:33;;;:35;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;14075:63;;14148:3;:7;;;14156:30;;;14188:17;14148:58;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;14217:25;14254:17;14245:45;;;:47;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;14217:75;;14302:3;:7;;;14310:30;;;14342:17;14302:58;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;14371:22;14396:37;14415:17;14396:18;:37::i;:::-;14371:62;;14443:3;:7;;;14451:27;;;14480:14;14443:52;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;14506:29;14538:33;14553:17;14538:14;:33::i;:::-;14506:65;;14581:3;:7;;;14589:34;;;14625:21;14581:66;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;14658:30;14700:21;14691:37;;;:39;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;14658:72;;14740:3;:7;;;14748:35;;;14785:22;14740:68;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;14819:27;14849:42;14873:17;14849:23;:42::i;:::-;14819:72;;14901:3;:7;;;14909:32;;;14943:19;14901:62;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;14974:41;15018:56;15056:17;15018:37;:56::i;:::-;14974:100;;15084:3;:7;;;15092:46;;;15140:33;15084:90;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;13935:1246;;;;;;;;13845:1336;;:::o;15187:1190::-;15293:29;15325:3;:25;;;:27;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;15293:59;;15362:3;:7;;;15370:34;;;15406:21;15362:66;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;15439:35;15486:21;15477:41;;;:43;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;15439:81;;15530:3;:7;;;15538:40;;;15580:27;15530:78;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;15619:26;15648:47;15667:27;15648:18;:47::i;:::-;15619:76;;15705:3;:7;;;15713:31;;;15746:18;15705:60;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;15776:27;15806:52;15830:27;15806:23;:52::i;:::-;15776:82;;15868:3;:7;;;15876:32;;;15910:19;15868:62;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;15941:23;15967:33;15980:19;15967:12;:33::i;:::-;15941:59;;16010:3;:7;;;16018:28;;;16048:15;16010:54;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;16075:23;16101:40;16121:19;16101;:40::i;:::-;16075:66;;16151:3;:7;;;16159:28;;;16189:15;16151:54;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;16216:29;16248:46;16274:19;16248:25;:46::i;:::-;16216:78;;16304:3;:7;;;16312:34;;;16348:21;16304:66;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;15283:1094;;;;;;;15187:1190;;:::o;16383:4033::-;16457:25;16485:3;:21;;;:23;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;16457:51;;16518:27;16548:3;:23;;;:25;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;16518:55;;16597:19;16588:47;;;:49;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;16584:909;;16836:3;:7;;;16844:30;;;16890:16;16836:72;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;16922:27;16976:19;16967:38;;;:40;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;16963:240;;17156:19;17147:39;;;:41;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;17125:63;;16963:240;;;17076:9;17054:31;;17008:92;16963:240;17216:3;:7;;;17224:32;;;17258:19;17216:62;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;17293:16;17321:19;17312:38;;;:40;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;17293:59;;17366:3;:7;;;17374:21;;;17397:8;17366:40;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;17476:7;;;;;;16584:909;16681:3;:7;;;16689:30;;;16721:9;16681:50;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;16638:104;17503:31;17537:46;17565:17;17537:27;:46::i;:::-;17503:80;;17632:1;17597:37;;:23;:37;;;17593:2817;;17650:3;:7;;;17658:36;;;17696:23;17650:70;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;17735:35;17773:52;17801:23;17773:27;:52::i;:::-;17735:90;;17882:1;17843:41;;:27;:41;;;17839:1278;;17959:3;:7;;;17967:25;;;17994:4;17959:40;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;18017:3;:7;;;18025:40;;;18067:27;18017:78;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;18114:18;18144:27;18135:48;;;:50;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;18114:71;;18203:3;:7;;;18211:23;;;18236:10;18203:44;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;18266:32;18310:27;18301:57;;;:59;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;18266:94;;18378:3;:7;;;18386:37;;;18425:24;18378:72;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;18469:16;18497:27;18488:46;;;:48;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;18469:67;;18554:3;:7;;;18562:21;;;18585:8;18554:40;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;18613;18656:49;18677:27;18656:20;:49::i;:::-;18613:92;;18723:3;:7;;;18731:45;;;18778:32;18723:88;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;18830:16;18858:27;18849:40;;;:42;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;18830:61;;18909:3;:7;;;18917:21;;;18940:8;18909:40;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;18968:26;19006:8;18997:25;;;:27;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;18968:56;;19042:3;:7;;;19050:31;;;19083:18;19042:60;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;17886:1231;;;;;;17839:1278;19131:28;19162:45;19183:23;19162:20;:45::i;:::-;19131:76;;19257:1;19225:34;;:20;:34;;;19221:470;;19336:3;:7;;;19344:33;;;19379:20;19336:64;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;19418:3;:7;;;19426:27;;;19455:4;19418:42;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;19479;19524;19545:20;19524;:42::i;:::-;19479:87;;19584:3;:7;;;19592:47;;;19641:34;19584:92;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;19261:430;19221:470;19705:38;19762:68;19783:23;2662:1:129;19762:20:100;:68::i;:::-;19705:125;;19890:1;19848:44;;:30;:44;;;19844:167;;19912:3;:7;;;19920:43;;;19965:30;19912:84;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;19844:167;17636:2385;;;17593:2817;;;20125:27;20164:19;20155:39;;;:41;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;20125:71;;20210:3;:7;;;20218:32;;;20252:19;20210:62;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;20286:16;20314:19;20305:38;;;:40;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;20286:59;;20359:3;:7;;;20367:21;;;20390:8;20359:40;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;20027:383;;17593:2817;16447:3969;;;16383:4033;;:::o;24750:224::-;24829:7;24848:19;24879:18;24870:40;;;:42;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;24848:64;;24953:11;24945:20;;24922:45;;;24750:224;;;:::o;24980:169::-;25050:7;336:42:36;25069:8:100;;;25086:1;25069:20;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;25115:18;25106:34;;;:36;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;25099:43;;24980:169;;;:::o;21672:299::-;21756:7;21788:18;21779:43;;;:45;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;21775:190;;21952:1;21937:17;;;;21775:190;21885:20;21878:27;;;21672:299;;;;:::o;21977:377::-;22075:7;22107:18;22098:57;;;:59;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;22094:254;;22335:1;22320:17;;;;22094:254;22254:34;22247:41;;;21977:377;;;;:::o;21316:350::-;21405:7;21424:36;21463:1;21424:40;;21474:12;21510:28;21540;21499:70;;;;;;;;;:::i;:::-;;;;;;;;;;;;;21489:81;;;;;;21474:96;;336:42:36;21612:7:100;;;21620:28;21650:4;21612:43;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;21603:54;;21580:79;;;;21316:350;;;:::o;20972:338::-;21066:7;21098:28;21089:45;;;:47;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;21085:219;;21255:28;21246:45;;;:47;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;21239:54;;;;21085:219;21192:15;21185:22;;;20972:338;;;;:::o;20422:256::-;20484:7;20516;20507:26;;;:28;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;20503:169;;20642:7;20633:26;;;:28;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;20626:35;;;;20503:169;20585:9;20578:16;;;20422:256;;;;:::o;24157:277::-;24239:7;24271:20;24262:41;;;:43;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;24258:170;;24415:1;24400:17;;;;24258:170;24357:11;24350:18;;;24157:277;;;;:::o;22764:311::-;22852:7;22884:20;22875:47;;;:49;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;22871:198;;23056:1;23041:17;;;;22871:198;22987:22;22980:29;;;22764:311;;;;:::o;22360:398::-;22448:7;22480:18;22471:47;;;:49;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;22467:285;;22739:1;22724:17;;;;22467:285;22585:24;22578:31;;;22360:398;;;;:::o;23782:369::-;23876:7;23908:24;23899:44;;;1677:1:129;23899:75:100;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;23895:250;;24132:1;24117:17;;;;23895:250;24061:24;24054:31;;;23782:369;;;;:::o;24440:304::-;24515:7;24535;24544:17;24573:12;24565:32;;24598:33;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;24565:67;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;24534:98;;;;24646:2;:23;;;;;24667:2;24652:4;:11;:17;24646:23;24642:95;;;24689:4;24678:27;;;;;;;;;;;;:::i;:::-;24671:34;;;;;;24642:95;24735:1;24720:17;;;;24440:304;;;;:::o;23081:313::-;23168:7;23200:24;23191:44;;;1534:1:129;23191:62:100;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;23187:201;;23375:1;23360:17;;;;23187:201;23311:17;23304:24;;;23081:313;;;;:::o;23400:376::-;23553:7;23589:24;23580:44;;;23625:9;23580:55;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;23576:194;;23757:1;23742:17;;;;23576:194;23693:17;23686:24;;;23400:376;;;;;:::o;7:90:182:-;41:7;84:5;77:13;70:21;59:32;;7:90;;;:::o;103:109::-;184:21;199:5;184:21;:::i;:::-;179:3;172:34;103:109;;:::o;218:210::-;305:4;343:2;332:9;328:18;320:26;;356:65;418:1;407:9;403:17;394:6;356:65;:::i;:::-;218:210;;;;:::o;515:117::-;624:1;621;614:12;761:126;798:7;838:42;831:5;827:54;816:65;;761:126;;;:::o;893:96::-;930:7;959:24;977:5;959:24;:::i;:::-;948:35;;893:96;;;:::o;995:125::-;1061:7;1090:24;1108:5;1090:24;:::i;:::-;1079:35;;995:125;;;:::o;1126:180::-;1228:53;1275:5;1228:53;:::i;:::-;1221:5;1218:64;1208:92;;1296:1;1293;1286:12;1208:92;1126:180;:::o;1312:197::-;1387:5;1425:6;1412:20;1403:29;;1441:62;1497:5;1441:62;:::i;:::-;1312:197;;;;:::o;1515:126::-;1582:7;1611:24;1629:5;1611:24;:::i;:::-;1600:35;;1515:126;;;:::o;1647:182::-;1750:54;1798:5;1750:54;:::i;:::-;1743:5;1740:65;1730:93;;1819:1;1816;1809:12;1730:93;1647:182;:::o;1835:199::-;1911:5;1949:6;1936:20;1927:29;;1965:63;2022:5;1965:63;:::i;:::-;1835:199;;;;:::o;2040:592::-;2167:6;2175;2224:2;2212:9;2203:7;2199:23;2195:32;2192:119;;;2230:79;;:::i;:::-;2192:119;2350:1;2375:82;2449:7;2440:6;2429:9;2425:22;2375:82;:::i;:::-;2365:92;;2321:146;2506:2;2532:83;2607:7;2598:6;2587:9;2583:22;2532:83;:::i;:::-;2522:93;;2477:148;2040:592;;;;;:::o;2638:122::-;2711:24;2729:5;2711:24;:::i;:::-;2704:5;2701:35;2691:63;;2750:1;2747;2740:12;2691:63;2638:122;:::o;2766:143::-;2823:5;2854:6;2848:13;2839:22;;2870:33;2897:5;2870:33;:::i;:::-;2766:143;;;;:::o;2915:351::-;2985:6;3034:2;3022:9;3013:7;3009:23;3005:32;3002:119;;;3040:79;;:::i;:::-;3002:119;3160:1;3185:64;3241:7;3232:6;3221:9;3217:22;3185:64;:::i;:::-;3175:74;;3131:128;2915:351;;;;:::o;3272:149::-;3308:7;3348:66;3341:5;3337:78;3326:89;;3272:149;;;:::o;3427:115::-;3512:23;3529:5;3512:23;:::i;:::-;3507:3;3500:36;3427:115;;:::o;3548:118::-;3635:24;3653:5;3635:24;:::i;:::-;3630:3;3623:37;3548:118;;:::o;3672:328::-;3791:4;3829:2;3818:9;3814:18;3806:26;;3842:69;3908:1;3897:9;3893:17;3884:6;3842:69;:::i;:::-;3921:72;3989:2;3978:9;3974:18;3965:6;3921:72;:::i;:::-;3672:328;;;;;:::o;4006:93::-;4042:7;4082:10;4075:5;4071:22;4060:33;;4006:93;;;:::o;4105:151::-;4208:23;4225:5;4208:23;:::i;:::-;4201:5;4198:34;4188:62;;4246:1;4243;4236:12;4188:62;4105:151;:::o;4262:203::-;4349:5;4380:6;4374:13;4365:22;;4396:63;4453:5;4396:63;:::i;:::-;4262:203;;;;:::o;4471:411::-;4571:6;4620:2;4608:9;4599:7;4595:23;4591:32;4588:119;;;4626:79;;:::i;:::-;4588:119;4746:1;4771:94;4857:7;4848:6;4837:9;4833:22;4771:94;:::i;:::-;4761:104;;4717:158;4471:411;;;;:::o;4888:60::-;4916:3;4937:5;4930:12;;4888:60;;;:::o;4954:138::-;5002:9;5035:51;5052:33;5061:23;5078:5;5061:23;:::i;:::-;5052:33;:::i;:::-;5035:51;:::i;:::-;5022:64;;4954:138;;;:::o;5098:158::-;5214:35;5243:5;5214:35;:::i;:::-;5209:3;5202:48;5098:158;;:::o;5262:386::-;5410:4;5448:2;5437:9;5433:18;5425:26;;5461:69;5527:1;5516:9;5512:17;5503:6;5461:69;:::i;:::-;5540:101;5637:2;5626:9;5622:18;5613:6;5540:101;:::i;:::-;5262:386;;;;;:::o;5654:316::-;5767:4;5805:2;5794:9;5790:18;5782:26;;5818:69;5884:1;5873:9;5869:17;5860:6;5818:69;:::i;:::-;5897:66;5959:2;5948:9;5944:18;5935:6;5897:66;:::i;:::-;5654:316;;;;;:::o;5976:77::-;6013:7;6042:5;6031:16;;5976:77;;;:::o;6059:122::-;6132:24;6150:5;6132:24;:::i;:::-;6125:5;6122:35;6112:63;;6171:1;6168;6161:12;6112:63;6059:122;:::o;6187:143::-;6244:5;6275:6;6269:13;6260:22;;6291:33;6318:5;6291:33;:::i;:::-;6187:143;;;;:::o;6336:351::-;6406:6;6455:2;6443:9;6434:7;6430:23;6426:32;6423:119;;;6461:79;;:::i;:::-;6423:119;6581:1;6606:64;6662:7;6653:6;6642:9;6638:22;6606:64;:::i;:::-;6596:74;;6552:128;6336:351;;;;:::o;6693:222::-;6786:4;6824:2;6813:9;6809:18;6801:26;;6837:71;6905:1;6894:9;6890:17;6881:6;6837:71;:::i;:::-;6693:222;;;;:::o;6921:77::-;6958:7;6987:5;6976:16;;6921:77;;;:::o;7004:118::-;7091:24;7109:5;7091:24;:::i;:::-;7086:3;7079:37;7004:118;;:::o;7128:332::-;7249:4;7287:2;7276:9;7272:18;7264:26;;7300:71;7368:1;7357:9;7353:17;7344:6;7300:71;:::i;:::-;7381:72;7449:2;7438:9;7434:18;7425:6;7381:72;:::i;:::-;7128:332;;;;;:::o;7466:118::-;7553:24;7571:5;7553:24;:::i;:::-;7548:3;7541:37;7466:118;;:::o;7590:332::-;7711:4;7749:2;7738:9;7734:18;7726:26;;7762:71;7830:1;7819:9;7815:17;7806:6;7762:71;:::i;:::-;7843:72;7911:2;7900:9;7896:18;7887:6;7843:72;:::i;:::-;7590:332;;;;;:::o;7928:280::-;8050:4;8088:2;8077:9;8073:18;8065:26;;8101:100;8198:1;8187:9;8183:17;8174:6;8101:100;:::i;:::-;7928:280;;;;:::o;8214:98::-;8265:6;8299:5;8293:12;8283:22;;8214:98;;;:::o;8318:147::-;8419:11;8456:3;8441:18;;8318:147;;;;:::o;8471:139::-;8560:6;8555:3;8550;8544:23;8601:1;8592:6;8587:3;8583:16;8576:27;8471:139;;;:::o;8616:386::-;8720:3;8748:38;8780:5;8748:38;:::i;:::-;8802:88;8883:6;8878:3;8802:88;:::i;:::-;8795:95;;8899:65;8957:6;8952:3;8945:4;8938:5;8934:16;8899:65;:::i;:::-;8989:6;8984:3;8980:16;8973:23;;8724:278;8616:386;;;;:::o;9008:271::-;9138:3;9160:93;9249:3;9240:6;9160:93;:::i;:::-;9153:100;;9270:3;9263:10;;9008:271;;;;:::o;9285:104::-;9330:7;9359:24;9377:5;9359:24;:::i;:::-;9348:35;;9285:104;;;:::o;9395:138::-;9476:32;9502:5;9476:32;:::i;:::-;9469:5;9466:43;9456:71;;9523:1;9520;9513:12;9456:71;9395:138;:::o;9539:159::-;9604:5;9635:6;9629:13;9620:22;;9651:41;9686:5;9651:41;:::i;:::-;9539:159;;;;:::o;9704:367::-;9782:6;9831:2;9819:9;9810:7;9806:23;9802:32;9799:119;;;9837:79;;:::i;:::-;9799:119;9957:1;9982:72;10046:7;10037:6;10026:9;10022:22;9982:72;:::i;:::-;9972:82;;9928:136;9704:367;;;;:::o","linkReferences":{}},"methodIdentifiers":{"IS_SCRIPT()":"f8ccbf47","run(address,address)":"fc4dcacb"},"rawMetadata":"{\"compiler\":{\"version\":\"0.8.27+commit.40a35a09\"},\"language\":\"Solidity\",\"output\":{\"abi\":[{\"inputs\":[],\"name\":\"IS_SCRIPT\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"contract FetchChainInfoInput\",\"name\":\"_fi\",\"type\":\"address\"},{\"internalType\":\"contract FetchChainInfoOutput\",\"name\":\"_fo\",\"type\":\"address\"}],\"name\":\"run\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"}],\"devdoc\":{\"kind\":\"dev\",\"methods\":{},\"version\":1},\"userdoc\":{\"kind\":\"user\",\"methods\":{},\"version\":1}},\"settings\":{\"compilationTarget\":{\"scripts/FetchChainInfo.s.sol\":\"FetchChainInfo\"},\"evmVersion\":\"cancun\",\"libraries\":{},\"metadata\":{\"bytecodeHash\":\"none\",\"useLiteralContent\":true},\"optimizer\":{\"enabled\":false,\"runs\":0},\"remappings\":[\":@lib-keccak/=lib/lib-keccak/contracts/lib/\",\":@openzeppelin/contracts-upgradeable/=lib/openzeppelin-contracts-upgradeable/contracts/\",\":@openzeppelin/contracts-v5/=lib/openzeppelin-contracts-v5/contracts/\",\":@openzeppelin/contracts/=lib/openzeppelin-contracts/contracts/\",\":@rari-capital/solmate/=lib/solmate/\",\":@solady-test/=lib/lib-keccak/lib/solady/test/\",\":@solady-v0.0.245/=lib/solady-v0.0.245/src/\",\":@solady/=lib/solady/src/\",\":ds-test/=lib/forge-std/lib/ds-test/src/\",\":erc4626-tests/=lib/openzeppelin-contracts-v5/lib/erc4626-tests/\",\":forge-std/=lib/forge-std/src/\",\":interfaces/=interfaces/\",\":kontrol-cheatcodes/=lib/kontrol-cheatcodes/src/\",\":lib-keccak/=lib/lib-keccak/contracts/\",\":openzeppelin-contracts-upgradeable/=lib/openzeppelin-contracts-upgradeable/\",\":openzeppelin-contracts-v5/=lib/openzeppelin-contracts-v5/\",\":openzeppelin-contracts/=lib/openzeppelin-contracts/\",\":safe-contracts/=lib/safe-contracts/contracts/\",\":solady-v0.0.245/=lib/solady-v0.0.245/src/\",\":solady/=lib/solady/\",\":solmate/=lib/solmate/src/\"]},\"sources\":{\"lib/forge-std/src/Base.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity >=0.6.2 <0.9.0;\\n\\nimport {StdStorage} from \\\"./StdStorage.sol\\\";\\nimport {Vm, VmSafe} from \\\"./Vm.sol\\\";\\n\\nabstract contract CommonBase {\\n /// @dev Cheat code address.\\n /// Calculated as `address(uint160(uint256(keccak256(\\\"hevm cheat code\\\"))))`.\\n address internal constant VM_ADDRESS = 0x7109709ECfa91a80626fF3989D68f67F5b1DD12D;\\n /// @dev console.sol and console2.sol work by executing a staticcall to this address.\\n /// Calculated as `address(uint160(uint88(bytes11(\\\"console.log\\\"))))`.\\n address internal constant CONSOLE = 0x000000000000000000636F6e736F6c652e6c6f67;\\n /// @dev Used when deploying with create2.\\n /// Taken from https://github.com/Arachnid/deterministic-deployment-proxy.\\n address internal constant CREATE2_FACTORY = 0x4e59b44847b379578588920cA78FbF26c0B4956C;\\n /// @dev The default address for tx.origin and msg.sender.\\n /// Calculated as `address(uint160(uint256(keccak256(\\\"foundry default caller\\\"))))`.\\n address internal constant DEFAULT_SENDER = 0x1804c8AB1F12E6bbf3894d4083f33e07309d1f38;\\n /// @dev The address of the first contract `CREATE`d by a running test contract.\\n /// When running tests, each test contract is `CREATE`d by `DEFAULT_SENDER` with nonce 1.\\n /// Calculated as `VM.computeCreateAddress(VM.computeCreateAddress(DEFAULT_SENDER, 1), 1)`.\\n address internal constant DEFAULT_TEST_CONTRACT = 0x5615dEB798BB3E4dFa0139dFa1b3D433Cc23b72f;\\n /// @dev Deterministic deployment address of the Multicall3 contract.\\n /// Taken from https://www.multicall3.com.\\n address internal constant MULTICALL3_ADDRESS = 0xcA11bde05977b3631167028862bE2a173976CA11;\\n /// @dev The order of the secp256k1 curve.\\n uint256 internal constant SECP256K1_ORDER =\\n 115792089237316195423570985008687907852837564279074904382605163141518161494337;\\n\\n uint256 internal constant UINT256_MAX =\\n 115792089237316195423570985008687907853269984665640564039457584007913129639935;\\n\\n Vm internal constant vm = Vm(VM_ADDRESS);\\n StdStorage internal stdstore;\\n}\\n\\nabstract contract TestBase is CommonBase {}\\n\\nabstract contract ScriptBase is CommonBase {\\n VmSafe internal constant vmSafe = VmSafe(VM_ADDRESS);\\n}\\n\",\"keccak256\":\"0xa3735a6618a3014e42bb4329ad143e3b2c59cd95094350202e4c4a06c9d585dd\",\"license\":\"MIT\"},\"lib/forge-std/src/Script.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity >=0.6.2 <0.9.0;\\n\\n// \\ud83d\\udcac ABOUT\\n// Forge Std's default Script.\\n\\n// \\ud83e\\udde9 MODULES\\nimport {console} from \\\"./console.sol\\\";\\nimport {console2} from \\\"./console2.sol\\\";\\nimport {safeconsole} from \\\"./safeconsole.sol\\\";\\nimport {StdChains} from \\\"./StdChains.sol\\\";\\nimport {StdCheatsSafe} from \\\"./StdCheats.sol\\\";\\nimport {StdConstants} from \\\"./StdConstants.sol\\\";\\nimport {stdJson} from \\\"./StdJson.sol\\\";\\nimport {stdMath} from \\\"./StdMath.sol\\\";\\nimport {StdStorage, stdStorageSafe} from \\\"./StdStorage.sol\\\";\\nimport {StdStyle} from \\\"./StdStyle.sol\\\";\\nimport {StdUtils} from \\\"./StdUtils.sol\\\";\\nimport {VmSafe} from \\\"./Vm.sol\\\";\\n\\n// \\ud83d\\udce6 BOILERPLATE\\nimport {ScriptBase} from \\\"./Base.sol\\\";\\n\\n// \\u2b50\\ufe0f SCRIPT\\nabstract contract Script is ScriptBase, StdChains, StdCheatsSafe, StdUtils {\\n // Note: IS_SCRIPT() must return true.\\n bool public IS_SCRIPT = true;\\n}\\n\",\"keccak256\":\"0xc942e27c7baae499beb01afbbae99f24d42af9a6e4aae675bc6901b704aa8e9b\",\"license\":\"MIT\"},\"lib/forge-std/src/StdChains.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity >=0.6.2 <0.9.0;\\n\\nimport {VmSafe} from \\\"./Vm.sol\\\";\\n\\n/**\\n * StdChains provides information about EVM compatible chains that can be used in scripts/tests.\\n * For each chain, the chain's name, chain ID, and a default RPC URL are provided. Chains are\\n * identified by their alias, which is the same as the alias in the `[rpc_endpoints]` section of\\n * the `foundry.toml` file. For best UX, ensure the alias in the `foundry.toml` file match the\\n * alias used in this contract, which can be found as the first argument to the\\n * `setChainWithDefaultRpcUrl` call in the `initializeStdChains` function.\\n *\\n * There are two main ways to use this contract:\\n * 1. Set a chain with `setChain(string memory chainAlias, ChainData memory chain)` or\\n * `setChain(string memory chainAlias, Chain memory chain)`\\n * 2. Get a chain with `getChain(string memory chainAlias)` or `getChain(uint256 chainId)`.\\n *\\n * The first time either of those are used, chains are initialized with the default set of RPC URLs.\\n * This is done in `initializeStdChains`, which uses `setChainWithDefaultRpcUrl`. Defaults are recorded in\\n * `defaultRpcUrls`.\\n *\\n * The `setChain` function is straightforward, and it simply saves off the given chain data.\\n *\\n * The `getChain` methods use `getChainWithUpdatedRpcUrl` to return a chain. For example, let's say\\n * we want to retrieve the RPC URL for `mainnet`:\\n * - If you have specified data with `setChain`, it will return that.\\n * - If you have configured a mainnet RPC URL in `foundry.toml`, it will return the URL, provided it\\n * is valid (e.g. a URL is specified, or an environment variable is given and exists).\\n * - If neither of the above conditions is met, the default data is returned.\\n *\\n * Summarizing the above, the prioritization hierarchy is `setChain` -> `foundry.toml` -> environment variable -> defaults.\\n */\\nabstract contract StdChains {\\n VmSafe private constant vm = VmSafe(address(uint160(uint256(keccak256(\\\"hevm cheat code\\\")))));\\n\\n bool private stdChainsInitialized;\\n\\n struct ChainData {\\n string name;\\n uint256 chainId;\\n string rpcUrl;\\n }\\n\\n struct Chain {\\n // The chain name.\\n string name;\\n // The chain's Chain ID.\\n uint256 chainId;\\n // The chain's alias. (i.e. what gets specified in `foundry.toml`).\\n string chainAlias;\\n // A default RPC endpoint for this chain.\\n // NOTE: This default RPC URL is included for convenience to facilitate quick tests and\\n // experimentation. Do not use this RPC URL for production test suites, CI, or other heavy\\n // usage as you will be throttled and this is a disservice to others who need this endpoint.\\n string rpcUrl;\\n }\\n\\n // Maps from the chain's alias (matching the alias in the `foundry.toml` file) to chain data.\\n mapping(string => Chain) private chains;\\n // Maps from the chain's alias to it's default RPC URL.\\n mapping(string => string) private defaultRpcUrls;\\n // Maps from a chain ID to it's alias.\\n mapping(uint256 => string) private idToAlias;\\n\\n bool private fallbackToDefaultRpcUrls = true;\\n\\n // The RPC URL will be fetched from config or defaultRpcUrls if possible.\\n function getChain(string memory chainAlias) internal virtual returns (Chain memory chain) {\\n require(bytes(chainAlias).length != 0, \\\"StdChains getChain(string): Chain alias cannot be the empty string.\\\");\\n\\n initializeStdChains();\\n chain = chains[chainAlias];\\n require(\\n chain.chainId != 0,\\n string(abi.encodePacked(\\\"StdChains getChain(string): Chain with alias \\\\\\\"\\\", chainAlias, \\\"\\\\\\\" not found.\\\"))\\n );\\n\\n chain = getChainWithUpdatedRpcUrl(chainAlias, chain);\\n }\\n\\n function getChain(uint256 chainId) internal virtual returns (Chain memory chain) {\\n require(chainId != 0, \\\"StdChains getChain(uint256): Chain ID cannot be 0.\\\");\\n initializeStdChains();\\n string memory chainAlias = idToAlias[chainId];\\n\\n chain = chains[chainAlias];\\n\\n require(\\n chain.chainId != 0,\\n string(abi.encodePacked(\\\"StdChains getChain(uint256): Chain with ID \\\", vm.toString(chainId), \\\" not found.\\\"))\\n );\\n\\n chain = getChainWithUpdatedRpcUrl(chainAlias, chain);\\n }\\n\\n // set chain info, with priority to argument's rpcUrl field.\\n function setChain(string memory chainAlias, ChainData memory chain) internal virtual {\\n require(\\n bytes(chainAlias).length != 0,\\n \\\"StdChains setChain(string,ChainData): Chain alias cannot be the empty string.\\\"\\n );\\n\\n require(chain.chainId != 0, \\\"StdChains setChain(string,ChainData): Chain ID cannot be 0.\\\");\\n\\n initializeStdChains();\\n string memory foundAlias = idToAlias[chain.chainId];\\n\\n require(\\n bytes(foundAlias).length == 0 || keccak256(bytes(foundAlias)) == keccak256(bytes(chainAlias)),\\n string(\\n abi.encodePacked(\\n \\\"StdChains setChain(string,ChainData): Chain ID \\\",\\n vm.toString(chain.chainId),\\n \\\" already used by \\\\\\\"\\\",\\n foundAlias,\\n \\\"\\\\\\\".\\\"\\n )\\n )\\n );\\n\\n uint256 oldChainId = chains[chainAlias].chainId;\\n delete idToAlias[oldChainId];\\n\\n chains[chainAlias] =\\n Chain({name: chain.name, chainId: chain.chainId, chainAlias: chainAlias, rpcUrl: chain.rpcUrl});\\n idToAlias[chain.chainId] = chainAlias;\\n }\\n\\n // set chain info, with priority to argument's rpcUrl field.\\n function setChain(string memory chainAlias, Chain memory chain) internal virtual {\\n setChain(chainAlias, ChainData({name: chain.name, chainId: chain.chainId, rpcUrl: chain.rpcUrl}));\\n }\\n\\n function _toUpper(string memory str) private pure returns (string memory) {\\n bytes memory strb = bytes(str);\\n bytes memory copy = new bytes(strb.length);\\n for (uint256 i = 0; i < strb.length; i++) {\\n bytes1 b = strb[i];\\n if (b >= 0x61 && b <= 0x7A) {\\n copy[i] = bytes1(uint8(b) - 32);\\n } else {\\n copy[i] = b;\\n }\\n }\\n return string(copy);\\n }\\n\\n // lookup rpcUrl, in descending order of priority:\\n // current -> config (foundry.toml) -> environment variable -> default\\n function getChainWithUpdatedRpcUrl(string memory chainAlias, Chain memory chain)\\n private\\n view\\n returns (Chain memory)\\n {\\n if (bytes(chain.rpcUrl).length == 0) {\\n try vm.rpcUrl(chainAlias) returns (string memory configRpcUrl) {\\n chain.rpcUrl = configRpcUrl;\\n } catch (bytes memory err) {\\n string memory envName = string(abi.encodePacked(_toUpper(chainAlias), \\\"_RPC_URL\\\"));\\n if (fallbackToDefaultRpcUrls) {\\n chain.rpcUrl = vm.envOr(envName, defaultRpcUrls[chainAlias]);\\n } else {\\n chain.rpcUrl = vm.envString(envName);\\n }\\n // Distinguish 'not found' from 'cannot read'\\n // The upstream error thrown by forge for failing cheats changed so we check both the old and new versions\\n bytes memory oldNotFoundError =\\n abi.encodeWithSignature(\\\"CheatCodeError\\\", string(abi.encodePacked(\\\"invalid rpc url \\\", chainAlias)));\\n bytes memory newNotFoundError = abi.encodeWithSignature(\\n \\\"CheatcodeError(string)\\\", string(abi.encodePacked(\\\"invalid rpc url: \\\", chainAlias))\\n );\\n bytes32 errHash = keccak256(err);\\n if (\\n (errHash != keccak256(oldNotFoundError) && errHash != keccak256(newNotFoundError))\\n || bytes(chain.rpcUrl).length == 0\\n ) {\\n /// @solidity memory-safe-assembly\\n assembly {\\n revert(add(32, err), mload(err))\\n }\\n }\\n }\\n }\\n return chain;\\n }\\n\\n function setFallbackToDefaultRpcUrls(bool useDefault) internal {\\n fallbackToDefaultRpcUrls = useDefault;\\n }\\n\\n function initializeStdChains() private {\\n if (stdChainsInitialized) return;\\n\\n stdChainsInitialized = true;\\n\\n // If adding an RPC here, make sure to test the default RPC URL in `test_Rpcs` in `StdChains.t.sol`\\n setChainWithDefaultRpcUrl(\\\"anvil\\\", ChainData(\\\"Anvil\\\", 31337, \\\"http://127.0.0.1:8545\\\"));\\n setChainWithDefaultRpcUrl(\\\"mainnet\\\", ChainData(\\\"Mainnet\\\", 1, \\\"https://eth.llamarpc.com\\\"));\\n setChainWithDefaultRpcUrl(\\n \\\"sepolia\\\", ChainData(\\\"Sepolia\\\", 11155111, \\\"https://sepolia.infura.io/v3/b9794ad1ddf84dfb8c34d6bb5dca2001\\\")\\n );\\n setChainWithDefaultRpcUrl(\\\"holesky\\\", ChainData(\\\"Holesky\\\", 17000, \\\"https://rpc.holesky.ethpandaops.io\\\"));\\n setChainWithDefaultRpcUrl(\\\"optimism\\\", ChainData(\\\"Optimism\\\", 10, \\\"https://mainnet.optimism.io\\\"));\\n setChainWithDefaultRpcUrl(\\n \\\"optimism_sepolia\\\", ChainData(\\\"Optimism Sepolia\\\", 11155420, \\\"https://sepolia.optimism.io\\\")\\n );\\n setChainWithDefaultRpcUrl(\\\"arbitrum_one\\\", ChainData(\\\"Arbitrum One\\\", 42161, \\\"https://arb1.arbitrum.io/rpc\\\"));\\n setChainWithDefaultRpcUrl(\\n \\\"arbitrum_one_sepolia\\\", ChainData(\\\"Arbitrum One Sepolia\\\", 421614, \\\"https://sepolia-rollup.arbitrum.io/rpc\\\")\\n );\\n setChainWithDefaultRpcUrl(\\\"arbitrum_nova\\\", ChainData(\\\"Arbitrum Nova\\\", 42170, \\\"https://nova.arbitrum.io/rpc\\\"));\\n setChainWithDefaultRpcUrl(\\\"polygon\\\", ChainData(\\\"Polygon\\\", 137, \\\"https://polygon-rpc.com\\\"));\\n setChainWithDefaultRpcUrl(\\n \\\"polygon_amoy\\\", ChainData(\\\"Polygon Amoy\\\", 80002, \\\"https://rpc-amoy.polygon.technology\\\")\\n );\\n setChainWithDefaultRpcUrl(\\\"avalanche\\\", ChainData(\\\"Avalanche\\\", 43114, \\\"https://api.avax.network/ext/bc/C/rpc\\\"));\\n setChainWithDefaultRpcUrl(\\n \\\"avalanche_fuji\\\", ChainData(\\\"Avalanche Fuji\\\", 43113, \\\"https://api.avax-test.network/ext/bc/C/rpc\\\")\\n );\\n setChainWithDefaultRpcUrl(\\n \\\"bnb_smart_chain\\\", ChainData(\\\"BNB Smart Chain\\\", 56, \\\"https://bsc-dataseed1.binance.org\\\")\\n );\\n setChainWithDefaultRpcUrl(\\n \\\"bnb_smart_chain_testnet\\\",\\n ChainData(\\\"BNB Smart Chain Testnet\\\", 97, \\\"https://rpc.ankr.com/bsc_testnet_chapel\\\")\\n );\\n setChainWithDefaultRpcUrl(\\\"gnosis_chain\\\", ChainData(\\\"Gnosis Chain\\\", 100, \\\"https://rpc.gnosischain.com\\\"));\\n setChainWithDefaultRpcUrl(\\\"moonbeam\\\", ChainData(\\\"Moonbeam\\\", 1284, \\\"https://rpc.api.moonbeam.network\\\"));\\n setChainWithDefaultRpcUrl(\\n \\\"moonriver\\\", ChainData(\\\"Moonriver\\\", 1285, \\\"https://rpc.api.moonriver.moonbeam.network\\\")\\n );\\n setChainWithDefaultRpcUrl(\\\"moonbase\\\", ChainData(\\\"Moonbase\\\", 1287, \\\"https://rpc.testnet.moonbeam.network\\\"));\\n setChainWithDefaultRpcUrl(\\\"base_sepolia\\\", ChainData(\\\"Base Sepolia\\\", 84532, \\\"https://sepolia.base.org\\\"));\\n setChainWithDefaultRpcUrl(\\\"base\\\", ChainData(\\\"Base\\\", 8453, \\\"https://mainnet.base.org\\\"));\\n setChainWithDefaultRpcUrl(\\\"blast_sepolia\\\", ChainData(\\\"Blast Sepolia\\\", 168587773, \\\"https://sepolia.blast.io\\\"));\\n setChainWithDefaultRpcUrl(\\\"blast\\\", ChainData(\\\"Blast\\\", 81457, \\\"https://rpc.blast.io\\\"));\\n setChainWithDefaultRpcUrl(\\\"fantom_opera\\\", ChainData(\\\"Fantom Opera\\\", 250, \\\"https://rpc.ankr.com/fantom/\\\"));\\n setChainWithDefaultRpcUrl(\\n \\\"fantom_opera_testnet\\\", ChainData(\\\"Fantom Opera Testnet\\\", 4002, \\\"https://rpc.ankr.com/fantom_testnet/\\\")\\n );\\n setChainWithDefaultRpcUrl(\\\"fraxtal\\\", ChainData(\\\"Fraxtal\\\", 252, \\\"https://rpc.frax.com\\\"));\\n setChainWithDefaultRpcUrl(\\\"fraxtal_testnet\\\", ChainData(\\\"Fraxtal Testnet\\\", 2522, \\\"https://rpc.testnet.frax.com\\\"));\\n setChainWithDefaultRpcUrl(\\n \\\"berachain_bartio_testnet\\\", ChainData(\\\"Berachain bArtio Testnet\\\", 80084, \\\"https://bartio.rpc.berachain.com\\\")\\n );\\n setChainWithDefaultRpcUrl(\\\"flare\\\", ChainData(\\\"Flare\\\", 14, \\\"https://flare-api.flare.network/ext/C/rpc\\\"));\\n setChainWithDefaultRpcUrl(\\n \\\"flare_coston2\\\", ChainData(\\\"Flare Coston2\\\", 114, \\\"https://coston2-api.flare.network/ext/C/rpc\\\")\\n );\\n\\n setChainWithDefaultRpcUrl(\\\"mode\\\", ChainData(\\\"Mode\\\", 34443, \\\"https://mode.drpc.org\\\"));\\n setChainWithDefaultRpcUrl(\\\"mode_sepolia\\\", ChainData(\\\"Mode Sepolia\\\", 919, \\\"https://sepolia.mode.network\\\"));\\n\\n setChainWithDefaultRpcUrl(\\\"zora\\\", ChainData(\\\"Zora\\\", 7777777, \\\"https://zora.drpc.org\\\"));\\n setChainWithDefaultRpcUrl(\\n \\\"zora_sepolia\\\", ChainData(\\\"Zora Sepolia\\\", 999999999, \\\"https://sepolia.rpc.zora.energy\\\")\\n );\\n\\n setChainWithDefaultRpcUrl(\\\"race\\\", ChainData(\\\"Race\\\", 6805, \\\"https://racemainnet.io\\\"));\\n setChainWithDefaultRpcUrl(\\\"race_sepolia\\\", ChainData(\\\"Race Sepolia\\\", 6806, \\\"https://racemainnet.io\\\"));\\n\\n setChainWithDefaultRpcUrl(\\\"metal\\\", ChainData(\\\"Metal\\\", 1750, \\\"https://metall2.drpc.org\\\"));\\n setChainWithDefaultRpcUrl(\\\"metal_sepolia\\\", ChainData(\\\"Metal Sepolia\\\", 1740, \\\"https://testnet.rpc.metall2.com\\\"));\\n\\n setChainWithDefaultRpcUrl(\\\"binary\\\", ChainData(\\\"Binary\\\", 624, \\\"https://rpc.zero.thebinaryholdings.com\\\"));\\n setChainWithDefaultRpcUrl(\\n \\\"binary_sepolia\\\", ChainData(\\\"Binary Sepolia\\\", 625, \\\"https://rpc.zero.thebinaryholdings.com\\\")\\n );\\n\\n setChainWithDefaultRpcUrl(\\\"orderly\\\", ChainData(\\\"Orderly\\\", 291, \\\"https://rpc.orderly.network\\\"));\\n setChainWithDefaultRpcUrl(\\n \\\"orderly_sepolia\\\", ChainData(\\\"Orderly Sepolia\\\", 4460, \\\"https://testnet-rpc.orderly.org\\\")\\n );\\n }\\n\\n // set chain info, with priority to chainAlias' rpc url in foundry.toml\\n function setChainWithDefaultRpcUrl(string memory chainAlias, ChainData memory chain) private {\\n string memory rpcUrl = chain.rpcUrl;\\n defaultRpcUrls[chainAlias] = rpcUrl;\\n chain.rpcUrl = \\\"\\\";\\n setChain(chainAlias, chain);\\n chain.rpcUrl = rpcUrl; // restore argument\\n }\\n}\\n\",\"keccak256\":\"0x200b597cd01c229633b4a2317846cac7d36d337e2381b4a2e81faac23c2ad1cf\",\"license\":\"MIT\"},\"lib/forge-std/src/StdCheats.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity >=0.6.2 <0.9.0;\\n\\npragma experimental ABIEncoderV2;\\n\\nimport {StdStorage, stdStorage} from \\\"./StdStorage.sol\\\";\\nimport {console2} from \\\"./console2.sol\\\";\\nimport {Vm} from \\\"./Vm.sol\\\";\\n\\nabstract contract StdCheatsSafe {\\n Vm private constant vm = Vm(address(uint160(uint256(keccak256(\\\"hevm cheat code\\\")))));\\n\\n uint256 private constant UINT256_MAX =\\n 115792089237316195423570985008687907853269984665640564039457584007913129639935;\\n\\n bool private gasMeteringOff;\\n\\n // Data structures to parse Transaction objects from the broadcast artifact\\n // that conform to EIP1559. The Raw structs is what is parsed from the JSON\\n // and then converted to the one that is used by the user for better UX.\\n\\n struct RawTx1559 {\\n string[] arguments;\\n address contractAddress;\\n string contractName;\\n // json value name = function\\n string functionSig;\\n bytes32 hash;\\n // json value name = tx\\n RawTx1559Detail txDetail;\\n // json value name = type\\n string opcode;\\n }\\n\\n struct RawTx1559Detail {\\n AccessList[] accessList;\\n bytes data;\\n address from;\\n bytes gas;\\n bytes nonce;\\n address to;\\n bytes txType;\\n bytes value;\\n }\\n\\n struct Tx1559 {\\n string[] arguments;\\n address contractAddress;\\n string contractName;\\n string functionSig;\\n bytes32 hash;\\n Tx1559Detail txDetail;\\n string opcode;\\n }\\n\\n struct Tx1559Detail {\\n AccessList[] accessList;\\n bytes data;\\n address from;\\n uint256 gas;\\n uint256 nonce;\\n address to;\\n uint256 txType;\\n uint256 value;\\n }\\n\\n // Data structures to parse Transaction objects from the broadcast artifact\\n // that DO NOT conform to EIP1559. The Raw structs is what is parsed from the JSON\\n // and then converted to the one that is used by the user for better UX.\\n\\n struct TxLegacy {\\n string[] arguments;\\n address contractAddress;\\n string contractName;\\n string functionSig;\\n string hash;\\n string opcode;\\n TxDetailLegacy transaction;\\n }\\n\\n struct TxDetailLegacy {\\n AccessList[] accessList;\\n uint256 chainId;\\n bytes data;\\n address from;\\n uint256 gas;\\n uint256 gasPrice;\\n bytes32 hash;\\n uint256 nonce;\\n bytes1 opcode;\\n bytes32 r;\\n bytes32 s;\\n uint256 txType;\\n address to;\\n uint8 v;\\n uint256 value;\\n }\\n\\n struct AccessList {\\n address accessAddress;\\n bytes32[] storageKeys;\\n }\\n\\n // Data structures to parse Receipt objects from the broadcast artifact.\\n // The Raw structs is what is parsed from the JSON\\n // and then converted to the one that is used by the user for better UX.\\n\\n struct RawReceipt {\\n bytes32 blockHash;\\n bytes blockNumber;\\n address contractAddress;\\n bytes cumulativeGasUsed;\\n bytes effectiveGasPrice;\\n address from;\\n bytes gasUsed;\\n RawReceiptLog[] logs;\\n bytes logsBloom;\\n bytes status;\\n address to;\\n bytes32 transactionHash;\\n bytes transactionIndex;\\n }\\n\\n struct Receipt {\\n bytes32 blockHash;\\n uint256 blockNumber;\\n address contractAddress;\\n uint256 cumulativeGasUsed;\\n uint256 effectiveGasPrice;\\n address from;\\n uint256 gasUsed;\\n ReceiptLog[] logs;\\n bytes logsBloom;\\n uint256 status;\\n address to;\\n bytes32 transactionHash;\\n uint256 transactionIndex;\\n }\\n\\n // Data structures to parse the entire broadcast artifact, assuming the\\n // transactions conform to EIP1559.\\n\\n struct EIP1559ScriptArtifact {\\n string[] libraries;\\n string path;\\n string[] pending;\\n Receipt[] receipts;\\n uint256 timestamp;\\n Tx1559[] transactions;\\n TxReturn[] txReturns;\\n }\\n\\n struct RawEIP1559ScriptArtifact {\\n string[] libraries;\\n string path;\\n string[] pending;\\n RawReceipt[] receipts;\\n TxReturn[] txReturns;\\n uint256 timestamp;\\n RawTx1559[] transactions;\\n }\\n\\n struct RawReceiptLog {\\n // json value = address\\n address logAddress;\\n bytes32 blockHash;\\n bytes blockNumber;\\n bytes data;\\n bytes logIndex;\\n bool removed;\\n bytes32[] topics;\\n bytes32 transactionHash;\\n bytes transactionIndex;\\n bytes transactionLogIndex;\\n }\\n\\n struct ReceiptLog {\\n // json value = address\\n address logAddress;\\n bytes32 blockHash;\\n uint256 blockNumber;\\n bytes data;\\n uint256 logIndex;\\n bytes32[] topics;\\n uint256 transactionIndex;\\n uint256 transactionLogIndex;\\n bool removed;\\n }\\n\\n struct TxReturn {\\n string internalType;\\n string value;\\n }\\n\\n struct Account {\\n address addr;\\n uint256 key;\\n }\\n\\n enum AddressType {\\n Payable,\\n NonPayable,\\n ZeroAddress,\\n Precompile,\\n ForgeAddress\\n }\\n\\n // Checks that `addr` is not blacklisted by token contracts that have a blacklist.\\n function assumeNotBlacklisted(address token, address addr) internal view virtual {\\n // Nothing to check if `token` is not a contract.\\n uint256 tokenCodeSize;\\n assembly {\\n tokenCodeSize := extcodesize(token)\\n }\\n require(tokenCodeSize > 0, \\\"StdCheats assumeNotBlacklisted(address,address): Token address is not a contract.\\\");\\n\\n bool success;\\n bytes memory returnData;\\n\\n // 4-byte selector for `isBlacklisted(address)`, used by USDC.\\n (success, returnData) = token.staticcall(abi.encodeWithSelector(0xfe575a87, addr));\\n vm.assume(!success || abi.decode(returnData, (bool)) == false);\\n\\n // 4-byte selector for `isBlackListed(address)`, used by USDT.\\n (success, returnData) = token.staticcall(abi.encodeWithSelector(0xe47d6060, addr));\\n vm.assume(!success || abi.decode(returnData, (bool)) == false);\\n }\\n\\n // Checks that `addr` is not blacklisted by token contracts that have a blacklist.\\n // This is identical to `assumeNotBlacklisted(address,address)` but with a different name, for\\n // backwards compatibility, since this name was used in the original PR which already has\\n // a release. This function can be removed in a future release once we want a breaking change.\\n function assumeNoBlacklisted(address token, address addr) internal view virtual {\\n assumeNotBlacklisted(token, addr);\\n }\\n\\n function assumeAddressIsNot(address addr, AddressType addressType) internal virtual {\\n if (addressType == AddressType.Payable) {\\n assumeNotPayable(addr);\\n } else if (addressType == AddressType.NonPayable) {\\n assumePayable(addr);\\n } else if (addressType == AddressType.ZeroAddress) {\\n assumeNotZeroAddress(addr);\\n } else if (addressType == AddressType.Precompile) {\\n assumeNotPrecompile(addr);\\n } else if (addressType == AddressType.ForgeAddress) {\\n assumeNotForgeAddress(addr);\\n }\\n }\\n\\n function assumeAddressIsNot(address addr, AddressType addressType1, AddressType addressType2) internal virtual {\\n assumeAddressIsNot(addr, addressType1);\\n assumeAddressIsNot(addr, addressType2);\\n }\\n\\n function assumeAddressIsNot(\\n address addr,\\n AddressType addressType1,\\n AddressType addressType2,\\n AddressType addressType3\\n ) internal virtual {\\n assumeAddressIsNot(addr, addressType1);\\n assumeAddressIsNot(addr, addressType2);\\n assumeAddressIsNot(addr, addressType3);\\n }\\n\\n function assumeAddressIsNot(\\n address addr,\\n AddressType addressType1,\\n AddressType addressType2,\\n AddressType addressType3,\\n AddressType addressType4\\n ) internal virtual {\\n assumeAddressIsNot(addr, addressType1);\\n assumeAddressIsNot(addr, addressType2);\\n assumeAddressIsNot(addr, addressType3);\\n assumeAddressIsNot(addr, addressType4);\\n }\\n\\n // This function checks whether an address, `addr`, is payable. It works by sending 1 wei to\\n // `addr` and checking the `success` return value.\\n // NOTE: This function may result in state changes depending on the fallback/receive logic\\n // implemented by `addr`, which should be taken into account when this function is used.\\n function _isPayable(address addr) private returns (bool) {\\n require(\\n addr.balance < UINT256_MAX,\\n \\\"StdCheats _isPayable(address): Balance equals max uint256, so it cannot receive any more funds\\\"\\n );\\n uint256 origBalanceTest = address(this).balance;\\n uint256 origBalanceAddr = address(addr).balance;\\n\\n vm.deal(address(this), 1);\\n (bool success,) = payable(addr).call{value: 1}(\\\"\\\");\\n\\n // reset balances\\n vm.deal(address(this), origBalanceTest);\\n vm.deal(addr, origBalanceAddr);\\n\\n return success;\\n }\\n\\n // NOTE: This function may result in state changes depending on the fallback/receive logic\\n // implemented by `addr`, which should be taken into account when this function is used. See the\\n // `_isPayable` method for more information.\\n function assumePayable(address addr) internal virtual {\\n vm.assume(_isPayable(addr));\\n }\\n\\n function assumeNotPayable(address addr) internal virtual {\\n vm.assume(!_isPayable(addr));\\n }\\n\\n function assumeNotZeroAddress(address addr) internal pure virtual {\\n vm.assume(addr != address(0));\\n }\\n\\n function assumeNotPrecompile(address addr) internal pure virtual {\\n assumeNotPrecompile(addr, _pureChainId());\\n }\\n\\n function assumeNotPrecompile(address addr, uint256 chainId) internal pure virtual {\\n // Note: For some chains like Optimism these are technically predeploys (i.e. bytecode placed at a specific\\n // address), but the same rationale for excluding them applies so we include those too.\\n\\n // These are reserved by Ethereum and may be on all EVM-compatible chains.\\n vm.assume(addr < address(0x1) || addr > address(0xff));\\n\\n // forgefmt: disable-start\\n if (chainId == 10 || chainId == 420) {\\n // https://github.com/ethereum-optimism/optimism/blob/eaa371a0184b56b7ca6d9eb9cb0a2b78b2ccd864/op-bindings/predeploys/addresses.go#L6-L21\\n vm.assume(addr < address(0x4200000000000000000000000000000000000000) || addr > address(0x4200000000000000000000000000000000000800));\\n } else if (chainId == 42161 || chainId == 421613) {\\n // https://developer.arbitrum.io/useful-addresses#arbitrum-precompiles-l2-same-on-all-arb-chains\\n vm.assume(addr < address(0x0000000000000000000000000000000000000064) || addr > address(0x0000000000000000000000000000000000000068));\\n } else if (chainId == 43114 || chainId == 43113) {\\n // https://github.com/ava-labs/subnet-evm/blob/47c03fd007ecaa6de2c52ea081596e0a88401f58/precompile/params.go#L18-L59\\n vm.assume(addr < address(0x0100000000000000000000000000000000000000) || addr > address(0x01000000000000000000000000000000000000ff));\\n vm.assume(addr < address(0x0200000000000000000000000000000000000000) || addr > address(0x02000000000000000000000000000000000000FF));\\n vm.assume(addr < address(0x0300000000000000000000000000000000000000) || addr > address(0x03000000000000000000000000000000000000Ff));\\n }\\n // forgefmt: disable-end\\n }\\n\\n function assumeNotForgeAddress(address addr) internal pure virtual {\\n // vm, console, and Create2Deployer addresses\\n vm.assume(\\n addr != address(vm) && addr != 0x000000000000000000636F6e736F6c652e6c6f67\\n && addr != 0x4e59b44847b379578588920cA78FbF26c0B4956C\\n );\\n }\\n\\n function assumeUnusedAddress(address addr) internal view virtual {\\n uint256 size;\\n assembly {\\n size := extcodesize(addr)\\n }\\n vm.assume(size == 0);\\n\\n assumeNotPrecompile(addr);\\n assumeNotZeroAddress(addr);\\n assumeNotForgeAddress(addr);\\n }\\n\\n function readEIP1559ScriptArtifact(string memory path)\\n internal\\n view\\n virtual\\n returns (EIP1559ScriptArtifact memory)\\n {\\n string memory data = vm.readFile(path);\\n bytes memory parsedData = vm.parseJson(data);\\n RawEIP1559ScriptArtifact memory rawArtifact = abi.decode(parsedData, (RawEIP1559ScriptArtifact));\\n EIP1559ScriptArtifact memory artifact;\\n artifact.libraries = rawArtifact.libraries;\\n artifact.path = rawArtifact.path;\\n artifact.timestamp = rawArtifact.timestamp;\\n artifact.pending = rawArtifact.pending;\\n artifact.txReturns = rawArtifact.txReturns;\\n artifact.receipts = rawToConvertedReceipts(rawArtifact.receipts);\\n artifact.transactions = rawToConvertedEIPTx1559s(rawArtifact.transactions);\\n return artifact;\\n }\\n\\n function rawToConvertedEIPTx1559s(RawTx1559[] memory rawTxs) internal pure virtual returns (Tx1559[] memory) {\\n Tx1559[] memory txs = new Tx1559[](rawTxs.length);\\n for (uint256 i; i < rawTxs.length; i++) {\\n txs[i] = rawToConvertedEIPTx1559(rawTxs[i]);\\n }\\n return txs;\\n }\\n\\n function rawToConvertedEIPTx1559(RawTx1559 memory rawTx) internal pure virtual returns (Tx1559 memory) {\\n Tx1559 memory transaction;\\n transaction.arguments = rawTx.arguments;\\n transaction.contractName = rawTx.contractName;\\n transaction.functionSig = rawTx.functionSig;\\n transaction.hash = rawTx.hash;\\n transaction.txDetail = rawToConvertedEIP1559Detail(rawTx.txDetail);\\n transaction.opcode = rawTx.opcode;\\n return transaction;\\n }\\n\\n function rawToConvertedEIP1559Detail(RawTx1559Detail memory rawDetail)\\n internal\\n pure\\n virtual\\n returns (Tx1559Detail memory)\\n {\\n Tx1559Detail memory txDetail;\\n txDetail.data = rawDetail.data;\\n txDetail.from = rawDetail.from;\\n txDetail.to = rawDetail.to;\\n txDetail.nonce = _bytesToUint(rawDetail.nonce);\\n txDetail.txType = _bytesToUint(rawDetail.txType);\\n txDetail.value = _bytesToUint(rawDetail.value);\\n txDetail.gas = _bytesToUint(rawDetail.gas);\\n txDetail.accessList = rawDetail.accessList;\\n return txDetail;\\n }\\n\\n function readTx1559s(string memory path) internal view virtual returns (Tx1559[] memory) {\\n string memory deployData = vm.readFile(path);\\n bytes memory parsedDeployData = vm.parseJson(deployData, \\\".transactions\\\");\\n RawTx1559[] memory rawTxs = abi.decode(parsedDeployData, (RawTx1559[]));\\n return rawToConvertedEIPTx1559s(rawTxs);\\n }\\n\\n function readTx1559(string memory path, uint256 index) internal view virtual returns (Tx1559 memory) {\\n string memory deployData = vm.readFile(path);\\n string memory key = string(abi.encodePacked(\\\".transactions[\\\", vm.toString(index), \\\"]\\\"));\\n bytes memory parsedDeployData = vm.parseJson(deployData, key);\\n RawTx1559 memory rawTx = abi.decode(parsedDeployData, (RawTx1559));\\n return rawToConvertedEIPTx1559(rawTx);\\n }\\n\\n // Analogous to readTransactions, but for receipts.\\n function readReceipts(string memory path) internal view virtual returns (Receipt[] memory) {\\n string memory deployData = vm.readFile(path);\\n bytes memory parsedDeployData = vm.parseJson(deployData, \\\".receipts\\\");\\n RawReceipt[] memory rawReceipts = abi.decode(parsedDeployData, (RawReceipt[]));\\n return rawToConvertedReceipts(rawReceipts);\\n }\\n\\n function readReceipt(string memory path, uint256 index) internal view virtual returns (Receipt memory) {\\n string memory deployData = vm.readFile(path);\\n string memory key = string(abi.encodePacked(\\\".receipts[\\\", vm.toString(index), \\\"]\\\"));\\n bytes memory parsedDeployData = vm.parseJson(deployData, key);\\n RawReceipt memory rawReceipt = abi.decode(parsedDeployData, (RawReceipt));\\n return rawToConvertedReceipt(rawReceipt);\\n }\\n\\n function rawToConvertedReceipts(RawReceipt[] memory rawReceipts) internal pure virtual returns (Receipt[] memory) {\\n Receipt[] memory receipts = new Receipt[](rawReceipts.length);\\n for (uint256 i; i < rawReceipts.length; i++) {\\n receipts[i] = rawToConvertedReceipt(rawReceipts[i]);\\n }\\n return receipts;\\n }\\n\\n function rawToConvertedReceipt(RawReceipt memory rawReceipt) internal pure virtual returns (Receipt memory) {\\n Receipt memory receipt;\\n receipt.blockHash = rawReceipt.blockHash;\\n receipt.to = rawReceipt.to;\\n receipt.from = rawReceipt.from;\\n receipt.contractAddress = rawReceipt.contractAddress;\\n receipt.effectiveGasPrice = _bytesToUint(rawReceipt.effectiveGasPrice);\\n receipt.cumulativeGasUsed = _bytesToUint(rawReceipt.cumulativeGasUsed);\\n receipt.gasUsed = _bytesToUint(rawReceipt.gasUsed);\\n receipt.status = _bytesToUint(rawReceipt.status);\\n receipt.transactionIndex = _bytesToUint(rawReceipt.transactionIndex);\\n receipt.blockNumber = _bytesToUint(rawReceipt.blockNumber);\\n receipt.logs = rawToConvertedReceiptLogs(rawReceipt.logs);\\n receipt.logsBloom = rawReceipt.logsBloom;\\n receipt.transactionHash = rawReceipt.transactionHash;\\n return receipt;\\n }\\n\\n function rawToConvertedReceiptLogs(RawReceiptLog[] memory rawLogs)\\n internal\\n pure\\n virtual\\n returns (ReceiptLog[] memory)\\n {\\n ReceiptLog[] memory logs = new ReceiptLog[](rawLogs.length);\\n for (uint256 i; i < rawLogs.length; i++) {\\n logs[i].logAddress = rawLogs[i].logAddress;\\n logs[i].blockHash = rawLogs[i].blockHash;\\n logs[i].blockNumber = _bytesToUint(rawLogs[i].blockNumber);\\n logs[i].data = rawLogs[i].data;\\n logs[i].logIndex = _bytesToUint(rawLogs[i].logIndex);\\n logs[i].topics = rawLogs[i].topics;\\n logs[i].transactionIndex = _bytesToUint(rawLogs[i].transactionIndex);\\n logs[i].transactionLogIndex = _bytesToUint(rawLogs[i].transactionLogIndex);\\n logs[i].removed = rawLogs[i].removed;\\n }\\n return logs;\\n }\\n\\n // Deploy a contract by fetching the contract bytecode from\\n // the artifacts directory\\n // e.g. `deployCode(code, abi.encode(arg1,arg2,arg3))`\\n function deployCode(string memory what, bytes memory args) internal virtual returns (address addr) {\\n bytes memory bytecode = abi.encodePacked(vm.getCode(what), args);\\n /// @solidity memory-safe-assembly\\n assembly {\\n addr := create(0, add(bytecode, 0x20), mload(bytecode))\\n }\\n\\n require(addr != address(0), \\\"StdCheats deployCode(string,bytes): Deployment failed.\\\");\\n }\\n\\n function deployCode(string memory what) internal virtual returns (address addr) {\\n bytes memory bytecode = vm.getCode(what);\\n /// @solidity memory-safe-assembly\\n assembly {\\n addr := create(0, add(bytecode, 0x20), mload(bytecode))\\n }\\n\\n require(addr != address(0), \\\"StdCheats deployCode(string): Deployment failed.\\\");\\n }\\n\\n /// @dev deploy contract with value on construction\\n function deployCode(string memory what, bytes memory args, uint256 val) internal virtual returns (address addr) {\\n bytes memory bytecode = abi.encodePacked(vm.getCode(what), args);\\n /// @solidity memory-safe-assembly\\n assembly {\\n addr := create(val, add(bytecode, 0x20), mload(bytecode))\\n }\\n\\n require(addr != address(0), \\\"StdCheats deployCode(string,bytes,uint256): Deployment failed.\\\");\\n }\\n\\n function deployCode(string memory what, uint256 val) internal virtual returns (address addr) {\\n bytes memory bytecode = vm.getCode(what);\\n /// @solidity memory-safe-assembly\\n assembly {\\n addr := create(val, add(bytecode, 0x20), mload(bytecode))\\n }\\n\\n require(addr != address(0), \\\"StdCheats deployCode(string,uint256): Deployment failed.\\\");\\n }\\n\\n // creates a labeled address and the corresponding private key\\n function makeAddrAndKey(string memory name) internal virtual returns (address addr, uint256 privateKey) {\\n privateKey = uint256(keccak256(abi.encodePacked(name)));\\n addr = vm.addr(privateKey);\\n vm.label(addr, name);\\n }\\n\\n // creates a labeled address\\n function makeAddr(string memory name) internal virtual returns (address addr) {\\n (addr,) = makeAddrAndKey(name);\\n }\\n\\n // Destroys an account immediately, sending the balance to beneficiary.\\n // Destroying means: balance will be zero, code will be empty, and nonce will be 0\\n // This is similar to selfdestruct but not identical: selfdestruct destroys code and nonce\\n // only after tx ends, this will run immediately.\\n function destroyAccount(address who, address beneficiary) internal virtual {\\n uint256 currBalance = who.balance;\\n vm.etch(who, abi.encode());\\n vm.deal(who, 0);\\n vm.resetNonce(who);\\n\\n uint256 beneficiaryBalance = beneficiary.balance;\\n vm.deal(beneficiary, currBalance + beneficiaryBalance);\\n }\\n\\n // creates a struct containing both a labeled address and the corresponding private key\\n function makeAccount(string memory name) internal virtual returns (Account memory account) {\\n (account.addr, account.key) = makeAddrAndKey(name);\\n }\\n\\n function deriveRememberKey(string memory mnemonic, uint32 index)\\n internal\\n virtual\\n returns (address who, uint256 privateKey)\\n {\\n privateKey = vm.deriveKey(mnemonic, index);\\n who = vm.rememberKey(privateKey);\\n }\\n\\n function _bytesToUint(bytes memory b) private pure returns (uint256) {\\n require(b.length <= 32, \\\"StdCheats _bytesToUint(bytes): Bytes length exceeds 32.\\\");\\n return abi.decode(abi.encodePacked(new bytes(32 - b.length), b), (uint256));\\n }\\n\\n function isFork() internal view virtual returns (bool status) {\\n try vm.activeFork() {\\n status = true;\\n } catch (bytes memory) {}\\n }\\n\\n modifier skipWhenForking() {\\n if (!isFork()) {\\n _;\\n }\\n }\\n\\n modifier skipWhenNotForking() {\\n if (isFork()) {\\n _;\\n }\\n }\\n\\n modifier noGasMetering() {\\n vm.pauseGasMetering();\\n // To prevent turning gas monitoring back on with nested functions that use this modifier,\\n // we check if gasMetering started in the off position. If it did, we don't want to turn\\n // it back on until we exit the top level function that used the modifier\\n //\\n // i.e. funcA() noGasMetering { funcB() }, where funcB has noGasMetering as well.\\n // funcA will have `gasStartedOff` as false, funcB will have it as true,\\n // so we only turn metering back on at the end of the funcA\\n bool gasStartedOff = gasMeteringOff;\\n gasMeteringOff = true;\\n\\n _;\\n\\n // if gas metering was on when this modifier was called, turn it back on at the end\\n if (!gasStartedOff) {\\n gasMeteringOff = false;\\n vm.resumeGasMetering();\\n }\\n }\\n\\n // We use this complex approach of `_viewChainId` and `_pureChainId` to ensure there are no\\n // compiler warnings when accessing chain ID in any solidity version supported by forge-std. We\\n // can't simply access the chain ID in a normal view or pure function because the solc View Pure\\n // Checker changed `chainid` from pure to view in 0.8.0.\\n function _viewChainId() private view returns (uint256 chainId) {\\n // Assembly required since `block.chainid` was introduced in 0.8.0.\\n assembly {\\n chainId := chainid()\\n }\\n\\n address(this); // Silence warnings in older Solc versions.\\n }\\n\\n function _pureChainId() private pure returns (uint256 chainId) {\\n function() internal view returns (uint256) fnIn = _viewChainId;\\n function() internal pure returns (uint256) pureChainId;\\n assembly {\\n pureChainId := fnIn\\n }\\n chainId = pureChainId();\\n }\\n}\\n\\n// Wrappers around cheatcodes to avoid footguns\\nabstract contract StdCheats is StdCheatsSafe {\\n using stdStorage for StdStorage;\\n\\n StdStorage private stdstore;\\n Vm private constant vm = Vm(address(uint160(uint256(keccak256(\\\"hevm cheat code\\\")))));\\n address private constant CONSOLE2_ADDRESS = 0x000000000000000000636F6e736F6c652e6c6f67;\\n\\n // Skip forward or rewind time by the specified number of seconds\\n function skip(uint256 time) internal virtual {\\n vm.warp(vm.getBlockTimestamp() + time);\\n }\\n\\n function rewind(uint256 time) internal virtual {\\n vm.warp(vm.getBlockTimestamp() - time);\\n }\\n\\n // Setup a prank from an address that has some ether\\n function hoax(address msgSender) internal virtual {\\n vm.deal(msgSender, 1 << 128);\\n vm.prank(msgSender);\\n }\\n\\n function hoax(address msgSender, uint256 give) internal virtual {\\n vm.deal(msgSender, give);\\n vm.prank(msgSender);\\n }\\n\\n function hoax(address msgSender, address origin) internal virtual {\\n vm.deal(msgSender, 1 << 128);\\n vm.prank(msgSender, origin);\\n }\\n\\n function hoax(address msgSender, address origin, uint256 give) internal virtual {\\n vm.deal(msgSender, give);\\n vm.prank(msgSender, origin);\\n }\\n\\n // Start perpetual prank from an address that has some ether\\n function startHoax(address msgSender) internal virtual {\\n vm.deal(msgSender, 1 << 128);\\n vm.startPrank(msgSender);\\n }\\n\\n function startHoax(address msgSender, uint256 give) internal virtual {\\n vm.deal(msgSender, give);\\n vm.startPrank(msgSender);\\n }\\n\\n // Start perpetual prank from an address that has some ether\\n // tx.origin is set to the origin parameter\\n function startHoax(address msgSender, address origin) internal virtual {\\n vm.deal(msgSender, 1 << 128);\\n vm.startPrank(msgSender, origin);\\n }\\n\\n function startHoax(address msgSender, address origin, uint256 give) internal virtual {\\n vm.deal(msgSender, give);\\n vm.startPrank(msgSender, origin);\\n }\\n\\n function changePrank(address msgSender) internal virtual {\\n console2_log_StdCheats(\\\"changePrank is deprecated. Please use vm.startPrank instead.\\\");\\n vm.stopPrank();\\n vm.startPrank(msgSender);\\n }\\n\\n function changePrank(address msgSender, address txOrigin) internal virtual {\\n vm.stopPrank();\\n vm.startPrank(msgSender, txOrigin);\\n }\\n\\n // The same as Vm's `deal`\\n // Use the alternative signature for ERC20 tokens\\n function deal(address to, uint256 give) internal virtual {\\n vm.deal(to, give);\\n }\\n\\n // Set the balance of an account for any ERC20 token\\n // Use the alternative signature to update `totalSupply`\\n function deal(address token, address to, uint256 give) internal virtual {\\n deal(token, to, give, false);\\n }\\n\\n // Set the balance of an account for any ERC1155 token\\n // Use the alternative signature to update `totalSupply`\\n function dealERC1155(address token, address to, uint256 id, uint256 give) internal virtual {\\n dealERC1155(token, to, id, give, false);\\n }\\n\\n function deal(address token, address to, uint256 give, bool adjust) internal virtual {\\n // get current balance\\n (, bytes memory balData) = token.staticcall(abi.encodeWithSelector(0x70a08231, to));\\n uint256 prevBal = abi.decode(balData, (uint256));\\n\\n // update balance\\n stdstore.target(token).sig(0x70a08231).with_key(to).checked_write(give);\\n\\n // update total supply\\n if (adjust) {\\n (, bytes memory totSupData) = token.staticcall(abi.encodeWithSelector(0x18160ddd));\\n uint256 totSup = abi.decode(totSupData, (uint256));\\n if (give < prevBal) {\\n totSup -= (prevBal - give);\\n } else {\\n totSup += (give - prevBal);\\n }\\n stdstore.target(token).sig(0x18160ddd).checked_write(totSup);\\n }\\n }\\n\\n function dealERC1155(address token, address to, uint256 id, uint256 give, bool adjust) internal virtual {\\n // get current balance\\n (, bytes memory balData) = token.staticcall(abi.encodeWithSelector(0x00fdd58e, to, id));\\n uint256 prevBal = abi.decode(balData, (uint256));\\n\\n // update balance\\n stdstore.target(token).sig(0x00fdd58e).with_key(to).with_key(id).checked_write(give);\\n\\n // update total supply\\n if (adjust) {\\n (, bytes memory totSupData) = token.staticcall(abi.encodeWithSelector(0xbd85b039, id));\\n require(\\n totSupData.length != 0,\\n \\\"StdCheats deal(address,address,uint,uint,bool): target contract is not ERC1155Supply.\\\"\\n );\\n uint256 totSup = abi.decode(totSupData, (uint256));\\n if (give < prevBal) {\\n totSup -= (prevBal - give);\\n } else {\\n totSup += (give - prevBal);\\n }\\n stdstore.target(token).sig(0xbd85b039).with_key(id).checked_write(totSup);\\n }\\n }\\n\\n function dealERC721(address token, address to, uint256 id) internal virtual {\\n // check if token id is already minted and the actual owner.\\n (bool successMinted, bytes memory ownerData) = token.staticcall(abi.encodeWithSelector(0x6352211e, id));\\n require(successMinted, \\\"StdCheats deal(address,address,uint,bool): id not minted.\\\");\\n\\n // get owner current balance\\n (, bytes memory fromBalData) =\\n token.staticcall(abi.encodeWithSelector(0x70a08231, abi.decode(ownerData, (address))));\\n uint256 fromPrevBal = abi.decode(fromBalData, (uint256));\\n\\n // get new user current balance\\n (, bytes memory toBalData) = token.staticcall(abi.encodeWithSelector(0x70a08231, to));\\n uint256 toPrevBal = abi.decode(toBalData, (uint256));\\n\\n // update balances\\n stdstore.target(token).sig(0x70a08231).with_key(abi.decode(ownerData, (address))).checked_write(--fromPrevBal);\\n stdstore.target(token).sig(0x70a08231).with_key(to).checked_write(++toPrevBal);\\n\\n // update owner\\n stdstore.target(token).sig(0x6352211e).with_key(id).checked_write(to);\\n }\\n\\n function deployCodeTo(string memory what, address where) internal virtual {\\n deployCodeTo(what, \\\"\\\", 0, where);\\n }\\n\\n function deployCodeTo(string memory what, bytes memory args, address where) internal virtual {\\n deployCodeTo(what, args, 0, where);\\n }\\n\\n function deployCodeTo(string memory what, bytes memory args, uint256 value, address where) internal virtual {\\n bytes memory creationCode = vm.getCode(what);\\n vm.etch(where, abi.encodePacked(creationCode, args));\\n (bool success, bytes memory runtimeBytecode) = where.call{value: value}(\\\"\\\");\\n require(success, \\\"StdCheats deployCodeTo(string,bytes,uint256,address): Failed to create runtime bytecode.\\\");\\n vm.etch(where, runtimeBytecode);\\n }\\n\\n // Used to prevent the compilation of console, which shortens the compilation time when console is not used elsewhere.\\n function console2_log_StdCheats(string memory p0) private view {\\n (bool status,) = address(CONSOLE2_ADDRESS).staticcall(abi.encodeWithSignature(\\\"log(string)\\\", p0));\\n status;\\n }\\n}\\n\",\"keccak256\":\"0x0fa6ec03602648b62cce41aab2096e6b7e052f2846075d967b6958dd586db746\",\"license\":\"MIT\"},\"lib/forge-std/src/StdConstants.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity >=0.6.2 <0.9.0;\\n\\nimport {IMulticall3} from \\\"./interfaces/IMulticall3.sol\\\";\\nimport {Vm} from \\\"./Vm.sol\\\";\\n\\nlibrary StdConstants {\\n /// @dev Cheat code address.\\n /// Calculated as `address(uint160(uint256(keccak256(\\\"hevm cheat code\\\"))))`.\\n Vm internal constant VM = Vm(0x7109709ECfa91a80626fF3989D68f67F5b1DD12D);\\n /// @dev console.sol and console2.sol work by executing a staticcall to this address.\\n /// Calculated as `address(uint160(uint88(bytes11(\\\"console.log\\\"))))`.\\n address internal constant CONSOLE = 0x000000000000000000636F6e736F6c652e6c6f67;\\n /// @dev Used when deploying with create2.\\n /// Taken from https://github.com/Arachnid/deterministic-deployment-proxy.\\n address internal constant CREATE2_FACTORY = 0x4e59b44847b379578588920cA78FbF26c0B4956C;\\n /// @dev The default address for tx.origin and msg.sender.\\n /// Calculated as `address(uint160(uint256(keccak256(\\\"foundry default caller\\\"))))`.\\n address internal constant DEFAULT_SENDER = 0x1804c8AB1F12E6bbf3894d4083f33e07309d1f38;\\n /// @dev The address of the first contract `CREATE`d by a running test contract.\\n /// When running tests, each test contract is `CREATE`d by `DEFAULT_SENDER` with nonce 1.\\n /// Calculated as `VM.computeCreateAddress(VM.computeCreateAddress(DEFAULT_SENDER, 1), 1)`.\\n address internal constant DEFAULT_TEST_CONTRACT = 0x5615dEB798BB3E4dFa0139dFa1b3D433Cc23b72f;\\n /// @dev Deterministic deployment address of the Multicall3 contract.\\n /// Taken from https://www.multicall3.com.\\n IMulticall3 internal constant MULTICALL3_ADDRESS = IMulticall3(0xcA11bde05977b3631167028862bE2a173976CA11);\\n /// @dev The order of the secp256k1 curve.\\n uint256 internal constant SECP256K1_ORDER =\\n 115792089237316195423570985008687907852837564279074904382605163141518161494337;\\n}\\n\",\"keccak256\":\"0x319ccdabfa2c0b2428301445873270ffea20f0e039d4fd5e6eeba65158e4e534\",\"license\":\"MIT\"},\"lib/forge-std/src/StdJson.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity >=0.6.0 <0.9.0;\\n\\npragma experimental ABIEncoderV2;\\n\\nimport {VmSafe} from \\\"./Vm.sol\\\";\\n\\n// Helpers for parsing and writing JSON files\\n// To parse:\\n// ```\\n// using stdJson for string;\\n// string memory json = vm.readFile(\\\"\\\");\\n// json.readUint(\\\"\\\");\\n// ```\\n// To write:\\n// ```\\n// using stdJson for string;\\n// string memory json = \\\"json\\\";\\n// json.serialize(\\\"a\\\", uint256(123));\\n// string memory semiFinal = json.serialize(\\\"b\\\", string(\\\"test\\\"));\\n// string memory finalJson = json.serialize(\\\"c\\\", semiFinal);\\n// finalJson.write(\\\"\\\");\\n// ```\\n\\nlibrary stdJson {\\n VmSafe private constant vm = VmSafe(address(uint160(uint256(keccak256(\\\"hevm cheat code\\\")))));\\n\\n function keyExists(string memory json, string memory key) internal view returns (bool) {\\n return vm.keyExistsJson(json, key);\\n }\\n\\n function parseRaw(string memory json, string memory key) internal pure returns (bytes memory) {\\n return vm.parseJson(json, key);\\n }\\n\\n function readUint(string memory json, string memory key) internal pure returns (uint256) {\\n return vm.parseJsonUint(json, key);\\n }\\n\\n function readUintArray(string memory json, string memory key) internal pure returns (uint256[] memory) {\\n return vm.parseJsonUintArray(json, key);\\n }\\n\\n function readInt(string memory json, string memory key) internal pure returns (int256) {\\n return vm.parseJsonInt(json, key);\\n }\\n\\n function readIntArray(string memory json, string memory key) internal pure returns (int256[] memory) {\\n return vm.parseJsonIntArray(json, key);\\n }\\n\\n function readBytes32(string memory json, string memory key) internal pure returns (bytes32) {\\n return vm.parseJsonBytes32(json, key);\\n }\\n\\n function readBytes32Array(string memory json, string memory key) internal pure returns (bytes32[] memory) {\\n return vm.parseJsonBytes32Array(json, key);\\n }\\n\\n function readString(string memory json, string memory key) internal pure returns (string memory) {\\n return vm.parseJsonString(json, key);\\n }\\n\\n function readStringArray(string memory json, string memory key) internal pure returns (string[] memory) {\\n return vm.parseJsonStringArray(json, key);\\n }\\n\\n function readAddress(string memory json, string memory key) internal pure returns (address) {\\n return vm.parseJsonAddress(json, key);\\n }\\n\\n function readAddressArray(string memory json, string memory key) internal pure returns (address[] memory) {\\n return vm.parseJsonAddressArray(json, key);\\n }\\n\\n function readBool(string memory json, string memory key) internal pure returns (bool) {\\n return vm.parseJsonBool(json, key);\\n }\\n\\n function readBoolArray(string memory json, string memory key) internal pure returns (bool[] memory) {\\n return vm.parseJsonBoolArray(json, key);\\n }\\n\\n function readBytes(string memory json, string memory key) internal pure returns (bytes memory) {\\n return vm.parseJsonBytes(json, key);\\n }\\n\\n function readBytesArray(string memory json, string memory key) internal pure returns (bytes[] memory) {\\n return vm.parseJsonBytesArray(json, key);\\n }\\n\\n function readUintOr(string memory json, string memory key, uint256 defaultValue) internal view returns (uint256) {\\n return keyExists(json, key) ? readUint(json, key) : defaultValue;\\n }\\n\\n function readUintArrayOr(string memory json, string memory key, uint256[] memory defaultValue)\\n internal\\n view\\n returns (uint256[] memory)\\n {\\n return keyExists(json, key) ? readUintArray(json, key) : defaultValue;\\n }\\n\\n function readIntOr(string memory json, string memory key, int256 defaultValue) internal view returns (int256) {\\n return keyExists(json, key) ? readInt(json, key) : defaultValue;\\n }\\n\\n function readIntArrayOr(string memory json, string memory key, int256[] memory defaultValue)\\n internal\\n view\\n returns (int256[] memory)\\n {\\n return keyExists(json, key) ? readIntArray(json, key) : defaultValue;\\n }\\n\\n function readBytes32Or(string memory json, string memory key, bytes32 defaultValue)\\n internal\\n view\\n returns (bytes32)\\n {\\n return keyExists(json, key) ? readBytes32(json, key) : defaultValue;\\n }\\n\\n function readBytes32ArrayOr(string memory json, string memory key, bytes32[] memory defaultValue)\\n internal\\n view\\n returns (bytes32[] memory)\\n {\\n return keyExists(json, key) ? readBytes32Array(json, key) : defaultValue;\\n }\\n\\n function readStringOr(string memory json, string memory key, string memory defaultValue)\\n internal\\n view\\n returns (string memory)\\n {\\n return keyExists(json, key) ? readString(json, key) : defaultValue;\\n }\\n\\n function readStringArrayOr(string memory json, string memory key, string[] memory defaultValue)\\n internal\\n view\\n returns (string[] memory)\\n {\\n return keyExists(json, key) ? readStringArray(json, key) : defaultValue;\\n }\\n\\n function readAddressOr(string memory json, string memory key, address defaultValue)\\n internal\\n view\\n returns (address)\\n {\\n return keyExists(json, key) ? readAddress(json, key) : defaultValue;\\n }\\n\\n function readAddressArrayOr(string memory json, string memory key, address[] memory defaultValue)\\n internal\\n view\\n returns (address[] memory)\\n {\\n return keyExists(json, key) ? readAddressArray(json, key) : defaultValue;\\n }\\n\\n function readBoolOr(string memory json, string memory key, bool defaultValue) internal view returns (bool) {\\n return keyExists(json, key) ? readBool(json, key) : defaultValue;\\n }\\n\\n function readBoolArrayOr(string memory json, string memory key, bool[] memory defaultValue)\\n internal\\n view\\n returns (bool[] memory)\\n {\\n return keyExists(json, key) ? readBoolArray(json, key) : defaultValue;\\n }\\n\\n function readBytesOr(string memory json, string memory key, bytes memory defaultValue)\\n internal\\n view\\n returns (bytes memory)\\n {\\n return keyExists(json, key) ? readBytes(json, key) : defaultValue;\\n }\\n\\n function readBytesArrayOr(string memory json, string memory key, bytes[] memory defaultValue)\\n internal\\n view\\n returns (bytes[] memory)\\n {\\n return keyExists(json, key) ? readBytesArray(json, key) : defaultValue;\\n }\\n\\n function serialize(string memory jsonKey, string memory rootObject) internal returns (string memory) {\\n return vm.serializeJson(jsonKey, rootObject);\\n }\\n\\n function serialize(string memory jsonKey, string memory key, bool value) internal returns (string memory) {\\n return vm.serializeBool(jsonKey, key, value);\\n }\\n\\n function serialize(string memory jsonKey, string memory key, bool[] memory value)\\n internal\\n returns (string memory)\\n {\\n return vm.serializeBool(jsonKey, key, value);\\n }\\n\\n function serialize(string memory jsonKey, string memory key, uint256 value) internal returns (string memory) {\\n return vm.serializeUint(jsonKey, key, value);\\n }\\n\\n function serialize(string memory jsonKey, string memory key, uint256[] memory value)\\n internal\\n returns (string memory)\\n {\\n return vm.serializeUint(jsonKey, key, value);\\n }\\n\\n function serialize(string memory jsonKey, string memory key, int256 value) internal returns (string memory) {\\n return vm.serializeInt(jsonKey, key, value);\\n }\\n\\n function serialize(string memory jsonKey, string memory key, int256[] memory value)\\n internal\\n returns (string memory)\\n {\\n return vm.serializeInt(jsonKey, key, value);\\n }\\n\\n function serialize(string memory jsonKey, string memory key, address value) internal returns (string memory) {\\n return vm.serializeAddress(jsonKey, key, value);\\n }\\n\\n function serialize(string memory jsonKey, string memory key, address[] memory value)\\n internal\\n returns (string memory)\\n {\\n return vm.serializeAddress(jsonKey, key, value);\\n }\\n\\n function serialize(string memory jsonKey, string memory key, bytes32 value) internal returns (string memory) {\\n return vm.serializeBytes32(jsonKey, key, value);\\n }\\n\\n function serialize(string memory jsonKey, string memory key, bytes32[] memory value)\\n internal\\n returns (string memory)\\n {\\n return vm.serializeBytes32(jsonKey, key, value);\\n }\\n\\n function serialize(string memory jsonKey, string memory key, bytes memory value) internal returns (string memory) {\\n return vm.serializeBytes(jsonKey, key, value);\\n }\\n\\n function serialize(string memory jsonKey, string memory key, bytes[] memory value)\\n internal\\n returns (string memory)\\n {\\n return vm.serializeBytes(jsonKey, key, value);\\n }\\n\\n function serialize(string memory jsonKey, string memory key, string memory value)\\n internal\\n returns (string memory)\\n {\\n return vm.serializeString(jsonKey, key, value);\\n }\\n\\n function serialize(string memory jsonKey, string memory key, string[] memory value)\\n internal\\n returns (string memory)\\n {\\n return vm.serializeString(jsonKey, key, value);\\n }\\n\\n function write(string memory jsonKey, string memory path) internal {\\n vm.writeJson(jsonKey, path);\\n }\\n\\n function write(string memory jsonKey, string memory path, string memory valueKey) internal {\\n vm.writeJson(jsonKey, path, valueKey);\\n }\\n}\\n\",\"keccak256\":\"0xbc0132abe1c2accc2867c0f03667afffdf92f3e95a581bb03c9557eaa38ea500\",\"license\":\"MIT\"},\"lib/forge-std/src/StdMath.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity >=0.6.2 <0.9.0;\\n\\nlibrary stdMath {\\n int256 private constant INT256_MIN = -57896044618658097711785492504343953926634992332820282019728792003956564819968;\\n\\n function abs(int256 a) internal pure returns (uint256) {\\n // Required or it will fail when `a = type(int256).min`\\n if (a == INT256_MIN) {\\n return 57896044618658097711785492504343953926634992332820282019728792003956564819968;\\n }\\n\\n return uint256(a > 0 ? a : -a);\\n }\\n\\n function delta(uint256 a, uint256 b) internal pure returns (uint256) {\\n return a > b ? a - b : b - a;\\n }\\n\\n function delta(int256 a, int256 b) internal pure returns (uint256) {\\n // a and b are of the same sign\\n // this works thanks to two's complement, the left-most bit is the sign bit\\n if ((a ^ b) > -1) {\\n return delta(abs(a), abs(b));\\n }\\n\\n // a and b are of opposite signs\\n return abs(a) + abs(b);\\n }\\n\\n function percentDelta(uint256 a, uint256 b) internal pure returns (uint256) {\\n uint256 absDelta = delta(a, b);\\n\\n return absDelta * 1e18 / b;\\n }\\n\\n function percentDelta(int256 a, int256 b) internal pure returns (uint256) {\\n uint256 absDelta = delta(a, b);\\n uint256 absB = abs(b);\\n\\n return absDelta * 1e18 / absB;\\n }\\n}\\n\",\"keccak256\":\"0xd90ad4fd8aeaeb8929964e686e769fdedd5eded3fc3815df194a0ab9f91a3fb2\",\"license\":\"MIT\"},\"lib/forge-std/src/StdStorage.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity >=0.6.2 <0.9.0;\\n\\nimport {Vm} from \\\"./Vm.sol\\\";\\n\\nstruct FindData {\\n uint256 slot;\\n uint256 offsetLeft;\\n uint256 offsetRight;\\n bool found;\\n}\\n\\nstruct StdStorage {\\n mapping(address => mapping(bytes4 => mapping(bytes32 => FindData))) finds;\\n bytes32[] _keys;\\n bytes4 _sig;\\n uint256 _depth;\\n address _target;\\n bytes32 _set;\\n bool _enable_packed_slots;\\n bytes _calldata;\\n}\\n\\nlibrary stdStorageSafe {\\n event SlotFound(address who, bytes4 fsig, bytes32 keysHash, uint256 slot);\\n event WARNING_UninitedSlot(address who, uint256 slot);\\n\\n Vm private constant vm = Vm(address(uint160(uint256(keccak256(\\\"hevm cheat code\\\")))));\\n uint256 constant UINT256_MAX = 115792089237316195423570985008687907853269984665640564039457584007913129639935;\\n\\n function sigs(string memory sigStr) internal pure returns (bytes4) {\\n return bytes4(keccak256(bytes(sigStr)));\\n }\\n\\n function getCallParams(StdStorage storage self) internal view returns (bytes memory) {\\n if (self._calldata.length == 0) {\\n return flatten(self._keys);\\n } else {\\n return self._calldata;\\n }\\n }\\n\\n // Calls target contract with configured parameters\\n function callTarget(StdStorage storage self) internal view returns (bool, bytes32) {\\n bytes memory cald = abi.encodePacked(self._sig, getCallParams(self));\\n (bool success, bytes memory rdat) = self._target.staticcall(cald);\\n bytes32 result = bytesToBytes32(rdat, 32 * self._depth);\\n\\n return (success, result);\\n }\\n\\n // Tries mutating slot value to determine if the targeted value is stored in it.\\n // If current value is 0, then we are setting slot value to type(uint256).max\\n // Otherwise, we set it to 0. That way, return value should always be affected.\\n function checkSlotMutatesCall(StdStorage storage self, bytes32 slot) internal returns (bool) {\\n bytes32 prevSlotValue = vm.load(self._target, slot);\\n (bool success, bytes32 prevReturnValue) = callTarget(self);\\n\\n bytes32 testVal = prevReturnValue == bytes32(0) ? bytes32(UINT256_MAX) : bytes32(0);\\n vm.store(self._target, slot, testVal);\\n\\n (, bytes32 newReturnValue) = callTarget(self);\\n\\n vm.store(self._target, slot, prevSlotValue);\\n\\n return (success && (prevReturnValue != newReturnValue));\\n }\\n\\n // Tries setting one of the bits in slot to 1 until return value changes.\\n // Index of resulted bit is an offset packed slot has from left/right side\\n function findOffset(StdStorage storage self, bytes32 slot, bool left) internal returns (bool, uint256) {\\n for (uint256 offset = 0; offset < 256; offset++) {\\n uint256 valueToPut = left ? (1 << (255 - offset)) : (1 << offset);\\n vm.store(self._target, slot, bytes32(valueToPut));\\n\\n (bool success, bytes32 data) = callTarget(self);\\n\\n if (success && (uint256(data) > 0)) {\\n return (true, offset);\\n }\\n }\\n return (false, 0);\\n }\\n\\n function findOffsets(StdStorage storage self, bytes32 slot) internal returns (bool, uint256, uint256) {\\n bytes32 prevSlotValue = vm.load(self._target, slot);\\n\\n (bool foundLeft, uint256 offsetLeft) = findOffset(self, slot, true);\\n (bool foundRight, uint256 offsetRight) = findOffset(self, slot, false);\\n\\n // `findOffset` may mutate slot value, so we are setting it to initial value\\n vm.store(self._target, slot, prevSlotValue);\\n return (foundLeft && foundRight, offsetLeft, offsetRight);\\n }\\n\\n function find(StdStorage storage self) internal returns (FindData storage) {\\n return find(self, true);\\n }\\n\\n /// @notice find an arbitrary storage slot given a function sig, input data, address of the contract and a value to check against\\n // slot complexity:\\n // if flat, will be bytes32(uint256(uint));\\n // if map, will be keccak256(abi.encode(key, uint(slot)));\\n // if deep map, will be keccak256(abi.encode(key1, keccak256(abi.encode(key0, uint(slot)))));\\n // if map struct, will be bytes32(uint256(keccak256(abi.encode(key1, keccak256(abi.encode(key0, uint(slot)))))) + structFieldDepth);\\n function find(StdStorage storage self, bool _clear) internal returns (FindData storage) {\\n address who = self._target;\\n bytes4 fsig = self._sig;\\n uint256 field_depth = self._depth;\\n bytes memory params = getCallParams(self);\\n\\n // calldata to test against\\n if (self.finds[who][fsig][keccak256(abi.encodePacked(params, field_depth))].found) {\\n if (_clear) {\\n clear(self);\\n }\\n return self.finds[who][fsig][keccak256(abi.encodePacked(params, field_depth))];\\n }\\n vm.record();\\n (, bytes32 callResult) = callTarget(self);\\n (bytes32[] memory reads,) = vm.accesses(address(who));\\n\\n if (reads.length == 0) {\\n revert(\\\"stdStorage find(StdStorage): No storage use detected for target.\\\");\\n } else {\\n for (uint256 i = reads.length; --i >= 0;) {\\n bytes32 prev = vm.load(who, reads[i]);\\n if (prev == bytes32(0)) {\\n emit WARNING_UninitedSlot(who, uint256(reads[i]));\\n }\\n\\n if (!checkSlotMutatesCall(self, reads[i])) {\\n continue;\\n }\\n\\n (uint256 offsetLeft, uint256 offsetRight) = (0, 0);\\n\\n if (self._enable_packed_slots) {\\n bool found;\\n (found, offsetLeft, offsetRight) = findOffsets(self, reads[i]);\\n if (!found) {\\n continue;\\n }\\n }\\n\\n // Check that value between found offsets is equal to the current call result\\n uint256 curVal = (uint256(prev) & getMaskByOffsets(offsetLeft, offsetRight)) >> offsetRight;\\n\\n if (uint256(callResult) != curVal) {\\n continue;\\n }\\n\\n emit SlotFound(who, fsig, keccak256(abi.encodePacked(params, field_depth)), uint256(reads[i]));\\n self.finds[who][fsig][keccak256(abi.encodePacked(params, field_depth))] =\\n FindData(uint256(reads[i]), offsetLeft, offsetRight, true);\\n break;\\n }\\n }\\n\\n require(\\n self.finds[who][fsig][keccak256(abi.encodePacked(params, field_depth))].found,\\n \\\"stdStorage find(StdStorage): Slot(s) not found.\\\"\\n );\\n\\n if (_clear) {\\n clear(self);\\n }\\n return self.finds[who][fsig][keccak256(abi.encodePacked(params, field_depth))];\\n }\\n\\n function target(StdStorage storage self, address _target) internal returns (StdStorage storage) {\\n self._target = _target;\\n return self;\\n }\\n\\n function sig(StdStorage storage self, bytes4 _sig) internal returns (StdStorage storage) {\\n self._sig = _sig;\\n return self;\\n }\\n\\n function sig(StdStorage storage self, string memory _sig) internal returns (StdStorage storage) {\\n self._sig = sigs(_sig);\\n return self;\\n }\\n\\n function with_calldata(StdStorage storage self, bytes memory _calldata) internal returns (StdStorage storage) {\\n self._calldata = _calldata;\\n return self;\\n }\\n\\n function with_key(StdStorage storage self, address who) internal returns (StdStorage storage) {\\n self._keys.push(bytes32(uint256(uint160(who))));\\n return self;\\n }\\n\\n function with_key(StdStorage storage self, uint256 amt) internal returns (StdStorage storage) {\\n self._keys.push(bytes32(amt));\\n return self;\\n }\\n\\n function with_key(StdStorage storage self, bytes32 key) internal returns (StdStorage storage) {\\n self._keys.push(key);\\n return self;\\n }\\n\\n function enable_packed_slots(StdStorage storage self) internal returns (StdStorage storage) {\\n self._enable_packed_slots = true;\\n return self;\\n }\\n\\n function depth(StdStorage storage self, uint256 _depth) internal returns (StdStorage storage) {\\n self._depth = _depth;\\n return self;\\n }\\n\\n function read(StdStorage storage self) private returns (bytes memory) {\\n FindData storage data = find(self, false);\\n uint256 mask = getMaskByOffsets(data.offsetLeft, data.offsetRight);\\n uint256 value = (uint256(vm.load(self._target, bytes32(data.slot))) & mask) >> data.offsetRight;\\n clear(self);\\n return abi.encode(value);\\n }\\n\\n function read_bytes32(StdStorage storage self) internal returns (bytes32) {\\n return abi.decode(read(self), (bytes32));\\n }\\n\\n function read_bool(StdStorage storage self) internal returns (bool) {\\n int256 v = read_int(self);\\n if (v == 0) return false;\\n if (v == 1) return true;\\n revert(\\\"stdStorage read_bool(StdStorage): Cannot decode. Make sure you are reading a bool.\\\");\\n }\\n\\n function read_address(StdStorage storage self) internal returns (address) {\\n return abi.decode(read(self), (address));\\n }\\n\\n function read_uint(StdStorage storage self) internal returns (uint256) {\\n return abi.decode(read(self), (uint256));\\n }\\n\\n function read_int(StdStorage storage self) internal returns (int256) {\\n return abi.decode(read(self), (int256));\\n }\\n\\n function parent(StdStorage storage self) internal returns (uint256, bytes32) {\\n address who = self._target;\\n uint256 field_depth = self._depth;\\n vm.startMappingRecording();\\n uint256 child = find(self, true).slot - field_depth;\\n (bool found, bytes32 key, bytes32 parent_slot) = vm.getMappingKeyAndParentOf(who, bytes32(child));\\n if (!found) {\\n revert(\\n \\\"stdStorage read_bool(StdStorage): Cannot find parent. Make sure you give a slot and startMappingRecording() has been called.\\\"\\n );\\n }\\n return (uint256(parent_slot), key);\\n }\\n\\n function root(StdStorage storage self) internal returns (uint256) {\\n address who = self._target;\\n uint256 field_depth = self._depth;\\n vm.startMappingRecording();\\n uint256 child = find(self, true).slot - field_depth;\\n bool found;\\n bytes32 root_slot;\\n bytes32 parent_slot;\\n (found,, parent_slot) = vm.getMappingKeyAndParentOf(who, bytes32(child));\\n if (!found) {\\n revert(\\n \\\"stdStorage read_bool(StdStorage): Cannot find parent. Make sure you give a slot and startMappingRecording() has been called.\\\"\\n );\\n }\\n while (found) {\\n root_slot = parent_slot;\\n (found,, parent_slot) = vm.getMappingKeyAndParentOf(who, bytes32(root_slot));\\n }\\n return uint256(root_slot);\\n }\\n\\n function bytesToBytes32(bytes memory b, uint256 offset) private pure returns (bytes32) {\\n bytes32 out;\\n\\n uint256 max = b.length > 32 ? 32 : b.length;\\n for (uint256 i = 0; i < max; i++) {\\n out |= bytes32(b[offset + i] & 0xFF) >> (i * 8);\\n }\\n return out;\\n }\\n\\n function flatten(bytes32[] memory b) private pure returns (bytes memory) {\\n bytes memory result = new bytes(b.length * 32);\\n for (uint256 i = 0; i < b.length; i++) {\\n bytes32 k = b[i];\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(add(result, add(32, mul(32, i))), k)\\n }\\n }\\n\\n return result;\\n }\\n\\n function clear(StdStorage storage self) internal {\\n delete self._target;\\n delete self._sig;\\n delete self._keys;\\n delete self._depth;\\n delete self._enable_packed_slots;\\n delete self._calldata;\\n }\\n\\n // Returns mask which contains non-zero bits for values between `offsetLeft` and `offsetRight`\\n // (slotValue & mask) >> offsetRight will be the value of the given packed variable\\n function getMaskByOffsets(uint256 offsetLeft, uint256 offsetRight) internal pure returns (uint256 mask) {\\n // mask = ((1 << (256 - (offsetRight + offsetLeft))) - 1) << offsetRight;\\n // using assembly because (1 << 256) causes overflow\\n assembly {\\n mask := shl(offsetRight, sub(shl(sub(256, add(offsetRight, offsetLeft)), 1), 1))\\n }\\n }\\n\\n // Returns slot value with updated packed variable.\\n function getUpdatedSlotValue(bytes32 curValue, uint256 varValue, uint256 offsetLeft, uint256 offsetRight)\\n internal\\n pure\\n returns (bytes32 newValue)\\n {\\n return bytes32((uint256(curValue) & ~getMaskByOffsets(offsetLeft, offsetRight)) | (varValue << offsetRight));\\n }\\n}\\n\\nlibrary stdStorage {\\n Vm private constant vm = Vm(address(uint160(uint256(keccak256(\\\"hevm cheat code\\\")))));\\n\\n function sigs(string memory sigStr) internal pure returns (bytes4) {\\n return stdStorageSafe.sigs(sigStr);\\n }\\n\\n function find(StdStorage storage self) internal returns (uint256) {\\n return find(self, true);\\n }\\n\\n function find(StdStorage storage self, bool _clear) internal returns (uint256) {\\n return stdStorageSafe.find(self, _clear).slot;\\n }\\n\\n function target(StdStorage storage self, address _target) internal returns (StdStorage storage) {\\n return stdStorageSafe.target(self, _target);\\n }\\n\\n function sig(StdStorage storage self, bytes4 _sig) internal returns (StdStorage storage) {\\n return stdStorageSafe.sig(self, _sig);\\n }\\n\\n function sig(StdStorage storage self, string memory _sig) internal returns (StdStorage storage) {\\n return stdStorageSafe.sig(self, _sig);\\n }\\n\\n function with_key(StdStorage storage self, address who) internal returns (StdStorage storage) {\\n return stdStorageSafe.with_key(self, who);\\n }\\n\\n function with_key(StdStorage storage self, uint256 amt) internal returns (StdStorage storage) {\\n return stdStorageSafe.with_key(self, amt);\\n }\\n\\n function with_key(StdStorage storage self, bytes32 key) internal returns (StdStorage storage) {\\n return stdStorageSafe.with_key(self, key);\\n }\\n\\n function with_calldata(StdStorage storage self, bytes memory _calldata) internal returns (StdStorage storage) {\\n return stdStorageSafe.with_calldata(self, _calldata);\\n }\\n\\n function enable_packed_slots(StdStorage storage self) internal returns (StdStorage storage) {\\n return stdStorageSafe.enable_packed_slots(self);\\n }\\n\\n function depth(StdStorage storage self, uint256 _depth) internal returns (StdStorage storage) {\\n return stdStorageSafe.depth(self, _depth);\\n }\\n\\n function clear(StdStorage storage self) internal {\\n stdStorageSafe.clear(self);\\n }\\n\\n function checked_write(StdStorage storage self, address who) internal {\\n checked_write(self, bytes32(uint256(uint160(who))));\\n }\\n\\n function checked_write(StdStorage storage self, uint256 amt) internal {\\n checked_write(self, bytes32(amt));\\n }\\n\\n function checked_write_int(StdStorage storage self, int256 val) internal {\\n checked_write(self, bytes32(uint256(val)));\\n }\\n\\n function checked_write(StdStorage storage self, bool write) internal {\\n bytes32 t;\\n /// @solidity memory-safe-assembly\\n assembly {\\n t := write\\n }\\n checked_write(self, t);\\n }\\n\\n function checked_write(StdStorage storage self, bytes32 set) internal {\\n address who = self._target;\\n bytes4 fsig = self._sig;\\n uint256 field_depth = self._depth;\\n bytes memory params = stdStorageSafe.getCallParams(self);\\n\\n if (!self.finds[who][fsig][keccak256(abi.encodePacked(params, field_depth))].found) {\\n find(self, false);\\n }\\n FindData storage data = self.finds[who][fsig][keccak256(abi.encodePacked(params, field_depth))];\\n if ((data.offsetLeft + data.offsetRight) > 0) {\\n uint256 maxVal = 2 ** (256 - (data.offsetLeft + data.offsetRight));\\n require(\\n uint256(set) < maxVal,\\n string(\\n abi.encodePacked(\\n \\\"stdStorage find(StdStorage): Packed slot. We can't fit value greater than \\\",\\n vm.toString(maxVal)\\n )\\n )\\n );\\n }\\n bytes32 curVal = vm.load(who, bytes32(data.slot));\\n bytes32 valToSet = stdStorageSafe.getUpdatedSlotValue(curVal, uint256(set), data.offsetLeft, data.offsetRight);\\n\\n vm.store(who, bytes32(data.slot), valToSet);\\n\\n (bool success, bytes32 callResult) = stdStorageSafe.callTarget(self);\\n\\n if (!success || callResult != set) {\\n vm.store(who, bytes32(data.slot), curVal);\\n revert(\\\"stdStorage find(StdStorage): Failed to write value.\\\");\\n }\\n clear(self);\\n }\\n\\n function read_bytes32(StdStorage storage self) internal returns (bytes32) {\\n return stdStorageSafe.read_bytes32(self);\\n }\\n\\n function read_bool(StdStorage storage self) internal returns (bool) {\\n return stdStorageSafe.read_bool(self);\\n }\\n\\n function read_address(StdStorage storage self) internal returns (address) {\\n return stdStorageSafe.read_address(self);\\n }\\n\\n function read_uint(StdStorage storage self) internal returns (uint256) {\\n return stdStorageSafe.read_uint(self);\\n }\\n\\n function read_int(StdStorage storage self) internal returns (int256) {\\n return stdStorageSafe.read_int(self);\\n }\\n\\n function parent(StdStorage storage self) internal returns (uint256, bytes32) {\\n return stdStorageSafe.parent(self);\\n }\\n\\n function root(StdStorage storage self) internal returns (uint256) {\\n return stdStorageSafe.root(self);\\n }\\n}\\n\",\"keccak256\":\"0xb91ab24383a5872b894fc93325eef1add6cbbf981628f18e860068bf88bb7dcc\",\"license\":\"MIT\"},\"lib/forge-std/src/StdStyle.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity >=0.4.22 <0.9.0;\\n\\nimport {VmSafe} from \\\"./Vm.sol\\\";\\n\\nlibrary StdStyle {\\n VmSafe private constant vm = VmSafe(address(uint160(uint256(keccak256(\\\"hevm cheat code\\\")))));\\n\\n string constant RED = \\\"\\\\u001b[91m\\\";\\n string constant GREEN = \\\"\\\\u001b[92m\\\";\\n string constant YELLOW = \\\"\\\\u001b[93m\\\";\\n string constant BLUE = \\\"\\\\u001b[94m\\\";\\n string constant MAGENTA = \\\"\\\\u001b[95m\\\";\\n string constant CYAN = \\\"\\\\u001b[96m\\\";\\n string constant BOLD = \\\"\\\\u001b[1m\\\";\\n string constant DIM = \\\"\\\\u001b[2m\\\";\\n string constant ITALIC = \\\"\\\\u001b[3m\\\";\\n string constant UNDERLINE = \\\"\\\\u001b[4m\\\";\\n string constant INVERSE = \\\"\\\\u001b[7m\\\";\\n string constant RESET = \\\"\\\\u001b[0m\\\";\\n\\n function styleConcat(string memory style, string memory self) private pure returns (string memory) {\\n return string(abi.encodePacked(style, self, RESET));\\n }\\n\\n function red(string memory self) internal pure returns (string memory) {\\n return styleConcat(RED, self);\\n }\\n\\n function red(uint256 self) internal pure returns (string memory) {\\n return red(vm.toString(self));\\n }\\n\\n function red(int256 self) internal pure returns (string memory) {\\n return red(vm.toString(self));\\n }\\n\\n function red(address self) internal pure returns (string memory) {\\n return red(vm.toString(self));\\n }\\n\\n function red(bool self) internal pure returns (string memory) {\\n return red(vm.toString(self));\\n }\\n\\n function redBytes(bytes memory self) internal pure returns (string memory) {\\n return red(vm.toString(self));\\n }\\n\\n function redBytes32(bytes32 self) internal pure returns (string memory) {\\n return red(vm.toString(self));\\n }\\n\\n function green(string memory self) internal pure returns (string memory) {\\n return styleConcat(GREEN, self);\\n }\\n\\n function green(uint256 self) internal pure returns (string memory) {\\n return green(vm.toString(self));\\n }\\n\\n function green(int256 self) internal pure returns (string memory) {\\n return green(vm.toString(self));\\n }\\n\\n function green(address self) internal pure returns (string memory) {\\n return green(vm.toString(self));\\n }\\n\\n function green(bool self) internal pure returns (string memory) {\\n return green(vm.toString(self));\\n }\\n\\n function greenBytes(bytes memory self) internal pure returns (string memory) {\\n return green(vm.toString(self));\\n }\\n\\n function greenBytes32(bytes32 self) internal pure returns (string memory) {\\n return green(vm.toString(self));\\n }\\n\\n function yellow(string memory self) internal pure returns (string memory) {\\n return styleConcat(YELLOW, self);\\n }\\n\\n function yellow(uint256 self) internal pure returns (string memory) {\\n return yellow(vm.toString(self));\\n }\\n\\n function yellow(int256 self) internal pure returns (string memory) {\\n return yellow(vm.toString(self));\\n }\\n\\n function yellow(address self) internal pure returns (string memory) {\\n return yellow(vm.toString(self));\\n }\\n\\n function yellow(bool self) internal pure returns (string memory) {\\n return yellow(vm.toString(self));\\n }\\n\\n function yellowBytes(bytes memory self) internal pure returns (string memory) {\\n return yellow(vm.toString(self));\\n }\\n\\n function yellowBytes32(bytes32 self) internal pure returns (string memory) {\\n return yellow(vm.toString(self));\\n }\\n\\n function blue(string memory self) internal pure returns (string memory) {\\n return styleConcat(BLUE, self);\\n }\\n\\n function blue(uint256 self) internal pure returns (string memory) {\\n return blue(vm.toString(self));\\n }\\n\\n function blue(int256 self) internal pure returns (string memory) {\\n return blue(vm.toString(self));\\n }\\n\\n function blue(address self) internal pure returns (string memory) {\\n return blue(vm.toString(self));\\n }\\n\\n function blue(bool self) internal pure returns (string memory) {\\n return blue(vm.toString(self));\\n }\\n\\n function blueBytes(bytes memory self) internal pure returns (string memory) {\\n return blue(vm.toString(self));\\n }\\n\\n function blueBytes32(bytes32 self) internal pure returns (string memory) {\\n return blue(vm.toString(self));\\n }\\n\\n function magenta(string memory self) internal pure returns (string memory) {\\n return styleConcat(MAGENTA, self);\\n }\\n\\n function magenta(uint256 self) internal pure returns (string memory) {\\n return magenta(vm.toString(self));\\n }\\n\\n function magenta(int256 self) internal pure returns (string memory) {\\n return magenta(vm.toString(self));\\n }\\n\\n function magenta(address self) internal pure returns (string memory) {\\n return magenta(vm.toString(self));\\n }\\n\\n function magenta(bool self) internal pure returns (string memory) {\\n return magenta(vm.toString(self));\\n }\\n\\n function magentaBytes(bytes memory self) internal pure returns (string memory) {\\n return magenta(vm.toString(self));\\n }\\n\\n function magentaBytes32(bytes32 self) internal pure returns (string memory) {\\n return magenta(vm.toString(self));\\n }\\n\\n function cyan(string memory self) internal pure returns (string memory) {\\n return styleConcat(CYAN, self);\\n }\\n\\n function cyan(uint256 self) internal pure returns (string memory) {\\n return cyan(vm.toString(self));\\n }\\n\\n function cyan(int256 self) internal pure returns (string memory) {\\n return cyan(vm.toString(self));\\n }\\n\\n function cyan(address self) internal pure returns (string memory) {\\n return cyan(vm.toString(self));\\n }\\n\\n function cyan(bool self) internal pure returns (string memory) {\\n return cyan(vm.toString(self));\\n }\\n\\n function cyanBytes(bytes memory self) internal pure returns (string memory) {\\n return cyan(vm.toString(self));\\n }\\n\\n function cyanBytes32(bytes32 self) internal pure returns (string memory) {\\n return cyan(vm.toString(self));\\n }\\n\\n function bold(string memory self) internal pure returns (string memory) {\\n return styleConcat(BOLD, self);\\n }\\n\\n function bold(uint256 self) internal pure returns (string memory) {\\n return bold(vm.toString(self));\\n }\\n\\n function bold(int256 self) internal pure returns (string memory) {\\n return bold(vm.toString(self));\\n }\\n\\n function bold(address self) internal pure returns (string memory) {\\n return bold(vm.toString(self));\\n }\\n\\n function bold(bool self) internal pure returns (string memory) {\\n return bold(vm.toString(self));\\n }\\n\\n function boldBytes(bytes memory self) internal pure returns (string memory) {\\n return bold(vm.toString(self));\\n }\\n\\n function boldBytes32(bytes32 self) internal pure returns (string memory) {\\n return bold(vm.toString(self));\\n }\\n\\n function dim(string memory self) internal pure returns (string memory) {\\n return styleConcat(DIM, self);\\n }\\n\\n function dim(uint256 self) internal pure returns (string memory) {\\n return dim(vm.toString(self));\\n }\\n\\n function dim(int256 self) internal pure returns (string memory) {\\n return dim(vm.toString(self));\\n }\\n\\n function dim(address self) internal pure returns (string memory) {\\n return dim(vm.toString(self));\\n }\\n\\n function dim(bool self) internal pure returns (string memory) {\\n return dim(vm.toString(self));\\n }\\n\\n function dimBytes(bytes memory self) internal pure returns (string memory) {\\n return dim(vm.toString(self));\\n }\\n\\n function dimBytes32(bytes32 self) internal pure returns (string memory) {\\n return dim(vm.toString(self));\\n }\\n\\n function italic(string memory self) internal pure returns (string memory) {\\n return styleConcat(ITALIC, self);\\n }\\n\\n function italic(uint256 self) internal pure returns (string memory) {\\n return italic(vm.toString(self));\\n }\\n\\n function italic(int256 self) internal pure returns (string memory) {\\n return italic(vm.toString(self));\\n }\\n\\n function italic(address self) internal pure returns (string memory) {\\n return italic(vm.toString(self));\\n }\\n\\n function italic(bool self) internal pure returns (string memory) {\\n return italic(vm.toString(self));\\n }\\n\\n function italicBytes(bytes memory self) internal pure returns (string memory) {\\n return italic(vm.toString(self));\\n }\\n\\n function italicBytes32(bytes32 self) internal pure returns (string memory) {\\n return italic(vm.toString(self));\\n }\\n\\n function underline(string memory self) internal pure returns (string memory) {\\n return styleConcat(UNDERLINE, self);\\n }\\n\\n function underline(uint256 self) internal pure returns (string memory) {\\n return underline(vm.toString(self));\\n }\\n\\n function underline(int256 self) internal pure returns (string memory) {\\n return underline(vm.toString(self));\\n }\\n\\n function underline(address self) internal pure returns (string memory) {\\n return underline(vm.toString(self));\\n }\\n\\n function underline(bool self) internal pure returns (string memory) {\\n return underline(vm.toString(self));\\n }\\n\\n function underlineBytes(bytes memory self) internal pure returns (string memory) {\\n return underline(vm.toString(self));\\n }\\n\\n function underlineBytes32(bytes32 self) internal pure returns (string memory) {\\n return underline(vm.toString(self));\\n }\\n\\n function inverse(string memory self) internal pure returns (string memory) {\\n return styleConcat(INVERSE, self);\\n }\\n\\n function inverse(uint256 self) internal pure returns (string memory) {\\n return inverse(vm.toString(self));\\n }\\n\\n function inverse(int256 self) internal pure returns (string memory) {\\n return inverse(vm.toString(self));\\n }\\n\\n function inverse(address self) internal pure returns (string memory) {\\n return inverse(vm.toString(self));\\n }\\n\\n function inverse(bool self) internal pure returns (string memory) {\\n return inverse(vm.toString(self));\\n }\\n\\n function inverseBytes(bytes memory self) internal pure returns (string memory) {\\n return inverse(vm.toString(self));\\n }\\n\\n function inverseBytes32(bytes32 self) internal pure returns (string memory) {\\n return inverse(vm.toString(self));\\n }\\n}\\n\",\"keccak256\":\"0x43e2a8a9b9c2574dabe74f11adf6f782df218f463540e3b5b563609fe108597d\",\"license\":\"MIT\"},\"lib/forge-std/src/StdUtils.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity >=0.6.2 <0.9.0;\\n\\npragma experimental ABIEncoderV2;\\n\\nimport {IMulticall3} from \\\"./interfaces/IMulticall3.sol\\\";\\nimport {VmSafe} from \\\"./Vm.sol\\\";\\n\\nabstract contract StdUtils {\\n /*//////////////////////////////////////////////////////////////////////////\\n CONSTANTS\\n //////////////////////////////////////////////////////////////////////////*/\\n\\n IMulticall3 private constant multicall = IMulticall3(0xcA11bde05977b3631167028862bE2a173976CA11);\\n VmSafe private constant vm = VmSafe(address(uint160(uint256(keccak256(\\\"hevm cheat code\\\")))));\\n address private constant CONSOLE2_ADDRESS = 0x000000000000000000636F6e736F6c652e6c6f67;\\n uint256 private constant INT256_MIN_ABS =\\n 57896044618658097711785492504343953926634992332820282019728792003956564819968;\\n uint256 private constant SECP256K1_ORDER =\\n 115792089237316195423570985008687907852837564279074904382605163141518161494337;\\n uint256 private constant UINT256_MAX =\\n 115792089237316195423570985008687907853269984665640564039457584007913129639935;\\n\\n // Used by default when deploying with create2, https://github.com/Arachnid/deterministic-deployment-proxy.\\n address private constant CREATE2_FACTORY = 0x4e59b44847b379578588920cA78FbF26c0B4956C;\\n\\n /*//////////////////////////////////////////////////////////////////////////\\n INTERNAL FUNCTIONS\\n //////////////////////////////////////////////////////////////////////////*/\\n\\n function _bound(uint256 x, uint256 min, uint256 max) internal pure virtual returns (uint256 result) {\\n require(min <= max, \\\"StdUtils bound(uint256,uint256,uint256): Max is less than min.\\\");\\n // If x is between min and max, return x directly. This is to ensure that dictionary values\\n // do not get shifted if the min is nonzero. More info: https://github.com/foundry-rs/forge-std/issues/188\\n if (x >= min && x <= max) return x;\\n\\n uint256 size = max - min + 1;\\n\\n // If the value is 0, 1, 2, 3, wrap that to min, min+1, min+2, min+3. Similarly for the UINT256_MAX side.\\n // This helps ensure coverage of the min/max values.\\n if (x <= 3 && size > x) return min + x;\\n if (x >= UINT256_MAX - 3 && size > UINT256_MAX - x) return max - (UINT256_MAX - x);\\n\\n // Otherwise, wrap x into the range [min, max], i.e. the range is inclusive.\\n if (x > max) {\\n uint256 diff = x - max;\\n uint256 rem = diff % size;\\n if (rem == 0) return max;\\n result = min + rem - 1;\\n } else if (x < min) {\\n uint256 diff = min - x;\\n uint256 rem = diff % size;\\n if (rem == 0) return min;\\n result = max - rem + 1;\\n }\\n }\\n\\n function bound(uint256 x, uint256 min, uint256 max) internal pure virtual returns (uint256 result) {\\n result = _bound(x, min, max);\\n console2_log_StdUtils(\\\"Bound result\\\", result);\\n }\\n\\n function _bound(int256 x, int256 min, int256 max) internal pure virtual returns (int256 result) {\\n require(min <= max, \\\"StdUtils bound(int256,int256,int256): Max is less than min.\\\");\\n\\n // Shifting all int256 values to uint256 to use _bound function. The range of two types are:\\n // int256 : -(2**255) ~ (2**255 - 1)\\n // uint256: 0 ~ (2**256 - 1)\\n // So, add 2**255, INT256_MIN_ABS to the integer values.\\n //\\n // If the given integer value is -2**255, we cannot use `-uint256(-x)` because of the overflow.\\n // So, use `~uint256(x) + 1` instead.\\n uint256 _x = x < 0 ? (INT256_MIN_ABS - ~uint256(x) - 1) : (uint256(x) + INT256_MIN_ABS);\\n uint256 _min = min < 0 ? (INT256_MIN_ABS - ~uint256(min) - 1) : (uint256(min) + INT256_MIN_ABS);\\n uint256 _max = max < 0 ? (INT256_MIN_ABS - ~uint256(max) - 1) : (uint256(max) + INT256_MIN_ABS);\\n\\n uint256 y = _bound(_x, _min, _max);\\n\\n // To move it back to int256 value, subtract INT256_MIN_ABS at here.\\n result = y < INT256_MIN_ABS ? int256(~(INT256_MIN_ABS - y) + 1) : int256(y - INT256_MIN_ABS);\\n }\\n\\n function bound(int256 x, int256 min, int256 max) internal pure virtual returns (int256 result) {\\n result = _bound(x, min, max);\\n console2_log_StdUtils(\\\"Bound result\\\", vm.toString(result));\\n }\\n\\n function boundPrivateKey(uint256 privateKey) internal pure virtual returns (uint256 result) {\\n result = _bound(privateKey, 1, SECP256K1_ORDER - 1);\\n }\\n\\n function bytesToUint(bytes memory b) internal pure virtual returns (uint256) {\\n require(b.length <= 32, \\\"StdUtils bytesToUint(bytes): Bytes length exceeds 32.\\\");\\n return abi.decode(abi.encodePacked(new bytes(32 - b.length), b), (uint256));\\n }\\n\\n /// @dev Compute the address a contract will be deployed at for a given deployer address and nonce\\n /// @notice adapted from Solmate implementation (https://github.com/Rari-Capital/solmate/blob/main/src/utils/LibRLP.sol)\\n function computeCreateAddress(address deployer, uint256 nonce) internal pure virtual returns (address) {\\n console2_log_StdUtils(\\\"computeCreateAddress is deprecated. Please use vm.computeCreateAddress instead.\\\");\\n return vm.computeCreateAddress(deployer, nonce);\\n }\\n\\n function computeCreate2Address(bytes32 salt, bytes32 initcodeHash, address deployer)\\n internal\\n pure\\n virtual\\n returns (address)\\n {\\n console2_log_StdUtils(\\\"computeCreate2Address is deprecated. Please use vm.computeCreate2Address instead.\\\");\\n return vm.computeCreate2Address(salt, initcodeHash, deployer);\\n }\\n\\n /// @dev returns the address of a contract created with CREATE2 using the default CREATE2 deployer\\n function computeCreate2Address(bytes32 salt, bytes32 initCodeHash) internal pure returns (address) {\\n console2_log_StdUtils(\\\"computeCreate2Address is deprecated. Please use vm.computeCreate2Address instead.\\\");\\n return vm.computeCreate2Address(salt, initCodeHash);\\n }\\n\\n /// @dev returns the hash of the init code (creation code + no args) used in CREATE2 with no constructor arguments\\n /// @param creationCode the creation code of a contract C, as returned by type(C).creationCode\\n function hashInitCode(bytes memory creationCode) internal pure returns (bytes32) {\\n return hashInitCode(creationCode, \\\"\\\");\\n }\\n\\n /// @dev returns the hash of the init code (creation code + ABI-encoded args) used in CREATE2\\n /// @param creationCode the creation code of a contract C, as returned by type(C).creationCode\\n /// @param args the ABI-encoded arguments to the constructor of C\\n function hashInitCode(bytes memory creationCode, bytes memory args) internal pure returns (bytes32) {\\n return keccak256(abi.encodePacked(creationCode, args));\\n }\\n\\n // Performs a single call with Multicall3 to query the ERC-20 token balances of the given addresses.\\n function getTokenBalances(address token, address[] memory addresses)\\n internal\\n virtual\\n returns (uint256[] memory balances)\\n {\\n uint256 tokenCodeSize;\\n assembly {\\n tokenCodeSize := extcodesize(token)\\n }\\n require(tokenCodeSize > 0, \\\"StdUtils getTokenBalances(address,address[]): Token address is not a contract.\\\");\\n\\n // ABI encode the aggregate call to Multicall3.\\n uint256 length = addresses.length;\\n IMulticall3.Call[] memory calls = new IMulticall3.Call[](length);\\n for (uint256 i = 0; i < length; ++i) {\\n // 0x70a08231 = bytes4(\\\"balanceOf(address)\\\"))\\n calls[i] = IMulticall3.Call({target: token, callData: abi.encodeWithSelector(0x70a08231, (addresses[i]))});\\n }\\n\\n // Make the aggregate call.\\n (, bytes[] memory returnData) = multicall.aggregate(calls);\\n\\n // ABI decode the return data and return the balances.\\n balances = new uint256[](length);\\n for (uint256 i = 0; i < length; ++i) {\\n balances[i] = abi.decode(returnData[i], (uint256));\\n }\\n }\\n\\n /*//////////////////////////////////////////////////////////////////////////\\n PRIVATE FUNCTIONS\\n //////////////////////////////////////////////////////////////////////////*/\\n\\n function addressFromLast20Bytes(bytes32 bytesValue) private pure returns (address) {\\n return address(uint160(uint256(bytesValue)));\\n }\\n\\n // This section is used to prevent the compilation of console, which shortens the compilation time when console is\\n // not used elsewhere. We also trick the compiler into letting us make the console log methods as `pure` to avoid\\n // any breaking changes to function signatures.\\n function _castLogPayloadViewToPure(function(bytes memory) internal view fnIn)\\n internal\\n pure\\n returns (function(bytes memory) internal pure fnOut)\\n {\\n assembly {\\n fnOut := fnIn\\n }\\n }\\n\\n function _sendLogPayload(bytes memory payload) internal pure {\\n _castLogPayloadViewToPure(_sendLogPayloadView)(payload);\\n }\\n\\n function _sendLogPayloadView(bytes memory payload) private view {\\n uint256 payloadLength = payload.length;\\n address consoleAddress = CONSOLE2_ADDRESS;\\n /// @solidity memory-safe-assembly\\n assembly {\\n let payloadStart := add(payload, 32)\\n let r := staticcall(gas(), consoleAddress, payloadStart, payloadLength, 0, 0)\\n }\\n }\\n\\n function console2_log_StdUtils(string memory p0) private pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string)\\\", p0));\\n }\\n\\n function console2_log_StdUtils(string memory p0, uint256 p1) private pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,uint256)\\\", p0, p1));\\n }\\n\\n function console2_log_StdUtils(string memory p0, string memory p1) private pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,string)\\\", p0, p1));\\n }\\n}\\n\",\"keccak256\":\"0x7274081e11c05164fd8eadde4de8305c033e58a43008dea58065f3170ccf0737\",\"license\":\"MIT\"},\"lib/forge-std/src/Vm.sol\":{\"content\":\"// Automatically @generated by scripts/vm.py. Do not modify manually.\\n\\n// SPDX-License-Identifier: MIT OR Apache-2.0\\npragma solidity >=0.6.2 <0.9.0;\\npragma experimental ABIEncoderV2;\\n\\n/// The `VmSafe` interface does not allow manipulation of the EVM state or other actions that may\\n/// result in Script simulations differing from on-chain execution. It is recommended to only use\\n/// these cheats in scripts.\\ninterface VmSafe {\\n /// A modification applied to either `msg.sender` or `tx.origin`. Returned by `readCallers`.\\n enum CallerMode {\\n // No caller modification is currently active.\\n None,\\n // A one time broadcast triggered by a `vm.broadcast()` call is currently active.\\n Broadcast,\\n // A recurrent broadcast triggered by a `vm.startBroadcast()` call is currently active.\\n RecurrentBroadcast,\\n // A one time prank triggered by a `vm.prank()` call is currently active.\\n Prank,\\n // A recurrent prank triggered by a `vm.startPrank()` call is currently active.\\n RecurrentPrank\\n }\\n\\n /// The kind of account access that occurred.\\n enum AccountAccessKind {\\n // The account was called.\\n Call,\\n // The account was called via delegatecall.\\n DelegateCall,\\n // The account was called via callcode.\\n CallCode,\\n // The account was called via staticcall.\\n StaticCall,\\n // The account was created.\\n Create,\\n // The account was selfdestructed.\\n SelfDestruct,\\n // Synthetic access indicating the current context has resumed after a previous sub-context (AccountAccess).\\n Resume,\\n // The account's balance was read.\\n Balance,\\n // The account's codesize was read.\\n Extcodesize,\\n // The account's codehash was read.\\n Extcodehash,\\n // The account's code was copied.\\n Extcodecopy\\n }\\n\\n /// Forge execution contexts.\\n enum ForgeContext {\\n // Test group execution context (test, coverage or snapshot).\\n TestGroup,\\n // `forge test` execution context.\\n Test,\\n // `forge coverage` execution context.\\n Coverage,\\n // `forge snapshot` execution context.\\n Snapshot,\\n // Script group execution context (dry run, broadcast or resume).\\n ScriptGroup,\\n // `forge script` execution context.\\n ScriptDryRun,\\n // `forge script --broadcast` execution context.\\n ScriptBroadcast,\\n // `forge script --resume` execution context.\\n ScriptResume,\\n // Unknown `forge` execution context.\\n Unknown\\n }\\n\\n /// The transaction type (`txType`) of the broadcast.\\n enum BroadcastTxType {\\n // Represents a CALL broadcast tx.\\n Call,\\n // Represents a CREATE broadcast tx.\\n Create,\\n // Represents a CREATE2 broadcast tx.\\n Create2\\n }\\n\\n /// An Ethereum log. Returned by `getRecordedLogs`.\\n struct Log {\\n // The topics of the log, including the signature, if any.\\n bytes32[] topics;\\n // The raw data of the log.\\n bytes data;\\n // The address of the log's emitter.\\n address emitter;\\n }\\n\\n /// An RPC URL and its alias. Returned by `rpcUrlStructs`.\\n struct Rpc {\\n // The alias of the RPC URL.\\n string key;\\n // The RPC URL.\\n string url;\\n }\\n\\n /// An RPC log object. Returned by `eth_getLogs`.\\n struct EthGetLogs {\\n // The address of the log's emitter.\\n address emitter;\\n // The topics of the log, including the signature, if any.\\n bytes32[] topics;\\n // The raw data of the log.\\n bytes data;\\n // The block hash.\\n bytes32 blockHash;\\n // The block number.\\n uint64 blockNumber;\\n // The transaction hash.\\n bytes32 transactionHash;\\n // The transaction index in the block.\\n uint64 transactionIndex;\\n // The log index.\\n uint256 logIndex;\\n // Whether the log was removed.\\n bool removed;\\n }\\n\\n /// A single entry in a directory listing. Returned by `readDir`.\\n struct DirEntry {\\n // The error message, if any.\\n string errorMessage;\\n // The path of the entry.\\n string path;\\n // The depth of the entry.\\n uint64 depth;\\n // Whether the entry is a directory.\\n bool isDir;\\n // Whether the entry is a symlink.\\n bool isSymlink;\\n }\\n\\n /// Metadata information about a file.\\n /// This structure is returned from the `fsMetadata` function and represents known\\n /// metadata about a file such as its permissions, size, modification\\n /// times, etc.\\n struct FsMetadata {\\n // True if this metadata is for a directory.\\n bool isDir;\\n // True if this metadata is for a symlink.\\n bool isSymlink;\\n // The size of the file, in bytes, this metadata is for.\\n uint256 length;\\n // True if this metadata is for a readonly (unwritable) file.\\n bool readOnly;\\n // The last modification time listed in this metadata.\\n uint256 modified;\\n // The last access time of this metadata.\\n uint256 accessed;\\n // The creation time listed in this metadata.\\n uint256 created;\\n }\\n\\n /// A wallet with a public and private key.\\n struct Wallet {\\n // The wallet's address.\\n address addr;\\n // The wallet's public key `X`.\\n uint256 publicKeyX;\\n // The wallet's public key `Y`.\\n uint256 publicKeyY;\\n // The wallet's private key.\\n uint256 privateKey;\\n }\\n\\n /// The result of a `tryFfi` call.\\n struct FfiResult {\\n // The exit code of the call.\\n int32 exitCode;\\n // The optionally hex-decoded `stdout` data.\\n bytes stdout;\\n // The `stderr` data.\\n bytes stderr;\\n }\\n\\n /// Information on the chain and fork.\\n struct ChainInfo {\\n // The fork identifier. Set to zero if no fork is active.\\n uint256 forkId;\\n // The chain ID of the current fork.\\n uint256 chainId;\\n }\\n\\n /// The result of a `stopAndReturnStateDiff` call.\\n struct AccountAccess {\\n // The chain and fork the access occurred.\\n ChainInfo chainInfo;\\n // The kind of account access that determines what the account is.\\n // If kind is Call, DelegateCall, StaticCall or CallCode, then the account is the callee.\\n // If kind is Create, then the account is the newly created account.\\n // If kind is SelfDestruct, then the account is the selfdestruct recipient.\\n // If kind is a Resume, then account represents a account context that has resumed.\\n AccountAccessKind kind;\\n // The account that was accessed.\\n // It's either the account created, callee or a selfdestruct recipient for CREATE, CALL or SELFDESTRUCT.\\n address account;\\n // What accessed the account.\\n address accessor;\\n // If the account was initialized or empty prior to the access.\\n // An account is considered initialized if it has code, a\\n // non-zero nonce, or a non-zero balance.\\n bool initialized;\\n // The previous balance of the accessed account.\\n uint256 oldBalance;\\n // The potential new balance of the accessed account.\\n // That is, all balance changes are recorded here, even if reverts occurred.\\n uint256 newBalance;\\n // Code of the account deployed by CREATE.\\n bytes deployedCode;\\n // Value passed along with the account access\\n uint256 value;\\n // Input data provided to the CREATE or CALL\\n bytes data;\\n // If this access reverted in either the current or parent context.\\n bool reverted;\\n // An ordered list of storage accesses made during an account access operation.\\n StorageAccess[] storageAccesses;\\n // Call depth traversed during the recording of state differences\\n uint64 depth;\\n }\\n\\n /// The storage accessed during an `AccountAccess`.\\n struct StorageAccess {\\n // The account whose storage was accessed.\\n address account;\\n // The slot that was accessed.\\n bytes32 slot;\\n // If the access was a write.\\n bool isWrite;\\n // The previous value of the slot.\\n bytes32 previousValue;\\n // The new value of the slot.\\n bytes32 newValue;\\n // If the access was reverted.\\n bool reverted;\\n }\\n\\n /// Gas used. Returned by `lastCallGas`.\\n struct Gas {\\n // The gas limit of the call.\\n uint64 gasLimit;\\n // The total gas used.\\n uint64 gasTotalUsed;\\n // DEPRECATED: The amount of gas used for memory expansion. Ref: \\n uint64 gasMemoryUsed;\\n // The amount of gas refunded.\\n int64 gasRefunded;\\n // The amount of gas remaining.\\n uint64 gasRemaining;\\n }\\n\\n /// The result of the `stopDebugTraceRecording` call\\n struct DebugStep {\\n // The stack before executing the step of the run.\\n // stack\\\\[0\\\\] represents the top of the stack.\\n // and only stack data relevant to the opcode execution is contained.\\n uint256[] stack;\\n // The memory input data before executing the step of the run.\\n // only input data relevant to the opcode execution is contained.\\n // e.g. for MLOAD, it will have memory\\\\[offset:offset+32\\\\] copied here.\\n // the offset value can be get by the stack data.\\n bytes memoryInput;\\n // The opcode that was accessed.\\n uint8 opcode;\\n // The call depth of the step.\\n uint64 depth;\\n // Whether the call end up with out of gas error.\\n bool isOutOfGas;\\n // The contract address where the opcode is running\\n address contractAddr;\\n }\\n\\n /// Represents a transaction's broadcast details.\\n struct BroadcastTxSummary {\\n // The hash of the transaction that was broadcasted\\n bytes32 txHash;\\n // Represent the type of transaction among CALL, CREATE, CREATE2\\n BroadcastTxType txType;\\n // The address of the contract that was called or created.\\n // This is address of the contract that is created if the txType is CREATE or CREATE2.\\n address contractAddress;\\n // The block number the transaction landed in.\\n uint64 blockNumber;\\n // Status of the transaction, retrieved from the transaction receipt.\\n bool success;\\n }\\n\\n /// Holds a signed EIP-7702 authorization for an authority account to delegate to an implementation.\\n struct SignedDelegation {\\n // The y-parity of the recovered secp256k1 signature (0 or 1).\\n uint8 v;\\n // First 32 bytes of the signature.\\n bytes32 r;\\n // Second 32 bytes of the signature.\\n bytes32 s;\\n // The current nonce of the authority account at signing time.\\n // Used to ensure signature can't be replayed after account nonce changes.\\n uint64 nonce;\\n // Address of the contract implementation that will be delegated to.\\n // Gets encoded into delegation code: 0xef0100 || implementation.\\n address implementation;\\n }\\n\\n /// Represents a \\\"potential\\\" revert reason from a single subsequent call when using `vm.assumeNoReverts`.\\n /// Reverts that match will result in a FOUNDRY::ASSUME rejection, whereas unmatched reverts will be surfaced\\n /// as normal.\\n struct PotentialRevert {\\n // The allowed origin of the revert opcode; address(0) allows reverts from any address\\n address reverter;\\n // When true, only matches on the beginning of the revert data, otherwise, matches on entire revert data\\n bool partialMatch;\\n // The data to use to match encountered reverts\\n bytes revertData;\\n }\\n\\n /// An EIP-2930 access list item.\\n struct AccessListItem {\\n // The address to be added in access list.\\n address target;\\n // The storage keys to be added in access list.\\n bytes32[] storageKeys;\\n }\\n\\n // ======== Crypto ========\\n\\n /// Derives a private key from the name, labels the account with that name, and returns the wallet.\\n function createWallet(string calldata walletLabel) external returns (Wallet memory wallet);\\n\\n /// Generates a wallet from the private key and returns the wallet.\\n function createWallet(uint256 privateKey) external returns (Wallet memory wallet);\\n\\n /// Generates a wallet from the private key, labels the account with that name, and returns the wallet.\\n function createWallet(uint256 privateKey, string calldata walletLabel) external returns (Wallet memory wallet);\\n\\n /// Derive a private key from a provided mnenomic string (or mnenomic file path)\\n /// at the derivation path `m/44'/60'/0'/0/{index}`.\\n function deriveKey(string calldata mnemonic, uint32 index) external pure returns (uint256 privateKey);\\n\\n /// Derive a private key from a provided mnenomic string (or mnenomic file path)\\n /// at `{derivationPath}{index}`.\\n function deriveKey(string calldata mnemonic, string calldata derivationPath, uint32 index)\\n external\\n pure\\n returns (uint256 privateKey);\\n\\n /// Derive a private key from a provided mnenomic string (or mnenomic file path) in the specified language\\n /// at the derivation path `m/44'/60'/0'/0/{index}`.\\n function deriveKey(string calldata mnemonic, uint32 index, string calldata language)\\n external\\n pure\\n returns (uint256 privateKey);\\n\\n /// Derive a private key from a provided mnenomic string (or mnenomic file path) in the specified language\\n /// at `{derivationPath}{index}`.\\n function deriveKey(string calldata mnemonic, string calldata derivationPath, uint32 index, string calldata language)\\n external\\n pure\\n returns (uint256 privateKey);\\n\\n /// Derives secp256r1 public key from the provided `privateKey`.\\n function publicKeyP256(uint256 privateKey) external pure returns (uint256 publicKeyX, uint256 publicKeyY);\\n\\n /// Adds a private key to the local forge wallet and returns the address.\\n function rememberKey(uint256 privateKey) external returns (address keyAddr);\\n\\n /// Derive a set number of wallets from a mnemonic at the derivation path `m/44'/60'/0'/0/{0..count}`.\\n /// The respective private keys are saved to the local forge wallet for later use and their addresses are returned.\\n function rememberKeys(string calldata mnemonic, string calldata derivationPath, uint32 count)\\n external\\n returns (address[] memory keyAddrs);\\n\\n /// Derive a set number of wallets from a mnemonic in the specified language at the derivation path `m/44'/60'/0'/0/{0..count}`.\\n /// The respective private keys are saved to the local forge wallet for later use and their addresses are returned.\\n function rememberKeys(\\n string calldata mnemonic,\\n string calldata derivationPath,\\n string calldata language,\\n uint32 count\\n ) external returns (address[] memory keyAddrs);\\n\\n /// Signs data with a `Wallet`.\\n /// Returns a compact signature (`r`, `vs`) as per EIP-2098, where `vs` encodes both the\\n /// signature's `s` value, and the recovery id `v` in a single bytes32.\\n /// This format reduces the signature size from 65 to 64 bytes.\\n function signCompact(Wallet calldata wallet, bytes32 digest) external returns (bytes32 r, bytes32 vs);\\n\\n /// Signs `digest` with `privateKey` using the secp256k1 curve.\\n /// Returns a compact signature (`r`, `vs`) as per EIP-2098, where `vs` encodes both the\\n /// signature's `s` value, and the recovery id `v` in a single bytes32.\\n /// This format reduces the signature size from 65 to 64 bytes.\\n function signCompact(uint256 privateKey, bytes32 digest) external pure returns (bytes32 r, bytes32 vs);\\n\\n /// Signs `digest` with signer provided to script using the secp256k1 curve.\\n /// Returns a compact signature (`r`, `vs`) as per EIP-2098, where `vs` encodes both the\\n /// signature's `s` value, and the recovery id `v` in a single bytes32.\\n /// This format reduces the signature size from 65 to 64 bytes.\\n /// If `--sender` is provided, the signer with provided address is used, otherwise,\\n /// if exactly one signer is provided to the script, that signer is used.\\n /// Raises error if signer passed through `--sender` does not match any unlocked signers or\\n /// if `--sender` is not provided and not exactly one signer is passed to the script.\\n function signCompact(bytes32 digest) external pure returns (bytes32 r, bytes32 vs);\\n\\n /// Signs `digest` with signer provided to script using the secp256k1 curve.\\n /// Returns a compact signature (`r`, `vs`) as per EIP-2098, where `vs` encodes both the\\n /// signature's `s` value, and the recovery id `v` in a single bytes32.\\n /// This format reduces the signature size from 65 to 64 bytes.\\n /// Raises error if none of the signers passed into the script have provided address.\\n function signCompact(address signer, bytes32 digest) external pure returns (bytes32 r, bytes32 vs);\\n\\n /// Signs `digest` with `privateKey` using the secp256r1 curve.\\n function signP256(uint256 privateKey, bytes32 digest) external pure returns (bytes32 r, bytes32 s);\\n\\n /// Signs data with a `Wallet`.\\n function sign(Wallet calldata wallet, bytes32 digest) external returns (uint8 v, bytes32 r, bytes32 s);\\n\\n /// Signs `digest` with `privateKey` using the secp256k1 curve.\\n function sign(uint256 privateKey, bytes32 digest) external pure returns (uint8 v, bytes32 r, bytes32 s);\\n\\n /// Signs `digest` with signer provided to script using the secp256k1 curve.\\n /// If `--sender` is provided, the signer with provided address is used, otherwise,\\n /// if exactly one signer is provided to the script, that signer is used.\\n /// Raises error if signer passed through `--sender` does not match any unlocked signers or\\n /// if `--sender` is not provided and not exactly one signer is passed to the script.\\n function sign(bytes32 digest) external pure returns (uint8 v, bytes32 r, bytes32 s);\\n\\n /// Signs `digest` with signer provided to script using the secp256k1 curve.\\n /// Raises error if none of the signers passed into the script have provided address.\\n function sign(address signer, bytes32 digest) external pure returns (uint8 v, bytes32 r, bytes32 s);\\n\\n // ======== Environment ========\\n\\n /// Gets the environment variable `name` and parses it as `address`.\\n /// Reverts if the variable was not found or could not be parsed.\\n function envAddress(string calldata name) external view returns (address value);\\n\\n /// Gets the environment variable `name` and parses it as an array of `address`, delimited by `delim`.\\n /// Reverts if the variable was not found or could not be parsed.\\n function envAddress(string calldata name, string calldata delim) external view returns (address[] memory value);\\n\\n /// Gets the environment variable `name` and parses it as `bool`.\\n /// Reverts if the variable was not found or could not be parsed.\\n function envBool(string calldata name) external view returns (bool value);\\n\\n /// Gets the environment variable `name` and parses it as an array of `bool`, delimited by `delim`.\\n /// Reverts if the variable was not found or could not be parsed.\\n function envBool(string calldata name, string calldata delim) external view returns (bool[] memory value);\\n\\n /// Gets the environment variable `name` and parses it as `bytes32`.\\n /// Reverts if the variable was not found or could not be parsed.\\n function envBytes32(string calldata name) external view returns (bytes32 value);\\n\\n /// Gets the environment variable `name` and parses it as an array of `bytes32`, delimited by `delim`.\\n /// Reverts if the variable was not found or could not be parsed.\\n function envBytes32(string calldata name, string calldata delim) external view returns (bytes32[] memory value);\\n\\n /// Gets the environment variable `name` and parses it as `bytes`.\\n /// Reverts if the variable was not found or could not be parsed.\\n function envBytes(string calldata name) external view returns (bytes memory value);\\n\\n /// Gets the environment variable `name` and parses it as an array of `bytes`, delimited by `delim`.\\n /// Reverts if the variable was not found or could not be parsed.\\n function envBytes(string calldata name, string calldata delim) external view returns (bytes[] memory value);\\n\\n /// Gets the environment variable `name` and returns true if it exists, else returns false.\\n function envExists(string calldata name) external view returns (bool result);\\n\\n /// Gets the environment variable `name` and parses it as `int256`.\\n /// Reverts if the variable was not found or could not be parsed.\\n function envInt(string calldata name) external view returns (int256 value);\\n\\n /// Gets the environment variable `name` and parses it as an array of `int256`, delimited by `delim`.\\n /// Reverts if the variable was not found or could not be parsed.\\n function envInt(string calldata name, string calldata delim) external view returns (int256[] memory value);\\n\\n /// Gets the environment variable `name` and parses it as `bool`.\\n /// Reverts if the variable could not be parsed.\\n /// Returns `defaultValue` if the variable was not found.\\n function envOr(string calldata name, bool defaultValue) external view returns (bool value);\\n\\n /// Gets the environment variable `name` and parses it as `uint256`.\\n /// Reverts if the variable could not be parsed.\\n /// Returns `defaultValue` if the variable was not found.\\n function envOr(string calldata name, uint256 defaultValue) external view returns (uint256 value);\\n\\n /// Gets the environment variable `name` and parses it as an array of `address`, delimited by `delim`.\\n /// Reverts if the variable could not be parsed.\\n /// Returns `defaultValue` if the variable was not found.\\n function envOr(string calldata name, string calldata delim, address[] calldata defaultValue)\\n external\\n view\\n returns (address[] memory value);\\n\\n /// Gets the environment variable `name` and parses it as an array of `bytes32`, delimited by `delim`.\\n /// Reverts if the variable could not be parsed.\\n /// Returns `defaultValue` if the variable was not found.\\n function envOr(string calldata name, string calldata delim, bytes32[] calldata defaultValue)\\n external\\n view\\n returns (bytes32[] memory value);\\n\\n /// Gets the environment variable `name` and parses it as an array of `string`, delimited by `delim`.\\n /// Reverts if the variable could not be parsed.\\n /// Returns `defaultValue` if the variable was not found.\\n function envOr(string calldata name, string calldata delim, string[] calldata defaultValue)\\n external\\n view\\n returns (string[] memory value);\\n\\n /// Gets the environment variable `name` and parses it as an array of `bytes`, delimited by `delim`.\\n /// Reverts if the variable could not be parsed.\\n /// Returns `defaultValue` if the variable was not found.\\n function envOr(string calldata name, string calldata delim, bytes[] calldata defaultValue)\\n external\\n view\\n returns (bytes[] memory value);\\n\\n /// Gets the environment variable `name` and parses it as `int256`.\\n /// Reverts if the variable could not be parsed.\\n /// Returns `defaultValue` if the variable was not found.\\n function envOr(string calldata name, int256 defaultValue) external view returns (int256 value);\\n\\n /// Gets the environment variable `name` and parses it as `address`.\\n /// Reverts if the variable could not be parsed.\\n /// Returns `defaultValue` if the variable was not found.\\n function envOr(string calldata name, address defaultValue) external view returns (address value);\\n\\n /// Gets the environment variable `name` and parses it as `bytes32`.\\n /// Reverts if the variable could not be parsed.\\n /// Returns `defaultValue` if the variable was not found.\\n function envOr(string calldata name, bytes32 defaultValue) external view returns (bytes32 value);\\n\\n /// Gets the environment variable `name` and parses it as `string`.\\n /// Reverts if the variable could not be parsed.\\n /// Returns `defaultValue` if the variable was not found.\\n function envOr(string calldata name, string calldata defaultValue) external view returns (string memory value);\\n\\n /// Gets the environment variable `name` and parses it as `bytes`.\\n /// Reverts if the variable could not be parsed.\\n /// Returns `defaultValue` if the variable was not found.\\n function envOr(string calldata name, bytes calldata defaultValue) external view returns (bytes memory value);\\n\\n /// Gets the environment variable `name` and parses it as an array of `bool`, delimited by `delim`.\\n /// Reverts if the variable could not be parsed.\\n /// Returns `defaultValue` if the variable was not found.\\n function envOr(string calldata name, string calldata delim, bool[] calldata defaultValue)\\n external\\n view\\n returns (bool[] memory value);\\n\\n /// Gets the environment variable `name` and parses it as an array of `uint256`, delimited by `delim`.\\n /// Reverts if the variable could not be parsed.\\n /// Returns `defaultValue` if the variable was not found.\\n function envOr(string calldata name, string calldata delim, uint256[] calldata defaultValue)\\n external\\n view\\n returns (uint256[] memory value);\\n\\n /// Gets the environment variable `name` and parses it as an array of `int256`, delimited by `delim`.\\n /// Reverts if the variable could not be parsed.\\n /// Returns `defaultValue` if the variable was not found.\\n function envOr(string calldata name, string calldata delim, int256[] calldata defaultValue)\\n external\\n view\\n returns (int256[] memory value);\\n\\n /// Gets the environment variable `name` and parses it as `string`.\\n /// Reverts if the variable was not found or could not be parsed.\\n function envString(string calldata name) external view returns (string memory value);\\n\\n /// Gets the environment variable `name` and parses it as an array of `string`, delimited by `delim`.\\n /// Reverts if the variable was not found or could not be parsed.\\n function envString(string calldata name, string calldata delim) external view returns (string[] memory value);\\n\\n /// Gets the environment variable `name` and parses it as `uint256`.\\n /// Reverts if the variable was not found or could not be parsed.\\n function envUint(string calldata name) external view returns (uint256 value);\\n\\n /// Gets the environment variable `name` and parses it as an array of `uint256`, delimited by `delim`.\\n /// Reverts if the variable was not found or could not be parsed.\\n function envUint(string calldata name, string calldata delim) external view returns (uint256[] memory value);\\n\\n /// Returns true if `forge` command was executed in given context.\\n function isContext(ForgeContext context) external view returns (bool result);\\n\\n /// Sets environment variables.\\n function setEnv(string calldata name, string calldata value) external;\\n\\n // ======== EVM ========\\n\\n /// Gets all accessed reads and write slot from a `vm.record` session, for a given address.\\n function accesses(address target) external returns (bytes32[] memory readSlots, bytes32[] memory writeSlots);\\n\\n /// Gets the address for a given private key.\\n function addr(uint256 privateKey) external pure returns (address keyAddr);\\n\\n /// Gets all the logs according to specified filter.\\n function eth_getLogs(uint256 fromBlock, uint256 toBlock, address target, bytes32[] calldata topics)\\n external\\n returns (EthGetLogs[] memory logs);\\n\\n /// Gets the current `block.blobbasefee`.\\n /// You should use this instead of `block.blobbasefee` if you use `vm.blobBaseFee`, as `block.blobbasefee` is assumed to be constant across a transaction,\\n /// and as a result will get optimized out by the compiler.\\n /// See https://github.com/foundry-rs/foundry/issues/6180\\n function getBlobBaseFee() external view returns (uint256 blobBaseFee);\\n\\n /// Gets the current `block.number`.\\n /// You should use this instead of `block.number` if you use `vm.roll`, as `block.number` is assumed to be constant across a transaction,\\n /// and as a result will get optimized out by the compiler.\\n /// See https://github.com/foundry-rs/foundry/issues/6180\\n function getBlockNumber() external view returns (uint256 height);\\n\\n /// Gets the current `block.timestamp`.\\n /// You should use this instead of `block.timestamp` if you use `vm.warp`, as `block.timestamp` is assumed to be constant across a transaction,\\n /// and as a result will get optimized out by the compiler.\\n /// See https://github.com/foundry-rs/foundry/issues/6180\\n function getBlockTimestamp() external view returns (uint256 timestamp);\\n\\n /// Gets the map key and parent of a mapping at a given slot, for a given address.\\n function getMappingKeyAndParentOf(address target, bytes32 elementSlot)\\n external\\n returns (bool found, bytes32 key, bytes32 parent);\\n\\n /// Gets the number of elements in the mapping at the given slot, for a given address.\\n function getMappingLength(address target, bytes32 mappingSlot) external returns (uint256 length);\\n\\n /// Gets the elements at index idx of the mapping at the given slot, for a given address. The\\n /// index must be less than the length of the mapping (i.e. the number of keys in the mapping).\\n function getMappingSlotAt(address target, bytes32 mappingSlot, uint256 idx) external returns (bytes32 value);\\n\\n /// Gets the nonce of an account.\\n function getNonce(address account) external view returns (uint64 nonce);\\n\\n /// Get the nonce of a `Wallet`.\\n function getNonce(Wallet calldata wallet) external returns (uint64 nonce);\\n\\n /// Gets all the recorded logs.\\n function getRecordedLogs() external returns (Log[] memory logs);\\n\\n /// Returns state diffs from current `vm.startStateDiffRecording` session.\\n function getStateDiff() external view returns (string memory diff);\\n\\n /// Returns state diffs from current `vm.startStateDiffRecording` session, in json format.\\n function getStateDiffJson() external view returns (string memory diff);\\n\\n /// Gets the gas used in the last call from the callee perspective.\\n function lastCallGas() external view returns (Gas memory gas);\\n\\n /// Loads a storage slot from an address.\\n function load(address target, bytes32 slot) external view returns (bytes32 data);\\n\\n /// Pauses gas metering (i.e. gas usage is not counted). Noop if already paused.\\n function pauseGasMetering() external;\\n\\n /// Records all storage reads and writes.\\n function record() external;\\n\\n /// Record all the transaction logs.\\n function recordLogs() external;\\n\\n /// Reset gas metering (i.e. gas usage is set to gas limit).\\n function resetGasMetering() external;\\n\\n /// Resumes gas metering (i.e. gas usage is counted again). Noop if already on.\\n function resumeGasMetering() external;\\n\\n /// Performs an Ethereum JSON-RPC request to the current fork URL.\\n function rpc(string calldata method, string calldata params) external returns (bytes memory data);\\n\\n /// Performs an Ethereum JSON-RPC request to the given endpoint.\\n function rpc(string calldata urlOrAlias, string calldata method, string calldata params)\\n external\\n returns (bytes memory data);\\n\\n /// Records the debug trace during the run.\\n function startDebugTraceRecording() external;\\n\\n /// Starts recording all map SSTOREs for later retrieval.\\n function startMappingRecording() external;\\n\\n /// Record all account accesses as part of CREATE, CALL or SELFDESTRUCT opcodes in order,\\n /// along with the context of the calls\\n function startStateDiffRecording() external;\\n\\n /// Stop debug trace recording and returns the recorded debug trace.\\n function stopAndReturnDebugTraceRecording() external returns (DebugStep[] memory step);\\n\\n /// Returns an ordered array of all account accesses from a `vm.startStateDiffRecording` session.\\n function stopAndReturnStateDiff() external returns (AccountAccess[] memory accountAccesses);\\n\\n /// Stops recording all map SSTOREs for later retrieval and clears the recorded data.\\n function stopMappingRecording() external;\\n\\n // ======== Filesystem ========\\n\\n /// Closes file for reading, resetting the offset and allowing to read it from beginning with readLine.\\n /// `path` is relative to the project root.\\n function closeFile(string calldata path) external;\\n\\n /// Copies the contents of one file to another. This function will **overwrite** the contents of `to`.\\n /// On success, the total number of bytes copied is returned and it is equal to the length of the `to` file as reported by `metadata`.\\n /// Both `from` and `to` are relative to the project root.\\n function copyFile(string calldata from, string calldata to) external returns (uint64 copied);\\n\\n /// Creates a new, empty directory at the provided path.\\n /// This cheatcode will revert in the following situations, but is not limited to just these cases:\\n /// - User lacks permissions to modify `path`.\\n /// - A parent of the given path doesn't exist and `recursive` is false.\\n /// - `path` already exists and `recursive` is false.\\n /// `path` is relative to the project root.\\n function createDir(string calldata path, bool recursive) external;\\n\\n /// Deploys a contract from an artifact file. Takes in the relative path to the json file or the path to the\\n /// artifact in the form of :: where and parts are optional.\\n function deployCode(string calldata artifactPath) external returns (address deployedAddress);\\n\\n /// Deploys a contract from an artifact file. Takes in the relative path to the json file or the path to the\\n /// artifact in the form of :: where and parts are optional.\\n /// Additionally accepts abi-encoded constructor arguments.\\n function deployCode(string calldata artifactPath, bytes calldata constructorArgs)\\n external\\n returns (address deployedAddress);\\n\\n /// Returns true if the given path points to an existing entity, else returns false.\\n function exists(string calldata path) external view returns (bool result);\\n\\n /// Performs a foreign function call via the terminal.\\n function ffi(string[] calldata commandInput) external returns (bytes memory result);\\n\\n /// Given a path, query the file system to get information about a file, directory, etc.\\n function fsMetadata(string calldata path) external view returns (FsMetadata memory metadata);\\n\\n /// Gets the artifact path from code (aka. creation code).\\n function getArtifactPathByCode(bytes calldata code) external view returns (string memory path);\\n\\n /// Gets the artifact path from deployed code (aka. runtime code).\\n function getArtifactPathByDeployedCode(bytes calldata deployedCode) external view returns (string memory path);\\n\\n /// Returns the most recent broadcast for the given contract on `chainId` matching `txType`.\\n /// For example:\\n /// The most recent deployment can be fetched by passing `txType` as `CREATE` or `CREATE2`.\\n /// The most recent call can be fetched by passing `txType` as `CALL`.\\n function getBroadcast(string calldata contractName, uint64 chainId, BroadcastTxType txType)\\n external\\n view\\n returns (BroadcastTxSummary memory);\\n\\n /// Returns all broadcasts for the given contract on `chainId` with the specified `txType`.\\n /// Sorted such that the most recent broadcast is the first element, and the oldest is the last. i.e descending order of BroadcastTxSummary.blockNumber.\\n function getBroadcasts(string calldata contractName, uint64 chainId, BroadcastTxType txType)\\n external\\n view\\n returns (BroadcastTxSummary[] memory);\\n\\n /// Returns all broadcasts for the given contract on `chainId`.\\n /// Sorted such that the most recent broadcast is the first element, and the oldest is the last. i.e descending order of BroadcastTxSummary.blockNumber.\\n function getBroadcasts(string calldata contractName, uint64 chainId)\\n external\\n view\\n returns (BroadcastTxSummary[] memory);\\n\\n /// Gets the creation bytecode from an artifact file. Takes in the relative path to the json file or the path to the\\n /// artifact in the form of :: where and parts are optional.\\n function getCode(string calldata artifactPath) external view returns (bytes memory creationBytecode);\\n\\n /// Gets the deployed bytecode from an artifact file. Takes in the relative path to the json file or the path to the\\n /// artifact in the form of :: where and parts are optional.\\n function getDeployedCode(string calldata artifactPath) external view returns (bytes memory runtimeBytecode);\\n\\n /// Returns the most recent deployment for the current `chainId`.\\n function getDeployment(string calldata contractName) external view returns (address deployedAddress);\\n\\n /// Returns the most recent deployment for the given contract on `chainId`\\n function getDeployment(string calldata contractName, uint64 chainId)\\n external\\n view\\n returns (address deployedAddress);\\n\\n /// Returns all deployments for the given contract on `chainId`\\n /// Sorted in descending order of deployment time i.e descending order of BroadcastTxSummary.blockNumber.\\n /// The most recent deployment is the first element, and the oldest is the last.\\n function getDeployments(string calldata contractName, uint64 chainId)\\n external\\n view\\n returns (address[] memory deployedAddresses);\\n\\n /// Returns true if the path exists on disk and is pointing at a directory, else returns false.\\n function isDir(string calldata path) external view returns (bool result);\\n\\n /// Returns true if the path exists on disk and is pointing at a regular file, else returns false.\\n function isFile(string calldata path) external view returns (bool result);\\n\\n /// Get the path of the current project root.\\n function projectRoot() external view returns (string memory path);\\n\\n /// Prompts the user for a string value in the terminal.\\n function prompt(string calldata promptText) external returns (string memory input);\\n\\n /// Prompts the user for an address in the terminal.\\n function promptAddress(string calldata promptText) external returns (address);\\n\\n /// Prompts the user for a hidden string value in the terminal.\\n function promptSecret(string calldata promptText) external returns (string memory input);\\n\\n /// Prompts the user for hidden uint256 in the terminal (usually pk).\\n function promptSecretUint(string calldata promptText) external returns (uint256);\\n\\n /// Prompts the user for uint256 in the terminal.\\n function promptUint(string calldata promptText) external returns (uint256);\\n\\n /// Reads the directory at the given path recursively, up to `maxDepth`.\\n /// `maxDepth` defaults to 1, meaning only the direct children of the given directory will be returned.\\n /// Follows symbolic links if `followLinks` is true.\\n function readDir(string calldata path) external view returns (DirEntry[] memory entries);\\n\\n /// See `readDir(string)`.\\n function readDir(string calldata path, uint64 maxDepth) external view returns (DirEntry[] memory entries);\\n\\n /// See `readDir(string)`.\\n function readDir(string calldata path, uint64 maxDepth, bool followLinks)\\n external\\n view\\n returns (DirEntry[] memory entries);\\n\\n /// Reads the entire content of file to string. `path` is relative to the project root.\\n function readFile(string calldata path) external view returns (string memory data);\\n\\n /// Reads the entire content of file as binary. `path` is relative to the project root.\\n function readFileBinary(string calldata path) external view returns (bytes memory data);\\n\\n /// Reads next line of file to string.\\n function readLine(string calldata path) external view returns (string memory line);\\n\\n /// Reads a symbolic link, returning the path that the link points to.\\n /// This cheatcode will revert in the following situations, but is not limited to just these cases:\\n /// - `path` is not a symbolic link.\\n /// - `path` does not exist.\\n function readLink(string calldata linkPath) external view returns (string memory targetPath);\\n\\n /// Removes a directory at the provided path.\\n /// This cheatcode will revert in the following situations, but is not limited to just these cases:\\n /// - `path` doesn't exist.\\n /// - `path` isn't a directory.\\n /// - User lacks permissions to modify `path`.\\n /// - The directory is not empty and `recursive` is false.\\n /// `path` is relative to the project root.\\n function removeDir(string calldata path, bool recursive) external;\\n\\n /// Removes a file from the filesystem.\\n /// This cheatcode will revert in the following situations, but is not limited to just these cases:\\n /// - `path` points to a directory.\\n /// - The file doesn't exist.\\n /// - The user lacks permissions to remove the file.\\n /// `path` is relative to the project root.\\n function removeFile(string calldata path) external;\\n\\n /// Performs a foreign function call via terminal and returns the exit code, stdout, and stderr.\\n function tryFfi(string[] calldata commandInput) external returns (FfiResult memory result);\\n\\n /// Returns the time since unix epoch in milliseconds.\\n function unixTime() external view returns (uint256 milliseconds);\\n\\n /// Writes data to file, creating a file if it does not exist, and entirely replacing its contents if it does.\\n /// `path` is relative to the project root.\\n function writeFile(string calldata path, string calldata data) external;\\n\\n /// Writes binary data to a file, creating a file if it does not exist, and entirely replacing its contents if it does.\\n /// `path` is relative to the project root.\\n function writeFileBinary(string calldata path, bytes calldata data) external;\\n\\n /// Writes line to file, creating a file if it does not exist.\\n /// `path` is relative to the project root.\\n function writeLine(string calldata path, string calldata data) external;\\n\\n // ======== JSON ========\\n\\n /// Checks if `key` exists in a JSON object.\\n function keyExistsJson(string calldata json, string calldata key) external view returns (bool);\\n\\n /// Parses a string of JSON data at `key` and coerces it to `address`.\\n function parseJsonAddress(string calldata json, string calldata key) external pure returns (address);\\n\\n /// Parses a string of JSON data at `key` and coerces it to `address[]`.\\n function parseJsonAddressArray(string calldata json, string calldata key)\\n external\\n pure\\n returns (address[] memory);\\n\\n /// Parses a string of JSON data at `key` and coerces it to `bool`.\\n function parseJsonBool(string calldata json, string calldata key) external pure returns (bool);\\n\\n /// Parses a string of JSON data at `key` and coerces it to `bool[]`.\\n function parseJsonBoolArray(string calldata json, string calldata key) external pure returns (bool[] memory);\\n\\n /// Parses a string of JSON data at `key` and coerces it to `bytes`.\\n function parseJsonBytes(string calldata json, string calldata key) external pure returns (bytes memory);\\n\\n /// Parses a string of JSON data at `key` and coerces it to `bytes32`.\\n function parseJsonBytes32(string calldata json, string calldata key) external pure returns (bytes32);\\n\\n /// Parses a string of JSON data at `key` and coerces it to `bytes32[]`.\\n function parseJsonBytes32Array(string calldata json, string calldata key)\\n external\\n pure\\n returns (bytes32[] memory);\\n\\n /// Parses a string of JSON data at `key` and coerces it to `bytes[]`.\\n function parseJsonBytesArray(string calldata json, string calldata key) external pure returns (bytes[] memory);\\n\\n /// Parses a string of JSON data at `key` and coerces it to `int256`.\\n function parseJsonInt(string calldata json, string calldata key) external pure returns (int256);\\n\\n /// Parses a string of JSON data at `key` and coerces it to `int256[]`.\\n function parseJsonIntArray(string calldata json, string calldata key) external pure returns (int256[] memory);\\n\\n /// Returns an array of all the keys in a JSON object.\\n function parseJsonKeys(string calldata json, string calldata key) external pure returns (string[] memory keys);\\n\\n /// Parses a string of JSON data at `key` and coerces it to `string`.\\n function parseJsonString(string calldata json, string calldata key) external pure returns (string memory);\\n\\n /// Parses a string of JSON data at `key` and coerces it to `string[]`.\\n function parseJsonStringArray(string calldata json, string calldata key) external pure returns (string[] memory);\\n\\n /// Parses a string of JSON data at `key` and coerces it to type array corresponding to `typeDescription`.\\n function parseJsonTypeArray(string calldata json, string calldata key, string calldata typeDescription)\\n external\\n pure\\n returns (bytes memory);\\n\\n /// Parses a string of JSON data and coerces it to type corresponding to `typeDescription`.\\n function parseJsonType(string calldata json, string calldata typeDescription)\\n external\\n pure\\n returns (bytes memory);\\n\\n /// Parses a string of JSON data at `key` and coerces it to type corresponding to `typeDescription`.\\n function parseJsonType(string calldata json, string calldata key, string calldata typeDescription)\\n external\\n pure\\n returns (bytes memory);\\n\\n /// Parses a string of JSON data at `key` and coerces it to `uint256`.\\n function parseJsonUint(string calldata json, string calldata key) external pure returns (uint256);\\n\\n /// Parses a string of JSON data at `key` and coerces it to `uint256[]`.\\n function parseJsonUintArray(string calldata json, string calldata key) external pure returns (uint256[] memory);\\n\\n /// ABI-encodes a JSON object.\\n function parseJson(string calldata json) external pure returns (bytes memory abiEncodedData);\\n\\n /// ABI-encodes a JSON object at `key`.\\n function parseJson(string calldata json, string calldata key) external pure returns (bytes memory abiEncodedData);\\n\\n /// See `serializeJson`.\\n function serializeAddress(string calldata objectKey, string calldata valueKey, address value)\\n external\\n returns (string memory json);\\n\\n /// See `serializeJson`.\\n function serializeAddress(string calldata objectKey, string calldata valueKey, address[] calldata values)\\n external\\n returns (string memory json);\\n\\n /// See `serializeJson`.\\n function serializeBool(string calldata objectKey, string calldata valueKey, bool value)\\n external\\n returns (string memory json);\\n\\n /// See `serializeJson`.\\n function serializeBool(string calldata objectKey, string calldata valueKey, bool[] calldata values)\\n external\\n returns (string memory json);\\n\\n /// See `serializeJson`.\\n function serializeBytes32(string calldata objectKey, string calldata valueKey, bytes32 value)\\n external\\n returns (string memory json);\\n\\n /// See `serializeJson`.\\n function serializeBytes32(string calldata objectKey, string calldata valueKey, bytes32[] calldata values)\\n external\\n returns (string memory json);\\n\\n /// See `serializeJson`.\\n function serializeBytes(string calldata objectKey, string calldata valueKey, bytes calldata value)\\n external\\n returns (string memory json);\\n\\n /// See `serializeJson`.\\n function serializeBytes(string calldata objectKey, string calldata valueKey, bytes[] calldata values)\\n external\\n returns (string memory json);\\n\\n /// See `serializeJson`.\\n function serializeInt(string calldata objectKey, string calldata valueKey, int256 value)\\n external\\n returns (string memory json);\\n\\n /// See `serializeJson`.\\n function serializeInt(string calldata objectKey, string calldata valueKey, int256[] calldata values)\\n external\\n returns (string memory json);\\n\\n /// Serializes a key and value to a JSON object stored in-memory that can be later written to a file.\\n /// Returns the stringified version of the specific JSON file up to that moment.\\n function serializeJson(string calldata objectKey, string calldata value) external returns (string memory json);\\n\\n /// See `serializeJson`.\\n function serializeJsonType(string calldata typeDescription, bytes calldata value)\\n external\\n pure\\n returns (string memory json);\\n\\n /// See `serializeJson`.\\n function serializeJsonType(\\n string calldata objectKey,\\n string calldata valueKey,\\n string calldata typeDescription,\\n bytes calldata value\\n ) external returns (string memory json);\\n\\n /// See `serializeJson`.\\n function serializeString(string calldata objectKey, string calldata valueKey, string calldata value)\\n external\\n returns (string memory json);\\n\\n /// See `serializeJson`.\\n function serializeString(string calldata objectKey, string calldata valueKey, string[] calldata values)\\n external\\n returns (string memory json);\\n\\n /// See `serializeJson`.\\n function serializeUintToHex(string calldata objectKey, string calldata valueKey, uint256 value)\\n external\\n returns (string memory json);\\n\\n /// See `serializeJson`.\\n function serializeUint(string calldata objectKey, string calldata valueKey, uint256 value)\\n external\\n returns (string memory json);\\n\\n /// See `serializeJson`.\\n function serializeUint(string calldata objectKey, string calldata valueKey, uint256[] calldata values)\\n external\\n returns (string memory json);\\n\\n /// Write a serialized JSON object to a file. If the file exists, it will be overwritten.\\n function writeJson(string calldata json, string calldata path) external;\\n\\n /// Write a serialized JSON object to an **existing** JSON file, replacing a value with key = \\n /// This is useful to replace a specific value of a JSON file, without having to parse the entire thing.\\n function writeJson(string calldata json, string calldata path, string calldata valueKey) external;\\n\\n /// Checks if `key` exists in a JSON object\\n /// `keyExists` is being deprecated in favor of `keyExistsJson`. It will be removed in future versions.\\n function keyExists(string calldata json, string calldata key) external view returns (bool);\\n\\n // ======== Scripting ========\\n\\n /// Designate the next call as an EIP-7702 transaction\\n function attachDelegation(SignedDelegation calldata signedDelegation) external;\\n\\n /// Takes a signed transaction and broadcasts it to the network.\\n function broadcastRawTransaction(bytes calldata data) external;\\n\\n /// Has the next call (at this call depth only) create transactions that can later be signed and sent onchain.\\n /// Broadcasting address is determined by checking the following in order:\\n /// 1. If `--sender` argument was provided, that address is used.\\n /// 2. If exactly one signer (e.g. private key, hw wallet, keystore) is set when `forge broadcast` is invoked, that signer is used.\\n /// 3. Otherwise, default foundry sender (1804c8AB1F12E6bbf3894d4083f33e07309d1f38) is used.\\n function broadcast() external;\\n\\n /// Has the next call (at this call depth only) create a transaction with the address provided\\n /// as the sender that can later be signed and sent onchain.\\n function broadcast(address signer) external;\\n\\n /// Has the next call (at this call depth only) create a transaction with the private key\\n /// provided as the sender that can later be signed and sent onchain.\\n function broadcast(uint256 privateKey) external;\\n\\n /// Returns addresses of available unlocked wallets in the script environment.\\n function getWallets() external returns (address[] memory wallets);\\n\\n /// Sign an EIP-7702 authorization and designate the next call as an EIP-7702 transaction\\n function signAndAttachDelegation(address implementation, uint256 privateKey)\\n external\\n returns (SignedDelegation memory signedDelegation);\\n\\n /// Sign an EIP-7702 authorization for delegation\\n function signDelegation(address implementation, uint256 privateKey)\\n external\\n returns (SignedDelegation memory signedDelegation);\\n\\n /// Has all subsequent calls (at this call depth only) create transactions that can later be signed and sent onchain.\\n /// Broadcasting address is determined by checking the following in order:\\n /// 1. If `--sender` argument was provided, that address is used.\\n /// 2. If exactly one signer (e.g. private key, hw wallet, keystore) is set when `forge broadcast` is invoked, that signer is used.\\n /// 3. Otherwise, default foundry sender (1804c8AB1F12E6bbf3894d4083f33e07309d1f38) is used.\\n function startBroadcast() external;\\n\\n /// Has all subsequent calls (at this call depth only) create transactions with the address\\n /// provided that can later be signed and sent onchain.\\n function startBroadcast(address signer) external;\\n\\n /// Has all subsequent calls (at this call depth only) create transactions with the private key\\n /// provided that can later be signed and sent onchain.\\n function startBroadcast(uint256 privateKey) external;\\n\\n /// Stops collecting onchain transactions.\\n function stopBroadcast() external;\\n\\n // ======== String ========\\n\\n /// Returns true if `search` is found in `subject`, false otherwise.\\n function contains(string calldata subject, string calldata search) external returns (bool result);\\n\\n /// Returns the index of the first occurrence of a `key` in an `input` string.\\n /// Returns `NOT_FOUND` (i.e. `type(uint256).max`) if the `key` is not found.\\n /// Returns 0 in case of an empty `key`.\\n function indexOf(string calldata input, string calldata key) external pure returns (uint256);\\n\\n /// Parses the given `string` into an `address`.\\n function parseAddress(string calldata stringifiedValue) external pure returns (address parsedValue);\\n\\n /// Parses the given `string` into a `bool`.\\n function parseBool(string calldata stringifiedValue) external pure returns (bool parsedValue);\\n\\n /// Parses the given `string` into `bytes`.\\n function parseBytes(string calldata stringifiedValue) external pure returns (bytes memory parsedValue);\\n\\n /// Parses the given `string` into a `bytes32`.\\n function parseBytes32(string calldata stringifiedValue) external pure returns (bytes32 parsedValue);\\n\\n /// Parses the given `string` into a `int256`.\\n function parseInt(string calldata stringifiedValue) external pure returns (int256 parsedValue);\\n\\n /// Parses the given `string` into a `uint256`.\\n function parseUint(string calldata stringifiedValue) external pure returns (uint256 parsedValue);\\n\\n /// Replaces occurrences of `from` in the given `string` with `to`.\\n function replace(string calldata input, string calldata from, string calldata to)\\n external\\n pure\\n returns (string memory output);\\n\\n /// Splits the given `string` into an array of strings divided by the `delimiter`.\\n function split(string calldata input, string calldata delimiter) external pure returns (string[] memory outputs);\\n\\n /// Converts the given `string` value to Lowercase.\\n function toLowercase(string calldata input) external pure returns (string memory output);\\n\\n /// Converts the given value to a `string`.\\n function toString(address value) external pure returns (string memory stringifiedValue);\\n\\n /// Converts the given value to a `string`.\\n function toString(bytes calldata value) external pure returns (string memory stringifiedValue);\\n\\n /// Converts the given value to a `string`.\\n function toString(bytes32 value) external pure returns (string memory stringifiedValue);\\n\\n /// Converts the given value to a `string`.\\n function toString(bool value) external pure returns (string memory stringifiedValue);\\n\\n /// Converts the given value to a `string`.\\n function toString(uint256 value) external pure returns (string memory stringifiedValue);\\n\\n /// Converts the given value to a `string`.\\n function toString(int256 value) external pure returns (string memory stringifiedValue);\\n\\n /// Converts the given `string` value to Uppercase.\\n function toUppercase(string calldata input) external pure returns (string memory output);\\n\\n /// Trims leading and trailing whitespace from the given `string` value.\\n function trim(string calldata input) external pure returns (string memory output);\\n\\n // ======== Testing ========\\n\\n /// Compares two `uint256` values. Expects difference to be less than or equal to `maxDelta`.\\n /// Formats values with decimals in failure message.\\n function assertApproxEqAbsDecimal(uint256 left, uint256 right, uint256 maxDelta, uint256 decimals) external pure;\\n\\n /// Compares two `uint256` values. Expects difference to be less than or equal to `maxDelta`.\\n /// Formats values with decimals in failure message. Includes error message into revert string on failure.\\n function assertApproxEqAbsDecimal(\\n uint256 left,\\n uint256 right,\\n uint256 maxDelta,\\n uint256 decimals,\\n string calldata error\\n ) external pure;\\n\\n /// Compares two `int256` values. Expects difference to be less than or equal to `maxDelta`.\\n /// Formats values with decimals in failure message.\\n function assertApproxEqAbsDecimal(int256 left, int256 right, uint256 maxDelta, uint256 decimals) external pure;\\n\\n /// Compares two `int256` values. Expects difference to be less than or equal to `maxDelta`.\\n /// Formats values with decimals in failure message. Includes error message into revert string on failure.\\n function assertApproxEqAbsDecimal(\\n int256 left,\\n int256 right,\\n uint256 maxDelta,\\n uint256 decimals,\\n string calldata error\\n ) external pure;\\n\\n /// Compares two `uint256` values. Expects difference to be less than or equal to `maxDelta`.\\n function assertApproxEqAbs(uint256 left, uint256 right, uint256 maxDelta) external pure;\\n\\n /// Compares two `uint256` values. Expects difference to be less than or equal to `maxDelta`.\\n /// Includes error message into revert string on failure.\\n function assertApproxEqAbs(uint256 left, uint256 right, uint256 maxDelta, string calldata error) external pure;\\n\\n /// Compares two `int256` values. Expects difference to be less than or equal to `maxDelta`.\\n function assertApproxEqAbs(int256 left, int256 right, uint256 maxDelta) external pure;\\n\\n /// Compares two `int256` values. Expects difference to be less than or equal to `maxDelta`.\\n /// Includes error message into revert string on failure.\\n function assertApproxEqAbs(int256 left, int256 right, uint256 maxDelta, string calldata error) external pure;\\n\\n /// Compares two `uint256` values. Expects relative difference in percents to be less than or equal to `maxPercentDelta`.\\n /// `maxPercentDelta` is an 18 decimal fixed point number, where 1e18 == 100%\\n /// Formats values with decimals in failure message.\\n function assertApproxEqRelDecimal(uint256 left, uint256 right, uint256 maxPercentDelta, uint256 decimals)\\n external\\n pure;\\n\\n /// Compares two `uint256` values. Expects relative difference in percents to be less than or equal to `maxPercentDelta`.\\n /// `maxPercentDelta` is an 18 decimal fixed point number, where 1e18 == 100%\\n /// Formats values with decimals in failure message. Includes error message into revert string on failure.\\n function assertApproxEqRelDecimal(\\n uint256 left,\\n uint256 right,\\n uint256 maxPercentDelta,\\n uint256 decimals,\\n string calldata error\\n ) external pure;\\n\\n /// Compares two `int256` values. Expects relative difference in percents to be less than or equal to `maxPercentDelta`.\\n /// `maxPercentDelta` is an 18 decimal fixed point number, where 1e18 == 100%\\n /// Formats values with decimals in failure message.\\n function assertApproxEqRelDecimal(int256 left, int256 right, uint256 maxPercentDelta, uint256 decimals)\\n external\\n pure;\\n\\n /// Compares two `int256` values. Expects relative difference in percents to be less than or equal to `maxPercentDelta`.\\n /// `maxPercentDelta` is an 18 decimal fixed point number, where 1e18 == 100%\\n /// Formats values with decimals in failure message. Includes error message into revert string on failure.\\n function assertApproxEqRelDecimal(\\n int256 left,\\n int256 right,\\n uint256 maxPercentDelta,\\n uint256 decimals,\\n string calldata error\\n ) external pure;\\n\\n /// Compares two `uint256` values. Expects relative difference in percents to be less than or equal to `maxPercentDelta`.\\n /// `maxPercentDelta` is an 18 decimal fixed point number, where 1e18 == 100%\\n function assertApproxEqRel(uint256 left, uint256 right, uint256 maxPercentDelta) external pure;\\n\\n /// Compares two `uint256` values. Expects relative difference in percents to be less than or equal to `maxPercentDelta`.\\n /// `maxPercentDelta` is an 18 decimal fixed point number, where 1e18 == 100%\\n /// Includes error message into revert string on failure.\\n function assertApproxEqRel(uint256 left, uint256 right, uint256 maxPercentDelta, string calldata error)\\n external\\n pure;\\n\\n /// Compares two `int256` values. Expects relative difference in percents to be less than or equal to `maxPercentDelta`.\\n /// `maxPercentDelta` is an 18 decimal fixed point number, where 1e18 == 100%\\n function assertApproxEqRel(int256 left, int256 right, uint256 maxPercentDelta) external pure;\\n\\n /// Compares two `int256` values. Expects relative difference in percents to be less than or equal to `maxPercentDelta`.\\n /// `maxPercentDelta` is an 18 decimal fixed point number, where 1e18 == 100%\\n /// Includes error message into revert string on failure.\\n function assertApproxEqRel(int256 left, int256 right, uint256 maxPercentDelta, string calldata error)\\n external\\n pure;\\n\\n /// Asserts that two `uint256` values are equal, formatting them with decimals in failure message.\\n function assertEqDecimal(uint256 left, uint256 right, uint256 decimals) external pure;\\n\\n /// Asserts that two `uint256` values are equal, formatting them with decimals in failure message.\\n /// Includes error message into revert string on failure.\\n function assertEqDecimal(uint256 left, uint256 right, uint256 decimals, string calldata error) external pure;\\n\\n /// Asserts that two `int256` values are equal, formatting them with decimals in failure message.\\n function assertEqDecimal(int256 left, int256 right, uint256 decimals) external pure;\\n\\n /// Asserts that two `int256` values are equal, formatting them with decimals in failure message.\\n /// Includes error message into revert string on failure.\\n function assertEqDecimal(int256 left, int256 right, uint256 decimals, string calldata error) external pure;\\n\\n /// Asserts that two `bool` values are equal.\\n function assertEq(bool left, bool right) external pure;\\n\\n /// Asserts that two `bool` values are equal and includes error message into revert string on failure.\\n function assertEq(bool left, bool right, string calldata error) external pure;\\n\\n /// Asserts that two `string` values are equal.\\n function assertEq(string calldata left, string calldata right) external pure;\\n\\n /// Asserts that two `string` values are equal and includes error message into revert string on failure.\\n function assertEq(string calldata left, string calldata right, string calldata error) external pure;\\n\\n /// Asserts that two `bytes` values are equal.\\n function assertEq(bytes calldata left, bytes calldata right) external pure;\\n\\n /// Asserts that two `bytes` values are equal and includes error message into revert string on failure.\\n function assertEq(bytes calldata left, bytes calldata right, string calldata error) external pure;\\n\\n /// Asserts that two arrays of `bool` values are equal.\\n function assertEq(bool[] calldata left, bool[] calldata right) external pure;\\n\\n /// Asserts that two arrays of `bool` values are equal and includes error message into revert string on failure.\\n function assertEq(bool[] calldata left, bool[] calldata right, string calldata error) external pure;\\n\\n /// Asserts that two arrays of `uint256 values are equal.\\n function assertEq(uint256[] calldata left, uint256[] calldata right) external pure;\\n\\n /// Asserts that two arrays of `uint256` values are equal and includes error message into revert string on failure.\\n function assertEq(uint256[] calldata left, uint256[] calldata right, string calldata error) external pure;\\n\\n /// Asserts that two arrays of `int256` values are equal.\\n function assertEq(int256[] calldata left, int256[] calldata right) external pure;\\n\\n /// Asserts that two arrays of `int256` values are equal and includes error message into revert string on failure.\\n function assertEq(int256[] calldata left, int256[] calldata right, string calldata error) external pure;\\n\\n /// Asserts that two `uint256` values are equal.\\n function assertEq(uint256 left, uint256 right) external pure;\\n\\n /// Asserts that two arrays of `address` values are equal.\\n function assertEq(address[] calldata left, address[] calldata right) external pure;\\n\\n /// Asserts that two arrays of `address` values are equal and includes error message into revert string on failure.\\n function assertEq(address[] calldata left, address[] calldata right, string calldata error) external pure;\\n\\n /// Asserts that two arrays of `bytes32` values are equal.\\n function assertEq(bytes32[] calldata left, bytes32[] calldata right) external pure;\\n\\n /// Asserts that two arrays of `bytes32` values are equal and includes error message into revert string on failure.\\n function assertEq(bytes32[] calldata left, bytes32[] calldata right, string calldata error) external pure;\\n\\n /// Asserts that two arrays of `string` values are equal.\\n function assertEq(string[] calldata left, string[] calldata right) external pure;\\n\\n /// Asserts that two arrays of `string` values are equal and includes error message into revert string on failure.\\n function assertEq(string[] calldata left, string[] calldata right, string calldata error) external pure;\\n\\n /// Asserts that two arrays of `bytes` values are equal.\\n function assertEq(bytes[] calldata left, bytes[] calldata right) external pure;\\n\\n /// Asserts that two arrays of `bytes` values are equal and includes error message into revert string on failure.\\n function assertEq(bytes[] calldata left, bytes[] calldata right, string calldata error) external pure;\\n\\n /// Asserts that two `uint256` values are equal and includes error message into revert string on failure.\\n function assertEq(uint256 left, uint256 right, string calldata error) external pure;\\n\\n /// Asserts that two `int256` values are equal.\\n function assertEq(int256 left, int256 right) external pure;\\n\\n /// Asserts that two `int256` values are equal and includes error message into revert string on failure.\\n function assertEq(int256 left, int256 right, string calldata error) external pure;\\n\\n /// Asserts that two `address` values are equal.\\n function assertEq(address left, address right) external pure;\\n\\n /// Asserts that two `address` values are equal and includes error message into revert string on failure.\\n function assertEq(address left, address right, string calldata error) external pure;\\n\\n /// Asserts that two `bytes32` values are equal.\\n function assertEq(bytes32 left, bytes32 right) external pure;\\n\\n /// Asserts that two `bytes32` values are equal and includes error message into revert string on failure.\\n function assertEq(bytes32 left, bytes32 right, string calldata error) external pure;\\n\\n /// Asserts that the given condition is false.\\n function assertFalse(bool condition) external pure;\\n\\n /// Asserts that the given condition is false and includes error message into revert string on failure.\\n function assertFalse(bool condition, string calldata error) external pure;\\n\\n /// Compares two `uint256` values. Expects first value to be greater than or equal to second.\\n /// Formats values with decimals in failure message.\\n function assertGeDecimal(uint256 left, uint256 right, uint256 decimals) external pure;\\n\\n /// Compares two `uint256` values. Expects first value to be greater than or equal to second.\\n /// Formats values with decimals in failure message. Includes error message into revert string on failure.\\n function assertGeDecimal(uint256 left, uint256 right, uint256 decimals, string calldata error) external pure;\\n\\n /// Compares two `int256` values. Expects first value to be greater than or equal to second.\\n /// Formats values with decimals in failure message.\\n function assertGeDecimal(int256 left, int256 right, uint256 decimals) external pure;\\n\\n /// Compares two `int256` values. Expects first value to be greater than or equal to second.\\n /// Formats values with decimals in failure message. Includes error message into revert string on failure.\\n function assertGeDecimal(int256 left, int256 right, uint256 decimals, string calldata error) external pure;\\n\\n /// Compares two `uint256` values. Expects first value to be greater than or equal to second.\\n function assertGe(uint256 left, uint256 right) external pure;\\n\\n /// Compares two `uint256` values. Expects first value to be greater than or equal to second.\\n /// Includes error message into revert string on failure.\\n function assertGe(uint256 left, uint256 right, string calldata error) external pure;\\n\\n /// Compares two `int256` values. Expects first value to be greater than or equal to second.\\n function assertGe(int256 left, int256 right) external pure;\\n\\n /// Compares two `int256` values. Expects first value to be greater than or equal to second.\\n /// Includes error message into revert string on failure.\\n function assertGe(int256 left, int256 right, string calldata error) external pure;\\n\\n /// Compares two `uint256` values. Expects first value to be greater than second.\\n /// Formats values with decimals in failure message.\\n function assertGtDecimal(uint256 left, uint256 right, uint256 decimals) external pure;\\n\\n /// Compares two `uint256` values. Expects first value to be greater than second.\\n /// Formats values with decimals in failure message. Includes error message into revert string on failure.\\n function assertGtDecimal(uint256 left, uint256 right, uint256 decimals, string calldata error) external pure;\\n\\n /// Compares two `int256` values. Expects first value to be greater than second.\\n /// Formats values with decimals in failure message.\\n function assertGtDecimal(int256 left, int256 right, uint256 decimals) external pure;\\n\\n /// Compares two `int256` values. Expects first value to be greater than second.\\n /// Formats values with decimals in failure message. Includes error message into revert string on failure.\\n function assertGtDecimal(int256 left, int256 right, uint256 decimals, string calldata error) external pure;\\n\\n /// Compares two `uint256` values. Expects first value to be greater than second.\\n function assertGt(uint256 left, uint256 right) external pure;\\n\\n /// Compares two `uint256` values. Expects first value to be greater than second.\\n /// Includes error message into revert string on failure.\\n function assertGt(uint256 left, uint256 right, string calldata error) external pure;\\n\\n /// Compares two `int256` values. Expects first value to be greater than second.\\n function assertGt(int256 left, int256 right) external pure;\\n\\n /// Compares two `int256` values. Expects first value to be greater than second.\\n /// Includes error message into revert string on failure.\\n function assertGt(int256 left, int256 right, string calldata error) external pure;\\n\\n /// Compares two `uint256` values. Expects first value to be less than or equal to second.\\n /// Formats values with decimals in failure message.\\n function assertLeDecimal(uint256 left, uint256 right, uint256 decimals) external pure;\\n\\n /// Compares two `uint256` values. Expects first value to be less than or equal to second.\\n /// Formats values with decimals in failure message. Includes error message into revert string on failure.\\n function assertLeDecimal(uint256 left, uint256 right, uint256 decimals, string calldata error) external pure;\\n\\n /// Compares two `int256` values. Expects first value to be less than or equal to second.\\n /// Formats values with decimals in failure message.\\n function assertLeDecimal(int256 left, int256 right, uint256 decimals) external pure;\\n\\n /// Compares two `int256` values. Expects first value to be less than or equal to second.\\n /// Formats values with decimals in failure message. Includes error message into revert string on failure.\\n function assertLeDecimal(int256 left, int256 right, uint256 decimals, string calldata error) external pure;\\n\\n /// Compares two `uint256` values. Expects first value to be less than or equal to second.\\n function assertLe(uint256 left, uint256 right) external pure;\\n\\n /// Compares two `uint256` values. Expects first value to be less than or equal to second.\\n /// Includes error message into revert string on failure.\\n function assertLe(uint256 left, uint256 right, string calldata error) external pure;\\n\\n /// Compares two `int256` values. Expects first value to be less than or equal to second.\\n function assertLe(int256 left, int256 right) external pure;\\n\\n /// Compares two `int256` values. Expects first value to be less than or equal to second.\\n /// Includes error message into revert string on failure.\\n function assertLe(int256 left, int256 right, string calldata error) external pure;\\n\\n /// Compares two `uint256` values. Expects first value to be less than second.\\n /// Formats values with decimals in failure message.\\n function assertLtDecimal(uint256 left, uint256 right, uint256 decimals) external pure;\\n\\n /// Compares two `uint256` values. Expects first value to be less than second.\\n /// Formats values with decimals in failure message. Includes error message into revert string on failure.\\n function assertLtDecimal(uint256 left, uint256 right, uint256 decimals, string calldata error) external pure;\\n\\n /// Compares two `int256` values. Expects first value to be less than second.\\n /// Formats values with decimals in failure message.\\n function assertLtDecimal(int256 left, int256 right, uint256 decimals) external pure;\\n\\n /// Compares two `int256` values. Expects first value to be less than second.\\n /// Formats values with decimals in failure message. Includes error message into revert string on failure.\\n function assertLtDecimal(int256 left, int256 right, uint256 decimals, string calldata error) external pure;\\n\\n /// Compares two `uint256` values. Expects first value to be less than second.\\n function assertLt(uint256 left, uint256 right) external pure;\\n\\n /// Compares two `uint256` values. Expects first value to be less than second.\\n /// Includes error message into revert string on failure.\\n function assertLt(uint256 left, uint256 right, string calldata error) external pure;\\n\\n /// Compares two `int256` values. Expects first value to be less than second.\\n function assertLt(int256 left, int256 right) external pure;\\n\\n /// Compares two `int256` values. Expects first value to be less than second.\\n /// Includes error message into revert string on failure.\\n function assertLt(int256 left, int256 right, string calldata error) external pure;\\n\\n /// Asserts that two `uint256` values are not equal, formatting them with decimals in failure message.\\n function assertNotEqDecimal(uint256 left, uint256 right, uint256 decimals) external pure;\\n\\n /// Asserts that two `uint256` values are not equal, formatting them with decimals in failure message.\\n /// Includes error message into revert string on failure.\\n function assertNotEqDecimal(uint256 left, uint256 right, uint256 decimals, string calldata error) external pure;\\n\\n /// Asserts that two `int256` values are not equal, formatting them with decimals in failure message.\\n function assertNotEqDecimal(int256 left, int256 right, uint256 decimals) external pure;\\n\\n /// Asserts that two `int256` values are not equal, formatting them with decimals in failure message.\\n /// Includes error message into revert string on failure.\\n function assertNotEqDecimal(int256 left, int256 right, uint256 decimals, string calldata error) external pure;\\n\\n /// Asserts that two `bool` values are not equal.\\n function assertNotEq(bool left, bool right) external pure;\\n\\n /// Asserts that two `bool` values are not equal and includes error message into revert string on failure.\\n function assertNotEq(bool left, bool right, string calldata error) external pure;\\n\\n /// Asserts that two `string` values are not equal.\\n function assertNotEq(string calldata left, string calldata right) external pure;\\n\\n /// Asserts that two `string` values are not equal and includes error message into revert string on failure.\\n function assertNotEq(string calldata left, string calldata right, string calldata error) external pure;\\n\\n /// Asserts that two `bytes` values are not equal.\\n function assertNotEq(bytes calldata left, bytes calldata right) external pure;\\n\\n /// Asserts that two `bytes` values are not equal and includes error message into revert string on failure.\\n function assertNotEq(bytes calldata left, bytes calldata right, string calldata error) external pure;\\n\\n /// Asserts that two arrays of `bool` values are not equal.\\n function assertNotEq(bool[] calldata left, bool[] calldata right) external pure;\\n\\n /// Asserts that two arrays of `bool` values are not equal and includes error message into revert string on failure.\\n function assertNotEq(bool[] calldata left, bool[] calldata right, string calldata error) external pure;\\n\\n /// Asserts that two arrays of `uint256` values are not equal.\\n function assertNotEq(uint256[] calldata left, uint256[] calldata right) external pure;\\n\\n /// Asserts that two arrays of `uint256` values are not equal and includes error message into revert string on failure.\\n function assertNotEq(uint256[] calldata left, uint256[] calldata right, string calldata error) external pure;\\n\\n /// Asserts that two arrays of `int256` values are not equal.\\n function assertNotEq(int256[] calldata left, int256[] calldata right) external pure;\\n\\n /// Asserts that two arrays of `int256` values are not equal and includes error message into revert string on failure.\\n function assertNotEq(int256[] calldata left, int256[] calldata right, string calldata error) external pure;\\n\\n /// Asserts that two `uint256` values are not equal.\\n function assertNotEq(uint256 left, uint256 right) external pure;\\n\\n /// Asserts that two arrays of `address` values are not equal.\\n function assertNotEq(address[] calldata left, address[] calldata right) external pure;\\n\\n /// Asserts that two arrays of `address` values are not equal and includes error message into revert string on failure.\\n function assertNotEq(address[] calldata left, address[] calldata right, string calldata error) external pure;\\n\\n /// Asserts that two arrays of `bytes32` values are not equal.\\n function assertNotEq(bytes32[] calldata left, bytes32[] calldata right) external pure;\\n\\n /// Asserts that two arrays of `bytes32` values are not equal and includes error message into revert string on failure.\\n function assertNotEq(bytes32[] calldata left, bytes32[] calldata right, string calldata error) external pure;\\n\\n /// Asserts that two arrays of `string` values are not equal.\\n function assertNotEq(string[] calldata left, string[] calldata right) external pure;\\n\\n /// Asserts that two arrays of `string` values are not equal and includes error message into revert string on failure.\\n function assertNotEq(string[] calldata left, string[] calldata right, string calldata error) external pure;\\n\\n /// Asserts that two arrays of `bytes` values are not equal.\\n function assertNotEq(bytes[] calldata left, bytes[] calldata right) external pure;\\n\\n /// Asserts that two arrays of `bytes` values are not equal and includes error message into revert string on failure.\\n function assertNotEq(bytes[] calldata left, bytes[] calldata right, string calldata error) external pure;\\n\\n /// Asserts that two `uint256` values are not equal and includes error message into revert string on failure.\\n function assertNotEq(uint256 left, uint256 right, string calldata error) external pure;\\n\\n /// Asserts that two `int256` values are not equal.\\n function assertNotEq(int256 left, int256 right) external pure;\\n\\n /// Asserts that two `int256` values are not equal and includes error message into revert string on failure.\\n function assertNotEq(int256 left, int256 right, string calldata error) external pure;\\n\\n /// Asserts that two `address` values are not equal.\\n function assertNotEq(address left, address right) external pure;\\n\\n /// Asserts that two `address` values are not equal and includes error message into revert string on failure.\\n function assertNotEq(address left, address right, string calldata error) external pure;\\n\\n /// Asserts that two `bytes32` values are not equal.\\n function assertNotEq(bytes32 left, bytes32 right) external pure;\\n\\n /// Asserts that two `bytes32` values are not equal and includes error message into revert string on failure.\\n function assertNotEq(bytes32 left, bytes32 right, string calldata error) external pure;\\n\\n /// Asserts that the given condition is true.\\n function assertTrue(bool condition) external pure;\\n\\n /// Asserts that the given condition is true and includes error message into revert string on failure.\\n function assertTrue(bool condition, string calldata error) external pure;\\n\\n /// If the condition is false, discard this run's fuzz inputs and generate new ones.\\n function assume(bool condition) external pure;\\n\\n /// Discard this run's fuzz inputs and generate new ones if next call reverted.\\n function assumeNoRevert() external pure;\\n\\n /// Discard this run's fuzz inputs and generate new ones if next call reverts with the potential revert parameters.\\n function assumeNoRevert(PotentialRevert calldata potentialRevert) external pure;\\n\\n /// Discard this run's fuzz inputs and generate new ones if next call reverts with the any of the potential revert parameters.\\n function assumeNoRevert(PotentialRevert[] calldata potentialReverts) external pure;\\n\\n /// Writes a breakpoint to jump to in the debugger.\\n function breakpoint(string calldata char) external pure;\\n\\n /// Writes a conditional breakpoint to jump to in the debugger.\\n function breakpoint(string calldata char, bool value) external pure;\\n\\n /// Returns true if the current Foundry version is greater than or equal to the given version.\\n /// The given version string must be in the format `major.minor.patch`.\\n /// This is equivalent to `foundryVersionCmp(version) >= 0`.\\n function foundryVersionAtLeast(string calldata version) external view returns (bool);\\n\\n /// Compares the current Foundry version with the given version string.\\n /// The given version string must be in the format `major.minor.patch`.\\n /// Returns:\\n /// -1 if current Foundry version is less than the given version\\n /// 0 if current Foundry version equals the given version\\n /// 1 if current Foundry version is greater than the given version\\n /// This result can then be used with a comparison operator against `0`.\\n /// For example, to check if the current Foundry version is greater than or equal to `1.0.0`:\\n /// `if (foundryVersionCmp(\\\"1.0.0\\\") >= 0) { ... }`\\n function foundryVersionCmp(string calldata version) external view returns (int256);\\n\\n /// Returns the Foundry version.\\n /// Format: -+..\\n /// Sample output: 0.3.0-nightly+3cb96bde9b.1737036656.debug\\n /// Note: Build timestamps may vary slightly across platforms due to separate CI jobs.\\n /// For reliable version comparisons, use UNIX format (e.g., >= 1700000000)\\n /// to compare timestamps while ignoring minor time differences.\\n function getFoundryVersion() external view returns (string memory version);\\n\\n /// Returns the RPC url for the given alias.\\n function rpcUrl(string calldata rpcAlias) external view returns (string memory json);\\n\\n /// Returns all rpc urls and their aliases as structs.\\n function rpcUrlStructs() external view returns (Rpc[] memory urls);\\n\\n /// Returns all rpc urls and their aliases `[alias, url][]`.\\n function rpcUrls() external view returns (string[2][] memory urls);\\n\\n /// Suspends execution of the main thread for `duration` milliseconds.\\n function sleep(uint256 duration) external;\\n\\n // ======== Toml ========\\n\\n /// Checks if `key` exists in a TOML table.\\n function keyExistsToml(string calldata toml, string calldata key) external view returns (bool);\\n\\n /// Parses a string of TOML data at `key` and coerces it to `address`.\\n function parseTomlAddress(string calldata toml, string calldata key) external pure returns (address);\\n\\n /// Parses a string of TOML data at `key` and coerces it to `address[]`.\\n function parseTomlAddressArray(string calldata toml, string calldata key)\\n external\\n pure\\n returns (address[] memory);\\n\\n /// Parses a string of TOML data at `key` and coerces it to `bool`.\\n function parseTomlBool(string calldata toml, string calldata key) external pure returns (bool);\\n\\n /// Parses a string of TOML data at `key` and coerces it to `bool[]`.\\n function parseTomlBoolArray(string calldata toml, string calldata key) external pure returns (bool[] memory);\\n\\n /// Parses a string of TOML data at `key` and coerces it to `bytes`.\\n function parseTomlBytes(string calldata toml, string calldata key) external pure returns (bytes memory);\\n\\n /// Parses a string of TOML data at `key` and coerces it to `bytes32`.\\n function parseTomlBytes32(string calldata toml, string calldata key) external pure returns (bytes32);\\n\\n /// Parses a string of TOML data at `key` and coerces it to `bytes32[]`.\\n function parseTomlBytes32Array(string calldata toml, string calldata key)\\n external\\n pure\\n returns (bytes32[] memory);\\n\\n /// Parses a string of TOML data at `key` and coerces it to `bytes[]`.\\n function parseTomlBytesArray(string calldata toml, string calldata key) external pure returns (bytes[] memory);\\n\\n /// Parses a string of TOML data at `key` and coerces it to `int256`.\\n function parseTomlInt(string calldata toml, string calldata key) external pure returns (int256);\\n\\n /// Parses a string of TOML data at `key` and coerces it to `int256[]`.\\n function parseTomlIntArray(string calldata toml, string calldata key) external pure returns (int256[] memory);\\n\\n /// Returns an array of all the keys in a TOML table.\\n function parseTomlKeys(string calldata toml, string calldata key) external pure returns (string[] memory keys);\\n\\n /// Parses a string of TOML data at `key` and coerces it to `string`.\\n function parseTomlString(string calldata toml, string calldata key) external pure returns (string memory);\\n\\n /// Parses a string of TOML data at `key` and coerces it to `string[]`.\\n function parseTomlStringArray(string calldata toml, string calldata key) external pure returns (string[] memory);\\n\\n /// Parses a string of TOML data at `key` and coerces it to type array corresponding to `typeDescription`.\\n function parseTomlTypeArray(string calldata toml, string calldata key, string calldata typeDescription)\\n external\\n pure\\n returns (bytes memory);\\n\\n /// Parses a string of TOML data and coerces it to type corresponding to `typeDescription`.\\n function parseTomlType(string calldata toml, string calldata typeDescription)\\n external\\n pure\\n returns (bytes memory);\\n\\n /// Parses a string of TOML data at `key` and coerces it to type corresponding to `typeDescription`.\\n function parseTomlType(string calldata toml, string calldata key, string calldata typeDescription)\\n external\\n pure\\n returns (bytes memory);\\n\\n /// Parses a string of TOML data at `key` and coerces it to `uint256`.\\n function parseTomlUint(string calldata toml, string calldata key) external pure returns (uint256);\\n\\n /// Parses a string of TOML data at `key` and coerces it to `uint256[]`.\\n function parseTomlUintArray(string calldata toml, string calldata key) external pure returns (uint256[] memory);\\n\\n /// ABI-encodes a TOML table.\\n function parseToml(string calldata toml) external pure returns (bytes memory abiEncodedData);\\n\\n /// ABI-encodes a TOML table at `key`.\\n function parseToml(string calldata toml, string calldata key) external pure returns (bytes memory abiEncodedData);\\n\\n /// Takes serialized JSON, converts to TOML and write a serialized TOML to a file.\\n function writeToml(string calldata json, string calldata path) external;\\n\\n /// Takes serialized JSON, converts to TOML and write a serialized TOML table to an **existing** TOML file, replacing a value with key = \\n /// This is useful to replace a specific value of a TOML file, without having to parse the entire thing.\\n function writeToml(string calldata json, string calldata path, string calldata valueKey) external;\\n\\n // ======== Utilities ========\\n\\n /// Compute the address of a contract created with CREATE2 using the given CREATE2 deployer.\\n function computeCreate2Address(bytes32 salt, bytes32 initCodeHash, address deployer)\\n external\\n pure\\n returns (address);\\n\\n /// Compute the address of a contract created with CREATE2 using the default CREATE2 deployer.\\n function computeCreate2Address(bytes32 salt, bytes32 initCodeHash) external pure returns (address);\\n\\n /// Compute the address a contract will be deployed at for a given deployer address and nonce.\\n function computeCreateAddress(address deployer, uint256 nonce) external pure returns (address);\\n\\n /// Utility cheatcode to copy storage of `from` contract to another `to` contract.\\n function copyStorage(address from, address to) external;\\n\\n /// Returns ENS namehash for provided string.\\n function ensNamehash(string calldata name) external pure returns (bytes32);\\n\\n /// Gets the label for the specified address.\\n function getLabel(address account) external view returns (string memory currentLabel);\\n\\n /// Labels an address in call traces.\\n function label(address account, string calldata newLabel) external;\\n\\n /// Pauses collection of call traces. Useful in cases when you want to skip tracing of\\n /// complex calls which are not useful for debugging.\\n function pauseTracing() external view;\\n\\n /// Returns a random `address`.\\n function randomAddress() external returns (address);\\n\\n /// Returns a random `bool`.\\n function randomBool() external view returns (bool);\\n\\n /// Returns a random byte array value of the given length.\\n function randomBytes(uint256 len) external view returns (bytes memory);\\n\\n /// Returns a random fixed-size byte array of length 4.\\n function randomBytes4() external view returns (bytes4);\\n\\n /// Returns a random fixed-size byte array of length 8.\\n function randomBytes8() external view returns (bytes8);\\n\\n /// Returns a random `int256` value.\\n function randomInt() external view returns (int256);\\n\\n /// Returns a random `int256` value of given bits.\\n function randomInt(uint256 bits) external view returns (int256);\\n\\n /// Returns a random uint256 value.\\n function randomUint() external returns (uint256);\\n\\n /// Returns random uint256 value between the provided range (=min..=max).\\n function randomUint(uint256 min, uint256 max) external returns (uint256);\\n\\n /// Returns a random `uint256` value of given bits.\\n function randomUint(uint256 bits) external view returns (uint256);\\n\\n /// Unpauses collection of call traces.\\n function resumeTracing() external view;\\n\\n /// Utility cheatcode to set arbitrary storage for given target address.\\n function setArbitraryStorage(address target) external;\\n\\n /// Encodes a `bytes` value to a base64url string.\\n function toBase64URL(bytes calldata data) external pure returns (string memory);\\n\\n /// Encodes a `string` value to a base64url string.\\n function toBase64URL(string calldata data) external pure returns (string memory);\\n\\n /// Encodes a `bytes` value to a base64 string.\\n function toBase64(bytes calldata data) external pure returns (string memory);\\n\\n /// Encodes a `string` value to a base64 string.\\n function toBase64(string calldata data) external pure returns (string memory);\\n}\\n\\n/// The `Vm` interface does allow manipulation of the EVM state. These are all intended to be used\\n/// in tests, but it is not recommended to use these cheats in scripts.\\ninterface Vm is VmSafe {\\n // ======== EVM ========\\n\\n /// Utility cheatcode to set an EIP-2930 access list for all subsequent transactions.\\n function accessList(AccessListItem[] calldata access) external;\\n\\n /// Returns the identifier of the currently active fork. Reverts if no fork is currently active.\\n function activeFork() external view returns (uint256 forkId);\\n\\n /// In forking mode, explicitly grant the given address cheatcode access.\\n function allowCheatcodes(address account) external;\\n\\n /// Sets `block.blobbasefee`\\n function blobBaseFee(uint256 newBlobBaseFee) external;\\n\\n /// Sets the blobhashes in the transaction.\\n /// Not available on EVM versions before Cancun.\\n /// If used on unsupported EVM versions it will revert.\\n function blobhashes(bytes32[] calldata hashes) external;\\n\\n /// Sets `block.chainid`.\\n function chainId(uint256 newChainId) external;\\n\\n /// Clears all mocked calls.\\n function clearMockedCalls() external;\\n\\n /// Clones a source account code, state, balance and nonce to a target account and updates in-memory EVM state.\\n function cloneAccount(address source, address target) external;\\n\\n /// Sets `block.coinbase`.\\n function coinbase(address newCoinbase) external;\\n\\n /// Marks the slots of an account and the account address as cold.\\n function cool(address target) external;\\n\\n /// Utility cheatcode to mark specific storage slot as cold, simulating no prior read.\\n function coolSlot(address target, bytes32 slot) external;\\n\\n /// Creates a new fork with the given endpoint and the _latest_ block and returns the identifier of the fork.\\n function createFork(string calldata urlOrAlias) external returns (uint256 forkId);\\n\\n /// Creates a new fork with the given endpoint and block and returns the identifier of the fork.\\n function createFork(string calldata urlOrAlias, uint256 blockNumber) external returns (uint256 forkId);\\n\\n /// Creates a new fork with the given endpoint and at the block the given transaction was mined in,\\n /// replays all transaction mined in the block before the transaction, and returns the identifier of the fork.\\n function createFork(string calldata urlOrAlias, bytes32 txHash) external returns (uint256 forkId);\\n\\n /// Creates and also selects a new fork with the given endpoint and the latest block and returns the identifier of the fork.\\n function createSelectFork(string calldata urlOrAlias) external returns (uint256 forkId);\\n\\n /// Creates and also selects a new fork with the given endpoint and block and returns the identifier of the fork.\\n function createSelectFork(string calldata urlOrAlias, uint256 blockNumber) external returns (uint256 forkId);\\n\\n /// Creates and also selects new fork with the given endpoint and at the block the given transaction was mined in,\\n /// replays all transaction mined in the block before the transaction, returns the identifier of the fork.\\n function createSelectFork(string calldata urlOrAlias, bytes32 txHash) external returns (uint256 forkId);\\n\\n /// Sets an address' balance.\\n function deal(address account, uint256 newBalance) external;\\n\\n /// Removes the snapshot with the given ID created by `snapshot`.\\n /// Takes the snapshot ID to delete.\\n /// Returns `true` if the snapshot was successfully deleted.\\n /// Returns `false` if the snapshot does not exist.\\n function deleteStateSnapshot(uint256 snapshotId) external returns (bool success);\\n\\n /// Removes _all_ snapshots previously created by `snapshot`.\\n function deleteStateSnapshots() external;\\n\\n /// Sets `block.difficulty`.\\n /// Not available on EVM versions from Paris onwards. Use `prevrandao` instead.\\n /// Reverts if used on unsupported EVM versions.\\n function difficulty(uint256 newDifficulty) external;\\n\\n /// Dump a genesis JSON file's `allocs` to disk.\\n function dumpState(string calldata pathToStateJson) external;\\n\\n /// Sets an address' code.\\n function etch(address target, bytes calldata newRuntimeBytecode) external;\\n\\n /// Sets `block.basefee`.\\n function fee(uint256 newBasefee) external;\\n\\n /// Gets the blockhashes from the current transaction.\\n /// Not available on EVM versions before Cancun.\\n /// If used on unsupported EVM versions it will revert.\\n function getBlobhashes() external view returns (bytes32[] memory hashes);\\n\\n /// Returns true if the account is marked as persistent.\\n function isPersistent(address account) external view returns (bool persistent);\\n\\n /// Load a genesis JSON file's `allocs` into the in-memory EVM state.\\n function loadAllocs(string calldata pathToAllocsJson) external;\\n\\n /// Marks that the account(s) should use persistent storage across fork swaps in a multifork setup\\n /// Meaning, changes made to the state of this account will be kept when switching forks.\\n function makePersistent(address account) external;\\n\\n /// See `makePersistent(address)`.\\n function makePersistent(address account0, address account1) external;\\n\\n /// See `makePersistent(address)`.\\n function makePersistent(address account0, address account1, address account2) external;\\n\\n /// See `makePersistent(address)`.\\n function makePersistent(address[] calldata accounts) external;\\n\\n /// Reverts a call to an address with specified revert data.\\n function mockCallRevert(address callee, bytes calldata data, bytes calldata revertData) external;\\n\\n /// Reverts a call to an address with a specific `msg.value`, with specified revert data.\\n function mockCallRevert(address callee, uint256 msgValue, bytes calldata data, bytes calldata revertData)\\n external;\\n\\n /// Reverts a call to an address with specified revert data.\\n /// Overload to pass the function selector directly `token.approve.selector` instead of `abi.encodeWithSelector(token.approve.selector)`.\\n function mockCallRevert(address callee, bytes4 data, bytes calldata revertData) external;\\n\\n /// Reverts a call to an address with a specific `msg.value`, with specified revert data.\\n /// Overload to pass the function selector directly `token.approve.selector` instead of `abi.encodeWithSelector(token.approve.selector)`.\\n function mockCallRevert(address callee, uint256 msgValue, bytes4 data, bytes calldata revertData) external;\\n\\n /// Mocks a call to an address, returning specified data.\\n /// Calldata can either be strict or a partial match, e.g. if you only\\n /// pass a Solidity selector to the expected calldata, then the entire Solidity\\n /// function will be mocked.\\n function mockCall(address callee, bytes calldata data, bytes calldata returnData) external;\\n\\n /// Mocks a call to an address with a specific `msg.value`, returning specified data.\\n /// Calldata match takes precedence over `msg.value` in case of ambiguity.\\n function mockCall(address callee, uint256 msgValue, bytes calldata data, bytes calldata returnData) external;\\n\\n /// Mocks a call to an address, returning specified data.\\n /// Calldata can either be strict or a partial match, e.g. if you only\\n /// pass a Solidity selector to the expected calldata, then the entire Solidity\\n /// function will be mocked.\\n /// Overload to pass the function selector directly `token.approve.selector` instead of `abi.encodeWithSelector(token.approve.selector)`.\\n function mockCall(address callee, bytes4 data, bytes calldata returnData) external;\\n\\n /// Mocks a call to an address with a specific `msg.value`, returning specified data.\\n /// Calldata match takes precedence over `msg.value` in case of ambiguity.\\n /// Overload to pass the function selector directly `token.approve.selector` instead of `abi.encodeWithSelector(token.approve.selector)`.\\n function mockCall(address callee, uint256 msgValue, bytes4 data, bytes calldata returnData) external;\\n\\n /// Mocks multiple calls to an address, returning specified data for each call.\\n function mockCalls(address callee, bytes calldata data, bytes[] calldata returnData) external;\\n\\n /// Mocks multiple calls to an address with a specific `msg.value`, returning specified data for each call.\\n function mockCalls(address callee, uint256 msgValue, bytes calldata data, bytes[] calldata returnData) external;\\n\\n /// Whenever a call is made to `callee` with calldata `data`, this cheatcode instead calls\\n /// `target` with the same calldata. This functionality is similar to a delegate call made to\\n /// `target` contract from `callee`.\\n /// Can be used to substitute a call to a function with another implementation that captures\\n /// the primary logic of the original function but is easier to reason about.\\n /// If calldata is not a strict match then partial match by selector is attempted.\\n function mockFunction(address callee, address target, bytes calldata data) external;\\n\\n /// Utility cheatcode to remove any EIP-2930 access list set by `accessList` cheatcode.\\n function noAccessList() external;\\n\\n /// Sets the *next* call's `msg.sender` to be the input address.\\n function prank(address msgSender) external;\\n\\n /// Sets the *next* call's `msg.sender` to be the input address, and the `tx.origin` to be the second input.\\n function prank(address msgSender, address txOrigin) external;\\n\\n /// Sets the *next* delegate call's `msg.sender` to be the input address.\\n function prank(address msgSender, bool delegateCall) external;\\n\\n /// Sets the *next* delegate call's `msg.sender` to be the input address, and the `tx.origin` to be the second input.\\n function prank(address msgSender, address txOrigin, bool delegateCall) external;\\n\\n /// Sets `block.prevrandao`.\\n /// Not available on EVM versions before Paris. Use `difficulty` instead.\\n /// If used on unsupported EVM versions it will revert.\\n function prevrandao(bytes32 newPrevrandao) external;\\n\\n /// Sets `block.prevrandao`.\\n /// Not available on EVM versions before Paris. Use `difficulty` instead.\\n /// If used on unsupported EVM versions it will revert.\\n function prevrandao(uint256 newPrevrandao) external;\\n\\n /// Reads the current `msg.sender` and `tx.origin` from state and reports if there is any active caller modification.\\n function readCallers() external returns (CallerMode callerMode, address msgSender, address txOrigin);\\n\\n /// Resets the nonce of an account to 0 for EOAs and 1 for contract accounts.\\n function resetNonce(address account) external;\\n\\n /// Revert the state of the EVM to a previous snapshot\\n /// Takes the snapshot ID to revert to.\\n /// Returns `true` if the snapshot was successfully reverted.\\n /// Returns `false` if the snapshot does not exist.\\n /// **Note:** This does not automatically delete the snapshot. To delete the snapshot use `deleteStateSnapshot`.\\n function revertToState(uint256 snapshotId) external returns (bool success);\\n\\n /// Revert the state of the EVM to a previous snapshot and automatically deletes the snapshots\\n /// Takes the snapshot ID to revert to.\\n /// Returns `true` if the snapshot was successfully reverted and deleted.\\n /// Returns `false` if the snapshot does not exist.\\n function revertToStateAndDelete(uint256 snapshotId) external returns (bool success);\\n\\n /// Revokes persistent status from the address, previously added via `makePersistent`.\\n function revokePersistent(address account) external;\\n\\n /// See `revokePersistent(address)`.\\n function revokePersistent(address[] calldata accounts) external;\\n\\n /// Sets `block.height`.\\n function roll(uint256 newHeight) external;\\n\\n /// Updates the currently active fork to given block number\\n /// This is similar to `roll` but for the currently active fork.\\n function rollFork(uint256 blockNumber) external;\\n\\n /// Updates the currently active fork to given transaction. This will `rollFork` with the number\\n /// of the block the transaction was mined in and replays all transaction mined before it in the block.\\n function rollFork(bytes32 txHash) external;\\n\\n /// Updates the given fork to given block number.\\n function rollFork(uint256 forkId, uint256 blockNumber) external;\\n\\n /// Updates the given fork to block number of the given transaction and replays all transaction mined before it in the block.\\n function rollFork(uint256 forkId, bytes32 txHash) external;\\n\\n /// Takes a fork identifier created by `createFork` and sets the corresponding forked state as active.\\n function selectFork(uint256 forkId) external;\\n\\n /// Set blockhash for the current block.\\n /// It only sets the blockhash for blocks where `block.number - 256 <= number < block.number`.\\n function setBlockhash(uint256 blockNumber, bytes32 blockHash) external;\\n\\n /// Sets the nonce of an account. Must be higher than the current nonce of the account.\\n function setNonce(address account, uint64 newNonce) external;\\n\\n /// Sets the nonce of an account to an arbitrary value.\\n function setNonceUnsafe(address account, uint64 newNonce) external;\\n\\n /// Snapshot capture the gas usage of the last call by name from the callee perspective.\\n function snapshotGasLastCall(string calldata name) external returns (uint256 gasUsed);\\n\\n /// Snapshot capture the gas usage of the last call by name in a group from the callee perspective.\\n function snapshotGasLastCall(string calldata group, string calldata name) external returns (uint256 gasUsed);\\n\\n /// Snapshot the current state of the evm.\\n /// Returns the ID of the snapshot that was created.\\n /// To revert a snapshot use `revertToState`.\\n function snapshotState() external returns (uint256 snapshotId);\\n\\n /// Snapshot capture an arbitrary numerical value by name.\\n /// The group name is derived from the contract name.\\n function snapshotValue(string calldata name, uint256 value) external;\\n\\n /// Snapshot capture an arbitrary numerical value by name in a group.\\n function snapshotValue(string calldata group, string calldata name, uint256 value) external;\\n\\n /// Sets all subsequent calls' `msg.sender` to be the input address until `stopPrank` is called.\\n function startPrank(address msgSender) external;\\n\\n /// Sets all subsequent calls' `msg.sender` to be the input address until `stopPrank` is called, and the `tx.origin` to be the second input.\\n function startPrank(address msgSender, address txOrigin) external;\\n\\n /// Sets all subsequent delegate calls' `msg.sender` to be the input address until `stopPrank` is called.\\n function startPrank(address msgSender, bool delegateCall) external;\\n\\n /// Sets all subsequent delegate calls' `msg.sender` to be the input address until `stopPrank` is called, and the `tx.origin` to be the second input.\\n function startPrank(address msgSender, address txOrigin, bool delegateCall) external;\\n\\n /// Start a snapshot capture of the current gas usage by name.\\n /// The group name is derived from the contract name.\\n function startSnapshotGas(string calldata name) external;\\n\\n /// Start a snapshot capture of the current gas usage by name in a group.\\n function startSnapshotGas(string calldata group, string calldata name) external;\\n\\n /// Resets subsequent calls' `msg.sender` to be `address(this)`.\\n function stopPrank() external;\\n\\n /// Stop the snapshot capture of the current gas by latest snapshot name, capturing the gas used since the start.\\n function stopSnapshotGas() external returns (uint256 gasUsed);\\n\\n /// Stop the snapshot capture of the current gas usage by name, capturing the gas used since the start.\\n /// The group name is derived from the contract name.\\n function stopSnapshotGas(string calldata name) external returns (uint256 gasUsed);\\n\\n /// Stop the snapshot capture of the current gas usage by name in a group, capturing the gas used since the start.\\n function stopSnapshotGas(string calldata group, string calldata name) external returns (uint256 gasUsed);\\n\\n /// Stores a value to an address' storage slot.\\n function store(address target, bytes32 slot, bytes32 value) external;\\n\\n /// Fetches the given transaction from the active fork and executes it on the current state.\\n function transact(bytes32 txHash) external;\\n\\n /// Fetches the given transaction from the given fork and executes it on the current state.\\n function transact(uint256 forkId, bytes32 txHash) external;\\n\\n /// Sets `tx.gasprice`.\\n function txGasPrice(uint256 newGasPrice) external;\\n\\n /// Utility cheatcode to mark specific storage slot as warm, simulating a prior read.\\n function warmSlot(address target, bytes32 slot) external;\\n\\n /// Sets `block.timestamp`.\\n function warp(uint256 newTimestamp) external;\\n\\n /// `deleteSnapshot` is being deprecated in favor of `deleteStateSnapshot`. It will be removed in future versions.\\n function deleteSnapshot(uint256 snapshotId) external returns (bool success);\\n\\n /// `deleteSnapshots` is being deprecated in favor of `deleteStateSnapshots`. It will be removed in future versions.\\n function deleteSnapshots() external;\\n\\n /// `revertToAndDelete` is being deprecated in favor of `revertToStateAndDelete`. It will be removed in future versions.\\n function revertToAndDelete(uint256 snapshotId) external returns (bool success);\\n\\n /// `revertTo` is being deprecated in favor of `revertToState`. It will be removed in future versions.\\n function revertTo(uint256 snapshotId) external returns (bool success);\\n\\n /// `snapshot` is being deprecated in favor of `snapshotState`. It will be removed in future versions.\\n function snapshot() external returns (uint256 snapshotId);\\n\\n // ======== Testing ========\\n\\n /// Expect a call to an address with the specified `msg.value` and calldata, and a *minimum* amount of gas.\\n function expectCallMinGas(address callee, uint256 msgValue, uint64 minGas, bytes calldata data) external;\\n\\n /// Expect given number of calls to an address with the specified `msg.value` and calldata, and a *minimum* amount of gas.\\n function expectCallMinGas(address callee, uint256 msgValue, uint64 minGas, bytes calldata data, uint64 count)\\n external;\\n\\n /// Expects a call to an address with the specified calldata.\\n /// Calldata can either be a strict or a partial match.\\n function expectCall(address callee, bytes calldata data) external;\\n\\n /// Expects given number of calls to an address with the specified calldata.\\n function expectCall(address callee, bytes calldata data, uint64 count) external;\\n\\n /// Expects a call to an address with the specified `msg.value` and calldata.\\n function expectCall(address callee, uint256 msgValue, bytes calldata data) external;\\n\\n /// Expects given number of calls to an address with the specified `msg.value` and calldata.\\n function expectCall(address callee, uint256 msgValue, bytes calldata data, uint64 count) external;\\n\\n /// Expect a call to an address with the specified `msg.value`, gas, and calldata.\\n function expectCall(address callee, uint256 msgValue, uint64 gas, bytes calldata data) external;\\n\\n /// Expects given number of calls to an address with the specified `msg.value`, gas, and calldata.\\n function expectCall(address callee, uint256 msgValue, uint64 gas, bytes calldata data, uint64 count) external;\\n\\n /// Expects the deployment of the specified bytecode by the specified address using the CREATE opcode\\n function expectCreate(bytes calldata bytecode, address deployer) external;\\n\\n /// Expects the deployment of the specified bytecode by the specified address using the CREATE2 opcode\\n function expectCreate2(bytes calldata bytecode, address deployer) external;\\n\\n /// Prepare an expected anonymous log with (bool checkTopic1, bool checkTopic2, bool checkTopic3, bool checkData.).\\n /// Call this function, then emit an anonymous event, then call a function. Internally after the call, we check if\\n /// logs were emitted in the expected order with the expected topics and data (as specified by the booleans).\\n function expectEmitAnonymous(bool checkTopic0, bool checkTopic1, bool checkTopic2, bool checkTopic3, bool checkData)\\n external;\\n\\n /// Same as the previous method, but also checks supplied address against emitting contract.\\n function expectEmitAnonymous(\\n bool checkTopic0,\\n bool checkTopic1,\\n bool checkTopic2,\\n bool checkTopic3,\\n bool checkData,\\n address emitter\\n ) external;\\n\\n /// Prepare an expected anonymous log with all topic and data checks enabled.\\n /// Call this function, then emit an anonymous event, then call a function. Internally after the call, we check if\\n /// logs were emitted in the expected order with the expected topics and data.\\n function expectEmitAnonymous() external;\\n\\n /// Same as the previous method, but also checks supplied address against emitting contract.\\n function expectEmitAnonymous(address emitter) external;\\n\\n /// Prepare an expected log with (bool checkTopic1, bool checkTopic2, bool checkTopic3, bool checkData.).\\n /// Call this function, then emit an event, then call a function. Internally after the call, we check if\\n /// logs were emitted in the expected order with the expected topics and data (as specified by the booleans).\\n function expectEmit(bool checkTopic1, bool checkTopic2, bool checkTopic3, bool checkData) external;\\n\\n /// Same as the previous method, but also checks supplied address against emitting contract.\\n function expectEmit(bool checkTopic1, bool checkTopic2, bool checkTopic3, bool checkData, address emitter)\\n external;\\n\\n /// Prepare an expected log with all topic and data checks enabled.\\n /// Call this function, then emit an event, then call a function. Internally after the call, we check if\\n /// logs were emitted in the expected order with the expected topics and data.\\n function expectEmit() external;\\n\\n /// Same as the previous method, but also checks supplied address against emitting contract.\\n function expectEmit(address emitter) external;\\n\\n /// Expect a given number of logs with the provided topics.\\n function expectEmit(bool checkTopic1, bool checkTopic2, bool checkTopic3, bool checkData, uint64 count) external;\\n\\n /// Expect a given number of logs from a specific emitter with the provided topics.\\n function expectEmit(\\n bool checkTopic1,\\n bool checkTopic2,\\n bool checkTopic3,\\n bool checkData,\\n address emitter,\\n uint64 count\\n ) external;\\n\\n /// Expect a given number of logs with all topic and data checks enabled.\\n function expectEmit(uint64 count) external;\\n\\n /// Expect a given number of logs from a specific emitter with all topic and data checks enabled.\\n function expectEmit(address emitter, uint64 count) external;\\n\\n /// Expects an error on next call that starts with the revert data.\\n function expectPartialRevert(bytes4 revertData) external;\\n\\n /// Expects an error on next call to reverter address, that starts with the revert data.\\n function expectPartialRevert(bytes4 revertData, address reverter) external;\\n\\n /// Expects an error on next call with any revert data.\\n function expectRevert() external;\\n\\n /// Expects an error on next call that exactly matches the revert data.\\n function expectRevert(bytes4 revertData) external;\\n\\n /// Expects a `count` number of reverts from the upcoming calls from the reverter address that match the revert data.\\n function expectRevert(bytes4 revertData, address reverter, uint64 count) external;\\n\\n /// Expects a `count` number of reverts from the upcoming calls from the reverter address that exactly match the revert data.\\n function expectRevert(bytes calldata revertData, address reverter, uint64 count) external;\\n\\n /// Expects an error on next call that exactly matches the revert data.\\n function expectRevert(bytes calldata revertData) external;\\n\\n /// Expects an error with any revert data on next call to reverter address.\\n function expectRevert(address reverter) external;\\n\\n /// Expects an error from reverter address on next call, with any revert data.\\n function expectRevert(bytes4 revertData, address reverter) external;\\n\\n /// Expects an error from reverter address on next call, that exactly matches the revert data.\\n function expectRevert(bytes calldata revertData, address reverter) external;\\n\\n /// Expects a `count` number of reverts from the upcoming calls with any revert data or reverter.\\n function expectRevert(uint64 count) external;\\n\\n /// Expects a `count` number of reverts from the upcoming calls that match the revert data.\\n function expectRevert(bytes4 revertData, uint64 count) external;\\n\\n /// Expects a `count` number of reverts from the upcoming calls that exactly match the revert data.\\n function expectRevert(bytes calldata revertData, uint64 count) external;\\n\\n /// Expects a `count` number of reverts from the upcoming calls from the reverter address.\\n function expectRevert(address reverter, uint64 count) external;\\n\\n /// Only allows memory writes to offsets [0x00, 0x60) \\u222a [min, max) in the current subcontext. If any other\\n /// memory is written to, the test will fail. Can be called multiple times to add more ranges to the set.\\n function expectSafeMemory(uint64 min, uint64 max) external;\\n\\n /// Only allows memory writes to offsets [0x00, 0x60) \\u222a [min, max) in the next created subcontext.\\n /// If any other memory is written to, the test will fail. Can be called multiple times to add more ranges\\n /// to the set.\\n function expectSafeMemoryCall(uint64 min, uint64 max) external;\\n\\n /// Marks a test as skipped. Must be called at the top level of a test.\\n function skip(bool skipTest) external;\\n\\n /// Marks a test as skipped with a reason. Must be called at the top level of a test.\\n function skip(bool skipTest, string calldata reason) external;\\n\\n /// Stops all safe memory expectation in the current subcontext.\\n function stopExpectSafeMemory() external;\\n}\\n\",\"keccak256\":\"0xd91fb0df409fbd22463e937b48b9682d9333c5d4528d8fe7b36102a0323c44bf\",\"license\":\"MIT OR Apache-2.0\"},\"lib/forge-std/src/console.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity >=0.4.22 <0.9.0;\\n\\nlibrary console {\\n address constant CONSOLE_ADDRESS =\\n 0x000000000000000000636F6e736F6c652e6c6f67;\\n\\n function _sendLogPayloadImplementation(bytes memory payload) internal view {\\n address consoleAddress = CONSOLE_ADDRESS;\\n /// @solidity memory-safe-assembly\\n assembly {\\n pop(\\n staticcall(\\n gas(),\\n consoleAddress,\\n add(payload, 32),\\n mload(payload),\\n 0,\\n 0\\n )\\n )\\n }\\n }\\n\\n function _castToPure(\\n function(bytes memory) internal view fnIn\\n ) internal pure returns (function(bytes memory) pure fnOut) {\\n assembly {\\n fnOut := fnIn\\n }\\n }\\n\\n function _sendLogPayload(bytes memory payload) internal pure {\\n _castToPure(_sendLogPayloadImplementation)(payload);\\n }\\n\\n function log() internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log()\\\"));\\n }\\n\\n function logInt(int256 p0) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(int256)\\\", p0));\\n }\\n\\n function logUint(uint256 p0) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256)\\\", p0));\\n }\\n\\n function logString(string memory p0) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string)\\\", p0));\\n }\\n\\n function logBool(bool p0) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool)\\\", p0));\\n }\\n\\n function logAddress(address p0) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address)\\\", p0));\\n }\\n\\n function logBytes(bytes memory p0) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bytes)\\\", p0));\\n }\\n\\n function logBytes1(bytes1 p0) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bytes1)\\\", p0));\\n }\\n\\n function logBytes2(bytes2 p0) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bytes2)\\\", p0));\\n }\\n\\n function logBytes3(bytes3 p0) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bytes3)\\\", p0));\\n }\\n\\n function logBytes4(bytes4 p0) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bytes4)\\\", p0));\\n }\\n\\n function logBytes5(bytes5 p0) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bytes5)\\\", p0));\\n }\\n\\n function logBytes6(bytes6 p0) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bytes6)\\\", p0));\\n }\\n\\n function logBytes7(bytes7 p0) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bytes7)\\\", p0));\\n }\\n\\n function logBytes8(bytes8 p0) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bytes8)\\\", p0));\\n }\\n\\n function logBytes9(bytes9 p0) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bytes9)\\\", p0));\\n }\\n\\n function logBytes10(bytes10 p0) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bytes10)\\\", p0));\\n }\\n\\n function logBytes11(bytes11 p0) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bytes11)\\\", p0));\\n }\\n\\n function logBytes12(bytes12 p0) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bytes12)\\\", p0));\\n }\\n\\n function logBytes13(bytes13 p0) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bytes13)\\\", p0));\\n }\\n\\n function logBytes14(bytes14 p0) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bytes14)\\\", p0));\\n }\\n\\n function logBytes15(bytes15 p0) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bytes15)\\\", p0));\\n }\\n\\n function logBytes16(bytes16 p0) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bytes16)\\\", p0));\\n }\\n\\n function logBytes17(bytes17 p0) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bytes17)\\\", p0));\\n }\\n\\n function logBytes18(bytes18 p0) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bytes18)\\\", p0));\\n }\\n\\n function logBytes19(bytes19 p0) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bytes19)\\\", p0));\\n }\\n\\n function logBytes20(bytes20 p0) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bytes20)\\\", p0));\\n }\\n\\n function logBytes21(bytes21 p0) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bytes21)\\\", p0));\\n }\\n\\n function logBytes22(bytes22 p0) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bytes22)\\\", p0));\\n }\\n\\n function logBytes23(bytes23 p0) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bytes23)\\\", p0));\\n }\\n\\n function logBytes24(bytes24 p0) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bytes24)\\\", p0));\\n }\\n\\n function logBytes25(bytes25 p0) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bytes25)\\\", p0));\\n }\\n\\n function logBytes26(bytes26 p0) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bytes26)\\\", p0));\\n }\\n\\n function logBytes27(bytes27 p0) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bytes27)\\\", p0));\\n }\\n\\n function logBytes28(bytes28 p0) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bytes28)\\\", p0));\\n }\\n\\n function logBytes29(bytes29 p0) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bytes29)\\\", p0));\\n }\\n\\n function logBytes30(bytes30 p0) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bytes30)\\\", p0));\\n }\\n\\n function logBytes31(bytes31 p0) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bytes31)\\\", p0));\\n }\\n\\n function logBytes32(bytes32 p0) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bytes32)\\\", p0));\\n }\\n\\n function log(uint256 p0) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256)\\\", p0));\\n }\\n\\n function log(int256 p0) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(int256)\\\", p0));\\n }\\n\\n function log(string memory p0) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string)\\\", p0));\\n }\\n\\n function log(bool p0) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool)\\\", p0));\\n }\\n\\n function log(address p0) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address)\\\", p0));\\n }\\n\\n function log(uint256 p0, uint256 p1) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,uint256)\\\", p0, p1));\\n }\\n\\n function log(uint256 p0, string memory p1) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,string)\\\", p0, p1));\\n }\\n\\n function log(uint256 p0, bool p1) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,bool)\\\", p0, p1));\\n }\\n\\n function log(uint256 p0, address p1) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,address)\\\", p0, p1));\\n }\\n\\n function log(string memory p0, uint256 p1) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,uint256)\\\", p0, p1));\\n }\\n\\n function log(string memory p0, int256 p1) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,int256)\\\", p0, p1));\\n }\\n\\n function log(string memory p0, string memory p1) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,string)\\\", p0, p1));\\n }\\n\\n function log(string memory p0, bool p1) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,bool)\\\", p0, p1));\\n }\\n\\n function log(string memory p0, address p1) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,address)\\\", p0, p1));\\n }\\n\\n function log(bool p0, uint256 p1) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,uint256)\\\", p0, p1));\\n }\\n\\n function log(bool p0, string memory p1) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,string)\\\", p0, p1));\\n }\\n\\n function log(bool p0, bool p1) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,bool)\\\", p0, p1));\\n }\\n\\n function log(bool p0, address p1) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,address)\\\", p0, p1));\\n }\\n\\n function log(address p0, uint256 p1) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,uint256)\\\", p0, p1));\\n }\\n\\n function log(address p0, string memory p1) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,string)\\\", p0, p1));\\n }\\n\\n function log(address p0, bool p1) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,bool)\\\", p0, p1));\\n }\\n\\n function log(address p0, address p1) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,address)\\\", p0, p1));\\n }\\n\\n function log(uint256 p0, uint256 p1, uint256 p2) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,uint256,uint256)\\\", p0, p1, p2));\\n }\\n\\n function log(uint256 p0, uint256 p1, string memory p2) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,uint256,string)\\\", p0, p1, p2));\\n }\\n\\n function log(uint256 p0, uint256 p1, bool p2) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,uint256,bool)\\\", p0, p1, p2));\\n }\\n\\n function log(uint256 p0, uint256 p1, address p2) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,uint256,address)\\\", p0, p1, p2));\\n }\\n\\n function log(uint256 p0, string memory p1, uint256 p2) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,string,uint256)\\\", p0, p1, p2));\\n }\\n\\n function log(uint256 p0, string memory p1, string memory p2) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,string,string)\\\", p0, p1, p2));\\n }\\n\\n function log(uint256 p0, string memory p1, bool p2) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,string,bool)\\\", p0, p1, p2));\\n }\\n\\n function log(uint256 p0, string memory p1, address p2) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,string,address)\\\", p0, p1, p2));\\n }\\n\\n function log(uint256 p0, bool p1, uint256 p2) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,bool,uint256)\\\", p0, p1, p2));\\n }\\n\\n function log(uint256 p0, bool p1, string memory p2) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,bool,string)\\\", p0, p1, p2));\\n }\\n\\n function log(uint256 p0, bool p1, bool p2) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,bool,bool)\\\", p0, p1, p2));\\n }\\n\\n function log(uint256 p0, bool p1, address p2) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,bool,address)\\\", p0, p1, p2));\\n }\\n\\n function log(uint256 p0, address p1, uint256 p2) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,address,uint256)\\\", p0, p1, p2));\\n }\\n\\n function log(uint256 p0, address p1, string memory p2) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,address,string)\\\", p0, p1, p2));\\n }\\n\\n function log(uint256 p0, address p1, bool p2) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,address,bool)\\\", p0, p1, p2));\\n }\\n\\n function log(uint256 p0, address p1, address p2) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,address,address)\\\", p0, p1, p2));\\n }\\n\\n function log(string memory p0, uint256 p1, uint256 p2) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,uint256,uint256)\\\", p0, p1, p2));\\n }\\n\\n function log(string memory p0, uint256 p1, string memory p2) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,uint256,string)\\\", p0, p1, p2));\\n }\\n\\n function log(string memory p0, uint256 p1, bool p2) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,uint256,bool)\\\", p0, p1, p2));\\n }\\n\\n function log(string memory p0, uint256 p1, address p2) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,uint256,address)\\\", p0, p1, p2));\\n }\\n\\n function log(string memory p0, string memory p1, uint256 p2) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,string,uint256)\\\", p0, p1, p2));\\n }\\n\\n function log(string memory p0, string memory p1, string memory p2) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,string,string)\\\", p0, p1, p2));\\n }\\n\\n function log(string memory p0, string memory p1, bool p2) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,string,bool)\\\", p0, p1, p2));\\n }\\n\\n function log(string memory p0, string memory p1, address p2) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,string,address)\\\", p0, p1, p2));\\n }\\n\\n function log(string memory p0, bool p1, uint256 p2) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,bool,uint256)\\\", p0, p1, p2));\\n }\\n\\n function log(string memory p0, bool p1, string memory p2) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,bool,string)\\\", p0, p1, p2));\\n }\\n\\n function log(string memory p0, bool p1, bool p2) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,bool,bool)\\\", p0, p1, p2));\\n }\\n\\n function log(string memory p0, bool p1, address p2) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,bool,address)\\\", p0, p1, p2));\\n }\\n\\n function log(string memory p0, address p1, uint256 p2) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,address,uint256)\\\", p0, p1, p2));\\n }\\n\\n function log(string memory p0, address p1, string memory p2) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,address,string)\\\", p0, p1, p2));\\n }\\n\\n function log(string memory p0, address p1, bool p2) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,address,bool)\\\", p0, p1, p2));\\n }\\n\\n function log(string memory p0, address p1, address p2) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,address,address)\\\", p0, p1, p2));\\n }\\n\\n function log(bool p0, uint256 p1, uint256 p2) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,uint256,uint256)\\\", p0, p1, p2));\\n }\\n\\n function log(bool p0, uint256 p1, string memory p2) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,uint256,string)\\\", p0, p1, p2));\\n }\\n\\n function log(bool p0, uint256 p1, bool p2) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,uint256,bool)\\\", p0, p1, p2));\\n }\\n\\n function log(bool p0, uint256 p1, address p2) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,uint256,address)\\\", p0, p1, p2));\\n }\\n\\n function log(bool p0, string memory p1, uint256 p2) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,string,uint256)\\\", p0, p1, p2));\\n }\\n\\n function log(bool p0, string memory p1, string memory p2) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,string,string)\\\", p0, p1, p2));\\n }\\n\\n function log(bool p0, string memory p1, bool p2) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,string,bool)\\\", p0, p1, p2));\\n }\\n\\n function log(bool p0, string memory p1, address p2) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,string,address)\\\", p0, p1, p2));\\n }\\n\\n function log(bool p0, bool p1, uint256 p2) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,bool,uint256)\\\", p0, p1, p2));\\n }\\n\\n function log(bool p0, bool p1, string memory p2) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,bool,string)\\\", p0, p1, p2));\\n }\\n\\n function log(bool p0, bool p1, bool p2) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,bool,bool)\\\", p0, p1, p2));\\n }\\n\\n function log(bool p0, bool p1, address p2) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,bool,address)\\\", p0, p1, p2));\\n }\\n\\n function log(bool p0, address p1, uint256 p2) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,address,uint256)\\\", p0, p1, p2));\\n }\\n\\n function log(bool p0, address p1, string memory p2) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,address,string)\\\", p0, p1, p2));\\n }\\n\\n function log(bool p0, address p1, bool p2) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,address,bool)\\\", p0, p1, p2));\\n }\\n\\n function log(bool p0, address p1, address p2) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,address,address)\\\", p0, p1, p2));\\n }\\n\\n function log(address p0, uint256 p1, uint256 p2) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,uint256,uint256)\\\", p0, p1, p2));\\n }\\n\\n function log(address p0, uint256 p1, string memory p2) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,uint256,string)\\\", p0, p1, p2));\\n }\\n\\n function log(address p0, uint256 p1, bool p2) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,uint256,bool)\\\", p0, p1, p2));\\n }\\n\\n function log(address p0, uint256 p1, address p2) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,uint256,address)\\\", p0, p1, p2));\\n }\\n\\n function log(address p0, string memory p1, uint256 p2) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,string,uint256)\\\", p0, p1, p2));\\n }\\n\\n function log(address p0, string memory p1, string memory p2) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,string,string)\\\", p0, p1, p2));\\n }\\n\\n function log(address p0, string memory p1, bool p2) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,string,bool)\\\", p0, p1, p2));\\n }\\n\\n function log(address p0, string memory p1, address p2) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,string,address)\\\", p0, p1, p2));\\n }\\n\\n function log(address p0, bool p1, uint256 p2) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,bool,uint256)\\\", p0, p1, p2));\\n }\\n\\n function log(address p0, bool p1, string memory p2) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,bool,string)\\\", p0, p1, p2));\\n }\\n\\n function log(address p0, bool p1, bool p2) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,bool,bool)\\\", p0, p1, p2));\\n }\\n\\n function log(address p0, bool p1, address p2) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,bool,address)\\\", p0, p1, p2));\\n }\\n\\n function log(address p0, address p1, uint256 p2) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,address,uint256)\\\", p0, p1, p2));\\n }\\n\\n function log(address p0, address p1, string memory p2) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,address,string)\\\", p0, p1, p2));\\n }\\n\\n function log(address p0, address p1, bool p2) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,address,bool)\\\", p0, p1, p2));\\n }\\n\\n function log(address p0, address p1, address p2) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,address,address)\\\", p0, p1, p2));\\n }\\n\\n function log(uint256 p0, uint256 p1, uint256 p2, uint256 p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,uint256,uint256,uint256)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(uint256 p0, uint256 p1, uint256 p2, string memory p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,uint256,uint256,string)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(uint256 p0, uint256 p1, uint256 p2, bool p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,uint256,uint256,bool)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(uint256 p0, uint256 p1, uint256 p2, address p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,uint256,uint256,address)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(uint256 p0, uint256 p1, string memory p2, uint256 p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,uint256,string,uint256)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(uint256 p0, uint256 p1, string memory p2, string memory p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,uint256,string,string)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(uint256 p0, uint256 p1, string memory p2, bool p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,uint256,string,bool)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(uint256 p0, uint256 p1, string memory p2, address p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,uint256,string,address)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(uint256 p0, uint256 p1, bool p2, uint256 p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,uint256,bool,uint256)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(uint256 p0, uint256 p1, bool p2, string memory p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,uint256,bool,string)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(uint256 p0, uint256 p1, bool p2, bool p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,uint256,bool,bool)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(uint256 p0, uint256 p1, bool p2, address p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,uint256,bool,address)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(uint256 p0, uint256 p1, address p2, uint256 p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,uint256,address,uint256)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(uint256 p0, uint256 p1, address p2, string memory p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,uint256,address,string)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(uint256 p0, uint256 p1, address p2, bool p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,uint256,address,bool)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(uint256 p0, uint256 p1, address p2, address p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,uint256,address,address)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(uint256 p0, string memory p1, uint256 p2, uint256 p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,string,uint256,uint256)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(uint256 p0, string memory p1, uint256 p2, string memory p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,string,uint256,string)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(uint256 p0, string memory p1, uint256 p2, bool p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,string,uint256,bool)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(uint256 p0, string memory p1, uint256 p2, address p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,string,uint256,address)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(uint256 p0, string memory p1, string memory p2, uint256 p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,string,string,uint256)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(uint256 p0, string memory p1, string memory p2, string memory p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,string,string,string)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(uint256 p0, string memory p1, string memory p2, bool p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,string,string,bool)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(uint256 p0, string memory p1, string memory p2, address p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,string,string,address)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(uint256 p0, string memory p1, bool p2, uint256 p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,string,bool,uint256)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(uint256 p0, string memory p1, bool p2, string memory p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,string,bool,string)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(uint256 p0, string memory p1, bool p2, bool p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,string,bool,bool)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(uint256 p0, string memory p1, bool p2, address p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,string,bool,address)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(uint256 p0, string memory p1, address p2, uint256 p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,string,address,uint256)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(uint256 p0, string memory p1, address p2, string memory p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,string,address,string)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(uint256 p0, string memory p1, address p2, bool p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,string,address,bool)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(uint256 p0, string memory p1, address p2, address p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,string,address,address)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(uint256 p0, bool p1, uint256 p2, uint256 p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,bool,uint256,uint256)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(uint256 p0, bool p1, uint256 p2, string memory p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,bool,uint256,string)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(uint256 p0, bool p1, uint256 p2, bool p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,bool,uint256,bool)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(uint256 p0, bool p1, uint256 p2, address p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,bool,uint256,address)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(uint256 p0, bool p1, string memory p2, uint256 p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,bool,string,uint256)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(uint256 p0, bool p1, string memory p2, string memory p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,bool,string,string)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(uint256 p0, bool p1, string memory p2, bool p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,bool,string,bool)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(uint256 p0, bool p1, string memory p2, address p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,bool,string,address)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(uint256 p0, bool p1, bool p2, uint256 p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,bool,bool,uint256)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(uint256 p0, bool p1, bool p2, string memory p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,bool,bool,string)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(uint256 p0, bool p1, bool p2, bool p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,bool,bool,bool)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(uint256 p0, bool p1, bool p2, address p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,bool,bool,address)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(uint256 p0, bool p1, address p2, uint256 p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,bool,address,uint256)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(uint256 p0, bool p1, address p2, string memory p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,bool,address,string)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(uint256 p0, bool p1, address p2, bool p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,bool,address,bool)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(uint256 p0, bool p1, address p2, address p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,bool,address,address)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(uint256 p0, address p1, uint256 p2, uint256 p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,address,uint256,uint256)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(uint256 p0, address p1, uint256 p2, string memory p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,address,uint256,string)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(uint256 p0, address p1, uint256 p2, bool p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,address,uint256,bool)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(uint256 p0, address p1, uint256 p2, address p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,address,uint256,address)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(uint256 p0, address p1, string memory p2, uint256 p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,address,string,uint256)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(uint256 p0, address p1, string memory p2, string memory p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,address,string,string)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(uint256 p0, address p1, string memory p2, bool p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,address,string,bool)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(uint256 p0, address p1, string memory p2, address p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,address,string,address)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(uint256 p0, address p1, bool p2, uint256 p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,address,bool,uint256)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(uint256 p0, address p1, bool p2, string memory p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,address,bool,string)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(uint256 p0, address p1, bool p2, bool p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,address,bool,bool)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(uint256 p0, address p1, bool p2, address p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,address,bool,address)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(uint256 p0, address p1, address p2, uint256 p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,address,address,uint256)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(uint256 p0, address p1, address p2, string memory p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,address,address,string)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(uint256 p0, address p1, address p2, bool p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,address,address,bool)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(uint256 p0, address p1, address p2, address p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,address,address,address)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(string memory p0, uint256 p1, uint256 p2, uint256 p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,uint256,uint256,uint256)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(string memory p0, uint256 p1, uint256 p2, string memory p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,uint256,uint256,string)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(string memory p0, uint256 p1, uint256 p2, bool p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,uint256,uint256,bool)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(string memory p0, uint256 p1, uint256 p2, address p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,uint256,uint256,address)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(string memory p0, uint256 p1, string memory p2, uint256 p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,uint256,string,uint256)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(string memory p0, uint256 p1, string memory p2, string memory p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,uint256,string,string)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(string memory p0, uint256 p1, string memory p2, bool p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,uint256,string,bool)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(string memory p0, uint256 p1, string memory p2, address p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,uint256,string,address)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(string memory p0, uint256 p1, bool p2, uint256 p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,uint256,bool,uint256)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(string memory p0, uint256 p1, bool p2, string memory p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,uint256,bool,string)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(string memory p0, uint256 p1, bool p2, bool p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,uint256,bool,bool)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(string memory p0, uint256 p1, bool p2, address p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,uint256,bool,address)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(string memory p0, uint256 p1, address p2, uint256 p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,uint256,address,uint256)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(string memory p0, uint256 p1, address p2, string memory p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,uint256,address,string)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(string memory p0, uint256 p1, address p2, bool p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,uint256,address,bool)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(string memory p0, uint256 p1, address p2, address p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,uint256,address,address)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(string memory p0, string memory p1, uint256 p2, uint256 p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,string,uint256,uint256)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(string memory p0, string memory p1, uint256 p2, string memory p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,string,uint256,string)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(string memory p0, string memory p1, uint256 p2, bool p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,string,uint256,bool)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(string memory p0, string memory p1, uint256 p2, address p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,string,uint256,address)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(string memory p0, string memory p1, string memory p2, uint256 p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,string,string,uint256)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(string memory p0, string memory p1, string memory p2, string memory p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,string,string,string)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(string memory p0, string memory p1, string memory p2, bool p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,string,string,bool)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(string memory p0, string memory p1, string memory p2, address p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,string,string,address)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(string memory p0, string memory p1, bool p2, uint256 p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,string,bool,uint256)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(string memory p0, string memory p1, bool p2, string memory p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,string,bool,string)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(string memory p0, string memory p1, bool p2, bool p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,string,bool,bool)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(string memory p0, string memory p1, bool p2, address p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,string,bool,address)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(string memory p0, string memory p1, address p2, uint256 p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,string,address,uint256)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(string memory p0, string memory p1, address p2, string memory p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,string,address,string)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(string memory p0, string memory p1, address p2, bool p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,string,address,bool)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(string memory p0, string memory p1, address p2, address p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,string,address,address)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(string memory p0, bool p1, uint256 p2, uint256 p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,bool,uint256,uint256)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(string memory p0, bool p1, uint256 p2, string memory p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,bool,uint256,string)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(string memory p0, bool p1, uint256 p2, bool p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,bool,uint256,bool)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(string memory p0, bool p1, uint256 p2, address p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,bool,uint256,address)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(string memory p0, bool p1, string memory p2, uint256 p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,bool,string,uint256)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(string memory p0, bool p1, string memory p2, string memory p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,bool,string,string)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(string memory p0, bool p1, string memory p2, bool p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,bool,string,bool)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(string memory p0, bool p1, string memory p2, address p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,bool,string,address)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(string memory p0, bool p1, bool p2, uint256 p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,bool,bool,uint256)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(string memory p0, bool p1, bool p2, string memory p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,bool,bool,string)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(string memory p0, bool p1, bool p2, bool p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,bool,bool,bool)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(string memory p0, bool p1, bool p2, address p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,bool,bool,address)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(string memory p0, bool p1, address p2, uint256 p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,bool,address,uint256)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(string memory p0, bool p1, address p2, string memory p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,bool,address,string)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(string memory p0, bool p1, address p2, bool p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,bool,address,bool)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(string memory p0, bool p1, address p2, address p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,bool,address,address)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(string memory p0, address p1, uint256 p2, uint256 p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,address,uint256,uint256)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(string memory p0, address p1, uint256 p2, string memory p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,address,uint256,string)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(string memory p0, address p1, uint256 p2, bool p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,address,uint256,bool)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(string memory p0, address p1, uint256 p2, address p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,address,uint256,address)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(string memory p0, address p1, string memory p2, uint256 p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,address,string,uint256)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(string memory p0, address p1, string memory p2, string memory p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,address,string,string)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(string memory p0, address p1, string memory p2, bool p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,address,string,bool)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(string memory p0, address p1, string memory p2, address p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,address,string,address)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(string memory p0, address p1, bool p2, uint256 p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,address,bool,uint256)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(string memory p0, address p1, bool p2, string memory p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,address,bool,string)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(string memory p0, address p1, bool p2, bool p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,address,bool,bool)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(string memory p0, address p1, bool p2, address p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,address,bool,address)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(string memory p0, address p1, address p2, uint256 p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,address,address,uint256)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(string memory p0, address p1, address p2, string memory p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,address,address,string)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(string memory p0, address p1, address p2, bool p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,address,address,bool)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(string memory p0, address p1, address p2, address p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,address,address,address)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(bool p0, uint256 p1, uint256 p2, uint256 p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,uint256,uint256,uint256)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(bool p0, uint256 p1, uint256 p2, string memory p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,uint256,uint256,string)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(bool p0, uint256 p1, uint256 p2, bool p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,uint256,uint256,bool)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(bool p0, uint256 p1, uint256 p2, address p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,uint256,uint256,address)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(bool p0, uint256 p1, string memory p2, uint256 p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,uint256,string,uint256)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(bool p0, uint256 p1, string memory p2, string memory p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,uint256,string,string)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(bool p0, uint256 p1, string memory p2, bool p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,uint256,string,bool)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(bool p0, uint256 p1, string memory p2, address p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,uint256,string,address)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(bool p0, uint256 p1, bool p2, uint256 p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,uint256,bool,uint256)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(bool p0, uint256 p1, bool p2, string memory p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,uint256,bool,string)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(bool p0, uint256 p1, bool p2, bool p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,uint256,bool,bool)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(bool p0, uint256 p1, bool p2, address p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,uint256,bool,address)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(bool p0, uint256 p1, address p2, uint256 p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,uint256,address,uint256)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(bool p0, uint256 p1, address p2, string memory p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,uint256,address,string)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(bool p0, uint256 p1, address p2, bool p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,uint256,address,bool)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(bool p0, uint256 p1, address p2, address p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,uint256,address,address)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(bool p0, string memory p1, uint256 p2, uint256 p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,string,uint256,uint256)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(bool p0, string memory p1, uint256 p2, string memory p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,string,uint256,string)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(bool p0, string memory p1, uint256 p2, bool p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,string,uint256,bool)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(bool p0, string memory p1, uint256 p2, address p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,string,uint256,address)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(bool p0, string memory p1, string memory p2, uint256 p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,string,string,uint256)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(bool p0, string memory p1, string memory p2, string memory p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,string,string,string)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(bool p0, string memory p1, string memory p2, bool p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,string,string,bool)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(bool p0, string memory p1, string memory p2, address p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,string,string,address)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(bool p0, string memory p1, bool p2, uint256 p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,string,bool,uint256)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(bool p0, string memory p1, bool p2, string memory p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,string,bool,string)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(bool p0, string memory p1, bool p2, bool p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,string,bool,bool)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(bool p0, string memory p1, bool p2, address p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,string,bool,address)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(bool p0, string memory p1, address p2, uint256 p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,string,address,uint256)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(bool p0, string memory p1, address p2, string memory p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,string,address,string)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(bool p0, string memory p1, address p2, bool p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,string,address,bool)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(bool p0, string memory p1, address p2, address p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,string,address,address)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(bool p0, bool p1, uint256 p2, uint256 p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,bool,uint256,uint256)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(bool p0, bool p1, uint256 p2, string memory p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,bool,uint256,string)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(bool p0, bool p1, uint256 p2, bool p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,bool,uint256,bool)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(bool p0, bool p1, uint256 p2, address p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,bool,uint256,address)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(bool p0, bool p1, string memory p2, uint256 p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,bool,string,uint256)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(bool p0, bool p1, string memory p2, string memory p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,bool,string,string)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(bool p0, bool p1, string memory p2, bool p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,bool,string,bool)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(bool p0, bool p1, string memory p2, address p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,bool,string,address)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(bool p0, bool p1, bool p2, uint256 p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,bool,bool,uint256)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(bool p0, bool p1, bool p2, string memory p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,bool,bool,string)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(bool p0, bool p1, bool p2, bool p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,bool,bool,bool)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(bool p0, bool p1, bool p2, address p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,bool,bool,address)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(bool p0, bool p1, address p2, uint256 p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,bool,address,uint256)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(bool p0, bool p1, address p2, string memory p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,bool,address,string)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(bool p0, bool p1, address p2, bool p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,bool,address,bool)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(bool p0, bool p1, address p2, address p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,bool,address,address)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(bool p0, address p1, uint256 p2, uint256 p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,address,uint256,uint256)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(bool p0, address p1, uint256 p2, string memory p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,address,uint256,string)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(bool p0, address p1, uint256 p2, bool p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,address,uint256,bool)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(bool p0, address p1, uint256 p2, address p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,address,uint256,address)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(bool p0, address p1, string memory p2, uint256 p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,address,string,uint256)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(bool p0, address p1, string memory p2, string memory p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,address,string,string)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(bool p0, address p1, string memory p2, bool p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,address,string,bool)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(bool p0, address p1, string memory p2, address p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,address,string,address)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(bool p0, address p1, bool p2, uint256 p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,address,bool,uint256)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(bool p0, address p1, bool p2, string memory p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,address,bool,string)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(bool p0, address p1, bool p2, bool p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,address,bool,bool)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(bool p0, address p1, bool p2, address p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,address,bool,address)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(bool p0, address p1, address p2, uint256 p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,address,address,uint256)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(bool p0, address p1, address p2, string memory p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,address,address,string)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(bool p0, address p1, address p2, bool p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,address,address,bool)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(bool p0, address p1, address p2, address p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,address,address,address)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(address p0, uint256 p1, uint256 p2, uint256 p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,uint256,uint256,uint256)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(address p0, uint256 p1, uint256 p2, string memory p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,uint256,uint256,string)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(address p0, uint256 p1, uint256 p2, bool p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,uint256,uint256,bool)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(address p0, uint256 p1, uint256 p2, address p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,uint256,uint256,address)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(address p0, uint256 p1, string memory p2, uint256 p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,uint256,string,uint256)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(address p0, uint256 p1, string memory p2, string memory p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,uint256,string,string)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(address p0, uint256 p1, string memory p2, bool p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,uint256,string,bool)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(address p0, uint256 p1, string memory p2, address p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,uint256,string,address)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(address p0, uint256 p1, bool p2, uint256 p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,uint256,bool,uint256)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(address p0, uint256 p1, bool p2, string memory p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,uint256,bool,string)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(address p0, uint256 p1, bool p2, bool p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,uint256,bool,bool)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(address p0, uint256 p1, bool p2, address p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,uint256,bool,address)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(address p0, uint256 p1, address p2, uint256 p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,uint256,address,uint256)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(address p0, uint256 p1, address p2, string memory p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,uint256,address,string)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(address p0, uint256 p1, address p2, bool p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,uint256,address,bool)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(address p0, uint256 p1, address p2, address p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,uint256,address,address)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(address p0, string memory p1, uint256 p2, uint256 p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,string,uint256,uint256)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(address p0, string memory p1, uint256 p2, string memory p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,string,uint256,string)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(address p0, string memory p1, uint256 p2, bool p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,string,uint256,bool)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(address p0, string memory p1, uint256 p2, address p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,string,uint256,address)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(address p0, string memory p1, string memory p2, uint256 p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,string,string,uint256)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(address p0, string memory p1, string memory p2, string memory p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,string,string,string)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(address p0, string memory p1, string memory p2, bool p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,string,string,bool)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(address p0, string memory p1, string memory p2, address p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,string,string,address)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(address p0, string memory p1, bool p2, uint256 p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,string,bool,uint256)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(address p0, string memory p1, bool p2, string memory p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,string,bool,string)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(address p0, string memory p1, bool p2, bool p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,string,bool,bool)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(address p0, string memory p1, bool p2, address p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,string,bool,address)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(address p0, string memory p1, address p2, uint256 p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,string,address,uint256)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(address p0, string memory p1, address p2, string memory p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,string,address,string)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(address p0, string memory p1, address p2, bool p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,string,address,bool)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(address p0, string memory p1, address p2, address p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,string,address,address)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(address p0, bool p1, uint256 p2, uint256 p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,bool,uint256,uint256)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(address p0, bool p1, uint256 p2, string memory p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,bool,uint256,string)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(address p0, bool p1, uint256 p2, bool p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,bool,uint256,bool)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(address p0, bool p1, uint256 p2, address p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,bool,uint256,address)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(address p0, bool p1, string memory p2, uint256 p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,bool,string,uint256)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(address p0, bool p1, string memory p2, string memory p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,bool,string,string)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(address p0, bool p1, string memory p2, bool p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,bool,string,bool)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(address p0, bool p1, string memory p2, address p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,bool,string,address)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(address p0, bool p1, bool p2, uint256 p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,bool,bool,uint256)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(address p0, bool p1, bool p2, string memory p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,bool,bool,string)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(address p0, bool p1, bool p2, bool p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,bool,bool,bool)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(address p0, bool p1, bool p2, address p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,bool,bool,address)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(address p0, bool p1, address p2, uint256 p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,bool,address,uint256)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(address p0, bool p1, address p2, string memory p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,bool,address,string)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(address p0, bool p1, address p2, bool p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,bool,address,bool)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(address p0, bool p1, address p2, address p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,bool,address,address)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(address p0, address p1, uint256 p2, uint256 p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,address,uint256,uint256)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(address p0, address p1, uint256 p2, string memory p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,address,uint256,string)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(address p0, address p1, uint256 p2, bool p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,address,uint256,bool)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(address p0, address p1, uint256 p2, address p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,address,uint256,address)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(address p0, address p1, string memory p2, uint256 p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,address,string,uint256)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(address p0, address p1, string memory p2, string memory p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,address,string,string)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(address p0, address p1, string memory p2, bool p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,address,string,bool)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(address p0, address p1, string memory p2, address p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,address,string,address)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(address p0, address p1, bool p2, uint256 p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,address,bool,uint256)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(address p0, address p1, bool p2, string memory p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,address,bool,string)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(address p0, address p1, bool p2, bool p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,address,bool,bool)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(address p0, address p1, bool p2, address p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,address,bool,address)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(address p0, address p1, address p2, uint256 p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,address,address,uint256)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(address p0, address p1, address p2, string memory p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,address,address,string)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(address p0, address p1, address p2, bool p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,address,address,bool)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(address p0, address p1, address p2, address p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,address,address,address)\\\", p0, p1, p2, p3));\\n }\\n}\\n\",\"keccak256\":\"0x4bbf47eb762cef93729d6ef15e78789957147039b113e5d4df48e3d3fd16d0f5\",\"license\":\"MIT\"},\"lib/forge-std/src/console2.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity >=0.4.22 <0.9.0;\\n\\nimport {console as console2} from \\\"./console.sol\\\";\\n\",\"keccak256\":\"0x3b8fe79f48f065a4e4d35362171304a33784c3a90febae5f2787805a438de12f\",\"license\":\"MIT\"},\"lib/forge-std/src/interfaces/IMulticall3.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity >=0.6.2 <0.9.0;\\n\\npragma experimental ABIEncoderV2;\\n\\ninterface IMulticall3 {\\n struct Call {\\n address target;\\n bytes callData;\\n }\\n\\n struct Call3 {\\n address target;\\n bool allowFailure;\\n bytes callData;\\n }\\n\\n struct Call3Value {\\n address target;\\n bool allowFailure;\\n uint256 value;\\n bytes callData;\\n }\\n\\n struct Result {\\n bool success;\\n bytes returnData;\\n }\\n\\n function aggregate(Call[] calldata calls)\\n external\\n payable\\n returns (uint256 blockNumber, bytes[] memory returnData);\\n\\n function aggregate3(Call3[] calldata calls) external payable returns (Result[] memory returnData);\\n\\n function aggregate3Value(Call3Value[] calldata calls) external payable returns (Result[] memory returnData);\\n\\n function blockAndAggregate(Call[] calldata calls)\\n external\\n payable\\n returns (uint256 blockNumber, bytes32 blockHash, Result[] memory returnData);\\n\\n function getBasefee() external view returns (uint256 basefee);\\n\\n function getBlockHash(uint256 blockNumber) external view returns (bytes32 blockHash);\\n\\n function getBlockNumber() external view returns (uint256 blockNumber);\\n\\n function getChainId() external view returns (uint256 chainid);\\n\\n function getCurrentBlockCoinbase() external view returns (address coinbase);\\n\\n function getCurrentBlockDifficulty() external view returns (uint256 difficulty);\\n\\n function getCurrentBlockGasLimit() external view returns (uint256 gaslimit);\\n\\n function getCurrentBlockTimestamp() external view returns (uint256 timestamp);\\n\\n function getEthBalance(address addr) external view returns (uint256 balance);\\n\\n function getLastBlockHash() external view returns (bytes32 blockHash);\\n\\n function tryAggregate(bool requireSuccess, Call[] calldata calls)\\n external\\n payable\\n returns (Result[] memory returnData);\\n\\n function tryBlockAndAggregate(bool requireSuccess, Call[] calldata calls)\\n external\\n payable\\n returns (uint256 blockNumber, bytes32 blockHash, Result[] memory returnData);\\n}\\n\",\"keccak256\":\"0x7aac1389150499a922d1f9ef5749c908cef127cb2075b92fa17e9cb611263d0a\",\"license\":\"MIT\"},\"lib/forge-std/src/safeconsole.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity >=0.6.2 <0.9.0;\\n\\n/// @author philogy \\n/// @dev Code generated automatically by script.\\nlibrary safeconsole {\\n uint256 constant CONSOLE_ADDR = 0x000000000000000000000000000000000000000000636F6e736F6c652e6c6f67;\\n\\n // Credit to [0age](https://twitter.com/z0age/status/1654922202930888704) and [0xdapper](https://github.com/foundry-rs/forge-std/pull/374)\\n // for the view-to-pure log trick.\\n function _sendLogPayload(uint256 offset, uint256 size) private pure {\\n function(uint256, uint256) internal view fnIn = _sendLogPayloadView;\\n function(uint256, uint256) internal pure pureSendLogPayload;\\n /// @solidity memory-safe-assembly\\n assembly {\\n pureSendLogPayload := fnIn\\n }\\n pureSendLogPayload(offset, size);\\n }\\n\\n function _sendLogPayloadView(uint256 offset, uint256 size) private view {\\n /// @solidity memory-safe-assembly\\n assembly {\\n pop(staticcall(gas(), CONSOLE_ADDR, offset, size, 0x0, 0x0))\\n }\\n }\\n\\n function _memcopy(uint256 fromOffset, uint256 toOffset, uint256 length) private pure {\\n function(uint256, uint256, uint256) internal view fnIn = _memcopyView;\\n function(uint256, uint256, uint256) internal pure pureMemcopy;\\n /// @solidity memory-safe-assembly\\n assembly {\\n pureMemcopy := fnIn\\n }\\n pureMemcopy(fromOffset, toOffset, length);\\n }\\n\\n function _memcopyView(uint256 fromOffset, uint256 toOffset, uint256 length) private view {\\n /// @solidity memory-safe-assembly\\n assembly {\\n pop(staticcall(gas(), 0x4, fromOffset, length, toOffset, length))\\n }\\n }\\n\\n function logMemory(uint256 offset, uint256 length) internal pure {\\n if (offset >= 0x60) {\\n // Sufficient memory before slice to prepare call header.\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(sub(offset, 0x60))\\n m1 := mload(sub(offset, 0x40))\\n m2 := mload(sub(offset, 0x20))\\n // Selector of `log(bytes)`.\\n mstore(sub(offset, 0x60), 0x0be77f56)\\n mstore(sub(offset, 0x40), 0x20)\\n mstore(sub(offset, 0x20), length)\\n }\\n _sendLogPayload(offset - 0x44, length + 0x44);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(sub(offset, 0x60), m0)\\n mstore(sub(offset, 0x40), m1)\\n mstore(sub(offset, 0x20), m2)\\n }\\n } else {\\n // Insufficient space, so copy slice forward, add header and reverse.\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n uint256 endOffset = offset + length;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(add(endOffset, 0x00))\\n m1 := mload(add(endOffset, 0x20))\\n m2 := mload(add(endOffset, 0x40))\\n }\\n _memcopy(offset, offset + 0x60, length);\\n /// @solidity memory-safe-assembly\\n assembly {\\n // Selector of `log(bytes)`.\\n mstore(add(offset, 0x00), 0x0be77f56)\\n mstore(add(offset, 0x20), 0x20)\\n mstore(add(offset, 0x40), length)\\n }\\n _sendLogPayload(offset + 0x1c, length + 0x44);\\n _memcopy(offset + 0x60, offset, length);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(add(endOffset, 0x00), m0)\\n mstore(add(endOffset, 0x20), m1)\\n mstore(add(endOffset, 0x40), m2)\\n }\\n }\\n }\\n\\n function log(address p0) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n // Selector of `log(address)`.\\n mstore(0x00, 0x2c2ecbc2)\\n mstore(0x20, p0)\\n }\\n _sendLogPayload(0x1c, 0x24);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n }\\n }\\n\\n function log(bool p0) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n // Selector of `log(bool)`.\\n mstore(0x00, 0x32458eed)\\n mstore(0x20, p0)\\n }\\n _sendLogPayload(0x1c, 0x24);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n }\\n }\\n\\n function log(uint256 p0) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n // Selector of `log(uint256)`.\\n mstore(0x00, 0xf82c50f1)\\n mstore(0x20, p0)\\n }\\n _sendLogPayload(0x1c, 0x24);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n }\\n }\\n\\n function log(bytes32 p0) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n // Selector of `log(string)`.\\n mstore(0x00, 0x41304fac)\\n mstore(0x20, 0x20)\\n writeString(0x40, p0)\\n }\\n _sendLogPayload(0x1c, 0x64);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n }\\n }\\n\\n function log(address p0, address p1) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n // Selector of `log(address,address)`.\\n mstore(0x00, 0xdaf0d4aa)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n }\\n _sendLogPayload(0x1c, 0x44);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n }\\n }\\n\\n function log(address p0, bool p1) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n // Selector of `log(address,bool)`.\\n mstore(0x00, 0x75b605d3)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n }\\n _sendLogPayload(0x1c, 0x44);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n }\\n }\\n\\n function log(address p0, uint256 p1) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n // Selector of `log(address,uint256)`.\\n mstore(0x00, 0x8309e8a8)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n }\\n _sendLogPayload(0x1c, 0x44);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n }\\n }\\n\\n function log(address p0, bytes32 p1) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(address,string)`.\\n mstore(0x00, 0x759f86bb)\\n mstore(0x20, p0)\\n mstore(0x40, 0x40)\\n writeString(0x60, p1)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(bool p0, address p1) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n // Selector of `log(bool,address)`.\\n mstore(0x00, 0x853c4849)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n }\\n _sendLogPayload(0x1c, 0x44);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n }\\n }\\n\\n function log(bool p0, bool p1) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n // Selector of `log(bool,bool)`.\\n mstore(0x00, 0x2a110e83)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n }\\n _sendLogPayload(0x1c, 0x44);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n }\\n }\\n\\n function log(bool p0, uint256 p1) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n // Selector of `log(bool,uint256)`.\\n mstore(0x00, 0x399174d3)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n }\\n _sendLogPayload(0x1c, 0x44);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n }\\n }\\n\\n function log(bool p0, bytes32 p1) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(bool,string)`.\\n mstore(0x00, 0x8feac525)\\n mstore(0x20, p0)\\n mstore(0x40, 0x40)\\n writeString(0x60, p1)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(uint256 p0, address p1) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n // Selector of `log(uint256,address)`.\\n mstore(0x00, 0x69276c86)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n }\\n _sendLogPayload(0x1c, 0x44);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n }\\n }\\n\\n function log(uint256 p0, bool p1) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n // Selector of `log(uint256,bool)`.\\n mstore(0x00, 0x1c9d7eb3)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n }\\n _sendLogPayload(0x1c, 0x44);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n }\\n }\\n\\n function log(uint256 p0, uint256 p1) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n // Selector of `log(uint256,uint256)`.\\n mstore(0x00, 0xf666715a)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n }\\n _sendLogPayload(0x1c, 0x44);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n }\\n }\\n\\n function log(uint256 p0, bytes32 p1) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(uint256,string)`.\\n mstore(0x00, 0x643fd0df)\\n mstore(0x20, p0)\\n mstore(0x40, 0x40)\\n writeString(0x60, p1)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(bytes32 p0, address p1) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(string,address)`.\\n mstore(0x00, 0x319af333)\\n mstore(0x20, 0x40)\\n mstore(0x40, p1)\\n writeString(0x60, p0)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(bytes32 p0, bool p1) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(string,bool)`.\\n mstore(0x00, 0xc3b55635)\\n mstore(0x20, 0x40)\\n mstore(0x40, p1)\\n writeString(0x60, p0)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(bytes32 p0, uint256 p1) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(string,uint256)`.\\n mstore(0x00, 0xb60e72cc)\\n mstore(0x20, 0x40)\\n mstore(0x40, p1)\\n writeString(0x60, p0)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(bytes32 p0, bytes32 p1) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(string,string)`.\\n mstore(0x00, 0x4b5c4277)\\n mstore(0x20, 0x40)\\n mstore(0x40, 0x80)\\n writeString(0x60, p0)\\n writeString(0xa0, p1)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(address p0, address p1, address p2) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n // Selector of `log(address,address,address)`.\\n mstore(0x00, 0x018c84c2)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n }\\n _sendLogPayload(0x1c, 0x64);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n }\\n }\\n\\n function log(address p0, address p1, bool p2) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n // Selector of `log(address,address,bool)`.\\n mstore(0x00, 0xf2a66286)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n }\\n _sendLogPayload(0x1c, 0x64);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n }\\n }\\n\\n function log(address p0, address p1, uint256 p2) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n // Selector of `log(address,address,uint256)`.\\n mstore(0x00, 0x17fe6185)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n }\\n _sendLogPayload(0x1c, 0x64);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n }\\n }\\n\\n function log(address p0, address p1, bytes32 p2) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n // Selector of `log(address,address,string)`.\\n mstore(0x00, 0x007150be)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, 0x60)\\n writeString(0x80, p2)\\n }\\n _sendLogPayload(0x1c, 0xa4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n }\\n }\\n\\n function log(address p0, bool p1, address p2) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n // Selector of `log(address,bool,address)`.\\n mstore(0x00, 0xf11699ed)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n }\\n _sendLogPayload(0x1c, 0x64);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n }\\n }\\n\\n function log(address p0, bool p1, bool p2) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n // Selector of `log(address,bool,bool)`.\\n mstore(0x00, 0xeb830c92)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n }\\n _sendLogPayload(0x1c, 0x64);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n }\\n }\\n\\n function log(address p0, bool p1, uint256 p2) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n // Selector of `log(address,bool,uint256)`.\\n mstore(0x00, 0x9c4f99fb)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n }\\n _sendLogPayload(0x1c, 0x64);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n }\\n }\\n\\n function log(address p0, bool p1, bytes32 p2) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n // Selector of `log(address,bool,string)`.\\n mstore(0x00, 0x212255cc)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, 0x60)\\n writeString(0x80, p2)\\n }\\n _sendLogPayload(0x1c, 0xa4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n }\\n }\\n\\n function log(address p0, uint256 p1, address p2) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n // Selector of `log(address,uint256,address)`.\\n mstore(0x00, 0x7bc0d848)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n }\\n _sendLogPayload(0x1c, 0x64);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n }\\n }\\n\\n function log(address p0, uint256 p1, bool p2) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n // Selector of `log(address,uint256,bool)`.\\n mstore(0x00, 0x678209a8)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n }\\n _sendLogPayload(0x1c, 0x64);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n }\\n }\\n\\n function log(address p0, uint256 p1, uint256 p2) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n // Selector of `log(address,uint256,uint256)`.\\n mstore(0x00, 0xb69bcaf6)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n }\\n _sendLogPayload(0x1c, 0x64);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n }\\n }\\n\\n function log(address p0, uint256 p1, bytes32 p2) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n // Selector of `log(address,uint256,string)`.\\n mstore(0x00, 0xa1f2e8aa)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, 0x60)\\n writeString(0x80, p2)\\n }\\n _sendLogPayload(0x1c, 0xa4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n }\\n }\\n\\n function log(address p0, bytes32 p1, address p2) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n // Selector of `log(address,string,address)`.\\n mstore(0x00, 0xf08744e8)\\n mstore(0x20, p0)\\n mstore(0x40, 0x60)\\n mstore(0x60, p2)\\n writeString(0x80, p1)\\n }\\n _sendLogPayload(0x1c, 0xa4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n }\\n }\\n\\n function log(address p0, bytes32 p1, bool p2) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n // Selector of `log(address,string,bool)`.\\n mstore(0x00, 0xcf020fb1)\\n mstore(0x20, p0)\\n mstore(0x40, 0x60)\\n mstore(0x60, p2)\\n writeString(0x80, p1)\\n }\\n _sendLogPayload(0x1c, 0xa4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n }\\n }\\n\\n function log(address p0, bytes32 p1, uint256 p2) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n // Selector of `log(address,string,uint256)`.\\n mstore(0x00, 0x67dd6ff1)\\n mstore(0x20, p0)\\n mstore(0x40, 0x60)\\n mstore(0x60, p2)\\n writeString(0x80, p1)\\n }\\n _sendLogPayload(0x1c, 0xa4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n }\\n }\\n\\n function log(address p0, bytes32 p1, bytes32 p2) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n // Selector of `log(address,string,string)`.\\n mstore(0x00, 0xfb772265)\\n mstore(0x20, p0)\\n mstore(0x40, 0x60)\\n mstore(0x60, 0xa0)\\n writeString(0x80, p1)\\n writeString(0xc0, p2)\\n }\\n _sendLogPayload(0x1c, 0xe4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n }\\n }\\n\\n function log(bool p0, address p1, address p2) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n // Selector of `log(bool,address,address)`.\\n mstore(0x00, 0xd2763667)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n }\\n _sendLogPayload(0x1c, 0x64);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n }\\n }\\n\\n function log(bool p0, address p1, bool p2) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n // Selector of `log(bool,address,bool)`.\\n mstore(0x00, 0x18c9c746)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n }\\n _sendLogPayload(0x1c, 0x64);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n }\\n }\\n\\n function log(bool p0, address p1, uint256 p2) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n // Selector of `log(bool,address,uint256)`.\\n mstore(0x00, 0x5f7b9afb)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n }\\n _sendLogPayload(0x1c, 0x64);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n }\\n }\\n\\n function log(bool p0, address p1, bytes32 p2) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n // Selector of `log(bool,address,string)`.\\n mstore(0x00, 0xde9a9270)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, 0x60)\\n writeString(0x80, p2)\\n }\\n _sendLogPayload(0x1c, 0xa4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n }\\n }\\n\\n function log(bool p0, bool p1, address p2) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n // Selector of `log(bool,bool,address)`.\\n mstore(0x00, 0x1078f68d)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n }\\n _sendLogPayload(0x1c, 0x64);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n }\\n }\\n\\n function log(bool p0, bool p1, bool p2) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n // Selector of `log(bool,bool,bool)`.\\n mstore(0x00, 0x50709698)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n }\\n _sendLogPayload(0x1c, 0x64);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n }\\n }\\n\\n function log(bool p0, bool p1, uint256 p2) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n // Selector of `log(bool,bool,uint256)`.\\n mstore(0x00, 0x12f21602)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n }\\n _sendLogPayload(0x1c, 0x64);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n }\\n }\\n\\n function log(bool p0, bool p1, bytes32 p2) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n // Selector of `log(bool,bool,string)`.\\n mstore(0x00, 0x2555fa46)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, 0x60)\\n writeString(0x80, p2)\\n }\\n _sendLogPayload(0x1c, 0xa4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n }\\n }\\n\\n function log(bool p0, uint256 p1, address p2) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n // Selector of `log(bool,uint256,address)`.\\n mstore(0x00, 0x088ef9d2)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n }\\n _sendLogPayload(0x1c, 0x64);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n }\\n }\\n\\n function log(bool p0, uint256 p1, bool p2) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n // Selector of `log(bool,uint256,bool)`.\\n mstore(0x00, 0xe8defba9)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n }\\n _sendLogPayload(0x1c, 0x64);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n }\\n }\\n\\n function log(bool p0, uint256 p1, uint256 p2) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n // Selector of `log(bool,uint256,uint256)`.\\n mstore(0x00, 0x37103367)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n }\\n _sendLogPayload(0x1c, 0x64);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n }\\n }\\n\\n function log(bool p0, uint256 p1, bytes32 p2) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n // Selector of `log(bool,uint256,string)`.\\n mstore(0x00, 0xc3fc3970)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, 0x60)\\n writeString(0x80, p2)\\n }\\n _sendLogPayload(0x1c, 0xa4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n }\\n }\\n\\n function log(bool p0, bytes32 p1, address p2) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n // Selector of `log(bool,string,address)`.\\n mstore(0x00, 0x9591b953)\\n mstore(0x20, p0)\\n mstore(0x40, 0x60)\\n mstore(0x60, p2)\\n writeString(0x80, p1)\\n }\\n _sendLogPayload(0x1c, 0xa4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n }\\n }\\n\\n function log(bool p0, bytes32 p1, bool p2) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n // Selector of `log(bool,string,bool)`.\\n mstore(0x00, 0xdbb4c247)\\n mstore(0x20, p0)\\n mstore(0x40, 0x60)\\n mstore(0x60, p2)\\n writeString(0x80, p1)\\n }\\n _sendLogPayload(0x1c, 0xa4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n }\\n }\\n\\n function log(bool p0, bytes32 p1, uint256 p2) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n // Selector of `log(bool,string,uint256)`.\\n mstore(0x00, 0x1093ee11)\\n mstore(0x20, p0)\\n mstore(0x40, 0x60)\\n mstore(0x60, p2)\\n writeString(0x80, p1)\\n }\\n _sendLogPayload(0x1c, 0xa4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n }\\n }\\n\\n function log(bool p0, bytes32 p1, bytes32 p2) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n // Selector of `log(bool,string,string)`.\\n mstore(0x00, 0xb076847f)\\n mstore(0x20, p0)\\n mstore(0x40, 0x60)\\n mstore(0x60, 0xa0)\\n writeString(0x80, p1)\\n writeString(0xc0, p2)\\n }\\n _sendLogPayload(0x1c, 0xe4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n }\\n }\\n\\n function log(uint256 p0, address p1, address p2) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n // Selector of `log(uint256,address,address)`.\\n mstore(0x00, 0xbcfd9be0)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n }\\n _sendLogPayload(0x1c, 0x64);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n }\\n }\\n\\n function log(uint256 p0, address p1, bool p2) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n // Selector of `log(uint256,address,bool)`.\\n mstore(0x00, 0x9b6ec042)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n }\\n _sendLogPayload(0x1c, 0x64);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n }\\n }\\n\\n function log(uint256 p0, address p1, uint256 p2) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n // Selector of `log(uint256,address,uint256)`.\\n mstore(0x00, 0x5a9b5ed5)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n }\\n _sendLogPayload(0x1c, 0x64);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n }\\n }\\n\\n function log(uint256 p0, address p1, bytes32 p2) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n // Selector of `log(uint256,address,string)`.\\n mstore(0x00, 0x63cb41f9)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, 0x60)\\n writeString(0x80, p2)\\n }\\n _sendLogPayload(0x1c, 0xa4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n }\\n }\\n\\n function log(uint256 p0, bool p1, address p2) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n // Selector of `log(uint256,bool,address)`.\\n mstore(0x00, 0x35085f7b)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n }\\n _sendLogPayload(0x1c, 0x64);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n }\\n }\\n\\n function log(uint256 p0, bool p1, bool p2) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n // Selector of `log(uint256,bool,bool)`.\\n mstore(0x00, 0x20718650)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n }\\n _sendLogPayload(0x1c, 0x64);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n }\\n }\\n\\n function log(uint256 p0, bool p1, uint256 p2) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n // Selector of `log(uint256,bool,uint256)`.\\n mstore(0x00, 0x20098014)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n }\\n _sendLogPayload(0x1c, 0x64);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n }\\n }\\n\\n function log(uint256 p0, bool p1, bytes32 p2) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n // Selector of `log(uint256,bool,string)`.\\n mstore(0x00, 0x85775021)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, 0x60)\\n writeString(0x80, p2)\\n }\\n _sendLogPayload(0x1c, 0xa4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n }\\n }\\n\\n function log(uint256 p0, uint256 p1, address p2) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n // Selector of `log(uint256,uint256,address)`.\\n mstore(0x00, 0x5c96b331)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n }\\n _sendLogPayload(0x1c, 0x64);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n }\\n }\\n\\n function log(uint256 p0, uint256 p1, bool p2) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n // Selector of `log(uint256,uint256,bool)`.\\n mstore(0x00, 0x4766da72)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n }\\n _sendLogPayload(0x1c, 0x64);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n }\\n }\\n\\n function log(uint256 p0, uint256 p1, uint256 p2) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n // Selector of `log(uint256,uint256,uint256)`.\\n mstore(0x00, 0xd1ed7a3c)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n }\\n _sendLogPayload(0x1c, 0x64);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n }\\n }\\n\\n function log(uint256 p0, uint256 p1, bytes32 p2) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n // Selector of `log(uint256,uint256,string)`.\\n mstore(0x00, 0x71d04af2)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, 0x60)\\n writeString(0x80, p2)\\n }\\n _sendLogPayload(0x1c, 0xa4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n }\\n }\\n\\n function log(uint256 p0, bytes32 p1, address p2) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n // Selector of `log(uint256,string,address)`.\\n mstore(0x00, 0x7afac959)\\n mstore(0x20, p0)\\n mstore(0x40, 0x60)\\n mstore(0x60, p2)\\n writeString(0x80, p1)\\n }\\n _sendLogPayload(0x1c, 0xa4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n }\\n }\\n\\n function log(uint256 p0, bytes32 p1, bool p2) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n // Selector of `log(uint256,string,bool)`.\\n mstore(0x00, 0x4ceda75a)\\n mstore(0x20, p0)\\n mstore(0x40, 0x60)\\n mstore(0x60, p2)\\n writeString(0x80, p1)\\n }\\n _sendLogPayload(0x1c, 0xa4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n }\\n }\\n\\n function log(uint256 p0, bytes32 p1, uint256 p2) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n // Selector of `log(uint256,string,uint256)`.\\n mstore(0x00, 0x37aa7d4c)\\n mstore(0x20, p0)\\n mstore(0x40, 0x60)\\n mstore(0x60, p2)\\n writeString(0x80, p1)\\n }\\n _sendLogPayload(0x1c, 0xa4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n }\\n }\\n\\n function log(uint256 p0, bytes32 p1, bytes32 p2) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n // Selector of `log(uint256,string,string)`.\\n mstore(0x00, 0xb115611f)\\n mstore(0x20, p0)\\n mstore(0x40, 0x60)\\n mstore(0x60, 0xa0)\\n writeString(0x80, p1)\\n writeString(0xc0, p2)\\n }\\n _sendLogPayload(0x1c, 0xe4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n }\\n }\\n\\n function log(bytes32 p0, address p1, address p2) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n // Selector of `log(string,address,address)`.\\n mstore(0x00, 0xfcec75e0)\\n mstore(0x20, 0x60)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n writeString(0x80, p0)\\n }\\n _sendLogPayload(0x1c, 0xa4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n }\\n }\\n\\n function log(bytes32 p0, address p1, bool p2) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n // Selector of `log(string,address,bool)`.\\n mstore(0x00, 0xc91d5ed4)\\n mstore(0x20, 0x60)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n writeString(0x80, p0)\\n }\\n _sendLogPayload(0x1c, 0xa4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n }\\n }\\n\\n function log(bytes32 p0, address p1, uint256 p2) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n // Selector of `log(string,address,uint256)`.\\n mstore(0x00, 0x0d26b925)\\n mstore(0x20, 0x60)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n writeString(0x80, p0)\\n }\\n _sendLogPayload(0x1c, 0xa4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n }\\n }\\n\\n function log(bytes32 p0, address p1, bytes32 p2) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n // Selector of `log(string,address,string)`.\\n mstore(0x00, 0xe0e9ad4f)\\n mstore(0x20, 0x60)\\n mstore(0x40, p1)\\n mstore(0x60, 0xa0)\\n writeString(0x80, p0)\\n writeString(0xc0, p2)\\n }\\n _sendLogPayload(0x1c, 0xe4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n }\\n }\\n\\n function log(bytes32 p0, bool p1, address p2) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n // Selector of `log(string,bool,address)`.\\n mstore(0x00, 0x932bbb38)\\n mstore(0x20, 0x60)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n writeString(0x80, p0)\\n }\\n _sendLogPayload(0x1c, 0xa4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n }\\n }\\n\\n function log(bytes32 p0, bool p1, bool p2) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n // Selector of `log(string,bool,bool)`.\\n mstore(0x00, 0x850b7ad6)\\n mstore(0x20, 0x60)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n writeString(0x80, p0)\\n }\\n _sendLogPayload(0x1c, 0xa4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n }\\n }\\n\\n function log(bytes32 p0, bool p1, uint256 p2) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n // Selector of `log(string,bool,uint256)`.\\n mstore(0x00, 0xc95958d6)\\n mstore(0x20, 0x60)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n writeString(0x80, p0)\\n }\\n _sendLogPayload(0x1c, 0xa4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n }\\n }\\n\\n function log(bytes32 p0, bool p1, bytes32 p2) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n // Selector of `log(string,bool,string)`.\\n mstore(0x00, 0xe298f47d)\\n mstore(0x20, 0x60)\\n mstore(0x40, p1)\\n mstore(0x60, 0xa0)\\n writeString(0x80, p0)\\n writeString(0xc0, p2)\\n }\\n _sendLogPayload(0x1c, 0xe4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n }\\n }\\n\\n function log(bytes32 p0, uint256 p1, address p2) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n // Selector of `log(string,uint256,address)`.\\n mstore(0x00, 0x1c7ec448)\\n mstore(0x20, 0x60)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n writeString(0x80, p0)\\n }\\n _sendLogPayload(0x1c, 0xa4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n }\\n }\\n\\n function log(bytes32 p0, uint256 p1, bool p2) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n // Selector of `log(string,uint256,bool)`.\\n mstore(0x00, 0xca7733b1)\\n mstore(0x20, 0x60)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n writeString(0x80, p0)\\n }\\n _sendLogPayload(0x1c, 0xa4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n }\\n }\\n\\n function log(bytes32 p0, uint256 p1, uint256 p2) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n // Selector of `log(string,uint256,uint256)`.\\n mstore(0x00, 0xca47c4eb)\\n mstore(0x20, 0x60)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n writeString(0x80, p0)\\n }\\n _sendLogPayload(0x1c, 0xa4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n }\\n }\\n\\n function log(bytes32 p0, uint256 p1, bytes32 p2) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n // Selector of `log(string,uint256,string)`.\\n mstore(0x00, 0x5970e089)\\n mstore(0x20, 0x60)\\n mstore(0x40, p1)\\n mstore(0x60, 0xa0)\\n writeString(0x80, p0)\\n writeString(0xc0, p2)\\n }\\n _sendLogPayload(0x1c, 0xe4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n }\\n }\\n\\n function log(bytes32 p0, bytes32 p1, address p2) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n // Selector of `log(string,string,address)`.\\n mstore(0x00, 0x95ed0195)\\n mstore(0x20, 0x60)\\n mstore(0x40, 0xa0)\\n mstore(0x60, p2)\\n writeString(0x80, p0)\\n writeString(0xc0, p1)\\n }\\n _sendLogPayload(0x1c, 0xe4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n }\\n }\\n\\n function log(bytes32 p0, bytes32 p1, bool p2) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n // Selector of `log(string,string,bool)`.\\n mstore(0x00, 0xb0e0f9b5)\\n mstore(0x20, 0x60)\\n mstore(0x40, 0xa0)\\n mstore(0x60, p2)\\n writeString(0x80, p0)\\n writeString(0xc0, p1)\\n }\\n _sendLogPayload(0x1c, 0xe4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n }\\n }\\n\\n function log(bytes32 p0, bytes32 p1, uint256 p2) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n // Selector of `log(string,string,uint256)`.\\n mstore(0x00, 0x5821efa1)\\n mstore(0x20, 0x60)\\n mstore(0x40, 0xa0)\\n mstore(0x60, p2)\\n writeString(0x80, p0)\\n writeString(0xc0, p1)\\n }\\n _sendLogPayload(0x1c, 0xe4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n }\\n }\\n\\n function log(bytes32 p0, bytes32 p1, bytes32 p2) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n bytes32 m9;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n m9 := mload(0x120)\\n // Selector of `log(string,string,string)`.\\n mstore(0x00, 0x2ced7cef)\\n mstore(0x20, 0x60)\\n mstore(0x40, 0xa0)\\n mstore(0x60, 0xe0)\\n writeString(0x80, p0)\\n writeString(0xc0, p1)\\n writeString(0x100, p2)\\n }\\n _sendLogPayload(0x1c, 0x124);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n mstore(0x120, m9)\\n }\\n }\\n\\n function log(address p0, address p1, address p2, address p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(address,address,address,address)`.\\n mstore(0x00, 0x665bf134)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(address p0, address p1, address p2, bool p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(address,address,address,bool)`.\\n mstore(0x00, 0x0e378994)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(address p0, address p1, address p2, uint256 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(address,address,address,uint256)`.\\n mstore(0x00, 0x94250d77)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(address p0, address p1, address p2, bytes32 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(address,address,address,string)`.\\n mstore(0x00, 0xf808da20)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, 0x80)\\n writeString(0xa0, p3)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(address p0, address p1, bool p2, address p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(address,address,bool,address)`.\\n mstore(0x00, 0x9f1bc36e)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(address p0, address p1, bool p2, bool p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(address,address,bool,bool)`.\\n mstore(0x00, 0x2cd4134a)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(address p0, address p1, bool p2, uint256 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(address,address,bool,uint256)`.\\n mstore(0x00, 0x3971e78c)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(address p0, address p1, bool p2, bytes32 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(address,address,bool,string)`.\\n mstore(0x00, 0xaa6540c8)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, 0x80)\\n writeString(0xa0, p3)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(address p0, address p1, uint256 p2, address p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(address,address,uint256,address)`.\\n mstore(0x00, 0x8da6def5)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(address p0, address p1, uint256 p2, bool p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(address,address,uint256,bool)`.\\n mstore(0x00, 0x9b4254e2)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(address p0, address p1, uint256 p2, uint256 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(address,address,uint256,uint256)`.\\n mstore(0x00, 0xbe553481)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(address p0, address p1, uint256 p2, bytes32 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(address,address,uint256,string)`.\\n mstore(0x00, 0xfdb4f990)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, 0x80)\\n writeString(0xa0, p3)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(address p0, address p1, bytes32 p2, address p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(address,address,string,address)`.\\n mstore(0x00, 0x8f736d16)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, 0x80)\\n mstore(0x80, p3)\\n writeString(0xa0, p2)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(address p0, address p1, bytes32 p2, bool p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(address,address,string,bool)`.\\n mstore(0x00, 0x6f1a594e)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, 0x80)\\n mstore(0x80, p3)\\n writeString(0xa0, p2)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(address p0, address p1, bytes32 p2, uint256 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(address,address,string,uint256)`.\\n mstore(0x00, 0xef1cefe7)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, 0x80)\\n mstore(0x80, p3)\\n writeString(0xa0, p2)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(address p0, address p1, bytes32 p2, bytes32 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n // Selector of `log(address,address,string,string)`.\\n mstore(0x00, 0x21bdaf25)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, 0x80)\\n mstore(0x80, 0xc0)\\n writeString(0xa0, p2)\\n writeString(0xe0, p3)\\n }\\n _sendLogPayload(0x1c, 0x104);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n }\\n }\\n\\n function log(address p0, bool p1, address p2, address p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(address,bool,address,address)`.\\n mstore(0x00, 0x660375dd)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(address p0, bool p1, address p2, bool p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(address,bool,address,bool)`.\\n mstore(0x00, 0xa6f50b0f)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(address p0, bool p1, address p2, uint256 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(address,bool,address,uint256)`.\\n mstore(0x00, 0xa75c59de)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(address p0, bool p1, address p2, bytes32 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(address,bool,address,string)`.\\n mstore(0x00, 0x2dd778e6)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, 0x80)\\n writeString(0xa0, p3)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(address p0, bool p1, bool p2, address p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(address,bool,bool,address)`.\\n mstore(0x00, 0xcf394485)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(address p0, bool p1, bool p2, bool p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(address,bool,bool,bool)`.\\n mstore(0x00, 0xcac43479)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(address p0, bool p1, bool p2, uint256 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(address,bool,bool,uint256)`.\\n mstore(0x00, 0x8c4e5de6)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(address p0, bool p1, bool p2, bytes32 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(address,bool,bool,string)`.\\n mstore(0x00, 0xdfc4a2e8)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, 0x80)\\n writeString(0xa0, p3)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(address p0, bool p1, uint256 p2, address p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(address,bool,uint256,address)`.\\n mstore(0x00, 0xccf790a1)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(address p0, bool p1, uint256 p2, bool p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(address,bool,uint256,bool)`.\\n mstore(0x00, 0xc4643e20)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(address p0, bool p1, uint256 p2, uint256 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(address,bool,uint256,uint256)`.\\n mstore(0x00, 0x386ff5f4)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(address p0, bool p1, uint256 p2, bytes32 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(address,bool,uint256,string)`.\\n mstore(0x00, 0x0aa6cfad)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, 0x80)\\n writeString(0xa0, p3)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(address p0, bool p1, bytes32 p2, address p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(address,bool,string,address)`.\\n mstore(0x00, 0x19fd4956)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, 0x80)\\n mstore(0x80, p3)\\n writeString(0xa0, p2)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(address p0, bool p1, bytes32 p2, bool p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(address,bool,string,bool)`.\\n mstore(0x00, 0x50ad461d)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, 0x80)\\n mstore(0x80, p3)\\n writeString(0xa0, p2)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(address p0, bool p1, bytes32 p2, uint256 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(address,bool,string,uint256)`.\\n mstore(0x00, 0x80e6a20b)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, 0x80)\\n mstore(0x80, p3)\\n writeString(0xa0, p2)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(address p0, bool p1, bytes32 p2, bytes32 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n // Selector of `log(address,bool,string,string)`.\\n mstore(0x00, 0x475c5c33)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, 0x80)\\n mstore(0x80, 0xc0)\\n writeString(0xa0, p2)\\n writeString(0xe0, p3)\\n }\\n _sendLogPayload(0x1c, 0x104);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n }\\n }\\n\\n function log(address p0, uint256 p1, address p2, address p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(address,uint256,address,address)`.\\n mstore(0x00, 0x478d1c62)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(address p0, uint256 p1, address p2, bool p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(address,uint256,address,bool)`.\\n mstore(0x00, 0xa1bcc9b3)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(address p0, uint256 p1, address p2, uint256 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(address,uint256,address,uint256)`.\\n mstore(0x00, 0x100f650e)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(address p0, uint256 p1, address p2, bytes32 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(address,uint256,address,string)`.\\n mstore(0x00, 0x1da986ea)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, 0x80)\\n writeString(0xa0, p3)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(address p0, uint256 p1, bool p2, address p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(address,uint256,bool,address)`.\\n mstore(0x00, 0xa31bfdcc)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(address p0, uint256 p1, bool p2, bool p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(address,uint256,bool,bool)`.\\n mstore(0x00, 0x3bf5e537)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(address p0, uint256 p1, bool p2, uint256 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(address,uint256,bool,uint256)`.\\n mstore(0x00, 0x22f6b999)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(address p0, uint256 p1, bool p2, bytes32 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(address,uint256,bool,string)`.\\n mstore(0x00, 0xc5ad85f9)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, 0x80)\\n writeString(0xa0, p3)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(address p0, uint256 p1, uint256 p2, address p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(address,uint256,uint256,address)`.\\n mstore(0x00, 0x20e3984d)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(address p0, uint256 p1, uint256 p2, bool p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(address,uint256,uint256,bool)`.\\n mstore(0x00, 0x66f1bc67)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(address p0, uint256 p1, uint256 p2, uint256 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(address,uint256,uint256,uint256)`.\\n mstore(0x00, 0x34f0e636)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(address p0, uint256 p1, uint256 p2, bytes32 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(address,uint256,uint256,string)`.\\n mstore(0x00, 0x4a28c017)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, 0x80)\\n writeString(0xa0, p3)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(address p0, uint256 p1, bytes32 p2, address p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(address,uint256,string,address)`.\\n mstore(0x00, 0x5c430d47)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, 0x80)\\n mstore(0x80, p3)\\n writeString(0xa0, p2)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(address p0, uint256 p1, bytes32 p2, bool p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(address,uint256,string,bool)`.\\n mstore(0x00, 0xcf18105c)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, 0x80)\\n mstore(0x80, p3)\\n writeString(0xa0, p2)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(address p0, uint256 p1, bytes32 p2, uint256 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(address,uint256,string,uint256)`.\\n mstore(0x00, 0xbf01f891)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, 0x80)\\n mstore(0x80, p3)\\n writeString(0xa0, p2)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(address p0, uint256 p1, bytes32 p2, bytes32 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n // Selector of `log(address,uint256,string,string)`.\\n mstore(0x00, 0x88a8c406)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, 0x80)\\n mstore(0x80, 0xc0)\\n writeString(0xa0, p2)\\n writeString(0xe0, p3)\\n }\\n _sendLogPayload(0x1c, 0x104);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n }\\n }\\n\\n function log(address p0, bytes32 p1, address p2, address p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(address,string,address,address)`.\\n mstore(0x00, 0x0d36fa20)\\n mstore(0x20, p0)\\n mstore(0x40, 0x80)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n writeString(0xa0, p1)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(address p0, bytes32 p1, address p2, bool p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(address,string,address,bool)`.\\n mstore(0x00, 0x0df12b76)\\n mstore(0x20, p0)\\n mstore(0x40, 0x80)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n writeString(0xa0, p1)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(address p0, bytes32 p1, address p2, uint256 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(address,string,address,uint256)`.\\n mstore(0x00, 0x457fe3cf)\\n mstore(0x20, p0)\\n mstore(0x40, 0x80)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n writeString(0xa0, p1)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(address p0, bytes32 p1, address p2, bytes32 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n // Selector of `log(address,string,address,string)`.\\n mstore(0x00, 0xf7e36245)\\n mstore(0x20, p0)\\n mstore(0x40, 0x80)\\n mstore(0x60, p2)\\n mstore(0x80, 0xc0)\\n writeString(0xa0, p1)\\n writeString(0xe0, p3)\\n }\\n _sendLogPayload(0x1c, 0x104);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n }\\n }\\n\\n function log(address p0, bytes32 p1, bool p2, address p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(address,string,bool,address)`.\\n mstore(0x00, 0x205871c2)\\n mstore(0x20, p0)\\n mstore(0x40, 0x80)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n writeString(0xa0, p1)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(address p0, bytes32 p1, bool p2, bool p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(address,string,bool,bool)`.\\n mstore(0x00, 0x5f1d5c9f)\\n mstore(0x20, p0)\\n mstore(0x40, 0x80)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n writeString(0xa0, p1)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(address p0, bytes32 p1, bool p2, uint256 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(address,string,bool,uint256)`.\\n mstore(0x00, 0x515e38b6)\\n mstore(0x20, p0)\\n mstore(0x40, 0x80)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n writeString(0xa0, p1)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(address p0, bytes32 p1, bool p2, bytes32 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n // Selector of `log(address,string,bool,string)`.\\n mstore(0x00, 0xbc0b61fe)\\n mstore(0x20, p0)\\n mstore(0x40, 0x80)\\n mstore(0x60, p2)\\n mstore(0x80, 0xc0)\\n writeString(0xa0, p1)\\n writeString(0xe0, p3)\\n }\\n _sendLogPayload(0x1c, 0x104);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n }\\n }\\n\\n function log(address p0, bytes32 p1, uint256 p2, address p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(address,string,uint256,address)`.\\n mstore(0x00, 0x63183678)\\n mstore(0x20, p0)\\n mstore(0x40, 0x80)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n writeString(0xa0, p1)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(address p0, bytes32 p1, uint256 p2, bool p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(address,string,uint256,bool)`.\\n mstore(0x00, 0x0ef7e050)\\n mstore(0x20, p0)\\n mstore(0x40, 0x80)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n writeString(0xa0, p1)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(address p0, bytes32 p1, uint256 p2, uint256 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(address,string,uint256,uint256)`.\\n mstore(0x00, 0x1dc8e1b8)\\n mstore(0x20, p0)\\n mstore(0x40, 0x80)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n writeString(0xa0, p1)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(address p0, bytes32 p1, uint256 p2, bytes32 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n // Selector of `log(address,string,uint256,string)`.\\n mstore(0x00, 0x448830a8)\\n mstore(0x20, p0)\\n mstore(0x40, 0x80)\\n mstore(0x60, p2)\\n mstore(0x80, 0xc0)\\n writeString(0xa0, p1)\\n writeString(0xe0, p3)\\n }\\n _sendLogPayload(0x1c, 0x104);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n }\\n }\\n\\n function log(address p0, bytes32 p1, bytes32 p2, address p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n // Selector of `log(address,string,string,address)`.\\n mstore(0x00, 0xa04e2f87)\\n mstore(0x20, p0)\\n mstore(0x40, 0x80)\\n mstore(0x60, 0xc0)\\n mstore(0x80, p3)\\n writeString(0xa0, p1)\\n writeString(0xe0, p2)\\n }\\n _sendLogPayload(0x1c, 0x104);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n }\\n }\\n\\n function log(address p0, bytes32 p1, bytes32 p2, bool p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n // Selector of `log(address,string,string,bool)`.\\n mstore(0x00, 0x35a5071f)\\n mstore(0x20, p0)\\n mstore(0x40, 0x80)\\n mstore(0x60, 0xc0)\\n mstore(0x80, p3)\\n writeString(0xa0, p1)\\n writeString(0xe0, p2)\\n }\\n _sendLogPayload(0x1c, 0x104);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n }\\n }\\n\\n function log(address p0, bytes32 p1, bytes32 p2, uint256 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n // Selector of `log(address,string,string,uint256)`.\\n mstore(0x00, 0x159f8927)\\n mstore(0x20, p0)\\n mstore(0x40, 0x80)\\n mstore(0x60, 0xc0)\\n mstore(0x80, p3)\\n writeString(0xa0, p1)\\n writeString(0xe0, p2)\\n }\\n _sendLogPayload(0x1c, 0x104);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n }\\n }\\n\\n function log(address p0, bytes32 p1, bytes32 p2, bytes32 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n bytes32 m9;\\n bytes32 m10;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n m9 := mload(0x120)\\n m10 := mload(0x140)\\n // Selector of `log(address,string,string,string)`.\\n mstore(0x00, 0x5d02c50b)\\n mstore(0x20, p0)\\n mstore(0x40, 0x80)\\n mstore(0x60, 0xc0)\\n mstore(0x80, 0x100)\\n writeString(0xa0, p1)\\n writeString(0xe0, p2)\\n writeString(0x120, p3)\\n }\\n _sendLogPayload(0x1c, 0x144);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n mstore(0x120, m9)\\n mstore(0x140, m10)\\n }\\n }\\n\\n function log(bool p0, address p1, address p2, address p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(bool,address,address,address)`.\\n mstore(0x00, 0x1d14d001)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(bool p0, address p1, address p2, bool p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(bool,address,address,bool)`.\\n mstore(0x00, 0x46600be0)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(bool p0, address p1, address p2, uint256 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(bool,address,address,uint256)`.\\n mstore(0x00, 0x0c66d1be)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(bool p0, address p1, address p2, bytes32 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(bool,address,address,string)`.\\n mstore(0x00, 0xd812a167)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, 0x80)\\n writeString(0xa0, p3)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(bool p0, address p1, bool p2, address p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(bool,address,bool,address)`.\\n mstore(0x00, 0x1c41a336)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(bool p0, address p1, bool p2, bool p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(bool,address,bool,bool)`.\\n mstore(0x00, 0x6a9c478b)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(bool p0, address p1, bool p2, uint256 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(bool,address,bool,uint256)`.\\n mstore(0x00, 0x07831502)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(bool p0, address p1, bool p2, bytes32 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(bool,address,bool,string)`.\\n mstore(0x00, 0x4a66cb34)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, 0x80)\\n writeString(0xa0, p3)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(bool p0, address p1, uint256 p2, address p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(bool,address,uint256,address)`.\\n mstore(0x00, 0x136b05dd)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(bool p0, address p1, uint256 p2, bool p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(bool,address,uint256,bool)`.\\n mstore(0x00, 0xd6019f1c)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(bool p0, address p1, uint256 p2, uint256 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(bool,address,uint256,uint256)`.\\n mstore(0x00, 0x7bf181a1)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(bool p0, address p1, uint256 p2, bytes32 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(bool,address,uint256,string)`.\\n mstore(0x00, 0x51f09ff8)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, 0x80)\\n writeString(0xa0, p3)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(bool p0, address p1, bytes32 p2, address p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(bool,address,string,address)`.\\n mstore(0x00, 0x6f7c603e)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, 0x80)\\n mstore(0x80, p3)\\n writeString(0xa0, p2)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(bool p0, address p1, bytes32 p2, bool p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(bool,address,string,bool)`.\\n mstore(0x00, 0xe2bfd60b)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, 0x80)\\n mstore(0x80, p3)\\n writeString(0xa0, p2)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(bool p0, address p1, bytes32 p2, uint256 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(bool,address,string,uint256)`.\\n mstore(0x00, 0xc21f64c7)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, 0x80)\\n mstore(0x80, p3)\\n writeString(0xa0, p2)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(bool p0, address p1, bytes32 p2, bytes32 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n // Selector of `log(bool,address,string,string)`.\\n mstore(0x00, 0xa73c1db6)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, 0x80)\\n mstore(0x80, 0xc0)\\n writeString(0xa0, p2)\\n writeString(0xe0, p3)\\n }\\n _sendLogPayload(0x1c, 0x104);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n }\\n }\\n\\n function log(bool p0, bool p1, address p2, address p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(bool,bool,address,address)`.\\n mstore(0x00, 0xf4880ea4)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(bool p0, bool p1, address p2, bool p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(bool,bool,address,bool)`.\\n mstore(0x00, 0xc0a302d8)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(bool p0, bool p1, address p2, uint256 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(bool,bool,address,uint256)`.\\n mstore(0x00, 0x4c123d57)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(bool p0, bool p1, address p2, bytes32 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(bool,bool,address,string)`.\\n mstore(0x00, 0xa0a47963)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, 0x80)\\n writeString(0xa0, p3)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(bool p0, bool p1, bool p2, address p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(bool,bool,bool,address)`.\\n mstore(0x00, 0x8c329b1a)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(bool p0, bool p1, bool p2, bool p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(bool,bool,bool,bool)`.\\n mstore(0x00, 0x3b2a5ce0)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(bool p0, bool p1, bool p2, uint256 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(bool,bool,bool,uint256)`.\\n mstore(0x00, 0x6d7045c1)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(bool p0, bool p1, bool p2, bytes32 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(bool,bool,bool,string)`.\\n mstore(0x00, 0x2ae408d4)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, 0x80)\\n writeString(0xa0, p3)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(bool p0, bool p1, uint256 p2, address p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(bool,bool,uint256,address)`.\\n mstore(0x00, 0x54a7a9a0)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(bool p0, bool p1, uint256 p2, bool p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(bool,bool,uint256,bool)`.\\n mstore(0x00, 0x619e4d0e)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(bool p0, bool p1, uint256 p2, uint256 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(bool,bool,uint256,uint256)`.\\n mstore(0x00, 0x0bb00eab)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(bool p0, bool p1, uint256 p2, bytes32 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(bool,bool,uint256,string)`.\\n mstore(0x00, 0x7dd4d0e0)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, 0x80)\\n writeString(0xa0, p3)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(bool p0, bool p1, bytes32 p2, address p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(bool,bool,string,address)`.\\n mstore(0x00, 0xf9ad2b89)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, 0x80)\\n mstore(0x80, p3)\\n writeString(0xa0, p2)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(bool p0, bool p1, bytes32 p2, bool p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(bool,bool,string,bool)`.\\n mstore(0x00, 0xb857163a)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, 0x80)\\n mstore(0x80, p3)\\n writeString(0xa0, p2)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(bool p0, bool p1, bytes32 p2, uint256 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(bool,bool,string,uint256)`.\\n mstore(0x00, 0xe3a9ca2f)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, 0x80)\\n mstore(0x80, p3)\\n writeString(0xa0, p2)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(bool p0, bool p1, bytes32 p2, bytes32 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n // Selector of `log(bool,bool,string,string)`.\\n mstore(0x00, 0x6d1e8751)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, 0x80)\\n mstore(0x80, 0xc0)\\n writeString(0xa0, p2)\\n writeString(0xe0, p3)\\n }\\n _sendLogPayload(0x1c, 0x104);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n }\\n }\\n\\n function log(bool p0, uint256 p1, address p2, address p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(bool,uint256,address,address)`.\\n mstore(0x00, 0x26f560a8)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(bool p0, uint256 p1, address p2, bool p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(bool,uint256,address,bool)`.\\n mstore(0x00, 0xb4c314ff)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(bool p0, uint256 p1, address p2, uint256 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(bool,uint256,address,uint256)`.\\n mstore(0x00, 0x1537dc87)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(bool p0, uint256 p1, address p2, bytes32 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(bool,uint256,address,string)`.\\n mstore(0x00, 0x1bb3b09a)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, 0x80)\\n writeString(0xa0, p3)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(bool p0, uint256 p1, bool p2, address p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(bool,uint256,bool,address)`.\\n mstore(0x00, 0x9acd3616)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(bool p0, uint256 p1, bool p2, bool p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(bool,uint256,bool,bool)`.\\n mstore(0x00, 0xceb5f4d7)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(bool p0, uint256 p1, bool p2, uint256 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(bool,uint256,bool,uint256)`.\\n mstore(0x00, 0x7f9bbca2)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(bool p0, uint256 p1, bool p2, bytes32 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(bool,uint256,bool,string)`.\\n mstore(0x00, 0x9143dbb1)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, 0x80)\\n writeString(0xa0, p3)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(bool p0, uint256 p1, uint256 p2, address p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(bool,uint256,uint256,address)`.\\n mstore(0x00, 0x00dd87b9)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(bool p0, uint256 p1, uint256 p2, bool p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(bool,uint256,uint256,bool)`.\\n mstore(0x00, 0xbe984353)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(bool p0, uint256 p1, uint256 p2, uint256 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(bool,uint256,uint256,uint256)`.\\n mstore(0x00, 0x374bb4b2)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(bool p0, uint256 p1, uint256 p2, bytes32 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(bool,uint256,uint256,string)`.\\n mstore(0x00, 0x8e69fb5d)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, 0x80)\\n writeString(0xa0, p3)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(bool p0, uint256 p1, bytes32 p2, address p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(bool,uint256,string,address)`.\\n mstore(0x00, 0xfedd1fff)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, 0x80)\\n mstore(0x80, p3)\\n writeString(0xa0, p2)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(bool p0, uint256 p1, bytes32 p2, bool p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(bool,uint256,string,bool)`.\\n mstore(0x00, 0xe5e70b2b)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, 0x80)\\n mstore(0x80, p3)\\n writeString(0xa0, p2)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(bool p0, uint256 p1, bytes32 p2, uint256 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(bool,uint256,string,uint256)`.\\n mstore(0x00, 0x6a1199e2)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, 0x80)\\n mstore(0x80, p3)\\n writeString(0xa0, p2)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(bool p0, uint256 p1, bytes32 p2, bytes32 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n // Selector of `log(bool,uint256,string,string)`.\\n mstore(0x00, 0xf5bc2249)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, 0x80)\\n mstore(0x80, 0xc0)\\n writeString(0xa0, p2)\\n writeString(0xe0, p3)\\n }\\n _sendLogPayload(0x1c, 0x104);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n }\\n }\\n\\n function log(bool p0, bytes32 p1, address p2, address p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(bool,string,address,address)`.\\n mstore(0x00, 0x2b2b18dc)\\n mstore(0x20, p0)\\n mstore(0x40, 0x80)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n writeString(0xa0, p1)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(bool p0, bytes32 p1, address p2, bool p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(bool,string,address,bool)`.\\n mstore(0x00, 0x6dd434ca)\\n mstore(0x20, p0)\\n mstore(0x40, 0x80)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n writeString(0xa0, p1)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(bool p0, bytes32 p1, address p2, uint256 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(bool,string,address,uint256)`.\\n mstore(0x00, 0xa5cada94)\\n mstore(0x20, p0)\\n mstore(0x40, 0x80)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n writeString(0xa0, p1)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(bool p0, bytes32 p1, address p2, bytes32 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n // Selector of `log(bool,string,address,string)`.\\n mstore(0x00, 0x12d6c788)\\n mstore(0x20, p0)\\n mstore(0x40, 0x80)\\n mstore(0x60, p2)\\n mstore(0x80, 0xc0)\\n writeString(0xa0, p1)\\n writeString(0xe0, p3)\\n }\\n _sendLogPayload(0x1c, 0x104);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n }\\n }\\n\\n function log(bool p0, bytes32 p1, bool p2, address p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(bool,string,bool,address)`.\\n mstore(0x00, 0x538e06ab)\\n mstore(0x20, p0)\\n mstore(0x40, 0x80)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n writeString(0xa0, p1)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(bool p0, bytes32 p1, bool p2, bool p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(bool,string,bool,bool)`.\\n mstore(0x00, 0xdc5e935b)\\n mstore(0x20, p0)\\n mstore(0x40, 0x80)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n writeString(0xa0, p1)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(bool p0, bytes32 p1, bool p2, uint256 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(bool,string,bool,uint256)`.\\n mstore(0x00, 0x1606a393)\\n mstore(0x20, p0)\\n mstore(0x40, 0x80)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n writeString(0xa0, p1)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(bool p0, bytes32 p1, bool p2, bytes32 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n // Selector of `log(bool,string,bool,string)`.\\n mstore(0x00, 0x483d0416)\\n mstore(0x20, p0)\\n mstore(0x40, 0x80)\\n mstore(0x60, p2)\\n mstore(0x80, 0xc0)\\n writeString(0xa0, p1)\\n writeString(0xe0, p3)\\n }\\n _sendLogPayload(0x1c, 0x104);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n }\\n }\\n\\n function log(bool p0, bytes32 p1, uint256 p2, address p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(bool,string,uint256,address)`.\\n mstore(0x00, 0x1596a1ce)\\n mstore(0x20, p0)\\n mstore(0x40, 0x80)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n writeString(0xa0, p1)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(bool p0, bytes32 p1, uint256 p2, bool p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(bool,string,uint256,bool)`.\\n mstore(0x00, 0x6b0e5d53)\\n mstore(0x20, p0)\\n mstore(0x40, 0x80)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n writeString(0xa0, p1)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(bool p0, bytes32 p1, uint256 p2, uint256 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(bool,string,uint256,uint256)`.\\n mstore(0x00, 0x28863fcb)\\n mstore(0x20, p0)\\n mstore(0x40, 0x80)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n writeString(0xa0, p1)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(bool p0, bytes32 p1, uint256 p2, bytes32 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n // Selector of `log(bool,string,uint256,string)`.\\n mstore(0x00, 0x1ad96de6)\\n mstore(0x20, p0)\\n mstore(0x40, 0x80)\\n mstore(0x60, p2)\\n mstore(0x80, 0xc0)\\n writeString(0xa0, p1)\\n writeString(0xe0, p3)\\n }\\n _sendLogPayload(0x1c, 0x104);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n }\\n }\\n\\n function log(bool p0, bytes32 p1, bytes32 p2, address p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n // Selector of `log(bool,string,string,address)`.\\n mstore(0x00, 0x97d394d8)\\n mstore(0x20, p0)\\n mstore(0x40, 0x80)\\n mstore(0x60, 0xc0)\\n mstore(0x80, p3)\\n writeString(0xa0, p1)\\n writeString(0xe0, p2)\\n }\\n _sendLogPayload(0x1c, 0x104);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n }\\n }\\n\\n function log(bool p0, bytes32 p1, bytes32 p2, bool p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n // Selector of `log(bool,string,string,bool)`.\\n mstore(0x00, 0x1e4b87e5)\\n mstore(0x20, p0)\\n mstore(0x40, 0x80)\\n mstore(0x60, 0xc0)\\n mstore(0x80, p3)\\n writeString(0xa0, p1)\\n writeString(0xe0, p2)\\n }\\n _sendLogPayload(0x1c, 0x104);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n }\\n }\\n\\n function log(bool p0, bytes32 p1, bytes32 p2, uint256 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n // Selector of `log(bool,string,string,uint256)`.\\n mstore(0x00, 0x7be0c3eb)\\n mstore(0x20, p0)\\n mstore(0x40, 0x80)\\n mstore(0x60, 0xc0)\\n mstore(0x80, p3)\\n writeString(0xa0, p1)\\n writeString(0xe0, p2)\\n }\\n _sendLogPayload(0x1c, 0x104);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n }\\n }\\n\\n function log(bool p0, bytes32 p1, bytes32 p2, bytes32 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n bytes32 m9;\\n bytes32 m10;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n m9 := mload(0x120)\\n m10 := mload(0x140)\\n // Selector of `log(bool,string,string,string)`.\\n mstore(0x00, 0x1762e32a)\\n mstore(0x20, p0)\\n mstore(0x40, 0x80)\\n mstore(0x60, 0xc0)\\n mstore(0x80, 0x100)\\n writeString(0xa0, p1)\\n writeString(0xe0, p2)\\n writeString(0x120, p3)\\n }\\n _sendLogPayload(0x1c, 0x144);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n mstore(0x120, m9)\\n mstore(0x140, m10)\\n }\\n }\\n\\n function log(uint256 p0, address p1, address p2, address p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(uint256,address,address,address)`.\\n mstore(0x00, 0x2488b414)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(uint256 p0, address p1, address p2, bool p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(uint256,address,address,bool)`.\\n mstore(0x00, 0x091ffaf5)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(uint256 p0, address p1, address p2, uint256 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(uint256,address,address,uint256)`.\\n mstore(0x00, 0x736efbb6)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(uint256 p0, address p1, address p2, bytes32 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(uint256,address,address,string)`.\\n mstore(0x00, 0x031c6f73)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, 0x80)\\n writeString(0xa0, p3)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(uint256 p0, address p1, bool p2, address p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(uint256,address,bool,address)`.\\n mstore(0x00, 0xef72c513)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(uint256 p0, address p1, bool p2, bool p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(uint256,address,bool,bool)`.\\n mstore(0x00, 0xe351140f)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(uint256 p0, address p1, bool p2, uint256 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(uint256,address,bool,uint256)`.\\n mstore(0x00, 0x5abd992a)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(uint256 p0, address p1, bool p2, bytes32 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(uint256,address,bool,string)`.\\n mstore(0x00, 0x90fb06aa)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, 0x80)\\n writeString(0xa0, p3)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(uint256 p0, address p1, uint256 p2, address p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(uint256,address,uint256,address)`.\\n mstore(0x00, 0x15c127b5)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(uint256 p0, address p1, uint256 p2, bool p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(uint256,address,uint256,bool)`.\\n mstore(0x00, 0x5f743a7c)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(uint256 p0, address p1, uint256 p2, uint256 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(uint256,address,uint256,uint256)`.\\n mstore(0x00, 0x0c9cd9c1)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(uint256 p0, address p1, uint256 p2, bytes32 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(uint256,address,uint256,string)`.\\n mstore(0x00, 0xddb06521)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, 0x80)\\n writeString(0xa0, p3)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(uint256 p0, address p1, bytes32 p2, address p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(uint256,address,string,address)`.\\n mstore(0x00, 0x9cba8fff)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, 0x80)\\n mstore(0x80, p3)\\n writeString(0xa0, p2)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(uint256 p0, address p1, bytes32 p2, bool p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(uint256,address,string,bool)`.\\n mstore(0x00, 0xcc32ab07)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, 0x80)\\n mstore(0x80, p3)\\n writeString(0xa0, p2)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(uint256 p0, address p1, bytes32 p2, uint256 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(uint256,address,string,uint256)`.\\n mstore(0x00, 0x46826b5d)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, 0x80)\\n mstore(0x80, p3)\\n writeString(0xa0, p2)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(uint256 p0, address p1, bytes32 p2, bytes32 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n // Selector of `log(uint256,address,string,string)`.\\n mstore(0x00, 0x3e128ca3)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, 0x80)\\n mstore(0x80, 0xc0)\\n writeString(0xa0, p2)\\n writeString(0xe0, p3)\\n }\\n _sendLogPayload(0x1c, 0x104);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n }\\n }\\n\\n function log(uint256 p0, bool p1, address p2, address p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(uint256,bool,address,address)`.\\n mstore(0x00, 0xa1ef4cbb)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(uint256 p0, bool p1, address p2, bool p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(uint256,bool,address,bool)`.\\n mstore(0x00, 0x454d54a5)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(uint256 p0, bool p1, address p2, uint256 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(uint256,bool,address,uint256)`.\\n mstore(0x00, 0x078287f5)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(uint256 p0, bool p1, address p2, bytes32 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(uint256,bool,address,string)`.\\n mstore(0x00, 0xade052c7)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, 0x80)\\n writeString(0xa0, p3)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(uint256 p0, bool p1, bool p2, address p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(uint256,bool,bool,address)`.\\n mstore(0x00, 0x69640b59)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(uint256 p0, bool p1, bool p2, bool p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(uint256,bool,bool,bool)`.\\n mstore(0x00, 0xb6f577a1)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(uint256 p0, bool p1, bool p2, uint256 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(uint256,bool,bool,uint256)`.\\n mstore(0x00, 0x7464ce23)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(uint256 p0, bool p1, bool p2, bytes32 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(uint256,bool,bool,string)`.\\n mstore(0x00, 0xdddb9561)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, 0x80)\\n writeString(0xa0, p3)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(uint256 p0, bool p1, uint256 p2, address p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(uint256,bool,uint256,address)`.\\n mstore(0x00, 0x88cb6041)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(uint256 p0, bool p1, uint256 p2, bool p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(uint256,bool,uint256,bool)`.\\n mstore(0x00, 0x91a02e2a)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(uint256 p0, bool p1, uint256 p2, uint256 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(uint256,bool,uint256,uint256)`.\\n mstore(0x00, 0xc6acc7a8)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(uint256 p0, bool p1, uint256 p2, bytes32 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(uint256,bool,uint256,string)`.\\n mstore(0x00, 0xde03e774)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, 0x80)\\n writeString(0xa0, p3)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(uint256 p0, bool p1, bytes32 p2, address p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(uint256,bool,string,address)`.\\n mstore(0x00, 0xef529018)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, 0x80)\\n mstore(0x80, p3)\\n writeString(0xa0, p2)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(uint256 p0, bool p1, bytes32 p2, bool p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(uint256,bool,string,bool)`.\\n mstore(0x00, 0xeb928d7f)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, 0x80)\\n mstore(0x80, p3)\\n writeString(0xa0, p2)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(uint256 p0, bool p1, bytes32 p2, uint256 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(uint256,bool,string,uint256)`.\\n mstore(0x00, 0x2c1d0746)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, 0x80)\\n mstore(0x80, p3)\\n writeString(0xa0, p2)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(uint256 p0, bool p1, bytes32 p2, bytes32 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n // Selector of `log(uint256,bool,string,string)`.\\n mstore(0x00, 0x68c8b8bd)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, 0x80)\\n mstore(0x80, 0xc0)\\n writeString(0xa0, p2)\\n writeString(0xe0, p3)\\n }\\n _sendLogPayload(0x1c, 0x104);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n }\\n }\\n\\n function log(uint256 p0, uint256 p1, address p2, address p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(uint256,uint256,address,address)`.\\n mstore(0x00, 0x56a5d1b1)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(uint256 p0, uint256 p1, address p2, bool p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(uint256,uint256,address,bool)`.\\n mstore(0x00, 0x15cac476)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(uint256 p0, uint256 p1, address p2, uint256 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(uint256,uint256,address,uint256)`.\\n mstore(0x00, 0x88f6e4b2)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(uint256 p0, uint256 p1, address p2, bytes32 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(uint256,uint256,address,string)`.\\n mstore(0x00, 0x6cde40b8)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, 0x80)\\n writeString(0xa0, p3)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(uint256 p0, uint256 p1, bool p2, address p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(uint256,uint256,bool,address)`.\\n mstore(0x00, 0x9a816a83)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(uint256 p0, uint256 p1, bool p2, bool p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(uint256,uint256,bool,bool)`.\\n mstore(0x00, 0xab085ae6)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(uint256 p0, uint256 p1, bool p2, uint256 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(uint256,uint256,bool,uint256)`.\\n mstore(0x00, 0xeb7f6fd2)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(uint256 p0, uint256 p1, bool p2, bytes32 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(uint256,uint256,bool,string)`.\\n mstore(0x00, 0xa5b4fc99)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, 0x80)\\n writeString(0xa0, p3)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(uint256 p0, uint256 p1, uint256 p2, address p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(uint256,uint256,uint256,address)`.\\n mstore(0x00, 0xfa8185af)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(uint256 p0, uint256 p1, uint256 p2, bool p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(uint256,uint256,uint256,bool)`.\\n mstore(0x00, 0xc598d185)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(uint256 p0, uint256 p1, uint256 p2, uint256 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(uint256,uint256,uint256,uint256)`.\\n mstore(0x00, 0x193fb800)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(uint256 p0, uint256 p1, uint256 p2, bytes32 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(uint256,uint256,uint256,string)`.\\n mstore(0x00, 0x59cfcbe3)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, 0x80)\\n writeString(0xa0, p3)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(uint256 p0, uint256 p1, bytes32 p2, address p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(uint256,uint256,string,address)`.\\n mstore(0x00, 0x42d21db7)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, 0x80)\\n mstore(0x80, p3)\\n writeString(0xa0, p2)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(uint256 p0, uint256 p1, bytes32 p2, bool p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(uint256,uint256,string,bool)`.\\n mstore(0x00, 0x7af6ab25)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, 0x80)\\n mstore(0x80, p3)\\n writeString(0xa0, p2)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(uint256 p0, uint256 p1, bytes32 p2, uint256 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(uint256,uint256,string,uint256)`.\\n mstore(0x00, 0x5da297eb)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, 0x80)\\n mstore(0x80, p3)\\n writeString(0xa0, p2)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(uint256 p0, uint256 p1, bytes32 p2, bytes32 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n // Selector of `log(uint256,uint256,string,string)`.\\n mstore(0x00, 0x27d8afd2)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, 0x80)\\n mstore(0x80, 0xc0)\\n writeString(0xa0, p2)\\n writeString(0xe0, p3)\\n }\\n _sendLogPayload(0x1c, 0x104);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n }\\n }\\n\\n function log(uint256 p0, bytes32 p1, address p2, address p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(uint256,string,address,address)`.\\n mstore(0x00, 0x6168ed61)\\n mstore(0x20, p0)\\n mstore(0x40, 0x80)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n writeString(0xa0, p1)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(uint256 p0, bytes32 p1, address p2, bool p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(uint256,string,address,bool)`.\\n mstore(0x00, 0x90c30a56)\\n mstore(0x20, p0)\\n mstore(0x40, 0x80)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n writeString(0xa0, p1)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(uint256 p0, bytes32 p1, address p2, uint256 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(uint256,string,address,uint256)`.\\n mstore(0x00, 0xe8d3018d)\\n mstore(0x20, p0)\\n mstore(0x40, 0x80)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n writeString(0xa0, p1)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(uint256 p0, bytes32 p1, address p2, bytes32 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n // Selector of `log(uint256,string,address,string)`.\\n mstore(0x00, 0x9c3adfa1)\\n mstore(0x20, p0)\\n mstore(0x40, 0x80)\\n mstore(0x60, p2)\\n mstore(0x80, 0xc0)\\n writeString(0xa0, p1)\\n writeString(0xe0, p3)\\n }\\n _sendLogPayload(0x1c, 0x104);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n }\\n }\\n\\n function log(uint256 p0, bytes32 p1, bool p2, address p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(uint256,string,bool,address)`.\\n mstore(0x00, 0xae2ec581)\\n mstore(0x20, p0)\\n mstore(0x40, 0x80)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n writeString(0xa0, p1)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(uint256 p0, bytes32 p1, bool p2, bool p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(uint256,string,bool,bool)`.\\n mstore(0x00, 0xba535d9c)\\n mstore(0x20, p0)\\n mstore(0x40, 0x80)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n writeString(0xa0, p1)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(uint256 p0, bytes32 p1, bool p2, uint256 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(uint256,string,bool,uint256)`.\\n mstore(0x00, 0xcf009880)\\n mstore(0x20, p0)\\n mstore(0x40, 0x80)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n writeString(0xa0, p1)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(uint256 p0, bytes32 p1, bool p2, bytes32 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n // Selector of `log(uint256,string,bool,string)`.\\n mstore(0x00, 0xd2d423cd)\\n mstore(0x20, p0)\\n mstore(0x40, 0x80)\\n mstore(0x60, p2)\\n mstore(0x80, 0xc0)\\n writeString(0xa0, p1)\\n writeString(0xe0, p3)\\n }\\n _sendLogPayload(0x1c, 0x104);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n }\\n }\\n\\n function log(uint256 p0, bytes32 p1, uint256 p2, address p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(uint256,string,uint256,address)`.\\n mstore(0x00, 0x3b2279b4)\\n mstore(0x20, p0)\\n mstore(0x40, 0x80)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n writeString(0xa0, p1)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(uint256 p0, bytes32 p1, uint256 p2, bool p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(uint256,string,uint256,bool)`.\\n mstore(0x00, 0x691a8f74)\\n mstore(0x20, p0)\\n mstore(0x40, 0x80)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n writeString(0xa0, p1)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(uint256 p0, bytes32 p1, uint256 p2, uint256 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(uint256,string,uint256,uint256)`.\\n mstore(0x00, 0x82c25b74)\\n mstore(0x20, p0)\\n mstore(0x40, 0x80)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n writeString(0xa0, p1)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(uint256 p0, bytes32 p1, uint256 p2, bytes32 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n // Selector of `log(uint256,string,uint256,string)`.\\n mstore(0x00, 0xb7b914ca)\\n mstore(0x20, p0)\\n mstore(0x40, 0x80)\\n mstore(0x60, p2)\\n mstore(0x80, 0xc0)\\n writeString(0xa0, p1)\\n writeString(0xe0, p3)\\n }\\n _sendLogPayload(0x1c, 0x104);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n }\\n }\\n\\n function log(uint256 p0, bytes32 p1, bytes32 p2, address p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n // Selector of `log(uint256,string,string,address)`.\\n mstore(0x00, 0xd583c602)\\n mstore(0x20, p0)\\n mstore(0x40, 0x80)\\n mstore(0x60, 0xc0)\\n mstore(0x80, p3)\\n writeString(0xa0, p1)\\n writeString(0xe0, p2)\\n }\\n _sendLogPayload(0x1c, 0x104);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n }\\n }\\n\\n function log(uint256 p0, bytes32 p1, bytes32 p2, bool p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n // Selector of `log(uint256,string,string,bool)`.\\n mstore(0x00, 0xb3a6b6bd)\\n mstore(0x20, p0)\\n mstore(0x40, 0x80)\\n mstore(0x60, 0xc0)\\n mstore(0x80, p3)\\n writeString(0xa0, p1)\\n writeString(0xe0, p2)\\n }\\n _sendLogPayload(0x1c, 0x104);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n }\\n }\\n\\n function log(uint256 p0, bytes32 p1, bytes32 p2, uint256 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n // Selector of `log(uint256,string,string,uint256)`.\\n mstore(0x00, 0xb028c9bd)\\n mstore(0x20, p0)\\n mstore(0x40, 0x80)\\n mstore(0x60, 0xc0)\\n mstore(0x80, p3)\\n writeString(0xa0, p1)\\n writeString(0xe0, p2)\\n }\\n _sendLogPayload(0x1c, 0x104);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n }\\n }\\n\\n function log(uint256 p0, bytes32 p1, bytes32 p2, bytes32 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n bytes32 m9;\\n bytes32 m10;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n m9 := mload(0x120)\\n m10 := mload(0x140)\\n // Selector of `log(uint256,string,string,string)`.\\n mstore(0x00, 0x21ad0683)\\n mstore(0x20, p0)\\n mstore(0x40, 0x80)\\n mstore(0x60, 0xc0)\\n mstore(0x80, 0x100)\\n writeString(0xa0, p1)\\n writeString(0xe0, p2)\\n writeString(0x120, p3)\\n }\\n _sendLogPayload(0x1c, 0x144);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n mstore(0x120, m9)\\n mstore(0x140, m10)\\n }\\n }\\n\\n function log(bytes32 p0, address p1, address p2, address p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(string,address,address,address)`.\\n mstore(0x00, 0xed8f28f6)\\n mstore(0x20, 0x80)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n writeString(0xa0, p0)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(bytes32 p0, address p1, address p2, bool p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(string,address,address,bool)`.\\n mstore(0x00, 0xb59dbd60)\\n mstore(0x20, 0x80)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n writeString(0xa0, p0)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(bytes32 p0, address p1, address p2, uint256 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(string,address,address,uint256)`.\\n mstore(0x00, 0x8ef3f399)\\n mstore(0x20, 0x80)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n writeString(0xa0, p0)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(bytes32 p0, address p1, address p2, bytes32 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n // Selector of `log(string,address,address,string)`.\\n mstore(0x00, 0x800a1c67)\\n mstore(0x20, 0x80)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, 0xc0)\\n writeString(0xa0, p0)\\n writeString(0xe0, p3)\\n }\\n _sendLogPayload(0x1c, 0x104);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n }\\n }\\n\\n function log(bytes32 p0, address p1, bool p2, address p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(string,address,bool,address)`.\\n mstore(0x00, 0x223603bd)\\n mstore(0x20, 0x80)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n writeString(0xa0, p0)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(bytes32 p0, address p1, bool p2, bool p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(string,address,bool,bool)`.\\n mstore(0x00, 0x79884c2b)\\n mstore(0x20, 0x80)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n writeString(0xa0, p0)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(bytes32 p0, address p1, bool p2, uint256 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(string,address,bool,uint256)`.\\n mstore(0x00, 0x3e9f866a)\\n mstore(0x20, 0x80)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n writeString(0xa0, p0)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(bytes32 p0, address p1, bool p2, bytes32 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n // Selector of `log(string,address,bool,string)`.\\n mstore(0x00, 0x0454c079)\\n mstore(0x20, 0x80)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, 0xc0)\\n writeString(0xa0, p0)\\n writeString(0xe0, p3)\\n }\\n _sendLogPayload(0x1c, 0x104);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n }\\n }\\n\\n function log(bytes32 p0, address p1, uint256 p2, address p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(string,address,uint256,address)`.\\n mstore(0x00, 0x63fb8bc5)\\n mstore(0x20, 0x80)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n writeString(0xa0, p0)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(bytes32 p0, address p1, uint256 p2, bool p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(string,address,uint256,bool)`.\\n mstore(0x00, 0xfc4845f0)\\n mstore(0x20, 0x80)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n writeString(0xa0, p0)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(bytes32 p0, address p1, uint256 p2, uint256 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(string,address,uint256,uint256)`.\\n mstore(0x00, 0xf8f51b1e)\\n mstore(0x20, 0x80)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n writeString(0xa0, p0)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(bytes32 p0, address p1, uint256 p2, bytes32 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n // Selector of `log(string,address,uint256,string)`.\\n mstore(0x00, 0x5a477632)\\n mstore(0x20, 0x80)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, 0xc0)\\n writeString(0xa0, p0)\\n writeString(0xe0, p3)\\n }\\n _sendLogPayload(0x1c, 0x104);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n }\\n }\\n\\n function log(bytes32 p0, address p1, bytes32 p2, address p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n // Selector of `log(string,address,string,address)`.\\n mstore(0x00, 0xaabc9a31)\\n mstore(0x20, 0x80)\\n mstore(0x40, p1)\\n mstore(0x60, 0xc0)\\n mstore(0x80, p3)\\n writeString(0xa0, p0)\\n writeString(0xe0, p2)\\n }\\n _sendLogPayload(0x1c, 0x104);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n }\\n }\\n\\n function log(bytes32 p0, address p1, bytes32 p2, bool p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n // Selector of `log(string,address,string,bool)`.\\n mstore(0x00, 0x5f15d28c)\\n mstore(0x20, 0x80)\\n mstore(0x40, p1)\\n mstore(0x60, 0xc0)\\n mstore(0x80, p3)\\n writeString(0xa0, p0)\\n writeString(0xe0, p2)\\n }\\n _sendLogPayload(0x1c, 0x104);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n }\\n }\\n\\n function log(bytes32 p0, address p1, bytes32 p2, uint256 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n // Selector of `log(string,address,string,uint256)`.\\n mstore(0x00, 0x91d1112e)\\n mstore(0x20, 0x80)\\n mstore(0x40, p1)\\n mstore(0x60, 0xc0)\\n mstore(0x80, p3)\\n writeString(0xa0, p0)\\n writeString(0xe0, p2)\\n }\\n _sendLogPayload(0x1c, 0x104);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n }\\n }\\n\\n function log(bytes32 p0, address p1, bytes32 p2, bytes32 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n bytes32 m9;\\n bytes32 m10;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n m9 := mload(0x120)\\n m10 := mload(0x140)\\n // Selector of `log(string,address,string,string)`.\\n mstore(0x00, 0x245986f2)\\n mstore(0x20, 0x80)\\n mstore(0x40, p1)\\n mstore(0x60, 0xc0)\\n mstore(0x80, 0x100)\\n writeString(0xa0, p0)\\n writeString(0xe0, p2)\\n writeString(0x120, p3)\\n }\\n _sendLogPayload(0x1c, 0x144);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n mstore(0x120, m9)\\n mstore(0x140, m10)\\n }\\n }\\n\\n function log(bytes32 p0, bool p1, address p2, address p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(string,bool,address,address)`.\\n mstore(0x00, 0x33e9dd1d)\\n mstore(0x20, 0x80)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n writeString(0xa0, p0)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(bytes32 p0, bool p1, address p2, bool p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(string,bool,address,bool)`.\\n mstore(0x00, 0x958c28c6)\\n mstore(0x20, 0x80)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n writeString(0xa0, p0)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(bytes32 p0, bool p1, address p2, uint256 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(string,bool,address,uint256)`.\\n mstore(0x00, 0x5d08bb05)\\n mstore(0x20, 0x80)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n writeString(0xa0, p0)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(bytes32 p0, bool p1, address p2, bytes32 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n // Selector of `log(string,bool,address,string)`.\\n mstore(0x00, 0x2d8e33a4)\\n mstore(0x20, 0x80)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, 0xc0)\\n writeString(0xa0, p0)\\n writeString(0xe0, p3)\\n }\\n _sendLogPayload(0x1c, 0x104);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n }\\n }\\n\\n function log(bytes32 p0, bool p1, bool p2, address p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(string,bool,bool,address)`.\\n mstore(0x00, 0x7190a529)\\n mstore(0x20, 0x80)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n writeString(0xa0, p0)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(bytes32 p0, bool p1, bool p2, bool p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(string,bool,bool,bool)`.\\n mstore(0x00, 0x895af8c5)\\n mstore(0x20, 0x80)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n writeString(0xa0, p0)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(bytes32 p0, bool p1, bool p2, uint256 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(string,bool,bool,uint256)`.\\n mstore(0x00, 0x8e3f78a9)\\n mstore(0x20, 0x80)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n writeString(0xa0, p0)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(bytes32 p0, bool p1, bool p2, bytes32 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n // Selector of `log(string,bool,bool,string)`.\\n mstore(0x00, 0x9d22d5dd)\\n mstore(0x20, 0x80)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, 0xc0)\\n writeString(0xa0, p0)\\n writeString(0xe0, p3)\\n }\\n _sendLogPayload(0x1c, 0x104);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n }\\n }\\n\\n function log(bytes32 p0, bool p1, uint256 p2, address p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(string,bool,uint256,address)`.\\n mstore(0x00, 0x935e09bf)\\n mstore(0x20, 0x80)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n writeString(0xa0, p0)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(bytes32 p0, bool p1, uint256 p2, bool p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(string,bool,uint256,bool)`.\\n mstore(0x00, 0x8af7cf8a)\\n mstore(0x20, 0x80)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n writeString(0xa0, p0)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(bytes32 p0, bool p1, uint256 p2, uint256 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(string,bool,uint256,uint256)`.\\n mstore(0x00, 0x64b5bb67)\\n mstore(0x20, 0x80)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n writeString(0xa0, p0)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(bytes32 p0, bool p1, uint256 p2, bytes32 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n // Selector of `log(string,bool,uint256,string)`.\\n mstore(0x00, 0x742d6ee7)\\n mstore(0x20, 0x80)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, 0xc0)\\n writeString(0xa0, p0)\\n writeString(0xe0, p3)\\n }\\n _sendLogPayload(0x1c, 0x104);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n }\\n }\\n\\n function log(bytes32 p0, bool p1, bytes32 p2, address p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n // Selector of `log(string,bool,string,address)`.\\n mstore(0x00, 0xe0625b29)\\n mstore(0x20, 0x80)\\n mstore(0x40, p1)\\n mstore(0x60, 0xc0)\\n mstore(0x80, p3)\\n writeString(0xa0, p0)\\n writeString(0xe0, p2)\\n }\\n _sendLogPayload(0x1c, 0x104);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n }\\n }\\n\\n function log(bytes32 p0, bool p1, bytes32 p2, bool p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n // Selector of `log(string,bool,string,bool)`.\\n mstore(0x00, 0x3f8a701d)\\n mstore(0x20, 0x80)\\n mstore(0x40, p1)\\n mstore(0x60, 0xc0)\\n mstore(0x80, p3)\\n writeString(0xa0, p0)\\n writeString(0xe0, p2)\\n }\\n _sendLogPayload(0x1c, 0x104);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n }\\n }\\n\\n function log(bytes32 p0, bool p1, bytes32 p2, uint256 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n // Selector of `log(string,bool,string,uint256)`.\\n mstore(0x00, 0x24f91465)\\n mstore(0x20, 0x80)\\n mstore(0x40, p1)\\n mstore(0x60, 0xc0)\\n mstore(0x80, p3)\\n writeString(0xa0, p0)\\n writeString(0xe0, p2)\\n }\\n _sendLogPayload(0x1c, 0x104);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n }\\n }\\n\\n function log(bytes32 p0, bool p1, bytes32 p2, bytes32 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n bytes32 m9;\\n bytes32 m10;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n m9 := mload(0x120)\\n m10 := mload(0x140)\\n // Selector of `log(string,bool,string,string)`.\\n mstore(0x00, 0xa826caeb)\\n mstore(0x20, 0x80)\\n mstore(0x40, p1)\\n mstore(0x60, 0xc0)\\n mstore(0x80, 0x100)\\n writeString(0xa0, p0)\\n writeString(0xe0, p2)\\n writeString(0x120, p3)\\n }\\n _sendLogPayload(0x1c, 0x144);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n mstore(0x120, m9)\\n mstore(0x140, m10)\\n }\\n }\\n\\n function log(bytes32 p0, uint256 p1, address p2, address p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(string,uint256,address,address)`.\\n mstore(0x00, 0x5ea2b7ae)\\n mstore(0x20, 0x80)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n writeString(0xa0, p0)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(bytes32 p0, uint256 p1, address p2, bool p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(string,uint256,address,bool)`.\\n mstore(0x00, 0x82112a42)\\n mstore(0x20, 0x80)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n writeString(0xa0, p0)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(bytes32 p0, uint256 p1, address p2, uint256 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(string,uint256,address,uint256)`.\\n mstore(0x00, 0x4f04fdc6)\\n mstore(0x20, 0x80)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n writeString(0xa0, p0)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(bytes32 p0, uint256 p1, address p2, bytes32 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n // Selector of `log(string,uint256,address,string)`.\\n mstore(0x00, 0x9ffb2f93)\\n mstore(0x20, 0x80)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, 0xc0)\\n writeString(0xa0, p0)\\n writeString(0xe0, p3)\\n }\\n _sendLogPayload(0x1c, 0x104);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n }\\n }\\n\\n function log(bytes32 p0, uint256 p1, bool p2, address p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(string,uint256,bool,address)`.\\n mstore(0x00, 0xe0e95b98)\\n mstore(0x20, 0x80)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n writeString(0xa0, p0)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(bytes32 p0, uint256 p1, bool p2, bool p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(string,uint256,bool,bool)`.\\n mstore(0x00, 0x354c36d6)\\n mstore(0x20, 0x80)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n writeString(0xa0, p0)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(bytes32 p0, uint256 p1, bool p2, uint256 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(string,uint256,bool,uint256)`.\\n mstore(0x00, 0xe41b6f6f)\\n mstore(0x20, 0x80)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n writeString(0xa0, p0)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(bytes32 p0, uint256 p1, bool p2, bytes32 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n // Selector of `log(string,uint256,bool,string)`.\\n mstore(0x00, 0xabf73a98)\\n mstore(0x20, 0x80)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, 0xc0)\\n writeString(0xa0, p0)\\n writeString(0xe0, p3)\\n }\\n _sendLogPayload(0x1c, 0x104);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n }\\n }\\n\\n function log(bytes32 p0, uint256 p1, uint256 p2, address p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(string,uint256,uint256,address)`.\\n mstore(0x00, 0xe21de278)\\n mstore(0x20, 0x80)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n writeString(0xa0, p0)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(bytes32 p0, uint256 p1, uint256 p2, bool p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(string,uint256,uint256,bool)`.\\n mstore(0x00, 0x7626db92)\\n mstore(0x20, 0x80)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n writeString(0xa0, p0)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(bytes32 p0, uint256 p1, uint256 p2, uint256 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(string,uint256,uint256,uint256)`.\\n mstore(0x00, 0xa7a87853)\\n mstore(0x20, 0x80)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n writeString(0xa0, p0)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(bytes32 p0, uint256 p1, uint256 p2, bytes32 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n // Selector of `log(string,uint256,uint256,string)`.\\n mstore(0x00, 0x854b3496)\\n mstore(0x20, 0x80)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, 0xc0)\\n writeString(0xa0, p0)\\n writeString(0xe0, p3)\\n }\\n _sendLogPayload(0x1c, 0x104);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n }\\n }\\n\\n function log(bytes32 p0, uint256 p1, bytes32 p2, address p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n // Selector of `log(string,uint256,string,address)`.\\n mstore(0x00, 0x7c4632a4)\\n mstore(0x20, 0x80)\\n mstore(0x40, p1)\\n mstore(0x60, 0xc0)\\n mstore(0x80, p3)\\n writeString(0xa0, p0)\\n writeString(0xe0, p2)\\n }\\n _sendLogPayload(0x1c, 0x104);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n }\\n }\\n\\n function log(bytes32 p0, uint256 p1, bytes32 p2, bool p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n // Selector of `log(string,uint256,string,bool)`.\\n mstore(0x00, 0x7d24491d)\\n mstore(0x20, 0x80)\\n mstore(0x40, p1)\\n mstore(0x60, 0xc0)\\n mstore(0x80, p3)\\n writeString(0xa0, p0)\\n writeString(0xe0, p2)\\n }\\n _sendLogPayload(0x1c, 0x104);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n }\\n }\\n\\n function log(bytes32 p0, uint256 p1, bytes32 p2, uint256 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n // Selector of `log(string,uint256,string,uint256)`.\\n mstore(0x00, 0xc67ea9d1)\\n mstore(0x20, 0x80)\\n mstore(0x40, p1)\\n mstore(0x60, 0xc0)\\n mstore(0x80, p3)\\n writeString(0xa0, p0)\\n writeString(0xe0, p2)\\n }\\n _sendLogPayload(0x1c, 0x104);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n }\\n }\\n\\n function log(bytes32 p0, uint256 p1, bytes32 p2, bytes32 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n bytes32 m9;\\n bytes32 m10;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n m9 := mload(0x120)\\n m10 := mload(0x140)\\n // Selector of `log(string,uint256,string,string)`.\\n mstore(0x00, 0x5ab84e1f)\\n mstore(0x20, 0x80)\\n mstore(0x40, p1)\\n mstore(0x60, 0xc0)\\n mstore(0x80, 0x100)\\n writeString(0xa0, p0)\\n writeString(0xe0, p2)\\n writeString(0x120, p3)\\n }\\n _sendLogPayload(0x1c, 0x144);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n mstore(0x120, m9)\\n mstore(0x140, m10)\\n }\\n }\\n\\n function log(bytes32 p0, bytes32 p1, address p2, address p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n // Selector of `log(string,string,address,address)`.\\n mstore(0x00, 0x439c7bef)\\n mstore(0x20, 0x80)\\n mstore(0x40, 0xc0)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n writeString(0xa0, p0)\\n writeString(0xe0, p1)\\n }\\n _sendLogPayload(0x1c, 0x104);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n }\\n }\\n\\n function log(bytes32 p0, bytes32 p1, address p2, bool p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n // Selector of `log(string,string,address,bool)`.\\n mstore(0x00, 0x5ccd4e37)\\n mstore(0x20, 0x80)\\n mstore(0x40, 0xc0)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n writeString(0xa0, p0)\\n writeString(0xe0, p1)\\n }\\n _sendLogPayload(0x1c, 0x104);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n }\\n }\\n\\n function log(bytes32 p0, bytes32 p1, address p2, uint256 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n // Selector of `log(string,string,address,uint256)`.\\n mstore(0x00, 0x7cc3c607)\\n mstore(0x20, 0x80)\\n mstore(0x40, 0xc0)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n writeString(0xa0, p0)\\n writeString(0xe0, p1)\\n }\\n _sendLogPayload(0x1c, 0x104);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n }\\n }\\n\\n function log(bytes32 p0, bytes32 p1, address p2, bytes32 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n bytes32 m9;\\n bytes32 m10;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n m9 := mload(0x120)\\n m10 := mload(0x140)\\n // Selector of `log(string,string,address,string)`.\\n mstore(0x00, 0xeb1bff80)\\n mstore(0x20, 0x80)\\n mstore(0x40, 0xc0)\\n mstore(0x60, p2)\\n mstore(0x80, 0x100)\\n writeString(0xa0, p0)\\n writeString(0xe0, p1)\\n writeString(0x120, p3)\\n }\\n _sendLogPayload(0x1c, 0x144);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n mstore(0x120, m9)\\n mstore(0x140, m10)\\n }\\n }\\n\\n function log(bytes32 p0, bytes32 p1, bool p2, address p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n // Selector of `log(string,string,bool,address)`.\\n mstore(0x00, 0xc371c7db)\\n mstore(0x20, 0x80)\\n mstore(0x40, 0xc0)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n writeString(0xa0, p0)\\n writeString(0xe0, p1)\\n }\\n _sendLogPayload(0x1c, 0x104);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n }\\n }\\n\\n function log(bytes32 p0, bytes32 p1, bool p2, bool p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n // Selector of `log(string,string,bool,bool)`.\\n mstore(0x00, 0x40785869)\\n mstore(0x20, 0x80)\\n mstore(0x40, 0xc0)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n writeString(0xa0, p0)\\n writeString(0xe0, p1)\\n }\\n _sendLogPayload(0x1c, 0x104);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n }\\n }\\n\\n function log(bytes32 p0, bytes32 p1, bool p2, uint256 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n // Selector of `log(string,string,bool,uint256)`.\\n mstore(0x00, 0xd6aefad2)\\n mstore(0x20, 0x80)\\n mstore(0x40, 0xc0)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n writeString(0xa0, p0)\\n writeString(0xe0, p1)\\n }\\n _sendLogPayload(0x1c, 0x104);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n }\\n }\\n\\n function log(bytes32 p0, bytes32 p1, bool p2, bytes32 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n bytes32 m9;\\n bytes32 m10;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n m9 := mload(0x120)\\n m10 := mload(0x140)\\n // Selector of `log(string,string,bool,string)`.\\n mstore(0x00, 0x5e84b0ea)\\n mstore(0x20, 0x80)\\n mstore(0x40, 0xc0)\\n mstore(0x60, p2)\\n mstore(0x80, 0x100)\\n writeString(0xa0, p0)\\n writeString(0xe0, p1)\\n writeString(0x120, p3)\\n }\\n _sendLogPayload(0x1c, 0x144);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n mstore(0x120, m9)\\n mstore(0x140, m10)\\n }\\n }\\n\\n function log(bytes32 p0, bytes32 p1, uint256 p2, address p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n // Selector of `log(string,string,uint256,address)`.\\n mstore(0x00, 0x1023f7b2)\\n mstore(0x20, 0x80)\\n mstore(0x40, 0xc0)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n writeString(0xa0, p0)\\n writeString(0xe0, p1)\\n }\\n _sendLogPayload(0x1c, 0x104);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n }\\n }\\n\\n function log(bytes32 p0, bytes32 p1, uint256 p2, bool p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n // Selector of `log(string,string,uint256,bool)`.\\n mstore(0x00, 0xc3a8a654)\\n mstore(0x20, 0x80)\\n mstore(0x40, 0xc0)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n writeString(0xa0, p0)\\n writeString(0xe0, p1)\\n }\\n _sendLogPayload(0x1c, 0x104);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n }\\n }\\n\\n function log(bytes32 p0, bytes32 p1, uint256 p2, uint256 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n // Selector of `log(string,string,uint256,uint256)`.\\n mstore(0x00, 0xf45d7d2c)\\n mstore(0x20, 0x80)\\n mstore(0x40, 0xc0)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n writeString(0xa0, p0)\\n writeString(0xe0, p1)\\n }\\n _sendLogPayload(0x1c, 0x104);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n }\\n }\\n\\n function log(bytes32 p0, bytes32 p1, uint256 p2, bytes32 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n bytes32 m9;\\n bytes32 m10;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n m9 := mload(0x120)\\n m10 := mload(0x140)\\n // Selector of `log(string,string,uint256,string)`.\\n mstore(0x00, 0x5d1a971a)\\n mstore(0x20, 0x80)\\n mstore(0x40, 0xc0)\\n mstore(0x60, p2)\\n mstore(0x80, 0x100)\\n writeString(0xa0, p0)\\n writeString(0xe0, p1)\\n writeString(0x120, p3)\\n }\\n _sendLogPayload(0x1c, 0x144);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n mstore(0x120, m9)\\n mstore(0x140, m10)\\n }\\n }\\n\\n function log(bytes32 p0, bytes32 p1, bytes32 p2, address p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n bytes32 m9;\\n bytes32 m10;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n m9 := mload(0x120)\\n m10 := mload(0x140)\\n // Selector of `log(string,string,string,address)`.\\n mstore(0x00, 0x6d572f44)\\n mstore(0x20, 0x80)\\n mstore(0x40, 0xc0)\\n mstore(0x60, 0x100)\\n mstore(0x80, p3)\\n writeString(0xa0, p0)\\n writeString(0xe0, p1)\\n writeString(0x120, p2)\\n }\\n _sendLogPayload(0x1c, 0x144);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n mstore(0x120, m9)\\n mstore(0x140, m10)\\n }\\n }\\n\\n function log(bytes32 p0, bytes32 p1, bytes32 p2, bool p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n bytes32 m9;\\n bytes32 m10;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n m9 := mload(0x120)\\n m10 := mload(0x140)\\n // Selector of `log(string,string,string,bool)`.\\n mstore(0x00, 0x2c1754ed)\\n mstore(0x20, 0x80)\\n mstore(0x40, 0xc0)\\n mstore(0x60, 0x100)\\n mstore(0x80, p3)\\n writeString(0xa0, p0)\\n writeString(0xe0, p1)\\n writeString(0x120, p2)\\n }\\n _sendLogPayload(0x1c, 0x144);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n mstore(0x120, m9)\\n mstore(0x140, m10)\\n }\\n }\\n\\n function log(bytes32 p0, bytes32 p1, bytes32 p2, uint256 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n bytes32 m9;\\n bytes32 m10;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n m9 := mload(0x120)\\n m10 := mload(0x140)\\n // Selector of `log(string,string,string,uint256)`.\\n mstore(0x00, 0x8eafb02b)\\n mstore(0x20, 0x80)\\n mstore(0x40, 0xc0)\\n mstore(0x60, 0x100)\\n mstore(0x80, p3)\\n writeString(0xa0, p0)\\n writeString(0xe0, p1)\\n writeString(0x120, p2)\\n }\\n _sendLogPayload(0x1c, 0x144);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n mstore(0x120, m9)\\n mstore(0x140, m10)\\n }\\n }\\n\\n function log(bytes32 p0, bytes32 p1, bytes32 p2, bytes32 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n bytes32 m9;\\n bytes32 m10;\\n bytes32 m11;\\n bytes32 m12;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n m9 := mload(0x120)\\n m10 := mload(0x140)\\n m11 := mload(0x160)\\n m12 := mload(0x180)\\n // Selector of `log(string,string,string,string)`.\\n mstore(0x00, 0xde68f20a)\\n mstore(0x20, 0x80)\\n mstore(0x40, 0xc0)\\n mstore(0x60, 0x100)\\n mstore(0x80, 0x140)\\n writeString(0xa0, p0)\\n writeString(0xe0, p1)\\n writeString(0x120, p2)\\n writeString(0x160, p3)\\n }\\n _sendLogPayload(0x1c, 0x184);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n mstore(0x120, m9)\\n mstore(0x140, m10)\\n mstore(0x160, m11)\\n mstore(0x180, m12)\\n }\\n }\\n}\\n\",\"keccak256\":\"0xbef9786cb49d3eade757bad87568c49c8c8f35721f0193c95ffb055d9e466e11\",\"license\":\"MIT\"},\"scripts/FetchChainInfo.s.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\nimport { Script } from \\\"forge-std/Script.sol\\\";\\nimport { GameTypes, GameType } from \\\"src/dispute/lib/Types.sol\\\";\\n\\n/// @notice Contains getters for arbitrary methods from all L1 contracts, including legacy getters\\n/// that have since been deprecated.\\ninterface IFetcher {\\n function guardian() external view returns (address);\\n function GUARDIAN() external view returns (address);\\n function systemConfig() external view returns (address);\\n function SYSTEM_CONFIG() external view returns (address);\\n function disputeGameFactory() external view returns (address);\\n function ethLockbox() external view returns (address);\\n function superchainConfig() external view returns (address);\\n function messenger() external view returns (address);\\n function addressManager() external view returns (address);\\n function PORTAL() external view returns (address);\\n function portal() external view returns (address);\\n function l1ERC721Bridge() external view returns (address);\\n function optimismMintableERC20Factory() external view returns (address);\\n function gameImpls(GameType _gameType) external view returns (address);\\n function respectedGameType() external view returns (GameType);\\n function anchorStateRegistry() external view returns (address);\\n function L2_ORACLE() external view returns (address);\\n function l2Oracle() external view returns (address);\\n function vm() external view returns (address);\\n function oracle() external view returns (address);\\n function challenger() external view returns (address);\\n function proposer() external view returns (address);\\n function PROPOSER() external view returns (address);\\n function batcherHash() external view returns (bytes32);\\n function admin() external view returns (address);\\n function owner() external view returns (address);\\n function unsafeBlockSigner() external view returns (address);\\n function weth() external view returns (address);\\n}\\n\\ncontract FetchChainInfoInput {\\n address internal _systemConfigProxy;\\n address internal _l1StandardBridgeProxy;\\n\\n function set(bytes4 _sel, address _addr) public {\\n require(_addr != address(0), \\\"FetchChainInfoInput: cannot set zero address\\\");\\n if (_sel == this.systemConfigProxy.selector) _systemConfigProxy = _addr;\\n else if (_sel == this.l1StandardBridgeProxy.selector) _l1StandardBridgeProxy = _addr;\\n else revert(\\\"FetchChainInfoInput: unknown selector\\\");\\n }\\n\\n function systemConfigProxy() public view returns (address) {\\n require(_systemConfigProxy != address(0), \\\"FetchChainInfoInput: systemConfigProxy not set\\\");\\n return _systemConfigProxy;\\n }\\n\\n function l1StandardBridgeProxy() public view returns (address) {\\n require(_l1StandardBridgeProxy != address(0), \\\"FetchChainInfoInput: l1StandardBridgeProxy not set\\\");\\n return _l1StandardBridgeProxy;\\n }\\n}\\n\\ncontract FetchChainInfoOutput {\\n // contract addresses\\n // - SuperchainContracts\\n address internal _superchainConfigProxy;\\n // - ImplementationsContracts\\n address internal _mipsImpl;\\n address internal _preimageOracleImpl;\\n // - OpChainContracts\\n address internal _addressManagerImpl;\\n address internal _ethLockboxProxy;\\n address internal _l1CrossDomainMessengerProxy;\\n address internal _l1Erc721BridgeProxy;\\n address internal _l1StandardBridgeProxy;\\n address internal _l2OutputOracleProxy;\\n address internal _optimismMintableErc20FactoryProxy;\\n address internal _optimismPortalProxy;\\n address internal _systemConfigProxy;\\n address internal _opChainProxyAdminImpl;\\n address internal _anchorStateRegistryProxy;\\n address internal _delayedWethPermissionedGameProxy;\\n address internal _delayedWethPermissionlessGameProxy;\\n address internal _disputeGameFactoryProxy;\\n address internal _faultDisputeGameImpl;\\n address internal _faultDisputeGameCannonKonaImpl;\\n address internal _permissionedDisputeGameImpl;\\n\\n // roles\\n address internal _systemConfigOwner;\\n address internal _opChainProxyAdminOwner;\\n address internal _opChainGuardian;\\n address internal _challenger;\\n address internal _proposer;\\n address internal _unsafeBlockSigner;\\n address internal _batchSubmitter;\\n\\n // fault proof status\\n bool internal _permissioned;\\n bool internal _permissionless;\\n GameType internal _respectedGameType;\\n\\n function set(bytes4 _sel, address _addr) public {\\n // SuperchainContracts\\n if (_sel == this.superchainConfigProxy.selector) _superchainConfigProxy = _addr;\\n // - ImplementationsContracts\\n else if (_sel == this.mipsImpl.selector) _mipsImpl = _addr;\\n else if (_sel == this.preimageOracleImpl.selector) _preimageOracleImpl = _addr;\\n // - OpChainContracts\\n else if (_sel == this.addressManagerImpl.selector) _addressManagerImpl = _addr;\\n else if (_sel == this.ethLockboxProxy.selector) _ethLockboxProxy = _addr;\\n else if (_sel == this.l1CrossDomainMessengerProxy.selector) _l1CrossDomainMessengerProxy = _addr;\\n else if (_sel == this.l1Erc721BridgeProxy.selector) _l1Erc721BridgeProxy = _addr;\\n else if (_sel == this.l1StandardBridgeProxy.selector) _l1StandardBridgeProxy = _addr;\\n else if (_sel == this.l2OutputOracleProxy.selector) _l2OutputOracleProxy = _addr;\\n else if (_sel == this.optimismMintableErc20FactoryProxy.selector) _optimismMintableErc20FactoryProxy = _addr;\\n else if (_sel == this.optimismPortalProxy.selector) _optimismPortalProxy = _addr;\\n else if (_sel == this.systemConfigProxy.selector) _systemConfigProxy = _addr;\\n else if (_sel == this.opChainProxyAdminImpl.selector) _opChainProxyAdminImpl = _addr;\\n else if (_sel == this.anchorStateRegistryProxy.selector) _anchorStateRegistryProxy = _addr;\\n else if (_sel == this.delayedWethPermissionedGameProxy.selector) _delayedWethPermissionedGameProxy = _addr;\\n else if (_sel == this.delayedWethPermissionlessGameProxy.selector) _delayedWethPermissionlessGameProxy = _addr;\\n else if (_sel == this.disputeGameFactoryProxy.selector) _disputeGameFactoryProxy = _addr;\\n else if (_sel == this.faultDisputeGameImpl.selector) _faultDisputeGameImpl = _addr;\\n else if (_sel == this.faultDisputeGameCannonKonaImpl.selector) _faultDisputeGameCannonKonaImpl = _addr;\\n else if (_sel == this.permissionedDisputeGameImpl.selector) _permissionedDisputeGameImpl = _addr;\\n // roles\\n else if (_sel == this.systemConfigOwner.selector) _systemConfigOwner = _addr;\\n else if (_sel == this.opChainProxyAdminOwner.selector) _opChainProxyAdminOwner = _addr;\\n else if (_sel == this.opChainGuardian.selector) _opChainGuardian = _addr;\\n else if (_sel == this.challenger.selector) _challenger = _addr;\\n else if (_sel == this.proposer.selector) _proposer = _addr;\\n else if (_sel == this.unsafeBlockSigner.selector) _unsafeBlockSigner = _addr;\\n else if (_sel == this.batchSubmitter.selector) _batchSubmitter = _addr;\\n else revert(\\\"FetchChainInfoOutput: unknown address selector test\\\");\\n }\\n\\n function set(bytes4 _sel, bool _bool) public {\\n if (_sel == this.permissioned.selector) _permissioned = _bool;\\n else if (_sel == this.permissionless.selector) _permissionless = _bool;\\n else revert(\\\"FetchChainInfoOutput: unknown bool selector\\\");\\n }\\n\\n function set(bytes4 _sel, GameType _gameType) public {\\n if (_sel == this.respectedGameType.selector) _respectedGameType = _gameType;\\n else revert(\\\"FetchChainInfoOutput: unknown GameType selector\\\");\\n }\\n\\n function addressManagerImpl() public view returns (address) {\\n require(_addressManagerImpl != address(0), \\\"FetchChainInfoOutput: addressManagerImpl not set\\\");\\n return _addressManagerImpl;\\n }\\n\\n function ethLockboxProxy() public view returns (address) {\\n return _ethLockboxProxy;\\n }\\n\\n function l1CrossDomainMessengerProxy() public view returns (address) {\\n require(_l1CrossDomainMessengerProxy != address(0), \\\"FetchChainInfoOutput: l1CrossDomainMessengerProxy not set\\\");\\n return _l1CrossDomainMessengerProxy;\\n }\\n\\n function l1Erc721BridgeProxy() public view returns (address) {\\n require(_l1Erc721BridgeProxy != address(0), \\\"FetchChainInfoOutput: l1Erc721BridgeProxy not set\\\");\\n return _l1Erc721BridgeProxy;\\n }\\n\\n function l1StandardBridgeProxy() public view returns (address) {\\n require(_l1StandardBridgeProxy != address(0), \\\"FetchChainInfoOutput: l1StandardBridgeProxy not set\\\");\\n return _l1StandardBridgeProxy;\\n }\\n\\n function l2OutputOracleProxy() public view returns (address) {\\n require(_l2OutputOracleProxy != address(0), \\\"FetchChainInfoOutput: l2OutputOracleProxy not set\\\");\\n return _l2OutputOracleProxy;\\n }\\n\\n function optimismMintableErc20FactoryProxy() public view returns (address) {\\n require(\\n _optimismMintableErc20FactoryProxy != address(0),\\n \\\"FetchChainInfoOutput: optimismMintableErc20FactoryProxy not set\\\"\\n );\\n return _optimismMintableErc20FactoryProxy;\\n }\\n\\n function optimismPortalProxy() public view returns (address) {\\n require(_optimismPortalProxy != address(0), \\\"FetchChainInfoOutput: optimismPortalProxy not set\\\");\\n return _optimismPortalProxy;\\n }\\n\\n function systemConfigProxy() public view returns (address) {\\n require(_systemConfigProxy != address(0), \\\"FetchChainInfoOutput: systemConfigProxy not set\\\");\\n return _systemConfigProxy;\\n }\\n\\n function opChainProxyAdminImpl() public view returns (address) {\\n require(_opChainProxyAdminImpl != address(0), \\\"FetchChainInfoOutput: opChainProxyAdminImpl not set\\\");\\n return _opChainProxyAdminImpl;\\n }\\n\\n function superchainConfigProxy() public view returns (address) {\\n require(_superchainConfigProxy != address(0), \\\"FetchChainInfoOutput: superchainConfigProxy not set\\\");\\n return _superchainConfigProxy;\\n }\\n\\n function anchorStateRegistryProxy() public view returns (address) {\\n require(_anchorStateRegistryProxy != address(0), \\\"FetchChainInfoOutput: anchorStateRegistryProxy not set\\\");\\n return _anchorStateRegistryProxy;\\n }\\n\\n function delayedWethPermissionedGameProxy() public view returns (address) {\\n return _delayedWethPermissionedGameProxy;\\n }\\n\\n function delayedWethPermissionlessGameProxy() public view returns (address) {\\n return _delayedWethPermissionlessGameProxy;\\n }\\n\\n function disputeGameFactoryProxy() public view returns (address) {\\n return _disputeGameFactoryProxy;\\n }\\n\\n function faultDisputeGameImpl() public view returns (address) {\\n require(_faultDisputeGameImpl != address(0), \\\"FetchChainInfoOutput: faultDisputeGameImpl not set\\\");\\n return _faultDisputeGameImpl;\\n }\\n\\n function faultDisputeGameCannonKonaImpl() public view returns (address) {\\n require(\\n _faultDisputeGameCannonKonaImpl != address(0),\\n \\\"FetchChainInfoOutput: faultDisputeGameCannonKonaImpl not set\\\"\\n );\\n return _faultDisputeGameCannonKonaImpl;\\n }\\n\\n function mipsImpl() public view returns (address) {\\n require(_mipsImpl != address(0), \\\"FetchChainInfoOutput: mipsImpl not set\\\");\\n return _mipsImpl;\\n }\\n\\n function permissionedDisputeGameImpl() public view returns (address) {\\n require(_permissionedDisputeGameImpl != address(0), \\\"FetchChainInfoOutput: permissionedDisputeGameImpl not set\\\");\\n return _permissionedDisputeGameImpl;\\n }\\n\\n function preimageOracleImpl() public view returns (address) {\\n require(_preimageOracleImpl != address(0), \\\"FetchChainInfoOutput: preimageOracleImpl not set\\\");\\n return _preimageOracleImpl;\\n }\\n\\n function systemConfigOwner() public view returns (address) {\\n require(_systemConfigOwner != address(0), \\\"FetchChainInfoOutput: systemConfigOwner not set\\\");\\n return _systemConfigOwner;\\n }\\n\\n function opChainProxyAdminOwner() public view returns (address) {\\n require(_opChainProxyAdminOwner != address(0), \\\"FetchChainInfoOutput: opChainProxyAdminOwner not set\\\");\\n return _opChainProxyAdminOwner;\\n }\\n\\n function opChainGuardian() public view returns (address) {\\n require(_opChainGuardian != address(0), \\\"FetchChainInfoOutput: opChainGuardian not set\\\");\\n return _opChainGuardian;\\n }\\n\\n function challenger() public view returns (address) {\\n require(_challenger != address(0), \\\"FetchChainInfoOutput: challenger not set\\\");\\n return _challenger;\\n }\\n\\n function proposer() public view returns (address) {\\n require(_proposer != address(0), \\\"FetchChainInfoOutput: proposer not set\\\");\\n return _proposer;\\n }\\n\\n function unsafeBlockSigner() public view returns (address) {\\n require(_unsafeBlockSigner != address(0), \\\"FetchChainInfoOutput: unsafeBlockSigner not set\\\");\\n return _unsafeBlockSigner;\\n }\\n\\n function batchSubmitter() public view returns (address) {\\n require(_batchSubmitter != address(0), \\\"FetchChainInfoOutput: batchSubmitter not set\\\");\\n return _batchSubmitter;\\n }\\n\\n function permissioned() public view returns (bool) {\\n return _permissioned;\\n }\\n\\n function permissionless() public view returns (bool) {\\n return _permissionless;\\n }\\n\\n function respectedGameType() public view returns (GameType) {\\n return _respectedGameType;\\n }\\n}\\n\\ncontract FetchChainInfo is Script {\\n function run(FetchChainInfoInput _fi, FetchChainInfoOutput _fo) public {\\n _processSystemConfig(_fi, _fo);\\n _processMessengerAndPortal(_fi, _fo);\\n _processFaultProofs(_fo);\\n }\\n\\n function _processSystemConfig(FetchChainInfoInput _fi, FetchChainInfoOutput _fo) internal {\\n address systemConfigProxy = _fi.systemConfigProxy();\\n _fo.set(_fo.systemConfigProxy.selector, systemConfigProxy);\\n\\n address systemConfigOwner = IFetcher(systemConfigProxy).owner();\\n _fo.set(_fo.systemConfigOwner.selector, systemConfigOwner);\\n\\n address unsafeBlockSigner = IFetcher(systemConfigProxy).unsafeBlockSigner();\\n _fo.set(_fo.unsafeBlockSigner.selector, unsafeBlockSigner);\\n\\n address batchSubmitter = _getBatchSubmitter(systemConfigProxy);\\n _fo.set(_fo.batchSubmitter.selector, batchSubmitter);\\n\\n address opChainProxyAdminImpl = _getProxyAdmin(systemConfigProxy);\\n _fo.set(_fo.opChainProxyAdminImpl.selector, opChainProxyAdminImpl);\\n\\n address opChainProxyAdminOwner = IFetcher(opChainProxyAdminImpl).owner();\\n _fo.set(_fo.opChainProxyAdminOwner.selector, opChainProxyAdminOwner);\\n\\n address l1Erc721BridgeProxy = _getL1ERC721BridgeProxy(systemConfigProxy);\\n _fo.set(_fo.l1Erc721BridgeProxy.selector, l1Erc721BridgeProxy);\\n\\n address optimismMintableErc20FactoryProxy = _getOptimismMintableERC20FactoryProxy(systemConfigProxy);\\n _fo.set(_fo.optimismMintableErc20FactoryProxy.selector, optimismMintableErc20FactoryProxy);\\n }\\n\\n function _processMessengerAndPortal(FetchChainInfoInput _fi, FetchChainInfoOutput _fo) internal {\\n address l1StandardBridgeProxy = _fi.l1StandardBridgeProxy();\\n _fo.set(_fo.l1StandardBridgeProxy.selector, l1StandardBridgeProxy);\\n\\n address l1CrossDomainMessengerProxy = IFetcher(l1StandardBridgeProxy).messenger();\\n _fo.set(_fo.l1CrossDomainMessengerProxy.selector, l1CrossDomainMessengerProxy);\\n\\n address addressManagerImpl = _getAddressManager(l1CrossDomainMessengerProxy);\\n _fo.set(_fo.addressManagerImpl.selector, addressManagerImpl);\\n\\n address optimismPortalProxy = _getOptimismPortalProxy(l1CrossDomainMessengerProxy);\\n _fo.set(_fo.optimismPortalProxy.selector, optimismPortalProxy);\\n\\n address opChainGuardian = _getGuardian(optimismPortalProxy);\\n _fo.set(_fo.opChainGuardian.selector, opChainGuardian);\\n\\n address ethLockboxProxy = _getEthLockboxProxy(optimismPortalProxy);\\n _fo.set(_fo.ethLockboxProxy.selector, ethLockboxProxy);\\n\\n address superchainConfigProxy = _getSuperchainConfigProxy(optimismPortalProxy);\\n _fo.set(_fo.superchainConfigProxy.selector, superchainConfigProxy);\\n }\\n\\n function _processFaultProofs(FetchChainInfoOutput _fo) internal {\\n address systemConfigProxy = _fo.systemConfigProxy();\\n address optimismPortalProxy = _fo.optimismPortalProxy();\\n\\n try IFetcher(optimismPortalProxy).respectedGameType() returns (GameType gameType_) {\\n _fo.set(_fo.respectedGameType.selector, gameType_);\\n } catch {\\n // default respectedGameType to uint32.max since 0 == CANNON\\n _fo.set(_fo.respectedGameType.selector, GameType.wrap(type(uint32).max));\\n address l2OutputOracleProxy;\\n try IFetcher(optimismPortalProxy).l2Oracle() returns (address l2Oracle_) {\\n l2OutputOracleProxy = l2Oracle_;\\n } catch {\\n l2OutputOracleProxy = IFetcher(optimismPortalProxy).L2_ORACLE();\\n }\\n _fo.set(_fo.l2OutputOracleProxy.selector, l2OutputOracleProxy);\\n\\n address proposer = IFetcher(l2OutputOracleProxy).PROPOSER();\\n _fo.set(_fo.proposer.selector, proposer);\\n\\n // no fault proofs installed so we're done\\n return;\\n }\\n\\n address disputeGameFactoryProxy = _getDisputeGameFactoryProxy(systemConfigProxy);\\n if (disputeGameFactoryProxy != address(0)) {\\n _fo.set(_fo.disputeGameFactoryProxy.selector, disputeGameFactoryProxy);\\n\\n address permissionedDisputeGameImpl = _getPermissionedDisputeGame(disputeGameFactoryProxy);\\n if (permissionedDisputeGameImpl != address(0)) {\\n // permissioned fault proofs installed\\n _fo.set(_fo.permissioned.selector, true);\\n _fo.set(_fo.permissionedDisputeGameImpl.selector, permissionedDisputeGameImpl);\\n\\n address challenger = IFetcher(permissionedDisputeGameImpl).challenger();\\n _fo.set(_fo.challenger.selector, challenger);\\n\\n address anchorStateRegistryProxy = IFetcher(permissionedDisputeGameImpl).anchorStateRegistry();\\n _fo.set(_fo.anchorStateRegistryProxy.selector, anchorStateRegistryProxy);\\n\\n address proposer = IFetcher(permissionedDisputeGameImpl).proposer();\\n _fo.set(_fo.proposer.selector, proposer);\\n\\n address delayedWethPermissionedGameProxy = _getDelayedWETHProxy(permissionedDisputeGameImpl);\\n _fo.set(_fo.delayedWethPermissionedGameProxy.selector, delayedWethPermissionedGameProxy);\\n\\n address mipsImpl = IFetcher(permissionedDisputeGameImpl).vm();\\n _fo.set(_fo.mipsImpl.selector, mipsImpl);\\n\\n address preimageOracleImpl = IFetcher(mipsImpl).oracle();\\n _fo.set(_fo.preimageOracleImpl.selector, preimageOracleImpl);\\n }\\n\\n address faultDisputeGameImpl = _getFaultDisputeGame(disputeGameFactoryProxy);\\n if (faultDisputeGameImpl != address(0)) {\\n // permissionless fault proofs installed\\n _fo.set(_fo.faultDisputeGameImpl.selector, faultDisputeGameImpl);\\n _fo.set(_fo.permissionless.selector, true);\\n\\n address delayedWethPermissionlessGameProxy = _getDelayedWETHProxy(faultDisputeGameImpl);\\n _fo.set(_fo.delayedWethPermissionlessGameProxy.selector, delayedWethPermissionlessGameProxy);\\n }\\n\\n address faultDisputeGameCannonKonaImpl =\\n _getFaultDisputeGame(disputeGameFactoryProxy, GameTypes.CANNON_KONA);\\n if (faultDisputeGameCannonKonaImpl != address(0)) {\\n _fo.set(_fo.faultDisputeGameCannonKonaImpl.selector, faultDisputeGameCannonKonaImpl);\\n }\\n } else {\\n // some older chains have L2OutputOracle instead of DisputeGameFactory.\\n address l2OutputOracleProxy = IFetcher(optimismPortalProxy).L2_ORACLE();\\n _fo.set(_fo.l2OutputOracleProxy.selector, l2OutputOracleProxy);\\n address proposer = IFetcher(l2OutputOracleProxy).PROPOSER();\\n _fo.set(_fo.proposer.selector, proposer);\\n }\\n }\\n\\n function _getGuardian(address _portal) internal view returns (address) {\\n try IFetcher(_portal).guardian() returns (address guardian_) {\\n return guardian_;\\n } catch {\\n return IFetcher(_portal).GUARDIAN();\\n }\\n }\\n\\n function _getSystemConfigProxy(address _portal) internal view returns (address) {\\n try IFetcher(_portal).systemConfig() returns (address systemConfig_) {\\n return systemConfig_;\\n } catch {\\n return IFetcher(_portal).SYSTEM_CONFIG();\\n }\\n }\\n\\n function _getOptimismPortalProxy(address _l1CrossDomainMessengerProxy) internal view returns (address) {\\n try IFetcher(_l1CrossDomainMessengerProxy).portal() returns (address optimismPortal_) {\\n return optimismPortal_;\\n } catch {\\n return IFetcher(_l1CrossDomainMessengerProxy).PORTAL();\\n }\\n }\\n\\n function _getAddressManager(address _l1CrossDomainMessengerProxy) internal view returns (address) {\\n uint256 ADDRESS_MANAGER_MAPPING_SLOT = 1;\\n bytes32 slot = keccak256(abi.encode(_l1CrossDomainMessengerProxy, ADDRESS_MANAGER_MAPPING_SLOT));\\n return address(uint160(uint256((vm.load(_l1CrossDomainMessengerProxy, slot)))));\\n }\\n\\n function _getL1ERC721BridgeProxy(address _systemConfigProxy) internal view returns (address) {\\n try IFetcher(_systemConfigProxy).l1ERC721Bridge() returns (address l1ERC721BridgeProxy_) {\\n return l1ERC721BridgeProxy_;\\n } catch {\\n return address(0);\\n }\\n }\\n\\n function _getOptimismMintableERC20FactoryProxy(address _systemConfigProxy) internal view returns (address) {\\n try IFetcher(_systemConfigProxy).optimismMintableERC20Factory() returns (\\n address optimismMintableERC20FactoryProxy_\\n ) {\\n return optimismMintableERC20FactoryProxy_;\\n } catch {\\n return address(0);\\n }\\n }\\n\\n function _getDisputeGameFactoryProxy(address _systemConfigProxy) internal view returns (address) {\\n try IFetcher(_systemConfigProxy).disputeGameFactory() returns (address disputeGameFactoryProxy_) {\\n return disputeGameFactoryProxy_;\\n } catch {\\n // Some older chains have L2OutputOracle instead of DisputeGameFactory\\n return address(0);\\n }\\n }\\n\\n function _getSuperchainConfigProxy(address _optimismPortalProxy) internal view returns (address) {\\n try IFetcher(_optimismPortalProxy).superchainConfig() returns (address superchainConfigProxy_) {\\n return superchainConfigProxy_;\\n } catch {\\n return address(0);\\n }\\n }\\n\\n function _getFaultDisputeGame(address _disputeGameFactoryProxy) internal view returns (address) {\\n try IFetcher(_disputeGameFactoryProxy).gameImpls(GameTypes.CANNON) returns (address faultDisputeGame_) {\\n return faultDisputeGame_;\\n } catch {\\n return address(0);\\n }\\n }\\n\\n function _getFaultDisputeGame(\\n address _disputeGameFactoryProxy,\\n GameType _gameType\\n )\\n internal\\n view\\n returns (address)\\n {\\n try IFetcher(_disputeGameFactoryProxy).gameImpls(_gameType) returns (address faultDisputeGame_) {\\n return faultDisputeGame_;\\n } catch {\\n return address(0);\\n }\\n }\\n\\n function _getPermissionedDisputeGame(address _disputeGameFactoryProxy) internal view returns (address) {\\n try IFetcher(_disputeGameFactoryProxy).gameImpls(GameTypes.PERMISSIONED_CANNON) returns (\\n address permissionedDisputeGame_\\n ) {\\n return permissionedDisputeGame_;\\n } catch {\\n return address(0);\\n }\\n }\\n\\n function _getEthLockboxProxy(address _optimismPortalProxy) internal view returns (address) {\\n try IFetcher(_optimismPortalProxy).ethLockbox() returns (address ethLockbox_) {\\n return ethLockbox_;\\n } catch {\\n return address(0);\\n }\\n }\\n\\n function _getDelayedWETHProxy(address _disputeGame) internal view returns (address) {\\n (bool ok, bytes memory data) = address(_disputeGame).staticcall(abi.encodeCall(IFetcher.weth, ()));\\n if (ok && data.length == 32) return abi.decode(data, (address));\\n else return address(0);\\n }\\n\\n function _getBatchSubmitter(address _systemConfigProxy) internal view returns (address) {\\n bytes32 batcherHash = IFetcher(_systemConfigProxy).batcherHash();\\n return address(uint160(uint256(batcherHash)));\\n }\\n\\n function _getProxyAdmin(address _systemConfigProxy) internal returns (address) {\\n vm.prank(address(0));\\n return IFetcher(_systemConfigProxy).admin();\\n }\\n}\\n\",\"keccak256\":\"0xb90e4f9a834c4dc584b4ad8c0503e35fdd8338533e0e75a7ca497f655ae12821\",\"license\":\"MIT\"},\"src/dispute/lib/LibPosition.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.15;\\n\\nusing LibPosition for Position global;\\n\\n/// @notice A `Position` represents a position of a claim within the game tree.\\n/// @dev This is represented as a \\\"generalized index\\\" where the high-order bit\\n/// is the level in the tree and the remaining bits is a unique bit pattern, allowing\\n/// a unique identifier for each node in the tree. Mathematically, it is calculated\\n/// as 2^{depth} + indexAtDepth.\\ntype Position is uint128;\\n\\n/// @title LibPosition\\n/// @notice This library contains helper functions for working with the `Position` type.\\nlibrary LibPosition {\\n /// @notice the `MAX_POSITION_BITLEN` is the number of bits that the `Position` type, and the implementation of\\n /// its behavior within this library, can safely support.\\n uint8 internal constant MAX_POSITION_BITLEN = 126;\\n\\n /// @notice Computes a generalized index (2^{depth} + indexAtDepth).\\n /// @param _depth The depth of the position.\\n /// @param _indexAtDepth The index at the depth of the position.\\n /// @return position_ The computed generalized index.\\n function wrap(uint8 _depth, uint128 _indexAtDepth) internal pure returns (Position position_) {\\n assembly {\\n // gindex = 2^{_depth} + _indexAtDepth\\n position_ := add(shl(_depth, 1), _indexAtDepth)\\n }\\n }\\n\\n /// @notice Pulls the `depth` out of a `Position` type.\\n /// @param _position The generalized index to get the `depth` of.\\n /// @return depth_ The `depth` of the `position` gindex.\\n /// @custom:attribution Solady \\n function depth(Position _position) internal pure returns (uint8 depth_) {\\n // Return the most significant bit offset, which signifies the depth of the gindex.\\n assembly {\\n depth_ := or(depth_, shl(6, lt(0xffffffffffffffff, shr(depth_, _position))))\\n depth_ := or(depth_, shl(5, lt(0xffffffff, shr(depth_, _position))))\\n\\n // For the remaining 32 bits, use a De Bruijn lookup.\\n _position := shr(depth_, _position)\\n _position := or(_position, shr(1, _position))\\n _position := or(_position, shr(2, _position))\\n _position := or(_position, shr(4, _position))\\n _position := or(_position, shr(8, _position))\\n _position := or(_position, shr(16, _position))\\n\\n depth_ :=\\n or(\\n depth_,\\n byte(\\n shr(251, mul(_position, shl(224, 0x07c4acdd))),\\n 0x0009010a0d15021d0b0e10121619031e080c141c0f111807131b17061a05041f\\n )\\n )\\n }\\n }\\n\\n /// @notice Pulls the `indexAtDepth` out of a `Position` type.\\n /// The `indexAtDepth` is the left/right index of a position at a specific depth within\\n /// the binary tree, starting from index 0. For example, at gindex 2, the `depth` = 1\\n /// and the `indexAtDepth` = 0.\\n /// @param _position The generalized index to get the `indexAtDepth` of.\\n /// @return indexAtDepth_ The `indexAtDepth` of the `position` gindex.\\n function indexAtDepth(Position _position) internal pure returns (uint128 indexAtDepth_) {\\n // Return bits p_{msb-1}...p_{0}. This effectively pulls the 2^{depth} out of the gindex,\\n // leaving only the `indexAtDepth`.\\n uint256 msb = depth(_position);\\n assembly {\\n indexAtDepth_ := sub(_position, shl(msb, 1))\\n }\\n }\\n\\n /// @notice Get the left child of `_position`.\\n /// @param _position The position to get the left position of.\\n /// @return left_ The position to the left of `position`.\\n function left(Position _position) internal pure returns (Position left_) {\\n assembly {\\n left_ := shl(1, _position)\\n }\\n }\\n\\n /// @notice Get the right child of `_position`\\n /// @param _position The position to get the right position of.\\n /// @return right_ The position to the right of `position`.\\n function right(Position _position) internal pure returns (Position right_) {\\n assembly {\\n right_ := or(1, shl(1, _position))\\n }\\n }\\n\\n /// @notice Get the parent position of `_position`.\\n /// @param _position The position to get the parent position of.\\n /// @return parent_ The parent position of `position`.\\n function parent(Position _position) internal pure returns (Position parent_) {\\n assembly {\\n parent_ := shr(1, _position)\\n }\\n }\\n\\n /// @notice Get the deepest, right most gindex relative to the `position`. This is equivalent to\\n /// calling `right` on a position until the maximum depth is reached.\\n /// @param _position The position to get the relative deepest, right most gindex of.\\n /// @param _maxDepth The maximum depth of the game.\\n /// @return rightIndex_ The deepest, right most gindex relative to the `position`.\\n function rightIndex(Position _position, uint256 _maxDepth) internal pure returns (Position rightIndex_) {\\n uint256 msb = depth(_position);\\n assembly {\\n let remaining := sub(_maxDepth, msb)\\n rightIndex_ := or(shl(remaining, _position), sub(shl(remaining, 1), 1))\\n }\\n }\\n\\n /// @notice Get the deepest, right most trace index relative to the `position`. This is\\n /// equivalent to calling `right` on a position until the maximum depth is reached and\\n /// then finding its index at depth.\\n /// @param _position The position to get the relative trace index of.\\n /// @param _maxDepth The maximum depth of the game.\\n /// @return traceIndex_ The trace index relative to the `position`.\\n function traceIndex(Position _position, uint256 _maxDepth) internal pure returns (uint256 traceIndex_) {\\n uint256 msb = depth(_position);\\n assembly {\\n let remaining := sub(_maxDepth, msb)\\n traceIndex_ := sub(or(shl(remaining, _position), sub(shl(remaining, 1), 1)), shl(_maxDepth, 1))\\n }\\n }\\n\\n /// @notice Gets the position of the highest ancestor of `_position` that commits to the same\\n /// trace index.\\n /// @param _position The position to get the highest ancestor of.\\n /// @return ancestor_ The highest ancestor of `position` that commits to the same trace index.\\n function traceAncestor(Position _position) internal pure returns (Position ancestor_) {\\n // Create a field with only the lowest unset bit of `_position` set.\\n Position lsb;\\n assembly {\\n lsb := and(not(_position), add(_position, 1))\\n }\\n // Find the index of the lowest unset bit within the field.\\n uint256 msb = depth(lsb);\\n // The highest ancestor that commits to the same trace index is the original position\\n // shifted right by the index of the lowest unset bit.\\n assembly {\\n let a := shr(msb, _position)\\n // Bound the ancestor to the minimum gindex, 1.\\n ancestor_ := or(a, iszero(a))\\n }\\n }\\n\\n /// @notice Gets the position of the highest ancestor of `_position` that commits to the same\\n /// trace index, while still being below `_upperBoundExclusive`.\\n /// @param _position The position to get the highest ancestor of.\\n /// @param _upperBoundExclusive The exclusive upper depth bound, used to inform where to stop in order\\n /// to not escape a sub-tree.\\n /// @return ancestor_ The highest ancestor of `position` that commits to the same trace index.\\n function traceAncestorBounded(\\n Position _position,\\n uint256 _upperBoundExclusive\\n )\\n internal\\n pure\\n returns (Position ancestor_)\\n {\\n // This function only works for positions that are below the upper bound.\\n if (_position.depth() <= _upperBoundExclusive) {\\n assembly {\\n // Revert with `ClaimAboveSplit()`\\n mstore(0x00, 0xb34b5c22)\\n revert(0x1C, 0x04)\\n }\\n }\\n\\n // Grab the global trace ancestor.\\n ancestor_ = traceAncestor(_position);\\n\\n // If the ancestor is above or at the upper bound, shift it to be below the upper bound.\\n // This should be a special case that only covers positions that commit to the final leaf\\n // in a sub-tree.\\n if (ancestor_.depth() <= _upperBoundExclusive) {\\n ancestor_ = ancestor_.rightIndex(_upperBoundExclusive + 1);\\n }\\n }\\n\\n /// @notice Get the move position of `_position`, which is the left child of:\\n /// 1. `_position` if `_isAttack` is true.\\n /// 2. `_position | 1` if `_isAttack` is false.\\n /// @param _position The position to get the relative attack/defense position of.\\n /// @param _isAttack Whether or not the move is an attack move.\\n /// @return move_ The move position relative to `position`.\\n function move(Position _position, bool _isAttack) internal pure returns (Position move_) {\\n assembly {\\n move_ := shl(1, or(iszero(_isAttack), _position))\\n }\\n }\\n\\n /// @notice Get the value of a `Position` type in the form of the underlying uint128.\\n /// @param _position The position to get the value of.\\n /// @return raw_ The value of the `position` as a uint128 type.\\n function raw(Position _position) internal pure returns (uint128 raw_) {\\n assembly {\\n raw_ := _position\\n }\\n }\\n}\\n\",\"keccak256\":\"0x7c5f19f8f54f06de2ce1c6cdcc5c7af65ac405130a4066cdaf146ca315818241\",\"license\":\"MIT\"},\"src/dispute/lib/LibUDT.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.15;\\n\\n// Libraries\\nimport { Position } from \\\"src/dispute/lib/LibPosition.sol\\\";\\n\\nusing LibClaim for Claim global;\\nusing LibHash for Hash global;\\nusing LibDuration for Duration global;\\nusing LibClock for Clock global;\\nusing LibGameId for GameId global;\\nusing LibTimestamp for Timestamp global;\\nusing LibVMStatus for VMStatus global;\\nusing LibGameType for GameType global;\\n\\n/// @notice A `Clock` represents a packed `Duration` and `Timestamp`\\n/// @dev The packed layout of this type is as follows:\\n/// \\u250c\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u252c\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2510\\n/// \\u2502 Bits \\u2502 Value \\u2502\\n/// \\u251c\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u253c\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2524\\n/// \\u2502 [0, 64) \\u2502 Duration \\u2502\\n/// \\u2502 [64, 128) \\u2502 Timestamp \\u2502\\n/// \\u2514\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2534\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2518\\ntype Clock is uint128;\\n\\n/// @title LibClock\\n/// @notice This library contains helper functions for working with the `Clock` type.\\nlibrary LibClock {\\n /// @notice Packs a `Duration` and `Timestamp` into a `Clock` type.\\n /// @param _duration The `Duration` to pack into the `Clock` type.\\n /// @param _timestamp The `Timestamp` to pack into the `Clock` type.\\n /// @return clock_ The `Clock` containing the `_duration` and `_timestamp`.\\n function wrap(Duration _duration, Timestamp _timestamp) internal pure returns (Clock clock_) {\\n assembly {\\n clock_ := or(shl(0x40, _duration), _timestamp)\\n }\\n }\\n\\n /// @notice Pull the `Duration` out of a `Clock` type.\\n /// @param _clock The `Clock` type to pull the `Duration` out of.\\n /// @return duration_ The `Duration` pulled out of `_clock`.\\n function duration(Clock _clock) internal pure returns (Duration duration_) {\\n // Shift the high-order 64 bits into the low-order 64 bits, leaving only the `duration`.\\n assembly {\\n duration_ := shr(0x40, _clock)\\n }\\n }\\n\\n /// @notice Pull the `Timestamp` out of a `Clock` type.\\n /// @param _clock The `Clock` type to pull the `Timestamp` out of.\\n /// @return timestamp_ The `Timestamp` pulled out of `_clock`.\\n function timestamp(Clock _clock) internal pure returns (Timestamp timestamp_) {\\n // Clean the high-order 192 bits by shifting the clock left and then right again, leaving\\n // only the `timestamp`.\\n assembly {\\n timestamp_ := shr(0xC0, shl(0xC0, _clock))\\n }\\n }\\n\\n /// @notice Get the value of a `Clock` type in the form of the underlying uint128.\\n /// @param _clock The `Clock` type to get the value of.\\n /// @return clock_ The value of the `Clock` type as a uint128 type.\\n function raw(Clock _clock) internal pure returns (uint128 clock_) {\\n assembly {\\n clock_ := _clock\\n }\\n }\\n}\\n\\n/// @notice A `GameId` represents a packed 4 byte game ID, a 8 byte timestamp, and a 20 byte address.\\n/// @dev The packed layout of this type is as follows:\\n/// \\u250c\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u252c\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2510\\n/// \\u2502 Bits \\u2502 Value \\u2502\\n/// \\u251c\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u253c\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2524\\n/// \\u2502 [0, 32) \\u2502 Game Type \\u2502\\n/// \\u2502 [32, 96) \\u2502 Timestamp \\u2502\\n/// \\u2502 [96, 256) \\u2502 Address \\u2502\\n/// \\u2514\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2534\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2518\\ntype GameId is bytes32;\\n\\n/// @title LibGameId\\n/// @notice Utility functions for packing and unpacking GameIds.\\nlibrary LibGameId {\\n /// @notice Packs values into a 32 byte GameId type.\\n /// @param _gameType The game type.\\n /// @param _timestamp The timestamp of the game's creation.\\n /// @param _gameProxy The game proxy address.\\n /// @return gameId_ The packed GameId.\\n function pack(\\n GameType _gameType,\\n Timestamp _timestamp,\\n address _gameProxy\\n )\\n internal\\n pure\\n returns (GameId gameId_)\\n {\\n assembly {\\n gameId_ := or(or(shl(224, _gameType), shl(160, _timestamp)), _gameProxy)\\n }\\n }\\n\\n /// @notice Unpacks values from a 32 byte GameId type.\\n /// @param _gameId The packed GameId.\\n /// @return gameType_ The game type.\\n /// @return timestamp_ The timestamp of the game's creation.\\n /// @return gameProxy_ The game proxy address.\\n function unpack(GameId _gameId)\\n internal\\n pure\\n returns (GameType gameType_, Timestamp timestamp_, address gameProxy_)\\n {\\n assembly {\\n gameType_ := shr(224, _gameId)\\n timestamp_ := and(shr(160, _gameId), 0xFFFFFFFFFFFFFFFF)\\n gameProxy_ := and(_gameId, 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF)\\n }\\n }\\n}\\n\\n/// @notice A claim represents an MPT root representing the state of the fault proof program.\\ntype Claim is bytes32;\\n\\n/// @title LibClaim\\n/// @notice This library contains helper functions for working with the `Claim` type.\\nlibrary LibClaim {\\n /// @notice Get the value of a `Claim` type in the form of the underlying bytes32.\\n /// @param _claim The `Claim` type to get the value of.\\n /// @return claim_ The value of the `Claim` type as a bytes32 type.\\n function raw(Claim _claim) internal pure returns (bytes32 claim_) {\\n assembly {\\n claim_ := _claim\\n }\\n }\\n\\n /// @notice Hashes a claim and a position together.\\n /// @param _claim A Claim type.\\n /// @param _position The position of `claim`.\\n /// @param _challengeIndex The index of the claim being moved against.\\n /// @return claimHash_ A hash of abi.encodePacked(claim, position|challengeIndex);\\n function hashClaimPos(\\n Claim _claim,\\n Position _position,\\n uint256 _challengeIndex\\n )\\n internal\\n pure\\n returns (Hash claimHash_)\\n {\\n assembly {\\n mstore(0x00, _claim)\\n mstore(0x20, or(shl(128, _position), and(0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF, _challengeIndex)))\\n claimHash_ := keccak256(0x00, 0x40)\\n }\\n }\\n}\\n\\n/// @notice A dedicated duration type.\\n/// @dev Unit: seconds\\ntype Duration is uint64;\\n\\n/// @title LibDuration\\n/// @notice This library contains helper functions for working with the `Duration` type.\\nlibrary LibDuration {\\n /// @notice Get the value of a `Duration` type in the form of the underlying uint64.\\n /// @param _duration The `Duration` type to get the value of.\\n /// @return duration_ The value of the `Duration` type as a uint64 type.\\n function raw(Duration _duration) internal pure returns (uint64 duration_) {\\n assembly {\\n duration_ := _duration\\n }\\n }\\n}\\n\\n/// @notice A custom type for a generic hash.\\ntype Hash is bytes32;\\n\\n/// @title LibHash\\n/// @notice This library contains helper functions for working with the `Hash` type.\\nlibrary LibHash {\\n /// @notice Get the value of a `Hash` type in the form of the underlying bytes32.\\n /// @param _hash The `Hash` type to get the value of.\\n /// @return hash_ The value of the `Hash` type as a bytes32 type.\\n function raw(Hash _hash) internal pure returns (bytes32 hash_) {\\n assembly {\\n hash_ := _hash\\n }\\n }\\n}\\n\\n/// @notice A dedicated timestamp type.\\ntype Timestamp is uint64;\\n\\n/// @title LibTimestamp\\n/// @notice This library contains helper functions for working with the `Timestamp` type.\\nlibrary LibTimestamp {\\n /// @notice Get the value of a `Timestamp` type in the form of the underlying uint64.\\n /// @param _timestamp The `Timestamp` type to get the value of.\\n /// @return timestamp_ The value of the `Timestamp` type as a uint64 type.\\n function raw(Timestamp _timestamp) internal pure returns (uint64 timestamp_) {\\n assembly {\\n timestamp_ := _timestamp\\n }\\n }\\n}\\n\\n/// @notice A `VMStatus` represents the status of a VM execution.\\ntype VMStatus is uint8;\\n\\n/// @title LibVMStatus\\n/// @notice This library contains helper functions for working with the `VMStatus` type.\\nlibrary LibVMStatus {\\n /// @notice Get the value of a `VMStatus` type in the form of the underlying uint8.\\n /// @param _vmstatus The `VMStatus` type to get the value of.\\n /// @return vmstatus_ The value of the `VMStatus` type as a uint8 type.\\n function raw(VMStatus _vmstatus) internal pure returns (uint8 vmstatus_) {\\n assembly {\\n vmstatus_ := _vmstatus\\n }\\n }\\n}\\n\\n/// @notice A `GameType` represents the type of game being played.\\ntype GameType is uint32;\\n\\n/// @title LibGameType\\n/// @notice This library contains helper functions for working with the `GameType` type.\\nlibrary LibGameType {\\n /// @notice Get the value of a `GameType` type in the form of the underlying uint32.\\n /// @param _gametype The `GameType` type to get the value of.\\n /// @return gametype_ The value of the `GameType` type as a uint32 type.\\n function raw(GameType _gametype) internal pure returns (uint32 gametype_) {\\n assembly {\\n gametype_ := _gametype\\n }\\n }\\n}\\n\",\"keccak256\":\"0x41d55e9c74d979b5b797198e38449e7cef4f925e04d61f7699e9c150c4a659d3\",\"license\":\"MIT\"},\"src/dispute/lib/Types.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.15;\\n\\n// Libraries\\nimport {\\n Position,\\n Hash,\\n GameType,\\n VMStatus,\\n Timestamp,\\n Duration,\\n Clock,\\n GameId,\\n Claim,\\n LibGameId,\\n LibClock\\n} from \\\"src/dispute/lib/LibUDT.sol\\\";\\n\\n/// @notice The current status of the dispute game.\\nenum GameStatus {\\n // The game is currently in progress, and has not been resolved.\\n IN_PROGRESS,\\n // The game has concluded, and the `rootClaim` was challenged successfully.\\n CHALLENGER_WINS,\\n // The game has concluded, and the `rootClaim` could not be contested.\\n DEFENDER_WINS\\n}\\n\\n/// @notice The game's bond distribution type. Games are expected to start in the `UNDECIDED`\\n/// state, and then choose either `NORMAL` or `REFUND`.\\nenum BondDistributionMode {\\n // Bond distribution strategy has not been chosen.\\n UNDECIDED,\\n // Bonds should be distributed as normal.\\n NORMAL,\\n // Bonds should be refunded to claimants.\\n REFUND\\n}\\n\\n/// @notice Represents an L2 root and the L2 sequence number at which it was generated.\\n/// @custom:field root The output root.\\n/// @custom:field l2SequenceNumber The L2 Sequence Number ( e.g. block number / timestamp) at which the root was\\n/// generated.\\nstruct Proposal {\\n Hash root;\\n uint256 l2SequenceNumber;\\n}\\n\\n/// @title GameTypes\\n/// @notice A library that defines the IDs of games that can be played.\\nlibrary GameTypes {\\n /// @dev A dispute game type the uses the cannon vm.\\n GameType internal constant CANNON = GameType.wrap(0);\\n\\n /// @dev A permissioned dispute game type that uses the cannon vm.\\n GameType internal constant PERMISSIONED_CANNON = GameType.wrap(1);\\n\\n /// @notice A dispute game type that uses the asterisc vm.\\n GameType internal constant ASTERISC = GameType.wrap(2);\\n\\n /// @notice A dispute game type that uses the asterisc vm with Kona.\\n GameType internal constant ASTERISC_KONA = GameType.wrap(3);\\n\\n /// @notice A dispute game type that uses the cannon vm (Super Roots).\\n GameType internal constant SUPER_CANNON = GameType.wrap(4);\\n\\n /// @notice A dispute game type that uses the permissioned cannon vm (Super Roots).\\n GameType internal constant SUPER_PERMISSIONED_CANNON = GameType.wrap(5);\\n\\n /// @notice A dispute game type that uses OP Succinct\\n GameType internal constant OP_SUCCINCT = GameType.wrap(6);\\n\\n /// @notice A dispute game type that uses the asterisc vm with Kona (Super Roots).\\n GameType internal constant SUPER_ASTERISC_KONA = GameType.wrap(7);\\n\\n /// @notice A dispute game type that uses the cannon vm with Kona.\\n GameType internal constant CANNON_KONA = GameType.wrap(8);\\n\\n /// @notice A dispute game type that uses the cannon vm with Kona (Super Roots).\\n GameType internal constant SUPER_CANNON_KONA = GameType.wrap(9);\\n\\n /// @notice A dispute game type with short game duration for testing withdrawals.\\n /// Not intended for production use.\\n GameType internal constant FAST = GameType.wrap(254);\\n\\n /// @notice A dispute game type that uses an alphabet vm.\\n /// Not intended for production use.\\n GameType internal constant ALPHABET = GameType.wrap(255);\\n\\n /// @notice A dispute game type that uses RISC Zero's Kailua\\n GameType internal constant KAILUA = GameType.wrap(1337);\\n}\\n\\n/// @title VMStatuses\\n/// @notice Named type aliases for the various valid VM status bytes.\\nlibrary VMStatuses {\\n /// @notice The VM has executed successfully and the outcome is valid.\\n VMStatus internal constant VALID = VMStatus.wrap(0);\\n\\n /// @notice The VM has executed successfully and the outcome is invalid.\\n VMStatus internal constant INVALID = VMStatus.wrap(1);\\n\\n /// @notice The VM has paniced.\\n VMStatus internal constant PANIC = VMStatus.wrap(2);\\n\\n /// @notice The VM execution is still in progress.\\n VMStatus internal constant UNFINISHED = VMStatus.wrap(3);\\n}\\n\\n/// @title LocalPreimageKey\\n/// @notice Named type aliases for local `PreimageOracle` key identifiers.\\nlibrary LocalPreimageKey {\\n /// @notice The identifier for the L1 head hash.\\n uint256 internal constant L1_HEAD_HASH = 0x01;\\n\\n /// @notice The identifier for the starting output root.\\n uint256 internal constant STARTING_OUTPUT_ROOT = 0x02;\\n\\n /// @notice The identifier for the disputed output root.\\n uint256 internal constant DISPUTED_OUTPUT_ROOT = 0x03;\\n\\n /// @notice The identifier for the disputed L2 block number.\\n uint256 internal constant DISPUTED_L2_BLOCK_NUMBER = 0x04;\\n\\n /// @notice The identifier for the chain ID.\\n uint256 internal constant CHAIN_ID = 0x05;\\n}\\n\",\"keccak256\":\"0x468fccc8d6ce3ac5b87bdd5002f84b315ac861be7655ceef87a018f596c410a1\",\"license\":\"MIT\"}},\"version\":1}","metadata":{"compiler":{"version":"0.8.27+commit.40a35a09"},"language":"Solidity","output":{"abi":[{"inputs":[],"stateMutability":"view","type":"function","name":"IS_SCRIPT","outputs":[{"internalType":"bool","name":"","type":"bool"}]},{"inputs":[{"internalType":"contract FetchChainInfoInput","name":"_fi","type":"address"},{"internalType":"contract FetchChainInfoOutput","name":"_fo","type":"address"}],"stateMutability":"nonpayable","type":"function","name":"run"}],"devdoc":{"kind":"dev","methods":{},"version":1},"userdoc":{"kind":"user","methods":{},"version":1}},"settings":{"remappings":["@lib-keccak/=lib/lib-keccak/contracts/lib/","@openzeppelin/contracts-upgradeable/=lib/openzeppelin-contracts-upgradeable/contracts/","@openzeppelin/contracts-v5/=lib/openzeppelin-contracts-v5/contracts/","@openzeppelin/contracts/=lib/openzeppelin-contracts/contracts/","@rari-capital/solmate/=lib/solmate/","@solady-test/=lib/lib-keccak/lib/solady/test/","@solady-v0.0.245/=lib/solady-v0.0.245/src/","@solady/=lib/solady/src/","ds-test/=lib/forge-std/lib/ds-test/src/","erc4626-tests/=lib/openzeppelin-contracts-v5/lib/erc4626-tests/","forge-std/=lib/forge-std/src/","interfaces/=interfaces/","kontrol-cheatcodes/=lib/kontrol-cheatcodes/src/","lib-keccak/=lib/lib-keccak/contracts/","openzeppelin-contracts-upgradeable/=lib/openzeppelin-contracts-upgradeable/","openzeppelin-contracts-v5/=lib/openzeppelin-contracts-v5/","openzeppelin-contracts/=lib/openzeppelin-contracts/","safe-contracts/=lib/safe-contracts/contracts/","solady-v0.0.245/=lib/solady-v0.0.245/src/","solady/=lib/solady/","solmate/=lib/solmate/src/"],"optimizer":{"enabled":false,"runs":0},"metadata":{"useLiteralContent":true,"bytecodeHash":"none"},"compilationTarget":{"scripts/FetchChainInfo.s.sol":"FetchChainInfo"},"evmVersion":"cancun","libraries":{}},"sources":{"lib/forge-std/src/Base.sol":{"keccak256":"0xa3735a6618a3014e42bb4329ad143e3b2c59cd95094350202e4c4a06c9d585dd","urls":[],"content":"// SPDX-License-Identifier: MIT\npragma solidity >=0.6.2 <0.9.0;\n\nimport {StdStorage} from \"./StdStorage.sol\";\nimport {Vm, VmSafe} from \"./Vm.sol\";\n\nabstract contract CommonBase {\n /// @dev Cheat code address.\n /// Calculated as `address(uint160(uint256(keccak256(\"hevm cheat code\"))))`.\n address internal constant VM_ADDRESS = 0x7109709ECfa91a80626fF3989D68f67F5b1DD12D;\n /// @dev console.sol and console2.sol work by executing a staticcall to this address.\n /// Calculated as `address(uint160(uint88(bytes11(\"console.log\"))))`.\n address internal constant CONSOLE = 0x000000000000000000636F6e736F6c652e6c6f67;\n /// @dev Used when deploying with create2.\n /// Taken from https://github.com/Arachnid/deterministic-deployment-proxy.\n address internal constant CREATE2_FACTORY = 0x4e59b44847b379578588920cA78FbF26c0B4956C;\n /// @dev The default address for tx.origin and msg.sender.\n /// Calculated as `address(uint160(uint256(keccak256(\"foundry default caller\"))))`.\n address internal constant DEFAULT_SENDER = 0x1804c8AB1F12E6bbf3894d4083f33e07309d1f38;\n /// @dev The address of the first contract `CREATE`d by a running test contract.\n /// When running tests, each test contract is `CREATE`d by `DEFAULT_SENDER` with nonce 1.\n /// Calculated as `VM.computeCreateAddress(VM.computeCreateAddress(DEFAULT_SENDER, 1), 1)`.\n address internal constant DEFAULT_TEST_CONTRACT = 0x5615dEB798BB3E4dFa0139dFa1b3D433Cc23b72f;\n /// @dev Deterministic deployment address of the Multicall3 contract.\n /// Taken from https://www.multicall3.com.\n address internal constant MULTICALL3_ADDRESS = 0xcA11bde05977b3631167028862bE2a173976CA11;\n /// @dev The order of the secp256k1 curve.\n uint256 internal constant SECP256K1_ORDER =\n 115792089237316195423570985008687907852837564279074904382605163141518161494337;\n\n uint256 internal constant UINT256_MAX =\n 115792089237316195423570985008687907853269984665640564039457584007913129639935;\n\n Vm internal constant vm = Vm(VM_ADDRESS);\n StdStorage internal stdstore;\n}\n\nabstract contract TestBase is CommonBase {}\n\nabstract contract ScriptBase is CommonBase {\n VmSafe internal constant vmSafe = VmSafe(VM_ADDRESS);\n}\n","license":"MIT"},"lib/forge-std/src/Script.sol":{"keccak256":"0xc942e27c7baae499beb01afbbae99f24d42af9a6e4aae675bc6901b704aa8e9b","urls":[],"content":"// SPDX-License-Identifier: MIT\npragma solidity >=0.6.2 <0.9.0;\n\n// 💬 ABOUT\n// Forge Std's default Script.\n\n// 🧩 MODULES\nimport {console} from \"./console.sol\";\nimport {console2} from \"./console2.sol\";\nimport {safeconsole} from \"./safeconsole.sol\";\nimport {StdChains} from \"./StdChains.sol\";\nimport {StdCheatsSafe} from \"./StdCheats.sol\";\nimport {StdConstants} from \"./StdConstants.sol\";\nimport {stdJson} from \"./StdJson.sol\";\nimport {stdMath} from \"./StdMath.sol\";\nimport {StdStorage, stdStorageSafe} from \"./StdStorage.sol\";\nimport {StdStyle} from \"./StdStyle.sol\";\nimport {StdUtils} from \"./StdUtils.sol\";\nimport {VmSafe} from \"./Vm.sol\";\n\n// 📦 BOILERPLATE\nimport {ScriptBase} from \"./Base.sol\";\n\n// ⭐️ SCRIPT\nabstract contract Script is ScriptBase, StdChains, StdCheatsSafe, StdUtils {\n // Note: IS_SCRIPT() must return true.\n bool public IS_SCRIPT = true;\n}\n","license":"MIT"},"lib/forge-std/src/StdChains.sol":{"keccak256":"0x200b597cd01c229633b4a2317846cac7d36d337e2381b4a2e81faac23c2ad1cf","urls":[],"content":"// SPDX-License-Identifier: MIT\npragma solidity >=0.6.2 <0.9.0;\n\nimport {VmSafe} from \"./Vm.sol\";\n\n/**\n * StdChains provides information about EVM compatible chains that can be used in scripts/tests.\n * For each chain, the chain's name, chain ID, and a default RPC URL are provided. Chains are\n * identified by their alias, which is the same as the alias in the `[rpc_endpoints]` section of\n * the `foundry.toml` file. For best UX, ensure the alias in the `foundry.toml` file match the\n * alias used in this contract, which can be found as the first argument to the\n * `setChainWithDefaultRpcUrl` call in the `initializeStdChains` function.\n *\n * There are two main ways to use this contract:\n * 1. Set a chain with `setChain(string memory chainAlias, ChainData memory chain)` or\n * `setChain(string memory chainAlias, Chain memory chain)`\n * 2. Get a chain with `getChain(string memory chainAlias)` or `getChain(uint256 chainId)`.\n *\n * The first time either of those are used, chains are initialized with the default set of RPC URLs.\n * This is done in `initializeStdChains`, which uses `setChainWithDefaultRpcUrl`. Defaults are recorded in\n * `defaultRpcUrls`.\n *\n * The `setChain` function is straightforward, and it simply saves off the given chain data.\n *\n * The `getChain` methods use `getChainWithUpdatedRpcUrl` to return a chain. For example, let's say\n * we want to retrieve the RPC URL for `mainnet`:\n * - If you have specified data with `setChain`, it will return that.\n * - If you have configured a mainnet RPC URL in `foundry.toml`, it will return the URL, provided it\n * is valid (e.g. a URL is specified, or an environment variable is given and exists).\n * - If neither of the above conditions is met, the default data is returned.\n *\n * Summarizing the above, the prioritization hierarchy is `setChain` -> `foundry.toml` -> environment variable -> defaults.\n */\nabstract contract StdChains {\n VmSafe private constant vm = VmSafe(address(uint160(uint256(keccak256(\"hevm cheat code\")))));\n\n bool private stdChainsInitialized;\n\n struct ChainData {\n string name;\n uint256 chainId;\n string rpcUrl;\n }\n\n struct Chain {\n // The chain name.\n string name;\n // The chain's Chain ID.\n uint256 chainId;\n // The chain's alias. (i.e. what gets specified in `foundry.toml`).\n string chainAlias;\n // A default RPC endpoint for this chain.\n // NOTE: This default RPC URL is included for convenience to facilitate quick tests and\n // experimentation. Do not use this RPC URL for production test suites, CI, or other heavy\n // usage as you will be throttled and this is a disservice to others who need this endpoint.\n string rpcUrl;\n }\n\n // Maps from the chain's alias (matching the alias in the `foundry.toml` file) to chain data.\n mapping(string => Chain) private chains;\n // Maps from the chain's alias to it's default RPC URL.\n mapping(string => string) private defaultRpcUrls;\n // Maps from a chain ID to it's alias.\n mapping(uint256 => string) private idToAlias;\n\n bool private fallbackToDefaultRpcUrls = true;\n\n // The RPC URL will be fetched from config or defaultRpcUrls if possible.\n function getChain(string memory chainAlias) internal virtual returns (Chain memory chain) {\n require(bytes(chainAlias).length != 0, \"StdChains getChain(string): Chain alias cannot be the empty string.\");\n\n initializeStdChains();\n chain = chains[chainAlias];\n require(\n chain.chainId != 0,\n string(abi.encodePacked(\"StdChains getChain(string): Chain with alias \\\"\", chainAlias, \"\\\" not found.\"))\n );\n\n chain = getChainWithUpdatedRpcUrl(chainAlias, chain);\n }\n\n function getChain(uint256 chainId) internal virtual returns (Chain memory chain) {\n require(chainId != 0, \"StdChains getChain(uint256): Chain ID cannot be 0.\");\n initializeStdChains();\n string memory chainAlias = idToAlias[chainId];\n\n chain = chains[chainAlias];\n\n require(\n chain.chainId != 0,\n string(abi.encodePacked(\"StdChains getChain(uint256): Chain with ID \", vm.toString(chainId), \" not found.\"))\n );\n\n chain = getChainWithUpdatedRpcUrl(chainAlias, chain);\n }\n\n // set chain info, with priority to argument's rpcUrl field.\n function setChain(string memory chainAlias, ChainData memory chain) internal virtual {\n require(\n bytes(chainAlias).length != 0,\n \"StdChains setChain(string,ChainData): Chain alias cannot be the empty string.\"\n );\n\n require(chain.chainId != 0, \"StdChains setChain(string,ChainData): Chain ID cannot be 0.\");\n\n initializeStdChains();\n string memory foundAlias = idToAlias[chain.chainId];\n\n require(\n bytes(foundAlias).length == 0 || keccak256(bytes(foundAlias)) == keccak256(bytes(chainAlias)),\n string(\n abi.encodePacked(\n \"StdChains setChain(string,ChainData): Chain ID \",\n vm.toString(chain.chainId),\n \" already used by \\\"\",\n foundAlias,\n \"\\\".\"\n )\n )\n );\n\n uint256 oldChainId = chains[chainAlias].chainId;\n delete idToAlias[oldChainId];\n\n chains[chainAlias] =\n Chain({name: chain.name, chainId: chain.chainId, chainAlias: chainAlias, rpcUrl: chain.rpcUrl});\n idToAlias[chain.chainId] = chainAlias;\n }\n\n // set chain info, with priority to argument's rpcUrl field.\n function setChain(string memory chainAlias, Chain memory chain) internal virtual {\n setChain(chainAlias, ChainData({name: chain.name, chainId: chain.chainId, rpcUrl: chain.rpcUrl}));\n }\n\n function _toUpper(string memory str) private pure returns (string memory) {\n bytes memory strb = bytes(str);\n bytes memory copy = new bytes(strb.length);\n for (uint256 i = 0; i < strb.length; i++) {\n bytes1 b = strb[i];\n if (b >= 0x61 && b <= 0x7A) {\n copy[i] = bytes1(uint8(b) - 32);\n } else {\n copy[i] = b;\n }\n }\n return string(copy);\n }\n\n // lookup rpcUrl, in descending order of priority:\n // current -> config (foundry.toml) -> environment variable -> default\n function getChainWithUpdatedRpcUrl(string memory chainAlias, Chain memory chain)\n private\n view\n returns (Chain memory)\n {\n if (bytes(chain.rpcUrl).length == 0) {\n try vm.rpcUrl(chainAlias) returns (string memory configRpcUrl) {\n chain.rpcUrl = configRpcUrl;\n } catch (bytes memory err) {\n string memory envName = string(abi.encodePacked(_toUpper(chainAlias), \"_RPC_URL\"));\n if (fallbackToDefaultRpcUrls) {\n chain.rpcUrl = vm.envOr(envName, defaultRpcUrls[chainAlias]);\n } else {\n chain.rpcUrl = vm.envString(envName);\n }\n // Distinguish 'not found' from 'cannot read'\n // The upstream error thrown by forge for failing cheats changed so we check both the old and new versions\n bytes memory oldNotFoundError =\n abi.encodeWithSignature(\"CheatCodeError\", string(abi.encodePacked(\"invalid rpc url \", chainAlias)));\n bytes memory newNotFoundError = abi.encodeWithSignature(\n \"CheatcodeError(string)\", string(abi.encodePacked(\"invalid rpc url: \", chainAlias))\n );\n bytes32 errHash = keccak256(err);\n if (\n (errHash != keccak256(oldNotFoundError) && errHash != keccak256(newNotFoundError))\n || bytes(chain.rpcUrl).length == 0\n ) {\n /// @solidity memory-safe-assembly\n assembly {\n revert(add(32, err), mload(err))\n }\n }\n }\n }\n return chain;\n }\n\n function setFallbackToDefaultRpcUrls(bool useDefault) internal {\n fallbackToDefaultRpcUrls = useDefault;\n }\n\n function initializeStdChains() private {\n if (stdChainsInitialized) return;\n\n stdChainsInitialized = true;\n\n // If adding an RPC here, make sure to test the default RPC URL in `test_Rpcs` in `StdChains.t.sol`\n setChainWithDefaultRpcUrl(\"anvil\", ChainData(\"Anvil\", 31337, \"http://127.0.0.1:8545\"));\n setChainWithDefaultRpcUrl(\"mainnet\", ChainData(\"Mainnet\", 1, \"https://eth.llamarpc.com\"));\n setChainWithDefaultRpcUrl(\n \"sepolia\", ChainData(\"Sepolia\", 11155111, \"https://sepolia.infura.io/v3/b9794ad1ddf84dfb8c34d6bb5dca2001\")\n );\n setChainWithDefaultRpcUrl(\"holesky\", ChainData(\"Holesky\", 17000, \"https://rpc.holesky.ethpandaops.io\"));\n setChainWithDefaultRpcUrl(\"optimism\", ChainData(\"Optimism\", 10, \"https://mainnet.optimism.io\"));\n setChainWithDefaultRpcUrl(\n \"optimism_sepolia\", ChainData(\"Optimism Sepolia\", 11155420, \"https://sepolia.optimism.io\")\n );\n setChainWithDefaultRpcUrl(\"arbitrum_one\", ChainData(\"Arbitrum One\", 42161, \"https://arb1.arbitrum.io/rpc\"));\n setChainWithDefaultRpcUrl(\n \"arbitrum_one_sepolia\", ChainData(\"Arbitrum One Sepolia\", 421614, \"https://sepolia-rollup.arbitrum.io/rpc\")\n );\n setChainWithDefaultRpcUrl(\"arbitrum_nova\", ChainData(\"Arbitrum Nova\", 42170, \"https://nova.arbitrum.io/rpc\"));\n setChainWithDefaultRpcUrl(\"polygon\", ChainData(\"Polygon\", 137, \"https://polygon-rpc.com\"));\n setChainWithDefaultRpcUrl(\n \"polygon_amoy\", ChainData(\"Polygon Amoy\", 80002, \"https://rpc-amoy.polygon.technology\")\n );\n setChainWithDefaultRpcUrl(\"avalanche\", ChainData(\"Avalanche\", 43114, \"https://api.avax.network/ext/bc/C/rpc\"));\n setChainWithDefaultRpcUrl(\n \"avalanche_fuji\", ChainData(\"Avalanche Fuji\", 43113, \"https://api.avax-test.network/ext/bc/C/rpc\")\n );\n setChainWithDefaultRpcUrl(\n \"bnb_smart_chain\", ChainData(\"BNB Smart Chain\", 56, \"https://bsc-dataseed1.binance.org\")\n );\n setChainWithDefaultRpcUrl(\n \"bnb_smart_chain_testnet\",\n ChainData(\"BNB Smart Chain Testnet\", 97, \"https://rpc.ankr.com/bsc_testnet_chapel\")\n );\n setChainWithDefaultRpcUrl(\"gnosis_chain\", ChainData(\"Gnosis Chain\", 100, \"https://rpc.gnosischain.com\"));\n setChainWithDefaultRpcUrl(\"moonbeam\", ChainData(\"Moonbeam\", 1284, \"https://rpc.api.moonbeam.network\"));\n setChainWithDefaultRpcUrl(\n \"moonriver\", ChainData(\"Moonriver\", 1285, \"https://rpc.api.moonriver.moonbeam.network\")\n );\n setChainWithDefaultRpcUrl(\"moonbase\", ChainData(\"Moonbase\", 1287, \"https://rpc.testnet.moonbeam.network\"));\n setChainWithDefaultRpcUrl(\"base_sepolia\", ChainData(\"Base Sepolia\", 84532, \"https://sepolia.base.org\"));\n setChainWithDefaultRpcUrl(\"base\", ChainData(\"Base\", 8453, \"https://mainnet.base.org\"));\n setChainWithDefaultRpcUrl(\"blast_sepolia\", ChainData(\"Blast Sepolia\", 168587773, \"https://sepolia.blast.io\"));\n setChainWithDefaultRpcUrl(\"blast\", ChainData(\"Blast\", 81457, \"https://rpc.blast.io\"));\n setChainWithDefaultRpcUrl(\"fantom_opera\", ChainData(\"Fantom Opera\", 250, \"https://rpc.ankr.com/fantom/\"));\n setChainWithDefaultRpcUrl(\n \"fantom_opera_testnet\", ChainData(\"Fantom Opera Testnet\", 4002, \"https://rpc.ankr.com/fantom_testnet/\")\n );\n setChainWithDefaultRpcUrl(\"fraxtal\", ChainData(\"Fraxtal\", 252, \"https://rpc.frax.com\"));\n setChainWithDefaultRpcUrl(\"fraxtal_testnet\", ChainData(\"Fraxtal Testnet\", 2522, \"https://rpc.testnet.frax.com\"));\n setChainWithDefaultRpcUrl(\n \"berachain_bartio_testnet\", ChainData(\"Berachain bArtio Testnet\", 80084, \"https://bartio.rpc.berachain.com\")\n );\n setChainWithDefaultRpcUrl(\"flare\", ChainData(\"Flare\", 14, \"https://flare-api.flare.network/ext/C/rpc\"));\n setChainWithDefaultRpcUrl(\n \"flare_coston2\", ChainData(\"Flare Coston2\", 114, \"https://coston2-api.flare.network/ext/C/rpc\")\n );\n\n setChainWithDefaultRpcUrl(\"mode\", ChainData(\"Mode\", 34443, \"https://mode.drpc.org\"));\n setChainWithDefaultRpcUrl(\"mode_sepolia\", ChainData(\"Mode Sepolia\", 919, \"https://sepolia.mode.network\"));\n\n setChainWithDefaultRpcUrl(\"zora\", ChainData(\"Zora\", 7777777, \"https://zora.drpc.org\"));\n setChainWithDefaultRpcUrl(\n \"zora_sepolia\", ChainData(\"Zora Sepolia\", 999999999, \"https://sepolia.rpc.zora.energy\")\n );\n\n setChainWithDefaultRpcUrl(\"race\", ChainData(\"Race\", 6805, \"https://racemainnet.io\"));\n setChainWithDefaultRpcUrl(\"race_sepolia\", ChainData(\"Race Sepolia\", 6806, \"https://racemainnet.io\"));\n\n setChainWithDefaultRpcUrl(\"metal\", ChainData(\"Metal\", 1750, \"https://metall2.drpc.org\"));\n setChainWithDefaultRpcUrl(\"metal_sepolia\", ChainData(\"Metal Sepolia\", 1740, \"https://testnet.rpc.metall2.com\"));\n\n setChainWithDefaultRpcUrl(\"binary\", ChainData(\"Binary\", 624, \"https://rpc.zero.thebinaryholdings.com\"));\n setChainWithDefaultRpcUrl(\n \"binary_sepolia\", ChainData(\"Binary Sepolia\", 625, \"https://rpc.zero.thebinaryholdings.com\")\n );\n\n setChainWithDefaultRpcUrl(\"orderly\", ChainData(\"Orderly\", 291, \"https://rpc.orderly.network\"));\n setChainWithDefaultRpcUrl(\n \"orderly_sepolia\", ChainData(\"Orderly Sepolia\", 4460, \"https://testnet-rpc.orderly.org\")\n );\n }\n\n // set chain info, with priority to chainAlias' rpc url in foundry.toml\n function setChainWithDefaultRpcUrl(string memory chainAlias, ChainData memory chain) private {\n string memory rpcUrl = chain.rpcUrl;\n defaultRpcUrls[chainAlias] = rpcUrl;\n chain.rpcUrl = \"\";\n setChain(chainAlias, chain);\n chain.rpcUrl = rpcUrl; // restore argument\n }\n}\n","license":"MIT"},"lib/forge-std/src/StdCheats.sol":{"keccak256":"0x0fa6ec03602648b62cce41aab2096e6b7e052f2846075d967b6958dd586db746","urls":[],"content":"// SPDX-License-Identifier: MIT\npragma solidity >=0.6.2 <0.9.0;\n\npragma experimental ABIEncoderV2;\n\nimport {StdStorage, stdStorage} from \"./StdStorage.sol\";\nimport {console2} from \"./console2.sol\";\nimport {Vm} from \"./Vm.sol\";\n\nabstract contract StdCheatsSafe {\n Vm private constant vm = Vm(address(uint160(uint256(keccak256(\"hevm cheat code\")))));\n\n uint256 private constant UINT256_MAX =\n 115792089237316195423570985008687907853269984665640564039457584007913129639935;\n\n bool private gasMeteringOff;\n\n // Data structures to parse Transaction objects from the broadcast artifact\n // that conform to EIP1559. The Raw structs is what is parsed from the JSON\n // and then converted to the one that is used by the user for better UX.\n\n struct RawTx1559 {\n string[] arguments;\n address contractAddress;\n string contractName;\n // json value name = function\n string functionSig;\n bytes32 hash;\n // json value name = tx\n RawTx1559Detail txDetail;\n // json value name = type\n string opcode;\n }\n\n struct RawTx1559Detail {\n AccessList[] accessList;\n bytes data;\n address from;\n bytes gas;\n bytes nonce;\n address to;\n bytes txType;\n bytes value;\n }\n\n struct Tx1559 {\n string[] arguments;\n address contractAddress;\n string contractName;\n string functionSig;\n bytes32 hash;\n Tx1559Detail txDetail;\n string opcode;\n }\n\n struct Tx1559Detail {\n AccessList[] accessList;\n bytes data;\n address from;\n uint256 gas;\n uint256 nonce;\n address to;\n uint256 txType;\n uint256 value;\n }\n\n // Data structures to parse Transaction objects from the broadcast artifact\n // that DO NOT conform to EIP1559. The Raw structs is what is parsed from the JSON\n // and then converted to the one that is used by the user for better UX.\n\n struct TxLegacy {\n string[] arguments;\n address contractAddress;\n string contractName;\n string functionSig;\n string hash;\n string opcode;\n TxDetailLegacy transaction;\n }\n\n struct TxDetailLegacy {\n AccessList[] accessList;\n uint256 chainId;\n bytes data;\n address from;\n uint256 gas;\n uint256 gasPrice;\n bytes32 hash;\n uint256 nonce;\n bytes1 opcode;\n bytes32 r;\n bytes32 s;\n uint256 txType;\n address to;\n uint8 v;\n uint256 value;\n }\n\n struct AccessList {\n address accessAddress;\n bytes32[] storageKeys;\n }\n\n // Data structures to parse Receipt objects from the broadcast artifact.\n // The Raw structs is what is parsed from the JSON\n // and then converted to the one that is used by the user for better UX.\n\n struct RawReceipt {\n bytes32 blockHash;\n bytes blockNumber;\n address contractAddress;\n bytes cumulativeGasUsed;\n bytes effectiveGasPrice;\n address from;\n bytes gasUsed;\n RawReceiptLog[] logs;\n bytes logsBloom;\n bytes status;\n address to;\n bytes32 transactionHash;\n bytes transactionIndex;\n }\n\n struct Receipt {\n bytes32 blockHash;\n uint256 blockNumber;\n address contractAddress;\n uint256 cumulativeGasUsed;\n uint256 effectiveGasPrice;\n address from;\n uint256 gasUsed;\n ReceiptLog[] logs;\n bytes logsBloom;\n uint256 status;\n address to;\n bytes32 transactionHash;\n uint256 transactionIndex;\n }\n\n // Data structures to parse the entire broadcast artifact, assuming the\n // transactions conform to EIP1559.\n\n struct EIP1559ScriptArtifact {\n string[] libraries;\n string path;\n string[] pending;\n Receipt[] receipts;\n uint256 timestamp;\n Tx1559[] transactions;\n TxReturn[] txReturns;\n }\n\n struct RawEIP1559ScriptArtifact {\n string[] libraries;\n string path;\n string[] pending;\n RawReceipt[] receipts;\n TxReturn[] txReturns;\n uint256 timestamp;\n RawTx1559[] transactions;\n }\n\n struct RawReceiptLog {\n // json value = address\n address logAddress;\n bytes32 blockHash;\n bytes blockNumber;\n bytes data;\n bytes logIndex;\n bool removed;\n bytes32[] topics;\n bytes32 transactionHash;\n bytes transactionIndex;\n bytes transactionLogIndex;\n }\n\n struct ReceiptLog {\n // json value = address\n address logAddress;\n bytes32 blockHash;\n uint256 blockNumber;\n bytes data;\n uint256 logIndex;\n bytes32[] topics;\n uint256 transactionIndex;\n uint256 transactionLogIndex;\n bool removed;\n }\n\n struct TxReturn {\n string internalType;\n string value;\n }\n\n struct Account {\n address addr;\n uint256 key;\n }\n\n enum AddressType {\n Payable,\n NonPayable,\n ZeroAddress,\n Precompile,\n ForgeAddress\n }\n\n // Checks that `addr` is not blacklisted by token contracts that have a blacklist.\n function assumeNotBlacklisted(address token, address addr) internal view virtual {\n // Nothing to check if `token` is not a contract.\n uint256 tokenCodeSize;\n assembly {\n tokenCodeSize := extcodesize(token)\n }\n require(tokenCodeSize > 0, \"StdCheats assumeNotBlacklisted(address,address): Token address is not a contract.\");\n\n bool success;\n bytes memory returnData;\n\n // 4-byte selector for `isBlacklisted(address)`, used by USDC.\n (success, returnData) = token.staticcall(abi.encodeWithSelector(0xfe575a87, addr));\n vm.assume(!success || abi.decode(returnData, (bool)) == false);\n\n // 4-byte selector for `isBlackListed(address)`, used by USDT.\n (success, returnData) = token.staticcall(abi.encodeWithSelector(0xe47d6060, addr));\n vm.assume(!success || abi.decode(returnData, (bool)) == false);\n }\n\n // Checks that `addr` is not blacklisted by token contracts that have a blacklist.\n // This is identical to `assumeNotBlacklisted(address,address)` but with a different name, for\n // backwards compatibility, since this name was used in the original PR which already has\n // a release. This function can be removed in a future release once we want a breaking change.\n function assumeNoBlacklisted(address token, address addr) internal view virtual {\n assumeNotBlacklisted(token, addr);\n }\n\n function assumeAddressIsNot(address addr, AddressType addressType) internal virtual {\n if (addressType == AddressType.Payable) {\n assumeNotPayable(addr);\n } else if (addressType == AddressType.NonPayable) {\n assumePayable(addr);\n } else if (addressType == AddressType.ZeroAddress) {\n assumeNotZeroAddress(addr);\n } else if (addressType == AddressType.Precompile) {\n assumeNotPrecompile(addr);\n } else if (addressType == AddressType.ForgeAddress) {\n assumeNotForgeAddress(addr);\n }\n }\n\n function assumeAddressIsNot(address addr, AddressType addressType1, AddressType addressType2) internal virtual {\n assumeAddressIsNot(addr, addressType1);\n assumeAddressIsNot(addr, addressType2);\n }\n\n function assumeAddressIsNot(\n address addr,\n AddressType addressType1,\n AddressType addressType2,\n AddressType addressType3\n ) internal virtual {\n assumeAddressIsNot(addr, addressType1);\n assumeAddressIsNot(addr, addressType2);\n assumeAddressIsNot(addr, addressType3);\n }\n\n function assumeAddressIsNot(\n address addr,\n AddressType addressType1,\n AddressType addressType2,\n AddressType addressType3,\n AddressType addressType4\n ) internal virtual {\n assumeAddressIsNot(addr, addressType1);\n assumeAddressIsNot(addr, addressType2);\n assumeAddressIsNot(addr, addressType3);\n assumeAddressIsNot(addr, addressType4);\n }\n\n // This function checks whether an address, `addr`, is payable. It works by sending 1 wei to\n // `addr` and checking the `success` return value.\n // NOTE: This function may result in state changes depending on the fallback/receive logic\n // implemented by `addr`, which should be taken into account when this function is used.\n function _isPayable(address addr) private returns (bool) {\n require(\n addr.balance < UINT256_MAX,\n \"StdCheats _isPayable(address): Balance equals max uint256, so it cannot receive any more funds\"\n );\n uint256 origBalanceTest = address(this).balance;\n uint256 origBalanceAddr = address(addr).balance;\n\n vm.deal(address(this), 1);\n (bool success,) = payable(addr).call{value: 1}(\"\");\n\n // reset balances\n vm.deal(address(this), origBalanceTest);\n vm.deal(addr, origBalanceAddr);\n\n return success;\n }\n\n // NOTE: This function may result in state changes depending on the fallback/receive logic\n // implemented by `addr`, which should be taken into account when this function is used. See the\n // `_isPayable` method for more information.\n function assumePayable(address addr) internal virtual {\n vm.assume(_isPayable(addr));\n }\n\n function assumeNotPayable(address addr) internal virtual {\n vm.assume(!_isPayable(addr));\n }\n\n function assumeNotZeroAddress(address addr) internal pure virtual {\n vm.assume(addr != address(0));\n }\n\n function assumeNotPrecompile(address addr) internal pure virtual {\n assumeNotPrecompile(addr, _pureChainId());\n }\n\n function assumeNotPrecompile(address addr, uint256 chainId) internal pure virtual {\n // Note: For some chains like Optimism these are technically predeploys (i.e. bytecode placed at a specific\n // address), but the same rationale for excluding them applies so we include those too.\n\n // These are reserved by Ethereum and may be on all EVM-compatible chains.\n vm.assume(addr < address(0x1) || addr > address(0xff));\n\n // forgefmt: disable-start\n if (chainId == 10 || chainId == 420) {\n // https://github.com/ethereum-optimism/optimism/blob/eaa371a0184b56b7ca6d9eb9cb0a2b78b2ccd864/op-bindings/predeploys/addresses.go#L6-L21\n vm.assume(addr < address(0x4200000000000000000000000000000000000000) || addr > address(0x4200000000000000000000000000000000000800));\n } else if (chainId == 42161 || chainId == 421613) {\n // https://developer.arbitrum.io/useful-addresses#arbitrum-precompiles-l2-same-on-all-arb-chains\n vm.assume(addr < address(0x0000000000000000000000000000000000000064) || addr > address(0x0000000000000000000000000000000000000068));\n } else if (chainId == 43114 || chainId == 43113) {\n // https://github.com/ava-labs/subnet-evm/blob/47c03fd007ecaa6de2c52ea081596e0a88401f58/precompile/params.go#L18-L59\n vm.assume(addr < address(0x0100000000000000000000000000000000000000) || addr > address(0x01000000000000000000000000000000000000ff));\n vm.assume(addr < address(0x0200000000000000000000000000000000000000) || addr > address(0x02000000000000000000000000000000000000FF));\n vm.assume(addr < address(0x0300000000000000000000000000000000000000) || addr > address(0x03000000000000000000000000000000000000Ff));\n }\n // forgefmt: disable-end\n }\n\n function assumeNotForgeAddress(address addr) internal pure virtual {\n // vm, console, and Create2Deployer addresses\n vm.assume(\n addr != address(vm) && addr != 0x000000000000000000636F6e736F6c652e6c6f67\n && addr != 0x4e59b44847b379578588920cA78FbF26c0B4956C\n );\n }\n\n function assumeUnusedAddress(address addr) internal view virtual {\n uint256 size;\n assembly {\n size := extcodesize(addr)\n }\n vm.assume(size == 0);\n\n assumeNotPrecompile(addr);\n assumeNotZeroAddress(addr);\n assumeNotForgeAddress(addr);\n }\n\n function readEIP1559ScriptArtifact(string memory path)\n internal\n view\n virtual\n returns (EIP1559ScriptArtifact memory)\n {\n string memory data = vm.readFile(path);\n bytes memory parsedData = vm.parseJson(data);\n RawEIP1559ScriptArtifact memory rawArtifact = abi.decode(parsedData, (RawEIP1559ScriptArtifact));\n EIP1559ScriptArtifact memory artifact;\n artifact.libraries = rawArtifact.libraries;\n artifact.path = rawArtifact.path;\n artifact.timestamp = rawArtifact.timestamp;\n artifact.pending = rawArtifact.pending;\n artifact.txReturns = rawArtifact.txReturns;\n artifact.receipts = rawToConvertedReceipts(rawArtifact.receipts);\n artifact.transactions = rawToConvertedEIPTx1559s(rawArtifact.transactions);\n return artifact;\n }\n\n function rawToConvertedEIPTx1559s(RawTx1559[] memory rawTxs) internal pure virtual returns (Tx1559[] memory) {\n Tx1559[] memory txs = new Tx1559[](rawTxs.length);\n for (uint256 i; i < rawTxs.length; i++) {\n txs[i] = rawToConvertedEIPTx1559(rawTxs[i]);\n }\n return txs;\n }\n\n function rawToConvertedEIPTx1559(RawTx1559 memory rawTx) internal pure virtual returns (Tx1559 memory) {\n Tx1559 memory transaction;\n transaction.arguments = rawTx.arguments;\n transaction.contractName = rawTx.contractName;\n transaction.functionSig = rawTx.functionSig;\n transaction.hash = rawTx.hash;\n transaction.txDetail = rawToConvertedEIP1559Detail(rawTx.txDetail);\n transaction.opcode = rawTx.opcode;\n return transaction;\n }\n\n function rawToConvertedEIP1559Detail(RawTx1559Detail memory rawDetail)\n internal\n pure\n virtual\n returns (Tx1559Detail memory)\n {\n Tx1559Detail memory txDetail;\n txDetail.data = rawDetail.data;\n txDetail.from = rawDetail.from;\n txDetail.to = rawDetail.to;\n txDetail.nonce = _bytesToUint(rawDetail.nonce);\n txDetail.txType = _bytesToUint(rawDetail.txType);\n txDetail.value = _bytesToUint(rawDetail.value);\n txDetail.gas = _bytesToUint(rawDetail.gas);\n txDetail.accessList = rawDetail.accessList;\n return txDetail;\n }\n\n function readTx1559s(string memory path) internal view virtual returns (Tx1559[] memory) {\n string memory deployData = vm.readFile(path);\n bytes memory parsedDeployData = vm.parseJson(deployData, \".transactions\");\n RawTx1559[] memory rawTxs = abi.decode(parsedDeployData, (RawTx1559[]));\n return rawToConvertedEIPTx1559s(rawTxs);\n }\n\n function readTx1559(string memory path, uint256 index) internal view virtual returns (Tx1559 memory) {\n string memory deployData = vm.readFile(path);\n string memory key = string(abi.encodePacked(\".transactions[\", vm.toString(index), \"]\"));\n bytes memory parsedDeployData = vm.parseJson(deployData, key);\n RawTx1559 memory rawTx = abi.decode(parsedDeployData, (RawTx1559));\n return rawToConvertedEIPTx1559(rawTx);\n }\n\n // Analogous to readTransactions, but for receipts.\n function readReceipts(string memory path) internal view virtual returns (Receipt[] memory) {\n string memory deployData = vm.readFile(path);\n bytes memory parsedDeployData = vm.parseJson(deployData, \".receipts\");\n RawReceipt[] memory rawReceipts = abi.decode(parsedDeployData, (RawReceipt[]));\n return rawToConvertedReceipts(rawReceipts);\n }\n\n function readReceipt(string memory path, uint256 index) internal view virtual returns (Receipt memory) {\n string memory deployData = vm.readFile(path);\n string memory key = string(abi.encodePacked(\".receipts[\", vm.toString(index), \"]\"));\n bytes memory parsedDeployData = vm.parseJson(deployData, key);\n RawReceipt memory rawReceipt = abi.decode(parsedDeployData, (RawReceipt));\n return rawToConvertedReceipt(rawReceipt);\n }\n\n function rawToConvertedReceipts(RawReceipt[] memory rawReceipts) internal pure virtual returns (Receipt[] memory) {\n Receipt[] memory receipts = new Receipt[](rawReceipts.length);\n for (uint256 i; i < rawReceipts.length; i++) {\n receipts[i] = rawToConvertedReceipt(rawReceipts[i]);\n }\n return receipts;\n }\n\n function rawToConvertedReceipt(RawReceipt memory rawReceipt) internal pure virtual returns (Receipt memory) {\n Receipt memory receipt;\n receipt.blockHash = rawReceipt.blockHash;\n receipt.to = rawReceipt.to;\n receipt.from = rawReceipt.from;\n receipt.contractAddress = rawReceipt.contractAddress;\n receipt.effectiveGasPrice = _bytesToUint(rawReceipt.effectiveGasPrice);\n receipt.cumulativeGasUsed = _bytesToUint(rawReceipt.cumulativeGasUsed);\n receipt.gasUsed = _bytesToUint(rawReceipt.gasUsed);\n receipt.status = _bytesToUint(rawReceipt.status);\n receipt.transactionIndex = _bytesToUint(rawReceipt.transactionIndex);\n receipt.blockNumber = _bytesToUint(rawReceipt.blockNumber);\n receipt.logs = rawToConvertedReceiptLogs(rawReceipt.logs);\n receipt.logsBloom = rawReceipt.logsBloom;\n receipt.transactionHash = rawReceipt.transactionHash;\n return receipt;\n }\n\n function rawToConvertedReceiptLogs(RawReceiptLog[] memory rawLogs)\n internal\n pure\n virtual\n returns (ReceiptLog[] memory)\n {\n ReceiptLog[] memory logs = new ReceiptLog[](rawLogs.length);\n for (uint256 i; i < rawLogs.length; i++) {\n logs[i].logAddress = rawLogs[i].logAddress;\n logs[i].blockHash = rawLogs[i].blockHash;\n logs[i].blockNumber = _bytesToUint(rawLogs[i].blockNumber);\n logs[i].data = rawLogs[i].data;\n logs[i].logIndex = _bytesToUint(rawLogs[i].logIndex);\n logs[i].topics = rawLogs[i].topics;\n logs[i].transactionIndex = _bytesToUint(rawLogs[i].transactionIndex);\n logs[i].transactionLogIndex = _bytesToUint(rawLogs[i].transactionLogIndex);\n logs[i].removed = rawLogs[i].removed;\n }\n return logs;\n }\n\n // Deploy a contract by fetching the contract bytecode from\n // the artifacts directory\n // e.g. `deployCode(code, abi.encode(arg1,arg2,arg3))`\n function deployCode(string memory what, bytes memory args) internal virtual returns (address addr) {\n bytes memory bytecode = abi.encodePacked(vm.getCode(what), args);\n /// @solidity memory-safe-assembly\n assembly {\n addr := create(0, add(bytecode, 0x20), mload(bytecode))\n }\n\n require(addr != address(0), \"StdCheats deployCode(string,bytes): Deployment failed.\");\n }\n\n function deployCode(string memory what) internal virtual returns (address addr) {\n bytes memory bytecode = vm.getCode(what);\n /// @solidity memory-safe-assembly\n assembly {\n addr := create(0, add(bytecode, 0x20), mload(bytecode))\n }\n\n require(addr != address(0), \"StdCheats deployCode(string): Deployment failed.\");\n }\n\n /// @dev deploy contract with value on construction\n function deployCode(string memory what, bytes memory args, uint256 val) internal virtual returns (address addr) {\n bytes memory bytecode = abi.encodePacked(vm.getCode(what), args);\n /// @solidity memory-safe-assembly\n assembly {\n addr := create(val, add(bytecode, 0x20), mload(bytecode))\n }\n\n require(addr != address(0), \"StdCheats deployCode(string,bytes,uint256): Deployment failed.\");\n }\n\n function deployCode(string memory what, uint256 val) internal virtual returns (address addr) {\n bytes memory bytecode = vm.getCode(what);\n /// @solidity memory-safe-assembly\n assembly {\n addr := create(val, add(bytecode, 0x20), mload(bytecode))\n }\n\n require(addr != address(0), \"StdCheats deployCode(string,uint256): Deployment failed.\");\n }\n\n // creates a labeled address and the corresponding private key\n function makeAddrAndKey(string memory name) internal virtual returns (address addr, uint256 privateKey) {\n privateKey = uint256(keccak256(abi.encodePacked(name)));\n addr = vm.addr(privateKey);\n vm.label(addr, name);\n }\n\n // creates a labeled address\n function makeAddr(string memory name) internal virtual returns (address addr) {\n (addr,) = makeAddrAndKey(name);\n }\n\n // Destroys an account immediately, sending the balance to beneficiary.\n // Destroying means: balance will be zero, code will be empty, and nonce will be 0\n // This is similar to selfdestruct but not identical: selfdestruct destroys code and nonce\n // only after tx ends, this will run immediately.\n function destroyAccount(address who, address beneficiary) internal virtual {\n uint256 currBalance = who.balance;\n vm.etch(who, abi.encode());\n vm.deal(who, 0);\n vm.resetNonce(who);\n\n uint256 beneficiaryBalance = beneficiary.balance;\n vm.deal(beneficiary, currBalance + beneficiaryBalance);\n }\n\n // creates a struct containing both a labeled address and the corresponding private key\n function makeAccount(string memory name) internal virtual returns (Account memory account) {\n (account.addr, account.key) = makeAddrAndKey(name);\n }\n\n function deriveRememberKey(string memory mnemonic, uint32 index)\n internal\n virtual\n returns (address who, uint256 privateKey)\n {\n privateKey = vm.deriveKey(mnemonic, index);\n who = vm.rememberKey(privateKey);\n }\n\n function _bytesToUint(bytes memory b) private pure returns (uint256) {\n require(b.length <= 32, \"StdCheats _bytesToUint(bytes): Bytes length exceeds 32.\");\n return abi.decode(abi.encodePacked(new bytes(32 - b.length), b), (uint256));\n }\n\n function isFork() internal view virtual returns (bool status) {\n try vm.activeFork() {\n status = true;\n } catch (bytes memory) {}\n }\n\n modifier skipWhenForking() {\n if (!isFork()) {\n _;\n }\n }\n\n modifier skipWhenNotForking() {\n if (isFork()) {\n _;\n }\n }\n\n modifier noGasMetering() {\n vm.pauseGasMetering();\n // To prevent turning gas monitoring back on with nested functions that use this modifier,\n // we check if gasMetering started in the off position. If it did, we don't want to turn\n // it back on until we exit the top level function that used the modifier\n //\n // i.e. funcA() noGasMetering { funcB() }, where funcB has noGasMetering as well.\n // funcA will have `gasStartedOff` as false, funcB will have it as true,\n // so we only turn metering back on at the end of the funcA\n bool gasStartedOff = gasMeteringOff;\n gasMeteringOff = true;\n\n _;\n\n // if gas metering was on when this modifier was called, turn it back on at the end\n if (!gasStartedOff) {\n gasMeteringOff = false;\n vm.resumeGasMetering();\n }\n }\n\n // We use this complex approach of `_viewChainId` and `_pureChainId` to ensure there are no\n // compiler warnings when accessing chain ID in any solidity version supported by forge-std. We\n // can't simply access the chain ID in a normal view or pure function because the solc View Pure\n // Checker changed `chainid` from pure to view in 0.8.0.\n function _viewChainId() private view returns (uint256 chainId) {\n // Assembly required since `block.chainid` was introduced in 0.8.0.\n assembly {\n chainId := chainid()\n }\n\n address(this); // Silence warnings in older Solc versions.\n }\n\n function _pureChainId() private pure returns (uint256 chainId) {\n function() internal view returns (uint256) fnIn = _viewChainId;\n function() internal pure returns (uint256) pureChainId;\n assembly {\n pureChainId := fnIn\n }\n chainId = pureChainId();\n }\n}\n\n// Wrappers around cheatcodes to avoid footguns\nabstract contract StdCheats is StdCheatsSafe {\n using stdStorage for StdStorage;\n\n StdStorage private stdstore;\n Vm private constant vm = Vm(address(uint160(uint256(keccak256(\"hevm cheat code\")))));\n address private constant CONSOLE2_ADDRESS = 0x000000000000000000636F6e736F6c652e6c6f67;\n\n // Skip forward or rewind time by the specified number of seconds\n function skip(uint256 time) internal virtual {\n vm.warp(vm.getBlockTimestamp() + time);\n }\n\n function rewind(uint256 time) internal virtual {\n vm.warp(vm.getBlockTimestamp() - time);\n }\n\n // Setup a prank from an address that has some ether\n function hoax(address msgSender) internal virtual {\n vm.deal(msgSender, 1 << 128);\n vm.prank(msgSender);\n }\n\n function hoax(address msgSender, uint256 give) internal virtual {\n vm.deal(msgSender, give);\n vm.prank(msgSender);\n }\n\n function hoax(address msgSender, address origin) internal virtual {\n vm.deal(msgSender, 1 << 128);\n vm.prank(msgSender, origin);\n }\n\n function hoax(address msgSender, address origin, uint256 give) internal virtual {\n vm.deal(msgSender, give);\n vm.prank(msgSender, origin);\n }\n\n // Start perpetual prank from an address that has some ether\n function startHoax(address msgSender) internal virtual {\n vm.deal(msgSender, 1 << 128);\n vm.startPrank(msgSender);\n }\n\n function startHoax(address msgSender, uint256 give) internal virtual {\n vm.deal(msgSender, give);\n vm.startPrank(msgSender);\n }\n\n // Start perpetual prank from an address that has some ether\n // tx.origin is set to the origin parameter\n function startHoax(address msgSender, address origin) internal virtual {\n vm.deal(msgSender, 1 << 128);\n vm.startPrank(msgSender, origin);\n }\n\n function startHoax(address msgSender, address origin, uint256 give) internal virtual {\n vm.deal(msgSender, give);\n vm.startPrank(msgSender, origin);\n }\n\n function changePrank(address msgSender) internal virtual {\n console2_log_StdCheats(\"changePrank is deprecated. Please use vm.startPrank instead.\");\n vm.stopPrank();\n vm.startPrank(msgSender);\n }\n\n function changePrank(address msgSender, address txOrigin) internal virtual {\n vm.stopPrank();\n vm.startPrank(msgSender, txOrigin);\n }\n\n // The same as Vm's `deal`\n // Use the alternative signature for ERC20 tokens\n function deal(address to, uint256 give) internal virtual {\n vm.deal(to, give);\n }\n\n // Set the balance of an account for any ERC20 token\n // Use the alternative signature to update `totalSupply`\n function deal(address token, address to, uint256 give) internal virtual {\n deal(token, to, give, false);\n }\n\n // Set the balance of an account for any ERC1155 token\n // Use the alternative signature to update `totalSupply`\n function dealERC1155(address token, address to, uint256 id, uint256 give) internal virtual {\n dealERC1155(token, to, id, give, false);\n }\n\n function deal(address token, address to, uint256 give, bool adjust) internal virtual {\n // get current balance\n (, bytes memory balData) = token.staticcall(abi.encodeWithSelector(0x70a08231, to));\n uint256 prevBal = abi.decode(balData, (uint256));\n\n // update balance\n stdstore.target(token).sig(0x70a08231).with_key(to).checked_write(give);\n\n // update total supply\n if (adjust) {\n (, bytes memory totSupData) = token.staticcall(abi.encodeWithSelector(0x18160ddd));\n uint256 totSup = abi.decode(totSupData, (uint256));\n if (give < prevBal) {\n totSup -= (prevBal - give);\n } else {\n totSup += (give - prevBal);\n }\n stdstore.target(token).sig(0x18160ddd).checked_write(totSup);\n }\n }\n\n function dealERC1155(address token, address to, uint256 id, uint256 give, bool adjust) internal virtual {\n // get current balance\n (, bytes memory balData) = token.staticcall(abi.encodeWithSelector(0x00fdd58e, to, id));\n uint256 prevBal = abi.decode(balData, (uint256));\n\n // update balance\n stdstore.target(token).sig(0x00fdd58e).with_key(to).with_key(id).checked_write(give);\n\n // update total supply\n if (adjust) {\n (, bytes memory totSupData) = token.staticcall(abi.encodeWithSelector(0xbd85b039, id));\n require(\n totSupData.length != 0,\n \"StdCheats deal(address,address,uint,uint,bool): target contract is not ERC1155Supply.\"\n );\n uint256 totSup = abi.decode(totSupData, (uint256));\n if (give < prevBal) {\n totSup -= (prevBal - give);\n } else {\n totSup += (give - prevBal);\n }\n stdstore.target(token).sig(0xbd85b039).with_key(id).checked_write(totSup);\n }\n }\n\n function dealERC721(address token, address to, uint256 id) internal virtual {\n // check if token id is already minted and the actual owner.\n (bool successMinted, bytes memory ownerData) = token.staticcall(abi.encodeWithSelector(0x6352211e, id));\n require(successMinted, \"StdCheats deal(address,address,uint,bool): id not minted.\");\n\n // get owner current balance\n (, bytes memory fromBalData) =\n token.staticcall(abi.encodeWithSelector(0x70a08231, abi.decode(ownerData, (address))));\n uint256 fromPrevBal = abi.decode(fromBalData, (uint256));\n\n // get new user current balance\n (, bytes memory toBalData) = token.staticcall(abi.encodeWithSelector(0x70a08231, to));\n uint256 toPrevBal = abi.decode(toBalData, (uint256));\n\n // update balances\n stdstore.target(token).sig(0x70a08231).with_key(abi.decode(ownerData, (address))).checked_write(--fromPrevBal);\n stdstore.target(token).sig(0x70a08231).with_key(to).checked_write(++toPrevBal);\n\n // update owner\n stdstore.target(token).sig(0x6352211e).with_key(id).checked_write(to);\n }\n\n function deployCodeTo(string memory what, address where) internal virtual {\n deployCodeTo(what, \"\", 0, where);\n }\n\n function deployCodeTo(string memory what, bytes memory args, address where) internal virtual {\n deployCodeTo(what, args, 0, where);\n }\n\n function deployCodeTo(string memory what, bytes memory args, uint256 value, address where) internal virtual {\n bytes memory creationCode = vm.getCode(what);\n vm.etch(where, abi.encodePacked(creationCode, args));\n (bool success, bytes memory runtimeBytecode) = where.call{value: value}(\"\");\n require(success, \"StdCheats deployCodeTo(string,bytes,uint256,address): Failed to create runtime bytecode.\");\n vm.etch(where, runtimeBytecode);\n }\n\n // Used to prevent the compilation of console, which shortens the compilation time when console is not used elsewhere.\n function console2_log_StdCheats(string memory p0) private view {\n (bool status,) = address(CONSOLE2_ADDRESS).staticcall(abi.encodeWithSignature(\"log(string)\", p0));\n status;\n }\n}\n","license":"MIT"},"lib/forge-std/src/StdConstants.sol":{"keccak256":"0x319ccdabfa2c0b2428301445873270ffea20f0e039d4fd5e6eeba65158e4e534","urls":[],"content":"// SPDX-License-Identifier: MIT\npragma solidity >=0.6.2 <0.9.0;\n\nimport {IMulticall3} from \"./interfaces/IMulticall3.sol\";\nimport {Vm} from \"./Vm.sol\";\n\nlibrary StdConstants {\n /// @dev Cheat code address.\n /// Calculated as `address(uint160(uint256(keccak256(\"hevm cheat code\"))))`.\n Vm internal constant VM = Vm(0x7109709ECfa91a80626fF3989D68f67F5b1DD12D);\n /// @dev console.sol and console2.sol work by executing a staticcall to this address.\n /// Calculated as `address(uint160(uint88(bytes11(\"console.log\"))))`.\n address internal constant CONSOLE = 0x000000000000000000636F6e736F6c652e6c6f67;\n /// @dev Used when deploying with create2.\n /// Taken from https://github.com/Arachnid/deterministic-deployment-proxy.\n address internal constant CREATE2_FACTORY = 0x4e59b44847b379578588920cA78FbF26c0B4956C;\n /// @dev The default address for tx.origin and msg.sender.\n /// Calculated as `address(uint160(uint256(keccak256(\"foundry default caller\"))))`.\n address internal constant DEFAULT_SENDER = 0x1804c8AB1F12E6bbf3894d4083f33e07309d1f38;\n /// @dev The address of the first contract `CREATE`d by a running test contract.\n /// When running tests, each test contract is `CREATE`d by `DEFAULT_SENDER` with nonce 1.\n /// Calculated as `VM.computeCreateAddress(VM.computeCreateAddress(DEFAULT_SENDER, 1), 1)`.\n address internal constant DEFAULT_TEST_CONTRACT = 0x5615dEB798BB3E4dFa0139dFa1b3D433Cc23b72f;\n /// @dev Deterministic deployment address of the Multicall3 contract.\n /// Taken from https://www.multicall3.com.\n IMulticall3 internal constant MULTICALL3_ADDRESS = IMulticall3(0xcA11bde05977b3631167028862bE2a173976CA11);\n /// @dev The order of the secp256k1 curve.\n uint256 internal constant SECP256K1_ORDER =\n 115792089237316195423570985008687907852837564279074904382605163141518161494337;\n}\n","license":"MIT"},"lib/forge-std/src/StdJson.sol":{"keccak256":"0xbc0132abe1c2accc2867c0f03667afffdf92f3e95a581bb03c9557eaa38ea500","urls":[],"content":"// SPDX-License-Identifier: MIT\npragma solidity >=0.6.0 <0.9.0;\n\npragma experimental ABIEncoderV2;\n\nimport {VmSafe} from \"./Vm.sol\";\n\n// Helpers for parsing and writing JSON files\n// To parse:\n// ```\n// using stdJson for string;\n// string memory json = vm.readFile(\"\");\n// json.readUint(\"\");\n// ```\n// To write:\n// ```\n// using stdJson for string;\n// string memory json = \"json\";\n// json.serialize(\"a\", uint256(123));\n// string memory semiFinal = json.serialize(\"b\", string(\"test\"));\n// string memory finalJson = json.serialize(\"c\", semiFinal);\n// finalJson.write(\"\");\n// ```\n\nlibrary stdJson {\n VmSafe private constant vm = VmSafe(address(uint160(uint256(keccak256(\"hevm cheat code\")))));\n\n function keyExists(string memory json, string memory key) internal view returns (bool) {\n return vm.keyExistsJson(json, key);\n }\n\n function parseRaw(string memory json, string memory key) internal pure returns (bytes memory) {\n return vm.parseJson(json, key);\n }\n\n function readUint(string memory json, string memory key) internal pure returns (uint256) {\n return vm.parseJsonUint(json, key);\n }\n\n function readUintArray(string memory json, string memory key) internal pure returns (uint256[] memory) {\n return vm.parseJsonUintArray(json, key);\n }\n\n function readInt(string memory json, string memory key) internal pure returns (int256) {\n return vm.parseJsonInt(json, key);\n }\n\n function readIntArray(string memory json, string memory key) internal pure returns (int256[] memory) {\n return vm.parseJsonIntArray(json, key);\n }\n\n function readBytes32(string memory json, string memory key) internal pure returns (bytes32) {\n return vm.parseJsonBytes32(json, key);\n }\n\n function readBytes32Array(string memory json, string memory key) internal pure returns (bytes32[] memory) {\n return vm.parseJsonBytes32Array(json, key);\n }\n\n function readString(string memory json, string memory key) internal pure returns (string memory) {\n return vm.parseJsonString(json, key);\n }\n\n function readStringArray(string memory json, string memory key) internal pure returns (string[] memory) {\n return vm.parseJsonStringArray(json, key);\n }\n\n function readAddress(string memory json, string memory key) internal pure returns (address) {\n return vm.parseJsonAddress(json, key);\n }\n\n function readAddressArray(string memory json, string memory key) internal pure returns (address[] memory) {\n return vm.parseJsonAddressArray(json, key);\n }\n\n function readBool(string memory json, string memory key) internal pure returns (bool) {\n return vm.parseJsonBool(json, key);\n }\n\n function readBoolArray(string memory json, string memory key) internal pure returns (bool[] memory) {\n return vm.parseJsonBoolArray(json, key);\n }\n\n function readBytes(string memory json, string memory key) internal pure returns (bytes memory) {\n return vm.parseJsonBytes(json, key);\n }\n\n function readBytesArray(string memory json, string memory key) internal pure returns (bytes[] memory) {\n return vm.parseJsonBytesArray(json, key);\n }\n\n function readUintOr(string memory json, string memory key, uint256 defaultValue) internal view returns (uint256) {\n return keyExists(json, key) ? readUint(json, key) : defaultValue;\n }\n\n function readUintArrayOr(string memory json, string memory key, uint256[] memory defaultValue)\n internal\n view\n returns (uint256[] memory)\n {\n return keyExists(json, key) ? readUintArray(json, key) : defaultValue;\n }\n\n function readIntOr(string memory json, string memory key, int256 defaultValue) internal view returns (int256) {\n return keyExists(json, key) ? readInt(json, key) : defaultValue;\n }\n\n function readIntArrayOr(string memory json, string memory key, int256[] memory defaultValue)\n internal\n view\n returns (int256[] memory)\n {\n return keyExists(json, key) ? readIntArray(json, key) : defaultValue;\n }\n\n function readBytes32Or(string memory json, string memory key, bytes32 defaultValue)\n internal\n view\n returns (bytes32)\n {\n return keyExists(json, key) ? readBytes32(json, key) : defaultValue;\n }\n\n function readBytes32ArrayOr(string memory json, string memory key, bytes32[] memory defaultValue)\n internal\n view\n returns (bytes32[] memory)\n {\n return keyExists(json, key) ? readBytes32Array(json, key) : defaultValue;\n }\n\n function readStringOr(string memory json, string memory key, string memory defaultValue)\n internal\n view\n returns (string memory)\n {\n return keyExists(json, key) ? readString(json, key) : defaultValue;\n }\n\n function readStringArrayOr(string memory json, string memory key, string[] memory defaultValue)\n internal\n view\n returns (string[] memory)\n {\n return keyExists(json, key) ? readStringArray(json, key) : defaultValue;\n }\n\n function readAddressOr(string memory json, string memory key, address defaultValue)\n internal\n view\n returns (address)\n {\n return keyExists(json, key) ? readAddress(json, key) : defaultValue;\n }\n\n function readAddressArrayOr(string memory json, string memory key, address[] memory defaultValue)\n internal\n view\n returns (address[] memory)\n {\n return keyExists(json, key) ? readAddressArray(json, key) : defaultValue;\n }\n\n function readBoolOr(string memory json, string memory key, bool defaultValue) internal view returns (bool) {\n return keyExists(json, key) ? readBool(json, key) : defaultValue;\n }\n\n function readBoolArrayOr(string memory json, string memory key, bool[] memory defaultValue)\n internal\n view\n returns (bool[] memory)\n {\n return keyExists(json, key) ? readBoolArray(json, key) : defaultValue;\n }\n\n function readBytesOr(string memory json, string memory key, bytes memory defaultValue)\n internal\n view\n returns (bytes memory)\n {\n return keyExists(json, key) ? readBytes(json, key) : defaultValue;\n }\n\n function readBytesArrayOr(string memory json, string memory key, bytes[] memory defaultValue)\n internal\n view\n returns (bytes[] memory)\n {\n return keyExists(json, key) ? readBytesArray(json, key) : defaultValue;\n }\n\n function serialize(string memory jsonKey, string memory rootObject) internal returns (string memory) {\n return vm.serializeJson(jsonKey, rootObject);\n }\n\n function serialize(string memory jsonKey, string memory key, bool value) internal returns (string memory) {\n return vm.serializeBool(jsonKey, key, value);\n }\n\n function serialize(string memory jsonKey, string memory key, bool[] memory value)\n internal\n returns (string memory)\n {\n return vm.serializeBool(jsonKey, key, value);\n }\n\n function serialize(string memory jsonKey, string memory key, uint256 value) internal returns (string memory) {\n return vm.serializeUint(jsonKey, key, value);\n }\n\n function serialize(string memory jsonKey, string memory key, uint256[] memory value)\n internal\n returns (string memory)\n {\n return vm.serializeUint(jsonKey, key, value);\n }\n\n function serialize(string memory jsonKey, string memory key, int256 value) internal returns (string memory) {\n return vm.serializeInt(jsonKey, key, value);\n }\n\n function serialize(string memory jsonKey, string memory key, int256[] memory value)\n internal\n returns (string memory)\n {\n return vm.serializeInt(jsonKey, key, value);\n }\n\n function serialize(string memory jsonKey, string memory key, address value) internal returns (string memory) {\n return vm.serializeAddress(jsonKey, key, value);\n }\n\n function serialize(string memory jsonKey, string memory key, address[] memory value)\n internal\n returns (string memory)\n {\n return vm.serializeAddress(jsonKey, key, value);\n }\n\n function serialize(string memory jsonKey, string memory key, bytes32 value) internal returns (string memory) {\n return vm.serializeBytes32(jsonKey, key, value);\n }\n\n function serialize(string memory jsonKey, string memory key, bytes32[] memory value)\n internal\n returns (string memory)\n {\n return vm.serializeBytes32(jsonKey, key, value);\n }\n\n function serialize(string memory jsonKey, string memory key, bytes memory value) internal returns (string memory) {\n return vm.serializeBytes(jsonKey, key, value);\n }\n\n function serialize(string memory jsonKey, string memory key, bytes[] memory value)\n internal\n returns (string memory)\n {\n return vm.serializeBytes(jsonKey, key, value);\n }\n\n function serialize(string memory jsonKey, string memory key, string memory value)\n internal\n returns (string memory)\n {\n return vm.serializeString(jsonKey, key, value);\n }\n\n function serialize(string memory jsonKey, string memory key, string[] memory value)\n internal\n returns (string memory)\n {\n return vm.serializeString(jsonKey, key, value);\n }\n\n function write(string memory jsonKey, string memory path) internal {\n vm.writeJson(jsonKey, path);\n }\n\n function write(string memory jsonKey, string memory path, string memory valueKey) internal {\n vm.writeJson(jsonKey, path, valueKey);\n }\n}\n","license":"MIT"},"lib/forge-std/src/StdMath.sol":{"keccak256":"0xd90ad4fd8aeaeb8929964e686e769fdedd5eded3fc3815df194a0ab9f91a3fb2","urls":[],"content":"// SPDX-License-Identifier: MIT\npragma solidity >=0.6.2 <0.9.0;\n\nlibrary stdMath {\n int256 private constant INT256_MIN = -57896044618658097711785492504343953926634992332820282019728792003956564819968;\n\n function abs(int256 a) internal pure returns (uint256) {\n // Required or it will fail when `a = type(int256).min`\n if (a == INT256_MIN) {\n return 57896044618658097711785492504343953926634992332820282019728792003956564819968;\n }\n\n return uint256(a > 0 ? a : -a);\n }\n\n function delta(uint256 a, uint256 b) internal pure returns (uint256) {\n return a > b ? a - b : b - a;\n }\n\n function delta(int256 a, int256 b) internal pure returns (uint256) {\n // a and b are of the same sign\n // this works thanks to two's complement, the left-most bit is the sign bit\n if ((a ^ b) > -1) {\n return delta(abs(a), abs(b));\n }\n\n // a and b are of opposite signs\n return abs(a) + abs(b);\n }\n\n function percentDelta(uint256 a, uint256 b) internal pure returns (uint256) {\n uint256 absDelta = delta(a, b);\n\n return absDelta * 1e18 / b;\n }\n\n function percentDelta(int256 a, int256 b) internal pure returns (uint256) {\n uint256 absDelta = delta(a, b);\n uint256 absB = abs(b);\n\n return absDelta * 1e18 / absB;\n }\n}\n","license":"MIT"},"lib/forge-std/src/StdStorage.sol":{"keccak256":"0xb91ab24383a5872b894fc93325eef1add6cbbf981628f18e860068bf88bb7dcc","urls":[],"content":"// SPDX-License-Identifier: MIT\npragma solidity >=0.6.2 <0.9.0;\n\nimport {Vm} from \"./Vm.sol\";\n\nstruct FindData {\n uint256 slot;\n uint256 offsetLeft;\n uint256 offsetRight;\n bool found;\n}\n\nstruct StdStorage {\n mapping(address => mapping(bytes4 => mapping(bytes32 => FindData))) finds;\n bytes32[] _keys;\n bytes4 _sig;\n uint256 _depth;\n address _target;\n bytes32 _set;\n bool _enable_packed_slots;\n bytes _calldata;\n}\n\nlibrary stdStorageSafe {\n event SlotFound(address who, bytes4 fsig, bytes32 keysHash, uint256 slot);\n event WARNING_UninitedSlot(address who, uint256 slot);\n\n Vm private constant vm = Vm(address(uint160(uint256(keccak256(\"hevm cheat code\")))));\n uint256 constant UINT256_MAX = 115792089237316195423570985008687907853269984665640564039457584007913129639935;\n\n function sigs(string memory sigStr) internal pure returns (bytes4) {\n return bytes4(keccak256(bytes(sigStr)));\n }\n\n function getCallParams(StdStorage storage self) internal view returns (bytes memory) {\n if (self._calldata.length == 0) {\n return flatten(self._keys);\n } else {\n return self._calldata;\n }\n }\n\n // Calls target contract with configured parameters\n function callTarget(StdStorage storage self) internal view returns (bool, bytes32) {\n bytes memory cald = abi.encodePacked(self._sig, getCallParams(self));\n (bool success, bytes memory rdat) = self._target.staticcall(cald);\n bytes32 result = bytesToBytes32(rdat, 32 * self._depth);\n\n return (success, result);\n }\n\n // Tries mutating slot value to determine if the targeted value is stored in it.\n // If current value is 0, then we are setting slot value to type(uint256).max\n // Otherwise, we set it to 0. That way, return value should always be affected.\n function checkSlotMutatesCall(StdStorage storage self, bytes32 slot) internal returns (bool) {\n bytes32 prevSlotValue = vm.load(self._target, slot);\n (bool success, bytes32 prevReturnValue) = callTarget(self);\n\n bytes32 testVal = prevReturnValue == bytes32(0) ? bytes32(UINT256_MAX) : bytes32(0);\n vm.store(self._target, slot, testVal);\n\n (, bytes32 newReturnValue) = callTarget(self);\n\n vm.store(self._target, slot, prevSlotValue);\n\n return (success && (prevReturnValue != newReturnValue));\n }\n\n // Tries setting one of the bits in slot to 1 until return value changes.\n // Index of resulted bit is an offset packed slot has from left/right side\n function findOffset(StdStorage storage self, bytes32 slot, bool left) internal returns (bool, uint256) {\n for (uint256 offset = 0; offset < 256; offset++) {\n uint256 valueToPut = left ? (1 << (255 - offset)) : (1 << offset);\n vm.store(self._target, slot, bytes32(valueToPut));\n\n (bool success, bytes32 data) = callTarget(self);\n\n if (success && (uint256(data) > 0)) {\n return (true, offset);\n }\n }\n return (false, 0);\n }\n\n function findOffsets(StdStorage storage self, bytes32 slot) internal returns (bool, uint256, uint256) {\n bytes32 prevSlotValue = vm.load(self._target, slot);\n\n (bool foundLeft, uint256 offsetLeft) = findOffset(self, slot, true);\n (bool foundRight, uint256 offsetRight) = findOffset(self, slot, false);\n\n // `findOffset` may mutate slot value, so we are setting it to initial value\n vm.store(self._target, slot, prevSlotValue);\n return (foundLeft && foundRight, offsetLeft, offsetRight);\n }\n\n function find(StdStorage storage self) internal returns (FindData storage) {\n return find(self, true);\n }\n\n /// @notice find an arbitrary storage slot given a function sig, input data, address of the contract and a value to check against\n // slot complexity:\n // if flat, will be bytes32(uint256(uint));\n // if map, will be keccak256(abi.encode(key, uint(slot)));\n // if deep map, will be keccak256(abi.encode(key1, keccak256(abi.encode(key0, uint(slot)))));\n // if map struct, will be bytes32(uint256(keccak256(abi.encode(key1, keccak256(abi.encode(key0, uint(slot)))))) + structFieldDepth);\n function find(StdStorage storage self, bool _clear) internal returns (FindData storage) {\n address who = self._target;\n bytes4 fsig = self._sig;\n uint256 field_depth = self._depth;\n bytes memory params = getCallParams(self);\n\n // calldata to test against\n if (self.finds[who][fsig][keccak256(abi.encodePacked(params, field_depth))].found) {\n if (_clear) {\n clear(self);\n }\n return self.finds[who][fsig][keccak256(abi.encodePacked(params, field_depth))];\n }\n vm.record();\n (, bytes32 callResult) = callTarget(self);\n (bytes32[] memory reads,) = vm.accesses(address(who));\n\n if (reads.length == 0) {\n revert(\"stdStorage find(StdStorage): No storage use detected for target.\");\n } else {\n for (uint256 i = reads.length; --i >= 0;) {\n bytes32 prev = vm.load(who, reads[i]);\n if (prev == bytes32(0)) {\n emit WARNING_UninitedSlot(who, uint256(reads[i]));\n }\n\n if (!checkSlotMutatesCall(self, reads[i])) {\n continue;\n }\n\n (uint256 offsetLeft, uint256 offsetRight) = (0, 0);\n\n if (self._enable_packed_slots) {\n bool found;\n (found, offsetLeft, offsetRight) = findOffsets(self, reads[i]);\n if (!found) {\n continue;\n }\n }\n\n // Check that value between found offsets is equal to the current call result\n uint256 curVal = (uint256(prev) & getMaskByOffsets(offsetLeft, offsetRight)) >> offsetRight;\n\n if (uint256(callResult) != curVal) {\n continue;\n }\n\n emit SlotFound(who, fsig, keccak256(abi.encodePacked(params, field_depth)), uint256(reads[i]));\n self.finds[who][fsig][keccak256(abi.encodePacked(params, field_depth))] =\n FindData(uint256(reads[i]), offsetLeft, offsetRight, true);\n break;\n }\n }\n\n require(\n self.finds[who][fsig][keccak256(abi.encodePacked(params, field_depth))].found,\n \"stdStorage find(StdStorage): Slot(s) not found.\"\n );\n\n if (_clear) {\n clear(self);\n }\n return self.finds[who][fsig][keccak256(abi.encodePacked(params, field_depth))];\n }\n\n function target(StdStorage storage self, address _target) internal returns (StdStorage storage) {\n self._target = _target;\n return self;\n }\n\n function sig(StdStorage storage self, bytes4 _sig) internal returns (StdStorage storage) {\n self._sig = _sig;\n return self;\n }\n\n function sig(StdStorage storage self, string memory _sig) internal returns (StdStorage storage) {\n self._sig = sigs(_sig);\n return self;\n }\n\n function with_calldata(StdStorage storage self, bytes memory _calldata) internal returns (StdStorage storage) {\n self._calldata = _calldata;\n return self;\n }\n\n function with_key(StdStorage storage self, address who) internal returns (StdStorage storage) {\n self._keys.push(bytes32(uint256(uint160(who))));\n return self;\n }\n\n function with_key(StdStorage storage self, uint256 amt) internal returns (StdStorage storage) {\n self._keys.push(bytes32(amt));\n return self;\n }\n\n function with_key(StdStorage storage self, bytes32 key) internal returns (StdStorage storage) {\n self._keys.push(key);\n return self;\n }\n\n function enable_packed_slots(StdStorage storage self) internal returns (StdStorage storage) {\n self._enable_packed_slots = true;\n return self;\n }\n\n function depth(StdStorage storage self, uint256 _depth) internal returns (StdStorage storage) {\n self._depth = _depth;\n return self;\n }\n\n function read(StdStorage storage self) private returns (bytes memory) {\n FindData storage data = find(self, false);\n uint256 mask = getMaskByOffsets(data.offsetLeft, data.offsetRight);\n uint256 value = (uint256(vm.load(self._target, bytes32(data.slot))) & mask) >> data.offsetRight;\n clear(self);\n return abi.encode(value);\n }\n\n function read_bytes32(StdStorage storage self) internal returns (bytes32) {\n return abi.decode(read(self), (bytes32));\n }\n\n function read_bool(StdStorage storage self) internal returns (bool) {\n int256 v = read_int(self);\n if (v == 0) return false;\n if (v == 1) return true;\n revert(\"stdStorage read_bool(StdStorage): Cannot decode. Make sure you are reading a bool.\");\n }\n\n function read_address(StdStorage storage self) internal returns (address) {\n return abi.decode(read(self), (address));\n }\n\n function read_uint(StdStorage storage self) internal returns (uint256) {\n return abi.decode(read(self), (uint256));\n }\n\n function read_int(StdStorage storage self) internal returns (int256) {\n return abi.decode(read(self), (int256));\n }\n\n function parent(StdStorage storage self) internal returns (uint256, bytes32) {\n address who = self._target;\n uint256 field_depth = self._depth;\n vm.startMappingRecording();\n uint256 child = find(self, true).slot - field_depth;\n (bool found, bytes32 key, bytes32 parent_slot) = vm.getMappingKeyAndParentOf(who, bytes32(child));\n if (!found) {\n revert(\n \"stdStorage read_bool(StdStorage): Cannot find parent. Make sure you give a slot and startMappingRecording() has been called.\"\n );\n }\n return (uint256(parent_slot), key);\n }\n\n function root(StdStorage storage self) internal returns (uint256) {\n address who = self._target;\n uint256 field_depth = self._depth;\n vm.startMappingRecording();\n uint256 child = find(self, true).slot - field_depth;\n bool found;\n bytes32 root_slot;\n bytes32 parent_slot;\n (found,, parent_slot) = vm.getMappingKeyAndParentOf(who, bytes32(child));\n if (!found) {\n revert(\n \"stdStorage read_bool(StdStorage): Cannot find parent. Make sure you give a slot and startMappingRecording() has been called.\"\n );\n }\n while (found) {\n root_slot = parent_slot;\n (found,, parent_slot) = vm.getMappingKeyAndParentOf(who, bytes32(root_slot));\n }\n return uint256(root_slot);\n }\n\n function bytesToBytes32(bytes memory b, uint256 offset) private pure returns (bytes32) {\n bytes32 out;\n\n uint256 max = b.length > 32 ? 32 : b.length;\n for (uint256 i = 0; i < max; i++) {\n out |= bytes32(b[offset + i] & 0xFF) >> (i * 8);\n }\n return out;\n }\n\n function flatten(bytes32[] memory b) private pure returns (bytes memory) {\n bytes memory result = new bytes(b.length * 32);\n for (uint256 i = 0; i < b.length; i++) {\n bytes32 k = b[i];\n /// @solidity memory-safe-assembly\n assembly {\n mstore(add(result, add(32, mul(32, i))), k)\n }\n }\n\n return result;\n }\n\n function clear(StdStorage storage self) internal {\n delete self._target;\n delete self._sig;\n delete self._keys;\n delete self._depth;\n delete self._enable_packed_slots;\n delete self._calldata;\n }\n\n // Returns mask which contains non-zero bits for values between `offsetLeft` and `offsetRight`\n // (slotValue & mask) >> offsetRight will be the value of the given packed variable\n function getMaskByOffsets(uint256 offsetLeft, uint256 offsetRight) internal pure returns (uint256 mask) {\n // mask = ((1 << (256 - (offsetRight + offsetLeft))) - 1) << offsetRight;\n // using assembly because (1 << 256) causes overflow\n assembly {\n mask := shl(offsetRight, sub(shl(sub(256, add(offsetRight, offsetLeft)), 1), 1))\n }\n }\n\n // Returns slot value with updated packed variable.\n function getUpdatedSlotValue(bytes32 curValue, uint256 varValue, uint256 offsetLeft, uint256 offsetRight)\n internal\n pure\n returns (bytes32 newValue)\n {\n return bytes32((uint256(curValue) & ~getMaskByOffsets(offsetLeft, offsetRight)) | (varValue << offsetRight));\n }\n}\n\nlibrary stdStorage {\n Vm private constant vm = Vm(address(uint160(uint256(keccak256(\"hevm cheat code\")))));\n\n function sigs(string memory sigStr) internal pure returns (bytes4) {\n return stdStorageSafe.sigs(sigStr);\n }\n\n function find(StdStorage storage self) internal returns (uint256) {\n return find(self, true);\n }\n\n function find(StdStorage storage self, bool _clear) internal returns (uint256) {\n return stdStorageSafe.find(self, _clear).slot;\n }\n\n function target(StdStorage storage self, address _target) internal returns (StdStorage storage) {\n return stdStorageSafe.target(self, _target);\n }\n\n function sig(StdStorage storage self, bytes4 _sig) internal returns (StdStorage storage) {\n return stdStorageSafe.sig(self, _sig);\n }\n\n function sig(StdStorage storage self, string memory _sig) internal returns (StdStorage storage) {\n return stdStorageSafe.sig(self, _sig);\n }\n\n function with_key(StdStorage storage self, address who) internal returns (StdStorage storage) {\n return stdStorageSafe.with_key(self, who);\n }\n\n function with_key(StdStorage storage self, uint256 amt) internal returns (StdStorage storage) {\n return stdStorageSafe.with_key(self, amt);\n }\n\n function with_key(StdStorage storage self, bytes32 key) internal returns (StdStorage storage) {\n return stdStorageSafe.with_key(self, key);\n }\n\n function with_calldata(StdStorage storage self, bytes memory _calldata) internal returns (StdStorage storage) {\n return stdStorageSafe.with_calldata(self, _calldata);\n }\n\n function enable_packed_slots(StdStorage storage self) internal returns (StdStorage storage) {\n return stdStorageSafe.enable_packed_slots(self);\n }\n\n function depth(StdStorage storage self, uint256 _depth) internal returns (StdStorage storage) {\n return stdStorageSafe.depth(self, _depth);\n }\n\n function clear(StdStorage storage self) internal {\n stdStorageSafe.clear(self);\n }\n\n function checked_write(StdStorage storage self, address who) internal {\n checked_write(self, bytes32(uint256(uint160(who))));\n }\n\n function checked_write(StdStorage storage self, uint256 amt) internal {\n checked_write(self, bytes32(amt));\n }\n\n function checked_write_int(StdStorage storage self, int256 val) internal {\n checked_write(self, bytes32(uint256(val)));\n }\n\n function checked_write(StdStorage storage self, bool write) internal {\n bytes32 t;\n /// @solidity memory-safe-assembly\n assembly {\n t := write\n }\n checked_write(self, t);\n }\n\n function checked_write(StdStorage storage self, bytes32 set) internal {\n address who = self._target;\n bytes4 fsig = self._sig;\n uint256 field_depth = self._depth;\n bytes memory params = stdStorageSafe.getCallParams(self);\n\n if (!self.finds[who][fsig][keccak256(abi.encodePacked(params, field_depth))].found) {\n find(self, false);\n }\n FindData storage data = self.finds[who][fsig][keccak256(abi.encodePacked(params, field_depth))];\n if ((data.offsetLeft + data.offsetRight) > 0) {\n uint256 maxVal = 2 ** (256 - (data.offsetLeft + data.offsetRight));\n require(\n uint256(set) < maxVal,\n string(\n abi.encodePacked(\n \"stdStorage find(StdStorage): Packed slot. We can't fit value greater than \",\n vm.toString(maxVal)\n )\n )\n );\n }\n bytes32 curVal = vm.load(who, bytes32(data.slot));\n bytes32 valToSet = stdStorageSafe.getUpdatedSlotValue(curVal, uint256(set), data.offsetLeft, data.offsetRight);\n\n vm.store(who, bytes32(data.slot), valToSet);\n\n (bool success, bytes32 callResult) = stdStorageSafe.callTarget(self);\n\n if (!success || callResult != set) {\n vm.store(who, bytes32(data.slot), curVal);\n revert(\"stdStorage find(StdStorage): Failed to write value.\");\n }\n clear(self);\n }\n\n function read_bytes32(StdStorage storage self) internal returns (bytes32) {\n return stdStorageSafe.read_bytes32(self);\n }\n\n function read_bool(StdStorage storage self) internal returns (bool) {\n return stdStorageSafe.read_bool(self);\n }\n\n function read_address(StdStorage storage self) internal returns (address) {\n return stdStorageSafe.read_address(self);\n }\n\n function read_uint(StdStorage storage self) internal returns (uint256) {\n return stdStorageSafe.read_uint(self);\n }\n\n function read_int(StdStorage storage self) internal returns (int256) {\n return stdStorageSafe.read_int(self);\n }\n\n function parent(StdStorage storage self) internal returns (uint256, bytes32) {\n return stdStorageSafe.parent(self);\n }\n\n function root(StdStorage storage self) internal returns (uint256) {\n return stdStorageSafe.root(self);\n }\n}\n","license":"MIT"},"lib/forge-std/src/StdStyle.sol":{"keccak256":"0x43e2a8a9b9c2574dabe74f11adf6f782df218f463540e3b5b563609fe108597d","urls":[],"content":"// SPDX-License-Identifier: MIT\npragma solidity >=0.4.22 <0.9.0;\n\nimport {VmSafe} from \"./Vm.sol\";\n\nlibrary StdStyle {\n VmSafe private constant vm = VmSafe(address(uint160(uint256(keccak256(\"hevm cheat code\")))));\n\n string constant RED = \"\\u001b[91m\";\n string constant GREEN = \"\\u001b[92m\";\n string constant YELLOW = \"\\u001b[93m\";\n string constant BLUE = \"\\u001b[94m\";\n string constant MAGENTA = \"\\u001b[95m\";\n string constant CYAN = \"\\u001b[96m\";\n string constant BOLD = \"\\u001b[1m\";\n string constant DIM = \"\\u001b[2m\";\n string constant ITALIC = \"\\u001b[3m\";\n string constant UNDERLINE = \"\\u001b[4m\";\n string constant INVERSE = \"\\u001b[7m\";\n string constant RESET = \"\\u001b[0m\";\n\n function styleConcat(string memory style, string memory self) private pure returns (string memory) {\n return string(abi.encodePacked(style, self, RESET));\n }\n\n function red(string memory self) internal pure returns (string memory) {\n return styleConcat(RED, self);\n }\n\n function red(uint256 self) internal pure returns (string memory) {\n return red(vm.toString(self));\n }\n\n function red(int256 self) internal pure returns (string memory) {\n return red(vm.toString(self));\n }\n\n function red(address self) internal pure returns (string memory) {\n return red(vm.toString(self));\n }\n\n function red(bool self) internal pure returns (string memory) {\n return red(vm.toString(self));\n }\n\n function redBytes(bytes memory self) internal pure returns (string memory) {\n return red(vm.toString(self));\n }\n\n function redBytes32(bytes32 self) internal pure returns (string memory) {\n return red(vm.toString(self));\n }\n\n function green(string memory self) internal pure returns (string memory) {\n return styleConcat(GREEN, self);\n }\n\n function green(uint256 self) internal pure returns (string memory) {\n return green(vm.toString(self));\n }\n\n function green(int256 self) internal pure returns (string memory) {\n return green(vm.toString(self));\n }\n\n function green(address self) internal pure returns (string memory) {\n return green(vm.toString(self));\n }\n\n function green(bool self) internal pure returns (string memory) {\n return green(vm.toString(self));\n }\n\n function greenBytes(bytes memory self) internal pure returns (string memory) {\n return green(vm.toString(self));\n }\n\n function greenBytes32(bytes32 self) internal pure returns (string memory) {\n return green(vm.toString(self));\n }\n\n function yellow(string memory self) internal pure returns (string memory) {\n return styleConcat(YELLOW, self);\n }\n\n function yellow(uint256 self) internal pure returns (string memory) {\n return yellow(vm.toString(self));\n }\n\n function yellow(int256 self) internal pure returns (string memory) {\n return yellow(vm.toString(self));\n }\n\n function yellow(address self) internal pure returns (string memory) {\n return yellow(vm.toString(self));\n }\n\n function yellow(bool self) internal pure returns (string memory) {\n return yellow(vm.toString(self));\n }\n\n function yellowBytes(bytes memory self) internal pure returns (string memory) {\n return yellow(vm.toString(self));\n }\n\n function yellowBytes32(bytes32 self) internal pure returns (string memory) {\n return yellow(vm.toString(self));\n }\n\n function blue(string memory self) internal pure returns (string memory) {\n return styleConcat(BLUE, self);\n }\n\n function blue(uint256 self) internal pure returns (string memory) {\n return blue(vm.toString(self));\n }\n\n function blue(int256 self) internal pure returns (string memory) {\n return blue(vm.toString(self));\n }\n\n function blue(address self) internal pure returns (string memory) {\n return blue(vm.toString(self));\n }\n\n function blue(bool self) internal pure returns (string memory) {\n return blue(vm.toString(self));\n }\n\n function blueBytes(bytes memory self) internal pure returns (string memory) {\n return blue(vm.toString(self));\n }\n\n function blueBytes32(bytes32 self) internal pure returns (string memory) {\n return blue(vm.toString(self));\n }\n\n function magenta(string memory self) internal pure returns (string memory) {\n return styleConcat(MAGENTA, self);\n }\n\n function magenta(uint256 self) internal pure returns (string memory) {\n return magenta(vm.toString(self));\n }\n\n function magenta(int256 self) internal pure returns (string memory) {\n return magenta(vm.toString(self));\n }\n\n function magenta(address self) internal pure returns (string memory) {\n return magenta(vm.toString(self));\n }\n\n function magenta(bool self) internal pure returns (string memory) {\n return magenta(vm.toString(self));\n }\n\n function magentaBytes(bytes memory self) internal pure returns (string memory) {\n return magenta(vm.toString(self));\n }\n\n function magentaBytes32(bytes32 self) internal pure returns (string memory) {\n return magenta(vm.toString(self));\n }\n\n function cyan(string memory self) internal pure returns (string memory) {\n return styleConcat(CYAN, self);\n }\n\n function cyan(uint256 self) internal pure returns (string memory) {\n return cyan(vm.toString(self));\n }\n\n function cyan(int256 self) internal pure returns (string memory) {\n return cyan(vm.toString(self));\n }\n\n function cyan(address self) internal pure returns (string memory) {\n return cyan(vm.toString(self));\n }\n\n function cyan(bool self) internal pure returns (string memory) {\n return cyan(vm.toString(self));\n }\n\n function cyanBytes(bytes memory self) internal pure returns (string memory) {\n return cyan(vm.toString(self));\n }\n\n function cyanBytes32(bytes32 self) internal pure returns (string memory) {\n return cyan(vm.toString(self));\n }\n\n function bold(string memory self) internal pure returns (string memory) {\n return styleConcat(BOLD, self);\n }\n\n function bold(uint256 self) internal pure returns (string memory) {\n return bold(vm.toString(self));\n }\n\n function bold(int256 self) internal pure returns (string memory) {\n return bold(vm.toString(self));\n }\n\n function bold(address self) internal pure returns (string memory) {\n return bold(vm.toString(self));\n }\n\n function bold(bool self) internal pure returns (string memory) {\n return bold(vm.toString(self));\n }\n\n function boldBytes(bytes memory self) internal pure returns (string memory) {\n return bold(vm.toString(self));\n }\n\n function boldBytes32(bytes32 self) internal pure returns (string memory) {\n return bold(vm.toString(self));\n }\n\n function dim(string memory self) internal pure returns (string memory) {\n return styleConcat(DIM, self);\n }\n\n function dim(uint256 self) internal pure returns (string memory) {\n return dim(vm.toString(self));\n }\n\n function dim(int256 self) internal pure returns (string memory) {\n return dim(vm.toString(self));\n }\n\n function dim(address self) internal pure returns (string memory) {\n return dim(vm.toString(self));\n }\n\n function dim(bool self) internal pure returns (string memory) {\n return dim(vm.toString(self));\n }\n\n function dimBytes(bytes memory self) internal pure returns (string memory) {\n return dim(vm.toString(self));\n }\n\n function dimBytes32(bytes32 self) internal pure returns (string memory) {\n return dim(vm.toString(self));\n }\n\n function italic(string memory self) internal pure returns (string memory) {\n return styleConcat(ITALIC, self);\n }\n\n function italic(uint256 self) internal pure returns (string memory) {\n return italic(vm.toString(self));\n }\n\n function italic(int256 self) internal pure returns (string memory) {\n return italic(vm.toString(self));\n }\n\n function italic(address self) internal pure returns (string memory) {\n return italic(vm.toString(self));\n }\n\n function italic(bool self) internal pure returns (string memory) {\n return italic(vm.toString(self));\n }\n\n function italicBytes(bytes memory self) internal pure returns (string memory) {\n return italic(vm.toString(self));\n }\n\n function italicBytes32(bytes32 self) internal pure returns (string memory) {\n return italic(vm.toString(self));\n }\n\n function underline(string memory self) internal pure returns (string memory) {\n return styleConcat(UNDERLINE, self);\n }\n\n function underline(uint256 self) internal pure returns (string memory) {\n return underline(vm.toString(self));\n }\n\n function underline(int256 self) internal pure returns (string memory) {\n return underline(vm.toString(self));\n }\n\n function underline(address self) internal pure returns (string memory) {\n return underline(vm.toString(self));\n }\n\n function underline(bool self) internal pure returns (string memory) {\n return underline(vm.toString(self));\n }\n\n function underlineBytes(bytes memory self) internal pure returns (string memory) {\n return underline(vm.toString(self));\n }\n\n function underlineBytes32(bytes32 self) internal pure returns (string memory) {\n return underline(vm.toString(self));\n }\n\n function inverse(string memory self) internal pure returns (string memory) {\n return styleConcat(INVERSE, self);\n }\n\n function inverse(uint256 self) internal pure returns (string memory) {\n return inverse(vm.toString(self));\n }\n\n function inverse(int256 self) internal pure returns (string memory) {\n return inverse(vm.toString(self));\n }\n\n function inverse(address self) internal pure returns (string memory) {\n return inverse(vm.toString(self));\n }\n\n function inverse(bool self) internal pure returns (string memory) {\n return inverse(vm.toString(self));\n }\n\n function inverseBytes(bytes memory self) internal pure returns (string memory) {\n return inverse(vm.toString(self));\n }\n\n function inverseBytes32(bytes32 self) internal pure returns (string memory) {\n return inverse(vm.toString(self));\n }\n}\n","license":"MIT"},"lib/forge-std/src/StdUtils.sol":{"keccak256":"0x7274081e11c05164fd8eadde4de8305c033e58a43008dea58065f3170ccf0737","urls":[],"content":"// SPDX-License-Identifier: MIT\npragma solidity >=0.6.2 <0.9.0;\n\npragma experimental ABIEncoderV2;\n\nimport {IMulticall3} from \"./interfaces/IMulticall3.sol\";\nimport {VmSafe} from \"./Vm.sol\";\n\nabstract contract StdUtils {\n /*//////////////////////////////////////////////////////////////////////////\n CONSTANTS\n //////////////////////////////////////////////////////////////////////////*/\n\n IMulticall3 private constant multicall = IMulticall3(0xcA11bde05977b3631167028862bE2a173976CA11);\n VmSafe private constant vm = VmSafe(address(uint160(uint256(keccak256(\"hevm cheat code\")))));\n address private constant CONSOLE2_ADDRESS = 0x000000000000000000636F6e736F6c652e6c6f67;\n uint256 private constant INT256_MIN_ABS =\n 57896044618658097711785492504343953926634992332820282019728792003956564819968;\n uint256 private constant SECP256K1_ORDER =\n 115792089237316195423570985008687907852837564279074904382605163141518161494337;\n uint256 private constant UINT256_MAX =\n 115792089237316195423570985008687907853269984665640564039457584007913129639935;\n\n // Used by default when deploying with create2, https://github.com/Arachnid/deterministic-deployment-proxy.\n address private constant CREATE2_FACTORY = 0x4e59b44847b379578588920cA78FbF26c0B4956C;\n\n /*//////////////////////////////////////////////////////////////////////////\n INTERNAL FUNCTIONS\n //////////////////////////////////////////////////////////////////////////*/\n\n function _bound(uint256 x, uint256 min, uint256 max) internal pure virtual returns (uint256 result) {\n require(min <= max, \"StdUtils bound(uint256,uint256,uint256): Max is less than min.\");\n // If x is between min and max, return x directly. This is to ensure that dictionary values\n // do not get shifted if the min is nonzero. More info: https://github.com/foundry-rs/forge-std/issues/188\n if (x >= min && x <= max) return x;\n\n uint256 size = max - min + 1;\n\n // If the value is 0, 1, 2, 3, wrap that to min, min+1, min+2, min+3. Similarly for the UINT256_MAX side.\n // This helps ensure coverage of the min/max values.\n if (x <= 3 && size > x) return min + x;\n if (x >= UINT256_MAX - 3 && size > UINT256_MAX - x) return max - (UINT256_MAX - x);\n\n // Otherwise, wrap x into the range [min, max], i.e. the range is inclusive.\n if (x > max) {\n uint256 diff = x - max;\n uint256 rem = diff % size;\n if (rem == 0) return max;\n result = min + rem - 1;\n } else if (x < min) {\n uint256 diff = min - x;\n uint256 rem = diff % size;\n if (rem == 0) return min;\n result = max - rem + 1;\n }\n }\n\n function bound(uint256 x, uint256 min, uint256 max) internal pure virtual returns (uint256 result) {\n result = _bound(x, min, max);\n console2_log_StdUtils(\"Bound result\", result);\n }\n\n function _bound(int256 x, int256 min, int256 max) internal pure virtual returns (int256 result) {\n require(min <= max, \"StdUtils bound(int256,int256,int256): Max is less than min.\");\n\n // Shifting all int256 values to uint256 to use _bound function. The range of two types are:\n // int256 : -(2**255) ~ (2**255 - 1)\n // uint256: 0 ~ (2**256 - 1)\n // So, add 2**255, INT256_MIN_ABS to the integer values.\n //\n // If the given integer value is -2**255, we cannot use `-uint256(-x)` because of the overflow.\n // So, use `~uint256(x) + 1` instead.\n uint256 _x = x < 0 ? (INT256_MIN_ABS - ~uint256(x) - 1) : (uint256(x) + INT256_MIN_ABS);\n uint256 _min = min < 0 ? (INT256_MIN_ABS - ~uint256(min) - 1) : (uint256(min) + INT256_MIN_ABS);\n uint256 _max = max < 0 ? (INT256_MIN_ABS - ~uint256(max) - 1) : (uint256(max) + INT256_MIN_ABS);\n\n uint256 y = _bound(_x, _min, _max);\n\n // To move it back to int256 value, subtract INT256_MIN_ABS at here.\n result = y < INT256_MIN_ABS ? int256(~(INT256_MIN_ABS - y) + 1) : int256(y - INT256_MIN_ABS);\n }\n\n function bound(int256 x, int256 min, int256 max) internal pure virtual returns (int256 result) {\n result = _bound(x, min, max);\n console2_log_StdUtils(\"Bound result\", vm.toString(result));\n }\n\n function boundPrivateKey(uint256 privateKey) internal pure virtual returns (uint256 result) {\n result = _bound(privateKey, 1, SECP256K1_ORDER - 1);\n }\n\n function bytesToUint(bytes memory b) internal pure virtual returns (uint256) {\n require(b.length <= 32, \"StdUtils bytesToUint(bytes): Bytes length exceeds 32.\");\n return abi.decode(abi.encodePacked(new bytes(32 - b.length), b), (uint256));\n }\n\n /// @dev Compute the address a contract will be deployed at for a given deployer address and nonce\n /// @notice adapted from Solmate implementation (https://github.com/Rari-Capital/solmate/blob/main/src/utils/LibRLP.sol)\n function computeCreateAddress(address deployer, uint256 nonce) internal pure virtual returns (address) {\n console2_log_StdUtils(\"computeCreateAddress is deprecated. Please use vm.computeCreateAddress instead.\");\n return vm.computeCreateAddress(deployer, nonce);\n }\n\n function computeCreate2Address(bytes32 salt, bytes32 initcodeHash, address deployer)\n internal\n pure\n virtual\n returns (address)\n {\n console2_log_StdUtils(\"computeCreate2Address is deprecated. Please use vm.computeCreate2Address instead.\");\n return vm.computeCreate2Address(salt, initcodeHash, deployer);\n }\n\n /// @dev returns the address of a contract created with CREATE2 using the default CREATE2 deployer\n function computeCreate2Address(bytes32 salt, bytes32 initCodeHash) internal pure returns (address) {\n console2_log_StdUtils(\"computeCreate2Address is deprecated. Please use vm.computeCreate2Address instead.\");\n return vm.computeCreate2Address(salt, initCodeHash);\n }\n\n /// @dev returns the hash of the init code (creation code + no args) used in CREATE2 with no constructor arguments\n /// @param creationCode the creation code of a contract C, as returned by type(C).creationCode\n function hashInitCode(bytes memory creationCode) internal pure returns (bytes32) {\n return hashInitCode(creationCode, \"\");\n }\n\n /// @dev returns the hash of the init code (creation code + ABI-encoded args) used in CREATE2\n /// @param creationCode the creation code of a contract C, as returned by type(C).creationCode\n /// @param args the ABI-encoded arguments to the constructor of C\n function hashInitCode(bytes memory creationCode, bytes memory args) internal pure returns (bytes32) {\n return keccak256(abi.encodePacked(creationCode, args));\n }\n\n // Performs a single call with Multicall3 to query the ERC-20 token balances of the given addresses.\n function getTokenBalances(address token, address[] memory addresses)\n internal\n virtual\n returns (uint256[] memory balances)\n {\n uint256 tokenCodeSize;\n assembly {\n tokenCodeSize := extcodesize(token)\n }\n require(tokenCodeSize > 0, \"StdUtils getTokenBalances(address,address[]): Token address is not a contract.\");\n\n // ABI encode the aggregate call to Multicall3.\n uint256 length = addresses.length;\n IMulticall3.Call[] memory calls = new IMulticall3.Call[](length);\n for (uint256 i = 0; i < length; ++i) {\n // 0x70a08231 = bytes4(\"balanceOf(address)\"))\n calls[i] = IMulticall3.Call({target: token, callData: abi.encodeWithSelector(0x70a08231, (addresses[i]))});\n }\n\n // Make the aggregate call.\n (, bytes[] memory returnData) = multicall.aggregate(calls);\n\n // ABI decode the return data and return the balances.\n balances = new uint256[](length);\n for (uint256 i = 0; i < length; ++i) {\n balances[i] = abi.decode(returnData[i], (uint256));\n }\n }\n\n /*//////////////////////////////////////////////////////////////////////////\n PRIVATE FUNCTIONS\n //////////////////////////////////////////////////////////////////////////*/\n\n function addressFromLast20Bytes(bytes32 bytesValue) private pure returns (address) {\n return address(uint160(uint256(bytesValue)));\n }\n\n // This section is used to prevent the compilation of console, which shortens the compilation time when console is\n // not used elsewhere. We also trick the compiler into letting us make the console log methods as `pure` to avoid\n // any breaking changes to function signatures.\n function _castLogPayloadViewToPure(function(bytes memory) internal view fnIn)\n internal\n pure\n returns (function(bytes memory) internal pure fnOut)\n {\n assembly {\n fnOut := fnIn\n }\n }\n\n function _sendLogPayload(bytes memory payload) internal pure {\n _castLogPayloadViewToPure(_sendLogPayloadView)(payload);\n }\n\n function _sendLogPayloadView(bytes memory payload) private view {\n uint256 payloadLength = payload.length;\n address consoleAddress = CONSOLE2_ADDRESS;\n /// @solidity memory-safe-assembly\n assembly {\n let payloadStart := add(payload, 32)\n let r := staticcall(gas(), consoleAddress, payloadStart, payloadLength, 0, 0)\n }\n }\n\n function console2_log_StdUtils(string memory p0) private pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string)\", p0));\n }\n\n function console2_log_StdUtils(string memory p0, uint256 p1) private pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,uint256)\", p0, p1));\n }\n\n function console2_log_StdUtils(string memory p0, string memory p1) private pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,string)\", p0, p1));\n }\n}\n","license":"MIT"},"lib/forge-std/src/Vm.sol":{"keccak256":"0xd91fb0df409fbd22463e937b48b9682d9333c5d4528d8fe7b36102a0323c44bf","urls":[],"content":"// Automatically @generated by scripts/vm.py. Do not modify manually.\n\n// SPDX-License-Identifier: MIT OR Apache-2.0\npragma solidity >=0.6.2 <0.9.0;\npragma experimental ABIEncoderV2;\n\n/// The `VmSafe` interface does not allow manipulation of the EVM state or other actions that may\n/// result in Script simulations differing from on-chain execution. It is recommended to only use\n/// these cheats in scripts.\ninterface VmSafe {\n /// A modification applied to either `msg.sender` or `tx.origin`. Returned by `readCallers`.\n enum CallerMode {\n // No caller modification is currently active.\n None,\n // A one time broadcast triggered by a `vm.broadcast()` call is currently active.\n Broadcast,\n // A recurrent broadcast triggered by a `vm.startBroadcast()` call is currently active.\n RecurrentBroadcast,\n // A one time prank triggered by a `vm.prank()` call is currently active.\n Prank,\n // A recurrent prank triggered by a `vm.startPrank()` call is currently active.\n RecurrentPrank\n }\n\n /// The kind of account access that occurred.\n enum AccountAccessKind {\n // The account was called.\n Call,\n // The account was called via delegatecall.\n DelegateCall,\n // The account was called via callcode.\n CallCode,\n // The account was called via staticcall.\n StaticCall,\n // The account was created.\n Create,\n // The account was selfdestructed.\n SelfDestruct,\n // Synthetic access indicating the current context has resumed after a previous sub-context (AccountAccess).\n Resume,\n // The account's balance was read.\n Balance,\n // The account's codesize was read.\n Extcodesize,\n // The account's codehash was read.\n Extcodehash,\n // The account's code was copied.\n Extcodecopy\n }\n\n /// Forge execution contexts.\n enum ForgeContext {\n // Test group execution context (test, coverage or snapshot).\n TestGroup,\n // `forge test` execution context.\n Test,\n // `forge coverage` execution context.\n Coverage,\n // `forge snapshot` execution context.\n Snapshot,\n // Script group execution context (dry run, broadcast or resume).\n ScriptGroup,\n // `forge script` execution context.\n ScriptDryRun,\n // `forge script --broadcast` execution context.\n ScriptBroadcast,\n // `forge script --resume` execution context.\n ScriptResume,\n // Unknown `forge` execution context.\n Unknown\n }\n\n /// The transaction type (`txType`) of the broadcast.\n enum BroadcastTxType {\n // Represents a CALL broadcast tx.\n Call,\n // Represents a CREATE broadcast tx.\n Create,\n // Represents a CREATE2 broadcast tx.\n Create2\n }\n\n /// An Ethereum log. Returned by `getRecordedLogs`.\n struct Log {\n // The topics of the log, including the signature, if any.\n bytes32[] topics;\n // The raw data of the log.\n bytes data;\n // The address of the log's emitter.\n address emitter;\n }\n\n /// An RPC URL and its alias. Returned by `rpcUrlStructs`.\n struct Rpc {\n // The alias of the RPC URL.\n string key;\n // The RPC URL.\n string url;\n }\n\n /// An RPC log object. Returned by `eth_getLogs`.\n struct EthGetLogs {\n // The address of the log's emitter.\n address emitter;\n // The topics of the log, including the signature, if any.\n bytes32[] topics;\n // The raw data of the log.\n bytes data;\n // The block hash.\n bytes32 blockHash;\n // The block number.\n uint64 blockNumber;\n // The transaction hash.\n bytes32 transactionHash;\n // The transaction index in the block.\n uint64 transactionIndex;\n // The log index.\n uint256 logIndex;\n // Whether the log was removed.\n bool removed;\n }\n\n /// A single entry in a directory listing. Returned by `readDir`.\n struct DirEntry {\n // The error message, if any.\n string errorMessage;\n // The path of the entry.\n string path;\n // The depth of the entry.\n uint64 depth;\n // Whether the entry is a directory.\n bool isDir;\n // Whether the entry is a symlink.\n bool isSymlink;\n }\n\n /// Metadata information about a file.\n /// This structure is returned from the `fsMetadata` function and represents known\n /// metadata about a file such as its permissions, size, modification\n /// times, etc.\n struct FsMetadata {\n // True if this metadata is for a directory.\n bool isDir;\n // True if this metadata is for a symlink.\n bool isSymlink;\n // The size of the file, in bytes, this metadata is for.\n uint256 length;\n // True if this metadata is for a readonly (unwritable) file.\n bool readOnly;\n // The last modification time listed in this metadata.\n uint256 modified;\n // The last access time of this metadata.\n uint256 accessed;\n // The creation time listed in this metadata.\n uint256 created;\n }\n\n /// A wallet with a public and private key.\n struct Wallet {\n // The wallet's address.\n address addr;\n // The wallet's public key `X`.\n uint256 publicKeyX;\n // The wallet's public key `Y`.\n uint256 publicKeyY;\n // The wallet's private key.\n uint256 privateKey;\n }\n\n /// The result of a `tryFfi` call.\n struct FfiResult {\n // The exit code of the call.\n int32 exitCode;\n // The optionally hex-decoded `stdout` data.\n bytes stdout;\n // The `stderr` data.\n bytes stderr;\n }\n\n /// Information on the chain and fork.\n struct ChainInfo {\n // The fork identifier. Set to zero if no fork is active.\n uint256 forkId;\n // The chain ID of the current fork.\n uint256 chainId;\n }\n\n /// The result of a `stopAndReturnStateDiff` call.\n struct AccountAccess {\n // The chain and fork the access occurred.\n ChainInfo chainInfo;\n // The kind of account access that determines what the account is.\n // If kind is Call, DelegateCall, StaticCall or CallCode, then the account is the callee.\n // If kind is Create, then the account is the newly created account.\n // If kind is SelfDestruct, then the account is the selfdestruct recipient.\n // If kind is a Resume, then account represents a account context that has resumed.\n AccountAccessKind kind;\n // The account that was accessed.\n // It's either the account created, callee or a selfdestruct recipient for CREATE, CALL or SELFDESTRUCT.\n address account;\n // What accessed the account.\n address accessor;\n // If the account was initialized or empty prior to the access.\n // An account is considered initialized if it has code, a\n // non-zero nonce, or a non-zero balance.\n bool initialized;\n // The previous balance of the accessed account.\n uint256 oldBalance;\n // The potential new balance of the accessed account.\n // That is, all balance changes are recorded here, even if reverts occurred.\n uint256 newBalance;\n // Code of the account deployed by CREATE.\n bytes deployedCode;\n // Value passed along with the account access\n uint256 value;\n // Input data provided to the CREATE or CALL\n bytes data;\n // If this access reverted in either the current or parent context.\n bool reverted;\n // An ordered list of storage accesses made during an account access operation.\n StorageAccess[] storageAccesses;\n // Call depth traversed during the recording of state differences\n uint64 depth;\n }\n\n /// The storage accessed during an `AccountAccess`.\n struct StorageAccess {\n // The account whose storage was accessed.\n address account;\n // The slot that was accessed.\n bytes32 slot;\n // If the access was a write.\n bool isWrite;\n // The previous value of the slot.\n bytes32 previousValue;\n // The new value of the slot.\n bytes32 newValue;\n // If the access was reverted.\n bool reverted;\n }\n\n /// Gas used. Returned by `lastCallGas`.\n struct Gas {\n // The gas limit of the call.\n uint64 gasLimit;\n // The total gas used.\n uint64 gasTotalUsed;\n // DEPRECATED: The amount of gas used for memory expansion. Ref: \n uint64 gasMemoryUsed;\n // The amount of gas refunded.\n int64 gasRefunded;\n // The amount of gas remaining.\n uint64 gasRemaining;\n }\n\n /// The result of the `stopDebugTraceRecording` call\n struct DebugStep {\n // The stack before executing the step of the run.\n // stack\\[0\\] represents the top of the stack.\n // and only stack data relevant to the opcode execution is contained.\n uint256[] stack;\n // The memory input data before executing the step of the run.\n // only input data relevant to the opcode execution is contained.\n // e.g. for MLOAD, it will have memory\\[offset:offset+32\\] copied here.\n // the offset value can be get by the stack data.\n bytes memoryInput;\n // The opcode that was accessed.\n uint8 opcode;\n // The call depth of the step.\n uint64 depth;\n // Whether the call end up with out of gas error.\n bool isOutOfGas;\n // The contract address where the opcode is running\n address contractAddr;\n }\n\n /// Represents a transaction's broadcast details.\n struct BroadcastTxSummary {\n // The hash of the transaction that was broadcasted\n bytes32 txHash;\n // Represent the type of transaction among CALL, CREATE, CREATE2\n BroadcastTxType txType;\n // The address of the contract that was called or created.\n // This is address of the contract that is created if the txType is CREATE or CREATE2.\n address contractAddress;\n // The block number the transaction landed in.\n uint64 blockNumber;\n // Status of the transaction, retrieved from the transaction receipt.\n bool success;\n }\n\n /// Holds a signed EIP-7702 authorization for an authority account to delegate to an implementation.\n struct SignedDelegation {\n // The y-parity of the recovered secp256k1 signature (0 or 1).\n uint8 v;\n // First 32 bytes of the signature.\n bytes32 r;\n // Second 32 bytes of the signature.\n bytes32 s;\n // The current nonce of the authority account at signing time.\n // Used to ensure signature can't be replayed after account nonce changes.\n uint64 nonce;\n // Address of the contract implementation that will be delegated to.\n // Gets encoded into delegation code: 0xef0100 || implementation.\n address implementation;\n }\n\n /// Represents a \"potential\" revert reason from a single subsequent call when using `vm.assumeNoReverts`.\n /// Reverts that match will result in a FOUNDRY::ASSUME rejection, whereas unmatched reverts will be surfaced\n /// as normal.\n struct PotentialRevert {\n // The allowed origin of the revert opcode; address(0) allows reverts from any address\n address reverter;\n // When true, only matches on the beginning of the revert data, otherwise, matches on entire revert data\n bool partialMatch;\n // The data to use to match encountered reverts\n bytes revertData;\n }\n\n /// An EIP-2930 access list item.\n struct AccessListItem {\n // The address to be added in access list.\n address target;\n // The storage keys to be added in access list.\n bytes32[] storageKeys;\n }\n\n // ======== Crypto ========\n\n /// Derives a private key from the name, labels the account with that name, and returns the wallet.\n function createWallet(string calldata walletLabel) external returns (Wallet memory wallet);\n\n /// Generates a wallet from the private key and returns the wallet.\n function createWallet(uint256 privateKey) external returns (Wallet memory wallet);\n\n /// Generates a wallet from the private key, labels the account with that name, and returns the wallet.\n function createWallet(uint256 privateKey, string calldata walletLabel) external returns (Wallet memory wallet);\n\n /// Derive a private key from a provided mnenomic string (or mnenomic file path)\n /// at the derivation path `m/44'/60'/0'/0/{index}`.\n function deriveKey(string calldata mnemonic, uint32 index) external pure returns (uint256 privateKey);\n\n /// Derive a private key from a provided mnenomic string (or mnenomic file path)\n /// at `{derivationPath}{index}`.\n function deriveKey(string calldata mnemonic, string calldata derivationPath, uint32 index)\n external\n pure\n returns (uint256 privateKey);\n\n /// Derive a private key from a provided mnenomic string (or mnenomic file path) in the specified language\n /// at the derivation path `m/44'/60'/0'/0/{index}`.\n function deriveKey(string calldata mnemonic, uint32 index, string calldata language)\n external\n pure\n returns (uint256 privateKey);\n\n /// Derive a private key from a provided mnenomic string (or mnenomic file path) in the specified language\n /// at `{derivationPath}{index}`.\n function deriveKey(string calldata mnemonic, string calldata derivationPath, uint32 index, string calldata language)\n external\n pure\n returns (uint256 privateKey);\n\n /// Derives secp256r1 public key from the provided `privateKey`.\n function publicKeyP256(uint256 privateKey) external pure returns (uint256 publicKeyX, uint256 publicKeyY);\n\n /// Adds a private key to the local forge wallet and returns the address.\n function rememberKey(uint256 privateKey) external returns (address keyAddr);\n\n /// Derive a set number of wallets from a mnemonic at the derivation path `m/44'/60'/0'/0/{0..count}`.\n /// The respective private keys are saved to the local forge wallet for later use and their addresses are returned.\n function rememberKeys(string calldata mnemonic, string calldata derivationPath, uint32 count)\n external\n returns (address[] memory keyAddrs);\n\n /// Derive a set number of wallets from a mnemonic in the specified language at the derivation path `m/44'/60'/0'/0/{0..count}`.\n /// The respective private keys are saved to the local forge wallet for later use and their addresses are returned.\n function rememberKeys(\n string calldata mnemonic,\n string calldata derivationPath,\n string calldata language,\n uint32 count\n ) external returns (address[] memory keyAddrs);\n\n /// Signs data with a `Wallet`.\n /// Returns a compact signature (`r`, `vs`) as per EIP-2098, where `vs` encodes both the\n /// signature's `s` value, and the recovery id `v` in a single bytes32.\n /// This format reduces the signature size from 65 to 64 bytes.\n function signCompact(Wallet calldata wallet, bytes32 digest) external returns (bytes32 r, bytes32 vs);\n\n /// Signs `digest` with `privateKey` using the secp256k1 curve.\n /// Returns a compact signature (`r`, `vs`) as per EIP-2098, where `vs` encodes both the\n /// signature's `s` value, and the recovery id `v` in a single bytes32.\n /// This format reduces the signature size from 65 to 64 bytes.\n function signCompact(uint256 privateKey, bytes32 digest) external pure returns (bytes32 r, bytes32 vs);\n\n /// Signs `digest` with signer provided to script using the secp256k1 curve.\n /// Returns a compact signature (`r`, `vs`) as per EIP-2098, where `vs` encodes both the\n /// signature's `s` value, and the recovery id `v` in a single bytes32.\n /// This format reduces the signature size from 65 to 64 bytes.\n /// If `--sender` is provided, the signer with provided address is used, otherwise,\n /// if exactly one signer is provided to the script, that signer is used.\n /// Raises error if signer passed through `--sender` does not match any unlocked signers or\n /// if `--sender` is not provided and not exactly one signer is passed to the script.\n function signCompact(bytes32 digest) external pure returns (bytes32 r, bytes32 vs);\n\n /// Signs `digest` with signer provided to script using the secp256k1 curve.\n /// Returns a compact signature (`r`, `vs`) as per EIP-2098, where `vs` encodes both the\n /// signature's `s` value, and the recovery id `v` in a single bytes32.\n /// This format reduces the signature size from 65 to 64 bytes.\n /// Raises error if none of the signers passed into the script have provided address.\n function signCompact(address signer, bytes32 digest) external pure returns (bytes32 r, bytes32 vs);\n\n /// Signs `digest` with `privateKey` using the secp256r1 curve.\n function signP256(uint256 privateKey, bytes32 digest) external pure returns (bytes32 r, bytes32 s);\n\n /// Signs data with a `Wallet`.\n function sign(Wallet calldata wallet, bytes32 digest) external returns (uint8 v, bytes32 r, bytes32 s);\n\n /// Signs `digest` with `privateKey` using the secp256k1 curve.\n function sign(uint256 privateKey, bytes32 digest) external pure returns (uint8 v, bytes32 r, bytes32 s);\n\n /// Signs `digest` with signer provided to script using the secp256k1 curve.\n /// If `--sender` is provided, the signer with provided address is used, otherwise,\n /// if exactly one signer is provided to the script, that signer is used.\n /// Raises error if signer passed through `--sender` does not match any unlocked signers or\n /// if `--sender` is not provided and not exactly one signer is passed to the script.\n function sign(bytes32 digest) external pure returns (uint8 v, bytes32 r, bytes32 s);\n\n /// Signs `digest` with signer provided to script using the secp256k1 curve.\n /// Raises error if none of the signers passed into the script have provided address.\n function sign(address signer, bytes32 digest) external pure returns (uint8 v, bytes32 r, bytes32 s);\n\n // ======== Environment ========\n\n /// Gets the environment variable `name` and parses it as `address`.\n /// Reverts if the variable was not found or could not be parsed.\n function envAddress(string calldata name) external view returns (address value);\n\n /// Gets the environment variable `name` and parses it as an array of `address`, delimited by `delim`.\n /// Reverts if the variable was not found or could not be parsed.\n function envAddress(string calldata name, string calldata delim) external view returns (address[] memory value);\n\n /// Gets the environment variable `name` and parses it as `bool`.\n /// Reverts if the variable was not found or could not be parsed.\n function envBool(string calldata name) external view returns (bool value);\n\n /// Gets the environment variable `name` and parses it as an array of `bool`, delimited by `delim`.\n /// Reverts if the variable was not found or could not be parsed.\n function envBool(string calldata name, string calldata delim) external view returns (bool[] memory value);\n\n /// Gets the environment variable `name` and parses it as `bytes32`.\n /// Reverts if the variable was not found or could not be parsed.\n function envBytes32(string calldata name) external view returns (bytes32 value);\n\n /// Gets the environment variable `name` and parses it as an array of `bytes32`, delimited by `delim`.\n /// Reverts if the variable was not found or could not be parsed.\n function envBytes32(string calldata name, string calldata delim) external view returns (bytes32[] memory value);\n\n /// Gets the environment variable `name` and parses it as `bytes`.\n /// Reverts if the variable was not found or could not be parsed.\n function envBytes(string calldata name) external view returns (bytes memory value);\n\n /// Gets the environment variable `name` and parses it as an array of `bytes`, delimited by `delim`.\n /// Reverts if the variable was not found or could not be parsed.\n function envBytes(string calldata name, string calldata delim) external view returns (bytes[] memory value);\n\n /// Gets the environment variable `name` and returns true if it exists, else returns false.\n function envExists(string calldata name) external view returns (bool result);\n\n /// Gets the environment variable `name` and parses it as `int256`.\n /// Reverts if the variable was not found or could not be parsed.\n function envInt(string calldata name) external view returns (int256 value);\n\n /// Gets the environment variable `name` and parses it as an array of `int256`, delimited by `delim`.\n /// Reverts if the variable was not found or could not be parsed.\n function envInt(string calldata name, string calldata delim) external view returns (int256[] memory value);\n\n /// Gets the environment variable `name` and parses it as `bool`.\n /// Reverts if the variable could not be parsed.\n /// Returns `defaultValue` if the variable was not found.\n function envOr(string calldata name, bool defaultValue) external view returns (bool value);\n\n /// Gets the environment variable `name` and parses it as `uint256`.\n /// Reverts if the variable could not be parsed.\n /// Returns `defaultValue` if the variable was not found.\n function envOr(string calldata name, uint256 defaultValue) external view returns (uint256 value);\n\n /// Gets the environment variable `name` and parses it as an array of `address`, delimited by `delim`.\n /// Reverts if the variable could not be parsed.\n /// Returns `defaultValue` if the variable was not found.\n function envOr(string calldata name, string calldata delim, address[] calldata defaultValue)\n external\n view\n returns (address[] memory value);\n\n /// Gets the environment variable `name` and parses it as an array of `bytes32`, delimited by `delim`.\n /// Reverts if the variable could not be parsed.\n /// Returns `defaultValue` if the variable was not found.\n function envOr(string calldata name, string calldata delim, bytes32[] calldata defaultValue)\n external\n view\n returns (bytes32[] memory value);\n\n /// Gets the environment variable `name` and parses it as an array of `string`, delimited by `delim`.\n /// Reverts if the variable could not be parsed.\n /// Returns `defaultValue` if the variable was not found.\n function envOr(string calldata name, string calldata delim, string[] calldata defaultValue)\n external\n view\n returns (string[] memory value);\n\n /// Gets the environment variable `name` and parses it as an array of `bytes`, delimited by `delim`.\n /// Reverts if the variable could not be parsed.\n /// Returns `defaultValue` if the variable was not found.\n function envOr(string calldata name, string calldata delim, bytes[] calldata defaultValue)\n external\n view\n returns (bytes[] memory value);\n\n /// Gets the environment variable `name` and parses it as `int256`.\n /// Reverts if the variable could not be parsed.\n /// Returns `defaultValue` if the variable was not found.\n function envOr(string calldata name, int256 defaultValue) external view returns (int256 value);\n\n /// Gets the environment variable `name` and parses it as `address`.\n /// Reverts if the variable could not be parsed.\n /// Returns `defaultValue` if the variable was not found.\n function envOr(string calldata name, address defaultValue) external view returns (address value);\n\n /// Gets the environment variable `name` and parses it as `bytes32`.\n /// Reverts if the variable could not be parsed.\n /// Returns `defaultValue` if the variable was not found.\n function envOr(string calldata name, bytes32 defaultValue) external view returns (bytes32 value);\n\n /// Gets the environment variable `name` and parses it as `string`.\n /// Reverts if the variable could not be parsed.\n /// Returns `defaultValue` if the variable was not found.\n function envOr(string calldata name, string calldata defaultValue) external view returns (string memory value);\n\n /// Gets the environment variable `name` and parses it as `bytes`.\n /// Reverts if the variable could not be parsed.\n /// Returns `defaultValue` if the variable was not found.\n function envOr(string calldata name, bytes calldata defaultValue) external view returns (bytes memory value);\n\n /// Gets the environment variable `name` and parses it as an array of `bool`, delimited by `delim`.\n /// Reverts if the variable could not be parsed.\n /// Returns `defaultValue` if the variable was not found.\n function envOr(string calldata name, string calldata delim, bool[] calldata defaultValue)\n external\n view\n returns (bool[] memory value);\n\n /// Gets the environment variable `name` and parses it as an array of `uint256`, delimited by `delim`.\n /// Reverts if the variable could not be parsed.\n /// Returns `defaultValue` if the variable was not found.\n function envOr(string calldata name, string calldata delim, uint256[] calldata defaultValue)\n external\n view\n returns (uint256[] memory value);\n\n /// Gets the environment variable `name` and parses it as an array of `int256`, delimited by `delim`.\n /// Reverts if the variable could not be parsed.\n /// Returns `defaultValue` if the variable was not found.\n function envOr(string calldata name, string calldata delim, int256[] calldata defaultValue)\n external\n view\n returns (int256[] memory value);\n\n /// Gets the environment variable `name` and parses it as `string`.\n /// Reverts if the variable was not found or could not be parsed.\n function envString(string calldata name) external view returns (string memory value);\n\n /// Gets the environment variable `name` and parses it as an array of `string`, delimited by `delim`.\n /// Reverts if the variable was not found or could not be parsed.\n function envString(string calldata name, string calldata delim) external view returns (string[] memory value);\n\n /// Gets the environment variable `name` and parses it as `uint256`.\n /// Reverts if the variable was not found or could not be parsed.\n function envUint(string calldata name) external view returns (uint256 value);\n\n /// Gets the environment variable `name` and parses it as an array of `uint256`, delimited by `delim`.\n /// Reverts if the variable was not found or could not be parsed.\n function envUint(string calldata name, string calldata delim) external view returns (uint256[] memory value);\n\n /// Returns true if `forge` command was executed in given context.\n function isContext(ForgeContext context) external view returns (bool result);\n\n /// Sets environment variables.\n function setEnv(string calldata name, string calldata value) external;\n\n // ======== EVM ========\n\n /// Gets all accessed reads and write slot from a `vm.record` session, for a given address.\n function accesses(address target) external returns (bytes32[] memory readSlots, bytes32[] memory writeSlots);\n\n /// Gets the address for a given private key.\n function addr(uint256 privateKey) external pure returns (address keyAddr);\n\n /// Gets all the logs according to specified filter.\n function eth_getLogs(uint256 fromBlock, uint256 toBlock, address target, bytes32[] calldata topics)\n external\n returns (EthGetLogs[] memory logs);\n\n /// Gets the current `block.blobbasefee`.\n /// You should use this instead of `block.blobbasefee` if you use `vm.blobBaseFee`, as `block.blobbasefee` is assumed to be constant across a transaction,\n /// and as a result will get optimized out by the compiler.\n /// See https://github.com/foundry-rs/foundry/issues/6180\n function getBlobBaseFee() external view returns (uint256 blobBaseFee);\n\n /// Gets the current `block.number`.\n /// You should use this instead of `block.number` if you use `vm.roll`, as `block.number` is assumed to be constant across a transaction,\n /// and as a result will get optimized out by the compiler.\n /// See https://github.com/foundry-rs/foundry/issues/6180\n function getBlockNumber() external view returns (uint256 height);\n\n /// Gets the current `block.timestamp`.\n /// You should use this instead of `block.timestamp` if you use `vm.warp`, as `block.timestamp` is assumed to be constant across a transaction,\n /// and as a result will get optimized out by the compiler.\n /// See https://github.com/foundry-rs/foundry/issues/6180\n function getBlockTimestamp() external view returns (uint256 timestamp);\n\n /// Gets the map key and parent of a mapping at a given slot, for a given address.\n function getMappingKeyAndParentOf(address target, bytes32 elementSlot)\n external\n returns (bool found, bytes32 key, bytes32 parent);\n\n /// Gets the number of elements in the mapping at the given slot, for a given address.\n function getMappingLength(address target, bytes32 mappingSlot) external returns (uint256 length);\n\n /// Gets the elements at index idx of the mapping at the given slot, for a given address. The\n /// index must be less than the length of the mapping (i.e. the number of keys in the mapping).\n function getMappingSlotAt(address target, bytes32 mappingSlot, uint256 idx) external returns (bytes32 value);\n\n /// Gets the nonce of an account.\n function getNonce(address account) external view returns (uint64 nonce);\n\n /// Get the nonce of a `Wallet`.\n function getNonce(Wallet calldata wallet) external returns (uint64 nonce);\n\n /// Gets all the recorded logs.\n function getRecordedLogs() external returns (Log[] memory logs);\n\n /// Returns state diffs from current `vm.startStateDiffRecording` session.\n function getStateDiff() external view returns (string memory diff);\n\n /// Returns state diffs from current `vm.startStateDiffRecording` session, in json format.\n function getStateDiffJson() external view returns (string memory diff);\n\n /// Gets the gas used in the last call from the callee perspective.\n function lastCallGas() external view returns (Gas memory gas);\n\n /// Loads a storage slot from an address.\n function load(address target, bytes32 slot) external view returns (bytes32 data);\n\n /// Pauses gas metering (i.e. gas usage is not counted). Noop if already paused.\n function pauseGasMetering() external;\n\n /// Records all storage reads and writes.\n function record() external;\n\n /// Record all the transaction logs.\n function recordLogs() external;\n\n /// Reset gas metering (i.e. gas usage is set to gas limit).\n function resetGasMetering() external;\n\n /// Resumes gas metering (i.e. gas usage is counted again). Noop if already on.\n function resumeGasMetering() external;\n\n /// Performs an Ethereum JSON-RPC request to the current fork URL.\n function rpc(string calldata method, string calldata params) external returns (bytes memory data);\n\n /// Performs an Ethereum JSON-RPC request to the given endpoint.\n function rpc(string calldata urlOrAlias, string calldata method, string calldata params)\n external\n returns (bytes memory data);\n\n /// Records the debug trace during the run.\n function startDebugTraceRecording() external;\n\n /// Starts recording all map SSTOREs for later retrieval.\n function startMappingRecording() external;\n\n /// Record all account accesses as part of CREATE, CALL or SELFDESTRUCT opcodes in order,\n /// along with the context of the calls\n function startStateDiffRecording() external;\n\n /// Stop debug trace recording and returns the recorded debug trace.\n function stopAndReturnDebugTraceRecording() external returns (DebugStep[] memory step);\n\n /// Returns an ordered array of all account accesses from a `vm.startStateDiffRecording` session.\n function stopAndReturnStateDiff() external returns (AccountAccess[] memory accountAccesses);\n\n /// Stops recording all map SSTOREs for later retrieval and clears the recorded data.\n function stopMappingRecording() external;\n\n // ======== Filesystem ========\n\n /// Closes file for reading, resetting the offset and allowing to read it from beginning with readLine.\n /// `path` is relative to the project root.\n function closeFile(string calldata path) external;\n\n /// Copies the contents of one file to another. This function will **overwrite** the contents of `to`.\n /// On success, the total number of bytes copied is returned and it is equal to the length of the `to` file as reported by `metadata`.\n /// Both `from` and `to` are relative to the project root.\n function copyFile(string calldata from, string calldata to) external returns (uint64 copied);\n\n /// Creates a new, empty directory at the provided path.\n /// This cheatcode will revert in the following situations, but is not limited to just these cases:\n /// - User lacks permissions to modify `path`.\n /// - A parent of the given path doesn't exist and `recursive` is false.\n /// - `path` already exists and `recursive` is false.\n /// `path` is relative to the project root.\n function createDir(string calldata path, bool recursive) external;\n\n /// Deploys a contract from an artifact file. Takes in the relative path to the json file or the path to the\n /// artifact in the form of :: where and parts are optional.\n function deployCode(string calldata artifactPath) external returns (address deployedAddress);\n\n /// Deploys a contract from an artifact file. Takes in the relative path to the json file or the path to the\n /// artifact in the form of :: where and parts are optional.\n /// Additionally accepts abi-encoded constructor arguments.\n function deployCode(string calldata artifactPath, bytes calldata constructorArgs)\n external\n returns (address deployedAddress);\n\n /// Returns true if the given path points to an existing entity, else returns false.\n function exists(string calldata path) external view returns (bool result);\n\n /// Performs a foreign function call via the terminal.\n function ffi(string[] calldata commandInput) external returns (bytes memory result);\n\n /// Given a path, query the file system to get information about a file, directory, etc.\n function fsMetadata(string calldata path) external view returns (FsMetadata memory metadata);\n\n /// Gets the artifact path from code (aka. creation code).\n function getArtifactPathByCode(bytes calldata code) external view returns (string memory path);\n\n /// Gets the artifact path from deployed code (aka. runtime code).\n function getArtifactPathByDeployedCode(bytes calldata deployedCode) external view returns (string memory path);\n\n /// Returns the most recent broadcast for the given contract on `chainId` matching `txType`.\n /// For example:\n /// The most recent deployment can be fetched by passing `txType` as `CREATE` or `CREATE2`.\n /// The most recent call can be fetched by passing `txType` as `CALL`.\n function getBroadcast(string calldata contractName, uint64 chainId, BroadcastTxType txType)\n external\n view\n returns (BroadcastTxSummary memory);\n\n /// Returns all broadcasts for the given contract on `chainId` with the specified `txType`.\n /// Sorted such that the most recent broadcast is the first element, and the oldest is the last. i.e descending order of BroadcastTxSummary.blockNumber.\n function getBroadcasts(string calldata contractName, uint64 chainId, BroadcastTxType txType)\n external\n view\n returns (BroadcastTxSummary[] memory);\n\n /// Returns all broadcasts for the given contract on `chainId`.\n /// Sorted such that the most recent broadcast is the first element, and the oldest is the last. i.e descending order of BroadcastTxSummary.blockNumber.\n function getBroadcasts(string calldata contractName, uint64 chainId)\n external\n view\n returns (BroadcastTxSummary[] memory);\n\n /// Gets the creation bytecode from an artifact file. Takes in the relative path to the json file or the path to the\n /// artifact in the form of :: where and parts are optional.\n function getCode(string calldata artifactPath) external view returns (bytes memory creationBytecode);\n\n /// Gets the deployed bytecode from an artifact file. Takes in the relative path to the json file or the path to the\n /// artifact in the form of :: where and parts are optional.\n function getDeployedCode(string calldata artifactPath) external view returns (bytes memory runtimeBytecode);\n\n /// Returns the most recent deployment for the current `chainId`.\n function getDeployment(string calldata contractName) external view returns (address deployedAddress);\n\n /// Returns the most recent deployment for the given contract on `chainId`\n function getDeployment(string calldata contractName, uint64 chainId)\n external\n view\n returns (address deployedAddress);\n\n /// Returns all deployments for the given contract on `chainId`\n /// Sorted in descending order of deployment time i.e descending order of BroadcastTxSummary.blockNumber.\n /// The most recent deployment is the first element, and the oldest is the last.\n function getDeployments(string calldata contractName, uint64 chainId)\n external\n view\n returns (address[] memory deployedAddresses);\n\n /// Returns true if the path exists on disk and is pointing at a directory, else returns false.\n function isDir(string calldata path) external view returns (bool result);\n\n /// Returns true if the path exists on disk and is pointing at a regular file, else returns false.\n function isFile(string calldata path) external view returns (bool result);\n\n /// Get the path of the current project root.\n function projectRoot() external view returns (string memory path);\n\n /// Prompts the user for a string value in the terminal.\n function prompt(string calldata promptText) external returns (string memory input);\n\n /// Prompts the user for an address in the terminal.\n function promptAddress(string calldata promptText) external returns (address);\n\n /// Prompts the user for a hidden string value in the terminal.\n function promptSecret(string calldata promptText) external returns (string memory input);\n\n /// Prompts the user for hidden uint256 in the terminal (usually pk).\n function promptSecretUint(string calldata promptText) external returns (uint256);\n\n /// Prompts the user for uint256 in the terminal.\n function promptUint(string calldata promptText) external returns (uint256);\n\n /// Reads the directory at the given path recursively, up to `maxDepth`.\n /// `maxDepth` defaults to 1, meaning only the direct children of the given directory will be returned.\n /// Follows symbolic links if `followLinks` is true.\n function readDir(string calldata path) external view returns (DirEntry[] memory entries);\n\n /// See `readDir(string)`.\n function readDir(string calldata path, uint64 maxDepth) external view returns (DirEntry[] memory entries);\n\n /// See `readDir(string)`.\n function readDir(string calldata path, uint64 maxDepth, bool followLinks)\n external\n view\n returns (DirEntry[] memory entries);\n\n /// Reads the entire content of file to string. `path` is relative to the project root.\n function readFile(string calldata path) external view returns (string memory data);\n\n /// Reads the entire content of file as binary. `path` is relative to the project root.\n function readFileBinary(string calldata path) external view returns (bytes memory data);\n\n /// Reads next line of file to string.\n function readLine(string calldata path) external view returns (string memory line);\n\n /// Reads a symbolic link, returning the path that the link points to.\n /// This cheatcode will revert in the following situations, but is not limited to just these cases:\n /// - `path` is not a symbolic link.\n /// - `path` does not exist.\n function readLink(string calldata linkPath) external view returns (string memory targetPath);\n\n /// Removes a directory at the provided path.\n /// This cheatcode will revert in the following situations, but is not limited to just these cases:\n /// - `path` doesn't exist.\n /// - `path` isn't a directory.\n /// - User lacks permissions to modify `path`.\n /// - The directory is not empty and `recursive` is false.\n /// `path` is relative to the project root.\n function removeDir(string calldata path, bool recursive) external;\n\n /// Removes a file from the filesystem.\n /// This cheatcode will revert in the following situations, but is not limited to just these cases:\n /// - `path` points to a directory.\n /// - The file doesn't exist.\n /// - The user lacks permissions to remove the file.\n /// `path` is relative to the project root.\n function removeFile(string calldata path) external;\n\n /// Performs a foreign function call via terminal and returns the exit code, stdout, and stderr.\n function tryFfi(string[] calldata commandInput) external returns (FfiResult memory result);\n\n /// Returns the time since unix epoch in milliseconds.\n function unixTime() external view returns (uint256 milliseconds);\n\n /// Writes data to file, creating a file if it does not exist, and entirely replacing its contents if it does.\n /// `path` is relative to the project root.\n function writeFile(string calldata path, string calldata data) external;\n\n /// Writes binary data to a file, creating a file if it does not exist, and entirely replacing its contents if it does.\n /// `path` is relative to the project root.\n function writeFileBinary(string calldata path, bytes calldata data) external;\n\n /// Writes line to file, creating a file if it does not exist.\n /// `path` is relative to the project root.\n function writeLine(string calldata path, string calldata data) external;\n\n // ======== JSON ========\n\n /// Checks if `key` exists in a JSON object.\n function keyExistsJson(string calldata json, string calldata key) external view returns (bool);\n\n /// Parses a string of JSON data at `key` and coerces it to `address`.\n function parseJsonAddress(string calldata json, string calldata key) external pure returns (address);\n\n /// Parses a string of JSON data at `key` and coerces it to `address[]`.\n function parseJsonAddressArray(string calldata json, string calldata key)\n external\n pure\n returns (address[] memory);\n\n /// Parses a string of JSON data at `key` and coerces it to `bool`.\n function parseJsonBool(string calldata json, string calldata key) external pure returns (bool);\n\n /// Parses a string of JSON data at `key` and coerces it to `bool[]`.\n function parseJsonBoolArray(string calldata json, string calldata key) external pure returns (bool[] memory);\n\n /// Parses a string of JSON data at `key` and coerces it to `bytes`.\n function parseJsonBytes(string calldata json, string calldata key) external pure returns (bytes memory);\n\n /// Parses a string of JSON data at `key` and coerces it to `bytes32`.\n function parseJsonBytes32(string calldata json, string calldata key) external pure returns (bytes32);\n\n /// Parses a string of JSON data at `key` and coerces it to `bytes32[]`.\n function parseJsonBytes32Array(string calldata json, string calldata key)\n external\n pure\n returns (bytes32[] memory);\n\n /// Parses a string of JSON data at `key` and coerces it to `bytes[]`.\n function parseJsonBytesArray(string calldata json, string calldata key) external pure returns (bytes[] memory);\n\n /// Parses a string of JSON data at `key` and coerces it to `int256`.\n function parseJsonInt(string calldata json, string calldata key) external pure returns (int256);\n\n /// Parses a string of JSON data at `key` and coerces it to `int256[]`.\n function parseJsonIntArray(string calldata json, string calldata key) external pure returns (int256[] memory);\n\n /// Returns an array of all the keys in a JSON object.\n function parseJsonKeys(string calldata json, string calldata key) external pure returns (string[] memory keys);\n\n /// Parses a string of JSON data at `key` and coerces it to `string`.\n function parseJsonString(string calldata json, string calldata key) external pure returns (string memory);\n\n /// Parses a string of JSON data at `key` and coerces it to `string[]`.\n function parseJsonStringArray(string calldata json, string calldata key) external pure returns (string[] memory);\n\n /// Parses a string of JSON data at `key` and coerces it to type array corresponding to `typeDescription`.\n function parseJsonTypeArray(string calldata json, string calldata key, string calldata typeDescription)\n external\n pure\n returns (bytes memory);\n\n /// Parses a string of JSON data and coerces it to type corresponding to `typeDescription`.\n function parseJsonType(string calldata json, string calldata typeDescription)\n external\n pure\n returns (bytes memory);\n\n /// Parses a string of JSON data at `key` and coerces it to type corresponding to `typeDescription`.\n function parseJsonType(string calldata json, string calldata key, string calldata typeDescription)\n external\n pure\n returns (bytes memory);\n\n /// Parses a string of JSON data at `key` and coerces it to `uint256`.\n function parseJsonUint(string calldata json, string calldata key) external pure returns (uint256);\n\n /// Parses a string of JSON data at `key` and coerces it to `uint256[]`.\n function parseJsonUintArray(string calldata json, string calldata key) external pure returns (uint256[] memory);\n\n /// ABI-encodes a JSON object.\n function parseJson(string calldata json) external pure returns (bytes memory abiEncodedData);\n\n /// ABI-encodes a JSON object at `key`.\n function parseJson(string calldata json, string calldata key) external pure returns (bytes memory abiEncodedData);\n\n /// See `serializeJson`.\n function serializeAddress(string calldata objectKey, string calldata valueKey, address value)\n external\n returns (string memory json);\n\n /// See `serializeJson`.\n function serializeAddress(string calldata objectKey, string calldata valueKey, address[] calldata values)\n external\n returns (string memory json);\n\n /// See `serializeJson`.\n function serializeBool(string calldata objectKey, string calldata valueKey, bool value)\n external\n returns (string memory json);\n\n /// See `serializeJson`.\n function serializeBool(string calldata objectKey, string calldata valueKey, bool[] calldata values)\n external\n returns (string memory json);\n\n /// See `serializeJson`.\n function serializeBytes32(string calldata objectKey, string calldata valueKey, bytes32 value)\n external\n returns (string memory json);\n\n /// See `serializeJson`.\n function serializeBytes32(string calldata objectKey, string calldata valueKey, bytes32[] calldata values)\n external\n returns (string memory json);\n\n /// See `serializeJson`.\n function serializeBytes(string calldata objectKey, string calldata valueKey, bytes calldata value)\n external\n returns (string memory json);\n\n /// See `serializeJson`.\n function serializeBytes(string calldata objectKey, string calldata valueKey, bytes[] calldata values)\n external\n returns (string memory json);\n\n /// See `serializeJson`.\n function serializeInt(string calldata objectKey, string calldata valueKey, int256 value)\n external\n returns (string memory json);\n\n /// See `serializeJson`.\n function serializeInt(string calldata objectKey, string calldata valueKey, int256[] calldata values)\n external\n returns (string memory json);\n\n /// Serializes a key and value to a JSON object stored in-memory that can be later written to a file.\n /// Returns the stringified version of the specific JSON file up to that moment.\n function serializeJson(string calldata objectKey, string calldata value) external returns (string memory json);\n\n /// See `serializeJson`.\n function serializeJsonType(string calldata typeDescription, bytes calldata value)\n external\n pure\n returns (string memory json);\n\n /// See `serializeJson`.\n function serializeJsonType(\n string calldata objectKey,\n string calldata valueKey,\n string calldata typeDescription,\n bytes calldata value\n ) external returns (string memory json);\n\n /// See `serializeJson`.\n function serializeString(string calldata objectKey, string calldata valueKey, string calldata value)\n external\n returns (string memory json);\n\n /// See `serializeJson`.\n function serializeString(string calldata objectKey, string calldata valueKey, string[] calldata values)\n external\n returns (string memory json);\n\n /// See `serializeJson`.\n function serializeUintToHex(string calldata objectKey, string calldata valueKey, uint256 value)\n external\n returns (string memory json);\n\n /// See `serializeJson`.\n function serializeUint(string calldata objectKey, string calldata valueKey, uint256 value)\n external\n returns (string memory json);\n\n /// See `serializeJson`.\n function serializeUint(string calldata objectKey, string calldata valueKey, uint256[] calldata values)\n external\n returns (string memory json);\n\n /// Write a serialized JSON object to a file. If the file exists, it will be overwritten.\n function writeJson(string calldata json, string calldata path) external;\n\n /// Write a serialized JSON object to an **existing** JSON file, replacing a value with key = \n /// This is useful to replace a specific value of a JSON file, without having to parse the entire thing.\n function writeJson(string calldata json, string calldata path, string calldata valueKey) external;\n\n /// Checks if `key` exists in a JSON object\n /// `keyExists` is being deprecated in favor of `keyExistsJson`. It will be removed in future versions.\n function keyExists(string calldata json, string calldata key) external view returns (bool);\n\n // ======== Scripting ========\n\n /// Designate the next call as an EIP-7702 transaction\n function attachDelegation(SignedDelegation calldata signedDelegation) external;\n\n /// Takes a signed transaction and broadcasts it to the network.\n function broadcastRawTransaction(bytes calldata data) external;\n\n /// Has the next call (at this call depth only) create transactions that can later be signed and sent onchain.\n /// Broadcasting address is determined by checking the following in order:\n /// 1. If `--sender` argument was provided, that address is used.\n /// 2. If exactly one signer (e.g. private key, hw wallet, keystore) is set when `forge broadcast` is invoked, that signer is used.\n /// 3. Otherwise, default foundry sender (1804c8AB1F12E6bbf3894d4083f33e07309d1f38) is used.\n function broadcast() external;\n\n /// Has the next call (at this call depth only) create a transaction with the address provided\n /// as the sender that can later be signed and sent onchain.\n function broadcast(address signer) external;\n\n /// Has the next call (at this call depth only) create a transaction with the private key\n /// provided as the sender that can later be signed and sent onchain.\n function broadcast(uint256 privateKey) external;\n\n /// Returns addresses of available unlocked wallets in the script environment.\n function getWallets() external returns (address[] memory wallets);\n\n /// Sign an EIP-7702 authorization and designate the next call as an EIP-7702 transaction\n function signAndAttachDelegation(address implementation, uint256 privateKey)\n external\n returns (SignedDelegation memory signedDelegation);\n\n /// Sign an EIP-7702 authorization for delegation\n function signDelegation(address implementation, uint256 privateKey)\n external\n returns (SignedDelegation memory signedDelegation);\n\n /// Has all subsequent calls (at this call depth only) create transactions that can later be signed and sent onchain.\n /// Broadcasting address is determined by checking the following in order:\n /// 1. If `--sender` argument was provided, that address is used.\n /// 2. If exactly one signer (e.g. private key, hw wallet, keystore) is set when `forge broadcast` is invoked, that signer is used.\n /// 3. Otherwise, default foundry sender (1804c8AB1F12E6bbf3894d4083f33e07309d1f38) is used.\n function startBroadcast() external;\n\n /// Has all subsequent calls (at this call depth only) create transactions with the address\n /// provided that can later be signed and sent onchain.\n function startBroadcast(address signer) external;\n\n /// Has all subsequent calls (at this call depth only) create transactions with the private key\n /// provided that can later be signed and sent onchain.\n function startBroadcast(uint256 privateKey) external;\n\n /// Stops collecting onchain transactions.\n function stopBroadcast() external;\n\n // ======== String ========\n\n /// Returns true if `search` is found in `subject`, false otherwise.\n function contains(string calldata subject, string calldata search) external returns (bool result);\n\n /// Returns the index of the first occurrence of a `key` in an `input` string.\n /// Returns `NOT_FOUND` (i.e. `type(uint256).max`) if the `key` is not found.\n /// Returns 0 in case of an empty `key`.\n function indexOf(string calldata input, string calldata key) external pure returns (uint256);\n\n /// Parses the given `string` into an `address`.\n function parseAddress(string calldata stringifiedValue) external pure returns (address parsedValue);\n\n /// Parses the given `string` into a `bool`.\n function parseBool(string calldata stringifiedValue) external pure returns (bool parsedValue);\n\n /// Parses the given `string` into `bytes`.\n function parseBytes(string calldata stringifiedValue) external pure returns (bytes memory parsedValue);\n\n /// Parses the given `string` into a `bytes32`.\n function parseBytes32(string calldata stringifiedValue) external pure returns (bytes32 parsedValue);\n\n /// Parses the given `string` into a `int256`.\n function parseInt(string calldata stringifiedValue) external pure returns (int256 parsedValue);\n\n /// Parses the given `string` into a `uint256`.\n function parseUint(string calldata stringifiedValue) external pure returns (uint256 parsedValue);\n\n /// Replaces occurrences of `from` in the given `string` with `to`.\n function replace(string calldata input, string calldata from, string calldata to)\n external\n pure\n returns (string memory output);\n\n /// Splits the given `string` into an array of strings divided by the `delimiter`.\n function split(string calldata input, string calldata delimiter) external pure returns (string[] memory outputs);\n\n /// Converts the given `string` value to Lowercase.\n function toLowercase(string calldata input) external pure returns (string memory output);\n\n /// Converts the given value to a `string`.\n function toString(address value) external pure returns (string memory stringifiedValue);\n\n /// Converts the given value to a `string`.\n function toString(bytes calldata value) external pure returns (string memory stringifiedValue);\n\n /// Converts the given value to a `string`.\n function toString(bytes32 value) external pure returns (string memory stringifiedValue);\n\n /// Converts the given value to a `string`.\n function toString(bool value) external pure returns (string memory stringifiedValue);\n\n /// Converts the given value to a `string`.\n function toString(uint256 value) external pure returns (string memory stringifiedValue);\n\n /// Converts the given value to a `string`.\n function toString(int256 value) external pure returns (string memory stringifiedValue);\n\n /// Converts the given `string` value to Uppercase.\n function toUppercase(string calldata input) external pure returns (string memory output);\n\n /// Trims leading and trailing whitespace from the given `string` value.\n function trim(string calldata input) external pure returns (string memory output);\n\n // ======== Testing ========\n\n /// Compares two `uint256` values. Expects difference to be less than or equal to `maxDelta`.\n /// Formats values with decimals in failure message.\n function assertApproxEqAbsDecimal(uint256 left, uint256 right, uint256 maxDelta, uint256 decimals) external pure;\n\n /// Compares two `uint256` values. Expects difference to be less than or equal to `maxDelta`.\n /// Formats values with decimals in failure message. Includes error message into revert string on failure.\n function assertApproxEqAbsDecimal(\n uint256 left,\n uint256 right,\n uint256 maxDelta,\n uint256 decimals,\n string calldata error\n ) external pure;\n\n /// Compares two `int256` values. Expects difference to be less than or equal to `maxDelta`.\n /// Formats values with decimals in failure message.\n function assertApproxEqAbsDecimal(int256 left, int256 right, uint256 maxDelta, uint256 decimals) external pure;\n\n /// Compares two `int256` values. Expects difference to be less than or equal to `maxDelta`.\n /// Formats values with decimals in failure message. Includes error message into revert string on failure.\n function assertApproxEqAbsDecimal(\n int256 left,\n int256 right,\n uint256 maxDelta,\n uint256 decimals,\n string calldata error\n ) external pure;\n\n /// Compares two `uint256` values. Expects difference to be less than or equal to `maxDelta`.\n function assertApproxEqAbs(uint256 left, uint256 right, uint256 maxDelta) external pure;\n\n /// Compares two `uint256` values. Expects difference to be less than or equal to `maxDelta`.\n /// Includes error message into revert string on failure.\n function assertApproxEqAbs(uint256 left, uint256 right, uint256 maxDelta, string calldata error) external pure;\n\n /// Compares two `int256` values. Expects difference to be less than or equal to `maxDelta`.\n function assertApproxEqAbs(int256 left, int256 right, uint256 maxDelta) external pure;\n\n /// Compares two `int256` values. Expects difference to be less than or equal to `maxDelta`.\n /// Includes error message into revert string on failure.\n function assertApproxEqAbs(int256 left, int256 right, uint256 maxDelta, string calldata error) external pure;\n\n /// Compares two `uint256` values. Expects relative difference in percents to be less than or equal to `maxPercentDelta`.\n /// `maxPercentDelta` is an 18 decimal fixed point number, where 1e18 == 100%\n /// Formats values with decimals in failure message.\n function assertApproxEqRelDecimal(uint256 left, uint256 right, uint256 maxPercentDelta, uint256 decimals)\n external\n pure;\n\n /// Compares two `uint256` values. Expects relative difference in percents to be less than or equal to `maxPercentDelta`.\n /// `maxPercentDelta` is an 18 decimal fixed point number, where 1e18 == 100%\n /// Formats values with decimals in failure message. Includes error message into revert string on failure.\n function assertApproxEqRelDecimal(\n uint256 left,\n uint256 right,\n uint256 maxPercentDelta,\n uint256 decimals,\n string calldata error\n ) external pure;\n\n /// Compares two `int256` values. Expects relative difference in percents to be less than or equal to `maxPercentDelta`.\n /// `maxPercentDelta` is an 18 decimal fixed point number, where 1e18 == 100%\n /// Formats values with decimals in failure message.\n function assertApproxEqRelDecimal(int256 left, int256 right, uint256 maxPercentDelta, uint256 decimals)\n external\n pure;\n\n /// Compares two `int256` values. Expects relative difference in percents to be less than or equal to `maxPercentDelta`.\n /// `maxPercentDelta` is an 18 decimal fixed point number, where 1e18 == 100%\n /// Formats values with decimals in failure message. Includes error message into revert string on failure.\n function assertApproxEqRelDecimal(\n int256 left,\n int256 right,\n uint256 maxPercentDelta,\n uint256 decimals,\n string calldata error\n ) external pure;\n\n /// Compares two `uint256` values. Expects relative difference in percents to be less than or equal to `maxPercentDelta`.\n /// `maxPercentDelta` is an 18 decimal fixed point number, where 1e18 == 100%\n function assertApproxEqRel(uint256 left, uint256 right, uint256 maxPercentDelta) external pure;\n\n /// Compares two `uint256` values. Expects relative difference in percents to be less than or equal to `maxPercentDelta`.\n /// `maxPercentDelta` is an 18 decimal fixed point number, where 1e18 == 100%\n /// Includes error message into revert string on failure.\n function assertApproxEqRel(uint256 left, uint256 right, uint256 maxPercentDelta, string calldata error)\n external\n pure;\n\n /// Compares two `int256` values. Expects relative difference in percents to be less than or equal to `maxPercentDelta`.\n /// `maxPercentDelta` is an 18 decimal fixed point number, where 1e18 == 100%\n function assertApproxEqRel(int256 left, int256 right, uint256 maxPercentDelta) external pure;\n\n /// Compares two `int256` values. Expects relative difference in percents to be less than or equal to `maxPercentDelta`.\n /// `maxPercentDelta` is an 18 decimal fixed point number, where 1e18 == 100%\n /// Includes error message into revert string on failure.\n function assertApproxEqRel(int256 left, int256 right, uint256 maxPercentDelta, string calldata error)\n external\n pure;\n\n /// Asserts that two `uint256` values are equal, formatting them with decimals in failure message.\n function assertEqDecimal(uint256 left, uint256 right, uint256 decimals) external pure;\n\n /// Asserts that two `uint256` values are equal, formatting them with decimals in failure message.\n /// Includes error message into revert string on failure.\n function assertEqDecimal(uint256 left, uint256 right, uint256 decimals, string calldata error) external pure;\n\n /// Asserts that two `int256` values are equal, formatting them with decimals in failure message.\n function assertEqDecimal(int256 left, int256 right, uint256 decimals) external pure;\n\n /// Asserts that two `int256` values are equal, formatting them with decimals in failure message.\n /// Includes error message into revert string on failure.\n function assertEqDecimal(int256 left, int256 right, uint256 decimals, string calldata error) external pure;\n\n /// Asserts that two `bool` values are equal.\n function assertEq(bool left, bool right) external pure;\n\n /// Asserts that two `bool` values are equal and includes error message into revert string on failure.\n function assertEq(bool left, bool right, string calldata error) external pure;\n\n /// Asserts that two `string` values are equal.\n function assertEq(string calldata left, string calldata right) external pure;\n\n /// Asserts that two `string` values are equal and includes error message into revert string on failure.\n function assertEq(string calldata left, string calldata right, string calldata error) external pure;\n\n /// Asserts that two `bytes` values are equal.\n function assertEq(bytes calldata left, bytes calldata right) external pure;\n\n /// Asserts that two `bytes` values are equal and includes error message into revert string on failure.\n function assertEq(bytes calldata left, bytes calldata right, string calldata error) external pure;\n\n /// Asserts that two arrays of `bool` values are equal.\n function assertEq(bool[] calldata left, bool[] calldata right) external pure;\n\n /// Asserts that two arrays of `bool` values are equal and includes error message into revert string on failure.\n function assertEq(bool[] calldata left, bool[] calldata right, string calldata error) external pure;\n\n /// Asserts that two arrays of `uint256 values are equal.\n function assertEq(uint256[] calldata left, uint256[] calldata right) external pure;\n\n /// Asserts that two arrays of `uint256` values are equal and includes error message into revert string on failure.\n function assertEq(uint256[] calldata left, uint256[] calldata right, string calldata error) external pure;\n\n /// Asserts that two arrays of `int256` values are equal.\n function assertEq(int256[] calldata left, int256[] calldata right) external pure;\n\n /// Asserts that two arrays of `int256` values are equal and includes error message into revert string on failure.\n function assertEq(int256[] calldata left, int256[] calldata right, string calldata error) external pure;\n\n /// Asserts that two `uint256` values are equal.\n function assertEq(uint256 left, uint256 right) external pure;\n\n /// Asserts that two arrays of `address` values are equal.\n function assertEq(address[] calldata left, address[] calldata right) external pure;\n\n /// Asserts that two arrays of `address` values are equal and includes error message into revert string on failure.\n function assertEq(address[] calldata left, address[] calldata right, string calldata error) external pure;\n\n /// Asserts that two arrays of `bytes32` values are equal.\n function assertEq(bytes32[] calldata left, bytes32[] calldata right) external pure;\n\n /// Asserts that two arrays of `bytes32` values are equal and includes error message into revert string on failure.\n function assertEq(bytes32[] calldata left, bytes32[] calldata right, string calldata error) external pure;\n\n /// Asserts that two arrays of `string` values are equal.\n function assertEq(string[] calldata left, string[] calldata right) external pure;\n\n /// Asserts that two arrays of `string` values are equal and includes error message into revert string on failure.\n function assertEq(string[] calldata left, string[] calldata right, string calldata error) external pure;\n\n /// Asserts that two arrays of `bytes` values are equal.\n function assertEq(bytes[] calldata left, bytes[] calldata right) external pure;\n\n /// Asserts that two arrays of `bytes` values are equal and includes error message into revert string on failure.\n function assertEq(bytes[] calldata left, bytes[] calldata right, string calldata error) external pure;\n\n /// Asserts that two `uint256` values are equal and includes error message into revert string on failure.\n function assertEq(uint256 left, uint256 right, string calldata error) external pure;\n\n /// Asserts that two `int256` values are equal.\n function assertEq(int256 left, int256 right) external pure;\n\n /// Asserts that two `int256` values are equal and includes error message into revert string on failure.\n function assertEq(int256 left, int256 right, string calldata error) external pure;\n\n /// Asserts that two `address` values are equal.\n function assertEq(address left, address right) external pure;\n\n /// Asserts that two `address` values are equal and includes error message into revert string on failure.\n function assertEq(address left, address right, string calldata error) external pure;\n\n /// Asserts that two `bytes32` values are equal.\n function assertEq(bytes32 left, bytes32 right) external pure;\n\n /// Asserts that two `bytes32` values are equal and includes error message into revert string on failure.\n function assertEq(bytes32 left, bytes32 right, string calldata error) external pure;\n\n /// Asserts that the given condition is false.\n function assertFalse(bool condition) external pure;\n\n /// Asserts that the given condition is false and includes error message into revert string on failure.\n function assertFalse(bool condition, string calldata error) external pure;\n\n /// Compares two `uint256` values. Expects first value to be greater than or equal to second.\n /// Formats values with decimals in failure message.\n function assertGeDecimal(uint256 left, uint256 right, uint256 decimals) external pure;\n\n /// Compares two `uint256` values. Expects first value to be greater than or equal to second.\n /// Formats values with decimals in failure message. Includes error message into revert string on failure.\n function assertGeDecimal(uint256 left, uint256 right, uint256 decimals, string calldata error) external pure;\n\n /// Compares two `int256` values. Expects first value to be greater than or equal to second.\n /// Formats values with decimals in failure message.\n function assertGeDecimal(int256 left, int256 right, uint256 decimals) external pure;\n\n /// Compares two `int256` values. Expects first value to be greater than or equal to second.\n /// Formats values with decimals in failure message. Includes error message into revert string on failure.\n function assertGeDecimal(int256 left, int256 right, uint256 decimals, string calldata error) external pure;\n\n /// Compares two `uint256` values. Expects first value to be greater than or equal to second.\n function assertGe(uint256 left, uint256 right) external pure;\n\n /// Compares two `uint256` values. Expects first value to be greater than or equal to second.\n /// Includes error message into revert string on failure.\n function assertGe(uint256 left, uint256 right, string calldata error) external pure;\n\n /// Compares two `int256` values. Expects first value to be greater than or equal to second.\n function assertGe(int256 left, int256 right) external pure;\n\n /// Compares two `int256` values. Expects first value to be greater than or equal to second.\n /// Includes error message into revert string on failure.\n function assertGe(int256 left, int256 right, string calldata error) external pure;\n\n /// Compares two `uint256` values. Expects first value to be greater than second.\n /// Formats values with decimals in failure message.\n function assertGtDecimal(uint256 left, uint256 right, uint256 decimals) external pure;\n\n /// Compares two `uint256` values. Expects first value to be greater than second.\n /// Formats values with decimals in failure message. Includes error message into revert string on failure.\n function assertGtDecimal(uint256 left, uint256 right, uint256 decimals, string calldata error) external pure;\n\n /// Compares two `int256` values. Expects first value to be greater than second.\n /// Formats values with decimals in failure message.\n function assertGtDecimal(int256 left, int256 right, uint256 decimals) external pure;\n\n /// Compares two `int256` values. Expects first value to be greater than second.\n /// Formats values with decimals in failure message. Includes error message into revert string on failure.\n function assertGtDecimal(int256 left, int256 right, uint256 decimals, string calldata error) external pure;\n\n /// Compares two `uint256` values. Expects first value to be greater than second.\n function assertGt(uint256 left, uint256 right) external pure;\n\n /// Compares two `uint256` values. Expects first value to be greater than second.\n /// Includes error message into revert string on failure.\n function assertGt(uint256 left, uint256 right, string calldata error) external pure;\n\n /// Compares two `int256` values. Expects first value to be greater than second.\n function assertGt(int256 left, int256 right) external pure;\n\n /// Compares two `int256` values. Expects first value to be greater than second.\n /// Includes error message into revert string on failure.\n function assertGt(int256 left, int256 right, string calldata error) external pure;\n\n /// Compares two `uint256` values. Expects first value to be less than or equal to second.\n /// Formats values with decimals in failure message.\n function assertLeDecimal(uint256 left, uint256 right, uint256 decimals) external pure;\n\n /// Compares two `uint256` values. Expects first value to be less than or equal to second.\n /// Formats values with decimals in failure message. Includes error message into revert string on failure.\n function assertLeDecimal(uint256 left, uint256 right, uint256 decimals, string calldata error) external pure;\n\n /// Compares two `int256` values. Expects first value to be less than or equal to second.\n /// Formats values with decimals in failure message.\n function assertLeDecimal(int256 left, int256 right, uint256 decimals) external pure;\n\n /// Compares two `int256` values. Expects first value to be less than or equal to second.\n /// Formats values with decimals in failure message. Includes error message into revert string on failure.\n function assertLeDecimal(int256 left, int256 right, uint256 decimals, string calldata error) external pure;\n\n /// Compares two `uint256` values. Expects first value to be less than or equal to second.\n function assertLe(uint256 left, uint256 right) external pure;\n\n /// Compares two `uint256` values. Expects first value to be less than or equal to second.\n /// Includes error message into revert string on failure.\n function assertLe(uint256 left, uint256 right, string calldata error) external pure;\n\n /// Compares two `int256` values. Expects first value to be less than or equal to second.\n function assertLe(int256 left, int256 right) external pure;\n\n /// Compares two `int256` values. Expects first value to be less than or equal to second.\n /// Includes error message into revert string on failure.\n function assertLe(int256 left, int256 right, string calldata error) external pure;\n\n /// Compares two `uint256` values. Expects first value to be less than second.\n /// Formats values with decimals in failure message.\n function assertLtDecimal(uint256 left, uint256 right, uint256 decimals) external pure;\n\n /// Compares two `uint256` values. Expects first value to be less than second.\n /// Formats values with decimals in failure message. Includes error message into revert string on failure.\n function assertLtDecimal(uint256 left, uint256 right, uint256 decimals, string calldata error) external pure;\n\n /// Compares two `int256` values. Expects first value to be less than second.\n /// Formats values with decimals in failure message.\n function assertLtDecimal(int256 left, int256 right, uint256 decimals) external pure;\n\n /// Compares two `int256` values. Expects first value to be less than second.\n /// Formats values with decimals in failure message. Includes error message into revert string on failure.\n function assertLtDecimal(int256 left, int256 right, uint256 decimals, string calldata error) external pure;\n\n /// Compares two `uint256` values. Expects first value to be less than second.\n function assertLt(uint256 left, uint256 right) external pure;\n\n /// Compares two `uint256` values. Expects first value to be less than second.\n /// Includes error message into revert string on failure.\n function assertLt(uint256 left, uint256 right, string calldata error) external pure;\n\n /// Compares two `int256` values. Expects first value to be less than second.\n function assertLt(int256 left, int256 right) external pure;\n\n /// Compares two `int256` values. Expects first value to be less than second.\n /// Includes error message into revert string on failure.\n function assertLt(int256 left, int256 right, string calldata error) external pure;\n\n /// Asserts that two `uint256` values are not equal, formatting them with decimals in failure message.\n function assertNotEqDecimal(uint256 left, uint256 right, uint256 decimals) external pure;\n\n /// Asserts that two `uint256` values are not equal, formatting them with decimals in failure message.\n /// Includes error message into revert string on failure.\n function assertNotEqDecimal(uint256 left, uint256 right, uint256 decimals, string calldata error) external pure;\n\n /// Asserts that two `int256` values are not equal, formatting them with decimals in failure message.\n function assertNotEqDecimal(int256 left, int256 right, uint256 decimals) external pure;\n\n /// Asserts that two `int256` values are not equal, formatting them with decimals in failure message.\n /// Includes error message into revert string on failure.\n function assertNotEqDecimal(int256 left, int256 right, uint256 decimals, string calldata error) external pure;\n\n /// Asserts that two `bool` values are not equal.\n function assertNotEq(bool left, bool right) external pure;\n\n /// Asserts that two `bool` values are not equal and includes error message into revert string on failure.\n function assertNotEq(bool left, bool right, string calldata error) external pure;\n\n /// Asserts that two `string` values are not equal.\n function assertNotEq(string calldata left, string calldata right) external pure;\n\n /// Asserts that two `string` values are not equal and includes error message into revert string on failure.\n function assertNotEq(string calldata left, string calldata right, string calldata error) external pure;\n\n /// Asserts that two `bytes` values are not equal.\n function assertNotEq(bytes calldata left, bytes calldata right) external pure;\n\n /// Asserts that two `bytes` values are not equal and includes error message into revert string on failure.\n function assertNotEq(bytes calldata left, bytes calldata right, string calldata error) external pure;\n\n /// Asserts that two arrays of `bool` values are not equal.\n function assertNotEq(bool[] calldata left, bool[] calldata right) external pure;\n\n /// Asserts that two arrays of `bool` values are not equal and includes error message into revert string on failure.\n function assertNotEq(bool[] calldata left, bool[] calldata right, string calldata error) external pure;\n\n /// Asserts that two arrays of `uint256` values are not equal.\n function assertNotEq(uint256[] calldata left, uint256[] calldata right) external pure;\n\n /// Asserts that two arrays of `uint256` values are not equal and includes error message into revert string on failure.\n function assertNotEq(uint256[] calldata left, uint256[] calldata right, string calldata error) external pure;\n\n /// Asserts that two arrays of `int256` values are not equal.\n function assertNotEq(int256[] calldata left, int256[] calldata right) external pure;\n\n /// Asserts that two arrays of `int256` values are not equal and includes error message into revert string on failure.\n function assertNotEq(int256[] calldata left, int256[] calldata right, string calldata error) external pure;\n\n /// Asserts that two `uint256` values are not equal.\n function assertNotEq(uint256 left, uint256 right) external pure;\n\n /// Asserts that two arrays of `address` values are not equal.\n function assertNotEq(address[] calldata left, address[] calldata right) external pure;\n\n /// Asserts that two arrays of `address` values are not equal and includes error message into revert string on failure.\n function assertNotEq(address[] calldata left, address[] calldata right, string calldata error) external pure;\n\n /// Asserts that two arrays of `bytes32` values are not equal.\n function assertNotEq(bytes32[] calldata left, bytes32[] calldata right) external pure;\n\n /// Asserts that two arrays of `bytes32` values are not equal and includes error message into revert string on failure.\n function assertNotEq(bytes32[] calldata left, bytes32[] calldata right, string calldata error) external pure;\n\n /// Asserts that two arrays of `string` values are not equal.\n function assertNotEq(string[] calldata left, string[] calldata right) external pure;\n\n /// Asserts that two arrays of `string` values are not equal and includes error message into revert string on failure.\n function assertNotEq(string[] calldata left, string[] calldata right, string calldata error) external pure;\n\n /// Asserts that two arrays of `bytes` values are not equal.\n function assertNotEq(bytes[] calldata left, bytes[] calldata right) external pure;\n\n /// Asserts that two arrays of `bytes` values are not equal and includes error message into revert string on failure.\n function assertNotEq(bytes[] calldata left, bytes[] calldata right, string calldata error) external pure;\n\n /// Asserts that two `uint256` values are not equal and includes error message into revert string on failure.\n function assertNotEq(uint256 left, uint256 right, string calldata error) external pure;\n\n /// Asserts that two `int256` values are not equal.\n function assertNotEq(int256 left, int256 right) external pure;\n\n /// Asserts that two `int256` values are not equal and includes error message into revert string on failure.\n function assertNotEq(int256 left, int256 right, string calldata error) external pure;\n\n /// Asserts that two `address` values are not equal.\n function assertNotEq(address left, address right) external pure;\n\n /// Asserts that two `address` values are not equal and includes error message into revert string on failure.\n function assertNotEq(address left, address right, string calldata error) external pure;\n\n /// Asserts that two `bytes32` values are not equal.\n function assertNotEq(bytes32 left, bytes32 right) external pure;\n\n /// Asserts that two `bytes32` values are not equal and includes error message into revert string on failure.\n function assertNotEq(bytes32 left, bytes32 right, string calldata error) external pure;\n\n /// Asserts that the given condition is true.\n function assertTrue(bool condition) external pure;\n\n /// Asserts that the given condition is true and includes error message into revert string on failure.\n function assertTrue(bool condition, string calldata error) external pure;\n\n /// If the condition is false, discard this run's fuzz inputs and generate new ones.\n function assume(bool condition) external pure;\n\n /// Discard this run's fuzz inputs and generate new ones if next call reverted.\n function assumeNoRevert() external pure;\n\n /// Discard this run's fuzz inputs and generate new ones if next call reverts with the potential revert parameters.\n function assumeNoRevert(PotentialRevert calldata potentialRevert) external pure;\n\n /// Discard this run's fuzz inputs and generate new ones if next call reverts with the any of the potential revert parameters.\n function assumeNoRevert(PotentialRevert[] calldata potentialReverts) external pure;\n\n /// Writes a breakpoint to jump to in the debugger.\n function breakpoint(string calldata char) external pure;\n\n /// Writes a conditional breakpoint to jump to in the debugger.\n function breakpoint(string calldata char, bool value) external pure;\n\n /// Returns true if the current Foundry version is greater than or equal to the given version.\n /// The given version string must be in the format `major.minor.patch`.\n /// This is equivalent to `foundryVersionCmp(version) >= 0`.\n function foundryVersionAtLeast(string calldata version) external view returns (bool);\n\n /// Compares the current Foundry version with the given version string.\n /// The given version string must be in the format `major.minor.patch`.\n /// Returns:\n /// -1 if current Foundry version is less than the given version\n /// 0 if current Foundry version equals the given version\n /// 1 if current Foundry version is greater than the given version\n /// This result can then be used with a comparison operator against `0`.\n /// For example, to check if the current Foundry version is greater than or equal to `1.0.0`:\n /// `if (foundryVersionCmp(\"1.0.0\") >= 0) { ... }`\n function foundryVersionCmp(string calldata version) external view returns (int256);\n\n /// Returns the Foundry version.\n /// Format: -+..\n /// Sample output: 0.3.0-nightly+3cb96bde9b.1737036656.debug\n /// Note: Build timestamps may vary slightly across platforms due to separate CI jobs.\n /// For reliable version comparisons, use UNIX format (e.g., >= 1700000000)\n /// to compare timestamps while ignoring minor time differences.\n function getFoundryVersion() external view returns (string memory version);\n\n /// Returns the RPC url for the given alias.\n function rpcUrl(string calldata rpcAlias) external view returns (string memory json);\n\n /// Returns all rpc urls and their aliases as structs.\n function rpcUrlStructs() external view returns (Rpc[] memory urls);\n\n /// Returns all rpc urls and their aliases `[alias, url][]`.\n function rpcUrls() external view returns (string[2][] memory urls);\n\n /// Suspends execution of the main thread for `duration` milliseconds.\n function sleep(uint256 duration) external;\n\n // ======== Toml ========\n\n /// Checks if `key` exists in a TOML table.\n function keyExistsToml(string calldata toml, string calldata key) external view returns (bool);\n\n /// Parses a string of TOML data at `key` and coerces it to `address`.\n function parseTomlAddress(string calldata toml, string calldata key) external pure returns (address);\n\n /// Parses a string of TOML data at `key` and coerces it to `address[]`.\n function parseTomlAddressArray(string calldata toml, string calldata key)\n external\n pure\n returns (address[] memory);\n\n /// Parses a string of TOML data at `key` and coerces it to `bool`.\n function parseTomlBool(string calldata toml, string calldata key) external pure returns (bool);\n\n /// Parses a string of TOML data at `key` and coerces it to `bool[]`.\n function parseTomlBoolArray(string calldata toml, string calldata key) external pure returns (bool[] memory);\n\n /// Parses a string of TOML data at `key` and coerces it to `bytes`.\n function parseTomlBytes(string calldata toml, string calldata key) external pure returns (bytes memory);\n\n /// Parses a string of TOML data at `key` and coerces it to `bytes32`.\n function parseTomlBytes32(string calldata toml, string calldata key) external pure returns (bytes32);\n\n /// Parses a string of TOML data at `key` and coerces it to `bytes32[]`.\n function parseTomlBytes32Array(string calldata toml, string calldata key)\n external\n pure\n returns (bytes32[] memory);\n\n /// Parses a string of TOML data at `key` and coerces it to `bytes[]`.\n function parseTomlBytesArray(string calldata toml, string calldata key) external pure returns (bytes[] memory);\n\n /// Parses a string of TOML data at `key` and coerces it to `int256`.\n function parseTomlInt(string calldata toml, string calldata key) external pure returns (int256);\n\n /// Parses a string of TOML data at `key` and coerces it to `int256[]`.\n function parseTomlIntArray(string calldata toml, string calldata key) external pure returns (int256[] memory);\n\n /// Returns an array of all the keys in a TOML table.\n function parseTomlKeys(string calldata toml, string calldata key) external pure returns (string[] memory keys);\n\n /// Parses a string of TOML data at `key` and coerces it to `string`.\n function parseTomlString(string calldata toml, string calldata key) external pure returns (string memory);\n\n /// Parses a string of TOML data at `key` and coerces it to `string[]`.\n function parseTomlStringArray(string calldata toml, string calldata key) external pure returns (string[] memory);\n\n /// Parses a string of TOML data at `key` and coerces it to type array corresponding to `typeDescription`.\n function parseTomlTypeArray(string calldata toml, string calldata key, string calldata typeDescription)\n external\n pure\n returns (bytes memory);\n\n /// Parses a string of TOML data and coerces it to type corresponding to `typeDescription`.\n function parseTomlType(string calldata toml, string calldata typeDescription)\n external\n pure\n returns (bytes memory);\n\n /// Parses a string of TOML data at `key` and coerces it to type corresponding to `typeDescription`.\n function parseTomlType(string calldata toml, string calldata key, string calldata typeDescription)\n external\n pure\n returns (bytes memory);\n\n /// Parses a string of TOML data at `key` and coerces it to `uint256`.\n function parseTomlUint(string calldata toml, string calldata key) external pure returns (uint256);\n\n /// Parses a string of TOML data at `key` and coerces it to `uint256[]`.\n function parseTomlUintArray(string calldata toml, string calldata key) external pure returns (uint256[] memory);\n\n /// ABI-encodes a TOML table.\n function parseToml(string calldata toml) external pure returns (bytes memory abiEncodedData);\n\n /// ABI-encodes a TOML table at `key`.\n function parseToml(string calldata toml, string calldata key) external pure returns (bytes memory abiEncodedData);\n\n /// Takes serialized JSON, converts to TOML and write a serialized TOML to a file.\n function writeToml(string calldata json, string calldata path) external;\n\n /// Takes serialized JSON, converts to TOML and write a serialized TOML table to an **existing** TOML file, replacing a value with key = \n /// This is useful to replace a specific value of a TOML file, without having to parse the entire thing.\n function writeToml(string calldata json, string calldata path, string calldata valueKey) external;\n\n // ======== Utilities ========\n\n /// Compute the address of a contract created with CREATE2 using the given CREATE2 deployer.\n function computeCreate2Address(bytes32 salt, bytes32 initCodeHash, address deployer)\n external\n pure\n returns (address);\n\n /// Compute the address of a contract created with CREATE2 using the default CREATE2 deployer.\n function computeCreate2Address(bytes32 salt, bytes32 initCodeHash) external pure returns (address);\n\n /// Compute the address a contract will be deployed at for a given deployer address and nonce.\n function computeCreateAddress(address deployer, uint256 nonce) external pure returns (address);\n\n /// Utility cheatcode to copy storage of `from` contract to another `to` contract.\n function copyStorage(address from, address to) external;\n\n /// Returns ENS namehash for provided string.\n function ensNamehash(string calldata name) external pure returns (bytes32);\n\n /// Gets the label for the specified address.\n function getLabel(address account) external view returns (string memory currentLabel);\n\n /// Labels an address in call traces.\n function label(address account, string calldata newLabel) external;\n\n /// Pauses collection of call traces. Useful in cases when you want to skip tracing of\n /// complex calls which are not useful for debugging.\n function pauseTracing() external view;\n\n /// Returns a random `address`.\n function randomAddress() external returns (address);\n\n /// Returns a random `bool`.\n function randomBool() external view returns (bool);\n\n /// Returns a random byte array value of the given length.\n function randomBytes(uint256 len) external view returns (bytes memory);\n\n /// Returns a random fixed-size byte array of length 4.\n function randomBytes4() external view returns (bytes4);\n\n /// Returns a random fixed-size byte array of length 8.\n function randomBytes8() external view returns (bytes8);\n\n /// Returns a random `int256` value.\n function randomInt() external view returns (int256);\n\n /// Returns a random `int256` value of given bits.\n function randomInt(uint256 bits) external view returns (int256);\n\n /// Returns a random uint256 value.\n function randomUint() external returns (uint256);\n\n /// Returns random uint256 value between the provided range (=min..=max).\n function randomUint(uint256 min, uint256 max) external returns (uint256);\n\n /// Returns a random `uint256` value of given bits.\n function randomUint(uint256 bits) external view returns (uint256);\n\n /// Unpauses collection of call traces.\n function resumeTracing() external view;\n\n /// Utility cheatcode to set arbitrary storage for given target address.\n function setArbitraryStorage(address target) external;\n\n /// Encodes a `bytes` value to a base64url string.\n function toBase64URL(bytes calldata data) external pure returns (string memory);\n\n /// Encodes a `string` value to a base64url string.\n function toBase64URL(string calldata data) external pure returns (string memory);\n\n /// Encodes a `bytes` value to a base64 string.\n function toBase64(bytes calldata data) external pure returns (string memory);\n\n /// Encodes a `string` value to a base64 string.\n function toBase64(string calldata data) external pure returns (string memory);\n}\n\n/// The `Vm` interface does allow manipulation of the EVM state. These are all intended to be used\n/// in tests, but it is not recommended to use these cheats in scripts.\ninterface Vm is VmSafe {\n // ======== EVM ========\n\n /// Utility cheatcode to set an EIP-2930 access list for all subsequent transactions.\n function accessList(AccessListItem[] calldata access) external;\n\n /// Returns the identifier of the currently active fork. Reverts if no fork is currently active.\n function activeFork() external view returns (uint256 forkId);\n\n /// In forking mode, explicitly grant the given address cheatcode access.\n function allowCheatcodes(address account) external;\n\n /// Sets `block.blobbasefee`\n function blobBaseFee(uint256 newBlobBaseFee) external;\n\n /// Sets the blobhashes in the transaction.\n /// Not available on EVM versions before Cancun.\n /// If used on unsupported EVM versions it will revert.\n function blobhashes(bytes32[] calldata hashes) external;\n\n /// Sets `block.chainid`.\n function chainId(uint256 newChainId) external;\n\n /// Clears all mocked calls.\n function clearMockedCalls() external;\n\n /// Clones a source account code, state, balance and nonce to a target account and updates in-memory EVM state.\n function cloneAccount(address source, address target) external;\n\n /// Sets `block.coinbase`.\n function coinbase(address newCoinbase) external;\n\n /// Marks the slots of an account and the account address as cold.\n function cool(address target) external;\n\n /// Utility cheatcode to mark specific storage slot as cold, simulating no prior read.\n function coolSlot(address target, bytes32 slot) external;\n\n /// Creates a new fork with the given endpoint and the _latest_ block and returns the identifier of the fork.\n function createFork(string calldata urlOrAlias) external returns (uint256 forkId);\n\n /// Creates a new fork with the given endpoint and block and returns the identifier of the fork.\n function createFork(string calldata urlOrAlias, uint256 blockNumber) external returns (uint256 forkId);\n\n /// Creates a new fork with the given endpoint and at the block the given transaction was mined in,\n /// replays all transaction mined in the block before the transaction, and returns the identifier of the fork.\n function createFork(string calldata urlOrAlias, bytes32 txHash) external returns (uint256 forkId);\n\n /// Creates and also selects a new fork with the given endpoint and the latest block and returns the identifier of the fork.\n function createSelectFork(string calldata urlOrAlias) external returns (uint256 forkId);\n\n /// Creates and also selects a new fork with the given endpoint and block and returns the identifier of the fork.\n function createSelectFork(string calldata urlOrAlias, uint256 blockNumber) external returns (uint256 forkId);\n\n /// Creates and also selects new fork with the given endpoint and at the block the given transaction was mined in,\n /// replays all transaction mined in the block before the transaction, returns the identifier of the fork.\n function createSelectFork(string calldata urlOrAlias, bytes32 txHash) external returns (uint256 forkId);\n\n /// Sets an address' balance.\n function deal(address account, uint256 newBalance) external;\n\n /// Removes the snapshot with the given ID created by `snapshot`.\n /// Takes the snapshot ID to delete.\n /// Returns `true` if the snapshot was successfully deleted.\n /// Returns `false` if the snapshot does not exist.\n function deleteStateSnapshot(uint256 snapshotId) external returns (bool success);\n\n /// Removes _all_ snapshots previously created by `snapshot`.\n function deleteStateSnapshots() external;\n\n /// Sets `block.difficulty`.\n /// Not available on EVM versions from Paris onwards. Use `prevrandao` instead.\n /// Reverts if used on unsupported EVM versions.\n function difficulty(uint256 newDifficulty) external;\n\n /// Dump a genesis JSON file's `allocs` to disk.\n function dumpState(string calldata pathToStateJson) external;\n\n /// Sets an address' code.\n function etch(address target, bytes calldata newRuntimeBytecode) external;\n\n /// Sets `block.basefee`.\n function fee(uint256 newBasefee) external;\n\n /// Gets the blockhashes from the current transaction.\n /// Not available on EVM versions before Cancun.\n /// If used on unsupported EVM versions it will revert.\n function getBlobhashes() external view returns (bytes32[] memory hashes);\n\n /// Returns true if the account is marked as persistent.\n function isPersistent(address account) external view returns (bool persistent);\n\n /// Load a genesis JSON file's `allocs` into the in-memory EVM state.\n function loadAllocs(string calldata pathToAllocsJson) external;\n\n /// Marks that the account(s) should use persistent storage across fork swaps in a multifork setup\n /// Meaning, changes made to the state of this account will be kept when switching forks.\n function makePersistent(address account) external;\n\n /// See `makePersistent(address)`.\n function makePersistent(address account0, address account1) external;\n\n /// See `makePersistent(address)`.\n function makePersistent(address account0, address account1, address account2) external;\n\n /// See `makePersistent(address)`.\n function makePersistent(address[] calldata accounts) external;\n\n /// Reverts a call to an address with specified revert data.\n function mockCallRevert(address callee, bytes calldata data, bytes calldata revertData) external;\n\n /// Reverts a call to an address with a specific `msg.value`, with specified revert data.\n function mockCallRevert(address callee, uint256 msgValue, bytes calldata data, bytes calldata revertData)\n external;\n\n /// Reverts a call to an address with specified revert data.\n /// Overload to pass the function selector directly `token.approve.selector` instead of `abi.encodeWithSelector(token.approve.selector)`.\n function mockCallRevert(address callee, bytes4 data, bytes calldata revertData) external;\n\n /// Reverts a call to an address with a specific `msg.value`, with specified revert data.\n /// Overload to pass the function selector directly `token.approve.selector` instead of `abi.encodeWithSelector(token.approve.selector)`.\n function mockCallRevert(address callee, uint256 msgValue, bytes4 data, bytes calldata revertData) external;\n\n /// Mocks a call to an address, returning specified data.\n /// Calldata can either be strict or a partial match, e.g. if you only\n /// pass a Solidity selector to the expected calldata, then the entire Solidity\n /// function will be mocked.\n function mockCall(address callee, bytes calldata data, bytes calldata returnData) external;\n\n /// Mocks a call to an address with a specific `msg.value`, returning specified data.\n /// Calldata match takes precedence over `msg.value` in case of ambiguity.\n function mockCall(address callee, uint256 msgValue, bytes calldata data, bytes calldata returnData) external;\n\n /// Mocks a call to an address, returning specified data.\n /// Calldata can either be strict or a partial match, e.g. if you only\n /// pass a Solidity selector to the expected calldata, then the entire Solidity\n /// function will be mocked.\n /// Overload to pass the function selector directly `token.approve.selector` instead of `abi.encodeWithSelector(token.approve.selector)`.\n function mockCall(address callee, bytes4 data, bytes calldata returnData) external;\n\n /// Mocks a call to an address with a specific `msg.value`, returning specified data.\n /// Calldata match takes precedence over `msg.value` in case of ambiguity.\n /// Overload to pass the function selector directly `token.approve.selector` instead of `abi.encodeWithSelector(token.approve.selector)`.\n function mockCall(address callee, uint256 msgValue, bytes4 data, bytes calldata returnData) external;\n\n /// Mocks multiple calls to an address, returning specified data for each call.\n function mockCalls(address callee, bytes calldata data, bytes[] calldata returnData) external;\n\n /// Mocks multiple calls to an address with a specific `msg.value`, returning specified data for each call.\n function mockCalls(address callee, uint256 msgValue, bytes calldata data, bytes[] calldata returnData) external;\n\n /// Whenever a call is made to `callee` with calldata `data`, this cheatcode instead calls\n /// `target` with the same calldata. This functionality is similar to a delegate call made to\n /// `target` contract from `callee`.\n /// Can be used to substitute a call to a function with another implementation that captures\n /// the primary logic of the original function but is easier to reason about.\n /// If calldata is not a strict match then partial match by selector is attempted.\n function mockFunction(address callee, address target, bytes calldata data) external;\n\n /// Utility cheatcode to remove any EIP-2930 access list set by `accessList` cheatcode.\n function noAccessList() external;\n\n /// Sets the *next* call's `msg.sender` to be the input address.\n function prank(address msgSender) external;\n\n /// Sets the *next* call's `msg.sender` to be the input address, and the `tx.origin` to be the second input.\n function prank(address msgSender, address txOrigin) external;\n\n /// Sets the *next* delegate call's `msg.sender` to be the input address.\n function prank(address msgSender, bool delegateCall) external;\n\n /// Sets the *next* delegate call's `msg.sender` to be the input address, and the `tx.origin` to be the second input.\n function prank(address msgSender, address txOrigin, bool delegateCall) external;\n\n /// Sets `block.prevrandao`.\n /// Not available on EVM versions before Paris. Use `difficulty` instead.\n /// If used on unsupported EVM versions it will revert.\n function prevrandao(bytes32 newPrevrandao) external;\n\n /// Sets `block.prevrandao`.\n /// Not available on EVM versions before Paris. Use `difficulty` instead.\n /// If used on unsupported EVM versions it will revert.\n function prevrandao(uint256 newPrevrandao) external;\n\n /// Reads the current `msg.sender` and `tx.origin` from state and reports if there is any active caller modification.\n function readCallers() external returns (CallerMode callerMode, address msgSender, address txOrigin);\n\n /// Resets the nonce of an account to 0 for EOAs and 1 for contract accounts.\n function resetNonce(address account) external;\n\n /// Revert the state of the EVM to a previous snapshot\n /// Takes the snapshot ID to revert to.\n /// Returns `true` if the snapshot was successfully reverted.\n /// Returns `false` if the snapshot does not exist.\n /// **Note:** This does not automatically delete the snapshot. To delete the snapshot use `deleteStateSnapshot`.\n function revertToState(uint256 snapshotId) external returns (bool success);\n\n /// Revert the state of the EVM to a previous snapshot and automatically deletes the snapshots\n /// Takes the snapshot ID to revert to.\n /// Returns `true` if the snapshot was successfully reverted and deleted.\n /// Returns `false` if the snapshot does not exist.\n function revertToStateAndDelete(uint256 snapshotId) external returns (bool success);\n\n /// Revokes persistent status from the address, previously added via `makePersistent`.\n function revokePersistent(address account) external;\n\n /// See `revokePersistent(address)`.\n function revokePersistent(address[] calldata accounts) external;\n\n /// Sets `block.height`.\n function roll(uint256 newHeight) external;\n\n /// Updates the currently active fork to given block number\n /// This is similar to `roll` but for the currently active fork.\n function rollFork(uint256 blockNumber) external;\n\n /// Updates the currently active fork to given transaction. This will `rollFork` with the number\n /// of the block the transaction was mined in and replays all transaction mined before it in the block.\n function rollFork(bytes32 txHash) external;\n\n /// Updates the given fork to given block number.\n function rollFork(uint256 forkId, uint256 blockNumber) external;\n\n /// Updates the given fork to block number of the given transaction and replays all transaction mined before it in the block.\n function rollFork(uint256 forkId, bytes32 txHash) external;\n\n /// Takes a fork identifier created by `createFork` and sets the corresponding forked state as active.\n function selectFork(uint256 forkId) external;\n\n /// Set blockhash for the current block.\n /// It only sets the blockhash for blocks where `block.number - 256 <= number < block.number`.\n function setBlockhash(uint256 blockNumber, bytes32 blockHash) external;\n\n /// Sets the nonce of an account. Must be higher than the current nonce of the account.\n function setNonce(address account, uint64 newNonce) external;\n\n /// Sets the nonce of an account to an arbitrary value.\n function setNonceUnsafe(address account, uint64 newNonce) external;\n\n /// Snapshot capture the gas usage of the last call by name from the callee perspective.\n function snapshotGasLastCall(string calldata name) external returns (uint256 gasUsed);\n\n /// Snapshot capture the gas usage of the last call by name in a group from the callee perspective.\n function snapshotGasLastCall(string calldata group, string calldata name) external returns (uint256 gasUsed);\n\n /// Snapshot the current state of the evm.\n /// Returns the ID of the snapshot that was created.\n /// To revert a snapshot use `revertToState`.\n function snapshotState() external returns (uint256 snapshotId);\n\n /// Snapshot capture an arbitrary numerical value by name.\n /// The group name is derived from the contract name.\n function snapshotValue(string calldata name, uint256 value) external;\n\n /// Snapshot capture an arbitrary numerical value by name in a group.\n function snapshotValue(string calldata group, string calldata name, uint256 value) external;\n\n /// Sets all subsequent calls' `msg.sender` to be the input address until `stopPrank` is called.\n function startPrank(address msgSender) external;\n\n /// Sets all subsequent calls' `msg.sender` to be the input address until `stopPrank` is called, and the `tx.origin` to be the second input.\n function startPrank(address msgSender, address txOrigin) external;\n\n /// Sets all subsequent delegate calls' `msg.sender` to be the input address until `stopPrank` is called.\n function startPrank(address msgSender, bool delegateCall) external;\n\n /// Sets all subsequent delegate calls' `msg.sender` to be the input address until `stopPrank` is called, and the `tx.origin` to be the second input.\n function startPrank(address msgSender, address txOrigin, bool delegateCall) external;\n\n /// Start a snapshot capture of the current gas usage by name.\n /// The group name is derived from the contract name.\n function startSnapshotGas(string calldata name) external;\n\n /// Start a snapshot capture of the current gas usage by name in a group.\n function startSnapshotGas(string calldata group, string calldata name) external;\n\n /// Resets subsequent calls' `msg.sender` to be `address(this)`.\n function stopPrank() external;\n\n /// Stop the snapshot capture of the current gas by latest snapshot name, capturing the gas used since the start.\n function stopSnapshotGas() external returns (uint256 gasUsed);\n\n /// Stop the snapshot capture of the current gas usage by name, capturing the gas used since the start.\n /// The group name is derived from the contract name.\n function stopSnapshotGas(string calldata name) external returns (uint256 gasUsed);\n\n /// Stop the snapshot capture of the current gas usage by name in a group, capturing the gas used since the start.\n function stopSnapshotGas(string calldata group, string calldata name) external returns (uint256 gasUsed);\n\n /// Stores a value to an address' storage slot.\n function store(address target, bytes32 slot, bytes32 value) external;\n\n /// Fetches the given transaction from the active fork and executes it on the current state.\n function transact(bytes32 txHash) external;\n\n /// Fetches the given transaction from the given fork and executes it on the current state.\n function transact(uint256 forkId, bytes32 txHash) external;\n\n /// Sets `tx.gasprice`.\n function txGasPrice(uint256 newGasPrice) external;\n\n /// Utility cheatcode to mark specific storage slot as warm, simulating a prior read.\n function warmSlot(address target, bytes32 slot) external;\n\n /// Sets `block.timestamp`.\n function warp(uint256 newTimestamp) external;\n\n /// `deleteSnapshot` is being deprecated in favor of `deleteStateSnapshot`. It will be removed in future versions.\n function deleteSnapshot(uint256 snapshotId) external returns (bool success);\n\n /// `deleteSnapshots` is being deprecated in favor of `deleteStateSnapshots`. It will be removed in future versions.\n function deleteSnapshots() external;\n\n /// `revertToAndDelete` is being deprecated in favor of `revertToStateAndDelete`. It will be removed in future versions.\n function revertToAndDelete(uint256 snapshotId) external returns (bool success);\n\n /// `revertTo` is being deprecated in favor of `revertToState`. It will be removed in future versions.\n function revertTo(uint256 snapshotId) external returns (bool success);\n\n /// `snapshot` is being deprecated in favor of `snapshotState`. It will be removed in future versions.\n function snapshot() external returns (uint256 snapshotId);\n\n // ======== Testing ========\n\n /// Expect a call to an address with the specified `msg.value` and calldata, and a *minimum* amount of gas.\n function expectCallMinGas(address callee, uint256 msgValue, uint64 minGas, bytes calldata data) external;\n\n /// Expect given number of calls to an address with the specified `msg.value` and calldata, and a *minimum* amount of gas.\n function expectCallMinGas(address callee, uint256 msgValue, uint64 minGas, bytes calldata data, uint64 count)\n external;\n\n /// Expects a call to an address with the specified calldata.\n /// Calldata can either be a strict or a partial match.\n function expectCall(address callee, bytes calldata data) external;\n\n /// Expects given number of calls to an address with the specified calldata.\n function expectCall(address callee, bytes calldata data, uint64 count) external;\n\n /// Expects a call to an address with the specified `msg.value` and calldata.\n function expectCall(address callee, uint256 msgValue, bytes calldata data) external;\n\n /// Expects given number of calls to an address with the specified `msg.value` and calldata.\n function expectCall(address callee, uint256 msgValue, bytes calldata data, uint64 count) external;\n\n /// Expect a call to an address with the specified `msg.value`, gas, and calldata.\n function expectCall(address callee, uint256 msgValue, uint64 gas, bytes calldata data) external;\n\n /// Expects given number of calls to an address with the specified `msg.value`, gas, and calldata.\n function expectCall(address callee, uint256 msgValue, uint64 gas, bytes calldata data, uint64 count) external;\n\n /// Expects the deployment of the specified bytecode by the specified address using the CREATE opcode\n function expectCreate(bytes calldata bytecode, address deployer) external;\n\n /// Expects the deployment of the specified bytecode by the specified address using the CREATE2 opcode\n function expectCreate2(bytes calldata bytecode, address deployer) external;\n\n /// Prepare an expected anonymous log with (bool checkTopic1, bool checkTopic2, bool checkTopic3, bool checkData.).\n /// Call this function, then emit an anonymous event, then call a function. Internally after the call, we check if\n /// logs were emitted in the expected order with the expected topics and data (as specified by the booleans).\n function expectEmitAnonymous(bool checkTopic0, bool checkTopic1, bool checkTopic2, bool checkTopic3, bool checkData)\n external;\n\n /// Same as the previous method, but also checks supplied address against emitting contract.\n function expectEmitAnonymous(\n bool checkTopic0,\n bool checkTopic1,\n bool checkTopic2,\n bool checkTopic3,\n bool checkData,\n address emitter\n ) external;\n\n /// Prepare an expected anonymous log with all topic and data checks enabled.\n /// Call this function, then emit an anonymous event, then call a function. Internally after the call, we check if\n /// logs were emitted in the expected order with the expected topics and data.\n function expectEmitAnonymous() external;\n\n /// Same as the previous method, but also checks supplied address against emitting contract.\n function expectEmitAnonymous(address emitter) external;\n\n /// Prepare an expected log with (bool checkTopic1, bool checkTopic2, bool checkTopic3, bool checkData.).\n /// Call this function, then emit an event, then call a function. Internally after the call, we check if\n /// logs were emitted in the expected order with the expected topics and data (as specified by the booleans).\n function expectEmit(bool checkTopic1, bool checkTopic2, bool checkTopic3, bool checkData) external;\n\n /// Same as the previous method, but also checks supplied address against emitting contract.\n function expectEmit(bool checkTopic1, bool checkTopic2, bool checkTopic3, bool checkData, address emitter)\n external;\n\n /// Prepare an expected log with all topic and data checks enabled.\n /// Call this function, then emit an event, then call a function. Internally after the call, we check if\n /// logs were emitted in the expected order with the expected topics and data.\n function expectEmit() external;\n\n /// Same as the previous method, but also checks supplied address against emitting contract.\n function expectEmit(address emitter) external;\n\n /// Expect a given number of logs with the provided topics.\n function expectEmit(bool checkTopic1, bool checkTopic2, bool checkTopic3, bool checkData, uint64 count) external;\n\n /// Expect a given number of logs from a specific emitter with the provided topics.\n function expectEmit(\n bool checkTopic1,\n bool checkTopic2,\n bool checkTopic3,\n bool checkData,\n address emitter,\n uint64 count\n ) external;\n\n /// Expect a given number of logs with all topic and data checks enabled.\n function expectEmit(uint64 count) external;\n\n /// Expect a given number of logs from a specific emitter with all topic and data checks enabled.\n function expectEmit(address emitter, uint64 count) external;\n\n /// Expects an error on next call that starts with the revert data.\n function expectPartialRevert(bytes4 revertData) external;\n\n /// Expects an error on next call to reverter address, that starts with the revert data.\n function expectPartialRevert(bytes4 revertData, address reverter) external;\n\n /// Expects an error on next call with any revert data.\n function expectRevert() external;\n\n /// Expects an error on next call that exactly matches the revert data.\n function expectRevert(bytes4 revertData) external;\n\n /// Expects a `count` number of reverts from the upcoming calls from the reverter address that match the revert data.\n function expectRevert(bytes4 revertData, address reverter, uint64 count) external;\n\n /// Expects a `count` number of reverts from the upcoming calls from the reverter address that exactly match the revert data.\n function expectRevert(bytes calldata revertData, address reverter, uint64 count) external;\n\n /// Expects an error on next call that exactly matches the revert data.\n function expectRevert(bytes calldata revertData) external;\n\n /// Expects an error with any revert data on next call to reverter address.\n function expectRevert(address reverter) external;\n\n /// Expects an error from reverter address on next call, with any revert data.\n function expectRevert(bytes4 revertData, address reverter) external;\n\n /// Expects an error from reverter address on next call, that exactly matches the revert data.\n function expectRevert(bytes calldata revertData, address reverter) external;\n\n /// Expects a `count` number of reverts from the upcoming calls with any revert data or reverter.\n function expectRevert(uint64 count) external;\n\n /// Expects a `count` number of reverts from the upcoming calls that match the revert data.\n function expectRevert(bytes4 revertData, uint64 count) external;\n\n /// Expects a `count` number of reverts from the upcoming calls that exactly match the revert data.\n function expectRevert(bytes calldata revertData, uint64 count) external;\n\n /// Expects a `count` number of reverts from the upcoming calls from the reverter address.\n function expectRevert(address reverter, uint64 count) external;\n\n /// Only allows memory writes to offsets [0x00, 0x60) ∪ [min, max) in the current subcontext. If any other\n /// memory is written to, the test will fail. Can be called multiple times to add more ranges to the set.\n function expectSafeMemory(uint64 min, uint64 max) external;\n\n /// Only allows memory writes to offsets [0x00, 0x60) ∪ [min, max) in the next created subcontext.\n /// If any other memory is written to, the test will fail. Can be called multiple times to add more ranges\n /// to the set.\n function expectSafeMemoryCall(uint64 min, uint64 max) external;\n\n /// Marks a test as skipped. Must be called at the top level of a test.\n function skip(bool skipTest) external;\n\n /// Marks a test as skipped with a reason. Must be called at the top level of a test.\n function skip(bool skipTest, string calldata reason) external;\n\n /// Stops all safe memory expectation in the current subcontext.\n function stopExpectSafeMemory() external;\n}\n","license":"MIT OR Apache-2.0"},"lib/forge-std/src/console.sol":{"keccak256":"0x4bbf47eb762cef93729d6ef15e78789957147039b113e5d4df48e3d3fd16d0f5","urls":[],"content":"// SPDX-License-Identifier: MIT\npragma solidity >=0.4.22 <0.9.0;\n\nlibrary console {\n address constant CONSOLE_ADDRESS =\n 0x000000000000000000636F6e736F6c652e6c6f67;\n\n function _sendLogPayloadImplementation(bytes memory payload) internal view {\n address consoleAddress = CONSOLE_ADDRESS;\n /// @solidity memory-safe-assembly\n assembly {\n pop(\n staticcall(\n gas(),\n consoleAddress,\n add(payload, 32),\n mload(payload),\n 0,\n 0\n )\n )\n }\n }\n\n function _castToPure(\n function(bytes memory) internal view fnIn\n ) internal pure returns (function(bytes memory) pure fnOut) {\n assembly {\n fnOut := fnIn\n }\n }\n\n function _sendLogPayload(bytes memory payload) internal pure {\n _castToPure(_sendLogPayloadImplementation)(payload);\n }\n\n function log() internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log()\"));\n }\n\n function logInt(int256 p0) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(int256)\", p0));\n }\n\n function logUint(uint256 p0) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256)\", p0));\n }\n\n function logString(string memory p0) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string)\", p0));\n }\n\n function logBool(bool p0) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool)\", p0));\n }\n\n function logAddress(address p0) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address)\", p0));\n }\n\n function logBytes(bytes memory p0) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bytes)\", p0));\n }\n\n function logBytes1(bytes1 p0) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bytes1)\", p0));\n }\n\n function logBytes2(bytes2 p0) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bytes2)\", p0));\n }\n\n function logBytes3(bytes3 p0) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bytes3)\", p0));\n }\n\n function logBytes4(bytes4 p0) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bytes4)\", p0));\n }\n\n function logBytes5(bytes5 p0) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bytes5)\", p0));\n }\n\n function logBytes6(bytes6 p0) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bytes6)\", p0));\n }\n\n function logBytes7(bytes7 p0) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bytes7)\", p0));\n }\n\n function logBytes8(bytes8 p0) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bytes8)\", p0));\n }\n\n function logBytes9(bytes9 p0) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bytes9)\", p0));\n }\n\n function logBytes10(bytes10 p0) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bytes10)\", p0));\n }\n\n function logBytes11(bytes11 p0) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bytes11)\", p0));\n }\n\n function logBytes12(bytes12 p0) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bytes12)\", p0));\n }\n\n function logBytes13(bytes13 p0) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bytes13)\", p0));\n }\n\n function logBytes14(bytes14 p0) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bytes14)\", p0));\n }\n\n function logBytes15(bytes15 p0) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bytes15)\", p0));\n }\n\n function logBytes16(bytes16 p0) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bytes16)\", p0));\n }\n\n function logBytes17(bytes17 p0) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bytes17)\", p0));\n }\n\n function logBytes18(bytes18 p0) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bytes18)\", p0));\n }\n\n function logBytes19(bytes19 p0) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bytes19)\", p0));\n }\n\n function logBytes20(bytes20 p0) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bytes20)\", p0));\n }\n\n function logBytes21(bytes21 p0) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bytes21)\", p0));\n }\n\n function logBytes22(bytes22 p0) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bytes22)\", p0));\n }\n\n function logBytes23(bytes23 p0) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bytes23)\", p0));\n }\n\n function logBytes24(bytes24 p0) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bytes24)\", p0));\n }\n\n function logBytes25(bytes25 p0) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bytes25)\", p0));\n }\n\n function logBytes26(bytes26 p0) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bytes26)\", p0));\n }\n\n function logBytes27(bytes27 p0) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bytes27)\", p0));\n }\n\n function logBytes28(bytes28 p0) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bytes28)\", p0));\n }\n\n function logBytes29(bytes29 p0) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bytes29)\", p0));\n }\n\n function logBytes30(bytes30 p0) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bytes30)\", p0));\n }\n\n function logBytes31(bytes31 p0) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bytes31)\", p0));\n }\n\n function logBytes32(bytes32 p0) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bytes32)\", p0));\n }\n\n function log(uint256 p0) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256)\", p0));\n }\n\n function log(int256 p0) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(int256)\", p0));\n }\n\n function log(string memory p0) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string)\", p0));\n }\n\n function log(bool p0) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool)\", p0));\n }\n\n function log(address p0) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address)\", p0));\n }\n\n function log(uint256 p0, uint256 p1) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,uint256)\", p0, p1));\n }\n\n function log(uint256 p0, string memory p1) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,string)\", p0, p1));\n }\n\n function log(uint256 p0, bool p1) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,bool)\", p0, p1));\n }\n\n function log(uint256 p0, address p1) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,address)\", p0, p1));\n }\n\n function log(string memory p0, uint256 p1) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,uint256)\", p0, p1));\n }\n\n function log(string memory p0, int256 p1) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,int256)\", p0, p1));\n }\n\n function log(string memory p0, string memory p1) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,string)\", p0, p1));\n }\n\n function log(string memory p0, bool p1) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,bool)\", p0, p1));\n }\n\n function log(string memory p0, address p1) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,address)\", p0, p1));\n }\n\n function log(bool p0, uint256 p1) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,uint256)\", p0, p1));\n }\n\n function log(bool p0, string memory p1) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,string)\", p0, p1));\n }\n\n function log(bool p0, bool p1) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,bool)\", p0, p1));\n }\n\n function log(bool p0, address p1) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,address)\", p0, p1));\n }\n\n function log(address p0, uint256 p1) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,uint256)\", p0, p1));\n }\n\n function log(address p0, string memory p1) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,string)\", p0, p1));\n }\n\n function log(address p0, bool p1) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,bool)\", p0, p1));\n }\n\n function log(address p0, address p1) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,address)\", p0, p1));\n }\n\n function log(uint256 p0, uint256 p1, uint256 p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,uint256,uint256)\", p0, p1, p2));\n }\n\n function log(uint256 p0, uint256 p1, string memory p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,uint256,string)\", p0, p1, p2));\n }\n\n function log(uint256 p0, uint256 p1, bool p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,uint256,bool)\", p0, p1, p2));\n }\n\n function log(uint256 p0, uint256 p1, address p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,uint256,address)\", p0, p1, p2));\n }\n\n function log(uint256 p0, string memory p1, uint256 p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,string,uint256)\", p0, p1, p2));\n }\n\n function log(uint256 p0, string memory p1, string memory p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,string,string)\", p0, p1, p2));\n }\n\n function log(uint256 p0, string memory p1, bool p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,string,bool)\", p0, p1, p2));\n }\n\n function log(uint256 p0, string memory p1, address p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,string,address)\", p0, p1, p2));\n }\n\n function log(uint256 p0, bool p1, uint256 p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,bool,uint256)\", p0, p1, p2));\n }\n\n function log(uint256 p0, bool p1, string memory p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,bool,string)\", p0, p1, p2));\n }\n\n function log(uint256 p0, bool p1, bool p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,bool,bool)\", p0, p1, p2));\n }\n\n function log(uint256 p0, bool p1, address p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,bool,address)\", p0, p1, p2));\n }\n\n function log(uint256 p0, address p1, uint256 p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,address,uint256)\", p0, p1, p2));\n }\n\n function log(uint256 p0, address p1, string memory p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,address,string)\", p0, p1, p2));\n }\n\n function log(uint256 p0, address p1, bool p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,address,bool)\", p0, p1, p2));\n }\n\n function log(uint256 p0, address p1, address p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,address,address)\", p0, p1, p2));\n }\n\n function log(string memory p0, uint256 p1, uint256 p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,uint256,uint256)\", p0, p1, p2));\n }\n\n function log(string memory p0, uint256 p1, string memory p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,uint256,string)\", p0, p1, p2));\n }\n\n function log(string memory p0, uint256 p1, bool p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,uint256,bool)\", p0, p1, p2));\n }\n\n function log(string memory p0, uint256 p1, address p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,uint256,address)\", p0, p1, p2));\n }\n\n function log(string memory p0, string memory p1, uint256 p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,string,uint256)\", p0, p1, p2));\n }\n\n function log(string memory p0, string memory p1, string memory p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,string,string)\", p0, p1, p2));\n }\n\n function log(string memory p0, string memory p1, bool p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,string,bool)\", p0, p1, p2));\n }\n\n function log(string memory p0, string memory p1, address p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,string,address)\", p0, p1, p2));\n }\n\n function log(string memory p0, bool p1, uint256 p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,bool,uint256)\", p0, p1, p2));\n }\n\n function log(string memory p0, bool p1, string memory p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,bool,string)\", p0, p1, p2));\n }\n\n function log(string memory p0, bool p1, bool p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,bool,bool)\", p0, p1, p2));\n }\n\n function log(string memory p0, bool p1, address p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,bool,address)\", p0, p1, p2));\n }\n\n function log(string memory p0, address p1, uint256 p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,address,uint256)\", p0, p1, p2));\n }\n\n function log(string memory p0, address p1, string memory p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,address,string)\", p0, p1, p2));\n }\n\n function log(string memory p0, address p1, bool p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,address,bool)\", p0, p1, p2));\n }\n\n function log(string memory p0, address p1, address p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,address,address)\", p0, p1, p2));\n }\n\n function log(bool p0, uint256 p1, uint256 p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,uint256,uint256)\", p0, p1, p2));\n }\n\n function log(bool p0, uint256 p1, string memory p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,uint256,string)\", p0, p1, p2));\n }\n\n function log(bool p0, uint256 p1, bool p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,uint256,bool)\", p0, p1, p2));\n }\n\n function log(bool p0, uint256 p1, address p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,uint256,address)\", p0, p1, p2));\n }\n\n function log(bool p0, string memory p1, uint256 p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,string,uint256)\", p0, p1, p2));\n }\n\n function log(bool p0, string memory p1, string memory p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,string,string)\", p0, p1, p2));\n }\n\n function log(bool p0, string memory p1, bool p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,string,bool)\", p0, p1, p2));\n }\n\n function log(bool p0, string memory p1, address p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,string,address)\", p0, p1, p2));\n }\n\n function log(bool p0, bool p1, uint256 p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,bool,uint256)\", p0, p1, p2));\n }\n\n function log(bool p0, bool p1, string memory p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,bool,string)\", p0, p1, p2));\n }\n\n function log(bool p0, bool p1, bool p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,bool,bool)\", p0, p1, p2));\n }\n\n function log(bool p0, bool p1, address p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,bool,address)\", p0, p1, p2));\n }\n\n function log(bool p0, address p1, uint256 p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,address,uint256)\", p0, p1, p2));\n }\n\n function log(bool p0, address p1, string memory p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,address,string)\", p0, p1, p2));\n }\n\n function log(bool p0, address p1, bool p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,address,bool)\", p0, p1, p2));\n }\n\n function log(bool p0, address p1, address p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,address,address)\", p0, p1, p2));\n }\n\n function log(address p0, uint256 p1, uint256 p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,uint256,uint256)\", p0, p1, p2));\n }\n\n function log(address p0, uint256 p1, string memory p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,uint256,string)\", p0, p1, p2));\n }\n\n function log(address p0, uint256 p1, bool p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,uint256,bool)\", p0, p1, p2));\n }\n\n function log(address p0, uint256 p1, address p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,uint256,address)\", p0, p1, p2));\n }\n\n function log(address p0, string memory p1, uint256 p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,string,uint256)\", p0, p1, p2));\n }\n\n function log(address p0, string memory p1, string memory p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,string,string)\", p0, p1, p2));\n }\n\n function log(address p0, string memory p1, bool p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,string,bool)\", p0, p1, p2));\n }\n\n function log(address p0, string memory p1, address p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,string,address)\", p0, p1, p2));\n }\n\n function log(address p0, bool p1, uint256 p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,bool,uint256)\", p0, p1, p2));\n }\n\n function log(address p0, bool p1, string memory p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,bool,string)\", p0, p1, p2));\n }\n\n function log(address p0, bool p1, bool p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,bool,bool)\", p0, p1, p2));\n }\n\n function log(address p0, bool p1, address p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,bool,address)\", p0, p1, p2));\n }\n\n function log(address p0, address p1, uint256 p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,address,uint256)\", p0, p1, p2));\n }\n\n function log(address p0, address p1, string memory p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,address,string)\", p0, p1, p2));\n }\n\n function log(address p0, address p1, bool p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,address,bool)\", p0, p1, p2));\n }\n\n function log(address p0, address p1, address p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,address,address)\", p0, p1, p2));\n }\n\n function log(uint256 p0, uint256 p1, uint256 p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,uint256,uint256,uint256)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, uint256 p1, uint256 p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,uint256,uint256,string)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, uint256 p1, uint256 p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,uint256,uint256,bool)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, uint256 p1, uint256 p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,uint256,uint256,address)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, uint256 p1, string memory p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,uint256,string,uint256)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, uint256 p1, string memory p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,uint256,string,string)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, uint256 p1, string memory p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,uint256,string,bool)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, uint256 p1, string memory p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,uint256,string,address)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, uint256 p1, bool p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,uint256,bool,uint256)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, uint256 p1, bool p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,uint256,bool,string)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, uint256 p1, bool p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,uint256,bool,bool)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, uint256 p1, bool p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,uint256,bool,address)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, uint256 p1, address p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,uint256,address,uint256)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, uint256 p1, address p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,uint256,address,string)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, uint256 p1, address p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,uint256,address,bool)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, uint256 p1, address p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,uint256,address,address)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, string memory p1, uint256 p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,string,uint256,uint256)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, string memory p1, uint256 p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,string,uint256,string)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, string memory p1, uint256 p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,string,uint256,bool)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, string memory p1, uint256 p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,string,uint256,address)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, string memory p1, string memory p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,string,string,uint256)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, string memory p1, string memory p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,string,string,string)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, string memory p1, string memory p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,string,string,bool)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, string memory p1, string memory p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,string,string,address)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, string memory p1, bool p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,string,bool,uint256)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, string memory p1, bool p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,string,bool,string)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, string memory p1, bool p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,string,bool,bool)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, string memory p1, bool p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,string,bool,address)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, string memory p1, address p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,string,address,uint256)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, string memory p1, address p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,string,address,string)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, string memory p1, address p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,string,address,bool)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, string memory p1, address p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,string,address,address)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, bool p1, uint256 p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,bool,uint256,uint256)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, bool p1, uint256 p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,bool,uint256,string)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, bool p1, uint256 p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,bool,uint256,bool)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, bool p1, uint256 p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,bool,uint256,address)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, bool p1, string memory p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,bool,string,uint256)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, bool p1, string memory p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,bool,string,string)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, bool p1, string memory p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,bool,string,bool)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, bool p1, string memory p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,bool,string,address)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, bool p1, bool p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,bool,bool,uint256)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, bool p1, bool p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,bool,bool,string)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, bool p1, bool p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,bool,bool,bool)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, bool p1, bool p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,bool,bool,address)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, bool p1, address p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,bool,address,uint256)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, bool p1, address p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,bool,address,string)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, bool p1, address p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,bool,address,bool)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, bool p1, address p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,bool,address,address)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, address p1, uint256 p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,address,uint256,uint256)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, address p1, uint256 p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,address,uint256,string)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, address p1, uint256 p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,address,uint256,bool)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, address p1, uint256 p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,address,uint256,address)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, address p1, string memory p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,address,string,uint256)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, address p1, string memory p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,address,string,string)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, address p1, string memory p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,address,string,bool)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, address p1, string memory p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,address,string,address)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, address p1, bool p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,address,bool,uint256)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, address p1, bool p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,address,bool,string)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, address p1, bool p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,address,bool,bool)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, address p1, bool p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,address,bool,address)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, address p1, address p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,address,address,uint256)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, address p1, address p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,address,address,string)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, address p1, address p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,address,address,bool)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, address p1, address p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,address,address,address)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, uint256 p1, uint256 p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,uint256,uint256,uint256)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, uint256 p1, uint256 p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,uint256,uint256,string)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, uint256 p1, uint256 p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,uint256,uint256,bool)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, uint256 p1, uint256 p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,uint256,uint256,address)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, uint256 p1, string memory p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,uint256,string,uint256)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, uint256 p1, string memory p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,uint256,string,string)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, uint256 p1, string memory p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,uint256,string,bool)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, uint256 p1, string memory p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,uint256,string,address)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, uint256 p1, bool p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,uint256,bool,uint256)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, uint256 p1, bool p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,uint256,bool,string)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, uint256 p1, bool p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,uint256,bool,bool)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, uint256 p1, bool p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,uint256,bool,address)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, uint256 p1, address p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,uint256,address,uint256)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, uint256 p1, address p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,uint256,address,string)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, uint256 p1, address p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,uint256,address,bool)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, uint256 p1, address p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,uint256,address,address)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, string memory p1, uint256 p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,string,uint256,uint256)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, string memory p1, uint256 p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,string,uint256,string)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, string memory p1, uint256 p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,string,uint256,bool)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, string memory p1, uint256 p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,string,uint256,address)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, string memory p1, string memory p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,string,string,uint256)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, string memory p1, string memory p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,string,string,string)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, string memory p1, string memory p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,string,string,bool)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, string memory p1, string memory p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,string,string,address)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, string memory p1, bool p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,string,bool,uint256)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, string memory p1, bool p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,string,bool,string)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, string memory p1, bool p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,string,bool,bool)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, string memory p1, bool p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,string,bool,address)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, string memory p1, address p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,string,address,uint256)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, string memory p1, address p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,string,address,string)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, string memory p1, address p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,string,address,bool)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, string memory p1, address p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,string,address,address)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, bool p1, uint256 p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,bool,uint256,uint256)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, bool p1, uint256 p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,bool,uint256,string)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, bool p1, uint256 p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,bool,uint256,bool)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, bool p1, uint256 p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,bool,uint256,address)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, bool p1, string memory p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,bool,string,uint256)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, bool p1, string memory p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,bool,string,string)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, bool p1, string memory p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,bool,string,bool)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, bool p1, string memory p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,bool,string,address)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, bool p1, bool p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,bool,bool,uint256)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, bool p1, bool p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,bool,bool,string)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, bool p1, bool p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,bool,bool,bool)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, bool p1, bool p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,bool,bool,address)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, bool p1, address p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,bool,address,uint256)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, bool p1, address p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,bool,address,string)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, bool p1, address p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,bool,address,bool)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, bool p1, address p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,bool,address,address)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, address p1, uint256 p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,address,uint256,uint256)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, address p1, uint256 p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,address,uint256,string)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, address p1, uint256 p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,address,uint256,bool)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, address p1, uint256 p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,address,uint256,address)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, address p1, string memory p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,address,string,uint256)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, address p1, string memory p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,address,string,string)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, address p1, string memory p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,address,string,bool)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, address p1, string memory p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,address,string,address)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, address p1, bool p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,address,bool,uint256)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, address p1, bool p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,address,bool,string)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, address p1, bool p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,address,bool,bool)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, address p1, bool p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,address,bool,address)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, address p1, address p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,address,address,uint256)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, address p1, address p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,address,address,string)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, address p1, address p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,address,address,bool)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, address p1, address p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,address,address,address)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, uint256 p1, uint256 p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,uint256,uint256,uint256)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, uint256 p1, uint256 p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,uint256,uint256,string)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, uint256 p1, uint256 p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,uint256,uint256,bool)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, uint256 p1, uint256 p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,uint256,uint256,address)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, uint256 p1, string memory p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,uint256,string,uint256)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, uint256 p1, string memory p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,uint256,string,string)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, uint256 p1, string memory p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,uint256,string,bool)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, uint256 p1, string memory p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,uint256,string,address)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, uint256 p1, bool p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,uint256,bool,uint256)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, uint256 p1, bool p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,uint256,bool,string)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, uint256 p1, bool p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,uint256,bool,bool)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, uint256 p1, bool p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,uint256,bool,address)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, uint256 p1, address p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,uint256,address,uint256)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, uint256 p1, address p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,uint256,address,string)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, uint256 p1, address p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,uint256,address,bool)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, uint256 p1, address p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,uint256,address,address)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, string memory p1, uint256 p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,string,uint256,uint256)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, string memory p1, uint256 p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,string,uint256,string)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, string memory p1, uint256 p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,string,uint256,bool)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, string memory p1, uint256 p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,string,uint256,address)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, string memory p1, string memory p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,string,string,uint256)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, string memory p1, string memory p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,string,string,string)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, string memory p1, string memory p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,string,string,bool)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, string memory p1, string memory p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,string,string,address)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, string memory p1, bool p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,string,bool,uint256)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, string memory p1, bool p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,string,bool,string)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, string memory p1, bool p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,string,bool,bool)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, string memory p1, bool p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,string,bool,address)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, string memory p1, address p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,string,address,uint256)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, string memory p1, address p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,string,address,string)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, string memory p1, address p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,string,address,bool)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, string memory p1, address p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,string,address,address)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, bool p1, uint256 p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,bool,uint256,uint256)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, bool p1, uint256 p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,bool,uint256,string)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, bool p1, uint256 p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,bool,uint256,bool)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, bool p1, uint256 p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,bool,uint256,address)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, bool p1, string memory p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,bool,string,uint256)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, bool p1, string memory p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,bool,string,string)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, bool p1, string memory p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,bool,string,bool)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, bool p1, string memory p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,bool,string,address)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, bool p1, bool p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,bool,bool,uint256)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, bool p1, bool p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,bool,bool,string)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, bool p1, bool p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,bool,bool,bool)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, bool p1, bool p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,bool,bool,address)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, bool p1, address p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,bool,address,uint256)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, bool p1, address p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,bool,address,string)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, bool p1, address p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,bool,address,bool)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, bool p1, address p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,bool,address,address)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, address p1, uint256 p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,address,uint256,uint256)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, address p1, uint256 p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,address,uint256,string)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, address p1, uint256 p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,address,uint256,bool)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, address p1, uint256 p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,address,uint256,address)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, address p1, string memory p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,address,string,uint256)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, address p1, string memory p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,address,string,string)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, address p1, string memory p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,address,string,bool)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, address p1, string memory p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,address,string,address)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, address p1, bool p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,address,bool,uint256)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, address p1, bool p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,address,bool,string)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, address p1, bool p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,address,bool,bool)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, address p1, bool p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,address,bool,address)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, address p1, address p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,address,address,uint256)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, address p1, address p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,address,address,string)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, address p1, address p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,address,address,bool)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, address p1, address p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,address,address,address)\", p0, p1, p2, p3));\n }\n\n function log(address p0, uint256 p1, uint256 p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,uint256,uint256,uint256)\", p0, p1, p2, p3));\n }\n\n function log(address p0, uint256 p1, uint256 p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,uint256,uint256,string)\", p0, p1, p2, p3));\n }\n\n function log(address p0, uint256 p1, uint256 p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,uint256,uint256,bool)\", p0, p1, p2, p3));\n }\n\n function log(address p0, uint256 p1, uint256 p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,uint256,uint256,address)\", p0, p1, p2, p3));\n }\n\n function log(address p0, uint256 p1, string memory p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,uint256,string,uint256)\", p0, p1, p2, p3));\n }\n\n function log(address p0, uint256 p1, string memory p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,uint256,string,string)\", p0, p1, p2, p3));\n }\n\n function log(address p0, uint256 p1, string memory p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,uint256,string,bool)\", p0, p1, p2, p3));\n }\n\n function log(address p0, uint256 p1, string memory p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,uint256,string,address)\", p0, p1, p2, p3));\n }\n\n function log(address p0, uint256 p1, bool p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,uint256,bool,uint256)\", p0, p1, p2, p3));\n }\n\n function log(address p0, uint256 p1, bool p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,uint256,bool,string)\", p0, p1, p2, p3));\n }\n\n function log(address p0, uint256 p1, bool p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,uint256,bool,bool)\", p0, p1, p2, p3));\n }\n\n function log(address p0, uint256 p1, bool p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,uint256,bool,address)\", p0, p1, p2, p3));\n }\n\n function log(address p0, uint256 p1, address p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,uint256,address,uint256)\", p0, p1, p2, p3));\n }\n\n function log(address p0, uint256 p1, address p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,uint256,address,string)\", p0, p1, p2, p3));\n }\n\n function log(address p0, uint256 p1, address p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,uint256,address,bool)\", p0, p1, p2, p3));\n }\n\n function log(address p0, uint256 p1, address p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,uint256,address,address)\", p0, p1, p2, p3));\n }\n\n function log(address p0, string memory p1, uint256 p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,string,uint256,uint256)\", p0, p1, p2, p3));\n }\n\n function log(address p0, string memory p1, uint256 p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,string,uint256,string)\", p0, p1, p2, p3));\n }\n\n function log(address p0, string memory p1, uint256 p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,string,uint256,bool)\", p0, p1, p2, p3));\n }\n\n function log(address p0, string memory p1, uint256 p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,string,uint256,address)\", p0, p1, p2, p3));\n }\n\n function log(address p0, string memory p1, string memory p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,string,string,uint256)\", p0, p1, p2, p3));\n }\n\n function log(address p0, string memory p1, string memory p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,string,string,string)\", p0, p1, p2, p3));\n }\n\n function log(address p0, string memory p1, string memory p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,string,string,bool)\", p0, p1, p2, p3));\n }\n\n function log(address p0, string memory p1, string memory p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,string,string,address)\", p0, p1, p2, p3));\n }\n\n function log(address p0, string memory p1, bool p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,string,bool,uint256)\", p0, p1, p2, p3));\n }\n\n function log(address p0, string memory p1, bool p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,string,bool,string)\", p0, p1, p2, p3));\n }\n\n function log(address p0, string memory p1, bool p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,string,bool,bool)\", p0, p1, p2, p3));\n }\n\n function log(address p0, string memory p1, bool p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,string,bool,address)\", p0, p1, p2, p3));\n }\n\n function log(address p0, string memory p1, address p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,string,address,uint256)\", p0, p1, p2, p3));\n }\n\n function log(address p0, string memory p1, address p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,string,address,string)\", p0, p1, p2, p3));\n }\n\n function log(address p0, string memory p1, address p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,string,address,bool)\", p0, p1, p2, p3));\n }\n\n function log(address p0, string memory p1, address p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,string,address,address)\", p0, p1, p2, p3));\n }\n\n function log(address p0, bool p1, uint256 p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,bool,uint256,uint256)\", p0, p1, p2, p3));\n }\n\n function log(address p0, bool p1, uint256 p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,bool,uint256,string)\", p0, p1, p2, p3));\n }\n\n function log(address p0, bool p1, uint256 p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,bool,uint256,bool)\", p0, p1, p2, p3));\n }\n\n function log(address p0, bool p1, uint256 p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,bool,uint256,address)\", p0, p1, p2, p3));\n }\n\n function log(address p0, bool p1, string memory p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,bool,string,uint256)\", p0, p1, p2, p3));\n }\n\n function log(address p0, bool p1, string memory p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,bool,string,string)\", p0, p1, p2, p3));\n }\n\n function log(address p0, bool p1, string memory p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,bool,string,bool)\", p0, p1, p2, p3));\n }\n\n function log(address p0, bool p1, string memory p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,bool,string,address)\", p0, p1, p2, p3));\n }\n\n function log(address p0, bool p1, bool p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,bool,bool,uint256)\", p0, p1, p2, p3));\n }\n\n function log(address p0, bool p1, bool p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,bool,bool,string)\", p0, p1, p2, p3));\n }\n\n function log(address p0, bool p1, bool p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,bool,bool,bool)\", p0, p1, p2, p3));\n }\n\n function log(address p0, bool p1, bool p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,bool,bool,address)\", p0, p1, p2, p3));\n }\n\n function log(address p0, bool p1, address p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,bool,address,uint256)\", p0, p1, p2, p3));\n }\n\n function log(address p0, bool p1, address p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,bool,address,string)\", p0, p1, p2, p3));\n }\n\n function log(address p0, bool p1, address p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,bool,address,bool)\", p0, p1, p2, p3));\n }\n\n function log(address p0, bool p1, address p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,bool,address,address)\", p0, p1, p2, p3));\n }\n\n function log(address p0, address p1, uint256 p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,address,uint256,uint256)\", p0, p1, p2, p3));\n }\n\n function log(address p0, address p1, uint256 p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,address,uint256,string)\", p0, p1, p2, p3));\n }\n\n function log(address p0, address p1, uint256 p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,address,uint256,bool)\", p0, p1, p2, p3));\n }\n\n function log(address p0, address p1, uint256 p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,address,uint256,address)\", p0, p1, p2, p3));\n }\n\n function log(address p0, address p1, string memory p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,address,string,uint256)\", p0, p1, p2, p3));\n }\n\n function log(address p0, address p1, string memory p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,address,string,string)\", p0, p1, p2, p3));\n }\n\n function log(address p0, address p1, string memory p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,address,string,bool)\", p0, p1, p2, p3));\n }\n\n function log(address p0, address p1, string memory p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,address,string,address)\", p0, p1, p2, p3));\n }\n\n function log(address p0, address p1, bool p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,address,bool,uint256)\", p0, p1, p2, p3));\n }\n\n function log(address p0, address p1, bool p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,address,bool,string)\", p0, p1, p2, p3));\n }\n\n function log(address p0, address p1, bool p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,address,bool,bool)\", p0, p1, p2, p3));\n }\n\n function log(address p0, address p1, bool p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,address,bool,address)\", p0, p1, p2, p3));\n }\n\n function log(address p0, address p1, address p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,address,address,uint256)\", p0, p1, p2, p3));\n }\n\n function log(address p0, address p1, address p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,address,address,string)\", p0, p1, p2, p3));\n }\n\n function log(address p0, address p1, address p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,address,address,bool)\", p0, p1, p2, p3));\n }\n\n function log(address p0, address p1, address p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,address,address,address)\", p0, p1, p2, p3));\n }\n}\n","license":"MIT"},"lib/forge-std/src/console2.sol":{"keccak256":"0x3b8fe79f48f065a4e4d35362171304a33784c3a90febae5f2787805a438de12f","urls":[],"content":"// SPDX-License-Identifier: MIT\npragma solidity >=0.4.22 <0.9.0;\n\nimport {console as console2} from \"./console.sol\";\n","license":"MIT"},"lib/forge-std/src/interfaces/IMulticall3.sol":{"keccak256":"0x7aac1389150499a922d1f9ef5749c908cef127cb2075b92fa17e9cb611263d0a","urls":[],"content":"// SPDX-License-Identifier: MIT\npragma solidity >=0.6.2 <0.9.0;\n\npragma experimental ABIEncoderV2;\n\ninterface IMulticall3 {\n struct Call {\n address target;\n bytes callData;\n }\n\n struct Call3 {\n address target;\n bool allowFailure;\n bytes callData;\n }\n\n struct Call3Value {\n address target;\n bool allowFailure;\n uint256 value;\n bytes callData;\n }\n\n struct Result {\n bool success;\n bytes returnData;\n }\n\n function aggregate(Call[] calldata calls)\n external\n payable\n returns (uint256 blockNumber, bytes[] memory returnData);\n\n function aggregate3(Call3[] calldata calls) external payable returns (Result[] memory returnData);\n\n function aggregate3Value(Call3Value[] calldata calls) external payable returns (Result[] memory returnData);\n\n function blockAndAggregate(Call[] calldata calls)\n external\n payable\n returns (uint256 blockNumber, bytes32 blockHash, Result[] memory returnData);\n\n function getBasefee() external view returns (uint256 basefee);\n\n function getBlockHash(uint256 blockNumber) external view returns (bytes32 blockHash);\n\n function getBlockNumber() external view returns (uint256 blockNumber);\n\n function getChainId() external view returns (uint256 chainid);\n\n function getCurrentBlockCoinbase() external view returns (address coinbase);\n\n function getCurrentBlockDifficulty() external view returns (uint256 difficulty);\n\n function getCurrentBlockGasLimit() external view returns (uint256 gaslimit);\n\n function getCurrentBlockTimestamp() external view returns (uint256 timestamp);\n\n function getEthBalance(address addr) external view returns (uint256 balance);\n\n function getLastBlockHash() external view returns (bytes32 blockHash);\n\n function tryAggregate(bool requireSuccess, Call[] calldata calls)\n external\n payable\n returns (Result[] memory returnData);\n\n function tryBlockAndAggregate(bool requireSuccess, Call[] calldata calls)\n external\n payable\n returns (uint256 blockNumber, bytes32 blockHash, Result[] memory returnData);\n}\n","license":"MIT"},"lib/forge-std/src/safeconsole.sol":{"keccak256":"0xbef9786cb49d3eade757bad87568c49c8c8f35721f0193c95ffb055d9e466e11","urls":[],"content":"// SPDX-License-Identifier: MIT\npragma solidity >=0.6.2 <0.9.0;\n\n/// @author philogy \n/// @dev Code generated automatically by script.\nlibrary safeconsole {\n uint256 constant CONSOLE_ADDR = 0x000000000000000000000000000000000000000000636F6e736F6c652e6c6f67;\n\n // Credit to [0age](https://twitter.com/z0age/status/1654922202930888704) and [0xdapper](https://github.com/foundry-rs/forge-std/pull/374)\n // for the view-to-pure log trick.\n function _sendLogPayload(uint256 offset, uint256 size) private pure {\n function(uint256, uint256) internal view fnIn = _sendLogPayloadView;\n function(uint256, uint256) internal pure pureSendLogPayload;\n /// @solidity memory-safe-assembly\n assembly {\n pureSendLogPayload := fnIn\n }\n pureSendLogPayload(offset, size);\n }\n\n function _sendLogPayloadView(uint256 offset, uint256 size) private view {\n /// @solidity memory-safe-assembly\n assembly {\n pop(staticcall(gas(), CONSOLE_ADDR, offset, size, 0x0, 0x0))\n }\n }\n\n function _memcopy(uint256 fromOffset, uint256 toOffset, uint256 length) private pure {\n function(uint256, uint256, uint256) internal view fnIn = _memcopyView;\n function(uint256, uint256, uint256) internal pure pureMemcopy;\n /// @solidity memory-safe-assembly\n assembly {\n pureMemcopy := fnIn\n }\n pureMemcopy(fromOffset, toOffset, length);\n }\n\n function _memcopyView(uint256 fromOffset, uint256 toOffset, uint256 length) private view {\n /// @solidity memory-safe-assembly\n assembly {\n pop(staticcall(gas(), 0x4, fromOffset, length, toOffset, length))\n }\n }\n\n function logMemory(uint256 offset, uint256 length) internal pure {\n if (offset >= 0x60) {\n // Sufficient memory before slice to prepare call header.\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(sub(offset, 0x60))\n m1 := mload(sub(offset, 0x40))\n m2 := mload(sub(offset, 0x20))\n // Selector of `log(bytes)`.\n mstore(sub(offset, 0x60), 0x0be77f56)\n mstore(sub(offset, 0x40), 0x20)\n mstore(sub(offset, 0x20), length)\n }\n _sendLogPayload(offset - 0x44, length + 0x44);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(sub(offset, 0x60), m0)\n mstore(sub(offset, 0x40), m1)\n mstore(sub(offset, 0x20), m2)\n }\n } else {\n // Insufficient space, so copy slice forward, add header and reverse.\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n uint256 endOffset = offset + length;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(add(endOffset, 0x00))\n m1 := mload(add(endOffset, 0x20))\n m2 := mload(add(endOffset, 0x40))\n }\n _memcopy(offset, offset + 0x60, length);\n /// @solidity memory-safe-assembly\n assembly {\n // Selector of `log(bytes)`.\n mstore(add(offset, 0x00), 0x0be77f56)\n mstore(add(offset, 0x20), 0x20)\n mstore(add(offset, 0x40), length)\n }\n _sendLogPayload(offset + 0x1c, length + 0x44);\n _memcopy(offset + 0x60, offset, length);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(add(endOffset, 0x00), m0)\n mstore(add(endOffset, 0x20), m1)\n mstore(add(endOffset, 0x40), m2)\n }\n }\n }\n\n function log(address p0) internal pure {\n bytes32 m0;\n bytes32 m1;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n // Selector of `log(address)`.\n mstore(0x00, 0x2c2ecbc2)\n mstore(0x20, p0)\n }\n _sendLogPayload(0x1c, 0x24);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n }\n }\n\n function log(bool p0) internal pure {\n bytes32 m0;\n bytes32 m1;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n // Selector of `log(bool)`.\n mstore(0x00, 0x32458eed)\n mstore(0x20, p0)\n }\n _sendLogPayload(0x1c, 0x24);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n }\n }\n\n function log(uint256 p0) internal pure {\n bytes32 m0;\n bytes32 m1;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n // Selector of `log(uint256)`.\n mstore(0x00, 0xf82c50f1)\n mstore(0x20, p0)\n }\n _sendLogPayload(0x1c, 0x24);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n }\n }\n\n function log(bytes32 p0) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n // Selector of `log(string)`.\n mstore(0x00, 0x41304fac)\n mstore(0x20, 0x20)\n writeString(0x40, p0)\n }\n _sendLogPayload(0x1c, 0x64);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n }\n }\n\n function log(address p0, address p1) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n // Selector of `log(address,address)`.\n mstore(0x00, 0xdaf0d4aa)\n mstore(0x20, p0)\n mstore(0x40, p1)\n }\n _sendLogPayload(0x1c, 0x44);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n }\n }\n\n function log(address p0, bool p1) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n // Selector of `log(address,bool)`.\n mstore(0x00, 0x75b605d3)\n mstore(0x20, p0)\n mstore(0x40, p1)\n }\n _sendLogPayload(0x1c, 0x44);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n }\n }\n\n function log(address p0, uint256 p1) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n // Selector of `log(address,uint256)`.\n mstore(0x00, 0x8309e8a8)\n mstore(0x20, p0)\n mstore(0x40, p1)\n }\n _sendLogPayload(0x1c, 0x44);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n }\n }\n\n function log(address p0, bytes32 p1) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(address,string)`.\n mstore(0x00, 0x759f86bb)\n mstore(0x20, p0)\n mstore(0x40, 0x40)\n writeString(0x60, p1)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(bool p0, address p1) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n // Selector of `log(bool,address)`.\n mstore(0x00, 0x853c4849)\n mstore(0x20, p0)\n mstore(0x40, p1)\n }\n _sendLogPayload(0x1c, 0x44);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n }\n }\n\n function log(bool p0, bool p1) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n // Selector of `log(bool,bool)`.\n mstore(0x00, 0x2a110e83)\n mstore(0x20, p0)\n mstore(0x40, p1)\n }\n _sendLogPayload(0x1c, 0x44);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n }\n }\n\n function log(bool p0, uint256 p1) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n // Selector of `log(bool,uint256)`.\n mstore(0x00, 0x399174d3)\n mstore(0x20, p0)\n mstore(0x40, p1)\n }\n _sendLogPayload(0x1c, 0x44);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n }\n }\n\n function log(bool p0, bytes32 p1) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(bool,string)`.\n mstore(0x00, 0x8feac525)\n mstore(0x20, p0)\n mstore(0x40, 0x40)\n writeString(0x60, p1)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(uint256 p0, address p1) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n // Selector of `log(uint256,address)`.\n mstore(0x00, 0x69276c86)\n mstore(0x20, p0)\n mstore(0x40, p1)\n }\n _sendLogPayload(0x1c, 0x44);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n }\n }\n\n function log(uint256 p0, bool p1) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n // Selector of `log(uint256,bool)`.\n mstore(0x00, 0x1c9d7eb3)\n mstore(0x20, p0)\n mstore(0x40, p1)\n }\n _sendLogPayload(0x1c, 0x44);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n }\n }\n\n function log(uint256 p0, uint256 p1) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n // Selector of `log(uint256,uint256)`.\n mstore(0x00, 0xf666715a)\n mstore(0x20, p0)\n mstore(0x40, p1)\n }\n _sendLogPayload(0x1c, 0x44);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n }\n }\n\n function log(uint256 p0, bytes32 p1) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(uint256,string)`.\n mstore(0x00, 0x643fd0df)\n mstore(0x20, p0)\n mstore(0x40, 0x40)\n writeString(0x60, p1)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(bytes32 p0, address p1) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(string,address)`.\n mstore(0x00, 0x319af333)\n mstore(0x20, 0x40)\n mstore(0x40, p1)\n writeString(0x60, p0)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(bytes32 p0, bool p1) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(string,bool)`.\n mstore(0x00, 0xc3b55635)\n mstore(0x20, 0x40)\n mstore(0x40, p1)\n writeString(0x60, p0)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(bytes32 p0, uint256 p1) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(string,uint256)`.\n mstore(0x00, 0xb60e72cc)\n mstore(0x20, 0x40)\n mstore(0x40, p1)\n writeString(0x60, p0)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(bytes32 p0, bytes32 p1) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(string,string)`.\n mstore(0x00, 0x4b5c4277)\n mstore(0x20, 0x40)\n mstore(0x40, 0x80)\n writeString(0x60, p0)\n writeString(0xa0, p1)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(address p0, address p1, address p2) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n // Selector of `log(address,address,address)`.\n mstore(0x00, 0x018c84c2)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n }\n _sendLogPayload(0x1c, 0x64);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n }\n }\n\n function log(address p0, address p1, bool p2) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n // Selector of `log(address,address,bool)`.\n mstore(0x00, 0xf2a66286)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n }\n _sendLogPayload(0x1c, 0x64);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n }\n }\n\n function log(address p0, address p1, uint256 p2) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n // Selector of `log(address,address,uint256)`.\n mstore(0x00, 0x17fe6185)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n }\n _sendLogPayload(0x1c, 0x64);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n }\n }\n\n function log(address p0, address p1, bytes32 p2) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n // Selector of `log(address,address,string)`.\n mstore(0x00, 0x007150be)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, 0x60)\n writeString(0x80, p2)\n }\n _sendLogPayload(0x1c, 0xa4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n }\n }\n\n function log(address p0, bool p1, address p2) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n // Selector of `log(address,bool,address)`.\n mstore(0x00, 0xf11699ed)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n }\n _sendLogPayload(0x1c, 0x64);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n }\n }\n\n function log(address p0, bool p1, bool p2) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n // Selector of `log(address,bool,bool)`.\n mstore(0x00, 0xeb830c92)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n }\n _sendLogPayload(0x1c, 0x64);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n }\n }\n\n function log(address p0, bool p1, uint256 p2) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n // Selector of `log(address,bool,uint256)`.\n mstore(0x00, 0x9c4f99fb)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n }\n _sendLogPayload(0x1c, 0x64);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n }\n }\n\n function log(address p0, bool p1, bytes32 p2) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n // Selector of `log(address,bool,string)`.\n mstore(0x00, 0x212255cc)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, 0x60)\n writeString(0x80, p2)\n }\n _sendLogPayload(0x1c, 0xa4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n }\n }\n\n function log(address p0, uint256 p1, address p2) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n // Selector of `log(address,uint256,address)`.\n mstore(0x00, 0x7bc0d848)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n }\n _sendLogPayload(0x1c, 0x64);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n }\n }\n\n function log(address p0, uint256 p1, bool p2) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n // Selector of `log(address,uint256,bool)`.\n mstore(0x00, 0x678209a8)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n }\n _sendLogPayload(0x1c, 0x64);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n }\n }\n\n function log(address p0, uint256 p1, uint256 p2) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n // Selector of `log(address,uint256,uint256)`.\n mstore(0x00, 0xb69bcaf6)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n }\n _sendLogPayload(0x1c, 0x64);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n }\n }\n\n function log(address p0, uint256 p1, bytes32 p2) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n // Selector of `log(address,uint256,string)`.\n mstore(0x00, 0xa1f2e8aa)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, 0x60)\n writeString(0x80, p2)\n }\n _sendLogPayload(0x1c, 0xa4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n }\n }\n\n function log(address p0, bytes32 p1, address p2) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n // Selector of `log(address,string,address)`.\n mstore(0x00, 0xf08744e8)\n mstore(0x20, p0)\n mstore(0x40, 0x60)\n mstore(0x60, p2)\n writeString(0x80, p1)\n }\n _sendLogPayload(0x1c, 0xa4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n }\n }\n\n function log(address p0, bytes32 p1, bool p2) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n // Selector of `log(address,string,bool)`.\n mstore(0x00, 0xcf020fb1)\n mstore(0x20, p0)\n mstore(0x40, 0x60)\n mstore(0x60, p2)\n writeString(0x80, p1)\n }\n _sendLogPayload(0x1c, 0xa4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n }\n }\n\n function log(address p0, bytes32 p1, uint256 p2) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n // Selector of `log(address,string,uint256)`.\n mstore(0x00, 0x67dd6ff1)\n mstore(0x20, p0)\n mstore(0x40, 0x60)\n mstore(0x60, p2)\n writeString(0x80, p1)\n }\n _sendLogPayload(0x1c, 0xa4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n }\n }\n\n function log(address p0, bytes32 p1, bytes32 p2) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n // Selector of `log(address,string,string)`.\n mstore(0x00, 0xfb772265)\n mstore(0x20, p0)\n mstore(0x40, 0x60)\n mstore(0x60, 0xa0)\n writeString(0x80, p1)\n writeString(0xc0, p2)\n }\n _sendLogPayload(0x1c, 0xe4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n }\n }\n\n function log(bool p0, address p1, address p2) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n // Selector of `log(bool,address,address)`.\n mstore(0x00, 0xd2763667)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n }\n _sendLogPayload(0x1c, 0x64);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n }\n }\n\n function log(bool p0, address p1, bool p2) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n // Selector of `log(bool,address,bool)`.\n mstore(0x00, 0x18c9c746)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n }\n _sendLogPayload(0x1c, 0x64);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n }\n }\n\n function log(bool p0, address p1, uint256 p2) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n // Selector of `log(bool,address,uint256)`.\n mstore(0x00, 0x5f7b9afb)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n }\n _sendLogPayload(0x1c, 0x64);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n }\n }\n\n function log(bool p0, address p1, bytes32 p2) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n // Selector of `log(bool,address,string)`.\n mstore(0x00, 0xde9a9270)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, 0x60)\n writeString(0x80, p2)\n }\n _sendLogPayload(0x1c, 0xa4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n }\n }\n\n function log(bool p0, bool p1, address p2) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n // Selector of `log(bool,bool,address)`.\n mstore(0x00, 0x1078f68d)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n }\n _sendLogPayload(0x1c, 0x64);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n }\n }\n\n function log(bool p0, bool p1, bool p2) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n // Selector of `log(bool,bool,bool)`.\n mstore(0x00, 0x50709698)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n }\n _sendLogPayload(0x1c, 0x64);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n }\n }\n\n function log(bool p0, bool p1, uint256 p2) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n // Selector of `log(bool,bool,uint256)`.\n mstore(0x00, 0x12f21602)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n }\n _sendLogPayload(0x1c, 0x64);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n }\n }\n\n function log(bool p0, bool p1, bytes32 p2) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n // Selector of `log(bool,bool,string)`.\n mstore(0x00, 0x2555fa46)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, 0x60)\n writeString(0x80, p2)\n }\n _sendLogPayload(0x1c, 0xa4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n }\n }\n\n function log(bool p0, uint256 p1, address p2) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n // Selector of `log(bool,uint256,address)`.\n mstore(0x00, 0x088ef9d2)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n }\n _sendLogPayload(0x1c, 0x64);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n }\n }\n\n function log(bool p0, uint256 p1, bool p2) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n // Selector of `log(bool,uint256,bool)`.\n mstore(0x00, 0xe8defba9)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n }\n _sendLogPayload(0x1c, 0x64);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n }\n }\n\n function log(bool p0, uint256 p1, uint256 p2) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n // Selector of `log(bool,uint256,uint256)`.\n mstore(0x00, 0x37103367)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n }\n _sendLogPayload(0x1c, 0x64);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n }\n }\n\n function log(bool p0, uint256 p1, bytes32 p2) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n // Selector of `log(bool,uint256,string)`.\n mstore(0x00, 0xc3fc3970)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, 0x60)\n writeString(0x80, p2)\n }\n _sendLogPayload(0x1c, 0xa4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n }\n }\n\n function log(bool p0, bytes32 p1, address p2) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n // Selector of `log(bool,string,address)`.\n mstore(0x00, 0x9591b953)\n mstore(0x20, p0)\n mstore(0x40, 0x60)\n mstore(0x60, p2)\n writeString(0x80, p1)\n }\n _sendLogPayload(0x1c, 0xa4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n }\n }\n\n function log(bool p0, bytes32 p1, bool p2) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n // Selector of `log(bool,string,bool)`.\n mstore(0x00, 0xdbb4c247)\n mstore(0x20, p0)\n mstore(0x40, 0x60)\n mstore(0x60, p2)\n writeString(0x80, p1)\n }\n _sendLogPayload(0x1c, 0xa4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n }\n }\n\n function log(bool p0, bytes32 p1, uint256 p2) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n // Selector of `log(bool,string,uint256)`.\n mstore(0x00, 0x1093ee11)\n mstore(0x20, p0)\n mstore(0x40, 0x60)\n mstore(0x60, p2)\n writeString(0x80, p1)\n }\n _sendLogPayload(0x1c, 0xa4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n }\n }\n\n function log(bool p0, bytes32 p1, bytes32 p2) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n // Selector of `log(bool,string,string)`.\n mstore(0x00, 0xb076847f)\n mstore(0x20, p0)\n mstore(0x40, 0x60)\n mstore(0x60, 0xa0)\n writeString(0x80, p1)\n writeString(0xc0, p2)\n }\n _sendLogPayload(0x1c, 0xe4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n }\n }\n\n function log(uint256 p0, address p1, address p2) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n // Selector of `log(uint256,address,address)`.\n mstore(0x00, 0xbcfd9be0)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n }\n _sendLogPayload(0x1c, 0x64);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n }\n }\n\n function log(uint256 p0, address p1, bool p2) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n // Selector of `log(uint256,address,bool)`.\n mstore(0x00, 0x9b6ec042)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n }\n _sendLogPayload(0x1c, 0x64);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n }\n }\n\n function log(uint256 p0, address p1, uint256 p2) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n // Selector of `log(uint256,address,uint256)`.\n mstore(0x00, 0x5a9b5ed5)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n }\n _sendLogPayload(0x1c, 0x64);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n }\n }\n\n function log(uint256 p0, address p1, bytes32 p2) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n // Selector of `log(uint256,address,string)`.\n mstore(0x00, 0x63cb41f9)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, 0x60)\n writeString(0x80, p2)\n }\n _sendLogPayload(0x1c, 0xa4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n }\n }\n\n function log(uint256 p0, bool p1, address p2) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n // Selector of `log(uint256,bool,address)`.\n mstore(0x00, 0x35085f7b)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n }\n _sendLogPayload(0x1c, 0x64);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n }\n }\n\n function log(uint256 p0, bool p1, bool p2) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n // Selector of `log(uint256,bool,bool)`.\n mstore(0x00, 0x20718650)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n }\n _sendLogPayload(0x1c, 0x64);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n }\n }\n\n function log(uint256 p0, bool p1, uint256 p2) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n // Selector of `log(uint256,bool,uint256)`.\n mstore(0x00, 0x20098014)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n }\n _sendLogPayload(0x1c, 0x64);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n }\n }\n\n function log(uint256 p0, bool p1, bytes32 p2) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n // Selector of `log(uint256,bool,string)`.\n mstore(0x00, 0x85775021)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, 0x60)\n writeString(0x80, p2)\n }\n _sendLogPayload(0x1c, 0xa4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n }\n }\n\n function log(uint256 p0, uint256 p1, address p2) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n // Selector of `log(uint256,uint256,address)`.\n mstore(0x00, 0x5c96b331)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n }\n _sendLogPayload(0x1c, 0x64);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n }\n }\n\n function log(uint256 p0, uint256 p1, bool p2) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n // Selector of `log(uint256,uint256,bool)`.\n mstore(0x00, 0x4766da72)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n }\n _sendLogPayload(0x1c, 0x64);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n }\n }\n\n function log(uint256 p0, uint256 p1, uint256 p2) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n // Selector of `log(uint256,uint256,uint256)`.\n mstore(0x00, 0xd1ed7a3c)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n }\n _sendLogPayload(0x1c, 0x64);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n }\n }\n\n function log(uint256 p0, uint256 p1, bytes32 p2) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n // Selector of `log(uint256,uint256,string)`.\n mstore(0x00, 0x71d04af2)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, 0x60)\n writeString(0x80, p2)\n }\n _sendLogPayload(0x1c, 0xa4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n }\n }\n\n function log(uint256 p0, bytes32 p1, address p2) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n // Selector of `log(uint256,string,address)`.\n mstore(0x00, 0x7afac959)\n mstore(0x20, p0)\n mstore(0x40, 0x60)\n mstore(0x60, p2)\n writeString(0x80, p1)\n }\n _sendLogPayload(0x1c, 0xa4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n }\n }\n\n function log(uint256 p0, bytes32 p1, bool p2) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n // Selector of `log(uint256,string,bool)`.\n mstore(0x00, 0x4ceda75a)\n mstore(0x20, p0)\n mstore(0x40, 0x60)\n mstore(0x60, p2)\n writeString(0x80, p1)\n }\n _sendLogPayload(0x1c, 0xa4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n }\n }\n\n function log(uint256 p0, bytes32 p1, uint256 p2) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n // Selector of `log(uint256,string,uint256)`.\n mstore(0x00, 0x37aa7d4c)\n mstore(0x20, p0)\n mstore(0x40, 0x60)\n mstore(0x60, p2)\n writeString(0x80, p1)\n }\n _sendLogPayload(0x1c, 0xa4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n }\n }\n\n function log(uint256 p0, bytes32 p1, bytes32 p2) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n // Selector of `log(uint256,string,string)`.\n mstore(0x00, 0xb115611f)\n mstore(0x20, p0)\n mstore(0x40, 0x60)\n mstore(0x60, 0xa0)\n writeString(0x80, p1)\n writeString(0xc0, p2)\n }\n _sendLogPayload(0x1c, 0xe4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n }\n }\n\n function log(bytes32 p0, address p1, address p2) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n // Selector of `log(string,address,address)`.\n mstore(0x00, 0xfcec75e0)\n mstore(0x20, 0x60)\n mstore(0x40, p1)\n mstore(0x60, p2)\n writeString(0x80, p0)\n }\n _sendLogPayload(0x1c, 0xa4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n }\n }\n\n function log(bytes32 p0, address p1, bool p2) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n // Selector of `log(string,address,bool)`.\n mstore(0x00, 0xc91d5ed4)\n mstore(0x20, 0x60)\n mstore(0x40, p1)\n mstore(0x60, p2)\n writeString(0x80, p0)\n }\n _sendLogPayload(0x1c, 0xa4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n }\n }\n\n function log(bytes32 p0, address p1, uint256 p2) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n // Selector of `log(string,address,uint256)`.\n mstore(0x00, 0x0d26b925)\n mstore(0x20, 0x60)\n mstore(0x40, p1)\n mstore(0x60, p2)\n writeString(0x80, p0)\n }\n _sendLogPayload(0x1c, 0xa4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n }\n }\n\n function log(bytes32 p0, address p1, bytes32 p2) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n // Selector of `log(string,address,string)`.\n mstore(0x00, 0xe0e9ad4f)\n mstore(0x20, 0x60)\n mstore(0x40, p1)\n mstore(0x60, 0xa0)\n writeString(0x80, p0)\n writeString(0xc0, p2)\n }\n _sendLogPayload(0x1c, 0xe4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n }\n }\n\n function log(bytes32 p0, bool p1, address p2) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n // Selector of `log(string,bool,address)`.\n mstore(0x00, 0x932bbb38)\n mstore(0x20, 0x60)\n mstore(0x40, p1)\n mstore(0x60, p2)\n writeString(0x80, p0)\n }\n _sendLogPayload(0x1c, 0xa4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n }\n }\n\n function log(bytes32 p0, bool p1, bool p2) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n // Selector of `log(string,bool,bool)`.\n mstore(0x00, 0x850b7ad6)\n mstore(0x20, 0x60)\n mstore(0x40, p1)\n mstore(0x60, p2)\n writeString(0x80, p0)\n }\n _sendLogPayload(0x1c, 0xa4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n }\n }\n\n function log(bytes32 p0, bool p1, uint256 p2) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n // Selector of `log(string,bool,uint256)`.\n mstore(0x00, 0xc95958d6)\n mstore(0x20, 0x60)\n mstore(0x40, p1)\n mstore(0x60, p2)\n writeString(0x80, p0)\n }\n _sendLogPayload(0x1c, 0xa4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n }\n }\n\n function log(bytes32 p0, bool p1, bytes32 p2) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n // Selector of `log(string,bool,string)`.\n mstore(0x00, 0xe298f47d)\n mstore(0x20, 0x60)\n mstore(0x40, p1)\n mstore(0x60, 0xa0)\n writeString(0x80, p0)\n writeString(0xc0, p2)\n }\n _sendLogPayload(0x1c, 0xe4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n }\n }\n\n function log(bytes32 p0, uint256 p1, address p2) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n // Selector of `log(string,uint256,address)`.\n mstore(0x00, 0x1c7ec448)\n mstore(0x20, 0x60)\n mstore(0x40, p1)\n mstore(0x60, p2)\n writeString(0x80, p0)\n }\n _sendLogPayload(0x1c, 0xa4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n }\n }\n\n function log(bytes32 p0, uint256 p1, bool p2) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n // Selector of `log(string,uint256,bool)`.\n mstore(0x00, 0xca7733b1)\n mstore(0x20, 0x60)\n mstore(0x40, p1)\n mstore(0x60, p2)\n writeString(0x80, p0)\n }\n _sendLogPayload(0x1c, 0xa4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n }\n }\n\n function log(bytes32 p0, uint256 p1, uint256 p2) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n // Selector of `log(string,uint256,uint256)`.\n mstore(0x00, 0xca47c4eb)\n mstore(0x20, 0x60)\n mstore(0x40, p1)\n mstore(0x60, p2)\n writeString(0x80, p0)\n }\n _sendLogPayload(0x1c, 0xa4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n }\n }\n\n function log(bytes32 p0, uint256 p1, bytes32 p2) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n // Selector of `log(string,uint256,string)`.\n mstore(0x00, 0x5970e089)\n mstore(0x20, 0x60)\n mstore(0x40, p1)\n mstore(0x60, 0xa0)\n writeString(0x80, p0)\n writeString(0xc0, p2)\n }\n _sendLogPayload(0x1c, 0xe4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n }\n }\n\n function log(bytes32 p0, bytes32 p1, address p2) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n // Selector of `log(string,string,address)`.\n mstore(0x00, 0x95ed0195)\n mstore(0x20, 0x60)\n mstore(0x40, 0xa0)\n mstore(0x60, p2)\n writeString(0x80, p0)\n writeString(0xc0, p1)\n }\n _sendLogPayload(0x1c, 0xe4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n }\n }\n\n function log(bytes32 p0, bytes32 p1, bool p2) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n // Selector of `log(string,string,bool)`.\n mstore(0x00, 0xb0e0f9b5)\n mstore(0x20, 0x60)\n mstore(0x40, 0xa0)\n mstore(0x60, p2)\n writeString(0x80, p0)\n writeString(0xc0, p1)\n }\n _sendLogPayload(0x1c, 0xe4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n }\n }\n\n function log(bytes32 p0, bytes32 p1, uint256 p2) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n // Selector of `log(string,string,uint256)`.\n mstore(0x00, 0x5821efa1)\n mstore(0x20, 0x60)\n mstore(0x40, 0xa0)\n mstore(0x60, p2)\n writeString(0x80, p0)\n writeString(0xc0, p1)\n }\n _sendLogPayload(0x1c, 0xe4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n }\n }\n\n function log(bytes32 p0, bytes32 p1, bytes32 p2) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n bytes32 m9;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n m9 := mload(0x120)\n // Selector of `log(string,string,string)`.\n mstore(0x00, 0x2ced7cef)\n mstore(0x20, 0x60)\n mstore(0x40, 0xa0)\n mstore(0x60, 0xe0)\n writeString(0x80, p0)\n writeString(0xc0, p1)\n writeString(0x100, p2)\n }\n _sendLogPayload(0x1c, 0x124);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n mstore(0x120, m9)\n }\n }\n\n function log(address p0, address p1, address p2, address p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(address,address,address,address)`.\n mstore(0x00, 0x665bf134)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(address p0, address p1, address p2, bool p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(address,address,address,bool)`.\n mstore(0x00, 0x0e378994)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(address p0, address p1, address p2, uint256 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(address,address,address,uint256)`.\n mstore(0x00, 0x94250d77)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(address p0, address p1, address p2, bytes32 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(address,address,address,string)`.\n mstore(0x00, 0xf808da20)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, 0x80)\n writeString(0xa0, p3)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(address p0, address p1, bool p2, address p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(address,address,bool,address)`.\n mstore(0x00, 0x9f1bc36e)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(address p0, address p1, bool p2, bool p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(address,address,bool,bool)`.\n mstore(0x00, 0x2cd4134a)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(address p0, address p1, bool p2, uint256 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(address,address,bool,uint256)`.\n mstore(0x00, 0x3971e78c)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(address p0, address p1, bool p2, bytes32 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(address,address,bool,string)`.\n mstore(0x00, 0xaa6540c8)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, 0x80)\n writeString(0xa0, p3)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(address p0, address p1, uint256 p2, address p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(address,address,uint256,address)`.\n mstore(0x00, 0x8da6def5)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(address p0, address p1, uint256 p2, bool p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(address,address,uint256,bool)`.\n mstore(0x00, 0x9b4254e2)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(address p0, address p1, uint256 p2, uint256 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(address,address,uint256,uint256)`.\n mstore(0x00, 0xbe553481)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(address p0, address p1, uint256 p2, bytes32 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(address,address,uint256,string)`.\n mstore(0x00, 0xfdb4f990)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, 0x80)\n writeString(0xa0, p3)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(address p0, address p1, bytes32 p2, address p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(address,address,string,address)`.\n mstore(0x00, 0x8f736d16)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, 0x80)\n mstore(0x80, p3)\n writeString(0xa0, p2)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(address p0, address p1, bytes32 p2, bool p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(address,address,string,bool)`.\n mstore(0x00, 0x6f1a594e)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, 0x80)\n mstore(0x80, p3)\n writeString(0xa0, p2)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(address p0, address p1, bytes32 p2, uint256 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(address,address,string,uint256)`.\n mstore(0x00, 0xef1cefe7)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, 0x80)\n mstore(0x80, p3)\n writeString(0xa0, p2)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(address p0, address p1, bytes32 p2, bytes32 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n // Selector of `log(address,address,string,string)`.\n mstore(0x00, 0x21bdaf25)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, 0x80)\n mstore(0x80, 0xc0)\n writeString(0xa0, p2)\n writeString(0xe0, p3)\n }\n _sendLogPayload(0x1c, 0x104);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n }\n }\n\n function log(address p0, bool p1, address p2, address p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(address,bool,address,address)`.\n mstore(0x00, 0x660375dd)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(address p0, bool p1, address p2, bool p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(address,bool,address,bool)`.\n mstore(0x00, 0xa6f50b0f)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(address p0, bool p1, address p2, uint256 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(address,bool,address,uint256)`.\n mstore(0x00, 0xa75c59de)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(address p0, bool p1, address p2, bytes32 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(address,bool,address,string)`.\n mstore(0x00, 0x2dd778e6)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, 0x80)\n writeString(0xa0, p3)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(address p0, bool p1, bool p2, address p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(address,bool,bool,address)`.\n mstore(0x00, 0xcf394485)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(address p0, bool p1, bool p2, bool p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(address,bool,bool,bool)`.\n mstore(0x00, 0xcac43479)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(address p0, bool p1, bool p2, uint256 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(address,bool,bool,uint256)`.\n mstore(0x00, 0x8c4e5de6)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(address p0, bool p1, bool p2, bytes32 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(address,bool,bool,string)`.\n mstore(0x00, 0xdfc4a2e8)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, 0x80)\n writeString(0xa0, p3)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(address p0, bool p1, uint256 p2, address p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(address,bool,uint256,address)`.\n mstore(0x00, 0xccf790a1)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(address p0, bool p1, uint256 p2, bool p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(address,bool,uint256,bool)`.\n mstore(0x00, 0xc4643e20)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(address p0, bool p1, uint256 p2, uint256 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(address,bool,uint256,uint256)`.\n mstore(0x00, 0x386ff5f4)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(address p0, bool p1, uint256 p2, bytes32 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(address,bool,uint256,string)`.\n mstore(0x00, 0x0aa6cfad)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, 0x80)\n writeString(0xa0, p3)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(address p0, bool p1, bytes32 p2, address p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(address,bool,string,address)`.\n mstore(0x00, 0x19fd4956)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, 0x80)\n mstore(0x80, p3)\n writeString(0xa0, p2)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(address p0, bool p1, bytes32 p2, bool p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(address,bool,string,bool)`.\n mstore(0x00, 0x50ad461d)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, 0x80)\n mstore(0x80, p3)\n writeString(0xa0, p2)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(address p0, bool p1, bytes32 p2, uint256 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(address,bool,string,uint256)`.\n mstore(0x00, 0x80e6a20b)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, 0x80)\n mstore(0x80, p3)\n writeString(0xa0, p2)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(address p0, bool p1, bytes32 p2, bytes32 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n // Selector of `log(address,bool,string,string)`.\n mstore(0x00, 0x475c5c33)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, 0x80)\n mstore(0x80, 0xc0)\n writeString(0xa0, p2)\n writeString(0xe0, p3)\n }\n _sendLogPayload(0x1c, 0x104);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n }\n }\n\n function log(address p0, uint256 p1, address p2, address p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(address,uint256,address,address)`.\n mstore(0x00, 0x478d1c62)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(address p0, uint256 p1, address p2, bool p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(address,uint256,address,bool)`.\n mstore(0x00, 0xa1bcc9b3)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(address p0, uint256 p1, address p2, uint256 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(address,uint256,address,uint256)`.\n mstore(0x00, 0x100f650e)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(address p0, uint256 p1, address p2, bytes32 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(address,uint256,address,string)`.\n mstore(0x00, 0x1da986ea)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, 0x80)\n writeString(0xa0, p3)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(address p0, uint256 p1, bool p2, address p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(address,uint256,bool,address)`.\n mstore(0x00, 0xa31bfdcc)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(address p0, uint256 p1, bool p2, bool p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(address,uint256,bool,bool)`.\n mstore(0x00, 0x3bf5e537)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(address p0, uint256 p1, bool p2, uint256 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(address,uint256,bool,uint256)`.\n mstore(0x00, 0x22f6b999)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(address p0, uint256 p1, bool p2, bytes32 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(address,uint256,bool,string)`.\n mstore(0x00, 0xc5ad85f9)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, 0x80)\n writeString(0xa0, p3)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(address p0, uint256 p1, uint256 p2, address p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(address,uint256,uint256,address)`.\n mstore(0x00, 0x20e3984d)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(address p0, uint256 p1, uint256 p2, bool p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(address,uint256,uint256,bool)`.\n mstore(0x00, 0x66f1bc67)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(address p0, uint256 p1, uint256 p2, uint256 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(address,uint256,uint256,uint256)`.\n mstore(0x00, 0x34f0e636)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(address p0, uint256 p1, uint256 p2, bytes32 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(address,uint256,uint256,string)`.\n mstore(0x00, 0x4a28c017)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, 0x80)\n writeString(0xa0, p3)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(address p0, uint256 p1, bytes32 p2, address p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(address,uint256,string,address)`.\n mstore(0x00, 0x5c430d47)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, 0x80)\n mstore(0x80, p3)\n writeString(0xa0, p2)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(address p0, uint256 p1, bytes32 p2, bool p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(address,uint256,string,bool)`.\n mstore(0x00, 0xcf18105c)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, 0x80)\n mstore(0x80, p3)\n writeString(0xa0, p2)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(address p0, uint256 p1, bytes32 p2, uint256 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(address,uint256,string,uint256)`.\n mstore(0x00, 0xbf01f891)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, 0x80)\n mstore(0x80, p3)\n writeString(0xa0, p2)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(address p0, uint256 p1, bytes32 p2, bytes32 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n // Selector of `log(address,uint256,string,string)`.\n mstore(0x00, 0x88a8c406)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, 0x80)\n mstore(0x80, 0xc0)\n writeString(0xa0, p2)\n writeString(0xe0, p3)\n }\n _sendLogPayload(0x1c, 0x104);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n }\n }\n\n function log(address p0, bytes32 p1, address p2, address p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(address,string,address,address)`.\n mstore(0x00, 0x0d36fa20)\n mstore(0x20, p0)\n mstore(0x40, 0x80)\n mstore(0x60, p2)\n mstore(0x80, p3)\n writeString(0xa0, p1)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(address p0, bytes32 p1, address p2, bool p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(address,string,address,bool)`.\n mstore(0x00, 0x0df12b76)\n mstore(0x20, p0)\n mstore(0x40, 0x80)\n mstore(0x60, p2)\n mstore(0x80, p3)\n writeString(0xa0, p1)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(address p0, bytes32 p1, address p2, uint256 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(address,string,address,uint256)`.\n mstore(0x00, 0x457fe3cf)\n mstore(0x20, p0)\n mstore(0x40, 0x80)\n mstore(0x60, p2)\n mstore(0x80, p3)\n writeString(0xa0, p1)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(address p0, bytes32 p1, address p2, bytes32 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n // Selector of `log(address,string,address,string)`.\n mstore(0x00, 0xf7e36245)\n mstore(0x20, p0)\n mstore(0x40, 0x80)\n mstore(0x60, p2)\n mstore(0x80, 0xc0)\n writeString(0xa0, p1)\n writeString(0xe0, p3)\n }\n _sendLogPayload(0x1c, 0x104);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n }\n }\n\n function log(address p0, bytes32 p1, bool p2, address p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(address,string,bool,address)`.\n mstore(0x00, 0x205871c2)\n mstore(0x20, p0)\n mstore(0x40, 0x80)\n mstore(0x60, p2)\n mstore(0x80, p3)\n writeString(0xa0, p1)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(address p0, bytes32 p1, bool p2, bool p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(address,string,bool,bool)`.\n mstore(0x00, 0x5f1d5c9f)\n mstore(0x20, p0)\n mstore(0x40, 0x80)\n mstore(0x60, p2)\n mstore(0x80, p3)\n writeString(0xa0, p1)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(address p0, bytes32 p1, bool p2, uint256 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(address,string,bool,uint256)`.\n mstore(0x00, 0x515e38b6)\n mstore(0x20, p0)\n mstore(0x40, 0x80)\n mstore(0x60, p2)\n mstore(0x80, p3)\n writeString(0xa0, p1)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(address p0, bytes32 p1, bool p2, bytes32 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n // Selector of `log(address,string,bool,string)`.\n mstore(0x00, 0xbc0b61fe)\n mstore(0x20, p0)\n mstore(0x40, 0x80)\n mstore(0x60, p2)\n mstore(0x80, 0xc0)\n writeString(0xa0, p1)\n writeString(0xe0, p3)\n }\n _sendLogPayload(0x1c, 0x104);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n }\n }\n\n function log(address p0, bytes32 p1, uint256 p2, address p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(address,string,uint256,address)`.\n mstore(0x00, 0x63183678)\n mstore(0x20, p0)\n mstore(0x40, 0x80)\n mstore(0x60, p2)\n mstore(0x80, p3)\n writeString(0xa0, p1)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(address p0, bytes32 p1, uint256 p2, bool p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(address,string,uint256,bool)`.\n mstore(0x00, 0x0ef7e050)\n mstore(0x20, p0)\n mstore(0x40, 0x80)\n mstore(0x60, p2)\n mstore(0x80, p3)\n writeString(0xa0, p1)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(address p0, bytes32 p1, uint256 p2, uint256 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(address,string,uint256,uint256)`.\n mstore(0x00, 0x1dc8e1b8)\n mstore(0x20, p0)\n mstore(0x40, 0x80)\n mstore(0x60, p2)\n mstore(0x80, p3)\n writeString(0xa0, p1)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(address p0, bytes32 p1, uint256 p2, bytes32 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n // Selector of `log(address,string,uint256,string)`.\n mstore(0x00, 0x448830a8)\n mstore(0x20, p0)\n mstore(0x40, 0x80)\n mstore(0x60, p2)\n mstore(0x80, 0xc0)\n writeString(0xa0, p1)\n writeString(0xe0, p3)\n }\n _sendLogPayload(0x1c, 0x104);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n }\n }\n\n function log(address p0, bytes32 p1, bytes32 p2, address p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n // Selector of `log(address,string,string,address)`.\n mstore(0x00, 0xa04e2f87)\n mstore(0x20, p0)\n mstore(0x40, 0x80)\n mstore(0x60, 0xc0)\n mstore(0x80, p3)\n writeString(0xa0, p1)\n writeString(0xe0, p2)\n }\n _sendLogPayload(0x1c, 0x104);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n }\n }\n\n function log(address p0, bytes32 p1, bytes32 p2, bool p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n // Selector of `log(address,string,string,bool)`.\n mstore(0x00, 0x35a5071f)\n mstore(0x20, p0)\n mstore(0x40, 0x80)\n mstore(0x60, 0xc0)\n mstore(0x80, p3)\n writeString(0xa0, p1)\n writeString(0xe0, p2)\n }\n _sendLogPayload(0x1c, 0x104);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n }\n }\n\n function log(address p0, bytes32 p1, bytes32 p2, uint256 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n // Selector of `log(address,string,string,uint256)`.\n mstore(0x00, 0x159f8927)\n mstore(0x20, p0)\n mstore(0x40, 0x80)\n mstore(0x60, 0xc0)\n mstore(0x80, p3)\n writeString(0xa0, p1)\n writeString(0xe0, p2)\n }\n _sendLogPayload(0x1c, 0x104);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n }\n }\n\n function log(address p0, bytes32 p1, bytes32 p2, bytes32 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n bytes32 m9;\n bytes32 m10;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n m9 := mload(0x120)\n m10 := mload(0x140)\n // Selector of `log(address,string,string,string)`.\n mstore(0x00, 0x5d02c50b)\n mstore(0x20, p0)\n mstore(0x40, 0x80)\n mstore(0x60, 0xc0)\n mstore(0x80, 0x100)\n writeString(0xa0, p1)\n writeString(0xe0, p2)\n writeString(0x120, p3)\n }\n _sendLogPayload(0x1c, 0x144);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n mstore(0x120, m9)\n mstore(0x140, m10)\n }\n }\n\n function log(bool p0, address p1, address p2, address p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(bool,address,address,address)`.\n mstore(0x00, 0x1d14d001)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(bool p0, address p1, address p2, bool p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(bool,address,address,bool)`.\n mstore(0x00, 0x46600be0)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(bool p0, address p1, address p2, uint256 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(bool,address,address,uint256)`.\n mstore(0x00, 0x0c66d1be)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(bool p0, address p1, address p2, bytes32 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(bool,address,address,string)`.\n mstore(0x00, 0xd812a167)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, 0x80)\n writeString(0xa0, p3)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(bool p0, address p1, bool p2, address p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(bool,address,bool,address)`.\n mstore(0x00, 0x1c41a336)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(bool p0, address p1, bool p2, bool p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(bool,address,bool,bool)`.\n mstore(0x00, 0x6a9c478b)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(bool p0, address p1, bool p2, uint256 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(bool,address,bool,uint256)`.\n mstore(0x00, 0x07831502)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(bool p0, address p1, bool p2, bytes32 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(bool,address,bool,string)`.\n mstore(0x00, 0x4a66cb34)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, 0x80)\n writeString(0xa0, p3)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(bool p0, address p1, uint256 p2, address p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(bool,address,uint256,address)`.\n mstore(0x00, 0x136b05dd)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(bool p0, address p1, uint256 p2, bool p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(bool,address,uint256,bool)`.\n mstore(0x00, 0xd6019f1c)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(bool p0, address p1, uint256 p2, uint256 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(bool,address,uint256,uint256)`.\n mstore(0x00, 0x7bf181a1)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(bool p0, address p1, uint256 p2, bytes32 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(bool,address,uint256,string)`.\n mstore(0x00, 0x51f09ff8)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, 0x80)\n writeString(0xa0, p3)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(bool p0, address p1, bytes32 p2, address p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(bool,address,string,address)`.\n mstore(0x00, 0x6f7c603e)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, 0x80)\n mstore(0x80, p3)\n writeString(0xa0, p2)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(bool p0, address p1, bytes32 p2, bool p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(bool,address,string,bool)`.\n mstore(0x00, 0xe2bfd60b)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, 0x80)\n mstore(0x80, p3)\n writeString(0xa0, p2)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(bool p0, address p1, bytes32 p2, uint256 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(bool,address,string,uint256)`.\n mstore(0x00, 0xc21f64c7)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, 0x80)\n mstore(0x80, p3)\n writeString(0xa0, p2)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(bool p0, address p1, bytes32 p2, bytes32 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n // Selector of `log(bool,address,string,string)`.\n mstore(0x00, 0xa73c1db6)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, 0x80)\n mstore(0x80, 0xc0)\n writeString(0xa0, p2)\n writeString(0xe0, p3)\n }\n _sendLogPayload(0x1c, 0x104);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n }\n }\n\n function log(bool p0, bool p1, address p2, address p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(bool,bool,address,address)`.\n mstore(0x00, 0xf4880ea4)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(bool p0, bool p1, address p2, bool p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(bool,bool,address,bool)`.\n mstore(0x00, 0xc0a302d8)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(bool p0, bool p1, address p2, uint256 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(bool,bool,address,uint256)`.\n mstore(0x00, 0x4c123d57)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(bool p0, bool p1, address p2, bytes32 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(bool,bool,address,string)`.\n mstore(0x00, 0xa0a47963)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, 0x80)\n writeString(0xa0, p3)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(bool p0, bool p1, bool p2, address p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(bool,bool,bool,address)`.\n mstore(0x00, 0x8c329b1a)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(bool p0, bool p1, bool p2, bool p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(bool,bool,bool,bool)`.\n mstore(0x00, 0x3b2a5ce0)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(bool p0, bool p1, bool p2, uint256 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(bool,bool,bool,uint256)`.\n mstore(0x00, 0x6d7045c1)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(bool p0, bool p1, bool p2, bytes32 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(bool,bool,bool,string)`.\n mstore(0x00, 0x2ae408d4)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, 0x80)\n writeString(0xa0, p3)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(bool p0, bool p1, uint256 p2, address p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(bool,bool,uint256,address)`.\n mstore(0x00, 0x54a7a9a0)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(bool p0, bool p1, uint256 p2, bool p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(bool,bool,uint256,bool)`.\n mstore(0x00, 0x619e4d0e)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(bool p0, bool p1, uint256 p2, uint256 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(bool,bool,uint256,uint256)`.\n mstore(0x00, 0x0bb00eab)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(bool p0, bool p1, uint256 p2, bytes32 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(bool,bool,uint256,string)`.\n mstore(0x00, 0x7dd4d0e0)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, 0x80)\n writeString(0xa0, p3)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(bool p0, bool p1, bytes32 p2, address p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(bool,bool,string,address)`.\n mstore(0x00, 0xf9ad2b89)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, 0x80)\n mstore(0x80, p3)\n writeString(0xa0, p2)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(bool p0, bool p1, bytes32 p2, bool p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(bool,bool,string,bool)`.\n mstore(0x00, 0xb857163a)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, 0x80)\n mstore(0x80, p3)\n writeString(0xa0, p2)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(bool p0, bool p1, bytes32 p2, uint256 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(bool,bool,string,uint256)`.\n mstore(0x00, 0xe3a9ca2f)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, 0x80)\n mstore(0x80, p3)\n writeString(0xa0, p2)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(bool p0, bool p1, bytes32 p2, bytes32 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n // Selector of `log(bool,bool,string,string)`.\n mstore(0x00, 0x6d1e8751)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, 0x80)\n mstore(0x80, 0xc0)\n writeString(0xa0, p2)\n writeString(0xe0, p3)\n }\n _sendLogPayload(0x1c, 0x104);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n }\n }\n\n function log(bool p0, uint256 p1, address p2, address p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(bool,uint256,address,address)`.\n mstore(0x00, 0x26f560a8)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(bool p0, uint256 p1, address p2, bool p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(bool,uint256,address,bool)`.\n mstore(0x00, 0xb4c314ff)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(bool p0, uint256 p1, address p2, uint256 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(bool,uint256,address,uint256)`.\n mstore(0x00, 0x1537dc87)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(bool p0, uint256 p1, address p2, bytes32 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(bool,uint256,address,string)`.\n mstore(0x00, 0x1bb3b09a)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, 0x80)\n writeString(0xa0, p3)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(bool p0, uint256 p1, bool p2, address p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(bool,uint256,bool,address)`.\n mstore(0x00, 0x9acd3616)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(bool p0, uint256 p1, bool p2, bool p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(bool,uint256,bool,bool)`.\n mstore(0x00, 0xceb5f4d7)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(bool p0, uint256 p1, bool p2, uint256 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(bool,uint256,bool,uint256)`.\n mstore(0x00, 0x7f9bbca2)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(bool p0, uint256 p1, bool p2, bytes32 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(bool,uint256,bool,string)`.\n mstore(0x00, 0x9143dbb1)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, 0x80)\n writeString(0xa0, p3)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(bool p0, uint256 p1, uint256 p2, address p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(bool,uint256,uint256,address)`.\n mstore(0x00, 0x00dd87b9)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(bool p0, uint256 p1, uint256 p2, bool p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(bool,uint256,uint256,bool)`.\n mstore(0x00, 0xbe984353)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(bool p0, uint256 p1, uint256 p2, uint256 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(bool,uint256,uint256,uint256)`.\n mstore(0x00, 0x374bb4b2)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(bool p0, uint256 p1, uint256 p2, bytes32 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(bool,uint256,uint256,string)`.\n mstore(0x00, 0x8e69fb5d)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, 0x80)\n writeString(0xa0, p3)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(bool p0, uint256 p1, bytes32 p2, address p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(bool,uint256,string,address)`.\n mstore(0x00, 0xfedd1fff)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, 0x80)\n mstore(0x80, p3)\n writeString(0xa0, p2)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(bool p0, uint256 p1, bytes32 p2, bool p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(bool,uint256,string,bool)`.\n mstore(0x00, 0xe5e70b2b)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, 0x80)\n mstore(0x80, p3)\n writeString(0xa0, p2)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(bool p0, uint256 p1, bytes32 p2, uint256 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(bool,uint256,string,uint256)`.\n mstore(0x00, 0x6a1199e2)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, 0x80)\n mstore(0x80, p3)\n writeString(0xa0, p2)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(bool p0, uint256 p1, bytes32 p2, bytes32 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n // Selector of `log(bool,uint256,string,string)`.\n mstore(0x00, 0xf5bc2249)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, 0x80)\n mstore(0x80, 0xc0)\n writeString(0xa0, p2)\n writeString(0xe0, p3)\n }\n _sendLogPayload(0x1c, 0x104);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n }\n }\n\n function log(bool p0, bytes32 p1, address p2, address p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(bool,string,address,address)`.\n mstore(0x00, 0x2b2b18dc)\n mstore(0x20, p0)\n mstore(0x40, 0x80)\n mstore(0x60, p2)\n mstore(0x80, p3)\n writeString(0xa0, p1)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(bool p0, bytes32 p1, address p2, bool p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(bool,string,address,bool)`.\n mstore(0x00, 0x6dd434ca)\n mstore(0x20, p0)\n mstore(0x40, 0x80)\n mstore(0x60, p2)\n mstore(0x80, p3)\n writeString(0xa0, p1)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(bool p0, bytes32 p1, address p2, uint256 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(bool,string,address,uint256)`.\n mstore(0x00, 0xa5cada94)\n mstore(0x20, p0)\n mstore(0x40, 0x80)\n mstore(0x60, p2)\n mstore(0x80, p3)\n writeString(0xa0, p1)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(bool p0, bytes32 p1, address p2, bytes32 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n // Selector of `log(bool,string,address,string)`.\n mstore(0x00, 0x12d6c788)\n mstore(0x20, p0)\n mstore(0x40, 0x80)\n mstore(0x60, p2)\n mstore(0x80, 0xc0)\n writeString(0xa0, p1)\n writeString(0xe0, p3)\n }\n _sendLogPayload(0x1c, 0x104);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n }\n }\n\n function log(bool p0, bytes32 p1, bool p2, address p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(bool,string,bool,address)`.\n mstore(0x00, 0x538e06ab)\n mstore(0x20, p0)\n mstore(0x40, 0x80)\n mstore(0x60, p2)\n mstore(0x80, p3)\n writeString(0xa0, p1)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(bool p0, bytes32 p1, bool p2, bool p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(bool,string,bool,bool)`.\n mstore(0x00, 0xdc5e935b)\n mstore(0x20, p0)\n mstore(0x40, 0x80)\n mstore(0x60, p2)\n mstore(0x80, p3)\n writeString(0xa0, p1)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(bool p0, bytes32 p1, bool p2, uint256 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(bool,string,bool,uint256)`.\n mstore(0x00, 0x1606a393)\n mstore(0x20, p0)\n mstore(0x40, 0x80)\n mstore(0x60, p2)\n mstore(0x80, p3)\n writeString(0xa0, p1)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(bool p0, bytes32 p1, bool p2, bytes32 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n // Selector of `log(bool,string,bool,string)`.\n mstore(0x00, 0x483d0416)\n mstore(0x20, p0)\n mstore(0x40, 0x80)\n mstore(0x60, p2)\n mstore(0x80, 0xc0)\n writeString(0xa0, p1)\n writeString(0xe0, p3)\n }\n _sendLogPayload(0x1c, 0x104);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n }\n }\n\n function log(bool p0, bytes32 p1, uint256 p2, address p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(bool,string,uint256,address)`.\n mstore(0x00, 0x1596a1ce)\n mstore(0x20, p0)\n mstore(0x40, 0x80)\n mstore(0x60, p2)\n mstore(0x80, p3)\n writeString(0xa0, p1)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(bool p0, bytes32 p1, uint256 p2, bool p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(bool,string,uint256,bool)`.\n mstore(0x00, 0x6b0e5d53)\n mstore(0x20, p0)\n mstore(0x40, 0x80)\n mstore(0x60, p2)\n mstore(0x80, p3)\n writeString(0xa0, p1)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(bool p0, bytes32 p1, uint256 p2, uint256 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(bool,string,uint256,uint256)`.\n mstore(0x00, 0x28863fcb)\n mstore(0x20, p0)\n mstore(0x40, 0x80)\n mstore(0x60, p2)\n mstore(0x80, p3)\n writeString(0xa0, p1)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(bool p0, bytes32 p1, uint256 p2, bytes32 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n // Selector of `log(bool,string,uint256,string)`.\n mstore(0x00, 0x1ad96de6)\n mstore(0x20, p0)\n mstore(0x40, 0x80)\n mstore(0x60, p2)\n mstore(0x80, 0xc0)\n writeString(0xa0, p1)\n writeString(0xe0, p3)\n }\n _sendLogPayload(0x1c, 0x104);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n }\n }\n\n function log(bool p0, bytes32 p1, bytes32 p2, address p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n // Selector of `log(bool,string,string,address)`.\n mstore(0x00, 0x97d394d8)\n mstore(0x20, p0)\n mstore(0x40, 0x80)\n mstore(0x60, 0xc0)\n mstore(0x80, p3)\n writeString(0xa0, p1)\n writeString(0xe0, p2)\n }\n _sendLogPayload(0x1c, 0x104);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n }\n }\n\n function log(bool p0, bytes32 p1, bytes32 p2, bool p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n // Selector of `log(bool,string,string,bool)`.\n mstore(0x00, 0x1e4b87e5)\n mstore(0x20, p0)\n mstore(0x40, 0x80)\n mstore(0x60, 0xc0)\n mstore(0x80, p3)\n writeString(0xa0, p1)\n writeString(0xe0, p2)\n }\n _sendLogPayload(0x1c, 0x104);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n }\n }\n\n function log(bool p0, bytes32 p1, bytes32 p2, uint256 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n // Selector of `log(bool,string,string,uint256)`.\n mstore(0x00, 0x7be0c3eb)\n mstore(0x20, p0)\n mstore(0x40, 0x80)\n mstore(0x60, 0xc0)\n mstore(0x80, p3)\n writeString(0xa0, p1)\n writeString(0xe0, p2)\n }\n _sendLogPayload(0x1c, 0x104);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n }\n }\n\n function log(bool p0, bytes32 p1, bytes32 p2, bytes32 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n bytes32 m9;\n bytes32 m10;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n m9 := mload(0x120)\n m10 := mload(0x140)\n // Selector of `log(bool,string,string,string)`.\n mstore(0x00, 0x1762e32a)\n mstore(0x20, p0)\n mstore(0x40, 0x80)\n mstore(0x60, 0xc0)\n mstore(0x80, 0x100)\n writeString(0xa0, p1)\n writeString(0xe0, p2)\n writeString(0x120, p3)\n }\n _sendLogPayload(0x1c, 0x144);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n mstore(0x120, m9)\n mstore(0x140, m10)\n }\n }\n\n function log(uint256 p0, address p1, address p2, address p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(uint256,address,address,address)`.\n mstore(0x00, 0x2488b414)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(uint256 p0, address p1, address p2, bool p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(uint256,address,address,bool)`.\n mstore(0x00, 0x091ffaf5)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(uint256 p0, address p1, address p2, uint256 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(uint256,address,address,uint256)`.\n mstore(0x00, 0x736efbb6)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(uint256 p0, address p1, address p2, bytes32 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(uint256,address,address,string)`.\n mstore(0x00, 0x031c6f73)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, 0x80)\n writeString(0xa0, p3)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(uint256 p0, address p1, bool p2, address p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(uint256,address,bool,address)`.\n mstore(0x00, 0xef72c513)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(uint256 p0, address p1, bool p2, bool p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(uint256,address,bool,bool)`.\n mstore(0x00, 0xe351140f)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(uint256 p0, address p1, bool p2, uint256 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(uint256,address,bool,uint256)`.\n mstore(0x00, 0x5abd992a)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(uint256 p0, address p1, bool p2, bytes32 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(uint256,address,bool,string)`.\n mstore(0x00, 0x90fb06aa)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, 0x80)\n writeString(0xa0, p3)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(uint256 p0, address p1, uint256 p2, address p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(uint256,address,uint256,address)`.\n mstore(0x00, 0x15c127b5)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(uint256 p0, address p1, uint256 p2, bool p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(uint256,address,uint256,bool)`.\n mstore(0x00, 0x5f743a7c)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(uint256 p0, address p1, uint256 p2, uint256 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(uint256,address,uint256,uint256)`.\n mstore(0x00, 0x0c9cd9c1)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(uint256 p0, address p1, uint256 p2, bytes32 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(uint256,address,uint256,string)`.\n mstore(0x00, 0xddb06521)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, 0x80)\n writeString(0xa0, p3)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(uint256 p0, address p1, bytes32 p2, address p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(uint256,address,string,address)`.\n mstore(0x00, 0x9cba8fff)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, 0x80)\n mstore(0x80, p3)\n writeString(0xa0, p2)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(uint256 p0, address p1, bytes32 p2, bool p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(uint256,address,string,bool)`.\n mstore(0x00, 0xcc32ab07)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, 0x80)\n mstore(0x80, p3)\n writeString(0xa0, p2)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(uint256 p0, address p1, bytes32 p2, uint256 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(uint256,address,string,uint256)`.\n mstore(0x00, 0x46826b5d)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, 0x80)\n mstore(0x80, p3)\n writeString(0xa0, p2)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(uint256 p0, address p1, bytes32 p2, bytes32 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n // Selector of `log(uint256,address,string,string)`.\n mstore(0x00, 0x3e128ca3)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, 0x80)\n mstore(0x80, 0xc0)\n writeString(0xa0, p2)\n writeString(0xe0, p3)\n }\n _sendLogPayload(0x1c, 0x104);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n }\n }\n\n function log(uint256 p0, bool p1, address p2, address p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(uint256,bool,address,address)`.\n mstore(0x00, 0xa1ef4cbb)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(uint256 p0, bool p1, address p2, bool p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(uint256,bool,address,bool)`.\n mstore(0x00, 0x454d54a5)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(uint256 p0, bool p1, address p2, uint256 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(uint256,bool,address,uint256)`.\n mstore(0x00, 0x078287f5)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(uint256 p0, bool p1, address p2, bytes32 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(uint256,bool,address,string)`.\n mstore(0x00, 0xade052c7)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, 0x80)\n writeString(0xa0, p3)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(uint256 p0, bool p1, bool p2, address p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(uint256,bool,bool,address)`.\n mstore(0x00, 0x69640b59)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(uint256 p0, bool p1, bool p2, bool p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(uint256,bool,bool,bool)`.\n mstore(0x00, 0xb6f577a1)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(uint256 p0, bool p1, bool p2, uint256 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(uint256,bool,bool,uint256)`.\n mstore(0x00, 0x7464ce23)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(uint256 p0, bool p1, bool p2, bytes32 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(uint256,bool,bool,string)`.\n mstore(0x00, 0xdddb9561)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, 0x80)\n writeString(0xa0, p3)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(uint256 p0, bool p1, uint256 p2, address p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(uint256,bool,uint256,address)`.\n mstore(0x00, 0x88cb6041)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(uint256 p0, bool p1, uint256 p2, bool p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(uint256,bool,uint256,bool)`.\n mstore(0x00, 0x91a02e2a)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(uint256 p0, bool p1, uint256 p2, uint256 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(uint256,bool,uint256,uint256)`.\n mstore(0x00, 0xc6acc7a8)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(uint256 p0, bool p1, uint256 p2, bytes32 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(uint256,bool,uint256,string)`.\n mstore(0x00, 0xde03e774)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, 0x80)\n writeString(0xa0, p3)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(uint256 p0, bool p1, bytes32 p2, address p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(uint256,bool,string,address)`.\n mstore(0x00, 0xef529018)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, 0x80)\n mstore(0x80, p3)\n writeString(0xa0, p2)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(uint256 p0, bool p1, bytes32 p2, bool p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(uint256,bool,string,bool)`.\n mstore(0x00, 0xeb928d7f)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, 0x80)\n mstore(0x80, p3)\n writeString(0xa0, p2)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(uint256 p0, bool p1, bytes32 p2, uint256 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(uint256,bool,string,uint256)`.\n mstore(0x00, 0x2c1d0746)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, 0x80)\n mstore(0x80, p3)\n writeString(0xa0, p2)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(uint256 p0, bool p1, bytes32 p2, bytes32 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n // Selector of `log(uint256,bool,string,string)`.\n mstore(0x00, 0x68c8b8bd)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, 0x80)\n mstore(0x80, 0xc0)\n writeString(0xa0, p2)\n writeString(0xe0, p3)\n }\n _sendLogPayload(0x1c, 0x104);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n }\n }\n\n function log(uint256 p0, uint256 p1, address p2, address p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(uint256,uint256,address,address)`.\n mstore(0x00, 0x56a5d1b1)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(uint256 p0, uint256 p1, address p2, bool p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(uint256,uint256,address,bool)`.\n mstore(0x00, 0x15cac476)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(uint256 p0, uint256 p1, address p2, uint256 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(uint256,uint256,address,uint256)`.\n mstore(0x00, 0x88f6e4b2)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(uint256 p0, uint256 p1, address p2, bytes32 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(uint256,uint256,address,string)`.\n mstore(0x00, 0x6cde40b8)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, 0x80)\n writeString(0xa0, p3)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(uint256 p0, uint256 p1, bool p2, address p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(uint256,uint256,bool,address)`.\n mstore(0x00, 0x9a816a83)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(uint256 p0, uint256 p1, bool p2, bool p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(uint256,uint256,bool,bool)`.\n mstore(0x00, 0xab085ae6)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(uint256 p0, uint256 p1, bool p2, uint256 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(uint256,uint256,bool,uint256)`.\n mstore(0x00, 0xeb7f6fd2)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(uint256 p0, uint256 p1, bool p2, bytes32 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(uint256,uint256,bool,string)`.\n mstore(0x00, 0xa5b4fc99)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, 0x80)\n writeString(0xa0, p3)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(uint256 p0, uint256 p1, uint256 p2, address p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(uint256,uint256,uint256,address)`.\n mstore(0x00, 0xfa8185af)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(uint256 p0, uint256 p1, uint256 p2, bool p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(uint256,uint256,uint256,bool)`.\n mstore(0x00, 0xc598d185)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(uint256 p0, uint256 p1, uint256 p2, uint256 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(uint256,uint256,uint256,uint256)`.\n mstore(0x00, 0x193fb800)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(uint256 p0, uint256 p1, uint256 p2, bytes32 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(uint256,uint256,uint256,string)`.\n mstore(0x00, 0x59cfcbe3)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, 0x80)\n writeString(0xa0, p3)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(uint256 p0, uint256 p1, bytes32 p2, address p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(uint256,uint256,string,address)`.\n mstore(0x00, 0x42d21db7)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, 0x80)\n mstore(0x80, p3)\n writeString(0xa0, p2)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(uint256 p0, uint256 p1, bytes32 p2, bool p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(uint256,uint256,string,bool)`.\n mstore(0x00, 0x7af6ab25)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, 0x80)\n mstore(0x80, p3)\n writeString(0xa0, p2)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(uint256 p0, uint256 p1, bytes32 p2, uint256 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(uint256,uint256,string,uint256)`.\n mstore(0x00, 0x5da297eb)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, 0x80)\n mstore(0x80, p3)\n writeString(0xa0, p2)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(uint256 p0, uint256 p1, bytes32 p2, bytes32 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n // Selector of `log(uint256,uint256,string,string)`.\n mstore(0x00, 0x27d8afd2)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, 0x80)\n mstore(0x80, 0xc0)\n writeString(0xa0, p2)\n writeString(0xe0, p3)\n }\n _sendLogPayload(0x1c, 0x104);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n }\n }\n\n function log(uint256 p0, bytes32 p1, address p2, address p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(uint256,string,address,address)`.\n mstore(0x00, 0x6168ed61)\n mstore(0x20, p0)\n mstore(0x40, 0x80)\n mstore(0x60, p2)\n mstore(0x80, p3)\n writeString(0xa0, p1)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(uint256 p0, bytes32 p1, address p2, bool p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(uint256,string,address,bool)`.\n mstore(0x00, 0x90c30a56)\n mstore(0x20, p0)\n mstore(0x40, 0x80)\n mstore(0x60, p2)\n mstore(0x80, p3)\n writeString(0xa0, p1)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(uint256 p0, bytes32 p1, address p2, uint256 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(uint256,string,address,uint256)`.\n mstore(0x00, 0xe8d3018d)\n mstore(0x20, p0)\n mstore(0x40, 0x80)\n mstore(0x60, p2)\n mstore(0x80, p3)\n writeString(0xa0, p1)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(uint256 p0, bytes32 p1, address p2, bytes32 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n // Selector of `log(uint256,string,address,string)`.\n mstore(0x00, 0x9c3adfa1)\n mstore(0x20, p0)\n mstore(0x40, 0x80)\n mstore(0x60, p2)\n mstore(0x80, 0xc0)\n writeString(0xa0, p1)\n writeString(0xe0, p3)\n }\n _sendLogPayload(0x1c, 0x104);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n }\n }\n\n function log(uint256 p0, bytes32 p1, bool p2, address p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(uint256,string,bool,address)`.\n mstore(0x00, 0xae2ec581)\n mstore(0x20, p0)\n mstore(0x40, 0x80)\n mstore(0x60, p2)\n mstore(0x80, p3)\n writeString(0xa0, p1)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(uint256 p0, bytes32 p1, bool p2, bool p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(uint256,string,bool,bool)`.\n mstore(0x00, 0xba535d9c)\n mstore(0x20, p0)\n mstore(0x40, 0x80)\n mstore(0x60, p2)\n mstore(0x80, p3)\n writeString(0xa0, p1)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(uint256 p0, bytes32 p1, bool p2, uint256 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(uint256,string,bool,uint256)`.\n mstore(0x00, 0xcf009880)\n mstore(0x20, p0)\n mstore(0x40, 0x80)\n mstore(0x60, p2)\n mstore(0x80, p3)\n writeString(0xa0, p1)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(uint256 p0, bytes32 p1, bool p2, bytes32 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n // Selector of `log(uint256,string,bool,string)`.\n mstore(0x00, 0xd2d423cd)\n mstore(0x20, p0)\n mstore(0x40, 0x80)\n mstore(0x60, p2)\n mstore(0x80, 0xc0)\n writeString(0xa0, p1)\n writeString(0xe0, p3)\n }\n _sendLogPayload(0x1c, 0x104);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n }\n }\n\n function log(uint256 p0, bytes32 p1, uint256 p2, address p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(uint256,string,uint256,address)`.\n mstore(0x00, 0x3b2279b4)\n mstore(0x20, p0)\n mstore(0x40, 0x80)\n mstore(0x60, p2)\n mstore(0x80, p3)\n writeString(0xa0, p1)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(uint256 p0, bytes32 p1, uint256 p2, bool p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(uint256,string,uint256,bool)`.\n mstore(0x00, 0x691a8f74)\n mstore(0x20, p0)\n mstore(0x40, 0x80)\n mstore(0x60, p2)\n mstore(0x80, p3)\n writeString(0xa0, p1)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(uint256 p0, bytes32 p1, uint256 p2, uint256 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(uint256,string,uint256,uint256)`.\n mstore(0x00, 0x82c25b74)\n mstore(0x20, p0)\n mstore(0x40, 0x80)\n mstore(0x60, p2)\n mstore(0x80, p3)\n writeString(0xa0, p1)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(uint256 p0, bytes32 p1, uint256 p2, bytes32 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n // Selector of `log(uint256,string,uint256,string)`.\n mstore(0x00, 0xb7b914ca)\n mstore(0x20, p0)\n mstore(0x40, 0x80)\n mstore(0x60, p2)\n mstore(0x80, 0xc0)\n writeString(0xa0, p1)\n writeString(0xe0, p3)\n }\n _sendLogPayload(0x1c, 0x104);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n }\n }\n\n function log(uint256 p0, bytes32 p1, bytes32 p2, address p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n // Selector of `log(uint256,string,string,address)`.\n mstore(0x00, 0xd583c602)\n mstore(0x20, p0)\n mstore(0x40, 0x80)\n mstore(0x60, 0xc0)\n mstore(0x80, p3)\n writeString(0xa0, p1)\n writeString(0xe0, p2)\n }\n _sendLogPayload(0x1c, 0x104);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n }\n }\n\n function log(uint256 p0, bytes32 p1, bytes32 p2, bool p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n // Selector of `log(uint256,string,string,bool)`.\n mstore(0x00, 0xb3a6b6bd)\n mstore(0x20, p0)\n mstore(0x40, 0x80)\n mstore(0x60, 0xc0)\n mstore(0x80, p3)\n writeString(0xa0, p1)\n writeString(0xe0, p2)\n }\n _sendLogPayload(0x1c, 0x104);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n }\n }\n\n function log(uint256 p0, bytes32 p1, bytes32 p2, uint256 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n // Selector of `log(uint256,string,string,uint256)`.\n mstore(0x00, 0xb028c9bd)\n mstore(0x20, p0)\n mstore(0x40, 0x80)\n mstore(0x60, 0xc0)\n mstore(0x80, p3)\n writeString(0xa0, p1)\n writeString(0xe0, p2)\n }\n _sendLogPayload(0x1c, 0x104);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n }\n }\n\n function log(uint256 p0, bytes32 p1, bytes32 p2, bytes32 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n bytes32 m9;\n bytes32 m10;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n m9 := mload(0x120)\n m10 := mload(0x140)\n // Selector of `log(uint256,string,string,string)`.\n mstore(0x00, 0x21ad0683)\n mstore(0x20, p0)\n mstore(0x40, 0x80)\n mstore(0x60, 0xc0)\n mstore(0x80, 0x100)\n writeString(0xa0, p1)\n writeString(0xe0, p2)\n writeString(0x120, p3)\n }\n _sendLogPayload(0x1c, 0x144);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n mstore(0x120, m9)\n mstore(0x140, m10)\n }\n }\n\n function log(bytes32 p0, address p1, address p2, address p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(string,address,address,address)`.\n mstore(0x00, 0xed8f28f6)\n mstore(0x20, 0x80)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n writeString(0xa0, p0)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(bytes32 p0, address p1, address p2, bool p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(string,address,address,bool)`.\n mstore(0x00, 0xb59dbd60)\n mstore(0x20, 0x80)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n writeString(0xa0, p0)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(bytes32 p0, address p1, address p2, uint256 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(string,address,address,uint256)`.\n mstore(0x00, 0x8ef3f399)\n mstore(0x20, 0x80)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n writeString(0xa0, p0)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(bytes32 p0, address p1, address p2, bytes32 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n // Selector of `log(string,address,address,string)`.\n mstore(0x00, 0x800a1c67)\n mstore(0x20, 0x80)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, 0xc0)\n writeString(0xa0, p0)\n writeString(0xe0, p3)\n }\n _sendLogPayload(0x1c, 0x104);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n }\n }\n\n function log(bytes32 p0, address p1, bool p2, address p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(string,address,bool,address)`.\n mstore(0x00, 0x223603bd)\n mstore(0x20, 0x80)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n writeString(0xa0, p0)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(bytes32 p0, address p1, bool p2, bool p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(string,address,bool,bool)`.\n mstore(0x00, 0x79884c2b)\n mstore(0x20, 0x80)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n writeString(0xa0, p0)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(bytes32 p0, address p1, bool p2, uint256 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(string,address,bool,uint256)`.\n mstore(0x00, 0x3e9f866a)\n mstore(0x20, 0x80)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n writeString(0xa0, p0)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(bytes32 p0, address p1, bool p2, bytes32 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n // Selector of `log(string,address,bool,string)`.\n mstore(0x00, 0x0454c079)\n mstore(0x20, 0x80)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, 0xc0)\n writeString(0xa0, p0)\n writeString(0xe0, p3)\n }\n _sendLogPayload(0x1c, 0x104);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n }\n }\n\n function log(bytes32 p0, address p1, uint256 p2, address p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(string,address,uint256,address)`.\n mstore(0x00, 0x63fb8bc5)\n mstore(0x20, 0x80)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n writeString(0xa0, p0)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(bytes32 p0, address p1, uint256 p2, bool p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(string,address,uint256,bool)`.\n mstore(0x00, 0xfc4845f0)\n mstore(0x20, 0x80)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n writeString(0xa0, p0)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(bytes32 p0, address p1, uint256 p2, uint256 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(string,address,uint256,uint256)`.\n mstore(0x00, 0xf8f51b1e)\n mstore(0x20, 0x80)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n writeString(0xa0, p0)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(bytes32 p0, address p1, uint256 p2, bytes32 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n // Selector of `log(string,address,uint256,string)`.\n mstore(0x00, 0x5a477632)\n mstore(0x20, 0x80)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, 0xc0)\n writeString(0xa0, p0)\n writeString(0xe0, p3)\n }\n _sendLogPayload(0x1c, 0x104);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n }\n }\n\n function log(bytes32 p0, address p1, bytes32 p2, address p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n // Selector of `log(string,address,string,address)`.\n mstore(0x00, 0xaabc9a31)\n mstore(0x20, 0x80)\n mstore(0x40, p1)\n mstore(0x60, 0xc0)\n mstore(0x80, p3)\n writeString(0xa0, p0)\n writeString(0xe0, p2)\n }\n _sendLogPayload(0x1c, 0x104);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n }\n }\n\n function log(bytes32 p0, address p1, bytes32 p2, bool p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n // Selector of `log(string,address,string,bool)`.\n mstore(0x00, 0x5f15d28c)\n mstore(0x20, 0x80)\n mstore(0x40, p1)\n mstore(0x60, 0xc0)\n mstore(0x80, p3)\n writeString(0xa0, p0)\n writeString(0xe0, p2)\n }\n _sendLogPayload(0x1c, 0x104);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n }\n }\n\n function log(bytes32 p0, address p1, bytes32 p2, uint256 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n // Selector of `log(string,address,string,uint256)`.\n mstore(0x00, 0x91d1112e)\n mstore(0x20, 0x80)\n mstore(0x40, p1)\n mstore(0x60, 0xc0)\n mstore(0x80, p3)\n writeString(0xa0, p0)\n writeString(0xe0, p2)\n }\n _sendLogPayload(0x1c, 0x104);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n }\n }\n\n function log(bytes32 p0, address p1, bytes32 p2, bytes32 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n bytes32 m9;\n bytes32 m10;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n m9 := mload(0x120)\n m10 := mload(0x140)\n // Selector of `log(string,address,string,string)`.\n mstore(0x00, 0x245986f2)\n mstore(0x20, 0x80)\n mstore(0x40, p1)\n mstore(0x60, 0xc0)\n mstore(0x80, 0x100)\n writeString(0xa0, p0)\n writeString(0xe0, p2)\n writeString(0x120, p3)\n }\n _sendLogPayload(0x1c, 0x144);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n mstore(0x120, m9)\n mstore(0x140, m10)\n }\n }\n\n function log(bytes32 p0, bool p1, address p2, address p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(string,bool,address,address)`.\n mstore(0x00, 0x33e9dd1d)\n mstore(0x20, 0x80)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n writeString(0xa0, p0)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(bytes32 p0, bool p1, address p2, bool p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(string,bool,address,bool)`.\n mstore(0x00, 0x958c28c6)\n mstore(0x20, 0x80)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n writeString(0xa0, p0)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(bytes32 p0, bool p1, address p2, uint256 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(string,bool,address,uint256)`.\n mstore(0x00, 0x5d08bb05)\n mstore(0x20, 0x80)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n writeString(0xa0, p0)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(bytes32 p0, bool p1, address p2, bytes32 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n // Selector of `log(string,bool,address,string)`.\n mstore(0x00, 0x2d8e33a4)\n mstore(0x20, 0x80)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, 0xc0)\n writeString(0xa0, p0)\n writeString(0xe0, p3)\n }\n _sendLogPayload(0x1c, 0x104);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n }\n }\n\n function log(bytes32 p0, bool p1, bool p2, address p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(string,bool,bool,address)`.\n mstore(0x00, 0x7190a529)\n mstore(0x20, 0x80)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n writeString(0xa0, p0)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(bytes32 p0, bool p1, bool p2, bool p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(string,bool,bool,bool)`.\n mstore(0x00, 0x895af8c5)\n mstore(0x20, 0x80)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n writeString(0xa0, p0)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(bytes32 p0, bool p1, bool p2, uint256 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(string,bool,bool,uint256)`.\n mstore(0x00, 0x8e3f78a9)\n mstore(0x20, 0x80)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n writeString(0xa0, p0)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(bytes32 p0, bool p1, bool p2, bytes32 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n // Selector of `log(string,bool,bool,string)`.\n mstore(0x00, 0x9d22d5dd)\n mstore(0x20, 0x80)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, 0xc0)\n writeString(0xa0, p0)\n writeString(0xe0, p3)\n }\n _sendLogPayload(0x1c, 0x104);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n }\n }\n\n function log(bytes32 p0, bool p1, uint256 p2, address p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(string,bool,uint256,address)`.\n mstore(0x00, 0x935e09bf)\n mstore(0x20, 0x80)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n writeString(0xa0, p0)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(bytes32 p0, bool p1, uint256 p2, bool p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(string,bool,uint256,bool)`.\n mstore(0x00, 0x8af7cf8a)\n mstore(0x20, 0x80)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n writeString(0xa0, p0)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(bytes32 p0, bool p1, uint256 p2, uint256 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(string,bool,uint256,uint256)`.\n mstore(0x00, 0x64b5bb67)\n mstore(0x20, 0x80)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n writeString(0xa0, p0)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(bytes32 p0, bool p1, uint256 p2, bytes32 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n // Selector of `log(string,bool,uint256,string)`.\n mstore(0x00, 0x742d6ee7)\n mstore(0x20, 0x80)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, 0xc0)\n writeString(0xa0, p0)\n writeString(0xe0, p3)\n }\n _sendLogPayload(0x1c, 0x104);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n }\n }\n\n function log(bytes32 p0, bool p1, bytes32 p2, address p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n // Selector of `log(string,bool,string,address)`.\n mstore(0x00, 0xe0625b29)\n mstore(0x20, 0x80)\n mstore(0x40, p1)\n mstore(0x60, 0xc0)\n mstore(0x80, p3)\n writeString(0xa0, p0)\n writeString(0xe0, p2)\n }\n _sendLogPayload(0x1c, 0x104);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n }\n }\n\n function log(bytes32 p0, bool p1, bytes32 p2, bool p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n // Selector of `log(string,bool,string,bool)`.\n mstore(0x00, 0x3f8a701d)\n mstore(0x20, 0x80)\n mstore(0x40, p1)\n mstore(0x60, 0xc0)\n mstore(0x80, p3)\n writeString(0xa0, p0)\n writeString(0xe0, p2)\n }\n _sendLogPayload(0x1c, 0x104);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n }\n }\n\n function log(bytes32 p0, bool p1, bytes32 p2, uint256 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n // Selector of `log(string,bool,string,uint256)`.\n mstore(0x00, 0x24f91465)\n mstore(0x20, 0x80)\n mstore(0x40, p1)\n mstore(0x60, 0xc0)\n mstore(0x80, p3)\n writeString(0xa0, p0)\n writeString(0xe0, p2)\n }\n _sendLogPayload(0x1c, 0x104);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n }\n }\n\n function log(bytes32 p0, bool p1, bytes32 p2, bytes32 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n bytes32 m9;\n bytes32 m10;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n m9 := mload(0x120)\n m10 := mload(0x140)\n // Selector of `log(string,bool,string,string)`.\n mstore(0x00, 0xa826caeb)\n mstore(0x20, 0x80)\n mstore(0x40, p1)\n mstore(0x60, 0xc0)\n mstore(0x80, 0x100)\n writeString(0xa0, p0)\n writeString(0xe0, p2)\n writeString(0x120, p3)\n }\n _sendLogPayload(0x1c, 0x144);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n mstore(0x120, m9)\n mstore(0x140, m10)\n }\n }\n\n function log(bytes32 p0, uint256 p1, address p2, address p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(string,uint256,address,address)`.\n mstore(0x00, 0x5ea2b7ae)\n mstore(0x20, 0x80)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n writeString(0xa0, p0)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(bytes32 p0, uint256 p1, address p2, bool p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(string,uint256,address,bool)`.\n mstore(0x00, 0x82112a42)\n mstore(0x20, 0x80)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n writeString(0xa0, p0)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(bytes32 p0, uint256 p1, address p2, uint256 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(string,uint256,address,uint256)`.\n mstore(0x00, 0x4f04fdc6)\n mstore(0x20, 0x80)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n writeString(0xa0, p0)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(bytes32 p0, uint256 p1, address p2, bytes32 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n // Selector of `log(string,uint256,address,string)`.\n mstore(0x00, 0x9ffb2f93)\n mstore(0x20, 0x80)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, 0xc0)\n writeString(0xa0, p0)\n writeString(0xe0, p3)\n }\n _sendLogPayload(0x1c, 0x104);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n }\n }\n\n function log(bytes32 p0, uint256 p1, bool p2, address p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(string,uint256,bool,address)`.\n mstore(0x00, 0xe0e95b98)\n mstore(0x20, 0x80)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n writeString(0xa0, p0)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(bytes32 p0, uint256 p1, bool p2, bool p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(string,uint256,bool,bool)`.\n mstore(0x00, 0x354c36d6)\n mstore(0x20, 0x80)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n writeString(0xa0, p0)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(bytes32 p0, uint256 p1, bool p2, uint256 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(string,uint256,bool,uint256)`.\n mstore(0x00, 0xe41b6f6f)\n mstore(0x20, 0x80)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n writeString(0xa0, p0)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(bytes32 p0, uint256 p1, bool p2, bytes32 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n // Selector of `log(string,uint256,bool,string)`.\n mstore(0x00, 0xabf73a98)\n mstore(0x20, 0x80)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, 0xc0)\n writeString(0xa0, p0)\n writeString(0xe0, p3)\n }\n _sendLogPayload(0x1c, 0x104);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n }\n }\n\n function log(bytes32 p0, uint256 p1, uint256 p2, address p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(string,uint256,uint256,address)`.\n mstore(0x00, 0xe21de278)\n mstore(0x20, 0x80)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n writeString(0xa0, p0)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(bytes32 p0, uint256 p1, uint256 p2, bool p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(string,uint256,uint256,bool)`.\n mstore(0x00, 0x7626db92)\n mstore(0x20, 0x80)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n writeString(0xa0, p0)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(bytes32 p0, uint256 p1, uint256 p2, uint256 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(string,uint256,uint256,uint256)`.\n mstore(0x00, 0xa7a87853)\n mstore(0x20, 0x80)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n writeString(0xa0, p0)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(bytes32 p0, uint256 p1, uint256 p2, bytes32 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n // Selector of `log(string,uint256,uint256,string)`.\n mstore(0x00, 0x854b3496)\n mstore(0x20, 0x80)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, 0xc0)\n writeString(0xa0, p0)\n writeString(0xe0, p3)\n }\n _sendLogPayload(0x1c, 0x104);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n }\n }\n\n function log(bytes32 p0, uint256 p1, bytes32 p2, address p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n // Selector of `log(string,uint256,string,address)`.\n mstore(0x00, 0x7c4632a4)\n mstore(0x20, 0x80)\n mstore(0x40, p1)\n mstore(0x60, 0xc0)\n mstore(0x80, p3)\n writeString(0xa0, p0)\n writeString(0xe0, p2)\n }\n _sendLogPayload(0x1c, 0x104);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n }\n }\n\n function log(bytes32 p0, uint256 p1, bytes32 p2, bool p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n // Selector of `log(string,uint256,string,bool)`.\n mstore(0x00, 0x7d24491d)\n mstore(0x20, 0x80)\n mstore(0x40, p1)\n mstore(0x60, 0xc0)\n mstore(0x80, p3)\n writeString(0xa0, p0)\n writeString(0xe0, p2)\n }\n _sendLogPayload(0x1c, 0x104);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n }\n }\n\n function log(bytes32 p0, uint256 p1, bytes32 p2, uint256 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n // Selector of `log(string,uint256,string,uint256)`.\n mstore(0x00, 0xc67ea9d1)\n mstore(0x20, 0x80)\n mstore(0x40, p1)\n mstore(0x60, 0xc0)\n mstore(0x80, p3)\n writeString(0xa0, p0)\n writeString(0xe0, p2)\n }\n _sendLogPayload(0x1c, 0x104);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n }\n }\n\n function log(bytes32 p0, uint256 p1, bytes32 p2, bytes32 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n bytes32 m9;\n bytes32 m10;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n m9 := mload(0x120)\n m10 := mload(0x140)\n // Selector of `log(string,uint256,string,string)`.\n mstore(0x00, 0x5ab84e1f)\n mstore(0x20, 0x80)\n mstore(0x40, p1)\n mstore(0x60, 0xc0)\n mstore(0x80, 0x100)\n writeString(0xa0, p0)\n writeString(0xe0, p2)\n writeString(0x120, p3)\n }\n _sendLogPayload(0x1c, 0x144);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n mstore(0x120, m9)\n mstore(0x140, m10)\n }\n }\n\n function log(bytes32 p0, bytes32 p1, address p2, address p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n // Selector of `log(string,string,address,address)`.\n mstore(0x00, 0x439c7bef)\n mstore(0x20, 0x80)\n mstore(0x40, 0xc0)\n mstore(0x60, p2)\n mstore(0x80, p3)\n writeString(0xa0, p0)\n writeString(0xe0, p1)\n }\n _sendLogPayload(0x1c, 0x104);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n }\n }\n\n function log(bytes32 p0, bytes32 p1, address p2, bool p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n // Selector of `log(string,string,address,bool)`.\n mstore(0x00, 0x5ccd4e37)\n mstore(0x20, 0x80)\n mstore(0x40, 0xc0)\n mstore(0x60, p2)\n mstore(0x80, p3)\n writeString(0xa0, p0)\n writeString(0xe0, p1)\n }\n _sendLogPayload(0x1c, 0x104);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n }\n }\n\n function log(bytes32 p0, bytes32 p1, address p2, uint256 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n // Selector of `log(string,string,address,uint256)`.\n mstore(0x00, 0x7cc3c607)\n mstore(0x20, 0x80)\n mstore(0x40, 0xc0)\n mstore(0x60, p2)\n mstore(0x80, p3)\n writeString(0xa0, p0)\n writeString(0xe0, p1)\n }\n _sendLogPayload(0x1c, 0x104);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n }\n }\n\n function log(bytes32 p0, bytes32 p1, address p2, bytes32 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n bytes32 m9;\n bytes32 m10;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n m9 := mload(0x120)\n m10 := mload(0x140)\n // Selector of `log(string,string,address,string)`.\n mstore(0x00, 0xeb1bff80)\n mstore(0x20, 0x80)\n mstore(0x40, 0xc0)\n mstore(0x60, p2)\n mstore(0x80, 0x100)\n writeString(0xa0, p0)\n writeString(0xe0, p1)\n writeString(0x120, p3)\n }\n _sendLogPayload(0x1c, 0x144);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n mstore(0x120, m9)\n mstore(0x140, m10)\n }\n }\n\n function log(bytes32 p0, bytes32 p1, bool p2, address p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n // Selector of `log(string,string,bool,address)`.\n mstore(0x00, 0xc371c7db)\n mstore(0x20, 0x80)\n mstore(0x40, 0xc0)\n mstore(0x60, p2)\n mstore(0x80, p3)\n writeString(0xa0, p0)\n writeString(0xe0, p1)\n }\n _sendLogPayload(0x1c, 0x104);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n }\n }\n\n function log(bytes32 p0, bytes32 p1, bool p2, bool p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n // Selector of `log(string,string,bool,bool)`.\n mstore(0x00, 0x40785869)\n mstore(0x20, 0x80)\n mstore(0x40, 0xc0)\n mstore(0x60, p2)\n mstore(0x80, p3)\n writeString(0xa0, p0)\n writeString(0xe0, p1)\n }\n _sendLogPayload(0x1c, 0x104);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n }\n }\n\n function log(bytes32 p0, bytes32 p1, bool p2, uint256 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n // Selector of `log(string,string,bool,uint256)`.\n mstore(0x00, 0xd6aefad2)\n mstore(0x20, 0x80)\n mstore(0x40, 0xc0)\n mstore(0x60, p2)\n mstore(0x80, p3)\n writeString(0xa0, p0)\n writeString(0xe0, p1)\n }\n _sendLogPayload(0x1c, 0x104);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n }\n }\n\n function log(bytes32 p0, bytes32 p1, bool p2, bytes32 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n bytes32 m9;\n bytes32 m10;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n m9 := mload(0x120)\n m10 := mload(0x140)\n // Selector of `log(string,string,bool,string)`.\n mstore(0x00, 0x5e84b0ea)\n mstore(0x20, 0x80)\n mstore(0x40, 0xc0)\n mstore(0x60, p2)\n mstore(0x80, 0x100)\n writeString(0xa0, p0)\n writeString(0xe0, p1)\n writeString(0x120, p3)\n }\n _sendLogPayload(0x1c, 0x144);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n mstore(0x120, m9)\n mstore(0x140, m10)\n }\n }\n\n function log(bytes32 p0, bytes32 p1, uint256 p2, address p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n // Selector of `log(string,string,uint256,address)`.\n mstore(0x00, 0x1023f7b2)\n mstore(0x20, 0x80)\n mstore(0x40, 0xc0)\n mstore(0x60, p2)\n mstore(0x80, p3)\n writeString(0xa0, p0)\n writeString(0xe0, p1)\n }\n _sendLogPayload(0x1c, 0x104);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n }\n }\n\n function log(bytes32 p0, bytes32 p1, uint256 p2, bool p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n // Selector of `log(string,string,uint256,bool)`.\n mstore(0x00, 0xc3a8a654)\n mstore(0x20, 0x80)\n mstore(0x40, 0xc0)\n mstore(0x60, p2)\n mstore(0x80, p3)\n writeString(0xa0, p0)\n writeString(0xe0, p1)\n }\n _sendLogPayload(0x1c, 0x104);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n }\n }\n\n function log(bytes32 p0, bytes32 p1, uint256 p2, uint256 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n // Selector of `log(string,string,uint256,uint256)`.\n mstore(0x00, 0xf45d7d2c)\n mstore(0x20, 0x80)\n mstore(0x40, 0xc0)\n mstore(0x60, p2)\n mstore(0x80, p3)\n writeString(0xa0, p0)\n writeString(0xe0, p1)\n }\n _sendLogPayload(0x1c, 0x104);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n }\n }\n\n function log(bytes32 p0, bytes32 p1, uint256 p2, bytes32 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n bytes32 m9;\n bytes32 m10;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n m9 := mload(0x120)\n m10 := mload(0x140)\n // Selector of `log(string,string,uint256,string)`.\n mstore(0x00, 0x5d1a971a)\n mstore(0x20, 0x80)\n mstore(0x40, 0xc0)\n mstore(0x60, p2)\n mstore(0x80, 0x100)\n writeString(0xa0, p0)\n writeString(0xe0, p1)\n writeString(0x120, p3)\n }\n _sendLogPayload(0x1c, 0x144);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n mstore(0x120, m9)\n mstore(0x140, m10)\n }\n }\n\n function log(bytes32 p0, bytes32 p1, bytes32 p2, address p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n bytes32 m9;\n bytes32 m10;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n m9 := mload(0x120)\n m10 := mload(0x140)\n // Selector of `log(string,string,string,address)`.\n mstore(0x00, 0x6d572f44)\n mstore(0x20, 0x80)\n mstore(0x40, 0xc0)\n mstore(0x60, 0x100)\n mstore(0x80, p3)\n writeString(0xa0, p0)\n writeString(0xe0, p1)\n writeString(0x120, p2)\n }\n _sendLogPayload(0x1c, 0x144);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n mstore(0x120, m9)\n mstore(0x140, m10)\n }\n }\n\n function log(bytes32 p0, bytes32 p1, bytes32 p2, bool p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n bytes32 m9;\n bytes32 m10;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n m9 := mload(0x120)\n m10 := mload(0x140)\n // Selector of `log(string,string,string,bool)`.\n mstore(0x00, 0x2c1754ed)\n mstore(0x20, 0x80)\n mstore(0x40, 0xc0)\n mstore(0x60, 0x100)\n mstore(0x80, p3)\n writeString(0xa0, p0)\n writeString(0xe0, p1)\n writeString(0x120, p2)\n }\n _sendLogPayload(0x1c, 0x144);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n mstore(0x120, m9)\n mstore(0x140, m10)\n }\n }\n\n function log(bytes32 p0, bytes32 p1, bytes32 p2, uint256 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n bytes32 m9;\n bytes32 m10;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n m9 := mload(0x120)\n m10 := mload(0x140)\n // Selector of `log(string,string,string,uint256)`.\n mstore(0x00, 0x8eafb02b)\n mstore(0x20, 0x80)\n mstore(0x40, 0xc0)\n mstore(0x60, 0x100)\n mstore(0x80, p3)\n writeString(0xa0, p0)\n writeString(0xe0, p1)\n writeString(0x120, p2)\n }\n _sendLogPayload(0x1c, 0x144);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n mstore(0x120, m9)\n mstore(0x140, m10)\n }\n }\n\n function log(bytes32 p0, bytes32 p1, bytes32 p2, bytes32 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n bytes32 m9;\n bytes32 m10;\n bytes32 m11;\n bytes32 m12;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n m9 := mload(0x120)\n m10 := mload(0x140)\n m11 := mload(0x160)\n m12 := mload(0x180)\n // Selector of `log(string,string,string,string)`.\n mstore(0x00, 0xde68f20a)\n mstore(0x20, 0x80)\n mstore(0x40, 0xc0)\n mstore(0x60, 0x100)\n mstore(0x80, 0x140)\n writeString(0xa0, p0)\n writeString(0xe0, p1)\n writeString(0x120, p2)\n writeString(0x160, p3)\n }\n _sendLogPayload(0x1c, 0x184);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n mstore(0x120, m9)\n mstore(0x140, m10)\n mstore(0x160, m11)\n mstore(0x180, m12)\n }\n }\n}\n","license":"MIT"},"scripts/FetchChainInfo.s.sol":{"keccak256":"0xb90e4f9a834c4dc584b4ad8c0503e35fdd8338533e0e75a7ca497f655ae12821","urls":[],"content":"// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\nimport { Script } from \"forge-std/Script.sol\";\nimport { GameTypes, GameType } from \"src/dispute/lib/Types.sol\";\n\n/// @notice Contains getters for arbitrary methods from all L1 contracts, including legacy getters\n/// that have since been deprecated.\ninterface IFetcher {\n function guardian() external view returns (address);\n function GUARDIAN() external view returns (address);\n function systemConfig() external view returns (address);\n function SYSTEM_CONFIG() external view returns (address);\n function disputeGameFactory() external view returns (address);\n function ethLockbox() external view returns (address);\n function superchainConfig() external view returns (address);\n function messenger() external view returns (address);\n function addressManager() external view returns (address);\n function PORTAL() external view returns (address);\n function portal() external view returns (address);\n function l1ERC721Bridge() external view returns (address);\n function optimismMintableERC20Factory() external view returns (address);\n function gameImpls(GameType _gameType) external view returns (address);\n function respectedGameType() external view returns (GameType);\n function anchorStateRegistry() external view returns (address);\n function L2_ORACLE() external view returns (address);\n function l2Oracle() external view returns (address);\n function vm() external view returns (address);\n function oracle() external view returns (address);\n function challenger() external view returns (address);\n function proposer() external view returns (address);\n function PROPOSER() external view returns (address);\n function batcherHash() external view returns (bytes32);\n function admin() external view returns (address);\n function owner() external view returns (address);\n function unsafeBlockSigner() external view returns (address);\n function weth() external view returns (address);\n}\n\ncontract FetchChainInfoInput {\n address internal _systemConfigProxy;\n address internal _l1StandardBridgeProxy;\n\n function set(bytes4 _sel, address _addr) public {\n require(_addr != address(0), \"FetchChainInfoInput: cannot set zero address\");\n if (_sel == this.systemConfigProxy.selector) _systemConfigProxy = _addr;\n else if (_sel == this.l1StandardBridgeProxy.selector) _l1StandardBridgeProxy = _addr;\n else revert(\"FetchChainInfoInput: unknown selector\");\n }\n\n function systemConfigProxy() public view returns (address) {\n require(_systemConfigProxy != address(0), \"FetchChainInfoInput: systemConfigProxy not set\");\n return _systemConfigProxy;\n }\n\n function l1StandardBridgeProxy() public view returns (address) {\n require(_l1StandardBridgeProxy != address(0), \"FetchChainInfoInput: l1StandardBridgeProxy not set\");\n return _l1StandardBridgeProxy;\n }\n}\n\ncontract FetchChainInfoOutput {\n // contract addresses\n // - SuperchainContracts\n address internal _superchainConfigProxy;\n // - ImplementationsContracts\n address internal _mipsImpl;\n address internal _preimageOracleImpl;\n // - OpChainContracts\n address internal _addressManagerImpl;\n address internal _ethLockboxProxy;\n address internal _l1CrossDomainMessengerProxy;\n address internal _l1Erc721BridgeProxy;\n address internal _l1StandardBridgeProxy;\n address internal _l2OutputOracleProxy;\n address internal _optimismMintableErc20FactoryProxy;\n address internal _optimismPortalProxy;\n address internal _systemConfigProxy;\n address internal _opChainProxyAdminImpl;\n address internal _anchorStateRegistryProxy;\n address internal _delayedWethPermissionedGameProxy;\n address internal _delayedWethPermissionlessGameProxy;\n address internal _disputeGameFactoryProxy;\n address internal _faultDisputeGameImpl;\n address internal _faultDisputeGameCannonKonaImpl;\n address internal _permissionedDisputeGameImpl;\n\n // roles\n address internal _systemConfigOwner;\n address internal _opChainProxyAdminOwner;\n address internal _opChainGuardian;\n address internal _challenger;\n address internal _proposer;\n address internal _unsafeBlockSigner;\n address internal _batchSubmitter;\n\n // fault proof status\n bool internal _permissioned;\n bool internal _permissionless;\n GameType internal _respectedGameType;\n\n function set(bytes4 _sel, address _addr) public {\n // SuperchainContracts\n if (_sel == this.superchainConfigProxy.selector) _superchainConfigProxy = _addr;\n // - ImplementationsContracts\n else if (_sel == this.mipsImpl.selector) _mipsImpl = _addr;\n else if (_sel == this.preimageOracleImpl.selector) _preimageOracleImpl = _addr;\n // - OpChainContracts\n else if (_sel == this.addressManagerImpl.selector) _addressManagerImpl = _addr;\n else if (_sel == this.ethLockboxProxy.selector) _ethLockboxProxy = _addr;\n else if (_sel == this.l1CrossDomainMessengerProxy.selector) _l1CrossDomainMessengerProxy = _addr;\n else if (_sel == this.l1Erc721BridgeProxy.selector) _l1Erc721BridgeProxy = _addr;\n else if (_sel == this.l1StandardBridgeProxy.selector) _l1StandardBridgeProxy = _addr;\n else if (_sel == this.l2OutputOracleProxy.selector) _l2OutputOracleProxy = _addr;\n else if (_sel == this.optimismMintableErc20FactoryProxy.selector) _optimismMintableErc20FactoryProxy = _addr;\n else if (_sel == this.optimismPortalProxy.selector) _optimismPortalProxy = _addr;\n else if (_sel == this.systemConfigProxy.selector) _systemConfigProxy = _addr;\n else if (_sel == this.opChainProxyAdminImpl.selector) _opChainProxyAdminImpl = _addr;\n else if (_sel == this.anchorStateRegistryProxy.selector) _anchorStateRegistryProxy = _addr;\n else if (_sel == this.delayedWethPermissionedGameProxy.selector) _delayedWethPermissionedGameProxy = _addr;\n else if (_sel == this.delayedWethPermissionlessGameProxy.selector) _delayedWethPermissionlessGameProxy = _addr;\n else if (_sel == this.disputeGameFactoryProxy.selector) _disputeGameFactoryProxy = _addr;\n else if (_sel == this.faultDisputeGameImpl.selector) _faultDisputeGameImpl = _addr;\n else if (_sel == this.faultDisputeGameCannonKonaImpl.selector) _faultDisputeGameCannonKonaImpl = _addr;\n else if (_sel == this.permissionedDisputeGameImpl.selector) _permissionedDisputeGameImpl = _addr;\n // roles\n else if (_sel == this.systemConfigOwner.selector) _systemConfigOwner = _addr;\n else if (_sel == this.opChainProxyAdminOwner.selector) _opChainProxyAdminOwner = _addr;\n else if (_sel == this.opChainGuardian.selector) _opChainGuardian = _addr;\n else if (_sel == this.challenger.selector) _challenger = _addr;\n else if (_sel == this.proposer.selector) _proposer = _addr;\n else if (_sel == this.unsafeBlockSigner.selector) _unsafeBlockSigner = _addr;\n else if (_sel == this.batchSubmitter.selector) _batchSubmitter = _addr;\n else revert(\"FetchChainInfoOutput: unknown address selector test\");\n }\n\n function set(bytes4 _sel, bool _bool) public {\n if (_sel == this.permissioned.selector) _permissioned = _bool;\n else if (_sel == this.permissionless.selector) _permissionless = _bool;\n else revert(\"FetchChainInfoOutput: unknown bool selector\");\n }\n\n function set(bytes4 _sel, GameType _gameType) public {\n if (_sel == this.respectedGameType.selector) _respectedGameType = _gameType;\n else revert(\"FetchChainInfoOutput: unknown GameType selector\");\n }\n\n function addressManagerImpl() public view returns (address) {\n require(_addressManagerImpl != address(0), \"FetchChainInfoOutput: addressManagerImpl not set\");\n return _addressManagerImpl;\n }\n\n function ethLockboxProxy() public view returns (address) {\n return _ethLockboxProxy;\n }\n\n function l1CrossDomainMessengerProxy() public view returns (address) {\n require(_l1CrossDomainMessengerProxy != address(0), \"FetchChainInfoOutput: l1CrossDomainMessengerProxy not set\");\n return _l1CrossDomainMessengerProxy;\n }\n\n function l1Erc721BridgeProxy() public view returns (address) {\n require(_l1Erc721BridgeProxy != address(0), \"FetchChainInfoOutput: l1Erc721BridgeProxy not set\");\n return _l1Erc721BridgeProxy;\n }\n\n function l1StandardBridgeProxy() public view returns (address) {\n require(_l1StandardBridgeProxy != address(0), \"FetchChainInfoOutput: l1StandardBridgeProxy not set\");\n return _l1StandardBridgeProxy;\n }\n\n function l2OutputOracleProxy() public view returns (address) {\n require(_l2OutputOracleProxy != address(0), \"FetchChainInfoOutput: l2OutputOracleProxy not set\");\n return _l2OutputOracleProxy;\n }\n\n function optimismMintableErc20FactoryProxy() public view returns (address) {\n require(\n _optimismMintableErc20FactoryProxy != address(0),\n \"FetchChainInfoOutput: optimismMintableErc20FactoryProxy not set\"\n );\n return _optimismMintableErc20FactoryProxy;\n }\n\n function optimismPortalProxy() public view returns (address) {\n require(_optimismPortalProxy != address(0), \"FetchChainInfoOutput: optimismPortalProxy not set\");\n return _optimismPortalProxy;\n }\n\n function systemConfigProxy() public view returns (address) {\n require(_systemConfigProxy != address(0), \"FetchChainInfoOutput: systemConfigProxy not set\");\n return _systemConfigProxy;\n }\n\n function opChainProxyAdminImpl() public view returns (address) {\n require(_opChainProxyAdminImpl != address(0), \"FetchChainInfoOutput: opChainProxyAdminImpl not set\");\n return _opChainProxyAdminImpl;\n }\n\n function superchainConfigProxy() public view returns (address) {\n require(_superchainConfigProxy != address(0), \"FetchChainInfoOutput: superchainConfigProxy not set\");\n return _superchainConfigProxy;\n }\n\n function anchorStateRegistryProxy() public view returns (address) {\n require(_anchorStateRegistryProxy != address(0), \"FetchChainInfoOutput: anchorStateRegistryProxy not set\");\n return _anchorStateRegistryProxy;\n }\n\n function delayedWethPermissionedGameProxy() public view returns (address) {\n return _delayedWethPermissionedGameProxy;\n }\n\n function delayedWethPermissionlessGameProxy() public view returns (address) {\n return _delayedWethPermissionlessGameProxy;\n }\n\n function disputeGameFactoryProxy() public view returns (address) {\n return _disputeGameFactoryProxy;\n }\n\n function faultDisputeGameImpl() public view returns (address) {\n require(_faultDisputeGameImpl != address(0), \"FetchChainInfoOutput: faultDisputeGameImpl not set\");\n return _faultDisputeGameImpl;\n }\n\n function faultDisputeGameCannonKonaImpl() public view returns (address) {\n require(\n _faultDisputeGameCannonKonaImpl != address(0),\n \"FetchChainInfoOutput: faultDisputeGameCannonKonaImpl not set\"\n );\n return _faultDisputeGameCannonKonaImpl;\n }\n\n function mipsImpl() public view returns (address) {\n require(_mipsImpl != address(0), \"FetchChainInfoOutput: mipsImpl not set\");\n return _mipsImpl;\n }\n\n function permissionedDisputeGameImpl() public view returns (address) {\n require(_permissionedDisputeGameImpl != address(0), \"FetchChainInfoOutput: permissionedDisputeGameImpl not set\");\n return _permissionedDisputeGameImpl;\n }\n\n function preimageOracleImpl() public view returns (address) {\n require(_preimageOracleImpl != address(0), \"FetchChainInfoOutput: preimageOracleImpl not set\");\n return _preimageOracleImpl;\n }\n\n function systemConfigOwner() public view returns (address) {\n require(_systemConfigOwner != address(0), \"FetchChainInfoOutput: systemConfigOwner not set\");\n return _systemConfigOwner;\n }\n\n function opChainProxyAdminOwner() public view returns (address) {\n require(_opChainProxyAdminOwner != address(0), \"FetchChainInfoOutput: opChainProxyAdminOwner not set\");\n return _opChainProxyAdminOwner;\n }\n\n function opChainGuardian() public view returns (address) {\n require(_opChainGuardian != address(0), \"FetchChainInfoOutput: opChainGuardian not set\");\n return _opChainGuardian;\n }\n\n function challenger() public view returns (address) {\n require(_challenger != address(0), \"FetchChainInfoOutput: challenger not set\");\n return _challenger;\n }\n\n function proposer() public view returns (address) {\n require(_proposer != address(0), \"FetchChainInfoOutput: proposer not set\");\n return _proposer;\n }\n\n function unsafeBlockSigner() public view returns (address) {\n require(_unsafeBlockSigner != address(0), \"FetchChainInfoOutput: unsafeBlockSigner not set\");\n return _unsafeBlockSigner;\n }\n\n function batchSubmitter() public view returns (address) {\n require(_batchSubmitter != address(0), \"FetchChainInfoOutput: batchSubmitter not set\");\n return _batchSubmitter;\n }\n\n function permissioned() public view returns (bool) {\n return _permissioned;\n }\n\n function permissionless() public view returns (bool) {\n return _permissionless;\n }\n\n function respectedGameType() public view returns (GameType) {\n return _respectedGameType;\n }\n}\n\ncontract FetchChainInfo is Script {\n function run(FetchChainInfoInput _fi, FetchChainInfoOutput _fo) public {\n _processSystemConfig(_fi, _fo);\n _processMessengerAndPortal(_fi, _fo);\n _processFaultProofs(_fo);\n }\n\n function _processSystemConfig(FetchChainInfoInput _fi, FetchChainInfoOutput _fo) internal {\n address systemConfigProxy = _fi.systemConfigProxy();\n _fo.set(_fo.systemConfigProxy.selector, systemConfigProxy);\n\n address systemConfigOwner = IFetcher(systemConfigProxy).owner();\n _fo.set(_fo.systemConfigOwner.selector, systemConfigOwner);\n\n address unsafeBlockSigner = IFetcher(systemConfigProxy).unsafeBlockSigner();\n _fo.set(_fo.unsafeBlockSigner.selector, unsafeBlockSigner);\n\n address batchSubmitter = _getBatchSubmitter(systemConfigProxy);\n _fo.set(_fo.batchSubmitter.selector, batchSubmitter);\n\n address opChainProxyAdminImpl = _getProxyAdmin(systemConfigProxy);\n _fo.set(_fo.opChainProxyAdminImpl.selector, opChainProxyAdminImpl);\n\n address opChainProxyAdminOwner = IFetcher(opChainProxyAdminImpl).owner();\n _fo.set(_fo.opChainProxyAdminOwner.selector, opChainProxyAdminOwner);\n\n address l1Erc721BridgeProxy = _getL1ERC721BridgeProxy(systemConfigProxy);\n _fo.set(_fo.l1Erc721BridgeProxy.selector, l1Erc721BridgeProxy);\n\n address optimismMintableErc20FactoryProxy = _getOptimismMintableERC20FactoryProxy(systemConfigProxy);\n _fo.set(_fo.optimismMintableErc20FactoryProxy.selector, optimismMintableErc20FactoryProxy);\n }\n\n function _processMessengerAndPortal(FetchChainInfoInput _fi, FetchChainInfoOutput _fo) internal {\n address l1StandardBridgeProxy = _fi.l1StandardBridgeProxy();\n _fo.set(_fo.l1StandardBridgeProxy.selector, l1StandardBridgeProxy);\n\n address l1CrossDomainMessengerProxy = IFetcher(l1StandardBridgeProxy).messenger();\n _fo.set(_fo.l1CrossDomainMessengerProxy.selector, l1CrossDomainMessengerProxy);\n\n address addressManagerImpl = _getAddressManager(l1CrossDomainMessengerProxy);\n _fo.set(_fo.addressManagerImpl.selector, addressManagerImpl);\n\n address optimismPortalProxy = _getOptimismPortalProxy(l1CrossDomainMessengerProxy);\n _fo.set(_fo.optimismPortalProxy.selector, optimismPortalProxy);\n\n address opChainGuardian = _getGuardian(optimismPortalProxy);\n _fo.set(_fo.opChainGuardian.selector, opChainGuardian);\n\n address ethLockboxProxy = _getEthLockboxProxy(optimismPortalProxy);\n _fo.set(_fo.ethLockboxProxy.selector, ethLockboxProxy);\n\n address superchainConfigProxy = _getSuperchainConfigProxy(optimismPortalProxy);\n _fo.set(_fo.superchainConfigProxy.selector, superchainConfigProxy);\n }\n\n function _processFaultProofs(FetchChainInfoOutput _fo) internal {\n address systemConfigProxy = _fo.systemConfigProxy();\n address optimismPortalProxy = _fo.optimismPortalProxy();\n\n try IFetcher(optimismPortalProxy).respectedGameType() returns (GameType gameType_) {\n _fo.set(_fo.respectedGameType.selector, gameType_);\n } catch {\n // default respectedGameType to uint32.max since 0 == CANNON\n _fo.set(_fo.respectedGameType.selector, GameType.wrap(type(uint32).max));\n address l2OutputOracleProxy;\n try IFetcher(optimismPortalProxy).l2Oracle() returns (address l2Oracle_) {\n l2OutputOracleProxy = l2Oracle_;\n } catch {\n l2OutputOracleProxy = IFetcher(optimismPortalProxy).L2_ORACLE();\n }\n _fo.set(_fo.l2OutputOracleProxy.selector, l2OutputOracleProxy);\n\n address proposer = IFetcher(l2OutputOracleProxy).PROPOSER();\n _fo.set(_fo.proposer.selector, proposer);\n\n // no fault proofs installed so we're done\n return;\n }\n\n address disputeGameFactoryProxy = _getDisputeGameFactoryProxy(systemConfigProxy);\n if (disputeGameFactoryProxy != address(0)) {\n _fo.set(_fo.disputeGameFactoryProxy.selector, disputeGameFactoryProxy);\n\n address permissionedDisputeGameImpl = _getPermissionedDisputeGame(disputeGameFactoryProxy);\n if (permissionedDisputeGameImpl != address(0)) {\n // permissioned fault proofs installed\n _fo.set(_fo.permissioned.selector, true);\n _fo.set(_fo.permissionedDisputeGameImpl.selector, permissionedDisputeGameImpl);\n\n address challenger = IFetcher(permissionedDisputeGameImpl).challenger();\n _fo.set(_fo.challenger.selector, challenger);\n\n address anchorStateRegistryProxy = IFetcher(permissionedDisputeGameImpl).anchorStateRegistry();\n _fo.set(_fo.anchorStateRegistryProxy.selector, anchorStateRegistryProxy);\n\n address proposer = IFetcher(permissionedDisputeGameImpl).proposer();\n _fo.set(_fo.proposer.selector, proposer);\n\n address delayedWethPermissionedGameProxy = _getDelayedWETHProxy(permissionedDisputeGameImpl);\n _fo.set(_fo.delayedWethPermissionedGameProxy.selector, delayedWethPermissionedGameProxy);\n\n address mipsImpl = IFetcher(permissionedDisputeGameImpl).vm();\n _fo.set(_fo.mipsImpl.selector, mipsImpl);\n\n address preimageOracleImpl = IFetcher(mipsImpl).oracle();\n _fo.set(_fo.preimageOracleImpl.selector, preimageOracleImpl);\n }\n\n address faultDisputeGameImpl = _getFaultDisputeGame(disputeGameFactoryProxy);\n if (faultDisputeGameImpl != address(0)) {\n // permissionless fault proofs installed\n _fo.set(_fo.faultDisputeGameImpl.selector, faultDisputeGameImpl);\n _fo.set(_fo.permissionless.selector, true);\n\n address delayedWethPermissionlessGameProxy = _getDelayedWETHProxy(faultDisputeGameImpl);\n _fo.set(_fo.delayedWethPermissionlessGameProxy.selector, delayedWethPermissionlessGameProxy);\n }\n\n address faultDisputeGameCannonKonaImpl =\n _getFaultDisputeGame(disputeGameFactoryProxy, GameTypes.CANNON_KONA);\n if (faultDisputeGameCannonKonaImpl != address(0)) {\n _fo.set(_fo.faultDisputeGameCannonKonaImpl.selector, faultDisputeGameCannonKonaImpl);\n }\n } else {\n // some older chains have L2OutputOracle instead of DisputeGameFactory.\n address l2OutputOracleProxy = IFetcher(optimismPortalProxy).L2_ORACLE();\n _fo.set(_fo.l2OutputOracleProxy.selector, l2OutputOracleProxy);\n address proposer = IFetcher(l2OutputOracleProxy).PROPOSER();\n _fo.set(_fo.proposer.selector, proposer);\n }\n }\n\n function _getGuardian(address _portal) internal view returns (address) {\n try IFetcher(_portal).guardian() returns (address guardian_) {\n return guardian_;\n } catch {\n return IFetcher(_portal).GUARDIAN();\n }\n }\n\n function _getSystemConfigProxy(address _portal) internal view returns (address) {\n try IFetcher(_portal).systemConfig() returns (address systemConfig_) {\n return systemConfig_;\n } catch {\n return IFetcher(_portal).SYSTEM_CONFIG();\n }\n }\n\n function _getOptimismPortalProxy(address _l1CrossDomainMessengerProxy) internal view returns (address) {\n try IFetcher(_l1CrossDomainMessengerProxy).portal() returns (address optimismPortal_) {\n return optimismPortal_;\n } catch {\n return IFetcher(_l1CrossDomainMessengerProxy).PORTAL();\n }\n }\n\n function _getAddressManager(address _l1CrossDomainMessengerProxy) internal view returns (address) {\n uint256 ADDRESS_MANAGER_MAPPING_SLOT = 1;\n bytes32 slot = keccak256(abi.encode(_l1CrossDomainMessengerProxy, ADDRESS_MANAGER_MAPPING_SLOT));\n return address(uint160(uint256((vm.load(_l1CrossDomainMessengerProxy, slot)))));\n }\n\n function _getL1ERC721BridgeProxy(address _systemConfigProxy) internal view returns (address) {\n try IFetcher(_systemConfigProxy).l1ERC721Bridge() returns (address l1ERC721BridgeProxy_) {\n return l1ERC721BridgeProxy_;\n } catch {\n return address(0);\n }\n }\n\n function _getOptimismMintableERC20FactoryProxy(address _systemConfigProxy) internal view returns (address) {\n try IFetcher(_systemConfigProxy).optimismMintableERC20Factory() returns (\n address optimismMintableERC20FactoryProxy_\n ) {\n return optimismMintableERC20FactoryProxy_;\n } catch {\n return address(0);\n }\n }\n\n function _getDisputeGameFactoryProxy(address _systemConfigProxy) internal view returns (address) {\n try IFetcher(_systemConfigProxy).disputeGameFactory() returns (address disputeGameFactoryProxy_) {\n return disputeGameFactoryProxy_;\n } catch {\n // Some older chains have L2OutputOracle instead of DisputeGameFactory\n return address(0);\n }\n }\n\n function _getSuperchainConfigProxy(address _optimismPortalProxy) internal view returns (address) {\n try IFetcher(_optimismPortalProxy).superchainConfig() returns (address superchainConfigProxy_) {\n return superchainConfigProxy_;\n } catch {\n return address(0);\n }\n }\n\n function _getFaultDisputeGame(address _disputeGameFactoryProxy) internal view returns (address) {\n try IFetcher(_disputeGameFactoryProxy).gameImpls(GameTypes.CANNON) returns (address faultDisputeGame_) {\n return faultDisputeGame_;\n } catch {\n return address(0);\n }\n }\n\n function _getFaultDisputeGame(\n address _disputeGameFactoryProxy,\n GameType _gameType\n )\n internal\n view\n returns (address)\n {\n try IFetcher(_disputeGameFactoryProxy).gameImpls(_gameType) returns (address faultDisputeGame_) {\n return faultDisputeGame_;\n } catch {\n return address(0);\n }\n }\n\n function _getPermissionedDisputeGame(address _disputeGameFactoryProxy) internal view returns (address) {\n try IFetcher(_disputeGameFactoryProxy).gameImpls(GameTypes.PERMISSIONED_CANNON) returns (\n address permissionedDisputeGame_\n ) {\n return permissionedDisputeGame_;\n } catch {\n return address(0);\n }\n }\n\n function _getEthLockboxProxy(address _optimismPortalProxy) internal view returns (address) {\n try IFetcher(_optimismPortalProxy).ethLockbox() returns (address ethLockbox_) {\n return ethLockbox_;\n } catch {\n return address(0);\n }\n }\n\n function _getDelayedWETHProxy(address _disputeGame) internal view returns (address) {\n (bool ok, bytes memory data) = address(_disputeGame).staticcall(abi.encodeCall(IFetcher.weth, ()));\n if (ok && data.length == 32) return abi.decode(data, (address));\n else return address(0);\n }\n\n function _getBatchSubmitter(address _systemConfigProxy) internal view returns (address) {\n bytes32 batcherHash = IFetcher(_systemConfigProxy).batcherHash();\n return address(uint160(uint256(batcherHash)));\n }\n\n function _getProxyAdmin(address _systemConfigProxy) internal returns (address) {\n vm.prank(address(0));\n return IFetcher(_systemConfigProxy).admin();\n }\n}\n","license":"MIT"},"src/dispute/lib/LibPosition.sol":{"keccak256":"0x7c5f19f8f54f06de2ce1c6cdcc5c7af65ac405130a4066cdaf146ca315818241","urls":[],"content":"// SPDX-License-Identifier: MIT\npragma solidity ^0.8.15;\n\nusing LibPosition for Position global;\n\n/// @notice A `Position` represents a position of a claim within the game tree.\n/// @dev This is represented as a \"generalized index\" where the high-order bit\n/// is the level in the tree and the remaining bits is a unique bit pattern, allowing\n/// a unique identifier for each node in the tree. Mathematically, it is calculated\n/// as 2^{depth} + indexAtDepth.\ntype Position is uint128;\n\n/// @title LibPosition\n/// @notice This library contains helper functions for working with the `Position` type.\nlibrary LibPosition {\n /// @notice the `MAX_POSITION_BITLEN` is the number of bits that the `Position` type, and the implementation of\n /// its behavior within this library, can safely support.\n uint8 internal constant MAX_POSITION_BITLEN = 126;\n\n /// @notice Computes a generalized index (2^{depth} + indexAtDepth).\n /// @param _depth The depth of the position.\n /// @param _indexAtDepth The index at the depth of the position.\n /// @return position_ The computed generalized index.\n function wrap(uint8 _depth, uint128 _indexAtDepth) internal pure returns (Position position_) {\n assembly {\n // gindex = 2^{_depth} + _indexAtDepth\n position_ := add(shl(_depth, 1), _indexAtDepth)\n }\n }\n\n /// @notice Pulls the `depth` out of a `Position` type.\n /// @param _position The generalized index to get the `depth` of.\n /// @return depth_ The `depth` of the `position` gindex.\n /// @custom:attribution Solady \n function depth(Position _position) internal pure returns (uint8 depth_) {\n // Return the most significant bit offset, which signifies the depth of the gindex.\n assembly {\n depth_ := or(depth_, shl(6, lt(0xffffffffffffffff, shr(depth_, _position))))\n depth_ := or(depth_, shl(5, lt(0xffffffff, shr(depth_, _position))))\n\n // For the remaining 32 bits, use a De Bruijn lookup.\n _position := shr(depth_, _position)\n _position := or(_position, shr(1, _position))\n _position := or(_position, shr(2, _position))\n _position := or(_position, shr(4, _position))\n _position := or(_position, shr(8, _position))\n _position := or(_position, shr(16, _position))\n\n depth_ :=\n or(\n depth_,\n byte(\n shr(251, mul(_position, shl(224, 0x07c4acdd))),\n 0x0009010a0d15021d0b0e10121619031e080c141c0f111807131b17061a05041f\n )\n )\n }\n }\n\n /// @notice Pulls the `indexAtDepth` out of a `Position` type.\n /// The `indexAtDepth` is the left/right index of a position at a specific depth within\n /// the binary tree, starting from index 0. For example, at gindex 2, the `depth` = 1\n /// and the `indexAtDepth` = 0.\n /// @param _position The generalized index to get the `indexAtDepth` of.\n /// @return indexAtDepth_ The `indexAtDepth` of the `position` gindex.\n function indexAtDepth(Position _position) internal pure returns (uint128 indexAtDepth_) {\n // Return bits p_{msb-1}...p_{0}. This effectively pulls the 2^{depth} out of the gindex,\n // leaving only the `indexAtDepth`.\n uint256 msb = depth(_position);\n assembly {\n indexAtDepth_ := sub(_position, shl(msb, 1))\n }\n }\n\n /// @notice Get the left child of `_position`.\n /// @param _position The position to get the left position of.\n /// @return left_ The position to the left of `position`.\n function left(Position _position) internal pure returns (Position left_) {\n assembly {\n left_ := shl(1, _position)\n }\n }\n\n /// @notice Get the right child of `_position`\n /// @param _position The position to get the right position of.\n /// @return right_ The position to the right of `position`.\n function right(Position _position) internal pure returns (Position right_) {\n assembly {\n right_ := or(1, shl(1, _position))\n }\n }\n\n /// @notice Get the parent position of `_position`.\n /// @param _position The position to get the parent position of.\n /// @return parent_ The parent position of `position`.\n function parent(Position _position) internal pure returns (Position parent_) {\n assembly {\n parent_ := shr(1, _position)\n }\n }\n\n /// @notice Get the deepest, right most gindex relative to the `position`. This is equivalent to\n /// calling `right` on a position until the maximum depth is reached.\n /// @param _position The position to get the relative deepest, right most gindex of.\n /// @param _maxDepth The maximum depth of the game.\n /// @return rightIndex_ The deepest, right most gindex relative to the `position`.\n function rightIndex(Position _position, uint256 _maxDepth) internal pure returns (Position rightIndex_) {\n uint256 msb = depth(_position);\n assembly {\n let remaining := sub(_maxDepth, msb)\n rightIndex_ := or(shl(remaining, _position), sub(shl(remaining, 1), 1))\n }\n }\n\n /// @notice Get the deepest, right most trace index relative to the `position`. This is\n /// equivalent to calling `right` on a position until the maximum depth is reached and\n /// then finding its index at depth.\n /// @param _position The position to get the relative trace index of.\n /// @param _maxDepth The maximum depth of the game.\n /// @return traceIndex_ The trace index relative to the `position`.\n function traceIndex(Position _position, uint256 _maxDepth) internal pure returns (uint256 traceIndex_) {\n uint256 msb = depth(_position);\n assembly {\n let remaining := sub(_maxDepth, msb)\n traceIndex_ := sub(or(shl(remaining, _position), sub(shl(remaining, 1), 1)), shl(_maxDepth, 1))\n }\n }\n\n /// @notice Gets the position of the highest ancestor of `_position` that commits to the same\n /// trace index.\n /// @param _position The position to get the highest ancestor of.\n /// @return ancestor_ The highest ancestor of `position` that commits to the same trace index.\n function traceAncestor(Position _position) internal pure returns (Position ancestor_) {\n // Create a field with only the lowest unset bit of `_position` set.\n Position lsb;\n assembly {\n lsb := and(not(_position), add(_position, 1))\n }\n // Find the index of the lowest unset bit within the field.\n uint256 msb = depth(lsb);\n // The highest ancestor that commits to the same trace index is the original position\n // shifted right by the index of the lowest unset bit.\n assembly {\n let a := shr(msb, _position)\n // Bound the ancestor to the minimum gindex, 1.\n ancestor_ := or(a, iszero(a))\n }\n }\n\n /// @notice Gets the position of the highest ancestor of `_position` that commits to the same\n /// trace index, while still being below `_upperBoundExclusive`.\n /// @param _position The position to get the highest ancestor of.\n /// @param _upperBoundExclusive The exclusive upper depth bound, used to inform where to stop in order\n /// to not escape a sub-tree.\n /// @return ancestor_ The highest ancestor of `position` that commits to the same trace index.\n function traceAncestorBounded(\n Position _position,\n uint256 _upperBoundExclusive\n )\n internal\n pure\n returns (Position ancestor_)\n {\n // This function only works for positions that are below the upper bound.\n if (_position.depth() <= _upperBoundExclusive) {\n assembly {\n // Revert with `ClaimAboveSplit()`\n mstore(0x00, 0xb34b5c22)\n revert(0x1C, 0x04)\n }\n }\n\n // Grab the global trace ancestor.\n ancestor_ = traceAncestor(_position);\n\n // If the ancestor is above or at the upper bound, shift it to be below the upper bound.\n // This should be a special case that only covers positions that commit to the final leaf\n // in a sub-tree.\n if (ancestor_.depth() <= _upperBoundExclusive) {\n ancestor_ = ancestor_.rightIndex(_upperBoundExclusive + 1);\n }\n }\n\n /// @notice Get the move position of `_position`, which is the left child of:\n /// 1. `_position` if `_isAttack` is true.\n /// 2. `_position | 1` if `_isAttack` is false.\n /// @param _position The position to get the relative attack/defense position of.\n /// @param _isAttack Whether or not the move is an attack move.\n /// @return move_ The move position relative to `position`.\n function move(Position _position, bool _isAttack) internal pure returns (Position move_) {\n assembly {\n move_ := shl(1, or(iszero(_isAttack), _position))\n }\n }\n\n /// @notice Get the value of a `Position` type in the form of the underlying uint128.\n /// @param _position The position to get the value of.\n /// @return raw_ The value of the `position` as a uint128 type.\n function raw(Position _position) internal pure returns (uint128 raw_) {\n assembly {\n raw_ := _position\n }\n }\n}\n","license":"MIT"},"src/dispute/lib/LibUDT.sol":{"keccak256":"0x41d55e9c74d979b5b797198e38449e7cef4f925e04d61f7699e9c150c4a659d3","urls":[],"content":"// SPDX-License-Identifier: MIT\npragma solidity ^0.8.15;\n\n// Libraries\nimport { Position } from \"src/dispute/lib/LibPosition.sol\";\n\nusing LibClaim for Claim global;\nusing LibHash for Hash global;\nusing LibDuration for Duration global;\nusing LibClock for Clock global;\nusing LibGameId for GameId global;\nusing LibTimestamp for Timestamp global;\nusing LibVMStatus for VMStatus global;\nusing LibGameType for GameType global;\n\n/// @notice A `Clock` represents a packed `Duration` and `Timestamp`\n/// @dev The packed layout of this type is as follows:\n/// ┌────────────┬────────────────┐\n/// │ Bits │ Value │\n/// ├────────────┼────────────────┤\n/// │ [0, 64) │ Duration │\n/// │ [64, 128) │ Timestamp │\n/// └────────────┴────────────────┘\ntype Clock is uint128;\n\n/// @title LibClock\n/// @notice This library contains helper functions for working with the `Clock` type.\nlibrary LibClock {\n /// @notice Packs a `Duration` and `Timestamp` into a `Clock` type.\n /// @param _duration The `Duration` to pack into the `Clock` type.\n /// @param _timestamp The `Timestamp` to pack into the `Clock` type.\n /// @return clock_ The `Clock` containing the `_duration` and `_timestamp`.\n function wrap(Duration _duration, Timestamp _timestamp) internal pure returns (Clock clock_) {\n assembly {\n clock_ := or(shl(0x40, _duration), _timestamp)\n }\n }\n\n /// @notice Pull the `Duration` out of a `Clock` type.\n /// @param _clock The `Clock` type to pull the `Duration` out of.\n /// @return duration_ The `Duration` pulled out of `_clock`.\n function duration(Clock _clock) internal pure returns (Duration duration_) {\n // Shift the high-order 64 bits into the low-order 64 bits, leaving only the `duration`.\n assembly {\n duration_ := shr(0x40, _clock)\n }\n }\n\n /// @notice Pull the `Timestamp` out of a `Clock` type.\n /// @param _clock The `Clock` type to pull the `Timestamp` out of.\n /// @return timestamp_ The `Timestamp` pulled out of `_clock`.\n function timestamp(Clock _clock) internal pure returns (Timestamp timestamp_) {\n // Clean the high-order 192 bits by shifting the clock left and then right again, leaving\n // only the `timestamp`.\n assembly {\n timestamp_ := shr(0xC0, shl(0xC0, _clock))\n }\n }\n\n /// @notice Get the value of a `Clock` type in the form of the underlying uint128.\n /// @param _clock The `Clock` type to get the value of.\n /// @return clock_ The value of the `Clock` type as a uint128 type.\n function raw(Clock _clock) internal pure returns (uint128 clock_) {\n assembly {\n clock_ := _clock\n }\n }\n}\n\n/// @notice A `GameId` represents a packed 4 byte game ID, a 8 byte timestamp, and a 20 byte address.\n/// @dev The packed layout of this type is as follows:\n/// ┌───────────┬───────────┐\n/// │ Bits │ Value │\n/// ├───────────┼───────────┤\n/// │ [0, 32) │ Game Type │\n/// │ [32, 96) │ Timestamp │\n/// │ [96, 256) │ Address │\n/// └───────────┴───────────┘\ntype GameId is bytes32;\n\n/// @title LibGameId\n/// @notice Utility functions for packing and unpacking GameIds.\nlibrary LibGameId {\n /// @notice Packs values into a 32 byte GameId type.\n /// @param _gameType The game type.\n /// @param _timestamp The timestamp of the game's creation.\n /// @param _gameProxy The game proxy address.\n /// @return gameId_ The packed GameId.\n function pack(\n GameType _gameType,\n Timestamp _timestamp,\n address _gameProxy\n )\n internal\n pure\n returns (GameId gameId_)\n {\n assembly {\n gameId_ := or(or(shl(224, _gameType), shl(160, _timestamp)), _gameProxy)\n }\n }\n\n /// @notice Unpacks values from a 32 byte GameId type.\n /// @param _gameId The packed GameId.\n /// @return gameType_ The game type.\n /// @return timestamp_ The timestamp of the game's creation.\n /// @return gameProxy_ The game proxy address.\n function unpack(GameId _gameId)\n internal\n pure\n returns (GameType gameType_, Timestamp timestamp_, address gameProxy_)\n {\n assembly {\n gameType_ := shr(224, _gameId)\n timestamp_ := and(shr(160, _gameId), 0xFFFFFFFFFFFFFFFF)\n gameProxy_ := and(_gameId, 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF)\n }\n }\n}\n\n/// @notice A claim represents an MPT root representing the state of the fault proof program.\ntype Claim is bytes32;\n\n/// @title LibClaim\n/// @notice This library contains helper functions for working with the `Claim` type.\nlibrary LibClaim {\n /// @notice Get the value of a `Claim` type in the form of the underlying bytes32.\n /// @param _claim The `Claim` type to get the value of.\n /// @return claim_ The value of the `Claim` type as a bytes32 type.\n function raw(Claim _claim) internal pure returns (bytes32 claim_) {\n assembly {\n claim_ := _claim\n }\n }\n\n /// @notice Hashes a claim and a position together.\n /// @param _claim A Claim type.\n /// @param _position The position of `claim`.\n /// @param _challengeIndex The index of the claim being moved against.\n /// @return claimHash_ A hash of abi.encodePacked(claim, position|challengeIndex);\n function hashClaimPos(\n Claim _claim,\n Position _position,\n uint256 _challengeIndex\n )\n internal\n pure\n returns (Hash claimHash_)\n {\n assembly {\n mstore(0x00, _claim)\n mstore(0x20, or(shl(128, _position), and(0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF, _challengeIndex)))\n claimHash_ := keccak256(0x00, 0x40)\n }\n }\n}\n\n/// @notice A dedicated duration type.\n/// @dev Unit: seconds\ntype Duration is uint64;\n\n/// @title LibDuration\n/// @notice This library contains helper functions for working with the `Duration` type.\nlibrary LibDuration {\n /// @notice Get the value of a `Duration` type in the form of the underlying uint64.\n /// @param _duration The `Duration` type to get the value of.\n /// @return duration_ The value of the `Duration` type as a uint64 type.\n function raw(Duration _duration) internal pure returns (uint64 duration_) {\n assembly {\n duration_ := _duration\n }\n }\n}\n\n/// @notice A custom type for a generic hash.\ntype Hash is bytes32;\n\n/// @title LibHash\n/// @notice This library contains helper functions for working with the `Hash` type.\nlibrary LibHash {\n /// @notice Get the value of a `Hash` type in the form of the underlying bytes32.\n /// @param _hash The `Hash` type to get the value of.\n /// @return hash_ The value of the `Hash` type as a bytes32 type.\n function raw(Hash _hash) internal pure returns (bytes32 hash_) {\n assembly {\n hash_ := _hash\n }\n }\n}\n\n/// @notice A dedicated timestamp type.\ntype Timestamp is uint64;\n\n/// @title LibTimestamp\n/// @notice This library contains helper functions for working with the `Timestamp` type.\nlibrary LibTimestamp {\n /// @notice Get the value of a `Timestamp` type in the form of the underlying uint64.\n /// @param _timestamp The `Timestamp` type to get the value of.\n /// @return timestamp_ The value of the `Timestamp` type as a uint64 type.\n function raw(Timestamp _timestamp) internal pure returns (uint64 timestamp_) {\n assembly {\n timestamp_ := _timestamp\n }\n }\n}\n\n/// @notice A `VMStatus` represents the status of a VM execution.\ntype VMStatus is uint8;\n\n/// @title LibVMStatus\n/// @notice This library contains helper functions for working with the `VMStatus` type.\nlibrary LibVMStatus {\n /// @notice Get the value of a `VMStatus` type in the form of the underlying uint8.\n /// @param _vmstatus The `VMStatus` type to get the value of.\n /// @return vmstatus_ The value of the `VMStatus` type as a uint8 type.\n function raw(VMStatus _vmstatus) internal pure returns (uint8 vmstatus_) {\n assembly {\n vmstatus_ := _vmstatus\n }\n }\n}\n\n/// @notice A `GameType` represents the type of game being played.\ntype GameType is uint32;\n\n/// @title LibGameType\n/// @notice This library contains helper functions for working with the `GameType` type.\nlibrary LibGameType {\n /// @notice Get the value of a `GameType` type in the form of the underlying uint32.\n /// @param _gametype The `GameType` type to get the value of.\n /// @return gametype_ The value of the `GameType` type as a uint32 type.\n function raw(GameType _gametype) internal pure returns (uint32 gametype_) {\n assembly {\n gametype_ := _gametype\n }\n }\n}\n","license":"MIT"},"src/dispute/lib/Types.sol":{"keccak256":"0x468fccc8d6ce3ac5b87bdd5002f84b315ac861be7655ceef87a018f596c410a1","urls":[],"content":"// SPDX-License-Identifier: MIT\npragma solidity ^0.8.15;\n\n// Libraries\nimport {\n Position,\n Hash,\n GameType,\n VMStatus,\n Timestamp,\n Duration,\n Clock,\n GameId,\n Claim,\n LibGameId,\n LibClock\n} from \"src/dispute/lib/LibUDT.sol\";\n\n/// @notice The current status of the dispute game.\nenum GameStatus {\n // The game is currently in progress, and has not been resolved.\n IN_PROGRESS,\n // The game has concluded, and the `rootClaim` was challenged successfully.\n CHALLENGER_WINS,\n // The game has concluded, and the `rootClaim` could not be contested.\n DEFENDER_WINS\n}\n\n/// @notice The game's bond distribution type. Games are expected to start in the `UNDECIDED`\n/// state, and then choose either `NORMAL` or `REFUND`.\nenum BondDistributionMode {\n // Bond distribution strategy has not been chosen.\n UNDECIDED,\n // Bonds should be distributed as normal.\n NORMAL,\n // Bonds should be refunded to claimants.\n REFUND\n}\n\n/// @notice Represents an L2 root and the L2 sequence number at which it was generated.\n/// @custom:field root The output root.\n/// @custom:field l2SequenceNumber The L2 Sequence Number ( e.g. block number / timestamp) at which the root was\n/// generated.\nstruct Proposal {\n Hash root;\n uint256 l2SequenceNumber;\n}\n\n/// @title GameTypes\n/// @notice A library that defines the IDs of games that can be played.\nlibrary GameTypes {\n /// @dev A dispute game type the uses the cannon vm.\n GameType internal constant CANNON = GameType.wrap(0);\n\n /// @dev A permissioned dispute game type that uses the cannon vm.\n GameType internal constant PERMISSIONED_CANNON = GameType.wrap(1);\n\n /// @notice A dispute game type that uses the asterisc vm.\n GameType internal constant ASTERISC = GameType.wrap(2);\n\n /// @notice A dispute game type that uses the asterisc vm with Kona.\n GameType internal constant ASTERISC_KONA = GameType.wrap(3);\n\n /// @notice A dispute game type that uses the cannon vm (Super Roots).\n GameType internal constant SUPER_CANNON = GameType.wrap(4);\n\n /// @notice A dispute game type that uses the permissioned cannon vm (Super Roots).\n GameType internal constant SUPER_PERMISSIONED_CANNON = GameType.wrap(5);\n\n /// @notice A dispute game type that uses OP Succinct\n GameType internal constant OP_SUCCINCT = GameType.wrap(6);\n\n /// @notice A dispute game type that uses the asterisc vm with Kona (Super Roots).\n GameType internal constant SUPER_ASTERISC_KONA = GameType.wrap(7);\n\n /// @notice A dispute game type that uses the cannon vm with Kona.\n GameType internal constant CANNON_KONA = GameType.wrap(8);\n\n /// @notice A dispute game type that uses the cannon vm with Kona (Super Roots).\n GameType internal constant SUPER_CANNON_KONA = GameType.wrap(9);\n\n /// @notice A dispute game type with short game duration for testing withdrawals.\n /// Not intended for production use.\n GameType internal constant FAST = GameType.wrap(254);\n\n /// @notice A dispute game type that uses an alphabet vm.\n /// Not intended for production use.\n GameType internal constant ALPHABET = GameType.wrap(255);\n\n /// @notice A dispute game type that uses RISC Zero's Kailua\n GameType internal constant KAILUA = GameType.wrap(1337);\n}\n\n/// @title VMStatuses\n/// @notice Named type aliases for the various valid VM status bytes.\nlibrary VMStatuses {\n /// @notice The VM has executed successfully and the outcome is valid.\n VMStatus internal constant VALID = VMStatus.wrap(0);\n\n /// @notice The VM has executed successfully and the outcome is invalid.\n VMStatus internal constant INVALID = VMStatus.wrap(1);\n\n /// @notice The VM has paniced.\n VMStatus internal constant PANIC = VMStatus.wrap(2);\n\n /// @notice The VM execution is still in progress.\n VMStatus internal constant UNFINISHED = VMStatus.wrap(3);\n}\n\n/// @title LocalPreimageKey\n/// @notice Named type aliases for local `PreimageOracle` key identifiers.\nlibrary LocalPreimageKey {\n /// @notice The identifier for the L1 head hash.\n uint256 internal constant L1_HEAD_HASH = 0x01;\n\n /// @notice The identifier for the starting output root.\n uint256 internal constant STARTING_OUTPUT_ROOT = 0x02;\n\n /// @notice The identifier for the disputed output root.\n uint256 internal constant DISPUTED_OUTPUT_ROOT = 0x03;\n\n /// @notice The identifier for the disputed L2 block number.\n uint256 internal constant DISPUTED_L2_BLOCK_NUMBER = 0x04;\n\n /// @notice The identifier for the chain ID.\n uint256 internal constant CHAIN_ID = 0x05;\n}\n","license":"MIT"}},"version":1},"storageLayout":{"storage":[{"astId":5504,"contract":"scripts/FetchChainInfo.s.sol:FetchChainInfo","label":"stdstore","offset":0,"slot":"0","type":"t_struct(StdStorage)13542_storage"},{"astId":8203,"contract":"scripts/FetchChainInfo.s.sol:FetchChainInfo","label":"stdChainsInitialized","offset":0,"slot":"8","type":"t_bool"},{"astId":8224,"contract":"scripts/FetchChainInfo.s.sol:FetchChainInfo","label":"chains","offset":0,"slot":"9","type":"t_mapping(t_string_memory_ptr,t_struct(Chain)8219_storage)"},{"astId":8228,"contract":"scripts/FetchChainInfo.s.sol:FetchChainInfo","label":"defaultRpcUrls","offset":0,"slot":"10","type":"t_mapping(t_string_memory_ptr,t_string_storage)"},{"astId":8232,"contract":"scripts/FetchChainInfo.s.sol:FetchChainInfo","label":"idToAlias","offset":0,"slot":"11","type":"t_mapping(t_uint256,t_string_storage)"},{"astId":8235,"contract":"scripts/FetchChainInfo.s.sol:FetchChainInfo","label":"fallbackToDefaultRpcUrls","offset":0,"slot":"12","type":"t_bool"},{"astId":9164,"contract":"scripts/FetchChainInfo.s.sol:FetchChainInfo","label":"gasMeteringOff","offset":1,"slot":"12","type":"t_bool"},{"astId":5557,"contract":"scripts/FetchChainInfo.s.sol:FetchChainInfo","label":"IS_SCRIPT","offset":2,"slot":"12","type":"t_bool"}],"types":{"t_address":{"encoding":"inplace","label":"address","numberOfBytes":"20"},"t_array(t_bytes32)dyn_storage":{"encoding":"dynamic_array","label":"bytes32[]","numberOfBytes":"32","base":"t_bytes32"},"t_bool":{"encoding":"inplace","label":"bool","numberOfBytes":"1"},"t_bytes32":{"encoding":"inplace","label":"bytes32","numberOfBytes":"32"},"t_bytes4":{"encoding":"inplace","label":"bytes4","numberOfBytes":"4"},"t_bytes_storage":{"encoding":"bytes","label":"bytes","numberOfBytes":"32"},"t_mapping(t_address,t_mapping(t_bytes4,t_mapping(t_bytes32,t_struct(FindData)13517_storage)))":{"encoding":"mapping","key":"t_address","label":"mapping(address => mapping(bytes4 => mapping(bytes32 => struct FindData)))","numberOfBytes":"32","value":"t_mapping(t_bytes4,t_mapping(t_bytes32,t_struct(FindData)13517_storage))"},"t_mapping(t_bytes32,t_struct(FindData)13517_storage)":{"encoding":"mapping","key":"t_bytes32","label":"mapping(bytes32 => struct FindData)","numberOfBytes":"32","value":"t_struct(FindData)13517_storage"},"t_mapping(t_bytes4,t_mapping(t_bytes32,t_struct(FindData)13517_storage))":{"encoding":"mapping","key":"t_bytes4","label":"mapping(bytes4 => mapping(bytes32 => struct FindData))","numberOfBytes":"32","value":"t_mapping(t_bytes32,t_struct(FindData)13517_storage)"},"t_mapping(t_string_memory_ptr,t_string_storage)":{"encoding":"mapping","key":"t_string_memory_ptr","label":"mapping(string => string)","numberOfBytes":"32","value":"t_string_storage"},"t_mapping(t_string_memory_ptr,t_struct(Chain)8219_storage)":{"encoding":"mapping","key":"t_string_memory_ptr","label":"mapping(string => struct StdChains.Chain)","numberOfBytes":"32","value":"t_struct(Chain)8219_storage"},"t_mapping(t_uint256,t_string_storage)":{"encoding":"mapping","key":"t_uint256","label":"mapping(uint256 => string)","numberOfBytes":"32","value":"t_string_storage"},"t_string_memory_ptr":{"encoding":"bytes","label":"string","numberOfBytes":"32"},"t_string_storage":{"encoding":"bytes","label":"string","numberOfBytes":"32"},"t_struct(Chain)8219_storage":{"encoding":"inplace","label":"struct StdChains.Chain","numberOfBytes":"128","members":[{"astId":8212,"contract":"scripts/FetchChainInfo.s.sol:FetchChainInfo","label":"name","offset":0,"slot":"0","type":"t_string_storage"},{"astId":8214,"contract":"scripts/FetchChainInfo.s.sol:FetchChainInfo","label":"chainId","offset":0,"slot":"1","type":"t_uint256"},{"astId":8216,"contract":"scripts/FetchChainInfo.s.sol:FetchChainInfo","label":"chainAlias","offset":0,"slot":"2","type":"t_string_storage"},{"astId":8218,"contract":"scripts/FetchChainInfo.s.sol:FetchChainInfo","label":"rpcUrl","offset":0,"slot":"3","type":"t_string_storage"}]},"t_struct(FindData)13517_storage":{"encoding":"inplace","label":"struct FindData","numberOfBytes":"128","members":[{"astId":13510,"contract":"scripts/FetchChainInfo.s.sol:FetchChainInfo","label":"slot","offset":0,"slot":"0","type":"t_uint256"},{"astId":13512,"contract":"scripts/FetchChainInfo.s.sol:FetchChainInfo","label":"offsetLeft","offset":0,"slot":"1","type":"t_uint256"},{"astId":13514,"contract":"scripts/FetchChainInfo.s.sol:FetchChainInfo","label":"offsetRight","offset":0,"slot":"2","type":"t_uint256"},{"astId":13516,"contract":"scripts/FetchChainInfo.s.sol:FetchChainInfo","label":"found","offset":0,"slot":"3","type":"t_bool"}]},"t_struct(StdStorage)13542_storage":{"encoding":"inplace","label":"struct StdStorage","numberOfBytes":"256","members":[{"astId":13526,"contract":"scripts/FetchChainInfo.s.sol:FetchChainInfo","label":"finds","offset":0,"slot":"0","type":"t_mapping(t_address,t_mapping(t_bytes4,t_mapping(t_bytes32,t_struct(FindData)13517_storage)))"},{"astId":13529,"contract":"scripts/FetchChainInfo.s.sol:FetchChainInfo","label":"_keys","offset":0,"slot":"1","type":"t_array(t_bytes32)dyn_storage"},{"astId":13531,"contract":"scripts/FetchChainInfo.s.sol:FetchChainInfo","label":"_sig","offset":0,"slot":"2","type":"t_bytes4"},{"astId":13533,"contract":"scripts/FetchChainInfo.s.sol:FetchChainInfo","label":"_depth","offset":0,"slot":"3","type":"t_uint256"},{"astId":13535,"contract":"scripts/FetchChainInfo.s.sol:FetchChainInfo","label":"_target","offset":0,"slot":"4","type":"t_address"},{"astId":13537,"contract":"scripts/FetchChainInfo.s.sol:FetchChainInfo","label":"_set","offset":0,"slot":"5","type":"t_bytes32"},{"astId":13539,"contract":"scripts/FetchChainInfo.s.sol:FetchChainInfo","label":"_enable_packed_slots","offset":0,"slot":"6","type":"t_bool"},{"astId":13541,"contract":"scripts/FetchChainInfo.s.sol:FetchChainInfo","label":"_calldata","offset":0,"slot":"7","type":"t_bytes_storage"}]},"t_uint256":{"encoding":"inplace","label":"uint256","numberOfBytes":"32"}}},"userdoc":{"version":1,"kind":"user"},"devdoc":{"version":1,"kind":"dev"},"ast":{"absolutePath":"scripts/FetchChainInfo.s.sol","id":56019,"exportedSymbols":{"FetchChainInfo":[56018],"FetchChainInfoInput":[54041],"FetchChainInfoOutput":[54911],"GameType":[70720],"GameTypes":[70870],"IFetcher":[53958],"Script":[5558]},"nodeType":"SourceUnit","src":"32:25120:100","nodes":[{"id":53807,"nodeType":"PragmaDirective","src":"32:23:100","nodes":[],"literals":["solidity","^","0.8",".0"]},{"id":53809,"nodeType":"ImportDirective","src":"57:46:100","nodes":[],"absolutePath":"lib/forge-std/src/Script.sol","file":"forge-std/Script.sol","nameLocation":"-1:-1:-1","scope":56019,"sourceUnit":5559,"symbolAliases":[{"foreign":{"id":53808,"name":"Script","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":5558,"src":"66:6:100","typeDescriptions":{}},"nameLocation":"-1:-1:-1"}],"unitAlias":""},{"id":53812,"nodeType":"ImportDirective","src":"104:64:100","nodes":[],"absolutePath":"src/dispute/lib/Types.sol","file":"src/dispute/lib/Types.sol","nameLocation":"-1:-1:-1","scope":56019,"sourceUnit":70927,"symbolAliases":[{"foreign":{"id":53810,"name":"GameTypes","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":70870,"src":"113:9:100","typeDescriptions":{}},"nameLocation":"-1:-1:-1"},{"foreign":{"id":53811,"name":"GameType","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":70720,"src":"124:8:100","typeDescriptions":{}},"nameLocation":"-1:-1:-1"}],"unitAlias":""},{"id":53958,"nodeType":"ContractDefinition","src":"306:1713:100","nodes":[{"id":53818,"nodeType":"FunctionDefinition","src":"331:52:100","nodes":[],"functionSelector":"452a9320","implemented":false,"kind":"function","modifiers":[],"name":"guardian","nameLocation":"340:8:100","parameters":{"id":53814,"nodeType":"ParameterList","parameters":[],"src":"348:2:100"},"returnParameters":{"id":53817,"nodeType":"ParameterList","parameters":[{"constant":false,"id":53816,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":53818,"src":"374:7:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":53815,"name":"address","nodeType":"ElementaryTypeName","src":"374:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"373:9:100"},"scope":53958,"stateMutability":"view","virtual":false,"visibility":"external"},{"id":53823,"nodeType":"FunctionDefinition","src":"388:52:100","nodes":[],"functionSelector":"724c184c","implemented":false,"kind":"function","modifiers":[],"name":"GUARDIAN","nameLocation":"397:8:100","parameters":{"id":53819,"nodeType":"ParameterList","parameters":[],"src":"405:2:100"},"returnParameters":{"id":53822,"nodeType":"ParameterList","parameters":[{"constant":false,"id":53821,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":53823,"src":"431:7:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":53820,"name":"address","nodeType":"ElementaryTypeName","src":"431:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"430:9:100"},"scope":53958,"stateMutability":"view","virtual":false,"visibility":"external"},{"id":53828,"nodeType":"FunctionDefinition","src":"445:56:100","nodes":[],"functionSelector":"33d7e2bd","implemented":false,"kind":"function","modifiers":[],"name":"systemConfig","nameLocation":"454:12:100","parameters":{"id":53824,"nodeType":"ParameterList","parameters":[],"src":"466:2:100"},"returnParameters":{"id":53827,"nodeType":"ParameterList","parameters":[{"constant":false,"id":53826,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":53828,"src":"492:7:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":53825,"name":"address","nodeType":"ElementaryTypeName","src":"492:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"491:9:100"},"scope":53958,"stateMutability":"view","virtual":false,"visibility":"external"},{"id":53833,"nodeType":"FunctionDefinition","src":"506:57:100","nodes":[],"functionSelector":"f0498750","implemented":false,"kind":"function","modifiers":[],"name":"SYSTEM_CONFIG","nameLocation":"515:13:100","parameters":{"id":53829,"nodeType":"ParameterList","parameters":[],"src":"528:2:100"},"returnParameters":{"id":53832,"nodeType":"ParameterList","parameters":[{"constant":false,"id":53831,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":53833,"src":"554:7:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":53830,"name":"address","nodeType":"ElementaryTypeName","src":"554:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"553:9:100"},"scope":53958,"stateMutability":"view","virtual":false,"visibility":"external"},{"id":53838,"nodeType":"FunctionDefinition","src":"568:62:100","nodes":[],"functionSelector":"f2b4e617","implemented":false,"kind":"function","modifiers":[],"name":"disputeGameFactory","nameLocation":"577:18:100","parameters":{"id":53834,"nodeType":"ParameterList","parameters":[],"src":"595:2:100"},"returnParameters":{"id":53837,"nodeType":"ParameterList","parameters":[{"constant":false,"id":53836,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":53838,"src":"621:7:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":53835,"name":"address","nodeType":"ElementaryTypeName","src":"621:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"620:9:100"},"scope":53958,"stateMutability":"view","virtual":false,"visibility":"external"},{"id":53843,"nodeType":"FunctionDefinition","src":"635:54:100","nodes":[],"functionSelector":"b682c444","implemented":false,"kind":"function","modifiers":[],"name":"ethLockbox","nameLocation":"644:10:100","parameters":{"id":53839,"nodeType":"ParameterList","parameters":[],"src":"654:2:100"},"returnParameters":{"id":53842,"nodeType":"ParameterList","parameters":[{"constant":false,"id":53841,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":53843,"src":"680:7:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":53840,"name":"address","nodeType":"ElementaryTypeName","src":"680:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"679:9:100"},"scope":53958,"stateMutability":"view","virtual":false,"visibility":"external"},{"id":53848,"nodeType":"FunctionDefinition","src":"694:60:100","nodes":[],"functionSelector":"35e80ab3","implemented":false,"kind":"function","modifiers":[],"name":"superchainConfig","nameLocation":"703:16:100","parameters":{"id":53844,"nodeType":"ParameterList","parameters":[],"src":"719:2:100"},"returnParameters":{"id":53847,"nodeType":"ParameterList","parameters":[{"constant":false,"id":53846,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":53848,"src":"745:7:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":53845,"name":"address","nodeType":"ElementaryTypeName","src":"745:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"744:9:100"},"scope":53958,"stateMutability":"view","virtual":false,"visibility":"external"},{"id":53853,"nodeType":"FunctionDefinition","src":"759:53:100","nodes":[],"functionSelector":"3cb747bf","implemented":false,"kind":"function","modifiers":[],"name":"messenger","nameLocation":"768:9:100","parameters":{"id":53849,"nodeType":"ParameterList","parameters":[],"src":"777:2:100"},"returnParameters":{"id":53852,"nodeType":"ParameterList","parameters":[{"constant":false,"id":53851,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":53853,"src":"803:7:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":53850,"name":"address","nodeType":"ElementaryTypeName","src":"803:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"802:9:100"},"scope":53958,"stateMutability":"view","virtual":false,"visibility":"external"},{"id":53858,"nodeType":"FunctionDefinition","src":"817:58:100","nodes":[],"functionSelector":"3ab76e9f","implemented":false,"kind":"function","modifiers":[],"name":"addressManager","nameLocation":"826:14:100","parameters":{"id":53854,"nodeType":"ParameterList","parameters":[],"src":"840:2:100"},"returnParameters":{"id":53857,"nodeType":"ParameterList","parameters":[{"constant":false,"id":53856,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":53858,"src":"866:7:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":53855,"name":"address","nodeType":"ElementaryTypeName","src":"866:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"865:9:100"},"scope":53958,"stateMutability":"view","virtual":false,"visibility":"external"},{"id":53863,"nodeType":"FunctionDefinition","src":"880:50:100","nodes":[],"functionSelector":"0ff754ea","implemented":false,"kind":"function","modifiers":[],"name":"PORTAL","nameLocation":"889:6:100","parameters":{"id":53859,"nodeType":"ParameterList","parameters":[],"src":"895:2:100"},"returnParameters":{"id":53862,"nodeType":"ParameterList","parameters":[{"constant":false,"id":53861,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":53863,"src":"921:7:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":53860,"name":"address","nodeType":"ElementaryTypeName","src":"921:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"920:9:100"},"scope":53958,"stateMutability":"view","virtual":false,"visibility":"external"},{"id":53868,"nodeType":"FunctionDefinition","src":"935:50:100","nodes":[],"functionSelector":"6425666b","implemented":false,"kind":"function","modifiers":[],"name":"portal","nameLocation":"944:6:100","parameters":{"id":53864,"nodeType":"ParameterList","parameters":[],"src":"950:2:100"},"returnParameters":{"id":53867,"nodeType":"ParameterList","parameters":[{"constant":false,"id":53866,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":53868,"src":"976:7:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":53865,"name":"address","nodeType":"ElementaryTypeName","src":"976:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"975:9:100"},"scope":53958,"stateMutability":"view","virtual":false,"visibility":"external"},{"id":53873,"nodeType":"FunctionDefinition","src":"990:58:100","nodes":[],"functionSelector":"c4e8ddfa","implemented":false,"kind":"function","modifiers":[],"name":"l1ERC721Bridge","nameLocation":"999:14:100","parameters":{"id":53869,"nodeType":"ParameterList","parameters":[],"src":"1013:2:100"},"returnParameters":{"id":53872,"nodeType":"ParameterList","parameters":[{"constant":false,"id":53871,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":53873,"src":"1039:7:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":53870,"name":"address","nodeType":"ElementaryTypeName","src":"1039:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"1038:9:100"},"scope":53958,"stateMutability":"view","virtual":false,"visibility":"external"},{"id":53878,"nodeType":"FunctionDefinition","src":"1053:72:100","nodes":[],"functionSelector":"9b7d7f0a","implemented":false,"kind":"function","modifiers":[],"name":"optimismMintableERC20Factory","nameLocation":"1062:28:100","parameters":{"id":53874,"nodeType":"ParameterList","parameters":[],"src":"1090:2:100"},"returnParameters":{"id":53877,"nodeType":"ParameterList","parameters":[{"constant":false,"id":53876,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":53878,"src":"1116:7:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":53875,"name":"address","nodeType":"ElementaryTypeName","src":"1116:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"1115:9:100"},"scope":53958,"stateMutability":"view","virtual":false,"visibility":"external"},{"id":53886,"nodeType":"FunctionDefinition","src":"1130:71:100","nodes":[],"functionSelector":"1b685b9e","implemented":false,"kind":"function","modifiers":[],"name":"gameImpls","nameLocation":"1139:9:100","parameters":{"id":53882,"nodeType":"ParameterList","parameters":[{"constant":false,"id":53881,"mutability":"mutable","name":"_gameType","nameLocation":"1158:9:100","nodeType":"VariableDeclaration","scope":53886,"src":"1149:18:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_userDefinedValueType$_GameType_$70720","typeString":"GameType"},"typeName":{"id":53880,"nodeType":"UserDefinedTypeName","pathNode":{"id":53879,"name":"GameType","nameLocations":["1149:8:100"],"nodeType":"IdentifierPath","referencedDeclaration":70720,"src":"1149:8:100"},"referencedDeclaration":70720,"src":"1149:8:100","typeDescriptions":{"typeIdentifier":"t_userDefinedValueType$_GameType_$70720","typeString":"GameType"}},"visibility":"internal"}],"src":"1148:20:100"},"returnParameters":{"id":53885,"nodeType":"ParameterList","parameters":[{"constant":false,"id":53884,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":53886,"src":"1192:7:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":53883,"name":"address","nodeType":"ElementaryTypeName","src":"1192:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"1191:9:100"},"scope":53958,"stateMutability":"view","virtual":false,"visibility":"external"},{"id":53892,"nodeType":"FunctionDefinition","src":"1206:62:100","nodes":[],"functionSelector":"3c9f397c","implemented":false,"kind":"function","modifiers":[],"name":"respectedGameType","nameLocation":"1215:17:100","parameters":{"id":53887,"nodeType":"ParameterList","parameters":[],"src":"1232:2:100"},"returnParameters":{"id":53891,"nodeType":"ParameterList","parameters":[{"constant":false,"id":53890,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":53892,"src":"1258:8:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_userDefinedValueType$_GameType_$70720","typeString":"GameType"},"typeName":{"id":53889,"nodeType":"UserDefinedTypeName","pathNode":{"id":53888,"name":"GameType","nameLocations":["1258:8:100"],"nodeType":"IdentifierPath","referencedDeclaration":70720,"src":"1258:8:100"},"referencedDeclaration":70720,"src":"1258:8:100","typeDescriptions":{"typeIdentifier":"t_userDefinedValueType$_GameType_$70720","typeString":"GameType"}},"visibility":"internal"}],"src":"1257:10:100"},"scope":53958,"stateMutability":"view","virtual":false,"visibility":"external"},{"id":53897,"nodeType":"FunctionDefinition","src":"1273:63:100","nodes":[],"functionSelector":"5c0cba33","implemented":false,"kind":"function","modifiers":[],"name":"anchorStateRegistry","nameLocation":"1282:19:100","parameters":{"id":53893,"nodeType":"ParameterList","parameters":[],"src":"1301:2:100"},"returnParameters":{"id":53896,"nodeType":"ParameterList","parameters":[{"constant":false,"id":53895,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":53897,"src":"1327:7:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":53894,"name":"address","nodeType":"ElementaryTypeName","src":"1327:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"1326:9:100"},"scope":53958,"stateMutability":"view","virtual":false,"visibility":"external"},{"id":53902,"nodeType":"FunctionDefinition","src":"1341:53:100","nodes":[],"functionSelector":"001c2ff6","implemented":false,"kind":"function","modifiers":[],"name":"L2_ORACLE","nameLocation":"1350:9:100","parameters":{"id":53898,"nodeType":"ParameterList","parameters":[],"src":"1359:2:100"},"returnParameters":{"id":53901,"nodeType":"ParameterList","parameters":[{"constant":false,"id":53900,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":53902,"src":"1385:7:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":53899,"name":"address","nodeType":"ElementaryTypeName","src":"1385:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"1384:9:100"},"scope":53958,"stateMutability":"view","virtual":false,"visibility":"external"},{"id":53907,"nodeType":"FunctionDefinition","src":"1399:52:100","nodes":[],"functionSelector":"9b5f694a","implemented":false,"kind":"function","modifiers":[],"name":"l2Oracle","nameLocation":"1408:8:100","parameters":{"id":53903,"nodeType":"ParameterList","parameters":[],"src":"1416:2:100"},"returnParameters":{"id":53906,"nodeType":"ParameterList","parameters":[{"constant":false,"id":53905,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":53907,"src":"1442:7:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":53904,"name":"address","nodeType":"ElementaryTypeName","src":"1442:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"1441:9:100"},"scope":53958,"stateMutability":"view","virtual":false,"visibility":"external"},{"id":53912,"nodeType":"FunctionDefinition","src":"1456:46:100","nodes":[],"functionSelector":"3a768463","implemented":false,"kind":"function","modifiers":[],"name":"vm","nameLocation":"1465:2:100","parameters":{"id":53908,"nodeType":"ParameterList","parameters":[],"src":"1467:2:100"},"returnParameters":{"id":53911,"nodeType":"ParameterList","parameters":[{"constant":false,"id":53910,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":53912,"src":"1493:7:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":53909,"name":"address","nodeType":"ElementaryTypeName","src":"1493:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"1492:9:100"},"scope":53958,"stateMutability":"view","virtual":false,"visibility":"external"},{"id":53917,"nodeType":"FunctionDefinition","src":"1507:50:100","nodes":[],"functionSelector":"7dc0d1d0","implemented":false,"kind":"function","modifiers":[],"name":"oracle","nameLocation":"1516:6:100","parameters":{"id":53913,"nodeType":"ParameterList","parameters":[],"src":"1522:2:100"},"returnParameters":{"id":53916,"nodeType":"ParameterList","parameters":[{"constant":false,"id":53915,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":53917,"src":"1548:7:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":53914,"name":"address","nodeType":"ElementaryTypeName","src":"1548:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"1547:9:100"},"scope":53958,"stateMutability":"view","virtual":false,"visibility":"external"},{"id":53922,"nodeType":"FunctionDefinition","src":"1562:54:100","nodes":[],"functionSelector":"534db0e2","implemented":false,"kind":"function","modifiers":[],"name":"challenger","nameLocation":"1571:10:100","parameters":{"id":53918,"nodeType":"ParameterList","parameters":[],"src":"1581:2:100"},"returnParameters":{"id":53921,"nodeType":"ParameterList","parameters":[{"constant":false,"id":53920,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":53922,"src":"1607:7:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":53919,"name":"address","nodeType":"ElementaryTypeName","src":"1607:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"1606:9:100"},"scope":53958,"stateMutability":"view","virtual":false,"visibility":"external"},{"id":53927,"nodeType":"FunctionDefinition","src":"1621:52:100","nodes":[],"functionSelector":"a8e4fb90","implemented":false,"kind":"function","modifiers":[],"name":"proposer","nameLocation":"1630:8:100","parameters":{"id":53923,"nodeType":"ParameterList","parameters":[],"src":"1638:2:100"},"returnParameters":{"id":53926,"nodeType":"ParameterList","parameters":[{"constant":false,"id":53925,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":53927,"src":"1664:7:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":53924,"name":"address","nodeType":"ElementaryTypeName","src":"1664:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"1663:9:100"},"scope":53958,"stateMutability":"view","virtual":false,"visibility":"external"},{"id":53932,"nodeType":"FunctionDefinition","src":"1678:52:100","nodes":[],"functionSelector":"bffa7f0f","implemented":false,"kind":"function","modifiers":[],"name":"PROPOSER","nameLocation":"1687:8:100","parameters":{"id":53928,"nodeType":"ParameterList","parameters":[],"src":"1695:2:100"},"returnParameters":{"id":53931,"nodeType":"ParameterList","parameters":[{"constant":false,"id":53930,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":53932,"src":"1721:7:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":53929,"name":"address","nodeType":"ElementaryTypeName","src":"1721:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"1720:9:100"},"scope":53958,"stateMutability":"view","virtual":false,"visibility":"external"},{"id":53937,"nodeType":"FunctionDefinition","src":"1735:55:100","nodes":[],"functionSelector":"e81b2c6d","implemented":false,"kind":"function","modifiers":[],"name":"batcherHash","nameLocation":"1744:11:100","parameters":{"id":53933,"nodeType":"ParameterList","parameters":[],"src":"1755:2:100"},"returnParameters":{"id":53936,"nodeType":"ParameterList","parameters":[{"constant":false,"id":53935,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":53937,"src":"1781:7:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_bytes32","typeString":"bytes32"},"typeName":{"id":53934,"name":"bytes32","nodeType":"ElementaryTypeName","src":"1781:7:100","typeDescriptions":{"typeIdentifier":"t_bytes32","typeString":"bytes32"}},"visibility":"internal"}],"src":"1780:9:100"},"scope":53958,"stateMutability":"view","virtual":false,"visibility":"external"},{"id":53942,"nodeType":"FunctionDefinition","src":"1795:49:100","nodes":[],"functionSelector":"f851a440","implemented":false,"kind":"function","modifiers":[],"name":"admin","nameLocation":"1804:5:100","parameters":{"id":53938,"nodeType":"ParameterList","parameters":[],"src":"1809:2:100"},"returnParameters":{"id":53941,"nodeType":"ParameterList","parameters":[{"constant":false,"id":53940,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":53942,"src":"1835:7:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":53939,"name":"address","nodeType":"ElementaryTypeName","src":"1835:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"1834:9:100"},"scope":53958,"stateMutability":"view","virtual":false,"visibility":"external"},{"id":53947,"nodeType":"FunctionDefinition","src":"1849:49:100","nodes":[],"functionSelector":"8da5cb5b","implemented":false,"kind":"function","modifiers":[],"name":"owner","nameLocation":"1858:5:100","parameters":{"id":53943,"nodeType":"ParameterList","parameters":[],"src":"1863:2:100"},"returnParameters":{"id":53946,"nodeType":"ParameterList","parameters":[{"constant":false,"id":53945,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":53947,"src":"1889:7:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":53944,"name":"address","nodeType":"ElementaryTypeName","src":"1889:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"1888:9:100"},"scope":53958,"stateMutability":"view","virtual":false,"visibility":"external"},{"id":53952,"nodeType":"FunctionDefinition","src":"1903:61:100","nodes":[],"functionSelector":"1fd19ee1","implemented":false,"kind":"function","modifiers":[],"name":"unsafeBlockSigner","nameLocation":"1912:17:100","parameters":{"id":53948,"nodeType":"ParameterList","parameters":[],"src":"1929:2:100"},"returnParameters":{"id":53951,"nodeType":"ParameterList","parameters":[{"constant":false,"id":53950,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":53952,"src":"1955:7:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":53949,"name":"address","nodeType":"ElementaryTypeName","src":"1955:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"1954:9:100"},"scope":53958,"stateMutability":"view","virtual":false,"visibility":"external"},{"id":53957,"nodeType":"FunctionDefinition","src":"1969:48:100","nodes":[],"functionSelector":"3fc8cef3","implemented":false,"kind":"function","modifiers":[],"name":"weth","nameLocation":"1978:4:100","parameters":{"id":53953,"nodeType":"ParameterList","parameters":[],"src":"1982:2:100"},"returnParameters":{"id":53956,"nodeType":"ParameterList","parameters":[{"constant":false,"id":53955,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":53957,"src":"2008:7:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":53954,"name":"address","nodeType":"ElementaryTypeName","src":"2008:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"2007:9:100"},"scope":53958,"stateMutability":"view","virtual":false,"visibility":"external"}],"abstract":false,"baseContracts":[],"canonicalName":"IFetcher","contractDependencies":[],"contractKind":"interface","documentation":{"id":53813,"nodeType":"StructuredDocumentation","src":"170:136:100","text":"@notice Contains getters for arbitrary methods from all L1 contracts, including legacy getters\n that have since been deprecated."},"fullyImplemented":false,"linearizedBaseContracts":[53958],"name":"IFetcher","nameLocation":"316:8:100","scope":56019,"usedErrors":[],"usedEvents":[]},{"id":54041,"nodeType":"ContractDefinition","src":"2021:934:100","nodes":[{"id":53960,"nodeType":"VariableDeclaration","src":"2056:35:100","nodes":[],"constant":false,"mutability":"mutable","name":"_systemConfigProxy","nameLocation":"2073:18:100","scope":54041,"stateVariable":true,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":53959,"name":"address","nodeType":"ElementaryTypeName","src":"2056:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"},{"id":53962,"nodeType":"VariableDeclaration","src":"2097:39:100","nodes":[],"constant":false,"mutability":"mutable","name":"_l1StandardBridgeProxy","nameLocation":"2114:22:100","scope":54041,"stateVariable":true,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":53961,"name":"address","nodeType":"ElementaryTypeName","src":"2097:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"},{"id":54004,"nodeType":"FunctionDefinition","src":"2143:378:100","nodes":[],"body":{"id":54003,"nodeType":"Block","src":"2191:330:100","nodes":[],"statements":[{"expression":{"arguments":[{"commonType":{"typeIdentifier":"t_address","typeString":"address"},"id":53975,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftExpression":{"id":53970,"name":"_addr","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":53966,"src":"2209:5:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"BinaryOperation","operator":"!=","rightExpression":{"arguments":[{"hexValue":"30","id":53973,"isConstant":false,"isLValue":false,"isPure":true,"kind":"number","lValueRequested":false,"nodeType":"Literal","src":"2226:1:100","typeDescriptions":{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"},"value":"0"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"}],"id":53972,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"nodeType":"ElementaryTypeNameExpression","src":"2218:7:100","typeDescriptions":{"typeIdentifier":"t_type$_t_address_$","typeString":"type(address)"},"typeName":{"id":53971,"name":"address","nodeType":"ElementaryTypeName","src":"2218:7:100","typeDescriptions":{}}},"id":53974,"isConstant":false,"isLValue":false,"isPure":true,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"2218:10:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"src":"2209:19:100","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},{"hexValue":"4665746368436861696e496e666f496e7075743a2063616e6e6f7420736574207a65726f2061646472657373","id":53976,"isConstant":false,"isLValue":false,"isPure":true,"kind":"string","lValueRequested":false,"nodeType":"Literal","src":"2230:46:100","typeDescriptions":{"typeIdentifier":"t_stringliteral_0336126ace187312d69da4c7cf05307af6a6596e8c75de2974f56108baf24145","typeString":"literal_string \"FetchChainInfoInput: cannot set zero address\""},"value":"FetchChainInfoInput: cannot set zero address"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_bool","typeString":"bool"},{"typeIdentifier":"t_stringliteral_0336126ace187312d69da4c7cf05307af6a6596e8c75de2974f56108baf24145","typeString":"literal_string \"FetchChainInfoInput: cannot set zero address\""}],"id":53969,"name":"require","nodeType":"Identifier","overloadedDeclarations":[-18,-18,-18],"referencedDeclaration":-18,"src":"2201:7:100","typeDescriptions":{"typeIdentifier":"t_function_require_pure$_t_bool_$_t_string_memory_ptr_$returns$__$","typeString":"function (bool,string memory) pure"}},"id":53977,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"2201:76:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":53978,"nodeType":"ExpressionStatement","src":"2201:76:100"},{"condition":{"commonType":{"typeIdentifier":"t_bytes4","typeString":"bytes4"},"id":53983,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftExpression":{"id":53979,"name":"_sel","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":53964,"src":"2291:4:100","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},"nodeType":"BinaryOperation","operator":"==","rightExpression":{"expression":{"expression":{"id":53980,"name":"this","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":-28,"src":"2299:4:100","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoInput_$54041","typeString":"contract FetchChainInfoInput"}},"id":53981,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"2304:17:100","memberName":"systemConfigProxy","nodeType":"MemberAccess","referencedDeclaration":54022,"src":"2299:22:100","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":53982,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"memberLocation":"2322:8:100","memberName":"selector","nodeType":"MemberAccess","src":"2299:31:100","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},"src":"2291:39:100","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},"falseBody":{"condition":{"commonType":{"typeIdentifier":"t_bytes4","typeString":"bytes4"},"id":53992,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftExpression":{"id":53988,"name":"_sel","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":53964,"src":"2377:4:100","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},"nodeType":"BinaryOperation","operator":"==","rightExpression":{"expression":{"expression":{"id":53989,"name":"this","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":-28,"src":"2385:4:100","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoInput_$54041","typeString":"contract FetchChainInfoInput"}},"id":53990,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"2390:21:100","memberName":"l1StandardBridgeProxy","nodeType":"MemberAccess","referencedDeclaration":54040,"src":"2385:26:100","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":53991,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"memberLocation":"2412:8:100","memberName":"selector","nodeType":"MemberAccess","src":"2385:35:100","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},"src":"2377:43:100","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},"falseBody":{"expression":{"arguments":[{"hexValue":"4665746368436861696e496e666f496e7075743a20756e6b6e6f776e2073656c6563746f72","id":53998,"isConstant":false,"isLValue":false,"isPure":true,"kind":"string","lValueRequested":false,"nodeType":"Literal","src":"2474:39:100","typeDescriptions":{"typeIdentifier":"t_stringliteral_3ec062448196d68b2d186fadb5ffe52c72f0a2b929c9d178cd6e6612281f066b","typeString":"literal_string \"FetchChainInfoInput: unknown selector\""},"value":"FetchChainInfoInput: unknown selector"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_stringliteral_3ec062448196d68b2d186fadb5ffe52c72f0a2b929c9d178cd6e6612281f066b","typeString":"literal_string \"FetchChainInfoInput: unknown selector\""}],"id":53997,"name":"revert","nodeType":"Identifier","overloadedDeclarations":[-19,-19],"referencedDeclaration":-19,"src":"2467:6:100","typeDescriptions":{"typeIdentifier":"t_function_revert_pure$_t_string_memory_ptr_$returns$__$","typeString":"function (string memory) pure"}},"id":53999,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"2467:47:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":54000,"nodeType":"ExpressionStatement","src":"2467:47:100"},"id":54001,"nodeType":"IfStatement","src":"2373:141:100","trueBody":{"expression":{"id":53995,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftHandSide":{"id":53993,"name":"_l1StandardBridgeProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":53962,"src":"2422:22:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"Assignment","operator":"=","rightHandSide":{"id":53994,"name":"_addr","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":53966,"src":"2447:5:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"src":"2422:30:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"id":53996,"nodeType":"ExpressionStatement","src":"2422:30:100"}},"id":54002,"nodeType":"IfStatement","src":"2287:227:100","trueBody":{"expression":{"id":53986,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftHandSide":{"id":53984,"name":"_systemConfigProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":53960,"src":"2332:18:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"Assignment","operator":"=","rightHandSide":{"id":53985,"name":"_addr","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":53966,"src":"2353:5:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"src":"2332:26:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"id":53987,"nodeType":"ExpressionStatement","src":"2332:26:100"}}]},"functionSelector":"c3e39250","implemented":true,"kind":"function","modifiers":[],"name":"set","nameLocation":"2152:3:100","parameters":{"id":53967,"nodeType":"ParameterList","parameters":[{"constant":false,"id":53964,"mutability":"mutable","name":"_sel","nameLocation":"2163:4:100","nodeType":"VariableDeclaration","scope":54004,"src":"2156:11:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"},"typeName":{"id":53963,"name":"bytes4","nodeType":"ElementaryTypeName","src":"2156:6:100","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},"visibility":"internal"},{"constant":false,"id":53966,"mutability":"mutable","name":"_addr","nameLocation":"2177:5:100","nodeType":"VariableDeclaration","scope":54004,"src":"2169:13:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":53965,"name":"address","nodeType":"ElementaryTypeName","src":"2169:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"2155:28:100"},"returnParameters":{"id":53968,"nodeType":"ParameterList","parameters":[],"src":"2191:0:100"},"scope":54041,"stateMutability":"nonpayable","virtual":false,"visibility":"public"},{"id":54022,"nodeType":"FunctionDefinition","src":"2527:202:100","nodes":[],"body":{"id":54021,"nodeType":"Block","src":"2586:143:100","nodes":[],"statements":[{"expression":{"arguments":[{"commonType":{"typeIdentifier":"t_address","typeString":"address"},"id":54015,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftExpression":{"id":54010,"name":"_systemConfigProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":53960,"src":"2604:18:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"BinaryOperation","operator":"!=","rightExpression":{"arguments":[{"hexValue":"30","id":54013,"isConstant":false,"isLValue":false,"isPure":true,"kind":"number","lValueRequested":false,"nodeType":"Literal","src":"2634:1:100","typeDescriptions":{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"},"value":"0"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"}],"id":54012,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"nodeType":"ElementaryTypeNameExpression","src":"2626:7:100","typeDescriptions":{"typeIdentifier":"t_type$_t_address_$","typeString":"type(address)"},"typeName":{"id":54011,"name":"address","nodeType":"ElementaryTypeName","src":"2626:7:100","typeDescriptions":{}}},"id":54014,"isConstant":false,"isLValue":false,"isPure":true,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"2626:10:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"src":"2604:32:100","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},{"hexValue":"4665746368436861696e496e666f496e7075743a2073797374656d436f6e66696750726f7879206e6f7420736574","id":54016,"isConstant":false,"isLValue":false,"isPure":true,"kind":"string","lValueRequested":false,"nodeType":"Literal","src":"2638:48:100","typeDescriptions":{"typeIdentifier":"t_stringliteral_cefeeda9841ab81b734a3e4f7bf39aeeab7704e02e2040531bd67ea944e4d5d3","typeString":"literal_string \"FetchChainInfoInput: systemConfigProxy not set\""},"value":"FetchChainInfoInput: systemConfigProxy not set"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_bool","typeString":"bool"},{"typeIdentifier":"t_stringliteral_cefeeda9841ab81b734a3e4f7bf39aeeab7704e02e2040531bd67ea944e4d5d3","typeString":"literal_string \"FetchChainInfoInput: systemConfigProxy not set\""}],"id":54009,"name":"require","nodeType":"Identifier","overloadedDeclarations":[-18,-18,-18],"referencedDeclaration":-18,"src":"2596:7:100","typeDescriptions":{"typeIdentifier":"t_function_require_pure$_t_bool_$_t_string_memory_ptr_$returns$__$","typeString":"function (bool,string memory) pure"}},"id":54017,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"2596:91:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":54018,"nodeType":"ExpressionStatement","src":"2596:91:100"},{"expression":{"id":54019,"name":"_systemConfigProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":53960,"src":"2704:18:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"functionReturnParameters":54008,"id":54020,"nodeType":"Return","src":"2697:25:100"}]},"functionSelector":"c17db6e3","implemented":true,"kind":"function","modifiers":[],"name":"systemConfigProxy","nameLocation":"2536:17:100","parameters":{"id":54005,"nodeType":"ParameterList","parameters":[],"src":"2553:2:100"},"returnParameters":{"id":54008,"nodeType":"ParameterList","parameters":[{"constant":false,"id":54007,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":54022,"src":"2577:7:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":54006,"name":"address","nodeType":"ElementaryTypeName","src":"2577:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"2576:9:100"},"scope":54041,"stateMutability":"view","virtual":false,"visibility":"public"},{"id":54040,"nodeType":"FunctionDefinition","src":"2735:218:100","nodes":[],"body":{"id":54039,"nodeType":"Block","src":"2798:155:100","nodes":[],"statements":[{"expression":{"arguments":[{"commonType":{"typeIdentifier":"t_address","typeString":"address"},"id":54033,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftExpression":{"id":54028,"name":"_l1StandardBridgeProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":53962,"src":"2816:22:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"BinaryOperation","operator":"!=","rightExpression":{"arguments":[{"hexValue":"30","id":54031,"isConstant":false,"isLValue":false,"isPure":true,"kind":"number","lValueRequested":false,"nodeType":"Literal","src":"2850:1:100","typeDescriptions":{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"},"value":"0"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"}],"id":54030,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"nodeType":"ElementaryTypeNameExpression","src":"2842:7:100","typeDescriptions":{"typeIdentifier":"t_type$_t_address_$","typeString":"type(address)"},"typeName":{"id":54029,"name":"address","nodeType":"ElementaryTypeName","src":"2842:7:100","typeDescriptions":{}}},"id":54032,"isConstant":false,"isLValue":false,"isPure":true,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"2842:10:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"src":"2816:36:100","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},{"hexValue":"4665746368436861696e496e666f496e7075743a206c315374616e6461726442726964676550726f7879206e6f7420736574","id":54034,"isConstant":false,"isLValue":false,"isPure":true,"kind":"string","lValueRequested":false,"nodeType":"Literal","src":"2854:52:100","typeDescriptions":{"typeIdentifier":"t_stringliteral_be85b0ed3fc58e97f8b79e4d9fb1c191539515cae509acde6becd9338254d33b","typeString":"literal_string \"FetchChainInfoInput: l1StandardBridgeProxy not set\""},"value":"FetchChainInfoInput: l1StandardBridgeProxy not set"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_bool","typeString":"bool"},{"typeIdentifier":"t_stringliteral_be85b0ed3fc58e97f8b79e4d9fb1c191539515cae509acde6becd9338254d33b","typeString":"literal_string \"FetchChainInfoInput: l1StandardBridgeProxy not set\""}],"id":54027,"name":"require","nodeType":"Identifier","overloadedDeclarations":[-18,-18,-18],"referencedDeclaration":-18,"src":"2808:7:100","typeDescriptions":{"typeIdentifier":"t_function_require_pure$_t_bool_$_t_string_memory_ptr_$returns$__$","typeString":"function (bool,string memory) pure"}},"id":54035,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"2808:99:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":54036,"nodeType":"ExpressionStatement","src":"2808:99:100"},{"expression":{"id":54037,"name":"_l1StandardBridgeProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":53962,"src":"2924:22:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"functionReturnParameters":54026,"id":54038,"nodeType":"Return","src":"2917:29:100"}]},"functionSelector":"102b6069","implemented":true,"kind":"function","modifiers":[],"name":"l1StandardBridgeProxy","nameLocation":"2744:21:100","parameters":{"id":54023,"nodeType":"ParameterList","parameters":[],"src":"2765:2:100"},"returnParameters":{"id":54026,"nodeType":"ParameterList","parameters":[{"constant":false,"id":54025,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":54040,"src":"2789:7:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":54024,"name":"address","nodeType":"ElementaryTypeName","src":"2789:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"2788:9:100"},"scope":54041,"stateMutability":"view","virtual":false,"visibility":"public"}],"abstract":false,"baseContracts":[],"canonicalName":"FetchChainInfoInput","contractDependencies":[],"contractKind":"contract","fullyImplemented":true,"linearizedBaseContracts":[54041],"name":"FetchChainInfoInput","nameLocation":"2030:19:100","scope":56019,"usedErrors":[],"usedEvents":[]},{"id":54911,"nodeType":"ContractDefinition","src":"2957:10642:100","nodes":[{"id":54043,"nodeType":"VariableDeclaration","src":"3049:39:100","nodes":[],"constant":false,"mutability":"mutable","name":"_superchainConfigProxy","nameLocation":"3066:22:100","scope":54911,"stateVariable":true,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":54042,"name":"address","nodeType":"ElementaryTypeName","src":"3049:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"},{"id":54045,"nodeType":"VariableDeclaration","src":"3129:26:100","nodes":[],"constant":false,"mutability":"mutable","name":"_mipsImpl","nameLocation":"3146:9:100","scope":54911,"stateVariable":true,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":54044,"name":"address","nodeType":"ElementaryTypeName","src":"3129:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"},{"id":54047,"nodeType":"VariableDeclaration","src":"3161:36:100","nodes":[],"constant":false,"mutability":"mutable","name":"_preimageOracleImpl","nameLocation":"3178:19:100","scope":54911,"stateVariable":true,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":54046,"name":"address","nodeType":"ElementaryTypeName","src":"3161:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"},{"id":54049,"nodeType":"VariableDeclaration","src":"3230:36:100","nodes":[],"constant":false,"mutability":"mutable","name":"_addressManagerImpl","nameLocation":"3247:19:100","scope":54911,"stateVariable":true,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":54048,"name":"address","nodeType":"ElementaryTypeName","src":"3230:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"},{"id":54051,"nodeType":"VariableDeclaration","src":"3272:33:100","nodes":[],"constant":false,"mutability":"mutable","name":"_ethLockboxProxy","nameLocation":"3289:16:100","scope":54911,"stateVariable":true,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":54050,"name":"address","nodeType":"ElementaryTypeName","src":"3272:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"},{"id":54053,"nodeType":"VariableDeclaration","src":"3311:45:100","nodes":[],"constant":false,"mutability":"mutable","name":"_l1CrossDomainMessengerProxy","nameLocation":"3328:28:100","scope":54911,"stateVariable":true,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":54052,"name":"address","nodeType":"ElementaryTypeName","src":"3311:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"},{"id":54055,"nodeType":"VariableDeclaration","src":"3362:37:100","nodes":[],"constant":false,"mutability":"mutable","name":"_l1Erc721BridgeProxy","nameLocation":"3379:20:100","scope":54911,"stateVariable":true,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":54054,"name":"address","nodeType":"ElementaryTypeName","src":"3362:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"},{"id":54057,"nodeType":"VariableDeclaration","src":"3405:39:100","nodes":[],"constant":false,"mutability":"mutable","name":"_l1StandardBridgeProxy","nameLocation":"3422:22:100","scope":54911,"stateVariable":true,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":54056,"name":"address","nodeType":"ElementaryTypeName","src":"3405:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"},{"id":54059,"nodeType":"VariableDeclaration","src":"3450:37:100","nodes":[],"constant":false,"mutability":"mutable","name":"_l2OutputOracleProxy","nameLocation":"3467:20:100","scope":54911,"stateVariable":true,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":54058,"name":"address","nodeType":"ElementaryTypeName","src":"3450:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"},{"id":54061,"nodeType":"VariableDeclaration","src":"3493:51:100","nodes":[],"constant":false,"mutability":"mutable","name":"_optimismMintableErc20FactoryProxy","nameLocation":"3510:34:100","scope":54911,"stateVariable":true,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":54060,"name":"address","nodeType":"ElementaryTypeName","src":"3493:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"},{"id":54063,"nodeType":"VariableDeclaration","src":"3550:37:100","nodes":[],"constant":false,"mutability":"mutable","name":"_optimismPortalProxy","nameLocation":"3567:20:100","scope":54911,"stateVariable":true,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":54062,"name":"address","nodeType":"ElementaryTypeName","src":"3550:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"},{"id":54065,"nodeType":"VariableDeclaration","src":"3593:35:100","nodes":[],"constant":false,"mutability":"mutable","name":"_systemConfigProxy","nameLocation":"3610:18:100","scope":54911,"stateVariable":true,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":54064,"name":"address","nodeType":"ElementaryTypeName","src":"3593:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"},{"id":54067,"nodeType":"VariableDeclaration","src":"3634:39:100","nodes":[],"constant":false,"mutability":"mutable","name":"_opChainProxyAdminImpl","nameLocation":"3651:22:100","scope":54911,"stateVariable":true,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":54066,"name":"address","nodeType":"ElementaryTypeName","src":"3634:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"},{"id":54069,"nodeType":"VariableDeclaration","src":"3679:42:100","nodes":[],"constant":false,"mutability":"mutable","name":"_anchorStateRegistryProxy","nameLocation":"3696:25:100","scope":54911,"stateVariable":true,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":54068,"name":"address","nodeType":"ElementaryTypeName","src":"3679:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"},{"id":54071,"nodeType":"VariableDeclaration","src":"3727:50:100","nodes":[],"constant":false,"mutability":"mutable","name":"_delayedWethPermissionedGameProxy","nameLocation":"3744:33:100","scope":54911,"stateVariable":true,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":54070,"name":"address","nodeType":"ElementaryTypeName","src":"3727:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"},{"id":54073,"nodeType":"VariableDeclaration","src":"3783:52:100","nodes":[],"constant":false,"mutability":"mutable","name":"_delayedWethPermissionlessGameProxy","nameLocation":"3800:35:100","scope":54911,"stateVariable":true,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":54072,"name":"address","nodeType":"ElementaryTypeName","src":"3783:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"},{"id":54075,"nodeType":"VariableDeclaration","src":"3841:41:100","nodes":[],"constant":false,"mutability":"mutable","name":"_disputeGameFactoryProxy","nameLocation":"3858:24:100","scope":54911,"stateVariable":true,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":54074,"name":"address","nodeType":"ElementaryTypeName","src":"3841:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"},{"id":54077,"nodeType":"VariableDeclaration","src":"3888:38:100","nodes":[],"constant":false,"mutability":"mutable","name":"_faultDisputeGameImpl","nameLocation":"3905:21:100","scope":54911,"stateVariable":true,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":54076,"name":"address","nodeType":"ElementaryTypeName","src":"3888:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"},{"id":54079,"nodeType":"VariableDeclaration","src":"3932:48:100","nodes":[],"constant":false,"mutability":"mutable","name":"_faultDisputeGameCannonKonaImpl","nameLocation":"3949:31:100","scope":54911,"stateVariable":true,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":54078,"name":"address","nodeType":"ElementaryTypeName","src":"3932:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"},{"id":54081,"nodeType":"VariableDeclaration","src":"3986:45:100","nodes":[],"constant":false,"mutability":"mutable","name":"_permissionedDisputeGameImpl","nameLocation":"4003:28:100","scope":54911,"stateVariable":true,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":54080,"name":"address","nodeType":"ElementaryTypeName","src":"3986:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"},{"id":54083,"nodeType":"VariableDeclaration","src":"4051:35:100","nodes":[],"constant":false,"mutability":"mutable","name":"_systemConfigOwner","nameLocation":"4068:18:100","scope":54911,"stateVariable":true,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":54082,"name":"address","nodeType":"ElementaryTypeName","src":"4051:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"},{"id":54085,"nodeType":"VariableDeclaration","src":"4092:40:100","nodes":[],"constant":false,"mutability":"mutable","name":"_opChainProxyAdminOwner","nameLocation":"4109:23:100","scope":54911,"stateVariable":true,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":54084,"name":"address","nodeType":"ElementaryTypeName","src":"4092:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"},{"id":54087,"nodeType":"VariableDeclaration","src":"4138:33:100","nodes":[],"constant":false,"mutability":"mutable","name":"_opChainGuardian","nameLocation":"4155:16:100","scope":54911,"stateVariable":true,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":54086,"name":"address","nodeType":"ElementaryTypeName","src":"4138:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"},{"id":54089,"nodeType":"VariableDeclaration","src":"4177:28:100","nodes":[],"constant":false,"mutability":"mutable","name":"_challenger","nameLocation":"4194:11:100","scope":54911,"stateVariable":true,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":54088,"name":"address","nodeType":"ElementaryTypeName","src":"4177:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"},{"id":54091,"nodeType":"VariableDeclaration","src":"4211:26:100","nodes":[],"constant":false,"mutability":"mutable","name":"_proposer","nameLocation":"4228:9:100","scope":54911,"stateVariable":true,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":54090,"name":"address","nodeType":"ElementaryTypeName","src":"4211:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"},{"id":54093,"nodeType":"VariableDeclaration","src":"4243:35:100","nodes":[],"constant":false,"mutability":"mutable","name":"_unsafeBlockSigner","nameLocation":"4260:18:100","scope":54911,"stateVariable":true,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":54092,"name":"address","nodeType":"ElementaryTypeName","src":"4243:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"},{"id":54095,"nodeType":"VariableDeclaration","src":"4284:32:100","nodes":[],"constant":false,"mutability":"mutable","name":"_batchSubmitter","nameLocation":"4301:15:100","scope":54911,"stateVariable":true,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":54094,"name":"address","nodeType":"ElementaryTypeName","src":"4284:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"},{"id":54097,"nodeType":"VariableDeclaration","src":"4349:27:100","nodes":[],"constant":false,"mutability":"mutable","name":"_permissioned","nameLocation":"4363:13:100","scope":54911,"stateVariable":true,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"},"typeName":{"id":54096,"name":"bool","nodeType":"ElementaryTypeName","src":"4349:4:100","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},"visibility":"internal"},{"id":54099,"nodeType":"VariableDeclaration","src":"4382:29:100","nodes":[],"constant":false,"mutability":"mutable","name":"_permissionless","nameLocation":"4396:15:100","scope":54911,"stateVariable":true,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"},"typeName":{"id":54098,"name":"bool","nodeType":"ElementaryTypeName","src":"4382:4:100","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},"visibility":"internal"},{"id":54102,"nodeType":"VariableDeclaration","src":"4417:36:100","nodes":[],"constant":false,"mutability":"mutable","name":"_respectedGameType","nameLocation":"4435:18:100","scope":54911,"stateVariable":true,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_userDefinedValueType$_GameType_$70720","typeString":"GameType"},"typeName":{"id":54101,"nodeType":"UserDefinedTypeName","pathNode":{"id":54100,"name":"GameType","nameLocations":["4417:8:100"],"nodeType":"IdentifierPath","referencedDeclaration":70720,"src":"4417:8:100"},"referencedDeclaration":70720,"src":"4417:8:100","typeDescriptions":{"typeIdentifier":"t_userDefinedValueType$_GameType_$70720","typeString":"GameType"}},"visibility":"internal"},{"id":54384,"nodeType":"FunctionDefinition","src":"4460:2746:100","nodes":[],"body":{"id":54383,"nodeType":"Block","src":"4508:2698:100","nodes":[],"statements":[{"condition":{"commonType":{"typeIdentifier":"t_bytes4","typeString":"bytes4"},"id":54113,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftExpression":{"id":54109,"name":"_sel","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54104,"src":"4553:4:100","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},"nodeType":"BinaryOperation","operator":"==","rightExpression":{"expression":{"expression":{"id":54110,"name":"this","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":-28,"src":"4561:4:100","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$54911","typeString":"contract FetchChainInfoOutput"}},"id":54111,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"4566:21:100","memberName":"superchainConfigProxy","nodeType":"MemberAccess","referencedDeclaration":54627,"src":"4561:26:100","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":54112,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"memberLocation":"4588:8:100","memberName":"selector","nodeType":"MemberAccess","src":"4561:35:100","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},"src":"4553:43:100","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},"falseBody":{"condition":{"commonType":{"typeIdentifier":"t_bytes4","typeString":"bytes4"},"id":54122,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftExpression":{"id":54118,"name":"_sel","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54104,"src":"4686:4:100","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},"nodeType":"BinaryOperation","operator":"==","rightExpression":{"expression":{"expression":{"id":54119,"name":"this","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":-28,"src":"4694:4:100","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$54911","typeString":"contract FetchChainInfoOutput"}},"id":54120,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"4699:8:100","memberName":"mipsImpl","nodeType":"MemberAccess","referencedDeclaration":54723,"src":"4694:13:100","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":54121,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"memberLocation":"4708:8:100","memberName":"selector","nodeType":"MemberAccess","src":"4694:22:100","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},"src":"4686:30:100","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},"falseBody":{"condition":{"commonType":{"typeIdentifier":"t_bytes4","typeString":"bytes4"},"id":54131,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftExpression":{"id":54127,"name":"_sel","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54104,"src":"4754:4:100","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},"nodeType":"BinaryOperation","operator":"==","rightExpression":{"expression":{"expression":{"id":54128,"name":"this","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":-28,"src":"4762:4:100","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$54911","typeString":"contract FetchChainInfoOutput"}},"id":54129,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"4767:18:100","memberName":"preimageOracleImpl","nodeType":"MemberAccess","referencedDeclaration":54759,"src":"4762:23:100","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":54130,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"memberLocation":"4786:8:100","memberName":"selector","nodeType":"MemberAccess","src":"4762:32:100","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},"src":"4754:40:100","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},"falseBody":{"condition":{"commonType":{"typeIdentifier":"t_bytes4","typeString":"bytes4"},"id":54140,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftExpression":{"id":54136,"name":"_sel","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54104,"src":"4873:4:100","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},"nodeType":"BinaryOperation","operator":"==","rightExpression":{"expression":{"expression":{"id":54137,"name":"this","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":-28,"src":"4881:4:100","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$54911","typeString":"contract FetchChainInfoOutput"}},"id":54138,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"4886:18:100","memberName":"addressManagerImpl","nodeType":"MemberAccess","referencedDeclaration":54457,"src":"4881:23:100","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":54139,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"memberLocation":"4905:8:100","memberName":"selector","nodeType":"MemberAccess","src":"4881:32:100","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},"src":"4873:40:100","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},"falseBody":{"condition":{"commonType":{"typeIdentifier":"t_bytes4","typeString":"bytes4"},"id":54149,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftExpression":{"id":54145,"name":"_sel","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54104,"src":"4961:4:100","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},"nodeType":"BinaryOperation","operator":"==","rightExpression":{"expression":{"expression":{"id":54146,"name":"this","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":-28,"src":"4969:4:100","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$54911","typeString":"contract FetchChainInfoOutput"}},"id":54147,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"4974:15:100","memberName":"ethLockboxProxy","nodeType":"MemberAccess","referencedDeclaration":54465,"src":"4969:20:100","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":54148,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"memberLocation":"4990:8:100","memberName":"selector","nodeType":"MemberAccess","src":"4969:29:100","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},"src":"4961:37:100","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},"falseBody":{"condition":{"commonType":{"typeIdentifier":"t_bytes4","typeString":"bytes4"},"id":54158,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftExpression":{"id":54154,"name":"_sel","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54104,"src":"5043:4:100","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},"nodeType":"BinaryOperation","operator":"==","rightExpression":{"expression":{"expression":{"id":54155,"name":"this","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":-28,"src":"5051:4:100","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$54911","typeString":"contract FetchChainInfoOutput"}},"id":54156,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"5056:27:100","memberName":"l1CrossDomainMessengerProxy","nodeType":"MemberAccess","referencedDeclaration":54483,"src":"5051:32:100","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":54157,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"memberLocation":"5084:8:100","memberName":"selector","nodeType":"MemberAccess","src":"5051:41:100","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},"src":"5043:49:100","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},"falseBody":{"condition":{"commonType":{"typeIdentifier":"t_bytes4","typeString":"bytes4"},"id":54167,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftExpression":{"id":54163,"name":"_sel","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54104,"src":"5149:4:100","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},"nodeType":"BinaryOperation","operator":"==","rightExpression":{"expression":{"expression":{"id":54164,"name":"this","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":-28,"src":"5157:4:100","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$54911","typeString":"contract FetchChainInfoOutput"}},"id":54165,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"5162:19:100","memberName":"l1Erc721BridgeProxy","nodeType":"MemberAccess","referencedDeclaration":54501,"src":"5157:24:100","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":54166,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"memberLocation":"5182:8:100","memberName":"selector","nodeType":"MemberAccess","src":"5157:33:100","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},"src":"5149:41:100","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},"falseBody":{"condition":{"commonType":{"typeIdentifier":"t_bytes4","typeString":"bytes4"},"id":54176,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftExpression":{"id":54172,"name":"_sel","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54104,"src":"5239:4:100","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},"nodeType":"BinaryOperation","operator":"==","rightExpression":{"expression":{"expression":{"id":54173,"name":"this","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":-28,"src":"5247:4:100","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$54911","typeString":"contract FetchChainInfoOutput"}},"id":54174,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"5252:21:100","memberName":"l1StandardBridgeProxy","nodeType":"MemberAccess","referencedDeclaration":54519,"src":"5247:26:100","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":54175,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"memberLocation":"5274:8:100","memberName":"selector","nodeType":"MemberAccess","src":"5247:35:100","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},"src":"5239:43:100","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},"falseBody":{"condition":{"commonType":{"typeIdentifier":"t_bytes4","typeString":"bytes4"},"id":54185,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftExpression":{"id":54181,"name":"_sel","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54104,"src":"5333:4:100","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},"nodeType":"BinaryOperation","operator":"==","rightExpression":{"expression":{"expression":{"id":54182,"name":"this","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":-28,"src":"5341:4:100","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$54911","typeString":"contract FetchChainInfoOutput"}},"id":54183,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"5346:19:100","memberName":"l2OutputOracleProxy","nodeType":"MemberAccess","referencedDeclaration":54537,"src":"5341:24:100","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":54184,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"memberLocation":"5366:8:100","memberName":"selector","nodeType":"MemberAccess","src":"5341:33:100","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},"src":"5333:41:100","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},"falseBody":{"condition":{"commonType":{"typeIdentifier":"t_bytes4","typeString":"bytes4"},"id":54194,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftExpression":{"id":54190,"name":"_sel","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54104,"src":"5423:4:100","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},"nodeType":"BinaryOperation","operator":"==","rightExpression":{"expression":{"expression":{"id":54191,"name":"this","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":-28,"src":"5431:4:100","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$54911","typeString":"contract FetchChainInfoOutput"}},"id":54192,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"5436:33:100","memberName":"optimismMintableErc20FactoryProxy","nodeType":"MemberAccess","referencedDeclaration":54555,"src":"5431:38:100","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":54193,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"memberLocation":"5470:8:100","memberName":"selector","nodeType":"MemberAccess","src":"5431:47:100","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},"src":"5423:55:100","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},"falseBody":{"condition":{"commonType":{"typeIdentifier":"t_bytes4","typeString":"bytes4"},"id":54203,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftExpression":{"id":54199,"name":"_sel","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54104,"src":"5541:4:100","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},"nodeType":"BinaryOperation","operator":"==","rightExpression":{"expression":{"expression":{"id":54200,"name":"this","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":-28,"src":"5549:4:100","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$54911","typeString":"contract FetchChainInfoOutput"}},"id":54201,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"5554:19:100","memberName":"optimismPortalProxy","nodeType":"MemberAccess","referencedDeclaration":54573,"src":"5549:24:100","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":54202,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"memberLocation":"5574:8:100","memberName":"selector","nodeType":"MemberAccess","src":"5549:33:100","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},"src":"5541:41:100","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},"falseBody":{"condition":{"commonType":{"typeIdentifier":"t_bytes4","typeString":"bytes4"},"id":54212,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftExpression":{"id":54208,"name":"_sel","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54104,"src":"5631:4:100","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},"nodeType":"BinaryOperation","operator":"==","rightExpression":{"expression":{"expression":{"id":54209,"name":"this","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":-28,"src":"5639:4:100","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$54911","typeString":"contract FetchChainInfoOutput"}},"id":54210,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"5644:17:100","memberName":"systemConfigProxy","nodeType":"MemberAccess","referencedDeclaration":54591,"src":"5639:22:100","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":54211,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"memberLocation":"5662:8:100","memberName":"selector","nodeType":"MemberAccess","src":"5639:31:100","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},"src":"5631:39:100","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},"falseBody":{"condition":{"commonType":{"typeIdentifier":"t_bytes4","typeString":"bytes4"},"id":54221,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftExpression":{"id":54217,"name":"_sel","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54104,"src":"5717:4:100","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},"nodeType":"BinaryOperation","operator":"==","rightExpression":{"expression":{"expression":{"id":54218,"name":"this","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":-28,"src":"5725:4:100","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$54911","typeString":"contract FetchChainInfoOutput"}},"id":54219,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"5730:21:100","memberName":"opChainProxyAdminImpl","nodeType":"MemberAccess","referencedDeclaration":54609,"src":"5725:26:100","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":54220,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"memberLocation":"5752:8:100","memberName":"selector","nodeType":"MemberAccess","src":"5725:35:100","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},"src":"5717:43:100","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},"falseBody":{"condition":{"commonType":{"typeIdentifier":"t_bytes4","typeString":"bytes4"},"id":54230,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftExpression":{"id":54226,"name":"_sel","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54104,"src":"5811:4:100","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},"nodeType":"BinaryOperation","operator":"==","rightExpression":{"expression":{"expression":{"id":54227,"name":"this","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":-28,"src":"5819:4:100","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$54911","typeString":"contract FetchChainInfoOutput"}},"id":54228,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"5824:24:100","memberName":"anchorStateRegistryProxy","nodeType":"MemberAccess","referencedDeclaration":54645,"src":"5819:29:100","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":54229,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"memberLocation":"5849:8:100","memberName":"selector","nodeType":"MemberAccess","src":"5819:38:100","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},"src":"5811:46:100","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},"falseBody":{"condition":{"commonType":{"typeIdentifier":"t_bytes4","typeString":"bytes4"},"id":54239,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftExpression":{"id":54235,"name":"_sel","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54104,"src":"5911:4:100","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},"nodeType":"BinaryOperation","operator":"==","rightExpression":{"expression":{"expression":{"id":54236,"name":"this","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":-28,"src":"5919:4:100","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$54911","typeString":"contract FetchChainInfoOutput"}},"id":54237,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"5924:32:100","memberName":"delayedWethPermissionedGameProxy","nodeType":"MemberAccess","referencedDeclaration":54653,"src":"5919:37:100","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":54238,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"memberLocation":"5957:8:100","memberName":"selector","nodeType":"MemberAccess","src":"5919:46:100","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},"src":"5911:54:100","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},"falseBody":{"condition":{"commonType":{"typeIdentifier":"t_bytes4","typeString":"bytes4"},"id":54248,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftExpression":{"id":54244,"name":"_sel","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54104,"src":"6027:4:100","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},"nodeType":"BinaryOperation","operator":"==","rightExpression":{"expression":{"expression":{"id":54245,"name":"this","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":-28,"src":"6035:4:100","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$54911","typeString":"contract FetchChainInfoOutput"}},"id":54246,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"6040:34:100","memberName":"delayedWethPermissionlessGameProxy","nodeType":"MemberAccess","referencedDeclaration":54661,"src":"6035:39:100","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":54247,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"memberLocation":"6075:8:100","memberName":"selector","nodeType":"MemberAccess","src":"6035:48:100","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},"src":"6027:56:100","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},"falseBody":{"condition":{"commonType":{"typeIdentifier":"t_bytes4","typeString":"bytes4"},"id":54257,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftExpression":{"id":54253,"name":"_sel","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54104,"src":"6147:4:100","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},"nodeType":"BinaryOperation","operator":"==","rightExpression":{"expression":{"expression":{"id":54254,"name":"this","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":-28,"src":"6155:4:100","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$54911","typeString":"contract FetchChainInfoOutput"}},"id":54255,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"6160:23:100","memberName":"disputeGameFactoryProxy","nodeType":"MemberAccess","referencedDeclaration":54669,"src":"6155:28:100","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":54256,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"memberLocation":"6184:8:100","memberName":"selector","nodeType":"MemberAccess","src":"6155:37:100","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},"src":"6147:45:100","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},"falseBody":{"condition":{"commonType":{"typeIdentifier":"t_bytes4","typeString":"bytes4"},"id":54266,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftExpression":{"id":54262,"name":"_sel","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54104,"src":"6245:4:100","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},"nodeType":"BinaryOperation","operator":"==","rightExpression":{"expression":{"expression":{"id":54263,"name":"this","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":-28,"src":"6253:4:100","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$54911","typeString":"contract FetchChainInfoOutput"}},"id":54264,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"6258:20:100","memberName":"faultDisputeGameImpl","nodeType":"MemberAccess","referencedDeclaration":54687,"src":"6253:25:100","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":54265,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"memberLocation":"6279:8:100","memberName":"selector","nodeType":"MemberAccess","src":"6253:34:100","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},"src":"6245:42:100","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},"falseBody":{"condition":{"commonType":{"typeIdentifier":"t_bytes4","typeString":"bytes4"},"id":54275,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftExpression":{"id":54271,"name":"_sel","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54104,"src":"6337:4:100","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},"nodeType":"BinaryOperation","operator":"==","rightExpression":{"expression":{"expression":{"id":54272,"name":"this","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":-28,"src":"6345:4:100","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$54911","typeString":"contract FetchChainInfoOutput"}},"id":54273,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"6350:30:100","memberName":"faultDisputeGameCannonKonaImpl","nodeType":"MemberAccess","referencedDeclaration":54705,"src":"6345:35:100","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":54274,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"memberLocation":"6381:8:100","memberName":"selector","nodeType":"MemberAccess","src":"6345:44:100","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},"src":"6337:52:100","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},"falseBody":{"condition":{"commonType":{"typeIdentifier":"t_bytes4","typeString":"bytes4"},"id":54284,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftExpression":{"id":54280,"name":"_sel","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54104,"src":"6449:4:100","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},"nodeType":"BinaryOperation","operator":"==","rightExpression":{"expression":{"expression":{"id":54281,"name":"this","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":-28,"src":"6457:4:100","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$54911","typeString":"contract FetchChainInfoOutput"}},"id":54282,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"6462:27:100","memberName":"permissionedDisputeGameImpl","nodeType":"MemberAccess","referencedDeclaration":54741,"src":"6457:32:100","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":54283,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"memberLocation":"6490:8:100","memberName":"selector","nodeType":"MemberAccess","src":"6457:41:100","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},"src":"6449:49:100","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},"falseBody":{"condition":{"commonType":{"typeIdentifier":"t_bytes4","typeString":"bytes4"},"id":54293,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftExpression":{"id":54289,"name":"_sel","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54104,"src":"6572:4:100","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},"nodeType":"BinaryOperation","operator":"==","rightExpression":{"expression":{"expression":{"id":54290,"name":"this","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":-28,"src":"6580:4:100","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$54911","typeString":"contract FetchChainInfoOutput"}},"id":54291,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"6585:17:100","memberName":"systemConfigOwner","nodeType":"MemberAccess","referencedDeclaration":54777,"src":"6580:22:100","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":54292,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"memberLocation":"6603:8:100","memberName":"selector","nodeType":"MemberAccess","src":"6580:31:100","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},"src":"6572:39:100","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},"falseBody":{"condition":{"commonType":{"typeIdentifier":"t_bytes4","typeString":"bytes4"},"id":54302,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftExpression":{"id":54298,"name":"_sel","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54104,"src":"6658:4:100","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},"nodeType":"BinaryOperation","operator":"==","rightExpression":{"expression":{"expression":{"id":54299,"name":"this","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":-28,"src":"6666:4:100","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$54911","typeString":"contract FetchChainInfoOutput"}},"id":54300,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"6671:22:100","memberName":"opChainProxyAdminOwner","nodeType":"MemberAccess","referencedDeclaration":54795,"src":"6666:27:100","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":54301,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"memberLocation":"6694:8:100","memberName":"selector","nodeType":"MemberAccess","src":"6666:36:100","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},"src":"6658:44:100","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},"falseBody":{"condition":{"commonType":{"typeIdentifier":"t_bytes4","typeString":"bytes4"},"id":54311,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftExpression":{"id":54307,"name":"_sel","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54104,"src":"6754:4:100","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},"nodeType":"BinaryOperation","operator":"==","rightExpression":{"expression":{"expression":{"id":54308,"name":"this","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":-28,"src":"6762:4:100","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$54911","typeString":"contract FetchChainInfoOutput"}},"id":54309,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"6767:15:100","memberName":"opChainGuardian","nodeType":"MemberAccess","referencedDeclaration":54813,"src":"6762:20:100","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":54310,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"memberLocation":"6783:8:100","memberName":"selector","nodeType":"MemberAccess","src":"6762:29:100","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},"src":"6754:37:100","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},"falseBody":{"condition":{"commonType":{"typeIdentifier":"t_bytes4","typeString":"bytes4"},"id":54320,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftExpression":{"id":54316,"name":"_sel","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54104,"src":"6836:4:100","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},"nodeType":"BinaryOperation","operator":"==","rightExpression":{"expression":{"expression":{"id":54317,"name":"this","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":-28,"src":"6844:4:100","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$54911","typeString":"contract FetchChainInfoOutput"}},"id":54318,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"6849:10:100","memberName":"challenger","nodeType":"MemberAccess","referencedDeclaration":54831,"src":"6844:15:100","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":54319,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"memberLocation":"6860:8:100","memberName":"selector","nodeType":"MemberAccess","src":"6844:24:100","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},"src":"6836:32:100","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},"falseBody":{"condition":{"commonType":{"typeIdentifier":"t_bytes4","typeString":"bytes4"},"id":54329,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftExpression":{"id":54325,"name":"_sel","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54104,"src":"6908:4:100","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},"nodeType":"BinaryOperation","operator":"==","rightExpression":{"expression":{"expression":{"id":54326,"name":"this","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":-28,"src":"6916:4:100","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$54911","typeString":"contract FetchChainInfoOutput"}},"id":54327,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"6921:8:100","memberName":"proposer","nodeType":"MemberAccess","referencedDeclaration":54849,"src":"6916:13:100","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":54328,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"memberLocation":"6930:8:100","memberName":"selector","nodeType":"MemberAccess","src":"6916:22:100","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},"src":"6908:30:100","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},"falseBody":{"condition":{"commonType":{"typeIdentifier":"t_bytes4","typeString":"bytes4"},"id":54338,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftExpression":{"id":54334,"name":"_sel","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54104,"src":"6976:4:100","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},"nodeType":"BinaryOperation","operator":"==","rightExpression":{"expression":{"expression":{"id":54335,"name":"this","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":-28,"src":"6984:4:100","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$54911","typeString":"contract FetchChainInfoOutput"}},"id":54336,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"6989:17:100","memberName":"unsafeBlockSigner","nodeType":"MemberAccess","referencedDeclaration":54867,"src":"6984:22:100","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":54337,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"memberLocation":"7007:8:100","memberName":"selector","nodeType":"MemberAccess","src":"6984:31:100","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},"src":"6976:39:100","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},"falseBody":{"condition":{"commonType":{"typeIdentifier":"t_bytes4","typeString":"bytes4"},"id":54347,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftExpression":{"id":54343,"name":"_sel","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54104,"src":"7062:4:100","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},"nodeType":"BinaryOperation","operator":"==","rightExpression":{"expression":{"expression":{"id":54344,"name":"this","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":-28,"src":"7070:4:100","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$54911","typeString":"contract FetchChainInfoOutput"}},"id":54345,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"7075:14:100","memberName":"batchSubmitter","nodeType":"MemberAccess","referencedDeclaration":54885,"src":"7070:19:100","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":54346,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"memberLocation":"7090:8:100","memberName":"selector","nodeType":"MemberAccess","src":"7070:28:100","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},"src":"7062:36:100","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},"falseBody":{"expression":{"arguments":[{"hexValue":"4665746368436861696e496e666f4f75747075743a20756e6b6e6f776e20616464726573732073656c6563746f722074657374","id":54353,"isConstant":false,"isLValue":false,"isPure":true,"kind":"string","lValueRequested":false,"nodeType":"Literal","src":"7145:53:100","typeDescriptions":{"typeIdentifier":"t_stringliteral_8be6a92cba5443877e2b6bededc383e178c3f2718dce3f3864f1721c31f5c065","typeString":"literal_string \"FetchChainInfoOutput: unknown address selector test\""},"value":"FetchChainInfoOutput: unknown address selector test"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_stringliteral_8be6a92cba5443877e2b6bededc383e178c3f2718dce3f3864f1721c31f5c065","typeString":"literal_string \"FetchChainInfoOutput: unknown address selector test\""}],"id":54352,"name":"revert","nodeType":"Identifier","overloadedDeclarations":[-19,-19],"referencedDeclaration":-19,"src":"7138:6:100","typeDescriptions":{"typeIdentifier":"t_function_revert_pure$_t_string_memory_ptr_$returns$__$","typeString":"function (string memory) pure"}},"id":54354,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"7138:61:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":54355,"nodeType":"ExpressionStatement","src":"7138:61:100"},"id":54356,"nodeType":"IfStatement","src":"7058:141:100","trueBody":{"expression":{"id":54350,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftHandSide":{"id":54348,"name":"_batchSubmitter","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54095,"src":"7100:15:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"Assignment","operator":"=","rightHandSide":{"id":54349,"name":"_addr","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54106,"src":"7118:5:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"src":"7100:23:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"id":54351,"nodeType":"ExpressionStatement","src":"7100:23:100"}},"id":54357,"nodeType":"IfStatement","src":"6972:227:100","trueBody":{"expression":{"id":54341,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftHandSide":{"id":54339,"name":"_unsafeBlockSigner","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54093,"src":"7017:18:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"Assignment","operator":"=","rightHandSide":{"id":54340,"name":"_addr","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54106,"src":"7038:5:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"src":"7017:26:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"id":54342,"nodeType":"ExpressionStatement","src":"7017:26:100"}},"id":54358,"nodeType":"IfStatement","src":"6904:295:100","trueBody":{"expression":{"id":54332,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftHandSide":{"id":54330,"name":"_proposer","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54091,"src":"6940:9:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"Assignment","operator":"=","rightHandSide":{"id":54331,"name":"_addr","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54106,"src":"6952:5:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"src":"6940:17:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"id":54333,"nodeType":"ExpressionStatement","src":"6940:17:100"}},"id":54359,"nodeType":"IfStatement","src":"6832:367:100","trueBody":{"expression":{"id":54323,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftHandSide":{"id":54321,"name":"_challenger","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54089,"src":"6870:11:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"Assignment","operator":"=","rightHandSide":{"id":54322,"name":"_addr","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54106,"src":"6884:5:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"src":"6870:19:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"id":54324,"nodeType":"ExpressionStatement","src":"6870:19:100"}},"id":54360,"nodeType":"IfStatement","src":"6750:449:100","trueBody":{"expression":{"id":54314,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftHandSide":{"id":54312,"name":"_opChainGuardian","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54087,"src":"6793:16:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"Assignment","operator":"=","rightHandSide":{"id":54313,"name":"_addr","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54106,"src":"6812:5:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"src":"6793:24:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"id":54315,"nodeType":"ExpressionStatement","src":"6793:24:100"}},"id":54361,"nodeType":"IfStatement","src":"6654:545:100","trueBody":{"expression":{"id":54305,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftHandSide":{"id":54303,"name":"_opChainProxyAdminOwner","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54085,"src":"6704:23:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"Assignment","operator":"=","rightHandSide":{"id":54304,"name":"_addr","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54106,"src":"6730:5:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"src":"6704:31:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"id":54306,"nodeType":"ExpressionStatement","src":"6704:31:100"}},"id":54362,"nodeType":"IfStatement","src":"6568:631:100","trueBody":{"expression":{"id":54296,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftHandSide":{"id":54294,"name":"_systemConfigOwner","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54083,"src":"6613:18:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"Assignment","operator":"=","rightHandSide":{"id":54295,"name":"_addr","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54106,"src":"6634:5:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"src":"6613:26:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"id":54297,"nodeType":"ExpressionStatement","src":"6613:26:100"}},"id":54363,"nodeType":"IfStatement","src":"6445:754:100","trueBody":{"expression":{"id":54287,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftHandSide":{"id":54285,"name":"_permissionedDisputeGameImpl","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54081,"src":"6500:28:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"Assignment","operator":"=","rightHandSide":{"id":54286,"name":"_addr","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54106,"src":"6531:5:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"src":"6500:36:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"id":54288,"nodeType":"ExpressionStatement","src":"6500:36:100"}},"id":54364,"nodeType":"IfStatement","src":"6333:866:100","trueBody":{"expression":{"id":54278,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftHandSide":{"id":54276,"name":"_faultDisputeGameCannonKonaImpl","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54079,"src":"6391:31:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"Assignment","operator":"=","rightHandSide":{"id":54277,"name":"_addr","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54106,"src":"6425:5:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"src":"6391:39:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"id":54279,"nodeType":"ExpressionStatement","src":"6391:39:100"}},"id":54365,"nodeType":"IfStatement","src":"6241:958:100","trueBody":{"expression":{"id":54269,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftHandSide":{"id":54267,"name":"_faultDisputeGameImpl","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54077,"src":"6289:21:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"Assignment","operator":"=","rightHandSide":{"id":54268,"name":"_addr","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54106,"src":"6313:5:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"src":"6289:29:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"id":54270,"nodeType":"ExpressionStatement","src":"6289:29:100"}},"id":54366,"nodeType":"IfStatement","src":"6143:1056:100","trueBody":{"expression":{"id":54260,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftHandSide":{"id":54258,"name":"_disputeGameFactoryProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54075,"src":"6194:24:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"Assignment","operator":"=","rightHandSide":{"id":54259,"name":"_addr","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54106,"src":"6221:5:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"src":"6194:32:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"id":54261,"nodeType":"ExpressionStatement","src":"6194:32:100"}},"id":54367,"nodeType":"IfStatement","src":"6023:1176:100","trueBody":{"expression":{"id":54251,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftHandSide":{"id":54249,"name":"_delayedWethPermissionlessGameProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54073,"src":"6085:35:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"Assignment","operator":"=","rightHandSide":{"id":54250,"name":"_addr","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54106,"src":"6123:5:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"src":"6085:43:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"id":54252,"nodeType":"ExpressionStatement","src":"6085:43:100"}},"id":54368,"nodeType":"IfStatement","src":"5907:1292:100","trueBody":{"expression":{"id":54242,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftHandSide":{"id":54240,"name":"_delayedWethPermissionedGameProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54071,"src":"5967:33:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"Assignment","operator":"=","rightHandSide":{"id":54241,"name":"_addr","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54106,"src":"6003:5:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"src":"5967:41:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"id":54243,"nodeType":"ExpressionStatement","src":"5967:41:100"}},"id":54369,"nodeType":"IfStatement","src":"5807:1392:100","trueBody":{"expression":{"id":54233,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftHandSide":{"id":54231,"name":"_anchorStateRegistryProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54069,"src":"5859:25:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"Assignment","operator":"=","rightHandSide":{"id":54232,"name":"_addr","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54106,"src":"5887:5:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"src":"5859:33:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"id":54234,"nodeType":"ExpressionStatement","src":"5859:33:100"}},"id":54370,"nodeType":"IfStatement","src":"5713:1486:100","trueBody":{"expression":{"id":54224,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftHandSide":{"id":54222,"name":"_opChainProxyAdminImpl","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54067,"src":"5762:22:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"Assignment","operator":"=","rightHandSide":{"id":54223,"name":"_addr","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54106,"src":"5787:5:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"src":"5762:30:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"id":54225,"nodeType":"ExpressionStatement","src":"5762:30:100"}},"id":54371,"nodeType":"IfStatement","src":"5627:1572:100","trueBody":{"expression":{"id":54215,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftHandSide":{"id":54213,"name":"_systemConfigProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54065,"src":"5672:18:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"Assignment","operator":"=","rightHandSide":{"id":54214,"name":"_addr","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54106,"src":"5693:5:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"src":"5672:26:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"id":54216,"nodeType":"ExpressionStatement","src":"5672:26:100"}},"id":54372,"nodeType":"IfStatement","src":"5537:1662:100","trueBody":{"expression":{"id":54206,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftHandSide":{"id":54204,"name":"_optimismPortalProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54063,"src":"5584:20:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"Assignment","operator":"=","rightHandSide":{"id":54205,"name":"_addr","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54106,"src":"5607:5:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"src":"5584:28:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"id":54207,"nodeType":"ExpressionStatement","src":"5584:28:100"}},"id":54373,"nodeType":"IfStatement","src":"5419:1780:100","trueBody":{"expression":{"id":54197,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftHandSide":{"id":54195,"name":"_optimismMintableErc20FactoryProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54061,"src":"5480:34:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"Assignment","operator":"=","rightHandSide":{"id":54196,"name":"_addr","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54106,"src":"5517:5:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"src":"5480:42:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"id":54198,"nodeType":"ExpressionStatement","src":"5480:42:100"}},"id":54374,"nodeType":"IfStatement","src":"5329:1870:100","trueBody":{"expression":{"id":54188,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftHandSide":{"id":54186,"name":"_l2OutputOracleProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54059,"src":"5376:20:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"Assignment","operator":"=","rightHandSide":{"id":54187,"name":"_addr","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54106,"src":"5399:5:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"src":"5376:28:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"id":54189,"nodeType":"ExpressionStatement","src":"5376:28:100"}},"id":54375,"nodeType":"IfStatement","src":"5235:1964:100","trueBody":{"expression":{"id":54179,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftHandSide":{"id":54177,"name":"_l1StandardBridgeProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54057,"src":"5284:22:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"Assignment","operator":"=","rightHandSide":{"id":54178,"name":"_addr","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54106,"src":"5309:5:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"src":"5284:30:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"id":54180,"nodeType":"ExpressionStatement","src":"5284:30:100"}},"id":54376,"nodeType":"IfStatement","src":"5145:2054:100","trueBody":{"expression":{"id":54170,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftHandSide":{"id":54168,"name":"_l1Erc721BridgeProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54055,"src":"5192:20:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"Assignment","operator":"=","rightHandSide":{"id":54169,"name":"_addr","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54106,"src":"5215:5:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"src":"5192:28:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"id":54171,"nodeType":"ExpressionStatement","src":"5192:28:100"}},"id":54377,"nodeType":"IfStatement","src":"5039:2160:100","trueBody":{"expression":{"id":54161,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftHandSide":{"id":54159,"name":"_l1CrossDomainMessengerProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54053,"src":"5094:28:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"Assignment","operator":"=","rightHandSide":{"id":54160,"name":"_addr","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54106,"src":"5125:5:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"src":"5094:36:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"id":54162,"nodeType":"ExpressionStatement","src":"5094:36:100"}},"id":54378,"nodeType":"IfStatement","src":"4957:2242:100","trueBody":{"expression":{"id":54152,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftHandSide":{"id":54150,"name":"_ethLockboxProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54051,"src":"5000:16:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"Assignment","operator":"=","rightHandSide":{"id":54151,"name":"_addr","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54106,"src":"5019:5:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"src":"5000:24:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"id":54153,"nodeType":"ExpressionStatement","src":"5000:24:100"}},"id":54379,"nodeType":"IfStatement","src":"4869:2330:100","trueBody":{"expression":{"id":54143,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftHandSide":{"id":54141,"name":"_addressManagerImpl","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54049,"src":"4915:19:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"Assignment","operator":"=","rightHandSide":{"id":54142,"name":"_addr","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54106,"src":"4937:5:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"src":"4915:27:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"id":54144,"nodeType":"ExpressionStatement","src":"4915:27:100"}},"id":54380,"nodeType":"IfStatement","src":"4750:2449:100","trueBody":{"expression":{"id":54134,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftHandSide":{"id":54132,"name":"_preimageOracleImpl","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54047,"src":"4796:19:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"Assignment","operator":"=","rightHandSide":{"id":54133,"name":"_addr","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54106,"src":"4818:5:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"src":"4796:27:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"id":54135,"nodeType":"ExpressionStatement","src":"4796:27:100"}},"id":54381,"nodeType":"IfStatement","src":"4682:2517:100","trueBody":{"expression":{"id":54125,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftHandSide":{"id":54123,"name":"_mipsImpl","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54045,"src":"4718:9:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"Assignment","operator":"=","rightHandSide":{"id":54124,"name":"_addr","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54106,"src":"4730:5:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"src":"4718:17:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"id":54126,"nodeType":"ExpressionStatement","src":"4718:17:100"}},"id":54382,"nodeType":"IfStatement","src":"4549:2650:100","trueBody":{"expression":{"id":54116,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftHandSide":{"id":54114,"name":"_superchainConfigProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54043,"src":"4598:22:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"Assignment","operator":"=","rightHandSide":{"id":54115,"name":"_addr","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54106,"src":"4623:5:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"src":"4598:30:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"id":54117,"nodeType":"ExpressionStatement","src":"4598:30:100"}}]},"functionSelector":"c3e39250","implemented":true,"kind":"function","modifiers":[],"name":"set","nameLocation":"4469:3:100","parameters":{"id":54107,"nodeType":"ParameterList","parameters":[{"constant":false,"id":54104,"mutability":"mutable","name":"_sel","nameLocation":"4480:4:100","nodeType":"VariableDeclaration","scope":54384,"src":"4473:11:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"},"typeName":{"id":54103,"name":"bytes4","nodeType":"ElementaryTypeName","src":"4473:6:100","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},"visibility":"internal"},{"constant":false,"id":54106,"mutability":"mutable","name":"_addr","nameLocation":"4494:5:100","nodeType":"VariableDeclaration","scope":54384,"src":"4486:13:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":54105,"name":"address","nodeType":"ElementaryTypeName","src":"4486:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"4472:28:100"},"returnParameters":{"id":54108,"nodeType":"ParameterList","parameters":[],"src":"4508:0:100"},"scope":54911,"stateMutability":"nonpayable","virtual":false,"visibility":"public"},{"id":54416,"nodeType":"FunctionDefinition","src":"7212:271:100","nodes":[],"body":{"id":54415,"nodeType":"Block","src":"7257:226:100","nodes":[],"statements":[{"condition":{"commonType":{"typeIdentifier":"t_bytes4","typeString":"bytes4"},"id":54395,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftExpression":{"id":54391,"name":"_sel","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54386,"src":"7271:4:100","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},"nodeType":"BinaryOperation","operator":"==","rightExpression":{"expression":{"expression":{"id":54392,"name":"this","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":-28,"src":"7279:4:100","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$54911","typeString":"contract FetchChainInfoOutput"}},"id":54393,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"7284:12:100","memberName":"permissioned","nodeType":"MemberAccess","referencedDeclaration":54893,"src":"7279:17:100","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_bool_$","typeString":"function () view external returns (bool)"}},"id":54394,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"memberLocation":"7297:8:100","memberName":"selector","nodeType":"MemberAccess","src":"7279:26:100","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},"src":"7271:34:100","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},"falseBody":{"condition":{"commonType":{"typeIdentifier":"t_bytes4","typeString":"bytes4"},"id":54404,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftExpression":{"id":54400,"name":"_sel","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54386,"src":"7347:4:100","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},"nodeType":"BinaryOperation","operator":"==","rightExpression":{"expression":{"expression":{"id":54401,"name":"this","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":-28,"src":"7355:4:100","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$54911","typeString":"contract FetchChainInfoOutput"}},"id":54402,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"7360:14:100","memberName":"permissionless","nodeType":"MemberAccess","referencedDeclaration":54901,"src":"7355:19:100","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_bool_$","typeString":"function () view external returns (bool)"}},"id":54403,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"memberLocation":"7375:8:100","memberName":"selector","nodeType":"MemberAccess","src":"7355:28:100","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},"src":"7347:36:100","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},"falseBody":{"expression":{"arguments":[{"hexValue":"4665746368436861696e496e666f4f75747075743a20756e6b6e6f776e20626f6f6c2073656c6563746f72","id":54410,"isConstant":false,"isLValue":false,"isPure":true,"kind":"string","lValueRequested":false,"nodeType":"Literal","src":"7430:45:100","typeDescriptions":{"typeIdentifier":"t_stringliteral_b43e73201a672ac9d292be9f8dc7215ba0fae6d34ae76c7f77ffd9b31af48fae","typeString":"literal_string \"FetchChainInfoOutput: unknown bool selector\""},"value":"FetchChainInfoOutput: unknown bool selector"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_stringliteral_b43e73201a672ac9d292be9f8dc7215ba0fae6d34ae76c7f77ffd9b31af48fae","typeString":"literal_string \"FetchChainInfoOutput: unknown bool selector\""}],"id":54409,"name":"revert","nodeType":"Identifier","overloadedDeclarations":[-19,-19],"referencedDeclaration":-19,"src":"7423:6:100","typeDescriptions":{"typeIdentifier":"t_function_revert_pure$_t_string_memory_ptr_$returns$__$","typeString":"function (string memory) pure"}},"id":54411,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"7423:53:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":54412,"nodeType":"ExpressionStatement","src":"7423:53:100"},"id":54413,"nodeType":"IfStatement","src":"7343:133:100","trueBody":{"expression":{"id":54407,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftHandSide":{"id":54405,"name":"_permissionless","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54099,"src":"7385:15:100","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},"nodeType":"Assignment","operator":"=","rightHandSide":{"id":54406,"name":"_bool","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54388,"src":"7403:5:100","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},"src":"7385:23:100","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},"id":54408,"nodeType":"ExpressionStatement","src":"7385:23:100"}},"id":54414,"nodeType":"IfStatement","src":"7267:209:100","trueBody":{"expression":{"id":54398,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftHandSide":{"id":54396,"name":"_permissioned","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54097,"src":"7307:13:100","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},"nodeType":"Assignment","operator":"=","rightHandSide":{"id":54397,"name":"_bool","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54388,"src":"7323:5:100","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},"src":"7307:21:100","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},"id":54399,"nodeType":"ExpressionStatement","src":"7307:21:100"}}]},"functionSelector":"baa1e15e","implemented":true,"kind":"function","modifiers":[],"name":"set","nameLocation":"7221:3:100","parameters":{"id":54389,"nodeType":"ParameterList","parameters":[{"constant":false,"id":54386,"mutability":"mutable","name":"_sel","nameLocation":"7232:4:100","nodeType":"VariableDeclaration","scope":54416,"src":"7225:11:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"},"typeName":{"id":54385,"name":"bytes4","nodeType":"ElementaryTypeName","src":"7225:6:100","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},"visibility":"internal"},{"constant":false,"id":54388,"mutability":"mutable","name":"_bool","nameLocation":"7243:5:100","nodeType":"VariableDeclaration","scope":54416,"src":"7238:10:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"},"typeName":{"id":54387,"name":"bool","nodeType":"ElementaryTypeName","src":"7238:4:100","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},"visibility":"internal"}],"src":"7224:25:100"},"returnParameters":{"id":54390,"nodeType":"ParameterList","parameters":[],"src":"7257:0:100"},"scope":54911,"stateMutability":"nonpayable","virtual":false,"visibility":"public"},{"id":54439,"nodeType":"FunctionDefinition","src":"7489:217:100","nodes":[],"body":{"id":54438,"nodeType":"Block","src":"7542:164:100","nodes":[],"statements":[{"condition":{"commonType":{"typeIdentifier":"t_bytes4","typeString":"bytes4"},"id":54428,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftExpression":{"id":54424,"name":"_sel","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54418,"src":"7556:4:100","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},"nodeType":"BinaryOperation","operator":"==","rightExpression":{"expression":{"expression":{"id":54425,"name":"this","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":-28,"src":"7564:4:100","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$54911","typeString":"contract FetchChainInfoOutput"}},"id":54426,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"7569:17:100","memberName":"respectedGameType","nodeType":"MemberAccess","referencedDeclaration":54910,"src":"7564:22:100","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_userDefinedValueType$_GameType_$70720_$","typeString":"function () view external returns (GameType)"}},"id":54427,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"memberLocation":"7587:8:100","memberName":"selector","nodeType":"MemberAccess","src":"7564:31:100","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},"src":"7556:39:100","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},"falseBody":{"expression":{"arguments":[{"hexValue":"4665746368436861696e496e666f4f75747075743a20756e6b6e6f776e2047616d65547970652073656c6563746f72","id":54434,"isConstant":false,"isLValue":false,"isPure":true,"kind":"string","lValueRequested":false,"nodeType":"Literal","src":"7649:49:100","typeDescriptions":{"typeIdentifier":"t_stringliteral_520d3d0cced140fee76c803f92d1db783b790e13f72de1e8f8c229c8c8783afc","typeString":"literal_string \"FetchChainInfoOutput: unknown GameType selector\""},"value":"FetchChainInfoOutput: unknown GameType selector"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_stringliteral_520d3d0cced140fee76c803f92d1db783b790e13f72de1e8f8c229c8c8783afc","typeString":"literal_string \"FetchChainInfoOutput: unknown GameType selector\""}],"id":54433,"name":"revert","nodeType":"Identifier","overloadedDeclarations":[-19,-19],"referencedDeclaration":-19,"src":"7642:6:100","typeDescriptions":{"typeIdentifier":"t_function_revert_pure$_t_string_memory_ptr_$returns$__$","typeString":"function (string memory) pure"}},"id":54435,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"7642:57:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":54436,"nodeType":"ExpressionStatement","src":"7642:57:100"},"id":54437,"nodeType":"IfStatement","src":"7552:147:100","trueBody":{"expression":{"id":54431,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftHandSide":{"id":54429,"name":"_respectedGameType","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54102,"src":"7597:18:100","typeDescriptions":{"typeIdentifier":"t_userDefinedValueType$_GameType_$70720","typeString":"GameType"}},"nodeType":"Assignment","operator":"=","rightHandSide":{"id":54430,"name":"_gameType","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54421,"src":"7618:9:100","typeDescriptions":{"typeIdentifier":"t_userDefinedValueType$_GameType_$70720","typeString":"GameType"}},"src":"7597:30:100","typeDescriptions":{"typeIdentifier":"t_userDefinedValueType$_GameType_$70720","typeString":"GameType"}},"id":54432,"nodeType":"ExpressionStatement","src":"7597:30:100"}}]},"functionSelector":"d08d6066","implemented":true,"kind":"function","modifiers":[],"name":"set","nameLocation":"7498:3:100","parameters":{"id":54422,"nodeType":"ParameterList","parameters":[{"constant":false,"id":54418,"mutability":"mutable","name":"_sel","nameLocation":"7509:4:100","nodeType":"VariableDeclaration","scope":54439,"src":"7502:11:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"},"typeName":{"id":54417,"name":"bytes4","nodeType":"ElementaryTypeName","src":"7502:6:100","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},"visibility":"internal"},{"constant":false,"id":54421,"mutability":"mutable","name":"_gameType","nameLocation":"7524:9:100","nodeType":"VariableDeclaration","scope":54439,"src":"7515:18:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_userDefinedValueType$_GameType_$70720","typeString":"GameType"},"typeName":{"id":54420,"nodeType":"UserDefinedTypeName","pathNode":{"id":54419,"name":"GameType","nameLocations":["7515:8:100"],"nodeType":"IdentifierPath","referencedDeclaration":70720,"src":"7515:8:100"},"referencedDeclaration":70720,"src":"7515:8:100","typeDescriptions":{"typeIdentifier":"t_userDefinedValueType$_GameType_$70720","typeString":"GameType"}},"visibility":"internal"}],"src":"7501:33:100"},"returnParameters":{"id":54423,"nodeType":"ParameterList","parameters":[],"src":"7542:0:100"},"scope":54911,"stateMutability":"nonpayable","virtual":false,"visibility":"public"},{"id":54457,"nodeType":"FunctionDefinition","src":"7712:207:100","nodes":[],"body":{"id":54456,"nodeType":"Block","src":"7772:147:100","nodes":[],"statements":[{"expression":{"arguments":[{"commonType":{"typeIdentifier":"t_address","typeString":"address"},"id":54450,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftExpression":{"id":54445,"name":"_addressManagerImpl","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54049,"src":"7790:19:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"BinaryOperation","operator":"!=","rightExpression":{"arguments":[{"hexValue":"30","id":54448,"isConstant":false,"isLValue":false,"isPure":true,"kind":"number","lValueRequested":false,"nodeType":"Literal","src":"7821:1:100","typeDescriptions":{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"},"value":"0"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"}],"id":54447,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"nodeType":"ElementaryTypeNameExpression","src":"7813:7:100","typeDescriptions":{"typeIdentifier":"t_type$_t_address_$","typeString":"type(address)"},"typeName":{"id":54446,"name":"address","nodeType":"ElementaryTypeName","src":"7813:7:100","typeDescriptions":{}}},"id":54449,"isConstant":false,"isLValue":false,"isPure":true,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"7813:10:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"src":"7790:33:100","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},{"hexValue":"4665746368436861696e496e666f4f75747075743a20616464726573734d616e61676572496d706c206e6f7420736574","id":54451,"isConstant":false,"isLValue":false,"isPure":true,"kind":"string","lValueRequested":false,"nodeType":"Literal","src":"7825:50:100","typeDescriptions":{"typeIdentifier":"t_stringliteral_b154041fe6470d62d16e8ad5c6d8e6c50a46e3e155a380b02703b07321b83f6a","typeString":"literal_string \"FetchChainInfoOutput: addressManagerImpl not set\""},"value":"FetchChainInfoOutput: addressManagerImpl not set"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_bool","typeString":"bool"},{"typeIdentifier":"t_stringliteral_b154041fe6470d62d16e8ad5c6d8e6c50a46e3e155a380b02703b07321b83f6a","typeString":"literal_string \"FetchChainInfoOutput: addressManagerImpl not set\""}],"id":54444,"name":"require","nodeType":"Identifier","overloadedDeclarations":[-18,-18,-18],"referencedDeclaration":-18,"src":"7782:7:100","typeDescriptions":{"typeIdentifier":"t_function_require_pure$_t_bool_$_t_string_memory_ptr_$returns$__$","typeString":"function (bool,string memory) pure"}},"id":54452,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"7782:94:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":54453,"nodeType":"ExpressionStatement","src":"7782:94:100"},{"expression":{"id":54454,"name":"_addressManagerImpl","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54049,"src":"7893:19:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"functionReturnParameters":54443,"id":54455,"nodeType":"Return","src":"7886:26:100"}]},"functionSelector":"bd366b8f","implemented":true,"kind":"function","modifiers":[],"name":"addressManagerImpl","nameLocation":"7721:18:100","parameters":{"id":54440,"nodeType":"ParameterList","parameters":[],"src":"7739:2:100"},"returnParameters":{"id":54443,"nodeType":"ParameterList","parameters":[{"constant":false,"id":54442,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":54457,"src":"7763:7:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":54441,"name":"address","nodeType":"ElementaryTypeName","src":"7763:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"7762:9:100"},"scope":54911,"stateMutability":"view","virtual":false,"visibility":"public"},{"id":54465,"nodeType":"FunctionDefinition","src":"7925:97:100","nodes":[],"body":{"id":54464,"nodeType":"Block","src":"7982:40:100","nodes":[],"statements":[{"expression":{"id":54462,"name":"_ethLockboxProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54051,"src":"7999:16:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"functionReturnParameters":54461,"id":54463,"nodeType":"Return","src":"7992:23:100"}]},"functionSelector":"f646b07c","implemented":true,"kind":"function","modifiers":[],"name":"ethLockboxProxy","nameLocation":"7934:15:100","parameters":{"id":54458,"nodeType":"ParameterList","parameters":[],"src":"7949:2:100"},"returnParameters":{"id":54461,"nodeType":"ParameterList","parameters":[{"constant":false,"id":54460,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":54465,"src":"7973:7:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":54459,"name":"address","nodeType":"ElementaryTypeName","src":"7973:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"7972:9:100"},"scope":54911,"stateMutability":"view","virtual":false,"visibility":"public"},{"id":54483,"nodeType":"FunctionDefinition","src":"8028:243:100","nodes":[],"body":{"id":54482,"nodeType":"Block","src":"8097:174:100","nodes":[],"statements":[{"expression":{"arguments":[{"commonType":{"typeIdentifier":"t_address","typeString":"address"},"id":54476,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftExpression":{"id":54471,"name":"_l1CrossDomainMessengerProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54053,"src":"8115:28:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"BinaryOperation","operator":"!=","rightExpression":{"arguments":[{"hexValue":"30","id":54474,"isConstant":false,"isLValue":false,"isPure":true,"kind":"number","lValueRequested":false,"nodeType":"Literal","src":"8155:1:100","typeDescriptions":{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"},"value":"0"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"}],"id":54473,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"nodeType":"ElementaryTypeNameExpression","src":"8147:7:100","typeDescriptions":{"typeIdentifier":"t_type$_t_address_$","typeString":"type(address)"},"typeName":{"id":54472,"name":"address","nodeType":"ElementaryTypeName","src":"8147:7:100","typeDescriptions":{}}},"id":54475,"isConstant":false,"isLValue":false,"isPure":true,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"8147:10:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"src":"8115:42:100","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},{"hexValue":"4665746368436861696e496e666f4f75747075743a206c3143726f7373446f6d61696e4d657373656e67657250726f7879206e6f7420736574","id":54477,"isConstant":false,"isLValue":false,"isPure":true,"kind":"string","lValueRequested":false,"nodeType":"Literal","src":"8159:59:100","typeDescriptions":{"typeIdentifier":"t_stringliteral_c51216a9bdef996dd7040e19ba4fe817587273a187f1f145abfd19b1308df5eb","typeString":"literal_string \"FetchChainInfoOutput: l1CrossDomainMessengerProxy not set\""},"value":"FetchChainInfoOutput: l1CrossDomainMessengerProxy not set"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_bool","typeString":"bool"},{"typeIdentifier":"t_stringliteral_c51216a9bdef996dd7040e19ba4fe817587273a187f1f145abfd19b1308df5eb","typeString":"literal_string \"FetchChainInfoOutput: l1CrossDomainMessengerProxy not set\""}],"id":54470,"name":"require","nodeType":"Identifier","overloadedDeclarations":[-18,-18,-18],"referencedDeclaration":-18,"src":"8107:7:100","typeDescriptions":{"typeIdentifier":"t_function_require_pure$_t_bool_$_t_string_memory_ptr_$returns$__$","typeString":"function (bool,string memory) pure"}},"id":54478,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"8107:112:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":54479,"nodeType":"ExpressionStatement","src":"8107:112:100"},{"expression":{"id":54480,"name":"_l1CrossDomainMessengerProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54053,"src":"8236:28:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"functionReturnParameters":54469,"id":54481,"nodeType":"Return","src":"8229:35:100"}]},"functionSelector":"54729cfb","implemented":true,"kind":"function","modifiers":[],"name":"l1CrossDomainMessengerProxy","nameLocation":"8037:27:100","parameters":{"id":54466,"nodeType":"ParameterList","parameters":[],"src":"8064:2:100"},"returnParameters":{"id":54469,"nodeType":"ParameterList","parameters":[{"constant":false,"id":54468,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":54483,"src":"8088:7:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":54467,"name":"address","nodeType":"ElementaryTypeName","src":"8088:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"8087:9:100"},"scope":54911,"stateMutability":"view","virtual":false,"visibility":"public"},{"id":54501,"nodeType":"FunctionDefinition","src":"8277:211:100","nodes":[],"body":{"id":54500,"nodeType":"Block","src":"8338:150:100","nodes":[],"statements":[{"expression":{"arguments":[{"commonType":{"typeIdentifier":"t_address","typeString":"address"},"id":54494,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftExpression":{"id":54489,"name":"_l1Erc721BridgeProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54055,"src":"8356:20:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"BinaryOperation","operator":"!=","rightExpression":{"arguments":[{"hexValue":"30","id":54492,"isConstant":false,"isLValue":false,"isPure":true,"kind":"number","lValueRequested":false,"nodeType":"Literal","src":"8388:1:100","typeDescriptions":{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"},"value":"0"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"}],"id":54491,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"nodeType":"ElementaryTypeNameExpression","src":"8380:7:100","typeDescriptions":{"typeIdentifier":"t_type$_t_address_$","typeString":"type(address)"},"typeName":{"id":54490,"name":"address","nodeType":"ElementaryTypeName","src":"8380:7:100","typeDescriptions":{}}},"id":54493,"isConstant":false,"isLValue":false,"isPure":true,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"8380:10:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"src":"8356:34:100","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},{"hexValue":"4665746368436861696e496e666f4f75747075743a206c3145726337323142726964676550726f7879206e6f7420736574","id":54495,"isConstant":false,"isLValue":false,"isPure":true,"kind":"string","lValueRequested":false,"nodeType":"Literal","src":"8392:51:100","typeDescriptions":{"typeIdentifier":"t_stringliteral_bdf5319949d8561b59a02fe667aa58fca11f5f8571bc18997b0bc0ac582aece7","typeString":"literal_string \"FetchChainInfoOutput: l1Erc721BridgeProxy not set\""},"value":"FetchChainInfoOutput: l1Erc721BridgeProxy not set"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_bool","typeString":"bool"},{"typeIdentifier":"t_stringliteral_bdf5319949d8561b59a02fe667aa58fca11f5f8571bc18997b0bc0ac582aece7","typeString":"literal_string \"FetchChainInfoOutput: l1Erc721BridgeProxy not set\""}],"id":54488,"name":"require","nodeType":"Identifier","overloadedDeclarations":[-18,-18,-18],"referencedDeclaration":-18,"src":"8348:7:100","typeDescriptions":{"typeIdentifier":"t_function_require_pure$_t_bool_$_t_string_memory_ptr_$returns$__$","typeString":"function (bool,string memory) pure"}},"id":54496,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"8348:96:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":54497,"nodeType":"ExpressionStatement","src":"8348:96:100"},{"expression":{"id":54498,"name":"_l1Erc721BridgeProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54055,"src":"8461:20:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"functionReturnParameters":54487,"id":54499,"nodeType":"Return","src":"8454:27:100"}]},"functionSelector":"ebfa8409","implemented":true,"kind":"function","modifiers":[],"name":"l1Erc721BridgeProxy","nameLocation":"8286:19:100","parameters":{"id":54484,"nodeType":"ParameterList","parameters":[],"src":"8305:2:100"},"returnParameters":{"id":54487,"nodeType":"ParameterList","parameters":[{"constant":false,"id":54486,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":54501,"src":"8329:7:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":54485,"name":"address","nodeType":"ElementaryTypeName","src":"8329:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"8328:9:100"},"scope":54911,"stateMutability":"view","virtual":false,"visibility":"public"},{"id":54519,"nodeType":"FunctionDefinition","src":"8494:219:100","nodes":[],"body":{"id":54518,"nodeType":"Block","src":"8557:156:100","nodes":[],"statements":[{"expression":{"arguments":[{"commonType":{"typeIdentifier":"t_address","typeString":"address"},"id":54512,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftExpression":{"id":54507,"name":"_l1StandardBridgeProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54057,"src":"8575:22:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"BinaryOperation","operator":"!=","rightExpression":{"arguments":[{"hexValue":"30","id":54510,"isConstant":false,"isLValue":false,"isPure":true,"kind":"number","lValueRequested":false,"nodeType":"Literal","src":"8609:1:100","typeDescriptions":{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"},"value":"0"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"}],"id":54509,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"nodeType":"ElementaryTypeNameExpression","src":"8601:7:100","typeDescriptions":{"typeIdentifier":"t_type$_t_address_$","typeString":"type(address)"},"typeName":{"id":54508,"name":"address","nodeType":"ElementaryTypeName","src":"8601:7:100","typeDescriptions":{}}},"id":54511,"isConstant":false,"isLValue":false,"isPure":true,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"8601:10:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"src":"8575:36:100","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},{"hexValue":"4665746368436861696e496e666f4f75747075743a206c315374616e6461726442726964676550726f7879206e6f7420736574","id":54513,"isConstant":false,"isLValue":false,"isPure":true,"kind":"string","lValueRequested":false,"nodeType":"Literal","src":"8613:53:100","typeDescriptions":{"typeIdentifier":"t_stringliteral_ab3776e760de395cff3bb935602469d5b7c0bd9b5cfaefde9d221be6524302e1","typeString":"literal_string \"FetchChainInfoOutput: l1StandardBridgeProxy not set\""},"value":"FetchChainInfoOutput: l1StandardBridgeProxy not set"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_bool","typeString":"bool"},{"typeIdentifier":"t_stringliteral_ab3776e760de395cff3bb935602469d5b7c0bd9b5cfaefde9d221be6524302e1","typeString":"literal_string \"FetchChainInfoOutput: l1StandardBridgeProxy not set\""}],"id":54506,"name":"require","nodeType":"Identifier","overloadedDeclarations":[-18,-18,-18],"referencedDeclaration":-18,"src":"8567:7:100","typeDescriptions":{"typeIdentifier":"t_function_require_pure$_t_bool_$_t_string_memory_ptr_$returns$__$","typeString":"function (bool,string memory) pure"}},"id":54514,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"8567:100:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":54515,"nodeType":"ExpressionStatement","src":"8567:100:100"},{"expression":{"id":54516,"name":"_l1StandardBridgeProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54057,"src":"8684:22:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"functionReturnParameters":54505,"id":54517,"nodeType":"Return","src":"8677:29:100"}]},"functionSelector":"102b6069","implemented":true,"kind":"function","modifiers":[],"name":"l1StandardBridgeProxy","nameLocation":"8503:21:100","parameters":{"id":54502,"nodeType":"ParameterList","parameters":[],"src":"8524:2:100"},"returnParameters":{"id":54505,"nodeType":"ParameterList","parameters":[{"constant":false,"id":54504,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":54519,"src":"8548:7:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":54503,"name":"address","nodeType":"ElementaryTypeName","src":"8548:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"8547:9:100"},"scope":54911,"stateMutability":"view","virtual":false,"visibility":"public"},{"id":54537,"nodeType":"FunctionDefinition","src":"8719:211:100","nodes":[],"body":{"id":54536,"nodeType":"Block","src":"8780:150:100","nodes":[],"statements":[{"expression":{"arguments":[{"commonType":{"typeIdentifier":"t_address","typeString":"address"},"id":54530,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftExpression":{"id":54525,"name":"_l2OutputOracleProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54059,"src":"8798:20:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"BinaryOperation","operator":"!=","rightExpression":{"arguments":[{"hexValue":"30","id":54528,"isConstant":false,"isLValue":false,"isPure":true,"kind":"number","lValueRequested":false,"nodeType":"Literal","src":"8830:1:100","typeDescriptions":{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"},"value":"0"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"}],"id":54527,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"nodeType":"ElementaryTypeNameExpression","src":"8822:7:100","typeDescriptions":{"typeIdentifier":"t_type$_t_address_$","typeString":"type(address)"},"typeName":{"id":54526,"name":"address","nodeType":"ElementaryTypeName","src":"8822:7:100","typeDescriptions":{}}},"id":54529,"isConstant":false,"isLValue":false,"isPure":true,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"8822:10:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"src":"8798:34:100","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},{"hexValue":"4665746368436861696e496e666f4f75747075743a206c324f75747075744f7261636c6550726f7879206e6f7420736574","id":54531,"isConstant":false,"isLValue":false,"isPure":true,"kind":"string","lValueRequested":false,"nodeType":"Literal","src":"8834:51:100","typeDescriptions":{"typeIdentifier":"t_stringliteral_2f861759874f8f3e0cfa53ef8dfb0556f88f877edbaf1dbc485fc820d67ac86a","typeString":"literal_string \"FetchChainInfoOutput: l2OutputOracleProxy not set\""},"value":"FetchChainInfoOutput: l2OutputOracleProxy not set"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_bool","typeString":"bool"},{"typeIdentifier":"t_stringliteral_2f861759874f8f3e0cfa53ef8dfb0556f88f877edbaf1dbc485fc820d67ac86a","typeString":"literal_string \"FetchChainInfoOutput: l2OutputOracleProxy not set\""}],"id":54524,"name":"require","nodeType":"Identifier","overloadedDeclarations":[-18,-18,-18],"referencedDeclaration":-18,"src":"8790:7:100","typeDescriptions":{"typeIdentifier":"t_function_require_pure$_t_bool_$_t_string_memory_ptr_$returns$__$","typeString":"function (bool,string memory) pure"}},"id":54532,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"8790:96:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":54533,"nodeType":"ExpressionStatement","src":"8790:96:100"},{"expression":{"id":54534,"name":"_l2OutputOracleProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54059,"src":"8903:20:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"functionReturnParameters":54523,"id":54535,"nodeType":"Return","src":"8896:27:100"}]},"functionSelector":"a2c9a89f","implemented":true,"kind":"function","modifiers":[],"name":"l2OutputOracleProxy","nameLocation":"8728:19:100","parameters":{"id":54520,"nodeType":"ParameterList","parameters":[],"src":"8747:2:100"},"returnParameters":{"id":54523,"nodeType":"ParameterList","parameters":[{"constant":false,"id":54522,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":54537,"src":"8771:7:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":54521,"name":"address","nodeType":"ElementaryTypeName","src":"8771:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"8770:9:100"},"scope":54911,"stateMutability":"view","virtual":false,"visibility":"public"},{"id":54555,"nodeType":"FunctionDefinition","src":"8936:301:100","nodes":[],"body":{"id":54554,"nodeType":"Block","src":"9011:226:100","nodes":[],"statements":[{"expression":{"arguments":[{"commonType":{"typeIdentifier":"t_address","typeString":"address"},"id":54548,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftExpression":{"id":54543,"name":"_optimismMintableErc20FactoryProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54061,"src":"9042:34:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"BinaryOperation","operator":"!=","rightExpression":{"arguments":[{"hexValue":"30","id":54546,"isConstant":false,"isLValue":false,"isPure":true,"kind":"number","lValueRequested":false,"nodeType":"Literal","src":"9088:1:100","typeDescriptions":{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"},"value":"0"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"}],"id":54545,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"nodeType":"ElementaryTypeNameExpression","src":"9080:7:100","typeDescriptions":{"typeIdentifier":"t_type$_t_address_$","typeString":"type(address)"},"typeName":{"id":54544,"name":"address","nodeType":"ElementaryTypeName","src":"9080:7:100","typeDescriptions":{}}},"id":54547,"isConstant":false,"isLValue":false,"isPure":true,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"9080:10:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"src":"9042:48:100","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},{"hexValue":"4665746368436861696e496e666f4f75747075743a206f7074696d69736d4d696e7461626c654572633230466163746f727950726f7879206e6f7420736574","id":54549,"isConstant":false,"isLValue":false,"isPure":true,"kind":"string","lValueRequested":false,"nodeType":"Literal","src":"9104:65:100","typeDescriptions":{"typeIdentifier":"t_stringliteral_58c040fbde84bd4afd9f21f5ba3150dab029d767b65aafdf14512bdafdbd9954","typeString":"literal_string \"FetchChainInfoOutput: optimismMintableErc20FactoryProxy not set\""},"value":"FetchChainInfoOutput: optimismMintableErc20FactoryProxy not set"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_bool","typeString":"bool"},{"typeIdentifier":"t_stringliteral_58c040fbde84bd4afd9f21f5ba3150dab029d767b65aafdf14512bdafdbd9954","typeString":"literal_string \"FetchChainInfoOutput: optimismMintableErc20FactoryProxy not set\""}],"id":54542,"name":"require","nodeType":"Identifier","overloadedDeclarations":[-18,-18,-18],"referencedDeclaration":-18,"src":"9021:7:100","typeDescriptions":{"typeIdentifier":"t_function_require_pure$_t_bool_$_t_string_memory_ptr_$returns$__$","typeString":"function (bool,string memory) pure"}},"id":54550,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"9021:158:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":54551,"nodeType":"ExpressionStatement","src":"9021:158:100"},{"expression":{"id":54552,"name":"_optimismMintableErc20FactoryProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54061,"src":"9196:34:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"functionReturnParameters":54541,"id":54553,"nodeType":"Return","src":"9189:41:100"}]},"functionSelector":"8f20c7e4","implemented":true,"kind":"function","modifiers":[],"name":"optimismMintableErc20FactoryProxy","nameLocation":"8945:33:100","parameters":{"id":54538,"nodeType":"ParameterList","parameters":[],"src":"8978:2:100"},"returnParameters":{"id":54541,"nodeType":"ParameterList","parameters":[{"constant":false,"id":54540,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":54555,"src":"9002:7:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":54539,"name":"address","nodeType":"ElementaryTypeName","src":"9002:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"9001:9:100"},"scope":54911,"stateMutability":"view","virtual":false,"visibility":"public"},{"id":54573,"nodeType":"FunctionDefinition","src":"9243:211:100","nodes":[],"body":{"id":54572,"nodeType":"Block","src":"9304:150:100","nodes":[],"statements":[{"expression":{"arguments":[{"commonType":{"typeIdentifier":"t_address","typeString":"address"},"id":54566,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftExpression":{"id":54561,"name":"_optimismPortalProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54063,"src":"9322:20:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"BinaryOperation","operator":"!=","rightExpression":{"arguments":[{"hexValue":"30","id":54564,"isConstant":false,"isLValue":false,"isPure":true,"kind":"number","lValueRequested":false,"nodeType":"Literal","src":"9354:1:100","typeDescriptions":{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"},"value":"0"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"}],"id":54563,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"nodeType":"ElementaryTypeNameExpression","src":"9346:7:100","typeDescriptions":{"typeIdentifier":"t_type$_t_address_$","typeString":"type(address)"},"typeName":{"id":54562,"name":"address","nodeType":"ElementaryTypeName","src":"9346:7:100","typeDescriptions":{}}},"id":54565,"isConstant":false,"isLValue":false,"isPure":true,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"9346:10:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"src":"9322:34:100","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},{"hexValue":"4665746368436861696e496e666f4f75747075743a206f7074696d69736d506f7274616c50726f7879206e6f7420736574","id":54567,"isConstant":false,"isLValue":false,"isPure":true,"kind":"string","lValueRequested":false,"nodeType":"Literal","src":"9358:51:100","typeDescriptions":{"typeIdentifier":"t_stringliteral_ef003bab75ab0cfa4ca81f99eb20b37a3fded08fa7502df7d991f596c8680642","typeString":"literal_string \"FetchChainInfoOutput: optimismPortalProxy not set\""},"value":"FetchChainInfoOutput: optimismPortalProxy not set"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_bool","typeString":"bool"},{"typeIdentifier":"t_stringliteral_ef003bab75ab0cfa4ca81f99eb20b37a3fded08fa7502df7d991f596c8680642","typeString":"literal_string \"FetchChainInfoOutput: optimismPortalProxy not set\""}],"id":54560,"name":"require","nodeType":"Identifier","overloadedDeclarations":[-18,-18,-18],"referencedDeclaration":-18,"src":"9314:7:100","typeDescriptions":{"typeIdentifier":"t_function_require_pure$_t_bool_$_t_string_memory_ptr_$returns$__$","typeString":"function (bool,string memory) pure"}},"id":54568,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"9314:96:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":54569,"nodeType":"ExpressionStatement","src":"9314:96:100"},{"expression":{"id":54570,"name":"_optimismPortalProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54063,"src":"9427:20:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"functionReturnParameters":54559,"id":54571,"nodeType":"Return","src":"9420:27:100"}]},"functionSelector":"04451c49","implemented":true,"kind":"function","modifiers":[],"name":"optimismPortalProxy","nameLocation":"9252:19:100","parameters":{"id":54556,"nodeType":"ParameterList","parameters":[],"src":"9271:2:100"},"returnParameters":{"id":54559,"nodeType":"ParameterList","parameters":[{"constant":false,"id":54558,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":54573,"src":"9295:7:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":54557,"name":"address","nodeType":"ElementaryTypeName","src":"9295:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"9294:9:100"},"scope":54911,"stateMutability":"view","virtual":false,"visibility":"public"},{"id":54591,"nodeType":"FunctionDefinition","src":"9460:203:100","nodes":[],"body":{"id":54590,"nodeType":"Block","src":"9519:144:100","nodes":[],"statements":[{"expression":{"arguments":[{"commonType":{"typeIdentifier":"t_address","typeString":"address"},"id":54584,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftExpression":{"id":54579,"name":"_systemConfigProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54065,"src":"9537:18:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"BinaryOperation","operator":"!=","rightExpression":{"arguments":[{"hexValue":"30","id":54582,"isConstant":false,"isLValue":false,"isPure":true,"kind":"number","lValueRequested":false,"nodeType":"Literal","src":"9567:1:100","typeDescriptions":{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"},"value":"0"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"}],"id":54581,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"nodeType":"ElementaryTypeNameExpression","src":"9559:7:100","typeDescriptions":{"typeIdentifier":"t_type$_t_address_$","typeString":"type(address)"},"typeName":{"id":54580,"name":"address","nodeType":"ElementaryTypeName","src":"9559:7:100","typeDescriptions":{}}},"id":54583,"isConstant":false,"isLValue":false,"isPure":true,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"9559:10:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"src":"9537:32:100","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},{"hexValue":"4665746368436861696e496e666f4f75747075743a2073797374656d436f6e66696750726f7879206e6f7420736574","id":54585,"isConstant":false,"isLValue":false,"isPure":true,"kind":"string","lValueRequested":false,"nodeType":"Literal","src":"9571:49:100","typeDescriptions":{"typeIdentifier":"t_stringliteral_09ada010329fb4e012f4c857519ec176efea734f55c01f382f1b6c7bd752716b","typeString":"literal_string \"FetchChainInfoOutput: systemConfigProxy not set\""},"value":"FetchChainInfoOutput: systemConfigProxy not set"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_bool","typeString":"bool"},{"typeIdentifier":"t_stringliteral_09ada010329fb4e012f4c857519ec176efea734f55c01f382f1b6c7bd752716b","typeString":"literal_string \"FetchChainInfoOutput: systemConfigProxy not set\""}],"id":54578,"name":"require","nodeType":"Identifier","overloadedDeclarations":[-18,-18,-18],"referencedDeclaration":-18,"src":"9529:7:100","typeDescriptions":{"typeIdentifier":"t_function_require_pure$_t_bool_$_t_string_memory_ptr_$returns$__$","typeString":"function (bool,string memory) pure"}},"id":54586,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"9529:92:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":54587,"nodeType":"ExpressionStatement","src":"9529:92:100"},{"expression":{"id":54588,"name":"_systemConfigProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54065,"src":"9638:18:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"functionReturnParameters":54577,"id":54589,"nodeType":"Return","src":"9631:25:100"}]},"functionSelector":"c17db6e3","implemented":true,"kind":"function","modifiers":[],"name":"systemConfigProxy","nameLocation":"9469:17:100","parameters":{"id":54574,"nodeType":"ParameterList","parameters":[],"src":"9486:2:100"},"returnParameters":{"id":54577,"nodeType":"ParameterList","parameters":[{"constant":false,"id":54576,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":54591,"src":"9510:7:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":54575,"name":"address","nodeType":"ElementaryTypeName","src":"9510:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"9509:9:100"},"scope":54911,"stateMutability":"view","virtual":false,"visibility":"public"},{"id":54609,"nodeType":"FunctionDefinition","src":"9669:219:100","nodes":[],"body":{"id":54608,"nodeType":"Block","src":"9732:156:100","nodes":[],"statements":[{"expression":{"arguments":[{"commonType":{"typeIdentifier":"t_address","typeString":"address"},"id":54602,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftExpression":{"id":54597,"name":"_opChainProxyAdminImpl","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54067,"src":"9750:22:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"BinaryOperation","operator":"!=","rightExpression":{"arguments":[{"hexValue":"30","id":54600,"isConstant":false,"isLValue":false,"isPure":true,"kind":"number","lValueRequested":false,"nodeType":"Literal","src":"9784:1:100","typeDescriptions":{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"},"value":"0"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"}],"id":54599,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"nodeType":"ElementaryTypeNameExpression","src":"9776:7:100","typeDescriptions":{"typeIdentifier":"t_type$_t_address_$","typeString":"type(address)"},"typeName":{"id":54598,"name":"address","nodeType":"ElementaryTypeName","src":"9776:7:100","typeDescriptions":{}}},"id":54601,"isConstant":false,"isLValue":false,"isPure":true,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"9776:10:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"src":"9750:36:100","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},{"hexValue":"4665746368436861696e496e666f4f75747075743a206f70436861696e50726f787941646d696e496d706c206e6f7420736574","id":54603,"isConstant":false,"isLValue":false,"isPure":true,"kind":"string","lValueRequested":false,"nodeType":"Literal","src":"9788:53:100","typeDescriptions":{"typeIdentifier":"t_stringliteral_8ebc3647bde8a1129bfd827c7ef2e2d4fea82292bcad8a3c8e3918d70fed8ea8","typeString":"literal_string \"FetchChainInfoOutput: opChainProxyAdminImpl not set\""},"value":"FetchChainInfoOutput: opChainProxyAdminImpl not set"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_bool","typeString":"bool"},{"typeIdentifier":"t_stringliteral_8ebc3647bde8a1129bfd827c7ef2e2d4fea82292bcad8a3c8e3918d70fed8ea8","typeString":"literal_string \"FetchChainInfoOutput: opChainProxyAdminImpl not set\""}],"id":54596,"name":"require","nodeType":"Identifier","overloadedDeclarations":[-18,-18,-18],"referencedDeclaration":-18,"src":"9742:7:100","typeDescriptions":{"typeIdentifier":"t_function_require_pure$_t_bool_$_t_string_memory_ptr_$returns$__$","typeString":"function (bool,string memory) pure"}},"id":54604,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"9742:100:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":54605,"nodeType":"ExpressionStatement","src":"9742:100:100"},{"expression":{"id":54606,"name":"_opChainProxyAdminImpl","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54067,"src":"9859:22:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"functionReturnParameters":54595,"id":54607,"nodeType":"Return","src":"9852:29:100"}]},"functionSelector":"5643665f","implemented":true,"kind":"function","modifiers":[],"name":"opChainProxyAdminImpl","nameLocation":"9678:21:100","parameters":{"id":54592,"nodeType":"ParameterList","parameters":[],"src":"9699:2:100"},"returnParameters":{"id":54595,"nodeType":"ParameterList","parameters":[{"constant":false,"id":54594,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":54609,"src":"9723:7:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":54593,"name":"address","nodeType":"ElementaryTypeName","src":"9723:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"9722:9:100"},"scope":54911,"stateMutability":"view","virtual":false,"visibility":"public"},{"id":54627,"nodeType":"FunctionDefinition","src":"9894:219:100","nodes":[],"body":{"id":54626,"nodeType":"Block","src":"9957:156:100","nodes":[],"statements":[{"expression":{"arguments":[{"commonType":{"typeIdentifier":"t_address","typeString":"address"},"id":54620,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftExpression":{"id":54615,"name":"_superchainConfigProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54043,"src":"9975:22:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"BinaryOperation","operator":"!=","rightExpression":{"arguments":[{"hexValue":"30","id":54618,"isConstant":false,"isLValue":false,"isPure":true,"kind":"number","lValueRequested":false,"nodeType":"Literal","src":"10009:1:100","typeDescriptions":{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"},"value":"0"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"}],"id":54617,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"nodeType":"ElementaryTypeNameExpression","src":"10001:7:100","typeDescriptions":{"typeIdentifier":"t_type$_t_address_$","typeString":"type(address)"},"typeName":{"id":54616,"name":"address","nodeType":"ElementaryTypeName","src":"10001:7:100","typeDescriptions":{}}},"id":54619,"isConstant":false,"isLValue":false,"isPure":true,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"10001:10:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"src":"9975:36:100","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},{"hexValue":"4665746368436861696e496e666f4f75747075743a207375706572636861696e436f6e66696750726f7879206e6f7420736574","id":54621,"isConstant":false,"isLValue":false,"isPure":true,"kind":"string","lValueRequested":false,"nodeType":"Literal","src":"10013:53:100","typeDescriptions":{"typeIdentifier":"t_stringliteral_1b8ad3d2e627aa065fd0fee387bc2d1e5e640177323f7f86733cd157b788a1ce","typeString":"literal_string \"FetchChainInfoOutput: superchainConfigProxy not set\""},"value":"FetchChainInfoOutput: superchainConfigProxy not set"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_bool","typeString":"bool"},{"typeIdentifier":"t_stringliteral_1b8ad3d2e627aa065fd0fee387bc2d1e5e640177323f7f86733cd157b788a1ce","typeString":"literal_string \"FetchChainInfoOutput: superchainConfigProxy not set\""}],"id":54614,"name":"require","nodeType":"Identifier","overloadedDeclarations":[-18,-18,-18],"referencedDeclaration":-18,"src":"9967:7:100","typeDescriptions":{"typeIdentifier":"t_function_require_pure$_t_bool_$_t_string_memory_ptr_$returns$__$","typeString":"function (bool,string memory) pure"}},"id":54622,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"9967:100:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":54623,"nodeType":"ExpressionStatement","src":"9967:100:100"},{"expression":{"id":54624,"name":"_superchainConfigProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54043,"src":"10084:22:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"functionReturnParameters":54613,"id":54625,"nodeType":"Return","src":"10077:29:100"}]},"functionSelector":"84cf2c97","implemented":true,"kind":"function","modifiers":[],"name":"superchainConfigProxy","nameLocation":"9903:21:100","parameters":{"id":54610,"nodeType":"ParameterList","parameters":[],"src":"9924:2:100"},"returnParameters":{"id":54613,"nodeType":"ParameterList","parameters":[{"constant":false,"id":54612,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":54627,"src":"9948:7:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":54611,"name":"address","nodeType":"ElementaryTypeName","src":"9948:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"9947:9:100"},"scope":54911,"stateMutability":"view","virtual":false,"visibility":"public"},{"id":54645,"nodeType":"FunctionDefinition","src":"10119:231:100","nodes":[],"body":{"id":54644,"nodeType":"Block","src":"10185:165:100","nodes":[],"statements":[{"expression":{"arguments":[{"commonType":{"typeIdentifier":"t_address","typeString":"address"},"id":54638,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftExpression":{"id":54633,"name":"_anchorStateRegistryProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54069,"src":"10203:25:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"BinaryOperation","operator":"!=","rightExpression":{"arguments":[{"hexValue":"30","id":54636,"isConstant":false,"isLValue":false,"isPure":true,"kind":"number","lValueRequested":false,"nodeType":"Literal","src":"10240:1:100","typeDescriptions":{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"},"value":"0"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"}],"id":54635,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"nodeType":"ElementaryTypeNameExpression","src":"10232:7:100","typeDescriptions":{"typeIdentifier":"t_type$_t_address_$","typeString":"type(address)"},"typeName":{"id":54634,"name":"address","nodeType":"ElementaryTypeName","src":"10232:7:100","typeDescriptions":{}}},"id":54637,"isConstant":false,"isLValue":false,"isPure":true,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"10232:10:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"src":"10203:39:100","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},{"hexValue":"4665746368436861696e496e666f4f75747075743a20616e63686f725374617465526567697374727950726f7879206e6f7420736574","id":54639,"isConstant":false,"isLValue":false,"isPure":true,"kind":"string","lValueRequested":false,"nodeType":"Literal","src":"10244:56:100","typeDescriptions":{"typeIdentifier":"t_stringliteral_6391076785d7152b9570ce8338ca2e43a749144cb3dbb7f9e5e1de5fabfbae48","typeString":"literal_string \"FetchChainInfoOutput: anchorStateRegistryProxy not set\""},"value":"FetchChainInfoOutput: anchorStateRegistryProxy not set"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_bool","typeString":"bool"},{"typeIdentifier":"t_stringliteral_6391076785d7152b9570ce8338ca2e43a749144cb3dbb7f9e5e1de5fabfbae48","typeString":"literal_string \"FetchChainInfoOutput: anchorStateRegistryProxy not set\""}],"id":54632,"name":"require","nodeType":"Identifier","overloadedDeclarations":[-18,-18,-18],"referencedDeclaration":-18,"src":"10195:7:100","typeDescriptions":{"typeIdentifier":"t_function_require_pure$_t_bool_$_t_string_memory_ptr_$returns$__$","typeString":"function (bool,string memory) pure"}},"id":54640,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"10195:106:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":54641,"nodeType":"ExpressionStatement","src":"10195:106:100"},{"expression":{"id":54642,"name":"_anchorStateRegistryProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54069,"src":"10318:25:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"functionReturnParameters":54631,"id":54643,"nodeType":"Return","src":"10311:32:100"}]},"functionSelector":"35596f76","implemented":true,"kind":"function","modifiers":[],"name":"anchorStateRegistryProxy","nameLocation":"10128:24:100","parameters":{"id":54628,"nodeType":"ParameterList","parameters":[],"src":"10152:2:100"},"returnParameters":{"id":54631,"nodeType":"ParameterList","parameters":[{"constant":false,"id":54630,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":54645,"src":"10176:7:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":54629,"name":"address","nodeType":"ElementaryTypeName","src":"10176:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"10175:9:100"},"scope":54911,"stateMutability":"view","virtual":false,"visibility":"public"},{"id":54653,"nodeType":"FunctionDefinition","src":"10356:131:100","nodes":[],"body":{"id":54652,"nodeType":"Block","src":"10430:57:100","nodes":[],"statements":[{"expression":{"id":54650,"name":"_delayedWethPermissionedGameProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54071,"src":"10447:33:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"functionReturnParameters":54649,"id":54651,"nodeType":"Return","src":"10440:40:100"}]},"functionSelector":"794836d7","implemented":true,"kind":"function","modifiers":[],"name":"delayedWethPermissionedGameProxy","nameLocation":"10365:32:100","parameters":{"id":54646,"nodeType":"ParameterList","parameters":[],"src":"10397:2:100"},"returnParameters":{"id":54649,"nodeType":"ParameterList","parameters":[{"constant":false,"id":54648,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":54653,"src":"10421:7:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":54647,"name":"address","nodeType":"ElementaryTypeName","src":"10421:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"10420:9:100"},"scope":54911,"stateMutability":"view","virtual":false,"visibility":"public"},{"id":54661,"nodeType":"FunctionDefinition","src":"10493:135:100","nodes":[],"body":{"id":54660,"nodeType":"Block","src":"10569:59:100","nodes":[],"statements":[{"expression":{"id":54658,"name":"_delayedWethPermissionlessGameProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54073,"src":"10586:35:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"functionReturnParameters":54657,"id":54659,"nodeType":"Return","src":"10579:42:100"}]},"functionSelector":"97068797","implemented":true,"kind":"function","modifiers":[],"name":"delayedWethPermissionlessGameProxy","nameLocation":"10502:34:100","parameters":{"id":54654,"nodeType":"ParameterList","parameters":[],"src":"10536:2:100"},"returnParameters":{"id":54657,"nodeType":"ParameterList","parameters":[{"constant":false,"id":54656,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":54661,"src":"10560:7:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":54655,"name":"address","nodeType":"ElementaryTypeName","src":"10560:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"10559:9:100"},"scope":54911,"stateMutability":"view","virtual":false,"visibility":"public"},{"id":54669,"nodeType":"FunctionDefinition","src":"10634:113:100","nodes":[],"body":{"id":54668,"nodeType":"Block","src":"10699:48:100","nodes":[],"statements":[{"expression":{"id":54666,"name":"_disputeGameFactoryProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54075,"src":"10716:24:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"functionReturnParameters":54665,"id":54667,"nodeType":"Return","src":"10709:31:100"}]},"functionSelector":"6c4568d1","implemented":true,"kind":"function","modifiers":[],"name":"disputeGameFactoryProxy","nameLocation":"10643:23:100","parameters":{"id":54662,"nodeType":"ParameterList","parameters":[],"src":"10666:2:100"},"returnParameters":{"id":54665,"nodeType":"ParameterList","parameters":[{"constant":false,"id":54664,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":54669,"src":"10690:7:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":54663,"name":"address","nodeType":"ElementaryTypeName","src":"10690:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"10689:9:100"},"scope":54911,"stateMutability":"view","virtual":false,"visibility":"public"},{"id":54687,"nodeType":"FunctionDefinition","src":"10753:215:100","nodes":[],"body":{"id":54686,"nodeType":"Block","src":"10815:153:100","nodes":[],"statements":[{"expression":{"arguments":[{"commonType":{"typeIdentifier":"t_address","typeString":"address"},"id":54680,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftExpression":{"id":54675,"name":"_faultDisputeGameImpl","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54077,"src":"10833:21:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"BinaryOperation","operator":"!=","rightExpression":{"arguments":[{"hexValue":"30","id":54678,"isConstant":false,"isLValue":false,"isPure":true,"kind":"number","lValueRequested":false,"nodeType":"Literal","src":"10866:1:100","typeDescriptions":{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"},"value":"0"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"}],"id":54677,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"nodeType":"ElementaryTypeNameExpression","src":"10858:7:100","typeDescriptions":{"typeIdentifier":"t_type$_t_address_$","typeString":"type(address)"},"typeName":{"id":54676,"name":"address","nodeType":"ElementaryTypeName","src":"10858:7:100","typeDescriptions":{}}},"id":54679,"isConstant":false,"isLValue":false,"isPure":true,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"10858:10:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"src":"10833:35:100","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},{"hexValue":"4665746368436861696e496e666f4f75747075743a206661756c744469737075746547616d65496d706c206e6f7420736574","id":54681,"isConstant":false,"isLValue":false,"isPure":true,"kind":"string","lValueRequested":false,"nodeType":"Literal","src":"10870:52:100","typeDescriptions":{"typeIdentifier":"t_stringliteral_baae18cd0fbc1fbf3c566f5918a7a4a780bb1a3d403d2b65d908417b87c06457","typeString":"literal_string \"FetchChainInfoOutput: faultDisputeGameImpl not set\""},"value":"FetchChainInfoOutput: faultDisputeGameImpl not set"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_bool","typeString":"bool"},{"typeIdentifier":"t_stringliteral_baae18cd0fbc1fbf3c566f5918a7a4a780bb1a3d403d2b65d908417b87c06457","typeString":"literal_string \"FetchChainInfoOutput: faultDisputeGameImpl not set\""}],"id":54674,"name":"require","nodeType":"Identifier","overloadedDeclarations":[-18,-18,-18],"referencedDeclaration":-18,"src":"10825:7:100","typeDescriptions":{"typeIdentifier":"t_function_require_pure$_t_bool_$_t_string_memory_ptr_$returns$__$","typeString":"function (bool,string memory) pure"}},"id":54682,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"10825:98:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":54683,"nodeType":"ExpressionStatement","src":"10825:98:100"},{"expression":{"id":54684,"name":"_faultDisputeGameImpl","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54077,"src":"10940:21:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"functionReturnParameters":54673,"id":54685,"nodeType":"Return","src":"10933:28:100"}]},"functionSelector":"dea21984","implemented":true,"kind":"function","modifiers":[],"name":"faultDisputeGameImpl","nameLocation":"10762:20:100","parameters":{"id":54670,"nodeType":"ParameterList","parameters":[],"src":"10782:2:100"},"returnParameters":{"id":54673,"nodeType":"ParameterList","parameters":[{"constant":false,"id":54672,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":54687,"src":"10806:7:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":54671,"name":"address","nodeType":"ElementaryTypeName","src":"10806:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"10805:9:100"},"scope":54911,"stateMutability":"view","virtual":false,"visibility":"public"},{"id":54705,"nodeType":"FunctionDefinition","src":"10974:289:100","nodes":[],"body":{"id":54704,"nodeType":"Block","src":"11046:217:100","nodes":[],"statements":[{"expression":{"arguments":[{"commonType":{"typeIdentifier":"t_address","typeString":"address"},"id":54698,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftExpression":{"id":54693,"name":"_faultDisputeGameCannonKonaImpl","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54079,"src":"11077:31:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"BinaryOperation","operator":"!=","rightExpression":{"arguments":[{"hexValue":"30","id":54696,"isConstant":false,"isLValue":false,"isPure":true,"kind":"number","lValueRequested":false,"nodeType":"Literal","src":"11120:1:100","typeDescriptions":{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"},"value":"0"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"}],"id":54695,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"nodeType":"ElementaryTypeNameExpression","src":"11112:7:100","typeDescriptions":{"typeIdentifier":"t_type$_t_address_$","typeString":"type(address)"},"typeName":{"id":54694,"name":"address","nodeType":"ElementaryTypeName","src":"11112:7:100","typeDescriptions":{}}},"id":54697,"isConstant":false,"isLValue":false,"isPure":true,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"11112:10:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"src":"11077:45:100","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},{"hexValue":"4665746368436861696e496e666f4f75747075743a206661756c744469737075746547616d6543616e6e6f6e4b6f6e61496d706c206e6f7420736574","id":54699,"isConstant":false,"isLValue":false,"isPure":true,"kind":"string","lValueRequested":false,"nodeType":"Literal","src":"11136:62:100","typeDescriptions":{"typeIdentifier":"t_stringliteral_1a6322899b29428b71a9f44d1d2e4f85d48c09a65bfacd98b10709bf7aff2087","typeString":"literal_string \"FetchChainInfoOutput: faultDisputeGameCannonKonaImpl not set\""},"value":"FetchChainInfoOutput: faultDisputeGameCannonKonaImpl not set"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_bool","typeString":"bool"},{"typeIdentifier":"t_stringliteral_1a6322899b29428b71a9f44d1d2e4f85d48c09a65bfacd98b10709bf7aff2087","typeString":"literal_string \"FetchChainInfoOutput: faultDisputeGameCannonKonaImpl not set\""}],"id":54692,"name":"require","nodeType":"Identifier","overloadedDeclarations":[-18,-18,-18],"referencedDeclaration":-18,"src":"11056:7:100","typeDescriptions":{"typeIdentifier":"t_function_require_pure$_t_bool_$_t_string_memory_ptr_$returns$__$","typeString":"function (bool,string memory) pure"}},"id":54700,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"11056:152:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":54701,"nodeType":"ExpressionStatement","src":"11056:152:100"},{"expression":{"id":54702,"name":"_faultDisputeGameCannonKonaImpl","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54079,"src":"11225:31:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"functionReturnParameters":54691,"id":54703,"nodeType":"Return","src":"11218:38:100"}]},"functionSelector":"5d25b21d","implemented":true,"kind":"function","modifiers":[],"name":"faultDisputeGameCannonKonaImpl","nameLocation":"10983:30:100","parameters":{"id":54688,"nodeType":"ParameterList","parameters":[],"src":"11013:2:100"},"returnParameters":{"id":54691,"nodeType":"ParameterList","parameters":[{"constant":false,"id":54690,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":54705,"src":"11037:7:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":54689,"name":"address","nodeType":"ElementaryTypeName","src":"11037:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"11036:9:100"},"scope":54911,"stateMutability":"view","virtual":false,"visibility":"public"},{"id":54723,"nodeType":"FunctionDefinition","src":"11269:167:100","nodes":[],"body":{"id":54722,"nodeType":"Block","src":"11319:117:100","nodes":[],"statements":[{"expression":{"arguments":[{"commonType":{"typeIdentifier":"t_address","typeString":"address"},"id":54716,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftExpression":{"id":54711,"name":"_mipsImpl","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54045,"src":"11337:9:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"BinaryOperation","operator":"!=","rightExpression":{"arguments":[{"hexValue":"30","id":54714,"isConstant":false,"isLValue":false,"isPure":true,"kind":"number","lValueRequested":false,"nodeType":"Literal","src":"11358:1:100","typeDescriptions":{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"},"value":"0"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"}],"id":54713,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"nodeType":"ElementaryTypeNameExpression","src":"11350:7:100","typeDescriptions":{"typeIdentifier":"t_type$_t_address_$","typeString":"type(address)"},"typeName":{"id":54712,"name":"address","nodeType":"ElementaryTypeName","src":"11350:7:100","typeDescriptions":{}}},"id":54715,"isConstant":false,"isLValue":false,"isPure":true,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"11350:10:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"src":"11337:23:100","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},{"hexValue":"4665746368436861696e496e666f4f75747075743a206d697073496d706c206e6f7420736574","id":54717,"isConstant":false,"isLValue":false,"isPure":true,"kind":"string","lValueRequested":false,"nodeType":"Literal","src":"11362:40:100","typeDescriptions":{"typeIdentifier":"t_stringliteral_178867f585ae7eaee2b47a35fdf118ac2b037c387c5937f3b39b1c51f05d7497","typeString":"literal_string \"FetchChainInfoOutput: mipsImpl not set\""},"value":"FetchChainInfoOutput: mipsImpl not set"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_bool","typeString":"bool"},{"typeIdentifier":"t_stringliteral_178867f585ae7eaee2b47a35fdf118ac2b037c387c5937f3b39b1c51f05d7497","typeString":"literal_string \"FetchChainInfoOutput: mipsImpl not set\""}],"id":54710,"name":"require","nodeType":"Identifier","overloadedDeclarations":[-18,-18,-18],"referencedDeclaration":-18,"src":"11329:7:100","typeDescriptions":{"typeIdentifier":"t_function_require_pure$_t_bool_$_t_string_memory_ptr_$returns$__$","typeString":"function (bool,string memory) pure"}},"id":54718,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"11329:74:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":54719,"nodeType":"ExpressionStatement","src":"11329:74:100"},{"expression":{"id":54720,"name":"_mipsImpl","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54045,"src":"11420:9:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"functionReturnParameters":54709,"id":54721,"nodeType":"Return","src":"11413:16:100"}]},"functionSelector":"e303272c","implemented":true,"kind":"function","modifiers":[],"name":"mipsImpl","nameLocation":"11278:8:100","parameters":{"id":54706,"nodeType":"ParameterList","parameters":[],"src":"11286:2:100"},"returnParameters":{"id":54709,"nodeType":"ParameterList","parameters":[{"constant":false,"id":54708,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":54723,"src":"11310:7:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":54707,"name":"address","nodeType":"ElementaryTypeName","src":"11310:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"11309:9:100"},"scope":54911,"stateMutability":"view","virtual":false,"visibility":"public"},{"id":54741,"nodeType":"FunctionDefinition","src":"11442:243:100","nodes":[],"body":{"id":54740,"nodeType":"Block","src":"11511:174:100","nodes":[],"statements":[{"expression":{"arguments":[{"commonType":{"typeIdentifier":"t_address","typeString":"address"},"id":54734,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftExpression":{"id":54729,"name":"_permissionedDisputeGameImpl","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54081,"src":"11529:28:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"BinaryOperation","operator":"!=","rightExpression":{"arguments":[{"hexValue":"30","id":54732,"isConstant":false,"isLValue":false,"isPure":true,"kind":"number","lValueRequested":false,"nodeType":"Literal","src":"11569:1:100","typeDescriptions":{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"},"value":"0"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"}],"id":54731,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"nodeType":"ElementaryTypeNameExpression","src":"11561:7:100","typeDescriptions":{"typeIdentifier":"t_type$_t_address_$","typeString":"type(address)"},"typeName":{"id":54730,"name":"address","nodeType":"ElementaryTypeName","src":"11561:7:100","typeDescriptions":{}}},"id":54733,"isConstant":false,"isLValue":false,"isPure":true,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"11561:10:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"src":"11529:42:100","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},{"hexValue":"4665746368436861696e496e666f4f75747075743a207065726d697373696f6e65644469737075746547616d65496d706c206e6f7420736574","id":54735,"isConstant":false,"isLValue":false,"isPure":true,"kind":"string","lValueRequested":false,"nodeType":"Literal","src":"11573:59:100","typeDescriptions":{"typeIdentifier":"t_stringliteral_234858b97aab3865b03b564f238f9977c62296b1532cb4f809e12678629cae92","typeString":"literal_string \"FetchChainInfoOutput: permissionedDisputeGameImpl not set\""},"value":"FetchChainInfoOutput: permissionedDisputeGameImpl not set"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_bool","typeString":"bool"},{"typeIdentifier":"t_stringliteral_234858b97aab3865b03b564f238f9977c62296b1532cb4f809e12678629cae92","typeString":"literal_string \"FetchChainInfoOutput: permissionedDisputeGameImpl not set\""}],"id":54728,"name":"require","nodeType":"Identifier","overloadedDeclarations":[-18,-18,-18],"referencedDeclaration":-18,"src":"11521:7:100","typeDescriptions":{"typeIdentifier":"t_function_require_pure$_t_bool_$_t_string_memory_ptr_$returns$__$","typeString":"function (bool,string memory) pure"}},"id":54736,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"11521:112:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":54737,"nodeType":"ExpressionStatement","src":"11521:112:100"},{"expression":{"id":54738,"name":"_permissionedDisputeGameImpl","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54081,"src":"11650:28:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"functionReturnParameters":54727,"id":54739,"nodeType":"Return","src":"11643:35:100"}]},"functionSelector":"98ccec3e","implemented":true,"kind":"function","modifiers":[],"name":"permissionedDisputeGameImpl","nameLocation":"11451:27:100","parameters":{"id":54724,"nodeType":"ParameterList","parameters":[],"src":"11478:2:100"},"returnParameters":{"id":54727,"nodeType":"ParameterList","parameters":[{"constant":false,"id":54726,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":54741,"src":"11502:7:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":54725,"name":"address","nodeType":"ElementaryTypeName","src":"11502:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"11501:9:100"},"scope":54911,"stateMutability":"view","virtual":false,"visibility":"public"},{"id":54759,"nodeType":"FunctionDefinition","src":"11691:207:100","nodes":[],"body":{"id":54758,"nodeType":"Block","src":"11751:147:100","nodes":[],"statements":[{"expression":{"arguments":[{"commonType":{"typeIdentifier":"t_address","typeString":"address"},"id":54752,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftExpression":{"id":54747,"name":"_preimageOracleImpl","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54047,"src":"11769:19:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"BinaryOperation","operator":"!=","rightExpression":{"arguments":[{"hexValue":"30","id":54750,"isConstant":false,"isLValue":false,"isPure":true,"kind":"number","lValueRequested":false,"nodeType":"Literal","src":"11800:1:100","typeDescriptions":{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"},"value":"0"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"}],"id":54749,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"nodeType":"ElementaryTypeNameExpression","src":"11792:7:100","typeDescriptions":{"typeIdentifier":"t_type$_t_address_$","typeString":"type(address)"},"typeName":{"id":54748,"name":"address","nodeType":"ElementaryTypeName","src":"11792:7:100","typeDescriptions":{}}},"id":54751,"isConstant":false,"isLValue":false,"isPure":true,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"11792:10:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"src":"11769:33:100","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},{"hexValue":"4665746368436861696e496e666f4f75747075743a20707265696d6167654f7261636c65496d706c206e6f7420736574","id":54753,"isConstant":false,"isLValue":false,"isPure":true,"kind":"string","lValueRequested":false,"nodeType":"Literal","src":"11804:50:100","typeDescriptions":{"typeIdentifier":"t_stringliteral_2434e23032e7627ba1a13e989a9fbe735952d0d6f49e2760e1b1064b8728d538","typeString":"literal_string \"FetchChainInfoOutput: preimageOracleImpl not set\""},"value":"FetchChainInfoOutput: preimageOracleImpl not set"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_bool","typeString":"bool"},{"typeIdentifier":"t_stringliteral_2434e23032e7627ba1a13e989a9fbe735952d0d6f49e2760e1b1064b8728d538","typeString":"literal_string \"FetchChainInfoOutput: preimageOracleImpl not set\""}],"id":54746,"name":"require","nodeType":"Identifier","overloadedDeclarations":[-18,-18,-18],"referencedDeclaration":-18,"src":"11761:7:100","typeDescriptions":{"typeIdentifier":"t_function_require_pure$_t_bool_$_t_string_memory_ptr_$returns$__$","typeString":"function (bool,string memory) pure"}},"id":54754,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"11761:94:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":54755,"nodeType":"ExpressionStatement","src":"11761:94:100"},{"expression":{"id":54756,"name":"_preimageOracleImpl","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54047,"src":"11872:19:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"functionReturnParameters":54745,"id":54757,"nodeType":"Return","src":"11865:26:100"}]},"functionSelector":"d030d2e8","implemented":true,"kind":"function","modifiers":[],"name":"preimageOracleImpl","nameLocation":"11700:18:100","parameters":{"id":54742,"nodeType":"ParameterList","parameters":[],"src":"11718:2:100"},"returnParameters":{"id":54745,"nodeType":"ParameterList","parameters":[{"constant":false,"id":54744,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":54759,"src":"11742:7:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":54743,"name":"address","nodeType":"ElementaryTypeName","src":"11742:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"11741:9:100"},"scope":54911,"stateMutability":"view","virtual":false,"visibility":"public"},{"id":54777,"nodeType":"FunctionDefinition","src":"11904:203:100","nodes":[],"body":{"id":54776,"nodeType":"Block","src":"11963:144:100","nodes":[],"statements":[{"expression":{"arguments":[{"commonType":{"typeIdentifier":"t_address","typeString":"address"},"id":54770,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftExpression":{"id":54765,"name":"_systemConfigOwner","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54083,"src":"11981:18:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"BinaryOperation","operator":"!=","rightExpression":{"arguments":[{"hexValue":"30","id":54768,"isConstant":false,"isLValue":false,"isPure":true,"kind":"number","lValueRequested":false,"nodeType":"Literal","src":"12011:1:100","typeDescriptions":{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"},"value":"0"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"}],"id":54767,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"nodeType":"ElementaryTypeNameExpression","src":"12003:7:100","typeDescriptions":{"typeIdentifier":"t_type$_t_address_$","typeString":"type(address)"},"typeName":{"id":54766,"name":"address","nodeType":"ElementaryTypeName","src":"12003:7:100","typeDescriptions":{}}},"id":54769,"isConstant":false,"isLValue":false,"isPure":true,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"12003:10:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"src":"11981:32:100","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},{"hexValue":"4665746368436861696e496e666f4f75747075743a2073797374656d436f6e6669674f776e6572206e6f7420736574","id":54771,"isConstant":false,"isLValue":false,"isPure":true,"kind":"string","lValueRequested":false,"nodeType":"Literal","src":"12015:49:100","typeDescriptions":{"typeIdentifier":"t_stringliteral_fc7a67f4775c5e19ca3731b64db9f9f8895dcd37a01bc895f1d1806a7f21c916","typeString":"literal_string \"FetchChainInfoOutput: systemConfigOwner not set\""},"value":"FetchChainInfoOutput: systemConfigOwner not set"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_bool","typeString":"bool"},{"typeIdentifier":"t_stringliteral_fc7a67f4775c5e19ca3731b64db9f9f8895dcd37a01bc895f1d1806a7f21c916","typeString":"literal_string \"FetchChainInfoOutput: systemConfigOwner not set\""}],"id":54764,"name":"require","nodeType":"Identifier","overloadedDeclarations":[-18,-18,-18],"referencedDeclaration":-18,"src":"11973:7:100","typeDescriptions":{"typeIdentifier":"t_function_require_pure$_t_bool_$_t_string_memory_ptr_$returns$__$","typeString":"function (bool,string memory) pure"}},"id":54772,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"11973:92:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":54773,"nodeType":"ExpressionStatement","src":"11973:92:100"},{"expression":{"id":54774,"name":"_systemConfigOwner","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54083,"src":"12082:18:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"functionReturnParameters":54763,"id":54775,"nodeType":"Return","src":"12075:25:100"}]},"functionSelector":"1e229b20","implemented":true,"kind":"function","modifiers":[],"name":"systemConfigOwner","nameLocation":"11913:17:100","parameters":{"id":54760,"nodeType":"ParameterList","parameters":[],"src":"11930:2:100"},"returnParameters":{"id":54763,"nodeType":"ParameterList","parameters":[{"constant":false,"id":54762,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":54777,"src":"11954:7:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":54761,"name":"address","nodeType":"ElementaryTypeName","src":"11954:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"11953:9:100"},"scope":54911,"stateMutability":"view","virtual":false,"visibility":"public"},{"id":54795,"nodeType":"FunctionDefinition","src":"12113:223:100","nodes":[],"body":{"id":54794,"nodeType":"Block","src":"12177:159:100","nodes":[],"statements":[{"expression":{"arguments":[{"commonType":{"typeIdentifier":"t_address","typeString":"address"},"id":54788,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftExpression":{"id":54783,"name":"_opChainProxyAdminOwner","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54085,"src":"12195:23:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"BinaryOperation","operator":"!=","rightExpression":{"arguments":[{"hexValue":"30","id":54786,"isConstant":false,"isLValue":false,"isPure":true,"kind":"number","lValueRequested":false,"nodeType":"Literal","src":"12230:1:100","typeDescriptions":{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"},"value":"0"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"}],"id":54785,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"nodeType":"ElementaryTypeNameExpression","src":"12222:7:100","typeDescriptions":{"typeIdentifier":"t_type$_t_address_$","typeString":"type(address)"},"typeName":{"id":54784,"name":"address","nodeType":"ElementaryTypeName","src":"12222:7:100","typeDescriptions":{}}},"id":54787,"isConstant":false,"isLValue":false,"isPure":true,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"12222:10:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"src":"12195:37:100","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},{"hexValue":"4665746368436861696e496e666f4f75747075743a206f70436861696e50726f787941646d696e4f776e6572206e6f7420736574","id":54789,"isConstant":false,"isLValue":false,"isPure":true,"kind":"string","lValueRequested":false,"nodeType":"Literal","src":"12234:54:100","typeDescriptions":{"typeIdentifier":"t_stringliteral_cc12cbf05d2d853ebebe6e25c8b02d2f78d6af131087a61088362ca7d0befc81","typeString":"literal_string \"FetchChainInfoOutput: opChainProxyAdminOwner not set\""},"value":"FetchChainInfoOutput: opChainProxyAdminOwner not set"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_bool","typeString":"bool"},{"typeIdentifier":"t_stringliteral_cc12cbf05d2d853ebebe6e25c8b02d2f78d6af131087a61088362ca7d0befc81","typeString":"literal_string \"FetchChainInfoOutput: opChainProxyAdminOwner not set\""}],"id":54782,"name":"require","nodeType":"Identifier","overloadedDeclarations":[-18,-18,-18],"referencedDeclaration":-18,"src":"12187:7:100","typeDescriptions":{"typeIdentifier":"t_function_require_pure$_t_bool_$_t_string_memory_ptr_$returns$__$","typeString":"function (bool,string memory) pure"}},"id":54790,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"12187:102:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":54791,"nodeType":"ExpressionStatement","src":"12187:102:100"},{"expression":{"id":54792,"name":"_opChainProxyAdminOwner","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54085,"src":"12306:23:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"functionReturnParameters":54781,"id":54793,"nodeType":"Return","src":"12299:30:100"}]},"functionSelector":"1480f0cc","implemented":true,"kind":"function","modifiers":[],"name":"opChainProxyAdminOwner","nameLocation":"12122:22:100","parameters":{"id":54778,"nodeType":"ParameterList","parameters":[],"src":"12144:2:100"},"returnParameters":{"id":54781,"nodeType":"ParameterList","parameters":[{"constant":false,"id":54780,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":54795,"src":"12168:7:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":54779,"name":"address","nodeType":"ElementaryTypeName","src":"12168:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"12167:9:100"},"scope":54911,"stateMutability":"view","virtual":false,"visibility":"public"},{"id":54813,"nodeType":"FunctionDefinition","src":"12342:195:100","nodes":[],"body":{"id":54812,"nodeType":"Block","src":"12399:138:100","nodes":[],"statements":[{"expression":{"arguments":[{"commonType":{"typeIdentifier":"t_address","typeString":"address"},"id":54806,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftExpression":{"id":54801,"name":"_opChainGuardian","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54087,"src":"12417:16:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"BinaryOperation","operator":"!=","rightExpression":{"arguments":[{"hexValue":"30","id":54804,"isConstant":false,"isLValue":false,"isPure":true,"kind":"number","lValueRequested":false,"nodeType":"Literal","src":"12445:1:100","typeDescriptions":{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"},"value":"0"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"}],"id":54803,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"nodeType":"ElementaryTypeNameExpression","src":"12437:7:100","typeDescriptions":{"typeIdentifier":"t_type$_t_address_$","typeString":"type(address)"},"typeName":{"id":54802,"name":"address","nodeType":"ElementaryTypeName","src":"12437:7:100","typeDescriptions":{}}},"id":54805,"isConstant":false,"isLValue":false,"isPure":true,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"12437:10:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"src":"12417:30:100","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},{"hexValue":"4665746368436861696e496e666f4f75747075743a206f70436861696e477561726469616e206e6f7420736574","id":54807,"isConstant":false,"isLValue":false,"isPure":true,"kind":"string","lValueRequested":false,"nodeType":"Literal","src":"12449:47:100","typeDescriptions":{"typeIdentifier":"t_stringliteral_ab71487628da5c56ff40f228ee915a62d6c0a28ab899f48f84343df6dbc48bb7","typeString":"literal_string \"FetchChainInfoOutput: opChainGuardian not set\""},"value":"FetchChainInfoOutput: opChainGuardian not set"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_bool","typeString":"bool"},{"typeIdentifier":"t_stringliteral_ab71487628da5c56ff40f228ee915a62d6c0a28ab899f48f84343df6dbc48bb7","typeString":"literal_string \"FetchChainInfoOutput: opChainGuardian not set\""}],"id":54800,"name":"require","nodeType":"Identifier","overloadedDeclarations":[-18,-18,-18],"referencedDeclaration":-18,"src":"12409:7:100","typeDescriptions":{"typeIdentifier":"t_function_require_pure$_t_bool_$_t_string_memory_ptr_$returns$__$","typeString":"function (bool,string memory) pure"}},"id":54808,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"12409:88:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":54809,"nodeType":"ExpressionStatement","src":"12409:88:100"},{"expression":{"id":54810,"name":"_opChainGuardian","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54087,"src":"12514:16:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"functionReturnParameters":54799,"id":54811,"nodeType":"Return","src":"12507:23:100"}]},"functionSelector":"4bc2695f","implemented":true,"kind":"function","modifiers":[],"name":"opChainGuardian","nameLocation":"12351:15:100","parameters":{"id":54796,"nodeType":"ParameterList","parameters":[],"src":"12366:2:100"},"returnParameters":{"id":54799,"nodeType":"ParameterList","parameters":[{"constant":false,"id":54798,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":54813,"src":"12390:7:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":54797,"name":"address","nodeType":"ElementaryTypeName","src":"12390:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"12389:9:100"},"scope":54911,"stateMutability":"view","virtual":false,"visibility":"public"},{"id":54831,"nodeType":"FunctionDefinition","src":"12543:175:100","nodes":[],"body":{"id":54830,"nodeType":"Block","src":"12595:123:100","nodes":[],"statements":[{"expression":{"arguments":[{"commonType":{"typeIdentifier":"t_address","typeString":"address"},"id":54824,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftExpression":{"id":54819,"name":"_challenger","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54089,"src":"12613:11:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"BinaryOperation","operator":"!=","rightExpression":{"arguments":[{"hexValue":"30","id":54822,"isConstant":false,"isLValue":false,"isPure":true,"kind":"number","lValueRequested":false,"nodeType":"Literal","src":"12636:1:100","typeDescriptions":{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"},"value":"0"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"}],"id":54821,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"nodeType":"ElementaryTypeNameExpression","src":"12628:7:100","typeDescriptions":{"typeIdentifier":"t_type$_t_address_$","typeString":"type(address)"},"typeName":{"id":54820,"name":"address","nodeType":"ElementaryTypeName","src":"12628:7:100","typeDescriptions":{}}},"id":54823,"isConstant":false,"isLValue":false,"isPure":true,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"12628:10:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"src":"12613:25:100","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},{"hexValue":"4665746368436861696e496e666f4f75747075743a206368616c6c656e676572206e6f7420736574","id":54825,"isConstant":false,"isLValue":false,"isPure":true,"kind":"string","lValueRequested":false,"nodeType":"Literal","src":"12640:42:100","typeDescriptions":{"typeIdentifier":"t_stringliteral_d1dd717c39956ee86b1eb77b9f3cb6dbeca6df99b330f67dd364a35a1174c2ce","typeString":"literal_string \"FetchChainInfoOutput: challenger not set\""},"value":"FetchChainInfoOutput: challenger not set"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_bool","typeString":"bool"},{"typeIdentifier":"t_stringliteral_d1dd717c39956ee86b1eb77b9f3cb6dbeca6df99b330f67dd364a35a1174c2ce","typeString":"literal_string \"FetchChainInfoOutput: challenger not set\""}],"id":54818,"name":"require","nodeType":"Identifier","overloadedDeclarations":[-18,-18,-18],"referencedDeclaration":-18,"src":"12605:7:100","typeDescriptions":{"typeIdentifier":"t_function_require_pure$_t_bool_$_t_string_memory_ptr_$returns$__$","typeString":"function (bool,string memory) pure"}},"id":54826,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"12605:78:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":54827,"nodeType":"ExpressionStatement","src":"12605:78:100"},{"expression":{"id":54828,"name":"_challenger","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54089,"src":"12700:11:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"functionReturnParameters":54817,"id":54829,"nodeType":"Return","src":"12693:18:100"}]},"functionSelector":"534db0e2","implemented":true,"kind":"function","modifiers":[],"name":"challenger","nameLocation":"12552:10:100","parameters":{"id":54814,"nodeType":"ParameterList","parameters":[],"src":"12562:2:100"},"returnParameters":{"id":54817,"nodeType":"ParameterList","parameters":[{"constant":false,"id":54816,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":54831,"src":"12586:7:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":54815,"name":"address","nodeType":"ElementaryTypeName","src":"12586:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"12585:9:100"},"scope":54911,"stateMutability":"view","virtual":false,"visibility":"public"},{"id":54849,"nodeType":"FunctionDefinition","src":"12724:167:100","nodes":[],"body":{"id":54848,"nodeType":"Block","src":"12774:117:100","nodes":[],"statements":[{"expression":{"arguments":[{"commonType":{"typeIdentifier":"t_address","typeString":"address"},"id":54842,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftExpression":{"id":54837,"name":"_proposer","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54091,"src":"12792:9:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"BinaryOperation","operator":"!=","rightExpression":{"arguments":[{"hexValue":"30","id":54840,"isConstant":false,"isLValue":false,"isPure":true,"kind":"number","lValueRequested":false,"nodeType":"Literal","src":"12813:1:100","typeDescriptions":{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"},"value":"0"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"}],"id":54839,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"nodeType":"ElementaryTypeNameExpression","src":"12805:7:100","typeDescriptions":{"typeIdentifier":"t_type$_t_address_$","typeString":"type(address)"},"typeName":{"id":54838,"name":"address","nodeType":"ElementaryTypeName","src":"12805:7:100","typeDescriptions":{}}},"id":54841,"isConstant":false,"isLValue":false,"isPure":true,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"12805:10:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"src":"12792:23:100","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},{"hexValue":"4665746368436861696e496e666f4f75747075743a2070726f706f736572206e6f7420736574","id":54843,"isConstant":false,"isLValue":false,"isPure":true,"kind":"string","lValueRequested":false,"nodeType":"Literal","src":"12817:40:100","typeDescriptions":{"typeIdentifier":"t_stringliteral_c4910753f64240b424591ec2bc873e5a728ff321d57cb1a353788ad2c385da71","typeString":"literal_string \"FetchChainInfoOutput: proposer not set\""},"value":"FetchChainInfoOutput: proposer not set"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_bool","typeString":"bool"},{"typeIdentifier":"t_stringliteral_c4910753f64240b424591ec2bc873e5a728ff321d57cb1a353788ad2c385da71","typeString":"literal_string \"FetchChainInfoOutput: proposer not set\""}],"id":54836,"name":"require","nodeType":"Identifier","overloadedDeclarations":[-18,-18,-18],"referencedDeclaration":-18,"src":"12784:7:100","typeDescriptions":{"typeIdentifier":"t_function_require_pure$_t_bool_$_t_string_memory_ptr_$returns$__$","typeString":"function (bool,string memory) pure"}},"id":54844,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"12784:74:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":54845,"nodeType":"ExpressionStatement","src":"12784:74:100"},{"expression":{"id":54846,"name":"_proposer","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54091,"src":"12875:9:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"functionReturnParameters":54835,"id":54847,"nodeType":"Return","src":"12868:16:100"}]},"functionSelector":"a8e4fb90","implemented":true,"kind":"function","modifiers":[],"name":"proposer","nameLocation":"12733:8:100","parameters":{"id":54832,"nodeType":"ParameterList","parameters":[],"src":"12741:2:100"},"returnParameters":{"id":54835,"nodeType":"ParameterList","parameters":[{"constant":false,"id":54834,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":54849,"src":"12765:7:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":54833,"name":"address","nodeType":"ElementaryTypeName","src":"12765:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"12764:9:100"},"scope":54911,"stateMutability":"view","virtual":false,"visibility":"public"},{"id":54867,"nodeType":"FunctionDefinition","src":"12897:203:100","nodes":[],"body":{"id":54866,"nodeType":"Block","src":"12956:144:100","nodes":[],"statements":[{"expression":{"arguments":[{"commonType":{"typeIdentifier":"t_address","typeString":"address"},"id":54860,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftExpression":{"id":54855,"name":"_unsafeBlockSigner","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54093,"src":"12974:18:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"BinaryOperation","operator":"!=","rightExpression":{"arguments":[{"hexValue":"30","id":54858,"isConstant":false,"isLValue":false,"isPure":true,"kind":"number","lValueRequested":false,"nodeType":"Literal","src":"13004:1:100","typeDescriptions":{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"},"value":"0"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"}],"id":54857,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"nodeType":"ElementaryTypeNameExpression","src":"12996:7:100","typeDescriptions":{"typeIdentifier":"t_type$_t_address_$","typeString":"type(address)"},"typeName":{"id":54856,"name":"address","nodeType":"ElementaryTypeName","src":"12996:7:100","typeDescriptions":{}}},"id":54859,"isConstant":false,"isLValue":false,"isPure":true,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"12996:10:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"src":"12974:32:100","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},{"hexValue":"4665746368436861696e496e666f4f75747075743a20756e73616665426c6f636b5369676e6572206e6f7420736574","id":54861,"isConstant":false,"isLValue":false,"isPure":true,"kind":"string","lValueRequested":false,"nodeType":"Literal","src":"13008:49:100","typeDescriptions":{"typeIdentifier":"t_stringliteral_c0c85432d1596fb73656e29b64f6ea745166dde4a7fa6163bfe6b285aea851d7","typeString":"literal_string \"FetchChainInfoOutput: unsafeBlockSigner not set\""},"value":"FetchChainInfoOutput: unsafeBlockSigner not set"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_bool","typeString":"bool"},{"typeIdentifier":"t_stringliteral_c0c85432d1596fb73656e29b64f6ea745166dde4a7fa6163bfe6b285aea851d7","typeString":"literal_string \"FetchChainInfoOutput: unsafeBlockSigner not set\""}],"id":54854,"name":"require","nodeType":"Identifier","overloadedDeclarations":[-18,-18,-18],"referencedDeclaration":-18,"src":"12966:7:100","typeDescriptions":{"typeIdentifier":"t_function_require_pure$_t_bool_$_t_string_memory_ptr_$returns$__$","typeString":"function (bool,string memory) pure"}},"id":54862,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"12966:92:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":54863,"nodeType":"ExpressionStatement","src":"12966:92:100"},{"expression":{"id":54864,"name":"_unsafeBlockSigner","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54093,"src":"13075:18:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"functionReturnParameters":54853,"id":54865,"nodeType":"Return","src":"13068:25:100"}]},"functionSelector":"1fd19ee1","implemented":true,"kind":"function","modifiers":[],"name":"unsafeBlockSigner","nameLocation":"12906:17:100","parameters":{"id":54850,"nodeType":"ParameterList","parameters":[],"src":"12923:2:100"},"returnParameters":{"id":54853,"nodeType":"ParameterList","parameters":[{"constant":false,"id":54852,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":54867,"src":"12947:7:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":54851,"name":"address","nodeType":"ElementaryTypeName","src":"12947:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"12946:9:100"},"scope":54911,"stateMutability":"view","virtual":false,"visibility":"public"},{"id":54885,"nodeType":"FunctionDefinition","src":"13106:191:100","nodes":[],"body":{"id":54884,"nodeType":"Block","src":"13162:135:100","nodes":[],"statements":[{"expression":{"arguments":[{"commonType":{"typeIdentifier":"t_address","typeString":"address"},"id":54878,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftExpression":{"id":54873,"name":"_batchSubmitter","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54095,"src":"13180:15:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"BinaryOperation","operator":"!=","rightExpression":{"arguments":[{"hexValue":"30","id":54876,"isConstant":false,"isLValue":false,"isPure":true,"kind":"number","lValueRequested":false,"nodeType":"Literal","src":"13207:1:100","typeDescriptions":{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"},"value":"0"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"}],"id":54875,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"nodeType":"ElementaryTypeNameExpression","src":"13199:7:100","typeDescriptions":{"typeIdentifier":"t_type$_t_address_$","typeString":"type(address)"},"typeName":{"id":54874,"name":"address","nodeType":"ElementaryTypeName","src":"13199:7:100","typeDescriptions":{}}},"id":54877,"isConstant":false,"isLValue":false,"isPure":true,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"13199:10:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"src":"13180:29:100","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},{"hexValue":"4665746368436861696e496e666f4f75747075743a2062617463685375626d6974746572206e6f7420736574","id":54879,"isConstant":false,"isLValue":false,"isPure":true,"kind":"string","lValueRequested":false,"nodeType":"Literal","src":"13211:46:100","typeDescriptions":{"typeIdentifier":"t_stringliteral_dc2094d90bbe21c62e4087e13d121e3f8b0b046ea0a70d61432535290d56a2cc","typeString":"literal_string \"FetchChainInfoOutput: batchSubmitter not set\""},"value":"FetchChainInfoOutput: batchSubmitter not set"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_bool","typeString":"bool"},{"typeIdentifier":"t_stringliteral_dc2094d90bbe21c62e4087e13d121e3f8b0b046ea0a70d61432535290d56a2cc","typeString":"literal_string \"FetchChainInfoOutput: batchSubmitter not set\""}],"id":54872,"name":"require","nodeType":"Identifier","overloadedDeclarations":[-18,-18,-18],"referencedDeclaration":-18,"src":"13172:7:100","typeDescriptions":{"typeIdentifier":"t_function_require_pure$_t_bool_$_t_string_memory_ptr_$returns$__$","typeString":"function (bool,string memory) pure"}},"id":54880,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"13172:86:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":54881,"nodeType":"ExpressionStatement","src":"13172:86:100"},{"expression":{"id":54882,"name":"_batchSubmitter","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54095,"src":"13275:15:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"functionReturnParameters":54871,"id":54883,"nodeType":"Return","src":"13268:22:100"}]},"functionSelector":"fb951e9d","implemented":true,"kind":"function","modifiers":[],"name":"batchSubmitter","nameLocation":"13115:14:100","parameters":{"id":54868,"nodeType":"ParameterList","parameters":[],"src":"13129:2:100"},"returnParameters":{"id":54871,"nodeType":"ParameterList","parameters":[{"constant":false,"id":54870,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":54885,"src":"13153:7:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":54869,"name":"address","nodeType":"ElementaryTypeName","src":"13153:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"13152:9:100"},"scope":54911,"stateMutability":"view","virtual":false,"visibility":"public"},{"id":54893,"nodeType":"FunctionDefinition","src":"13303:88:100","nodes":[],"body":{"id":54892,"nodeType":"Block","src":"13354:37:100","nodes":[],"statements":[{"expression":{"id":54890,"name":"_permissioned","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54097,"src":"13371:13:100","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},"functionReturnParameters":54889,"id":54891,"nodeType":"Return","src":"13364:20:100"}]},"functionSelector":"3cc162f1","implemented":true,"kind":"function","modifiers":[],"name":"permissioned","nameLocation":"13312:12:100","parameters":{"id":54886,"nodeType":"ParameterList","parameters":[],"src":"13324:2:100"},"returnParameters":{"id":54889,"nodeType":"ParameterList","parameters":[{"constant":false,"id":54888,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":54893,"src":"13348:4:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"},"typeName":{"id":54887,"name":"bool","nodeType":"ElementaryTypeName","src":"13348:4:100","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},"visibility":"internal"}],"src":"13347:6:100"},"scope":54911,"stateMutability":"view","virtual":false,"visibility":"public"},{"id":54901,"nodeType":"FunctionDefinition","src":"13397:92:100","nodes":[],"body":{"id":54900,"nodeType":"Block","src":"13450:39:100","nodes":[],"statements":[{"expression":{"id":54898,"name":"_permissionless","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54099,"src":"13467:15:100","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},"functionReturnParameters":54897,"id":54899,"nodeType":"Return","src":"13460:22:100"}]},"functionSelector":"a1256f9f","implemented":true,"kind":"function","modifiers":[],"name":"permissionless","nameLocation":"13406:14:100","parameters":{"id":54894,"nodeType":"ParameterList","parameters":[],"src":"13420:2:100"},"returnParameters":{"id":54897,"nodeType":"ParameterList","parameters":[{"constant":false,"id":54896,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":54901,"src":"13444:4:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"},"typeName":{"id":54895,"name":"bool","nodeType":"ElementaryTypeName","src":"13444:4:100","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},"visibility":"internal"}],"src":"13443:6:100"},"scope":54911,"stateMutability":"view","virtual":false,"visibility":"public"},{"id":54910,"nodeType":"FunctionDefinition","src":"13495:102:100","nodes":[],"body":{"id":54909,"nodeType":"Block","src":"13555:42:100","nodes":[],"statements":[{"expression":{"id":54907,"name":"_respectedGameType","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54102,"src":"13572:18:100","typeDescriptions":{"typeIdentifier":"t_userDefinedValueType$_GameType_$70720","typeString":"GameType"}},"functionReturnParameters":54906,"id":54908,"nodeType":"Return","src":"13565:25:100"}]},"functionSelector":"3c9f397c","implemented":true,"kind":"function","modifiers":[],"name":"respectedGameType","nameLocation":"13504:17:100","parameters":{"id":54902,"nodeType":"ParameterList","parameters":[],"src":"13521:2:100"},"returnParameters":{"id":54906,"nodeType":"ParameterList","parameters":[{"constant":false,"id":54905,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":54910,"src":"13545:8:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_userDefinedValueType$_GameType_$70720","typeString":"GameType"},"typeName":{"id":54904,"nodeType":"UserDefinedTypeName","pathNode":{"id":54903,"name":"GameType","nameLocations":["13545:8:100"],"nodeType":"IdentifierPath","referencedDeclaration":70720,"src":"13545:8:100"},"referencedDeclaration":70720,"src":"13545:8:100","typeDescriptions":{"typeIdentifier":"t_userDefinedValueType$_GameType_$70720","typeString":"GameType"}},"visibility":"internal"}],"src":"13544:10:100"},"scope":54911,"stateMutability":"view","virtual":false,"visibility":"public"}],"abstract":false,"baseContracts":[],"canonicalName":"FetchChainInfoOutput","contractDependencies":[],"contractKind":"contract","fullyImplemented":true,"linearizedBaseContracts":[54911],"name":"FetchChainInfoOutput","nameLocation":"2966:20:100","scope":56019,"usedErrors":[],"usedEvents":[]},{"id":56018,"nodeType":"ContractDefinition","src":"13601:11550:100","nodes":[{"id":54937,"nodeType":"FunctionDefinition","src":"13641:198:100","nodes":[],"body":{"id":54936,"nodeType":"Block","src":"13712:127:100","nodes":[],"statements":[{"expression":{"arguments":[{"id":54923,"name":"_fi","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54916,"src":"13743:3:100","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoInput_$54041","typeString":"contract FetchChainInfoInput"}},{"id":54924,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54919,"src":"13748:3:100","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$54911","typeString":"contract FetchChainInfoOutput"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_contract$_FetchChainInfoInput_$54041","typeString":"contract FetchChainInfoInput"},{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$54911","typeString":"contract FetchChainInfoOutput"}],"id":54922,"name":"_processSystemConfig","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55073,"src":"13722:20:100","typeDescriptions":{"typeIdentifier":"t_function_internal_nonpayable$_t_contract$_FetchChainInfoInput_$54041_$_t_contract$_FetchChainInfoOutput_$54911_$returns$__$","typeString":"function (contract FetchChainInfoInput,contract FetchChainInfoOutput)"}},"id":54925,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"13722:30:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":54926,"nodeType":"ExpressionStatement","src":"13722:30:100"},{"expression":{"arguments":[{"id":54928,"name":"_fi","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54916,"src":"13789:3:100","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoInput_$54041","typeString":"contract FetchChainInfoInput"}},{"id":54929,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54919,"src":"13794:3:100","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$54911","typeString":"contract FetchChainInfoOutput"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_contract$_FetchChainInfoInput_$54041","typeString":"contract FetchChainInfoInput"},{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$54911","typeString":"contract FetchChainInfoOutput"}],"id":54927,"name":"_processMessengerAndPortal","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55190,"src":"13762:26:100","typeDescriptions":{"typeIdentifier":"t_function_internal_nonpayable$_t_contract$_FetchChainInfoInput_$54041_$_t_contract$_FetchChainInfoOutput_$54911_$returns$__$","typeString":"function (contract FetchChainInfoInput,contract FetchChainInfoOutput)"}},"id":54930,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"13762:36:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":54931,"nodeType":"ExpressionStatement","src":"13762:36:100"},{"expression":{"arguments":[{"id":54933,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54919,"src":"13828:3:100","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$54911","typeString":"contract FetchChainInfoOutput"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$54911","typeString":"contract FetchChainInfoOutput"}],"id":54932,"name":"_processFaultProofs","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55565,"src":"13808:19:100","typeDescriptions":{"typeIdentifier":"t_function_internal_nonpayable$_t_contract$_FetchChainInfoOutput_$54911_$returns$__$","typeString":"function (contract FetchChainInfoOutput)"}},"id":54934,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"13808:24:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":54935,"nodeType":"ExpressionStatement","src":"13808:24:100"}]},"functionSelector":"fc4dcacb","implemented":true,"kind":"function","modifiers":[],"name":"run","nameLocation":"13650:3:100","parameters":{"id":54920,"nodeType":"ParameterList","parameters":[{"constant":false,"id":54916,"mutability":"mutable","name":"_fi","nameLocation":"13674:3:100","nodeType":"VariableDeclaration","scope":54937,"src":"13654:23:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoInput_$54041","typeString":"contract FetchChainInfoInput"},"typeName":{"id":54915,"nodeType":"UserDefinedTypeName","pathNode":{"id":54914,"name":"FetchChainInfoInput","nameLocations":["13654:19:100"],"nodeType":"IdentifierPath","referencedDeclaration":54041,"src":"13654:19:100"},"referencedDeclaration":54041,"src":"13654:19:100","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoInput_$54041","typeString":"contract FetchChainInfoInput"}},"visibility":"internal"},{"constant":false,"id":54919,"mutability":"mutable","name":"_fo","nameLocation":"13700:3:100","nodeType":"VariableDeclaration","scope":54937,"src":"13679:24:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$54911","typeString":"contract FetchChainInfoOutput"},"typeName":{"id":54918,"nodeType":"UserDefinedTypeName","pathNode":{"id":54917,"name":"FetchChainInfoOutput","nameLocations":["13679:20:100"],"nodeType":"IdentifierPath","referencedDeclaration":54911,"src":"13679:20:100"},"referencedDeclaration":54911,"src":"13679:20:100","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$54911","typeString":"contract FetchChainInfoOutput"}},"visibility":"internal"}],"src":"13653:51:100"},"returnParameters":{"id":54921,"nodeType":"ParameterList","parameters":[],"src":"13712:0:100"},"scope":56018,"stateMutability":"nonpayable","virtual":false,"visibility":"public"},{"id":55073,"nodeType":"FunctionDefinition","src":"13845:1336:100","nodes":[],"body":{"id":55072,"nodeType":"Block","src":"13935:1246:100","nodes":[],"statements":[{"assignments":[54947],"declarations":[{"constant":false,"id":54947,"mutability":"mutable","name":"systemConfigProxy","nameLocation":"13953:17:100","nodeType":"VariableDeclaration","scope":55072,"src":"13945:25:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":54946,"name":"address","nodeType":"ElementaryTypeName","src":"13945:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"id":54951,"initialValue":{"arguments":[],"expression":{"argumentTypes":[],"expression":{"id":54948,"name":"_fi","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54940,"src":"13973:3:100","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoInput_$54041","typeString":"contract FetchChainInfoInput"}},"id":54949,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"13977:17:100","memberName":"systemConfigProxy","nodeType":"MemberAccess","referencedDeclaration":54022,"src":"13973:21:100","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":54950,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"13973:23:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"VariableDeclarationStatement","src":"13945:51:100"},{"expression":{"arguments":[{"expression":{"expression":{"id":54955,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54943,"src":"14014:3:100","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$54911","typeString":"contract FetchChainInfoOutput"}},"id":54956,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"14018:17:100","memberName":"systemConfigProxy","nodeType":"MemberAccess","referencedDeclaration":54591,"src":"14014:21:100","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":54957,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"14036:8:100","memberName":"selector","nodeType":"MemberAccess","src":"14014:30:100","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},{"id":54958,"name":"systemConfigProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54947,"src":"14046:17:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_bytes4","typeString":"bytes4"},{"typeIdentifier":"t_address","typeString":"address"}],"expression":{"id":54952,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54943,"src":"14006:3:100","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$54911","typeString":"contract FetchChainInfoOutput"}},"id":54954,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"14010:3:100","memberName":"set","nodeType":"MemberAccess","referencedDeclaration":54384,"src":"14006:7:100","typeDescriptions":{"typeIdentifier":"t_function_external_nonpayable$_t_bytes4_$_t_address_$returns$__$","typeString":"function (bytes4,address) external"}},"id":54959,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"14006:58:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":54960,"nodeType":"ExpressionStatement","src":"14006:58:100"},{"assignments":[54962],"declarations":[{"constant":false,"id":54962,"mutability":"mutable","name":"systemConfigOwner","nameLocation":"14083:17:100","nodeType":"VariableDeclaration","scope":55072,"src":"14075:25:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":54961,"name":"address","nodeType":"ElementaryTypeName","src":"14075:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"id":54968,"initialValue":{"arguments":[],"expression":{"argumentTypes":[],"expression":{"arguments":[{"id":54964,"name":"systemConfigProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54947,"src":"14112:17:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_address","typeString":"address"}],"id":54963,"name":"IFetcher","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":53958,"src":"14103:8:100","typeDescriptions":{"typeIdentifier":"t_type$_t_contract$_IFetcher_$53958_$","typeString":"type(contract IFetcher)"}},"id":54965,"isConstant":false,"isLValue":false,"isPure":false,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"14103:27:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_contract$_IFetcher_$53958","typeString":"contract IFetcher"}},"id":54966,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"14131:5:100","memberName":"owner","nodeType":"MemberAccess","referencedDeclaration":53947,"src":"14103:33:100","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":54967,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"14103:35:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"VariableDeclarationStatement","src":"14075:63:100"},{"expression":{"arguments":[{"expression":{"expression":{"id":54972,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54943,"src":"14156:3:100","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$54911","typeString":"contract FetchChainInfoOutput"}},"id":54973,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"14160:17:100","memberName":"systemConfigOwner","nodeType":"MemberAccess","referencedDeclaration":54777,"src":"14156:21:100","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":54974,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"14178:8:100","memberName":"selector","nodeType":"MemberAccess","src":"14156:30:100","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},{"id":54975,"name":"systemConfigOwner","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54962,"src":"14188:17:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_bytes4","typeString":"bytes4"},{"typeIdentifier":"t_address","typeString":"address"}],"expression":{"id":54969,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54943,"src":"14148:3:100","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$54911","typeString":"contract FetchChainInfoOutput"}},"id":54971,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"14152:3:100","memberName":"set","nodeType":"MemberAccess","referencedDeclaration":54384,"src":"14148:7:100","typeDescriptions":{"typeIdentifier":"t_function_external_nonpayable$_t_bytes4_$_t_address_$returns$__$","typeString":"function (bytes4,address) external"}},"id":54976,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"14148:58:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":54977,"nodeType":"ExpressionStatement","src":"14148:58:100"},{"assignments":[54979],"declarations":[{"constant":false,"id":54979,"mutability":"mutable","name":"unsafeBlockSigner","nameLocation":"14225:17:100","nodeType":"VariableDeclaration","scope":55072,"src":"14217:25:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":54978,"name":"address","nodeType":"ElementaryTypeName","src":"14217:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"id":54985,"initialValue":{"arguments":[],"expression":{"argumentTypes":[],"expression":{"arguments":[{"id":54981,"name":"systemConfigProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54947,"src":"14254:17:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_address","typeString":"address"}],"id":54980,"name":"IFetcher","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":53958,"src":"14245:8:100","typeDescriptions":{"typeIdentifier":"t_type$_t_contract$_IFetcher_$53958_$","typeString":"type(contract IFetcher)"}},"id":54982,"isConstant":false,"isLValue":false,"isPure":false,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"14245:27:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_contract$_IFetcher_$53958","typeString":"contract IFetcher"}},"id":54983,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"14273:17:100","memberName":"unsafeBlockSigner","nodeType":"MemberAccess","referencedDeclaration":53952,"src":"14245:45:100","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":54984,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"14245:47:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"VariableDeclarationStatement","src":"14217:75:100"},{"expression":{"arguments":[{"expression":{"expression":{"id":54989,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54943,"src":"14310:3:100","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$54911","typeString":"contract FetchChainInfoOutput"}},"id":54990,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"14314:17:100","memberName":"unsafeBlockSigner","nodeType":"MemberAccess","referencedDeclaration":54867,"src":"14310:21:100","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":54991,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"14332:8:100","memberName":"selector","nodeType":"MemberAccess","src":"14310:30:100","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},{"id":54992,"name":"unsafeBlockSigner","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54979,"src":"14342:17:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_bytes4","typeString":"bytes4"},{"typeIdentifier":"t_address","typeString":"address"}],"expression":{"id":54986,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54943,"src":"14302:3:100","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$54911","typeString":"contract FetchChainInfoOutput"}},"id":54988,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"14306:3:100","memberName":"set","nodeType":"MemberAccess","referencedDeclaration":54384,"src":"14302:7:100","typeDescriptions":{"typeIdentifier":"t_function_external_nonpayable$_t_bytes4_$_t_address_$returns$__$","typeString":"function (bytes4,address) external"}},"id":54993,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"14302:58:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":54994,"nodeType":"ExpressionStatement","src":"14302:58:100"},{"assignments":[54996],"declarations":[{"constant":false,"id":54996,"mutability":"mutable","name":"batchSubmitter","nameLocation":"14379:14:100","nodeType":"VariableDeclaration","scope":55072,"src":"14371:22:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":54995,"name":"address","nodeType":"ElementaryTypeName","src":"14371:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"id":55000,"initialValue":{"arguments":[{"id":54998,"name":"systemConfigProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54947,"src":"14415:17:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_address","typeString":"address"}],"id":54997,"name":"_getBatchSubmitter","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55994,"src":"14396:18:100","typeDescriptions":{"typeIdentifier":"t_function_internal_view$_t_address_$returns$_t_address_$","typeString":"function (address) view returns (address)"}},"id":54999,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"14396:37:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"VariableDeclarationStatement","src":"14371:62:100"},{"expression":{"arguments":[{"expression":{"expression":{"id":55004,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54943,"src":"14451:3:100","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$54911","typeString":"contract FetchChainInfoOutput"}},"id":55005,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"14455:14:100","memberName":"batchSubmitter","nodeType":"MemberAccess","referencedDeclaration":54885,"src":"14451:18:100","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":55006,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"14470:8:100","memberName":"selector","nodeType":"MemberAccess","src":"14451:27:100","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},{"id":55007,"name":"batchSubmitter","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54996,"src":"14480:14:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_bytes4","typeString":"bytes4"},{"typeIdentifier":"t_address","typeString":"address"}],"expression":{"id":55001,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54943,"src":"14443:3:100","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$54911","typeString":"contract FetchChainInfoOutput"}},"id":55003,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"14447:3:100","memberName":"set","nodeType":"MemberAccess","referencedDeclaration":54384,"src":"14443:7:100","typeDescriptions":{"typeIdentifier":"t_function_external_nonpayable$_t_bytes4_$_t_address_$returns$__$","typeString":"function (bytes4,address) external"}},"id":55008,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"14443:52:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":55009,"nodeType":"ExpressionStatement","src":"14443:52:100"},{"assignments":[55011],"declarations":[{"constant":false,"id":55011,"mutability":"mutable","name":"opChainProxyAdminImpl","nameLocation":"14514:21:100","nodeType":"VariableDeclaration","scope":55072,"src":"14506:29:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":55010,"name":"address","nodeType":"ElementaryTypeName","src":"14506:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"id":55015,"initialValue":{"arguments":[{"id":55013,"name":"systemConfigProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54947,"src":"14553:17:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_address","typeString":"address"}],"id":55012,"name":"_getProxyAdmin","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":56017,"src":"14538:14:100","typeDescriptions":{"typeIdentifier":"t_function_internal_nonpayable$_t_address_$returns$_t_address_$","typeString":"function (address) returns (address)"}},"id":55014,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"14538:33:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"VariableDeclarationStatement","src":"14506:65:100"},{"expression":{"arguments":[{"expression":{"expression":{"id":55019,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54943,"src":"14589:3:100","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$54911","typeString":"contract FetchChainInfoOutput"}},"id":55020,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"14593:21:100","memberName":"opChainProxyAdminImpl","nodeType":"MemberAccess","referencedDeclaration":54609,"src":"14589:25:100","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":55021,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"14615:8:100","memberName":"selector","nodeType":"MemberAccess","src":"14589:34:100","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},{"id":55022,"name":"opChainProxyAdminImpl","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55011,"src":"14625:21:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_bytes4","typeString":"bytes4"},{"typeIdentifier":"t_address","typeString":"address"}],"expression":{"id":55016,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54943,"src":"14581:3:100","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$54911","typeString":"contract FetchChainInfoOutput"}},"id":55018,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"14585:3:100","memberName":"set","nodeType":"MemberAccess","referencedDeclaration":54384,"src":"14581:7:100","typeDescriptions":{"typeIdentifier":"t_function_external_nonpayable$_t_bytes4_$_t_address_$returns$__$","typeString":"function (bytes4,address) external"}},"id":55023,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"14581:66:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":55024,"nodeType":"ExpressionStatement","src":"14581:66:100"},{"assignments":[55026],"declarations":[{"constant":false,"id":55026,"mutability":"mutable","name":"opChainProxyAdminOwner","nameLocation":"14666:22:100","nodeType":"VariableDeclaration","scope":55072,"src":"14658:30:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":55025,"name":"address","nodeType":"ElementaryTypeName","src":"14658:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"id":55032,"initialValue":{"arguments":[],"expression":{"argumentTypes":[],"expression":{"arguments":[{"id":55028,"name":"opChainProxyAdminImpl","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55011,"src":"14700:21:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_address","typeString":"address"}],"id":55027,"name":"IFetcher","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":53958,"src":"14691:8:100","typeDescriptions":{"typeIdentifier":"t_type$_t_contract$_IFetcher_$53958_$","typeString":"type(contract IFetcher)"}},"id":55029,"isConstant":false,"isLValue":false,"isPure":false,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"14691:31:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_contract$_IFetcher_$53958","typeString":"contract IFetcher"}},"id":55030,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"14723:5:100","memberName":"owner","nodeType":"MemberAccess","referencedDeclaration":53947,"src":"14691:37:100","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":55031,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"14691:39:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"VariableDeclarationStatement","src":"14658:72:100"},{"expression":{"arguments":[{"expression":{"expression":{"id":55036,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54943,"src":"14748:3:100","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$54911","typeString":"contract FetchChainInfoOutput"}},"id":55037,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"14752:22:100","memberName":"opChainProxyAdminOwner","nodeType":"MemberAccess","referencedDeclaration":54795,"src":"14748:26:100","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":55038,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"14775:8:100","memberName":"selector","nodeType":"MemberAccess","src":"14748:35:100","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},{"id":55039,"name":"opChainProxyAdminOwner","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55026,"src":"14785:22:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_bytes4","typeString":"bytes4"},{"typeIdentifier":"t_address","typeString":"address"}],"expression":{"id":55033,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54943,"src":"14740:3:100","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$54911","typeString":"contract FetchChainInfoOutput"}},"id":55035,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"14744:3:100","memberName":"set","nodeType":"MemberAccess","referencedDeclaration":54384,"src":"14740:7:100","typeDescriptions":{"typeIdentifier":"t_function_external_nonpayable$_t_bytes4_$_t_address_$returns$__$","typeString":"function (bytes4,address) external"}},"id":55040,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"14740:68:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":55041,"nodeType":"ExpressionStatement","src":"14740:68:100"},{"assignments":[55043],"declarations":[{"constant":false,"id":55043,"mutability":"mutable","name":"l1Erc721BridgeProxy","nameLocation":"14827:19:100","nodeType":"VariableDeclaration","scope":55072,"src":"14819:27:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":55042,"name":"address","nodeType":"ElementaryTypeName","src":"14819:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"id":55047,"initialValue":{"arguments":[{"id":55045,"name":"systemConfigProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54947,"src":"14873:17:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_address","typeString":"address"}],"id":55044,"name":"_getL1ERC721BridgeProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55718,"src":"14849:23:100","typeDescriptions":{"typeIdentifier":"t_function_internal_view$_t_address_$returns$_t_address_$","typeString":"function (address) view returns (address)"}},"id":55046,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"14849:42:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"VariableDeclarationStatement","src":"14819:72:100"},{"expression":{"arguments":[{"expression":{"expression":{"id":55051,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54943,"src":"14909:3:100","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$54911","typeString":"contract FetchChainInfoOutput"}},"id":55052,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"14913:19:100","memberName":"l1Erc721BridgeProxy","nodeType":"MemberAccess","referencedDeclaration":54501,"src":"14909:23:100","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":55053,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"14933:8:100","memberName":"selector","nodeType":"MemberAccess","src":"14909:32:100","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},{"id":55054,"name":"l1Erc721BridgeProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55043,"src":"14943:19:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_bytes4","typeString":"bytes4"},{"typeIdentifier":"t_address","typeString":"address"}],"expression":{"id":55048,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54943,"src":"14901:3:100","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$54911","typeString":"contract FetchChainInfoOutput"}},"id":55050,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"14905:3:100","memberName":"set","nodeType":"MemberAccess","referencedDeclaration":54384,"src":"14901:7:100","typeDescriptions":{"typeIdentifier":"t_function_external_nonpayable$_t_bytes4_$_t_address_$returns$__$","typeString":"function (bytes4,address) external"}},"id":55055,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"14901:62:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":55056,"nodeType":"ExpressionStatement","src":"14901:62:100"},{"assignments":[55058],"declarations":[{"constant":false,"id":55058,"mutability":"mutable","name":"optimismMintableErc20FactoryProxy","nameLocation":"14982:33:100","nodeType":"VariableDeclaration","scope":55072,"src":"14974:41:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":55057,"name":"address","nodeType":"ElementaryTypeName","src":"14974:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"id":55062,"initialValue":{"arguments":[{"id":55060,"name":"systemConfigProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54947,"src":"15056:17:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_address","typeString":"address"}],"id":55059,"name":"_getOptimismMintableERC20FactoryProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55746,"src":"15018:37:100","typeDescriptions":{"typeIdentifier":"t_function_internal_view$_t_address_$returns$_t_address_$","typeString":"function (address) view returns (address)"}},"id":55061,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"15018:56:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"VariableDeclarationStatement","src":"14974:100:100"},{"expression":{"arguments":[{"expression":{"expression":{"id":55066,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54943,"src":"15092:3:100","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$54911","typeString":"contract FetchChainInfoOutput"}},"id":55067,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"15096:33:100","memberName":"optimismMintableErc20FactoryProxy","nodeType":"MemberAccess","referencedDeclaration":54555,"src":"15092:37:100","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":55068,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"15130:8:100","memberName":"selector","nodeType":"MemberAccess","src":"15092:46:100","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},{"id":55069,"name":"optimismMintableErc20FactoryProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55058,"src":"15140:33:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_bytes4","typeString":"bytes4"},{"typeIdentifier":"t_address","typeString":"address"}],"expression":{"id":55063,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54943,"src":"15084:3:100","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$54911","typeString":"contract FetchChainInfoOutput"}},"id":55065,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"15088:3:100","memberName":"set","nodeType":"MemberAccess","referencedDeclaration":54384,"src":"15084:7:100","typeDescriptions":{"typeIdentifier":"t_function_external_nonpayable$_t_bytes4_$_t_address_$returns$__$","typeString":"function (bytes4,address) external"}},"id":55070,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"15084:90:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":55071,"nodeType":"ExpressionStatement","src":"15084:90:100"}]},"implemented":true,"kind":"function","modifiers":[],"name":"_processSystemConfig","nameLocation":"13854:20:100","parameters":{"id":54944,"nodeType":"ParameterList","parameters":[{"constant":false,"id":54940,"mutability":"mutable","name":"_fi","nameLocation":"13895:3:100","nodeType":"VariableDeclaration","scope":55073,"src":"13875:23:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoInput_$54041","typeString":"contract FetchChainInfoInput"},"typeName":{"id":54939,"nodeType":"UserDefinedTypeName","pathNode":{"id":54938,"name":"FetchChainInfoInput","nameLocations":["13875:19:100"],"nodeType":"IdentifierPath","referencedDeclaration":54041,"src":"13875:19:100"},"referencedDeclaration":54041,"src":"13875:19:100","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoInput_$54041","typeString":"contract FetchChainInfoInput"}},"visibility":"internal"},{"constant":false,"id":54943,"mutability":"mutable","name":"_fo","nameLocation":"13921:3:100","nodeType":"VariableDeclaration","scope":55073,"src":"13900:24:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$54911","typeString":"contract FetchChainInfoOutput"},"typeName":{"id":54942,"nodeType":"UserDefinedTypeName","pathNode":{"id":54941,"name":"FetchChainInfoOutput","nameLocations":["13900:20:100"],"nodeType":"IdentifierPath","referencedDeclaration":54911,"src":"13900:20:100"},"referencedDeclaration":54911,"src":"13900:20:100","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$54911","typeString":"contract FetchChainInfoOutput"}},"visibility":"internal"}],"src":"13874:51:100"},"returnParameters":{"id":54945,"nodeType":"ParameterList","parameters":[],"src":"13935:0:100"},"scope":56018,"stateMutability":"nonpayable","virtual":false,"visibility":"internal"},{"id":55190,"nodeType":"FunctionDefinition","src":"15187:1190:100","nodes":[],"body":{"id":55189,"nodeType":"Block","src":"15283:1094:100","nodes":[],"statements":[{"assignments":[55083],"declarations":[{"constant":false,"id":55083,"mutability":"mutable","name":"l1StandardBridgeProxy","nameLocation":"15301:21:100","nodeType":"VariableDeclaration","scope":55189,"src":"15293:29:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":55082,"name":"address","nodeType":"ElementaryTypeName","src":"15293:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"id":55087,"initialValue":{"arguments":[],"expression":{"argumentTypes":[],"expression":{"id":55084,"name":"_fi","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55076,"src":"15325:3:100","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoInput_$54041","typeString":"contract FetchChainInfoInput"}},"id":55085,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"15329:21:100","memberName":"l1StandardBridgeProxy","nodeType":"MemberAccess","referencedDeclaration":54040,"src":"15325:25:100","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":55086,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"15325:27:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"VariableDeclarationStatement","src":"15293:59:100"},{"expression":{"arguments":[{"expression":{"expression":{"id":55091,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55079,"src":"15370:3:100","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$54911","typeString":"contract FetchChainInfoOutput"}},"id":55092,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"15374:21:100","memberName":"l1StandardBridgeProxy","nodeType":"MemberAccess","referencedDeclaration":54519,"src":"15370:25:100","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":55093,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"15396:8:100","memberName":"selector","nodeType":"MemberAccess","src":"15370:34:100","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},{"id":55094,"name":"l1StandardBridgeProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55083,"src":"15406:21:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_bytes4","typeString":"bytes4"},{"typeIdentifier":"t_address","typeString":"address"}],"expression":{"id":55088,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55079,"src":"15362:3:100","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$54911","typeString":"contract FetchChainInfoOutput"}},"id":55090,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"15366:3:100","memberName":"set","nodeType":"MemberAccess","referencedDeclaration":54384,"src":"15362:7:100","typeDescriptions":{"typeIdentifier":"t_function_external_nonpayable$_t_bytes4_$_t_address_$returns$__$","typeString":"function (bytes4,address) external"}},"id":55095,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"15362:66:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":55096,"nodeType":"ExpressionStatement","src":"15362:66:100"},{"assignments":[55098],"declarations":[{"constant":false,"id":55098,"mutability":"mutable","name":"l1CrossDomainMessengerProxy","nameLocation":"15447:27:100","nodeType":"VariableDeclaration","scope":55189,"src":"15439:35:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":55097,"name":"address","nodeType":"ElementaryTypeName","src":"15439:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"id":55104,"initialValue":{"arguments":[],"expression":{"argumentTypes":[],"expression":{"arguments":[{"id":55100,"name":"l1StandardBridgeProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55083,"src":"15486:21:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_address","typeString":"address"}],"id":55099,"name":"IFetcher","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":53958,"src":"15477:8:100","typeDescriptions":{"typeIdentifier":"t_type$_t_contract$_IFetcher_$53958_$","typeString":"type(contract IFetcher)"}},"id":55101,"isConstant":false,"isLValue":false,"isPure":false,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"15477:31:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_contract$_IFetcher_$53958","typeString":"contract IFetcher"}},"id":55102,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"15509:9:100","memberName":"messenger","nodeType":"MemberAccess","referencedDeclaration":53853,"src":"15477:41:100","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":55103,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"15477:43:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"VariableDeclarationStatement","src":"15439:81:100"},{"expression":{"arguments":[{"expression":{"expression":{"id":55108,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55079,"src":"15538:3:100","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$54911","typeString":"contract FetchChainInfoOutput"}},"id":55109,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"15542:27:100","memberName":"l1CrossDomainMessengerProxy","nodeType":"MemberAccess","referencedDeclaration":54483,"src":"15538:31:100","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":55110,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"15570:8:100","memberName":"selector","nodeType":"MemberAccess","src":"15538:40:100","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},{"id":55111,"name":"l1CrossDomainMessengerProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55098,"src":"15580:27:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_bytes4","typeString":"bytes4"},{"typeIdentifier":"t_address","typeString":"address"}],"expression":{"id":55105,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55079,"src":"15530:3:100","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$54911","typeString":"contract FetchChainInfoOutput"}},"id":55107,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"15534:3:100","memberName":"set","nodeType":"MemberAccess","referencedDeclaration":54384,"src":"15530:7:100","typeDescriptions":{"typeIdentifier":"t_function_external_nonpayable$_t_bytes4_$_t_address_$returns$__$","typeString":"function (bytes4,address) external"}},"id":55112,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"15530:78:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":55113,"nodeType":"ExpressionStatement","src":"15530:78:100"},{"assignments":[55115],"declarations":[{"constant":false,"id":55115,"mutability":"mutable","name":"addressManagerImpl","nameLocation":"15627:18:100","nodeType":"VariableDeclaration","scope":55189,"src":"15619:26:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":55114,"name":"address","nodeType":"ElementaryTypeName","src":"15619:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"id":55119,"initialValue":{"arguments":[{"id":55117,"name":"l1CrossDomainMessengerProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55098,"src":"15667:27:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_address","typeString":"address"}],"id":55116,"name":"_getAddressManager","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55690,"src":"15648:18:100","typeDescriptions":{"typeIdentifier":"t_function_internal_view$_t_address_$returns$_t_address_$","typeString":"function (address) view returns (address)"}},"id":55118,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"15648:47:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"VariableDeclarationStatement","src":"15619:76:100"},{"expression":{"arguments":[{"expression":{"expression":{"id":55123,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55079,"src":"15713:3:100","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$54911","typeString":"contract FetchChainInfoOutput"}},"id":55124,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"15717:18:100","memberName":"addressManagerImpl","nodeType":"MemberAccess","referencedDeclaration":54457,"src":"15713:22:100","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":55125,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"15736:8:100","memberName":"selector","nodeType":"MemberAccess","src":"15713:31:100","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},{"id":55126,"name":"addressManagerImpl","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55115,"src":"15746:18:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_bytes4","typeString":"bytes4"},{"typeIdentifier":"t_address","typeString":"address"}],"expression":{"id":55120,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55079,"src":"15705:3:100","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$54911","typeString":"contract FetchChainInfoOutput"}},"id":55122,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"15709:3:100","memberName":"set","nodeType":"MemberAccess","referencedDeclaration":54384,"src":"15705:7:100","typeDescriptions":{"typeIdentifier":"t_function_external_nonpayable$_t_bytes4_$_t_address_$returns$__$","typeString":"function (bytes4,address) external"}},"id":55127,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"15705:60:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":55128,"nodeType":"ExpressionStatement","src":"15705:60:100"},{"assignments":[55130],"declarations":[{"constant":false,"id":55130,"mutability":"mutable","name":"optimismPortalProxy","nameLocation":"15784:19:100","nodeType":"VariableDeclaration","scope":55189,"src":"15776:27:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":55129,"name":"address","nodeType":"ElementaryTypeName","src":"15776:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"id":55134,"initialValue":{"arguments":[{"id":55132,"name":"l1CrossDomainMessengerProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55098,"src":"15830:27:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_address","typeString":"address"}],"id":55131,"name":"_getOptimismPortalProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55652,"src":"15806:23:100","typeDescriptions":{"typeIdentifier":"t_function_internal_view$_t_address_$returns$_t_address_$","typeString":"function (address) view returns (address)"}},"id":55133,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"15806:52:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"VariableDeclarationStatement","src":"15776:82:100"},{"expression":{"arguments":[{"expression":{"expression":{"id":55138,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55079,"src":"15876:3:100","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$54911","typeString":"contract FetchChainInfoOutput"}},"id":55139,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"15880:19:100","memberName":"optimismPortalProxy","nodeType":"MemberAccess","referencedDeclaration":54573,"src":"15876:23:100","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":55140,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"15900:8:100","memberName":"selector","nodeType":"MemberAccess","src":"15876:32:100","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},{"id":55141,"name":"optimismPortalProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55130,"src":"15910:19:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_bytes4","typeString":"bytes4"},{"typeIdentifier":"t_address","typeString":"address"}],"expression":{"id":55135,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55079,"src":"15868:3:100","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$54911","typeString":"contract FetchChainInfoOutput"}},"id":55137,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"15872:3:100","memberName":"set","nodeType":"MemberAccess","referencedDeclaration":54384,"src":"15868:7:100","typeDescriptions":{"typeIdentifier":"t_function_external_nonpayable$_t_bytes4_$_t_address_$returns$__$","typeString":"function (bytes4,address) external"}},"id":55142,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"15868:62:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":55143,"nodeType":"ExpressionStatement","src":"15868:62:100"},{"assignments":[55145],"declarations":[{"constant":false,"id":55145,"mutability":"mutable","name":"opChainGuardian","nameLocation":"15949:15:100","nodeType":"VariableDeclaration","scope":55189,"src":"15941:23:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":55144,"name":"address","nodeType":"ElementaryTypeName","src":"15941:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"id":55149,"initialValue":{"arguments":[{"id":55147,"name":"optimismPortalProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55130,"src":"15980:19:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_address","typeString":"address"}],"id":55146,"name":"_getGuardian","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55594,"src":"15967:12:100","typeDescriptions":{"typeIdentifier":"t_function_internal_view$_t_address_$returns$_t_address_$","typeString":"function (address) view returns (address)"}},"id":55148,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"15967:33:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"VariableDeclarationStatement","src":"15941:59:100"},{"expression":{"arguments":[{"expression":{"expression":{"id":55153,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55079,"src":"16018:3:100","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$54911","typeString":"contract FetchChainInfoOutput"}},"id":55154,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"16022:15:100","memberName":"opChainGuardian","nodeType":"MemberAccess","referencedDeclaration":54813,"src":"16018:19:100","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":55155,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"16038:8:100","memberName":"selector","nodeType":"MemberAccess","src":"16018:28:100","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},{"id":55156,"name":"opChainGuardian","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55145,"src":"16048:15:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_bytes4","typeString":"bytes4"},{"typeIdentifier":"t_address","typeString":"address"}],"expression":{"id":55150,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55079,"src":"16010:3:100","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$54911","typeString":"contract FetchChainInfoOutput"}},"id":55152,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"16014:3:100","memberName":"set","nodeType":"MemberAccess","referencedDeclaration":54384,"src":"16010:7:100","typeDescriptions":{"typeIdentifier":"t_function_external_nonpayable$_t_bytes4_$_t_address_$returns$__$","typeString":"function (bytes4,address) external"}},"id":55157,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"16010:54:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":55158,"nodeType":"ExpressionStatement","src":"16010:54:100"},{"assignments":[55160],"declarations":[{"constant":false,"id":55160,"mutability":"mutable","name":"ethLockboxProxy","nameLocation":"16083:15:100","nodeType":"VariableDeclaration","scope":55189,"src":"16075:23:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":55159,"name":"address","nodeType":"ElementaryTypeName","src":"16075:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"id":55164,"initialValue":{"arguments":[{"id":55162,"name":"optimismPortalProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55130,"src":"16121:19:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_address","typeString":"address"}],"id":55161,"name":"_getEthLockboxProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55922,"src":"16101:19:100","typeDescriptions":{"typeIdentifier":"t_function_internal_view$_t_address_$returns$_t_address_$","typeString":"function (address) view returns (address)"}},"id":55163,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"16101:40:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"VariableDeclarationStatement","src":"16075:66:100"},{"expression":{"arguments":[{"expression":{"expression":{"id":55168,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55079,"src":"16159:3:100","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$54911","typeString":"contract FetchChainInfoOutput"}},"id":55169,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"16163:15:100","memberName":"ethLockboxProxy","nodeType":"MemberAccess","referencedDeclaration":54465,"src":"16159:19:100","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":55170,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"16179:8:100","memberName":"selector","nodeType":"MemberAccess","src":"16159:28:100","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},{"id":55171,"name":"ethLockboxProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55160,"src":"16189:15:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_bytes4","typeString":"bytes4"},{"typeIdentifier":"t_address","typeString":"address"}],"expression":{"id":55165,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55079,"src":"16151:3:100","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$54911","typeString":"contract FetchChainInfoOutput"}},"id":55167,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"16155:3:100","memberName":"set","nodeType":"MemberAccess","referencedDeclaration":54384,"src":"16151:7:100","typeDescriptions":{"typeIdentifier":"t_function_external_nonpayable$_t_bytes4_$_t_address_$returns$__$","typeString":"function (bytes4,address) external"}},"id":55172,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"16151:54:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":55173,"nodeType":"ExpressionStatement","src":"16151:54:100"},{"assignments":[55175],"declarations":[{"constant":false,"id":55175,"mutability":"mutable","name":"superchainConfigProxy","nameLocation":"16224:21:100","nodeType":"VariableDeclaration","scope":55189,"src":"16216:29:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":55174,"name":"address","nodeType":"ElementaryTypeName","src":"16216:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"id":55179,"initialValue":{"arguments":[{"id":55177,"name":"optimismPortalProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55130,"src":"16274:19:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_address","typeString":"address"}],"id":55176,"name":"_getSuperchainConfigProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55802,"src":"16248:25:100","typeDescriptions":{"typeIdentifier":"t_function_internal_view$_t_address_$returns$_t_address_$","typeString":"function (address) view returns (address)"}},"id":55178,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"16248:46:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"VariableDeclarationStatement","src":"16216:78:100"},{"expression":{"arguments":[{"expression":{"expression":{"id":55183,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55079,"src":"16312:3:100","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$54911","typeString":"contract FetchChainInfoOutput"}},"id":55184,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"16316:21:100","memberName":"superchainConfigProxy","nodeType":"MemberAccess","referencedDeclaration":54627,"src":"16312:25:100","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":55185,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"16338:8:100","memberName":"selector","nodeType":"MemberAccess","src":"16312:34:100","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},{"id":55186,"name":"superchainConfigProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55175,"src":"16348:21:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_bytes4","typeString":"bytes4"},{"typeIdentifier":"t_address","typeString":"address"}],"expression":{"id":55180,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55079,"src":"16304:3:100","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$54911","typeString":"contract FetchChainInfoOutput"}},"id":55182,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"16308:3:100","memberName":"set","nodeType":"MemberAccess","referencedDeclaration":54384,"src":"16304:7:100","typeDescriptions":{"typeIdentifier":"t_function_external_nonpayable$_t_bytes4_$_t_address_$returns$__$","typeString":"function (bytes4,address) external"}},"id":55187,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"16304:66:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":55188,"nodeType":"ExpressionStatement","src":"16304:66:100"}]},"implemented":true,"kind":"function","modifiers":[],"name":"_processMessengerAndPortal","nameLocation":"15196:26:100","parameters":{"id":55080,"nodeType":"ParameterList","parameters":[{"constant":false,"id":55076,"mutability":"mutable","name":"_fi","nameLocation":"15243:3:100","nodeType":"VariableDeclaration","scope":55190,"src":"15223:23:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoInput_$54041","typeString":"contract FetchChainInfoInput"},"typeName":{"id":55075,"nodeType":"UserDefinedTypeName","pathNode":{"id":55074,"name":"FetchChainInfoInput","nameLocations":["15223:19:100"],"nodeType":"IdentifierPath","referencedDeclaration":54041,"src":"15223:19:100"},"referencedDeclaration":54041,"src":"15223:19:100","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoInput_$54041","typeString":"contract FetchChainInfoInput"}},"visibility":"internal"},{"constant":false,"id":55079,"mutability":"mutable","name":"_fo","nameLocation":"15269:3:100","nodeType":"VariableDeclaration","scope":55190,"src":"15248:24:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$54911","typeString":"contract FetchChainInfoOutput"},"typeName":{"id":55078,"nodeType":"UserDefinedTypeName","pathNode":{"id":55077,"name":"FetchChainInfoOutput","nameLocations":["15248:20:100"],"nodeType":"IdentifierPath","referencedDeclaration":54911,"src":"15248:20:100"},"referencedDeclaration":54911,"src":"15248:20:100","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$54911","typeString":"contract FetchChainInfoOutput"}},"visibility":"internal"}],"src":"15222:51:100"},"returnParameters":{"id":55081,"nodeType":"ParameterList","parameters":[],"src":"15283:0:100"},"scope":56018,"stateMutability":"nonpayable","virtual":false,"visibility":"internal"},{"id":55565,"nodeType":"FunctionDefinition","src":"16383:4033:100","nodes":[],"body":{"id":55564,"nodeType":"Block","src":"16447:3969:100","nodes":[],"statements":[{"assignments":[55197],"declarations":[{"constant":false,"id":55197,"mutability":"mutable","name":"systemConfigProxy","nameLocation":"16465:17:100","nodeType":"VariableDeclaration","scope":55564,"src":"16457:25:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":55196,"name":"address","nodeType":"ElementaryTypeName","src":"16457:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"id":55201,"initialValue":{"arguments":[],"expression":{"argumentTypes":[],"expression":{"id":55198,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55193,"src":"16485:3:100","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$54911","typeString":"contract FetchChainInfoOutput"}},"id":55199,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"16489:17:100","memberName":"systemConfigProxy","nodeType":"MemberAccess","referencedDeclaration":54591,"src":"16485:21:100","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":55200,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"16485:23:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"VariableDeclarationStatement","src":"16457:51:100"},{"assignments":[55203],"declarations":[{"constant":false,"id":55203,"mutability":"mutable","name":"optimismPortalProxy","nameLocation":"16526:19:100","nodeType":"VariableDeclaration","scope":55564,"src":"16518:27:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":55202,"name":"address","nodeType":"ElementaryTypeName","src":"16518:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"id":55207,"initialValue":{"arguments":[],"expression":{"argumentTypes":[],"expression":{"id":55204,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55193,"src":"16548:3:100","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$54911","typeString":"contract FetchChainInfoOutput"}},"id":55205,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"16552:19:100","memberName":"optimismPortalProxy","nodeType":"MemberAccess","referencedDeclaration":54573,"src":"16548:23:100","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":55206,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"16548:25:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"VariableDeclarationStatement","src":"16518:55:100"},{"clauses":[{"block":{"id":55226,"nodeType":"Block","src":"16667:75:100","statements":[{"expression":{"arguments":[{"expression":{"expression":{"id":55220,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55193,"src":"16689:3:100","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$54911","typeString":"contract FetchChainInfoOutput"}},"id":55221,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"16693:17:100","memberName":"respectedGameType","nodeType":"MemberAccess","referencedDeclaration":54910,"src":"16689:21:100","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_userDefinedValueType$_GameType_$70720_$","typeString":"function () view external returns (GameType)"}},"id":55222,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"16711:8:100","memberName":"selector","nodeType":"MemberAccess","src":"16689:30:100","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},{"id":55223,"name":"gameType_","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55215,"src":"16721:9:100","typeDescriptions":{"typeIdentifier":"t_userDefinedValueType$_GameType_$70720","typeString":"GameType"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_bytes4","typeString":"bytes4"},{"typeIdentifier":"t_userDefinedValueType$_GameType_$70720","typeString":"GameType"}],"expression":{"id":55217,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55193,"src":"16681:3:100","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$54911","typeString":"contract FetchChainInfoOutput"}},"id":55219,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"16685:3:100","memberName":"set","nodeType":"MemberAccess","referencedDeclaration":54439,"src":"16681:7:100","typeDescriptions":{"typeIdentifier":"t_function_external_nonpayable$_t_bytes4_$_t_userDefinedValueType$_GameType_$70720_$returns$__$","typeString":"function (bytes4,GameType) external"}},"id":55224,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"16681:50:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":55225,"nodeType":"ExpressionStatement","src":"16681:50:100"}]},"errorName":"","id":55227,"nodeType":"TryCatchClause","parameters":{"id":55216,"nodeType":"ParameterList","parameters":[{"constant":false,"id":55215,"mutability":"mutable","name":"gameType_","nameLocation":"16656:9:100","nodeType":"VariableDeclaration","scope":55227,"src":"16647:18:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_userDefinedValueType$_GameType_$70720","typeString":"GameType"},"typeName":{"id":55214,"nodeType":"UserDefinedTypeName","pathNode":{"id":55213,"name":"GameType","nameLocations":["16647:8:100"],"nodeType":"IdentifierPath","referencedDeclaration":70720,"src":"16647:8:100"},"referencedDeclaration":70720,"src":"16647:8:100","typeDescriptions":{"typeIdentifier":"t_userDefinedValueType$_GameType_$70720","typeString":"GameType"}},"visibility":"internal"}],"src":"16646:20:100"},"src":"16638:104:100"},{"block":{"id":55299,"nodeType":"Block","src":"16749:744:100","statements":[{"expression":{"arguments":[{"expression":{"expression":{"id":55231,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55193,"src":"16844:3:100","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$54911","typeString":"contract FetchChainInfoOutput"}},"id":55232,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"16848:17:100","memberName":"respectedGameType","nodeType":"MemberAccess","referencedDeclaration":54910,"src":"16844:21:100","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_userDefinedValueType$_GameType_$70720_$","typeString":"function () view external returns (GameType)"}},"id":55233,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"16866:8:100","memberName":"selector","nodeType":"MemberAccess","src":"16844:30:100","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},{"arguments":[{"expression":{"arguments":[{"id":55238,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"nodeType":"ElementaryTypeNameExpression","src":"16895:6:100","typeDescriptions":{"typeIdentifier":"t_type$_t_uint32_$","typeString":"type(uint32)"},"typeName":{"id":55237,"name":"uint32","nodeType":"ElementaryTypeName","src":"16895:6:100","typeDescriptions":{}}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_type$_t_uint32_$","typeString":"type(uint32)"}],"id":55236,"name":"type","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":-27,"src":"16890:4:100","typeDescriptions":{"typeIdentifier":"t_function_metatype_pure$__$returns$__$","typeString":"function () pure"}},"id":55239,"isConstant":false,"isLValue":false,"isPure":true,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"16890:12:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_magic_meta_type_t_uint32","typeString":"type(uint32)"}},"id":55240,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"memberLocation":"16903:3:100","memberName":"max","nodeType":"MemberAccess","src":"16890:16:100","typeDescriptions":{"typeIdentifier":"t_uint32","typeString":"uint32"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_uint32","typeString":"uint32"}],"expression":{"id":55234,"name":"GameType","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":70720,"src":"16876:8:100","typeDescriptions":{"typeIdentifier":"t_type$_t_userDefinedValueType$_GameType_$70720_$","typeString":"type(GameType)"}},"id":55235,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"memberLocation":"16885:4:100","memberName":"wrap","nodeType":"MemberAccess","src":"16876:13:100","typeDescriptions":{"typeIdentifier":"t_function_wrap_pure$_t_uint32_$returns$_t_userDefinedValueType$_GameType_$70720_$","typeString":"function (uint32) pure returns (GameType)"}},"id":55241,"isConstant":false,"isLValue":false,"isPure":true,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"16876:31:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_userDefinedValueType$_GameType_$70720","typeString":"GameType"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_bytes4","typeString":"bytes4"},{"typeIdentifier":"t_userDefinedValueType$_GameType_$70720","typeString":"GameType"}],"expression":{"id":55228,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55193,"src":"16836:3:100","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$54911","typeString":"contract FetchChainInfoOutput"}},"id":55230,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"16840:3:100","memberName":"set","nodeType":"MemberAccess","referencedDeclaration":54439,"src":"16836:7:100","typeDescriptions":{"typeIdentifier":"t_function_external_nonpayable$_t_bytes4_$_t_userDefinedValueType$_GameType_$70720_$returns$__$","typeString":"function (bytes4,GameType) external"}},"id":55242,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"16836:72:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":55243,"nodeType":"ExpressionStatement","src":"16836:72:100"},{"assignments":[55245],"declarations":[{"constant":false,"id":55245,"mutability":"mutable","name":"l2OutputOracleProxy","nameLocation":"16930:19:100","nodeType":"VariableDeclaration","scope":55299,"src":"16922:27:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":55244,"name":"address","nodeType":"ElementaryTypeName","src":"16922:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"id":55246,"nodeType":"VariableDeclarationStatement","src":"16922:27:100"},{"clauses":[{"block":{"id":55259,"nodeType":"Block","src":"17036:64:100","statements":[{"expression":{"id":55257,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftHandSide":{"id":55255,"name":"l2OutputOracleProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55245,"src":"17054:19:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"Assignment","operator":"=","rightHandSide":{"id":55256,"name":"l2Oracle_","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55253,"src":"17076:9:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"src":"17054:31:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"id":55258,"nodeType":"ExpressionStatement","src":"17054:31:100"}]},"errorName":"","id":55260,"nodeType":"TryCatchClause","parameters":{"id":55254,"nodeType":"ParameterList","parameters":[{"constant":false,"id":55253,"mutability":"mutable","name":"l2Oracle_","nameLocation":"17025:9:100","nodeType":"VariableDeclaration","scope":55260,"src":"17017:17:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":55252,"name":"address","nodeType":"ElementaryTypeName","src":"17017:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"17016:19:100"},"src":"17008:92:100"},{"block":{"id":55269,"nodeType":"Block","src":"17107:96:100","statements":[{"expression":{"id":55267,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftHandSide":{"id":55261,"name":"l2OutputOracleProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55245,"src":"17125:19:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"Assignment","operator":"=","rightHandSide":{"arguments":[],"expression":{"argumentTypes":[],"expression":{"arguments":[{"id":55263,"name":"optimismPortalProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55203,"src":"17156:19:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_address","typeString":"address"}],"id":55262,"name":"IFetcher","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":53958,"src":"17147:8:100","typeDescriptions":{"typeIdentifier":"t_type$_t_contract$_IFetcher_$53958_$","typeString":"type(contract IFetcher)"}},"id":55264,"isConstant":false,"isLValue":false,"isPure":false,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"17147:29:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_contract$_IFetcher_$53958","typeString":"contract IFetcher"}},"id":55265,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"17177:9:100","memberName":"L2_ORACLE","nodeType":"MemberAccess","referencedDeclaration":53902,"src":"17147:39:100","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":55266,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"17147:41:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"src":"17125:63:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"id":55268,"nodeType":"ExpressionStatement","src":"17125:63:100"}]},"errorName":"","id":55270,"nodeType":"TryCatchClause","src":"17101:102:100"}],"externalCall":{"arguments":[],"expression":{"argumentTypes":[],"expression":{"arguments":[{"id":55248,"name":"optimismPortalProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55203,"src":"16976:19:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_address","typeString":"address"}],"id":55247,"name":"IFetcher","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":53958,"src":"16967:8:100","typeDescriptions":{"typeIdentifier":"t_type$_t_contract$_IFetcher_$53958_$","typeString":"type(contract IFetcher)"}},"id":55249,"isConstant":false,"isLValue":false,"isPure":false,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"16967:29:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_contract$_IFetcher_$53958","typeString":"contract IFetcher"}},"id":55250,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"16997:8:100","memberName":"l2Oracle","nodeType":"MemberAccess","referencedDeclaration":53907,"src":"16967:38:100","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":55251,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"16967:40:100","tryCall":true,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"id":55271,"nodeType":"TryStatement","src":"16963:240:100"},{"expression":{"arguments":[{"expression":{"expression":{"id":55275,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55193,"src":"17224:3:100","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$54911","typeString":"contract FetchChainInfoOutput"}},"id":55276,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"17228:19:100","memberName":"l2OutputOracleProxy","nodeType":"MemberAccess","referencedDeclaration":54537,"src":"17224:23:100","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":55277,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"17248:8:100","memberName":"selector","nodeType":"MemberAccess","src":"17224:32:100","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},{"id":55278,"name":"l2OutputOracleProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55245,"src":"17258:19:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_bytes4","typeString":"bytes4"},{"typeIdentifier":"t_address","typeString":"address"}],"expression":{"id":55272,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55193,"src":"17216:3:100","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$54911","typeString":"contract FetchChainInfoOutput"}},"id":55274,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"17220:3:100","memberName":"set","nodeType":"MemberAccess","referencedDeclaration":54384,"src":"17216:7:100","typeDescriptions":{"typeIdentifier":"t_function_external_nonpayable$_t_bytes4_$_t_address_$returns$__$","typeString":"function (bytes4,address) external"}},"id":55279,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"17216:62:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":55280,"nodeType":"ExpressionStatement","src":"17216:62:100"},{"assignments":[55282],"declarations":[{"constant":false,"id":55282,"mutability":"mutable","name":"proposer","nameLocation":"17301:8:100","nodeType":"VariableDeclaration","scope":55299,"src":"17293:16:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":55281,"name":"address","nodeType":"ElementaryTypeName","src":"17293:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"id":55288,"initialValue":{"arguments":[],"expression":{"argumentTypes":[],"expression":{"arguments":[{"id":55284,"name":"l2OutputOracleProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55245,"src":"17321:19:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_address","typeString":"address"}],"id":55283,"name":"IFetcher","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":53958,"src":"17312:8:100","typeDescriptions":{"typeIdentifier":"t_type$_t_contract$_IFetcher_$53958_$","typeString":"type(contract IFetcher)"}},"id":55285,"isConstant":false,"isLValue":false,"isPure":false,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"17312:29:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_contract$_IFetcher_$53958","typeString":"contract IFetcher"}},"id":55286,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"17342:8:100","memberName":"PROPOSER","nodeType":"MemberAccess","referencedDeclaration":53932,"src":"17312:38:100","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":55287,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"17312:40:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"VariableDeclarationStatement","src":"17293:59:100"},{"expression":{"arguments":[{"expression":{"expression":{"id":55292,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55193,"src":"17374:3:100","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$54911","typeString":"contract FetchChainInfoOutput"}},"id":55293,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"17378:8:100","memberName":"proposer","nodeType":"MemberAccess","referencedDeclaration":54849,"src":"17374:12:100","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":55294,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"17387:8:100","memberName":"selector","nodeType":"MemberAccess","src":"17374:21:100","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},{"id":55295,"name":"proposer","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55282,"src":"17397:8:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_bytes4","typeString":"bytes4"},{"typeIdentifier":"t_address","typeString":"address"}],"expression":{"id":55289,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55193,"src":"17366:3:100","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$54911","typeString":"contract FetchChainInfoOutput"}},"id":55291,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"17370:3:100","memberName":"set","nodeType":"MemberAccess","referencedDeclaration":54384,"src":"17366:7:100","typeDescriptions":{"typeIdentifier":"t_function_external_nonpayable$_t_bytes4_$_t_address_$returns$__$","typeString":"function (bytes4,address) external"}},"id":55296,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"17366:40:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":55297,"nodeType":"ExpressionStatement","src":"17366:40:100"},{"functionReturnParameters":55195,"id":55298,"nodeType":"Return","src":"17476:7:100"}]},"errorName":"","id":55300,"nodeType":"TryCatchClause","src":"16743:750:100"}],"externalCall":{"arguments":[],"expression":{"argumentTypes":[],"expression":{"arguments":[{"id":55209,"name":"optimismPortalProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55203,"src":"16597:19:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_address","typeString":"address"}],"id":55208,"name":"IFetcher","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":53958,"src":"16588:8:100","typeDescriptions":{"typeIdentifier":"t_type$_t_contract$_IFetcher_$53958_$","typeString":"type(contract IFetcher)"}},"id":55210,"isConstant":false,"isLValue":false,"isPure":false,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"16588:29:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_contract$_IFetcher_$53958","typeString":"contract IFetcher"}},"id":55211,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"16618:17:100","memberName":"respectedGameType","nodeType":"MemberAccess","referencedDeclaration":53892,"src":"16588:47:100","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_userDefinedValueType$_GameType_$70720_$","typeString":"function () view external returns (GameType)"}},"id":55212,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"16588:49:100","tryCall":true,"typeDescriptions":{"typeIdentifier":"t_userDefinedValueType$_GameType_$70720","typeString":"GameType"}},"id":55301,"nodeType":"TryStatement","src":"16584:909:100"},{"assignments":[55303],"declarations":[{"constant":false,"id":55303,"mutability":"mutable","name":"disputeGameFactoryProxy","nameLocation":"17511:23:100","nodeType":"VariableDeclaration","scope":55564,"src":"17503:31:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":55302,"name":"address","nodeType":"ElementaryTypeName","src":"17503:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"id":55307,"initialValue":{"arguments":[{"id":55305,"name":"systemConfigProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55197,"src":"17565:17:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_address","typeString":"address"}],"id":55304,"name":"_getDisputeGameFactoryProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55774,"src":"17537:27:100","typeDescriptions":{"typeIdentifier":"t_function_internal_view$_t_address_$returns$_t_address_$","typeString":"function (address) view returns (address)"}},"id":55306,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"17537:46:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"VariableDeclarationStatement","src":"17503:80:100"},{"condition":{"commonType":{"typeIdentifier":"t_address","typeString":"address"},"id":55313,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftExpression":{"id":55308,"name":"disputeGameFactoryProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55303,"src":"17597:23:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"BinaryOperation","operator":"!=","rightExpression":{"arguments":[{"hexValue":"30","id":55311,"isConstant":false,"isLValue":false,"isPure":true,"kind":"number","lValueRequested":false,"nodeType":"Literal","src":"17632:1:100","typeDescriptions":{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"},"value":"0"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"}],"id":55310,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"nodeType":"ElementaryTypeNameExpression","src":"17624:7:100","typeDescriptions":{"typeIdentifier":"t_type$_t_address_$","typeString":"type(address)"},"typeName":{"id":55309,"name":"address","nodeType":"ElementaryTypeName","src":"17624:7:100","typeDescriptions":{}}},"id":55312,"isConstant":false,"isLValue":false,"isPure":true,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"17624:10:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"src":"17597:37:100","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},"falseBody":{"id":55562,"nodeType":"Block","src":"20027:383:100","statements":[{"assignments":[55529],"declarations":[{"constant":false,"id":55529,"mutability":"mutable","name":"l2OutputOracleProxy","nameLocation":"20133:19:100","nodeType":"VariableDeclaration","scope":55562,"src":"20125:27:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":55528,"name":"address","nodeType":"ElementaryTypeName","src":"20125:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"id":55535,"initialValue":{"arguments":[],"expression":{"argumentTypes":[],"expression":{"arguments":[{"id":55531,"name":"optimismPortalProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55203,"src":"20164:19:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_address","typeString":"address"}],"id":55530,"name":"IFetcher","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":53958,"src":"20155:8:100","typeDescriptions":{"typeIdentifier":"t_type$_t_contract$_IFetcher_$53958_$","typeString":"type(contract IFetcher)"}},"id":55532,"isConstant":false,"isLValue":false,"isPure":false,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"20155:29:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_contract$_IFetcher_$53958","typeString":"contract IFetcher"}},"id":55533,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"20185:9:100","memberName":"L2_ORACLE","nodeType":"MemberAccess","referencedDeclaration":53902,"src":"20155:39:100","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":55534,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"20155:41:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"VariableDeclarationStatement","src":"20125:71:100"},{"expression":{"arguments":[{"expression":{"expression":{"id":55539,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55193,"src":"20218:3:100","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$54911","typeString":"contract FetchChainInfoOutput"}},"id":55540,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"20222:19:100","memberName":"l2OutputOracleProxy","nodeType":"MemberAccess","referencedDeclaration":54537,"src":"20218:23:100","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":55541,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"20242:8:100","memberName":"selector","nodeType":"MemberAccess","src":"20218:32:100","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},{"id":55542,"name":"l2OutputOracleProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55529,"src":"20252:19:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_bytes4","typeString":"bytes4"},{"typeIdentifier":"t_address","typeString":"address"}],"expression":{"id":55536,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55193,"src":"20210:3:100","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$54911","typeString":"contract FetchChainInfoOutput"}},"id":55538,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"20214:3:100","memberName":"set","nodeType":"MemberAccess","referencedDeclaration":54384,"src":"20210:7:100","typeDescriptions":{"typeIdentifier":"t_function_external_nonpayable$_t_bytes4_$_t_address_$returns$__$","typeString":"function (bytes4,address) external"}},"id":55543,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"20210:62:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":55544,"nodeType":"ExpressionStatement","src":"20210:62:100"},{"assignments":[55546],"declarations":[{"constant":false,"id":55546,"mutability":"mutable","name":"proposer","nameLocation":"20294:8:100","nodeType":"VariableDeclaration","scope":55562,"src":"20286:16:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":55545,"name":"address","nodeType":"ElementaryTypeName","src":"20286:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"id":55552,"initialValue":{"arguments":[],"expression":{"argumentTypes":[],"expression":{"arguments":[{"id":55548,"name":"l2OutputOracleProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55529,"src":"20314:19:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_address","typeString":"address"}],"id":55547,"name":"IFetcher","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":53958,"src":"20305:8:100","typeDescriptions":{"typeIdentifier":"t_type$_t_contract$_IFetcher_$53958_$","typeString":"type(contract IFetcher)"}},"id":55549,"isConstant":false,"isLValue":false,"isPure":false,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"20305:29:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_contract$_IFetcher_$53958","typeString":"contract IFetcher"}},"id":55550,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"20335:8:100","memberName":"PROPOSER","nodeType":"MemberAccess","referencedDeclaration":53932,"src":"20305:38:100","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":55551,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"20305:40:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"VariableDeclarationStatement","src":"20286:59:100"},{"expression":{"arguments":[{"expression":{"expression":{"id":55556,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55193,"src":"20367:3:100","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$54911","typeString":"contract FetchChainInfoOutput"}},"id":55557,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"20371:8:100","memberName":"proposer","nodeType":"MemberAccess","referencedDeclaration":54849,"src":"20367:12:100","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":55558,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"20380:8:100","memberName":"selector","nodeType":"MemberAccess","src":"20367:21:100","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},{"id":55559,"name":"proposer","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55546,"src":"20390:8:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_bytes4","typeString":"bytes4"},{"typeIdentifier":"t_address","typeString":"address"}],"expression":{"id":55553,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55193,"src":"20359:3:100","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$54911","typeString":"contract FetchChainInfoOutput"}},"id":55555,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"20363:3:100","memberName":"set","nodeType":"MemberAccess","referencedDeclaration":54384,"src":"20359:7:100","typeDescriptions":{"typeIdentifier":"t_function_external_nonpayable$_t_bytes4_$_t_address_$returns$__$","typeString":"function (bytes4,address) external"}},"id":55560,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"20359:40:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":55561,"nodeType":"ExpressionStatement","src":"20359:40:100"}]},"id":55563,"nodeType":"IfStatement","src":"17593:2817:100","trueBody":{"id":55527,"nodeType":"Block","src":"17636:2385:100","statements":[{"expression":{"arguments":[{"expression":{"expression":{"id":55317,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55193,"src":"17658:3:100","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$54911","typeString":"contract FetchChainInfoOutput"}},"id":55318,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"17662:23:100","memberName":"disputeGameFactoryProxy","nodeType":"MemberAccess","referencedDeclaration":54669,"src":"17658:27:100","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":55319,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"17686:8:100","memberName":"selector","nodeType":"MemberAccess","src":"17658:36:100","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},{"id":55320,"name":"disputeGameFactoryProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55303,"src":"17696:23:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_bytes4","typeString":"bytes4"},{"typeIdentifier":"t_address","typeString":"address"}],"expression":{"id":55314,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55193,"src":"17650:3:100","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$54911","typeString":"contract FetchChainInfoOutput"}},"id":55316,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"17654:3:100","memberName":"set","nodeType":"MemberAccess","referencedDeclaration":54384,"src":"17650:7:100","typeDescriptions":{"typeIdentifier":"t_function_external_nonpayable$_t_bytes4_$_t_address_$returns$__$","typeString":"function (bytes4,address) external"}},"id":55321,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"17650:70:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":55322,"nodeType":"ExpressionStatement","src":"17650:70:100"},{"assignments":[55324],"declarations":[{"constant":false,"id":55324,"mutability":"mutable","name":"permissionedDisputeGameImpl","nameLocation":"17743:27:100","nodeType":"VariableDeclaration","scope":55527,"src":"17735:35:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":55323,"name":"address","nodeType":"ElementaryTypeName","src":"17735:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"id":55328,"initialValue":{"arguments":[{"id":55326,"name":"disputeGameFactoryProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55303,"src":"17801:23:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_address","typeString":"address"}],"id":55325,"name":"_getPermissionedDisputeGame","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55894,"src":"17773:27:100","typeDescriptions":{"typeIdentifier":"t_function_internal_view$_t_address_$returns$_t_address_$","typeString":"function (address) view returns (address)"}},"id":55327,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"17773:52:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"VariableDeclarationStatement","src":"17735:90:100"},{"condition":{"commonType":{"typeIdentifier":"t_address","typeString":"address"},"id":55334,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftExpression":{"id":55329,"name":"permissionedDisputeGameImpl","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55324,"src":"17843:27:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"BinaryOperation","operator":"!=","rightExpression":{"arguments":[{"hexValue":"30","id":55332,"isConstant":false,"isLValue":false,"isPure":true,"kind":"number","lValueRequested":false,"nodeType":"Literal","src":"17882:1:100","typeDescriptions":{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"},"value":"0"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"}],"id":55331,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"nodeType":"ElementaryTypeNameExpression","src":"17874:7:100","typeDescriptions":{"typeIdentifier":"t_type$_t_address_$","typeString":"type(address)"},"typeName":{"id":55330,"name":"address","nodeType":"ElementaryTypeName","src":"17874:7:100","typeDescriptions":{}}},"id":55333,"isConstant":false,"isLValue":false,"isPure":true,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"17874:10:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"src":"17843:41:100","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},"id":55454,"nodeType":"IfStatement","src":"17839:1278:100","trueBody":{"id":55453,"nodeType":"Block","src":"17886:1231:100","statements":[{"expression":{"arguments":[{"expression":{"expression":{"id":55338,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55193,"src":"17967:3:100","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$54911","typeString":"contract FetchChainInfoOutput"}},"id":55339,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"17971:12:100","memberName":"permissioned","nodeType":"MemberAccess","referencedDeclaration":54893,"src":"17967:16:100","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_bool_$","typeString":"function () view external returns (bool)"}},"id":55340,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"17984:8:100","memberName":"selector","nodeType":"MemberAccess","src":"17967:25:100","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},{"hexValue":"74727565","id":55341,"isConstant":false,"isLValue":false,"isPure":true,"kind":"bool","lValueRequested":false,"nodeType":"Literal","src":"17994:4:100","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"},"value":"true"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_bytes4","typeString":"bytes4"},{"typeIdentifier":"t_bool","typeString":"bool"}],"expression":{"id":55335,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55193,"src":"17959:3:100","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$54911","typeString":"contract FetchChainInfoOutput"}},"id":55337,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"17963:3:100","memberName":"set","nodeType":"MemberAccess","referencedDeclaration":54416,"src":"17959:7:100","typeDescriptions":{"typeIdentifier":"t_function_external_nonpayable$_t_bytes4_$_t_bool_$returns$__$","typeString":"function (bytes4,bool) external"}},"id":55342,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"17959:40:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":55343,"nodeType":"ExpressionStatement","src":"17959:40:100"},{"expression":{"arguments":[{"expression":{"expression":{"id":55347,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55193,"src":"18025:3:100","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$54911","typeString":"contract FetchChainInfoOutput"}},"id":55348,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"18029:27:100","memberName":"permissionedDisputeGameImpl","nodeType":"MemberAccess","referencedDeclaration":54741,"src":"18025:31:100","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":55349,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"18057:8:100","memberName":"selector","nodeType":"MemberAccess","src":"18025:40:100","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},{"id":55350,"name":"permissionedDisputeGameImpl","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55324,"src":"18067:27:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_bytes4","typeString":"bytes4"},{"typeIdentifier":"t_address","typeString":"address"}],"expression":{"id":55344,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55193,"src":"18017:3:100","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$54911","typeString":"contract FetchChainInfoOutput"}},"id":55346,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"18021:3:100","memberName":"set","nodeType":"MemberAccess","referencedDeclaration":54384,"src":"18017:7:100","typeDescriptions":{"typeIdentifier":"t_function_external_nonpayable$_t_bytes4_$_t_address_$returns$__$","typeString":"function (bytes4,address) external"}},"id":55351,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"18017:78:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":55352,"nodeType":"ExpressionStatement","src":"18017:78:100"},{"assignments":[55354],"declarations":[{"constant":false,"id":55354,"mutability":"mutable","name":"challenger","nameLocation":"18122:10:100","nodeType":"VariableDeclaration","scope":55453,"src":"18114:18:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":55353,"name":"address","nodeType":"ElementaryTypeName","src":"18114:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"id":55360,"initialValue":{"arguments":[],"expression":{"argumentTypes":[],"expression":{"arguments":[{"id":55356,"name":"permissionedDisputeGameImpl","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55324,"src":"18144:27:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_address","typeString":"address"}],"id":55355,"name":"IFetcher","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":53958,"src":"18135:8:100","typeDescriptions":{"typeIdentifier":"t_type$_t_contract$_IFetcher_$53958_$","typeString":"type(contract IFetcher)"}},"id":55357,"isConstant":false,"isLValue":false,"isPure":false,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"18135:37:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_contract$_IFetcher_$53958","typeString":"contract IFetcher"}},"id":55358,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"18173:10:100","memberName":"challenger","nodeType":"MemberAccess","referencedDeclaration":53922,"src":"18135:48:100","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":55359,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"18135:50:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"VariableDeclarationStatement","src":"18114:71:100"},{"expression":{"arguments":[{"expression":{"expression":{"id":55364,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55193,"src":"18211:3:100","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$54911","typeString":"contract FetchChainInfoOutput"}},"id":55365,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"18215:10:100","memberName":"challenger","nodeType":"MemberAccess","referencedDeclaration":54831,"src":"18211:14:100","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":55366,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"18226:8:100","memberName":"selector","nodeType":"MemberAccess","src":"18211:23:100","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},{"id":55367,"name":"challenger","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55354,"src":"18236:10:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_bytes4","typeString":"bytes4"},{"typeIdentifier":"t_address","typeString":"address"}],"expression":{"id":55361,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55193,"src":"18203:3:100","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$54911","typeString":"contract FetchChainInfoOutput"}},"id":55363,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"18207:3:100","memberName":"set","nodeType":"MemberAccess","referencedDeclaration":54384,"src":"18203:7:100","typeDescriptions":{"typeIdentifier":"t_function_external_nonpayable$_t_bytes4_$_t_address_$returns$__$","typeString":"function (bytes4,address) external"}},"id":55368,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"18203:44:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":55369,"nodeType":"ExpressionStatement","src":"18203:44:100"},{"assignments":[55371],"declarations":[{"constant":false,"id":55371,"mutability":"mutable","name":"anchorStateRegistryProxy","nameLocation":"18274:24:100","nodeType":"VariableDeclaration","scope":55453,"src":"18266:32:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":55370,"name":"address","nodeType":"ElementaryTypeName","src":"18266:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"id":55377,"initialValue":{"arguments":[],"expression":{"argumentTypes":[],"expression":{"arguments":[{"id":55373,"name":"permissionedDisputeGameImpl","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55324,"src":"18310:27:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_address","typeString":"address"}],"id":55372,"name":"IFetcher","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":53958,"src":"18301:8:100","typeDescriptions":{"typeIdentifier":"t_type$_t_contract$_IFetcher_$53958_$","typeString":"type(contract IFetcher)"}},"id":55374,"isConstant":false,"isLValue":false,"isPure":false,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"18301:37:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_contract$_IFetcher_$53958","typeString":"contract IFetcher"}},"id":55375,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"18339:19:100","memberName":"anchorStateRegistry","nodeType":"MemberAccess","referencedDeclaration":53897,"src":"18301:57:100","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":55376,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"18301:59:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"VariableDeclarationStatement","src":"18266:94:100"},{"expression":{"arguments":[{"expression":{"expression":{"id":55381,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55193,"src":"18386:3:100","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$54911","typeString":"contract FetchChainInfoOutput"}},"id":55382,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"18390:24:100","memberName":"anchorStateRegistryProxy","nodeType":"MemberAccess","referencedDeclaration":54645,"src":"18386:28:100","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":55383,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"18415:8:100","memberName":"selector","nodeType":"MemberAccess","src":"18386:37:100","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},{"id":55384,"name":"anchorStateRegistryProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55371,"src":"18425:24:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_bytes4","typeString":"bytes4"},{"typeIdentifier":"t_address","typeString":"address"}],"expression":{"id":55378,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55193,"src":"18378:3:100","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$54911","typeString":"contract FetchChainInfoOutput"}},"id":55380,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"18382:3:100","memberName":"set","nodeType":"MemberAccess","referencedDeclaration":54384,"src":"18378:7:100","typeDescriptions":{"typeIdentifier":"t_function_external_nonpayable$_t_bytes4_$_t_address_$returns$__$","typeString":"function (bytes4,address) external"}},"id":55385,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"18378:72:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":55386,"nodeType":"ExpressionStatement","src":"18378:72:100"},{"assignments":[55388],"declarations":[{"constant":false,"id":55388,"mutability":"mutable","name":"proposer","nameLocation":"18477:8:100","nodeType":"VariableDeclaration","scope":55453,"src":"18469:16:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":55387,"name":"address","nodeType":"ElementaryTypeName","src":"18469:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"id":55394,"initialValue":{"arguments":[],"expression":{"argumentTypes":[],"expression":{"arguments":[{"id":55390,"name":"permissionedDisputeGameImpl","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55324,"src":"18497:27:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_address","typeString":"address"}],"id":55389,"name":"IFetcher","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":53958,"src":"18488:8:100","typeDescriptions":{"typeIdentifier":"t_type$_t_contract$_IFetcher_$53958_$","typeString":"type(contract IFetcher)"}},"id":55391,"isConstant":false,"isLValue":false,"isPure":false,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"18488:37:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_contract$_IFetcher_$53958","typeString":"contract IFetcher"}},"id":55392,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"18526:8:100","memberName":"proposer","nodeType":"MemberAccess","referencedDeclaration":53927,"src":"18488:46:100","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":55393,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"18488:48:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"VariableDeclarationStatement","src":"18469:67:100"},{"expression":{"arguments":[{"expression":{"expression":{"id":55398,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55193,"src":"18562:3:100","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$54911","typeString":"contract FetchChainInfoOutput"}},"id":55399,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"18566:8:100","memberName":"proposer","nodeType":"MemberAccess","referencedDeclaration":54849,"src":"18562:12:100","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":55400,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"18575:8:100","memberName":"selector","nodeType":"MemberAccess","src":"18562:21:100","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},{"id":55401,"name":"proposer","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55388,"src":"18585:8:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_bytes4","typeString":"bytes4"},{"typeIdentifier":"t_address","typeString":"address"}],"expression":{"id":55395,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55193,"src":"18554:3:100","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$54911","typeString":"contract FetchChainInfoOutput"}},"id":55397,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"18558:3:100","memberName":"set","nodeType":"MemberAccess","referencedDeclaration":54384,"src":"18554:7:100","typeDescriptions":{"typeIdentifier":"t_function_external_nonpayable$_t_bytes4_$_t_address_$returns$__$","typeString":"function (bytes4,address) external"}},"id":55402,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"18554:40:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":55403,"nodeType":"ExpressionStatement","src":"18554:40:100"},{"assignments":[55405],"declarations":[{"constant":false,"id":55405,"mutability":"mutable","name":"delayedWethPermissionedGameProxy","nameLocation":"18621:32:100","nodeType":"VariableDeclaration","scope":55453,"src":"18613:40:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":55404,"name":"address","nodeType":"ElementaryTypeName","src":"18613:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"id":55409,"initialValue":{"arguments":[{"id":55407,"name":"permissionedDisputeGameImpl","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55324,"src":"18677:27:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_address","typeString":"address"}],"id":55406,"name":"_getDelayedWETHProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55967,"src":"18656:20:100","typeDescriptions":{"typeIdentifier":"t_function_internal_view$_t_address_$returns$_t_address_$","typeString":"function (address) view returns (address)"}},"id":55408,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"18656:49:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"VariableDeclarationStatement","src":"18613:92:100"},{"expression":{"arguments":[{"expression":{"expression":{"id":55413,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55193,"src":"18731:3:100","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$54911","typeString":"contract FetchChainInfoOutput"}},"id":55414,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"18735:32:100","memberName":"delayedWethPermissionedGameProxy","nodeType":"MemberAccess","referencedDeclaration":54653,"src":"18731:36:100","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":55415,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"18768:8:100","memberName":"selector","nodeType":"MemberAccess","src":"18731:45:100","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},{"id":55416,"name":"delayedWethPermissionedGameProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55405,"src":"18778:32:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_bytes4","typeString":"bytes4"},{"typeIdentifier":"t_address","typeString":"address"}],"expression":{"id":55410,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55193,"src":"18723:3:100","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$54911","typeString":"contract FetchChainInfoOutput"}},"id":55412,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"18727:3:100","memberName":"set","nodeType":"MemberAccess","referencedDeclaration":54384,"src":"18723:7:100","typeDescriptions":{"typeIdentifier":"t_function_external_nonpayable$_t_bytes4_$_t_address_$returns$__$","typeString":"function (bytes4,address) external"}},"id":55417,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"18723:88:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":55418,"nodeType":"ExpressionStatement","src":"18723:88:100"},{"assignments":[55420],"declarations":[{"constant":false,"id":55420,"mutability":"mutable","name":"mipsImpl","nameLocation":"18838:8:100","nodeType":"VariableDeclaration","scope":55453,"src":"18830:16:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":55419,"name":"address","nodeType":"ElementaryTypeName","src":"18830:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"id":55426,"initialValue":{"arguments":[],"expression":{"argumentTypes":[],"expression":{"arguments":[{"id":55422,"name":"permissionedDisputeGameImpl","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55324,"src":"18858:27:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_address","typeString":"address"}],"id":55421,"name":"IFetcher","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":53958,"src":"18849:8:100","typeDescriptions":{"typeIdentifier":"t_type$_t_contract$_IFetcher_$53958_$","typeString":"type(contract IFetcher)"}},"id":55423,"isConstant":false,"isLValue":false,"isPure":false,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"18849:37:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_contract$_IFetcher_$53958","typeString":"contract IFetcher"}},"id":55424,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"18887:2:100","memberName":"vm","nodeType":"MemberAccess","referencedDeclaration":53912,"src":"18849:40:100","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":55425,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"18849:42:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"VariableDeclarationStatement","src":"18830:61:100"},{"expression":{"arguments":[{"expression":{"expression":{"id":55430,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55193,"src":"18917:3:100","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$54911","typeString":"contract FetchChainInfoOutput"}},"id":55431,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"18921:8:100","memberName":"mipsImpl","nodeType":"MemberAccess","referencedDeclaration":54723,"src":"18917:12:100","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":55432,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"18930:8:100","memberName":"selector","nodeType":"MemberAccess","src":"18917:21:100","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},{"id":55433,"name":"mipsImpl","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55420,"src":"18940:8:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_bytes4","typeString":"bytes4"},{"typeIdentifier":"t_address","typeString":"address"}],"expression":{"id":55427,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55193,"src":"18909:3:100","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$54911","typeString":"contract FetchChainInfoOutput"}},"id":55429,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"18913:3:100","memberName":"set","nodeType":"MemberAccess","referencedDeclaration":54384,"src":"18909:7:100","typeDescriptions":{"typeIdentifier":"t_function_external_nonpayable$_t_bytes4_$_t_address_$returns$__$","typeString":"function (bytes4,address) external"}},"id":55434,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"18909:40:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":55435,"nodeType":"ExpressionStatement","src":"18909:40:100"},{"assignments":[55437],"declarations":[{"constant":false,"id":55437,"mutability":"mutable","name":"preimageOracleImpl","nameLocation":"18976:18:100","nodeType":"VariableDeclaration","scope":55453,"src":"18968:26:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":55436,"name":"address","nodeType":"ElementaryTypeName","src":"18968:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"id":55443,"initialValue":{"arguments":[],"expression":{"argumentTypes":[],"expression":{"arguments":[{"id":55439,"name":"mipsImpl","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55420,"src":"19006:8:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_address","typeString":"address"}],"id":55438,"name":"IFetcher","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":53958,"src":"18997:8:100","typeDescriptions":{"typeIdentifier":"t_type$_t_contract$_IFetcher_$53958_$","typeString":"type(contract IFetcher)"}},"id":55440,"isConstant":false,"isLValue":false,"isPure":false,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"18997:18:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_contract$_IFetcher_$53958","typeString":"contract IFetcher"}},"id":55441,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"19016:6:100","memberName":"oracle","nodeType":"MemberAccess","referencedDeclaration":53917,"src":"18997:25:100","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":55442,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"18997:27:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"VariableDeclarationStatement","src":"18968:56:100"},{"expression":{"arguments":[{"expression":{"expression":{"id":55447,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55193,"src":"19050:3:100","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$54911","typeString":"contract FetchChainInfoOutput"}},"id":55448,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"19054:18:100","memberName":"preimageOracleImpl","nodeType":"MemberAccess","referencedDeclaration":54759,"src":"19050:22:100","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":55449,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"19073:8:100","memberName":"selector","nodeType":"MemberAccess","src":"19050:31:100","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},{"id":55450,"name":"preimageOracleImpl","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55437,"src":"19083:18:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_bytes4","typeString":"bytes4"},{"typeIdentifier":"t_address","typeString":"address"}],"expression":{"id":55444,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55193,"src":"19042:3:100","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$54911","typeString":"contract FetchChainInfoOutput"}},"id":55446,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"19046:3:100","memberName":"set","nodeType":"MemberAccess","referencedDeclaration":54384,"src":"19042:7:100","typeDescriptions":{"typeIdentifier":"t_function_external_nonpayable$_t_bytes4_$_t_address_$returns$__$","typeString":"function (bytes4,address) external"}},"id":55451,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"19042:60:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":55452,"nodeType":"ExpressionStatement","src":"19042:60:100"}]}},{"assignments":[55456],"declarations":[{"constant":false,"id":55456,"mutability":"mutable","name":"faultDisputeGameImpl","nameLocation":"19139:20:100","nodeType":"VariableDeclaration","scope":55527,"src":"19131:28:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":55455,"name":"address","nodeType":"ElementaryTypeName","src":"19131:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"id":55460,"initialValue":{"arguments":[{"id":55458,"name":"disputeGameFactoryProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55303,"src":"19183:23:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_address","typeString":"address"}],"id":55457,"name":"_getFaultDisputeGame","nodeType":"Identifier","overloadedDeclarations":[55832,55864],"referencedDeclaration":55832,"src":"19162:20:100","typeDescriptions":{"typeIdentifier":"t_function_internal_view$_t_address_$returns$_t_address_$","typeString":"function (address) view returns (address)"}},"id":55459,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"19162:45:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"VariableDeclarationStatement","src":"19131:76:100"},{"condition":{"commonType":{"typeIdentifier":"t_address","typeString":"address"},"id":55466,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftExpression":{"id":55461,"name":"faultDisputeGameImpl","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55456,"src":"19225:20:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"BinaryOperation","operator":"!=","rightExpression":{"arguments":[{"hexValue":"30","id":55464,"isConstant":false,"isLValue":false,"isPure":true,"kind":"number","lValueRequested":false,"nodeType":"Literal","src":"19257:1:100","typeDescriptions":{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"},"value":"0"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"}],"id":55463,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"nodeType":"ElementaryTypeNameExpression","src":"19249:7:100","typeDescriptions":{"typeIdentifier":"t_type$_t_address_$","typeString":"type(address)"},"typeName":{"id":55462,"name":"address","nodeType":"ElementaryTypeName","src":"19249:7:100","typeDescriptions":{}}},"id":55465,"isConstant":false,"isLValue":false,"isPure":true,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"19249:10:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"src":"19225:34:100","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},"id":55501,"nodeType":"IfStatement","src":"19221:470:100","trueBody":{"id":55500,"nodeType":"Block","src":"19261:430:100","statements":[{"expression":{"arguments":[{"expression":{"expression":{"id":55470,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55193,"src":"19344:3:100","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$54911","typeString":"contract FetchChainInfoOutput"}},"id":55471,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"19348:20:100","memberName":"faultDisputeGameImpl","nodeType":"MemberAccess","referencedDeclaration":54687,"src":"19344:24:100","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":55472,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"19369:8:100","memberName":"selector","nodeType":"MemberAccess","src":"19344:33:100","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},{"id":55473,"name":"faultDisputeGameImpl","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55456,"src":"19379:20:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_bytes4","typeString":"bytes4"},{"typeIdentifier":"t_address","typeString":"address"}],"expression":{"id":55467,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55193,"src":"19336:3:100","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$54911","typeString":"contract FetchChainInfoOutput"}},"id":55469,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"19340:3:100","memberName":"set","nodeType":"MemberAccess","referencedDeclaration":54384,"src":"19336:7:100","typeDescriptions":{"typeIdentifier":"t_function_external_nonpayable$_t_bytes4_$_t_address_$returns$__$","typeString":"function (bytes4,address) external"}},"id":55474,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"19336:64:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":55475,"nodeType":"ExpressionStatement","src":"19336:64:100"},{"expression":{"arguments":[{"expression":{"expression":{"id":55479,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55193,"src":"19426:3:100","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$54911","typeString":"contract FetchChainInfoOutput"}},"id":55480,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"19430:14:100","memberName":"permissionless","nodeType":"MemberAccess","referencedDeclaration":54901,"src":"19426:18:100","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_bool_$","typeString":"function () view external returns (bool)"}},"id":55481,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"19445:8:100","memberName":"selector","nodeType":"MemberAccess","src":"19426:27:100","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},{"hexValue":"74727565","id":55482,"isConstant":false,"isLValue":false,"isPure":true,"kind":"bool","lValueRequested":false,"nodeType":"Literal","src":"19455:4:100","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"},"value":"true"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_bytes4","typeString":"bytes4"},{"typeIdentifier":"t_bool","typeString":"bool"}],"expression":{"id":55476,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55193,"src":"19418:3:100","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$54911","typeString":"contract FetchChainInfoOutput"}},"id":55478,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"19422:3:100","memberName":"set","nodeType":"MemberAccess","referencedDeclaration":54416,"src":"19418:7:100","typeDescriptions":{"typeIdentifier":"t_function_external_nonpayable$_t_bytes4_$_t_bool_$returns$__$","typeString":"function (bytes4,bool) external"}},"id":55483,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"19418:42:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":55484,"nodeType":"ExpressionStatement","src":"19418:42:100"},{"assignments":[55486],"declarations":[{"constant":false,"id":55486,"mutability":"mutable","name":"delayedWethPermissionlessGameProxy","nameLocation":"19487:34:100","nodeType":"VariableDeclaration","scope":55500,"src":"19479:42:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":55485,"name":"address","nodeType":"ElementaryTypeName","src":"19479:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"id":55490,"initialValue":{"arguments":[{"id":55488,"name":"faultDisputeGameImpl","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55456,"src":"19545:20:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_address","typeString":"address"}],"id":55487,"name":"_getDelayedWETHProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55967,"src":"19524:20:100","typeDescriptions":{"typeIdentifier":"t_function_internal_view$_t_address_$returns$_t_address_$","typeString":"function (address) view returns (address)"}},"id":55489,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"19524:42:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"VariableDeclarationStatement","src":"19479:87:100"},{"expression":{"arguments":[{"expression":{"expression":{"id":55494,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55193,"src":"19592:3:100","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$54911","typeString":"contract FetchChainInfoOutput"}},"id":55495,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"19596:34:100","memberName":"delayedWethPermissionlessGameProxy","nodeType":"MemberAccess","referencedDeclaration":54661,"src":"19592:38:100","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":55496,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"19631:8:100","memberName":"selector","nodeType":"MemberAccess","src":"19592:47:100","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},{"id":55497,"name":"delayedWethPermissionlessGameProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55486,"src":"19641:34:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_bytes4","typeString":"bytes4"},{"typeIdentifier":"t_address","typeString":"address"}],"expression":{"id":55491,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55193,"src":"19584:3:100","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$54911","typeString":"contract FetchChainInfoOutput"}},"id":55493,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"19588:3:100","memberName":"set","nodeType":"MemberAccess","referencedDeclaration":54384,"src":"19584:7:100","typeDescriptions":{"typeIdentifier":"t_function_external_nonpayable$_t_bytes4_$_t_address_$returns$__$","typeString":"function (bytes4,address) external"}},"id":55498,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"19584:92:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":55499,"nodeType":"ExpressionStatement","src":"19584:92:100"}]}},{"assignments":[55503],"declarations":[{"constant":false,"id":55503,"mutability":"mutable","name":"faultDisputeGameCannonKonaImpl","nameLocation":"19713:30:100","nodeType":"VariableDeclaration","scope":55527,"src":"19705:38:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":55502,"name":"address","nodeType":"ElementaryTypeName","src":"19705:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"id":55509,"initialValue":{"arguments":[{"id":55505,"name":"disputeGameFactoryProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55303,"src":"19783:23:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},{"expression":{"id":55506,"name":"GameTypes","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":70870,"src":"19808:9:100","typeDescriptions":{"typeIdentifier":"t_type$_t_contract$_GameTypes_$70870_$","typeString":"type(library GameTypes)"}},"id":55507,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"memberLocation":"19818:11:100","memberName":"CANNON_KONA","nodeType":"MemberAccess","referencedDeclaration":70837,"src":"19808:21:100","typeDescriptions":{"typeIdentifier":"t_userDefinedValueType$_GameType_$70720","typeString":"GameType"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_address","typeString":"address"},{"typeIdentifier":"t_userDefinedValueType$_GameType_$70720","typeString":"GameType"}],"id":55504,"name":"_getFaultDisputeGame","nodeType":"Identifier","overloadedDeclarations":[55832,55864],"referencedDeclaration":55864,"src":"19762:20:100","typeDescriptions":{"typeIdentifier":"t_function_internal_view$_t_address_$_t_userDefinedValueType$_GameType_$70720_$returns$_t_address_$","typeString":"function (address,GameType) view returns (address)"}},"id":55508,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"19762:68:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"VariableDeclarationStatement","src":"19705:125:100"},{"condition":{"commonType":{"typeIdentifier":"t_address","typeString":"address"},"id":55515,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftExpression":{"id":55510,"name":"faultDisputeGameCannonKonaImpl","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55503,"src":"19848:30:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"BinaryOperation","operator":"!=","rightExpression":{"arguments":[{"hexValue":"30","id":55513,"isConstant":false,"isLValue":false,"isPure":true,"kind":"number","lValueRequested":false,"nodeType":"Literal","src":"19890:1:100","typeDescriptions":{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"},"value":"0"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"}],"id":55512,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"nodeType":"ElementaryTypeNameExpression","src":"19882:7:100","typeDescriptions":{"typeIdentifier":"t_type$_t_address_$","typeString":"type(address)"},"typeName":{"id":55511,"name":"address","nodeType":"ElementaryTypeName","src":"19882:7:100","typeDescriptions":{}}},"id":55514,"isConstant":false,"isLValue":false,"isPure":true,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"19882:10:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"src":"19848:44:100","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},"id":55526,"nodeType":"IfStatement","src":"19844:167:100","trueBody":{"id":55525,"nodeType":"Block","src":"19894:117:100","statements":[{"expression":{"arguments":[{"expression":{"expression":{"id":55519,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55193,"src":"19920:3:100","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$54911","typeString":"contract FetchChainInfoOutput"}},"id":55520,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"19924:30:100","memberName":"faultDisputeGameCannonKonaImpl","nodeType":"MemberAccess","referencedDeclaration":54705,"src":"19920:34:100","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":55521,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"19955:8:100","memberName":"selector","nodeType":"MemberAccess","src":"19920:43:100","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},{"id":55522,"name":"faultDisputeGameCannonKonaImpl","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55503,"src":"19965:30:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_bytes4","typeString":"bytes4"},{"typeIdentifier":"t_address","typeString":"address"}],"expression":{"id":55516,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55193,"src":"19912:3:100","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$54911","typeString":"contract FetchChainInfoOutput"}},"id":55518,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"19916:3:100","memberName":"set","nodeType":"MemberAccess","referencedDeclaration":54384,"src":"19912:7:100","typeDescriptions":{"typeIdentifier":"t_function_external_nonpayable$_t_bytes4_$_t_address_$returns$__$","typeString":"function (bytes4,address) external"}},"id":55523,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"19912:84:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":55524,"nodeType":"ExpressionStatement","src":"19912:84:100"}]}}]}}]},"implemented":true,"kind":"function","modifiers":[],"name":"_processFaultProofs","nameLocation":"16392:19:100","parameters":{"id":55194,"nodeType":"ParameterList","parameters":[{"constant":false,"id":55193,"mutability":"mutable","name":"_fo","nameLocation":"16433:3:100","nodeType":"VariableDeclaration","scope":55565,"src":"16412:24:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$54911","typeString":"contract FetchChainInfoOutput"},"typeName":{"id":55192,"nodeType":"UserDefinedTypeName","pathNode":{"id":55191,"name":"FetchChainInfoOutput","nameLocations":["16412:20:100"],"nodeType":"IdentifierPath","referencedDeclaration":54911,"src":"16412:20:100"},"referencedDeclaration":54911,"src":"16412:20:100","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$54911","typeString":"contract FetchChainInfoOutput"}},"visibility":"internal"}],"src":"16411:26:100"},"returnParameters":{"id":55195,"nodeType":"ParameterList","parameters":[],"src":"16447:0:100"},"scope":56018,"stateMutability":"nonpayable","virtual":false,"visibility":"internal"},{"id":55594,"nodeType":"FunctionDefinition","src":"20422:256:100","nodes":[],"body":{"id":55593,"nodeType":"Block","src":"20493:185:100","nodes":[],"statements":[{"clauses":[{"block":{"id":55582,"nodeType":"Block","src":"20564:41:100","statements":[{"expression":{"id":55580,"name":"guardian_","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55578,"src":"20585:9:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"functionReturnParameters":55571,"id":55581,"nodeType":"Return","src":"20578:16:100"}]},"errorName":"","id":55583,"nodeType":"TryCatchClause","parameters":{"id":55579,"nodeType":"ParameterList","parameters":[{"constant":false,"id":55578,"mutability":"mutable","name":"guardian_","nameLocation":"20553:9:100","nodeType":"VariableDeclaration","scope":55583,"src":"20545:17:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":55577,"name":"address","nodeType":"ElementaryTypeName","src":"20545:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"20544:19:100"},"src":"20536:69:100"},{"block":{"id":55590,"nodeType":"Block","src":"20612:60:100","statements":[{"expression":{"arguments":[],"expression":{"argumentTypes":[],"expression":{"arguments":[{"id":55585,"name":"_portal","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55567,"src":"20642:7:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_address","typeString":"address"}],"id":55584,"name":"IFetcher","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":53958,"src":"20633:8:100","typeDescriptions":{"typeIdentifier":"t_type$_t_contract$_IFetcher_$53958_$","typeString":"type(contract IFetcher)"}},"id":55586,"isConstant":false,"isLValue":false,"isPure":false,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"20633:17:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_contract$_IFetcher_$53958","typeString":"contract IFetcher"}},"id":55587,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"20651:8:100","memberName":"GUARDIAN","nodeType":"MemberAccess","referencedDeclaration":53823,"src":"20633:26:100","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":55588,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"20633:28:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"functionReturnParameters":55571,"id":55589,"nodeType":"Return","src":"20626:35:100"}]},"errorName":"","id":55591,"nodeType":"TryCatchClause","src":"20606:66:100"}],"externalCall":{"arguments":[],"expression":{"argumentTypes":[],"expression":{"arguments":[{"id":55573,"name":"_portal","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55567,"src":"20516:7:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_address","typeString":"address"}],"id":55572,"name":"IFetcher","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":53958,"src":"20507:8:100","typeDescriptions":{"typeIdentifier":"t_type$_t_contract$_IFetcher_$53958_$","typeString":"type(contract IFetcher)"}},"id":55574,"isConstant":false,"isLValue":false,"isPure":false,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"20507:17:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_contract$_IFetcher_$53958","typeString":"contract IFetcher"}},"id":55575,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"20525:8:100","memberName":"guardian","nodeType":"MemberAccess","referencedDeclaration":53818,"src":"20507:26:100","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":55576,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"20507:28:100","tryCall":true,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"id":55592,"nodeType":"TryStatement","src":"20503:169:100"}]},"implemented":true,"kind":"function","modifiers":[],"name":"_getGuardian","nameLocation":"20431:12:100","parameters":{"id":55568,"nodeType":"ParameterList","parameters":[{"constant":false,"id":55567,"mutability":"mutable","name":"_portal","nameLocation":"20452:7:100","nodeType":"VariableDeclaration","scope":55594,"src":"20444:15:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":55566,"name":"address","nodeType":"ElementaryTypeName","src":"20444:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"20443:17:100"},"returnParameters":{"id":55571,"nodeType":"ParameterList","parameters":[{"constant":false,"id":55570,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":55594,"src":"20484:7:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":55569,"name":"address","nodeType":"ElementaryTypeName","src":"20484:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"20483:9:100"},"scope":56018,"stateMutability":"view","virtual":false,"visibility":"internal"},{"id":55623,"nodeType":"FunctionDefinition","src":"20684:282:100","nodes":[],"body":{"id":55622,"nodeType":"Block","src":"20764:202:100","nodes":[],"statements":[{"clauses":[{"block":{"id":55611,"nodeType":"Block","src":"20843:45:100","statements":[{"expression":{"id":55609,"name":"systemConfig_","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55607,"src":"20864:13:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"functionReturnParameters":55600,"id":55610,"nodeType":"Return","src":"20857:20:100"}]},"errorName":"","id":55612,"nodeType":"TryCatchClause","parameters":{"id":55608,"nodeType":"ParameterList","parameters":[{"constant":false,"id":55607,"mutability":"mutable","name":"systemConfig_","nameLocation":"20828:13:100","nodeType":"VariableDeclaration","scope":55612,"src":"20820:21:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":55606,"name":"address","nodeType":"ElementaryTypeName","src":"20820:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"20819:23:100"},"src":"20811:77:100"},{"block":{"id":55619,"nodeType":"Block","src":"20895:65:100","statements":[{"expression":{"arguments":[],"expression":{"argumentTypes":[],"expression":{"arguments":[{"id":55614,"name":"_portal","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55596,"src":"20925:7:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_address","typeString":"address"}],"id":55613,"name":"IFetcher","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":53958,"src":"20916:8:100","typeDescriptions":{"typeIdentifier":"t_type$_t_contract$_IFetcher_$53958_$","typeString":"type(contract IFetcher)"}},"id":55615,"isConstant":false,"isLValue":false,"isPure":false,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"20916:17:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_contract$_IFetcher_$53958","typeString":"contract IFetcher"}},"id":55616,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"20934:13:100","memberName":"SYSTEM_CONFIG","nodeType":"MemberAccess","referencedDeclaration":53833,"src":"20916:31:100","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":55617,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"20916:33:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"functionReturnParameters":55600,"id":55618,"nodeType":"Return","src":"20909:40:100"}]},"errorName":"","id":55620,"nodeType":"TryCatchClause","src":"20889:71:100"}],"externalCall":{"arguments":[],"expression":{"argumentTypes":[],"expression":{"arguments":[{"id":55602,"name":"_portal","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55596,"src":"20787:7:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_address","typeString":"address"}],"id":55601,"name":"IFetcher","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":53958,"src":"20778:8:100","typeDescriptions":{"typeIdentifier":"t_type$_t_contract$_IFetcher_$53958_$","typeString":"type(contract IFetcher)"}},"id":55603,"isConstant":false,"isLValue":false,"isPure":false,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"20778:17:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_contract$_IFetcher_$53958","typeString":"contract IFetcher"}},"id":55604,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"20796:12:100","memberName":"systemConfig","nodeType":"MemberAccess","referencedDeclaration":53828,"src":"20778:30:100","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":55605,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"20778:32:100","tryCall":true,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"id":55621,"nodeType":"TryStatement","src":"20774:186:100"}]},"implemented":true,"kind":"function","modifiers":[],"name":"_getSystemConfigProxy","nameLocation":"20693:21:100","parameters":{"id":55597,"nodeType":"ParameterList","parameters":[{"constant":false,"id":55596,"mutability":"mutable","name":"_portal","nameLocation":"20723:7:100","nodeType":"VariableDeclaration","scope":55623,"src":"20715:15:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":55595,"name":"address","nodeType":"ElementaryTypeName","src":"20715:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"20714:17:100"},"returnParameters":{"id":55600,"nodeType":"ParameterList","parameters":[{"constant":false,"id":55599,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":55623,"src":"20755:7:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":55598,"name":"address","nodeType":"ElementaryTypeName","src":"20755:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"20754:9:100"},"scope":56018,"stateMutability":"view","virtual":false,"visibility":"internal"},{"id":55652,"nodeType":"FunctionDefinition","src":"20972:338:100","nodes":[],"body":{"id":55651,"nodeType":"Block","src":"21075:235:100","nodes":[],"statements":[{"clauses":[{"block":{"id":55640,"nodeType":"Block","src":"21171:47:100","statements":[{"expression":{"id":55638,"name":"optimismPortal_","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55636,"src":"21192:15:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"functionReturnParameters":55629,"id":55639,"nodeType":"Return","src":"21185:22:100"}]},"errorName":"","id":55641,"nodeType":"TryCatchClause","parameters":{"id":55637,"nodeType":"ParameterList","parameters":[{"constant":false,"id":55636,"mutability":"mutable","name":"optimismPortal_","nameLocation":"21154:15:100","nodeType":"VariableDeclaration","scope":55641,"src":"21146:23:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":55635,"name":"address","nodeType":"ElementaryTypeName","src":"21146:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"21145:25:100"},"src":"21137:81:100"},{"block":{"id":55648,"nodeType":"Block","src":"21225:79:100","statements":[{"expression":{"arguments":[],"expression":{"argumentTypes":[],"expression":{"arguments":[{"id":55643,"name":"_l1CrossDomainMessengerProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55625,"src":"21255:28:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_address","typeString":"address"}],"id":55642,"name":"IFetcher","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":53958,"src":"21246:8:100","typeDescriptions":{"typeIdentifier":"t_type$_t_contract$_IFetcher_$53958_$","typeString":"type(contract IFetcher)"}},"id":55644,"isConstant":false,"isLValue":false,"isPure":false,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"21246:38:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_contract$_IFetcher_$53958","typeString":"contract IFetcher"}},"id":55645,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"21285:6:100","memberName":"PORTAL","nodeType":"MemberAccess","referencedDeclaration":53863,"src":"21246:45:100","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":55646,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"21246:47:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"functionReturnParameters":55629,"id":55647,"nodeType":"Return","src":"21239:54:100"}]},"errorName":"","id":55649,"nodeType":"TryCatchClause","src":"21219:85:100"}],"externalCall":{"arguments":[],"expression":{"argumentTypes":[],"expression":{"arguments":[{"id":55631,"name":"_l1CrossDomainMessengerProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55625,"src":"21098:28:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_address","typeString":"address"}],"id":55630,"name":"IFetcher","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":53958,"src":"21089:8:100","typeDescriptions":{"typeIdentifier":"t_type$_t_contract$_IFetcher_$53958_$","typeString":"type(contract IFetcher)"}},"id":55632,"isConstant":false,"isLValue":false,"isPure":false,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"21089:38:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_contract$_IFetcher_$53958","typeString":"contract IFetcher"}},"id":55633,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"21128:6:100","memberName":"portal","nodeType":"MemberAccess","referencedDeclaration":53868,"src":"21089:45:100","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":55634,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"21089:47:100","tryCall":true,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"id":55650,"nodeType":"TryStatement","src":"21085:219:100"}]},"implemented":true,"kind":"function","modifiers":[],"name":"_getOptimismPortalProxy","nameLocation":"20981:23:100","parameters":{"id":55626,"nodeType":"ParameterList","parameters":[{"constant":false,"id":55625,"mutability":"mutable","name":"_l1CrossDomainMessengerProxy","nameLocation":"21013:28:100","nodeType":"VariableDeclaration","scope":55652,"src":"21005:36:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":55624,"name":"address","nodeType":"ElementaryTypeName","src":"21005:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"21004:38:100"},"returnParameters":{"id":55629,"nodeType":"ParameterList","parameters":[{"constant":false,"id":55628,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":55652,"src":"21066:7:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":55627,"name":"address","nodeType":"ElementaryTypeName","src":"21066:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"21065:9:100"},"scope":56018,"stateMutability":"view","virtual":false,"visibility":"internal"},{"id":55690,"nodeType":"FunctionDefinition","src":"21316:350:100","nodes":[],"body":{"id":55689,"nodeType":"Block","src":"21414:252:100","nodes":[],"statements":[{"assignments":[55660],"declarations":[{"constant":false,"id":55660,"mutability":"mutable","name":"ADDRESS_MANAGER_MAPPING_SLOT","nameLocation":"21432:28:100","nodeType":"VariableDeclaration","scope":55689,"src":"21424:36:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_uint256","typeString":"uint256"},"typeName":{"id":55659,"name":"uint256","nodeType":"ElementaryTypeName","src":"21424:7:100","typeDescriptions":{"typeIdentifier":"t_uint256","typeString":"uint256"}},"visibility":"internal"}],"id":55662,"initialValue":{"hexValue":"31","id":55661,"isConstant":false,"isLValue":false,"isPure":true,"kind":"number","lValueRequested":false,"nodeType":"Literal","src":"21463:1:100","typeDescriptions":{"typeIdentifier":"t_rational_1_by_1","typeString":"int_const 1"},"value":"1"},"nodeType":"VariableDeclarationStatement","src":"21424:40:100"},{"assignments":[55664],"declarations":[{"constant":false,"id":55664,"mutability":"mutable","name":"slot","nameLocation":"21482:4:100","nodeType":"VariableDeclaration","scope":55689,"src":"21474:12:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_bytes32","typeString":"bytes32"},"typeName":{"id":55663,"name":"bytes32","nodeType":"ElementaryTypeName","src":"21474:7:100","typeDescriptions":{"typeIdentifier":"t_bytes32","typeString":"bytes32"}},"visibility":"internal"}],"id":55672,"initialValue":{"arguments":[{"arguments":[{"id":55668,"name":"_l1CrossDomainMessengerProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55654,"src":"21510:28:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},{"id":55669,"name":"ADDRESS_MANAGER_MAPPING_SLOT","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55660,"src":"21540:28:100","typeDescriptions":{"typeIdentifier":"t_uint256","typeString":"uint256"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_address","typeString":"address"},{"typeIdentifier":"t_uint256","typeString":"uint256"}],"expression":{"id":55666,"name":"abi","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":-1,"src":"21499:3:100","typeDescriptions":{"typeIdentifier":"t_magic_abi","typeString":"abi"}},"id":55667,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"memberLocation":"21503:6:100","memberName":"encode","nodeType":"MemberAccess","src":"21499:10:100","typeDescriptions":{"typeIdentifier":"t_function_abiencode_pure$__$returns$_t_bytes_memory_ptr_$","typeString":"function () pure returns (bytes memory)"}},"id":55670,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"21499:70:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_bytes_memory_ptr","typeString":"bytes memory"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_bytes_memory_ptr","typeString":"bytes memory"}],"id":55665,"name":"keccak256","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":-8,"src":"21489:9:100","typeDescriptions":{"typeIdentifier":"t_function_keccak256_pure$_t_bytes_memory_ptr_$returns$_t_bytes32_$","typeString":"function (bytes memory) pure returns (bytes32)"}},"id":55671,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"21489:81:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_bytes32","typeString":"bytes32"}},"nodeType":"VariableDeclarationStatement","src":"21474:96:100"},{"expression":{"arguments":[{"arguments":[{"arguments":[{"components":[{"arguments":[{"id":55681,"name":"_l1CrossDomainMessengerProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55654,"src":"21620:28:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},{"id":55682,"name":"slot","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55664,"src":"21650:4:100","typeDescriptions":{"typeIdentifier":"t_bytes32","typeString":"bytes32"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_address","typeString":"address"},{"typeIdentifier":"t_bytes32","typeString":"bytes32"}],"expression":{"id":55679,"name":"vm","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":5501,"src":"21612:2:100","typeDescriptions":{"typeIdentifier":"t_contract$_Vm_$23288","typeString":"contract Vm"}},"id":55680,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"21615:4:100","memberName":"load","nodeType":"MemberAccess","referencedDeclaration":19384,"src":"21612:7:100","typeDescriptions":{"typeIdentifier":"t_function_external_view$_t_address_$_t_bytes32_$returns$_t_bytes32_$","typeString":"function (address,bytes32) view external returns (bytes32)"}},"id":55683,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"21612:43:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_bytes32","typeString":"bytes32"}}],"id":55684,"isConstant":false,"isInlineArray":false,"isLValue":false,"isPure":false,"lValueRequested":false,"nodeType":"TupleExpression","src":"21611:45:100","typeDescriptions":{"typeIdentifier":"t_bytes32","typeString":"bytes32"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_bytes32","typeString":"bytes32"}],"id":55678,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"nodeType":"ElementaryTypeNameExpression","src":"21603:7:100","typeDescriptions":{"typeIdentifier":"t_type$_t_uint256_$","typeString":"type(uint256)"},"typeName":{"id":55677,"name":"uint256","nodeType":"ElementaryTypeName","src":"21603:7:100","typeDescriptions":{}}},"id":55685,"isConstant":false,"isLValue":false,"isPure":false,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"21603:54:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_uint256","typeString":"uint256"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_uint256","typeString":"uint256"}],"id":55676,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"nodeType":"ElementaryTypeNameExpression","src":"21595:7:100","typeDescriptions":{"typeIdentifier":"t_type$_t_uint160_$","typeString":"type(uint160)"},"typeName":{"id":55675,"name":"uint160","nodeType":"ElementaryTypeName","src":"21595:7:100","typeDescriptions":{}}},"id":55686,"isConstant":false,"isLValue":false,"isPure":false,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"21595:63:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_uint160","typeString":"uint160"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_uint160","typeString":"uint160"}],"id":55674,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"nodeType":"ElementaryTypeNameExpression","src":"21587:7:100","typeDescriptions":{"typeIdentifier":"t_type$_t_address_$","typeString":"type(address)"},"typeName":{"id":55673,"name":"address","nodeType":"ElementaryTypeName","src":"21587:7:100","typeDescriptions":{}}},"id":55687,"isConstant":false,"isLValue":false,"isPure":false,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"21587:72:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"functionReturnParameters":55658,"id":55688,"nodeType":"Return","src":"21580:79:100"}]},"implemented":true,"kind":"function","modifiers":[],"name":"_getAddressManager","nameLocation":"21325:18:100","parameters":{"id":55655,"nodeType":"ParameterList","parameters":[{"constant":false,"id":55654,"mutability":"mutable","name":"_l1CrossDomainMessengerProxy","nameLocation":"21352:28:100","nodeType":"VariableDeclaration","scope":55690,"src":"21344:36:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":55653,"name":"address","nodeType":"ElementaryTypeName","src":"21344:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"21343:38:100"},"returnParameters":{"id":55658,"nodeType":"ParameterList","parameters":[{"constant":false,"id":55657,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":55690,"src":"21405:7:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":55656,"name":"address","nodeType":"ElementaryTypeName","src":"21405:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"21404:9:100"},"scope":56018,"stateMutability":"view","virtual":false,"visibility":"internal"},{"id":55718,"nodeType":"FunctionDefinition","src":"21672:299:100","nodes":[],"body":{"id":55717,"nodeType":"Block","src":"21765:206:100","nodes":[],"statements":[{"clauses":[{"block":{"id":55707,"nodeType":"Block","src":"21864:52:100","statements":[{"expression":{"id":55705,"name":"l1ERC721BridgeProxy_","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55703,"src":"21885:20:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"functionReturnParameters":55696,"id":55706,"nodeType":"Return","src":"21878:27:100"}]},"errorName":"","id":55708,"nodeType":"TryCatchClause","parameters":{"id":55704,"nodeType":"ParameterList","parameters":[{"constant":false,"id":55703,"mutability":"mutable","name":"l1ERC721BridgeProxy_","nameLocation":"21842:20:100","nodeType":"VariableDeclaration","scope":55708,"src":"21834:28:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":55702,"name":"address","nodeType":"ElementaryTypeName","src":"21834:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"21833:30:100"},"src":"21825:91:100"},{"block":{"id":55714,"nodeType":"Block","src":"21923:42:100","statements":[{"expression":{"arguments":[{"hexValue":"30","id":55711,"isConstant":false,"isLValue":false,"isPure":true,"kind":"number","lValueRequested":false,"nodeType":"Literal","src":"21952:1:100","typeDescriptions":{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"},"value":"0"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"}],"id":55710,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"nodeType":"ElementaryTypeNameExpression","src":"21944:7:100","typeDescriptions":{"typeIdentifier":"t_type$_t_address_$","typeString":"type(address)"},"typeName":{"id":55709,"name":"address","nodeType":"ElementaryTypeName","src":"21944:7:100","typeDescriptions":{}}},"id":55712,"isConstant":false,"isLValue":false,"isPure":true,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"21944:10:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"functionReturnParameters":55696,"id":55713,"nodeType":"Return","src":"21937:17:100"}]},"errorName":"","id":55715,"nodeType":"TryCatchClause","src":"21917:48:100"}],"externalCall":{"arguments":[],"expression":{"argumentTypes":[],"expression":{"arguments":[{"id":55698,"name":"_systemConfigProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55692,"src":"21788:18:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_address","typeString":"address"}],"id":55697,"name":"IFetcher","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":53958,"src":"21779:8:100","typeDescriptions":{"typeIdentifier":"t_type$_t_contract$_IFetcher_$53958_$","typeString":"type(contract IFetcher)"}},"id":55699,"isConstant":false,"isLValue":false,"isPure":false,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"21779:28:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_contract$_IFetcher_$53958","typeString":"contract IFetcher"}},"id":55700,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"21808:14:100","memberName":"l1ERC721Bridge","nodeType":"MemberAccess","referencedDeclaration":53873,"src":"21779:43:100","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":55701,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"21779:45:100","tryCall":true,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"id":55716,"nodeType":"TryStatement","src":"21775:190:100"}]},"implemented":true,"kind":"function","modifiers":[],"name":"_getL1ERC721BridgeProxy","nameLocation":"21681:23:100","parameters":{"id":55693,"nodeType":"ParameterList","parameters":[{"constant":false,"id":55692,"mutability":"mutable","name":"_systemConfigProxy","nameLocation":"21713:18:100","nodeType":"VariableDeclaration","scope":55718,"src":"21705:26:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":55691,"name":"address","nodeType":"ElementaryTypeName","src":"21705:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"21704:28:100"},"returnParameters":{"id":55696,"nodeType":"ParameterList","parameters":[{"constant":false,"id":55695,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":55718,"src":"21756:7:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":55694,"name":"address","nodeType":"ElementaryTypeName","src":"21756:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"21755:9:100"},"scope":56018,"stateMutability":"view","virtual":false,"visibility":"internal"},{"id":55746,"nodeType":"FunctionDefinition","src":"21977:377:100","nodes":[],"body":{"id":55745,"nodeType":"Block","src":"22084:270:100","nodes":[],"statements":[{"clauses":[{"block":{"id":55735,"nodeType":"Block","src":"22233:66:100","statements":[{"expression":{"id":55733,"name":"optimismMintableERC20FactoryProxy_","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55731,"src":"22254:34:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"functionReturnParameters":55724,"id":55734,"nodeType":"Return","src":"22247:41:100"}]},"errorName":"","id":55736,"nodeType":"TryCatchClause","parameters":{"id":55732,"nodeType":"ParameterList","parameters":[{"constant":false,"id":55731,"mutability":"mutable","name":"optimismMintableERC20FactoryProxy_","nameLocation":"22188:34:100","nodeType":"VariableDeclaration","scope":55736,"src":"22180:42:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":55730,"name":"address","nodeType":"ElementaryTypeName","src":"22180:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"22166:66:100"},"src":"22158:141:100"},{"block":{"id":55742,"nodeType":"Block","src":"22306:42:100","statements":[{"expression":{"arguments":[{"hexValue":"30","id":55739,"isConstant":false,"isLValue":false,"isPure":true,"kind":"number","lValueRequested":false,"nodeType":"Literal","src":"22335:1:100","typeDescriptions":{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"},"value":"0"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"}],"id":55738,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"nodeType":"ElementaryTypeNameExpression","src":"22327:7:100","typeDescriptions":{"typeIdentifier":"t_type$_t_address_$","typeString":"type(address)"},"typeName":{"id":55737,"name":"address","nodeType":"ElementaryTypeName","src":"22327:7:100","typeDescriptions":{}}},"id":55740,"isConstant":false,"isLValue":false,"isPure":true,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"22327:10:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"functionReturnParameters":55724,"id":55741,"nodeType":"Return","src":"22320:17:100"}]},"errorName":"","id":55743,"nodeType":"TryCatchClause","src":"22300:48:100"}],"externalCall":{"arguments":[],"expression":{"argumentTypes":[],"expression":{"arguments":[{"id":55726,"name":"_systemConfigProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55720,"src":"22107:18:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_address","typeString":"address"}],"id":55725,"name":"IFetcher","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":53958,"src":"22098:8:100","typeDescriptions":{"typeIdentifier":"t_type$_t_contract$_IFetcher_$53958_$","typeString":"type(contract IFetcher)"}},"id":55727,"isConstant":false,"isLValue":false,"isPure":false,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"22098:28:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_contract$_IFetcher_$53958","typeString":"contract IFetcher"}},"id":55728,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"22127:28:100","memberName":"optimismMintableERC20Factory","nodeType":"MemberAccess","referencedDeclaration":53878,"src":"22098:57:100","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":55729,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"22098:59:100","tryCall":true,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"id":55744,"nodeType":"TryStatement","src":"22094:254:100"}]},"implemented":true,"kind":"function","modifiers":[],"name":"_getOptimismMintableERC20FactoryProxy","nameLocation":"21986:37:100","parameters":{"id":55721,"nodeType":"ParameterList","parameters":[{"constant":false,"id":55720,"mutability":"mutable","name":"_systemConfigProxy","nameLocation":"22032:18:100","nodeType":"VariableDeclaration","scope":55746,"src":"22024:26:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":55719,"name":"address","nodeType":"ElementaryTypeName","src":"22024:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"22023:28:100"},"returnParameters":{"id":55724,"nodeType":"ParameterList","parameters":[{"constant":false,"id":55723,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":55746,"src":"22075:7:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":55722,"name":"address","nodeType":"ElementaryTypeName","src":"22075:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"22074:9:100"},"scope":56018,"stateMutability":"view","virtual":false,"visibility":"internal"},{"id":55774,"nodeType":"FunctionDefinition","src":"22360:398:100","nodes":[],"body":{"id":55773,"nodeType":"Block","src":"22457:301:100","nodes":[],"statements":[{"clauses":[{"block":{"id":55763,"nodeType":"Block","src":"22564:56:100","statements":[{"expression":{"id":55761,"name":"disputeGameFactoryProxy_","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55759,"src":"22585:24:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"functionReturnParameters":55752,"id":55762,"nodeType":"Return","src":"22578:31:100"}]},"errorName":"","id":55764,"nodeType":"TryCatchClause","parameters":{"id":55760,"nodeType":"ParameterList","parameters":[{"constant":false,"id":55759,"mutability":"mutable","name":"disputeGameFactoryProxy_","nameLocation":"22538:24:100","nodeType":"VariableDeclaration","scope":55764,"src":"22530:32:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":55758,"name":"address","nodeType":"ElementaryTypeName","src":"22530:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"22529:34:100"},"src":"22521:99:100"},{"block":{"id":55770,"nodeType":"Block","src":"22627:125:100","statements":[{"expression":{"arguments":[{"hexValue":"30","id":55767,"isConstant":false,"isLValue":false,"isPure":true,"kind":"number","lValueRequested":false,"nodeType":"Literal","src":"22739:1:100","typeDescriptions":{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"},"value":"0"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"}],"id":55766,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"nodeType":"ElementaryTypeNameExpression","src":"22731:7:100","typeDescriptions":{"typeIdentifier":"t_type$_t_address_$","typeString":"type(address)"},"typeName":{"id":55765,"name":"address","nodeType":"ElementaryTypeName","src":"22731:7:100","typeDescriptions":{}}},"id":55768,"isConstant":false,"isLValue":false,"isPure":true,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"22731:10:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"functionReturnParameters":55752,"id":55769,"nodeType":"Return","src":"22724:17:100"}]},"errorName":"","id":55771,"nodeType":"TryCatchClause","src":"22621:131:100"}],"externalCall":{"arguments":[],"expression":{"argumentTypes":[],"expression":{"arguments":[{"id":55754,"name":"_systemConfigProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55748,"src":"22480:18:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_address","typeString":"address"}],"id":55753,"name":"IFetcher","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":53958,"src":"22471:8:100","typeDescriptions":{"typeIdentifier":"t_type$_t_contract$_IFetcher_$53958_$","typeString":"type(contract IFetcher)"}},"id":55755,"isConstant":false,"isLValue":false,"isPure":false,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"22471:28:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_contract$_IFetcher_$53958","typeString":"contract IFetcher"}},"id":55756,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"22500:18:100","memberName":"disputeGameFactory","nodeType":"MemberAccess","referencedDeclaration":53838,"src":"22471:47:100","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":55757,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"22471:49:100","tryCall":true,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"id":55772,"nodeType":"TryStatement","src":"22467:285:100"}]},"implemented":true,"kind":"function","modifiers":[],"name":"_getDisputeGameFactoryProxy","nameLocation":"22369:27:100","parameters":{"id":55749,"nodeType":"ParameterList","parameters":[{"constant":false,"id":55748,"mutability":"mutable","name":"_systemConfigProxy","nameLocation":"22405:18:100","nodeType":"VariableDeclaration","scope":55774,"src":"22397:26:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":55747,"name":"address","nodeType":"ElementaryTypeName","src":"22397:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"22396:28:100"},"returnParameters":{"id":55752,"nodeType":"ParameterList","parameters":[{"constant":false,"id":55751,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":55774,"src":"22448:7:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":55750,"name":"address","nodeType":"ElementaryTypeName","src":"22448:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"22447:9:100"},"scope":56018,"stateMutability":"view","virtual":false,"visibility":"internal"},{"id":55802,"nodeType":"FunctionDefinition","src":"22764:311:100","nodes":[],"body":{"id":55801,"nodeType":"Block","src":"22861:214:100","nodes":[],"statements":[{"clauses":[{"block":{"id":55791,"nodeType":"Block","src":"22966:54:100","statements":[{"expression":{"id":55789,"name":"superchainConfigProxy_","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55787,"src":"22987:22:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"functionReturnParameters":55780,"id":55790,"nodeType":"Return","src":"22980:29:100"}]},"errorName":"","id":55792,"nodeType":"TryCatchClause","parameters":{"id":55788,"nodeType":"ParameterList","parameters":[{"constant":false,"id":55787,"mutability":"mutable","name":"superchainConfigProxy_","nameLocation":"22942:22:100","nodeType":"VariableDeclaration","scope":55792,"src":"22934:30:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":55786,"name":"address","nodeType":"ElementaryTypeName","src":"22934:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"22933:32:100"},"src":"22925:95:100"},{"block":{"id":55798,"nodeType":"Block","src":"23027:42:100","statements":[{"expression":{"arguments":[{"hexValue":"30","id":55795,"isConstant":false,"isLValue":false,"isPure":true,"kind":"number","lValueRequested":false,"nodeType":"Literal","src":"23056:1:100","typeDescriptions":{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"},"value":"0"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"}],"id":55794,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"nodeType":"ElementaryTypeNameExpression","src":"23048:7:100","typeDescriptions":{"typeIdentifier":"t_type$_t_address_$","typeString":"type(address)"},"typeName":{"id":55793,"name":"address","nodeType":"ElementaryTypeName","src":"23048:7:100","typeDescriptions":{}}},"id":55796,"isConstant":false,"isLValue":false,"isPure":true,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"23048:10:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"functionReturnParameters":55780,"id":55797,"nodeType":"Return","src":"23041:17:100"}]},"errorName":"","id":55799,"nodeType":"TryCatchClause","src":"23021:48:100"}],"externalCall":{"arguments":[],"expression":{"argumentTypes":[],"expression":{"arguments":[{"id":55782,"name":"_optimismPortalProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55776,"src":"22884:20:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_address","typeString":"address"}],"id":55781,"name":"IFetcher","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":53958,"src":"22875:8:100","typeDescriptions":{"typeIdentifier":"t_type$_t_contract$_IFetcher_$53958_$","typeString":"type(contract IFetcher)"}},"id":55783,"isConstant":false,"isLValue":false,"isPure":false,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"22875:30:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_contract$_IFetcher_$53958","typeString":"contract IFetcher"}},"id":55784,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"22906:16:100","memberName":"superchainConfig","nodeType":"MemberAccess","referencedDeclaration":53848,"src":"22875:47:100","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":55785,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"22875:49:100","tryCall":true,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"id":55800,"nodeType":"TryStatement","src":"22871:198:100"}]},"implemented":true,"kind":"function","modifiers":[],"name":"_getSuperchainConfigProxy","nameLocation":"22773:25:100","parameters":{"id":55777,"nodeType":"ParameterList","parameters":[{"constant":false,"id":55776,"mutability":"mutable","name":"_optimismPortalProxy","nameLocation":"22807:20:100","nodeType":"VariableDeclaration","scope":55802,"src":"22799:28:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":55775,"name":"address","nodeType":"ElementaryTypeName","src":"22799:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"22798:30:100"},"returnParameters":{"id":55780,"nodeType":"ParameterList","parameters":[{"constant":false,"id":55779,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":55802,"src":"22852:7:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":55778,"name":"address","nodeType":"ElementaryTypeName","src":"22852:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"22851:9:100"},"scope":56018,"stateMutability":"view","virtual":false,"visibility":"internal"},{"id":55832,"nodeType":"FunctionDefinition","src":"23081:313:100","nodes":[],"body":{"id":55831,"nodeType":"Block","src":"23177:217:100","nodes":[],"statements":[{"clauses":[{"block":{"id":55821,"nodeType":"Block","src":"23290:49:100","statements":[{"expression":{"id":55819,"name":"faultDisputeGame_","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55817,"src":"23311:17:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"functionReturnParameters":55808,"id":55820,"nodeType":"Return","src":"23304:24:100"}]},"errorName":"","id":55822,"nodeType":"TryCatchClause","parameters":{"id":55818,"nodeType":"ParameterList","parameters":[{"constant":false,"id":55817,"mutability":"mutable","name":"faultDisputeGame_","nameLocation":"23271:17:100","nodeType":"VariableDeclaration","scope":55822,"src":"23263:25:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":55816,"name":"address","nodeType":"ElementaryTypeName","src":"23263:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"23262:27:100"},"src":"23254:85:100"},{"block":{"id":55828,"nodeType":"Block","src":"23346:42:100","statements":[{"expression":{"arguments":[{"hexValue":"30","id":55825,"isConstant":false,"isLValue":false,"isPure":true,"kind":"number","lValueRequested":false,"nodeType":"Literal","src":"23375:1:100","typeDescriptions":{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"},"value":"0"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"}],"id":55824,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"nodeType":"ElementaryTypeNameExpression","src":"23367:7:100","typeDescriptions":{"typeIdentifier":"t_type$_t_address_$","typeString":"type(address)"},"typeName":{"id":55823,"name":"address","nodeType":"ElementaryTypeName","src":"23367:7:100","typeDescriptions":{}}},"id":55826,"isConstant":false,"isLValue":false,"isPure":true,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"23367:10:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"functionReturnParameters":55808,"id":55827,"nodeType":"Return","src":"23360:17:100"}]},"errorName":"","id":55829,"nodeType":"TryCatchClause","src":"23340:48:100"}],"externalCall":{"arguments":[{"expression":{"id":55813,"name":"GameTypes","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":70870,"src":"23236:9:100","typeDescriptions":{"typeIdentifier":"t_type$_t_contract$_GameTypes_$70870_$","typeString":"type(library GameTypes)"}},"id":55814,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"memberLocation":"23246:6:100","memberName":"CANNON","nodeType":"MemberAccess","referencedDeclaration":70773,"src":"23236:16:100","typeDescriptions":{"typeIdentifier":"t_userDefinedValueType$_GameType_$70720","typeString":"GameType"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_userDefinedValueType$_GameType_$70720","typeString":"GameType"}],"expression":{"arguments":[{"id":55810,"name":"_disputeGameFactoryProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55804,"src":"23200:24:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_address","typeString":"address"}],"id":55809,"name":"IFetcher","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":53958,"src":"23191:8:100","typeDescriptions":{"typeIdentifier":"t_type$_t_contract$_IFetcher_$53958_$","typeString":"type(contract IFetcher)"}},"id":55811,"isConstant":false,"isLValue":false,"isPure":false,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"23191:34:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_contract$_IFetcher_$53958","typeString":"contract IFetcher"}},"id":55812,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"23226:9:100","memberName":"gameImpls","nodeType":"MemberAccess","referencedDeclaration":53886,"src":"23191:44:100","typeDescriptions":{"typeIdentifier":"t_function_external_view$_t_userDefinedValueType$_GameType_$70720_$returns$_t_address_$","typeString":"function (GameType) view external returns (address)"}},"id":55815,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"23191:62:100","tryCall":true,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"id":55830,"nodeType":"TryStatement","src":"23187:201:100"}]},"implemented":true,"kind":"function","modifiers":[],"name":"_getFaultDisputeGame","nameLocation":"23090:20:100","parameters":{"id":55805,"nodeType":"ParameterList","parameters":[{"constant":false,"id":55804,"mutability":"mutable","name":"_disputeGameFactoryProxy","nameLocation":"23119:24:100","nodeType":"VariableDeclaration","scope":55832,"src":"23111:32:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":55803,"name":"address","nodeType":"ElementaryTypeName","src":"23111:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"23110:34:100"},"returnParameters":{"id":55808,"nodeType":"ParameterList","parameters":[{"constant":false,"id":55807,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":55832,"src":"23168:7:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":55806,"name":"address","nodeType":"ElementaryTypeName","src":"23168:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"23167:9:100"},"scope":56018,"stateMutability":"view","virtual":false,"visibility":"internal"},{"id":55864,"nodeType":"FunctionDefinition","src":"23400:376:100","nodes":[],"body":{"id":55863,"nodeType":"Block","src":"23566:210:100","nodes":[],"statements":[{"clauses":[{"block":{"id":55853,"nodeType":"Block","src":"23672:49:100","statements":[{"expression":{"id":55851,"name":"faultDisputeGame_","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55849,"src":"23693:17:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"functionReturnParameters":55841,"id":55852,"nodeType":"Return","src":"23686:24:100"}]},"errorName":"","id":55854,"nodeType":"TryCatchClause","parameters":{"id":55850,"nodeType":"ParameterList","parameters":[{"constant":false,"id":55849,"mutability":"mutable","name":"faultDisputeGame_","nameLocation":"23653:17:100","nodeType":"VariableDeclaration","scope":55854,"src":"23645:25:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":55848,"name":"address","nodeType":"ElementaryTypeName","src":"23645:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"23644:27:100"},"src":"23636:85:100"},{"block":{"id":55860,"nodeType":"Block","src":"23728:42:100","statements":[{"expression":{"arguments":[{"hexValue":"30","id":55857,"isConstant":false,"isLValue":false,"isPure":true,"kind":"number","lValueRequested":false,"nodeType":"Literal","src":"23757:1:100","typeDescriptions":{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"},"value":"0"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"}],"id":55856,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"nodeType":"ElementaryTypeNameExpression","src":"23749:7:100","typeDescriptions":{"typeIdentifier":"t_type$_t_address_$","typeString":"type(address)"},"typeName":{"id":55855,"name":"address","nodeType":"ElementaryTypeName","src":"23749:7:100","typeDescriptions":{}}},"id":55858,"isConstant":false,"isLValue":false,"isPure":true,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"23749:10:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"functionReturnParameters":55841,"id":55859,"nodeType":"Return","src":"23742:17:100"}]},"errorName":"","id":55861,"nodeType":"TryCatchClause","src":"23722:48:100"}],"externalCall":{"arguments":[{"id":55846,"name":"_gameType","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55837,"src":"23625:9:100","typeDescriptions":{"typeIdentifier":"t_userDefinedValueType$_GameType_$70720","typeString":"GameType"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_userDefinedValueType$_GameType_$70720","typeString":"GameType"}],"expression":{"arguments":[{"id":55843,"name":"_disputeGameFactoryProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55834,"src":"23589:24:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_address","typeString":"address"}],"id":55842,"name":"IFetcher","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":53958,"src":"23580:8:100","typeDescriptions":{"typeIdentifier":"t_type$_t_contract$_IFetcher_$53958_$","typeString":"type(contract IFetcher)"}},"id":55844,"isConstant":false,"isLValue":false,"isPure":false,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"23580:34:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_contract$_IFetcher_$53958","typeString":"contract IFetcher"}},"id":55845,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"23615:9:100","memberName":"gameImpls","nodeType":"MemberAccess","referencedDeclaration":53886,"src":"23580:44:100","typeDescriptions":{"typeIdentifier":"t_function_external_view$_t_userDefinedValueType$_GameType_$70720_$returns$_t_address_$","typeString":"function (GameType) view external returns (address)"}},"id":55847,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"23580:55:100","tryCall":true,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"id":55862,"nodeType":"TryStatement","src":"23576:194:100"}]},"implemented":true,"kind":"function","modifiers":[],"name":"_getFaultDisputeGame","nameLocation":"23409:20:100","parameters":{"id":55838,"nodeType":"ParameterList","parameters":[{"constant":false,"id":55834,"mutability":"mutable","name":"_disputeGameFactoryProxy","nameLocation":"23447:24:100","nodeType":"VariableDeclaration","scope":55864,"src":"23439:32:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":55833,"name":"address","nodeType":"ElementaryTypeName","src":"23439:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"},{"constant":false,"id":55837,"mutability":"mutable","name":"_gameType","nameLocation":"23490:9:100","nodeType":"VariableDeclaration","scope":55864,"src":"23481:18:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_userDefinedValueType$_GameType_$70720","typeString":"GameType"},"typeName":{"id":55836,"nodeType":"UserDefinedTypeName","pathNode":{"id":55835,"name":"GameType","nameLocations":["23481:8:100"],"nodeType":"IdentifierPath","referencedDeclaration":70720,"src":"23481:8:100"},"referencedDeclaration":70720,"src":"23481:8:100","typeDescriptions":{"typeIdentifier":"t_userDefinedValueType$_GameType_$70720","typeString":"GameType"}},"visibility":"internal"}],"src":"23429:76:100"},"returnParameters":{"id":55841,"nodeType":"ParameterList","parameters":[{"constant":false,"id":55840,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":55864,"src":"23553:7:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":55839,"name":"address","nodeType":"ElementaryTypeName","src":"23553:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"23552:9:100"},"scope":56018,"stateMutability":"view","virtual":false,"visibility":"internal"},{"id":55894,"nodeType":"FunctionDefinition","src":"23782:369:100","nodes":[],"body":{"id":55893,"nodeType":"Block","src":"23885:266:100","nodes":[],"statements":[{"clauses":[{"block":{"id":55883,"nodeType":"Block","src":"24040:56:100","statements":[{"expression":{"id":55881,"name":"permissionedDisputeGame_","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55879,"src":"24061:24:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"functionReturnParameters":55870,"id":55882,"nodeType":"Return","src":"24054:31:100"}]},"errorName":"","id":55884,"nodeType":"TryCatchClause","parameters":{"id":55880,"nodeType":"ParameterList","parameters":[{"constant":false,"id":55879,"mutability":"mutable","name":"permissionedDisputeGame_","nameLocation":"24005:24:100","nodeType":"VariableDeclaration","scope":55884,"src":"23997:32:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":55878,"name":"address","nodeType":"ElementaryTypeName","src":"23997:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"23983:56:100"},"src":"23975:121:100"},{"block":{"id":55890,"nodeType":"Block","src":"24103:42:100","statements":[{"expression":{"arguments":[{"hexValue":"30","id":55887,"isConstant":false,"isLValue":false,"isPure":true,"kind":"number","lValueRequested":false,"nodeType":"Literal","src":"24132:1:100","typeDescriptions":{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"},"value":"0"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"}],"id":55886,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"nodeType":"ElementaryTypeNameExpression","src":"24124:7:100","typeDescriptions":{"typeIdentifier":"t_type$_t_address_$","typeString":"type(address)"},"typeName":{"id":55885,"name":"address","nodeType":"ElementaryTypeName","src":"24124:7:100","typeDescriptions":{}}},"id":55888,"isConstant":false,"isLValue":false,"isPure":true,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"24124:10:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"functionReturnParameters":55870,"id":55889,"nodeType":"Return","src":"24117:17:100"}]},"errorName":"","id":55891,"nodeType":"TryCatchClause","src":"24097:48:100"}],"externalCall":{"arguments":[{"expression":{"id":55875,"name":"GameTypes","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":70870,"src":"23944:9:100","typeDescriptions":{"typeIdentifier":"t_type$_t_contract$_GameTypes_$70870_$","typeString":"type(library GameTypes)"}},"id":55876,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"memberLocation":"23954:19:100","memberName":"PERMISSIONED_CANNON","nodeType":"MemberAccess","referencedDeclaration":70781,"src":"23944:29:100","typeDescriptions":{"typeIdentifier":"t_userDefinedValueType$_GameType_$70720","typeString":"GameType"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_userDefinedValueType$_GameType_$70720","typeString":"GameType"}],"expression":{"arguments":[{"id":55872,"name":"_disputeGameFactoryProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55866,"src":"23908:24:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_address","typeString":"address"}],"id":55871,"name":"IFetcher","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":53958,"src":"23899:8:100","typeDescriptions":{"typeIdentifier":"t_type$_t_contract$_IFetcher_$53958_$","typeString":"type(contract IFetcher)"}},"id":55873,"isConstant":false,"isLValue":false,"isPure":false,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"23899:34:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_contract$_IFetcher_$53958","typeString":"contract IFetcher"}},"id":55874,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"23934:9:100","memberName":"gameImpls","nodeType":"MemberAccess","referencedDeclaration":53886,"src":"23899:44:100","typeDescriptions":{"typeIdentifier":"t_function_external_view$_t_userDefinedValueType$_GameType_$70720_$returns$_t_address_$","typeString":"function (GameType) view external returns (address)"}},"id":55877,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"23899:75:100","tryCall":true,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"id":55892,"nodeType":"TryStatement","src":"23895:250:100"}]},"implemented":true,"kind":"function","modifiers":[],"name":"_getPermissionedDisputeGame","nameLocation":"23791:27:100","parameters":{"id":55867,"nodeType":"ParameterList","parameters":[{"constant":false,"id":55866,"mutability":"mutable","name":"_disputeGameFactoryProxy","nameLocation":"23827:24:100","nodeType":"VariableDeclaration","scope":55894,"src":"23819:32:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":55865,"name":"address","nodeType":"ElementaryTypeName","src":"23819:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"23818:34:100"},"returnParameters":{"id":55870,"nodeType":"ParameterList","parameters":[{"constant":false,"id":55869,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":55894,"src":"23876:7:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":55868,"name":"address","nodeType":"ElementaryTypeName","src":"23876:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"23875:9:100"},"scope":56018,"stateMutability":"view","virtual":false,"visibility":"internal"},{"id":55922,"nodeType":"FunctionDefinition","src":"24157:277:100","nodes":[],"body":{"id":55921,"nodeType":"Block","src":"24248:186:100","nodes":[],"statements":[{"clauses":[{"block":{"id":55911,"nodeType":"Block","src":"24336:43:100","statements":[{"expression":{"id":55909,"name":"ethLockbox_","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55907,"src":"24357:11:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"functionReturnParameters":55900,"id":55910,"nodeType":"Return","src":"24350:18:100"}]},"errorName":"","id":55912,"nodeType":"TryCatchClause","parameters":{"id":55908,"nodeType":"ParameterList","parameters":[{"constant":false,"id":55907,"mutability":"mutable","name":"ethLockbox_","nameLocation":"24323:11:100","nodeType":"VariableDeclaration","scope":55912,"src":"24315:19:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":55906,"name":"address","nodeType":"ElementaryTypeName","src":"24315:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"24314:21:100"},"src":"24306:73:100"},{"block":{"id":55918,"nodeType":"Block","src":"24386:42:100","statements":[{"expression":{"arguments":[{"hexValue":"30","id":55915,"isConstant":false,"isLValue":false,"isPure":true,"kind":"number","lValueRequested":false,"nodeType":"Literal","src":"24415:1:100","typeDescriptions":{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"},"value":"0"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"}],"id":55914,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"nodeType":"ElementaryTypeNameExpression","src":"24407:7:100","typeDescriptions":{"typeIdentifier":"t_type$_t_address_$","typeString":"type(address)"},"typeName":{"id":55913,"name":"address","nodeType":"ElementaryTypeName","src":"24407:7:100","typeDescriptions":{}}},"id":55916,"isConstant":false,"isLValue":false,"isPure":true,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"24407:10:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"functionReturnParameters":55900,"id":55917,"nodeType":"Return","src":"24400:17:100"}]},"errorName":"","id":55919,"nodeType":"TryCatchClause","src":"24380:48:100"}],"externalCall":{"arguments":[],"expression":{"argumentTypes":[],"expression":{"arguments":[{"id":55902,"name":"_optimismPortalProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55896,"src":"24271:20:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_address","typeString":"address"}],"id":55901,"name":"IFetcher","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":53958,"src":"24262:8:100","typeDescriptions":{"typeIdentifier":"t_type$_t_contract$_IFetcher_$53958_$","typeString":"type(contract IFetcher)"}},"id":55903,"isConstant":false,"isLValue":false,"isPure":false,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"24262:30:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_contract$_IFetcher_$53958","typeString":"contract IFetcher"}},"id":55904,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"24293:10:100","memberName":"ethLockbox","nodeType":"MemberAccess","referencedDeclaration":53843,"src":"24262:41:100","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":55905,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"24262:43:100","tryCall":true,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"id":55920,"nodeType":"TryStatement","src":"24258:170:100"}]},"implemented":true,"kind":"function","modifiers":[],"name":"_getEthLockboxProxy","nameLocation":"24166:19:100","parameters":{"id":55897,"nodeType":"ParameterList","parameters":[{"constant":false,"id":55896,"mutability":"mutable","name":"_optimismPortalProxy","nameLocation":"24194:20:100","nodeType":"VariableDeclaration","scope":55922,"src":"24186:28:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":55895,"name":"address","nodeType":"ElementaryTypeName","src":"24186:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"24185:30:100"},"returnParameters":{"id":55900,"nodeType":"ParameterList","parameters":[{"constant":false,"id":55899,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":55922,"src":"24239:7:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":55898,"name":"address","nodeType":"ElementaryTypeName","src":"24239:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"24238:9:100"},"scope":56018,"stateMutability":"view","virtual":false,"visibility":"internal"},{"id":55967,"nodeType":"FunctionDefinition","src":"24440:304:100","nodes":[],"body":{"id":55966,"nodeType":"Block","src":"24524:220:100","nodes":[],"statements":[{"assignments":[55930,55932],"declarations":[{"constant":false,"id":55930,"mutability":"mutable","name":"ok","nameLocation":"24540:2:100","nodeType":"VariableDeclaration","scope":55966,"src":"24535:7:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"},"typeName":{"id":55929,"name":"bool","nodeType":"ElementaryTypeName","src":"24535:4:100","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},"visibility":"internal"},{"constant":false,"id":55932,"mutability":"mutable","name":"data","nameLocation":"24557:4:100","nodeType":"VariableDeclaration","scope":55966,"src":"24544:17:100","stateVariable":false,"storageLocation":"memory","typeDescriptions":{"typeIdentifier":"t_bytes_memory_ptr","typeString":"bytes"},"typeName":{"id":55931,"name":"bytes","nodeType":"ElementaryTypeName","src":"24544:5:100","typeDescriptions":{"typeIdentifier":"t_bytes_storage_ptr","typeString":"bytes"}},"visibility":"internal"}],"id":55945,"initialValue":{"arguments":[{"arguments":[{"expression":{"id":55940,"name":"IFetcher","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":53958,"src":"24613:8:100","typeDescriptions":{"typeIdentifier":"t_type$_t_contract$_IFetcher_$53958_$","typeString":"type(contract IFetcher)"}},"id":55941,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"memberLocation":"24622:4:100","memberName":"weth","nodeType":"MemberAccess","referencedDeclaration":53957,"src":"24613:13:100","typeDescriptions":{"typeIdentifier":"t_function_declaration_view$__$returns$_t_address_$","typeString":"function IFetcher.weth() view returns (address)"}},{"components":[],"id":55942,"isConstant":false,"isInlineArray":false,"isLValue":false,"isPure":true,"lValueRequested":false,"nodeType":"TupleExpression","src":"24628:2:100","typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_function_declaration_view$__$returns$_t_address_$","typeString":"function IFetcher.weth() view returns (address)"},{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}],"expression":{"id":55938,"name":"abi","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":-1,"src":"24598:3:100","typeDescriptions":{"typeIdentifier":"t_magic_abi","typeString":"abi"}},"id":55939,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"memberLocation":"24602:10:100","memberName":"encodeCall","nodeType":"MemberAccess","src":"24598:14:100","typeDescriptions":{"typeIdentifier":"t_function_abiencodecall_pure$__$returns$_t_bytes_memory_ptr_$","typeString":"function () pure returns (bytes memory)"}},"id":55943,"isConstant":false,"isLValue":false,"isPure":true,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"24598:33:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_bytes_memory_ptr","typeString":"bytes memory"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_bytes_memory_ptr","typeString":"bytes memory"}],"expression":{"arguments":[{"id":55935,"name":"_disputeGame","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55924,"src":"24573:12:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_address","typeString":"address"}],"id":55934,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"nodeType":"ElementaryTypeNameExpression","src":"24565:7:100","typeDescriptions":{"typeIdentifier":"t_type$_t_address_$","typeString":"type(address)"},"typeName":{"id":55933,"name":"address","nodeType":"ElementaryTypeName","src":"24565:7:100","typeDescriptions":{}}},"id":55936,"isConstant":false,"isLValue":false,"isPure":false,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"24565:21:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"id":55937,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"24587:10:100","memberName":"staticcall","nodeType":"MemberAccess","src":"24565:32:100","typeDescriptions":{"typeIdentifier":"t_function_barestaticcall_view$_t_bytes_memory_ptr_$returns$_t_bool_$_t_bytes_memory_ptr_$","typeString":"function (bytes memory) view returns (bool,bytes memory)"}},"id":55944,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"24565:67:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$_t_bool_$_t_bytes_memory_ptr_$","typeString":"tuple(bool,bytes memory)"}},"nodeType":"VariableDeclarationStatement","src":"24534:98:100"},{"condition":{"commonType":{"typeIdentifier":"t_bool","typeString":"bool"},"id":55951,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftExpression":{"id":55946,"name":"ok","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55930,"src":"24646:2:100","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},"nodeType":"BinaryOperation","operator":"&&","rightExpression":{"commonType":{"typeIdentifier":"t_uint256","typeString":"uint256"},"id":55950,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftExpression":{"expression":{"id":55947,"name":"data","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55932,"src":"24652:4:100","typeDescriptions":{"typeIdentifier":"t_bytes_memory_ptr","typeString":"bytes memory"}},"id":55948,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"24657:6:100","memberName":"length","nodeType":"MemberAccess","src":"24652:11:100","typeDescriptions":{"typeIdentifier":"t_uint256","typeString":"uint256"}},"nodeType":"BinaryOperation","operator":"==","rightExpression":{"hexValue":"3332","id":55949,"isConstant":false,"isLValue":false,"isPure":true,"kind":"number","lValueRequested":false,"nodeType":"Literal","src":"24667:2:100","typeDescriptions":{"typeIdentifier":"t_rational_32_by_1","typeString":"int_const 32"},"value":"32"},"src":"24652:17:100","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},"src":"24646:23:100","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},"falseBody":{"expression":{"arguments":[{"hexValue":"30","id":55962,"isConstant":false,"isLValue":false,"isPure":true,"kind":"number","lValueRequested":false,"nodeType":"Literal","src":"24735:1:100","typeDescriptions":{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"},"value":"0"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"}],"id":55961,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"nodeType":"ElementaryTypeNameExpression","src":"24727:7:100","typeDescriptions":{"typeIdentifier":"t_type$_t_address_$","typeString":"type(address)"},"typeName":{"id":55960,"name":"address","nodeType":"ElementaryTypeName","src":"24727:7:100","typeDescriptions":{}}},"id":55963,"isConstant":false,"isLValue":false,"isPure":true,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"24727:10:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"functionReturnParameters":55928,"id":55964,"nodeType":"Return","src":"24720:17:100"},"id":55965,"nodeType":"IfStatement","src":"24642:95:100","trueBody":{"expression":{"arguments":[{"id":55954,"name":"data","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55932,"src":"24689:4:100","typeDescriptions":{"typeIdentifier":"t_bytes_memory_ptr","typeString":"bytes memory"}},{"components":[{"id":55956,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"nodeType":"ElementaryTypeNameExpression","src":"24696:7:100","typeDescriptions":{"typeIdentifier":"t_type$_t_address_$","typeString":"type(address)"},"typeName":{"id":55955,"name":"address","nodeType":"ElementaryTypeName","src":"24696:7:100","typeDescriptions":{}}}],"id":55957,"isConstant":false,"isInlineArray":false,"isLValue":false,"isPure":true,"lValueRequested":false,"nodeType":"TupleExpression","src":"24695:9:100","typeDescriptions":{"typeIdentifier":"t_type$_t_address_$","typeString":"type(address)"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_bytes_memory_ptr","typeString":"bytes memory"},{"typeIdentifier":"t_type$_t_address_$","typeString":"type(address)"}],"expression":{"id":55952,"name":"abi","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":-1,"src":"24678:3:100","typeDescriptions":{"typeIdentifier":"t_magic_abi","typeString":"abi"}},"id":55953,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"memberLocation":"24682:6:100","memberName":"decode","nodeType":"MemberAccess","src":"24678:10:100","typeDescriptions":{"typeIdentifier":"t_function_abidecode_pure$__$returns$__$","typeString":"function () pure"}},"id":55958,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"24678:27:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address_payable","typeString":"address payable"}},"functionReturnParameters":55928,"id":55959,"nodeType":"Return","src":"24671:34:100"}}]},"implemented":true,"kind":"function","modifiers":[],"name":"_getDelayedWETHProxy","nameLocation":"24449:20:100","parameters":{"id":55925,"nodeType":"ParameterList","parameters":[{"constant":false,"id":55924,"mutability":"mutable","name":"_disputeGame","nameLocation":"24478:12:100","nodeType":"VariableDeclaration","scope":55967,"src":"24470:20:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":55923,"name":"address","nodeType":"ElementaryTypeName","src":"24470:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"24469:22:100"},"returnParameters":{"id":55928,"nodeType":"ParameterList","parameters":[{"constant":false,"id":55927,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":55967,"src":"24515:7:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":55926,"name":"address","nodeType":"ElementaryTypeName","src":"24515:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"24514:9:100"},"scope":56018,"stateMutability":"view","virtual":false,"visibility":"internal"},{"id":55994,"nodeType":"FunctionDefinition","src":"24750:224:100","nodes":[],"body":{"id":55993,"nodeType":"Block","src":"24838:136:100","nodes":[],"statements":[{"assignments":[55975],"declarations":[{"constant":false,"id":55975,"mutability":"mutable","name":"batcherHash","nameLocation":"24856:11:100","nodeType":"VariableDeclaration","scope":55993,"src":"24848:19:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_bytes32","typeString":"bytes32"},"typeName":{"id":55974,"name":"bytes32","nodeType":"ElementaryTypeName","src":"24848:7:100","typeDescriptions":{"typeIdentifier":"t_bytes32","typeString":"bytes32"}},"visibility":"internal"}],"id":55981,"initialValue":{"arguments":[],"expression":{"argumentTypes":[],"expression":{"arguments":[{"id":55977,"name":"_systemConfigProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55969,"src":"24879:18:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_address","typeString":"address"}],"id":55976,"name":"IFetcher","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":53958,"src":"24870:8:100","typeDescriptions":{"typeIdentifier":"t_type$_t_contract$_IFetcher_$53958_$","typeString":"type(contract IFetcher)"}},"id":55978,"isConstant":false,"isLValue":false,"isPure":false,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"24870:28:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_contract$_IFetcher_$53958","typeString":"contract IFetcher"}},"id":55979,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"24899:11:100","memberName":"batcherHash","nodeType":"MemberAccess","referencedDeclaration":53937,"src":"24870:40:100","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_bytes32_$","typeString":"function () view external returns (bytes32)"}},"id":55980,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"24870:42:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_bytes32","typeString":"bytes32"}},"nodeType":"VariableDeclarationStatement","src":"24848:64:100"},{"expression":{"arguments":[{"arguments":[{"arguments":[{"id":55988,"name":"batcherHash","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55975,"src":"24953:11:100","typeDescriptions":{"typeIdentifier":"t_bytes32","typeString":"bytes32"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_bytes32","typeString":"bytes32"}],"id":55987,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"nodeType":"ElementaryTypeNameExpression","src":"24945:7:100","typeDescriptions":{"typeIdentifier":"t_type$_t_uint256_$","typeString":"type(uint256)"},"typeName":{"id":55986,"name":"uint256","nodeType":"ElementaryTypeName","src":"24945:7:100","typeDescriptions":{}}},"id":55989,"isConstant":false,"isLValue":false,"isPure":false,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"24945:20:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_uint256","typeString":"uint256"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_uint256","typeString":"uint256"}],"id":55985,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"nodeType":"ElementaryTypeNameExpression","src":"24937:7:100","typeDescriptions":{"typeIdentifier":"t_type$_t_uint160_$","typeString":"type(uint160)"},"typeName":{"id":55984,"name":"uint160","nodeType":"ElementaryTypeName","src":"24937:7:100","typeDescriptions":{}}},"id":55990,"isConstant":false,"isLValue":false,"isPure":false,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"24937:29:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_uint160","typeString":"uint160"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_uint160","typeString":"uint160"}],"id":55983,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"nodeType":"ElementaryTypeNameExpression","src":"24929:7:100","typeDescriptions":{"typeIdentifier":"t_type$_t_address_$","typeString":"type(address)"},"typeName":{"id":55982,"name":"address","nodeType":"ElementaryTypeName","src":"24929:7:100","typeDescriptions":{}}},"id":55991,"isConstant":false,"isLValue":false,"isPure":false,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"24929:38:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"functionReturnParameters":55973,"id":55992,"nodeType":"Return","src":"24922:45:100"}]},"implemented":true,"kind":"function","modifiers":[],"name":"_getBatchSubmitter","nameLocation":"24759:18:100","parameters":{"id":55970,"nodeType":"ParameterList","parameters":[{"constant":false,"id":55969,"mutability":"mutable","name":"_systemConfigProxy","nameLocation":"24786:18:100","nodeType":"VariableDeclaration","scope":55994,"src":"24778:26:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":55968,"name":"address","nodeType":"ElementaryTypeName","src":"24778:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"24777:28:100"},"returnParameters":{"id":55973,"nodeType":"ParameterList","parameters":[{"constant":false,"id":55972,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":55994,"src":"24829:7:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":55971,"name":"address","nodeType":"ElementaryTypeName","src":"24829:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"24828:9:100"},"scope":56018,"stateMutability":"view","virtual":false,"visibility":"internal"},{"id":56017,"nodeType":"FunctionDefinition","src":"24980:169:100","nodes":[],"body":{"id":56016,"nodeType":"Block","src":"25059:90:100","nodes":[],"statements":[{"expression":{"arguments":[{"arguments":[{"hexValue":"30","id":56006,"isConstant":false,"isLValue":false,"isPure":true,"kind":"number","lValueRequested":false,"nodeType":"Literal","src":"25086:1:100","typeDescriptions":{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"},"value":"0"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"}],"id":56005,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"nodeType":"ElementaryTypeNameExpression","src":"25078:7:100","typeDescriptions":{"typeIdentifier":"t_type$_t_address_$","typeString":"type(address)"},"typeName":{"id":56004,"name":"address","nodeType":"ElementaryTypeName","src":"25078:7:100","typeDescriptions":{}}},"id":56007,"isConstant":false,"isLValue":false,"isPure":true,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"25078:10:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_address","typeString":"address"}],"expression":{"id":56001,"name":"vm","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":5501,"src":"25069:2:100","typeDescriptions":{"typeIdentifier":"t_contract$_Vm_$23288","typeString":"contract Vm"}},"id":56003,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"25072:5:100","memberName":"prank","nodeType":"MemberAccess","referencedDeclaration":22581,"src":"25069:8:100","typeDescriptions":{"typeIdentifier":"t_function_external_nonpayable$_t_address_$returns$__$","typeString":"function (address) external"}},"id":56008,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"25069:20:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":56009,"nodeType":"ExpressionStatement","src":"25069:20:100"},{"expression":{"arguments":[],"expression":{"argumentTypes":[],"expression":{"arguments":[{"id":56011,"name":"_systemConfigProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55996,"src":"25115:18:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_address","typeString":"address"}],"id":56010,"name":"IFetcher","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":53958,"src":"25106:8:100","typeDescriptions":{"typeIdentifier":"t_type$_t_contract$_IFetcher_$53958_$","typeString":"type(contract IFetcher)"}},"id":56012,"isConstant":false,"isLValue":false,"isPure":false,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"25106:28:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_contract$_IFetcher_$53958","typeString":"contract IFetcher"}},"id":56013,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"25135:5:100","memberName":"admin","nodeType":"MemberAccess","referencedDeclaration":53942,"src":"25106:34:100","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":56014,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"25106:36:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"functionReturnParameters":56000,"id":56015,"nodeType":"Return","src":"25099:43:100"}]},"implemented":true,"kind":"function","modifiers":[],"name":"_getProxyAdmin","nameLocation":"24989:14:100","parameters":{"id":55997,"nodeType":"ParameterList","parameters":[{"constant":false,"id":55996,"mutability":"mutable","name":"_systemConfigProxy","nameLocation":"25012:18:100","nodeType":"VariableDeclaration","scope":56017,"src":"25004:26:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":55995,"name":"address","nodeType":"ElementaryTypeName","src":"25004:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"25003:28:100"},"returnParameters":{"id":56000,"nodeType":"ParameterList","parameters":[{"constant":false,"id":55999,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":56017,"src":"25050:7:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":55998,"name":"address","nodeType":"ElementaryTypeName","src":"25050:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"25049:9:100"},"scope":56018,"stateMutability":"nonpayable","virtual":false,"visibility":"internal"}],"abstract":false,"baseContracts":[{"baseName":{"id":54912,"name":"Script","nameLocations":["13628:6:100"],"nodeType":"IdentifierPath","referencedDeclaration":5558,"src":"13628:6:100"},"id":54913,"nodeType":"InheritanceSpecifier","src":"13628:6:100"}],"canonicalName":"FetchChainInfo","contractDependencies":[],"contractKind":"contract","fullyImplemented":true,"linearizedBaseContracts":[56018,5558,18381,11222,9132,5517,5505],"name":"FetchChainInfo","nameLocation":"13610:14:100","scope":56019,"usedErrors":[],"usedEvents":[]}],"license":"MIT"},"id":100} \ No newline at end of file diff --git a/op-fetcher/pkg/fetcher/fetch/forge-artifacts/FetchChainInfo.s.sol/FetchChainInfoInput.json b/op-fetcher/pkg/fetcher/fetch/forge-artifacts/FetchChainInfo.s.sol/FetchChainInfoInput.json index 5f8756409e0..334f7ff5a81 100644 --- a/op-fetcher/pkg/fetcher/fetch/forge-artifacts/FetchChainInfo.s.sol/FetchChainInfoInput.json +++ b/op-fetcher/pkg/fetcher/fetch/forge-artifacts/FetchChainInfo.s.sol/FetchChainInfoInput.json @@ -1 +1 @@ -{"abi":[{"type":"function","name":"l1StandardBridgeProxy","inputs":[],"outputs":[{"name":"","type":"address","internalType":"address"}],"stateMutability":"view"},{"type":"function","name":"set","inputs":[{"name":"_sel","type":"bytes4","internalType":"bytes4"},{"name":"_addr","type":"address","internalType":"address"}],"outputs":[],"stateMutability":"nonpayable"},{"type":"function","name":"systemConfigProxy","inputs":[],"outputs":[{"name":"","type":"address","internalType":"address"}],"stateMutability":"view"}],"bytecode":{"object":"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","sourceMap":"2021:934:120:-:0;;;;;;;;;;;;;;;;;;;","linkReferences":{}},"deployedBytecode":{"object":"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","sourceMap":"2021:934:120:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2735:218;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;2527:202;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;2143:378;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;2735:218;2789:7;2850:1;2816:36;;:22;;;;;;;;;;;:36;;;2808:99;;;;;;;;;;;;:::i;:::-;;;;;;;;;2924:22;;;;;;;;;;;2917:29;;2735:218;:::o;2527:202::-;2577:7;2634:1;2604:32;;:18;;;;;;;;;;:32;;;2596:91;;;;;;;;;;;;:::i;:::-;;;;;;;;;2704:18;;;;;;;;;;2697:25;;2527:202;:::o;2143:378::-;2226:1;2209:19;;:5;:19;;;2201:76;;;;;;;;;;;;:::i;:::-;;;;;;;;;2299:31;;;2291:39;;;:4;:39;;;;2287:227;;2353:5;2332:18;;:26;;;;;;;;;;;;;;;;;;2287:227;;;2385:35;;;2377:43;;;:4;:43;;;;2373:141;;2447:5;2422:22;;:30;;;;;;;;;;;;;;;;;;2373:141;;;2467:47;;;;;;;;;;:::i;:::-;;;;;;;;2373:141;2287:227;2143:378;;:::o;7:126:207:-;44:7;84:42;77:5;73:54;62:65;;7:126;;;:::o;139:96::-;176:7;205:24;223:5;205:24;:::i;:::-;194:35;;139:96;;;:::o;241:118::-;328:24;346:5;328:24;:::i;:::-;323:3;316:37;241:118;;:::o;365:222::-;458:4;496:2;485:9;481:18;473:26;;509:71;577:1;566:9;562:17;553:6;509:71;:::i;:::-;365:222;;;;:::o;674:117::-;783:1;780;773:12;920:149;956:7;996:66;989:5;985:78;974:89;;920:149;;;:::o;1075:120::-;1147:23;1164:5;1147:23;:::i;:::-;1140:5;1137:34;1127:62;;1185:1;1182;1175:12;1127:62;1075:120;:::o;1201:137::-;1246:5;1284:6;1271:20;1262:29;;1300:32;1326:5;1300:32;:::i;:::-;1201:137;;;;:::o;1344:122::-;1417:24;1435:5;1417:24;:::i;:::-;1410:5;1407:35;1397:63;;1456:1;1453;1446:12;1397:63;1344:122;:::o;1472:139::-;1518:5;1556:6;1543:20;1534:29;;1572:33;1599:5;1572:33;:::i;:::-;1472:139;;;;:::o;1617:472::-;1684:6;1692;1741:2;1729:9;1720:7;1716:23;1712:32;1709:119;;;1747:79;;:::i;:::-;1709:119;1867:1;1892:52;1936:7;1927:6;1916:9;1912:22;1892:52;:::i;:::-;1882:62;;1838:116;1993:2;2019:53;2064:7;2055:6;2044:9;2040:22;2019:53;:::i;:::-;2009:63;;1964:118;1617:472;;;;;:::o;2095:169::-;2179:11;2213:6;2208:3;2201:19;2253:4;2248:3;2244:14;2229:29;;2095:169;;;;:::o;2270:237::-;2410:34;2406:1;2398:6;2394:14;2387:58;2479:20;2474:2;2466:6;2462:15;2455:45;2270:237;:::o;2513:366::-;2655:3;2676:67;2740:2;2735:3;2676:67;:::i;:::-;2669:74;;2752:93;2841:3;2752:93;:::i;:::-;2870:2;2865:3;2861:12;2854:19;;2513:366;;;:::o;2885:419::-;3051:4;3089:2;3078:9;3074:18;3066:26;;3138:9;3132:4;3128:20;3124:1;3113:9;3109:17;3102:47;3166:131;3292:4;3166:131;:::i;:::-;3158:139;;2885:419;;;:::o;3310:233::-;3450:34;3446:1;3438:6;3434:14;3427:58;3519:16;3514:2;3506:6;3502:15;3495:41;3310:233;:::o;3549:366::-;3691:3;3712:67;3776:2;3771:3;3712:67;:::i;:::-;3705:74;;3788:93;3877:3;3788:93;:::i;:::-;3906:2;3901:3;3897:12;3890:19;;3549:366;;;:::o;3921:419::-;4087:4;4125:2;4114:9;4110:18;4102:26;;4174:9;4168:4;4164:20;4160:1;4149:9;4145:17;4138:47;4202:131;4328:4;4202:131;:::i;:::-;4194:139;;3921:419;;;:::o;4346:231::-;4486:34;4482:1;4474:6;4470:14;4463:58;4555:14;4550:2;4542:6;4538:15;4531:39;4346:231;:::o;4583:366::-;4725:3;4746:67;4810:2;4805:3;4746:67;:::i;:::-;4739:74;;4822:93;4911:3;4822:93;:::i;:::-;4940:2;4935:3;4931:12;4924:19;;4583:366;;;:::o;4955:419::-;5121:4;5159:2;5148:9;5144:18;5136:26;;5208:9;5202:4;5198:20;5194:1;5183:9;5179:17;5172:47;5236:131;5362:4;5236:131;:::i;:::-;5228:139;;4955:419;;;:::o;5380:224::-;5520:34;5516:1;5508:6;5504:14;5497:58;5589:7;5584:2;5576:6;5572:15;5565:32;5380:224;:::o;5610:366::-;5752:3;5773:67;5837:2;5832:3;5773:67;:::i;:::-;5766:74;;5849:93;5938:3;5849:93;:::i;:::-;5967:2;5962:3;5958:12;5951:19;;5610:366;;;:::o;5982:419::-;6148:4;6186:2;6175:9;6171:18;6163:26;;6235:9;6229:4;6225:20;6221:1;6210:9;6206:17;6199:47;6263:131;6389:4;6263:131;:::i;:::-;6255:139;;5982:419;;;:::o","linkReferences":{}},"methodIdentifiers":{"l1StandardBridgeProxy()":"102b6069","set(bytes4,address)":"c3e39250","systemConfigProxy()":"c17db6e3"},"rawMetadata":"{\"compiler\":{\"version\":\"0.8.25+commit.b61c2a91\"},\"language\":\"Solidity\",\"output\":{\"abi\":[{\"inputs\":[],\"name\":\"l1StandardBridgeProxy\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes4\",\"name\":\"_sel\",\"type\":\"bytes4\"},{\"internalType\":\"address\",\"name\":\"_addr\",\"type\":\"address\"}],\"name\":\"set\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"systemConfigProxy\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"}],\"devdoc\":{\"kind\":\"dev\",\"methods\":{},\"version\":1},\"userdoc\":{\"kind\":\"user\",\"methods\":{},\"version\":1}},\"settings\":{\"compilationTarget\":{\"scripts/FetchChainInfo.s.sol\":\"FetchChainInfoInput\"},\"evmVersion\":\"cancun\",\"libraries\":{},\"metadata\":{\"bytecodeHash\":\"none\",\"useLiteralContent\":true},\"optimizer\":{\"enabled\":false,\"runs\":999999},\"remappings\":[\":@lib-keccak/=lib/lib-keccak/contracts/lib/\",\":@openzeppelin/contracts-upgradeable/=lib/openzeppelin-contracts-upgradeable/contracts/\",\":@openzeppelin/contracts-v5/=lib/openzeppelin-contracts-v5/contracts/\",\":@openzeppelin/contracts/=lib/openzeppelin-contracts/contracts/\",\":@rari-capital/solmate/=lib/solmate/\",\":@solady-test/=lib/lib-keccak/lib/solady/test/\",\":@solady-v0.0.245/=lib/solady-v0.0.245/src/\",\":@solady/=lib/solady/src/\",\":ds-test/=lib/forge-std/lib/ds-test/src/\",\":erc4626-tests/=lib/openzeppelin-contracts-v5/lib/erc4626-tests/\",\":forge-std/=lib/forge-std/src/\",\":interfaces/=interfaces/\",\":kontrol-cheatcodes/=lib/kontrol-cheatcodes/src/\",\":lib-keccak/=lib/lib-keccak/contracts/\",\":openzeppelin-contracts-upgradeable/=lib/openzeppelin-contracts-upgradeable/\",\":openzeppelin-contracts-v5/=lib/openzeppelin-contracts-v5/\",\":openzeppelin-contracts/=lib/openzeppelin-contracts/\",\":safe-contracts/=lib/safe-contracts/contracts/\",\":solady-v0.0.245/=lib/solady-v0.0.245/src/\",\":solady/=lib/solady/\",\":solmate/=lib/solmate/src/\"]},\"sources\":{\"lib/forge-std/src/Base.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity >=0.6.2 <0.9.0;\\n\\nimport {StdStorage} from \\\"./StdStorage.sol\\\";\\nimport {Vm, VmSafe} from \\\"./Vm.sol\\\";\\n\\nabstract contract CommonBase {\\n /// @dev Cheat code address.\\n /// Calculated as `address(uint160(uint256(keccak256(\\\"hevm cheat code\\\"))))`.\\n address internal constant VM_ADDRESS = 0x7109709ECfa91a80626fF3989D68f67F5b1DD12D;\\n /// @dev console.sol and console2.sol work by executing a staticcall to this address.\\n /// Calculated as `address(uint160(uint88(bytes11(\\\"console.log\\\"))))`.\\n address internal constant CONSOLE = 0x000000000000000000636F6e736F6c652e6c6f67;\\n /// @dev Used when deploying with create2.\\n /// Taken from https://github.com/Arachnid/deterministic-deployment-proxy.\\n address internal constant CREATE2_FACTORY = 0x4e59b44847b379578588920cA78FbF26c0B4956C;\\n /// @dev The default address for tx.origin and msg.sender.\\n /// Calculated as `address(uint160(uint256(keccak256(\\\"foundry default caller\\\"))))`.\\n address internal constant DEFAULT_SENDER = 0x1804c8AB1F12E6bbf3894d4083f33e07309d1f38;\\n /// @dev The address of the first contract `CREATE`d by a running test contract.\\n /// When running tests, each test contract is `CREATE`d by `DEFAULT_SENDER` with nonce 1.\\n /// Calculated as `VM.computeCreateAddress(VM.computeCreateAddress(DEFAULT_SENDER, 1), 1)`.\\n address internal constant DEFAULT_TEST_CONTRACT = 0x5615dEB798BB3E4dFa0139dFa1b3D433Cc23b72f;\\n /// @dev Deterministic deployment address of the Multicall3 contract.\\n /// Taken from https://www.multicall3.com.\\n address internal constant MULTICALL3_ADDRESS = 0xcA11bde05977b3631167028862bE2a173976CA11;\\n /// @dev The order of the secp256k1 curve.\\n uint256 internal constant SECP256K1_ORDER =\\n 115792089237316195423570985008687907852837564279074904382605163141518161494337;\\n\\n uint256 internal constant UINT256_MAX =\\n 115792089237316195423570985008687907853269984665640564039457584007913129639935;\\n\\n Vm internal constant vm = Vm(VM_ADDRESS);\\n StdStorage internal stdstore;\\n}\\n\\nabstract contract TestBase is CommonBase {}\\n\\nabstract contract ScriptBase is CommonBase {\\n VmSafe internal constant vmSafe = VmSafe(VM_ADDRESS);\\n}\\n\",\"keccak256\":\"0xa3735a6618a3014e42bb4329ad143e3b2c59cd95094350202e4c4a06c9d585dd\",\"license\":\"MIT\"},\"lib/forge-std/src/Script.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity >=0.6.2 <0.9.0;\\n\\n// \\ud83d\\udcac ABOUT\\n// Forge Std's default Script.\\n\\n// \\ud83e\\udde9 MODULES\\nimport {console} from \\\"./console.sol\\\";\\nimport {console2} from \\\"./console2.sol\\\";\\nimport {safeconsole} from \\\"./safeconsole.sol\\\";\\nimport {StdChains} from \\\"./StdChains.sol\\\";\\nimport {StdCheatsSafe} from \\\"./StdCheats.sol\\\";\\nimport {StdConstants} from \\\"./StdConstants.sol\\\";\\nimport {stdJson} from \\\"./StdJson.sol\\\";\\nimport {stdMath} from \\\"./StdMath.sol\\\";\\nimport {StdStorage, stdStorageSafe} from \\\"./StdStorage.sol\\\";\\nimport {StdStyle} from \\\"./StdStyle.sol\\\";\\nimport {StdUtils} from \\\"./StdUtils.sol\\\";\\nimport {VmSafe} from \\\"./Vm.sol\\\";\\n\\n// \\ud83d\\udce6 BOILERPLATE\\nimport {ScriptBase} from \\\"./Base.sol\\\";\\n\\n// \\u2b50\\ufe0f SCRIPT\\nabstract contract Script is ScriptBase, StdChains, StdCheatsSafe, StdUtils {\\n // Note: IS_SCRIPT() must return true.\\n bool public IS_SCRIPT = true;\\n}\\n\",\"keccak256\":\"0xc942e27c7baae499beb01afbbae99f24d42af9a6e4aae675bc6901b704aa8e9b\",\"license\":\"MIT\"},\"lib/forge-std/src/StdChains.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity >=0.6.2 <0.9.0;\\n\\nimport {VmSafe} from \\\"./Vm.sol\\\";\\n\\n/**\\n * StdChains provides information about EVM compatible chains that can be used in scripts/tests.\\n * For each chain, the chain's name, chain ID, and a default RPC URL are provided. Chains are\\n * identified by their alias, which is the same as the alias in the `[rpc_endpoints]` section of\\n * the `foundry.toml` file. For best UX, ensure the alias in the `foundry.toml` file match the\\n * alias used in this contract, which can be found as the first argument to the\\n * `setChainWithDefaultRpcUrl` call in the `initializeStdChains` function.\\n *\\n * There are two main ways to use this contract:\\n * 1. Set a chain with `setChain(string memory chainAlias, ChainData memory chain)` or\\n * `setChain(string memory chainAlias, Chain memory chain)`\\n * 2. Get a chain with `getChain(string memory chainAlias)` or `getChain(uint256 chainId)`.\\n *\\n * The first time either of those are used, chains are initialized with the default set of RPC URLs.\\n * This is done in `initializeStdChains`, which uses `setChainWithDefaultRpcUrl`. Defaults are recorded in\\n * `defaultRpcUrls`.\\n *\\n * The `setChain` function is straightforward, and it simply saves off the given chain data.\\n *\\n * The `getChain` methods use `getChainWithUpdatedRpcUrl` to return a chain. For example, let's say\\n * we want to retrieve the RPC URL for `mainnet`:\\n * - If you have specified data with `setChain`, it will return that.\\n * - If you have configured a mainnet RPC URL in `foundry.toml`, it will return the URL, provided it\\n * is valid (e.g. a URL is specified, or an environment variable is given and exists).\\n * - If neither of the above conditions is met, the default data is returned.\\n *\\n * Summarizing the above, the prioritization hierarchy is `setChain` -> `foundry.toml` -> environment variable -> defaults.\\n */\\nabstract contract StdChains {\\n VmSafe private constant vm = VmSafe(address(uint160(uint256(keccak256(\\\"hevm cheat code\\\")))));\\n\\n bool private stdChainsInitialized;\\n\\n struct ChainData {\\n string name;\\n uint256 chainId;\\n string rpcUrl;\\n }\\n\\n struct Chain {\\n // The chain name.\\n string name;\\n // The chain's Chain ID.\\n uint256 chainId;\\n // The chain's alias. (i.e. what gets specified in `foundry.toml`).\\n string chainAlias;\\n // A default RPC endpoint for this chain.\\n // NOTE: This default RPC URL is included for convenience to facilitate quick tests and\\n // experimentation. Do not use this RPC URL for production test suites, CI, or other heavy\\n // usage as you will be throttled and this is a disservice to others who need this endpoint.\\n string rpcUrl;\\n }\\n\\n // Maps from the chain's alias (matching the alias in the `foundry.toml` file) to chain data.\\n mapping(string => Chain) private chains;\\n // Maps from the chain's alias to it's default RPC URL.\\n mapping(string => string) private defaultRpcUrls;\\n // Maps from a chain ID to it's alias.\\n mapping(uint256 => string) private idToAlias;\\n\\n bool private fallbackToDefaultRpcUrls = true;\\n\\n // The RPC URL will be fetched from config or defaultRpcUrls if possible.\\n function getChain(string memory chainAlias) internal virtual returns (Chain memory chain) {\\n require(bytes(chainAlias).length != 0, \\\"StdChains getChain(string): Chain alias cannot be the empty string.\\\");\\n\\n initializeStdChains();\\n chain = chains[chainAlias];\\n require(\\n chain.chainId != 0,\\n string(abi.encodePacked(\\\"StdChains getChain(string): Chain with alias \\\\\\\"\\\", chainAlias, \\\"\\\\\\\" not found.\\\"))\\n );\\n\\n chain = getChainWithUpdatedRpcUrl(chainAlias, chain);\\n }\\n\\n function getChain(uint256 chainId) internal virtual returns (Chain memory chain) {\\n require(chainId != 0, \\\"StdChains getChain(uint256): Chain ID cannot be 0.\\\");\\n initializeStdChains();\\n string memory chainAlias = idToAlias[chainId];\\n\\n chain = chains[chainAlias];\\n\\n require(\\n chain.chainId != 0,\\n string(abi.encodePacked(\\\"StdChains getChain(uint256): Chain with ID \\\", vm.toString(chainId), \\\" not found.\\\"))\\n );\\n\\n chain = getChainWithUpdatedRpcUrl(chainAlias, chain);\\n }\\n\\n // set chain info, with priority to argument's rpcUrl field.\\n function setChain(string memory chainAlias, ChainData memory chain) internal virtual {\\n require(\\n bytes(chainAlias).length != 0,\\n \\\"StdChains setChain(string,ChainData): Chain alias cannot be the empty string.\\\"\\n );\\n\\n require(chain.chainId != 0, \\\"StdChains setChain(string,ChainData): Chain ID cannot be 0.\\\");\\n\\n initializeStdChains();\\n string memory foundAlias = idToAlias[chain.chainId];\\n\\n require(\\n bytes(foundAlias).length == 0 || keccak256(bytes(foundAlias)) == keccak256(bytes(chainAlias)),\\n string(\\n abi.encodePacked(\\n \\\"StdChains setChain(string,ChainData): Chain ID \\\",\\n vm.toString(chain.chainId),\\n \\\" already used by \\\\\\\"\\\",\\n foundAlias,\\n \\\"\\\\\\\".\\\"\\n )\\n )\\n );\\n\\n uint256 oldChainId = chains[chainAlias].chainId;\\n delete idToAlias[oldChainId];\\n\\n chains[chainAlias] =\\n Chain({name: chain.name, chainId: chain.chainId, chainAlias: chainAlias, rpcUrl: chain.rpcUrl});\\n idToAlias[chain.chainId] = chainAlias;\\n }\\n\\n // set chain info, with priority to argument's rpcUrl field.\\n function setChain(string memory chainAlias, Chain memory chain) internal virtual {\\n setChain(chainAlias, ChainData({name: chain.name, chainId: chain.chainId, rpcUrl: chain.rpcUrl}));\\n }\\n\\n function _toUpper(string memory str) private pure returns (string memory) {\\n bytes memory strb = bytes(str);\\n bytes memory copy = new bytes(strb.length);\\n for (uint256 i = 0; i < strb.length; i++) {\\n bytes1 b = strb[i];\\n if (b >= 0x61 && b <= 0x7A) {\\n copy[i] = bytes1(uint8(b) - 32);\\n } else {\\n copy[i] = b;\\n }\\n }\\n return string(copy);\\n }\\n\\n // lookup rpcUrl, in descending order of priority:\\n // current -> config (foundry.toml) -> environment variable -> default\\n function getChainWithUpdatedRpcUrl(string memory chainAlias, Chain memory chain)\\n private\\n view\\n returns (Chain memory)\\n {\\n if (bytes(chain.rpcUrl).length == 0) {\\n try vm.rpcUrl(chainAlias) returns (string memory configRpcUrl) {\\n chain.rpcUrl = configRpcUrl;\\n } catch (bytes memory err) {\\n string memory envName = string(abi.encodePacked(_toUpper(chainAlias), \\\"_RPC_URL\\\"));\\n if (fallbackToDefaultRpcUrls) {\\n chain.rpcUrl = vm.envOr(envName, defaultRpcUrls[chainAlias]);\\n } else {\\n chain.rpcUrl = vm.envString(envName);\\n }\\n // Distinguish 'not found' from 'cannot read'\\n // The upstream error thrown by forge for failing cheats changed so we check both the old and new versions\\n bytes memory oldNotFoundError =\\n abi.encodeWithSignature(\\\"CheatCodeError\\\", string(abi.encodePacked(\\\"invalid rpc url \\\", chainAlias)));\\n bytes memory newNotFoundError = abi.encodeWithSignature(\\n \\\"CheatcodeError(string)\\\", string(abi.encodePacked(\\\"invalid rpc url: \\\", chainAlias))\\n );\\n bytes32 errHash = keccak256(err);\\n if (\\n (errHash != keccak256(oldNotFoundError) && errHash != keccak256(newNotFoundError))\\n || bytes(chain.rpcUrl).length == 0\\n ) {\\n /// @solidity memory-safe-assembly\\n assembly {\\n revert(add(32, err), mload(err))\\n }\\n }\\n }\\n }\\n return chain;\\n }\\n\\n function setFallbackToDefaultRpcUrls(bool useDefault) internal {\\n fallbackToDefaultRpcUrls = useDefault;\\n }\\n\\n function initializeStdChains() private {\\n if (stdChainsInitialized) return;\\n\\n stdChainsInitialized = true;\\n\\n // If adding an RPC here, make sure to test the default RPC URL in `test_Rpcs` in `StdChains.t.sol`\\n setChainWithDefaultRpcUrl(\\\"anvil\\\", ChainData(\\\"Anvil\\\", 31337, \\\"http://127.0.0.1:8545\\\"));\\n setChainWithDefaultRpcUrl(\\\"mainnet\\\", ChainData(\\\"Mainnet\\\", 1, \\\"https://eth.llamarpc.com\\\"));\\n setChainWithDefaultRpcUrl(\\n \\\"sepolia\\\", ChainData(\\\"Sepolia\\\", 11155111, \\\"https://sepolia.infura.io/v3/b9794ad1ddf84dfb8c34d6bb5dca2001\\\")\\n );\\n setChainWithDefaultRpcUrl(\\\"holesky\\\", ChainData(\\\"Holesky\\\", 17000, \\\"https://rpc.holesky.ethpandaops.io\\\"));\\n setChainWithDefaultRpcUrl(\\\"optimism\\\", ChainData(\\\"Optimism\\\", 10, \\\"https://mainnet.optimism.io\\\"));\\n setChainWithDefaultRpcUrl(\\n \\\"optimism_sepolia\\\", ChainData(\\\"Optimism Sepolia\\\", 11155420, \\\"https://sepolia.optimism.io\\\")\\n );\\n setChainWithDefaultRpcUrl(\\\"arbitrum_one\\\", ChainData(\\\"Arbitrum One\\\", 42161, \\\"https://arb1.arbitrum.io/rpc\\\"));\\n setChainWithDefaultRpcUrl(\\n \\\"arbitrum_one_sepolia\\\", ChainData(\\\"Arbitrum One Sepolia\\\", 421614, \\\"https://sepolia-rollup.arbitrum.io/rpc\\\")\\n );\\n setChainWithDefaultRpcUrl(\\\"arbitrum_nova\\\", ChainData(\\\"Arbitrum Nova\\\", 42170, \\\"https://nova.arbitrum.io/rpc\\\"));\\n setChainWithDefaultRpcUrl(\\\"polygon\\\", ChainData(\\\"Polygon\\\", 137, \\\"https://polygon-rpc.com\\\"));\\n setChainWithDefaultRpcUrl(\\n \\\"polygon_amoy\\\", ChainData(\\\"Polygon Amoy\\\", 80002, \\\"https://rpc-amoy.polygon.technology\\\")\\n );\\n setChainWithDefaultRpcUrl(\\\"avalanche\\\", ChainData(\\\"Avalanche\\\", 43114, \\\"https://api.avax.network/ext/bc/C/rpc\\\"));\\n setChainWithDefaultRpcUrl(\\n \\\"avalanche_fuji\\\", ChainData(\\\"Avalanche Fuji\\\", 43113, \\\"https://api.avax-test.network/ext/bc/C/rpc\\\")\\n );\\n setChainWithDefaultRpcUrl(\\n \\\"bnb_smart_chain\\\", ChainData(\\\"BNB Smart Chain\\\", 56, \\\"https://bsc-dataseed1.binance.org\\\")\\n );\\n setChainWithDefaultRpcUrl(\\n \\\"bnb_smart_chain_testnet\\\",\\n ChainData(\\\"BNB Smart Chain Testnet\\\", 97, \\\"https://rpc.ankr.com/bsc_testnet_chapel\\\")\\n );\\n setChainWithDefaultRpcUrl(\\\"gnosis_chain\\\", ChainData(\\\"Gnosis Chain\\\", 100, \\\"https://rpc.gnosischain.com\\\"));\\n setChainWithDefaultRpcUrl(\\\"moonbeam\\\", ChainData(\\\"Moonbeam\\\", 1284, \\\"https://rpc.api.moonbeam.network\\\"));\\n setChainWithDefaultRpcUrl(\\n \\\"moonriver\\\", ChainData(\\\"Moonriver\\\", 1285, \\\"https://rpc.api.moonriver.moonbeam.network\\\")\\n );\\n setChainWithDefaultRpcUrl(\\\"moonbase\\\", ChainData(\\\"Moonbase\\\", 1287, \\\"https://rpc.testnet.moonbeam.network\\\"));\\n setChainWithDefaultRpcUrl(\\\"base_sepolia\\\", ChainData(\\\"Base Sepolia\\\", 84532, \\\"https://sepolia.base.org\\\"));\\n setChainWithDefaultRpcUrl(\\\"base\\\", ChainData(\\\"Base\\\", 8453, \\\"https://mainnet.base.org\\\"));\\n setChainWithDefaultRpcUrl(\\\"blast_sepolia\\\", ChainData(\\\"Blast Sepolia\\\", 168587773, \\\"https://sepolia.blast.io\\\"));\\n setChainWithDefaultRpcUrl(\\\"blast\\\", ChainData(\\\"Blast\\\", 81457, \\\"https://rpc.blast.io\\\"));\\n setChainWithDefaultRpcUrl(\\\"fantom_opera\\\", ChainData(\\\"Fantom Opera\\\", 250, \\\"https://rpc.ankr.com/fantom/\\\"));\\n setChainWithDefaultRpcUrl(\\n \\\"fantom_opera_testnet\\\", ChainData(\\\"Fantom Opera Testnet\\\", 4002, \\\"https://rpc.ankr.com/fantom_testnet/\\\")\\n );\\n setChainWithDefaultRpcUrl(\\\"fraxtal\\\", ChainData(\\\"Fraxtal\\\", 252, \\\"https://rpc.frax.com\\\"));\\n setChainWithDefaultRpcUrl(\\\"fraxtal_testnet\\\", ChainData(\\\"Fraxtal Testnet\\\", 2522, \\\"https://rpc.testnet.frax.com\\\"));\\n setChainWithDefaultRpcUrl(\\n \\\"berachain_bartio_testnet\\\", ChainData(\\\"Berachain bArtio Testnet\\\", 80084, \\\"https://bartio.rpc.berachain.com\\\")\\n );\\n setChainWithDefaultRpcUrl(\\\"flare\\\", ChainData(\\\"Flare\\\", 14, \\\"https://flare-api.flare.network/ext/C/rpc\\\"));\\n setChainWithDefaultRpcUrl(\\n \\\"flare_coston2\\\", ChainData(\\\"Flare Coston2\\\", 114, \\\"https://coston2-api.flare.network/ext/C/rpc\\\")\\n );\\n\\n setChainWithDefaultRpcUrl(\\\"mode\\\", ChainData(\\\"Mode\\\", 34443, \\\"https://mode.drpc.org\\\"));\\n setChainWithDefaultRpcUrl(\\\"mode_sepolia\\\", ChainData(\\\"Mode Sepolia\\\", 919, \\\"https://sepolia.mode.network\\\"));\\n\\n setChainWithDefaultRpcUrl(\\\"zora\\\", ChainData(\\\"Zora\\\", 7777777, \\\"https://zora.drpc.org\\\"));\\n setChainWithDefaultRpcUrl(\\n \\\"zora_sepolia\\\", ChainData(\\\"Zora Sepolia\\\", 999999999, \\\"https://sepolia.rpc.zora.energy\\\")\\n );\\n\\n setChainWithDefaultRpcUrl(\\\"race\\\", ChainData(\\\"Race\\\", 6805, \\\"https://racemainnet.io\\\"));\\n setChainWithDefaultRpcUrl(\\\"race_sepolia\\\", ChainData(\\\"Race Sepolia\\\", 6806, \\\"https://racemainnet.io\\\"));\\n\\n setChainWithDefaultRpcUrl(\\\"metal\\\", ChainData(\\\"Metal\\\", 1750, \\\"https://metall2.drpc.org\\\"));\\n setChainWithDefaultRpcUrl(\\\"metal_sepolia\\\", ChainData(\\\"Metal Sepolia\\\", 1740, \\\"https://testnet.rpc.metall2.com\\\"));\\n\\n setChainWithDefaultRpcUrl(\\\"binary\\\", ChainData(\\\"Binary\\\", 624, \\\"https://rpc.zero.thebinaryholdings.com\\\"));\\n setChainWithDefaultRpcUrl(\\n \\\"binary_sepolia\\\", ChainData(\\\"Binary Sepolia\\\", 625, \\\"https://rpc.zero.thebinaryholdings.com\\\")\\n );\\n\\n setChainWithDefaultRpcUrl(\\\"orderly\\\", ChainData(\\\"Orderly\\\", 291, \\\"https://rpc.orderly.network\\\"));\\n setChainWithDefaultRpcUrl(\\n \\\"orderly_sepolia\\\", ChainData(\\\"Orderly Sepolia\\\", 4460, \\\"https://testnet-rpc.orderly.org\\\")\\n );\\n }\\n\\n // set chain info, with priority to chainAlias' rpc url in foundry.toml\\n function setChainWithDefaultRpcUrl(string memory chainAlias, ChainData memory chain) private {\\n string memory rpcUrl = chain.rpcUrl;\\n defaultRpcUrls[chainAlias] = rpcUrl;\\n chain.rpcUrl = \\\"\\\";\\n setChain(chainAlias, chain);\\n chain.rpcUrl = rpcUrl; // restore argument\\n }\\n}\\n\",\"keccak256\":\"0x200b597cd01c229633b4a2317846cac7d36d337e2381b4a2e81faac23c2ad1cf\",\"license\":\"MIT\"},\"lib/forge-std/src/StdCheats.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity >=0.6.2 <0.9.0;\\n\\npragma experimental ABIEncoderV2;\\n\\nimport {StdStorage, stdStorage} from \\\"./StdStorage.sol\\\";\\nimport {console2} from \\\"./console2.sol\\\";\\nimport {Vm} from \\\"./Vm.sol\\\";\\n\\nabstract contract StdCheatsSafe {\\n Vm private constant vm = Vm(address(uint160(uint256(keccak256(\\\"hevm cheat code\\\")))));\\n\\n uint256 private constant UINT256_MAX =\\n 115792089237316195423570985008687907853269984665640564039457584007913129639935;\\n\\n bool private gasMeteringOff;\\n\\n // Data structures to parse Transaction objects from the broadcast artifact\\n // that conform to EIP1559. The Raw structs is what is parsed from the JSON\\n // and then converted to the one that is used by the user for better UX.\\n\\n struct RawTx1559 {\\n string[] arguments;\\n address contractAddress;\\n string contractName;\\n // json value name = function\\n string functionSig;\\n bytes32 hash;\\n // json value name = tx\\n RawTx1559Detail txDetail;\\n // json value name = type\\n string opcode;\\n }\\n\\n struct RawTx1559Detail {\\n AccessList[] accessList;\\n bytes data;\\n address from;\\n bytes gas;\\n bytes nonce;\\n address to;\\n bytes txType;\\n bytes value;\\n }\\n\\n struct Tx1559 {\\n string[] arguments;\\n address contractAddress;\\n string contractName;\\n string functionSig;\\n bytes32 hash;\\n Tx1559Detail txDetail;\\n string opcode;\\n }\\n\\n struct Tx1559Detail {\\n AccessList[] accessList;\\n bytes data;\\n address from;\\n uint256 gas;\\n uint256 nonce;\\n address to;\\n uint256 txType;\\n uint256 value;\\n }\\n\\n // Data structures to parse Transaction objects from the broadcast artifact\\n // that DO NOT conform to EIP1559. The Raw structs is what is parsed from the JSON\\n // and then converted to the one that is used by the user for better UX.\\n\\n struct TxLegacy {\\n string[] arguments;\\n address contractAddress;\\n string contractName;\\n string functionSig;\\n string hash;\\n string opcode;\\n TxDetailLegacy transaction;\\n }\\n\\n struct TxDetailLegacy {\\n AccessList[] accessList;\\n uint256 chainId;\\n bytes data;\\n address from;\\n uint256 gas;\\n uint256 gasPrice;\\n bytes32 hash;\\n uint256 nonce;\\n bytes1 opcode;\\n bytes32 r;\\n bytes32 s;\\n uint256 txType;\\n address to;\\n uint8 v;\\n uint256 value;\\n }\\n\\n struct AccessList {\\n address accessAddress;\\n bytes32[] storageKeys;\\n }\\n\\n // Data structures to parse Receipt objects from the broadcast artifact.\\n // The Raw structs is what is parsed from the JSON\\n // and then converted to the one that is used by the user for better UX.\\n\\n struct RawReceipt {\\n bytes32 blockHash;\\n bytes blockNumber;\\n address contractAddress;\\n bytes cumulativeGasUsed;\\n bytes effectiveGasPrice;\\n address from;\\n bytes gasUsed;\\n RawReceiptLog[] logs;\\n bytes logsBloom;\\n bytes status;\\n address to;\\n bytes32 transactionHash;\\n bytes transactionIndex;\\n }\\n\\n struct Receipt {\\n bytes32 blockHash;\\n uint256 blockNumber;\\n address contractAddress;\\n uint256 cumulativeGasUsed;\\n uint256 effectiveGasPrice;\\n address from;\\n uint256 gasUsed;\\n ReceiptLog[] logs;\\n bytes logsBloom;\\n uint256 status;\\n address to;\\n bytes32 transactionHash;\\n uint256 transactionIndex;\\n }\\n\\n // Data structures to parse the entire broadcast artifact, assuming the\\n // transactions conform to EIP1559.\\n\\n struct EIP1559ScriptArtifact {\\n string[] libraries;\\n string path;\\n string[] pending;\\n Receipt[] receipts;\\n uint256 timestamp;\\n Tx1559[] transactions;\\n TxReturn[] txReturns;\\n }\\n\\n struct RawEIP1559ScriptArtifact {\\n string[] libraries;\\n string path;\\n string[] pending;\\n RawReceipt[] receipts;\\n TxReturn[] txReturns;\\n uint256 timestamp;\\n RawTx1559[] transactions;\\n }\\n\\n struct RawReceiptLog {\\n // json value = address\\n address logAddress;\\n bytes32 blockHash;\\n bytes blockNumber;\\n bytes data;\\n bytes logIndex;\\n bool removed;\\n bytes32[] topics;\\n bytes32 transactionHash;\\n bytes transactionIndex;\\n bytes transactionLogIndex;\\n }\\n\\n struct ReceiptLog {\\n // json value = address\\n address logAddress;\\n bytes32 blockHash;\\n uint256 blockNumber;\\n bytes data;\\n uint256 logIndex;\\n bytes32[] topics;\\n uint256 transactionIndex;\\n uint256 transactionLogIndex;\\n bool removed;\\n }\\n\\n struct TxReturn {\\n string internalType;\\n string value;\\n }\\n\\n struct Account {\\n address addr;\\n uint256 key;\\n }\\n\\n enum AddressType {\\n Payable,\\n NonPayable,\\n ZeroAddress,\\n Precompile,\\n ForgeAddress\\n }\\n\\n // Checks that `addr` is not blacklisted by token contracts that have a blacklist.\\n function assumeNotBlacklisted(address token, address addr) internal view virtual {\\n // Nothing to check if `token` is not a contract.\\n uint256 tokenCodeSize;\\n assembly {\\n tokenCodeSize := extcodesize(token)\\n }\\n require(tokenCodeSize > 0, \\\"StdCheats assumeNotBlacklisted(address,address): Token address is not a contract.\\\");\\n\\n bool success;\\n bytes memory returnData;\\n\\n // 4-byte selector for `isBlacklisted(address)`, used by USDC.\\n (success, returnData) = token.staticcall(abi.encodeWithSelector(0xfe575a87, addr));\\n vm.assume(!success || abi.decode(returnData, (bool)) == false);\\n\\n // 4-byte selector for `isBlackListed(address)`, used by USDT.\\n (success, returnData) = token.staticcall(abi.encodeWithSelector(0xe47d6060, addr));\\n vm.assume(!success || abi.decode(returnData, (bool)) == false);\\n }\\n\\n // Checks that `addr` is not blacklisted by token contracts that have a blacklist.\\n // This is identical to `assumeNotBlacklisted(address,address)` but with a different name, for\\n // backwards compatibility, since this name was used in the original PR which already has\\n // a release. This function can be removed in a future release once we want a breaking change.\\n function assumeNoBlacklisted(address token, address addr) internal view virtual {\\n assumeNotBlacklisted(token, addr);\\n }\\n\\n function assumeAddressIsNot(address addr, AddressType addressType) internal virtual {\\n if (addressType == AddressType.Payable) {\\n assumeNotPayable(addr);\\n } else if (addressType == AddressType.NonPayable) {\\n assumePayable(addr);\\n } else if (addressType == AddressType.ZeroAddress) {\\n assumeNotZeroAddress(addr);\\n } else if (addressType == AddressType.Precompile) {\\n assumeNotPrecompile(addr);\\n } else if (addressType == AddressType.ForgeAddress) {\\n assumeNotForgeAddress(addr);\\n }\\n }\\n\\n function assumeAddressIsNot(address addr, AddressType addressType1, AddressType addressType2) internal virtual {\\n assumeAddressIsNot(addr, addressType1);\\n assumeAddressIsNot(addr, addressType2);\\n }\\n\\n function assumeAddressIsNot(\\n address addr,\\n AddressType addressType1,\\n AddressType addressType2,\\n AddressType addressType3\\n ) internal virtual {\\n assumeAddressIsNot(addr, addressType1);\\n assumeAddressIsNot(addr, addressType2);\\n assumeAddressIsNot(addr, addressType3);\\n }\\n\\n function assumeAddressIsNot(\\n address addr,\\n AddressType addressType1,\\n AddressType addressType2,\\n AddressType addressType3,\\n AddressType addressType4\\n ) internal virtual {\\n assumeAddressIsNot(addr, addressType1);\\n assumeAddressIsNot(addr, addressType2);\\n assumeAddressIsNot(addr, addressType3);\\n assumeAddressIsNot(addr, addressType4);\\n }\\n\\n // This function checks whether an address, `addr`, is payable. It works by sending 1 wei to\\n // `addr` and checking the `success` return value.\\n // NOTE: This function may result in state changes depending on the fallback/receive logic\\n // implemented by `addr`, which should be taken into account when this function is used.\\n function _isPayable(address addr) private returns (bool) {\\n require(\\n addr.balance < UINT256_MAX,\\n \\\"StdCheats _isPayable(address): Balance equals max uint256, so it cannot receive any more funds\\\"\\n );\\n uint256 origBalanceTest = address(this).balance;\\n uint256 origBalanceAddr = address(addr).balance;\\n\\n vm.deal(address(this), 1);\\n (bool success,) = payable(addr).call{value: 1}(\\\"\\\");\\n\\n // reset balances\\n vm.deal(address(this), origBalanceTest);\\n vm.deal(addr, origBalanceAddr);\\n\\n return success;\\n }\\n\\n // NOTE: This function may result in state changes depending on the fallback/receive logic\\n // implemented by `addr`, which should be taken into account when this function is used. See the\\n // `_isPayable` method for more information.\\n function assumePayable(address addr) internal virtual {\\n vm.assume(_isPayable(addr));\\n }\\n\\n function assumeNotPayable(address addr) internal virtual {\\n vm.assume(!_isPayable(addr));\\n }\\n\\n function assumeNotZeroAddress(address addr) internal pure virtual {\\n vm.assume(addr != address(0));\\n }\\n\\n function assumeNotPrecompile(address addr) internal pure virtual {\\n assumeNotPrecompile(addr, _pureChainId());\\n }\\n\\n function assumeNotPrecompile(address addr, uint256 chainId) internal pure virtual {\\n // Note: For some chains like Optimism these are technically predeploys (i.e. bytecode placed at a specific\\n // address), but the same rationale for excluding them applies so we include those too.\\n\\n // These are reserved by Ethereum and may be on all EVM-compatible chains.\\n vm.assume(addr < address(0x1) || addr > address(0xff));\\n\\n // forgefmt: disable-start\\n if (chainId == 10 || chainId == 420) {\\n // https://github.com/ethereum-optimism/optimism/blob/eaa371a0184b56b7ca6d9eb9cb0a2b78b2ccd864/op-bindings/predeploys/addresses.go#L6-L21\\n vm.assume(addr < address(0x4200000000000000000000000000000000000000) || addr > address(0x4200000000000000000000000000000000000800));\\n } else if (chainId == 42161 || chainId == 421613) {\\n // https://developer.arbitrum.io/useful-addresses#arbitrum-precompiles-l2-same-on-all-arb-chains\\n vm.assume(addr < address(0x0000000000000000000000000000000000000064) || addr > address(0x0000000000000000000000000000000000000068));\\n } else if (chainId == 43114 || chainId == 43113) {\\n // https://github.com/ava-labs/subnet-evm/blob/47c03fd007ecaa6de2c52ea081596e0a88401f58/precompile/params.go#L18-L59\\n vm.assume(addr < address(0x0100000000000000000000000000000000000000) || addr > address(0x01000000000000000000000000000000000000ff));\\n vm.assume(addr < address(0x0200000000000000000000000000000000000000) || addr > address(0x02000000000000000000000000000000000000FF));\\n vm.assume(addr < address(0x0300000000000000000000000000000000000000) || addr > address(0x03000000000000000000000000000000000000Ff));\\n }\\n // forgefmt: disable-end\\n }\\n\\n function assumeNotForgeAddress(address addr) internal pure virtual {\\n // vm, console, and Create2Deployer addresses\\n vm.assume(\\n addr != address(vm) && addr != 0x000000000000000000636F6e736F6c652e6c6f67\\n && addr != 0x4e59b44847b379578588920cA78FbF26c0B4956C\\n );\\n }\\n\\n function assumeUnusedAddress(address addr) internal view virtual {\\n uint256 size;\\n assembly {\\n size := extcodesize(addr)\\n }\\n vm.assume(size == 0);\\n\\n assumeNotPrecompile(addr);\\n assumeNotZeroAddress(addr);\\n assumeNotForgeAddress(addr);\\n }\\n\\n function readEIP1559ScriptArtifact(string memory path)\\n internal\\n view\\n virtual\\n returns (EIP1559ScriptArtifact memory)\\n {\\n string memory data = vm.readFile(path);\\n bytes memory parsedData = vm.parseJson(data);\\n RawEIP1559ScriptArtifact memory rawArtifact = abi.decode(parsedData, (RawEIP1559ScriptArtifact));\\n EIP1559ScriptArtifact memory artifact;\\n artifact.libraries = rawArtifact.libraries;\\n artifact.path = rawArtifact.path;\\n artifact.timestamp = rawArtifact.timestamp;\\n artifact.pending = rawArtifact.pending;\\n artifact.txReturns = rawArtifact.txReturns;\\n artifact.receipts = rawToConvertedReceipts(rawArtifact.receipts);\\n artifact.transactions = rawToConvertedEIPTx1559s(rawArtifact.transactions);\\n return artifact;\\n }\\n\\n function rawToConvertedEIPTx1559s(RawTx1559[] memory rawTxs) internal pure virtual returns (Tx1559[] memory) {\\n Tx1559[] memory txs = new Tx1559[](rawTxs.length);\\n for (uint256 i; i < rawTxs.length; i++) {\\n txs[i] = rawToConvertedEIPTx1559(rawTxs[i]);\\n }\\n return txs;\\n }\\n\\n function rawToConvertedEIPTx1559(RawTx1559 memory rawTx) internal pure virtual returns (Tx1559 memory) {\\n Tx1559 memory transaction;\\n transaction.arguments = rawTx.arguments;\\n transaction.contractName = rawTx.contractName;\\n transaction.functionSig = rawTx.functionSig;\\n transaction.hash = rawTx.hash;\\n transaction.txDetail = rawToConvertedEIP1559Detail(rawTx.txDetail);\\n transaction.opcode = rawTx.opcode;\\n return transaction;\\n }\\n\\n function rawToConvertedEIP1559Detail(RawTx1559Detail memory rawDetail)\\n internal\\n pure\\n virtual\\n returns (Tx1559Detail memory)\\n {\\n Tx1559Detail memory txDetail;\\n txDetail.data = rawDetail.data;\\n txDetail.from = rawDetail.from;\\n txDetail.to = rawDetail.to;\\n txDetail.nonce = _bytesToUint(rawDetail.nonce);\\n txDetail.txType = _bytesToUint(rawDetail.txType);\\n txDetail.value = _bytesToUint(rawDetail.value);\\n txDetail.gas = _bytesToUint(rawDetail.gas);\\n txDetail.accessList = rawDetail.accessList;\\n return txDetail;\\n }\\n\\n function readTx1559s(string memory path) internal view virtual returns (Tx1559[] memory) {\\n string memory deployData = vm.readFile(path);\\n bytes memory parsedDeployData = vm.parseJson(deployData, \\\".transactions\\\");\\n RawTx1559[] memory rawTxs = abi.decode(parsedDeployData, (RawTx1559[]));\\n return rawToConvertedEIPTx1559s(rawTxs);\\n }\\n\\n function readTx1559(string memory path, uint256 index) internal view virtual returns (Tx1559 memory) {\\n string memory deployData = vm.readFile(path);\\n string memory key = string(abi.encodePacked(\\\".transactions[\\\", vm.toString(index), \\\"]\\\"));\\n bytes memory parsedDeployData = vm.parseJson(deployData, key);\\n RawTx1559 memory rawTx = abi.decode(parsedDeployData, (RawTx1559));\\n return rawToConvertedEIPTx1559(rawTx);\\n }\\n\\n // Analogous to readTransactions, but for receipts.\\n function readReceipts(string memory path) internal view virtual returns (Receipt[] memory) {\\n string memory deployData = vm.readFile(path);\\n bytes memory parsedDeployData = vm.parseJson(deployData, \\\".receipts\\\");\\n RawReceipt[] memory rawReceipts = abi.decode(parsedDeployData, (RawReceipt[]));\\n return rawToConvertedReceipts(rawReceipts);\\n }\\n\\n function readReceipt(string memory path, uint256 index) internal view virtual returns (Receipt memory) {\\n string memory deployData = vm.readFile(path);\\n string memory key = string(abi.encodePacked(\\\".receipts[\\\", vm.toString(index), \\\"]\\\"));\\n bytes memory parsedDeployData = vm.parseJson(deployData, key);\\n RawReceipt memory rawReceipt = abi.decode(parsedDeployData, (RawReceipt));\\n return rawToConvertedReceipt(rawReceipt);\\n }\\n\\n function rawToConvertedReceipts(RawReceipt[] memory rawReceipts) internal pure virtual returns (Receipt[] memory) {\\n Receipt[] memory receipts = new Receipt[](rawReceipts.length);\\n for (uint256 i; i < rawReceipts.length; i++) {\\n receipts[i] = rawToConvertedReceipt(rawReceipts[i]);\\n }\\n return receipts;\\n }\\n\\n function rawToConvertedReceipt(RawReceipt memory rawReceipt) internal pure virtual returns (Receipt memory) {\\n Receipt memory receipt;\\n receipt.blockHash = rawReceipt.blockHash;\\n receipt.to = rawReceipt.to;\\n receipt.from = rawReceipt.from;\\n receipt.contractAddress = rawReceipt.contractAddress;\\n receipt.effectiveGasPrice = _bytesToUint(rawReceipt.effectiveGasPrice);\\n receipt.cumulativeGasUsed = _bytesToUint(rawReceipt.cumulativeGasUsed);\\n receipt.gasUsed = _bytesToUint(rawReceipt.gasUsed);\\n receipt.status = _bytesToUint(rawReceipt.status);\\n receipt.transactionIndex = _bytesToUint(rawReceipt.transactionIndex);\\n receipt.blockNumber = _bytesToUint(rawReceipt.blockNumber);\\n receipt.logs = rawToConvertedReceiptLogs(rawReceipt.logs);\\n receipt.logsBloom = rawReceipt.logsBloom;\\n receipt.transactionHash = rawReceipt.transactionHash;\\n return receipt;\\n }\\n\\n function rawToConvertedReceiptLogs(RawReceiptLog[] memory rawLogs)\\n internal\\n pure\\n virtual\\n returns (ReceiptLog[] memory)\\n {\\n ReceiptLog[] memory logs = new ReceiptLog[](rawLogs.length);\\n for (uint256 i; i < rawLogs.length; i++) {\\n logs[i].logAddress = rawLogs[i].logAddress;\\n logs[i].blockHash = rawLogs[i].blockHash;\\n logs[i].blockNumber = _bytesToUint(rawLogs[i].blockNumber);\\n logs[i].data = rawLogs[i].data;\\n logs[i].logIndex = _bytesToUint(rawLogs[i].logIndex);\\n logs[i].topics = rawLogs[i].topics;\\n logs[i].transactionIndex = _bytesToUint(rawLogs[i].transactionIndex);\\n logs[i].transactionLogIndex = _bytesToUint(rawLogs[i].transactionLogIndex);\\n logs[i].removed = rawLogs[i].removed;\\n }\\n return logs;\\n }\\n\\n // Deploy a contract by fetching the contract bytecode from\\n // the artifacts directory\\n // e.g. `deployCode(code, abi.encode(arg1,arg2,arg3))`\\n function deployCode(string memory what, bytes memory args) internal virtual returns (address addr) {\\n bytes memory bytecode = abi.encodePacked(vm.getCode(what), args);\\n /// @solidity memory-safe-assembly\\n assembly {\\n addr := create(0, add(bytecode, 0x20), mload(bytecode))\\n }\\n\\n require(addr != address(0), \\\"StdCheats deployCode(string,bytes): Deployment failed.\\\");\\n }\\n\\n function deployCode(string memory what) internal virtual returns (address addr) {\\n bytes memory bytecode = vm.getCode(what);\\n /// @solidity memory-safe-assembly\\n assembly {\\n addr := create(0, add(bytecode, 0x20), mload(bytecode))\\n }\\n\\n require(addr != address(0), \\\"StdCheats deployCode(string): Deployment failed.\\\");\\n }\\n\\n /// @dev deploy contract with value on construction\\n function deployCode(string memory what, bytes memory args, uint256 val) internal virtual returns (address addr) {\\n bytes memory bytecode = abi.encodePacked(vm.getCode(what), args);\\n /// @solidity memory-safe-assembly\\n assembly {\\n addr := create(val, add(bytecode, 0x20), mload(bytecode))\\n }\\n\\n require(addr != address(0), \\\"StdCheats deployCode(string,bytes,uint256): Deployment failed.\\\");\\n }\\n\\n function deployCode(string memory what, uint256 val) internal virtual returns (address addr) {\\n bytes memory bytecode = vm.getCode(what);\\n /// @solidity memory-safe-assembly\\n assembly {\\n addr := create(val, add(bytecode, 0x20), mload(bytecode))\\n }\\n\\n require(addr != address(0), \\\"StdCheats deployCode(string,uint256): Deployment failed.\\\");\\n }\\n\\n // creates a labeled address and the corresponding private key\\n function makeAddrAndKey(string memory name) internal virtual returns (address addr, uint256 privateKey) {\\n privateKey = uint256(keccak256(abi.encodePacked(name)));\\n addr = vm.addr(privateKey);\\n vm.label(addr, name);\\n }\\n\\n // creates a labeled address\\n function makeAddr(string memory name) internal virtual returns (address addr) {\\n (addr,) = makeAddrAndKey(name);\\n }\\n\\n // Destroys an account immediately, sending the balance to beneficiary.\\n // Destroying means: balance will be zero, code will be empty, and nonce will be 0\\n // This is similar to selfdestruct but not identical: selfdestruct destroys code and nonce\\n // only after tx ends, this will run immediately.\\n function destroyAccount(address who, address beneficiary) internal virtual {\\n uint256 currBalance = who.balance;\\n vm.etch(who, abi.encode());\\n vm.deal(who, 0);\\n vm.resetNonce(who);\\n\\n uint256 beneficiaryBalance = beneficiary.balance;\\n vm.deal(beneficiary, currBalance + beneficiaryBalance);\\n }\\n\\n // creates a struct containing both a labeled address and the corresponding private key\\n function makeAccount(string memory name) internal virtual returns (Account memory account) {\\n (account.addr, account.key) = makeAddrAndKey(name);\\n }\\n\\n function deriveRememberKey(string memory mnemonic, uint32 index)\\n internal\\n virtual\\n returns (address who, uint256 privateKey)\\n {\\n privateKey = vm.deriveKey(mnemonic, index);\\n who = vm.rememberKey(privateKey);\\n }\\n\\n function _bytesToUint(bytes memory b) private pure returns (uint256) {\\n require(b.length <= 32, \\\"StdCheats _bytesToUint(bytes): Bytes length exceeds 32.\\\");\\n return abi.decode(abi.encodePacked(new bytes(32 - b.length), b), (uint256));\\n }\\n\\n function isFork() internal view virtual returns (bool status) {\\n try vm.activeFork() {\\n status = true;\\n } catch (bytes memory) {}\\n }\\n\\n modifier skipWhenForking() {\\n if (!isFork()) {\\n _;\\n }\\n }\\n\\n modifier skipWhenNotForking() {\\n if (isFork()) {\\n _;\\n }\\n }\\n\\n modifier noGasMetering() {\\n vm.pauseGasMetering();\\n // To prevent turning gas monitoring back on with nested functions that use this modifier,\\n // we check if gasMetering started in the off position. If it did, we don't want to turn\\n // it back on until we exit the top level function that used the modifier\\n //\\n // i.e. funcA() noGasMetering { funcB() }, where funcB has noGasMetering as well.\\n // funcA will have `gasStartedOff` as false, funcB will have it as true,\\n // so we only turn metering back on at the end of the funcA\\n bool gasStartedOff = gasMeteringOff;\\n gasMeteringOff = true;\\n\\n _;\\n\\n // if gas metering was on when this modifier was called, turn it back on at the end\\n if (!gasStartedOff) {\\n gasMeteringOff = false;\\n vm.resumeGasMetering();\\n }\\n }\\n\\n // We use this complex approach of `_viewChainId` and `_pureChainId` to ensure there are no\\n // compiler warnings when accessing chain ID in any solidity version supported by forge-std. We\\n // can't simply access the chain ID in a normal view or pure function because the solc View Pure\\n // Checker changed `chainid` from pure to view in 0.8.0.\\n function _viewChainId() private view returns (uint256 chainId) {\\n // Assembly required since `block.chainid` was introduced in 0.8.0.\\n assembly {\\n chainId := chainid()\\n }\\n\\n address(this); // Silence warnings in older Solc versions.\\n }\\n\\n function _pureChainId() private pure returns (uint256 chainId) {\\n function() internal view returns (uint256) fnIn = _viewChainId;\\n function() internal pure returns (uint256) pureChainId;\\n assembly {\\n pureChainId := fnIn\\n }\\n chainId = pureChainId();\\n }\\n}\\n\\n// Wrappers around cheatcodes to avoid footguns\\nabstract contract StdCheats is StdCheatsSafe {\\n using stdStorage for StdStorage;\\n\\n StdStorage private stdstore;\\n Vm private constant vm = Vm(address(uint160(uint256(keccak256(\\\"hevm cheat code\\\")))));\\n address private constant CONSOLE2_ADDRESS = 0x000000000000000000636F6e736F6c652e6c6f67;\\n\\n // Skip forward or rewind time by the specified number of seconds\\n function skip(uint256 time) internal virtual {\\n vm.warp(vm.getBlockTimestamp() + time);\\n }\\n\\n function rewind(uint256 time) internal virtual {\\n vm.warp(vm.getBlockTimestamp() - time);\\n }\\n\\n // Setup a prank from an address that has some ether\\n function hoax(address msgSender) internal virtual {\\n vm.deal(msgSender, 1 << 128);\\n vm.prank(msgSender);\\n }\\n\\n function hoax(address msgSender, uint256 give) internal virtual {\\n vm.deal(msgSender, give);\\n vm.prank(msgSender);\\n }\\n\\n function hoax(address msgSender, address origin) internal virtual {\\n vm.deal(msgSender, 1 << 128);\\n vm.prank(msgSender, origin);\\n }\\n\\n function hoax(address msgSender, address origin, uint256 give) internal virtual {\\n vm.deal(msgSender, give);\\n vm.prank(msgSender, origin);\\n }\\n\\n // Start perpetual prank from an address that has some ether\\n function startHoax(address msgSender) internal virtual {\\n vm.deal(msgSender, 1 << 128);\\n vm.startPrank(msgSender);\\n }\\n\\n function startHoax(address msgSender, uint256 give) internal virtual {\\n vm.deal(msgSender, give);\\n vm.startPrank(msgSender);\\n }\\n\\n // Start perpetual prank from an address that has some ether\\n // tx.origin is set to the origin parameter\\n function startHoax(address msgSender, address origin) internal virtual {\\n vm.deal(msgSender, 1 << 128);\\n vm.startPrank(msgSender, origin);\\n }\\n\\n function startHoax(address msgSender, address origin, uint256 give) internal virtual {\\n vm.deal(msgSender, give);\\n vm.startPrank(msgSender, origin);\\n }\\n\\n function changePrank(address msgSender) internal virtual {\\n console2_log_StdCheats(\\\"changePrank is deprecated. Please use vm.startPrank instead.\\\");\\n vm.stopPrank();\\n vm.startPrank(msgSender);\\n }\\n\\n function changePrank(address msgSender, address txOrigin) internal virtual {\\n vm.stopPrank();\\n vm.startPrank(msgSender, txOrigin);\\n }\\n\\n // The same as Vm's `deal`\\n // Use the alternative signature for ERC20 tokens\\n function deal(address to, uint256 give) internal virtual {\\n vm.deal(to, give);\\n }\\n\\n // Set the balance of an account for any ERC20 token\\n // Use the alternative signature to update `totalSupply`\\n function deal(address token, address to, uint256 give) internal virtual {\\n deal(token, to, give, false);\\n }\\n\\n // Set the balance of an account for any ERC1155 token\\n // Use the alternative signature to update `totalSupply`\\n function dealERC1155(address token, address to, uint256 id, uint256 give) internal virtual {\\n dealERC1155(token, to, id, give, false);\\n }\\n\\n function deal(address token, address to, uint256 give, bool adjust) internal virtual {\\n // get current balance\\n (, bytes memory balData) = token.staticcall(abi.encodeWithSelector(0x70a08231, to));\\n uint256 prevBal = abi.decode(balData, (uint256));\\n\\n // update balance\\n stdstore.target(token).sig(0x70a08231).with_key(to).checked_write(give);\\n\\n // update total supply\\n if (adjust) {\\n (, bytes memory totSupData) = token.staticcall(abi.encodeWithSelector(0x18160ddd));\\n uint256 totSup = abi.decode(totSupData, (uint256));\\n if (give < prevBal) {\\n totSup -= (prevBal - give);\\n } else {\\n totSup += (give - prevBal);\\n }\\n stdstore.target(token).sig(0x18160ddd).checked_write(totSup);\\n }\\n }\\n\\n function dealERC1155(address token, address to, uint256 id, uint256 give, bool adjust) internal virtual {\\n // get current balance\\n (, bytes memory balData) = token.staticcall(abi.encodeWithSelector(0x00fdd58e, to, id));\\n uint256 prevBal = abi.decode(balData, (uint256));\\n\\n // update balance\\n stdstore.target(token).sig(0x00fdd58e).with_key(to).with_key(id).checked_write(give);\\n\\n // update total supply\\n if (adjust) {\\n (, bytes memory totSupData) = token.staticcall(abi.encodeWithSelector(0xbd85b039, id));\\n require(\\n totSupData.length != 0,\\n \\\"StdCheats deal(address,address,uint,uint,bool): target contract is not ERC1155Supply.\\\"\\n );\\n uint256 totSup = abi.decode(totSupData, (uint256));\\n if (give < prevBal) {\\n totSup -= (prevBal - give);\\n } else {\\n totSup += (give - prevBal);\\n }\\n stdstore.target(token).sig(0xbd85b039).with_key(id).checked_write(totSup);\\n }\\n }\\n\\n function dealERC721(address token, address to, uint256 id) internal virtual {\\n // check if token id is already minted and the actual owner.\\n (bool successMinted, bytes memory ownerData) = token.staticcall(abi.encodeWithSelector(0x6352211e, id));\\n require(successMinted, \\\"StdCheats deal(address,address,uint,bool): id not minted.\\\");\\n\\n // get owner current balance\\n (, bytes memory fromBalData) =\\n token.staticcall(abi.encodeWithSelector(0x70a08231, abi.decode(ownerData, (address))));\\n uint256 fromPrevBal = abi.decode(fromBalData, (uint256));\\n\\n // get new user current balance\\n (, bytes memory toBalData) = token.staticcall(abi.encodeWithSelector(0x70a08231, to));\\n uint256 toPrevBal = abi.decode(toBalData, (uint256));\\n\\n // update balances\\n stdstore.target(token).sig(0x70a08231).with_key(abi.decode(ownerData, (address))).checked_write(--fromPrevBal);\\n stdstore.target(token).sig(0x70a08231).with_key(to).checked_write(++toPrevBal);\\n\\n // update owner\\n stdstore.target(token).sig(0x6352211e).with_key(id).checked_write(to);\\n }\\n\\n function deployCodeTo(string memory what, address where) internal virtual {\\n deployCodeTo(what, \\\"\\\", 0, where);\\n }\\n\\n function deployCodeTo(string memory what, bytes memory args, address where) internal virtual {\\n deployCodeTo(what, args, 0, where);\\n }\\n\\n function deployCodeTo(string memory what, bytes memory args, uint256 value, address where) internal virtual {\\n bytes memory creationCode = vm.getCode(what);\\n vm.etch(where, abi.encodePacked(creationCode, args));\\n (bool success, bytes memory runtimeBytecode) = where.call{value: value}(\\\"\\\");\\n require(success, \\\"StdCheats deployCodeTo(string,bytes,uint256,address): Failed to create runtime bytecode.\\\");\\n vm.etch(where, runtimeBytecode);\\n }\\n\\n // Used to prevent the compilation of console, which shortens the compilation time when console is not used elsewhere.\\n function console2_log_StdCheats(string memory p0) private view {\\n (bool status,) = address(CONSOLE2_ADDRESS).staticcall(abi.encodeWithSignature(\\\"log(string)\\\", p0));\\n status;\\n }\\n}\\n\",\"keccak256\":\"0x0fa6ec03602648b62cce41aab2096e6b7e052f2846075d967b6958dd586db746\",\"license\":\"MIT\"},\"lib/forge-std/src/StdConstants.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity >=0.6.2 <0.9.0;\\n\\nimport {IMulticall3} from \\\"./interfaces/IMulticall3.sol\\\";\\nimport {Vm} from \\\"./Vm.sol\\\";\\n\\nlibrary StdConstants {\\n /// @dev Cheat code address.\\n /// Calculated as `address(uint160(uint256(keccak256(\\\"hevm cheat code\\\"))))`.\\n Vm internal constant VM = Vm(0x7109709ECfa91a80626fF3989D68f67F5b1DD12D);\\n /// @dev console.sol and console2.sol work by executing a staticcall to this address.\\n /// Calculated as `address(uint160(uint88(bytes11(\\\"console.log\\\"))))`.\\n address internal constant CONSOLE = 0x000000000000000000636F6e736F6c652e6c6f67;\\n /// @dev Used when deploying with create2.\\n /// Taken from https://github.com/Arachnid/deterministic-deployment-proxy.\\n address internal constant CREATE2_FACTORY = 0x4e59b44847b379578588920cA78FbF26c0B4956C;\\n /// @dev The default address for tx.origin and msg.sender.\\n /// Calculated as `address(uint160(uint256(keccak256(\\\"foundry default caller\\\"))))`.\\n address internal constant DEFAULT_SENDER = 0x1804c8AB1F12E6bbf3894d4083f33e07309d1f38;\\n /// @dev The address of the first contract `CREATE`d by a running test contract.\\n /// When running tests, each test contract is `CREATE`d by `DEFAULT_SENDER` with nonce 1.\\n /// Calculated as `VM.computeCreateAddress(VM.computeCreateAddress(DEFAULT_SENDER, 1), 1)`.\\n address internal constant DEFAULT_TEST_CONTRACT = 0x5615dEB798BB3E4dFa0139dFa1b3D433Cc23b72f;\\n /// @dev Deterministic deployment address of the Multicall3 contract.\\n /// Taken from https://www.multicall3.com.\\n IMulticall3 internal constant MULTICALL3_ADDRESS = IMulticall3(0xcA11bde05977b3631167028862bE2a173976CA11);\\n /// @dev The order of the secp256k1 curve.\\n uint256 internal constant SECP256K1_ORDER =\\n 115792089237316195423570985008687907852837564279074904382605163141518161494337;\\n}\\n\",\"keccak256\":\"0x319ccdabfa2c0b2428301445873270ffea20f0e039d4fd5e6eeba65158e4e534\",\"license\":\"MIT\"},\"lib/forge-std/src/StdJson.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity >=0.6.0 <0.9.0;\\n\\npragma experimental ABIEncoderV2;\\n\\nimport {VmSafe} from \\\"./Vm.sol\\\";\\n\\n// Helpers for parsing and writing JSON files\\n// To parse:\\n// ```\\n// using stdJson for string;\\n// string memory json = vm.readFile(\\\"\\\");\\n// json.readUint(\\\"\\\");\\n// ```\\n// To write:\\n// ```\\n// using stdJson for string;\\n// string memory json = \\\"json\\\";\\n// json.serialize(\\\"a\\\", uint256(123));\\n// string memory semiFinal = json.serialize(\\\"b\\\", string(\\\"test\\\"));\\n// string memory finalJson = json.serialize(\\\"c\\\", semiFinal);\\n// finalJson.write(\\\"\\\");\\n// ```\\n\\nlibrary stdJson {\\n VmSafe private constant vm = VmSafe(address(uint160(uint256(keccak256(\\\"hevm cheat code\\\")))));\\n\\n function keyExists(string memory json, string memory key) internal view returns (bool) {\\n return vm.keyExistsJson(json, key);\\n }\\n\\n function parseRaw(string memory json, string memory key) internal pure returns (bytes memory) {\\n return vm.parseJson(json, key);\\n }\\n\\n function readUint(string memory json, string memory key) internal pure returns (uint256) {\\n return vm.parseJsonUint(json, key);\\n }\\n\\n function readUintArray(string memory json, string memory key) internal pure returns (uint256[] memory) {\\n return vm.parseJsonUintArray(json, key);\\n }\\n\\n function readInt(string memory json, string memory key) internal pure returns (int256) {\\n return vm.parseJsonInt(json, key);\\n }\\n\\n function readIntArray(string memory json, string memory key) internal pure returns (int256[] memory) {\\n return vm.parseJsonIntArray(json, key);\\n }\\n\\n function readBytes32(string memory json, string memory key) internal pure returns (bytes32) {\\n return vm.parseJsonBytes32(json, key);\\n }\\n\\n function readBytes32Array(string memory json, string memory key) internal pure returns (bytes32[] memory) {\\n return vm.parseJsonBytes32Array(json, key);\\n }\\n\\n function readString(string memory json, string memory key) internal pure returns (string memory) {\\n return vm.parseJsonString(json, key);\\n }\\n\\n function readStringArray(string memory json, string memory key) internal pure returns (string[] memory) {\\n return vm.parseJsonStringArray(json, key);\\n }\\n\\n function readAddress(string memory json, string memory key) internal pure returns (address) {\\n return vm.parseJsonAddress(json, key);\\n }\\n\\n function readAddressArray(string memory json, string memory key) internal pure returns (address[] memory) {\\n return vm.parseJsonAddressArray(json, key);\\n }\\n\\n function readBool(string memory json, string memory key) internal pure returns (bool) {\\n return vm.parseJsonBool(json, key);\\n }\\n\\n function readBoolArray(string memory json, string memory key) internal pure returns (bool[] memory) {\\n return vm.parseJsonBoolArray(json, key);\\n }\\n\\n function readBytes(string memory json, string memory key) internal pure returns (bytes memory) {\\n return vm.parseJsonBytes(json, key);\\n }\\n\\n function readBytesArray(string memory json, string memory key) internal pure returns (bytes[] memory) {\\n return vm.parseJsonBytesArray(json, key);\\n }\\n\\n function readUintOr(string memory json, string memory key, uint256 defaultValue) internal view returns (uint256) {\\n return keyExists(json, key) ? readUint(json, key) : defaultValue;\\n }\\n\\n function readUintArrayOr(string memory json, string memory key, uint256[] memory defaultValue)\\n internal\\n view\\n returns (uint256[] memory)\\n {\\n return keyExists(json, key) ? readUintArray(json, key) : defaultValue;\\n }\\n\\n function readIntOr(string memory json, string memory key, int256 defaultValue) internal view returns (int256) {\\n return keyExists(json, key) ? readInt(json, key) : defaultValue;\\n }\\n\\n function readIntArrayOr(string memory json, string memory key, int256[] memory defaultValue)\\n internal\\n view\\n returns (int256[] memory)\\n {\\n return keyExists(json, key) ? readIntArray(json, key) : defaultValue;\\n }\\n\\n function readBytes32Or(string memory json, string memory key, bytes32 defaultValue)\\n internal\\n view\\n returns (bytes32)\\n {\\n return keyExists(json, key) ? readBytes32(json, key) : defaultValue;\\n }\\n\\n function readBytes32ArrayOr(string memory json, string memory key, bytes32[] memory defaultValue)\\n internal\\n view\\n returns (bytes32[] memory)\\n {\\n return keyExists(json, key) ? readBytes32Array(json, key) : defaultValue;\\n }\\n\\n function readStringOr(string memory json, string memory key, string memory defaultValue)\\n internal\\n view\\n returns (string memory)\\n {\\n return keyExists(json, key) ? readString(json, key) : defaultValue;\\n }\\n\\n function readStringArrayOr(string memory json, string memory key, string[] memory defaultValue)\\n internal\\n view\\n returns (string[] memory)\\n {\\n return keyExists(json, key) ? readStringArray(json, key) : defaultValue;\\n }\\n\\n function readAddressOr(string memory json, string memory key, address defaultValue)\\n internal\\n view\\n returns (address)\\n {\\n return keyExists(json, key) ? readAddress(json, key) : defaultValue;\\n }\\n\\n function readAddressArrayOr(string memory json, string memory key, address[] memory defaultValue)\\n internal\\n view\\n returns (address[] memory)\\n {\\n return keyExists(json, key) ? readAddressArray(json, key) : defaultValue;\\n }\\n\\n function readBoolOr(string memory json, string memory key, bool defaultValue) internal view returns (bool) {\\n return keyExists(json, key) ? readBool(json, key) : defaultValue;\\n }\\n\\n function readBoolArrayOr(string memory json, string memory key, bool[] memory defaultValue)\\n internal\\n view\\n returns (bool[] memory)\\n {\\n return keyExists(json, key) ? readBoolArray(json, key) : defaultValue;\\n }\\n\\n function readBytesOr(string memory json, string memory key, bytes memory defaultValue)\\n internal\\n view\\n returns (bytes memory)\\n {\\n return keyExists(json, key) ? readBytes(json, key) : defaultValue;\\n }\\n\\n function readBytesArrayOr(string memory json, string memory key, bytes[] memory defaultValue)\\n internal\\n view\\n returns (bytes[] memory)\\n {\\n return keyExists(json, key) ? readBytesArray(json, key) : defaultValue;\\n }\\n\\n function serialize(string memory jsonKey, string memory rootObject) internal returns (string memory) {\\n return vm.serializeJson(jsonKey, rootObject);\\n }\\n\\n function serialize(string memory jsonKey, string memory key, bool value) internal returns (string memory) {\\n return vm.serializeBool(jsonKey, key, value);\\n }\\n\\n function serialize(string memory jsonKey, string memory key, bool[] memory value)\\n internal\\n returns (string memory)\\n {\\n return vm.serializeBool(jsonKey, key, value);\\n }\\n\\n function serialize(string memory jsonKey, string memory key, uint256 value) internal returns (string memory) {\\n return vm.serializeUint(jsonKey, key, value);\\n }\\n\\n function serialize(string memory jsonKey, string memory key, uint256[] memory value)\\n internal\\n returns (string memory)\\n {\\n return vm.serializeUint(jsonKey, key, value);\\n }\\n\\n function serialize(string memory jsonKey, string memory key, int256 value) internal returns (string memory) {\\n return vm.serializeInt(jsonKey, key, value);\\n }\\n\\n function serialize(string memory jsonKey, string memory key, int256[] memory value)\\n internal\\n returns (string memory)\\n {\\n return vm.serializeInt(jsonKey, key, value);\\n }\\n\\n function serialize(string memory jsonKey, string memory key, address value) internal returns (string memory) {\\n return vm.serializeAddress(jsonKey, key, value);\\n }\\n\\n function serialize(string memory jsonKey, string memory key, address[] memory value)\\n internal\\n returns (string memory)\\n {\\n return vm.serializeAddress(jsonKey, key, value);\\n }\\n\\n function serialize(string memory jsonKey, string memory key, bytes32 value) internal returns (string memory) {\\n return vm.serializeBytes32(jsonKey, key, value);\\n }\\n\\n function serialize(string memory jsonKey, string memory key, bytes32[] memory value)\\n internal\\n returns (string memory)\\n {\\n return vm.serializeBytes32(jsonKey, key, value);\\n }\\n\\n function serialize(string memory jsonKey, string memory key, bytes memory value) internal returns (string memory) {\\n return vm.serializeBytes(jsonKey, key, value);\\n }\\n\\n function serialize(string memory jsonKey, string memory key, bytes[] memory value)\\n internal\\n returns (string memory)\\n {\\n return vm.serializeBytes(jsonKey, key, value);\\n }\\n\\n function serialize(string memory jsonKey, string memory key, string memory value)\\n internal\\n returns (string memory)\\n {\\n return vm.serializeString(jsonKey, key, value);\\n }\\n\\n function serialize(string memory jsonKey, string memory key, string[] memory value)\\n internal\\n returns (string memory)\\n {\\n return vm.serializeString(jsonKey, key, value);\\n }\\n\\n function write(string memory jsonKey, string memory path) internal {\\n vm.writeJson(jsonKey, path);\\n }\\n\\n function write(string memory jsonKey, string memory path, string memory valueKey) internal {\\n vm.writeJson(jsonKey, path, valueKey);\\n }\\n}\\n\",\"keccak256\":\"0xbc0132abe1c2accc2867c0f03667afffdf92f3e95a581bb03c9557eaa38ea500\",\"license\":\"MIT\"},\"lib/forge-std/src/StdMath.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity >=0.6.2 <0.9.0;\\n\\nlibrary stdMath {\\n int256 private constant INT256_MIN = -57896044618658097711785492504343953926634992332820282019728792003956564819968;\\n\\n function abs(int256 a) internal pure returns (uint256) {\\n // Required or it will fail when `a = type(int256).min`\\n if (a == INT256_MIN) {\\n return 57896044618658097711785492504343953926634992332820282019728792003956564819968;\\n }\\n\\n return uint256(a > 0 ? a : -a);\\n }\\n\\n function delta(uint256 a, uint256 b) internal pure returns (uint256) {\\n return a > b ? a - b : b - a;\\n }\\n\\n function delta(int256 a, int256 b) internal pure returns (uint256) {\\n // a and b are of the same sign\\n // this works thanks to two's complement, the left-most bit is the sign bit\\n if ((a ^ b) > -1) {\\n return delta(abs(a), abs(b));\\n }\\n\\n // a and b are of opposite signs\\n return abs(a) + abs(b);\\n }\\n\\n function percentDelta(uint256 a, uint256 b) internal pure returns (uint256) {\\n uint256 absDelta = delta(a, b);\\n\\n return absDelta * 1e18 / b;\\n }\\n\\n function percentDelta(int256 a, int256 b) internal pure returns (uint256) {\\n uint256 absDelta = delta(a, b);\\n uint256 absB = abs(b);\\n\\n return absDelta * 1e18 / absB;\\n }\\n}\\n\",\"keccak256\":\"0xd90ad4fd8aeaeb8929964e686e769fdedd5eded3fc3815df194a0ab9f91a3fb2\",\"license\":\"MIT\"},\"lib/forge-std/src/StdStorage.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity >=0.6.2 <0.9.0;\\n\\nimport {Vm} from \\\"./Vm.sol\\\";\\n\\nstruct FindData {\\n uint256 slot;\\n uint256 offsetLeft;\\n uint256 offsetRight;\\n bool found;\\n}\\n\\nstruct StdStorage {\\n mapping(address => mapping(bytes4 => mapping(bytes32 => FindData))) finds;\\n bytes32[] _keys;\\n bytes4 _sig;\\n uint256 _depth;\\n address _target;\\n bytes32 _set;\\n bool _enable_packed_slots;\\n bytes _calldata;\\n}\\n\\nlibrary stdStorageSafe {\\n event SlotFound(address who, bytes4 fsig, bytes32 keysHash, uint256 slot);\\n event WARNING_UninitedSlot(address who, uint256 slot);\\n\\n Vm private constant vm = Vm(address(uint160(uint256(keccak256(\\\"hevm cheat code\\\")))));\\n uint256 constant UINT256_MAX = 115792089237316195423570985008687907853269984665640564039457584007913129639935;\\n\\n function sigs(string memory sigStr) internal pure returns (bytes4) {\\n return bytes4(keccak256(bytes(sigStr)));\\n }\\n\\n function getCallParams(StdStorage storage self) internal view returns (bytes memory) {\\n if (self._calldata.length == 0) {\\n return flatten(self._keys);\\n } else {\\n return self._calldata;\\n }\\n }\\n\\n // Calls target contract with configured parameters\\n function callTarget(StdStorage storage self) internal view returns (bool, bytes32) {\\n bytes memory cald = abi.encodePacked(self._sig, getCallParams(self));\\n (bool success, bytes memory rdat) = self._target.staticcall(cald);\\n bytes32 result = bytesToBytes32(rdat, 32 * self._depth);\\n\\n return (success, result);\\n }\\n\\n // Tries mutating slot value to determine if the targeted value is stored in it.\\n // If current value is 0, then we are setting slot value to type(uint256).max\\n // Otherwise, we set it to 0. That way, return value should always be affected.\\n function checkSlotMutatesCall(StdStorage storage self, bytes32 slot) internal returns (bool) {\\n bytes32 prevSlotValue = vm.load(self._target, slot);\\n (bool success, bytes32 prevReturnValue) = callTarget(self);\\n\\n bytes32 testVal = prevReturnValue == bytes32(0) ? bytes32(UINT256_MAX) : bytes32(0);\\n vm.store(self._target, slot, testVal);\\n\\n (, bytes32 newReturnValue) = callTarget(self);\\n\\n vm.store(self._target, slot, prevSlotValue);\\n\\n return (success && (prevReturnValue != newReturnValue));\\n }\\n\\n // Tries setting one of the bits in slot to 1 until return value changes.\\n // Index of resulted bit is an offset packed slot has from left/right side\\n function findOffset(StdStorage storage self, bytes32 slot, bool left) internal returns (bool, uint256) {\\n for (uint256 offset = 0; offset < 256; offset++) {\\n uint256 valueToPut = left ? (1 << (255 - offset)) : (1 << offset);\\n vm.store(self._target, slot, bytes32(valueToPut));\\n\\n (bool success, bytes32 data) = callTarget(self);\\n\\n if (success && (uint256(data) > 0)) {\\n return (true, offset);\\n }\\n }\\n return (false, 0);\\n }\\n\\n function findOffsets(StdStorage storage self, bytes32 slot) internal returns (bool, uint256, uint256) {\\n bytes32 prevSlotValue = vm.load(self._target, slot);\\n\\n (bool foundLeft, uint256 offsetLeft) = findOffset(self, slot, true);\\n (bool foundRight, uint256 offsetRight) = findOffset(self, slot, false);\\n\\n // `findOffset` may mutate slot value, so we are setting it to initial value\\n vm.store(self._target, slot, prevSlotValue);\\n return (foundLeft && foundRight, offsetLeft, offsetRight);\\n }\\n\\n function find(StdStorage storage self) internal returns (FindData storage) {\\n return find(self, true);\\n }\\n\\n /// @notice find an arbitrary storage slot given a function sig, input data, address of the contract and a value to check against\\n // slot complexity:\\n // if flat, will be bytes32(uint256(uint));\\n // if map, will be keccak256(abi.encode(key, uint(slot)));\\n // if deep map, will be keccak256(abi.encode(key1, keccak256(abi.encode(key0, uint(slot)))));\\n // if map struct, will be bytes32(uint256(keccak256(abi.encode(key1, keccak256(abi.encode(key0, uint(slot)))))) + structFieldDepth);\\n function find(StdStorage storage self, bool _clear) internal returns (FindData storage) {\\n address who = self._target;\\n bytes4 fsig = self._sig;\\n uint256 field_depth = self._depth;\\n bytes memory params = getCallParams(self);\\n\\n // calldata to test against\\n if (self.finds[who][fsig][keccak256(abi.encodePacked(params, field_depth))].found) {\\n if (_clear) {\\n clear(self);\\n }\\n return self.finds[who][fsig][keccak256(abi.encodePacked(params, field_depth))];\\n }\\n vm.record();\\n (, bytes32 callResult) = callTarget(self);\\n (bytes32[] memory reads,) = vm.accesses(address(who));\\n\\n if (reads.length == 0) {\\n revert(\\\"stdStorage find(StdStorage): No storage use detected for target.\\\");\\n } else {\\n for (uint256 i = reads.length; --i >= 0;) {\\n bytes32 prev = vm.load(who, reads[i]);\\n if (prev == bytes32(0)) {\\n emit WARNING_UninitedSlot(who, uint256(reads[i]));\\n }\\n\\n if (!checkSlotMutatesCall(self, reads[i])) {\\n continue;\\n }\\n\\n (uint256 offsetLeft, uint256 offsetRight) = (0, 0);\\n\\n if (self._enable_packed_slots) {\\n bool found;\\n (found, offsetLeft, offsetRight) = findOffsets(self, reads[i]);\\n if (!found) {\\n continue;\\n }\\n }\\n\\n // Check that value between found offsets is equal to the current call result\\n uint256 curVal = (uint256(prev) & getMaskByOffsets(offsetLeft, offsetRight)) >> offsetRight;\\n\\n if (uint256(callResult) != curVal) {\\n continue;\\n }\\n\\n emit SlotFound(who, fsig, keccak256(abi.encodePacked(params, field_depth)), uint256(reads[i]));\\n self.finds[who][fsig][keccak256(abi.encodePacked(params, field_depth))] =\\n FindData(uint256(reads[i]), offsetLeft, offsetRight, true);\\n break;\\n }\\n }\\n\\n require(\\n self.finds[who][fsig][keccak256(abi.encodePacked(params, field_depth))].found,\\n \\\"stdStorage find(StdStorage): Slot(s) not found.\\\"\\n );\\n\\n if (_clear) {\\n clear(self);\\n }\\n return self.finds[who][fsig][keccak256(abi.encodePacked(params, field_depth))];\\n }\\n\\n function target(StdStorage storage self, address _target) internal returns (StdStorage storage) {\\n self._target = _target;\\n return self;\\n }\\n\\n function sig(StdStorage storage self, bytes4 _sig) internal returns (StdStorage storage) {\\n self._sig = _sig;\\n return self;\\n }\\n\\n function sig(StdStorage storage self, string memory _sig) internal returns (StdStorage storage) {\\n self._sig = sigs(_sig);\\n return self;\\n }\\n\\n function with_calldata(StdStorage storage self, bytes memory _calldata) internal returns (StdStorage storage) {\\n self._calldata = _calldata;\\n return self;\\n }\\n\\n function with_key(StdStorage storage self, address who) internal returns (StdStorage storage) {\\n self._keys.push(bytes32(uint256(uint160(who))));\\n return self;\\n }\\n\\n function with_key(StdStorage storage self, uint256 amt) internal returns (StdStorage storage) {\\n self._keys.push(bytes32(amt));\\n return self;\\n }\\n\\n function with_key(StdStorage storage self, bytes32 key) internal returns (StdStorage storage) {\\n self._keys.push(key);\\n return self;\\n }\\n\\n function enable_packed_slots(StdStorage storage self) internal returns (StdStorage storage) {\\n self._enable_packed_slots = true;\\n return self;\\n }\\n\\n function depth(StdStorage storage self, uint256 _depth) internal returns (StdStorage storage) {\\n self._depth = _depth;\\n return self;\\n }\\n\\n function read(StdStorage storage self) private returns (bytes memory) {\\n FindData storage data = find(self, false);\\n uint256 mask = getMaskByOffsets(data.offsetLeft, data.offsetRight);\\n uint256 value = (uint256(vm.load(self._target, bytes32(data.slot))) & mask) >> data.offsetRight;\\n clear(self);\\n return abi.encode(value);\\n }\\n\\n function read_bytes32(StdStorage storage self) internal returns (bytes32) {\\n return abi.decode(read(self), (bytes32));\\n }\\n\\n function read_bool(StdStorage storage self) internal returns (bool) {\\n int256 v = read_int(self);\\n if (v == 0) return false;\\n if (v == 1) return true;\\n revert(\\\"stdStorage read_bool(StdStorage): Cannot decode. Make sure you are reading a bool.\\\");\\n }\\n\\n function read_address(StdStorage storage self) internal returns (address) {\\n return abi.decode(read(self), (address));\\n }\\n\\n function read_uint(StdStorage storage self) internal returns (uint256) {\\n return abi.decode(read(self), (uint256));\\n }\\n\\n function read_int(StdStorage storage self) internal returns (int256) {\\n return abi.decode(read(self), (int256));\\n }\\n\\n function parent(StdStorage storage self) internal returns (uint256, bytes32) {\\n address who = self._target;\\n uint256 field_depth = self._depth;\\n vm.startMappingRecording();\\n uint256 child = find(self, true).slot - field_depth;\\n (bool found, bytes32 key, bytes32 parent_slot) = vm.getMappingKeyAndParentOf(who, bytes32(child));\\n if (!found) {\\n revert(\\n \\\"stdStorage read_bool(StdStorage): Cannot find parent. Make sure you give a slot and startMappingRecording() has been called.\\\"\\n );\\n }\\n return (uint256(parent_slot), key);\\n }\\n\\n function root(StdStorage storage self) internal returns (uint256) {\\n address who = self._target;\\n uint256 field_depth = self._depth;\\n vm.startMappingRecording();\\n uint256 child = find(self, true).slot - field_depth;\\n bool found;\\n bytes32 root_slot;\\n bytes32 parent_slot;\\n (found,, parent_slot) = vm.getMappingKeyAndParentOf(who, bytes32(child));\\n if (!found) {\\n revert(\\n \\\"stdStorage read_bool(StdStorage): Cannot find parent. Make sure you give a slot and startMappingRecording() has been called.\\\"\\n );\\n }\\n while (found) {\\n root_slot = parent_slot;\\n (found,, parent_slot) = vm.getMappingKeyAndParentOf(who, bytes32(root_slot));\\n }\\n return uint256(root_slot);\\n }\\n\\n function bytesToBytes32(bytes memory b, uint256 offset) private pure returns (bytes32) {\\n bytes32 out;\\n\\n uint256 max = b.length > 32 ? 32 : b.length;\\n for (uint256 i = 0; i < max; i++) {\\n out |= bytes32(b[offset + i] & 0xFF) >> (i * 8);\\n }\\n return out;\\n }\\n\\n function flatten(bytes32[] memory b) private pure returns (bytes memory) {\\n bytes memory result = new bytes(b.length * 32);\\n for (uint256 i = 0; i < b.length; i++) {\\n bytes32 k = b[i];\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(add(result, add(32, mul(32, i))), k)\\n }\\n }\\n\\n return result;\\n }\\n\\n function clear(StdStorage storage self) internal {\\n delete self._target;\\n delete self._sig;\\n delete self._keys;\\n delete self._depth;\\n delete self._enable_packed_slots;\\n delete self._calldata;\\n }\\n\\n // Returns mask which contains non-zero bits for values between `offsetLeft` and `offsetRight`\\n // (slotValue & mask) >> offsetRight will be the value of the given packed variable\\n function getMaskByOffsets(uint256 offsetLeft, uint256 offsetRight) internal pure returns (uint256 mask) {\\n // mask = ((1 << (256 - (offsetRight + offsetLeft))) - 1) << offsetRight;\\n // using assembly because (1 << 256) causes overflow\\n assembly {\\n mask := shl(offsetRight, sub(shl(sub(256, add(offsetRight, offsetLeft)), 1), 1))\\n }\\n }\\n\\n // Returns slot value with updated packed variable.\\n function getUpdatedSlotValue(bytes32 curValue, uint256 varValue, uint256 offsetLeft, uint256 offsetRight)\\n internal\\n pure\\n returns (bytes32 newValue)\\n {\\n return bytes32((uint256(curValue) & ~getMaskByOffsets(offsetLeft, offsetRight)) | (varValue << offsetRight));\\n }\\n}\\n\\nlibrary stdStorage {\\n Vm private constant vm = Vm(address(uint160(uint256(keccak256(\\\"hevm cheat code\\\")))));\\n\\n function sigs(string memory sigStr) internal pure returns (bytes4) {\\n return stdStorageSafe.sigs(sigStr);\\n }\\n\\n function find(StdStorage storage self) internal returns (uint256) {\\n return find(self, true);\\n }\\n\\n function find(StdStorage storage self, bool _clear) internal returns (uint256) {\\n return stdStorageSafe.find(self, _clear).slot;\\n }\\n\\n function target(StdStorage storage self, address _target) internal returns (StdStorage storage) {\\n return stdStorageSafe.target(self, _target);\\n }\\n\\n function sig(StdStorage storage self, bytes4 _sig) internal returns (StdStorage storage) {\\n return stdStorageSafe.sig(self, _sig);\\n }\\n\\n function sig(StdStorage storage self, string memory _sig) internal returns (StdStorage storage) {\\n return stdStorageSafe.sig(self, _sig);\\n }\\n\\n function with_key(StdStorage storage self, address who) internal returns (StdStorage storage) {\\n return stdStorageSafe.with_key(self, who);\\n }\\n\\n function with_key(StdStorage storage self, uint256 amt) internal returns (StdStorage storage) {\\n return stdStorageSafe.with_key(self, amt);\\n }\\n\\n function with_key(StdStorage storage self, bytes32 key) internal returns (StdStorage storage) {\\n return stdStorageSafe.with_key(self, key);\\n }\\n\\n function with_calldata(StdStorage storage self, bytes memory _calldata) internal returns (StdStorage storage) {\\n return stdStorageSafe.with_calldata(self, _calldata);\\n }\\n\\n function enable_packed_slots(StdStorage storage self) internal returns (StdStorage storage) {\\n return stdStorageSafe.enable_packed_slots(self);\\n }\\n\\n function depth(StdStorage storage self, uint256 _depth) internal returns (StdStorage storage) {\\n return stdStorageSafe.depth(self, _depth);\\n }\\n\\n function clear(StdStorage storage self) internal {\\n stdStorageSafe.clear(self);\\n }\\n\\n function checked_write(StdStorage storage self, address who) internal {\\n checked_write(self, bytes32(uint256(uint160(who))));\\n }\\n\\n function checked_write(StdStorage storage self, uint256 amt) internal {\\n checked_write(self, bytes32(amt));\\n }\\n\\n function checked_write_int(StdStorage storage self, int256 val) internal {\\n checked_write(self, bytes32(uint256(val)));\\n }\\n\\n function checked_write(StdStorage storage self, bool write) internal {\\n bytes32 t;\\n /// @solidity memory-safe-assembly\\n assembly {\\n t := write\\n }\\n checked_write(self, t);\\n }\\n\\n function checked_write(StdStorage storage self, bytes32 set) internal {\\n address who = self._target;\\n bytes4 fsig = self._sig;\\n uint256 field_depth = self._depth;\\n bytes memory params = stdStorageSafe.getCallParams(self);\\n\\n if (!self.finds[who][fsig][keccak256(abi.encodePacked(params, field_depth))].found) {\\n find(self, false);\\n }\\n FindData storage data = self.finds[who][fsig][keccak256(abi.encodePacked(params, field_depth))];\\n if ((data.offsetLeft + data.offsetRight) > 0) {\\n uint256 maxVal = 2 ** (256 - (data.offsetLeft + data.offsetRight));\\n require(\\n uint256(set) < maxVal,\\n string(\\n abi.encodePacked(\\n \\\"stdStorage find(StdStorage): Packed slot. We can't fit value greater than \\\",\\n vm.toString(maxVal)\\n )\\n )\\n );\\n }\\n bytes32 curVal = vm.load(who, bytes32(data.slot));\\n bytes32 valToSet = stdStorageSafe.getUpdatedSlotValue(curVal, uint256(set), data.offsetLeft, data.offsetRight);\\n\\n vm.store(who, bytes32(data.slot), valToSet);\\n\\n (bool success, bytes32 callResult) = stdStorageSafe.callTarget(self);\\n\\n if (!success || callResult != set) {\\n vm.store(who, bytes32(data.slot), curVal);\\n revert(\\\"stdStorage find(StdStorage): Failed to write value.\\\");\\n }\\n clear(self);\\n }\\n\\n function read_bytes32(StdStorage storage self) internal returns (bytes32) {\\n return stdStorageSafe.read_bytes32(self);\\n }\\n\\n function read_bool(StdStorage storage self) internal returns (bool) {\\n return stdStorageSafe.read_bool(self);\\n }\\n\\n function read_address(StdStorage storage self) internal returns (address) {\\n return stdStorageSafe.read_address(self);\\n }\\n\\n function read_uint(StdStorage storage self) internal returns (uint256) {\\n return stdStorageSafe.read_uint(self);\\n }\\n\\n function read_int(StdStorage storage self) internal returns (int256) {\\n return stdStorageSafe.read_int(self);\\n }\\n\\n function parent(StdStorage storage self) internal returns (uint256, bytes32) {\\n return stdStorageSafe.parent(self);\\n }\\n\\n function root(StdStorage storage self) internal returns (uint256) {\\n return stdStorageSafe.root(self);\\n }\\n}\\n\",\"keccak256\":\"0xb91ab24383a5872b894fc93325eef1add6cbbf981628f18e860068bf88bb7dcc\",\"license\":\"MIT\"},\"lib/forge-std/src/StdStyle.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity >=0.4.22 <0.9.0;\\n\\nimport {VmSafe} from \\\"./Vm.sol\\\";\\n\\nlibrary StdStyle {\\n VmSafe private constant vm = VmSafe(address(uint160(uint256(keccak256(\\\"hevm cheat code\\\")))));\\n\\n string constant RED = \\\"\\\\u001b[91m\\\";\\n string constant GREEN = \\\"\\\\u001b[92m\\\";\\n string constant YELLOW = \\\"\\\\u001b[93m\\\";\\n string constant BLUE = \\\"\\\\u001b[94m\\\";\\n string constant MAGENTA = \\\"\\\\u001b[95m\\\";\\n string constant CYAN = \\\"\\\\u001b[96m\\\";\\n string constant BOLD = \\\"\\\\u001b[1m\\\";\\n string constant DIM = \\\"\\\\u001b[2m\\\";\\n string constant ITALIC = \\\"\\\\u001b[3m\\\";\\n string constant UNDERLINE = \\\"\\\\u001b[4m\\\";\\n string constant INVERSE = \\\"\\\\u001b[7m\\\";\\n string constant RESET = \\\"\\\\u001b[0m\\\";\\n\\n function styleConcat(string memory style, string memory self) private pure returns (string memory) {\\n return string(abi.encodePacked(style, self, RESET));\\n }\\n\\n function red(string memory self) internal pure returns (string memory) {\\n return styleConcat(RED, self);\\n }\\n\\n function red(uint256 self) internal pure returns (string memory) {\\n return red(vm.toString(self));\\n }\\n\\n function red(int256 self) internal pure returns (string memory) {\\n return red(vm.toString(self));\\n }\\n\\n function red(address self) internal pure returns (string memory) {\\n return red(vm.toString(self));\\n }\\n\\n function red(bool self) internal pure returns (string memory) {\\n return red(vm.toString(self));\\n }\\n\\n function redBytes(bytes memory self) internal pure returns (string memory) {\\n return red(vm.toString(self));\\n }\\n\\n function redBytes32(bytes32 self) internal pure returns (string memory) {\\n return red(vm.toString(self));\\n }\\n\\n function green(string memory self) internal pure returns (string memory) {\\n return styleConcat(GREEN, self);\\n }\\n\\n function green(uint256 self) internal pure returns (string memory) {\\n return green(vm.toString(self));\\n }\\n\\n function green(int256 self) internal pure returns (string memory) {\\n return green(vm.toString(self));\\n }\\n\\n function green(address self) internal pure returns (string memory) {\\n return green(vm.toString(self));\\n }\\n\\n function green(bool self) internal pure returns (string memory) {\\n return green(vm.toString(self));\\n }\\n\\n function greenBytes(bytes memory self) internal pure returns (string memory) {\\n return green(vm.toString(self));\\n }\\n\\n function greenBytes32(bytes32 self) internal pure returns (string memory) {\\n return green(vm.toString(self));\\n }\\n\\n function yellow(string memory self) internal pure returns (string memory) {\\n return styleConcat(YELLOW, self);\\n }\\n\\n function yellow(uint256 self) internal pure returns (string memory) {\\n return yellow(vm.toString(self));\\n }\\n\\n function yellow(int256 self) internal pure returns (string memory) {\\n return yellow(vm.toString(self));\\n }\\n\\n function yellow(address self) internal pure returns (string memory) {\\n return yellow(vm.toString(self));\\n }\\n\\n function yellow(bool self) internal pure returns (string memory) {\\n return yellow(vm.toString(self));\\n }\\n\\n function yellowBytes(bytes memory self) internal pure returns (string memory) {\\n return yellow(vm.toString(self));\\n }\\n\\n function yellowBytes32(bytes32 self) internal pure returns (string memory) {\\n return yellow(vm.toString(self));\\n }\\n\\n function blue(string memory self) internal pure returns (string memory) {\\n return styleConcat(BLUE, self);\\n }\\n\\n function blue(uint256 self) internal pure returns (string memory) {\\n return blue(vm.toString(self));\\n }\\n\\n function blue(int256 self) internal pure returns (string memory) {\\n return blue(vm.toString(self));\\n }\\n\\n function blue(address self) internal pure returns (string memory) {\\n return blue(vm.toString(self));\\n }\\n\\n function blue(bool self) internal pure returns (string memory) {\\n return blue(vm.toString(self));\\n }\\n\\n function blueBytes(bytes memory self) internal pure returns (string memory) {\\n return blue(vm.toString(self));\\n }\\n\\n function blueBytes32(bytes32 self) internal pure returns (string memory) {\\n return blue(vm.toString(self));\\n }\\n\\n function magenta(string memory self) internal pure returns (string memory) {\\n return styleConcat(MAGENTA, self);\\n }\\n\\n function magenta(uint256 self) internal pure returns (string memory) {\\n return magenta(vm.toString(self));\\n }\\n\\n function magenta(int256 self) internal pure returns (string memory) {\\n return magenta(vm.toString(self));\\n }\\n\\n function magenta(address self) internal pure returns (string memory) {\\n return magenta(vm.toString(self));\\n }\\n\\n function magenta(bool self) internal pure returns (string memory) {\\n return magenta(vm.toString(self));\\n }\\n\\n function magentaBytes(bytes memory self) internal pure returns (string memory) {\\n return magenta(vm.toString(self));\\n }\\n\\n function magentaBytes32(bytes32 self) internal pure returns (string memory) {\\n return magenta(vm.toString(self));\\n }\\n\\n function cyan(string memory self) internal pure returns (string memory) {\\n return styleConcat(CYAN, self);\\n }\\n\\n function cyan(uint256 self) internal pure returns (string memory) {\\n return cyan(vm.toString(self));\\n }\\n\\n function cyan(int256 self) internal pure returns (string memory) {\\n return cyan(vm.toString(self));\\n }\\n\\n function cyan(address self) internal pure returns (string memory) {\\n return cyan(vm.toString(self));\\n }\\n\\n function cyan(bool self) internal pure returns (string memory) {\\n return cyan(vm.toString(self));\\n }\\n\\n function cyanBytes(bytes memory self) internal pure returns (string memory) {\\n return cyan(vm.toString(self));\\n }\\n\\n function cyanBytes32(bytes32 self) internal pure returns (string memory) {\\n return cyan(vm.toString(self));\\n }\\n\\n function bold(string memory self) internal pure returns (string memory) {\\n return styleConcat(BOLD, self);\\n }\\n\\n function bold(uint256 self) internal pure returns (string memory) {\\n return bold(vm.toString(self));\\n }\\n\\n function bold(int256 self) internal pure returns (string memory) {\\n return bold(vm.toString(self));\\n }\\n\\n function bold(address self) internal pure returns (string memory) {\\n return bold(vm.toString(self));\\n }\\n\\n function bold(bool self) internal pure returns (string memory) {\\n return bold(vm.toString(self));\\n }\\n\\n function boldBytes(bytes memory self) internal pure returns (string memory) {\\n return bold(vm.toString(self));\\n }\\n\\n function boldBytes32(bytes32 self) internal pure returns (string memory) {\\n return bold(vm.toString(self));\\n }\\n\\n function dim(string memory self) internal pure returns (string memory) {\\n return styleConcat(DIM, self);\\n }\\n\\n function dim(uint256 self) internal pure returns (string memory) {\\n return dim(vm.toString(self));\\n }\\n\\n function dim(int256 self) internal pure returns (string memory) {\\n return dim(vm.toString(self));\\n }\\n\\n function dim(address self) internal pure returns (string memory) {\\n return dim(vm.toString(self));\\n }\\n\\n function dim(bool self) internal pure returns (string memory) {\\n return dim(vm.toString(self));\\n }\\n\\n function dimBytes(bytes memory self) internal pure returns (string memory) {\\n return dim(vm.toString(self));\\n }\\n\\n function dimBytes32(bytes32 self) internal pure returns (string memory) {\\n return dim(vm.toString(self));\\n }\\n\\n function italic(string memory self) internal pure returns (string memory) {\\n return styleConcat(ITALIC, self);\\n }\\n\\n function italic(uint256 self) internal pure returns (string memory) {\\n return italic(vm.toString(self));\\n }\\n\\n function italic(int256 self) internal pure returns (string memory) {\\n return italic(vm.toString(self));\\n }\\n\\n function italic(address self) internal pure returns (string memory) {\\n return italic(vm.toString(self));\\n }\\n\\n function italic(bool self) internal pure returns (string memory) {\\n return italic(vm.toString(self));\\n }\\n\\n function italicBytes(bytes memory self) internal pure returns (string memory) {\\n return italic(vm.toString(self));\\n }\\n\\n function italicBytes32(bytes32 self) internal pure returns (string memory) {\\n return italic(vm.toString(self));\\n }\\n\\n function underline(string memory self) internal pure returns (string memory) {\\n return styleConcat(UNDERLINE, self);\\n }\\n\\n function underline(uint256 self) internal pure returns (string memory) {\\n return underline(vm.toString(self));\\n }\\n\\n function underline(int256 self) internal pure returns (string memory) {\\n return underline(vm.toString(self));\\n }\\n\\n function underline(address self) internal pure returns (string memory) {\\n return underline(vm.toString(self));\\n }\\n\\n function underline(bool self) internal pure returns (string memory) {\\n return underline(vm.toString(self));\\n }\\n\\n function underlineBytes(bytes memory self) internal pure returns (string memory) {\\n return underline(vm.toString(self));\\n }\\n\\n function underlineBytes32(bytes32 self) internal pure returns (string memory) {\\n return underline(vm.toString(self));\\n }\\n\\n function inverse(string memory self) internal pure returns (string memory) {\\n return styleConcat(INVERSE, self);\\n }\\n\\n function inverse(uint256 self) internal pure returns (string memory) {\\n return inverse(vm.toString(self));\\n }\\n\\n function inverse(int256 self) internal pure returns (string memory) {\\n return inverse(vm.toString(self));\\n }\\n\\n function inverse(address self) internal pure returns (string memory) {\\n return inverse(vm.toString(self));\\n }\\n\\n function inverse(bool self) internal pure returns (string memory) {\\n return inverse(vm.toString(self));\\n }\\n\\n function inverseBytes(bytes memory self) internal pure returns (string memory) {\\n return inverse(vm.toString(self));\\n }\\n\\n function inverseBytes32(bytes32 self) internal pure returns (string memory) {\\n return inverse(vm.toString(self));\\n }\\n}\\n\",\"keccak256\":\"0x43e2a8a9b9c2574dabe74f11adf6f782df218f463540e3b5b563609fe108597d\",\"license\":\"MIT\"},\"lib/forge-std/src/StdUtils.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity >=0.6.2 <0.9.0;\\n\\npragma experimental ABIEncoderV2;\\n\\nimport {IMulticall3} from \\\"./interfaces/IMulticall3.sol\\\";\\nimport {VmSafe} from \\\"./Vm.sol\\\";\\n\\nabstract contract StdUtils {\\n /*//////////////////////////////////////////////////////////////////////////\\n CONSTANTS\\n //////////////////////////////////////////////////////////////////////////*/\\n\\n IMulticall3 private constant multicall = IMulticall3(0xcA11bde05977b3631167028862bE2a173976CA11);\\n VmSafe private constant vm = VmSafe(address(uint160(uint256(keccak256(\\\"hevm cheat code\\\")))));\\n address private constant CONSOLE2_ADDRESS = 0x000000000000000000636F6e736F6c652e6c6f67;\\n uint256 private constant INT256_MIN_ABS =\\n 57896044618658097711785492504343953926634992332820282019728792003956564819968;\\n uint256 private constant SECP256K1_ORDER =\\n 115792089237316195423570985008687907852837564279074904382605163141518161494337;\\n uint256 private constant UINT256_MAX =\\n 115792089237316195423570985008687907853269984665640564039457584007913129639935;\\n\\n // Used by default when deploying with create2, https://github.com/Arachnid/deterministic-deployment-proxy.\\n address private constant CREATE2_FACTORY = 0x4e59b44847b379578588920cA78FbF26c0B4956C;\\n\\n /*//////////////////////////////////////////////////////////////////////////\\n INTERNAL FUNCTIONS\\n //////////////////////////////////////////////////////////////////////////*/\\n\\n function _bound(uint256 x, uint256 min, uint256 max) internal pure virtual returns (uint256 result) {\\n require(min <= max, \\\"StdUtils bound(uint256,uint256,uint256): Max is less than min.\\\");\\n // If x is between min and max, return x directly. This is to ensure that dictionary values\\n // do not get shifted if the min is nonzero. More info: https://github.com/foundry-rs/forge-std/issues/188\\n if (x >= min && x <= max) return x;\\n\\n uint256 size = max - min + 1;\\n\\n // If the value is 0, 1, 2, 3, wrap that to min, min+1, min+2, min+3. Similarly for the UINT256_MAX side.\\n // This helps ensure coverage of the min/max values.\\n if (x <= 3 && size > x) return min + x;\\n if (x >= UINT256_MAX - 3 && size > UINT256_MAX - x) return max - (UINT256_MAX - x);\\n\\n // Otherwise, wrap x into the range [min, max], i.e. the range is inclusive.\\n if (x > max) {\\n uint256 diff = x - max;\\n uint256 rem = diff % size;\\n if (rem == 0) return max;\\n result = min + rem - 1;\\n } else if (x < min) {\\n uint256 diff = min - x;\\n uint256 rem = diff % size;\\n if (rem == 0) return min;\\n result = max - rem + 1;\\n }\\n }\\n\\n function bound(uint256 x, uint256 min, uint256 max) internal pure virtual returns (uint256 result) {\\n result = _bound(x, min, max);\\n console2_log_StdUtils(\\\"Bound result\\\", result);\\n }\\n\\n function _bound(int256 x, int256 min, int256 max) internal pure virtual returns (int256 result) {\\n require(min <= max, \\\"StdUtils bound(int256,int256,int256): Max is less than min.\\\");\\n\\n // Shifting all int256 values to uint256 to use _bound function. The range of two types are:\\n // int256 : -(2**255) ~ (2**255 - 1)\\n // uint256: 0 ~ (2**256 - 1)\\n // So, add 2**255, INT256_MIN_ABS to the integer values.\\n //\\n // If the given integer value is -2**255, we cannot use `-uint256(-x)` because of the overflow.\\n // So, use `~uint256(x) + 1` instead.\\n uint256 _x = x < 0 ? (INT256_MIN_ABS - ~uint256(x) - 1) : (uint256(x) + INT256_MIN_ABS);\\n uint256 _min = min < 0 ? (INT256_MIN_ABS - ~uint256(min) - 1) : (uint256(min) + INT256_MIN_ABS);\\n uint256 _max = max < 0 ? (INT256_MIN_ABS - ~uint256(max) - 1) : (uint256(max) + INT256_MIN_ABS);\\n\\n uint256 y = _bound(_x, _min, _max);\\n\\n // To move it back to int256 value, subtract INT256_MIN_ABS at here.\\n result = y < INT256_MIN_ABS ? int256(~(INT256_MIN_ABS - y) + 1) : int256(y - INT256_MIN_ABS);\\n }\\n\\n function bound(int256 x, int256 min, int256 max) internal pure virtual returns (int256 result) {\\n result = _bound(x, min, max);\\n console2_log_StdUtils(\\\"Bound result\\\", vm.toString(result));\\n }\\n\\n function boundPrivateKey(uint256 privateKey) internal pure virtual returns (uint256 result) {\\n result = _bound(privateKey, 1, SECP256K1_ORDER - 1);\\n }\\n\\n function bytesToUint(bytes memory b) internal pure virtual returns (uint256) {\\n require(b.length <= 32, \\\"StdUtils bytesToUint(bytes): Bytes length exceeds 32.\\\");\\n return abi.decode(abi.encodePacked(new bytes(32 - b.length), b), (uint256));\\n }\\n\\n /// @dev Compute the address a contract will be deployed at for a given deployer address and nonce\\n /// @notice adapted from Solmate implementation (https://github.com/Rari-Capital/solmate/blob/main/src/utils/LibRLP.sol)\\n function computeCreateAddress(address deployer, uint256 nonce) internal pure virtual returns (address) {\\n console2_log_StdUtils(\\\"computeCreateAddress is deprecated. Please use vm.computeCreateAddress instead.\\\");\\n return vm.computeCreateAddress(deployer, nonce);\\n }\\n\\n function computeCreate2Address(bytes32 salt, bytes32 initcodeHash, address deployer)\\n internal\\n pure\\n virtual\\n returns (address)\\n {\\n console2_log_StdUtils(\\\"computeCreate2Address is deprecated. Please use vm.computeCreate2Address instead.\\\");\\n return vm.computeCreate2Address(salt, initcodeHash, deployer);\\n }\\n\\n /// @dev returns the address of a contract created with CREATE2 using the default CREATE2 deployer\\n function computeCreate2Address(bytes32 salt, bytes32 initCodeHash) internal pure returns (address) {\\n console2_log_StdUtils(\\\"computeCreate2Address is deprecated. Please use vm.computeCreate2Address instead.\\\");\\n return vm.computeCreate2Address(salt, initCodeHash);\\n }\\n\\n /// @dev returns the hash of the init code (creation code + no args) used in CREATE2 with no constructor arguments\\n /// @param creationCode the creation code of a contract C, as returned by type(C).creationCode\\n function hashInitCode(bytes memory creationCode) internal pure returns (bytes32) {\\n return hashInitCode(creationCode, \\\"\\\");\\n }\\n\\n /// @dev returns the hash of the init code (creation code + ABI-encoded args) used in CREATE2\\n /// @param creationCode the creation code of a contract C, as returned by type(C).creationCode\\n /// @param args the ABI-encoded arguments to the constructor of C\\n function hashInitCode(bytes memory creationCode, bytes memory args) internal pure returns (bytes32) {\\n return keccak256(abi.encodePacked(creationCode, args));\\n }\\n\\n // Performs a single call with Multicall3 to query the ERC-20 token balances of the given addresses.\\n function getTokenBalances(address token, address[] memory addresses)\\n internal\\n virtual\\n returns (uint256[] memory balances)\\n {\\n uint256 tokenCodeSize;\\n assembly {\\n tokenCodeSize := extcodesize(token)\\n }\\n require(tokenCodeSize > 0, \\\"StdUtils getTokenBalances(address,address[]): Token address is not a contract.\\\");\\n\\n // ABI encode the aggregate call to Multicall3.\\n uint256 length = addresses.length;\\n IMulticall3.Call[] memory calls = new IMulticall3.Call[](length);\\n for (uint256 i = 0; i < length; ++i) {\\n // 0x70a08231 = bytes4(\\\"balanceOf(address)\\\"))\\n calls[i] = IMulticall3.Call({target: token, callData: abi.encodeWithSelector(0x70a08231, (addresses[i]))});\\n }\\n\\n // Make the aggregate call.\\n (, bytes[] memory returnData) = multicall.aggregate(calls);\\n\\n // ABI decode the return data and return the balances.\\n balances = new uint256[](length);\\n for (uint256 i = 0; i < length; ++i) {\\n balances[i] = abi.decode(returnData[i], (uint256));\\n }\\n }\\n\\n /*//////////////////////////////////////////////////////////////////////////\\n PRIVATE FUNCTIONS\\n //////////////////////////////////////////////////////////////////////////*/\\n\\n function addressFromLast20Bytes(bytes32 bytesValue) private pure returns (address) {\\n return address(uint160(uint256(bytesValue)));\\n }\\n\\n // This section is used to prevent the compilation of console, which shortens the compilation time when console is\\n // not used elsewhere. We also trick the compiler into letting us make the console log methods as `pure` to avoid\\n // any breaking changes to function signatures.\\n function _castLogPayloadViewToPure(function(bytes memory) internal view fnIn)\\n internal\\n pure\\n returns (function(bytes memory) internal pure fnOut)\\n {\\n assembly {\\n fnOut := fnIn\\n }\\n }\\n\\n function _sendLogPayload(bytes memory payload) internal pure {\\n _castLogPayloadViewToPure(_sendLogPayloadView)(payload);\\n }\\n\\n function _sendLogPayloadView(bytes memory payload) private view {\\n uint256 payloadLength = payload.length;\\n address consoleAddress = CONSOLE2_ADDRESS;\\n /// @solidity memory-safe-assembly\\n assembly {\\n let payloadStart := add(payload, 32)\\n let r := staticcall(gas(), consoleAddress, payloadStart, payloadLength, 0, 0)\\n }\\n }\\n\\n function console2_log_StdUtils(string memory p0) private pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string)\\\", p0));\\n }\\n\\n function console2_log_StdUtils(string memory p0, uint256 p1) private pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,uint256)\\\", p0, p1));\\n }\\n\\n function console2_log_StdUtils(string memory p0, string memory p1) private pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,string)\\\", p0, p1));\\n }\\n}\\n\",\"keccak256\":\"0x7274081e11c05164fd8eadde4de8305c033e58a43008dea58065f3170ccf0737\",\"license\":\"MIT\"},\"lib/forge-std/src/Vm.sol\":{\"content\":\"// Automatically @generated by scripts/vm.py. Do not modify manually.\\n\\n// SPDX-License-Identifier: MIT OR Apache-2.0\\npragma solidity >=0.6.2 <0.9.0;\\npragma experimental ABIEncoderV2;\\n\\n/// The `VmSafe` interface does not allow manipulation of the EVM state or other actions that may\\n/// result in Script simulations differing from on-chain execution. It is recommended to only use\\n/// these cheats in scripts.\\ninterface VmSafe {\\n /// A modification applied to either `msg.sender` or `tx.origin`. Returned by `readCallers`.\\n enum CallerMode {\\n // No caller modification is currently active.\\n None,\\n // A one time broadcast triggered by a `vm.broadcast()` call is currently active.\\n Broadcast,\\n // A recurrent broadcast triggered by a `vm.startBroadcast()` call is currently active.\\n RecurrentBroadcast,\\n // A one time prank triggered by a `vm.prank()` call is currently active.\\n Prank,\\n // A recurrent prank triggered by a `vm.startPrank()` call is currently active.\\n RecurrentPrank\\n }\\n\\n /// The kind of account access that occurred.\\n enum AccountAccessKind {\\n // The account was called.\\n Call,\\n // The account was called via delegatecall.\\n DelegateCall,\\n // The account was called via callcode.\\n CallCode,\\n // The account was called via staticcall.\\n StaticCall,\\n // The account was created.\\n Create,\\n // The account was selfdestructed.\\n SelfDestruct,\\n // Synthetic access indicating the current context has resumed after a previous sub-context (AccountAccess).\\n Resume,\\n // The account's balance was read.\\n Balance,\\n // The account's codesize was read.\\n Extcodesize,\\n // The account's codehash was read.\\n Extcodehash,\\n // The account's code was copied.\\n Extcodecopy\\n }\\n\\n /// Forge execution contexts.\\n enum ForgeContext {\\n // Test group execution context (test, coverage or snapshot).\\n TestGroup,\\n // `forge test` execution context.\\n Test,\\n // `forge coverage` execution context.\\n Coverage,\\n // `forge snapshot` execution context.\\n Snapshot,\\n // Script group execution context (dry run, broadcast or resume).\\n ScriptGroup,\\n // `forge script` execution context.\\n ScriptDryRun,\\n // `forge script --broadcast` execution context.\\n ScriptBroadcast,\\n // `forge script --resume` execution context.\\n ScriptResume,\\n // Unknown `forge` execution context.\\n Unknown\\n }\\n\\n /// The transaction type (`txType`) of the broadcast.\\n enum BroadcastTxType {\\n // Represents a CALL broadcast tx.\\n Call,\\n // Represents a CREATE broadcast tx.\\n Create,\\n // Represents a CREATE2 broadcast tx.\\n Create2\\n }\\n\\n /// An Ethereum log. Returned by `getRecordedLogs`.\\n struct Log {\\n // The topics of the log, including the signature, if any.\\n bytes32[] topics;\\n // The raw data of the log.\\n bytes data;\\n // The address of the log's emitter.\\n address emitter;\\n }\\n\\n /// An RPC URL and its alias. Returned by `rpcUrlStructs`.\\n struct Rpc {\\n // The alias of the RPC URL.\\n string key;\\n // The RPC URL.\\n string url;\\n }\\n\\n /// An RPC log object. Returned by `eth_getLogs`.\\n struct EthGetLogs {\\n // The address of the log's emitter.\\n address emitter;\\n // The topics of the log, including the signature, if any.\\n bytes32[] topics;\\n // The raw data of the log.\\n bytes data;\\n // The block hash.\\n bytes32 blockHash;\\n // The block number.\\n uint64 blockNumber;\\n // The transaction hash.\\n bytes32 transactionHash;\\n // The transaction index in the block.\\n uint64 transactionIndex;\\n // The log index.\\n uint256 logIndex;\\n // Whether the log was removed.\\n bool removed;\\n }\\n\\n /// A single entry in a directory listing. Returned by `readDir`.\\n struct DirEntry {\\n // The error message, if any.\\n string errorMessage;\\n // The path of the entry.\\n string path;\\n // The depth of the entry.\\n uint64 depth;\\n // Whether the entry is a directory.\\n bool isDir;\\n // Whether the entry is a symlink.\\n bool isSymlink;\\n }\\n\\n /// Metadata information about a file.\\n /// This structure is returned from the `fsMetadata` function and represents known\\n /// metadata about a file such as its permissions, size, modification\\n /// times, etc.\\n struct FsMetadata {\\n // True if this metadata is for a directory.\\n bool isDir;\\n // True if this metadata is for a symlink.\\n bool isSymlink;\\n // The size of the file, in bytes, this metadata is for.\\n uint256 length;\\n // True if this metadata is for a readonly (unwritable) file.\\n bool readOnly;\\n // The last modification time listed in this metadata.\\n uint256 modified;\\n // The last access time of this metadata.\\n uint256 accessed;\\n // The creation time listed in this metadata.\\n uint256 created;\\n }\\n\\n /// A wallet with a public and private key.\\n struct Wallet {\\n // The wallet's address.\\n address addr;\\n // The wallet's public key `X`.\\n uint256 publicKeyX;\\n // The wallet's public key `Y`.\\n uint256 publicKeyY;\\n // The wallet's private key.\\n uint256 privateKey;\\n }\\n\\n /// The result of a `tryFfi` call.\\n struct FfiResult {\\n // The exit code of the call.\\n int32 exitCode;\\n // The optionally hex-decoded `stdout` data.\\n bytes stdout;\\n // The `stderr` data.\\n bytes stderr;\\n }\\n\\n /// Information on the chain and fork.\\n struct ChainInfo {\\n // The fork identifier. Set to zero if no fork is active.\\n uint256 forkId;\\n // The chain ID of the current fork.\\n uint256 chainId;\\n }\\n\\n /// The result of a `stopAndReturnStateDiff` call.\\n struct AccountAccess {\\n // The chain and fork the access occurred.\\n ChainInfo chainInfo;\\n // The kind of account access that determines what the account is.\\n // If kind is Call, DelegateCall, StaticCall or CallCode, then the account is the callee.\\n // If kind is Create, then the account is the newly created account.\\n // If kind is SelfDestruct, then the account is the selfdestruct recipient.\\n // If kind is a Resume, then account represents a account context that has resumed.\\n AccountAccessKind kind;\\n // The account that was accessed.\\n // It's either the account created, callee or a selfdestruct recipient for CREATE, CALL or SELFDESTRUCT.\\n address account;\\n // What accessed the account.\\n address accessor;\\n // If the account was initialized or empty prior to the access.\\n // An account is considered initialized if it has code, a\\n // non-zero nonce, or a non-zero balance.\\n bool initialized;\\n // The previous balance of the accessed account.\\n uint256 oldBalance;\\n // The potential new balance of the accessed account.\\n // That is, all balance changes are recorded here, even if reverts occurred.\\n uint256 newBalance;\\n // Code of the account deployed by CREATE.\\n bytes deployedCode;\\n // Value passed along with the account access\\n uint256 value;\\n // Input data provided to the CREATE or CALL\\n bytes data;\\n // If this access reverted in either the current or parent context.\\n bool reverted;\\n // An ordered list of storage accesses made during an account access operation.\\n StorageAccess[] storageAccesses;\\n // Call depth traversed during the recording of state differences\\n uint64 depth;\\n }\\n\\n /// The storage accessed during an `AccountAccess`.\\n struct StorageAccess {\\n // The account whose storage was accessed.\\n address account;\\n // The slot that was accessed.\\n bytes32 slot;\\n // If the access was a write.\\n bool isWrite;\\n // The previous value of the slot.\\n bytes32 previousValue;\\n // The new value of the slot.\\n bytes32 newValue;\\n // If the access was reverted.\\n bool reverted;\\n }\\n\\n /// Gas used. Returned by `lastCallGas`.\\n struct Gas {\\n // The gas limit of the call.\\n uint64 gasLimit;\\n // The total gas used.\\n uint64 gasTotalUsed;\\n // DEPRECATED: The amount of gas used for memory expansion. Ref: \\n uint64 gasMemoryUsed;\\n // The amount of gas refunded.\\n int64 gasRefunded;\\n // The amount of gas remaining.\\n uint64 gasRemaining;\\n }\\n\\n /// The result of the `stopDebugTraceRecording` call\\n struct DebugStep {\\n // The stack before executing the step of the run.\\n // stack\\\\[0\\\\] represents the top of the stack.\\n // and only stack data relevant to the opcode execution is contained.\\n uint256[] stack;\\n // The memory input data before executing the step of the run.\\n // only input data relevant to the opcode execution is contained.\\n // e.g. for MLOAD, it will have memory\\\\[offset:offset+32\\\\] copied here.\\n // the offset value can be get by the stack data.\\n bytes memoryInput;\\n // The opcode that was accessed.\\n uint8 opcode;\\n // The call depth of the step.\\n uint64 depth;\\n // Whether the call end up with out of gas error.\\n bool isOutOfGas;\\n // The contract address where the opcode is running\\n address contractAddr;\\n }\\n\\n /// Represents a transaction's broadcast details.\\n struct BroadcastTxSummary {\\n // The hash of the transaction that was broadcasted\\n bytes32 txHash;\\n // Represent the type of transaction among CALL, CREATE, CREATE2\\n BroadcastTxType txType;\\n // The address of the contract that was called or created.\\n // This is address of the contract that is created if the txType is CREATE or CREATE2.\\n address contractAddress;\\n // The block number the transaction landed in.\\n uint64 blockNumber;\\n // Status of the transaction, retrieved from the transaction receipt.\\n bool success;\\n }\\n\\n /// Holds a signed EIP-7702 authorization for an authority account to delegate to an implementation.\\n struct SignedDelegation {\\n // The y-parity of the recovered secp256k1 signature (0 or 1).\\n uint8 v;\\n // First 32 bytes of the signature.\\n bytes32 r;\\n // Second 32 bytes of the signature.\\n bytes32 s;\\n // The current nonce of the authority account at signing time.\\n // Used to ensure signature can't be replayed after account nonce changes.\\n uint64 nonce;\\n // Address of the contract implementation that will be delegated to.\\n // Gets encoded into delegation code: 0xef0100 || implementation.\\n address implementation;\\n }\\n\\n /// Represents a \\\"potential\\\" revert reason from a single subsequent call when using `vm.assumeNoReverts`.\\n /// Reverts that match will result in a FOUNDRY::ASSUME rejection, whereas unmatched reverts will be surfaced\\n /// as normal.\\n struct PotentialRevert {\\n // The allowed origin of the revert opcode; address(0) allows reverts from any address\\n address reverter;\\n // When true, only matches on the beginning of the revert data, otherwise, matches on entire revert data\\n bool partialMatch;\\n // The data to use to match encountered reverts\\n bytes revertData;\\n }\\n\\n /// An EIP-2930 access list item.\\n struct AccessListItem {\\n // The address to be added in access list.\\n address target;\\n // The storage keys to be added in access list.\\n bytes32[] storageKeys;\\n }\\n\\n // ======== Crypto ========\\n\\n /// Derives a private key from the name, labels the account with that name, and returns the wallet.\\n function createWallet(string calldata walletLabel) external returns (Wallet memory wallet);\\n\\n /// Generates a wallet from the private key and returns the wallet.\\n function createWallet(uint256 privateKey) external returns (Wallet memory wallet);\\n\\n /// Generates a wallet from the private key, labels the account with that name, and returns the wallet.\\n function createWallet(uint256 privateKey, string calldata walletLabel) external returns (Wallet memory wallet);\\n\\n /// Derive a private key from a provided mnenomic string (or mnenomic file path)\\n /// at the derivation path `m/44'/60'/0'/0/{index}`.\\n function deriveKey(string calldata mnemonic, uint32 index) external pure returns (uint256 privateKey);\\n\\n /// Derive a private key from a provided mnenomic string (or mnenomic file path)\\n /// at `{derivationPath}{index}`.\\n function deriveKey(string calldata mnemonic, string calldata derivationPath, uint32 index)\\n external\\n pure\\n returns (uint256 privateKey);\\n\\n /// Derive a private key from a provided mnenomic string (or mnenomic file path) in the specified language\\n /// at the derivation path `m/44'/60'/0'/0/{index}`.\\n function deriveKey(string calldata mnemonic, uint32 index, string calldata language)\\n external\\n pure\\n returns (uint256 privateKey);\\n\\n /// Derive a private key from a provided mnenomic string (or mnenomic file path) in the specified language\\n /// at `{derivationPath}{index}`.\\n function deriveKey(string calldata mnemonic, string calldata derivationPath, uint32 index, string calldata language)\\n external\\n pure\\n returns (uint256 privateKey);\\n\\n /// Derives secp256r1 public key from the provided `privateKey`.\\n function publicKeyP256(uint256 privateKey) external pure returns (uint256 publicKeyX, uint256 publicKeyY);\\n\\n /// Adds a private key to the local forge wallet and returns the address.\\n function rememberKey(uint256 privateKey) external returns (address keyAddr);\\n\\n /// Derive a set number of wallets from a mnemonic at the derivation path `m/44'/60'/0'/0/{0..count}`.\\n /// The respective private keys are saved to the local forge wallet for later use and their addresses are returned.\\n function rememberKeys(string calldata mnemonic, string calldata derivationPath, uint32 count)\\n external\\n returns (address[] memory keyAddrs);\\n\\n /// Derive a set number of wallets from a mnemonic in the specified language at the derivation path `m/44'/60'/0'/0/{0..count}`.\\n /// The respective private keys are saved to the local forge wallet for later use and their addresses are returned.\\n function rememberKeys(\\n string calldata mnemonic,\\n string calldata derivationPath,\\n string calldata language,\\n uint32 count\\n ) external returns (address[] memory keyAddrs);\\n\\n /// Signs data with a `Wallet`.\\n /// Returns a compact signature (`r`, `vs`) as per EIP-2098, where `vs` encodes both the\\n /// signature's `s` value, and the recovery id `v` in a single bytes32.\\n /// This format reduces the signature size from 65 to 64 bytes.\\n function signCompact(Wallet calldata wallet, bytes32 digest) external returns (bytes32 r, bytes32 vs);\\n\\n /// Signs `digest` with `privateKey` using the secp256k1 curve.\\n /// Returns a compact signature (`r`, `vs`) as per EIP-2098, where `vs` encodes both the\\n /// signature's `s` value, and the recovery id `v` in a single bytes32.\\n /// This format reduces the signature size from 65 to 64 bytes.\\n function signCompact(uint256 privateKey, bytes32 digest) external pure returns (bytes32 r, bytes32 vs);\\n\\n /// Signs `digest` with signer provided to script using the secp256k1 curve.\\n /// Returns a compact signature (`r`, `vs`) as per EIP-2098, where `vs` encodes both the\\n /// signature's `s` value, and the recovery id `v` in a single bytes32.\\n /// This format reduces the signature size from 65 to 64 bytes.\\n /// If `--sender` is provided, the signer with provided address is used, otherwise,\\n /// if exactly one signer is provided to the script, that signer is used.\\n /// Raises error if signer passed through `--sender` does not match any unlocked signers or\\n /// if `--sender` is not provided and not exactly one signer is passed to the script.\\n function signCompact(bytes32 digest) external pure returns (bytes32 r, bytes32 vs);\\n\\n /// Signs `digest` with signer provided to script using the secp256k1 curve.\\n /// Returns a compact signature (`r`, `vs`) as per EIP-2098, where `vs` encodes both the\\n /// signature's `s` value, and the recovery id `v` in a single bytes32.\\n /// This format reduces the signature size from 65 to 64 bytes.\\n /// Raises error if none of the signers passed into the script have provided address.\\n function signCompact(address signer, bytes32 digest) external pure returns (bytes32 r, bytes32 vs);\\n\\n /// Signs `digest` with `privateKey` using the secp256r1 curve.\\n function signP256(uint256 privateKey, bytes32 digest) external pure returns (bytes32 r, bytes32 s);\\n\\n /// Signs data with a `Wallet`.\\n function sign(Wallet calldata wallet, bytes32 digest) external returns (uint8 v, bytes32 r, bytes32 s);\\n\\n /// Signs `digest` with `privateKey` using the secp256k1 curve.\\n function sign(uint256 privateKey, bytes32 digest) external pure returns (uint8 v, bytes32 r, bytes32 s);\\n\\n /// Signs `digest` with signer provided to script using the secp256k1 curve.\\n /// If `--sender` is provided, the signer with provided address is used, otherwise,\\n /// if exactly one signer is provided to the script, that signer is used.\\n /// Raises error if signer passed through `--sender` does not match any unlocked signers or\\n /// if `--sender` is not provided and not exactly one signer is passed to the script.\\n function sign(bytes32 digest) external pure returns (uint8 v, bytes32 r, bytes32 s);\\n\\n /// Signs `digest` with signer provided to script using the secp256k1 curve.\\n /// Raises error if none of the signers passed into the script have provided address.\\n function sign(address signer, bytes32 digest) external pure returns (uint8 v, bytes32 r, bytes32 s);\\n\\n // ======== Environment ========\\n\\n /// Gets the environment variable `name` and parses it as `address`.\\n /// Reverts if the variable was not found or could not be parsed.\\n function envAddress(string calldata name) external view returns (address value);\\n\\n /// Gets the environment variable `name` and parses it as an array of `address`, delimited by `delim`.\\n /// Reverts if the variable was not found or could not be parsed.\\n function envAddress(string calldata name, string calldata delim) external view returns (address[] memory value);\\n\\n /// Gets the environment variable `name` and parses it as `bool`.\\n /// Reverts if the variable was not found or could not be parsed.\\n function envBool(string calldata name) external view returns (bool value);\\n\\n /// Gets the environment variable `name` and parses it as an array of `bool`, delimited by `delim`.\\n /// Reverts if the variable was not found or could not be parsed.\\n function envBool(string calldata name, string calldata delim) external view returns (bool[] memory value);\\n\\n /// Gets the environment variable `name` and parses it as `bytes32`.\\n /// Reverts if the variable was not found or could not be parsed.\\n function envBytes32(string calldata name) external view returns (bytes32 value);\\n\\n /// Gets the environment variable `name` and parses it as an array of `bytes32`, delimited by `delim`.\\n /// Reverts if the variable was not found or could not be parsed.\\n function envBytes32(string calldata name, string calldata delim) external view returns (bytes32[] memory value);\\n\\n /// Gets the environment variable `name` and parses it as `bytes`.\\n /// Reverts if the variable was not found or could not be parsed.\\n function envBytes(string calldata name) external view returns (bytes memory value);\\n\\n /// Gets the environment variable `name` and parses it as an array of `bytes`, delimited by `delim`.\\n /// Reverts if the variable was not found or could not be parsed.\\n function envBytes(string calldata name, string calldata delim) external view returns (bytes[] memory value);\\n\\n /// Gets the environment variable `name` and returns true if it exists, else returns false.\\n function envExists(string calldata name) external view returns (bool result);\\n\\n /// Gets the environment variable `name` and parses it as `int256`.\\n /// Reverts if the variable was not found or could not be parsed.\\n function envInt(string calldata name) external view returns (int256 value);\\n\\n /// Gets the environment variable `name` and parses it as an array of `int256`, delimited by `delim`.\\n /// Reverts if the variable was not found or could not be parsed.\\n function envInt(string calldata name, string calldata delim) external view returns (int256[] memory value);\\n\\n /// Gets the environment variable `name` and parses it as `bool`.\\n /// Reverts if the variable could not be parsed.\\n /// Returns `defaultValue` if the variable was not found.\\n function envOr(string calldata name, bool defaultValue) external view returns (bool value);\\n\\n /// Gets the environment variable `name` and parses it as `uint256`.\\n /// Reverts if the variable could not be parsed.\\n /// Returns `defaultValue` if the variable was not found.\\n function envOr(string calldata name, uint256 defaultValue) external view returns (uint256 value);\\n\\n /// Gets the environment variable `name` and parses it as an array of `address`, delimited by `delim`.\\n /// Reverts if the variable could not be parsed.\\n /// Returns `defaultValue` if the variable was not found.\\n function envOr(string calldata name, string calldata delim, address[] calldata defaultValue)\\n external\\n view\\n returns (address[] memory value);\\n\\n /// Gets the environment variable `name` and parses it as an array of `bytes32`, delimited by `delim`.\\n /// Reverts if the variable could not be parsed.\\n /// Returns `defaultValue` if the variable was not found.\\n function envOr(string calldata name, string calldata delim, bytes32[] calldata defaultValue)\\n external\\n view\\n returns (bytes32[] memory value);\\n\\n /// Gets the environment variable `name` and parses it as an array of `string`, delimited by `delim`.\\n /// Reverts if the variable could not be parsed.\\n /// Returns `defaultValue` if the variable was not found.\\n function envOr(string calldata name, string calldata delim, string[] calldata defaultValue)\\n external\\n view\\n returns (string[] memory value);\\n\\n /// Gets the environment variable `name` and parses it as an array of `bytes`, delimited by `delim`.\\n /// Reverts if the variable could not be parsed.\\n /// Returns `defaultValue` if the variable was not found.\\n function envOr(string calldata name, string calldata delim, bytes[] calldata defaultValue)\\n external\\n view\\n returns (bytes[] memory value);\\n\\n /// Gets the environment variable `name` and parses it as `int256`.\\n /// Reverts if the variable could not be parsed.\\n /// Returns `defaultValue` if the variable was not found.\\n function envOr(string calldata name, int256 defaultValue) external view returns (int256 value);\\n\\n /// Gets the environment variable `name` and parses it as `address`.\\n /// Reverts if the variable could not be parsed.\\n /// Returns `defaultValue` if the variable was not found.\\n function envOr(string calldata name, address defaultValue) external view returns (address value);\\n\\n /// Gets the environment variable `name` and parses it as `bytes32`.\\n /// Reverts if the variable could not be parsed.\\n /// Returns `defaultValue` if the variable was not found.\\n function envOr(string calldata name, bytes32 defaultValue) external view returns (bytes32 value);\\n\\n /// Gets the environment variable `name` and parses it as `string`.\\n /// Reverts if the variable could not be parsed.\\n /// Returns `defaultValue` if the variable was not found.\\n function envOr(string calldata name, string calldata defaultValue) external view returns (string memory value);\\n\\n /// Gets the environment variable `name` and parses it as `bytes`.\\n /// Reverts if the variable could not be parsed.\\n /// Returns `defaultValue` if the variable was not found.\\n function envOr(string calldata name, bytes calldata defaultValue) external view returns (bytes memory value);\\n\\n /// Gets the environment variable `name` and parses it as an array of `bool`, delimited by `delim`.\\n /// Reverts if the variable could not be parsed.\\n /// Returns `defaultValue` if the variable was not found.\\n function envOr(string calldata name, string calldata delim, bool[] calldata defaultValue)\\n external\\n view\\n returns (bool[] memory value);\\n\\n /// Gets the environment variable `name` and parses it as an array of `uint256`, delimited by `delim`.\\n /// Reverts if the variable could not be parsed.\\n /// Returns `defaultValue` if the variable was not found.\\n function envOr(string calldata name, string calldata delim, uint256[] calldata defaultValue)\\n external\\n view\\n returns (uint256[] memory value);\\n\\n /// Gets the environment variable `name` and parses it as an array of `int256`, delimited by `delim`.\\n /// Reverts if the variable could not be parsed.\\n /// Returns `defaultValue` if the variable was not found.\\n function envOr(string calldata name, string calldata delim, int256[] calldata defaultValue)\\n external\\n view\\n returns (int256[] memory value);\\n\\n /// Gets the environment variable `name` and parses it as `string`.\\n /// Reverts if the variable was not found or could not be parsed.\\n function envString(string calldata name) external view returns (string memory value);\\n\\n /// Gets the environment variable `name` and parses it as an array of `string`, delimited by `delim`.\\n /// Reverts if the variable was not found or could not be parsed.\\n function envString(string calldata name, string calldata delim) external view returns (string[] memory value);\\n\\n /// Gets the environment variable `name` and parses it as `uint256`.\\n /// Reverts if the variable was not found or could not be parsed.\\n function envUint(string calldata name) external view returns (uint256 value);\\n\\n /// Gets the environment variable `name` and parses it as an array of `uint256`, delimited by `delim`.\\n /// Reverts if the variable was not found or could not be parsed.\\n function envUint(string calldata name, string calldata delim) external view returns (uint256[] memory value);\\n\\n /// Returns true if `forge` command was executed in given context.\\n function isContext(ForgeContext context) external view returns (bool result);\\n\\n /// Sets environment variables.\\n function setEnv(string calldata name, string calldata value) external;\\n\\n // ======== EVM ========\\n\\n /// Gets all accessed reads and write slot from a `vm.record` session, for a given address.\\n function accesses(address target) external returns (bytes32[] memory readSlots, bytes32[] memory writeSlots);\\n\\n /// Gets the address for a given private key.\\n function addr(uint256 privateKey) external pure returns (address keyAddr);\\n\\n /// Gets all the logs according to specified filter.\\n function eth_getLogs(uint256 fromBlock, uint256 toBlock, address target, bytes32[] calldata topics)\\n external\\n returns (EthGetLogs[] memory logs);\\n\\n /// Gets the current `block.blobbasefee`.\\n /// You should use this instead of `block.blobbasefee` if you use `vm.blobBaseFee`, as `block.blobbasefee` is assumed to be constant across a transaction,\\n /// and as a result will get optimized out by the compiler.\\n /// See https://github.com/foundry-rs/foundry/issues/6180\\n function getBlobBaseFee() external view returns (uint256 blobBaseFee);\\n\\n /// Gets the current `block.number`.\\n /// You should use this instead of `block.number` if you use `vm.roll`, as `block.number` is assumed to be constant across a transaction,\\n /// and as a result will get optimized out by the compiler.\\n /// See https://github.com/foundry-rs/foundry/issues/6180\\n function getBlockNumber() external view returns (uint256 height);\\n\\n /// Gets the current `block.timestamp`.\\n /// You should use this instead of `block.timestamp` if you use `vm.warp`, as `block.timestamp` is assumed to be constant across a transaction,\\n /// and as a result will get optimized out by the compiler.\\n /// See https://github.com/foundry-rs/foundry/issues/6180\\n function getBlockTimestamp() external view returns (uint256 timestamp);\\n\\n /// Gets the map key and parent of a mapping at a given slot, for a given address.\\n function getMappingKeyAndParentOf(address target, bytes32 elementSlot)\\n external\\n returns (bool found, bytes32 key, bytes32 parent);\\n\\n /// Gets the number of elements in the mapping at the given slot, for a given address.\\n function getMappingLength(address target, bytes32 mappingSlot) external returns (uint256 length);\\n\\n /// Gets the elements at index idx of the mapping at the given slot, for a given address. The\\n /// index must be less than the length of the mapping (i.e. the number of keys in the mapping).\\n function getMappingSlotAt(address target, bytes32 mappingSlot, uint256 idx) external returns (bytes32 value);\\n\\n /// Gets the nonce of an account.\\n function getNonce(address account) external view returns (uint64 nonce);\\n\\n /// Get the nonce of a `Wallet`.\\n function getNonce(Wallet calldata wallet) external returns (uint64 nonce);\\n\\n /// Gets all the recorded logs.\\n function getRecordedLogs() external returns (Log[] memory logs);\\n\\n /// Returns state diffs from current `vm.startStateDiffRecording` session.\\n function getStateDiff() external view returns (string memory diff);\\n\\n /// Returns state diffs from current `vm.startStateDiffRecording` session, in json format.\\n function getStateDiffJson() external view returns (string memory diff);\\n\\n /// Gets the gas used in the last call from the callee perspective.\\n function lastCallGas() external view returns (Gas memory gas);\\n\\n /// Loads a storage slot from an address.\\n function load(address target, bytes32 slot) external view returns (bytes32 data);\\n\\n /// Pauses gas metering (i.e. gas usage is not counted). Noop if already paused.\\n function pauseGasMetering() external;\\n\\n /// Records all storage reads and writes.\\n function record() external;\\n\\n /// Record all the transaction logs.\\n function recordLogs() external;\\n\\n /// Reset gas metering (i.e. gas usage is set to gas limit).\\n function resetGasMetering() external;\\n\\n /// Resumes gas metering (i.e. gas usage is counted again). Noop if already on.\\n function resumeGasMetering() external;\\n\\n /// Performs an Ethereum JSON-RPC request to the current fork URL.\\n function rpc(string calldata method, string calldata params) external returns (bytes memory data);\\n\\n /// Performs an Ethereum JSON-RPC request to the given endpoint.\\n function rpc(string calldata urlOrAlias, string calldata method, string calldata params)\\n external\\n returns (bytes memory data);\\n\\n /// Records the debug trace during the run.\\n function startDebugTraceRecording() external;\\n\\n /// Starts recording all map SSTOREs for later retrieval.\\n function startMappingRecording() external;\\n\\n /// Record all account accesses as part of CREATE, CALL or SELFDESTRUCT opcodes in order,\\n /// along with the context of the calls\\n function startStateDiffRecording() external;\\n\\n /// Stop debug trace recording and returns the recorded debug trace.\\n function stopAndReturnDebugTraceRecording() external returns (DebugStep[] memory step);\\n\\n /// Returns an ordered array of all account accesses from a `vm.startStateDiffRecording` session.\\n function stopAndReturnStateDiff() external returns (AccountAccess[] memory accountAccesses);\\n\\n /// Stops recording all map SSTOREs for later retrieval and clears the recorded data.\\n function stopMappingRecording() external;\\n\\n // ======== Filesystem ========\\n\\n /// Closes file for reading, resetting the offset and allowing to read it from beginning with readLine.\\n /// `path` is relative to the project root.\\n function closeFile(string calldata path) external;\\n\\n /// Copies the contents of one file to another. This function will **overwrite** the contents of `to`.\\n /// On success, the total number of bytes copied is returned and it is equal to the length of the `to` file as reported by `metadata`.\\n /// Both `from` and `to` are relative to the project root.\\n function copyFile(string calldata from, string calldata to) external returns (uint64 copied);\\n\\n /// Creates a new, empty directory at the provided path.\\n /// This cheatcode will revert in the following situations, but is not limited to just these cases:\\n /// - User lacks permissions to modify `path`.\\n /// - A parent of the given path doesn't exist and `recursive` is false.\\n /// - `path` already exists and `recursive` is false.\\n /// `path` is relative to the project root.\\n function createDir(string calldata path, bool recursive) external;\\n\\n /// Deploys a contract from an artifact file. Takes in the relative path to the json file or the path to the\\n /// artifact in the form of :: where and parts are optional.\\n function deployCode(string calldata artifactPath) external returns (address deployedAddress);\\n\\n /// Deploys a contract from an artifact file. Takes in the relative path to the json file or the path to the\\n /// artifact in the form of :: where and parts are optional.\\n /// Additionally accepts abi-encoded constructor arguments.\\n function deployCode(string calldata artifactPath, bytes calldata constructorArgs)\\n external\\n returns (address deployedAddress);\\n\\n /// Returns true if the given path points to an existing entity, else returns false.\\n function exists(string calldata path) external view returns (bool result);\\n\\n /// Performs a foreign function call via the terminal.\\n function ffi(string[] calldata commandInput) external returns (bytes memory result);\\n\\n /// Given a path, query the file system to get information about a file, directory, etc.\\n function fsMetadata(string calldata path) external view returns (FsMetadata memory metadata);\\n\\n /// Gets the artifact path from code (aka. creation code).\\n function getArtifactPathByCode(bytes calldata code) external view returns (string memory path);\\n\\n /// Gets the artifact path from deployed code (aka. runtime code).\\n function getArtifactPathByDeployedCode(bytes calldata deployedCode) external view returns (string memory path);\\n\\n /// Returns the most recent broadcast for the given contract on `chainId` matching `txType`.\\n /// For example:\\n /// The most recent deployment can be fetched by passing `txType` as `CREATE` or `CREATE2`.\\n /// The most recent call can be fetched by passing `txType` as `CALL`.\\n function getBroadcast(string calldata contractName, uint64 chainId, BroadcastTxType txType)\\n external\\n view\\n returns (BroadcastTxSummary memory);\\n\\n /// Returns all broadcasts for the given contract on `chainId` with the specified `txType`.\\n /// Sorted such that the most recent broadcast is the first element, and the oldest is the last. i.e descending order of BroadcastTxSummary.blockNumber.\\n function getBroadcasts(string calldata contractName, uint64 chainId, BroadcastTxType txType)\\n external\\n view\\n returns (BroadcastTxSummary[] memory);\\n\\n /// Returns all broadcasts for the given contract on `chainId`.\\n /// Sorted such that the most recent broadcast is the first element, and the oldest is the last. i.e descending order of BroadcastTxSummary.blockNumber.\\n function getBroadcasts(string calldata contractName, uint64 chainId)\\n external\\n view\\n returns (BroadcastTxSummary[] memory);\\n\\n /// Gets the creation bytecode from an artifact file. Takes in the relative path to the json file or the path to the\\n /// artifact in the form of :: where and parts are optional.\\n function getCode(string calldata artifactPath) external view returns (bytes memory creationBytecode);\\n\\n /// Gets the deployed bytecode from an artifact file. Takes in the relative path to the json file or the path to the\\n /// artifact in the form of :: where and parts are optional.\\n function getDeployedCode(string calldata artifactPath) external view returns (bytes memory runtimeBytecode);\\n\\n /// Returns the most recent deployment for the current `chainId`.\\n function getDeployment(string calldata contractName) external view returns (address deployedAddress);\\n\\n /// Returns the most recent deployment for the given contract on `chainId`\\n function getDeployment(string calldata contractName, uint64 chainId)\\n external\\n view\\n returns (address deployedAddress);\\n\\n /// Returns all deployments for the given contract on `chainId`\\n /// Sorted in descending order of deployment time i.e descending order of BroadcastTxSummary.blockNumber.\\n /// The most recent deployment is the first element, and the oldest is the last.\\n function getDeployments(string calldata contractName, uint64 chainId)\\n external\\n view\\n returns (address[] memory deployedAddresses);\\n\\n /// Returns true if the path exists on disk and is pointing at a directory, else returns false.\\n function isDir(string calldata path) external view returns (bool result);\\n\\n /// Returns true if the path exists on disk and is pointing at a regular file, else returns false.\\n function isFile(string calldata path) external view returns (bool result);\\n\\n /// Get the path of the current project root.\\n function projectRoot() external view returns (string memory path);\\n\\n /// Prompts the user for a string value in the terminal.\\n function prompt(string calldata promptText) external returns (string memory input);\\n\\n /// Prompts the user for an address in the terminal.\\n function promptAddress(string calldata promptText) external returns (address);\\n\\n /// Prompts the user for a hidden string value in the terminal.\\n function promptSecret(string calldata promptText) external returns (string memory input);\\n\\n /// Prompts the user for hidden uint256 in the terminal (usually pk).\\n function promptSecretUint(string calldata promptText) external returns (uint256);\\n\\n /// Prompts the user for uint256 in the terminal.\\n function promptUint(string calldata promptText) external returns (uint256);\\n\\n /// Reads the directory at the given path recursively, up to `maxDepth`.\\n /// `maxDepth` defaults to 1, meaning only the direct children of the given directory will be returned.\\n /// Follows symbolic links if `followLinks` is true.\\n function readDir(string calldata path) external view returns (DirEntry[] memory entries);\\n\\n /// See `readDir(string)`.\\n function readDir(string calldata path, uint64 maxDepth) external view returns (DirEntry[] memory entries);\\n\\n /// See `readDir(string)`.\\n function readDir(string calldata path, uint64 maxDepth, bool followLinks)\\n external\\n view\\n returns (DirEntry[] memory entries);\\n\\n /// Reads the entire content of file to string. `path` is relative to the project root.\\n function readFile(string calldata path) external view returns (string memory data);\\n\\n /// Reads the entire content of file as binary. `path` is relative to the project root.\\n function readFileBinary(string calldata path) external view returns (bytes memory data);\\n\\n /// Reads next line of file to string.\\n function readLine(string calldata path) external view returns (string memory line);\\n\\n /// Reads a symbolic link, returning the path that the link points to.\\n /// This cheatcode will revert in the following situations, but is not limited to just these cases:\\n /// - `path` is not a symbolic link.\\n /// - `path` does not exist.\\n function readLink(string calldata linkPath) external view returns (string memory targetPath);\\n\\n /// Removes a directory at the provided path.\\n /// This cheatcode will revert in the following situations, but is not limited to just these cases:\\n /// - `path` doesn't exist.\\n /// - `path` isn't a directory.\\n /// - User lacks permissions to modify `path`.\\n /// - The directory is not empty and `recursive` is false.\\n /// `path` is relative to the project root.\\n function removeDir(string calldata path, bool recursive) external;\\n\\n /// Removes a file from the filesystem.\\n /// This cheatcode will revert in the following situations, but is not limited to just these cases:\\n /// - `path` points to a directory.\\n /// - The file doesn't exist.\\n /// - The user lacks permissions to remove the file.\\n /// `path` is relative to the project root.\\n function removeFile(string calldata path) external;\\n\\n /// Performs a foreign function call via terminal and returns the exit code, stdout, and stderr.\\n function tryFfi(string[] calldata commandInput) external returns (FfiResult memory result);\\n\\n /// Returns the time since unix epoch in milliseconds.\\n function unixTime() external view returns (uint256 milliseconds);\\n\\n /// Writes data to file, creating a file if it does not exist, and entirely replacing its contents if it does.\\n /// `path` is relative to the project root.\\n function writeFile(string calldata path, string calldata data) external;\\n\\n /// Writes binary data to a file, creating a file if it does not exist, and entirely replacing its contents if it does.\\n /// `path` is relative to the project root.\\n function writeFileBinary(string calldata path, bytes calldata data) external;\\n\\n /// Writes line to file, creating a file if it does not exist.\\n /// `path` is relative to the project root.\\n function writeLine(string calldata path, string calldata data) external;\\n\\n // ======== JSON ========\\n\\n /// Checks if `key` exists in a JSON object.\\n function keyExistsJson(string calldata json, string calldata key) external view returns (bool);\\n\\n /// Parses a string of JSON data at `key` and coerces it to `address`.\\n function parseJsonAddress(string calldata json, string calldata key) external pure returns (address);\\n\\n /// Parses a string of JSON data at `key` and coerces it to `address[]`.\\n function parseJsonAddressArray(string calldata json, string calldata key)\\n external\\n pure\\n returns (address[] memory);\\n\\n /// Parses a string of JSON data at `key` and coerces it to `bool`.\\n function parseJsonBool(string calldata json, string calldata key) external pure returns (bool);\\n\\n /// Parses a string of JSON data at `key` and coerces it to `bool[]`.\\n function parseJsonBoolArray(string calldata json, string calldata key) external pure returns (bool[] memory);\\n\\n /// Parses a string of JSON data at `key` and coerces it to `bytes`.\\n function parseJsonBytes(string calldata json, string calldata key) external pure returns (bytes memory);\\n\\n /// Parses a string of JSON data at `key` and coerces it to `bytes32`.\\n function parseJsonBytes32(string calldata json, string calldata key) external pure returns (bytes32);\\n\\n /// Parses a string of JSON data at `key` and coerces it to `bytes32[]`.\\n function parseJsonBytes32Array(string calldata json, string calldata key)\\n external\\n pure\\n returns (bytes32[] memory);\\n\\n /// Parses a string of JSON data at `key` and coerces it to `bytes[]`.\\n function parseJsonBytesArray(string calldata json, string calldata key) external pure returns (bytes[] memory);\\n\\n /// Parses a string of JSON data at `key` and coerces it to `int256`.\\n function parseJsonInt(string calldata json, string calldata key) external pure returns (int256);\\n\\n /// Parses a string of JSON data at `key` and coerces it to `int256[]`.\\n function parseJsonIntArray(string calldata json, string calldata key) external pure returns (int256[] memory);\\n\\n /// Returns an array of all the keys in a JSON object.\\n function parseJsonKeys(string calldata json, string calldata key) external pure returns (string[] memory keys);\\n\\n /// Parses a string of JSON data at `key` and coerces it to `string`.\\n function parseJsonString(string calldata json, string calldata key) external pure returns (string memory);\\n\\n /// Parses a string of JSON data at `key` and coerces it to `string[]`.\\n function parseJsonStringArray(string calldata json, string calldata key) external pure returns (string[] memory);\\n\\n /// Parses a string of JSON data at `key` and coerces it to type array corresponding to `typeDescription`.\\n function parseJsonTypeArray(string calldata json, string calldata key, string calldata typeDescription)\\n external\\n pure\\n returns (bytes memory);\\n\\n /// Parses a string of JSON data and coerces it to type corresponding to `typeDescription`.\\n function parseJsonType(string calldata json, string calldata typeDescription)\\n external\\n pure\\n returns (bytes memory);\\n\\n /// Parses a string of JSON data at `key` and coerces it to type corresponding to `typeDescription`.\\n function parseJsonType(string calldata json, string calldata key, string calldata typeDescription)\\n external\\n pure\\n returns (bytes memory);\\n\\n /// Parses a string of JSON data at `key` and coerces it to `uint256`.\\n function parseJsonUint(string calldata json, string calldata key) external pure returns (uint256);\\n\\n /// Parses a string of JSON data at `key` and coerces it to `uint256[]`.\\n function parseJsonUintArray(string calldata json, string calldata key) external pure returns (uint256[] memory);\\n\\n /// ABI-encodes a JSON object.\\n function parseJson(string calldata json) external pure returns (bytes memory abiEncodedData);\\n\\n /// ABI-encodes a JSON object at `key`.\\n function parseJson(string calldata json, string calldata key) external pure returns (bytes memory abiEncodedData);\\n\\n /// See `serializeJson`.\\n function serializeAddress(string calldata objectKey, string calldata valueKey, address value)\\n external\\n returns (string memory json);\\n\\n /// See `serializeJson`.\\n function serializeAddress(string calldata objectKey, string calldata valueKey, address[] calldata values)\\n external\\n returns (string memory json);\\n\\n /// See `serializeJson`.\\n function serializeBool(string calldata objectKey, string calldata valueKey, bool value)\\n external\\n returns (string memory json);\\n\\n /// See `serializeJson`.\\n function serializeBool(string calldata objectKey, string calldata valueKey, bool[] calldata values)\\n external\\n returns (string memory json);\\n\\n /// See `serializeJson`.\\n function serializeBytes32(string calldata objectKey, string calldata valueKey, bytes32 value)\\n external\\n returns (string memory json);\\n\\n /// See `serializeJson`.\\n function serializeBytes32(string calldata objectKey, string calldata valueKey, bytes32[] calldata values)\\n external\\n returns (string memory json);\\n\\n /// See `serializeJson`.\\n function serializeBytes(string calldata objectKey, string calldata valueKey, bytes calldata value)\\n external\\n returns (string memory json);\\n\\n /// See `serializeJson`.\\n function serializeBytes(string calldata objectKey, string calldata valueKey, bytes[] calldata values)\\n external\\n returns (string memory json);\\n\\n /// See `serializeJson`.\\n function serializeInt(string calldata objectKey, string calldata valueKey, int256 value)\\n external\\n returns (string memory json);\\n\\n /// See `serializeJson`.\\n function serializeInt(string calldata objectKey, string calldata valueKey, int256[] calldata values)\\n external\\n returns (string memory json);\\n\\n /// Serializes a key and value to a JSON object stored in-memory that can be later written to a file.\\n /// Returns the stringified version of the specific JSON file up to that moment.\\n function serializeJson(string calldata objectKey, string calldata value) external returns (string memory json);\\n\\n /// See `serializeJson`.\\n function serializeJsonType(string calldata typeDescription, bytes calldata value)\\n external\\n pure\\n returns (string memory json);\\n\\n /// See `serializeJson`.\\n function serializeJsonType(\\n string calldata objectKey,\\n string calldata valueKey,\\n string calldata typeDescription,\\n bytes calldata value\\n ) external returns (string memory json);\\n\\n /// See `serializeJson`.\\n function serializeString(string calldata objectKey, string calldata valueKey, string calldata value)\\n external\\n returns (string memory json);\\n\\n /// See `serializeJson`.\\n function serializeString(string calldata objectKey, string calldata valueKey, string[] calldata values)\\n external\\n returns (string memory json);\\n\\n /// See `serializeJson`.\\n function serializeUintToHex(string calldata objectKey, string calldata valueKey, uint256 value)\\n external\\n returns (string memory json);\\n\\n /// See `serializeJson`.\\n function serializeUint(string calldata objectKey, string calldata valueKey, uint256 value)\\n external\\n returns (string memory json);\\n\\n /// See `serializeJson`.\\n function serializeUint(string calldata objectKey, string calldata valueKey, uint256[] calldata values)\\n external\\n returns (string memory json);\\n\\n /// Write a serialized JSON object to a file. If the file exists, it will be overwritten.\\n function writeJson(string calldata json, string calldata path) external;\\n\\n /// Write a serialized JSON object to an **existing** JSON file, replacing a value with key = \\n /// This is useful to replace a specific value of a JSON file, without having to parse the entire thing.\\n function writeJson(string calldata json, string calldata path, string calldata valueKey) external;\\n\\n /// Checks if `key` exists in a JSON object\\n /// `keyExists` is being deprecated in favor of `keyExistsJson`. It will be removed in future versions.\\n function keyExists(string calldata json, string calldata key) external view returns (bool);\\n\\n // ======== Scripting ========\\n\\n /// Designate the next call as an EIP-7702 transaction\\n function attachDelegation(SignedDelegation calldata signedDelegation) external;\\n\\n /// Takes a signed transaction and broadcasts it to the network.\\n function broadcastRawTransaction(bytes calldata data) external;\\n\\n /// Has the next call (at this call depth only) create transactions that can later be signed and sent onchain.\\n /// Broadcasting address is determined by checking the following in order:\\n /// 1. If `--sender` argument was provided, that address is used.\\n /// 2. If exactly one signer (e.g. private key, hw wallet, keystore) is set when `forge broadcast` is invoked, that signer is used.\\n /// 3. Otherwise, default foundry sender (1804c8AB1F12E6bbf3894d4083f33e07309d1f38) is used.\\n function broadcast() external;\\n\\n /// Has the next call (at this call depth only) create a transaction with the address provided\\n /// as the sender that can later be signed and sent onchain.\\n function broadcast(address signer) external;\\n\\n /// Has the next call (at this call depth only) create a transaction with the private key\\n /// provided as the sender that can later be signed and sent onchain.\\n function broadcast(uint256 privateKey) external;\\n\\n /// Returns addresses of available unlocked wallets in the script environment.\\n function getWallets() external returns (address[] memory wallets);\\n\\n /// Sign an EIP-7702 authorization and designate the next call as an EIP-7702 transaction\\n function signAndAttachDelegation(address implementation, uint256 privateKey)\\n external\\n returns (SignedDelegation memory signedDelegation);\\n\\n /// Sign an EIP-7702 authorization for delegation\\n function signDelegation(address implementation, uint256 privateKey)\\n external\\n returns (SignedDelegation memory signedDelegation);\\n\\n /// Has all subsequent calls (at this call depth only) create transactions that can later be signed and sent onchain.\\n /// Broadcasting address is determined by checking the following in order:\\n /// 1. If `--sender` argument was provided, that address is used.\\n /// 2. If exactly one signer (e.g. private key, hw wallet, keystore) is set when `forge broadcast` is invoked, that signer is used.\\n /// 3. Otherwise, default foundry sender (1804c8AB1F12E6bbf3894d4083f33e07309d1f38) is used.\\n function startBroadcast() external;\\n\\n /// Has all subsequent calls (at this call depth only) create transactions with the address\\n /// provided that can later be signed and sent onchain.\\n function startBroadcast(address signer) external;\\n\\n /// Has all subsequent calls (at this call depth only) create transactions with the private key\\n /// provided that can later be signed and sent onchain.\\n function startBroadcast(uint256 privateKey) external;\\n\\n /// Stops collecting onchain transactions.\\n function stopBroadcast() external;\\n\\n // ======== String ========\\n\\n /// Returns true if `search` is found in `subject`, false otherwise.\\n function contains(string calldata subject, string calldata search) external returns (bool result);\\n\\n /// Returns the index of the first occurrence of a `key` in an `input` string.\\n /// Returns `NOT_FOUND` (i.e. `type(uint256).max`) if the `key` is not found.\\n /// Returns 0 in case of an empty `key`.\\n function indexOf(string calldata input, string calldata key) external pure returns (uint256);\\n\\n /// Parses the given `string` into an `address`.\\n function parseAddress(string calldata stringifiedValue) external pure returns (address parsedValue);\\n\\n /// Parses the given `string` into a `bool`.\\n function parseBool(string calldata stringifiedValue) external pure returns (bool parsedValue);\\n\\n /// Parses the given `string` into `bytes`.\\n function parseBytes(string calldata stringifiedValue) external pure returns (bytes memory parsedValue);\\n\\n /// Parses the given `string` into a `bytes32`.\\n function parseBytes32(string calldata stringifiedValue) external pure returns (bytes32 parsedValue);\\n\\n /// Parses the given `string` into a `int256`.\\n function parseInt(string calldata stringifiedValue) external pure returns (int256 parsedValue);\\n\\n /// Parses the given `string` into a `uint256`.\\n function parseUint(string calldata stringifiedValue) external pure returns (uint256 parsedValue);\\n\\n /// Replaces occurrences of `from` in the given `string` with `to`.\\n function replace(string calldata input, string calldata from, string calldata to)\\n external\\n pure\\n returns (string memory output);\\n\\n /// Splits the given `string` into an array of strings divided by the `delimiter`.\\n function split(string calldata input, string calldata delimiter) external pure returns (string[] memory outputs);\\n\\n /// Converts the given `string` value to Lowercase.\\n function toLowercase(string calldata input) external pure returns (string memory output);\\n\\n /// Converts the given value to a `string`.\\n function toString(address value) external pure returns (string memory stringifiedValue);\\n\\n /// Converts the given value to a `string`.\\n function toString(bytes calldata value) external pure returns (string memory stringifiedValue);\\n\\n /// Converts the given value to a `string`.\\n function toString(bytes32 value) external pure returns (string memory stringifiedValue);\\n\\n /// Converts the given value to a `string`.\\n function toString(bool value) external pure returns (string memory stringifiedValue);\\n\\n /// Converts the given value to a `string`.\\n function toString(uint256 value) external pure returns (string memory stringifiedValue);\\n\\n /// Converts the given value to a `string`.\\n function toString(int256 value) external pure returns (string memory stringifiedValue);\\n\\n /// Converts the given `string` value to Uppercase.\\n function toUppercase(string calldata input) external pure returns (string memory output);\\n\\n /// Trims leading and trailing whitespace from the given `string` value.\\n function trim(string calldata input) external pure returns (string memory output);\\n\\n // ======== Testing ========\\n\\n /// Compares two `uint256` values. Expects difference to be less than or equal to `maxDelta`.\\n /// Formats values with decimals in failure message.\\n function assertApproxEqAbsDecimal(uint256 left, uint256 right, uint256 maxDelta, uint256 decimals) external pure;\\n\\n /// Compares two `uint256` values. Expects difference to be less than or equal to `maxDelta`.\\n /// Formats values with decimals in failure message. Includes error message into revert string on failure.\\n function assertApproxEqAbsDecimal(\\n uint256 left,\\n uint256 right,\\n uint256 maxDelta,\\n uint256 decimals,\\n string calldata error\\n ) external pure;\\n\\n /// Compares two `int256` values. Expects difference to be less than or equal to `maxDelta`.\\n /// Formats values with decimals in failure message.\\n function assertApproxEqAbsDecimal(int256 left, int256 right, uint256 maxDelta, uint256 decimals) external pure;\\n\\n /// Compares two `int256` values. Expects difference to be less than or equal to `maxDelta`.\\n /// Formats values with decimals in failure message. Includes error message into revert string on failure.\\n function assertApproxEqAbsDecimal(\\n int256 left,\\n int256 right,\\n uint256 maxDelta,\\n uint256 decimals,\\n string calldata error\\n ) external pure;\\n\\n /// Compares two `uint256` values. Expects difference to be less than or equal to `maxDelta`.\\n function assertApproxEqAbs(uint256 left, uint256 right, uint256 maxDelta) external pure;\\n\\n /// Compares two `uint256` values. Expects difference to be less than or equal to `maxDelta`.\\n /// Includes error message into revert string on failure.\\n function assertApproxEqAbs(uint256 left, uint256 right, uint256 maxDelta, string calldata error) external pure;\\n\\n /// Compares two `int256` values. Expects difference to be less than or equal to `maxDelta`.\\n function assertApproxEqAbs(int256 left, int256 right, uint256 maxDelta) external pure;\\n\\n /// Compares two `int256` values. Expects difference to be less than or equal to `maxDelta`.\\n /// Includes error message into revert string on failure.\\n function assertApproxEqAbs(int256 left, int256 right, uint256 maxDelta, string calldata error) external pure;\\n\\n /// Compares two `uint256` values. Expects relative difference in percents to be less than or equal to `maxPercentDelta`.\\n /// `maxPercentDelta` is an 18 decimal fixed point number, where 1e18 == 100%\\n /// Formats values with decimals in failure message.\\n function assertApproxEqRelDecimal(uint256 left, uint256 right, uint256 maxPercentDelta, uint256 decimals)\\n external\\n pure;\\n\\n /// Compares two `uint256` values. Expects relative difference in percents to be less than or equal to `maxPercentDelta`.\\n /// `maxPercentDelta` is an 18 decimal fixed point number, where 1e18 == 100%\\n /// Formats values with decimals in failure message. Includes error message into revert string on failure.\\n function assertApproxEqRelDecimal(\\n uint256 left,\\n uint256 right,\\n uint256 maxPercentDelta,\\n uint256 decimals,\\n string calldata error\\n ) external pure;\\n\\n /// Compares two `int256` values. Expects relative difference in percents to be less than or equal to `maxPercentDelta`.\\n /// `maxPercentDelta` is an 18 decimal fixed point number, where 1e18 == 100%\\n /// Formats values with decimals in failure message.\\n function assertApproxEqRelDecimal(int256 left, int256 right, uint256 maxPercentDelta, uint256 decimals)\\n external\\n pure;\\n\\n /// Compares two `int256` values. Expects relative difference in percents to be less than or equal to `maxPercentDelta`.\\n /// `maxPercentDelta` is an 18 decimal fixed point number, where 1e18 == 100%\\n /// Formats values with decimals in failure message. Includes error message into revert string on failure.\\n function assertApproxEqRelDecimal(\\n int256 left,\\n int256 right,\\n uint256 maxPercentDelta,\\n uint256 decimals,\\n string calldata error\\n ) external pure;\\n\\n /// Compares two `uint256` values. Expects relative difference in percents to be less than or equal to `maxPercentDelta`.\\n /// `maxPercentDelta` is an 18 decimal fixed point number, where 1e18 == 100%\\n function assertApproxEqRel(uint256 left, uint256 right, uint256 maxPercentDelta) external pure;\\n\\n /// Compares two `uint256` values. Expects relative difference in percents to be less than or equal to `maxPercentDelta`.\\n /// `maxPercentDelta` is an 18 decimal fixed point number, where 1e18 == 100%\\n /// Includes error message into revert string on failure.\\n function assertApproxEqRel(uint256 left, uint256 right, uint256 maxPercentDelta, string calldata error)\\n external\\n pure;\\n\\n /// Compares two `int256` values. Expects relative difference in percents to be less than or equal to `maxPercentDelta`.\\n /// `maxPercentDelta` is an 18 decimal fixed point number, where 1e18 == 100%\\n function assertApproxEqRel(int256 left, int256 right, uint256 maxPercentDelta) external pure;\\n\\n /// Compares two `int256` values. Expects relative difference in percents to be less than or equal to `maxPercentDelta`.\\n /// `maxPercentDelta` is an 18 decimal fixed point number, where 1e18 == 100%\\n /// Includes error message into revert string on failure.\\n function assertApproxEqRel(int256 left, int256 right, uint256 maxPercentDelta, string calldata error)\\n external\\n pure;\\n\\n /// Asserts that two `uint256` values are equal, formatting them with decimals in failure message.\\n function assertEqDecimal(uint256 left, uint256 right, uint256 decimals) external pure;\\n\\n /// Asserts that two `uint256` values are equal, formatting them with decimals in failure message.\\n /// Includes error message into revert string on failure.\\n function assertEqDecimal(uint256 left, uint256 right, uint256 decimals, string calldata error) external pure;\\n\\n /// Asserts that two `int256` values are equal, formatting them with decimals in failure message.\\n function assertEqDecimal(int256 left, int256 right, uint256 decimals) external pure;\\n\\n /// Asserts that two `int256` values are equal, formatting them with decimals in failure message.\\n /// Includes error message into revert string on failure.\\n function assertEqDecimal(int256 left, int256 right, uint256 decimals, string calldata error) external pure;\\n\\n /// Asserts that two `bool` values are equal.\\n function assertEq(bool left, bool right) external pure;\\n\\n /// Asserts that two `bool` values are equal and includes error message into revert string on failure.\\n function assertEq(bool left, bool right, string calldata error) external pure;\\n\\n /// Asserts that two `string` values are equal.\\n function assertEq(string calldata left, string calldata right) external pure;\\n\\n /// Asserts that two `string` values are equal and includes error message into revert string on failure.\\n function assertEq(string calldata left, string calldata right, string calldata error) external pure;\\n\\n /// Asserts that two `bytes` values are equal.\\n function assertEq(bytes calldata left, bytes calldata right) external pure;\\n\\n /// Asserts that two `bytes` values are equal and includes error message into revert string on failure.\\n function assertEq(bytes calldata left, bytes calldata right, string calldata error) external pure;\\n\\n /// Asserts that two arrays of `bool` values are equal.\\n function assertEq(bool[] calldata left, bool[] calldata right) external pure;\\n\\n /// Asserts that two arrays of `bool` values are equal and includes error message into revert string on failure.\\n function assertEq(bool[] calldata left, bool[] calldata right, string calldata error) external pure;\\n\\n /// Asserts that two arrays of `uint256 values are equal.\\n function assertEq(uint256[] calldata left, uint256[] calldata right) external pure;\\n\\n /// Asserts that two arrays of `uint256` values are equal and includes error message into revert string on failure.\\n function assertEq(uint256[] calldata left, uint256[] calldata right, string calldata error) external pure;\\n\\n /// Asserts that two arrays of `int256` values are equal.\\n function assertEq(int256[] calldata left, int256[] calldata right) external pure;\\n\\n /// Asserts that two arrays of `int256` values are equal and includes error message into revert string on failure.\\n function assertEq(int256[] calldata left, int256[] calldata right, string calldata error) external pure;\\n\\n /// Asserts that two `uint256` values are equal.\\n function assertEq(uint256 left, uint256 right) external pure;\\n\\n /// Asserts that two arrays of `address` values are equal.\\n function assertEq(address[] calldata left, address[] calldata right) external pure;\\n\\n /// Asserts that two arrays of `address` values are equal and includes error message into revert string on failure.\\n function assertEq(address[] calldata left, address[] calldata right, string calldata error) external pure;\\n\\n /// Asserts that two arrays of `bytes32` values are equal.\\n function assertEq(bytes32[] calldata left, bytes32[] calldata right) external pure;\\n\\n /// Asserts that two arrays of `bytes32` values are equal and includes error message into revert string on failure.\\n function assertEq(bytes32[] calldata left, bytes32[] calldata right, string calldata error) external pure;\\n\\n /// Asserts that two arrays of `string` values are equal.\\n function assertEq(string[] calldata left, string[] calldata right) external pure;\\n\\n /// Asserts that two arrays of `string` values are equal and includes error message into revert string on failure.\\n function assertEq(string[] calldata left, string[] calldata right, string calldata error) external pure;\\n\\n /// Asserts that two arrays of `bytes` values are equal.\\n function assertEq(bytes[] calldata left, bytes[] calldata right) external pure;\\n\\n /// Asserts that two arrays of `bytes` values are equal and includes error message into revert string on failure.\\n function assertEq(bytes[] calldata left, bytes[] calldata right, string calldata error) external pure;\\n\\n /// Asserts that two `uint256` values are equal and includes error message into revert string on failure.\\n function assertEq(uint256 left, uint256 right, string calldata error) external pure;\\n\\n /// Asserts that two `int256` values are equal.\\n function assertEq(int256 left, int256 right) external pure;\\n\\n /// Asserts that two `int256` values are equal and includes error message into revert string on failure.\\n function assertEq(int256 left, int256 right, string calldata error) external pure;\\n\\n /// Asserts that two `address` values are equal.\\n function assertEq(address left, address right) external pure;\\n\\n /// Asserts that two `address` values are equal and includes error message into revert string on failure.\\n function assertEq(address left, address right, string calldata error) external pure;\\n\\n /// Asserts that two `bytes32` values are equal.\\n function assertEq(bytes32 left, bytes32 right) external pure;\\n\\n /// Asserts that two `bytes32` values are equal and includes error message into revert string on failure.\\n function assertEq(bytes32 left, bytes32 right, string calldata error) external pure;\\n\\n /// Asserts that the given condition is false.\\n function assertFalse(bool condition) external pure;\\n\\n /// Asserts that the given condition is false and includes error message into revert string on failure.\\n function assertFalse(bool condition, string calldata error) external pure;\\n\\n /// Compares two `uint256` values. Expects first value to be greater than or equal to second.\\n /// Formats values with decimals in failure message.\\n function assertGeDecimal(uint256 left, uint256 right, uint256 decimals) external pure;\\n\\n /// Compares two `uint256` values. Expects first value to be greater than or equal to second.\\n /// Formats values with decimals in failure message. Includes error message into revert string on failure.\\n function assertGeDecimal(uint256 left, uint256 right, uint256 decimals, string calldata error) external pure;\\n\\n /// Compares two `int256` values. Expects first value to be greater than or equal to second.\\n /// Formats values with decimals in failure message.\\n function assertGeDecimal(int256 left, int256 right, uint256 decimals) external pure;\\n\\n /// Compares two `int256` values. Expects first value to be greater than or equal to second.\\n /// Formats values with decimals in failure message. Includes error message into revert string on failure.\\n function assertGeDecimal(int256 left, int256 right, uint256 decimals, string calldata error) external pure;\\n\\n /// Compares two `uint256` values. Expects first value to be greater than or equal to second.\\n function assertGe(uint256 left, uint256 right) external pure;\\n\\n /// Compares two `uint256` values. Expects first value to be greater than or equal to second.\\n /// Includes error message into revert string on failure.\\n function assertGe(uint256 left, uint256 right, string calldata error) external pure;\\n\\n /// Compares two `int256` values. Expects first value to be greater than or equal to second.\\n function assertGe(int256 left, int256 right) external pure;\\n\\n /// Compares two `int256` values. Expects first value to be greater than or equal to second.\\n /// Includes error message into revert string on failure.\\n function assertGe(int256 left, int256 right, string calldata error) external pure;\\n\\n /// Compares two `uint256` values. Expects first value to be greater than second.\\n /// Formats values with decimals in failure message.\\n function assertGtDecimal(uint256 left, uint256 right, uint256 decimals) external pure;\\n\\n /// Compares two `uint256` values. Expects first value to be greater than second.\\n /// Formats values with decimals in failure message. Includes error message into revert string on failure.\\n function assertGtDecimal(uint256 left, uint256 right, uint256 decimals, string calldata error) external pure;\\n\\n /// Compares two `int256` values. Expects first value to be greater than second.\\n /// Formats values with decimals in failure message.\\n function assertGtDecimal(int256 left, int256 right, uint256 decimals) external pure;\\n\\n /// Compares two `int256` values. Expects first value to be greater than second.\\n /// Formats values with decimals in failure message. Includes error message into revert string on failure.\\n function assertGtDecimal(int256 left, int256 right, uint256 decimals, string calldata error) external pure;\\n\\n /// Compares two `uint256` values. Expects first value to be greater than second.\\n function assertGt(uint256 left, uint256 right) external pure;\\n\\n /// Compares two `uint256` values. Expects first value to be greater than second.\\n /// Includes error message into revert string on failure.\\n function assertGt(uint256 left, uint256 right, string calldata error) external pure;\\n\\n /// Compares two `int256` values. Expects first value to be greater than second.\\n function assertGt(int256 left, int256 right) external pure;\\n\\n /// Compares two `int256` values. Expects first value to be greater than second.\\n /// Includes error message into revert string on failure.\\n function assertGt(int256 left, int256 right, string calldata error) external pure;\\n\\n /// Compares two `uint256` values. Expects first value to be less than or equal to second.\\n /// Formats values with decimals in failure message.\\n function assertLeDecimal(uint256 left, uint256 right, uint256 decimals) external pure;\\n\\n /// Compares two `uint256` values. Expects first value to be less than or equal to second.\\n /// Formats values with decimals in failure message. Includes error message into revert string on failure.\\n function assertLeDecimal(uint256 left, uint256 right, uint256 decimals, string calldata error) external pure;\\n\\n /// Compares two `int256` values. Expects first value to be less than or equal to second.\\n /// Formats values with decimals in failure message.\\n function assertLeDecimal(int256 left, int256 right, uint256 decimals) external pure;\\n\\n /// Compares two `int256` values. Expects first value to be less than or equal to second.\\n /// Formats values with decimals in failure message. Includes error message into revert string on failure.\\n function assertLeDecimal(int256 left, int256 right, uint256 decimals, string calldata error) external pure;\\n\\n /// Compares two `uint256` values. Expects first value to be less than or equal to second.\\n function assertLe(uint256 left, uint256 right) external pure;\\n\\n /// Compares two `uint256` values. Expects first value to be less than or equal to second.\\n /// Includes error message into revert string on failure.\\n function assertLe(uint256 left, uint256 right, string calldata error) external pure;\\n\\n /// Compares two `int256` values. Expects first value to be less than or equal to second.\\n function assertLe(int256 left, int256 right) external pure;\\n\\n /// Compares two `int256` values. Expects first value to be less than or equal to second.\\n /// Includes error message into revert string on failure.\\n function assertLe(int256 left, int256 right, string calldata error) external pure;\\n\\n /// Compares two `uint256` values. Expects first value to be less than second.\\n /// Formats values with decimals in failure message.\\n function assertLtDecimal(uint256 left, uint256 right, uint256 decimals) external pure;\\n\\n /// Compares two `uint256` values. Expects first value to be less than second.\\n /// Formats values with decimals in failure message. Includes error message into revert string on failure.\\n function assertLtDecimal(uint256 left, uint256 right, uint256 decimals, string calldata error) external pure;\\n\\n /// Compares two `int256` values. Expects first value to be less than second.\\n /// Formats values with decimals in failure message.\\n function assertLtDecimal(int256 left, int256 right, uint256 decimals) external pure;\\n\\n /// Compares two `int256` values. Expects first value to be less than second.\\n /// Formats values with decimals in failure message. Includes error message into revert string on failure.\\n function assertLtDecimal(int256 left, int256 right, uint256 decimals, string calldata error) external pure;\\n\\n /// Compares two `uint256` values. Expects first value to be less than second.\\n function assertLt(uint256 left, uint256 right) external pure;\\n\\n /// Compares two `uint256` values. Expects first value to be less than second.\\n /// Includes error message into revert string on failure.\\n function assertLt(uint256 left, uint256 right, string calldata error) external pure;\\n\\n /// Compares two `int256` values. Expects first value to be less than second.\\n function assertLt(int256 left, int256 right) external pure;\\n\\n /// Compares two `int256` values. Expects first value to be less than second.\\n /// Includes error message into revert string on failure.\\n function assertLt(int256 left, int256 right, string calldata error) external pure;\\n\\n /// Asserts that two `uint256` values are not equal, formatting them with decimals in failure message.\\n function assertNotEqDecimal(uint256 left, uint256 right, uint256 decimals) external pure;\\n\\n /// Asserts that two `uint256` values are not equal, formatting them with decimals in failure message.\\n /// Includes error message into revert string on failure.\\n function assertNotEqDecimal(uint256 left, uint256 right, uint256 decimals, string calldata error) external pure;\\n\\n /// Asserts that two `int256` values are not equal, formatting them with decimals in failure message.\\n function assertNotEqDecimal(int256 left, int256 right, uint256 decimals) external pure;\\n\\n /// Asserts that two `int256` values are not equal, formatting them with decimals in failure message.\\n /// Includes error message into revert string on failure.\\n function assertNotEqDecimal(int256 left, int256 right, uint256 decimals, string calldata error) external pure;\\n\\n /// Asserts that two `bool` values are not equal.\\n function assertNotEq(bool left, bool right) external pure;\\n\\n /// Asserts that two `bool` values are not equal and includes error message into revert string on failure.\\n function assertNotEq(bool left, bool right, string calldata error) external pure;\\n\\n /// Asserts that two `string` values are not equal.\\n function assertNotEq(string calldata left, string calldata right) external pure;\\n\\n /// Asserts that two `string` values are not equal and includes error message into revert string on failure.\\n function assertNotEq(string calldata left, string calldata right, string calldata error) external pure;\\n\\n /// Asserts that two `bytes` values are not equal.\\n function assertNotEq(bytes calldata left, bytes calldata right) external pure;\\n\\n /// Asserts that two `bytes` values are not equal and includes error message into revert string on failure.\\n function assertNotEq(bytes calldata left, bytes calldata right, string calldata error) external pure;\\n\\n /// Asserts that two arrays of `bool` values are not equal.\\n function assertNotEq(bool[] calldata left, bool[] calldata right) external pure;\\n\\n /// Asserts that two arrays of `bool` values are not equal and includes error message into revert string on failure.\\n function assertNotEq(bool[] calldata left, bool[] calldata right, string calldata error) external pure;\\n\\n /// Asserts that two arrays of `uint256` values are not equal.\\n function assertNotEq(uint256[] calldata left, uint256[] calldata right) external pure;\\n\\n /// Asserts that two arrays of `uint256` values are not equal and includes error message into revert string on failure.\\n function assertNotEq(uint256[] calldata left, uint256[] calldata right, string calldata error) external pure;\\n\\n /// Asserts that two arrays of `int256` values are not equal.\\n function assertNotEq(int256[] calldata left, int256[] calldata right) external pure;\\n\\n /// Asserts that two arrays of `int256` values are not equal and includes error message into revert string on failure.\\n function assertNotEq(int256[] calldata left, int256[] calldata right, string calldata error) external pure;\\n\\n /// Asserts that two `uint256` values are not equal.\\n function assertNotEq(uint256 left, uint256 right) external pure;\\n\\n /// Asserts that two arrays of `address` values are not equal.\\n function assertNotEq(address[] calldata left, address[] calldata right) external pure;\\n\\n /// Asserts that two arrays of `address` values are not equal and includes error message into revert string on failure.\\n function assertNotEq(address[] calldata left, address[] calldata right, string calldata error) external pure;\\n\\n /// Asserts that two arrays of `bytes32` values are not equal.\\n function assertNotEq(bytes32[] calldata left, bytes32[] calldata right) external pure;\\n\\n /// Asserts that two arrays of `bytes32` values are not equal and includes error message into revert string on failure.\\n function assertNotEq(bytes32[] calldata left, bytes32[] calldata right, string calldata error) external pure;\\n\\n /// Asserts that two arrays of `string` values are not equal.\\n function assertNotEq(string[] calldata left, string[] calldata right) external pure;\\n\\n /// Asserts that two arrays of `string` values are not equal and includes error message into revert string on failure.\\n function assertNotEq(string[] calldata left, string[] calldata right, string calldata error) external pure;\\n\\n /// Asserts that two arrays of `bytes` values are not equal.\\n function assertNotEq(bytes[] calldata left, bytes[] calldata right) external pure;\\n\\n /// Asserts that two arrays of `bytes` values are not equal and includes error message into revert string on failure.\\n function assertNotEq(bytes[] calldata left, bytes[] calldata right, string calldata error) external pure;\\n\\n /// Asserts that two `uint256` values are not equal and includes error message into revert string on failure.\\n function assertNotEq(uint256 left, uint256 right, string calldata error) external pure;\\n\\n /// Asserts that two `int256` values are not equal.\\n function assertNotEq(int256 left, int256 right) external pure;\\n\\n /// Asserts that two `int256` values are not equal and includes error message into revert string on failure.\\n function assertNotEq(int256 left, int256 right, string calldata error) external pure;\\n\\n /// Asserts that two `address` values are not equal.\\n function assertNotEq(address left, address right) external pure;\\n\\n /// Asserts that two `address` values are not equal and includes error message into revert string on failure.\\n function assertNotEq(address left, address right, string calldata error) external pure;\\n\\n /// Asserts that two `bytes32` values are not equal.\\n function assertNotEq(bytes32 left, bytes32 right) external pure;\\n\\n /// Asserts that two `bytes32` values are not equal and includes error message into revert string on failure.\\n function assertNotEq(bytes32 left, bytes32 right, string calldata error) external pure;\\n\\n /// Asserts that the given condition is true.\\n function assertTrue(bool condition) external pure;\\n\\n /// Asserts that the given condition is true and includes error message into revert string on failure.\\n function assertTrue(bool condition, string calldata error) external pure;\\n\\n /// If the condition is false, discard this run's fuzz inputs and generate new ones.\\n function assume(bool condition) external pure;\\n\\n /// Discard this run's fuzz inputs and generate new ones if next call reverted.\\n function assumeNoRevert() external pure;\\n\\n /// Discard this run's fuzz inputs and generate new ones if next call reverts with the potential revert parameters.\\n function assumeNoRevert(PotentialRevert calldata potentialRevert) external pure;\\n\\n /// Discard this run's fuzz inputs and generate new ones if next call reverts with the any of the potential revert parameters.\\n function assumeNoRevert(PotentialRevert[] calldata potentialReverts) external pure;\\n\\n /// Writes a breakpoint to jump to in the debugger.\\n function breakpoint(string calldata char) external pure;\\n\\n /// Writes a conditional breakpoint to jump to in the debugger.\\n function breakpoint(string calldata char, bool value) external pure;\\n\\n /// Returns true if the current Foundry version is greater than or equal to the given version.\\n /// The given version string must be in the format `major.minor.patch`.\\n /// This is equivalent to `foundryVersionCmp(version) >= 0`.\\n function foundryVersionAtLeast(string calldata version) external view returns (bool);\\n\\n /// Compares the current Foundry version with the given version string.\\n /// The given version string must be in the format `major.minor.patch`.\\n /// Returns:\\n /// -1 if current Foundry version is less than the given version\\n /// 0 if current Foundry version equals the given version\\n /// 1 if current Foundry version is greater than the given version\\n /// This result can then be used with a comparison operator against `0`.\\n /// For example, to check if the current Foundry version is greater than or equal to `1.0.0`:\\n /// `if (foundryVersionCmp(\\\"1.0.0\\\") >= 0) { ... }`\\n function foundryVersionCmp(string calldata version) external view returns (int256);\\n\\n /// Returns the Foundry version.\\n /// Format: -+..\\n /// Sample output: 0.3.0-nightly+3cb96bde9b.1737036656.debug\\n /// Note: Build timestamps may vary slightly across platforms due to separate CI jobs.\\n /// For reliable version comparisons, use UNIX format (e.g., >= 1700000000)\\n /// to compare timestamps while ignoring minor time differences.\\n function getFoundryVersion() external view returns (string memory version);\\n\\n /// Returns the RPC url for the given alias.\\n function rpcUrl(string calldata rpcAlias) external view returns (string memory json);\\n\\n /// Returns all rpc urls and their aliases as structs.\\n function rpcUrlStructs() external view returns (Rpc[] memory urls);\\n\\n /// Returns all rpc urls and their aliases `[alias, url][]`.\\n function rpcUrls() external view returns (string[2][] memory urls);\\n\\n /// Suspends execution of the main thread for `duration` milliseconds.\\n function sleep(uint256 duration) external;\\n\\n // ======== Toml ========\\n\\n /// Checks if `key` exists in a TOML table.\\n function keyExistsToml(string calldata toml, string calldata key) external view returns (bool);\\n\\n /// Parses a string of TOML data at `key` and coerces it to `address`.\\n function parseTomlAddress(string calldata toml, string calldata key) external pure returns (address);\\n\\n /// Parses a string of TOML data at `key` and coerces it to `address[]`.\\n function parseTomlAddressArray(string calldata toml, string calldata key)\\n external\\n pure\\n returns (address[] memory);\\n\\n /// Parses a string of TOML data at `key` and coerces it to `bool`.\\n function parseTomlBool(string calldata toml, string calldata key) external pure returns (bool);\\n\\n /// Parses a string of TOML data at `key` and coerces it to `bool[]`.\\n function parseTomlBoolArray(string calldata toml, string calldata key) external pure returns (bool[] memory);\\n\\n /// Parses a string of TOML data at `key` and coerces it to `bytes`.\\n function parseTomlBytes(string calldata toml, string calldata key) external pure returns (bytes memory);\\n\\n /// Parses a string of TOML data at `key` and coerces it to `bytes32`.\\n function parseTomlBytes32(string calldata toml, string calldata key) external pure returns (bytes32);\\n\\n /// Parses a string of TOML data at `key` and coerces it to `bytes32[]`.\\n function parseTomlBytes32Array(string calldata toml, string calldata key)\\n external\\n pure\\n returns (bytes32[] memory);\\n\\n /// Parses a string of TOML data at `key` and coerces it to `bytes[]`.\\n function parseTomlBytesArray(string calldata toml, string calldata key) external pure returns (bytes[] memory);\\n\\n /// Parses a string of TOML data at `key` and coerces it to `int256`.\\n function parseTomlInt(string calldata toml, string calldata key) external pure returns (int256);\\n\\n /// Parses a string of TOML data at `key` and coerces it to `int256[]`.\\n function parseTomlIntArray(string calldata toml, string calldata key) external pure returns (int256[] memory);\\n\\n /// Returns an array of all the keys in a TOML table.\\n function parseTomlKeys(string calldata toml, string calldata key) external pure returns (string[] memory keys);\\n\\n /// Parses a string of TOML data at `key` and coerces it to `string`.\\n function parseTomlString(string calldata toml, string calldata key) external pure returns (string memory);\\n\\n /// Parses a string of TOML data at `key` and coerces it to `string[]`.\\n function parseTomlStringArray(string calldata toml, string calldata key) external pure returns (string[] memory);\\n\\n /// Parses a string of TOML data at `key` and coerces it to type array corresponding to `typeDescription`.\\n function parseTomlTypeArray(string calldata toml, string calldata key, string calldata typeDescription)\\n external\\n pure\\n returns (bytes memory);\\n\\n /// Parses a string of TOML data and coerces it to type corresponding to `typeDescription`.\\n function parseTomlType(string calldata toml, string calldata typeDescription)\\n external\\n pure\\n returns (bytes memory);\\n\\n /// Parses a string of TOML data at `key` and coerces it to type corresponding to `typeDescription`.\\n function parseTomlType(string calldata toml, string calldata key, string calldata typeDescription)\\n external\\n pure\\n returns (bytes memory);\\n\\n /// Parses a string of TOML data at `key` and coerces it to `uint256`.\\n function parseTomlUint(string calldata toml, string calldata key) external pure returns (uint256);\\n\\n /// Parses a string of TOML data at `key` and coerces it to `uint256[]`.\\n function parseTomlUintArray(string calldata toml, string calldata key) external pure returns (uint256[] memory);\\n\\n /// ABI-encodes a TOML table.\\n function parseToml(string calldata toml) external pure returns (bytes memory abiEncodedData);\\n\\n /// ABI-encodes a TOML table at `key`.\\n function parseToml(string calldata toml, string calldata key) external pure returns (bytes memory abiEncodedData);\\n\\n /// Takes serialized JSON, converts to TOML and write a serialized TOML to a file.\\n function writeToml(string calldata json, string calldata path) external;\\n\\n /// Takes serialized JSON, converts to TOML and write a serialized TOML table to an **existing** TOML file, replacing a value with key = \\n /// This is useful to replace a specific value of a TOML file, without having to parse the entire thing.\\n function writeToml(string calldata json, string calldata path, string calldata valueKey) external;\\n\\n // ======== Utilities ========\\n\\n /// Compute the address of a contract created with CREATE2 using the given CREATE2 deployer.\\n function computeCreate2Address(bytes32 salt, bytes32 initCodeHash, address deployer)\\n external\\n pure\\n returns (address);\\n\\n /// Compute the address of a contract created with CREATE2 using the default CREATE2 deployer.\\n function computeCreate2Address(bytes32 salt, bytes32 initCodeHash) external pure returns (address);\\n\\n /// Compute the address a contract will be deployed at for a given deployer address and nonce.\\n function computeCreateAddress(address deployer, uint256 nonce) external pure returns (address);\\n\\n /// Utility cheatcode to copy storage of `from` contract to another `to` contract.\\n function copyStorage(address from, address to) external;\\n\\n /// Returns ENS namehash for provided string.\\n function ensNamehash(string calldata name) external pure returns (bytes32);\\n\\n /// Gets the label for the specified address.\\n function getLabel(address account) external view returns (string memory currentLabel);\\n\\n /// Labels an address in call traces.\\n function label(address account, string calldata newLabel) external;\\n\\n /// Pauses collection of call traces. Useful in cases when you want to skip tracing of\\n /// complex calls which are not useful for debugging.\\n function pauseTracing() external view;\\n\\n /// Returns a random `address`.\\n function randomAddress() external returns (address);\\n\\n /// Returns a random `bool`.\\n function randomBool() external view returns (bool);\\n\\n /// Returns a random byte array value of the given length.\\n function randomBytes(uint256 len) external view returns (bytes memory);\\n\\n /// Returns a random fixed-size byte array of length 4.\\n function randomBytes4() external view returns (bytes4);\\n\\n /// Returns a random fixed-size byte array of length 8.\\n function randomBytes8() external view returns (bytes8);\\n\\n /// Returns a random `int256` value.\\n function randomInt() external view returns (int256);\\n\\n /// Returns a random `int256` value of given bits.\\n function randomInt(uint256 bits) external view returns (int256);\\n\\n /// Returns a random uint256 value.\\n function randomUint() external returns (uint256);\\n\\n /// Returns random uint256 value between the provided range (=min..=max).\\n function randomUint(uint256 min, uint256 max) external returns (uint256);\\n\\n /// Returns a random `uint256` value of given bits.\\n function randomUint(uint256 bits) external view returns (uint256);\\n\\n /// Unpauses collection of call traces.\\n function resumeTracing() external view;\\n\\n /// Utility cheatcode to set arbitrary storage for given target address.\\n function setArbitraryStorage(address target) external;\\n\\n /// Encodes a `bytes` value to a base64url string.\\n function toBase64URL(bytes calldata data) external pure returns (string memory);\\n\\n /// Encodes a `string` value to a base64url string.\\n function toBase64URL(string calldata data) external pure returns (string memory);\\n\\n /// Encodes a `bytes` value to a base64 string.\\n function toBase64(bytes calldata data) external pure returns (string memory);\\n\\n /// Encodes a `string` value to a base64 string.\\n function toBase64(string calldata data) external pure returns (string memory);\\n}\\n\\n/// The `Vm` interface does allow manipulation of the EVM state. These are all intended to be used\\n/// in tests, but it is not recommended to use these cheats in scripts.\\ninterface Vm is VmSafe {\\n // ======== EVM ========\\n\\n /// Utility cheatcode to set an EIP-2930 access list for all subsequent transactions.\\n function accessList(AccessListItem[] calldata access) external;\\n\\n /// Returns the identifier of the currently active fork. Reverts if no fork is currently active.\\n function activeFork() external view returns (uint256 forkId);\\n\\n /// In forking mode, explicitly grant the given address cheatcode access.\\n function allowCheatcodes(address account) external;\\n\\n /// Sets `block.blobbasefee`\\n function blobBaseFee(uint256 newBlobBaseFee) external;\\n\\n /// Sets the blobhashes in the transaction.\\n /// Not available on EVM versions before Cancun.\\n /// If used on unsupported EVM versions it will revert.\\n function blobhashes(bytes32[] calldata hashes) external;\\n\\n /// Sets `block.chainid`.\\n function chainId(uint256 newChainId) external;\\n\\n /// Clears all mocked calls.\\n function clearMockedCalls() external;\\n\\n /// Clones a source account code, state, balance and nonce to a target account and updates in-memory EVM state.\\n function cloneAccount(address source, address target) external;\\n\\n /// Sets `block.coinbase`.\\n function coinbase(address newCoinbase) external;\\n\\n /// Marks the slots of an account and the account address as cold.\\n function cool(address target) external;\\n\\n /// Utility cheatcode to mark specific storage slot as cold, simulating no prior read.\\n function coolSlot(address target, bytes32 slot) external;\\n\\n /// Creates a new fork with the given endpoint and the _latest_ block and returns the identifier of the fork.\\n function createFork(string calldata urlOrAlias) external returns (uint256 forkId);\\n\\n /// Creates a new fork with the given endpoint and block and returns the identifier of the fork.\\n function createFork(string calldata urlOrAlias, uint256 blockNumber) external returns (uint256 forkId);\\n\\n /// Creates a new fork with the given endpoint and at the block the given transaction was mined in,\\n /// replays all transaction mined in the block before the transaction, and returns the identifier of the fork.\\n function createFork(string calldata urlOrAlias, bytes32 txHash) external returns (uint256 forkId);\\n\\n /// Creates and also selects a new fork with the given endpoint and the latest block and returns the identifier of the fork.\\n function createSelectFork(string calldata urlOrAlias) external returns (uint256 forkId);\\n\\n /// Creates and also selects a new fork with the given endpoint and block and returns the identifier of the fork.\\n function createSelectFork(string calldata urlOrAlias, uint256 blockNumber) external returns (uint256 forkId);\\n\\n /// Creates and also selects new fork with the given endpoint and at the block the given transaction was mined in,\\n /// replays all transaction mined in the block before the transaction, returns the identifier of the fork.\\n function createSelectFork(string calldata urlOrAlias, bytes32 txHash) external returns (uint256 forkId);\\n\\n /// Sets an address' balance.\\n function deal(address account, uint256 newBalance) external;\\n\\n /// Removes the snapshot with the given ID created by `snapshot`.\\n /// Takes the snapshot ID to delete.\\n /// Returns `true` if the snapshot was successfully deleted.\\n /// Returns `false` if the snapshot does not exist.\\n function deleteStateSnapshot(uint256 snapshotId) external returns (bool success);\\n\\n /// Removes _all_ snapshots previously created by `snapshot`.\\n function deleteStateSnapshots() external;\\n\\n /// Sets `block.difficulty`.\\n /// Not available on EVM versions from Paris onwards. Use `prevrandao` instead.\\n /// Reverts if used on unsupported EVM versions.\\n function difficulty(uint256 newDifficulty) external;\\n\\n /// Dump a genesis JSON file's `allocs` to disk.\\n function dumpState(string calldata pathToStateJson) external;\\n\\n /// Sets an address' code.\\n function etch(address target, bytes calldata newRuntimeBytecode) external;\\n\\n /// Sets `block.basefee`.\\n function fee(uint256 newBasefee) external;\\n\\n /// Gets the blockhashes from the current transaction.\\n /// Not available on EVM versions before Cancun.\\n /// If used on unsupported EVM versions it will revert.\\n function getBlobhashes() external view returns (bytes32[] memory hashes);\\n\\n /// Returns true if the account is marked as persistent.\\n function isPersistent(address account) external view returns (bool persistent);\\n\\n /// Load a genesis JSON file's `allocs` into the in-memory EVM state.\\n function loadAllocs(string calldata pathToAllocsJson) external;\\n\\n /// Marks that the account(s) should use persistent storage across fork swaps in a multifork setup\\n /// Meaning, changes made to the state of this account will be kept when switching forks.\\n function makePersistent(address account) external;\\n\\n /// See `makePersistent(address)`.\\n function makePersistent(address account0, address account1) external;\\n\\n /// See `makePersistent(address)`.\\n function makePersistent(address account0, address account1, address account2) external;\\n\\n /// See `makePersistent(address)`.\\n function makePersistent(address[] calldata accounts) external;\\n\\n /// Reverts a call to an address with specified revert data.\\n function mockCallRevert(address callee, bytes calldata data, bytes calldata revertData) external;\\n\\n /// Reverts a call to an address with a specific `msg.value`, with specified revert data.\\n function mockCallRevert(address callee, uint256 msgValue, bytes calldata data, bytes calldata revertData)\\n external;\\n\\n /// Reverts a call to an address with specified revert data.\\n /// Overload to pass the function selector directly `token.approve.selector` instead of `abi.encodeWithSelector(token.approve.selector)`.\\n function mockCallRevert(address callee, bytes4 data, bytes calldata revertData) external;\\n\\n /// Reverts a call to an address with a specific `msg.value`, with specified revert data.\\n /// Overload to pass the function selector directly `token.approve.selector` instead of `abi.encodeWithSelector(token.approve.selector)`.\\n function mockCallRevert(address callee, uint256 msgValue, bytes4 data, bytes calldata revertData) external;\\n\\n /// Mocks a call to an address, returning specified data.\\n /// Calldata can either be strict or a partial match, e.g. if you only\\n /// pass a Solidity selector to the expected calldata, then the entire Solidity\\n /// function will be mocked.\\n function mockCall(address callee, bytes calldata data, bytes calldata returnData) external;\\n\\n /// Mocks a call to an address with a specific `msg.value`, returning specified data.\\n /// Calldata match takes precedence over `msg.value` in case of ambiguity.\\n function mockCall(address callee, uint256 msgValue, bytes calldata data, bytes calldata returnData) external;\\n\\n /// Mocks a call to an address, returning specified data.\\n /// Calldata can either be strict or a partial match, e.g. if you only\\n /// pass a Solidity selector to the expected calldata, then the entire Solidity\\n /// function will be mocked.\\n /// Overload to pass the function selector directly `token.approve.selector` instead of `abi.encodeWithSelector(token.approve.selector)`.\\n function mockCall(address callee, bytes4 data, bytes calldata returnData) external;\\n\\n /// Mocks a call to an address with a specific `msg.value`, returning specified data.\\n /// Calldata match takes precedence over `msg.value` in case of ambiguity.\\n /// Overload to pass the function selector directly `token.approve.selector` instead of `abi.encodeWithSelector(token.approve.selector)`.\\n function mockCall(address callee, uint256 msgValue, bytes4 data, bytes calldata returnData) external;\\n\\n /// Mocks multiple calls to an address, returning specified data for each call.\\n function mockCalls(address callee, bytes calldata data, bytes[] calldata returnData) external;\\n\\n /// Mocks multiple calls to an address with a specific `msg.value`, returning specified data for each call.\\n function mockCalls(address callee, uint256 msgValue, bytes calldata data, bytes[] calldata returnData) external;\\n\\n /// Whenever a call is made to `callee` with calldata `data`, this cheatcode instead calls\\n /// `target` with the same calldata. This functionality is similar to a delegate call made to\\n /// `target` contract from `callee`.\\n /// Can be used to substitute a call to a function with another implementation that captures\\n /// the primary logic of the original function but is easier to reason about.\\n /// If calldata is not a strict match then partial match by selector is attempted.\\n function mockFunction(address callee, address target, bytes calldata data) external;\\n\\n /// Utility cheatcode to remove any EIP-2930 access list set by `accessList` cheatcode.\\n function noAccessList() external;\\n\\n /// Sets the *next* call's `msg.sender` to be the input address.\\n function prank(address msgSender) external;\\n\\n /// Sets the *next* call's `msg.sender` to be the input address, and the `tx.origin` to be the second input.\\n function prank(address msgSender, address txOrigin) external;\\n\\n /// Sets the *next* delegate call's `msg.sender` to be the input address.\\n function prank(address msgSender, bool delegateCall) external;\\n\\n /// Sets the *next* delegate call's `msg.sender` to be the input address, and the `tx.origin` to be the second input.\\n function prank(address msgSender, address txOrigin, bool delegateCall) external;\\n\\n /// Sets `block.prevrandao`.\\n /// Not available on EVM versions before Paris. Use `difficulty` instead.\\n /// If used on unsupported EVM versions it will revert.\\n function prevrandao(bytes32 newPrevrandao) external;\\n\\n /// Sets `block.prevrandao`.\\n /// Not available on EVM versions before Paris. Use `difficulty` instead.\\n /// If used on unsupported EVM versions it will revert.\\n function prevrandao(uint256 newPrevrandao) external;\\n\\n /// Reads the current `msg.sender` and `tx.origin` from state and reports if there is any active caller modification.\\n function readCallers() external returns (CallerMode callerMode, address msgSender, address txOrigin);\\n\\n /// Resets the nonce of an account to 0 for EOAs and 1 for contract accounts.\\n function resetNonce(address account) external;\\n\\n /// Revert the state of the EVM to a previous snapshot\\n /// Takes the snapshot ID to revert to.\\n /// Returns `true` if the snapshot was successfully reverted.\\n /// Returns `false` if the snapshot does not exist.\\n /// **Note:** This does not automatically delete the snapshot. To delete the snapshot use `deleteStateSnapshot`.\\n function revertToState(uint256 snapshotId) external returns (bool success);\\n\\n /// Revert the state of the EVM to a previous snapshot and automatically deletes the snapshots\\n /// Takes the snapshot ID to revert to.\\n /// Returns `true` if the snapshot was successfully reverted and deleted.\\n /// Returns `false` if the snapshot does not exist.\\n function revertToStateAndDelete(uint256 snapshotId) external returns (bool success);\\n\\n /// Revokes persistent status from the address, previously added via `makePersistent`.\\n function revokePersistent(address account) external;\\n\\n /// See `revokePersistent(address)`.\\n function revokePersistent(address[] calldata accounts) external;\\n\\n /// Sets `block.height`.\\n function roll(uint256 newHeight) external;\\n\\n /// Updates the currently active fork to given block number\\n /// This is similar to `roll` but for the currently active fork.\\n function rollFork(uint256 blockNumber) external;\\n\\n /// Updates the currently active fork to given transaction. This will `rollFork` with the number\\n /// of the block the transaction was mined in and replays all transaction mined before it in the block.\\n function rollFork(bytes32 txHash) external;\\n\\n /// Updates the given fork to given block number.\\n function rollFork(uint256 forkId, uint256 blockNumber) external;\\n\\n /// Updates the given fork to block number of the given transaction and replays all transaction mined before it in the block.\\n function rollFork(uint256 forkId, bytes32 txHash) external;\\n\\n /// Takes a fork identifier created by `createFork` and sets the corresponding forked state as active.\\n function selectFork(uint256 forkId) external;\\n\\n /// Set blockhash for the current block.\\n /// It only sets the blockhash for blocks where `block.number - 256 <= number < block.number`.\\n function setBlockhash(uint256 blockNumber, bytes32 blockHash) external;\\n\\n /// Sets the nonce of an account. Must be higher than the current nonce of the account.\\n function setNonce(address account, uint64 newNonce) external;\\n\\n /// Sets the nonce of an account to an arbitrary value.\\n function setNonceUnsafe(address account, uint64 newNonce) external;\\n\\n /// Snapshot capture the gas usage of the last call by name from the callee perspective.\\n function snapshotGasLastCall(string calldata name) external returns (uint256 gasUsed);\\n\\n /// Snapshot capture the gas usage of the last call by name in a group from the callee perspective.\\n function snapshotGasLastCall(string calldata group, string calldata name) external returns (uint256 gasUsed);\\n\\n /// Snapshot the current state of the evm.\\n /// Returns the ID of the snapshot that was created.\\n /// To revert a snapshot use `revertToState`.\\n function snapshotState() external returns (uint256 snapshotId);\\n\\n /// Snapshot capture an arbitrary numerical value by name.\\n /// The group name is derived from the contract name.\\n function snapshotValue(string calldata name, uint256 value) external;\\n\\n /// Snapshot capture an arbitrary numerical value by name in a group.\\n function snapshotValue(string calldata group, string calldata name, uint256 value) external;\\n\\n /// Sets all subsequent calls' `msg.sender` to be the input address until `stopPrank` is called.\\n function startPrank(address msgSender) external;\\n\\n /// Sets all subsequent calls' `msg.sender` to be the input address until `stopPrank` is called, and the `tx.origin` to be the second input.\\n function startPrank(address msgSender, address txOrigin) external;\\n\\n /// Sets all subsequent delegate calls' `msg.sender` to be the input address until `stopPrank` is called.\\n function startPrank(address msgSender, bool delegateCall) external;\\n\\n /// Sets all subsequent delegate calls' `msg.sender` to be the input address until `stopPrank` is called, and the `tx.origin` to be the second input.\\n function startPrank(address msgSender, address txOrigin, bool delegateCall) external;\\n\\n /// Start a snapshot capture of the current gas usage by name.\\n /// The group name is derived from the contract name.\\n function startSnapshotGas(string calldata name) external;\\n\\n /// Start a snapshot capture of the current gas usage by name in a group.\\n function startSnapshotGas(string calldata group, string calldata name) external;\\n\\n /// Resets subsequent calls' `msg.sender` to be `address(this)`.\\n function stopPrank() external;\\n\\n /// Stop the snapshot capture of the current gas by latest snapshot name, capturing the gas used since the start.\\n function stopSnapshotGas() external returns (uint256 gasUsed);\\n\\n /// Stop the snapshot capture of the current gas usage by name, capturing the gas used since the start.\\n /// The group name is derived from the contract name.\\n function stopSnapshotGas(string calldata name) external returns (uint256 gasUsed);\\n\\n /// Stop the snapshot capture of the current gas usage by name in a group, capturing the gas used since the start.\\n function stopSnapshotGas(string calldata group, string calldata name) external returns (uint256 gasUsed);\\n\\n /// Stores a value to an address' storage slot.\\n function store(address target, bytes32 slot, bytes32 value) external;\\n\\n /// Fetches the given transaction from the active fork and executes it on the current state.\\n function transact(bytes32 txHash) external;\\n\\n /// Fetches the given transaction from the given fork and executes it on the current state.\\n function transact(uint256 forkId, bytes32 txHash) external;\\n\\n /// Sets `tx.gasprice`.\\n function txGasPrice(uint256 newGasPrice) external;\\n\\n /// Utility cheatcode to mark specific storage slot as warm, simulating a prior read.\\n function warmSlot(address target, bytes32 slot) external;\\n\\n /// Sets `block.timestamp`.\\n function warp(uint256 newTimestamp) external;\\n\\n /// `deleteSnapshot` is being deprecated in favor of `deleteStateSnapshot`. It will be removed in future versions.\\n function deleteSnapshot(uint256 snapshotId) external returns (bool success);\\n\\n /// `deleteSnapshots` is being deprecated in favor of `deleteStateSnapshots`. It will be removed in future versions.\\n function deleteSnapshots() external;\\n\\n /// `revertToAndDelete` is being deprecated in favor of `revertToStateAndDelete`. It will be removed in future versions.\\n function revertToAndDelete(uint256 snapshotId) external returns (bool success);\\n\\n /// `revertTo` is being deprecated in favor of `revertToState`. It will be removed in future versions.\\n function revertTo(uint256 snapshotId) external returns (bool success);\\n\\n /// `snapshot` is being deprecated in favor of `snapshotState`. It will be removed in future versions.\\n function snapshot() external returns (uint256 snapshotId);\\n\\n // ======== Testing ========\\n\\n /// Expect a call to an address with the specified `msg.value` and calldata, and a *minimum* amount of gas.\\n function expectCallMinGas(address callee, uint256 msgValue, uint64 minGas, bytes calldata data) external;\\n\\n /// Expect given number of calls to an address with the specified `msg.value` and calldata, and a *minimum* amount of gas.\\n function expectCallMinGas(address callee, uint256 msgValue, uint64 minGas, bytes calldata data, uint64 count)\\n external;\\n\\n /// Expects a call to an address with the specified calldata.\\n /// Calldata can either be a strict or a partial match.\\n function expectCall(address callee, bytes calldata data) external;\\n\\n /// Expects given number of calls to an address with the specified calldata.\\n function expectCall(address callee, bytes calldata data, uint64 count) external;\\n\\n /// Expects a call to an address with the specified `msg.value` and calldata.\\n function expectCall(address callee, uint256 msgValue, bytes calldata data) external;\\n\\n /// Expects given number of calls to an address with the specified `msg.value` and calldata.\\n function expectCall(address callee, uint256 msgValue, bytes calldata data, uint64 count) external;\\n\\n /// Expect a call to an address with the specified `msg.value`, gas, and calldata.\\n function expectCall(address callee, uint256 msgValue, uint64 gas, bytes calldata data) external;\\n\\n /// Expects given number of calls to an address with the specified `msg.value`, gas, and calldata.\\n function expectCall(address callee, uint256 msgValue, uint64 gas, bytes calldata data, uint64 count) external;\\n\\n /// Expects the deployment of the specified bytecode by the specified address using the CREATE opcode\\n function expectCreate(bytes calldata bytecode, address deployer) external;\\n\\n /// Expects the deployment of the specified bytecode by the specified address using the CREATE2 opcode\\n function expectCreate2(bytes calldata bytecode, address deployer) external;\\n\\n /// Prepare an expected anonymous log with (bool checkTopic1, bool checkTopic2, bool checkTopic3, bool checkData.).\\n /// Call this function, then emit an anonymous event, then call a function. Internally after the call, we check if\\n /// logs were emitted in the expected order with the expected topics and data (as specified by the booleans).\\n function expectEmitAnonymous(bool checkTopic0, bool checkTopic1, bool checkTopic2, bool checkTopic3, bool checkData)\\n external;\\n\\n /// Same as the previous method, but also checks supplied address against emitting contract.\\n function expectEmitAnonymous(\\n bool checkTopic0,\\n bool checkTopic1,\\n bool checkTopic2,\\n bool checkTopic3,\\n bool checkData,\\n address emitter\\n ) external;\\n\\n /// Prepare an expected anonymous log with all topic and data checks enabled.\\n /// Call this function, then emit an anonymous event, then call a function. Internally after the call, we check if\\n /// logs were emitted in the expected order with the expected topics and data.\\n function expectEmitAnonymous() external;\\n\\n /// Same as the previous method, but also checks supplied address against emitting contract.\\n function expectEmitAnonymous(address emitter) external;\\n\\n /// Prepare an expected log with (bool checkTopic1, bool checkTopic2, bool checkTopic3, bool checkData.).\\n /// Call this function, then emit an event, then call a function. Internally after the call, we check if\\n /// logs were emitted in the expected order with the expected topics and data (as specified by the booleans).\\n function expectEmit(bool checkTopic1, bool checkTopic2, bool checkTopic3, bool checkData) external;\\n\\n /// Same as the previous method, but also checks supplied address against emitting contract.\\n function expectEmit(bool checkTopic1, bool checkTopic2, bool checkTopic3, bool checkData, address emitter)\\n external;\\n\\n /// Prepare an expected log with all topic and data checks enabled.\\n /// Call this function, then emit an event, then call a function. Internally after the call, we check if\\n /// logs were emitted in the expected order with the expected topics and data.\\n function expectEmit() external;\\n\\n /// Same as the previous method, but also checks supplied address against emitting contract.\\n function expectEmit(address emitter) external;\\n\\n /// Expect a given number of logs with the provided topics.\\n function expectEmit(bool checkTopic1, bool checkTopic2, bool checkTopic3, bool checkData, uint64 count) external;\\n\\n /// Expect a given number of logs from a specific emitter with the provided topics.\\n function expectEmit(\\n bool checkTopic1,\\n bool checkTopic2,\\n bool checkTopic3,\\n bool checkData,\\n address emitter,\\n uint64 count\\n ) external;\\n\\n /// Expect a given number of logs with all topic and data checks enabled.\\n function expectEmit(uint64 count) external;\\n\\n /// Expect a given number of logs from a specific emitter with all topic and data checks enabled.\\n function expectEmit(address emitter, uint64 count) external;\\n\\n /// Expects an error on next call that starts with the revert data.\\n function expectPartialRevert(bytes4 revertData) external;\\n\\n /// Expects an error on next call to reverter address, that starts with the revert data.\\n function expectPartialRevert(bytes4 revertData, address reverter) external;\\n\\n /// Expects an error on next call with any revert data.\\n function expectRevert() external;\\n\\n /// Expects an error on next call that exactly matches the revert data.\\n function expectRevert(bytes4 revertData) external;\\n\\n /// Expects a `count` number of reverts from the upcoming calls from the reverter address that match the revert data.\\n function expectRevert(bytes4 revertData, address reverter, uint64 count) external;\\n\\n /// Expects a `count` number of reverts from the upcoming calls from the reverter address that exactly match the revert data.\\n function expectRevert(bytes calldata revertData, address reverter, uint64 count) external;\\n\\n /// Expects an error on next call that exactly matches the revert data.\\n function expectRevert(bytes calldata revertData) external;\\n\\n /// Expects an error with any revert data on next call to reverter address.\\n function expectRevert(address reverter) external;\\n\\n /// Expects an error from reverter address on next call, with any revert data.\\n function expectRevert(bytes4 revertData, address reverter) external;\\n\\n /// Expects an error from reverter address on next call, that exactly matches the revert data.\\n function expectRevert(bytes calldata revertData, address reverter) external;\\n\\n /// Expects a `count` number of reverts from the upcoming calls with any revert data or reverter.\\n function expectRevert(uint64 count) external;\\n\\n /// Expects a `count` number of reverts from the upcoming calls that match the revert data.\\n function expectRevert(bytes4 revertData, uint64 count) external;\\n\\n /// Expects a `count` number of reverts from the upcoming calls that exactly match the revert data.\\n function expectRevert(bytes calldata revertData, uint64 count) external;\\n\\n /// Expects a `count` number of reverts from the upcoming calls from the reverter address.\\n function expectRevert(address reverter, uint64 count) external;\\n\\n /// Only allows memory writes to offsets [0x00, 0x60) \\u222a [min, max) in the current subcontext. If any other\\n /// memory is written to, the test will fail. Can be called multiple times to add more ranges to the set.\\n function expectSafeMemory(uint64 min, uint64 max) external;\\n\\n /// Only allows memory writes to offsets [0x00, 0x60) \\u222a [min, max) in the next created subcontext.\\n /// If any other memory is written to, the test will fail. Can be called multiple times to add more ranges\\n /// to the set.\\n function expectSafeMemoryCall(uint64 min, uint64 max) external;\\n\\n /// Marks a test as skipped. Must be called at the top level of a test.\\n function skip(bool skipTest) external;\\n\\n /// Marks a test as skipped with a reason. Must be called at the top level of a test.\\n function skip(bool skipTest, string calldata reason) external;\\n\\n /// Stops all safe memory expectation in the current subcontext.\\n function stopExpectSafeMemory() external;\\n}\\n\",\"keccak256\":\"0xd91fb0df409fbd22463e937b48b9682d9333c5d4528d8fe7b36102a0323c44bf\",\"license\":\"MIT OR Apache-2.0\"},\"lib/forge-std/src/console.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity >=0.4.22 <0.9.0;\\n\\nlibrary console {\\n address constant CONSOLE_ADDRESS =\\n 0x000000000000000000636F6e736F6c652e6c6f67;\\n\\n function _sendLogPayloadImplementation(bytes memory payload) internal view {\\n address consoleAddress = CONSOLE_ADDRESS;\\n /// @solidity memory-safe-assembly\\n assembly {\\n pop(\\n staticcall(\\n gas(),\\n consoleAddress,\\n add(payload, 32),\\n mload(payload),\\n 0,\\n 0\\n )\\n )\\n }\\n }\\n\\n function _castToPure(\\n function(bytes memory) internal view fnIn\\n ) internal pure returns (function(bytes memory) pure fnOut) {\\n assembly {\\n fnOut := fnIn\\n }\\n }\\n\\n function _sendLogPayload(bytes memory payload) internal pure {\\n _castToPure(_sendLogPayloadImplementation)(payload);\\n }\\n\\n function log() internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log()\\\"));\\n }\\n\\n function logInt(int256 p0) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(int256)\\\", p0));\\n }\\n\\n function logUint(uint256 p0) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256)\\\", p0));\\n }\\n\\n function logString(string memory p0) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string)\\\", p0));\\n }\\n\\n function logBool(bool p0) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool)\\\", p0));\\n }\\n\\n function logAddress(address p0) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address)\\\", p0));\\n }\\n\\n function logBytes(bytes memory p0) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bytes)\\\", p0));\\n }\\n\\n function logBytes1(bytes1 p0) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bytes1)\\\", p0));\\n }\\n\\n function logBytes2(bytes2 p0) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bytes2)\\\", p0));\\n }\\n\\n function logBytes3(bytes3 p0) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bytes3)\\\", p0));\\n }\\n\\n function logBytes4(bytes4 p0) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bytes4)\\\", p0));\\n }\\n\\n function logBytes5(bytes5 p0) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bytes5)\\\", p0));\\n }\\n\\n function logBytes6(bytes6 p0) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bytes6)\\\", p0));\\n }\\n\\n function logBytes7(bytes7 p0) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bytes7)\\\", p0));\\n }\\n\\n function logBytes8(bytes8 p0) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bytes8)\\\", p0));\\n }\\n\\n function logBytes9(bytes9 p0) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bytes9)\\\", p0));\\n }\\n\\n function logBytes10(bytes10 p0) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bytes10)\\\", p0));\\n }\\n\\n function logBytes11(bytes11 p0) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bytes11)\\\", p0));\\n }\\n\\n function logBytes12(bytes12 p0) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bytes12)\\\", p0));\\n }\\n\\n function logBytes13(bytes13 p0) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bytes13)\\\", p0));\\n }\\n\\n function logBytes14(bytes14 p0) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bytes14)\\\", p0));\\n }\\n\\n function logBytes15(bytes15 p0) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bytes15)\\\", p0));\\n }\\n\\n function logBytes16(bytes16 p0) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bytes16)\\\", p0));\\n }\\n\\n function logBytes17(bytes17 p0) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bytes17)\\\", p0));\\n }\\n\\n function logBytes18(bytes18 p0) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bytes18)\\\", p0));\\n }\\n\\n function logBytes19(bytes19 p0) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bytes19)\\\", p0));\\n }\\n\\n function logBytes20(bytes20 p0) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bytes20)\\\", p0));\\n }\\n\\n function logBytes21(bytes21 p0) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bytes21)\\\", p0));\\n }\\n\\n function logBytes22(bytes22 p0) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bytes22)\\\", p0));\\n }\\n\\n function logBytes23(bytes23 p0) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bytes23)\\\", p0));\\n }\\n\\n function logBytes24(bytes24 p0) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bytes24)\\\", p0));\\n }\\n\\n function logBytes25(bytes25 p0) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bytes25)\\\", p0));\\n }\\n\\n function logBytes26(bytes26 p0) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bytes26)\\\", p0));\\n }\\n\\n function logBytes27(bytes27 p0) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bytes27)\\\", p0));\\n }\\n\\n function logBytes28(bytes28 p0) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bytes28)\\\", p0));\\n }\\n\\n function logBytes29(bytes29 p0) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bytes29)\\\", p0));\\n }\\n\\n function logBytes30(bytes30 p0) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bytes30)\\\", p0));\\n }\\n\\n function logBytes31(bytes31 p0) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bytes31)\\\", p0));\\n }\\n\\n function logBytes32(bytes32 p0) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bytes32)\\\", p0));\\n }\\n\\n function log(uint256 p0) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256)\\\", p0));\\n }\\n\\n function log(int256 p0) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(int256)\\\", p0));\\n }\\n\\n function log(string memory p0) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string)\\\", p0));\\n }\\n\\n function log(bool p0) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool)\\\", p0));\\n }\\n\\n function log(address p0) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address)\\\", p0));\\n }\\n\\n function log(uint256 p0, uint256 p1) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,uint256)\\\", p0, p1));\\n }\\n\\n function log(uint256 p0, string memory p1) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,string)\\\", p0, p1));\\n }\\n\\n function log(uint256 p0, bool p1) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,bool)\\\", p0, p1));\\n }\\n\\n function log(uint256 p0, address p1) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,address)\\\", p0, p1));\\n }\\n\\n function log(string memory p0, uint256 p1) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,uint256)\\\", p0, p1));\\n }\\n\\n function log(string memory p0, int256 p1) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,int256)\\\", p0, p1));\\n }\\n\\n function log(string memory p0, string memory p1) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,string)\\\", p0, p1));\\n }\\n\\n function log(string memory p0, bool p1) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,bool)\\\", p0, p1));\\n }\\n\\n function log(string memory p0, address p1) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,address)\\\", p0, p1));\\n }\\n\\n function log(bool p0, uint256 p1) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,uint256)\\\", p0, p1));\\n }\\n\\n function log(bool p0, string memory p1) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,string)\\\", p0, p1));\\n }\\n\\n function log(bool p0, bool p1) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,bool)\\\", p0, p1));\\n }\\n\\n function log(bool p0, address p1) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,address)\\\", p0, p1));\\n }\\n\\n function log(address p0, uint256 p1) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,uint256)\\\", p0, p1));\\n }\\n\\n function log(address p0, string memory p1) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,string)\\\", p0, p1));\\n }\\n\\n function log(address p0, bool p1) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,bool)\\\", p0, p1));\\n }\\n\\n function log(address p0, address p1) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,address)\\\", p0, p1));\\n }\\n\\n function log(uint256 p0, uint256 p1, uint256 p2) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,uint256,uint256)\\\", p0, p1, p2));\\n }\\n\\n function log(uint256 p0, uint256 p1, string memory p2) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,uint256,string)\\\", p0, p1, p2));\\n }\\n\\n function log(uint256 p0, uint256 p1, bool p2) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,uint256,bool)\\\", p0, p1, p2));\\n }\\n\\n function log(uint256 p0, uint256 p1, address p2) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,uint256,address)\\\", p0, p1, p2));\\n }\\n\\n function log(uint256 p0, string memory p1, uint256 p2) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,string,uint256)\\\", p0, p1, p2));\\n }\\n\\n function log(uint256 p0, string memory p1, string memory p2) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,string,string)\\\", p0, p1, p2));\\n }\\n\\n function log(uint256 p0, string memory p1, bool p2) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,string,bool)\\\", p0, p1, p2));\\n }\\n\\n function log(uint256 p0, string memory p1, address p2) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,string,address)\\\", p0, p1, p2));\\n }\\n\\n function log(uint256 p0, bool p1, uint256 p2) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,bool,uint256)\\\", p0, p1, p2));\\n }\\n\\n function log(uint256 p0, bool p1, string memory p2) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,bool,string)\\\", p0, p1, p2));\\n }\\n\\n function log(uint256 p0, bool p1, bool p2) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,bool,bool)\\\", p0, p1, p2));\\n }\\n\\n function log(uint256 p0, bool p1, address p2) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,bool,address)\\\", p0, p1, p2));\\n }\\n\\n function log(uint256 p0, address p1, uint256 p2) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,address,uint256)\\\", p0, p1, p2));\\n }\\n\\n function log(uint256 p0, address p1, string memory p2) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,address,string)\\\", p0, p1, p2));\\n }\\n\\n function log(uint256 p0, address p1, bool p2) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,address,bool)\\\", p0, p1, p2));\\n }\\n\\n function log(uint256 p0, address p1, address p2) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,address,address)\\\", p0, p1, p2));\\n }\\n\\n function log(string memory p0, uint256 p1, uint256 p2) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,uint256,uint256)\\\", p0, p1, p2));\\n }\\n\\n function log(string memory p0, uint256 p1, string memory p2) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,uint256,string)\\\", p0, p1, p2));\\n }\\n\\n function log(string memory p0, uint256 p1, bool p2) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,uint256,bool)\\\", p0, p1, p2));\\n }\\n\\n function log(string memory p0, uint256 p1, address p2) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,uint256,address)\\\", p0, p1, p2));\\n }\\n\\n function log(string memory p0, string memory p1, uint256 p2) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,string,uint256)\\\", p0, p1, p2));\\n }\\n\\n function log(string memory p0, string memory p1, string memory p2) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,string,string)\\\", p0, p1, p2));\\n }\\n\\n function log(string memory p0, string memory p1, bool p2) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,string,bool)\\\", p0, p1, p2));\\n }\\n\\n function log(string memory p0, string memory p1, address p2) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,string,address)\\\", p0, p1, p2));\\n }\\n\\n function log(string memory p0, bool p1, uint256 p2) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,bool,uint256)\\\", p0, p1, p2));\\n }\\n\\n function log(string memory p0, bool p1, string memory p2) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,bool,string)\\\", p0, p1, p2));\\n }\\n\\n function log(string memory p0, bool p1, bool p2) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,bool,bool)\\\", p0, p1, p2));\\n }\\n\\n function log(string memory p0, bool p1, address p2) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,bool,address)\\\", p0, p1, p2));\\n }\\n\\n function log(string memory p0, address p1, uint256 p2) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,address,uint256)\\\", p0, p1, p2));\\n }\\n\\n function log(string memory p0, address p1, string memory p2) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,address,string)\\\", p0, p1, p2));\\n }\\n\\n function log(string memory p0, address p1, bool p2) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,address,bool)\\\", p0, p1, p2));\\n }\\n\\n function log(string memory p0, address p1, address p2) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,address,address)\\\", p0, p1, p2));\\n }\\n\\n function log(bool p0, uint256 p1, uint256 p2) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,uint256,uint256)\\\", p0, p1, p2));\\n }\\n\\n function log(bool p0, uint256 p1, string memory p2) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,uint256,string)\\\", p0, p1, p2));\\n }\\n\\n function log(bool p0, uint256 p1, bool p2) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,uint256,bool)\\\", p0, p1, p2));\\n }\\n\\n function log(bool p0, uint256 p1, address p2) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,uint256,address)\\\", p0, p1, p2));\\n }\\n\\n function log(bool p0, string memory p1, uint256 p2) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,string,uint256)\\\", p0, p1, p2));\\n }\\n\\n function log(bool p0, string memory p1, string memory p2) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,string,string)\\\", p0, p1, p2));\\n }\\n\\n function log(bool p0, string memory p1, bool p2) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,string,bool)\\\", p0, p1, p2));\\n }\\n\\n function log(bool p0, string memory p1, address p2) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,string,address)\\\", p0, p1, p2));\\n }\\n\\n function log(bool p0, bool p1, uint256 p2) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,bool,uint256)\\\", p0, p1, p2));\\n }\\n\\n function log(bool p0, bool p1, string memory p2) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,bool,string)\\\", p0, p1, p2));\\n }\\n\\n function log(bool p0, bool p1, bool p2) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,bool,bool)\\\", p0, p1, p2));\\n }\\n\\n function log(bool p0, bool p1, address p2) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,bool,address)\\\", p0, p1, p2));\\n }\\n\\n function log(bool p0, address p1, uint256 p2) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,address,uint256)\\\", p0, p1, p2));\\n }\\n\\n function log(bool p0, address p1, string memory p2) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,address,string)\\\", p0, p1, p2));\\n }\\n\\n function log(bool p0, address p1, bool p2) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,address,bool)\\\", p0, p1, p2));\\n }\\n\\n function log(bool p0, address p1, address p2) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,address,address)\\\", p0, p1, p2));\\n }\\n\\n function log(address p0, uint256 p1, uint256 p2) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,uint256,uint256)\\\", p0, p1, p2));\\n }\\n\\n function log(address p0, uint256 p1, string memory p2) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,uint256,string)\\\", p0, p1, p2));\\n }\\n\\n function log(address p0, uint256 p1, bool p2) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,uint256,bool)\\\", p0, p1, p2));\\n }\\n\\n function log(address p0, uint256 p1, address p2) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,uint256,address)\\\", p0, p1, p2));\\n }\\n\\n function log(address p0, string memory p1, uint256 p2) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,string,uint256)\\\", p0, p1, p2));\\n }\\n\\n function log(address p0, string memory p1, string memory p2) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,string,string)\\\", p0, p1, p2));\\n }\\n\\n function log(address p0, string memory p1, bool p2) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,string,bool)\\\", p0, p1, p2));\\n }\\n\\n function log(address p0, string memory p1, address p2) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,string,address)\\\", p0, p1, p2));\\n }\\n\\n function log(address p0, bool p1, uint256 p2) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,bool,uint256)\\\", p0, p1, p2));\\n }\\n\\n function log(address p0, bool p1, string memory p2) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,bool,string)\\\", p0, p1, p2));\\n }\\n\\n function log(address p0, bool p1, bool p2) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,bool,bool)\\\", p0, p1, p2));\\n }\\n\\n function log(address p0, bool p1, address p2) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,bool,address)\\\", p0, p1, p2));\\n }\\n\\n function log(address p0, address p1, uint256 p2) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,address,uint256)\\\", p0, p1, p2));\\n }\\n\\n function log(address p0, address p1, string memory p2) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,address,string)\\\", p0, p1, p2));\\n }\\n\\n function log(address p0, address p1, bool p2) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,address,bool)\\\", p0, p1, p2));\\n }\\n\\n function log(address p0, address p1, address p2) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,address,address)\\\", p0, p1, p2));\\n }\\n\\n function log(uint256 p0, uint256 p1, uint256 p2, uint256 p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,uint256,uint256,uint256)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(uint256 p0, uint256 p1, uint256 p2, string memory p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,uint256,uint256,string)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(uint256 p0, uint256 p1, uint256 p2, bool p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,uint256,uint256,bool)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(uint256 p0, uint256 p1, uint256 p2, address p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,uint256,uint256,address)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(uint256 p0, uint256 p1, string memory p2, uint256 p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,uint256,string,uint256)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(uint256 p0, uint256 p1, string memory p2, string memory p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,uint256,string,string)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(uint256 p0, uint256 p1, string memory p2, bool p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,uint256,string,bool)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(uint256 p0, uint256 p1, string memory p2, address p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,uint256,string,address)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(uint256 p0, uint256 p1, bool p2, uint256 p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,uint256,bool,uint256)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(uint256 p0, uint256 p1, bool p2, string memory p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,uint256,bool,string)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(uint256 p0, uint256 p1, bool p2, bool p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,uint256,bool,bool)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(uint256 p0, uint256 p1, bool p2, address p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,uint256,bool,address)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(uint256 p0, uint256 p1, address p2, uint256 p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,uint256,address,uint256)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(uint256 p0, uint256 p1, address p2, string memory p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,uint256,address,string)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(uint256 p0, uint256 p1, address p2, bool p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,uint256,address,bool)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(uint256 p0, uint256 p1, address p2, address p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,uint256,address,address)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(uint256 p0, string memory p1, uint256 p2, uint256 p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,string,uint256,uint256)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(uint256 p0, string memory p1, uint256 p2, string memory p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,string,uint256,string)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(uint256 p0, string memory p1, uint256 p2, bool p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,string,uint256,bool)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(uint256 p0, string memory p1, uint256 p2, address p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,string,uint256,address)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(uint256 p0, string memory p1, string memory p2, uint256 p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,string,string,uint256)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(uint256 p0, string memory p1, string memory p2, string memory p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,string,string,string)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(uint256 p0, string memory p1, string memory p2, bool p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,string,string,bool)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(uint256 p0, string memory p1, string memory p2, address p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,string,string,address)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(uint256 p0, string memory p1, bool p2, uint256 p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,string,bool,uint256)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(uint256 p0, string memory p1, bool p2, string memory p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,string,bool,string)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(uint256 p0, string memory p1, bool p2, bool p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,string,bool,bool)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(uint256 p0, string memory p1, bool p2, address p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,string,bool,address)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(uint256 p0, string memory p1, address p2, uint256 p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,string,address,uint256)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(uint256 p0, string memory p1, address p2, string memory p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,string,address,string)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(uint256 p0, string memory p1, address p2, bool p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,string,address,bool)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(uint256 p0, string memory p1, address p2, address p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,string,address,address)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(uint256 p0, bool p1, uint256 p2, uint256 p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,bool,uint256,uint256)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(uint256 p0, bool p1, uint256 p2, string memory p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,bool,uint256,string)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(uint256 p0, bool p1, uint256 p2, bool p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,bool,uint256,bool)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(uint256 p0, bool p1, uint256 p2, address p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,bool,uint256,address)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(uint256 p0, bool p1, string memory p2, uint256 p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,bool,string,uint256)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(uint256 p0, bool p1, string memory p2, string memory p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,bool,string,string)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(uint256 p0, bool p1, string memory p2, bool p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,bool,string,bool)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(uint256 p0, bool p1, string memory p2, address p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,bool,string,address)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(uint256 p0, bool p1, bool p2, uint256 p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,bool,bool,uint256)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(uint256 p0, bool p1, bool p2, string memory p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,bool,bool,string)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(uint256 p0, bool p1, bool p2, bool p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,bool,bool,bool)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(uint256 p0, bool p1, bool p2, address p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,bool,bool,address)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(uint256 p0, bool p1, address p2, uint256 p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,bool,address,uint256)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(uint256 p0, bool p1, address p2, string memory p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,bool,address,string)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(uint256 p0, bool p1, address p2, bool p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,bool,address,bool)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(uint256 p0, bool p1, address p2, address p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,bool,address,address)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(uint256 p0, address p1, uint256 p2, uint256 p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,address,uint256,uint256)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(uint256 p0, address p1, uint256 p2, string memory p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,address,uint256,string)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(uint256 p0, address p1, uint256 p2, bool p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,address,uint256,bool)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(uint256 p0, address p1, uint256 p2, address p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,address,uint256,address)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(uint256 p0, address p1, string memory p2, uint256 p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,address,string,uint256)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(uint256 p0, address p1, string memory p2, string memory p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,address,string,string)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(uint256 p0, address p1, string memory p2, bool p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,address,string,bool)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(uint256 p0, address p1, string memory p2, address p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,address,string,address)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(uint256 p0, address p1, bool p2, uint256 p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,address,bool,uint256)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(uint256 p0, address p1, bool p2, string memory p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,address,bool,string)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(uint256 p0, address p1, bool p2, bool p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,address,bool,bool)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(uint256 p0, address p1, bool p2, address p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,address,bool,address)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(uint256 p0, address p1, address p2, uint256 p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,address,address,uint256)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(uint256 p0, address p1, address p2, string memory p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,address,address,string)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(uint256 p0, address p1, address p2, bool p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,address,address,bool)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(uint256 p0, address p1, address p2, address p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,address,address,address)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(string memory p0, uint256 p1, uint256 p2, uint256 p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,uint256,uint256,uint256)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(string memory p0, uint256 p1, uint256 p2, string memory p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,uint256,uint256,string)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(string memory p0, uint256 p1, uint256 p2, bool p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,uint256,uint256,bool)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(string memory p0, uint256 p1, uint256 p2, address p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,uint256,uint256,address)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(string memory p0, uint256 p1, string memory p2, uint256 p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,uint256,string,uint256)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(string memory p0, uint256 p1, string memory p2, string memory p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,uint256,string,string)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(string memory p0, uint256 p1, string memory p2, bool p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,uint256,string,bool)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(string memory p0, uint256 p1, string memory p2, address p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,uint256,string,address)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(string memory p0, uint256 p1, bool p2, uint256 p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,uint256,bool,uint256)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(string memory p0, uint256 p1, bool p2, string memory p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,uint256,bool,string)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(string memory p0, uint256 p1, bool p2, bool p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,uint256,bool,bool)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(string memory p0, uint256 p1, bool p2, address p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,uint256,bool,address)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(string memory p0, uint256 p1, address p2, uint256 p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,uint256,address,uint256)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(string memory p0, uint256 p1, address p2, string memory p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,uint256,address,string)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(string memory p0, uint256 p1, address p2, bool p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,uint256,address,bool)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(string memory p0, uint256 p1, address p2, address p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,uint256,address,address)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(string memory p0, string memory p1, uint256 p2, uint256 p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,string,uint256,uint256)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(string memory p0, string memory p1, uint256 p2, string memory p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,string,uint256,string)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(string memory p0, string memory p1, uint256 p2, bool p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,string,uint256,bool)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(string memory p0, string memory p1, uint256 p2, address p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,string,uint256,address)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(string memory p0, string memory p1, string memory p2, uint256 p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,string,string,uint256)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(string memory p0, string memory p1, string memory p2, string memory p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,string,string,string)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(string memory p0, string memory p1, string memory p2, bool p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,string,string,bool)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(string memory p0, string memory p1, string memory p2, address p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,string,string,address)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(string memory p0, string memory p1, bool p2, uint256 p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,string,bool,uint256)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(string memory p0, string memory p1, bool p2, string memory p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,string,bool,string)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(string memory p0, string memory p1, bool p2, bool p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,string,bool,bool)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(string memory p0, string memory p1, bool p2, address p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,string,bool,address)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(string memory p0, string memory p1, address p2, uint256 p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,string,address,uint256)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(string memory p0, string memory p1, address p2, string memory p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,string,address,string)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(string memory p0, string memory p1, address p2, bool p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,string,address,bool)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(string memory p0, string memory p1, address p2, address p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,string,address,address)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(string memory p0, bool p1, uint256 p2, uint256 p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,bool,uint256,uint256)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(string memory p0, bool p1, uint256 p2, string memory p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,bool,uint256,string)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(string memory p0, bool p1, uint256 p2, bool p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,bool,uint256,bool)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(string memory p0, bool p1, uint256 p2, address p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,bool,uint256,address)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(string memory p0, bool p1, string memory p2, uint256 p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,bool,string,uint256)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(string memory p0, bool p1, string memory p2, string memory p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,bool,string,string)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(string memory p0, bool p1, string memory p2, bool p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,bool,string,bool)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(string memory p0, bool p1, string memory p2, address p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,bool,string,address)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(string memory p0, bool p1, bool p2, uint256 p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,bool,bool,uint256)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(string memory p0, bool p1, bool p2, string memory p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,bool,bool,string)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(string memory p0, bool p1, bool p2, bool p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,bool,bool,bool)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(string memory p0, bool p1, bool p2, address p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,bool,bool,address)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(string memory p0, bool p1, address p2, uint256 p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,bool,address,uint256)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(string memory p0, bool p1, address p2, string memory p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,bool,address,string)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(string memory p0, bool p1, address p2, bool p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,bool,address,bool)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(string memory p0, bool p1, address p2, address p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,bool,address,address)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(string memory p0, address p1, uint256 p2, uint256 p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,address,uint256,uint256)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(string memory p0, address p1, uint256 p2, string memory p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,address,uint256,string)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(string memory p0, address p1, uint256 p2, bool p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,address,uint256,bool)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(string memory p0, address p1, uint256 p2, address p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,address,uint256,address)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(string memory p0, address p1, string memory p2, uint256 p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,address,string,uint256)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(string memory p0, address p1, string memory p2, string memory p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,address,string,string)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(string memory p0, address p1, string memory p2, bool p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,address,string,bool)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(string memory p0, address p1, string memory p2, address p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,address,string,address)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(string memory p0, address p1, bool p2, uint256 p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,address,bool,uint256)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(string memory p0, address p1, bool p2, string memory p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,address,bool,string)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(string memory p0, address p1, bool p2, bool p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,address,bool,bool)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(string memory p0, address p1, bool p2, address p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,address,bool,address)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(string memory p0, address p1, address p2, uint256 p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,address,address,uint256)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(string memory p0, address p1, address p2, string memory p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,address,address,string)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(string memory p0, address p1, address p2, bool p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,address,address,bool)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(string memory p0, address p1, address p2, address p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,address,address,address)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(bool p0, uint256 p1, uint256 p2, uint256 p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,uint256,uint256,uint256)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(bool p0, uint256 p1, uint256 p2, string memory p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,uint256,uint256,string)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(bool p0, uint256 p1, uint256 p2, bool p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,uint256,uint256,bool)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(bool p0, uint256 p1, uint256 p2, address p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,uint256,uint256,address)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(bool p0, uint256 p1, string memory p2, uint256 p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,uint256,string,uint256)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(bool p0, uint256 p1, string memory p2, string memory p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,uint256,string,string)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(bool p0, uint256 p1, string memory p2, bool p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,uint256,string,bool)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(bool p0, uint256 p1, string memory p2, address p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,uint256,string,address)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(bool p0, uint256 p1, bool p2, uint256 p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,uint256,bool,uint256)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(bool p0, uint256 p1, bool p2, string memory p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,uint256,bool,string)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(bool p0, uint256 p1, bool p2, bool p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,uint256,bool,bool)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(bool p0, uint256 p1, bool p2, address p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,uint256,bool,address)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(bool p0, uint256 p1, address p2, uint256 p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,uint256,address,uint256)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(bool p0, uint256 p1, address p2, string memory p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,uint256,address,string)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(bool p0, uint256 p1, address p2, bool p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,uint256,address,bool)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(bool p0, uint256 p1, address p2, address p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,uint256,address,address)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(bool p0, string memory p1, uint256 p2, uint256 p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,string,uint256,uint256)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(bool p0, string memory p1, uint256 p2, string memory p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,string,uint256,string)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(bool p0, string memory p1, uint256 p2, bool p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,string,uint256,bool)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(bool p0, string memory p1, uint256 p2, address p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,string,uint256,address)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(bool p0, string memory p1, string memory p2, uint256 p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,string,string,uint256)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(bool p0, string memory p1, string memory p2, string memory p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,string,string,string)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(bool p0, string memory p1, string memory p2, bool p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,string,string,bool)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(bool p0, string memory p1, string memory p2, address p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,string,string,address)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(bool p0, string memory p1, bool p2, uint256 p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,string,bool,uint256)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(bool p0, string memory p1, bool p2, string memory p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,string,bool,string)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(bool p0, string memory p1, bool p2, bool p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,string,bool,bool)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(bool p0, string memory p1, bool p2, address p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,string,bool,address)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(bool p0, string memory p1, address p2, uint256 p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,string,address,uint256)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(bool p0, string memory p1, address p2, string memory p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,string,address,string)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(bool p0, string memory p1, address p2, bool p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,string,address,bool)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(bool p0, string memory p1, address p2, address p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,string,address,address)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(bool p0, bool p1, uint256 p2, uint256 p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,bool,uint256,uint256)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(bool p0, bool p1, uint256 p2, string memory p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,bool,uint256,string)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(bool p0, bool p1, uint256 p2, bool p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,bool,uint256,bool)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(bool p0, bool p1, uint256 p2, address p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,bool,uint256,address)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(bool p0, bool p1, string memory p2, uint256 p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,bool,string,uint256)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(bool p0, bool p1, string memory p2, string memory p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,bool,string,string)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(bool p0, bool p1, string memory p2, bool p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,bool,string,bool)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(bool p0, bool p1, string memory p2, address p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,bool,string,address)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(bool p0, bool p1, bool p2, uint256 p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,bool,bool,uint256)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(bool p0, bool p1, bool p2, string memory p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,bool,bool,string)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(bool p0, bool p1, bool p2, bool p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,bool,bool,bool)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(bool p0, bool p1, bool p2, address p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,bool,bool,address)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(bool p0, bool p1, address p2, uint256 p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,bool,address,uint256)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(bool p0, bool p1, address p2, string memory p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,bool,address,string)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(bool p0, bool p1, address p2, bool p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,bool,address,bool)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(bool p0, bool p1, address p2, address p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,bool,address,address)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(bool p0, address p1, uint256 p2, uint256 p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,address,uint256,uint256)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(bool p0, address p1, uint256 p2, string memory p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,address,uint256,string)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(bool p0, address p1, uint256 p2, bool p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,address,uint256,bool)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(bool p0, address p1, uint256 p2, address p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,address,uint256,address)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(bool p0, address p1, string memory p2, uint256 p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,address,string,uint256)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(bool p0, address p1, string memory p2, string memory p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,address,string,string)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(bool p0, address p1, string memory p2, bool p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,address,string,bool)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(bool p0, address p1, string memory p2, address p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,address,string,address)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(bool p0, address p1, bool p2, uint256 p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,address,bool,uint256)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(bool p0, address p1, bool p2, string memory p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,address,bool,string)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(bool p0, address p1, bool p2, bool p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,address,bool,bool)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(bool p0, address p1, bool p2, address p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,address,bool,address)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(bool p0, address p1, address p2, uint256 p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,address,address,uint256)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(bool p0, address p1, address p2, string memory p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,address,address,string)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(bool p0, address p1, address p2, bool p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,address,address,bool)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(bool p0, address p1, address p2, address p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,address,address,address)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(address p0, uint256 p1, uint256 p2, uint256 p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,uint256,uint256,uint256)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(address p0, uint256 p1, uint256 p2, string memory p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,uint256,uint256,string)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(address p0, uint256 p1, uint256 p2, bool p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,uint256,uint256,bool)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(address p0, uint256 p1, uint256 p2, address p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,uint256,uint256,address)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(address p0, uint256 p1, string memory p2, uint256 p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,uint256,string,uint256)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(address p0, uint256 p1, string memory p2, string memory p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,uint256,string,string)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(address p0, uint256 p1, string memory p2, bool p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,uint256,string,bool)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(address p0, uint256 p1, string memory p2, address p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,uint256,string,address)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(address p0, uint256 p1, bool p2, uint256 p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,uint256,bool,uint256)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(address p0, uint256 p1, bool p2, string memory p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,uint256,bool,string)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(address p0, uint256 p1, bool p2, bool p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,uint256,bool,bool)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(address p0, uint256 p1, bool p2, address p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,uint256,bool,address)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(address p0, uint256 p1, address p2, uint256 p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,uint256,address,uint256)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(address p0, uint256 p1, address p2, string memory p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,uint256,address,string)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(address p0, uint256 p1, address p2, bool p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,uint256,address,bool)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(address p0, uint256 p1, address p2, address p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,uint256,address,address)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(address p0, string memory p1, uint256 p2, uint256 p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,string,uint256,uint256)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(address p0, string memory p1, uint256 p2, string memory p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,string,uint256,string)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(address p0, string memory p1, uint256 p2, bool p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,string,uint256,bool)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(address p0, string memory p1, uint256 p2, address p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,string,uint256,address)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(address p0, string memory p1, string memory p2, uint256 p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,string,string,uint256)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(address p0, string memory p1, string memory p2, string memory p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,string,string,string)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(address p0, string memory p1, string memory p2, bool p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,string,string,bool)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(address p0, string memory p1, string memory p2, address p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,string,string,address)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(address p0, string memory p1, bool p2, uint256 p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,string,bool,uint256)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(address p0, string memory p1, bool p2, string memory p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,string,bool,string)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(address p0, string memory p1, bool p2, bool p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,string,bool,bool)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(address p0, string memory p1, bool p2, address p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,string,bool,address)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(address p0, string memory p1, address p2, uint256 p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,string,address,uint256)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(address p0, string memory p1, address p2, string memory p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,string,address,string)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(address p0, string memory p1, address p2, bool p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,string,address,bool)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(address p0, string memory p1, address p2, address p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,string,address,address)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(address p0, bool p1, uint256 p2, uint256 p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,bool,uint256,uint256)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(address p0, bool p1, uint256 p2, string memory p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,bool,uint256,string)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(address p0, bool p1, uint256 p2, bool p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,bool,uint256,bool)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(address p0, bool p1, uint256 p2, address p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,bool,uint256,address)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(address p0, bool p1, string memory p2, uint256 p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,bool,string,uint256)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(address p0, bool p1, string memory p2, string memory p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,bool,string,string)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(address p0, bool p1, string memory p2, bool p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,bool,string,bool)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(address p0, bool p1, string memory p2, address p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,bool,string,address)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(address p0, bool p1, bool p2, uint256 p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,bool,bool,uint256)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(address p0, bool p1, bool p2, string memory p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,bool,bool,string)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(address p0, bool p1, bool p2, bool p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,bool,bool,bool)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(address p0, bool p1, bool p2, address p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,bool,bool,address)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(address p0, bool p1, address p2, uint256 p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,bool,address,uint256)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(address p0, bool p1, address p2, string memory p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,bool,address,string)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(address p0, bool p1, address p2, bool p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,bool,address,bool)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(address p0, bool p1, address p2, address p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,bool,address,address)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(address p0, address p1, uint256 p2, uint256 p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,address,uint256,uint256)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(address p0, address p1, uint256 p2, string memory p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,address,uint256,string)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(address p0, address p1, uint256 p2, bool p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,address,uint256,bool)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(address p0, address p1, uint256 p2, address p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,address,uint256,address)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(address p0, address p1, string memory p2, uint256 p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,address,string,uint256)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(address p0, address p1, string memory p2, string memory p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,address,string,string)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(address p0, address p1, string memory p2, bool p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,address,string,bool)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(address p0, address p1, string memory p2, address p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,address,string,address)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(address p0, address p1, bool p2, uint256 p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,address,bool,uint256)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(address p0, address p1, bool p2, string memory p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,address,bool,string)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(address p0, address p1, bool p2, bool p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,address,bool,bool)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(address p0, address p1, bool p2, address p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,address,bool,address)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(address p0, address p1, address p2, uint256 p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,address,address,uint256)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(address p0, address p1, address p2, string memory p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,address,address,string)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(address p0, address p1, address p2, bool p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,address,address,bool)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(address p0, address p1, address p2, address p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,address,address,address)\\\", p0, p1, p2, p3));\\n }\\n}\\n\",\"keccak256\":\"0x4bbf47eb762cef93729d6ef15e78789957147039b113e5d4df48e3d3fd16d0f5\",\"license\":\"MIT\"},\"lib/forge-std/src/console2.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity >=0.4.22 <0.9.0;\\n\\nimport {console as console2} from \\\"./console.sol\\\";\\n\",\"keccak256\":\"0x3b8fe79f48f065a4e4d35362171304a33784c3a90febae5f2787805a438de12f\",\"license\":\"MIT\"},\"lib/forge-std/src/interfaces/IMulticall3.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity >=0.6.2 <0.9.0;\\n\\npragma experimental ABIEncoderV2;\\n\\ninterface IMulticall3 {\\n struct Call {\\n address target;\\n bytes callData;\\n }\\n\\n struct Call3 {\\n address target;\\n bool allowFailure;\\n bytes callData;\\n }\\n\\n struct Call3Value {\\n address target;\\n bool allowFailure;\\n uint256 value;\\n bytes callData;\\n }\\n\\n struct Result {\\n bool success;\\n bytes returnData;\\n }\\n\\n function aggregate(Call[] calldata calls)\\n external\\n payable\\n returns (uint256 blockNumber, bytes[] memory returnData);\\n\\n function aggregate3(Call3[] calldata calls) external payable returns (Result[] memory returnData);\\n\\n function aggregate3Value(Call3Value[] calldata calls) external payable returns (Result[] memory returnData);\\n\\n function blockAndAggregate(Call[] calldata calls)\\n external\\n payable\\n returns (uint256 blockNumber, bytes32 blockHash, Result[] memory returnData);\\n\\n function getBasefee() external view returns (uint256 basefee);\\n\\n function getBlockHash(uint256 blockNumber) external view returns (bytes32 blockHash);\\n\\n function getBlockNumber() external view returns (uint256 blockNumber);\\n\\n function getChainId() external view returns (uint256 chainid);\\n\\n function getCurrentBlockCoinbase() external view returns (address coinbase);\\n\\n function getCurrentBlockDifficulty() external view returns (uint256 difficulty);\\n\\n function getCurrentBlockGasLimit() external view returns (uint256 gaslimit);\\n\\n function getCurrentBlockTimestamp() external view returns (uint256 timestamp);\\n\\n function getEthBalance(address addr) external view returns (uint256 balance);\\n\\n function getLastBlockHash() external view returns (bytes32 blockHash);\\n\\n function tryAggregate(bool requireSuccess, Call[] calldata calls)\\n external\\n payable\\n returns (Result[] memory returnData);\\n\\n function tryBlockAndAggregate(bool requireSuccess, Call[] calldata calls)\\n external\\n payable\\n returns (uint256 blockNumber, bytes32 blockHash, Result[] memory returnData);\\n}\\n\",\"keccak256\":\"0x7aac1389150499a922d1f9ef5749c908cef127cb2075b92fa17e9cb611263d0a\",\"license\":\"MIT\"},\"lib/forge-std/src/safeconsole.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity >=0.6.2 <0.9.0;\\n\\n/// @author philogy \\n/// @dev Code generated automatically by script.\\nlibrary safeconsole {\\n uint256 constant CONSOLE_ADDR = 0x000000000000000000000000000000000000000000636F6e736F6c652e6c6f67;\\n\\n // Credit to [0age](https://twitter.com/z0age/status/1654922202930888704) and [0xdapper](https://github.com/foundry-rs/forge-std/pull/374)\\n // for the view-to-pure log trick.\\n function _sendLogPayload(uint256 offset, uint256 size) private pure {\\n function(uint256, uint256) internal view fnIn = _sendLogPayloadView;\\n function(uint256, uint256) internal pure pureSendLogPayload;\\n /// @solidity memory-safe-assembly\\n assembly {\\n pureSendLogPayload := fnIn\\n }\\n pureSendLogPayload(offset, size);\\n }\\n\\n function _sendLogPayloadView(uint256 offset, uint256 size) private view {\\n /// @solidity memory-safe-assembly\\n assembly {\\n pop(staticcall(gas(), CONSOLE_ADDR, offset, size, 0x0, 0x0))\\n }\\n }\\n\\n function _memcopy(uint256 fromOffset, uint256 toOffset, uint256 length) private pure {\\n function(uint256, uint256, uint256) internal view fnIn = _memcopyView;\\n function(uint256, uint256, uint256) internal pure pureMemcopy;\\n /// @solidity memory-safe-assembly\\n assembly {\\n pureMemcopy := fnIn\\n }\\n pureMemcopy(fromOffset, toOffset, length);\\n }\\n\\n function _memcopyView(uint256 fromOffset, uint256 toOffset, uint256 length) private view {\\n /// @solidity memory-safe-assembly\\n assembly {\\n pop(staticcall(gas(), 0x4, fromOffset, length, toOffset, length))\\n }\\n }\\n\\n function logMemory(uint256 offset, uint256 length) internal pure {\\n if (offset >= 0x60) {\\n // Sufficient memory before slice to prepare call header.\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(sub(offset, 0x60))\\n m1 := mload(sub(offset, 0x40))\\n m2 := mload(sub(offset, 0x20))\\n // Selector of `log(bytes)`.\\n mstore(sub(offset, 0x60), 0x0be77f56)\\n mstore(sub(offset, 0x40), 0x20)\\n mstore(sub(offset, 0x20), length)\\n }\\n _sendLogPayload(offset - 0x44, length + 0x44);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(sub(offset, 0x60), m0)\\n mstore(sub(offset, 0x40), m1)\\n mstore(sub(offset, 0x20), m2)\\n }\\n } else {\\n // Insufficient space, so copy slice forward, add header and reverse.\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n uint256 endOffset = offset + length;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(add(endOffset, 0x00))\\n m1 := mload(add(endOffset, 0x20))\\n m2 := mload(add(endOffset, 0x40))\\n }\\n _memcopy(offset, offset + 0x60, length);\\n /// @solidity memory-safe-assembly\\n assembly {\\n // Selector of `log(bytes)`.\\n mstore(add(offset, 0x00), 0x0be77f56)\\n mstore(add(offset, 0x20), 0x20)\\n mstore(add(offset, 0x40), length)\\n }\\n _sendLogPayload(offset + 0x1c, length + 0x44);\\n _memcopy(offset + 0x60, offset, length);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(add(endOffset, 0x00), m0)\\n mstore(add(endOffset, 0x20), m1)\\n mstore(add(endOffset, 0x40), m2)\\n }\\n }\\n }\\n\\n function log(address p0) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n // Selector of `log(address)`.\\n mstore(0x00, 0x2c2ecbc2)\\n mstore(0x20, p0)\\n }\\n _sendLogPayload(0x1c, 0x24);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n }\\n }\\n\\n function log(bool p0) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n // Selector of `log(bool)`.\\n mstore(0x00, 0x32458eed)\\n mstore(0x20, p0)\\n }\\n _sendLogPayload(0x1c, 0x24);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n }\\n }\\n\\n function log(uint256 p0) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n // Selector of `log(uint256)`.\\n mstore(0x00, 0xf82c50f1)\\n mstore(0x20, p0)\\n }\\n _sendLogPayload(0x1c, 0x24);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n }\\n }\\n\\n function log(bytes32 p0) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n // Selector of `log(string)`.\\n mstore(0x00, 0x41304fac)\\n mstore(0x20, 0x20)\\n writeString(0x40, p0)\\n }\\n _sendLogPayload(0x1c, 0x64);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n }\\n }\\n\\n function log(address p0, address p1) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n // Selector of `log(address,address)`.\\n mstore(0x00, 0xdaf0d4aa)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n }\\n _sendLogPayload(0x1c, 0x44);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n }\\n }\\n\\n function log(address p0, bool p1) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n // Selector of `log(address,bool)`.\\n mstore(0x00, 0x75b605d3)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n }\\n _sendLogPayload(0x1c, 0x44);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n }\\n }\\n\\n function log(address p0, uint256 p1) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n // Selector of `log(address,uint256)`.\\n mstore(0x00, 0x8309e8a8)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n }\\n _sendLogPayload(0x1c, 0x44);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n }\\n }\\n\\n function log(address p0, bytes32 p1) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(address,string)`.\\n mstore(0x00, 0x759f86bb)\\n mstore(0x20, p0)\\n mstore(0x40, 0x40)\\n writeString(0x60, p1)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(bool p0, address p1) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n // Selector of `log(bool,address)`.\\n mstore(0x00, 0x853c4849)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n }\\n _sendLogPayload(0x1c, 0x44);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n }\\n }\\n\\n function log(bool p0, bool p1) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n // Selector of `log(bool,bool)`.\\n mstore(0x00, 0x2a110e83)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n }\\n _sendLogPayload(0x1c, 0x44);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n }\\n }\\n\\n function log(bool p0, uint256 p1) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n // Selector of `log(bool,uint256)`.\\n mstore(0x00, 0x399174d3)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n }\\n _sendLogPayload(0x1c, 0x44);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n }\\n }\\n\\n function log(bool p0, bytes32 p1) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(bool,string)`.\\n mstore(0x00, 0x8feac525)\\n mstore(0x20, p0)\\n mstore(0x40, 0x40)\\n writeString(0x60, p1)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(uint256 p0, address p1) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n // Selector of `log(uint256,address)`.\\n mstore(0x00, 0x69276c86)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n }\\n _sendLogPayload(0x1c, 0x44);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n }\\n }\\n\\n function log(uint256 p0, bool p1) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n // Selector of `log(uint256,bool)`.\\n mstore(0x00, 0x1c9d7eb3)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n }\\n _sendLogPayload(0x1c, 0x44);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n }\\n }\\n\\n function log(uint256 p0, uint256 p1) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n // Selector of `log(uint256,uint256)`.\\n mstore(0x00, 0xf666715a)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n }\\n _sendLogPayload(0x1c, 0x44);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n }\\n }\\n\\n function log(uint256 p0, bytes32 p1) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(uint256,string)`.\\n mstore(0x00, 0x643fd0df)\\n mstore(0x20, p0)\\n mstore(0x40, 0x40)\\n writeString(0x60, p1)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(bytes32 p0, address p1) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(string,address)`.\\n mstore(0x00, 0x319af333)\\n mstore(0x20, 0x40)\\n mstore(0x40, p1)\\n writeString(0x60, p0)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(bytes32 p0, bool p1) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(string,bool)`.\\n mstore(0x00, 0xc3b55635)\\n mstore(0x20, 0x40)\\n mstore(0x40, p1)\\n writeString(0x60, p0)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(bytes32 p0, uint256 p1) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(string,uint256)`.\\n mstore(0x00, 0xb60e72cc)\\n mstore(0x20, 0x40)\\n mstore(0x40, p1)\\n writeString(0x60, p0)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(bytes32 p0, bytes32 p1) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(string,string)`.\\n mstore(0x00, 0x4b5c4277)\\n mstore(0x20, 0x40)\\n mstore(0x40, 0x80)\\n writeString(0x60, p0)\\n writeString(0xa0, p1)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(address p0, address p1, address p2) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n // Selector of `log(address,address,address)`.\\n mstore(0x00, 0x018c84c2)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n }\\n _sendLogPayload(0x1c, 0x64);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n }\\n }\\n\\n function log(address p0, address p1, bool p2) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n // Selector of `log(address,address,bool)`.\\n mstore(0x00, 0xf2a66286)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n }\\n _sendLogPayload(0x1c, 0x64);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n }\\n }\\n\\n function log(address p0, address p1, uint256 p2) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n // Selector of `log(address,address,uint256)`.\\n mstore(0x00, 0x17fe6185)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n }\\n _sendLogPayload(0x1c, 0x64);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n }\\n }\\n\\n function log(address p0, address p1, bytes32 p2) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n // Selector of `log(address,address,string)`.\\n mstore(0x00, 0x007150be)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, 0x60)\\n writeString(0x80, p2)\\n }\\n _sendLogPayload(0x1c, 0xa4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n }\\n }\\n\\n function log(address p0, bool p1, address p2) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n // Selector of `log(address,bool,address)`.\\n mstore(0x00, 0xf11699ed)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n }\\n _sendLogPayload(0x1c, 0x64);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n }\\n }\\n\\n function log(address p0, bool p1, bool p2) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n // Selector of `log(address,bool,bool)`.\\n mstore(0x00, 0xeb830c92)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n }\\n _sendLogPayload(0x1c, 0x64);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n }\\n }\\n\\n function log(address p0, bool p1, uint256 p2) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n // Selector of `log(address,bool,uint256)`.\\n mstore(0x00, 0x9c4f99fb)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n }\\n _sendLogPayload(0x1c, 0x64);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n }\\n }\\n\\n function log(address p0, bool p1, bytes32 p2) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n // Selector of `log(address,bool,string)`.\\n mstore(0x00, 0x212255cc)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, 0x60)\\n writeString(0x80, p2)\\n }\\n _sendLogPayload(0x1c, 0xa4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n }\\n }\\n\\n function log(address p0, uint256 p1, address p2) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n // Selector of `log(address,uint256,address)`.\\n mstore(0x00, 0x7bc0d848)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n }\\n _sendLogPayload(0x1c, 0x64);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n }\\n }\\n\\n function log(address p0, uint256 p1, bool p2) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n // Selector of `log(address,uint256,bool)`.\\n mstore(0x00, 0x678209a8)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n }\\n _sendLogPayload(0x1c, 0x64);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n }\\n }\\n\\n function log(address p0, uint256 p1, uint256 p2) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n // Selector of `log(address,uint256,uint256)`.\\n mstore(0x00, 0xb69bcaf6)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n }\\n _sendLogPayload(0x1c, 0x64);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n }\\n }\\n\\n function log(address p0, uint256 p1, bytes32 p2) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n // Selector of `log(address,uint256,string)`.\\n mstore(0x00, 0xa1f2e8aa)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, 0x60)\\n writeString(0x80, p2)\\n }\\n _sendLogPayload(0x1c, 0xa4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n }\\n }\\n\\n function log(address p0, bytes32 p1, address p2) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n // Selector of `log(address,string,address)`.\\n mstore(0x00, 0xf08744e8)\\n mstore(0x20, p0)\\n mstore(0x40, 0x60)\\n mstore(0x60, p2)\\n writeString(0x80, p1)\\n }\\n _sendLogPayload(0x1c, 0xa4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n }\\n }\\n\\n function log(address p0, bytes32 p1, bool p2) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n // Selector of `log(address,string,bool)`.\\n mstore(0x00, 0xcf020fb1)\\n mstore(0x20, p0)\\n mstore(0x40, 0x60)\\n mstore(0x60, p2)\\n writeString(0x80, p1)\\n }\\n _sendLogPayload(0x1c, 0xa4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n }\\n }\\n\\n function log(address p0, bytes32 p1, uint256 p2) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n // Selector of `log(address,string,uint256)`.\\n mstore(0x00, 0x67dd6ff1)\\n mstore(0x20, p0)\\n mstore(0x40, 0x60)\\n mstore(0x60, p2)\\n writeString(0x80, p1)\\n }\\n _sendLogPayload(0x1c, 0xa4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n }\\n }\\n\\n function log(address p0, bytes32 p1, bytes32 p2) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n // Selector of `log(address,string,string)`.\\n mstore(0x00, 0xfb772265)\\n mstore(0x20, p0)\\n mstore(0x40, 0x60)\\n mstore(0x60, 0xa0)\\n writeString(0x80, p1)\\n writeString(0xc0, p2)\\n }\\n _sendLogPayload(0x1c, 0xe4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n }\\n }\\n\\n function log(bool p0, address p1, address p2) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n // Selector of `log(bool,address,address)`.\\n mstore(0x00, 0xd2763667)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n }\\n _sendLogPayload(0x1c, 0x64);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n }\\n }\\n\\n function log(bool p0, address p1, bool p2) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n // Selector of `log(bool,address,bool)`.\\n mstore(0x00, 0x18c9c746)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n }\\n _sendLogPayload(0x1c, 0x64);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n }\\n }\\n\\n function log(bool p0, address p1, uint256 p2) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n // Selector of `log(bool,address,uint256)`.\\n mstore(0x00, 0x5f7b9afb)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n }\\n _sendLogPayload(0x1c, 0x64);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n }\\n }\\n\\n function log(bool p0, address p1, bytes32 p2) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n // Selector of `log(bool,address,string)`.\\n mstore(0x00, 0xde9a9270)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, 0x60)\\n writeString(0x80, p2)\\n }\\n _sendLogPayload(0x1c, 0xa4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n }\\n }\\n\\n function log(bool p0, bool p1, address p2) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n // Selector of `log(bool,bool,address)`.\\n mstore(0x00, 0x1078f68d)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n }\\n _sendLogPayload(0x1c, 0x64);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n }\\n }\\n\\n function log(bool p0, bool p1, bool p2) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n // Selector of `log(bool,bool,bool)`.\\n mstore(0x00, 0x50709698)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n }\\n _sendLogPayload(0x1c, 0x64);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n }\\n }\\n\\n function log(bool p0, bool p1, uint256 p2) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n // Selector of `log(bool,bool,uint256)`.\\n mstore(0x00, 0x12f21602)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n }\\n _sendLogPayload(0x1c, 0x64);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n }\\n }\\n\\n function log(bool p0, bool p1, bytes32 p2) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n // Selector of `log(bool,bool,string)`.\\n mstore(0x00, 0x2555fa46)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, 0x60)\\n writeString(0x80, p2)\\n }\\n _sendLogPayload(0x1c, 0xa4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n }\\n }\\n\\n function log(bool p0, uint256 p1, address p2) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n // Selector of `log(bool,uint256,address)`.\\n mstore(0x00, 0x088ef9d2)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n }\\n _sendLogPayload(0x1c, 0x64);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n }\\n }\\n\\n function log(bool p0, uint256 p1, bool p2) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n // Selector of `log(bool,uint256,bool)`.\\n mstore(0x00, 0xe8defba9)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n }\\n _sendLogPayload(0x1c, 0x64);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n }\\n }\\n\\n function log(bool p0, uint256 p1, uint256 p2) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n // Selector of `log(bool,uint256,uint256)`.\\n mstore(0x00, 0x37103367)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n }\\n _sendLogPayload(0x1c, 0x64);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n }\\n }\\n\\n function log(bool p0, uint256 p1, bytes32 p2) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n // Selector of `log(bool,uint256,string)`.\\n mstore(0x00, 0xc3fc3970)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, 0x60)\\n writeString(0x80, p2)\\n }\\n _sendLogPayload(0x1c, 0xa4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n }\\n }\\n\\n function log(bool p0, bytes32 p1, address p2) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n // Selector of `log(bool,string,address)`.\\n mstore(0x00, 0x9591b953)\\n mstore(0x20, p0)\\n mstore(0x40, 0x60)\\n mstore(0x60, p2)\\n writeString(0x80, p1)\\n }\\n _sendLogPayload(0x1c, 0xa4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n }\\n }\\n\\n function log(bool p0, bytes32 p1, bool p2) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n // Selector of `log(bool,string,bool)`.\\n mstore(0x00, 0xdbb4c247)\\n mstore(0x20, p0)\\n mstore(0x40, 0x60)\\n mstore(0x60, p2)\\n writeString(0x80, p1)\\n }\\n _sendLogPayload(0x1c, 0xa4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n }\\n }\\n\\n function log(bool p0, bytes32 p1, uint256 p2) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n // Selector of `log(bool,string,uint256)`.\\n mstore(0x00, 0x1093ee11)\\n mstore(0x20, p0)\\n mstore(0x40, 0x60)\\n mstore(0x60, p2)\\n writeString(0x80, p1)\\n }\\n _sendLogPayload(0x1c, 0xa4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n }\\n }\\n\\n function log(bool p0, bytes32 p1, bytes32 p2) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n // Selector of `log(bool,string,string)`.\\n mstore(0x00, 0xb076847f)\\n mstore(0x20, p0)\\n mstore(0x40, 0x60)\\n mstore(0x60, 0xa0)\\n writeString(0x80, p1)\\n writeString(0xc0, p2)\\n }\\n _sendLogPayload(0x1c, 0xe4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n }\\n }\\n\\n function log(uint256 p0, address p1, address p2) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n // Selector of `log(uint256,address,address)`.\\n mstore(0x00, 0xbcfd9be0)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n }\\n _sendLogPayload(0x1c, 0x64);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n }\\n }\\n\\n function log(uint256 p0, address p1, bool p2) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n // Selector of `log(uint256,address,bool)`.\\n mstore(0x00, 0x9b6ec042)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n }\\n _sendLogPayload(0x1c, 0x64);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n }\\n }\\n\\n function log(uint256 p0, address p1, uint256 p2) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n // Selector of `log(uint256,address,uint256)`.\\n mstore(0x00, 0x5a9b5ed5)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n }\\n _sendLogPayload(0x1c, 0x64);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n }\\n }\\n\\n function log(uint256 p0, address p1, bytes32 p2) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n // Selector of `log(uint256,address,string)`.\\n mstore(0x00, 0x63cb41f9)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, 0x60)\\n writeString(0x80, p2)\\n }\\n _sendLogPayload(0x1c, 0xa4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n }\\n }\\n\\n function log(uint256 p0, bool p1, address p2) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n // Selector of `log(uint256,bool,address)`.\\n mstore(0x00, 0x35085f7b)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n }\\n _sendLogPayload(0x1c, 0x64);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n }\\n }\\n\\n function log(uint256 p0, bool p1, bool p2) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n // Selector of `log(uint256,bool,bool)`.\\n mstore(0x00, 0x20718650)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n }\\n _sendLogPayload(0x1c, 0x64);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n }\\n }\\n\\n function log(uint256 p0, bool p1, uint256 p2) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n // Selector of `log(uint256,bool,uint256)`.\\n mstore(0x00, 0x20098014)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n }\\n _sendLogPayload(0x1c, 0x64);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n }\\n }\\n\\n function log(uint256 p0, bool p1, bytes32 p2) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n // Selector of `log(uint256,bool,string)`.\\n mstore(0x00, 0x85775021)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, 0x60)\\n writeString(0x80, p2)\\n }\\n _sendLogPayload(0x1c, 0xa4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n }\\n }\\n\\n function log(uint256 p0, uint256 p1, address p2) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n // Selector of `log(uint256,uint256,address)`.\\n mstore(0x00, 0x5c96b331)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n }\\n _sendLogPayload(0x1c, 0x64);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n }\\n }\\n\\n function log(uint256 p0, uint256 p1, bool p2) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n // Selector of `log(uint256,uint256,bool)`.\\n mstore(0x00, 0x4766da72)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n }\\n _sendLogPayload(0x1c, 0x64);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n }\\n }\\n\\n function log(uint256 p0, uint256 p1, uint256 p2) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n // Selector of `log(uint256,uint256,uint256)`.\\n mstore(0x00, 0xd1ed7a3c)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n }\\n _sendLogPayload(0x1c, 0x64);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n }\\n }\\n\\n function log(uint256 p0, uint256 p1, bytes32 p2) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n // Selector of `log(uint256,uint256,string)`.\\n mstore(0x00, 0x71d04af2)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, 0x60)\\n writeString(0x80, p2)\\n }\\n _sendLogPayload(0x1c, 0xa4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n }\\n }\\n\\n function log(uint256 p0, bytes32 p1, address p2) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n // Selector of `log(uint256,string,address)`.\\n mstore(0x00, 0x7afac959)\\n mstore(0x20, p0)\\n mstore(0x40, 0x60)\\n mstore(0x60, p2)\\n writeString(0x80, p1)\\n }\\n _sendLogPayload(0x1c, 0xa4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n }\\n }\\n\\n function log(uint256 p0, bytes32 p1, bool p2) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n // Selector of `log(uint256,string,bool)`.\\n mstore(0x00, 0x4ceda75a)\\n mstore(0x20, p0)\\n mstore(0x40, 0x60)\\n mstore(0x60, p2)\\n writeString(0x80, p1)\\n }\\n _sendLogPayload(0x1c, 0xa4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n }\\n }\\n\\n function log(uint256 p0, bytes32 p1, uint256 p2) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n // Selector of `log(uint256,string,uint256)`.\\n mstore(0x00, 0x37aa7d4c)\\n mstore(0x20, p0)\\n mstore(0x40, 0x60)\\n mstore(0x60, p2)\\n writeString(0x80, p1)\\n }\\n _sendLogPayload(0x1c, 0xa4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n }\\n }\\n\\n function log(uint256 p0, bytes32 p1, bytes32 p2) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n // Selector of `log(uint256,string,string)`.\\n mstore(0x00, 0xb115611f)\\n mstore(0x20, p0)\\n mstore(0x40, 0x60)\\n mstore(0x60, 0xa0)\\n writeString(0x80, p1)\\n writeString(0xc0, p2)\\n }\\n _sendLogPayload(0x1c, 0xe4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n }\\n }\\n\\n function log(bytes32 p0, address p1, address p2) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n // Selector of `log(string,address,address)`.\\n mstore(0x00, 0xfcec75e0)\\n mstore(0x20, 0x60)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n writeString(0x80, p0)\\n }\\n _sendLogPayload(0x1c, 0xa4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n }\\n }\\n\\n function log(bytes32 p0, address p1, bool p2) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n // Selector of `log(string,address,bool)`.\\n mstore(0x00, 0xc91d5ed4)\\n mstore(0x20, 0x60)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n writeString(0x80, p0)\\n }\\n _sendLogPayload(0x1c, 0xa4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n }\\n }\\n\\n function log(bytes32 p0, address p1, uint256 p2) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n // Selector of `log(string,address,uint256)`.\\n mstore(0x00, 0x0d26b925)\\n mstore(0x20, 0x60)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n writeString(0x80, p0)\\n }\\n _sendLogPayload(0x1c, 0xa4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n }\\n }\\n\\n function log(bytes32 p0, address p1, bytes32 p2) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n // Selector of `log(string,address,string)`.\\n mstore(0x00, 0xe0e9ad4f)\\n mstore(0x20, 0x60)\\n mstore(0x40, p1)\\n mstore(0x60, 0xa0)\\n writeString(0x80, p0)\\n writeString(0xc0, p2)\\n }\\n _sendLogPayload(0x1c, 0xe4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n }\\n }\\n\\n function log(bytes32 p0, bool p1, address p2) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n // Selector of `log(string,bool,address)`.\\n mstore(0x00, 0x932bbb38)\\n mstore(0x20, 0x60)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n writeString(0x80, p0)\\n }\\n _sendLogPayload(0x1c, 0xa4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n }\\n }\\n\\n function log(bytes32 p0, bool p1, bool p2) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n // Selector of `log(string,bool,bool)`.\\n mstore(0x00, 0x850b7ad6)\\n mstore(0x20, 0x60)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n writeString(0x80, p0)\\n }\\n _sendLogPayload(0x1c, 0xa4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n }\\n }\\n\\n function log(bytes32 p0, bool p1, uint256 p2) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n // Selector of `log(string,bool,uint256)`.\\n mstore(0x00, 0xc95958d6)\\n mstore(0x20, 0x60)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n writeString(0x80, p0)\\n }\\n _sendLogPayload(0x1c, 0xa4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n }\\n }\\n\\n function log(bytes32 p0, bool p1, bytes32 p2) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n // Selector of `log(string,bool,string)`.\\n mstore(0x00, 0xe298f47d)\\n mstore(0x20, 0x60)\\n mstore(0x40, p1)\\n mstore(0x60, 0xa0)\\n writeString(0x80, p0)\\n writeString(0xc0, p2)\\n }\\n _sendLogPayload(0x1c, 0xe4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n }\\n }\\n\\n function log(bytes32 p0, uint256 p1, address p2) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n // Selector of `log(string,uint256,address)`.\\n mstore(0x00, 0x1c7ec448)\\n mstore(0x20, 0x60)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n writeString(0x80, p0)\\n }\\n _sendLogPayload(0x1c, 0xa4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n }\\n }\\n\\n function log(bytes32 p0, uint256 p1, bool p2) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n // Selector of `log(string,uint256,bool)`.\\n mstore(0x00, 0xca7733b1)\\n mstore(0x20, 0x60)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n writeString(0x80, p0)\\n }\\n _sendLogPayload(0x1c, 0xa4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n }\\n }\\n\\n function log(bytes32 p0, uint256 p1, uint256 p2) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n // Selector of `log(string,uint256,uint256)`.\\n mstore(0x00, 0xca47c4eb)\\n mstore(0x20, 0x60)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n writeString(0x80, p0)\\n }\\n _sendLogPayload(0x1c, 0xa4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n }\\n }\\n\\n function log(bytes32 p0, uint256 p1, bytes32 p2) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n // Selector of `log(string,uint256,string)`.\\n mstore(0x00, 0x5970e089)\\n mstore(0x20, 0x60)\\n mstore(0x40, p1)\\n mstore(0x60, 0xa0)\\n writeString(0x80, p0)\\n writeString(0xc0, p2)\\n }\\n _sendLogPayload(0x1c, 0xe4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n }\\n }\\n\\n function log(bytes32 p0, bytes32 p1, address p2) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n // Selector of `log(string,string,address)`.\\n mstore(0x00, 0x95ed0195)\\n mstore(0x20, 0x60)\\n mstore(0x40, 0xa0)\\n mstore(0x60, p2)\\n writeString(0x80, p0)\\n writeString(0xc0, p1)\\n }\\n _sendLogPayload(0x1c, 0xe4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n }\\n }\\n\\n function log(bytes32 p0, bytes32 p1, bool p2) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n // Selector of `log(string,string,bool)`.\\n mstore(0x00, 0xb0e0f9b5)\\n mstore(0x20, 0x60)\\n mstore(0x40, 0xa0)\\n mstore(0x60, p2)\\n writeString(0x80, p0)\\n writeString(0xc0, p1)\\n }\\n _sendLogPayload(0x1c, 0xe4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n }\\n }\\n\\n function log(bytes32 p0, bytes32 p1, uint256 p2) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n // Selector of `log(string,string,uint256)`.\\n mstore(0x00, 0x5821efa1)\\n mstore(0x20, 0x60)\\n mstore(0x40, 0xa0)\\n mstore(0x60, p2)\\n writeString(0x80, p0)\\n writeString(0xc0, p1)\\n }\\n _sendLogPayload(0x1c, 0xe4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n }\\n }\\n\\n function log(bytes32 p0, bytes32 p1, bytes32 p2) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n bytes32 m9;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n m9 := mload(0x120)\\n // Selector of `log(string,string,string)`.\\n mstore(0x00, 0x2ced7cef)\\n mstore(0x20, 0x60)\\n mstore(0x40, 0xa0)\\n mstore(0x60, 0xe0)\\n writeString(0x80, p0)\\n writeString(0xc0, p1)\\n writeString(0x100, p2)\\n }\\n _sendLogPayload(0x1c, 0x124);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n mstore(0x120, m9)\\n }\\n }\\n\\n function log(address p0, address p1, address p2, address p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(address,address,address,address)`.\\n mstore(0x00, 0x665bf134)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(address p0, address p1, address p2, bool p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(address,address,address,bool)`.\\n mstore(0x00, 0x0e378994)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(address p0, address p1, address p2, uint256 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(address,address,address,uint256)`.\\n mstore(0x00, 0x94250d77)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(address p0, address p1, address p2, bytes32 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(address,address,address,string)`.\\n mstore(0x00, 0xf808da20)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, 0x80)\\n writeString(0xa0, p3)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(address p0, address p1, bool p2, address p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(address,address,bool,address)`.\\n mstore(0x00, 0x9f1bc36e)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(address p0, address p1, bool p2, bool p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(address,address,bool,bool)`.\\n mstore(0x00, 0x2cd4134a)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(address p0, address p1, bool p2, uint256 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(address,address,bool,uint256)`.\\n mstore(0x00, 0x3971e78c)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(address p0, address p1, bool p2, bytes32 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(address,address,bool,string)`.\\n mstore(0x00, 0xaa6540c8)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, 0x80)\\n writeString(0xa0, p3)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(address p0, address p1, uint256 p2, address p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(address,address,uint256,address)`.\\n mstore(0x00, 0x8da6def5)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(address p0, address p1, uint256 p2, bool p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(address,address,uint256,bool)`.\\n mstore(0x00, 0x9b4254e2)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(address p0, address p1, uint256 p2, uint256 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(address,address,uint256,uint256)`.\\n mstore(0x00, 0xbe553481)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(address p0, address p1, uint256 p2, bytes32 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(address,address,uint256,string)`.\\n mstore(0x00, 0xfdb4f990)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, 0x80)\\n writeString(0xa0, p3)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(address p0, address p1, bytes32 p2, address p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(address,address,string,address)`.\\n mstore(0x00, 0x8f736d16)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, 0x80)\\n mstore(0x80, p3)\\n writeString(0xa0, p2)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(address p0, address p1, bytes32 p2, bool p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(address,address,string,bool)`.\\n mstore(0x00, 0x6f1a594e)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, 0x80)\\n mstore(0x80, p3)\\n writeString(0xa0, p2)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(address p0, address p1, bytes32 p2, uint256 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(address,address,string,uint256)`.\\n mstore(0x00, 0xef1cefe7)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, 0x80)\\n mstore(0x80, p3)\\n writeString(0xa0, p2)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(address p0, address p1, bytes32 p2, bytes32 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n // Selector of `log(address,address,string,string)`.\\n mstore(0x00, 0x21bdaf25)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, 0x80)\\n mstore(0x80, 0xc0)\\n writeString(0xa0, p2)\\n writeString(0xe0, p3)\\n }\\n _sendLogPayload(0x1c, 0x104);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n }\\n }\\n\\n function log(address p0, bool p1, address p2, address p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(address,bool,address,address)`.\\n mstore(0x00, 0x660375dd)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(address p0, bool p1, address p2, bool p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(address,bool,address,bool)`.\\n mstore(0x00, 0xa6f50b0f)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(address p0, bool p1, address p2, uint256 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(address,bool,address,uint256)`.\\n mstore(0x00, 0xa75c59de)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(address p0, bool p1, address p2, bytes32 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(address,bool,address,string)`.\\n mstore(0x00, 0x2dd778e6)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, 0x80)\\n writeString(0xa0, p3)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(address p0, bool p1, bool p2, address p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(address,bool,bool,address)`.\\n mstore(0x00, 0xcf394485)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(address p0, bool p1, bool p2, bool p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(address,bool,bool,bool)`.\\n mstore(0x00, 0xcac43479)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(address p0, bool p1, bool p2, uint256 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(address,bool,bool,uint256)`.\\n mstore(0x00, 0x8c4e5de6)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(address p0, bool p1, bool p2, bytes32 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(address,bool,bool,string)`.\\n mstore(0x00, 0xdfc4a2e8)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, 0x80)\\n writeString(0xa0, p3)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(address p0, bool p1, uint256 p2, address p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(address,bool,uint256,address)`.\\n mstore(0x00, 0xccf790a1)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(address p0, bool p1, uint256 p2, bool p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(address,bool,uint256,bool)`.\\n mstore(0x00, 0xc4643e20)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(address p0, bool p1, uint256 p2, uint256 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(address,bool,uint256,uint256)`.\\n mstore(0x00, 0x386ff5f4)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(address p0, bool p1, uint256 p2, bytes32 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(address,bool,uint256,string)`.\\n mstore(0x00, 0x0aa6cfad)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, 0x80)\\n writeString(0xa0, p3)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(address p0, bool p1, bytes32 p2, address p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(address,bool,string,address)`.\\n mstore(0x00, 0x19fd4956)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, 0x80)\\n mstore(0x80, p3)\\n writeString(0xa0, p2)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(address p0, bool p1, bytes32 p2, bool p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(address,bool,string,bool)`.\\n mstore(0x00, 0x50ad461d)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, 0x80)\\n mstore(0x80, p3)\\n writeString(0xa0, p2)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(address p0, bool p1, bytes32 p2, uint256 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(address,bool,string,uint256)`.\\n mstore(0x00, 0x80e6a20b)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, 0x80)\\n mstore(0x80, p3)\\n writeString(0xa0, p2)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(address p0, bool p1, bytes32 p2, bytes32 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n // Selector of `log(address,bool,string,string)`.\\n mstore(0x00, 0x475c5c33)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, 0x80)\\n mstore(0x80, 0xc0)\\n writeString(0xa0, p2)\\n writeString(0xe0, p3)\\n }\\n _sendLogPayload(0x1c, 0x104);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n }\\n }\\n\\n function log(address p0, uint256 p1, address p2, address p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(address,uint256,address,address)`.\\n mstore(0x00, 0x478d1c62)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(address p0, uint256 p1, address p2, bool p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(address,uint256,address,bool)`.\\n mstore(0x00, 0xa1bcc9b3)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(address p0, uint256 p1, address p2, uint256 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(address,uint256,address,uint256)`.\\n mstore(0x00, 0x100f650e)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(address p0, uint256 p1, address p2, bytes32 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(address,uint256,address,string)`.\\n mstore(0x00, 0x1da986ea)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, 0x80)\\n writeString(0xa0, p3)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(address p0, uint256 p1, bool p2, address p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(address,uint256,bool,address)`.\\n mstore(0x00, 0xa31bfdcc)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(address p0, uint256 p1, bool p2, bool p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(address,uint256,bool,bool)`.\\n mstore(0x00, 0x3bf5e537)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(address p0, uint256 p1, bool p2, uint256 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(address,uint256,bool,uint256)`.\\n mstore(0x00, 0x22f6b999)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(address p0, uint256 p1, bool p2, bytes32 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(address,uint256,bool,string)`.\\n mstore(0x00, 0xc5ad85f9)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, 0x80)\\n writeString(0xa0, p3)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(address p0, uint256 p1, uint256 p2, address p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(address,uint256,uint256,address)`.\\n mstore(0x00, 0x20e3984d)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(address p0, uint256 p1, uint256 p2, bool p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(address,uint256,uint256,bool)`.\\n mstore(0x00, 0x66f1bc67)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(address p0, uint256 p1, uint256 p2, uint256 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(address,uint256,uint256,uint256)`.\\n mstore(0x00, 0x34f0e636)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(address p0, uint256 p1, uint256 p2, bytes32 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(address,uint256,uint256,string)`.\\n mstore(0x00, 0x4a28c017)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, 0x80)\\n writeString(0xa0, p3)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(address p0, uint256 p1, bytes32 p2, address p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(address,uint256,string,address)`.\\n mstore(0x00, 0x5c430d47)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, 0x80)\\n mstore(0x80, p3)\\n writeString(0xa0, p2)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(address p0, uint256 p1, bytes32 p2, bool p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(address,uint256,string,bool)`.\\n mstore(0x00, 0xcf18105c)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, 0x80)\\n mstore(0x80, p3)\\n writeString(0xa0, p2)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(address p0, uint256 p1, bytes32 p2, uint256 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(address,uint256,string,uint256)`.\\n mstore(0x00, 0xbf01f891)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, 0x80)\\n mstore(0x80, p3)\\n writeString(0xa0, p2)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(address p0, uint256 p1, bytes32 p2, bytes32 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n // Selector of `log(address,uint256,string,string)`.\\n mstore(0x00, 0x88a8c406)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, 0x80)\\n mstore(0x80, 0xc0)\\n writeString(0xa0, p2)\\n writeString(0xe0, p3)\\n }\\n _sendLogPayload(0x1c, 0x104);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n }\\n }\\n\\n function log(address p0, bytes32 p1, address p2, address p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(address,string,address,address)`.\\n mstore(0x00, 0x0d36fa20)\\n mstore(0x20, p0)\\n mstore(0x40, 0x80)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n writeString(0xa0, p1)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(address p0, bytes32 p1, address p2, bool p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(address,string,address,bool)`.\\n mstore(0x00, 0x0df12b76)\\n mstore(0x20, p0)\\n mstore(0x40, 0x80)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n writeString(0xa0, p1)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(address p0, bytes32 p1, address p2, uint256 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(address,string,address,uint256)`.\\n mstore(0x00, 0x457fe3cf)\\n mstore(0x20, p0)\\n mstore(0x40, 0x80)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n writeString(0xa0, p1)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(address p0, bytes32 p1, address p2, bytes32 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n // Selector of `log(address,string,address,string)`.\\n mstore(0x00, 0xf7e36245)\\n mstore(0x20, p0)\\n mstore(0x40, 0x80)\\n mstore(0x60, p2)\\n mstore(0x80, 0xc0)\\n writeString(0xa0, p1)\\n writeString(0xe0, p3)\\n }\\n _sendLogPayload(0x1c, 0x104);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n }\\n }\\n\\n function log(address p0, bytes32 p1, bool p2, address p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(address,string,bool,address)`.\\n mstore(0x00, 0x205871c2)\\n mstore(0x20, p0)\\n mstore(0x40, 0x80)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n writeString(0xa0, p1)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(address p0, bytes32 p1, bool p2, bool p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(address,string,bool,bool)`.\\n mstore(0x00, 0x5f1d5c9f)\\n mstore(0x20, p0)\\n mstore(0x40, 0x80)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n writeString(0xa0, p1)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(address p0, bytes32 p1, bool p2, uint256 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(address,string,bool,uint256)`.\\n mstore(0x00, 0x515e38b6)\\n mstore(0x20, p0)\\n mstore(0x40, 0x80)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n writeString(0xa0, p1)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(address p0, bytes32 p1, bool p2, bytes32 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n // Selector of `log(address,string,bool,string)`.\\n mstore(0x00, 0xbc0b61fe)\\n mstore(0x20, p0)\\n mstore(0x40, 0x80)\\n mstore(0x60, p2)\\n mstore(0x80, 0xc0)\\n writeString(0xa0, p1)\\n writeString(0xe0, p3)\\n }\\n _sendLogPayload(0x1c, 0x104);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n }\\n }\\n\\n function log(address p0, bytes32 p1, uint256 p2, address p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(address,string,uint256,address)`.\\n mstore(0x00, 0x63183678)\\n mstore(0x20, p0)\\n mstore(0x40, 0x80)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n writeString(0xa0, p1)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(address p0, bytes32 p1, uint256 p2, bool p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(address,string,uint256,bool)`.\\n mstore(0x00, 0x0ef7e050)\\n mstore(0x20, p0)\\n mstore(0x40, 0x80)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n writeString(0xa0, p1)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(address p0, bytes32 p1, uint256 p2, uint256 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(address,string,uint256,uint256)`.\\n mstore(0x00, 0x1dc8e1b8)\\n mstore(0x20, p0)\\n mstore(0x40, 0x80)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n writeString(0xa0, p1)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(address p0, bytes32 p1, uint256 p2, bytes32 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n // Selector of `log(address,string,uint256,string)`.\\n mstore(0x00, 0x448830a8)\\n mstore(0x20, p0)\\n mstore(0x40, 0x80)\\n mstore(0x60, p2)\\n mstore(0x80, 0xc0)\\n writeString(0xa0, p1)\\n writeString(0xe0, p3)\\n }\\n _sendLogPayload(0x1c, 0x104);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n }\\n }\\n\\n function log(address p0, bytes32 p1, bytes32 p2, address p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n // Selector of `log(address,string,string,address)`.\\n mstore(0x00, 0xa04e2f87)\\n mstore(0x20, p0)\\n mstore(0x40, 0x80)\\n mstore(0x60, 0xc0)\\n mstore(0x80, p3)\\n writeString(0xa0, p1)\\n writeString(0xe0, p2)\\n }\\n _sendLogPayload(0x1c, 0x104);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n }\\n }\\n\\n function log(address p0, bytes32 p1, bytes32 p2, bool p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n // Selector of `log(address,string,string,bool)`.\\n mstore(0x00, 0x35a5071f)\\n mstore(0x20, p0)\\n mstore(0x40, 0x80)\\n mstore(0x60, 0xc0)\\n mstore(0x80, p3)\\n writeString(0xa0, p1)\\n writeString(0xe0, p2)\\n }\\n _sendLogPayload(0x1c, 0x104);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n }\\n }\\n\\n function log(address p0, bytes32 p1, bytes32 p2, uint256 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n // Selector of `log(address,string,string,uint256)`.\\n mstore(0x00, 0x159f8927)\\n mstore(0x20, p0)\\n mstore(0x40, 0x80)\\n mstore(0x60, 0xc0)\\n mstore(0x80, p3)\\n writeString(0xa0, p1)\\n writeString(0xe0, p2)\\n }\\n _sendLogPayload(0x1c, 0x104);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n }\\n }\\n\\n function log(address p0, bytes32 p1, bytes32 p2, bytes32 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n bytes32 m9;\\n bytes32 m10;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n m9 := mload(0x120)\\n m10 := mload(0x140)\\n // Selector of `log(address,string,string,string)`.\\n mstore(0x00, 0x5d02c50b)\\n mstore(0x20, p0)\\n mstore(0x40, 0x80)\\n mstore(0x60, 0xc0)\\n mstore(0x80, 0x100)\\n writeString(0xa0, p1)\\n writeString(0xe0, p2)\\n writeString(0x120, p3)\\n }\\n _sendLogPayload(0x1c, 0x144);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n mstore(0x120, m9)\\n mstore(0x140, m10)\\n }\\n }\\n\\n function log(bool p0, address p1, address p2, address p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(bool,address,address,address)`.\\n mstore(0x00, 0x1d14d001)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(bool p0, address p1, address p2, bool p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(bool,address,address,bool)`.\\n mstore(0x00, 0x46600be0)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(bool p0, address p1, address p2, uint256 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(bool,address,address,uint256)`.\\n mstore(0x00, 0x0c66d1be)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(bool p0, address p1, address p2, bytes32 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(bool,address,address,string)`.\\n mstore(0x00, 0xd812a167)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, 0x80)\\n writeString(0xa0, p3)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(bool p0, address p1, bool p2, address p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(bool,address,bool,address)`.\\n mstore(0x00, 0x1c41a336)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(bool p0, address p1, bool p2, bool p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(bool,address,bool,bool)`.\\n mstore(0x00, 0x6a9c478b)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(bool p0, address p1, bool p2, uint256 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(bool,address,bool,uint256)`.\\n mstore(0x00, 0x07831502)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(bool p0, address p1, bool p2, bytes32 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(bool,address,bool,string)`.\\n mstore(0x00, 0x4a66cb34)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, 0x80)\\n writeString(0xa0, p3)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(bool p0, address p1, uint256 p2, address p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(bool,address,uint256,address)`.\\n mstore(0x00, 0x136b05dd)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(bool p0, address p1, uint256 p2, bool p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(bool,address,uint256,bool)`.\\n mstore(0x00, 0xd6019f1c)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(bool p0, address p1, uint256 p2, uint256 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(bool,address,uint256,uint256)`.\\n mstore(0x00, 0x7bf181a1)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(bool p0, address p1, uint256 p2, bytes32 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(bool,address,uint256,string)`.\\n mstore(0x00, 0x51f09ff8)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, 0x80)\\n writeString(0xa0, p3)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(bool p0, address p1, bytes32 p2, address p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(bool,address,string,address)`.\\n mstore(0x00, 0x6f7c603e)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, 0x80)\\n mstore(0x80, p3)\\n writeString(0xa0, p2)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(bool p0, address p1, bytes32 p2, bool p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(bool,address,string,bool)`.\\n mstore(0x00, 0xe2bfd60b)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, 0x80)\\n mstore(0x80, p3)\\n writeString(0xa0, p2)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(bool p0, address p1, bytes32 p2, uint256 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(bool,address,string,uint256)`.\\n mstore(0x00, 0xc21f64c7)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, 0x80)\\n mstore(0x80, p3)\\n writeString(0xa0, p2)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(bool p0, address p1, bytes32 p2, bytes32 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n // Selector of `log(bool,address,string,string)`.\\n mstore(0x00, 0xa73c1db6)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, 0x80)\\n mstore(0x80, 0xc0)\\n writeString(0xa0, p2)\\n writeString(0xe0, p3)\\n }\\n _sendLogPayload(0x1c, 0x104);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n }\\n }\\n\\n function log(bool p0, bool p1, address p2, address p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(bool,bool,address,address)`.\\n mstore(0x00, 0xf4880ea4)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(bool p0, bool p1, address p2, bool p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(bool,bool,address,bool)`.\\n mstore(0x00, 0xc0a302d8)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(bool p0, bool p1, address p2, uint256 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(bool,bool,address,uint256)`.\\n mstore(0x00, 0x4c123d57)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(bool p0, bool p1, address p2, bytes32 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(bool,bool,address,string)`.\\n mstore(0x00, 0xa0a47963)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, 0x80)\\n writeString(0xa0, p3)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(bool p0, bool p1, bool p2, address p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(bool,bool,bool,address)`.\\n mstore(0x00, 0x8c329b1a)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(bool p0, bool p1, bool p2, bool p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(bool,bool,bool,bool)`.\\n mstore(0x00, 0x3b2a5ce0)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(bool p0, bool p1, bool p2, uint256 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(bool,bool,bool,uint256)`.\\n mstore(0x00, 0x6d7045c1)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(bool p0, bool p1, bool p2, bytes32 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(bool,bool,bool,string)`.\\n mstore(0x00, 0x2ae408d4)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, 0x80)\\n writeString(0xa0, p3)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(bool p0, bool p1, uint256 p2, address p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(bool,bool,uint256,address)`.\\n mstore(0x00, 0x54a7a9a0)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(bool p0, bool p1, uint256 p2, bool p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(bool,bool,uint256,bool)`.\\n mstore(0x00, 0x619e4d0e)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(bool p0, bool p1, uint256 p2, uint256 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(bool,bool,uint256,uint256)`.\\n mstore(0x00, 0x0bb00eab)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(bool p0, bool p1, uint256 p2, bytes32 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(bool,bool,uint256,string)`.\\n mstore(0x00, 0x7dd4d0e0)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, 0x80)\\n writeString(0xa0, p3)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(bool p0, bool p1, bytes32 p2, address p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(bool,bool,string,address)`.\\n mstore(0x00, 0xf9ad2b89)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, 0x80)\\n mstore(0x80, p3)\\n writeString(0xa0, p2)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(bool p0, bool p1, bytes32 p2, bool p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(bool,bool,string,bool)`.\\n mstore(0x00, 0xb857163a)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, 0x80)\\n mstore(0x80, p3)\\n writeString(0xa0, p2)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(bool p0, bool p1, bytes32 p2, uint256 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(bool,bool,string,uint256)`.\\n mstore(0x00, 0xe3a9ca2f)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, 0x80)\\n mstore(0x80, p3)\\n writeString(0xa0, p2)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(bool p0, bool p1, bytes32 p2, bytes32 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n // Selector of `log(bool,bool,string,string)`.\\n mstore(0x00, 0x6d1e8751)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, 0x80)\\n mstore(0x80, 0xc0)\\n writeString(0xa0, p2)\\n writeString(0xe0, p3)\\n }\\n _sendLogPayload(0x1c, 0x104);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n }\\n }\\n\\n function log(bool p0, uint256 p1, address p2, address p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(bool,uint256,address,address)`.\\n mstore(0x00, 0x26f560a8)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(bool p0, uint256 p1, address p2, bool p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(bool,uint256,address,bool)`.\\n mstore(0x00, 0xb4c314ff)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(bool p0, uint256 p1, address p2, uint256 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(bool,uint256,address,uint256)`.\\n mstore(0x00, 0x1537dc87)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(bool p0, uint256 p1, address p2, bytes32 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(bool,uint256,address,string)`.\\n mstore(0x00, 0x1bb3b09a)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, 0x80)\\n writeString(0xa0, p3)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(bool p0, uint256 p1, bool p2, address p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(bool,uint256,bool,address)`.\\n mstore(0x00, 0x9acd3616)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(bool p0, uint256 p1, bool p2, bool p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(bool,uint256,bool,bool)`.\\n mstore(0x00, 0xceb5f4d7)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(bool p0, uint256 p1, bool p2, uint256 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(bool,uint256,bool,uint256)`.\\n mstore(0x00, 0x7f9bbca2)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(bool p0, uint256 p1, bool p2, bytes32 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(bool,uint256,bool,string)`.\\n mstore(0x00, 0x9143dbb1)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, 0x80)\\n writeString(0xa0, p3)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(bool p0, uint256 p1, uint256 p2, address p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(bool,uint256,uint256,address)`.\\n mstore(0x00, 0x00dd87b9)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(bool p0, uint256 p1, uint256 p2, bool p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(bool,uint256,uint256,bool)`.\\n mstore(0x00, 0xbe984353)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(bool p0, uint256 p1, uint256 p2, uint256 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(bool,uint256,uint256,uint256)`.\\n mstore(0x00, 0x374bb4b2)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(bool p0, uint256 p1, uint256 p2, bytes32 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(bool,uint256,uint256,string)`.\\n mstore(0x00, 0x8e69fb5d)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, 0x80)\\n writeString(0xa0, p3)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(bool p0, uint256 p1, bytes32 p2, address p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(bool,uint256,string,address)`.\\n mstore(0x00, 0xfedd1fff)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, 0x80)\\n mstore(0x80, p3)\\n writeString(0xa0, p2)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(bool p0, uint256 p1, bytes32 p2, bool p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(bool,uint256,string,bool)`.\\n mstore(0x00, 0xe5e70b2b)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, 0x80)\\n mstore(0x80, p3)\\n writeString(0xa0, p2)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(bool p0, uint256 p1, bytes32 p2, uint256 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(bool,uint256,string,uint256)`.\\n mstore(0x00, 0x6a1199e2)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, 0x80)\\n mstore(0x80, p3)\\n writeString(0xa0, p2)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(bool p0, uint256 p1, bytes32 p2, bytes32 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n // Selector of `log(bool,uint256,string,string)`.\\n mstore(0x00, 0xf5bc2249)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, 0x80)\\n mstore(0x80, 0xc0)\\n writeString(0xa0, p2)\\n writeString(0xe0, p3)\\n }\\n _sendLogPayload(0x1c, 0x104);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n }\\n }\\n\\n function log(bool p0, bytes32 p1, address p2, address p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(bool,string,address,address)`.\\n mstore(0x00, 0x2b2b18dc)\\n mstore(0x20, p0)\\n mstore(0x40, 0x80)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n writeString(0xa0, p1)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(bool p0, bytes32 p1, address p2, bool p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(bool,string,address,bool)`.\\n mstore(0x00, 0x6dd434ca)\\n mstore(0x20, p0)\\n mstore(0x40, 0x80)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n writeString(0xa0, p1)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(bool p0, bytes32 p1, address p2, uint256 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(bool,string,address,uint256)`.\\n mstore(0x00, 0xa5cada94)\\n mstore(0x20, p0)\\n mstore(0x40, 0x80)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n writeString(0xa0, p1)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(bool p0, bytes32 p1, address p2, bytes32 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n // Selector of `log(bool,string,address,string)`.\\n mstore(0x00, 0x12d6c788)\\n mstore(0x20, p0)\\n mstore(0x40, 0x80)\\n mstore(0x60, p2)\\n mstore(0x80, 0xc0)\\n writeString(0xa0, p1)\\n writeString(0xe0, p3)\\n }\\n _sendLogPayload(0x1c, 0x104);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n }\\n }\\n\\n function log(bool p0, bytes32 p1, bool p2, address p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(bool,string,bool,address)`.\\n mstore(0x00, 0x538e06ab)\\n mstore(0x20, p0)\\n mstore(0x40, 0x80)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n writeString(0xa0, p1)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(bool p0, bytes32 p1, bool p2, bool p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(bool,string,bool,bool)`.\\n mstore(0x00, 0xdc5e935b)\\n mstore(0x20, p0)\\n mstore(0x40, 0x80)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n writeString(0xa0, p1)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(bool p0, bytes32 p1, bool p2, uint256 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(bool,string,bool,uint256)`.\\n mstore(0x00, 0x1606a393)\\n mstore(0x20, p0)\\n mstore(0x40, 0x80)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n writeString(0xa0, p1)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(bool p0, bytes32 p1, bool p2, bytes32 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n // Selector of `log(bool,string,bool,string)`.\\n mstore(0x00, 0x483d0416)\\n mstore(0x20, p0)\\n mstore(0x40, 0x80)\\n mstore(0x60, p2)\\n mstore(0x80, 0xc0)\\n writeString(0xa0, p1)\\n writeString(0xe0, p3)\\n }\\n _sendLogPayload(0x1c, 0x104);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n }\\n }\\n\\n function log(bool p0, bytes32 p1, uint256 p2, address p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(bool,string,uint256,address)`.\\n mstore(0x00, 0x1596a1ce)\\n mstore(0x20, p0)\\n mstore(0x40, 0x80)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n writeString(0xa0, p1)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(bool p0, bytes32 p1, uint256 p2, bool p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(bool,string,uint256,bool)`.\\n mstore(0x00, 0x6b0e5d53)\\n mstore(0x20, p0)\\n mstore(0x40, 0x80)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n writeString(0xa0, p1)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(bool p0, bytes32 p1, uint256 p2, uint256 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(bool,string,uint256,uint256)`.\\n mstore(0x00, 0x28863fcb)\\n mstore(0x20, p0)\\n mstore(0x40, 0x80)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n writeString(0xa0, p1)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(bool p0, bytes32 p1, uint256 p2, bytes32 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n // Selector of `log(bool,string,uint256,string)`.\\n mstore(0x00, 0x1ad96de6)\\n mstore(0x20, p0)\\n mstore(0x40, 0x80)\\n mstore(0x60, p2)\\n mstore(0x80, 0xc0)\\n writeString(0xa0, p1)\\n writeString(0xe0, p3)\\n }\\n _sendLogPayload(0x1c, 0x104);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n }\\n }\\n\\n function log(bool p0, bytes32 p1, bytes32 p2, address p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n // Selector of `log(bool,string,string,address)`.\\n mstore(0x00, 0x97d394d8)\\n mstore(0x20, p0)\\n mstore(0x40, 0x80)\\n mstore(0x60, 0xc0)\\n mstore(0x80, p3)\\n writeString(0xa0, p1)\\n writeString(0xe0, p2)\\n }\\n _sendLogPayload(0x1c, 0x104);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n }\\n }\\n\\n function log(bool p0, bytes32 p1, bytes32 p2, bool p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n // Selector of `log(bool,string,string,bool)`.\\n mstore(0x00, 0x1e4b87e5)\\n mstore(0x20, p0)\\n mstore(0x40, 0x80)\\n mstore(0x60, 0xc0)\\n mstore(0x80, p3)\\n writeString(0xa0, p1)\\n writeString(0xe0, p2)\\n }\\n _sendLogPayload(0x1c, 0x104);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n }\\n }\\n\\n function log(bool p0, bytes32 p1, bytes32 p2, uint256 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n // Selector of `log(bool,string,string,uint256)`.\\n mstore(0x00, 0x7be0c3eb)\\n mstore(0x20, p0)\\n mstore(0x40, 0x80)\\n mstore(0x60, 0xc0)\\n mstore(0x80, p3)\\n writeString(0xa0, p1)\\n writeString(0xe0, p2)\\n }\\n _sendLogPayload(0x1c, 0x104);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n }\\n }\\n\\n function log(bool p0, bytes32 p1, bytes32 p2, bytes32 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n bytes32 m9;\\n bytes32 m10;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n m9 := mload(0x120)\\n m10 := mload(0x140)\\n // Selector of `log(bool,string,string,string)`.\\n mstore(0x00, 0x1762e32a)\\n mstore(0x20, p0)\\n mstore(0x40, 0x80)\\n mstore(0x60, 0xc0)\\n mstore(0x80, 0x100)\\n writeString(0xa0, p1)\\n writeString(0xe0, p2)\\n writeString(0x120, p3)\\n }\\n _sendLogPayload(0x1c, 0x144);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n mstore(0x120, m9)\\n mstore(0x140, m10)\\n }\\n }\\n\\n function log(uint256 p0, address p1, address p2, address p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(uint256,address,address,address)`.\\n mstore(0x00, 0x2488b414)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(uint256 p0, address p1, address p2, bool p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(uint256,address,address,bool)`.\\n mstore(0x00, 0x091ffaf5)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(uint256 p0, address p1, address p2, uint256 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(uint256,address,address,uint256)`.\\n mstore(0x00, 0x736efbb6)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(uint256 p0, address p1, address p2, bytes32 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(uint256,address,address,string)`.\\n mstore(0x00, 0x031c6f73)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, 0x80)\\n writeString(0xa0, p3)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(uint256 p0, address p1, bool p2, address p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(uint256,address,bool,address)`.\\n mstore(0x00, 0xef72c513)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(uint256 p0, address p1, bool p2, bool p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(uint256,address,bool,bool)`.\\n mstore(0x00, 0xe351140f)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(uint256 p0, address p1, bool p2, uint256 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(uint256,address,bool,uint256)`.\\n mstore(0x00, 0x5abd992a)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(uint256 p0, address p1, bool p2, bytes32 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(uint256,address,bool,string)`.\\n mstore(0x00, 0x90fb06aa)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, 0x80)\\n writeString(0xa0, p3)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(uint256 p0, address p1, uint256 p2, address p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(uint256,address,uint256,address)`.\\n mstore(0x00, 0x15c127b5)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(uint256 p0, address p1, uint256 p2, bool p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(uint256,address,uint256,bool)`.\\n mstore(0x00, 0x5f743a7c)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(uint256 p0, address p1, uint256 p2, uint256 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(uint256,address,uint256,uint256)`.\\n mstore(0x00, 0x0c9cd9c1)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(uint256 p0, address p1, uint256 p2, bytes32 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(uint256,address,uint256,string)`.\\n mstore(0x00, 0xddb06521)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, 0x80)\\n writeString(0xa0, p3)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(uint256 p0, address p1, bytes32 p2, address p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(uint256,address,string,address)`.\\n mstore(0x00, 0x9cba8fff)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, 0x80)\\n mstore(0x80, p3)\\n writeString(0xa0, p2)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(uint256 p0, address p1, bytes32 p2, bool p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(uint256,address,string,bool)`.\\n mstore(0x00, 0xcc32ab07)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, 0x80)\\n mstore(0x80, p3)\\n writeString(0xa0, p2)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(uint256 p0, address p1, bytes32 p2, uint256 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(uint256,address,string,uint256)`.\\n mstore(0x00, 0x46826b5d)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, 0x80)\\n mstore(0x80, p3)\\n writeString(0xa0, p2)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(uint256 p0, address p1, bytes32 p2, bytes32 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n // Selector of `log(uint256,address,string,string)`.\\n mstore(0x00, 0x3e128ca3)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, 0x80)\\n mstore(0x80, 0xc0)\\n writeString(0xa0, p2)\\n writeString(0xe0, p3)\\n }\\n _sendLogPayload(0x1c, 0x104);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n }\\n }\\n\\n function log(uint256 p0, bool p1, address p2, address p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(uint256,bool,address,address)`.\\n mstore(0x00, 0xa1ef4cbb)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(uint256 p0, bool p1, address p2, bool p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(uint256,bool,address,bool)`.\\n mstore(0x00, 0x454d54a5)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(uint256 p0, bool p1, address p2, uint256 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(uint256,bool,address,uint256)`.\\n mstore(0x00, 0x078287f5)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(uint256 p0, bool p1, address p2, bytes32 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(uint256,bool,address,string)`.\\n mstore(0x00, 0xade052c7)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, 0x80)\\n writeString(0xa0, p3)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(uint256 p0, bool p1, bool p2, address p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(uint256,bool,bool,address)`.\\n mstore(0x00, 0x69640b59)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(uint256 p0, bool p1, bool p2, bool p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(uint256,bool,bool,bool)`.\\n mstore(0x00, 0xb6f577a1)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(uint256 p0, bool p1, bool p2, uint256 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(uint256,bool,bool,uint256)`.\\n mstore(0x00, 0x7464ce23)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(uint256 p0, bool p1, bool p2, bytes32 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(uint256,bool,bool,string)`.\\n mstore(0x00, 0xdddb9561)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, 0x80)\\n writeString(0xa0, p3)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(uint256 p0, bool p1, uint256 p2, address p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(uint256,bool,uint256,address)`.\\n mstore(0x00, 0x88cb6041)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(uint256 p0, bool p1, uint256 p2, bool p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(uint256,bool,uint256,bool)`.\\n mstore(0x00, 0x91a02e2a)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(uint256 p0, bool p1, uint256 p2, uint256 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(uint256,bool,uint256,uint256)`.\\n mstore(0x00, 0xc6acc7a8)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(uint256 p0, bool p1, uint256 p2, bytes32 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(uint256,bool,uint256,string)`.\\n mstore(0x00, 0xde03e774)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, 0x80)\\n writeString(0xa0, p3)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(uint256 p0, bool p1, bytes32 p2, address p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(uint256,bool,string,address)`.\\n mstore(0x00, 0xef529018)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, 0x80)\\n mstore(0x80, p3)\\n writeString(0xa0, p2)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(uint256 p0, bool p1, bytes32 p2, bool p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(uint256,bool,string,bool)`.\\n mstore(0x00, 0xeb928d7f)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, 0x80)\\n mstore(0x80, p3)\\n writeString(0xa0, p2)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(uint256 p0, bool p1, bytes32 p2, uint256 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(uint256,bool,string,uint256)`.\\n mstore(0x00, 0x2c1d0746)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, 0x80)\\n mstore(0x80, p3)\\n writeString(0xa0, p2)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(uint256 p0, bool p1, bytes32 p2, bytes32 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n // Selector of `log(uint256,bool,string,string)`.\\n mstore(0x00, 0x68c8b8bd)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, 0x80)\\n mstore(0x80, 0xc0)\\n writeString(0xa0, p2)\\n writeString(0xe0, p3)\\n }\\n _sendLogPayload(0x1c, 0x104);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n }\\n }\\n\\n function log(uint256 p0, uint256 p1, address p2, address p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(uint256,uint256,address,address)`.\\n mstore(0x00, 0x56a5d1b1)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(uint256 p0, uint256 p1, address p2, bool p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(uint256,uint256,address,bool)`.\\n mstore(0x00, 0x15cac476)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(uint256 p0, uint256 p1, address p2, uint256 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(uint256,uint256,address,uint256)`.\\n mstore(0x00, 0x88f6e4b2)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(uint256 p0, uint256 p1, address p2, bytes32 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(uint256,uint256,address,string)`.\\n mstore(0x00, 0x6cde40b8)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, 0x80)\\n writeString(0xa0, p3)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(uint256 p0, uint256 p1, bool p2, address p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(uint256,uint256,bool,address)`.\\n mstore(0x00, 0x9a816a83)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(uint256 p0, uint256 p1, bool p2, bool p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(uint256,uint256,bool,bool)`.\\n mstore(0x00, 0xab085ae6)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(uint256 p0, uint256 p1, bool p2, uint256 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(uint256,uint256,bool,uint256)`.\\n mstore(0x00, 0xeb7f6fd2)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(uint256 p0, uint256 p1, bool p2, bytes32 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(uint256,uint256,bool,string)`.\\n mstore(0x00, 0xa5b4fc99)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, 0x80)\\n writeString(0xa0, p3)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(uint256 p0, uint256 p1, uint256 p2, address p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(uint256,uint256,uint256,address)`.\\n mstore(0x00, 0xfa8185af)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(uint256 p0, uint256 p1, uint256 p2, bool p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(uint256,uint256,uint256,bool)`.\\n mstore(0x00, 0xc598d185)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(uint256 p0, uint256 p1, uint256 p2, uint256 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(uint256,uint256,uint256,uint256)`.\\n mstore(0x00, 0x193fb800)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(uint256 p0, uint256 p1, uint256 p2, bytes32 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(uint256,uint256,uint256,string)`.\\n mstore(0x00, 0x59cfcbe3)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, 0x80)\\n writeString(0xa0, p3)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(uint256 p0, uint256 p1, bytes32 p2, address p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(uint256,uint256,string,address)`.\\n mstore(0x00, 0x42d21db7)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, 0x80)\\n mstore(0x80, p3)\\n writeString(0xa0, p2)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(uint256 p0, uint256 p1, bytes32 p2, bool p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(uint256,uint256,string,bool)`.\\n mstore(0x00, 0x7af6ab25)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, 0x80)\\n mstore(0x80, p3)\\n writeString(0xa0, p2)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(uint256 p0, uint256 p1, bytes32 p2, uint256 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(uint256,uint256,string,uint256)`.\\n mstore(0x00, 0x5da297eb)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, 0x80)\\n mstore(0x80, p3)\\n writeString(0xa0, p2)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(uint256 p0, uint256 p1, bytes32 p2, bytes32 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n // Selector of `log(uint256,uint256,string,string)`.\\n mstore(0x00, 0x27d8afd2)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, 0x80)\\n mstore(0x80, 0xc0)\\n writeString(0xa0, p2)\\n writeString(0xe0, p3)\\n }\\n _sendLogPayload(0x1c, 0x104);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n }\\n }\\n\\n function log(uint256 p0, bytes32 p1, address p2, address p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(uint256,string,address,address)`.\\n mstore(0x00, 0x6168ed61)\\n mstore(0x20, p0)\\n mstore(0x40, 0x80)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n writeString(0xa0, p1)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(uint256 p0, bytes32 p1, address p2, bool p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(uint256,string,address,bool)`.\\n mstore(0x00, 0x90c30a56)\\n mstore(0x20, p0)\\n mstore(0x40, 0x80)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n writeString(0xa0, p1)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(uint256 p0, bytes32 p1, address p2, uint256 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(uint256,string,address,uint256)`.\\n mstore(0x00, 0xe8d3018d)\\n mstore(0x20, p0)\\n mstore(0x40, 0x80)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n writeString(0xa0, p1)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(uint256 p0, bytes32 p1, address p2, bytes32 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n // Selector of `log(uint256,string,address,string)`.\\n mstore(0x00, 0x9c3adfa1)\\n mstore(0x20, p0)\\n mstore(0x40, 0x80)\\n mstore(0x60, p2)\\n mstore(0x80, 0xc0)\\n writeString(0xa0, p1)\\n writeString(0xe0, p3)\\n }\\n _sendLogPayload(0x1c, 0x104);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n }\\n }\\n\\n function log(uint256 p0, bytes32 p1, bool p2, address p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(uint256,string,bool,address)`.\\n mstore(0x00, 0xae2ec581)\\n mstore(0x20, p0)\\n mstore(0x40, 0x80)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n writeString(0xa0, p1)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(uint256 p0, bytes32 p1, bool p2, bool p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(uint256,string,bool,bool)`.\\n mstore(0x00, 0xba535d9c)\\n mstore(0x20, p0)\\n mstore(0x40, 0x80)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n writeString(0xa0, p1)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(uint256 p0, bytes32 p1, bool p2, uint256 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(uint256,string,bool,uint256)`.\\n mstore(0x00, 0xcf009880)\\n mstore(0x20, p0)\\n mstore(0x40, 0x80)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n writeString(0xa0, p1)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(uint256 p0, bytes32 p1, bool p2, bytes32 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n // Selector of `log(uint256,string,bool,string)`.\\n mstore(0x00, 0xd2d423cd)\\n mstore(0x20, p0)\\n mstore(0x40, 0x80)\\n mstore(0x60, p2)\\n mstore(0x80, 0xc0)\\n writeString(0xa0, p1)\\n writeString(0xe0, p3)\\n }\\n _sendLogPayload(0x1c, 0x104);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n }\\n }\\n\\n function log(uint256 p0, bytes32 p1, uint256 p2, address p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(uint256,string,uint256,address)`.\\n mstore(0x00, 0x3b2279b4)\\n mstore(0x20, p0)\\n mstore(0x40, 0x80)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n writeString(0xa0, p1)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(uint256 p0, bytes32 p1, uint256 p2, bool p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(uint256,string,uint256,bool)`.\\n mstore(0x00, 0x691a8f74)\\n mstore(0x20, p0)\\n mstore(0x40, 0x80)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n writeString(0xa0, p1)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(uint256 p0, bytes32 p1, uint256 p2, uint256 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(uint256,string,uint256,uint256)`.\\n mstore(0x00, 0x82c25b74)\\n mstore(0x20, p0)\\n mstore(0x40, 0x80)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n writeString(0xa0, p1)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(uint256 p0, bytes32 p1, uint256 p2, bytes32 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n // Selector of `log(uint256,string,uint256,string)`.\\n mstore(0x00, 0xb7b914ca)\\n mstore(0x20, p0)\\n mstore(0x40, 0x80)\\n mstore(0x60, p2)\\n mstore(0x80, 0xc0)\\n writeString(0xa0, p1)\\n writeString(0xe0, p3)\\n }\\n _sendLogPayload(0x1c, 0x104);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n }\\n }\\n\\n function log(uint256 p0, bytes32 p1, bytes32 p2, address p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n // Selector of `log(uint256,string,string,address)`.\\n mstore(0x00, 0xd583c602)\\n mstore(0x20, p0)\\n mstore(0x40, 0x80)\\n mstore(0x60, 0xc0)\\n mstore(0x80, p3)\\n writeString(0xa0, p1)\\n writeString(0xe0, p2)\\n }\\n _sendLogPayload(0x1c, 0x104);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n }\\n }\\n\\n function log(uint256 p0, bytes32 p1, bytes32 p2, bool p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n // Selector of `log(uint256,string,string,bool)`.\\n mstore(0x00, 0xb3a6b6bd)\\n mstore(0x20, p0)\\n mstore(0x40, 0x80)\\n mstore(0x60, 0xc0)\\n mstore(0x80, p3)\\n writeString(0xa0, p1)\\n writeString(0xe0, p2)\\n }\\n _sendLogPayload(0x1c, 0x104);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n }\\n }\\n\\n function log(uint256 p0, bytes32 p1, bytes32 p2, uint256 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n // Selector of `log(uint256,string,string,uint256)`.\\n mstore(0x00, 0xb028c9bd)\\n mstore(0x20, p0)\\n mstore(0x40, 0x80)\\n mstore(0x60, 0xc0)\\n mstore(0x80, p3)\\n writeString(0xa0, p1)\\n writeString(0xe0, p2)\\n }\\n _sendLogPayload(0x1c, 0x104);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n }\\n }\\n\\n function log(uint256 p0, bytes32 p1, bytes32 p2, bytes32 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n bytes32 m9;\\n bytes32 m10;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n m9 := mload(0x120)\\n m10 := mload(0x140)\\n // Selector of `log(uint256,string,string,string)`.\\n mstore(0x00, 0x21ad0683)\\n mstore(0x20, p0)\\n mstore(0x40, 0x80)\\n mstore(0x60, 0xc0)\\n mstore(0x80, 0x100)\\n writeString(0xa0, p1)\\n writeString(0xe0, p2)\\n writeString(0x120, p3)\\n }\\n _sendLogPayload(0x1c, 0x144);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n mstore(0x120, m9)\\n mstore(0x140, m10)\\n }\\n }\\n\\n function log(bytes32 p0, address p1, address p2, address p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(string,address,address,address)`.\\n mstore(0x00, 0xed8f28f6)\\n mstore(0x20, 0x80)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n writeString(0xa0, p0)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(bytes32 p0, address p1, address p2, bool p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(string,address,address,bool)`.\\n mstore(0x00, 0xb59dbd60)\\n mstore(0x20, 0x80)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n writeString(0xa0, p0)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(bytes32 p0, address p1, address p2, uint256 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(string,address,address,uint256)`.\\n mstore(0x00, 0x8ef3f399)\\n mstore(0x20, 0x80)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n writeString(0xa0, p0)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(bytes32 p0, address p1, address p2, bytes32 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n // Selector of `log(string,address,address,string)`.\\n mstore(0x00, 0x800a1c67)\\n mstore(0x20, 0x80)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, 0xc0)\\n writeString(0xa0, p0)\\n writeString(0xe0, p3)\\n }\\n _sendLogPayload(0x1c, 0x104);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n }\\n }\\n\\n function log(bytes32 p0, address p1, bool p2, address p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(string,address,bool,address)`.\\n mstore(0x00, 0x223603bd)\\n mstore(0x20, 0x80)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n writeString(0xa0, p0)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(bytes32 p0, address p1, bool p2, bool p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(string,address,bool,bool)`.\\n mstore(0x00, 0x79884c2b)\\n mstore(0x20, 0x80)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n writeString(0xa0, p0)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(bytes32 p0, address p1, bool p2, uint256 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(string,address,bool,uint256)`.\\n mstore(0x00, 0x3e9f866a)\\n mstore(0x20, 0x80)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n writeString(0xa0, p0)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(bytes32 p0, address p1, bool p2, bytes32 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n // Selector of `log(string,address,bool,string)`.\\n mstore(0x00, 0x0454c079)\\n mstore(0x20, 0x80)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, 0xc0)\\n writeString(0xa0, p0)\\n writeString(0xe0, p3)\\n }\\n _sendLogPayload(0x1c, 0x104);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n }\\n }\\n\\n function log(bytes32 p0, address p1, uint256 p2, address p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(string,address,uint256,address)`.\\n mstore(0x00, 0x63fb8bc5)\\n mstore(0x20, 0x80)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n writeString(0xa0, p0)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(bytes32 p0, address p1, uint256 p2, bool p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(string,address,uint256,bool)`.\\n mstore(0x00, 0xfc4845f0)\\n mstore(0x20, 0x80)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n writeString(0xa0, p0)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(bytes32 p0, address p1, uint256 p2, uint256 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(string,address,uint256,uint256)`.\\n mstore(0x00, 0xf8f51b1e)\\n mstore(0x20, 0x80)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n writeString(0xa0, p0)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(bytes32 p0, address p1, uint256 p2, bytes32 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n // Selector of `log(string,address,uint256,string)`.\\n mstore(0x00, 0x5a477632)\\n mstore(0x20, 0x80)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, 0xc0)\\n writeString(0xa0, p0)\\n writeString(0xe0, p3)\\n }\\n _sendLogPayload(0x1c, 0x104);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n }\\n }\\n\\n function log(bytes32 p0, address p1, bytes32 p2, address p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n // Selector of `log(string,address,string,address)`.\\n mstore(0x00, 0xaabc9a31)\\n mstore(0x20, 0x80)\\n mstore(0x40, p1)\\n mstore(0x60, 0xc0)\\n mstore(0x80, p3)\\n writeString(0xa0, p0)\\n writeString(0xe0, p2)\\n }\\n _sendLogPayload(0x1c, 0x104);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n }\\n }\\n\\n function log(bytes32 p0, address p1, bytes32 p2, bool p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n // Selector of `log(string,address,string,bool)`.\\n mstore(0x00, 0x5f15d28c)\\n mstore(0x20, 0x80)\\n mstore(0x40, p1)\\n mstore(0x60, 0xc0)\\n mstore(0x80, p3)\\n writeString(0xa0, p0)\\n writeString(0xe0, p2)\\n }\\n _sendLogPayload(0x1c, 0x104);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n }\\n }\\n\\n function log(bytes32 p0, address p1, bytes32 p2, uint256 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n // Selector of `log(string,address,string,uint256)`.\\n mstore(0x00, 0x91d1112e)\\n mstore(0x20, 0x80)\\n mstore(0x40, p1)\\n mstore(0x60, 0xc0)\\n mstore(0x80, p3)\\n writeString(0xa0, p0)\\n writeString(0xe0, p2)\\n }\\n _sendLogPayload(0x1c, 0x104);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n }\\n }\\n\\n function log(bytes32 p0, address p1, bytes32 p2, bytes32 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n bytes32 m9;\\n bytes32 m10;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n m9 := mload(0x120)\\n m10 := mload(0x140)\\n // Selector of `log(string,address,string,string)`.\\n mstore(0x00, 0x245986f2)\\n mstore(0x20, 0x80)\\n mstore(0x40, p1)\\n mstore(0x60, 0xc0)\\n mstore(0x80, 0x100)\\n writeString(0xa0, p0)\\n writeString(0xe0, p2)\\n writeString(0x120, p3)\\n }\\n _sendLogPayload(0x1c, 0x144);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n mstore(0x120, m9)\\n mstore(0x140, m10)\\n }\\n }\\n\\n function log(bytes32 p0, bool p1, address p2, address p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(string,bool,address,address)`.\\n mstore(0x00, 0x33e9dd1d)\\n mstore(0x20, 0x80)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n writeString(0xa0, p0)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(bytes32 p0, bool p1, address p2, bool p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(string,bool,address,bool)`.\\n mstore(0x00, 0x958c28c6)\\n mstore(0x20, 0x80)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n writeString(0xa0, p0)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(bytes32 p0, bool p1, address p2, uint256 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(string,bool,address,uint256)`.\\n mstore(0x00, 0x5d08bb05)\\n mstore(0x20, 0x80)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n writeString(0xa0, p0)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(bytes32 p0, bool p1, address p2, bytes32 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n // Selector of `log(string,bool,address,string)`.\\n mstore(0x00, 0x2d8e33a4)\\n mstore(0x20, 0x80)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, 0xc0)\\n writeString(0xa0, p0)\\n writeString(0xe0, p3)\\n }\\n _sendLogPayload(0x1c, 0x104);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n }\\n }\\n\\n function log(bytes32 p0, bool p1, bool p2, address p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(string,bool,bool,address)`.\\n mstore(0x00, 0x7190a529)\\n mstore(0x20, 0x80)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n writeString(0xa0, p0)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(bytes32 p0, bool p1, bool p2, bool p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(string,bool,bool,bool)`.\\n mstore(0x00, 0x895af8c5)\\n mstore(0x20, 0x80)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n writeString(0xa0, p0)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(bytes32 p0, bool p1, bool p2, uint256 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(string,bool,bool,uint256)`.\\n mstore(0x00, 0x8e3f78a9)\\n mstore(0x20, 0x80)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n writeString(0xa0, p0)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(bytes32 p0, bool p1, bool p2, bytes32 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n // Selector of `log(string,bool,bool,string)`.\\n mstore(0x00, 0x9d22d5dd)\\n mstore(0x20, 0x80)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, 0xc0)\\n writeString(0xa0, p0)\\n writeString(0xe0, p3)\\n }\\n _sendLogPayload(0x1c, 0x104);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n }\\n }\\n\\n function log(bytes32 p0, bool p1, uint256 p2, address p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(string,bool,uint256,address)`.\\n mstore(0x00, 0x935e09bf)\\n mstore(0x20, 0x80)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n writeString(0xa0, p0)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(bytes32 p0, bool p1, uint256 p2, bool p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(string,bool,uint256,bool)`.\\n mstore(0x00, 0x8af7cf8a)\\n mstore(0x20, 0x80)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n writeString(0xa0, p0)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(bytes32 p0, bool p1, uint256 p2, uint256 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(string,bool,uint256,uint256)`.\\n mstore(0x00, 0x64b5bb67)\\n mstore(0x20, 0x80)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n writeString(0xa0, p0)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(bytes32 p0, bool p1, uint256 p2, bytes32 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n // Selector of `log(string,bool,uint256,string)`.\\n mstore(0x00, 0x742d6ee7)\\n mstore(0x20, 0x80)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, 0xc0)\\n writeString(0xa0, p0)\\n writeString(0xe0, p3)\\n }\\n _sendLogPayload(0x1c, 0x104);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n }\\n }\\n\\n function log(bytes32 p0, bool p1, bytes32 p2, address p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n // Selector of `log(string,bool,string,address)`.\\n mstore(0x00, 0xe0625b29)\\n mstore(0x20, 0x80)\\n mstore(0x40, p1)\\n mstore(0x60, 0xc0)\\n mstore(0x80, p3)\\n writeString(0xa0, p0)\\n writeString(0xe0, p2)\\n }\\n _sendLogPayload(0x1c, 0x104);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n }\\n }\\n\\n function log(bytes32 p0, bool p1, bytes32 p2, bool p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n // Selector of `log(string,bool,string,bool)`.\\n mstore(0x00, 0x3f8a701d)\\n mstore(0x20, 0x80)\\n mstore(0x40, p1)\\n mstore(0x60, 0xc0)\\n mstore(0x80, p3)\\n writeString(0xa0, p0)\\n writeString(0xe0, p2)\\n }\\n _sendLogPayload(0x1c, 0x104);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n }\\n }\\n\\n function log(bytes32 p0, bool p1, bytes32 p2, uint256 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n // Selector of `log(string,bool,string,uint256)`.\\n mstore(0x00, 0x24f91465)\\n mstore(0x20, 0x80)\\n mstore(0x40, p1)\\n mstore(0x60, 0xc0)\\n mstore(0x80, p3)\\n writeString(0xa0, p0)\\n writeString(0xe0, p2)\\n }\\n _sendLogPayload(0x1c, 0x104);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n }\\n }\\n\\n function log(bytes32 p0, bool p1, bytes32 p2, bytes32 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n bytes32 m9;\\n bytes32 m10;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n m9 := mload(0x120)\\n m10 := mload(0x140)\\n // Selector of `log(string,bool,string,string)`.\\n mstore(0x00, 0xa826caeb)\\n mstore(0x20, 0x80)\\n mstore(0x40, p1)\\n mstore(0x60, 0xc0)\\n mstore(0x80, 0x100)\\n writeString(0xa0, p0)\\n writeString(0xe0, p2)\\n writeString(0x120, p3)\\n }\\n _sendLogPayload(0x1c, 0x144);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n mstore(0x120, m9)\\n mstore(0x140, m10)\\n }\\n }\\n\\n function log(bytes32 p0, uint256 p1, address p2, address p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(string,uint256,address,address)`.\\n mstore(0x00, 0x5ea2b7ae)\\n mstore(0x20, 0x80)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n writeString(0xa0, p0)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(bytes32 p0, uint256 p1, address p2, bool p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(string,uint256,address,bool)`.\\n mstore(0x00, 0x82112a42)\\n mstore(0x20, 0x80)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n writeString(0xa0, p0)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(bytes32 p0, uint256 p1, address p2, uint256 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(string,uint256,address,uint256)`.\\n mstore(0x00, 0x4f04fdc6)\\n mstore(0x20, 0x80)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n writeString(0xa0, p0)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(bytes32 p0, uint256 p1, address p2, bytes32 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n // Selector of `log(string,uint256,address,string)`.\\n mstore(0x00, 0x9ffb2f93)\\n mstore(0x20, 0x80)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, 0xc0)\\n writeString(0xa0, p0)\\n writeString(0xe0, p3)\\n }\\n _sendLogPayload(0x1c, 0x104);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n }\\n }\\n\\n function log(bytes32 p0, uint256 p1, bool p2, address p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(string,uint256,bool,address)`.\\n mstore(0x00, 0xe0e95b98)\\n mstore(0x20, 0x80)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n writeString(0xa0, p0)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(bytes32 p0, uint256 p1, bool p2, bool p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(string,uint256,bool,bool)`.\\n mstore(0x00, 0x354c36d6)\\n mstore(0x20, 0x80)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n writeString(0xa0, p0)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(bytes32 p0, uint256 p1, bool p2, uint256 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(string,uint256,bool,uint256)`.\\n mstore(0x00, 0xe41b6f6f)\\n mstore(0x20, 0x80)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n writeString(0xa0, p0)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(bytes32 p0, uint256 p1, bool p2, bytes32 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n // Selector of `log(string,uint256,bool,string)`.\\n mstore(0x00, 0xabf73a98)\\n mstore(0x20, 0x80)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, 0xc0)\\n writeString(0xa0, p0)\\n writeString(0xe0, p3)\\n }\\n _sendLogPayload(0x1c, 0x104);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n }\\n }\\n\\n function log(bytes32 p0, uint256 p1, uint256 p2, address p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(string,uint256,uint256,address)`.\\n mstore(0x00, 0xe21de278)\\n mstore(0x20, 0x80)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n writeString(0xa0, p0)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(bytes32 p0, uint256 p1, uint256 p2, bool p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(string,uint256,uint256,bool)`.\\n mstore(0x00, 0x7626db92)\\n mstore(0x20, 0x80)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n writeString(0xa0, p0)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(bytes32 p0, uint256 p1, uint256 p2, uint256 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(string,uint256,uint256,uint256)`.\\n mstore(0x00, 0xa7a87853)\\n mstore(0x20, 0x80)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n writeString(0xa0, p0)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(bytes32 p0, uint256 p1, uint256 p2, bytes32 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n // Selector of `log(string,uint256,uint256,string)`.\\n mstore(0x00, 0x854b3496)\\n mstore(0x20, 0x80)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, 0xc0)\\n writeString(0xa0, p0)\\n writeString(0xe0, p3)\\n }\\n _sendLogPayload(0x1c, 0x104);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n }\\n }\\n\\n function log(bytes32 p0, uint256 p1, bytes32 p2, address p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n // Selector of `log(string,uint256,string,address)`.\\n mstore(0x00, 0x7c4632a4)\\n mstore(0x20, 0x80)\\n mstore(0x40, p1)\\n mstore(0x60, 0xc0)\\n mstore(0x80, p3)\\n writeString(0xa0, p0)\\n writeString(0xe0, p2)\\n }\\n _sendLogPayload(0x1c, 0x104);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n }\\n }\\n\\n function log(bytes32 p0, uint256 p1, bytes32 p2, bool p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n // Selector of `log(string,uint256,string,bool)`.\\n mstore(0x00, 0x7d24491d)\\n mstore(0x20, 0x80)\\n mstore(0x40, p1)\\n mstore(0x60, 0xc0)\\n mstore(0x80, p3)\\n writeString(0xa0, p0)\\n writeString(0xe0, p2)\\n }\\n _sendLogPayload(0x1c, 0x104);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n }\\n }\\n\\n function log(bytes32 p0, uint256 p1, bytes32 p2, uint256 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n // Selector of `log(string,uint256,string,uint256)`.\\n mstore(0x00, 0xc67ea9d1)\\n mstore(0x20, 0x80)\\n mstore(0x40, p1)\\n mstore(0x60, 0xc0)\\n mstore(0x80, p3)\\n writeString(0xa0, p0)\\n writeString(0xe0, p2)\\n }\\n _sendLogPayload(0x1c, 0x104);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n }\\n }\\n\\n function log(bytes32 p0, uint256 p1, bytes32 p2, bytes32 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n bytes32 m9;\\n bytes32 m10;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n m9 := mload(0x120)\\n m10 := mload(0x140)\\n // Selector of `log(string,uint256,string,string)`.\\n mstore(0x00, 0x5ab84e1f)\\n mstore(0x20, 0x80)\\n mstore(0x40, p1)\\n mstore(0x60, 0xc0)\\n mstore(0x80, 0x100)\\n writeString(0xa0, p0)\\n writeString(0xe0, p2)\\n writeString(0x120, p3)\\n }\\n _sendLogPayload(0x1c, 0x144);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n mstore(0x120, m9)\\n mstore(0x140, m10)\\n }\\n }\\n\\n function log(bytes32 p0, bytes32 p1, address p2, address p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n // Selector of `log(string,string,address,address)`.\\n mstore(0x00, 0x439c7bef)\\n mstore(0x20, 0x80)\\n mstore(0x40, 0xc0)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n writeString(0xa0, p0)\\n writeString(0xe0, p1)\\n }\\n _sendLogPayload(0x1c, 0x104);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n }\\n }\\n\\n function log(bytes32 p0, bytes32 p1, address p2, bool p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n // Selector of `log(string,string,address,bool)`.\\n mstore(0x00, 0x5ccd4e37)\\n mstore(0x20, 0x80)\\n mstore(0x40, 0xc0)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n writeString(0xa0, p0)\\n writeString(0xe0, p1)\\n }\\n _sendLogPayload(0x1c, 0x104);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n }\\n }\\n\\n function log(bytes32 p0, bytes32 p1, address p2, uint256 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n // Selector of `log(string,string,address,uint256)`.\\n mstore(0x00, 0x7cc3c607)\\n mstore(0x20, 0x80)\\n mstore(0x40, 0xc0)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n writeString(0xa0, p0)\\n writeString(0xe0, p1)\\n }\\n _sendLogPayload(0x1c, 0x104);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n }\\n }\\n\\n function log(bytes32 p0, bytes32 p1, address p2, bytes32 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n bytes32 m9;\\n bytes32 m10;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n m9 := mload(0x120)\\n m10 := mload(0x140)\\n // Selector of `log(string,string,address,string)`.\\n mstore(0x00, 0xeb1bff80)\\n mstore(0x20, 0x80)\\n mstore(0x40, 0xc0)\\n mstore(0x60, p2)\\n mstore(0x80, 0x100)\\n writeString(0xa0, p0)\\n writeString(0xe0, p1)\\n writeString(0x120, p3)\\n }\\n _sendLogPayload(0x1c, 0x144);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n mstore(0x120, m9)\\n mstore(0x140, m10)\\n }\\n }\\n\\n function log(bytes32 p0, bytes32 p1, bool p2, address p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n // Selector of `log(string,string,bool,address)`.\\n mstore(0x00, 0xc371c7db)\\n mstore(0x20, 0x80)\\n mstore(0x40, 0xc0)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n writeString(0xa0, p0)\\n writeString(0xe0, p1)\\n }\\n _sendLogPayload(0x1c, 0x104);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n }\\n }\\n\\n function log(bytes32 p0, bytes32 p1, bool p2, bool p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n // Selector of `log(string,string,bool,bool)`.\\n mstore(0x00, 0x40785869)\\n mstore(0x20, 0x80)\\n mstore(0x40, 0xc0)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n writeString(0xa0, p0)\\n writeString(0xe0, p1)\\n }\\n _sendLogPayload(0x1c, 0x104);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n }\\n }\\n\\n function log(bytes32 p0, bytes32 p1, bool p2, uint256 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n // Selector of `log(string,string,bool,uint256)`.\\n mstore(0x00, 0xd6aefad2)\\n mstore(0x20, 0x80)\\n mstore(0x40, 0xc0)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n writeString(0xa0, p0)\\n writeString(0xe0, p1)\\n }\\n _sendLogPayload(0x1c, 0x104);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n }\\n }\\n\\n function log(bytes32 p0, bytes32 p1, bool p2, bytes32 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n bytes32 m9;\\n bytes32 m10;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n m9 := mload(0x120)\\n m10 := mload(0x140)\\n // Selector of `log(string,string,bool,string)`.\\n mstore(0x00, 0x5e84b0ea)\\n mstore(0x20, 0x80)\\n mstore(0x40, 0xc0)\\n mstore(0x60, p2)\\n mstore(0x80, 0x100)\\n writeString(0xa0, p0)\\n writeString(0xe0, p1)\\n writeString(0x120, p3)\\n }\\n _sendLogPayload(0x1c, 0x144);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n mstore(0x120, m9)\\n mstore(0x140, m10)\\n }\\n }\\n\\n function log(bytes32 p0, bytes32 p1, uint256 p2, address p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n // Selector of `log(string,string,uint256,address)`.\\n mstore(0x00, 0x1023f7b2)\\n mstore(0x20, 0x80)\\n mstore(0x40, 0xc0)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n writeString(0xa0, p0)\\n writeString(0xe0, p1)\\n }\\n _sendLogPayload(0x1c, 0x104);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n }\\n }\\n\\n function log(bytes32 p0, bytes32 p1, uint256 p2, bool p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n // Selector of `log(string,string,uint256,bool)`.\\n mstore(0x00, 0xc3a8a654)\\n mstore(0x20, 0x80)\\n mstore(0x40, 0xc0)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n writeString(0xa0, p0)\\n writeString(0xe0, p1)\\n }\\n _sendLogPayload(0x1c, 0x104);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n }\\n }\\n\\n function log(bytes32 p0, bytes32 p1, uint256 p2, uint256 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n // Selector of `log(string,string,uint256,uint256)`.\\n mstore(0x00, 0xf45d7d2c)\\n mstore(0x20, 0x80)\\n mstore(0x40, 0xc0)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n writeString(0xa0, p0)\\n writeString(0xe0, p1)\\n }\\n _sendLogPayload(0x1c, 0x104);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n }\\n }\\n\\n function log(bytes32 p0, bytes32 p1, uint256 p2, bytes32 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n bytes32 m9;\\n bytes32 m10;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n m9 := mload(0x120)\\n m10 := mload(0x140)\\n // Selector of `log(string,string,uint256,string)`.\\n mstore(0x00, 0x5d1a971a)\\n mstore(0x20, 0x80)\\n mstore(0x40, 0xc0)\\n mstore(0x60, p2)\\n mstore(0x80, 0x100)\\n writeString(0xa0, p0)\\n writeString(0xe0, p1)\\n writeString(0x120, p3)\\n }\\n _sendLogPayload(0x1c, 0x144);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n mstore(0x120, m9)\\n mstore(0x140, m10)\\n }\\n }\\n\\n function log(bytes32 p0, bytes32 p1, bytes32 p2, address p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n bytes32 m9;\\n bytes32 m10;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n m9 := mload(0x120)\\n m10 := mload(0x140)\\n // Selector of `log(string,string,string,address)`.\\n mstore(0x00, 0x6d572f44)\\n mstore(0x20, 0x80)\\n mstore(0x40, 0xc0)\\n mstore(0x60, 0x100)\\n mstore(0x80, p3)\\n writeString(0xa0, p0)\\n writeString(0xe0, p1)\\n writeString(0x120, p2)\\n }\\n _sendLogPayload(0x1c, 0x144);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n mstore(0x120, m9)\\n mstore(0x140, m10)\\n }\\n }\\n\\n function log(bytes32 p0, bytes32 p1, bytes32 p2, bool p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n bytes32 m9;\\n bytes32 m10;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n m9 := mload(0x120)\\n m10 := mload(0x140)\\n // Selector of `log(string,string,string,bool)`.\\n mstore(0x00, 0x2c1754ed)\\n mstore(0x20, 0x80)\\n mstore(0x40, 0xc0)\\n mstore(0x60, 0x100)\\n mstore(0x80, p3)\\n writeString(0xa0, p0)\\n writeString(0xe0, p1)\\n writeString(0x120, p2)\\n }\\n _sendLogPayload(0x1c, 0x144);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n mstore(0x120, m9)\\n mstore(0x140, m10)\\n }\\n }\\n\\n function log(bytes32 p0, bytes32 p1, bytes32 p2, uint256 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n bytes32 m9;\\n bytes32 m10;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n m9 := mload(0x120)\\n m10 := mload(0x140)\\n // Selector of `log(string,string,string,uint256)`.\\n mstore(0x00, 0x8eafb02b)\\n mstore(0x20, 0x80)\\n mstore(0x40, 0xc0)\\n mstore(0x60, 0x100)\\n mstore(0x80, p3)\\n writeString(0xa0, p0)\\n writeString(0xe0, p1)\\n writeString(0x120, p2)\\n }\\n _sendLogPayload(0x1c, 0x144);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n mstore(0x120, m9)\\n mstore(0x140, m10)\\n }\\n }\\n\\n function log(bytes32 p0, bytes32 p1, bytes32 p2, bytes32 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n bytes32 m9;\\n bytes32 m10;\\n bytes32 m11;\\n bytes32 m12;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n m9 := mload(0x120)\\n m10 := mload(0x140)\\n m11 := mload(0x160)\\n m12 := mload(0x180)\\n // Selector of `log(string,string,string,string)`.\\n mstore(0x00, 0xde68f20a)\\n mstore(0x20, 0x80)\\n mstore(0x40, 0xc0)\\n mstore(0x60, 0x100)\\n mstore(0x80, 0x140)\\n writeString(0xa0, p0)\\n writeString(0xe0, p1)\\n writeString(0x120, p2)\\n writeString(0x160, p3)\\n }\\n _sendLogPayload(0x1c, 0x184);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n mstore(0x120, m9)\\n mstore(0x140, m10)\\n mstore(0x160, m11)\\n mstore(0x180, m12)\\n }\\n }\\n}\\n\",\"keccak256\":\"0xbef9786cb49d3eade757bad87568c49c8c8f35721f0193c95ffb055d9e466e11\",\"license\":\"MIT\"},\"scripts/FetchChainInfo.s.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\nimport { Script } from \\\"forge-std/Script.sol\\\";\\nimport { GameTypes, GameType } from \\\"src/dispute/lib/Types.sol\\\";\\n\\n/// @notice Contains getters for arbitrary methods from all L1 contracts, including legacy getters\\n/// that have since been deprecated.\\ninterface IFetcher {\\n function guardian() external view returns (address);\\n function GUARDIAN() external view returns (address);\\n function systemConfig() external view returns (address);\\n function SYSTEM_CONFIG() external view returns (address);\\n function disputeGameFactory() external view returns (address);\\n function ethLockbox() external view returns (address);\\n function superchainConfig() external view returns (address);\\n function messenger() external view returns (address);\\n function addressManager() external view returns (address);\\n function PORTAL() external view returns (address);\\n function portal() external view returns (address);\\n function l1ERC721Bridge() external view returns (address);\\n function optimismMintableERC20Factory() external view returns (address);\\n function gameImpls(GameType _gameType) external view returns (address);\\n function respectedGameType() external view returns (GameType);\\n function anchorStateRegistry() external view returns (address);\\n function L2_ORACLE() external view returns (address);\\n function l2Oracle() external view returns (address);\\n function vm() external view returns (address);\\n function oracle() external view returns (address);\\n function challenger() external view returns (address);\\n function proposer() external view returns (address);\\n function PROPOSER() external view returns (address);\\n function batcherHash() external view returns (bytes32);\\n function admin() external view returns (address);\\n function owner() external view returns (address);\\n function unsafeBlockSigner() external view returns (address);\\n function weth() external view returns (address);\\n}\\n\\ncontract FetchChainInfoInput {\\n address internal _systemConfigProxy;\\n address internal _l1StandardBridgeProxy;\\n\\n function set(bytes4 _sel, address _addr) public {\\n require(_addr != address(0), \\\"FetchChainInfoInput: cannot set zero address\\\");\\n if (_sel == this.systemConfigProxy.selector) _systemConfigProxy = _addr;\\n else if (_sel == this.l1StandardBridgeProxy.selector) _l1StandardBridgeProxy = _addr;\\n else revert(\\\"FetchChainInfoInput: unknown selector\\\");\\n }\\n\\n function systemConfigProxy() public view returns (address) {\\n require(_systemConfigProxy != address(0), \\\"FetchChainInfoInput: systemConfigProxy not set\\\");\\n return _systemConfigProxy;\\n }\\n\\n function l1StandardBridgeProxy() public view returns (address) {\\n require(_l1StandardBridgeProxy != address(0), \\\"FetchChainInfoInput: l1StandardBridgeProxy not set\\\");\\n return _l1StandardBridgeProxy;\\n }\\n}\\n\\ncontract FetchChainInfoOutput {\\n // contract addresses\\n // - SuperchainContracts\\n address internal _superchainConfigProxy;\\n // - ImplementationsContracts\\n address internal _mipsImpl;\\n address internal _preimageOracleImpl;\\n // - OpChainContracts\\n address internal _addressManagerImpl;\\n address internal _ethLockboxProxy;\\n address internal _l1CrossDomainMessengerProxy;\\n address internal _l1Erc721BridgeProxy;\\n address internal _l1StandardBridgeProxy;\\n address internal _l2OutputOracleProxy;\\n address internal _optimismMintableErc20FactoryProxy;\\n address internal _optimismPortalProxy;\\n address internal _systemConfigProxy;\\n address internal _opChainProxyAdminImpl;\\n address internal _anchorStateRegistryProxy;\\n address internal _delayedWethPermissionedGameProxy;\\n address internal _delayedWethPermissionlessGameProxy;\\n address internal _disputeGameFactoryProxy;\\n address internal _faultDisputeGameImpl;\\n address internal _permissionedDisputeGameImpl;\\n\\n // roles\\n address internal _systemConfigOwner;\\n address internal _opChainProxyAdminOwner;\\n address internal _opChainGuardian;\\n address internal _challenger;\\n address internal _proposer;\\n address internal _unsafeBlockSigner;\\n address internal _batchSubmitter;\\n\\n // fault proof status\\n bool internal _permissioned;\\n bool internal _permissionless;\\n GameType internal _respectedGameType;\\n\\n function set(bytes4 _sel, address _addr) public {\\n // SuperchainContracts\\n if (_sel == this.superchainConfigProxy.selector) _superchainConfigProxy = _addr;\\n // - ImplementationsContracts\\n else if (_sel == this.mipsImpl.selector) _mipsImpl = _addr;\\n else if (_sel == this.preimageOracleImpl.selector) _preimageOracleImpl = _addr;\\n // - OpChainContracts\\n else if (_sel == this.addressManagerImpl.selector) _addressManagerImpl = _addr;\\n else if (_sel == this.ethLockboxProxy.selector) _ethLockboxProxy = _addr;\\n else if (_sel == this.l1CrossDomainMessengerProxy.selector) _l1CrossDomainMessengerProxy = _addr;\\n else if (_sel == this.l1Erc721BridgeProxy.selector) _l1Erc721BridgeProxy = _addr;\\n else if (_sel == this.l1StandardBridgeProxy.selector) _l1StandardBridgeProxy = _addr;\\n else if (_sel == this.l2OutputOracleProxy.selector) _l2OutputOracleProxy = _addr;\\n else if (_sel == this.optimismMintableErc20FactoryProxy.selector) _optimismMintableErc20FactoryProxy = _addr;\\n else if (_sel == this.optimismPortalProxy.selector) _optimismPortalProxy = _addr;\\n else if (_sel == this.systemConfigProxy.selector) _systemConfigProxy = _addr;\\n else if (_sel == this.opChainProxyAdminImpl.selector) _opChainProxyAdminImpl = _addr;\\n else if (_sel == this.anchorStateRegistryProxy.selector) _anchorStateRegistryProxy = _addr;\\n else if (_sel == this.delayedWethPermissionedGameProxy.selector) _delayedWethPermissionedGameProxy = _addr;\\n else if (_sel == this.delayedWethPermissionlessGameProxy.selector) _delayedWethPermissionlessGameProxy = _addr;\\n else if (_sel == this.disputeGameFactoryProxy.selector) _disputeGameFactoryProxy = _addr;\\n else if (_sel == this.faultDisputeGameImpl.selector) _faultDisputeGameImpl = _addr;\\n else if (_sel == this.permissionedDisputeGameImpl.selector) _permissionedDisputeGameImpl = _addr;\\n // roles\\n else if (_sel == this.systemConfigOwner.selector) _systemConfigOwner = _addr;\\n else if (_sel == this.opChainProxyAdminOwner.selector) _opChainProxyAdminOwner = _addr;\\n else if (_sel == this.opChainGuardian.selector) _opChainGuardian = _addr;\\n else if (_sel == this.challenger.selector) _challenger = _addr;\\n else if (_sel == this.proposer.selector) _proposer = _addr;\\n else if (_sel == this.unsafeBlockSigner.selector) _unsafeBlockSigner = _addr;\\n else if (_sel == this.batchSubmitter.selector) _batchSubmitter = _addr;\\n else revert(\\\"FetchChainInfoOutput: unknown address selector test\\\");\\n }\\n\\n function set(bytes4 _sel, bool _bool) public {\\n if (_sel == this.permissioned.selector) _permissioned = _bool;\\n else if (_sel == this.permissionless.selector) _permissionless = _bool;\\n else revert(\\\"FetchChainInfoOutput: unknown bool selector\\\");\\n }\\n\\n function set(bytes4 _sel, GameType _gameType) public {\\n if (_sel == this.respectedGameType.selector) _respectedGameType = _gameType;\\n else revert(\\\"FetchChainInfoOutput: unknown GameType selector\\\");\\n }\\n\\n function addressManagerImpl() public view returns (address) {\\n require(_addressManagerImpl != address(0), \\\"FetchChainInfoOutput: addressManagerImpl not set\\\");\\n return _addressManagerImpl;\\n }\\n\\n function ethLockboxProxy() public view returns (address) {\\n return _ethLockboxProxy;\\n }\\n\\n function l1CrossDomainMessengerProxy() public view returns (address) {\\n require(_l1CrossDomainMessengerProxy != address(0), \\\"FetchChainInfoOutput: l1CrossDomainMessengerProxy not set\\\");\\n return _l1CrossDomainMessengerProxy;\\n }\\n\\n function l1Erc721BridgeProxy() public view returns (address) {\\n require(_l1Erc721BridgeProxy != address(0), \\\"FetchChainInfoOutput: l1Erc721BridgeProxy not set\\\");\\n return _l1Erc721BridgeProxy;\\n }\\n\\n function l1StandardBridgeProxy() public view returns (address) {\\n require(_l1StandardBridgeProxy != address(0), \\\"FetchChainInfoOutput: l1StandardBridgeProxy not set\\\");\\n return _l1StandardBridgeProxy;\\n }\\n\\n function l2OutputOracleProxy() public view returns (address) {\\n require(_l2OutputOracleProxy != address(0), \\\"FetchChainInfoOutput: l2OutputOracleProxy not set\\\");\\n return _l2OutputOracleProxy;\\n }\\n\\n function optimismMintableErc20FactoryProxy() public view returns (address) {\\n require(\\n _optimismMintableErc20FactoryProxy != address(0),\\n \\\"FetchChainInfoOutput: optimismMintableErc20FactoryProxy not set\\\"\\n );\\n return _optimismMintableErc20FactoryProxy;\\n }\\n\\n function optimismPortalProxy() public view returns (address) {\\n require(_optimismPortalProxy != address(0), \\\"FetchChainInfoOutput: optimismPortalProxy not set\\\");\\n return _optimismPortalProxy;\\n }\\n\\n function systemConfigProxy() public view returns (address) {\\n require(_systemConfigProxy != address(0), \\\"FetchChainInfoOutput: systemConfigProxy not set\\\");\\n return _systemConfigProxy;\\n }\\n\\n function opChainProxyAdminImpl() public view returns (address) {\\n require(_opChainProxyAdminImpl != address(0), \\\"FetchChainInfoOutput: opChainProxyAdminImpl not set\\\");\\n return _opChainProxyAdminImpl;\\n }\\n\\n function superchainConfigProxy() public view returns (address) {\\n require(_superchainConfigProxy != address(0), \\\"FetchChainInfoOutput: superchainConfigProxy not set\\\");\\n return _superchainConfigProxy;\\n }\\n\\n function anchorStateRegistryProxy() public view returns (address) {\\n require(_anchorStateRegistryProxy != address(0), \\\"FetchChainInfoOutput: anchorStateRegistryProxy not set\\\");\\n return _anchorStateRegistryProxy;\\n }\\n\\n function delayedWethPermissionedGameProxy() public view returns (address) {\\n return _delayedWethPermissionedGameProxy;\\n }\\n\\n function delayedWethPermissionlessGameProxy() public view returns (address) {\\n return _delayedWethPermissionlessGameProxy;\\n }\\n\\n function disputeGameFactoryProxy() public view returns (address) {\\n return _disputeGameFactoryProxy;\\n }\\n\\n function faultDisputeGameImpl() public view returns (address) {\\n require(_faultDisputeGameImpl != address(0), \\\"FetchChainInfoOutput: faultDisputeGameImpl not set\\\");\\n return _faultDisputeGameImpl;\\n }\\n\\n function mipsImpl() public view returns (address) {\\n require(_mipsImpl != address(0), \\\"FetchChainInfoOutput: mipsImpl not set\\\");\\n return _mipsImpl;\\n }\\n\\n function permissionedDisputeGameImpl() public view returns (address) {\\n require(_permissionedDisputeGameImpl != address(0), \\\"FetchChainInfoOutput: permissionedDisputeGameImpl not set\\\");\\n return _permissionedDisputeGameImpl;\\n }\\n\\n function preimageOracleImpl() public view returns (address) {\\n require(_preimageOracleImpl != address(0), \\\"FetchChainInfoOutput: preimageOracleImpl not set\\\");\\n return _preimageOracleImpl;\\n }\\n\\n function systemConfigOwner() public view returns (address) {\\n require(_systemConfigOwner != address(0), \\\"FetchChainInfoOutput: systemConfigOwner not set\\\");\\n return _systemConfigOwner;\\n }\\n\\n function opChainProxyAdminOwner() public view returns (address) {\\n require(_opChainProxyAdminOwner != address(0), \\\"FetchChainInfoOutput: opChainProxyAdminOwner not set\\\");\\n return _opChainProxyAdminOwner;\\n }\\n\\n function opChainGuardian() public view returns (address) {\\n require(_opChainGuardian != address(0), \\\"FetchChainInfoOutput: opChainGuardian not set\\\");\\n return _opChainGuardian;\\n }\\n\\n function challenger() public view returns (address) {\\n require(_challenger != address(0), \\\"FetchChainInfoOutput: challenger not set\\\");\\n return _challenger;\\n }\\n\\n function proposer() public view returns (address) {\\n require(_proposer != address(0), \\\"FetchChainInfoOutput: proposer not set\\\");\\n return _proposer;\\n }\\n\\n function unsafeBlockSigner() public view returns (address) {\\n require(_unsafeBlockSigner != address(0), \\\"FetchChainInfoOutput: unsafeBlockSigner not set\\\");\\n return _unsafeBlockSigner;\\n }\\n\\n function batchSubmitter() public view returns (address) {\\n require(_batchSubmitter != address(0), \\\"FetchChainInfoOutput: batchSubmitter not set\\\");\\n return _batchSubmitter;\\n }\\n\\n function permissioned() public view returns (bool) {\\n return _permissioned;\\n }\\n\\n function permissionless() public view returns (bool) {\\n return _permissionless;\\n }\\n\\n function respectedGameType() public view returns (GameType) {\\n return _respectedGameType;\\n }\\n}\\n\\ncontract FetchChainInfo is Script {\\n function run(FetchChainInfoInput _fi, FetchChainInfoOutput _fo) public {\\n _processSystemConfig(_fi, _fo);\\n _processMessengerAndPortal(_fi, _fo);\\n _processFaultProofs(_fo);\\n }\\n\\n function _processSystemConfig(FetchChainInfoInput _fi, FetchChainInfoOutput _fo) internal {\\n address systemConfigProxy = _fi.systemConfigProxy();\\n _fo.set(_fo.systemConfigProxy.selector, systemConfigProxy);\\n\\n address systemConfigOwner = IFetcher(systemConfigProxy).owner();\\n _fo.set(_fo.systemConfigOwner.selector, systemConfigOwner);\\n\\n address unsafeBlockSigner = IFetcher(systemConfigProxy).unsafeBlockSigner();\\n _fo.set(_fo.unsafeBlockSigner.selector, unsafeBlockSigner);\\n\\n address batchSubmitter = _getBatchSubmitter(systemConfigProxy);\\n _fo.set(_fo.batchSubmitter.selector, batchSubmitter);\\n\\n address opChainProxyAdminImpl = _getProxyAdmin(systemConfigProxy);\\n _fo.set(_fo.opChainProxyAdminImpl.selector, opChainProxyAdminImpl);\\n\\n address opChainProxyAdminOwner = IFetcher(opChainProxyAdminImpl).owner();\\n _fo.set(_fo.opChainProxyAdminOwner.selector, opChainProxyAdminOwner);\\n\\n address l1Erc721BridgeProxy = _getL1ERC721BridgeProxy(systemConfigProxy);\\n _fo.set(_fo.l1Erc721BridgeProxy.selector, l1Erc721BridgeProxy);\\n\\n address optimismMintableErc20FactoryProxy = _getOptimismMintableERC20FactoryProxy(systemConfigProxy);\\n _fo.set(_fo.optimismMintableErc20FactoryProxy.selector, optimismMintableErc20FactoryProxy);\\n }\\n\\n function _processMessengerAndPortal(FetchChainInfoInput _fi, FetchChainInfoOutput _fo) internal {\\n address l1StandardBridgeProxy = _fi.l1StandardBridgeProxy();\\n _fo.set(_fo.l1StandardBridgeProxy.selector, l1StandardBridgeProxy);\\n\\n address l1CrossDomainMessengerProxy = IFetcher(l1StandardBridgeProxy).messenger();\\n _fo.set(_fo.l1CrossDomainMessengerProxy.selector, l1CrossDomainMessengerProxy);\\n\\n address addressManagerImpl = _getAddressManager(l1CrossDomainMessengerProxy);\\n _fo.set(_fo.addressManagerImpl.selector, addressManagerImpl);\\n\\n address optimismPortalProxy = _getOptimismPortalProxy(l1CrossDomainMessengerProxy);\\n _fo.set(_fo.optimismPortalProxy.selector, optimismPortalProxy);\\n\\n address opChainGuardian = _getGuardian(optimismPortalProxy);\\n _fo.set(_fo.opChainGuardian.selector, opChainGuardian);\\n\\n address ethLockboxProxy = _getEthLockboxProxy(optimismPortalProxy);\\n _fo.set(_fo.ethLockboxProxy.selector, ethLockboxProxy);\\n\\n address superchainConfigProxy = _getSuperchainConfigProxy(optimismPortalProxy);\\n _fo.set(_fo.superchainConfigProxy.selector, superchainConfigProxy);\\n }\\n\\n function _processFaultProofs(FetchChainInfoOutput _fo) internal {\\n address systemConfigProxy = _fo.systemConfigProxy();\\n address optimismPortalProxy = _fo.optimismPortalProxy();\\n\\n try IFetcher(optimismPortalProxy).respectedGameType() returns (GameType gameType_) {\\n _fo.set(_fo.respectedGameType.selector, gameType_);\\n } catch {\\n // default respectedGameType to uint32.max since 0 == CANNON\\n _fo.set(_fo.respectedGameType.selector, GameType.wrap(type(uint32).max));\\n address l2OutputOracleProxy;\\n try IFetcher(optimismPortalProxy).l2Oracle() returns (address l2Oracle_) {\\n l2OutputOracleProxy = l2Oracle_;\\n } catch {\\n l2OutputOracleProxy = IFetcher(optimismPortalProxy).L2_ORACLE();\\n }\\n _fo.set(_fo.l2OutputOracleProxy.selector, l2OutputOracleProxy);\\n\\n address proposer = IFetcher(l2OutputOracleProxy).PROPOSER();\\n _fo.set(_fo.proposer.selector, proposer);\\n\\n // no fault proofs installed so we're done\\n return;\\n }\\n\\n address disputeGameFactoryProxy = _getDisputeGameFactoryProxy(systemConfigProxy);\\n if (disputeGameFactoryProxy != address(0)) {\\n _fo.set(_fo.disputeGameFactoryProxy.selector, disputeGameFactoryProxy);\\n\\n address permissionedDisputeGameImpl = _getPermissionedDisputeGame(disputeGameFactoryProxy);\\n if (permissionedDisputeGameImpl != address(0)) {\\n // permissioned fault proofs installed\\n _fo.set(_fo.permissioned.selector, true);\\n _fo.set(_fo.permissionedDisputeGameImpl.selector, permissionedDisputeGameImpl);\\n\\n address challenger = IFetcher(permissionedDisputeGameImpl).challenger();\\n _fo.set(_fo.challenger.selector, challenger);\\n\\n address anchorStateRegistryProxy = IFetcher(permissionedDisputeGameImpl).anchorStateRegistry();\\n _fo.set(_fo.anchorStateRegistryProxy.selector, anchorStateRegistryProxy);\\n\\n address proposer = IFetcher(permissionedDisputeGameImpl).proposer();\\n _fo.set(_fo.proposer.selector, proposer);\\n\\n address delayedWethPermissionedGameProxy = _getDelayedWETHProxy(permissionedDisputeGameImpl);\\n _fo.set(_fo.delayedWethPermissionedGameProxy.selector, delayedWethPermissionedGameProxy);\\n\\n address mipsImpl = IFetcher(permissionedDisputeGameImpl).vm();\\n _fo.set(_fo.mipsImpl.selector, mipsImpl);\\n\\n address preimageOracleImpl = IFetcher(mipsImpl).oracle();\\n _fo.set(_fo.preimageOracleImpl.selector, preimageOracleImpl);\\n }\\n\\n address faultDisputeGameImpl = _getFaultDisputeGame(disputeGameFactoryProxy);\\n if (faultDisputeGameImpl != address(0)) {\\n // permissionless fault proofs installed\\n _fo.set(_fo.faultDisputeGameImpl.selector, faultDisputeGameImpl);\\n _fo.set(_fo.permissionless.selector, true);\\n\\n address delayedWethPermissionlessGameProxy = _getDelayedWETHProxy(faultDisputeGameImpl);\\n _fo.set(_fo.delayedWethPermissionlessGameProxy.selector, delayedWethPermissionlessGameProxy);\\n }\\n } else {\\n // some older chains have L2OutputOracle instead of DisputeGameFactory.\\n address l2OutputOracleProxy = IFetcher(optimismPortalProxy).L2_ORACLE();\\n _fo.set(_fo.l2OutputOracleProxy.selector, l2OutputOracleProxy);\\n address proposer = IFetcher(l2OutputOracleProxy).PROPOSER();\\n _fo.set(_fo.proposer.selector, proposer);\\n }\\n }\\n\\n function _getGuardian(address _portal) internal view returns (address) {\\n try IFetcher(_portal).guardian() returns (address guardian_) {\\n return guardian_;\\n } catch {\\n return IFetcher(_portal).GUARDIAN();\\n }\\n }\\n\\n function _getSystemConfigProxy(address _portal) internal view returns (address) {\\n try IFetcher(_portal).systemConfig() returns (address systemConfig_) {\\n return systemConfig_;\\n } catch {\\n return IFetcher(_portal).SYSTEM_CONFIG();\\n }\\n }\\n\\n function _getOptimismPortalProxy(address _l1CrossDomainMessengerProxy) internal view returns (address) {\\n try IFetcher(_l1CrossDomainMessengerProxy).portal() returns (address optimismPortal_) {\\n return optimismPortal_;\\n } catch {\\n return IFetcher(_l1CrossDomainMessengerProxy).PORTAL();\\n }\\n }\\n\\n function _getAddressManager(address _l1CrossDomainMessengerProxy) internal view returns (address) {\\n uint256 ADDRESS_MANAGER_MAPPING_SLOT = 1;\\n bytes32 slot = keccak256(abi.encode(_l1CrossDomainMessengerProxy, ADDRESS_MANAGER_MAPPING_SLOT));\\n return address(uint160(uint256((vm.load(_l1CrossDomainMessengerProxy, slot)))));\\n }\\n\\n function _getL1ERC721BridgeProxy(address _systemConfigProxy) internal view returns (address) {\\n try IFetcher(_systemConfigProxy).l1ERC721Bridge() returns (address l1ERC721BridgeProxy_) {\\n return l1ERC721BridgeProxy_;\\n } catch {\\n return address(0);\\n }\\n }\\n\\n function _getOptimismMintableERC20FactoryProxy(address _systemConfigProxy) internal view returns (address) {\\n try IFetcher(_systemConfigProxy).optimismMintableERC20Factory() returns (\\n address optimismMintableERC20FactoryProxy_\\n ) {\\n return optimismMintableERC20FactoryProxy_;\\n } catch {\\n return address(0);\\n }\\n }\\n\\n function _getDisputeGameFactoryProxy(address _systemConfigProxy) internal view returns (address) {\\n try IFetcher(_systemConfigProxy).disputeGameFactory() returns (address disputeGameFactoryProxy_) {\\n return disputeGameFactoryProxy_;\\n } catch {\\n // Some older chains have L2OutputOracle instead of DisputeGameFactory\\n return address(0);\\n }\\n }\\n\\n function _getSuperchainConfigProxy(address _optimismPortalProxy) internal view returns (address) {\\n try IFetcher(_optimismPortalProxy).superchainConfig() returns (address superchainConfigProxy_) {\\n return superchainConfigProxy_;\\n } catch {\\n return address(0);\\n }\\n }\\n\\n function _getFaultDisputeGame(address _disputeGameFactoryProxy) internal view returns (address) {\\n try IFetcher(_disputeGameFactoryProxy).gameImpls(GameTypes.CANNON) returns (address faultDisputeGame_) {\\n return faultDisputeGame_;\\n } catch {\\n return address(0);\\n }\\n }\\n\\n function _getPermissionedDisputeGame(address _disputeGameFactoryProxy) internal view returns (address) {\\n try IFetcher(_disputeGameFactoryProxy).gameImpls(GameTypes.PERMISSIONED_CANNON) returns (\\n address permissionedDisputeGame_\\n ) {\\n return permissionedDisputeGame_;\\n } catch {\\n return address(0);\\n }\\n }\\n\\n function _getEthLockboxProxy(address _optimismPortalProxy) internal view returns (address) {\\n try IFetcher(_optimismPortalProxy).ethLockbox() returns (address ethLockbox_) {\\n return ethLockbox_;\\n } catch {\\n return address(0);\\n }\\n }\\n\\n function _getDelayedWETHProxy(address _disputeGame) internal view returns (address) {\\n (bool ok, bytes memory data) = address(_disputeGame).staticcall(abi.encodeCall(IFetcher.weth, ()));\\n if (ok && data.length == 32) return abi.decode(data, (address));\\n else return address(0);\\n }\\n\\n function _getBatchSubmitter(address _systemConfigProxy) internal view returns (address) {\\n bytes32 batcherHash = IFetcher(_systemConfigProxy).batcherHash();\\n return address(uint160(uint256(batcherHash)));\\n }\\n\\n function _getProxyAdmin(address _systemConfigProxy) internal returns (address) {\\n vm.prank(address(0));\\n return IFetcher(_systemConfigProxy).admin();\\n }\\n}\\n\",\"keccak256\":\"0x202fb27a5a78b7d8c96c3a4ea69981dc4eeda765aa2747699ac80b8499feb709\",\"license\":\"MIT\"},\"src/dispute/lib/LibPosition.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.15;\\n\\nusing LibPosition for Position global;\\n\\n/// @notice A `Position` represents a position of a claim within the game tree.\\n/// @dev This is represented as a \\\"generalized index\\\" where the high-order bit\\n/// is the level in the tree and the remaining bits is a unique bit pattern, allowing\\n/// a unique identifier for each node in the tree. Mathematically, it is calculated\\n/// as 2^{depth} + indexAtDepth.\\ntype Position is uint128;\\n\\n/// @title LibPosition\\n/// @notice This library contains helper functions for working with the `Position` type.\\nlibrary LibPosition {\\n /// @notice the `MAX_POSITION_BITLEN` is the number of bits that the `Position` type, and the implementation of\\n /// its behavior within this library, can safely support.\\n uint8 internal constant MAX_POSITION_BITLEN = 126;\\n\\n /// @notice Computes a generalized index (2^{depth} + indexAtDepth).\\n /// @param _depth The depth of the position.\\n /// @param _indexAtDepth The index at the depth of the position.\\n /// @return position_ The computed generalized index.\\n function wrap(uint8 _depth, uint128 _indexAtDepth) internal pure returns (Position position_) {\\n assembly {\\n // gindex = 2^{_depth} + _indexAtDepth\\n position_ := add(shl(_depth, 1), _indexAtDepth)\\n }\\n }\\n\\n /// @notice Pulls the `depth` out of a `Position` type.\\n /// @param _position The generalized index to get the `depth` of.\\n /// @return depth_ The `depth` of the `position` gindex.\\n /// @custom:attribution Solady \\n function depth(Position _position) internal pure returns (uint8 depth_) {\\n // Return the most significant bit offset, which signifies the depth of the gindex.\\n assembly {\\n depth_ := or(depth_, shl(6, lt(0xffffffffffffffff, shr(depth_, _position))))\\n depth_ := or(depth_, shl(5, lt(0xffffffff, shr(depth_, _position))))\\n\\n // For the remaining 32 bits, use a De Bruijn lookup.\\n _position := shr(depth_, _position)\\n _position := or(_position, shr(1, _position))\\n _position := or(_position, shr(2, _position))\\n _position := or(_position, shr(4, _position))\\n _position := or(_position, shr(8, _position))\\n _position := or(_position, shr(16, _position))\\n\\n depth_ :=\\n or(\\n depth_,\\n byte(\\n shr(251, mul(_position, shl(224, 0x07c4acdd))),\\n 0x0009010a0d15021d0b0e10121619031e080c141c0f111807131b17061a05041f\\n )\\n )\\n }\\n }\\n\\n /// @notice Pulls the `indexAtDepth` out of a `Position` type.\\n /// The `indexAtDepth` is the left/right index of a position at a specific depth within\\n /// the binary tree, starting from index 0. For example, at gindex 2, the `depth` = 1\\n /// and the `indexAtDepth` = 0.\\n /// @param _position The generalized index to get the `indexAtDepth` of.\\n /// @return indexAtDepth_ The `indexAtDepth` of the `position` gindex.\\n function indexAtDepth(Position _position) internal pure returns (uint128 indexAtDepth_) {\\n // Return bits p_{msb-1}...p_{0}. This effectively pulls the 2^{depth} out of the gindex,\\n // leaving only the `indexAtDepth`.\\n uint256 msb = depth(_position);\\n assembly {\\n indexAtDepth_ := sub(_position, shl(msb, 1))\\n }\\n }\\n\\n /// @notice Get the left child of `_position`.\\n /// @param _position The position to get the left position of.\\n /// @return left_ The position to the left of `position`.\\n function left(Position _position) internal pure returns (Position left_) {\\n assembly {\\n left_ := shl(1, _position)\\n }\\n }\\n\\n /// @notice Get the right child of `_position`\\n /// @param _position The position to get the right position of.\\n /// @return right_ The position to the right of `position`.\\n function right(Position _position) internal pure returns (Position right_) {\\n assembly {\\n right_ := or(1, shl(1, _position))\\n }\\n }\\n\\n /// @notice Get the parent position of `_position`.\\n /// @param _position The position to get the parent position of.\\n /// @return parent_ The parent position of `position`.\\n function parent(Position _position) internal pure returns (Position parent_) {\\n assembly {\\n parent_ := shr(1, _position)\\n }\\n }\\n\\n /// @notice Get the deepest, right most gindex relative to the `position`. This is equivalent to\\n /// calling `right` on a position until the maximum depth is reached.\\n /// @param _position The position to get the relative deepest, right most gindex of.\\n /// @param _maxDepth The maximum depth of the game.\\n /// @return rightIndex_ The deepest, right most gindex relative to the `position`.\\n function rightIndex(Position _position, uint256 _maxDepth) internal pure returns (Position rightIndex_) {\\n uint256 msb = depth(_position);\\n assembly {\\n let remaining := sub(_maxDepth, msb)\\n rightIndex_ := or(shl(remaining, _position), sub(shl(remaining, 1), 1))\\n }\\n }\\n\\n /// @notice Get the deepest, right most trace index relative to the `position`. This is\\n /// equivalent to calling `right` on a position until the maximum depth is reached and\\n /// then finding its index at depth.\\n /// @param _position The position to get the relative trace index of.\\n /// @param _maxDepth The maximum depth of the game.\\n /// @return traceIndex_ The trace index relative to the `position`.\\n function traceIndex(Position _position, uint256 _maxDepth) internal pure returns (uint256 traceIndex_) {\\n uint256 msb = depth(_position);\\n assembly {\\n let remaining := sub(_maxDepth, msb)\\n traceIndex_ := sub(or(shl(remaining, _position), sub(shl(remaining, 1), 1)), shl(_maxDepth, 1))\\n }\\n }\\n\\n /// @notice Gets the position of the highest ancestor of `_position` that commits to the same\\n /// trace index.\\n /// @param _position The position to get the highest ancestor of.\\n /// @return ancestor_ The highest ancestor of `position` that commits to the same trace index.\\n function traceAncestor(Position _position) internal pure returns (Position ancestor_) {\\n // Create a field with only the lowest unset bit of `_position` set.\\n Position lsb;\\n assembly {\\n lsb := and(not(_position), add(_position, 1))\\n }\\n // Find the index of the lowest unset bit within the field.\\n uint256 msb = depth(lsb);\\n // The highest ancestor that commits to the same trace index is the original position\\n // shifted right by the index of the lowest unset bit.\\n assembly {\\n let a := shr(msb, _position)\\n // Bound the ancestor to the minimum gindex, 1.\\n ancestor_ := or(a, iszero(a))\\n }\\n }\\n\\n /// @notice Gets the position of the highest ancestor of `_position` that commits to the same\\n /// trace index, while still being below `_upperBoundExclusive`.\\n /// @param _position The position to get the highest ancestor of.\\n /// @param _upperBoundExclusive The exclusive upper depth bound, used to inform where to stop in order\\n /// to not escape a sub-tree.\\n /// @return ancestor_ The highest ancestor of `position` that commits to the same trace index.\\n function traceAncestorBounded(\\n Position _position,\\n uint256 _upperBoundExclusive\\n )\\n internal\\n pure\\n returns (Position ancestor_)\\n {\\n // This function only works for positions that are below the upper bound.\\n if (_position.depth() <= _upperBoundExclusive) {\\n assembly {\\n // Revert with `ClaimAboveSplit()`\\n mstore(0x00, 0xb34b5c22)\\n revert(0x1C, 0x04)\\n }\\n }\\n\\n // Grab the global trace ancestor.\\n ancestor_ = traceAncestor(_position);\\n\\n // If the ancestor is above or at the upper bound, shift it to be below the upper bound.\\n // This should be a special case that only covers positions that commit to the final leaf\\n // in a sub-tree.\\n if (ancestor_.depth() <= _upperBoundExclusive) {\\n ancestor_ = ancestor_.rightIndex(_upperBoundExclusive + 1);\\n }\\n }\\n\\n /// @notice Get the move position of `_position`, which is the left child of:\\n /// 1. `_position` if `_isAttack` is true.\\n /// 2. `_position | 1` if `_isAttack` is false.\\n /// @param _position The position to get the relative attack/defense position of.\\n /// @param _isAttack Whether or not the move is an attack move.\\n /// @return move_ The move position relative to `position`.\\n function move(Position _position, bool _isAttack) internal pure returns (Position move_) {\\n assembly {\\n move_ := shl(1, or(iszero(_isAttack), _position))\\n }\\n }\\n\\n /// @notice Get the value of a `Position` type in the form of the underlying uint128.\\n /// @param _position The position to get the value of.\\n /// @return raw_ The value of the `position` as a uint128 type.\\n function raw(Position _position) internal pure returns (uint128 raw_) {\\n assembly {\\n raw_ := _position\\n }\\n }\\n}\\n\",\"keccak256\":\"0x7c5f19f8f54f06de2ce1c6cdcc5c7af65ac405130a4066cdaf146ca315818241\",\"license\":\"MIT\"},\"src/dispute/lib/LibUDT.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.15;\\n\\n// Libraries\\nimport { Position } from \\\"src/dispute/lib/LibPosition.sol\\\";\\n\\nusing LibClaim for Claim global;\\nusing LibHash for Hash global;\\nusing LibDuration for Duration global;\\nusing LibClock for Clock global;\\nusing LibGameId for GameId global;\\nusing LibTimestamp for Timestamp global;\\nusing LibVMStatus for VMStatus global;\\nusing LibGameType for GameType global;\\n\\n/// @notice A `Clock` represents a packed `Duration` and `Timestamp`\\n/// @dev The packed layout of this type is as follows:\\n/// \\u250c\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u252c\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2510\\n/// \\u2502 Bits \\u2502 Value \\u2502\\n/// \\u251c\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u253c\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2524\\n/// \\u2502 [0, 64) \\u2502 Duration \\u2502\\n/// \\u2502 [64, 128) \\u2502 Timestamp \\u2502\\n/// \\u2514\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2534\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2518\\ntype Clock is uint128;\\n\\n/// @title LibClock\\n/// @notice This library contains helper functions for working with the `Clock` type.\\nlibrary LibClock {\\n /// @notice Packs a `Duration` and `Timestamp` into a `Clock` type.\\n /// @param _duration The `Duration` to pack into the `Clock` type.\\n /// @param _timestamp The `Timestamp` to pack into the `Clock` type.\\n /// @return clock_ The `Clock` containing the `_duration` and `_timestamp`.\\n function wrap(Duration _duration, Timestamp _timestamp) internal pure returns (Clock clock_) {\\n assembly {\\n clock_ := or(shl(0x40, _duration), _timestamp)\\n }\\n }\\n\\n /// @notice Pull the `Duration` out of a `Clock` type.\\n /// @param _clock The `Clock` type to pull the `Duration` out of.\\n /// @return duration_ The `Duration` pulled out of `_clock`.\\n function duration(Clock _clock) internal pure returns (Duration duration_) {\\n // Shift the high-order 64 bits into the low-order 64 bits, leaving only the `duration`.\\n assembly {\\n duration_ := shr(0x40, _clock)\\n }\\n }\\n\\n /// @notice Pull the `Timestamp` out of a `Clock` type.\\n /// @param _clock The `Clock` type to pull the `Timestamp` out of.\\n /// @return timestamp_ The `Timestamp` pulled out of `_clock`.\\n function timestamp(Clock _clock) internal pure returns (Timestamp timestamp_) {\\n // Clean the high-order 192 bits by shifting the clock left and then right again, leaving\\n // only the `timestamp`.\\n assembly {\\n timestamp_ := shr(0xC0, shl(0xC0, _clock))\\n }\\n }\\n\\n /// @notice Get the value of a `Clock` type in the form of the underlying uint128.\\n /// @param _clock The `Clock` type to get the value of.\\n /// @return clock_ The value of the `Clock` type as a uint128 type.\\n function raw(Clock _clock) internal pure returns (uint128 clock_) {\\n assembly {\\n clock_ := _clock\\n }\\n }\\n}\\n\\n/// @notice A `GameId` represents a packed 4 byte game ID, a 8 byte timestamp, and a 20 byte address.\\n/// @dev The packed layout of this type is as follows:\\n/// \\u250c\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u252c\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2510\\n/// \\u2502 Bits \\u2502 Value \\u2502\\n/// \\u251c\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u253c\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2524\\n/// \\u2502 [0, 32) \\u2502 Game Type \\u2502\\n/// \\u2502 [32, 96) \\u2502 Timestamp \\u2502\\n/// \\u2502 [96, 256) \\u2502 Address \\u2502\\n/// \\u2514\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2534\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2518\\ntype GameId is bytes32;\\n\\n/// @title LibGameId\\n/// @notice Utility functions for packing and unpacking GameIds.\\nlibrary LibGameId {\\n /// @notice Packs values into a 32 byte GameId type.\\n /// @param _gameType The game type.\\n /// @param _timestamp The timestamp of the game's creation.\\n /// @param _gameProxy The game proxy address.\\n /// @return gameId_ The packed GameId.\\n function pack(\\n GameType _gameType,\\n Timestamp _timestamp,\\n address _gameProxy\\n )\\n internal\\n pure\\n returns (GameId gameId_)\\n {\\n assembly {\\n gameId_ := or(or(shl(224, _gameType), shl(160, _timestamp)), _gameProxy)\\n }\\n }\\n\\n /// @notice Unpacks values from a 32 byte GameId type.\\n /// @param _gameId The packed GameId.\\n /// @return gameType_ The game type.\\n /// @return timestamp_ The timestamp of the game's creation.\\n /// @return gameProxy_ The game proxy address.\\n function unpack(GameId _gameId)\\n internal\\n pure\\n returns (GameType gameType_, Timestamp timestamp_, address gameProxy_)\\n {\\n assembly {\\n gameType_ := shr(224, _gameId)\\n timestamp_ := and(shr(160, _gameId), 0xFFFFFFFFFFFFFFFF)\\n gameProxy_ := and(_gameId, 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF)\\n }\\n }\\n}\\n\\n/// @notice A claim represents an MPT root representing the state of the fault proof program.\\ntype Claim is bytes32;\\n\\n/// @title LibClaim\\n/// @notice This library contains helper functions for working with the `Claim` type.\\nlibrary LibClaim {\\n /// @notice Get the value of a `Claim` type in the form of the underlying bytes32.\\n /// @param _claim The `Claim` type to get the value of.\\n /// @return claim_ The value of the `Claim` type as a bytes32 type.\\n function raw(Claim _claim) internal pure returns (bytes32 claim_) {\\n assembly {\\n claim_ := _claim\\n }\\n }\\n\\n /// @notice Hashes a claim and a position together.\\n /// @param _claim A Claim type.\\n /// @param _position The position of `claim`.\\n /// @param _challengeIndex The index of the claim being moved against.\\n /// @return claimHash_ A hash of abi.encodePacked(claim, position|challengeIndex);\\n function hashClaimPos(\\n Claim _claim,\\n Position _position,\\n uint256 _challengeIndex\\n )\\n internal\\n pure\\n returns (Hash claimHash_)\\n {\\n assembly {\\n mstore(0x00, _claim)\\n mstore(0x20, or(shl(128, _position), and(0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF, _challengeIndex)))\\n claimHash_ := keccak256(0x00, 0x40)\\n }\\n }\\n}\\n\\n/// @notice A dedicated duration type.\\n/// @dev Unit: seconds\\ntype Duration is uint64;\\n\\n/// @title LibDuration\\n/// @notice This library contains helper functions for working with the `Duration` type.\\nlibrary LibDuration {\\n /// @notice Get the value of a `Duration` type in the form of the underlying uint64.\\n /// @param _duration The `Duration` type to get the value of.\\n /// @return duration_ The value of the `Duration` type as a uint64 type.\\n function raw(Duration _duration) internal pure returns (uint64 duration_) {\\n assembly {\\n duration_ := _duration\\n }\\n }\\n}\\n\\n/// @notice A custom type for a generic hash.\\ntype Hash is bytes32;\\n\\n/// @title LibHash\\n/// @notice This library contains helper functions for working with the `Hash` type.\\nlibrary LibHash {\\n /// @notice Get the value of a `Hash` type in the form of the underlying bytes32.\\n /// @param _hash The `Hash` type to get the value of.\\n /// @return hash_ The value of the `Hash` type as a bytes32 type.\\n function raw(Hash _hash) internal pure returns (bytes32 hash_) {\\n assembly {\\n hash_ := _hash\\n }\\n }\\n}\\n\\n/// @notice A dedicated timestamp type.\\ntype Timestamp is uint64;\\n\\n/// @title LibTimestamp\\n/// @notice This library contains helper functions for working with the `Timestamp` type.\\nlibrary LibTimestamp {\\n /// @notice Get the value of a `Timestamp` type in the form of the underlying uint64.\\n /// @param _timestamp The `Timestamp` type to get the value of.\\n /// @return timestamp_ The value of the `Timestamp` type as a uint64 type.\\n function raw(Timestamp _timestamp) internal pure returns (uint64 timestamp_) {\\n assembly {\\n timestamp_ := _timestamp\\n }\\n }\\n}\\n\\n/// @notice A `VMStatus` represents the status of a VM execution.\\ntype VMStatus is uint8;\\n\\n/// @title LibVMStatus\\n/// @notice This library contains helper functions for working with the `VMStatus` type.\\nlibrary LibVMStatus {\\n /// @notice Get the value of a `VMStatus` type in the form of the underlying uint8.\\n /// @param _vmstatus The `VMStatus` type to get the value of.\\n /// @return vmstatus_ The value of the `VMStatus` type as a uint8 type.\\n function raw(VMStatus _vmstatus) internal pure returns (uint8 vmstatus_) {\\n assembly {\\n vmstatus_ := _vmstatus\\n }\\n }\\n}\\n\\n/// @notice A `GameType` represents the type of game being played.\\ntype GameType is uint32;\\n\\n/// @title LibGameType\\n/// @notice This library contains helper functions for working with the `GameType` type.\\nlibrary LibGameType {\\n /// @notice Get the value of a `GameType` type in the form of the underlying uint32.\\n /// @param _gametype The `GameType` type to get the value of.\\n /// @return gametype_ The value of the `GameType` type as a uint32 type.\\n function raw(GameType _gametype) internal pure returns (uint32 gametype_) {\\n assembly {\\n gametype_ := _gametype\\n }\\n }\\n}\\n\",\"keccak256\":\"0x41d55e9c74d979b5b797198e38449e7cef4f925e04d61f7699e9c150c4a659d3\",\"license\":\"MIT\"},\"src/dispute/lib/Types.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.15;\\n\\n// Libraries\\nimport {\\n Position,\\n Hash,\\n GameType,\\n VMStatus,\\n Timestamp,\\n Duration,\\n Clock,\\n GameId,\\n Claim,\\n LibGameId,\\n LibClock\\n} from \\\"src/dispute/lib/LibUDT.sol\\\";\\n\\n/// @notice The current status of the dispute game.\\nenum GameStatus {\\n // The game is currently in progress, and has not been resolved.\\n IN_PROGRESS,\\n // The game has concluded, and the `rootClaim` was challenged successfully.\\n CHALLENGER_WINS,\\n // The game has concluded, and the `rootClaim` could not be contested.\\n DEFENDER_WINS\\n}\\n\\n/// @notice The game's bond distribution type. Games are expected to start in the `UNDECIDED`\\n/// state, and then choose either `NORMAL` or `REFUND`.\\nenum BondDistributionMode {\\n // Bond distribution strategy has not been chosen.\\n UNDECIDED,\\n // Bonds should be distributed as normal.\\n NORMAL,\\n // Bonds should be refunded to claimants.\\n REFUND\\n}\\n\\n/// @notice Represents an L2 root and the L2 sequence number at which it was generated.\\n/// @custom:field root The output root.\\n/// @custom:field l2SequenceNumber The L2 Sequence Number ( e.g. block number / timestamp) at which the root was\\n/// generated.\\nstruct Proposal {\\n Hash root;\\n uint256 l2SequenceNumber;\\n}\\n\\n/// @title GameTypes\\n/// @notice A library that defines the IDs of games that can be played.\\nlibrary GameTypes {\\n /// @dev A dispute game type the uses the cannon vm.\\n GameType internal constant CANNON = GameType.wrap(0);\\n\\n /// @dev A permissioned dispute game type that uses the cannon vm.\\n GameType internal constant PERMISSIONED_CANNON = GameType.wrap(1);\\n\\n /// @notice A dispute game type that uses the asterisc vm.\\n GameType internal constant ASTERISC = GameType.wrap(2);\\n\\n /// @notice A dispute game type that uses the asterisc vm with Kona.\\n GameType internal constant ASTERISC_KONA = GameType.wrap(3);\\n\\n /// @notice A dispute game type that uses the cannon vm (Super Roots).\\n GameType internal constant SUPER_CANNON = GameType.wrap(4);\\n\\n /// @notice A dispute game type that uses the permissioned cannon vm (Super Roots).\\n GameType internal constant SUPER_PERMISSIONED_CANNON = GameType.wrap(5);\\n\\n /// @notice A dispute game type that uses OP Succinct\\n GameType internal constant OP_SUCCINCT = GameType.wrap(6);\\n\\n /// @notice A dispute game type with short game duration for testing withdrawals.\\n /// Not intended for production use.\\n GameType internal constant FAST = GameType.wrap(254);\\n\\n /// @notice A dispute game type that uses an alphabet vm.\\n /// Not intended for production use.\\n GameType internal constant ALPHABET = GameType.wrap(255);\\n\\n /// @notice A dispute game type that uses RISC Zero's Kailua\\n GameType internal constant KAILUA = GameType.wrap(1337);\\n}\\n\\n/// @title VMStatuses\\n/// @notice Named type aliases for the various valid VM status bytes.\\nlibrary VMStatuses {\\n /// @notice The VM has executed successfully and the outcome is valid.\\n VMStatus internal constant VALID = VMStatus.wrap(0);\\n\\n /// @notice The VM has executed successfully and the outcome is invalid.\\n VMStatus internal constant INVALID = VMStatus.wrap(1);\\n\\n /// @notice The VM has paniced.\\n VMStatus internal constant PANIC = VMStatus.wrap(2);\\n\\n /// @notice The VM execution is still in progress.\\n VMStatus internal constant UNFINISHED = VMStatus.wrap(3);\\n}\\n\\n/// @title LocalPreimageKey\\n/// @notice Named type aliases for local `PreimageOracle` key identifiers.\\nlibrary LocalPreimageKey {\\n /// @notice The identifier for the L1 head hash.\\n uint256 internal constant L1_HEAD_HASH = 0x01;\\n\\n /// @notice The identifier for the starting output root.\\n uint256 internal constant STARTING_OUTPUT_ROOT = 0x02;\\n\\n /// @notice The identifier for the disputed output root.\\n uint256 internal constant DISPUTED_OUTPUT_ROOT = 0x03;\\n\\n /// @notice The identifier for the disputed L2 block number.\\n uint256 internal constant DISPUTED_L2_BLOCK_NUMBER = 0x04;\\n\\n /// @notice The identifier for the chain ID.\\n uint256 internal constant CHAIN_ID = 0x05;\\n}\\n\",\"keccak256\":\"0x7cc2960ea5c5223d81ae2156a966fa0226b70f9666932aca63a0a2a45c9182ae\",\"license\":\"MIT\"}},\"version\":1}","metadata":{"compiler":{"version":"0.8.25+commit.b61c2a91"},"language":"Solidity","output":{"abi":[{"inputs":[],"stateMutability":"view","type":"function","name":"l1StandardBridgeProxy","outputs":[{"internalType":"address","name":"","type":"address"}]},{"inputs":[{"internalType":"bytes4","name":"_sel","type":"bytes4"},{"internalType":"address","name":"_addr","type":"address"}],"stateMutability":"nonpayable","type":"function","name":"set"},{"inputs":[],"stateMutability":"view","type":"function","name":"systemConfigProxy","outputs":[{"internalType":"address","name":"","type":"address"}]}],"devdoc":{"kind":"dev","methods":{},"version":1},"userdoc":{"kind":"user","methods":{},"version":1}},"settings":{"remappings":["@lib-keccak/=lib/lib-keccak/contracts/lib/","@openzeppelin/contracts-upgradeable/=lib/openzeppelin-contracts-upgradeable/contracts/","@openzeppelin/contracts-v5/=lib/openzeppelin-contracts-v5/contracts/","@openzeppelin/contracts/=lib/openzeppelin-contracts/contracts/","@rari-capital/solmate/=lib/solmate/","@solady-test/=lib/lib-keccak/lib/solady/test/","@solady-v0.0.245/=lib/solady-v0.0.245/src/","@solady/=lib/solady/src/","ds-test/=lib/forge-std/lib/ds-test/src/","erc4626-tests/=lib/openzeppelin-contracts-v5/lib/erc4626-tests/","forge-std/=lib/forge-std/src/","interfaces/=interfaces/","kontrol-cheatcodes/=lib/kontrol-cheatcodes/src/","lib-keccak/=lib/lib-keccak/contracts/","openzeppelin-contracts-upgradeable/=lib/openzeppelin-contracts-upgradeable/","openzeppelin-contracts-v5/=lib/openzeppelin-contracts-v5/","openzeppelin-contracts/=lib/openzeppelin-contracts/","safe-contracts/=lib/safe-contracts/contracts/","solady-v0.0.245/=lib/solady-v0.0.245/src/","solady/=lib/solady/","solmate/=lib/solmate/src/"],"optimizer":{"enabled":false,"runs":999999},"metadata":{"useLiteralContent":true,"bytecodeHash":"none"},"compilationTarget":{"scripts/FetchChainInfo.s.sol":"FetchChainInfoInput"},"evmVersion":"cancun","libraries":{}},"sources":{"lib/forge-std/src/Base.sol":{"keccak256":"0xa3735a6618a3014e42bb4329ad143e3b2c59cd95094350202e4c4a06c9d585dd","urls":[],"content":"// SPDX-License-Identifier: MIT\npragma solidity >=0.6.2 <0.9.0;\n\nimport {StdStorage} from \"./StdStorage.sol\";\nimport {Vm, VmSafe} from \"./Vm.sol\";\n\nabstract contract CommonBase {\n /// @dev Cheat code address.\n /// Calculated as `address(uint160(uint256(keccak256(\"hevm cheat code\"))))`.\n address internal constant VM_ADDRESS = 0x7109709ECfa91a80626fF3989D68f67F5b1DD12D;\n /// @dev console.sol and console2.sol work by executing a staticcall to this address.\n /// Calculated as `address(uint160(uint88(bytes11(\"console.log\"))))`.\n address internal constant CONSOLE = 0x000000000000000000636F6e736F6c652e6c6f67;\n /// @dev Used when deploying with create2.\n /// Taken from https://github.com/Arachnid/deterministic-deployment-proxy.\n address internal constant CREATE2_FACTORY = 0x4e59b44847b379578588920cA78FbF26c0B4956C;\n /// @dev The default address for tx.origin and msg.sender.\n /// Calculated as `address(uint160(uint256(keccak256(\"foundry default caller\"))))`.\n address internal constant DEFAULT_SENDER = 0x1804c8AB1F12E6bbf3894d4083f33e07309d1f38;\n /// @dev The address of the first contract `CREATE`d by a running test contract.\n /// When running tests, each test contract is `CREATE`d by `DEFAULT_SENDER` with nonce 1.\n /// Calculated as `VM.computeCreateAddress(VM.computeCreateAddress(DEFAULT_SENDER, 1), 1)`.\n address internal constant DEFAULT_TEST_CONTRACT = 0x5615dEB798BB3E4dFa0139dFa1b3D433Cc23b72f;\n /// @dev Deterministic deployment address of the Multicall3 contract.\n /// Taken from https://www.multicall3.com.\n address internal constant MULTICALL3_ADDRESS = 0xcA11bde05977b3631167028862bE2a173976CA11;\n /// @dev The order of the secp256k1 curve.\n uint256 internal constant SECP256K1_ORDER =\n 115792089237316195423570985008687907852837564279074904382605163141518161494337;\n\n uint256 internal constant UINT256_MAX =\n 115792089237316195423570985008687907853269984665640564039457584007913129639935;\n\n Vm internal constant vm = Vm(VM_ADDRESS);\n StdStorage internal stdstore;\n}\n\nabstract contract TestBase is CommonBase {}\n\nabstract contract ScriptBase is CommonBase {\n VmSafe internal constant vmSafe = VmSafe(VM_ADDRESS);\n}\n","license":"MIT"},"lib/forge-std/src/Script.sol":{"keccak256":"0xc942e27c7baae499beb01afbbae99f24d42af9a6e4aae675bc6901b704aa8e9b","urls":[],"content":"// SPDX-License-Identifier: MIT\npragma solidity >=0.6.2 <0.9.0;\n\n// 💬 ABOUT\n// Forge Std's default Script.\n\n// 🧩 MODULES\nimport {console} from \"./console.sol\";\nimport {console2} from \"./console2.sol\";\nimport {safeconsole} from \"./safeconsole.sol\";\nimport {StdChains} from \"./StdChains.sol\";\nimport {StdCheatsSafe} from \"./StdCheats.sol\";\nimport {StdConstants} from \"./StdConstants.sol\";\nimport {stdJson} from \"./StdJson.sol\";\nimport {stdMath} from \"./StdMath.sol\";\nimport {StdStorage, stdStorageSafe} from \"./StdStorage.sol\";\nimport {StdStyle} from \"./StdStyle.sol\";\nimport {StdUtils} from \"./StdUtils.sol\";\nimport {VmSafe} from \"./Vm.sol\";\n\n// 📦 BOILERPLATE\nimport {ScriptBase} from \"./Base.sol\";\n\n// ⭐️ SCRIPT\nabstract contract Script is ScriptBase, StdChains, StdCheatsSafe, StdUtils {\n // Note: IS_SCRIPT() must return true.\n bool public IS_SCRIPT = true;\n}\n","license":"MIT"},"lib/forge-std/src/StdChains.sol":{"keccak256":"0x200b597cd01c229633b4a2317846cac7d36d337e2381b4a2e81faac23c2ad1cf","urls":[],"content":"// SPDX-License-Identifier: MIT\npragma solidity >=0.6.2 <0.9.0;\n\nimport {VmSafe} from \"./Vm.sol\";\n\n/**\n * StdChains provides information about EVM compatible chains that can be used in scripts/tests.\n * For each chain, the chain's name, chain ID, and a default RPC URL are provided. Chains are\n * identified by their alias, which is the same as the alias in the `[rpc_endpoints]` section of\n * the `foundry.toml` file. For best UX, ensure the alias in the `foundry.toml` file match the\n * alias used in this contract, which can be found as the first argument to the\n * `setChainWithDefaultRpcUrl` call in the `initializeStdChains` function.\n *\n * There are two main ways to use this contract:\n * 1. Set a chain with `setChain(string memory chainAlias, ChainData memory chain)` or\n * `setChain(string memory chainAlias, Chain memory chain)`\n * 2. Get a chain with `getChain(string memory chainAlias)` or `getChain(uint256 chainId)`.\n *\n * The first time either of those are used, chains are initialized with the default set of RPC URLs.\n * This is done in `initializeStdChains`, which uses `setChainWithDefaultRpcUrl`. Defaults are recorded in\n * `defaultRpcUrls`.\n *\n * The `setChain` function is straightforward, and it simply saves off the given chain data.\n *\n * The `getChain` methods use `getChainWithUpdatedRpcUrl` to return a chain. For example, let's say\n * we want to retrieve the RPC URL for `mainnet`:\n * - If you have specified data with `setChain`, it will return that.\n * - If you have configured a mainnet RPC URL in `foundry.toml`, it will return the URL, provided it\n * is valid (e.g. a URL is specified, or an environment variable is given and exists).\n * - If neither of the above conditions is met, the default data is returned.\n *\n * Summarizing the above, the prioritization hierarchy is `setChain` -> `foundry.toml` -> environment variable -> defaults.\n */\nabstract contract StdChains {\n VmSafe private constant vm = VmSafe(address(uint160(uint256(keccak256(\"hevm cheat code\")))));\n\n bool private stdChainsInitialized;\n\n struct ChainData {\n string name;\n uint256 chainId;\n string rpcUrl;\n }\n\n struct Chain {\n // The chain name.\n string name;\n // The chain's Chain ID.\n uint256 chainId;\n // The chain's alias. (i.e. what gets specified in `foundry.toml`).\n string chainAlias;\n // A default RPC endpoint for this chain.\n // NOTE: This default RPC URL is included for convenience to facilitate quick tests and\n // experimentation. Do not use this RPC URL for production test suites, CI, or other heavy\n // usage as you will be throttled and this is a disservice to others who need this endpoint.\n string rpcUrl;\n }\n\n // Maps from the chain's alias (matching the alias in the `foundry.toml` file) to chain data.\n mapping(string => Chain) private chains;\n // Maps from the chain's alias to it's default RPC URL.\n mapping(string => string) private defaultRpcUrls;\n // Maps from a chain ID to it's alias.\n mapping(uint256 => string) private idToAlias;\n\n bool private fallbackToDefaultRpcUrls = true;\n\n // The RPC URL will be fetched from config or defaultRpcUrls if possible.\n function getChain(string memory chainAlias) internal virtual returns (Chain memory chain) {\n require(bytes(chainAlias).length != 0, \"StdChains getChain(string): Chain alias cannot be the empty string.\");\n\n initializeStdChains();\n chain = chains[chainAlias];\n require(\n chain.chainId != 0,\n string(abi.encodePacked(\"StdChains getChain(string): Chain with alias \\\"\", chainAlias, \"\\\" not found.\"))\n );\n\n chain = getChainWithUpdatedRpcUrl(chainAlias, chain);\n }\n\n function getChain(uint256 chainId) internal virtual returns (Chain memory chain) {\n require(chainId != 0, \"StdChains getChain(uint256): Chain ID cannot be 0.\");\n initializeStdChains();\n string memory chainAlias = idToAlias[chainId];\n\n chain = chains[chainAlias];\n\n require(\n chain.chainId != 0,\n string(abi.encodePacked(\"StdChains getChain(uint256): Chain with ID \", vm.toString(chainId), \" not found.\"))\n );\n\n chain = getChainWithUpdatedRpcUrl(chainAlias, chain);\n }\n\n // set chain info, with priority to argument's rpcUrl field.\n function setChain(string memory chainAlias, ChainData memory chain) internal virtual {\n require(\n bytes(chainAlias).length != 0,\n \"StdChains setChain(string,ChainData): Chain alias cannot be the empty string.\"\n );\n\n require(chain.chainId != 0, \"StdChains setChain(string,ChainData): Chain ID cannot be 0.\");\n\n initializeStdChains();\n string memory foundAlias = idToAlias[chain.chainId];\n\n require(\n bytes(foundAlias).length == 0 || keccak256(bytes(foundAlias)) == keccak256(bytes(chainAlias)),\n string(\n abi.encodePacked(\n \"StdChains setChain(string,ChainData): Chain ID \",\n vm.toString(chain.chainId),\n \" already used by \\\"\",\n foundAlias,\n \"\\\".\"\n )\n )\n );\n\n uint256 oldChainId = chains[chainAlias].chainId;\n delete idToAlias[oldChainId];\n\n chains[chainAlias] =\n Chain({name: chain.name, chainId: chain.chainId, chainAlias: chainAlias, rpcUrl: chain.rpcUrl});\n idToAlias[chain.chainId] = chainAlias;\n }\n\n // set chain info, with priority to argument's rpcUrl field.\n function setChain(string memory chainAlias, Chain memory chain) internal virtual {\n setChain(chainAlias, ChainData({name: chain.name, chainId: chain.chainId, rpcUrl: chain.rpcUrl}));\n }\n\n function _toUpper(string memory str) private pure returns (string memory) {\n bytes memory strb = bytes(str);\n bytes memory copy = new bytes(strb.length);\n for (uint256 i = 0; i < strb.length; i++) {\n bytes1 b = strb[i];\n if (b >= 0x61 && b <= 0x7A) {\n copy[i] = bytes1(uint8(b) - 32);\n } else {\n copy[i] = b;\n }\n }\n return string(copy);\n }\n\n // lookup rpcUrl, in descending order of priority:\n // current -> config (foundry.toml) -> environment variable -> default\n function getChainWithUpdatedRpcUrl(string memory chainAlias, Chain memory chain)\n private\n view\n returns (Chain memory)\n {\n if (bytes(chain.rpcUrl).length == 0) {\n try vm.rpcUrl(chainAlias) returns (string memory configRpcUrl) {\n chain.rpcUrl = configRpcUrl;\n } catch (bytes memory err) {\n string memory envName = string(abi.encodePacked(_toUpper(chainAlias), \"_RPC_URL\"));\n if (fallbackToDefaultRpcUrls) {\n chain.rpcUrl = vm.envOr(envName, defaultRpcUrls[chainAlias]);\n } else {\n chain.rpcUrl = vm.envString(envName);\n }\n // Distinguish 'not found' from 'cannot read'\n // The upstream error thrown by forge for failing cheats changed so we check both the old and new versions\n bytes memory oldNotFoundError =\n abi.encodeWithSignature(\"CheatCodeError\", string(abi.encodePacked(\"invalid rpc url \", chainAlias)));\n bytes memory newNotFoundError = abi.encodeWithSignature(\n \"CheatcodeError(string)\", string(abi.encodePacked(\"invalid rpc url: \", chainAlias))\n );\n bytes32 errHash = keccak256(err);\n if (\n (errHash != keccak256(oldNotFoundError) && errHash != keccak256(newNotFoundError))\n || bytes(chain.rpcUrl).length == 0\n ) {\n /// @solidity memory-safe-assembly\n assembly {\n revert(add(32, err), mload(err))\n }\n }\n }\n }\n return chain;\n }\n\n function setFallbackToDefaultRpcUrls(bool useDefault) internal {\n fallbackToDefaultRpcUrls = useDefault;\n }\n\n function initializeStdChains() private {\n if (stdChainsInitialized) return;\n\n stdChainsInitialized = true;\n\n // If adding an RPC here, make sure to test the default RPC URL in `test_Rpcs` in `StdChains.t.sol`\n setChainWithDefaultRpcUrl(\"anvil\", ChainData(\"Anvil\", 31337, \"http://127.0.0.1:8545\"));\n setChainWithDefaultRpcUrl(\"mainnet\", ChainData(\"Mainnet\", 1, \"https://eth.llamarpc.com\"));\n setChainWithDefaultRpcUrl(\n \"sepolia\", ChainData(\"Sepolia\", 11155111, \"https://sepolia.infura.io/v3/b9794ad1ddf84dfb8c34d6bb5dca2001\")\n );\n setChainWithDefaultRpcUrl(\"holesky\", ChainData(\"Holesky\", 17000, \"https://rpc.holesky.ethpandaops.io\"));\n setChainWithDefaultRpcUrl(\"optimism\", ChainData(\"Optimism\", 10, \"https://mainnet.optimism.io\"));\n setChainWithDefaultRpcUrl(\n \"optimism_sepolia\", ChainData(\"Optimism Sepolia\", 11155420, \"https://sepolia.optimism.io\")\n );\n setChainWithDefaultRpcUrl(\"arbitrum_one\", ChainData(\"Arbitrum One\", 42161, \"https://arb1.arbitrum.io/rpc\"));\n setChainWithDefaultRpcUrl(\n \"arbitrum_one_sepolia\", ChainData(\"Arbitrum One Sepolia\", 421614, \"https://sepolia-rollup.arbitrum.io/rpc\")\n );\n setChainWithDefaultRpcUrl(\"arbitrum_nova\", ChainData(\"Arbitrum Nova\", 42170, \"https://nova.arbitrum.io/rpc\"));\n setChainWithDefaultRpcUrl(\"polygon\", ChainData(\"Polygon\", 137, \"https://polygon-rpc.com\"));\n setChainWithDefaultRpcUrl(\n \"polygon_amoy\", ChainData(\"Polygon Amoy\", 80002, \"https://rpc-amoy.polygon.technology\")\n );\n setChainWithDefaultRpcUrl(\"avalanche\", ChainData(\"Avalanche\", 43114, \"https://api.avax.network/ext/bc/C/rpc\"));\n setChainWithDefaultRpcUrl(\n \"avalanche_fuji\", ChainData(\"Avalanche Fuji\", 43113, \"https://api.avax-test.network/ext/bc/C/rpc\")\n );\n setChainWithDefaultRpcUrl(\n \"bnb_smart_chain\", ChainData(\"BNB Smart Chain\", 56, \"https://bsc-dataseed1.binance.org\")\n );\n setChainWithDefaultRpcUrl(\n \"bnb_smart_chain_testnet\",\n ChainData(\"BNB Smart Chain Testnet\", 97, \"https://rpc.ankr.com/bsc_testnet_chapel\")\n );\n setChainWithDefaultRpcUrl(\"gnosis_chain\", ChainData(\"Gnosis Chain\", 100, \"https://rpc.gnosischain.com\"));\n setChainWithDefaultRpcUrl(\"moonbeam\", ChainData(\"Moonbeam\", 1284, \"https://rpc.api.moonbeam.network\"));\n setChainWithDefaultRpcUrl(\n \"moonriver\", ChainData(\"Moonriver\", 1285, \"https://rpc.api.moonriver.moonbeam.network\")\n );\n setChainWithDefaultRpcUrl(\"moonbase\", ChainData(\"Moonbase\", 1287, \"https://rpc.testnet.moonbeam.network\"));\n setChainWithDefaultRpcUrl(\"base_sepolia\", ChainData(\"Base Sepolia\", 84532, \"https://sepolia.base.org\"));\n setChainWithDefaultRpcUrl(\"base\", ChainData(\"Base\", 8453, \"https://mainnet.base.org\"));\n setChainWithDefaultRpcUrl(\"blast_sepolia\", ChainData(\"Blast Sepolia\", 168587773, \"https://sepolia.blast.io\"));\n setChainWithDefaultRpcUrl(\"blast\", ChainData(\"Blast\", 81457, \"https://rpc.blast.io\"));\n setChainWithDefaultRpcUrl(\"fantom_opera\", ChainData(\"Fantom Opera\", 250, \"https://rpc.ankr.com/fantom/\"));\n setChainWithDefaultRpcUrl(\n \"fantom_opera_testnet\", ChainData(\"Fantom Opera Testnet\", 4002, \"https://rpc.ankr.com/fantom_testnet/\")\n );\n setChainWithDefaultRpcUrl(\"fraxtal\", ChainData(\"Fraxtal\", 252, \"https://rpc.frax.com\"));\n setChainWithDefaultRpcUrl(\"fraxtal_testnet\", ChainData(\"Fraxtal Testnet\", 2522, \"https://rpc.testnet.frax.com\"));\n setChainWithDefaultRpcUrl(\n \"berachain_bartio_testnet\", ChainData(\"Berachain bArtio Testnet\", 80084, \"https://bartio.rpc.berachain.com\")\n );\n setChainWithDefaultRpcUrl(\"flare\", ChainData(\"Flare\", 14, \"https://flare-api.flare.network/ext/C/rpc\"));\n setChainWithDefaultRpcUrl(\n \"flare_coston2\", ChainData(\"Flare Coston2\", 114, \"https://coston2-api.flare.network/ext/C/rpc\")\n );\n\n setChainWithDefaultRpcUrl(\"mode\", ChainData(\"Mode\", 34443, \"https://mode.drpc.org\"));\n setChainWithDefaultRpcUrl(\"mode_sepolia\", ChainData(\"Mode Sepolia\", 919, \"https://sepolia.mode.network\"));\n\n setChainWithDefaultRpcUrl(\"zora\", ChainData(\"Zora\", 7777777, \"https://zora.drpc.org\"));\n setChainWithDefaultRpcUrl(\n \"zora_sepolia\", ChainData(\"Zora Sepolia\", 999999999, \"https://sepolia.rpc.zora.energy\")\n );\n\n setChainWithDefaultRpcUrl(\"race\", ChainData(\"Race\", 6805, \"https://racemainnet.io\"));\n setChainWithDefaultRpcUrl(\"race_sepolia\", ChainData(\"Race Sepolia\", 6806, \"https://racemainnet.io\"));\n\n setChainWithDefaultRpcUrl(\"metal\", ChainData(\"Metal\", 1750, \"https://metall2.drpc.org\"));\n setChainWithDefaultRpcUrl(\"metal_sepolia\", ChainData(\"Metal Sepolia\", 1740, \"https://testnet.rpc.metall2.com\"));\n\n setChainWithDefaultRpcUrl(\"binary\", ChainData(\"Binary\", 624, \"https://rpc.zero.thebinaryholdings.com\"));\n setChainWithDefaultRpcUrl(\n \"binary_sepolia\", ChainData(\"Binary Sepolia\", 625, \"https://rpc.zero.thebinaryholdings.com\")\n );\n\n setChainWithDefaultRpcUrl(\"orderly\", ChainData(\"Orderly\", 291, \"https://rpc.orderly.network\"));\n setChainWithDefaultRpcUrl(\n \"orderly_sepolia\", ChainData(\"Orderly Sepolia\", 4460, \"https://testnet-rpc.orderly.org\")\n );\n }\n\n // set chain info, with priority to chainAlias' rpc url in foundry.toml\n function setChainWithDefaultRpcUrl(string memory chainAlias, ChainData memory chain) private {\n string memory rpcUrl = chain.rpcUrl;\n defaultRpcUrls[chainAlias] = rpcUrl;\n chain.rpcUrl = \"\";\n setChain(chainAlias, chain);\n chain.rpcUrl = rpcUrl; // restore argument\n }\n}\n","license":"MIT"},"lib/forge-std/src/StdCheats.sol":{"keccak256":"0x0fa6ec03602648b62cce41aab2096e6b7e052f2846075d967b6958dd586db746","urls":[],"content":"// SPDX-License-Identifier: MIT\npragma solidity >=0.6.2 <0.9.0;\n\npragma experimental ABIEncoderV2;\n\nimport {StdStorage, stdStorage} from \"./StdStorage.sol\";\nimport {console2} from \"./console2.sol\";\nimport {Vm} from \"./Vm.sol\";\n\nabstract contract StdCheatsSafe {\n Vm private constant vm = Vm(address(uint160(uint256(keccak256(\"hevm cheat code\")))));\n\n uint256 private constant UINT256_MAX =\n 115792089237316195423570985008687907853269984665640564039457584007913129639935;\n\n bool private gasMeteringOff;\n\n // Data structures to parse Transaction objects from the broadcast artifact\n // that conform to EIP1559. The Raw structs is what is parsed from the JSON\n // and then converted to the one that is used by the user for better UX.\n\n struct RawTx1559 {\n string[] arguments;\n address contractAddress;\n string contractName;\n // json value name = function\n string functionSig;\n bytes32 hash;\n // json value name = tx\n RawTx1559Detail txDetail;\n // json value name = type\n string opcode;\n }\n\n struct RawTx1559Detail {\n AccessList[] accessList;\n bytes data;\n address from;\n bytes gas;\n bytes nonce;\n address to;\n bytes txType;\n bytes value;\n }\n\n struct Tx1559 {\n string[] arguments;\n address contractAddress;\n string contractName;\n string functionSig;\n bytes32 hash;\n Tx1559Detail txDetail;\n string opcode;\n }\n\n struct Tx1559Detail {\n AccessList[] accessList;\n bytes data;\n address from;\n uint256 gas;\n uint256 nonce;\n address to;\n uint256 txType;\n uint256 value;\n }\n\n // Data structures to parse Transaction objects from the broadcast artifact\n // that DO NOT conform to EIP1559. The Raw structs is what is parsed from the JSON\n // and then converted to the one that is used by the user for better UX.\n\n struct TxLegacy {\n string[] arguments;\n address contractAddress;\n string contractName;\n string functionSig;\n string hash;\n string opcode;\n TxDetailLegacy transaction;\n }\n\n struct TxDetailLegacy {\n AccessList[] accessList;\n uint256 chainId;\n bytes data;\n address from;\n uint256 gas;\n uint256 gasPrice;\n bytes32 hash;\n uint256 nonce;\n bytes1 opcode;\n bytes32 r;\n bytes32 s;\n uint256 txType;\n address to;\n uint8 v;\n uint256 value;\n }\n\n struct AccessList {\n address accessAddress;\n bytes32[] storageKeys;\n }\n\n // Data structures to parse Receipt objects from the broadcast artifact.\n // The Raw structs is what is parsed from the JSON\n // and then converted to the one that is used by the user for better UX.\n\n struct RawReceipt {\n bytes32 blockHash;\n bytes blockNumber;\n address contractAddress;\n bytes cumulativeGasUsed;\n bytes effectiveGasPrice;\n address from;\n bytes gasUsed;\n RawReceiptLog[] logs;\n bytes logsBloom;\n bytes status;\n address to;\n bytes32 transactionHash;\n bytes transactionIndex;\n }\n\n struct Receipt {\n bytes32 blockHash;\n uint256 blockNumber;\n address contractAddress;\n uint256 cumulativeGasUsed;\n uint256 effectiveGasPrice;\n address from;\n uint256 gasUsed;\n ReceiptLog[] logs;\n bytes logsBloom;\n uint256 status;\n address to;\n bytes32 transactionHash;\n uint256 transactionIndex;\n }\n\n // Data structures to parse the entire broadcast artifact, assuming the\n // transactions conform to EIP1559.\n\n struct EIP1559ScriptArtifact {\n string[] libraries;\n string path;\n string[] pending;\n Receipt[] receipts;\n uint256 timestamp;\n Tx1559[] transactions;\n TxReturn[] txReturns;\n }\n\n struct RawEIP1559ScriptArtifact {\n string[] libraries;\n string path;\n string[] pending;\n RawReceipt[] receipts;\n TxReturn[] txReturns;\n uint256 timestamp;\n RawTx1559[] transactions;\n }\n\n struct RawReceiptLog {\n // json value = address\n address logAddress;\n bytes32 blockHash;\n bytes blockNumber;\n bytes data;\n bytes logIndex;\n bool removed;\n bytes32[] topics;\n bytes32 transactionHash;\n bytes transactionIndex;\n bytes transactionLogIndex;\n }\n\n struct ReceiptLog {\n // json value = address\n address logAddress;\n bytes32 blockHash;\n uint256 blockNumber;\n bytes data;\n uint256 logIndex;\n bytes32[] topics;\n uint256 transactionIndex;\n uint256 transactionLogIndex;\n bool removed;\n }\n\n struct TxReturn {\n string internalType;\n string value;\n }\n\n struct Account {\n address addr;\n uint256 key;\n }\n\n enum AddressType {\n Payable,\n NonPayable,\n ZeroAddress,\n Precompile,\n ForgeAddress\n }\n\n // Checks that `addr` is not blacklisted by token contracts that have a blacklist.\n function assumeNotBlacklisted(address token, address addr) internal view virtual {\n // Nothing to check if `token` is not a contract.\n uint256 tokenCodeSize;\n assembly {\n tokenCodeSize := extcodesize(token)\n }\n require(tokenCodeSize > 0, \"StdCheats assumeNotBlacklisted(address,address): Token address is not a contract.\");\n\n bool success;\n bytes memory returnData;\n\n // 4-byte selector for `isBlacklisted(address)`, used by USDC.\n (success, returnData) = token.staticcall(abi.encodeWithSelector(0xfe575a87, addr));\n vm.assume(!success || abi.decode(returnData, (bool)) == false);\n\n // 4-byte selector for `isBlackListed(address)`, used by USDT.\n (success, returnData) = token.staticcall(abi.encodeWithSelector(0xe47d6060, addr));\n vm.assume(!success || abi.decode(returnData, (bool)) == false);\n }\n\n // Checks that `addr` is not blacklisted by token contracts that have a blacklist.\n // This is identical to `assumeNotBlacklisted(address,address)` but with a different name, for\n // backwards compatibility, since this name was used in the original PR which already has\n // a release. This function can be removed in a future release once we want a breaking change.\n function assumeNoBlacklisted(address token, address addr) internal view virtual {\n assumeNotBlacklisted(token, addr);\n }\n\n function assumeAddressIsNot(address addr, AddressType addressType) internal virtual {\n if (addressType == AddressType.Payable) {\n assumeNotPayable(addr);\n } else if (addressType == AddressType.NonPayable) {\n assumePayable(addr);\n } else if (addressType == AddressType.ZeroAddress) {\n assumeNotZeroAddress(addr);\n } else if (addressType == AddressType.Precompile) {\n assumeNotPrecompile(addr);\n } else if (addressType == AddressType.ForgeAddress) {\n assumeNotForgeAddress(addr);\n }\n }\n\n function assumeAddressIsNot(address addr, AddressType addressType1, AddressType addressType2) internal virtual {\n assumeAddressIsNot(addr, addressType1);\n assumeAddressIsNot(addr, addressType2);\n }\n\n function assumeAddressIsNot(\n address addr,\n AddressType addressType1,\n AddressType addressType2,\n AddressType addressType3\n ) internal virtual {\n assumeAddressIsNot(addr, addressType1);\n assumeAddressIsNot(addr, addressType2);\n assumeAddressIsNot(addr, addressType3);\n }\n\n function assumeAddressIsNot(\n address addr,\n AddressType addressType1,\n AddressType addressType2,\n AddressType addressType3,\n AddressType addressType4\n ) internal virtual {\n assumeAddressIsNot(addr, addressType1);\n assumeAddressIsNot(addr, addressType2);\n assumeAddressIsNot(addr, addressType3);\n assumeAddressIsNot(addr, addressType4);\n }\n\n // This function checks whether an address, `addr`, is payable. It works by sending 1 wei to\n // `addr` and checking the `success` return value.\n // NOTE: This function may result in state changes depending on the fallback/receive logic\n // implemented by `addr`, which should be taken into account when this function is used.\n function _isPayable(address addr) private returns (bool) {\n require(\n addr.balance < UINT256_MAX,\n \"StdCheats _isPayable(address): Balance equals max uint256, so it cannot receive any more funds\"\n );\n uint256 origBalanceTest = address(this).balance;\n uint256 origBalanceAddr = address(addr).balance;\n\n vm.deal(address(this), 1);\n (bool success,) = payable(addr).call{value: 1}(\"\");\n\n // reset balances\n vm.deal(address(this), origBalanceTest);\n vm.deal(addr, origBalanceAddr);\n\n return success;\n }\n\n // NOTE: This function may result in state changes depending on the fallback/receive logic\n // implemented by `addr`, which should be taken into account when this function is used. See the\n // `_isPayable` method for more information.\n function assumePayable(address addr) internal virtual {\n vm.assume(_isPayable(addr));\n }\n\n function assumeNotPayable(address addr) internal virtual {\n vm.assume(!_isPayable(addr));\n }\n\n function assumeNotZeroAddress(address addr) internal pure virtual {\n vm.assume(addr != address(0));\n }\n\n function assumeNotPrecompile(address addr) internal pure virtual {\n assumeNotPrecompile(addr, _pureChainId());\n }\n\n function assumeNotPrecompile(address addr, uint256 chainId) internal pure virtual {\n // Note: For some chains like Optimism these are technically predeploys (i.e. bytecode placed at a specific\n // address), but the same rationale for excluding them applies so we include those too.\n\n // These are reserved by Ethereum and may be on all EVM-compatible chains.\n vm.assume(addr < address(0x1) || addr > address(0xff));\n\n // forgefmt: disable-start\n if (chainId == 10 || chainId == 420) {\n // https://github.com/ethereum-optimism/optimism/blob/eaa371a0184b56b7ca6d9eb9cb0a2b78b2ccd864/op-bindings/predeploys/addresses.go#L6-L21\n vm.assume(addr < address(0x4200000000000000000000000000000000000000) || addr > address(0x4200000000000000000000000000000000000800));\n } else if (chainId == 42161 || chainId == 421613) {\n // https://developer.arbitrum.io/useful-addresses#arbitrum-precompiles-l2-same-on-all-arb-chains\n vm.assume(addr < address(0x0000000000000000000000000000000000000064) || addr > address(0x0000000000000000000000000000000000000068));\n } else if (chainId == 43114 || chainId == 43113) {\n // https://github.com/ava-labs/subnet-evm/blob/47c03fd007ecaa6de2c52ea081596e0a88401f58/precompile/params.go#L18-L59\n vm.assume(addr < address(0x0100000000000000000000000000000000000000) || addr > address(0x01000000000000000000000000000000000000ff));\n vm.assume(addr < address(0x0200000000000000000000000000000000000000) || addr > address(0x02000000000000000000000000000000000000FF));\n vm.assume(addr < address(0x0300000000000000000000000000000000000000) || addr > address(0x03000000000000000000000000000000000000Ff));\n }\n // forgefmt: disable-end\n }\n\n function assumeNotForgeAddress(address addr) internal pure virtual {\n // vm, console, and Create2Deployer addresses\n vm.assume(\n addr != address(vm) && addr != 0x000000000000000000636F6e736F6c652e6c6f67\n && addr != 0x4e59b44847b379578588920cA78FbF26c0B4956C\n );\n }\n\n function assumeUnusedAddress(address addr) internal view virtual {\n uint256 size;\n assembly {\n size := extcodesize(addr)\n }\n vm.assume(size == 0);\n\n assumeNotPrecompile(addr);\n assumeNotZeroAddress(addr);\n assumeNotForgeAddress(addr);\n }\n\n function readEIP1559ScriptArtifact(string memory path)\n internal\n view\n virtual\n returns (EIP1559ScriptArtifact memory)\n {\n string memory data = vm.readFile(path);\n bytes memory parsedData = vm.parseJson(data);\n RawEIP1559ScriptArtifact memory rawArtifact = abi.decode(parsedData, (RawEIP1559ScriptArtifact));\n EIP1559ScriptArtifact memory artifact;\n artifact.libraries = rawArtifact.libraries;\n artifact.path = rawArtifact.path;\n artifact.timestamp = rawArtifact.timestamp;\n artifact.pending = rawArtifact.pending;\n artifact.txReturns = rawArtifact.txReturns;\n artifact.receipts = rawToConvertedReceipts(rawArtifact.receipts);\n artifact.transactions = rawToConvertedEIPTx1559s(rawArtifact.transactions);\n return artifact;\n }\n\n function rawToConvertedEIPTx1559s(RawTx1559[] memory rawTxs) internal pure virtual returns (Tx1559[] memory) {\n Tx1559[] memory txs = new Tx1559[](rawTxs.length);\n for (uint256 i; i < rawTxs.length; i++) {\n txs[i] = rawToConvertedEIPTx1559(rawTxs[i]);\n }\n return txs;\n }\n\n function rawToConvertedEIPTx1559(RawTx1559 memory rawTx) internal pure virtual returns (Tx1559 memory) {\n Tx1559 memory transaction;\n transaction.arguments = rawTx.arguments;\n transaction.contractName = rawTx.contractName;\n transaction.functionSig = rawTx.functionSig;\n transaction.hash = rawTx.hash;\n transaction.txDetail = rawToConvertedEIP1559Detail(rawTx.txDetail);\n transaction.opcode = rawTx.opcode;\n return transaction;\n }\n\n function rawToConvertedEIP1559Detail(RawTx1559Detail memory rawDetail)\n internal\n pure\n virtual\n returns (Tx1559Detail memory)\n {\n Tx1559Detail memory txDetail;\n txDetail.data = rawDetail.data;\n txDetail.from = rawDetail.from;\n txDetail.to = rawDetail.to;\n txDetail.nonce = _bytesToUint(rawDetail.nonce);\n txDetail.txType = _bytesToUint(rawDetail.txType);\n txDetail.value = _bytesToUint(rawDetail.value);\n txDetail.gas = _bytesToUint(rawDetail.gas);\n txDetail.accessList = rawDetail.accessList;\n return txDetail;\n }\n\n function readTx1559s(string memory path) internal view virtual returns (Tx1559[] memory) {\n string memory deployData = vm.readFile(path);\n bytes memory parsedDeployData = vm.parseJson(deployData, \".transactions\");\n RawTx1559[] memory rawTxs = abi.decode(parsedDeployData, (RawTx1559[]));\n return rawToConvertedEIPTx1559s(rawTxs);\n }\n\n function readTx1559(string memory path, uint256 index) internal view virtual returns (Tx1559 memory) {\n string memory deployData = vm.readFile(path);\n string memory key = string(abi.encodePacked(\".transactions[\", vm.toString(index), \"]\"));\n bytes memory parsedDeployData = vm.parseJson(deployData, key);\n RawTx1559 memory rawTx = abi.decode(parsedDeployData, (RawTx1559));\n return rawToConvertedEIPTx1559(rawTx);\n }\n\n // Analogous to readTransactions, but for receipts.\n function readReceipts(string memory path) internal view virtual returns (Receipt[] memory) {\n string memory deployData = vm.readFile(path);\n bytes memory parsedDeployData = vm.parseJson(deployData, \".receipts\");\n RawReceipt[] memory rawReceipts = abi.decode(parsedDeployData, (RawReceipt[]));\n return rawToConvertedReceipts(rawReceipts);\n }\n\n function readReceipt(string memory path, uint256 index) internal view virtual returns (Receipt memory) {\n string memory deployData = vm.readFile(path);\n string memory key = string(abi.encodePacked(\".receipts[\", vm.toString(index), \"]\"));\n bytes memory parsedDeployData = vm.parseJson(deployData, key);\n RawReceipt memory rawReceipt = abi.decode(parsedDeployData, (RawReceipt));\n return rawToConvertedReceipt(rawReceipt);\n }\n\n function rawToConvertedReceipts(RawReceipt[] memory rawReceipts) internal pure virtual returns (Receipt[] memory) {\n Receipt[] memory receipts = new Receipt[](rawReceipts.length);\n for (uint256 i; i < rawReceipts.length; i++) {\n receipts[i] = rawToConvertedReceipt(rawReceipts[i]);\n }\n return receipts;\n }\n\n function rawToConvertedReceipt(RawReceipt memory rawReceipt) internal pure virtual returns (Receipt memory) {\n Receipt memory receipt;\n receipt.blockHash = rawReceipt.blockHash;\n receipt.to = rawReceipt.to;\n receipt.from = rawReceipt.from;\n receipt.contractAddress = rawReceipt.contractAddress;\n receipt.effectiveGasPrice = _bytesToUint(rawReceipt.effectiveGasPrice);\n receipt.cumulativeGasUsed = _bytesToUint(rawReceipt.cumulativeGasUsed);\n receipt.gasUsed = _bytesToUint(rawReceipt.gasUsed);\n receipt.status = _bytesToUint(rawReceipt.status);\n receipt.transactionIndex = _bytesToUint(rawReceipt.transactionIndex);\n receipt.blockNumber = _bytesToUint(rawReceipt.blockNumber);\n receipt.logs = rawToConvertedReceiptLogs(rawReceipt.logs);\n receipt.logsBloom = rawReceipt.logsBloom;\n receipt.transactionHash = rawReceipt.transactionHash;\n return receipt;\n }\n\n function rawToConvertedReceiptLogs(RawReceiptLog[] memory rawLogs)\n internal\n pure\n virtual\n returns (ReceiptLog[] memory)\n {\n ReceiptLog[] memory logs = new ReceiptLog[](rawLogs.length);\n for (uint256 i; i < rawLogs.length; i++) {\n logs[i].logAddress = rawLogs[i].logAddress;\n logs[i].blockHash = rawLogs[i].blockHash;\n logs[i].blockNumber = _bytesToUint(rawLogs[i].blockNumber);\n logs[i].data = rawLogs[i].data;\n logs[i].logIndex = _bytesToUint(rawLogs[i].logIndex);\n logs[i].topics = rawLogs[i].topics;\n logs[i].transactionIndex = _bytesToUint(rawLogs[i].transactionIndex);\n logs[i].transactionLogIndex = _bytesToUint(rawLogs[i].transactionLogIndex);\n logs[i].removed = rawLogs[i].removed;\n }\n return logs;\n }\n\n // Deploy a contract by fetching the contract bytecode from\n // the artifacts directory\n // e.g. `deployCode(code, abi.encode(arg1,arg2,arg3))`\n function deployCode(string memory what, bytes memory args) internal virtual returns (address addr) {\n bytes memory bytecode = abi.encodePacked(vm.getCode(what), args);\n /// @solidity memory-safe-assembly\n assembly {\n addr := create(0, add(bytecode, 0x20), mload(bytecode))\n }\n\n require(addr != address(0), \"StdCheats deployCode(string,bytes): Deployment failed.\");\n }\n\n function deployCode(string memory what) internal virtual returns (address addr) {\n bytes memory bytecode = vm.getCode(what);\n /// @solidity memory-safe-assembly\n assembly {\n addr := create(0, add(bytecode, 0x20), mload(bytecode))\n }\n\n require(addr != address(0), \"StdCheats deployCode(string): Deployment failed.\");\n }\n\n /// @dev deploy contract with value on construction\n function deployCode(string memory what, bytes memory args, uint256 val) internal virtual returns (address addr) {\n bytes memory bytecode = abi.encodePacked(vm.getCode(what), args);\n /// @solidity memory-safe-assembly\n assembly {\n addr := create(val, add(bytecode, 0x20), mload(bytecode))\n }\n\n require(addr != address(0), \"StdCheats deployCode(string,bytes,uint256): Deployment failed.\");\n }\n\n function deployCode(string memory what, uint256 val) internal virtual returns (address addr) {\n bytes memory bytecode = vm.getCode(what);\n /// @solidity memory-safe-assembly\n assembly {\n addr := create(val, add(bytecode, 0x20), mload(bytecode))\n }\n\n require(addr != address(0), \"StdCheats deployCode(string,uint256): Deployment failed.\");\n }\n\n // creates a labeled address and the corresponding private key\n function makeAddrAndKey(string memory name) internal virtual returns (address addr, uint256 privateKey) {\n privateKey = uint256(keccak256(abi.encodePacked(name)));\n addr = vm.addr(privateKey);\n vm.label(addr, name);\n }\n\n // creates a labeled address\n function makeAddr(string memory name) internal virtual returns (address addr) {\n (addr,) = makeAddrAndKey(name);\n }\n\n // Destroys an account immediately, sending the balance to beneficiary.\n // Destroying means: balance will be zero, code will be empty, and nonce will be 0\n // This is similar to selfdestruct but not identical: selfdestruct destroys code and nonce\n // only after tx ends, this will run immediately.\n function destroyAccount(address who, address beneficiary) internal virtual {\n uint256 currBalance = who.balance;\n vm.etch(who, abi.encode());\n vm.deal(who, 0);\n vm.resetNonce(who);\n\n uint256 beneficiaryBalance = beneficiary.balance;\n vm.deal(beneficiary, currBalance + beneficiaryBalance);\n }\n\n // creates a struct containing both a labeled address and the corresponding private key\n function makeAccount(string memory name) internal virtual returns (Account memory account) {\n (account.addr, account.key) = makeAddrAndKey(name);\n }\n\n function deriveRememberKey(string memory mnemonic, uint32 index)\n internal\n virtual\n returns (address who, uint256 privateKey)\n {\n privateKey = vm.deriveKey(mnemonic, index);\n who = vm.rememberKey(privateKey);\n }\n\n function _bytesToUint(bytes memory b) private pure returns (uint256) {\n require(b.length <= 32, \"StdCheats _bytesToUint(bytes): Bytes length exceeds 32.\");\n return abi.decode(abi.encodePacked(new bytes(32 - b.length), b), (uint256));\n }\n\n function isFork() internal view virtual returns (bool status) {\n try vm.activeFork() {\n status = true;\n } catch (bytes memory) {}\n }\n\n modifier skipWhenForking() {\n if (!isFork()) {\n _;\n }\n }\n\n modifier skipWhenNotForking() {\n if (isFork()) {\n _;\n }\n }\n\n modifier noGasMetering() {\n vm.pauseGasMetering();\n // To prevent turning gas monitoring back on with nested functions that use this modifier,\n // we check if gasMetering started in the off position. If it did, we don't want to turn\n // it back on until we exit the top level function that used the modifier\n //\n // i.e. funcA() noGasMetering { funcB() }, where funcB has noGasMetering as well.\n // funcA will have `gasStartedOff` as false, funcB will have it as true,\n // so we only turn metering back on at the end of the funcA\n bool gasStartedOff = gasMeteringOff;\n gasMeteringOff = true;\n\n _;\n\n // if gas metering was on when this modifier was called, turn it back on at the end\n if (!gasStartedOff) {\n gasMeteringOff = false;\n vm.resumeGasMetering();\n }\n }\n\n // We use this complex approach of `_viewChainId` and `_pureChainId` to ensure there are no\n // compiler warnings when accessing chain ID in any solidity version supported by forge-std. We\n // can't simply access the chain ID in a normal view or pure function because the solc View Pure\n // Checker changed `chainid` from pure to view in 0.8.0.\n function _viewChainId() private view returns (uint256 chainId) {\n // Assembly required since `block.chainid` was introduced in 0.8.0.\n assembly {\n chainId := chainid()\n }\n\n address(this); // Silence warnings in older Solc versions.\n }\n\n function _pureChainId() private pure returns (uint256 chainId) {\n function() internal view returns (uint256) fnIn = _viewChainId;\n function() internal pure returns (uint256) pureChainId;\n assembly {\n pureChainId := fnIn\n }\n chainId = pureChainId();\n }\n}\n\n// Wrappers around cheatcodes to avoid footguns\nabstract contract StdCheats is StdCheatsSafe {\n using stdStorage for StdStorage;\n\n StdStorage private stdstore;\n Vm private constant vm = Vm(address(uint160(uint256(keccak256(\"hevm cheat code\")))));\n address private constant CONSOLE2_ADDRESS = 0x000000000000000000636F6e736F6c652e6c6f67;\n\n // Skip forward or rewind time by the specified number of seconds\n function skip(uint256 time) internal virtual {\n vm.warp(vm.getBlockTimestamp() + time);\n }\n\n function rewind(uint256 time) internal virtual {\n vm.warp(vm.getBlockTimestamp() - time);\n }\n\n // Setup a prank from an address that has some ether\n function hoax(address msgSender) internal virtual {\n vm.deal(msgSender, 1 << 128);\n vm.prank(msgSender);\n }\n\n function hoax(address msgSender, uint256 give) internal virtual {\n vm.deal(msgSender, give);\n vm.prank(msgSender);\n }\n\n function hoax(address msgSender, address origin) internal virtual {\n vm.deal(msgSender, 1 << 128);\n vm.prank(msgSender, origin);\n }\n\n function hoax(address msgSender, address origin, uint256 give) internal virtual {\n vm.deal(msgSender, give);\n vm.prank(msgSender, origin);\n }\n\n // Start perpetual prank from an address that has some ether\n function startHoax(address msgSender) internal virtual {\n vm.deal(msgSender, 1 << 128);\n vm.startPrank(msgSender);\n }\n\n function startHoax(address msgSender, uint256 give) internal virtual {\n vm.deal(msgSender, give);\n vm.startPrank(msgSender);\n }\n\n // Start perpetual prank from an address that has some ether\n // tx.origin is set to the origin parameter\n function startHoax(address msgSender, address origin) internal virtual {\n vm.deal(msgSender, 1 << 128);\n vm.startPrank(msgSender, origin);\n }\n\n function startHoax(address msgSender, address origin, uint256 give) internal virtual {\n vm.deal(msgSender, give);\n vm.startPrank(msgSender, origin);\n }\n\n function changePrank(address msgSender) internal virtual {\n console2_log_StdCheats(\"changePrank is deprecated. Please use vm.startPrank instead.\");\n vm.stopPrank();\n vm.startPrank(msgSender);\n }\n\n function changePrank(address msgSender, address txOrigin) internal virtual {\n vm.stopPrank();\n vm.startPrank(msgSender, txOrigin);\n }\n\n // The same as Vm's `deal`\n // Use the alternative signature for ERC20 tokens\n function deal(address to, uint256 give) internal virtual {\n vm.deal(to, give);\n }\n\n // Set the balance of an account for any ERC20 token\n // Use the alternative signature to update `totalSupply`\n function deal(address token, address to, uint256 give) internal virtual {\n deal(token, to, give, false);\n }\n\n // Set the balance of an account for any ERC1155 token\n // Use the alternative signature to update `totalSupply`\n function dealERC1155(address token, address to, uint256 id, uint256 give) internal virtual {\n dealERC1155(token, to, id, give, false);\n }\n\n function deal(address token, address to, uint256 give, bool adjust) internal virtual {\n // get current balance\n (, bytes memory balData) = token.staticcall(abi.encodeWithSelector(0x70a08231, to));\n uint256 prevBal = abi.decode(balData, (uint256));\n\n // update balance\n stdstore.target(token).sig(0x70a08231).with_key(to).checked_write(give);\n\n // update total supply\n if (adjust) {\n (, bytes memory totSupData) = token.staticcall(abi.encodeWithSelector(0x18160ddd));\n uint256 totSup = abi.decode(totSupData, (uint256));\n if (give < prevBal) {\n totSup -= (prevBal - give);\n } else {\n totSup += (give - prevBal);\n }\n stdstore.target(token).sig(0x18160ddd).checked_write(totSup);\n }\n }\n\n function dealERC1155(address token, address to, uint256 id, uint256 give, bool adjust) internal virtual {\n // get current balance\n (, bytes memory balData) = token.staticcall(abi.encodeWithSelector(0x00fdd58e, to, id));\n uint256 prevBal = abi.decode(balData, (uint256));\n\n // update balance\n stdstore.target(token).sig(0x00fdd58e).with_key(to).with_key(id).checked_write(give);\n\n // update total supply\n if (adjust) {\n (, bytes memory totSupData) = token.staticcall(abi.encodeWithSelector(0xbd85b039, id));\n require(\n totSupData.length != 0,\n \"StdCheats deal(address,address,uint,uint,bool): target contract is not ERC1155Supply.\"\n );\n uint256 totSup = abi.decode(totSupData, (uint256));\n if (give < prevBal) {\n totSup -= (prevBal - give);\n } else {\n totSup += (give - prevBal);\n }\n stdstore.target(token).sig(0xbd85b039).with_key(id).checked_write(totSup);\n }\n }\n\n function dealERC721(address token, address to, uint256 id) internal virtual {\n // check if token id is already minted and the actual owner.\n (bool successMinted, bytes memory ownerData) = token.staticcall(abi.encodeWithSelector(0x6352211e, id));\n require(successMinted, \"StdCheats deal(address,address,uint,bool): id not minted.\");\n\n // get owner current balance\n (, bytes memory fromBalData) =\n token.staticcall(abi.encodeWithSelector(0x70a08231, abi.decode(ownerData, (address))));\n uint256 fromPrevBal = abi.decode(fromBalData, (uint256));\n\n // get new user current balance\n (, bytes memory toBalData) = token.staticcall(abi.encodeWithSelector(0x70a08231, to));\n uint256 toPrevBal = abi.decode(toBalData, (uint256));\n\n // update balances\n stdstore.target(token).sig(0x70a08231).with_key(abi.decode(ownerData, (address))).checked_write(--fromPrevBal);\n stdstore.target(token).sig(0x70a08231).with_key(to).checked_write(++toPrevBal);\n\n // update owner\n stdstore.target(token).sig(0x6352211e).with_key(id).checked_write(to);\n }\n\n function deployCodeTo(string memory what, address where) internal virtual {\n deployCodeTo(what, \"\", 0, where);\n }\n\n function deployCodeTo(string memory what, bytes memory args, address where) internal virtual {\n deployCodeTo(what, args, 0, where);\n }\n\n function deployCodeTo(string memory what, bytes memory args, uint256 value, address where) internal virtual {\n bytes memory creationCode = vm.getCode(what);\n vm.etch(where, abi.encodePacked(creationCode, args));\n (bool success, bytes memory runtimeBytecode) = where.call{value: value}(\"\");\n require(success, \"StdCheats deployCodeTo(string,bytes,uint256,address): Failed to create runtime bytecode.\");\n vm.etch(where, runtimeBytecode);\n }\n\n // Used to prevent the compilation of console, which shortens the compilation time when console is not used elsewhere.\n function console2_log_StdCheats(string memory p0) private view {\n (bool status,) = address(CONSOLE2_ADDRESS).staticcall(abi.encodeWithSignature(\"log(string)\", p0));\n status;\n }\n}\n","license":"MIT"},"lib/forge-std/src/StdConstants.sol":{"keccak256":"0x319ccdabfa2c0b2428301445873270ffea20f0e039d4fd5e6eeba65158e4e534","urls":[],"content":"// SPDX-License-Identifier: MIT\npragma solidity >=0.6.2 <0.9.0;\n\nimport {IMulticall3} from \"./interfaces/IMulticall3.sol\";\nimport {Vm} from \"./Vm.sol\";\n\nlibrary StdConstants {\n /// @dev Cheat code address.\n /// Calculated as `address(uint160(uint256(keccak256(\"hevm cheat code\"))))`.\n Vm internal constant VM = Vm(0x7109709ECfa91a80626fF3989D68f67F5b1DD12D);\n /// @dev console.sol and console2.sol work by executing a staticcall to this address.\n /// Calculated as `address(uint160(uint88(bytes11(\"console.log\"))))`.\n address internal constant CONSOLE = 0x000000000000000000636F6e736F6c652e6c6f67;\n /// @dev Used when deploying with create2.\n /// Taken from https://github.com/Arachnid/deterministic-deployment-proxy.\n address internal constant CREATE2_FACTORY = 0x4e59b44847b379578588920cA78FbF26c0B4956C;\n /// @dev The default address for tx.origin and msg.sender.\n /// Calculated as `address(uint160(uint256(keccak256(\"foundry default caller\"))))`.\n address internal constant DEFAULT_SENDER = 0x1804c8AB1F12E6bbf3894d4083f33e07309d1f38;\n /// @dev The address of the first contract `CREATE`d by a running test contract.\n /// When running tests, each test contract is `CREATE`d by `DEFAULT_SENDER` with nonce 1.\n /// Calculated as `VM.computeCreateAddress(VM.computeCreateAddress(DEFAULT_SENDER, 1), 1)`.\n address internal constant DEFAULT_TEST_CONTRACT = 0x5615dEB798BB3E4dFa0139dFa1b3D433Cc23b72f;\n /// @dev Deterministic deployment address of the Multicall3 contract.\n /// Taken from https://www.multicall3.com.\n IMulticall3 internal constant MULTICALL3_ADDRESS = IMulticall3(0xcA11bde05977b3631167028862bE2a173976CA11);\n /// @dev The order of the secp256k1 curve.\n uint256 internal constant SECP256K1_ORDER =\n 115792089237316195423570985008687907852837564279074904382605163141518161494337;\n}\n","license":"MIT"},"lib/forge-std/src/StdJson.sol":{"keccak256":"0xbc0132abe1c2accc2867c0f03667afffdf92f3e95a581bb03c9557eaa38ea500","urls":[],"content":"// SPDX-License-Identifier: MIT\npragma solidity >=0.6.0 <0.9.0;\n\npragma experimental ABIEncoderV2;\n\nimport {VmSafe} from \"./Vm.sol\";\n\n// Helpers for parsing and writing JSON files\n// To parse:\n// ```\n// using stdJson for string;\n// string memory json = vm.readFile(\"\");\n// json.readUint(\"\");\n// ```\n// To write:\n// ```\n// using stdJson for string;\n// string memory json = \"json\";\n// json.serialize(\"a\", uint256(123));\n// string memory semiFinal = json.serialize(\"b\", string(\"test\"));\n// string memory finalJson = json.serialize(\"c\", semiFinal);\n// finalJson.write(\"\");\n// ```\n\nlibrary stdJson {\n VmSafe private constant vm = VmSafe(address(uint160(uint256(keccak256(\"hevm cheat code\")))));\n\n function keyExists(string memory json, string memory key) internal view returns (bool) {\n return vm.keyExistsJson(json, key);\n }\n\n function parseRaw(string memory json, string memory key) internal pure returns (bytes memory) {\n return vm.parseJson(json, key);\n }\n\n function readUint(string memory json, string memory key) internal pure returns (uint256) {\n return vm.parseJsonUint(json, key);\n }\n\n function readUintArray(string memory json, string memory key) internal pure returns (uint256[] memory) {\n return vm.parseJsonUintArray(json, key);\n }\n\n function readInt(string memory json, string memory key) internal pure returns (int256) {\n return vm.parseJsonInt(json, key);\n }\n\n function readIntArray(string memory json, string memory key) internal pure returns (int256[] memory) {\n return vm.parseJsonIntArray(json, key);\n }\n\n function readBytes32(string memory json, string memory key) internal pure returns (bytes32) {\n return vm.parseJsonBytes32(json, key);\n }\n\n function readBytes32Array(string memory json, string memory key) internal pure returns (bytes32[] memory) {\n return vm.parseJsonBytes32Array(json, key);\n }\n\n function readString(string memory json, string memory key) internal pure returns (string memory) {\n return vm.parseJsonString(json, key);\n }\n\n function readStringArray(string memory json, string memory key) internal pure returns (string[] memory) {\n return vm.parseJsonStringArray(json, key);\n }\n\n function readAddress(string memory json, string memory key) internal pure returns (address) {\n return vm.parseJsonAddress(json, key);\n }\n\n function readAddressArray(string memory json, string memory key) internal pure returns (address[] memory) {\n return vm.parseJsonAddressArray(json, key);\n }\n\n function readBool(string memory json, string memory key) internal pure returns (bool) {\n return vm.parseJsonBool(json, key);\n }\n\n function readBoolArray(string memory json, string memory key) internal pure returns (bool[] memory) {\n return vm.parseJsonBoolArray(json, key);\n }\n\n function readBytes(string memory json, string memory key) internal pure returns (bytes memory) {\n return vm.parseJsonBytes(json, key);\n }\n\n function readBytesArray(string memory json, string memory key) internal pure returns (bytes[] memory) {\n return vm.parseJsonBytesArray(json, key);\n }\n\n function readUintOr(string memory json, string memory key, uint256 defaultValue) internal view returns (uint256) {\n return keyExists(json, key) ? readUint(json, key) : defaultValue;\n }\n\n function readUintArrayOr(string memory json, string memory key, uint256[] memory defaultValue)\n internal\n view\n returns (uint256[] memory)\n {\n return keyExists(json, key) ? readUintArray(json, key) : defaultValue;\n }\n\n function readIntOr(string memory json, string memory key, int256 defaultValue) internal view returns (int256) {\n return keyExists(json, key) ? readInt(json, key) : defaultValue;\n }\n\n function readIntArrayOr(string memory json, string memory key, int256[] memory defaultValue)\n internal\n view\n returns (int256[] memory)\n {\n return keyExists(json, key) ? readIntArray(json, key) : defaultValue;\n }\n\n function readBytes32Or(string memory json, string memory key, bytes32 defaultValue)\n internal\n view\n returns (bytes32)\n {\n return keyExists(json, key) ? readBytes32(json, key) : defaultValue;\n }\n\n function readBytes32ArrayOr(string memory json, string memory key, bytes32[] memory defaultValue)\n internal\n view\n returns (bytes32[] memory)\n {\n return keyExists(json, key) ? readBytes32Array(json, key) : defaultValue;\n }\n\n function readStringOr(string memory json, string memory key, string memory defaultValue)\n internal\n view\n returns (string memory)\n {\n return keyExists(json, key) ? readString(json, key) : defaultValue;\n }\n\n function readStringArrayOr(string memory json, string memory key, string[] memory defaultValue)\n internal\n view\n returns (string[] memory)\n {\n return keyExists(json, key) ? readStringArray(json, key) : defaultValue;\n }\n\n function readAddressOr(string memory json, string memory key, address defaultValue)\n internal\n view\n returns (address)\n {\n return keyExists(json, key) ? readAddress(json, key) : defaultValue;\n }\n\n function readAddressArrayOr(string memory json, string memory key, address[] memory defaultValue)\n internal\n view\n returns (address[] memory)\n {\n return keyExists(json, key) ? readAddressArray(json, key) : defaultValue;\n }\n\n function readBoolOr(string memory json, string memory key, bool defaultValue) internal view returns (bool) {\n return keyExists(json, key) ? readBool(json, key) : defaultValue;\n }\n\n function readBoolArrayOr(string memory json, string memory key, bool[] memory defaultValue)\n internal\n view\n returns (bool[] memory)\n {\n return keyExists(json, key) ? readBoolArray(json, key) : defaultValue;\n }\n\n function readBytesOr(string memory json, string memory key, bytes memory defaultValue)\n internal\n view\n returns (bytes memory)\n {\n return keyExists(json, key) ? readBytes(json, key) : defaultValue;\n }\n\n function readBytesArrayOr(string memory json, string memory key, bytes[] memory defaultValue)\n internal\n view\n returns (bytes[] memory)\n {\n return keyExists(json, key) ? readBytesArray(json, key) : defaultValue;\n }\n\n function serialize(string memory jsonKey, string memory rootObject) internal returns (string memory) {\n return vm.serializeJson(jsonKey, rootObject);\n }\n\n function serialize(string memory jsonKey, string memory key, bool value) internal returns (string memory) {\n return vm.serializeBool(jsonKey, key, value);\n }\n\n function serialize(string memory jsonKey, string memory key, bool[] memory value)\n internal\n returns (string memory)\n {\n return vm.serializeBool(jsonKey, key, value);\n }\n\n function serialize(string memory jsonKey, string memory key, uint256 value) internal returns (string memory) {\n return vm.serializeUint(jsonKey, key, value);\n }\n\n function serialize(string memory jsonKey, string memory key, uint256[] memory value)\n internal\n returns (string memory)\n {\n return vm.serializeUint(jsonKey, key, value);\n }\n\n function serialize(string memory jsonKey, string memory key, int256 value) internal returns (string memory) {\n return vm.serializeInt(jsonKey, key, value);\n }\n\n function serialize(string memory jsonKey, string memory key, int256[] memory value)\n internal\n returns (string memory)\n {\n return vm.serializeInt(jsonKey, key, value);\n }\n\n function serialize(string memory jsonKey, string memory key, address value) internal returns (string memory) {\n return vm.serializeAddress(jsonKey, key, value);\n }\n\n function serialize(string memory jsonKey, string memory key, address[] memory value)\n internal\n returns (string memory)\n {\n return vm.serializeAddress(jsonKey, key, value);\n }\n\n function serialize(string memory jsonKey, string memory key, bytes32 value) internal returns (string memory) {\n return vm.serializeBytes32(jsonKey, key, value);\n }\n\n function serialize(string memory jsonKey, string memory key, bytes32[] memory value)\n internal\n returns (string memory)\n {\n return vm.serializeBytes32(jsonKey, key, value);\n }\n\n function serialize(string memory jsonKey, string memory key, bytes memory value) internal returns (string memory) {\n return vm.serializeBytes(jsonKey, key, value);\n }\n\n function serialize(string memory jsonKey, string memory key, bytes[] memory value)\n internal\n returns (string memory)\n {\n return vm.serializeBytes(jsonKey, key, value);\n }\n\n function serialize(string memory jsonKey, string memory key, string memory value)\n internal\n returns (string memory)\n {\n return vm.serializeString(jsonKey, key, value);\n }\n\n function serialize(string memory jsonKey, string memory key, string[] memory value)\n internal\n returns (string memory)\n {\n return vm.serializeString(jsonKey, key, value);\n }\n\n function write(string memory jsonKey, string memory path) internal {\n vm.writeJson(jsonKey, path);\n }\n\n function write(string memory jsonKey, string memory path, string memory valueKey) internal {\n vm.writeJson(jsonKey, path, valueKey);\n }\n}\n","license":"MIT"},"lib/forge-std/src/StdMath.sol":{"keccak256":"0xd90ad4fd8aeaeb8929964e686e769fdedd5eded3fc3815df194a0ab9f91a3fb2","urls":[],"content":"// SPDX-License-Identifier: MIT\npragma solidity >=0.6.2 <0.9.0;\n\nlibrary stdMath {\n int256 private constant INT256_MIN = -57896044618658097711785492504343953926634992332820282019728792003956564819968;\n\n function abs(int256 a) internal pure returns (uint256) {\n // Required or it will fail when `a = type(int256).min`\n if (a == INT256_MIN) {\n return 57896044618658097711785492504343953926634992332820282019728792003956564819968;\n }\n\n return uint256(a > 0 ? a : -a);\n }\n\n function delta(uint256 a, uint256 b) internal pure returns (uint256) {\n return a > b ? a - b : b - a;\n }\n\n function delta(int256 a, int256 b) internal pure returns (uint256) {\n // a and b are of the same sign\n // this works thanks to two's complement, the left-most bit is the sign bit\n if ((a ^ b) > -1) {\n return delta(abs(a), abs(b));\n }\n\n // a and b are of opposite signs\n return abs(a) + abs(b);\n }\n\n function percentDelta(uint256 a, uint256 b) internal pure returns (uint256) {\n uint256 absDelta = delta(a, b);\n\n return absDelta * 1e18 / b;\n }\n\n function percentDelta(int256 a, int256 b) internal pure returns (uint256) {\n uint256 absDelta = delta(a, b);\n uint256 absB = abs(b);\n\n return absDelta * 1e18 / absB;\n }\n}\n","license":"MIT"},"lib/forge-std/src/StdStorage.sol":{"keccak256":"0xb91ab24383a5872b894fc93325eef1add6cbbf981628f18e860068bf88bb7dcc","urls":[],"content":"// SPDX-License-Identifier: MIT\npragma solidity >=0.6.2 <0.9.0;\n\nimport {Vm} from \"./Vm.sol\";\n\nstruct FindData {\n uint256 slot;\n uint256 offsetLeft;\n uint256 offsetRight;\n bool found;\n}\n\nstruct StdStorage {\n mapping(address => mapping(bytes4 => mapping(bytes32 => FindData))) finds;\n bytes32[] _keys;\n bytes4 _sig;\n uint256 _depth;\n address _target;\n bytes32 _set;\n bool _enable_packed_slots;\n bytes _calldata;\n}\n\nlibrary stdStorageSafe {\n event SlotFound(address who, bytes4 fsig, bytes32 keysHash, uint256 slot);\n event WARNING_UninitedSlot(address who, uint256 slot);\n\n Vm private constant vm = Vm(address(uint160(uint256(keccak256(\"hevm cheat code\")))));\n uint256 constant UINT256_MAX = 115792089237316195423570985008687907853269984665640564039457584007913129639935;\n\n function sigs(string memory sigStr) internal pure returns (bytes4) {\n return bytes4(keccak256(bytes(sigStr)));\n }\n\n function getCallParams(StdStorage storage self) internal view returns (bytes memory) {\n if (self._calldata.length == 0) {\n return flatten(self._keys);\n } else {\n return self._calldata;\n }\n }\n\n // Calls target contract with configured parameters\n function callTarget(StdStorage storage self) internal view returns (bool, bytes32) {\n bytes memory cald = abi.encodePacked(self._sig, getCallParams(self));\n (bool success, bytes memory rdat) = self._target.staticcall(cald);\n bytes32 result = bytesToBytes32(rdat, 32 * self._depth);\n\n return (success, result);\n }\n\n // Tries mutating slot value to determine if the targeted value is stored in it.\n // If current value is 0, then we are setting slot value to type(uint256).max\n // Otherwise, we set it to 0. That way, return value should always be affected.\n function checkSlotMutatesCall(StdStorage storage self, bytes32 slot) internal returns (bool) {\n bytes32 prevSlotValue = vm.load(self._target, slot);\n (bool success, bytes32 prevReturnValue) = callTarget(self);\n\n bytes32 testVal = prevReturnValue == bytes32(0) ? bytes32(UINT256_MAX) : bytes32(0);\n vm.store(self._target, slot, testVal);\n\n (, bytes32 newReturnValue) = callTarget(self);\n\n vm.store(self._target, slot, prevSlotValue);\n\n return (success && (prevReturnValue != newReturnValue));\n }\n\n // Tries setting one of the bits in slot to 1 until return value changes.\n // Index of resulted bit is an offset packed slot has from left/right side\n function findOffset(StdStorage storage self, bytes32 slot, bool left) internal returns (bool, uint256) {\n for (uint256 offset = 0; offset < 256; offset++) {\n uint256 valueToPut = left ? (1 << (255 - offset)) : (1 << offset);\n vm.store(self._target, slot, bytes32(valueToPut));\n\n (bool success, bytes32 data) = callTarget(self);\n\n if (success && (uint256(data) > 0)) {\n return (true, offset);\n }\n }\n return (false, 0);\n }\n\n function findOffsets(StdStorage storage self, bytes32 slot) internal returns (bool, uint256, uint256) {\n bytes32 prevSlotValue = vm.load(self._target, slot);\n\n (bool foundLeft, uint256 offsetLeft) = findOffset(self, slot, true);\n (bool foundRight, uint256 offsetRight) = findOffset(self, slot, false);\n\n // `findOffset` may mutate slot value, so we are setting it to initial value\n vm.store(self._target, slot, prevSlotValue);\n return (foundLeft && foundRight, offsetLeft, offsetRight);\n }\n\n function find(StdStorage storage self) internal returns (FindData storage) {\n return find(self, true);\n }\n\n /// @notice find an arbitrary storage slot given a function sig, input data, address of the contract and a value to check against\n // slot complexity:\n // if flat, will be bytes32(uint256(uint));\n // if map, will be keccak256(abi.encode(key, uint(slot)));\n // if deep map, will be keccak256(abi.encode(key1, keccak256(abi.encode(key0, uint(slot)))));\n // if map struct, will be bytes32(uint256(keccak256(abi.encode(key1, keccak256(abi.encode(key0, uint(slot)))))) + structFieldDepth);\n function find(StdStorage storage self, bool _clear) internal returns (FindData storage) {\n address who = self._target;\n bytes4 fsig = self._sig;\n uint256 field_depth = self._depth;\n bytes memory params = getCallParams(self);\n\n // calldata to test against\n if (self.finds[who][fsig][keccak256(abi.encodePacked(params, field_depth))].found) {\n if (_clear) {\n clear(self);\n }\n return self.finds[who][fsig][keccak256(abi.encodePacked(params, field_depth))];\n }\n vm.record();\n (, bytes32 callResult) = callTarget(self);\n (bytes32[] memory reads,) = vm.accesses(address(who));\n\n if (reads.length == 0) {\n revert(\"stdStorage find(StdStorage): No storage use detected for target.\");\n } else {\n for (uint256 i = reads.length; --i >= 0;) {\n bytes32 prev = vm.load(who, reads[i]);\n if (prev == bytes32(0)) {\n emit WARNING_UninitedSlot(who, uint256(reads[i]));\n }\n\n if (!checkSlotMutatesCall(self, reads[i])) {\n continue;\n }\n\n (uint256 offsetLeft, uint256 offsetRight) = (0, 0);\n\n if (self._enable_packed_slots) {\n bool found;\n (found, offsetLeft, offsetRight) = findOffsets(self, reads[i]);\n if (!found) {\n continue;\n }\n }\n\n // Check that value between found offsets is equal to the current call result\n uint256 curVal = (uint256(prev) & getMaskByOffsets(offsetLeft, offsetRight)) >> offsetRight;\n\n if (uint256(callResult) != curVal) {\n continue;\n }\n\n emit SlotFound(who, fsig, keccak256(abi.encodePacked(params, field_depth)), uint256(reads[i]));\n self.finds[who][fsig][keccak256(abi.encodePacked(params, field_depth))] =\n FindData(uint256(reads[i]), offsetLeft, offsetRight, true);\n break;\n }\n }\n\n require(\n self.finds[who][fsig][keccak256(abi.encodePacked(params, field_depth))].found,\n \"stdStorage find(StdStorage): Slot(s) not found.\"\n );\n\n if (_clear) {\n clear(self);\n }\n return self.finds[who][fsig][keccak256(abi.encodePacked(params, field_depth))];\n }\n\n function target(StdStorage storage self, address _target) internal returns (StdStorage storage) {\n self._target = _target;\n return self;\n }\n\n function sig(StdStorage storage self, bytes4 _sig) internal returns (StdStorage storage) {\n self._sig = _sig;\n return self;\n }\n\n function sig(StdStorage storage self, string memory _sig) internal returns (StdStorage storage) {\n self._sig = sigs(_sig);\n return self;\n }\n\n function with_calldata(StdStorage storage self, bytes memory _calldata) internal returns (StdStorage storage) {\n self._calldata = _calldata;\n return self;\n }\n\n function with_key(StdStorage storage self, address who) internal returns (StdStorage storage) {\n self._keys.push(bytes32(uint256(uint160(who))));\n return self;\n }\n\n function with_key(StdStorage storage self, uint256 amt) internal returns (StdStorage storage) {\n self._keys.push(bytes32(amt));\n return self;\n }\n\n function with_key(StdStorage storage self, bytes32 key) internal returns (StdStorage storage) {\n self._keys.push(key);\n return self;\n }\n\n function enable_packed_slots(StdStorage storage self) internal returns (StdStorage storage) {\n self._enable_packed_slots = true;\n return self;\n }\n\n function depth(StdStorage storage self, uint256 _depth) internal returns (StdStorage storage) {\n self._depth = _depth;\n return self;\n }\n\n function read(StdStorage storage self) private returns (bytes memory) {\n FindData storage data = find(self, false);\n uint256 mask = getMaskByOffsets(data.offsetLeft, data.offsetRight);\n uint256 value = (uint256(vm.load(self._target, bytes32(data.slot))) & mask) >> data.offsetRight;\n clear(self);\n return abi.encode(value);\n }\n\n function read_bytes32(StdStorage storage self) internal returns (bytes32) {\n return abi.decode(read(self), (bytes32));\n }\n\n function read_bool(StdStorage storage self) internal returns (bool) {\n int256 v = read_int(self);\n if (v == 0) return false;\n if (v == 1) return true;\n revert(\"stdStorage read_bool(StdStorage): Cannot decode. Make sure you are reading a bool.\");\n }\n\n function read_address(StdStorage storage self) internal returns (address) {\n return abi.decode(read(self), (address));\n }\n\n function read_uint(StdStorage storage self) internal returns (uint256) {\n return abi.decode(read(self), (uint256));\n }\n\n function read_int(StdStorage storage self) internal returns (int256) {\n return abi.decode(read(self), (int256));\n }\n\n function parent(StdStorage storage self) internal returns (uint256, bytes32) {\n address who = self._target;\n uint256 field_depth = self._depth;\n vm.startMappingRecording();\n uint256 child = find(self, true).slot - field_depth;\n (bool found, bytes32 key, bytes32 parent_slot) = vm.getMappingKeyAndParentOf(who, bytes32(child));\n if (!found) {\n revert(\n \"stdStorage read_bool(StdStorage): Cannot find parent. Make sure you give a slot and startMappingRecording() has been called.\"\n );\n }\n return (uint256(parent_slot), key);\n }\n\n function root(StdStorage storage self) internal returns (uint256) {\n address who = self._target;\n uint256 field_depth = self._depth;\n vm.startMappingRecording();\n uint256 child = find(self, true).slot - field_depth;\n bool found;\n bytes32 root_slot;\n bytes32 parent_slot;\n (found,, parent_slot) = vm.getMappingKeyAndParentOf(who, bytes32(child));\n if (!found) {\n revert(\n \"stdStorage read_bool(StdStorage): Cannot find parent. Make sure you give a slot and startMappingRecording() has been called.\"\n );\n }\n while (found) {\n root_slot = parent_slot;\n (found,, parent_slot) = vm.getMappingKeyAndParentOf(who, bytes32(root_slot));\n }\n return uint256(root_slot);\n }\n\n function bytesToBytes32(bytes memory b, uint256 offset) private pure returns (bytes32) {\n bytes32 out;\n\n uint256 max = b.length > 32 ? 32 : b.length;\n for (uint256 i = 0; i < max; i++) {\n out |= bytes32(b[offset + i] & 0xFF) >> (i * 8);\n }\n return out;\n }\n\n function flatten(bytes32[] memory b) private pure returns (bytes memory) {\n bytes memory result = new bytes(b.length * 32);\n for (uint256 i = 0; i < b.length; i++) {\n bytes32 k = b[i];\n /// @solidity memory-safe-assembly\n assembly {\n mstore(add(result, add(32, mul(32, i))), k)\n }\n }\n\n return result;\n }\n\n function clear(StdStorage storage self) internal {\n delete self._target;\n delete self._sig;\n delete self._keys;\n delete self._depth;\n delete self._enable_packed_slots;\n delete self._calldata;\n }\n\n // Returns mask which contains non-zero bits for values between `offsetLeft` and `offsetRight`\n // (slotValue & mask) >> offsetRight will be the value of the given packed variable\n function getMaskByOffsets(uint256 offsetLeft, uint256 offsetRight) internal pure returns (uint256 mask) {\n // mask = ((1 << (256 - (offsetRight + offsetLeft))) - 1) << offsetRight;\n // using assembly because (1 << 256) causes overflow\n assembly {\n mask := shl(offsetRight, sub(shl(sub(256, add(offsetRight, offsetLeft)), 1), 1))\n }\n }\n\n // Returns slot value with updated packed variable.\n function getUpdatedSlotValue(bytes32 curValue, uint256 varValue, uint256 offsetLeft, uint256 offsetRight)\n internal\n pure\n returns (bytes32 newValue)\n {\n return bytes32((uint256(curValue) & ~getMaskByOffsets(offsetLeft, offsetRight)) | (varValue << offsetRight));\n }\n}\n\nlibrary stdStorage {\n Vm private constant vm = Vm(address(uint160(uint256(keccak256(\"hevm cheat code\")))));\n\n function sigs(string memory sigStr) internal pure returns (bytes4) {\n return stdStorageSafe.sigs(sigStr);\n }\n\n function find(StdStorage storage self) internal returns (uint256) {\n return find(self, true);\n }\n\n function find(StdStorage storage self, bool _clear) internal returns (uint256) {\n return stdStorageSafe.find(self, _clear).slot;\n }\n\n function target(StdStorage storage self, address _target) internal returns (StdStorage storage) {\n return stdStorageSafe.target(self, _target);\n }\n\n function sig(StdStorage storage self, bytes4 _sig) internal returns (StdStorage storage) {\n return stdStorageSafe.sig(self, _sig);\n }\n\n function sig(StdStorage storage self, string memory _sig) internal returns (StdStorage storage) {\n return stdStorageSafe.sig(self, _sig);\n }\n\n function with_key(StdStorage storage self, address who) internal returns (StdStorage storage) {\n return stdStorageSafe.with_key(self, who);\n }\n\n function with_key(StdStorage storage self, uint256 amt) internal returns (StdStorage storage) {\n return stdStorageSafe.with_key(self, amt);\n }\n\n function with_key(StdStorage storage self, bytes32 key) internal returns (StdStorage storage) {\n return stdStorageSafe.with_key(self, key);\n }\n\n function with_calldata(StdStorage storage self, bytes memory _calldata) internal returns (StdStorage storage) {\n return stdStorageSafe.with_calldata(self, _calldata);\n }\n\n function enable_packed_slots(StdStorage storage self) internal returns (StdStorage storage) {\n return stdStorageSafe.enable_packed_slots(self);\n }\n\n function depth(StdStorage storage self, uint256 _depth) internal returns (StdStorage storage) {\n return stdStorageSafe.depth(self, _depth);\n }\n\n function clear(StdStorage storage self) internal {\n stdStorageSafe.clear(self);\n }\n\n function checked_write(StdStorage storage self, address who) internal {\n checked_write(self, bytes32(uint256(uint160(who))));\n }\n\n function checked_write(StdStorage storage self, uint256 amt) internal {\n checked_write(self, bytes32(amt));\n }\n\n function checked_write_int(StdStorage storage self, int256 val) internal {\n checked_write(self, bytes32(uint256(val)));\n }\n\n function checked_write(StdStorage storage self, bool write) internal {\n bytes32 t;\n /// @solidity memory-safe-assembly\n assembly {\n t := write\n }\n checked_write(self, t);\n }\n\n function checked_write(StdStorage storage self, bytes32 set) internal {\n address who = self._target;\n bytes4 fsig = self._sig;\n uint256 field_depth = self._depth;\n bytes memory params = stdStorageSafe.getCallParams(self);\n\n if (!self.finds[who][fsig][keccak256(abi.encodePacked(params, field_depth))].found) {\n find(self, false);\n }\n FindData storage data = self.finds[who][fsig][keccak256(abi.encodePacked(params, field_depth))];\n if ((data.offsetLeft + data.offsetRight) > 0) {\n uint256 maxVal = 2 ** (256 - (data.offsetLeft + data.offsetRight));\n require(\n uint256(set) < maxVal,\n string(\n abi.encodePacked(\n \"stdStorage find(StdStorage): Packed slot. We can't fit value greater than \",\n vm.toString(maxVal)\n )\n )\n );\n }\n bytes32 curVal = vm.load(who, bytes32(data.slot));\n bytes32 valToSet = stdStorageSafe.getUpdatedSlotValue(curVal, uint256(set), data.offsetLeft, data.offsetRight);\n\n vm.store(who, bytes32(data.slot), valToSet);\n\n (bool success, bytes32 callResult) = stdStorageSafe.callTarget(self);\n\n if (!success || callResult != set) {\n vm.store(who, bytes32(data.slot), curVal);\n revert(\"stdStorage find(StdStorage): Failed to write value.\");\n }\n clear(self);\n }\n\n function read_bytes32(StdStorage storage self) internal returns (bytes32) {\n return stdStorageSafe.read_bytes32(self);\n }\n\n function read_bool(StdStorage storage self) internal returns (bool) {\n return stdStorageSafe.read_bool(self);\n }\n\n function read_address(StdStorage storage self) internal returns (address) {\n return stdStorageSafe.read_address(self);\n }\n\n function read_uint(StdStorage storage self) internal returns (uint256) {\n return stdStorageSafe.read_uint(self);\n }\n\n function read_int(StdStorage storage self) internal returns (int256) {\n return stdStorageSafe.read_int(self);\n }\n\n function parent(StdStorage storage self) internal returns (uint256, bytes32) {\n return stdStorageSafe.parent(self);\n }\n\n function root(StdStorage storage self) internal returns (uint256) {\n return stdStorageSafe.root(self);\n }\n}\n","license":"MIT"},"lib/forge-std/src/StdStyle.sol":{"keccak256":"0x43e2a8a9b9c2574dabe74f11adf6f782df218f463540e3b5b563609fe108597d","urls":[],"content":"// SPDX-License-Identifier: MIT\npragma solidity >=0.4.22 <0.9.0;\n\nimport {VmSafe} from \"./Vm.sol\";\n\nlibrary StdStyle {\n VmSafe private constant vm = VmSafe(address(uint160(uint256(keccak256(\"hevm cheat code\")))));\n\n string constant RED = \"\\u001b[91m\";\n string constant GREEN = \"\\u001b[92m\";\n string constant YELLOW = \"\\u001b[93m\";\n string constant BLUE = \"\\u001b[94m\";\n string constant MAGENTA = \"\\u001b[95m\";\n string constant CYAN = \"\\u001b[96m\";\n string constant BOLD = \"\\u001b[1m\";\n string constant DIM = \"\\u001b[2m\";\n string constant ITALIC = \"\\u001b[3m\";\n string constant UNDERLINE = \"\\u001b[4m\";\n string constant INVERSE = \"\\u001b[7m\";\n string constant RESET = \"\\u001b[0m\";\n\n function styleConcat(string memory style, string memory self) private pure returns (string memory) {\n return string(abi.encodePacked(style, self, RESET));\n }\n\n function red(string memory self) internal pure returns (string memory) {\n return styleConcat(RED, self);\n }\n\n function red(uint256 self) internal pure returns (string memory) {\n return red(vm.toString(self));\n }\n\n function red(int256 self) internal pure returns (string memory) {\n return red(vm.toString(self));\n }\n\n function red(address self) internal pure returns (string memory) {\n return red(vm.toString(self));\n }\n\n function red(bool self) internal pure returns (string memory) {\n return red(vm.toString(self));\n }\n\n function redBytes(bytes memory self) internal pure returns (string memory) {\n return red(vm.toString(self));\n }\n\n function redBytes32(bytes32 self) internal pure returns (string memory) {\n return red(vm.toString(self));\n }\n\n function green(string memory self) internal pure returns (string memory) {\n return styleConcat(GREEN, self);\n }\n\n function green(uint256 self) internal pure returns (string memory) {\n return green(vm.toString(self));\n }\n\n function green(int256 self) internal pure returns (string memory) {\n return green(vm.toString(self));\n }\n\n function green(address self) internal pure returns (string memory) {\n return green(vm.toString(self));\n }\n\n function green(bool self) internal pure returns (string memory) {\n return green(vm.toString(self));\n }\n\n function greenBytes(bytes memory self) internal pure returns (string memory) {\n return green(vm.toString(self));\n }\n\n function greenBytes32(bytes32 self) internal pure returns (string memory) {\n return green(vm.toString(self));\n }\n\n function yellow(string memory self) internal pure returns (string memory) {\n return styleConcat(YELLOW, self);\n }\n\n function yellow(uint256 self) internal pure returns (string memory) {\n return yellow(vm.toString(self));\n }\n\n function yellow(int256 self) internal pure returns (string memory) {\n return yellow(vm.toString(self));\n }\n\n function yellow(address self) internal pure returns (string memory) {\n return yellow(vm.toString(self));\n }\n\n function yellow(bool self) internal pure returns (string memory) {\n return yellow(vm.toString(self));\n }\n\n function yellowBytes(bytes memory self) internal pure returns (string memory) {\n return yellow(vm.toString(self));\n }\n\n function yellowBytes32(bytes32 self) internal pure returns (string memory) {\n return yellow(vm.toString(self));\n }\n\n function blue(string memory self) internal pure returns (string memory) {\n return styleConcat(BLUE, self);\n }\n\n function blue(uint256 self) internal pure returns (string memory) {\n return blue(vm.toString(self));\n }\n\n function blue(int256 self) internal pure returns (string memory) {\n return blue(vm.toString(self));\n }\n\n function blue(address self) internal pure returns (string memory) {\n return blue(vm.toString(self));\n }\n\n function blue(bool self) internal pure returns (string memory) {\n return blue(vm.toString(self));\n }\n\n function blueBytes(bytes memory self) internal pure returns (string memory) {\n return blue(vm.toString(self));\n }\n\n function blueBytes32(bytes32 self) internal pure returns (string memory) {\n return blue(vm.toString(self));\n }\n\n function magenta(string memory self) internal pure returns (string memory) {\n return styleConcat(MAGENTA, self);\n }\n\n function magenta(uint256 self) internal pure returns (string memory) {\n return magenta(vm.toString(self));\n }\n\n function magenta(int256 self) internal pure returns (string memory) {\n return magenta(vm.toString(self));\n }\n\n function magenta(address self) internal pure returns (string memory) {\n return magenta(vm.toString(self));\n }\n\n function magenta(bool self) internal pure returns (string memory) {\n return magenta(vm.toString(self));\n }\n\n function magentaBytes(bytes memory self) internal pure returns (string memory) {\n return magenta(vm.toString(self));\n }\n\n function magentaBytes32(bytes32 self) internal pure returns (string memory) {\n return magenta(vm.toString(self));\n }\n\n function cyan(string memory self) internal pure returns (string memory) {\n return styleConcat(CYAN, self);\n }\n\n function cyan(uint256 self) internal pure returns (string memory) {\n return cyan(vm.toString(self));\n }\n\n function cyan(int256 self) internal pure returns (string memory) {\n return cyan(vm.toString(self));\n }\n\n function cyan(address self) internal pure returns (string memory) {\n return cyan(vm.toString(self));\n }\n\n function cyan(bool self) internal pure returns (string memory) {\n return cyan(vm.toString(self));\n }\n\n function cyanBytes(bytes memory self) internal pure returns (string memory) {\n return cyan(vm.toString(self));\n }\n\n function cyanBytes32(bytes32 self) internal pure returns (string memory) {\n return cyan(vm.toString(self));\n }\n\n function bold(string memory self) internal pure returns (string memory) {\n return styleConcat(BOLD, self);\n }\n\n function bold(uint256 self) internal pure returns (string memory) {\n return bold(vm.toString(self));\n }\n\n function bold(int256 self) internal pure returns (string memory) {\n return bold(vm.toString(self));\n }\n\n function bold(address self) internal pure returns (string memory) {\n return bold(vm.toString(self));\n }\n\n function bold(bool self) internal pure returns (string memory) {\n return bold(vm.toString(self));\n }\n\n function boldBytes(bytes memory self) internal pure returns (string memory) {\n return bold(vm.toString(self));\n }\n\n function boldBytes32(bytes32 self) internal pure returns (string memory) {\n return bold(vm.toString(self));\n }\n\n function dim(string memory self) internal pure returns (string memory) {\n return styleConcat(DIM, self);\n }\n\n function dim(uint256 self) internal pure returns (string memory) {\n return dim(vm.toString(self));\n }\n\n function dim(int256 self) internal pure returns (string memory) {\n return dim(vm.toString(self));\n }\n\n function dim(address self) internal pure returns (string memory) {\n return dim(vm.toString(self));\n }\n\n function dim(bool self) internal pure returns (string memory) {\n return dim(vm.toString(self));\n }\n\n function dimBytes(bytes memory self) internal pure returns (string memory) {\n return dim(vm.toString(self));\n }\n\n function dimBytes32(bytes32 self) internal pure returns (string memory) {\n return dim(vm.toString(self));\n }\n\n function italic(string memory self) internal pure returns (string memory) {\n return styleConcat(ITALIC, self);\n }\n\n function italic(uint256 self) internal pure returns (string memory) {\n return italic(vm.toString(self));\n }\n\n function italic(int256 self) internal pure returns (string memory) {\n return italic(vm.toString(self));\n }\n\n function italic(address self) internal pure returns (string memory) {\n return italic(vm.toString(self));\n }\n\n function italic(bool self) internal pure returns (string memory) {\n return italic(vm.toString(self));\n }\n\n function italicBytes(bytes memory self) internal pure returns (string memory) {\n return italic(vm.toString(self));\n }\n\n function italicBytes32(bytes32 self) internal pure returns (string memory) {\n return italic(vm.toString(self));\n }\n\n function underline(string memory self) internal pure returns (string memory) {\n return styleConcat(UNDERLINE, self);\n }\n\n function underline(uint256 self) internal pure returns (string memory) {\n return underline(vm.toString(self));\n }\n\n function underline(int256 self) internal pure returns (string memory) {\n return underline(vm.toString(self));\n }\n\n function underline(address self) internal pure returns (string memory) {\n return underline(vm.toString(self));\n }\n\n function underline(bool self) internal pure returns (string memory) {\n return underline(vm.toString(self));\n }\n\n function underlineBytes(bytes memory self) internal pure returns (string memory) {\n return underline(vm.toString(self));\n }\n\n function underlineBytes32(bytes32 self) internal pure returns (string memory) {\n return underline(vm.toString(self));\n }\n\n function inverse(string memory self) internal pure returns (string memory) {\n return styleConcat(INVERSE, self);\n }\n\n function inverse(uint256 self) internal pure returns (string memory) {\n return inverse(vm.toString(self));\n }\n\n function inverse(int256 self) internal pure returns (string memory) {\n return inverse(vm.toString(self));\n }\n\n function inverse(address self) internal pure returns (string memory) {\n return inverse(vm.toString(self));\n }\n\n function inverse(bool self) internal pure returns (string memory) {\n return inverse(vm.toString(self));\n }\n\n function inverseBytes(bytes memory self) internal pure returns (string memory) {\n return inverse(vm.toString(self));\n }\n\n function inverseBytes32(bytes32 self) internal pure returns (string memory) {\n return inverse(vm.toString(self));\n }\n}\n","license":"MIT"},"lib/forge-std/src/StdUtils.sol":{"keccak256":"0x7274081e11c05164fd8eadde4de8305c033e58a43008dea58065f3170ccf0737","urls":[],"content":"// SPDX-License-Identifier: MIT\npragma solidity >=0.6.2 <0.9.0;\n\npragma experimental ABIEncoderV2;\n\nimport {IMulticall3} from \"./interfaces/IMulticall3.sol\";\nimport {VmSafe} from \"./Vm.sol\";\n\nabstract contract StdUtils {\n /*//////////////////////////////////////////////////////////////////////////\n CONSTANTS\n //////////////////////////////////////////////////////////////////////////*/\n\n IMulticall3 private constant multicall = IMulticall3(0xcA11bde05977b3631167028862bE2a173976CA11);\n VmSafe private constant vm = VmSafe(address(uint160(uint256(keccak256(\"hevm cheat code\")))));\n address private constant CONSOLE2_ADDRESS = 0x000000000000000000636F6e736F6c652e6c6f67;\n uint256 private constant INT256_MIN_ABS =\n 57896044618658097711785492504343953926634992332820282019728792003956564819968;\n uint256 private constant SECP256K1_ORDER =\n 115792089237316195423570985008687907852837564279074904382605163141518161494337;\n uint256 private constant UINT256_MAX =\n 115792089237316195423570985008687907853269984665640564039457584007913129639935;\n\n // Used by default when deploying with create2, https://github.com/Arachnid/deterministic-deployment-proxy.\n address private constant CREATE2_FACTORY = 0x4e59b44847b379578588920cA78FbF26c0B4956C;\n\n /*//////////////////////////////////////////////////////////////////////////\n INTERNAL FUNCTIONS\n //////////////////////////////////////////////////////////////////////////*/\n\n function _bound(uint256 x, uint256 min, uint256 max) internal pure virtual returns (uint256 result) {\n require(min <= max, \"StdUtils bound(uint256,uint256,uint256): Max is less than min.\");\n // If x is between min and max, return x directly. This is to ensure that dictionary values\n // do not get shifted if the min is nonzero. More info: https://github.com/foundry-rs/forge-std/issues/188\n if (x >= min && x <= max) return x;\n\n uint256 size = max - min + 1;\n\n // If the value is 0, 1, 2, 3, wrap that to min, min+1, min+2, min+3. Similarly for the UINT256_MAX side.\n // This helps ensure coverage of the min/max values.\n if (x <= 3 && size > x) return min + x;\n if (x >= UINT256_MAX - 3 && size > UINT256_MAX - x) return max - (UINT256_MAX - x);\n\n // Otherwise, wrap x into the range [min, max], i.e. the range is inclusive.\n if (x > max) {\n uint256 diff = x - max;\n uint256 rem = diff % size;\n if (rem == 0) return max;\n result = min + rem - 1;\n } else if (x < min) {\n uint256 diff = min - x;\n uint256 rem = diff % size;\n if (rem == 0) return min;\n result = max - rem + 1;\n }\n }\n\n function bound(uint256 x, uint256 min, uint256 max) internal pure virtual returns (uint256 result) {\n result = _bound(x, min, max);\n console2_log_StdUtils(\"Bound result\", result);\n }\n\n function _bound(int256 x, int256 min, int256 max) internal pure virtual returns (int256 result) {\n require(min <= max, \"StdUtils bound(int256,int256,int256): Max is less than min.\");\n\n // Shifting all int256 values to uint256 to use _bound function. The range of two types are:\n // int256 : -(2**255) ~ (2**255 - 1)\n // uint256: 0 ~ (2**256 - 1)\n // So, add 2**255, INT256_MIN_ABS to the integer values.\n //\n // If the given integer value is -2**255, we cannot use `-uint256(-x)` because of the overflow.\n // So, use `~uint256(x) + 1` instead.\n uint256 _x = x < 0 ? (INT256_MIN_ABS - ~uint256(x) - 1) : (uint256(x) + INT256_MIN_ABS);\n uint256 _min = min < 0 ? (INT256_MIN_ABS - ~uint256(min) - 1) : (uint256(min) + INT256_MIN_ABS);\n uint256 _max = max < 0 ? (INT256_MIN_ABS - ~uint256(max) - 1) : (uint256(max) + INT256_MIN_ABS);\n\n uint256 y = _bound(_x, _min, _max);\n\n // To move it back to int256 value, subtract INT256_MIN_ABS at here.\n result = y < INT256_MIN_ABS ? int256(~(INT256_MIN_ABS - y) + 1) : int256(y - INT256_MIN_ABS);\n }\n\n function bound(int256 x, int256 min, int256 max) internal pure virtual returns (int256 result) {\n result = _bound(x, min, max);\n console2_log_StdUtils(\"Bound result\", vm.toString(result));\n }\n\n function boundPrivateKey(uint256 privateKey) internal pure virtual returns (uint256 result) {\n result = _bound(privateKey, 1, SECP256K1_ORDER - 1);\n }\n\n function bytesToUint(bytes memory b) internal pure virtual returns (uint256) {\n require(b.length <= 32, \"StdUtils bytesToUint(bytes): Bytes length exceeds 32.\");\n return abi.decode(abi.encodePacked(new bytes(32 - b.length), b), (uint256));\n }\n\n /// @dev Compute the address a contract will be deployed at for a given deployer address and nonce\n /// @notice adapted from Solmate implementation (https://github.com/Rari-Capital/solmate/blob/main/src/utils/LibRLP.sol)\n function computeCreateAddress(address deployer, uint256 nonce) internal pure virtual returns (address) {\n console2_log_StdUtils(\"computeCreateAddress is deprecated. Please use vm.computeCreateAddress instead.\");\n return vm.computeCreateAddress(deployer, nonce);\n }\n\n function computeCreate2Address(bytes32 salt, bytes32 initcodeHash, address deployer)\n internal\n pure\n virtual\n returns (address)\n {\n console2_log_StdUtils(\"computeCreate2Address is deprecated. Please use vm.computeCreate2Address instead.\");\n return vm.computeCreate2Address(salt, initcodeHash, deployer);\n }\n\n /// @dev returns the address of a contract created with CREATE2 using the default CREATE2 deployer\n function computeCreate2Address(bytes32 salt, bytes32 initCodeHash) internal pure returns (address) {\n console2_log_StdUtils(\"computeCreate2Address is deprecated. Please use vm.computeCreate2Address instead.\");\n return vm.computeCreate2Address(salt, initCodeHash);\n }\n\n /// @dev returns the hash of the init code (creation code + no args) used in CREATE2 with no constructor arguments\n /// @param creationCode the creation code of a contract C, as returned by type(C).creationCode\n function hashInitCode(bytes memory creationCode) internal pure returns (bytes32) {\n return hashInitCode(creationCode, \"\");\n }\n\n /// @dev returns the hash of the init code (creation code + ABI-encoded args) used in CREATE2\n /// @param creationCode the creation code of a contract C, as returned by type(C).creationCode\n /// @param args the ABI-encoded arguments to the constructor of C\n function hashInitCode(bytes memory creationCode, bytes memory args) internal pure returns (bytes32) {\n return keccak256(abi.encodePacked(creationCode, args));\n }\n\n // Performs a single call with Multicall3 to query the ERC-20 token balances of the given addresses.\n function getTokenBalances(address token, address[] memory addresses)\n internal\n virtual\n returns (uint256[] memory balances)\n {\n uint256 tokenCodeSize;\n assembly {\n tokenCodeSize := extcodesize(token)\n }\n require(tokenCodeSize > 0, \"StdUtils getTokenBalances(address,address[]): Token address is not a contract.\");\n\n // ABI encode the aggregate call to Multicall3.\n uint256 length = addresses.length;\n IMulticall3.Call[] memory calls = new IMulticall3.Call[](length);\n for (uint256 i = 0; i < length; ++i) {\n // 0x70a08231 = bytes4(\"balanceOf(address)\"))\n calls[i] = IMulticall3.Call({target: token, callData: abi.encodeWithSelector(0x70a08231, (addresses[i]))});\n }\n\n // Make the aggregate call.\n (, bytes[] memory returnData) = multicall.aggregate(calls);\n\n // ABI decode the return data and return the balances.\n balances = new uint256[](length);\n for (uint256 i = 0; i < length; ++i) {\n balances[i] = abi.decode(returnData[i], (uint256));\n }\n }\n\n /*//////////////////////////////////////////////////////////////////////////\n PRIVATE FUNCTIONS\n //////////////////////////////////////////////////////////////////////////*/\n\n function addressFromLast20Bytes(bytes32 bytesValue) private pure returns (address) {\n return address(uint160(uint256(bytesValue)));\n }\n\n // This section is used to prevent the compilation of console, which shortens the compilation time when console is\n // not used elsewhere. We also trick the compiler into letting us make the console log methods as `pure` to avoid\n // any breaking changes to function signatures.\n function _castLogPayloadViewToPure(function(bytes memory) internal view fnIn)\n internal\n pure\n returns (function(bytes memory) internal pure fnOut)\n {\n assembly {\n fnOut := fnIn\n }\n }\n\n function _sendLogPayload(bytes memory payload) internal pure {\n _castLogPayloadViewToPure(_sendLogPayloadView)(payload);\n }\n\n function _sendLogPayloadView(bytes memory payload) private view {\n uint256 payloadLength = payload.length;\n address consoleAddress = CONSOLE2_ADDRESS;\n /// @solidity memory-safe-assembly\n assembly {\n let payloadStart := add(payload, 32)\n let r := staticcall(gas(), consoleAddress, payloadStart, payloadLength, 0, 0)\n }\n }\n\n function console2_log_StdUtils(string memory p0) private pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string)\", p0));\n }\n\n function console2_log_StdUtils(string memory p0, uint256 p1) private pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,uint256)\", p0, p1));\n }\n\n function console2_log_StdUtils(string memory p0, string memory p1) private pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,string)\", p0, p1));\n }\n}\n","license":"MIT"},"lib/forge-std/src/Vm.sol":{"keccak256":"0xd91fb0df409fbd22463e937b48b9682d9333c5d4528d8fe7b36102a0323c44bf","urls":[],"content":"// Automatically @generated by scripts/vm.py. Do not modify manually.\n\n// SPDX-License-Identifier: MIT OR Apache-2.0\npragma solidity >=0.6.2 <0.9.0;\npragma experimental ABIEncoderV2;\n\n/// The `VmSafe` interface does not allow manipulation of the EVM state or other actions that may\n/// result in Script simulations differing from on-chain execution. It is recommended to only use\n/// these cheats in scripts.\ninterface VmSafe {\n /// A modification applied to either `msg.sender` or `tx.origin`. Returned by `readCallers`.\n enum CallerMode {\n // No caller modification is currently active.\n None,\n // A one time broadcast triggered by a `vm.broadcast()` call is currently active.\n Broadcast,\n // A recurrent broadcast triggered by a `vm.startBroadcast()` call is currently active.\n RecurrentBroadcast,\n // A one time prank triggered by a `vm.prank()` call is currently active.\n Prank,\n // A recurrent prank triggered by a `vm.startPrank()` call is currently active.\n RecurrentPrank\n }\n\n /// The kind of account access that occurred.\n enum AccountAccessKind {\n // The account was called.\n Call,\n // The account was called via delegatecall.\n DelegateCall,\n // The account was called via callcode.\n CallCode,\n // The account was called via staticcall.\n StaticCall,\n // The account was created.\n Create,\n // The account was selfdestructed.\n SelfDestruct,\n // Synthetic access indicating the current context has resumed after a previous sub-context (AccountAccess).\n Resume,\n // The account's balance was read.\n Balance,\n // The account's codesize was read.\n Extcodesize,\n // The account's codehash was read.\n Extcodehash,\n // The account's code was copied.\n Extcodecopy\n }\n\n /// Forge execution contexts.\n enum ForgeContext {\n // Test group execution context (test, coverage or snapshot).\n TestGroup,\n // `forge test` execution context.\n Test,\n // `forge coverage` execution context.\n Coverage,\n // `forge snapshot` execution context.\n Snapshot,\n // Script group execution context (dry run, broadcast or resume).\n ScriptGroup,\n // `forge script` execution context.\n ScriptDryRun,\n // `forge script --broadcast` execution context.\n ScriptBroadcast,\n // `forge script --resume` execution context.\n ScriptResume,\n // Unknown `forge` execution context.\n Unknown\n }\n\n /// The transaction type (`txType`) of the broadcast.\n enum BroadcastTxType {\n // Represents a CALL broadcast tx.\n Call,\n // Represents a CREATE broadcast tx.\n Create,\n // Represents a CREATE2 broadcast tx.\n Create2\n }\n\n /// An Ethereum log. Returned by `getRecordedLogs`.\n struct Log {\n // The topics of the log, including the signature, if any.\n bytes32[] topics;\n // The raw data of the log.\n bytes data;\n // The address of the log's emitter.\n address emitter;\n }\n\n /// An RPC URL and its alias. Returned by `rpcUrlStructs`.\n struct Rpc {\n // The alias of the RPC URL.\n string key;\n // The RPC URL.\n string url;\n }\n\n /// An RPC log object. Returned by `eth_getLogs`.\n struct EthGetLogs {\n // The address of the log's emitter.\n address emitter;\n // The topics of the log, including the signature, if any.\n bytes32[] topics;\n // The raw data of the log.\n bytes data;\n // The block hash.\n bytes32 blockHash;\n // The block number.\n uint64 blockNumber;\n // The transaction hash.\n bytes32 transactionHash;\n // The transaction index in the block.\n uint64 transactionIndex;\n // The log index.\n uint256 logIndex;\n // Whether the log was removed.\n bool removed;\n }\n\n /// A single entry in a directory listing. Returned by `readDir`.\n struct DirEntry {\n // The error message, if any.\n string errorMessage;\n // The path of the entry.\n string path;\n // The depth of the entry.\n uint64 depth;\n // Whether the entry is a directory.\n bool isDir;\n // Whether the entry is a symlink.\n bool isSymlink;\n }\n\n /// Metadata information about a file.\n /// This structure is returned from the `fsMetadata` function and represents known\n /// metadata about a file such as its permissions, size, modification\n /// times, etc.\n struct FsMetadata {\n // True if this metadata is for a directory.\n bool isDir;\n // True if this metadata is for a symlink.\n bool isSymlink;\n // The size of the file, in bytes, this metadata is for.\n uint256 length;\n // True if this metadata is for a readonly (unwritable) file.\n bool readOnly;\n // The last modification time listed in this metadata.\n uint256 modified;\n // The last access time of this metadata.\n uint256 accessed;\n // The creation time listed in this metadata.\n uint256 created;\n }\n\n /// A wallet with a public and private key.\n struct Wallet {\n // The wallet's address.\n address addr;\n // The wallet's public key `X`.\n uint256 publicKeyX;\n // The wallet's public key `Y`.\n uint256 publicKeyY;\n // The wallet's private key.\n uint256 privateKey;\n }\n\n /// The result of a `tryFfi` call.\n struct FfiResult {\n // The exit code of the call.\n int32 exitCode;\n // The optionally hex-decoded `stdout` data.\n bytes stdout;\n // The `stderr` data.\n bytes stderr;\n }\n\n /// Information on the chain and fork.\n struct ChainInfo {\n // The fork identifier. Set to zero if no fork is active.\n uint256 forkId;\n // The chain ID of the current fork.\n uint256 chainId;\n }\n\n /// The result of a `stopAndReturnStateDiff` call.\n struct AccountAccess {\n // The chain and fork the access occurred.\n ChainInfo chainInfo;\n // The kind of account access that determines what the account is.\n // If kind is Call, DelegateCall, StaticCall or CallCode, then the account is the callee.\n // If kind is Create, then the account is the newly created account.\n // If kind is SelfDestruct, then the account is the selfdestruct recipient.\n // If kind is a Resume, then account represents a account context that has resumed.\n AccountAccessKind kind;\n // The account that was accessed.\n // It's either the account created, callee or a selfdestruct recipient for CREATE, CALL or SELFDESTRUCT.\n address account;\n // What accessed the account.\n address accessor;\n // If the account was initialized or empty prior to the access.\n // An account is considered initialized if it has code, a\n // non-zero nonce, or a non-zero balance.\n bool initialized;\n // The previous balance of the accessed account.\n uint256 oldBalance;\n // The potential new balance of the accessed account.\n // That is, all balance changes are recorded here, even if reverts occurred.\n uint256 newBalance;\n // Code of the account deployed by CREATE.\n bytes deployedCode;\n // Value passed along with the account access\n uint256 value;\n // Input data provided to the CREATE or CALL\n bytes data;\n // If this access reverted in either the current or parent context.\n bool reverted;\n // An ordered list of storage accesses made during an account access operation.\n StorageAccess[] storageAccesses;\n // Call depth traversed during the recording of state differences\n uint64 depth;\n }\n\n /// The storage accessed during an `AccountAccess`.\n struct StorageAccess {\n // The account whose storage was accessed.\n address account;\n // The slot that was accessed.\n bytes32 slot;\n // If the access was a write.\n bool isWrite;\n // The previous value of the slot.\n bytes32 previousValue;\n // The new value of the slot.\n bytes32 newValue;\n // If the access was reverted.\n bool reverted;\n }\n\n /// Gas used. Returned by `lastCallGas`.\n struct Gas {\n // The gas limit of the call.\n uint64 gasLimit;\n // The total gas used.\n uint64 gasTotalUsed;\n // DEPRECATED: The amount of gas used for memory expansion. Ref: \n uint64 gasMemoryUsed;\n // The amount of gas refunded.\n int64 gasRefunded;\n // The amount of gas remaining.\n uint64 gasRemaining;\n }\n\n /// The result of the `stopDebugTraceRecording` call\n struct DebugStep {\n // The stack before executing the step of the run.\n // stack\\[0\\] represents the top of the stack.\n // and only stack data relevant to the opcode execution is contained.\n uint256[] stack;\n // The memory input data before executing the step of the run.\n // only input data relevant to the opcode execution is contained.\n // e.g. for MLOAD, it will have memory\\[offset:offset+32\\] copied here.\n // the offset value can be get by the stack data.\n bytes memoryInput;\n // The opcode that was accessed.\n uint8 opcode;\n // The call depth of the step.\n uint64 depth;\n // Whether the call end up with out of gas error.\n bool isOutOfGas;\n // The contract address where the opcode is running\n address contractAddr;\n }\n\n /// Represents a transaction's broadcast details.\n struct BroadcastTxSummary {\n // The hash of the transaction that was broadcasted\n bytes32 txHash;\n // Represent the type of transaction among CALL, CREATE, CREATE2\n BroadcastTxType txType;\n // The address of the contract that was called or created.\n // This is address of the contract that is created if the txType is CREATE or CREATE2.\n address contractAddress;\n // The block number the transaction landed in.\n uint64 blockNumber;\n // Status of the transaction, retrieved from the transaction receipt.\n bool success;\n }\n\n /// Holds a signed EIP-7702 authorization for an authority account to delegate to an implementation.\n struct SignedDelegation {\n // The y-parity of the recovered secp256k1 signature (0 or 1).\n uint8 v;\n // First 32 bytes of the signature.\n bytes32 r;\n // Second 32 bytes of the signature.\n bytes32 s;\n // The current nonce of the authority account at signing time.\n // Used to ensure signature can't be replayed after account nonce changes.\n uint64 nonce;\n // Address of the contract implementation that will be delegated to.\n // Gets encoded into delegation code: 0xef0100 || implementation.\n address implementation;\n }\n\n /// Represents a \"potential\" revert reason from a single subsequent call when using `vm.assumeNoReverts`.\n /// Reverts that match will result in a FOUNDRY::ASSUME rejection, whereas unmatched reverts will be surfaced\n /// as normal.\n struct PotentialRevert {\n // The allowed origin of the revert opcode; address(0) allows reverts from any address\n address reverter;\n // When true, only matches on the beginning of the revert data, otherwise, matches on entire revert data\n bool partialMatch;\n // The data to use to match encountered reverts\n bytes revertData;\n }\n\n /// An EIP-2930 access list item.\n struct AccessListItem {\n // The address to be added in access list.\n address target;\n // The storage keys to be added in access list.\n bytes32[] storageKeys;\n }\n\n // ======== Crypto ========\n\n /// Derives a private key from the name, labels the account with that name, and returns the wallet.\n function createWallet(string calldata walletLabel) external returns (Wallet memory wallet);\n\n /// Generates a wallet from the private key and returns the wallet.\n function createWallet(uint256 privateKey) external returns (Wallet memory wallet);\n\n /// Generates a wallet from the private key, labels the account with that name, and returns the wallet.\n function createWallet(uint256 privateKey, string calldata walletLabel) external returns (Wallet memory wallet);\n\n /// Derive a private key from a provided mnenomic string (or mnenomic file path)\n /// at the derivation path `m/44'/60'/0'/0/{index}`.\n function deriveKey(string calldata mnemonic, uint32 index) external pure returns (uint256 privateKey);\n\n /// Derive a private key from a provided mnenomic string (or mnenomic file path)\n /// at `{derivationPath}{index}`.\n function deriveKey(string calldata mnemonic, string calldata derivationPath, uint32 index)\n external\n pure\n returns (uint256 privateKey);\n\n /// Derive a private key from a provided mnenomic string (or mnenomic file path) in the specified language\n /// at the derivation path `m/44'/60'/0'/0/{index}`.\n function deriveKey(string calldata mnemonic, uint32 index, string calldata language)\n external\n pure\n returns (uint256 privateKey);\n\n /// Derive a private key from a provided mnenomic string (or mnenomic file path) in the specified language\n /// at `{derivationPath}{index}`.\n function deriveKey(string calldata mnemonic, string calldata derivationPath, uint32 index, string calldata language)\n external\n pure\n returns (uint256 privateKey);\n\n /// Derives secp256r1 public key from the provided `privateKey`.\n function publicKeyP256(uint256 privateKey) external pure returns (uint256 publicKeyX, uint256 publicKeyY);\n\n /// Adds a private key to the local forge wallet and returns the address.\n function rememberKey(uint256 privateKey) external returns (address keyAddr);\n\n /// Derive a set number of wallets from a mnemonic at the derivation path `m/44'/60'/0'/0/{0..count}`.\n /// The respective private keys are saved to the local forge wallet for later use and their addresses are returned.\n function rememberKeys(string calldata mnemonic, string calldata derivationPath, uint32 count)\n external\n returns (address[] memory keyAddrs);\n\n /// Derive a set number of wallets from a mnemonic in the specified language at the derivation path `m/44'/60'/0'/0/{0..count}`.\n /// The respective private keys are saved to the local forge wallet for later use and their addresses are returned.\n function rememberKeys(\n string calldata mnemonic,\n string calldata derivationPath,\n string calldata language,\n uint32 count\n ) external returns (address[] memory keyAddrs);\n\n /// Signs data with a `Wallet`.\n /// Returns a compact signature (`r`, `vs`) as per EIP-2098, where `vs` encodes both the\n /// signature's `s` value, and the recovery id `v` in a single bytes32.\n /// This format reduces the signature size from 65 to 64 bytes.\n function signCompact(Wallet calldata wallet, bytes32 digest) external returns (bytes32 r, bytes32 vs);\n\n /// Signs `digest` with `privateKey` using the secp256k1 curve.\n /// Returns a compact signature (`r`, `vs`) as per EIP-2098, where `vs` encodes both the\n /// signature's `s` value, and the recovery id `v` in a single bytes32.\n /// This format reduces the signature size from 65 to 64 bytes.\n function signCompact(uint256 privateKey, bytes32 digest) external pure returns (bytes32 r, bytes32 vs);\n\n /// Signs `digest` with signer provided to script using the secp256k1 curve.\n /// Returns a compact signature (`r`, `vs`) as per EIP-2098, where `vs` encodes both the\n /// signature's `s` value, and the recovery id `v` in a single bytes32.\n /// This format reduces the signature size from 65 to 64 bytes.\n /// If `--sender` is provided, the signer with provided address is used, otherwise,\n /// if exactly one signer is provided to the script, that signer is used.\n /// Raises error if signer passed through `--sender` does not match any unlocked signers or\n /// if `--sender` is not provided and not exactly one signer is passed to the script.\n function signCompact(bytes32 digest) external pure returns (bytes32 r, bytes32 vs);\n\n /// Signs `digest` with signer provided to script using the secp256k1 curve.\n /// Returns a compact signature (`r`, `vs`) as per EIP-2098, where `vs` encodes both the\n /// signature's `s` value, and the recovery id `v` in a single bytes32.\n /// This format reduces the signature size from 65 to 64 bytes.\n /// Raises error if none of the signers passed into the script have provided address.\n function signCompact(address signer, bytes32 digest) external pure returns (bytes32 r, bytes32 vs);\n\n /// Signs `digest` with `privateKey` using the secp256r1 curve.\n function signP256(uint256 privateKey, bytes32 digest) external pure returns (bytes32 r, bytes32 s);\n\n /// Signs data with a `Wallet`.\n function sign(Wallet calldata wallet, bytes32 digest) external returns (uint8 v, bytes32 r, bytes32 s);\n\n /// Signs `digest` with `privateKey` using the secp256k1 curve.\n function sign(uint256 privateKey, bytes32 digest) external pure returns (uint8 v, bytes32 r, bytes32 s);\n\n /// Signs `digest` with signer provided to script using the secp256k1 curve.\n /// If `--sender` is provided, the signer with provided address is used, otherwise,\n /// if exactly one signer is provided to the script, that signer is used.\n /// Raises error if signer passed through `--sender` does not match any unlocked signers or\n /// if `--sender` is not provided and not exactly one signer is passed to the script.\n function sign(bytes32 digest) external pure returns (uint8 v, bytes32 r, bytes32 s);\n\n /// Signs `digest` with signer provided to script using the secp256k1 curve.\n /// Raises error if none of the signers passed into the script have provided address.\n function sign(address signer, bytes32 digest) external pure returns (uint8 v, bytes32 r, bytes32 s);\n\n // ======== Environment ========\n\n /// Gets the environment variable `name` and parses it as `address`.\n /// Reverts if the variable was not found or could not be parsed.\n function envAddress(string calldata name) external view returns (address value);\n\n /// Gets the environment variable `name` and parses it as an array of `address`, delimited by `delim`.\n /// Reverts if the variable was not found or could not be parsed.\n function envAddress(string calldata name, string calldata delim) external view returns (address[] memory value);\n\n /// Gets the environment variable `name` and parses it as `bool`.\n /// Reverts if the variable was not found or could not be parsed.\n function envBool(string calldata name) external view returns (bool value);\n\n /// Gets the environment variable `name` and parses it as an array of `bool`, delimited by `delim`.\n /// Reverts if the variable was not found or could not be parsed.\n function envBool(string calldata name, string calldata delim) external view returns (bool[] memory value);\n\n /// Gets the environment variable `name` and parses it as `bytes32`.\n /// Reverts if the variable was not found or could not be parsed.\n function envBytes32(string calldata name) external view returns (bytes32 value);\n\n /// Gets the environment variable `name` and parses it as an array of `bytes32`, delimited by `delim`.\n /// Reverts if the variable was not found or could not be parsed.\n function envBytes32(string calldata name, string calldata delim) external view returns (bytes32[] memory value);\n\n /// Gets the environment variable `name` and parses it as `bytes`.\n /// Reverts if the variable was not found or could not be parsed.\n function envBytes(string calldata name) external view returns (bytes memory value);\n\n /// Gets the environment variable `name` and parses it as an array of `bytes`, delimited by `delim`.\n /// Reverts if the variable was not found or could not be parsed.\n function envBytes(string calldata name, string calldata delim) external view returns (bytes[] memory value);\n\n /// Gets the environment variable `name` and returns true if it exists, else returns false.\n function envExists(string calldata name) external view returns (bool result);\n\n /// Gets the environment variable `name` and parses it as `int256`.\n /// Reverts if the variable was not found or could not be parsed.\n function envInt(string calldata name) external view returns (int256 value);\n\n /// Gets the environment variable `name` and parses it as an array of `int256`, delimited by `delim`.\n /// Reverts if the variable was not found or could not be parsed.\n function envInt(string calldata name, string calldata delim) external view returns (int256[] memory value);\n\n /// Gets the environment variable `name` and parses it as `bool`.\n /// Reverts if the variable could not be parsed.\n /// Returns `defaultValue` if the variable was not found.\n function envOr(string calldata name, bool defaultValue) external view returns (bool value);\n\n /// Gets the environment variable `name` and parses it as `uint256`.\n /// Reverts if the variable could not be parsed.\n /// Returns `defaultValue` if the variable was not found.\n function envOr(string calldata name, uint256 defaultValue) external view returns (uint256 value);\n\n /// Gets the environment variable `name` and parses it as an array of `address`, delimited by `delim`.\n /// Reverts if the variable could not be parsed.\n /// Returns `defaultValue` if the variable was not found.\n function envOr(string calldata name, string calldata delim, address[] calldata defaultValue)\n external\n view\n returns (address[] memory value);\n\n /// Gets the environment variable `name` and parses it as an array of `bytes32`, delimited by `delim`.\n /// Reverts if the variable could not be parsed.\n /// Returns `defaultValue` if the variable was not found.\n function envOr(string calldata name, string calldata delim, bytes32[] calldata defaultValue)\n external\n view\n returns (bytes32[] memory value);\n\n /// Gets the environment variable `name` and parses it as an array of `string`, delimited by `delim`.\n /// Reverts if the variable could not be parsed.\n /// Returns `defaultValue` if the variable was not found.\n function envOr(string calldata name, string calldata delim, string[] calldata defaultValue)\n external\n view\n returns (string[] memory value);\n\n /// Gets the environment variable `name` and parses it as an array of `bytes`, delimited by `delim`.\n /// Reverts if the variable could not be parsed.\n /// Returns `defaultValue` if the variable was not found.\n function envOr(string calldata name, string calldata delim, bytes[] calldata defaultValue)\n external\n view\n returns (bytes[] memory value);\n\n /// Gets the environment variable `name` and parses it as `int256`.\n /// Reverts if the variable could not be parsed.\n /// Returns `defaultValue` if the variable was not found.\n function envOr(string calldata name, int256 defaultValue) external view returns (int256 value);\n\n /// Gets the environment variable `name` and parses it as `address`.\n /// Reverts if the variable could not be parsed.\n /// Returns `defaultValue` if the variable was not found.\n function envOr(string calldata name, address defaultValue) external view returns (address value);\n\n /// Gets the environment variable `name` and parses it as `bytes32`.\n /// Reverts if the variable could not be parsed.\n /// Returns `defaultValue` if the variable was not found.\n function envOr(string calldata name, bytes32 defaultValue) external view returns (bytes32 value);\n\n /// Gets the environment variable `name` and parses it as `string`.\n /// Reverts if the variable could not be parsed.\n /// Returns `defaultValue` if the variable was not found.\n function envOr(string calldata name, string calldata defaultValue) external view returns (string memory value);\n\n /// Gets the environment variable `name` and parses it as `bytes`.\n /// Reverts if the variable could not be parsed.\n /// Returns `defaultValue` if the variable was not found.\n function envOr(string calldata name, bytes calldata defaultValue) external view returns (bytes memory value);\n\n /// Gets the environment variable `name` and parses it as an array of `bool`, delimited by `delim`.\n /// Reverts if the variable could not be parsed.\n /// Returns `defaultValue` if the variable was not found.\n function envOr(string calldata name, string calldata delim, bool[] calldata defaultValue)\n external\n view\n returns (bool[] memory value);\n\n /// Gets the environment variable `name` and parses it as an array of `uint256`, delimited by `delim`.\n /// Reverts if the variable could not be parsed.\n /// Returns `defaultValue` if the variable was not found.\n function envOr(string calldata name, string calldata delim, uint256[] calldata defaultValue)\n external\n view\n returns (uint256[] memory value);\n\n /// Gets the environment variable `name` and parses it as an array of `int256`, delimited by `delim`.\n /// Reverts if the variable could not be parsed.\n /// Returns `defaultValue` if the variable was not found.\n function envOr(string calldata name, string calldata delim, int256[] calldata defaultValue)\n external\n view\n returns (int256[] memory value);\n\n /// Gets the environment variable `name` and parses it as `string`.\n /// Reverts if the variable was not found or could not be parsed.\n function envString(string calldata name) external view returns (string memory value);\n\n /// Gets the environment variable `name` and parses it as an array of `string`, delimited by `delim`.\n /// Reverts if the variable was not found or could not be parsed.\n function envString(string calldata name, string calldata delim) external view returns (string[] memory value);\n\n /// Gets the environment variable `name` and parses it as `uint256`.\n /// Reverts if the variable was not found or could not be parsed.\n function envUint(string calldata name) external view returns (uint256 value);\n\n /// Gets the environment variable `name` and parses it as an array of `uint256`, delimited by `delim`.\n /// Reverts if the variable was not found or could not be parsed.\n function envUint(string calldata name, string calldata delim) external view returns (uint256[] memory value);\n\n /// Returns true if `forge` command was executed in given context.\n function isContext(ForgeContext context) external view returns (bool result);\n\n /// Sets environment variables.\n function setEnv(string calldata name, string calldata value) external;\n\n // ======== EVM ========\n\n /// Gets all accessed reads and write slot from a `vm.record` session, for a given address.\n function accesses(address target) external returns (bytes32[] memory readSlots, bytes32[] memory writeSlots);\n\n /// Gets the address for a given private key.\n function addr(uint256 privateKey) external pure returns (address keyAddr);\n\n /// Gets all the logs according to specified filter.\n function eth_getLogs(uint256 fromBlock, uint256 toBlock, address target, bytes32[] calldata topics)\n external\n returns (EthGetLogs[] memory logs);\n\n /// Gets the current `block.blobbasefee`.\n /// You should use this instead of `block.blobbasefee` if you use `vm.blobBaseFee`, as `block.blobbasefee` is assumed to be constant across a transaction,\n /// and as a result will get optimized out by the compiler.\n /// See https://github.com/foundry-rs/foundry/issues/6180\n function getBlobBaseFee() external view returns (uint256 blobBaseFee);\n\n /// Gets the current `block.number`.\n /// You should use this instead of `block.number` if you use `vm.roll`, as `block.number` is assumed to be constant across a transaction,\n /// and as a result will get optimized out by the compiler.\n /// See https://github.com/foundry-rs/foundry/issues/6180\n function getBlockNumber() external view returns (uint256 height);\n\n /// Gets the current `block.timestamp`.\n /// You should use this instead of `block.timestamp` if you use `vm.warp`, as `block.timestamp` is assumed to be constant across a transaction,\n /// and as a result will get optimized out by the compiler.\n /// See https://github.com/foundry-rs/foundry/issues/6180\n function getBlockTimestamp() external view returns (uint256 timestamp);\n\n /// Gets the map key and parent of a mapping at a given slot, for a given address.\n function getMappingKeyAndParentOf(address target, bytes32 elementSlot)\n external\n returns (bool found, bytes32 key, bytes32 parent);\n\n /// Gets the number of elements in the mapping at the given slot, for a given address.\n function getMappingLength(address target, bytes32 mappingSlot) external returns (uint256 length);\n\n /// Gets the elements at index idx of the mapping at the given slot, for a given address. The\n /// index must be less than the length of the mapping (i.e. the number of keys in the mapping).\n function getMappingSlotAt(address target, bytes32 mappingSlot, uint256 idx) external returns (bytes32 value);\n\n /// Gets the nonce of an account.\n function getNonce(address account) external view returns (uint64 nonce);\n\n /// Get the nonce of a `Wallet`.\n function getNonce(Wallet calldata wallet) external returns (uint64 nonce);\n\n /// Gets all the recorded logs.\n function getRecordedLogs() external returns (Log[] memory logs);\n\n /// Returns state diffs from current `vm.startStateDiffRecording` session.\n function getStateDiff() external view returns (string memory diff);\n\n /// Returns state diffs from current `vm.startStateDiffRecording` session, in json format.\n function getStateDiffJson() external view returns (string memory diff);\n\n /// Gets the gas used in the last call from the callee perspective.\n function lastCallGas() external view returns (Gas memory gas);\n\n /// Loads a storage slot from an address.\n function load(address target, bytes32 slot) external view returns (bytes32 data);\n\n /// Pauses gas metering (i.e. gas usage is not counted). Noop if already paused.\n function pauseGasMetering() external;\n\n /// Records all storage reads and writes.\n function record() external;\n\n /// Record all the transaction logs.\n function recordLogs() external;\n\n /// Reset gas metering (i.e. gas usage is set to gas limit).\n function resetGasMetering() external;\n\n /// Resumes gas metering (i.e. gas usage is counted again). Noop if already on.\n function resumeGasMetering() external;\n\n /// Performs an Ethereum JSON-RPC request to the current fork URL.\n function rpc(string calldata method, string calldata params) external returns (bytes memory data);\n\n /// Performs an Ethereum JSON-RPC request to the given endpoint.\n function rpc(string calldata urlOrAlias, string calldata method, string calldata params)\n external\n returns (bytes memory data);\n\n /// Records the debug trace during the run.\n function startDebugTraceRecording() external;\n\n /// Starts recording all map SSTOREs for later retrieval.\n function startMappingRecording() external;\n\n /// Record all account accesses as part of CREATE, CALL or SELFDESTRUCT opcodes in order,\n /// along with the context of the calls\n function startStateDiffRecording() external;\n\n /// Stop debug trace recording and returns the recorded debug trace.\n function stopAndReturnDebugTraceRecording() external returns (DebugStep[] memory step);\n\n /// Returns an ordered array of all account accesses from a `vm.startStateDiffRecording` session.\n function stopAndReturnStateDiff() external returns (AccountAccess[] memory accountAccesses);\n\n /// Stops recording all map SSTOREs for later retrieval and clears the recorded data.\n function stopMappingRecording() external;\n\n // ======== Filesystem ========\n\n /// Closes file for reading, resetting the offset and allowing to read it from beginning with readLine.\n /// `path` is relative to the project root.\n function closeFile(string calldata path) external;\n\n /// Copies the contents of one file to another. This function will **overwrite** the contents of `to`.\n /// On success, the total number of bytes copied is returned and it is equal to the length of the `to` file as reported by `metadata`.\n /// Both `from` and `to` are relative to the project root.\n function copyFile(string calldata from, string calldata to) external returns (uint64 copied);\n\n /// Creates a new, empty directory at the provided path.\n /// This cheatcode will revert in the following situations, but is not limited to just these cases:\n /// - User lacks permissions to modify `path`.\n /// - A parent of the given path doesn't exist and `recursive` is false.\n /// - `path` already exists and `recursive` is false.\n /// `path` is relative to the project root.\n function createDir(string calldata path, bool recursive) external;\n\n /// Deploys a contract from an artifact file. Takes in the relative path to the json file or the path to the\n /// artifact in the form of :: where and parts are optional.\n function deployCode(string calldata artifactPath) external returns (address deployedAddress);\n\n /// Deploys a contract from an artifact file. Takes in the relative path to the json file or the path to the\n /// artifact in the form of :: where and parts are optional.\n /// Additionally accepts abi-encoded constructor arguments.\n function deployCode(string calldata artifactPath, bytes calldata constructorArgs)\n external\n returns (address deployedAddress);\n\n /// Returns true if the given path points to an existing entity, else returns false.\n function exists(string calldata path) external view returns (bool result);\n\n /// Performs a foreign function call via the terminal.\n function ffi(string[] calldata commandInput) external returns (bytes memory result);\n\n /// Given a path, query the file system to get information about a file, directory, etc.\n function fsMetadata(string calldata path) external view returns (FsMetadata memory metadata);\n\n /// Gets the artifact path from code (aka. creation code).\n function getArtifactPathByCode(bytes calldata code) external view returns (string memory path);\n\n /// Gets the artifact path from deployed code (aka. runtime code).\n function getArtifactPathByDeployedCode(bytes calldata deployedCode) external view returns (string memory path);\n\n /// Returns the most recent broadcast for the given contract on `chainId` matching `txType`.\n /// For example:\n /// The most recent deployment can be fetched by passing `txType` as `CREATE` or `CREATE2`.\n /// The most recent call can be fetched by passing `txType` as `CALL`.\n function getBroadcast(string calldata contractName, uint64 chainId, BroadcastTxType txType)\n external\n view\n returns (BroadcastTxSummary memory);\n\n /// Returns all broadcasts for the given contract on `chainId` with the specified `txType`.\n /// Sorted such that the most recent broadcast is the first element, and the oldest is the last. i.e descending order of BroadcastTxSummary.blockNumber.\n function getBroadcasts(string calldata contractName, uint64 chainId, BroadcastTxType txType)\n external\n view\n returns (BroadcastTxSummary[] memory);\n\n /// Returns all broadcasts for the given contract on `chainId`.\n /// Sorted such that the most recent broadcast is the first element, and the oldest is the last. i.e descending order of BroadcastTxSummary.blockNumber.\n function getBroadcasts(string calldata contractName, uint64 chainId)\n external\n view\n returns (BroadcastTxSummary[] memory);\n\n /// Gets the creation bytecode from an artifact file. Takes in the relative path to the json file or the path to the\n /// artifact in the form of :: where and parts are optional.\n function getCode(string calldata artifactPath) external view returns (bytes memory creationBytecode);\n\n /// Gets the deployed bytecode from an artifact file. Takes in the relative path to the json file or the path to the\n /// artifact in the form of :: where and parts are optional.\n function getDeployedCode(string calldata artifactPath) external view returns (bytes memory runtimeBytecode);\n\n /// Returns the most recent deployment for the current `chainId`.\n function getDeployment(string calldata contractName) external view returns (address deployedAddress);\n\n /// Returns the most recent deployment for the given contract on `chainId`\n function getDeployment(string calldata contractName, uint64 chainId)\n external\n view\n returns (address deployedAddress);\n\n /// Returns all deployments for the given contract on `chainId`\n /// Sorted in descending order of deployment time i.e descending order of BroadcastTxSummary.blockNumber.\n /// The most recent deployment is the first element, and the oldest is the last.\n function getDeployments(string calldata contractName, uint64 chainId)\n external\n view\n returns (address[] memory deployedAddresses);\n\n /// Returns true if the path exists on disk and is pointing at a directory, else returns false.\n function isDir(string calldata path) external view returns (bool result);\n\n /// Returns true if the path exists on disk and is pointing at a regular file, else returns false.\n function isFile(string calldata path) external view returns (bool result);\n\n /// Get the path of the current project root.\n function projectRoot() external view returns (string memory path);\n\n /// Prompts the user for a string value in the terminal.\n function prompt(string calldata promptText) external returns (string memory input);\n\n /// Prompts the user for an address in the terminal.\n function promptAddress(string calldata promptText) external returns (address);\n\n /// Prompts the user for a hidden string value in the terminal.\n function promptSecret(string calldata promptText) external returns (string memory input);\n\n /// Prompts the user for hidden uint256 in the terminal (usually pk).\n function promptSecretUint(string calldata promptText) external returns (uint256);\n\n /// Prompts the user for uint256 in the terminal.\n function promptUint(string calldata promptText) external returns (uint256);\n\n /// Reads the directory at the given path recursively, up to `maxDepth`.\n /// `maxDepth` defaults to 1, meaning only the direct children of the given directory will be returned.\n /// Follows symbolic links if `followLinks` is true.\n function readDir(string calldata path) external view returns (DirEntry[] memory entries);\n\n /// See `readDir(string)`.\n function readDir(string calldata path, uint64 maxDepth) external view returns (DirEntry[] memory entries);\n\n /// See `readDir(string)`.\n function readDir(string calldata path, uint64 maxDepth, bool followLinks)\n external\n view\n returns (DirEntry[] memory entries);\n\n /// Reads the entire content of file to string. `path` is relative to the project root.\n function readFile(string calldata path) external view returns (string memory data);\n\n /// Reads the entire content of file as binary. `path` is relative to the project root.\n function readFileBinary(string calldata path) external view returns (bytes memory data);\n\n /// Reads next line of file to string.\n function readLine(string calldata path) external view returns (string memory line);\n\n /// Reads a symbolic link, returning the path that the link points to.\n /// This cheatcode will revert in the following situations, but is not limited to just these cases:\n /// - `path` is not a symbolic link.\n /// - `path` does not exist.\n function readLink(string calldata linkPath) external view returns (string memory targetPath);\n\n /// Removes a directory at the provided path.\n /// This cheatcode will revert in the following situations, but is not limited to just these cases:\n /// - `path` doesn't exist.\n /// - `path` isn't a directory.\n /// - User lacks permissions to modify `path`.\n /// - The directory is not empty and `recursive` is false.\n /// `path` is relative to the project root.\n function removeDir(string calldata path, bool recursive) external;\n\n /// Removes a file from the filesystem.\n /// This cheatcode will revert in the following situations, but is not limited to just these cases:\n /// - `path` points to a directory.\n /// - The file doesn't exist.\n /// - The user lacks permissions to remove the file.\n /// `path` is relative to the project root.\n function removeFile(string calldata path) external;\n\n /// Performs a foreign function call via terminal and returns the exit code, stdout, and stderr.\n function tryFfi(string[] calldata commandInput) external returns (FfiResult memory result);\n\n /// Returns the time since unix epoch in milliseconds.\n function unixTime() external view returns (uint256 milliseconds);\n\n /// Writes data to file, creating a file if it does not exist, and entirely replacing its contents if it does.\n /// `path` is relative to the project root.\n function writeFile(string calldata path, string calldata data) external;\n\n /// Writes binary data to a file, creating a file if it does not exist, and entirely replacing its contents if it does.\n /// `path` is relative to the project root.\n function writeFileBinary(string calldata path, bytes calldata data) external;\n\n /// Writes line to file, creating a file if it does not exist.\n /// `path` is relative to the project root.\n function writeLine(string calldata path, string calldata data) external;\n\n // ======== JSON ========\n\n /// Checks if `key` exists in a JSON object.\n function keyExistsJson(string calldata json, string calldata key) external view returns (bool);\n\n /// Parses a string of JSON data at `key` and coerces it to `address`.\n function parseJsonAddress(string calldata json, string calldata key) external pure returns (address);\n\n /// Parses a string of JSON data at `key` and coerces it to `address[]`.\n function parseJsonAddressArray(string calldata json, string calldata key)\n external\n pure\n returns (address[] memory);\n\n /// Parses a string of JSON data at `key` and coerces it to `bool`.\n function parseJsonBool(string calldata json, string calldata key) external pure returns (bool);\n\n /// Parses a string of JSON data at `key` and coerces it to `bool[]`.\n function parseJsonBoolArray(string calldata json, string calldata key) external pure returns (bool[] memory);\n\n /// Parses a string of JSON data at `key` and coerces it to `bytes`.\n function parseJsonBytes(string calldata json, string calldata key) external pure returns (bytes memory);\n\n /// Parses a string of JSON data at `key` and coerces it to `bytes32`.\n function parseJsonBytes32(string calldata json, string calldata key) external pure returns (bytes32);\n\n /// Parses a string of JSON data at `key` and coerces it to `bytes32[]`.\n function parseJsonBytes32Array(string calldata json, string calldata key)\n external\n pure\n returns (bytes32[] memory);\n\n /// Parses a string of JSON data at `key` and coerces it to `bytes[]`.\n function parseJsonBytesArray(string calldata json, string calldata key) external pure returns (bytes[] memory);\n\n /// Parses a string of JSON data at `key` and coerces it to `int256`.\n function parseJsonInt(string calldata json, string calldata key) external pure returns (int256);\n\n /// Parses a string of JSON data at `key` and coerces it to `int256[]`.\n function parseJsonIntArray(string calldata json, string calldata key) external pure returns (int256[] memory);\n\n /// Returns an array of all the keys in a JSON object.\n function parseJsonKeys(string calldata json, string calldata key) external pure returns (string[] memory keys);\n\n /// Parses a string of JSON data at `key` and coerces it to `string`.\n function parseJsonString(string calldata json, string calldata key) external pure returns (string memory);\n\n /// Parses a string of JSON data at `key` and coerces it to `string[]`.\n function parseJsonStringArray(string calldata json, string calldata key) external pure returns (string[] memory);\n\n /// Parses a string of JSON data at `key` and coerces it to type array corresponding to `typeDescription`.\n function parseJsonTypeArray(string calldata json, string calldata key, string calldata typeDescription)\n external\n pure\n returns (bytes memory);\n\n /// Parses a string of JSON data and coerces it to type corresponding to `typeDescription`.\n function parseJsonType(string calldata json, string calldata typeDescription)\n external\n pure\n returns (bytes memory);\n\n /// Parses a string of JSON data at `key` and coerces it to type corresponding to `typeDescription`.\n function parseJsonType(string calldata json, string calldata key, string calldata typeDescription)\n external\n pure\n returns (bytes memory);\n\n /// Parses a string of JSON data at `key` and coerces it to `uint256`.\n function parseJsonUint(string calldata json, string calldata key) external pure returns (uint256);\n\n /// Parses a string of JSON data at `key` and coerces it to `uint256[]`.\n function parseJsonUintArray(string calldata json, string calldata key) external pure returns (uint256[] memory);\n\n /// ABI-encodes a JSON object.\n function parseJson(string calldata json) external pure returns (bytes memory abiEncodedData);\n\n /// ABI-encodes a JSON object at `key`.\n function parseJson(string calldata json, string calldata key) external pure returns (bytes memory abiEncodedData);\n\n /// See `serializeJson`.\n function serializeAddress(string calldata objectKey, string calldata valueKey, address value)\n external\n returns (string memory json);\n\n /// See `serializeJson`.\n function serializeAddress(string calldata objectKey, string calldata valueKey, address[] calldata values)\n external\n returns (string memory json);\n\n /// See `serializeJson`.\n function serializeBool(string calldata objectKey, string calldata valueKey, bool value)\n external\n returns (string memory json);\n\n /// See `serializeJson`.\n function serializeBool(string calldata objectKey, string calldata valueKey, bool[] calldata values)\n external\n returns (string memory json);\n\n /// See `serializeJson`.\n function serializeBytes32(string calldata objectKey, string calldata valueKey, bytes32 value)\n external\n returns (string memory json);\n\n /// See `serializeJson`.\n function serializeBytes32(string calldata objectKey, string calldata valueKey, bytes32[] calldata values)\n external\n returns (string memory json);\n\n /// See `serializeJson`.\n function serializeBytes(string calldata objectKey, string calldata valueKey, bytes calldata value)\n external\n returns (string memory json);\n\n /// See `serializeJson`.\n function serializeBytes(string calldata objectKey, string calldata valueKey, bytes[] calldata values)\n external\n returns (string memory json);\n\n /// See `serializeJson`.\n function serializeInt(string calldata objectKey, string calldata valueKey, int256 value)\n external\n returns (string memory json);\n\n /// See `serializeJson`.\n function serializeInt(string calldata objectKey, string calldata valueKey, int256[] calldata values)\n external\n returns (string memory json);\n\n /// Serializes a key and value to a JSON object stored in-memory that can be later written to a file.\n /// Returns the stringified version of the specific JSON file up to that moment.\n function serializeJson(string calldata objectKey, string calldata value) external returns (string memory json);\n\n /// See `serializeJson`.\n function serializeJsonType(string calldata typeDescription, bytes calldata value)\n external\n pure\n returns (string memory json);\n\n /// See `serializeJson`.\n function serializeJsonType(\n string calldata objectKey,\n string calldata valueKey,\n string calldata typeDescription,\n bytes calldata value\n ) external returns (string memory json);\n\n /// See `serializeJson`.\n function serializeString(string calldata objectKey, string calldata valueKey, string calldata value)\n external\n returns (string memory json);\n\n /// See `serializeJson`.\n function serializeString(string calldata objectKey, string calldata valueKey, string[] calldata values)\n external\n returns (string memory json);\n\n /// See `serializeJson`.\n function serializeUintToHex(string calldata objectKey, string calldata valueKey, uint256 value)\n external\n returns (string memory json);\n\n /// See `serializeJson`.\n function serializeUint(string calldata objectKey, string calldata valueKey, uint256 value)\n external\n returns (string memory json);\n\n /// See `serializeJson`.\n function serializeUint(string calldata objectKey, string calldata valueKey, uint256[] calldata values)\n external\n returns (string memory json);\n\n /// Write a serialized JSON object to a file. If the file exists, it will be overwritten.\n function writeJson(string calldata json, string calldata path) external;\n\n /// Write a serialized JSON object to an **existing** JSON file, replacing a value with key = \n /// This is useful to replace a specific value of a JSON file, without having to parse the entire thing.\n function writeJson(string calldata json, string calldata path, string calldata valueKey) external;\n\n /// Checks if `key` exists in a JSON object\n /// `keyExists` is being deprecated in favor of `keyExistsJson`. It will be removed in future versions.\n function keyExists(string calldata json, string calldata key) external view returns (bool);\n\n // ======== Scripting ========\n\n /// Designate the next call as an EIP-7702 transaction\n function attachDelegation(SignedDelegation calldata signedDelegation) external;\n\n /// Takes a signed transaction and broadcasts it to the network.\n function broadcastRawTransaction(bytes calldata data) external;\n\n /// Has the next call (at this call depth only) create transactions that can later be signed and sent onchain.\n /// Broadcasting address is determined by checking the following in order:\n /// 1. If `--sender` argument was provided, that address is used.\n /// 2. If exactly one signer (e.g. private key, hw wallet, keystore) is set when `forge broadcast` is invoked, that signer is used.\n /// 3. Otherwise, default foundry sender (1804c8AB1F12E6bbf3894d4083f33e07309d1f38) is used.\n function broadcast() external;\n\n /// Has the next call (at this call depth only) create a transaction with the address provided\n /// as the sender that can later be signed and sent onchain.\n function broadcast(address signer) external;\n\n /// Has the next call (at this call depth only) create a transaction with the private key\n /// provided as the sender that can later be signed and sent onchain.\n function broadcast(uint256 privateKey) external;\n\n /// Returns addresses of available unlocked wallets in the script environment.\n function getWallets() external returns (address[] memory wallets);\n\n /// Sign an EIP-7702 authorization and designate the next call as an EIP-7702 transaction\n function signAndAttachDelegation(address implementation, uint256 privateKey)\n external\n returns (SignedDelegation memory signedDelegation);\n\n /// Sign an EIP-7702 authorization for delegation\n function signDelegation(address implementation, uint256 privateKey)\n external\n returns (SignedDelegation memory signedDelegation);\n\n /// Has all subsequent calls (at this call depth only) create transactions that can later be signed and sent onchain.\n /// Broadcasting address is determined by checking the following in order:\n /// 1. If `--sender` argument was provided, that address is used.\n /// 2. If exactly one signer (e.g. private key, hw wallet, keystore) is set when `forge broadcast` is invoked, that signer is used.\n /// 3. Otherwise, default foundry sender (1804c8AB1F12E6bbf3894d4083f33e07309d1f38) is used.\n function startBroadcast() external;\n\n /// Has all subsequent calls (at this call depth only) create transactions with the address\n /// provided that can later be signed and sent onchain.\n function startBroadcast(address signer) external;\n\n /// Has all subsequent calls (at this call depth only) create transactions with the private key\n /// provided that can later be signed and sent onchain.\n function startBroadcast(uint256 privateKey) external;\n\n /// Stops collecting onchain transactions.\n function stopBroadcast() external;\n\n // ======== String ========\n\n /// Returns true if `search` is found in `subject`, false otherwise.\n function contains(string calldata subject, string calldata search) external returns (bool result);\n\n /// Returns the index of the first occurrence of a `key` in an `input` string.\n /// Returns `NOT_FOUND` (i.e. `type(uint256).max`) if the `key` is not found.\n /// Returns 0 in case of an empty `key`.\n function indexOf(string calldata input, string calldata key) external pure returns (uint256);\n\n /// Parses the given `string` into an `address`.\n function parseAddress(string calldata stringifiedValue) external pure returns (address parsedValue);\n\n /// Parses the given `string` into a `bool`.\n function parseBool(string calldata stringifiedValue) external pure returns (bool parsedValue);\n\n /// Parses the given `string` into `bytes`.\n function parseBytes(string calldata stringifiedValue) external pure returns (bytes memory parsedValue);\n\n /// Parses the given `string` into a `bytes32`.\n function parseBytes32(string calldata stringifiedValue) external pure returns (bytes32 parsedValue);\n\n /// Parses the given `string` into a `int256`.\n function parseInt(string calldata stringifiedValue) external pure returns (int256 parsedValue);\n\n /// Parses the given `string` into a `uint256`.\n function parseUint(string calldata stringifiedValue) external pure returns (uint256 parsedValue);\n\n /// Replaces occurrences of `from` in the given `string` with `to`.\n function replace(string calldata input, string calldata from, string calldata to)\n external\n pure\n returns (string memory output);\n\n /// Splits the given `string` into an array of strings divided by the `delimiter`.\n function split(string calldata input, string calldata delimiter) external pure returns (string[] memory outputs);\n\n /// Converts the given `string` value to Lowercase.\n function toLowercase(string calldata input) external pure returns (string memory output);\n\n /// Converts the given value to a `string`.\n function toString(address value) external pure returns (string memory stringifiedValue);\n\n /// Converts the given value to a `string`.\n function toString(bytes calldata value) external pure returns (string memory stringifiedValue);\n\n /// Converts the given value to a `string`.\n function toString(bytes32 value) external pure returns (string memory stringifiedValue);\n\n /// Converts the given value to a `string`.\n function toString(bool value) external pure returns (string memory stringifiedValue);\n\n /// Converts the given value to a `string`.\n function toString(uint256 value) external pure returns (string memory stringifiedValue);\n\n /// Converts the given value to a `string`.\n function toString(int256 value) external pure returns (string memory stringifiedValue);\n\n /// Converts the given `string` value to Uppercase.\n function toUppercase(string calldata input) external pure returns (string memory output);\n\n /// Trims leading and trailing whitespace from the given `string` value.\n function trim(string calldata input) external pure returns (string memory output);\n\n // ======== Testing ========\n\n /// Compares two `uint256` values. Expects difference to be less than or equal to `maxDelta`.\n /// Formats values with decimals in failure message.\n function assertApproxEqAbsDecimal(uint256 left, uint256 right, uint256 maxDelta, uint256 decimals) external pure;\n\n /// Compares two `uint256` values. Expects difference to be less than or equal to `maxDelta`.\n /// Formats values with decimals in failure message. Includes error message into revert string on failure.\n function assertApproxEqAbsDecimal(\n uint256 left,\n uint256 right,\n uint256 maxDelta,\n uint256 decimals,\n string calldata error\n ) external pure;\n\n /// Compares two `int256` values. Expects difference to be less than or equal to `maxDelta`.\n /// Formats values with decimals in failure message.\n function assertApproxEqAbsDecimal(int256 left, int256 right, uint256 maxDelta, uint256 decimals) external pure;\n\n /// Compares two `int256` values. Expects difference to be less than or equal to `maxDelta`.\n /// Formats values with decimals in failure message. Includes error message into revert string on failure.\n function assertApproxEqAbsDecimal(\n int256 left,\n int256 right,\n uint256 maxDelta,\n uint256 decimals,\n string calldata error\n ) external pure;\n\n /// Compares two `uint256` values. Expects difference to be less than or equal to `maxDelta`.\n function assertApproxEqAbs(uint256 left, uint256 right, uint256 maxDelta) external pure;\n\n /// Compares two `uint256` values. Expects difference to be less than or equal to `maxDelta`.\n /// Includes error message into revert string on failure.\n function assertApproxEqAbs(uint256 left, uint256 right, uint256 maxDelta, string calldata error) external pure;\n\n /// Compares two `int256` values. Expects difference to be less than or equal to `maxDelta`.\n function assertApproxEqAbs(int256 left, int256 right, uint256 maxDelta) external pure;\n\n /// Compares two `int256` values. Expects difference to be less than or equal to `maxDelta`.\n /// Includes error message into revert string on failure.\n function assertApproxEqAbs(int256 left, int256 right, uint256 maxDelta, string calldata error) external pure;\n\n /// Compares two `uint256` values. Expects relative difference in percents to be less than or equal to `maxPercentDelta`.\n /// `maxPercentDelta` is an 18 decimal fixed point number, where 1e18 == 100%\n /// Formats values with decimals in failure message.\n function assertApproxEqRelDecimal(uint256 left, uint256 right, uint256 maxPercentDelta, uint256 decimals)\n external\n pure;\n\n /// Compares two `uint256` values. Expects relative difference in percents to be less than or equal to `maxPercentDelta`.\n /// `maxPercentDelta` is an 18 decimal fixed point number, where 1e18 == 100%\n /// Formats values with decimals in failure message. Includes error message into revert string on failure.\n function assertApproxEqRelDecimal(\n uint256 left,\n uint256 right,\n uint256 maxPercentDelta,\n uint256 decimals,\n string calldata error\n ) external pure;\n\n /// Compares two `int256` values. Expects relative difference in percents to be less than or equal to `maxPercentDelta`.\n /// `maxPercentDelta` is an 18 decimal fixed point number, where 1e18 == 100%\n /// Formats values with decimals in failure message.\n function assertApproxEqRelDecimal(int256 left, int256 right, uint256 maxPercentDelta, uint256 decimals)\n external\n pure;\n\n /// Compares two `int256` values. Expects relative difference in percents to be less than or equal to `maxPercentDelta`.\n /// `maxPercentDelta` is an 18 decimal fixed point number, where 1e18 == 100%\n /// Formats values with decimals in failure message. Includes error message into revert string on failure.\n function assertApproxEqRelDecimal(\n int256 left,\n int256 right,\n uint256 maxPercentDelta,\n uint256 decimals,\n string calldata error\n ) external pure;\n\n /// Compares two `uint256` values. Expects relative difference in percents to be less than or equal to `maxPercentDelta`.\n /// `maxPercentDelta` is an 18 decimal fixed point number, where 1e18 == 100%\n function assertApproxEqRel(uint256 left, uint256 right, uint256 maxPercentDelta) external pure;\n\n /// Compares two `uint256` values. Expects relative difference in percents to be less than or equal to `maxPercentDelta`.\n /// `maxPercentDelta` is an 18 decimal fixed point number, where 1e18 == 100%\n /// Includes error message into revert string on failure.\n function assertApproxEqRel(uint256 left, uint256 right, uint256 maxPercentDelta, string calldata error)\n external\n pure;\n\n /// Compares two `int256` values. Expects relative difference in percents to be less than or equal to `maxPercentDelta`.\n /// `maxPercentDelta` is an 18 decimal fixed point number, where 1e18 == 100%\n function assertApproxEqRel(int256 left, int256 right, uint256 maxPercentDelta) external pure;\n\n /// Compares two `int256` values. Expects relative difference in percents to be less than or equal to `maxPercentDelta`.\n /// `maxPercentDelta` is an 18 decimal fixed point number, where 1e18 == 100%\n /// Includes error message into revert string on failure.\n function assertApproxEqRel(int256 left, int256 right, uint256 maxPercentDelta, string calldata error)\n external\n pure;\n\n /// Asserts that two `uint256` values are equal, formatting them with decimals in failure message.\n function assertEqDecimal(uint256 left, uint256 right, uint256 decimals) external pure;\n\n /// Asserts that two `uint256` values are equal, formatting them with decimals in failure message.\n /// Includes error message into revert string on failure.\n function assertEqDecimal(uint256 left, uint256 right, uint256 decimals, string calldata error) external pure;\n\n /// Asserts that two `int256` values are equal, formatting them with decimals in failure message.\n function assertEqDecimal(int256 left, int256 right, uint256 decimals) external pure;\n\n /// Asserts that two `int256` values are equal, formatting them with decimals in failure message.\n /// Includes error message into revert string on failure.\n function assertEqDecimal(int256 left, int256 right, uint256 decimals, string calldata error) external pure;\n\n /// Asserts that two `bool` values are equal.\n function assertEq(bool left, bool right) external pure;\n\n /// Asserts that two `bool` values are equal and includes error message into revert string on failure.\n function assertEq(bool left, bool right, string calldata error) external pure;\n\n /// Asserts that two `string` values are equal.\n function assertEq(string calldata left, string calldata right) external pure;\n\n /// Asserts that two `string` values are equal and includes error message into revert string on failure.\n function assertEq(string calldata left, string calldata right, string calldata error) external pure;\n\n /// Asserts that two `bytes` values are equal.\n function assertEq(bytes calldata left, bytes calldata right) external pure;\n\n /// Asserts that two `bytes` values are equal and includes error message into revert string on failure.\n function assertEq(bytes calldata left, bytes calldata right, string calldata error) external pure;\n\n /// Asserts that two arrays of `bool` values are equal.\n function assertEq(bool[] calldata left, bool[] calldata right) external pure;\n\n /// Asserts that two arrays of `bool` values are equal and includes error message into revert string on failure.\n function assertEq(bool[] calldata left, bool[] calldata right, string calldata error) external pure;\n\n /// Asserts that two arrays of `uint256 values are equal.\n function assertEq(uint256[] calldata left, uint256[] calldata right) external pure;\n\n /// Asserts that two arrays of `uint256` values are equal and includes error message into revert string on failure.\n function assertEq(uint256[] calldata left, uint256[] calldata right, string calldata error) external pure;\n\n /// Asserts that two arrays of `int256` values are equal.\n function assertEq(int256[] calldata left, int256[] calldata right) external pure;\n\n /// Asserts that two arrays of `int256` values are equal and includes error message into revert string on failure.\n function assertEq(int256[] calldata left, int256[] calldata right, string calldata error) external pure;\n\n /// Asserts that two `uint256` values are equal.\n function assertEq(uint256 left, uint256 right) external pure;\n\n /// Asserts that two arrays of `address` values are equal.\n function assertEq(address[] calldata left, address[] calldata right) external pure;\n\n /// Asserts that two arrays of `address` values are equal and includes error message into revert string on failure.\n function assertEq(address[] calldata left, address[] calldata right, string calldata error) external pure;\n\n /// Asserts that two arrays of `bytes32` values are equal.\n function assertEq(bytes32[] calldata left, bytes32[] calldata right) external pure;\n\n /// Asserts that two arrays of `bytes32` values are equal and includes error message into revert string on failure.\n function assertEq(bytes32[] calldata left, bytes32[] calldata right, string calldata error) external pure;\n\n /// Asserts that two arrays of `string` values are equal.\n function assertEq(string[] calldata left, string[] calldata right) external pure;\n\n /// Asserts that two arrays of `string` values are equal and includes error message into revert string on failure.\n function assertEq(string[] calldata left, string[] calldata right, string calldata error) external pure;\n\n /// Asserts that two arrays of `bytes` values are equal.\n function assertEq(bytes[] calldata left, bytes[] calldata right) external pure;\n\n /// Asserts that two arrays of `bytes` values are equal and includes error message into revert string on failure.\n function assertEq(bytes[] calldata left, bytes[] calldata right, string calldata error) external pure;\n\n /// Asserts that two `uint256` values are equal and includes error message into revert string on failure.\n function assertEq(uint256 left, uint256 right, string calldata error) external pure;\n\n /// Asserts that two `int256` values are equal.\n function assertEq(int256 left, int256 right) external pure;\n\n /// Asserts that two `int256` values are equal and includes error message into revert string on failure.\n function assertEq(int256 left, int256 right, string calldata error) external pure;\n\n /// Asserts that two `address` values are equal.\n function assertEq(address left, address right) external pure;\n\n /// Asserts that two `address` values are equal and includes error message into revert string on failure.\n function assertEq(address left, address right, string calldata error) external pure;\n\n /// Asserts that two `bytes32` values are equal.\n function assertEq(bytes32 left, bytes32 right) external pure;\n\n /// Asserts that two `bytes32` values are equal and includes error message into revert string on failure.\n function assertEq(bytes32 left, bytes32 right, string calldata error) external pure;\n\n /// Asserts that the given condition is false.\n function assertFalse(bool condition) external pure;\n\n /// Asserts that the given condition is false and includes error message into revert string on failure.\n function assertFalse(bool condition, string calldata error) external pure;\n\n /// Compares two `uint256` values. Expects first value to be greater than or equal to second.\n /// Formats values with decimals in failure message.\n function assertGeDecimal(uint256 left, uint256 right, uint256 decimals) external pure;\n\n /// Compares two `uint256` values. Expects first value to be greater than or equal to second.\n /// Formats values with decimals in failure message. Includes error message into revert string on failure.\n function assertGeDecimal(uint256 left, uint256 right, uint256 decimals, string calldata error) external pure;\n\n /// Compares two `int256` values. Expects first value to be greater than or equal to second.\n /// Formats values with decimals in failure message.\n function assertGeDecimal(int256 left, int256 right, uint256 decimals) external pure;\n\n /// Compares two `int256` values. Expects first value to be greater than or equal to second.\n /// Formats values with decimals in failure message. Includes error message into revert string on failure.\n function assertGeDecimal(int256 left, int256 right, uint256 decimals, string calldata error) external pure;\n\n /// Compares two `uint256` values. Expects first value to be greater than or equal to second.\n function assertGe(uint256 left, uint256 right) external pure;\n\n /// Compares two `uint256` values. Expects first value to be greater than or equal to second.\n /// Includes error message into revert string on failure.\n function assertGe(uint256 left, uint256 right, string calldata error) external pure;\n\n /// Compares two `int256` values. Expects first value to be greater than or equal to second.\n function assertGe(int256 left, int256 right) external pure;\n\n /// Compares two `int256` values. Expects first value to be greater than or equal to second.\n /// Includes error message into revert string on failure.\n function assertGe(int256 left, int256 right, string calldata error) external pure;\n\n /// Compares two `uint256` values. Expects first value to be greater than second.\n /// Formats values with decimals in failure message.\n function assertGtDecimal(uint256 left, uint256 right, uint256 decimals) external pure;\n\n /// Compares two `uint256` values. Expects first value to be greater than second.\n /// Formats values with decimals in failure message. Includes error message into revert string on failure.\n function assertGtDecimal(uint256 left, uint256 right, uint256 decimals, string calldata error) external pure;\n\n /// Compares two `int256` values. Expects first value to be greater than second.\n /// Formats values with decimals in failure message.\n function assertGtDecimal(int256 left, int256 right, uint256 decimals) external pure;\n\n /// Compares two `int256` values. Expects first value to be greater than second.\n /// Formats values with decimals in failure message. Includes error message into revert string on failure.\n function assertGtDecimal(int256 left, int256 right, uint256 decimals, string calldata error) external pure;\n\n /// Compares two `uint256` values. Expects first value to be greater than second.\n function assertGt(uint256 left, uint256 right) external pure;\n\n /// Compares two `uint256` values. Expects first value to be greater than second.\n /// Includes error message into revert string on failure.\n function assertGt(uint256 left, uint256 right, string calldata error) external pure;\n\n /// Compares two `int256` values. Expects first value to be greater than second.\n function assertGt(int256 left, int256 right) external pure;\n\n /// Compares two `int256` values. Expects first value to be greater than second.\n /// Includes error message into revert string on failure.\n function assertGt(int256 left, int256 right, string calldata error) external pure;\n\n /// Compares two `uint256` values. Expects first value to be less than or equal to second.\n /// Formats values with decimals in failure message.\n function assertLeDecimal(uint256 left, uint256 right, uint256 decimals) external pure;\n\n /// Compares two `uint256` values. Expects first value to be less than or equal to second.\n /// Formats values with decimals in failure message. Includes error message into revert string on failure.\n function assertLeDecimal(uint256 left, uint256 right, uint256 decimals, string calldata error) external pure;\n\n /// Compares two `int256` values. Expects first value to be less than or equal to second.\n /// Formats values with decimals in failure message.\n function assertLeDecimal(int256 left, int256 right, uint256 decimals) external pure;\n\n /// Compares two `int256` values. Expects first value to be less than or equal to second.\n /// Formats values with decimals in failure message. Includes error message into revert string on failure.\n function assertLeDecimal(int256 left, int256 right, uint256 decimals, string calldata error) external pure;\n\n /// Compares two `uint256` values. Expects first value to be less than or equal to second.\n function assertLe(uint256 left, uint256 right) external pure;\n\n /// Compares two `uint256` values. Expects first value to be less than or equal to second.\n /// Includes error message into revert string on failure.\n function assertLe(uint256 left, uint256 right, string calldata error) external pure;\n\n /// Compares two `int256` values. Expects first value to be less than or equal to second.\n function assertLe(int256 left, int256 right) external pure;\n\n /// Compares two `int256` values. Expects first value to be less than or equal to second.\n /// Includes error message into revert string on failure.\n function assertLe(int256 left, int256 right, string calldata error) external pure;\n\n /// Compares two `uint256` values. Expects first value to be less than second.\n /// Formats values with decimals in failure message.\n function assertLtDecimal(uint256 left, uint256 right, uint256 decimals) external pure;\n\n /// Compares two `uint256` values. Expects first value to be less than second.\n /// Formats values with decimals in failure message. Includes error message into revert string on failure.\n function assertLtDecimal(uint256 left, uint256 right, uint256 decimals, string calldata error) external pure;\n\n /// Compares two `int256` values. Expects first value to be less than second.\n /// Formats values with decimals in failure message.\n function assertLtDecimal(int256 left, int256 right, uint256 decimals) external pure;\n\n /// Compares two `int256` values. Expects first value to be less than second.\n /// Formats values with decimals in failure message. Includes error message into revert string on failure.\n function assertLtDecimal(int256 left, int256 right, uint256 decimals, string calldata error) external pure;\n\n /// Compares two `uint256` values. Expects first value to be less than second.\n function assertLt(uint256 left, uint256 right) external pure;\n\n /// Compares two `uint256` values. Expects first value to be less than second.\n /// Includes error message into revert string on failure.\n function assertLt(uint256 left, uint256 right, string calldata error) external pure;\n\n /// Compares two `int256` values. Expects first value to be less than second.\n function assertLt(int256 left, int256 right) external pure;\n\n /// Compares two `int256` values. Expects first value to be less than second.\n /// Includes error message into revert string on failure.\n function assertLt(int256 left, int256 right, string calldata error) external pure;\n\n /// Asserts that two `uint256` values are not equal, formatting them with decimals in failure message.\n function assertNotEqDecimal(uint256 left, uint256 right, uint256 decimals) external pure;\n\n /// Asserts that two `uint256` values are not equal, formatting them with decimals in failure message.\n /// Includes error message into revert string on failure.\n function assertNotEqDecimal(uint256 left, uint256 right, uint256 decimals, string calldata error) external pure;\n\n /// Asserts that two `int256` values are not equal, formatting them with decimals in failure message.\n function assertNotEqDecimal(int256 left, int256 right, uint256 decimals) external pure;\n\n /// Asserts that two `int256` values are not equal, formatting them with decimals in failure message.\n /// Includes error message into revert string on failure.\n function assertNotEqDecimal(int256 left, int256 right, uint256 decimals, string calldata error) external pure;\n\n /// Asserts that two `bool` values are not equal.\n function assertNotEq(bool left, bool right) external pure;\n\n /// Asserts that two `bool` values are not equal and includes error message into revert string on failure.\n function assertNotEq(bool left, bool right, string calldata error) external pure;\n\n /// Asserts that two `string` values are not equal.\n function assertNotEq(string calldata left, string calldata right) external pure;\n\n /// Asserts that two `string` values are not equal and includes error message into revert string on failure.\n function assertNotEq(string calldata left, string calldata right, string calldata error) external pure;\n\n /// Asserts that two `bytes` values are not equal.\n function assertNotEq(bytes calldata left, bytes calldata right) external pure;\n\n /// Asserts that two `bytes` values are not equal and includes error message into revert string on failure.\n function assertNotEq(bytes calldata left, bytes calldata right, string calldata error) external pure;\n\n /// Asserts that two arrays of `bool` values are not equal.\n function assertNotEq(bool[] calldata left, bool[] calldata right) external pure;\n\n /// Asserts that two arrays of `bool` values are not equal and includes error message into revert string on failure.\n function assertNotEq(bool[] calldata left, bool[] calldata right, string calldata error) external pure;\n\n /// Asserts that two arrays of `uint256` values are not equal.\n function assertNotEq(uint256[] calldata left, uint256[] calldata right) external pure;\n\n /// Asserts that two arrays of `uint256` values are not equal and includes error message into revert string on failure.\n function assertNotEq(uint256[] calldata left, uint256[] calldata right, string calldata error) external pure;\n\n /// Asserts that two arrays of `int256` values are not equal.\n function assertNotEq(int256[] calldata left, int256[] calldata right) external pure;\n\n /// Asserts that two arrays of `int256` values are not equal and includes error message into revert string on failure.\n function assertNotEq(int256[] calldata left, int256[] calldata right, string calldata error) external pure;\n\n /// Asserts that two `uint256` values are not equal.\n function assertNotEq(uint256 left, uint256 right) external pure;\n\n /// Asserts that two arrays of `address` values are not equal.\n function assertNotEq(address[] calldata left, address[] calldata right) external pure;\n\n /// Asserts that two arrays of `address` values are not equal and includes error message into revert string on failure.\n function assertNotEq(address[] calldata left, address[] calldata right, string calldata error) external pure;\n\n /// Asserts that two arrays of `bytes32` values are not equal.\n function assertNotEq(bytes32[] calldata left, bytes32[] calldata right) external pure;\n\n /// Asserts that two arrays of `bytes32` values are not equal and includes error message into revert string on failure.\n function assertNotEq(bytes32[] calldata left, bytes32[] calldata right, string calldata error) external pure;\n\n /// Asserts that two arrays of `string` values are not equal.\n function assertNotEq(string[] calldata left, string[] calldata right) external pure;\n\n /// Asserts that two arrays of `string` values are not equal and includes error message into revert string on failure.\n function assertNotEq(string[] calldata left, string[] calldata right, string calldata error) external pure;\n\n /// Asserts that two arrays of `bytes` values are not equal.\n function assertNotEq(bytes[] calldata left, bytes[] calldata right) external pure;\n\n /// Asserts that two arrays of `bytes` values are not equal and includes error message into revert string on failure.\n function assertNotEq(bytes[] calldata left, bytes[] calldata right, string calldata error) external pure;\n\n /// Asserts that two `uint256` values are not equal and includes error message into revert string on failure.\n function assertNotEq(uint256 left, uint256 right, string calldata error) external pure;\n\n /// Asserts that two `int256` values are not equal.\n function assertNotEq(int256 left, int256 right) external pure;\n\n /// Asserts that two `int256` values are not equal and includes error message into revert string on failure.\n function assertNotEq(int256 left, int256 right, string calldata error) external pure;\n\n /// Asserts that two `address` values are not equal.\n function assertNotEq(address left, address right) external pure;\n\n /// Asserts that two `address` values are not equal and includes error message into revert string on failure.\n function assertNotEq(address left, address right, string calldata error) external pure;\n\n /// Asserts that two `bytes32` values are not equal.\n function assertNotEq(bytes32 left, bytes32 right) external pure;\n\n /// Asserts that two `bytes32` values are not equal and includes error message into revert string on failure.\n function assertNotEq(bytes32 left, bytes32 right, string calldata error) external pure;\n\n /// Asserts that the given condition is true.\n function assertTrue(bool condition) external pure;\n\n /// Asserts that the given condition is true and includes error message into revert string on failure.\n function assertTrue(bool condition, string calldata error) external pure;\n\n /// If the condition is false, discard this run's fuzz inputs and generate new ones.\n function assume(bool condition) external pure;\n\n /// Discard this run's fuzz inputs and generate new ones if next call reverted.\n function assumeNoRevert() external pure;\n\n /// Discard this run's fuzz inputs and generate new ones if next call reverts with the potential revert parameters.\n function assumeNoRevert(PotentialRevert calldata potentialRevert) external pure;\n\n /// Discard this run's fuzz inputs and generate new ones if next call reverts with the any of the potential revert parameters.\n function assumeNoRevert(PotentialRevert[] calldata potentialReverts) external pure;\n\n /// Writes a breakpoint to jump to in the debugger.\n function breakpoint(string calldata char) external pure;\n\n /// Writes a conditional breakpoint to jump to in the debugger.\n function breakpoint(string calldata char, bool value) external pure;\n\n /// Returns true if the current Foundry version is greater than or equal to the given version.\n /// The given version string must be in the format `major.minor.patch`.\n /// This is equivalent to `foundryVersionCmp(version) >= 0`.\n function foundryVersionAtLeast(string calldata version) external view returns (bool);\n\n /// Compares the current Foundry version with the given version string.\n /// The given version string must be in the format `major.minor.patch`.\n /// Returns:\n /// -1 if current Foundry version is less than the given version\n /// 0 if current Foundry version equals the given version\n /// 1 if current Foundry version is greater than the given version\n /// This result can then be used with a comparison operator against `0`.\n /// For example, to check if the current Foundry version is greater than or equal to `1.0.0`:\n /// `if (foundryVersionCmp(\"1.0.0\") >= 0) { ... }`\n function foundryVersionCmp(string calldata version) external view returns (int256);\n\n /// Returns the Foundry version.\n /// Format: -+..\n /// Sample output: 0.3.0-nightly+3cb96bde9b.1737036656.debug\n /// Note: Build timestamps may vary slightly across platforms due to separate CI jobs.\n /// For reliable version comparisons, use UNIX format (e.g., >= 1700000000)\n /// to compare timestamps while ignoring minor time differences.\n function getFoundryVersion() external view returns (string memory version);\n\n /// Returns the RPC url for the given alias.\n function rpcUrl(string calldata rpcAlias) external view returns (string memory json);\n\n /// Returns all rpc urls and their aliases as structs.\n function rpcUrlStructs() external view returns (Rpc[] memory urls);\n\n /// Returns all rpc urls and their aliases `[alias, url][]`.\n function rpcUrls() external view returns (string[2][] memory urls);\n\n /// Suspends execution of the main thread for `duration` milliseconds.\n function sleep(uint256 duration) external;\n\n // ======== Toml ========\n\n /// Checks if `key` exists in a TOML table.\n function keyExistsToml(string calldata toml, string calldata key) external view returns (bool);\n\n /// Parses a string of TOML data at `key` and coerces it to `address`.\n function parseTomlAddress(string calldata toml, string calldata key) external pure returns (address);\n\n /// Parses a string of TOML data at `key` and coerces it to `address[]`.\n function parseTomlAddressArray(string calldata toml, string calldata key)\n external\n pure\n returns (address[] memory);\n\n /// Parses a string of TOML data at `key` and coerces it to `bool`.\n function parseTomlBool(string calldata toml, string calldata key) external pure returns (bool);\n\n /// Parses a string of TOML data at `key` and coerces it to `bool[]`.\n function parseTomlBoolArray(string calldata toml, string calldata key) external pure returns (bool[] memory);\n\n /// Parses a string of TOML data at `key` and coerces it to `bytes`.\n function parseTomlBytes(string calldata toml, string calldata key) external pure returns (bytes memory);\n\n /// Parses a string of TOML data at `key` and coerces it to `bytes32`.\n function parseTomlBytes32(string calldata toml, string calldata key) external pure returns (bytes32);\n\n /// Parses a string of TOML data at `key` and coerces it to `bytes32[]`.\n function parseTomlBytes32Array(string calldata toml, string calldata key)\n external\n pure\n returns (bytes32[] memory);\n\n /// Parses a string of TOML data at `key` and coerces it to `bytes[]`.\n function parseTomlBytesArray(string calldata toml, string calldata key) external pure returns (bytes[] memory);\n\n /// Parses a string of TOML data at `key` and coerces it to `int256`.\n function parseTomlInt(string calldata toml, string calldata key) external pure returns (int256);\n\n /// Parses a string of TOML data at `key` and coerces it to `int256[]`.\n function parseTomlIntArray(string calldata toml, string calldata key) external pure returns (int256[] memory);\n\n /// Returns an array of all the keys in a TOML table.\n function parseTomlKeys(string calldata toml, string calldata key) external pure returns (string[] memory keys);\n\n /// Parses a string of TOML data at `key` and coerces it to `string`.\n function parseTomlString(string calldata toml, string calldata key) external pure returns (string memory);\n\n /// Parses a string of TOML data at `key` and coerces it to `string[]`.\n function parseTomlStringArray(string calldata toml, string calldata key) external pure returns (string[] memory);\n\n /// Parses a string of TOML data at `key` and coerces it to type array corresponding to `typeDescription`.\n function parseTomlTypeArray(string calldata toml, string calldata key, string calldata typeDescription)\n external\n pure\n returns (bytes memory);\n\n /// Parses a string of TOML data and coerces it to type corresponding to `typeDescription`.\n function parseTomlType(string calldata toml, string calldata typeDescription)\n external\n pure\n returns (bytes memory);\n\n /// Parses a string of TOML data at `key` and coerces it to type corresponding to `typeDescription`.\n function parseTomlType(string calldata toml, string calldata key, string calldata typeDescription)\n external\n pure\n returns (bytes memory);\n\n /// Parses a string of TOML data at `key` and coerces it to `uint256`.\n function parseTomlUint(string calldata toml, string calldata key) external pure returns (uint256);\n\n /// Parses a string of TOML data at `key` and coerces it to `uint256[]`.\n function parseTomlUintArray(string calldata toml, string calldata key) external pure returns (uint256[] memory);\n\n /// ABI-encodes a TOML table.\n function parseToml(string calldata toml) external pure returns (bytes memory abiEncodedData);\n\n /// ABI-encodes a TOML table at `key`.\n function parseToml(string calldata toml, string calldata key) external pure returns (bytes memory abiEncodedData);\n\n /// Takes serialized JSON, converts to TOML and write a serialized TOML to a file.\n function writeToml(string calldata json, string calldata path) external;\n\n /// Takes serialized JSON, converts to TOML and write a serialized TOML table to an **existing** TOML file, replacing a value with key = \n /// This is useful to replace a specific value of a TOML file, without having to parse the entire thing.\n function writeToml(string calldata json, string calldata path, string calldata valueKey) external;\n\n // ======== Utilities ========\n\n /// Compute the address of a contract created with CREATE2 using the given CREATE2 deployer.\n function computeCreate2Address(bytes32 salt, bytes32 initCodeHash, address deployer)\n external\n pure\n returns (address);\n\n /// Compute the address of a contract created with CREATE2 using the default CREATE2 deployer.\n function computeCreate2Address(bytes32 salt, bytes32 initCodeHash) external pure returns (address);\n\n /// Compute the address a contract will be deployed at for a given deployer address and nonce.\n function computeCreateAddress(address deployer, uint256 nonce) external pure returns (address);\n\n /// Utility cheatcode to copy storage of `from` contract to another `to` contract.\n function copyStorage(address from, address to) external;\n\n /// Returns ENS namehash for provided string.\n function ensNamehash(string calldata name) external pure returns (bytes32);\n\n /// Gets the label for the specified address.\n function getLabel(address account) external view returns (string memory currentLabel);\n\n /// Labels an address in call traces.\n function label(address account, string calldata newLabel) external;\n\n /// Pauses collection of call traces. Useful in cases when you want to skip tracing of\n /// complex calls which are not useful for debugging.\n function pauseTracing() external view;\n\n /// Returns a random `address`.\n function randomAddress() external returns (address);\n\n /// Returns a random `bool`.\n function randomBool() external view returns (bool);\n\n /// Returns a random byte array value of the given length.\n function randomBytes(uint256 len) external view returns (bytes memory);\n\n /// Returns a random fixed-size byte array of length 4.\n function randomBytes4() external view returns (bytes4);\n\n /// Returns a random fixed-size byte array of length 8.\n function randomBytes8() external view returns (bytes8);\n\n /// Returns a random `int256` value.\n function randomInt() external view returns (int256);\n\n /// Returns a random `int256` value of given bits.\n function randomInt(uint256 bits) external view returns (int256);\n\n /// Returns a random uint256 value.\n function randomUint() external returns (uint256);\n\n /// Returns random uint256 value between the provided range (=min..=max).\n function randomUint(uint256 min, uint256 max) external returns (uint256);\n\n /// Returns a random `uint256` value of given bits.\n function randomUint(uint256 bits) external view returns (uint256);\n\n /// Unpauses collection of call traces.\n function resumeTracing() external view;\n\n /// Utility cheatcode to set arbitrary storage for given target address.\n function setArbitraryStorage(address target) external;\n\n /// Encodes a `bytes` value to a base64url string.\n function toBase64URL(bytes calldata data) external pure returns (string memory);\n\n /// Encodes a `string` value to a base64url string.\n function toBase64URL(string calldata data) external pure returns (string memory);\n\n /// Encodes a `bytes` value to a base64 string.\n function toBase64(bytes calldata data) external pure returns (string memory);\n\n /// Encodes a `string` value to a base64 string.\n function toBase64(string calldata data) external pure returns (string memory);\n}\n\n/// The `Vm` interface does allow manipulation of the EVM state. These are all intended to be used\n/// in tests, but it is not recommended to use these cheats in scripts.\ninterface Vm is VmSafe {\n // ======== EVM ========\n\n /// Utility cheatcode to set an EIP-2930 access list for all subsequent transactions.\n function accessList(AccessListItem[] calldata access) external;\n\n /// Returns the identifier of the currently active fork. Reverts if no fork is currently active.\n function activeFork() external view returns (uint256 forkId);\n\n /// In forking mode, explicitly grant the given address cheatcode access.\n function allowCheatcodes(address account) external;\n\n /// Sets `block.blobbasefee`\n function blobBaseFee(uint256 newBlobBaseFee) external;\n\n /// Sets the blobhashes in the transaction.\n /// Not available on EVM versions before Cancun.\n /// If used on unsupported EVM versions it will revert.\n function blobhashes(bytes32[] calldata hashes) external;\n\n /// Sets `block.chainid`.\n function chainId(uint256 newChainId) external;\n\n /// Clears all mocked calls.\n function clearMockedCalls() external;\n\n /// Clones a source account code, state, balance and nonce to a target account and updates in-memory EVM state.\n function cloneAccount(address source, address target) external;\n\n /// Sets `block.coinbase`.\n function coinbase(address newCoinbase) external;\n\n /// Marks the slots of an account and the account address as cold.\n function cool(address target) external;\n\n /// Utility cheatcode to mark specific storage slot as cold, simulating no prior read.\n function coolSlot(address target, bytes32 slot) external;\n\n /// Creates a new fork with the given endpoint and the _latest_ block and returns the identifier of the fork.\n function createFork(string calldata urlOrAlias) external returns (uint256 forkId);\n\n /// Creates a new fork with the given endpoint and block and returns the identifier of the fork.\n function createFork(string calldata urlOrAlias, uint256 blockNumber) external returns (uint256 forkId);\n\n /// Creates a new fork with the given endpoint and at the block the given transaction was mined in,\n /// replays all transaction mined in the block before the transaction, and returns the identifier of the fork.\n function createFork(string calldata urlOrAlias, bytes32 txHash) external returns (uint256 forkId);\n\n /// Creates and also selects a new fork with the given endpoint and the latest block and returns the identifier of the fork.\n function createSelectFork(string calldata urlOrAlias) external returns (uint256 forkId);\n\n /// Creates and also selects a new fork with the given endpoint and block and returns the identifier of the fork.\n function createSelectFork(string calldata urlOrAlias, uint256 blockNumber) external returns (uint256 forkId);\n\n /// Creates and also selects new fork with the given endpoint and at the block the given transaction was mined in,\n /// replays all transaction mined in the block before the transaction, returns the identifier of the fork.\n function createSelectFork(string calldata urlOrAlias, bytes32 txHash) external returns (uint256 forkId);\n\n /// Sets an address' balance.\n function deal(address account, uint256 newBalance) external;\n\n /// Removes the snapshot with the given ID created by `snapshot`.\n /// Takes the snapshot ID to delete.\n /// Returns `true` if the snapshot was successfully deleted.\n /// Returns `false` if the snapshot does not exist.\n function deleteStateSnapshot(uint256 snapshotId) external returns (bool success);\n\n /// Removes _all_ snapshots previously created by `snapshot`.\n function deleteStateSnapshots() external;\n\n /// Sets `block.difficulty`.\n /// Not available on EVM versions from Paris onwards. Use `prevrandao` instead.\n /// Reverts if used on unsupported EVM versions.\n function difficulty(uint256 newDifficulty) external;\n\n /// Dump a genesis JSON file's `allocs` to disk.\n function dumpState(string calldata pathToStateJson) external;\n\n /// Sets an address' code.\n function etch(address target, bytes calldata newRuntimeBytecode) external;\n\n /// Sets `block.basefee`.\n function fee(uint256 newBasefee) external;\n\n /// Gets the blockhashes from the current transaction.\n /// Not available on EVM versions before Cancun.\n /// If used on unsupported EVM versions it will revert.\n function getBlobhashes() external view returns (bytes32[] memory hashes);\n\n /// Returns true if the account is marked as persistent.\n function isPersistent(address account) external view returns (bool persistent);\n\n /// Load a genesis JSON file's `allocs` into the in-memory EVM state.\n function loadAllocs(string calldata pathToAllocsJson) external;\n\n /// Marks that the account(s) should use persistent storage across fork swaps in a multifork setup\n /// Meaning, changes made to the state of this account will be kept when switching forks.\n function makePersistent(address account) external;\n\n /// See `makePersistent(address)`.\n function makePersistent(address account0, address account1) external;\n\n /// See `makePersistent(address)`.\n function makePersistent(address account0, address account1, address account2) external;\n\n /// See `makePersistent(address)`.\n function makePersistent(address[] calldata accounts) external;\n\n /// Reverts a call to an address with specified revert data.\n function mockCallRevert(address callee, bytes calldata data, bytes calldata revertData) external;\n\n /// Reverts a call to an address with a specific `msg.value`, with specified revert data.\n function mockCallRevert(address callee, uint256 msgValue, bytes calldata data, bytes calldata revertData)\n external;\n\n /// Reverts a call to an address with specified revert data.\n /// Overload to pass the function selector directly `token.approve.selector` instead of `abi.encodeWithSelector(token.approve.selector)`.\n function mockCallRevert(address callee, bytes4 data, bytes calldata revertData) external;\n\n /// Reverts a call to an address with a specific `msg.value`, with specified revert data.\n /// Overload to pass the function selector directly `token.approve.selector` instead of `abi.encodeWithSelector(token.approve.selector)`.\n function mockCallRevert(address callee, uint256 msgValue, bytes4 data, bytes calldata revertData) external;\n\n /// Mocks a call to an address, returning specified data.\n /// Calldata can either be strict or a partial match, e.g. if you only\n /// pass a Solidity selector to the expected calldata, then the entire Solidity\n /// function will be mocked.\n function mockCall(address callee, bytes calldata data, bytes calldata returnData) external;\n\n /// Mocks a call to an address with a specific `msg.value`, returning specified data.\n /// Calldata match takes precedence over `msg.value` in case of ambiguity.\n function mockCall(address callee, uint256 msgValue, bytes calldata data, bytes calldata returnData) external;\n\n /// Mocks a call to an address, returning specified data.\n /// Calldata can either be strict or a partial match, e.g. if you only\n /// pass a Solidity selector to the expected calldata, then the entire Solidity\n /// function will be mocked.\n /// Overload to pass the function selector directly `token.approve.selector` instead of `abi.encodeWithSelector(token.approve.selector)`.\n function mockCall(address callee, bytes4 data, bytes calldata returnData) external;\n\n /// Mocks a call to an address with a specific `msg.value`, returning specified data.\n /// Calldata match takes precedence over `msg.value` in case of ambiguity.\n /// Overload to pass the function selector directly `token.approve.selector` instead of `abi.encodeWithSelector(token.approve.selector)`.\n function mockCall(address callee, uint256 msgValue, bytes4 data, bytes calldata returnData) external;\n\n /// Mocks multiple calls to an address, returning specified data for each call.\n function mockCalls(address callee, bytes calldata data, bytes[] calldata returnData) external;\n\n /// Mocks multiple calls to an address with a specific `msg.value`, returning specified data for each call.\n function mockCalls(address callee, uint256 msgValue, bytes calldata data, bytes[] calldata returnData) external;\n\n /// Whenever a call is made to `callee` with calldata `data`, this cheatcode instead calls\n /// `target` with the same calldata. This functionality is similar to a delegate call made to\n /// `target` contract from `callee`.\n /// Can be used to substitute a call to a function with another implementation that captures\n /// the primary logic of the original function but is easier to reason about.\n /// If calldata is not a strict match then partial match by selector is attempted.\n function mockFunction(address callee, address target, bytes calldata data) external;\n\n /// Utility cheatcode to remove any EIP-2930 access list set by `accessList` cheatcode.\n function noAccessList() external;\n\n /// Sets the *next* call's `msg.sender` to be the input address.\n function prank(address msgSender) external;\n\n /// Sets the *next* call's `msg.sender` to be the input address, and the `tx.origin` to be the second input.\n function prank(address msgSender, address txOrigin) external;\n\n /// Sets the *next* delegate call's `msg.sender` to be the input address.\n function prank(address msgSender, bool delegateCall) external;\n\n /// Sets the *next* delegate call's `msg.sender` to be the input address, and the `tx.origin` to be the second input.\n function prank(address msgSender, address txOrigin, bool delegateCall) external;\n\n /// Sets `block.prevrandao`.\n /// Not available on EVM versions before Paris. Use `difficulty` instead.\n /// If used on unsupported EVM versions it will revert.\n function prevrandao(bytes32 newPrevrandao) external;\n\n /// Sets `block.prevrandao`.\n /// Not available on EVM versions before Paris. Use `difficulty` instead.\n /// If used on unsupported EVM versions it will revert.\n function prevrandao(uint256 newPrevrandao) external;\n\n /// Reads the current `msg.sender` and `tx.origin` from state and reports if there is any active caller modification.\n function readCallers() external returns (CallerMode callerMode, address msgSender, address txOrigin);\n\n /// Resets the nonce of an account to 0 for EOAs and 1 for contract accounts.\n function resetNonce(address account) external;\n\n /// Revert the state of the EVM to a previous snapshot\n /// Takes the snapshot ID to revert to.\n /// Returns `true` if the snapshot was successfully reverted.\n /// Returns `false` if the snapshot does not exist.\n /// **Note:** This does not automatically delete the snapshot. To delete the snapshot use `deleteStateSnapshot`.\n function revertToState(uint256 snapshotId) external returns (bool success);\n\n /// Revert the state of the EVM to a previous snapshot and automatically deletes the snapshots\n /// Takes the snapshot ID to revert to.\n /// Returns `true` if the snapshot was successfully reverted and deleted.\n /// Returns `false` if the snapshot does not exist.\n function revertToStateAndDelete(uint256 snapshotId) external returns (bool success);\n\n /// Revokes persistent status from the address, previously added via `makePersistent`.\n function revokePersistent(address account) external;\n\n /// See `revokePersistent(address)`.\n function revokePersistent(address[] calldata accounts) external;\n\n /// Sets `block.height`.\n function roll(uint256 newHeight) external;\n\n /// Updates the currently active fork to given block number\n /// This is similar to `roll` but for the currently active fork.\n function rollFork(uint256 blockNumber) external;\n\n /// Updates the currently active fork to given transaction. This will `rollFork` with the number\n /// of the block the transaction was mined in and replays all transaction mined before it in the block.\n function rollFork(bytes32 txHash) external;\n\n /// Updates the given fork to given block number.\n function rollFork(uint256 forkId, uint256 blockNumber) external;\n\n /// Updates the given fork to block number of the given transaction and replays all transaction mined before it in the block.\n function rollFork(uint256 forkId, bytes32 txHash) external;\n\n /// Takes a fork identifier created by `createFork` and sets the corresponding forked state as active.\n function selectFork(uint256 forkId) external;\n\n /// Set blockhash for the current block.\n /// It only sets the blockhash for blocks where `block.number - 256 <= number < block.number`.\n function setBlockhash(uint256 blockNumber, bytes32 blockHash) external;\n\n /// Sets the nonce of an account. Must be higher than the current nonce of the account.\n function setNonce(address account, uint64 newNonce) external;\n\n /// Sets the nonce of an account to an arbitrary value.\n function setNonceUnsafe(address account, uint64 newNonce) external;\n\n /// Snapshot capture the gas usage of the last call by name from the callee perspective.\n function snapshotGasLastCall(string calldata name) external returns (uint256 gasUsed);\n\n /// Snapshot capture the gas usage of the last call by name in a group from the callee perspective.\n function snapshotGasLastCall(string calldata group, string calldata name) external returns (uint256 gasUsed);\n\n /// Snapshot the current state of the evm.\n /// Returns the ID of the snapshot that was created.\n /// To revert a snapshot use `revertToState`.\n function snapshotState() external returns (uint256 snapshotId);\n\n /// Snapshot capture an arbitrary numerical value by name.\n /// The group name is derived from the contract name.\n function snapshotValue(string calldata name, uint256 value) external;\n\n /// Snapshot capture an arbitrary numerical value by name in a group.\n function snapshotValue(string calldata group, string calldata name, uint256 value) external;\n\n /// Sets all subsequent calls' `msg.sender` to be the input address until `stopPrank` is called.\n function startPrank(address msgSender) external;\n\n /// Sets all subsequent calls' `msg.sender` to be the input address until `stopPrank` is called, and the `tx.origin` to be the second input.\n function startPrank(address msgSender, address txOrigin) external;\n\n /// Sets all subsequent delegate calls' `msg.sender` to be the input address until `stopPrank` is called.\n function startPrank(address msgSender, bool delegateCall) external;\n\n /// Sets all subsequent delegate calls' `msg.sender` to be the input address until `stopPrank` is called, and the `tx.origin` to be the second input.\n function startPrank(address msgSender, address txOrigin, bool delegateCall) external;\n\n /// Start a snapshot capture of the current gas usage by name.\n /// The group name is derived from the contract name.\n function startSnapshotGas(string calldata name) external;\n\n /// Start a snapshot capture of the current gas usage by name in a group.\n function startSnapshotGas(string calldata group, string calldata name) external;\n\n /// Resets subsequent calls' `msg.sender` to be `address(this)`.\n function stopPrank() external;\n\n /// Stop the snapshot capture of the current gas by latest snapshot name, capturing the gas used since the start.\n function stopSnapshotGas() external returns (uint256 gasUsed);\n\n /// Stop the snapshot capture of the current gas usage by name, capturing the gas used since the start.\n /// The group name is derived from the contract name.\n function stopSnapshotGas(string calldata name) external returns (uint256 gasUsed);\n\n /// Stop the snapshot capture of the current gas usage by name in a group, capturing the gas used since the start.\n function stopSnapshotGas(string calldata group, string calldata name) external returns (uint256 gasUsed);\n\n /// Stores a value to an address' storage slot.\n function store(address target, bytes32 slot, bytes32 value) external;\n\n /// Fetches the given transaction from the active fork and executes it on the current state.\n function transact(bytes32 txHash) external;\n\n /// Fetches the given transaction from the given fork and executes it on the current state.\n function transact(uint256 forkId, bytes32 txHash) external;\n\n /// Sets `tx.gasprice`.\n function txGasPrice(uint256 newGasPrice) external;\n\n /// Utility cheatcode to mark specific storage slot as warm, simulating a prior read.\n function warmSlot(address target, bytes32 slot) external;\n\n /// Sets `block.timestamp`.\n function warp(uint256 newTimestamp) external;\n\n /// `deleteSnapshot` is being deprecated in favor of `deleteStateSnapshot`. It will be removed in future versions.\n function deleteSnapshot(uint256 snapshotId) external returns (bool success);\n\n /// `deleteSnapshots` is being deprecated in favor of `deleteStateSnapshots`. It will be removed in future versions.\n function deleteSnapshots() external;\n\n /// `revertToAndDelete` is being deprecated in favor of `revertToStateAndDelete`. It will be removed in future versions.\n function revertToAndDelete(uint256 snapshotId) external returns (bool success);\n\n /// `revertTo` is being deprecated in favor of `revertToState`. It will be removed in future versions.\n function revertTo(uint256 snapshotId) external returns (bool success);\n\n /// `snapshot` is being deprecated in favor of `snapshotState`. It will be removed in future versions.\n function snapshot() external returns (uint256 snapshotId);\n\n // ======== Testing ========\n\n /// Expect a call to an address with the specified `msg.value` and calldata, and a *minimum* amount of gas.\n function expectCallMinGas(address callee, uint256 msgValue, uint64 minGas, bytes calldata data) external;\n\n /// Expect given number of calls to an address with the specified `msg.value` and calldata, and a *minimum* amount of gas.\n function expectCallMinGas(address callee, uint256 msgValue, uint64 minGas, bytes calldata data, uint64 count)\n external;\n\n /// Expects a call to an address with the specified calldata.\n /// Calldata can either be a strict or a partial match.\n function expectCall(address callee, bytes calldata data) external;\n\n /// Expects given number of calls to an address with the specified calldata.\n function expectCall(address callee, bytes calldata data, uint64 count) external;\n\n /// Expects a call to an address with the specified `msg.value` and calldata.\n function expectCall(address callee, uint256 msgValue, bytes calldata data) external;\n\n /// Expects given number of calls to an address with the specified `msg.value` and calldata.\n function expectCall(address callee, uint256 msgValue, bytes calldata data, uint64 count) external;\n\n /// Expect a call to an address with the specified `msg.value`, gas, and calldata.\n function expectCall(address callee, uint256 msgValue, uint64 gas, bytes calldata data) external;\n\n /// Expects given number of calls to an address with the specified `msg.value`, gas, and calldata.\n function expectCall(address callee, uint256 msgValue, uint64 gas, bytes calldata data, uint64 count) external;\n\n /// Expects the deployment of the specified bytecode by the specified address using the CREATE opcode\n function expectCreate(bytes calldata bytecode, address deployer) external;\n\n /// Expects the deployment of the specified bytecode by the specified address using the CREATE2 opcode\n function expectCreate2(bytes calldata bytecode, address deployer) external;\n\n /// Prepare an expected anonymous log with (bool checkTopic1, bool checkTopic2, bool checkTopic3, bool checkData.).\n /// Call this function, then emit an anonymous event, then call a function. Internally after the call, we check if\n /// logs were emitted in the expected order with the expected topics and data (as specified by the booleans).\n function expectEmitAnonymous(bool checkTopic0, bool checkTopic1, bool checkTopic2, bool checkTopic3, bool checkData)\n external;\n\n /// Same as the previous method, but also checks supplied address against emitting contract.\n function expectEmitAnonymous(\n bool checkTopic0,\n bool checkTopic1,\n bool checkTopic2,\n bool checkTopic3,\n bool checkData,\n address emitter\n ) external;\n\n /// Prepare an expected anonymous log with all topic and data checks enabled.\n /// Call this function, then emit an anonymous event, then call a function. Internally after the call, we check if\n /// logs were emitted in the expected order with the expected topics and data.\n function expectEmitAnonymous() external;\n\n /// Same as the previous method, but also checks supplied address against emitting contract.\n function expectEmitAnonymous(address emitter) external;\n\n /// Prepare an expected log with (bool checkTopic1, bool checkTopic2, bool checkTopic3, bool checkData.).\n /// Call this function, then emit an event, then call a function. Internally after the call, we check if\n /// logs were emitted in the expected order with the expected topics and data (as specified by the booleans).\n function expectEmit(bool checkTopic1, bool checkTopic2, bool checkTopic3, bool checkData) external;\n\n /// Same as the previous method, but also checks supplied address against emitting contract.\n function expectEmit(bool checkTopic1, bool checkTopic2, bool checkTopic3, bool checkData, address emitter)\n external;\n\n /// Prepare an expected log with all topic and data checks enabled.\n /// Call this function, then emit an event, then call a function. Internally after the call, we check if\n /// logs were emitted in the expected order with the expected topics and data.\n function expectEmit() external;\n\n /// Same as the previous method, but also checks supplied address against emitting contract.\n function expectEmit(address emitter) external;\n\n /// Expect a given number of logs with the provided topics.\n function expectEmit(bool checkTopic1, bool checkTopic2, bool checkTopic3, bool checkData, uint64 count) external;\n\n /// Expect a given number of logs from a specific emitter with the provided topics.\n function expectEmit(\n bool checkTopic1,\n bool checkTopic2,\n bool checkTopic3,\n bool checkData,\n address emitter,\n uint64 count\n ) external;\n\n /// Expect a given number of logs with all topic and data checks enabled.\n function expectEmit(uint64 count) external;\n\n /// Expect a given number of logs from a specific emitter with all topic and data checks enabled.\n function expectEmit(address emitter, uint64 count) external;\n\n /// Expects an error on next call that starts with the revert data.\n function expectPartialRevert(bytes4 revertData) external;\n\n /// Expects an error on next call to reverter address, that starts with the revert data.\n function expectPartialRevert(bytes4 revertData, address reverter) external;\n\n /// Expects an error on next call with any revert data.\n function expectRevert() external;\n\n /// Expects an error on next call that exactly matches the revert data.\n function expectRevert(bytes4 revertData) external;\n\n /// Expects a `count` number of reverts from the upcoming calls from the reverter address that match the revert data.\n function expectRevert(bytes4 revertData, address reverter, uint64 count) external;\n\n /// Expects a `count` number of reverts from the upcoming calls from the reverter address that exactly match the revert data.\n function expectRevert(bytes calldata revertData, address reverter, uint64 count) external;\n\n /// Expects an error on next call that exactly matches the revert data.\n function expectRevert(bytes calldata revertData) external;\n\n /// Expects an error with any revert data on next call to reverter address.\n function expectRevert(address reverter) external;\n\n /// Expects an error from reverter address on next call, with any revert data.\n function expectRevert(bytes4 revertData, address reverter) external;\n\n /// Expects an error from reverter address on next call, that exactly matches the revert data.\n function expectRevert(bytes calldata revertData, address reverter) external;\n\n /// Expects a `count` number of reverts from the upcoming calls with any revert data or reverter.\n function expectRevert(uint64 count) external;\n\n /// Expects a `count` number of reverts from the upcoming calls that match the revert data.\n function expectRevert(bytes4 revertData, uint64 count) external;\n\n /// Expects a `count` number of reverts from the upcoming calls that exactly match the revert data.\n function expectRevert(bytes calldata revertData, uint64 count) external;\n\n /// Expects a `count` number of reverts from the upcoming calls from the reverter address.\n function expectRevert(address reverter, uint64 count) external;\n\n /// Only allows memory writes to offsets [0x00, 0x60) ∪ [min, max) in the current subcontext. If any other\n /// memory is written to, the test will fail. Can be called multiple times to add more ranges to the set.\n function expectSafeMemory(uint64 min, uint64 max) external;\n\n /// Only allows memory writes to offsets [0x00, 0x60) ∪ [min, max) in the next created subcontext.\n /// If any other memory is written to, the test will fail. Can be called multiple times to add more ranges\n /// to the set.\n function expectSafeMemoryCall(uint64 min, uint64 max) external;\n\n /// Marks a test as skipped. Must be called at the top level of a test.\n function skip(bool skipTest) external;\n\n /// Marks a test as skipped with a reason. Must be called at the top level of a test.\n function skip(bool skipTest, string calldata reason) external;\n\n /// Stops all safe memory expectation in the current subcontext.\n function stopExpectSafeMemory() external;\n}\n","license":"MIT OR Apache-2.0"},"lib/forge-std/src/console.sol":{"keccak256":"0x4bbf47eb762cef93729d6ef15e78789957147039b113e5d4df48e3d3fd16d0f5","urls":[],"content":"// SPDX-License-Identifier: MIT\npragma solidity >=0.4.22 <0.9.0;\n\nlibrary console {\n address constant CONSOLE_ADDRESS =\n 0x000000000000000000636F6e736F6c652e6c6f67;\n\n function _sendLogPayloadImplementation(bytes memory payload) internal view {\n address consoleAddress = CONSOLE_ADDRESS;\n /// @solidity memory-safe-assembly\n assembly {\n pop(\n staticcall(\n gas(),\n consoleAddress,\n add(payload, 32),\n mload(payload),\n 0,\n 0\n )\n )\n }\n }\n\n function _castToPure(\n function(bytes memory) internal view fnIn\n ) internal pure returns (function(bytes memory) pure fnOut) {\n assembly {\n fnOut := fnIn\n }\n }\n\n function _sendLogPayload(bytes memory payload) internal pure {\n _castToPure(_sendLogPayloadImplementation)(payload);\n }\n\n function log() internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log()\"));\n }\n\n function logInt(int256 p0) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(int256)\", p0));\n }\n\n function logUint(uint256 p0) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256)\", p0));\n }\n\n function logString(string memory p0) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string)\", p0));\n }\n\n function logBool(bool p0) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool)\", p0));\n }\n\n function logAddress(address p0) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address)\", p0));\n }\n\n function logBytes(bytes memory p0) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bytes)\", p0));\n }\n\n function logBytes1(bytes1 p0) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bytes1)\", p0));\n }\n\n function logBytes2(bytes2 p0) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bytes2)\", p0));\n }\n\n function logBytes3(bytes3 p0) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bytes3)\", p0));\n }\n\n function logBytes4(bytes4 p0) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bytes4)\", p0));\n }\n\n function logBytes5(bytes5 p0) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bytes5)\", p0));\n }\n\n function logBytes6(bytes6 p0) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bytes6)\", p0));\n }\n\n function logBytes7(bytes7 p0) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bytes7)\", p0));\n }\n\n function logBytes8(bytes8 p0) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bytes8)\", p0));\n }\n\n function logBytes9(bytes9 p0) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bytes9)\", p0));\n }\n\n function logBytes10(bytes10 p0) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bytes10)\", p0));\n }\n\n function logBytes11(bytes11 p0) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bytes11)\", p0));\n }\n\n function logBytes12(bytes12 p0) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bytes12)\", p0));\n }\n\n function logBytes13(bytes13 p0) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bytes13)\", p0));\n }\n\n function logBytes14(bytes14 p0) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bytes14)\", p0));\n }\n\n function logBytes15(bytes15 p0) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bytes15)\", p0));\n }\n\n function logBytes16(bytes16 p0) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bytes16)\", p0));\n }\n\n function logBytes17(bytes17 p0) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bytes17)\", p0));\n }\n\n function logBytes18(bytes18 p0) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bytes18)\", p0));\n }\n\n function logBytes19(bytes19 p0) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bytes19)\", p0));\n }\n\n function logBytes20(bytes20 p0) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bytes20)\", p0));\n }\n\n function logBytes21(bytes21 p0) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bytes21)\", p0));\n }\n\n function logBytes22(bytes22 p0) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bytes22)\", p0));\n }\n\n function logBytes23(bytes23 p0) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bytes23)\", p0));\n }\n\n function logBytes24(bytes24 p0) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bytes24)\", p0));\n }\n\n function logBytes25(bytes25 p0) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bytes25)\", p0));\n }\n\n function logBytes26(bytes26 p0) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bytes26)\", p0));\n }\n\n function logBytes27(bytes27 p0) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bytes27)\", p0));\n }\n\n function logBytes28(bytes28 p0) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bytes28)\", p0));\n }\n\n function logBytes29(bytes29 p0) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bytes29)\", p0));\n }\n\n function logBytes30(bytes30 p0) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bytes30)\", p0));\n }\n\n function logBytes31(bytes31 p0) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bytes31)\", p0));\n }\n\n function logBytes32(bytes32 p0) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bytes32)\", p0));\n }\n\n function log(uint256 p0) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256)\", p0));\n }\n\n function log(int256 p0) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(int256)\", p0));\n }\n\n function log(string memory p0) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string)\", p0));\n }\n\n function log(bool p0) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool)\", p0));\n }\n\n function log(address p0) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address)\", p0));\n }\n\n function log(uint256 p0, uint256 p1) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,uint256)\", p0, p1));\n }\n\n function log(uint256 p0, string memory p1) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,string)\", p0, p1));\n }\n\n function log(uint256 p0, bool p1) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,bool)\", p0, p1));\n }\n\n function log(uint256 p0, address p1) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,address)\", p0, p1));\n }\n\n function log(string memory p0, uint256 p1) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,uint256)\", p0, p1));\n }\n\n function log(string memory p0, int256 p1) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,int256)\", p0, p1));\n }\n\n function log(string memory p0, string memory p1) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,string)\", p0, p1));\n }\n\n function log(string memory p0, bool p1) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,bool)\", p0, p1));\n }\n\n function log(string memory p0, address p1) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,address)\", p0, p1));\n }\n\n function log(bool p0, uint256 p1) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,uint256)\", p0, p1));\n }\n\n function log(bool p0, string memory p1) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,string)\", p0, p1));\n }\n\n function log(bool p0, bool p1) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,bool)\", p0, p1));\n }\n\n function log(bool p0, address p1) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,address)\", p0, p1));\n }\n\n function log(address p0, uint256 p1) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,uint256)\", p0, p1));\n }\n\n function log(address p0, string memory p1) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,string)\", p0, p1));\n }\n\n function log(address p0, bool p1) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,bool)\", p0, p1));\n }\n\n function log(address p0, address p1) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,address)\", p0, p1));\n }\n\n function log(uint256 p0, uint256 p1, uint256 p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,uint256,uint256)\", p0, p1, p2));\n }\n\n function log(uint256 p0, uint256 p1, string memory p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,uint256,string)\", p0, p1, p2));\n }\n\n function log(uint256 p0, uint256 p1, bool p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,uint256,bool)\", p0, p1, p2));\n }\n\n function log(uint256 p0, uint256 p1, address p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,uint256,address)\", p0, p1, p2));\n }\n\n function log(uint256 p0, string memory p1, uint256 p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,string,uint256)\", p0, p1, p2));\n }\n\n function log(uint256 p0, string memory p1, string memory p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,string,string)\", p0, p1, p2));\n }\n\n function log(uint256 p0, string memory p1, bool p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,string,bool)\", p0, p1, p2));\n }\n\n function log(uint256 p0, string memory p1, address p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,string,address)\", p0, p1, p2));\n }\n\n function log(uint256 p0, bool p1, uint256 p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,bool,uint256)\", p0, p1, p2));\n }\n\n function log(uint256 p0, bool p1, string memory p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,bool,string)\", p0, p1, p2));\n }\n\n function log(uint256 p0, bool p1, bool p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,bool,bool)\", p0, p1, p2));\n }\n\n function log(uint256 p0, bool p1, address p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,bool,address)\", p0, p1, p2));\n }\n\n function log(uint256 p0, address p1, uint256 p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,address,uint256)\", p0, p1, p2));\n }\n\n function log(uint256 p0, address p1, string memory p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,address,string)\", p0, p1, p2));\n }\n\n function log(uint256 p0, address p1, bool p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,address,bool)\", p0, p1, p2));\n }\n\n function log(uint256 p0, address p1, address p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,address,address)\", p0, p1, p2));\n }\n\n function log(string memory p0, uint256 p1, uint256 p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,uint256,uint256)\", p0, p1, p2));\n }\n\n function log(string memory p0, uint256 p1, string memory p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,uint256,string)\", p0, p1, p2));\n }\n\n function log(string memory p0, uint256 p1, bool p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,uint256,bool)\", p0, p1, p2));\n }\n\n function log(string memory p0, uint256 p1, address p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,uint256,address)\", p0, p1, p2));\n }\n\n function log(string memory p0, string memory p1, uint256 p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,string,uint256)\", p0, p1, p2));\n }\n\n function log(string memory p0, string memory p1, string memory p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,string,string)\", p0, p1, p2));\n }\n\n function log(string memory p0, string memory p1, bool p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,string,bool)\", p0, p1, p2));\n }\n\n function log(string memory p0, string memory p1, address p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,string,address)\", p0, p1, p2));\n }\n\n function log(string memory p0, bool p1, uint256 p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,bool,uint256)\", p0, p1, p2));\n }\n\n function log(string memory p0, bool p1, string memory p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,bool,string)\", p0, p1, p2));\n }\n\n function log(string memory p0, bool p1, bool p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,bool,bool)\", p0, p1, p2));\n }\n\n function log(string memory p0, bool p1, address p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,bool,address)\", p0, p1, p2));\n }\n\n function log(string memory p0, address p1, uint256 p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,address,uint256)\", p0, p1, p2));\n }\n\n function log(string memory p0, address p1, string memory p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,address,string)\", p0, p1, p2));\n }\n\n function log(string memory p0, address p1, bool p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,address,bool)\", p0, p1, p2));\n }\n\n function log(string memory p0, address p1, address p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,address,address)\", p0, p1, p2));\n }\n\n function log(bool p0, uint256 p1, uint256 p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,uint256,uint256)\", p0, p1, p2));\n }\n\n function log(bool p0, uint256 p1, string memory p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,uint256,string)\", p0, p1, p2));\n }\n\n function log(bool p0, uint256 p1, bool p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,uint256,bool)\", p0, p1, p2));\n }\n\n function log(bool p0, uint256 p1, address p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,uint256,address)\", p0, p1, p2));\n }\n\n function log(bool p0, string memory p1, uint256 p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,string,uint256)\", p0, p1, p2));\n }\n\n function log(bool p0, string memory p1, string memory p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,string,string)\", p0, p1, p2));\n }\n\n function log(bool p0, string memory p1, bool p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,string,bool)\", p0, p1, p2));\n }\n\n function log(bool p0, string memory p1, address p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,string,address)\", p0, p1, p2));\n }\n\n function log(bool p0, bool p1, uint256 p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,bool,uint256)\", p0, p1, p2));\n }\n\n function log(bool p0, bool p1, string memory p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,bool,string)\", p0, p1, p2));\n }\n\n function log(bool p0, bool p1, bool p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,bool,bool)\", p0, p1, p2));\n }\n\n function log(bool p0, bool p1, address p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,bool,address)\", p0, p1, p2));\n }\n\n function log(bool p0, address p1, uint256 p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,address,uint256)\", p0, p1, p2));\n }\n\n function log(bool p0, address p1, string memory p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,address,string)\", p0, p1, p2));\n }\n\n function log(bool p0, address p1, bool p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,address,bool)\", p0, p1, p2));\n }\n\n function log(bool p0, address p1, address p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,address,address)\", p0, p1, p2));\n }\n\n function log(address p0, uint256 p1, uint256 p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,uint256,uint256)\", p0, p1, p2));\n }\n\n function log(address p0, uint256 p1, string memory p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,uint256,string)\", p0, p1, p2));\n }\n\n function log(address p0, uint256 p1, bool p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,uint256,bool)\", p0, p1, p2));\n }\n\n function log(address p0, uint256 p1, address p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,uint256,address)\", p0, p1, p2));\n }\n\n function log(address p0, string memory p1, uint256 p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,string,uint256)\", p0, p1, p2));\n }\n\n function log(address p0, string memory p1, string memory p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,string,string)\", p0, p1, p2));\n }\n\n function log(address p0, string memory p1, bool p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,string,bool)\", p0, p1, p2));\n }\n\n function log(address p0, string memory p1, address p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,string,address)\", p0, p1, p2));\n }\n\n function log(address p0, bool p1, uint256 p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,bool,uint256)\", p0, p1, p2));\n }\n\n function log(address p0, bool p1, string memory p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,bool,string)\", p0, p1, p2));\n }\n\n function log(address p0, bool p1, bool p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,bool,bool)\", p0, p1, p2));\n }\n\n function log(address p0, bool p1, address p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,bool,address)\", p0, p1, p2));\n }\n\n function log(address p0, address p1, uint256 p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,address,uint256)\", p0, p1, p2));\n }\n\n function log(address p0, address p1, string memory p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,address,string)\", p0, p1, p2));\n }\n\n function log(address p0, address p1, bool p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,address,bool)\", p0, p1, p2));\n }\n\n function log(address p0, address p1, address p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,address,address)\", p0, p1, p2));\n }\n\n function log(uint256 p0, uint256 p1, uint256 p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,uint256,uint256,uint256)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, uint256 p1, uint256 p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,uint256,uint256,string)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, uint256 p1, uint256 p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,uint256,uint256,bool)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, uint256 p1, uint256 p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,uint256,uint256,address)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, uint256 p1, string memory p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,uint256,string,uint256)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, uint256 p1, string memory p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,uint256,string,string)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, uint256 p1, string memory p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,uint256,string,bool)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, uint256 p1, string memory p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,uint256,string,address)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, uint256 p1, bool p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,uint256,bool,uint256)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, uint256 p1, bool p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,uint256,bool,string)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, uint256 p1, bool p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,uint256,bool,bool)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, uint256 p1, bool p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,uint256,bool,address)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, uint256 p1, address p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,uint256,address,uint256)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, uint256 p1, address p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,uint256,address,string)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, uint256 p1, address p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,uint256,address,bool)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, uint256 p1, address p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,uint256,address,address)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, string memory p1, uint256 p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,string,uint256,uint256)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, string memory p1, uint256 p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,string,uint256,string)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, string memory p1, uint256 p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,string,uint256,bool)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, string memory p1, uint256 p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,string,uint256,address)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, string memory p1, string memory p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,string,string,uint256)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, string memory p1, string memory p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,string,string,string)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, string memory p1, string memory p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,string,string,bool)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, string memory p1, string memory p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,string,string,address)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, string memory p1, bool p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,string,bool,uint256)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, string memory p1, bool p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,string,bool,string)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, string memory p1, bool p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,string,bool,bool)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, string memory p1, bool p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,string,bool,address)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, string memory p1, address p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,string,address,uint256)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, string memory p1, address p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,string,address,string)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, string memory p1, address p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,string,address,bool)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, string memory p1, address p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,string,address,address)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, bool p1, uint256 p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,bool,uint256,uint256)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, bool p1, uint256 p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,bool,uint256,string)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, bool p1, uint256 p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,bool,uint256,bool)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, bool p1, uint256 p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,bool,uint256,address)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, bool p1, string memory p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,bool,string,uint256)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, bool p1, string memory p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,bool,string,string)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, bool p1, string memory p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,bool,string,bool)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, bool p1, string memory p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,bool,string,address)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, bool p1, bool p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,bool,bool,uint256)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, bool p1, bool p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,bool,bool,string)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, bool p1, bool p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,bool,bool,bool)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, bool p1, bool p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,bool,bool,address)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, bool p1, address p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,bool,address,uint256)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, bool p1, address p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,bool,address,string)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, bool p1, address p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,bool,address,bool)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, bool p1, address p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,bool,address,address)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, address p1, uint256 p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,address,uint256,uint256)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, address p1, uint256 p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,address,uint256,string)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, address p1, uint256 p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,address,uint256,bool)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, address p1, uint256 p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,address,uint256,address)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, address p1, string memory p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,address,string,uint256)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, address p1, string memory p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,address,string,string)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, address p1, string memory p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,address,string,bool)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, address p1, string memory p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,address,string,address)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, address p1, bool p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,address,bool,uint256)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, address p1, bool p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,address,bool,string)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, address p1, bool p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,address,bool,bool)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, address p1, bool p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,address,bool,address)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, address p1, address p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,address,address,uint256)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, address p1, address p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,address,address,string)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, address p1, address p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,address,address,bool)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, address p1, address p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,address,address,address)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, uint256 p1, uint256 p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,uint256,uint256,uint256)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, uint256 p1, uint256 p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,uint256,uint256,string)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, uint256 p1, uint256 p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,uint256,uint256,bool)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, uint256 p1, uint256 p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,uint256,uint256,address)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, uint256 p1, string memory p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,uint256,string,uint256)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, uint256 p1, string memory p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,uint256,string,string)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, uint256 p1, string memory p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,uint256,string,bool)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, uint256 p1, string memory p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,uint256,string,address)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, uint256 p1, bool p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,uint256,bool,uint256)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, uint256 p1, bool p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,uint256,bool,string)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, uint256 p1, bool p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,uint256,bool,bool)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, uint256 p1, bool p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,uint256,bool,address)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, uint256 p1, address p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,uint256,address,uint256)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, uint256 p1, address p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,uint256,address,string)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, uint256 p1, address p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,uint256,address,bool)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, uint256 p1, address p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,uint256,address,address)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, string memory p1, uint256 p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,string,uint256,uint256)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, string memory p1, uint256 p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,string,uint256,string)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, string memory p1, uint256 p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,string,uint256,bool)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, string memory p1, uint256 p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,string,uint256,address)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, string memory p1, string memory p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,string,string,uint256)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, string memory p1, string memory p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,string,string,string)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, string memory p1, string memory p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,string,string,bool)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, string memory p1, string memory p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,string,string,address)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, string memory p1, bool p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,string,bool,uint256)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, string memory p1, bool p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,string,bool,string)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, string memory p1, bool p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,string,bool,bool)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, string memory p1, bool p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,string,bool,address)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, string memory p1, address p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,string,address,uint256)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, string memory p1, address p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,string,address,string)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, string memory p1, address p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,string,address,bool)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, string memory p1, address p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,string,address,address)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, bool p1, uint256 p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,bool,uint256,uint256)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, bool p1, uint256 p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,bool,uint256,string)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, bool p1, uint256 p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,bool,uint256,bool)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, bool p1, uint256 p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,bool,uint256,address)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, bool p1, string memory p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,bool,string,uint256)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, bool p1, string memory p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,bool,string,string)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, bool p1, string memory p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,bool,string,bool)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, bool p1, string memory p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,bool,string,address)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, bool p1, bool p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,bool,bool,uint256)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, bool p1, bool p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,bool,bool,string)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, bool p1, bool p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,bool,bool,bool)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, bool p1, bool p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,bool,bool,address)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, bool p1, address p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,bool,address,uint256)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, bool p1, address p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,bool,address,string)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, bool p1, address p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,bool,address,bool)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, bool p1, address p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,bool,address,address)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, address p1, uint256 p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,address,uint256,uint256)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, address p1, uint256 p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,address,uint256,string)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, address p1, uint256 p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,address,uint256,bool)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, address p1, uint256 p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,address,uint256,address)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, address p1, string memory p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,address,string,uint256)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, address p1, string memory p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,address,string,string)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, address p1, string memory p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,address,string,bool)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, address p1, string memory p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,address,string,address)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, address p1, bool p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,address,bool,uint256)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, address p1, bool p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,address,bool,string)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, address p1, bool p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,address,bool,bool)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, address p1, bool p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,address,bool,address)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, address p1, address p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,address,address,uint256)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, address p1, address p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,address,address,string)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, address p1, address p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,address,address,bool)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, address p1, address p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,address,address,address)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, uint256 p1, uint256 p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,uint256,uint256,uint256)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, uint256 p1, uint256 p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,uint256,uint256,string)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, uint256 p1, uint256 p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,uint256,uint256,bool)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, uint256 p1, uint256 p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,uint256,uint256,address)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, uint256 p1, string memory p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,uint256,string,uint256)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, uint256 p1, string memory p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,uint256,string,string)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, uint256 p1, string memory p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,uint256,string,bool)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, uint256 p1, string memory p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,uint256,string,address)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, uint256 p1, bool p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,uint256,bool,uint256)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, uint256 p1, bool p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,uint256,bool,string)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, uint256 p1, bool p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,uint256,bool,bool)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, uint256 p1, bool p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,uint256,bool,address)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, uint256 p1, address p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,uint256,address,uint256)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, uint256 p1, address p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,uint256,address,string)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, uint256 p1, address p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,uint256,address,bool)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, uint256 p1, address p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,uint256,address,address)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, string memory p1, uint256 p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,string,uint256,uint256)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, string memory p1, uint256 p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,string,uint256,string)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, string memory p1, uint256 p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,string,uint256,bool)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, string memory p1, uint256 p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,string,uint256,address)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, string memory p1, string memory p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,string,string,uint256)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, string memory p1, string memory p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,string,string,string)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, string memory p1, string memory p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,string,string,bool)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, string memory p1, string memory p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,string,string,address)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, string memory p1, bool p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,string,bool,uint256)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, string memory p1, bool p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,string,bool,string)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, string memory p1, bool p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,string,bool,bool)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, string memory p1, bool p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,string,bool,address)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, string memory p1, address p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,string,address,uint256)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, string memory p1, address p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,string,address,string)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, string memory p1, address p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,string,address,bool)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, string memory p1, address p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,string,address,address)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, bool p1, uint256 p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,bool,uint256,uint256)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, bool p1, uint256 p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,bool,uint256,string)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, bool p1, uint256 p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,bool,uint256,bool)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, bool p1, uint256 p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,bool,uint256,address)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, bool p1, string memory p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,bool,string,uint256)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, bool p1, string memory p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,bool,string,string)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, bool p1, string memory p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,bool,string,bool)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, bool p1, string memory p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,bool,string,address)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, bool p1, bool p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,bool,bool,uint256)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, bool p1, bool p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,bool,bool,string)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, bool p1, bool p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,bool,bool,bool)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, bool p1, bool p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,bool,bool,address)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, bool p1, address p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,bool,address,uint256)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, bool p1, address p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,bool,address,string)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, bool p1, address p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,bool,address,bool)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, bool p1, address p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,bool,address,address)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, address p1, uint256 p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,address,uint256,uint256)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, address p1, uint256 p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,address,uint256,string)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, address p1, uint256 p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,address,uint256,bool)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, address p1, uint256 p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,address,uint256,address)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, address p1, string memory p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,address,string,uint256)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, address p1, string memory p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,address,string,string)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, address p1, string memory p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,address,string,bool)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, address p1, string memory p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,address,string,address)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, address p1, bool p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,address,bool,uint256)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, address p1, bool p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,address,bool,string)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, address p1, bool p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,address,bool,bool)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, address p1, bool p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,address,bool,address)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, address p1, address p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,address,address,uint256)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, address p1, address p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,address,address,string)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, address p1, address p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,address,address,bool)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, address p1, address p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,address,address,address)\", p0, p1, p2, p3));\n }\n\n function log(address p0, uint256 p1, uint256 p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,uint256,uint256,uint256)\", p0, p1, p2, p3));\n }\n\n function log(address p0, uint256 p1, uint256 p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,uint256,uint256,string)\", p0, p1, p2, p3));\n }\n\n function log(address p0, uint256 p1, uint256 p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,uint256,uint256,bool)\", p0, p1, p2, p3));\n }\n\n function log(address p0, uint256 p1, uint256 p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,uint256,uint256,address)\", p0, p1, p2, p3));\n }\n\n function log(address p0, uint256 p1, string memory p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,uint256,string,uint256)\", p0, p1, p2, p3));\n }\n\n function log(address p0, uint256 p1, string memory p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,uint256,string,string)\", p0, p1, p2, p3));\n }\n\n function log(address p0, uint256 p1, string memory p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,uint256,string,bool)\", p0, p1, p2, p3));\n }\n\n function log(address p0, uint256 p1, string memory p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,uint256,string,address)\", p0, p1, p2, p3));\n }\n\n function log(address p0, uint256 p1, bool p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,uint256,bool,uint256)\", p0, p1, p2, p3));\n }\n\n function log(address p0, uint256 p1, bool p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,uint256,bool,string)\", p0, p1, p2, p3));\n }\n\n function log(address p0, uint256 p1, bool p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,uint256,bool,bool)\", p0, p1, p2, p3));\n }\n\n function log(address p0, uint256 p1, bool p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,uint256,bool,address)\", p0, p1, p2, p3));\n }\n\n function log(address p0, uint256 p1, address p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,uint256,address,uint256)\", p0, p1, p2, p3));\n }\n\n function log(address p0, uint256 p1, address p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,uint256,address,string)\", p0, p1, p2, p3));\n }\n\n function log(address p0, uint256 p1, address p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,uint256,address,bool)\", p0, p1, p2, p3));\n }\n\n function log(address p0, uint256 p1, address p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,uint256,address,address)\", p0, p1, p2, p3));\n }\n\n function log(address p0, string memory p1, uint256 p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,string,uint256,uint256)\", p0, p1, p2, p3));\n }\n\n function log(address p0, string memory p1, uint256 p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,string,uint256,string)\", p0, p1, p2, p3));\n }\n\n function log(address p0, string memory p1, uint256 p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,string,uint256,bool)\", p0, p1, p2, p3));\n }\n\n function log(address p0, string memory p1, uint256 p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,string,uint256,address)\", p0, p1, p2, p3));\n }\n\n function log(address p0, string memory p1, string memory p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,string,string,uint256)\", p0, p1, p2, p3));\n }\n\n function log(address p0, string memory p1, string memory p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,string,string,string)\", p0, p1, p2, p3));\n }\n\n function log(address p0, string memory p1, string memory p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,string,string,bool)\", p0, p1, p2, p3));\n }\n\n function log(address p0, string memory p1, string memory p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,string,string,address)\", p0, p1, p2, p3));\n }\n\n function log(address p0, string memory p1, bool p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,string,bool,uint256)\", p0, p1, p2, p3));\n }\n\n function log(address p0, string memory p1, bool p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,string,bool,string)\", p0, p1, p2, p3));\n }\n\n function log(address p0, string memory p1, bool p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,string,bool,bool)\", p0, p1, p2, p3));\n }\n\n function log(address p0, string memory p1, bool p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,string,bool,address)\", p0, p1, p2, p3));\n }\n\n function log(address p0, string memory p1, address p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,string,address,uint256)\", p0, p1, p2, p3));\n }\n\n function log(address p0, string memory p1, address p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,string,address,string)\", p0, p1, p2, p3));\n }\n\n function log(address p0, string memory p1, address p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,string,address,bool)\", p0, p1, p2, p3));\n }\n\n function log(address p0, string memory p1, address p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,string,address,address)\", p0, p1, p2, p3));\n }\n\n function log(address p0, bool p1, uint256 p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,bool,uint256,uint256)\", p0, p1, p2, p3));\n }\n\n function log(address p0, bool p1, uint256 p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,bool,uint256,string)\", p0, p1, p2, p3));\n }\n\n function log(address p0, bool p1, uint256 p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,bool,uint256,bool)\", p0, p1, p2, p3));\n }\n\n function log(address p0, bool p1, uint256 p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,bool,uint256,address)\", p0, p1, p2, p3));\n }\n\n function log(address p0, bool p1, string memory p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,bool,string,uint256)\", p0, p1, p2, p3));\n }\n\n function log(address p0, bool p1, string memory p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,bool,string,string)\", p0, p1, p2, p3));\n }\n\n function log(address p0, bool p1, string memory p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,bool,string,bool)\", p0, p1, p2, p3));\n }\n\n function log(address p0, bool p1, string memory p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,bool,string,address)\", p0, p1, p2, p3));\n }\n\n function log(address p0, bool p1, bool p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,bool,bool,uint256)\", p0, p1, p2, p3));\n }\n\n function log(address p0, bool p1, bool p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,bool,bool,string)\", p0, p1, p2, p3));\n }\n\n function log(address p0, bool p1, bool p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,bool,bool,bool)\", p0, p1, p2, p3));\n }\n\n function log(address p0, bool p1, bool p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,bool,bool,address)\", p0, p1, p2, p3));\n }\n\n function log(address p0, bool p1, address p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,bool,address,uint256)\", p0, p1, p2, p3));\n }\n\n function log(address p0, bool p1, address p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,bool,address,string)\", p0, p1, p2, p3));\n }\n\n function log(address p0, bool p1, address p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,bool,address,bool)\", p0, p1, p2, p3));\n }\n\n function log(address p0, bool p1, address p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,bool,address,address)\", p0, p1, p2, p3));\n }\n\n function log(address p0, address p1, uint256 p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,address,uint256,uint256)\", p0, p1, p2, p3));\n }\n\n function log(address p0, address p1, uint256 p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,address,uint256,string)\", p0, p1, p2, p3));\n }\n\n function log(address p0, address p1, uint256 p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,address,uint256,bool)\", p0, p1, p2, p3));\n }\n\n function log(address p0, address p1, uint256 p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,address,uint256,address)\", p0, p1, p2, p3));\n }\n\n function log(address p0, address p1, string memory p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,address,string,uint256)\", p0, p1, p2, p3));\n }\n\n function log(address p0, address p1, string memory p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,address,string,string)\", p0, p1, p2, p3));\n }\n\n function log(address p0, address p1, string memory p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,address,string,bool)\", p0, p1, p2, p3));\n }\n\n function log(address p0, address p1, string memory p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,address,string,address)\", p0, p1, p2, p3));\n }\n\n function log(address p0, address p1, bool p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,address,bool,uint256)\", p0, p1, p2, p3));\n }\n\n function log(address p0, address p1, bool p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,address,bool,string)\", p0, p1, p2, p3));\n }\n\n function log(address p0, address p1, bool p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,address,bool,bool)\", p0, p1, p2, p3));\n }\n\n function log(address p0, address p1, bool p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,address,bool,address)\", p0, p1, p2, p3));\n }\n\n function log(address p0, address p1, address p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,address,address,uint256)\", p0, p1, p2, p3));\n }\n\n function log(address p0, address p1, address p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,address,address,string)\", p0, p1, p2, p3));\n }\n\n function log(address p0, address p1, address p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,address,address,bool)\", p0, p1, p2, p3));\n }\n\n function log(address p0, address p1, address p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,address,address,address)\", p0, p1, p2, p3));\n }\n}\n","license":"MIT"},"lib/forge-std/src/console2.sol":{"keccak256":"0x3b8fe79f48f065a4e4d35362171304a33784c3a90febae5f2787805a438de12f","urls":[],"content":"// SPDX-License-Identifier: MIT\npragma solidity >=0.4.22 <0.9.0;\n\nimport {console as console2} from \"./console.sol\";\n","license":"MIT"},"lib/forge-std/src/interfaces/IMulticall3.sol":{"keccak256":"0x7aac1389150499a922d1f9ef5749c908cef127cb2075b92fa17e9cb611263d0a","urls":[],"content":"// SPDX-License-Identifier: MIT\npragma solidity >=0.6.2 <0.9.0;\n\npragma experimental ABIEncoderV2;\n\ninterface IMulticall3 {\n struct Call {\n address target;\n bytes callData;\n }\n\n struct Call3 {\n address target;\n bool allowFailure;\n bytes callData;\n }\n\n struct Call3Value {\n address target;\n bool allowFailure;\n uint256 value;\n bytes callData;\n }\n\n struct Result {\n bool success;\n bytes returnData;\n }\n\n function aggregate(Call[] calldata calls)\n external\n payable\n returns (uint256 blockNumber, bytes[] memory returnData);\n\n function aggregate3(Call3[] calldata calls) external payable returns (Result[] memory returnData);\n\n function aggregate3Value(Call3Value[] calldata calls) external payable returns (Result[] memory returnData);\n\n function blockAndAggregate(Call[] calldata calls)\n external\n payable\n returns (uint256 blockNumber, bytes32 blockHash, Result[] memory returnData);\n\n function getBasefee() external view returns (uint256 basefee);\n\n function getBlockHash(uint256 blockNumber) external view returns (bytes32 blockHash);\n\n function getBlockNumber() external view returns (uint256 blockNumber);\n\n function getChainId() external view returns (uint256 chainid);\n\n function getCurrentBlockCoinbase() external view returns (address coinbase);\n\n function getCurrentBlockDifficulty() external view returns (uint256 difficulty);\n\n function getCurrentBlockGasLimit() external view returns (uint256 gaslimit);\n\n function getCurrentBlockTimestamp() external view returns (uint256 timestamp);\n\n function getEthBalance(address addr) external view returns (uint256 balance);\n\n function getLastBlockHash() external view returns (bytes32 blockHash);\n\n function tryAggregate(bool requireSuccess, Call[] calldata calls)\n external\n payable\n returns (Result[] memory returnData);\n\n function tryBlockAndAggregate(bool requireSuccess, Call[] calldata calls)\n external\n payable\n returns (uint256 blockNumber, bytes32 blockHash, Result[] memory returnData);\n}\n","license":"MIT"},"lib/forge-std/src/safeconsole.sol":{"keccak256":"0xbef9786cb49d3eade757bad87568c49c8c8f35721f0193c95ffb055d9e466e11","urls":[],"content":"// SPDX-License-Identifier: MIT\npragma solidity >=0.6.2 <0.9.0;\n\n/// @author philogy \n/// @dev Code generated automatically by script.\nlibrary safeconsole {\n uint256 constant CONSOLE_ADDR = 0x000000000000000000000000000000000000000000636F6e736F6c652e6c6f67;\n\n // Credit to [0age](https://twitter.com/z0age/status/1654922202930888704) and [0xdapper](https://github.com/foundry-rs/forge-std/pull/374)\n // for the view-to-pure log trick.\n function _sendLogPayload(uint256 offset, uint256 size) private pure {\n function(uint256, uint256) internal view fnIn = _sendLogPayloadView;\n function(uint256, uint256) internal pure pureSendLogPayload;\n /// @solidity memory-safe-assembly\n assembly {\n pureSendLogPayload := fnIn\n }\n pureSendLogPayload(offset, size);\n }\n\n function _sendLogPayloadView(uint256 offset, uint256 size) private view {\n /// @solidity memory-safe-assembly\n assembly {\n pop(staticcall(gas(), CONSOLE_ADDR, offset, size, 0x0, 0x0))\n }\n }\n\n function _memcopy(uint256 fromOffset, uint256 toOffset, uint256 length) private pure {\n function(uint256, uint256, uint256) internal view fnIn = _memcopyView;\n function(uint256, uint256, uint256) internal pure pureMemcopy;\n /// @solidity memory-safe-assembly\n assembly {\n pureMemcopy := fnIn\n }\n pureMemcopy(fromOffset, toOffset, length);\n }\n\n function _memcopyView(uint256 fromOffset, uint256 toOffset, uint256 length) private view {\n /// @solidity memory-safe-assembly\n assembly {\n pop(staticcall(gas(), 0x4, fromOffset, length, toOffset, length))\n }\n }\n\n function logMemory(uint256 offset, uint256 length) internal pure {\n if (offset >= 0x60) {\n // Sufficient memory before slice to prepare call header.\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(sub(offset, 0x60))\n m1 := mload(sub(offset, 0x40))\n m2 := mload(sub(offset, 0x20))\n // Selector of `log(bytes)`.\n mstore(sub(offset, 0x60), 0x0be77f56)\n mstore(sub(offset, 0x40), 0x20)\n mstore(sub(offset, 0x20), length)\n }\n _sendLogPayload(offset - 0x44, length + 0x44);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(sub(offset, 0x60), m0)\n mstore(sub(offset, 0x40), m1)\n mstore(sub(offset, 0x20), m2)\n }\n } else {\n // Insufficient space, so copy slice forward, add header and reverse.\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n uint256 endOffset = offset + length;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(add(endOffset, 0x00))\n m1 := mload(add(endOffset, 0x20))\n m2 := mload(add(endOffset, 0x40))\n }\n _memcopy(offset, offset + 0x60, length);\n /// @solidity memory-safe-assembly\n assembly {\n // Selector of `log(bytes)`.\n mstore(add(offset, 0x00), 0x0be77f56)\n mstore(add(offset, 0x20), 0x20)\n mstore(add(offset, 0x40), length)\n }\n _sendLogPayload(offset + 0x1c, length + 0x44);\n _memcopy(offset + 0x60, offset, length);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(add(endOffset, 0x00), m0)\n mstore(add(endOffset, 0x20), m1)\n mstore(add(endOffset, 0x40), m2)\n }\n }\n }\n\n function log(address p0) internal pure {\n bytes32 m0;\n bytes32 m1;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n // Selector of `log(address)`.\n mstore(0x00, 0x2c2ecbc2)\n mstore(0x20, p0)\n }\n _sendLogPayload(0x1c, 0x24);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n }\n }\n\n function log(bool p0) internal pure {\n bytes32 m0;\n bytes32 m1;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n // Selector of `log(bool)`.\n mstore(0x00, 0x32458eed)\n mstore(0x20, p0)\n }\n _sendLogPayload(0x1c, 0x24);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n }\n }\n\n function log(uint256 p0) internal pure {\n bytes32 m0;\n bytes32 m1;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n // Selector of `log(uint256)`.\n mstore(0x00, 0xf82c50f1)\n mstore(0x20, p0)\n }\n _sendLogPayload(0x1c, 0x24);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n }\n }\n\n function log(bytes32 p0) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n // Selector of `log(string)`.\n mstore(0x00, 0x41304fac)\n mstore(0x20, 0x20)\n writeString(0x40, p0)\n }\n _sendLogPayload(0x1c, 0x64);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n }\n }\n\n function log(address p0, address p1) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n // Selector of `log(address,address)`.\n mstore(0x00, 0xdaf0d4aa)\n mstore(0x20, p0)\n mstore(0x40, p1)\n }\n _sendLogPayload(0x1c, 0x44);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n }\n }\n\n function log(address p0, bool p1) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n // Selector of `log(address,bool)`.\n mstore(0x00, 0x75b605d3)\n mstore(0x20, p0)\n mstore(0x40, p1)\n }\n _sendLogPayload(0x1c, 0x44);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n }\n }\n\n function log(address p0, uint256 p1) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n // Selector of `log(address,uint256)`.\n mstore(0x00, 0x8309e8a8)\n mstore(0x20, p0)\n mstore(0x40, p1)\n }\n _sendLogPayload(0x1c, 0x44);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n }\n }\n\n function log(address p0, bytes32 p1) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(address,string)`.\n mstore(0x00, 0x759f86bb)\n mstore(0x20, p0)\n mstore(0x40, 0x40)\n writeString(0x60, p1)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(bool p0, address p1) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n // Selector of `log(bool,address)`.\n mstore(0x00, 0x853c4849)\n mstore(0x20, p0)\n mstore(0x40, p1)\n }\n _sendLogPayload(0x1c, 0x44);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n }\n }\n\n function log(bool p0, bool p1) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n // Selector of `log(bool,bool)`.\n mstore(0x00, 0x2a110e83)\n mstore(0x20, p0)\n mstore(0x40, p1)\n }\n _sendLogPayload(0x1c, 0x44);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n }\n }\n\n function log(bool p0, uint256 p1) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n // Selector of `log(bool,uint256)`.\n mstore(0x00, 0x399174d3)\n mstore(0x20, p0)\n mstore(0x40, p1)\n }\n _sendLogPayload(0x1c, 0x44);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n }\n }\n\n function log(bool p0, bytes32 p1) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(bool,string)`.\n mstore(0x00, 0x8feac525)\n mstore(0x20, p0)\n mstore(0x40, 0x40)\n writeString(0x60, p1)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(uint256 p0, address p1) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n // Selector of `log(uint256,address)`.\n mstore(0x00, 0x69276c86)\n mstore(0x20, p0)\n mstore(0x40, p1)\n }\n _sendLogPayload(0x1c, 0x44);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n }\n }\n\n function log(uint256 p0, bool p1) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n // Selector of `log(uint256,bool)`.\n mstore(0x00, 0x1c9d7eb3)\n mstore(0x20, p0)\n mstore(0x40, p1)\n }\n _sendLogPayload(0x1c, 0x44);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n }\n }\n\n function log(uint256 p0, uint256 p1) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n // Selector of `log(uint256,uint256)`.\n mstore(0x00, 0xf666715a)\n mstore(0x20, p0)\n mstore(0x40, p1)\n }\n _sendLogPayload(0x1c, 0x44);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n }\n }\n\n function log(uint256 p0, bytes32 p1) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(uint256,string)`.\n mstore(0x00, 0x643fd0df)\n mstore(0x20, p0)\n mstore(0x40, 0x40)\n writeString(0x60, p1)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(bytes32 p0, address p1) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(string,address)`.\n mstore(0x00, 0x319af333)\n mstore(0x20, 0x40)\n mstore(0x40, p1)\n writeString(0x60, p0)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(bytes32 p0, bool p1) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(string,bool)`.\n mstore(0x00, 0xc3b55635)\n mstore(0x20, 0x40)\n mstore(0x40, p1)\n writeString(0x60, p0)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(bytes32 p0, uint256 p1) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(string,uint256)`.\n mstore(0x00, 0xb60e72cc)\n mstore(0x20, 0x40)\n mstore(0x40, p1)\n writeString(0x60, p0)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(bytes32 p0, bytes32 p1) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(string,string)`.\n mstore(0x00, 0x4b5c4277)\n mstore(0x20, 0x40)\n mstore(0x40, 0x80)\n writeString(0x60, p0)\n writeString(0xa0, p1)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(address p0, address p1, address p2) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n // Selector of `log(address,address,address)`.\n mstore(0x00, 0x018c84c2)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n }\n _sendLogPayload(0x1c, 0x64);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n }\n }\n\n function log(address p0, address p1, bool p2) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n // Selector of `log(address,address,bool)`.\n mstore(0x00, 0xf2a66286)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n }\n _sendLogPayload(0x1c, 0x64);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n }\n }\n\n function log(address p0, address p1, uint256 p2) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n // Selector of `log(address,address,uint256)`.\n mstore(0x00, 0x17fe6185)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n }\n _sendLogPayload(0x1c, 0x64);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n }\n }\n\n function log(address p0, address p1, bytes32 p2) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n // Selector of `log(address,address,string)`.\n mstore(0x00, 0x007150be)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, 0x60)\n writeString(0x80, p2)\n }\n _sendLogPayload(0x1c, 0xa4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n }\n }\n\n function log(address p0, bool p1, address p2) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n // Selector of `log(address,bool,address)`.\n mstore(0x00, 0xf11699ed)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n }\n _sendLogPayload(0x1c, 0x64);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n }\n }\n\n function log(address p0, bool p1, bool p2) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n // Selector of `log(address,bool,bool)`.\n mstore(0x00, 0xeb830c92)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n }\n _sendLogPayload(0x1c, 0x64);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n }\n }\n\n function log(address p0, bool p1, uint256 p2) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n // Selector of `log(address,bool,uint256)`.\n mstore(0x00, 0x9c4f99fb)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n }\n _sendLogPayload(0x1c, 0x64);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n }\n }\n\n function log(address p0, bool p1, bytes32 p2) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n // Selector of `log(address,bool,string)`.\n mstore(0x00, 0x212255cc)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, 0x60)\n writeString(0x80, p2)\n }\n _sendLogPayload(0x1c, 0xa4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n }\n }\n\n function log(address p0, uint256 p1, address p2) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n // Selector of `log(address,uint256,address)`.\n mstore(0x00, 0x7bc0d848)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n }\n _sendLogPayload(0x1c, 0x64);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n }\n }\n\n function log(address p0, uint256 p1, bool p2) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n // Selector of `log(address,uint256,bool)`.\n mstore(0x00, 0x678209a8)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n }\n _sendLogPayload(0x1c, 0x64);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n }\n }\n\n function log(address p0, uint256 p1, uint256 p2) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n // Selector of `log(address,uint256,uint256)`.\n mstore(0x00, 0xb69bcaf6)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n }\n _sendLogPayload(0x1c, 0x64);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n }\n }\n\n function log(address p0, uint256 p1, bytes32 p2) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n // Selector of `log(address,uint256,string)`.\n mstore(0x00, 0xa1f2e8aa)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, 0x60)\n writeString(0x80, p2)\n }\n _sendLogPayload(0x1c, 0xa4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n }\n }\n\n function log(address p0, bytes32 p1, address p2) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n // Selector of `log(address,string,address)`.\n mstore(0x00, 0xf08744e8)\n mstore(0x20, p0)\n mstore(0x40, 0x60)\n mstore(0x60, p2)\n writeString(0x80, p1)\n }\n _sendLogPayload(0x1c, 0xa4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n }\n }\n\n function log(address p0, bytes32 p1, bool p2) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n // Selector of `log(address,string,bool)`.\n mstore(0x00, 0xcf020fb1)\n mstore(0x20, p0)\n mstore(0x40, 0x60)\n mstore(0x60, p2)\n writeString(0x80, p1)\n }\n _sendLogPayload(0x1c, 0xa4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n }\n }\n\n function log(address p0, bytes32 p1, uint256 p2) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n // Selector of `log(address,string,uint256)`.\n mstore(0x00, 0x67dd6ff1)\n mstore(0x20, p0)\n mstore(0x40, 0x60)\n mstore(0x60, p2)\n writeString(0x80, p1)\n }\n _sendLogPayload(0x1c, 0xa4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n }\n }\n\n function log(address p0, bytes32 p1, bytes32 p2) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n // Selector of `log(address,string,string)`.\n mstore(0x00, 0xfb772265)\n mstore(0x20, p0)\n mstore(0x40, 0x60)\n mstore(0x60, 0xa0)\n writeString(0x80, p1)\n writeString(0xc0, p2)\n }\n _sendLogPayload(0x1c, 0xe4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n }\n }\n\n function log(bool p0, address p1, address p2) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n // Selector of `log(bool,address,address)`.\n mstore(0x00, 0xd2763667)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n }\n _sendLogPayload(0x1c, 0x64);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n }\n }\n\n function log(bool p0, address p1, bool p2) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n // Selector of `log(bool,address,bool)`.\n mstore(0x00, 0x18c9c746)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n }\n _sendLogPayload(0x1c, 0x64);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n }\n }\n\n function log(bool p0, address p1, uint256 p2) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n // Selector of `log(bool,address,uint256)`.\n mstore(0x00, 0x5f7b9afb)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n }\n _sendLogPayload(0x1c, 0x64);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n }\n }\n\n function log(bool p0, address p1, bytes32 p2) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n // Selector of `log(bool,address,string)`.\n mstore(0x00, 0xde9a9270)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, 0x60)\n writeString(0x80, p2)\n }\n _sendLogPayload(0x1c, 0xa4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n }\n }\n\n function log(bool p0, bool p1, address p2) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n // Selector of `log(bool,bool,address)`.\n mstore(0x00, 0x1078f68d)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n }\n _sendLogPayload(0x1c, 0x64);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n }\n }\n\n function log(bool p0, bool p1, bool p2) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n // Selector of `log(bool,bool,bool)`.\n mstore(0x00, 0x50709698)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n }\n _sendLogPayload(0x1c, 0x64);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n }\n }\n\n function log(bool p0, bool p1, uint256 p2) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n // Selector of `log(bool,bool,uint256)`.\n mstore(0x00, 0x12f21602)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n }\n _sendLogPayload(0x1c, 0x64);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n }\n }\n\n function log(bool p0, bool p1, bytes32 p2) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n // Selector of `log(bool,bool,string)`.\n mstore(0x00, 0x2555fa46)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, 0x60)\n writeString(0x80, p2)\n }\n _sendLogPayload(0x1c, 0xa4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n }\n }\n\n function log(bool p0, uint256 p1, address p2) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n // Selector of `log(bool,uint256,address)`.\n mstore(0x00, 0x088ef9d2)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n }\n _sendLogPayload(0x1c, 0x64);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n }\n }\n\n function log(bool p0, uint256 p1, bool p2) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n // Selector of `log(bool,uint256,bool)`.\n mstore(0x00, 0xe8defba9)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n }\n _sendLogPayload(0x1c, 0x64);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n }\n }\n\n function log(bool p0, uint256 p1, uint256 p2) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n // Selector of `log(bool,uint256,uint256)`.\n mstore(0x00, 0x37103367)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n }\n _sendLogPayload(0x1c, 0x64);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n }\n }\n\n function log(bool p0, uint256 p1, bytes32 p2) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n // Selector of `log(bool,uint256,string)`.\n mstore(0x00, 0xc3fc3970)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, 0x60)\n writeString(0x80, p2)\n }\n _sendLogPayload(0x1c, 0xa4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n }\n }\n\n function log(bool p0, bytes32 p1, address p2) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n // Selector of `log(bool,string,address)`.\n mstore(0x00, 0x9591b953)\n mstore(0x20, p0)\n mstore(0x40, 0x60)\n mstore(0x60, p2)\n writeString(0x80, p1)\n }\n _sendLogPayload(0x1c, 0xa4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n }\n }\n\n function log(bool p0, bytes32 p1, bool p2) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n // Selector of `log(bool,string,bool)`.\n mstore(0x00, 0xdbb4c247)\n mstore(0x20, p0)\n mstore(0x40, 0x60)\n mstore(0x60, p2)\n writeString(0x80, p1)\n }\n _sendLogPayload(0x1c, 0xa4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n }\n }\n\n function log(bool p0, bytes32 p1, uint256 p2) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n // Selector of `log(bool,string,uint256)`.\n mstore(0x00, 0x1093ee11)\n mstore(0x20, p0)\n mstore(0x40, 0x60)\n mstore(0x60, p2)\n writeString(0x80, p1)\n }\n _sendLogPayload(0x1c, 0xa4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n }\n }\n\n function log(bool p0, bytes32 p1, bytes32 p2) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n // Selector of `log(bool,string,string)`.\n mstore(0x00, 0xb076847f)\n mstore(0x20, p0)\n mstore(0x40, 0x60)\n mstore(0x60, 0xa0)\n writeString(0x80, p1)\n writeString(0xc0, p2)\n }\n _sendLogPayload(0x1c, 0xe4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n }\n }\n\n function log(uint256 p0, address p1, address p2) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n // Selector of `log(uint256,address,address)`.\n mstore(0x00, 0xbcfd9be0)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n }\n _sendLogPayload(0x1c, 0x64);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n }\n }\n\n function log(uint256 p0, address p1, bool p2) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n // Selector of `log(uint256,address,bool)`.\n mstore(0x00, 0x9b6ec042)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n }\n _sendLogPayload(0x1c, 0x64);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n }\n }\n\n function log(uint256 p0, address p1, uint256 p2) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n // Selector of `log(uint256,address,uint256)`.\n mstore(0x00, 0x5a9b5ed5)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n }\n _sendLogPayload(0x1c, 0x64);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n }\n }\n\n function log(uint256 p0, address p1, bytes32 p2) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n // Selector of `log(uint256,address,string)`.\n mstore(0x00, 0x63cb41f9)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, 0x60)\n writeString(0x80, p2)\n }\n _sendLogPayload(0x1c, 0xa4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n }\n }\n\n function log(uint256 p0, bool p1, address p2) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n // Selector of `log(uint256,bool,address)`.\n mstore(0x00, 0x35085f7b)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n }\n _sendLogPayload(0x1c, 0x64);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n }\n }\n\n function log(uint256 p0, bool p1, bool p2) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n // Selector of `log(uint256,bool,bool)`.\n mstore(0x00, 0x20718650)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n }\n _sendLogPayload(0x1c, 0x64);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n }\n }\n\n function log(uint256 p0, bool p1, uint256 p2) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n // Selector of `log(uint256,bool,uint256)`.\n mstore(0x00, 0x20098014)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n }\n _sendLogPayload(0x1c, 0x64);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n }\n }\n\n function log(uint256 p0, bool p1, bytes32 p2) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n // Selector of `log(uint256,bool,string)`.\n mstore(0x00, 0x85775021)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, 0x60)\n writeString(0x80, p2)\n }\n _sendLogPayload(0x1c, 0xa4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n }\n }\n\n function log(uint256 p0, uint256 p1, address p2) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n // Selector of `log(uint256,uint256,address)`.\n mstore(0x00, 0x5c96b331)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n }\n _sendLogPayload(0x1c, 0x64);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n }\n }\n\n function log(uint256 p0, uint256 p1, bool p2) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n // Selector of `log(uint256,uint256,bool)`.\n mstore(0x00, 0x4766da72)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n }\n _sendLogPayload(0x1c, 0x64);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n }\n }\n\n function log(uint256 p0, uint256 p1, uint256 p2) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n // Selector of `log(uint256,uint256,uint256)`.\n mstore(0x00, 0xd1ed7a3c)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n }\n _sendLogPayload(0x1c, 0x64);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n }\n }\n\n function log(uint256 p0, uint256 p1, bytes32 p2) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n // Selector of `log(uint256,uint256,string)`.\n mstore(0x00, 0x71d04af2)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, 0x60)\n writeString(0x80, p2)\n }\n _sendLogPayload(0x1c, 0xa4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n }\n }\n\n function log(uint256 p0, bytes32 p1, address p2) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n // Selector of `log(uint256,string,address)`.\n mstore(0x00, 0x7afac959)\n mstore(0x20, p0)\n mstore(0x40, 0x60)\n mstore(0x60, p2)\n writeString(0x80, p1)\n }\n _sendLogPayload(0x1c, 0xa4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n }\n }\n\n function log(uint256 p0, bytes32 p1, bool p2) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n // Selector of `log(uint256,string,bool)`.\n mstore(0x00, 0x4ceda75a)\n mstore(0x20, p0)\n mstore(0x40, 0x60)\n mstore(0x60, p2)\n writeString(0x80, p1)\n }\n _sendLogPayload(0x1c, 0xa4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n }\n }\n\n function log(uint256 p0, bytes32 p1, uint256 p2) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n // Selector of `log(uint256,string,uint256)`.\n mstore(0x00, 0x37aa7d4c)\n mstore(0x20, p0)\n mstore(0x40, 0x60)\n mstore(0x60, p2)\n writeString(0x80, p1)\n }\n _sendLogPayload(0x1c, 0xa4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n }\n }\n\n function log(uint256 p0, bytes32 p1, bytes32 p2) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n // Selector of `log(uint256,string,string)`.\n mstore(0x00, 0xb115611f)\n mstore(0x20, p0)\n mstore(0x40, 0x60)\n mstore(0x60, 0xa0)\n writeString(0x80, p1)\n writeString(0xc0, p2)\n }\n _sendLogPayload(0x1c, 0xe4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n }\n }\n\n function log(bytes32 p0, address p1, address p2) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n // Selector of `log(string,address,address)`.\n mstore(0x00, 0xfcec75e0)\n mstore(0x20, 0x60)\n mstore(0x40, p1)\n mstore(0x60, p2)\n writeString(0x80, p0)\n }\n _sendLogPayload(0x1c, 0xa4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n }\n }\n\n function log(bytes32 p0, address p1, bool p2) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n // Selector of `log(string,address,bool)`.\n mstore(0x00, 0xc91d5ed4)\n mstore(0x20, 0x60)\n mstore(0x40, p1)\n mstore(0x60, p2)\n writeString(0x80, p0)\n }\n _sendLogPayload(0x1c, 0xa4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n }\n }\n\n function log(bytes32 p0, address p1, uint256 p2) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n // Selector of `log(string,address,uint256)`.\n mstore(0x00, 0x0d26b925)\n mstore(0x20, 0x60)\n mstore(0x40, p1)\n mstore(0x60, p2)\n writeString(0x80, p0)\n }\n _sendLogPayload(0x1c, 0xa4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n }\n }\n\n function log(bytes32 p0, address p1, bytes32 p2) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n // Selector of `log(string,address,string)`.\n mstore(0x00, 0xe0e9ad4f)\n mstore(0x20, 0x60)\n mstore(0x40, p1)\n mstore(0x60, 0xa0)\n writeString(0x80, p0)\n writeString(0xc0, p2)\n }\n _sendLogPayload(0x1c, 0xe4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n }\n }\n\n function log(bytes32 p0, bool p1, address p2) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n // Selector of `log(string,bool,address)`.\n mstore(0x00, 0x932bbb38)\n mstore(0x20, 0x60)\n mstore(0x40, p1)\n mstore(0x60, p2)\n writeString(0x80, p0)\n }\n _sendLogPayload(0x1c, 0xa4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n }\n }\n\n function log(bytes32 p0, bool p1, bool p2) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n // Selector of `log(string,bool,bool)`.\n mstore(0x00, 0x850b7ad6)\n mstore(0x20, 0x60)\n mstore(0x40, p1)\n mstore(0x60, p2)\n writeString(0x80, p0)\n }\n _sendLogPayload(0x1c, 0xa4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n }\n }\n\n function log(bytes32 p0, bool p1, uint256 p2) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n // Selector of `log(string,bool,uint256)`.\n mstore(0x00, 0xc95958d6)\n mstore(0x20, 0x60)\n mstore(0x40, p1)\n mstore(0x60, p2)\n writeString(0x80, p0)\n }\n _sendLogPayload(0x1c, 0xa4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n }\n }\n\n function log(bytes32 p0, bool p1, bytes32 p2) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n // Selector of `log(string,bool,string)`.\n mstore(0x00, 0xe298f47d)\n mstore(0x20, 0x60)\n mstore(0x40, p1)\n mstore(0x60, 0xa0)\n writeString(0x80, p0)\n writeString(0xc0, p2)\n }\n _sendLogPayload(0x1c, 0xe4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n }\n }\n\n function log(bytes32 p0, uint256 p1, address p2) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n // Selector of `log(string,uint256,address)`.\n mstore(0x00, 0x1c7ec448)\n mstore(0x20, 0x60)\n mstore(0x40, p1)\n mstore(0x60, p2)\n writeString(0x80, p0)\n }\n _sendLogPayload(0x1c, 0xa4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n }\n }\n\n function log(bytes32 p0, uint256 p1, bool p2) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n // Selector of `log(string,uint256,bool)`.\n mstore(0x00, 0xca7733b1)\n mstore(0x20, 0x60)\n mstore(0x40, p1)\n mstore(0x60, p2)\n writeString(0x80, p0)\n }\n _sendLogPayload(0x1c, 0xa4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n }\n }\n\n function log(bytes32 p0, uint256 p1, uint256 p2) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n // Selector of `log(string,uint256,uint256)`.\n mstore(0x00, 0xca47c4eb)\n mstore(0x20, 0x60)\n mstore(0x40, p1)\n mstore(0x60, p2)\n writeString(0x80, p0)\n }\n _sendLogPayload(0x1c, 0xa4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n }\n }\n\n function log(bytes32 p0, uint256 p1, bytes32 p2) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n // Selector of `log(string,uint256,string)`.\n mstore(0x00, 0x5970e089)\n mstore(0x20, 0x60)\n mstore(0x40, p1)\n mstore(0x60, 0xa0)\n writeString(0x80, p0)\n writeString(0xc0, p2)\n }\n _sendLogPayload(0x1c, 0xe4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n }\n }\n\n function log(bytes32 p0, bytes32 p1, address p2) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n // Selector of `log(string,string,address)`.\n mstore(0x00, 0x95ed0195)\n mstore(0x20, 0x60)\n mstore(0x40, 0xa0)\n mstore(0x60, p2)\n writeString(0x80, p0)\n writeString(0xc0, p1)\n }\n _sendLogPayload(0x1c, 0xe4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n }\n }\n\n function log(bytes32 p0, bytes32 p1, bool p2) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n // Selector of `log(string,string,bool)`.\n mstore(0x00, 0xb0e0f9b5)\n mstore(0x20, 0x60)\n mstore(0x40, 0xa0)\n mstore(0x60, p2)\n writeString(0x80, p0)\n writeString(0xc0, p1)\n }\n _sendLogPayload(0x1c, 0xe4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n }\n }\n\n function log(bytes32 p0, bytes32 p1, uint256 p2) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n // Selector of `log(string,string,uint256)`.\n mstore(0x00, 0x5821efa1)\n mstore(0x20, 0x60)\n mstore(0x40, 0xa0)\n mstore(0x60, p2)\n writeString(0x80, p0)\n writeString(0xc0, p1)\n }\n _sendLogPayload(0x1c, 0xe4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n }\n }\n\n function log(bytes32 p0, bytes32 p1, bytes32 p2) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n bytes32 m9;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n m9 := mload(0x120)\n // Selector of `log(string,string,string)`.\n mstore(0x00, 0x2ced7cef)\n mstore(0x20, 0x60)\n mstore(0x40, 0xa0)\n mstore(0x60, 0xe0)\n writeString(0x80, p0)\n writeString(0xc0, p1)\n writeString(0x100, p2)\n }\n _sendLogPayload(0x1c, 0x124);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n mstore(0x120, m9)\n }\n }\n\n function log(address p0, address p1, address p2, address p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(address,address,address,address)`.\n mstore(0x00, 0x665bf134)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(address p0, address p1, address p2, bool p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(address,address,address,bool)`.\n mstore(0x00, 0x0e378994)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(address p0, address p1, address p2, uint256 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(address,address,address,uint256)`.\n mstore(0x00, 0x94250d77)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(address p0, address p1, address p2, bytes32 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(address,address,address,string)`.\n mstore(0x00, 0xf808da20)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, 0x80)\n writeString(0xa0, p3)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(address p0, address p1, bool p2, address p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(address,address,bool,address)`.\n mstore(0x00, 0x9f1bc36e)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(address p0, address p1, bool p2, bool p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(address,address,bool,bool)`.\n mstore(0x00, 0x2cd4134a)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(address p0, address p1, bool p2, uint256 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(address,address,bool,uint256)`.\n mstore(0x00, 0x3971e78c)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(address p0, address p1, bool p2, bytes32 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(address,address,bool,string)`.\n mstore(0x00, 0xaa6540c8)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, 0x80)\n writeString(0xa0, p3)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(address p0, address p1, uint256 p2, address p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(address,address,uint256,address)`.\n mstore(0x00, 0x8da6def5)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(address p0, address p1, uint256 p2, bool p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(address,address,uint256,bool)`.\n mstore(0x00, 0x9b4254e2)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(address p0, address p1, uint256 p2, uint256 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(address,address,uint256,uint256)`.\n mstore(0x00, 0xbe553481)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(address p0, address p1, uint256 p2, bytes32 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(address,address,uint256,string)`.\n mstore(0x00, 0xfdb4f990)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, 0x80)\n writeString(0xa0, p3)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(address p0, address p1, bytes32 p2, address p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(address,address,string,address)`.\n mstore(0x00, 0x8f736d16)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, 0x80)\n mstore(0x80, p3)\n writeString(0xa0, p2)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(address p0, address p1, bytes32 p2, bool p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(address,address,string,bool)`.\n mstore(0x00, 0x6f1a594e)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, 0x80)\n mstore(0x80, p3)\n writeString(0xa0, p2)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(address p0, address p1, bytes32 p2, uint256 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(address,address,string,uint256)`.\n mstore(0x00, 0xef1cefe7)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, 0x80)\n mstore(0x80, p3)\n writeString(0xa0, p2)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(address p0, address p1, bytes32 p2, bytes32 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n // Selector of `log(address,address,string,string)`.\n mstore(0x00, 0x21bdaf25)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, 0x80)\n mstore(0x80, 0xc0)\n writeString(0xa0, p2)\n writeString(0xe0, p3)\n }\n _sendLogPayload(0x1c, 0x104);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n }\n }\n\n function log(address p0, bool p1, address p2, address p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(address,bool,address,address)`.\n mstore(0x00, 0x660375dd)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(address p0, bool p1, address p2, bool p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(address,bool,address,bool)`.\n mstore(0x00, 0xa6f50b0f)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(address p0, bool p1, address p2, uint256 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(address,bool,address,uint256)`.\n mstore(0x00, 0xa75c59de)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(address p0, bool p1, address p2, bytes32 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(address,bool,address,string)`.\n mstore(0x00, 0x2dd778e6)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, 0x80)\n writeString(0xa0, p3)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(address p0, bool p1, bool p2, address p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(address,bool,bool,address)`.\n mstore(0x00, 0xcf394485)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(address p0, bool p1, bool p2, bool p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(address,bool,bool,bool)`.\n mstore(0x00, 0xcac43479)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(address p0, bool p1, bool p2, uint256 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(address,bool,bool,uint256)`.\n mstore(0x00, 0x8c4e5de6)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(address p0, bool p1, bool p2, bytes32 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(address,bool,bool,string)`.\n mstore(0x00, 0xdfc4a2e8)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, 0x80)\n writeString(0xa0, p3)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(address p0, bool p1, uint256 p2, address p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(address,bool,uint256,address)`.\n mstore(0x00, 0xccf790a1)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(address p0, bool p1, uint256 p2, bool p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(address,bool,uint256,bool)`.\n mstore(0x00, 0xc4643e20)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(address p0, bool p1, uint256 p2, uint256 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(address,bool,uint256,uint256)`.\n mstore(0x00, 0x386ff5f4)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(address p0, bool p1, uint256 p2, bytes32 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(address,bool,uint256,string)`.\n mstore(0x00, 0x0aa6cfad)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, 0x80)\n writeString(0xa0, p3)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(address p0, bool p1, bytes32 p2, address p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(address,bool,string,address)`.\n mstore(0x00, 0x19fd4956)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, 0x80)\n mstore(0x80, p3)\n writeString(0xa0, p2)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(address p0, bool p1, bytes32 p2, bool p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(address,bool,string,bool)`.\n mstore(0x00, 0x50ad461d)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, 0x80)\n mstore(0x80, p3)\n writeString(0xa0, p2)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(address p0, bool p1, bytes32 p2, uint256 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(address,bool,string,uint256)`.\n mstore(0x00, 0x80e6a20b)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, 0x80)\n mstore(0x80, p3)\n writeString(0xa0, p2)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(address p0, bool p1, bytes32 p2, bytes32 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n // Selector of `log(address,bool,string,string)`.\n mstore(0x00, 0x475c5c33)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, 0x80)\n mstore(0x80, 0xc0)\n writeString(0xa0, p2)\n writeString(0xe0, p3)\n }\n _sendLogPayload(0x1c, 0x104);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n }\n }\n\n function log(address p0, uint256 p1, address p2, address p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(address,uint256,address,address)`.\n mstore(0x00, 0x478d1c62)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(address p0, uint256 p1, address p2, bool p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(address,uint256,address,bool)`.\n mstore(0x00, 0xa1bcc9b3)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(address p0, uint256 p1, address p2, uint256 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(address,uint256,address,uint256)`.\n mstore(0x00, 0x100f650e)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(address p0, uint256 p1, address p2, bytes32 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(address,uint256,address,string)`.\n mstore(0x00, 0x1da986ea)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, 0x80)\n writeString(0xa0, p3)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(address p0, uint256 p1, bool p2, address p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(address,uint256,bool,address)`.\n mstore(0x00, 0xa31bfdcc)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(address p0, uint256 p1, bool p2, bool p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(address,uint256,bool,bool)`.\n mstore(0x00, 0x3bf5e537)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(address p0, uint256 p1, bool p2, uint256 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(address,uint256,bool,uint256)`.\n mstore(0x00, 0x22f6b999)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(address p0, uint256 p1, bool p2, bytes32 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(address,uint256,bool,string)`.\n mstore(0x00, 0xc5ad85f9)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, 0x80)\n writeString(0xa0, p3)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(address p0, uint256 p1, uint256 p2, address p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(address,uint256,uint256,address)`.\n mstore(0x00, 0x20e3984d)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(address p0, uint256 p1, uint256 p2, bool p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(address,uint256,uint256,bool)`.\n mstore(0x00, 0x66f1bc67)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(address p0, uint256 p1, uint256 p2, uint256 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(address,uint256,uint256,uint256)`.\n mstore(0x00, 0x34f0e636)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(address p0, uint256 p1, uint256 p2, bytes32 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(address,uint256,uint256,string)`.\n mstore(0x00, 0x4a28c017)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, 0x80)\n writeString(0xa0, p3)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(address p0, uint256 p1, bytes32 p2, address p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(address,uint256,string,address)`.\n mstore(0x00, 0x5c430d47)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, 0x80)\n mstore(0x80, p3)\n writeString(0xa0, p2)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(address p0, uint256 p1, bytes32 p2, bool p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(address,uint256,string,bool)`.\n mstore(0x00, 0xcf18105c)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, 0x80)\n mstore(0x80, p3)\n writeString(0xa0, p2)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(address p0, uint256 p1, bytes32 p2, uint256 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(address,uint256,string,uint256)`.\n mstore(0x00, 0xbf01f891)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, 0x80)\n mstore(0x80, p3)\n writeString(0xa0, p2)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(address p0, uint256 p1, bytes32 p2, bytes32 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n // Selector of `log(address,uint256,string,string)`.\n mstore(0x00, 0x88a8c406)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, 0x80)\n mstore(0x80, 0xc0)\n writeString(0xa0, p2)\n writeString(0xe0, p3)\n }\n _sendLogPayload(0x1c, 0x104);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n }\n }\n\n function log(address p0, bytes32 p1, address p2, address p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(address,string,address,address)`.\n mstore(0x00, 0x0d36fa20)\n mstore(0x20, p0)\n mstore(0x40, 0x80)\n mstore(0x60, p2)\n mstore(0x80, p3)\n writeString(0xa0, p1)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(address p0, bytes32 p1, address p2, bool p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(address,string,address,bool)`.\n mstore(0x00, 0x0df12b76)\n mstore(0x20, p0)\n mstore(0x40, 0x80)\n mstore(0x60, p2)\n mstore(0x80, p3)\n writeString(0xa0, p1)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(address p0, bytes32 p1, address p2, uint256 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(address,string,address,uint256)`.\n mstore(0x00, 0x457fe3cf)\n mstore(0x20, p0)\n mstore(0x40, 0x80)\n mstore(0x60, p2)\n mstore(0x80, p3)\n writeString(0xa0, p1)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(address p0, bytes32 p1, address p2, bytes32 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n // Selector of `log(address,string,address,string)`.\n mstore(0x00, 0xf7e36245)\n mstore(0x20, p0)\n mstore(0x40, 0x80)\n mstore(0x60, p2)\n mstore(0x80, 0xc0)\n writeString(0xa0, p1)\n writeString(0xe0, p3)\n }\n _sendLogPayload(0x1c, 0x104);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n }\n }\n\n function log(address p0, bytes32 p1, bool p2, address p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(address,string,bool,address)`.\n mstore(0x00, 0x205871c2)\n mstore(0x20, p0)\n mstore(0x40, 0x80)\n mstore(0x60, p2)\n mstore(0x80, p3)\n writeString(0xa0, p1)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(address p0, bytes32 p1, bool p2, bool p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(address,string,bool,bool)`.\n mstore(0x00, 0x5f1d5c9f)\n mstore(0x20, p0)\n mstore(0x40, 0x80)\n mstore(0x60, p2)\n mstore(0x80, p3)\n writeString(0xa0, p1)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(address p0, bytes32 p1, bool p2, uint256 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(address,string,bool,uint256)`.\n mstore(0x00, 0x515e38b6)\n mstore(0x20, p0)\n mstore(0x40, 0x80)\n mstore(0x60, p2)\n mstore(0x80, p3)\n writeString(0xa0, p1)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(address p0, bytes32 p1, bool p2, bytes32 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n // Selector of `log(address,string,bool,string)`.\n mstore(0x00, 0xbc0b61fe)\n mstore(0x20, p0)\n mstore(0x40, 0x80)\n mstore(0x60, p2)\n mstore(0x80, 0xc0)\n writeString(0xa0, p1)\n writeString(0xe0, p3)\n }\n _sendLogPayload(0x1c, 0x104);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n }\n }\n\n function log(address p0, bytes32 p1, uint256 p2, address p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(address,string,uint256,address)`.\n mstore(0x00, 0x63183678)\n mstore(0x20, p0)\n mstore(0x40, 0x80)\n mstore(0x60, p2)\n mstore(0x80, p3)\n writeString(0xa0, p1)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(address p0, bytes32 p1, uint256 p2, bool p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(address,string,uint256,bool)`.\n mstore(0x00, 0x0ef7e050)\n mstore(0x20, p0)\n mstore(0x40, 0x80)\n mstore(0x60, p2)\n mstore(0x80, p3)\n writeString(0xa0, p1)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(address p0, bytes32 p1, uint256 p2, uint256 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(address,string,uint256,uint256)`.\n mstore(0x00, 0x1dc8e1b8)\n mstore(0x20, p0)\n mstore(0x40, 0x80)\n mstore(0x60, p2)\n mstore(0x80, p3)\n writeString(0xa0, p1)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(address p0, bytes32 p1, uint256 p2, bytes32 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n // Selector of `log(address,string,uint256,string)`.\n mstore(0x00, 0x448830a8)\n mstore(0x20, p0)\n mstore(0x40, 0x80)\n mstore(0x60, p2)\n mstore(0x80, 0xc0)\n writeString(0xa0, p1)\n writeString(0xe0, p3)\n }\n _sendLogPayload(0x1c, 0x104);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n }\n }\n\n function log(address p0, bytes32 p1, bytes32 p2, address p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n // Selector of `log(address,string,string,address)`.\n mstore(0x00, 0xa04e2f87)\n mstore(0x20, p0)\n mstore(0x40, 0x80)\n mstore(0x60, 0xc0)\n mstore(0x80, p3)\n writeString(0xa0, p1)\n writeString(0xe0, p2)\n }\n _sendLogPayload(0x1c, 0x104);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n }\n }\n\n function log(address p0, bytes32 p1, bytes32 p2, bool p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n // Selector of `log(address,string,string,bool)`.\n mstore(0x00, 0x35a5071f)\n mstore(0x20, p0)\n mstore(0x40, 0x80)\n mstore(0x60, 0xc0)\n mstore(0x80, p3)\n writeString(0xa0, p1)\n writeString(0xe0, p2)\n }\n _sendLogPayload(0x1c, 0x104);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n }\n }\n\n function log(address p0, bytes32 p1, bytes32 p2, uint256 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n // Selector of `log(address,string,string,uint256)`.\n mstore(0x00, 0x159f8927)\n mstore(0x20, p0)\n mstore(0x40, 0x80)\n mstore(0x60, 0xc0)\n mstore(0x80, p3)\n writeString(0xa0, p1)\n writeString(0xe0, p2)\n }\n _sendLogPayload(0x1c, 0x104);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n }\n }\n\n function log(address p0, bytes32 p1, bytes32 p2, bytes32 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n bytes32 m9;\n bytes32 m10;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n m9 := mload(0x120)\n m10 := mload(0x140)\n // Selector of `log(address,string,string,string)`.\n mstore(0x00, 0x5d02c50b)\n mstore(0x20, p0)\n mstore(0x40, 0x80)\n mstore(0x60, 0xc0)\n mstore(0x80, 0x100)\n writeString(0xa0, p1)\n writeString(0xe0, p2)\n writeString(0x120, p3)\n }\n _sendLogPayload(0x1c, 0x144);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n mstore(0x120, m9)\n mstore(0x140, m10)\n }\n }\n\n function log(bool p0, address p1, address p2, address p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(bool,address,address,address)`.\n mstore(0x00, 0x1d14d001)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(bool p0, address p1, address p2, bool p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(bool,address,address,bool)`.\n mstore(0x00, 0x46600be0)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(bool p0, address p1, address p2, uint256 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(bool,address,address,uint256)`.\n mstore(0x00, 0x0c66d1be)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(bool p0, address p1, address p2, bytes32 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(bool,address,address,string)`.\n mstore(0x00, 0xd812a167)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, 0x80)\n writeString(0xa0, p3)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(bool p0, address p1, bool p2, address p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(bool,address,bool,address)`.\n mstore(0x00, 0x1c41a336)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(bool p0, address p1, bool p2, bool p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(bool,address,bool,bool)`.\n mstore(0x00, 0x6a9c478b)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(bool p0, address p1, bool p2, uint256 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(bool,address,bool,uint256)`.\n mstore(0x00, 0x07831502)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(bool p0, address p1, bool p2, bytes32 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(bool,address,bool,string)`.\n mstore(0x00, 0x4a66cb34)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, 0x80)\n writeString(0xa0, p3)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(bool p0, address p1, uint256 p2, address p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(bool,address,uint256,address)`.\n mstore(0x00, 0x136b05dd)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(bool p0, address p1, uint256 p2, bool p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(bool,address,uint256,bool)`.\n mstore(0x00, 0xd6019f1c)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(bool p0, address p1, uint256 p2, uint256 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(bool,address,uint256,uint256)`.\n mstore(0x00, 0x7bf181a1)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(bool p0, address p1, uint256 p2, bytes32 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(bool,address,uint256,string)`.\n mstore(0x00, 0x51f09ff8)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, 0x80)\n writeString(0xa0, p3)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(bool p0, address p1, bytes32 p2, address p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(bool,address,string,address)`.\n mstore(0x00, 0x6f7c603e)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, 0x80)\n mstore(0x80, p3)\n writeString(0xa0, p2)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(bool p0, address p1, bytes32 p2, bool p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(bool,address,string,bool)`.\n mstore(0x00, 0xe2bfd60b)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, 0x80)\n mstore(0x80, p3)\n writeString(0xa0, p2)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(bool p0, address p1, bytes32 p2, uint256 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(bool,address,string,uint256)`.\n mstore(0x00, 0xc21f64c7)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, 0x80)\n mstore(0x80, p3)\n writeString(0xa0, p2)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(bool p0, address p1, bytes32 p2, bytes32 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n // Selector of `log(bool,address,string,string)`.\n mstore(0x00, 0xa73c1db6)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, 0x80)\n mstore(0x80, 0xc0)\n writeString(0xa0, p2)\n writeString(0xe0, p3)\n }\n _sendLogPayload(0x1c, 0x104);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n }\n }\n\n function log(bool p0, bool p1, address p2, address p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(bool,bool,address,address)`.\n mstore(0x00, 0xf4880ea4)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(bool p0, bool p1, address p2, bool p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(bool,bool,address,bool)`.\n mstore(0x00, 0xc0a302d8)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(bool p0, bool p1, address p2, uint256 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(bool,bool,address,uint256)`.\n mstore(0x00, 0x4c123d57)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(bool p0, bool p1, address p2, bytes32 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(bool,bool,address,string)`.\n mstore(0x00, 0xa0a47963)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, 0x80)\n writeString(0xa0, p3)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(bool p0, bool p1, bool p2, address p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(bool,bool,bool,address)`.\n mstore(0x00, 0x8c329b1a)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(bool p0, bool p1, bool p2, bool p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(bool,bool,bool,bool)`.\n mstore(0x00, 0x3b2a5ce0)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(bool p0, bool p1, bool p2, uint256 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(bool,bool,bool,uint256)`.\n mstore(0x00, 0x6d7045c1)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(bool p0, bool p1, bool p2, bytes32 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(bool,bool,bool,string)`.\n mstore(0x00, 0x2ae408d4)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, 0x80)\n writeString(0xa0, p3)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(bool p0, bool p1, uint256 p2, address p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(bool,bool,uint256,address)`.\n mstore(0x00, 0x54a7a9a0)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(bool p0, bool p1, uint256 p2, bool p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(bool,bool,uint256,bool)`.\n mstore(0x00, 0x619e4d0e)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(bool p0, bool p1, uint256 p2, uint256 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(bool,bool,uint256,uint256)`.\n mstore(0x00, 0x0bb00eab)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(bool p0, bool p1, uint256 p2, bytes32 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(bool,bool,uint256,string)`.\n mstore(0x00, 0x7dd4d0e0)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, 0x80)\n writeString(0xa0, p3)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(bool p0, bool p1, bytes32 p2, address p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(bool,bool,string,address)`.\n mstore(0x00, 0xf9ad2b89)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, 0x80)\n mstore(0x80, p3)\n writeString(0xa0, p2)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(bool p0, bool p1, bytes32 p2, bool p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(bool,bool,string,bool)`.\n mstore(0x00, 0xb857163a)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, 0x80)\n mstore(0x80, p3)\n writeString(0xa0, p2)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(bool p0, bool p1, bytes32 p2, uint256 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(bool,bool,string,uint256)`.\n mstore(0x00, 0xe3a9ca2f)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, 0x80)\n mstore(0x80, p3)\n writeString(0xa0, p2)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(bool p0, bool p1, bytes32 p2, bytes32 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n // Selector of `log(bool,bool,string,string)`.\n mstore(0x00, 0x6d1e8751)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, 0x80)\n mstore(0x80, 0xc0)\n writeString(0xa0, p2)\n writeString(0xe0, p3)\n }\n _sendLogPayload(0x1c, 0x104);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n }\n }\n\n function log(bool p0, uint256 p1, address p2, address p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(bool,uint256,address,address)`.\n mstore(0x00, 0x26f560a8)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(bool p0, uint256 p1, address p2, bool p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(bool,uint256,address,bool)`.\n mstore(0x00, 0xb4c314ff)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(bool p0, uint256 p1, address p2, uint256 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(bool,uint256,address,uint256)`.\n mstore(0x00, 0x1537dc87)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(bool p0, uint256 p1, address p2, bytes32 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(bool,uint256,address,string)`.\n mstore(0x00, 0x1bb3b09a)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, 0x80)\n writeString(0xa0, p3)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(bool p0, uint256 p1, bool p2, address p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(bool,uint256,bool,address)`.\n mstore(0x00, 0x9acd3616)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(bool p0, uint256 p1, bool p2, bool p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(bool,uint256,bool,bool)`.\n mstore(0x00, 0xceb5f4d7)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(bool p0, uint256 p1, bool p2, uint256 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(bool,uint256,bool,uint256)`.\n mstore(0x00, 0x7f9bbca2)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(bool p0, uint256 p1, bool p2, bytes32 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(bool,uint256,bool,string)`.\n mstore(0x00, 0x9143dbb1)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, 0x80)\n writeString(0xa0, p3)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(bool p0, uint256 p1, uint256 p2, address p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(bool,uint256,uint256,address)`.\n mstore(0x00, 0x00dd87b9)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(bool p0, uint256 p1, uint256 p2, bool p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(bool,uint256,uint256,bool)`.\n mstore(0x00, 0xbe984353)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(bool p0, uint256 p1, uint256 p2, uint256 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(bool,uint256,uint256,uint256)`.\n mstore(0x00, 0x374bb4b2)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(bool p0, uint256 p1, uint256 p2, bytes32 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(bool,uint256,uint256,string)`.\n mstore(0x00, 0x8e69fb5d)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, 0x80)\n writeString(0xa0, p3)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(bool p0, uint256 p1, bytes32 p2, address p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(bool,uint256,string,address)`.\n mstore(0x00, 0xfedd1fff)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, 0x80)\n mstore(0x80, p3)\n writeString(0xa0, p2)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(bool p0, uint256 p1, bytes32 p2, bool p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(bool,uint256,string,bool)`.\n mstore(0x00, 0xe5e70b2b)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, 0x80)\n mstore(0x80, p3)\n writeString(0xa0, p2)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(bool p0, uint256 p1, bytes32 p2, uint256 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(bool,uint256,string,uint256)`.\n mstore(0x00, 0x6a1199e2)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, 0x80)\n mstore(0x80, p3)\n writeString(0xa0, p2)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(bool p0, uint256 p1, bytes32 p2, bytes32 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n // Selector of `log(bool,uint256,string,string)`.\n mstore(0x00, 0xf5bc2249)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, 0x80)\n mstore(0x80, 0xc0)\n writeString(0xa0, p2)\n writeString(0xe0, p3)\n }\n _sendLogPayload(0x1c, 0x104);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n }\n }\n\n function log(bool p0, bytes32 p1, address p2, address p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(bool,string,address,address)`.\n mstore(0x00, 0x2b2b18dc)\n mstore(0x20, p0)\n mstore(0x40, 0x80)\n mstore(0x60, p2)\n mstore(0x80, p3)\n writeString(0xa0, p1)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(bool p0, bytes32 p1, address p2, bool p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(bool,string,address,bool)`.\n mstore(0x00, 0x6dd434ca)\n mstore(0x20, p0)\n mstore(0x40, 0x80)\n mstore(0x60, p2)\n mstore(0x80, p3)\n writeString(0xa0, p1)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(bool p0, bytes32 p1, address p2, uint256 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(bool,string,address,uint256)`.\n mstore(0x00, 0xa5cada94)\n mstore(0x20, p0)\n mstore(0x40, 0x80)\n mstore(0x60, p2)\n mstore(0x80, p3)\n writeString(0xa0, p1)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(bool p0, bytes32 p1, address p2, bytes32 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n // Selector of `log(bool,string,address,string)`.\n mstore(0x00, 0x12d6c788)\n mstore(0x20, p0)\n mstore(0x40, 0x80)\n mstore(0x60, p2)\n mstore(0x80, 0xc0)\n writeString(0xa0, p1)\n writeString(0xe0, p3)\n }\n _sendLogPayload(0x1c, 0x104);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n }\n }\n\n function log(bool p0, bytes32 p1, bool p2, address p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(bool,string,bool,address)`.\n mstore(0x00, 0x538e06ab)\n mstore(0x20, p0)\n mstore(0x40, 0x80)\n mstore(0x60, p2)\n mstore(0x80, p3)\n writeString(0xa0, p1)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(bool p0, bytes32 p1, bool p2, bool p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(bool,string,bool,bool)`.\n mstore(0x00, 0xdc5e935b)\n mstore(0x20, p0)\n mstore(0x40, 0x80)\n mstore(0x60, p2)\n mstore(0x80, p3)\n writeString(0xa0, p1)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(bool p0, bytes32 p1, bool p2, uint256 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(bool,string,bool,uint256)`.\n mstore(0x00, 0x1606a393)\n mstore(0x20, p0)\n mstore(0x40, 0x80)\n mstore(0x60, p2)\n mstore(0x80, p3)\n writeString(0xa0, p1)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(bool p0, bytes32 p1, bool p2, bytes32 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n // Selector of `log(bool,string,bool,string)`.\n mstore(0x00, 0x483d0416)\n mstore(0x20, p0)\n mstore(0x40, 0x80)\n mstore(0x60, p2)\n mstore(0x80, 0xc0)\n writeString(0xa0, p1)\n writeString(0xe0, p3)\n }\n _sendLogPayload(0x1c, 0x104);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n }\n }\n\n function log(bool p0, bytes32 p1, uint256 p2, address p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(bool,string,uint256,address)`.\n mstore(0x00, 0x1596a1ce)\n mstore(0x20, p0)\n mstore(0x40, 0x80)\n mstore(0x60, p2)\n mstore(0x80, p3)\n writeString(0xa0, p1)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(bool p0, bytes32 p1, uint256 p2, bool p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(bool,string,uint256,bool)`.\n mstore(0x00, 0x6b0e5d53)\n mstore(0x20, p0)\n mstore(0x40, 0x80)\n mstore(0x60, p2)\n mstore(0x80, p3)\n writeString(0xa0, p1)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(bool p0, bytes32 p1, uint256 p2, uint256 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(bool,string,uint256,uint256)`.\n mstore(0x00, 0x28863fcb)\n mstore(0x20, p0)\n mstore(0x40, 0x80)\n mstore(0x60, p2)\n mstore(0x80, p3)\n writeString(0xa0, p1)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(bool p0, bytes32 p1, uint256 p2, bytes32 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n // Selector of `log(bool,string,uint256,string)`.\n mstore(0x00, 0x1ad96de6)\n mstore(0x20, p0)\n mstore(0x40, 0x80)\n mstore(0x60, p2)\n mstore(0x80, 0xc0)\n writeString(0xa0, p1)\n writeString(0xe0, p3)\n }\n _sendLogPayload(0x1c, 0x104);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n }\n }\n\n function log(bool p0, bytes32 p1, bytes32 p2, address p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n // Selector of `log(bool,string,string,address)`.\n mstore(0x00, 0x97d394d8)\n mstore(0x20, p0)\n mstore(0x40, 0x80)\n mstore(0x60, 0xc0)\n mstore(0x80, p3)\n writeString(0xa0, p1)\n writeString(0xe0, p2)\n }\n _sendLogPayload(0x1c, 0x104);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n }\n }\n\n function log(bool p0, bytes32 p1, bytes32 p2, bool p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n // Selector of `log(bool,string,string,bool)`.\n mstore(0x00, 0x1e4b87e5)\n mstore(0x20, p0)\n mstore(0x40, 0x80)\n mstore(0x60, 0xc0)\n mstore(0x80, p3)\n writeString(0xa0, p1)\n writeString(0xe0, p2)\n }\n _sendLogPayload(0x1c, 0x104);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n }\n }\n\n function log(bool p0, bytes32 p1, bytes32 p2, uint256 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n // Selector of `log(bool,string,string,uint256)`.\n mstore(0x00, 0x7be0c3eb)\n mstore(0x20, p0)\n mstore(0x40, 0x80)\n mstore(0x60, 0xc0)\n mstore(0x80, p3)\n writeString(0xa0, p1)\n writeString(0xe0, p2)\n }\n _sendLogPayload(0x1c, 0x104);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n }\n }\n\n function log(bool p0, bytes32 p1, bytes32 p2, bytes32 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n bytes32 m9;\n bytes32 m10;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n m9 := mload(0x120)\n m10 := mload(0x140)\n // Selector of `log(bool,string,string,string)`.\n mstore(0x00, 0x1762e32a)\n mstore(0x20, p0)\n mstore(0x40, 0x80)\n mstore(0x60, 0xc0)\n mstore(0x80, 0x100)\n writeString(0xa0, p1)\n writeString(0xe0, p2)\n writeString(0x120, p3)\n }\n _sendLogPayload(0x1c, 0x144);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n mstore(0x120, m9)\n mstore(0x140, m10)\n }\n }\n\n function log(uint256 p0, address p1, address p2, address p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(uint256,address,address,address)`.\n mstore(0x00, 0x2488b414)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(uint256 p0, address p1, address p2, bool p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(uint256,address,address,bool)`.\n mstore(0x00, 0x091ffaf5)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(uint256 p0, address p1, address p2, uint256 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(uint256,address,address,uint256)`.\n mstore(0x00, 0x736efbb6)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(uint256 p0, address p1, address p2, bytes32 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(uint256,address,address,string)`.\n mstore(0x00, 0x031c6f73)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, 0x80)\n writeString(0xa0, p3)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(uint256 p0, address p1, bool p2, address p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(uint256,address,bool,address)`.\n mstore(0x00, 0xef72c513)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(uint256 p0, address p1, bool p2, bool p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(uint256,address,bool,bool)`.\n mstore(0x00, 0xe351140f)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(uint256 p0, address p1, bool p2, uint256 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(uint256,address,bool,uint256)`.\n mstore(0x00, 0x5abd992a)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(uint256 p0, address p1, bool p2, bytes32 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(uint256,address,bool,string)`.\n mstore(0x00, 0x90fb06aa)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, 0x80)\n writeString(0xa0, p3)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(uint256 p0, address p1, uint256 p2, address p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(uint256,address,uint256,address)`.\n mstore(0x00, 0x15c127b5)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(uint256 p0, address p1, uint256 p2, bool p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(uint256,address,uint256,bool)`.\n mstore(0x00, 0x5f743a7c)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(uint256 p0, address p1, uint256 p2, uint256 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(uint256,address,uint256,uint256)`.\n mstore(0x00, 0x0c9cd9c1)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(uint256 p0, address p1, uint256 p2, bytes32 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(uint256,address,uint256,string)`.\n mstore(0x00, 0xddb06521)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, 0x80)\n writeString(0xa0, p3)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(uint256 p0, address p1, bytes32 p2, address p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(uint256,address,string,address)`.\n mstore(0x00, 0x9cba8fff)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, 0x80)\n mstore(0x80, p3)\n writeString(0xa0, p2)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(uint256 p0, address p1, bytes32 p2, bool p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(uint256,address,string,bool)`.\n mstore(0x00, 0xcc32ab07)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, 0x80)\n mstore(0x80, p3)\n writeString(0xa0, p2)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(uint256 p0, address p1, bytes32 p2, uint256 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(uint256,address,string,uint256)`.\n mstore(0x00, 0x46826b5d)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, 0x80)\n mstore(0x80, p3)\n writeString(0xa0, p2)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(uint256 p0, address p1, bytes32 p2, bytes32 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n // Selector of `log(uint256,address,string,string)`.\n mstore(0x00, 0x3e128ca3)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, 0x80)\n mstore(0x80, 0xc0)\n writeString(0xa0, p2)\n writeString(0xe0, p3)\n }\n _sendLogPayload(0x1c, 0x104);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n }\n }\n\n function log(uint256 p0, bool p1, address p2, address p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(uint256,bool,address,address)`.\n mstore(0x00, 0xa1ef4cbb)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(uint256 p0, bool p1, address p2, bool p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(uint256,bool,address,bool)`.\n mstore(0x00, 0x454d54a5)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(uint256 p0, bool p1, address p2, uint256 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(uint256,bool,address,uint256)`.\n mstore(0x00, 0x078287f5)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(uint256 p0, bool p1, address p2, bytes32 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(uint256,bool,address,string)`.\n mstore(0x00, 0xade052c7)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, 0x80)\n writeString(0xa0, p3)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(uint256 p0, bool p1, bool p2, address p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(uint256,bool,bool,address)`.\n mstore(0x00, 0x69640b59)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(uint256 p0, bool p1, bool p2, bool p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(uint256,bool,bool,bool)`.\n mstore(0x00, 0xb6f577a1)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(uint256 p0, bool p1, bool p2, uint256 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(uint256,bool,bool,uint256)`.\n mstore(0x00, 0x7464ce23)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(uint256 p0, bool p1, bool p2, bytes32 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(uint256,bool,bool,string)`.\n mstore(0x00, 0xdddb9561)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, 0x80)\n writeString(0xa0, p3)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(uint256 p0, bool p1, uint256 p2, address p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(uint256,bool,uint256,address)`.\n mstore(0x00, 0x88cb6041)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(uint256 p0, bool p1, uint256 p2, bool p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(uint256,bool,uint256,bool)`.\n mstore(0x00, 0x91a02e2a)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(uint256 p0, bool p1, uint256 p2, uint256 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(uint256,bool,uint256,uint256)`.\n mstore(0x00, 0xc6acc7a8)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(uint256 p0, bool p1, uint256 p2, bytes32 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(uint256,bool,uint256,string)`.\n mstore(0x00, 0xde03e774)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, 0x80)\n writeString(0xa0, p3)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(uint256 p0, bool p1, bytes32 p2, address p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(uint256,bool,string,address)`.\n mstore(0x00, 0xef529018)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, 0x80)\n mstore(0x80, p3)\n writeString(0xa0, p2)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(uint256 p0, bool p1, bytes32 p2, bool p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(uint256,bool,string,bool)`.\n mstore(0x00, 0xeb928d7f)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, 0x80)\n mstore(0x80, p3)\n writeString(0xa0, p2)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(uint256 p0, bool p1, bytes32 p2, uint256 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(uint256,bool,string,uint256)`.\n mstore(0x00, 0x2c1d0746)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, 0x80)\n mstore(0x80, p3)\n writeString(0xa0, p2)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(uint256 p0, bool p1, bytes32 p2, bytes32 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n // Selector of `log(uint256,bool,string,string)`.\n mstore(0x00, 0x68c8b8bd)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, 0x80)\n mstore(0x80, 0xc0)\n writeString(0xa0, p2)\n writeString(0xe0, p3)\n }\n _sendLogPayload(0x1c, 0x104);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n }\n }\n\n function log(uint256 p0, uint256 p1, address p2, address p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(uint256,uint256,address,address)`.\n mstore(0x00, 0x56a5d1b1)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(uint256 p0, uint256 p1, address p2, bool p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(uint256,uint256,address,bool)`.\n mstore(0x00, 0x15cac476)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(uint256 p0, uint256 p1, address p2, uint256 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(uint256,uint256,address,uint256)`.\n mstore(0x00, 0x88f6e4b2)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(uint256 p0, uint256 p1, address p2, bytes32 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(uint256,uint256,address,string)`.\n mstore(0x00, 0x6cde40b8)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, 0x80)\n writeString(0xa0, p3)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(uint256 p0, uint256 p1, bool p2, address p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(uint256,uint256,bool,address)`.\n mstore(0x00, 0x9a816a83)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(uint256 p0, uint256 p1, bool p2, bool p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(uint256,uint256,bool,bool)`.\n mstore(0x00, 0xab085ae6)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(uint256 p0, uint256 p1, bool p2, uint256 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(uint256,uint256,bool,uint256)`.\n mstore(0x00, 0xeb7f6fd2)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(uint256 p0, uint256 p1, bool p2, bytes32 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(uint256,uint256,bool,string)`.\n mstore(0x00, 0xa5b4fc99)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, 0x80)\n writeString(0xa0, p3)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(uint256 p0, uint256 p1, uint256 p2, address p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(uint256,uint256,uint256,address)`.\n mstore(0x00, 0xfa8185af)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(uint256 p0, uint256 p1, uint256 p2, bool p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(uint256,uint256,uint256,bool)`.\n mstore(0x00, 0xc598d185)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(uint256 p0, uint256 p1, uint256 p2, uint256 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(uint256,uint256,uint256,uint256)`.\n mstore(0x00, 0x193fb800)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(uint256 p0, uint256 p1, uint256 p2, bytes32 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(uint256,uint256,uint256,string)`.\n mstore(0x00, 0x59cfcbe3)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, 0x80)\n writeString(0xa0, p3)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(uint256 p0, uint256 p1, bytes32 p2, address p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(uint256,uint256,string,address)`.\n mstore(0x00, 0x42d21db7)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, 0x80)\n mstore(0x80, p3)\n writeString(0xa0, p2)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(uint256 p0, uint256 p1, bytes32 p2, bool p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(uint256,uint256,string,bool)`.\n mstore(0x00, 0x7af6ab25)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, 0x80)\n mstore(0x80, p3)\n writeString(0xa0, p2)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(uint256 p0, uint256 p1, bytes32 p2, uint256 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(uint256,uint256,string,uint256)`.\n mstore(0x00, 0x5da297eb)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, 0x80)\n mstore(0x80, p3)\n writeString(0xa0, p2)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(uint256 p0, uint256 p1, bytes32 p2, bytes32 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n // Selector of `log(uint256,uint256,string,string)`.\n mstore(0x00, 0x27d8afd2)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, 0x80)\n mstore(0x80, 0xc0)\n writeString(0xa0, p2)\n writeString(0xe0, p3)\n }\n _sendLogPayload(0x1c, 0x104);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n }\n }\n\n function log(uint256 p0, bytes32 p1, address p2, address p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(uint256,string,address,address)`.\n mstore(0x00, 0x6168ed61)\n mstore(0x20, p0)\n mstore(0x40, 0x80)\n mstore(0x60, p2)\n mstore(0x80, p3)\n writeString(0xa0, p1)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(uint256 p0, bytes32 p1, address p2, bool p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(uint256,string,address,bool)`.\n mstore(0x00, 0x90c30a56)\n mstore(0x20, p0)\n mstore(0x40, 0x80)\n mstore(0x60, p2)\n mstore(0x80, p3)\n writeString(0xa0, p1)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(uint256 p0, bytes32 p1, address p2, uint256 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(uint256,string,address,uint256)`.\n mstore(0x00, 0xe8d3018d)\n mstore(0x20, p0)\n mstore(0x40, 0x80)\n mstore(0x60, p2)\n mstore(0x80, p3)\n writeString(0xa0, p1)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(uint256 p0, bytes32 p1, address p2, bytes32 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n // Selector of `log(uint256,string,address,string)`.\n mstore(0x00, 0x9c3adfa1)\n mstore(0x20, p0)\n mstore(0x40, 0x80)\n mstore(0x60, p2)\n mstore(0x80, 0xc0)\n writeString(0xa0, p1)\n writeString(0xe0, p3)\n }\n _sendLogPayload(0x1c, 0x104);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n }\n }\n\n function log(uint256 p0, bytes32 p1, bool p2, address p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(uint256,string,bool,address)`.\n mstore(0x00, 0xae2ec581)\n mstore(0x20, p0)\n mstore(0x40, 0x80)\n mstore(0x60, p2)\n mstore(0x80, p3)\n writeString(0xa0, p1)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(uint256 p0, bytes32 p1, bool p2, bool p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(uint256,string,bool,bool)`.\n mstore(0x00, 0xba535d9c)\n mstore(0x20, p0)\n mstore(0x40, 0x80)\n mstore(0x60, p2)\n mstore(0x80, p3)\n writeString(0xa0, p1)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(uint256 p0, bytes32 p1, bool p2, uint256 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(uint256,string,bool,uint256)`.\n mstore(0x00, 0xcf009880)\n mstore(0x20, p0)\n mstore(0x40, 0x80)\n mstore(0x60, p2)\n mstore(0x80, p3)\n writeString(0xa0, p1)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(uint256 p0, bytes32 p1, bool p2, bytes32 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n // Selector of `log(uint256,string,bool,string)`.\n mstore(0x00, 0xd2d423cd)\n mstore(0x20, p0)\n mstore(0x40, 0x80)\n mstore(0x60, p2)\n mstore(0x80, 0xc0)\n writeString(0xa0, p1)\n writeString(0xe0, p3)\n }\n _sendLogPayload(0x1c, 0x104);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n }\n }\n\n function log(uint256 p0, bytes32 p1, uint256 p2, address p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(uint256,string,uint256,address)`.\n mstore(0x00, 0x3b2279b4)\n mstore(0x20, p0)\n mstore(0x40, 0x80)\n mstore(0x60, p2)\n mstore(0x80, p3)\n writeString(0xa0, p1)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(uint256 p0, bytes32 p1, uint256 p2, bool p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(uint256,string,uint256,bool)`.\n mstore(0x00, 0x691a8f74)\n mstore(0x20, p0)\n mstore(0x40, 0x80)\n mstore(0x60, p2)\n mstore(0x80, p3)\n writeString(0xa0, p1)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(uint256 p0, bytes32 p1, uint256 p2, uint256 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(uint256,string,uint256,uint256)`.\n mstore(0x00, 0x82c25b74)\n mstore(0x20, p0)\n mstore(0x40, 0x80)\n mstore(0x60, p2)\n mstore(0x80, p3)\n writeString(0xa0, p1)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(uint256 p0, bytes32 p1, uint256 p2, bytes32 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n // Selector of `log(uint256,string,uint256,string)`.\n mstore(0x00, 0xb7b914ca)\n mstore(0x20, p0)\n mstore(0x40, 0x80)\n mstore(0x60, p2)\n mstore(0x80, 0xc0)\n writeString(0xa0, p1)\n writeString(0xe0, p3)\n }\n _sendLogPayload(0x1c, 0x104);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n }\n }\n\n function log(uint256 p0, bytes32 p1, bytes32 p2, address p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n // Selector of `log(uint256,string,string,address)`.\n mstore(0x00, 0xd583c602)\n mstore(0x20, p0)\n mstore(0x40, 0x80)\n mstore(0x60, 0xc0)\n mstore(0x80, p3)\n writeString(0xa0, p1)\n writeString(0xe0, p2)\n }\n _sendLogPayload(0x1c, 0x104);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n }\n }\n\n function log(uint256 p0, bytes32 p1, bytes32 p2, bool p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n // Selector of `log(uint256,string,string,bool)`.\n mstore(0x00, 0xb3a6b6bd)\n mstore(0x20, p0)\n mstore(0x40, 0x80)\n mstore(0x60, 0xc0)\n mstore(0x80, p3)\n writeString(0xa0, p1)\n writeString(0xe0, p2)\n }\n _sendLogPayload(0x1c, 0x104);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n }\n }\n\n function log(uint256 p0, bytes32 p1, bytes32 p2, uint256 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n // Selector of `log(uint256,string,string,uint256)`.\n mstore(0x00, 0xb028c9bd)\n mstore(0x20, p0)\n mstore(0x40, 0x80)\n mstore(0x60, 0xc0)\n mstore(0x80, p3)\n writeString(0xa0, p1)\n writeString(0xe0, p2)\n }\n _sendLogPayload(0x1c, 0x104);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n }\n }\n\n function log(uint256 p0, bytes32 p1, bytes32 p2, bytes32 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n bytes32 m9;\n bytes32 m10;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n m9 := mload(0x120)\n m10 := mload(0x140)\n // Selector of `log(uint256,string,string,string)`.\n mstore(0x00, 0x21ad0683)\n mstore(0x20, p0)\n mstore(0x40, 0x80)\n mstore(0x60, 0xc0)\n mstore(0x80, 0x100)\n writeString(0xa0, p1)\n writeString(0xe0, p2)\n writeString(0x120, p3)\n }\n _sendLogPayload(0x1c, 0x144);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n mstore(0x120, m9)\n mstore(0x140, m10)\n }\n }\n\n function log(bytes32 p0, address p1, address p2, address p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(string,address,address,address)`.\n mstore(0x00, 0xed8f28f6)\n mstore(0x20, 0x80)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n writeString(0xa0, p0)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(bytes32 p0, address p1, address p2, bool p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(string,address,address,bool)`.\n mstore(0x00, 0xb59dbd60)\n mstore(0x20, 0x80)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n writeString(0xa0, p0)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(bytes32 p0, address p1, address p2, uint256 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(string,address,address,uint256)`.\n mstore(0x00, 0x8ef3f399)\n mstore(0x20, 0x80)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n writeString(0xa0, p0)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(bytes32 p0, address p1, address p2, bytes32 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n // Selector of `log(string,address,address,string)`.\n mstore(0x00, 0x800a1c67)\n mstore(0x20, 0x80)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, 0xc0)\n writeString(0xa0, p0)\n writeString(0xe0, p3)\n }\n _sendLogPayload(0x1c, 0x104);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n }\n }\n\n function log(bytes32 p0, address p1, bool p2, address p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(string,address,bool,address)`.\n mstore(0x00, 0x223603bd)\n mstore(0x20, 0x80)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n writeString(0xa0, p0)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(bytes32 p0, address p1, bool p2, bool p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(string,address,bool,bool)`.\n mstore(0x00, 0x79884c2b)\n mstore(0x20, 0x80)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n writeString(0xa0, p0)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(bytes32 p0, address p1, bool p2, uint256 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(string,address,bool,uint256)`.\n mstore(0x00, 0x3e9f866a)\n mstore(0x20, 0x80)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n writeString(0xa0, p0)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(bytes32 p0, address p1, bool p2, bytes32 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n // Selector of `log(string,address,bool,string)`.\n mstore(0x00, 0x0454c079)\n mstore(0x20, 0x80)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, 0xc0)\n writeString(0xa0, p0)\n writeString(0xe0, p3)\n }\n _sendLogPayload(0x1c, 0x104);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n }\n }\n\n function log(bytes32 p0, address p1, uint256 p2, address p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(string,address,uint256,address)`.\n mstore(0x00, 0x63fb8bc5)\n mstore(0x20, 0x80)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n writeString(0xa0, p0)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(bytes32 p0, address p1, uint256 p2, bool p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(string,address,uint256,bool)`.\n mstore(0x00, 0xfc4845f0)\n mstore(0x20, 0x80)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n writeString(0xa0, p0)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(bytes32 p0, address p1, uint256 p2, uint256 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(string,address,uint256,uint256)`.\n mstore(0x00, 0xf8f51b1e)\n mstore(0x20, 0x80)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n writeString(0xa0, p0)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(bytes32 p0, address p1, uint256 p2, bytes32 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n // Selector of `log(string,address,uint256,string)`.\n mstore(0x00, 0x5a477632)\n mstore(0x20, 0x80)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, 0xc0)\n writeString(0xa0, p0)\n writeString(0xe0, p3)\n }\n _sendLogPayload(0x1c, 0x104);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n }\n }\n\n function log(bytes32 p0, address p1, bytes32 p2, address p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n // Selector of `log(string,address,string,address)`.\n mstore(0x00, 0xaabc9a31)\n mstore(0x20, 0x80)\n mstore(0x40, p1)\n mstore(0x60, 0xc0)\n mstore(0x80, p3)\n writeString(0xa0, p0)\n writeString(0xe0, p2)\n }\n _sendLogPayload(0x1c, 0x104);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n }\n }\n\n function log(bytes32 p0, address p1, bytes32 p2, bool p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n // Selector of `log(string,address,string,bool)`.\n mstore(0x00, 0x5f15d28c)\n mstore(0x20, 0x80)\n mstore(0x40, p1)\n mstore(0x60, 0xc0)\n mstore(0x80, p3)\n writeString(0xa0, p0)\n writeString(0xe0, p2)\n }\n _sendLogPayload(0x1c, 0x104);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n }\n }\n\n function log(bytes32 p0, address p1, bytes32 p2, uint256 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n // Selector of `log(string,address,string,uint256)`.\n mstore(0x00, 0x91d1112e)\n mstore(0x20, 0x80)\n mstore(0x40, p1)\n mstore(0x60, 0xc0)\n mstore(0x80, p3)\n writeString(0xa0, p0)\n writeString(0xe0, p2)\n }\n _sendLogPayload(0x1c, 0x104);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n }\n }\n\n function log(bytes32 p0, address p1, bytes32 p2, bytes32 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n bytes32 m9;\n bytes32 m10;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n m9 := mload(0x120)\n m10 := mload(0x140)\n // Selector of `log(string,address,string,string)`.\n mstore(0x00, 0x245986f2)\n mstore(0x20, 0x80)\n mstore(0x40, p1)\n mstore(0x60, 0xc0)\n mstore(0x80, 0x100)\n writeString(0xa0, p0)\n writeString(0xe0, p2)\n writeString(0x120, p3)\n }\n _sendLogPayload(0x1c, 0x144);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n mstore(0x120, m9)\n mstore(0x140, m10)\n }\n }\n\n function log(bytes32 p0, bool p1, address p2, address p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(string,bool,address,address)`.\n mstore(0x00, 0x33e9dd1d)\n mstore(0x20, 0x80)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n writeString(0xa0, p0)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(bytes32 p0, bool p1, address p2, bool p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(string,bool,address,bool)`.\n mstore(0x00, 0x958c28c6)\n mstore(0x20, 0x80)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n writeString(0xa0, p0)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(bytes32 p0, bool p1, address p2, uint256 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(string,bool,address,uint256)`.\n mstore(0x00, 0x5d08bb05)\n mstore(0x20, 0x80)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n writeString(0xa0, p0)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(bytes32 p0, bool p1, address p2, bytes32 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n // Selector of `log(string,bool,address,string)`.\n mstore(0x00, 0x2d8e33a4)\n mstore(0x20, 0x80)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, 0xc0)\n writeString(0xa0, p0)\n writeString(0xe0, p3)\n }\n _sendLogPayload(0x1c, 0x104);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n }\n }\n\n function log(bytes32 p0, bool p1, bool p2, address p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(string,bool,bool,address)`.\n mstore(0x00, 0x7190a529)\n mstore(0x20, 0x80)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n writeString(0xa0, p0)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(bytes32 p0, bool p1, bool p2, bool p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(string,bool,bool,bool)`.\n mstore(0x00, 0x895af8c5)\n mstore(0x20, 0x80)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n writeString(0xa0, p0)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(bytes32 p0, bool p1, bool p2, uint256 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(string,bool,bool,uint256)`.\n mstore(0x00, 0x8e3f78a9)\n mstore(0x20, 0x80)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n writeString(0xa0, p0)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(bytes32 p0, bool p1, bool p2, bytes32 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n // Selector of `log(string,bool,bool,string)`.\n mstore(0x00, 0x9d22d5dd)\n mstore(0x20, 0x80)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, 0xc0)\n writeString(0xa0, p0)\n writeString(0xe0, p3)\n }\n _sendLogPayload(0x1c, 0x104);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n }\n }\n\n function log(bytes32 p0, bool p1, uint256 p2, address p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(string,bool,uint256,address)`.\n mstore(0x00, 0x935e09bf)\n mstore(0x20, 0x80)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n writeString(0xa0, p0)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(bytes32 p0, bool p1, uint256 p2, bool p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(string,bool,uint256,bool)`.\n mstore(0x00, 0x8af7cf8a)\n mstore(0x20, 0x80)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n writeString(0xa0, p0)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(bytes32 p0, bool p1, uint256 p2, uint256 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(string,bool,uint256,uint256)`.\n mstore(0x00, 0x64b5bb67)\n mstore(0x20, 0x80)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n writeString(0xa0, p0)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(bytes32 p0, bool p1, uint256 p2, bytes32 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n // Selector of `log(string,bool,uint256,string)`.\n mstore(0x00, 0x742d6ee7)\n mstore(0x20, 0x80)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, 0xc0)\n writeString(0xa0, p0)\n writeString(0xe0, p3)\n }\n _sendLogPayload(0x1c, 0x104);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n }\n }\n\n function log(bytes32 p0, bool p1, bytes32 p2, address p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n // Selector of `log(string,bool,string,address)`.\n mstore(0x00, 0xe0625b29)\n mstore(0x20, 0x80)\n mstore(0x40, p1)\n mstore(0x60, 0xc0)\n mstore(0x80, p3)\n writeString(0xa0, p0)\n writeString(0xe0, p2)\n }\n _sendLogPayload(0x1c, 0x104);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n }\n }\n\n function log(bytes32 p0, bool p1, bytes32 p2, bool p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n // Selector of `log(string,bool,string,bool)`.\n mstore(0x00, 0x3f8a701d)\n mstore(0x20, 0x80)\n mstore(0x40, p1)\n mstore(0x60, 0xc0)\n mstore(0x80, p3)\n writeString(0xa0, p0)\n writeString(0xe0, p2)\n }\n _sendLogPayload(0x1c, 0x104);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n }\n }\n\n function log(bytes32 p0, bool p1, bytes32 p2, uint256 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n // Selector of `log(string,bool,string,uint256)`.\n mstore(0x00, 0x24f91465)\n mstore(0x20, 0x80)\n mstore(0x40, p1)\n mstore(0x60, 0xc0)\n mstore(0x80, p3)\n writeString(0xa0, p0)\n writeString(0xe0, p2)\n }\n _sendLogPayload(0x1c, 0x104);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n }\n }\n\n function log(bytes32 p0, bool p1, bytes32 p2, bytes32 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n bytes32 m9;\n bytes32 m10;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n m9 := mload(0x120)\n m10 := mload(0x140)\n // Selector of `log(string,bool,string,string)`.\n mstore(0x00, 0xa826caeb)\n mstore(0x20, 0x80)\n mstore(0x40, p1)\n mstore(0x60, 0xc0)\n mstore(0x80, 0x100)\n writeString(0xa0, p0)\n writeString(0xe0, p2)\n writeString(0x120, p3)\n }\n _sendLogPayload(0x1c, 0x144);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n mstore(0x120, m9)\n mstore(0x140, m10)\n }\n }\n\n function log(bytes32 p0, uint256 p1, address p2, address p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(string,uint256,address,address)`.\n mstore(0x00, 0x5ea2b7ae)\n mstore(0x20, 0x80)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n writeString(0xa0, p0)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(bytes32 p0, uint256 p1, address p2, bool p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(string,uint256,address,bool)`.\n mstore(0x00, 0x82112a42)\n mstore(0x20, 0x80)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n writeString(0xa0, p0)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(bytes32 p0, uint256 p1, address p2, uint256 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(string,uint256,address,uint256)`.\n mstore(0x00, 0x4f04fdc6)\n mstore(0x20, 0x80)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n writeString(0xa0, p0)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(bytes32 p0, uint256 p1, address p2, bytes32 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n // Selector of `log(string,uint256,address,string)`.\n mstore(0x00, 0x9ffb2f93)\n mstore(0x20, 0x80)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, 0xc0)\n writeString(0xa0, p0)\n writeString(0xe0, p3)\n }\n _sendLogPayload(0x1c, 0x104);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n }\n }\n\n function log(bytes32 p0, uint256 p1, bool p2, address p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(string,uint256,bool,address)`.\n mstore(0x00, 0xe0e95b98)\n mstore(0x20, 0x80)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n writeString(0xa0, p0)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(bytes32 p0, uint256 p1, bool p2, bool p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(string,uint256,bool,bool)`.\n mstore(0x00, 0x354c36d6)\n mstore(0x20, 0x80)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n writeString(0xa0, p0)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(bytes32 p0, uint256 p1, bool p2, uint256 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(string,uint256,bool,uint256)`.\n mstore(0x00, 0xe41b6f6f)\n mstore(0x20, 0x80)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n writeString(0xa0, p0)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(bytes32 p0, uint256 p1, bool p2, bytes32 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n // Selector of `log(string,uint256,bool,string)`.\n mstore(0x00, 0xabf73a98)\n mstore(0x20, 0x80)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, 0xc0)\n writeString(0xa0, p0)\n writeString(0xe0, p3)\n }\n _sendLogPayload(0x1c, 0x104);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n }\n }\n\n function log(bytes32 p0, uint256 p1, uint256 p2, address p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(string,uint256,uint256,address)`.\n mstore(0x00, 0xe21de278)\n mstore(0x20, 0x80)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n writeString(0xa0, p0)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(bytes32 p0, uint256 p1, uint256 p2, bool p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(string,uint256,uint256,bool)`.\n mstore(0x00, 0x7626db92)\n mstore(0x20, 0x80)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n writeString(0xa0, p0)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(bytes32 p0, uint256 p1, uint256 p2, uint256 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(string,uint256,uint256,uint256)`.\n mstore(0x00, 0xa7a87853)\n mstore(0x20, 0x80)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n writeString(0xa0, p0)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(bytes32 p0, uint256 p1, uint256 p2, bytes32 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n // Selector of `log(string,uint256,uint256,string)`.\n mstore(0x00, 0x854b3496)\n mstore(0x20, 0x80)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, 0xc0)\n writeString(0xa0, p0)\n writeString(0xe0, p3)\n }\n _sendLogPayload(0x1c, 0x104);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n }\n }\n\n function log(bytes32 p0, uint256 p1, bytes32 p2, address p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n // Selector of `log(string,uint256,string,address)`.\n mstore(0x00, 0x7c4632a4)\n mstore(0x20, 0x80)\n mstore(0x40, p1)\n mstore(0x60, 0xc0)\n mstore(0x80, p3)\n writeString(0xa0, p0)\n writeString(0xe0, p2)\n }\n _sendLogPayload(0x1c, 0x104);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n }\n }\n\n function log(bytes32 p0, uint256 p1, bytes32 p2, bool p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n // Selector of `log(string,uint256,string,bool)`.\n mstore(0x00, 0x7d24491d)\n mstore(0x20, 0x80)\n mstore(0x40, p1)\n mstore(0x60, 0xc0)\n mstore(0x80, p3)\n writeString(0xa0, p0)\n writeString(0xe0, p2)\n }\n _sendLogPayload(0x1c, 0x104);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n }\n }\n\n function log(bytes32 p0, uint256 p1, bytes32 p2, uint256 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n // Selector of `log(string,uint256,string,uint256)`.\n mstore(0x00, 0xc67ea9d1)\n mstore(0x20, 0x80)\n mstore(0x40, p1)\n mstore(0x60, 0xc0)\n mstore(0x80, p3)\n writeString(0xa0, p0)\n writeString(0xe0, p2)\n }\n _sendLogPayload(0x1c, 0x104);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n }\n }\n\n function log(bytes32 p0, uint256 p1, bytes32 p2, bytes32 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n bytes32 m9;\n bytes32 m10;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n m9 := mload(0x120)\n m10 := mload(0x140)\n // Selector of `log(string,uint256,string,string)`.\n mstore(0x00, 0x5ab84e1f)\n mstore(0x20, 0x80)\n mstore(0x40, p1)\n mstore(0x60, 0xc0)\n mstore(0x80, 0x100)\n writeString(0xa0, p0)\n writeString(0xe0, p2)\n writeString(0x120, p3)\n }\n _sendLogPayload(0x1c, 0x144);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n mstore(0x120, m9)\n mstore(0x140, m10)\n }\n }\n\n function log(bytes32 p0, bytes32 p1, address p2, address p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n // Selector of `log(string,string,address,address)`.\n mstore(0x00, 0x439c7bef)\n mstore(0x20, 0x80)\n mstore(0x40, 0xc0)\n mstore(0x60, p2)\n mstore(0x80, p3)\n writeString(0xa0, p0)\n writeString(0xe0, p1)\n }\n _sendLogPayload(0x1c, 0x104);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n }\n }\n\n function log(bytes32 p0, bytes32 p1, address p2, bool p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n // Selector of `log(string,string,address,bool)`.\n mstore(0x00, 0x5ccd4e37)\n mstore(0x20, 0x80)\n mstore(0x40, 0xc0)\n mstore(0x60, p2)\n mstore(0x80, p3)\n writeString(0xa0, p0)\n writeString(0xe0, p1)\n }\n _sendLogPayload(0x1c, 0x104);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n }\n }\n\n function log(bytes32 p0, bytes32 p1, address p2, uint256 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n // Selector of `log(string,string,address,uint256)`.\n mstore(0x00, 0x7cc3c607)\n mstore(0x20, 0x80)\n mstore(0x40, 0xc0)\n mstore(0x60, p2)\n mstore(0x80, p3)\n writeString(0xa0, p0)\n writeString(0xe0, p1)\n }\n _sendLogPayload(0x1c, 0x104);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n }\n }\n\n function log(bytes32 p0, bytes32 p1, address p2, bytes32 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n bytes32 m9;\n bytes32 m10;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n m9 := mload(0x120)\n m10 := mload(0x140)\n // Selector of `log(string,string,address,string)`.\n mstore(0x00, 0xeb1bff80)\n mstore(0x20, 0x80)\n mstore(0x40, 0xc0)\n mstore(0x60, p2)\n mstore(0x80, 0x100)\n writeString(0xa0, p0)\n writeString(0xe0, p1)\n writeString(0x120, p3)\n }\n _sendLogPayload(0x1c, 0x144);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n mstore(0x120, m9)\n mstore(0x140, m10)\n }\n }\n\n function log(bytes32 p0, bytes32 p1, bool p2, address p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n // Selector of `log(string,string,bool,address)`.\n mstore(0x00, 0xc371c7db)\n mstore(0x20, 0x80)\n mstore(0x40, 0xc0)\n mstore(0x60, p2)\n mstore(0x80, p3)\n writeString(0xa0, p0)\n writeString(0xe0, p1)\n }\n _sendLogPayload(0x1c, 0x104);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n }\n }\n\n function log(bytes32 p0, bytes32 p1, bool p2, bool p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n // Selector of `log(string,string,bool,bool)`.\n mstore(0x00, 0x40785869)\n mstore(0x20, 0x80)\n mstore(0x40, 0xc0)\n mstore(0x60, p2)\n mstore(0x80, p3)\n writeString(0xa0, p0)\n writeString(0xe0, p1)\n }\n _sendLogPayload(0x1c, 0x104);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n }\n }\n\n function log(bytes32 p0, bytes32 p1, bool p2, uint256 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n // Selector of `log(string,string,bool,uint256)`.\n mstore(0x00, 0xd6aefad2)\n mstore(0x20, 0x80)\n mstore(0x40, 0xc0)\n mstore(0x60, p2)\n mstore(0x80, p3)\n writeString(0xa0, p0)\n writeString(0xe0, p1)\n }\n _sendLogPayload(0x1c, 0x104);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n }\n }\n\n function log(bytes32 p0, bytes32 p1, bool p2, bytes32 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n bytes32 m9;\n bytes32 m10;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n m9 := mload(0x120)\n m10 := mload(0x140)\n // Selector of `log(string,string,bool,string)`.\n mstore(0x00, 0x5e84b0ea)\n mstore(0x20, 0x80)\n mstore(0x40, 0xc0)\n mstore(0x60, p2)\n mstore(0x80, 0x100)\n writeString(0xa0, p0)\n writeString(0xe0, p1)\n writeString(0x120, p3)\n }\n _sendLogPayload(0x1c, 0x144);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n mstore(0x120, m9)\n mstore(0x140, m10)\n }\n }\n\n function log(bytes32 p0, bytes32 p1, uint256 p2, address p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n // Selector of `log(string,string,uint256,address)`.\n mstore(0x00, 0x1023f7b2)\n mstore(0x20, 0x80)\n mstore(0x40, 0xc0)\n mstore(0x60, p2)\n mstore(0x80, p3)\n writeString(0xa0, p0)\n writeString(0xe0, p1)\n }\n _sendLogPayload(0x1c, 0x104);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n }\n }\n\n function log(bytes32 p0, bytes32 p1, uint256 p2, bool p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n // Selector of `log(string,string,uint256,bool)`.\n mstore(0x00, 0xc3a8a654)\n mstore(0x20, 0x80)\n mstore(0x40, 0xc0)\n mstore(0x60, p2)\n mstore(0x80, p3)\n writeString(0xa0, p0)\n writeString(0xe0, p1)\n }\n _sendLogPayload(0x1c, 0x104);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n }\n }\n\n function log(bytes32 p0, bytes32 p1, uint256 p2, uint256 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n // Selector of `log(string,string,uint256,uint256)`.\n mstore(0x00, 0xf45d7d2c)\n mstore(0x20, 0x80)\n mstore(0x40, 0xc0)\n mstore(0x60, p2)\n mstore(0x80, p3)\n writeString(0xa0, p0)\n writeString(0xe0, p1)\n }\n _sendLogPayload(0x1c, 0x104);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n }\n }\n\n function log(bytes32 p0, bytes32 p1, uint256 p2, bytes32 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n bytes32 m9;\n bytes32 m10;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n m9 := mload(0x120)\n m10 := mload(0x140)\n // Selector of `log(string,string,uint256,string)`.\n mstore(0x00, 0x5d1a971a)\n mstore(0x20, 0x80)\n mstore(0x40, 0xc0)\n mstore(0x60, p2)\n mstore(0x80, 0x100)\n writeString(0xa0, p0)\n writeString(0xe0, p1)\n writeString(0x120, p3)\n }\n _sendLogPayload(0x1c, 0x144);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n mstore(0x120, m9)\n mstore(0x140, m10)\n }\n }\n\n function log(bytes32 p0, bytes32 p1, bytes32 p2, address p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n bytes32 m9;\n bytes32 m10;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n m9 := mload(0x120)\n m10 := mload(0x140)\n // Selector of `log(string,string,string,address)`.\n mstore(0x00, 0x6d572f44)\n mstore(0x20, 0x80)\n mstore(0x40, 0xc0)\n mstore(0x60, 0x100)\n mstore(0x80, p3)\n writeString(0xa0, p0)\n writeString(0xe0, p1)\n writeString(0x120, p2)\n }\n _sendLogPayload(0x1c, 0x144);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n mstore(0x120, m9)\n mstore(0x140, m10)\n }\n }\n\n function log(bytes32 p0, bytes32 p1, bytes32 p2, bool p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n bytes32 m9;\n bytes32 m10;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n m9 := mload(0x120)\n m10 := mload(0x140)\n // Selector of `log(string,string,string,bool)`.\n mstore(0x00, 0x2c1754ed)\n mstore(0x20, 0x80)\n mstore(0x40, 0xc0)\n mstore(0x60, 0x100)\n mstore(0x80, p3)\n writeString(0xa0, p0)\n writeString(0xe0, p1)\n writeString(0x120, p2)\n }\n _sendLogPayload(0x1c, 0x144);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n mstore(0x120, m9)\n mstore(0x140, m10)\n }\n }\n\n function log(bytes32 p0, bytes32 p1, bytes32 p2, uint256 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n bytes32 m9;\n bytes32 m10;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n m9 := mload(0x120)\n m10 := mload(0x140)\n // Selector of `log(string,string,string,uint256)`.\n mstore(0x00, 0x8eafb02b)\n mstore(0x20, 0x80)\n mstore(0x40, 0xc0)\n mstore(0x60, 0x100)\n mstore(0x80, p3)\n writeString(0xa0, p0)\n writeString(0xe0, p1)\n writeString(0x120, p2)\n }\n _sendLogPayload(0x1c, 0x144);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n mstore(0x120, m9)\n mstore(0x140, m10)\n }\n }\n\n function log(bytes32 p0, bytes32 p1, bytes32 p2, bytes32 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n bytes32 m9;\n bytes32 m10;\n bytes32 m11;\n bytes32 m12;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n m9 := mload(0x120)\n m10 := mload(0x140)\n m11 := mload(0x160)\n m12 := mload(0x180)\n // Selector of `log(string,string,string,string)`.\n mstore(0x00, 0xde68f20a)\n mstore(0x20, 0x80)\n mstore(0x40, 0xc0)\n mstore(0x60, 0x100)\n mstore(0x80, 0x140)\n writeString(0xa0, p0)\n writeString(0xe0, p1)\n writeString(0x120, p2)\n writeString(0x160, p3)\n }\n _sendLogPayload(0x1c, 0x184);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n mstore(0x120, m9)\n mstore(0x140, m10)\n mstore(0x160, m11)\n mstore(0x180, m12)\n }\n }\n}\n","license":"MIT"},"scripts/FetchChainInfo.s.sol":{"keccak256":"0x202fb27a5a78b7d8c96c3a4ea69981dc4eeda765aa2747699ac80b8499feb709","urls":[],"content":"// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\nimport { Script } from \"forge-std/Script.sol\";\nimport { GameTypes, GameType } from \"src/dispute/lib/Types.sol\";\n\n/// @notice Contains getters for arbitrary methods from all L1 contracts, including legacy getters\n/// that have since been deprecated.\ninterface IFetcher {\n function guardian() external view returns (address);\n function GUARDIAN() external view returns (address);\n function systemConfig() external view returns (address);\n function SYSTEM_CONFIG() external view returns (address);\n function disputeGameFactory() external view returns (address);\n function ethLockbox() external view returns (address);\n function superchainConfig() external view returns (address);\n function messenger() external view returns (address);\n function addressManager() external view returns (address);\n function PORTAL() external view returns (address);\n function portal() external view returns (address);\n function l1ERC721Bridge() external view returns (address);\n function optimismMintableERC20Factory() external view returns (address);\n function gameImpls(GameType _gameType) external view returns (address);\n function respectedGameType() external view returns (GameType);\n function anchorStateRegistry() external view returns (address);\n function L2_ORACLE() external view returns (address);\n function l2Oracle() external view returns (address);\n function vm() external view returns (address);\n function oracle() external view returns (address);\n function challenger() external view returns (address);\n function proposer() external view returns (address);\n function PROPOSER() external view returns (address);\n function batcherHash() external view returns (bytes32);\n function admin() external view returns (address);\n function owner() external view returns (address);\n function unsafeBlockSigner() external view returns (address);\n function weth() external view returns (address);\n}\n\ncontract FetchChainInfoInput {\n address internal _systemConfigProxy;\n address internal _l1StandardBridgeProxy;\n\n function set(bytes4 _sel, address _addr) public {\n require(_addr != address(0), \"FetchChainInfoInput: cannot set zero address\");\n if (_sel == this.systemConfigProxy.selector) _systemConfigProxy = _addr;\n else if (_sel == this.l1StandardBridgeProxy.selector) _l1StandardBridgeProxy = _addr;\n else revert(\"FetchChainInfoInput: unknown selector\");\n }\n\n function systemConfigProxy() public view returns (address) {\n require(_systemConfigProxy != address(0), \"FetchChainInfoInput: systemConfigProxy not set\");\n return _systemConfigProxy;\n }\n\n function l1StandardBridgeProxy() public view returns (address) {\n require(_l1StandardBridgeProxy != address(0), \"FetchChainInfoInput: l1StandardBridgeProxy not set\");\n return _l1StandardBridgeProxy;\n }\n}\n\ncontract FetchChainInfoOutput {\n // contract addresses\n // - SuperchainContracts\n address internal _superchainConfigProxy;\n // - ImplementationsContracts\n address internal _mipsImpl;\n address internal _preimageOracleImpl;\n // - OpChainContracts\n address internal _addressManagerImpl;\n address internal _ethLockboxProxy;\n address internal _l1CrossDomainMessengerProxy;\n address internal _l1Erc721BridgeProxy;\n address internal _l1StandardBridgeProxy;\n address internal _l2OutputOracleProxy;\n address internal _optimismMintableErc20FactoryProxy;\n address internal _optimismPortalProxy;\n address internal _systemConfigProxy;\n address internal _opChainProxyAdminImpl;\n address internal _anchorStateRegistryProxy;\n address internal _delayedWethPermissionedGameProxy;\n address internal _delayedWethPermissionlessGameProxy;\n address internal _disputeGameFactoryProxy;\n address internal _faultDisputeGameImpl;\n address internal _permissionedDisputeGameImpl;\n\n // roles\n address internal _systemConfigOwner;\n address internal _opChainProxyAdminOwner;\n address internal _opChainGuardian;\n address internal _challenger;\n address internal _proposer;\n address internal _unsafeBlockSigner;\n address internal _batchSubmitter;\n\n // fault proof status\n bool internal _permissioned;\n bool internal _permissionless;\n GameType internal _respectedGameType;\n\n function set(bytes4 _sel, address _addr) public {\n // SuperchainContracts\n if (_sel == this.superchainConfigProxy.selector) _superchainConfigProxy = _addr;\n // - ImplementationsContracts\n else if (_sel == this.mipsImpl.selector) _mipsImpl = _addr;\n else if (_sel == this.preimageOracleImpl.selector) _preimageOracleImpl = _addr;\n // - OpChainContracts\n else if (_sel == this.addressManagerImpl.selector) _addressManagerImpl = _addr;\n else if (_sel == this.ethLockboxProxy.selector) _ethLockboxProxy = _addr;\n else if (_sel == this.l1CrossDomainMessengerProxy.selector) _l1CrossDomainMessengerProxy = _addr;\n else if (_sel == this.l1Erc721BridgeProxy.selector) _l1Erc721BridgeProxy = _addr;\n else if (_sel == this.l1StandardBridgeProxy.selector) _l1StandardBridgeProxy = _addr;\n else if (_sel == this.l2OutputOracleProxy.selector) _l2OutputOracleProxy = _addr;\n else if (_sel == this.optimismMintableErc20FactoryProxy.selector) _optimismMintableErc20FactoryProxy = _addr;\n else if (_sel == this.optimismPortalProxy.selector) _optimismPortalProxy = _addr;\n else if (_sel == this.systemConfigProxy.selector) _systemConfigProxy = _addr;\n else if (_sel == this.opChainProxyAdminImpl.selector) _opChainProxyAdminImpl = _addr;\n else if (_sel == this.anchorStateRegistryProxy.selector) _anchorStateRegistryProxy = _addr;\n else if (_sel == this.delayedWethPermissionedGameProxy.selector) _delayedWethPermissionedGameProxy = _addr;\n else if (_sel == this.delayedWethPermissionlessGameProxy.selector) _delayedWethPermissionlessGameProxy = _addr;\n else if (_sel == this.disputeGameFactoryProxy.selector) _disputeGameFactoryProxy = _addr;\n else if (_sel == this.faultDisputeGameImpl.selector) _faultDisputeGameImpl = _addr;\n else if (_sel == this.permissionedDisputeGameImpl.selector) _permissionedDisputeGameImpl = _addr;\n // roles\n else if (_sel == this.systemConfigOwner.selector) _systemConfigOwner = _addr;\n else if (_sel == this.opChainProxyAdminOwner.selector) _opChainProxyAdminOwner = _addr;\n else if (_sel == this.opChainGuardian.selector) _opChainGuardian = _addr;\n else if (_sel == this.challenger.selector) _challenger = _addr;\n else if (_sel == this.proposer.selector) _proposer = _addr;\n else if (_sel == this.unsafeBlockSigner.selector) _unsafeBlockSigner = _addr;\n else if (_sel == this.batchSubmitter.selector) _batchSubmitter = _addr;\n else revert(\"FetchChainInfoOutput: unknown address selector test\");\n }\n\n function set(bytes4 _sel, bool _bool) public {\n if (_sel == this.permissioned.selector) _permissioned = _bool;\n else if (_sel == this.permissionless.selector) _permissionless = _bool;\n else revert(\"FetchChainInfoOutput: unknown bool selector\");\n }\n\n function set(bytes4 _sel, GameType _gameType) public {\n if (_sel == this.respectedGameType.selector) _respectedGameType = _gameType;\n else revert(\"FetchChainInfoOutput: unknown GameType selector\");\n }\n\n function addressManagerImpl() public view returns (address) {\n require(_addressManagerImpl != address(0), \"FetchChainInfoOutput: addressManagerImpl not set\");\n return _addressManagerImpl;\n }\n\n function ethLockboxProxy() public view returns (address) {\n return _ethLockboxProxy;\n }\n\n function l1CrossDomainMessengerProxy() public view returns (address) {\n require(_l1CrossDomainMessengerProxy != address(0), \"FetchChainInfoOutput: l1CrossDomainMessengerProxy not set\");\n return _l1CrossDomainMessengerProxy;\n }\n\n function l1Erc721BridgeProxy() public view returns (address) {\n require(_l1Erc721BridgeProxy != address(0), \"FetchChainInfoOutput: l1Erc721BridgeProxy not set\");\n return _l1Erc721BridgeProxy;\n }\n\n function l1StandardBridgeProxy() public view returns (address) {\n require(_l1StandardBridgeProxy != address(0), \"FetchChainInfoOutput: l1StandardBridgeProxy not set\");\n return _l1StandardBridgeProxy;\n }\n\n function l2OutputOracleProxy() public view returns (address) {\n require(_l2OutputOracleProxy != address(0), \"FetchChainInfoOutput: l2OutputOracleProxy not set\");\n return _l2OutputOracleProxy;\n }\n\n function optimismMintableErc20FactoryProxy() public view returns (address) {\n require(\n _optimismMintableErc20FactoryProxy != address(0),\n \"FetchChainInfoOutput: optimismMintableErc20FactoryProxy not set\"\n );\n return _optimismMintableErc20FactoryProxy;\n }\n\n function optimismPortalProxy() public view returns (address) {\n require(_optimismPortalProxy != address(0), \"FetchChainInfoOutput: optimismPortalProxy not set\");\n return _optimismPortalProxy;\n }\n\n function systemConfigProxy() public view returns (address) {\n require(_systemConfigProxy != address(0), \"FetchChainInfoOutput: systemConfigProxy not set\");\n return _systemConfigProxy;\n }\n\n function opChainProxyAdminImpl() public view returns (address) {\n require(_opChainProxyAdminImpl != address(0), \"FetchChainInfoOutput: opChainProxyAdminImpl not set\");\n return _opChainProxyAdminImpl;\n }\n\n function superchainConfigProxy() public view returns (address) {\n require(_superchainConfigProxy != address(0), \"FetchChainInfoOutput: superchainConfigProxy not set\");\n return _superchainConfigProxy;\n }\n\n function anchorStateRegistryProxy() public view returns (address) {\n require(_anchorStateRegistryProxy != address(0), \"FetchChainInfoOutput: anchorStateRegistryProxy not set\");\n return _anchorStateRegistryProxy;\n }\n\n function delayedWethPermissionedGameProxy() public view returns (address) {\n return _delayedWethPermissionedGameProxy;\n }\n\n function delayedWethPermissionlessGameProxy() public view returns (address) {\n return _delayedWethPermissionlessGameProxy;\n }\n\n function disputeGameFactoryProxy() public view returns (address) {\n return _disputeGameFactoryProxy;\n }\n\n function faultDisputeGameImpl() public view returns (address) {\n require(_faultDisputeGameImpl != address(0), \"FetchChainInfoOutput: faultDisputeGameImpl not set\");\n return _faultDisputeGameImpl;\n }\n\n function mipsImpl() public view returns (address) {\n require(_mipsImpl != address(0), \"FetchChainInfoOutput: mipsImpl not set\");\n return _mipsImpl;\n }\n\n function permissionedDisputeGameImpl() public view returns (address) {\n require(_permissionedDisputeGameImpl != address(0), \"FetchChainInfoOutput: permissionedDisputeGameImpl not set\");\n return _permissionedDisputeGameImpl;\n }\n\n function preimageOracleImpl() public view returns (address) {\n require(_preimageOracleImpl != address(0), \"FetchChainInfoOutput: preimageOracleImpl not set\");\n return _preimageOracleImpl;\n }\n\n function systemConfigOwner() public view returns (address) {\n require(_systemConfigOwner != address(0), \"FetchChainInfoOutput: systemConfigOwner not set\");\n return _systemConfigOwner;\n }\n\n function opChainProxyAdminOwner() public view returns (address) {\n require(_opChainProxyAdminOwner != address(0), \"FetchChainInfoOutput: opChainProxyAdminOwner not set\");\n return _opChainProxyAdminOwner;\n }\n\n function opChainGuardian() public view returns (address) {\n require(_opChainGuardian != address(0), \"FetchChainInfoOutput: opChainGuardian not set\");\n return _opChainGuardian;\n }\n\n function challenger() public view returns (address) {\n require(_challenger != address(0), \"FetchChainInfoOutput: challenger not set\");\n return _challenger;\n }\n\n function proposer() public view returns (address) {\n require(_proposer != address(0), \"FetchChainInfoOutput: proposer not set\");\n return _proposer;\n }\n\n function unsafeBlockSigner() public view returns (address) {\n require(_unsafeBlockSigner != address(0), \"FetchChainInfoOutput: unsafeBlockSigner not set\");\n return _unsafeBlockSigner;\n }\n\n function batchSubmitter() public view returns (address) {\n require(_batchSubmitter != address(0), \"FetchChainInfoOutput: batchSubmitter not set\");\n return _batchSubmitter;\n }\n\n function permissioned() public view returns (bool) {\n return _permissioned;\n }\n\n function permissionless() public view returns (bool) {\n return _permissionless;\n }\n\n function respectedGameType() public view returns (GameType) {\n return _respectedGameType;\n }\n}\n\ncontract FetchChainInfo is Script {\n function run(FetchChainInfoInput _fi, FetchChainInfoOutput _fo) public {\n _processSystemConfig(_fi, _fo);\n _processMessengerAndPortal(_fi, _fo);\n _processFaultProofs(_fo);\n }\n\n function _processSystemConfig(FetchChainInfoInput _fi, FetchChainInfoOutput _fo) internal {\n address systemConfigProxy = _fi.systemConfigProxy();\n _fo.set(_fo.systemConfigProxy.selector, systemConfigProxy);\n\n address systemConfigOwner = IFetcher(systemConfigProxy).owner();\n _fo.set(_fo.systemConfigOwner.selector, systemConfigOwner);\n\n address unsafeBlockSigner = IFetcher(systemConfigProxy).unsafeBlockSigner();\n _fo.set(_fo.unsafeBlockSigner.selector, unsafeBlockSigner);\n\n address batchSubmitter = _getBatchSubmitter(systemConfigProxy);\n _fo.set(_fo.batchSubmitter.selector, batchSubmitter);\n\n address opChainProxyAdminImpl = _getProxyAdmin(systemConfigProxy);\n _fo.set(_fo.opChainProxyAdminImpl.selector, opChainProxyAdminImpl);\n\n address opChainProxyAdminOwner = IFetcher(opChainProxyAdminImpl).owner();\n _fo.set(_fo.opChainProxyAdminOwner.selector, opChainProxyAdminOwner);\n\n address l1Erc721BridgeProxy = _getL1ERC721BridgeProxy(systemConfigProxy);\n _fo.set(_fo.l1Erc721BridgeProxy.selector, l1Erc721BridgeProxy);\n\n address optimismMintableErc20FactoryProxy = _getOptimismMintableERC20FactoryProxy(systemConfigProxy);\n _fo.set(_fo.optimismMintableErc20FactoryProxy.selector, optimismMintableErc20FactoryProxy);\n }\n\n function _processMessengerAndPortal(FetchChainInfoInput _fi, FetchChainInfoOutput _fo) internal {\n address l1StandardBridgeProxy = _fi.l1StandardBridgeProxy();\n _fo.set(_fo.l1StandardBridgeProxy.selector, l1StandardBridgeProxy);\n\n address l1CrossDomainMessengerProxy = IFetcher(l1StandardBridgeProxy).messenger();\n _fo.set(_fo.l1CrossDomainMessengerProxy.selector, l1CrossDomainMessengerProxy);\n\n address addressManagerImpl = _getAddressManager(l1CrossDomainMessengerProxy);\n _fo.set(_fo.addressManagerImpl.selector, addressManagerImpl);\n\n address optimismPortalProxy = _getOptimismPortalProxy(l1CrossDomainMessengerProxy);\n _fo.set(_fo.optimismPortalProxy.selector, optimismPortalProxy);\n\n address opChainGuardian = _getGuardian(optimismPortalProxy);\n _fo.set(_fo.opChainGuardian.selector, opChainGuardian);\n\n address ethLockboxProxy = _getEthLockboxProxy(optimismPortalProxy);\n _fo.set(_fo.ethLockboxProxy.selector, ethLockboxProxy);\n\n address superchainConfigProxy = _getSuperchainConfigProxy(optimismPortalProxy);\n _fo.set(_fo.superchainConfigProxy.selector, superchainConfigProxy);\n }\n\n function _processFaultProofs(FetchChainInfoOutput _fo) internal {\n address systemConfigProxy = _fo.systemConfigProxy();\n address optimismPortalProxy = _fo.optimismPortalProxy();\n\n try IFetcher(optimismPortalProxy).respectedGameType() returns (GameType gameType_) {\n _fo.set(_fo.respectedGameType.selector, gameType_);\n } catch {\n // default respectedGameType to uint32.max since 0 == CANNON\n _fo.set(_fo.respectedGameType.selector, GameType.wrap(type(uint32).max));\n address l2OutputOracleProxy;\n try IFetcher(optimismPortalProxy).l2Oracle() returns (address l2Oracle_) {\n l2OutputOracleProxy = l2Oracle_;\n } catch {\n l2OutputOracleProxy = IFetcher(optimismPortalProxy).L2_ORACLE();\n }\n _fo.set(_fo.l2OutputOracleProxy.selector, l2OutputOracleProxy);\n\n address proposer = IFetcher(l2OutputOracleProxy).PROPOSER();\n _fo.set(_fo.proposer.selector, proposer);\n\n // no fault proofs installed so we're done\n return;\n }\n\n address disputeGameFactoryProxy = _getDisputeGameFactoryProxy(systemConfigProxy);\n if (disputeGameFactoryProxy != address(0)) {\n _fo.set(_fo.disputeGameFactoryProxy.selector, disputeGameFactoryProxy);\n\n address permissionedDisputeGameImpl = _getPermissionedDisputeGame(disputeGameFactoryProxy);\n if (permissionedDisputeGameImpl != address(0)) {\n // permissioned fault proofs installed\n _fo.set(_fo.permissioned.selector, true);\n _fo.set(_fo.permissionedDisputeGameImpl.selector, permissionedDisputeGameImpl);\n\n address challenger = IFetcher(permissionedDisputeGameImpl).challenger();\n _fo.set(_fo.challenger.selector, challenger);\n\n address anchorStateRegistryProxy = IFetcher(permissionedDisputeGameImpl).anchorStateRegistry();\n _fo.set(_fo.anchorStateRegistryProxy.selector, anchorStateRegistryProxy);\n\n address proposer = IFetcher(permissionedDisputeGameImpl).proposer();\n _fo.set(_fo.proposer.selector, proposer);\n\n address delayedWethPermissionedGameProxy = _getDelayedWETHProxy(permissionedDisputeGameImpl);\n _fo.set(_fo.delayedWethPermissionedGameProxy.selector, delayedWethPermissionedGameProxy);\n\n address mipsImpl = IFetcher(permissionedDisputeGameImpl).vm();\n _fo.set(_fo.mipsImpl.selector, mipsImpl);\n\n address preimageOracleImpl = IFetcher(mipsImpl).oracle();\n _fo.set(_fo.preimageOracleImpl.selector, preimageOracleImpl);\n }\n\n address faultDisputeGameImpl = _getFaultDisputeGame(disputeGameFactoryProxy);\n if (faultDisputeGameImpl != address(0)) {\n // permissionless fault proofs installed\n _fo.set(_fo.faultDisputeGameImpl.selector, faultDisputeGameImpl);\n _fo.set(_fo.permissionless.selector, true);\n\n address delayedWethPermissionlessGameProxy = _getDelayedWETHProxy(faultDisputeGameImpl);\n _fo.set(_fo.delayedWethPermissionlessGameProxy.selector, delayedWethPermissionlessGameProxy);\n }\n } else {\n // some older chains have L2OutputOracle instead of DisputeGameFactory.\n address l2OutputOracleProxy = IFetcher(optimismPortalProxy).L2_ORACLE();\n _fo.set(_fo.l2OutputOracleProxy.selector, l2OutputOracleProxy);\n address proposer = IFetcher(l2OutputOracleProxy).PROPOSER();\n _fo.set(_fo.proposer.selector, proposer);\n }\n }\n\n function _getGuardian(address _portal) internal view returns (address) {\n try IFetcher(_portal).guardian() returns (address guardian_) {\n return guardian_;\n } catch {\n return IFetcher(_portal).GUARDIAN();\n }\n }\n\n function _getSystemConfigProxy(address _portal) internal view returns (address) {\n try IFetcher(_portal).systemConfig() returns (address systemConfig_) {\n return systemConfig_;\n } catch {\n return IFetcher(_portal).SYSTEM_CONFIG();\n }\n }\n\n function _getOptimismPortalProxy(address _l1CrossDomainMessengerProxy) internal view returns (address) {\n try IFetcher(_l1CrossDomainMessengerProxy).portal() returns (address optimismPortal_) {\n return optimismPortal_;\n } catch {\n return IFetcher(_l1CrossDomainMessengerProxy).PORTAL();\n }\n }\n\n function _getAddressManager(address _l1CrossDomainMessengerProxy) internal view returns (address) {\n uint256 ADDRESS_MANAGER_MAPPING_SLOT = 1;\n bytes32 slot = keccak256(abi.encode(_l1CrossDomainMessengerProxy, ADDRESS_MANAGER_MAPPING_SLOT));\n return address(uint160(uint256((vm.load(_l1CrossDomainMessengerProxy, slot)))));\n }\n\n function _getL1ERC721BridgeProxy(address _systemConfigProxy) internal view returns (address) {\n try IFetcher(_systemConfigProxy).l1ERC721Bridge() returns (address l1ERC721BridgeProxy_) {\n return l1ERC721BridgeProxy_;\n } catch {\n return address(0);\n }\n }\n\n function _getOptimismMintableERC20FactoryProxy(address _systemConfigProxy) internal view returns (address) {\n try IFetcher(_systemConfigProxy).optimismMintableERC20Factory() returns (\n address optimismMintableERC20FactoryProxy_\n ) {\n return optimismMintableERC20FactoryProxy_;\n } catch {\n return address(0);\n }\n }\n\n function _getDisputeGameFactoryProxy(address _systemConfigProxy) internal view returns (address) {\n try IFetcher(_systemConfigProxy).disputeGameFactory() returns (address disputeGameFactoryProxy_) {\n return disputeGameFactoryProxy_;\n } catch {\n // Some older chains have L2OutputOracle instead of DisputeGameFactory\n return address(0);\n }\n }\n\n function _getSuperchainConfigProxy(address _optimismPortalProxy) internal view returns (address) {\n try IFetcher(_optimismPortalProxy).superchainConfig() returns (address superchainConfigProxy_) {\n return superchainConfigProxy_;\n } catch {\n return address(0);\n }\n }\n\n function _getFaultDisputeGame(address _disputeGameFactoryProxy) internal view returns (address) {\n try IFetcher(_disputeGameFactoryProxy).gameImpls(GameTypes.CANNON) returns (address faultDisputeGame_) {\n return faultDisputeGame_;\n } catch {\n return address(0);\n }\n }\n\n function _getPermissionedDisputeGame(address _disputeGameFactoryProxy) internal view returns (address) {\n try IFetcher(_disputeGameFactoryProxy).gameImpls(GameTypes.PERMISSIONED_CANNON) returns (\n address permissionedDisputeGame_\n ) {\n return permissionedDisputeGame_;\n } catch {\n return address(0);\n }\n }\n\n function _getEthLockboxProxy(address _optimismPortalProxy) internal view returns (address) {\n try IFetcher(_optimismPortalProxy).ethLockbox() returns (address ethLockbox_) {\n return ethLockbox_;\n } catch {\n return address(0);\n }\n }\n\n function _getDelayedWETHProxy(address _disputeGame) internal view returns (address) {\n (bool ok, bytes memory data) = address(_disputeGame).staticcall(abi.encodeCall(IFetcher.weth, ()));\n if (ok && data.length == 32) return abi.decode(data, (address));\n else return address(0);\n }\n\n function _getBatchSubmitter(address _systemConfigProxy) internal view returns (address) {\n bytes32 batcherHash = IFetcher(_systemConfigProxy).batcherHash();\n return address(uint160(uint256(batcherHash)));\n }\n\n function _getProxyAdmin(address _systemConfigProxy) internal returns (address) {\n vm.prank(address(0));\n return IFetcher(_systemConfigProxy).admin();\n }\n}\n","license":"MIT"},"src/dispute/lib/LibPosition.sol":{"keccak256":"0x7c5f19f8f54f06de2ce1c6cdcc5c7af65ac405130a4066cdaf146ca315818241","urls":[],"content":"// SPDX-License-Identifier: MIT\npragma solidity ^0.8.15;\n\nusing LibPosition for Position global;\n\n/// @notice A `Position` represents a position of a claim within the game tree.\n/// @dev This is represented as a \"generalized index\" where the high-order bit\n/// is the level in the tree and the remaining bits is a unique bit pattern, allowing\n/// a unique identifier for each node in the tree. Mathematically, it is calculated\n/// as 2^{depth} + indexAtDepth.\ntype Position is uint128;\n\n/// @title LibPosition\n/// @notice This library contains helper functions for working with the `Position` type.\nlibrary LibPosition {\n /// @notice the `MAX_POSITION_BITLEN` is the number of bits that the `Position` type, and the implementation of\n /// its behavior within this library, can safely support.\n uint8 internal constant MAX_POSITION_BITLEN = 126;\n\n /// @notice Computes a generalized index (2^{depth} + indexAtDepth).\n /// @param _depth The depth of the position.\n /// @param _indexAtDepth The index at the depth of the position.\n /// @return position_ The computed generalized index.\n function wrap(uint8 _depth, uint128 _indexAtDepth) internal pure returns (Position position_) {\n assembly {\n // gindex = 2^{_depth} + _indexAtDepth\n position_ := add(shl(_depth, 1), _indexAtDepth)\n }\n }\n\n /// @notice Pulls the `depth` out of a `Position` type.\n /// @param _position The generalized index to get the `depth` of.\n /// @return depth_ The `depth` of the `position` gindex.\n /// @custom:attribution Solady \n function depth(Position _position) internal pure returns (uint8 depth_) {\n // Return the most significant bit offset, which signifies the depth of the gindex.\n assembly {\n depth_ := or(depth_, shl(6, lt(0xffffffffffffffff, shr(depth_, _position))))\n depth_ := or(depth_, shl(5, lt(0xffffffff, shr(depth_, _position))))\n\n // For the remaining 32 bits, use a De Bruijn lookup.\n _position := shr(depth_, _position)\n _position := or(_position, shr(1, _position))\n _position := or(_position, shr(2, _position))\n _position := or(_position, shr(4, _position))\n _position := or(_position, shr(8, _position))\n _position := or(_position, shr(16, _position))\n\n depth_ :=\n or(\n depth_,\n byte(\n shr(251, mul(_position, shl(224, 0x07c4acdd))),\n 0x0009010a0d15021d0b0e10121619031e080c141c0f111807131b17061a05041f\n )\n )\n }\n }\n\n /// @notice Pulls the `indexAtDepth` out of a `Position` type.\n /// The `indexAtDepth` is the left/right index of a position at a specific depth within\n /// the binary tree, starting from index 0. For example, at gindex 2, the `depth` = 1\n /// and the `indexAtDepth` = 0.\n /// @param _position The generalized index to get the `indexAtDepth` of.\n /// @return indexAtDepth_ The `indexAtDepth` of the `position` gindex.\n function indexAtDepth(Position _position) internal pure returns (uint128 indexAtDepth_) {\n // Return bits p_{msb-1}...p_{0}. This effectively pulls the 2^{depth} out of the gindex,\n // leaving only the `indexAtDepth`.\n uint256 msb = depth(_position);\n assembly {\n indexAtDepth_ := sub(_position, shl(msb, 1))\n }\n }\n\n /// @notice Get the left child of `_position`.\n /// @param _position The position to get the left position of.\n /// @return left_ The position to the left of `position`.\n function left(Position _position) internal pure returns (Position left_) {\n assembly {\n left_ := shl(1, _position)\n }\n }\n\n /// @notice Get the right child of `_position`\n /// @param _position The position to get the right position of.\n /// @return right_ The position to the right of `position`.\n function right(Position _position) internal pure returns (Position right_) {\n assembly {\n right_ := or(1, shl(1, _position))\n }\n }\n\n /// @notice Get the parent position of `_position`.\n /// @param _position The position to get the parent position of.\n /// @return parent_ The parent position of `position`.\n function parent(Position _position) internal pure returns (Position parent_) {\n assembly {\n parent_ := shr(1, _position)\n }\n }\n\n /// @notice Get the deepest, right most gindex relative to the `position`. This is equivalent to\n /// calling `right` on a position until the maximum depth is reached.\n /// @param _position The position to get the relative deepest, right most gindex of.\n /// @param _maxDepth The maximum depth of the game.\n /// @return rightIndex_ The deepest, right most gindex relative to the `position`.\n function rightIndex(Position _position, uint256 _maxDepth) internal pure returns (Position rightIndex_) {\n uint256 msb = depth(_position);\n assembly {\n let remaining := sub(_maxDepth, msb)\n rightIndex_ := or(shl(remaining, _position), sub(shl(remaining, 1), 1))\n }\n }\n\n /// @notice Get the deepest, right most trace index relative to the `position`. This is\n /// equivalent to calling `right` on a position until the maximum depth is reached and\n /// then finding its index at depth.\n /// @param _position The position to get the relative trace index of.\n /// @param _maxDepth The maximum depth of the game.\n /// @return traceIndex_ The trace index relative to the `position`.\n function traceIndex(Position _position, uint256 _maxDepth) internal pure returns (uint256 traceIndex_) {\n uint256 msb = depth(_position);\n assembly {\n let remaining := sub(_maxDepth, msb)\n traceIndex_ := sub(or(shl(remaining, _position), sub(shl(remaining, 1), 1)), shl(_maxDepth, 1))\n }\n }\n\n /// @notice Gets the position of the highest ancestor of `_position` that commits to the same\n /// trace index.\n /// @param _position The position to get the highest ancestor of.\n /// @return ancestor_ The highest ancestor of `position` that commits to the same trace index.\n function traceAncestor(Position _position) internal pure returns (Position ancestor_) {\n // Create a field with only the lowest unset bit of `_position` set.\n Position lsb;\n assembly {\n lsb := and(not(_position), add(_position, 1))\n }\n // Find the index of the lowest unset bit within the field.\n uint256 msb = depth(lsb);\n // The highest ancestor that commits to the same trace index is the original position\n // shifted right by the index of the lowest unset bit.\n assembly {\n let a := shr(msb, _position)\n // Bound the ancestor to the minimum gindex, 1.\n ancestor_ := or(a, iszero(a))\n }\n }\n\n /// @notice Gets the position of the highest ancestor of `_position` that commits to the same\n /// trace index, while still being below `_upperBoundExclusive`.\n /// @param _position The position to get the highest ancestor of.\n /// @param _upperBoundExclusive The exclusive upper depth bound, used to inform where to stop in order\n /// to not escape a sub-tree.\n /// @return ancestor_ The highest ancestor of `position` that commits to the same trace index.\n function traceAncestorBounded(\n Position _position,\n uint256 _upperBoundExclusive\n )\n internal\n pure\n returns (Position ancestor_)\n {\n // This function only works for positions that are below the upper bound.\n if (_position.depth() <= _upperBoundExclusive) {\n assembly {\n // Revert with `ClaimAboveSplit()`\n mstore(0x00, 0xb34b5c22)\n revert(0x1C, 0x04)\n }\n }\n\n // Grab the global trace ancestor.\n ancestor_ = traceAncestor(_position);\n\n // If the ancestor is above or at the upper bound, shift it to be below the upper bound.\n // This should be a special case that only covers positions that commit to the final leaf\n // in a sub-tree.\n if (ancestor_.depth() <= _upperBoundExclusive) {\n ancestor_ = ancestor_.rightIndex(_upperBoundExclusive + 1);\n }\n }\n\n /// @notice Get the move position of `_position`, which is the left child of:\n /// 1. `_position` if `_isAttack` is true.\n /// 2. `_position | 1` if `_isAttack` is false.\n /// @param _position The position to get the relative attack/defense position of.\n /// @param _isAttack Whether or not the move is an attack move.\n /// @return move_ The move position relative to `position`.\n function move(Position _position, bool _isAttack) internal pure returns (Position move_) {\n assembly {\n move_ := shl(1, or(iszero(_isAttack), _position))\n }\n }\n\n /// @notice Get the value of a `Position` type in the form of the underlying uint128.\n /// @param _position The position to get the value of.\n /// @return raw_ The value of the `position` as a uint128 type.\n function raw(Position _position) internal pure returns (uint128 raw_) {\n assembly {\n raw_ := _position\n }\n }\n}\n","license":"MIT"},"src/dispute/lib/LibUDT.sol":{"keccak256":"0x41d55e9c74d979b5b797198e38449e7cef4f925e04d61f7699e9c150c4a659d3","urls":[],"content":"// SPDX-License-Identifier: MIT\npragma solidity ^0.8.15;\n\n// Libraries\nimport { Position } from \"src/dispute/lib/LibPosition.sol\";\n\nusing LibClaim for Claim global;\nusing LibHash for Hash global;\nusing LibDuration for Duration global;\nusing LibClock for Clock global;\nusing LibGameId for GameId global;\nusing LibTimestamp for Timestamp global;\nusing LibVMStatus for VMStatus global;\nusing LibGameType for GameType global;\n\n/// @notice A `Clock` represents a packed `Duration` and `Timestamp`\n/// @dev The packed layout of this type is as follows:\n/// ┌────────────┬────────────────┐\n/// │ Bits │ Value │\n/// ├────────────┼────────────────┤\n/// │ [0, 64) │ Duration │\n/// │ [64, 128) │ Timestamp │\n/// └────────────┴────────────────┘\ntype Clock is uint128;\n\n/// @title LibClock\n/// @notice This library contains helper functions for working with the `Clock` type.\nlibrary LibClock {\n /// @notice Packs a `Duration` and `Timestamp` into a `Clock` type.\n /// @param _duration The `Duration` to pack into the `Clock` type.\n /// @param _timestamp The `Timestamp` to pack into the `Clock` type.\n /// @return clock_ The `Clock` containing the `_duration` and `_timestamp`.\n function wrap(Duration _duration, Timestamp _timestamp) internal pure returns (Clock clock_) {\n assembly {\n clock_ := or(shl(0x40, _duration), _timestamp)\n }\n }\n\n /// @notice Pull the `Duration` out of a `Clock` type.\n /// @param _clock The `Clock` type to pull the `Duration` out of.\n /// @return duration_ The `Duration` pulled out of `_clock`.\n function duration(Clock _clock) internal pure returns (Duration duration_) {\n // Shift the high-order 64 bits into the low-order 64 bits, leaving only the `duration`.\n assembly {\n duration_ := shr(0x40, _clock)\n }\n }\n\n /// @notice Pull the `Timestamp` out of a `Clock` type.\n /// @param _clock The `Clock` type to pull the `Timestamp` out of.\n /// @return timestamp_ The `Timestamp` pulled out of `_clock`.\n function timestamp(Clock _clock) internal pure returns (Timestamp timestamp_) {\n // Clean the high-order 192 bits by shifting the clock left and then right again, leaving\n // only the `timestamp`.\n assembly {\n timestamp_ := shr(0xC0, shl(0xC0, _clock))\n }\n }\n\n /// @notice Get the value of a `Clock` type in the form of the underlying uint128.\n /// @param _clock The `Clock` type to get the value of.\n /// @return clock_ The value of the `Clock` type as a uint128 type.\n function raw(Clock _clock) internal pure returns (uint128 clock_) {\n assembly {\n clock_ := _clock\n }\n }\n}\n\n/// @notice A `GameId` represents a packed 4 byte game ID, a 8 byte timestamp, and a 20 byte address.\n/// @dev The packed layout of this type is as follows:\n/// ┌───────────┬───────────┐\n/// │ Bits │ Value │\n/// ├───────────┼───────────┤\n/// │ [0, 32) │ Game Type │\n/// │ [32, 96) │ Timestamp │\n/// │ [96, 256) │ Address │\n/// └───────────┴───────────┘\ntype GameId is bytes32;\n\n/// @title LibGameId\n/// @notice Utility functions for packing and unpacking GameIds.\nlibrary LibGameId {\n /// @notice Packs values into a 32 byte GameId type.\n /// @param _gameType The game type.\n /// @param _timestamp The timestamp of the game's creation.\n /// @param _gameProxy The game proxy address.\n /// @return gameId_ The packed GameId.\n function pack(\n GameType _gameType,\n Timestamp _timestamp,\n address _gameProxy\n )\n internal\n pure\n returns (GameId gameId_)\n {\n assembly {\n gameId_ := or(or(shl(224, _gameType), shl(160, _timestamp)), _gameProxy)\n }\n }\n\n /// @notice Unpacks values from a 32 byte GameId type.\n /// @param _gameId The packed GameId.\n /// @return gameType_ The game type.\n /// @return timestamp_ The timestamp of the game's creation.\n /// @return gameProxy_ The game proxy address.\n function unpack(GameId _gameId)\n internal\n pure\n returns (GameType gameType_, Timestamp timestamp_, address gameProxy_)\n {\n assembly {\n gameType_ := shr(224, _gameId)\n timestamp_ := and(shr(160, _gameId), 0xFFFFFFFFFFFFFFFF)\n gameProxy_ := and(_gameId, 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF)\n }\n }\n}\n\n/// @notice A claim represents an MPT root representing the state of the fault proof program.\ntype Claim is bytes32;\n\n/// @title LibClaim\n/// @notice This library contains helper functions for working with the `Claim` type.\nlibrary LibClaim {\n /// @notice Get the value of a `Claim` type in the form of the underlying bytes32.\n /// @param _claim The `Claim` type to get the value of.\n /// @return claim_ The value of the `Claim` type as a bytes32 type.\n function raw(Claim _claim) internal pure returns (bytes32 claim_) {\n assembly {\n claim_ := _claim\n }\n }\n\n /// @notice Hashes a claim and a position together.\n /// @param _claim A Claim type.\n /// @param _position The position of `claim`.\n /// @param _challengeIndex The index of the claim being moved against.\n /// @return claimHash_ A hash of abi.encodePacked(claim, position|challengeIndex);\n function hashClaimPos(\n Claim _claim,\n Position _position,\n uint256 _challengeIndex\n )\n internal\n pure\n returns (Hash claimHash_)\n {\n assembly {\n mstore(0x00, _claim)\n mstore(0x20, or(shl(128, _position), and(0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF, _challengeIndex)))\n claimHash_ := keccak256(0x00, 0x40)\n }\n }\n}\n\n/// @notice A dedicated duration type.\n/// @dev Unit: seconds\ntype Duration is uint64;\n\n/// @title LibDuration\n/// @notice This library contains helper functions for working with the `Duration` type.\nlibrary LibDuration {\n /// @notice Get the value of a `Duration` type in the form of the underlying uint64.\n /// @param _duration The `Duration` type to get the value of.\n /// @return duration_ The value of the `Duration` type as a uint64 type.\n function raw(Duration _duration) internal pure returns (uint64 duration_) {\n assembly {\n duration_ := _duration\n }\n }\n}\n\n/// @notice A custom type for a generic hash.\ntype Hash is bytes32;\n\n/// @title LibHash\n/// @notice This library contains helper functions for working with the `Hash` type.\nlibrary LibHash {\n /// @notice Get the value of a `Hash` type in the form of the underlying bytes32.\n /// @param _hash The `Hash` type to get the value of.\n /// @return hash_ The value of the `Hash` type as a bytes32 type.\n function raw(Hash _hash) internal pure returns (bytes32 hash_) {\n assembly {\n hash_ := _hash\n }\n }\n}\n\n/// @notice A dedicated timestamp type.\ntype Timestamp is uint64;\n\n/// @title LibTimestamp\n/// @notice This library contains helper functions for working with the `Timestamp` type.\nlibrary LibTimestamp {\n /// @notice Get the value of a `Timestamp` type in the form of the underlying uint64.\n /// @param _timestamp The `Timestamp` type to get the value of.\n /// @return timestamp_ The value of the `Timestamp` type as a uint64 type.\n function raw(Timestamp _timestamp) internal pure returns (uint64 timestamp_) {\n assembly {\n timestamp_ := _timestamp\n }\n }\n}\n\n/// @notice A `VMStatus` represents the status of a VM execution.\ntype VMStatus is uint8;\n\n/// @title LibVMStatus\n/// @notice This library contains helper functions for working with the `VMStatus` type.\nlibrary LibVMStatus {\n /// @notice Get the value of a `VMStatus` type in the form of the underlying uint8.\n /// @param _vmstatus The `VMStatus` type to get the value of.\n /// @return vmstatus_ The value of the `VMStatus` type as a uint8 type.\n function raw(VMStatus _vmstatus) internal pure returns (uint8 vmstatus_) {\n assembly {\n vmstatus_ := _vmstatus\n }\n }\n}\n\n/// @notice A `GameType` represents the type of game being played.\ntype GameType is uint32;\n\n/// @title LibGameType\n/// @notice This library contains helper functions for working with the `GameType` type.\nlibrary LibGameType {\n /// @notice Get the value of a `GameType` type in the form of the underlying uint32.\n /// @param _gametype The `GameType` type to get the value of.\n /// @return gametype_ The value of the `GameType` type as a uint32 type.\n function raw(GameType _gametype) internal pure returns (uint32 gametype_) {\n assembly {\n gametype_ := _gametype\n }\n }\n}\n","license":"MIT"},"src/dispute/lib/Types.sol":{"keccak256":"0x7cc2960ea5c5223d81ae2156a966fa0226b70f9666932aca63a0a2a45c9182ae","urls":[],"content":"// SPDX-License-Identifier: MIT\npragma solidity ^0.8.15;\n\n// Libraries\nimport {\n Position,\n Hash,\n GameType,\n VMStatus,\n Timestamp,\n Duration,\n Clock,\n GameId,\n Claim,\n LibGameId,\n LibClock\n} from \"src/dispute/lib/LibUDT.sol\";\n\n/// @notice The current status of the dispute game.\nenum GameStatus {\n // The game is currently in progress, and has not been resolved.\n IN_PROGRESS,\n // The game has concluded, and the `rootClaim` was challenged successfully.\n CHALLENGER_WINS,\n // The game has concluded, and the `rootClaim` could not be contested.\n DEFENDER_WINS\n}\n\n/// @notice The game's bond distribution type. Games are expected to start in the `UNDECIDED`\n/// state, and then choose either `NORMAL` or `REFUND`.\nenum BondDistributionMode {\n // Bond distribution strategy has not been chosen.\n UNDECIDED,\n // Bonds should be distributed as normal.\n NORMAL,\n // Bonds should be refunded to claimants.\n REFUND\n}\n\n/// @notice Represents an L2 root and the L2 sequence number at which it was generated.\n/// @custom:field root The output root.\n/// @custom:field l2SequenceNumber The L2 Sequence Number ( e.g. block number / timestamp) at which the root was\n/// generated.\nstruct Proposal {\n Hash root;\n uint256 l2SequenceNumber;\n}\n\n/// @title GameTypes\n/// @notice A library that defines the IDs of games that can be played.\nlibrary GameTypes {\n /// @dev A dispute game type the uses the cannon vm.\n GameType internal constant CANNON = GameType.wrap(0);\n\n /// @dev A permissioned dispute game type that uses the cannon vm.\n GameType internal constant PERMISSIONED_CANNON = GameType.wrap(1);\n\n /// @notice A dispute game type that uses the asterisc vm.\n GameType internal constant ASTERISC = GameType.wrap(2);\n\n /// @notice A dispute game type that uses the asterisc vm with Kona.\n GameType internal constant ASTERISC_KONA = GameType.wrap(3);\n\n /// @notice A dispute game type that uses the cannon vm (Super Roots).\n GameType internal constant SUPER_CANNON = GameType.wrap(4);\n\n /// @notice A dispute game type that uses the permissioned cannon vm (Super Roots).\n GameType internal constant SUPER_PERMISSIONED_CANNON = GameType.wrap(5);\n\n /// @notice A dispute game type that uses OP Succinct\n GameType internal constant OP_SUCCINCT = GameType.wrap(6);\n\n /// @notice A dispute game type with short game duration for testing withdrawals.\n /// Not intended for production use.\n GameType internal constant FAST = GameType.wrap(254);\n\n /// @notice A dispute game type that uses an alphabet vm.\n /// Not intended for production use.\n GameType internal constant ALPHABET = GameType.wrap(255);\n\n /// @notice A dispute game type that uses RISC Zero's Kailua\n GameType internal constant KAILUA = GameType.wrap(1337);\n}\n\n/// @title VMStatuses\n/// @notice Named type aliases for the various valid VM status bytes.\nlibrary VMStatuses {\n /// @notice The VM has executed successfully and the outcome is valid.\n VMStatus internal constant VALID = VMStatus.wrap(0);\n\n /// @notice The VM has executed successfully and the outcome is invalid.\n VMStatus internal constant INVALID = VMStatus.wrap(1);\n\n /// @notice The VM has paniced.\n VMStatus internal constant PANIC = VMStatus.wrap(2);\n\n /// @notice The VM execution is still in progress.\n VMStatus internal constant UNFINISHED = VMStatus.wrap(3);\n}\n\n/// @title LocalPreimageKey\n/// @notice Named type aliases for local `PreimageOracle` key identifiers.\nlibrary LocalPreimageKey {\n /// @notice The identifier for the L1 head hash.\n uint256 internal constant L1_HEAD_HASH = 0x01;\n\n /// @notice The identifier for the starting output root.\n uint256 internal constant STARTING_OUTPUT_ROOT = 0x02;\n\n /// @notice The identifier for the disputed output root.\n uint256 internal constant DISPUTED_OUTPUT_ROOT = 0x03;\n\n /// @notice The identifier for the disputed L2 block number.\n uint256 internal constant DISPUTED_L2_BLOCK_NUMBER = 0x04;\n\n /// @notice The identifier for the chain ID.\n uint256 internal constant CHAIN_ID = 0x05;\n}\n","license":"MIT"}},"version":1},"storageLayout":{"storage":[{"astId":57328,"contract":"scripts/FetchChainInfo.s.sol:FetchChainInfoInput","label":"_systemConfigProxy","offset":0,"slot":"0","type":"t_address"},{"astId":57330,"contract":"scripts/FetchChainInfo.s.sol:FetchChainInfoInput","label":"_l1StandardBridgeProxy","offset":0,"slot":"1","type":"t_address"}],"types":{"t_address":{"encoding":"inplace","label":"address","numberOfBytes":"20"}}},"userdoc":{"version":1,"kind":"user"},"devdoc":{"version":1,"kind":"dev"},"ast":{"absolutePath":"scripts/FetchChainInfo.s.sol","id":59300,"exportedSymbols":{"FetchChainInfo":[59299],"FetchChainInfoInput":[57409],"FetchChainInfoOutput":[58249],"GameType":[75355],"GameTypes":[75481],"IFetcher":[57326],"Script":[6037]},"nodeType":"SourceUnit","src":"32:23957:120","nodes":[{"id":57175,"nodeType":"PragmaDirective","src":"32:23:120","nodes":[],"literals":["solidity","^","0.8",".0"]},{"id":57177,"nodeType":"ImportDirective","src":"57:46:120","nodes":[],"absolutePath":"lib/forge-std/src/Script.sol","file":"forge-std/Script.sol","nameLocation":"-1:-1:-1","scope":59300,"sourceUnit":6038,"symbolAliases":[{"foreign":{"id":57176,"name":"Script","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":6037,"src":"66:6:120","typeDescriptions":{}},"nameLocation":"-1:-1:-1"}],"unitAlias":""},{"id":57180,"nodeType":"ImportDirective","src":"104:64:120","nodes":[],"absolutePath":"src/dispute/lib/Types.sol","file":"src/dispute/lib/Types.sol","nameLocation":"-1:-1:-1","scope":59300,"sourceUnit":75538,"symbolAliases":[{"foreign":{"id":57178,"name":"GameTypes","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":75481,"src":"113:9:120","typeDescriptions":{}},"nameLocation":"-1:-1:-1"},{"foreign":{"id":57179,"name":"GameType","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":75355,"src":"124:8:120","typeDescriptions":{}},"nameLocation":"-1:-1:-1"}],"unitAlias":""},{"id":57326,"nodeType":"ContractDefinition","src":"306:1713:120","nodes":[{"id":57186,"nodeType":"FunctionDefinition","src":"331:52:120","nodes":[],"functionSelector":"452a9320","implemented":false,"kind":"function","modifiers":[],"name":"guardian","nameLocation":"340:8:120","parameters":{"id":57182,"nodeType":"ParameterList","parameters":[],"src":"348:2:120"},"returnParameters":{"id":57185,"nodeType":"ParameterList","parameters":[{"constant":false,"id":57184,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":57186,"src":"374:7:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":57183,"name":"address","nodeType":"ElementaryTypeName","src":"374:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"373:9:120"},"scope":57326,"stateMutability":"view","virtual":false,"visibility":"external"},{"id":57191,"nodeType":"FunctionDefinition","src":"388:52:120","nodes":[],"functionSelector":"724c184c","implemented":false,"kind":"function","modifiers":[],"name":"GUARDIAN","nameLocation":"397:8:120","parameters":{"id":57187,"nodeType":"ParameterList","parameters":[],"src":"405:2:120"},"returnParameters":{"id":57190,"nodeType":"ParameterList","parameters":[{"constant":false,"id":57189,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":57191,"src":"431:7:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":57188,"name":"address","nodeType":"ElementaryTypeName","src":"431:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"430:9:120"},"scope":57326,"stateMutability":"view","virtual":false,"visibility":"external"},{"id":57196,"nodeType":"FunctionDefinition","src":"445:56:120","nodes":[],"functionSelector":"33d7e2bd","implemented":false,"kind":"function","modifiers":[],"name":"systemConfig","nameLocation":"454:12:120","parameters":{"id":57192,"nodeType":"ParameterList","parameters":[],"src":"466:2:120"},"returnParameters":{"id":57195,"nodeType":"ParameterList","parameters":[{"constant":false,"id":57194,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":57196,"src":"492:7:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":57193,"name":"address","nodeType":"ElementaryTypeName","src":"492:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"491:9:120"},"scope":57326,"stateMutability":"view","virtual":false,"visibility":"external"},{"id":57201,"nodeType":"FunctionDefinition","src":"506:57:120","nodes":[],"functionSelector":"f0498750","implemented":false,"kind":"function","modifiers":[],"name":"SYSTEM_CONFIG","nameLocation":"515:13:120","parameters":{"id":57197,"nodeType":"ParameterList","parameters":[],"src":"528:2:120"},"returnParameters":{"id":57200,"nodeType":"ParameterList","parameters":[{"constant":false,"id":57199,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":57201,"src":"554:7:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":57198,"name":"address","nodeType":"ElementaryTypeName","src":"554:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"553:9:120"},"scope":57326,"stateMutability":"view","virtual":false,"visibility":"external"},{"id":57206,"nodeType":"FunctionDefinition","src":"568:62:120","nodes":[],"functionSelector":"f2b4e617","implemented":false,"kind":"function","modifiers":[],"name":"disputeGameFactory","nameLocation":"577:18:120","parameters":{"id":57202,"nodeType":"ParameterList","parameters":[],"src":"595:2:120"},"returnParameters":{"id":57205,"nodeType":"ParameterList","parameters":[{"constant":false,"id":57204,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":57206,"src":"621:7:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":57203,"name":"address","nodeType":"ElementaryTypeName","src":"621:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"620:9:120"},"scope":57326,"stateMutability":"view","virtual":false,"visibility":"external"},{"id":57211,"nodeType":"FunctionDefinition","src":"635:54:120","nodes":[],"functionSelector":"b682c444","implemented":false,"kind":"function","modifiers":[],"name":"ethLockbox","nameLocation":"644:10:120","parameters":{"id":57207,"nodeType":"ParameterList","parameters":[],"src":"654:2:120"},"returnParameters":{"id":57210,"nodeType":"ParameterList","parameters":[{"constant":false,"id":57209,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":57211,"src":"680:7:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":57208,"name":"address","nodeType":"ElementaryTypeName","src":"680:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"679:9:120"},"scope":57326,"stateMutability":"view","virtual":false,"visibility":"external"},{"id":57216,"nodeType":"FunctionDefinition","src":"694:60:120","nodes":[],"functionSelector":"35e80ab3","implemented":false,"kind":"function","modifiers":[],"name":"superchainConfig","nameLocation":"703:16:120","parameters":{"id":57212,"nodeType":"ParameterList","parameters":[],"src":"719:2:120"},"returnParameters":{"id":57215,"nodeType":"ParameterList","parameters":[{"constant":false,"id":57214,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":57216,"src":"745:7:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":57213,"name":"address","nodeType":"ElementaryTypeName","src":"745:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"744:9:120"},"scope":57326,"stateMutability":"view","virtual":false,"visibility":"external"},{"id":57221,"nodeType":"FunctionDefinition","src":"759:53:120","nodes":[],"functionSelector":"3cb747bf","implemented":false,"kind":"function","modifiers":[],"name":"messenger","nameLocation":"768:9:120","parameters":{"id":57217,"nodeType":"ParameterList","parameters":[],"src":"777:2:120"},"returnParameters":{"id":57220,"nodeType":"ParameterList","parameters":[{"constant":false,"id":57219,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":57221,"src":"803:7:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":57218,"name":"address","nodeType":"ElementaryTypeName","src":"803:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"802:9:120"},"scope":57326,"stateMutability":"view","virtual":false,"visibility":"external"},{"id":57226,"nodeType":"FunctionDefinition","src":"817:58:120","nodes":[],"functionSelector":"3ab76e9f","implemented":false,"kind":"function","modifiers":[],"name":"addressManager","nameLocation":"826:14:120","parameters":{"id":57222,"nodeType":"ParameterList","parameters":[],"src":"840:2:120"},"returnParameters":{"id":57225,"nodeType":"ParameterList","parameters":[{"constant":false,"id":57224,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":57226,"src":"866:7:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":57223,"name":"address","nodeType":"ElementaryTypeName","src":"866:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"865:9:120"},"scope":57326,"stateMutability":"view","virtual":false,"visibility":"external"},{"id":57231,"nodeType":"FunctionDefinition","src":"880:50:120","nodes":[],"functionSelector":"0ff754ea","implemented":false,"kind":"function","modifiers":[],"name":"PORTAL","nameLocation":"889:6:120","parameters":{"id":57227,"nodeType":"ParameterList","parameters":[],"src":"895:2:120"},"returnParameters":{"id":57230,"nodeType":"ParameterList","parameters":[{"constant":false,"id":57229,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":57231,"src":"921:7:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":57228,"name":"address","nodeType":"ElementaryTypeName","src":"921:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"920:9:120"},"scope":57326,"stateMutability":"view","virtual":false,"visibility":"external"},{"id":57236,"nodeType":"FunctionDefinition","src":"935:50:120","nodes":[],"functionSelector":"6425666b","implemented":false,"kind":"function","modifiers":[],"name":"portal","nameLocation":"944:6:120","parameters":{"id":57232,"nodeType":"ParameterList","parameters":[],"src":"950:2:120"},"returnParameters":{"id":57235,"nodeType":"ParameterList","parameters":[{"constant":false,"id":57234,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":57236,"src":"976:7:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":57233,"name":"address","nodeType":"ElementaryTypeName","src":"976:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"975:9:120"},"scope":57326,"stateMutability":"view","virtual":false,"visibility":"external"},{"id":57241,"nodeType":"FunctionDefinition","src":"990:58:120","nodes":[],"functionSelector":"c4e8ddfa","implemented":false,"kind":"function","modifiers":[],"name":"l1ERC721Bridge","nameLocation":"999:14:120","parameters":{"id":57237,"nodeType":"ParameterList","parameters":[],"src":"1013:2:120"},"returnParameters":{"id":57240,"nodeType":"ParameterList","parameters":[{"constant":false,"id":57239,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":57241,"src":"1039:7:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":57238,"name":"address","nodeType":"ElementaryTypeName","src":"1039:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"1038:9:120"},"scope":57326,"stateMutability":"view","virtual":false,"visibility":"external"},{"id":57246,"nodeType":"FunctionDefinition","src":"1053:72:120","nodes":[],"functionSelector":"9b7d7f0a","implemented":false,"kind":"function","modifiers":[],"name":"optimismMintableERC20Factory","nameLocation":"1062:28:120","parameters":{"id":57242,"nodeType":"ParameterList","parameters":[],"src":"1090:2:120"},"returnParameters":{"id":57245,"nodeType":"ParameterList","parameters":[{"constant":false,"id":57244,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":57246,"src":"1116:7:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":57243,"name":"address","nodeType":"ElementaryTypeName","src":"1116:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"1115:9:120"},"scope":57326,"stateMutability":"view","virtual":false,"visibility":"external"},{"id":57254,"nodeType":"FunctionDefinition","src":"1130:71:120","nodes":[],"functionSelector":"1b685b9e","implemented":false,"kind":"function","modifiers":[],"name":"gameImpls","nameLocation":"1139:9:120","parameters":{"id":57250,"nodeType":"ParameterList","parameters":[{"constant":false,"id":57249,"mutability":"mutable","name":"_gameType","nameLocation":"1158:9:120","nodeType":"VariableDeclaration","scope":57254,"src":"1149:18:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_userDefinedValueType$_GameType_$75355","typeString":"GameType"},"typeName":{"id":57248,"nodeType":"UserDefinedTypeName","pathNode":{"id":57247,"name":"GameType","nameLocations":["1149:8:120"],"nodeType":"IdentifierPath","referencedDeclaration":75355,"src":"1149:8:120"},"referencedDeclaration":75355,"src":"1149:8:120","typeDescriptions":{"typeIdentifier":"t_userDefinedValueType$_GameType_$75355","typeString":"GameType"}},"visibility":"internal"}],"src":"1148:20:120"},"returnParameters":{"id":57253,"nodeType":"ParameterList","parameters":[{"constant":false,"id":57252,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":57254,"src":"1192:7:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":57251,"name":"address","nodeType":"ElementaryTypeName","src":"1192:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"1191:9:120"},"scope":57326,"stateMutability":"view","virtual":false,"visibility":"external"},{"id":57260,"nodeType":"FunctionDefinition","src":"1206:62:120","nodes":[],"functionSelector":"3c9f397c","implemented":false,"kind":"function","modifiers":[],"name":"respectedGameType","nameLocation":"1215:17:120","parameters":{"id":57255,"nodeType":"ParameterList","parameters":[],"src":"1232:2:120"},"returnParameters":{"id":57259,"nodeType":"ParameterList","parameters":[{"constant":false,"id":57258,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":57260,"src":"1258:8:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_userDefinedValueType$_GameType_$75355","typeString":"GameType"},"typeName":{"id":57257,"nodeType":"UserDefinedTypeName","pathNode":{"id":57256,"name":"GameType","nameLocations":["1258:8:120"],"nodeType":"IdentifierPath","referencedDeclaration":75355,"src":"1258:8:120"},"referencedDeclaration":75355,"src":"1258:8:120","typeDescriptions":{"typeIdentifier":"t_userDefinedValueType$_GameType_$75355","typeString":"GameType"}},"visibility":"internal"}],"src":"1257:10:120"},"scope":57326,"stateMutability":"view","virtual":false,"visibility":"external"},{"id":57265,"nodeType":"FunctionDefinition","src":"1273:63:120","nodes":[],"functionSelector":"5c0cba33","implemented":false,"kind":"function","modifiers":[],"name":"anchorStateRegistry","nameLocation":"1282:19:120","parameters":{"id":57261,"nodeType":"ParameterList","parameters":[],"src":"1301:2:120"},"returnParameters":{"id":57264,"nodeType":"ParameterList","parameters":[{"constant":false,"id":57263,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":57265,"src":"1327:7:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":57262,"name":"address","nodeType":"ElementaryTypeName","src":"1327:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"1326:9:120"},"scope":57326,"stateMutability":"view","virtual":false,"visibility":"external"},{"id":57270,"nodeType":"FunctionDefinition","src":"1341:53:120","nodes":[],"functionSelector":"001c2ff6","implemented":false,"kind":"function","modifiers":[],"name":"L2_ORACLE","nameLocation":"1350:9:120","parameters":{"id":57266,"nodeType":"ParameterList","parameters":[],"src":"1359:2:120"},"returnParameters":{"id":57269,"nodeType":"ParameterList","parameters":[{"constant":false,"id":57268,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":57270,"src":"1385:7:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":57267,"name":"address","nodeType":"ElementaryTypeName","src":"1385:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"1384:9:120"},"scope":57326,"stateMutability":"view","virtual":false,"visibility":"external"},{"id":57275,"nodeType":"FunctionDefinition","src":"1399:52:120","nodes":[],"functionSelector":"9b5f694a","implemented":false,"kind":"function","modifiers":[],"name":"l2Oracle","nameLocation":"1408:8:120","parameters":{"id":57271,"nodeType":"ParameterList","parameters":[],"src":"1416:2:120"},"returnParameters":{"id":57274,"nodeType":"ParameterList","parameters":[{"constant":false,"id":57273,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":57275,"src":"1442:7:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":57272,"name":"address","nodeType":"ElementaryTypeName","src":"1442:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"1441:9:120"},"scope":57326,"stateMutability":"view","virtual":false,"visibility":"external"},{"id":57280,"nodeType":"FunctionDefinition","src":"1456:46:120","nodes":[],"functionSelector":"3a768463","implemented":false,"kind":"function","modifiers":[],"name":"vm","nameLocation":"1465:2:120","parameters":{"id":57276,"nodeType":"ParameterList","parameters":[],"src":"1467:2:120"},"returnParameters":{"id":57279,"nodeType":"ParameterList","parameters":[{"constant":false,"id":57278,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":57280,"src":"1493:7:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":57277,"name":"address","nodeType":"ElementaryTypeName","src":"1493:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"1492:9:120"},"scope":57326,"stateMutability":"view","virtual":false,"visibility":"external"},{"id":57285,"nodeType":"FunctionDefinition","src":"1507:50:120","nodes":[],"functionSelector":"7dc0d1d0","implemented":false,"kind":"function","modifiers":[],"name":"oracle","nameLocation":"1516:6:120","parameters":{"id":57281,"nodeType":"ParameterList","parameters":[],"src":"1522:2:120"},"returnParameters":{"id":57284,"nodeType":"ParameterList","parameters":[{"constant":false,"id":57283,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":57285,"src":"1548:7:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":57282,"name":"address","nodeType":"ElementaryTypeName","src":"1548:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"1547:9:120"},"scope":57326,"stateMutability":"view","virtual":false,"visibility":"external"},{"id":57290,"nodeType":"FunctionDefinition","src":"1562:54:120","nodes":[],"functionSelector":"534db0e2","implemented":false,"kind":"function","modifiers":[],"name":"challenger","nameLocation":"1571:10:120","parameters":{"id":57286,"nodeType":"ParameterList","parameters":[],"src":"1581:2:120"},"returnParameters":{"id":57289,"nodeType":"ParameterList","parameters":[{"constant":false,"id":57288,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":57290,"src":"1607:7:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":57287,"name":"address","nodeType":"ElementaryTypeName","src":"1607:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"1606:9:120"},"scope":57326,"stateMutability":"view","virtual":false,"visibility":"external"},{"id":57295,"nodeType":"FunctionDefinition","src":"1621:52:120","nodes":[],"functionSelector":"a8e4fb90","implemented":false,"kind":"function","modifiers":[],"name":"proposer","nameLocation":"1630:8:120","parameters":{"id":57291,"nodeType":"ParameterList","parameters":[],"src":"1638:2:120"},"returnParameters":{"id":57294,"nodeType":"ParameterList","parameters":[{"constant":false,"id":57293,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":57295,"src":"1664:7:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":57292,"name":"address","nodeType":"ElementaryTypeName","src":"1664:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"1663:9:120"},"scope":57326,"stateMutability":"view","virtual":false,"visibility":"external"},{"id":57300,"nodeType":"FunctionDefinition","src":"1678:52:120","nodes":[],"functionSelector":"bffa7f0f","implemented":false,"kind":"function","modifiers":[],"name":"PROPOSER","nameLocation":"1687:8:120","parameters":{"id":57296,"nodeType":"ParameterList","parameters":[],"src":"1695:2:120"},"returnParameters":{"id":57299,"nodeType":"ParameterList","parameters":[{"constant":false,"id":57298,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":57300,"src":"1721:7:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":57297,"name":"address","nodeType":"ElementaryTypeName","src":"1721:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"1720:9:120"},"scope":57326,"stateMutability":"view","virtual":false,"visibility":"external"},{"id":57305,"nodeType":"FunctionDefinition","src":"1735:55:120","nodes":[],"functionSelector":"e81b2c6d","implemented":false,"kind":"function","modifiers":[],"name":"batcherHash","nameLocation":"1744:11:120","parameters":{"id":57301,"nodeType":"ParameterList","parameters":[],"src":"1755:2:120"},"returnParameters":{"id":57304,"nodeType":"ParameterList","parameters":[{"constant":false,"id":57303,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":57305,"src":"1781:7:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_bytes32","typeString":"bytes32"},"typeName":{"id":57302,"name":"bytes32","nodeType":"ElementaryTypeName","src":"1781:7:120","typeDescriptions":{"typeIdentifier":"t_bytes32","typeString":"bytes32"}},"visibility":"internal"}],"src":"1780:9:120"},"scope":57326,"stateMutability":"view","virtual":false,"visibility":"external"},{"id":57310,"nodeType":"FunctionDefinition","src":"1795:49:120","nodes":[],"functionSelector":"f851a440","implemented":false,"kind":"function","modifiers":[],"name":"admin","nameLocation":"1804:5:120","parameters":{"id":57306,"nodeType":"ParameterList","parameters":[],"src":"1809:2:120"},"returnParameters":{"id":57309,"nodeType":"ParameterList","parameters":[{"constant":false,"id":57308,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":57310,"src":"1835:7:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":57307,"name":"address","nodeType":"ElementaryTypeName","src":"1835:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"1834:9:120"},"scope":57326,"stateMutability":"view","virtual":false,"visibility":"external"},{"id":57315,"nodeType":"FunctionDefinition","src":"1849:49:120","nodes":[],"functionSelector":"8da5cb5b","implemented":false,"kind":"function","modifiers":[],"name":"owner","nameLocation":"1858:5:120","parameters":{"id":57311,"nodeType":"ParameterList","parameters":[],"src":"1863:2:120"},"returnParameters":{"id":57314,"nodeType":"ParameterList","parameters":[{"constant":false,"id":57313,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":57315,"src":"1889:7:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":57312,"name":"address","nodeType":"ElementaryTypeName","src":"1889:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"1888:9:120"},"scope":57326,"stateMutability":"view","virtual":false,"visibility":"external"},{"id":57320,"nodeType":"FunctionDefinition","src":"1903:61:120","nodes":[],"functionSelector":"1fd19ee1","implemented":false,"kind":"function","modifiers":[],"name":"unsafeBlockSigner","nameLocation":"1912:17:120","parameters":{"id":57316,"nodeType":"ParameterList","parameters":[],"src":"1929:2:120"},"returnParameters":{"id":57319,"nodeType":"ParameterList","parameters":[{"constant":false,"id":57318,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":57320,"src":"1955:7:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":57317,"name":"address","nodeType":"ElementaryTypeName","src":"1955:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"1954:9:120"},"scope":57326,"stateMutability":"view","virtual":false,"visibility":"external"},{"id":57325,"nodeType":"FunctionDefinition","src":"1969:48:120","nodes":[],"functionSelector":"3fc8cef3","implemented":false,"kind":"function","modifiers":[],"name":"weth","nameLocation":"1978:4:120","parameters":{"id":57321,"nodeType":"ParameterList","parameters":[],"src":"1982:2:120"},"returnParameters":{"id":57324,"nodeType":"ParameterList","parameters":[{"constant":false,"id":57323,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":57325,"src":"2008:7:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":57322,"name":"address","nodeType":"ElementaryTypeName","src":"2008:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"2007:9:120"},"scope":57326,"stateMutability":"view","virtual":false,"visibility":"external"}],"abstract":false,"baseContracts":[],"canonicalName":"IFetcher","contractDependencies":[],"contractKind":"interface","documentation":{"id":57181,"nodeType":"StructuredDocumentation","src":"170:136:120","text":"@notice Contains getters for arbitrary methods from all L1 contracts, including legacy getters\n that have since been deprecated."},"fullyImplemented":false,"linearizedBaseContracts":[57326],"name":"IFetcher","nameLocation":"316:8:120","scope":59300,"usedErrors":[],"usedEvents":[]},{"id":57409,"nodeType":"ContractDefinition","src":"2021:934:120","nodes":[{"id":57328,"nodeType":"VariableDeclaration","src":"2056:35:120","nodes":[],"constant":false,"mutability":"mutable","name":"_systemConfigProxy","nameLocation":"2073:18:120","scope":57409,"stateVariable":true,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":57327,"name":"address","nodeType":"ElementaryTypeName","src":"2056:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"},{"id":57330,"nodeType":"VariableDeclaration","src":"2097:39:120","nodes":[],"constant":false,"mutability":"mutable","name":"_l1StandardBridgeProxy","nameLocation":"2114:22:120","scope":57409,"stateVariable":true,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":57329,"name":"address","nodeType":"ElementaryTypeName","src":"2097:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"},{"id":57372,"nodeType":"FunctionDefinition","src":"2143:378:120","nodes":[],"body":{"id":57371,"nodeType":"Block","src":"2191:330:120","nodes":[],"statements":[{"expression":{"arguments":[{"commonType":{"typeIdentifier":"t_address","typeString":"address"},"id":57343,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftExpression":{"id":57338,"name":"_addr","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57334,"src":"2209:5:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"BinaryOperation","operator":"!=","rightExpression":{"arguments":[{"hexValue":"30","id":57341,"isConstant":false,"isLValue":false,"isPure":true,"kind":"number","lValueRequested":false,"nodeType":"Literal","src":"2226:1:120","typeDescriptions":{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"},"value":"0"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"}],"id":57340,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"nodeType":"ElementaryTypeNameExpression","src":"2218:7:120","typeDescriptions":{"typeIdentifier":"t_type$_t_address_$","typeString":"type(address)"},"typeName":{"id":57339,"name":"address","nodeType":"ElementaryTypeName","src":"2218:7:120","typeDescriptions":{}}},"id":57342,"isConstant":false,"isLValue":false,"isPure":true,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"2218:10:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"src":"2209:19:120","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},{"hexValue":"4665746368436861696e496e666f496e7075743a2063616e6e6f7420736574207a65726f2061646472657373","id":57344,"isConstant":false,"isLValue":false,"isPure":true,"kind":"string","lValueRequested":false,"nodeType":"Literal","src":"2230:46:120","typeDescriptions":{"typeIdentifier":"t_stringliteral_0336126ace187312d69da4c7cf05307af6a6596e8c75de2974f56108baf24145","typeString":"literal_string \"FetchChainInfoInput: cannot set zero address\""},"value":"FetchChainInfoInput: cannot set zero address"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_bool","typeString":"bool"},{"typeIdentifier":"t_stringliteral_0336126ace187312d69da4c7cf05307af6a6596e8c75de2974f56108baf24145","typeString":"literal_string \"FetchChainInfoInput: cannot set zero address\""}],"id":57337,"name":"require","nodeType":"Identifier","overloadedDeclarations":[-18,-18],"referencedDeclaration":-18,"src":"2201:7:120","typeDescriptions":{"typeIdentifier":"t_function_require_pure$_t_bool_$_t_string_memory_ptr_$returns$__$","typeString":"function (bool,string memory) pure"}},"id":57345,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"2201:76:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":57346,"nodeType":"ExpressionStatement","src":"2201:76:120"},{"condition":{"commonType":{"typeIdentifier":"t_bytes4","typeString":"bytes4"},"id":57351,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftExpression":{"id":57347,"name":"_sel","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57332,"src":"2291:4:120","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},"nodeType":"BinaryOperation","operator":"==","rightExpression":{"expression":{"expression":{"id":57348,"name":"this","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":-28,"src":"2299:4:120","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoInput_$57409","typeString":"contract FetchChainInfoInput"}},"id":57349,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"2304:17:120","memberName":"systemConfigProxy","nodeType":"MemberAccess","referencedDeclaration":57390,"src":"2299:22:120","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":57350,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"memberLocation":"2322:8:120","memberName":"selector","nodeType":"MemberAccess","src":"2299:31:120","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},"src":"2291:39:120","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},"falseBody":{"condition":{"commonType":{"typeIdentifier":"t_bytes4","typeString":"bytes4"},"id":57360,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftExpression":{"id":57356,"name":"_sel","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57332,"src":"2377:4:120","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},"nodeType":"BinaryOperation","operator":"==","rightExpression":{"expression":{"expression":{"id":57357,"name":"this","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":-28,"src":"2385:4:120","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoInput_$57409","typeString":"contract FetchChainInfoInput"}},"id":57358,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"2390:21:120","memberName":"l1StandardBridgeProxy","nodeType":"MemberAccess","referencedDeclaration":57408,"src":"2385:26:120","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":57359,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"memberLocation":"2412:8:120","memberName":"selector","nodeType":"MemberAccess","src":"2385:35:120","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},"src":"2377:43:120","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},"falseBody":{"expression":{"arguments":[{"hexValue":"4665746368436861696e496e666f496e7075743a20756e6b6e6f776e2073656c6563746f72","id":57366,"isConstant":false,"isLValue":false,"isPure":true,"kind":"string","lValueRequested":false,"nodeType":"Literal","src":"2474:39:120","typeDescriptions":{"typeIdentifier":"t_stringliteral_3ec062448196d68b2d186fadb5ffe52c72f0a2b929c9d178cd6e6612281f066b","typeString":"literal_string \"FetchChainInfoInput: unknown selector\""},"value":"FetchChainInfoInput: unknown selector"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_stringliteral_3ec062448196d68b2d186fadb5ffe52c72f0a2b929c9d178cd6e6612281f066b","typeString":"literal_string \"FetchChainInfoInput: unknown selector\""}],"id":57365,"name":"revert","nodeType":"Identifier","overloadedDeclarations":[-19,-19],"referencedDeclaration":-19,"src":"2467:6:120","typeDescriptions":{"typeIdentifier":"t_function_revert_pure$_t_string_memory_ptr_$returns$__$","typeString":"function (string memory) pure"}},"id":57367,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"2467:47:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":57368,"nodeType":"ExpressionStatement","src":"2467:47:120"},"id":57369,"nodeType":"IfStatement","src":"2373:141:120","trueBody":{"expression":{"id":57363,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftHandSide":{"id":57361,"name":"_l1StandardBridgeProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57330,"src":"2422:22:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"Assignment","operator":"=","rightHandSide":{"id":57362,"name":"_addr","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57334,"src":"2447:5:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"src":"2422:30:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"id":57364,"nodeType":"ExpressionStatement","src":"2422:30:120"}},"id":57370,"nodeType":"IfStatement","src":"2287:227:120","trueBody":{"expression":{"id":57354,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftHandSide":{"id":57352,"name":"_systemConfigProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57328,"src":"2332:18:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"Assignment","operator":"=","rightHandSide":{"id":57353,"name":"_addr","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57334,"src":"2353:5:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"src":"2332:26:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"id":57355,"nodeType":"ExpressionStatement","src":"2332:26:120"}}]},"functionSelector":"c3e39250","implemented":true,"kind":"function","modifiers":[],"name":"set","nameLocation":"2152:3:120","parameters":{"id":57335,"nodeType":"ParameterList","parameters":[{"constant":false,"id":57332,"mutability":"mutable","name":"_sel","nameLocation":"2163:4:120","nodeType":"VariableDeclaration","scope":57372,"src":"2156:11:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"},"typeName":{"id":57331,"name":"bytes4","nodeType":"ElementaryTypeName","src":"2156:6:120","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},"visibility":"internal"},{"constant":false,"id":57334,"mutability":"mutable","name":"_addr","nameLocation":"2177:5:120","nodeType":"VariableDeclaration","scope":57372,"src":"2169:13:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":57333,"name":"address","nodeType":"ElementaryTypeName","src":"2169:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"2155:28:120"},"returnParameters":{"id":57336,"nodeType":"ParameterList","parameters":[],"src":"2191:0:120"},"scope":57409,"stateMutability":"nonpayable","virtual":false,"visibility":"public"},{"id":57390,"nodeType":"FunctionDefinition","src":"2527:202:120","nodes":[],"body":{"id":57389,"nodeType":"Block","src":"2586:143:120","nodes":[],"statements":[{"expression":{"arguments":[{"commonType":{"typeIdentifier":"t_address","typeString":"address"},"id":57383,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftExpression":{"id":57378,"name":"_systemConfigProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57328,"src":"2604:18:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"BinaryOperation","operator":"!=","rightExpression":{"arguments":[{"hexValue":"30","id":57381,"isConstant":false,"isLValue":false,"isPure":true,"kind":"number","lValueRequested":false,"nodeType":"Literal","src":"2634:1:120","typeDescriptions":{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"},"value":"0"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"}],"id":57380,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"nodeType":"ElementaryTypeNameExpression","src":"2626:7:120","typeDescriptions":{"typeIdentifier":"t_type$_t_address_$","typeString":"type(address)"},"typeName":{"id":57379,"name":"address","nodeType":"ElementaryTypeName","src":"2626:7:120","typeDescriptions":{}}},"id":57382,"isConstant":false,"isLValue":false,"isPure":true,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"2626:10:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"src":"2604:32:120","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},{"hexValue":"4665746368436861696e496e666f496e7075743a2073797374656d436f6e66696750726f7879206e6f7420736574","id":57384,"isConstant":false,"isLValue":false,"isPure":true,"kind":"string","lValueRequested":false,"nodeType":"Literal","src":"2638:48:120","typeDescriptions":{"typeIdentifier":"t_stringliteral_cefeeda9841ab81b734a3e4f7bf39aeeab7704e02e2040531bd67ea944e4d5d3","typeString":"literal_string \"FetchChainInfoInput: systemConfigProxy not set\""},"value":"FetchChainInfoInput: systemConfigProxy not set"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_bool","typeString":"bool"},{"typeIdentifier":"t_stringliteral_cefeeda9841ab81b734a3e4f7bf39aeeab7704e02e2040531bd67ea944e4d5d3","typeString":"literal_string \"FetchChainInfoInput: systemConfigProxy not set\""}],"id":57377,"name":"require","nodeType":"Identifier","overloadedDeclarations":[-18,-18],"referencedDeclaration":-18,"src":"2596:7:120","typeDescriptions":{"typeIdentifier":"t_function_require_pure$_t_bool_$_t_string_memory_ptr_$returns$__$","typeString":"function (bool,string memory) pure"}},"id":57385,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"2596:91:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":57386,"nodeType":"ExpressionStatement","src":"2596:91:120"},{"expression":{"id":57387,"name":"_systemConfigProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57328,"src":"2704:18:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"functionReturnParameters":57376,"id":57388,"nodeType":"Return","src":"2697:25:120"}]},"functionSelector":"c17db6e3","implemented":true,"kind":"function","modifiers":[],"name":"systemConfigProxy","nameLocation":"2536:17:120","parameters":{"id":57373,"nodeType":"ParameterList","parameters":[],"src":"2553:2:120"},"returnParameters":{"id":57376,"nodeType":"ParameterList","parameters":[{"constant":false,"id":57375,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":57390,"src":"2577:7:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":57374,"name":"address","nodeType":"ElementaryTypeName","src":"2577:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"2576:9:120"},"scope":57409,"stateMutability":"view","virtual":false,"visibility":"public"},{"id":57408,"nodeType":"FunctionDefinition","src":"2735:218:120","nodes":[],"body":{"id":57407,"nodeType":"Block","src":"2798:155:120","nodes":[],"statements":[{"expression":{"arguments":[{"commonType":{"typeIdentifier":"t_address","typeString":"address"},"id":57401,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftExpression":{"id":57396,"name":"_l1StandardBridgeProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57330,"src":"2816:22:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"BinaryOperation","operator":"!=","rightExpression":{"arguments":[{"hexValue":"30","id":57399,"isConstant":false,"isLValue":false,"isPure":true,"kind":"number","lValueRequested":false,"nodeType":"Literal","src":"2850:1:120","typeDescriptions":{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"},"value":"0"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"}],"id":57398,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"nodeType":"ElementaryTypeNameExpression","src":"2842:7:120","typeDescriptions":{"typeIdentifier":"t_type$_t_address_$","typeString":"type(address)"},"typeName":{"id":57397,"name":"address","nodeType":"ElementaryTypeName","src":"2842:7:120","typeDescriptions":{}}},"id":57400,"isConstant":false,"isLValue":false,"isPure":true,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"2842:10:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"src":"2816:36:120","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},{"hexValue":"4665746368436861696e496e666f496e7075743a206c315374616e6461726442726964676550726f7879206e6f7420736574","id":57402,"isConstant":false,"isLValue":false,"isPure":true,"kind":"string","lValueRequested":false,"nodeType":"Literal","src":"2854:52:120","typeDescriptions":{"typeIdentifier":"t_stringliteral_be85b0ed3fc58e97f8b79e4d9fb1c191539515cae509acde6becd9338254d33b","typeString":"literal_string \"FetchChainInfoInput: l1StandardBridgeProxy not set\""},"value":"FetchChainInfoInput: l1StandardBridgeProxy not set"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_bool","typeString":"bool"},{"typeIdentifier":"t_stringliteral_be85b0ed3fc58e97f8b79e4d9fb1c191539515cae509acde6becd9338254d33b","typeString":"literal_string \"FetchChainInfoInput: l1StandardBridgeProxy not set\""}],"id":57395,"name":"require","nodeType":"Identifier","overloadedDeclarations":[-18,-18],"referencedDeclaration":-18,"src":"2808:7:120","typeDescriptions":{"typeIdentifier":"t_function_require_pure$_t_bool_$_t_string_memory_ptr_$returns$__$","typeString":"function (bool,string memory) pure"}},"id":57403,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"2808:99:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":57404,"nodeType":"ExpressionStatement","src":"2808:99:120"},{"expression":{"id":57405,"name":"_l1StandardBridgeProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57330,"src":"2924:22:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"functionReturnParameters":57394,"id":57406,"nodeType":"Return","src":"2917:29:120"}]},"functionSelector":"102b6069","implemented":true,"kind":"function","modifiers":[],"name":"l1StandardBridgeProxy","nameLocation":"2744:21:120","parameters":{"id":57391,"nodeType":"ParameterList","parameters":[],"src":"2765:2:120"},"returnParameters":{"id":57394,"nodeType":"ParameterList","parameters":[{"constant":false,"id":57393,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":57408,"src":"2789:7:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":57392,"name":"address","nodeType":"ElementaryTypeName","src":"2789:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"2788:9:120"},"scope":57409,"stateMutability":"view","virtual":false,"visibility":"public"}],"abstract":false,"baseContracts":[],"canonicalName":"FetchChainInfoInput","contractDependencies":[],"contractKind":"contract","fullyImplemented":true,"linearizedBaseContracts":[57409],"name":"FetchChainInfoInput","nameLocation":"2030:19:120","scope":59300,"usedErrors":[],"usedEvents":[]},{"id":58249,"nodeType":"ContractDefinition","src":"2957:10181:120","nodes":[{"id":57411,"nodeType":"VariableDeclaration","src":"3049:39:120","nodes":[],"constant":false,"mutability":"mutable","name":"_superchainConfigProxy","nameLocation":"3066:22:120","scope":58249,"stateVariable":true,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":57410,"name":"address","nodeType":"ElementaryTypeName","src":"3049:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"},{"id":57413,"nodeType":"VariableDeclaration","src":"3129:26:120","nodes":[],"constant":false,"mutability":"mutable","name":"_mipsImpl","nameLocation":"3146:9:120","scope":58249,"stateVariable":true,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":57412,"name":"address","nodeType":"ElementaryTypeName","src":"3129:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"},{"id":57415,"nodeType":"VariableDeclaration","src":"3161:36:120","nodes":[],"constant":false,"mutability":"mutable","name":"_preimageOracleImpl","nameLocation":"3178:19:120","scope":58249,"stateVariable":true,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":57414,"name":"address","nodeType":"ElementaryTypeName","src":"3161:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"},{"id":57417,"nodeType":"VariableDeclaration","src":"3230:36:120","nodes":[],"constant":false,"mutability":"mutable","name":"_addressManagerImpl","nameLocation":"3247:19:120","scope":58249,"stateVariable":true,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":57416,"name":"address","nodeType":"ElementaryTypeName","src":"3230:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"},{"id":57419,"nodeType":"VariableDeclaration","src":"3272:33:120","nodes":[],"constant":false,"mutability":"mutable","name":"_ethLockboxProxy","nameLocation":"3289:16:120","scope":58249,"stateVariable":true,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":57418,"name":"address","nodeType":"ElementaryTypeName","src":"3272:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"},{"id":57421,"nodeType":"VariableDeclaration","src":"3311:45:120","nodes":[],"constant":false,"mutability":"mutable","name":"_l1CrossDomainMessengerProxy","nameLocation":"3328:28:120","scope":58249,"stateVariable":true,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":57420,"name":"address","nodeType":"ElementaryTypeName","src":"3311:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"},{"id":57423,"nodeType":"VariableDeclaration","src":"3362:37:120","nodes":[],"constant":false,"mutability":"mutable","name":"_l1Erc721BridgeProxy","nameLocation":"3379:20:120","scope":58249,"stateVariable":true,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":57422,"name":"address","nodeType":"ElementaryTypeName","src":"3362:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"},{"id":57425,"nodeType":"VariableDeclaration","src":"3405:39:120","nodes":[],"constant":false,"mutability":"mutable","name":"_l1StandardBridgeProxy","nameLocation":"3422:22:120","scope":58249,"stateVariable":true,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":57424,"name":"address","nodeType":"ElementaryTypeName","src":"3405:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"},{"id":57427,"nodeType":"VariableDeclaration","src":"3450:37:120","nodes":[],"constant":false,"mutability":"mutable","name":"_l2OutputOracleProxy","nameLocation":"3467:20:120","scope":58249,"stateVariable":true,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":57426,"name":"address","nodeType":"ElementaryTypeName","src":"3450:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"},{"id":57429,"nodeType":"VariableDeclaration","src":"3493:51:120","nodes":[],"constant":false,"mutability":"mutable","name":"_optimismMintableErc20FactoryProxy","nameLocation":"3510:34:120","scope":58249,"stateVariable":true,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":57428,"name":"address","nodeType":"ElementaryTypeName","src":"3493:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"},{"id":57431,"nodeType":"VariableDeclaration","src":"3550:37:120","nodes":[],"constant":false,"mutability":"mutable","name":"_optimismPortalProxy","nameLocation":"3567:20:120","scope":58249,"stateVariable":true,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":57430,"name":"address","nodeType":"ElementaryTypeName","src":"3550:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"},{"id":57433,"nodeType":"VariableDeclaration","src":"3593:35:120","nodes":[],"constant":false,"mutability":"mutable","name":"_systemConfigProxy","nameLocation":"3610:18:120","scope":58249,"stateVariable":true,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":57432,"name":"address","nodeType":"ElementaryTypeName","src":"3593:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"},{"id":57435,"nodeType":"VariableDeclaration","src":"3634:39:120","nodes":[],"constant":false,"mutability":"mutable","name":"_opChainProxyAdminImpl","nameLocation":"3651:22:120","scope":58249,"stateVariable":true,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":57434,"name":"address","nodeType":"ElementaryTypeName","src":"3634:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"},{"id":57437,"nodeType":"VariableDeclaration","src":"3679:42:120","nodes":[],"constant":false,"mutability":"mutable","name":"_anchorStateRegistryProxy","nameLocation":"3696:25:120","scope":58249,"stateVariable":true,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":57436,"name":"address","nodeType":"ElementaryTypeName","src":"3679:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"},{"id":57439,"nodeType":"VariableDeclaration","src":"3727:50:120","nodes":[],"constant":false,"mutability":"mutable","name":"_delayedWethPermissionedGameProxy","nameLocation":"3744:33:120","scope":58249,"stateVariable":true,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":57438,"name":"address","nodeType":"ElementaryTypeName","src":"3727:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"},{"id":57441,"nodeType":"VariableDeclaration","src":"3783:52:120","nodes":[],"constant":false,"mutability":"mutable","name":"_delayedWethPermissionlessGameProxy","nameLocation":"3800:35:120","scope":58249,"stateVariable":true,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":57440,"name":"address","nodeType":"ElementaryTypeName","src":"3783:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"},{"id":57443,"nodeType":"VariableDeclaration","src":"3841:41:120","nodes":[],"constant":false,"mutability":"mutable","name":"_disputeGameFactoryProxy","nameLocation":"3858:24:120","scope":58249,"stateVariable":true,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":57442,"name":"address","nodeType":"ElementaryTypeName","src":"3841:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"},{"id":57445,"nodeType":"VariableDeclaration","src":"3888:38:120","nodes":[],"constant":false,"mutability":"mutable","name":"_faultDisputeGameImpl","nameLocation":"3905:21:120","scope":58249,"stateVariable":true,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":57444,"name":"address","nodeType":"ElementaryTypeName","src":"3888:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"},{"id":57447,"nodeType":"VariableDeclaration","src":"3932:45:120","nodes":[],"constant":false,"mutability":"mutable","name":"_permissionedDisputeGameImpl","nameLocation":"3949:28:120","scope":58249,"stateVariable":true,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":57446,"name":"address","nodeType":"ElementaryTypeName","src":"3932:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"},{"id":57449,"nodeType":"VariableDeclaration","src":"3997:35:120","nodes":[],"constant":false,"mutability":"mutable","name":"_systemConfigOwner","nameLocation":"4014:18:120","scope":58249,"stateVariable":true,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":57448,"name":"address","nodeType":"ElementaryTypeName","src":"3997:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"},{"id":57451,"nodeType":"VariableDeclaration","src":"4038:40:120","nodes":[],"constant":false,"mutability":"mutable","name":"_opChainProxyAdminOwner","nameLocation":"4055:23:120","scope":58249,"stateVariable":true,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":57450,"name":"address","nodeType":"ElementaryTypeName","src":"4038:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"},{"id":57453,"nodeType":"VariableDeclaration","src":"4084:33:120","nodes":[],"constant":false,"mutability":"mutable","name":"_opChainGuardian","nameLocation":"4101:16:120","scope":58249,"stateVariable":true,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":57452,"name":"address","nodeType":"ElementaryTypeName","src":"4084:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"},{"id":57455,"nodeType":"VariableDeclaration","src":"4123:28:120","nodes":[],"constant":false,"mutability":"mutable","name":"_challenger","nameLocation":"4140:11:120","scope":58249,"stateVariable":true,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":57454,"name":"address","nodeType":"ElementaryTypeName","src":"4123:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"},{"id":57457,"nodeType":"VariableDeclaration","src":"4157:26:120","nodes":[],"constant":false,"mutability":"mutable","name":"_proposer","nameLocation":"4174:9:120","scope":58249,"stateVariable":true,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":57456,"name":"address","nodeType":"ElementaryTypeName","src":"4157:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"},{"id":57459,"nodeType":"VariableDeclaration","src":"4189:35:120","nodes":[],"constant":false,"mutability":"mutable","name":"_unsafeBlockSigner","nameLocation":"4206:18:120","scope":58249,"stateVariable":true,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":57458,"name":"address","nodeType":"ElementaryTypeName","src":"4189:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"},{"id":57461,"nodeType":"VariableDeclaration","src":"4230:32:120","nodes":[],"constant":false,"mutability":"mutable","name":"_batchSubmitter","nameLocation":"4247:15:120","scope":58249,"stateVariable":true,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":57460,"name":"address","nodeType":"ElementaryTypeName","src":"4230:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"},{"id":57463,"nodeType":"VariableDeclaration","src":"4295:27:120","nodes":[],"constant":false,"mutability":"mutable","name":"_permissioned","nameLocation":"4309:13:120","scope":58249,"stateVariable":true,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"},"typeName":{"id":57462,"name":"bool","nodeType":"ElementaryTypeName","src":"4295:4:120","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},"visibility":"internal"},{"id":57465,"nodeType":"VariableDeclaration","src":"4328:29:120","nodes":[],"constant":false,"mutability":"mutable","name":"_permissionless","nameLocation":"4342:15:120","scope":58249,"stateVariable":true,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"},"typeName":{"id":57464,"name":"bool","nodeType":"ElementaryTypeName","src":"4328:4:120","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},"visibility":"internal"},{"id":57468,"nodeType":"VariableDeclaration","src":"4363:36:120","nodes":[],"constant":false,"mutability":"mutable","name":"_respectedGameType","nameLocation":"4381:18:120","scope":58249,"stateVariable":true,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_userDefinedValueType$_GameType_$75355","typeString":"GameType"},"typeName":{"id":57467,"nodeType":"UserDefinedTypeName","pathNode":{"id":57466,"name":"GameType","nameLocations":["4363:8:120"],"nodeType":"IdentifierPath","referencedDeclaration":75355,"src":"4363:8:120"},"referencedDeclaration":75355,"src":"4363:8:120","typeDescriptions":{"typeIdentifier":"t_userDefinedValueType$_GameType_$75355","typeString":"GameType"}},"visibility":"internal"},{"id":57740,"nodeType":"FunctionDefinition","src":"4406:2634:120","nodes":[],"body":{"id":57739,"nodeType":"Block","src":"4454:2586:120","nodes":[],"statements":[{"condition":{"commonType":{"typeIdentifier":"t_bytes4","typeString":"bytes4"},"id":57479,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftExpression":{"id":57475,"name":"_sel","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57470,"src":"4499:4:120","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},"nodeType":"BinaryOperation","operator":"==","rightExpression":{"expression":{"expression":{"id":57476,"name":"this","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":-28,"src":"4507:4:120","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$58249","typeString":"contract FetchChainInfoOutput"}},"id":57477,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"4512:21:120","memberName":"superchainConfigProxy","nodeType":"MemberAccess","referencedDeclaration":57983,"src":"4507:26:120","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":57478,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"memberLocation":"4534:8:120","memberName":"selector","nodeType":"MemberAccess","src":"4507:35:120","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},"src":"4499:43:120","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},"falseBody":{"condition":{"commonType":{"typeIdentifier":"t_bytes4","typeString":"bytes4"},"id":57488,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftExpression":{"id":57484,"name":"_sel","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57470,"src":"4632:4:120","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},"nodeType":"BinaryOperation","operator":"==","rightExpression":{"expression":{"expression":{"id":57485,"name":"this","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":-28,"src":"4640:4:120","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$58249","typeString":"contract FetchChainInfoOutput"}},"id":57486,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"4645:8:120","memberName":"mipsImpl","nodeType":"MemberAccess","referencedDeclaration":58061,"src":"4640:13:120","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":57487,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"memberLocation":"4654:8:120","memberName":"selector","nodeType":"MemberAccess","src":"4640:22:120","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},"src":"4632:30:120","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},"falseBody":{"condition":{"commonType":{"typeIdentifier":"t_bytes4","typeString":"bytes4"},"id":57497,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftExpression":{"id":57493,"name":"_sel","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57470,"src":"4700:4:120","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},"nodeType":"BinaryOperation","operator":"==","rightExpression":{"expression":{"expression":{"id":57494,"name":"this","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":-28,"src":"4708:4:120","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$58249","typeString":"contract FetchChainInfoOutput"}},"id":57495,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"4713:18:120","memberName":"preimageOracleImpl","nodeType":"MemberAccess","referencedDeclaration":58097,"src":"4708:23:120","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":57496,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"memberLocation":"4732:8:120","memberName":"selector","nodeType":"MemberAccess","src":"4708:32:120","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},"src":"4700:40:120","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},"falseBody":{"condition":{"commonType":{"typeIdentifier":"t_bytes4","typeString":"bytes4"},"id":57506,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftExpression":{"id":57502,"name":"_sel","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57470,"src":"4819:4:120","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},"nodeType":"BinaryOperation","operator":"==","rightExpression":{"expression":{"expression":{"id":57503,"name":"this","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":-28,"src":"4827:4:120","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$58249","typeString":"contract FetchChainInfoOutput"}},"id":57504,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"4832:18:120","memberName":"addressManagerImpl","nodeType":"MemberAccess","referencedDeclaration":57813,"src":"4827:23:120","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":57505,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"memberLocation":"4851:8:120","memberName":"selector","nodeType":"MemberAccess","src":"4827:32:120","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},"src":"4819:40:120","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},"falseBody":{"condition":{"commonType":{"typeIdentifier":"t_bytes4","typeString":"bytes4"},"id":57515,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftExpression":{"id":57511,"name":"_sel","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57470,"src":"4907:4:120","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},"nodeType":"BinaryOperation","operator":"==","rightExpression":{"expression":{"expression":{"id":57512,"name":"this","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":-28,"src":"4915:4:120","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$58249","typeString":"contract FetchChainInfoOutput"}},"id":57513,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"4920:15:120","memberName":"ethLockboxProxy","nodeType":"MemberAccess","referencedDeclaration":57821,"src":"4915:20:120","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":57514,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"memberLocation":"4936:8:120","memberName":"selector","nodeType":"MemberAccess","src":"4915:29:120","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},"src":"4907:37:120","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},"falseBody":{"condition":{"commonType":{"typeIdentifier":"t_bytes4","typeString":"bytes4"},"id":57524,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftExpression":{"id":57520,"name":"_sel","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57470,"src":"4989:4:120","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},"nodeType":"BinaryOperation","operator":"==","rightExpression":{"expression":{"expression":{"id":57521,"name":"this","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":-28,"src":"4997:4:120","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$58249","typeString":"contract FetchChainInfoOutput"}},"id":57522,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"5002:27:120","memberName":"l1CrossDomainMessengerProxy","nodeType":"MemberAccess","referencedDeclaration":57839,"src":"4997:32:120","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":57523,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"memberLocation":"5030:8:120","memberName":"selector","nodeType":"MemberAccess","src":"4997:41:120","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},"src":"4989:49:120","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},"falseBody":{"condition":{"commonType":{"typeIdentifier":"t_bytes4","typeString":"bytes4"},"id":57533,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftExpression":{"id":57529,"name":"_sel","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57470,"src":"5095:4:120","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},"nodeType":"BinaryOperation","operator":"==","rightExpression":{"expression":{"expression":{"id":57530,"name":"this","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":-28,"src":"5103:4:120","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$58249","typeString":"contract FetchChainInfoOutput"}},"id":57531,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"5108:19:120","memberName":"l1Erc721BridgeProxy","nodeType":"MemberAccess","referencedDeclaration":57857,"src":"5103:24:120","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":57532,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"memberLocation":"5128:8:120","memberName":"selector","nodeType":"MemberAccess","src":"5103:33:120","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},"src":"5095:41:120","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},"falseBody":{"condition":{"commonType":{"typeIdentifier":"t_bytes4","typeString":"bytes4"},"id":57542,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftExpression":{"id":57538,"name":"_sel","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57470,"src":"5185:4:120","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},"nodeType":"BinaryOperation","operator":"==","rightExpression":{"expression":{"expression":{"id":57539,"name":"this","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":-28,"src":"5193:4:120","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$58249","typeString":"contract FetchChainInfoOutput"}},"id":57540,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"5198:21:120","memberName":"l1StandardBridgeProxy","nodeType":"MemberAccess","referencedDeclaration":57875,"src":"5193:26:120","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":57541,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"memberLocation":"5220:8:120","memberName":"selector","nodeType":"MemberAccess","src":"5193:35:120","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},"src":"5185:43:120","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},"falseBody":{"condition":{"commonType":{"typeIdentifier":"t_bytes4","typeString":"bytes4"},"id":57551,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftExpression":{"id":57547,"name":"_sel","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57470,"src":"5279:4:120","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},"nodeType":"BinaryOperation","operator":"==","rightExpression":{"expression":{"expression":{"id":57548,"name":"this","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":-28,"src":"5287:4:120","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$58249","typeString":"contract FetchChainInfoOutput"}},"id":57549,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"5292:19:120","memberName":"l2OutputOracleProxy","nodeType":"MemberAccess","referencedDeclaration":57893,"src":"5287:24:120","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":57550,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"memberLocation":"5312:8:120","memberName":"selector","nodeType":"MemberAccess","src":"5287:33:120","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},"src":"5279:41:120","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},"falseBody":{"condition":{"commonType":{"typeIdentifier":"t_bytes4","typeString":"bytes4"},"id":57560,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftExpression":{"id":57556,"name":"_sel","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57470,"src":"5369:4:120","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},"nodeType":"BinaryOperation","operator":"==","rightExpression":{"expression":{"expression":{"id":57557,"name":"this","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":-28,"src":"5377:4:120","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$58249","typeString":"contract FetchChainInfoOutput"}},"id":57558,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"5382:33:120","memberName":"optimismMintableErc20FactoryProxy","nodeType":"MemberAccess","referencedDeclaration":57911,"src":"5377:38:120","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":57559,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"memberLocation":"5416:8:120","memberName":"selector","nodeType":"MemberAccess","src":"5377:47:120","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},"src":"5369:55:120","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},"falseBody":{"condition":{"commonType":{"typeIdentifier":"t_bytes4","typeString":"bytes4"},"id":57569,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftExpression":{"id":57565,"name":"_sel","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57470,"src":"5487:4:120","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},"nodeType":"BinaryOperation","operator":"==","rightExpression":{"expression":{"expression":{"id":57566,"name":"this","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":-28,"src":"5495:4:120","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$58249","typeString":"contract FetchChainInfoOutput"}},"id":57567,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"5500:19:120","memberName":"optimismPortalProxy","nodeType":"MemberAccess","referencedDeclaration":57929,"src":"5495:24:120","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":57568,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"memberLocation":"5520:8:120","memberName":"selector","nodeType":"MemberAccess","src":"5495:33:120","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},"src":"5487:41:120","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},"falseBody":{"condition":{"commonType":{"typeIdentifier":"t_bytes4","typeString":"bytes4"},"id":57578,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftExpression":{"id":57574,"name":"_sel","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57470,"src":"5577:4:120","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},"nodeType":"BinaryOperation","operator":"==","rightExpression":{"expression":{"expression":{"id":57575,"name":"this","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":-28,"src":"5585:4:120","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$58249","typeString":"contract FetchChainInfoOutput"}},"id":57576,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"5590:17:120","memberName":"systemConfigProxy","nodeType":"MemberAccess","referencedDeclaration":57947,"src":"5585:22:120","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":57577,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"memberLocation":"5608:8:120","memberName":"selector","nodeType":"MemberAccess","src":"5585:31:120","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},"src":"5577:39:120","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},"falseBody":{"condition":{"commonType":{"typeIdentifier":"t_bytes4","typeString":"bytes4"},"id":57587,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftExpression":{"id":57583,"name":"_sel","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57470,"src":"5663:4:120","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},"nodeType":"BinaryOperation","operator":"==","rightExpression":{"expression":{"expression":{"id":57584,"name":"this","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":-28,"src":"5671:4:120","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$58249","typeString":"contract FetchChainInfoOutput"}},"id":57585,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"5676:21:120","memberName":"opChainProxyAdminImpl","nodeType":"MemberAccess","referencedDeclaration":57965,"src":"5671:26:120","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":57586,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"memberLocation":"5698:8:120","memberName":"selector","nodeType":"MemberAccess","src":"5671:35:120","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},"src":"5663:43:120","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},"falseBody":{"condition":{"commonType":{"typeIdentifier":"t_bytes4","typeString":"bytes4"},"id":57596,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftExpression":{"id":57592,"name":"_sel","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57470,"src":"5757:4:120","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},"nodeType":"BinaryOperation","operator":"==","rightExpression":{"expression":{"expression":{"id":57593,"name":"this","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":-28,"src":"5765:4:120","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$58249","typeString":"contract FetchChainInfoOutput"}},"id":57594,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"5770:24:120","memberName":"anchorStateRegistryProxy","nodeType":"MemberAccess","referencedDeclaration":58001,"src":"5765:29:120","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":57595,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"memberLocation":"5795:8:120","memberName":"selector","nodeType":"MemberAccess","src":"5765:38:120","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},"src":"5757:46:120","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},"falseBody":{"condition":{"commonType":{"typeIdentifier":"t_bytes4","typeString":"bytes4"},"id":57605,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftExpression":{"id":57601,"name":"_sel","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57470,"src":"5857:4:120","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},"nodeType":"BinaryOperation","operator":"==","rightExpression":{"expression":{"expression":{"id":57602,"name":"this","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":-28,"src":"5865:4:120","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$58249","typeString":"contract FetchChainInfoOutput"}},"id":57603,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"5870:32:120","memberName":"delayedWethPermissionedGameProxy","nodeType":"MemberAccess","referencedDeclaration":58009,"src":"5865:37:120","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":57604,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"memberLocation":"5903:8:120","memberName":"selector","nodeType":"MemberAccess","src":"5865:46:120","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},"src":"5857:54:120","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},"falseBody":{"condition":{"commonType":{"typeIdentifier":"t_bytes4","typeString":"bytes4"},"id":57614,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftExpression":{"id":57610,"name":"_sel","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57470,"src":"5973:4:120","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},"nodeType":"BinaryOperation","operator":"==","rightExpression":{"expression":{"expression":{"id":57611,"name":"this","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":-28,"src":"5981:4:120","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$58249","typeString":"contract FetchChainInfoOutput"}},"id":57612,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"5986:34:120","memberName":"delayedWethPermissionlessGameProxy","nodeType":"MemberAccess","referencedDeclaration":58017,"src":"5981:39:120","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":57613,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"memberLocation":"6021:8:120","memberName":"selector","nodeType":"MemberAccess","src":"5981:48:120","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},"src":"5973:56:120","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},"falseBody":{"condition":{"commonType":{"typeIdentifier":"t_bytes4","typeString":"bytes4"},"id":57623,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftExpression":{"id":57619,"name":"_sel","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57470,"src":"6093:4:120","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},"nodeType":"BinaryOperation","operator":"==","rightExpression":{"expression":{"expression":{"id":57620,"name":"this","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":-28,"src":"6101:4:120","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$58249","typeString":"contract FetchChainInfoOutput"}},"id":57621,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"6106:23:120","memberName":"disputeGameFactoryProxy","nodeType":"MemberAccess","referencedDeclaration":58025,"src":"6101:28:120","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":57622,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"memberLocation":"6130:8:120","memberName":"selector","nodeType":"MemberAccess","src":"6101:37:120","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},"src":"6093:45:120","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},"falseBody":{"condition":{"commonType":{"typeIdentifier":"t_bytes4","typeString":"bytes4"},"id":57632,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftExpression":{"id":57628,"name":"_sel","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57470,"src":"6191:4:120","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},"nodeType":"BinaryOperation","operator":"==","rightExpression":{"expression":{"expression":{"id":57629,"name":"this","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":-28,"src":"6199:4:120","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$58249","typeString":"contract FetchChainInfoOutput"}},"id":57630,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"6204:20:120","memberName":"faultDisputeGameImpl","nodeType":"MemberAccess","referencedDeclaration":58043,"src":"6199:25:120","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":57631,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"memberLocation":"6225:8:120","memberName":"selector","nodeType":"MemberAccess","src":"6199:34:120","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},"src":"6191:42:120","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},"falseBody":{"condition":{"commonType":{"typeIdentifier":"t_bytes4","typeString":"bytes4"},"id":57641,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftExpression":{"id":57637,"name":"_sel","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57470,"src":"6283:4:120","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},"nodeType":"BinaryOperation","operator":"==","rightExpression":{"expression":{"expression":{"id":57638,"name":"this","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":-28,"src":"6291:4:120","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$58249","typeString":"contract FetchChainInfoOutput"}},"id":57639,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"6296:27:120","memberName":"permissionedDisputeGameImpl","nodeType":"MemberAccess","referencedDeclaration":58079,"src":"6291:32:120","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":57640,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"memberLocation":"6324:8:120","memberName":"selector","nodeType":"MemberAccess","src":"6291:41:120","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},"src":"6283:49:120","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},"falseBody":{"condition":{"commonType":{"typeIdentifier":"t_bytes4","typeString":"bytes4"},"id":57650,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftExpression":{"id":57646,"name":"_sel","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57470,"src":"6406:4:120","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},"nodeType":"BinaryOperation","operator":"==","rightExpression":{"expression":{"expression":{"id":57647,"name":"this","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":-28,"src":"6414:4:120","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$58249","typeString":"contract FetchChainInfoOutput"}},"id":57648,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"6419:17:120","memberName":"systemConfigOwner","nodeType":"MemberAccess","referencedDeclaration":58115,"src":"6414:22:120","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":57649,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"memberLocation":"6437:8:120","memberName":"selector","nodeType":"MemberAccess","src":"6414:31:120","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},"src":"6406:39:120","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},"falseBody":{"condition":{"commonType":{"typeIdentifier":"t_bytes4","typeString":"bytes4"},"id":57659,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftExpression":{"id":57655,"name":"_sel","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57470,"src":"6492:4:120","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},"nodeType":"BinaryOperation","operator":"==","rightExpression":{"expression":{"expression":{"id":57656,"name":"this","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":-28,"src":"6500:4:120","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$58249","typeString":"contract FetchChainInfoOutput"}},"id":57657,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"6505:22:120","memberName":"opChainProxyAdminOwner","nodeType":"MemberAccess","referencedDeclaration":58133,"src":"6500:27:120","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":57658,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"memberLocation":"6528:8:120","memberName":"selector","nodeType":"MemberAccess","src":"6500:36:120","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},"src":"6492:44:120","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},"falseBody":{"condition":{"commonType":{"typeIdentifier":"t_bytes4","typeString":"bytes4"},"id":57668,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftExpression":{"id":57664,"name":"_sel","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57470,"src":"6588:4:120","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},"nodeType":"BinaryOperation","operator":"==","rightExpression":{"expression":{"expression":{"id":57665,"name":"this","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":-28,"src":"6596:4:120","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$58249","typeString":"contract FetchChainInfoOutput"}},"id":57666,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"6601:15:120","memberName":"opChainGuardian","nodeType":"MemberAccess","referencedDeclaration":58151,"src":"6596:20:120","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":57667,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"memberLocation":"6617:8:120","memberName":"selector","nodeType":"MemberAccess","src":"6596:29:120","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},"src":"6588:37:120","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},"falseBody":{"condition":{"commonType":{"typeIdentifier":"t_bytes4","typeString":"bytes4"},"id":57677,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftExpression":{"id":57673,"name":"_sel","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57470,"src":"6670:4:120","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},"nodeType":"BinaryOperation","operator":"==","rightExpression":{"expression":{"expression":{"id":57674,"name":"this","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":-28,"src":"6678:4:120","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$58249","typeString":"contract FetchChainInfoOutput"}},"id":57675,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"6683:10:120","memberName":"challenger","nodeType":"MemberAccess","referencedDeclaration":58169,"src":"6678:15:120","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":57676,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"memberLocation":"6694:8:120","memberName":"selector","nodeType":"MemberAccess","src":"6678:24:120","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},"src":"6670:32:120","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},"falseBody":{"condition":{"commonType":{"typeIdentifier":"t_bytes4","typeString":"bytes4"},"id":57686,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftExpression":{"id":57682,"name":"_sel","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57470,"src":"6742:4:120","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},"nodeType":"BinaryOperation","operator":"==","rightExpression":{"expression":{"expression":{"id":57683,"name":"this","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":-28,"src":"6750:4:120","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$58249","typeString":"contract FetchChainInfoOutput"}},"id":57684,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"6755:8:120","memberName":"proposer","nodeType":"MemberAccess","referencedDeclaration":58187,"src":"6750:13:120","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":57685,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"memberLocation":"6764:8:120","memberName":"selector","nodeType":"MemberAccess","src":"6750:22:120","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},"src":"6742:30:120","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},"falseBody":{"condition":{"commonType":{"typeIdentifier":"t_bytes4","typeString":"bytes4"},"id":57695,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftExpression":{"id":57691,"name":"_sel","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57470,"src":"6810:4:120","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},"nodeType":"BinaryOperation","operator":"==","rightExpression":{"expression":{"expression":{"id":57692,"name":"this","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":-28,"src":"6818:4:120","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$58249","typeString":"contract FetchChainInfoOutput"}},"id":57693,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"6823:17:120","memberName":"unsafeBlockSigner","nodeType":"MemberAccess","referencedDeclaration":58205,"src":"6818:22:120","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":57694,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"memberLocation":"6841:8:120","memberName":"selector","nodeType":"MemberAccess","src":"6818:31:120","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},"src":"6810:39:120","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},"falseBody":{"condition":{"commonType":{"typeIdentifier":"t_bytes4","typeString":"bytes4"},"id":57704,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftExpression":{"id":57700,"name":"_sel","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57470,"src":"6896:4:120","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},"nodeType":"BinaryOperation","operator":"==","rightExpression":{"expression":{"expression":{"id":57701,"name":"this","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":-28,"src":"6904:4:120","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$58249","typeString":"contract FetchChainInfoOutput"}},"id":57702,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"6909:14:120","memberName":"batchSubmitter","nodeType":"MemberAccess","referencedDeclaration":58223,"src":"6904:19:120","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":57703,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"memberLocation":"6924:8:120","memberName":"selector","nodeType":"MemberAccess","src":"6904:28:120","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},"src":"6896:36:120","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},"falseBody":{"expression":{"arguments":[{"hexValue":"4665746368436861696e496e666f4f75747075743a20756e6b6e6f776e20616464726573732073656c6563746f722074657374","id":57710,"isConstant":false,"isLValue":false,"isPure":true,"kind":"string","lValueRequested":false,"nodeType":"Literal","src":"6979:53:120","typeDescriptions":{"typeIdentifier":"t_stringliteral_8be6a92cba5443877e2b6bededc383e178c3f2718dce3f3864f1721c31f5c065","typeString":"literal_string \"FetchChainInfoOutput: unknown address selector test\""},"value":"FetchChainInfoOutput: unknown address selector test"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_stringliteral_8be6a92cba5443877e2b6bededc383e178c3f2718dce3f3864f1721c31f5c065","typeString":"literal_string \"FetchChainInfoOutput: unknown address selector test\""}],"id":57709,"name":"revert","nodeType":"Identifier","overloadedDeclarations":[-19,-19],"referencedDeclaration":-19,"src":"6972:6:120","typeDescriptions":{"typeIdentifier":"t_function_revert_pure$_t_string_memory_ptr_$returns$__$","typeString":"function (string memory) pure"}},"id":57711,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"6972:61:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":57712,"nodeType":"ExpressionStatement","src":"6972:61:120"},"id":57713,"nodeType":"IfStatement","src":"6892:141:120","trueBody":{"expression":{"id":57707,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftHandSide":{"id":57705,"name":"_batchSubmitter","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57461,"src":"6934:15:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"Assignment","operator":"=","rightHandSide":{"id":57706,"name":"_addr","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57472,"src":"6952:5:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"src":"6934:23:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"id":57708,"nodeType":"ExpressionStatement","src":"6934:23:120"}},"id":57714,"nodeType":"IfStatement","src":"6806:227:120","trueBody":{"expression":{"id":57698,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftHandSide":{"id":57696,"name":"_unsafeBlockSigner","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57459,"src":"6851:18:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"Assignment","operator":"=","rightHandSide":{"id":57697,"name":"_addr","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57472,"src":"6872:5:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"src":"6851:26:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"id":57699,"nodeType":"ExpressionStatement","src":"6851:26:120"}},"id":57715,"nodeType":"IfStatement","src":"6738:295:120","trueBody":{"expression":{"id":57689,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftHandSide":{"id":57687,"name":"_proposer","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57457,"src":"6774:9:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"Assignment","operator":"=","rightHandSide":{"id":57688,"name":"_addr","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57472,"src":"6786:5:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"src":"6774:17:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"id":57690,"nodeType":"ExpressionStatement","src":"6774:17:120"}},"id":57716,"nodeType":"IfStatement","src":"6666:367:120","trueBody":{"expression":{"id":57680,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftHandSide":{"id":57678,"name":"_challenger","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57455,"src":"6704:11:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"Assignment","operator":"=","rightHandSide":{"id":57679,"name":"_addr","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57472,"src":"6718:5:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"src":"6704:19:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"id":57681,"nodeType":"ExpressionStatement","src":"6704:19:120"}},"id":57717,"nodeType":"IfStatement","src":"6584:449:120","trueBody":{"expression":{"id":57671,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftHandSide":{"id":57669,"name":"_opChainGuardian","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57453,"src":"6627:16:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"Assignment","operator":"=","rightHandSide":{"id":57670,"name":"_addr","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57472,"src":"6646:5:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"src":"6627:24:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"id":57672,"nodeType":"ExpressionStatement","src":"6627:24:120"}},"id":57718,"nodeType":"IfStatement","src":"6488:545:120","trueBody":{"expression":{"id":57662,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftHandSide":{"id":57660,"name":"_opChainProxyAdminOwner","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57451,"src":"6538:23:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"Assignment","operator":"=","rightHandSide":{"id":57661,"name":"_addr","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57472,"src":"6564:5:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"src":"6538:31:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"id":57663,"nodeType":"ExpressionStatement","src":"6538:31:120"}},"id":57719,"nodeType":"IfStatement","src":"6402:631:120","trueBody":{"expression":{"id":57653,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftHandSide":{"id":57651,"name":"_systemConfigOwner","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57449,"src":"6447:18:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"Assignment","operator":"=","rightHandSide":{"id":57652,"name":"_addr","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57472,"src":"6468:5:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"src":"6447:26:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"id":57654,"nodeType":"ExpressionStatement","src":"6447:26:120"}},"id":57720,"nodeType":"IfStatement","src":"6279:754:120","trueBody":{"expression":{"id":57644,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftHandSide":{"id":57642,"name":"_permissionedDisputeGameImpl","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57447,"src":"6334:28:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"Assignment","operator":"=","rightHandSide":{"id":57643,"name":"_addr","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57472,"src":"6365:5:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"src":"6334:36:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"id":57645,"nodeType":"ExpressionStatement","src":"6334:36:120"}},"id":57721,"nodeType":"IfStatement","src":"6187:846:120","trueBody":{"expression":{"id":57635,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftHandSide":{"id":57633,"name":"_faultDisputeGameImpl","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57445,"src":"6235:21:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"Assignment","operator":"=","rightHandSide":{"id":57634,"name":"_addr","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57472,"src":"6259:5:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"src":"6235:29:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"id":57636,"nodeType":"ExpressionStatement","src":"6235:29:120"}},"id":57722,"nodeType":"IfStatement","src":"6089:944:120","trueBody":{"expression":{"id":57626,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftHandSide":{"id":57624,"name":"_disputeGameFactoryProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57443,"src":"6140:24:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"Assignment","operator":"=","rightHandSide":{"id":57625,"name":"_addr","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57472,"src":"6167:5:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"src":"6140:32:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"id":57627,"nodeType":"ExpressionStatement","src":"6140:32:120"}},"id":57723,"nodeType":"IfStatement","src":"5969:1064:120","trueBody":{"expression":{"id":57617,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftHandSide":{"id":57615,"name":"_delayedWethPermissionlessGameProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57441,"src":"6031:35:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"Assignment","operator":"=","rightHandSide":{"id":57616,"name":"_addr","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57472,"src":"6069:5:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"src":"6031:43:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"id":57618,"nodeType":"ExpressionStatement","src":"6031:43:120"}},"id":57724,"nodeType":"IfStatement","src":"5853:1180:120","trueBody":{"expression":{"id":57608,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftHandSide":{"id":57606,"name":"_delayedWethPermissionedGameProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57439,"src":"5913:33:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"Assignment","operator":"=","rightHandSide":{"id":57607,"name":"_addr","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57472,"src":"5949:5:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"src":"5913:41:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"id":57609,"nodeType":"ExpressionStatement","src":"5913:41:120"}},"id":57725,"nodeType":"IfStatement","src":"5753:1280:120","trueBody":{"expression":{"id":57599,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftHandSide":{"id":57597,"name":"_anchorStateRegistryProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57437,"src":"5805:25:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"Assignment","operator":"=","rightHandSide":{"id":57598,"name":"_addr","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57472,"src":"5833:5:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"src":"5805:33:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"id":57600,"nodeType":"ExpressionStatement","src":"5805:33:120"}},"id":57726,"nodeType":"IfStatement","src":"5659:1374:120","trueBody":{"expression":{"id":57590,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftHandSide":{"id":57588,"name":"_opChainProxyAdminImpl","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57435,"src":"5708:22:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"Assignment","operator":"=","rightHandSide":{"id":57589,"name":"_addr","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57472,"src":"5733:5:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"src":"5708:30:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"id":57591,"nodeType":"ExpressionStatement","src":"5708:30:120"}},"id":57727,"nodeType":"IfStatement","src":"5573:1460:120","trueBody":{"expression":{"id":57581,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftHandSide":{"id":57579,"name":"_systemConfigProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57433,"src":"5618:18:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"Assignment","operator":"=","rightHandSide":{"id":57580,"name":"_addr","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57472,"src":"5639:5:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"src":"5618:26:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"id":57582,"nodeType":"ExpressionStatement","src":"5618:26:120"}},"id":57728,"nodeType":"IfStatement","src":"5483:1550:120","trueBody":{"expression":{"id":57572,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftHandSide":{"id":57570,"name":"_optimismPortalProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57431,"src":"5530:20:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"Assignment","operator":"=","rightHandSide":{"id":57571,"name":"_addr","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57472,"src":"5553:5:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"src":"5530:28:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"id":57573,"nodeType":"ExpressionStatement","src":"5530:28:120"}},"id":57729,"nodeType":"IfStatement","src":"5365:1668:120","trueBody":{"expression":{"id":57563,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftHandSide":{"id":57561,"name":"_optimismMintableErc20FactoryProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57429,"src":"5426:34:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"Assignment","operator":"=","rightHandSide":{"id":57562,"name":"_addr","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57472,"src":"5463:5:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"src":"5426:42:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"id":57564,"nodeType":"ExpressionStatement","src":"5426:42:120"}},"id":57730,"nodeType":"IfStatement","src":"5275:1758:120","trueBody":{"expression":{"id":57554,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftHandSide":{"id":57552,"name":"_l2OutputOracleProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57427,"src":"5322:20:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"Assignment","operator":"=","rightHandSide":{"id":57553,"name":"_addr","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57472,"src":"5345:5:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"src":"5322:28:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"id":57555,"nodeType":"ExpressionStatement","src":"5322:28:120"}},"id":57731,"nodeType":"IfStatement","src":"5181:1852:120","trueBody":{"expression":{"id":57545,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftHandSide":{"id":57543,"name":"_l1StandardBridgeProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57425,"src":"5230:22:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"Assignment","operator":"=","rightHandSide":{"id":57544,"name":"_addr","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57472,"src":"5255:5:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"src":"5230:30:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"id":57546,"nodeType":"ExpressionStatement","src":"5230:30:120"}},"id":57732,"nodeType":"IfStatement","src":"5091:1942:120","trueBody":{"expression":{"id":57536,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftHandSide":{"id":57534,"name":"_l1Erc721BridgeProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57423,"src":"5138:20:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"Assignment","operator":"=","rightHandSide":{"id":57535,"name":"_addr","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57472,"src":"5161:5:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"src":"5138:28:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"id":57537,"nodeType":"ExpressionStatement","src":"5138:28:120"}},"id":57733,"nodeType":"IfStatement","src":"4985:2048:120","trueBody":{"expression":{"id":57527,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftHandSide":{"id":57525,"name":"_l1CrossDomainMessengerProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57421,"src":"5040:28:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"Assignment","operator":"=","rightHandSide":{"id":57526,"name":"_addr","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57472,"src":"5071:5:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"src":"5040:36:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"id":57528,"nodeType":"ExpressionStatement","src":"5040:36:120"}},"id":57734,"nodeType":"IfStatement","src":"4903:2130:120","trueBody":{"expression":{"id":57518,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftHandSide":{"id":57516,"name":"_ethLockboxProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57419,"src":"4946:16:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"Assignment","operator":"=","rightHandSide":{"id":57517,"name":"_addr","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57472,"src":"4965:5:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"src":"4946:24:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"id":57519,"nodeType":"ExpressionStatement","src":"4946:24:120"}},"id":57735,"nodeType":"IfStatement","src":"4815:2218:120","trueBody":{"expression":{"id":57509,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftHandSide":{"id":57507,"name":"_addressManagerImpl","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57417,"src":"4861:19:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"Assignment","operator":"=","rightHandSide":{"id":57508,"name":"_addr","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57472,"src":"4883:5:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"src":"4861:27:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"id":57510,"nodeType":"ExpressionStatement","src":"4861:27:120"}},"id":57736,"nodeType":"IfStatement","src":"4696:2337:120","trueBody":{"expression":{"id":57500,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftHandSide":{"id":57498,"name":"_preimageOracleImpl","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57415,"src":"4742:19:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"Assignment","operator":"=","rightHandSide":{"id":57499,"name":"_addr","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57472,"src":"4764:5:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"src":"4742:27:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"id":57501,"nodeType":"ExpressionStatement","src":"4742:27:120"}},"id":57737,"nodeType":"IfStatement","src":"4628:2405:120","trueBody":{"expression":{"id":57491,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftHandSide":{"id":57489,"name":"_mipsImpl","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57413,"src":"4664:9:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"Assignment","operator":"=","rightHandSide":{"id":57490,"name":"_addr","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57472,"src":"4676:5:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"src":"4664:17:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"id":57492,"nodeType":"ExpressionStatement","src":"4664:17:120"}},"id":57738,"nodeType":"IfStatement","src":"4495:2538:120","trueBody":{"expression":{"id":57482,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftHandSide":{"id":57480,"name":"_superchainConfigProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57411,"src":"4544:22:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"Assignment","operator":"=","rightHandSide":{"id":57481,"name":"_addr","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57472,"src":"4569:5:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"src":"4544:30:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"id":57483,"nodeType":"ExpressionStatement","src":"4544:30:120"}}]},"functionSelector":"c3e39250","implemented":true,"kind":"function","modifiers":[],"name":"set","nameLocation":"4415:3:120","parameters":{"id":57473,"nodeType":"ParameterList","parameters":[{"constant":false,"id":57470,"mutability":"mutable","name":"_sel","nameLocation":"4426:4:120","nodeType":"VariableDeclaration","scope":57740,"src":"4419:11:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"},"typeName":{"id":57469,"name":"bytes4","nodeType":"ElementaryTypeName","src":"4419:6:120","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},"visibility":"internal"},{"constant":false,"id":57472,"mutability":"mutable","name":"_addr","nameLocation":"4440:5:120","nodeType":"VariableDeclaration","scope":57740,"src":"4432:13:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":57471,"name":"address","nodeType":"ElementaryTypeName","src":"4432:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"4418:28:120"},"returnParameters":{"id":57474,"nodeType":"ParameterList","parameters":[],"src":"4454:0:120"},"scope":58249,"stateMutability":"nonpayable","virtual":false,"visibility":"public"},{"id":57772,"nodeType":"FunctionDefinition","src":"7046:271:120","nodes":[],"body":{"id":57771,"nodeType":"Block","src":"7091:226:120","nodes":[],"statements":[{"condition":{"commonType":{"typeIdentifier":"t_bytes4","typeString":"bytes4"},"id":57751,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftExpression":{"id":57747,"name":"_sel","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57742,"src":"7105:4:120","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},"nodeType":"BinaryOperation","operator":"==","rightExpression":{"expression":{"expression":{"id":57748,"name":"this","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":-28,"src":"7113:4:120","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$58249","typeString":"contract FetchChainInfoOutput"}},"id":57749,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"7118:12:120","memberName":"permissioned","nodeType":"MemberAccess","referencedDeclaration":58231,"src":"7113:17:120","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_bool_$","typeString":"function () view external returns (bool)"}},"id":57750,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"memberLocation":"7131:8:120","memberName":"selector","nodeType":"MemberAccess","src":"7113:26:120","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},"src":"7105:34:120","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},"falseBody":{"condition":{"commonType":{"typeIdentifier":"t_bytes4","typeString":"bytes4"},"id":57760,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftExpression":{"id":57756,"name":"_sel","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57742,"src":"7181:4:120","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},"nodeType":"BinaryOperation","operator":"==","rightExpression":{"expression":{"expression":{"id":57757,"name":"this","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":-28,"src":"7189:4:120","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$58249","typeString":"contract FetchChainInfoOutput"}},"id":57758,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"7194:14:120","memberName":"permissionless","nodeType":"MemberAccess","referencedDeclaration":58239,"src":"7189:19:120","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_bool_$","typeString":"function () view external returns (bool)"}},"id":57759,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"memberLocation":"7209:8:120","memberName":"selector","nodeType":"MemberAccess","src":"7189:28:120","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},"src":"7181:36:120","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},"falseBody":{"expression":{"arguments":[{"hexValue":"4665746368436861696e496e666f4f75747075743a20756e6b6e6f776e20626f6f6c2073656c6563746f72","id":57766,"isConstant":false,"isLValue":false,"isPure":true,"kind":"string","lValueRequested":false,"nodeType":"Literal","src":"7264:45:120","typeDescriptions":{"typeIdentifier":"t_stringliteral_b43e73201a672ac9d292be9f8dc7215ba0fae6d34ae76c7f77ffd9b31af48fae","typeString":"literal_string \"FetchChainInfoOutput: unknown bool selector\""},"value":"FetchChainInfoOutput: unknown bool selector"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_stringliteral_b43e73201a672ac9d292be9f8dc7215ba0fae6d34ae76c7f77ffd9b31af48fae","typeString":"literal_string \"FetchChainInfoOutput: unknown bool selector\""}],"id":57765,"name":"revert","nodeType":"Identifier","overloadedDeclarations":[-19,-19],"referencedDeclaration":-19,"src":"7257:6:120","typeDescriptions":{"typeIdentifier":"t_function_revert_pure$_t_string_memory_ptr_$returns$__$","typeString":"function (string memory) pure"}},"id":57767,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"7257:53:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":57768,"nodeType":"ExpressionStatement","src":"7257:53:120"},"id":57769,"nodeType":"IfStatement","src":"7177:133:120","trueBody":{"expression":{"id":57763,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftHandSide":{"id":57761,"name":"_permissionless","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57465,"src":"7219:15:120","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},"nodeType":"Assignment","operator":"=","rightHandSide":{"id":57762,"name":"_bool","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57744,"src":"7237:5:120","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},"src":"7219:23:120","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},"id":57764,"nodeType":"ExpressionStatement","src":"7219:23:120"}},"id":57770,"nodeType":"IfStatement","src":"7101:209:120","trueBody":{"expression":{"id":57754,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftHandSide":{"id":57752,"name":"_permissioned","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57463,"src":"7141:13:120","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},"nodeType":"Assignment","operator":"=","rightHandSide":{"id":57753,"name":"_bool","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57744,"src":"7157:5:120","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},"src":"7141:21:120","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},"id":57755,"nodeType":"ExpressionStatement","src":"7141:21:120"}}]},"functionSelector":"baa1e15e","implemented":true,"kind":"function","modifiers":[],"name":"set","nameLocation":"7055:3:120","parameters":{"id":57745,"nodeType":"ParameterList","parameters":[{"constant":false,"id":57742,"mutability":"mutable","name":"_sel","nameLocation":"7066:4:120","nodeType":"VariableDeclaration","scope":57772,"src":"7059:11:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"},"typeName":{"id":57741,"name":"bytes4","nodeType":"ElementaryTypeName","src":"7059:6:120","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},"visibility":"internal"},{"constant":false,"id":57744,"mutability":"mutable","name":"_bool","nameLocation":"7077:5:120","nodeType":"VariableDeclaration","scope":57772,"src":"7072:10:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"},"typeName":{"id":57743,"name":"bool","nodeType":"ElementaryTypeName","src":"7072:4:120","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},"visibility":"internal"}],"src":"7058:25:120"},"returnParameters":{"id":57746,"nodeType":"ParameterList","parameters":[],"src":"7091:0:120"},"scope":58249,"stateMutability":"nonpayable","virtual":false,"visibility":"public"},{"id":57795,"nodeType":"FunctionDefinition","src":"7323:217:120","nodes":[],"body":{"id":57794,"nodeType":"Block","src":"7376:164:120","nodes":[],"statements":[{"condition":{"commonType":{"typeIdentifier":"t_bytes4","typeString":"bytes4"},"id":57784,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftExpression":{"id":57780,"name":"_sel","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57774,"src":"7390:4:120","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},"nodeType":"BinaryOperation","operator":"==","rightExpression":{"expression":{"expression":{"id":57781,"name":"this","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":-28,"src":"7398:4:120","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$58249","typeString":"contract FetchChainInfoOutput"}},"id":57782,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"7403:17:120","memberName":"respectedGameType","nodeType":"MemberAccess","referencedDeclaration":58248,"src":"7398:22:120","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_userDefinedValueType$_GameType_$75355_$","typeString":"function () view external returns (GameType)"}},"id":57783,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"memberLocation":"7421:8:120","memberName":"selector","nodeType":"MemberAccess","src":"7398:31:120","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},"src":"7390:39:120","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},"falseBody":{"expression":{"arguments":[{"hexValue":"4665746368436861696e496e666f4f75747075743a20756e6b6e6f776e2047616d65547970652073656c6563746f72","id":57790,"isConstant":false,"isLValue":false,"isPure":true,"kind":"string","lValueRequested":false,"nodeType":"Literal","src":"7483:49:120","typeDescriptions":{"typeIdentifier":"t_stringliteral_520d3d0cced140fee76c803f92d1db783b790e13f72de1e8f8c229c8c8783afc","typeString":"literal_string \"FetchChainInfoOutput: unknown GameType selector\""},"value":"FetchChainInfoOutput: unknown GameType selector"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_stringliteral_520d3d0cced140fee76c803f92d1db783b790e13f72de1e8f8c229c8c8783afc","typeString":"literal_string \"FetchChainInfoOutput: unknown GameType selector\""}],"id":57789,"name":"revert","nodeType":"Identifier","overloadedDeclarations":[-19,-19],"referencedDeclaration":-19,"src":"7476:6:120","typeDescriptions":{"typeIdentifier":"t_function_revert_pure$_t_string_memory_ptr_$returns$__$","typeString":"function (string memory) pure"}},"id":57791,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"7476:57:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":57792,"nodeType":"ExpressionStatement","src":"7476:57:120"},"id":57793,"nodeType":"IfStatement","src":"7386:147:120","trueBody":{"expression":{"id":57787,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftHandSide":{"id":57785,"name":"_respectedGameType","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57468,"src":"7431:18:120","typeDescriptions":{"typeIdentifier":"t_userDefinedValueType$_GameType_$75355","typeString":"GameType"}},"nodeType":"Assignment","operator":"=","rightHandSide":{"id":57786,"name":"_gameType","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57777,"src":"7452:9:120","typeDescriptions":{"typeIdentifier":"t_userDefinedValueType$_GameType_$75355","typeString":"GameType"}},"src":"7431:30:120","typeDescriptions":{"typeIdentifier":"t_userDefinedValueType$_GameType_$75355","typeString":"GameType"}},"id":57788,"nodeType":"ExpressionStatement","src":"7431:30:120"}}]},"functionSelector":"d08d6066","implemented":true,"kind":"function","modifiers":[],"name":"set","nameLocation":"7332:3:120","parameters":{"id":57778,"nodeType":"ParameterList","parameters":[{"constant":false,"id":57774,"mutability":"mutable","name":"_sel","nameLocation":"7343:4:120","nodeType":"VariableDeclaration","scope":57795,"src":"7336:11:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"},"typeName":{"id":57773,"name":"bytes4","nodeType":"ElementaryTypeName","src":"7336:6:120","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},"visibility":"internal"},{"constant":false,"id":57777,"mutability":"mutable","name":"_gameType","nameLocation":"7358:9:120","nodeType":"VariableDeclaration","scope":57795,"src":"7349:18:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_userDefinedValueType$_GameType_$75355","typeString":"GameType"},"typeName":{"id":57776,"nodeType":"UserDefinedTypeName","pathNode":{"id":57775,"name":"GameType","nameLocations":["7349:8:120"],"nodeType":"IdentifierPath","referencedDeclaration":75355,"src":"7349:8:120"},"referencedDeclaration":75355,"src":"7349:8:120","typeDescriptions":{"typeIdentifier":"t_userDefinedValueType$_GameType_$75355","typeString":"GameType"}},"visibility":"internal"}],"src":"7335:33:120"},"returnParameters":{"id":57779,"nodeType":"ParameterList","parameters":[],"src":"7376:0:120"},"scope":58249,"stateMutability":"nonpayable","virtual":false,"visibility":"public"},{"id":57813,"nodeType":"FunctionDefinition","src":"7546:207:120","nodes":[],"body":{"id":57812,"nodeType":"Block","src":"7606:147:120","nodes":[],"statements":[{"expression":{"arguments":[{"commonType":{"typeIdentifier":"t_address","typeString":"address"},"id":57806,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftExpression":{"id":57801,"name":"_addressManagerImpl","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57417,"src":"7624:19:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"BinaryOperation","operator":"!=","rightExpression":{"arguments":[{"hexValue":"30","id":57804,"isConstant":false,"isLValue":false,"isPure":true,"kind":"number","lValueRequested":false,"nodeType":"Literal","src":"7655:1:120","typeDescriptions":{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"},"value":"0"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"}],"id":57803,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"nodeType":"ElementaryTypeNameExpression","src":"7647:7:120","typeDescriptions":{"typeIdentifier":"t_type$_t_address_$","typeString":"type(address)"},"typeName":{"id":57802,"name":"address","nodeType":"ElementaryTypeName","src":"7647:7:120","typeDescriptions":{}}},"id":57805,"isConstant":false,"isLValue":false,"isPure":true,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"7647:10:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"src":"7624:33:120","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},{"hexValue":"4665746368436861696e496e666f4f75747075743a20616464726573734d616e61676572496d706c206e6f7420736574","id":57807,"isConstant":false,"isLValue":false,"isPure":true,"kind":"string","lValueRequested":false,"nodeType":"Literal","src":"7659:50:120","typeDescriptions":{"typeIdentifier":"t_stringliteral_b154041fe6470d62d16e8ad5c6d8e6c50a46e3e155a380b02703b07321b83f6a","typeString":"literal_string \"FetchChainInfoOutput: addressManagerImpl not set\""},"value":"FetchChainInfoOutput: addressManagerImpl not set"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_bool","typeString":"bool"},{"typeIdentifier":"t_stringliteral_b154041fe6470d62d16e8ad5c6d8e6c50a46e3e155a380b02703b07321b83f6a","typeString":"literal_string \"FetchChainInfoOutput: addressManagerImpl not set\""}],"id":57800,"name":"require","nodeType":"Identifier","overloadedDeclarations":[-18,-18],"referencedDeclaration":-18,"src":"7616:7:120","typeDescriptions":{"typeIdentifier":"t_function_require_pure$_t_bool_$_t_string_memory_ptr_$returns$__$","typeString":"function (bool,string memory) pure"}},"id":57808,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"7616:94:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":57809,"nodeType":"ExpressionStatement","src":"7616:94:120"},{"expression":{"id":57810,"name":"_addressManagerImpl","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57417,"src":"7727:19:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"functionReturnParameters":57799,"id":57811,"nodeType":"Return","src":"7720:26:120"}]},"functionSelector":"bd366b8f","implemented":true,"kind":"function","modifiers":[],"name":"addressManagerImpl","nameLocation":"7555:18:120","parameters":{"id":57796,"nodeType":"ParameterList","parameters":[],"src":"7573:2:120"},"returnParameters":{"id":57799,"nodeType":"ParameterList","parameters":[{"constant":false,"id":57798,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":57813,"src":"7597:7:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":57797,"name":"address","nodeType":"ElementaryTypeName","src":"7597:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"7596:9:120"},"scope":58249,"stateMutability":"view","virtual":false,"visibility":"public"},{"id":57821,"nodeType":"FunctionDefinition","src":"7759:97:120","nodes":[],"body":{"id":57820,"nodeType":"Block","src":"7816:40:120","nodes":[],"statements":[{"expression":{"id":57818,"name":"_ethLockboxProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57419,"src":"7833:16:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"functionReturnParameters":57817,"id":57819,"nodeType":"Return","src":"7826:23:120"}]},"functionSelector":"f646b07c","implemented":true,"kind":"function","modifiers":[],"name":"ethLockboxProxy","nameLocation":"7768:15:120","parameters":{"id":57814,"nodeType":"ParameterList","parameters":[],"src":"7783:2:120"},"returnParameters":{"id":57817,"nodeType":"ParameterList","parameters":[{"constant":false,"id":57816,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":57821,"src":"7807:7:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":57815,"name":"address","nodeType":"ElementaryTypeName","src":"7807:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"7806:9:120"},"scope":58249,"stateMutability":"view","virtual":false,"visibility":"public"},{"id":57839,"nodeType":"FunctionDefinition","src":"7862:243:120","nodes":[],"body":{"id":57838,"nodeType":"Block","src":"7931:174:120","nodes":[],"statements":[{"expression":{"arguments":[{"commonType":{"typeIdentifier":"t_address","typeString":"address"},"id":57832,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftExpression":{"id":57827,"name":"_l1CrossDomainMessengerProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57421,"src":"7949:28:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"BinaryOperation","operator":"!=","rightExpression":{"arguments":[{"hexValue":"30","id":57830,"isConstant":false,"isLValue":false,"isPure":true,"kind":"number","lValueRequested":false,"nodeType":"Literal","src":"7989:1:120","typeDescriptions":{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"},"value":"0"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"}],"id":57829,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"nodeType":"ElementaryTypeNameExpression","src":"7981:7:120","typeDescriptions":{"typeIdentifier":"t_type$_t_address_$","typeString":"type(address)"},"typeName":{"id":57828,"name":"address","nodeType":"ElementaryTypeName","src":"7981:7:120","typeDescriptions":{}}},"id":57831,"isConstant":false,"isLValue":false,"isPure":true,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"7981:10:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"src":"7949:42:120","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},{"hexValue":"4665746368436861696e496e666f4f75747075743a206c3143726f7373446f6d61696e4d657373656e67657250726f7879206e6f7420736574","id":57833,"isConstant":false,"isLValue":false,"isPure":true,"kind":"string","lValueRequested":false,"nodeType":"Literal","src":"7993:59:120","typeDescriptions":{"typeIdentifier":"t_stringliteral_c51216a9bdef996dd7040e19ba4fe817587273a187f1f145abfd19b1308df5eb","typeString":"literal_string \"FetchChainInfoOutput: l1CrossDomainMessengerProxy not set\""},"value":"FetchChainInfoOutput: l1CrossDomainMessengerProxy not set"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_bool","typeString":"bool"},{"typeIdentifier":"t_stringliteral_c51216a9bdef996dd7040e19ba4fe817587273a187f1f145abfd19b1308df5eb","typeString":"literal_string \"FetchChainInfoOutput: l1CrossDomainMessengerProxy not set\""}],"id":57826,"name":"require","nodeType":"Identifier","overloadedDeclarations":[-18,-18],"referencedDeclaration":-18,"src":"7941:7:120","typeDescriptions":{"typeIdentifier":"t_function_require_pure$_t_bool_$_t_string_memory_ptr_$returns$__$","typeString":"function (bool,string memory) pure"}},"id":57834,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"7941:112:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":57835,"nodeType":"ExpressionStatement","src":"7941:112:120"},{"expression":{"id":57836,"name":"_l1CrossDomainMessengerProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57421,"src":"8070:28:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"functionReturnParameters":57825,"id":57837,"nodeType":"Return","src":"8063:35:120"}]},"functionSelector":"54729cfb","implemented":true,"kind":"function","modifiers":[],"name":"l1CrossDomainMessengerProxy","nameLocation":"7871:27:120","parameters":{"id":57822,"nodeType":"ParameterList","parameters":[],"src":"7898:2:120"},"returnParameters":{"id":57825,"nodeType":"ParameterList","parameters":[{"constant":false,"id":57824,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":57839,"src":"7922:7:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":57823,"name":"address","nodeType":"ElementaryTypeName","src":"7922:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"7921:9:120"},"scope":58249,"stateMutability":"view","virtual":false,"visibility":"public"},{"id":57857,"nodeType":"FunctionDefinition","src":"8111:211:120","nodes":[],"body":{"id":57856,"nodeType":"Block","src":"8172:150:120","nodes":[],"statements":[{"expression":{"arguments":[{"commonType":{"typeIdentifier":"t_address","typeString":"address"},"id":57850,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftExpression":{"id":57845,"name":"_l1Erc721BridgeProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57423,"src":"8190:20:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"BinaryOperation","operator":"!=","rightExpression":{"arguments":[{"hexValue":"30","id":57848,"isConstant":false,"isLValue":false,"isPure":true,"kind":"number","lValueRequested":false,"nodeType":"Literal","src":"8222:1:120","typeDescriptions":{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"},"value":"0"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"}],"id":57847,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"nodeType":"ElementaryTypeNameExpression","src":"8214:7:120","typeDescriptions":{"typeIdentifier":"t_type$_t_address_$","typeString":"type(address)"},"typeName":{"id":57846,"name":"address","nodeType":"ElementaryTypeName","src":"8214:7:120","typeDescriptions":{}}},"id":57849,"isConstant":false,"isLValue":false,"isPure":true,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"8214:10:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"src":"8190:34:120","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},{"hexValue":"4665746368436861696e496e666f4f75747075743a206c3145726337323142726964676550726f7879206e6f7420736574","id":57851,"isConstant":false,"isLValue":false,"isPure":true,"kind":"string","lValueRequested":false,"nodeType":"Literal","src":"8226:51:120","typeDescriptions":{"typeIdentifier":"t_stringliteral_bdf5319949d8561b59a02fe667aa58fca11f5f8571bc18997b0bc0ac582aece7","typeString":"literal_string \"FetchChainInfoOutput: l1Erc721BridgeProxy not set\""},"value":"FetchChainInfoOutput: l1Erc721BridgeProxy not set"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_bool","typeString":"bool"},{"typeIdentifier":"t_stringliteral_bdf5319949d8561b59a02fe667aa58fca11f5f8571bc18997b0bc0ac582aece7","typeString":"literal_string \"FetchChainInfoOutput: l1Erc721BridgeProxy not set\""}],"id":57844,"name":"require","nodeType":"Identifier","overloadedDeclarations":[-18,-18],"referencedDeclaration":-18,"src":"8182:7:120","typeDescriptions":{"typeIdentifier":"t_function_require_pure$_t_bool_$_t_string_memory_ptr_$returns$__$","typeString":"function (bool,string memory) pure"}},"id":57852,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"8182:96:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":57853,"nodeType":"ExpressionStatement","src":"8182:96:120"},{"expression":{"id":57854,"name":"_l1Erc721BridgeProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57423,"src":"8295:20:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"functionReturnParameters":57843,"id":57855,"nodeType":"Return","src":"8288:27:120"}]},"functionSelector":"ebfa8409","implemented":true,"kind":"function","modifiers":[],"name":"l1Erc721BridgeProxy","nameLocation":"8120:19:120","parameters":{"id":57840,"nodeType":"ParameterList","parameters":[],"src":"8139:2:120"},"returnParameters":{"id":57843,"nodeType":"ParameterList","parameters":[{"constant":false,"id":57842,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":57857,"src":"8163:7:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":57841,"name":"address","nodeType":"ElementaryTypeName","src":"8163:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"8162:9:120"},"scope":58249,"stateMutability":"view","virtual":false,"visibility":"public"},{"id":57875,"nodeType":"FunctionDefinition","src":"8328:219:120","nodes":[],"body":{"id":57874,"nodeType":"Block","src":"8391:156:120","nodes":[],"statements":[{"expression":{"arguments":[{"commonType":{"typeIdentifier":"t_address","typeString":"address"},"id":57868,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftExpression":{"id":57863,"name":"_l1StandardBridgeProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57425,"src":"8409:22:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"BinaryOperation","operator":"!=","rightExpression":{"arguments":[{"hexValue":"30","id":57866,"isConstant":false,"isLValue":false,"isPure":true,"kind":"number","lValueRequested":false,"nodeType":"Literal","src":"8443:1:120","typeDescriptions":{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"},"value":"0"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"}],"id":57865,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"nodeType":"ElementaryTypeNameExpression","src":"8435:7:120","typeDescriptions":{"typeIdentifier":"t_type$_t_address_$","typeString":"type(address)"},"typeName":{"id":57864,"name":"address","nodeType":"ElementaryTypeName","src":"8435:7:120","typeDescriptions":{}}},"id":57867,"isConstant":false,"isLValue":false,"isPure":true,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"8435:10:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"src":"8409:36:120","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},{"hexValue":"4665746368436861696e496e666f4f75747075743a206c315374616e6461726442726964676550726f7879206e6f7420736574","id":57869,"isConstant":false,"isLValue":false,"isPure":true,"kind":"string","lValueRequested":false,"nodeType":"Literal","src":"8447:53:120","typeDescriptions":{"typeIdentifier":"t_stringliteral_ab3776e760de395cff3bb935602469d5b7c0bd9b5cfaefde9d221be6524302e1","typeString":"literal_string \"FetchChainInfoOutput: l1StandardBridgeProxy not set\""},"value":"FetchChainInfoOutput: l1StandardBridgeProxy not set"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_bool","typeString":"bool"},{"typeIdentifier":"t_stringliteral_ab3776e760de395cff3bb935602469d5b7c0bd9b5cfaefde9d221be6524302e1","typeString":"literal_string \"FetchChainInfoOutput: l1StandardBridgeProxy not set\""}],"id":57862,"name":"require","nodeType":"Identifier","overloadedDeclarations":[-18,-18],"referencedDeclaration":-18,"src":"8401:7:120","typeDescriptions":{"typeIdentifier":"t_function_require_pure$_t_bool_$_t_string_memory_ptr_$returns$__$","typeString":"function (bool,string memory) pure"}},"id":57870,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"8401:100:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":57871,"nodeType":"ExpressionStatement","src":"8401:100:120"},{"expression":{"id":57872,"name":"_l1StandardBridgeProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57425,"src":"8518:22:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"functionReturnParameters":57861,"id":57873,"nodeType":"Return","src":"8511:29:120"}]},"functionSelector":"102b6069","implemented":true,"kind":"function","modifiers":[],"name":"l1StandardBridgeProxy","nameLocation":"8337:21:120","parameters":{"id":57858,"nodeType":"ParameterList","parameters":[],"src":"8358:2:120"},"returnParameters":{"id":57861,"nodeType":"ParameterList","parameters":[{"constant":false,"id":57860,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":57875,"src":"8382:7:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":57859,"name":"address","nodeType":"ElementaryTypeName","src":"8382:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"8381:9:120"},"scope":58249,"stateMutability":"view","virtual":false,"visibility":"public"},{"id":57893,"nodeType":"FunctionDefinition","src":"8553:211:120","nodes":[],"body":{"id":57892,"nodeType":"Block","src":"8614:150:120","nodes":[],"statements":[{"expression":{"arguments":[{"commonType":{"typeIdentifier":"t_address","typeString":"address"},"id":57886,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftExpression":{"id":57881,"name":"_l2OutputOracleProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57427,"src":"8632:20:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"BinaryOperation","operator":"!=","rightExpression":{"arguments":[{"hexValue":"30","id":57884,"isConstant":false,"isLValue":false,"isPure":true,"kind":"number","lValueRequested":false,"nodeType":"Literal","src":"8664:1:120","typeDescriptions":{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"},"value":"0"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"}],"id":57883,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"nodeType":"ElementaryTypeNameExpression","src":"8656:7:120","typeDescriptions":{"typeIdentifier":"t_type$_t_address_$","typeString":"type(address)"},"typeName":{"id":57882,"name":"address","nodeType":"ElementaryTypeName","src":"8656:7:120","typeDescriptions":{}}},"id":57885,"isConstant":false,"isLValue":false,"isPure":true,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"8656:10:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"src":"8632:34:120","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},{"hexValue":"4665746368436861696e496e666f4f75747075743a206c324f75747075744f7261636c6550726f7879206e6f7420736574","id":57887,"isConstant":false,"isLValue":false,"isPure":true,"kind":"string","lValueRequested":false,"nodeType":"Literal","src":"8668:51:120","typeDescriptions":{"typeIdentifier":"t_stringliteral_2f861759874f8f3e0cfa53ef8dfb0556f88f877edbaf1dbc485fc820d67ac86a","typeString":"literal_string \"FetchChainInfoOutput: l2OutputOracleProxy not set\""},"value":"FetchChainInfoOutput: l2OutputOracleProxy not set"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_bool","typeString":"bool"},{"typeIdentifier":"t_stringliteral_2f861759874f8f3e0cfa53ef8dfb0556f88f877edbaf1dbc485fc820d67ac86a","typeString":"literal_string \"FetchChainInfoOutput: l2OutputOracleProxy not set\""}],"id":57880,"name":"require","nodeType":"Identifier","overloadedDeclarations":[-18,-18],"referencedDeclaration":-18,"src":"8624:7:120","typeDescriptions":{"typeIdentifier":"t_function_require_pure$_t_bool_$_t_string_memory_ptr_$returns$__$","typeString":"function (bool,string memory) pure"}},"id":57888,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"8624:96:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":57889,"nodeType":"ExpressionStatement","src":"8624:96:120"},{"expression":{"id":57890,"name":"_l2OutputOracleProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57427,"src":"8737:20:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"functionReturnParameters":57879,"id":57891,"nodeType":"Return","src":"8730:27:120"}]},"functionSelector":"a2c9a89f","implemented":true,"kind":"function","modifiers":[],"name":"l2OutputOracleProxy","nameLocation":"8562:19:120","parameters":{"id":57876,"nodeType":"ParameterList","parameters":[],"src":"8581:2:120"},"returnParameters":{"id":57879,"nodeType":"ParameterList","parameters":[{"constant":false,"id":57878,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":57893,"src":"8605:7:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":57877,"name":"address","nodeType":"ElementaryTypeName","src":"8605:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"8604:9:120"},"scope":58249,"stateMutability":"view","virtual":false,"visibility":"public"},{"id":57911,"nodeType":"FunctionDefinition","src":"8770:301:120","nodes":[],"body":{"id":57910,"nodeType":"Block","src":"8845:226:120","nodes":[],"statements":[{"expression":{"arguments":[{"commonType":{"typeIdentifier":"t_address","typeString":"address"},"id":57904,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftExpression":{"id":57899,"name":"_optimismMintableErc20FactoryProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57429,"src":"8876:34:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"BinaryOperation","operator":"!=","rightExpression":{"arguments":[{"hexValue":"30","id":57902,"isConstant":false,"isLValue":false,"isPure":true,"kind":"number","lValueRequested":false,"nodeType":"Literal","src":"8922:1:120","typeDescriptions":{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"},"value":"0"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"}],"id":57901,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"nodeType":"ElementaryTypeNameExpression","src":"8914:7:120","typeDescriptions":{"typeIdentifier":"t_type$_t_address_$","typeString":"type(address)"},"typeName":{"id":57900,"name":"address","nodeType":"ElementaryTypeName","src":"8914:7:120","typeDescriptions":{}}},"id":57903,"isConstant":false,"isLValue":false,"isPure":true,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"8914:10:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"src":"8876:48:120","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},{"hexValue":"4665746368436861696e496e666f4f75747075743a206f7074696d69736d4d696e7461626c654572633230466163746f727950726f7879206e6f7420736574","id":57905,"isConstant":false,"isLValue":false,"isPure":true,"kind":"string","lValueRequested":false,"nodeType":"Literal","src":"8938:65:120","typeDescriptions":{"typeIdentifier":"t_stringliteral_58c040fbde84bd4afd9f21f5ba3150dab029d767b65aafdf14512bdafdbd9954","typeString":"literal_string \"FetchChainInfoOutput: optimismMintableErc20FactoryProxy not set\""},"value":"FetchChainInfoOutput: optimismMintableErc20FactoryProxy not set"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_bool","typeString":"bool"},{"typeIdentifier":"t_stringliteral_58c040fbde84bd4afd9f21f5ba3150dab029d767b65aafdf14512bdafdbd9954","typeString":"literal_string \"FetchChainInfoOutput: optimismMintableErc20FactoryProxy not set\""}],"id":57898,"name":"require","nodeType":"Identifier","overloadedDeclarations":[-18,-18],"referencedDeclaration":-18,"src":"8855:7:120","typeDescriptions":{"typeIdentifier":"t_function_require_pure$_t_bool_$_t_string_memory_ptr_$returns$__$","typeString":"function (bool,string memory) pure"}},"id":57906,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"8855:158:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":57907,"nodeType":"ExpressionStatement","src":"8855:158:120"},{"expression":{"id":57908,"name":"_optimismMintableErc20FactoryProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57429,"src":"9030:34:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"functionReturnParameters":57897,"id":57909,"nodeType":"Return","src":"9023:41:120"}]},"functionSelector":"8f20c7e4","implemented":true,"kind":"function","modifiers":[],"name":"optimismMintableErc20FactoryProxy","nameLocation":"8779:33:120","parameters":{"id":57894,"nodeType":"ParameterList","parameters":[],"src":"8812:2:120"},"returnParameters":{"id":57897,"nodeType":"ParameterList","parameters":[{"constant":false,"id":57896,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":57911,"src":"8836:7:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":57895,"name":"address","nodeType":"ElementaryTypeName","src":"8836:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"8835:9:120"},"scope":58249,"stateMutability":"view","virtual":false,"visibility":"public"},{"id":57929,"nodeType":"FunctionDefinition","src":"9077:211:120","nodes":[],"body":{"id":57928,"nodeType":"Block","src":"9138:150:120","nodes":[],"statements":[{"expression":{"arguments":[{"commonType":{"typeIdentifier":"t_address","typeString":"address"},"id":57922,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftExpression":{"id":57917,"name":"_optimismPortalProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57431,"src":"9156:20:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"BinaryOperation","operator":"!=","rightExpression":{"arguments":[{"hexValue":"30","id":57920,"isConstant":false,"isLValue":false,"isPure":true,"kind":"number","lValueRequested":false,"nodeType":"Literal","src":"9188:1:120","typeDescriptions":{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"},"value":"0"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"}],"id":57919,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"nodeType":"ElementaryTypeNameExpression","src":"9180:7:120","typeDescriptions":{"typeIdentifier":"t_type$_t_address_$","typeString":"type(address)"},"typeName":{"id":57918,"name":"address","nodeType":"ElementaryTypeName","src":"9180:7:120","typeDescriptions":{}}},"id":57921,"isConstant":false,"isLValue":false,"isPure":true,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"9180:10:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"src":"9156:34:120","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},{"hexValue":"4665746368436861696e496e666f4f75747075743a206f7074696d69736d506f7274616c50726f7879206e6f7420736574","id":57923,"isConstant":false,"isLValue":false,"isPure":true,"kind":"string","lValueRequested":false,"nodeType":"Literal","src":"9192:51:120","typeDescriptions":{"typeIdentifier":"t_stringliteral_ef003bab75ab0cfa4ca81f99eb20b37a3fded08fa7502df7d991f596c8680642","typeString":"literal_string \"FetchChainInfoOutput: optimismPortalProxy not set\""},"value":"FetchChainInfoOutput: optimismPortalProxy not set"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_bool","typeString":"bool"},{"typeIdentifier":"t_stringliteral_ef003bab75ab0cfa4ca81f99eb20b37a3fded08fa7502df7d991f596c8680642","typeString":"literal_string \"FetchChainInfoOutput: optimismPortalProxy not set\""}],"id":57916,"name":"require","nodeType":"Identifier","overloadedDeclarations":[-18,-18],"referencedDeclaration":-18,"src":"9148:7:120","typeDescriptions":{"typeIdentifier":"t_function_require_pure$_t_bool_$_t_string_memory_ptr_$returns$__$","typeString":"function (bool,string memory) pure"}},"id":57924,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"9148:96:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":57925,"nodeType":"ExpressionStatement","src":"9148:96:120"},{"expression":{"id":57926,"name":"_optimismPortalProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57431,"src":"9261:20:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"functionReturnParameters":57915,"id":57927,"nodeType":"Return","src":"9254:27:120"}]},"functionSelector":"04451c49","implemented":true,"kind":"function","modifiers":[],"name":"optimismPortalProxy","nameLocation":"9086:19:120","parameters":{"id":57912,"nodeType":"ParameterList","parameters":[],"src":"9105:2:120"},"returnParameters":{"id":57915,"nodeType":"ParameterList","parameters":[{"constant":false,"id":57914,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":57929,"src":"9129:7:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":57913,"name":"address","nodeType":"ElementaryTypeName","src":"9129:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"9128:9:120"},"scope":58249,"stateMutability":"view","virtual":false,"visibility":"public"},{"id":57947,"nodeType":"FunctionDefinition","src":"9294:203:120","nodes":[],"body":{"id":57946,"nodeType":"Block","src":"9353:144:120","nodes":[],"statements":[{"expression":{"arguments":[{"commonType":{"typeIdentifier":"t_address","typeString":"address"},"id":57940,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftExpression":{"id":57935,"name":"_systemConfigProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57433,"src":"9371:18:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"BinaryOperation","operator":"!=","rightExpression":{"arguments":[{"hexValue":"30","id":57938,"isConstant":false,"isLValue":false,"isPure":true,"kind":"number","lValueRequested":false,"nodeType":"Literal","src":"9401:1:120","typeDescriptions":{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"},"value":"0"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"}],"id":57937,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"nodeType":"ElementaryTypeNameExpression","src":"9393:7:120","typeDescriptions":{"typeIdentifier":"t_type$_t_address_$","typeString":"type(address)"},"typeName":{"id":57936,"name":"address","nodeType":"ElementaryTypeName","src":"9393:7:120","typeDescriptions":{}}},"id":57939,"isConstant":false,"isLValue":false,"isPure":true,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"9393:10:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"src":"9371:32:120","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},{"hexValue":"4665746368436861696e496e666f4f75747075743a2073797374656d436f6e66696750726f7879206e6f7420736574","id":57941,"isConstant":false,"isLValue":false,"isPure":true,"kind":"string","lValueRequested":false,"nodeType":"Literal","src":"9405:49:120","typeDescriptions":{"typeIdentifier":"t_stringliteral_09ada010329fb4e012f4c857519ec176efea734f55c01f382f1b6c7bd752716b","typeString":"literal_string \"FetchChainInfoOutput: systemConfigProxy not set\""},"value":"FetchChainInfoOutput: systemConfigProxy not set"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_bool","typeString":"bool"},{"typeIdentifier":"t_stringliteral_09ada010329fb4e012f4c857519ec176efea734f55c01f382f1b6c7bd752716b","typeString":"literal_string \"FetchChainInfoOutput: systemConfigProxy not set\""}],"id":57934,"name":"require","nodeType":"Identifier","overloadedDeclarations":[-18,-18],"referencedDeclaration":-18,"src":"9363:7:120","typeDescriptions":{"typeIdentifier":"t_function_require_pure$_t_bool_$_t_string_memory_ptr_$returns$__$","typeString":"function (bool,string memory) pure"}},"id":57942,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"9363:92:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":57943,"nodeType":"ExpressionStatement","src":"9363:92:120"},{"expression":{"id":57944,"name":"_systemConfigProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57433,"src":"9472:18:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"functionReturnParameters":57933,"id":57945,"nodeType":"Return","src":"9465:25:120"}]},"functionSelector":"c17db6e3","implemented":true,"kind":"function","modifiers":[],"name":"systemConfigProxy","nameLocation":"9303:17:120","parameters":{"id":57930,"nodeType":"ParameterList","parameters":[],"src":"9320:2:120"},"returnParameters":{"id":57933,"nodeType":"ParameterList","parameters":[{"constant":false,"id":57932,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":57947,"src":"9344:7:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":57931,"name":"address","nodeType":"ElementaryTypeName","src":"9344:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"9343:9:120"},"scope":58249,"stateMutability":"view","virtual":false,"visibility":"public"},{"id":57965,"nodeType":"FunctionDefinition","src":"9503:219:120","nodes":[],"body":{"id":57964,"nodeType":"Block","src":"9566:156:120","nodes":[],"statements":[{"expression":{"arguments":[{"commonType":{"typeIdentifier":"t_address","typeString":"address"},"id":57958,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftExpression":{"id":57953,"name":"_opChainProxyAdminImpl","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57435,"src":"9584:22:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"BinaryOperation","operator":"!=","rightExpression":{"arguments":[{"hexValue":"30","id":57956,"isConstant":false,"isLValue":false,"isPure":true,"kind":"number","lValueRequested":false,"nodeType":"Literal","src":"9618:1:120","typeDescriptions":{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"},"value":"0"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"}],"id":57955,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"nodeType":"ElementaryTypeNameExpression","src":"9610:7:120","typeDescriptions":{"typeIdentifier":"t_type$_t_address_$","typeString":"type(address)"},"typeName":{"id":57954,"name":"address","nodeType":"ElementaryTypeName","src":"9610:7:120","typeDescriptions":{}}},"id":57957,"isConstant":false,"isLValue":false,"isPure":true,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"9610:10:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"src":"9584:36:120","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},{"hexValue":"4665746368436861696e496e666f4f75747075743a206f70436861696e50726f787941646d696e496d706c206e6f7420736574","id":57959,"isConstant":false,"isLValue":false,"isPure":true,"kind":"string","lValueRequested":false,"nodeType":"Literal","src":"9622:53:120","typeDescriptions":{"typeIdentifier":"t_stringliteral_8ebc3647bde8a1129bfd827c7ef2e2d4fea82292bcad8a3c8e3918d70fed8ea8","typeString":"literal_string \"FetchChainInfoOutput: opChainProxyAdminImpl not set\""},"value":"FetchChainInfoOutput: opChainProxyAdminImpl not set"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_bool","typeString":"bool"},{"typeIdentifier":"t_stringliteral_8ebc3647bde8a1129bfd827c7ef2e2d4fea82292bcad8a3c8e3918d70fed8ea8","typeString":"literal_string \"FetchChainInfoOutput: opChainProxyAdminImpl not set\""}],"id":57952,"name":"require","nodeType":"Identifier","overloadedDeclarations":[-18,-18],"referencedDeclaration":-18,"src":"9576:7:120","typeDescriptions":{"typeIdentifier":"t_function_require_pure$_t_bool_$_t_string_memory_ptr_$returns$__$","typeString":"function (bool,string memory) pure"}},"id":57960,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"9576:100:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":57961,"nodeType":"ExpressionStatement","src":"9576:100:120"},{"expression":{"id":57962,"name":"_opChainProxyAdminImpl","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57435,"src":"9693:22:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"functionReturnParameters":57951,"id":57963,"nodeType":"Return","src":"9686:29:120"}]},"functionSelector":"5643665f","implemented":true,"kind":"function","modifiers":[],"name":"opChainProxyAdminImpl","nameLocation":"9512:21:120","parameters":{"id":57948,"nodeType":"ParameterList","parameters":[],"src":"9533:2:120"},"returnParameters":{"id":57951,"nodeType":"ParameterList","parameters":[{"constant":false,"id":57950,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":57965,"src":"9557:7:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":57949,"name":"address","nodeType":"ElementaryTypeName","src":"9557:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"9556:9:120"},"scope":58249,"stateMutability":"view","virtual":false,"visibility":"public"},{"id":57983,"nodeType":"FunctionDefinition","src":"9728:219:120","nodes":[],"body":{"id":57982,"nodeType":"Block","src":"9791:156:120","nodes":[],"statements":[{"expression":{"arguments":[{"commonType":{"typeIdentifier":"t_address","typeString":"address"},"id":57976,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftExpression":{"id":57971,"name":"_superchainConfigProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57411,"src":"9809:22:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"BinaryOperation","operator":"!=","rightExpression":{"arguments":[{"hexValue":"30","id":57974,"isConstant":false,"isLValue":false,"isPure":true,"kind":"number","lValueRequested":false,"nodeType":"Literal","src":"9843:1:120","typeDescriptions":{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"},"value":"0"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"}],"id":57973,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"nodeType":"ElementaryTypeNameExpression","src":"9835:7:120","typeDescriptions":{"typeIdentifier":"t_type$_t_address_$","typeString":"type(address)"},"typeName":{"id":57972,"name":"address","nodeType":"ElementaryTypeName","src":"9835:7:120","typeDescriptions":{}}},"id":57975,"isConstant":false,"isLValue":false,"isPure":true,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"9835:10:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"src":"9809:36:120","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},{"hexValue":"4665746368436861696e496e666f4f75747075743a207375706572636861696e436f6e66696750726f7879206e6f7420736574","id":57977,"isConstant":false,"isLValue":false,"isPure":true,"kind":"string","lValueRequested":false,"nodeType":"Literal","src":"9847:53:120","typeDescriptions":{"typeIdentifier":"t_stringliteral_1b8ad3d2e627aa065fd0fee387bc2d1e5e640177323f7f86733cd157b788a1ce","typeString":"literal_string \"FetchChainInfoOutput: superchainConfigProxy not set\""},"value":"FetchChainInfoOutput: superchainConfigProxy not set"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_bool","typeString":"bool"},{"typeIdentifier":"t_stringliteral_1b8ad3d2e627aa065fd0fee387bc2d1e5e640177323f7f86733cd157b788a1ce","typeString":"literal_string \"FetchChainInfoOutput: superchainConfigProxy not set\""}],"id":57970,"name":"require","nodeType":"Identifier","overloadedDeclarations":[-18,-18],"referencedDeclaration":-18,"src":"9801:7:120","typeDescriptions":{"typeIdentifier":"t_function_require_pure$_t_bool_$_t_string_memory_ptr_$returns$__$","typeString":"function (bool,string memory) pure"}},"id":57978,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"9801:100:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":57979,"nodeType":"ExpressionStatement","src":"9801:100:120"},{"expression":{"id":57980,"name":"_superchainConfigProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57411,"src":"9918:22:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"functionReturnParameters":57969,"id":57981,"nodeType":"Return","src":"9911:29:120"}]},"functionSelector":"84cf2c97","implemented":true,"kind":"function","modifiers":[],"name":"superchainConfigProxy","nameLocation":"9737:21:120","parameters":{"id":57966,"nodeType":"ParameterList","parameters":[],"src":"9758:2:120"},"returnParameters":{"id":57969,"nodeType":"ParameterList","parameters":[{"constant":false,"id":57968,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":57983,"src":"9782:7:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":57967,"name":"address","nodeType":"ElementaryTypeName","src":"9782:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"9781:9:120"},"scope":58249,"stateMutability":"view","virtual":false,"visibility":"public"},{"id":58001,"nodeType":"FunctionDefinition","src":"9953:231:120","nodes":[],"body":{"id":58000,"nodeType":"Block","src":"10019:165:120","nodes":[],"statements":[{"expression":{"arguments":[{"commonType":{"typeIdentifier":"t_address","typeString":"address"},"id":57994,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftExpression":{"id":57989,"name":"_anchorStateRegistryProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57437,"src":"10037:25:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"BinaryOperation","operator":"!=","rightExpression":{"arguments":[{"hexValue":"30","id":57992,"isConstant":false,"isLValue":false,"isPure":true,"kind":"number","lValueRequested":false,"nodeType":"Literal","src":"10074:1:120","typeDescriptions":{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"},"value":"0"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"}],"id":57991,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"nodeType":"ElementaryTypeNameExpression","src":"10066:7:120","typeDescriptions":{"typeIdentifier":"t_type$_t_address_$","typeString":"type(address)"},"typeName":{"id":57990,"name":"address","nodeType":"ElementaryTypeName","src":"10066:7:120","typeDescriptions":{}}},"id":57993,"isConstant":false,"isLValue":false,"isPure":true,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"10066:10:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"src":"10037:39:120","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},{"hexValue":"4665746368436861696e496e666f4f75747075743a20616e63686f725374617465526567697374727950726f7879206e6f7420736574","id":57995,"isConstant":false,"isLValue":false,"isPure":true,"kind":"string","lValueRequested":false,"nodeType":"Literal","src":"10078:56:120","typeDescriptions":{"typeIdentifier":"t_stringliteral_6391076785d7152b9570ce8338ca2e43a749144cb3dbb7f9e5e1de5fabfbae48","typeString":"literal_string \"FetchChainInfoOutput: anchorStateRegistryProxy not set\""},"value":"FetchChainInfoOutput: anchorStateRegistryProxy not set"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_bool","typeString":"bool"},{"typeIdentifier":"t_stringliteral_6391076785d7152b9570ce8338ca2e43a749144cb3dbb7f9e5e1de5fabfbae48","typeString":"literal_string \"FetchChainInfoOutput: anchorStateRegistryProxy not set\""}],"id":57988,"name":"require","nodeType":"Identifier","overloadedDeclarations":[-18,-18],"referencedDeclaration":-18,"src":"10029:7:120","typeDescriptions":{"typeIdentifier":"t_function_require_pure$_t_bool_$_t_string_memory_ptr_$returns$__$","typeString":"function (bool,string memory) pure"}},"id":57996,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"10029:106:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":57997,"nodeType":"ExpressionStatement","src":"10029:106:120"},{"expression":{"id":57998,"name":"_anchorStateRegistryProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57437,"src":"10152:25:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"functionReturnParameters":57987,"id":57999,"nodeType":"Return","src":"10145:32:120"}]},"functionSelector":"35596f76","implemented":true,"kind":"function","modifiers":[],"name":"anchorStateRegistryProxy","nameLocation":"9962:24:120","parameters":{"id":57984,"nodeType":"ParameterList","parameters":[],"src":"9986:2:120"},"returnParameters":{"id":57987,"nodeType":"ParameterList","parameters":[{"constant":false,"id":57986,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":58001,"src":"10010:7:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":57985,"name":"address","nodeType":"ElementaryTypeName","src":"10010:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"10009:9:120"},"scope":58249,"stateMutability":"view","virtual":false,"visibility":"public"},{"id":58009,"nodeType":"FunctionDefinition","src":"10190:131:120","nodes":[],"body":{"id":58008,"nodeType":"Block","src":"10264:57:120","nodes":[],"statements":[{"expression":{"id":58006,"name":"_delayedWethPermissionedGameProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57439,"src":"10281:33:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"functionReturnParameters":58005,"id":58007,"nodeType":"Return","src":"10274:40:120"}]},"functionSelector":"794836d7","implemented":true,"kind":"function","modifiers":[],"name":"delayedWethPermissionedGameProxy","nameLocation":"10199:32:120","parameters":{"id":58002,"nodeType":"ParameterList","parameters":[],"src":"10231:2:120"},"returnParameters":{"id":58005,"nodeType":"ParameterList","parameters":[{"constant":false,"id":58004,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":58009,"src":"10255:7:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":58003,"name":"address","nodeType":"ElementaryTypeName","src":"10255:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"10254:9:120"},"scope":58249,"stateMutability":"view","virtual":false,"visibility":"public"},{"id":58017,"nodeType":"FunctionDefinition","src":"10327:135:120","nodes":[],"body":{"id":58016,"nodeType":"Block","src":"10403:59:120","nodes":[],"statements":[{"expression":{"id":58014,"name":"_delayedWethPermissionlessGameProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57441,"src":"10420:35:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"functionReturnParameters":58013,"id":58015,"nodeType":"Return","src":"10413:42:120"}]},"functionSelector":"97068797","implemented":true,"kind":"function","modifiers":[],"name":"delayedWethPermissionlessGameProxy","nameLocation":"10336:34:120","parameters":{"id":58010,"nodeType":"ParameterList","parameters":[],"src":"10370:2:120"},"returnParameters":{"id":58013,"nodeType":"ParameterList","parameters":[{"constant":false,"id":58012,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":58017,"src":"10394:7:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":58011,"name":"address","nodeType":"ElementaryTypeName","src":"10394:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"10393:9:120"},"scope":58249,"stateMutability":"view","virtual":false,"visibility":"public"},{"id":58025,"nodeType":"FunctionDefinition","src":"10468:113:120","nodes":[],"body":{"id":58024,"nodeType":"Block","src":"10533:48:120","nodes":[],"statements":[{"expression":{"id":58022,"name":"_disputeGameFactoryProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57443,"src":"10550:24:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"functionReturnParameters":58021,"id":58023,"nodeType":"Return","src":"10543:31:120"}]},"functionSelector":"6c4568d1","implemented":true,"kind":"function","modifiers":[],"name":"disputeGameFactoryProxy","nameLocation":"10477:23:120","parameters":{"id":58018,"nodeType":"ParameterList","parameters":[],"src":"10500:2:120"},"returnParameters":{"id":58021,"nodeType":"ParameterList","parameters":[{"constant":false,"id":58020,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":58025,"src":"10524:7:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":58019,"name":"address","nodeType":"ElementaryTypeName","src":"10524:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"10523:9:120"},"scope":58249,"stateMutability":"view","virtual":false,"visibility":"public"},{"id":58043,"nodeType":"FunctionDefinition","src":"10587:215:120","nodes":[],"body":{"id":58042,"nodeType":"Block","src":"10649:153:120","nodes":[],"statements":[{"expression":{"arguments":[{"commonType":{"typeIdentifier":"t_address","typeString":"address"},"id":58036,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftExpression":{"id":58031,"name":"_faultDisputeGameImpl","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57445,"src":"10667:21:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"BinaryOperation","operator":"!=","rightExpression":{"arguments":[{"hexValue":"30","id":58034,"isConstant":false,"isLValue":false,"isPure":true,"kind":"number","lValueRequested":false,"nodeType":"Literal","src":"10700:1:120","typeDescriptions":{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"},"value":"0"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"}],"id":58033,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"nodeType":"ElementaryTypeNameExpression","src":"10692:7:120","typeDescriptions":{"typeIdentifier":"t_type$_t_address_$","typeString":"type(address)"},"typeName":{"id":58032,"name":"address","nodeType":"ElementaryTypeName","src":"10692:7:120","typeDescriptions":{}}},"id":58035,"isConstant":false,"isLValue":false,"isPure":true,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"10692:10:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"src":"10667:35:120","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},{"hexValue":"4665746368436861696e496e666f4f75747075743a206661756c744469737075746547616d65496d706c206e6f7420736574","id":58037,"isConstant":false,"isLValue":false,"isPure":true,"kind":"string","lValueRequested":false,"nodeType":"Literal","src":"10704:52:120","typeDescriptions":{"typeIdentifier":"t_stringliteral_baae18cd0fbc1fbf3c566f5918a7a4a780bb1a3d403d2b65d908417b87c06457","typeString":"literal_string \"FetchChainInfoOutput: faultDisputeGameImpl not set\""},"value":"FetchChainInfoOutput: faultDisputeGameImpl not set"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_bool","typeString":"bool"},{"typeIdentifier":"t_stringliteral_baae18cd0fbc1fbf3c566f5918a7a4a780bb1a3d403d2b65d908417b87c06457","typeString":"literal_string \"FetchChainInfoOutput: faultDisputeGameImpl not set\""}],"id":58030,"name":"require","nodeType":"Identifier","overloadedDeclarations":[-18,-18],"referencedDeclaration":-18,"src":"10659:7:120","typeDescriptions":{"typeIdentifier":"t_function_require_pure$_t_bool_$_t_string_memory_ptr_$returns$__$","typeString":"function (bool,string memory) pure"}},"id":58038,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"10659:98:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":58039,"nodeType":"ExpressionStatement","src":"10659:98:120"},{"expression":{"id":58040,"name":"_faultDisputeGameImpl","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57445,"src":"10774:21:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"functionReturnParameters":58029,"id":58041,"nodeType":"Return","src":"10767:28:120"}]},"functionSelector":"dea21984","implemented":true,"kind":"function","modifiers":[],"name":"faultDisputeGameImpl","nameLocation":"10596:20:120","parameters":{"id":58026,"nodeType":"ParameterList","parameters":[],"src":"10616:2:120"},"returnParameters":{"id":58029,"nodeType":"ParameterList","parameters":[{"constant":false,"id":58028,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":58043,"src":"10640:7:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":58027,"name":"address","nodeType":"ElementaryTypeName","src":"10640:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"10639:9:120"},"scope":58249,"stateMutability":"view","virtual":false,"visibility":"public"},{"id":58061,"nodeType":"FunctionDefinition","src":"10808:167:120","nodes":[],"body":{"id":58060,"nodeType":"Block","src":"10858:117:120","nodes":[],"statements":[{"expression":{"arguments":[{"commonType":{"typeIdentifier":"t_address","typeString":"address"},"id":58054,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftExpression":{"id":58049,"name":"_mipsImpl","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57413,"src":"10876:9:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"BinaryOperation","operator":"!=","rightExpression":{"arguments":[{"hexValue":"30","id":58052,"isConstant":false,"isLValue":false,"isPure":true,"kind":"number","lValueRequested":false,"nodeType":"Literal","src":"10897:1:120","typeDescriptions":{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"},"value":"0"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"}],"id":58051,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"nodeType":"ElementaryTypeNameExpression","src":"10889:7:120","typeDescriptions":{"typeIdentifier":"t_type$_t_address_$","typeString":"type(address)"},"typeName":{"id":58050,"name":"address","nodeType":"ElementaryTypeName","src":"10889:7:120","typeDescriptions":{}}},"id":58053,"isConstant":false,"isLValue":false,"isPure":true,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"10889:10:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"src":"10876:23:120","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},{"hexValue":"4665746368436861696e496e666f4f75747075743a206d697073496d706c206e6f7420736574","id":58055,"isConstant":false,"isLValue":false,"isPure":true,"kind":"string","lValueRequested":false,"nodeType":"Literal","src":"10901:40:120","typeDescriptions":{"typeIdentifier":"t_stringliteral_178867f585ae7eaee2b47a35fdf118ac2b037c387c5937f3b39b1c51f05d7497","typeString":"literal_string \"FetchChainInfoOutput: mipsImpl not set\""},"value":"FetchChainInfoOutput: mipsImpl not set"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_bool","typeString":"bool"},{"typeIdentifier":"t_stringliteral_178867f585ae7eaee2b47a35fdf118ac2b037c387c5937f3b39b1c51f05d7497","typeString":"literal_string \"FetchChainInfoOutput: mipsImpl not set\""}],"id":58048,"name":"require","nodeType":"Identifier","overloadedDeclarations":[-18,-18],"referencedDeclaration":-18,"src":"10868:7:120","typeDescriptions":{"typeIdentifier":"t_function_require_pure$_t_bool_$_t_string_memory_ptr_$returns$__$","typeString":"function (bool,string memory) pure"}},"id":58056,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"10868:74:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":58057,"nodeType":"ExpressionStatement","src":"10868:74:120"},{"expression":{"id":58058,"name":"_mipsImpl","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57413,"src":"10959:9:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"functionReturnParameters":58047,"id":58059,"nodeType":"Return","src":"10952:16:120"}]},"functionSelector":"e303272c","implemented":true,"kind":"function","modifiers":[],"name":"mipsImpl","nameLocation":"10817:8:120","parameters":{"id":58044,"nodeType":"ParameterList","parameters":[],"src":"10825:2:120"},"returnParameters":{"id":58047,"nodeType":"ParameterList","parameters":[{"constant":false,"id":58046,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":58061,"src":"10849:7:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":58045,"name":"address","nodeType":"ElementaryTypeName","src":"10849:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"10848:9:120"},"scope":58249,"stateMutability":"view","virtual":false,"visibility":"public"},{"id":58079,"nodeType":"FunctionDefinition","src":"10981:243:120","nodes":[],"body":{"id":58078,"nodeType":"Block","src":"11050:174:120","nodes":[],"statements":[{"expression":{"arguments":[{"commonType":{"typeIdentifier":"t_address","typeString":"address"},"id":58072,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftExpression":{"id":58067,"name":"_permissionedDisputeGameImpl","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57447,"src":"11068:28:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"BinaryOperation","operator":"!=","rightExpression":{"arguments":[{"hexValue":"30","id":58070,"isConstant":false,"isLValue":false,"isPure":true,"kind":"number","lValueRequested":false,"nodeType":"Literal","src":"11108:1:120","typeDescriptions":{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"},"value":"0"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"}],"id":58069,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"nodeType":"ElementaryTypeNameExpression","src":"11100:7:120","typeDescriptions":{"typeIdentifier":"t_type$_t_address_$","typeString":"type(address)"},"typeName":{"id":58068,"name":"address","nodeType":"ElementaryTypeName","src":"11100:7:120","typeDescriptions":{}}},"id":58071,"isConstant":false,"isLValue":false,"isPure":true,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"11100:10:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"src":"11068:42:120","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},{"hexValue":"4665746368436861696e496e666f4f75747075743a207065726d697373696f6e65644469737075746547616d65496d706c206e6f7420736574","id":58073,"isConstant":false,"isLValue":false,"isPure":true,"kind":"string","lValueRequested":false,"nodeType":"Literal","src":"11112:59:120","typeDescriptions":{"typeIdentifier":"t_stringliteral_234858b97aab3865b03b564f238f9977c62296b1532cb4f809e12678629cae92","typeString":"literal_string \"FetchChainInfoOutput: permissionedDisputeGameImpl not set\""},"value":"FetchChainInfoOutput: permissionedDisputeGameImpl not set"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_bool","typeString":"bool"},{"typeIdentifier":"t_stringliteral_234858b97aab3865b03b564f238f9977c62296b1532cb4f809e12678629cae92","typeString":"literal_string \"FetchChainInfoOutput: permissionedDisputeGameImpl not set\""}],"id":58066,"name":"require","nodeType":"Identifier","overloadedDeclarations":[-18,-18],"referencedDeclaration":-18,"src":"11060:7:120","typeDescriptions":{"typeIdentifier":"t_function_require_pure$_t_bool_$_t_string_memory_ptr_$returns$__$","typeString":"function (bool,string memory) pure"}},"id":58074,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"11060:112:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":58075,"nodeType":"ExpressionStatement","src":"11060:112:120"},{"expression":{"id":58076,"name":"_permissionedDisputeGameImpl","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57447,"src":"11189:28:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"functionReturnParameters":58065,"id":58077,"nodeType":"Return","src":"11182:35:120"}]},"functionSelector":"98ccec3e","implemented":true,"kind":"function","modifiers":[],"name":"permissionedDisputeGameImpl","nameLocation":"10990:27:120","parameters":{"id":58062,"nodeType":"ParameterList","parameters":[],"src":"11017:2:120"},"returnParameters":{"id":58065,"nodeType":"ParameterList","parameters":[{"constant":false,"id":58064,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":58079,"src":"11041:7:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":58063,"name":"address","nodeType":"ElementaryTypeName","src":"11041:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"11040:9:120"},"scope":58249,"stateMutability":"view","virtual":false,"visibility":"public"},{"id":58097,"nodeType":"FunctionDefinition","src":"11230:207:120","nodes":[],"body":{"id":58096,"nodeType":"Block","src":"11290:147:120","nodes":[],"statements":[{"expression":{"arguments":[{"commonType":{"typeIdentifier":"t_address","typeString":"address"},"id":58090,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftExpression":{"id":58085,"name":"_preimageOracleImpl","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57415,"src":"11308:19:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"BinaryOperation","operator":"!=","rightExpression":{"arguments":[{"hexValue":"30","id":58088,"isConstant":false,"isLValue":false,"isPure":true,"kind":"number","lValueRequested":false,"nodeType":"Literal","src":"11339:1:120","typeDescriptions":{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"},"value":"0"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"}],"id":58087,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"nodeType":"ElementaryTypeNameExpression","src":"11331:7:120","typeDescriptions":{"typeIdentifier":"t_type$_t_address_$","typeString":"type(address)"},"typeName":{"id":58086,"name":"address","nodeType":"ElementaryTypeName","src":"11331:7:120","typeDescriptions":{}}},"id":58089,"isConstant":false,"isLValue":false,"isPure":true,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"11331:10:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"src":"11308:33:120","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},{"hexValue":"4665746368436861696e496e666f4f75747075743a20707265696d6167654f7261636c65496d706c206e6f7420736574","id":58091,"isConstant":false,"isLValue":false,"isPure":true,"kind":"string","lValueRequested":false,"nodeType":"Literal","src":"11343:50:120","typeDescriptions":{"typeIdentifier":"t_stringliteral_2434e23032e7627ba1a13e989a9fbe735952d0d6f49e2760e1b1064b8728d538","typeString":"literal_string \"FetchChainInfoOutput: preimageOracleImpl not set\""},"value":"FetchChainInfoOutput: preimageOracleImpl not set"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_bool","typeString":"bool"},{"typeIdentifier":"t_stringliteral_2434e23032e7627ba1a13e989a9fbe735952d0d6f49e2760e1b1064b8728d538","typeString":"literal_string \"FetchChainInfoOutput: preimageOracleImpl not set\""}],"id":58084,"name":"require","nodeType":"Identifier","overloadedDeclarations":[-18,-18],"referencedDeclaration":-18,"src":"11300:7:120","typeDescriptions":{"typeIdentifier":"t_function_require_pure$_t_bool_$_t_string_memory_ptr_$returns$__$","typeString":"function (bool,string memory) pure"}},"id":58092,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"11300:94:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":58093,"nodeType":"ExpressionStatement","src":"11300:94:120"},{"expression":{"id":58094,"name":"_preimageOracleImpl","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57415,"src":"11411:19:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"functionReturnParameters":58083,"id":58095,"nodeType":"Return","src":"11404:26:120"}]},"functionSelector":"d030d2e8","implemented":true,"kind":"function","modifiers":[],"name":"preimageOracleImpl","nameLocation":"11239:18:120","parameters":{"id":58080,"nodeType":"ParameterList","parameters":[],"src":"11257:2:120"},"returnParameters":{"id":58083,"nodeType":"ParameterList","parameters":[{"constant":false,"id":58082,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":58097,"src":"11281:7:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":58081,"name":"address","nodeType":"ElementaryTypeName","src":"11281:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"11280:9:120"},"scope":58249,"stateMutability":"view","virtual":false,"visibility":"public"},{"id":58115,"nodeType":"FunctionDefinition","src":"11443:203:120","nodes":[],"body":{"id":58114,"nodeType":"Block","src":"11502:144:120","nodes":[],"statements":[{"expression":{"arguments":[{"commonType":{"typeIdentifier":"t_address","typeString":"address"},"id":58108,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftExpression":{"id":58103,"name":"_systemConfigOwner","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57449,"src":"11520:18:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"BinaryOperation","operator":"!=","rightExpression":{"arguments":[{"hexValue":"30","id":58106,"isConstant":false,"isLValue":false,"isPure":true,"kind":"number","lValueRequested":false,"nodeType":"Literal","src":"11550:1:120","typeDescriptions":{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"},"value":"0"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"}],"id":58105,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"nodeType":"ElementaryTypeNameExpression","src":"11542:7:120","typeDescriptions":{"typeIdentifier":"t_type$_t_address_$","typeString":"type(address)"},"typeName":{"id":58104,"name":"address","nodeType":"ElementaryTypeName","src":"11542:7:120","typeDescriptions":{}}},"id":58107,"isConstant":false,"isLValue":false,"isPure":true,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"11542:10:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"src":"11520:32:120","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},{"hexValue":"4665746368436861696e496e666f4f75747075743a2073797374656d436f6e6669674f776e6572206e6f7420736574","id":58109,"isConstant":false,"isLValue":false,"isPure":true,"kind":"string","lValueRequested":false,"nodeType":"Literal","src":"11554:49:120","typeDescriptions":{"typeIdentifier":"t_stringliteral_fc7a67f4775c5e19ca3731b64db9f9f8895dcd37a01bc895f1d1806a7f21c916","typeString":"literal_string \"FetchChainInfoOutput: systemConfigOwner not set\""},"value":"FetchChainInfoOutput: systemConfigOwner not set"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_bool","typeString":"bool"},{"typeIdentifier":"t_stringliteral_fc7a67f4775c5e19ca3731b64db9f9f8895dcd37a01bc895f1d1806a7f21c916","typeString":"literal_string \"FetchChainInfoOutput: systemConfigOwner not set\""}],"id":58102,"name":"require","nodeType":"Identifier","overloadedDeclarations":[-18,-18],"referencedDeclaration":-18,"src":"11512:7:120","typeDescriptions":{"typeIdentifier":"t_function_require_pure$_t_bool_$_t_string_memory_ptr_$returns$__$","typeString":"function (bool,string memory) pure"}},"id":58110,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"11512:92:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":58111,"nodeType":"ExpressionStatement","src":"11512:92:120"},{"expression":{"id":58112,"name":"_systemConfigOwner","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57449,"src":"11621:18:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"functionReturnParameters":58101,"id":58113,"nodeType":"Return","src":"11614:25:120"}]},"functionSelector":"1e229b20","implemented":true,"kind":"function","modifiers":[],"name":"systemConfigOwner","nameLocation":"11452:17:120","parameters":{"id":58098,"nodeType":"ParameterList","parameters":[],"src":"11469:2:120"},"returnParameters":{"id":58101,"nodeType":"ParameterList","parameters":[{"constant":false,"id":58100,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":58115,"src":"11493:7:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":58099,"name":"address","nodeType":"ElementaryTypeName","src":"11493:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"11492:9:120"},"scope":58249,"stateMutability":"view","virtual":false,"visibility":"public"},{"id":58133,"nodeType":"FunctionDefinition","src":"11652:223:120","nodes":[],"body":{"id":58132,"nodeType":"Block","src":"11716:159:120","nodes":[],"statements":[{"expression":{"arguments":[{"commonType":{"typeIdentifier":"t_address","typeString":"address"},"id":58126,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftExpression":{"id":58121,"name":"_opChainProxyAdminOwner","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57451,"src":"11734:23:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"BinaryOperation","operator":"!=","rightExpression":{"arguments":[{"hexValue":"30","id":58124,"isConstant":false,"isLValue":false,"isPure":true,"kind":"number","lValueRequested":false,"nodeType":"Literal","src":"11769:1:120","typeDescriptions":{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"},"value":"0"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"}],"id":58123,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"nodeType":"ElementaryTypeNameExpression","src":"11761:7:120","typeDescriptions":{"typeIdentifier":"t_type$_t_address_$","typeString":"type(address)"},"typeName":{"id":58122,"name":"address","nodeType":"ElementaryTypeName","src":"11761:7:120","typeDescriptions":{}}},"id":58125,"isConstant":false,"isLValue":false,"isPure":true,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"11761:10:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"src":"11734:37:120","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},{"hexValue":"4665746368436861696e496e666f4f75747075743a206f70436861696e50726f787941646d696e4f776e6572206e6f7420736574","id":58127,"isConstant":false,"isLValue":false,"isPure":true,"kind":"string","lValueRequested":false,"nodeType":"Literal","src":"11773:54:120","typeDescriptions":{"typeIdentifier":"t_stringliteral_cc12cbf05d2d853ebebe6e25c8b02d2f78d6af131087a61088362ca7d0befc81","typeString":"literal_string \"FetchChainInfoOutput: opChainProxyAdminOwner not set\""},"value":"FetchChainInfoOutput: opChainProxyAdminOwner not set"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_bool","typeString":"bool"},{"typeIdentifier":"t_stringliteral_cc12cbf05d2d853ebebe6e25c8b02d2f78d6af131087a61088362ca7d0befc81","typeString":"literal_string \"FetchChainInfoOutput: opChainProxyAdminOwner not set\""}],"id":58120,"name":"require","nodeType":"Identifier","overloadedDeclarations":[-18,-18],"referencedDeclaration":-18,"src":"11726:7:120","typeDescriptions":{"typeIdentifier":"t_function_require_pure$_t_bool_$_t_string_memory_ptr_$returns$__$","typeString":"function (bool,string memory) pure"}},"id":58128,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"11726:102:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":58129,"nodeType":"ExpressionStatement","src":"11726:102:120"},{"expression":{"id":58130,"name":"_opChainProxyAdminOwner","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57451,"src":"11845:23:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"functionReturnParameters":58119,"id":58131,"nodeType":"Return","src":"11838:30:120"}]},"functionSelector":"1480f0cc","implemented":true,"kind":"function","modifiers":[],"name":"opChainProxyAdminOwner","nameLocation":"11661:22:120","parameters":{"id":58116,"nodeType":"ParameterList","parameters":[],"src":"11683:2:120"},"returnParameters":{"id":58119,"nodeType":"ParameterList","parameters":[{"constant":false,"id":58118,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":58133,"src":"11707:7:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":58117,"name":"address","nodeType":"ElementaryTypeName","src":"11707:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"11706:9:120"},"scope":58249,"stateMutability":"view","virtual":false,"visibility":"public"},{"id":58151,"nodeType":"FunctionDefinition","src":"11881:195:120","nodes":[],"body":{"id":58150,"nodeType":"Block","src":"11938:138:120","nodes":[],"statements":[{"expression":{"arguments":[{"commonType":{"typeIdentifier":"t_address","typeString":"address"},"id":58144,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftExpression":{"id":58139,"name":"_opChainGuardian","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57453,"src":"11956:16:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"BinaryOperation","operator":"!=","rightExpression":{"arguments":[{"hexValue":"30","id":58142,"isConstant":false,"isLValue":false,"isPure":true,"kind":"number","lValueRequested":false,"nodeType":"Literal","src":"11984:1:120","typeDescriptions":{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"},"value":"0"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"}],"id":58141,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"nodeType":"ElementaryTypeNameExpression","src":"11976:7:120","typeDescriptions":{"typeIdentifier":"t_type$_t_address_$","typeString":"type(address)"},"typeName":{"id":58140,"name":"address","nodeType":"ElementaryTypeName","src":"11976:7:120","typeDescriptions":{}}},"id":58143,"isConstant":false,"isLValue":false,"isPure":true,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"11976:10:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"src":"11956:30:120","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},{"hexValue":"4665746368436861696e496e666f4f75747075743a206f70436861696e477561726469616e206e6f7420736574","id":58145,"isConstant":false,"isLValue":false,"isPure":true,"kind":"string","lValueRequested":false,"nodeType":"Literal","src":"11988:47:120","typeDescriptions":{"typeIdentifier":"t_stringliteral_ab71487628da5c56ff40f228ee915a62d6c0a28ab899f48f84343df6dbc48bb7","typeString":"literal_string \"FetchChainInfoOutput: opChainGuardian not set\""},"value":"FetchChainInfoOutput: opChainGuardian not set"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_bool","typeString":"bool"},{"typeIdentifier":"t_stringliteral_ab71487628da5c56ff40f228ee915a62d6c0a28ab899f48f84343df6dbc48bb7","typeString":"literal_string \"FetchChainInfoOutput: opChainGuardian not set\""}],"id":58138,"name":"require","nodeType":"Identifier","overloadedDeclarations":[-18,-18],"referencedDeclaration":-18,"src":"11948:7:120","typeDescriptions":{"typeIdentifier":"t_function_require_pure$_t_bool_$_t_string_memory_ptr_$returns$__$","typeString":"function (bool,string memory) pure"}},"id":58146,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"11948:88:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":58147,"nodeType":"ExpressionStatement","src":"11948:88:120"},{"expression":{"id":58148,"name":"_opChainGuardian","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57453,"src":"12053:16:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"functionReturnParameters":58137,"id":58149,"nodeType":"Return","src":"12046:23:120"}]},"functionSelector":"4bc2695f","implemented":true,"kind":"function","modifiers":[],"name":"opChainGuardian","nameLocation":"11890:15:120","parameters":{"id":58134,"nodeType":"ParameterList","parameters":[],"src":"11905:2:120"},"returnParameters":{"id":58137,"nodeType":"ParameterList","parameters":[{"constant":false,"id":58136,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":58151,"src":"11929:7:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":58135,"name":"address","nodeType":"ElementaryTypeName","src":"11929:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"11928:9:120"},"scope":58249,"stateMutability":"view","virtual":false,"visibility":"public"},{"id":58169,"nodeType":"FunctionDefinition","src":"12082:175:120","nodes":[],"body":{"id":58168,"nodeType":"Block","src":"12134:123:120","nodes":[],"statements":[{"expression":{"arguments":[{"commonType":{"typeIdentifier":"t_address","typeString":"address"},"id":58162,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftExpression":{"id":58157,"name":"_challenger","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57455,"src":"12152:11:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"BinaryOperation","operator":"!=","rightExpression":{"arguments":[{"hexValue":"30","id":58160,"isConstant":false,"isLValue":false,"isPure":true,"kind":"number","lValueRequested":false,"nodeType":"Literal","src":"12175:1:120","typeDescriptions":{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"},"value":"0"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"}],"id":58159,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"nodeType":"ElementaryTypeNameExpression","src":"12167:7:120","typeDescriptions":{"typeIdentifier":"t_type$_t_address_$","typeString":"type(address)"},"typeName":{"id":58158,"name":"address","nodeType":"ElementaryTypeName","src":"12167:7:120","typeDescriptions":{}}},"id":58161,"isConstant":false,"isLValue":false,"isPure":true,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"12167:10:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"src":"12152:25:120","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},{"hexValue":"4665746368436861696e496e666f4f75747075743a206368616c6c656e676572206e6f7420736574","id":58163,"isConstant":false,"isLValue":false,"isPure":true,"kind":"string","lValueRequested":false,"nodeType":"Literal","src":"12179:42:120","typeDescriptions":{"typeIdentifier":"t_stringliteral_d1dd717c39956ee86b1eb77b9f3cb6dbeca6df99b330f67dd364a35a1174c2ce","typeString":"literal_string \"FetchChainInfoOutput: challenger not set\""},"value":"FetchChainInfoOutput: challenger not set"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_bool","typeString":"bool"},{"typeIdentifier":"t_stringliteral_d1dd717c39956ee86b1eb77b9f3cb6dbeca6df99b330f67dd364a35a1174c2ce","typeString":"literal_string \"FetchChainInfoOutput: challenger not set\""}],"id":58156,"name":"require","nodeType":"Identifier","overloadedDeclarations":[-18,-18],"referencedDeclaration":-18,"src":"12144:7:120","typeDescriptions":{"typeIdentifier":"t_function_require_pure$_t_bool_$_t_string_memory_ptr_$returns$__$","typeString":"function (bool,string memory) pure"}},"id":58164,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"12144:78:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":58165,"nodeType":"ExpressionStatement","src":"12144:78:120"},{"expression":{"id":58166,"name":"_challenger","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57455,"src":"12239:11:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"functionReturnParameters":58155,"id":58167,"nodeType":"Return","src":"12232:18:120"}]},"functionSelector":"534db0e2","implemented":true,"kind":"function","modifiers":[],"name":"challenger","nameLocation":"12091:10:120","parameters":{"id":58152,"nodeType":"ParameterList","parameters":[],"src":"12101:2:120"},"returnParameters":{"id":58155,"nodeType":"ParameterList","parameters":[{"constant":false,"id":58154,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":58169,"src":"12125:7:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":58153,"name":"address","nodeType":"ElementaryTypeName","src":"12125:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"12124:9:120"},"scope":58249,"stateMutability":"view","virtual":false,"visibility":"public"},{"id":58187,"nodeType":"FunctionDefinition","src":"12263:167:120","nodes":[],"body":{"id":58186,"nodeType":"Block","src":"12313:117:120","nodes":[],"statements":[{"expression":{"arguments":[{"commonType":{"typeIdentifier":"t_address","typeString":"address"},"id":58180,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftExpression":{"id":58175,"name":"_proposer","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57457,"src":"12331:9:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"BinaryOperation","operator":"!=","rightExpression":{"arguments":[{"hexValue":"30","id":58178,"isConstant":false,"isLValue":false,"isPure":true,"kind":"number","lValueRequested":false,"nodeType":"Literal","src":"12352:1:120","typeDescriptions":{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"},"value":"0"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"}],"id":58177,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"nodeType":"ElementaryTypeNameExpression","src":"12344:7:120","typeDescriptions":{"typeIdentifier":"t_type$_t_address_$","typeString":"type(address)"},"typeName":{"id":58176,"name":"address","nodeType":"ElementaryTypeName","src":"12344:7:120","typeDescriptions":{}}},"id":58179,"isConstant":false,"isLValue":false,"isPure":true,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"12344:10:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"src":"12331:23:120","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},{"hexValue":"4665746368436861696e496e666f4f75747075743a2070726f706f736572206e6f7420736574","id":58181,"isConstant":false,"isLValue":false,"isPure":true,"kind":"string","lValueRequested":false,"nodeType":"Literal","src":"12356:40:120","typeDescriptions":{"typeIdentifier":"t_stringliteral_c4910753f64240b424591ec2bc873e5a728ff321d57cb1a353788ad2c385da71","typeString":"literal_string \"FetchChainInfoOutput: proposer not set\""},"value":"FetchChainInfoOutput: proposer not set"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_bool","typeString":"bool"},{"typeIdentifier":"t_stringliteral_c4910753f64240b424591ec2bc873e5a728ff321d57cb1a353788ad2c385da71","typeString":"literal_string \"FetchChainInfoOutput: proposer not set\""}],"id":58174,"name":"require","nodeType":"Identifier","overloadedDeclarations":[-18,-18],"referencedDeclaration":-18,"src":"12323:7:120","typeDescriptions":{"typeIdentifier":"t_function_require_pure$_t_bool_$_t_string_memory_ptr_$returns$__$","typeString":"function (bool,string memory) pure"}},"id":58182,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"12323:74:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":58183,"nodeType":"ExpressionStatement","src":"12323:74:120"},{"expression":{"id":58184,"name":"_proposer","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57457,"src":"12414:9:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"functionReturnParameters":58173,"id":58185,"nodeType":"Return","src":"12407:16:120"}]},"functionSelector":"a8e4fb90","implemented":true,"kind":"function","modifiers":[],"name":"proposer","nameLocation":"12272:8:120","parameters":{"id":58170,"nodeType":"ParameterList","parameters":[],"src":"12280:2:120"},"returnParameters":{"id":58173,"nodeType":"ParameterList","parameters":[{"constant":false,"id":58172,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":58187,"src":"12304:7:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":58171,"name":"address","nodeType":"ElementaryTypeName","src":"12304:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"12303:9:120"},"scope":58249,"stateMutability":"view","virtual":false,"visibility":"public"},{"id":58205,"nodeType":"FunctionDefinition","src":"12436:203:120","nodes":[],"body":{"id":58204,"nodeType":"Block","src":"12495:144:120","nodes":[],"statements":[{"expression":{"arguments":[{"commonType":{"typeIdentifier":"t_address","typeString":"address"},"id":58198,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftExpression":{"id":58193,"name":"_unsafeBlockSigner","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57459,"src":"12513:18:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"BinaryOperation","operator":"!=","rightExpression":{"arguments":[{"hexValue":"30","id":58196,"isConstant":false,"isLValue":false,"isPure":true,"kind":"number","lValueRequested":false,"nodeType":"Literal","src":"12543:1:120","typeDescriptions":{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"},"value":"0"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"}],"id":58195,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"nodeType":"ElementaryTypeNameExpression","src":"12535:7:120","typeDescriptions":{"typeIdentifier":"t_type$_t_address_$","typeString":"type(address)"},"typeName":{"id":58194,"name":"address","nodeType":"ElementaryTypeName","src":"12535:7:120","typeDescriptions":{}}},"id":58197,"isConstant":false,"isLValue":false,"isPure":true,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"12535:10:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"src":"12513:32:120","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},{"hexValue":"4665746368436861696e496e666f4f75747075743a20756e73616665426c6f636b5369676e6572206e6f7420736574","id":58199,"isConstant":false,"isLValue":false,"isPure":true,"kind":"string","lValueRequested":false,"nodeType":"Literal","src":"12547:49:120","typeDescriptions":{"typeIdentifier":"t_stringliteral_c0c85432d1596fb73656e29b64f6ea745166dde4a7fa6163bfe6b285aea851d7","typeString":"literal_string \"FetchChainInfoOutput: unsafeBlockSigner not set\""},"value":"FetchChainInfoOutput: unsafeBlockSigner not set"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_bool","typeString":"bool"},{"typeIdentifier":"t_stringliteral_c0c85432d1596fb73656e29b64f6ea745166dde4a7fa6163bfe6b285aea851d7","typeString":"literal_string \"FetchChainInfoOutput: unsafeBlockSigner not set\""}],"id":58192,"name":"require","nodeType":"Identifier","overloadedDeclarations":[-18,-18],"referencedDeclaration":-18,"src":"12505:7:120","typeDescriptions":{"typeIdentifier":"t_function_require_pure$_t_bool_$_t_string_memory_ptr_$returns$__$","typeString":"function (bool,string memory) pure"}},"id":58200,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"12505:92:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":58201,"nodeType":"ExpressionStatement","src":"12505:92:120"},{"expression":{"id":58202,"name":"_unsafeBlockSigner","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57459,"src":"12614:18:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"functionReturnParameters":58191,"id":58203,"nodeType":"Return","src":"12607:25:120"}]},"functionSelector":"1fd19ee1","implemented":true,"kind":"function","modifiers":[],"name":"unsafeBlockSigner","nameLocation":"12445:17:120","parameters":{"id":58188,"nodeType":"ParameterList","parameters":[],"src":"12462:2:120"},"returnParameters":{"id":58191,"nodeType":"ParameterList","parameters":[{"constant":false,"id":58190,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":58205,"src":"12486:7:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":58189,"name":"address","nodeType":"ElementaryTypeName","src":"12486:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"12485:9:120"},"scope":58249,"stateMutability":"view","virtual":false,"visibility":"public"},{"id":58223,"nodeType":"FunctionDefinition","src":"12645:191:120","nodes":[],"body":{"id":58222,"nodeType":"Block","src":"12701:135:120","nodes":[],"statements":[{"expression":{"arguments":[{"commonType":{"typeIdentifier":"t_address","typeString":"address"},"id":58216,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftExpression":{"id":58211,"name":"_batchSubmitter","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57461,"src":"12719:15:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"BinaryOperation","operator":"!=","rightExpression":{"arguments":[{"hexValue":"30","id":58214,"isConstant":false,"isLValue":false,"isPure":true,"kind":"number","lValueRequested":false,"nodeType":"Literal","src":"12746:1:120","typeDescriptions":{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"},"value":"0"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"}],"id":58213,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"nodeType":"ElementaryTypeNameExpression","src":"12738:7:120","typeDescriptions":{"typeIdentifier":"t_type$_t_address_$","typeString":"type(address)"},"typeName":{"id":58212,"name":"address","nodeType":"ElementaryTypeName","src":"12738:7:120","typeDescriptions":{}}},"id":58215,"isConstant":false,"isLValue":false,"isPure":true,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"12738:10:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"src":"12719:29:120","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},{"hexValue":"4665746368436861696e496e666f4f75747075743a2062617463685375626d6974746572206e6f7420736574","id":58217,"isConstant":false,"isLValue":false,"isPure":true,"kind":"string","lValueRequested":false,"nodeType":"Literal","src":"12750:46:120","typeDescriptions":{"typeIdentifier":"t_stringliteral_dc2094d90bbe21c62e4087e13d121e3f8b0b046ea0a70d61432535290d56a2cc","typeString":"literal_string \"FetchChainInfoOutput: batchSubmitter not set\""},"value":"FetchChainInfoOutput: batchSubmitter not set"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_bool","typeString":"bool"},{"typeIdentifier":"t_stringliteral_dc2094d90bbe21c62e4087e13d121e3f8b0b046ea0a70d61432535290d56a2cc","typeString":"literal_string \"FetchChainInfoOutput: batchSubmitter not set\""}],"id":58210,"name":"require","nodeType":"Identifier","overloadedDeclarations":[-18,-18],"referencedDeclaration":-18,"src":"12711:7:120","typeDescriptions":{"typeIdentifier":"t_function_require_pure$_t_bool_$_t_string_memory_ptr_$returns$__$","typeString":"function (bool,string memory) pure"}},"id":58218,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"12711:86:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":58219,"nodeType":"ExpressionStatement","src":"12711:86:120"},{"expression":{"id":58220,"name":"_batchSubmitter","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57461,"src":"12814:15:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"functionReturnParameters":58209,"id":58221,"nodeType":"Return","src":"12807:22:120"}]},"functionSelector":"fb951e9d","implemented":true,"kind":"function","modifiers":[],"name":"batchSubmitter","nameLocation":"12654:14:120","parameters":{"id":58206,"nodeType":"ParameterList","parameters":[],"src":"12668:2:120"},"returnParameters":{"id":58209,"nodeType":"ParameterList","parameters":[{"constant":false,"id":58208,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":58223,"src":"12692:7:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":58207,"name":"address","nodeType":"ElementaryTypeName","src":"12692:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"12691:9:120"},"scope":58249,"stateMutability":"view","virtual":false,"visibility":"public"},{"id":58231,"nodeType":"FunctionDefinition","src":"12842:88:120","nodes":[],"body":{"id":58230,"nodeType":"Block","src":"12893:37:120","nodes":[],"statements":[{"expression":{"id":58228,"name":"_permissioned","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57463,"src":"12910:13:120","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},"functionReturnParameters":58227,"id":58229,"nodeType":"Return","src":"12903:20:120"}]},"functionSelector":"3cc162f1","implemented":true,"kind":"function","modifiers":[],"name":"permissioned","nameLocation":"12851:12:120","parameters":{"id":58224,"nodeType":"ParameterList","parameters":[],"src":"12863:2:120"},"returnParameters":{"id":58227,"nodeType":"ParameterList","parameters":[{"constant":false,"id":58226,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":58231,"src":"12887:4:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"},"typeName":{"id":58225,"name":"bool","nodeType":"ElementaryTypeName","src":"12887:4:120","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},"visibility":"internal"}],"src":"12886:6:120"},"scope":58249,"stateMutability":"view","virtual":false,"visibility":"public"},{"id":58239,"nodeType":"FunctionDefinition","src":"12936:92:120","nodes":[],"body":{"id":58238,"nodeType":"Block","src":"12989:39:120","nodes":[],"statements":[{"expression":{"id":58236,"name":"_permissionless","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57465,"src":"13006:15:120","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},"functionReturnParameters":58235,"id":58237,"nodeType":"Return","src":"12999:22:120"}]},"functionSelector":"a1256f9f","implemented":true,"kind":"function","modifiers":[],"name":"permissionless","nameLocation":"12945:14:120","parameters":{"id":58232,"nodeType":"ParameterList","parameters":[],"src":"12959:2:120"},"returnParameters":{"id":58235,"nodeType":"ParameterList","parameters":[{"constant":false,"id":58234,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":58239,"src":"12983:4:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"},"typeName":{"id":58233,"name":"bool","nodeType":"ElementaryTypeName","src":"12983:4:120","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},"visibility":"internal"}],"src":"12982:6:120"},"scope":58249,"stateMutability":"view","virtual":false,"visibility":"public"},{"id":58248,"nodeType":"FunctionDefinition","src":"13034:102:120","nodes":[],"body":{"id":58247,"nodeType":"Block","src":"13094:42:120","nodes":[],"statements":[{"expression":{"id":58245,"name":"_respectedGameType","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57468,"src":"13111:18:120","typeDescriptions":{"typeIdentifier":"t_userDefinedValueType$_GameType_$75355","typeString":"GameType"}},"functionReturnParameters":58244,"id":58246,"nodeType":"Return","src":"13104:25:120"}]},"functionSelector":"3c9f397c","implemented":true,"kind":"function","modifiers":[],"name":"respectedGameType","nameLocation":"13043:17:120","parameters":{"id":58240,"nodeType":"ParameterList","parameters":[],"src":"13060:2:120"},"returnParameters":{"id":58244,"nodeType":"ParameterList","parameters":[{"constant":false,"id":58243,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":58248,"src":"13084:8:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_userDefinedValueType$_GameType_$75355","typeString":"GameType"},"typeName":{"id":58242,"nodeType":"UserDefinedTypeName","pathNode":{"id":58241,"name":"GameType","nameLocations":["13084:8:120"],"nodeType":"IdentifierPath","referencedDeclaration":75355,"src":"13084:8:120"},"referencedDeclaration":75355,"src":"13084:8:120","typeDescriptions":{"typeIdentifier":"t_userDefinedValueType$_GameType_$75355","typeString":"GameType"}},"visibility":"internal"}],"src":"13083:10:120"},"scope":58249,"stateMutability":"view","virtual":false,"visibility":"public"}],"abstract":false,"baseContracts":[],"canonicalName":"FetchChainInfoOutput","contractDependencies":[],"contractKind":"contract","fullyImplemented":true,"linearizedBaseContracts":[58249],"name":"FetchChainInfoOutput","nameLocation":"2966:20:120","scope":59300,"usedErrors":[],"usedEvents":[]},{"id":59299,"nodeType":"ContractDefinition","src":"13140:10848:120","nodes":[{"id":58275,"nodeType":"FunctionDefinition","src":"13180:198:120","nodes":[],"body":{"id":58274,"nodeType":"Block","src":"13251:127:120","nodes":[],"statements":[{"expression":{"arguments":[{"id":58261,"name":"_fi","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58254,"src":"13282:3:120","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoInput_$57409","typeString":"contract FetchChainInfoInput"}},{"id":58262,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58257,"src":"13287:3:120","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$58249","typeString":"contract FetchChainInfoOutput"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_contract$_FetchChainInfoInput_$57409","typeString":"contract FetchChainInfoInput"},{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$58249","typeString":"contract FetchChainInfoOutput"}],"id":58260,"name":"_processSystemConfig","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58411,"src":"13261:20:120","typeDescriptions":{"typeIdentifier":"t_function_internal_nonpayable$_t_contract$_FetchChainInfoInput_$57409_$_t_contract$_FetchChainInfoOutput_$58249_$returns$__$","typeString":"function (contract FetchChainInfoInput,contract FetchChainInfoOutput)"}},"id":58263,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"13261:30:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":58264,"nodeType":"ExpressionStatement","src":"13261:30:120"},{"expression":{"arguments":[{"id":58266,"name":"_fi","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58254,"src":"13328:3:120","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoInput_$57409","typeString":"contract FetchChainInfoInput"}},{"id":58267,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58257,"src":"13333:3:120","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$58249","typeString":"contract FetchChainInfoOutput"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_contract$_FetchChainInfoInput_$57409","typeString":"contract FetchChainInfoInput"},{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$58249","typeString":"contract FetchChainInfoOutput"}],"id":58265,"name":"_processMessengerAndPortal","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58528,"src":"13301:26:120","typeDescriptions":{"typeIdentifier":"t_function_internal_nonpayable$_t_contract$_FetchChainInfoInput_$57409_$_t_contract$_FetchChainInfoOutput_$58249_$returns$__$","typeString":"function (contract FetchChainInfoInput,contract FetchChainInfoOutput)"}},"id":58268,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"13301:36:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":58269,"nodeType":"ExpressionStatement","src":"13301:36:120"},{"expression":{"arguments":[{"id":58271,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58257,"src":"13367:3:120","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$58249","typeString":"contract FetchChainInfoOutput"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$58249","typeString":"contract FetchChainInfoOutput"}],"id":58270,"name":"_processFaultProofs","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58878,"src":"13347:19:120","typeDescriptions":{"typeIdentifier":"t_function_internal_nonpayable$_t_contract$_FetchChainInfoOutput_$58249_$returns$__$","typeString":"function (contract FetchChainInfoOutput)"}},"id":58272,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"13347:24:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":58273,"nodeType":"ExpressionStatement","src":"13347:24:120"}]},"functionSelector":"fc4dcacb","implemented":true,"kind":"function","modifiers":[],"name":"run","nameLocation":"13189:3:120","parameters":{"id":58258,"nodeType":"ParameterList","parameters":[{"constant":false,"id":58254,"mutability":"mutable","name":"_fi","nameLocation":"13213:3:120","nodeType":"VariableDeclaration","scope":58275,"src":"13193:23:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoInput_$57409","typeString":"contract FetchChainInfoInput"},"typeName":{"id":58253,"nodeType":"UserDefinedTypeName","pathNode":{"id":58252,"name":"FetchChainInfoInput","nameLocations":["13193:19:120"],"nodeType":"IdentifierPath","referencedDeclaration":57409,"src":"13193:19:120"},"referencedDeclaration":57409,"src":"13193:19:120","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoInput_$57409","typeString":"contract FetchChainInfoInput"}},"visibility":"internal"},{"constant":false,"id":58257,"mutability":"mutable","name":"_fo","nameLocation":"13239:3:120","nodeType":"VariableDeclaration","scope":58275,"src":"13218:24:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$58249","typeString":"contract FetchChainInfoOutput"},"typeName":{"id":58256,"nodeType":"UserDefinedTypeName","pathNode":{"id":58255,"name":"FetchChainInfoOutput","nameLocations":["13218:20:120"],"nodeType":"IdentifierPath","referencedDeclaration":58249,"src":"13218:20:120"},"referencedDeclaration":58249,"src":"13218:20:120","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$58249","typeString":"contract FetchChainInfoOutput"}},"visibility":"internal"}],"src":"13192:51:120"},"returnParameters":{"id":58259,"nodeType":"ParameterList","parameters":[],"src":"13251:0:120"},"scope":59299,"stateMutability":"nonpayable","virtual":false,"visibility":"public"},{"id":58411,"nodeType":"FunctionDefinition","src":"13384:1336:120","nodes":[],"body":{"id":58410,"nodeType":"Block","src":"13474:1246:120","nodes":[],"statements":[{"assignments":[58285],"declarations":[{"constant":false,"id":58285,"mutability":"mutable","name":"systemConfigProxy","nameLocation":"13492:17:120","nodeType":"VariableDeclaration","scope":58410,"src":"13484:25:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":58284,"name":"address","nodeType":"ElementaryTypeName","src":"13484:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"id":58289,"initialValue":{"arguments":[],"expression":{"argumentTypes":[],"expression":{"id":58286,"name":"_fi","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58278,"src":"13512:3:120","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoInput_$57409","typeString":"contract FetchChainInfoInput"}},"id":58287,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"13516:17:120","memberName":"systemConfigProxy","nodeType":"MemberAccess","referencedDeclaration":57390,"src":"13512:21:120","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":58288,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"13512:23:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"VariableDeclarationStatement","src":"13484:51:120"},{"expression":{"arguments":[{"expression":{"expression":{"id":58293,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58281,"src":"13553:3:120","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$58249","typeString":"contract FetchChainInfoOutput"}},"id":58294,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"13557:17:120","memberName":"systemConfigProxy","nodeType":"MemberAccess","referencedDeclaration":57947,"src":"13553:21:120","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":58295,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"13575:8:120","memberName":"selector","nodeType":"MemberAccess","src":"13553:30:120","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},{"id":58296,"name":"systemConfigProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58285,"src":"13585:17:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_bytes4","typeString":"bytes4"},{"typeIdentifier":"t_address","typeString":"address"}],"expression":{"id":58290,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58281,"src":"13545:3:120","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$58249","typeString":"contract FetchChainInfoOutput"}},"id":58292,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"13549:3:120","memberName":"set","nodeType":"MemberAccess","referencedDeclaration":57740,"src":"13545:7:120","typeDescriptions":{"typeIdentifier":"t_function_external_nonpayable$_t_bytes4_$_t_address_$returns$__$","typeString":"function (bytes4,address) external"}},"id":58297,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"13545:58:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":58298,"nodeType":"ExpressionStatement","src":"13545:58:120"},{"assignments":[58300],"declarations":[{"constant":false,"id":58300,"mutability":"mutable","name":"systemConfigOwner","nameLocation":"13622:17:120","nodeType":"VariableDeclaration","scope":58410,"src":"13614:25:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":58299,"name":"address","nodeType":"ElementaryTypeName","src":"13614:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"id":58306,"initialValue":{"arguments":[],"expression":{"argumentTypes":[],"expression":{"arguments":[{"id":58302,"name":"systemConfigProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58285,"src":"13651:17:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_address","typeString":"address"}],"id":58301,"name":"IFetcher","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57326,"src":"13642:8:120","typeDescriptions":{"typeIdentifier":"t_type$_t_contract$_IFetcher_$57326_$","typeString":"type(contract IFetcher)"}},"id":58303,"isConstant":false,"isLValue":false,"isPure":false,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"13642:27:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_contract$_IFetcher_$57326","typeString":"contract IFetcher"}},"id":58304,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"13670:5:120","memberName":"owner","nodeType":"MemberAccess","referencedDeclaration":57315,"src":"13642:33:120","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":58305,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"13642:35:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"VariableDeclarationStatement","src":"13614:63:120"},{"expression":{"arguments":[{"expression":{"expression":{"id":58310,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58281,"src":"13695:3:120","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$58249","typeString":"contract FetchChainInfoOutput"}},"id":58311,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"13699:17:120","memberName":"systemConfigOwner","nodeType":"MemberAccess","referencedDeclaration":58115,"src":"13695:21:120","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":58312,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"13717:8:120","memberName":"selector","nodeType":"MemberAccess","src":"13695:30:120","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},{"id":58313,"name":"systemConfigOwner","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58300,"src":"13727:17:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_bytes4","typeString":"bytes4"},{"typeIdentifier":"t_address","typeString":"address"}],"expression":{"id":58307,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58281,"src":"13687:3:120","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$58249","typeString":"contract FetchChainInfoOutput"}},"id":58309,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"13691:3:120","memberName":"set","nodeType":"MemberAccess","referencedDeclaration":57740,"src":"13687:7:120","typeDescriptions":{"typeIdentifier":"t_function_external_nonpayable$_t_bytes4_$_t_address_$returns$__$","typeString":"function (bytes4,address) external"}},"id":58314,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"13687:58:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":58315,"nodeType":"ExpressionStatement","src":"13687:58:120"},{"assignments":[58317],"declarations":[{"constant":false,"id":58317,"mutability":"mutable","name":"unsafeBlockSigner","nameLocation":"13764:17:120","nodeType":"VariableDeclaration","scope":58410,"src":"13756:25:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":58316,"name":"address","nodeType":"ElementaryTypeName","src":"13756:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"id":58323,"initialValue":{"arguments":[],"expression":{"argumentTypes":[],"expression":{"arguments":[{"id":58319,"name":"systemConfigProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58285,"src":"13793:17:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_address","typeString":"address"}],"id":58318,"name":"IFetcher","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57326,"src":"13784:8:120","typeDescriptions":{"typeIdentifier":"t_type$_t_contract$_IFetcher_$57326_$","typeString":"type(contract IFetcher)"}},"id":58320,"isConstant":false,"isLValue":false,"isPure":false,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"13784:27:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_contract$_IFetcher_$57326","typeString":"contract IFetcher"}},"id":58321,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"13812:17:120","memberName":"unsafeBlockSigner","nodeType":"MemberAccess","referencedDeclaration":57320,"src":"13784:45:120","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":58322,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"13784:47:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"VariableDeclarationStatement","src":"13756:75:120"},{"expression":{"arguments":[{"expression":{"expression":{"id":58327,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58281,"src":"13849:3:120","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$58249","typeString":"contract FetchChainInfoOutput"}},"id":58328,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"13853:17:120","memberName":"unsafeBlockSigner","nodeType":"MemberAccess","referencedDeclaration":58205,"src":"13849:21:120","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":58329,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"13871:8:120","memberName":"selector","nodeType":"MemberAccess","src":"13849:30:120","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},{"id":58330,"name":"unsafeBlockSigner","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58317,"src":"13881:17:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_bytes4","typeString":"bytes4"},{"typeIdentifier":"t_address","typeString":"address"}],"expression":{"id":58324,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58281,"src":"13841:3:120","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$58249","typeString":"contract FetchChainInfoOutput"}},"id":58326,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"13845:3:120","memberName":"set","nodeType":"MemberAccess","referencedDeclaration":57740,"src":"13841:7:120","typeDescriptions":{"typeIdentifier":"t_function_external_nonpayable$_t_bytes4_$_t_address_$returns$__$","typeString":"function (bytes4,address) external"}},"id":58331,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"13841:58:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":58332,"nodeType":"ExpressionStatement","src":"13841:58:120"},{"assignments":[58334],"declarations":[{"constant":false,"id":58334,"mutability":"mutable","name":"batchSubmitter","nameLocation":"13918:14:120","nodeType":"VariableDeclaration","scope":58410,"src":"13910:22:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":58333,"name":"address","nodeType":"ElementaryTypeName","src":"13910:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"id":58338,"initialValue":{"arguments":[{"id":58336,"name":"systemConfigProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58285,"src":"13954:17:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_address","typeString":"address"}],"id":58335,"name":"_getBatchSubmitter","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":59275,"src":"13935:18:120","typeDescriptions":{"typeIdentifier":"t_function_internal_view$_t_address_$returns$_t_address_$","typeString":"function (address) view returns (address)"}},"id":58337,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"13935:37:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"VariableDeclarationStatement","src":"13910:62:120"},{"expression":{"arguments":[{"expression":{"expression":{"id":58342,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58281,"src":"13990:3:120","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$58249","typeString":"contract FetchChainInfoOutput"}},"id":58343,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"13994:14:120","memberName":"batchSubmitter","nodeType":"MemberAccess","referencedDeclaration":58223,"src":"13990:18:120","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":58344,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"14009:8:120","memberName":"selector","nodeType":"MemberAccess","src":"13990:27:120","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},{"id":58345,"name":"batchSubmitter","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58334,"src":"14019:14:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_bytes4","typeString":"bytes4"},{"typeIdentifier":"t_address","typeString":"address"}],"expression":{"id":58339,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58281,"src":"13982:3:120","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$58249","typeString":"contract FetchChainInfoOutput"}},"id":58341,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"13986:3:120","memberName":"set","nodeType":"MemberAccess","referencedDeclaration":57740,"src":"13982:7:120","typeDescriptions":{"typeIdentifier":"t_function_external_nonpayable$_t_bytes4_$_t_address_$returns$__$","typeString":"function (bytes4,address) external"}},"id":58346,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"13982:52:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":58347,"nodeType":"ExpressionStatement","src":"13982:52:120"},{"assignments":[58349],"declarations":[{"constant":false,"id":58349,"mutability":"mutable","name":"opChainProxyAdminImpl","nameLocation":"14053:21:120","nodeType":"VariableDeclaration","scope":58410,"src":"14045:29:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":58348,"name":"address","nodeType":"ElementaryTypeName","src":"14045:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"id":58353,"initialValue":{"arguments":[{"id":58351,"name":"systemConfigProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58285,"src":"14092:17:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_address","typeString":"address"}],"id":58350,"name":"_getProxyAdmin","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":59298,"src":"14077:14:120","typeDescriptions":{"typeIdentifier":"t_function_internal_nonpayable$_t_address_$returns$_t_address_$","typeString":"function (address) returns (address)"}},"id":58352,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"14077:33:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"VariableDeclarationStatement","src":"14045:65:120"},{"expression":{"arguments":[{"expression":{"expression":{"id":58357,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58281,"src":"14128:3:120","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$58249","typeString":"contract FetchChainInfoOutput"}},"id":58358,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"14132:21:120","memberName":"opChainProxyAdminImpl","nodeType":"MemberAccess","referencedDeclaration":57965,"src":"14128:25:120","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":58359,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"14154:8:120","memberName":"selector","nodeType":"MemberAccess","src":"14128:34:120","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},{"id":58360,"name":"opChainProxyAdminImpl","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58349,"src":"14164:21:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_bytes4","typeString":"bytes4"},{"typeIdentifier":"t_address","typeString":"address"}],"expression":{"id":58354,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58281,"src":"14120:3:120","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$58249","typeString":"contract FetchChainInfoOutput"}},"id":58356,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"14124:3:120","memberName":"set","nodeType":"MemberAccess","referencedDeclaration":57740,"src":"14120:7:120","typeDescriptions":{"typeIdentifier":"t_function_external_nonpayable$_t_bytes4_$_t_address_$returns$__$","typeString":"function (bytes4,address) external"}},"id":58361,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"14120:66:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":58362,"nodeType":"ExpressionStatement","src":"14120:66:120"},{"assignments":[58364],"declarations":[{"constant":false,"id":58364,"mutability":"mutable","name":"opChainProxyAdminOwner","nameLocation":"14205:22:120","nodeType":"VariableDeclaration","scope":58410,"src":"14197:30:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":58363,"name":"address","nodeType":"ElementaryTypeName","src":"14197:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"id":58370,"initialValue":{"arguments":[],"expression":{"argumentTypes":[],"expression":{"arguments":[{"id":58366,"name":"opChainProxyAdminImpl","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58349,"src":"14239:21:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_address","typeString":"address"}],"id":58365,"name":"IFetcher","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57326,"src":"14230:8:120","typeDescriptions":{"typeIdentifier":"t_type$_t_contract$_IFetcher_$57326_$","typeString":"type(contract IFetcher)"}},"id":58367,"isConstant":false,"isLValue":false,"isPure":false,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"14230:31:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_contract$_IFetcher_$57326","typeString":"contract IFetcher"}},"id":58368,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"14262:5:120","memberName":"owner","nodeType":"MemberAccess","referencedDeclaration":57315,"src":"14230:37:120","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":58369,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"14230:39:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"VariableDeclarationStatement","src":"14197:72:120"},{"expression":{"arguments":[{"expression":{"expression":{"id":58374,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58281,"src":"14287:3:120","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$58249","typeString":"contract FetchChainInfoOutput"}},"id":58375,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"14291:22:120","memberName":"opChainProxyAdminOwner","nodeType":"MemberAccess","referencedDeclaration":58133,"src":"14287:26:120","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":58376,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"14314:8:120","memberName":"selector","nodeType":"MemberAccess","src":"14287:35:120","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},{"id":58377,"name":"opChainProxyAdminOwner","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58364,"src":"14324:22:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_bytes4","typeString":"bytes4"},{"typeIdentifier":"t_address","typeString":"address"}],"expression":{"id":58371,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58281,"src":"14279:3:120","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$58249","typeString":"contract FetchChainInfoOutput"}},"id":58373,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"14283:3:120","memberName":"set","nodeType":"MemberAccess","referencedDeclaration":57740,"src":"14279:7:120","typeDescriptions":{"typeIdentifier":"t_function_external_nonpayable$_t_bytes4_$_t_address_$returns$__$","typeString":"function (bytes4,address) external"}},"id":58378,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"14279:68:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":58379,"nodeType":"ExpressionStatement","src":"14279:68:120"},{"assignments":[58381],"declarations":[{"constant":false,"id":58381,"mutability":"mutable","name":"l1Erc721BridgeProxy","nameLocation":"14366:19:120","nodeType":"VariableDeclaration","scope":58410,"src":"14358:27:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":58380,"name":"address","nodeType":"ElementaryTypeName","src":"14358:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"id":58385,"initialValue":{"arguments":[{"id":58383,"name":"systemConfigProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58285,"src":"14412:17:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_address","typeString":"address"}],"id":58382,"name":"_getL1ERC721BridgeProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":59031,"src":"14388:23:120","typeDescriptions":{"typeIdentifier":"t_function_internal_view$_t_address_$returns$_t_address_$","typeString":"function (address) view returns (address)"}},"id":58384,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"14388:42:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"VariableDeclarationStatement","src":"14358:72:120"},{"expression":{"arguments":[{"expression":{"expression":{"id":58389,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58281,"src":"14448:3:120","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$58249","typeString":"contract FetchChainInfoOutput"}},"id":58390,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"14452:19:120","memberName":"l1Erc721BridgeProxy","nodeType":"MemberAccess","referencedDeclaration":57857,"src":"14448:23:120","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":58391,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"14472:8:120","memberName":"selector","nodeType":"MemberAccess","src":"14448:32:120","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},{"id":58392,"name":"l1Erc721BridgeProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58381,"src":"14482:19:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_bytes4","typeString":"bytes4"},{"typeIdentifier":"t_address","typeString":"address"}],"expression":{"id":58386,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58281,"src":"14440:3:120","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$58249","typeString":"contract FetchChainInfoOutput"}},"id":58388,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"14444:3:120","memberName":"set","nodeType":"MemberAccess","referencedDeclaration":57740,"src":"14440:7:120","typeDescriptions":{"typeIdentifier":"t_function_external_nonpayable$_t_bytes4_$_t_address_$returns$__$","typeString":"function (bytes4,address) external"}},"id":58393,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"14440:62:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":58394,"nodeType":"ExpressionStatement","src":"14440:62:120"},{"assignments":[58396],"declarations":[{"constant":false,"id":58396,"mutability":"mutable","name":"optimismMintableErc20FactoryProxy","nameLocation":"14521:33:120","nodeType":"VariableDeclaration","scope":58410,"src":"14513:41:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":58395,"name":"address","nodeType":"ElementaryTypeName","src":"14513:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"id":58400,"initialValue":{"arguments":[{"id":58398,"name":"systemConfigProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58285,"src":"14595:17:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_address","typeString":"address"}],"id":58397,"name":"_getOptimismMintableERC20FactoryProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":59059,"src":"14557:37:120","typeDescriptions":{"typeIdentifier":"t_function_internal_view$_t_address_$returns$_t_address_$","typeString":"function (address) view returns (address)"}},"id":58399,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"14557:56:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"VariableDeclarationStatement","src":"14513:100:120"},{"expression":{"arguments":[{"expression":{"expression":{"id":58404,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58281,"src":"14631:3:120","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$58249","typeString":"contract FetchChainInfoOutput"}},"id":58405,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"14635:33:120","memberName":"optimismMintableErc20FactoryProxy","nodeType":"MemberAccess","referencedDeclaration":57911,"src":"14631:37:120","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":58406,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"14669:8:120","memberName":"selector","nodeType":"MemberAccess","src":"14631:46:120","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},{"id":58407,"name":"optimismMintableErc20FactoryProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58396,"src":"14679:33:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_bytes4","typeString":"bytes4"},{"typeIdentifier":"t_address","typeString":"address"}],"expression":{"id":58401,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58281,"src":"14623:3:120","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$58249","typeString":"contract FetchChainInfoOutput"}},"id":58403,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"14627:3:120","memberName":"set","nodeType":"MemberAccess","referencedDeclaration":57740,"src":"14623:7:120","typeDescriptions":{"typeIdentifier":"t_function_external_nonpayable$_t_bytes4_$_t_address_$returns$__$","typeString":"function (bytes4,address) external"}},"id":58408,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"14623:90:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":58409,"nodeType":"ExpressionStatement","src":"14623:90:120"}]},"implemented":true,"kind":"function","modifiers":[],"name":"_processSystemConfig","nameLocation":"13393:20:120","parameters":{"id":58282,"nodeType":"ParameterList","parameters":[{"constant":false,"id":58278,"mutability":"mutable","name":"_fi","nameLocation":"13434:3:120","nodeType":"VariableDeclaration","scope":58411,"src":"13414:23:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoInput_$57409","typeString":"contract FetchChainInfoInput"},"typeName":{"id":58277,"nodeType":"UserDefinedTypeName","pathNode":{"id":58276,"name":"FetchChainInfoInput","nameLocations":["13414:19:120"],"nodeType":"IdentifierPath","referencedDeclaration":57409,"src":"13414:19:120"},"referencedDeclaration":57409,"src":"13414:19:120","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoInput_$57409","typeString":"contract FetchChainInfoInput"}},"visibility":"internal"},{"constant":false,"id":58281,"mutability":"mutable","name":"_fo","nameLocation":"13460:3:120","nodeType":"VariableDeclaration","scope":58411,"src":"13439:24:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$58249","typeString":"contract FetchChainInfoOutput"},"typeName":{"id":58280,"nodeType":"UserDefinedTypeName","pathNode":{"id":58279,"name":"FetchChainInfoOutput","nameLocations":["13439:20:120"],"nodeType":"IdentifierPath","referencedDeclaration":58249,"src":"13439:20:120"},"referencedDeclaration":58249,"src":"13439:20:120","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$58249","typeString":"contract FetchChainInfoOutput"}},"visibility":"internal"}],"src":"13413:51:120"},"returnParameters":{"id":58283,"nodeType":"ParameterList","parameters":[],"src":"13474:0:120"},"scope":59299,"stateMutability":"nonpayable","virtual":false,"visibility":"internal"},{"id":58528,"nodeType":"FunctionDefinition","src":"14726:1190:120","nodes":[],"body":{"id":58527,"nodeType":"Block","src":"14822:1094:120","nodes":[],"statements":[{"assignments":[58421],"declarations":[{"constant":false,"id":58421,"mutability":"mutable","name":"l1StandardBridgeProxy","nameLocation":"14840:21:120","nodeType":"VariableDeclaration","scope":58527,"src":"14832:29:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":58420,"name":"address","nodeType":"ElementaryTypeName","src":"14832:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"id":58425,"initialValue":{"arguments":[],"expression":{"argumentTypes":[],"expression":{"id":58422,"name":"_fi","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58414,"src":"14864:3:120","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoInput_$57409","typeString":"contract FetchChainInfoInput"}},"id":58423,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"14868:21:120","memberName":"l1StandardBridgeProxy","nodeType":"MemberAccess","referencedDeclaration":57408,"src":"14864:25:120","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":58424,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"14864:27:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"VariableDeclarationStatement","src":"14832:59:120"},{"expression":{"arguments":[{"expression":{"expression":{"id":58429,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58417,"src":"14909:3:120","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$58249","typeString":"contract FetchChainInfoOutput"}},"id":58430,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"14913:21:120","memberName":"l1StandardBridgeProxy","nodeType":"MemberAccess","referencedDeclaration":57875,"src":"14909:25:120","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":58431,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"14935:8:120","memberName":"selector","nodeType":"MemberAccess","src":"14909:34:120","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},{"id":58432,"name":"l1StandardBridgeProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58421,"src":"14945:21:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_bytes4","typeString":"bytes4"},{"typeIdentifier":"t_address","typeString":"address"}],"expression":{"id":58426,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58417,"src":"14901:3:120","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$58249","typeString":"contract FetchChainInfoOutput"}},"id":58428,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"14905:3:120","memberName":"set","nodeType":"MemberAccess","referencedDeclaration":57740,"src":"14901:7:120","typeDescriptions":{"typeIdentifier":"t_function_external_nonpayable$_t_bytes4_$_t_address_$returns$__$","typeString":"function (bytes4,address) external"}},"id":58433,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"14901:66:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":58434,"nodeType":"ExpressionStatement","src":"14901:66:120"},{"assignments":[58436],"declarations":[{"constant":false,"id":58436,"mutability":"mutable","name":"l1CrossDomainMessengerProxy","nameLocation":"14986:27:120","nodeType":"VariableDeclaration","scope":58527,"src":"14978:35:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":58435,"name":"address","nodeType":"ElementaryTypeName","src":"14978:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"id":58442,"initialValue":{"arguments":[],"expression":{"argumentTypes":[],"expression":{"arguments":[{"id":58438,"name":"l1StandardBridgeProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58421,"src":"15025:21:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_address","typeString":"address"}],"id":58437,"name":"IFetcher","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57326,"src":"15016:8:120","typeDescriptions":{"typeIdentifier":"t_type$_t_contract$_IFetcher_$57326_$","typeString":"type(contract IFetcher)"}},"id":58439,"isConstant":false,"isLValue":false,"isPure":false,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"15016:31:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_contract$_IFetcher_$57326","typeString":"contract IFetcher"}},"id":58440,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"15048:9:120","memberName":"messenger","nodeType":"MemberAccess","referencedDeclaration":57221,"src":"15016:41:120","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":58441,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"15016:43:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"VariableDeclarationStatement","src":"14978:81:120"},{"expression":{"arguments":[{"expression":{"expression":{"id":58446,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58417,"src":"15077:3:120","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$58249","typeString":"contract FetchChainInfoOutput"}},"id":58447,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"15081:27:120","memberName":"l1CrossDomainMessengerProxy","nodeType":"MemberAccess","referencedDeclaration":57839,"src":"15077:31:120","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":58448,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"15109:8:120","memberName":"selector","nodeType":"MemberAccess","src":"15077:40:120","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},{"id":58449,"name":"l1CrossDomainMessengerProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58436,"src":"15119:27:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_bytes4","typeString":"bytes4"},{"typeIdentifier":"t_address","typeString":"address"}],"expression":{"id":58443,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58417,"src":"15069:3:120","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$58249","typeString":"contract FetchChainInfoOutput"}},"id":58445,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"15073:3:120","memberName":"set","nodeType":"MemberAccess","referencedDeclaration":57740,"src":"15069:7:120","typeDescriptions":{"typeIdentifier":"t_function_external_nonpayable$_t_bytes4_$_t_address_$returns$__$","typeString":"function (bytes4,address) external"}},"id":58450,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"15069:78:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":58451,"nodeType":"ExpressionStatement","src":"15069:78:120"},{"assignments":[58453],"declarations":[{"constant":false,"id":58453,"mutability":"mutable","name":"addressManagerImpl","nameLocation":"15166:18:120","nodeType":"VariableDeclaration","scope":58527,"src":"15158:26:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":58452,"name":"address","nodeType":"ElementaryTypeName","src":"15158:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"id":58457,"initialValue":{"arguments":[{"id":58455,"name":"l1CrossDomainMessengerProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58436,"src":"15206:27:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_address","typeString":"address"}],"id":58454,"name":"_getAddressManager","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":59003,"src":"15187:18:120","typeDescriptions":{"typeIdentifier":"t_function_internal_view$_t_address_$returns$_t_address_$","typeString":"function (address) view returns (address)"}},"id":58456,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"15187:47:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"VariableDeclarationStatement","src":"15158:76:120"},{"expression":{"arguments":[{"expression":{"expression":{"id":58461,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58417,"src":"15252:3:120","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$58249","typeString":"contract FetchChainInfoOutput"}},"id":58462,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"15256:18:120","memberName":"addressManagerImpl","nodeType":"MemberAccess","referencedDeclaration":57813,"src":"15252:22:120","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":58463,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"15275:8:120","memberName":"selector","nodeType":"MemberAccess","src":"15252:31:120","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},{"id":58464,"name":"addressManagerImpl","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58453,"src":"15285:18:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_bytes4","typeString":"bytes4"},{"typeIdentifier":"t_address","typeString":"address"}],"expression":{"id":58458,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58417,"src":"15244:3:120","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$58249","typeString":"contract FetchChainInfoOutput"}},"id":58460,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"15248:3:120","memberName":"set","nodeType":"MemberAccess","referencedDeclaration":57740,"src":"15244:7:120","typeDescriptions":{"typeIdentifier":"t_function_external_nonpayable$_t_bytes4_$_t_address_$returns$__$","typeString":"function (bytes4,address) external"}},"id":58465,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"15244:60:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":58466,"nodeType":"ExpressionStatement","src":"15244:60:120"},{"assignments":[58468],"declarations":[{"constant":false,"id":58468,"mutability":"mutable","name":"optimismPortalProxy","nameLocation":"15323:19:120","nodeType":"VariableDeclaration","scope":58527,"src":"15315:27:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":58467,"name":"address","nodeType":"ElementaryTypeName","src":"15315:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"id":58472,"initialValue":{"arguments":[{"id":58470,"name":"l1CrossDomainMessengerProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58436,"src":"15369:27:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_address","typeString":"address"}],"id":58469,"name":"_getOptimismPortalProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58965,"src":"15345:23:120","typeDescriptions":{"typeIdentifier":"t_function_internal_view$_t_address_$returns$_t_address_$","typeString":"function (address) view returns (address)"}},"id":58471,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"15345:52:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"VariableDeclarationStatement","src":"15315:82:120"},{"expression":{"arguments":[{"expression":{"expression":{"id":58476,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58417,"src":"15415:3:120","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$58249","typeString":"contract FetchChainInfoOutput"}},"id":58477,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"15419:19:120","memberName":"optimismPortalProxy","nodeType":"MemberAccess","referencedDeclaration":57929,"src":"15415:23:120","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":58478,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"15439:8:120","memberName":"selector","nodeType":"MemberAccess","src":"15415:32:120","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},{"id":58479,"name":"optimismPortalProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58468,"src":"15449:19:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_bytes4","typeString":"bytes4"},{"typeIdentifier":"t_address","typeString":"address"}],"expression":{"id":58473,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58417,"src":"15407:3:120","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$58249","typeString":"contract FetchChainInfoOutput"}},"id":58475,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"15411:3:120","memberName":"set","nodeType":"MemberAccess","referencedDeclaration":57740,"src":"15407:7:120","typeDescriptions":{"typeIdentifier":"t_function_external_nonpayable$_t_bytes4_$_t_address_$returns$__$","typeString":"function (bytes4,address) external"}},"id":58480,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"15407:62:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":58481,"nodeType":"ExpressionStatement","src":"15407:62:120"},{"assignments":[58483],"declarations":[{"constant":false,"id":58483,"mutability":"mutable","name":"opChainGuardian","nameLocation":"15488:15:120","nodeType":"VariableDeclaration","scope":58527,"src":"15480:23:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":58482,"name":"address","nodeType":"ElementaryTypeName","src":"15480:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"id":58487,"initialValue":{"arguments":[{"id":58485,"name":"optimismPortalProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58468,"src":"15519:19:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_address","typeString":"address"}],"id":58484,"name":"_getGuardian","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58907,"src":"15506:12:120","typeDescriptions":{"typeIdentifier":"t_function_internal_view$_t_address_$returns$_t_address_$","typeString":"function (address) view returns (address)"}},"id":58486,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"15506:33:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"VariableDeclarationStatement","src":"15480:59:120"},{"expression":{"arguments":[{"expression":{"expression":{"id":58491,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58417,"src":"15557:3:120","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$58249","typeString":"contract FetchChainInfoOutput"}},"id":58492,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"15561:15:120","memberName":"opChainGuardian","nodeType":"MemberAccess","referencedDeclaration":58151,"src":"15557:19:120","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":58493,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"15577:8:120","memberName":"selector","nodeType":"MemberAccess","src":"15557:28:120","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},{"id":58494,"name":"opChainGuardian","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58483,"src":"15587:15:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_bytes4","typeString":"bytes4"},{"typeIdentifier":"t_address","typeString":"address"}],"expression":{"id":58488,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58417,"src":"15549:3:120","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$58249","typeString":"contract FetchChainInfoOutput"}},"id":58490,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"15553:3:120","memberName":"set","nodeType":"MemberAccess","referencedDeclaration":57740,"src":"15549:7:120","typeDescriptions":{"typeIdentifier":"t_function_external_nonpayable$_t_bytes4_$_t_address_$returns$__$","typeString":"function (bytes4,address) external"}},"id":58495,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"15549:54:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":58496,"nodeType":"ExpressionStatement","src":"15549:54:120"},{"assignments":[58498],"declarations":[{"constant":false,"id":58498,"mutability":"mutable","name":"ethLockboxProxy","nameLocation":"15622:15:120","nodeType":"VariableDeclaration","scope":58527,"src":"15614:23:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":58497,"name":"address","nodeType":"ElementaryTypeName","src":"15614:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"id":58502,"initialValue":{"arguments":[{"id":58500,"name":"optimismPortalProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58468,"src":"15660:19:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_address","typeString":"address"}],"id":58499,"name":"_getEthLockboxProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":59203,"src":"15640:19:120","typeDescriptions":{"typeIdentifier":"t_function_internal_view$_t_address_$returns$_t_address_$","typeString":"function (address) view returns (address)"}},"id":58501,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"15640:40:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"VariableDeclarationStatement","src":"15614:66:120"},{"expression":{"arguments":[{"expression":{"expression":{"id":58506,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58417,"src":"15698:3:120","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$58249","typeString":"contract FetchChainInfoOutput"}},"id":58507,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"15702:15:120","memberName":"ethLockboxProxy","nodeType":"MemberAccess","referencedDeclaration":57821,"src":"15698:19:120","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":58508,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"15718:8:120","memberName":"selector","nodeType":"MemberAccess","src":"15698:28:120","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},{"id":58509,"name":"ethLockboxProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58498,"src":"15728:15:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_bytes4","typeString":"bytes4"},{"typeIdentifier":"t_address","typeString":"address"}],"expression":{"id":58503,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58417,"src":"15690:3:120","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$58249","typeString":"contract FetchChainInfoOutput"}},"id":58505,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"15694:3:120","memberName":"set","nodeType":"MemberAccess","referencedDeclaration":57740,"src":"15690:7:120","typeDescriptions":{"typeIdentifier":"t_function_external_nonpayable$_t_bytes4_$_t_address_$returns$__$","typeString":"function (bytes4,address) external"}},"id":58510,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"15690:54:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":58511,"nodeType":"ExpressionStatement","src":"15690:54:120"},{"assignments":[58513],"declarations":[{"constant":false,"id":58513,"mutability":"mutable","name":"superchainConfigProxy","nameLocation":"15763:21:120","nodeType":"VariableDeclaration","scope":58527,"src":"15755:29:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":58512,"name":"address","nodeType":"ElementaryTypeName","src":"15755:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"id":58517,"initialValue":{"arguments":[{"id":58515,"name":"optimismPortalProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58468,"src":"15813:19:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_address","typeString":"address"}],"id":58514,"name":"_getSuperchainConfigProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":59115,"src":"15787:25:120","typeDescriptions":{"typeIdentifier":"t_function_internal_view$_t_address_$returns$_t_address_$","typeString":"function (address) view returns (address)"}},"id":58516,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"15787:46:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"VariableDeclarationStatement","src":"15755:78:120"},{"expression":{"arguments":[{"expression":{"expression":{"id":58521,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58417,"src":"15851:3:120","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$58249","typeString":"contract FetchChainInfoOutput"}},"id":58522,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"15855:21:120","memberName":"superchainConfigProxy","nodeType":"MemberAccess","referencedDeclaration":57983,"src":"15851:25:120","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":58523,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"15877:8:120","memberName":"selector","nodeType":"MemberAccess","src":"15851:34:120","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},{"id":58524,"name":"superchainConfigProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58513,"src":"15887:21:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_bytes4","typeString":"bytes4"},{"typeIdentifier":"t_address","typeString":"address"}],"expression":{"id":58518,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58417,"src":"15843:3:120","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$58249","typeString":"contract FetchChainInfoOutput"}},"id":58520,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"15847:3:120","memberName":"set","nodeType":"MemberAccess","referencedDeclaration":57740,"src":"15843:7:120","typeDescriptions":{"typeIdentifier":"t_function_external_nonpayable$_t_bytes4_$_t_address_$returns$__$","typeString":"function (bytes4,address) external"}},"id":58525,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"15843:66:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":58526,"nodeType":"ExpressionStatement","src":"15843:66:120"}]},"implemented":true,"kind":"function","modifiers":[],"name":"_processMessengerAndPortal","nameLocation":"14735:26:120","parameters":{"id":58418,"nodeType":"ParameterList","parameters":[{"constant":false,"id":58414,"mutability":"mutable","name":"_fi","nameLocation":"14782:3:120","nodeType":"VariableDeclaration","scope":58528,"src":"14762:23:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoInput_$57409","typeString":"contract FetchChainInfoInput"},"typeName":{"id":58413,"nodeType":"UserDefinedTypeName","pathNode":{"id":58412,"name":"FetchChainInfoInput","nameLocations":["14762:19:120"],"nodeType":"IdentifierPath","referencedDeclaration":57409,"src":"14762:19:120"},"referencedDeclaration":57409,"src":"14762:19:120","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoInput_$57409","typeString":"contract FetchChainInfoInput"}},"visibility":"internal"},{"constant":false,"id":58417,"mutability":"mutable","name":"_fo","nameLocation":"14808:3:120","nodeType":"VariableDeclaration","scope":58528,"src":"14787:24:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$58249","typeString":"contract FetchChainInfoOutput"},"typeName":{"id":58416,"nodeType":"UserDefinedTypeName","pathNode":{"id":58415,"name":"FetchChainInfoOutput","nameLocations":["14787:20:120"],"nodeType":"IdentifierPath","referencedDeclaration":58249,"src":"14787:20:120"},"referencedDeclaration":58249,"src":"14787:20:120","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$58249","typeString":"contract FetchChainInfoOutput"}},"visibility":"internal"}],"src":"14761:51:120"},"returnParameters":{"id":58419,"nodeType":"ParameterList","parameters":[],"src":"14822:0:120"},"scope":59299,"stateMutability":"nonpayable","virtual":false,"visibility":"internal"},{"id":58878,"nodeType":"FunctionDefinition","src":"15922:3713:120","nodes":[],"body":{"id":58877,"nodeType":"Block","src":"15986:3649:120","nodes":[],"statements":[{"assignments":[58535],"declarations":[{"constant":false,"id":58535,"mutability":"mutable","name":"systemConfigProxy","nameLocation":"16004:17:120","nodeType":"VariableDeclaration","scope":58877,"src":"15996:25:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":58534,"name":"address","nodeType":"ElementaryTypeName","src":"15996:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"id":58539,"initialValue":{"arguments":[],"expression":{"argumentTypes":[],"expression":{"id":58536,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58531,"src":"16024:3:120","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$58249","typeString":"contract FetchChainInfoOutput"}},"id":58537,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"16028:17:120","memberName":"systemConfigProxy","nodeType":"MemberAccess","referencedDeclaration":57947,"src":"16024:21:120","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":58538,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"16024:23:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"VariableDeclarationStatement","src":"15996:51:120"},{"assignments":[58541],"declarations":[{"constant":false,"id":58541,"mutability":"mutable","name":"optimismPortalProxy","nameLocation":"16065:19:120","nodeType":"VariableDeclaration","scope":58877,"src":"16057:27:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":58540,"name":"address","nodeType":"ElementaryTypeName","src":"16057:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"id":58545,"initialValue":{"arguments":[],"expression":{"argumentTypes":[],"expression":{"id":58542,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58531,"src":"16087:3:120","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$58249","typeString":"contract FetchChainInfoOutput"}},"id":58543,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"16091:19:120","memberName":"optimismPortalProxy","nodeType":"MemberAccess","referencedDeclaration":57929,"src":"16087:23:120","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":58544,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"16087:25:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"VariableDeclarationStatement","src":"16057:55:120"},{"clauses":[{"block":{"id":58564,"nodeType":"Block","src":"16206:75:120","statements":[{"expression":{"arguments":[{"expression":{"expression":{"id":58558,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58531,"src":"16228:3:120","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$58249","typeString":"contract FetchChainInfoOutput"}},"id":58559,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"16232:17:120","memberName":"respectedGameType","nodeType":"MemberAccess","referencedDeclaration":58248,"src":"16228:21:120","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_userDefinedValueType$_GameType_$75355_$","typeString":"function () view external returns (GameType)"}},"id":58560,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"16250:8:120","memberName":"selector","nodeType":"MemberAccess","src":"16228:30:120","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},{"id":58561,"name":"gameType_","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58553,"src":"16260:9:120","typeDescriptions":{"typeIdentifier":"t_userDefinedValueType$_GameType_$75355","typeString":"GameType"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_bytes4","typeString":"bytes4"},{"typeIdentifier":"t_userDefinedValueType$_GameType_$75355","typeString":"GameType"}],"expression":{"id":58555,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58531,"src":"16220:3:120","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$58249","typeString":"contract FetchChainInfoOutput"}},"id":58557,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"16224:3:120","memberName":"set","nodeType":"MemberAccess","referencedDeclaration":57795,"src":"16220:7:120","typeDescriptions":{"typeIdentifier":"t_function_external_nonpayable$_t_bytes4_$_t_userDefinedValueType$_GameType_$75355_$returns$__$","typeString":"function (bytes4,GameType) external"}},"id":58562,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"16220:50:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":58563,"nodeType":"ExpressionStatement","src":"16220:50:120"}]},"errorName":"","id":58565,"nodeType":"TryCatchClause","parameters":{"id":58554,"nodeType":"ParameterList","parameters":[{"constant":false,"id":58553,"mutability":"mutable","name":"gameType_","nameLocation":"16195:9:120","nodeType":"VariableDeclaration","scope":58565,"src":"16186:18:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_userDefinedValueType$_GameType_$75355","typeString":"GameType"},"typeName":{"id":58552,"nodeType":"UserDefinedTypeName","pathNode":{"id":58551,"name":"GameType","nameLocations":["16186:8:120"],"nodeType":"IdentifierPath","referencedDeclaration":75355,"src":"16186:8:120"},"referencedDeclaration":75355,"src":"16186:8:120","typeDescriptions":{"typeIdentifier":"t_userDefinedValueType$_GameType_$75355","typeString":"GameType"}},"visibility":"internal"}],"src":"16185:20:120"},"src":"16177:104:120"},{"block":{"id":58637,"nodeType":"Block","src":"16288:744:120","statements":[{"expression":{"arguments":[{"expression":{"expression":{"id":58569,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58531,"src":"16383:3:120","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$58249","typeString":"contract FetchChainInfoOutput"}},"id":58570,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"16387:17:120","memberName":"respectedGameType","nodeType":"MemberAccess","referencedDeclaration":58248,"src":"16383:21:120","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_userDefinedValueType$_GameType_$75355_$","typeString":"function () view external returns (GameType)"}},"id":58571,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"16405:8:120","memberName":"selector","nodeType":"MemberAccess","src":"16383:30:120","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},{"arguments":[{"expression":{"arguments":[{"id":58576,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"nodeType":"ElementaryTypeNameExpression","src":"16434:6:120","typeDescriptions":{"typeIdentifier":"t_type$_t_uint32_$","typeString":"type(uint32)"},"typeName":{"id":58575,"name":"uint32","nodeType":"ElementaryTypeName","src":"16434:6:120","typeDescriptions":{}}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_type$_t_uint32_$","typeString":"type(uint32)"}],"id":58574,"name":"type","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":-27,"src":"16429:4:120","typeDescriptions":{"typeIdentifier":"t_function_metatype_pure$__$returns$__$","typeString":"function () pure"}},"id":58577,"isConstant":false,"isLValue":false,"isPure":true,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"16429:12:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_magic_meta_type_t_uint32","typeString":"type(uint32)"}},"id":58578,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"memberLocation":"16442:3:120","memberName":"max","nodeType":"MemberAccess","src":"16429:16:120","typeDescriptions":{"typeIdentifier":"t_uint32","typeString":"uint32"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_uint32","typeString":"uint32"}],"expression":{"id":58572,"name":"GameType","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":75355,"src":"16415:8:120","typeDescriptions":{"typeIdentifier":"t_type$_t_userDefinedValueType$_GameType_$75355_$","typeString":"type(GameType)"}},"id":58573,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"memberLocation":"16424:4:120","memberName":"wrap","nodeType":"MemberAccess","src":"16415:13:120","typeDescriptions":{"typeIdentifier":"t_function_wrap_pure$_t_uint32_$returns$_t_userDefinedValueType$_GameType_$75355_$","typeString":"function (uint32) pure returns (GameType)"}},"id":58579,"isConstant":false,"isLValue":false,"isPure":true,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"16415:31:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_userDefinedValueType$_GameType_$75355","typeString":"GameType"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_bytes4","typeString":"bytes4"},{"typeIdentifier":"t_userDefinedValueType$_GameType_$75355","typeString":"GameType"}],"expression":{"id":58566,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58531,"src":"16375:3:120","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$58249","typeString":"contract FetchChainInfoOutput"}},"id":58568,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"16379:3:120","memberName":"set","nodeType":"MemberAccess","referencedDeclaration":57795,"src":"16375:7:120","typeDescriptions":{"typeIdentifier":"t_function_external_nonpayable$_t_bytes4_$_t_userDefinedValueType$_GameType_$75355_$returns$__$","typeString":"function (bytes4,GameType) external"}},"id":58580,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"16375:72:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":58581,"nodeType":"ExpressionStatement","src":"16375:72:120"},{"assignments":[58583],"declarations":[{"constant":false,"id":58583,"mutability":"mutable","name":"l2OutputOracleProxy","nameLocation":"16469:19:120","nodeType":"VariableDeclaration","scope":58637,"src":"16461:27:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":58582,"name":"address","nodeType":"ElementaryTypeName","src":"16461:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"id":58584,"nodeType":"VariableDeclarationStatement","src":"16461:27:120"},{"clauses":[{"block":{"id":58597,"nodeType":"Block","src":"16575:64:120","statements":[{"expression":{"id":58595,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftHandSide":{"id":58593,"name":"l2OutputOracleProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58583,"src":"16593:19:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"Assignment","operator":"=","rightHandSide":{"id":58594,"name":"l2Oracle_","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58591,"src":"16615:9:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"src":"16593:31:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"id":58596,"nodeType":"ExpressionStatement","src":"16593:31:120"}]},"errorName":"","id":58598,"nodeType":"TryCatchClause","parameters":{"id":58592,"nodeType":"ParameterList","parameters":[{"constant":false,"id":58591,"mutability":"mutable","name":"l2Oracle_","nameLocation":"16564:9:120","nodeType":"VariableDeclaration","scope":58598,"src":"16556:17:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":58590,"name":"address","nodeType":"ElementaryTypeName","src":"16556:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"16555:19:120"},"src":"16547:92:120"},{"block":{"id":58607,"nodeType":"Block","src":"16646:96:120","statements":[{"expression":{"id":58605,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftHandSide":{"id":58599,"name":"l2OutputOracleProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58583,"src":"16664:19:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"Assignment","operator":"=","rightHandSide":{"arguments":[],"expression":{"argumentTypes":[],"expression":{"arguments":[{"id":58601,"name":"optimismPortalProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58541,"src":"16695:19:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_address","typeString":"address"}],"id":58600,"name":"IFetcher","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57326,"src":"16686:8:120","typeDescriptions":{"typeIdentifier":"t_type$_t_contract$_IFetcher_$57326_$","typeString":"type(contract IFetcher)"}},"id":58602,"isConstant":false,"isLValue":false,"isPure":false,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"16686:29:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_contract$_IFetcher_$57326","typeString":"contract IFetcher"}},"id":58603,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"16716:9:120","memberName":"L2_ORACLE","nodeType":"MemberAccess","referencedDeclaration":57270,"src":"16686:39:120","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":58604,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"16686:41:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"src":"16664:63:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"id":58606,"nodeType":"ExpressionStatement","src":"16664:63:120"}]},"errorName":"","id":58608,"nodeType":"TryCatchClause","src":"16640:102:120"}],"externalCall":{"arguments":[],"expression":{"argumentTypes":[],"expression":{"arguments":[{"id":58586,"name":"optimismPortalProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58541,"src":"16515:19:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_address","typeString":"address"}],"id":58585,"name":"IFetcher","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57326,"src":"16506:8:120","typeDescriptions":{"typeIdentifier":"t_type$_t_contract$_IFetcher_$57326_$","typeString":"type(contract IFetcher)"}},"id":58587,"isConstant":false,"isLValue":false,"isPure":false,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"16506:29:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_contract$_IFetcher_$57326","typeString":"contract IFetcher"}},"id":58588,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"16536:8:120","memberName":"l2Oracle","nodeType":"MemberAccess","referencedDeclaration":57275,"src":"16506:38:120","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":58589,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"16506:40:120","tryCall":true,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"id":58609,"nodeType":"TryStatement","src":"16502:240:120"},{"expression":{"arguments":[{"expression":{"expression":{"id":58613,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58531,"src":"16763:3:120","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$58249","typeString":"contract FetchChainInfoOutput"}},"id":58614,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"16767:19:120","memberName":"l2OutputOracleProxy","nodeType":"MemberAccess","referencedDeclaration":57893,"src":"16763:23:120","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":58615,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"16787:8:120","memberName":"selector","nodeType":"MemberAccess","src":"16763:32:120","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},{"id":58616,"name":"l2OutputOracleProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58583,"src":"16797:19:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_bytes4","typeString":"bytes4"},{"typeIdentifier":"t_address","typeString":"address"}],"expression":{"id":58610,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58531,"src":"16755:3:120","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$58249","typeString":"contract FetchChainInfoOutput"}},"id":58612,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"16759:3:120","memberName":"set","nodeType":"MemberAccess","referencedDeclaration":57740,"src":"16755:7:120","typeDescriptions":{"typeIdentifier":"t_function_external_nonpayable$_t_bytes4_$_t_address_$returns$__$","typeString":"function (bytes4,address) external"}},"id":58617,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"16755:62:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":58618,"nodeType":"ExpressionStatement","src":"16755:62:120"},{"assignments":[58620],"declarations":[{"constant":false,"id":58620,"mutability":"mutable","name":"proposer","nameLocation":"16840:8:120","nodeType":"VariableDeclaration","scope":58637,"src":"16832:16:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":58619,"name":"address","nodeType":"ElementaryTypeName","src":"16832:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"id":58626,"initialValue":{"arguments":[],"expression":{"argumentTypes":[],"expression":{"arguments":[{"id":58622,"name":"l2OutputOracleProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58583,"src":"16860:19:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_address","typeString":"address"}],"id":58621,"name":"IFetcher","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57326,"src":"16851:8:120","typeDescriptions":{"typeIdentifier":"t_type$_t_contract$_IFetcher_$57326_$","typeString":"type(contract IFetcher)"}},"id":58623,"isConstant":false,"isLValue":false,"isPure":false,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"16851:29:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_contract$_IFetcher_$57326","typeString":"contract IFetcher"}},"id":58624,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"16881:8:120","memberName":"PROPOSER","nodeType":"MemberAccess","referencedDeclaration":57300,"src":"16851:38:120","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":58625,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"16851:40:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"VariableDeclarationStatement","src":"16832:59:120"},{"expression":{"arguments":[{"expression":{"expression":{"id":58630,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58531,"src":"16913:3:120","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$58249","typeString":"contract FetchChainInfoOutput"}},"id":58631,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"16917:8:120","memberName":"proposer","nodeType":"MemberAccess","referencedDeclaration":58187,"src":"16913:12:120","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":58632,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"16926:8:120","memberName":"selector","nodeType":"MemberAccess","src":"16913:21:120","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},{"id":58633,"name":"proposer","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58620,"src":"16936:8:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_bytes4","typeString":"bytes4"},{"typeIdentifier":"t_address","typeString":"address"}],"expression":{"id":58627,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58531,"src":"16905:3:120","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$58249","typeString":"contract FetchChainInfoOutput"}},"id":58629,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"16909:3:120","memberName":"set","nodeType":"MemberAccess","referencedDeclaration":57740,"src":"16905:7:120","typeDescriptions":{"typeIdentifier":"t_function_external_nonpayable$_t_bytes4_$_t_address_$returns$__$","typeString":"function (bytes4,address) external"}},"id":58634,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"16905:40:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":58635,"nodeType":"ExpressionStatement","src":"16905:40:120"},{"functionReturnParameters":58533,"id":58636,"nodeType":"Return","src":"17015:7:120"}]},"errorName":"","id":58638,"nodeType":"TryCatchClause","src":"16282:750:120"}],"externalCall":{"arguments":[],"expression":{"argumentTypes":[],"expression":{"arguments":[{"id":58547,"name":"optimismPortalProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58541,"src":"16136:19:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_address","typeString":"address"}],"id":58546,"name":"IFetcher","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57326,"src":"16127:8:120","typeDescriptions":{"typeIdentifier":"t_type$_t_contract$_IFetcher_$57326_$","typeString":"type(contract IFetcher)"}},"id":58548,"isConstant":false,"isLValue":false,"isPure":false,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"16127:29:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_contract$_IFetcher_$57326","typeString":"contract IFetcher"}},"id":58549,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"16157:17:120","memberName":"respectedGameType","nodeType":"MemberAccess","referencedDeclaration":57260,"src":"16127:47:120","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_userDefinedValueType$_GameType_$75355_$","typeString":"function () view external returns (GameType)"}},"id":58550,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"16127:49:120","tryCall":true,"typeDescriptions":{"typeIdentifier":"t_userDefinedValueType$_GameType_$75355","typeString":"GameType"}},"id":58639,"nodeType":"TryStatement","src":"16123:909:120"},{"assignments":[58641],"declarations":[{"constant":false,"id":58641,"mutability":"mutable","name":"disputeGameFactoryProxy","nameLocation":"17050:23:120","nodeType":"VariableDeclaration","scope":58877,"src":"17042:31:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":58640,"name":"address","nodeType":"ElementaryTypeName","src":"17042:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"id":58645,"initialValue":{"arguments":[{"id":58643,"name":"systemConfigProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58535,"src":"17104:17:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_address","typeString":"address"}],"id":58642,"name":"_getDisputeGameFactoryProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":59087,"src":"17076:27:120","typeDescriptions":{"typeIdentifier":"t_function_internal_view$_t_address_$returns$_t_address_$","typeString":"function (address) view returns (address)"}},"id":58644,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"17076:46:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"VariableDeclarationStatement","src":"17042:80:120"},{"condition":{"commonType":{"typeIdentifier":"t_address","typeString":"address"},"id":58651,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftExpression":{"id":58646,"name":"disputeGameFactoryProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58641,"src":"17136:23:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"BinaryOperation","operator":"!=","rightExpression":{"arguments":[{"hexValue":"30","id":58649,"isConstant":false,"isLValue":false,"isPure":true,"kind":"number","lValueRequested":false,"nodeType":"Literal","src":"17171:1:120","typeDescriptions":{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"},"value":"0"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"}],"id":58648,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"nodeType":"ElementaryTypeNameExpression","src":"17163:7:120","typeDescriptions":{"typeIdentifier":"t_type$_t_address_$","typeString":"type(address)"},"typeName":{"id":58647,"name":"address","nodeType":"ElementaryTypeName","src":"17163:7:120","typeDescriptions":{}}},"id":58650,"isConstant":false,"isLValue":false,"isPure":true,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"17163:10:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"src":"17136:37:120","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},"falseBody":{"id":58875,"nodeType":"Block","src":"19246:383:120","statements":[{"assignments":[58842],"declarations":[{"constant":false,"id":58842,"mutability":"mutable","name":"l2OutputOracleProxy","nameLocation":"19352:19:120","nodeType":"VariableDeclaration","scope":58875,"src":"19344:27:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":58841,"name":"address","nodeType":"ElementaryTypeName","src":"19344:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"id":58848,"initialValue":{"arguments":[],"expression":{"argumentTypes":[],"expression":{"arguments":[{"id":58844,"name":"optimismPortalProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58541,"src":"19383:19:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_address","typeString":"address"}],"id":58843,"name":"IFetcher","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57326,"src":"19374:8:120","typeDescriptions":{"typeIdentifier":"t_type$_t_contract$_IFetcher_$57326_$","typeString":"type(contract IFetcher)"}},"id":58845,"isConstant":false,"isLValue":false,"isPure":false,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"19374:29:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_contract$_IFetcher_$57326","typeString":"contract IFetcher"}},"id":58846,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"19404:9:120","memberName":"L2_ORACLE","nodeType":"MemberAccess","referencedDeclaration":57270,"src":"19374:39:120","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":58847,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"19374:41:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"VariableDeclarationStatement","src":"19344:71:120"},{"expression":{"arguments":[{"expression":{"expression":{"id":58852,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58531,"src":"19437:3:120","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$58249","typeString":"contract FetchChainInfoOutput"}},"id":58853,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"19441:19:120","memberName":"l2OutputOracleProxy","nodeType":"MemberAccess","referencedDeclaration":57893,"src":"19437:23:120","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":58854,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"19461:8:120","memberName":"selector","nodeType":"MemberAccess","src":"19437:32:120","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},{"id":58855,"name":"l2OutputOracleProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58842,"src":"19471:19:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_bytes4","typeString":"bytes4"},{"typeIdentifier":"t_address","typeString":"address"}],"expression":{"id":58849,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58531,"src":"19429:3:120","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$58249","typeString":"contract FetchChainInfoOutput"}},"id":58851,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"19433:3:120","memberName":"set","nodeType":"MemberAccess","referencedDeclaration":57740,"src":"19429:7:120","typeDescriptions":{"typeIdentifier":"t_function_external_nonpayable$_t_bytes4_$_t_address_$returns$__$","typeString":"function (bytes4,address) external"}},"id":58856,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"19429:62:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":58857,"nodeType":"ExpressionStatement","src":"19429:62:120"},{"assignments":[58859],"declarations":[{"constant":false,"id":58859,"mutability":"mutable","name":"proposer","nameLocation":"19513:8:120","nodeType":"VariableDeclaration","scope":58875,"src":"19505:16:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":58858,"name":"address","nodeType":"ElementaryTypeName","src":"19505:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"id":58865,"initialValue":{"arguments":[],"expression":{"argumentTypes":[],"expression":{"arguments":[{"id":58861,"name":"l2OutputOracleProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58842,"src":"19533:19:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_address","typeString":"address"}],"id":58860,"name":"IFetcher","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57326,"src":"19524:8:120","typeDescriptions":{"typeIdentifier":"t_type$_t_contract$_IFetcher_$57326_$","typeString":"type(contract IFetcher)"}},"id":58862,"isConstant":false,"isLValue":false,"isPure":false,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"19524:29:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_contract$_IFetcher_$57326","typeString":"contract IFetcher"}},"id":58863,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"19554:8:120","memberName":"PROPOSER","nodeType":"MemberAccess","referencedDeclaration":57300,"src":"19524:38:120","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":58864,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"19524:40:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"VariableDeclarationStatement","src":"19505:59:120"},{"expression":{"arguments":[{"expression":{"expression":{"id":58869,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58531,"src":"19586:3:120","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$58249","typeString":"contract FetchChainInfoOutput"}},"id":58870,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"19590:8:120","memberName":"proposer","nodeType":"MemberAccess","referencedDeclaration":58187,"src":"19586:12:120","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":58871,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"19599:8:120","memberName":"selector","nodeType":"MemberAccess","src":"19586:21:120","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},{"id":58872,"name":"proposer","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58859,"src":"19609:8:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_bytes4","typeString":"bytes4"},{"typeIdentifier":"t_address","typeString":"address"}],"expression":{"id":58866,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58531,"src":"19578:3:120","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$58249","typeString":"contract FetchChainInfoOutput"}},"id":58868,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"19582:3:120","memberName":"set","nodeType":"MemberAccess","referencedDeclaration":57740,"src":"19578:7:120","typeDescriptions":{"typeIdentifier":"t_function_external_nonpayable$_t_bytes4_$_t_address_$returns$__$","typeString":"function (bytes4,address) external"}},"id":58873,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"19578:40:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":58874,"nodeType":"ExpressionStatement","src":"19578:40:120"}]},"id":58876,"nodeType":"IfStatement","src":"17132:2497:120","trueBody":{"id":58840,"nodeType":"Block","src":"17175:2065:120","statements":[{"expression":{"arguments":[{"expression":{"expression":{"id":58655,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58531,"src":"17197:3:120","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$58249","typeString":"contract FetchChainInfoOutput"}},"id":58656,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"17201:23:120","memberName":"disputeGameFactoryProxy","nodeType":"MemberAccess","referencedDeclaration":58025,"src":"17197:27:120","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":58657,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"17225:8:120","memberName":"selector","nodeType":"MemberAccess","src":"17197:36:120","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},{"id":58658,"name":"disputeGameFactoryProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58641,"src":"17235:23:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_bytes4","typeString":"bytes4"},{"typeIdentifier":"t_address","typeString":"address"}],"expression":{"id":58652,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58531,"src":"17189:3:120","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$58249","typeString":"contract FetchChainInfoOutput"}},"id":58654,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"17193:3:120","memberName":"set","nodeType":"MemberAccess","referencedDeclaration":57740,"src":"17189:7:120","typeDescriptions":{"typeIdentifier":"t_function_external_nonpayable$_t_bytes4_$_t_address_$returns$__$","typeString":"function (bytes4,address) external"}},"id":58659,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"17189:70:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":58660,"nodeType":"ExpressionStatement","src":"17189:70:120"},{"assignments":[58662],"declarations":[{"constant":false,"id":58662,"mutability":"mutable","name":"permissionedDisputeGameImpl","nameLocation":"17282:27:120","nodeType":"VariableDeclaration","scope":58840,"src":"17274:35:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":58661,"name":"address","nodeType":"ElementaryTypeName","src":"17274:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"id":58666,"initialValue":{"arguments":[{"id":58664,"name":"disputeGameFactoryProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58641,"src":"17340:23:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_address","typeString":"address"}],"id":58663,"name":"_getPermissionedDisputeGame","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":59175,"src":"17312:27:120","typeDescriptions":{"typeIdentifier":"t_function_internal_view$_t_address_$returns$_t_address_$","typeString":"function (address) view returns (address)"}},"id":58665,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"17312:52:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"VariableDeclarationStatement","src":"17274:90:120"},{"condition":{"commonType":{"typeIdentifier":"t_address","typeString":"address"},"id":58672,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftExpression":{"id":58667,"name":"permissionedDisputeGameImpl","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58662,"src":"17382:27:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"BinaryOperation","operator":"!=","rightExpression":{"arguments":[{"hexValue":"30","id":58670,"isConstant":false,"isLValue":false,"isPure":true,"kind":"number","lValueRequested":false,"nodeType":"Literal","src":"17421:1:120","typeDescriptions":{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"},"value":"0"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"}],"id":58669,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"nodeType":"ElementaryTypeNameExpression","src":"17413:7:120","typeDescriptions":{"typeIdentifier":"t_type$_t_address_$","typeString":"type(address)"},"typeName":{"id":58668,"name":"address","nodeType":"ElementaryTypeName","src":"17413:7:120","typeDescriptions":{}}},"id":58671,"isConstant":false,"isLValue":false,"isPure":true,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"17413:10:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"src":"17382:41:120","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},"id":58792,"nodeType":"IfStatement","src":"17378:1278:120","trueBody":{"id":58791,"nodeType":"Block","src":"17425:1231:120","statements":[{"expression":{"arguments":[{"expression":{"expression":{"id":58676,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58531,"src":"17506:3:120","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$58249","typeString":"contract FetchChainInfoOutput"}},"id":58677,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"17510:12:120","memberName":"permissioned","nodeType":"MemberAccess","referencedDeclaration":58231,"src":"17506:16:120","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_bool_$","typeString":"function () view external returns (bool)"}},"id":58678,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"17523:8:120","memberName":"selector","nodeType":"MemberAccess","src":"17506:25:120","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},{"hexValue":"74727565","id":58679,"isConstant":false,"isLValue":false,"isPure":true,"kind":"bool","lValueRequested":false,"nodeType":"Literal","src":"17533:4:120","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"},"value":"true"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_bytes4","typeString":"bytes4"},{"typeIdentifier":"t_bool","typeString":"bool"}],"expression":{"id":58673,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58531,"src":"17498:3:120","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$58249","typeString":"contract FetchChainInfoOutput"}},"id":58675,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"17502:3:120","memberName":"set","nodeType":"MemberAccess","referencedDeclaration":57772,"src":"17498:7:120","typeDescriptions":{"typeIdentifier":"t_function_external_nonpayable$_t_bytes4_$_t_bool_$returns$__$","typeString":"function (bytes4,bool) external"}},"id":58680,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"17498:40:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":58681,"nodeType":"ExpressionStatement","src":"17498:40:120"},{"expression":{"arguments":[{"expression":{"expression":{"id":58685,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58531,"src":"17564:3:120","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$58249","typeString":"contract FetchChainInfoOutput"}},"id":58686,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"17568:27:120","memberName":"permissionedDisputeGameImpl","nodeType":"MemberAccess","referencedDeclaration":58079,"src":"17564:31:120","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":58687,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"17596:8:120","memberName":"selector","nodeType":"MemberAccess","src":"17564:40:120","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},{"id":58688,"name":"permissionedDisputeGameImpl","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58662,"src":"17606:27:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_bytes4","typeString":"bytes4"},{"typeIdentifier":"t_address","typeString":"address"}],"expression":{"id":58682,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58531,"src":"17556:3:120","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$58249","typeString":"contract FetchChainInfoOutput"}},"id":58684,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"17560:3:120","memberName":"set","nodeType":"MemberAccess","referencedDeclaration":57740,"src":"17556:7:120","typeDescriptions":{"typeIdentifier":"t_function_external_nonpayable$_t_bytes4_$_t_address_$returns$__$","typeString":"function (bytes4,address) external"}},"id":58689,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"17556:78:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":58690,"nodeType":"ExpressionStatement","src":"17556:78:120"},{"assignments":[58692],"declarations":[{"constant":false,"id":58692,"mutability":"mutable","name":"challenger","nameLocation":"17661:10:120","nodeType":"VariableDeclaration","scope":58791,"src":"17653:18:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":58691,"name":"address","nodeType":"ElementaryTypeName","src":"17653:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"id":58698,"initialValue":{"arguments":[],"expression":{"argumentTypes":[],"expression":{"arguments":[{"id":58694,"name":"permissionedDisputeGameImpl","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58662,"src":"17683:27:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_address","typeString":"address"}],"id":58693,"name":"IFetcher","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57326,"src":"17674:8:120","typeDescriptions":{"typeIdentifier":"t_type$_t_contract$_IFetcher_$57326_$","typeString":"type(contract IFetcher)"}},"id":58695,"isConstant":false,"isLValue":false,"isPure":false,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"17674:37:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_contract$_IFetcher_$57326","typeString":"contract IFetcher"}},"id":58696,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"17712:10:120","memberName":"challenger","nodeType":"MemberAccess","referencedDeclaration":57290,"src":"17674:48:120","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":58697,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"17674:50:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"VariableDeclarationStatement","src":"17653:71:120"},{"expression":{"arguments":[{"expression":{"expression":{"id":58702,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58531,"src":"17750:3:120","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$58249","typeString":"contract FetchChainInfoOutput"}},"id":58703,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"17754:10:120","memberName":"challenger","nodeType":"MemberAccess","referencedDeclaration":58169,"src":"17750:14:120","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":58704,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"17765:8:120","memberName":"selector","nodeType":"MemberAccess","src":"17750:23:120","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},{"id":58705,"name":"challenger","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58692,"src":"17775:10:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_bytes4","typeString":"bytes4"},{"typeIdentifier":"t_address","typeString":"address"}],"expression":{"id":58699,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58531,"src":"17742:3:120","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$58249","typeString":"contract FetchChainInfoOutput"}},"id":58701,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"17746:3:120","memberName":"set","nodeType":"MemberAccess","referencedDeclaration":57740,"src":"17742:7:120","typeDescriptions":{"typeIdentifier":"t_function_external_nonpayable$_t_bytes4_$_t_address_$returns$__$","typeString":"function (bytes4,address) external"}},"id":58706,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"17742:44:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":58707,"nodeType":"ExpressionStatement","src":"17742:44:120"},{"assignments":[58709],"declarations":[{"constant":false,"id":58709,"mutability":"mutable","name":"anchorStateRegistryProxy","nameLocation":"17813:24:120","nodeType":"VariableDeclaration","scope":58791,"src":"17805:32:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":58708,"name":"address","nodeType":"ElementaryTypeName","src":"17805:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"id":58715,"initialValue":{"arguments":[],"expression":{"argumentTypes":[],"expression":{"arguments":[{"id":58711,"name":"permissionedDisputeGameImpl","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58662,"src":"17849:27:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_address","typeString":"address"}],"id":58710,"name":"IFetcher","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57326,"src":"17840:8:120","typeDescriptions":{"typeIdentifier":"t_type$_t_contract$_IFetcher_$57326_$","typeString":"type(contract IFetcher)"}},"id":58712,"isConstant":false,"isLValue":false,"isPure":false,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"17840:37:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_contract$_IFetcher_$57326","typeString":"contract IFetcher"}},"id":58713,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"17878:19:120","memberName":"anchorStateRegistry","nodeType":"MemberAccess","referencedDeclaration":57265,"src":"17840:57:120","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":58714,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"17840:59:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"VariableDeclarationStatement","src":"17805:94:120"},{"expression":{"arguments":[{"expression":{"expression":{"id":58719,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58531,"src":"17925:3:120","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$58249","typeString":"contract FetchChainInfoOutput"}},"id":58720,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"17929:24:120","memberName":"anchorStateRegistryProxy","nodeType":"MemberAccess","referencedDeclaration":58001,"src":"17925:28:120","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":58721,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"17954:8:120","memberName":"selector","nodeType":"MemberAccess","src":"17925:37:120","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},{"id":58722,"name":"anchorStateRegistryProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58709,"src":"17964:24:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_bytes4","typeString":"bytes4"},{"typeIdentifier":"t_address","typeString":"address"}],"expression":{"id":58716,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58531,"src":"17917:3:120","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$58249","typeString":"contract FetchChainInfoOutput"}},"id":58718,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"17921:3:120","memberName":"set","nodeType":"MemberAccess","referencedDeclaration":57740,"src":"17917:7:120","typeDescriptions":{"typeIdentifier":"t_function_external_nonpayable$_t_bytes4_$_t_address_$returns$__$","typeString":"function (bytes4,address) external"}},"id":58723,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"17917:72:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":58724,"nodeType":"ExpressionStatement","src":"17917:72:120"},{"assignments":[58726],"declarations":[{"constant":false,"id":58726,"mutability":"mutable","name":"proposer","nameLocation":"18016:8:120","nodeType":"VariableDeclaration","scope":58791,"src":"18008:16:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":58725,"name":"address","nodeType":"ElementaryTypeName","src":"18008:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"id":58732,"initialValue":{"arguments":[],"expression":{"argumentTypes":[],"expression":{"arguments":[{"id":58728,"name":"permissionedDisputeGameImpl","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58662,"src":"18036:27:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_address","typeString":"address"}],"id":58727,"name":"IFetcher","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57326,"src":"18027:8:120","typeDescriptions":{"typeIdentifier":"t_type$_t_contract$_IFetcher_$57326_$","typeString":"type(contract IFetcher)"}},"id":58729,"isConstant":false,"isLValue":false,"isPure":false,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"18027:37:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_contract$_IFetcher_$57326","typeString":"contract IFetcher"}},"id":58730,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"18065:8:120","memberName":"proposer","nodeType":"MemberAccess","referencedDeclaration":57295,"src":"18027:46:120","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":58731,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"18027:48:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"VariableDeclarationStatement","src":"18008:67:120"},{"expression":{"arguments":[{"expression":{"expression":{"id":58736,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58531,"src":"18101:3:120","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$58249","typeString":"contract FetchChainInfoOutput"}},"id":58737,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"18105:8:120","memberName":"proposer","nodeType":"MemberAccess","referencedDeclaration":58187,"src":"18101:12:120","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":58738,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"18114:8:120","memberName":"selector","nodeType":"MemberAccess","src":"18101:21:120","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},{"id":58739,"name":"proposer","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58726,"src":"18124:8:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_bytes4","typeString":"bytes4"},{"typeIdentifier":"t_address","typeString":"address"}],"expression":{"id":58733,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58531,"src":"18093:3:120","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$58249","typeString":"contract FetchChainInfoOutput"}},"id":58735,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"18097:3:120","memberName":"set","nodeType":"MemberAccess","referencedDeclaration":57740,"src":"18093:7:120","typeDescriptions":{"typeIdentifier":"t_function_external_nonpayable$_t_bytes4_$_t_address_$returns$__$","typeString":"function (bytes4,address) external"}},"id":58740,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"18093:40:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":58741,"nodeType":"ExpressionStatement","src":"18093:40:120"},{"assignments":[58743],"declarations":[{"constant":false,"id":58743,"mutability":"mutable","name":"delayedWethPermissionedGameProxy","nameLocation":"18160:32:120","nodeType":"VariableDeclaration","scope":58791,"src":"18152:40:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":58742,"name":"address","nodeType":"ElementaryTypeName","src":"18152:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"id":58747,"initialValue":{"arguments":[{"id":58745,"name":"permissionedDisputeGameImpl","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58662,"src":"18216:27:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_address","typeString":"address"}],"id":58744,"name":"_getDelayedWETHProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":59248,"src":"18195:20:120","typeDescriptions":{"typeIdentifier":"t_function_internal_view$_t_address_$returns$_t_address_$","typeString":"function (address) view returns (address)"}},"id":58746,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"18195:49:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"VariableDeclarationStatement","src":"18152:92:120"},{"expression":{"arguments":[{"expression":{"expression":{"id":58751,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58531,"src":"18270:3:120","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$58249","typeString":"contract FetchChainInfoOutput"}},"id":58752,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"18274:32:120","memberName":"delayedWethPermissionedGameProxy","nodeType":"MemberAccess","referencedDeclaration":58009,"src":"18270:36:120","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":58753,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"18307:8:120","memberName":"selector","nodeType":"MemberAccess","src":"18270:45:120","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},{"id":58754,"name":"delayedWethPermissionedGameProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58743,"src":"18317:32:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_bytes4","typeString":"bytes4"},{"typeIdentifier":"t_address","typeString":"address"}],"expression":{"id":58748,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58531,"src":"18262:3:120","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$58249","typeString":"contract FetchChainInfoOutput"}},"id":58750,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"18266:3:120","memberName":"set","nodeType":"MemberAccess","referencedDeclaration":57740,"src":"18262:7:120","typeDescriptions":{"typeIdentifier":"t_function_external_nonpayable$_t_bytes4_$_t_address_$returns$__$","typeString":"function (bytes4,address) external"}},"id":58755,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"18262:88:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":58756,"nodeType":"ExpressionStatement","src":"18262:88:120"},{"assignments":[58758],"declarations":[{"constant":false,"id":58758,"mutability":"mutable","name":"mipsImpl","nameLocation":"18377:8:120","nodeType":"VariableDeclaration","scope":58791,"src":"18369:16:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":58757,"name":"address","nodeType":"ElementaryTypeName","src":"18369:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"id":58764,"initialValue":{"arguments":[],"expression":{"argumentTypes":[],"expression":{"arguments":[{"id":58760,"name":"permissionedDisputeGameImpl","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58662,"src":"18397:27:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_address","typeString":"address"}],"id":58759,"name":"IFetcher","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57326,"src":"18388:8:120","typeDescriptions":{"typeIdentifier":"t_type$_t_contract$_IFetcher_$57326_$","typeString":"type(contract IFetcher)"}},"id":58761,"isConstant":false,"isLValue":false,"isPure":false,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"18388:37:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_contract$_IFetcher_$57326","typeString":"contract IFetcher"}},"id":58762,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"18426:2:120","memberName":"vm","nodeType":"MemberAccess","referencedDeclaration":57280,"src":"18388:40:120","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":58763,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"18388:42:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"VariableDeclarationStatement","src":"18369:61:120"},{"expression":{"arguments":[{"expression":{"expression":{"id":58768,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58531,"src":"18456:3:120","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$58249","typeString":"contract FetchChainInfoOutput"}},"id":58769,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"18460:8:120","memberName":"mipsImpl","nodeType":"MemberAccess","referencedDeclaration":58061,"src":"18456:12:120","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":58770,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"18469:8:120","memberName":"selector","nodeType":"MemberAccess","src":"18456:21:120","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},{"id":58771,"name":"mipsImpl","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58758,"src":"18479:8:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_bytes4","typeString":"bytes4"},{"typeIdentifier":"t_address","typeString":"address"}],"expression":{"id":58765,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58531,"src":"18448:3:120","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$58249","typeString":"contract FetchChainInfoOutput"}},"id":58767,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"18452:3:120","memberName":"set","nodeType":"MemberAccess","referencedDeclaration":57740,"src":"18448:7:120","typeDescriptions":{"typeIdentifier":"t_function_external_nonpayable$_t_bytes4_$_t_address_$returns$__$","typeString":"function (bytes4,address) external"}},"id":58772,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"18448:40:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":58773,"nodeType":"ExpressionStatement","src":"18448:40:120"},{"assignments":[58775],"declarations":[{"constant":false,"id":58775,"mutability":"mutable","name":"preimageOracleImpl","nameLocation":"18515:18:120","nodeType":"VariableDeclaration","scope":58791,"src":"18507:26:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":58774,"name":"address","nodeType":"ElementaryTypeName","src":"18507:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"id":58781,"initialValue":{"arguments":[],"expression":{"argumentTypes":[],"expression":{"arguments":[{"id":58777,"name":"mipsImpl","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58758,"src":"18545:8:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_address","typeString":"address"}],"id":58776,"name":"IFetcher","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57326,"src":"18536:8:120","typeDescriptions":{"typeIdentifier":"t_type$_t_contract$_IFetcher_$57326_$","typeString":"type(contract IFetcher)"}},"id":58778,"isConstant":false,"isLValue":false,"isPure":false,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"18536:18:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_contract$_IFetcher_$57326","typeString":"contract IFetcher"}},"id":58779,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"18555:6:120","memberName":"oracle","nodeType":"MemberAccess","referencedDeclaration":57285,"src":"18536:25:120","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":58780,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"18536:27:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"VariableDeclarationStatement","src":"18507:56:120"},{"expression":{"arguments":[{"expression":{"expression":{"id":58785,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58531,"src":"18589:3:120","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$58249","typeString":"contract FetchChainInfoOutput"}},"id":58786,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"18593:18:120","memberName":"preimageOracleImpl","nodeType":"MemberAccess","referencedDeclaration":58097,"src":"18589:22:120","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":58787,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"18612:8:120","memberName":"selector","nodeType":"MemberAccess","src":"18589:31:120","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},{"id":58788,"name":"preimageOracleImpl","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58775,"src":"18622:18:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_bytes4","typeString":"bytes4"},{"typeIdentifier":"t_address","typeString":"address"}],"expression":{"id":58782,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58531,"src":"18581:3:120","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$58249","typeString":"contract FetchChainInfoOutput"}},"id":58784,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"18585:3:120","memberName":"set","nodeType":"MemberAccess","referencedDeclaration":57740,"src":"18581:7:120","typeDescriptions":{"typeIdentifier":"t_function_external_nonpayable$_t_bytes4_$_t_address_$returns$__$","typeString":"function (bytes4,address) external"}},"id":58789,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"18581:60:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":58790,"nodeType":"ExpressionStatement","src":"18581:60:120"}]}},{"assignments":[58794],"declarations":[{"constant":false,"id":58794,"mutability":"mutable","name":"faultDisputeGameImpl","nameLocation":"18678:20:120","nodeType":"VariableDeclaration","scope":58840,"src":"18670:28:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":58793,"name":"address","nodeType":"ElementaryTypeName","src":"18670:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"id":58798,"initialValue":{"arguments":[{"id":58796,"name":"disputeGameFactoryProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58641,"src":"18722:23:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_address","typeString":"address"}],"id":58795,"name":"_getFaultDisputeGame","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":59145,"src":"18701:20:120","typeDescriptions":{"typeIdentifier":"t_function_internal_view$_t_address_$returns$_t_address_$","typeString":"function (address) view returns (address)"}},"id":58797,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"18701:45:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"VariableDeclarationStatement","src":"18670:76:120"},{"condition":{"commonType":{"typeIdentifier":"t_address","typeString":"address"},"id":58804,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftExpression":{"id":58799,"name":"faultDisputeGameImpl","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58794,"src":"18764:20:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"BinaryOperation","operator":"!=","rightExpression":{"arguments":[{"hexValue":"30","id":58802,"isConstant":false,"isLValue":false,"isPure":true,"kind":"number","lValueRequested":false,"nodeType":"Literal","src":"18796:1:120","typeDescriptions":{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"},"value":"0"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"}],"id":58801,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"nodeType":"ElementaryTypeNameExpression","src":"18788:7:120","typeDescriptions":{"typeIdentifier":"t_type$_t_address_$","typeString":"type(address)"},"typeName":{"id":58800,"name":"address","nodeType":"ElementaryTypeName","src":"18788:7:120","typeDescriptions":{}}},"id":58803,"isConstant":false,"isLValue":false,"isPure":true,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"18788:10:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"src":"18764:34:120","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},"id":58839,"nodeType":"IfStatement","src":"18760:470:120","trueBody":{"id":58838,"nodeType":"Block","src":"18800:430:120","statements":[{"expression":{"arguments":[{"expression":{"expression":{"id":58808,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58531,"src":"18883:3:120","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$58249","typeString":"contract FetchChainInfoOutput"}},"id":58809,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"18887:20:120","memberName":"faultDisputeGameImpl","nodeType":"MemberAccess","referencedDeclaration":58043,"src":"18883:24:120","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":58810,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"18908:8:120","memberName":"selector","nodeType":"MemberAccess","src":"18883:33:120","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},{"id":58811,"name":"faultDisputeGameImpl","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58794,"src":"18918:20:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_bytes4","typeString":"bytes4"},{"typeIdentifier":"t_address","typeString":"address"}],"expression":{"id":58805,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58531,"src":"18875:3:120","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$58249","typeString":"contract FetchChainInfoOutput"}},"id":58807,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"18879:3:120","memberName":"set","nodeType":"MemberAccess","referencedDeclaration":57740,"src":"18875:7:120","typeDescriptions":{"typeIdentifier":"t_function_external_nonpayable$_t_bytes4_$_t_address_$returns$__$","typeString":"function (bytes4,address) external"}},"id":58812,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"18875:64:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":58813,"nodeType":"ExpressionStatement","src":"18875:64:120"},{"expression":{"arguments":[{"expression":{"expression":{"id":58817,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58531,"src":"18965:3:120","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$58249","typeString":"contract FetchChainInfoOutput"}},"id":58818,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"18969:14:120","memberName":"permissionless","nodeType":"MemberAccess","referencedDeclaration":58239,"src":"18965:18:120","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_bool_$","typeString":"function () view external returns (bool)"}},"id":58819,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"18984:8:120","memberName":"selector","nodeType":"MemberAccess","src":"18965:27:120","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},{"hexValue":"74727565","id":58820,"isConstant":false,"isLValue":false,"isPure":true,"kind":"bool","lValueRequested":false,"nodeType":"Literal","src":"18994:4:120","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"},"value":"true"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_bytes4","typeString":"bytes4"},{"typeIdentifier":"t_bool","typeString":"bool"}],"expression":{"id":58814,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58531,"src":"18957:3:120","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$58249","typeString":"contract FetchChainInfoOutput"}},"id":58816,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"18961:3:120","memberName":"set","nodeType":"MemberAccess","referencedDeclaration":57772,"src":"18957:7:120","typeDescriptions":{"typeIdentifier":"t_function_external_nonpayable$_t_bytes4_$_t_bool_$returns$__$","typeString":"function (bytes4,bool) external"}},"id":58821,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"18957:42:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":58822,"nodeType":"ExpressionStatement","src":"18957:42:120"},{"assignments":[58824],"declarations":[{"constant":false,"id":58824,"mutability":"mutable","name":"delayedWethPermissionlessGameProxy","nameLocation":"19026:34:120","nodeType":"VariableDeclaration","scope":58838,"src":"19018:42:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":58823,"name":"address","nodeType":"ElementaryTypeName","src":"19018:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"id":58828,"initialValue":{"arguments":[{"id":58826,"name":"faultDisputeGameImpl","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58794,"src":"19084:20:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_address","typeString":"address"}],"id":58825,"name":"_getDelayedWETHProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":59248,"src":"19063:20:120","typeDescriptions":{"typeIdentifier":"t_function_internal_view$_t_address_$returns$_t_address_$","typeString":"function (address) view returns (address)"}},"id":58827,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"19063:42:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"VariableDeclarationStatement","src":"19018:87:120"},{"expression":{"arguments":[{"expression":{"expression":{"id":58832,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58531,"src":"19131:3:120","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$58249","typeString":"contract FetchChainInfoOutput"}},"id":58833,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"19135:34:120","memberName":"delayedWethPermissionlessGameProxy","nodeType":"MemberAccess","referencedDeclaration":58017,"src":"19131:38:120","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":58834,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"19170:8:120","memberName":"selector","nodeType":"MemberAccess","src":"19131:47:120","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},{"id":58835,"name":"delayedWethPermissionlessGameProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58824,"src":"19180:34:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_bytes4","typeString":"bytes4"},{"typeIdentifier":"t_address","typeString":"address"}],"expression":{"id":58829,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58531,"src":"19123:3:120","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$58249","typeString":"contract FetchChainInfoOutput"}},"id":58831,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"19127:3:120","memberName":"set","nodeType":"MemberAccess","referencedDeclaration":57740,"src":"19123:7:120","typeDescriptions":{"typeIdentifier":"t_function_external_nonpayable$_t_bytes4_$_t_address_$returns$__$","typeString":"function (bytes4,address) external"}},"id":58836,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"19123:92:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":58837,"nodeType":"ExpressionStatement","src":"19123:92:120"}]}}]}}]},"implemented":true,"kind":"function","modifiers":[],"name":"_processFaultProofs","nameLocation":"15931:19:120","parameters":{"id":58532,"nodeType":"ParameterList","parameters":[{"constant":false,"id":58531,"mutability":"mutable","name":"_fo","nameLocation":"15972:3:120","nodeType":"VariableDeclaration","scope":58878,"src":"15951:24:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$58249","typeString":"contract FetchChainInfoOutput"},"typeName":{"id":58530,"nodeType":"UserDefinedTypeName","pathNode":{"id":58529,"name":"FetchChainInfoOutput","nameLocations":["15951:20:120"],"nodeType":"IdentifierPath","referencedDeclaration":58249,"src":"15951:20:120"},"referencedDeclaration":58249,"src":"15951:20:120","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$58249","typeString":"contract FetchChainInfoOutput"}},"visibility":"internal"}],"src":"15950:26:120"},"returnParameters":{"id":58533,"nodeType":"ParameterList","parameters":[],"src":"15986:0:120"},"scope":59299,"stateMutability":"nonpayable","virtual":false,"visibility":"internal"},{"id":58907,"nodeType":"FunctionDefinition","src":"19641:256:120","nodes":[],"body":{"id":58906,"nodeType":"Block","src":"19712:185:120","nodes":[],"statements":[{"clauses":[{"block":{"id":58895,"nodeType":"Block","src":"19783:41:120","statements":[{"expression":{"id":58893,"name":"guardian_","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58891,"src":"19804:9:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"functionReturnParameters":58884,"id":58894,"nodeType":"Return","src":"19797:16:120"}]},"errorName":"","id":58896,"nodeType":"TryCatchClause","parameters":{"id":58892,"nodeType":"ParameterList","parameters":[{"constant":false,"id":58891,"mutability":"mutable","name":"guardian_","nameLocation":"19772:9:120","nodeType":"VariableDeclaration","scope":58896,"src":"19764:17:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":58890,"name":"address","nodeType":"ElementaryTypeName","src":"19764:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"19763:19:120"},"src":"19755:69:120"},{"block":{"id":58903,"nodeType":"Block","src":"19831:60:120","statements":[{"expression":{"arguments":[],"expression":{"argumentTypes":[],"expression":{"arguments":[{"id":58898,"name":"_portal","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58880,"src":"19861:7:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_address","typeString":"address"}],"id":58897,"name":"IFetcher","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57326,"src":"19852:8:120","typeDescriptions":{"typeIdentifier":"t_type$_t_contract$_IFetcher_$57326_$","typeString":"type(contract IFetcher)"}},"id":58899,"isConstant":false,"isLValue":false,"isPure":false,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"19852:17:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_contract$_IFetcher_$57326","typeString":"contract IFetcher"}},"id":58900,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"19870:8:120","memberName":"GUARDIAN","nodeType":"MemberAccess","referencedDeclaration":57191,"src":"19852:26:120","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":58901,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"19852:28:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"functionReturnParameters":58884,"id":58902,"nodeType":"Return","src":"19845:35:120"}]},"errorName":"","id":58904,"nodeType":"TryCatchClause","src":"19825:66:120"}],"externalCall":{"arguments":[],"expression":{"argumentTypes":[],"expression":{"arguments":[{"id":58886,"name":"_portal","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58880,"src":"19735:7:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_address","typeString":"address"}],"id":58885,"name":"IFetcher","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57326,"src":"19726:8:120","typeDescriptions":{"typeIdentifier":"t_type$_t_contract$_IFetcher_$57326_$","typeString":"type(contract IFetcher)"}},"id":58887,"isConstant":false,"isLValue":false,"isPure":false,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"19726:17:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_contract$_IFetcher_$57326","typeString":"contract IFetcher"}},"id":58888,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"19744:8:120","memberName":"guardian","nodeType":"MemberAccess","referencedDeclaration":57186,"src":"19726:26:120","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":58889,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"19726:28:120","tryCall":true,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"id":58905,"nodeType":"TryStatement","src":"19722:169:120"}]},"implemented":true,"kind":"function","modifiers":[],"name":"_getGuardian","nameLocation":"19650:12:120","parameters":{"id":58881,"nodeType":"ParameterList","parameters":[{"constant":false,"id":58880,"mutability":"mutable","name":"_portal","nameLocation":"19671:7:120","nodeType":"VariableDeclaration","scope":58907,"src":"19663:15:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":58879,"name":"address","nodeType":"ElementaryTypeName","src":"19663:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"19662:17:120"},"returnParameters":{"id":58884,"nodeType":"ParameterList","parameters":[{"constant":false,"id":58883,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":58907,"src":"19703:7:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":58882,"name":"address","nodeType":"ElementaryTypeName","src":"19703:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"19702:9:120"},"scope":59299,"stateMutability":"view","virtual":false,"visibility":"internal"},{"id":58936,"nodeType":"FunctionDefinition","src":"19903:282:120","nodes":[],"body":{"id":58935,"nodeType":"Block","src":"19983:202:120","nodes":[],"statements":[{"clauses":[{"block":{"id":58924,"nodeType":"Block","src":"20062:45:120","statements":[{"expression":{"id":58922,"name":"systemConfig_","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58920,"src":"20083:13:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"functionReturnParameters":58913,"id":58923,"nodeType":"Return","src":"20076:20:120"}]},"errorName":"","id":58925,"nodeType":"TryCatchClause","parameters":{"id":58921,"nodeType":"ParameterList","parameters":[{"constant":false,"id":58920,"mutability":"mutable","name":"systemConfig_","nameLocation":"20047:13:120","nodeType":"VariableDeclaration","scope":58925,"src":"20039:21:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":58919,"name":"address","nodeType":"ElementaryTypeName","src":"20039:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"20038:23:120"},"src":"20030:77:120"},{"block":{"id":58932,"nodeType":"Block","src":"20114:65:120","statements":[{"expression":{"arguments":[],"expression":{"argumentTypes":[],"expression":{"arguments":[{"id":58927,"name":"_portal","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58909,"src":"20144:7:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_address","typeString":"address"}],"id":58926,"name":"IFetcher","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57326,"src":"20135:8:120","typeDescriptions":{"typeIdentifier":"t_type$_t_contract$_IFetcher_$57326_$","typeString":"type(contract IFetcher)"}},"id":58928,"isConstant":false,"isLValue":false,"isPure":false,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"20135:17:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_contract$_IFetcher_$57326","typeString":"contract IFetcher"}},"id":58929,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"20153:13:120","memberName":"SYSTEM_CONFIG","nodeType":"MemberAccess","referencedDeclaration":57201,"src":"20135:31:120","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":58930,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"20135:33:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"functionReturnParameters":58913,"id":58931,"nodeType":"Return","src":"20128:40:120"}]},"errorName":"","id":58933,"nodeType":"TryCatchClause","src":"20108:71:120"}],"externalCall":{"arguments":[],"expression":{"argumentTypes":[],"expression":{"arguments":[{"id":58915,"name":"_portal","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58909,"src":"20006:7:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_address","typeString":"address"}],"id":58914,"name":"IFetcher","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57326,"src":"19997:8:120","typeDescriptions":{"typeIdentifier":"t_type$_t_contract$_IFetcher_$57326_$","typeString":"type(contract IFetcher)"}},"id":58916,"isConstant":false,"isLValue":false,"isPure":false,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"19997:17:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_contract$_IFetcher_$57326","typeString":"contract IFetcher"}},"id":58917,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"20015:12:120","memberName":"systemConfig","nodeType":"MemberAccess","referencedDeclaration":57196,"src":"19997:30:120","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":58918,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"19997:32:120","tryCall":true,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"id":58934,"nodeType":"TryStatement","src":"19993:186:120"}]},"implemented":true,"kind":"function","modifiers":[],"name":"_getSystemConfigProxy","nameLocation":"19912:21:120","parameters":{"id":58910,"nodeType":"ParameterList","parameters":[{"constant":false,"id":58909,"mutability":"mutable","name":"_portal","nameLocation":"19942:7:120","nodeType":"VariableDeclaration","scope":58936,"src":"19934:15:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":58908,"name":"address","nodeType":"ElementaryTypeName","src":"19934:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"19933:17:120"},"returnParameters":{"id":58913,"nodeType":"ParameterList","parameters":[{"constant":false,"id":58912,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":58936,"src":"19974:7:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":58911,"name":"address","nodeType":"ElementaryTypeName","src":"19974:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"19973:9:120"},"scope":59299,"stateMutability":"view","virtual":false,"visibility":"internal"},{"id":58965,"nodeType":"FunctionDefinition","src":"20191:338:120","nodes":[],"body":{"id":58964,"nodeType":"Block","src":"20294:235:120","nodes":[],"statements":[{"clauses":[{"block":{"id":58953,"nodeType":"Block","src":"20390:47:120","statements":[{"expression":{"id":58951,"name":"optimismPortal_","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58949,"src":"20411:15:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"functionReturnParameters":58942,"id":58952,"nodeType":"Return","src":"20404:22:120"}]},"errorName":"","id":58954,"nodeType":"TryCatchClause","parameters":{"id":58950,"nodeType":"ParameterList","parameters":[{"constant":false,"id":58949,"mutability":"mutable","name":"optimismPortal_","nameLocation":"20373:15:120","nodeType":"VariableDeclaration","scope":58954,"src":"20365:23:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":58948,"name":"address","nodeType":"ElementaryTypeName","src":"20365:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"20364:25:120"},"src":"20356:81:120"},{"block":{"id":58961,"nodeType":"Block","src":"20444:79:120","statements":[{"expression":{"arguments":[],"expression":{"argumentTypes":[],"expression":{"arguments":[{"id":58956,"name":"_l1CrossDomainMessengerProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58938,"src":"20474:28:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_address","typeString":"address"}],"id":58955,"name":"IFetcher","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57326,"src":"20465:8:120","typeDescriptions":{"typeIdentifier":"t_type$_t_contract$_IFetcher_$57326_$","typeString":"type(contract IFetcher)"}},"id":58957,"isConstant":false,"isLValue":false,"isPure":false,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"20465:38:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_contract$_IFetcher_$57326","typeString":"contract IFetcher"}},"id":58958,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"20504:6:120","memberName":"PORTAL","nodeType":"MemberAccess","referencedDeclaration":57231,"src":"20465:45:120","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":58959,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"20465:47:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"functionReturnParameters":58942,"id":58960,"nodeType":"Return","src":"20458:54:120"}]},"errorName":"","id":58962,"nodeType":"TryCatchClause","src":"20438:85:120"}],"externalCall":{"arguments":[],"expression":{"argumentTypes":[],"expression":{"arguments":[{"id":58944,"name":"_l1CrossDomainMessengerProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58938,"src":"20317:28:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_address","typeString":"address"}],"id":58943,"name":"IFetcher","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57326,"src":"20308:8:120","typeDescriptions":{"typeIdentifier":"t_type$_t_contract$_IFetcher_$57326_$","typeString":"type(contract IFetcher)"}},"id":58945,"isConstant":false,"isLValue":false,"isPure":false,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"20308:38:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_contract$_IFetcher_$57326","typeString":"contract IFetcher"}},"id":58946,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"20347:6:120","memberName":"portal","nodeType":"MemberAccess","referencedDeclaration":57236,"src":"20308:45:120","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":58947,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"20308:47:120","tryCall":true,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"id":58963,"nodeType":"TryStatement","src":"20304:219:120"}]},"implemented":true,"kind":"function","modifiers":[],"name":"_getOptimismPortalProxy","nameLocation":"20200:23:120","parameters":{"id":58939,"nodeType":"ParameterList","parameters":[{"constant":false,"id":58938,"mutability":"mutable","name":"_l1CrossDomainMessengerProxy","nameLocation":"20232:28:120","nodeType":"VariableDeclaration","scope":58965,"src":"20224:36:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":58937,"name":"address","nodeType":"ElementaryTypeName","src":"20224:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"20223:38:120"},"returnParameters":{"id":58942,"nodeType":"ParameterList","parameters":[{"constant":false,"id":58941,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":58965,"src":"20285:7:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":58940,"name":"address","nodeType":"ElementaryTypeName","src":"20285:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"20284:9:120"},"scope":59299,"stateMutability":"view","virtual":false,"visibility":"internal"},{"id":59003,"nodeType":"FunctionDefinition","src":"20535:350:120","nodes":[],"body":{"id":59002,"nodeType":"Block","src":"20633:252:120","nodes":[],"statements":[{"assignments":[58973],"declarations":[{"constant":false,"id":58973,"mutability":"mutable","name":"ADDRESS_MANAGER_MAPPING_SLOT","nameLocation":"20651:28:120","nodeType":"VariableDeclaration","scope":59002,"src":"20643:36:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_uint256","typeString":"uint256"},"typeName":{"id":58972,"name":"uint256","nodeType":"ElementaryTypeName","src":"20643:7:120","typeDescriptions":{"typeIdentifier":"t_uint256","typeString":"uint256"}},"visibility":"internal"}],"id":58975,"initialValue":{"hexValue":"31","id":58974,"isConstant":false,"isLValue":false,"isPure":true,"kind":"number","lValueRequested":false,"nodeType":"Literal","src":"20682:1:120","typeDescriptions":{"typeIdentifier":"t_rational_1_by_1","typeString":"int_const 1"},"value":"1"},"nodeType":"VariableDeclarationStatement","src":"20643:40:120"},{"assignments":[58977],"declarations":[{"constant":false,"id":58977,"mutability":"mutable","name":"slot","nameLocation":"20701:4:120","nodeType":"VariableDeclaration","scope":59002,"src":"20693:12:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_bytes32","typeString":"bytes32"},"typeName":{"id":58976,"name":"bytes32","nodeType":"ElementaryTypeName","src":"20693:7:120","typeDescriptions":{"typeIdentifier":"t_bytes32","typeString":"bytes32"}},"visibility":"internal"}],"id":58985,"initialValue":{"arguments":[{"arguments":[{"id":58981,"name":"_l1CrossDomainMessengerProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58967,"src":"20729:28:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},{"id":58982,"name":"ADDRESS_MANAGER_MAPPING_SLOT","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58973,"src":"20759:28:120","typeDescriptions":{"typeIdentifier":"t_uint256","typeString":"uint256"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_address","typeString":"address"},{"typeIdentifier":"t_uint256","typeString":"uint256"}],"expression":{"id":58979,"name":"abi","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":-1,"src":"20718:3:120","typeDescriptions":{"typeIdentifier":"t_magic_abi","typeString":"abi"}},"id":58980,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"memberLocation":"20722:6:120","memberName":"encode","nodeType":"MemberAccess","src":"20718:10:120","typeDescriptions":{"typeIdentifier":"t_function_abiencode_pure$__$returns$_t_bytes_memory_ptr_$","typeString":"function () pure returns (bytes memory)"}},"id":58983,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"20718:70:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_bytes_memory_ptr","typeString":"bytes memory"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_bytes_memory_ptr","typeString":"bytes memory"}],"id":58978,"name":"keccak256","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":-8,"src":"20708:9:120","typeDescriptions":{"typeIdentifier":"t_function_keccak256_pure$_t_bytes_memory_ptr_$returns$_t_bytes32_$","typeString":"function (bytes memory) pure returns (bytes32)"}},"id":58984,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"20708:81:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_bytes32","typeString":"bytes32"}},"nodeType":"VariableDeclarationStatement","src":"20693:96:120"},{"expression":{"arguments":[{"arguments":[{"arguments":[{"components":[{"arguments":[{"id":58994,"name":"_l1CrossDomainMessengerProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58967,"src":"20839:28:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},{"id":58995,"name":"slot","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58977,"src":"20869:4:120","typeDescriptions":{"typeIdentifier":"t_bytes32","typeString":"bytes32"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_address","typeString":"address"},{"typeIdentifier":"t_bytes32","typeString":"bytes32"}],"expression":{"id":58992,"name":"vm","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":5980,"src":"20831:2:120","typeDescriptions":{"typeIdentifier":"t_contract$_Vm_$23767","typeString":"contract Vm"}},"id":58993,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"20834:4:120","memberName":"load","nodeType":"MemberAccess","referencedDeclaration":19863,"src":"20831:7:120","typeDescriptions":{"typeIdentifier":"t_function_external_view$_t_address_$_t_bytes32_$returns$_t_bytes32_$","typeString":"function (address,bytes32) view external returns (bytes32)"}},"id":58996,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"20831:43:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_bytes32","typeString":"bytes32"}}],"id":58997,"isConstant":false,"isInlineArray":false,"isLValue":false,"isPure":false,"lValueRequested":false,"nodeType":"TupleExpression","src":"20830:45:120","typeDescriptions":{"typeIdentifier":"t_bytes32","typeString":"bytes32"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_bytes32","typeString":"bytes32"}],"id":58991,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"nodeType":"ElementaryTypeNameExpression","src":"20822:7:120","typeDescriptions":{"typeIdentifier":"t_type$_t_uint256_$","typeString":"type(uint256)"},"typeName":{"id":58990,"name":"uint256","nodeType":"ElementaryTypeName","src":"20822:7:120","typeDescriptions":{}}},"id":58998,"isConstant":false,"isLValue":false,"isPure":false,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"20822:54:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_uint256","typeString":"uint256"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_uint256","typeString":"uint256"}],"id":58989,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"nodeType":"ElementaryTypeNameExpression","src":"20814:7:120","typeDescriptions":{"typeIdentifier":"t_type$_t_uint160_$","typeString":"type(uint160)"},"typeName":{"id":58988,"name":"uint160","nodeType":"ElementaryTypeName","src":"20814:7:120","typeDescriptions":{}}},"id":58999,"isConstant":false,"isLValue":false,"isPure":false,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"20814:63:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_uint160","typeString":"uint160"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_uint160","typeString":"uint160"}],"id":58987,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"nodeType":"ElementaryTypeNameExpression","src":"20806:7:120","typeDescriptions":{"typeIdentifier":"t_type$_t_address_$","typeString":"type(address)"},"typeName":{"id":58986,"name":"address","nodeType":"ElementaryTypeName","src":"20806:7:120","typeDescriptions":{}}},"id":59000,"isConstant":false,"isLValue":false,"isPure":false,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"20806:72:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"functionReturnParameters":58971,"id":59001,"nodeType":"Return","src":"20799:79:120"}]},"implemented":true,"kind":"function","modifiers":[],"name":"_getAddressManager","nameLocation":"20544:18:120","parameters":{"id":58968,"nodeType":"ParameterList","parameters":[{"constant":false,"id":58967,"mutability":"mutable","name":"_l1CrossDomainMessengerProxy","nameLocation":"20571:28:120","nodeType":"VariableDeclaration","scope":59003,"src":"20563:36:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":58966,"name":"address","nodeType":"ElementaryTypeName","src":"20563:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"20562:38:120"},"returnParameters":{"id":58971,"nodeType":"ParameterList","parameters":[{"constant":false,"id":58970,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":59003,"src":"20624:7:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":58969,"name":"address","nodeType":"ElementaryTypeName","src":"20624:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"20623:9:120"},"scope":59299,"stateMutability":"view","virtual":false,"visibility":"internal"},{"id":59031,"nodeType":"FunctionDefinition","src":"20891:299:120","nodes":[],"body":{"id":59030,"nodeType":"Block","src":"20984:206:120","nodes":[],"statements":[{"clauses":[{"block":{"id":59020,"nodeType":"Block","src":"21083:52:120","statements":[{"expression":{"id":59018,"name":"l1ERC721BridgeProxy_","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":59016,"src":"21104:20:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"functionReturnParameters":59009,"id":59019,"nodeType":"Return","src":"21097:27:120"}]},"errorName":"","id":59021,"nodeType":"TryCatchClause","parameters":{"id":59017,"nodeType":"ParameterList","parameters":[{"constant":false,"id":59016,"mutability":"mutable","name":"l1ERC721BridgeProxy_","nameLocation":"21061:20:120","nodeType":"VariableDeclaration","scope":59021,"src":"21053:28:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":59015,"name":"address","nodeType":"ElementaryTypeName","src":"21053:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"21052:30:120"},"src":"21044:91:120"},{"block":{"id":59027,"nodeType":"Block","src":"21142:42:120","statements":[{"expression":{"arguments":[{"hexValue":"30","id":59024,"isConstant":false,"isLValue":false,"isPure":true,"kind":"number","lValueRequested":false,"nodeType":"Literal","src":"21171:1:120","typeDescriptions":{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"},"value":"0"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"}],"id":59023,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"nodeType":"ElementaryTypeNameExpression","src":"21163:7:120","typeDescriptions":{"typeIdentifier":"t_type$_t_address_$","typeString":"type(address)"},"typeName":{"id":59022,"name":"address","nodeType":"ElementaryTypeName","src":"21163:7:120","typeDescriptions":{}}},"id":59025,"isConstant":false,"isLValue":false,"isPure":true,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"21163:10:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"functionReturnParameters":59009,"id":59026,"nodeType":"Return","src":"21156:17:120"}]},"errorName":"","id":59028,"nodeType":"TryCatchClause","src":"21136:48:120"}],"externalCall":{"arguments":[],"expression":{"argumentTypes":[],"expression":{"arguments":[{"id":59011,"name":"_systemConfigProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":59005,"src":"21007:18:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_address","typeString":"address"}],"id":59010,"name":"IFetcher","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57326,"src":"20998:8:120","typeDescriptions":{"typeIdentifier":"t_type$_t_contract$_IFetcher_$57326_$","typeString":"type(contract IFetcher)"}},"id":59012,"isConstant":false,"isLValue":false,"isPure":false,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"20998:28:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_contract$_IFetcher_$57326","typeString":"contract IFetcher"}},"id":59013,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"21027:14:120","memberName":"l1ERC721Bridge","nodeType":"MemberAccess","referencedDeclaration":57241,"src":"20998:43:120","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":59014,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"20998:45:120","tryCall":true,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"id":59029,"nodeType":"TryStatement","src":"20994:190:120"}]},"implemented":true,"kind":"function","modifiers":[],"name":"_getL1ERC721BridgeProxy","nameLocation":"20900:23:120","parameters":{"id":59006,"nodeType":"ParameterList","parameters":[{"constant":false,"id":59005,"mutability":"mutable","name":"_systemConfigProxy","nameLocation":"20932:18:120","nodeType":"VariableDeclaration","scope":59031,"src":"20924:26:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":59004,"name":"address","nodeType":"ElementaryTypeName","src":"20924:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"20923:28:120"},"returnParameters":{"id":59009,"nodeType":"ParameterList","parameters":[{"constant":false,"id":59008,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":59031,"src":"20975:7:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":59007,"name":"address","nodeType":"ElementaryTypeName","src":"20975:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"20974:9:120"},"scope":59299,"stateMutability":"view","virtual":false,"visibility":"internal"},{"id":59059,"nodeType":"FunctionDefinition","src":"21196:377:120","nodes":[],"body":{"id":59058,"nodeType":"Block","src":"21303:270:120","nodes":[],"statements":[{"clauses":[{"block":{"id":59048,"nodeType":"Block","src":"21452:66:120","statements":[{"expression":{"id":59046,"name":"optimismMintableERC20FactoryProxy_","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":59044,"src":"21473:34:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"functionReturnParameters":59037,"id":59047,"nodeType":"Return","src":"21466:41:120"}]},"errorName":"","id":59049,"nodeType":"TryCatchClause","parameters":{"id":59045,"nodeType":"ParameterList","parameters":[{"constant":false,"id":59044,"mutability":"mutable","name":"optimismMintableERC20FactoryProxy_","nameLocation":"21407:34:120","nodeType":"VariableDeclaration","scope":59049,"src":"21399:42:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":59043,"name":"address","nodeType":"ElementaryTypeName","src":"21399:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"21385:66:120"},"src":"21377:141:120"},{"block":{"id":59055,"nodeType":"Block","src":"21525:42:120","statements":[{"expression":{"arguments":[{"hexValue":"30","id":59052,"isConstant":false,"isLValue":false,"isPure":true,"kind":"number","lValueRequested":false,"nodeType":"Literal","src":"21554:1:120","typeDescriptions":{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"},"value":"0"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"}],"id":59051,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"nodeType":"ElementaryTypeNameExpression","src":"21546:7:120","typeDescriptions":{"typeIdentifier":"t_type$_t_address_$","typeString":"type(address)"},"typeName":{"id":59050,"name":"address","nodeType":"ElementaryTypeName","src":"21546:7:120","typeDescriptions":{}}},"id":59053,"isConstant":false,"isLValue":false,"isPure":true,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"21546:10:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"functionReturnParameters":59037,"id":59054,"nodeType":"Return","src":"21539:17:120"}]},"errorName":"","id":59056,"nodeType":"TryCatchClause","src":"21519:48:120"}],"externalCall":{"arguments":[],"expression":{"argumentTypes":[],"expression":{"arguments":[{"id":59039,"name":"_systemConfigProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":59033,"src":"21326:18:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_address","typeString":"address"}],"id":59038,"name":"IFetcher","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57326,"src":"21317:8:120","typeDescriptions":{"typeIdentifier":"t_type$_t_contract$_IFetcher_$57326_$","typeString":"type(contract IFetcher)"}},"id":59040,"isConstant":false,"isLValue":false,"isPure":false,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"21317:28:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_contract$_IFetcher_$57326","typeString":"contract IFetcher"}},"id":59041,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"21346:28:120","memberName":"optimismMintableERC20Factory","nodeType":"MemberAccess","referencedDeclaration":57246,"src":"21317:57:120","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":59042,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"21317:59:120","tryCall":true,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"id":59057,"nodeType":"TryStatement","src":"21313:254:120"}]},"implemented":true,"kind":"function","modifiers":[],"name":"_getOptimismMintableERC20FactoryProxy","nameLocation":"21205:37:120","parameters":{"id":59034,"nodeType":"ParameterList","parameters":[{"constant":false,"id":59033,"mutability":"mutable","name":"_systemConfigProxy","nameLocation":"21251:18:120","nodeType":"VariableDeclaration","scope":59059,"src":"21243:26:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":59032,"name":"address","nodeType":"ElementaryTypeName","src":"21243:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"21242:28:120"},"returnParameters":{"id":59037,"nodeType":"ParameterList","parameters":[{"constant":false,"id":59036,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":59059,"src":"21294:7:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":59035,"name":"address","nodeType":"ElementaryTypeName","src":"21294:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"21293:9:120"},"scope":59299,"stateMutability":"view","virtual":false,"visibility":"internal"},{"id":59087,"nodeType":"FunctionDefinition","src":"21579:398:120","nodes":[],"body":{"id":59086,"nodeType":"Block","src":"21676:301:120","nodes":[],"statements":[{"clauses":[{"block":{"id":59076,"nodeType":"Block","src":"21783:56:120","statements":[{"expression":{"id":59074,"name":"disputeGameFactoryProxy_","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":59072,"src":"21804:24:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"functionReturnParameters":59065,"id":59075,"nodeType":"Return","src":"21797:31:120"}]},"errorName":"","id":59077,"nodeType":"TryCatchClause","parameters":{"id":59073,"nodeType":"ParameterList","parameters":[{"constant":false,"id":59072,"mutability":"mutable","name":"disputeGameFactoryProxy_","nameLocation":"21757:24:120","nodeType":"VariableDeclaration","scope":59077,"src":"21749:32:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":59071,"name":"address","nodeType":"ElementaryTypeName","src":"21749:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"21748:34:120"},"src":"21740:99:120"},{"block":{"id":59083,"nodeType":"Block","src":"21846:125:120","statements":[{"expression":{"arguments":[{"hexValue":"30","id":59080,"isConstant":false,"isLValue":false,"isPure":true,"kind":"number","lValueRequested":false,"nodeType":"Literal","src":"21958:1:120","typeDescriptions":{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"},"value":"0"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"}],"id":59079,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"nodeType":"ElementaryTypeNameExpression","src":"21950:7:120","typeDescriptions":{"typeIdentifier":"t_type$_t_address_$","typeString":"type(address)"},"typeName":{"id":59078,"name":"address","nodeType":"ElementaryTypeName","src":"21950:7:120","typeDescriptions":{}}},"id":59081,"isConstant":false,"isLValue":false,"isPure":true,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"21950:10:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"functionReturnParameters":59065,"id":59082,"nodeType":"Return","src":"21943:17:120"}]},"errorName":"","id":59084,"nodeType":"TryCatchClause","src":"21840:131:120"}],"externalCall":{"arguments":[],"expression":{"argumentTypes":[],"expression":{"arguments":[{"id":59067,"name":"_systemConfigProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":59061,"src":"21699:18:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_address","typeString":"address"}],"id":59066,"name":"IFetcher","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57326,"src":"21690:8:120","typeDescriptions":{"typeIdentifier":"t_type$_t_contract$_IFetcher_$57326_$","typeString":"type(contract IFetcher)"}},"id":59068,"isConstant":false,"isLValue":false,"isPure":false,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"21690:28:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_contract$_IFetcher_$57326","typeString":"contract IFetcher"}},"id":59069,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"21719:18:120","memberName":"disputeGameFactory","nodeType":"MemberAccess","referencedDeclaration":57206,"src":"21690:47:120","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":59070,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"21690:49:120","tryCall":true,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"id":59085,"nodeType":"TryStatement","src":"21686:285:120"}]},"implemented":true,"kind":"function","modifiers":[],"name":"_getDisputeGameFactoryProxy","nameLocation":"21588:27:120","parameters":{"id":59062,"nodeType":"ParameterList","parameters":[{"constant":false,"id":59061,"mutability":"mutable","name":"_systemConfigProxy","nameLocation":"21624:18:120","nodeType":"VariableDeclaration","scope":59087,"src":"21616:26:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":59060,"name":"address","nodeType":"ElementaryTypeName","src":"21616:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"21615:28:120"},"returnParameters":{"id":59065,"nodeType":"ParameterList","parameters":[{"constant":false,"id":59064,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":59087,"src":"21667:7:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":59063,"name":"address","nodeType":"ElementaryTypeName","src":"21667:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"21666:9:120"},"scope":59299,"stateMutability":"view","virtual":false,"visibility":"internal"},{"id":59115,"nodeType":"FunctionDefinition","src":"21983:311:120","nodes":[],"body":{"id":59114,"nodeType":"Block","src":"22080:214:120","nodes":[],"statements":[{"clauses":[{"block":{"id":59104,"nodeType":"Block","src":"22185:54:120","statements":[{"expression":{"id":59102,"name":"superchainConfigProxy_","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":59100,"src":"22206:22:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"functionReturnParameters":59093,"id":59103,"nodeType":"Return","src":"22199:29:120"}]},"errorName":"","id":59105,"nodeType":"TryCatchClause","parameters":{"id":59101,"nodeType":"ParameterList","parameters":[{"constant":false,"id":59100,"mutability":"mutable","name":"superchainConfigProxy_","nameLocation":"22161:22:120","nodeType":"VariableDeclaration","scope":59105,"src":"22153:30:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":59099,"name":"address","nodeType":"ElementaryTypeName","src":"22153:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"22152:32:120"},"src":"22144:95:120"},{"block":{"id":59111,"nodeType":"Block","src":"22246:42:120","statements":[{"expression":{"arguments":[{"hexValue":"30","id":59108,"isConstant":false,"isLValue":false,"isPure":true,"kind":"number","lValueRequested":false,"nodeType":"Literal","src":"22275:1:120","typeDescriptions":{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"},"value":"0"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"}],"id":59107,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"nodeType":"ElementaryTypeNameExpression","src":"22267:7:120","typeDescriptions":{"typeIdentifier":"t_type$_t_address_$","typeString":"type(address)"},"typeName":{"id":59106,"name":"address","nodeType":"ElementaryTypeName","src":"22267:7:120","typeDescriptions":{}}},"id":59109,"isConstant":false,"isLValue":false,"isPure":true,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"22267:10:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"functionReturnParameters":59093,"id":59110,"nodeType":"Return","src":"22260:17:120"}]},"errorName":"","id":59112,"nodeType":"TryCatchClause","src":"22240:48:120"}],"externalCall":{"arguments":[],"expression":{"argumentTypes":[],"expression":{"arguments":[{"id":59095,"name":"_optimismPortalProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":59089,"src":"22103:20:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_address","typeString":"address"}],"id":59094,"name":"IFetcher","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57326,"src":"22094:8:120","typeDescriptions":{"typeIdentifier":"t_type$_t_contract$_IFetcher_$57326_$","typeString":"type(contract IFetcher)"}},"id":59096,"isConstant":false,"isLValue":false,"isPure":false,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"22094:30:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_contract$_IFetcher_$57326","typeString":"contract IFetcher"}},"id":59097,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"22125:16:120","memberName":"superchainConfig","nodeType":"MemberAccess","referencedDeclaration":57216,"src":"22094:47:120","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":59098,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"22094:49:120","tryCall":true,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"id":59113,"nodeType":"TryStatement","src":"22090:198:120"}]},"implemented":true,"kind":"function","modifiers":[],"name":"_getSuperchainConfigProxy","nameLocation":"21992:25:120","parameters":{"id":59090,"nodeType":"ParameterList","parameters":[{"constant":false,"id":59089,"mutability":"mutable","name":"_optimismPortalProxy","nameLocation":"22026:20:120","nodeType":"VariableDeclaration","scope":59115,"src":"22018:28:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":59088,"name":"address","nodeType":"ElementaryTypeName","src":"22018:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"22017:30:120"},"returnParameters":{"id":59093,"nodeType":"ParameterList","parameters":[{"constant":false,"id":59092,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":59115,"src":"22071:7:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":59091,"name":"address","nodeType":"ElementaryTypeName","src":"22071:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"22070:9:120"},"scope":59299,"stateMutability":"view","virtual":false,"visibility":"internal"},{"id":59145,"nodeType":"FunctionDefinition","src":"22300:313:120","nodes":[],"body":{"id":59144,"nodeType":"Block","src":"22396:217:120","nodes":[],"statements":[{"clauses":[{"block":{"id":59134,"nodeType":"Block","src":"22509:49:120","statements":[{"expression":{"id":59132,"name":"faultDisputeGame_","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":59130,"src":"22530:17:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"functionReturnParameters":59121,"id":59133,"nodeType":"Return","src":"22523:24:120"}]},"errorName":"","id":59135,"nodeType":"TryCatchClause","parameters":{"id":59131,"nodeType":"ParameterList","parameters":[{"constant":false,"id":59130,"mutability":"mutable","name":"faultDisputeGame_","nameLocation":"22490:17:120","nodeType":"VariableDeclaration","scope":59135,"src":"22482:25:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":59129,"name":"address","nodeType":"ElementaryTypeName","src":"22482:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"22481:27:120"},"src":"22473:85:120"},{"block":{"id":59141,"nodeType":"Block","src":"22565:42:120","statements":[{"expression":{"arguments":[{"hexValue":"30","id":59138,"isConstant":false,"isLValue":false,"isPure":true,"kind":"number","lValueRequested":false,"nodeType":"Literal","src":"22594:1:120","typeDescriptions":{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"},"value":"0"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"}],"id":59137,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"nodeType":"ElementaryTypeNameExpression","src":"22586:7:120","typeDescriptions":{"typeIdentifier":"t_type$_t_address_$","typeString":"type(address)"},"typeName":{"id":59136,"name":"address","nodeType":"ElementaryTypeName","src":"22586:7:120","typeDescriptions":{}}},"id":59139,"isConstant":false,"isLValue":false,"isPure":true,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"22586:10:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"functionReturnParameters":59121,"id":59140,"nodeType":"Return","src":"22579:17:120"}]},"errorName":"","id":59142,"nodeType":"TryCatchClause","src":"22559:48:120"}],"externalCall":{"arguments":[{"expression":{"id":59126,"name":"GameTypes","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":75481,"src":"22455:9:120","typeDescriptions":{"typeIdentifier":"t_type$_t_contract$_GameTypes_$75481_$","typeString":"type(library GameTypes)"}},"id":59127,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"memberLocation":"22465:6:120","memberName":"CANNON","nodeType":"MemberAccess","referencedDeclaration":75408,"src":"22455:16:120","typeDescriptions":{"typeIdentifier":"t_userDefinedValueType$_GameType_$75355","typeString":"GameType"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_userDefinedValueType$_GameType_$75355","typeString":"GameType"}],"expression":{"arguments":[{"id":59123,"name":"_disputeGameFactoryProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":59117,"src":"22419:24:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_address","typeString":"address"}],"id":59122,"name":"IFetcher","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57326,"src":"22410:8:120","typeDescriptions":{"typeIdentifier":"t_type$_t_contract$_IFetcher_$57326_$","typeString":"type(contract IFetcher)"}},"id":59124,"isConstant":false,"isLValue":false,"isPure":false,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"22410:34:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_contract$_IFetcher_$57326","typeString":"contract IFetcher"}},"id":59125,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"22445:9:120","memberName":"gameImpls","nodeType":"MemberAccess","referencedDeclaration":57254,"src":"22410:44:120","typeDescriptions":{"typeIdentifier":"t_function_external_view$_t_userDefinedValueType$_GameType_$75355_$returns$_t_address_$","typeString":"function (GameType) view external returns (address)"}},"id":59128,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"22410:62:120","tryCall":true,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"id":59143,"nodeType":"TryStatement","src":"22406:201:120"}]},"implemented":true,"kind":"function","modifiers":[],"name":"_getFaultDisputeGame","nameLocation":"22309:20:120","parameters":{"id":59118,"nodeType":"ParameterList","parameters":[{"constant":false,"id":59117,"mutability":"mutable","name":"_disputeGameFactoryProxy","nameLocation":"22338:24:120","nodeType":"VariableDeclaration","scope":59145,"src":"22330:32:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":59116,"name":"address","nodeType":"ElementaryTypeName","src":"22330:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"22329:34:120"},"returnParameters":{"id":59121,"nodeType":"ParameterList","parameters":[{"constant":false,"id":59120,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":59145,"src":"22387:7:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":59119,"name":"address","nodeType":"ElementaryTypeName","src":"22387:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"22386:9:120"},"scope":59299,"stateMutability":"view","virtual":false,"visibility":"internal"},{"id":59175,"nodeType":"FunctionDefinition","src":"22619:369:120","nodes":[],"body":{"id":59174,"nodeType":"Block","src":"22722:266:120","nodes":[],"statements":[{"clauses":[{"block":{"id":59164,"nodeType":"Block","src":"22877:56:120","statements":[{"expression":{"id":59162,"name":"permissionedDisputeGame_","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":59160,"src":"22898:24:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"functionReturnParameters":59151,"id":59163,"nodeType":"Return","src":"22891:31:120"}]},"errorName":"","id":59165,"nodeType":"TryCatchClause","parameters":{"id":59161,"nodeType":"ParameterList","parameters":[{"constant":false,"id":59160,"mutability":"mutable","name":"permissionedDisputeGame_","nameLocation":"22842:24:120","nodeType":"VariableDeclaration","scope":59165,"src":"22834:32:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":59159,"name":"address","nodeType":"ElementaryTypeName","src":"22834:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"22820:56:120"},"src":"22812:121:120"},{"block":{"id":59171,"nodeType":"Block","src":"22940:42:120","statements":[{"expression":{"arguments":[{"hexValue":"30","id":59168,"isConstant":false,"isLValue":false,"isPure":true,"kind":"number","lValueRequested":false,"nodeType":"Literal","src":"22969:1:120","typeDescriptions":{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"},"value":"0"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"}],"id":59167,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"nodeType":"ElementaryTypeNameExpression","src":"22961:7:120","typeDescriptions":{"typeIdentifier":"t_type$_t_address_$","typeString":"type(address)"},"typeName":{"id":59166,"name":"address","nodeType":"ElementaryTypeName","src":"22961:7:120","typeDescriptions":{}}},"id":59169,"isConstant":false,"isLValue":false,"isPure":true,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"22961:10:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"functionReturnParameters":59151,"id":59170,"nodeType":"Return","src":"22954:17:120"}]},"errorName":"","id":59172,"nodeType":"TryCatchClause","src":"22934:48:120"}],"externalCall":{"arguments":[{"expression":{"id":59156,"name":"GameTypes","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":75481,"src":"22781:9:120","typeDescriptions":{"typeIdentifier":"t_type$_t_contract$_GameTypes_$75481_$","typeString":"type(library GameTypes)"}},"id":59157,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"memberLocation":"22791:19:120","memberName":"PERMISSIONED_CANNON","nodeType":"MemberAccess","referencedDeclaration":75416,"src":"22781:29:120","typeDescriptions":{"typeIdentifier":"t_userDefinedValueType$_GameType_$75355","typeString":"GameType"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_userDefinedValueType$_GameType_$75355","typeString":"GameType"}],"expression":{"arguments":[{"id":59153,"name":"_disputeGameFactoryProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":59147,"src":"22745:24:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_address","typeString":"address"}],"id":59152,"name":"IFetcher","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57326,"src":"22736:8:120","typeDescriptions":{"typeIdentifier":"t_type$_t_contract$_IFetcher_$57326_$","typeString":"type(contract IFetcher)"}},"id":59154,"isConstant":false,"isLValue":false,"isPure":false,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"22736:34:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_contract$_IFetcher_$57326","typeString":"contract IFetcher"}},"id":59155,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"22771:9:120","memberName":"gameImpls","nodeType":"MemberAccess","referencedDeclaration":57254,"src":"22736:44:120","typeDescriptions":{"typeIdentifier":"t_function_external_view$_t_userDefinedValueType$_GameType_$75355_$returns$_t_address_$","typeString":"function (GameType) view external returns (address)"}},"id":59158,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"22736:75:120","tryCall":true,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"id":59173,"nodeType":"TryStatement","src":"22732:250:120"}]},"implemented":true,"kind":"function","modifiers":[],"name":"_getPermissionedDisputeGame","nameLocation":"22628:27:120","parameters":{"id":59148,"nodeType":"ParameterList","parameters":[{"constant":false,"id":59147,"mutability":"mutable","name":"_disputeGameFactoryProxy","nameLocation":"22664:24:120","nodeType":"VariableDeclaration","scope":59175,"src":"22656:32:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":59146,"name":"address","nodeType":"ElementaryTypeName","src":"22656:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"22655:34:120"},"returnParameters":{"id":59151,"nodeType":"ParameterList","parameters":[{"constant":false,"id":59150,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":59175,"src":"22713:7:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":59149,"name":"address","nodeType":"ElementaryTypeName","src":"22713:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"22712:9:120"},"scope":59299,"stateMutability":"view","virtual":false,"visibility":"internal"},{"id":59203,"nodeType":"FunctionDefinition","src":"22994:277:120","nodes":[],"body":{"id":59202,"nodeType":"Block","src":"23085:186:120","nodes":[],"statements":[{"clauses":[{"block":{"id":59192,"nodeType":"Block","src":"23173:43:120","statements":[{"expression":{"id":59190,"name":"ethLockbox_","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":59188,"src":"23194:11:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"functionReturnParameters":59181,"id":59191,"nodeType":"Return","src":"23187:18:120"}]},"errorName":"","id":59193,"nodeType":"TryCatchClause","parameters":{"id":59189,"nodeType":"ParameterList","parameters":[{"constant":false,"id":59188,"mutability":"mutable","name":"ethLockbox_","nameLocation":"23160:11:120","nodeType":"VariableDeclaration","scope":59193,"src":"23152:19:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":59187,"name":"address","nodeType":"ElementaryTypeName","src":"23152:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"23151:21:120"},"src":"23143:73:120"},{"block":{"id":59199,"nodeType":"Block","src":"23223:42:120","statements":[{"expression":{"arguments":[{"hexValue":"30","id":59196,"isConstant":false,"isLValue":false,"isPure":true,"kind":"number","lValueRequested":false,"nodeType":"Literal","src":"23252:1:120","typeDescriptions":{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"},"value":"0"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"}],"id":59195,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"nodeType":"ElementaryTypeNameExpression","src":"23244:7:120","typeDescriptions":{"typeIdentifier":"t_type$_t_address_$","typeString":"type(address)"},"typeName":{"id":59194,"name":"address","nodeType":"ElementaryTypeName","src":"23244:7:120","typeDescriptions":{}}},"id":59197,"isConstant":false,"isLValue":false,"isPure":true,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"23244:10:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"functionReturnParameters":59181,"id":59198,"nodeType":"Return","src":"23237:17:120"}]},"errorName":"","id":59200,"nodeType":"TryCatchClause","src":"23217:48:120"}],"externalCall":{"arguments":[],"expression":{"argumentTypes":[],"expression":{"arguments":[{"id":59183,"name":"_optimismPortalProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":59177,"src":"23108:20:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_address","typeString":"address"}],"id":59182,"name":"IFetcher","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57326,"src":"23099:8:120","typeDescriptions":{"typeIdentifier":"t_type$_t_contract$_IFetcher_$57326_$","typeString":"type(contract IFetcher)"}},"id":59184,"isConstant":false,"isLValue":false,"isPure":false,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"23099:30:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_contract$_IFetcher_$57326","typeString":"contract IFetcher"}},"id":59185,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"23130:10:120","memberName":"ethLockbox","nodeType":"MemberAccess","referencedDeclaration":57211,"src":"23099:41:120","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":59186,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"23099:43:120","tryCall":true,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"id":59201,"nodeType":"TryStatement","src":"23095:170:120"}]},"implemented":true,"kind":"function","modifiers":[],"name":"_getEthLockboxProxy","nameLocation":"23003:19:120","parameters":{"id":59178,"nodeType":"ParameterList","parameters":[{"constant":false,"id":59177,"mutability":"mutable","name":"_optimismPortalProxy","nameLocation":"23031:20:120","nodeType":"VariableDeclaration","scope":59203,"src":"23023:28:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":59176,"name":"address","nodeType":"ElementaryTypeName","src":"23023:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"23022:30:120"},"returnParameters":{"id":59181,"nodeType":"ParameterList","parameters":[{"constant":false,"id":59180,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":59203,"src":"23076:7:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":59179,"name":"address","nodeType":"ElementaryTypeName","src":"23076:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"23075:9:120"},"scope":59299,"stateMutability":"view","virtual":false,"visibility":"internal"},{"id":59248,"nodeType":"FunctionDefinition","src":"23277:304:120","nodes":[],"body":{"id":59247,"nodeType":"Block","src":"23361:220:120","nodes":[],"statements":[{"assignments":[59211,59213],"declarations":[{"constant":false,"id":59211,"mutability":"mutable","name":"ok","nameLocation":"23377:2:120","nodeType":"VariableDeclaration","scope":59247,"src":"23372:7:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"},"typeName":{"id":59210,"name":"bool","nodeType":"ElementaryTypeName","src":"23372:4:120","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},"visibility":"internal"},{"constant":false,"id":59213,"mutability":"mutable","name":"data","nameLocation":"23394:4:120","nodeType":"VariableDeclaration","scope":59247,"src":"23381:17:120","stateVariable":false,"storageLocation":"memory","typeDescriptions":{"typeIdentifier":"t_bytes_memory_ptr","typeString":"bytes"},"typeName":{"id":59212,"name":"bytes","nodeType":"ElementaryTypeName","src":"23381:5:120","typeDescriptions":{"typeIdentifier":"t_bytes_storage_ptr","typeString":"bytes"}},"visibility":"internal"}],"id":59226,"initialValue":{"arguments":[{"arguments":[{"expression":{"id":59221,"name":"IFetcher","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57326,"src":"23450:8:120","typeDescriptions":{"typeIdentifier":"t_type$_t_contract$_IFetcher_$57326_$","typeString":"type(contract IFetcher)"}},"id":59222,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"memberLocation":"23459:4:120","memberName":"weth","nodeType":"MemberAccess","referencedDeclaration":57325,"src":"23450:13:120","typeDescriptions":{"typeIdentifier":"t_function_declaration_view$__$returns$_t_address_$","typeString":"function IFetcher.weth() view returns (address)"}},{"components":[],"id":59223,"isConstant":false,"isInlineArray":false,"isLValue":false,"isPure":true,"lValueRequested":false,"nodeType":"TupleExpression","src":"23465:2:120","typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_function_declaration_view$__$returns$_t_address_$","typeString":"function IFetcher.weth() view returns (address)"},{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}],"expression":{"id":59219,"name":"abi","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":-1,"src":"23435:3:120","typeDescriptions":{"typeIdentifier":"t_magic_abi","typeString":"abi"}},"id":59220,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"memberLocation":"23439:10:120","memberName":"encodeCall","nodeType":"MemberAccess","src":"23435:14:120","typeDescriptions":{"typeIdentifier":"t_function_abiencodecall_pure$__$returns$_t_bytes_memory_ptr_$","typeString":"function () pure returns (bytes memory)"}},"id":59224,"isConstant":false,"isLValue":false,"isPure":true,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"23435:33:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_bytes_memory_ptr","typeString":"bytes memory"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_bytes_memory_ptr","typeString":"bytes memory"}],"expression":{"arguments":[{"id":59216,"name":"_disputeGame","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":59205,"src":"23410:12:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_address","typeString":"address"}],"id":59215,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"nodeType":"ElementaryTypeNameExpression","src":"23402:7:120","typeDescriptions":{"typeIdentifier":"t_type$_t_address_$","typeString":"type(address)"},"typeName":{"id":59214,"name":"address","nodeType":"ElementaryTypeName","src":"23402:7:120","typeDescriptions":{}}},"id":59217,"isConstant":false,"isLValue":false,"isPure":false,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"23402:21:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"id":59218,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"23424:10:120","memberName":"staticcall","nodeType":"MemberAccess","src":"23402:32:120","typeDescriptions":{"typeIdentifier":"t_function_barestaticcall_view$_t_bytes_memory_ptr_$returns$_t_bool_$_t_bytes_memory_ptr_$","typeString":"function (bytes memory) view returns (bool,bytes memory)"}},"id":59225,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"23402:67:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$_t_bool_$_t_bytes_memory_ptr_$","typeString":"tuple(bool,bytes memory)"}},"nodeType":"VariableDeclarationStatement","src":"23371:98:120"},{"condition":{"commonType":{"typeIdentifier":"t_bool","typeString":"bool"},"id":59232,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftExpression":{"id":59227,"name":"ok","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":59211,"src":"23483:2:120","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},"nodeType":"BinaryOperation","operator":"&&","rightExpression":{"commonType":{"typeIdentifier":"t_uint256","typeString":"uint256"},"id":59231,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftExpression":{"expression":{"id":59228,"name":"data","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":59213,"src":"23489:4:120","typeDescriptions":{"typeIdentifier":"t_bytes_memory_ptr","typeString":"bytes memory"}},"id":59229,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"23494:6:120","memberName":"length","nodeType":"MemberAccess","src":"23489:11:120","typeDescriptions":{"typeIdentifier":"t_uint256","typeString":"uint256"}},"nodeType":"BinaryOperation","operator":"==","rightExpression":{"hexValue":"3332","id":59230,"isConstant":false,"isLValue":false,"isPure":true,"kind":"number","lValueRequested":false,"nodeType":"Literal","src":"23504:2:120","typeDescriptions":{"typeIdentifier":"t_rational_32_by_1","typeString":"int_const 32"},"value":"32"},"src":"23489:17:120","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},"src":"23483:23:120","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},"falseBody":{"expression":{"arguments":[{"hexValue":"30","id":59243,"isConstant":false,"isLValue":false,"isPure":true,"kind":"number","lValueRequested":false,"nodeType":"Literal","src":"23572:1:120","typeDescriptions":{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"},"value":"0"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"}],"id":59242,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"nodeType":"ElementaryTypeNameExpression","src":"23564:7:120","typeDescriptions":{"typeIdentifier":"t_type$_t_address_$","typeString":"type(address)"},"typeName":{"id":59241,"name":"address","nodeType":"ElementaryTypeName","src":"23564:7:120","typeDescriptions":{}}},"id":59244,"isConstant":false,"isLValue":false,"isPure":true,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"23564:10:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"functionReturnParameters":59209,"id":59245,"nodeType":"Return","src":"23557:17:120"},"id":59246,"nodeType":"IfStatement","src":"23479:95:120","trueBody":{"expression":{"arguments":[{"id":59235,"name":"data","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":59213,"src":"23526:4:120","typeDescriptions":{"typeIdentifier":"t_bytes_memory_ptr","typeString":"bytes memory"}},{"components":[{"id":59237,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"nodeType":"ElementaryTypeNameExpression","src":"23533:7:120","typeDescriptions":{"typeIdentifier":"t_type$_t_address_$","typeString":"type(address)"},"typeName":{"id":59236,"name":"address","nodeType":"ElementaryTypeName","src":"23533:7:120","typeDescriptions":{}}}],"id":59238,"isConstant":false,"isInlineArray":false,"isLValue":false,"isPure":true,"lValueRequested":false,"nodeType":"TupleExpression","src":"23532:9:120","typeDescriptions":{"typeIdentifier":"t_type$_t_address_$","typeString":"type(address)"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_bytes_memory_ptr","typeString":"bytes memory"},{"typeIdentifier":"t_type$_t_address_$","typeString":"type(address)"}],"expression":{"id":59233,"name":"abi","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":-1,"src":"23515:3:120","typeDescriptions":{"typeIdentifier":"t_magic_abi","typeString":"abi"}},"id":59234,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"memberLocation":"23519:6:120","memberName":"decode","nodeType":"MemberAccess","src":"23515:10:120","typeDescriptions":{"typeIdentifier":"t_function_abidecode_pure$__$returns$__$","typeString":"function () pure"}},"id":59239,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"23515:27:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address_payable","typeString":"address payable"}},"functionReturnParameters":59209,"id":59240,"nodeType":"Return","src":"23508:34:120"}}]},"implemented":true,"kind":"function","modifiers":[],"name":"_getDelayedWETHProxy","nameLocation":"23286:20:120","parameters":{"id":59206,"nodeType":"ParameterList","parameters":[{"constant":false,"id":59205,"mutability":"mutable","name":"_disputeGame","nameLocation":"23315:12:120","nodeType":"VariableDeclaration","scope":59248,"src":"23307:20:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":59204,"name":"address","nodeType":"ElementaryTypeName","src":"23307:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"23306:22:120"},"returnParameters":{"id":59209,"nodeType":"ParameterList","parameters":[{"constant":false,"id":59208,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":59248,"src":"23352:7:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":59207,"name":"address","nodeType":"ElementaryTypeName","src":"23352:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"23351:9:120"},"scope":59299,"stateMutability":"view","virtual":false,"visibility":"internal"},{"id":59275,"nodeType":"FunctionDefinition","src":"23587:224:120","nodes":[],"body":{"id":59274,"nodeType":"Block","src":"23675:136:120","nodes":[],"statements":[{"assignments":[59256],"declarations":[{"constant":false,"id":59256,"mutability":"mutable","name":"batcherHash","nameLocation":"23693:11:120","nodeType":"VariableDeclaration","scope":59274,"src":"23685:19:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_bytes32","typeString":"bytes32"},"typeName":{"id":59255,"name":"bytes32","nodeType":"ElementaryTypeName","src":"23685:7:120","typeDescriptions":{"typeIdentifier":"t_bytes32","typeString":"bytes32"}},"visibility":"internal"}],"id":59262,"initialValue":{"arguments":[],"expression":{"argumentTypes":[],"expression":{"arguments":[{"id":59258,"name":"_systemConfigProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":59250,"src":"23716:18:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_address","typeString":"address"}],"id":59257,"name":"IFetcher","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57326,"src":"23707:8:120","typeDescriptions":{"typeIdentifier":"t_type$_t_contract$_IFetcher_$57326_$","typeString":"type(contract IFetcher)"}},"id":59259,"isConstant":false,"isLValue":false,"isPure":false,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"23707:28:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_contract$_IFetcher_$57326","typeString":"contract IFetcher"}},"id":59260,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"23736:11:120","memberName":"batcherHash","nodeType":"MemberAccess","referencedDeclaration":57305,"src":"23707:40:120","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_bytes32_$","typeString":"function () view external returns (bytes32)"}},"id":59261,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"23707:42:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_bytes32","typeString":"bytes32"}},"nodeType":"VariableDeclarationStatement","src":"23685:64:120"},{"expression":{"arguments":[{"arguments":[{"arguments":[{"id":59269,"name":"batcherHash","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":59256,"src":"23790:11:120","typeDescriptions":{"typeIdentifier":"t_bytes32","typeString":"bytes32"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_bytes32","typeString":"bytes32"}],"id":59268,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"nodeType":"ElementaryTypeNameExpression","src":"23782:7:120","typeDescriptions":{"typeIdentifier":"t_type$_t_uint256_$","typeString":"type(uint256)"},"typeName":{"id":59267,"name":"uint256","nodeType":"ElementaryTypeName","src":"23782:7:120","typeDescriptions":{}}},"id":59270,"isConstant":false,"isLValue":false,"isPure":false,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"23782:20:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_uint256","typeString":"uint256"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_uint256","typeString":"uint256"}],"id":59266,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"nodeType":"ElementaryTypeNameExpression","src":"23774:7:120","typeDescriptions":{"typeIdentifier":"t_type$_t_uint160_$","typeString":"type(uint160)"},"typeName":{"id":59265,"name":"uint160","nodeType":"ElementaryTypeName","src":"23774:7:120","typeDescriptions":{}}},"id":59271,"isConstant":false,"isLValue":false,"isPure":false,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"23774:29:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_uint160","typeString":"uint160"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_uint160","typeString":"uint160"}],"id":59264,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"nodeType":"ElementaryTypeNameExpression","src":"23766:7:120","typeDescriptions":{"typeIdentifier":"t_type$_t_address_$","typeString":"type(address)"},"typeName":{"id":59263,"name":"address","nodeType":"ElementaryTypeName","src":"23766:7:120","typeDescriptions":{}}},"id":59272,"isConstant":false,"isLValue":false,"isPure":false,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"23766:38:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"functionReturnParameters":59254,"id":59273,"nodeType":"Return","src":"23759:45:120"}]},"implemented":true,"kind":"function","modifiers":[],"name":"_getBatchSubmitter","nameLocation":"23596:18:120","parameters":{"id":59251,"nodeType":"ParameterList","parameters":[{"constant":false,"id":59250,"mutability":"mutable","name":"_systemConfigProxy","nameLocation":"23623:18:120","nodeType":"VariableDeclaration","scope":59275,"src":"23615:26:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":59249,"name":"address","nodeType":"ElementaryTypeName","src":"23615:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"23614:28:120"},"returnParameters":{"id":59254,"nodeType":"ParameterList","parameters":[{"constant":false,"id":59253,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":59275,"src":"23666:7:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":59252,"name":"address","nodeType":"ElementaryTypeName","src":"23666:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"23665:9:120"},"scope":59299,"stateMutability":"view","virtual":false,"visibility":"internal"},{"id":59298,"nodeType":"FunctionDefinition","src":"23817:169:120","nodes":[],"body":{"id":59297,"nodeType":"Block","src":"23896:90:120","nodes":[],"statements":[{"expression":{"arguments":[{"arguments":[{"hexValue":"30","id":59287,"isConstant":false,"isLValue":false,"isPure":true,"kind":"number","lValueRequested":false,"nodeType":"Literal","src":"23923:1:120","typeDescriptions":{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"},"value":"0"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"}],"id":59286,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"nodeType":"ElementaryTypeNameExpression","src":"23915:7:120","typeDescriptions":{"typeIdentifier":"t_type$_t_address_$","typeString":"type(address)"},"typeName":{"id":59285,"name":"address","nodeType":"ElementaryTypeName","src":"23915:7:120","typeDescriptions":{}}},"id":59288,"isConstant":false,"isLValue":false,"isPure":true,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"23915:10:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_address","typeString":"address"}],"expression":{"id":59282,"name":"vm","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":5980,"src":"23906:2:120","typeDescriptions":{"typeIdentifier":"t_contract$_Vm_$23767","typeString":"contract Vm"}},"id":59284,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"23909:5:120","memberName":"prank","nodeType":"MemberAccess","referencedDeclaration":23060,"src":"23906:8:120","typeDescriptions":{"typeIdentifier":"t_function_external_nonpayable$_t_address_$returns$__$","typeString":"function (address) external"}},"id":59289,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"23906:20:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":59290,"nodeType":"ExpressionStatement","src":"23906:20:120"},{"expression":{"arguments":[],"expression":{"argumentTypes":[],"expression":{"arguments":[{"id":59292,"name":"_systemConfigProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":59277,"src":"23952:18:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_address","typeString":"address"}],"id":59291,"name":"IFetcher","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57326,"src":"23943:8:120","typeDescriptions":{"typeIdentifier":"t_type$_t_contract$_IFetcher_$57326_$","typeString":"type(contract IFetcher)"}},"id":59293,"isConstant":false,"isLValue":false,"isPure":false,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"23943:28:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_contract$_IFetcher_$57326","typeString":"contract IFetcher"}},"id":59294,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"23972:5:120","memberName":"admin","nodeType":"MemberAccess","referencedDeclaration":57310,"src":"23943:34:120","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":59295,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"23943:36:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"functionReturnParameters":59281,"id":59296,"nodeType":"Return","src":"23936:43:120"}]},"implemented":true,"kind":"function","modifiers":[],"name":"_getProxyAdmin","nameLocation":"23826:14:120","parameters":{"id":59278,"nodeType":"ParameterList","parameters":[{"constant":false,"id":59277,"mutability":"mutable","name":"_systemConfigProxy","nameLocation":"23849:18:120","nodeType":"VariableDeclaration","scope":59298,"src":"23841:26:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":59276,"name":"address","nodeType":"ElementaryTypeName","src":"23841:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"23840:28:120"},"returnParameters":{"id":59281,"nodeType":"ParameterList","parameters":[{"constant":false,"id":59280,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":59298,"src":"23887:7:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":59279,"name":"address","nodeType":"ElementaryTypeName","src":"23887:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"23886:9:120"},"scope":59299,"stateMutability":"nonpayable","virtual":false,"visibility":"internal"}],"abstract":false,"baseContracts":[{"baseName":{"id":58250,"name":"Script","nameLocations":["13167:6:120"],"nodeType":"IdentifierPath","referencedDeclaration":6037,"src":"13167:6:120"},"id":58251,"nodeType":"InheritanceSpecifier","src":"13167:6:120"}],"canonicalName":"FetchChainInfo","contractDependencies":[],"contractKind":"contract","fullyImplemented":true,"linearizedBaseContracts":[59299,6037,18860,11701,9611,5996,5984],"name":"FetchChainInfo","nameLocation":"13149:14:120","scope":59300,"usedErrors":[],"usedEvents":[]}],"license":"MIT"},"id":120} \ No newline at end of file +{"abi":[{"type":"function","name":"l1StandardBridgeProxy","inputs":[],"outputs":[{"name":"","type":"address","internalType":"address"}],"stateMutability":"view"},{"type":"function","name":"set","inputs":[{"name":"_sel","type":"bytes4","internalType":"bytes4"},{"name":"_addr","type":"address","internalType":"address"}],"outputs":[],"stateMutability":"nonpayable"},{"type":"function","name":"systemConfigProxy","inputs":[],"outputs":[{"name":"","type":"address","internalType":"address"}],"stateMutability":"view"}],"bytecode":{"object":"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","sourceMap":"2021:934:100:-:0;;;;;;;;;;;;;;;;;;;","linkReferences":{}},"deployedBytecode":{"object":"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","sourceMap":"2021:934:100:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2735:218;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;2527:202;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;2143:378;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;2735:218;2789:7;2850:1;2816:36;;:22;;;;;;;;;;;:36;;;2808:99;;;;;;;;;;;;:::i;:::-;;;;;;;;;2924:22;;;;;;;;;;;2917:29;;2735:218;:::o;2527:202::-;2577:7;2634:1;2604:32;;:18;;;;;;;;;;;:32;;;2596:91;;;;;;;;;;;;:::i;:::-;;;;;;;;;2704:18;;;;;;;;;;;2697:25;;2527:202;:::o;2143:378::-;2226:1;2209:19;;:5;:19;;;2201:76;;;;;;;;;;;;:::i;:::-;;;;;;;;;2299:31;;;2291:39;;;:4;:39;;;;2287:227;;2353:5;2332:18;;:26;;;;;;;;;;;;;;;;;;2287:227;;;2385:35;;;2377:43;;;:4;:43;;;;2373:141;;2447:5;2422:22;;:30;;;;;;;;;;;;;;;;;;2373:141;;;2467:47;;;;;;;;;;:::i;:::-;;;;;;;;2373:141;2287:227;2143:378;;:::o;7:126:182:-;44:7;84:42;77:5;73:54;62:65;;7:126;;;:::o;139:96::-;176:7;205:24;223:5;205:24;:::i;:::-;194:35;;139:96;;;:::o;241:118::-;328:24;346:5;328:24;:::i;:::-;323:3;316:37;241:118;;:::o;365:222::-;458:4;496:2;485:9;481:18;473:26;;509:71;577:1;566:9;562:17;553:6;509:71;:::i;:::-;365:222;;;;:::o;674:117::-;783:1;780;773:12;920:149;956:7;996:66;989:5;985:78;974:89;;920:149;;;:::o;1075:120::-;1147:23;1164:5;1147:23;:::i;:::-;1140:5;1137:34;1127:62;;1185:1;1182;1175:12;1127:62;1075:120;:::o;1201:137::-;1246:5;1284:6;1271:20;1262:29;;1300:32;1326:5;1300:32;:::i;:::-;1201:137;;;;:::o;1344:122::-;1417:24;1435:5;1417:24;:::i;:::-;1410:5;1407:35;1397:63;;1456:1;1453;1446:12;1397:63;1344:122;:::o;1472:139::-;1518:5;1556:6;1543:20;1534:29;;1572:33;1599:5;1572:33;:::i;:::-;1472:139;;;;:::o;1617:472::-;1684:6;1692;1741:2;1729:9;1720:7;1716:23;1712:32;1709:119;;;1747:79;;:::i;:::-;1709:119;1867:1;1892:52;1936:7;1927:6;1916:9;1912:22;1892:52;:::i;:::-;1882:62;;1838:116;1993:2;2019:53;2064:7;2055:6;2044:9;2040:22;2019:53;:::i;:::-;2009:63;;1964:118;1617:472;;;;;:::o;2095:169::-;2179:11;2213:6;2208:3;2201:19;2253:4;2248:3;2244:14;2229:29;;2095:169;;;;:::o;2270:237::-;2410:34;2406:1;2398:6;2394:14;2387:58;2479:20;2474:2;2466:6;2462:15;2455:45;2270:237;:::o;2513:366::-;2655:3;2676:67;2740:2;2735:3;2676:67;:::i;:::-;2669:74;;2752:93;2841:3;2752:93;:::i;:::-;2870:2;2865:3;2861:12;2854:19;;2513:366;;;:::o;2885:419::-;3051:4;3089:2;3078:9;3074:18;3066:26;;3138:9;3132:4;3128:20;3124:1;3113:9;3109:17;3102:47;3166:131;3292:4;3166:131;:::i;:::-;3158:139;;2885:419;;;:::o;3310:233::-;3450:34;3446:1;3438:6;3434:14;3427:58;3519:16;3514:2;3506:6;3502:15;3495:41;3310:233;:::o;3549:366::-;3691:3;3712:67;3776:2;3771:3;3712:67;:::i;:::-;3705:74;;3788:93;3877:3;3788:93;:::i;:::-;3906:2;3901:3;3897:12;3890:19;;3549:366;;;:::o;3921:419::-;4087:4;4125:2;4114:9;4110:18;4102:26;;4174:9;4168:4;4164:20;4160:1;4149:9;4145:17;4138:47;4202:131;4328:4;4202:131;:::i;:::-;4194:139;;3921:419;;;:::o;4346:231::-;4486:34;4482:1;4474:6;4470:14;4463:58;4555:14;4550:2;4542:6;4538:15;4531:39;4346:231;:::o;4583:366::-;4725:3;4746:67;4810:2;4805:3;4746:67;:::i;:::-;4739:74;;4822:93;4911:3;4822:93;:::i;:::-;4940:2;4935:3;4931:12;4924:19;;4583:366;;;:::o;4955:419::-;5121:4;5159:2;5148:9;5144:18;5136:26;;5208:9;5202:4;5198:20;5194:1;5183:9;5179:17;5172:47;5236:131;5362:4;5236:131;:::i;:::-;5228:139;;4955:419;;;:::o;5380:224::-;5520:34;5516:1;5508:6;5504:14;5497:58;5589:7;5584:2;5576:6;5572:15;5565:32;5380:224;:::o;5610:366::-;5752:3;5773:67;5837:2;5832:3;5773:67;:::i;:::-;5766:74;;5849:93;5938:3;5849:93;:::i;:::-;5967:2;5962:3;5958:12;5951:19;;5610:366;;;:::o;5982:419::-;6148:4;6186:2;6175:9;6171:18;6163:26;;6235:9;6229:4;6225:20;6221:1;6210:9;6206:17;6199:47;6263:131;6389:4;6263:131;:::i;:::-;6255:139;;5982:419;;;:::o","linkReferences":{}},"methodIdentifiers":{"l1StandardBridgeProxy()":"102b6069","set(bytes4,address)":"c3e39250","systemConfigProxy()":"c17db6e3"},"rawMetadata":"{\"compiler\":{\"version\":\"0.8.27+commit.40a35a09\"},\"language\":\"Solidity\",\"output\":{\"abi\":[{\"inputs\":[],\"name\":\"l1StandardBridgeProxy\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes4\",\"name\":\"_sel\",\"type\":\"bytes4\"},{\"internalType\":\"address\",\"name\":\"_addr\",\"type\":\"address\"}],\"name\":\"set\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"systemConfigProxy\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"}],\"devdoc\":{\"kind\":\"dev\",\"methods\":{},\"version\":1},\"userdoc\":{\"kind\":\"user\",\"methods\":{},\"version\":1}},\"settings\":{\"compilationTarget\":{\"scripts/FetchChainInfo.s.sol\":\"FetchChainInfoInput\"},\"evmVersion\":\"cancun\",\"libraries\":{},\"metadata\":{\"bytecodeHash\":\"none\",\"useLiteralContent\":true},\"optimizer\":{\"enabled\":false,\"runs\":0},\"remappings\":[\":@lib-keccak/=lib/lib-keccak/contracts/lib/\",\":@openzeppelin/contracts-upgradeable/=lib/openzeppelin-contracts-upgradeable/contracts/\",\":@openzeppelin/contracts-v5/=lib/openzeppelin-contracts-v5/contracts/\",\":@openzeppelin/contracts/=lib/openzeppelin-contracts/contracts/\",\":@rari-capital/solmate/=lib/solmate/\",\":@solady-test/=lib/lib-keccak/lib/solady/test/\",\":@solady-v0.0.245/=lib/solady-v0.0.245/src/\",\":@solady/=lib/solady/src/\",\":ds-test/=lib/forge-std/lib/ds-test/src/\",\":erc4626-tests/=lib/openzeppelin-contracts-v5/lib/erc4626-tests/\",\":forge-std/=lib/forge-std/src/\",\":interfaces/=interfaces/\",\":kontrol-cheatcodes/=lib/kontrol-cheatcodes/src/\",\":lib-keccak/=lib/lib-keccak/contracts/\",\":openzeppelin-contracts-upgradeable/=lib/openzeppelin-contracts-upgradeable/\",\":openzeppelin-contracts-v5/=lib/openzeppelin-contracts-v5/\",\":openzeppelin-contracts/=lib/openzeppelin-contracts/\",\":safe-contracts/=lib/safe-contracts/contracts/\",\":solady-v0.0.245/=lib/solady-v0.0.245/src/\",\":solady/=lib/solady/\",\":solmate/=lib/solmate/src/\"]},\"sources\":{\"lib/forge-std/src/Base.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity >=0.6.2 <0.9.0;\\n\\nimport {StdStorage} from \\\"./StdStorage.sol\\\";\\nimport {Vm, VmSafe} from \\\"./Vm.sol\\\";\\n\\nabstract contract CommonBase {\\n /// @dev Cheat code address.\\n /// Calculated as `address(uint160(uint256(keccak256(\\\"hevm cheat code\\\"))))`.\\n address internal constant VM_ADDRESS = 0x7109709ECfa91a80626fF3989D68f67F5b1DD12D;\\n /// @dev console.sol and console2.sol work by executing a staticcall to this address.\\n /// Calculated as `address(uint160(uint88(bytes11(\\\"console.log\\\"))))`.\\n address internal constant CONSOLE = 0x000000000000000000636F6e736F6c652e6c6f67;\\n /// @dev Used when deploying with create2.\\n /// Taken from https://github.com/Arachnid/deterministic-deployment-proxy.\\n address internal constant CREATE2_FACTORY = 0x4e59b44847b379578588920cA78FbF26c0B4956C;\\n /// @dev The default address for tx.origin and msg.sender.\\n /// Calculated as `address(uint160(uint256(keccak256(\\\"foundry default caller\\\"))))`.\\n address internal constant DEFAULT_SENDER = 0x1804c8AB1F12E6bbf3894d4083f33e07309d1f38;\\n /// @dev The address of the first contract `CREATE`d by a running test contract.\\n /// When running tests, each test contract is `CREATE`d by `DEFAULT_SENDER` with nonce 1.\\n /// Calculated as `VM.computeCreateAddress(VM.computeCreateAddress(DEFAULT_SENDER, 1), 1)`.\\n address internal constant DEFAULT_TEST_CONTRACT = 0x5615dEB798BB3E4dFa0139dFa1b3D433Cc23b72f;\\n /// @dev Deterministic deployment address of the Multicall3 contract.\\n /// Taken from https://www.multicall3.com.\\n address internal constant MULTICALL3_ADDRESS = 0xcA11bde05977b3631167028862bE2a173976CA11;\\n /// @dev The order of the secp256k1 curve.\\n uint256 internal constant SECP256K1_ORDER =\\n 115792089237316195423570985008687907852837564279074904382605163141518161494337;\\n\\n uint256 internal constant UINT256_MAX =\\n 115792089237316195423570985008687907853269984665640564039457584007913129639935;\\n\\n Vm internal constant vm = Vm(VM_ADDRESS);\\n StdStorage internal stdstore;\\n}\\n\\nabstract contract TestBase is CommonBase {}\\n\\nabstract contract ScriptBase is CommonBase {\\n VmSafe internal constant vmSafe = VmSafe(VM_ADDRESS);\\n}\\n\",\"keccak256\":\"0xa3735a6618a3014e42bb4329ad143e3b2c59cd95094350202e4c4a06c9d585dd\",\"license\":\"MIT\"},\"lib/forge-std/src/Script.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity >=0.6.2 <0.9.0;\\n\\n// \\ud83d\\udcac ABOUT\\n// Forge Std's default Script.\\n\\n// \\ud83e\\udde9 MODULES\\nimport {console} from \\\"./console.sol\\\";\\nimport {console2} from \\\"./console2.sol\\\";\\nimport {safeconsole} from \\\"./safeconsole.sol\\\";\\nimport {StdChains} from \\\"./StdChains.sol\\\";\\nimport {StdCheatsSafe} from \\\"./StdCheats.sol\\\";\\nimport {StdConstants} from \\\"./StdConstants.sol\\\";\\nimport {stdJson} from \\\"./StdJson.sol\\\";\\nimport {stdMath} from \\\"./StdMath.sol\\\";\\nimport {StdStorage, stdStorageSafe} from \\\"./StdStorage.sol\\\";\\nimport {StdStyle} from \\\"./StdStyle.sol\\\";\\nimport {StdUtils} from \\\"./StdUtils.sol\\\";\\nimport {VmSafe} from \\\"./Vm.sol\\\";\\n\\n// \\ud83d\\udce6 BOILERPLATE\\nimport {ScriptBase} from \\\"./Base.sol\\\";\\n\\n// \\u2b50\\ufe0f SCRIPT\\nabstract contract Script is ScriptBase, StdChains, StdCheatsSafe, StdUtils {\\n // Note: IS_SCRIPT() must return true.\\n bool public IS_SCRIPT = true;\\n}\\n\",\"keccak256\":\"0xc942e27c7baae499beb01afbbae99f24d42af9a6e4aae675bc6901b704aa8e9b\",\"license\":\"MIT\"},\"lib/forge-std/src/StdChains.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity >=0.6.2 <0.9.0;\\n\\nimport {VmSafe} from \\\"./Vm.sol\\\";\\n\\n/**\\n * StdChains provides information about EVM compatible chains that can be used in scripts/tests.\\n * For each chain, the chain's name, chain ID, and a default RPC URL are provided. Chains are\\n * identified by their alias, which is the same as the alias in the `[rpc_endpoints]` section of\\n * the `foundry.toml` file. For best UX, ensure the alias in the `foundry.toml` file match the\\n * alias used in this contract, which can be found as the first argument to the\\n * `setChainWithDefaultRpcUrl` call in the `initializeStdChains` function.\\n *\\n * There are two main ways to use this contract:\\n * 1. Set a chain with `setChain(string memory chainAlias, ChainData memory chain)` or\\n * `setChain(string memory chainAlias, Chain memory chain)`\\n * 2. Get a chain with `getChain(string memory chainAlias)` or `getChain(uint256 chainId)`.\\n *\\n * The first time either of those are used, chains are initialized with the default set of RPC URLs.\\n * This is done in `initializeStdChains`, which uses `setChainWithDefaultRpcUrl`. Defaults are recorded in\\n * `defaultRpcUrls`.\\n *\\n * The `setChain` function is straightforward, and it simply saves off the given chain data.\\n *\\n * The `getChain` methods use `getChainWithUpdatedRpcUrl` to return a chain. For example, let's say\\n * we want to retrieve the RPC URL for `mainnet`:\\n * - If you have specified data with `setChain`, it will return that.\\n * - If you have configured a mainnet RPC URL in `foundry.toml`, it will return the URL, provided it\\n * is valid (e.g. a URL is specified, or an environment variable is given and exists).\\n * - If neither of the above conditions is met, the default data is returned.\\n *\\n * Summarizing the above, the prioritization hierarchy is `setChain` -> `foundry.toml` -> environment variable -> defaults.\\n */\\nabstract contract StdChains {\\n VmSafe private constant vm = VmSafe(address(uint160(uint256(keccak256(\\\"hevm cheat code\\\")))));\\n\\n bool private stdChainsInitialized;\\n\\n struct ChainData {\\n string name;\\n uint256 chainId;\\n string rpcUrl;\\n }\\n\\n struct Chain {\\n // The chain name.\\n string name;\\n // The chain's Chain ID.\\n uint256 chainId;\\n // The chain's alias. (i.e. what gets specified in `foundry.toml`).\\n string chainAlias;\\n // A default RPC endpoint for this chain.\\n // NOTE: This default RPC URL is included for convenience to facilitate quick tests and\\n // experimentation. Do not use this RPC URL for production test suites, CI, or other heavy\\n // usage as you will be throttled and this is a disservice to others who need this endpoint.\\n string rpcUrl;\\n }\\n\\n // Maps from the chain's alias (matching the alias in the `foundry.toml` file) to chain data.\\n mapping(string => Chain) private chains;\\n // Maps from the chain's alias to it's default RPC URL.\\n mapping(string => string) private defaultRpcUrls;\\n // Maps from a chain ID to it's alias.\\n mapping(uint256 => string) private idToAlias;\\n\\n bool private fallbackToDefaultRpcUrls = true;\\n\\n // The RPC URL will be fetched from config or defaultRpcUrls if possible.\\n function getChain(string memory chainAlias) internal virtual returns (Chain memory chain) {\\n require(bytes(chainAlias).length != 0, \\\"StdChains getChain(string): Chain alias cannot be the empty string.\\\");\\n\\n initializeStdChains();\\n chain = chains[chainAlias];\\n require(\\n chain.chainId != 0,\\n string(abi.encodePacked(\\\"StdChains getChain(string): Chain with alias \\\\\\\"\\\", chainAlias, \\\"\\\\\\\" not found.\\\"))\\n );\\n\\n chain = getChainWithUpdatedRpcUrl(chainAlias, chain);\\n }\\n\\n function getChain(uint256 chainId) internal virtual returns (Chain memory chain) {\\n require(chainId != 0, \\\"StdChains getChain(uint256): Chain ID cannot be 0.\\\");\\n initializeStdChains();\\n string memory chainAlias = idToAlias[chainId];\\n\\n chain = chains[chainAlias];\\n\\n require(\\n chain.chainId != 0,\\n string(abi.encodePacked(\\\"StdChains getChain(uint256): Chain with ID \\\", vm.toString(chainId), \\\" not found.\\\"))\\n );\\n\\n chain = getChainWithUpdatedRpcUrl(chainAlias, chain);\\n }\\n\\n // set chain info, with priority to argument's rpcUrl field.\\n function setChain(string memory chainAlias, ChainData memory chain) internal virtual {\\n require(\\n bytes(chainAlias).length != 0,\\n \\\"StdChains setChain(string,ChainData): Chain alias cannot be the empty string.\\\"\\n );\\n\\n require(chain.chainId != 0, \\\"StdChains setChain(string,ChainData): Chain ID cannot be 0.\\\");\\n\\n initializeStdChains();\\n string memory foundAlias = idToAlias[chain.chainId];\\n\\n require(\\n bytes(foundAlias).length == 0 || keccak256(bytes(foundAlias)) == keccak256(bytes(chainAlias)),\\n string(\\n abi.encodePacked(\\n \\\"StdChains setChain(string,ChainData): Chain ID \\\",\\n vm.toString(chain.chainId),\\n \\\" already used by \\\\\\\"\\\",\\n foundAlias,\\n \\\"\\\\\\\".\\\"\\n )\\n )\\n );\\n\\n uint256 oldChainId = chains[chainAlias].chainId;\\n delete idToAlias[oldChainId];\\n\\n chains[chainAlias] =\\n Chain({name: chain.name, chainId: chain.chainId, chainAlias: chainAlias, rpcUrl: chain.rpcUrl});\\n idToAlias[chain.chainId] = chainAlias;\\n }\\n\\n // set chain info, with priority to argument's rpcUrl field.\\n function setChain(string memory chainAlias, Chain memory chain) internal virtual {\\n setChain(chainAlias, ChainData({name: chain.name, chainId: chain.chainId, rpcUrl: chain.rpcUrl}));\\n }\\n\\n function _toUpper(string memory str) private pure returns (string memory) {\\n bytes memory strb = bytes(str);\\n bytes memory copy = new bytes(strb.length);\\n for (uint256 i = 0; i < strb.length; i++) {\\n bytes1 b = strb[i];\\n if (b >= 0x61 && b <= 0x7A) {\\n copy[i] = bytes1(uint8(b) - 32);\\n } else {\\n copy[i] = b;\\n }\\n }\\n return string(copy);\\n }\\n\\n // lookup rpcUrl, in descending order of priority:\\n // current -> config (foundry.toml) -> environment variable -> default\\n function getChainWithUpdatedRpcUrl(string memory chainAlias, Chain memory chain)\\n private\\n view\\n returns (Chain memory)\\n {\\n if (bytes(chain.rpcUrl).length == 0) {\\n try vm.rpcUrl(chainAlias) returns (string memory configRpcUrl) {\\n chain.rpcUrl = configRpcUrl;\\n } catch (bytes memory err) {\\n string memory envName = string(abi.encodePacked(_toUpper(chainAlias), \\\"_RPC_URL\\\"));\\n if (fallbackToDefaultRpcUrls) {\\n chain.rpcUrl = vm.envOr(envName, defaultRpcUrls[chainAlias]);\\n } else {\\n chain.rpcUrl = vm.envString(envName);\\n }\\n // Distinguish 'not found' from 'cannot read'\\n // The upstream error thrown by forge for failing cheats changed so we check both the old and new versions\\n bytes memory oldNotFoundError =\\n abi.encodeWithSignature(\\\"CheatCodeError\\\", string(abi.encodePacked(\\\"invalid rpc url \\\", chainAlias)));\\n bytes memory newNotFoundError = abi.encodeWithSignature(\\n \\\"CheatcodeError(string)\\\", string(abi.encodePacked(\\\"invalid rpc url: \\\", chainAlias))\\n );\\n bytes32 errHash = keccak256(err);\\n if (\\n (errHash != keccak256(oldNotFoundError) && errHash != keccak256(newNotFoundError))\\n || bytes(chain.rpcUrl).length == 0\\n ) {\\n /// @solidity memory-safe-assembly\\n assembly {\\n revert(add(32, err), mload(err))\\n }\\n }\\n }\\n }\\n return chain;\\n }\\n\\n function setFallbackToDefaultRpcUrls(bool useDefault) internal {\\n fallbackToDefaultRpcUrls = useDefault;\\n }\\n\\n function initializeStdChains() private {\\n if (stdChainsInitialized) return;\\n\\n stdChainsInitialized = true;\\n\\n // If adding an RPC here, make sure to test the default RPC URL in `test_Rpcs` in `StdChains.t.sol`\\n setChainWithDefaultRpcUrl(\\\"anvil\\\", ChainData(\\\"Anvil\\\", 31337, \\\"http://127.0.0.1:8545\\\"));\\n setChainWithDefaultRpcUrl(\\\"mainnet\\\", ChainData(\\\"Mainnet\\\", 1, \\\"https://eth.llamarpc.com\\\"));\\n setChainWithDefaultRpcUrl(\\n \\\"sepolia\\\", ChainData(\\\"Sepolia\\\", 11155111, \\\"https://sepolia.infura.io/v3/b9794ad1ddf84dfb8c34d6bb5dca2001\\\")\\n );\\n setChainWithDefaultRpcUrl(\\\"holesky\\\", ChainData(\\\"Holesky\\\", 17000, \\\"https://rpc.holesky.ethpandaops.io\\\"));\\n setChainWithDefaultRpcUrl(\\\"optimism\\\", ChainData(\\\"Optimism\\\", 10, \\\"https://mainnet.optimism.io\\\"));\\n setChainWithDefaultRpcUrl(\\n \\\"optimism_sepolia\\\", ChainData(\\\"Optimism Sepolia\\\", 11155420, \\\"https://sepolia.optimism.io\\\")\\n );\\n setChainWithDefaultRpcUrl(\\\"arbitrum_one\\\", ChainData(\\\"Arbitrum One\\\", 42161, \\\"https://arb1.arbitrum.io/rpc\\\"));\\n setChainWithDefaultRpcUrl(\\n \\\"arbitrum_one_sepolia\\\", ChainData(\\\"Arbitrum One Sepolia\\\", 421614, \\\"https://sepolia-rollup.arbitrum.io/rpc\\\")\\n );\\n setChainWithDefaultRpcUrl(\\\"arbitrum_nova\\\", ChainData(\\\"Arbitrum Nova\\\", 42170, \\\"https://nova.arbitrum.io/rpc\\\"));\\n setChainWithDefaultRpcUrl(\\\"polygon\\\", ChainData(\\\"Polygon\\\", 137, \\\"https://polygon-rpc.com\\\"));\\n setChainWithDefaultRpcUrl(\\n \\\"polygon_amoy\\\", ChainData(\\\"Polygon Amoy\\\", 80002, \\\"https://rpc-amoy.polygon.technology\\\")\\n );\\n setChainWithDefaultRpcUrl(\\\"avalanche\\\", ChainData(\\\"Avalanche\\\", 43114, \\\"https://api.avax.network/ext/bc/C/rpc\\\"));\\n setChainWithDefaultRpcUrl(\\n \\\"avalanche_fuji\\\", ChainData(\\\"Avalanche Fuji\\\", 43113, \\\"https://api.avax-test.network/ext/bc/C/rpc\\\")\\n );\\n setChainWithDefaultRpcUrl(\\n \\\"bnb_smart_chain\\\", ChainData(\\\"BNB Smart Chain\\\", 56, \\\"https://bsc-dataseed1.binance.org\\\")\\n );\\n setChainWithDefaultRpcUrl(\\n \\\"bnb_smart_chain_testnet\\\",\\n ChainData(\\\"BNB Smart Chain Testnet\\\", 97, \\\"https://rpc.ankr.com/bsc_testnet_chapel\\\")\\n );\\n setChainWithDefaultRpcUrl(\\\"gnosis_chain\\\", ChainData(\\\"Gnosis Chain\\\", 100, \\\"https://rpc.gnosischain.com\\\"));\\n setChainWithDefaultRpcUrl(\\\"moonbeam\\\", ChainData(\\\"Moonbeam\\\", 1284, \\\"https://rpc.api.moonbeam.network\\\"));\\n setChainWithDefaultRpcUrl(\\n \\\"moonriver\\\", ChainData(\\\"Moonriver\\\", 1285, \\\"https://rpc.api.moonriver.moonbeam.network\\\")\\n );\\n setChainWithDefaultRpcUrl(\\\"moonbase\\\", ChainData(\\\"Moonbase\\\", 1287, \\\"https://rpc.testnet.moonbeam.network\\\"));\\n setChainWithDefaultRpcUrl(\\\"base_sepolia\\\", ChainData(\\\"Base Sepolia\\\", 84532, \\\"https://sepolia.base.org\\\"));\\n setChainWithDefaultRpcUrl(\\\"base\\\", ChainData(\\\"Base\\\", 8453, \\\"https://mainnet.base.org\\\"));\\n setChainWithDefaultRpcUrl(\\\"blast_sepolia\\\", ChainData(\\\"Blast Sepolia\\\", 168587773, \\\"https://sepolia.blast.io\\\"));\\n setChainWithDefaultRpcUrl(\\\"blast\\\", ChainData(\\\"Blast\\\", 81457, \\\"https://rpc.blast.io\\\"));\\n setChainWithDefaultRpcUrl(\\\"fantom_opera\\\", ChainData(\\\"Fantom Opera\\\", 250, \\\"https://rpc.ankr.com/fantom/\\\"));\\n setChainWithDefaultRpcUrl(\\n \\\"fantom_opera_testnet\\\", ChainData(\\\"Fantom Opera Testnet\\\", 4002, \\\"https://rpc.ankr.com/fantom_testnet/\\\")\\n );\\n setChainWithDefaultRpcUrl(\\\"fraxtal\\\", ChainData(\\\"Fraxtal\\\", 252, \\\"https://rpc.frax.com\\\"));\\n setChainWithDefaultRpcUrl(\\\"fraxtal_testnet\\\", ChainData(\\\"Fraxtal Testnet\\\", 2522, \\\"https://rpc.testnet.frax.com\\\"));\\n setChainWithDefaultRpcUrl(\\n \\\"berachain_bartio_testnet\\\", ChainData(\\\"Berachain bArtio Testnet\\\", 80084, \\\"https://bartio.rpc.berachain.com\\\")\\n );\\n setChainWithDefaultRpcUrl(\\\"flare\\\", ChainData(\\\"Flare\\\", 14, \\\"https://flare-api.flare.network/ext/C/rpc\\\"));\\n setChainWithDefaultRpcUrl(\\n \\\"flare_coston2\\\", ChainData(\\\"Flare Coston2\\\", 114, \\\"https://coston2-api.flare.network/ext/C/rpc\\\")\\n );\\n\\n setChainWithDefaultRpcUrl(\\\"mode\\\", ChainData(\\\"Mode\\\", 34443, \\\"https://mode.drpc.org\\\"));\\n setChainWithDefaultRpcUrl(\\\"mode_sepolia\\\", ChainData(\\\"Mode Sepolia\\\", 919, \\\"https://sepolia.mode.network\\\"));\\n\\n setChainWithDefaultRpcUrl(\\\"zora\\\", ChainData(\\\"Zora\\\", 7777777, \\\"https://zora.drpc.org\\\"));\\n setChainWithDefaultRpcUrl(\\n \\\"zora_sepolia\\\", ChainData(\\\"Zora Sepolia\\\", 999999999, \\\"https://sepolia.rpc.zora.energy\\\")\\n );\\n\\n setChainWithDefaultRpcUrl(\\\"race\\\", ChainData(\\\"Race\\\", 6805, \\\"https://racemainnet.io\\\"));\\n setChainWithDefaultRpcUrl(\\\"race_sepolia\\\", ChainData(\\\"Race Sepolia\\\", 6806, \\\"https://racemainnet.io\\\"));\\n\\n setChainWithDefaultRpcUrl(\\\"metal\\\", ChainData(\\\"Metal\\\", 1750, \\\"https://metall2.drpc.org\\\"));\\n setChainWithDefaultRpcUrl(\\\"metal_sepolia\\\", ChainData(\\\"Metal Sepolia\\\", 1740, \\\"https://testnet.rpc.metall2.com\\\"));\\n\\n setChainWithDefaultRpcUrl(\\\"binary\\\", ChainData(\\\"Binary\\\", 624, \\\"https://rpc.zero.thebinaryholdings.com\\\"));\\n setChainWithDefaultRpcUrl(\\n \\\"binary_sepolia\\\", ChainData(\\\"Binary Sepolia\\\", 625, \\\"https://rpc.zero.thebinaryholdings.com\\\")\\n );\\n\\n setChainWithDefaultRpcUrl(\\\"orderly\\\", ChainData(\\\"Orderly\\\", 291, \\\"https://rpc.orderly.network\\\"));\\n setChainWithDefaultRpcUrl(\\n \\\"orderly_sepolia\\\", ChainData(\\\"Orderly Sepolia\\\", 4460, \\\"https://testnet-rpc.orderly.org\\\")\\n );\\n }\\n\\n // set chain info, with priority to chainAlias' rpc url in foundry.toml\\n function setChainWithDefaultRpcUrl(string memory chainAlias, ChainData memory chain) private {\\n string memory rpcUrl = chain.rpcUrl;\\n defaultRpcUrls[chainAlias] = rpcUrl;\\n chain.rpcUrl = \\\"\\\";\\n setChain(chainAlias, chain);\\n chain.rpcUrl = rpcUrl; // restore argument\\n }\\n}\\n\",\"keccak256\":\"0x200b597cd01c229633b4a2317846cac7d36d337e2381b4a2e81faac23c2ad1cf\",\"license\":\"MIT\"},\"lib/forge-std/src/StdCheats.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity >=0.6.2 <0.9.0;\\n\\npragma experimental ABIEncoderV2;\\n\\nimport {StdStorage, stdStorage} from \\\"./StdStorage.sol\\\";\\nimport {console2} from \\\"./console2.sol\\\";\\nimport {Vm} from \\\"./Vm.sol\\\";\\n\\nabstract contract StdCheatsSafe {\\n Vm private constant vm = Vm(address(uint160(uint256(keccak256(\\\"hevm cheat code\\\")))));\\n\\n uint256 private constant UINT256_MAX =\\n 115792089237316195423570985008687907853269984665640564039457584007913129639935;\\n\\n bool private gasMeteringOff;\\n\\n // Data structures to parse Transaction objects from the broadcast artifact\\n // that conform to EIP1559. The Raw structs is what is parsed from the JSON\\n // and then converted to the one that is used by the user for better UX.\\n\\n struct RawTx1559 {\\n string[] arguments;\\n address contractAddress;\\n string contractName;\\n // json value name = function\\n string functionSig;\\n bytes32 hash;\\n // json value name = tx\\n RawTx1559Detail txDetail;\\n // json value name = type\\n string opcode;\\n }\\n\\n struct RawTx1559Detail {\\n AccessList[] accessList;\\n bytes data;\\n address from;\\n bytes gas;\\n bytes nonce;\\n address to;\\n bytes txType;\\n bytes value;\\n }\\n\\n struct Tx1559 {\\n string[] arguments;\\n address contractAddress;\\n string contractName;\\n string functionSig;\\n bytes32 hash;\\n Tx1559Detail txDetail;\\n string opcode;\\n }\\n\\n struct Tx1559Detail {\\n AccessList[] accessList;\\n bytes data;\\n address from;\\n uint256 gas;\\n uint256 nonce;\\n address to;\\n uint256 txType;\\n uint256 value;\\n }\\n\\n // Data structures to parse Transaction objects from the broadcast artifact\\n // that DO NOT conform to EIP1559. The Raw structs is what is parsed from the JSON\\n // and then converted to the one that is used by the user for better UX.\\n\\n struct TxLegacy {\\n string[] arguments;\\n address contractAddress;\\n string contractName;\\n string functionSig;\\n string hash;\\n string opcode;\\n TxDetailLegacy transaction;\\n }\\n\\n struct TxDetailLegacy {\\n AccessList[] accessList;\\n uint256 chainId;\\n bytes data;\\n address from;\\n uint256 gas;\\n uint256 gasPrice;\\n bytes32 hash;\\n uint256 nonce;\\n bytes1 opcode;\\n bytes32 r;\\n bytes32 s;\\n uint256 txType;\\n address to;\\n uint8 v;\\n uint256 value;\\n }\\n\\n struct AccessList {\\n address accessAddress;\\n bytes32[] storageKeys;\\n }\\n\\n // Data structures to parse Receipt objects from the broadcast artifact.\\n // The Raw structs is what is parsed from the JSON\\n // and then converted to the one that is used by the user for better UX.\\n\\n struct RawReceipt {\\n bytes32 blockHash;\\n bytes blockNumber;\\n address contractAddress;\\n bytes cumulativeGasUsed;\\n bytes effectiveGasPrice;\\n address from;\\n bytes gasUsed;\\n RawReceiptLog[] logs;\\n bytes logsBloom;\\n bytes status;\\n address to;\\n bytes32 transactionHash;\\n bytes transactionIndex;\\n }\\n\\n struct Receipt {\\n bytes32 blockHash;\\n uint256 blockNumber;\\n address contractAddress;\\n uint256 cumulativeGasUsed;\\n uint256 effectiveGasPrice;\\n address from;\\n uint256 gasUsed;\\n ReceiptLog[] logs;\\n bytes logsBloom;\\n uint256 status;\\n address to;\\n bytes32 transactionHash;\\n uint256 transactionIndex;\\n }\\n\\n // Data structures to parse the entire broadcast artifact, assuming the\\n // transactions conform to EIP1559.\\n\\n struct EIP1559ScriptArtifact {\\n string[] libraries;\\n string path;\\n string[] pending;\\n Receipt[] receipts;\\n uint256 timestamp;\\n Tx1559[] transactions;\\n TxReturn[] txReturns;\\n }\\n\\n struct RawEIP1559ScriptArtifact {\\n string[] libraries;\\n string path;\\n string[] pending;\\n RawReceipt[] receipts;\\n TxReturn[] txReturns;\\n uint256 timestamp;\\n RawTx1559[] transactions;\\n }\\n\\n struct RawReceiptLog {\\n // json value = address\\n address logAddress;\\n bytes32 blockHash;\\n bytes blockNumber;\\n bytes data;\\n bytes logIndex;\\n bool removed;\\n bytes32[] topics;\\n bytes32 transactionHash;\\n bytes transactionIndex;\\n bytes transactionLogIndex;\\n }\\n\\n struct ReceiptLog {\\n // json value = address\\n address logAddress;\\n bytes32 blockHash;\\n uint256 blockNumber;\\n bytes data;\\n uint256 logIndex;\\n bytes32[] topics;\\n uint256 transactionIndex;\\n uint256 transactionLogIndex;\\n bool removed;\\n }\\n\\n struct TxReturn {\\n string internalType;\\n string value;\\n }\\n\\n struct Account {\\n address addr;\\n uint256 key;\\n }\\n\\n enum AddressType {\\n Payable,\\n NonPayable,\\n ZeroAddress,\\n Precompile,\\n ForgeAddress\\n }\\n\\n // Checks that `addr` is not blacklisted by token contracts that have a blacklist.\\n function assumeNotBlacklisted(address token, address addr) internal view virtual {\\n // Nothing to check if `token` is not a contract.\\n uint256 tokenCodeSize;\\n assembly {\\n tokenCodeSize := extcodesize(token)\\n }\\n require(tokenCodeSize > 0, \\\"StdCheats assumeNotBlacklisted(address,address): Token address is not a contract.\\\");\\n\\n bool success;\\n bytes memory returnData;\\n\\n // 4-byte selector for `isBlacklisted(address)`, used by USDC.\\n (success, returnData) = token.staticcall(abi.encodeWithSelector(0xfe575a87, addr));\\n vm.assume(!success || abi.decode(returnData, (bool)) == false);\\n\\n // 4-byte selector for `isBlackListed(address)`, used by USDT.\\n (success, returnData) = token.staticcall(abi.encodeWithSelector(0xe47d6060, addr));\\n vm.assume(!success || abi.decode(returnData, (bool)) == false);\\n }\\n\\n // Checks that `addr` is not blacklisted by token contracts that have a blacklist.\\n // This is identical to `assumeNotBlacklisted(address,address)` but with a different name, for\\n // backwards compatibility, since this name was used in the original PR which already has\\n // a release. This function can be removed in a future release once we want a breaking change.\\n function assumeNoBlacklisted(address token, address addr) internal view virtual {\\n assumeNotBlacklisted(token, addr);\\n }\\n\\n function assumeAddressIsNot(address addr, AddressType addressType) internal virtual {\\n if (addressType == AddressType.Payable) {\\n assumeNotPayable(addr);\\n } else if (addressType == AddressType.NonPayable) {\\n assumePayable(addr);\\n } else if (addressType == AddressType.ZeroAddress) {\\n assumeNotZeroAddress(addr);\\n } else if (addressType == AddressType.Precompile) {\\n assumeNotPrecompile(addr);\\n } else if (addressType == AddressType.ForgeAddress) {\\n assumeNotForgeAddress(addr);\\n }\\n }\\n\\n function assumeAddressIsNot(address addr, AddressType addressType1, AddressType addressType2) internal virtual {\\n assumeAddressIsNot(addr, addressType1);\\n assumeAddressIsNot(addr, addressType2);\\n }\\n\\n function assumeAddressIsNot(\\n address addr,\\n AddressType addressType1,\\n AddressType addressType2,\\n AddressType addressType3\\n ) internal virtual {\\n assumeAddressIsNot(addr, addressType1);\\n assumeAddressIsNot(addr, addressType2);\\n assumeAddressIsNot(addr, addressType3);\\n }\\n\\n function assumeAddressIsNot(\\n address addr,\\n AddressType addressType1,\\n AddressType addressType2,\\n AddressType addressType3,\\n AddressType addressType4\\n ) internal virtual {\\n assumeAddressIsNot(addr, addressType1);\\n assumeAddressIsNot(addr, addressType2);\\n assumeAddressIsNot(addr, addressType3);\\n assumeAddressIsNot(addr, addressType4);\\n }\\n\\n // This function checks whether an address, `addr`, is payable. It works by sending 1 wei to\\n // `addr` and checking the `success` return value.\\n // NOTE: This function may result in state changes depending on the fallback/receive logic\\n // implemented by `addr`, which should be taken into account when this function is used.\\n function _isPayable(address addr) private returns (bool) {\\n require(\\n addr.balance < UINT256_MAX,\\n \\\"StdCheats _isPayable(address): Balance equals max uint256, so it cannot receive any more funds\\\"\\n );\\n uint256 origBalanceTest = address(this).balance;\\n uint256 origBalanceAddr = address(addr).balance;\\n\\n vm.deal(address(this), 1);\\n (bool success,) = payable(addr).call{value: 1}(\\\"\\\");\\n\\n // reset balances\\n vm.deal(address(this), origBalanceTest);\\n vm.deal(addr, origBalanceAddr);\\n\\n return success;\\n }\\n\\n // NOTE: This function may result in state changes depending on the fallback/receive logic\\n // implemented by `addr`, which should be taken into account when this function is used. See the\\n // `_isPayable` method for more information.\\n function assumePayable(address addr) internal virtual {\\n vm.assume(_isPayable(addr));\\n }\\n\\n function assumeNotPayable(address addr) internal virtual {\\n vm.assume(!_isPayable(addr));\\n }\\n\\n function assumeNotZeroAddress(address addr) internal pure virtual {\\n vm.assume(addr != address(0));\\n }\\n\\n function assumeNotPrecompile(address addr) internal pure virtual {\\n assumeNotPrecompile(addr, _pureChainId());\\n }\\n\\n function assumeNotPrecompile(address addr, uint256 chainId) internal pure virtual {\\n // Note: For some chains like Optimism these are technically predeploys (i.e. bytecode placed at a specific\\n // address), but the same rationale for excluding them applies so we include those too.\\n\\n // These are reserved by Ethereum and may be on all EVM-compatible chains.\\n vm.assume(addr < address(0x1) || addr > address(0xff));\\n\\n // forgefmt: disable-start\\n if (chainId == 10 || chainId == 420) {\\n // https://github.com/ethereum-optimism/optimism/blob/eaa371a0184b56b7ca6d9eb9cb0a2b78b2ccd864/op-bindings/predeploys/addresses.go#L6-L21\\n vm.assume(addr < address(0x4200000000000000000000000000000000000000) || addr > address(0x4200000000000000000000000000000000000800));\\n } else if (chainId == 42161 || chainId == 421613) {\\n // https://developer.arbitrum.io/useful-addresses#arbitrum-precompiles-l2-same-on-all-arb-chains\\n vm.assume(addr < address(0x0000000000000000000000000000000000000064) || addr > address(0x0000000000000000000000000000000000000068));\\n } else if (chainId == 43114 || chainId == 43113) {\\n // https://github.com/ava-labs/subnet-evm/blob/47c03fd007ecaa6de2c52ea081596e0a88401f58/precompile/params.go#L18-L59\\n vm.assume(addr < address(0x0100000000000000000000000000000000000000) || addr > address(0x01000000000000000000000000000000000000ff));\\n vm.assume(addr < address(0x0200000000000000000000000000000000000000) || addr > address(0x02000000000000000000000000000000000000FF));\\n vm.assume(addr < address(0x0300000000000000000000000000000000000000) || addr > address(0x03000000000000000000000000000000000000Ff));\\n }\\n // forgefmt: disable-end\\n }\\n\\n function assumeNotForgeAddress(address addr) internal pure virtual {\\n // vm, console, and Create2Deployer addresses\\n vm.assume(\\n addr != address(vm) && addr != 0x000000000000000000636F6e736F6c652e6c6f67\\n && addr != 0x4e59b44847b379578588920cA78FbF26c0B4956C\\n );\\n }\\n\\n function assumeUnusedAddress(address addr) internal view virtual {\\n uint256 size;\\n assembly {\\n size := extcodesize(addr)\\n }\\n vm.assume(size == 0);\\n\\n assumeNotPrecompile(addr);\\n assumeNotZeroAddress(addr);\\n assumeNotForgeAddress(addr);\\n }\\n\\n function readEIP1559ScriptArtifact(string memory path)\\n internal\\n view\\n virtual\\n returns (EIP1559ScriptArtifact memory)\\n {\\n string memory data = vm.readFile(path);\\n bytes memory parsedData = vm.parseJson(data);\\n RawEIP1559ScriptArtifact memory rawArtifact = abi.decode(parsedData, (RawEIP1559ScriptArtifact));\\n EIP1559ScriptArtifact memory artifact;\\n artifact.libraries = rawArtifact.libraries;\\n artifact.path = rawArtifact.path;\\n artifact.timestamp = rawArtifact.timestamp;\\n artifact.pending = rawArtifact.pending;\\n artifact.txReturns = rawArtifact.txReturns;\\n artifact.receipts = rawToConvertedReceipts(rawArtifact.receipts);\\n artifact.transactions = rawToConvertedEIPTx1559s(rawArtifact.transactions);\\n return artifact;\\n }\\n\\n function rawToConvertedEIPTx1559s(RawTx1559[] memory rawTxs) internal pure virtual returns (Tx1559[] memory) {\\n Tx1559[] memory txs = new Tx1559[](rawTxs.length);\\n for (uint256 i; i < rawTxs.length; i++) {\\n txs[i] = rawToConvertedEIPTx1559(rawTxs[i]);\\n }\\n return txs;\\n }\\n\\n function rawToConvertedEIPTx1559(RawTx1559 memory rawTx) internal pure virtual returns (Tx1559 memory) {\\n Tx1559 memory transaction;\\n transaction.arguments = rawTx.arguments;\\n transaction.contractName = rawTx.contractName;\\n transaction.functionSig = rawTx.functionSig;\\n transaction.hash = rawTx.hash;\\n transaction.txDetail = rawToConvertedEIP1559Detail(rawTx.txDetail);\\n transaction.opcode = rawTx.opcode;\\n return transaction;\\n }\\n\\n function rawToConvertedEIP1559Detail(RawTx1559Detail memory rawDetail)\\n internal\\n pure\\n virtual\\n returns (Tx1559Detail memory)\\n {\\n Tx1559Detail memory txDetail;\\n txDetail.data = rawDetail.data;\\n txDetail.from = rawDetail.from;\\n txDetail.to = rawDetail.to;\\n txDetail.nonce = _bytesToUint(rawDetail.nonce);\\n txDetail.txType = _bytesToUint(rawDetail.txType);\\n txDetail.value = _bytesToUint(rawDetail.value);\\n txDetail.gas = _bytesToUint(rawDetail.gas);\\n txDetail.accessList = rawDetail.accessList;\\n return txDetail;\\n }\\n\\n function readTx1559s(string memory path) internal view virtual returns (Tx1559[] memory) {\\n string memory deployData = vm.readFile(path);\\n bytes memory parsedDeployData = vm.parseJson(deployData, \\\".transactions\\\");\\n RawTx1559[] memory rawTxs = abi.decode(parsedDeployData, (RawTx1559[]));\\n return rawToConvertedEIPTx1559s(rawTxs);\\n }\\n\\n function readTx1559(string memory path, uint256 index) internal view virtual returns (Tx1559 memory) {\\n string memory deployData = vm.readFile(path);\\n string memory key = string(abi.encodePacked(\\\".transactions[\\\", vm.toString(index), \\\"]\\\"));\\n bytes memory parsedDeployData = vm.parseJson(deployData, key);\\n RawTx1559 memory rawTx = abi.decode(parsedDeployData, (RawTx1559));\\n return rawToConvertedEIPTx1559(rawTx);\\n }\\n\\n // Analogous to readTransactions, but for receipts.\\n function readReceipts(string memory path) internal view virtual returns (Receipt[] memory) {\\n string memory deployData = vm.readFile(path);\\n bytes memory parsedDeployData = vm.parseJson(deployData, \\\".receipts\\\");\\n RawReceipt[] memory rawReceipts = abi.decode(parsedDeployData, (RawReceipt[]));\\n return rawToConvertedReceipts(rawReceipts);\\n }\\n\\n function readReceipt(string memory path, uint256 index) internal view virtual returns (Receipt memory) {\\n string memory deployData = vm.readFile(path);\\n string memory key = string(abi.encodePacked(\\\".receipts[\\\", vm.toString(index), \\\"]\\\"));\\n bytes memory parsedDeployData = vm.parseJson(deployData, key);\\n RawReceipt memory rawReceipt = abi.decode(parsedDeployData, (RawReceipt));\\n return rawToConvertedReceipt(rawReceipt);\\n }\\n\\n function rawToConvertedReceipts(RawReceipt[] memory rawReceipts) internal pure virtual returns (Receipt[] memory) {\\n Receipt[] memory receipts = new Receipt[](rawReceipts.length);\\n for (uint256 i; i < rawReceipts.length; i++) {\\n receipts[i] = rawToConvertedReceipt(rawReceipts[i]);\\n }\\n return receipts;\\n }\\n\\n function rawToConvertedReceipt(RawReceipt memory rawReceipt) internal pure virtual returns (Receipt memory) {\\n Receipt memory receipt;\\n receipt.blockHash = rawReceipt.blockHash;\\n receipt.to = rawReceipt.to;\\n receipt.from = rawReceipt.from;\\n receipt.contractAddress = rawReceipt.contractAddress;\\n receipt.effectiveGasPrice = _bytesToUint(rawReceipt.effectiveGasPrice);\\n receipt.cumulativeGasUsed = _bytesToUint(rawReceipt.cumulativeGasUsed);\\n receipt.gasUsed = _bytesToUint(rawReceipt.gasUsed);\\n receipt.status = _bytesToUint(rawReceipt.status);\\n receipt.transactionIndex = _bytesToUint(rawReceipt.transactionIndex);\\n receipt.blockNumber = _bytesToUint(rawReceipt.blockNumber);\\n receipt.logs = rawToConvertedReceiptLogs(rawReceipt.logs);\\n receipt.logsBloom = rawReceipt.logsBloom;\\n receipt.transactionHash = rawReceipt.transactionHash;\\n return receipt;\\n }\\n\\n function rawToConvertedReceiptLogs(RawReceiptLog[] memory rawLogs)\\n internal\\n pure\\n virtual\\n returns (ReceiptLog[] memory)\\n {\\n ReceiptLog[] memory logs = new ReceiptLog[](rawLogs.length);\\n for (uint256 i; i < rawLogs.length; i++) {\\n logs[i].logAddress = rawLogs[i].logAddress;\\n logs[i].blockHash = rawLogs[i].blockHash;\\n logs[i].blockNumber = _bytesToUint(rawLogs[i].blockNumber);\\n logs[i].data = rawLogs[i].data;\\n logs[i].logIndex = _bytesToUint(rawLogs[i].logIndex);\\n logs[i].topics = rawLogs[i].topics;\\n logs[i].transactionIndex = _bytesToUint(rawLogs[i].transactionIndex);\\n logs[i].transactionLogIndex = _bytesToUint(rawLogs[i].transactionLogIndex);\\n logs[i].removed = rawLogs[i].removed;\\n }\\n return logs;\\n }\\n\\n // Deploy a contract by fetching the contract bytecode from\\n // the artifacts directory\\n // e.g. `deployCode(code, abi.encode(arg1,arg2,arg3))`\\n function deployCode(string memory what, bytes memory args) internal virtual returns (address addr) {\\n bytes memory bytecode = abi.encodePacked(vm.getCode(what), args);\\n /// @solidity memory-safe-assembly\\n assembly {\\n addr := create(0, add(bytecode, 0x20), mload(bytecode))\\n }\\n\\n require(addr != address(0), \\\"StdCheats deployCode(string,bytes): Deployment failed.\\\");\\n }\\n\\n function deployCode(string memory what) internal virtual returns (address addr) {\\n bytes memory bytecode = vm.getCode(what);\\n /// @solidity memory-safe-assembly\\n assembly {\\n addr := create(0, add(bytecode, 0x20), mload(bytecode))\\n }\\n\\n require(addr != address(0), \\\"StdCheats deployCode(string): Deployment failed.\\\");\\n }\\n\\n /// @dev deploy contract with value on construction\\n function deployCode(string memory what, bytes memory args, uint256 val) internal virtual returns (address addr) {\\n bytes memory bytecode = abi.encodePacked(vm.getCode(what), args);\\n /// @solidity memory-safe-assembly\\n assembly {\\n addr := create(val, add(bytecode, 0x20), mload(bytecode))\\n }\\n\\n require(addr != address(0), \\\"StdCheats deployCode(string,bytes,uint256): Deployment failed.\\\");\\n }\\n\\n function deployCode(string memory what, uint256 val) internal virtual returns (address addr) {\\n bytes memory bytecode = vm.getCode(what);\\n /// @solidity memory-safe-assembly\\n assembly {\\n addr := create(val, add(bytecode, 0x20), mload(bytecode))\\n }\\n\\n require(addr != address(0), \\\"StdCheats deployCode(string,uint256): Deployment failed.\\\");\\n }\\n\\n // creates a labeled address and the corresponding private key\\n function makeAddrAndKey(string memory name) internal virtual returns (address addr, uint256 privateKey) {\\n privateKey = uint256(keccak256(abi.encodePacked(name)));\\n addr = vm.addr(privateKey);\\n vm.label(addr, name);\\n }\\n\\n // creates a labeled address\\n function makeAddr(string memory name) internal virtual returns (address addr) {\\n (addr,) = makeAddrAndKey(name);\\n }\\n\\n // Destroys an account immediately, sending the balance to beneficiary.\\n // Destroying means: balance will be zero, code will be empty, and nonce will be 0\\n // This is similar to selfdestruct but not identical: selfdestruct destroys code and nonce\\n // only after tx ends, this will run immediately.\\n function destroyAccount(address who, address beneficiary) internal virtual {\\n uint256 currBalance = who.balance;\\n vm.etch(who, abi.encode());\\n vm.deal(who, 0);\\n vm.resetNonce(who);\\n\\n uint256 beneficiaryBalance = beneficiary.balance;\\n vm.deal(beneficiary, currBalance + beneficiaryBalance);\\n }\\n\\n // creates a struct containing both a labeled address and the corresponding private key\\n function makeAccount(string memory name) internal virtual returns (Account memory account) {\\n (account.addr, account.key) = makeAddrAndKey(name);\\n }\\n\\n function deriveRememberKey(string memory mnemonic, uint32 index)\\n internal\\n virtual\\n returns (address who, uint256 privateKey)\\n {\\n privateKey = vm.deriveKey(mnemonic, index);\\n who = vm.rememberKey(privateKey);\\n }\\n\\n function _bytesToUint(bytes memory b) private pure returns (uint256) {\\n require(b.length <= 32, \\\"StdCheats _bytesToUint(bytes): Bytes length exceeds 32.\\\");\\n return abi.decode(abi.encodePacked(new bytes(32 - b.length), b), (uint256));\\n }\\n\\n function isFork() internal view virtual returns (bool status) {\\n try vm.activeFork() {\\n status = true;\\n } catch (bytes memory) {}\\n }\\n\\n modifier skipWhenForking() {\\n if (!isFork()) {\\n _;\\n }\\n }\\n\\n modifier skipWhenNotForking() {\\n if (isFork()) {\\n _;\\n }\\n }\\n\\n modifier noGasMetering() {\\n vm.pauseGasMetering();\\n // To prevent turning gas monitoring back on with nested functions that use this modifier,\\n // we check if gasMetering started in the off position. If it did, we don't want to turn\\n // it back on until we exit the top level function that used the modifier\\n //\\n // i.e. funcA() noGasMetering { funcB() }, where funcB has noGasMetering as well.\\n // funcA will have `gasStartedOff` as false, funcB will have it as true,\\n // so we only turn metering back on at the end of the funcA\\n bool gasStartedOff = gasMeteringOff;\\n gasMeteringOff = true;\\n\\n _;\\n\\n // if gas metering was on when this modifier was called, turn it back on at the end\\n if (!gasStartedOff) {\\n gasMeteringOff = false;\\n vm.resumeGasMetering();\\n }\\n }\\n\\n // We use this complex approach of `_viewChainId` and `_pureChainId` to ensure there are no\\n // compiler warnings when accessing chain ID in any solidity version supported by forge-std. We\\n // can't simply access the chain ID in a normal view or pure function because the solc View Pure\\n // Checker changed `chainid` from pure to view in 0.8.0.\\n function _viewChainId() private view returns (uint256 chainId) {\\n // Assembly required since `block.chainid` was introduced in 0.8.0.\\n assembly {\\n chainId := chainid()\\n }\\n\\n address(this); // Silence warnings in older Solc versions.\\n }\\n\\n function _pureChainId() private pure returns (uint256 chainId) {\\n function() internal view returns (uint256) fnIn = _viewChainId;\\n function() internal pure returns (uint256) pureChainId;\\n assembly {\\n pureChainId := fnIn\\n }\\n chainId = pureChainId();\\n }\\n}\\n\\n// Wrappers around cheatcodes to avoid footguns\\nabstract contract StdCheats is StdCheatsSafe {\\n using stdStorage for StdStorage;\\n\\n StdStorage private stdstore;\\n Vm private constant vm = Vm(address(uint160(uint256(keccak256(\\\"hevm cheat code\\\")))));\\n address private constant CONSOLE2_ADDRESS = 0x000000000000000000636F6e736F6c652e6c6f67;\\n\\n // Skip forward or rewind time by the specified number of seconds\\n function skip(uint256 time) internal virtual {\\n vm.warp(vm.getBlockTimestamp() + time);\\n }\\n\\n function rewind(uint256 time) internal virtual {\\n vm.warp(vm.getBlockTimestamp() - time);\\n }\\n\\n // Setup a prank from an address that has some ether\\n function hoax(address msgSender) internal virtual {\\n vm.deal(msgSender, 1 << 128);\\n vm.prank(msgSender);\\n }\\n\\n function hoax(address msgSender, uint256 give) internal virtual {\\n vm.deal(msgSender, give);\\n vm.prank(msgSender);\\n }\\n\\n function hoax(address msgSender, address origin) internal virtual {\\n vm.deal(msgSender, 1 << 128);\\n vm.prank(msgSender, origin);\\n }\\n\\n function hoax(address msgSender, address origin, uint256 give) internal virtual {\\n vm.deal(msgSender, give);\\n vm.prank(msgSender, origin);\\n }\\n\\n // Start perpetual prank from an address that has some ether\\n function startHoax(address msgSender) internal virtual {\\n vm.deal(msgSender, 1 << 128);\\n vm.startPrank(msgSender);\\n }\\n\\n function startHoax(address msgSender, uint256 give) internal virtual {\\n vm.deal(msgSender, give);\\n vm.startPrank(msgSender);\\n }\\n\\n // Start perpetual prank from an address that has some ether\\n // tx.origin is set to the origin parameter\\n function startHoax(address msgSender, address origin) internal virtual {\\n vm.deal(msgSender, 1 << 128);\\n vm.startPrank(msgSender, origin);\\n }\\n\\n function startHoax(address msgSender, address origin, uint256 give) internal virtual {\\n vm.deal(msgSender, give);\\n vm.startPrank(msgSender, origin);\\n }\\n\\n function changePrank(address msgSender) internal virtual {\\n console2_log_StdCheats(\\\"changePrank is deprecated. Please use vm.startPrank instead.\\\");\\n vm.stopPrank();\\n vm.startPrank(msgSender);\\n }\\n\\n function changePrank(address msgSender, address txOrigin) internal virtual {\\n vm.stopPrank();\\n vm.startPrank(msgSender, txOrigin);\\n }\\n\\n // The same as Vm's `deal`\\n // Use the alternative signature for ERC20 tokens\\n function deal(address to, uint256 give) internal virtual {\\n vm.deal(to, give);\\n }\\n\\n // Set the balance of an account for any ERC20 token\\n // Use the alternative signature to update `totalSupply`\\n function deal(address token, address to, uint256 give) internal virtual {\\n deal(token, to, give, false);\\n }\\n\\n // Set the balance of an account for any ERC1155 token\\n // Use the alternative signature to update `totalSupply`\\n function dealERC1155(address token, address to, uint256 id, uint256 give) internal virtual {\\n dealERC1155(token, to, id, give, false);\\n }\\n\\n function deal(address token, address to, uint256 give, bool adjust) internal virtual {\\n // get current balance\\n (, bytes memory balData) = token.staticcall(abi.encodeWithSelector(0x70a08231, to));\\n uint256 prevBal = abi.decode(balData, (uint256));\\n\\n // update balance\\n stdstore.target(token).sig(0x70a08231).with_key(to).checked_write(give);\\n\\n // update total supply\\n if (adjust) {\\n (, bytes memory totSupData) = token.staticcall(abi.encodeWithSelector(0x18160ddd));\\n uint256 totSup = abi.decode(totSupData, (uint256));\\n if (give < prevBal) {\\n totSup -= (prevBal - give);\\n } else {\\n totSup += (give - prevBal);\\n }\\n stdstore.target(token).sig(0x18160ddd).checked_write(totSup);\\n }\\n }\\n\\n function dealERC1155(address token, address to, uint256 id, uint256 give, bool adjust) internal virtual {\\n // get current balance\\n (, bytes memory balData) = token.staticcall(abi.encodeWithSelector(0x00fdd58e, to, id));\\n uint256 prevBal = abi.decode(balData, (uint256));\\n\\n // update balance\\n stdstore.target(token).sig(0x00fdd58e).with_key(to).with_key(id).checked_write(give);\\n\\n // update total supply\\n if (adjust) {\\n (, bytes memory totSupData) = token.staticcall(abi.encodeWithSelector(0xbd85b039, id));\\n require(\\n totSupData.length != 0,\\n \\\"StdCheats deal(address,address,uint,uint,bool): target contract is not ERC1155Supply.\\\"\\n );\\n uint256 totSup = abi.decode(totSupData, (uint256));\\n if (give < prevBal) {\\n totSup -= (prevBal - give);\\n } else {\\n totSup += (give - prevBal);\\n }\\n stdstore.target(token).sig(0xbd85b039).with_key(id).checked_write(totSup);\\n }\\n }\\n\\n function dealERC721(address token, address to, uint256 id) internal virtual {\\n // check if token id is already minted and the actual owner.\\n (bool successMinted, bytes memory ownerData) = token.staticcall(abi.encodeWithSelector(0x6352211e, id));\\n require(successMinted, \\\"StdCheats deal(address,address,uint,bool): id not minted.\\\");\\n\\n // get owner current balance\\n (, bytes memory fromBalData) =\\n token.staticcall(abi.encodeWithSelector(0x70a08231, abi.decode(ownerData, (address))));\\n uint256 fromPrevBal = abi.decode(fromBalData, (uint256));\\n\\n // get new user current balance\\n (, bytes memory toBalData) = token.staticcall(abi.encodeWithSelector(0x70a08231, to));\\n uint256 toPrevBal = abi.decode(toBalData, (uint256));\\n\\n // update balances\\n stdstore.target(token).sig(0x70a08231).with_key(abi.decode(ownerData, (address))).checked_write(--fromPrevBal);\\n stdstore.target(token).sig(0x70a08231).with_key(to).checked_write(++toPrevBal);\\n\\n // update owner\\n stdstore.target(token).sig(0x6352211e).with_key(id).checked_write(to);\\n }\\n\\n function deployCodeTo(string memory what, address where) internal virtual {\\n deployCodeTo(what, \\\"\\\", 0, where);\\n }\\n\\n function deployCodeTo(string memory what, bytes memory args, address where) internal virtual {\\n deployCodeTo(what, args, 0, where);\\n }\\n\\n function deployCodeTo(string memory what, bytes memory args, uint256 value, address where) internal virtual {\\n bytes memory creationCode = vm.getCode(what);\\n vm.etch(where, abi.encodePacked(creationCode, args));\\n (bool success, bytes memory runtimeBytecode) = where.call{value: value}(\\\"\\\");\\n require(success, \\\"StdCheats deployCodeTo(string,bytes,uint256,address): Failed to create runtime bytecode.\\\");\\n vm.etch(where, runtimeBytecode);\\n }\\n\\n // Used to prevent the compilation of console, which shortens the compilation time when console is not used elsewhere.\\n function console2_log_StdCheats(string memory p0) private view {\\n (bool status,) = address(CONSOLE2_ADDRESS).staticcall(abi.encodeWithSignature(\\\"log(string)\\\", p0));\\n status;\\n }\\n}\\n\",\"keccak256\":\"0x0fa6ec03602648b62cce41aab2096e6b7e052f2846075d967b6958dd586db746\",\"license\":\"MIT\"},\"lib/forge-std/src/StdConstants.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity >=0.6.2 <0.9.0;\\n\\nimport {IMulticall3} from \\\"./interfaces/IMulticall3.sol\\\";\\nimport {Vm} from \\\"./Vm.sol\\\";\\n\\nlibrary StdConstants {\\n /// @dev Cheat code address.\\n /// Calculated as `address(uint160(uint256(keccak256(\\\"hevm cheat code\\\"))))`.\\n Vm internal constant VM = Vm(0x7109709ECfa91a80626fF3989D68f67F5b1DD12D);\\n /// @dev console.sol and console2.sol work by executing a staticcall to this address.\\n /// Calculated as `address(uint160(uint88(bytes11(\\\"console.log\\\"))))`.\\n address internal constant CONSOLE = 0x000000000000000000636F6e736F6c652e6c6f67;\\n /// @dev Used when deploying with create2.\\n /// Taken from https://github.com/Arachnid/deterministic-deployment-proxy.\\n address internal constant CREATE2_FACTORY = 0x4e59b44847b379578588920cA78FbF26c0B4956C;\\n /// @dev The default address for tx.origin and msg.sender.\\n /// Calculated as `address(uint160(uint256(keccak256(\\\"foundry default caller\\\"))))`.\\n address internal constant DEFAULT_SENDER = 0x1804c8AB1F12E6bbf3894d4083f33e07309d1f38;\\n /// @dev The address of the first contract `CREATE`d by a running test contract.\\n /// When running tests, each test contract is `CREATE`d by `DEFAULT_SENDER` with nonce 1.\\n /// Calculated as `VM.computeCreateAddress(VM.computeCreateAddress(DEFAULT_SENDER, 1), 1)`.\\n address internal constant DEFAULT_TEST_CONTRACT = 0x5615dEB798BB3E4dFa0139dFa1b3D433Cc23b72f;\\n /// @dev Deterministic deployment address of the Multicall3 contract.\\n /// Taken from https://www.multicall3.com.\\n IMulticall3 internal constant MULTICALL3_ADDRESS = IMulticall3(0xcA11bde05977b3631167028862bE2a173976CA11);\\n /// @dev The order of the secp256k1 curve.\\n uint256 internal constant SECP256K1_ORDER =\\n 115792089237316195423570985008687907852837564279074904382605163141518161494337;\\n}\\n\",\"keccak256\":\"0x319ccdabfa2c0b2428301445873270ffea20f0e039d4fd5e6eeba65158e4e534\",\"license\":\"MIT\"},\"lib/forge-std/src/StdJson.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity >=0.6.0 <0.9.0;\\n\\npragma experimental ABIEncoderV2;\\n\\nimport {VmSafe} from \\\"./Vm.sol\\\";\\n\\n// Helpers for parsing and writing JSON files\\n// To parse:\\n// ```\\n// using stdJson for string;\\n// string memory json = vm.readFile(\\\"\\\");\\n// json.readUint(\\\"\\\");\\n// ```\\n// To write:\\n// ```\\n// using stdJson for string;\\n// string memory json = \\\"json\\\";\\n// json.serialize(\\\"a\\\", uint256(123));\\n// string memory semiFinal = json.serialize(\\\"b\\\", string(\\\"test\\\"));\\n// string memory finalJson = json.serialize(\\\"c\\\", semiFinal);\\n// finalJson.write(\\\"\\\");\\n// ```\\n\\nlibrary stdJson {\\n VmSafe private constant vm = VmSafe(address(uint160(uint256(keccak256(\\\"hevm cheat code\\\")))));\\n\\n function keyExists(string memory json, string memory key) internal view returns (bool) {\\n return vm.keyExistsJson(json, key);\\n }\\n\\n function parseRaw(string memory json, string memory key) internal pure returns (bytes memory) {\\n return vm.parseJson(json, key);\\n }\\n\\n function readUint(string memory json, string memory key) internal pure returns (uint256) {\\n return vm.parseJsonUint(json, key);\\n }\\n\\n function readUintArray(string memory json, string memory key) internal pure returns (uint256[] memory) {\\n return vm.parseJsonUintArray(json, key);\\n }\\n\\n function readInt(string memory json, string memory key) internal pure returns (int256) {\\n return vm.parseJsonInt(json, key);\\n }\\n\\n function readIntArray(string memory json, string memory key) internal pure returns (int256[] memory) {\\n return vm.parseJsonIntArray(json, key);\\n }\\n\\n function readBytes32(string memory json, string memory key) internal pure returns (bytes32) {\\n return vm.parseJsonBytes32(json, key);\\n }\\n\\n function readBytes32Array(string memory json, string memory key) internal pure returns (bytes32[] memory) {\\n return vm.parseJsonBytes32Array(json, key);\\n }\\n\\n function readString(string memory json, string memory key) internal pure returns (string memory) {\\n return vm.parseJsonString(json, key);\\n }\\n\\n function readStringArray(string memory json, string memory key) internal pure returns (string[] memory) {\\n return vm.parseJsonStringArray(json, key);\\n }\\n\\n function readAddress(string memory json, string memory key) internal pure returns (address) {\\n return vm.parseJsonAddress(json, key);\\n }\\n\\n function readAddressArray(string memory json, string memory key) internal pure returns (address[] memory) {\\n return vm.parseJsonAddressArray(json, key);\\n }\\n\\n function readBool(string memory json, string memory key) internal pure returns (bool) {\\n return vm.parseJsonBool(json, key);\\n }\\n\\n function readBoolArray(string memory json, string memory key) internal pure returns (bool[] memory) {\\n return vm.parseJsonBoolArray(json, key);\\n }\\n\\n function readBytes(string memory json, string memory key) internal pure returns (bytes memory) {\\n return vm.parseJsonBytes(json, key);\\n }\\n\\n function readBytesArray(string memory json, string memory key) internal pure returns (bytes[] memory) {\\n return vm.parseJsonBytesArray(json, key);\\n }\\n\\n function readUintOr(string memory json, string memory key, uint256 defaultValue) internal view returns (uint256) {\\n return keyExists(json, key) ? readUint(json, key) : defaultValue;\\n }\\n\\n function readUintArrayOr(string memory json, string memory key, uint256[] memory defaultValue)\\n internal\\n view\\n returns (uint256[] memory)\\n {\\n return keyExists(json, key) ? readUintArray(json, key) : defaultValue;\\n }\\n\\n function readIntOr(string memory json, string memory key, int256 defaultValue) internal view returns (int256) {\\n return keyExists(json, key) ? readInt(json, key) : defaultValue;\\n }\\n\\n function readIntArrayOr(string memory json, string memory key, int256[] memory defaultValue)\\n internal\\n view\\n returns (int256[] memory)\\n {\\n return keyExists(json, key) ? readIntArray(json, key) : defaultValue;\\n }\\n\\n function readBytes32Or(string memory json, string memory key, bytes32 defaultValue)\\n internal\\n view\\n returns (bytes32)\\n {\\n return keyExists(json, key) ? readBytes32(json, key) : defaultValue;\\n }\\n\\n function readBytes32ArrayOr(string memory json, string memory key, bytes32[] memory defaultValue)\\n internal\\n view\\n returns (bytes32[] memory)\\n {\\n return keyExists(json, key) ? readBytes32Array(json, key) : defaultValue;\\n }\\n\\n function readStringOr(string memory json, string memory key, string memory defaultValue)\\n internal\\n view\\n returns (string memory)\\n {\\n return keyExists(json, key) ? readString(json, key) : defaultValue;\\n }\\n\\n function readStringArrayOr(string memory json, string memory key, string[] memory defaultValue)\\n internal\\n view\\n returns (string[] memory)\\n {\\n return keyExists(json, key) ? readStringArray(json, key) : defaultValue;\\n }\\n\\n function readAddressOr(string memory json, string memory key, address defaultValue)\\n internal\\n view\\n returns (address)\\n {\\n return keyExists(json, key) ? readAddress(json, key) : defaultValue;\\n }\\n\\n function readAddressArrayOr(string memory json, string memory key, address[] memory defaultValue)\\n internal\\n view\\n returns (address[] memory)\\n {\\n return keyExists(json, key) ? readAddressArray(json, key) : defaultValue;\\n }\\n\\n function readBoolOr(string memory json, string memory key, bool defaultValue) internal view returns (bool) {\\n return keyExists(json, key) ? readBool(json, key) : defaultValue;\\n }\\n\\n function readBoolArrayOr(string memory json, string memory key, bool[] memory defaultValue)\\n internal\\n view\\n returns (bool[] memory)\\n {\\n return keyExists(json, key) ? readBoolArray(json, key) : defaultValue;\\n }\\n\\n function readBytesOr(string memory json, string memory key, bytes memory defaultValue)\\n internal\\n view\\n returns (bytes memory)\\n {\\n return keyExists(json, key) ? readBytes(json, key) : defaultValue;\\n }\\n\\n function readBytesArrayOr(string memory json, string memory key, bytes[] memory defaultValue)\\n internal\\n view\\n returns (bytes[] memory)\\n {\\n return keyExists(json, key) ? readBytesArray(json, key) : defaultValue;\\n }\\n\\n function serialize(string memory jsonKey, string memory rootObject) internal returns (string memory) {\\n return vm.serializeJson(jsonKey, rootObject);\\n }\\n\\n function serialize(string memory jsonKey, string memory key, bool value) internal returns (string memory) {\\n return vm.serializeBool(jsonKey, key, value);\\n }\\n\\n function serialize(string memory jsonKey, string memory key, bool[] memory value)\\n internal\\n returns (string memory)\\n {\\n return vm.serializeBool(jsonKey, key, value);\\n }\\n\\n function serialize(string memory jsonKey, string memory key, uint256 value) internal returns (string memory) {\\n return vm.serializeUint(jsonKey, key, value);\\n }\\n\\n function serialize(string memory jsonKey, string memory key, uint256[] memory value)\\n internal\\n returns (string memory)\\n {\\n return vm.serializeUint(jsonKey, key, value);\\n }\\n\\n function serialize(string memory jsonKey, string memory key, int256 value) internal returns (string memory) {\\n return vm.serializeInt(jsonKey, key, value);\\n }\\n\\n function serialize(string memory jsonKey, string memory key, int256[] memory value)\\n internal\\n returns (string memory)\\n {\\n return vm.serializeInt(jsonKey, key, value);\\n }\\n\\n function serialize(string memory jsonKey, string memory key, address value) internal returns (string memory) {\\n return vm.serializeAddress(jsonKey, key, value);\\n }\\n\\n function serialize(string memory jsonKey, string memory key, address[] memory value)\\n internal\\n returns (string memory)\\n {\\n return vm.serializeAddress(jsonKey, key, value);\\n }\\n\\n function serialize(string memory jsonKey, string memory key, bytes32 value) internal returns (string memory) {\\n return vm.serializeBytes32(jsonKey, key, value);\\n }\\n\\n function serialize(string memory jsonKey, string memory key, bytes32[] memory value)\\n internal\\n returns (string memory)\\n {\\n return vm.serializeBytes32(jsonKey, key, value);\\n }\\n\\n function serialize(string memory jsonKey, string memory key, bytes memory value) internal returns (string memory) {\\n return vm.serializeBytes(jsonKey, key, value);\\n }\\n\\n function serialize(string memory jsonKey, string memory key, bytes[] memory value)\\n internal\\n returns (string memory)\\n {\\n return vm.serializeBytes(jsonKey, key, value);\\n }\\n\\n function serialize(string memory jsonKey, string memory key, string memory value)\\n internal\\n returns (string memory)\\n {\\n return vm.serializeString(jsonKey, key, value);\\n }\\n\\n function serialize(string memory jsonKey, string memory key, string[] memory value)\\n internal\\n returns (string memory)\\n {\\n return vm.serializeString(jsonKey, key, value);\\n }\\n\\n function write(string memory jsonKey, string memory path) internal {\\n vm.writeJson(jsonKey, path);\\n }\\n\\n function write(string memory jsonKey, string memory path, string memory valueKey) internal {\\n vm.writeJson(jsonKey, path, valueKey);\\n }\\n}\\n\",\"keccak256\":\"0xbc0132abe1c2accc2867c0f03667afffdf92f3e95a581bb03c9557eaa38ea500\",\"license\":\"MIT\"},\"lib/forge-std/src/StdMath.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity >=0.6.2 <0.9.0;\\n\\nlibrary stdMath {\\n int256 private constant INT256_MIN = -57896044618658097711785492504343953926634992332820282019728792003956564819968;\\n\\n function abs(int256 a) internal pure returns (uint256) {\\n // Required or it will fail when `a = type(int256).min`\\n if (a == INT256_MIN) {\\n return 57896044618658097711785492504343953926634992332820282019728792003956564819968;\\n }\\n\\n return uint256(a > 0 ? a : -a);\\n }\\n\\n function delta(uint256 a, uint256 b) internal pure returns (uint256) {\\n return a > b ? a - b : b - a;\\n }\\n\\n function delta(int256 a, int256 b) internal pure returns (uint256) {\\n // a and b are of the same sign\\n // this works thanks to two's complement, the left-most bit is the sign bit\\n if ((a ^ b) > -1) {\\n return delta(abs(a), abs(b));\\n }\\n\\n // a and b are of opposite signs\\n return abs(a) + abs(b);\\n }\\n\\n function percentDelta(uint256 a, uint256 b) internal pure returns (uint256) {\\n uint256 absDelta = delta(a, b);\\n\\n return absDelta * 1e18 / b;\\n }\\n\\n function percentDelta(int256 a, int256 b) internal pure returns (uint256) {\\n uint256 absDelta = delta(a, b);\\n uint256 absB = abs(b);\\n\\n return absDelta * 1e18 / absB;\\n }\\n}\\n\",\"keccak256\":\"0xd90ad4fd8aeaeb8929964e686e769fdedd5eded3fc3815df194a0ab9f91a3fb2\",\"license\":\"MIT\"},\"lib/forge-std/src/StdStorage.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity >=0.6.2 <0.9.0;\\n\\nimport {Vm} from \\\"./Vm.sol\\\";\\n\\nstruct FindData {\\n uint256 slot;\\n uint256 offsetLeft;\\n uint256 offsetRight;\\n bool found;\\n}\\n\\nstruct StdStorage {\\n mapping(address => mapping(bytes4 => mapping(bytes32 => FindData))) finds;\\n bytes32[] _keys;\\n bytes4 _sig;\\n uint256 _depth;\\n address _target;\\n bytes32 _set;\\n bool _enable_packed_slots;\\n bytes _calldata;\\n}\\n\\nlibrary stdStorageSafe {\\n event SlotFound(address who, bytes4 fsig, bytes32 keysHash, uint256 slot);\\n event WARNING_UninitedSlot(address who, uint256 slot);\\n\\n Vm private constant vm = Vm(address(uint160(uint256(keccak256(\\\"hevm cheat code\\\")))));\\n uint256 constant UINT256_MAX = 115792089237316195423570985008687907853269984665640564039457584007913129639935;\\n\\n function sigs(string memory sigStr) internal pure returns (bytes4) {\\n return bytes4(keccak256(bytes(sigStr)));\\n }\\n\\n function getCallParams(StdStorage storage self) internal view returns (bytes memory) {\\n if (self._calldata.length == 0) {\\n return flatten(self._keys);\\n } else {\\n return self._calldata;\\n }\\n }\\n\\n // Calls target contract with configured parameters\\n function callTarget(StdStorage storage self) internal view returns (bool, bytes32) {\\n bytes memory cald = abi.encodePacked(self._sig, getCallParams(self));\\n (bool success, bytes memory rdat) = self._target.staticcall(cald);\\n bytes32 result = bytesToBytes32(rdat, 32 * self._depth);\\n\\n return (success, result);\\n }\\n\\n // Tries mutating slot value to determine if the targeted value is stored in it.\\n // If current value is 0, then we are setting slot value to type(uint256).max\\n // Otherwise, we set it to 0. That way, return value should always be affected.\\n function checkSlotMutatesCall(StdStorage storage self, bytes32 slot) internal returns (bool) {\\n bytes32 prevSlotValue = vm.load(self._target, slot);\\n (bool success, bytes32 prevReturnValue) = callTarget(self);\\n\\n bytes32 testVal = prevReturnValue == bytes32(0) ? bytes32(UINT256_MAX) : bytes32(0);\\n vm.store(self._target, slot, testVal);\\n\\n (, bytes32 newReturnValue) = callTarget(self);\\n\\n vm.store(self._target, slot, prevSlotValue);\\n\\n return (success && (prevReturnValue != newReturnValue));\\n }\\n\\n // Tries setting one of the bits in slot to 1 until return value changes.\\n // Index of resulted bit is an offset packed slot has from left/right side\\n function findOffset(StdStorage storage self, bytes32 slot, bool left) internal returns (bool, uint256) {\\n for (uint256 offset = 0; offset < 256; offset++) {\\n uint256 valueToPut = left ? (1 << (255 - offset)) : (1 << offset);\\n vm.store(self._target, slot, bytes32(valueToPut));\\n\\n (bool success, bytes32 data) = callTarget(self);\\n\\n if (success && (uint256(data) > 0)) {\\n return (true, offset);\\n }\\n }\\n return (false, 0);\\n }\\n\\n function findOffsets(StdStorage storage self, bytes32 slot) internal returns (bool, uint256, uint256) {\\n bytes32 prevSlotValue = vm.load(self._target, slot);\\n\\n (bool foundLeft, uint256 offsetLeft) = findOffset(self, slot, true);\\n (bool foundRight, uint256 offsetRight) = findOffset(self, slot, false);\\n\\n // `findOffset` may mutate slot value, so we are setting it to initial value\\n vm.store(self._target, slot, prevSlotValue);\\n return (foundLeft && foundRight, offsetLeft, offsetRight);\\n }\\n\\n function find(StdStorage storage self) internal returns (FindData storage) {\\n return find(self, true);\\n }\\n\\n /// @notice find an arbitrary storage slot given a function sig, input data, address of the contract and a value to check against\\n // slot complexity:\\n // if flat, will be bytes32(uint256(uint));\\n // if map, will be keccak256(abi.encode(key, uint(slot)));\\n // if deep map, will be keccak256(abi.encode(key1, keccak256(abi.encode(key0, uint(slot)))));\\n // if map struct, will be bytes32(uint256(keccak256(abi.encode(key1, keccak256(abi.encode(key0, uint(slot)))))) + structFieldDepth);\\n function find(StdStorage storage self, bool _clear) internal returns (FindData storage) {\\n address who = self._target;\\n bytes4 fsig = self._sig;\\n uint256 field_depth = self._depth;\\n bytes memory params = getCallParams(self);\\n\\n // calldata to test against\\n if (self.finds[who][fsig][keccak256(abi.encodePacked(params, field_depth))].found) {\\n if (_clear) {\\n clear(self);\\n }\\n return self.finds[who][fsig][keccak256(abi.encodePacked(params, field_depth))];\\n }\\n vm.record();\\n (, bytes32 callResult) = callTarget(self);\\n (bytes32[] memory reads,) = vm.accesses(address(who));\\n\\n if (reads.length == 0) {\\n revert(\\\"stdStorage find(StdStorage): No storage use detected for target.\\\");\\n } else {\\n for (uint256 i = reads.length; --i >= 0;) {\\n bytes32 prev = vm.load(who, reads[i]);\\n if (prev == bytes32(0)) {\\n emit WARNING_UninitedSlot(who, uint256(reads[i]));\\n }\\n\\n if (!checkSlotMutatesCall(self, reads[i])) {\\n continue;\\n }\\n\\n (uint256 offsetLeft, uint256 offsetRight) = (0, 0);\\n\\n if (self._enable_packed_slots) {\\n bool found;\\n (found, offsetLeft, offsetRight) = findOffsets(self, reads[i]);\\n if (!found) {\\n continue;\\n }\\n }\\n\\n // Check that value between found offsets is equal to the current call result\\n uint256 curVal = (uint256(prev) & getMaskByOffsets(offsetLeft, offsetRight)) >> offsetRight;\\n\\n if (uint256(callResult) != curVal) {\\n continue;\\n }\\n\\n emit SlotFound(who, fsig, keccak256(abi.encodePacked(params, field_depth)), uint256(reads[i]));\\n self.finds[who][fsig][keccak256(abi.encodePacked(params, field_depth))] =\\n FindData(uint256(reads[i]), offsetLeft, offsetRight, true);\\n break;\\n }\\n }\\n\\n require(\\n self.finds[who][fsig][keccak256(abi.encodePacked(params, field_depth))].found,\\n \\\"stdStorage find(StdStorage): Slot(s) not found.\\\"\\n );\\n\\n if (_clear) {\\n clear(self);\\n }\\n return self.finds[who][fsig][keccak256(abi.encodePacked(params, field_depth))];\\n }\\n\\n function target(StdStorage storage self, address _target) internal returns (StdStorage storage) {\\n self._target = _target;\\n return self;\\n }\\n\\n function sig(StdStorage storage self, bytes4 _sig) internal returns (StdStorage storage) {\\n self._sig = _sig;\\n return self;\\n }\\n\\n function sig(StdStorage storage self, string memory _sig) internal returns (StdStorage storage) {\\n self._sig = sigs(_sig);\\n return self;\\n }\\n\\n function with_calldata(StdStorage storage self, bytes memory _calldata) internal returns (StdStorage storage) {\\n self._calldata = _calldata;\\n return self;\\n }\\n\\n function with_key(StdStorage storage self, address who) internal returns (StdStorage storage) {\\n self._keys.push(bytes32(uint256(uint160(who))));\\n return self;\\n }\\n\\n function with_key(StdStorage storage self, uint256 amt) internal returns (StdStorage storage) {\\n self._keys.push(bytes32(amt));\\n return self;\\n }\\n\\n function with_key(StdStorage storage self, bytes32 key) internal returns (StdStorage storage) {\\n self._keys.push(key);\\n return self;\\n }\\n\\n function enable_packed_slots(StdStorage storage self) internal returns (StdStorage storage) {\\n self._enable_packed_slots = true;\\n return self;\\n }\\n\\n function depth(StdStorage storage self, uint256 _depth) internal returns (StdStorage storage) {\\n self._depth = _depth;\\n return self;\\n }\\n\\n function read(StdStorage storage self) private returns (bytes memory) {\\n FindData storage data = find(self, false);\\n uint256 mask = getMaskByOffsets(data.offsetLeft, data.offsetRight);\\n uint256 value = (uint256(vm.load(self._target, bytes32(data.slot))) & mask) >> data.offsetRight;\\n clear(self);\\n return abi.encode(value);\\n }\\n\\n function read_bytes32(StdStorage storage self) internal returns (bytes32) {\\n return abi.decode(read(self), (bytes32));\\n }\\n\\n function read_bool(StdStorage storage self) internal returns (bool) {\\n int256 v = read_int(self);\\n if (v == 0) return false;\\n if (v == 1) return true;\\n revert(\\\"stdStorage read_bool(StdStorage): Cannot decode. Make sure you are reading a bool.\\\");\\n }\\n\\n function read_address(StdStorage storage self) internal returns (address) {\\n return abi.decode(read(self), (address));\\n }\\n\\n function read_uint(StdStorage storage self) internal returns (uint256) {\\n return abi.decode(read(self), (uint256));\\n }\\n\\n function read_int(StdStorage storage self) internal returns (int256) {\\n return abi.decode(read(self), (int256));\\n }\\n\\n function parent(StdStorage storage self) internal returns (uint256, bytes32) {\\n address who = self._target;\\n uint256 field_depth = self._depth;\\n vm.startMappingRecording();\\n uint256 child = find(self, true).slot - field_depth;\\n (bool found, bytes32 key, bytes32 parent_slot) = vm.getMappingKeyAndParentOf(who, bytes32(child));\\n if (!found) {\\n revert(\\n \\\"stdStorage read_bool(StdStorage): Cannot find parent. Make sure you give a slot and startMappingRecording() has been called.\\\"\\n );\\n }\\n return (uint256(parent_slot), key);\\n }\\n\\n function root(StdStorage storage self) internal returns (uint256) {\\n address who = self._target;\\n uint256 field_depth = self._depth;\\n vm.startMappingRecording();\\n uint256 child = find(self, true).slot - field_depth;\\n bool found;\\n bytes32 root_slot;\\n bytes32 parent_slot;\\n (found,, parent_slot) = vm.getMappingKeyAndParentOf(who, bytes32(child));\\n if (!found) {\\n revert(\\n \\\"stdStorage read_bool(StdStorage): Cannot find parent. Make sure you give a slot and startMappingRecording() has been called.\\\"\\n );\\n }\\n while (found) {\\n root_slot = parent_slot;\\n (found,, parent_slot) = vm.getMappingKeyAndParentOf(who, bytes32(root_slot));\\n }\\n return uint256(root_slot);\\n }\\n\\n function bytesToBytes32(bytes memory b, uint256 offset) private pure returns (bytes32) {\\n bytes32 out;\\n\\n uint256 max = b.length > 32 ? 32 : b.length;\\n for (uint256 i = 0; i < max; i++) {\\n out |= bytes32(b[offset + i] & 0xFF) >> (i * 8);\\n }\\n return out;\\n }\\n\\n function flatten(bytes32[] memory b) private pure returns (bytes memory) {\\n bytes memory result = new bytes(b.length * 32);\\n for (uint256 i = 0; i < b.length; i++) {\\n bytes32 k = b[i];\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(add(result, add(32, mul(32, i))), k)\\n }\\n }\\n\\n return result;\\n }\\n\\n function clear(StdStorage storage self) internal {\\n delete self._target;\\n delete self._sig;\\n delete self._keys;\\n delete self._depth;\\n delete self._enable_packed_slots;\\n delete self._calldata;\\n }\\n\\n // Returns mask which contains non-zero bits for values between `offsetLeft` and `offsetRight`\\n // (slotValue & mask) >> offsetRight will be the value of the given packed variable\\n function getMaskByOffsets(uint256 offsetLeft, uint256 offsetRight) internal pure returns (uint256 mask) {\\n // mask = ((1 << (256 - (offsetRight + offsetLeft))) - 1) << offsetRight;\\n // using assembly because (1 << 256) causes overflow\\n assembly {\\n mask := shl(offsetRight, sub(shl(sub(256, add(offsetRight, offsetLeft)), 1), 1))\\n }\\n }\\n\\n // Returns slot value with updated packed variable.\\n function getUpdatedSlotValue(bytes32 curValue, uint256 varValue, uint256 offsetLeft, uint256 offsetRight)\\n internal\\n pure\\n returns (bytes32 newValue)\\n {\\n return bytes32((uint256(curValue) & ~getMaskByOffsets(offsetLeft, offsetRight)) | (varValue << offsetRight));\\n }\\n}\\n\\nlibrary stdStorage {\\n Vm private constant vm = Vm(address(uint160(uint256(keccak256(\\\"hevm cheat code\\\")))));\\n\\n function sigs(string memory sigStr) internal pure returns (bytes4) {\\n return stdStorageSafe.sigs(sigStr);\\n }\\n\\n function find(StdStorage storage self) internal returns (uint256) {\\n return find(self, true);\\n }\\n\\n function find(StdStorage storage self, bool _clear) internal returns (uint256) {\\n return stdStorageSafe.find(self, _clear).slot;\\n }\\n\\n function target(StdStorage storage self, address _target) internal returns (StdStorage storage) {\\n return stdStorageSafe.target(self, _target);\\n }\\n\\n function sig(StdStorage storage self, bytes4 _sig) internal returns (StdStorage storage) {\\n return stdStorageSafe.sig(self, _sig);\\n }\\n\\n function sig(StdStorage storage self, string memory _sig) internal returns (StdStorage storage) {\\n return stdStorageSafe.sig(self, _sig);\\n }\\n\\n function with_key(StdStorage storage self, address who) internal returns (StdStorage storage) {\\n return stdStorageSafe.with_key(self, who);\\n }\\n\\n function with_key(StdStorage storage self, uint256 amt) internal returns (StdStorage storage) {\\n return stdStorageSafe.with_key(self, amt);\\n }\\n\\n function with_key(StdStorage storage self, bytes32 key) internal returns (StdStorage storage) {\\n return stdStorageSafe.with_key(self, key);\\n }\\n\\n function with_calldata(StdStorage storage self, bytes memory _calldata) internal returns (StdStorage storage) {\\n return stdStorageSafe.with_calldata(self, _calldata);\\n }\\n\\n function enable_packed_slots(StdStorage storage self) internal returns (StdStorage storage) {\\n return stdStorageSafe.enable_packed_slots(self);\\n }\\n\\n function depth(StdStorage storage self, uint256 _depth) internal returns (StdStorage storage) {\\n return stdStorageSafe.depth(self, _depth);\\n }\\n\\n function clear(StdStorage storage self) internal {\\n stdStorageSafe.clear(self);\\n }\\n\\n function checked_write(StdStorage storage self, address who) internal {\\n checked_write(self, bytes32(uint256(uint160(who))));\\n }\\n\\n function checked_write(StdStorage storage self, uint256 amt) internal {\\n checked_write(self, bytes32(amt));\\n }\\n\\n function checked_write_int(StdStorage storage self, int256 val) internal {\\n checked_write(self, bytes32(uint256(val)));\\n }\\n\\n function checked_write(StdStorage storage self, bool write) internal {\\n bytes32 t;\\n /// @solidity memory-safe-assembly\\n assembly {\\n t := write\\n }\\n checked_write(self, t);\\n }\\n\\n function checked_write(StdStorage storage self, bytes32 set) internal {\\n address who = self._target;\\n bytes4 fsig = self._sig;\\n uint256 field_depth = self._depth;\\n bytes memory params = stdStorageSafe.getCallParams(self);\\n\\n if (!self.finds[who][fsig][keccak256(abi.encodePacked(params, field_depth))].found) {\\n find(self, false);\\n }\\n FindData storage data = self.finds[who][fsig][keccak256(abi.encodePacked(params, field_depth))];\\n if ((data.offsetLeft + data.offsetRight) > 0) {\\n uint256 maxVal = 2 ** (256 - (data.offsetLeft + data.offsetRight));\\n require(\\n uint256(set) < maxVal,\\n string(\\n abi.encodePacked(\\n \\\"stdStorage find(StdStorage): Packed slot. We can't fit value greater than \\\",\\n vm.toString(maxVal)\\n )\\n )\\n );\\n }\\n bytes32 curVal = vm.load(who, bytes32(data.slot));\\n bytes32 valToSet = stdStorageSafe.getUpdatedSlotValue(curVal, uint256(set), data.offsetLeft, data.offsetRight);\\n\\n vm.store(who, bytes32(data.slot), valToSet);\\n\\n (bool success, bytes32 callResult) = stdStorageSafe.callTarget(self);\\n\\n if (!success || callResult != set) {\\n vm.store(who, bytes32(data.slot), curVal);\\n revert(\\\"stdStorage find(StdStorage): Failed to write value.\\\");\\n }\\n clear(self);\\n }\\n\\n function read_bytes32(StdStorage storage self) internal returns (bytes32) {\\n return stdStorageSafe.read_bytes32(self);\\n }\\n\\n function read_bool(StdStorage storage self) internal returns (bool) {\\n return stdStorageSafe.read_bool(self);\\n }\\n\\n function read_address(StdStorage storage self) internal returns (address) {\\n return stdStorageSafe.read_address(self);\\n }\\n\\n function read_uint(StdStorage storage self) internal returns (uint256) {\\n return stdStorageSafe.read_uint(self);\\n }\\n\\n function read_int(StdStorage storage self) internal returns (int256) {\\n return stdStorageSafe.read_int(self);\\n }\\n\\n function parent(StdStorage storage self) internal returns (uint256, bytes32) {\\n return stdStorageSafe.parent(self);\\n }\\n\\n function root(StdStorage storage self) internal returns (uint256) {\\n return stdStorageSafe.root(self);\\n }\\n}\\n\",\"keccak256\":\"0xb91ab24383a5872b894fc93325eef1add6cbbf981628f18e860068bf88bb7dcc\",\"license\":\"MIT\"},\"lib/forge-std/src/StdStyle.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity >=0.4.22 <0.9.0;\\n\\nimport {VmSafe} from \\\"./Vm.sol\\\";\\n\\nlibrary StdStyle {\\n VmSafe private constant vm = VmSafe(address(uint160(uint256(keccak256(\\\"hevm cheat code\\\")))));\\n\\n string constant RED = \\\"\\\\u001b[91m\\\";\\n string constant GREEN = \\\"\\\\u001b[92m\\\";\\n string constant YELLOW = \\\"\\\\u001b[93m\\\";\\n string constant BLUE = \\\"\\\\u001b[94m\\\";\\n string constant MAGENTA = \\\"\\\\u001b[95m\\\";\\n string constant CYAN = \\\"\\\\u001b[96m\\\";\\n string constant BOLD = \\\"\\\\u001b[1m\\\";\\n string constant DIM = \\\"\\\\u001b[2m\\\";\\n string constant ITALIC = \\\"\\\\u001b[3m\\\";\\n string constant UNDERLINE = \\\"\\\\u001b[4m\\\";\\n string constant INVERSE = \\\"\\\\u001b[7m\\\";\\n string constant RESET = \\\"\\\\u001b[0m\\\";\\n\\n function styleConcat(string memory style, string memory self) private pure returns (string memory) {\\n return string(abi.encodePacked(style, self, RESET));\\n }\\n\\n function red(string memory self) internal pure returns (string memory) {\\n return styleConcat(RED, self);\\n }\\n\\n function red(uint256 self) internal pure returns (string memory) {\\n return red(vm.toString(self));\\n }\\n\\n function red(int256 self) internal pure returns (string memory) {\\n return red(vm.toString(self));\\n }\\n\\n function red(address self) internal pure returns (string memory) {\\n return red(vm.toString(self));\\n }\\n\\n function red(bool self) internal pure returns (string memory) {\\n return red(vm.toString(self));\\n }\\n\\n function redBytes(bytes memory self) internal pure returns (string memory) {\\n return red(vm.toString(self));\\n }\\n\\n function redBytes32(bytes32 self) internal pure returns (string memory) {\\n return red(vm.toString(self));\\n }\\n\\n function green(string memory self) internal pure returns (string memory) {\\n return styleConcat(GREEN, self);\\n }\\n\\n function green(uint256 self) internal pure returns (string memory) {\\n return green(vm.toString(self));\\n }\\n\\n function green(int256 self) internal pure returns (string memory) {\\n return green(vm.toString(self));\\n }\\n\\n function green(address self) internal pure returns (string memory) {\\n return green(vm.toString(self));\\n }\\n\\n function green(bool self) internal pure returns (string memory) {\\n return green(vm.toString(self));\\n }\\n\\n function greenBytes(bytes memory self) internal pure returns (string memory) {\\n return green(vm.toString(self));\\n }\\n\\n function greenBytes32(bytes32 self) internal pure returns (string memory) {\\n return green(vm.toString(self));\\n }\\n\\n function yellow(string memory self) internal pure returns (string memory) {\\n return styleConcat(YELLOW, self);\\n }\\n\\n function yellow(uint256 self) internal pure returns (string memory) {\\n return yellow(vm.toString(self));\\n }\\n\\n function yellow(int256 self) internal pure returns (string memory) {\\n return yellow(vm.toString(self));\\n }\\n\\n function yellow(address self) internal pure returns (string memory) {\\n return yellow(vm.toString(self));\\n }\\n\\n function yellow(bool self) internal pure returns (string memory) {\\n return yellow(vm.toString(self));\\n }\\n\\n function yellowBytes(bytes memory self) internal pure returns (string memory) {\\n return yellow(vm.toString(self));\\n }\\n\\n function yellowBytes32(bytes32 self) internal pure returns (string memory) {\\n return yellow(vm.toString(self));\\n }\\n\\n function blue(string memory self) internal pure returns (string memory) {\\n return styleConcat(BLUE, self);\\n }\\n\\n function blue(uint256 self) internal pure returns (string memory) {\\n return blue(vm.toString(self));\\n }\\n\\n function blue(int256 self) internal pure returns (string memory) {\\n return blue(vm.toString(self));\\n }\\n\\n function blue(address self) internal pure returns (string memory) {\\n return blue(vm.toString(self));\\n }\\n\\n function blue(bool self) internal pure returns (string memory) {\\n return blue(vm.toString(self));\\n }\\n\\n function blueBytes(bytes memory self) internal pure returns (string memory) {\\n return blue(vm.toString(self));\\n }\\n\\n function blueBytes32(bytes32 self) internal pure returns (string memory) {\\n return blue(vm.toString(self));\\n }\\n\\n function magenta(string memory self) internal pure returns (string memory) {\\n return styleConcat(MAGENTA, self);\\n }\\n\\n function magenta(uint256 self) internal pure returns (string memory) {\\n return magenta(vm.toString(self));\\n }\\n\\n function magenta(int256 self) internal pure returns (string memory) {\\n return magenta(vm.toString(self));\\n }\\n\\n function magenta(address self) internal pure returns (string memory) {\\n return magenta(vm.toString(self));\\n }\\n\\n function magenta(bool self) internal pure returns (string memory) {\\n return magenta(vm.toString(self));\\n }\\n\\n function magentaBytes(bytes memory self) internal pure returns (string memory) {\\n return magenta(vm.toString(self));\\n }\\n\\n function magentaBytes32(bytes32 self) internal pure returns (string memory) {\\n return magenta(vm.toString(self));\\n }\\n\\n function cyan(string memory self) internal pure returns (string memory) {\\n return styleConcat(CYAN, self);\\n }\\n\\n function cyan(uint256 self) internal pure returns (string memory) {\\n return cyan(vm.toString(self));\\n }\\n\\n function cyan(int256 self) internal pure returns (string memory) {\\n return cyan(vm.toString(self));\\n }\\n\\n function cyan(address self) internal pure returns (string memory) {\\n return cyan(vm.toString(self));\\n }\\n\\n function cyan(bool self) internal pure returns (string memory) {\\n return cyan(vm.toString(self));\\n }\\n\\n function cyanBytes(bytes memory self) internal pure returns (string memory) {\\n return cyan(vm.toString(self));\\n }\\n\\n function cyanBytes32(bytes32 self) internal pure returns (string memory) {\\n return cyan(vm.toString(self));\\n }\\n\\n function bold(string memory self) internal pure returns (string memory) {\\n return styleConcat(BOLD, self);\\n }\\n\\n function bold(uint256 self) internal pure returns (string memory) {\\n return bold(vm.toString(self));\\n }\\n\\n function bold(int256 self) internal pure returns (string memory) {\\n return bold(vm.toString(self));\\n }\\n\\n function bold(address self) internal pure returns (string memory) {\\n return bold(vm.toString(self));\\n }\\n\\n function bold(bool self) internal pure returns (string memory) {\\n return bold(vm.toString(self));\\n }\\n\\n function boldBytes(bytes memory self) internal pure returns (string memory) {\\n return bold(vm.toString(self));\\n }\\n\\n function boldBytes32(bytes32 self) internal pure returns (string memory) {\\n return bold(vm.toString(self));\\n }\\n\\n function dim(string memory self) internal pure returns (string memory) {\\n return styleConcat(DIM, self);\\n }\\n\\n function dim(uint256 self) internal pure returns (string memory) {\\n return dim(vm.toString(self));\\n }\\n\\n function dim(int256 self) internal pure returns (string memory) {\\n return dim(vm.toString(self));\\n }\\n\\n function dim(address self) internal pure returns (string memory) {\\n return dim(vm.toString(self));\\n }\\n\\n function dim(bool self) internal pure returns (string memory) {\\n return dim(vm.toString(self));\\n }\\n\\n function dimBytes(bytes memory self) internal pure returns (string memory) {\\n return dim(vm.toString(self));\\n }\\n\\n function dimBytes32(bytes32 self) internal pure returns (string memory) {\\n return dim(vm.toString(self));\\n }\\n\\n function italic(string memory self) internal pure returns (string memory) {\\n return styleConcat(ITALIC, self);\\n }\\n\\n function italic(uint256 self) internal pure returns (string memory) {\\n return italic(vm.toString(self));\\n }\\n\\n function italic(int256 self) internal pure returns (string memory) {\\n return italic(vm.toString(self));\\n }\\n\\n function italic(address self) internal pure returns (string memory) {\\n return italic(vm.toString(self));\\n }\\n\\n function italic(bool self) internal pure returns (string memory) {\\n return italic(vm.toString(self));\\n }\\n\\n function italicBytes(bytes memory self) internal pure returns (string memory) {\\n return italic(vm.toString(self));\\n }\\n\\n function italicBytes32(bytes32 self) internal pure returns (string memory) {\\n return italic(vm.toString(self));\\n }\\n\\n function underline(string memory self) internal pure returns (string memory) {\\n return styleConcat(UNDERLINE, self);\\n }\\n\\n function underline(uint256 self) internal pure returns (string memory) {\\n return underline(vm.toString(self));\\n }\\n\\n function underline(int256 self) internal pure returns (string memory) {\\n return underline(vm.toString(self));\\n }\\n\\n function underline(address self) internal pure returns (string memory) {\\n return underline(vm.toString(self));\\n }\\n\\n function underline(bool self) internal pure returns (string memory) {\\n return underline(vm.toString(self));\\n }\\n\\n function underlineBytes(bytes memory self) internal pure returns (string memory) {\\n return underline(vm.toString(self));\\n }\\n\\n function underlineBytes32(bytes32 self) internal pure returns (string memory) {\\n return underline(vm.toString(self));\\n }\\n\\n function inverse(string memory self) internal pure returns (string memory) {\\n return styleConcat(INVERSE, self);\\n }\\n\\n function inverse(uint256 self) internal pure returns (string memory) {\\n return inverse(vm.toString(self));\\n }\\n\\n function inverse(int256 self) internal pure returns (string memory) {\\n return inverse(vm.toString(self));\\n }\\n\\n function inverse(address self) internal pure returns (string memory) {\\n return inverse(vm.toString(self));\\n }\\n\\n function inverse(bool self) internal pure returns (string memory) {\\n return inverse(vm.toString(self));\\n }\\n\\n function inverseBytes(bytes memory self) internal pure returns (string memory) {\\n return inverse(vm.toString(self));\\n }\\n\\n function inverseBytes32(bytes32 self) internal pure returns (string memory) {\\n return inverse(vm.toString(self));\\n }\\n}\\n\",\"keccak256\":\"0x43e2a8a9b9c2574dabe74f11adf6f782df218f463540e3b5b563609fe108597d\",\"license\":\"MIT\"},\"lib/forge-std/src/StdUtils.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity >=0.6.2 <0.9.0;\\n\\npragma experimental ABIEncoderV2;\\n\\nimport {IMulticall3} from \\\"./interfaces/IMulticall3.sol\\\";\\nimport {VmSafe} from \\\"./Vm.sol\\\";\\n\\nabstract contract StdUtils {\\n /*//////////////////////////////////////////////////////////////////////////\\n CONSTANTS\\n //////////////////////////////////////////////////////////////////////////*/\\n\\n IMulticall3 private constant multicall = IMulticall3(0xcA11bde05977b3631167028862bE2a173976CA11);\\n VmSafe private constant vm = VmSafe(address(uint160(uint256(keccak256(\\\"hevm cheat code\\\")))));\\n address private constant CONSOLE2_ADDRESS = 0x000000000000000000636F6e736F6c652e6c6f67;\\n uint256 private constant INT256_MIN_ABS =\\n 57896044618658097711785492504343953926634992332820282019728792003956564819968;\\n uint256 private constant SECP256K1_ORDER =\\n 115792089237316195423570985008687907852837564279074904382605163141518161494337;\\n uint256 private constant UINT256_MAX =\\n 115792089237316195423570985008687907853269984665640564039457584007913129639935;\\n\\n // Used by default when deploying with create2, https://github.com/Arachnid/deterministic-deployment-proxy.\\n address private constant CREATE2_FACTORY = 0x4e59b44847b379578588920cA78FbF26c0B4956C;\\n\\n /*//////////////////////////////////////////////////////////////////////////\\n INTERNAL FUNCTIONS\\n //////////////////////////////////////////////////////////////////////////*/\\n\\n function _bound(uint256 x, uint256 min, uint256 max) internal pure virtual returns (uint256 result) {\\n require(min <= max, \\\"StdUtils bound(uint256,uint256,uint256): Max is less than min.\\\");\\n // If x is between min and max, return x directly. This is to ensure that dictionary values\\n // do not get shifted if the min is nonzero. More info: https://github.com/foundry-rs/forge-std/issues/188\\n if (x >= min && x <= max) return x;\\n\\n uint256 size = max - min + 1;\\n\\n // If the value is 0, 1, 2, 3, wrap that to min, min+1, min+2, min+3. Similarly for the UINT256_MAX side.\\n // This helps ensure coverage of the min/max values.\\n if (x <= 3 && size > x) return min + x;\\n if (x >= UINT256_MAX - 3 && size > UINT256_MAX - x) return max - (UINT256_MAX - x);\\n\\n // Otherwise, wrap x into the range [min, max], i.e. the range is inclusive.\\n if (x > max) {\\n uint256 diff = x - max;\\n uint256 rem = diff % size;\\n if (rem == 0) return max;\\n result = min + rem - 1;\\n } else if (x < min) {\\n uint256 diff = min - x;\\n uint256 rem = diff % size;\\n if (rem == 0) return min;\\n result = max - rem + 1;\\n }\\n }\\n\\n function bound(uint256 x, uint256 min, uint256 max) internal pure virtual returns (uint256 result) {\\n result = _bound(x, min, max);\\n console2_log_StdUtils(\\\"Bound result\\\", result);\\n }\\n\\n function _bound(int256 x, int256 min, int256 max) internal pure virtual returns (int256 result) {\\n require(min <= max, \\\"StdUtils bound(int256,int256,int256): Max is less than min.\\\");\\n\\n // Shifting all int256 values to uint256 to use _bound function. The range of two types are:\\n // int256 : -(2**255) ~ (2**255 - 1)\\n // uint256: 0 ~ (2**256 - 1)\\n // So, add 2**255, INT256_MIN_ABS to the integer values.\\n //\\n // If the given integer value is -2**255, we cannot use `-uint256(-x)` because of the overflow.\\n // So, use `~uint256(x) + 1` instead.\\n uint256 _x = x < 0 ? (INT256_MIN_ABS - ~uint256(x) - 1) : (uint256(x) + INT256_MIN_ABS);\\n uint256 _min = min < 0 ? (INT256_MIN_ABS - ~uint256(min) - 1) : (uint256(min) + INT256_MIN_ABS);\\n uint256 _max = max < 0 ? (INT256_MIN_ABS - ~uint256(max) - 1) : (uint256(max) + INT256_MIN_ABS);\\n\\n uint256 y = _bound(_x, _min, _max);\\n\\n // To move it back to int256 value, subtract INT256_MIN_ABS at here.\\n result = y < INT256_MIN_ABS ? int256(~(INT256_MIN_ABS - y) + 1) : int256(y - INT256_MIN_ABS);\\n }\\n\\n function bound(int256 x, int256 min, int256 max) internal pure virtual returns (int256 result) {\\n result = _bound(x, min, max);\\n console2_log_StdUtils(\\\"Bound result\\\", vm.toString(result));\\n }\\n\\n function boundPrivateKey(uint256 privateKey) internal pure virtual returns (uint256 result) {\\n result = _bound(privateKey, 1, SECP256K1_ORDER - 1);\\n }\\n\\n function bytesToUint(bytes memory b) internal pure virtual returns (uint256) {\\n require(b.length <= 32, \\\"StdUtils bytesToUint(bytes): Bytes length exceeds 32.\\\");\\n return abi.decode(abi.encodePacked(new bytes(32 - b.length), b), (uint256));\\n }\\n\\n /// @dev Compute the address a contract will be deployed at for a given deployer address and nonce\\n /// @notice adapted from Solmate implementation (https://github.com/Rari-Capital/solmate/blob/main/src/utils/LibRLP.sol)\\n function computeCreateAddress(address deployer, uint256 nonce) internal pure virtual returns (address) {\\n console2_log_StdUtils(\\\"computeCreateAddress is deprecated. Please use vm.computeCreateAddress instead.\\\");\\n return vm.computeCreateAddress(deployer, nonce);\\n }\\n\\n function computeCreate2Address(bytes32 salt, bytes32 initcodeHash, address deployer)\\n internal\\n pure\\n virtual\\n returns (address)\\n {\\n console2_log_StdUtils(\\\"computeCreate2Address is deprecated. Please use vm.computeCreate2Address instead.\\\");\\n return vm.computeCreate2Address(salt, initcodeHash, deployer);\\n }\\n\\n /// @dev returns the address of a contract created with CREATE2 using the default CREATE2 deployer\\n function computeCreate2Address(bytes32 salt, bytes32 initCodeHash) internal pure returns (address) {\\n console2_log_StdUtils(\\\"computeCreate2Address is deprecated. Please use vm.computeCreate2Address instead.\\\");\\n return vm.computeCreate2Address(salt, initCodeHash);\\n }\\n\\n /// @dev returns the hash of the init code (creation code + no args) used in CREATE2 with no constructor arguments\\n /// @param creationCode the creation code of a contract C, as returned by type(C).creationCode\\n function hashInitCode(bytes memory creationCode) internal pure returns (bytes32) {\\n return hashInitCode(creationCode, \\\"\\\");\\n }\\n\\n /// @dev returns the hash of the init code (creation code + ABI-encoded args) used in CREATE2\\n /// @param creationCode the creation code of a contract C, as returned by type(C).creationCode\\n /// @param args the ABI-encoded arguments to the constructor of C\\n function hashInitCode(bytes memory creationCode, bytes memory args) internal pure returns (bytes32) {\\n return keccak256(abi.encodePacked(creationCode, args));\\n }\\n\\n // Performs a single call with Multicall3 to query the ERC-20 token balances of the given addresses.\\n function getTokenBalances(address token, address[] memory addresses)\\n internal\\n virtual\\n returns (uint256[] memory balances)\\n {\\n uint256 tokenCodeSize;\\n assembly {\\n tokenCodeSize := extcodesize(token)\\n }\\n require(tokenCodeSize > 0, \\\"StdUtils getTokenBalances(address,address[]): Token address is not a contract.\\\");\\n\\n // ABI encode the aggregate call to Multicall3.\\n uint256 length = addresses.length;\\n IMulticall3.Call[] memory calls = new IMulticall3.Call[](length);\\n for (uint256 i = 0; i < length; ++i) {\\n // 0x70a08231 = bytes4(\\\"balanceOf(address)\\\"))\\n calls[i] = IMulticall3.Call({target: token, callData: abi.encodeWithSelector(0x70a08231, (addresses[i]))});\\n }\\n\\n // Make the aggregate call.\\n (, bytes[] memory returnData) = multicall.aggregate(calls);\\n\\n // ABI decode the return data and return the balances.\\n balances = new uint256[](length);\\n for (uint256 i = 0; i < length; ++i) {\\n balances[i] = abi.decode(returnData[i], (uint256));\\n }\\n }\\n\\n /*//////////////////////////////////////////////////////////////////////////\\n PRIVATE FUNCTIONS\\n //////////////////////////////////////////////////////////////////////////*/\\n\\n function addressFromLast20Bytes(bytes32 bytesValue) private pure returns (address) {\\n return address(uint160(uint256(bytesValue)));\\n }\\n\\n // This section is used to prevent the compilation of console, which shortens the compilation time when console is\\n // not used elsewhere. We also trick the compiler into letting us make the console log methods as `pure` to avoid\\n // any breaking changes to function signatures.\\n function _castLogPayloadViewToPure(function(bytes memory) internal view fnIn)\\n internal\\n pure\\n returns (function(bytes memory) internal pure fnOut)\\n {\\n assembly {\\n fnOut := fnIn\\n }\\n }\\n\\n function _sendLogPayload(bytes memory payload) internal pure {\\n _castLogPayloadViewToPure(_sendLogPayloadView)(payload);\\n }\\n\\n function _sendLogPayloadView(bytes memory payload) private view {\\n uint256 payloadLength = payload.length;\\n address consoleAddress = CONSOLE2_ADDRESS;\\n /// @solidity memory-safe-assembly\\n assembly {\\n let payloadStart := add(payload, 32)\\n let r := staticcall(gas(), consoleAddress, payloadStart, payloadLength, 0, 0)\\n }\\n }\\n\\n function console2_log_StdUtils(string memory p0) private pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string)\\\", p0));\\n }\\n\\n function console2_log_StdUtils(string memory p0, uint256 p1) private pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,uint256)\\\", p0, p1));\\n }\\n\\n function console2_log_StdUtils(string memory p0, string memory p1) private pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,string)\\\", p0, p1));\\n }\\n}\\n\",\"keccak256\":\"0x7274081e11c05164fd8eadde4de8305c033e58a43008dea58065f3170ccf0737\",\"license\":\"MIT\"},\"lib/forge-std/src/Vm.sol\":{\"content\":\"// Automatically @generated by scripts/vm.py. Do not modify manually.\\n\\n// SPDX-License-Identifier: MIT OR Apache-2.0\\npragma solidity >=0.6.2 <0.9.0;\\npragma experimental ABIEncoderV2;\\n\\n/// The `VmSafe` interface does not allow manipulation of the EVM state or other actions that may\\n/// result in Script simulations differing from on-chain execution. It is recommended to only use\\n/// these cheats in scripts.\\ninterface VmSafe {\\n /// A modification applied to either `msg.sender` or `tx.origin`. Returned by `readCallers`.\\n enum CallerMode {\\n // No caller modification is currently active.\\n None,\\n // A one time broadcast triggered by a `vm.broadcast()` call is currently active.\\n Broadcast,\\n // A recurrent broadcast triggered by a `vm.startBroadcast()` call is currently active.\\n RecurrentBroadcast,\\n // A one time prank triggered by a `vm.prank()` call is currently active.\\n Prank,\\n // A recurrent prank triggered by a `vm.startPrank()` call is currently active.\\n RecurrentPrank\\n }\\n\\n /// The kind of account access that occurred.\\n enum AccountAccessKind {\\n // The account was called.\\n Call,\\n // The account was called via delegatecall.\\n DelegateCall,\\n // The account was called via callcode.\\n CallCode,\\n // The account was called via staticcall.\\n StaticCall,\\n // The account was created.\\n Create,\\n // The account was selfdestructed.\\n SelfDestruct,\\n // Synthetic access indicating the current context has resumed after a previous sub-context (AccountAccess).\\n Resume,\\n // The account's balance was read.\\n Balance,\\n // The account's codesize was read.\\n Extcodesize,\\n // The account's codehash was read.\\n Extcodehash,\\n // The account's code was copied.\\n Extcodecopy\\n }\\n\\n /// Forge execution contexts.\\n enum ForgeContext {\\n // Test group execution context (test, coverage or snapshot).\\n TestGroup,\\n // `forge test` execution context.\\n Test,\\n // `forge coverage` execution context.\\n Coverage,\\n // `forge snapshot` execution context.\\n Snapshot,\\n // Script group execution context (dry run, broadcast or resume).\\n ScriptGroup,\\n // `forge script` execution context.\\n ScriptDryRun,\\n // `forge script --broadcast` execution context.\\n ScriptBroadcast,\\n // `forge script --resume` execution context.\\n ScriptResume,\\n // Unknown `forge` execution context.\\n Unknown\\n }\\n\\n /// The transaction type (`txType`) of the broadcast.\\n enum BroadcastTxType {\\n // Represents a CALL broadcast tx.\\n Call,\\n // Represents a CREATE broadcast tx.\\n Create,\\n // Represents a CREATE2 broadcast tx.\\n Create2\\n }\\n\\n /// An Ethereum log. Returned by `getRecordedLogs`.\\n struct Log {\\n // The topics of the log, including the signature, if any.\\n bytes32[] topics;\\n // The raw data of the log.\\n bytes data;\\n // The address of the log's emitter.\\n address emitter;\\n }\\n\\n /// An RPC URL and its alias. Returned by `rpcUrlStructs`.\\n struct Rpc {\\n // The alias of the RPC URL.\\n string key;\\n // The RPC URL.\\n string url;\\n }\\n\\n /// An RPC log object. Returned by `eth_getLogs`.\\n struct EthGetLogs {\\n // The address of the log's emitter.\\n address emitter;\\n // The topics of the log, including the signature, if any.\\n bytes32[] topics;\\n // The raw data of the log.\\n bytes data;\\n // The block hash.\\n bytes32 blockHash;\\n // The block number.\\n uint64 blockNumber;\\n // The transaction hash.\\n bytes32 transactionHash;\\n // The transaction index in the block.\\n uint64 transactionIndex;\\n // The log index.\\n uint256 logIndex;\\n // Whether the log was removed.\\n bool removed;\\n }\\n\\n /// A single entry in a directory listing. Returned by `readDir`.\\n struct DirEntry {\\n // The error message, if any.\\n string errorMessage;\\n // The path of the entry.\\n string path;\\n // The depth of the entry.\\n uint64 depth;\\n // Whether the entry is a directory.\\n bool isDir;\\n // Whether the entry is a symlink.\\n bool isSymlink;\\n }\\n\\n /// Metadata information about a file.\\n /// This structure is returned from the `fsMetadata` function and represents known\\n /// metadata about a file such as its permissions, size, modification\\n /// times, etc.\\n struct FsMetadata {\\n // True if this metadata is for a directory.\\n bool isDir;\\n // True if this metadata is for a symlink.\\n bool isSymlink;\\n // The size of the file, in bytes, this metadata is for.\\n uint256 length;\\n // True if this metadata is for a readonly (unwritable) file.\\n bool readOnly;\\n // The last modification time listed in this metadata.\\n uint256 modified;\\n // The last access time of this metadata.\\n uint256 accessed;\\n // The creation time listed in this metadata.\\n uint256 created;\\n }\\n\\n /// A wallet with a public and private key.\\n struct Wallet {\\n // The wallet's address.\\n address addr;\\n // The wallet's public key `X`.\\n uint256 publicKeyX;\\n // The wallet's public key `Y`.\\n uint256 publicKeyY;\\n // The wallet's private key.\\n uint256 privateKey;\\n }\\n\\n /// The result of a `tryFfi` call.\\n struct FfiResult {\\n // The exit code of the call.\\n int32 exitCode;\\n // The optionally hex-decoded `stdout` data.\\n bytes stdout;\\n // The `stderr` data.\\n bytes stderr;\\n }\\n\\n /// Information on the chain and fork.\\n struct ChainInfo {\\n // The fork identifier. Set to zero if no fork is active.\\n uint256 forkId;\\n // The chain ID of the current fork.\\n uint256 chainId;\\n }\\n\\n /// The result of a `stopAndReturnStateDiff` call.\\n struct AccountAccess {\\n // The chain and fork the access occurred.\\n ChainInfo chainInfo;\\n // The kind of account access that determines what the account is.\\n // If kind is Call, DelegateCall, StaticCall or CallCode, then the account is the callee.\\n // If kind is Create, then the account is the newly created account.\\n // If kind is SelfDestruct, then the account is the selfdestruct recipient.\\n // If kind is a Resume, then account represents a account context that has resumed.\\n AccountAccessKind kind;\\n // The account that was accessed.\\n // It's either the account created, callee or a selfdestruct recipient for CREATE, CALL or SELFDESTRUCT.\\n address account;\\n // What accessed the account.\\n address accessor;\\n // If the account was initialized or empty prior to the access.\\n // An account is considered initialized if it has code, a\\n // non-zero nonce, or a non-zero balance.\\n bool initialized;\\n // The previous balance of the accessed account.\\n uint256 oldBalance;\\n // The potential new balance of the accessed account.\\n // That is, all balance changes are recorded here, even if reverts occurred.\\n uint256 newBalance;\\n // Code of the account deployed by CREATE.\\n bytes deployedCode;\\n // Value passed along with the account access\\n uint256 value;\\n // Input data provided to the CREATE or CALL\\n bytes data;\\n // If this access reverted in either the current or parent context.\\n bool reverted;\\n // An ordered list of storage accesses made during an account access operation.\\n StorageAccess[] storageAccesses;\\n // Call depth traversed during the recording of state differences\\n uint64 depth;\\n }\\n\\n /// The storage accessed during an `AccountAccess`.\\n struct StorageAccess {\\n // The account whose storage was accessed.\\n address account;\\n // The slot that was accessed.\\n bytes32 slot;\\n // If the access was a write.\\n bool isWrite;\\n // The previous value of the slot.\\n bytes32 previousValue;\\n // The new value of the slot.\\n bytes32 newValue;\\n // If the access was reverted.\\n bool reverted;\\n }\\n\\n /// Gas used. Returned by `lastCallGas`.\\n struct Gas {\\n // The gas limit of the call.\\n uint64 gasLimit;\\n // The total gas used.\\n uint64 gasTotalUsed;\\n // DEPRECATED: The amount of gas used for memory expansion. Ref: \\n uint64 gasMemoryUsed;\\n // The amount of gas refunded.\\n int64 gasRefunded;\\n // The amount of gas remaining.\\n uint64 gasRemaining;\\n }\\n\\n /// The result of the `stopDebugTraceRecording` call\\n struct DebugStep {\\n // The stack before executing the step of the run.\\n // stack\\\\[0\\\\] represents the top of the stack.\\n // and only stack data relevant to the opcode execution is contained.\\n uint256[] stack;\\n // The memory input data before executing the step of the run.\\n // only input data relevant to the opcode execution is contained.\\n // e.g. for MLOAD, it will have memory\\\\[offset:offset+32\\\\] copied here.\\n // the offset value can be get by the stack data.\\n bytes memoryInput;\\n // The opcode that was accessed.\\n uint8 opcode;\\n // The call depth of the step.\\n uint64 depth;\\n // Whether the call end up with out of gas error.\\n bool isOutOfGas;\\n // The contract address where the opcode is running\\n address contractAddr;\\n }\\n\\n /// Represents a transaction's broadcast details.\\n struct BroadcastTxSummary {\\n // The hash of the transaction that was broadcasted\\n bytes32 txHash;\\n // Represent the type of transaction among CALL, CREATE, CREATE2\\n BroadcastTxType txType;\\n // The address of the contract that was called or created.\\n // This is address of the contract that is created if the txType is CREATE or CREATE2.\\n address contractAddress;\\n // The block number the transaction landed in.\\n uint64 blockNumber;\\n // Status of the transaction, retrieved from the transaction receipt.\\n bool success;\\n }\\n\\n /// Holds a signed EIP-7702 authorization for an authority account to delegate to an implementation.\\n struct SignedDelegation {\\n // The y-parity of the recovered secp256k1 signature (0 or 1).\\n uint8 v;\\n // First 32 bytes of the signature.\\n bytes32 r;\\n // Second 32 bytes of the signature.\\n bytes32 s;\\n // The current nonce of the authority account at signing time.\\n // Used to ensure signature can't be replayed after account nonce changes.\\n uint64 nonce;\\n // Address of the contract implementation that will be delegated to.\\n // Gets encoded into delegation code: 0xef0100 || implementation.\\n address implementation;\\n }\\n\\n /// Represents a \\\"potential\\\" revert reason from a single subsequent call when using `vm.assumeNoReverts`.\\n /// Reverts that match will result in a FOUNDRY::ASSUME rejection, whereas unmatched reverts will be surfaced\\n /// as normal.\\n struct PotentialRevert {\\n // The allowed origin of the revert opcode; address(0) allows reverts from any address\\n address reverter;\\n // When true, only matches on the beginning of the revert data, otherwise, matches on entire revert data\\n bool partialMatch;\\n // The data to use to match encountered reverts\\n bytes revertData;\\n }\\n\\n /// An EIP-2930 access list item.\\n struct AccessListItem {\\n // The address to be added in access list.\\n address target;\\n // The storage keys to be added in access list.\\n bytes32[] storageKeys;\\n }\\n\\n // ======== Crypto ========\\n\\n /// Derives a private key from the name, labels the account with that name, and returns the wallet.\\n function createWallet(string calldata walletLabel) external returns (Wallet memory wallet);\\n\\n /// Generates a wallet from the private key and returns the wallet.\\n function createWallet(uint256 privateKey) external returns (Wallet memory wallet);\\n\\n /// Generates a wallet from the private key, labels the account with that name, and returns the wallet.\\n function createWallet(uint256 privateKey, string calldata walletLabel) external returns (Wallet memory wallet);\\n\\n /// Derive a private key from a provided mnenomic string (or mnenomic file path)\\n /// at the derivation path `m/44'/60'/0'/0/{index}`.\\n function deriveKey(string calldata mnemonic, uint32 index) external pure returns (uint256 privateKey);\\n\\n /// Derive a private key from a provided mnenomic string (or mnenomic file path)\\n /// at `{derivationPath}{index}`.\\n function deriveKey(string calldata mnemonic, string calldata derivationPath, uint32 index)\\n external\\n pure\\n returns (uint256 privateKey);\\n\\n /// Derive a private key from a provided mnenomic string (or mnenomic file path) in the specified language\\n /// at the derivation path `m/44'/60'/0'/0/{index}`.\\n function deriveKey(string calldata mnemonic, uint32 index, string calldata language)\\n external\\n pure\\n returns (uint256 privateKey);\\n\\n /// Derive a private key from a provided mnenomic string (or mnenomic file path) in the specified language\\n /// at `{derivationPath}{index}`.\\n function deriveKey(string calldata mnemonic, string calldata derivationPath, uint32 index, string calldata language)\\n external\\n pure\\n returns (uint256 privateKey);\\n\\n /// Derives secp256r1 public key from the provided `privateKey`.\\n function publicKeyP256(uint256 privateKey) external pure returns (uint256 publicKeyX, uint256 publicKeyY);\\n\\n /// Adds a private key to the local forge wallet and returns the address.\\n function rememberKey(uint256 privateKey) external returns (address keyAddr);\\n\\n /// Derive a set number of wallets from a mnemonic at the derivation path `m/44'/60'/0'/0/{0..count}`.\\n /// The respective private keys are saved to the local forge wallet for later use and their addresses are returned.\\n function rememberKeys(string calldata mnemonic, string calldata derivationPath, uint32 count)\\n external\\n returns (address[] memory keyAddrs);\\n\\n /// Derive a set number of wallets from a mnemonic in the specified language at the derivation path `m/44'/60'/0'/0/{0..count}`.\\n /// The respective private keys are saved to the local forge wallet for later use and their addresses are returned.\\n function rememberKeys(\\n string calldata mnemonic,\\n string calldata derivationPath,\\n string calldata language,\\n uint32 count\\n ) external returns (address[] memory keyAddrs);\\n\\n /// Signs data with a `Wallet`.\\n /// Returns a compact signature (`r`, `vs`) as per EIP-2098, where `vs` encodes both the\\n /// signature's `s` value, and the recovery id `v` in a single bytes32.\\n /// This format reduces the signature size from 65 to 64 bytes.\\n function signCompact(Wallet calldata wallet, bytes32 digest) external returns (bytes32 r, bytes32 vs);\\n\\n /// Signs `digest` with `privateKey` using the secp256k1 curve.\\n /// Returns a compact signature (`r`, `vs`) as per EIP-2098, where `vs` encodes both the\\n /// signature's `s` value, and the recovery id `v` in a single bytes32.\\n /// This format reduces the signature size from 65 to 64 bytes.\\n function signCompact(uint256 privateKey, bytes32 digest) external pure returns (bytes32 r, bytes32 vs);\\n\\n /// Signs `digest` with signer provided to script using the secp256k1 curve.\\n /// Returns a compact signature (`r`, `vs`) as per EIP-2098, where `vs` encodes both the\\n /// signature's `s` value, and the recovery id `v` in a single bytes32.\\n /// This format reduces the signature size from 65 to 64 bytes.\\n /// If `--sender` is provided, the signer with provided address is used, otherwise,\\n /// if exactly one signer is provided to the script, that signer is used.\\n /// Raises error if signer passed through `--sender` does not match any unlocked signers or\\n /// if `--sender` is not provided and not exactly one signer is passed to the script.\\n function signCompact(bytes32 digest) external pure returns (bytes32 r, bytes32 vs);\\n\\n /// Signs `digest` with signer provided to script using the secp256k1 curve.\\n /// Returns a compact signature (`r`, `vs`) as per EIP-2098, where `vs` encodes both the\\n /// signature's `s` value, and the recovery id `v` in a single bytes32.\\n /// This format reduces the signature size from 65 to 64 bytes.\\n /// Raises error if none of the signers passed into the script have provided address.\\n function signCompact(address signer, bytes32 digest) external pure returns (bytes32 r, bytes32 vs);\\n\\n /// Signs `digest` with `privateKey` using the secp256r1 curve.\\n function signP256(uint256 privateKey, bytes32 digest) external pure returns (bytes32 r, bytes32 s);\\n\\n /// Signs data with a `Wallet`.\\n function sign(Wallet calldata wallet, bytes32 digest) external returns (uint8 v, bytes32 r, bytes32 s);\\n\\n /// Signs `digest` with `privateKey` using the secp256k1 curve.\\n function sign(uint256 privateKey, bytes32 digest) external pure returns (uint8 v, bytes32 r, bytes32 s);\\n\\n /// Signs `digest` with signer provided to script using the secp256k1 curve.\\n /// If `--sender` is provided, the signer with provided address is used, otherwise,\\n /// if exactly one signer is provided to the script, that signer is used.\\n /// Raises error if signer passed through `--sender` does not match any unlocked signers or\\n /// if `--sender` is not provided and not exactly one signer is passed to the script.\\n function sign(bytes32 digest) external pure returns (uint8 v, bytes32 r, bytes32 s);\\n\\n /// Signs `digest` with signer provided to script using the secp256k1 curve.\\n /// Raises error if none of the signers passed into the script have provided address.\\n function sign(address signer, bytes32 digest) external pure returns (uint8 v, bytes32 r, bytes32 s);\\n\\n // ======== Environment ========\\n\\n /// Gets the environment variable `name` and parses it as `address`.\\n /// Reverts if the variable was not found or could not be parsed.\\n function envAddress(string calldata name) external view returns (address value);\\n\\n /// Gets the environment variable `name` and parses it as an array of `address`, delimited by `delim`.\\n /// Reverts if the variable was not found or could not be parsed.\\n function envAddress(string calldata name, string calldata delim) external view returns (address[] memory value);\\n\\n /// Gets the environment variable `name` and parses it as `bool`.\\n /// Reverts if the variable was not found or could not be parsed.\\n function envBool(string calldata name) external view returns (bool value);\\n\\n /// Gets the environment variable `name` and parses it as an array of `bool`, delimited by `delim`.\\n /// Reverts if the variable was not found or could not be parsed.\\n function envBool(string calldata name, string calldata delim) external view returns (bool[] memory value);\\n\\n /// Gets the environment variable `name` and parses it as `bytes32`.\\n /// Reverts if the variable was not found or could not be parsed.\\n function envBytes32(string calldata name) external view returns (bytes32 value);\\n\\n /// Gets the environment variable `name` and parses it as an array of `bytes32`, delimited by `delim`.\\n /// Reverts if the variable was not found or could not be parsed.\\n function envBytes32(string calldata name, string calldata delim) external view returns (bytes32[] memory value);\\n\\n /// Gets the environment variable `name` and parses it as `bytes`.\\n /// Reverts if the variable was not found or could not be parsed.\\n function envBytes(string calldata name) external view returns (bytes memory value);\\n\\n /// Gets the environment variable `name` and parses it as an array of `bytes`, delimited by `delim`.\\n /// Reverts if the variable was not found or could not be parsed.\\n function envBytes(string calldata name, string calldata delim) external view returns (bytes[] memory value);\\n\\n /// Gets the environment variable `name` and returns true if it exists, else returns false.\\n function envExists(string calldata name) external view returns (bool result);\\n\\n /// Gets the environment variable `name` and parses it as `int256`.\\n /// Reverts if the variable was not found or could not be parsed.\\n function envInt(string calldata name) external view returns (int256 value);\\n\\n /// Gets the environment variable `name` and parses it as an array of `int256`, delimited by `delim`.\\n /// Reverts if the variable was not found or could not be parsed.\\n function envInt(string calldata name, string calldata delim) external view returns (int256[] memory value);\\n\\n /// Gets the environment variable `name` and parses it as `bool`.\\n /// Reverts if the variable could not be parsed.\\n /// Returns `defaultValue` if the variable was not found.\\n function envOr(string calldata name, bool defaultValue) external view returns (bool value);\\n\\n /// Gets the environment variable `name` and parses it as `uint256`.\\n /// Reverts if the variable could not be parsed.\\n /// Returns `defaultValue` if the variable was not found.\\n function envOr(string calldata name, uint256 defaultValue) external view returns (uint256 value);\\n\\n /// Gets the environment variable `name` and parses it as an array of `address`, delimited by `delim`.\\n /// Reverts if the variable could not be parsed.\\n /// Returns `defaultValue` if the variable was not found.\\n function envOr(string calldata name, string calldata delim, address[] calldata defaultValue)\\n external\\n view\\n returns (address[] memory value);\\n\\n /// Gets the environment variable `name` and parses it as an array of `bytes32`, delimited by `delim`.\\n /// Reverts if the variable could not be parsed.\\n /// Returns `defaultValue` if the variable was not found.\\n function envOr(string calldata name, string calldata delim, bytes32[] calldata defaultValue)\\n external\\n view\\n returns (bytes32[] memory value);\\n\\n /// Gets the environment variable `name` and parses it as an array of `string`, delimited by `delim`.\\n /// Reverts if the variable could not be parsed.\\n /// Returns `defaultValue` if the variable was not found.\\n function envOr(string calldata name, string calldata delim, string[] calldata defaultValue)\\n external\\n view\\n returns (string[] memory value);\\n\\n /// Gets the environment variable `name` and parses it as an array of `bytes`, delimited by `delim`.\\n /// Reverts if the variable could not be parsed.\\n /// Returns `defaultValue` if the variable was not found.\\n function envOr(string calldata name, string calldata delim, bytes[] calldata defaultValue)\\n external\\n view\\n returns (bytes[] memory value);\\n\\n /// Gets the environment variable `name` and parses it as `int256`.\\n /// Reverts if the variable could not be parsed.\\n /// Returns `defaultValue` if the variable was not found.\\n function envOr(string calldata name, int256 defaultValue) external view returns (int256 value);\\n\\n /// Gets the environment variable `name` and parses it as `address`.\\n /// Reverts if the variable could not be parsed.\\n /// Returns `defaultValue` if the variable was not found.\\n function envOr(string calldata name, address defaultValue) external view returns (address value);\\n\\n /// Gets the environment variable `name` and parses it as `bytes32`.\\n /// Reverts if the variable could not be parsed.\\n /// Returns `defaultValue` if the variable was not found.\\n function envOr(string calldata name, bytes32 defaultValue) external view returns (bytes32 value);\\n\\n /// Gets the environment variable `name` and parses it as `string`.\\n /// Reverts if the variable could not be parsed.\\n /// Returns `defaultValue` if the variable was not found.\\n function envOr(string calldata name, string calldata defaultValue) external view returns (string memory value);\\n\\n /// Gets the environment variable `name` and parses it as `bytes`.\\n /// Reverts if the variable could not be parsed.\\n /// Returns `defaultValue` if the variable was not found.\\n function envOr(string calldata name, bytes calldata defaultValue) external view returns (bytes memory value);\\n\\n /// Gets the environment variable `name` and parses it as an array of `bool`, delimited by `delim`.\\n /// Reverts if the variable could not be parsed.\\n /// Returns `defaultValue` if the variable was not found.\\n function envOr(string calldata name, string calldata delim, bool[] calldata defaultValue)\\n external\\n view\\n returns (bool[] memory value);\\n\\n /// Gets the environment variable `name` and parses it as an array of `uint256`, delimited by `delim`.\\n /// Reverts if the variable could not be parsed.\\n /// Returns `defaultValue` if the variable was not found.\\n function envOr(string calldata name, string calldata delim, uint256[] calldata defaultValue)\\n external\\n view\\n returns (uint256[] memory value);\\n\\n /// Gets the environment variable `name` and parses it as an array of `int256`, delimited by `delim`.\\n /// Reverts if the variable could not be parsed.\\n /// Returns `defaultValue` if the variable was not found.\\n function envOr(string calldata name, string calldata delim, int256[] calldata defaultValue)\\n external\\n view\\n returns (int256[] memory value);\\n\\n /// Gets the environment variable `name` and parses it as `string`.\\n /// Reverts if the variable was not found or could not be parsed.\\n function envString(string calldata name) external view returns (string memory value);\\n\\n /// Gets the environment variable `name` and parses it as an array of `string`, delimited by `delim`.\\n /// Reverts if the variable was not found or could not be parsed.\\n function envString(string calldata name, string calldata delim) external view returns (string[] memory value);\\n\\n /// Gets the environment variable `name` and parses it as `uint256`.\\n /// Reverts if the variable was not found or could not be parsed.\\n function envUint(string calldata name) external view returns (uint256 value);\\n\\n /// Gets the environment variable `name` and parses it as an array of `uint256`, delimited by `delim`.\\n /// Reverts if the variable was not found or could not be parsed.\\n function envUint(string calldata name, string calldata delim) external view returns (uint256[] memory value);\\n\\n /// Returns true if `forge` command was executed in given context.\\n function isContext(ForgeContext context) external view returns (bool result);\\n\\n /// Sets environment variables.\\n function setEnv(string calldata name, string calldata value) external;\\n\\n // ======== EVM ========\\n\\n /// Gets all accessed reads and write slot from a `vm.record` session, for a given address.\\n function accesses(address target) external returns (bytes32[] memory readSlots, bytes32[] memory writeSlots);\\n\\n /// Gets the address for a given private key.\\n function addr(uint256 privateKey) external pure returns (address keyAddr);\\n\\n /// Gets all the logs according to specified filter.\\n function eth_getLogs(uint256 fromBlock, uint256 toBlock, address target, bytes32[] calldata topics)\\n external\\n returns (EthGetLogs[] memory logs);\\n\\n /// Gets the current `block.blobbasefee`.\\n /// You should use this instead of `block.blobbasefee` if you use `vm.blobBaseFee`, as `block.blobbasefee` is assumed to be constant across a transaction,\\n /// and as a result will get optimized out by the compiler.\\n /// See https://github.com/foundry-rs/foundry/issues/6180\\n function getBlobBaseFee() external view returns (uint256 blobBaseFee);\\n\\n /// Gets the current `block.number`.\\n /// You should use this instead of `block.number` if you use `vm.roll`, as `block.number` is assumed to be constant across a transaction,\\n /// and as a result will get optimized out by the compiler.\\n /// See https://github.com/foundry-rs/foundry/issues/6180\\n function getBlockNumber() external view returns (uint256 height);\\n\\n /// Gets the current `block.timestamp`.\\n /// You should use this instead of `block.timestamp` if you use `vm.warp`, as `block.timestamp` is assumed to be constant across a transaction,\\n /// and as a result will get optimized out by the compiler.\\n /// See https://github.com/foundry-rs/foundry/issues/6180\\n function getBlockTimestamp() external view returns (uint256 timestamp);\\n\\n /// Gets the map key and parent of a mapping at a given slot, for a given address.\\n function getMappingKeyAndParentOf(address target, bytes32 elementSlot)\\n external\\n returns (bool found, bytes32 key, bytes32 parent);\\n\\n /// Gets the number of elements in the mapping at the given slot, for a given address.\\n function getMappingLength(address target, bytes32 mappingSlot) external returns (uint256 length);\\n\\n /// Gets the elements at index idx of the mapping at the given slot, for a given address. The\\n /// index must be less than the length of the mapping (i.e. the number of keys in the mapping).\\n function getMappingSlotAt(address target, bytes32 mappingSlot, uint256 idx) external returns (bytes32 value);\\n\\n /// Gets the nonce of an account.\\n function getNonce(address account) external view returns (uint64 nonce);\\n\\n /// Get the nonce of a `Wallet`.\\n function getNonce(Wallet calldata wallet) external returns (uint64 nonce);\\n\\n /// Gets all the recorded logs.\\n function getRecordedLogs() external returns (Log[] memory logs);\\n\\n /// Returns state diffs from current `vm.startStateDiffRecording` session.\\n function getStateDiff() external view returns (string memory diff);\\n\\n /// Returns state diffs from current `vm.startStateDiffRecording` session, in json format.\\n function getStateDiffJson() external view returns (string memory diff);\\n\\n /// Gets the gas used in the last call from the callee perspective.\\n function lastCallGas() external view returns (Gas memory gas);\\n\\n /// Loads a storage slot from an address.\\n function load(address target, bytes32 slot) external view returns (bytes32 data);\\n\\n /// Pauses gas metering (i.e. gas usage is not counted). Noop if already paused.\\n function pauseGasMetering() external;\\n\\n /// Records all storage reads and writes.\\n function record() external;\\n\\n /// Record all the transaction logs.\\n function recordLogs() external;\\n\\n /// Reset gas metering (i.e. gas usage is set to gas limit).\\n function resetGasMetering() external;\\n\\n /// Resumes gas metering (i.e. gas usage is counted again). Noop if already on.\\n function resumeGasMetering() external;\\n\\n /// Performs an Ethereum JSON-RPC request to the current fork URL.\\n function rpc(string calldata method, string calldata params) external returns (bytes memory data);\\n\\n /// Performs an Ethereum JSON-RPC request to the given endpoint.\\n function rpc(string calldata urlOrAlias, string calldata method, string calldata params)\\n external\\n returns (bytes memory data);\\n\\n /// Records the debug trace during the run.\\n function startDebugTraceRecording() external;\\n\\n /// Starts recording all map SSTOREs for later retrieval.\\n function startMappingRecording() external;\\n\\n /// Record all account accesses as part of CREATE, CALL or SELFDESTRUCT opcodes in order,\\n /// along with the context of the calls\\n function startStateDiffRecording() external;\\n\\n /// Stop debug trace recording and returns the recorded debug trace.\\n function stopAndReturnDebugTraceRecording() external returns (DebugStep[] memory step);\\n\\n /// Returns an ordered array of all account accesses from a `vm.startStateDiffRecording` session.\\n function stopAndReturnStateDiff() external returns (AccountAccess[] memory accountAccesses);\\n\\n /// Stops recording all map SSTOREs for later retrieval and clears the recorded data.\\n function stopMappingRecording() external;\\n\\n // ======== Filesystem ========\\n\\n /// Closes file for reading, resetting the offset and allowing to read it from beginning with readLine.\\n /// `path` is relative to the project root.\\n function closeFile(string calldata path) external;\\n\\n /// Copies the contents of one file to another. This function will **overwrite** the contents of `to`.\\n /// On success, the total number of bytes copied is returned and it is equal to the length of the `to` file as reported by `metadata`.\\n /// Both `from` and `to` are relative to the project root.\\n function copyFile(string calldata from, string calldata to) external returns (uint64 copied);\\n\\n /// Creates a new, empty directory at the provided path.\\n /// This cheatcode will revert in the following situations, but is not limited to just these cases:\\n /// - User lacks permissions to modify `path`.\\n /// - A parent of the given path doesn't exist and `recursive` is false.\\n /// - `path` already exists and `recursive` is false.\\n /// `path` is relative to the project root.\\n function createDir(string calldata path, bool recursive) external;\\n\\n /// Deploys a contract from an artifact file. Takes in the relative path to the json file or the path to the\\n /// artifact in the form of :: where and parts are optional.\\n function deployCode(string calldata artifactPath) external returns (address deployedAddress);\\n\\n /// Deploys a contract from an artifact file. Takes in the relative path to the json file or the path to the\\n /// artifact in the form of :: where and parts are optional.\\n /// Additionally accepts abi-encoded constructor arguments.\\n function deployCode(string calldata artifactPath, bytes calldata constructorArgs)\\n external\\n returns (address deployedAddress);\\n\\n /// Returns true if the given path points to an existing entity, else returns false.\\n function exists(string calldata path) external view returns (bool result);\\n\\n /// Performs a foreign function call via the terminal.\\n function ffi(string[] calldata commandInput) external returns (bytes memory result);\\n\\n /// Given a path, query the file system to get information about a file, directory, etc.\\n function fsMetadata(string calldata path) external view returns (FsMetadata memory metadata);\\n\\n /// Gets the artifact path from code (aka. creation code).\\n function getArtifactPathByCode(bytes calldata code) external view returns (string memory path);\\n\\n /// Gets the artifact path from deployed code (aka. runtime code).\\n function getArtifactPathByDeployedCode(bytes calldata deployedCode) external view returns (string memory path);\\n\\n /// Returns the most recent broadcast for the given contract on `chainId` matching `txType`.\\n /// For example:\\n /// The most recent deployment can be fetched by passing `txType` as `CREATE` or `CREATE2`.\\n /// The most recent call can be fetched by passing `txType` as `CALL`.\\n function getBroadcast(string calldata contractName, uint64 chainId, BroadcastTxType txType)\\n external\\n view\\n returns (BroadcastTxSummary memory);\\n\\n /// Returns all broadcasts for the given contract on `chainId` with the specified `txType`.\\n /// Sorted such that the most recent broadcast is the first element, and the oldest is the last. i.e descending order of BroadcastTxSummary.blockNumber.\\n function getBroadcasts(string calldata contractName, uint64 chainId, BroadcastTxType txType)\\n external\\n view\\n returns (BroadcastTxSummary[] memory);\\n\\n /// Returns all broadcasts for the given contract on `chainId`.\\n /// Sorted such that the most recent broadcast is the first element, and the oldest is the last. i.e descending order of BroadcastTxSummary.blockNumber.\\n function getBroadcasts(string calldata contractName, uint64 chainId)\\n external\\n view\\n returns (BroadcastTxSummary[] memory);\\n\\n /// Gets the creation bytecode from an artifact file. Takes in the relative path to the json file or the path to the\\n /// artifact in the form of :: where and parts are optional.\\n function getCode(string calldata artifactPath) external view returns (bytes memory creationBytecode);\\n\\n /// Gets the deployed bytecode from an artifact file. Takes in the relative path to the json file or the path to the\\n /// artifact in the form of :: where and parts are optional.\\n function getDeployedCode(string calldata artifactPath) external view returns (bytes memory runtimeBytecode);\\n\\n /// Returns the most recent deployment for the current `chainId`.\\n function getDeployment(string calldata contractName) external view returns (address deployedAddress);\\n\\n /// Returns the most recent deployment for the given contract on `chainId`\\n function getDeployment(string calldata contractName, uint64 chainId)\\n external\\n view\\n returns (address deployedAddress);\\n\\n /// Returns all deployments for the given contract on `chainId`\\n /// Sorted in descending order of deployment time i.e descending order of BroadcastTxSummary.blockNumber.\\n /// The most recent deployment is the first element, and the oldest is the last.\\n function getDeployments(string calldata contractName, uint64 chainId)\\n external\\n view\\n returns (address[] memory deployedAddresses);\\n\\n /// Returns true if the path exists on disk and is pointing at a directory, else returns false.\\n function isDir(string calldata path) external view returns (bool result);\\n\\n /// Returns true if the path exists on disk and is pointing at a regular file, else returns false.\\n function isFile(string calldata path) external view returns (bool result);\\n\\n /// Get the path of the current project root.\\n function projectRoot() external view returns (string memory path);\\n\\n /// Prompts the user for a string value in the terminal.\\n function prompt(string calldata promptText) external returns (string memory input);\\n\\n /// Prompts the user for an address in the terminal.\\n function promptAddress(string calldata promptText) external returns (address);\\n\\n /// Prompts the user for a hidden string value in the terminal.\\n function promptSecret(string calldata promptText) external returns (string memory input);\\n\\n /// Prompts the user for hidden uint256 in the terminal (usually pk).\\n function promptSecretUint(string calldata promptText) external returns (uint256);\\n\\n /// Prompts the user for uint256 in the terminal.\\n function promptUint(string calldata promptText) external returns (uint256);\\n\\n /// Reads the directory at the given path recursively, up to `maxDepth`.\\n /// `maxDepth` defaults to 1, meaning only the direct children of the given directory will be returned.\\n /// Follows symbolic links if `followLinks` is true.\\n function readDir(string calldata path) external view returns (DirEntry[] memory entries);\\n\\n /// See `readDir(string)`.\\n function readDir(string calldata path, uint64 maxDepth) external view returns (DirEntry[] memory entries);\\n\\n /// See `readDir(string)`.\\n function readDir(string calldata path, uint64 maxDepth, bool followLinks)\\n external\\n view\\n returns (DirEntry[] memory entries);\\n\\n /// Reads the entire content of file to string. `path` is relative to the project root.\\n function readFile(string calldata path) external view returns (string memory data);\\n\\n /// Reads the entire content of file as binary. `path` is relative to the project root.\\n function readFileBinary(string calldata path) external view returns (bytes memory data);\\n\\n /// Reads next line of file to string.\\n function readLine(string calldata path) external view returns (string memory line);\\n\\n /// Reads a symbolic link, returning the path that the link points to.\\n /// This cheatcode will revert in the following situations, but is not limited to just these cases:\\n /// - `path` is not a symbolic link.\\n /// - `path` does not exist.\\n function readLink(string calldata linkPath) external view returns (string memory targetPath);\\n\\n /// Removes a directory at the provided path.\\n /// This cheatcode will revert in the following situations, but is not limited to just these cases:\\n /// - `path` doesn't exist.\\n /// - `path` isn't a directory.\\n /// - User lacks permissions to modify `path`.\\n /// - The directory is not empty and `recursive` is false.\\n /// `path` is relative to the project root.\\n function removeDir(string calldata path, bool recursive) external;\\n\\n /// Removes a file from the filesystem.\\n /// This cheatcode will revert in the following situations, but is not limited to just these cases:\\n /// - `path` points to a directory.\\n /// - The file doesn't exist.\\n /// - The user lacks permissions to remove the file.\\n /// `path` is relative to the project root.\\n function removeFile(string calldata path) external;\\n\\n /// Performs a foreign function call via terminal and returns the exit code, stdout, and stderr.\\n function tryFfi(string[] calldata commandInput) external returns (FfiResult memory result);\\n\\n /// Returns the time since unix epoch in milliseconds.\\n function unixTime() external view returns (uint256 milliseconds);\\n\\n /// Writes data to file, creating a file if it does not exist, and entirely replacing its contents if it does.\\n /// `path` is relative to the project root.\\n function writeFile(string calldata path, string calldata data) external;\\n\\n /// Writes binary data to a file, creating a file if it does not exist, and entirely replacing its contents if it does.\\n /// `path` is relative to the project root.\\n function writeFileBinary(string calldata path, bytes calldata data) external;\\n\\n /// Writes line to file, creating a file if it does not exist.\\n /// `path` is relative to the project root.\\n function writeLine(string calldata path, string calldata data) external;\\n\\n // ======== JSON ========\\n\\n /// Checks if `key` exists in a JSON object.\\n function keyExistsJson(string calldata json, string calldata key) external view returns (bool);\\n\\n /// Parses a string of JSON data at `key` and coerces it to `address`.\\n function parseJsonAddress(string calldata json, string calldata key) external pure returns (address);\\n\\n /// Parses a string of JSON data at `key` and coerces it to `address[]`.\\n function parseJsonAddressArray(string calldata json, string calldata key)\\n external\\n pure\\n returns (address[] memory);\\n\\n /// Parses a string of JSON data at `key` and coerces it to `bool`.\\n function parseJsonBool(string calldata json, string calldata key) external pure returns (bool);\\n\\n /// Parses a string of JSON data at `key` and coerces it to `bool[]`.\\n function parseJsonBoolArray(string calldata json, string calldata key) external pure returns (bool[] memory);\\n\\n /// Parses a string of JSON data at `key` and coerces it to `bytes`.\\n function parseJsonBytes(string calldata json, string calldata key) external pure returns (bytes memory);\\n\\n /// Parses a string of JSON data at `key` and coerces it to `bytes32`.\\n function parseJsonBytes32(string calldata json, string calldata key) external pure returns (bytes32);\\n\\n /// Parses a string of JSON data at `key` and coerces it to `bytes32[]`.\\n function parseJsonBytes32Array(string calldata json, string calldata key)\\n external\\n pure\\n returns (bytes32[] memory);\\n\\n /// Parses a string of JSON data at `key` and coerces it to `bytes[]`.\\n function parseJsonBytesArray(string calldata json, string calldata key) external pure returns (bytes[] memory);\\n\\n /// Parses a string of JSON data at `key` and coerces it to `int256`.\\n function parseJsonInt(string calldata json, string calldata key) external pure returns (int256);\\n\\n /// Parses a string of JSON data at `key` and coerces it to `int256[]`.\\n function parseJsonIntArray(string calldata json, string calldata key) external pure returns (int256[] memory);\\n\\n /// Returns an array of all the keys in a JSON object.\\n function parseJsonKeys(string calldata json, string calldata key) external pure returns (string[] memory keys);\\n\\n /// Parses a string of JSON data at `key` and coerces it to `string`.\\n function parseJsonString(string calldata json, string calldata key) external pure returns (string memory);\\n\\n /// Parses a string of JSON data at `key` and coerces it to `string[]`.\\n function parseJsonStringArray(string calldata json, string calldata key) external pure returns (string[] memory);\\n\\n /// Parses a string of JSON data at `key` and coerces it to type array corresponding to `typeDescription`.\\n function parseJsonTypeArray(string calldata json, string calldata key, string calldata typeDescription)\\n external\\n pure\\n returns (bytes memory);\\n\\n /// Parses a string of JSON data and coerces it to type corresponding to `typeDescription`.\\n function parseJsonType(string calldata json, string calldata typeDescription)\\n external\\n pure\\n returns (bytes memory);\\n\\n /// Parses a string of JSON data at `key` and coerces it to type corresponding to `typeDescription`.\\n function parseJsonType(string calldata json, string calldata key, string calldata typeDescription)\\n external\\n pure\\n returns (bytes memory);\\n\\n /// Parses a string of JSON data at `key` and coerces it to `uint256`.\\n function parseJsonUint(string calldata json, string calldata key) external pure returns (uint256);\\n\\n /// Parses a string of JSON data at `key` and coerces it to `uint256[]`.\\n function parseJsonUintArray(string calldata json, string calldata key) external pure returns (uint256[] memory);\\n\\n /// ABI-encodes a JSON object.\\n function parseJson(string calldata json) external pure returns (bytes memory abiEncodedData);\\n\\n /// ABI-encodes a JSON object at `key`.\\n function parseJson(string calldata json, string calldata key) external pure returns (bytes memory abiEncodedData);\\n\\n /// See `serializeJson`.\\n function serializeAddress(string calldata objectKey, string calldata valueKey, address value)\\n external\\n returns (string memory json);\\n\\n /// See `serializeJson`.\\n function serializeAddress(string calldata objectKey, string calldata valueKey, address[] calldata values)\\n external\\n returns (string memory json);\\n\\n /// See `serializeJson`.\\n function serializeBool(string calldata objectKey, string calldata valueKey, bool value)\\n external\\n returns (string memory json);\\n\\n /// See `serializeJson`.\\n function serializeBool(string calldata objectKey, string calldata valueKey, bool[] calldata values)\\n external\\n returns (string memory json);\\n\\n /// See `serializeJson`.\\n function serializeBytes32(string calldata objectKey, string calldata valueKey, bytes32 value)\\n external\\n returns (string memory json);\\n\\n /// See `serializeJson`.\\n function serializeBytes32(string calldata objectKey, string calldata valueKey, bytes32[] calldata values)\\n external\\n returns (string memory json);\\n\\n /// See `serializeJson`.\\n function serializeBytes(string calldata objectKey, string calldata valueKey, bytes calldata value)\\n external\\n returns (string memory json);\\n\\n /// See `serializeJson`.\\n function serializeBytes(string calldata objectKey, string calldata valueKey, bytes[] calldata values)\\n external\\n returns (string memory json);\\n\\n /// See `serializeJson`.\\n function serializeInt(string calldata objectKey, string calldata valueKey, int256 value)\\n external\\n returns (string memory json);\\n\\n /// See `serializeJson`.\\n function serializeInt(string calldata objectKey, string calldata valueKey, int256[] calldata values)\\n external\\n returns (string memory json);\\n\\n /// Serializes a key and value to a JSON object stored in-memory that can be later written to a file.\\n /// Returns the stringified version of the specific JSON file up to that moment.\\n function serializeJson(string calldata objectKey, string calldata value) external returns (string memory json);\\n\\n /// See `serializeJson`.\\n function serializeJsonType(string calldata typeDescription, bytes calldata value)\\n external\\n pure\\n returns (string memory json);\\n\\n /// See `serializeJson`.\\n function serializeJsonType(\\n string calldata objectKey,\\n string calldata valueKey,\\n string calldata typeDescription,\\n bytes calldata value\\n ) external returns (string memory json);\\n\\n /// See `serializeJson`.\\n function serializeString(string calldata objectKey, string calldata valueKey, string calldata value)\\n external\\n returns (string memory json);\\n\\n /// See `serializeJson`.\\n function serializeString(string calldata objectKey, string calldata valueKey, string[] calldata values)\\n external\\n returns (string memory json);\\n\\n /// See `serializeJson`.\\n function serializeUintToHex(string calldata objectKey, string calldata valueKey, uint256 value)\\n external\\n returns (string memory json);\\n\\n /// See `serializeJson`.\\n function serializeUint(string calldata objectKey, string calldata valueKey, uint256 value)\\n external\\n returns (string memory json);\\n\\n /// See `serializeJson`.\\n function serializeUint(string calldata objectKey, string calldata valueKey, uint256[] calldata values)\\n external\\n returns (string memory json);\\n\\n /// Write a serialized JSON object to a file. If the file exists, it will be overwritten.\\n function writeJson(string calldata json, string calldata path) external;\\n\\n /// Write a serialized JSON object to an **existing** JSON file, replacing a value with key = \\n /// This is useful to replace a specific value of a JSON file, without having to parse the entire thing.\\n function writeJson(string calldata json, string calldata path, string calldata valueKey) external;\\n\\n /// Checks if `key` exists in a JSON object\\n /// `keyExists` is being deprecated in favor of `keyExistsJson`. It will be removed in future versions.\\n function keyExists(string calldata json, string calldata key) external view returns (bool);\\n\\n // ======== Scripting ========\\n\\n /// Designate the next call as an EIP-7702 transaction\\n function attachDelegation(SignedDelegation calldata signedDelegation) external;\\n\\n /// Takes a signed transaction and broadcasts it to the network.\\n function broadcastRawTransaction(bytes calldata data) external;\\n\\n /// Has the next call (at this call depth only) create transactions that can later be signed and sent onchain.\\n /// Broadcasting address is determined by checking the following in order:\\n /// 1. If `--sender` argument was provided, that address is used.\\n /// 2. If exactly one signer (e.g. private key, hw wallet, keystore) is set when `forge broadcast` is invoked, that signer is used.\\n /// 3. Otherwise, default foundry sender (1804c8AB1F12E6bbf3894d4083f33e07309d1f38) is used.\\n function broadcast() external;\\n\\n /// Has the next call (at this call depth only) create a transaction with the address provided\\n /// as the sender that can later be signed and sent onchain.\\n function broadcast(address signer) external;\\n\\n /// Has the next call (at this call depth only) create a transaction with the private key\\n /// provided as the sender that can later be signed and sent onchain.\\n function broadcast(uint256 privateKey) external;\\n\\n /// Returns addresses of available unlocked wallets in the script environment.\\n function getWallets() external returns (address[] memory wallets);\\n\\n /// Sign an EIP-7702 authorization and designate the next call as an EIP-7702 transaction\\n function signAndAttachDelegation(address implementation, uint256 privateKey)\\n external\\n returns (SignedDelegation memory signedDelegation);\\n\\n /// Sign an EIP-7702 authorization for delegation\\n function signDelegation(address implementation, uint256 privateKey)\\n external\\n returns (SignedDelegation memory signedDelegation);\\n\\n /// Has all subsequent calls (at this call depth only) create transactions that can later be signed and sent onchain.\\n /// Broadcasting address is determined by checking the following in order:\\n /// 1. If `--sender` argument was provided, that address is used.\\n /// 2. If exactly one signer (e.g. private key, hw wallet, keystore) is set when `forge broadcast` is invoked, that signer is used.\\n /// 3. Otherwise, default foundry sender (1804c8AB1F12E6bbf3894d4083f33e07309d1f38) is used.\\n function startBroadcast() external;\\n\\n /// Has all subsequent calls (at this call depth only) create transactions with the address\\n /// provided that can later be signed and sent onchain.\\n function startBroadcast(address signer) external;\\n\\n /// Has all subsequent calls (at this call depth only) create transactions with the private key\\n /// provided that can later be signed and sent onchain.\\n function startBroadcast(uint256 privateKey) external;\\n\\n /// Stops collecting onchain transactions.\\n function stopBroadcast() external;\\n\\n // ======== String ========\\n\\n /// Returns true if `search` is found in `subject`, false otherwise.\\n function contains(string calldata subject, string calldata search) external returns (bool result);\\n\\n /// Returns the index of the first occurrence of a `key` in an `input` string.\\n /// Returns `NOT_FOUND` (i.e. `type(uint256).max`) if the `key` is not found.\\n /// Returns 0 in case of an empty `key`.\\n function indexOf(string calldata input, string calldata key) external pure returns (uint256);\\n\\n /// Parses the given `string` into an `address`.\\n function parseAddress(string calldata stringifiedValue) external pure returns (address parsedValue);\\n\\n /// Parses the given `string` into a `bool`.\\n function parseBool(string calldata stringifiedValue) external pure returns (bool parsedValue);\\n\\n /// Parses the given `string` into `bytes`.\\n function parseBytes(string calldata stringifiedValue) external pure returns (bytes memory parsedValue);\\n\\n /// Parses the given `string` into a `bytes32`.\\n function parseBytes32(string calldata stringifiedValue) external pure returns (bytes32 parsedValue);\\n\\n /// Parses the given `string` into a `int256`.\\n function parseInt(string calldata stringifiedValue) external pure returns (int256 parsedValue);\\n\\n /// Parses the given `string` into a `uint256`.\\n function parseUint(string calldata stringifiedValue) external pure returns (uint256 parsedValue);\\n\\n /// Replaces occurrences of `from` in the given `string` with `to`.\\n function replace(string calldata input, string calldata from, string calldata to)\\n external\\n pure\\n returns (string memory output);\\n\\n /// Splits the given `string` into an array of strings divided by the `delimiter`.\\n function split(string calldata input, string calldata delimiter) external pure returns (string[] memory outputs);\\n\\n /// Converts the given `string` value to Lowercase.\\n function toLowercase(string calldata input) external pure returns (string memory output);\\n\\n /// Converts the given value to a `string`.\\n function toString(address value) external pure returns (string memory stringifiedValue);\\n\\n /// Converts the given value to a `string`.\\n function toString(bytes calldata value) external pure returns (string memory stringifiedValue);\\n\\n /// Converts the given value to a `string`.\\n function toString(bytes32 value) external pure returns (string memory stringifiedValue);\\n\\n /// Converts the given value to a `string`.\\n function toString(bool value) external pure returns (string memory stringifiedValue);\\n\\n /// Converts the given value to a `string`.\\n function toString(uint256 value) external pure returns (string memory stringifiedValue);\\n\\n /// Converts the given value to a `string`.\\n function toString(int256 value) external pure returns (string memory stringifiedValue);\\n\\n /// Converts the given `string` value to Uppercase.\\n function toUppercase(string calldata input) external pure returns (string memory output);\\n\\n /// Trims leading and trailing whitespace from the given `string` value.\\n function trim(string calldata input) external pure returns (string memory output);\\n\\n // ======== Testing ========\\n\\n /// Compares two `uint256` values. Expects difference to be less than or equal to `maxDelta`.\\n /// Formats values with decimals in failure message.\\n function assertApproxEqAbsDecimal(uint256 left, uint256 right, uint256 maxDelta, uint256 decimals) external pure;\\n\\n /// Compares two `uint256` values. Expects difference to be less than or equal to `maxDelta`.\\n /// Formats values with decimals in failure message. Includes error message into revert string on failure.\\n function assertApproxEqAbsDecimal(\\n uint256 left,\\n uint256 right,\\n uint256 maxDelta,\\n uint256 decimals,\\n string calldata error\\n ) external pure;\\n\\n /// Compares two `int256` values. Expects difference to be less than or equal to `maxDelta`.\\n /// Formats values with decimals in failure message.\\n function assertApproxEqAbsDecimal(int256 left, int256 right, uint256 maxDelta, uint256 decimals) external pure;\\n\\n /// Compares two `int256` values. Expects difference to be less than or equal to `maxDelta`.\\n /// Formats values with decimals in failure message. Includes error message into revert string on failure.\\n function assertApproxEqAbsDecimal(\\n int256 left,\\n int256 right,\\n uint256 maxDelta,\\n uint256 decimals,\\n string calldata error\\n ) external pure;\\n\\n /// Compares two `uint256` values. Expects difference to be less than or equal to `maxDelta`.\\n function assertApproxEqAbs(uint256 left, uint256 right, uint256 maxDelta) external pure;\\n\\n /// Compares two `uint256` values. Expects difference to be less than or equal to `maxDelta`.\\n /// Includes error message into revert string on failure.\\n function assertApproxEqAbs(uint256 left, uint256 right, uint256 maxDelta, string calldata error) external pure;\\n\\n /// Compares two `int256` values. Expects difference to be less than or equal to `maxDelta`.\\n function assertApproxEqAbs(int256 left, int256 right, uint256 maxDelta) external pure;\\n\\n /// Compares two `int256` values. Expects difference to be less than or equal to `maxDelta`.\\n /// Includes error message into revert string on failure.\\n function assertApproxEqAbs(int256 left, int256 right, uint256 maxDelta, string calldata error) external pure;\\n\\n /// Compares two `uint256` values. Expects relative difference in percents to be less than or equal to `maxPercentDelta`.\\n /// `maxPercentDelta` is an 18 decimal fixed point number, where 1e18 == 100%\\n /// Formats values with decimals in failure message.\\n function assertApproxEqRelDecimal(uint256 left, uint256 right, uint256 maxPercentDelta, uint256 decimals)\\n external\\n pure;\\n\\n /// Compares two `uint256` values. Expects relative difference in percents to be less than or equal to `maxPercentDelta`.\\n /// `maxPercentDelta` is an 18 decimal fixed point number, where 1e18 == 100%\\n /// Formats values with decimals in failure message. Includes error message into revert string on failure.\\n function assertApproxEqRelDecimal(\\n uint256 left,\\n uint256 right,\\n uint256 maxPercentDelta,\\n uint256 decimals,\\n string calldata error\\n ) external pure;\\n\\n /// Compares two `int256` values. Expects relative difference in percents to be less than or equal to `maxPercentDelta`.\\n /// `maxPercentDelta` is an 18 decimal fixed point number, where 1e18 == 100%\\n /// Formats values with decimals in failure message.\\n function assertApproxEqRelDecimal(int256 left, int256 right, uint256 maxPercentDelta, uint256 decimals)\\n external\\n pure;\\n\\n /// Compares two `int256` values. Expects relative difference in percents to be less than or equal to `maxPercentDelta`.\\n /// `maxPercentDelta` is an 18 decimal fixed point number, where 1e18 == 100%\\n /// Formats values with decimals in failure message. Includes error message into revert string on failure.\\n function assertApproxEqRelDecimal(\\n int256 left,\\n int256 right,\\n uint256 maxPercentDelta,\\n uint256 decimals,\\n string calldata error\\n ) external pure;\\n\\n /// Compares two `uint256` values. Expects relative difference in percents to be less than or equal to `maxPercentDelta`.\\n /// `maxPercentDelta` is an 18 decimal fixed point number, where 1e18 == 100%\\n function assertApproxEqRel(uint256 left, uint256 right, uint256 maxPercentDelta) external pure;\\n\\n /// Compares two `uint256` values. Expects relative difference in percents to be less than or equal to `maxPercentDelta`.\\n /// `maxPercentDelta` is an 18 decimal fixed point number, where 1e18 == 100%\\n /// Includes error message into revert string on failure.\\n function assertApproxEqRel(uint256 left, uint256 right, uint256 maxPercentDelta, string calldata error)\\n external\\n pure;\\n\\n /// Compares two `int256` values. Expects relative difference in percents to be less than or equal to `maxPercentDelta`.\\n /// `maxPercentDelta` is an 18 decimal fixed point number, where 1e18 == 100%\\n function assertApproxEqRel(int256 left, int256 right, uint256 maxPercentDelta) external pure;\\n\\n /// Compares two `int256` values. Expects relative difference in percents to be less than or equal to `maxPercentDelta`.\\n /// `maxPercentDelta` is an 18 decimal fixed point number, where 1e18 == 100%\\n /// Includes error message into revert string on failure.\\n function assertApproxEqRel(int256 left, int256 right, uint256 maxPercentDelta, string calldata error)\\n external\\n pure;\\n\\n /// Asserts that two `uint256` values are equal, formatting them with decimals in failure message.\\n function assertEqDecimal(uint256 left, uint256 right, uint256 decimals) external pure;\\n\\n /// Asserts that two `uint256` values are equal, formatting them with decimals in failure message.\\n /// Includes error message into revert string on failure.\\n function assertEqDecimal(uint256 left, uint256 right, uint256 decimals, string calldata error) external pure;\\n\\n /// Asserts that two `int256` values are equal, formatting them with decimals in failure message.\\n function assertEqDecimal(int256 left, int256 right, uint256 decimals) external pure;\\n\\n /// Asserts that two `int256` values are equal, formatting them with decimals in failure message.\\n /// Includes error message into revert string on failure.\\n function assertEqDecimal(int256 left, int256 right, uint256 decimals, string calldata error) external pure;\\n\\n /// Asserts that two `bool` values are equal.\\n function assertEq(bool left, bool right) external pure;\\n\\n /// Asserts that two `bool` values are equal and includes error message into revert string on failure.\\n function assertEq(bool left, bool right, string calldata error) external pure;\\n\\n /// Asserts that two `string` values are equal.\\n function assertEq(string calldata left, string calldata right) external pure;\\n\\n /// Asserts that two `string` values are equal and includes error message into revert string on failure.\\n function assertEq(string calldata left, string calldata right, string calldata error) external pure;\\n\\n /// Asserts that two `bytes` values are equal.\\n function assertEq(bytes calldata left, bytes calldata right) external pure;\\n\\n /// Asserts that two `bytes` values are equal and includes error message into revert string on failure.\\n function assertEq(bytes calldata left, bytes calldata right, string calldata error) external pure;\\n\\n /// Asserts that two arrays of `bool` values are equal.\\n function assertEq(bool[] calldata left, bool[] calldata right) external pure;\\n\\n /// Asserts that two arrays of `bool` values are equal and includes error message into revert string on failure.\\n function assertEq(bool[] calldata left, bool[] calldata right, string calldata error) external pure;\\n\\n /// Asserts that two arrays of `uint256 values are equal.\\n function assertEq(uint256[] calldata left, uint256[] calldata right) external pure;\\n\\n /// Asserts that two arrays of `uint256` values are equal and includes error message into revert string on failure.\\n function assertEq(uint256[] calldata left, uint256[] calldata right, string calldata error) external pure;\\n\\n /// Asserts that two arrays of `int256` values are equal.\\n function assertEq(int256[] calldata left, int256[] calldata right) external pure;\\n\\n /// Asserts that two arrays of `int256` values are equal and includes error message into revert string on failure.\\n function assertEq(int256[] calldata left, int256[] calldata right, string calldata error) external pure;\\n\\n /// Asserts that two `uint256` values are equal.\\n function assertEq(uint256 left, uint256 right) external pure;\\n\\n /// Asserts that two arrays of `address` values are equal.\\n function assertEq(address[] calldata left, address[] calldata right) external pure;\\n\\n /// Asserts that two arrays of `address` values are equal and includes error message into revert string on failure.\\n function assertEq(address[] calldata left, address[] calldata right, string calldata error) external pure;\\n\\n /// Asserts that two arrays of `bytes32` values are equal.\\n function assertEq(bytes32[] calldata left, bytes32[] calldata right) external pure;\\n\\n /// Asserts that two arrays of `bytes32` values are equal and includes error message into revert string on failure.\\n function assertEq(bytes32[] calldata left, bytes32[] calldata right, string calldata error) external pure;\\n\\n /// Asserts that two arrays of `string` values are equal.\\n function assertEq(string[] calldata left, string[] calldata right) external pure;\\n\\n /// Asserts that two arrays of `string` values are equal and includes error message into revert string on failure.\\n function assertEq(string[] calldata left, string[] calldata right, string calldata error) external pure;\\n\\n /// Asserts that two arrays of `bytes` values are equal.\\n function assertEq(bytes[] calldata left, bytes[] calldata right) external pure;\\n\\n /// Asserts that two arrays of `bytes` values are equal and includes error message into revert string on failure.\\n function assertEq(bytes[] calldata left, bytes[] calldata right, string calldata error) external pure;\\n\\n /// Asserts that two `uint256` values are equal and includes error message into revert string on failure.\\n function assertEq(uint256 left, uint256 right, string calldata error) external pure;\\n\\n /// Asserts that two `int256` values are equal.\\n function assertEq(int256 left, int256 right) external pure;\\n\\n /// Asserts that two `int256` values are equal and includes error message into revert string on failure.\\n function assertEq(int256 left, int256 right, string calldata error) external pure;\\n\\n /// Asserts that two `address` values are equal.\\n function assertEq(address left, address right) external pure;\\n\\n /// Asserts that two `address` values are equal and includes error message into revert string on failure.\\n function assertEq(address left, address right, string calldata error) external pure;\\n\\n /// Asserts that two `bytes32` values are equal.\\n function assertEq(bytes32 left, bytes32 right) external pure;\\n\\n /// Asserts that two `bytes32` values are equal and includes error message into revert string on failure.\\n function assertEq(bytes32 left, bytes32 right, string calldata error) external pure;\\n\\n /// Asserts that the given condition is false.\\n function assertFalse(bool condition) external pure;\\n\\n /// Asserts that the given condition is false and includes error message into revert string on failure.\\n function assertFalse(bool condition, string calldata error) external pure;\\n\\n /// Compares two `uint256` values. Expects first value to be greater than or equal to second.\\n /// Formats values with decimals in failure message.\\n function assertGeDecimal(uint256 left, uint256 right, uint256 decimals) external pure;\\n\\n /// Compares two `uint256` values. Expects first value to be greater than or equal to second.\\n /// Formats values with decimals in failure message. Includes error message into revert string on failure.\\n function assertGeDecimal(uint256 left, uint256 right, uint256 decimals, string calldata error) external pure;\\n\\n /// Compares two `int256` values. Expects first value to be greater than or equal to second.\\n /// Formats values with decimals in failure message.\\n function assertGeDecimal(int256 left, int256 right, uint256 decimals) external pure;\\n\\n /// Compares two `int256` values. Expects first value to be greater than or equal to second.\\n /// Formats values with decimals in failure message. Includes error message into revert string on failure.\\n function assertGeDecimal(int256 left, int256 right, uint256 decimals, string calldata error) external pure;\\n\\n /// Compares two `uint256` values. Expects first value to be greater than or equal to second.\\n function assertGe(uint256 left, uint256 right) external pure;\\n\\n /// Compares two `uint256` values. Expects first value to be greater than or equal to second.\\n /// Includes error message into revert string on failure.\\n function assertGe(uint256 left, uint256 right, string calldata error) external pure;\\n\\n /// Compares two `int256` values. Expects first value to be greater than or equal to second.\\n function assertGe(int256 left, int256 right) external pure;\\n\\n /// Compares two `int256` values. Expects first value to be greater than or equal to second.\\n /// Includes error message into revert string on failure.\\n function assertGe(int256 left, int256 right, string calldata error) external pure;\\n\\n /// Compares two `uint256` values. Expects first value to be greater than second.\\n /// Formats values with decimals in failure message.\\n function assertGtDecimal(uint256 left, uint256 right, uint256 decimals) external pure;\\n\\n /// Compares two `uint256` values. Expects first value to be greater than second.\\n /// Formats values with decimals in failure message. Includes error message into revert string on failure.\\n function assertGtDecimal(uint256 left, uint256 right, uint256 decimals, string calldata error) external pure;\\n\\n /// Compares two `int256` values. Expects first value to be greater than second.\\n /// Formats values with decimals in failure message.\\n function assertGtDecimal(int256 left, int256 right, uint256 decimals) external pure;\\n\\n /// Compares two `int256` values. Expects first value to be greater than second.\\n /// Formats values with decimals in failure message. Includes error message into revert string on failure.\\n function assertGtDecimal(int256 left, int256 right, uint256 decimals, string calldata error) external pure;\\n\\n /// Compares two `uint256` values. Expects first value to be greater than second.\\n function assertGt(uint256 left, uint256 right) external pure;\\n\\n /// Compares two `uint256` values. Expects first value to be greater than second.\\n /// Includes error message into revert string on failure.\\n function assertGt(uint256 left, uint256 right, string calldata error) external pure;\\n\\n /// Compares two `int256` values. Expects first value to be greater than second.\\n function assertGt(int256 left, int256 right) external pure;\\n\\n /// Compares two `int256` values. Expects first value to be greater than second.\\n /// Includes error message into revert string on failure.\\n function assertGt(int256 left, int256 right, string calldata error) external pure;\\n\\n /// Compares two `uint256` values. Expects first value to be less than or equal to second.\\n /// Formats values with decimals in failure message.\\n function assertLeDecimal(uint256 left, uint256 right, uint256 decimals) external pure;\\n\\n /// Compares two `uint256` values. Expects first value to be less than or equal to second.\\n /// Formats values with decimals in failure message. Includes error message into revert string on failure.\\n function assertLeDecimal(uint256 left, uint256 right, uint256 decimals, string calldata error) external pure;\\n\\n /// Compares two `int256` values. Expects first value to be less than or equal to second.\\n /// Formats values with decimals in failure message.\\n function assertLeDecimal(int256 left, int256 right, uint256 decimals) external pure;\\n\\n /// Compares two `int256` values. Expects first value to be less than or equal to second.\\n /// Formats values with decimals in failure message. Includes error message into revert string on failure.\\n function assertLeDecimal(int256 left, int256 right, uint256 decimals, string calldata error) external pure;\\n\\n /// Compares two `uint256` values. Expects first value to be less than or equal to second.\\n function assertLe(uint256 left, uint256 right) external pure;\\n\\n /// Compares two `uint256` values. Expects first value to be less than or equal to second.\\n /// Includes error message into revert string on failure.\\n function assertLe(uint256 left, uint256 right, string calldata error) external pure;\\n\\n /// Compares two `int256` values. Expects first value to be less than or equal to second.\\n function assertLe(int256 left, int256 right) external pure;\\n\\n /// Compares two `int256` values. Expects first value to be less than or equal to second.\\n /// Includes error message into revert string on failure.\\n function assertLe(int256 left, int256 right, string calldata error) external pure;\\n\\n /// Compares two `uint256` values. Expects first value to be less than second.\\n /// Formats values with decimals in failure message.\\n function assertLtDecimal(uint256 left, uint256 right, uint256 decimals) external pure;\\n\\n /// Compares two `uint256` values. Expects first value to be less than second.\\n /// Formats values with decimals in failure message. Includes error message into revert string on failure.\\n function assertLtDecimal(uint256 left, uint256 right, uint256 decimals, string calldata error) external pure;\\n\\n /// Compares two `int256` values. Expects first value to be less than second.\\n /// Formats values with decimals in failure message.\\n function assertLtDecimal(int256 left, int256 right, uint256 decimals) external pure;\\n\\n /// Compares two `int256` values. Expects first value to be less than second.\\n /// Formats values with decimals in failure message. Includes error message into revert string on failure.\\n function assertLtDecimal(int256 left, int256 right, uint256 decimals, string calldata error) external pure;\\n\\n /// Compares two `uint256` values. Expects first value to be less than second.\\n function assertLt(uint256 left, uint256 right) external pure;\\n\\n /// Compares two `uint256` values. Expects first value to be less than second.\\n /// Includes error message into revert string on failure.\\n function assertLt(uint256 left, uint256 right, string calldata error) external pure;\\n\\n /// Compares two `int256` values. Expects first value to be less than second.\\n function assertLt(int256 left, int256 right) external pure;\\n\\n /// Compares two `int256` values. Expects first value to be less than second.\\n /// Includes error message into revert string on failure.\\n function assertLt(int256 left, int256 right, string calldata error) external pure;\\n\\n /// Asserts that two `uint256` values are not equal, formatting them with decimals in failure message.\\n function assertNotEqDecimal(uint256 left, uint256 right, uint256 decimals) external pure;\\n\\n /// Asserts that two `uint256` values are not equal, formatting them with decimals in failure message.\\n /// Includes error message into revert string on failure.\\n function assertNotEqDecimal(uint256 left, uint256 right, uint256 decimals, string calldata error) external pure;\\n\\n /// Asserts that two `int256` values are not equal, formatting them with decimals in failure message.\\n function assertNotEqDecimal(int256 left, int256 right, uint256 decimals) external pure;\\n\\n /// Asserts that two `int256` values are not equal, formatting them with decimals in failure message.\\n /// Includes error message into revert string on failure.\\n function assertNotEqDecimal(int256 left, int256 right, uint256 decimals, string calldata error) external pure;\\n\\n /// Asserts that two `bool` values are not equal.\\n function assertNotEq(bool left, bool right) external pure;\\n\\n /// Asserts that two `bool` values are not equal and includes error message into revert string on failure.\\n function assertNotEq(bool left, bool right, string calldata error) external pure;\\n\\n /// Asserts that two `string` values are not equal.\\n function assertNotEq(string calldata left, string calldata right) external pure;\\n\\n /// Asserts that two `string` values are not equal and includes error message into revert string on failure.\\n function assertNotEq(string calldata left, string calldata right, string calldata error) external pure;\\n\\n /// Asserts that two `bytes` values are not equal.\\n function assertNotEq(bytes calldata left, bytes calldata right) external pure;\\n\\n /// Asserts that two `bytes` values are not equal and includes error message into revert string on failure.\\n function assertNotEq(bytes calldata left, bytes calldata right, string calldata error) external pure;\\n\\n /// Asserts that two arrays of `bool` values are not equal.\\n function assertNotEq(bool[] calldata left, bool[] calldata right) external pure;\\n\\n /// Asserts that two arrays of `bool` values are not equal and includes error message into revert string on failure.\\n function assertNotEq(bool[] calldata left, bool[] calldata right, string calldata error) external pure;\\n\\n /// Asserts that two arrays of `uint256` values are not equal.\\n function assertNotEq(uint256[] calldata left, uint256[] calldata right) external pure;\\n\\n /// Asserts that two arrays of `uint256` values are not equal and includes error message into revert string on failure.\\n function assertNotEq(uint256[] calldata left, uint256[] calldata right, string calldata error) external pure;\\n\\n /// Asserts that two arrays of `int256` values are not equal.\\n function assertNotEq(int256[] calldata left, int256[] calldata right) external pure;\\n\\n /// Asserts that two arrays of `int256` values are not equal and includes error message into revert string on failure.\\n function assertNotEq(int256[] calldata left, int256[] calldata right, string calldata error) external pure;\\n\\n /// Asserts that two `uint256` values are not equal.\\n function assertNotEq(uint256 left, uint256 right) external pure;\\n\\n /// Asserts that two arrays of `address` values are not equal.\\n function assertNotEq(address[] calldata left, address[] calldata right) external pure;\\n\\n /// Asserts that two arrays of `address` values are not equal and includes error message into revert string on failure.\\n function assertNotEq(address[] calldata left, address[] calldata right, string calldata error) external pure;\\n\\n /// Asserts that two arrays of `bytes32` values are not equal.\\n function assertNotEq(bytes32[] calldata left, bytes32[] calldata right) external pure;\\n\\n /// Asserts that two arrays of `bytes32` values are not equal and includes error message into revert string on failure.\\n function assertNotEq(bytes32[] calldata left, bytes32[] calldata right, string calldata error) external pure;\\n\\n /// Asserts that two arrays of `string` values are not equal.\\n function assertNotEq(string[] calldata left, string[] calldata right) external pure;\\n\\n /// Asserts that two arrays of `string` values are not equal and includes error message into revert string on failure.\\n function assertNotEq(string[] calldata left, string[] calldata right, string calldata error) external pure;\\n\\n /// Asserts that two arrays of `bytes` values are not equal.\\n function assertNotEq(bytes[] calldata left, bytes[] calldata right) external pure;\\n\\n /// Asserts that two arrays of `bytes` values are not equal and includes error message into revert string on failure.\\n function assertNotEq(bytes[] calldata left, bytes[] calldata right, string calldata error) external pure;\\n\\n /// Asserts that two `uint256` values are not equal and includes error message into revert string on failure.\\n function assertNotEq(uint256 left, uint256 right, string calldata error) external pure;\\n\\n /// Asserts that two `int256` values are not equal.\\n function assertNotEq(int256 left, int256 right) external pure;\\n\\n /// Asserts that two `int256` values are not equal and includes error message into revert string on failure.\\n function assertNotEq(int256 left, int256 right, string calldata error) external pure;\\n\\n /// Asserts that two `address` values are not equal.\\n function assertNotEq(address left, address right) external pure;\\n\\n /// Asserts that two `address` values are not equal and includes error message into revert string on failure.\\n function assertNotEq(address left, address right, string calldata error) external pure;\\n\\n /// Asserts that two `bytes32` values are not equal.\\n function assertNotEq(bytes32 left, bytes32 right) external pure;\\n\\n /// Asserts that two `bytes32` values are not equal and includes error message into revert string on failure.\\n function assertNotEq(bytes32 left, bytes32 right, string calldata error) external pure;\\n\\n /// Asserts that the given condition is true.\\n function assertTrue(bool condition) external pure;\\n\\n /// Asserts that the given condition is true and includes error message into revert string on failure.\\n function assertTrue(bool condition, string calldata error) external pure;\\n\\n /// If the condition is false, discard this run's fuzz inputs and generate new ones.\\n function assume(bool condition) external pure;\\n\\n /// Discard this run's fuzz inputs and generate new ones if next call reverted.\\n function assumeNoRevert() external pure;\\n\\n /// Discard this run's fuzz inputs and generate new ones if next call reverts with the potential revert parameters.\\n function assumeNoRevert(PotentialRevert calldata potentialRevert) external pure;\\n\\n /// Discard this run's fuzz inputs and generate new ones if next call reverts with the any of the potential revert parameters.\\n function assumeNoRevert(PotentialRevert[] calldata potentialReverts) external pure;\\n\\n /// Writes a breakpoint to jump to in the debugger.\\n function breakpoint(string calldata char) external pure;\\n\\n /// Writes a conditional breakpoint to jump to in the debugger.\\n function breakpoint(string calldata char, bool value) external pure;\\n\\n /// Returns true if the current Foundry version is greater than or equal to the given version.\\n /// The given version string must be in the format `major.minor.patch`.\\n /// This is equivalent to `foundryVersionCmp(version) >= 0`.\\n function foundryVersionAtLeast(string calldata version) external view returns (bool);\\n\\n /// Compares the current Foundry version with the given version string.\\n /// The given version string must be in the format `major.minor.patch`.\\n /// Returns:\\n /// -1 if current Foundry version is less than the given version\\n /// 0 if current Foundry version equals the given version\\n /// 1 if current Foundry version is greater than the given version\\n /// This result can then be used with a comparison operator against `0`.\\n /// For example, to check if the current Foundry version is greater than or equal to `1.0.0`:\\n /// `if (foundryVersionCmp(\\\"1.0.0\\\") >= 0) { ... }`\\n function foundryVersionCmp(string calldata version) external view returns (int256);\\n\\n /// Returns the Foundry version.\\n /// Format: -+..\\n /// Sample output: 0.3.0-nightly+3cb96bde9b.1737036656.debug\\n /// Note: Build timestamps may vary slightly across platforms due to separate CI jobs.\\n /// For reliable version comparisons, use UNIX format (e.g., >= 1700000000)\\n /// to compare timestamps while ignoring minor time differences.\\n function getFoundryVersion() external view returns (string memory version);\\n\\n /// Returns the RPC url for the given alias.\\n function rpcUrl(string calldata rpcAlias) external view returns (string memory json);\\n\\n /// Returns all rpc urls and their aliases as structs.\\n function rpcUrlStructs() external view returns (Rpc[] memory urls);\\n\\n /// Returns all rpc urls and their aliases `[alias, url][]`.\\n function rpcUrls() external view returns (string[2][] memory urls);\\n\\n /// Suspends execution of the main thread for `duration` milliseconds.\\n function sleep(uint256 duration) external;\\n\\n // ======== Toml ========\\n\\n /// Checks if `key` exists in a TOML table.\\n function keyExistsToml(string calldata toml, string calldata key) external view returns (bool);\\n\\n /// Parses a string of TOML data at `key` and coerces it to `address`.\\n function parseTomlAddress(string calldata toml, string calldata key) external pure returns (address);\\n\\n /// Parses a string of TOML data at `key` and coerces it to `address[]`.\\n function parseTomlAddressArray(string calldata toml, string calldata key)\\n external\\n pure\\n returns (address[] memory);\\n\\n /// Parses a string of TOML data at `key` and coerces it to `bool`.\\n function parseTomlBool(string calldata toml, string calldata key) external pure returns (bool);\\n\\n /// Parses a string of TOML data at `key` and coerces it to `bool[]`.\\n function parseTomlBoolArray(string calldata toml, string calldata key) external pure returns (bool[] memory);\\n\\n /// Parses a string of TOML data at `key` and coerces it to `bytes`.\\n function parseTomlBytes(string calldata toml, string calldata key) external pure returns (bytes memory);\\n\\n /// Parses a string of TOML data at `key` and coerces it to `bytes32`.\\n function parseTomlBytes32(string calldata toml, string calldata key) external pure returns (bytes32);\\n\\n /// Parses a string of TOML data at `key` and coerces it to `bytes32[]`.\\n function parseTomlBytes32Array(string calldata toml, string calldata key)\\n external\\n pure\\n returns (bytes32[] memory);\\n\\n /// Parses a string of TOML data at `key` and coerces it to `bytes[]`.\\n function parseTomlBytesArray(string calldata toml, string calldata key) external pure returns (bytes[] memory);\\n\\n /// Parses a string of TOML data at `key` and coerces it to `int256`.\\n function parseTomlInt(string calldata toml, string calldata key) external pure returns (int256);\\n\\n /// Parses a string of TOML data at `key` and coerces it to `int256[]`.\\n function parseTomlIntArray(string calldata toml, string calldata key) external pure returns (int256[] memory);\\n\\n /// Returns an array of all the keys in a TOML table.\\n function parseTomlKeys(string calldata toml, string calldata key) external pure returns (string[] memory keys);\\n\\n /// Parses a string of TOML data at `key` and coerces it to `string`.\\n function parseTomlString(string calldata toml, string calldata key) external pure returns (string memory);\\n\\n /// Parses a string of TOML data at `key` and coerces it to `string[]`.\\n function parseTomlStringArray(string calldata toml, string calldata key) external pure returns (string[] memory);\\n\\n /// Parses a string of TOML data at `key` and coerces it to type array corresponding to `typeDescription`.\\n function parseTomlTypeArray(string calldata toml, string calldata key, string calldata typeDescription)\\n external\\n pure\\n returns (bytes memory);\\n\\n /// Parses a string of TOML data and coerces it to type corresponding to `typeDescription`.\\n function parseTomlType(string calldata toml, string calldata typeDescription)\\n external\\n pure\\n returns (bytes memory);\\n\\n /// Parses a string of TOML data at `key` and coerces it to type corresponding to `typeDescription`.\\n function parseTomlType(string calldata toml, string calldata key, string calldata typeDescription)\\n external\\n pure\\n returns (bytes memory);\\n\\n /// Parses a string of TOML data at `key` and coerces it to `uint256`.\\n function parseTomlUint(string calldata toml, string calldata key) external pure returns (uint256);\\n\\n /// Parses a string of TOML data at `key` and coerces it to `uint256[]`.\\n function parseTomlUintArray(string calldata toml, string calldata key) external pure returns (uint256[] memory);\\n\\n /// ABI-encodes a TOML table.\\n function parseToml(string calldata toml) external pure returns (bytes memory abiEncodedData);\\n\\n /// ABI-encodes a TOML table at `key`.\\n function parseToml(string calldata toml, string calldata key) external pure returns (bytes memory abiEncodedData);\\n\\n /// Takes serialized JSON, converts to TOML and write a serialized TOML to a file.\\n function writeToml(string calldata json, string calldata path) external;\\n\\n /// Takes serialized JSON, converts to TOML and write a serialized TOML table to an **existing** TOML file, replacing a value with key = \\n /// This is useful to replace a specific value of a TOML file, without having to parse the entire thing.\\n function writeToml(string calldata json, string calldata path, string calldata valueKey) external;\\n\\n // ======== Utilities ========\\n\\n /// Compute the address of a contract created with CREATE2 using the given CREATE2 deployer.\\n function computeCreate2Address(bytes32 salt, bytes32 initCodeHash, address deployer)\\n external\\n pure\\n returns (address);\\n\\n /// Compute the address of a contract created with CREATE2 using the default CREATE2 deployer.\\n function computeCreate2Address(bytes32 salt, bytes32 initCodeHash) external pure returns (address);\\n\\n /// Compute the address a contract will be deployed at for a given deployer address and nonce.\\n function computeCreateAddress(address deployer, uint256 nonce) external pure returns (address);\\n\\n /// Utility cheatcode to copy storage of `from` contract to another `to` contract.\\n function copyStorage(address from, address to) external;\\n\\n /// Returns ENS namehash for provided string.\\n function ensNamehash(string calldata name) external pure returns (bytes32);\\n\\n /// Gets the label for the specified address.\\n function getLabel(address account) external view returns (string memory currentLabel);\\n\\n /// Labels an address in call traces.\\n function label(address account, string calldata newLabel) external;\\n\\n /// Pauses collection of call traces. Useful in cases when you want to skip tracing of\\n /// complex calls which are not useful for debugging.\\n function pauseTracing() external view;\\n\\n /// Returns a random `address`.\\n function randomAddress() external returns (address);\\n\\n /// Returns a random `bool`.\\n function randomBool() external view returns (bool);\\n\\n /// Returns a random byte array value of the given length.\\n function randomBytes(uint256 len) external view returns (bytes memory);\\n\\n /// Returns a random fixed-size byte array of length 4.\\n function randomBytes4() external view returns (bytes4);\\n\\n /// Returns a random fixed-size byte array of length 8.\\n function randomBytes8() external view returns (bytes8);\\n\\n /// Returns a random `int256` value.\\n function randomInt() external view returns (int256);\\n\\n /// Returns a random `int256` value of given bits.\\n function randomInt(uint256 bits) external view returns (int256);\\n\\n /// Returns a random uint256 value.\\n function randomUint() external returns (uint256);\\n\\n /// Returns random uint256 value between the provided range (=min..=max).\\n function randomUint(uint256 min, uint256 max) external returns (uint256);\\n\\n /// Returns a random `uint256` value of given bits.\\n function randomUint(uint256 bits) external view returns (uint256);\\n\\n /// Unpauses collection of call traces.\\n function resumeTracing() external view;\\n\\n /// Utility cheatcode to set arbitrary storage for given target address.\\n function setArbitraryStorage(address target) external;\\n\\n /// Encodes a `bytes` value to a base64url string.\\n function toBase64URL(bytes calldata data) external pure returns (string memory);\\n\\n /// Encodes a `string` value to a base64url string.\\n function toBase64URL(string calldata data) external pure returns (string memory);\\n\\n /// Encodes a `bytes` value to a base64 string.\\n function toBase64(bytes calldata data) external pure returns (string memory);\\n\\n /// Encodes a `string` value to a base64 string.\\n function toBase64(string calldata data) external pure returns (string memory);\\n}\\n\\n/// The `Vm` interface does allow manipulation of the EVM state. These are all intended to be used\\n/// in tests, but it is not recommended to use these cheats in scripts.\\ninterface Vm is VmSafe {\\n // ======== EVM ========\\n\\n /// Utility cheatcode to set an EIP-2930 access list for all subsequent transactions.\\n function accessList(AccessListItem[] calldata access) external;\\n\\n /// Returns the identifier of the currently active fork. Reverts if no fork is currently active.\\n function activeFork() external view returns (uint256 forkId);\\n\\n /// In forking mode, explicitly grant the given address cheatcode access.\\n function allowCheatcodes(address account) external;\\n\\n /// Sets `block.blobbasefee`\\n function blobBaseFee(uint256 newBlobBaseFee) external;\\n\\n /// Sets the blobhashes in the transaction.\\n /// Not available on EVM versions before Cancun.\\n /// If used on unsupported EVM versions it will revert.\\n function blobhashes(bytes32[] calldata hashes) external;\\n\\n /// Sets `block.chainid`.\\n function chainId(uint256 newChainId) external;\\n\\n /// Clears all mocked calls.\\n function clearMockedCalls() external;\\n\\n /// Clones a source account code, state, balance and nonce to a target account and updates in-memory EVM state.\\n function cloneAccount(address source, address target) external;\\n\\n /// Sets `block.coinbase`.\\n function coinbase(address newCoinbase) external;\\n\\n /// Marks the slots of an account and the account address as cold.\\n function cool(address target) external;\\n\\n /// Utility cheatcode to mark specific storage slot as cold, simulating no prior read.\\n function coolSlot(address target, bytes32 slot) external;\\n\\n /// Creates a new fork with the given endpoint and the _latest_ block and returns the identifier of the fork.\\n function createFork(string calldata urlOrAlias) external returns (uint256 forkId);\\n\\n /// Creates a new fork with the given endpoint and block and returns the identifier of the fork.\\n function createFork(string calldata urlOrAlias, uint256 blockNumber) external returns (uint256 forkId);\\n\\n /// Creates a new fork with the given endpoint and at the block the given transaction was mined in,\\n /// replays all transaction mined in the block before the transaction, and returns the identifier of the fork.\\n function createFork(string calldata urlOrAlias, bytes32 txHash) external returns (uint256 forkId);\\n\\n /// Creates and also selects a new fork with the given endpoint and the latest block and returns the identifier of the fork.\\n function createSelectFork(string calldata urlOrAlias) external returns (uint256 forkId);\\n\\n /// Creates and also selects a new fork with the given endpoint and block and returns the identifier of the fork.\\n function createSelectFork(string calldata urlOrAlias, uint256 blockNumber) external returns (uint256 forkId);\\n\\n /// Creates and also selects new fork with the given endpoint and at the block the given transaction was mined in,\\n /// replays all transaction mined in the block before the transaction, returns the identifier of the fork.\\n function createSelectFork(string calldata urlOrAlias, bytes32 txHash) external returns (uint256 forkId);\\n\\n /// Sets an address' balance.\\n function deal(address account, uint256 newBalance) external;\\n\\n /// Removes the snapshot with the given ID created by `snapshot`.\\n /// Takes the snapshot ID to delete.\\n /// Returns `true` if the snapshot was successfully deleted.\\n /// Returns `false` if the snapshot does not exist.\\n function deleteStateSnapshot(uint256 snapshotId) external returns (bool success);\\n\\n /// Removes _all_ snapshots previously created by `snapshot`.\\n function deleteStateSnapshots() external;\\n\\n /// Sets `block.difficulty`.\\n /// Not available on EVM versions from Paris onwards. Use `prevrandao` instead.\\n /// Reverts if used on unsupported EVM versions.\\n function difficulty(uint256 newDifficulty) external;\\n\\n /// Dump a genesis JSON file's `allocs` to disk.\\n function dumpState(string calldata pathToStateJson) external;\\n\\n /// Sets an address' code.\\n function etch(address target, bytes calldata newRuntimeBytecode) external;\\n\\n /// Sets `block.basefee`.\\n function fee(uint256 newBasefee) external;\\n\\n /// Gets the blockhashes from the current transaction.\\n /// Not available on EVM versions before Cancun.\\n /// If used on unsupported EVM versions it will revert.\\n function getBlobhashes() external view returns (bytes32[] memory hashes);\\n\\n /// Returns true if the account is marked as persistent.\\n function isPersistent(address account) external view returns (bool persistent);\\n\\n /// Load a genesis JSON file's `allocs` into the in-memory EVM state.\\n function loadAllocs(string calldata pathToAllocsJson) external;\\n\\n /// Marks that the account(s) should use persistent storage across fork swaps in a multifork setup\\n /// Meaning, changes made to the state of this account will be kept when switching forks.\\n function makePersistent(address account) external;\\n\\n /// See `makePersistent(address)`.\\n function makePersistent(address account0, address account1) external;\\n\\n /// See `makePersistent(address)`.\\n function makePersistent(address account0, address account1, address account2) external;\\n\\n /// See `makePersistent(address)`.\\n function makePersistent(address[] calldata accounts) external;\\n\\n /// Reverts a call to an address with specified revert data.\\n function mockCallRevert(address callee, bytes calldata data, bytes calldata revertData) external;\\n\\n /// Reverts a call to an address with a specific `msg.value`, with specified revert data.\\n function mockCallRevert(address callee, uint256 msgValue, bytes calldata data, bytes calldata revertData)\\n external;\\n\\n /// Reverts a call to an address with specified revert data.\\n /// Overload to pass the function selector directly `token.approve.selector` instead of `abi.encodeWithSelector(token.approve.selector)`.\\n function mockCallRevert(address callee, bytes4 data, bytes calldata revertData) external;\\n\\n /// Reverts a call to an address with a specific `msg.value`, with specified revert data.\\n /// Overload to pass the function selector directly `token.approve.selector` instead of `abi.encodeWithSelector(token.approve.selector)`.\\n function mockCallRevert(address callee, uint256 msgValue, bytes4 data, bytes calldata revertData) external;\\n\\n /// Mocks a call to an address, returning specified data.\\n /// Calldata can either be strict or a partial match, e.g. if you only\\n /// pass a Solidity selector to the expected calldata, then the entire Solidity\\n /// function will be mocked.\\n function mockCall(address callee, bytes calldata data, bytes calldata returnData) external;\\n\\n /// Mocks a call to an address with a specific `msg.value`, returning specified data.\\n /// Calldata match takes precedence over `msg.value` in case of ambiguity.\\n function mockCall(address callee, uint256 msgValue, bytes calldata data, bytes calldata returnData) external;\\n\\n /// Mocks a call to an address, returning specified data.\\n /// Calldata can either be strict or a partial match, e.g. if you only\\n /// pass a Solidity selector to the expected calldata, then the entire Solidity\\n /// function will be mocked.\\n /// Overload to pass the function selector directly `token.approve.selector` instead of `abi.encodeWithSelector(token.approve.selector)`.\\n function mockCall(address callee, bytes4 data, bytes calldata returnData) external;\\n\\n /// Mocks a call to an address with a specific `msg.value`, returning specified data.\\n /// Calldata match takes precedence over `msg.value` in case of ambiguity.\\n /// Overload to pass the function selector directly `token.approve.selector` instead of `abi.encodeWithSelector(token.approve.selector)`.\\n function mockCall(address callee, uint256 msgValue, bytes4 data, bytes calldata returnData) external;\\n\\n /// Mocks multiple calls to an address, returning specified data for each call.\\n function mockCalls(address callee, bytes calldata data, bytes[] calldata returnData) external;\\n\\n /// Mocks multiple calls to an address with a specific `msg.value`, returning specified data for each call.\\n function mockCalls(address callee, uint256 msgValue, bytes calldata data, bytes[] calldata returnData) external;\\n\\n /// Whenever a call is made to `callee` with calldata `data`, this cheatcode instead calls\\n /// `target` with the same calldata. This functionality is similar to a delegate call made to\\n /// `target` contract from `callee`.\\n /// Can be used to substitute a call to a function with another implementation that captures\\n /// the primary logic of the original function but is easier to reason about.\\n /// If calldata is not a strict match then partial match by selector is attempted.\\n function mockFunction(address callee, address target, bytes calldata data) external;\\n\\n /// Utility cheatcode to remove any EIP-2930 access list set by `accessList` cheatcode.\\n function noAccessList() external;\\n\\n /// Sets the *next* call's `msg.sender` to be the input address.\\n function prank(address msgSender) external;\\n\\n /// Sets the *next* call's `msg.sender` to be the input address, and the `tx.origin` to be the second input.\\n function prank(address msgSender, address txOrigin) external;\\n\\n /// Sets the *next* delegate call's `msg.sender` to be the input address.\\n function prank(address msgSender, bool delegateCall) external;\\n\\n /// Sets the *next* delegate call's `msg.sender` to be the input address, and the `tx.origin` to be the second input.\\n function prank(address msgSender, address txOrigin, bool delegateCall) external;\\n\\n /// Sets `block.prevrandao`.\\n /// Not available on EVM versions before Paris. Use `difficulty` instead.\\n /// If used on unsupported EVM versions it will revert.\\n function prevrandao(bytes32 newPrevrandao) external;\\n\\n /// Sets `block.prevrandao`.\\n /// Not available on EVM versions before Paris. Use `difficulty` instead.\\n /// If used on unsupported EVM versions it will revert.\\n function prevrandao(uint256 newPrevrandao) external;\\n\\n /// Reads the current `msg.sender` and `tx.origin` from state and reports if there is any active caller modification.\\n function readCallers() external returns (CallerMode callerMode, address msgSender, address txOrigin);\\n\\n /// Resets the nonce of an account to 0 for EOAs and 1 for contract accounts.\\n function resetNonce(address account) external;\\n\\n /// Revert the state of the EVM to a previous snapshot\\n /// Takes the snapshot ID to revert to.\\n /// Returns `true` if the snapshot was successfully reverted.\\n /// Returns `false` if the snapshot does not exist.\\n /// **Note:** This does not automatically delete the snapshot. To delete the snapshot use `deleteStateSnapshot`.\\n function revertToState(uint256 snapshotId) external returns (bool success);\\n\\n /// Revert the state of the EVM to a previous snapshot and automatically deletes the snapshots\\n /// Takes the snapshot ID to revert to.\\n /// Returns `true` if the snapshot was successfully reverted and deleted.\\n /// Returns `false` if the snapshot does not exist.\\n function revertToStateAndDelete(uint256 snapshotId) external returns (bool success);\\n\\n /// Revokes persistent status from the address, previously added via `makePersistent`.\\n function revokePersistent(address account) external;\\n\\n /// See `revokePersistent(address)`.\\n function revokePersistent(address[] calldata accounts) external;\\n\\n /// Sets `block.height`.\\n function roll(uint256 newHeight) external;\\n\\n /// Updates the currently active fork to given block number\\n /// This is similar to `roll` but for the currently active fork.\\n function rollFork(uint256 blockNumber) external;\\n\\n /// Updates the currently active fork to given transaction. This will `rollFork` with the number\\n /// of the block the transaction was mined in and replays all transaction mined before it in the block.\\n function rollFork(bytes32 txHash) external;\\n\\n /// Updates the given fork to given block number.\\n function rollFork(uint256 forkId, uint256 blockNumber) external;\\n\\n /// Updates the given fork to block number of the given transaction and replays all transaction mined before it in the block.\\n function rollFork(uint256 forkId, bytes32 txHash) external;\\n\\n /// Takes a fork identifier created by `createFork` and sets the corresponding forked state as active.\\n function selectFork(uint256 forkId) external;\\n\\n /// Set blockhash for the current block.\\n /// It only sets the blockhash for blocks where `block.number - 256 <= number < block.number`.\\n function setBlockhash(uint256 blockNumber, bytes32 blockHash) external;\\n\\n /// Sets the nonce of an account. Must be higher than the current nonce of the account.\\n function setNonce(address account, uint64 newNonce) external;\\n\\n /// Sets the nonce of an account to an arbitrary value.\\n function setNonceUnsafe(address account, uint64 newNonce) external;\\n\\n /// Snapshot capture the gas usage of the last call by name from the callee perspective.\\n function snapshotGasLastCall(string calldata name) external returns (uint256 gasUsed);\\n\\n /// Snapshot capture the gas usage of the last call by name in a group from the callee perspective.\\n function snapshotGasLastCall(string calldata group, string calldata name) external returns (uint256 gasUsed);\\n\\n /// Snapshot the current state of the evm.\\n /// Returns the ID of the snapshot that was created.\\n /// To revert a snapshot use `revertToState`.\\n function snapshotState() external returns (uint256 snapshotId);\\n\\n /// Snapshot capture an arbitrary numerical value by name.\\n /// The group name is derived from the contract name.\\n function snapshotValue(string calldata name, uint256 value) external;\\n\\n /// Snapshot capture an arbitrary numerical value by name in a group.\\n function snapshotValue(string calldata group, string calldata name, uint256 value) external;\\n\\n /// Sets all subsequent calls' `msg.sender` to be the input address until `stopPrank` is called.\\n function startPrank(address msgSender) external;\\n\\n /// Sets all subsequent calls' `msg.sender` to be the input address until `stopPrank` is called, and the `tx.origin` to be the second input.\\n function startPrank(address msgSender, address txOrigin) external;\\n\\n /// Sets all subsequent delegate calls' `msg.sender` to be the input address until `stopPrank` is called.\\n function startPrank(address msgSender, bool delegateCall) external;\\n\\n /// Sets all subsequent delegate calls' `msg.sender` to be the input address until `stopPrank` is called, and the `tx.origin` to be the second input.\\n function startPrank(address msgSender, address txOrigin, bool delegateCall) external;\\n\\n /// Start a snapshot capture of the current gas usage by name.\\n /// The group name is derived from the contract name.\\n function startSnapshotGas(string calldata name) external;\\n\\n /// Start a snapshot capture of the current gas usage by name in a group.\\n function startSnapshotGas(string calldata group, string calldata name) external;\\n\\n /// Resets subsequent calls' `msg.sender` to be `address(this)`.\\n function stopPrank() external;\\n\\n /// Stop the snapshot capture of the current gas by latest snapshot name, capturing the gas used since the start.\\n function stopSnapshotGas() external returns (uint256 gasUsed);\\n\\n /// Stop the snapshot capture of the current gas usage by name, capturing the gas used since the start.\\n /// The group name is derived from the contract name.\\n function stopSnapshotGas(string calldata name) external returns (uint256 gasUsed);\\n\\n /// Stop the snapshot capture of the current gas usage by name in a group, capturing the gas used since the start.\\n function stopSnapshotGas(string calldata group, string calldata name) external returns (uint256 gasUsed);\\n\\n /// Stores a value to an address' storage slot.\\n function store(address target, bytes32 slot, bytes32 value) external;\\n\\n /// Fetches the given transaction from the active fork and executes it on the current state.\\n function transact(bytes32 txHash) external;\\n\\n /// Fetches the given transaction from the given fork and executes it on the current state.\\n function transact(uint256 forkId, bytes32 txHash) external;\\n\\n /// Sets `tx.gasprice`.\\n function txGasPrice(uint256 newGasPrice) external;\\n\\n /// Utility cheatcode to mark specific storage slot as warm, simulating a prior read.\\n function warmSlot(address target, bytes32 slot) external;\\n\\n /// Sets `block.timestamp`.\\n function warp(uint256 newTimestamp) external;\\n\\n /// `deleteSnapshot` is being deprecated in favor of `deleteStateSnapshot`. It will be removed in future versions.\\n function deleteSnapshot(uint256 snapshotId) external returns (bool success);\\n\\n /// `deleteSnapshots` is being deprecated in favor of `deleteStateSnapshots`. It will be removed in future versions.\\n function deleteSnapshots() external;\\n\\n /// `revertToAndDelete` is being deprecated in favor of `revertToStateAndDelete`. It will be removed in future versions.\\n function revertToAndDelete(uint256 snapshotId) external returns (bool success);\\n\\n /// `revertTo` is being deprecated in favor of `revertToState`. It will be removed in future versions.\\n function revertTo(uint256 snapshotId) external returns (bool success);\\n\\n /// `snapshot` is being deprecated in favor of `snapshotState`. It will be removed in future versions.\\n function snapshot() external returns (uint256 snapshotId);\\n\\n // ======== Testing ========\\n\\n /// Expect a call to an address with the specified `msg.value` and calldata, and a *minimum* amount of gas.\\n function expectCallMinGas(address callee, uint256 msgValue, uint64 minGas, bytes calldata data) external;\\n\\n /// Expect given number of calls to an address with the specified `msg.value` and calldata, and a *minimum* amount of gas.\\n function expectCallMinGas(address callee, uint256 msgValue, uint64 minGas, bytes calldata data, uint64 count)\\n external;\\n\\n /// Expects a call to an address with the specified calldata.\\n /// Calldata can either be a strict or a partial match.\\n function expectCall(address callee, bytes calldata data) external;\\n\\n /// Expects given number of calls to an address with the specified calldata.\\n function expectCall(address callee, bytes calldata data, uint64 count) external;\\n\\n /// Expects a call to an address with the specified `msg.value` and calldata.\\n function expectCall(address callee, uint256 msgValue, bytes calldata data) external;\\n\\n /// Expects given number of calls to an address with the specified `msg.value` and calldata.\\n function expectCall(address callee, uint256 msgValue, bytes calldata data, uint64 count) external;\\n\\n /// Expect a call to an address with the specified `msg.value`, gas, and calldata.\\n function expectCall(address callee, uint256 msgValue, uint64 gas, bytes calldata data) external;\\n\\n /// Expects given number of calls to an address with the specified `msg.value`, gas, and calldata.\\n function expectCall(address callee, uint256 msgValue, uint64 gas, bytes calldata data, uint64 count) external;\\n\\n /// Expects the deployment of the specified bytecode by the specified address using the CREATE opcode\\n function expectCreate(bytes calldata bytecode, address deployer) external;\\n\\n /// Expects the deployment of the specified bytecode by the specified address using the CREATE2 opcode\\n function expectCreate2(bytes calldata bytecode, address deployer) external;\\n\\n /// Prepare an expected anonymous log with (bool checkTopic1, bool checkTopic2, bool checkTopic3, bool checkData.).\\n /// Call this function, then emit an anonymous event, then call a function. Internally after the call, we check if\\n /// logs were emitted in the expected order with the expected topics and data (as specified by the booleans).\\n function expectEmitAnonymous(bool checkTopic0, bool checkTopic1, bool checkTopic2, bool checkTopic3, bool checkData)\\n external;\\n\\n /// Same as the previous method, but also checks supplied address against emitting contract.\\n function expectEmitAnonymous(\\n bool checkTopic0,\\n bool checkTopic1,\\n bool checkTopic2,\\n bool checkTopic3,\\n bool checkData,\\n address emitter\\n ) external;\\n\\n /// Prepare an expected anonymous log with all topic and data checks enabled.\\n /// Call this function, then emit an anonymous event, then call a function. Internally after the call, we check if\\n /// logs were emitted in the expected order with the expected topics and data.\\n function expectEmitAnonymous() external;\\n\\n /// Same as the previous method, but also checks supplied address against emitting contract.\\n function expectEmitAnonymous(address emitter) external;\\n\\n /// Prepare an expected log with (bool checkTopic1, bool checkTopic2, bool checkTopic3, bool checkData.).\\n /// Call this function, then emit an event, then call a function. Internally after the call, we check if\\n /// logs were emitted in the expected order with the expected topics and data (as specified by the booleans).\\n function expectEmit(bool checkTopic1, bool checkTopic2, bool checkTopic3, bool checkData) external;\\n\\n /// Same as the previous method, but also checks supplied address against emitting contract.\\n function expectEmit(bool checkTopic1, bool checkTopic2, bool checkTopic3, bool checkData, address emitter)\\n external;\\n\\n /// Prepare an expected log with all topic and data checks enabled.\\n /// Call this function, then emit an event, then call a function. Internally after the call, we check if\\n /// logs were emitted in the expected order with the expected topics and data.\\n function expectEmit() external;\\n\\n /// Same as the previous method, but also checks supplied address against emitting contract.\\n function expectEmit(address emitter) external;\\n\\n /// Expect a given number of logs with the provided topics.\\n function expectEmit(bool checkTopic1, bool checkTopic2, bool checkTopic3, bool checkData, uint64 count) external;\\n\\n /// Expect a given number of logs from a specific emitter with the provided topics.\\n function expectEmit(\\n bool checkTopic1,\\n bool checkTopic2,\\n bool checkTopic3,\\n bool checkData,\\n address emitter,\\n uint64 count\\n ) external;\\n\\n /// Expect a given number of logs with all topic and data checks enabled.\\n function expectEmit(uint64 count) external;\\n\\n /// Expect a given number of logs from a specific emitter with all topic and data checks enabled.\\n function expectEmit(address emitter, uint64 count) external;\\n\\n /// Expects an error on next call that starts with the revert data.\\n function expectPartialRevert(bytes4 revertData) external;\\n\\n /// Expects an error on next call to reverter address, that starts with the revert data.\\n function expectPartialRevert(bytes4 revertData, address reverter) external;\\n\\n /// Expects an error on next call with any revert data.\\n function expectRevert() external;\\n\\n /// Expects an error on next call that exactly matches the revert data.\\n function expectRevert(bytes4 revertData) external;\\n\\n /// Expects a `count` number of reverts from the upcoming calls from the reverter address that match the revert data.\\n function expectRevert(bytes4 revertData, address reverter, uint64 count) external;\\n\\n /// Expects a `count` number of reverts from the upcoming calls from the reverter address that exactly match the revert data.\\n function expectRevert(bytes calldata revertData, address reverter, uint64 count) external;\\n\\n /// Expects an error on next call that exactly matches the revert data.\\n function expectRevert(bytes calldata revertData) external;\\n\\n /// Expects an error with any revert data on next call to reverter address.\\n function expectRevert(address reverter) external;\\n\\n /// Expects an error from reverter address on next call, with any revert data.\\n function expectRevert(bytes4 revertData, address reverter) external;\\n\\n /// Expects an error from reverter address on next call, that exactly matches the revert data.\\n function expectRevert(bytes calldata revertData, address reverter) external;\\n\\n /// Expects a `count` number of reverts from the upcoming calls with any revert data or reverter.\\n function expectRevert(uint64 count) external;\\n\\n /// Expects a `count` number of reverts from the upcoming calls that match the revert data.\\n function expectRevert(bytes4 revertData, uint64 count) external;\\n\\n /// Expects a `count` number of reverts from the upcoming calls that exactly match the revert data.\\n function expectRevert(bytes calldata revertData, uint64 count) external;\\n\\n /// Expects a `count` number of reverts from the upcoming calls from the reverter address.\\n function expectRevert(address reverter, uint64 count) external;\\n\\n /// Only allows memory writes to offsets [0x00, 0x60) \\u222a [min, max) in the current subcontext. If any other\\n /// memory is written to, the test will fail. Can be called multiple times to add more ranges to the set.\\n function expectSafeMemory(uint64 min, uint64 max) external;\\n\\n /// Only allows memory writes to offsets [0x00, 0x60) \\u222a [min, max) in the next created subcontext.\\n /// If any other memory is written to, the test will fail. Can be called multiple times to add more ranges\\n /// to the set.\\n function expectSafeMemoryCall(uint64 min, uint64 max) external;\\n\\n /// Marks a test as skipped. Must be called at the top level of a test.\\n function skip(bool skipTest) external;\\n\\n /// Marks a test as skipped with a reason. Must be called at the top level of a test.\\n function skip(bool skipTest, string calldata reason) external;\\n\\n /// Stops all safe memory expectation in the current subcontext.\\n function stopExpectSafeMemory() external;\\n}\\n\",\"keccak256\":\"0xd91fb0df409fbd22463e937b48b9682d9333c5d4528d8fe7b36102a0323c44bf\",\"license\":\"MIT OR Apache-2.0\"},\"lib/forge-std/src/console.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity >=0.4.22 <0.9.0;\\n\\nlibrary console {\\n address constant CONSOLE_ADDRESS =\\n 0x000000000000000000636F6e736F6c652e6c6f67;\\n\\n function _sendLogPayloadImplementation(bytes memory payload) internal view {\\n address consoleAddress = CONSOLE_ADDRESS;\\n /// @solidity memory-safe-assembly\\n assembly {\\n pop(\\n staticcall(\\n gas(),\\n consoleAddress,\\n add(payload, 32),\\n mload(payload),\\n 0,\\n 0\\n )\\n )\\n }\\n }\\n\\n function _castToPure(\\n function(bytes memory) internal view fnIn\\n ) internal pure returns (function(bytes memory) pure fnOut) {\\n assembly {\\n fnOut := fnIn\\n }\\n }\\n\\n function _sendLogPayload(bytes memory payload) internal pure {\\n _castToPure(_sendLogPayloadImplementation)(payload);\\n }\\n\\n function log() internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log()\\\"));\\n }\\n\\n function logInt(int256 p0) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(int256)\\\", p0));\\n }\\n\\n function logUint(uint256 p0) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256)\\\", p0));\\n }\\n\\n function logString(string memory p0) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string)\\\", p0));\\n }\\n\\n function logBool(bool p0) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool)\\\", p0));\\n }\\n\\n function logAddress(address p0) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address)\\\", p0));\\n }\\n\\n function logBytes(bytes memory p0) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bytes)\\\", p0));\\n }\\n\\n function logBytes1(bytes1 p0) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bytes1)\\\", p0));\\n }\\n\\n function logBytes2(bytes2 p0) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bytes2)\\\", p0));\\n }\\n\\n function logBytes3(bytes3 p0) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bytes3)\\\", p0));\\n }\\n\\n function logBytes4(bytes4 p0) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bytes4)\\\", p0));\\n }\\n\\n function logBytes5(bytes5 p0) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bytes5)\\\", p0));\\n }\\n\\n function logBytes6(bytes6 p0) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bytes6)\\\", p0));\\n }\\n\\n function logBytes7(bytes7 p0) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bytes7)\\\", p0));\\n }\\n\\n function logBytes8(bytes8 p0) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bytes8)\\\", p0));\\n }\\n\\n function logBytes9(bytes9 p0) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bytes9)\\\", p0));\\n }\\n\\n function logBytes10(bytes10 p0) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bytes10)\\\", p0));\\n }\\n\\n function logBytes11(bytes11 p0) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bytes11)\\\", p0));\\n }\\n\\n function logBytes12(bytes12 p0) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bytes12)\\\", p0));\\n }\\n\\n function logBytes13(bytes13 p0) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bytes13)\\\", p0));\\n }\\n\\n function logBytes14(bytes14 p0) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bytes14)\\\", p0));\\n }\\n\\n function logBytes15(bytes15 p0) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bytes15)\\\", p0));\\n }\\n\\n function logBytes16(bytes16 p0) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bytes16)\\\", p0));\\n }\\n\\n function logBytes17(bytes17 p0) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bytes17)\\\", p0));\\n }\\n\\n function logBytes18(bytes18 p0) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bytes18)\\\", p0));\\n }\\n\\n function logBytes19(bytes19 p0) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bytes19)\\\", p0));\\n }\\n\\n function logBytes20(bytes20 p0) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bytes20)\\\", p0));\\n }\\n\\n function logBytes21(bytes21 p0) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bytes21)\\\", p0));\\n }\\n\\n function logBytes22(bytes22 p0) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bytes22)\\\", p0));\\n }\\n\\n function logBytes23(bytes23 p0) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bytes23)\\\", p0));\\n }\\n\\n function logBytes24(bytes24 p0) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bytes24)\\\", p0));\\n }\\n\\n function logBytes25(bytes25 p0) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bytes25)\\\", p0));\\n }\\n\\n function logBytes26(bytes26 p0) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bytes26)\\\", p0));\\n }\\n\\n function logBytes27(bytes27 p0) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bytes27)\\\", p0));\\n }\\n\\n function logBytes28(bytes28 p0) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bytes28)\\\", p0));\\n }\\n\\n function logBytes29(bytes29 p0) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bytes29)\\\", p0));\\n }\\n\\n function logBytes30(bytes30 p0) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bytes30)\\\", p0));\\n }\\n\\n function logBytes31(bytes31 p0) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bytes31)\\\", p0));\\n }\\n\\n function logBytes32(bytes32 p0) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bytes32)\\\", p0));\\n }\\n\\n function log(uint256 p0) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256)\\\", p0));\\n }\\n\\n function log(int256 p0) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(int256)\\\", p0));\\n }\\n\\n function log(string memory p0) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string)\\\", p0));\\n }\\n\\n function log(bool p0) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool)\\\", p0));\\n }\\n\\n function log(address p0) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address)\\\", p0));\\n }\\n\\n function log(uint256 p0, uint256 p1) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,uint256)\\\", p0, p1));\\n }\\n\\n function log(uint256 p0, string memory p1) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,string)\\\", p0, p1));\\n }\\n\\n function log(uint256 p0, bool p1) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,bool)\\\", p0, p1));\\n }\\n\\n function log(uint256 p0, address p1) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,address)\\\", p0, p1));\\n }\\n\\n function log(string memory p0, uint256 p1) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,uint256)\\\", p0, p1));\\n }\\n\\n function log(string memory p0, int256 p1) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,int256)\\\", p0, p1));\\n }\\n\\n function log(string memory p0, string memory p1) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,string)\\\", p0, p1));\\n }\\n\\n function log(string memory p0, bool p1) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,bool)\\\", p0, p1));\\n }\\n\\n function log(string memory p0, address p1) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,address)\\\", p0, p1));\\n }\\n\\n function log(bool p0, uint256 p1) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,uint256)\\\", p0, p1));\\n }\\n\\n function log(bool p0, string memory p1) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,string)\\\", p0, p1));\\n }\\n\\n function log(bool p0, bool p1) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,bool)\\\", p0, p1));\\n }\\n\\n function log(bool p0, address p1) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,address)\\\", p0, p1));\\n }\\n\\n function log(address p0, uint256 p1) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,uint256)\\\", p0, p1));\\n }\\n\\n function log(address p0, string memory p1) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,string)\\\", p0, p1));\\n }\\n\\n function log(address p0, bool p1) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,bool)\\\", p0, p1));\\n }\\n\\n function log(address p0, address p1) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,address)\\\", p0, p1));\\n }\\n\\n function log(uint256 p0, uint256 p1, uint256 p2) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,uint256,uint256)\\\", p0, p1, p2));\\n }\\n\\n function log(uint256 p0, uint256 p1, string memory p2) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,uint256,string)\\\", p0, p1, p2));\\n }\\n\\n function log(uint256 p0, uint256 p1, bool p2) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,uint256,bool)\\\", p0, p1, p2));\\n }\\n\\n function log(uint256 p0, uint256 p1, address p2) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,uint256,address)\\\", p0, p1, p2));\\n }\\n\\n function log(uint256 p0, string memory p1, uint256 p2) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,string,uint256)\\\", p0, p1, p2));\\n }\\n\\n function log(uint256 p0, string memory p1, string memory p2) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,string,string)\\\", p0, p1, p2));\\n }\\n\\n function log(uint256 p0, string memory p1, bool p2) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,string,bool)\\\", p0, p1, p2));\\n }\\n\\n function log(uint256 p0, string memory p1, address p2) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,string,address)\\\", p0, p1, p2));\\n }\\n\\n function log(uint256 p0, bool p1, uint256 p2) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,bool,uint256)\\\", p0, p1, p2));\\n }\\n\\n function log(uint256 p0, bool p1, string memory p2) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,bool,string)\\\", p0, p1, p2));\\n }\\n\\n function log(uint256 p0, bool p1, bool p2) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,bool,bool)\\\", p0, p1, p2));\\n }\\n\\n function log(uint256 p0, bool p1, address p2) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,bool,address)\\\", p0, p1, p2));\\n }\\n\\n function log(uint256 p0, address p1, uint256 p2) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,address,uint256)\\\", p0, p1, p2));\\n }\\n\\n function log(uint256 p0, address p1, string memory p2) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,address,string)\\\", p0, p1, p2));\\n }\\n\\n function log(uint256 p0, address p1, bool p2) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,address,bool)\\\", p0, p1, p2));\\n }\\n\\n function log(uint256 p0, address p1, address p2) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,address,address)\\\", p0, p1, p2));\\n }\\n\\n function log(string memory p0, uint256 p1, uint256 p2) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,uint256,uint256)\\\", p0, p1, p2));\\n }\\n\\n function log(string memory p0, uint256 p1, string memory p2) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,uint256,string)\\\", p0, p1, p2));\\n }\\n\\n function log(string memory p0, uint256 p1, bool p2) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,uint256,bool)\\\", p0, p1, p2));\\n }\\n\\n function log(string memory p0, uint256 p1, address p2) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,uint256,address)\\\", p0, p1, p2));\\n }\\n\\n function log(string memory p0, string memory p1, uint256 p2) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,string,uint256)\\\", p0, p1, p2));\\n }\\n\\n function log(string memory p0, string memory p1, string memory p2) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,string,string)\\\", p0, p1, p2));\\n }\\n\\n function log(string memory p0, string memory p1, bool p2) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,string,bool)\\\", p0, p1, p2));\\n }\\n\\n function log(string memory p0, string memory p1, address p2) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,string,address)\\\", p0, p1, p2));\\n }\\n\\n function log(string memory p0, bool p1, uint256 p2) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,bool,uint256)\\\", p0, p1, p2));\\n }\\n\\n function log(string memory p0, bool p1, string memory p2) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,bool,string)\\\", p0, p1, p2));\\n }\\n\\n function log(string memory p0, bool p1, bool p2) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,bool,bool)\\\", p0, p1, p2));\\n }\\n\\n function log(string memory p0, bool p1, address p2) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,bool,address)\\\", p0, p1, p2));\\n }\\n\\n function log(string memory p0, address p1, uint256 p2) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,address,uint256)\\\", p0, p1, p2));\\n }\\n\\n function log(string memory p0, address p1, string memory p2) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,address,string)\\\", p0, p1, p2));\\n }\\n\\n function log(string memory p0, address p1, bool p2) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,address,bool)\\\", p0, p1, p2));\\n }\\n\\n function log(string memory p0, address p1, address p2) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,address,address)\\\", p0, p1, p2));\\n }\\n\\n function log(bool p0, uint256 p1, uint256 p2) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,uint256,uint256)\\\", p0, p1, p2));\\n }\\n\\n function log(bool p0, uint256 p1, string memory p2) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,uint256,string)\\\", p0, p1, p2));\\n }\\n\\n function log(bool p0, uint256 p1, bool p2) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,uint256,bool)\\\", p0, p1, p2));\\n }\\n\\n function log(bool p0, uint256 p1, address p2) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,uint256,address)\\\", p0, p1, p2));\\n }\\n\\n function log(bool p0, string memory p1, uint256 p2) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,string,uint256)\\\", p0, p1, p2));\\n }\\n\\n function log(bool p0, string memory p1, string memory p2) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,string,string)\\\", p0, p1, p2));\\n }\\n\\n function log(bool p0, string memory p1, bool p2) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,string,bool)\\\", p0, p1, p2));\\n }\\n\\n function log(bool p0, string memory p1, address p2) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,string,address)\\\", p0, p1, p2));\\n }\\n\\n function log(bool p0, bool p1, uint256 p2) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,bool,uint256)\\\", p0, p1, p2));\\n }\\n\\n function log(bool p0, bool p1, string memory p2) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,bool,string)\\\", p0, p1, p2));\\n }\\n\\n function log(bool p0, bool p1, bool p2) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,bool,bool)\\\", p0, p1, p2));\\n }\\n\\n function log(bool p0, bool p1, address p2) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,bool,address)\\\", p0, p1, p2));\\n }\\n\\n function log(bool p0, address p1, uint256 p2) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,address,uint256)\\\", p0, p1, p2));\\n }\\n\\n function log(bool p0, address p1, string memory p2) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,address,string)\\\", p0, p1, p2));\\n }\\n\\n function log(bool p0, address p1, bool p2) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,address,bool)\\\", p0, p1, p2));\\n }\\n\\n function log(bool p0, address p1, address p2) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,address,address)\\\", p0, p1, p2));\\n }\\n\\n function log(address p0, uint256 p1, uint256 p2) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,uint256,uint256)\\\", p0, p1, p2));\\n }\\n\\n function log(address p0, uint256 p1, string memory p2) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,uint256,string)\\\", p0, p1, p2));\\n }\\n\\n function log(address p0, uint256 p1, bool p2) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,uint256,bool)\\\", p0, p1, p2));\\n }\\n\\n function log(address p0, uint256 p1, address p2) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,uint256,address)\\\", p0, p1, p2));\\n }\\n\\n function log(address p0, string memory p1, uint256 p2) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,string,uint256)\\\", p0, p1, p2));\\n }\\n\\n function log(address p0, string memory p1, string memory p2) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,string,string)\\\", p0, p1, p2));\\n }\\n\\n function log(address p0, string memory p1, bool p2) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,string,bool)\\\", p0, p1, p2));\\n }\\n\\n function log(address p0, string memory p1, address p2) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,string,address)\\\", p0, p1, p2));\\n }\\n\\n function log(address p0, bool p1, uint256 p2) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,bool,uint256)\\\", p0, p1, p2));\\n }\\n\\n function log(address p0, bool p1, string memory p2) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,bool,string)\\\", p0, p1, p2));\\n }\\n\\n function log(address p0, bool p1, bool p2) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,bool,bool)\\\", p0, p1, p2));\\n }\\n\\n function log(address p0, bool p1, address p2) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,bool,address)\\\", p0, p1, p2));\\n }\\n\\n function log(address p0, address p1, uint256 p2) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,address,uint256)\\\", p0, p1, p2));\\n }\\n\\n function log(address p0, address p1, string memory p2) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,address,string)\\\", p0, p1, p2));\\n }\\n\\n function log(address p0, address p1, bool p2) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,address,bool)\\\", p0, p1, p2));\\n }\\n\\n function log(address p0, address p1, address p2) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,address,address)\\\", p0, p1, p2));\\n }\\n\\n function log(uint256 p0, uint256 p1, uint256 p2, uint256 p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,uint256,uint256,uint256)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(uint256 p0, uint256 p1, uint256 p2, string memory p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,uint256,uint256,string)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(uint256 p0, uint256 p1, uint256 p2, bool p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,uint256,uint256,bool)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(uint256 p0, uint256 p1, uint256 p2, address p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,uint256,uint256,address)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(uint256 p0, uint256 p1, string memory p2, uint256 p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,uint256,string,uint256)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(uint256 p0, uint256 p1, string memory p2, string memory p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,uint256,string,string)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(uint256 p0, uint256 p1, string memory p2, bool p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,uint256,string,bool)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(uint256 p0, uint256 p1, string memory p2, address p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,uint256,string,address)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(uint256 p0, uint256 p1, bool p2, uint256 p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,uint256,bool,uint256)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(uint256 p0, uint256 p1, bool p2, string memory p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,uint256,bool,string)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(uint256 p0, uint256 p1, bool p2, bool p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,uint256,bool,bool)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(uint256 p0, uint256 p1, bool p2, address p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,uint256,bool,address)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(uint256 p0, uint256 p1, address p2, uint256 p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,uint256,address,uint256)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(uint256 p0, uint256 p1, address p2, string memory p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,uint256,address,string)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(uint256 p0, uint256 p1, address p2, bool p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,uint256,address,bool)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(uint256 p0, uint256 p1, address p2, address p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,uint256,address,address)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(uint256 p0, string memory p1, uint256 p2, uint256 p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,string,uint256,uint256)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(uint256 p0, string memory p1, uint256 p2, string memory p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,string,uint256,string)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(uint256 p0, string memory p1, uint256 p2, bool p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,string,uint256,bool)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(uint256 p0, string memory p1, uint256 p2, address p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,string,uint256,address)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(uint256 p0, string memory p1, string memory p2, uint256 p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,string,string,uint256)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(uint256 p0, string memory p1, string memory p2, string memory p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,string,string,string)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(uint256 p0, string memory p1, string memory p2, bool p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,string,string,bool)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(uint256 p0, string memory p1, string memory p2, address p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,string,string,address)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(uint256 p0, string memory p1, bool p2, uint256 p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,string,bool,uint256)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(uint256 p0, string memory p1, bool p2, string memory p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,string,bool,string)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(uint256 p0, string memory p1, bool p2, bool p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,string,bool,bool)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(uint256 p0, string memory p1, bool p2, address p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,string,bool,address)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(uint256 p0, string memory p1, address p2, uint256 p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,string,address,uint256)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(uint256 p0, string memory p1, address p2, string memory p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,string,address,string)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(uint256 p0, string memory p1, address p2, bool p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,string,address,bool)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(uint256 p0, string memory p1, address p2, address p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,string,address,address)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(uint256 p0, bool p1, uint256 p2, uint256 p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,bool,uint256,uint256)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(uint256 p0, bool p1, uint256 p2, string memory p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,bool,uint256,string)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(uint256 p0, bool p1, uint256 p2, bool p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,bool,uint256,bool)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(uint256 p0, bool p1, uint256 p2, address p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,bool,uint256,address)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(uint256 p0, bool p1, string memory p2, uint256 p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,bool,string,uint256)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(uint256 p0, bool p1, string memory p2, string memory p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,bool,string,string)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(uint256 p0, bool p1, string memory p2, bool p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,bool,string,bool)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(uint256 p0, bool p1, string memory p2, address p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,bool,string,address)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(uint256 p0, bool p1, bool p2, uint256 p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,bool,bool,uint256)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(uint256 p0, bool p1, bool p2, string memory p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,bool,bool,string)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(uint256 p0, bool p1, bool p2, bool p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,bool,bool,bool)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(uint256 p0, bool p1, bool p2, address p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,bool,bool,address)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(uint256 p0, bool p1, address p2, uint256 p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,bool,address,uint256)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(uint256 p0, bool p1, address p2, string memory p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,bool,address,string)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(uint256 p0, bool p1, address p2, bool p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,bool,address,bool)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(uint256 p0, bool p1, address p2, address p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,bool,address,address)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(uint256 p0, address p1, uint256 p2, uint256 p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,address,uint256,uint256)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(uint256 p0, address p1, uint256 p2, string memory p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,address,uint256,string)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(uint256 p0, address p1, uint256 p2, bool p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,address,uint256,bool)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(uint256 p0, address p1, uint256 p2, address p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,address,uint256,address)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(uint256 p0, address p1, string memory p2, uint256 p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,address,string,uint256)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(uint256 p0, address p1, string memory p2, string memory p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,address,string,string)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(uint256 p0, address p1, string memory p2, bool p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,address,string,bool)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(uint256 p0, address p1, string memory p2, address p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,address,string,address)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(uint256 p0, address p1, bool p2, uint256 p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,address,bool,uint256)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(uint256 p0, address p1, bool p2, string memory p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,address,bool,string)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(uint256 p0, address p1, bool p2, bool p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,address,bool,bool)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(uint256 p0, address p1, bool p2, address p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,address,bool,address)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(uint256 p0, address p1, address p2, uint256 p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,address,address,uint256)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(uint256 p0, address p1, address p2, string memory p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,address,address,string)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(uint256 p0, address p1, address p2, bool p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,address,address,bool)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(uint256 p0, address p1, address p2, address p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,address,address,address)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(string memory p0, uint256 p1, uint256 p2, uint256 p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,uint256,uint256,uint256)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(string memory p0, uint256 p1, uint256 p2, string memory p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,uint256,uint256,string)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(string memory p0, uint256 p1, uint256 p2, bool p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,uint256,uint256,bool)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(string memory p0, uint256 p1, uint256 p2, address p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,uint256,uint256,address)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(string memory p0, uint256 p1, string memory p2, uint256 p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,uint256,string,uint256)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(string memory p0, uint256 p1, string memory p2, string memory p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,uint256,string,string)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(string memory p0, uint256 p1, string memory p2, bool p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,uint256,string,bool)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(string memory p0, uint256 p1, string memory p2, address p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,uint256,string,address)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(string memory p0, uint256 p1, bool p2, uint256 p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,uint256,bool,uint256)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(string memory p0, uint256 p1, bool p2, string memory p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,uint256,bool,string)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(string memory p0, uint256 p1, bool p2, bool p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,uint256,bool,bool)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(string memory p0, uint256 p1, bool p2, address p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,uint256,bool,address)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(string memory p0, uint256 p1, address p2, uint256 p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,uint256,address,uint256)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(string memory p0, uint256 p1, address p2, string memory p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,uint256,address,string)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(string memory p0, uint256 p1, address p2, bool p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,uint256,address,bool)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(string memory p0, uint256 p1, address p2, address p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,uint256,address,address)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(string memory p0, string memory p1, uint256 p2, uint256 p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,string,uint256,uint256)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(string memory p0, string memory p1, uint256 p2, string memory p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,string,uint256,string)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(string memory p0, string memory p1, uint256 p2, bool p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,string,uint256,bool)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(string memory p0, string memory p1, uint256 p2, address p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,string,uint256,address)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(string memory p0, string memory p1, string memory p2, uint256 p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,string,string,uint256)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(string memory p0, string memory p1, string memory p2, string memory p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,string,string,string)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(string memory p0, string memory p1, string memory p2, bool p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,string,string,bool)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(string memory p0, string memory p1, string memory p2, address p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,string,string,address)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(string memory p0, string memory p1, bool p2, uint256 p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,string,bool,uint256)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(string memory p0, string memory p1, bool p2, string memory p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,string,bool,string)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(string memory p0, string memory p1, bool p2, bool p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,string,bool,bool)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(string memory p0, string memory p1, bool p2, address p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,string,bool,address)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(string memory p0, string memory p1, address p2, uint256 p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,string,address,uint256)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(string memory p0, string memory p1, address p2, string memory p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,string,address,string)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(string memory p0, string memory p1, address p2, bool p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,string,address,bool)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(string memory p0, string memory p1, address p2, address p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,string,address,address)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(string memory p0, bool p1, uint256 p2, uint256 p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,bool,uint256,uint256)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(string memory p0, bool p1, uint256 p2, string memory p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,bool,uint256,string)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(string memory p0, bool p1, uint256 p2, bool p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,bool,uint256,bool)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(string memory p0, bool p1, uint256 p2, address p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,bool,uint256,address)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(string memory p0, bool p1, string memory p2, uint256 p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,bool,string,uint256)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(string memory p0, bool p1, string memory p2, string memory p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,bool,string,string)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(string memory p0, bool p1, string memory p2, bool p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,bool,string,bool)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(string memory p0, bool p1, string memory p2, address p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,bool,string,address)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(string memory p0, bool p1, bool p2, uint256 p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,bool,bool,uint256)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(string memory p0, bool p1, bool p2, string memory p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,bool,bool,string)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(string memory p0, bool p1, bool p2, bool p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,bool,bool,bool)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(string memory p0, bool p1, bool p2, address p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,bool,bool,address)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(string memory p0, bool p1, address p2, uint256 p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,bool,address,uint256)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(string memory p0, bool p1, address p2, string memory p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,bool,address,string)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(string memory p0, bool p1, address p2, bool p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,bool,address,bool)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(string memory p0, bool p1, address p2, address p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,bool,address,address)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(string memory p0, address p1, uint256 p2, uint256 p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,address,uint256,uint256)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(string memory p0, address p1, uint256 p2, string memory p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,address,uint256,string)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(string memory p0, address p1, uint256 p2, bool p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,address,uint256,bool)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(string memory p0, address p1, uint256 p2, address p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,address,uint256,address)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(string memory p0, address p1, string memory p2, uint256 p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,address,string,uint256)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(string memory p0, address p1, string memory p2, string memory p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,address,string,string)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(string memory p0, address p1, string memory p2, bool p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,address,string,bool)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(string memory p0, address p1, string memory p2, address p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,address,string,address)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(string memory p0, address p1, bool p2, uint256 p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,address,bool,uint256)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(string memory p0, address p1, bool p2, string memory p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,address,bool,string)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(string memory p0, address p1, bool p2, bool p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,address,bool,bool)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(string memory p0, address p1, bool p2, address p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,address,bool,address)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(string memory p0, address p1, address p2, uint256 p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,address,address,uint256)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(string memory p0, address p1, address p2, string memory p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,address,address,string)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(string memory p0, address p1, address p2, bool p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,address,address,bool)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(string memory p0, address p1, address p2, address p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,address,address,address)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(bool p0, uint256 p1, uint256 p2, uint256 p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,uint256,uint256,uint256)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(bool p0, uint256 p1, uint256 p2, string memory p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,uint256,uint256,string)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(bool p0, uint256 p1, uint256 p2, bool p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,uint256,uint256,bool)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(bool p0, uint256 p1, uint256 p2, address p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,uint256,uint256,address)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(bool p0, uint256 p1, string memory p2, uint256 p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,uint256,string,uint256)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(bool p0, uint256 p1, string memory p2, string memory p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,uint256,string,string)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(bool p0, uint256 p1, string memory p2, bool p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,uint256,string,bool)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(bool p0, uint256 p1, string memory p2, address p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,uint256,string,address)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(bool p0, uint256 p1, bool p2, uint256 p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,uint256,bool,uint256)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(bool p0, uint256 p1, bool p2, string memory p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,uint256,bool,string)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(bool p0, uint256 p1, bool p2, bool p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,uint256,bool,bool)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(bool p0, uint256 p1, bool p2, address p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,uint256,bool,address)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(bool p0, uint256 p1, address p2, uint256 p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,uint256,address,uint256)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(bool p0, uint256 p1, address p2, string memory p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,uint256,address,string)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(bool p0, uint256 p1, address p2, bool p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,uint256,address,bool)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(bool p0, uint256 p1, address p2, address p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,uint256,address,address)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(bool p0, string memory p1, uint256 p2, uint256 p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,string,uint256,uint256)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(bool p0, string memory p1, uint256 p2, string memory p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,string,uint256,string)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(bool p0, string memory p1, uint256 p2, bool p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,string,uint256,bool)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(bool p0, string memory p1, uint256 p2, address p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,string,uint256,address)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(bool p0, string memory p1, string memory p2, uint256 p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,string,string,uint256)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(bool p0, string memory p1, string memory p2, string memory p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,string,string,string)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(bool p0, string memory p1, string memory p2, bool p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,string,string,bool)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(bool p0, string memory p1, string memory p2, address p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,string,string,address)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(bool p0, string memory p1, bool p2, uint256 p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,string,bool,uint256)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(bool p0, string memory p1, bool p2, string memory p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,string,bool,string)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(bool p0, string memory p1, bool p2, bool p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,string,bool,bool)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(bool p0, string memory p1, bool p2, address p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,string,bool,address)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(bool p0, string memory p1, address p2, uint256 p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,string,address,uint256)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(bool p0, string memory p1, address p2, string memory p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,string,address,string)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(bool p0, string memory p1, address p2, bool p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,string,address,bool)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(bool p0, string memory p1, address p2, address p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,string,address,address)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(bool p0, bool p1, uint256 p2, uint256 p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,bool,uint256,uint256)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(bool p0, bool p1, uint256 p2, string memory p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,bool,uint256,string)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(bool p0, bool p1, uint256 p2, bool p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,bool,uint256,bool)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(bool p0, bool p1, uint256 p2, address p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,bool,uint256,address)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(bool p0, bool p1, string memory p2, uint256 p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,bool,string,uint256)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(bool p0, bool p1, string memory p2, string memory p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,bool,string,string)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(bool p0, bool p1, string memory p2, bool p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,bool,string,bool)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(bool p0, bool p1, string memory p2, address p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,bool,string,address)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(bool p0, bool p1, bool p2, uint256 p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,bool,bool,uint256)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(bool p0, bool p1, bool p2, string memory p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,bool,bool,string)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(bool p0, bool p1, bool p2, bool p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,bool,bool,bool)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(bool p0, bool p1, bool p2, address p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,bool,bool,address)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(bool p0, bool p1, address p2, uint256 p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,bool,address,uint256)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(bool p0, bool p1, address p2, string memory p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,bool,address,string)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(bool p0, bool p1, address p2, bool p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,bool,address,bool)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(bool p0, bool p1, address p2, address p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,bool,address,address)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(bool p0, address p1, uint256 p2, uint256 p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,address,uint256,uint256)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(bool p0, address p1, uint256 p2, string memory p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,address,uint256,string)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(bool p0, address p1, uint256 p2, bool p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,address,uint256,bool)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(bool p0, address p1, uint256 p2, address p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,address,uint256,address)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(bool p0, address p1, string memory p2, uint256 p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,address,string,uint256)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(bool p0, address p1, string memory p2, string memory p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,address,string,string)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(bool p0, address p1, string memory p2, bool p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,address,string,bool)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(bool p0, address p1, string memory p2, address p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,address,string,address)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(bool p0, address p1, bool p2, uint256 p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,address,bool,uint256)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(bool p0, address p1, bool p2, string memory p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,address,bool,string)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(bool p0, address p1, bool p2, bool p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,address,bool,bool)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(bool p0, address p1, bool p2, address p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,address,bool,address)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(bool p0, address p1, address p2, uint256 p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,address,address,uint256)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(bool p0, address p1, address p2, string memory p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,address,address,string)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(bool p0, address p1, address p2, bool p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,address,address,bool)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(bool p0, address p1, address p2, address p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,address,address,address)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(address p0, uint256 p1, uint256 p2, uint256 p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,uint256,uint256,uint256)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(address p0, uint256 p1, uint256 p2, string memory p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,uint256,uint256,string)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(address p0, uint256 p1, uint256 p2, bool p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,uint256,uint256,bool)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(address p0, uint256 p1, uint256 p2, address p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,uint256,uint256,address)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(address p0, uint256 p1, string memory p2, uint256 p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,uint256,string,uint256)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(address p0, uint256 p1, string memory p2, string memory p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,uint256,string,string)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(address p0, uint256 p1, string memory p2, bool p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,uint256,string,bool)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(address p0, uint256 p1, string memory p2, address p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,uint256,string,address)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(address p0, uint256 p1, bool p2, uint256 p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,uint256,bool,uint256)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(address p0, uint256 p1, bool p2, string memory p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,uint256,bool,string)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(address p0, uint256 p1, bool p2, bool p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,uint256,bool,bool)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(address p0, uint256 p1, bool p2, address p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,uint256,bool,address)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(address p0, uint256 p1, address p2, uint256 p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,uint256,address,uint256)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(address p0, uint256 p1, address p2, string memory p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,uint256,address,string)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(address p0, uint256 p1, address p2, bool p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,uint256,address,bool)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(address p0, uint256 p1, address p2, address p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,uint256,address,address)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(address p0, string memory p1, uint256 p2, uint256 p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,string,uint256,uint256)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(address p0, string memory p1, uint256 p2, string memory p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,string,uint256,string)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(address p0, string memory p1, uint256 p2, bool p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,string,uint256,bool)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(address p0, string memory p1, uint256 p2, address p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,string,uint256,address)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(address p0, string memory p1, string memory p2, uint256 p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,string,string,uint256)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(address p0, string memory p1, string memory p2, string memory p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,string,string,string)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(address p0, string memory p1, string memory p2, bool p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,string,string,bool)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(address p0, string memory p1, string memory p2, address p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,string,string,address)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(address p0, string memory p1, bool p2, uint256 p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,string,bool,uint256)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(address p0, string memory p1, bool p2, string memory p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,string,bool,string)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(address p0, string memory p1, bool p2, bool p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,string,bool,bool)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(address p0, string memory p1, bool p2, address p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,string,bool,address)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(address p0, string memory p1, address p2, uint256 p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,string,address,uint256)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(address p0, string memory p1, address p2, string memory p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,string,address,string)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(address p0, string memory p1, address p2, bool p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,string,address,bool)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(address p0, string memory p1, address p2, address p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,string,address,address)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(address p0, bool p1, uint256 p2, uint256 p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,bool,uint256,uint256)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(address p0, bool p1, uint256 p2, string memory p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,bool,uint256,string)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(address p0, bool p1, uint256 p2, bool p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,bool,uint256,bool)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(address p0, bool p1, uint256 p2, address p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,bool,uint256,address)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(address p0, bool p1, string memory p2, uint256 p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,bool,string,uint256)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(address p0, bool p1, string memory p2, string memory p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,bool,string,string)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(address p0, bool p1, string memory p2, bool p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,bool,string,bool)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(address p0, bool p1, string memory p2, address p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,bool,string,address)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(address p0, bool p1, bool p2, uint256 p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,bool,bool,uint256)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(address p0, bool p1, bool p2, string memory p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,bool,bool,string)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(address p0, bool p1, bool p2, bool p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,bool,bool,bool)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(address p0, bool p1, bool p2, address p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,bool,bool,address)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(address p0, bool p1, address p2, uint256 p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,bool,address,uint256)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(address p0, bool p1, address p2, string memory p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,bool,address,string)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(address p0, bool p1, address p2, bool p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,bool,address,bool)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(address p0, bool p1, address p2, address p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,bool,address,address)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(address p0, address p1, uint256 p2, uint256 p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,address,uint256,uint256)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(address p0, address p1, uint256 p2, string memory p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,address,uint256,string)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(address p0, address p1, uint256 p2, bool p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,address,uint256,bool)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(address p0, address p1, uint256 p2, address p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,address,uint256,address)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(address p0, address p1, string memory p2, uint256 p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,address,string,uint256)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(address p0, address p1, string memory p2, string memory p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,address,string,string)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(address p0, address p1, string memory p2, bool p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,address,string,bool)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(address p0, address p1, string memory p2, address p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,address,string,address)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(address p0, address p1, bool p2, uint256 p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,address,bool,uint256)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(address p0, address p1, bool p2, string memory p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,address,bool,string)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(address p0, address p1, bool p2, bool p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,address,bool,bool)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(address p0, address p1, bool p2, address p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,address,bool,address)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(address p0, address p1, address p2, uint256 p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,address,address,uint256)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(address p0, address p1, address p2, string memory p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,address,address,string)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(address p0, address p1, address p2, bool p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,address,address,bool)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(address p0, address p1, address p2, address p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,address,address,address)\\\", p0, p1, p2, p3));\\n }\\n}\\n\",\"keccak256\":\"0x4bbf47eb762cef93729d6ef15e78789957147039b113e5d4df48e3d3fd16d0f5\",\"license\":\"MIT\"},\"lib/forge-std/src/console2.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity >=0.4.22 <0.9.0;\\n\\nimport {console as console2} from \\\"./console.sol\\\";\\n\",\"keccak256\":\"0x3b8fe79f48f065a4e4d35362171304a33784c3a90febae5f2787805a438de12f\",\"license\":\"MIT\"},\"lib/forge-std/src/interfaces/IMulticall3.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity >=0.6.2 <0.9.0;\\n\\npragma experimental ABIEncoderV2;\\n\\ninterface IMulticall3 {\\n struct Call {\\n address target;\\n bytes callData;\\n }\\n\\n struct Call3 {\\n address target;\\n bool allowFailure;\\n bytes callData;\\n }\\n\\n struct Call3Value {\\n address target;\\n bool allowFailure;\\n uint256 value;\\n bytes callData;\\n }\\n\\n struct Result {\\n bool success;\\n bytes returnData;\\n }\\n\\n function aggregate(Call[] calldata calls)\\n external\\n payable\\n returns (uint256 blockNumber, bytes[] memory returnData);\\n\\n function aggregate3(Call3[] calldata calls) external payable returns (Result[] memory returnData);\\n\\n function aggregate3Value(Call3Value[] calldata calls) external payable returns (Result[] memory returnData);\\n\\n function blockAndAggregate(Call[] calldata calls)\\n external\\n payable\\n returns (uint256 blockNumber, bytes32 blockHash, Result[] memory returnData);\\n\\n function getBasefee() external view returns (uint256 basefee);\\n\\n function getBlockHash(uint256 blockNumber) external view returns (bytes32 blockHash);\\n\\n function getBlockNumber() external view returns (uint256 blockNumber);\\n\\n function getChainId() external view returns (uint256 chainid);\\n\\n function getCurrentBlockCoinbase() external view returns (address coinbase);\\n\\n function getCurrentBlockDifficulty() external view returns (uint256 difficulty);\\n\\n function getCurrentBlockGasLimit() external view returns (uint256 gaslimit);\\n\\n function getCurrentBlockTimestamp() external view returns (uint256 timestamp);\\n\\n function getEthBalance(address addr) external view returns (uint256 balance);\\n\\n function getLastBlockHash() external view returns (bytes32 blockHash);\\n\\n function tryAggregate(bool requireSuccess, Call[] calldata calls)\\n external\\n payable\\n returns (Result[] memory returnData);\\n\\n function tryBlockAndAggregate(bool requireSuccess, Call[] calldata calls)\\n external\\n payable\\n returns (uint256 blockNumber, bytes32 blockHash, Result[] memory returnData);\\n}\\n\",\"keccak256\":\"0x7aac1389150499a922d1f9ef5749c908cef127cb2075b92fa17e9cb611263d0a\",\"license\":\"MIT\"},\"lib/forge-std/src/safeconsole.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity >=0.6.2 <0.9.0;\\n\\n/// @author philogy \\n/// @dev Code generated automatically by script.\\nlibrary safeconsole {\\n uint256 constant CONSOLE_ADDR = 0x000000000000000000000000000000000000000000636F6e736F6c652e6c6f67;\\n\\n // Credit to [0age](https://twitter.com/z0age/status/1654922202930888704) and [0xdapper](https://github.com/foundry-rs/forge-std/pull/374)\\n // for the view-to-pure log trick.\\n function _sendLogPayload(uint256 offset, uint256 size) private pure {\\n function(uint256, uint256) internal view fnIn = _sendLogPayloadView;\\n function(uint256, uint256) internal pure pureSendLogPayload;\\n /// @solidity memory-safe-assembly\\n assembly {\\n pureSendLogPayload := fnIn\\n }\\n pureSendLogPayload(offset, size);\\n }\\n\\n function _sendLogPayloadView(uint256 offset, uint256 size) private view {\\n /// @solidity memory-safe-assembly\\n assembly {\\n pop(staticcall(gas(), CONSOLE_ADDR, offset, size, 0x0, 0x0))\\n }\\n }\\n\\n function _memcopy(uint256 fromOffset, uint256 toOffset, uint256 length) private pure {\\n function(uint256, uint256, uint256) internal view fnIn = _memcopyView;\\n function(uint256, uint256, uint256) internal pure pureMemcopy;\\n /// @solidity memory-safe-assembly\\n assembly {\\n pureMemcopy := fnIn\\n }\\n pureMemcopy(fromOffset, toOffset, length);\\n }\\n\\n function _memcopyView(uint256 fromOffset, uint256 toOffset, uint256 length) private view {\\n /// @solidity memory-safe-assembly\\n assembly {\\n pop(staticcall(gas(), 0x4, fromOffset, length, toOffset, length))\\n }\\n }\\n\\n function logMemory(uint256 offset, uint256 length) internal pure {\\n if (offset >= 0x60) {\\n // Sufficient memory before slice to prepare call header.\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(sub(offset, 0x60))\\n m1 := mload(sub(offset, 0x40))\\n m2 := mload(sub(offset, 0x20))\\n // Selector of `log(bytes)`.\\n mstore(sub(offset, 0x60), 0x0be77f56)\\n mstore(sub(offset, 0x40), 0x20)\\n mstore(sub(offset, 0x20), length)\\n }\\n _sendLogPayload(offset - 0x44, length + 0x44);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(sub(offset, 0x60), m0)\\n mstore(sub(offset, 0x40), m1)\\n mstore(sub(offset, 0x20), m2)\\n }\\n } else {\\n // Insufficient space, so copy slice forward, add header and reverse.\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n uint256 endOffset = offset + length;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(add(endOffset, 0x00))\\n m1 := mload(add(endOffset, 0x20))\\n m2 := mload(add(endOffset, 0x40))\\n }\\n _memcopy(offset, offset + 0x60, length);\\n /// @solidity memory-safe-assembly\\n assembly {\\n // Selector of `log(bytes)`.\\n mstore(add(offset, 0x00), 0x0be77f56)\\n mstore(add(offset, 0x20), 0x20)\\n mstore(add(offset, 0x40), length)\\n }\\n _sendLogPayload(offset + 0x1c, length + 0x44);\\n _memcopy(offset + 0x60, offset, length);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(add(endOffset, 0x00), m0)\\n mstore(add(endOffset, 0x20), m1)\\n mstore(add(endOffset, 0x40), m2)\\n }\\n }\\n }\\n\\n function log(address p0) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n // Selector of `log(address)`.\\n mstore(0x00, 0x2c2ecbc2)\\n mstore(0x20, p0)\\n }\\n _sendLogPayload(0x1c, 0x24);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n }\\n }\\n\\n function log(bool p0) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n // Selector of `log(bool)`.\\n mstore(0x00, 0x32458eed)\\n mstore(0x20, p0)\\n }\\n _sendLogPayload(0x1c, 0x24);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n }\\n }\\n\\n function log(uint256 p0) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n // Selector of `log(uint256)`.\\n mstore(0x00, 0xf82c50f1)\\n mstore(0x20, p0)\\n }\\n _sendLogPayload(0x1c, 0x24);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n }\\n }\\n\\n function log(bytes32 p0) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n // Selector of `log(string)`.\\n mstore(0x00, 0x41304fac)\\n mstore(0x20, 0x20)\\n writeString(0x40, p0)\\n }\\n _sendLogPayload(0x1c, 0x64);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n }\\n }\\n\\n function log(address p0, address p1) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n // Selector of `log(address,address)`.\\n mstore(0x00, 0xdaf0d4aa)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n }\\n _sendLogPayload(0x1c, 0x44);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n }\\n }\\n\\n function log(address p0, bool p1) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n // Selector of `log(address,bool)`.\\n mstore(0x00, 0x75b605d3)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n }\\n _sendLogPayload(0x1c, 0x44);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n }\\n }\\n\\n function log(address p0, uint256 p1) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n // Selector of `log(address,uint256)`.\\n mstore(0x00, 0x8309e8a8)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n }\\n _sendLogPayload(0x1c, 0x44);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n }\\n }\\n\\n function log(address p0, bytes32 p1) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(address,string)`.\\n mstore(0x00, 0x759f86bb)\\n mstore(0x20, p0)\\n mstore(0x40, 0x40)\\n writeString(0x60, p1)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(bool p0, address p1) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n // Selector of `log(bool,address)`.\\n mstore(0x00, 0x853c4849)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n }\\n _sendLogPayload(0x1c, 0x44);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n }\\n }\\n\\n function log(bool p0, bool p1) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n // Selector of `log(bool,bool)`.\\n mstore(0x00, 0x2a110e83)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n }\\n _sendLogPayload(0x1c, 0x44);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n }\\n }\\n\\n function log(bool p0, uint256 p1) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n // Selector of `log(bool,uint256)`.\\n mstore(0x00, 0x399174d3)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n }\\n _sendLogPayload(0x1c, 0x44);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n }\\n }\\n\\n function log(bool p0, bytes32 p1) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(bool,string)`.\\n mstore(0x00, 0x8feac525)\\n mstore(0x20, p0)\\n mstore(0x40, 0x40)\\n writeString(0x60, p1)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(uint256 p0, address p1) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n // Selector of `log(uint256,address)`.\\n mstore(0x00, 0x69276c86)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n }\\n _sendLogPayload(0x1c, 0x44);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n }\\n }\\n\\n function log(uint256 p0, bool p1) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n // Selector of `log(uint256,bool)`.\\n mstore(0x00, 0x1c9d7eb3)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n }\\n _sendLogPayload(0x1c, 0x44);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n }\\n }\\n\\n function log(uint256 p0, uint256 p1) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n // Selector of `log(uint256,uint256)`.\\n mstore(0x00, 0xf666715a)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n }\\n _sendLogPayload(0x1c, 0x44);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n }\\n }\\n\\n function log(uint256 p0, bytes32 p1) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(uint256,string)`.\\n mstore(0x00, 0x643fd0df)\\n mstore(0x20, p0)\\n mstore(0x40, 0x40)\\n writeString(0x60, p1)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(bytes32 p0, address p1) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(string,address)`.\\n mstore(0x00, 0x319af333)\\n mstore(0x20, 0x40)\\n mstore(0x40, p1)\\n writeString(0x60, p0)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(bytes32 p0, bool p1) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(string,bool)`.\\n mstore(0x00, 0xc3b55635)\\n mstore(0x20, 0x40)\\n mstore(0x40, p1)\\n writeString(0x60, p0)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(bytes32 p0, uint256 p1) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(string,uint256)`.\\n mstore(0x00, 0xb60e72cc)\\n mstore(0x20, 0x40)\\n mstore(0x40, p1)\\n writeString(0x60, p0)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(bytes32 p0, bytes32 p1) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(string,string)`.\\n mstore(0x00, 0x4b5c4277)\\n mstore(0x20, 0x40)\\n mstore(0x40, 0x80)\\n writeString(0x60, p0)\\n writeString(0xa0, p1)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(address p0, address p1, address p2) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n // Selector of `log(address,address,address)`.\\n mstore(0x00, 0x018c84c2)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n }\\n _sendLogPayload(0x1c, 0x64);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n }\\n }\\n\\n function log(address p0, address p1, bool p2) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n // Selector of `log(address,address,bool)`.\\n mstore(0x00, 0xf2a66286)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n }\\n _sendLogPayload(0x1c, 0x64);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n }\\n }\\n\\n function log(address p0, address p1, uint256 p2) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n // Selector of `log(address,address,uint256)`.\\n mstore(0x00, 0x17fe6185)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n }\\n _sendLogPayload(0x1c, 0x64);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n }\\n }\\n\\n function log(address p0, address p1, bytes32 p2) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n // Selector of `log(address,address,string)`.\\n mstore(0x00, 0x007150be)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, 0x60)\\n writeString(0x80, p2)\\n }\\n _sendLogPayload(0x1c, 0xa4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n }\\n }\\n\\n function log(address p0, bool p1, address p2) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n // Selector of `log(address,bool,address)`.\\n mstore(0x00, 0xf11699ed)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n }\\n _sendLogPayload(0x1c, 0x64);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n }\\n }\\n\\n function log(address p0, bool p1, bool p2) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n // Selector of `log(address,bool,bool)`.\\n mstore(0x00, 0xeb830c92)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n }\\n _sendLogPayload(0x1c, 0x64);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n }\\n }\\n\\n function log(address p0, bool p1, uint256 p2) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n // Selector of `log(address,bool,uint256)`.\\n mstore(0x00, 0x9c4f99fb)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n }\\n _sendLogPayload(0x1c, 0x64);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n }\\n }\\n\\n function log(address p0, bool p1, bytes32 p2) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n // Selector of `log(address,bool,string)`.\\n mstore(0x00, 0x212255cc)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, 0x60)\\n writeString(0x80, p2)\\n }\\n _sendLogPayload(0x1c, 0xa4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n }\\n }\\n\\n function log(address p0, uint256 p1, address p2) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n // Selector of `log(address,uint256,address)`.\\n mstore(0x00, 0x7bc0d848)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n }\\n _sendLogPayload(0x1c, 0x64);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n }\\n }\\n\\n function log(address p0, uint256 p1, bool p2) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n // Selector of `log(address,uint256,bool)`.\\n mstore(0x00, 0x678209a8)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n }\\n _sendLogPayload(0x1c, 0x64);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n }\\n }\\n\\n function log(address p0, uint256 p1, uint256 p2) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n // Selector of `log(address,uint256,uint256)`.\\n mstore(0x00, 0xb69bcaf6)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n }\\n _sendLogPayload(0x1c, 0x64);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n }\\n }\\n\\n function log(address p0, uint256 p1, bytes32 p2) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n // Selector of `log(address,uint256,string)`.\\n mstore(0x00, 0xa1f2e8aa)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, 0x60)\\n writeString(0x80, p2)\\n }\\n _sendLogPayload(0x1c, 0xa4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n }\\n }\\n\\n function log(address p0, bytes32 p1, address p2) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n // Selector of `log(address,string,address)`.\\n mstore(0x00, 0xf08744e8)\\n mstore(0x20, p0)\\n mstore(0x40, 0x60)\\n mstore(0x60, p2)\\n writeString(0x80, p1)\\n }\\n _sendLogPayload(0x1c, 0xa4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n }\\n }\\n\\n function log(address p0, bytes32 p1, bool p2) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n // Selector of `log(address,string,bool)`.\\n mstore(0x00, 0xcf020fb1)\\n mstore(0x20, p0)\\n mstore(0x40, 0x60)\\n mstore(0x60, p2)\\n writeString(0x80, p1)\\n }\\n _sendLogPayload(0x1c, 0xa4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n }\\n }\\n\\n function log(address p0, bytes32 p1, uint256 p2) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n // Selector of `log(address,string,uint256)`.\\n mstore(0x00, 0x67dd6ff1)\\n mstore(0x20, p0)\\n mstore(0x40, 0x60)\\n mstore(0x60, p2)\\n writeString(0x80, p1)\\n }\\n _sendLogPayload(0x1c, 0xa4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n }\\n }\\n\\n function log(address p0, bytes32 p1, bytes32 p2) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n // Selector of `log(address,string,string)`.\\n mstore(0x00, 0xfb772265)\\n mstore(0x20, p0)\\n mstore(0x40, 0x60)\\n mstore(0x60, 0xa0)\\n writeString(0x80, p1)\\n writeString(0xc0, p2)\\n }\\n _sendLogPayload(0x1c, 0xe4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n }\\n }\\n\\n function log(bool p0, address p1, address p2) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n // Selector of `log(bool,address,address)`.\\n mstore(0x00, 0xd2763667)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n }\\n _sendLogPayload(0x1c, 0x64);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n }\\n }\\n\\n function log(bool p0, address p1, bool p2) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n // Selector of `log(bool,address,bool)`.\\n mstore(0x00, 0x18c9c746)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n }\\n _sendLogPayload(0x1c, 0x64);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n }\\n }\\n\\n function log(bool p0, address p1, uint256 p2) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n // Selector of `log(bool,address,uint256)`.\\n mstore(0x00, 0x5f7b9afb)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n }\\n _sendLogPayload(0x1c, 0x64);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n }\\n }\\n\\n function log(bool p0, address p1, bytes32 p2) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n // Selector of `log(bool,address,string)`.\\n mstore(0x00, 0xde9a9270)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, 0x60)\\n writeString(0x80, p2)\\n }\\n _sendLogPayload(0x1c, 0xa4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n }\\n }\\n\\n function log(bool p0, bool p1, address p2) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n // Selector of `log(bool,bool,address)`.\\n mstore(0x00, 0x1078f68d)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n }\\n _sendLogPayload(0x1c, 0x64);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n }\\n }\\n\\n function log(bool p0, bool p1, bool p2) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n // Selector of `log(bool,bool,bool)`.\\n mstore(0x00, 0x50709698)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n }\\n _sendLogPayload(0x1c, 0x64);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n }\\n }\\n\\n function log(bool p0, bool p1, uint256 p2) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n // Selector of `log(bool,bool,uint256)`.\\n mstore(0x00, 0x12f21602)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n }\\n _sendLogPayload(0x1c, 0x64);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n }\\n }\\n\\n function log(bool p0, bool p1, bytes32 p2) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n // Selector of `log(bool,bool,string)`.\\n mstore(0x00, 0x2555fa46)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, 0x60)\\n writeString(0x80, p2)\\n }\\n _sendLogPayload(0x1c, 0xa4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n }\\n }\\n\\n function log(bool p0, uint256 p1, address p2) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n // Selector of `log(bool,uint256,address)`.\\n mstore(0x00, 0x088ef9d2)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n }\\n _sendLogPayload(0x1c, 0x64);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n }\\n }\\n\\n function log(bool p0, uint256 p1, bool p2) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n // Selector of `log(bool,uint256,bool)`.\\n mstore(0x00, 0xe8defba9)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n }\\n _sendLogPayload(0x1c, 0x64);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n }\\n }\\n\\n function log(bool p0, uint256 p1, uint256 p2) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n // Selector of `log(bool,uint256,uint256)`.\\n mstore(0x00, 0x37103367)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n }\\n _sendLogPayload(0x1c, 0x64);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n }\\n }\\n\\n function log(bool p0, uint256 p1, bytes32 p2) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n // Selector of `log(bool,uint256,string)`.\\n mstore(0x00, 0xc3fc3970)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, 0x60)\\n writeString(0x80, p2)\\n }\\n _sendLogPayload(0x1c, 0xa4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n }\\n }\\n\\n function log(bool p0, bytes32 p1, address p2) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n // Selector of `log(bool,string,address)`.\\n mstore(0x00, 0x9591b953)\\n mstore(0x20, p0)\\n mstore(0x40, 0x60)\\n mstore(0x60, p2)\\n writeString(0x80, p1)\\n }\\n _sendLogPayload(0x1c, 0xa4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n }\\n }\\n\\n function log(bool p0, bytes32 p1, bool p2) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n // Selector of `log(bool,string,bool)`.\\n mstore(0x00, 0xdbb4c247)\\n mstore(0x20, p0)\\n mstore(0x40, 0x60)\\n mstore(0x60, p2)\\n writeString(0x80, p1)\\n }\\n _sendLogPayload(0x1c, 0xa4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n }\\n }\\n\\n function log(bool p0, bytes32 p1, uint256 p2) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n // Selector of `log(bool,string,uint256)`.\\n mstore(0x00, 0x1093ee11)\\n mstore(0x20, p0)\\n mstore(0x40, 0x60)\\n mstore(0x60, p2)\\n writeString(0x80, p1)\\n }\\n _sendLogPayload(0x1c, 0xa4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n }\\n }\\n\\n function log(bool p0, bytes32 p1, bytes32 p2) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n // Selector of `log(bool,string,string)`.\\n mstore(0x00, 0xb076847f)\\n mstore(0x20, p0)\\n mstore(0x40, 0x60)\\n mstore(0x60, 0xa0)\\n writeString(0x80, p1)\\n writeString(0xc0, p2)\\n }\\n _sendLogPayload(0x1c, 0xe4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n }\\n }\\n\\n function log(uint256 p0, address p1, address p2) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n // Selector of `log(uint256,address,address)`.\\n mstore(0x00, 0xbcfd9be0)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n }\\n _sendLogPayload(0x1c, 0x64);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n }\\n }\\n\\n function log(uint256 p0, address p1, bool p2) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n // Selector of `log(uint256,address,bool)`.\\n mstore(0x00, 0x9b6ec042)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n }\\n _sendLogPayload(0x1c, 0x64);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n }\\n }\\n\\n function log(uint256 p0, address p1, uint256 p2) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n // Selector of `log(uint256,address,uint256)`.\\n mstore(0x00, 0x5a9b5ed5)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n }\\n _sendLogPayload(0x1c, 0x64);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n }\\n }\\n\\n function log(uint256 p0, address p1, bytes32 p2) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n // Selector of `log(uint256,address,string)`.\\n mstore(0x00, 0x63cb41f9)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, 0x60)\\n writeString(0x80, p2)\\n }\\n _sendLogPayload(0x1c, 0xa4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n }\\n }\\n\\n function log(uint256 p0, bool p1, address p2) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n // Selector of `log(uint256,bool,address)`.\\n mstore(0x00, 0x35085f7b)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n }\\n _sendLogPayload(0x1c, 0x64);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n }\\n }\\n\\n function log(uint256 p0, bool p1, bool p2) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n // Selector of `log(uint256,bool,bool)`.\\n mstore(0x00, 0x20718650)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n }\\n _sendLogPayload(0x1c, 0x64);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n }\\n }\\n\\n function log(uint256 p0, bool p1, uint256 p2) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n // Selector of `log(uint256,bool,uint256)`.\\n mstore(0x00, 0x20098014)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n }\\n _sendLogPayload(0x1c, 0x64);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n }\\n }\\n\\n function log(uint256 p0, bool p1, bytes32 p2) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n // Selector of `log(uint256,bool,string)`.\\n mstore(0x00, 0x85775021)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, 0x60)\\n writeString(0x80, p2)\\n }\\n _sendLogPayload(0x1c, 0xa4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n }\\n }\\n\\n function log(uint256 p0, uint256 p1, address p2) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n // Selector of `log(uint256,uint256,address)`.\\n mstore(0x00, 0x5c96b331)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n }\\n _sendLogPayload(0x1c, 0x64);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n }\\n }\\n\\n function log(uint256 p0, uint256 p1, bool p2) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n // Selector of `log(uint256,uint256,bool)`.\\n mstore(0x00, 0x4766da72)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n }\\n _sendLogPayload(0x1c, 0x64);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n }\\n }\\n\\n function log(uint256 p0, uint256 p1, uint256 p2) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n // Selector of `log(uint256,uint256,uint256)`.\\n mstore(0x00, 0xd1ed7a3c)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n }\\n _sendLogPayload(0x1c, 0x64);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n }\\n }\\n\\n function log(uint256 p0, uint256 p1, bytes32 p2) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n // Selector of `log(uint256,uint256,string)`.\\n mstore(0x00, 0x71d04af2)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, 0x60)\\n writeString(0x80, p2)\\n }\\n _sendLogPayload(0x1c, 0xa4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n }\\n }\\n\\n function log(uint256 p0, bytes32 p1, address p2) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n // Selector of `log(uint256,string,address)`.\\n mstore(0x00, 0x7afac959)\\n mstore(0x20, p0)\\n mstore(0x40, 0x60)\\n mstore(0x60, p2)\\n writeString(0x80, p1)\\n }\\n _sendLogPayload(0x1c, 0xa4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n }\\n }\\n\\n function log(uint256 p0, bytes32 p1, bool p2) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n // Selector of `log(uint256,string,bool)`.\\n mstore(0x00, 0x4ceda75a)\\n mstore(0x20, p0)\\n mstore(0x40, 0x60)\\n mstore(0x60, p2)\\n writeString(0x80, p1)\\n }\\n _sendLogPayload(0x1c, 0xa4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n }\\n }\\n\\n function log(uint256 p0, bytes32 p1, uint256 p2) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n // Selector of `log(uint256,string,uint256)`.\\n mstore(0x00, 0x37aa7d4c)\\n mstore(0x20, p0)\\n mstore(0x40, 0x60)\\n mstore(0x60, p2)\\n writeString(0x80, p1)\\n }\\n _sendLogPayload(0x1c, 0xa4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n }\\n }\\n\\n function log(uint256 p0, bytes32 p1, bytes32 p2) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n // Selector of `log(uint256,string,string)`.\\n mstore(0x00, 0xb115611f)\\n mstore(0x20, p0)\\n mstore(0x40, 0x60)\\n mstore(0x60, 0xa0)\\n writeString(0x80, p1)\\n writeString(0xc0, p2)\\n }\\n _sendLogPayload(0x1c, 0xe4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n }\\n }\\n\\n function log(bytes32 p0, address p1, address p2) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n // Selector of `log(string,address,address)`.\\n mstore(0x00, 0xfcec75e0)\\n mstore(0x20, 0x60)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n writeString(0x80, p0)\\n }\\n _sendLogPayload(0x1c, 0xa4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n }\\n }\\n\\n function log(bytes32 p0, address p1, bool p2) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n // Selector of `log(string,address,bool)`.\\n mstore(0x00, 0xc91d5ed4)\\n mstore(0x20, 0x60)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n writeString(0x80, p0)\\n }\\n _sendLogPayload(0x1c, 0xa4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n }\\n }\\n\\n function log(bytes32 p0, address p1, uint256 p2) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n // Selector of `log(string,address,uint256)`.\\n mstore(0x00, 0x0d26b925)\\n mstore(0x20, 0x60)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n writeString(0x80, p0)\\n }\\n _sendLogPayload(0x1c, 0xa4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n }\\n }\\n\\n function log(bytes32 p0, address p1, bytes32 p2) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n // Selector of `log(string,address,string)`.\\n mstore(0x00, 0xe0e9ad4f)\\n mstore(0x20, 0x60)\\n mstore(0x40, p1)\\n mstore(0x60, 0xa0)\\n writeString(0x80, p0)\\n writeString(0xc0, p2)\\n }\\n _sendLogPayload(0x1c, 0xe4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n }\\n }\\n\\n function log(bytes32 p0, bool p1, address p2) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n // Selector of `log(string,bool,address)`.\\n mstore(0x00, 0x932bbb38)\\n mstore(0x20, 0x60)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n writeString(0x80, p0)\\n }\\n _sendLogPayload(0x1c, 0xa4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n }\\n }\\n\\n function log(bytes32 p0, bool p1, bool p2) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n // Selector of `log(string,bool,bool)`.\\n mstore(0x00, 0x850b7ad6)\\n mstore(0x20, 0x60)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n writeString(0x80, p0)\\n }\\n _sendLogPayload(0x1c, 0xa4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n }\\n }\\n\\n function log(bytes32 p0, bool p1, uint256 p2) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n // Selector of `log(string,bool,uint256)`.\\n mstore(0x00, 0xc95958d6)\\n mstore(0x20, 0x60)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n writeString(0x80, p0)\\n }\\n _sendLogPayload(0x1c, 0xa4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n }\\n }\\n\\n function log(bytes32 p0, bool p1, bytes32 p2) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n // Selector of `log(string,bool,string)`.\\n mstore(0x00, 0xe298f47d)\\n mstore(0x20, 0x60)\\n mstore(0x40, p1)\\n mstore(0x60, 0xa0)\\n writeString(0x80, p0)\\n writeString(0xc0, p2)\\n }\\n _sendLogPayload(0x1c, 0xe4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n }\\n }\\n\\n function log(bytes32 p0, uint256 p1, address p2) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n // Selector of `log(string,uint256,address)`.\\n mstore(0x00, 0x1c7ec448)\\n mstore(0x20, 0x60)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n writeString(0x80, p0)\\n }\\n _sendLogPayload(0x1c, 0xa4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n }\\n }\\n\\n function log(bytes32 p0, uint256 p1, bool p2) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n // Selector of `log(string,uint256,bool)`.\\n mstore(0x00, 0xca7733b1)\\n mstore(0x20, 0x60)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n writeString(0x80, p0)\\n }\\n _sendLogPayload(0x1c, 0xa4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n }\\n }\\n\\n function log(bytes32 p0, uint256 p1, uint256 p2) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n // Selector of `log(string,uint256,uint256)`.\\n mstore(0x00, 0xca47c4eb)\\n mstore(0x20, 0x60)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n writeString(0x80, p0)\\n }\\n _sendLogPayload(0x1c, 0xa4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n }\\n }\\n\\n function log(bytes32 p0, uint256 p1, bytes32 p2) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n // Selector of `log(string,uint256,string)`.\\n mstore(0x00, 0x5970e089)\\n mstore(0x20, 0x60)\\n mstore(0x40, p1)\\n mstore(0x60, 0xa0)\\n writeString(0x80, p0)\\n writeString(0xc0, p2)\\n }\\n _sendLogPayload(0x1c, 0xe4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n }\\n }\\n\\n function log(bytes32 p0, bytes32 p1, address p2) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n // Selector of `log(string,string,address)`.\\n mstore(0x00, 0x95ed0195)\\n mstore(0x20, 0x60)\\n mstore(0x40, 0xa0)\\n mstore(0x60, p2)\\n writeString(0x80, p0)\\n writeString(0xc0, p1)\\n }\\n _sendLogPayload(0x1c, 0xe4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n }\\n }\\n\\n function log(bytes32 p0, bytes32 p1, bool p2) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n // Selector of `log(string,string,bool)`.\\n mstore(0x00, 0xb0e0f9b5)\\n mstore(0x20, 0x60)\\n mstore(0x40, 0xa0)\\n mstore(0x60, p2)\\n writeString(0x80, p0)\\n writeString(0xc0, p1)\\n }\\n _sendLogPayload(0x1c, 0xe4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n }\\n }\\n\\n function log(bytes32 p0, bytes32 p1, uint256 p2) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n // Selector of `log(string,string,uint256)`.\\n mstore(0x00, 0x5821efa1)\\n mstore(0x20, 0x60)\\n mstore(0x40, 0xa0)\\n mstore(0x60, p2)\\n writeString(0x80, p0)\\n writeString(0xc0, p1)\\n }\\n _sendLogPayload(0x1c, 0xe4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n }\\n }\\n\\n function log(bytes32 p0, bytes32 p1, bytes32 p2) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n bytes32 m9;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n m9 := mload(0x120)\\n // Selector of `log(string,string,string)`.\\n mstore(0x00, 0x2ced7cef)\\n mstore(0x20, 0x60)\\n mstore(0x40, 0xa0)\\n mstore(0x60, 0xe0)\\n writeString(0x80, p0)\\n writeString(0xc0, p1)\\n writeString(0x100, p2)\\n }\\n _sendLogPayload(0x1c, 0x124);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n mstore(0x120, m9)\\n }\\n }\\n\\n function log(address p0, address p1, address p2, address p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(address,address,address,address)`.\\n mstore(0x00, 0x665bf134)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(address p0, address p1, address p2, bool p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(address,address,address,bool)`.\\n mstore(0x00, 0x0e378994)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(address p0, address p1, address p2, uint256 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(address,address,address,uint256)`.\\n mstore(0x00, 0x94250d77)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(address p0, address p1, address p2, bytes32 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(address,address,address,string)`.\\n mstore(0x00, 0xf808da20)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, 0x80)\\n writeString(0xa0, p3)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(address p0, address p1, bool p2, address p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(address,address,bool,address)`.\\n mstore(0x00, 0x9f1bc36e)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(address p0, address p1, bool p2, bool p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(address,address,bool,bool)`.\\n mstore(0x00, 0x2cd4134a)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(address p0, address p1, bool p2, uint256 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(address,address,bool,uint256)`.\\n mstore(0x00, 0x3971e78c)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(address p0, address p1, bool p2, bytes32 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(address,address,bool,string)`.\\n mstore(0x00, 0xaa6540c8)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, 0x80)\\n writeString(0xa0, p3)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(address p0, address p1, uint256 p2, address p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(address,address,uint256,address)`.\\n mstore(0x00, 0x8da6def5)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(address p0, address p1, uint256 p2, bool p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(address,address,uint256,bool)`.\\n mstore(0x00, 0x9b4254e2)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(address p0, address p1, uint256 p2, uint256 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(address,address,uint256,uint256)`.\\n mstore(0x00, 0xbe553481)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(address p0, address p1, uint256 p2, bytes32 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(address,address,uint256,string)`.\\n mstore(0x00, 0xfdb4f990)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, 0x80)\\n writeString(0xa0, p3)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(address p0, address p1, bytes32 p2, address p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(address,address,string,address)`.\\n mstore(0x00, 0x8f736d16)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, 0x80)\\n mstore(0x80, p3)\\n writeString(0xa0, p2)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(address p0, address p1, bytes32 p2, bool p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(address,address,string,bool)`.\\n mstore(0x00, 0x6f1a594e)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, 0x80)\\n mstore(0x80, p3)\\n writeString(0xa0, p2)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(address p0, address p1, bytes32 p2, uint256 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(address,address,string,uint256)`.\\n mstore(0x00, 0xef1cefe7)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, 0x80)\\n mstore(0x80, p3)\\n writeString(0xa0, p2)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(address p0, address p1, bytes32 p2, bytes32 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n // Selector of `log(address,address,string,string)`.\\n mstore(0x00, 0x21bdaf25)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, 0x80)\\n mstore(0x80, 0xc0)\\n writeString(0xa0, p2)\\n writeString(0xe0, p3)\\n }\\n _sendLogPayload(0x1c, 0x104);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n }\\n }\\n\\n function log(address p0, bool p1, address p2, address p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(address,bool,address,address)`.\\n mstore(0x00, 0x660375dd)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(address p0, bool p1, address p2, bool p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(address,bool,address,bool)`.\\n mstore(0x00, 0xa6f50b0f)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(address p0, bool p1, address p2, uint256 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(address,bool,address,uint256)`.\\n mstore(0x00, 0xa75c59de)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(address p0, bool p1, address p2, bytes32 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(address,bool,address,string)`.\\n mstore(0x00, 0x2dd778e6)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, 0x80)\\n writeString(0xa0, p3)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(address p0, bool p1, bool p2, address p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(address,bool,bool,address)`.\\n mstore(0x00, 0xcf394485)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(address p0, bool p1, bool p2, bool p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(address,bool,bool,bool)`.\\n mstore(0x00, 0xcac43479)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(address p0, bool p1, bool p2, uint256 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(address,bool,bool,uint256)`.\\n mstore(0x00, 0x8c4e5de6)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(address p0, bool p1, bool p2, bytes32 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(address,bool,bool,string)`.\\n mstore(0x00, 0xdfc4a2e8)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, 0x80)\\n writeString(0xa0, p3)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(address p0, bool p1, uint256 p2, address p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(address,bool,uint256,address)`.\\n mstore(0x00, 0xccf790a1)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(address p0, bool p1, uint256 p2, bool p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(address,bool,uint256,bool)`.\\n mstore(0x00, 0xc4643e20)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(address p0, bool p1, uint256 p2, uint256 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(address,bool,uint256,uint256)`.\\n mstore(0x00, 0x386ff5f4)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(address p0, bool p1, uint256 p2, bytes32 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(address,bool,uint256,string)`.\\n mstore(0x00, 0x0aa6cfad)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, 0x80)\\n writeString(0xa0, p3)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(address p0, bool p1, bytes32 p2, address p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(address,bool,string,address)`.\\n mstore(0x00, 0x19fd4956)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, 0x80)\\n mstore(0x80, p3)\\n writeString(0xa0, p2)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(address p0, bool p1, bytes32 p2, bool p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(address,bool,string,bool)`.\\n mstore(0x00, 0x50ad461d)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, 0x80)\\n mstore(0x80, p3)\\n writeString(0xa0, p2)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(address p0, bool p1, bytes32 p2, uint256 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(address,bool,string,uint256)`.\\n mstore(0x00, 0x80e6a20b)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, 0x80)\\n mstore(0x80, p3)\\n writeString(0xa0, p2)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(address p0, bool p1, bytes32 p2, bytes32 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n // Selector of `log(address,bool,string,string)`.\\n mstore(0x00, 0x475c5c33)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, 0x80)\\n mstore(0x80, 0xc0)\\n writeString(0xa0, p2)\\n writeString(0xe0, p3)\\n }\\n _sendLogPayload(0x1c, 0x104);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n }\\n }\\n\\n function log(address p0, uint256 p1, address p2, address p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(address,uint256,address,address)`.\\n mstore(0x00, 0x478d1c62)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(address p0, uint256 p1, address p2, bool p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(address,uint256,address,bool)`.\\n mstore(0x00, 0xa1bcc9b3)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(address p0, uint256 p1, address p2, uint256 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(address,uint256,address,uint256)`.\\n mstore(0x00, 0x100f650e)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(address p0, uint256 p1, address p2, bytes32 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(address,uint256,address,string)`.\\n mstore(0x00, 0x1da986ea)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, 0x80)\\n writeString(0xa0, p3)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(address p0, uint256 p1, bool p2, address p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(address,uint256,bool,address)`.\\n mstore(0x00, 0xa31bfdcc)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(address p0, uint256 p1, bool p2, bool p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(address,uint256,bool,bool)`.\\n mstore(0x00, 0x3bf5e537)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(address p0, uint256 p1, bool p2, uint256 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(address,uint256,bool,uint256)`.\\n mstore(0x00, 0x22f6b999)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(address p0, uint256 p1, bool p2, bytes32 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(address,uint256,bool,string)`.\\n mstore(0x00, 0xc5ad85f9)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, 0x80)\\n writeString(0xa0, p3)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(address p0, uint256 p1, uint256 p2, address p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(address,uint256,uint256,address)`.\\n mstore(0x00, 0x20e3984d)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(address p0, uint256 p1, uint256 p2, bool p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(address,uint256,uint256,bool)`.\\n mstore(0x00, 0x66f1bc67)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(address p0, uint256 p1, uint256 p2, uint256 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(address,uint256,uint256,uint256)`.\\n mstore(0x00, 0x34f0e636)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(address p0, uint256 p1, uint256 p2, bytes32 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(address,uint256,uint256,string)`.\\n mstore(0x00, 0x4a28c017)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, 0x80)\\n writeString(0xa0, p3)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(address p0, uint256 p1, bytes32 p2, address p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(address,uint256,string,address)`.\\n mstore(0x00, 0x5c430d47)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, 0x80)\\n mstore(0x80, p3)\\n writeString(0xa0, p2)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(address p0, uint256 p1, bytes32 p2, bool p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(address,uint256,string,bool)`.\\n mstore(0x00, 0xcf18105c)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, 0x80)\\n mstore(0x80, p3)\\n writeString(0xa0, p2)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(address p0, uint256 p1, bytes32 p2, uint256 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(address,uint256,string,uint256)`.\\n mstore(0x00, 0xbf01f891)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, 0x80)\\n mstore(0x80, p3)\\n writeString(0xa0, p2)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(address p0, uint256 p1, bytes32 p2, bytes32 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n // Selector of `log(address,uint256,string,string)`.\\n mstore(0x00, 0x88a8c406)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, 0x80)\\n mstore(0x80, 0xc0)\\n writeString(0xa0, p2)\\n writeString(0xe0, p3)\\n }\\n _sendLogPayload(0x1c, 0x104);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n }\\n }\\n\\n function log(address p0, bytes32 p1, address p2, address p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(address,string,address,address)`.\\n mstore(0x00, 0x0d36fa20)\\n mstore(0x20, p0)\\n mstore(0x40, 0x80)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n writeString(0xa0, p1)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(address p0, bytes32 p1, address p2, bool p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(address,string,address,bool)`.\\n mstore(0x00, 0x0df12b76)\\n mstore(0x20, p0)\\n mstore(0x40, 0x80)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n writeString(0xa0, p1)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(address p0, bytes32 p1, address p2, uint256 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(address,string,address,uint256)`.\\n mstore(0x00, 0x457fe3cf)\\n mstore(0x20, p0)\\n mstore(0x40, 0x80)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n writeString(0xa0, p1)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(address p0, bytes32 p1, address p2, bytes32 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n // Selector of `log(address,string,address,string)`.\\n mstore(0x00, 0xf7e36245)\\n mstore(0x20, p0)\\n mstore(0x40, 0x80)\\n mstore(0x60, p2)\\n mstore(0x80, 0xc0)\\n writeString(0xa0, p1)\\n writeString(0xe0, p3)\\n }\\n _sendLogPayload(0x1c, 0x104);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n }\\n }\\n\\n function log(address p0, bytes32 p1, bool p2, address p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(address,string,bool,address)`.\\n mstore(0x00, 0x205871c2)\\n mstore(0x20, p0)\\n mstore(0x40, 0x80)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n writeString(0xa0, p1)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(address p0, bytes32 p1, bool p2, bool p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(address,string,bool,bool)`.\\n mstore(0x00, 0x5f1d5c9f)\\n mstore(0x20, p0)\\n mstore(0x40, 0x80)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n writeString(0xa0, p1)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(address p0, bytes32 p1, bool p2, uint256 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(address,string,bool,uint256)`.\\n mstore(0x00, 0x515e38b6)\\n mstore(0x20, p0)\\n mstore(0x40, 0x80)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n writeString(0xa0, p1)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(address p0, bytes32 p1, bool p2, bytes32 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n // Selector of `log(address,string,bool,string)`.\\n mstore(0x00, 0xbc0b61fe)\\n mstore(0x20, p0)\\n mstore(0x40, 0x80)\\n mstore(0x60, p2)\\n mstore(0x80, 0xc0)\\n writeString(0xa0, p1)\\n writeString(0xe0, p3)\\n }\\n _sendLogPayload(0x1c, 0x104);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n }\\n }\\n\\n function log(address p0, bytes32 p1, uint256 p2, address p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(address,string,uint256,address)`.\\n mstore(0x00, 0x63183678)\\n mstore(0x20, p0)\\n mstore(0x40, 0x80)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n writeString(0xa0, p1)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(address p0, bytes32 p1, uint256 p2, bool p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(address,string,uint256,bool)`.\\n mstore(0x00, 0x0ef7e050)\\n mstore(0x20, p0)\\n mstore(0x40, 0x80)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n writeString(0xa0, p1)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(address p0, bytes32 p1, uint256 p2, uint256 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(address,string,uint256,uint256)`.\\n mstore(0x00, 0x1dc8e1b8)\\n mstore(0x20, p0)\\n mstore(0x40, 0x80)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n writeString(0xa0, p1)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(address p0, bytes32 p1, uint256 p2, bytes32 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n // Selector of `log(address,string,uint256,string)`.\\n mstore(0x00, 0x448830a8)\\n mstore(0x20, p0)\\n mstore(0x40, 0x80)\\n mstore(0x60, p2)\\n mstore(0x80, 0xc0)\\n writeString(0xa0, p1)\\n writeString(0xe0, p3)\\n }\\n _sendLogPayload(0x1c, 0x104);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n }\\n }\\n\\n function log(address p0, bytes32 p1, bytes32 p2, address p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n // Selector of `log(address,string,string,address)`.\\n mstore(0x00, 0xa04e2f87)\\n mstore(0x20, p0)\\n mstore(0x40, 0x80)\\n mstore(0x60, 0xc0)\\n mstore(0x80, p3)\\n writeString(0xa0, p1)\\n writeString(0xe0, p2)\\n }\\n _sendLogPayload(0x1c, 0x104);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n }\\n }\\n\\n function log(address p0, bytes32 p1, bytes32 p2, bool p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n // Selector of `log(address,string,string,bool)`.\\n mstore(0x00, 0x35a5071f)\\n mstore(0x20, p0)\\n mstore(0x40, 0x80)\\n mstore(0x60, 0xc0)\\n mstore(0x80, p3)\\n writeString(0xa0, p1)\\n writeString(0xe0, p2)\\n }\\n _sendLogPayload(0x1c, 0x104);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n }\\n }\\n\\n function log(address p0, bytes32 p1, bytes32 p2, uint256 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n // Selector of `log(address,string,string,uint256)`.\\n mstore(0x00, 0x159f8927)\\n mstore(0x20, p0)\\n mstore(0x40, 0x80)\\n mstore(0x60, 0xc0)\\n mstore(0x80, p3)\\n writeString(0xa0, p1)\\n writeString(0xe0, p2)\\n }\\n _sendLogPayload(0x1c, 0x104);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n }\\n }\\n\\n function log(address p0, bytes32 p1, bytes32 p2, bytes32 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n bytes32 m9;\\n bytes32 m10;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n m9 := mload(0x120)\\n m10 := mload(0x140)\\n // Selector of `log(address,string,string,string)`.\\n mstore(0x00, 0x5d02c50b)\\n mstore(0x20, p0)\\n mstore(0x40, 0x80)\\n mstore(0x60, 0xc0)\\n mstore(0x80, 0x100)\\n writeString(0xa0, p1)\\n writeString(0xe0, p2)\\n writeString(0x120, p3)\\n }\\n _sendLogPayload(0x1c, 0x144);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n mstore(0x120, m9)\\n mstore(0x140, m10)\\n }\\n }\\n\\n function log(bool p0, address p1, address p2, address p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(bool,address,address,address)`.\\n mstore(0x00, 0x1d14d001)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(bool p0, address p1, address p2, bool p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(bool,address,address,bool)`.\\n mstore(0x00, 0x46600be0)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(bool p0, address p1, address p2, uint256 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(bool,address,address,uint256)`.\\n mstore(0x00, 0x0c66d1be)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(bool p0, address p1, address p2, bytes32 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(bool,address,address,string)`.\\n mstore(0x00, 0xd812a167)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, 0x80)\\n writeString(0xa0, p3)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(bool p0, address p1, bool p2, address p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(bool,address,bool,address)`.\\n mstore(0x00, 0x1c41a336)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(bool p0, address p1, bool p2, bool p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(bool,address,bool,bool)`.\\n mstore(0x00, 0x6a9c478b)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(bool p0, address p1, bool p2, uint256 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(bool,address,bool,uint256)`.\\n mstore(0x00, 0x07831502)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(bool p0, address p1, bool p2, bytes32 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(bool,address,bool,string)`.\\n mstore(0x00, 0x4a66cb34)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, 0x80)\\n writeString(0xa0, p3)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(bool p0, address p1, uint256 p2, address p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(bool,address,uint256,address)`.\\n mstore(0x00, 0x136b05dd)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(bool p0, address p1, uint256 p2, bool p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(bool,address,uint256,bool)`.\\n mstore(0x00, 0xd6019f1c)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(bool p0, address p1, uint256 p2, uint256 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(bool,address,uint256,uint256)`.\\n mstore(0x00, 0x7bf181a1)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(bool p0, address p1, uint256 p2, bytes32 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(bool,address,uint256,string)`.\\n mstore(0x00, 0x51f09ff8)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, 0x80)\\n writeString(0xa0, p3)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(bool p0, address p1, bytes32 p2, address p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(bool,address,string,address)`.\\n mstore(0x00, 0x6f7c603e)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, 0x80)\\n mstore(0x80, p3)\\n writeString(0xa0, p2)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(bool p0, address p1, bytes32 p2, bool p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(bool,address,string,bool)`.\\n mstore(0x00, 0xe2bfd60b)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, 0x80)\\n mstore(0x80, p3)\\n writeString(0xa0, p2)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(bool p0, address p1, bytes32 p2, uint256 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(bool,address,string,uint256)`.\\n mstore(0x00, 0xc21f64c7)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, 0x80)\\n mstore(0x80, p3)\\n writeString(0xa0, p2)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(bool p0, address p1, bytes32 p2, bytes32 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n // Selector of `log(bool,address,string,string)`.\\n mstore(0x00, 0xa73c1db6)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, 0x80)\\n mstore(0x80, 0xc0)\\n writeString(0xa0, p2)\\n writeString(0xe0, p3)\\n }\\n _sendLogPayload(0x1c, 0x104);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n }\\n }\\n\\n function log(bool p0, bool p1, address p2, address p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(bool,bool,address,address)`.\\n mstore(0x00, 0xf4880ea4)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(bool p0, bool p1, address p2, bool p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(bool,bool,address,bool)`.\\n mstore(0x00, 0xc0a302d8)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(bool p0, bool p1, address p2, uint256 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(bool,bool,address,uint256)`.\\n mstore(0x00, 0x4c123d57)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(bool p0, bool p1, address p2, bytes32 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(bool,bool,address,string)`.\\n mstore(0x00, 0xa0a47963)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, 0x80)\\n writeString(0xa0, p3)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(bool p0, bool p1, bool p2, address p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(bool,bool,bool,address)`.\\n mstore(0x00, 0x8c329b1a)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(bool p0, bool p1, bool p2, bool p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(bool,bool,bool,bool)`.\\n mstore(0x00, 0x3b2a5ce0)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(bool p0, bool p1, bool p2, uint256 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(bool,bool,bool,uint256)`.\\n mstore(0x00, 0x6d7045c1)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(bool p0, bool p1, bool p2, bytes32 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(bool,bool,bool,string)`.\\n mstore(0x00, 0x2ae408d4)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, 0x80)\\n writeString(0xa0, p3)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(bool p0, bool p1, uint256 p2, address p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(bool,bool,uint256,address)`.\\n mstore(0x00, 0x54a7a9a0)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(bool p0, bool p1, uint256 p2, bool p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(bool,bool,uint256,bool)`.\\n mstore(0x00, 0x619e4d0e)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(bool p0, bool p1, uint256 p2, uint256 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(bool,bool,uint256,uint256)`.\\n mstore(0x00, 0x0bb00eab)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(bool p0, bool p1, uint256 p2, bytes32 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(bool,bool,uint256,string)`.\\n mstore(0x00, 0x7dd4d0e0)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, 0x80)\\n writeString(0xa0, p3)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(bool p0, bool p1, bytes32 p2, address p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(bool,bool,string,address)`.\\n mstore(0x00, 0xf9ad2b89)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, 0x80)\\n mstore(0x80, p3)\\n writeString(0xa0, p2)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(bool p0, bool p1, bytes32 p2, bool p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(bool,bool,string,bool)`.\\n mstore(0x00, 0xb857163a)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, 0x80)\\n mstore(0x80, p3)\\n writeString(0xa0, p2)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(bool p0, bool p1, bytes32 p2, uint256 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(bool,bool,string,uint256)`.\\n mstore(0x00, 0xe3a9ca2f)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, 0x80)\\n mstore(0x80, p3)\\n writeString(0xa0, p2)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(bool p0, bool p1, bytes32 p2, bytes32 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n // Selector of `log(bool,bool,string,string)`.\\n mstore(0x00, 0x6d1e8751)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, 0x80)\\n mstore(0x80, 0xc0)\\n writeString(0xa0, p2)\\n writeString(0xe0, p3)\\n }\\n _sendLogPayload(0x1c, 0x104);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n }\\n }\\n\\n function log(bool p0, uint256 p1, address p2, address p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(bool,uint256,address,address)`.\\n mstore(0x00, 0x26f560a8)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(bool p0, uint256 p1, address p2, bool p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(bool,uint256,address,bool)`.\\n mstore(0x00, 0xb4c314ff)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(bool p0, uint256 p1, address p2, uint256 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(bool,uint256,address,uint256)`.\\n mstore(0x00, 0x1537dc87)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(bool p0, uint256 p1, address p2, bytes32 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(bool,uint256,address,string)`.\\n mstore(0x00, 0x1bb3b09a)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, 0x80)\\n writeString(0xa0, p3)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(bool p0, uint256 p1, bool p2, address p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(bool,uint256,bool,address)`.\\n mstore(0x00, 0x9acd3616)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(bool p0, uint256 p1, bool p2, bool p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(bool,uint256,bool,bool)`.\\n mstore(0x00, 0xceb5f4d7)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(bool p0, uint256 p1, bool p2, uint256 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(bool,uint256,bool,uint256)`.\\n mstore(0x00, 0x7f9bbca2)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(bool p0, uint256 p1, bool p2, bytes32 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(bool,uint256,bool,string)`.\\n mstore(0x00, 0x9143dbb1)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, 0x80)\\n writeString(0xa0, p3)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(bool p0, uint256 p1, uint256 p2, address p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(bool,uint256,uint256,address)`.\\n mstore(0x00, 0x00dd87b9)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(bool p0, uint256 p1, uint256 p2, bool p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(bool,uint256,uint256,bool)`.\\n mstore(0x00, 0xbe984353)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(bool p0, uint256 p1, uint256 p2, uint256 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(bool,uint256,uint256,uint256)`.\\n mstore(0x00, 0x374bb4b2)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(bool p0, uint256 p1, uint256 p2, bytes32 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(bool,uint256,uint256,string)`.\\n mstore(0x00, 0x8e69fb5d)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, 0x80)\\n writeString(0xa0, p3)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(bool p0, uint256 p1, bytes32 p2, address p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(bool,uint256,string,address)`.\\n mstore(0x00, 0xfedd1fff)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, 0x80)\\n mstore(0x80, p3)\\n writeString(0xa0, p2)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(bool p0, uint256 p1, bytes32 p2, bool p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(bool,uint256,string,bool)`.\\n mstore(0x00, 0xe5e70b2b)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, 0x80)\\n mstore(0x80, p3)\\n writeString(0xa0, p2)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(bool p0, uint256 p1, bytes32 p2, uint256 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(bool,uint256,string,uint256)`.\\n mstore(0x00, 0x6a1199e2)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, 0x80)\\n mstore(0x80, p3)\\n writeString(0xa0, p2)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(bool p0, uint256 p1, bytes32 p2, bytes32 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n // Selector of `log(bool,uint256,string,string)`.\\n mstore(0x00, 0xf5bc2249)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, 0x80)\\n mstore(0x80, 0xc0)\\n writeString(0xa0, p2)\\n writeString(0xe0, p3)\\n }\\n _sendLogPayload(0x1c, 0x104);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n }\\n }\\n\\n function log(bool p0, bytes32 p1, address p2, address p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(bool,string,address,address)`.\\n mstore(0x00, 0x2b2b18dc)\\n mstore(0x20, p0)\\n mstore(0x40, 0x80)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n writeString(0xa0, p1)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(bool p0, bytes32 p1, address p2, bool p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(bool,string,address,bool)`.\\n mstore(0x00, 0x6dd434ca)\\n mstore(0x20, p0)\\n mstore(0x40, 0x80)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n writeString(0xa0, p1)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(bool p0, bytes32 p1, address p2, uint256 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(bool,string,address,uint256)`.\\n mstore(0x00, 0xa5cada94)\\n mstore(0x20, p0)\\n mstore(0x40, 0x80)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n writeString(0xa0, p1)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(bool p0, bytes32 p1, address p2, bytes32 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n // Selector of `log(bool,string,address,string)`.\\n mstore(0x00, 0x12d6c788)\\n mstore(0x20, p0)\\n mstore(0x40, 0x80)\\n mstore(0x60, p2)\\n mstore(0x80, 0xc0)\\n writeString(0xa0, p1)\\n writeString(0xe0, p3)\\n }\\n _sendLogPayload(0x1c, 0x104);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n }\\n }\\n\\n function log(bool p0, bytes32 p1, bool p2, address p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(bool,string,bool,address)`.\\n mstore(0x00, 0x538e06ab)\\n mstore(0x20, p0)\\n mstore(0x40, 0x80)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n writeString(0xa0, p1)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(bool p0, bytes32 p1, bool p2, bool p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(bool,string,bool,bool)`.\\n mstore(0x00, 0xdc5e935b)\\n mstore(0x20, p0)\\n mstore(0x40, 0x80)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n writeString(0xa0, p1)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(bool p0, bytes32 p1, bool p2, uint256 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(bool,string,bool,uint256)`.\\n mstore(0x00, 0x1606a393)\\n mstore(0x20, p0)\\n mstore(0x40, 0x80)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n writeString(0xa0, p1)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(bool p0, bytes32 p1, bool p2, bytes32 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n // Selector of `log(bool,string,bool,string)`.\\n mstore(0x00, 0x483d0416)\\n mstore(0x20, p0)\\n mstore(0x40, 0x80)\\n mstore(0x60, p2)\\n mstore(0x80, 0xc0)\\n writeString(0xa0, p1)\\n writeString(0xe0, p3)\\n }\\n _sendLogPayload(0x1c, 0x104);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n }\\n }\\n\\n function log(bool p0, bytes32 p1, uint256 p2, address p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(bool,string,uint256,address)`.\\n mstore(0x00, 0x1596a1ce)\\n mstore(0x20, p0)\\n mstore(0x40, 0x80)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n writeString(0xa0, p1)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(bool p0, bytes32 p1, uint256 p2, bool p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(bool,string,uint256,bool)`.\\n mstore(0x00, 0x6b0e5d53)\\n mstore(0x20, p0)\\n mstore(0x40, 0x80)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n writeString(0xa0, p1)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(bool p0, bytes32 p1, uint256 p2, uint256 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(bool,string,uint256,uint256)`.\\n mstore(0x00, 0x28863fcb)\\n mstore(0x20, p0)\\n mstore(0x40, 0x80)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n writeString(0xa0, p1)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(bool p0, bytes32 p1, uint256 p2, bytes32 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n // Selector of `log(bool,string,uint256,string)`.\\n mstore(0x00, 0x1ad96de6)\\n mstore(0x20, p0)\\n mstore(0x40, 0x80)\\n mstore(0x60, p2)\\n mstore(0x80, 0xc0)\\n writeString(0xa0, p1)\\n writeString(0xe0, p3)\\n }\\n _sendLogPayload(0x1c, 0x104);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n }\\n }\\n\\n function log(bool p0, bytes32 p1, bytes32 p2, address p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n // Selector of `log(bool,string,string,address)`.\\n mstore(0x00, 0x97d394d8)\\n mstore(0x20, p0)\\n mstore(0x40, 0x80)\\n mstore(0x60, 0xc0)\\n mstore(0x80, p3)\\n writeString(0xa0, p1)\\n writeString(0xe0, p2)\\n }\\n _sendLogPayload(0x1c, 0x104);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n }\\n }\\n\\n function log(bool p0, bytes32 p1, bytes32 p2, bool p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n // Selector of `log(bool,string,string,bool)`.\\n mstore(0x00, 0x1e4b87e5)\\n mstore(0x20, p0)\\n mstore(0x40, 0x80)\\n mstore(0x60, 0xc0)\\n mstore(0x80, p3)\\n writeString(0xa0, p1)\\n writeString(0xe0, p2)\\n }\\n _sendLogPayload(0x1c, 0x104);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n }\\n }\\n\\n function log(bool p0, bytes32 p1, bytes32 p2, uint256 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n // Selector of `log(bool,string,string,uint256)`.\\n mstore(0x00, 0x7be0c3eb)\\n mstore(0x20, p0)\\n mstore(0x40, 0x80)\\n mstore(0x60, 0xc0)\\n mstore(0x80, p3)\\n writeString(0xa0, p1)\\n writeString(0xe0, p2)\\n }\\n _sendLogPayload(0x1c, 0x104);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n }\\n }\\n\\n function log(bool p0, bytes32 p1, bytes32 p2, bytes32 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n bytes32 m9;\\n bytes32 m10;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n m9 := mload(0x120)\\n m10 := mload(0x140)\\n // Selector of `log(bool,string,string,string)`.\\n mstore(0x00, 0x1762e32a)\\n mstore(0x20, p0)\\n mstore(0x40, 0x80)\\n mstore(0x60, 0xc0)\\n mstore(0x80, 0x100)\\n writeString(0xa0, p1)\\n writeString(0xe0, p2)\\n writeString(0x120, p3)\\n }\\n _sendLogPayload(0x1c, 0x144);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n mstore(0x120, m9)\\n mstore(0x140, m10)\\n }\\n }\\n\\n function log(uint256 p0, address p1, address p2, address p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(uint256,address,address,address)`.\\n mstore(0x00, 0x2488b414)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(uint256 p0, address p1, address p2, bool p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(uint256,address,address,bool)`.\\n mstore(0x00, 0x091ffaf5)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(uint256 p0, address p1, address p2, uint256 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(uint256,address,address,uint256)`.\\n mstore(0x00, 0x736efbb6)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(uint256 p0, address p1, address p2, bytes32 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(uint256,address,address,string)`.\\n mstore(0x00, 0x031c6f73)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, 0x80)\\n writeString(0xa0, p3)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(uint256 p0, address p1, bool p2, address p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(uint256,address,bool,address)`.\\n mstore(0x00, 0xef72c513)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(uint256 p0, address p1, bool p2, bool p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(uint256,address,bool,bool)`.\\n mstore(0x00, 0xe351140f)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(uint256 p0, address p1, bool p2, uint256 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(uint256,address,bool,uint256)`.\\n mstore(0x00, 0x5abd992a)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(uint256 p0, address p1, bool p2, bytes32 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(uint256,address,bool,string)`.\\n mstore(0x00, 0x90fb06aa)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, 0x80)\\n writeString(0xa0, p3)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(uint256 p0, address p1, uint256 p2, address p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(uint256,address,uint256,address)`.\\n mstore(0x00, 0x15c127b5)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(uint256 p0, address p1, uint256 p2, bool p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(uint256,address,uint256,bool)`.\\n mstore(0x00, 0x5f743a7c)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(uint256 p0, address p1, uint256 p2, uint256 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(uint256,address,uint256,uint256)`.\\n mstore(0x00, 0x0c9cd9c1)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(uint256 p0, address p1, uint256 p2, bytes32 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(uint256,address,uint256,string)`.\\n mstore(0x00, 0xddb06521)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, 0x80)\\n writeString(0xa0, p3)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(uint256 p0, address p1, bytes32 p2, address p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(uint256,address,string,address)`.\\n mstore(0x00, 0x9cba8fff)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, 0x80)\\n mstore(0x80, p3)\\n writeString(0xa0, p2)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(uint256 p0, address p1, bytes32 p2, bool p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(uint256,address,string,bool)`.\\n mstore(0x00, 0xcc32ab07)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, 0x80)\\n mstore(0x80, p3)\\n writeString(0xa0, p2)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(uint256 p0, address p1, bytes32 p2, uint256 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(uint256,address,string,uint256)`.\\n mstore(0x00, 0x46826b5d)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, 0x80)\\n mstore(0x80, p3)\\n writeString(0xa0, p2)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(uint256 p0, address p1, bytes32 p2, bytes32 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n // Selector of `log(uint256,address,string,string)`.\\n mstore(0x00, 0x3e128ca3)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, 0x80)\\n mstore(0x80, 0xc0)\\n writeString(0xa0, p2)\\n writeString(0xe0, p3)\\n }\\n _sendLogPayload(0x1c, 0x104);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n }\\n }\\n\\n function log(uint256 p0, bool p1, address p2, address p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(uint256,bool,address,address)`.\\n mstore(0x00, 0xa1ef4cbb)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(uint256 p0, bool p1, address p2, bool p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(uint256,bool,address,bool)`.\\n mstore(0x00, 0x454d54a5)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(uint256 p0, bool p1, address p2, uint256 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(uint256,bool,address,uint256)`.\\n mstore(0x00, 0x078287f5)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(uint256 p0, bool p1, address p2, bytes32 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(uint256,bool,address,string)`.\\n mstore(0x00, 0xade052c7)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, 0x80)\\n writeString(0xa0, p3)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(uint256 p0, bool p1, bool p2, address p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(uint256,bool,bool,address)`.\\n mstore(0x00, 0x69640b59)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(uint256 p0, bool p1, bool p2, bool p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(uint256,bool,bool,bool)`.\\n mstore(0x00, 0xb6f577a1)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(uint256 p0, bool p1, bool p2, uint256 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(uint256,bool,bool,uint256)`.\\n mstore(0x00, 0x7464ce23)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(uint256 p0, bool p1, bool p2, bytes32 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(uint256,bool,bool,string)`.\\n mstore(0x00, 0xdddb9561)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, 0x80)\\n writeString(0xa0, p3)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(uint256 p0, bool p1, uint256 p2, address p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(uint256,bool,uint256,address)`.\\n mstore(0x00, 0x88cb6041)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(uint256 p0, bool p1, uint256 p2, bool p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(uint256,bool,uint256,bool)`.\\n mstore(0x00, 0x91a02e2a)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(uint256 p0, bool p1, uint256 p2, uint256 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(uint256,bool,uint256,uint256)`.\\n mstore(0x00, 0xc6acc7a8)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(uint256 p0, bool p1, uint256 p2, bytes32 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(uint256,bool,uint256,string)`.\\n mstore(0x00, 0xde03e774)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, 0x80)\\n writeString(0xa0, p3)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(uint256 p0, bool p1, bytes32 p2, address p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(uint256,bool,string,address)`.\\n mstore(0x00, 0xef529018)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, 0x80)\\n mstore(0x80, p3)\\n writeString(0xa0, p2)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(uint256 p0, bool p1, bytes32 p2, bool p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(uint256,bool,string,bool)`.\\n mstore(0x00, 0xeb928d7f)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, 0x80)\\n mstore(0x80, p3)\\n writeString(0xa0, p2)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(uint256 p0, bool p1, bytes32 p2, uint256 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(uint256,bool,string,uint256)`.\\n mstore(0x00, 0x2c1d0746)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, 0x80)\\n mstore(0x80, p3)\\n writeString(0xa0, p2)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(uint256 p0, bool p1, bytes32 p2, bytes32 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n // Selector of `log(uint256,bool,string,string)`.\\n mstore(0x00, 0x68c8b8bd)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, 0x80)\\n mstore(0x80, 0xc0)\\n writeString(0xa0, p2)\\n writeString(0xe0, p3)\\n }\\n _sendLogPayload(0x1c, 0x104);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n }\\n }\\n\\n function log(uint256 p0, uint256 p1, address p2, address p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(uint256,uint256,address,address)`.\\n mstore(0x00, 0x56a5d1b1)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(uint256 p0, uint256 p1, address p2, bool p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(uint256,uint256,address,bool)`.\\n mstore(0x00, 0x15cac476)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(uint256 p0, uint256 p1, address p2, uint256 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(uint256,uint256,address,uint256)`.\\n mstore(0x00, 0x88f6e4b2)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(uint256 p0, uint256 p1, address p2, bytes32 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(uint256,uint256,address,string)`.\\n mstore(0x00, 0x6cde40b8)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, 0x80)\\n writeString(0xa0, p3)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(uint256 p0, uint256 p1, bool p2, address p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(uint256,uint256,bool,address)`.\\n mstore(0x00, 0x9a816a83)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(uint256 p0, uint256 p1, bool p2, bool p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(uint256,uint256,bool,bool)`.\\n mstore(0x00, 0xab085ae6)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(uint256 p0, uint256 p1, bool p2, uint256 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(uint256,uint256,bool,uint256)`.\\n mstore(0x00, 0xeb7f6fd2)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(uint256 p0, uint256 p1, bool p2, bytes32 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(uint256,uint256,bool,string)`.\\n mstore(0x00, 0xa5b4fc99)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, 0x80)\\n writeString(0xa0, p3)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(uint256 p0, uint256 p1, uint256 p2, address p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(uint256,uint256,uint256,address)`.\\n mstore(0x00, 0xfa8185af)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(uint256 p0, uint256 p1, uint256 p2, bool p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(uint256,uint256,uint256,bool)`.\\n mstore(0x00, 0xc598d185)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(uint256 p0, uint256 p1, uint256 p2, uint256 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(uint256,uint256,uint256,uint256)`.\\n mstore(0x00, 0x193fb800)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(uint256 p0, uint256 p1, uint256 p2, bytes32 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(uint256,uint256,uint256,string)`.\\n mstore(0x00, 0x59cfcbe3)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, 0x80)\\n writeString(0xa0, p3)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(uint256 p0, uint256 p1, bytes32 p2, address p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(uint256,uint256,string,address)`.\\n mstore(0x00, 0x42d21db7)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, 0x80)\\n mstore(0x80, p3)\\n writeString(0xa0, p2)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(uint256 p0, uint256 p1, bytes32 p2, bool p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(uint256,uint256,string,bool)`.\\n mstore(0x00, 0x7af6ab25)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, 0x80)\\n mstore(0x80, p3)\\n writeString(0xa0, p2)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(uint256 p0, uint256 p1, bytes32 p2, uint256 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(uint256,uint256,string,uint256)`.\\n mstore(0x00, 0x5da297eb)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, 0x80)\\n mstore(0x80, p3)\\n writeString(0xa0, p2)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(uint256 p0, uint256 p1, bytes32 p2, bytes32 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n // Selector of `log(uint256,uint256,string,string)`.\\n mstore(0x00, 0x27d8afd2)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, 0x80)\\n mstore(0x80, 0xc0)\\n writeString(0xa0, p2)\\n writeString(0xe0, p3)\\n }\\n _sendLogPayload(0x1c, 0x104);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n }\\n }\\n\\n function log(uint256 p0, bytes32 p1, address p2, address p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(uint256,string,address,address)`.\\n mstore(0x00, 0x6168ed61)\\n mstore(0x20, p0)\\n mstore(0x40, 0x80)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n writeString(0xa0, p1)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(uint256 p0, bytes32 p1, address p2, bool p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(uint256,string,address,bool)`.\\n mstore(0x00, 0x90c30a56)\\n mstore(0x20, p0)\\n mstore(0x40, 0x80)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n writeString(0xa0, p1)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(uint256 p0, bytes32 p1, address p2, uint256 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(uint256,string,address,uint256)`.\\n mstore(0x00, 0xe8d3018d)\\n mstore(0x20, p0)\\n mstore(0x40, 0x80)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n writeString(0xa0, p1)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(uint256 p0, bytes32 p1, address p2, bytes32 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n // Selector of `log(uint256,string,address,string)`.\\n mstore(0x00, 0x9c3adfa1)\\n mstore(0x20, p0)\\n mstore(0x40, 0x80)\\n mstore(0x60, p2)\\n mstore(0x80, 0xc0)\\n writeString(0xa0, p1)\\n writeString(0xe0, p3)\\n }\\n _sendLogPayload(0x1c, 0x104);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n }\\n }\\n\\n function log(uint256 p0, bytes32 p1, bool p2, address p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(uint256,string,bool,address)`.\\n mstore(0x00, 0xae2ec581)\\n mstore(0x20, p0)\\n mstore(0x40, 0x80)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n writeString(0xa0, p1)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(uint256 p0, bytes32 p1, bool p2, bool p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(uint256,string,bool,bool)`.\\n mstore(0x00, 0xba535d9c)\\n mstore(0x20, p0)\\n mstore(0x40, 0x80)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n writeString(0xa0, p1)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(uint256 p0, bytes32 p1, bool p2, uint256 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(uint256,string,bool,uint256)`.\\n mstore(0x00, 0xcf009880)\\n mstore(0x20, p0)\\n mstore(0x40, 0x80)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n writeString(0xa0, p1)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(uint256 p0, bytes32 p1, bool p2, bytes32 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n // Selector of `log(uint256,string,bool,string)`.\\n mstore(0x00, 0xd2d423cd)\\n mstore(0x20, p0)\\n mstore(0x40, 0x80)\\n mstore(0x60, p2)\\n mstore(0x80, 0xc0)\\n writeString(0xa0, p1)\\n writeString(0xe0, p3)\\n }\\n _sendLogPayload(0x1c, 0x104);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n }\\n }\\n\\n function log(uint256 p0, bytes32 p1, uint256 p2, address p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(uint256,string,uint256,address)`.\\n mstore(0x00, 0x3b2279b4)\\n mstore(0x20, p0)\\n mstore(0x40, 0x80)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n writeString(0xa0, p1)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(uint256 p0, bytes32 p1, uint256 p2, bool p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(uint256,string,uint256,bool)`.\\n mstore(0x00, 0x691a8f74)\\n mstore(0x20, p0)\\n mstore(0x40, 0x80)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n writeString(0xa0, p1)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(uint256 p0, bytes32 p1, uint256 p2, uint256 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(uint256,string,uint256,uint256)`.\\n mstore(0x00, 0x82c25b74)\\n mstore(0x20, p0)\\n mstore(0x40, 0x80)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n writeString(0xa0, p1)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(uint256 p0, bytes32 p1, uint256 p2, bytes32 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n // Selector of `log(uint256,string,uint256,string)`.\\n mstore(0x00, 0xb7b914ca)\\n mstore(0x20, p0)\\n mstore(0x40, 0x80)\\n mstore(0x60, p2)\\n mstore(0x80, 0xc0)\\n writeString(0xa0, p1)\\n writeString(0xe0, p3)\\n }\\n _sendLogPayload(0x1c, 0x104);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n }\\n }\\n\\n function log(uint256 p0, bytes32 p1, bytes32 p2, address p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n // Selector of `log(uint256,string,string,address)`.\\n mstore(0x00, 0xd583c602)\\n mstore(0x20, p0)\\n mstore(0x40, 0x80)\\n mstore(0x60, 0xc0)\\n mstore(0x80, p3)\\n writeString(0xa0, p1)\\n writeString(0xe0, p2)\\n }\\n _sendLogPayload(0x1c, 0x104);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n }\\n }\\n\\n function log(uint256 p0, bytes32 p1, bytes32 p2, bool p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n // Selector of `log(uint256,string,string,bool)`.\\n mstore(0x00, 0xb3a6b6bd)\\n mstore(0x20, p0)\\n mstore(0x40, 0x80)\\n mstore(0x60, 0xc0)\\n mstore(0x80, p3)\\n writeString(0xa0, p1)\\n writeString(0xe0, p2)\\n }\\n _sendLogPayload(0x1c, 0x104);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n }\\n }\\n\\n function log(uint256 p0, bytes32 p1, bytes32 p2, uint256 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n // Selector of `log(uint256,string,string,uint256)`.\\n mstore(0x00, 0xb028c9bd)\\n mstore(0x20, p0)\\n mstore(0x40, 0x80)\\n mstore(0x60, 0xc0)\\n mstore(0x80, p3)\\n writeString(0xa0, p1)\\n writeString(0xe0, p2)\\n }\\n _sendLogPayload(0x1c, 0x104);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n }\\n }\\n\\n function log(uint256 p0, bytes32 p1, bytes32 p2, bytes32 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n bytes32 m9;\\n bytes32 m10;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n m9 := mload(0x120)\\n m10 := mload(0x140)\\n // Selector of `log(uint256,string,string,string)`.\\n mstore(0x00, 0x21ad0683)\\n mstore(0x20, p0)\\n mstore(0x40, 0x80)\\n mstore(0x60, 0xc0)\\n mstore(0x80, 0x100)\\n writeString(0xa0, p1)\\n writeString(0xe0, p2)\\n writeString(0x120, p3)\\n }\\n _sendLogPayload(0x1c, 0x144);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n mstore(0x120, m9)\\n mstore(0x140, m10)\\n }\\n }\\n\\n function log(bytes32 p0, address p1, address p2, address p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(string,address,address,address)`.\\n mstore(0x00, 0xed8f28f6)\\n mstore(0x20, 0x80)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n writeString(0xa0, p0)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(bytes32 p0, address p1, address p2, bool p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(string,address,address,bool)`.\\n mstore(0x00, 0xb59dbd60)\\n mstore(0x20, 0x80)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n writeString(0xa0, p0)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(bytes32 p0, address p1, address p2, uint256 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(string,address,address,uint256)`.\\n mstore(0x00, 0x8ef3f399)\\n mstore(0x20, 0x80)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n writeString(0xa0, p0)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(bytes32 p0, address p1, address p2, bytes32 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n // Selector of `log(string,address,address,string)`.\\n mstore(0x00, 0x800a1c67)\\n mstore(0x20, 0x80)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, 0xc0)\\n writeString(0xa0, p0)\\n writeString(0xe0, p3)\\n }\\n _sendLogPayload(0x1c, 0x104);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n }\\n }\\n\\n function log(bytes32 p0, address p1, bool p2, address p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(string,address,bool,address)`.\\n mstore(0x00, 0x223603bd)\\n mstore(0x20, 0x80)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n writeString(0xa0, p0)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(bytes32 p0, address p1, bool p2, bool p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(string,address,bool,bool)`.\\n mstore(0x00, 0x79884c2b)\\n mstore(0x20, 0x80)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n writeString(0xa0, p0)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(bytes32 p0, address p1, bool p2, uint256 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(string,address,bool,uint256)`.\\n mstore(0x00, 0x3e9f866a)\\n mstore(0x20, 0x80)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n writeString(0xa0, p0)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(bytes32 p0, address p1, bool p2, bytes32 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n // Selector of `log(string,address,bool,string)`.\\n mstore(0x00, 0x0454c079)\\n mstore(0x20, 0x80)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, 0xc0)\\n writeString(0xa0, p0)\\n writeString(0xe0, p3)\\n }\\n _sendLogPayload(0x1c, 0x104);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n }\\n }\\n\\n function log(bytes32 p0, address p1, uint256 p2, address p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(string,address,uint256,address)`.\\n mstore(0x00, 0x63fb8bc5)\\n mstore(0x20, 0x80)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n writeString(0xa0, p0)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(bytes32 p0, address p1, uint256 p2, bool p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(string,address,uint256,bool)`.\\n mstore(0x00, 0xfc4845f0)\\n mstore(0x20, 0x80)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n writeString(0xa0, p0)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(bytes32 p0, address p1, uint256 p2, uint256 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(string,address,uint256,uint256)`.\\n mstore(0x00, 0xf8f51b1e)\\n mstore(0x20, 0x80)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n writeString(0xa0, p0)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(bytes32 p0, address p1, uint256 p2, bytes32 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n // Selector of `log(string,address,uint256,string)`.\\n mstore(0x00, 0x5a477632)\\n mstore(0x20, 0x80)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, 0xc0)\\n writeString(0xa0, p0)\\n writeString(0xe0, p3)\\n }\\n _sendLogPayload(0x1c, 0x104);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n }\\n }\\n\\n function log(bytes32 p0, address p1, bytes32 p2, address p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n // Selector of `log(string,address,string,address)`.\\n mstore(0x00, 0xaabc9a31)\\n mstore(0x20, 0x80)\\n mstore(0x40, p1)\\n mstore(0x60, 0xc0)\\n mstore(0x80, p3)\\n writeString(0xa0, p0)\\n writeString(0xe0, p2)\\n }\\n _sendLogPayload(0x1c, 0x104);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n }\\n }\\n\\n function log(bytes32 p0, address p1, bytes32 p2, bool p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n // Selector of `log(string,address,string,bool)`.\\n mstore(0x00, 0x5f15d28c)\\n mstore(0x20, 0x80)\\n mstore(0x40, p1)\\n mstore(0x60, 0xc0)\\n mstore(0x80, p3)\\n writeString(0xa0, p0)\\n writeString(0xe0, p2)\\n }\\n _sendLogPayload(0x1c, 0x104);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n }\\n }\\n\\n function log(bytes32 p0, address p1, bytes32 p2, uint256 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n // Selector of `log(string,address,string,uint256)`.\\n mstore(0x00, 0x91d1112e)\\n mstore(0x20, 0x80)\\n mstore(0x40, p1)\\n mstore(0x60, 0xc0)\\n mstore(0x80, p3)\\n writeString(0xa0, p0)\\n writeString(0xe0, p2)\\n }\\n _sendLogPayload(0x1c, 0x104);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n }\\n }\\n\\n function log(bytes32 p0, address p1, bytes32 p2, bytes32 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n bytes32 m9;\\n bytes32 m10;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n m9 := mload(0x120)\\n m10 := mload(0x140)\\n // Selector of `log(string,address,string,string)`.\\n mstore(0x00, 0x245986f2)\\n mstore(0x20, 0x80)\\n mstore(0x40, p1)\\n mstore(0x60, 0xc0)\\n mstore(0x80, 0x100)\\n writeString(0xa0, p0)\\n writeString(0xe0, p2)\\n writeString(0x120, p3)\\n }\\n _sendLogPayload(0x1c, 0x144);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n mstore(0x120, m9)\\n mstore(0x140, m10)\\n }\\n }\\n\\n function log(bytes32 p0, bool p1, address p2, address p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(string,bool,address,address)`.\\n mstore(0x00, 0x33e9dd1d)\\n mstore(0x20, 0x80)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n writeString(0xa0, p0)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(bytes32 p0, bool p1, address p2, bool p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(string,bool,address,bool)`.\\n mstore(0x00, 0x958c28c6)\\n mstore(0x20, 0x80)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n writeString(0xa0, p0)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(bytes32 p0, bool p1, address p2, uint256 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(string,bool,address,uint256)`.\\n mstore(0x00, 0x5d08bb05)\\n mstore(0x20, 0x80)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n writeString(0xa0, p0)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(bytes32 p0, bool p1, address p2, bytes32 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n // Selector of `log(string,bool,address,string)`.\\n mstore(0x00, 0x2d8e33a4)\\n mstore(0x20, 0x80)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, 0xc0)\\n writeString(0xa0, p0)\\n writeString(0xe0, p3)\\n }\\n _sendLogPayload(0x1c, 0x104);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n }\\n }\\n\\n function log(bytes32 p0, bool p1, bool p2, address p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(string,bool,bool,address)`.\\n mstore(0x00, 0x7190a529)\\n mstore(0x20, 0x80)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n writeString(0xa0, p0)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(bytes32 p0, bool p1, bool p2, bool p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(string,bool,bool,bool)`.\\n mstore(0x00, 0x895af8c5)\\n mstore(0x20, 0x80)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n writeString(0xa0, p0)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(bytes32 p0, bool p1, bool p2, uint256 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(string,bool,bool,uint256)`.\\n mstore(0x00, 0x8e3f78a9)\\n mstore(0x20, 0x80)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n writeString(0xa0, p0)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(bytes32 p0, bool p1, bool p2, bytes32 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n // Selector of `log(string,bool,bool,string)`.\\n mstore(0x00, 0x9d22d5dd)\\n mstore(0x20, 0x80)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, 0xc0)\\n writeString(0xa0, p0)\\n writeString(0xe0, p3)\\n }\\n _sendLogPayload(0x1c, 0x104);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n }\\n }\\n\\n function log(bytes32 p0, bool p1, uint256 p2, address p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(string,bool,uint256,address)`.\\n mstore(0x00, 0x935e09bf)\\n mstore(0x20, 0x80)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n writeString(0xa0, p0)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(bytes32 p0, bool p1, uint256 p2, bool p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(string,bool,uint256,bool)`.\\n mstore(0x00, 0x8af7cf8a)\\n mstore(0x20, 0x80)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n writeString(0xa0, p0)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(bytes32 p0, bool p1, uint256 p2, uint256 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(string,bool,uint256,uint256)`.\\n mstore(0x00, 0x64b5bb67)\\n mstore(0x20, 0x80)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n writeString(0xa0, p0)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(bytes32 p0, bool p1, uint256 p2, bytes32 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n // Selector of `log(string,bool,uint256,string)`.\\n mstore(0x00, 0x742d6ee7)\\n mstore(0x20, 0x80)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, 0xc0)\\n writeString(0xa0, p0)\\n writeString(0xe0, p3)\\n }\\n _sendLogPayload(0x1c, 0x104);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n }\\n }\\n\\n function log(bytes32 p0, bool p1, bytes32 p2, address p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n // Selector of `log(string,bool,string,address)`.\\n mstore(0x00, 0xe0625b29)\\n mstore(0x20, 0x80)\\n mstore(0x40, p1)\\n mstore(0x60, 0xc0)\\n mstore(0x80, p3)\\n writeString(0xa0, p0)\\n writeString(0xe0, p2)\\n }\\n _sendLogPayload(0x1c, 0x104);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n }\\n }\\n\\n function log(bytes32 p0, bool p1, bytes32 p2, bool p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n // Selector of `log(string,bool,string,bool)`.\\n mstore(0x00, 0x3f8a701d)\\n mstore(0x20, 0x80)\\n mstore(0x40, p1)\\n mstore(0x60, 0xc0)\\n mstore(0x80, p3)\\n writeString(0xa0, p0)\\n writeString(0xe0, p2)\\n }\\n _sendLogPayload(0x1c, 0x104);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n }\\n }\\n\\n function log(bytes32 p0, bool p1, bytes32 p2, uint256 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n // Selector of `log(string,bool,string,uint256)`.\\n mstore(0x00, 0x24f91465)\\n mstore(0x20, 0x80)\\n mstore(0x40, p1)\\n mstore(0x60, 0xc0)\\n mstore(0x80, p3)\\n writeString(0xa0, p0)\\n writeString(0xe0, p2)\\n }\\n _sendLogPayload(0x1c, 0x104);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n }\\n }\\n\\n function log(bytes32 p0, bool p1, bytes32 p2, bytes32 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n bytes32 m9;\\n bytes32 m10;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n m9 := mload(0x120)\\n m10 := mload(0x140)\\n // Selector of `log(string,bool,string,string)`.\\n mstore(0x00, 0xa826caeb)\\n mstore(0x20, 0x80)\\n mstore(0x40, p1)\\n mstore(0x60, 0xc0)\\n mstore(0x80, 0x100)\\n writeString(0xa0, p0)\\n writeString(0xe0, p2)\\n writeString(0x120, p3)\\n }\\n _sendLogPayload(0x1c, 0x144);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n mstore(0x120, m9)\\n mstore(0x140, m10)\\n }\\n }\\n\\n function log(bytes32 p0, uint256 p1, address p2, address p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(string,uint256,address,address)`.\\n mstore(0x00, 0x5ea2b7ae)\\n mstore(0x20, 0x80)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n writeString(0xa0, p0)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(bytes32 p0, uint256 p1, address p2, bool p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(string,uint256,address,bool)`.\\n mstore(0x00, 0x82112a42)\\n mstore(0x20, 0x80)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n writeString(0xa0, p0)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(bytes32 p0, uint256 p1, address p2, uint256 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(string,uint256,address,uint256)`.\\n mstore(0x00, 0x4f04fdc6)\\n mstore(0x20, 0x80)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n writeString(0xa0, p0)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(bytes32 p0, uint256 p1, address p2, bytes32 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n // Selector of `log(string,uint256,address,string)`.\\n mstore(0x00, 0x9ffb2f93)\\n mstore(0x20, 0x80)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, 0xc0)\\n writeString(0xa0, p0)\\n writeString(0xe0, p3)\\n }\\n _sendLogPayload(0x1c, 0x104);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n }\\n }\\n\\n function log(bytes32 p0, uint256 p1, bool p2, address p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(string,uint256,bool,address)`.\\n mstore(0x00, 0xe0e95b98)\\n mstore(0x20, 0x80)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n writeString(0xa0, p0)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(bytes32 p0, uint256 p1, bool p2, bool p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(string,uint256,bool,bool)`.\\n mstore(0x00, 0x354c36d6)\\n mstore(0x20, 0x80)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n writeString(0xa0, p0)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(bytes32 p0, uint256 p1, bool p2, uint256 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(string,uint256,bool,uint256)`.\\n mstore(0x00, 0xe41b6f6f)\\n mstore(0x20, 0x80)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n writeString(0xa0, p0)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(bytes32 p0, uint256 p1, bool p2, bytes32 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n // Selector of `log(string,uint256,bool,string)`.\\n mstore(0x00, 0xabf73a98)\\n mstore(0x20, 0x80)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, 0xc0)\\n writeString(0xa0, p0)\\n writeString(0xe0, p3)\\n }\\n _sendLogPayload(0x1c, 0x104);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n }\\n }\\n\\n function log(bytes32 p0, uint256 p1, uint256 p2, address p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(string,uint256,uint256,address)`.\\n mstore(0x00, 0xe21de278)\\n mstore(0x20, 0x80)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n writeString(0xa0, p0)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(bytes32 p0, uint256 p1, uint256 p2, bool p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(string,uint256,uint256,bool)`.\\n mstore(0x00, 0x7626db92)\\n mstore(0x20, 0x80)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n writeString(0xa0, p0)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(bytes32 p0, uint256 p1, uint256 p2, uint256 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(string,uint256,uint256,uint256)`.\\n mstore(0x00, 0xa7a87853)\\n mstore(0x20, 0x80)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n writeString(0xa0, p0)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(bytes32 p0, uint256 p1, uint256 p2, bytes32 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n // Selector of `log(string,uint256,uint256,string)`.\\n mstore(0x00, 0x854b3496)\\n mstore(0x20, 0x80)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, 0xc0)\\n writeString(0xa0, p0)\\n writeString(0xe0, p3)\\n }\\n _sendLogPayload(0x1c, 0x104);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n }\\n }\\n\\n function log(bytes32 p0, uint256 p1, bytes32 p2, address p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n // Selector of `log(string,uint256,string,address)`.\\n mstore(0x00, 0x7c4632a4)\\n mstore(0x20, 0x80)\\n mstore(0x40, p1)\\n mstore(0x60, 0xc0)\\n mstore(0x80, p3)\\n writeString(0xa0, p0)\\n writeString(0xe0, p2)\\n }\\n _sendLogPayload(0x1c, 0x104);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n }\\n }\\n\\n function log(bytes32 p0, uint256 p1, bytes32 p2, bool p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n // Selector of `log(string,uint256,string,bool)`.\\n mstore(0x00, 0x7d24491d)\\n mstore(0x20, 0x80)\\n mstore(0x40, p1)\\n mstore(0x60, 0xc0)\\n mstore(0x80, p3)\\n writeString(0xa0, p0)\\n writeString(0xe0, p2)\\n }\\n _sendLogPayload(0x1c, 0x104);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n }\\n }\\n\\n function log(bytes32 p0, uint256 p1, bytes32 p2, uint256 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n // Selector of `log(string,uint256,string,uint256)`.\\n mstore(0x00, 0xc67ea9d1)\\n mstore(0x20, 0x80)\\n mstore(0x40, p1)\\n mstore(0x60, 0xc0)\\n mstore(0x80, p3)\\n writeString(0xa0, p0)\\n writeString(0xe0, p2)\\n }\\n _sendLogPayload(0x1c, 0x104);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n }\\n }\\n\\n function log(bytes32 p0, uint256 p1, bytes32 p2, bytes32 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n bytes32 m9;\\n bytes32 m10;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n m9 := mload(0x120)\\n m10 := mload(0x140)\\n // Selector of `log(string,uint256,string,string)`.\\n mstore(0x00, 0x5ab84e1f)\\n mstore(0x20, 0x80)\\n mstore(0x40, p1)\\n mstore(0x60, 0xc0)\\n mstore(0x80, 0x100)\\n writeString(0xa0, p0)\\n writeString(0xe0, p2)\\n writeString(0x120, p3)\\n }\\n _sendLogPayload(0x1c, 0x144);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n mstore(0x120, m9)\\n mstore(0x140, m10)\\n }\\n }\\n\\n function log(bytes32 p0, bytes32 p1, address p2, address p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n // Selector of `log(string,string,address,address)`.\\n mstore(0x00, 0x439c7bef)\\n mstore(0x20, 0x80)\\n mstore(0x40, 0xc0)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n writeString(0xa0, p0)\\n writeString(0xe0, p1)\\n }\\n _sendLogPayload(0x1c, 0x104);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n }\\n }\\n\\n function log(bytes32 p0, bytes32 p1, address p2, bool p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n // Selector of `log(string,string,address,bool)`.\\n mstore(0x00, 0x5ccd4e37)\\n mstore(0x20, 0x80)\\n mstore(0x40, 0xc0)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n writeString(0xa0, p0)\\n writeString(0xe0, p1)\\n }\\n _sendLogPayload(0x1c, 0x104);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n }\\n }\\n\\n function log(bytes32 p0, bytes32 p1, address p2, uint256 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n // Selector of `log(string,string,address,uint256)`.\\n mstore(0x00, 0x7cc3c607)\\n mstore(0x20, 0x80)\\n mstore(0x40, 0xc0)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n writeString(0xa0, p0)\\n writeString(0xe0, p1)\\n }\\n _sendLogPayload(0x1c, 0x104);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n }\\n }\\n\\n function log(bytes32 p0, bytes32 p1, address p2, bytes32 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n bytes32 m9;\\n bytes32 m10;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n m9 := mload(0x120)\\n m10 := mload(0x140)\\n // Selector of `log(string,string,address,string)`.\\n mstore(0x00, 0xeb1bff80)\\n mstore(0x20, 0x80)\\n mstore(0x40, 0xc0)\\n mstore(0x60, p2)\\n mstore(0x80, 0x100)\\n writeString(0xa0, p0)\\n writeString(0xe0, p1)\\n writeString(0x120, p3)\\n }\\n _sendLogPayload(0x1c, 0x144);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n mstore(0x120, m9)\\n mstore(0x140, m10)\\n }\\n }\\n\\n function log(bytes32 p0, bytes32 p1, bool p2, address p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n // Selector of `log(string,string,bool,address)`.\\n mstore(0x00, 0xc371c7db)\\n mstore(0x20, 0x80)\\n mstore(0x40, 0xc0)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n writeString(0xa0, p0)\\n writeString(0xe0, p1)\\n }\\n _sendLogPayload(0x1c, 0x104);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n }\\n }\\n\\n function log(bytes32 p0, bytes32 p1, bool p2, bool p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n // Selector of `log(string,string,bool,bool)`.\\n mstore(0x00, 0x40785869)\\n mstore(0x20, 0x80)\\n mstore(0x40, 0xc0)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n writeString(0xa0, p0)\\n writeString(0xe0, p1)\\n }\\n _sendLogPayload(0x1c, 0x104);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n }\\n }\\n\\n function log(bytes32 p0, bytes32 p1, bool p2, uint256 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n // Selector of `log(string,string,bool,uint256)`.\\n mstore(0x00, 0xd6aefad2)\\n mstore(0x20, 0x80)\\n mstore(0x40, 0xc0)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n writeString(0xa0, p0)\\n writeString(0xe0, p1)\\n }\\n _sendLogPayload(0x1c, 0x104);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n }\\n }\\n\\n function log(bytes32 p0, bytes32 p1, bool p2, bytes32 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n bytes32 m9;\\n bytes32 m10;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n m9 := mload(0x120)\\n m10 := mload(0x140)\\n // Selector of `log(string,string,bool,string)`.\\n mstore(0x00, 0x5e84b0ea)\\n mstore(0x20, 0x80)\\n mstore(0x40, 0xc0)\\n mstore(0x60, p2)\\n mstore(0x80, 0x100)\\n writeString(0xa0, p0)\\n writeString(0xe0, p1)\\n writeString(0x120, p3)\\n }\\n _sendLogPayload(0x1c, 0x144);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n mstore(0x120, m9)\\n mstore(0x140, m10)\\n }\\n }\\n\\n function log(bytes32 p0, bytes32 p1, uint256 p2, address p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n // Selector of `log(string,string,uint256,address)`.\\n mstore(0x00, 0x1023f7b2)\\n mstore(0x20, 0x80)\\n mstore(0x40, 0xc0)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n writeString(0xa0, p0)\\n writeString(0xe0, p1)\\n }\\n _sendLogPayload(0x1c, 0x104);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n }\\n }\\n\\n function log(bytes32 p0, bytes32 p1, uint256 p2, bool p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n // Selector of `log(string,string,uint256,bool)`.\\n mstore(0x00, 0xc3a8a654)\\n mstore(0x20, 0x80)\\n mstore(0x40, 0xc0)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n writeString(0xa0, p0)\\n writeString(0xe0, p1)\\n }\\n _sendLogPayload(0x1c, 0x104);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n }\\n }\\n\\n function log(bytes32 p0, bytes32 p1, uint256 p2, uint256 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n // Selector of `log(string,string,uint256,uint256)`.\\n mstore(0x00, 0xf45d7d2c)\\n mstore(0x20, 0x80)\\n mstore(0x40, 0xc0)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n writeString(0xa0, p0)\\n writeString(0xe0, p1)\\n }\\n _sendLogPayload(0x1c, 0x104);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n }\\n }\\n\\n function log(bytes32 p0, bytes32 p1, uint256 p2, bytes32 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n bytes32 m9;\\n bytes32 m10;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n m9 := mload(0x120)\\n m10 := mload(0x140)\\n // Selector of `log(string,string,uint256,string)`.\\n mstore(0x00, 0x5d1a971a)\\n mstore(0x20, 0x80)\\n mstore(0x40, 0xc0)\\n mstore(0x60, p2)\\n mstore(0x80, 0x100)\\n writeString(0xa0, p0)\\n writeString(0xe0, p1)\\n writeString(0x120, p3)\\n }\\n _sendLogPayload(0x1c, 0x144);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n mstore(0x120, m9)\\n mstore(0x140, m10)\\n }\\n }\\n\\n function log(bytes32 p0, bytes32 p1, bytes32 p2, address p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n bytes32 m9;\\n bytes32 m10;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n m9 := mload(0x120)\\n m10 := mload(0x140)\\n // Selector of `log(string,string,string,address)`.\\n mstore(0x00, 0x6d572f44)\\n mstore(0x20, 0x80)\\n mstore(0x40, 0xc0)\\n mstore(0x60, 0x100)\\n mstore(0x80, p3)\\n writeString(0xa0, p0)\\n writeString(0xe0, p1)\\n writeString(0x120, p2)\\n }\\n _sendLogPayload(0x1c, 0x144);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n mstore(0x120, m9)\\n mstore(0x140, m10)\\n }\\n }\\n\\n function log(bytes32 p0, bytes32 p1, bytes32 p2, bool p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n bytes32 m9;\\n bytes32 m10;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n m9 := mload(0x120)\\n m10 := mload(0x140)\\n // Selector of `log(string,string,string,bool)`.\\n mstore(0x00, 0x2c1754ed)\\n mstore(0x20, 0x80)\\n mstore(0x40, 0xc0)\\n mstore(0x60, 0x100)\\n mstore(0x80, p3)\\n writeString(0xa0, p0)\\n writeString(0xe0, p1)\\n writeString(0x120, p2)\\n }\\n _sendLogPayload(0x1c, 0x144);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n mstore(0x120, m9)\\n mstore(0x140, m10)\\n }\\n }\\n\\n function log(bytes32 p0, bytes32 p1, bytes32 p2, uint256 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n bytes32 m9;\\n bytes32 m10;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n m9 := mload(0x120)\\n m10 := mload(0x140)\\n // Selector of `log(string,string,string,uint256)`.\\n mstore(0x00, 0x8eafb02b)\\n mstore(0x20, 0x80)\\n mstore(0x40, 0xc0)\\n mstore(0x60, 0x100)\\n mstore(0x80, p3)\\n writeString(0xa0, p0)\\n writeString(0xe0, p1)\\n writeString(0x120, p2)\\n }\\n _sendLogPayload(0x1c, 0x144);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n mstore(0x120, m9)\\n mstore(0x140, m10)\\n }\\n }\\n\\n function log(bytes32 p0, bytes32 p1, bytes32 p2, bytes32 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n bytes32 m9;\\n bytes32 m10;\\n bytes32 m11;\\n bytes32 m12;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n m9 := mload(0x120)\\n m10 := mload(0x140)\\n m11 := mload(0x160)\\n m12 := mload(0x180)\\n // Selector of `log(string,string,string,string)`.\\n mstore(0x00, 0xde68f20a)\\n mstore(0x20, 0x80)\\n mstore(0x40, 0xc0)\\n mstore(0x60, 0x100)\\n mstore(0x80, 0x140)\\n writeString(0xa0, p0)\\n writeString(0xe0, p1)\\n writeString(0x120, p2)\\n writeString(0x160, p3)\\n }\\n _sendLogPayload(0x1c, 0x184);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n mstore(0x120, m9)\\n mstore(0x140, m10)\\n mstore(0x160, m11)\\n mstore(0x180, m12)\\n }\\n }\\n}\\n\",\"keccak256\":\"0xbef9786cb49d3eade757bad87568c49c8c8f35721f0193c95ffb055d9e466e11\",\"license\":\"MIT\"},\"scripts/FetchChainInfo.s.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\nimport { Script } from \\\"forge-std/Script.sol\\\";\\nimport { GameTypes, GameType } from \\\"src/dispute/lib/Types.sol\\\";\\n\\n/// @notice Contains getters for arbitrary methods from all L1 contracts, including legacy getters\\n/// that have since been deprecated.\\ninterface IFetcher {\\n function guardian() external view returns (address);\\n function GUARDIAN() external view returns (address);\\n function systemConfig() external view returns (address);\\n function SYSTEM_CONFIG() external view returns (address);\\n function disputeGameFactory() external view returns (address);\\n function ethLockbox() external view returns (address);\\n function superchainConfig() external view returns (address);\\n function messenger() external view returns (address);\\n function addressManager() external view returns (address);\\n function PORTAL() external view returns (address);\\n function portal() external view returns (address);\\n function l1ERC721Bridge() external view returns (address);\\n function optimismMintableERC20Factory() external view returns (address);\\n function gameImpls(GameType _gameType) external view returns (address);\\n function respectedGameType() external view returns (GameType);\\n function anchorStateRegistry() external view returns (address);\\n function L2_ORACLE() external view returns (address);\\n function l2Oracle() external view returns (address);\\n function vm() external view returns (address);\\n function oracle() external view returns (address);\\n function challenger() external view returns (address);\\n function proposer() external view returns (address);\\n function PROPOSER() external view returns (address);\\n function batcherHash() external view returns (bytes32);\\n function admin() external view returns (address);\\n function owner() external view returns (address);\\n function unsafeBlockSigner() external view returns (address);\\n function weth() external view returns (address);\\n}\\n\\ncontract FetchChainInfoInput {\\n address internal _systemConfigProxy;\\n address internal _l1StandardBridgeProxy;\\n\\n function set(bytes4 _sel, address _addr) public {\\n require(_addr != address(0), \\\"FetchChainInfoInput: cannot set zero address\\\");\\n if (_sel == this.systemConfigProxy.selector) _systemConfigProxy = _addr;\\n else if (_sel == this.l1StandardBridgeProxy.selector) _l1StandardBridgeProxy = _addr;\\n else revert(\\\"FetchChainInfoInput: unknown selector\\\");\\n }\\n\\n function systemConfigProxy() public view returns (address) {\\n require(_systemConfigProxy != address(0), \\\"FetchChainInfoInput: systemConfigProxy not set\\\");\\n return _systemConfigProxy;\\n }\\n\\n function l1StandardBridgeProxy() public view returns (address) {\\n require(_l1StandardBridgeProxy != address(0), \\\"FetchChainInfoInput: l1StandardBridgeProxy not set\\\");\\n return _l1StandardBridgeProxy;\\n }\\n}\\n\\ncontract FetchChainInfoOutput {\\n // contract addresses\\n // - SuperchainContracts\\n address internal _superchainConfigProxy;\\n // - ImplementationsContracts\\n address internal _mipsImpl;\\n address internal _preimageOracleImpl;\\n // - OpChainContracts\\n address internal _addressManagerImpl;\\n address internal _ethLockboxProxy;\\n address internal _l1CrossDomainMessengerProxy;\\n address internal _l1Erc721BridgeProxy;\\n address internal _l1StandardBridgeProxy;\\n address internal _l2OutputOracleProxy;\\n address internal _optimismMintableErc20FactoryProxy;\\n address internal _optimismPortalProxy;\\n address internal _systemConfigProxy;\\n address internal _opChainProxyAdminImpl;\\n address internal _anchorStateRegistryProxy;\\n address internal _delayedWethPermissionedGameProxy;\\n address internal _delayedWethPermissionlessGameProxy;\\n address internal _disputeGameFactoryProxy;\\n address internal _faultDisputeGameImpl;\\n address internal _faultDisputeGameCannonKonaImpl;\\n address internal _permissionedDisputeGameImpl;\\n\\n // roles\\n address internal _systemConfigOwner;\\n address internal _opChainProxyAdminOwner;\\n address internal _opChainGuardian;\\n address internal _challenger;\\n address internal _proposer;\\n address internal _unsafeBlockSigner;\\n address internal _batchSubmitter;\\n\\n // fault proof status\\n bool internal _permissioned;\\n bool internal _permissionless;\\n GameType internal _respectedGameType;\\n\\n function set(bytes4 _sel, address _addr) public {\\n // SuperchainContracts\\n if (_sel == this.superchainConfigProxy.selector) _superchainConfigProxy = _addr;\\n // - ImplementationsContracts\\n else if (_sel == this.mipsImpl.selector) _mipsImpl = _addr;\\n else if (_sel == this.preimageOracleImpl.selector) _preimageOracleImpl = _addr;\\n // - OpChainContracts\\n else if (_sel == this.addressManagerImpl.selector) _addressManagerImpl = _addr;\\n else if (_sel == this.ethLockboxProxy.selector) _ethLockboxProxy = _addr;\\n else if (_sel == this.l1CrossDomainMessengerProxy.selector) _l1CrossDomainMessengerProxy = _addr;\\n else if (_sel == this.l1Erc721BridgeProxy.selector) _l1Erc721BridgeProxy = _addr;\\n else if (_sel == this.l1StandardBridgeProxy.selector) _l1StandardBridgeProxy = _addr;\\n else if (_sel == this.l2OutputOracleProxy.selector) _l2OutputOracleProxy = _addr;\\n else if (_sel == this.optimismMintableErc20FactoryProxy.selector) _optimismMintableErc20FactoryProxy = _addr;\\n else if (_sel == this.optimismPortalProxy.selector) _optimismPortalProxy = _addr;\\n else if (_sel == this.systemConfigProxy.selector) _systemConfigProxy = _addr;\\n else if (_sel == this.opChainProxyAdminImpl.selector) _opChainProxyAdminImpl = _addr;\\n else if (_sel == this.anchorStateRegistryProxy.selector) _anchorStateRegistryProxy = _addr;\\n else if (_sel == this.delayedWethPermissionedGameProxy.selector) _delayedWethPermissionedGameProxy = _addr;\\n else if (_sel == this.delayedWethPermissionlessGameProxy.selector) _delayedWethPermissionlessGameProxy = _addr;\\n else if (_sel == this.disputeGameFactoryProxy.selector) _disputeGameFactoryProxy = _addr;\\n else if (_sel == this.faultDisputeGameImpl.selector) _faultDisputeGameImpl = _addr;\\n else if (_sel == this.faultDisputeGameCannonKonaImpl.selector) _faultDisputeGameCannonKonaImpl = _addr;\\n else if (_sel == this.permissionedDisputeGameImpl.selector) _permissionedDisputeGameImpl = _addr;\\n // roles\\n else if (_sel == this.systemConfigOwner.selector) _systemConfigOwner = _addr;\\n else if (_sel == this.opChainProxyAdminOwner.selector) _opChainProxyAdminOwner = _addr;\\n else if (_sel == this.opChainGuardian.selector) _opChainGuardian = _addr;\\n else if (_sel == this.challenger.selector) _challenger = _addr;\\n else if (_sel == this.proposer.selector) _proposer = _addr;\\n else if (_sel == this.unsafeBlockSigner.selector) _unsafeBlockSigner = _addr;\\n else if (_sel == this.batchSubmitter.selector) _batchSubmitter = _addr;\\n else revert(\\\"FetchChainInfoOutput: unknown address selector test\\\");\\n }\\n\\n function set(bytes4 _sel, bool _bool) public {\\n if (_sel == this.permissioned.selector) _permissioned = _bool;\\n else if (_sel == this.permissionless.selector) _permissionless = _bool;\\n else revert(\\\"FetchChainInfoOutput: unknown bool selector\\\");\\n }\\n\\n function set(bytes4 _sel, GameType _gameType) public {\\n if (_sel == this.respectedGameType.selector) _respectedGameType = _gameType;\\n else revert(\\\"FetchChainInfoOutput: unknown GameType selector\\\");\\n }\\n\\n function addressManagerImpl() public view returns (address) {\\n require(_addressManagerImpl != address(0), \\\"FetchChainInfoOutput: addressManagerImpl not set\\\");\\n return _addressManagerImpl;\\n }\\n\\n function ethLockboxProxy() public view returns (address) {\\n return _ethLockboxProxy;\\n }\\n\\n function l1CrossDomainMessengerProxy() public view returns (address) {\\n require(_l1CrossDomainMessengerProxy != address(0), \\\"FetchChainInfoOutput: l1CrossDomainMessengerProxy not set\\\");\\n return _l1CrossDomainMessengerProxy;\\n }\\n\\n function l1Erc721BridgeProxy() public view returns (address) {\\n require(_l1Erc721BridgeProxy != address(0), \\\"FetchChainInfoOutput: l1Erc721BridgeProxy not set\\\");\\n return _l1Erc721BridgeProxy;\\n }\\n\\n function l1StandardBridgeProxy() public view returns (address) {\\n require(_l1StandardBridgeProxy != address(0), \\\"FetchChainInfoOutput: l1StandardBridgeProxy not set\\\");\\n return _l1StandardBridgeProxy;\\n }\\n\\n function l2OutputOracleProxy() public view returns (address) {\\n require(_l2OutputOracleProxy != address(0), \\\"FetchChainInfoOutput: l2OutputOracleProxy not set\\\");\\n return _l2OutputOracleProxy;\\n }\\n\\n function optimismMintableErc20FactoryProxy() public view returns (address) {\\n require(\\n _optimismMintableErc20FactoryProxy != address(0),\\n \\\"FetchChainInfoOutput: optimismMintableErc20FactoryProxy not set\\\"\\n );\\n return _optimismMintableErc20FactoryProxy;\\n }\\n\\n function optimismPortalProxy() public view returns (address) {\\n require(_optimismPortalProxy != address(0), \\\"FetchChainInfoOutput: optimismPortalProxy not set\\\");\\n return _optimismPortalProxy;\\n }\\n\\n function systemConfigProxy() public view returns (address) {\\n require(_systemConfigProxy != address(0), \\\"FetchChainInfoOutput: systemConfigProxy not set\\\");\\n return _systemConfigProxy;\\n }\\n\\n function opChainProxyAdminImpl() public view returns (address) {\\n require(_opChainProxyAdminImpl != address(0), \\\"FetchChainInfoOutput: opChainProxyAdminImpl not set\\\");\\n return _opChainProxyAdminImpl;\\n }\\n\\n function superchainConfigProxy() public view returns (address) {\\n require(_superchainConfigProxy != address(0), \\\"FetchChainInfoOutput: superchainConfigProxy not set\\\");\\n return _superchainConfigProxy;\\n }\\n\\n function anchorStateRegistryProxy() public view returns (address) {\\n require(_anchorStateRegistryProxy != address(0), \\\"FetchChainInfoOutput: anchorStateRegistryProxy not set\\\");\\n return _anchorStateRegistryProxy;\\n }\\n\\n function delayedWethPermissionedGameProxy() public view returns (address) {\\n return _delayedWethPermissionedGameProxy;\\n }\\n\\n function delayedWethPermissionlessGameProxy() public view returns (address) {\\n return _delayedWethPermissionlessGameProxy;\\n }\\n\\n function disputeGameFactoryProxy() public view returns (address) {\\n return _disputeGameFactoryProxy;\\n }\\n\\n function faultDisputeGameImpl() public view returns (address) {\\n require(_faultDisputeGameImpl != address(0), \\\"FetchChainInfoOutput: faultDisputeGameImpl not set\\\");\\n return _faultDisputeGameImpl;\\n }\\n\\n function faultDisputeGameCannonKonaImpl() public view returns (address) {\\n require(\\n _faultDisputeGameCannonKonaImpl != address(0),\\n \\\"FetchChainInfoOutput: faultDisputeGameCannonKonaImpl not set\\\"\\n );\\n return _faultDisputeGameCannonKonaImpl;\\n }\\n\\n function mipsImpl() public view returns (address) {\\n require(_mipsImpl != address(0), \\\"FetchChainInfoOutput: mipsImpl not set\\\");\\n return _mipsImpl;\\n }\\n\\n function permissionedDisputeGameImpl() public view returns (address) {\\n require(_permissionedDisputeGameImpl != address(0), \\\"FetchChainInfoOutput: permissionedDisputeGameImpl not set\\\");\\n return _permissionedDisputeGameImpl;\\n }\\n\\n function preimageOracleImpl() public view returns (address) {\\n require(_preimageOracleImpl != address(0), \\\"FetchChainInfoOutput: preimageOracleImpl not set\\\");\\n return _preimageOracleImpl;\\n }\\n\\n function systemConfigOwner() public view returns (address) {\\n require(_systemConfigOwner != address(0), \\\"FetchChainInfoOutput: systemConfigOwner not set\\\");\\n return _systemConfigOwner;\\n }\\n\\n function opChainProxyAdminOwner() public view returns (address) {\\n require(_opChainProxyAdminOwner != address(0), \\\"FetchChainInfoOutput: opChainProxyAdminOwner not set\\\");\\n return _opChainProxyAdminOwner;\\n }\\n\\n function opChainGuardian() public view returns (address) {\\n require(_opChainGuardian != address(0), \\\"FetchChainInfoOutput: opChainGuardian not set\\\");\\n return _opChainGuardian;\\n }\\n\\n function challenger() public view returns (address) {\\n require(_challenger != address(0), \\\"FetchChainInfoOutput: challenger not set\\\");\\n return _challenger;\\n }\\n\\n function proposer() public view returns (address) {\\n require(_proposer != address(0), \\\"FetchChainInfoOutput: proposer not set\\\");\\n return _proposer;\\n }\\n\\n function unsafeBlockSigner() public view returns (address) {\\n require(_unsafeBlockSigner != address(0), \\\"FetchChainInfoOutput: unsafeBlockSigner not set\\\");\\n return _unsafeBlockSigner;\\n }\\n\\n function batchSubmitter() public view returns (address) {\\n require(_batchSubmitter != address(0), \\\"FetchChainInfoOutput: batchSubmitter not set\\\");\\n return _batchSubmitter;\\n }\\n\\n function permissioned() public view returns (bool) {\\n return _permissioned;\\n }\\n\\n function permissionless() public view returns (bool) {\\n return _permissionless;\\n }\\n\\n function respectedGameType() public view returns (GameType) {\\n return _respectedGameType;\\n }\\n}\\n\\ncontract FetchChainInfo is Script {\\n function run(FetchChainInfoInput _fi, FetchChainInfoOutput _fo) public {\\n _processSystemConfig(_fi, _fo);\\n _processMessengerAndPortal(_fi, _fo);\\n _processFaultProofs(_fo);\\n }\\n\\n function _processSystemConfig(FetchChainInfoInput _fi, FetchChainInfoOutput _fo) internal {\\n address systemConfigProxy = _fi.systemConfigProxy();\\n _fo.set(_fo.systemConfigProxy.selector, systemConfigProxy);\\n\\n address systemConfigOwner = IFetcher(systemConfigProxy).owner();\\n _fo.set(_fo.systemConfigOwner.selector, systemConfigOwner);\\n\\n address unsafeBlockSigner = IFetcher(systemConfigProxy).unsafeBlockSigner();\\n _fo.set(_fo.unsafeBlockSigner.selector, unsafeBlockSigner);\\n\\n address batchSubmitter = _getBatchSubmitter(systemConfigProxy);\\n _fo.set(_fo.batchSubmitter.selector, batchSubmitter);\\n\\n address opChainProxyAdminImpl = _getProxyAdmin(systemConfigProxy);\\n _fo.set(_fo.opChainProxyAdminImpl.selector, opChainProxyAdminImpl);\\n\\n address opChainProxyAdminOwner = IFetcher(opChainProxyAdminImpl).owner();\\n _fo.set(_fo.opChainProxyAdminOwner.selector, opChainProxyAdminOwner);\\n\\n address l1Erc721BridgeProxy = _getL1ERC721BridgeProxy(systemConfigProxy);\\n _fo.set(_fo.l1Erc721BridgeProxy.selector, l1Erc721BridgeProxy);\\n\\n address optimismMintableErc20FactoryProxy = _getOptimismMintableERC20FactoryProxy(systemConfigProxy);\\n _fo.set(_fo.optimismMintableErc20FactoryProxy.selector, optimismMintableErc20FactoryProxy);\\n }\\n\\n function _processMessengerAndPortal(FetchChainInfoInput _fi, FetchChainInfoOutput _fo) internal {\\n address l1StandardBridgeProxy = _fi.l1StandardBridgeProxy();\\n _fo.set(_fo.l1StandardBridgeProxy.selector, l1StandardBridgeProxy);\\n\\n address l1CrossDomainMessengerProxy = IFetcher(l1StandardBridgeProxy).messenger();\\n _fo.set(_fo.l1CrossDomainMessengerProxy.selector, l1CrossDomainMessengerProxy);\\n\\n address addressManagerImpl = _getAddressManager(l1CrossDomainMessengerProxy);\\n _fo.set(_fo.addressManagerImpl.selector, addressManagerImpl);\\n\\n address optimismPortalProxy = _getOptimismPortalProxy(l1CrossDomainMessengerProxy);\\n _fo.set(_fo.optimismPortalProxy.selector, optimismPortalProxy);\\n\\n address opChainGuardian = _getGuardian(optimismPortalProxy);\\n _fo.set(_fo.opChainGuardian.selector, opChainGuardian);\\n\\n address ethLockboxProxy = _getEthLockboxProxy(optimismPortalProxy);\\n _fo.set(_fo.ethLockboxProxy.selector, ethLockboxProxy);\\n\\n address superchainConfigProxy = _getSuperchainConfigProxy(optimismPortalProxy);\\n _fo.set(_fo.superchainConfigProxy.selector, superchainConfigProxy);\\n }\\n\\n function _processFaultProofs(FetchChainInfoOutput _fo) internal {\\n address systemConfigProxy = _fo.systemConfigProxy();\\n address optimismPortalProxy = _fo.optimismPortalProxy();\\n\\n try IFetcher(optimismPortalProxy).respectedGameType() returns (GameType gameType_) {\\n _fo.set(_fo.respectedGameType.selector, gameType_);\\n } catch {\\n // default respectedGameType to uint32.max since 0 == CANNON\\n _fo.set(_fo.respectedGameType.selector, GameType.wrap(type(uint32).max));\\n address l2OutputOracleProxy;\\n try IFetcher(optimismPortalProxy).l2Oracle() returns (address l2Oracle_) {\\n l2OutputOracleProxy = l2Oracle_;\\n } catch {\\n l2OutputOracleProxy = IFetcher(optimismPortalProxy).L2_ORACLE();\\n }\\n _fo.set(_fo.l2OutputOracleProxy.selector, l2OutputOracleProxy);\\n\\n address proposer = IFetcher(l2OutputOracleProxy).PROPOSER();\\n _fo.set(_fo.proposer.selector, proposer);\\n\\n // no fault proofs installed so we're done\\n return;\\n }\\n\\n address disputeGameFactoryProxy = _getDisputeGameFactoryProxy(systemConfigProxy);\\n if (disputeGameFactoryProxy != address(0)) {\\n _fo.set(_fo.disputeGameFactoryProxy.selector, disputeGameFactoryProxy);\\n\\n address permissionedDisputeGameImpl = _getPermissionedDisputeGame(disputeGameFactoryProxy);\\n if (permissionedDisputeGameImpl != address(0)) {\\n // permissioned fault proofs installed\\n _fo.set(_fo.permissioned.selector, true);\\n _fo.set(_fo.permissionedDisputeGameImpl.selector, permissionedDisputeGameImpl);\\n\\n address challenger = IFetcher(permissionedDisputeGameImpl).challenger();\\n _fo.set(_fo.challenger.selector, challenger);\\n\\n address anchorStateRegistryProxy = IFetcher(permissionedDisputeGameImpl).anchorStateRegistry();\\n _fo.set(_fo.anchorStateRegistryProxy.selector, anchorStateRegistryProxy);\\n\\n address proposer = IFetcher(permissionedDisputeGameImpl).proposer();\\n _fo.set(_fo.proposer.selector, proposer);\\n\\n address delayedWethPermissionedGameProxy = _getDelayedWETHProxy(permissionedDisputeGameImpl);\\n _fo.set(_fo.delayedWethPermissionedGameProxy.selector, delayedWethPermissionedGameProxy);\\n\\n address mipsImpl = IFetcher(permissionedDisputeGameImpl).vm();\\n _fo.set(_fo.mipsImpl.selector, mipsImpl);\\n\\n address preimageOracleImpl = IFetcher(mipsImpl).oracle();\\n _fo.set(_fo.preimageOracleImpl.selector, preimageOracleImpl);\\n }\\n\\n address faultDisputeGameImpl = _getFaultDisputeGame(disputeGameFactoryProxy);\\n if (faultDisputeGameImpl != address(0)) {\\n // permissionless fault proofs installed\\n _fo.set(_fo.faultDisputeGameImpl.selector, faultDisputeGameImpl);\\n _fo.set(_fo.permissionless.selector, true);\\n\\n address delayedWethPermissionlessGameProxy = _getDelayedWETHProxy(faultDisputeGameImpl);\\n _fo.set(_fo.delayedWethPermissionlessGameProxy.selector, delayedWethPermissionlessGameProxy);\\n }\\n\\n address faultDisputeGameCannonKonaImpl =\\n _getFaultDisputeGame(disputeGameFactoryProxy, GameTypes.CANNON_KONA);\\n if (faultDisputeGameCannonKonaImpl != address(0)) {\\n _fo.set(_fo.faultDisputeGameCannonKonaImpl.selector, faultDisputeGameCannonKonaImpl);\\n }\\n } else {\\n // some older chains have L2OutputOracle instead of DisputeGameFactory.\\n address l2OutputOracleProxy = IFetcher(optimismPortalProxy).L2_ORACLE();\\n _fo.set(_fo.l2OutputOracleProxy.selector, l2OutputOracleProxy);\\n address proposer = IFetcher(l2OutputOracleProxy).PROPOSER();\\n _fo.set(_fo.proposer.selector, proposer);\\n }\\n }\\n\\n function _getGuardian(address _portal) internal view returns (address) {\\n try IFetcher(_portal).guardian() returns (address guardian_) {\\n return guardian_;\\n } catch {\\n return IFetcher(_portal).GUARDIAN();\\n }\\n }\\n\\n function _getSystemConfigProxy(address _portal) internal view returns (address) {\\n try IFetcher(_portal).systemConfig() returns (address systemConfig_) {\\n return systemConfig_;\\n } catch {\\n return IFetcher(_portal).SYSTEM_CONFIG();\\n }\\n }\\n\\n function _getOptimismPortalProxy(address _l1CrossDomainMessengerProxy) internal view returns (address) {\\n try IFetcher(_l1CrossDomainMessengerProxy).portal() returns (address optimismPortal_) {\\n return optimismPortal_;\\n } catch {\\n return IFetcher(_l1CrossDomainMessengerProxy).PORTAL();\\n }\\n }\\n\\n function _getAddressManager(address _l1CrossDomainMessengerProxy) internal view returns (address) {\\n uint256 ADDRESS_MANAGER_MAPPING_SLOT = 1;\\n bytes32 slot = keccak256(abi.encode(_l1CrossDomainMessengerProxy, ADDRESS_MANAGER_MAPPING_SLOT));\\n return address(uint160(uint256((vm.load(_l1CrossDomainMessengerProxy, slot)))));\\n }\\n\\n function _getL1ERC721BridgeProxy(address _systemConfigProxy) internal view returns (address) {\\n try IFetcher(_systemConfigProxy).l1ERC721Bridge() returns (address l1ERC721BridgeProxy_) {\\n return l1ERC721BridgeProxy_;\\n } catch {\\n return address(0);\\n }\\n }\\n\\n function _getOptimismMintableERC20FactoryProxy(address _systemConfigProxy) internal view returns (address) {\\n try IFetcher(_systemConfigProxy).optimismMintableERC20Factory() returns (\\n address optimismMintableERC20FactoryProxy_\\n ) {\\n return optimismMintableERC20FactoryProxy_;\\n } catch {\\n return address(0);\\n }\\n }\\n\\n function _getDisputeGameFactoryProxy(address _systemConfigProxy) internal view returns (address) {\\n try IFetcher(_systemConfigProxy).disputeGameFactory() returns (address disputeGameFactoryProxy_) {\\n return disputeGameFactoryProxy_;\\n } catch {\\n // Some older chains have L2OutputOracle instead of DisputeGameFactory\\n return address(0);\\n }\\n }\\n\\n function _getSuperchainConfigProxy(address _optimismPortalProxy) internal view returns (address) {\\n try IFetcher(_optimismPortalProxy).superchainConfig() returns (address superchainConfigProxy_) {\\n return superchainConfigProxy_;\\n } catch {\\n return address(0);\\n }\\n }\\n\\n function _getFaultDisputeGame(address _disputeGameFactoryProxy) internal view returns (address) {\\n try IFetcher(_disputeGameFactoryProxy).gameImpls(GameTypes.CANNON) returns (address faultDisputeGame_) {\\n return faultDisputeGame_;\\n } catch {\\n return address(0);\\n }\\n }\\n\\n function _getFaultDisputeGame(\\n address _disputeGameFactoryProxy,\\n GameType _gameType\\n )\\n internal\\n view\\n returns (address)\\n {\\n try IFetcher(_disputeGameFactoryProxy).gameImpls(_gameType) returns (address faultDisputeGame_) {\\n return faultDisputeGame_;\\n } catch {\\n return address(0);\\n }\\n }\\n\\n function _getPermissionedDisputeGame(address _disputeGameFactoryProxy) internal view returns (address) {\\n try IFetcher(_disputeGameFactoryProxy).gameImpls(GameTypes.PERMISSIONED_CANNON) returns (\\n address permissionedDisputeGame_\\n ) {\\n return permissionedDisputeGame_;\\n } catch {\\n return address(0);\\n }\\n }\\n\\n function _getEthLockboxProxy(address _optimismPortalProxy) internal view returns (address) {\\n try IFetcher(_optimismPortalProxy).ethLockbox() returns (address ethLockbox_) {\\n return ethLockbox_;\\n } catch {\\n return address(0);\\n }\\n }\\n\\n function _getDelayedWETHProxy(address _disputeGame) internal view returns (address) {\\n (bool ok, bytes memory data) = address(_disputeGame).staticcall(abi.encodeCall(IFetcher.weth, ()));\\n if (ok && data.length == 32) return abi.decode(data, (address));\\n else return address(0);\\n }\\n\\n function _getBatchSubmitter(address _systemConfigProxy) internal view returns (address) {\\n bytes32 batcherHash = IFetcher(_systemConfigProxy).batcherHash();\\n return address(uint160(uint256(batcherHash)));\\n }\\n\\n function _getProxyAdmin(address _systemConfigProxy) internal returns (address) {\\n vm.prank(address(0));\\n return IFetcher(_systemConfigProxy).admin();\\n }\\n}\\n\",\"keccak256\":\"0xb90e4f9a834c4dc584b4ad8c0503e35fdd8338533e0e75a7ca497f655ae12821\",\"license\":\"MIT\"},\"src/dispute/lib/LibPosition.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.15;\\n\\nusing LibPosition for Position global;\\n\\n/// @notice A `Position` represents a position of a claim within the game tree.\\n/// @dev This is represented as a \\\"generalized index\\\" where the high-order bit\\n/// is the level in the tree and the remaining bits is a unique bit pattern, allowing\\n/// a unique identifier for each node in the tree. Mathematically, it is calculated\\n/// as 2^{depth} + indexAtDepth.\\ntype Position is uint128;\\n\\n/// @title LibPosition\\n/// @notice This library contains helper functions for working with the `Position` type.\\nlibrary LibPosition {\\n /// @notice the `MAX_POSITION_BITLEN` is the number of bits that the `Position` type, and the implementation of\\n /// its behavior within this library, can safely support.\\n uint8 internal constant MAX_POSITION_BITLEN = 126;\\n\\n /// @notice Computes a generalized index (2^{depth} + indexAtDepth).\\n /// @param _depth The depth of the position.\\n /// @param _indexAtDepth The index at the depth of the position.\\n /// @return position_ The computed generalized index.\\n function wrap(uint8 _depth, uint128 _indexAtDepth) internal pure returns (Position position_) {\\n assembly {\\n // gindex = 2^{_depth} + _indexAtDepth\\n position_ := add(shl(_depth, 1), _indexAtDepth)\\n }\\n }\\n\\n /// @notice Pulls the `depth` out of a `Position` type.\\n /// @param _position The generalized index to get the `depth` of.\\n /// @return depth_ The `depth` of the `position` gindex.\\n /// @custom:attribution Solady \\n function depth(Position _position) internal pure returns (uint8 depth_) {\\n // Return the most significant bit offset, which signifies the depth of the gindex.\\n assembly {\\n depth_ := or(depth_, shl(6, lt(0xffffffffffffffff, shr(depth_, _position))))\\n depth_ := or(depth_, shl(5, lt(0xffffffff, shr(depth_, _position))))\\n\\n // For the remaining 32 bits, use a De Bruijn lookup.\\n _position := shr(depth_, _position)\\n _position := or(_position, shr(1, _position))\\n _position := or(_position, shr(2, _position))\\n _position := or(_position, shr(4, _position))\\n _position := or(_position, shr(8, _position))\\n _position := or(_position, shr(16, _position))\\n\\n depth_ :=\\n or(\\n depth_,\\n byte(\\n shr(251, mul(_position, shl(224, 0x07c4acdd))),\\n 0x0009010a0d15021d0b0e10121619031e080c141c0f111807131b17061a05041f\\n )\\n )\\n }\\n }\\n\\n /// @notice Pulls the `indexAtDepth` out of a `Position` type.\\n /// The `indexAtDepth` is the left/right index of a position at a specific depth within\\n /// the binary tree, starting from index 0. For example, at gindex 2, the `depth` = 1\\n /// and the `indexAtDepth` = 0.\\n /// @param _position The generalized index to get the `indexAtDepth` of.\\n /// @return indexAtDepth_ The `indexAtDepth` of the `position` gindex.\\n function indexAtDepth(Position _position) internal pure returns (uint128 indexAtDepth_) {\\n // Return bits p_{msb-1}...p_{0}. This effectively pulls the 2^{depth} out of the gindex,\\n // leaving only the `indexAtDepth`.\\n uint256 msb = depth(_position);\\n assembly {\\n indexAtDepth_ := sub(_position, shl(msb, 1))\\n }\\n }\\n\\n /// @notice Get the left child of `_position`.\\n /// @param _position The position to get the left position of.\\n /// @return left_ The position to the left of `position`.\\n function left(Position _position) internal pure returns (Position left_) {\\n assembly {\\n left_ := shl(1, _position)\\n }\\n }\\n\\n /// @notice Get the right child of `_position`\\n /// @param _position The position to get the right position of.\\n /// @return right_ The position to the right of `position`.\\n function right(Position _position) internal pure returns (Position right_) {\\n assembly {\\n right_ := or(1, shl(1, _position))\\n }\\n }\\n\\n /// @notice Get the parent position of `_position`.\\n /// @param _position The position to get the parent position of.\\n /// @return parent_ The parent position of `position`.\\n function parent(Position _position) internal pure returns (Position parent_) {\\n assembly {\\n parent_ := shr(1, _position)\\n }\\n }\\n\\n /// @notice Get the deepest, right most gindex relative to the `position`. This is equivalent to\\n /// calling `right` on a position until the maximum depth is reached.\\n /// @param _position The position to get the relative deepest, right most gindex of.\\n /// @param _maxDepth The maximum depth of the game.\\n /// @return rightIndex_ The deepest, right most gindex relative to the `position`.\\n function rightIndex(Position _position, uint256 _maxDepth) internal pure returns (Position rightIndex_) {\\n uint256 msb = depth(_position);\\n assembly {\\n let remaining := sub(_maxDepth, msb)\\n rightIndex_ := or(shl(remaining, _position), sub(shl(remaining, 1), 1))\\n }\\n }\\n\\n /// @notice Get the deepest, right most trace index relative to the `position`. This is\\n /// equivalent to calling `right` on a position until the maximum depth is reached and\\n /// then finding its index at depth.\\n /// @param _position The position to get the relative trace index of.\\n /// @param _maxDepth The maximum depth of the game.\\n /// @return traceIndex_ The trace index relative to the `position`.\\n function traceIndex(Position _position, uint256 _maxDepth) internal pure returns (uint256 traceIndex_) {\\n uint256 msb = depth(_position);\\n assembly {\\n let remaining := sub(_maxDepth, msb)\\n traceIndex_ := sub(or(shl(remaining, _position), sub(shl(remaining, 1), 1)), shl(_maxDepth, 1))\\n }\\n }\\n\\n /// @notice Gets the position of the highest ancestor of `_position` that commits to the same\\n /// trace index.\\n /// @param _position The position to get the highest ancestor of.\\n /// @return ancestor_ The highest ancestor of `position` that commits to the same trace index.\\n function traceAncestor(Position _position) internal pure returns (Position ancestor_) {\\n // Create a field with only the lowest unset bit of `_position` set.\\n Position lsb;\\n assembly {\\n lsb := and(not(_position), add(_position, 1))\\n }\\n // Find the index of the lowest unset bit within the field.\\n uint256 msb = depth(lsb);\\n // The highest ancestor that commits to the same trace index is the original position\\n // shifted right by the index of the lowest unset bit.\\n assembly {\\n let a := shr(msb, _position)\\n // Bound the ancestor to the minimum gindex, 1.\\n ancestor_ := or(a, iszero(a))\\n }\\n }\\n\\n /// @notice Gets the position of the highest ancestor of `_position` that commits to the same\\n /// trace index, while still being below `_upperBoundExclusive`.\\n /// @param _position The position to get the highest ancestor of.\\n /// @param _upperBoundExclusive The exclusive upper depth bound, used to inform where to stop in order\\n /// to not escape a sub-tree.\\n /// @return ancestor_ The highest ancestor of `position` that commits to the same trace index.\\n function traceAncestorBounded(\\n Position _position,\\n uint256 _upperBoundExclusive\\n )\\n internal\\n pure\\n returns (Position ancestor_)\\n {\\n // This function only works for positions that are below the upper bound.\\n if (_position.depth() <= _upperBoundExclusive) {\\n assembly {\\n // Revert with `ClaimAboveSplit()`\\n mstore(0x00, 0xb34b5c22)\\n revert(0x1C, 0x04)\\n }\\n }\\n\\n // Grab the global trace ancestor.\\n ancestor_ = traceAncestor(_position);\\n\\n // If the ancestor is above or at the upper bound, shift it to be below the upper bound.\\n // This should be a special case that only covers positions that commit to the final leaf\\n // in a sub-tree.\\n if (ancestor_.depth() <= _upperBoundExclusive) {\\n ancestor_ = ancestor_.rightIndex(_upperBoundExclusive + 1);\\n }\\n }\\n\\n /// @notice Get the move position of `_position`, which is the left child of:\\n /// 1. `_position` if `_isAttack` is true.\\n /// 2. `_position | 1` if `_isAttack` is false.\\n /// @param _position The position to get the relative attack/defense position of.\\n /// @param _isAttack Whether or not the move is an attack move.\\n /// @return move_ The move position relative to `position`.\\n function move(Position _position, bool _isAttack) internal pure returns (Position move_) {\\n assembly {\\n move_ := shl(1, or(iszero(_isAttack), _position))\\n }\\n }\\n\\n /// @notice Get the value of a `Position` type in the form of the underlying uint128.\\n /// @param _position The position to get the value of.\\n /// @return raw_ The value of the `position` as a uint128 type.\\n function raw(Position _position) internal pure returns (uint128 raw_) {\\n assembly {\\n raw_ := _position\\n }\\n }\\n}\\n\",\"keccak256\":\"0x7c5f19f8f54f06de2ce1c6cdcc5c7af65ac405130a4066cdaf146ca315818241\",\"license\":\"MIT\"},\"src/dispute/lib/LibUDT.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.15;\\n\\n// Libraries\\nimport { Position } from \\\"src/dispute/lib/LibPosition.sol\\\";\\n\\nusing LibClaim for Claim global;\\nusing LibHash for Hash global;\\nusing LibDuration for Duration global;\\nusing LibClock for Clock global;\\nusing LibGameId for GameId global;\\nusing LibTimestamp for Timestamp global;\\nusing LibVMStatus for VMStatus global;\\nusing LibGameType for GameType global;\\n\\n/// @notice A `Clock` represents a packed `Duration` and `Timestamp`\\n/// @dev The packed layout of this type is as follows:\\n/// \\u250c\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u252c\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2510\\n/// \\u2502 Bits \\u2502 Value \\u2502\\n/// \\u251c\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u253c\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2524\\n/// \\u2502 [0, 64) \\u2502 Duration \\u2502\\n/// \\u2502 [64, 128) \\u2502 Timestamp \\u2502\\n/// \\u2514\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2534\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2518\\ntype Clock is uint128;\\n\\n/// @title LibClock\\n/// @notice This library contains helper functions for working with the `Clock` type.\\nlibrary LibClock {\\n /// @notice Packs a `Duration` and `Timestamp` into a `Clock` type.\\n /// @param _duration The `Duration` to pack into the `Clock` type.\\n /// @param _timestamp The `Timestamp` to pack into the `Clock` type.\\n /// @return clock_ The `Clock` containing the `_duration` and `_timestamp`.\\n function wrap(Duration _duration, Timestamp _timestamp) internal pure returns (Clock clock_) {\\n assembly {\\n clock_ := or(shl(0x40, _duration), _timestamp)\\n }\\n }\\n\\n /// @notice Pull the `Duration` out of a `Clock` type.\\n /// @param _clock The `Clock` type to pull the `Duration` out of.\\n /// @return duration_ The `Duration` pulled out of `_clock`.\\n function duration(Clock _clock) internal pure returns (Duration duration_) {\\n // Shift the high-order 64 bits into the low-order 64 bits, leaving only the `duration`.\\n assembly {\\n duration_ := shr(0x40, _clock)\\n }\\n }\\n\\n /// @notice Pull the `Timestamp` out of a `Clock` type.\\n /// @param _clock The `Clock` type to pull the `Timestamp` out of.\\n /// @return timestamp_ The `Timestamp` pulled out of `_clock`.\\n function timestamp(Clock _clock) internal pure returns (Timestamp timestamp_) {\\n // Clean the high-order 192 bits by shifting the clock left and then right again, leaving\\n // only the `timestamp`.\\n assembly {\\n timestamp_ := shr(0xC0, shl(0xC0, _clock))\\n }\\n }\\n\\n /// @notice Get the value of a `Clock` type in the form of the underlying uint128.\\n /// @param _clock The `Clock` type to get the value of.\\n /// @return clock_ The value of the `Clock` type as a uint128 type.\\n function raw(Clock _clock) internal pure returns (uint128 clock_) {\\n assembly {\\n clock_ := _clock\\n }\\n }\\n}\\n\\n/// @notice A `GameId` represents a packed 4 byte game ID, a 8 byte timestamp, and a 20 byte address.\\n/// @dev The packed layout of this type is as follows:\\n/// \\u250c\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u252c\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2510\\n/// \\u2502 Bits \\u2502 Value \\u2502\\n/// \\u251c\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u253c\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2524\\n/// \\u2502 [0, 32) \\u2502 Game Type \\u2502\\n/// \\u2502 [32, 96) \\u2502 Timestamp \\u2502\\n/// \\u2502 [96, 256) \\u2502 Address \\u2502\\n/// \\u2514\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2534\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2518\\ntype GameId is bytes32;\\n\\n/// @title LibGameId\\n/// @notice Utility functions for packing and unpacking GameIds.\\nlibrary LibGameId {\\n /// @notice Packs values into a 32 byte GameId type.\\n /// @param _gameType The game type.\\n /// @param _timestamp The timestamp of the game's creation.\\n /// @param _gameProxy The game proxy address.\\n /// @return gameId_ The packed GameId.\\n function pack(\\n GameType _gameType,\\n Timestamp _timestamp,\\n address _gameProxy\\n )\\n internal\\n pure\\n returns (GameId gameId_)\\n {\\n assembly {\\n gameId_ := or(or(shl(224, _gameType), shl(160, _timestamp)), _gameProxy)\\n }\\n }\\n\\n /// @notice Unpacks values from a 32 byte GameId type.\\n /// @param _gameId The packed GameId.\\n /// @return gameType_ The game type.\\n /// @return timestamp_ The timestamp of the game's creation.\\n /// @return gameProxy_ The game proxy address.\\n function unpack(GameId _gameId)\\n internal\\n pure\\n returns (GameType gameType_, Timestamp timestamp_, address gameProxy_)\\n {\\n assembly {\\n gameType_ := shr(224, _gameId)\\n timestamp_ := and(shr(160, _gameId), 0xFFFFFFFFFFFFFFFF)\\n gameProxy_ := and(_gameId, 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF)\\n }\\n }\\n}\\n\\n/// @notice A claim represents an MPT root representing the state of the fault proof program.\\ntype Claim is bytes32;\\n\\n/// @title LibClaim\\n/// @notice This library contains helper functions for working with the `Claim` type.\\nlibrary LibClaim {\\n /// @notice Get the value of a `Claim` type in the form of the underlying bytes32.\\n /// @param _claim The `Claim` type to get the value of.\\n /// @return claim_ The value of the `Claim` type as a bytes32 type.\\n function raw(Claim _claim) internal pure returns (bytes32 claim_) {\\n assembly {\\n claim_ := _claim\\n }\\n }\\n\\n /// @notice Hashes a claim and a position together.\\n /// @param _claim A Claim type.\\n /// @param _position The position of `claim`.\\n /// @param _challengeIndex The index of the claim being moved against.\\n /// @return claimHash_ A hash of abi.encodePacked(claim, position|challengeIndex);\\n function hashClaimPos(\\n Claim _claim,\\n Position _position,\\n uint256 _challengeIndex\\n )\\n internal\\n pure\\n returns (Hash claimHash_)\\n {\\n assembly {\\n mstore(0x00, _claim)\\n mstore(0x20, or(shl(128, _position), and(0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF, _challengeIndex)))\\n claimHash_ := keccak256(0x00, 0x40)\\n }\\n }\\n}\\n\\n/// @notice A dedicated duration type.\\n/// @dev Unit: seconds\\ntype Duration is uint64;\\n\\n/// @title LibDuration\\n/// @notice This library contains helper functions for working with the `Duration` type.\\nlibrary LibDuration {\\n /// @notice Get the value of a `Duration` type in the form of the underlying uint64.\\n /// @param _duration The `Duration` type to get the value of.\\n /// @return duration_ The value of the `Duration` type as a uint64 type.\\n function raw(Duration _duration) internal pure returns (uint64 duration_) {\\n assembly {\\n duration_ := _duration\\n }\\n }\\n}\\n\\n/// @notice A custom type for a generic hash.\\ntype Hash is bytes32;\\n\\n/// @title LibHash\\n/// @notice This library contains helper functions for working with the `Hash` type.\\nlibrary LibHash {\\n /// @notice Get the value of a `Hash` type in the form of the underlying bytes32.\\n /// @param _hash The `Hash` type to get the value of.\\n /// @return hash_ The value of the `Hash` type as a bytes32 type.\\n function raw(Hash _hash) internal pure returns (bytes32 hash_) {\\n assembly {\\n hash_ := _hash\\n }\\n }\\n}\\n\\n/// @notice A dedicated timestamp type.\\ntype Timestamp is uint64;\\n\\n/// @title LibTimestamp\\n/// @notice This library contains helper functions for working with the `Timestamp` type.\\nlibrary LibTimestamp {\\n /// @notice Get the value of a `Timestamp` type in the form of the underlying uint64.\\n /// @param _timestamp The `Timestamp` type to get the value of.\\n /// @return timestamp_ The value of the `Timestamp` type as a uint64 type.\\n function raw(Timestamp _timestamp) internal pure returns (uint64 timestamp_) {\\n assembly {\\n timestamp_ := _timestamp\\n }\\n }\\n}\\n\\n/// @notice A `VMStatus` represents the status of a VM execution.\\ntype VMStatus is uint8;\\n\\n/// @title LibVMStatus\\n/// @notice This library contains helper functions for working with the `VMStatus` type.\\nlibrary LibVMStatus {\\n /// @notice Get the value of a `VMStatus` type in the form of the underlying uint8.\\n /// @param _vmstatus The `VMStatus` type to get the value of.\\n /// @return vmstatus_ The value of the `VMStatus` type as a uint8 type.\\n function raw(VMStatus _vmstatus) internal pure returns (uint8 vmstatus_) {\\n assembly {\\n vmstatus_ := _vmstatus\\n }\\n }\\n}\\n\\n/// @notice A `GameType` represents the type of game being played.\\ntype GameType is uint32;\\n\\n/// @title LibGameType\\n/// @notice This library contains helper functions for working with the `GameType` type.\\nlibrary LibGameType {\\n /// @notice Get the value of a `GameType` type in the form of the underlying uint32.\\n /// @param _gametype The `GameType` type to get the value of.\\n /// @return gametype_ The value of the `GameType` type as a uint32 type.\\n function raw(GameType _gametype) internal pure returns (uint32 gametype_) {\\n assembly {\\n gametype_ := _gametype\\n }\\n }\\n}\\n\",\"keccak256\":\"0x41d55e9c74d979b5b797198e38449e7cef4f925e04d61f7699e9c150c4a659d3\",\"license\":\"MIT\"},\"src/dispute/lib/Types.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.15;\\n\\n// Libraries\\nimport {\\n Position,\\n Hash,\\n GameType,\\n VMStatus,\\n Timestamp,\\n Duration,\\n Clock,\\n GameId,\\n Claim,\\n LibGameId,\\n LibClock\\n} from \\\"src/dispute/lib/LibUDT.sol\\\";\\n\\n/// @notice The current status of the dispute game.\\nenum GameStatus {\\n // The game is currently in progress, and has not been resolved.\\n IN_PROGRESS,\\n // The game has concluded, and the `rootClaim` was challenged successfully.\\n CHALLENGER_WINS,\\n // The game has concluded, and the `rootClaim` could not be contested.\\n DEFENDER_WINS\\n}\\n\\n/// @notice The game's bond distribution type. Games are expected to start in the `UNDECIDED`\\n/// state, and then choose either `NORMAL` or `REFUND`.\\nenum BondDistributionMode {\\n // Bond distribution strategy has not been chosen.\\n UNDECIDED,\\n // Bonds should be distributed as normal.\\n NORMAL,\\n // Bonds should be refunded to claimants.\\n REFUND\\n}\\n\\n/// @notice Represents an L2 root and the L2 sequence number at which it was generated.\\n/// @custom:field root The output root.\\n/// @custom:field l2SequenceNumber The L2 Sequence Number ( e.g. block number / timestamp) at which the root was\\n/// generated.\\nstruct Proposal {\\n Hash root;\\n uint256 l2SequenceNumber;\\n}\\n\\n/// @title GameTypes\\n/// @notice A library that defines the IDs of games that can be played.\\nlibrary GameTypes {\\n /// @dev A dispute game type the uses the cannon vm.\\n GameType internal constant CANNON = GameType.wrap(0);\\n\\n /// @dev A permissioned dispute game type that uses the cannon vm.\\n GameType internal constant PERMISSIONED_CANNON = GameType.wrap(1);\\n\\n /// @notice A dispute game type that uses the asterisc vm.\\n GameType internal constant ASTERISC = GameType.wrap(2);\\n\\n /// @notice A dispute game type that uses the asterisc vm with Kona.\\n GameType internal constant ASTERISC_KONA = GameType.wrap(3);\\n\\n /// @notice A dispute game type that uses the cannon vm (Super Roots).\\n GameType internal constant SUPER_CANNON = GameType.wrap(4);\\n\\n /// @notice A dispute game type that uses the permissioned cannon vm (Super Roots).\\n GameType internal constant SUPER_PERMISSIONED_CANNON = GameType.wrap(5);\\n\\n /// @notice A dispute game type that uses OP Succinct\\n GameType internal constant OP_SUCCINCT = GameType.wrap(6);\\n\\n /// @notice A dispute game type that uses the asterisc vm with Kona (Super Roots).\\n GameType internal constant SUPER_ASTERISC_KONA = GameType.wrap(7);\\n\\n /// @notice A dispute game type that uses the cannon vm with Kona.\\n GameType internal constant CANNON_KONA = GameType.wrap(8);\\n\\n /// @notice A dispute game type that uses the cannon vm with Kona (Super Roots).\\n GameType internal constant SUPER_CANNON_KONA = GameType.wrap(9);\\n\\n /// @notice A dispute game type with short game duration for testing withdrawals.\\n /// Not intended for production use.\\n GameType internal constant FAST = GameType.wrap(254);\\n\\n /// @notice A dispute game type that uses an alphabet vm.\\n /// Not intended for production use.\\n GameType internal constant ALPHABET = GameType.wrap(255);\\n\\n /// @notice A dispute game type that uses RISC Zero's Kailua\\n GameType internal constant KAILUA = GameType.wrap(1337);\\n}\\n\\n/// @title VMStatuses\\n/// @notice Named type aliases for the various valid VM status bytes.\\nlibrary VMStatuses {\\n /// @notice The VM has executed successfully and the outcome is valid.\\n VMStatus internal constant VALID = VMStatus.wrap(0);\\n\\n /// @notice The VM has executed successfully and the outcome is invalid.\\n VMStatus internal constant INVALID = VMStatus.wrap(1);\\n\\n /// @notice The VM has paniced.\\n VMStatus internal constant PANIC = VMStatus.wrap(2);\\n\\n /// @notice The VM execution is still in progress.\\n VMStatus internal constant UNFINISHED = VMStatus.wrap(3);\\n}\\n\\n/// @title LocalPreimageKey\\n/// @notice Named type aliases for local `PreimageOracle` key identifiers.\\nlibrary LocalPreimageKey {\\n /// @notice The identifier for the L1 head hash.\\n uint256 internal constant L1_HEAD_HASH = 0x01;\\n\\n /// @notice The identifier for the starting output root.\\n uint256 internal constant STARTING_OUTPUT_ROOT = 0x02;\\n\\n /// @notice The identifier for the disputed output root.\\n uint256 internal constant DISPUTED_OUTPUT_ROOT = 0x03;\\n\\n /// @notice The identifier for the disputed L2 block number.\\n uint256 internal constant DISPUTED_L2_BLOCK_NUMBER = 0x04;\\n\\n /// @notice The identifier for the chain ID.\\n uint256 internal constant CHAIN_ID = 0x05;\\n}\\n\",\"keccak256\":\"0x468fccc8d6ce3ac5b87bdd5002f84b315ac861be7655ceef87a018f596c410a1\",\"license\":\"MIT\"}},\"version\":1}","metadata":{"compiler":{"version":"0.8.27+commit.40a35a09"},"language":"Solidity","output":{"abi":[{"inputs":[],"stateMutability":"view","type":"function","name":"l1StandardBridgeProxy","outputs":[{"internalType":"address","name":"","type":"address"}]},{"inputs":[{"internalType":"bytes4","name":"_sel","type":"bytes4"},{"internalType":"address","name":"_addr","type":"address"}],"stateMutability":"nonpayable","type":"function","name":"set"},{"inputs":[],"stateMutability":"view","type":"function","name":"systemConfigProxy","outputs":[{"internalType":"address","name":"","type":"address"}]}],"devdoc":{"kind":"dev","methods":{},"version":1},"userdoc":{"kind":"user","methods":{},"version":1}},"settings":{"remappings":["@lib-keccak/=lib/lib-keccak/contracts/lib/","@openzeppelin/contracts-upgradeable/=lib/openzeppelin-contracts-upgradeable/contracts/","@openzeppelin/contracts-v5/=lib/openzeppelin-contracts-v5/contracts/","@openzeppelin/contracts/=lib/openzeppelin-contracts/contracts/","@rari-capital/solmate/=lib/solmate/","@solady-test/=lib/lib-keccak/lib/solady/test/","@solady-v0.0.245/=lib/solady-v0.0.245/src/","@solady/=lib/solady/src/","ds-test/=lib/forge-std/lib/ds-test/src/","erc4626-tests/=lib/openzeppelin-contracts-v5/lib/erc4626-tests/","forge-std/=lib/forge-std/src/","interfaces/=interfaces/","kontrol-cheatcodes/=lib/kontrol-cheatcodes/src/","lib-keccak/=lib/lib-keccak/contracts/","openzeppelin-contracts-upgradeable/=lib/openzeppelin-contracts-upgradeable/","openzeppelin-contracts-v5/=lib/openzeppelin-contracts-v5/","openzeppelin-contracts/=lib/openzeppelin-contracts/","safe-contracts/=lib/safe-contracts/contracts/","solady-v0.0.245/=lib/solady-v0.0.245/src/","solady/=lib/solady/","solmate/=lib/solmate/src/"],"optimizer":{"enabled":false,"runs":0},"metadata":{"useLiteralContent":true,"bytecodeHash":"none"},"compilationTarget":{"scripts/FetchChainInfo.s.sol":"FetchChainInfoInput"},"evmVersion":"cancun","libraries":{}},"sources":{"lib/forge-std/src/Base.sol":{"keccak256":"0xa3735a6618a3014e42bb4329ad143e3b2c59cd95094350202e4c4a06c9d585dd","urls":[],"content":"// SPDX-License-Identifier: MIT\npragma solidity >=0.6.2 <0.9.0;\n\nimport {StdStorage} from \"./StdStorage.sol\";\nimport {Vm, VmSafe} from \"./Vm.sol\";\n\nabstract contract CommonBase {\n /// @dev Cheat code address.\n /// Calculated as `address(uint160(uint256(keccak256(\"hevm cheat code\"))))`.\n address internal constant VM_ADDRESS = 0x7109709ECfa91a80626fF3989D68f67F5b1DD12D;\n /// @dev console.sol and console2.sol work by executing a staticcall to this address.\n /// Calculated as `address(uint160(uint88(bytes11(\"console.log\"))))`.\n address internal constant CONSOLE = 0x000000000000000000636F6e736F6c652e6c6f67;\n /// @dev Used when deploying with create2.\n /// Taken from https://github.com/Arachnid/deterministic-deployment-proxy.\n address internal constant CREATE2_FACTORY = 0x4e59b44847b379578588920cA78FbF26c0B4956C;\n /// @dev The default address for tx.origin and msg.sender.\n /// Calculated as `address(uint160(uint256(keccak256(\"foundry default caller\"))))`.\n address internal constant DEFAULT_SENDER = 0x1804c8AB1F12E6bbf3894d4083f33e07309d1f38;\n /// @dev The address of the first contract `CREATE`d by a running test contract.\n /// When running tests, each test contract is `CREATE`d by `DEFAULT_SENDER` with nonce 1.\n /// Calculated as `VM.computeCreateAddress(VM.computeCreateAddress(DEFAULT_SENDER, 1), 1)`.\n address internal constant DEFAULT_TEST_CONTRACT = 0x5615dEB798BB3E4dFa0139dFa1b3D433Cc23b72f;\n /// @dev Deterministic deployment address of the Multicall3 contract.\n /// Taken from https://www.multicall3.com.\n address internal constant MULTICALL3_ADDRESS = 0xcA11bde05977b3631167028862bE2a173976CA11;\n /// @dev The order of the secp256k1 curve.\n uint256 internal constant SECP256K1_ORDER =\n 115792089237316195423570985008687907852837564279074904382605163141518161494337;\n\n uint256 internal constant UINT256_MAX =\n 115792089237316195423570985008687907853269984665640564039457584007913129639935;\n\n Vm internal constant vm = Vm(VM_ADDRESS);\n StdStorage internal stdstore;\n}\n\nabstract contract TestBase is CommonBase {}\n\nabstract contract ScriptBase is CommonBase {\n VmSafe internal constant vmSafe = VmSafe(VM_ADDRESS);\n}\n","license":"MIT"},"lib/forge-std/src/Script.sol":{"keccak256":"0xc942e27c7baae499beb01afbbae99f24d42af9a6e4aae675bc6901b704aa8e9b","urls":[],"content":"// SPDX-License-Identifier: MIT\npragma solidity >=0.6.2 <0.9.0;\n\n// 💬 ABOUT\n// Forge Std's default Script.\n\n// 🧩 MODULES\nimport {console} from \"./console.sol\";\nimport {console2} from \"./console2.sol\";\nimport {safeconsole} from \"./safeconsole.sol\";\nimport {StdChains} from \"./StdChains.sol\";\nimport {StdCheatsSafe} from \"./StdCheats.sol\";\nimport {StdConstants} from \"./StdConstants.sol\";\nimport {stdJson} from \"./StdJson.sol\";\nimport {stdMath} from \"./StdMath.sol\";\nimport {StdStorage, stdStorageSafe} from \"./StdStorage.sol\";\nimport {StdStyle} from \"./StdStyle.sol\";\nimport {StdUtils} from \"./StdUtils.sol\";\nimport {VmSafe} from \"./Vm.sol\";\n\n// 📦 BOILERPLATE\nimport {ScriptBase} from \"./Base.sol\";\n\n// ⭐️ SCRIPT\nabstract contract Script is ScriptBase, StdChains, StdCheatsSafe, StdUtils {\n // Note: IS_SCRIPT() must return true.\n bool public IS_SCRIPT = true;\n}\n","license":"MIT"},"lib/forge-std/src/StdChains.sol":{"keccak256":"0x200b597cd01c229633b4a2317846cac7d36d337e2381b4a2e81faac23c2ad1cf","urls":[],"content":"// SPDX-License-Identifier: MIT\npragma solidity >=0.6.2 <0.9.0;\n\nimport {VmSafe} from \"./Vm.sol\";\n\n/**\n * StdChains provides information about EVM compatible chains that can be used in scripts/tests.\n * For each chain, the chain's name, chain ID, and a default RPC URL are provided. Chains are\n * identified by their alias, which is the same as the alias in the `[rpc_endpoints]` section of\n * the `foundry.toml` file. For best UX, ensure the alias in the `foundry.toml` file match the\n * alias used in this contract, which can be found as the first argument to the\n * `setChainWithDefaultRpcUrl` call in the `initializeStdChains` function.\n *\n * There are two main ways to use this contract:\n * 1. Set a chain with `setChain(string memory chainAlias, ChainData memory chain)` or\n * `setChain(string memory chainAlias, Chain memory chain)`\n * 2. Get a chain with `getChain(string memory chainAlias)` or `getChain(uint256 chainId)`.\n *\n * The first time either of those are used, chains are initialized with the default set of RPC URLs.\n * This is done in `initializeStdChains`, which uses `setChainWithDefaultRpcUrl`. Defaults are recorded in\n * `defaultRpcUrls`.\n *\n * The `setChain` function is straightforward, and it simply saves off the given chain data.\n *\n * The `getChain` methods use `getChainWithUpdatedRpcUrl` to return a chain. For example, let's say\n * we want to retrieve the RPC URL for `mainnet`:\n * - If you have specified data with `setChain`, it will return that.\n * - If you have configured a mainnet RPC URL in `foundry.toml`, it will return the URL, provided it\n * is valid (e.g. a URL is specified, or an environment variable is given and exists).\n * - If neither of the above conditions is met, the default data is returned.\n *\n * Summarizing the above, the prioritization hierarchy is `setChain` -> `foundry.toml` -> environment variable -> defaults.\n */\nabstract contract StdChains {\n VmSafe private constant vm = VmSafe(address(uint160(uint256(keccak256(\"hevm cheat code\")))));\n\n bool private stdChainsInitialized;\n\n struct ChainData {\n string name;\n uint256 chainId;\n string rpcUrl;\n }\n\n struct Chain {\n // The chain name.\n string name;\n // The chain's Chain ID.\n uint256 chainId;\n // The chain's alias. (i.e. what gets specified in `foundry.toml`).\n string chainAlias;\n // A default RPC endpoint for this chain.\n // NOTE: This default RPC URL is included for convenience to facilitate quick tests and\n // experimentation. Do not use this RPC URL for production test suites, CI, or other heavy\n // usage as you will be throttled and this is a disservice to others who need this endpoint.\n string rpcUrl;\n }\n\n // Maps from the chain's alias (matching the alias in the `foundry.toml` file) to chain data.\n mapping(string => Chain) private chains;\n // Maps from the chain's alias to it's default RPC URL.\n mapping(string => string) private defaultRpcUrls;\n // Maps from a chain ID to it's alias.\n mapping(uint256 => string) private idToAlias;\n\n bool private fallbackToDefaultRpcUrls = true;\n\n // The RPC URL will be fetched from config or defaultRpcUrls if possible.\n function getChain(string memory chainAlias) internal virtual returns (Chain memory chain) {\n require(bytes(chainAlias).length != 0, \"StdChains getChain(string): Chain alias cannot be the empty string.\");\n\n initializeStdChains();\n chain = chains[chainAlias];\n require(\n chain.chainId != 0,\n string(abi.encodePacked(\"StdChains getChain(string): Chain with alias \\\"\", chainAlias, \"\\\" not found.\"))\n );\n\n chain = getChainWithUpdatedRpcUrl(chainAlias, chain);\n }\n\n function getChain(uint256 chainId) internal virtual returns (Chain memory chain) {\n require(chainId != 0, \"StdChains getChain(uint256): Chain ID cannot be 0.\");\n initializeStdChains();\n string memory chainAlias = idToAlias[chainId];\n\n chain = chains[chainAlias];\n\n require(\n chain.chainId != 0,\n string(abi.encodePacked(\"StdChains getChain(uint256): Chain with ID \", vm.toString(chainId), \" not found.\"))\n );\n\n chain = getChainWithUpdatedRpcUrl(chainAlias, chain);\n }\n\n // set chain info, with priority to argument's rpcUrl field.\n function setChain(string memory chainAlias, ChainData memory chain) internal virtual {\n require(\n bytes(chainAlias).length != 0,\n \"StdChains setChain(string,ChainData): Chain alias cannot be the empty string.\"\n );\n\n require(chain.chainId != 0, \"StdChains setChain(string,ChainData): Chain ID cannot be 0.\");\n\n initializeStdChains();\n string memory foundAlias = idToAlias[chain.chainId];\n\n require(\n bytes(foundAlias).length == 0 || keccak256(bytes(foundAlias)) == keccak256(bytes(chainAlias)),\n string(\n abi.encodePacked(\n \"StdChains setChain(string,ChainData): Chain ID \",\n vm.toString(chain.chainId),\n \" already used by \\\"\",\n foundAlias,\n \"\\\".\"\n )\n )\n );\n\n uint256 oldChainId = chains[chainAlias].chainId;\n delete idToAlias[oldChainId];\n\n chains[chainAlias] =\n Chain({name: chain.name, chainId: chain.chainId, chainAlias: chainAlias, rpcUrl: chain.rpcUrl});\n idToAlias[chain.chainId] = chainAlias;\n }\n\n // set chain info, with priority to argument's rpcUrl field.\n function setChain(string memory chainAlias, Chain memory chain) internal virtual {\n setChain(chainAlias, ChainData({name: chain.name, chainId: chain.chainId, rpcUrl: chain.rpcUrl}));\n }\n\n function _toUpper(string memory str) private pure returns (string memory) {\n bytes memory strb = bytes(str);\n bytes memory copy = new bytes(strb.length);\n for (uint256 i = 0; i < strb.length; i++) {\n bytes1 b = strb[i];\n if (b >= 0x61 && b <= 0x7A) {\n copy[i] = bytes1(uint8(b) - 32);\n } else {\n copy[i] = b;\n }\n }\n return string(copy);\n }\n\n // lookup rpcUrl, in descending order of priority:\n // current -> config (foundry.toml) -> environment variable -> default\n function getChainWithUpdatedRpcUrl(string memory chainAlias, Chain memory chain)\n private\n view\n returns (Chain memory)\n {\n if (bytes(chain.rpcUrl).length == 0) {\n try vm.rpcUrl(chainAlias) returns (string memory configRpcUrl) {\n chain.rpcUrl = configRpcUrl;\n } catch (bytes memory err) {\n string memory envName = string(abi.encodePacked(_toUpper(chainAlias), \"_RPC_URL\"));\n if (fallbackToDefaultRpcUrls) {\n chain.rpcUrl = vm.envOr(envName, defaultRpcUrls[chainAlias]);\n } else {\n chain.rpcUrl = vm.envString(envName);\n }\n // Distinguish 'not found' from 'cannot read'\n // The upstream error thrown by forge for failing cheats changed so we check both the old and new versions\n bytes memory oldNotFoundError =\n abi.encodeWithSignature(\"CheatCodeError\", string(abi.encodePacked(\"invalid rpc url \", chainAlias)));\n bytes memory newNotFoundError = abi.encodeWithSignature(\n \"CheatcodeError(string)\", string(abi.encodePacked(\"invalid rpc url: \", chainAlias))\n );\n bytes32 errHash = keccak256(err);\n if (\n (errHash != keccak256(oldNotFoundError) && errHash != keccak256(newNotFoundError))\n || bytes(chain.rpcUrl).length == 0\n ) {\n /// @solidity memory-safe-assembly\n assembly {\n revert(add(32, err), mload(err))\n }\n }\n }\n }\n return chain;\n }\n\n function setFallbackToDefaultRpcUrls(bool useDefault) internal {\n fallbackToDefaultRpcUrls = useDefault;\n }\n\n function initializeStdChains() private {\n if (stdChainsInitialized) return;\n\n stdChainsInitialized = true;\n\n // If adding an RPC here, make sure to test the default RPC URL in `test_Rpcs` in `StdChains.t.sol`\n setChainWithDefaultRpcUrl(\"anvil\", ChainData(\"Anvil\", 31337, \"http://127.0.0.1:8545\"));\n setChainWithDefaultRpcUrl(\"mainnet\", ChainData(\"Mainnet\", 1, \"https://eth.llamarpc.com\"));\n setChainWithDefaultRpcUrl(\n \"sepolia\", ChainData(\"Sepolia\", 11155111, \"https://sepolia.infura.io/v3/b9794ad1ddf84dfb8c34d6bb5dca2001\")\n );\n setChainWithDefaultRpcUrl(\"holesky\", ChainData(\"Holesky\", 17000, \"https://rpc.holesky.ethpandaops.io\"));\n setChainWithDefaultRpcUrl(\"optimism\", ChainData(\"Optimism\", 10, \"https://mainnet.optimism.io\"));\n setChainWithDefaultRpcUrl(\n \"optimism_sepolia\", ChainData(\"Optimism Sepolia\", 11155420, \"https://sepolia.optimism.io\")\n );\n setChainWithDefaultRpcUrl(\"arbitrum_one\", ChainData(\"Arbitrum One\", 42161, \"https://arb1.arbitrum.io/rpc\"));\n setChainWithDefaultRpcUrl(\n \"arbitrum_one_sepolia\", ChainData(\"Arbitrum One Sepolia\", 421614, \"https://sepolia-rollup.arbitrum.io/rpc\")\n );\n setChainWithDefaultRpcUrl(\"arbitrum_nova\", ChainData(\"Arbitrum Nova\", 42170, \"https://nova.arbitrum.io/rpc\"));\n setChainWithDefaultRpcUrl(\"polygon\", ChainData(\"Polygon\", 137, \"https://polygon-rpc.com\"));\n setChainWithDefaultRpcUrl(\n \"polygon_amoy\", ChainData(\"Polygon Amoy\", 80002, \"https://rpc-amoy.polygon.technology\")\n );\n setChainWithDefaultRpcUrl(\"avalanche\", ChainData(\"Avalanche\", 43114, \"https://api.avax.network/ext/bc/C/rpc\"));\n setChainWithDefaultRpcUrl(\n \"avalanche_fuji\", ChainData(\"Avalanche Fuji\", 43113, \"https://api.avax-test.network/ext/bc/C/rpc\")\n );\n setChainWithDefaultRpcUrl(\n \"bnb_smart_chain\", ChainData(\"BNB Smart Chain\", 56, \"https://bsc-dataseed1.binance.org\")\n );\n setChainWithDefaultRpcUrl(\n \"bnb_smart_chain_testnet\",\n ChainData(\"BNB Smart Chain Testnet\", 97, \"https://rpc.ankr.com/bsc_testnet_chapel\")\n );\n setChainWithDefaultRpcUrl(\"gnosis_chain\", ChainData(\"Gnosis Chain\", 100, \"https://rpc.gnosischain.com\"));\n setChainWithDefaultRpcUrl(\"moonbeam\", ChainData(\"Moonbeam\", 1284, \"https://rpc.api.moonbeam.network\"));\n setChainWithDefaultRpcUrl(\n \"moonriver\", ChainData(\"Moonriver\", 1285, \"https://rpc.api.moonriver.moonbeam.network\")\n );\n setChainWithDefaultRpcUrl(\"moonbase\", ChainData(\"Moonbase\", 1287, \"https://rpc.testnet.moonbeam.network\"));\n setChainWithDefaultRpcUrl(\"base_sepolia\", ChainData(\"Base Sepolia\", 84532, \"https://sepolia.base.org\"));\n setChainWithDefaultRpcUrl(\"base\", ChainData(\"Base\", 8453, \"https://mainnet.base.org\"));\n setChainWithDefaultRpcUrl(\"blast_sepolia\", ChainData(\"Blast Sepolia\", 168587773, \"https://sepolia.blast.io\"));\n setChainWithDefaultRpcUrl(\"blast\", ChainData(\"Blast\", 81457, \"https://rpc.blast.io\"));\n setChainWithDefaultRpcUrl(\"fantom_opera\", ChainData(\"Fantom Opera\", 250, \"https://rpc.ankr.com/fantom/\"));\n setChainWithDefaultRpcUrl(\n \"fantom_opera_testnet\", ChainData(\"Fantom Opera Testnet\", 4002, \"https://rpc.ankr.com/fantom_testnet/\")\n );\n setChainWithDefaultRpcUrl(\"fraxtal\", ChainData(\"Fraxtal\", 252, \"https://rpc.frax.com\"));\n setChainWithDefaultRpcUrl(\"fraxtal_testnet\", ChainData(\"Fraxtal Testnet\", 2522, \"https://rpc.testnet.frax.com\"));\n setChainWithDefaultRpcUrl(\n \"berachain_bartio_testnet\", ChainData(\"Berachain bArtio Testnet\", 80084, \"https://bartio.rpc.berachain.com\")\n );\n setChainWithDefaultRpcUrl(\"flare\", ChainData(\"Flare\", 14, \"https://flare-api.flare.network/ext/C/rpc\"));\n setChainWithDefaultRpcUrl(\n \"flare_coston2\", ChainData(\"Flare Coston2\", 114, \"https://coston2-api.flare.network/ext/C/rpc\")\n );\n\n setChainWithDefaultRpcUrl(\"mode\", ChainData(\"Mode\", 34443, \"https://mode.drpc.org\"));\n setChainWithDefaultRpcUrl(\"mode_sepolia\", ChainData(\"Mode Sepolia\", 919, \"https://sepolia.mode.network\"));\n\n setChainWithDefaultRpcUrl(\"zora\", ChainData(\"Zora\", 7777777, \"https://zora.drpc.org\"));\n setChainWithDefaultRpcUrl(\n \"zora_sepolia\", ChainData(\"Zora Sepolia\", 999999999, \"https://sepolia.rpc.zora.energy\")\n );\n\n setChainWithDefaultRpcUrl(\"race\", ChainData(\"Race\", 6805, \"https://racemainnet.io\"));\n setChainWithDefaultRpcUrl(\"race_sepolia\", ChainData(\"Race Sepolia\", 6806, \"https://racemainnet.io\"));\n\n setChainWithDefaultRpcUrl(\"metal\", ChainData(\"Metal\", 1750, \"https://metall2.drpc.org\"));\n setChainWithDefaultRpcUrl(\"metal_sepolia\", ChainData(\"Metal Sepolia\", 1740, \"https://testnet.rpc.metall2.com\"));\n\n setChainWithDefaultRpcUrl(\"binary\", ChainData(\"Binary\", 624, \"https://rpc.zero.thebinaryholdings.com\"));\n setChainWithDefaultRpcUrl(\n \"binary_sepolia\", ChainData(\"Binary Sepolia\", 625, \"https://rpc.zero.thebinaryholdings.com\")\n );\n\n setChainWithDefaultRpcUrl(\"orderly\", ChainData(\"Orderly\", 291, \"https://rpc.orderly.network\"));\n setChainWithDefaultRpcUrl(\n \"orderly_sepolia\", ChainData(\"Orderly Sepolia\", 4460, \"https://testnet-rpc.orderly.org\")\n );\n }\n\n // set chain info, with priority to chainAlias' rpc url in foundry.toml\n function setChainWithDefaultRpcUrl(string memory chainAlias, ChainData memory chain) private {\n string memory rpcUrl = chain.rpcUrl;\n defaultRpcUrls[chainAlias] = rpcUrl;\n chain.rpcUrl = \"\";\n setChain(chainAlias, chain);\n chain.rpcUrl = rpcUrl; // restore argument\n }\n}\n","license":"MIT"},"lib/forge-std/src/StdCheats.sol":{"keccak256":"0x0fa6ec03602648b62cce41aab2096e6b7e052f2846075d967b6958dd586db746","urls":[],"content":"// SPDX-License-Identifier: MIT\npragma solidity >=0.6.2 <0.9.0;\n\npragma experimental ABIEncoderV2;\n\nimport {StdStorage, stdStorage} from \"./StdStorage.sol\";\nimport {console2} from \"./console2.sol\";\nimport {Vm} from \"./Vm.sol\";\n\nabstract contract StdCheatsSafe {\n Vm private constant vm = Vm(address(uint160(uint256(keccak256(\"hevm cheat code\")))));\n\n uint256 private constant UINT256_MAX =\n 115792089237316195423570985008687907853269984665640564039457584007913129639935;\n\n bool private gasMeteringOff;\n\n // Data structures to parse Transaction objects from the broadcast artifact\n // that conform to EIP1559. The Raw structs is what is parsed from the JSON\n // and then converted to the one that is used by the user for better UX.\n\n struct RawTx1559 {\n string[] arguments;\n address contractAddress;\n string contractName;\n // json value name = function\n string functionSig;\n bytes32 hash;\n // json value name = tx\n RawTx1559Detail txDetail;\n // json value name = type\n string opcode;\n }\n\n struct RawTx1559Detail {\n AccessList[] accessList;\n bytes data;\n address from;\n bytes gas;\n bytes nonce;\n address to;\n bytes txType;\n bytes value;\n }\n\n struct Tx1559 {\n string[] arguments;\n address contractAddress;\n string contractName;\n string functionSig;\n bytes32 hash;\n Tx1559Detail txDetail;\n string opcode;\n }\n\n struct Tx1559Detail {\n AccessList[] accessList;\n bytes data;\n address from;\n uint256 gas;\n uint256 nonce;\n address to;\n uint256 txType;\n uint256 value;\n }\n\n // Data structures to parse Transaction objects from the broadcast artifact\n // that DO NOT conform to EIP1559. The Raw structs is what is parsed from the JSON\n // and then converted to the one that is used by the user for better UX.\n\n struct TxLegacy {\n string[] arguments;\n address contractAddress;\n string contractName;\n string functionSig;\n string hash;\n string opcode;\n TxDetailLegacy transaction;\n }\n\n struct TxDetailLegacy {\n AccessList[] accessList;\n uint256 chainId;\n bytes data;\n address from;\n uint256 gas;\n uint256 gasPrice;\n bytes32 hash;\n uint256 nonce;\n bytes1 opcode;\n bytes32 r;\n bytes32 s;\n uint256 txType;\n address to;\n uint8 v;\n uint256 value;\n }\n\n struct AccessList {\n address accessAddress;\n bytes32[] storageKeys;\n }\n\n // Data structures to parse Receipt objects from the broadcast artifact.\n // The Raw structs is what is parsed from the JSON\n // and then converted to the one that is used by the user for better UX.\n\n struct RawReceipt {\n bytes32 blockHash;\n bytes blockNumber;\n address contractAddress;\n bytes cumulativeGasUsed;\n bytes effectiveGasPrice;\n address from;\n bytes gasUsed;\n RawReceiptLog[] logs;\n bytes logsBloom;\n bytes status;\n address to;\n bytes32 transactionHash;\n bytes transactionIndex;\n }\n\n struct Receipt {\n bytes32 blockHash;\n uint256 blockNumber;\n address contractAddress;\n uint256 cumulativeGasUsed;\n uint256 effectiveGasPrice;\n address from;\n uint256 gasUsed;\n ReceiptLog[] logs;\n bytes logsBloom;\n uint256 status;\n address to;\n bytes32 transactionHash;\n uint256 transactionIndex;\n }\n\n // Data structures to parse the entire broadcast artifact, assuming the\n // transactions conform to EIP1559.\n\n struct EIP1559ScriptArtifact {\n string[] libraries;\n string path;\n string[] pending;\n Receipt[] receipts;\n uint256 timestamp;\n Tx1559[] transactions;\n TxReturn[] txReturns;\n }\n\n struct RawEIP1559ScriptArtifact {\n string[] libraries;\n string path;\n string[] pending;\n RawReceipt[] receipts;\n TxReturn[] txReturns;\n uint256 timestamp;\n RawTx1559[] transactions;\n }\n\n struct RawReceiptLog {\n // json value = address\n address logAddress;\n bytes32 blockHash;\n bytes blockNumber;\n bytes data;\n bytes logIndex;\n bool removed;\n bytes32[] topics;\n bytes32 transactionHash;\n bytes transactionIndex;\n bytes transactionLogIndex;\n }\n\n struct ReceiptLog {\n // json value = address\n address logAddress;\n bytes32 blockHash;\n uint256 blockNumber;\n bytes data;\n uint256 logIndex;\n bytes32[] topics;\n uint256 transactionIndex;\n uint256 transactionLogIndex;\n bool removed;\n }\n\n struct TxReturn {\n string internalType;\n string value;\n }\n\n struct Account {\n address addr;\n uint256 key;\n }\n\n enum AddressType {\n Payable,\n NonPayable,\n ZeroAddress,\n Precompile,\n ForgeAddress\n }\n\n // Checks that `addr` is not blacklisted by token contracts that have a blacklist.\n function assumeNotBlacklisted(address token, address addr) internal view virtual {\n // Nothing to check if `token` is not a contract.\n uint256 tokenCodeSize;\n assembly {\n tokenCodeSize := extcodesize(token)\n }\n require(tokenCodeSize > 0, \"StdCheats assumeNotBlacklisted(address,address): Token address is not a contract.\");\n\n bool success;\n bytes memory returnData;\n\n // 4-byte selector for `isBlacklisted(address)`, used by USDC.\n (success, returnData) = token.staticcall(abi.encodeWithSelector(0xfe575a87, addr));\n vm.assume(!success || abi.decode(returnData, (bool)) == false);\n\n // 4-byte selector for `isBlackListed(address)`, used by USDT.\n (success, returnData) = token.staticcall(abi.encodeWithSelector(0xe47d6060, addr));\n vm.assume(!success || abi.decode(returnData, (bool)) == false);\n }\n\n // Checks that `addr` is not blacklisted by token contracts that have a blacklist.\n // This is identical to `assumeNotBlacklisted(address,address)` but with a different name, for\n // backwards compatibility, since this name was used in the original PR which already has\n // a release. This function can be removed in a future release once we want a breaking change.\n function assumeNoBlacklisted(address token, address addr) internal view virtual {\n assumeNotBlacklisted(token, addr);\n }\n\n function assumeAddressIsNot(address addr, AddressType addressType) internal virtual {\n if (addressType == AddressType.Payable) {\n assumeNotPayable(addr);\n } else if (addressType == AddressType.NonPayable) {\n assumePayable(addr);\n } else if (addressType == AddressType.ZeroAddress) {\n assumeNotZeroAddress(addr);\n } else if (addressType == AddressType.Precompile) {\n assumeNotPrecompile(addr);\n } else if (addressType == AddressType.ForgeAddress) {\n assumeNotForgeAddress(addr);\n }\n }\n\n function assumeAddressIsNot(address addr, AddressType addressType1, AddressType addressType2) internal virtual {\n assumeAddressIsNot(addr, addressType1);\n assumeAddressIsNot(addr, addressType2);\n }\n\n function assumeAddressIsNot(\n address addr,\n AddressType addressType1,\n AddressType addressType2,\n AddressType addressType3\n ) internal virtual {\n assumeAddressIsNot(addr, addressType1);\n assumeAddressIsNot(addr, addressType2);\n assumeAddressIsNot(addr, addressType3);\n }\n\n function assumeAddressIsNot(\n address addr,\n AddressType addressType1,\n AddressType addressType2,\n AddressType addressType3,\n AddressType addressType4\n ) internal virtual {\n assumeAddressIsNot(addr, addressType1);\n assumeAddressIsNot(addr, addressType2);\n assumeAddressIsNot(addr, addressType3);\n assumeAddressIsNot(addr, addressType4);\n }\n\n // This function checks whether an address, `addr`, is payable. It works by sending 1 wei to\n // `addr` and checking the `success` return value.\n // NOTE: This function may result in state changes depending on the fallback/receive logic\n // implemented by `addr`, which should be taken into account when this function is used.\n function _isPayable(address addr) private returns (bool) {\n require(\n addr.balance < UINT256_MAX,\n \"StdCheats _isPayable(address): Balance equals max uint256, so it cannot receive any more funds\"\n );\n uint256 origBalanceTest = address(this).balance;\n uint256 origBalanceAddr = address(addr).balance;\n\n vm.deal(address(this), 1);\n (bool success,) = payable(addr).call{value: 1}(\"\");\n\n // reset balances\n vm.deal(address(this), origBalanceTest);\n vm.deal(addr, origBalanceAddr);\n\n return success;\n }\n\n // NOTE: This function may result in state changes depending on the fallback/receive logic\n // implemented by `addr`, which should be taken into account when this function is used. See the\n // `_isPayable` method for more information.\n function assumePayable(address addr) internal virtual {\n vm.assume(_isPayable(addr));\n }\n\n function assumeNotPayable(address addr) internal virtual {\n vm.assume(!_isPayable(addr));\n }\n\n function assumeNotZeroAddress(address addr) internal pure virtual {\n vm.assume(addr != address(0));\n }\n\n function assumeNotPrecompile(address addr) internal pure virtual {\n assumeNotPrecompile(addr, _pureChainId());\n }\n\n function assumeNotPrecompile(address addr, uint256 chainId) internal pure virtual {\n // Note: For some chains like Optimism these are technically predeploys (i.e. bytecode placed at a specific\n // address), but the same rationale for excluding them applies so we include those too.\n\n // These are reserved by Ethereum and may be on all EVM-compatible chains.\n vm.assume(addr < address(0x1) || addr > address(0xff));\n\n // forgefmt: disable-start\n if (chainId == 10 || chainId == 420) {\n // https://github.com/ethereum-optimism/optimism/blob/eaa371a0184b56b7ca6d9eb9cb0a2b78b2ccd864/op-bindings/predeploys/addresses.go#L6-L21\n vm.assume(addr < address(0x4200000000000000000000000000000000000000) || addr > address(0x4200000000000000000000000000000000000800));\n } else if (chainId == 42161 || chainId == 421613) {\n // https://developer.arbitrum.io/useful-addresses#arbitrum-precompiles-l2-same-on-all-arb-chains\n vm.assume(addr < address(0x0000000000000000000000000000000000000064) || addr > address(0x0000000000000000000000000000000000000068));\n } else if (chainId == 43114 || chainId == 43113) {\n // https://github.com/ava-labs/subnet-evm/blob/47c03fd007ecaa6de2c52ea081596e0a88401f58/precompile/params.go#L18-L59\n vm.assume(addr < address(0x0100000000000000000000000000000000000000) || addr > address(0x01000000000000000000000000000000000000ff));\n vm.assume(addr < address(0x0200000000000000000000000000000000000000) || addr > address(0x02000000000000000000000000000000000000FF));\n vm.assume(addr < address(0x0300000000000000000000000000000000000000) || addr > address(0x03000000000000000000000000000000000000Ff));\n }\n // forgefmt: disable-end\n }\n\n function assumeNotForgeAddress(address addr) internal pure virtual {\n // vm, console, and Create2Deployer addresses\n vm.assume(\n addr != address(vm) && addr != 0x000000000000000000636F6e736F6c652e6c6f67\n && addr != 0x4e59b44847b379578588920cA78FbF26c0B4956C\n );\n }\n\n function assumeUnusedAddress(address addr) internal view virtual {\n uint256 size;\n assembly {\n size := extcodesize(addr)\n }\n vm.assume(size == 0);\n\n assumeNotPrecompile(addr);\n assumeNotZeroAddress(addr);\n assumeNotForgeAddress(addr);\n }\n\n function readEIP1559ScriptArtifact(string memory path)\n internal\n view\n virtual\n returns (EIP1559ScriptArtifact memory)\n {\n string memory data = vm.readFile(path);\n bytes memory parsedData = vm.parseJson(data);\n RawEIP1559ScriptArtifact memory rawArtifact = abi.decode(parsedData, (RawEIP1559ScriptArtifact));\n EIP1559ScriptArtifact memory artifact;\n artifact.libraries = rawArtifact.libraries;\n artifact.path = rawArtifact.path;\n artifact.timestamp = rawArtifact.timestamp;\n artifact.pending = rawArtifact.pending;\n artifact.txReturns = rawArtifact.txReturns;\n artifact.receipts = rawToConvertedReceipts(rawArtifact.receipts);\n artifact.transactions = rawToConvertedEIPTx1559s(rawArtifact.transactions);\n return artifact;\n }\n\n function rawToConvertedEIPTx1559s(RawTx1559[] memory rawTxs) internal pure virtual returns (Tx1559[] memory) {\n Tx1559[] memory txs = new Tx1559[](rawTxs.length);\n for (uint256 i; i < rawTxs.length; i++) {\n txs[i] = rawToConvertedEIPTx1559(rawTxs[i]);\n }\n return txs;\n }\n\n function rawToConvertedEIPTx1559(RawTx1559 memory rawTx) internal pure virtual returns (Tx1559 memory) {\n Tx1559 memory transaction;\n transaction.arguments = rawTx.arguments;\n transaction.contractName = rawTx.contractName;\n transaction.functionSig = rawTx.functionSig;\n transaction.hash = rawTx.hash;\n transaction.txDetail = rawToConvertedEIP1559Detail(rawTx.txDetail);\n transaction.opcode = rawTx.opcode;\n return transaction;\n }\n\n function rawToConvertedEIP1559Detail(RawTx1559Detail memory rawDetail)\n internal\n pure\n virtual\n returns (Tx1559Detail memory)\n {\n Tx1559Detail memory txDetail;\n txDetail.data = rawDetail.data;\n txDetail.from = rawDetail.from;\n txDetail.to = rawDetail.to;\n txDetail.nonce = _bytesToUint(rawDetail.nonce);\n txDetail.txType = _bytesToUint(rawDetail.txType);\n txDetail.value = _bytesToUint(rawDetail.value);\n txDetail.gas = _bytesToUint(rawDetail.gas);\n txDetail.accessList = rawDetail.accessList;\n return txDetail;\n }\n\n function readTx1559s(string memory path) internal view virtual returns (Tx1559[] memory) {\n string memory deployData = vm.readFile(path);\n bytes memory parsedDeployData = vm.parseJson(deployData, \".transactions\");\n RawTx1559[] memory rawTxs = abi.decode(parsedDeployData, (RawTx1559[]));\n return rawToConvertedEIPTx1559s(rawTxs);\n }\n\n function readTx1559(string memory path, uint256 index) internal view virtual returns (Tx1559 memory) {\n string memory deployData = vm.readFile(path);\n string memory key = string(abi.encodePacked(\".transactions[\", vm.toString(index), \"]\"));\n bytes memory parsedDeployData = vm.parseJson(deployData, key);\n RawTx1559 memory rawTx = abi.decode(parsedDeployData, (RawTx1559));\n return rawToConvertedEIPTx1559(rawTx);\n }\n\n // Analogous to readTransactions, but for receipts.\n function readReceipts(string memory path) internal view virtual returns (Receipt[] memory) {\n string memory deployData = vm.readFile(path);\n bytes memory parsedDeployData = vm.parseJson(deployData, \".receipts\");\n RawReceipt[] memory rawReceipts = abi.decode(parsedDeployData, (RawReceipt[]));\n return rawToConvertedReceipts(rawReceipts);\n }\n\n function readReceipt(string memory path, uint256 index) internal view virtual returns (Receipt memory) {\n string memory deployData = vm.readFile(path);\n string memory key = string(abi.encodePacked(\".receipts[\", vm.toString(index), \"]\"));\n bytes memory parsedDeployData = vm.parseJson(deployData, key);\n RawReceipt memory rawReceipt = abi.decode(parsedDeployData, (RawReceipt));\n return rawToConvertedReceipt(rawReceipt);\n }\n\n function rawToConvertedReceipts(RawReceipt[] memory rawReceipts) internal pure virtual returns (Receipt[] memory) {\n Receipt[] memory receipts = new Receipt[](rawReceipts.length);\n for (uint256 i; i < rawReceipts.length; i++) {\n receipts[i] = rawToConvertedReceipt(rawReceipts[i]);\n }\n return receipts;\n }\n\n function rawToConvertedReceipt(RawReceipt memory rawReceipt) internal pure virtual returns (Receipt memory) {\n Receipt memory receipt;\n receipt.blockHash = rawReceipt.blockHash;\n receipt.to = rawReceipt.to;\n receipt.from = rawReceipt.from;\n receipt.contractAddress = rawReceipt.contractAddress;\n receipt.effectiveGasPrice = _bytesToUint(rawReceipt.effectiveGasPrice);\n receipt.cumulativeGasUsed = _bytesToUint(rawReceipt.cumulativeGasUsed);\n receipt.gasUsed = _bytesToUint(rawReceipt.gasUsed);\n receipt.status = _bytesToUint(rawReceipt.status);\n receipt.transactionIndex = _bytesToUint(rawReceipt.transactionIndex);\n receipt.blockNumber = _bytesToUint(rawReceipt.blockNumber);\n receipt.logs = rawToConvertedReceiptLogs(rawReceipt.logs);\n receipt.logsBloom = rawReceipt.logsBloom;\n receipt.transactionHash = rawReceipt.transactionHash;\n return receipt;\n }\n\n function rawToConvertedReceiptLogs(RawReceiptLog[] memory rawLogs)\n internal\n pure\n virtual\n returns (ReceiptLog[] memory)\n {\n ReceiptLog[] memory logs = new ReceiptLog[](rawLogs.length);\n for (uint256 i; i < rawLogs.length; i++) {\n logs[i].logAddress = rawLogs[i].logAddress;\n logs[i].blockHash = rawLogs[i].blockHash;\n logs[i].blockNumber = _bytesToUint(rawLogs[i].blockNumber);\n logs[i].data = rawLogs[i].data;\n logs[i].logIndex = _bytesToUint(rawLogs[i].logIndex);\n logs[i].topics = rawLogs[i].topics;\n logs[i].transactionIndex = _bytesToUint(rawLogs[i].transactionIndex);\n logs[i].transactionLogIndex = _bytesToUint(rawLogs[i].transactionLogIndex);\n logs[i].removed = rawLogs[i].removed;\n }\n return logs;\n }\n\n // Deploy a contract by fetching the contract bytecode from\n // the artifacts directory\n // e.g. `deployCode(code, abi.encode(arg1,arg2,arg3))`\n function deployCode(string memory what, bytes memory args) internal virtual returns (address addr) {\n bytes memory bytecode = abi.encodePacked(vm.getCode(what), args);\n /// @solidity memory-safe-assembly\n assembly {\n addr := create(0, add(bytecode, 0x20), mload(bytecode))\n }\n\n require(addr != address(0), \"StdCheats deployCode(string,bytes): Deployment failed.\");\n }\n\n function deployCode(string memory what) internal virtual returns (address addr) {\n bytes memory bytecode = vm.getCode(what);\n /// @solidity memory-safe-assembly\n assembly {\n addr := create(0, add(bytecode, 0x20), mload(bytecode))\n }\n\n require(addr != address(0), \"StdCheats deployCode(string): Deployment failed.\");\n }\n\n /// @dev deploy contract with value on construction\n function deployCode(string memory what, bytes memory args, uint256 val) internal virtual returns (address addr) {\n bytes memory bytecode = abi.encodePacked(vm.getCode(what), args);\n /// @solidity memory-safe-assembly\n assembly {\n addr := create(val, add(bytecode, 0x20), mload(bytecode))\n }\n\n require(addr != address(0), \"StdCheats deployCode(string,bytes,uint256): Deployment failed.\");\n }\n\n function deployCode(string memory what, uint256 val) internal virtual returns (address addr) {\n bytes memory bytecode = vm.getCode(what);\n /// @solidity memory-safe-assembly\n assembly {\n addr := create(val, add(bytecode, 0x20), mload(bytecode))\n }\n\n require(addr != address(0), \"StdCheats deployCode(string,uint256): Deployment failed.\");\n }\n\n // creates a labeled address and the corresponding private key\n function makeAddrAndKey(string memory name) internal virtual returns (address addr, uint256 privateKey) {\n privateKey = uint256(keccak256(abi.encodePacked(name)));\n addr = vm.addr(privateKey);\n vm.label(addr, name);\n }\n\n // creates a labeled address\n function makeAddr(string memory name) internal virtual returns (address addr) {\n (addr,) = makeAddrAndKey(name);\n }\n\n // Destroys an account immediately, sending the balance to beneficiary.\n // Destroying means: balance will be zero, code will be empty, and nonce will be 0\n // This is similar to selfdestruct but not identical: selfdestruct destroys code and nonce\n // only after tx ends, this will run immediately.\n function destroyAccount(address who, address beneficiary) internal virtual {\n uint256 currBalance = who.balance;\n vm.etch(who, abi.encode());\n vm.deal(who, 0);\n vm.resetNonce(who);\n\n uint256 beneficiaryBalance = beneficiary.balance;\n vm.deal(beneficiary, currBalance + beneficiaryBalance);\n }\n\n // creates a struct containing both a labeled address and the corresponding private key\n function makeAccount(string memory name) internal virtual returns (Account memory account) {\n (account.addr, account.key) = makeAddrAndKey(name);\n }\n\n function deriveRememberKey(string memory mnemonic, uint32 index)\n internal\n virtual\n returns (address who, uint256 privateKey)\n {\n privateKey = vm.deriveKey(mnemonic, index);\n who = vm.rememberKey(privateKey);\n }\n\n function _bytesToUint(bytes memory b) private pure returns (uint256) {\n require(b.length <= 32, \"StdCheats _bytesToUint(bytes): Bytes length exceeds 32.\");\n return abi.decode(abi.encodePacked(new bytes(32 - b.length), b), (uint256));\n }\n\n function isFork() internal view virtual returns (bool status) {\n try vm.activeFork() {\n status = true;\n } catch (bytes memory) {}\n }\n\n modifier skipWhenForking() {\n if (!isFork()) {\n _;\n }\n }\n\n modifier skipWhenNotForking() {\n if (isFork()) {\n _;\n }\n }\n\n modifier noGasMetering() {\n vm.pauseGasMetering();\n // To prevent turning gas monitoring back on with nested functions that use this modifier,\n // we check if gasMetering started in the off position. If it did, we don't want to turn\n // it back on until we exit the top level function that used the modifier\n //\n // i.e. funcA() noGasMetering { funcB() }, where funcB has noGasMetering as well.\n // funcA will have `gasStartedOff` as false, funcB will have it as true,\n // so we only turn metering back on at the end of the funcA\n bool gasStartedOff = gasMeteringOff;\n gasMeteringOff = true;\n\n _;\n\n // if gas metering was on when this modifier was called, turn it back on at the end\n if (!gasStartedOff) {\n gasMeteringOff = false;\n vm.resumeGasMetering();\n }\n }\n\n // We use this complex approach of `_viewChainId` and `_pureChainId` to ensure there are no\n // compiler warnings when accessing chain ID in any solidity version supported by forge-std. We\n // can't simply access the chain ID in a normal view or pure function because the solc View Pure\n // Checker changed `chainid` from pure to view in 0.8.0.\n function _viewChainId() private view returns (uint256 chainId) {\n // Assembly required since `block.chainid` was introduced in 0.8.0.\n assembly {\n chainId := chainid()\n }\n\n address(this); // Silence warnings in older Solc versions.\n }\n\n function _pureChainId() private pure returns (uint256 chainId) {\n function() internal view returns (uint256) fnIn = _viewChainId;\n function() internal pure returns (uint256) pureChainId;\n assembly {\n pureChainId := fnIn\n }\n chainId = pureChainId();\n }\n}\n\n// Wrappers around cheatcodes to avoid footguns\nabstract contract StdCheats is StdCheatsSafe {\n using stdStorage for StdStorage;\n\n StdStorage private stdstore;\n Vm private constant vm = Vm(address(uint160(uint256(keccak256(\"hevm cheat code\")))));\n address private constant CONSOLE2_ADDRESS = 0x000000000000000000636F6e736F6c652e6c6f67;\n\n // Skip forward or rewind time by the specified number of seconds\n function skip(uint256 time) internal virtual {\n vm.warp(vm.getBlockTimestamp() + time);\n }\n\n function rewind(uint256 time) internal virtual {\n vm.warp(vm.getBlockTimestamp() - time);\n }\n\n // Setup a prank from an address that has some ether\n function hoax(address msgSender) internal virtual {\n vm.deal(msgSender, 1 << 128);\n vm.prank(msgSender);\n }\n\n function hoax(address msgSender, uint256 give) internal virtual {\n vm.deal(msgSender, give);\n vm.prank(msgSender);\n }\n\n function hoax(address msgSender, address origin) internal virtual {\n vm.deal(msgSender, 1 << 128);\n vm.prank(msgSender, origin);\n }\n\n function hoax(address msgSender, address origin, uint256 give) internal virtual {\n vm.deal(msgSender, give);\n vm.prank(msgSender, origin);\n }\n\n // Start perpetual prank from an address that has some ether\n function startHoax(address msgSender) internal virtual {\n vm.deal(msgSender, 1 << 128);\n vm.startPrank(msgSender);\n }\n\n function startHoax(address msgSender, uint256 give) internal virtual {\n vm.deal(msgSender, give);\n vm.startPrank(msgSender);\n }\n\n // Start perpetual prank from an address that has some ether\n // tx.origin is set to the origin parameter\n function startHoax(address msgSender, address origin) internal virtual {\n vm.deal(msgSender, 1 << 128);\n vm.startPrank(msgSender, origin);\n }\n\n function startHoax(address msgSender, address origin, uint256 give) internal virtual {\n vm.deal(msgSender, give);\n vm.startPrank(msgSender, origin);\n }\n\n function changePrank(address msgSender) internal virtual {\n console2_log_StdCheats(\"changePrank is deprecated. Please use vm.startPrank instead.\");\n vm.stopPrank();\n vm.startPrank(msgSender);\n }\n\n function changePrank(address msgSender, address txOrigin) internal virtual {\n vm.stopPrank();\n vm.startPrank(msgSender, txOrigin);\n }\n\n // The same as Vm's `deal`\n // Use the alternative signature for ERC20 tokens\n function deal(address to, uint256 give) internal virtual {\n vm.deal(to, give);\n }\n\n // Set the balance of an account for any ERC20 token\n // Use the alternative signature to update `totalSupply`\n function deal(address token, address to, uint256 give) internal virtual {\n deal(token, to, give, false);\n }\n\n // Set the balance of an account for any ERC1155 token\n // Use the alternative signature to update `totalSupply`\n function dealERC1155(address token, address to, uint256 id, uint256 give) internal virtual {\n dealERC1155(token, to, id, give, false);\n }\n\n function deal(address token, address to, uint256 give, bool adjust) internal virtual {\n // get current balance\n (, bytes memory balData) = token.staticcall(abi.encodeWithSelector(0x70a08231, to));\n uint256 prevBal = abi.decode(balData, (uint256));\n\n // update balance\n stdstore.target(token).sig(0x70a08231).with_key(to).checked_write(give);\n\n // update total supply\n if (adjust) {\n (, bytes memory totSupData) = token.staticcall(abi.encodeWithSelector(0x18160ddd));\n uint256 totSup = abi.decode(totSupData, (uint256));\n if (give < prevBal) {\n totSup -= (prevBal - give);\n } else {\n totSup += (give - prevBal);\n }\n stdstore.target(token).sig(0x18160ddd).checked_write(totSup);\n }\n }\n\n function dealERC1155(address token, address to, uint256 id, uint256 give, bool adjust) internal virtual {\n // get current balance\n (, bytes memory balData) = token.staticcall(abi.encodeWithSelector(0x00fdd58e, to, id));\n uint256 prevBal = abi.decode(balData, (uint256));\n\n // update balance\n stdstore.target(token).sig(0x00fdd58e).with_key(to).with_key(id).checked_write(give);\n\n // update total supply\n if (adjust) {\n (, bytes memory totSupData) = token.staticcall(abi.encodeWithSelector(0xbd85b039, id));\n require(\n totSupData.length != 0,\n \"StdCheats deal(address,address,uint,uint,bool): target contract is not ERC1155Supply.\"\n );\n uint256 totSup = abi.decode(totSupData, (uint256));\n if (give < prevBal) {\n totSup -= (prevBal - give);\n } else {\n totSup += (give - prevBal);\n }\n stdstore.target(token).sig(0xbd85b039).with_key(id).checked_write(totSup);\n }\n }\n\n function dealERC721(address token, address to, uint256 id) internal virtual {\n // check if token id is already minted and the actual owner.\n (bool successMinted, bytes memory ownerData) = token.staticcall(abi.encodeWithSelector(0x6352211e, id));\n require(successMinted, \"StdCheats deal(address,address,uint,bool): id not minted.\");\n\n // get owner current balance\n (, bytes memory fromBalData) =\n token.staticcall(abi.encodeWithSelector(0x70a08231, abi.decode(ownerData, (address))));\n uint256 fromPrevBal = abi.decode(fromBalData, (uint256));\n\n // get new user current balance\n (, bytes memory toBalData) = token.staticcall(abi.encodeWithSelector(0x70a08231, to));\n uint256 toPrevBal = abi.decode(toBalData, (uint256));\n\n // update balances\n stdstore.target(token).sig(0x70a08231).with_key(abi.decode(ownerData, (address))).checked_write(--fromPrevBal);\n stdstore.target(token).sig(0x70a08231).with_key(to).checked_write(++toPrevBal);\n\n // update owner\n stdstore.target(token).sig(0x6352211e).with_key(id).checked_write(to);\n }\n\n function deployCodeTo(string memory what, address where) internal virtual {\n deployCodeTo(what, \"\", 0, where);\n }\n\n function deployCodeTo(string memory what, bytes memory args, address where) internal virtual {\n deployCodeTo(what, args, 0, where);\n }\n\n function deployCodeTo(string memory what, bytes memory args, uint256 value, address where) internal virtual {\n bytes memory creationCode = vm.getCode(what);\n vm.etch(where, abi.encodePacked(creationCode, args));\n (bool success, bytes memory runtimeBytecode) = where.call{value: value}(\"\");\n require(success, \"StdCheats deployCodeTo(string,bytes,uint256,address): Failed to create runtime bytecode.\");\n vm.etch(where, runtimeBytecode);\n }\n\n // Used to prevent the compilation of console, which shortens the compilation time when console is not used elsewhere.\n function console2_log_StdCheats(string memory p0) private view {\n (bool status,) = address(CONSOLE2_ADDRESS).staticcall(abi.encodeWithSignature(\"log(string)\", p0));\n status;\n }\n}\n","license":"MIT"},"lib/forge-std/src/StdConstants.sol":{"keccak256":"0x319ccdabfa2c0b2428301445873270ffea20f0e039d4fd5e6eeba65158e4e534","urls":[],"content":"// SPDX-License-Identifier: MIT\npragma solidity >=0.6.2 <0.9.0;\n\nimport {IMulticall3} from \"./interfaces/IMulticall3.sol\";\nimport {Vm} from \"./Vm.sol\";\n\nlibrary StdConstants {\n /// @dev Cheat code address.\n /// Calculated as `address(uint160(uint256(keccak256(\"hevm cheat code\"))))`.\n Vm internal constant VM = Vm(0x7109709ECfa91a80626fF3989D68f67F5b1DD12D);\n /// @dev console.sol and console2.sol work by executing a staticcall to this address.\n /// Calculated as `address(uint160(uint88(bytes11(\"console.log\"))))`.\n address internal constant CONSOLE = 0x000000000000000000636F6e736F6c652e6c6f67;\n /// @dev Used when deploying with create2.\n /// Taken from https://github.com/Arachnid/deterministic-deployment-proxy.\n address internal constant CREATE2_FACTORY = 0x4e59b44847b379578588920cA78FbF26c0B4956C;\n /// @dev The default address for tx.origin and msg.sender.\n /// Calculated as `address(uint160(uint256(keccak256(\"foundry default caller\"))))`.\n address internal constant DEFAULT_SENDER = 0x1804c8AB1F12E6bbf3894d4083f33e07309d1f38;\n /// @dev The address of the first contract `CREATE`d by a running test contract.\n /// When running tests, each test contract is `CREATE`d by `DEFAULT_SENDER` with nonce 1.\n /// Calculated as `VM.computeCreateAddress(VM.computeCreateAddress(DEFAULT_SENDER, 1), 1)`.\n address internal constant DEFAULT_TEST_CONTRACT = 0x5615dEB798BB3E4dFa0139dFa1b3D433Cc23b72f;\n /// @dev Deterministic deployment address of the Multicall3 contract.\n /// Taken from https://www.multicall3.com.\n IMulticall3 internal constant MULTICALL3_ADDRESS = IMulticall3(0xcA11bde05977b3631167028862bE2a173976CA11);\n /// @dev The order of the secp256k1 curve.\n uint256 internal constant SECP256K1_ORDER =\n 115792089237316195423570985008687907852837564279074904382605163141518161494337;\n}\n","license":"MIT"},"lib/forge-std/src/StdJson.sol":{"keccak256":"0xbc0132abe1c2accc2867c0f03667afffdf92f3e95a581bb03c9557eaa38ea500","urls":[],"content":"// SPDX-License-Identifier: MIT\npragma solidity >=0.6.0 <0.9.0;\n\npragma experimental ABIEncoderV2;\n\nimport {VmSafe} from \"./Vm.sol\";\n\n// Helpers for parsing and writing JSON files\n// To parse:\n// ```\n// using stdJson for string;\n// string memory json = vm.readFile(\"\");\n// json.readUint(\"\");\n// ```\n// To write:\n// ```\n// using stdJson for string;\n// string memory json = \"json\";\n// json.serialize(\"a\", uint256(123));\n// string memory semiFinal = json.serialize(\"b\", string(\"test\"));\n// string memory finalJson = json.serialize(\"c\", semiFinal);\n// finalJson.write(\"\");\n// ```\n\nlibrary stdJson {\n VmSafe private constant vm = VmSafe(address(uint160(uint256(keccak256(\"hevm cheat code\")))));\n\n function keyExists(string memory json, string memory key) internal view returns (bool) {\n return vm.keyExistsJson(json, key);\n }\n\n function parseRaw(string memory json, string memory key) internal pure returns (bytes memory) {\n return vm.parseJson(json, key);\n }\n\n function readUint(string memory json, string memory key) internal pure returns (uint256) {\n return vm.parseJsonUint(json, key);\n }\n\n function readUintArray(string memory json, string memory key) internal pure returns (uint256[] memory) {\n return vm.parseJsonUintArray(json, key);\n }\n\n function readInt(string memory json, string memory key) internal pure returns (int256) {\n return vm.parseJsonInt(json, key);\n }\n\n function readIntArray(string memory json, string memory key) internal pure returns (int256[] memory) {\n return vm.parseJsonIntArray(json, key);\n }\n\n function readBytes32(string memory json, string memory key) internal pure returns (bytes32) {\n return vm.parseJsonBytes32(json, key);\n }\n\n function readBytes32Array(string memory json, string memory key) internal pure returns (bytes32[] memory) {\n return vm.parseJsonBytes32Array(json, key);\n }\n\n function readString(string memory json, string memory key) internal pure returns (string memory) {\n return vm.parseJsonString(json, key);\n }\n\n function readStringArray(string memory json, string memory key) internal pure returns (string[] memory) {\n return vm.parseJsonStringArray(json, key);\n }\n\n function readAddress(string memory json, string memory key) internal pure returns (address) {\n return vm.parseJsonAddress(json, key);\n }\n\n function readAddressArray(string memory json, string memory key) internal pure returns (address[] memory) {\n return vm.parseJsonAddressArray(json, key);\n }\n\n function readBool(string memory json, string memory key) internal pure returns (bool) {\n return vm.parseJsonBool(json, key);\n }\n\n function readBoolArray(string memory json, string memory key) internal pure returns (bool[] memory) {\n return vm.parseJsonBoolArray(json, key);\n }\n\n function readBytes(string memory json, string memory key) internal pure returns (bytes memory) {\n return vm.parseJsonBytes(json, key);\n }\n\n function readBytesArray(string memory json, string memory key) internal pure returns (bytes[] memory) {\n return vm.parseJsonBytesArray(json, key);\n }\n\n function readUintOr(string memory json, string memory key, uint256 defaultValue) internal view returns (uint256) {\n return keyExists(json, key) ? readUint(json, key) : defaultValue;\n }\n\n function readUintArrayOr(string memory json, string memory key, uint256[] memory defaultValue)\n internal\n view\n returns (uint256[] memory)\n {\n return keyExists(json, key) ? readUintArray(json, key) : defaultValue;\n }\n\n function readIntOr(string memory json, string memory key, int256 defaultValue) internal view returns (int256) {\n return keyExists(json, key) ? readInt(json, key) : defaultValue;\n }\n\n function readIntArrayOr(string memory json, string memory key, int256[] memory defaultValue)\n internal\n view\n returns (int256[] memory)\n {\n return keyExists(json, key) ? readIntArray(json, key) : defaultValue;\n }\n\n function readBytes32Or(string memory json, string memory key, bytes32 defaultValue)\n internal\n view\n returns (bytes32)\n {\n return keyExists(json, key) ? readBytes32(json, key) : defaultValue;\n }\n\n function readBytes32ArrayOr(string memory json, string memory key, bytes32[] memory defaultValue)\n internal\n view\n returns (bytes32[] memory)\n {\n return keyExists(json, key) ? readBytes32Array(json, key) : defaultValue;\n }\n\n function readStringOr(string memory json, string memory key, string memory defaultValue)\n internal\n view\n returns (string memory)\n {\n return keyExists(json, key) ? readString(json, key) : defaultValue;\n }\n\n function readStringArrayOr(string memory json, string memory key, string[] memory defaultValue)\n internal\n view\n returns (string[] memory)\n {\n return keyExists(json, key) ? readStringArray(json, key) : defaultValue;\n }\n\n function readAddressOr(string memory json, string memory key, address defaultValue)\n internal\n view\n returns (address)\n {\n return keyExists(json, key) ? readAddress(json, key) : defaultValue;\n }\n\n function readAddressArrayOr(string memory json, string memory key, address[] memory defaultValue)\n internal\n view\n returns (address[] memory)\n {\n return keyExists(json, key) ? readAddressArray(json, key) : defaultValue;\n }\n\n function readBoolOr(string memory json, string memory key, bool defaultValue) internal view returns (bool) {\n return keyExists(json, key) ? readBool(json, key) : defaultValue;\n }\n\n function readBoolArrayOr(string memory json, string memory key, bool[] memory defaultValue)\n internal\n view\n returns (bool[] memory)\n {\n return keyExists(json, key) ? readBoolArray(json, key) : defaultValue;\n }\n\n function readBytesOr(string memory json, string memory key, bytes memory defaultValue)\n internal\n view\n returns (bytes memory)\n {\n return keyExists(json, key) ? readBytes(json, key) : defaultValue;\n }\n\n function readBytesArrayOr(string memory json, string memory key, bytes[] memory defaultValue)\n internal\n view\n returns (bytes[] memory)\n {\n return keyExists(json, key) ? readBytesArray(json, key) : defaultValue;\n }\n\n function serialize(string memory jsonKey, string memory rootObject) internal returns (string memory) {\n return vm.serializeJson(jsonKey, rootObject);\n }\n\n function serialize(string memory jsonKey, string memory key, bool value) internal returns (string memory) {\n return vm.serializeBool(jsonKey, key, value);\n }\n\n function serialize(string memory jsonKey, string memory key, bool[] memory value)\n internal\n returns (string memory)\n {\n return vm.serializeBool(jsonKey, key, value);\n }\n\n function serialize(string memory jsonKey, string memory key, uint256 value) internal returns (string memory) {\n return vm.serializeUint(jsonKey, key, value);\n }\n\n function serialize(string memory jsonKey, string memory key, uint256[] memory value)\n internal\n returns (string memory)\n {\n return vm.serializeUint(jsonKey, key, value);\n }\n\n function serialize(string memory jsonKey, string memory key, int256 value) internal returns (string memory) {\n return vm.serializeInt(jsonKey, key, value);\n }\n\n function serialize(string memory jsonKey, string memory key, int256[] memory value)\n internal\n returns (string memory)\n {\n return vm.serializeInt(jsonKey, key, value);\n }\n\n function serialize(string memory jsonKey, string memory key, address value) internal returns (string memory) {\n return vm.serializeAddress(jsonKey, key, value);\n }\n\n function serialize(string memory jsonKey, string memory key, address[] memory value)\n internal\n returns (string memory)\n {\n return vm.serializeAddress(jsonKey, key, value);\n }\n\n function serialize(string memory jsonKey, string memory key, bytes32 value) internal returns (string memory) {\n return vm.serializeBytes32(jsonKey, key, value);\n }\n\n function serialize(string memory jsonKey, string memory key, bytes32[] memory value)\n internal\n returns (string memory)\n {\n return vm.serializeBytes32(jsonKey, key, value);\n }\n\n function serialize(string memory jsonKey, string memory key, bytes memory value) internal returns (string memory) {\n return vm.serializeBytes(jsonKey, key, value);\n }\n\n function serialize(string memory jsonKey, string memory key, bytes[] memory value)\n internal\n returns (string memory)\n {\n return vm.serializeBytes(jsonKey, key, value);\n }\n\n function serialize(string memory jsonKey, string memory key, string memory value)\n internal\n returns (string memory)\n {\n return vm.serializeString(jsonKey, key, value);\n }\n\n function serialize(string memory jsonKey, string memory key, string[] memory value)\n internal\n returns (string memory)\n {\n return vm.serializeString(jsonKey, key, value);\n }\n\n function write(string memory jsonKey, string memory path) internal {\n vm.writeJson(jsonKey, path);\n }\n\n function write(string memory jsonKey, string memory path, string memory valueKey) internal {\n vm.writeJson(jsonKey, path, valueKey);\n }\n}\n","license":"MIT"},"lib/forge-std/src/StdMath.sol":{"keccak256":"0xd90ad4fd8aeaeb8929964e686e769fdedd5eded3fc3815df194a0ab9f91a3fb2","urls":[],"content":"// SPDX-License-Identifier: MIT\npragma solidity >=0.6.2 <0.9.0;\n\nlibrary stdMath {\n int256 private constant INT256_MIN = -57896044618658097711785492504343953926634992332820282019728792003956564819968;\n\n function abs(int256 a) internal pure returns (uint256) {\n // Required or it will fail when `a = type(int256).min`\n if (a == INT256_MIN) {\n return 57896044618658097711785492504343953926634992332820282019728792003956564819968;\n }\n\n return uint256(a > 0 ? a : -a);\n }\n\n function delta(uint256 a, uint256 b) internal pure returns (uint256) {\n return a > b ? a - b : b - a;\n }\n\n function delta(int256 a, int256 b) internal pure returns (uint256) {\n // a and b are of the same sign\n // this works thanks to two's complement, the left-most bit is the sign bit\n if ((a ^ b) > -1) {\n return delta(abs(a), abs(b));\n }\n\n // a and b are of opposite signs\n return abs(a) + abs(b);\n }\n\n function percentDelta(uint256 a, uint256 b) internal pure returns (uint256) {\n uint256 absDelta = delta(a, b);\n\n return absDelta * 1e18 / b;\n }\n\n function percentDelta(int256 a, int256 b) internal pure returns (uint256) {\n uint256 absDelta = delta(a, b);\n uint256 absB = abs(b);\n\n return absDelta * 1e18 / absB;\n }\n}\n","license":"MIT"},"lib/forge-std/src/StdStorage.sol":{"keccak256":"0xb91ab24383a5872b894fc93325eef1add6cbbf981628f18e860068bf88bb7dcc","urls":[],"content":"// SPDX-License-Identifier: MIT\npragma solidity >=0.6.2 <0.9.0;\n\nimport {Vm} from \"./Vm.sol\";\n\nstruct FindData {\n uint256 slot;\n uint256 offsetLeft;\n uint256 offsetRight;\n bool found;\n}\n\nstruct StdStorage {\n mapping(address => mapping(bytes4 => mapping(bytes32 => FindData))) finds;\n bytes32[] _keys;\n bytes4 _sig;\n uint256 _depth;\n address _target;\n bytes32 _set;\n bool _enable_packed_slots;\n bytes _calldata;\n}\n\nlibrary stdStorageSafe {\n event SlotFound(address who, bytes4 fsig, bytes32 keysHash, uint256 slot);\n event WARNING_UninitedSlot(address who, uint256 slot);\n\n Vm private constant vm = Vm(address(uint160(uint256(keccak256(\"hevm cheat code\")))));\n uint256 constant UINT256_MAX = 115792089237316195423570985008687907853269984665640564039457584007913129639935;\n\n function sigs(string memory sigStr) internal pure returns (bytes4) {\n return bytes4(keccak256(bytes(sigStr)));\n }\n\n function getCallParams(StdStorage storage self) internal view returns (bytes memory) {\n if (self._calldata.length == 0) {\n return flatten(self._keys);\n } else {\n return self._calldata;\n }\n }\n\n // Calls target contract with configured parameters\n function callTarget(StdStorage storage self) internal view returns (bool, bytes32) {\n bytes memory cald = abi.encodePacked(self._sig, getCallParams(self));\n (bool success, bytes memory rdat) = self._target.staticcall(cald);\n bytes32 result = bytesToBytes32(rdat, 32 * self._depth);\n\n return (success, result);\n }\n\n // Tries mutating slot value to determine if the targeted value is stored in it.\n // If current value is 0, then we are setting slot value to type(uint256).max\n // Otherwise, we set it to 0. That way, return value should always be affected.\n function checkSlotMutatesCall(StdStorage storage self, bytes32 slot) internal returns (bool) {\n bytes32 prevSlotValue = vm.load(self._target, slot);\n (bool success, bytes32 prevReturnValue) = callTarget(self);\n\n bytes32 testVal = prevReturnValue == bytes32(0) ? bytes32(UINT256_MAX) : bytes32(0);\n vm.store(self._target, slot, testVal);\n\n (, bytes32 newReturnValue) = callTarget(self);\n\n vm.store(self._target, slot, prevSlotValue);\n\n return (success && (prevReturnValue != newReturnValue));\n }\n\n // Tries setting one of the bits in slot to 1 until return value changes.\n // Index of resulted bit is an offset packed slot has from left/right side\n function findOffset(StdStorage storage self, bytes32 slot, bool left) internal returns (bool, uint256) {\n for (uint256 offset = 0; offset < 256; offset++) {\n uint256 valueToPut = left ? (1 << (255 - offset)) : (1 << offset);\n vm.store(self._target, slot, bytes32(valueToPut));\n\n (bool success, bytes32 data) = callTarget(self);\n\n if (success && (uint256(data) > 0)) {\n return (true, offset);\n }\n }\n return (false, 0);\n }\n\n function findOffsets(StdStorage storage self, bytes32 slot) internal returns (bool, uint256, uint256) {\n bytes32 prevSlotValue = vm.load(self._target, slot);\n\n (bool foundLeft, uint256 offsetLeft) = findOffset(self, slot, true);\n (bool foundRight, uint256 offsetRight) = findOffset(self, slot, false);\n\n // `findOffset` may mutate slot value, so we are setting it to initial value\n vm.store(self._target, slot, prevSlotValue);\n return (foundLeft && foundRight, offsetLeft, offsetRight);\n }\n\n function find(StdStorage storage self) internal returns (FindData storage) {\n return find(self, true);\n }\n\n /// @notice find an arbitrary storage slot given a function sig, input data, address of the contract and a value to check against\n // slot complexity:\n // if flat, will be bytes32(uint256(uint));\n // if map, will be keccak256(abi.encode(key, uint(slot)));\n // if deep map, will be keccak256(abi.encode(key1, keccak256(abi.encode(key0, uint(slot)))));\n // if map struct, will be bytes32(uint256(keccak256(abi.encode(key1, keccak256(abi.encode(key0, uint(slot)))))) + structFieldDepth);\n function find(StdStorage storage self, bool _clear) internal returns (FindData storage) {\n address who = self._target;\n bytes4 fsig = self._sig;\n uint256 field_depth = self._depth;\n bytes memory params = getCallParams(self);\n\n // calldata to test against\n if (self.finds[who][fsig][keccak256(abi.encodePacked(params, field_depth))].found) {\n if (_clear) {\n clear(self);\n }\n return self.finds[who][fsig][keccak256(abi.encodePacked(params, field_depth))];\n }\n vm.record();\n (, bytes32 callResult) = callTarget(self);\n (bytes32[] memory reads,) = vm.accesses(address(who));\n\n if (reads.length == 0) {\n revert(\"stdStorage find(StdStorage): No storage use detected for target.\");\n } else {\n for (uint256 i = reads.length; --i >= 0;) {\n bytes32 prev = vm.load(who, reads[i]);\n if (prev == bytes32(0)) {\n emit WARNING_UninitedSlot(who, uint256(reads[i]));\n }\n\n if (!checkSlotMutatesCall(self, reads[i])) {\n continue;\n }\n\n (uint256 offsetLeft, uint256 offsetRight) = (0, 0);\n\n if (self._enable_packed_slots) {\n bool found;\n (found, offsetLeft, offsetRight) = findOffsets(self, reads[i]);\n if (!found) {\n continue;\n }\n }\n\n // Check that value between found offsets is equal to the current call result\n uint256 curVal = (uint256(prev) & getMaskByOffsets(offsetLeft, offsetRight)) >> offsetRight;\n\n if (uint256(callResult) != curVal) {\n continue;\n }\n\n emit SlotFound(who, fsig, keccak256(abi.encodePacked(params, field_depth)), uint256(reads[i]));\n self.finds[who][fsig][keccak256(abi.encodePacked(params, field_depth))] =\n FindData(uint256(reads[i]), offsetLeft, offsetRight, true);\n break;\n }\n }\n\n require(\n self.finds[who][fsig][keccak256(abi.encodePacked(params, field_depth))].found,\n \"stdStorage find(StdStorage): Slot(s) not found.\"\n );\n\n if (_clear) {\n clear(self);\n }\n return self.finds[who][fsig][keccak256(abi.encodePacked(params, field_depth))];\n }\n\n function target(StdStorage storage self, address _target) internal returns (StdStorage storage) {\n self._target = _target;\n return self;\n }\n\n function sig(StdStorage storage self, bytes4 _sig) internal returns (StdStorage storage) {\n self._sig = _sig;\n return self;\n }\n\n function sig(StdStorage storage self, string memory _sig) internal returns (StdStorage storage) {\n self._sig = sigs(_sig);\n return self;\n }\n\n function with_calldata(StdStorage storage self, bytes memory _calldata) internal returns (StdStorage storage) {\n self._calldata = _calldata;\n return self;\n }\n\n function with_key(StdStorage storage self, address who) internal returns (StdStorage storage) {\n self._keys.push(bytes32(uint256(uint160(who))));\n return self;\n }\n\n function with_key(StdStorage storage self, uint256 amt) internal returns (StdStorage storage) {\n self._keys.push(bytes32(amt));\n return self;\n }\n\n function with_key(StdStorage storage self, bytes32 key) internal returns (StdStorage storage) {\n self._keys.push(key);\n return self;\n }\n\n function enable_packed_slots(StdStorage storage self) internal returns (StdStorage storage) {\n self._enable_packed_slots = true;\n return self;\n }\n\n function depth(StdStorage storage self, uint256 _depth) internal returns (StdStorage storage) {\n self._depth = _depth;\n return self;\n }\n\n function read(StdStorage storage self) private returns (bytes memory) {\n FindData storage data = find(self, false);\n uint256 mask = getMaskByOffsets(data.offsetLeft, data.offsetRight);\n uint256 value = (uint256(vm.load(self._target, bytes32(data.slot))) & mask) >> data.offsetRight;\n clear(self);\n return abi.encode(value);\n }\n\n function read_bytes32(StdStorage storage self) internal returns (bytes32) {\n return abi.decode(read(self), (bytes32));\n }\n\n function read_bool(StdStorage storage self) internal returns (bool) {\n int256 v = read_int(self);\n if (v == 0) return false;\n if (v == 1) return true;\n revert(\"stdStorage read_bool(StdStorage): Cannot decode. Make sure you are reading a bool.\");\n }\n\n function read_address(StdStorage storage self) internal returns (address) {\n return abi.decode(read(self), (address));\n }\n\n function read_uint(StdStorage storage self) internal returns (uint256) {\n return abi.decode(read(self), (uint256));\n }\n\n function read_int(StdStorage storage self) internal returns (int256) {\n return abi.decode(read(self), (int256));\n }\n\n function parent(StdStorage storage self) internal returns (uint256, bytes32) {\n address who = self._target;\n uint256 field_depth = self._depth;\n vm.startMappingRecording();\n uint256 child = find(self, true).slot - field_depth;\n (bool found, bytes32 key, bytes32 parent_slot) = vm.getMappingKeyAndParentOf(who, bytes32(child));\n if (!found) {\n revert(\n \"stdStorage read_bool(StdStorage): Cannot find parent. Make sure you give a slot and startMappingRecording() has been called.\"\n );\n }\n return (uint256(parent_slot), key);\n }\n\n function root(StdStorage storage self) internal returns (uint256) {\n address who = self._target;\n uint256 field_depth = self._depth;\n vm.startMappingRecording();\n uint256 child = find(self, true).slot - field_depth;\n bool found;\n bytes32 root_slot;\n bytes32 parent_slot;\n (found,, parent_slot) = vm.getMappingKeyAndParentOf(who, bytes32(child));\n if (!found) {\n revert(\n \"stdStorage read_bool(StdStorage): Cannot find parent. Make sure you give a slot and startMappingRecording() has been called.\"\n );\n }\n while (found) {\n root_slot = parent_slot;\n (found,, parent_slot) = vm.getMappingKeyAndParentOf(who, bytes32(root_slot));\n }\n return uint256(root_slot);\n }\n\n function bytesToBytes32(bytes memory b, uint256 offset) private pure returns (bytes32) {\n bytes32 out;\n\n uint256 max = b.length > 32 ? 32 : b.length;\n for (uint256 i = 0; i < max; i++) {\n out |= bytes32(b[offset + i] & 0xFF) >> (i * 8);\n }\n return out;\n }\n\n function flatten(bytes32[] memory b) private pure returns (bytes memory) {\n bytes memory result = new bytes(b.length * 32);\n for (uint256 i = 0; i < b.length; i++) {\n bytes32 k = b[i];\n /// @solidity memory-safe-assembly\n assembly {\n mstore(add(result, add(32, mul(32, i))), k)\n }\n }\n\n return result;\n }\n\n function clear(StdStorage storage self) internal {\n delete self._target;\n delete self._sig;\n delete self._keys;\n delete self._depth;\n delete self._enable_packed_slots;\n delete self._calldata;\n }\n\n // Returns mask which contains non-zero bits for values between `offsetLeft` and `offsetRight`\n // (slotValue & mask) >> offsetRight will be the value of the given packed variable\n function getMaskByOffsets(uint256 offsetLeft, uint256 offsetRight) internal pure returns (uint256 mask) {\n // mask = ((1 << (256 - (offsetRight + offsetLeft))) - 1) << offsetRight;\n // using assembly because (1 << 256) causes overflow\n assembly {\n mask := shl(offsetRight, sub(shl(sub(256, add(offsetRight, offsetLeft)), 1), 1))\n }\n }\n\n // Returns slot value with updated packed variable.\n function getUpdatedSlotValue(bytes32 curValue, uint256 varValue, uint256 offsetLeft, uint256 offsetRight)\n internal\n pure\n returns (bytes32 newValue)\n {\n return bytes32((uint256(curValue) & ~getMaskByOffsets(offsetLeft, offsetRight)) | (varValue << offsetRight));\n }\n}\n\nlibrary stdStorage {\n Vm private constant vm = Vm(address(uint160(uint256(keccak256(\"hevm cheat code\")))));\n\n function sigs(string memory sigStr) internal pure returns (bytes4) {\n return stdStorageSafe.sigs(sigStr);\n }\n\n function find(StdStorage storage self) internal returns (uint256) {\n return find(self, true);\n }\n\n function find(StdStorage storage self, bool _clear) internal returns (uint256) {\n return stdStorageSafe.find(self, _clear).slot;\n }\n\n function target(StdStorage storage self, address _target) internal returns (StdStorage storage) {\n return stdStorageSafe.target(self, _target);\n }\n\n function sig(StdStorage storage self, bytes4 _sig) internal returns (StdStorage storage) {\n return stdStorageSafe.sig(self, _sig);\n }\n\n function sig(StdStorage storage self, string memory _sig) internal returns (StdStorage storage) {\n return stdStorageSafe.sig(self, _sig);\n }\n\n function with_key(StdStorage storage self, address who) internal returns (StdStorage storage) {\n return stdStorageSafe.with_key(self, who);\n }\n\n function with_key(StdStorage storage self, uint256 amt) internal returns (StdStorage storage) {\n return stdStorageSafe.with_key(self, amt);\n }\n\n function with_key(StdStorage storage self, bytes32 key) internal returns (StdStorage storage) {\n return stdStorageSafe.with_key(self, key);\n }\n\n function with_calldata(StdStorage storage self, bytes memory _calldata) internal returns (StdStorage storage) {\n return stdStorageSafe.with_calldata(self, _calldata);\n }\n\n function enable_packed_slots(StdStorage storage self) internal returns (StdStorage storage) {\n return stdStorageSafe.enable_packed_slots(self);\n }\n\n function depth(StdStorage storage self, uint256 _depth) internal returns (StdStorage storage) {\n return stdStorageSafe.depth(self, _depth);\n }\n\n function clear(StdStorage storage self) internal {\n stdStorageSafe.clear(self);\n }\n\n function checked_write(StdStorage storage self, address who) internal {\n checked_write(self, bytes32(uint256(uint160(who))));\n }\n\n function checked_write(StdStorage storage self, uint256 amt) internal {\n checked_write(self, bytes32(amt));\n }\n\n function checked_write_int(StdStorage storage self, int256 val) internal {\n checked_write(self, bytes32(uint256(val)));\n }\n\n function checked_write(StdStorage storage self, bool write) internal {\n bytes32 t;\n /// @solidity memory-safe-assembly\n assembly {\n t := write\n }\n checked_write(self, t);\n }\n\n function checked_write(StdStorage storage self, bytes32 set) internal {\n address who = self._target;\n bytes4 fsig = self._sig;\n uint256 field_depth = self._depth;\n bytes memory params = stdStorageSafe.getCallParams(self);\n\n if (!self.finds[who][fsig][keccak256(abi.encodePacked(params, field_depth))].found) {\n find(self, false);\n }\n FindData storage data = self.finds[who][fsig][keccak256(abi.encodePacked(params, field_depth))];\n if ((data.offsetLeft + data.offsetRight) > 0) {\n uint256 maxVal = 2 ** (256 - (data.offsetLeft + data.offsetRight));\n require(\n uint256(set) < maxVal,\n string(\n abi.encodePacked(\n \"stdStorage find(StdStorage): Packed slot. We can't fit value greater than \",\n vm.toString(maxVal)\n )\n )\n );\n }\n bytes32 curVal = vm.load(who, bytes32(data.slot));\n bytes32 valToSet = stdStorageSafe.getUpdatedSlotValue(curVal, uint256(set), data.offsetLeft, data.offsetRight);\n\n vm.store(who, bytes32(data.slot), valToSet);\n\n (bool success, bytes32 callResult) = stdStorageSafe.callTarget(self);\n\n if (!success || callResult != set) {\n vm.store(who, bytes32(data.slot), curVal);\n revert(\"stdStorage find(StdStorage): Failed to write value.\");\n }\n clear(self);\n }\n\n function read_bytes32(StdStorage storage self) internal returns (bytes32) {\n return stdStorageSafe.read_bytes32(self);\n }\n\n function read_bool(StdStorage storage self) internal returns (bool) {\n return stdStorageSafe.read_bool(self);\n }\n\n function read_address(StdStorage storage self) internal returns (address) {\n return stdStorageSafe.read_address(self);\n }\n\n function read_uint(StdStorage storage self) internal returns (uint256) {\n return stdStorageSafe.read_uint(self);\n }\n\n function read_int(StdStorage storage self) internal returns (int256) {\n return stdStorageSafe.read_int(self);\n }\n\n function parent(StdStorage storage self) internal returns (uint256, bytes32) {\n return stdStorageSafe.parent(self);\n }\n\n function root(StdStorage storage self) internal returns (uint256) {\n return stdStorageSafe.root(self);\n }\n}\n","license":"MIT"},"lib/forge-std/src/StdStyle.sol":{"keccak256":"0x43e2a8a9b9c2574dabe74f11adf6f782df218f463540e3b5b563609fe108597d","urls":[],"content":"// SPDX-License-Identifier: MIT\npragma solidity >=0.4.22 <0.9.0;\n\nimport {VmSafe} from \"./Vm.sol\";\n\nlibrary StdStyle {\n VmSafe private constant vm = VmSafe(address(uint160(uint256(keccak256(\"hevm cheat code\")))));\n\n string constant RED = \"\\u001b[91m\";\n string constant GREEN = \"\\u001b[92m\";\n string constant YELLOW = \"\\u001b[93m\";\n string constant BLUE = \"\\u001b[94m\";\n string constant MAGENTA = \"\\u001b[95m\";\n string constant CYAN = \"\\u001b[96m\";\n string constant BOLD = \"\\u001b[1m\";\n string constant DIM = \"\\u001b[2m\";\n string constant ITALIC = \"\\u001b[3m\";\n string constant UNDERLINE = \"\\u001b[4m\";\n string constant INVERSE = \"\\u001b[7m\";\n string constant RESET = \"\\u001b[0m\";\n\n function styleConcat(string memory style, string memory self) private pure returns (string memory) {\n return string(abi.encodePacked(style, self, RESET));\n }\n\n function red(string memory self) internal pure returns (string memory) {\n return styleConcat(RED, self);\n }\n\n function red(uint256 self) internal pure returns (string memory) {\n return red(vm.toString(self));\n }\n\n function red(int256 self) internal pure returns (string memory) {\n return red(vm.toString(self));\n }\n\n function red(address self) internal pure returns (string memory) {\n return red(vm.toString(self));\n }\n\n function red(bool self) internal pure returns (string memory) {\n return red(vm.toString(self));\n }\n\n function redBytes(bytes memory self) internal pure returns (string memory) {\n return red(vm.toString(self));\n }\n\n function redBytes32(bytes32 self) internal pure returns (string memory) {\n return red(vm.toString(self));\n }\n\n function green(string memory self) internal pure returns (string memory) {\n return styleConcat(GREEN, self);\n }\n\n function green(uint256 self) internal pure returns (string memory) {\n return green(vm.toString(self));\n }\n\n function green(int256 self) internal pure returns (string memory) {\n return green(vm.toString(self));\n }\n\n function green(address self) internal pure returns (string memory) {\n return green(vm.toString(self));\n }\n\n function green(bool self) internal pure returns (string memory) {\n return green(vm.toString(self));\n }\n\n function greenBytes(bytes memory self) internal pure returns (string memory) {\n return green(vm.toString(self));\n }\n\n function greenBytes32(bytes32 self) internal pure returns (string memory) {\n return green(vm.toString(self));\n }\n\n function yellow(string memory self) internal pure returns (string memory) {\n return styleConcat(YELLOW, self);\n }\n\n function yellow(uint256 self) internal pure returns (string memory) {\n return yellow(vm.toString(self));\n }\n\n function yellow(int256 self) internal pure returns (string memory) {\n return yellow(vm.toString(self));\n }\n\n function yellow(address self) internal pure returns (string memory) {\n return yellow(vm.toString(self));\n }\n\n function yellow(bool self) internal pure returns (string memory) {\n return yellow(vm.toString(self));\n }\n\n function yellowBytes(bytes memory self) internal pure returns (string memory) {\n return yellow(vm.toString(self));\n }\n\n function yellowBytes32(bytes32 self) internal pure returns (string memory) {\n return yellow(vm.toString(self));\n }\n\n function blue(string memory self) internal pure returns (string memory) {\n return styleConcat(BLUE, self);\n }\n\n function blue(uint256 self) internal pure returns (string memory) {\n return blue(vm.toString(self));\n }\n\n function blue(int256 self) internal pure returns (string memory) {\n return blue(vm.toString(self));\n }\n\n function blue(address self) internal pure returns (string memory) {\n return blue(vm.toString(self));\n }\n\n function blue(bool self) internal pure returns (string memory) {\n return blue(vm.toString(self));\n }\n\n function blueBytes(bytes memory self) internal pure returns (string memory) {\n return blue(vm.toString(self));\n }\n\n function blueBytes32(bytes32 self) internal pure returns (string memory) {\n return blue(vm.toString(self));\n }\n\n function magenta(string memory self) internal pure returns (string memory) {\n return styleConcat(MAGENTA, self);\n }\n\n function magenta(uint256 self) internal pure returns (string memory) {\n return magenta(vm.toString(self));\n }\n\n function magenta(int256 self) internal pure returns (string memory) {\n return magenta(vm.toString(self));\n }\n\n function magenta(address self) internal pure returns (string memory) {\n return magenta(vm.toString(self));\n }\n\n function magenta(bool self) internal pure returns (string memory) {\n return magenta(vm.toString(self));\n }\n\n function magentaBytes(bytes memory self) internal pure returns (string memory) {\n return magenta(vm.toString(self));\n }\n\n function magentaBytes32(bytes32 self) internal pure returns (string memory) {\n return magenta(vm.toString(self));\n }\n\n function cyan(string memory self) internal pure returns (string memory) {\n return styleConcat(CYAN, self);\n }\n\n function cyan(uint256 self) internal pure returns (string memory) {\n return cyan(vm.toString(self));\n }\n\n function cyan(int256 self) internal pure returns (string memory) {\n return cyan(vm.toString(self));\n }\n\n function cyan(address self) internal pure returns (string memory) {\n return cyan(vm.toString(self));\n }\n\n function cyan(bool self) internal pure returns (string memory) {\n return cyan(vm.toString(self));\n }\n\n function cyanBytes(bytes memory self) internal pure returns (string memory) {\n return cyan(vm.toString(self));\n }\n\n function cyanBytes32(bytes32 self) internal pure returns (string memory) {\n return cyan(vm.toString(self));\n }\n\n function bold(string memory self) internal pure returns (string memory) {\n return styleConcat(BOLD, self);\n }\n\n function bold(uint256 self) internal pure returns (string memory) {\n return bold(vm.toString(self));\n }\n\n function bold(int256 self) internal pure returns (string memory) {\n return bold(vm.toString(self));\n }\n\n function bold(address self) internal pure returns (string memory) {\n return bold(vm.toString(self));\n }\n\n function bold(bool self) internal pure returns (string memory) {\n return bold(vm.toString(self));\n }\n\n function boldBytes(bytes memory self) internal pure returns (string memory) {\n return bold(vm.toString(self));\n }\n\n function boldBytes32(bytes32 self) internal pure returns (string memory) {\n return bold(vm.toString(self));\n }\n\n function dim(string memory self) internal pure returns (string memory) {\n return styleConcat(DIM, self);\n }\n\n function dim(uint256 self) internal pure returns (string memory) {\n return dim(vm.toString(self));\n }\n\n function dim(int256 self) internal pure returns (string memory) {\n return dim(vm.toString(self));\n }\n\n function dim(address self) internal pure returns (string memory) {\n return dim(vm.toString(self));\n }\n\n function dim(bool self) internal pure returns (string memory) {\n return dim(vm.toString(self));\n }\n\n function dimBytes(bytes memory self) internal pure returns (string memory) {\n return dim(vm.toString(self));\n }\n\n function dimBytes32(bytes32 self) internal pure returns (string memory) {\n return dim(vm.toString(self));\n }\n\n function italic(string memory self) internal pure returns (string memory) {\n return styleConcat(ITALIC, self);\n }\n\n function italic(uint256 self) internal pure returns (string memory) {\n return italic(vm.toString(self));\n }\n\n function italic(int256 self) internal pure returns (string memory) {\n return italic(vm.toString(self));\n }\n\n function italic(address self) internal pure returns (string memory) {\n return italic(vm.toString(self));\n }\n\n function italic(bool self) internal pure returns (string memory) {\n return italic(vm.toString(self));\n }\n\n function italicBytes(bytes memory self) internal pure returns (string memory) {\n return italic(vm.toString(self));\n }\n\n function italicBytes32(bytes32 self) internal pure returns (string memory) {\n return italic(vm.toString(self));\n }\n\n function underline(string memory self) internal pure returns (string memory) {\n return styleConcat(UNDERLINE, self);\n }\n\n function underline(uint256 self) internal pure returns (string memory) {\n return underline(vm.toString(self));\n }\n\n function underline(int256 self) internal pure returns (string memory) {\n return underline(vm.toString(self));\n }\n\n function underline(address self) internal pure returns (string memory) {\n return underline(vm.toString(self));\n }\n\n function underline(bool self) internal pure returns (string memory) {\n return underline(vm.toString(self));\n }\n\n function underlineBytes(bytes memory self) internal pure returns (string memory) {\n return underline(vm.toString(self));\n }\n\n function underlineBytes32(bytes32 self) internal pure returns (string memory) {\n return underline(vm.toString(self));\n }\n\n function inverse(string memory self) internal pure returns (string memory) {\n return styleConcat(INVERSE, self);\n }\n\n function inverse(uint256 self) internal pure returns (string memory) {\n return inverse(vm.toString(self));\n }\n\n function inverse(int256 self) internal pure returns (string memory) {\n return inverse(vm.toString(self));\n }\n\n function inverse(address self) internal pure returns (string memory) {\n return inverse(vm.toString(self));\n }\n\n function inverse(bool self) internal pure returns (string memory) {\n return inverse(vm.toString(self));\n }\n\n function inverseBytes(bytes memory self) internal pure returns (string memory) {\n return inverse(vm.toString(self));\n }\n\n function inverseBytes32(bytes32 self) internal pure returns (string memory) {\n return inverse(vm.toString(self));\n }\n}\n","license":"MIT"},"lib/forge-std/src/StdUtils.sol":{"keccak256":"0x7274081e11c05164fd8eadde4de8305c033e58a43008dea58065f3170ccf0737","urls":[],"content":"// SPDX-License-Identifier: MIT\npragma solidity >=0.6.2 <0.9.0;\n\npragma experimental ABIEncoderV2;\n\nimport {IMulticall3} from \"./interfaces/IMulticall3.sol\";\nimport {VmSafe} from \"./Vm.sol\";\n\nabstract contract StdUtils {\n /*//////////////////////////////////////////////////////////////////////////\n CONSTANTS\n //////////////////////////////////////////////////////////////////////////*/\n\n IMulticall3 private constant multicall = IMulticall3(0xcA11bde05977b3631167028862bE2a173976CA11);\n VmSafe private constant vm = VmSafe(address(uint160(uint256(keccak256(\"hevm cheat code\")))));\n address private constant CONSOLE2_ADDRESS = 0x000000000000000000636F6e736F6c652e6c6f67;\n uint256 private constant INT256_MIN_ABS =\n 57896044618658097711785492504343953926634992332820282019728792003956564819968;\n uint256 private constant SECP256K1_ORDER =\n 115792089237316195423570985008687907852837564279074904382605163141518161494337;\n uint256 private constant UINT256_MAX =\n 115792089237316195423570985008687907853269984665640564039457584007913129639935;\n\n // Used by default when deploying with create2, https://github.com/Arachnid/deterministic-deployment-proxy.\n address private constant CREATE2_FACTORY = 0x4e59b44847b379578588920cA78FbF26c0B4956C;\n\n /*//////////////////////////////////////////////////////////////////////////\n INTERNAL FUNCTIONS\n //////////////////////////////////////////////////////////////////////////*/\n\n function _bound(uint256 x, uint256 min, uint256 max) internal pure virtual returns (uint256 result) {\n require(min <= max, \"StdUtils bound(uint256,uint256,uint256): Max is less than min.\");\n // If x is between min and max, return x directly. This is to ensure that dictionary values\n // do not get shifted if the min is nonzero. More info: https://github.com/foundry-rs/forge-std/issues/188\n if (x >= min && x <= max) return x;\n\n uint256 size = max - min + 1;\n\n // If the value is 0, 1, 2, 3, wrap that to min, min+1, min+2, min+3. Similarly for the UINT256_MAX side.\n // This helps ensure coverage of the min/max values.\n if (x <= 3 && size > x) return min + x;\n if (x >= UINT256_MAX - 3 && size > UINT256_MAX - x) return max - (UINT256_MAX - x);\n\n // Otherwise, wrap x into the range [min, max], i.e. the range is inclusive.\n if (x > max) {\n uint256 diff = x - max;\n uint256 rem = diff % size;\n if (rem == 0) return max;\n result = min + rem - 1;\n } else if (x < min) {\n uint256 diff = min - x;\n uint256 rem = diff % size;\n if (rem == 0) return min;\n result = max - rem + 1;\n }\n }\n\n function bound(uint256 x, uint256 min, uint256 max) internal pure virtual returns (uint256 result) {\n result = _bound(x, min, max);\n console2_log_StdUtils(\"Bound result\", result);\n }\n\n function _bound(int256 x, int256 min, int256 max) internal pure virtual returns (int256 result) {\n require(min <= max, \"StdUtils bound(int256,int256,int256): Max is less than min.\");\n\n // Shifting all int256 values to uint256 to use _bound function. The range of two types are:\n // int256 : -(2**255) ~ (2**255 - 1)\n // uint256: 0 ~ (2**256 - 1)\n // So, add 2**255, INT256_MIN_ABS to the integer values.\n //\n // If the given integer value is -2**255, we cannot use `-uint256(-x)` because of the overflow.\n // So, use `~uint256(x) + 1` instead.\n uint256 _x = x < 0 ? (INT256_MIN_ABS - ~uint256(x) - 1) : (uint256(x) + INT256_MIN_ABS);\n uint256 _min = min < 0 ? (INT256_MIN_ABS - ~uint256(min) - 1) : (uint256(min) + INT256_MIN_ABS);\n uint256 _max = max < 0 ? (INT256_MIN_ABS - ~uint256(max) - 1) : (uint256(max) + INT256_MIN_ABS);\n\n uint256 y = _bound(_x, _min, _max);\n\n // To move it back to int256 value, subtract INT256_MIN_ABS at here.\n result = y < INT256_MIN_ABS ? int256(~(INT256_MIN_ABS - y) + 1) : int256(y - INT256_MIN_ABS);\n }\n\n function bound(int256 x, int256 min, int256 max) internal pure virtual returns (int256 result) {\n result = _bound(x, min, max);\n console2_log_StdUtils(\"Bound result\", vm.toString(result));\n }\n\n function boundPrivateKey(uint256 privateKey) internal pure virtual returns (uint256 result) {\n result = _bound(privateKey, 1, SECP256K1_ORDER - 1);\n }\n\n function bytesToUint(bytes memory b) internal pure virtual returns (uint256) {\n require(b.length <= 32, \"StdUtils bytesToUint(bytes): Bytes length exceeds 32.\");\n return abi.decode(abi.encodePacked(new bytes(32 - b.length), b), (uint256));\n }\n\n /// @dev Compute the address a contract will be deployed at for a given deployer address and nonce\n /// @notice adapted from Solmate implementation (https://github.com/Rari-Capital/solmate/blob/main/src/utils/LibRLP.sol)\n function computeCreateAddress(address deployer, uint256 nonce) internal pure virtual returns (address) {\n console2_log_StdUtils(\"computeCreateAddress is deprecated. Please use vm.computeCreateAddress instead.\");\n return vm.computeCreateAddress(deployer, nonce);\n }\n\n function computeCreate2Address(bytes32 salt, bytes32 initcodeHash, address deployer)\n internal\n pure\n virtual\n returns (address)\n {\n console2_log_StdUtils(\"computeCreate2Address is deprecated. Please use vm.computeCreate2Address instead.\");\n return vm.computeCreate2Address(salt, initcodeHash, deployer);\n }\n\n /// @dev returns the address of a contract created with CREATE2 using the default CREATE2 deployer\n function computeCreate2Address(bytes32 salt, bytes32 initCodeHash) internal pure returns (address) {\n console2_log_StdUtils(\"computeCreate2Address is deprecated. Please use vm.computeCreate2Address instead.\");\n return vm.computeCreate2Address(salt, initCodeHash);\n }\n\n /// @dev returns the hash of the init code (creation code + no args) used in CREATE2 with no constructor arguments\n /// @param creationCode the creation code of a contract C, as returned by type(C).creationCode\n function hashInitCode(bytes memory creationCode) internal pure returns (bytes32) {\n return hashInitCode(creationCode, \"\");\n }\n\n /// @dev returns the hash of the init code (creation code + ABI-encoded args) used in CREATE2\n /// @param creationCode the creation code of a contract C, as returned by type(C).creationCode\n /// @param args the ABI-encoded arguments to the constructor of C\n function hashInitCode(bytes memory creationCode, bytes memory args) internal pure returns (bytes32) {\n return keccak256(abi.encodePacked(creationCode, args));\n }\n\n // Performs a single call with Multicall3 to query the ERC-20 token balances of the given addresses.\n function getTokenBalances(address token, address[] memory addresses)\n internal\n virtual\n returns (uint256[] memory balances)\n {\n uint256 tokenCodeSize;\n assembly {\n tokenCodeSize := extcodesize(token)\n }\n require(tokenCodeSize > 0, \"StdUtils getTokenBalances(address,address[]): Token address is not a contract.\");\n\n // ABI encode the aggregate call to Multicall3.\n uint256 length = addresses.length;\n IMulticall3.Call[] memory calls = new IMulticall3.Call[](length);\n for (uint256 i = 0; i < length; ++i) {\n // 0x70a08231 = bytes4(\"balanceOf(address)\"))\n calls[i] = IMulticall3.Call({target: token, callData: abi.encodeWithSelector(0x70a08231, (addresses[i]))});\n }\n\n // Make the aggregate call.\n (, bytes[] memory returnData) = multicall.aggregate(calls);\n\n // ABI decode the return data and return the balances.\n balances = new uint256[](length);\n for (uint256 i = 0; i < length; ++i) {\n balances[i] = abi.decode(returnData[i], (uint256));\n }\n }\n\n /*//////////////////////////////////////////////////////////////////////////\n PRIVATE FUNCTIONS\n //////////////////////////////////////////////////////////////////////////*/\n\n function addressFromLast20Bytes(bytes32 bytesValue) private pure returns (address) {\n return address(uint160(uint256(bytesValue)));\n }\n\n // This section is used to prevent the compilation of console, which shortens the compilation time when console is\n // not used elsewhere. We also trick the compiler into letting us make the console log methods as `pure` to avoid\n // any breaking changes to function signatures.\n function _castLogPayloadViewToPure(function(bytes memory) internal view fnIn)\n internal\n pure\n returns (function(bytes memory) internal pure fnOut)\n {\n assembly {\n fnOut := fnIn\n }\n }\n\n function _sendLogPayload(bytes memory payload) internal pure {\n _castLogPayloadViewToPure(_sendLogPayloadView)(payload);\n }\n\n function _sendLogPayloadView(bytes memory payload) private view {\n uint256 payloadLength = payload.length;\n address consoleAddress = CONSOLE2_ADDRESS;\n /// @solidity memory-safe-assembly\n assembly {\n let payloadStart := add(payload, 32)\n let r := staticcall(gas(), consoleAddress, payloadStart, payloadLength, 0, 0)\n }\n }\n\n function console2_log_StdUtils(string memory p0) private pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string)\", p0));\n }\n\n function console2_log_StdUtils(string memory p0, uint256 p1) private pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,uint256)\", p0, p1));\n }\n\n function console2_log_StdUtils(string memory p0, string memory p1) private pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,string)\", p0, p1));\n }\n}\n","license":"MIT"},"lib/forge-std/src/Vm.sol":{"keccak256":"0xd91fb0df409fbd22463e937b48b9682d9333c5d4528d8fe7b36102a0323c44bf","urls":[],"content":"// Automatically @generated by scripts/vm.py. Do not modify manually.\n\n// SPDX-License-Identifier: MIT OR Apache-2.0\npragma solidity >=0.6.2 <0.9.0;\npragma experimental ABIEncoderV2;\n\n/// The `VmSafe` interface does not allow manipulation of the EVM state or other actions that may\n/// result in Script simulations differing from on-chain execution. It is recommended to only use\n/// these cheats in scripts.\ninterface VmSafe {\n /// A modification applied to either `msg.sender` or `tx.origin`. Returned by `readCallers`.\n enum CallerMode {\n // No caller modification is currently active.\n None,\n // A one time broadcast triggered by a `vm.broadcast()` call is currently active.\n Broadcast,\n // A recurrent broadcast triggered by a `vm.startBroadcast()` call is currently active.\n RecurrentBroadcast,\n // A one time prank triggered by a `vm.prank()` call is currently active.\n Prank,\n // A recurrent prank triggered by a `vm.startPrank()` call is currently active.\n RecurrentPrank\n }\n\n /// The kind of account access that occurred.\n enum AccountAccessKind {\n // The account was called.\n Call,\n // The account was called via delegatecall.\n DelegateCall,\n // The account was called via callcode.\n CallCode,\n // The account was called via staticcall.\n StaticCall,\n // The account was created.\n Create,\n // The account was selfdestructed.\n SelfDestruct,\n // Synthetic access indicating the current context has resumed after a previous sub-context (AccountAccess).\n Resume,\n // The account's balance was read.\n Balance,\n // The account's codesize was read.\n Extcodesize,\n // The account's codehash was read.\n Extcodehash,\n // The account's code was copied.\n Extcodecopy\n }\n\n /// Forge execution contexts.\n enum ForgeContext {\n // Test group execution context (test, coverage or snapshot).\n TestGroup,\n // `forge test` execution context.\n Test,\n // `forge coverage` execution context.\n Coverage,\n // `forge snapshot` execution context.\n Snapshot,\n // Script group execution context (dry run, broadcast or resume).\n ScriptGroup,\n // `forge script` execution context.\n ScriptDryRun,\n // `forge script --broadcast` execution context.\n ScriptBroadcast,\n // `forge script --resume` execution context.\n ScriptResume,\n // Unknown `forge` execution context.\n Unknown\n }\n\n /// The transaction type (`txType`) of the broadcast.\n enum BroadcastTxType {\n // Represents a CALL broadcast tx.\n Call,\n // Represents a CREATE broadcast tx.\n Create,\n // Represents a CREATE2 broadcast tx.\n Create2\n }\n\n /// An Ethereum log. Returned by `getRecordedLogs`.\n struct Log {\n // The topics of the log, including the signature, if any.\n bytes32[] topics;\n // The raw data of the log.\n bytes data;\n // The address of the log's emitter.\n address emitter;\n }\n\n /// An RPC URL and its alias. Returned by `rpcUrlStructs`.\n struct Rpc {\n // The alias of the RPC URL.\n string key;\n // The RPC URL.\n string url;\n }\n\n /// An RPC log object. Returned by `eth_getLogs`.\n struct EthGetLogs {\n // The address of the log's emitter.\n address emitter;\n // The topics of the log, including the signature, if any.\n bytes32[] topics;\n // The raw data of the log.\n bytes data;\n // The block hash.\n bytes32 blockHash;\n // The block number.\n uint64 blockNumber;\n // The transaction hash.\n bytes32 transactionHash;\n // The transaction index in the block.\n uint64 transactionIndex;\n // The log index.\n uint256 logIndex;\n // Whether the log was removed.\n bool removed;\n }\n\n /// A single entry in a directory listing. Returned by `readDir`.\n struct DirEntry {\n // The error message, if any.\n string errorMessage;\n // The path of the entry.\n string path;\n // The depth of the entry.\n uint64 depth;\n // Whether the entry is a directory.\n bool isDir;\n // Whether the entry is a symlink.\n bool isSymlink;\n }\n\n /// Metadata information about a file.\n /// This structure is returned from the `fsMetadata` function and represents known\n /// metadata about a file such as its permissions, size, modification\n /// times, etc.\n struct FsMetadata {\n // True if this metadata is for a directory.\n bool isDir;\n // True if this metadata is for a symlink.\n bool isSymlink;\n // The size of the file, in bytes, this metadata is for.\n uint256 length;\n // True if this metadata is for a readonly (unwritable) file.\n bool readOnly;\n // The last modification time listed in this metadata.\n uint256 modified;\n // The last access time of this metadata.\n uint256 accessed;\n // The creation time listed in this metadata.\n uint256 created;\n }\n\n /// A wallet with a public and private key.\n struct Wallet {\n // The wallet's address.\n address addr;\n // The wallet's public key `X`.\n uint256 publicKeyX;\n // The wallet's public key `Y`.\n uint256 publicKeyY;\n // The wallet's private key.\n uint256 privateKey;\n }\n\n /// The result of a `tryFfi` call.\n struct FfiResult {\n // The exit code of the call.\n int32 exitCode;\n // The optionally hex-decoded `stdout` data.\n bytes stdout;\n // The `stderr` data.\n bytes stderr;\n }\n\n /// Information on the chain and fork.\n struct ChainInfo {\n // The fork identifier. Set to zero if no fork is active.\n uint256 forkId;\n // The chain ID of the current fork.\n uint256 chainId;\n }\n\n /// The result of a `stopAndReturnStateDiff` call.\n struct AccountAccess {\n // The chain and fork the access occurred.\n ChainInfo chainInfo;\n // The kind of account access that determines what the account is.\n // If kind is Call, DelegateCall, StaticCall or CallCode, then the account is the callee.\n // If kind is Create, then the account is the newly created account.\n // If kind is SelfDestruct, then the account is the selfdestruct recipient.\n // If kind is a Resume, then account represents a account context that has resumed.\n AccountAccessKind kind;\n // The account that was accessed.\n // It's either the account created, callee or a selfdestruct recipient for CREATE, CALL or SELFDESTRUCT.\n address account;\n // What accessed the account.\n address accessor;\n // If the account was initialized or empty prior to the access.\n // An account is considered initialized if it has code, a\n // non-zero nonce, or a non-zero balance.\n bool initialized;\n // The previous balance of the accessed account.\n uint256 oldBalance;\n // The potential new balance of the accessed account.\n // That is, all balance changes are recorded here, even if reverts occurred.\n uint256 newBalance;\n // Code of the account deployed by CREATE.\n bytes deployedCode;\n // Value passed along with the account access\n uint256 value;\n // Input data provided to the CREATE or CALL\n bytes data;\n // If this access reverted in either the current or parent context.\n bool reverted;\n // An ordered list of storage accesses made during an account access operation.\n StorageAccess[] storageAccesses;\n // Call depth traversed during the recording of state differences\n uint64 depth;\n }\n\n /// The storage accessed during an `AccountAccess`.\n struct StorageAccess {\n // The account whose storage was accessed.\n address account;\n // The slot that was accessed.\n bytes32 slot;\n // If the access was a write.\n bool isWrite;\n // The previous value of the slot.\n bytes32 previousValue;\n // The new value of the slot.\n bytes32 newValue;\n // If the access was reverted.\n bool reverted;\n }\n\n /// Gas used. Returned by `lastCallGas`.\n struct Gas {\n // The gas limit of the call.\n uint64 gasLimit;\n // The total gas used.\n uint64 gasTotalUsed;\n // DEPRECATED: The amount of gas used for memory expansion. Ref: \n uint64 gasMemoryUsed;\n // The amount of gas refunded.\n int64 gasRefunded;\n // The amount of gas remaining.\n uint64 gasRemaining;\n }\n\n /// The result of the `stopDebugTraceRecording` call\n struct DebugStep {\n // The stack before executing the step of the run.\n // stack\\[0\\] represents the top of the stack.\n // and only stack data relevant to the opcode execution is contained.\n uint256[] stack;\n // The memory input data before executing the step of the run.\n // only input data relevant to the opcode execution is contained.\n // e.g. for MLOAD, it will have memory\\[offset:offset+32\\] copied here.\n // the offset value can be get by the stack data.\n bytes memoryInput;\n // The opcode that was accessed.\n uint8 opcode;\n // The call depth of the step.\n uint64 depth;\n // Whether the call end up with out of gas error.\n bool isOutOfGas;\n // The contract address where the opcode is running\n address contractAddr;\n }\n\n /// Represents a transaction's broadcast details.\n struct BroadcastTxSummary {\n // The hash of the transaction that was broadcasted\n bytes32 txHash;\n // Represent the type of transaction among CALL, CREATE, CREATE2\n BroadcastTxType txType;\n // The address of the contract that was called or created.\n // This is address of the contract that is created if the txType is CREATE or CREATE2.\n address contractAddress;\n // The block number the transaction landed in.\n uint64 blockNumber;\n // Status of the transaction, retrieved from the transaction receipt.\n bool success;\n }\n\n /// Holds a signed EIP-7702 authorization for an authority account to delegate to an implementation.\n struct SignedDelegation {\n // The y-parity of the recovered secp256k1 signature (0 or 1).\n uint8 v;\n // First 32 bytes of the signature.\n bytes32 r;\n // Second 32 bytes of the signature.\n bytes32 s;\n // The current nonce of the authority account at signing time.\n // Used to ensure signature can't be replayed after account nonce changes.\n uint64 nonce;\n // Address of the contract implementation that will be delegated to.\n // Gets encoded into delegation code: 0xef0100 || implementation.\n address implementation;\n }\n\n /// Represents a \"potential\" revert reason from a single subsequent call when using `vm.assumeNoReverts`.\n /// Reverts that match will result in a FOUNDRY::ASSUME rejection, whereas unmatched reverts will be surfaced\n /// as normal.\n struct PotentialRevert {\n // The allowed origin of the revert opcode; address(0) allows reverts from any address\n address reverter;\n // When true, only matches on the beginning of the revert data, otherwise, matches on entire revert data\n bool partialMatch;\n // The data to use to match encountered reverts\n bytes revertData;\n }\n\n /// An EIP-2930 access list item.\n struct AccessListItem {\n // The address to be added in access list.\n address target;\n // The storage keys to be added in access list.\n bytes32[] storageKeys;\n }\n\n // ======== Crypto ========\n\n /// Derives a private key from the name, labels the account with that name, and returns the wallet.\n function createWallet(string calldata walletLabel) external returns (Wallet memory wallet);\n\n /// Generates a wallet from the private key and returns the wallet.\n function createWallet(uint256 privateKey) external returns (Wallet memory wallet);\n\n /// Generates a wallet from the private key, labels the account with that name, and returns the wallet.\n function createWallet(uint256 privateKey, string calldata walletLabel) external returns (Wallet memory wallet);\n\n /// Derive a private key from a provided mnenomic string (or mnenomic file path)\n /// at the derivation path `m/44'/60'/0'/0/{index}`.\n function deriveKey(string calldata mnemonic, uint32 index) external pure returns (uint256 privateKey);\n\n /// Derive a private key from a provided mnenomic string (or mnenomic file path)\n /// at `{derivationPath}{index}`.\n function deriveKey(string calldata mnemonic, string calldata derivationPath, uint32 index)\n external\n pure\n returns (uint256 privateKey);\n\n /// Derive a private key from a provided mnenomic string (or mnenomic file path) in the specified language\n /// at the derivation path `m/44'/60'/0'/0/{index}`.\n function deriveKey(string calldata mnemonic, uint32 index, string calldata language)\n external\n pure\n returns (uint256 privateKey);\n\n /// Derive a private key from a provided mnenomic string (or mnenomic file path) in the specified language\n /// at `{derivationPath}{index}`.\n function deriveKey(string calldata mnemonic, string calldata derivationPath, uint32 index, string calldata language)\n external\n pure\n returns (uint256 privateKey);\n\n /// Derives secp256r1 public key from the provided `privateKey`.\n function publicKeyP256(uint256 privateKey) external pure returns (uint256 publicKeyX, uint256 publicKeyY);\n\n /// Adds a private key to the local forge wallet and returns the address.\n function rememberKey(uint256 privateKey) external returns (address keyAddr);\n\n /// Derive a set number of wallets from a mnemonic at the derivation path `m/44'/60'/0'/0/{0..count}`.\n /// The respective private keys are saved to the local forge wallet for later use and their addresses are returned.\n function rememberKeys(string calldata mnemonic, string calldata derivationPath, uint32 count)\n external\n returns (address[] memory keyAddrs);\n\n /// Derive a set number of wallets from a mnemonic in the specified language at the derivation path `m/44'/60'/0'/0/{0..count}`.\n /// The respective private keys are saved to the local forge wallet for later use and their addresses are returned.\n function rememberKeys(\n string calldata mnemonic,\n string calldata derivationPath,\n string calldata language,\n uint32 count\n ) external returns (address[] memory keyAddrs);\n\n /// Signs data with a `Wallet`.\n /// Returns a compact signature (`r`, `vs`) as per EIP-2098, where `vs` encodes both the\n /// signature's `s` value, and the recovery id `v` in a single bytes32.\n /// This format reduces the signature size from 65 to 64 bytes.\n function signCompact(Wallet calldata wallet, bytes32 digest) external returns (bytes32 r, bytes32 vs);\n\n /// Signs `digest` with `privateKey` using the secp256k1 curve.\n /// Returns a compact signature (`r`, `vs`) as per EIP-2098, where `vs` encodes both the\n /// signature's `s` value, and the recovery id `v` in a single bytes32.\n /// This format reduces the signature size from 65 to 64 bytes.\n function signCompact(uint256 privateKey, bytes32 digest) external pure returns (bytes32 r, bytes32 vs);\n\n /// Signs `digest` with signer provided to script using the secp256k1 curve.\n /// Returns a compact signature (`r`, `vs`) as per EIP-2098, where `vs` encodes both the\n /// signature's `s` value, and the recovery id `v` in a single bytes32.\n /// This format reduces the signature size from 65 to 64 bytes.\n /// If `--sender` is provided, the signer with provided address is used, otherwise,\n /// if exactly one signer is provided to the script, that signer is used.\n /// Raises error if signer passed through `--sender` does not match any unlocked signers or\n /// if `--sender` is not provided and not exactly one signer is passed to the script.\n function signCompact(bytes32 digest) external pure returns (bytes32 r, bytes32 vs);\n\n /// Signs `digest` with signer provided to script using the secp256k1 curve.\n /// Returns a compact signature (`r`, `vs`) as per EIP-2098, where `vs` encodes both the\n /// signature's `s` value, and the recovery id `v` in a single bytes32.\n /// This format reduces the signature size from 65 to 64 bytes.\n /// Raises error if none of the signers passed into the script have provided address.\n function signCompact(address signer, bytes32 digest) external pure returns (bytes32 r, bytes32 vs);\n\n /// Signs `digest` with `privateKey` using the secp256r1 curve.\n function signP256(uint256 privateKey, bytes32 digest) external pure returns (bytes32 r, bytes32 s);\n\n /// Signs data with a `Wallet`.\n function sign(Wallet calldata wallet, bytes32 digest) external returns (uint8 v, bytes32 r, bytes32 s);\n\n /// Signs `digest` with `privateKey` using the secp256k1 curve.\n function sign(uint256 privateKey, bytes32 digest) external pure returns (uint8 v, bytes32 r, bytes32 s);\n\n /// Signs `digest` with signer provided to script using the secp256k1 curve.\n /// If `--sender` is provided, the signer with provided address is used, otherwise,\n /// if exactly one signer is provided to the script, that signer is used.\n /// Raises error if signer passed through `--sender` does not match any unlocked signers or\n /// if `--sender` is not provided and not exactly one signer is passed to the script.\n function sign(bytes32 digest) external pure returns (uint8 v, bytes32 r, bytes32 s);\n\n /// Signs `digest` with signer provided to script using the secp256k1 curve.\n /// Raises error if none of the signers passed into the script have provided address.\n function sign(address signer, bytes32 digest) external pure returns (uint8 v, bytes32 r, bytes32 s);\n\n // ======== Environment ========\n\n /// Gets the environment variable `name` and parses it as `address`.\n /// Reverts if the variable was not found or could not be parsed.\n function envAddress(string calldata name) external view returns (address value);\n\n /// Gets the environment variable `name` and parses it as an array of `address`, delimited by `delim`.\n /// Reverts if the variable was not found or could not be parsed.\n function envAddress(string calldata name, string calldata delim) external view returns (address[] memory value);\n\n /// Gets the environment variable `name` and parses it as `bool`.\n /// Reverts if the variable was not found or could not be parsed.\n function envBool(string calldata name) external view returns (bool value);\n\n /// Gets the environment variable `name` and parses it as an array of `bool`, delimited by `delim`.\n /// Reverts if the variable was not found or could not be parsed.\n function envBool(string calldata name, string calldata delim) external view returns (bool[] memory value);\n\n /// Gets the environment variable `name` and parses it as `bytes32`.\n /// Reverts if the variable was not found or could not be parsed.\n function envBytes32(string calldata name) external view returns (bytes32 value);\n\n /// Gets the environment variable `name` and parses it as an array of `bytes32`, delimited by `delim`.\n /// Reverts if the variable was not found or could not be parsed.\n function envBytes32(string calldata name, string calldata delim) external view returns (bytes32[] memory value);\n\n /// Gets the environment variable `name` and parses it as `bytes`.\n /// Reverts if the variable was not found or could not be parsed.\n function envBytes(string calldata name) external view returns (bytes memory value);\n\n /// Gets the environment variable `name` and parses it as an array of `bytes`, delimited by `delim`.\n /// Reverts if the variable was not found or could not be parsed.\n function envBytes(string calldata name, string calldata delim) external view returns (bytes[] memory value);\n\n /// Gets the environment variable `name` and returns true if it exists, else returns false.\n function envExists(string calldata name) external view returns (bool result);\n\n /// Gets the environment variable `name` and parses it as `int256`.\n /// Reverts if the variable was not found or could not be parsed.\n function envInt(string calldata name) external view returns (int256 value);\n\n /// Gets the environment variable `name` and parses it as an array of `int256`, delimited by `delim`.\n /// Reverts if the variable was not found or could not be parsed.\n function envInt(string calldata name, string calldata delim) external view returns (int256[] memory value);\n\n /// Gets the environment variable `name` and parses it as `bool`.\n /// Reverts if the variable could not be parsed.\n /// Returns `defaultValue` if the variable was not found.\n function envOr(string calldata name, bool defaultValue) external view returns (bool value);\n\n /// Gets the environment variable `name` and parses it as `uint256`.\n /// Reverts if the variable could not be parsed.\n /// Returns `defaultValue` if the variable was not found.\n function envOr(string calldata name, uint256 defaultValue) external view returns (uint256 value);\n\n /// Gets the environment variable `name` and parses it as an array of `address`, delimited by `delim`.\n /// Reverts if the variable could not be parsed.\n /// Returns `defaultValue` if the variable was not found.\n function envOr(string calldata name, string calldata delim, address[] calldata defaultValue)\n external\n view\n returns (address[] memory value);\n\n /// Gets the environment variable `name` and parses it as an array of `bytes32`, delimited by `delim`.\n /// Reverts if the variable could not be parsed.\n /// Returns `defaultValue` if the variable was not found.\n function envOr(string calldata name, string calldata delim, bytes32[] calldata defaultValue)\n external\n view\n returns (bytes32[] memory value);\n\n /// Gets the environment variable `name` and parses it as an array of `string`, delimited by `delim`.\n /// Reverts if the variable could not be parsed.\n /// Returns `defaultValue` if the variable was not found.\n function envOr(string calldata name, string calldata delim, string[] calldata defaultValue)\n external\n view\n returns (string[] memory value);\n\n /// Gets the environment variable `name` and parses it as an array of `bytes`, delimited by `delim`.\n /// Reverts if the variable could not be parsed.\n /// Returns `defaultValue` if the variable was not found.\n function envOr(string calldata name, string calldata delim, bytes[] calldata defaultValue)\n external\n view\n returns (bytes[] memory value);\n\n /// Gets the environment variable `name` and parses it as `int256`.\n /// Reverts if the variable could not be parsed.\n /// Returns `defaultValue` if the variable was not found.\n function envOr(string calldata name, int256 defaultValue) external view returns (int256 value);\n\n /// Gets the environment variable `name` and parses it as `address`.\n /// Reverts if the variable could not be parsed.\n /// Returns `defaultValue` if the variable was not found.\n function envOr(string calldata name, address defaultValue) external view returns (address value);\n\n /// Gets the environment variable `name` and parses it as `bytes32`.\n /// Reverts if the variable could not be parsed.\n /// Returns `defaultValue` if the variable was not found.\n function envOr(string calldata name, bytes32 defaultValue) external view returns (bytes32 value);\n\n /// Gets the environment variable `name` and parses it as `string`.\n /// Reverts if the variable could not be parsed.\n /// Returns `defaultValue` if the variable was not found.\n function envOr(string calldata name, string calldata defaultValue) external view returns (string memory value);\n\n /// Gets the environment variable `name` and parses it as `bytes`.\n /// Reverts if the variable could not be parsed.\n /// Returns `defaultValue` if the variable was not found.\n function envOr(string calldata name, bytes calldata defaultValue) external view returns (bytes memory value);\n\n /// Gets the environment variable `name` and parses it as an array of `bool`, delimited by `delim`.\n /// Reverts if the variable could not be parsed.\n /// Returns `defaultValue` if the variable was not found.\n function envOr(string calldata name, string calldata delim, bool[] calldata defaultValue)\n external\n view\n returns (bool[] memory value);\n\n /// Gets the environment variable `name` and parses it as an array of `uint256`, delimited by `delim`.\n /// Reverts if the variable could not be parsed.\n /// Returns `defaultValue` if the variable was not found.\n function envOr(string calldata name, string calldata delim, uint256[] calldata defaultValue)\n external\n view\n returns (uint256[] memory value);\n\n /// Gets the environment variable `name` and parses it as an array of `int256`, delimited by `delim`.\n /// Reverts if the variable could not be parsed.\n /// Returns `defaultValue` if the variable was not found.\n function envOr(string calldata name, string calldata delim, int256[] calldata defaultValue)\n external\n view\n returns (int256[] memory value);\n\n /// Gets the environment variable `name` and parses it as `string`.\n /// Reverts if the variable was not found or could not be parsed.\n function envString(string calldata name) external view returns (string memory value);\n\n /// Gets the environment variable `name` and parses it as an array of `string`, delimited by `delim`.\n /// Reverts if the variable was not found or could not be parsed.\n function envString(string calldata name, string calldata delim) external view returns (string[] memory value);\n\n /// Gets the environment variable `name` and parses it as `uint256`.\n /// Reverts if the variable was not found or could not be parsed.\n function envUint(string calldata name) external view returns (uint256 value);\n\n /// Gets the environment variable `name` and parses it as an array of `uint256`, delimited by `delim`.\n /// Reverts if the variable was not found or could not be parsed.\n function envUint(string calldata name, string calldata delim) external view returns (uint256[] memory value);\n\n /// Returns true if `forge` command was executed in given context.\n function isContext(ForgeContext context) external view returns (bool result);\n\n /// Sets environment variables.\n function setEnv(string calldata name, string calldata value) external;\n\n // ======== EVM ========\n\n /// Gets all accessed reads and write slot from a `vm.record` session, for a given address.\n function accesses(address target) external returns (bytes32[] memory readSlots, bytes32[] memory writeSlots);\n\n /// Gets the address for a given private key.\n function addr(uint256 privateKey) external pure returns (address keyAddr);\n\n /// Gets all the logs according to specified filter.\n function eth_getLogs(uint256 fromBlock, uint256 toBlock, address target, bytes32[] calldata topics)\n external\n returns (EthGetLogs[] memory logs);\n\n /// Gets the current `block.blobbasefee`.\n /// You should use this instead of `block.blobbasefee` if you use `vm.blobBaseFee`, as `block.blobbasefee` is assumed to be constant across a transaction,\n /// and as a result will get optimized out by the compiler.\n /// See https://github.com/foundry-rs/foundry/issues/6180\n function getBlobBaseFee() external view returns (uint256 blobBaseFee);\n\n /// Gets the current `block.number`.\n /// You should use this instead of `block.number` if you use `vm.roll`, as `block.number` is assumed to be constant across a transaction,\n /// and as a result will get optimized out by the compiler.\n /// See https://github.com/foundry-rs/foundry/issues/6180\n function getBlockNumber() external view returns (uint256 height);\n\n /// Gets the current `block.timestamp`.\n /// You should use this instead of `block.timestamp` if you use `vm.warp`, as `block.timestamp` is assumed to be constant across a transaction,\n /// and as a result will get optimized out by the compiler.\n /// See https://github.com/foundry-rs/foundry/issues/6180\n function getBlockTimestamp() external view returns (uint256 timestamp);\n\n /// Gets the map key and parent of a mapping at a given slot, for a given address.\n function getMappingKeyAndParentOf(address target, bytes32 elementSlot)\n external\n returns (bool found, bytes32 key, bytes32 parent);\n\n /// Gets the number of elements in the mapping at the given slot, for a given address.\n function getMappingLength(address target, bytes32 mappingSlot) external returns (uint256 length);\n\n /// Gets the elements at index idx of the mapping at the given slot, for a given address. The\n /// index must be less than the length of the mapping (i.e. the number of keys in the mapping).\n function getMappingSlotAt(address target, bytes32 mappingSlot, uint256 idx) external returns (bytes32 value);\n\n /// Gets the nonce of an account.\n function getNonce(address account) external view returns (uint64 nonce);\n\n /// Get the nonce of a `Wallet`.\n function getNonce(Wallet calldata wallet) external returns (uint64 nonce);\n\n /// Gets all the recorded logs.\n function getRecordedLogs() external returns (Log[] memory logs);\n\n /// Returns state diffs from current `vm.startStateDiffRecording` session.\n function getStateDiff() external view returns (string memory diff);\n\n /// Returns state diffs from current `vm.startStateDiffRecording` session, in json format.\n function getStateDiffJson() external view returns (string memory diff);\n\n /// Gets the gas used in the last call from the callee perspective.\n function lastCallGas() external view returns (Gas memory gas);\n\n /// Loads a storage slot from an address.\n function load(address target, bytes32 slot) external view returns (bytes32 data);\n\n /// Pauses gas metering (i.e. gas usage is not counted). Noop if already paused.\n function pauseGasMetering() external;\n\n /// Records all storage reads and writes.\n function record() external;\n\n /// Record all the transaction logs.\n function recordLogs() external;\n\n /// Reset gas metering (i.e. gas usage is set to gas limit).\n function resetGasMetering() external;\n\n /// Resumes gas metering (i.e. gas usage is counted again). Noop if already on.\n function resumeGasMetering() external;\n\n /// Performs an Ethereum JSON-RPC request to the current fork URL.\n function rpc(string calldata method, string calldata params) external returns (bytes memory data);\n\n /// Performs an Ethereum JSON-RPC request to the given endpoint.\n function rpc(string calldata urlOrAlias, string calldata method, string calldata params)\n external\n returns (bytes memory data);\n\n /// Records the debug trace during the run.\n function startDebugTraceRecording() external;\n\n /// Starts recording all map SSTOREs for later retrieval.\n function startMappingRecording() external;\n\n /// Record all account accesses as part of CREATE, CALL or SELFDESTRUCT opcodes in order,\n /// along with the context of the calls\n function startStateDiffRecording() external;\n\n /// Stop debug trace recording and returns the recorded debug trace.\n function stopAndReturnDebugTraceRecording() external returns (DebugStep[] memory step);\n\n /// Returns an ordered array of all account accesses from a `vm.startStateDiffRecording` session.\n function stopAndReturnStateDiff() external returns (AccountAccess[] memory accountAccesses);\n\n /// Stops recording all map SSTOREs for later retrieval and clears the recorded data.\n function stopMappingRecording() external;\n\n // ======== Filesystem ========\n\n /// Closes file for reading, resetting the offset and allowing to read it from beginning with readLine.\n /// `path` is relative to the project root.\n function closeFile(string calldata path) external;\n\n /// Copies the contents of one file to another. This function will **overwrite** the contents of `to`.\n /// On success, the total number of bytes copied is returned and it is equal to the length of the `to` file as reported by `metadata`.\n /// Both `from` and `to` are relative to the project root.\n function copyFile(string calldata from, string calldata to) external returns (uint64 copied);\n\n /// Creates a new, empty directory at the provided path.\n /// This cheatcode will revert in the following situations, but is not limited to just these cases:\n /// - User lacks permissions to modify `path`.\n /// - A parent of the given path doesn't exist and `recursive` is false.\n /// - `path` already exists and `recursive` is false.\n /// `path` is relative to the project root.\n function createDir(string calldata path, bool recursive) external;\n\n /// Deploys a contract from an artifact file. Takes in the relative path to the json file or the path to the\n /// artifact in the form of :: where and parts are optional.\n function deployCode(string calldata artifactPath) external returns (address deployedAddress);\n\n /// Deploys a contract from an artifact file. Takes in the relative path to the json file or the path to the\n /// artifact in the form of :: where and parts are optional.\n /// Additionally accepts abi-encoded constructor arguments.\n function deployCode(string calldata artifactPath, bytes calldata constructorArgs)\n external\n returns (address deployedAddress);\n\n /// Returns true if the given path points to an existing entity, else returns false.\n function exists(string calldata path) external view returns (bool result);\n\n /// Performs a foreign function call via the terminal.\n function ffi(string[] calldata commandInput) external returns (bytes memory result);\n\n /// Given a path, query the file system to get information about a file, directory, etc.\n function fsMetadata(string calldata path) external view returns (FsMetadata memory metadata);\n\n /// Gets the artifact path from code (aka. creation code).\n function getArtifactPathByCode(bytes calldata code) external view returns (string memory path);\n\n /// Gets the artifact path from deployed code (aka. runtime code).\n function getArtifactPathByDeployedCode(bytes calldata deployedCode) external view returns (string memory path);\n\n /// Returns the most recent broadcast for the given contract on `chainId` matching `txType`.\n /// For example:\n /// The most recent deployment can be fetched by passing `txType` as `CREATE` or `CREATE2`.\n /// The most recent call can be fetched by passing `txType` as `CALL`.\n function getBroadcast(string calldata contractName, uint64 chainId, BroadcastTxType txType)\n external\n view\n returns (BroadcastTxSummary memory);\n\n /// Returns all broadcasts for the given contract on `chainId` with the specified `txType`.\n /// Sorted such that the most recent broadcast is the first element, and the oldest is the last. i.e descending order of BroadcastTxSummary.blockNumber.\n function getBroadcasts(string calldata contractName, uint64 chainId, BroadcastTxType txType)\n external\n view\n returns (BroadcastTxSummary[] memory);\n\n /// Returns all broadcasts for the given contract on `chainId`.\n /// Sorted such that the most recent broadcast is the first element, and the oldest is the last. i.e descending order of BroadcastTxSummary.blockNumber.\n function getBroadcasts(string calldata contractName, uint64 chainId)\n external\n view\n returns (BroadcastTxSummary[] memory);\n\n /// Gets the creation bytecode from an artifact file. Takes in the relative path to the json file or the path to the\n /// artifact in the form of :: where and parts are optional.\n function getCode(string calldata artifactPath) external view returns (bytes memory creationBytecode);\n\n /// Gets the deployed bytecode from an artifact file. Takes in the relative path to the json file or the path to the\n /// artifact in the form of :: where and parts are optional.\n function getDeployedCode(string calldata artifactPath) external view returns (bytes memory runtimeBytecode);\n\n /// Returns the most recent deployment for the current `chainId`.\n function getDeployment(string calldata contractName) external view returns (address deployedAddress);\n\n /// Returns the most recent deployment for the given contract on `chainId`\n function getDeployment(string calldata contractName, uint64 chainId)\n external\n view\n returns (address deployedAddress);\n\n /// Returns all deployments for the given contract on `chainId`\n /// Sorted in descending order of deployment time i.e descending order of BroadcastTxSummary.blockNumber.\n /// The most recent deployment is the first element, and the oldest is the last.\n function getDeployments(string calldata contractName, uint64 chainId)\n external\n view\n returns (address[] memory deployedAddresses);\n\n /// Returns true if the path exists on disk and is pointing at a directory, else returns false.\n function isDir(string calldata path) external view returns (bool result);\n\n /// Returns true if the path exists on disk and is pointing at a regular file, else returns false.\n function isFile(string calldata path) external view returns (bool result);\n\n /// Get the path of the current project root.\n function projectRoot() external view returns (string memory path);\n\n /// Prompts the user for a string value in the terminal.\n function prompt(string calldata promptText) external returns (string memory input);\n\n /// Prompts the user for an address in the terminal.\n function promptAddress(string calldata promptText) external returns (address);\n\n /// Prompts the user for a hidden string value in the terminal.\n function promptSecret(string calldata promptText) external returns (string memory input);\n\n /// Prompts the user for hidden uint256 in the terminal (usually pk).\n function promptSecretUint(string calldata promptText) external returns (uint256);\n\n /// Prompts the user for uint256 in the terminal.\n function promptUint(string calldata promptText) external returns (uint256);\n\n /// Reads the directory at the given path recursively, up to `maxDepth`.\n /// `maxDepth` defaults to 1, meaning only the direct children of the given directory will be returned.\n /// Follows symbolic links if `followLinks` is true.\n function readDir(string calldata path) external view returns (DirEntry[] memory entries);\n\n /// See `readDir(string)`.\n function readDir(string calldata path, uint64 maxDepth) external view returns (DirEntry[] memory entries);\n\n /// See `readDir(string)`.\n function readDir(string calldata path, uint64 maxDepth, bool followLinks)\n external\n view\n returns (DirEntry[] memory entries);\n\n /// Reads the entire content of file to string. `path` is relative to the project root.\n function readFile(string calldata path) external view returns (string memory data);\n\n /// Reads the entire content of file as binary. `path` is relative to the project root.\n function readFileBinary(string calldata path) external view returns (bytes memory data);\n\n /// Reads next line of file to string.\n function readLine(string calldata path) external view returns (string memory line);\n\n /// Reads a symbolic link, returning the path that the link points to.\n /// This cheatcode will revert in the following situations, but is not limited to just these cases:\n /// - `path` is not a symbolic link.\n /// - `path` does not exist.\n function readLink(string calldata linkPath) external view returns (string memory targetPath);\n\n /// Removes a directory at the provided path.\n /// This cheatcode will revert in the following situations, but is not limited to just these cases:\n /// - `path` doesn't exist.\n /// - `path` isn't a directory.\n /// - User lacks permissions to modify `path`.\n /// - The directory is not empty and `recursive` is false.\n /// `path` is relative to the project root.\n function removeDir(string calldata path, bool recursive) external;\n\n /// Removes a file from the filesystem.\n /// This cheatcode will revert in the following situations, but is not limited to just these cases:\n /// - `path` points to a directory.\n /// - The file doesn't exist.\n /// - The user lacks permissions to remove the file.\n /// `path` is relative to the project root.\n function removeFile(string calldata path) external;\n\n /// Performs a foreign function call via terminal and returns the exit code, stdout, and stderr.\n function tryFfi(string[] calldata commandInput) external returns (FfiResult memory result);\n\n /// Returns the time since unix epoch in milliseconds.\n function unixTime() external view returns (uint256 milliseconds);\n\n /// Writes data to file, creating a file if it does not exist, and entirely replacing its contents if it does.\n /// `path` is relative to the project root.\n function writeFile(string calldata path, string calldata data) external;\n\n /// Writes binary data to a file, creating a file if it does not exist, and entirely replacing its contents if it does.\n /// `path` is relative to the project root.\n function writeFileBinary(string calldata path, bytes calldata data) external;\n\n /// Writes line to file, creating a file if it does not exist.\n /// `path` is relative to the project root.\n function writeLine(string calldata path, string calldata data) external;\n\n // ======== JSON ========\n\n /// Checks if `key` exists in a JSON object.\n function keyExistsJson(string calldata json, string calldata key) external view returns (bool);\n\n /// Parses a string of JSON data at `key` and coerces it to `address`.\n function parseJsonAddress(string calldata json, string calldata key) external pure returns (address);\n\n /// Parses a string of JSON data at `key` and coerces it to `address[]`.\n function parseJsonAddressArray(string calldata json, string calldata key)\n external\n pure\n returns (address[] memory);\n\n /// Parses a string of JSON data at `key` and coerces it to `bool`.\n function parseJsonBool(string calldata json, string calldata key) external pure returns (bool);\n\n /// Parses a string of JSON data at `key` and coerces it to `bool[]`.\n function parseJsonBoolArray(string calldata json, string calldata key) external pure returns (bool[] memory);\n\n /// Parses a string of JSON data at `key` and coerces it to `bytes`.\n function parseJsonBytes(string calldata json, string calldata key) external pure returns (bytes memory);\n\n /// Parses a string of JSON data at `key` and coerces it to `bytes32`.\n function parseJsonBytes32(string calldata json, string calldata key) external pure returns (bytes32);\n\n /// Parses a string of JSON data at `key` and coerces it to `bytes32[]`.\n function parseJsonBytes32Array(string calldata json, string calldata key)\n external\n pure\n returns (bytes32[] memory);\n\n /// Parses a string of JSON data at `key` and coerces it to `bytes[]`.\n function parseJsonBytesArray(string calldata json, string calldata key) external pure returns (bytes[] memory);\n\n /// Parses a string of JSON data at `key` and coerces it to `int256`.\n function parseJsonInt(string calldata json, string calldata key) external pure returns (int256);\n\n /// Parses a string of JSON data at `key` and coerces it to `int256[]`.\n function parseJsonIntArray(string calldata json, string calldata key) external pure returns (int256[] memory);\n\n /// Returns an array of all the keys in a JSON object.\n function parseJsonKeys(string calldata json, string calldata key) external pure returns (string[] memory keys);\n\n /// Parses a string of JSON data at `key` and coerces it to `string`.\n function parseJsonString(string calldata json, string calldata key) external pure returns (string memory);\n\n /// Parses a string of JSON data at `key` and coerces it to `string[]`.\n function parseJsonStringArray(string calldata json, string calldata key) external pure returns (string[] memory);\n\n /// Parses a string of JSON data at `key` and coerces it to type array corresponding to `typeDescription`.\n function parseJsonTypeArray(string calldata json, string calldata key, string calldata typeDescription)\n external\n pure\n returns (bytes memory);\n\n /// Parses a string of JSON data and coerces it to type corresponding to `typeDescription`.\n function parseJsonType(string calldata json, string calldata typeDescription)\n external\n pure\n returns (bytes memory);\n\n /// Parses a string of JSON data at `key` and coerces it to type corresponding to `typeDescription`.\n function parseJsonType(string calldata json, string calldata key, string calldata typeDescription)\n external\n pure\n returns (bytes memory);\n\n /// Parses a string of JSON data at `key` and coerces it to `uint256`.\n function parseJsonUint(string calldata json, string calldata key) external pure returns (uint256);\n\n /// Parses a string of JSON data at `key` and coerces it to `uint256[]`.\n function parseJsonUintArray(string calldata json, string calldata key) external pure returns (uint256[] memory);\n\n /// ABI-encodes a JSON object.\n function parseJson(string calldata json) external pure returns (bytes memory abiEncodedData);\n\n /// ABI-encodes a JSON object at `key`.\n function parseJson(string calldata json, string calldata key) external pure returns (bytes memory abiEncodedData);\n\n /// See `serializeJson`.\n function serializeAddress(string calldata objectKey, string calldata valueKey, address value)\n external\n returns (string memory json);\n\n /// See `serializeJson`.\n function serializeAddress(string calldata objectKey, string calldata valueKey, address[] calldata values)\n external\n returns (string memory json);\n\n /// See `serializeJson`.\n function serializeBool(string calldata objectKey, string calldata valueKey, bool value)\n external\n returns (string memory json);\n\n /// See `serializeJson`.\n function serializeBool(string calldata objectKey, string calldata valueKey, bool[] calldata values)\n external\n returns (string memory json);\n\n /// See `serializeJson`.\n function serializeBytes32(string calldata objectKey, string calldata valueKey, bytes32 value)\n external\n returns (string memory json);\n\n /// See `serializeJson`.\n function serializeBytes32(string calldata objectKey, string calldata valueKey, bytes32[] calldata values)\n external\n returns (string memory json);\n\n /// See `serializeJson`.\n function serializeBytes(string calldata objectKey, string calldata valueKey, bytes calldata value)\n external\n returns (string memory json);\n\n /// See `serializeJson`.\n function serializeBytes(string calldata objectKey, string calldata valueKey, bytes[] calldata values)\n external\n returns (string memory json);\n\n /// See `serializeJson`.\n function serializeInt(string calldata objectKey, string calldata valueKey, int256 value)\n external\n returns (string memory json);\n\n /// See `serializeJson`.\n function serializeInt(string calldata objectKey, string calldata valueKey, int256[] calldata values)\n external\n returns (string memory json);\n\n /// Serializes a key and value to a JSON object stored in-memory that can be later written to a file.\n /// Returns the stringified version of the specific JSON file up to that moment.\n function serializeJson(string calldata objectKey, string calldata value) external returns (string memory json);\n\n /// See `serializeJson`.\n function serializeJsonType(string calldata typeDescription, bytes calldata value)\n external\n pure\n returns (string memory json);\n\n /// See `serializeJson`.\n function serializeJsonType(\n string calldata objectKey,\n string calldata valueKey,\n string calldata typeDescription,\n bytes calldata value\n ) external returns (string memory json);\n\n /// See `serializeJson`.\n function serializeString(string calldata objectKey, string calldata valueKey, string calldata value)\n external\n returns (string memory json);\n\n /// See `serializeJson`.\n function serializeString(string calldata objectKey, string calldata valueKey, string[] calldata values)\n external\n returns (string memory json);\n\n /// See `serializeJson`.\n function serializeUintToHex(string calldata objectKey, string calldata valueKey, uint256 value)\n external\n returns (string memory json);\n\n /// See `serializeJson`.\n function serializeUint(string calldata objectKey, string calldata valueKey, uint256 value)\n external\n returns (string memory json);\n\n /// See `serializeJson`.\n function serializeUint(string calldata objectKey, string calldata valueKey, uint256[] calldata values)\n external\n returns (string memory json);\n\n /// Write a serialized JSON object to a file. If the file exists, it will be overwritten.\n function writeJson(string calldata json, string calldata path) external;\n\n /// Write a serialized JSON object to an **existing** JSON file, replacing a value with key = \n /// This is useful to replace a specific value of a JSON file, without having to parse the entire thing.\n function writeJson(string calldata json, string calldata path, string calldata valueKey) external;\n\n /// Checks if `key` exists in a JSON object\n /// `keyExists` is being deprecated in favor of `keyExistsJson`. It will be removed in future versions.\n function keyExists(string calldata json, string calldata key) external view returns (bool);\n\n // ======== Scripting ========\n\n /// Designate the next call as an EIP-7702 transaction\n function attachDelegation(SignedDelegation calldata signedDelegation) external;\n\n /// Takes a signed transaction and broadcasts it to the network.\n function broadcastRawTransaction(bytes calldata data) external;\n\n /// Has the next call (at this call depth only) create transactions that can later be signed and sent onchain.\n /// Broadcasting address is determined by checking the following in order:\n /// 1. If `--sender` argument was provided, that address is used.\n /// 2. If exactly one signer (e.g. private key, hw wallet, keystore) is set when `forge broadcast` is invoked, that signer is used.\n /// 3. Otherwise, default foundry sender (1804c8AB1F12E6bbf3894d4083f33e07309d1f38) is used.\n function broadcast() external;\n\n /// Has the next call (at this call depth only) create a transaction with the address provided\n /// as the sender that can later be signed and sent onchain.\n function broadcast(address signer) external;\n\n /// Has the next call (at this call depth only) create a transaction with the private key\n /// provided as the sender that can later be signed and sent onchain.\n function broadcast(uint256 privateKey) external;\n\n /// Returns addresses of available unlocked wallets in the script environment.\n function getWallets() external returns (address[] memory wallets);\n\n /// Sign an EIP-7702 authorization and designate the next call as an EIP-7702 transaction\n function signAndAttachDelegation(address implementation, uint256 privateKey)\n external\n returns (SignedDelegation memory signedDelegation);\n\n /// Sign an EIP-7702 authorization for delegation\n function signDelegation(address implementation, uint256 privateKey)\n external\n returns (SignedDelegation memory signedDelegation);\n\n /// Has all subsequent calls (at this call depth only) create transactions that can later be signed and sent onchain.\n /// Broadcasting address is determined by checking the following in order:\n /// 1. If `--sender` argument was provided, that address is used.\n /// 2. If exactly one signer (e.g. private key, hw wallet, keystore) is set when `forge broadcast` is invoked, that signer is used.\n /// 3. Otherwise, default foundry sender (1804c8AB1F12E6bbf3894d4083f33e07309d1f38) is used.\n function startBroadcast() external;\n\n /// Has all subsequent calls (at this call depth only) create transactions with the address\n /// provided that can later be signed and sent onchain.\n function startBroadcast(address signer) external;\n\n /// Has all subsequent calls (at this call depth only) create transactions with the private key\n /// provided that can later be signed and sent onchain.\n function startBroadcast(uint256 privateKey) external;\n\n /// Stops collecting onchain transactions.\n function stopBroadcast() external;\n\n // ======== String ========\n\n /// Returns true if `search` is found in `subject`, false otherwise.\n function contains(string calldata subject, string calldata search) external returns (bool result);\n\n /// Returns the index of the first occurrence of a `key` in an `input` string.\n /// Returns `NOT_FOUND` (i.e. `type(uint256).max`) if the `key` is not found.\n /// Returns 0 in case of an empty `key`.\n function indexOf(string calldata input, string calldata key) external pure returns (uint256);\n\n /// Parses the given `string` into an `address`.\n function parseAddress(string calldata stringifiedValue) external pure returns (address parsedValue);\n\n /// Parses the given `string` into a `bool`.\n function parseBool(string calldata stringifiedValue) external pure returns (bool parsedValue);\n\n /// Parses the given `string` into `bytes`.\n function parseBytes(string calldata stringifiedValue) external pure returns (bytes memory parsedValue);\n\n /// Parses the given `string` into a `bytes32`.\n function parseBytes32(string calldata stringifiedValue) external pure returns (bytes32 parsedValue);\n\n /// Parses the given `string` into a `int256`.\n function parseInt(string calldata stringifiedValue) external pure returns (int256 parsedValue);\n\n /// Parses the given `string` into a `uint256`.\n function parseUint(string calldata stringifiedValue) external pure returns (uint256 parsedValue);\n\n /// Replaces occurrences of `from` in the given `string` with `to`.\n function replace(string calldata input, string calldata from, string calldata to)\n external\n pure\n returns (string memory output);\n\n /// Splits the given `string` into an array of strings divided by the `delimiter`.\n function split(string calldata input, string calldata delimiter) external pure returns (string[] memory outputs);\n\n /// Converts the given `string` value to Lowercase.\n function toLowercase(string calldata input) external pure returns (string memory output);\n\n /// Converts the given value to a `string`.\n function toString(address value) external pure returns (string memory stringifiedValue);\n\n /// Converts the given value to a `string`.\n function toString(bytes calldata value) external pure returns (string memory stringifiedValue);\n\n /// Converts the given value to a `string`.\n function toString(bytes32 value) external pure returns (string memory stringifiedValue);\n\n /// Converts the given value to a `string`.\n function toString(bool value) external pure returns (string memory stringifiedValue);\n\n /// Converts the given value to a `string`.\n function toString(uint256 value) external pure returns (string memory stringifiedValue);\n\n /// Converts the given value to a `string`.\n function toString(int256 value) external pure returns (string memory stringifiedValue);\n\n /// Converts the given `string` value to Uppercase.\n function toUppercase(string calldata input) external pure returns (string memory output);\n\n /// Trims leading and trailing whitespace from the given `string` value.\n function trim(string calldata input) external pure returns (string memory output);\n\n // ======== Testing ========\n\n /// Compares two `uint256` values. Expects difference to be less than or equal to `maxDelta`.\n /// Formats values with decimals in failure message.\n function assertApproxEqAbsDecimal(uint256 left, uint256 right, uint256 maxDelta, uint256 decimals) external pure;\n\n /// Compares two `uint256` values. Expects difference to be less than or equal to `maxDelta`.\n /// Formats values with decimals in failure message. Includes error message into revert string on failure.\n function assertApproxEqAbsDecimal(\n uint256 left,\n uint256 right,\n uint256 maxDelta,\n uint256 decimals,\n string calldata error\n ) external pure;\n\n /// Compares two `int256` values. Expects difference to be less than or equal to `maxDelta`.\n /// Formats values with decimals in failure message.\n function assertApproxEqAbsDecimal(int256 left, int256 right, uint256 maxDelta, uint256 decimals) external pure;\n\n /// Compares two `int256` values. Expects difference to be less than or equal to `maxDelta`.\n /// Formats values with decimals in failure message. Includes error message into revert string on failure.\n function assertApproxEqAbsDecimal(\n int256 left,\n int256 right,\n uint256 maxDelta,\n uint256 decimals,\n string calldata error\n ) external pure;\n\n /// Compares two `uint256` values. Expects difference to be less than or equal to `maxDelta`.\n function assertApproxEqAbs(uint256 left, uint256 right, uint256 maxDelta) external pure;\n\n /// Compares two `uint256` values. Expects difference to be less than or equal to `maxDelta`.\n /// Includes error message into revert string on failure.\n function assertApproxEqAbs(uint256 left, uint256 right, uint256 maxDelta, string calldata error) external pure;\n\n /// Compares two `int256` values. Expects difference to be less than or equal to `maxDelta`.\n function assertApproxEqAbs(int256 left, int256 right, uint256 maxDelta) external pure;\n\n /// Compares two `int256` values. Expects difference to be less than or equal to `maxDelta`.\n /// Includes error message into revert string on failure.\n function assertApproxEqAbs(int256 left, int256 right, uint256 maxDelta, string calldata error) external pure;\n\n /// Compares two `uint256` values. Expects relative difference in percents to be less than or equal to `maxPercentDelta`.\n /// `maxPercentDelta` is an 18 decimal fixed point number, where 1e18 == 100%\n /// Formats values with decimals in failure message.\n function assertApproxEqRelDecimal(uint256 left, uint256 right, uint256 maxPercentDelta, uint256 decimals)\n external\n pure;\n\n /// Compares two `uint256` values. Expects relative difference in percents to be less than or equal to `maxPercentDelta`.\n /// `maxPercentDelta` is an 18 decimal fixed point number, where 1e18 == 100%\n /// Formats values with decimals in failure message. Includes error message into revert string on failure.\n function assertApproxEqRelDecimal(\n uint256 left,\n uint256 right,\n uint256 maxPercentDelta,\n uint256 decimals,\n string calldata error\n ) external pure;\n\n /// Compares two `int256` values. Expects relative difference in percents to be less than or equal to `maxPercentDelta`.\n /// `maxPercentDelta` is an 18 decimal fixed point number, where 1e18 == 100%\n /// Formats values with decimals in failure message.\n function assertApproxEqRelDecimal(int256 left, int256 right, uint256 maxPercentDelta, uint256 decimals)\n external\n pure;\n\n /// Compares two `int256` values. Expects relative difference in percents to be less than or equal to `maxPercentDelta`.\n /// `maxPercentDelta` is an 18 decimal fixed point number, where 1e18 == 100%\n /// Formats values with decimals in failure message. Includes error message into revert string on failure.\n function assertApproxEqRelDecimal(\n int256 left,\n int256 right,\n uint256 maxPercentDelta,\n uint256 decimals,\n string calldata error\n ) external pure;\n\n /// Compares two `uint256` values. Expects relative difference in percents to be less than or equal to `maxPercentDelta`.\n /// `maxPercentDelta` is an 18 decimal fixed point number, where 1e18 == 100%\n function assertApproxEqRel(uint256 left, uint256 right, uint256 maxPercentDelta) external pure;\n\n /// Compares two `uint256` values. Expects relative difference in percents to be less than or equal to `maxPercentDelta`.\n /// `maxPercentDelta` is an 18 decimal fixed point number, where 1e18 == 100%\n /// Includes error message into revert string on failure.\n function assertApproxEqRel(uint256 left, uint256 right, uint256 maxPercentDelta, string calldata error)\n external\n pure;\n\n /// Compares two `int256` values. Expects relative difference in percents to be less than or equal to `maxPercentDelta`.\n /// `maxPercentDelta` is an 18 decimal fixed point number, where 1e18 == 100%\n function assertApproxEqRel(int256 left, int256 right, uint256 maxPercentDelta) external pure;\n\n /// Compares two `int256` values. Expects relative difference in percents to be less than or equal to `maxPercentDelta`.\n /// `maxPercentDelta` is an 18 decimal fixed point number, where 1e18 == 100%\n /// Includes error message into revert string on failure.\n function assertApproxEqRel(int256 left, int256 right, uint256 maxPercentDelta, string calldata error)\n external\n pure;\n\n /// Asserts that two `uint256` values are equal, formatting them with decimals in failure message.\n function assertEqDecimal(uint256 left, uint256 right, uint256 decimals) external pure;\n\n /// Asserts that two `uint256` values are equal, formatting them with decimals in failure message.\n /// Includes error message into revert string on failure.\n function assertEqDecimal(uint256 left, uint256 right, uint256 decimals, string calldata error) external pure;\n\n /// Asserts that two `int256` values are equal, formatting them with decimals in failure message.\n function assertEqDecimal(int256 left, int256 right, uint256 decimals) external pure;\n\n /// Asserts that two `int256` values are equal, formatting them with decimals in failure message.\n /// Includes error message into revert string on failure.\n function assertEqDecimal(int256 left, int256 right, uint256 decimals, string calldata error) external pure;\n\n /// Asserts that two `bool` values are equal.\n function assertEq(bool left, bool right) external pure;\n\n /// Asserts that two `bool` values are equal and includes error message into revert string on failure.\n function assertEq(bool left, bool right, string calldata error) external pure;\n\n /// Asserts that two `string` values are equal.\n function assertEq(string calldata left, string calldata right) external pure;\n\n /// Asserts that two `string` values are equal and includes error message into revert string on failure.\n function assertEq(string calldata left, string calldata right, string calldata error) external pure;\n\n /// Asserts that two `bytes` values are equal.\n function assertEq(bytes calldata left, bytes calldata right) external pure;\n\n /// Asserts that two `bytes` values are equal and includes error message into revert string on failure.\n function assertEq(bytes calldata left, bytes calldata right, string calldata error) external pure;\n\n /// Asserts that two arrays of `bool` values are equal.\n function assertEq(bool[] calldata left, bool[] calldata right) external pure;\n\n /// Asserts that two arrays of `bool` values are equal and includes error message into revert string on failure.\n function assertEq(bool[] calldata left, bool[] calldata right, string calldata error) external pure;\n\n /// Asserts that two arrays of `uint256 values are equal.\n function assertEq(uint256[] calldata left, uint256[] calldata right) external pure;\n\n /// Asserts that two arrays of `uint256` values are equal and includes error message into revert string on failure.\n function assertEq(uint256[] calldata left, uint256[] calldata right, string calldata error) external pure;\n\n /// Asserts that two arrays of `int256` values are equal.\n function assertEq(int256[] calldata left, int256[] calldata right) external pure;\n\n /// Asserts that two arrays of `int256` values are equal and includes error message into revert string on failure.\n function assertEq(int256[] calldata left, int256[] calldata right, string calldata error) external pure;\n\n /// Asserts that two `uint256` values are equal.\n function assertEq(uint256 left, uint256 right) external pure;\n\n /// Asserts that two arrays of `address` values are equal.\n function assertEq(address[] calldata left, address[] calldata right) external pure;\n\n /// Asserts that two arrays of `address` values are equal and includes error message into revert string on failure.\n function assertEq(address[] calldata left, address[] calldata right, string calldata error) external pure;\n\n /// Asserts that two arrays of `bytes32` values are equal.\n function assertEq(bytes32[] calldata left, bytes32[] calldata right) external pure;\n\n /// Asserts that two arrays of `bytes32` values are equal and includes error message into revert string on failure.\n function assertEq(bytes32[] calldata left, bytes32[] calldata right, string calldata error) external pure;\n\n /// Asserts that two arrays of `string` values are equal.\n function assertEq(string[] calldata left, string[] calldata right) external pure;\n\n /// Asserts that two arrays of `string` values are equal and includes error message into revert string on failure.\n function assertEq(string[] calldata left, string[] calldata right, string calldata error) external pure;\n\n /// Asserts that two arrays of `bytes` values are equal.\n function assertEq(bytes[] calldata left, bytes[] calldata right) external pure;\n\n /// Asserts that two arrays of `bytes` values are equal and includes error message into revert string on failure.\n function assertEq(bytes[] calldata left, bytes[] calldata right, string calldata error) external pure;\n\n /// Asserts that two `uint256` values are equal and includes error message into revert string on failure.\n function assertEq(uint256 left, uint256 right, string calldata error) external pure;\n\n /// Asserts that two `int256` values are equal.\n function assertEq(int256 left, int256 right) external pure;\n\n /// Asserts that two `int256` values are equal and includes error message into revert string on failure.\n function assertEq(int256 left, int256 right, string calldata error) external pure;\n\n /// Asserts that two `address` values are equal.\n function assertEq(address left, address right) external pure;\n\n /// Asserts that two `address` values are equal and includes error message into revert string on failure.\n function assertEq(address left, address right, string calldata error) external pure;\n\n /// Asserts that two `bytes32` values are equal.\n function assertEq(bytes32 left, bytes32 right) external pure;\n\n /// Asserts that two `bytes32` values are equal and includes error message into revert string on failure.\n function assertEq(bytes32 left, bytes32 right, string calldata error) external pure;\n\n /// Asserts that the given condition is false.\n function assertFalse(bool condition) external pure;\n\n /// Asserts that the given condition is false and includes error message into revert string on failure.\n function assertFalse(bool condition, string calldata error) external pure;\n\n /// Compares two `uint256` values. Expects first value to be greater than or equal to second.\n /// Formats values with decimals in failure message.\n function assertGeDecimal(uint256 left, uint256 right, uint256 decimals) external pure;\n\n /// Compares two `uint256` values. Expects first value to be greater than or equal to second.\n /// Formats values with decimals in failure message. Includes error message into revert string on failure.\n function assertGeDecimal(uint256 left, uint256 right, uint256 decimals, string calldata error) external pure;\n\n /// Compares two `int256` values. Expects first value to be greater than or equal to second.\n /// Formats values with decimals in failure message.\n function assertGeDecimal(int256 left, int256 right, uint256 decimals) external pure;\n\n /// Compares two `int256` values. Expects first value to be greater than or equal to second.\n /// Formats values with decimals in failure message. Includes error message into revert string on failure.\n function assertGeDecimal(int256 left, int256 right, uint256 decimals, string calldata error) external pure;\n\n /// Compares two `uint256` values. Expects first value to be greater than or equal to second.\n function assertGe(uint256 left, uint256 right) external pure;\n\n /// Compares two `uint256` values. Expects first value to be greater than or equal to second.\n /// Includes error message into revert string on failure.\n function assertGe(uint256 left, uint256 right, string calldata error) external pure;\n\n /// Compares two `int256` values. Expects first value to be greater than or equal to second.\n function assertGe(int256 left, int256 right) external pure;\n\n /// Compares two `int256` values. Expects first value to be greater than or equal to second.\n /// Includes error message into revert string on failure.\n function assertGe(int256 left, int256 right, string calldata error) external pure;\n\n /// Compares two `uint256` values. Expects first value to be greater than second.\n /// Formats values with decimals in failure message.\n function assertGtDecimal(uint256 left, uint256 right, uint256 decimals) external pure;\n\n /// Compares two `uint256` values. Expects first value to be greater than second.\n /// Formats values with decimals in failure message. Includes error message into revert string on failure.\n function assertGtDecimal(uint256 left, uint256 right, uint256 decimals, string calldata error) external pure;\n\n /// Compares two `int256` values. Expects first value to be greater than second.\n /// Formats values with decimals in failure message.\n function assertGtDecimal(int256 left, int256 right, uint256 decimals) external pure;\n\n /// Compares two `int256` values. Expects first value to be greater than second.\n /// Formats values with decimals in failure message. Includes error message into revert string on failure.\n function assertGtDecimal(int256 left, int256 right, uint256 decimals, string calldata error) external pure;\n\n /// Compares two `uint256` values. Expects first value to be greater than second.\n function assertGt(uint256 left, uint256 right) external pure;\n\n /// Compares two `uint256` values. Expects first value to be greater than second.\n /// Includes error message into revert string on failure.\n function assertGt(uint256 left, uint256 right, string calldata error) external pure;\n\n /// Compares two `int256` values. Expects first value to be greater than second.\n function assertGt(int256 left, int256 right) external pure;\n\n /// Compares two `int256` values. Expects first value to be greater than second.\n /// Includes error message into revert string on failure.\n function assertGt(int256 left, int256 right, string calldata error) external pure;\n\n /// Compares two `uint256` values. Expects first value to be less than or equal to second.\n /// Formats values with decimals in failure message.\n function assertLeDecimal(uint256 left, uint256 right, uint256 decimals) external pure;\n\n /// Compares two `uint256` values. Expects first value to be less than or equal to second.\n /// Formats values with decimals in failure message. Includes error message into revert string on failure.\n function assertLeDecimal(uint256 left, uint256 right, uint256 decimals, string calldata error) external pure;\n\n /// Compares two `int256` values. Expects first value to be less than or equal to second.\n /// Formats values with decimals in failure message.\n function assertLeDecimal(int256 left, int256 right, uint256 decimals) external pure;\n\n /// Compares two `int256` values. Expects first value to be less than or equal to second.\n /// Formats values with decimals in failure message. Includes error message into revert string on failure.\n function assertLeDecimal(int256 left, int256 right, uint256 decimals, string calldata error) external pure;\n\n /// Compares two `uint256` values. Expects first value to be less than or equal to second.\n function assertLe(uint256 left, uint256 right) external pure;\n\n /// Compares two `uint256` values. Expects first value to be less than or equal to second.\n /// Includes error message into revert string on failure.\n function assertLe(uint256 left, uint256 right, string calldata error) external pure;\n\n /// Compares two `int256` values. Expects first value to be less than or equal to second.\n function assertLe(int256 left, int256 right) external pure;\n\n /// Compares two `int256` values. Expects first value to be less than or equal to second.\n /// Includes error message into revert string on failure.\n function assertLe(int256 left, int256 right, string calldata error) external pure;\n\n /// Compares two `uint256` values. Expects first value to be less than second.\n /// Formats values with decimals in failure message.\n function assertLtDecimal(uint256 left, uint256 right, uint256 decimals) external pure;\n\n /// Compares two `uint256` values. Expects first value to be less than second.\n /// Formats values with decimals in failure message. Includes error message into revert string on failure.\n function assertLtDecimal(uint256 left, uint256 right, uint256 decimals, string calldata error) external pure;\n\n /// Compares two `int256` values. Expects first value to be less than second.\n /// Formats values with decimals in failure message.\n function assertLtDecimal(int256 left, int256 right, uint256 decimals) external pure;\n\n /// Compares two `int256` values. Expects first value to be less than second.\n /// Formats values with decimals in failure message. Includes error message into revert string on failure.\n function assertLtDecimal(int256 left, int256 right, uint256 decimals, string calldata error) external pure;\n\n /// Compares two `uint256` values. Expects first value to be less than second.\n function assertLt(uint256 left, uint256 right) external pure;\n\n /// Compares two `uint256` values. Expects first value to be less than second.\n /// Includes error message into revert string on failure.\n function assertLt(uint256 left, uint256 right, string calldata error) external pure;\n\n /// Compares two `int256` values. Expects first value to be less than second.\n function assertLt(int256 left, int256 right) external pure;\n\n /// Compares two `int256` values. Expects first value to be less than second.\n /// Includes error message into revert string on failure.\n function assertLt(int256 left, int256 right, string calldata error) external pure;\n\n /// Asserts that two `uint256` values are not equal, formatting them with decimals in failure message.\n function assertNotEqDecimal(uint256 left, uint256 right, uint256 decimals) external pure;\n\n /// Asserts that two `uint256` values are not equal, formatting them with decimals in failure message.\n /// Includes error message into revert string on failure.\n function assertNotEqDecimal(uint256 left, uint256 right, uint256 decimals, string calldata error) external pure;\n\n /// Asserts that two `int256` values are not equal, formatting them with decimals in failure message.\n function assertNotEqDecimal(int256 left, int256 right, uint256 decimals) external pure;\n\n /// Asserts that two `int256` values are not equal, formatting them with decimals in failure message.\n /// Includes error message into revert string on failure.\n function assertNotEqDecimal(int256 left, int256 right, uint256 decimals, string calldata error) external pure;\n\n /// Asserts that two `bool` values are not equal.\n function assertNotEq(bool left, bool right) external pure;\n\n /// Asserts that two `bool` values are not equal and includes error message into revert string on failure.\n function assertNotEq(bool left, bool right, string calldata error) external pure;\n\n /// Asserts that two `string` values are not equal.\n function assertNotEq(string calldata left, string calldata right) external pure;\n\n /// Asserts that two `string` values are not equal and includes error message into revert string on failure.\n function assertNotEq(string calldata left, string calldata right, string calldata error) external pure;\n\n /// Asserts that two `bytes` values are not equal.\n function assertNotEq(bytes calldata left, bytes calldata right) external pure;\n\n /// Asserts that two `bytes` values are not equal and includes error message into revert string on failure.\n function assertNotEq(bytes calldata left, bytes calldata right, string calldata error) external pure;\n\n /// Asserts that two arrays of `bool` values are not equal.\n function assertNotEq(bool[] calldata left, bool[] calldata right) external pure;\n\n /// Asserts that two arrays of `bool` values are not equal and includes error message into revert string on failure.\n function assertNotEq(bool[] calldata left, bool[] calldata right, string calldata error) external pure;\n\n /// Asserts that two arrays of `uint256` values are not equal.\n function assertNotEq(uint256[] calldata left, uint256[] calldata right) external pure;\n\n /// Asserts that two arrays of `uint256` values are not equal and includes error message into revert string on failure.\n function assertNotEq(uint256[] calldata left, uint256[] calldata right, string calldata error) external pure;\n\n /// Asserts that two arrays of `int256` values are not equal.\n function assertNotEq(int256[] calldata left, int256[] calldata right) external pure;\n\n /// Asserts that two arrays of `int256` values are not equal and includes error message into revert string on failure.\n function assertNotEq(int256[] calldata left, int256[] calldata right, string calldata error) external pure;\n\n /// Asserts that two `uint256` values are not equal.\n function assertNotEq(uint256 left, uint256 right) external pure;\n\n /// Asserts that two arrays of `address` values are not equal.\n function assertNotEq(address[] calldata left, address[] calldata right) external pure;\n\n /// Asserts that two arrays of `address` values are not equal and includes error message into revert string on failure.\n function assertNotEq(address[] calldata left, address[] calldata right, string calldata error) external pure;\n\n /// Asserts that two arrays of `bytes32` values are not equal.\n function assertNotEq(bytes32[] calldata left, bytes32[] calldata right) external pure;\n\n /// Asserts that two arrays of `bytes32` values are not equal and includes error message into revert string on failure.\n function assertNotEq(bytes32[] calldata left, bytes32[] calldata right, string calldata error) external pure;\n\n /// Asserts that two arrays of `string` values are not equal.\n function assertNotEq(string[] calldata left, string[] calldata right) external pure;\n\n /// Asserts that two arrays of `string` values are not equal and includes error message into revert string on failure.\n function assertNotEq(string[] calldata left, string[] calldata right, string calldata error) external pure;\n\n /// Asserts that two arrays of `bytes` values are not equal.\n function assertNotEq(bytes[] calldata left, bytes[] calldata right) external pure;\n\n /// Asserts that two arrays of `bytes` values are not equal and includes error message into revert string on failure.\n function assertNotEq(bytes[] calldata left, bytes[] calldata right, string calldata error) external pure;\n\n /// Asserts that two `uint256` values are not equal and includes error message into revert string on failure.\n function assertNotEq(uint256 left, uint256 right, string calldata error) external pure;\n\n /// Asserts that two `int256` values are not equal.\n function assertNotEq(int256 left, int256 right) external pure;\n\n /// Asserts that two `int256` values are not equal and includes error message into revert string on failure.\n function assertNotEq(int256 left, int256 right, string calldata error) external pure;\n\n /// Asserts that two `address` values are not equal.\n function assertNotEq(address left, address right) external pure;\n\n /// Asserts that two `address` values are not equal and includes error message into revert string on failure.\n function assertNotEq(address left, address right, string calldata error) external pure;\n\n /// Asserts that two `bytes32` values are not equal.\n function assertNotEq(bytes32 left, bytes32 right) external pure;\n\n /// Asserts that two `bytes32` values are not equal and includes error message into revert string on failure.\n function assertNotEq(bytes32 left, bytes32 right, string calldata error) external pure;\n\n /// Asserts that the given condition is true.\n function assertTrue(bool condition) external pure;\n\n /// Asserts that the given condition is true and includes error message into revert string on failure.\n function assertTrue(bool condition, string calldata error) external pure;\n\n /// If the condition is false, discard this run's fuzz inputs and generate new ones.\n function assume(bool condition) external pure;\n\n /// Discard this run's fuzz inputs and generate new ones if next call reverted.\n function assumeNoRevert() external pure;\n\n /// Discard this run's fuzz inputs and generate new ones if next call reverts with the potential revert parameters.\n function assumeNoRevert(PotentialRevert calldata potentialRevert) external pure;\n\n /// Discard this run's fuzz inputs and generate new ones if next call reverts with the any of the potential revert parameters.\n function assumeNoRevert(PotentialRevert[] calldata potentialReverts) external pure;\n\n /// Writes a breakpoint to jump to in the debugger.\n function breakpoint(string calldata char) external pure;\n\n /// Writes a conditional breakpoint to jump to in the debugger.\n function breakpoint(string calldata char, bool value) external pure;\n\n /// Returns true if the current Foundry version is greater than or equal to the given version.\n /// The given version string must be in the format `major.minor.patch`.\n /// This is equivalent to `foundryVersionCmp(version) >= 0`.\n function foundryVersionAtLeast(string calldata version) external view returns (bool);\n\n /// Compares the current Foundry version with the given version string.\n /// The given version string must be in the format `major.minor.patch`.\n /// Returns:\n /// -1 if current Foundry version is less than the given version\n /// 0 if current Foundry version equals the given version\n /// 1 if current Foundry version is greater than the given version\n /// This result can then be used with a comparison operator against `0`.\n /// For example, to check if the current Foundry version is greater than or equal to `1.0.0`:\n /// `if (foundryVersionCmp(\"1.0.0\") >= 0) { ... }`\n function foundryVersionCmp(string calldata version) external view returns (int256);\n\n /// Returns the Foundry version.\n /// Format: -+..\n /// Sample output: 0.3.0-nightly+3cb96bde9b.1737036656.debug\n /// Note: Build timestamps may vary slightly across platforms due to separate CI jobs.\n /// For reliable version comparisons, use UNIX format (e.g., >= 1700000000)\n /// to compare timestamps while ignoring minor time differences.\n function getFoundryVersion() external view returns (string memory version);\n\n /// Returns the RPC url for the given alias.\n function rpcUrl(string calldata rpcAlias) external view returns (string memory json);\n\n /// Returns all rpc urls and their aliases as structs.\n function rpcUrlStructs() external view returns (Rpc[] memory urls);\n\n /// Returns all rpc urls and their aliases `[alias, url][]`.\n function rpcUrls() external view returns (string[2][] memory urls);\n\n /// Suspends execution of the main thread for `duration` milliseconds.\n function sleep(uint256 duration) external;\n\n // ======== Toml ========\n\n /// Checks if `key` exists in a TOML table.\n function keyExistsToml(string calldata toml, string calldata key) external view returns (bool);\n\n /// Parses a string of TOML data at `key` and coerces it to `address`.\n function parseTomlAddress(string calldata toml, string calldata key) external pure returns (address);\n\n /// Parses a string of TOML data at `key` and coerces it to `address[]`.\n function parseTomlAddressArray(string calldata toml, string calldata key)\n external\n pure\n returns (address[] memory);\n\n /// Parses a string of TOML data at `key` and coerces it to `bool`.\n function parseTomlBool(string calldata toml, string calldata key) external pure returns (bool);\n\n /// Parses a string of TOML data at `key` and coerces it to `bool[]`.\n function parseTomlBoolArray(string calldata toml, string calldata key) external pure returns (bool[] memory);\n\n /// Parses a string of TOML data at `key` and coerces it to `bytes`.\n function parseTomlBytes(string calldata toml, string calldata key) external pure returns (bytes memory);\n\n /// Parses a string of TOML data at `key` and coerces it to `bytes32`.\n function parseTomlBytes32(string calldata toml, string calldata key) external pure returns (bytes32);\n\n /// Parses a string of TOML data at `key` and coerces it to `bytes32[]`.\n function parseTomlBytes32Array(string calldata toml, string calldata key)\n external\n pure\n returns (bytes32[] memory);\n\n /// Parses a string of TOML data at `key` and coerces it to `bytes[]`.\n function parseTomlBytesArray(string calldata toml, string calldata key) external pure returns (bytes[] memory);\n\n /// Parses a string of TOML data at `key` and coerces it to `int256`.\n function parseTomlInt(string calldata toml, string calldata key) external pure returns (int256);\n\n /// Parses a string of TOML data at `key` and coerces it to `int256[]`.\n function parseTomlIntArray(string calldata toml, string calldata key) external pure returns (int256[] memory);\n\n /// Returns an array of all the keys in a TOML table.\n function parseTomlKeys(string calldata toml, string calldata key) external pure returns (string[] memory keys);\n\n /// Parses a string of TOML data at `key` and coerces it to `string`.\n function parseTomlString(string calldata toml, string calldata key) external pure returns (string memory);\n\n /// Parses a string of TOML data at `key` and coerces it to `string[]`.\n function parseTomlStringArray(string calldata toml, string calldata key) external pure returns (string[] memory);\n\n /// Parses a string of TOML data at `key` and coerces it to type array corresponding to `typeDescription`.\n function parseTomlTypeArray(string calldata toml, string calldata key, string calldata typeDescription)\n external\n pure\n returns (bytes memory);\n\n /// Parses a string of TOML data and coerces it to type corresponding to `typeDescription`.\n function parseTomlType(string calldata toml, string calldata typeDescription)\n external\n pure\n returns (bytes memory);\n\n /// Parses a string of TOML data at `key` and coerces it to type corresponding to `typeDescription`.\n function parseTomlType(string calldata toml, string calldata key, string calldata typeDescription)\n external\n pure\n returns (bytes memory);\n\n /// Parses a string of TOML data at `key` and coerces it to `uint256`.\n function parseTomlUint(string calldata toml, string calldata key) external pure returns (uint256);\n\n /// Parses a string of TOML data at `key` and coerces it to `uint256[]`.\n function parseTomlUintArray(string calldata toml, string calldata key) external pure returns (uint256[] memory);\n\n /// ABI-encodes a TOML table.\n function parseToml(string calldata toml) external pure returns (bytes memory abiEncodedData);\n\n /// ABI-encodes a TOML table at `key`.\n function parseToml(string calldata toml, string calldata key) external pure returns (bytes memory abiEncodedData);\n\n /// Takes serialized JSON, converts to TOML and write a serialized TOML to a file.\n function writeToml(string calldata json, string calldata path) external;\n\n /// Takes serialized JSON, converts to TOML and write a serialized TOML table to an **existing** TOML file, replacing a value with key = \n /// This is useful to replace a specific value of a TOML file, without having to parse the entire thing.\n function writeToml(string calldata json, string calldata path, string calldata valueKey) external;\n\n // ======== Utilities ========\n\n /// Compute the address of a contract created with CREATE2 using the given CREATE2 deployer.\n function computeCreate2Address(bytes32 salt, bytes32 initCodeHash, address deployer)\n external\n pure\n returns (address);\n\n /// Compute the address of a contract created with CREATE2 using the default CREATE2 deployer.\n function computeCreate2Address(bytes32 salt, bytes32 initCodeHash) external pure returns (address);\n\n /// Compute the address a contract will be deployed at for a given deployer address and nonce.\n function computeCreateAddress(address deployer, uint256 nonce) external pure returns (address);\n\n /// Utility cheatcode to copy storage of `from` contract to another `to` contract.\n function copyStorage(address from, address to) external;\n\n /// Returns ENS namehash for provided string.\n function ensNamehash(string calldata name) external pure returns (bytes32);\n\n /// Gets the label for the specified address.\n function getLabel(address account) external view returns (string memory currentLabel);\n\n /// Labels an address in call traces.\n function label(address account, string calldata newLabel) external;\n\n /// Pauses collection of call traces. Useful in cases when you want to skip tracing of\n /// complex calls which are not useful for debugging.\n function pauseTracing() external view;\n\n /// Returns a random `address`.\n function randomAddress() external returns (address);\n\n /// Returns a random `bool`.\n function randomBool() external view returns (bool);\n\n /// Returns a random byte array value of the given length.\n function randomBytes(uint256 len) external view returns (bytes memory);\n\n /// Returns a random fixed-size byte array of length 4.\n function randomBytes4() external view returns (bytes4);\n\n /// Returns a random fixed-size byte array of length 8.\n function randomBytes8() external view returns (bytes8);\n\n /// Returns a random `int256` value.\n function randomInt() external view returns (int256);\n\n /// Returns a random `int256` value of given bits.\n function randomInt(uint256 bits) external view returns (int256);\n\n /// Returns a random uint256 value.\n function randomUint() external returns (uint256);\n\n /// Returns random uint256 value between the provided range (=min..=max).\n function randomUint(uint256 min, uint256 max) external returns (uint256);\n\n /// Returns a random `uint256` value of given bits.\n function randomUint(uint256 bits) external view returns (uint256);\n\n /// Unpauses collection of call traces.\n function resumeTracing() external view;\n\n /// Utility cheatcode to set arbitrary storage for given target address.\n function setArbitraryStorage(address target) external;\n\n /// Encodes a `bytes` value to a base64url string.\n function toBase64URL(bytes calldata data) external pure returns (string memory);\n\n /// Encodes a `string` value to a base64url string.\n function toBase64URL(string calldata data) external pure returns (string memory);\n\n /// Encodes a `bytes` value to a base64 string.\n function toBase64(bytes calldata data) external pure returns (string memory);\n\n /// Encodes a `string` value to a base64 string.\n function toBase64(string calldata data) external pure returns (string memory);\n}\n\n/// The `Vm` interface does allow manipulation of the EVM state. These are all intended to be used\n/// in tests, but it is not recommended to use these cheats in scripts.\ninterface Vm is VmSafe {\n // ======== EVM ========\n\n /// Utility cheatcode to set an EIP-2930 access list for all subsequent transactions.\n function accessList(AccessListItem[] calldata access) external;\n\n /// Returns the identifier of the currently active fork. Reverts if no fork is currently active.\n function activeFork() external view returns (uint256 forkId);\n\n /// In forking mode, explicitly grant the given address cheatcode access.\n function allowCheatcodes(address account) external;\n\n /// Sets `block.blobbasefee`\n function blobBaseFee(uint256 newBlobBaseFee) external;\n\n /// Sets the blobhashes in the transaction.\n /// Not available on EVM versions before Cancun.\n /// If used on unsupported EVM versions it will revert.\n function blobhashes(bytes32[] calldata hashes) external;\n\n /// Sets `block.chainid`.\n function chainId(uint256 newChainId) external;\n\n /// Clears all mocked calls.\n function clearMockedCalls() external;\n\n /// Clones a source account code, state, balance and nonce to a target account and updates in-memory EVM state.\n function cloneAccount(address source, address target) external;\n\n /// Sets `block.coinbase`.\n function coinbase(address newCoinbase) external;\n\n /// Marks the slots of an account and the account address as cold.\n function cool(address target) external;\n\n /// Utility cheatcode to mark specific storage slot as cold, simulating no prior read.\n function coolSlot(address target, bytes32 slot) external;\n\n /// Creates a new fork with the given endpoint and the _latest_ block and returns the identifier of the fork.\n function createFork(string calldata urlOrAlias) external returns (uint256 forkId);\n\n /// Creates a new fork with the given endpoint and block and returns the identifier of the fork.\n function createFork(string calldata urlOrAlias, uint256 blockNumber) external returns (uint256 forkId);\n\n /// Creates a new fork with the given endpoint and at the block the given transaction was mined in,\n /// replays all transaction mined in the block before the transaction, and returns the identifier of the fork.\n function createFork(string calldata urlOrAlias, bytes32 txHash) external returns (uint256 forkId);\n\n /// Creates and also selects a new fork with the given endpoint and the latest block and returns the identifier of the fork.\n function createSelectFork(string calldata urlOrAlias) external returns (uint256 forkId);\n\n /// Creates and also selects a new fork with the given endpoint and block and returns the identifier of the fork.\n function createSelectFork(string calldata urlOrAlias, uint256 blockNumber) external returns (uint256 forkId);\n\n /// Creates and also selects new fork with the given endpoint and at the block the given transaction was mined in,\n /// replays all transaction mined in the block before the transaction, returns the identifier of the fork.\n function createSelectFork(string calldata urlOrAlias, bytes32 txHash) external returns (uint256 forkId);\n\n /// Sets an address' balance.\n function deal(address account, uint256 newBalance) external;\n\n /// Removes the snapshot with the given ID created by `snapshot`.\n /// Takes the snapshot ID to delete.\n /// Returns `true` if the snapshot was successfully deleted.\n /// Returns `false` if the snapshot does not exist.\n function deleteStateSnapshot(uint256 snapshotId) external returns (bool success);\n\n /// Removes _all_ snapshots previously created by `snapshot`.\n function deleteStateSnapshots() external;\n\n /// Sets `block.difficulty`.\n /// Not available on EVM versions from Paris onwards. Use `prevrandao` instead.\n /// Reverts if used on unsupported EVM versions.\n function difficulty(uint256 newDifficulty) external;\n\n /// Dump a genesis JSON file's `allocs` to disk.\n function dumpState(string calldata pathToStateJson) external;\n\n /// Sets an address' code.\n function etch(address target, bytes calldata newRuntimeBytecode) external;\n\n /// Sets `block.basefee`.\n function fee(uint256 newBasefee) external;\n\n /// Gets the blockhashes from the current transaction.\n /// Not available on EVM versions before Cancun.\n /// If used on unsupported EVM versions it will revert.\n function getBlobhashes() external view returns (bytes32[] memory hashes);\n\n /// Returns true if the account is marked as persistent.\n function isPersistent(address account) external view returns (bool persistent);\n\n /// Load a genesis JSON file's `allocs` into the in-memory EVM state.\n function loadAllocs(string calldata pathToAllocsJson) external;\n\n /// Marks that the account(s) should use persistent storage across fork swaps in a multifork setup\n /// Meaning, changes made to the state of this account will be kept when switching forks.\n function makePersistent(address account) external;\n\n /// See `makePersistent(address)`.\n function makePersistent(address account0, address account1) external;\n\n /// See `makePersistent(address)`.\n function makePersistent(address account0, address account1, address account2) external;\n\n /// See `makePersistent(address)`.\n function makePersistent(address[] calldata accounts) external;\n\n /// Reverts a call to an address with specified revert data.\n function mockCallRevert(address callee, bytes calldata data, bytes calldata revertData) external;\n\n /// Reverts a call to an address with a specific `msg.value`, with specified revert data.\n function mockCallRevert(address callee, uint256 msgValue, bytes calldata data, bytes calldata revertData)\n external;\n\n /// Reverts a call to an address with specified revert data.\n /// Overload to pass the function selector directly `token.approve.selector` instead of `abi.encodeWithSelector(token.approve.selector)`.\n function mockCallRevert(address callee, bytes4 data, bytes calldata revertData) external;\n\n /// Reverts a call to an address with a specific `msg.value`, with specified revert data.\n /// Overload to pass the function selector directly `token.approve.selector` instead of `abi.encodeWithSelector(token.approve.selector)`.\n function mockCallRevert(address callee, uint256 msgValue, bytes4 data, bytes calldata revertData) external;\n\n /// Mocks a call to an address, returning specified data.\n /// Calldata can either be strict or a partial match, e.g. if you only\n /// pass a Solidity selector to the expected calldata, then the entire Solidity\n /// function will be mocked.\n function mockCall(address callee, bytes calldata data, bytes calldata returnData) external;\n\n /// Mocks a call to an address with a specific `msg.value`, returning specified data.\n /// Calldata match takes precedence over `msg.value` in case of ambiguity.\n function mockCall(address callee, uint256 msgValue, bytes calldata data, bytes calldata returnData) external;\n\n /// Mocks a call to an address, returning specified data.\n /// Calldata can either be strict or a partial match, e.g. if you only\n /// pass a Solidity selector to the expected calldata, then the entire Solidity\n /// function will be mocked.\n /// Overload to pass the function selector directly `token.approve.selector` instead of `abi.encodeWithSelector(token.approve.selector)`.\n function mockCall(address callee, bytes4 data, bytes calldata returnData) external;\n\n /// Mocks a call to an address with a specific `msg.value`, returning specified data.\n /// Calldata match takes precedence over `msg.value` in case of ambiguity.\n /// Overload to pass the function selector directly `token.approve.selector` instead of `abi.encodeWithSelector(token.approve.selector)`.\n function mockCall(address callee, uint256 msgValue, bytes4 data, bytes calldata returnData) external;\n\n /// Mocks multiple calls to an address, returning specified data for each call.\n function mockCalls(address callee, bytes calldata data, bytes[] calldata returnData) external;\n\n /// Mocks multiple calls to an address with a specific `msg.value`, returning specified data for each call.\n function mockCalls(address callee, uint256 msgValue, bytes calldata data, bytes[] calldata returnData) external;\n\n /// Whenever a call is made to `callee` with calldata `data`, this cheatcode instead calls\n /// `target` with the same calldata. This functionality is similar to a delegate call made to\n /// `target` contract from `callee`.\n /// Can be used to substitute a call to a function with another implementation that captures\n /// the primary logic of the original function but is easier to reason about.\n /// If calldata is not a strict match then partial match by selector is attempted.\n function mockFunction(address callee, address target, bytes calldata data) external;\n\n /// Utility cheatcode to remove any EIP-2930 access list set by `accessList` cheatcode.\n function noAccessList() external;\n\n /// Sets the *next* call's `msg.sender` to be the input address.\n function prank(address msgSender) external;\n\n /// Sets the *next* call's `msg.sender` to be the input address, and the `tx.origin` to be the second input.\n function prank(address msgSender, address txOrigin) external;\n\n /// Sets the *next* delegate call's `msg.sender` to be the input address.\n function prank(address msgSender, bool delegateCall) external;\n\n /// Sets the *next* delegate call's `msg.sender` to be the input address, and the `tx.origin` to be the second input.\n function prank(address msgSender, address txOrigin, bool delegateCall) external;\n\n /// Sets `block.prevrandao`.\n /// Not available on EVM versions before Paris. Use `difficulty` instead.\n /// If used on unsupported EVM versions it will revert.\n function prevrandao(bytes32 newPrevrandao) external;\n\n /// Sets `block.prevrandao`.\n /// Not available on EVM versions before Paris. Use `difficulty` instead.\n /// If used on unsupported EVM versions it will revert.\n function prevrandao(uint256 newPrevrandao) external;\n\n /// Reads the current `msg.sender` and `tx.origin` from state and reports if there is any active caller modification.\n function readCallers() external returns (CallerMode callerMode, address msgSender, address txOrigin);\n\n /// Resets the nonce of an account to 0 for EOAs and 1 for contract accounts.\n function resetNonce(address account) external;\n\n /// Revert the state of the EVM to a previous snapshot\n /// Takes the snapshot ID to revert to.\n /// Returns `true` if the snapshot was successfully reverted.\n /// Returns `false` if the snapshot does not exist.\n /// **Note:** This does not automatically delete the snapshot. To delete the snapshot use `deleteStateSnapshot`.\n function revertToState(uint256 snapshotId) external returns (bool success);\n\n /// Revert the state of the EVM to a previous snapshot and automatically deletes the snapshots\n /// Takes the snapshot ID to revert to.\n /// Returns `true` if the snapshot was successfully reverted and deleted.\n /// Returns `false` if the snapshot does not exist.\n function revertToStateAndDelete(uint256 snapshotId) external returns (bool success);\n\n /// Revokes persistent status from the address, previously added via `makePersistent`.\n function revokePersistent(address account) external;\n\n /// See `revokePersistent(address)`.\n function revokePersistent(address[] calldata accounts) external;\n\n /// Sets `block.height`.\n function roll(uint256 newHeight) external;\n\n /// Updates the currently active fork to given block number\n /// This is similar to `roll` but for the currently active fork.\n function rollFork(uint256 blockNumber) external;\n\n /// Updates the currently active fork to given transaction. This will `rollFork` with the number\n /// of the block the transaction was mined in and replays all transaction mined before it in the block.\n function rollFork(bytes32 txHash) external;\n\n /// Updates the given fork to given block number.\n function rollFork(uint256 forkId, uint256 blockNumber) external;\n\n /// Updates the given fork to block number of the given transaction and replays all transaction mined before it in the block.\n function rollFork(uint256 forkId, bytes32 txHash) external;\n\n /// Takes a fork identifier created by `createFork` and sets the corresponding forked state as active.\n function selectFork(uint256 forkId) external;\n\n /// Set blockhash for the current block.\n /// It only sets the blockhash for blocks where `block.number - 256 <= number < block.number`.\n function setBlockhash(uint256 blockNumber, bytes32 blockHash) external;\n\n /// Sets the nonce of an account. Must be higher than the current nonce of the account.\n function setNonce(address account, uint64 newNonce) external;\n\n /// Sets the nonce of an account to an arbitrary value.\n function setNonceUnsafe(address account, uint64 newNonce) external;\n\n /// Snapshot capture the gas usage of the last call by name from the callee perspective.\n function snapshotGasLastCall(string calldata name) external returns (uint256 gasUsed);\n\n /// Snapshot capture the gas usage of the last call by name in a group from the callee perspective.\n function snapshotGasLastCall(string calldata group, string calldata name) external returns (uint256 gasUsed);\n\n /// Snapshot the current state of the evm.\n /// Returns the ID of the snapshot that was created.\n /// To revert a snapshot use `revertToState`.\n function snapshotState() external returns (uint256 snapshotId);\n\n /// Snapshot capture an arbitrary numerical value by name.\n /// The group name is derived from the contract name.\n function snapshotValue(string calldata name, uint256 value) external;\n\n /// Snapshot capture an arbitrary numerical value by name in a group.\n function snapshotValue(string calldata group, string calldata name, uint256 value) external;\n\n /// Sets all subsequent calls' `msg.sender` to be the input address until `stopPrank` is called.\n function startPrank(address msgSender) external;\n\n /// Sets all subsequent calls' `msg.sender` to be the input address until `stopPrank` is called, and the `tx.origin` to be the second input.\n function startPrank(address msgSender, address txOrigin) external;\n\n /// Sets all subsequent delegate calls' `msg.sender` to be the input address until `stopPrank` is called.\n function startPrank(address msgSender, bool delegateCall) external;\n\n /// Sets all subsequent delegate calls' `msg.sender` to be the input address until `stopPrank` is called, and the `tx.origin` to be the second input.\n function startPrank(address msgSender, address txOrigin, bool delegateCall) external;\n\n /// Start a snapshot capture of the current gas usage by name.\n /// The group name is derived from the contract name.\n function startSnapshotGas(string calldata name) external;\n\n /// Start a snapshot capture of the current gas usage by name in a group.\n function startSnapshotGas(string calldata group, string calldata name) external;\n\n /// Resets subsequent calls' `msg.sender` to be `address(this)`.\n function stopPrank() external;\n\n /// Stop the snapshot capture of the current gas by latest snapshot name, capturing the gas used since the start.\n function stopSnapshotGas() external returns (uint256 gasUsed);\n\n /// Stop the snapshot capture of the current gas usage by name, capturing the gas used since the start.\n /// The group name is derived from the contract name.\n function stopSnapshotGas(string calldata name) external returns (uint256 gasUsed);\n\n /// Stop the snapshot capture of the current gas usage by name in a group, capturing the gas used since the start.\n function stopSnapshotGas(string calldata group, string calldata name) external returns (uint256 gasUsed);\n\n /// Stores a value to an address' storage slot.\n function store(address target, bytes32 slot, bytes32 value) external;\n\n /// Fetches the given transaction from the active fork and executes it on the current state.\n function transact(bytes32 txHash) external;\n\n /// Fetches the given transaction from the given fork and executes it on the current state.\n function transact(uint256 forkId, bytes32 txHash) external;\n\n /// Sets `tx.gasprice`.\n function txGasPrice(uint256 newGasPrice) external;\n\n /// Utility cheatcode to mark specific storage slot as warm, simulating a prior read.\n function warmSlot(address target, bytes32 slot) external;\n\n /// Sets `block.timestamp`.\n function warp(uint256 newTimestamp) external;\n\n /// `deleteSnapshot` is being deprecated in favor of `deleteStateSnapshot`. It will be removed in future versions.\n function deleteSnapshot(uint256 snapshotId) external returns (bool success);\n\n /// `deleteSnapshots` is being deprecated in favor of `deleteStateSnapshots`. It will be removed in future versions.\n function deleteSnapshots() external;\n\n /// `revertToAndDelete` is being deprecated in favor of `revertToStateAndDelete`. It will be removed in future versions.\n function revertToAndDelete(uint256 snapshotId) external returns (bool success);\n\n /// `revertTo` is being deprecated in favor of `revertToState`. It will be removed in future versions.\n function revertTo(uint256 snapshotId) external returns (bool success);\n\n /// `snapshot` is being deprecated in favor of `snapshotState`. It will be removed in future versions.\n function snapshot() external returns (uint256 snapshotId);\n\n // ======== Testing ========\n\n /// Expect a call to an address with the specified `msg.value` and calldata, and a *minimum* amount of gas.\n function expectCallMinGas(address callee, uint256 msgValue, uint64 minGas, bytes calldata data) external;\n\n /// Expect given number of calls to an address with the specified `msg.value` and calldata, and a *minimum* amount of gas.\n function expectCallMinGas(address callee, uint256 msgValue, uint64 minGas, bytes calldata data, uint64 count)\n external;\n\n /// Expects a call to an address with the specified calldata.\n /// Calldata can either be a strict or a partial match.\n function expectCall(address callee, bytes calldata data) external;\n\n /// Expects given number of calls to an address with the specified calldata.\n function expectCall(address callee, bytes calldata data, uint64 count) external;\n\n /// Expects a call to an address with the specified `msg.value` and calldata.\n function expectCall(address callee, uint256 msgValue, bytes calldata data) external;\n\n /// Expects given number of calls to an address with the specified `msg.value` and calldata.\n function expectCall(address callee, uint256 msgValue, bytes calldata data, uint64 count) external;\n\n /// Expect a call to an address with the specified `msg.value`, gas, and calldata.\n function expectCall(address callee, uint256 msgValue, uint64 gas, bytes calldata data) external;\n\n /// Expects given number of calls to an address with the specified `msg.value`, gas, and calldata.\n function expectCall(address callee, uint256 msgValue, uint64 gas, bytes calldata data, uint64 count) external;\n\n /// Expects the deployment of the specified bytecode by the specified address using the CREATE opcode\n function expectCreate(bytes calldata bytecode, address deployer) external;\n\n /// Expects the deployment of the specified bytecode by the specified address using the CREATE2 opcode\n function expectCreate2(bytes calldata bytecode, address deployer) external;\n\n /// Prepare an expected anonymous log with (bool checkTopic1, bool checkTopic2, bool checkTopic3, bool checkData.).\n /// Call this function, then emit an anonymous event, then call a function. Internally after the call, we check if\n /// logs were emitted in the expected order with the expected topics and data (as specified by the booleans).\n function expectEmitAnonymous(bool checkTopic0, bool checkTopic1, bool checkTopic2, bool checkTopic3, bool checkData)\n external;\n\n /// Same as the previous method, but also checks supplied address against emitting contract.\n function expectEmitAnonymous(\n bool checkTopic0,\n bool checkTopic1,\n bool checkTopic2,\n bool checkTopic3,\n bool checkData,\n address emitter\n ) external;\n\n /// Prepare an expected anonymous log with all topic and data checks enabled.\n /// Call this function, then emit an anonymous event, then call a function. Internally after the call, we check if\n /// logs were emitted in the expected order with the expected topics and data.\n function expectEmitAnonymous() external;\n\n /// Same as the previous method, but also checks supplied address against emitting contract.\n function expectEmitAnonymous(address emitter) external;\n\n /// Prepare an expected log with (bool checkTopic1, bool checkTopic2, bool checkTopic3, bool checkData.).\n /// Call this function, then emit an event, then call a function. Internally after the call, we check if\n /// logs were emitted in the expected order with the expected topics and data (as specified by the booleans).\n function expectEmit(bool checkTopic1, bool checkTopic2, bool checkTopic3, bool checkData) external;\n\n /// Same as the previous method, but also checks supplied address against emitting contract.\n function expectEmit(bool checkTopic1, bool checkTopic2, bool checkTopic3, bool checkData, address emitter)\n external;\n\n /// Prepare an expected log with all topic and data checks enabled.\n /// Call this function, then emit an event, then call a function. Internally after the call, we check if\n /// logs were emitted in the expected order with the expected topics and data.\n function expectEmit() external;\n\n /// Same as the previous method, but also checks supplied address against emitting contract.\n function expectEmit(address emitter) external;\n\n /// Expect a given number of logs with the provided topics.\n function expectEmit(bool checkTopic1, bool checkTopic2, bool checkTopic3, bool checkData, uint64 count) external;\n\n /// Expect a given number of logs from a specific emitter with the provided topics.\n function expectEmit(\n bool checkTopic1,\n bool checkTopic2,\n bool checkTopic3,\n bool checkData,\n address emitter,\n uint64 count\n ) external;\n\n /// Expect a given number of logs with all topic and data checks enabled.\n function expectEmit(uint64 count) external;\n\n /// Expect a given number of logs from a specific emitter with all topic and data checks enabled.\n function expectEmit(address emitter, uint64 count) external;\n\n /// Expects an error on next call that starts with the revert data.\n function expectPartialRevert(bytes4 revertData) external;\n\n /// Expects an error on next call to reverter address, that starts with the revert data.\n function expectPartialRevert(bytes4 revertData, address reverter) external;\n\n /// Expects an error on next call with any revert data.\n function expectRevert() external;\n\n /// Expects an error on next call that exactly matches the revert data.\n function expectRevert(bytes4 revertData) external;\n\n /// Expects a `count` number of reverts from the upcoming calls from the reverter address that match the revert data.\n function expectRevert(bytes4 revertData, address reverter, uint64 count) external;\n\n /// Expects a `count` number of reverts from the upcoming calls from the reverter address that exactly match the revert data.\n function expectRevert(bytes calldata revertData, address reverter, uint64 count) external;\n\n /// Expects an error on next call that exactly matches the revert data.\n function expectRevert(bytes calldata revertData) external;\n\n /// Expects an error with any revert data on next call to reverter address.\n function expectRevert(address reverter) external;\n\n /// Expects an error from reverter address on next call, with any revert data.\n function expectRevert(bytes4 revertData, address reverter) external;\n\n /// Expects an error from reverter address on next call, that exactly matches the revert data.\n function expectRevert(bytes calldata revertData, address reverter) external;\n\n /// Expects a `count` number of reverts from the upcoming calls with any revert data or reverter.\n function expectRevert(uint64 count) external;\n\n /// Expects a `count` number of reverts from the upcoming calls that match the revert data.\n function expectRevert(bytes4 revertData, uint64 count) external;\n\n /// Expects a `count` number of reverts from the upcoming calls that exactly match the revert data.\n function expectRevert(bytes calldata revertData, uint64 count) external;\n\n /// Expects a `count` number of reverts from the upcoming calls from the reverter address.\n function expectRevert(address reverter, uint64 count) external;\n\n /// Only allows memory writes to offsets [0x00, 0x60) ∪ [min, max) in the current subcontext. If any other\n /// memory is written to, the test will fail. Can be called multiple times to add more ranges to the set.\n function expectSafeMemory(uint64 min, uint64 max) external;\n\n /// Only allows memory writes to offsets [0x00, 0x60) ∪ [min, max) in the next created subcontext.\n /// If any other memory is written to, the test will fail. Can be called multiple times to add more ranges\n /// to the set.\n function expectSafeMemoryCall(uint64 min, uint64 max) external;\n\n /// Marks a test as skipped. Must be called at the top level of a test.\n function skip(bool skipTest) external;\n\n /// Marks a test as skipped with a reason. Must be called at the top level of a test.\n function skip(bool skipTest, string calldata reason) external;\n\n /// Stops all safe memory expectation in the current subcontext.\n function stopExpectSafeMemory() external;\n}\n","license":"MIT OR Apache-2.0"},"lib/forge-std/src/console.sol":{"keccak256":"0x4bbf47eb762cef93729d6ef15e78789957147039b113e5d4df48e3d3fd16d0f5","urls":[],"content":"// SPDX-License-Identifier: MIT\npragma solidity >=0.4.22 <0.9.0;\n\nlibrary console {\n address constant CONSOLE_ADDRESS =\n 0x000000000000000000636F6e736F6c652e6c6f67;\n\n function _sendLogPayloadImplementation(bytes memory payload) internal view {\n address consoleAddress = CONSOLE_ADDRESS;\n /// @solidity memory-safe-assembly\n assembly {\n pop(\n staticcall(\n gas(),\n consoleAddress,\n add(payload, 32),\n mload(payload),\n 0,\n 0\n )\n )\n }\n }\n\n function _castToPure(\n function(bytes memory) internal view fnIn\n ) internal pure returns (function(bytes memory) pure fnOut) {\n assembly {\n fnOut := fnIn\n }\n }\n\n function _sendLogPayload(bytes memory payload) internal pure {\n _castToPure(_sendLogPayloadImplementation)(payload);\n }\n\n function log() internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log()\"));\n }\n\n function logInt(int256 p0) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(int256)\", p0));\n }\n\n function logUint(uint256 p0) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256)\", p0));\n }\n\n function logString(string memory p0) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string)\", p0));\n }\n\n function logBool(bool p0) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool)\", p0));\n }\n\n function logAddress(address p0) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address)\", p0));\n }\n\n function logBytes(bytes memory p0) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bytes)\", p0));\n }\n\n function logBytes1(bytes1 p0) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bytes1)\", p0));\n }\n\n function logBytes2(bytes2 p0) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bytes2)\", p0));\n }\n\n function logBytes3(bytes3 p0) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bytes3)\", p0));\n }\n\n function logBytes4(bytes4 p0) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bytes4)\", p0));\n }\n\n function logBytes5(bytes5 p0) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bytes5)\", p0));\n }\n\n function logBytes6(bytes6 p0) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bytes6)\", p0));\n }\n\n function logBytes7(bytes7 p0) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bytes7)\", p0));\n }\n\n function logBytes8(bytes8 p0) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bytes8)\", p0));\n }\n\n function logBytes9(bytes9 p0) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bytes9)\", p0));\n }\n\n function logBytes10(bytes10 p0) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bytes10)\", p0));\n }\n\n function logBytes11(bytes11 p0) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bytes11)\", p0));\n }\n\n function logBytes12(bytes12 p0) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bytes12)\", p0));\n }\n\n function logBytes13(bytes13 p0) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bytes13)\", p0));\n }\n\n function logBytes14(bytes14 p0) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bytes14)\", p0));\n }\n\n function logBytes15(bytes15 p0) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bytes15)\", p0));\n }\n\n function logBytes16(bytes16 p0) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bytes16)\", p0));\n }\n\n function logBytes17(bytes17 p0) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bytes17)\", p0));\n }\n\n function logBytes18(bytes18 p0) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bytes18)\", p0));\n }\n\n function logBytes19(bytes19 p0) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bytes19)\", p0));\n }\n\n function logBytes20(bytes20 p0) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bytes20)\", p0));\n }\n\n function logBytes21(bytes21 p0) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bytes21)\", p0));\n }\n\n function logBytes22(bytes22 p0) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bytes22)\", p0));\n }\n\n function logBytes23(bytes23 p0) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bytes23)\", p0));\n }\n\n function logBytes24(bytes24 p0) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bytes24)\", p0));\n }\n\n function logBytes25(bytes25 p0) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bytes25)\", p0));\n }\n\n function logBytes26(bytes26 p0) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bytes26)\", p0));\n }\n\n function logBytes27(bytes27 p0) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bytes27)\", p0));\n }\n\n function logBytes28(bytes28 p0) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bytes28)\", p0));\n }\n\n function logBytes29(bytes29 p0) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bytes29)\", p0));\n }\n\n function logBytes30(bytes30 p0) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bytes30)\", p0));\n }\n\n function logBytes31(bytes31 p0) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bytes31)\", p0));\n }\n\n function logBytes32(bytes32 p0) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bytes32)\", p0));\n }\n\n function log(uint256 p0) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256)\", p0));\n }\n\n function log(int256 p0) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(int256)\", p0));\n }\n\n function log(string memory p0) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string)\", p0));\n }\n\n function log(bool p0) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool)\", p0));\n }\n\n function log(address p0) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address)\", p0));\n }\n\n function log(uint256 p0, uint256 p1) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,uint256)\", p0, p1));\n }\n\n function log(uint256 p0, string memory p1) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,string)\", p0, p1));\n }\n\n function log(uint256 p0, bool p1) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,bool)\", p0, p1));\n }\n\n function log(uint256 p0, address p1) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,address)\", p0, p1));\n }\n\n function log(string memory p0, uint256 p1) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,uint256)\", p0, p1));\n }\n\n function log(string memory p0, int256 p1) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,int256)\", p0, p1));\n }\n\n function log(string memory p0, string memory p1) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,string)\", p0, p1));\n }\n\n function log(string memory p0, bool p1) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,bool)\", p0, p1));\n }\n\n function log(string memory p0, address p1) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,address)\", p0, p1));\n }\n\n function log(bool p0, uint256 p1) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,uint256)\", p0, p1));\n }\n\n function log(bool p0, string memory p1) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,string)\", p0, p1));\n }\n\n function log(bool p0, bool p1) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,bool)\", p0, p1));\n }\n\n function log(bool p0, address p1) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,address)\", p0, p1));\n }\n\n function log(address p0, uint256 p1) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,uint256)\", p0, p1));\n }\n\n function log(address p0, string memory p1) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,string)\", p0, p1));\n }\n\n function log(address p0, bool p1) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,bool)\", p0, p1));\n }\n\n function log(address p0, address p1) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,address)\", p0, p1));\n }\n\n function log(uint256 p0, uint256 p1, uint256 p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,uint256,uint256)\", p0, p1, p2));\n }\n\n function log(uint256 p0, uint256 p1, string memory p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,uint256,string)\", p0, p1, p2));\n }\n\n function log(uint256 p0, uint256 p1, bool p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,uint256,bool)\", p0, p1, p2));\n }\n\n function log(uint256 p0, uint256 p1, address p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,uint256,address)\", p0, p1, p2));\n }\n\n function log(uint256 p0, string memory p1, uint256 p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,string,uint256)\", p0, p1, p2));\n }\n\n function log(uint256 p0, string memory p1, string memory p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,string,string)\", p0, p1, p2));\n }\n\n function log(uint256 p0, string memory p1, bool p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,string,bool)\", p0, p1, p2));\n }\n\n function log(uint256 p0, string memory p1, address p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,string,address)\", p0, p1, p2));\n }\n\n function log(uint256 p0, bool p1, uint256 p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,bool,uint256)\", p0, p1, p2));\n }\n\n function log(uint256 p0, bool p1, string memory p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,bool,string)\", p0, p1, p2));\n }\n\n function log(uint256 p0, bool p1, bool p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,bool,bool)\", p0, p1, p2));\n }\n\n function log(uint256 p0, bool p1, address p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,bool,address)\", p0, p1, p2));\n }\n\n function log(uint256 p0, address p1, uint256 p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,address,uint256)\", p0, p1, p2));\n }\n\n function log(uint256 p0, address p1, string memory p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,address,string)\", p0, p1, p2));\n }\n\n function log(uint256 p0, address p1, bool p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,address,bool)\", p0, p1, p2));\n }\n\n function log(uint256 p0, address p1, address p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,address,address)\", p0, p1, p2));\n }\n\n function log(string memory p0, uint256 p1, uint256 p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,uint256,uint256)\", p0, p1, p2));\n }\n\n function log(string memory p0, uint256 p1, string memory p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,uint256,string)\", p0, p1, p2));\n }\n\n function log(string memory p0, uint256 p1, bool p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,uint256,bool)\", p0, p1, p2));\n }\n\n function log(string memory p0, uint256 p1, address p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,uint256,address)\", p0, p1, p2));\n }\n\n function log(string memory p0, string memory p1, uint256 p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,string,uint256)\", p0, p1, p2));\n }\n\n function log(string memory p0, string memory p1, string memory p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,string,string)\", p0, p1, p2));\n }\n\n function log(string memory p0, string memory p1, bool p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,string,bool)\", p0, p1, p2));\n }\n\n function log(string memory p0, string memory p1, address p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,string,address)\", p0, p1, p2));\n }\n\n function log(string memory p0, bool p1, uint256 p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,bool,uint256)\", p0, p1, p2));\n }\n\n function log(string memory p0, bool p1, string memory p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,bool,string)\", p0, p1, p2));\n }\n\n function log(string memory p0, bool p1, bool p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,bool,bool)\", p0, p1, p2));\n }\n\n function log(string memory p0, bool p1, address p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,bool,address)\", p0, p1, p2));\n }\n\n function log(string memory p0, address p1, uint256 p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,address,uint256)\", p0, p1, p2));\n }\n\n function log(string memory p0, address p1, string memory p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,address,string)\", p0, p1, p2));\n }\n\n function log(string memory p0, address p1, bool p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,address,bool)\", p0, p1, p2));\n }\n\n function log(string memory p0, address p1, address p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,address,address)\", p0, p1, p2));\n }\n\n function log(bool p0, uint256 p1, uint256 p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,uint256,uint256)\", p0, p1, p2));\n }\n\n function log(bool p0, uint256 p1, string memory p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,uint256,string)\", p0, p1, p2));\n }\n\n function log(bool p0, uint256 p1, bool p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,uint256,bool)\", p0, p1, p2));\n }\n\n function log(bool p0, uint256 p1, address p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,uint256,address)\", p0, p1, p2));\n }\n\n function log(bool p0, string memory p1, uint256 p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,string,uint256)\", p0, p1, p2));\n }\n\n function log(bool p0, string memory p1, string memory p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,string,string)\", p0, p1, p2));\n }\n\n function log(bool p0, string memory p1, bool p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,string,bool)\", p0, p1, p2));\n }\n\n function log(bool p0, string memory p1, address p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,string,address)\", p0, p1, p2));\n }\n\n function log(bool p0, bool p1, uint256 p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,bool,uint256)\", p0, p1, p2));\n }\n\n function log(bool p0, bool p1, string memory p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,bool,string)\", p0, p1, p2));\n }\n\n function log(bool p0, bool p1, bool p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,bool,bool)\", p0, p1, p2));\n }\n\n function log(bool p0, bool p1, address p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,bool,address)\", p0, p1, p2));\n }\n\n function log(bool p0, address p1, uint256 p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,address,uint256)\", p0, p1, p2));\n }\n\n function log(bool p0, address p1, string memory p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,address,string)\", p0, p1, p2));\n }\n\n function log(bool p0, address p1, bool p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,address,bool)\", p0, p1, p2));\n }\n\n function log(bool p0, address p1, address p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,address,address)\", p0, p1, p2));\n }\n\n function log(address p0, uint256 p1, uint256 p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,uint256,uint256)\", p0, p1, p2));\n }\n\n function log(address p0, uint256 p1, string memory p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,uint256,string)\", p0, p1, p2));\n }\n\n function log(address p0, uint256 p1, bool p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,uint256,bool)\", p0, p1, p2));\n }\n\n function log(address p0, uint256 p1, address p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,uint256,address)\", p0, p1, p2));\n }\n\n function log(address p0, string memory p1, uint256 p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,string,uint256)\", p0, p1, p2));\n }\n\n function log(address p0, string memory p1, string memory p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,string,string)\", p0, p1, p2));\n }\n\n function log(address p0, string memory p1, bool p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,string,bool)\", p0, p1, p2));\n }\n\n function log(address p0, string memory p1, address p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,string,address)\", p0, p1, p2));\n }\n\n function log(address p0, bool p1, uint256 p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,bool,uint256)\", p0, p1, p2));\n }\n\n function log(address p0, bool p1, string memory p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,bool,string)\", p0, p1, p2));\n }\n\n function log(address p0, bool p1, bool p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,bool,bool)\", p0, p1, p2));\n }\n\n function log(address p0, bool p1, address p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,bool,address)\", p0, p1, p2));\n }\n\n function log(address p0, address p1, uint256 p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,address,uint256)\", p0, p1, p2));\n }\n\n function log(address p0, address p1, string memory p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,address,string)\", p0, p1, p2));\n }\n\n function log(address p0, address p1, bool p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,address,bool)\", p0, p1, p2));\n }\n\n function log(address p0, address p1, address p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,address,address)\", p0, p1, p2));\n }\n\n function log(uint256 p0, uint256 p1, uint256 p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,uint256,uint256,uint256)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, uint256 p1, uint256 p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,uint256,uint256,string)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, uint256 p1, uint256 p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,uint256,uint256,bool)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, uint256 p1, uint256 p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,uint256,uint256,address)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, uint256 p1, string memory p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,uint256,string,uint256)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, uint256 p1, string memory p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,uint256,string,string)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, uint256 p1, string memory p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,uint256,string,bool)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, uint256 p1, string memory p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,uint256,string,address)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, uint256 p1, bool p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,uint256,bool,uint256)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, uint256 p1, bool p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,uint256,bool,string)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, uint256 p1, bool p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,uint256,bool,bool)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, uint256 p1, bool p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,uint256,bool,address)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, uint256 p1, address p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,uint256,address,uint256)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, uint256 p1, address p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,uint256,address,string)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, uint256 p1, address p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,uint256,address,bool)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, uint256 p1, address p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,uint256,address,address)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, string memory p1, uint256 p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,string,uint256,uint256)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, string memory p1, uint256 p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,string,uint256,string)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, string memory p1, uint256 p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,string,uint256,bool)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, string memory p1, uint256 p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,string,uint256,address)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, string memory p1, string memory p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,string,string,uint256)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, string memory p1, string memory p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,string,string,string)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, string memory p1, string memory p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,string,string,bool)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, string memory p1, string memory p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,string,string,address)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, string memory p1, bool p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,string,bool,uint256)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, string memory p1, bool p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,string,bool,string)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, string memory p1, bool p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,string,bool,bool)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, string memory p1, bool p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,string,bool,address)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, string memory p1, address p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,string,address,uint256)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, string memory p1, address p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,string,address,string)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, string memory p1, address p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,string,address,bool)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, string memory p1, address p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,string,address,address)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, bool p1, uint256 p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,bool,uint256,uint256)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, bool p1, uint256 p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,bool,uint256,string)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, bool p1, uint256 p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,bool,uint256,bool)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, bool p1, uint256 p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,bool,uint256,address)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, bool p1, string memory p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,bool,string,uint256)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, bool p1, string memory p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,bool,string,string)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, bool p1, string memory p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,bool,string,bool)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, bool p1, string memory p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,bool,string,address)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, bool p1, bool p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,bool,bool,uint256)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, bool p1, bool p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,bool,bool,string)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, bool p1, bool p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,bool,bool,bool)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, bool p1, bool p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,bool,bool,address)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, bool p1, address p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,bool,address,uint256)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, bool p1, address p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,bool,address,string)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, bool p1, address p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,bool,address,bool)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, bool p1, address p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,bool,address,address)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, address p1, uint256 p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,address,uint256,uint256)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, address p1, uint256 p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,address,uint256,string)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, address p1, uint256 p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,address,uint256,bool)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, address p1, uint256 p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,address,uint256,address)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, address p1, string memory p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,address,string,uint256)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, address p1, string memory p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,address,string,string)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, address p1, string memory p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,address,string,bool)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, address p1, string memory p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,address,string,address)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, address p1, bool p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,address,bool,uint256)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, address p1, bool p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,address,bool,string)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, address p1, bool p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,address,bool,bool)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, address p1, bool p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,address,bool,address)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, address p1, address p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,address,address,uint256)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, address p1, address p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,address,address,string)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, address p1, address p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,address,address,bool)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, address p1, address p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,address,address,address)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, uint256 p1, uint256 p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,uint256,uint256,uint256)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, uint256 p1, uint256 p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,uint256,uint256,string)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, uint256 p1, uint256 p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,uint256,uint256,bool)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, uint256 p1, uint256 p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,uint256,uint256,address)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, uint256 p1, string memory p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,uint256,string,uint256)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, uint256 p1, string memory p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,uint256,string,string)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, uint256 p1, string memory p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,uint256,string,bool)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, uint256 p1, string memory p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,uint256,string,address)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, uint256 p1, bool p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,uint256,bool,uint256)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, uint256 p1, bool p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,uint256,bool,string)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, uint256 p1, bool p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,uint256,bool,bool)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, uint256 p1, bool p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,uint256,bool,address)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, uint256 p1, address p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,uint256,address,uint256)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, uint256 p1, address p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,uint256,address,string)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, uint256 p1, address p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,uint256,address,bool)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, uint256 p1, address p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,uint256,address,address)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, string memory p1, uint256 p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,string,uint256,uint256)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, string memory p1, uint256 p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,string,uint256,string)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, string memory p1, uint256 p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,string,uint256,bool)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, string memory p1, uint256 p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,string,uint256,address)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, string memory p1, string memory p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,string,string,uint256)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, string memory p1, string memory p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,string,string,string)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, string memory p1, string memory p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,string,string,bool)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, string memory p1, string memory p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,string,string,address)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, string memory p1, bool p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,string,bool,uint256)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, string memory p1, bool p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,string,bool,string)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, string memory p1, bool p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,string,bool,bool)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, string memory p1, bool p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,string,bool,address)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, string memory p1, address p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,string,address,uint256)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, string memory p1, address p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,string,address,string)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, string memory p1, address p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,string,address,bool)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, string memory p1, address p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,string,address,address)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, bool p1, uint256 p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,bool,uint256,uint256)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, bool p1, uint256 p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,bool,uint256,string)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, bool p1, uint256 p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,bool,uint256,bool)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, bool p1, uint256 p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,bool,uint256,address)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, bool p1, string memory p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,bool,string,uint256)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, bool p1, string memory p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,bool,string,string)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, bool p1, string memory p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,bool,string,bool)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, bool p1, string memory p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,bool,string,address)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, bool p1, bool p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,bool,bool,uint256)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, bool p1, bool p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,bool,bool,string)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, bool p1, bool p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,bool,bool,bool)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, bool p1, bool p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,bool,bool,address)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, bool p1, address p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,bool,address,uint256)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, bool p1, address p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,bool,address,string)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, bool p1, address p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,bool,address,bool)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, bool p1, address p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,bool,address,address)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, address p1, uint256 p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,address,uint256,uint256)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, address p1, uint256 p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,address,uint256,string)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, address p1, uint256 p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,address,uint256,bool)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, address p1, uint256 p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,address,uint256,address)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, address p1, string memory p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,address,string,uint256)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, address p1, string memory p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,address,string,string)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, address p1, string memory p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,address,string,bool)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, address p1, string memory p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,address,string,address)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, address p1, bool p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,address,bool,uint256)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, address p1, bool p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,address,bool,string)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, address p1, bool p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,address,bool,bool)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, address p1, bool p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,address,bool,address)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, address p1, address p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,address,address,uint256)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, address p1, address p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,address,address,string)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, address p1, address p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,address,address,bool)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, address p1, address p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,address,address,address)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, uint256 p1, uint256 p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,uint256,uint256,uint256)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, uint256 p1, uint256 p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,uint256,uint256,string)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, uint256 p1, uint256 p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,uint256,uint256,bool)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, uint256 p1, uint256 p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,uint256,uint256,address)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, uint256 p1, string memory p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,uint256,string,uint256)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, uint256 p1, string memory p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,uint256,string,string)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, uint256 p1, string memory p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,uint256,string,bool)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, uint256 p1, string memory p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,uint256,string,address)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, uint256 p1, bool p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,uint256,bool,uint256)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, uint256 p1, bool p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,uint256,bool,string)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, uint256 p1, bool p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,uint256,bool,bool)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, uint256 p1, bool p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,uint256,bool,address)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, uint256 p1, address p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,uint256,address,uint256)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, uint256 p1, address p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,uint256,address,string)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, uint256 p1, address p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,uint256,address,bool)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, uint256 p1, address p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,uint256,address,address)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, string memory p1, uint256 p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,string,uint256,uint256)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, string memory p1, uint256 p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,string,uint256,string)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, string memory p1, uint256 p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,string,uint256,bool)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, string memory p1, uint256 p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,string,uint256,address)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, string memory p1, string memory p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,string,string,uint256)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, string memory p1, string memory p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,string,string,string)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, string memory p1, string memory p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,string,string,bool)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, string memory p1, string memory p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,string,string,address)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, string memory p1, bool p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,string,bool,uint256)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, string memory p1, bool p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,string,bool,string)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, string memory p1, bool p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,string,bool,bool)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, string memory p1, bool p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,string,bool,address)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, string memory p1, address p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,string,address,uint256)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, string memory p1, address p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,string,address,string)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, string memory p1, address p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,string,address,bool)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, string memory p1, address p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,string,address,address)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, bool p1, uint256 p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,bool,uint256,uint256)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, bool p1, uint256 p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,bool,uint256,string)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, bool p1, uint256 p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,bool,uint256,bool)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, bool p1, uint256 p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,bool,uint256,address)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, bool p1, string memory p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,bool,string,uint256)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, bool p1, string memory p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,bool,string,string)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, bool p1, string memory p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,bool,string,bool)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, bool p1, string memory p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,bool,string,address)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, bool p1, bool p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,bool,bool,uint256)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, bool p1, bool p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,bool,bool,string)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, bool p1, bool p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,bool,bool,bool)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, bool p1, bool p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,bool,bool,address)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, bool p1, address p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,bool,address,uint256)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, bool p1, address p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,bool,address,string)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, bool p1, address p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,bool,address,bool)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, bool p1, address p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,bool,address,address)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, address p1, uint256 p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,address,uint256,uint256)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, address p1, uint256 p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,address,uint256,string)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, address p1, uint256 p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,address,uint256,bool)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, address p1, uint256 p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,address,uint256,address)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, address p1, string memory p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,address,string,uint256)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, address p1, string memory p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,address,string,string)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, address p1, string memory p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,address,string,bool)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, address p1, string memory p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,address,string,address)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, address p1, bool p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,address,bool,uint256)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, address p1, bool p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,address,bool,string)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, address p1, bool p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,address,bool,bool)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, address p1, bool p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,address,bool,address)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, address p1, address p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,address,address,uint256)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, address p1, address p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,address,address,string)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, address p1, address p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,address,address,bool)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, address p1, address p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,address,address,address)\", p0, p1, p2, p3));\n }\n\n function log(address p0, uint256 p1, uint256 p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,uint256,uint256,uint256)\", p0, p1, p2, p3));\n }\n\n function log(address p0, uint256 p1, uint256 p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,uint256,uint256,string)\", p0, p1, p2, p3));\n }\n\n function log(address p0, uint256 p1, uint256 p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,uint256,uint256,bool)\", p0, p1, p2, p3));\n }\n\n function log(address p0, uint256 p1, uint256 p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,uint256,uint256,address)\", p0, p1, p2, p3));\n }\n\n function log(address p0, uint256 p1, string memory p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,uint256,string,uint256)\", p0, p1, p2, p3));\n }\n\n function log(address p0, uint256 p1, string memory p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,uint256,string,string)\", p0, p1, p2, p3));\n }\n\n function log(address p0, uint256 p1, string memory p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,uint256,string,bool)\", p0, p1, p2, p3));\n }\n\n function log(address p0, uint256 p1, string memory p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,uint256,string,address)\", p0, p1, p2, p3));\n }\n\n function log(address p0, uint256 p1, bool p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,uint256,bool,uint256)\", p0, p1, p2, p3));\n }\n\n function log(address p0, uint256 p1, bool p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,uint256,bool,string)\", p0, p1, p2, p3));\n }\n\n function log(address p0, uint256 p1, bool p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,uint256,bool,bool)\", p0, p1, p2, p3));\n }\n\n function log(address p0, uint256 p1, bool p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,uint256,bool,address)\", p0, p1, p2, p3));\n }\n\n function log(address p0, uint256 p1, address p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,uint256,address,uint256)\", p0, p1, p2, p3));\n }\n\n function log(address p0, uint256 p1, address p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,uint256,address,string)\", p0, p1, p2, p3));\n }\n\n function log(address p0, uint256 p1, address p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,uint256,address,bool)\", p0, p1, p2, p3));\n }\n\n function log(address p0, uint256 p1, address p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,uint256,address,address)\", p0, p1, p2, p3));\n }\n\n function log(address p0, string memory p1, uint256 p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,string,uint256,uint256)\", p0, p1, p2, p3));\n }\n\n function log(address p0, string memory p1, uint256 p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,string,uint256,string)\", p0, p1, p2, p3));\n }\n\n function log(address p0, string memory p1, uint256 p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,string,uint256,bool)\", p0, p1, p2, p3));\n }\n\n function log(address p0, string memory p1, uint256 p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,string,uint256,address)\", p0, p1, p2, p3));\n }\n\n function log(address p0, string memory p1, string memory p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,string,string,uint256)\", p0, p1, p2, p3));\n }\n\n function log(address p0, string memory p1, string memory p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,string,string,string)\", p0, p1, p2, p3));\n }\n\n function log(address p0, string memory p1, string memory p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,string,string,bool)\", p0, p1, p2, p3));\n }\n\n function log(address p0, string memory p1, string memory p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,string,string,address)\", p0, p1, p2, p3));\n }\n\n function log(address p0, string memory p1, bool p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,string,bool,uint256)\", p0, p1, p2, p3));\n }\n\n function log(address p0, string memory p1, bool p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,string,bool,string)\", p0, p1, p2, p3));\n }\n\n function log(address p0, string memory p1, bool p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,string,bool,bool)\", p0, p1, p2, p3));\n }\n\n function log(address p0, string memory p1, bool p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,string,bool,address)\", p0, p1, p2, p3));\n }\n\n function log(address p0, string memory p1, address p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,string,address,uint256)\", p0, p1, p2, p3));\n }\n\n function log(address p0, string memory p1, address p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,string,address,string)\", p0, p1, p2, p3));\n }\n\n function log(address p0, string memory p1, address p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,string,address,bool)\", p0, p1, p2, p3));\n }\n\n function log(address p0, string memory p1, address p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,string,address,address)\", p0, p1, p2, p3));\n }\n\n function log(address p0, bool p1, uint256 p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,bool,uint256,uint256)\", p0, p1, p2, p3));\n }\n\n function log(address p0, bool p1, uint256 p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,bool,uint256,string)\", p0, p1, p2, p3));\n }\n\n function log(address p0, bool p1, uint256 p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,bool,uint256,bool)\", p0, p1, p2, p3));\n }\n\n function log(address p0, bool p1, uint256 p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,bool,uint256,address)\", p0, p1, p2, p3));\n }\n\n function log(address p0, bool p1, string memory p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,bool,string,uint256)\", p0, p1, p2, p3));\n }\n\n function log(address p0, bool p1, string memory p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,bool,string,string)\", p0, p1, p2, p3));\n }\n\n function log(address p0, bool p1, string memory p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,bool,string,bool)\", p0, p1, p2, p3));\n }\n\n function log(address p0, bool p1, string memory p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,bool,string,address)\", p0, p1, p2, p3));\n }\n\n function log(address p0, bool p1, bool p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,bool,bool,uint256)\", p0, p1, p2, p3));\n }\n\n function log(address p0, bool p1, bool p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,bool,bool,string)\", p0, p1, p2, p3));\n }\n\n function log(address p0, bool p1, bool p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,bool,bool,bool)\", p0, p1, p2, p3));\n }\n\n function log(address p0, bool p1, bool p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,bool,bool,address)\", p0, p1, p2, p3));\n }\n\n function log(address p0, bool p1, address p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,bool,address,uint256)\", p0, p1, p2, p3));\n }\n\n function log(address p0, bool p1, address p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,bool,address,string)\", p0, p1, p2, p3));\n }\n\n function log(address p0, bool p1, address p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,bool,address,bool)\", p0, p1, p2, p3));\n }\n\n function log(address p0, bool p1, address p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,bool,address,address)\", p0, p1, p2, p3));\n }\n\n function log(address p0, address p1, uint256 p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,address,uint256,uint256)\", p0, p1, p2, p3));\n }\n\n function log(address p0, address p1, uint256 p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,address,uint256,string)\", p0, p1, p2, p3));\n }\n\n function log(address p0, address p1, uint256 p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,address,uint256,bool)\", p0, p1, p2, p3));\n }\n\n function log(address p0, address p1, uint256 p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,address,uint256,address)\", p0, p1, p2, p3));\n }\n\n function log(address p0, address p1, string memory p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,address,string,uint256)\", p0, p1, p2, p3));\n }\n\n function log(address p0, address p1, string memory p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,address,string,string)\", p0, p1, p2, p3));\n }\n\n function log(address p0, address p1, string memory p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,address,string,bool)\", p0, p1, p2, p3));\n }\n\n function log(address p0, address p1, string memory p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,address,string,address)\", p0, p1, p2, p3));\n }\n\n function log(address p0, address p1, bool p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,address,bool,uint256)\", p0, p1, p2, p3));\n }\n\n function log(address p0, address p1, bool p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,address,bool,string)\", p0, p1, p2, p3));\n }\n\n function log(address p0, address p1, bool p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,address,bool,bool)\", p0, p1, p2, p3));\n }\n\n function log(address p0, address p1, bool p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,address,bool,address)\", p0, p1, p2, p3));\n }\n\n function log(address p0, address p1, address p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,address,address,uint256)\", p0, p1, p2, p3));\n }\n\n function log(address p0, address p1, address p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,address,address,string)\", p0, p1, p2, p3));\n }\n\n function log(address p0, address p1, address p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,address,address,bool)\", p0, p1, p2, p3));\n }\n\n function log(address p0, address p1, address p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,address,address,address)\", p0, p1, p2, p3));\n }\n}\n","license":"MIT"},"lib/forge-std/src/console2.sol":{"keccak256":"0x3b8fe79f48f065a4e4d35362171304a33784c3a90febae5f2787805a438de12f","urls":[],"content":"// SPDX-License-Identifier: MIT\npragma solidity >=0.4.22 <0.9.0;\n\nimport {console as console2} from \"./console.sol\";\n","license":"MIT"},"lib/forge-std/src/interfaces/IMulticall3.sol":{"keccak256":"0x7aac1389150499a922d1f9ef5749c908cef127cb2075b92fa17e9cb611263d0a","urls":[],"content":"// SPDX-License-Identifier: MIT\npragma solidity >=0.6.2 <0.9.0;\n\npragma experimental ABIEncoderV2;\n\ninterface IMulticall3 {\n struct Call {\n address target;\n bytes callData;\n }\n\n struct Call3 {\n address target;\n bool allowFailure;\n bytes callData;\n }\n\n struct Call3Value {\n address target;\n bool allowFailure;\n uint256 value;\n bytes callData;\n }\n\n struct Result {\n bool success;\n bytes returnData;\n }\n\n function aggregate(Call[] calldata calls)\n external\n payable\n returns (uint256 blockNumber, bytes[] memory returnData);\n\n function aggregate3(Call3[] calldata calls) external payable returns (Result[] memory returnData);\n\n function aggregate3Value(Call3Value[] calldata calls) external payable returns (Result[] memory returnData);\n\n function blockAndAggregate(Call[] calldata calls)\n external\n payable\n returns (uint256 blockNumber, bytes32 blockHash, Result[] memory returnData);\n\n function getBasefee() external view returns (uint256 basefee);\n\n function getBlockHash(uint256 blockNumber) external view returns (bytes32 blockHash);\n\n function getBlockNumber() external view returns (uint256 blockNumber);\n\n function getChainId() external view returns (uint256 chainid);\n\n function getCurrentBlockCoinbase() external view returns (address coinbase);\n\n function getCurrentBlockDifficulty() external view returns (uint256 difficulty);\n\n function getCurrentBlockGasLimit() external view returns (uint256 gaslimit);\n\n function getCurrentBlockTimestamp() external view returns (uint256 timestamp);\n\n function getEthBalance(address addr) external view returns (uint256 balance);\n\n function getLastBlockHash() external view returns (bytes32 blockHash);\n\n function tryAggregate(bool requireSuccess, Call[] calldata calls)\n external\n payable\n returns (Result[] memory returnData);\n\n function tryBlockAndAggregate(bool requireSuccess, Call[] calldata calls)\n external\n payable\n returns (uint256 blockNumber, bytes32 blockHash, Result[] memory returnData);\n}\n","license":"MIT"},"lib/forge-std/src/safeconsole.sol":{"keccak256":"0xbef9786cb49d3eade757bad87568c49c8c8f35721f0193c95ffb055d9e466e11","urls":[],"content":"// SPDX-License-Identifier: MIT\npragma solidity >=0.6.2 <0.9.0;\n\n/// @author philogy \n/// @dev Code generated automatically by script.\nlibrary safeconsole {\n uint256 constant CONSOLE_ADDR = 0x000000000000000000000000000000000000000000636F6e736F6c652e6c6f67;\n\n // Credit to [0age](https://twitter.com/z0age/status/1654922202930888704) and [0xdapper](https://github.com/foundry-rs/forge-std/pull/374)\n // for the view-to-pure log trick.\n function _sendLogPayload(uint256 offset, uint256 size) private pure {\n function(uint256, uint256) internal view fnIn = _sendLogPayloadView;\n function(uint256, uint256) internal pure pureSendLogPayload;\n /// @solidity memory-safe-assembly\n assembly {\n pureSendLogPayload := fnIn\n }\n pureSendLogPayload(offset, size);\n }\n\n function _sendLogPayloadView(uint256 offset, uint256 size) private view {\n /// @solidity memory-safe-assembly\n assembly {\n pop(staticcall(gas(), CONSOLE_ADDR, offset, size, 0x0, 0x0))\n }\n }\n\n function _memcopy(uint256 fromOffset, uint256 toOffset, uint256 length) private pure {\n function(uint256, uint256, uint256) internal view fnIn = _memcopyView;\n function(uint256, uint256, uint256) internal pure pureMemcopy;\n /// @solidity memory-safe-assembly\n assembly {\n pureMemcopy := fnIn\n }\n pureMemcopy(fromOffset, toOffset, length);\n }\n\n function _memcopyView(uint256 fromOffset, uint256 toOffset, uint256 length) private view {\n /// @solidity memory-safe-assembly\n assembly {\n pop(staticcall(gas(), 0x4, fromOffset, length, toOffset, length))\n }\n }\n\n function logMemory(uint256 offset, uint256 length) internal pure {\n if (offset >= 0x60) {\n // Sufficient memory before slice to prepare call header.\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(sub(offset, 0x60))\n m1 := mload(sub(offset, 0x40))\n m2 := mload(sub(offset, 0x20))\n // Selector of `log(bytes)`.\n mstore(sub(offset, 0x60), 0x0be77f56)\n mstore(sub(offset, 0x40), 0x20)\n mstore(sub(offset, 0x20), length)\n }\n _sendLogPayload(offset - 0x44, length + 0x44);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(sub(offset, 0x60), m0)\n mstore(sub(offset, 0x40), m1)\n mstore(sub(offset, 0x20), m2)\n }\n } else {\n // Insufficient space, so copy slice forward, add header and reverse.\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n uint256 endOffset = offset + length;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(add(endOffset, 0x00))\n m1 := mload(add(endOffset, 0x20))\n m2 := mload(add(endOffset, 0x40))\n }\n _memcopy(offset, offset + 0x60, length);\n /// @solidity memory-safe-assembly\n assembly {\n // Selector of `log(bytes)`.\n mstore(add(offset, 0x00), 0x0be77f56)\n mstore(add(offset, 0x20), 0x20)\n mstore(add(offset, 0x40), length)\n }\n _sendLogPayload(offset + 0x1c, length + 0x44);\n _memcopy(offset + 0x60, offset, length);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(add(endOffset, 0x00), m0)\n mstore(add(endOffset, 0x20), m1)\n mstore(add(endOffset, 0x40), m2)\n }\n }\n }\n\n function log(address p0) internal pure {\n bytes32 m0;\n bytes32 m1;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n // Selector of `log(address)`.\n mstore(0x00, 0x2c2ecbc2)\n mstore(0x20, p0)\n }\n _sendLogPayload(0x1c, 0x24);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n }\n }\n\n function log(bool p0) internal pure {\n bytes32 m0;\n bytes32 m1;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n // Selector of `log(bool)`.\n mstore(0x00, 0x32458eed)\n mstore(0x20, p0)\n }\n _sendLogPayload(0x1c, 0x24);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n }\n }\n\n function log(uint256 p0) internal pure {\n bytes32 m0;\n bytes32 m1;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n // Selector of `log(uint256)`.\n mstore(0x00, 0xf82c50f1)\n mstore(0x20, p0)\n }\n _sendLogPayload(0x1c, 0x24);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n }\n }\n\n function log(bytes32 p0) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n // Selector of `log(string)`.\n mstore(0x00, 0x41304fac)\n mstore(0x20, 0x20)\n writeString(0x40, p0)\n }\n _sendLogPayload(0x1c, 0x64);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n }\n }\n\n function log(address p0, address p1) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n // Selector of `log(address,address)`.\n mstore(0x00, 0xdaf0d4aa)\n mstore(0x20, p0)\n mstore(0x40, p1)\n }\n _sendLogPayload(0x1c, 0x44);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n }\n }\n\n function log(address p0, bool p1) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n // Selector of `log(address,bool)`.\n mstore(0x00, 0x75b605d3)\n mstore(0x20, p0)\n mstore(0x40, p1)\n }\n _sendLogPayload(0x1c, 0x44);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n }\n }\n\n function log(address p0, uint256 p1) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n // Selector of `log(address,uint256)`.\n mstore(0x00, 0x8309e8a8)\n mstore(0x20, p0)\n mstore(0x40, p1)\n }\n _sendLogPayload(0x1c, 0x44);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n }\n }\n\n function log(address p0, bytes32 p1) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(address,string)`.\n mstore(0x00, 0x759f86bb)\n mstore(0x20, p0)\n mstore(0x40, 0x40)\n writeString(0x60, p1)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(bool p0, address p1) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n // Selector of `log(bool,address)`.\n mstore(0x00, 0x853c4849)\n mstore(0x20, p0)\n mstore(0x40, p1)\n }\n _sendLogPayload(0x1c, 0x44);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n }\n }\n\n function log(bool p0, bool p1) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n // Selector of `log(bool,bool)`.\n mstore(0x00, 0x2a110e83)\n mstore(0x20, p0)\n mstore(0x40, p1)\n }\n _sendLogPayload(0x1c, 0x44);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n }\n }\n\n function log(bool p0, uint256 p1) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n // Selector of `log(bool,uint256)`.\n mstore(0x00, 0x399174d3)\n mstore(0x20, p0)\n mstore(0x40, p1)\n }\n _sendLogPayload(0x1c, 0x44);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n }\n }\n\n function log(bool p0, bytes32 p1) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(bool,string)`.\n mstore(0x00, 0x8feac525)\n mstore(0x20, p0)\n mstore(0x40, 0x40)\n writeString(0x60, p1)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(uint256 p0, address p1) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n // Selector of `log(uint256,address)`.\n mstore(0x00, 0x69276c86)\n mstore(0x20, p0)\n mstore(0x40, p1)\n }\n _sendLogPayload(0x1c, 0x44);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n }\n }\n\n function log(uint256 p0, bool p1) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n // Selector of `log(uint256,bool)`.\n mstore(0x00, 0x1c9d7eb3)\n mstore(0x20, p0)\n mstore(0x40, p1)\n }\n _sendLogPayload(0x1c, 0x44);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n }\n }\n\n function log(uint256 p0, uint256 p1) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n // Selector of `log(uint256,uint256)`.\n mstore(0x00, 0xf666715a)\n mstore(0x20, p0)\n mstore(0x40, p1)\n }\n _sendLogPayload(0x1c, 0x44);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n }\n }\n\n function log(uint256 p0, bytes32 p1) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(uint256,string)`.\n mstore(0x00, 0x643fd0df)\n mstore(0x20, p0)\n mstore(0x40, 0x40)\n writeString(0x60, p1)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(bytes32 p0, address p1) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(string,address)`.\n mstore(0x00, 0x319af333)\n mstore(0x20, 0x40)\n mstore(0x40, p1)\n writeString(0x60, p0)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(bytes32 p0, bool p1) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(string,bool)`.\n mstore(0x00, 0xc3b55635)\n mstore(0x20, 0x40)\n mstore(0x40, p1)\n writeString(0x60, p0)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(bytes32 p0, uint256 p1) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(string,uint256)`.\n mstore(0x00, 0xb60e72cc)\n mstore(0x20, 0x40)\n mstore(0x40, p1)\n writeString(0x60, p0)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(bytes32 p0, bytes32 p1) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(string,string)`.\n mstore(0x00, 0x4b5c4277)\n mstore(0x20, 0x40)\n mstore(0x40, 0x80)\n writeString(0x60, p0)\n writeString(0xa0, p1)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(address p0, address p1, address p2) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n // Selector of `log(address,address,address)`.\n mstore(0x00, 0x018c84c2)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n }\n _sendLogPayload(0x1c, 0x64);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n }\n }\n\n function log(address p0, address p1, bool p2) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n // Selector of `log(address,address,bool)`.\n mstore(0x00, 0xf2a66286)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n }\n _sendLogPayload(0x1c, 0x64);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n }\n }\n\n function log(address p0, address p1, uint256 p2) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n // Selector of `log(address,address,uint256)`.\n mstore(0x00, 0x17fe6185)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n }\n _sendLogPayload(0x1c, 0x64);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n }\n }\n\n function log(address p0, address p1, bytes32 p2) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n // Selector of `log(address,address,string)`.\n mstore(0x00, 0x007150be)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, 0x60)\n writeString(0x80, p2)\n }\n _sendLogPayload(0x1c, 0xa4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n }\n }\n\n function log(address p0, bool p1, address p2) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n // Selector of `log(address,bool,address)`.\n mstore(0x00, 0xf11699ed)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n }\n _sendLogPayload(0x1c, 0x64);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n }\n }\n\n function log(address p0, bool p1, bool p2) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n // Selector of `log(address,bool,bool)`.\n mstore(0x00, 0xeb830c92)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n }\n _sendLogPayload(0x1c, 0x64);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n }\n }\n\n function log(address p0, bool p1, uint256 p2) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n // Selector of `log(address,bool,uint256)`.\n mstore(0x00, 0x9c4f99fb)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n }\n _sendLogPayload(0x1c, 0x64);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n }\n }\n\n function log(address p0, bool p1, bytes32 p2) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n // Selector of `log(address,bool,string)`.\n mstore(0x00, 0x212255cc)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, 0x60)\n writeString(0x80, p2)\n }\n _sendLogPayload(0x1c, 0xa4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n }\n }\n\n function log(address p0, uint256 p1, address p2) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n // Selector of `log(address,uint256,address)`.\n mstore(0x00, 0x7bc0d848)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n }\n _sendLogPayload(0x1c, 0x64);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n }\n }\n\n function log(address p0, uint256 p1, bool p2) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n // Selector of `log(address,uint256,bool)`.\n mstore(0x00, 0x678209a8)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n }\n _sendLogPayload(0x1c, 0x64);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n }\n }\n\n function log(address p0, uint256 p1, uint256 p2) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n // Selector of `log(address,uint256,uint256)`.\n mstore(0x00, 0xb69bcaf6)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n }\n _sendLogPayload(0x1c, 0x64);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n }\n }\n\n function log(address p0, uint256 p1, bytes32 p2) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n // Selector of `log(address,uint256,string)`.\n mstore(0x00, 0xa1f2e8aa)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, 0x60)\n writeString(0x80, p2)\n }\n _sendLogPayload(0x1c, 0xa4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n }\n }\n\n function log(address p0, bytes32 p1, address p2) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n // Selector of `log(address,string,address)`.\n mstore(0x00, 0xf08744e8)\n mstore(0x20, p0)\n mstore(0x40, 0x60)\n mstore(0x60, p2)\n writeString(0x80, p1)\n }\n _sendLogPayload(0x1c, 0xa4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n }\n }\n\n function log(address p0, bytes32 p1, bool p2) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n // Selector of `log(address,string,bool)`.\n mstore(0x00, 0xcf020fb1)\n mstore(0x20, p0)\n mstore(0x40, 0x60)\n mstore(0x60, p2)\n writeString(0x80, p1)\n }\n _sendLogPayload(0x1c, 0xa4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n }\n }\n\n function log(address p0, bytes32 p1, uint256 p2) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n // Selector of `log(address,string,uint256)`.\n mstore(0x00, 0x67dd6ff1)\n mstore(0x20, p0)\n mstore(0x40, 0x60)\n mstore(0x60, p2)\n writeString(0x80, p1)\n }\n _sendLogPayload(0x1c, 0xa4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n }\n }\n\n function log(address p0, bytes32 p1, bytes32 p2) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n // Selector of `log(address,string,string)`.\n mstore(0x00, 0xfb772265)\n mstore(0x20, p0)\n mstore(0x40, 0x60)\n mstore(0x60, 0xa0)\n writeString(0x80, p1)\n writeString(0xc0, p2)\n }\n _sendLogPayload(0x1c, 0xe4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n }\n }\n\n function log(bool p0, address p1, address p2) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n // Selector of `log(bool,address,address)`.\n mstore(0x00, 0xd2763667)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n }\n _sendLogPayload(0x1c, 0x64);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n }\n }\n\n function log(bool p0, address p1, bool p2) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n // Selector of `log(bool,address,bool)`.\n mstore(0x00, 0x18c9c746)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n }\n _sendLogPayload(0x1c, 0x64);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n }\n }\n\n function log(bool p0, address p1, uint256 p2) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n // Selector of `log(bool,address,uint256)`.\n mstore(0x00, 0x5f7b9afb)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n }\n _sendLogPayload(0x1c, 0x64);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n }\n }\n\n function log(bool p0, address p1, bytes32 p2) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n // Selector of `log(bool,address,string)`.\n mstore(0x00, 0xde9a9270)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, 0x60)\n writeString(0x80, p2)\n }\n _sendLogPayload(0x1c, 0xa4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n }\n }\n\n function log(bool p0, bool p1, address p2) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n // Selector of `log(bool,bool,address)`.\n mstore(0x00, 0x1078f68d)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n }\n _sendLogPayload(0x1c, 0x64);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n }\n }\n\n function log(bool p0, bool p1, bool p2) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n // Selector of `log(bool,bool,bool)`.\n mstore(0x00, 0x50709698)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n }\n _sendLogPayload(0x1c, 0x64);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n }\n }\n\n function log(bool p0, bool p1, uint256 p2) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n // Selector of `log(bool,bool,uint256)`.\n mstore(0x00, 0x12f21602)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n }\n _sendLogPayload(0x1c, 0x64);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n }\n }\n\n function log(bool p0, bool p1, bytes32 p2) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n // Selector of `log(bool,bool,string)`.\n mstore(0x00, 0x2555fa46)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, 0x60)\n writeString(0x80, p2)\n }\n _sendLogPayload(0x1c, 0xa4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n }\n }\n\n function log(bool p0, uint256 p1, address p2) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n // Selector of `log(bool,uint256,address)`.\n mstore(0x00, 0x088ef9d2)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n }\n _sendLogPayload(0x1c, 0x64);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n }\n }\n\n function log(bool p0, uint256 p1, bool p2) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n // Selector of `log(bool,uint256,bool)`.\n mstore(0x00, 0xe8defba9)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n }\n _sendLogPayload(0x1c, 0x64);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n }\n }\n\n function log(bool p0, uint256 p1, uint256 p2) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n // Selector of `log(bool,uint256,uint256)`.\n mstore(0x00, 0x37103367)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n }\n _sendLogPayload(0x1c, 0x64);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n }\n }\n\n function log(bool p0, uint256 p1, bytes32 p2) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n // Selector of `log(bool,uint256,string)`.\n mstore(0x00, 0xc3fc3970)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, 0x60)\n writeString(0x80, p2)\n }\n _sendLogPayload(0x1c, 0xa4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n }\n }\n\n function log(bool p0, bytes32 p1, address p2) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n // Selector of `log(bool,string,address)`.\n mstore(0x00, 0x9591b953)\n mstore(0x20, p0)\n mstore(0x40, 0x60)\n mstore(0x60, p2)\n writeString(0x80, p1)\n }\n _sendLogPayload(0x1c, 0xa4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n }\n }\n\n function log(bool p0, bytes32 p1, bool p2) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n // Selector of `log(bool,string,bool)`.\n mstore(0x00, 0xdbb4c247)\n mstore(0x20, p0)\n mstore(0x40, 0x60)\n mstore(0x60, p2)\n writeString(0x80, p1)\n }\n _sendLogPayload(0x1c, 0xa4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n }\n }\n\n function log(bool p0, bytes32 p1, uint256 p2) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n // Selector of `log(bool,string,uint256)`.\n mstore(0x00, 0x1093ee11)\n mstore(0x20, p0)\n mstore(0x40, 0x60)\n mstore(0x60, p2)\n writeString(0x80, p1)\n }\n _sendLogPayload(0x1c, 0xa4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n }\n }\n\n function log(bool p0, bytes32 p1, bytes32 p2) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n // Selector of `log(bool,string,string)`.\n mstore(0x00, 0xb076847f)\n mstore(0x20, p0)\n mstore(0x40, 0x60)\n mstore(0x60, 0xa0)\n writeString(0x80, p1)\n writeString(0xc0, p2)\n }\n _sendLogPayload(0x1c, 0xe4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n }\n }\n\n function log(uint256 p0, address p1, address p2) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n // Selector of `log(uint256,address,address)`.\n mstore(0x00, 0xbcfd9be0)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n }\n _sendLogPayload(0x1c, 0x64);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n }\n }\n\n function log(uint256 p0, address p1, bool p2) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n // Selector of `log(uint256,address,bool)`.\n mstore(0x00, 0x9b6ec042)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n }\n _sendLogPayload(0x1c, 0x64);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n }\n }\n\n function log(uint256 p0, address p1, uint256 p2) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n // Selector of `log(uint256,address,uint256)`.\n mstore(0x00, 0x5a9b5ed5)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n }\n _sendLogPayload(0x1c, 0x64);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n }\n }\n\n function log(uint256 p0, address p1, bytes32 p2) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n // Selector of `log(uint256,address,string)`.\n mstore(0x00, 0x63cb41f9)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, 0x60)\n writeString(0x80, p2)\n }\n _sendLogPayload(0x1c, 0xa4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n }\n }\n\n function log(uint256 p0, bool p1, address p2) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n // Selector of `log(uint256,bool,address)`.\n mstore(0x00, 0x35085f7b)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n }\n _sendLogPayload(0x1c, 0x64);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n }\n }\n\n function log(uint256 p0, bool p1, bool p2) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n // Selector of `log(uint256,bool,bool)`.\n mstore(0x00, 0x20718650)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n }\n _sendLogPayload(0x1c, 0x64);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n }\n }\n\n function log(uint256 p0, bool p1, uint256 p2) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n // Selector of `log(uint256,bool,uint256)`.\n mstore(0x00, 0x20098014)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n }\n _sendLogPayload(0x1c, 0x64);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n }\n }\n\n function log(uint256 p0, bool p1, bytes32 p2) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n // Selector of `log(uint256,bool,string)`.\n mstore(0x00, 0x85775021)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, 0x60)\n writeString(0x80, p2)\n }\n _sendLogPayload(0x1c, 0xa4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n }\n }\n\n function log(uint256 p0, uint256 p1, address p2) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n // Selector of `log(uint256,uint256,address)`.\n mstore(0x00, 0x5c96b331)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n }\n _sendLogPayload(0x1c, 0x64);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n }\n }\n\n function log(uint256 p0, uint256 p1, bool p2) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n // Selector of `log(uint256,uint256,bool)`.\n mstore(0x00, 0x4766da72)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n }\n _sendLogPayload(0x1c, 0x64);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n }\n }\n\n function log(uint256 p0, uint256 p1, uint256 p2) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n // Selector of `log(uint256,uint256,uint256)`.\n mstore(0x00, 0xd1ed7a3c)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n }\n _sendLogPayload(0x1c, 0x64);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n }\n }\n\n function log(uint256 p0, uint256 p1, bytes32 p2) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n // Selector of `log(uint256,uint256,string)`.\n mstore(0x00, 0x71d04af2)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, 0x60)\n writeString(0x80, p2)\n }\n _sendLogPayload(0x1c, 0xa4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n }\n }\n\n function log(uint256 p0, bytes32 p1, address p2) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n // Selector of `log(uint256,string,address)`.\n mstore(0x00, 0x7afac959)\n mstore(0x20, p0)\n mstore(0x40, 0x60)\n mstore(0x60, p2)\n writeString(0x80, p1)\n }\n _sendLogPayload(0x1c, 0xa4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n }\n }\n\n function log(uint256 p0, bytes32 p1, bool p2) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n // Selector of `log(uint256,string,bool)`.\n mstore(0x00, 0x4ceda75a)\n mstore(0x20, p0)\n mstore(0x40, 0x60)\n mstore(0x60, p2)\n writeString(0x80, p1)\n }\n _sendLogPayload(0x1c, 0xa4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n }\n }\n\n function log(uint256 p0, bytes32 p1, uint256 p2) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n // Selector of `log(uint256,string,uint256)`.\n mstore(0x00, 0x37aa7d4c)\n mstore(0x20, p0)\n mstore(0x40, 0x60)\n mstore(0x60, p2)\n writeString(0x80, p1)\n }\n _sendLogPayload(0x1c, 0xa4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n }\n }\n\n function log(uint256 p0, bytes32 p1, bytes32 p2) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n // Selector of `log(uint256,string,string)`.\n mstore(0x00, 0xb115611f)\n mstore(0x20, p0)\n mstore(0x40, 0x60)\n mstore(0x60, 0xa0)\n writeString(0x80, p1)\n writeString(0xc0, p2)\n }\n _sendLogPayload(0x1c, 0xe4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n }\n }\n\n function log(bytes32 p0, address p1, address p2) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n // Selector of `log(string,address,address)`.\n mstore(0x00, 0xfcec75e0)\n mstore(0x20, 0x60)\n mstore(0x40, p1)\n mstore(0x60, p2)\n writeString(0x80, p0)\n }\n _sendLogPayload(0x1c, 0xa4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n }\n }\n\n function log(bytes32 p0, address p1, bool p2) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n // Selector of `log(string,address,bool)`.\n mstore(0x00, 0xc91d5ed4)\n mstore(0x20, 0x60)\n mstore(0x40, p1)\n mstore(0x60, p2)\n writeString(0x80, p0)\n }\n _sendLogPayload(0x1c, 0xa4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n }\n }\n\n function log(bytes32 p0, address p1, uint256 p2) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n // Selector of `log(string,address,uint256)`.\n mstore(0x00, 0x0d26b925)\n mstore(0x20, 0x60)\n mstore(0x40, p1)\n mstore(0x60, p2)\n writeString(0x80, p0)\n }\n _sendLogPayload(0x1c, 0xa4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n }\n }\n\n function log(bytes32 p0, address p1, bytes32 p2) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n // Selector of `log(string,address,string)`.\n mstore(0x00, 0xe0e9ad4f)\n mstore(0x20, 0x60)\n mstore(0x40, p1)\n mstore(0x60, 0xa0)\n writeString(0x80, p0)\n writeString(0xc0, p2)\n }\n _sendLogPayload(0x1c, 0xe4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n }\n }\n\n function log(bytes32 p0, bool p1, address p2) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n // Selector of `log(string,bool,address)`.\n mstore(0x00, 0x932bbb38)\n mstore(0x20, 0x60)\n mstore(0x40, p1)\n mstore(0x60, p2)\n writeString(0x80, p0)\n }\n _sendLogPayload(0x1c, 0xa4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n }\n }\n\n function log(bytes32 p0, bool p1, bool p2) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n // Selector of `log(string,bool,bool)`.\n mstore(0x00, 0x850b7ad6)\n mstore(0x20, 0x60)\n mstore(0x40, p1)\n mstore(0x60, p2)\n writeString(0x80, p0)\n }\n _sendLogPayload(0x1c, 0xa4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n }\n }\n\n function log(bytes32 p0, bool p1, uint256 p2) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n // Selector of `log(string,bool,uint256)`.\n mstore(0x00, 0xc95958d6)\n mstore(0x20, 0x60)\n mstore(0x40, p1)\n mstore(0x60, p2)\n writeString(0x80, p0)\n }\n _sendLogPayload(0x1c, 0xa4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n }\n }\n\n function log(bytes32 p0, bool p1, bytes32 p2) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n // Selector of `log(string,bool,string)`.\n mstore(0x00, 0xe298f47d)\n mstore(0x20, 0x60)\n mstore(0x40, p1)\n mstore(0x60, 0xa0)\n writeString(0x80, p0)\n writeString(0xc0, p2)\n }\n _sendLogPayload(0x1c, 0xe4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n }\n }\n\n function log(bytes32 p0, uint256 p1, address p2) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n // Selector of `log(string,uint256,address)`.\n mstore(0x00, 0x1c7ec448)\n mstore(0x20, 0x60)\n mstore(0x40, p1)\n mstore(0x60, p2)\n writeString(0x80, p0)\n }\n _sendLogPayload(0x1c, 0xa4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n }\n }\n\n function log(bytes32 p0, uint256 p1, bool p2) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n // Selector of `log(string,uint256,bool)`.\n mstore(0x00, 0xca7733b1)\n mstore(0x20, 0x60)\n mstore(0x40, p1)\n mstore(0x60, p2)\n writeString(0x80, p0)\n }\n _sendLogPayload(0x1c, 0xa4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n }\n }\n\n function log(bytes32 p0, uint256 p1, uint256 p2) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n // Selector of `log(string,uint256,uint256)`.\n mstore(0x00, 0xca47c4eb)\n mstore(0x20, 0x60)\n mstore(0x40, p1)\n mstore(0x60, p2)\n writeString(0x80, p0)\n }\n _sendLogPayload(0x1c, 0xa4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n }\n }\n\n function log(bytes32 p0, uint256 p1, bytes32 p2) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n // Selector of `log(string,uint256,string)`.\n mstore(0x00, 0x5970e089)\n mstore(0x20, 0x60)\n mstore(0x40, p1)\n mstore(0x60, 0xa0)\n writeString(0x80, p0)\n writeString(0xc0, p2)\n }\n _sendLogPayload(0x1c, 0xe4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n }\n }\n\n function log(bytes32 p0, bytes32 p1, address p2) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n // Selector of `log(string,string,address)`.\n mstore(0x00, 0x95ed0195)\n mstore(0x20, 0x60)\n mstore(0x40, 0xa0)\n mstore(0x60, p2)\n writeString(0x80, p0)\n writeString(0xc0, p1)\n }\n _sendLogPayload(0x1c, 0xe4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n }\n }\n\n function log(bytes32 p0, bytes32 p1, bool p2) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n // Selector of `log(string,string,bool)`.\n mstore(0x00, 0xb0e0f9b5)\n mstore(0x20, 0x60)\n mstore(0x40, 0xa0)\n mstore(0x60, p2)\n writeString(0x80, p0)\n writeString(0xc0, p1)\n }\n _sendLogPayload(0x1c, 0xe4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n }\n }\n\n function log(bytes32 p0, bytes32 p1, uint256 p2) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n // Selector of `log(string,string,uint256)`.\n mstore(0x00, 0x5821efa1)\n mstore(0x20, 0x60)\n mstore(0x40, 0xa0)\n mstore(0x60, p2)\n writeString(0x80, p0)\n writeString(0xc0, p1)\n }\n _sendLogPayload(0x1c, 0xe4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n }\n }\n\n function log(bytes32 p0, bytes32 p1, bytes32 p2) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n bytes32 m9;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n m9 := mload(0x120)\n // Selector of `log(string,string,string)`.\n mstore(0x00, 0x2ced7cef)\n mstore(0x20, 0x60)\n mstore(0x40, 0xa0)\n mstore(0x60, 0xe0)\n writeString(0x80, p0)\n writeString(0xc0, p1)\n writeString(0x100, p2)\n }\n _sendLogPayload(0x1c, 0x124);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n mstore(0x120, m9)\n }\n }\n\n function log(address p0, address p1, address p2, address p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(address,address,address,address)`.\n mstore(0x00, 0x665bf134)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(address p0, address p1, address p2, bool p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(address,address,address,bool)`.\n mstore(0x00, 0x0e378994)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(address p0, address p1, address p2, uint256 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(address,address,address,uint256)`.\n mstore(0x00, 0x94250d77)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(address p0, address p1, address p2, bytes32 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(address,address,address,string)`.\n mstore(0x00, 0xf808da20)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, 0x80)\n writeString(0xa0, p3)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(address p0, address p1, bool p2, address p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(address,address,bool,address)`.\n mstore(0x00, 0x9f1bc36e)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(address p0, address p1, bool p2, bool p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(address,address,bool,bool)`.\n mstore(0x00, 0x2cd4134a)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(address p0, address p1, bool p2, uint256 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(address,address,bool,uint256)`.\n mstore(0x00, 0x3971e78c)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(address p0, address p1, bool p2, bytes32 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(address,address,bool,string)`.\n mstore(0x00, 0xaa6540c8)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, 0x80)\n writeString(0xa0, p3)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(address p0, address p1, uint256 p2, address p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(address,address,uint256,address)`.\n mstore(0x00, 0x8da6def5)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(address p0, address p1, uint256 p2, bool p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(address,address,uint256,bool)`.\n mstore(0x00, 0x9b4254e2)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(address p0, address p1, uint256 p2, uint256 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(address,address,uint256,uint256)`.\n mstore(0x00, 0xbe553481)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(address p0, address p1, uint256 p2, bytes32 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(address,address,uint256,string)`.\n mstore(0x00, 0xfdb4f990)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, 0x80)\n writeString(0xa0, p3)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(address p0, address p1, bytes32 p2, address p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(address,address,string,address)`.\n mstore(0x00, 0x8f736d16)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, 0x80)\n mstore(0x80, p3)\n writeString(0xa0, p2)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(address p0, address p1, bytes32 p2, bool p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(address,address,string,bool)`.\n mstore(0x00, 0x6f1a594e)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, 0x80)\n mstore(0x80, p3)\n writeString(0xa0, p2)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(address p0, address p1, bytes32 p2, uint256 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(address,address,string,uint256)`.\n mstore(0x00, 0xef1cefe7)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, 0x80)\n mstore(0x80, p3)\n writeString(0xa0, p2)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(address p0, address p1, bytes32 p2, bytes32 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n // Selector of `log(address,address,string,string)`.\n mstore(0x00, 0x21bdaf25)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, 0x80)\n mstore(0x80, 0xc0)\n writeString(0xa0, p2)\n writeString(0xe0, p3)\n }\n _sendLogPayload(0x1c, 0x104);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n }\n }\n\n function log(address p0, bool p1, address p2, address p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(address,bool,address,address)`.\n mstore(0x00, 0x660375dd)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(address p0, bool p1, address p2, bool p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(address,bool,address,bool)`.\n mstore(0x00, 0xa6f50b0f)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(address p0, bool p1, address p2, uint256 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(address,bool,address,uint256)`.\n mstore(0x00, 0xa75c59de)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(address p0, bool p1, address p2, bytes32 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(address,bool,address,string)`.\n mstore(0x00, 0x2dd778e6)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, 0x80)\n writeString(0xa0, p3)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(address p0, bool p1, bool p2, address p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(address,bool,bool,address)`.\n mstore(0x00, 0xcf394485)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(address p0, bool p1, bool p2, bool p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(address,bool,bool,bool)`.\n mstore(0x00, 0xcac43479)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(address p0, bool p1, bool p2, uint256 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(address,bool,bool,uint256)`.\n mstore(0x00, 0x8c4e5de6)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(address p0, bool p1, bool p2, bytes32 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(address,bool,bool,string)`.\n mstore(0x00, 0xdfc4a2e8)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, 0x80)\n writeString(0xa0, p3)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(address p0, bool p1, uint256 p2, address p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(address,bool,uint256,address)`.\n mstore(0x00, 0xccf790a1)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(address p0, bool p1, uint256 p2, bool p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(address,bool,uint256,bool)`.\n mstore(0x00, 0xc4643e20)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(address p0, bool p1, uint256 p2, uint256 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(address,bool,uint256,uint256)`.\n mstore(0x00, 0x386ff5f4)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(address p0, bool p1, uint256 p2, bytes32 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(address,bool,uint256,string)`.\n mstore(0x00, 0x0aa6cfad)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, 0x80)\n writeString(0xa0, p3)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(address p0, bool p1, bytes32 p2, address p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(address,bool,string,address)`.\n mstore(0x00, 0x19fd4956)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, 0x80)\n mstore(0x80, p3)\n writeString(0xa0, p2)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(address p0, bool p1, bytes32 p2, bool p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(address,bool,string,bool)`.\n mstore(0x00, 0x50ad461d)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, 0x80)\n mstore(0x80, p3)\n writeString(0xa0, p2)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(address p0, bool p1, bytes32 p2, uint256 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(address,bool,string,uint256)`.\n mstore(0x00, 0x80e6a20b)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, 0x80)\n mstore(0x80, p3)\n writeString(0xa0, p2)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(address p0, bool p1, bytes32 p2, bytes32 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n // Selector of `log(address,bool,string,string)`.\n mstore(0x00, 0x475c5c33)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, 0x80)\n mstore(0x80, 0xc0)\n writeString(0xa0, p2)\n writeString(0xe0, p3)\n }\n _sendLogPayload(0x1c, 0x104);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n }\n }\n\n function log(address p0, uint256 p1, address p2, address p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(address,uint256,address,address)`.\n mstore(0x00, 0x478d1c62)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(address p0, uint256 p1, address p2, bool p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(address,uint256,address,bool)`.\n mstore(0x00, 0xa1bcc9b3)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(address p0, uint256 p1, address p2, uint256 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(address,uint256,address,uint256)`.\n mstore(0x00, 0x100f650e)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(address p0, uint256 p1, address p2, bytes32 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(address,uint256,address,string)`.\n mstore(0x00, 0x1da986ea)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, 0x80)\n writeString(0xa0, p3)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(address p0, uint256 p1, bool p2, address p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(address,uint256,bool,address)`.\n mstore(0x00, 0xa31bfdcc)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(address p0, uint256 p1, bool p2, bool p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(address,uint256,bool,bool)`.\n mstore(0x00, 0x3bf5e537)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(address p0, uint256 p1, bool p2, uint256 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(address,uint256,bool,uint256)`.\n mstore(0x00, 0x22f6b999)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(address p0, uint256 p1, bool p2, bytes32 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(address,uint256,bool,string)`.\n mstore(0x00, 0xc5ad85f9)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, 0x80)\n writeString(0xa0, p3)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(address p0, uint256 p1, uint256 p2, address p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(address,uint256,uint256,address)`.\n mstore(0x00, 0x20e3984d)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(address p0, uint256 p1, uint256 p2, bool p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(address,uint256,uint256,bool)`.\n mstore(0x00, 0x66f1bc67)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(address p0, uint256 p1, uint256 p2, uint256 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(address,uint256,uint256,uint256)`.\n mstore(0x00, 0x34f0e636)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(address p0, uint256 p1, uint256 p2, bytes32 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(address,uint256,uint256,string)`.\n mstore(0x00, 0x4a28c017)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, 0x80)\n writeString(0xa0, p3)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(address p0, uint256 p1, bytes32 p2, address p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(address,uint256,string,address)`.\n mstore(0x00, 0x5c430d47)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, 0x80)\n mstore(0x80, p3)\n writeString(0xa0, p2)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(address p0, uint256 p1, bytes32 p2, bool p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(address,uint256,string,bool)`.\n mstore(0x00, 0xcf18105c)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, 0x80)\n mstore(0x80, p3)\n writeString(0xa0, p2)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(address p0, uint256 p1, bytes32 p2, uint256 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(address,uint256,string,uint256)`.\n mstore(0x00, 0xbf01f891)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, 0x80)\n mstore(0x80, p3)\n writeString(0xa0, p2)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(address p0, uint256 p1, bytes32 p2, bytes32 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n // Selector of `log(address,uint256,string,string)`.\n mstore(0x00, 0x88a8c406)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, 0x80)\n mstore(0x80, 0xc0)\n writeString(0xa0, p2)\n writeString(0xe0, p3)\n }\n _sendLogPayload(0x1c, 0x104);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n }\n }\n\n function log(address p0, bytes32 p1, address p2, address p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(address,string,address,address)`.\n mstore(0x00, 0x0d36fa20)\n mstore(0x20, p0)\n mstore(0x40, 0x80)\n mstore(0x60, p2)\n mstore(0x80, p3)\n writeString(0xa0, p1)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(address p0, bytes32 p1, address p2, bool p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(address,string,address,bool)`.\n mstore(0x00, 0x0df12b76)\n mstore(0x20, p0)\n mstore(0x40, 0x80)\n mstore(0x60, p2)\n mstore(0x80, p3)\n writeString(0xa0, p1)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(address p0, bytes32 p1, address p2, uint256 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(address,string,address,uint256)`.\n mstore(0x00, 0x457fe3cf)\n mstore(0x20, p0)\n mstore(0x40, 0x80)\n mstore(0x60, p2)\n mstore(0x80, p3)\n writeString(0xa0, p1)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(address p0, bytes32 p1, address p2, bytes32 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n // Selector of `log(address,string,address,string)`.\n mstore(0x00, 0xf7e36245)\n mstore(0x20, p0)\n mstore(0x40, 0x80)\n mstore(0x60, p2)\n mstore(0x80, 0xc0)\n writeString(0xa0, p1)\n writeString(0xe0, p3)\n }\n _sendLogPayload(0x1c, 0x104);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n }\n }\n\n function log(address p0, bytes32 p1, bool p2, address p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(address,string,bool,address)`.\n mstore(0x00, 0x205871c2)\n mstore(0x20, p0)\n mstore(0x40, 0x80)\n mstore(0x60, p2)\n mstore(0x80, p3)\n writeString(0xa0, p1)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(address p0, bytes32 p1, bool p2, bool p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(address,string,bool,bool)`.\n mstore(0x00, 0x5f1d5c9f)\n mstore(0x20, p0)\n mstore(0x40, 0x80)\n mstore(0x60, p2)\n mstore(0x80, p3)\n writeString(0xa0, p1)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(address p0, bytes32 p1, bool p2, uint256 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(address,string,bool,uint256)`.\n mstore(0x00, 0x515e38b6)\n mstore(0x20, p0)\n mstore(0x40, 0x80)\n mstore(0x60, p2)\n mstore(0x80, p3)\n writeString(0xa0, p1)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(address p0, bytes32 p1, bool p2, bytes32 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n // Selector of `log(address,string,bool,string)`.\n mstore(0x00, 0xbc0b61fe)\n mstore(0x20, p0)\n mstore(0x40, 0x80)\n mstore(0x60, p2)\n mstore(0x80, 0xc0)\n writeString(0xa0, p1)\n writeString(0xe0, p3)\n }\n _sendLogPayload(0x1c, 0x104);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n }\n }\n\n function log(address p0, bytes32 p1, uint256 p2, address p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(address,string,uint256,address)`.\n mstore(0x00, 0x63183678)\n mstore(0x20, p0)\n mstore(0x40, 0x80)\n mstore(0x60, p2)\n mstore(0x80, p3)\n writeString(0xa0, p1)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(address p0, bytes32 p1, uint256 p2, bool p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(address,string,uint256,bool)`.\n mstore(0x00, 0x0ef7e050)\n mstore(0x20, p0)\n mstore(0x40, 0x80)\n mstore(0x60, p2)\n mstore(0x80, p3)\n writeString(0xa0, p1)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(address p0, bytes32 p1, uint256 p2, uint256 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(address,string,uint256,uint256)`.\n mstore(0x00, 0x1dc8e1b8)\n mstore(0x20, p0)\n mstore(0x40, 0x80)\n mstore(0x60, p2)\n mstore(0x80, p3)\n writeString(0xa0, p1)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(address p0, bytes32 p1, uint256 p2, bytes32 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n // Selector of `log(address,string,uint256,string)`.\n mstore(0x00, 0x448830a8)\n mstore(0x20, p0)\n mstore(0x40, 0x80)\n mstore(0x60, p2)\n mstore(0x80, 0xc0)\n writeString(0xa0, p1)\n writeString(0xe0, p3)\n }\n _sendLogPayload(0x1c, 0x104);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n }\n }\n\n function log(address p0, bytes32 p1, bytes32 p2, address p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n // Selector of `log(address,string,string,address)`.\n mstore(0x00, 0xa04e2f87)\n mstore(0x20, p0)\n mstore(0x40, 0x80)\n mstore(0x60, 0xc0)\n mstore(0x80, p3)\n writeString(0xa0, p1)\n writeString(0xe0, p2)\n }\n _sendLogPayload(0x1c, 0x104);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n }\n }\n\n function log(address p0, bytes32 p1, bytes32 p2, bool p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n // Selector of `log(address,string,string,bool)`.\n mstore(0x00, 0x35a5071f)\n mstore(0x20, p0)\n mstore(0x40, 0x80)\n mstore(0x60, 0xc0)\n mstore(0x80, p3)\n writeString(0xa0, p1)\n writeString(0xe0, p2)\n }\n _sendLogPayload(0x1c, 0x104);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n }\n }\n\n function log(address p0, bytes32 p1, bytes32 p2, uint256 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n // Selector of `log(address,string,string,uint256)`.\n mstore(0x00, 0x159f8927)\n mstore(0x20, p0)\n mstore(0x40, 0x80)\n mstore(0x60, 0xc0)\n mstore(0x80, p3)\n writeString(0xa0, p1)\n writeString(0xe0, p2)\n }\n _sendLogPayload(0x1c, 0x104);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n }\n }\n\n function log(address p0, bytes32 p1, bytes32 p2, bytes32 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n bytes32 m9;\n bytes32 m10;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n m9 := mload(0x120)\n m10 := mload(0x140)\n // Selector of `log(address,string,string,string)`.\n mstore(0x00, 0x5d02c50b)\n mstore(0x20, p0)\n mstore(0x40, 0x80)\n mstore(0x60, 0xc0)\n mstore(0x80, 0x100)\n writeString(0xa0, p1)\n writeString(0xe0, p2)\n writeString(0x120, p3)\n }\n _sendLogPayload(0x1c, 0x144);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n mstore(0x120, m9)\n mstore(0x140, m10)\n }\n }\n\n function log(bool p0, address p1, address p2, address p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(bool,address,address,address)`.\n mstore(0x00, 0x1d14d001)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(bool p0, address p1, address p2, bool p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(bool,address,address,bool)`.\n mstore(0x00, 0x46600be0)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(bool p0, address p1, address p2, uint256 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(bool,address,address,uint256)`.\n mstore(0x00, 0x0c66d1be)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(bool p0, address p1, address p2, bytes32 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(bool,address,address,string)`.\n mstore(0x00, 0xd812a167)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, 0x80)\n writeString(0xa0, p3)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(bool p0, address p1, bool p2, address p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(bool,address,bool,address)`.\n mstore(0x00, 0x1c41a336)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(bool p0, address p1, bool p2, bool p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(bool,address,bool,bool)`.\n mstore(0x00, 0x6a9c478b)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(bool p0, address p1, bool p2, uint256 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(bool,address,bool,uint256)`.\n mstore(0x00, 0x07831502)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(bool p0, address p1, bool p2, bytes32 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(bool,address,bool,string)`.\n mstore(0x00, 0x4a66cb34)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, 0x80)\n writeString(0xa0, p3)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(bool p0, address p1, uint256 p2, address p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(bool,address,uint256,address)`.\n mstore(0x00, 0x136b05dd)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(bool p0, address p1, uint256 p2, bool p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(bool,address,uint256,bool)`.\n mstore(0x00, 0xd6019f1c)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(bool p0, address p1, uint256 p2, uint256 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(bool,address,uint256,uint256)`.\n mstore(0x00, 0x7bf181a1)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(bool p0, address p1, uint256 p2, bytes32 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(bool,address,uint256,string)`.\n mstore(0x00, 0x51f09ff8)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, 0x80)\n writeString(0xa0, p3)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(bool p0, address p1, bytes32 p2, address p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(bool,address,string,address)`.\n mstore(0x00, 0x6f7c603e)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, 0x80)\n mstore(0x80, p3)\n writeString(0xa0, p2)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(bool p0, address p1, bytes32 p2, bool p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(bool,address,string,bool)`.\n mstore(0x00, 0xe2bfd60b)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, 0x80)\n mstore(0x80, p3)\n writeString(0xa0, p2)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(bool p0, address p1, bytes32 p2, uint256 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(bool,address,string,uint256)`.\n mstore(0x00, 0xc21f64c7)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, 0x80)\n mstore(0x80, p3)\n writeString(0xa0, p2)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(bool p0, address p1, bytes32 p2, bytes32 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n // Selector of `log(bool,address,string,string)`.\n mstore(0x00, 0xa73c1db6)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, 0x80)\n mstore(0x80, 0xc0)\n writeString(0xa0, p2)\n writeString(0xe0, p3)\n }\n _sendLogPayload(0x1c, 0x104);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n }\n }\n\n function log(bool p0, bool p1, address p2, address p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(bool,bool,address,address)`.\n mstore(0x00, 0xf4880ea4)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(bool p0, bool p1, address p2, bool p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(bool,bool,address,bool)`.\n mstore(0x00, 0xc0a302d8)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(bool p0, bool p1, address p2, uint256 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(bool,bool,address,uint256)`.\n mstore(0x00, 0x4c123d57)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(bool p0, bool p1, address p2, bytes32 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(bool,bool,address,string)`.\n mstore(0x00, 0xa0a47963)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, 0x80)\n writeString(0xa0, p3)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(bool p0, bool p1, bool p2, address p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(bool,bool,bool,address)`.\n mstore(0x00, 0x8c329b1a)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(bool p0, bool p1, bool p2, bool p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(bool,bool,bool,bool)`.\n mstore(0x00, 0x3b2a5ce0)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(bool p0, bool p1, bool p2, uint256 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(bool,bool,bool,uint256)`.\n mstore(0x00, 0x6d7045c1)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(bool p0, bool p1, bool p2, bytes32 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(bool,bool,bool,string)`.\n mstore(0x00, 0x2ae408d4)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, 0x80)\n writeString(0xa0, p3)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(bool p0, bool p1, uint256 p2, address p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(bool,bool,uint256,address)`.\n mstore(0x00, 0x54a7a9a0)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(bool p0, bool p1, uint256 p2, bool p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(bool,bool,uint256,bool)`.\n mstore(0x00, 0x619e4d0e)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(bool p0, bool p1, uint256 p2, uint256 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(bool,bool,uint256,uint256)`.\n mstore(0x00, 0x0bb00eab)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(bool p0, bool p1, uint256 p2, bytes32 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(bool,bool,uint256,string)`.\n mstore(0x00, 0x7dd4d0e0)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, 0x80)\n writeString(0xa0, p3)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(bool p0, bool p1, bytes32 p2, address p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(bool,bool,string,address)`.\n mstore(0x00, 0xf9ad2b89)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, 0x80)\n mstore(0x80, p3)\n writeString(0xa0, p2)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(bool p0, bool p1, bytes32 p2, bool p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(bool,bool,string,bool)`.\n mstore(0x00, 0xb857163a)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, 0x80)\n mstore(0x80, p3)\n writeString(0xa0, p2)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(bool p0, bool p1, bytes32 p2, uint256 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(bool,bool,string,uint256)`.\n mstore(0x00, 0xe3a9ca2f)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, 0x80)\n mstore(0x80, p3)\n writeString(0xa0, p2)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(bool p0, bool p1, bytes32 p2, bytes32 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n // Selector of `log(bool,bool,string,string)`.\n mstore(0x00, 0x6d1e8751)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, 0x80)\n mstore(0x80, 0xc0)\n writeString(0xa0, p2)\n writeString(0xe0, p3)\n }\n _sendLogPayload(0x1c, 0x104);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n }\n }\n\n function log(bool p0, uint256 p1, address p2, address p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(bool,uint256,address,address)`.\n mstore(0x00, 0x26f560a8)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(bool p0, uint256 p1, address p2, bool p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(bool,uint256,address,bool)`.\n mstore(0x00, 0xb4c314ff)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(bool p0, uint256 p1, address p2, uint256 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(bool,uint256,address,uint256)`.\n mstore(0x00, 0x1537dc87)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(bool p0, uint256 p1, address p2, bytes32 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(bool,uint256,address,string)`.\n mstore(0x00, 0x1bb3b09a)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, 0x80)\n writeString(0xa0, p3)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(bool p0, uint256 p1, bool p2, address p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(bool,uint256,bool,address)`.\n mstore(0x00, 0x9acd3616)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(bool p0, uint256 p1, bool p2, bool p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(bool,uint256,bool,bool)`.\n mstore(0x00, 0xceb5f4d7)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(bool p0, uint256 p1, bool p2, uint256 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(bool,uint256,bool,uint256)`.\n mstore(0x00, 0x7f9bbca2)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(bool p0, uint256 p1, bool p2, bytes32 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(bool,uint256,bool,string)`.\n mstore(0x00, 0x9143dbb1)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, 0x80)\n writeString(0xa0, p3)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(bool p0, uint256 p1, uint256 p2, address p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(bool,uint256,uint256,address)`.\n mstore(0x00, 0x00dd87b9)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(bool p0, uint256 p1, uint256 p2, bool p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(bool,uint256,uint256,bool)`.\n mstore(0x00, 0xbe984353)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(bool p0, uint256 p1, uint256 p2, uint256 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(bool,uint256,uint256,uint256)`.\n mstore(0x00, 0x374bb4b2)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(bool p0, uint256 p1, uint256 p2, bytes32 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(bool,uint256,uint256,string)`.\n mstore(0x00, 0x8e69fb5d)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, 0x80)\n writeString(0xa0, p3)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(bool p0, uint256 p1, bytes32 p2, address p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(bool,uint256,string,address)`.\n mstore(0x00, 0xfedd1fff)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, 0x80)\n mstore(0x80, p3)\n writeString(0xa0, p2)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(bool p0, uint256 p1, bytes32 p2, bool p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(bool,uint256,string,bool)`.\n mstore(0x00, 0xe5e70b2b)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, 0x80)\n mstore(0x80, p3)\n writeString(0xa0, p2)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(bool p0, uint256 p1, bytes32 p2, uint256 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(bool,uint256,string,uint256)`.\n mstore(0x00, 0x6a1199e2)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, 0x80)\n mstore(0x80, p3)\n writeString(0xa0, p2)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(bool p0, uint256 p1, bytes32 p2, bytes32 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n // Selector of `log(bool,uint256,string,string)`.\n mstore(0x00, 0xf5bc2249)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, 0x80)\n mstore(0x80, 0xc0)\n writeString(0xa0, p2)\n writeString(0xe0, p3)\n }\n _sendLogPayload(0x1c, 0x104);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n }\n }\n\n function log(bool p0, bytes32 p1, address p2, address p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(bool,string,address,address)`.\n mstore(0x00, 0x2b2b18dc)\n mstore(0x20, p0)\n mstore(0x40, 0x80)\n mstore(0x60, p2)\n mstore(0x80, p3)\n writeString(0xa0, p1)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(bool p0, bytes32 p1, address p2, bool p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(bool,string,address,bool)`.\n mstore(0x00, 0x6dd434ca)\n mstore(0x20, p0)\n mstore(0x40, 0x80)\n mstore(0x60, p2)\n mstore(0x80, p3)\n writeString(0xa0, p1)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(bool p0, bytes32 p1, address p2, uint256 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(bool,string,address,uint256)`.\n mstore(0x00, 0xa5cada94)\n mstore(0x20, p0)\n mstore(0x40, 0x80)\n mstore(0x60, p2)\n mstore(0x80, p3)\n writeString(0xa0, p1)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(bool p0, bytes32 p1, address p2, bytes32 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n // Selector of `log(bool,string,address,string)`.\n mstore(0x00, 0x12d6c788)\n mstore(0x20, p0)\n mstore(0x40, 0x80)\n mstore(0x60, p2)\n mstore(0x80, 0xc0)\n writeString(0xa0, p1)\n writeString(0xe0, p3)\n }\n _sendLogPayload(0x1c, 0x104);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n }\n }\n\n function log(bool p0, bytes32 p1, bool p2, address p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(bool,string,bool,address)`.\n mstore(0x00, 0x538e06ab)\n mstore(0x20, p0)\n mstore(0x40, 0x80)\n mstore(0x60, p2)\n mstore(0x80, p3)\n writeString(0xa0, p1)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(bool p0, bytes32 p1, bool p2, bool p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(bool,string,bool,bool)`.\n mstore(0x00, 0xdc5e935b)\n mstore(0x20, p0)\n mstore(0x40, 0x80)\n mstore(0x60, p2)\n mstore(0x80, p3)\n writeString(0xa0, p1)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(bool p0, bytes32 p1, bool p2, uint256 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(bool,string,bool,uint256)`.\n mstore(0x00, 0x1606a393)\n mstore(0x20, p0)\n mstore(0x40, 0x80)\n mstore(0x60, p2)\n mstore(0x80, p3)\n writeString(0xa0, p1)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(bool p0, bytes32 p1, bool p2, bytes32 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n // Selector of `log(bool,string,bool,string)`.\n mstore(0x00, 0x483d0416)\n mstore(0x20, p0)\n mstore(0x40, 0x80)\n mstore(0x60, p2)\n mstore(0x80, 0xc0)\n writeString(0xa0, p1)\n writeString(0xe0, p3)\n }\n _sendLogPayload(0x1c, 0x104);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n }\n }\n\n function log(bool p0, bytes32 p1, uint256 p2, address p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(bool,string,uint256,address)`.\n mstore(0x00, 0x1596a1ce)\n mstore(0x20, p0)\n mstore(0x40, 0x80)\n mstore(0x60, p2)\n mstore(0x80, p3)\n writeString(0xa0, p1)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(bool p0, bytes32 p1, uint256 p2, bool p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(bool,string,uint256,bool)`.\n mstore(0x00, 0x6b0e5d53)\n mstore(0x20, p0)\n mstore(0x40, 0x80)\n mstore(0x60, p2)\n mstore(0x80, p3)\n writeString(0xa0, p1)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(bool p0, bytes32 p1, uint256 p2, uint256 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(bool,string,uint256,uint256)`.\n mstore(0x00, 0x28863fcb)\n mstore(0x20, p0)\n mstore(0x40, 0x80)\n mstore(0x60, p2)\n mstore(0x80, p3)\n writeString(0xa0, p1)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(bool p0, bytes32 p1, uint256 p2, bytes32 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n // Selector of `log(bool,string,uint256,string)`.\n mstore(0x00, 0x1ad96de6)\n mstore(0x20, p0)\n mstore(0x40, 0x80)\n mstore(0x60, p2)\n mstore(0x80, 0xc0)\n writeString(0xa0, p1)\n writeString(0xe0, p3)\n }\n _sendLogPayload(0x1c, 0x104);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n }\n }\n\n function log(bool p0, bytes32 p1, bytes32 p2, address p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n // Selector of `log(bool,string,string,address)`.\n mstore(0x00, 0x97d394d8)\n mstore(0x20, p0)\n mstore(0x40, 0x80)\n mstore(0x60, 0xc0)\n mstore(0x80, p3)\n writeString(0xa0, p1)\n writeString(0xe0, p2)\n }\n _sendLogPayload(0x1c, 0x104);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n }\n }\n\n function log(bool p0, bytes32 p1, bytes32 p2, bool p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n // Selector of `log(bool,string,string,bool)`.\n mstore(0x00, 0x1e4b87e5)\n mstore(0x20, p0)\n mstore(0x40, 0x80)\n mstore(0x60, 0xc0)\n mstore(0x80, p3)\n writeString(0xa0, p1)\n writeString(0xe0, p2)\n }\n _sendLogPayload(0x1c, 0x104);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n }\n }\n\n function log(bool p0, bytes32 p1, bytes32 p2, uint256 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n // Selector of `log(bool,string,string,uint256)`.\n mstore(0x00, 0x7be0c3eb)\n mstore(0x20, p0)\n mstore(0x40, 0x80)\n mstore(0x60, 0xc0)\n mstore(0x80, p3)\n writeString(0xa0, p1)\n writeString(0xe0, p2)\n }\n _sendLogPayload(0x1c, 0x104);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n }\n }\n\n function log(bool p0, bytes32 p1, bytes32 p2, bytes32 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n bytes32 m9;\n bytes32 m10;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n m9 := mload(0x120)\n m10 := mload(0x140)\n // Selector of `log(bool,string,string,string)`.\n mstore(0x00, 0x1762e32a)\n mstore(0x20, p0)\n mstore(0x40, 0x80)\n mstore(0x60, 0xc0)\n mstore(0x80, 0x100)\n writeString(0xa0, p1)\n writeString(0xe0, p2)\n writeString(0x120, p3)\n }\n _sendLogPayload(0x1c, 0x144);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n mstore(0x120, m9)\n mstore(0x140, m10)\n }\n }\n\n function log(uint256 p0, address p1, address p2, address p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(uint256,address,address,address)`.\n mstore(0x00, 0x2488b414)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(uint256 p0, address p1, address p2, bool p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(uint256,address,address,bool)`.\n mstore(0x00, 0x091ffaf5)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(uint256 p0, address p1, address p2, uint256 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(uint256,address,address,uint256)`.\n mstore(0x00, 0x736efbb6)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(uint256 p0, address p1, address p2, bytes32 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(uint256,address,address,string)`.\n mstore(0x00, 0x031c6f73)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, 0x80)\n writeString(0xa0, p3)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(uint256 p0, address p1, bool p2, address p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(uint256,address,bool,address)`.\n mstore(0x00, 0xef72c513)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(uint256 p0, address p1, bool p2, bool p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(uint256,address,bool,bool)`.\n mstore(0x00, 0xe351140f)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(uint256 p0, address p1, bool p2, uint256 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(uint256,address,bool,uint256)`.\n mstore(0x00, 0x5abd992a)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(uint256 p0, address p1, bool p2, bytes32 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(uint256,address,bool,string)`.\n mstore(0x00, 0x90fb06aa)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, 0x80)\n writeString(0xa0, p3)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(uint256 p0, address p1, uint256 p2, address p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(uint256,address,uint256,address)`.\n mstore(0x00, 0x15c127b5)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(uint256 p0, address p1, uint256 p2, bool p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(uint256,address,uint256,bool)`.\n mstore(0x00, 0x5f743a7c)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(uint256 p0, address p1, uint256 p2, uint256 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(uint256,address,uint256,uint256)`.\n mstore(0x00, 0x0c9cd9c1)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(uint256 p0, address p1, uint256 p2, bytes32 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(uint256,address,uint256,string)`.\n mstore(0x00, 0xddb06521)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, 0x80)\n writeString(0xa0, p3)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(uint256 p0, address p1, bytes32 p2, address p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(uint256,address,string,address)`.\n mstore(0x00, 0x9cba8fff)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, 0x80)\n mstore(0x80, p3)\n writeString(0xa0, p2)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(uint256 p0, address p1, bytes32 p2, bool p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(uint256,address,string,bool)`.\n mstore(0x00, 0xcc32ab07)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, 0x80)\n mstore(0x80, p3)\n writeString(0xa0, p2)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(uint256 p0, address p1, bytes32 p2, uint256 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(uint256,address,string,uint256)`.\n mstore(0x00, 0x46826b5d)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, 0x80)\n mstore(0x80, p3)\n writeString(0xa0, p2)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(uint256 p0, address p1, bytes32 p2, bytes32 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n // Selector of `log(uint256,address,string,string)`.\n mstore(0x00, 0x3e128ca3)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, 0x80)\n mstore(0x80, 0xc0)\n writeString(0xa0, p2)\n writeString(0xe0, p3)\n }\n _sendLogPayload(0x1c, 0x104);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n }\n }\n\n function log(uint256 p0, bool p1, address p2, address p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(uint256,bool,address,address)`.\n mstore(0x00, 0xa1ef4cbb)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(uint256 p0, bool p1, address p2, bool p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(uint256,bool,address,bool)`.\n mstore(0x00, 0x454d54a5)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(uint256 p0, bool p1, address p2, uint256 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(uint256,bool,address,uint256)`.\n mstore(0x00, 0x078287f5)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(uint256 p0, bool p1, address p2, bytes32 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(uint256,bool,address,string)`.\n mstore(0x00, 0xade052c7)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, 0x80)\n writeString(0xa0, p3)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(uint256 p0, bool p1, bool p2, address p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(uint256,bool,bool,address)`.\n mstore(0x00, 0x69640b59)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(uint256 p0, bool p1, bool p2, bool p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(uint256,bool,bool,bool)`.\n mstore(0x00, 0xb6f577a1)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(uint256 p0, bool p1, bool p2, uint256 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(uint256,bool,bool,uint256)`.\n mstore(0x00, 0x7464ce23)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(uint256 p0, bool p1, bool p2, bytes32 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(uint256,bool,bool,string)`.\n mstore(0x00, 0xdddb9561)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, 0x80)\n writeString(0xa0, p3)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(uint256 p0, bool p1, uint256 p2, address p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(uint256,bool,uint256,address)`.\n mstore(0x00, 0x88cb6041)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(uint256 p0, bool p1, uint256 p2, bool p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(uint256,bool,uint256,bool)`.\n mstore(0x00, 0x91a02e2a)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(uint256 p0, bool p1, uint256 p2, uint256 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(uint256,bool,uint256,uint256)`.\n mstore(0x00, 0xc6acc7a8)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(uint256 p0, bool p1, uint256 p2, bytes32 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(uint256,bool,uint256,string)`.\n mstore(0x00, 0xde03e774)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, 0x80)\n writeString(0xa0, p3)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(uint256 p0, bool p1, bytes32 p2, address p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(uint256,bool,string,address)`.\n mstore(0x00, 0xef529018)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, 0x80)\n mstore(0x80, p3)\n writeString(0xa0, p2)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(uint256 p0, bool p1, bytes32 p2, bool p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(uint256,bool,string,bool)`.\n mstore(0x00, 0xeb928d7f)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, 0x80)\n mstore(0x80, p3)\n writeString(0xa0, p2)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(uint256 p0, bool p1, bytes32 p2, uint256 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(uint256,bool,string,uint256)`.\n mstore(0x00, 0x2c1d0746)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, 0x80)\n mstore(0x80, p3)\n writeString(0xa0, p2)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(uint256 p0, bool p1, bytes32 p2, bytes32 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n // Selector of `log(uint256,bool,string,string)`.\n mstore(0x00, 0x68c8b8bd)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, 0x80)\n mstore(0x80, 0xc0)\n writeString(0xa0, p2)\n writeString(0xe0, p3)\n }\n _sendLogPayload(0x1c, 0x104);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n }\n }\n\n function log(uint256 p0, uint256 p1, address p2, address p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(uint256,uint256,address,address)`.\n mstore(0x00, 0x56a5d1b1)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(uint256 p0, uint256 p1, address p2, bool p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(uint256,uint256,address,bool)`.\n mstore(0x00, 0x15cac476)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(uint256 p0, uint256 p1, address p2, uint256 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(uint256,uint256,address,uint256)`.\n mstore(0x00, 0x88f6e4b2)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(uint256 p0, uint256 p1, address p2, bytes32 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(uint256,uint256,address,string)`.\n mstore(0x00, 0x6cde40b8)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, 0x80)\n writeString(0xa0, p3)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(uint256 p0, uint256 p1, bool p2, address p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(uint256,uint256,bool,address)`.\n mstore(0x00, 0x9a816a83)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(uint256 p0, uint256 p1, bool p2, bool p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(uint256,uint256,bool,bool)`.\n mstore(0x00, 0xab085ae6)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(uint256 p0, uint256 p1, bool p2, uint256 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(uint256,uint256,bool,uint256)`.\n mstore(0x00, 0xeb7f6fd2)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(uint256 p0, uint256 p1, bool p2, bytes32 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(uint256,uint256,bool,string)`.\n mstore(0x00, 0xa5b4fc99)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, 0x80)\n writeString(0xa0, p3)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(uint256 p0, uint256 p1, uint256 p2, address p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(uint256,uint256,uint256,address)`.\n mstore(0x00, 0xfa8185af)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(uint256 p0, uint256 p1, uint256 p2, bool p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(uint256,uint256,uint256,bool)`.\n mstore(0x00, 0xc598d185)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(uint256 p0, uint256 p1, uint256 p2, uint256 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(uint256,uint256,uint256,uint256)`.\n mstore(0x00, 0x193fb800)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(uint256 p0, uint256 p1, uint256 p2, bytes32 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(uint256,uint256,uint256,string)`.\n mstore(0x00, 0x59cfcbe3)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, 0x80)\n writeString(0xa0, p3)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(uint256 p0, uint256 p1, bytes32 p2, address p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(uint256,uint256,string,address)`.\n mstore(0x00, 0x42d21db7)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, 0x80)\n mstore(0x80, p3)\n writeString(0xa0, p2)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(uint256 p0, uint256 p1, bytes32 p2, bool p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(uint256,uint256,string,bool)`.\n mstore(0x00, 0x7af6ab25)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, 0x80)\n mstore(0x80, p3)\n writeString(0xa0, p2)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(uint256 p0, uint256 p1, bytes32 p2, uint256 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(uint256,uint256,string,uint256)`.\n mstore(0x00, 0x5da297eb)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, 0x80)\n mstore(0x80, p3)\n writeString(0xa0, p2)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(uint256 p0, uint256 p1, bytes32 p2, bytes32 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n // Selector of `log(uint256,uint256,string,string)`.\n mstore(0x00, 0x27d8afd2)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, 0x80)\n mstore(0x80, 0xc0)\n writeString(0xa0, p2)\n writeString(0xe0, p3)\n }\n _sendLogPayload(0x1c, 0x104);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n }\n }\n\n function log(uint256 p0, bytes32 p1, address p2, address p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(uint256,string,address,address)`.\n mstore(0x00, 0x6168ed61)\n mstore(0x20, p0)\n mstore(0x40, 0x80)\n mstore(0x60, p2)\n mstore(0x80, p3)\n writeString(0xa0, p1)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(uint256 p0, bytes32 p1, address p2, bool p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(uint256,string,address,bool)`.\n mstore(0x00, 0x90c30a56)\n mstore(0x20, p0)\n mstore(0x40, 0x80)\n mstore(0x60, p2)\n mstore(0x80, p3)\n writeString(0xa0, p1)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(uint256 p0, bytes32 p1, address p2, uint256 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(uint256,string,address,uint256)`.\n mstore(0x00, 0xe8d3018d)\n mstore(0x20, p0)\n mstore(0x40, 0x80)\n mstore(0x60, p2)\n mstore(0x80, p3)\n writeString(0xa0, p1)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(uint256 p0, bytes32 p1, address p2, bytes32 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n // Selector of `log(uint256,string,address,string)`.\n mstore(0x00, 0x9c3adfa1)\n mstore(0x20, p0)\n mstore(0x40, 0x80)\n mstore(0x60, p2)\n mstore(0x80, 0xc0)\n writeString(0xa0, p1)\n writeString(0xe0, p3)\n }\n _sendLogPayload(0x1c, 0x104);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n }\n }\n\n function log(uint256 p0, bytes32 p1, bool p2, address p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(uint256,string,bool,address)`.\n mstore(0x00, 0xae2ec581)\n mstore(0x20, p0)\n mstore(0x40, 0x80)\n mstore(0x60, p2)\n mstore(0x80, p3)\n writeString(0xa0, p1)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(uint256 p0, bytes32 p1, bool p2, bool p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(uint256,string,bool,bool)`.\n mstore(0x00, 0xba535d9c)\n mstore(0x20, p0)\n mstore(0x40, 0x80)\n mstore(0x60, p2)\n mstore(0x80, p3)\n writeString(0xa0, p1)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(uint256 p0, bytes32 p1, bool p2, uint256 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(uint256,string,bool,uint256)`.\n mstore(0x00, 0xcf009880)\n mstore(0x20, p0)\n mstore(0x40, 0x80)\n mstore(0x60, p2)\n mstore(0x80, p3)\n writeString(0xa0, p1)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(uint256 p0, bytes32 p1, bool p2, bytes32 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n // Selector of `log(uint256,string,bool,string)`.\n mstore(0x00, 0xd2d423cd)\n mstore(0x20, p0)\n mstore(0x40, 0x80)\n mstore(0x60, p2)\n mstore(0x80, 0xc0)\n writeString(0xa0, p1)\n writeString(0xe0, p3)\n }\n _sendLogPayload(0x1c, 0x104);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n }\n }\n\n function log(uint256 p0, bytes32 p1, uint256 p2, address p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(uint256,string,uint256,address)`.\n mstore(0x00, 0x3b2279b4)\n mstore(0x20, p0)\n mstore(0x40, 0x80)\n mstore(0x60, p2)\n mstore(0x80, p3)\n writeString(0xa0, p1)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(uint256 p0, bytes32 p1, uint256 p2, bool p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(uint256,string,uint256,bool)`.\n mstore(0x00, 0x691a8f74)\n mstore(0x20, p0)\n mstore(0x40, 0x80)\n mstore(0x60, p2)\n mstore(0x80, p3)\n writeString(0xa0, p1)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(uint256 p0, bytes32 p1, uint256 p2, uint256 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(uint256,string,uint256,uint256)`.\n mstore(0x00, 0x82c25b74)\n mstore(0x20, p0)\n mstore(0x40, 0x80)\n mstore(0x60, p2)\n mstore(0x80, p3)\n writeString(0xa0, p1)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(uint256 p0, bytes32 p1, uint256 p2, bytes32 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n // Selector of `log(uint256,string,uint256,string)`.\n mstore(0x00, 0xb7b914ca)\n mstore(0x20, p0)\n mstore(0x40, 0x80)\n mstore(0x60, p2)\n mstore(0x80, 0xc0)\n writeString(0xa0, p1)\n writeString(0xe0, p3)\n }\n _sendLogPayload(0x1c, 0x104);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n }\n }\n\n function log(uint256 p0, bytes32 p1, bytes32 p2, address p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n // Selector of `log(uint256,string,string,address)`.\n mstore(0x00, 0xd583c602)\n mstore(0x20, p0)\n mstore(0x40, 0x80)\n mstore(0x60, 0xc0)\n mstore(0x80, p3)\n writeString(0xa0, p1)\n writeString(0xe0, p2)\n }\n _sendLogPayload(0x1c, 0x104);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n }\n }\n\n function log(uint256 p0, bytes32 p1, bytes32 p2, bool p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n // Selector of `log(uint256,string,string,bool)`.\n mstore(0x00, 0xb3a6b6bd)\n mstore(0x20, p0)\n mstore(0x40, 0x80)\n mstore(0x60, 0xc0)\n mstore(0x80, p3)\n writeString(0xa0, p1)\n writeString(0xe0, p2)\n }\n _sendLogPayload(0x1c, 0x104);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n }\n }\n\n function log(uint256 p0, bytes32 p1, bytes32 p2, uint256 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n // Selector of `log(uint256,string,string,uint256)`.\n mstore(0x00, 0xb028c9bd)\n mstore(0x20, p0)\n mstore(0x40, 0x80)\n mstore(0x60, 0xc0)\n mstore(0x80, p3)\n writeString(0xa0, p1)\n writeString(0xe0, p2)\n }\n _sendLogPayload(0x1c, 0x104);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n }\n }\n\n function log(uint256 p0, bytes32 p1, bytes32 p2, bytes32 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n bytes32 m9;\n bytes32 m10;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n m9 := mload(0x120)\n m10 := mload(0x140)\n // Selector of `log(uint256,string,string,string)`.\n mstore(0x00, 0x21ad0683)\n mstore(0x20, p0)\n mstore(0x40, 0x80)\n mstore(0x60, 0xc0)\n mstore(0x80, 0x100)\n writeString(0xa0, p1)\n writeString(0xe0, p2)\n writeString(0x120, p3)\n }\n _sendLogPayload(0x1c, 0x144);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n mstore(0x120, m9)\n mstore(0x140, m10)\n }\n }\n\n function log(bytes32 p0, address p1, address p2, address p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(string,address,address,address)`.\n mstore(0x00, 0xed8f28f6)\n mstore(0x20, 0x80)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n writeString(0xa0, p0)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(bytes32 p0, address p1, address p2, bool p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(string,address,address,bool)`.\n mstore(0x00, 0xb59dbd60)\n mstore(0x20, 0x80)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n writeString(0xa0, p0)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(bytes32 p0, address p1, address p2, uint256 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(string,address,address,uint256)`.\n mstore(0x00, 0x8ef3f399)\n mstore(0x20, 0x80)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n writeString(0xa0, p0)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(bytes32 p0, address p1, address p2, bytes32 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n // Selector of `log(string,address,address,string)`.\n mstore(0x00, 0x800a1c67)\n mstore(0x20, 0x80)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, 0xc0)\n writeString(0xa0, p0)\n writeString(0xe0, p3)\n }\n _sendLogPayload(0x1c, 0x104);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n }\n }\n\n function log(bytes32 p0, address p1, bool p2, address p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(string,address,bool,address)`.\n mstore(0x00, 0x223603bd)\n mstore(0x20, 0x80)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n writeString(0xa0, p0)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(bytes32 p0, address p1, bool p2, bool p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(string,address,bool,bool)`.\n mstore(0x00, 0x79884c2b)\n mstore(0x20, 0x80)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n writeString(0xa0, p0)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(bytes32 p0, address p1, bool p2, uint256 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(string,address,bool,uint256)`.\n mstore(0x00, 0x3e9f866a)\n mstore(0x20, 0x80)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n writeString(0xa0, p0)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(bytes32 p0, address p1, bool p2, bytes32 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n // Selector of `log(string,address,bool,string)`.\n mstore(0x00, 0x0454c079)\n mstore(0x20, 0x80)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, 0xc0)\n writeString(0xa0, p0)\n writeString(0xe0, p3)\n }\n _sendLogPayload(0x1c, 0x104);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n }\n }\n\n function log(bytes32 p0, address p1, uint256 p2, address p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(string,address,uint256,address)`.\n mstore(0x00, 0x63fb8bc5)\n mstore(0x20, 0x80)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n writeString(0xa0, p0)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(bytes32 p0, address p1, uint256 p2, bool p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(string,address,uint256,bool)`.\n mstore(0x00, 0xfc4845f0)\n mstore(0x20, 0x80)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n writeString(0xa0, p0)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(bytes32 p0, address p1, uint256 p2, uint256 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(string,address,uint256,uint256)`.\n mstore(0x00, 0xf8f51b1e)\n mstore(0x20, 0x80)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n writeString(0xa0, p0)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(bytes32 p0, address p1, uint256 p2, bytes32 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n // Selector of `log(string,address,uint256,string)`.\n mstore(0x00, 0x5a477632)\n mstore(0x20, 0x80)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, 0xc0)\n writeString(0xa0, p0)\n writeString(0xe0, p3)\n }\n _sendLogPayload(0x1c, 0x104);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n }\n }\n\n function log(bytes32 p0, address p1, bytes32 p2, address p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n // Selector of `log(string,address,string,address)`.\n mstore(0x00, 0xaabc9a31)\n mstore(0x20, 0x80)\n mstore(0x40, p1)\n mstore(0x60, 0xc0)\n mstore(0x80, p3)\n writeString(0xa0, p0)\n writeString(0xe0, p2)\n }\n _sendLogPayload(0x1c, 0x104);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n }\n }\n\n function log(bytes32 p0, address p1, bytes32 p2, bool p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n // Selector of `log(string,address,string,bool)`.\n mstore(0x00, 0x5f15d28c)\n mstore(0x20, 0x80)\n mstore(0x40, p1)\n mstore(0x60, 0xc0)\n mstore(0x80, p3)\n writeString(0xa0, p0)\n writeString(0xe0, p2)\n }\n _sendLogPayload(0x1c, 0x104);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n }\n }\n\n function log(bytes32 p0, address p1, bytes32 p2, uint256 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n // Selector of `log(string,address,string,uint256)`.\n mstore(0x00, 0x91d1112e)\n mstore(0x20, 0x80)\n mstore(0x40, p1)\n mstore(0x60, 0xc0)\n mstore(0x80, p3)\n writeString(0xa0, p0)\n writeString(0xe0, p2)\n }\n _sendLogPayload(0x1c, 0x104);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n }\n }\n\n function log(bytes32 p0, address p1, bytes32 p2, bytes32 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n bytes32 m9;\n bytes32 m10;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n m9 := mload(0x120)\n m10 := mload(0x140)\n // Selector of `log(string,address,string,string)`.\n mstore(0x00, 0x245986f2)\n mstore(0x20, 0x80)\n mstore(0x40, p1)\n mstore(0x60, 0xc0)\n mstore(0x80, 0x100)\n writeString(0xa0, p0)\n writeString(0xe0, p2)\n writeString(0x120, p3)\n }\n _sendLogPayload(0x1c, 0x144);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n mstore(0x120, m9)\n mstore(0x140, m10)\n }\n }\n\n function log(bytes32 p0, bool p1, address p2, address p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(string,bool,address,address)`.\n mstore(0x00, 0x33e9dd1d)\n mstore(0x20, 0x80)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n writeString(0xa0, p0)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(bytes32 p0, bool p1, address p2, bool p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(string,bool,address,bool)`.\n mstore(0x00, 0x958c28c6)\n mstore(0x20, 0x80)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n writeString(0xa0, p0)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(bytes32 p0, bool p1, address p2, uint256 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(string,bool,address,uint256)`.\n mstore(0x00, 0x5d08bb05)\n mstore(0x20, 0x80)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n writeString(0xa0, p0)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(bytes32 p0, bool p1, address p2, bytes32 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n // Selector of `log(string,bool,address,string)`.\n mstore(0x00, 0x2d8e33a4)\n mstore(0x20, 0x80)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, 0xc0)\n writeString(0xa0, p0)\n writeString(0xe0, p3)\n }\n _sendLogPayload(0x1c, 0x104);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n }\n }\n\n function log(bytes32 p0, bool p1, bool p2, address p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(string,bool,bool,address)`.\n mstore(0x00, 0x7190a529)\n mstore(0x20, 0x80)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n writeString(0xa0, p0)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(bytes32 p0, bool p1, bool p2, bool p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(string,bool,bool,bool)`.\n mstore(0x00, 0x895af8c5)\n mstore(0x20, 0x80)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n writeString(0xa0, p0)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(bytes32 p0, bool p1, bool p2, uint256 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(string,bool,bool,uint256)`.\n mstore(0x00, 0x8e3f78a9)\n mstore(0x20, 0x80)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n writeString(0xa0, p0)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(bytes32 p0, bool p1, bool p2, bytes32 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n // Selector of `log(string,bool,bool,string)`.\n mstore(0x00, 0x9d22d5dd)\n mstore(0x20, 0x80)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, 0xc0)\n writeString(0xa0, p0)\n writeString(0xe0, p3)\n }\n _sendLogPayload(0x1c, 0x104);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n }\n }\n\n function log(bytes32 p0, bool p1, uint256 p2, address p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(string,bool,uint256,address)`.\n mstore(0x00, 0x935e09bf)\n mstore(0x20, 0x80)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n writeString(0xa0, p0)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(bytes32 p0, bool p1, uint256 p2, bool p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(string,bool,uint256,bool)`.\n mstore(0x00, 0x8af7cf8a)\n mstore(0x20, 0x80)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n writeString(0xa0, p0)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(bytes32 p0, bool p1, uint256 p2, uint256 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(string,bool,uint256,uint256)`.\n mstore(0x00, 0x64b5bb67)\n mstore(0x20, 0x80)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n writeString(0xa0, p0)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(bytes32 p0, bool p1, uint256 p2, bytes32 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n // Selector of `log(string,bool,uint256,string)`.\n mstore(0x00, 0x742d6ee7)\n mstore(0x20, 0x80)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, 0xc0)\n writeString(0xa0, p0)\n writeString(0xe0, p3)\n }\n _sendLogPayload(0x1c, 0x104);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n }\n }\n\n function log(bytes32 p0, bool p1, bytes32 p2, address p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n // Selector of `log(string,bool,string,address)`.\n mstore(0x00, 0xe0625b29)\n mstore(0x20, 0x80)\n mstore(0x40, p1)\n mstore(0x60, 0xc0)\n mstore(0x80, p3)\n writeString(0xa0, p0)\n writeString(0xe0, p2)\n }\n _sendLogPayload(0x1c, 0x104);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n }\n }\n\n function log(bytes32 p0, bool p1, bytes32 p2, bool p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n // Selector of `log(string,bool,string,bool)`.\n mstore(0x00, 0x3f8a701d)\n mstore(0x20, 0x80)\n mstore(0x40, p1)\n mstore(0x60, 0xc0)\n mstore(0x80, p3)\n writeString(0xa0, p0)\n writeString(0xe0, p2)\n }\n _sendLogPayload(0x1c, 0x104);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n }\n }\n\n function log(bytes32 p0, bool p1, bytes32 p2, uint256 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n // Selector of `log(string,bool,string,uint256)`.\n mstore(0x00, 0x24f91465)\n mstore(0x20, 0x80)\n mstore(0x40, p1)\n mstore(0x60, 0xc0)\n mstore(0x80, p3)\n writeString(0xa0, p0)\n writeString(0xe0, p2)\n }\n _sendLogPayload(0x1c, 0x104);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n }\n }\n\n function log(bytes32 p0, bool p1, bytes32 p2, bytes32 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n bytes32 m9;\n bytes32 m10;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n m9 := mload(0x120)\n m10 := mload(0x140)\n // Selector of `log(string,bool,string,string)`.\n mstore(0x00, 0xa826caeb)\n mstore(0x20, 0x80)\n mstore(0x40, p1)\n mstore(0x60, 0xc0)\n mstore(0x80, 0x100)\n writeString(0xa0, p0)\n writeString(0xe0, p2)\n writeString(0x120, p3)\n }\n _sendLogPayload(0x1c, 0x144);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n mstore(0x120, m9)\n mstore(0x140, m10)\n }\n }\n\n function log(bytes32 p0, uint256 p1, address p2, address p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(string,uint256,address,address)`.\n mstore(0x00, 0x5ea2b7ae)\n mstore(0x20, 0x80)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n writeString(0xa0, p0)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(bytes32 p0, uint256 p1, address p2, bool p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(string,uint256,address,bool)`.\n mstore(0x00, 0x82112a42)\n mstore(0x20, 0x80)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n writeString(0xa0, p0)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(bytes32 p0, uint256 p1, address p2, uint256 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(string,uint256,address,uint256)`.\n mstore(0x00, 0x4f04fdc6)\n mstore(0x20, 0x80)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n writeString(0xa0, p0)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(bytes32 p0, uint256 p1, address p2, bytes32 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n // Selector of `log(string,uint256,address,string)`.\n mstore(0x00, 0x9ffb2f93)\n mstore(0x20, 0x80)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, 0xc0)\n writeString(0xa0, p0)\n writeString(0xe0, p3)\n }\n _sendLogPayload(0x1c, 0x104);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n }\n }\n\n function log(bytes32 p0, uint256 p1, bool p2, address p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(string,uint256,bool,address)`.\n mstore(0x00, 0xe0e95b98)\n mstore(0x20, 0x80)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n writeString(0xa0, p0)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(bytes32 p0, uint256 p1, bool p2, bool p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(string,uint256,bool,bool)`.\n mstore(0x00, 0x354c36d6)\n mstore(0x20, 0x80)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n writeString(0xa0, p0)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(bytes32 p0, uint256 p1, bool p2, uint256 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(string,uint256,bool,uint256)`.\n mstore(0x00, 0xe41b6f6f)\n mstore(0x20, 0x80)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n writeString(0xa0, p0)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(bytes32 p0, uint256 p1, bool p2, bytes32 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n // Selector of `log(string,uint256,bool,string)`.\n mstore(0x00, 0xabf73a98)\n mstore(0x20, 0x80)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, 0xc0)\n writeString(0xa0, p0)\n writeString(0xe0, p3)\n }\n _sendLogPayload(0x1c, 0x104);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n }\n }\n\n function log(bytes32 p0, uint256 p1, uint256 p2, address p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(string,uint256,uint256,address)`.\n mstore(0x00, 0xe21de278)\n mstore(0x20, 0x80)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n writeString(0xa0, p0)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(bytes32 p0, uint256 p1, uint256 p2, bool p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(string,uint256,uint256,bool)`.\n mstore(0x00, 0x7626db92)\n mstore(0x20, 0x80)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n writeString(0xa0, p0)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(bytes32 p0, uint256 p1, uint256 p2, uint256 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(string,uint256,uint256,uint256)`.\n mstore(0x00, 0xa7a87853)\n mstore(0x20, 0x80)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n writeString(0xa0, p0)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(bytes32 p0, uint256 p1, uint256 p2, bytes32 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n // Selector of `log(string,uint256,uint256,string)`.\n mstore(0x00, 0x854b3496)\n mstore(0x20, 0x80)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, 0xc0)\n writeString(0xa0, p0)\n writeString(0xe0, p3)\n }\n _sendLogPayload(0x1c, 0x104);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n }\n }\n\n function log(bytes32 p0, uint256 p1, bytes32 p2, address p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n // Selector of `log(string,uint256,string,address)`.\n mstore(0x00, 0x7c4632a4)\n mstore(0x20, 0x80)\n mstore(0x40, p1)\n mstore(0x60, 0xc0)\n mstore(0x80, p3)\n writeString(0xa0, p0)\n writeString(0xe0, p2)\n }\n _sendLogPayload(0x1c, 0x104);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n }\n }\n\n function log(bytes32 p0, uint256 p1, bytes32 p2, bool p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n // Selector of `log(string,uint256,string,bool)`.\n mstore(0x00, 0x7d24491d)\n mstore(0x20, 0x80)\n mstore(0x40, p1)\n mstore(0x60, 0xc0)\n mstore(0x80, p3)\n writeString(0xa0, p0)\n writeString(0xe0, p2)\n }\n _sendLogPayload(0x1c, 0x104);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n }\n }\n\n function log(bytes32 p0, uint256 p1, bytes32 p2, uint256 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n // Selector of `log(string,uint256,string,uint256)`.\n mstore(0x00, 0xc67ea9d1)\n mstore(0x20, 0x80)\n mstore(0x40, p1)\n mstore(0x60, 0xc0)\n mstore(0x80, p3)\n writeString(0xa0, p0)\n writeString(0xe0, p2)\n }\n _sendLogPayload(0x1c, 0x104);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n }\n }\n\n function log(bytes32 p0, uint256 p1, bytes32 p2, bytes32 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n bytes32 m9;\n bytes32 m10;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n m9 := mload(0x120)\n m10 := mload(0x140)\n // Selector of `log(string,uint256,string,string)`.\n mstore(0x00, 0x5ab84e1f)\n mstore(0x20, 0x80)\n mstore(0x40, p1)\n mstore(0x60, 0xc0)\n mstore(0x80, 0x100)\n writeString(0xa0, p0)\n writeString(0xe0, p2)\n writeString(0x120, p3)\n }\n _sendLogPayload(0x1c, 0x144);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n mstore(0x120, m9)\n mstore(0x140, m10)\n }\n }\n\n function log(bytes32 p0, bytes32 p1, address p2, address p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n // Selector of `log(string,string,address,address)`.\n mstore(0x00, 0x439c7bef)\n mstore(0x20, 0x80)\n mstore(0x40, 0xc0)\n mstore(0x60, p2)\n mstore(0x80, p3)\n writeString(0xa0, p0)\n writeString(0xe0, p1)\n }\n _sendLogPayload(0x1c, 0x104);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n }\n }\n\n function log(bytes32 p0, bytes32 p1, address p2, bool p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n // Selector of `log(string,string,address,bool)`.\n mstore(0x00, 0x5ccd4e37)\n mstore(0x20, 0x80)\n mstore(0x40, 0xc0)\n mstore(0x60, p2)\n mstore(0x80, p3)\n writeString(0xa0, p0)\n writeString(0xe0, p1)\n }\n _sendLogPayload(0x1c, 0x104);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n }\n }\n\n function log(bytes32 p0, bytes32 p1, address p2, uint256 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n // Selector of `log(string,string,address,uint256)`.\n mstore(0x00, 0x7cc3c607)\n mstore(0x20, 0x80)\n mstore(0x40, 0xc0)\n mstore(0x60, p2)\n mstore(0x80, p3)\n writeString(0xa0, p0)\n writeString(0xe0, p1)\n }\n _sendLogPayload(0x1c, 0x104);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n }\n }\n\n function log(bytes32 p0, bytes32 p1, address p2, bytes32 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n bytes32 m9;\n bytes32 m10;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n m9 := mload(0x120)\n m10 := mload(0x140)\n // Selector of `log(string,string,address,string)`.\n mstore(0x00, 0xeb1bff80)\n mstore(0x20, 0x80)\n mstore(0x40, 0xc0)\n mstore(0x60, p2)\n mstore(0x80, 0x100)\n writeString(0xa0, p0)\n writeString(0xe0, p1)\n writeString(0x120, p3)\n }\n _sendLogPayload(0x1c, 0x144);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n mstore(0x120, m9)\n mstore(0x140, m10)\n }\n }\n\n function log(bytes32 p0, bytes32 p1, bool p2, address p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n // Selector of `log(string,string,bool,address)`.\n mstore(0x00, 0xc371c7db)\n mstore(0x20, 0x80)\n mstore(0x40, 0xc0)\n mstore(0x60, p2)\n mstore(0x80, p3)\n writeString(0xa0, p0)\n writeString(0xe0, p1)\n }\n _sendLogPayload(0x1c, 0x104);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n }\n }\n\n function log(bytes32 p0, bytes32 p1, bool p2, bool p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n // Selector of `log(string,string,bool,bool)`.\n mstore(0x00, 0x40785869)\n mstore(0x20, 0x80)\n mstore(0x40, 0xc0)\n mstore(0x60, p2)\n mstore(0x80, p3)\n writeString(0xa0, p0)\n writeString(0xe0, p1)\n }\n _sendLogPayload(0x1c, 0x104);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n }\n }\n\n function log(bytes32 p0, bytes32 p1, bool p2, uint256 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n // Selector of `log(string,string,bool,uint256)`.\n mstore(0x00, 0xd6aefad2)\n mstore(0x20, 0x80)\n mstore(0x40, 0xc0)\n mstore(0x60, p2)\n mstore(0x80, p3)\n writeString(0xa0, p0)\n writeString(0xe0, p1)\n }\n _sendLogPayload(0x1c, 0x104);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n }\n }\n\n function log(bytes32 p0, bytes32 p1, bool p2, bytes32 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n bytes32 m9;\n bytes32 m10;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n m9 := mload(0x120)\n m10 := mload(0x140)\n // Selector of `log(string,string,bool,string)`.\n mstore(0x00, 0x5e84b0ea)\n mstore(0x20, 0x80)\n mstore(0x40, 0xc0)\n mstore(0x60, p2)\n mstore(0x80, 0x100)\n writeString(0xa0, p0)\n writeString(0xe0, p1)\n writeString(0x120, p3)\n }\n _sendLogPayload(0x1c, 0x144);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n mstore(0x120, m9)\n mstore(0x140, m10)\n }\n }\n\n function log(bytes32 p0, bytes32 p1, uint256 p2, address p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n // Selector of `log(string,string,uint256,address)`.\n mstore(0x00, 0x1023f7b2)\n mstore(0x20, 0x80)\n mstore(0x40, 0xc0)\n mstore(0x60, p2)\n mstore(0x80, p3)\n writeString(0xa0, p0)\n writeString(0xe0, p1)\n }\n _sendLogPayload(0x1c, 0x104);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n }\n }\n\n function log(bytes32 p0, bytes32 p1, uint256 p2, bool p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n // Selector of `log(string,string,uint256,bool)`.\n mstore(0x00, 0xc3a8a654)\n mstore(0x20, 0x80)\n mstore(0x40, 0xc0)\n mstore(0x60, p2)\n mstore(0x80, p3)\n writeString(0xa0, p0)\n writeString(0xe0, p1)\n }\n _sendLogPayload(0x1c, 0x104);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n }\n }\n\n function log(bytes32 p0, bytes32 p1, uint256 p2, uint256 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n // Selector of `log(string,string,uint256,uint256)`.\n mstore(0x00, 0xf45d7d2c)\n mstore(0x20, 0x80)\n mstore(0x40, 0xc0)\n mstore(0x60, p2)\n mstore(0x80, p3)\n writeString(0xa0, p0)\n writeString(0xe0, p1)\n }\n _sendLogPayload(0x1c, 0x104);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n }\n }\n\n function log(bytes32 p0, bytes32 p1, uint256 p2, bytes32 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n bytes32 m9;\n bytes32 m10;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n m9 := mload(0x120)\n m10 := mload(0x140)\n // Selector of `log(string,string,uint256,string)`.\n mstore(0x00, 0x5d1a971a)\n mstore(0x20, 0x80)\n mstore(0x40, 0xc0)\n mstore(0x60, p2)\n mstore(0x80, 0x100)\n writeString(0xa0, p0)\n writeString(0xe0, p1)\n writeString(0x120, p3)\n }\n _sendLogPayload(0x1c, 0x144);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n mstore(0x120, m9)\n mstore(0x140, m10)\n }\n }\n\n function log(bytes32 p0, bytes32 p1, bytes32 p2, address p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n bytes32 m9;\n bytes32 m10;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n m9 := mload(0x120)\n m10 := mload(0x140)\n // Selector of `log(string,string,string,address)`.\n mstore(0x00, 0x6d572f44)\n mstore(0x20, 0x80)\n mstore(0x40, 0xc0)\n mstore(0x60, 0x100)\n mstore(0x80, p3)\n writeString(0xa0, p0)\n writeString(0xe0, p1)\n writeString(0x120, p2)\n }\n _sendLogPayload(0x1c, 0x144);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n mstore(0x120, m9)\n mstore(0x140, m10)\n }\n }\n\n function log(bytes32 p0, bytes32 p1, bytes32 p2, bool p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n bytes32 m9;\n bytes32 m10;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n m9 := mload(0x120)\n m10 := mload(0x140)\n // Selector of `log(string,string,string,bool)`.\n mstore(0x00, 0x2c1754ed)\n mstore(0x20, 0x80)\n mstore(0x40, 0xc0)\n mstore(0x60, 0x100)\n mstore(0x80, p3)\n writeString(0xa0, p0)\n writeString(0xe0, p1)\n writeString(0x120, p2)\n }\n _sendLogPayload(0x1c, 0x144);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n mstore(0x120, m9)\n mstore(0x140, m10)\n }\n }\n\n function log(bytes32 p0, bytes32 p1, bytes32 p2, uint256 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n bytes32 m9;\n bytes32 m10;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n m9 := mload(0x120)\n m10 := mload(0x140)\n // Selector of `log(string,string,string,uint256)`.\n mstore(0x00, 0x8eafb02b)\n mstore(0x20, 0x80)\n mstore(0x40, 0xc0)\n mstore(0x60, 0x100)\n mstore(0x80, p3)\n writeString(0xa0, p0)\n writeString(0xe0, p1)\n writeString(0x120, p2)\n }\n _sendLogPayload(0x1c, 0x144);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n mstore(0x120, m9)\n mstore(0x140, m10)\n }\n }\n\n function log(bytes32 p0, bytes32 p1, bytes32 p2, bytes32 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n bytes32 m9;\n bytes32 m10;\n bytes32 m11;\n bytes32 m12;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n m9 := mload(0x120)\n m10 := mload(0x140)\n m11 := mload(0x160)\n m12 := mload(0x180)\n // Selector of `log(string,string,string,string)`.\n mstore(0x00, 0xde68f20a)\n mstore(0x20, 0x80)\n mstore(0x40, 0xc0)\n mstore(0x60, 0x100)\n mstore(0x80, 0x140)\n writeString(0xa0, p0)\n writeString(0xe0, p1)\n writeString(0x120, p2)\n writeString(0x160, p3)\n }\n _sendLogPayload(0x1c, 0x184);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n mstore(0x120, m9)\n mstore(0x140, m10)\n mstore(0x160, m11)\n mstore(0x180, m12)\n }\n }\n}\n","license":"MIT"},"scripts/FetchChainInfo.s.sol":{"keccak256":"0xb90e4f9a834c4dc584b4ad8c0503e35fdd8338533e0e75a7ca497f655ae12821","urls":[],"content":"// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\nimport { Script } from \"forge-std/Script.sol\";\nimport { GameTypes, GameType } from \"src/dispute/lib/Types.sol\";\n\n/// @notice Contains getters for arbitrary methods from all L1 contracts, including legacy getters\n/// that have since been deprecated.\ninterface IFetcher {\n function guardian() external view returns (address);\n function GUARDIAN() external view returns (address);\n function systemConfig() external view returns (address);\n function SYSTEM_CONFIG() external view returns (address);\n function disputeGameFactory() external view returns (address);\n function ethLockbox() external view returns (address);\n function superchainConfig() external view returns (address);\n function messenger() external view returns (address);\n function addressManager() external view returns (address);\n function PORTAL() external view returns (address);\n function portal() external view returns (address);\n function l1ERC721Bridge() external view returns (address);\n function optimismMintableERC20Factory() external view returns (address);\n function gameImpls(GameType _gameType) external view returns (address);\n function respectedGameType() external view returns (GameType);\n function anchorStateRegistry() external view returns (address);\n function L2_ORACLE() external view returns (address);\n function l2Oracle() external view returns (address);\n function vm() external view returns (address);\n function oracle() external view returns (address);\n function challenger() external view returns (address);\n function proposer() external view returns (address);\n function PROPOSER() external view returns (address);\n function batcherHash() external view returns (bytes32);\n function admin() external view returns (address);\n function owner() external view returns (address);\n function unsafeBlockSigner() external view returns (address);\n function weth() external view returns (address);\n}\n\ncontract FetchChainInfoInput {\n address internal _systemConfigProxy;\n address internal _l1StandardBridgeProxy;\n\n function set(bytes4 _sel, address _addr) public {\n require(_addr != address(0), \"FetchChainInfoInput: cannot set zero address\");\n if (_sel == this.systemConfigProxy.selector) _systemConfigProxy = _addr;\n else if (_sel == this.l1StandardBridgeProxy.selector) _l1StandardBridgeProxy = _addr;\n else revert(\"FetchChainInfoInput: unknown selector\");\n }\n\n function systemConfigProxy() public view returns (address) {\n require(_systemConfigProxy != address(0), \"FetchChainInfoInput: systemConfigProxy not set\");\n return _systemConfigProxy;\n }\n\n function l1StandardBridgeProxy() public view returns (address) {\n require(_l1StandardBridgeProxy != address(0), \"FetchChainInfoInput: l1StandardBridgeProxy not set\");\n return _l1StandardBridgeProxy;\n }\n}\n\ncontract FetchChainInfoOutput {\n // contract addresses\n // - SuperchainContracts\n address internal _superchainConfigProxy;\n // - ImplementationsContracts\n address internal _mipsImpl;\n address internal _preimageOracleImpl;\n // - OpChainContracts\n address internal _addressManagerImpl;\n address internal _ethLockboxProxy;\n address internal _l1CrossDomainMessengerProxy;\n address internal _l1Erc721BridgeProxy;\n address internal _l1StandardBridgeProxy;\n address internal _l2OutputOracleProxy;\n address internal _optimismMintableErc20FactoryProxy;\n address internal _optimismPortalProxy;\n address internal _systemConfigProxy;\n address internal _opChainProxyAdminImpl;\n address internal _anchorStateRegistryProxy;\n address internal _delayedWethPermissionedGameProxy;\n address internal _delayedWethPermissionlessGameProxy;\n address internal _disputeGameFactoryProxy;\n address internal _faultDisputeGameImpl;\n address internal _faultDisputeGameCannonKonaImpl;\n address internal _permissionedDisputeGameImpl;\n\n // roles\n address internal _systemConfigOwner;\n address internal _opChainProxyAdminOwner;\n address internal _opChainGuardian;\n address internal _challenger;\n address internal _proposer;\n address internal _unsafeBlockSigner;\n address internal _batchSubmitter;\n\n // fault proof status\n bool internal _permissioned;\n bool internal _permissionless;\n GameType internal _respectedGameType;\n\n function set(bytes4 _sel, address _addr) public {\n // SuperchainContracts\n if (_sel == this.superchainConfigProxy.selector) _superchainConfigProxy = _addr;\n // - ImplementationsContracts\n else if (_sel == this.mipsImpl.selector) _mipsImpl = _addr;\n else if (_sel == this.preimageOracleImpl.selector) _preimageOracleImpl = _addr;\n // - OpChainContracts\n else if (_sel == this.addressManagerImpl.selector) _addressManagerImpl = _addr;\n else if (_sel == this.ethLockboxProxy.selector) _ethLockboxProxy = _addr;\n else if (_sel == this.l1CrossDomainMessengerProxy.selector) _l1CrossDomainMessengerProxy = _addr;\n else if (_sel == this.l1Erc721BridgeProxy.selector) _l1Erc721BridgeProxy = _addr;\n else if (_sel == this.l1StandardBridgeProxy.selector) _l1StandardBridgeProxy = _addr;\n else if (_sel == this.l2OutputOracleProxy.selector) _l2OutputOracleProxy = _addr;\n else if (_sel == this.optimismMintableErc20FactoryProxy.selector) _optimismMintableErc20FactoryProxy = _addr;\n else if (_sel == this.optimismPortalProxy.selector) _optimismPortalProxy = _addr;\n else if (_sel == this.systemConfigProxy.selector) _systemConfigProxy = _addr;\n else if (_sel == this.opChainProxyAdminImpl.selector) _opChainProxyAdminImpl = _addr;\n else if (_sel == this.anchorStateRegistryProxy.selector) _anchorStateRegistryProxy = _addr;\n else if (_sel == this.delayedWethPermissionedGameProxy.selector) _delayedWethPermissionedGameProxy = _addr;\n else if (_sel == this.delayedWethPermissionlessGameProxy.selector) _delayedWethPermissionlessGameProxy = _addr;\n else if (_sel == this.disputeGameFactoryProxy.selector) _disputeGameFactoryProxy = _addr;\n else if (_sel == this.faultDisputeGameImpl.selector) _faultDisputeGameImpl = _addr;\n else if (_sel == this.faultDisputeGameCannonKonaImpl.selector) _faultDisputeGameCannonKonaImpl = _addr;\n else if (_sel == this.permissionedDisputeGameImpl.selector) _permissionedDisputeGameImpl = _addr;\n // roles\n else if (_sel == this.systemConfigOwner.selector) _systemConfigOwner = _addr;\n else if (_sel == this.opChainProxyAdminOwner.selector) _opChainProxyAdminOwner = _addr;\n else if (_sel == this.opChainGuardian.selector) _opChainGuardian = _addr;\n else if (_sel == this.challenger.selector) _challenger = _addr;\n else if (_sel == this.proposer.selector) _proposer = _addr;\n else if (_sel == this.unsafeBlockSigner.selector) _unsafeBlockSigner = _addr;\n else if (_sel == this.batchSubmitter.selector) _batchSubmitter = _addr;\n else revert(\"FetchChainInfoOutput: unknown address selector test\");\n }\n\n function set(bytes4 _sel, bool _bool) public {\n if (_sel == this.permissioned.selector) _permissioned = _bool;\n else if (_sel == this.permissionless.selector) _permissionless = _bool;\n else revert(\"FetchChainInfoOutput: unknown bool selector\");\n }\n\n function set(bytes4 _sel, GameType _gameType) public {\n if (_sel == this.respectedGameType.selector) _respectedGameType = _gameType;\n else revert(\"FetchChainInfoOutput: unknown GameType selector\");\n }\n\n function addressManagerImpl() public view returns (address) {\n require(_addressManagerImpl != address(0), \"FetchChainInfoOutput: addressManagerImpl not set\");\n return _addressManagerImpl;\n }\n\n function ethLockboxProxy() public view returns (address) {\n return _ethLockboxProxy;\n }\n\n function l1CrossDomainMessengerProxy() public view returns (address) {\n require(_l1CrossDomainMessengerProxy != address(0), \"FetchChainInfoOutput: l1CrossDomainMessengerProxy not set\");\n return _l1CrossDomainMessengerProxy;\n }\n\n function l1Erc721BridgeProxy() public view returns (address) {\n require(_l1Erc721BridgeProxy != address(0), \"FetchChainInfoOutput: l1Erc721BridgeProxy not set\");\n return _l1Erc721BridgeProxy;\n }\n\n function l1StandardBridgeProxy() public view returns (address) {\n require(_l1StandardBridgeProxy != address(0), \"FetchChainInfoOutput: l1StandardBridgeProxy not set\");\n return _l1StandardBridgeProxy;\n }\n\n function l2OutputOracleProxy() public view returns (address) {\n require(_l2OutputOracleProxy != address(0), \"FetchChainInfoOutput: l2OutputOracleProxy not set\");\n return _l2OutputOracleProxy;\n }\n\n function optimismMintableErc20FactoryProxy() public view returns (address) {\n require(\n _optimismMintableErc20FactoryProxy != address(0),\n \"FetchChainInfoOutput: optimismMintableErc20FactoryProxy not set\"\n );\n return _optimismMintableErc20FactoryProxy;\n }\n\n function optimismPortalProxy() public view returns (address) {\n require(_optimismPortalProxy != address(0), \"FetchChainInfoOutput: optimismPortalProxy not set\");\n return _optimismPortalProxy;\n }\n\n function systemConfigProxy() public view returns (address) {\n require(_systemConfigProxy != address(0), \"FetchChainInfoOutput: systemConfigProxy not set\");\n return _systemConfigProxy;\n }\n\n function opChainProxyAdminImpl() public view returns (address) {\n require(_opChainProxyAdminImpl != address(0), \"FetchChainInfoOutput: opChainProxyAdminImpl not set\");\n return _opChainProxyAdminImpl;\n }\n\n function superchainConfigProxy() public view returns (address) {\n require(_superchainConfigProxy != address(0), \"FetchChainInfoOutput: superchainConfigProxy not set\");\n return _superchainConfigProxy;\n }\n\n function anchorStateRegistryProxy() public view returns (address) {\n require(_anchorStateRegistryProxy != address(0), \"FetchChainInfoOutput: anchorStateRegistryProxy not set\");\n return _anchorStateRegistryProxy;\n }\n\n function delayedWethPermissionedGameProxy() public view returns (address) {\n return _delayedWethPermissionedGameProxy;\n }\n\n function delayedWethPermissionlessGameProxy() public view returns (address) {\n return _delayedWethPermissionlessGameProxy;\n }\n\n function disputeGameFactoryProxy() public view returns (address) {\n return _disputeGameFactoryProxy;\n }\n\n function faultDisputeGameImpl() public view returns (address) {\n require(_faultDisputeGameImpl != address(0), \"FetchChainInfoOutput: faultDisputeGameImpl not set\");\n return _faultDisputeGameImpl;\n }\n\n function faultDisputeGameCannonKonaImpl() public view returns (address) {\n require(\n _faultDisputeGameCannonKonaImpl != address(0),\n \"FetchChainInfoOutput: faultDisputeGameCannonKonaImpl not set\"\n );\n return _faultDisputeGameCannonKonaImpl;\n }\n\n function mipsImpl() public view returns (address) {\n require(_mipsImpl != address(0), \"FetchChainInfoOutput: mipsImpl not set\");\n return _mipsImpl;\n }\n\n function permissionedDisputeGameImpl() public view returns (address) {\n require(_permissionedDisputeGameImpl != address(0), \"FetchChainInfoOutput: permissionedDisputeGameImpl not set\");\n return _permissionedDisputeGameImpl;\n }\n\n function preimageOracleImpl() public view returns (address) {\n require(_preimageOracleImpl != address(0), \"FetchChainInfoOutput: preimageOracleImpl not set\");\n return _preimageOracleImpl;\n }\n\n function systemConfigOwner() public view returns (address) {\n require(_systemConfigOwner != address(0), \"FetchChainInfoOutput: systemConfigOwner not set\");\n return _systemConfigOwner;\n }\n\n function opChainProxyAdminOwner() public view returns (address) {\n require(_opChainProxyAdminOwner != address(0), \"FetchChainInfoOutput: opChainProxyAdminOwner not set\");\n return _opChainProxyAdminOwner;\n }\n\n function opChainGuardian() public view returns (address) {\n require(_opChainGuardian != address(0), \"FetchChainInfoOutput: opChainGuardian not set\");\n return _opChainGuardian;\n }\n\n function challenger() public view returns (address) {\n require(_challenger != address(0), \"FetchChainInfoOutput: challenger not set\");\n return _challenger;\n }\n\n function proposer() public view returns (address) {\n require(_proposer != address(0), \"FetchChainInfoOutput: proposer not set\");\n return _proposer;\n }\n\n function unsafeBlockSigner() public view returns (address) {\n require(_unsafeBlockSigner != address(0), \"FetchChainInfoOutput: unsafeBlockSigner not set\");\n return _unsafeBlockSigner;\n }\n\n function batchSubmitter() public view returns (address) {\n require(_batchSubmitter != address(0), \"FetchChainInfoOutput: batchSubmitter not set\");\n return _batchSubmitter;\n }\n\n function permissioned() public view returns (bool) {\n return _permissioned;\n }\n\n function permissionless() public view returns (bool) {\n return _permissionless;\n }\n\n function respectedGameType() public view returns (GameType) {\n return _respectedGameType;\n }\n}\n\ncontract FetchChainInfo is Script {\n function run(FetchChainInfoInput _fi, FetchChainInfoOutput _fo) public {\n _processSystemConfig(_fi, _fo);\n _processMessengerAndPortal(_fi, _fo);\n _processFaultProofs(_fo);\n }\n\n function _processSystemConfig(FetchChainInfoInput _fi, FetchChainInfoOutput _fo) internal {\n address systemConfigProxy = _fi.systemConfigProxy();\n _fo.set(_fo.systemConfigProxy.selector, systemConfigProxy);\n\n address systemConfigOwner = IFetcher(systemConfigProxy).owner();\n _fo.set(_fo.systemConfigOwner.selector, systemConfigOwner);\n\n address unsafeBlockSigner = IFetcher(systemConfigProxy).unsafeBlockSigner();\n _fo.set(_fo.unsafeBlockSigner.selector, unsafeBlockSigner);\n\n address batchSubmitter = _getBatchSubmitter(systemConfigProxy);\n _fo.set(_fo.batchSubmitter.selector, batchSubmitter);\n\n address opChainProxyAdminImpl = _getProxyAdmin(systemConfigProxy);\n _fo.set(_fo.opChainProxyAdminImpl.selector, opChainProxyAdminImpl);\n\n address opChainProxyAdminOwner = IFetcher(opChainProxyAdminImpl).owner();\n _fo.set(_fo.opChainProxyAdminOwner.selector, opChainProxyAdminOwner);\n\n address l1Erc721BridgeProxy = _getL1ERC721BridgeProxy(systemConfigProxy);\n _fo.set(_fo.l1Erc721BridgeProxy.selector, l1Erc721BridgeProxy);\n\n address optimismMintableErc20FactoryProxy = _getOptimismMintableERC20FactoryProxy(systemConfigProxy);\n _fo.set(_fo.optimismMintableErc20FactoryProxy.selector, optimismMintableErc20FactoryProxy);\n }\n\n function _processMessengerAndPortal(FetchChainInfoInput _fi, FetchChainInfoOutput _fo) internal {\n address l1StandardBridgeProxy = _fi.l1StandardBridgeProxy();\n _fo.set(_fo.l1StandardBridgeProxy.selector, l1StandardBridgeProxy);\n\n address l1CrossDomainMessengerProxy = IFetcher(l1StandardBridgeProxy).messenger();\n _fo.set(_fo.l1CrossDomainMessengerProxy.selector, l1CrossDomainMessengerProxy);\n\n address addressManagerImpl = _getAddressManager(l1CrossDomainMessengerProxy);\n _fo.set(_fo.addressManagerImpl.selector, addressManagerImpl);\n\n address optimismPortalProxy = _getOptimismPortalProxy(l1CrossDomainMessengerProxy);\n _fo.set(_fo.optimismPortalProxy.selector, optimismPortalProxy);\n\n address opChainGuardian = _getGuardian(optimismPortalProxy);\n _fo.set(_fo.opChainGuardian.selector, opChainGuardian);\n\n address ethLockboxProxy = _getEthLockboxProxy(optimismPortalProxy);\n _fo.set(_fo.ethLockboxProxy.selector, ethLockboxProxy);\n\n address superchainConfigProxy = _getSuperchainConfigProxy(optimismPortalProxy);\n _fo.set(_fo.superchainConfigProxy.selector, superchainConfigProxy);\n }\n\n function _processFaultProofs(FetchChainInfoOutput _fo) internal {\n address systemConfigProxy = _fo.systemConfigProxy();\n address optimismPortalProxy = _fo.optimismPortalProxy();\n\n try IFetcher(optimismPortalProxy).respectedGameType() returns (GameType gameType_) {\n _fo.set(_fo.respectedGameType.selector, gameType_);\n } catch {\n // default respectedGameType to uint32.max since 0 == CANNON\n _fo.set(_fo.respectedGameType.selector, GameType.wrap(type(uint32).max));\n address l2OutputOracleProxy;\n try IFetcher(optimismPortalProxy).l2Oracle() returns (address l2Oracle_) {\n l2OutputOracleProxy = l2Oracle_;\n } catch {\n l2OutputOracleProxy = IFetcher(optimismPortalProxy).L2_ORACLE();\n }\n _fo.set(_fo.l2OutputOracleProxy.selector, l2OutputOracleProxy);\n\n address proposer = IFetcher(l2OutputOracleProxy).PROPOSER();\n _fo.set(_fo.proposer.selector, proposer);\n\n // no fault proofs installed so we're done\n return;\n }\n\n address disputeGameFactoryProxy = _getDisputeGameFactoryProxy(systemConfigProxy);\n if (disputeGameFactoryProxy != address(0)) {\n _fo.set(_fo.disputeGameFactoryProxy.selector, disputeGameFactoryProxy);\n\n address permissionedDisputeGameImpl = _getPermissionedDisputeGame(disputeGameFactoryProxy);\n if (permissionedDisputeGameImpl != address(0)) {\n // permissioned fault proofs installed\n _fo.set(_fo.permissioned.selector, true);\n _fo.set(_fo.permissionedDisputeGameImpl.selector, permissionedDisputeGameImpl);\n\n address challenger = IFetcher(permissionedDisputeGameImpl).challenger();\n _fo.set(_fo.challenger.selector, challenger);\n\n address anchorStateRegistryProxy = IFetcher(permissionedDisputeGameImpl).anchorStateRegistry();\n _fo.set(_fo.anchorStateRegistryProxy.selector, anchorStateRegistryProxy);\n\n address proposer = IFetcher(permissionedDisputeGameImpl).proposer();\n _fo.set(_fo.proposer.selector, proposer);\n\n address delayedWethPermissionedGameProxy = _getDelayedWETHProxy(permissionedDisputeGameImpl);\n _fo.set(_fo.delayedWethPermissionedGameProxy.selector, delayedWethPermissionedGameProxy);\n\n address mipsImpl = IFetcher(permissionedDisputeGameImpl).vm();\n _fo.set(_fo.mipsImpl.selector, mipsImpl);\n\n address preimageOracleImpl = IFetcher(mipsImpl).oracle();\n _fo.set(_fo.preimageOracleImpl.selector, preimageOracleImpl);\n }\n\n address faultDisputeGameImpl = _getFaultDisputeGame(disputeGameFactoryProxy);\n if (faultDisputeGameImpl != address(0)) {\n // permissionless fault proofs installed\n _fo.set(_fo.faultDisputeGameImpl.selector, faultDisputeGameImpl);\n _fo.set(_fo.permissionless.selector, true);\n\n address delayedWethPermissionlessGameProxy = _getDelayedWETHProxy(faultDisputeGameImpl);\n _fo.set(_fo.delayedWethPermissionlessGameProxy.selector, delayedWethPermissionlessGameProxy);\n }\n\n address faultDisputeGameCannonKonaImpl =\n _getFaultDisputeGame(disputeGameFactoryProxy, GameTypes.CANNON_KONA);\n if (faultDisputeGameCannonKonaImpl != address(0)) {\n _fo.set(_fo.faultDisputeGameCannonKonaImpl.selector, faultDisputeGameCannonKonaImpl);\n }\n } else {\n // some older chains have L2OutputOracle instead of DisputeGameFactory.\n address l2OutputOracleProxy = IFetcher(optimismPortalProxy).L2_ORACLE();\n _fo.set(_fo.l2OutputOracleProxy.selector, l2OutputOracleProxy);\n address proposer = IFetcher(l2OutputOracleProxy).PROPOSER();\n _fo.set(_fo.proposer.selector, proposer);\n }\n }\n\n function _getGuardian(address _portal) internal view returns (address) {\n try IFetcher(_portal).guardian() returns (address guardian_) {\n return guardian_;\n } catch {\n return IFetcher(_portal).GUARDIAN();\n }\n }\n\n function _getSystemConfigProxy(address _portal) internal view returns (address) {\n try IFetcher(_portal).systemConfig() returns (address systemConfig_) {\n return systemConfig_;\n } catch {\n return IFetcher(_portal).SYSTEM_CONFIG();\n }\n }\n\n function _getOptimismPortalProxy(address _l1CrossDomainMessengerProxy) internal view returns (address) {\n try IFetcher(_l1CrossDomainMessengerProxy).portal() returns (address optimismPortal_) {\n return optimismPortal_;\n } catch {\n return IFetcher(_l1CrossDomainMessengerProxy).PORTAL();\n }\n }\n\n function _getAddressManager(address _l1CrossDomainMessengerProxy) internal view returns (address) {\n uint256 ADDRESS_MANAGER_MAPPING_SLOT = 1;\n bytes32 slot = keccak256(abi.encode(_l1CrossDomainMessengerProxy, ADDRESS_MANAGER_MAPPING_SLOT));\n return address(uint160(uint256((vm.load(_l1CrossDomainMessengerProxy, slot)))));\n }\n\n function _getL1ERC721BridgeProxy(address _systemConfigProxy) internal view returns (address) {\n try IFetcher(_systemConfigProxy).l1ERC721Bridge() returns (address l1ERC721BridgeProxy_) {\n return l1ERC721BridgeProxy_;\n } catch {\n return address(0);\n }\n }\n\n function _getOptimismMintableERC20FactoryProxy(address _systemConfigProxy) internal view returns (address) {\n try IFetcher(_systemConfigProxy).optimismMintableERC20Factory() returns (\n address optimismMintableERC20FactoryProxy_\n ) {\n return optimismMintableERC20FactoryProxy_;\n } catch {\n return address(0);\n }\n }\n\n function _getDisputeGameFactoryProxy(address _systemConfigProxy) internal view returns (address) {\n try IFetcher(_systemConfigProxy).disputeGameFactory() returns (address disputeGameFactoryProxy_) {\n return disputeGameFactoryProxy_;\n } catch {\n // Some older chains have L2OutputOracle instead of DisputeGameFactory\n return address(0);\n }\n }\n\n function _getSuperchainConfigProxy(address _optimismPortalProxy) internal view returns (address) {\n try IFetcher(_optimismPortalProxy).superchainConfig() returns (address superchainConfigProxy_) {\n return superchainConfigProxy_;\n } catch {\n return address(0);\n }\n }\n\n function _getFaultDisputeGame(address _disputeGameFactoryProxy) internal view returns (address) {\n try IFetcher(_disputeGameFactoryProxy).gameImpls(GameTypes.CANNON) returns (address faultDisputeGame_) {\n return faultDisputeGame_;\n } catch {\n return address(0);\n }\n }\n\n function _getFaultDisputeGame(\n address _disputeGameFactoryProxy,\n GameType _gameType\n )\n internal\n view\n returns (address)\n {\n try IFetcher(_disputeGameFactoryProxy).gameImpls(_gameType) returns (address faultDisputeGame_) {\n return faultDisputeGame_;\n } catch {\n return address(0);\n }\n }\n\n function _getPermissionedDisputeGame(address _disputeGameFactoryProxy) internal view returns (address) {\n try IFetcher(_disputeGameFactoryProxy).gameImpls(GameTypes.PERMISSIONED_CANNON) returns (\n address permissionedDisputeGame_\n ) {\n return permissionedDisputeGame_;\n } catch {\n return address(0);\n }\n }\n\n function _getEthLockboxProxy(address _optimismPortalProxy) internal view returns (address) {\n try IFetcher(_optimismPortalProxy).ethLockbox() returns (address ethLockbox_) {\n return ethLockbox_;\n } catch {\n return address(0);\n }\n }\n\n function _getDelayedWETHProxy(address _disputeGame) internal view returns (address) {\n (bool ok, bytes memory data) = address(_disputeGame).staticcall(abi.encodeCall(IFetcher.weth, ()));\n if (ok && data.length == 32) return abi.decode(data, (address));\n else return address(0);\n }\n\n function _getBatchSubmitter(address _systemConfigProxy) internal view returns (address) {\n bytes32 batcherHash = IFetcher(_systemConfigProxy).batcherHash();\n return address(uint160(uint256(batcherHash)));\n }\n\n function _getProxyAdmin(address _systemConfigProxy) internal returns (address) {\n vm.prank(address(0));\n return IFetcher(_systemConfigProxy).admin();\n }\n}\n","license":"MIT"},"src/dispute/lib/LibPosition.sol":{"keccak256":"0x7c5f19f8f54f06de2ce1c6cdcc5c7af65ac405130a4066cdaf146ca315818241","urls":[],"content":"// SPDX-License-Identifier: MIT\npragma solidity ^0.8.15;\n\nusing LibPosition for Position global;\n\n/// @notice A `Position` represents a position of a claim within the game tree.\n/// @dev This is represented as a \"generalized index\" where the high-order bit\n/// is the level in the tree and the remaining bits is a unique bit pattern, allowing\n/// a unique identifier for each node in the tree. Mathematically, it is calculated\n/// as 2^{depth} + indexAtDepth.\ntype Position is uint128;\n\n/// @title LibPosition\n/// @notice This library contains helper functions for working with the `Position` type.\nlibrary LibPosition {\n /// @notice the `MAX_POSITION_BITLEN` is the number of bits that the `Position` type, and the implementation of\n /// its behavior within this library, can safely support.\n uint8 internal constant MAX_POSITION_BITLEN = 126;\n\n /// @notice Computes a generalized index (2^{depth} + indexAtDepth).\n /// @param _depth The depth of the position.\n /// @param _indexAtDepth The index at the depth of the position.\n /// @return position_ The computed generalized index.\n function wrap(uint8 _depth, uint128 _indexAtDepth) internal pure returns (Position position_) {\n assembly {\n // gindex = 2^{_depth} + _indexAtDepth\n position_ := add(shl(_depth, 1), _indexAtDepth)\n }\n }\n\n /// @notice Pulls the `depth` out of a `Position` type.\n /// @param _position The generalized index to get the `depth` of.\n /// @return depth_ The `depth` of the `position` gindex.\n /// @custom:attribution Solady \n function depth(Position _position) internal pure returns (uint8 depth_) {\n // Return the most significant bit offset, which signifies the depth of the gindex.\n assembly {\n depth_ := or(depth_, shl(6, lt(0xffffffffffffffff, shr(depth_, _position))))\n depth_ := or(depth_, shl(5, lt(0xffffffff, shr(depth_, _position))))\n\n // For the remaining 32 bits, use a De Bruijn lookup.\n _position := shr(depth_, _position)\n _position := or(_position, shr(1, _position))\n _position := or(_position, shr(2, _position))\n _position := or(_position, shr(4, _position))\n _position := or(_position, shr(8, _position))\n _position := or(_position, shr(16, _position))\n\n depth_ :=\n or(\n depth_,\n byte(\n shr(251, mul(_position, shl(224, 0x07c4acdd))),\n 0x0009010a0d15021d0b0e10121619031e080c141c0f111807131b17061a05041f\n )\n )\n }\n }\n\n /// @notice Pulls the `indexAtDepth` out of a `Position` type.\n /// The `indexAtDepth` is the left/right index of a position at a specific depth within\n /// the binary tree, starting from index 0. For example, at gindex 2, the `depth` = 1\n /// and the `indexAtDepth` = 0.\n /// @param _position The generalized index to get the `indexAtDepth` of.\n /// @return indexAtDepth_ The `indexAtDepth` of the `position` gindex.\n function indexAtDepth(Position _position) internal pure returns (uint128 indexAtDepth_) {\n // Return bits p_{msb-1}...p_{0}. This effectively pulls the 2^{depth} out of the gindex,\n // leaving only the `indexAtDepth`.\n uint256 msb = depth(_position);\n assembly {\n indexAtDepth_ := sub(_position, shl(msb, 1))\n }\n }\n\n /// @notice Get the left child of `_position`.\n /// @param _position The position to get the left position of.\n /// @return left_ The position to the left of `position`.\n function left(Position _position) internal pure returns (Position left_) {\n assembly {\n left_ := shl(1, _position)\n }\n }\n\n /// @notice Get the right child of `_position`\n /// @param _position The position to get the right position of.\n /// @return right_ The position to the right of `position`.\n function right(Position _position) internal pure returns (Position right_) {\n assembly {\n right_ := or(1, shl(1, _position))\n }\n }\n\n /// @notice Get the parent position of `_position`.\n /// @param _position The position to get the parent position of.\n /// @return parent_ The parent position of `position`.\n function parent(Position _position) internal pure returns (Position parent_) {\n assembly {\n parent_ := shr(1, _position)\n }\n }\n\n /// @notice Get the deepest, right most gindex relative to the `position`. This is equivalent to\n /// calling `right` on a position until the maximum depth is reached.\n /// @param _position The position to get the relative deepest, right most gindex of.\n /// @param _maxDepth The maximum depth of the game.\n /// @return rightIndex_ The deepest, right most gindex relative to the `position`.\n function rightIndex(Position _position, uint256 _maxDepth) internal pure returns (Position rightIndex_) {\n uint256 msb = depth(_position);\n assembly {\n let remaining := sub(_maxDepth, msb)\n rightIndex_ := or(shl(remaining, _position), sub(shl(remaining, 1), 1))\n }\n }\n\n /// @notice Get the deepest, right most trace index relative to the `position`. This is\n /// equivalent to calling `right` on a position until the maximum depth is reached and\n /// then finding its index at depth.\n /// @param _position The position to get the relative trace index of.\n /// @param _maxDepth The maximum depth of the game.\n /// @return traceIndex_ The trace index relative to the `position`.\n function traceIndex(Position _position, uint256 _maxDepth) internal pure returns (uint256 traceIndex_) {\n uint256 msb = depth(_position);\n assembly {\n let remaining := sub(_maxDepth, msb)\n traceIndex_ := sub(or(shl(remaining, _position), sub(shl(remaining, 1), 1)), shl(_maxDepth, 1))\n }\n }\n\n /// @notice Gets the position of the highest ancestor of `_position` that commits to the same\n /// trace index.\n /// @param _position The position to get the highest ancestor of.\n /// @return ancestor_ The highest ancestor of `position` that commits to the same trace index.\n function traceAncestor(Position _position) internal pure returns (Position ancestor_) {\n // Create a field with only the lowest unset bit of `_position` set.\n Position lsb;\n assembly {\n lsb := and(not(_position), add(_position, 1))\n }\n // Find the index of the lowest unset bit within the field.\n uint256 msb = depth(lsb);\n // The highest ancestor that commits to the same trace index is the original position\n // shifted right by the index of the lowest unset bit.\n assembly {\n let a := shr(msb, _position)\n // Bound the ancestor to the minimum gindex, 1.\n ancestor_ := or(a, iszero(a))\n }\n }\n\n /// @notice Gets the position of the highest ancestor of `_position` that commits to the same\n /// trace index, while still being below `_upperBoundExclusive`.\n /// @param _position The position to get the highest ancestor of.\n /// @param _upperBoundExclusive The exclusive upper depth bound, used to inform where to stop in order\n /// to not escape a sub-tree.\n /// @return ancestor_ The highest ancestor of `position` that commits to the same trace index.\n function traceAncestorBounded(\n Position _position,\n uint256 _upperBoundExclusive\n )\n internal\n pure\n returns (Position ancestor_)\n {\n // This function only works for positions that are below the upper bound.\n if (_position.depth() <= _upperBoundExclusive) {\n assembly {\n // Revert with `ClaimAboveSplit()`\n mstore(0x00, 0xb34b5c22)\n revert(0x1C, 0x04)\n }\n }\n\n // Grab the global trace ancestor.\n ancestor_ = traceAncestor(_position);\n\n // If the ancestor is above or at the upper bound, shift it to be below the upper bound.\n // This should be a special case that only covers positions that commit to the final leaf\n // in a sub-tree.\n if (ancestor_.depth() <= _upperBoundExclusive) {\n ancestor_ = ancestor_.rightIndex(_upperBoundExclusive + 1);\n }\n }\n\n /// @notice Get the move position of `_position`, which is the left child of:\n /// 1. `_position` if `_isAttack` is true.\n /// 2. `_position | 1` if `_isAttack` is false.\n /// @param _position The position to get the relative attack/defense position of.\n /// @param _isAttack Whether or not the move is an attack move.\n /// @return move_ The move position relative to `position`.\n function move(Position _position, bool _isAttack) internal pure returns (Position move_) {\n assembly {\n move_ := shl(1, or(iszero(_isAttack), _position))\n }\n }\n\n /// @notice Get the value of a `Position` type in the form of the underlying uint128.\n /// @param _position The position to get the value of.\n /// @return raw_ The value of the `position` as a uint128 type.\n function raw(Position _position) internal pure returns (uint128 raw_) {\n assembly {\n raw_ := _position\n }\n }\n}\n","license":"MIT"},"src/dispute/lib/LibUDT.sol":{"keccak256":"0x41d55e9c74d979b5b797198e38449e7cef4f925e04d61f7699e9c150c4a659d3","urls":[],"content":"// SPDX-License-Identifier: MIT\npragma solidity ^0.8.15;\n\n// Libraries\nimport { Position } from \"src/dispute/lib/LibPosition.sol\";\n\nusing LibClaim for Claim global;\nusing LibHash for Hash global;\nusing LibDuration for Duration global;\nusing LibClock for Clock global;\nusing LibGameId for GameId global;\nusing LibTimestamp for Timestamp global;\nusing LibVMStatus for VMStatus global;\nusing LibGameType for GameType global;\n\n/// @notice A `Clock` represents a packed `Duration` and `Timestamp`\n/// @dev The packed layout of this type is as follows:\n/// ┌────────────┬────────────────┐\n/// │ Bits │ Value │\n/// ├────────────┼────────────────┤\n/// │ [0, 64) │ Duration │\n/// │ [64, 128) │ Timestamp │\n/// └────────────┴────────────────┘\ntype Clock is uint128;\n\n/// @title LibClock\n/// @notice This library contains helper functions for working with the `Clock` type.\nlibrary LibClock {\n /// @notice Packs a `Duration` and `Timestamp` into a `Clock` type.\n /// @param _duration The `Duration` to pack into the `Clock` type.\n /// @param _timestamp The `Timestamp` to pack into the `Clock` type.\n /// @return clock_ The `Clock` containing the `_duration` and `_timestamp`.\n function wrap(Duration _duration, Timestamp _timestamp) internal pure returns (Clock clock_) {\n assembly {\n clock_ := or(shl(0x40, _duration), _timestamp)\n }\n }\n\n /// @notice Pull the `Duration` out of a `Clock` type.\n /// @param _clock The `Clock` type to pull the `Duration` out of.\n /// @return duration_ The `Duration` pulled out of `_clock`.\n function duration(Clock _clock) internal pure returns (Duration duration_) {\n // Shift the high-order 64 bits into the low-order 64 bits, leaving only the `duration`.\n assembly {\n duration_ := shr(0x40, _clock)\n }\n }\n\n /// @notice Pull the `Timestamp` out of a `Clock` type.\n /// @param _clock The `Clock` type to pull the `Timestamp` out of.\n /// @return timestamp_ The `Timestamp` pulled out of `_clock`.\n function timestamp(Clock _clock) internal pure returns (Timestamp timestamp_) {\n // Clean the high-order 192 bits by shifting the clock left and then right again, leaving\n // only the `timestamp`.\n assembly {\n timestamp_ := shr(0xC0, shl(0xC0, _clock))\n }\n }\n\n /// @notice Get the value of a `Clock` type in the form of the underlying uint128.\n /// @param _clock The `Clock` type to get the value of.\n /// @return clock_ The value of the `Clock` type as a uint128 type.\n function raw(Clock _clock) internal pure returns (uint128 clock_) {\n assembly {\n clock_ := _clock\n }\n }\n}\n\n/// @notice A `GameId` represents a packed 4 byte game ID, a 8 byte timestamp, and a 20 byte address.\n/// @dev The packed layout of this type is as follows:\n/// ┌───────────┬───────────┐\n/// │ Bits │ Value │\n/// ├───────────┼───────────┤\n/// │ [0, 32) │ Game Type │\n/// │ [32, 96) │ Timestamp │\n/// │ [96, 256) │ Address │\n/// └───────────┴───────────┘\ntype GameId is bytes32;\n\n/// @title LibGameId\n/// @notice Utility functions for packing and unpacking GameIds.\nlibrary LibGameId {\n /// @notice Packs values into a 32 byte GameId type.\n /// @param _gameType The game type.\n /// @param _timestamp The timestamp of the game's creation.\n /// @param _gameProxy The game proxy address.\n /// @return gameId_ The packed GameId.\n function pack(\n GameType _gameType,\n Timestamp _timestamp,\n address _gameProxy\n )\n internal\n pure\n returns (GameId gameId_)\n {\n assembly {\n gameId_ := or(or(shl(224, _gameType), shl(160, _timestamp)), _gameProxy)\n }\n }\n\n /// @notice Unpacks values from a 32 byte GameId type.\n /// @param _gameId The packed GameId.\n /// @return gameType_ The game type.\n /// @return timestamp_ The timestamp of the game's creation.\n /// @return gameProxy_ The game proxy address.\n function unpack(GameId _gameId)\n internal\n pure\n returns (GameType gameType_, Timestamp timestamp_, address gameProxy_)\n {\n assembly {\n gameType_ := shr(224, _gameId)\n timestamp_ := and(shr(160, _gameId), 0xFFFFFFFFFFFFFFFF)\n gameProxy_ := and(_gameId, 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF)\n }\n }\n}\n\n/// @notice A claim represents an MPT root representing the state of the fault proof program.\ntype Claim is bytes32;\n\n/// @title LibClaim\n/// @notice This library contains helper functions for working with the `Claim` type.\nlibrary LibClaim {\n /// @notice Get the value of a `Claim` type in the form of the underlying bytes32.\n /// @param _claim The `Claim` type to get the value of.\n /// @return claim_ The value of the `Claim` type as a bytes32 type.\n function raw(Claim _claim) internal pure returns (bytes32 claim_) {\n assembly {\n claim_ := _claim\n }\n }\n\n /// @notice Hashes a claim and a position together.\n /// @param _claim A Claim type.\n /// @param _position The position of `claim`.\n /// @param _challengeIndex The index of the claim being moved against.\n /// @return claimHash_ A hash of abi.encodePacked(claim, position|challengeIndex);\n function hashClaimPos(\n Claim _claim,\n Position _position,\n uint256 _challengeIndex\n )\n internal\n pure\n returns (Hash claimHash_)\n {\n assembly {\n mstore(0x00, _claim)\n mstore(0x20, or(shl(128, _position), and(0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF, _challengeIndex)))\n claimHash_ := keccak256(0x00, 0x40)\n }\n }\n}\n\n/// @notice A dedicated duration type.\n/// @dev Unit: seconds\ntype Duration is uint64;\n\n/// @title LibDuration\n/// @notice This library contains helper functions for working with the `Duration` type.\nlibrary LibDuration {\n /// @notice Get the value of a `Duration` type in the form of the underlying uint64.\n /// @param _duration The `Duration` type to get the value of.\n /// @return duration_ The value of the `Duration` type as a uint64 type.\n function raw(Duration _duration) internal pure returns (uint64 duration_) {\n assembly {\n duration_ := _duration\n }\n }\n}\n\n/// @notice A custom type for a generic hash.\ntype Hash is bytes32;\n\n/// @title LibHash\n/// @notice This library contains helper functions for working with the `Hash` type.\nlibrary LibHash {\n /// @notice Get the value of a `Hash` type in the form of the underlying bytes32.\n /// @param _hash The `Hash` type to get the value of.\n /// @return hash_ The value of the `Hash` type as a bytes32 type.\n function raw(Hash _hash) internal pure returns (bytes32 hash_) {\n assembly {\n hash_ := _hash\n }\n }\n}\n\n/// @notice A dedicated timestamp type.\ntype Timestamp is uint64;\n\n/// @title LibTimestamp\n/// @notice This library contains helper functions for working with the `Timestamp` type.\nlibrary LibTimestamp {\n /// @notice Get the value of a `Timestamp` type in the form of the underlying uint64.\n /// @param _timestamp The `Timestamp` type to get the value of.\n /// @return timestamp_ The value of the `Timestamp` type as a uint64 type.\n function raw(Timestamp _timestamp) internal pure returns (uint64 timestamp_) {\n assembly {\n timestamp_ := _timestamp\n }\n }\n}\n\n/// @notice A `VMStatus` represents the status of a VM execution.\ntype VMStatus is uint8;\n\n/// @title LibVMStatus\n/// @notice This library contains helper functions for working with the `VMStatus` type.\nlibrary LibVMStatus {\n /// @notice Get the value of a `VMStatus` type in the form of the underlying uint8.\n /// @param _vmstatus The `VMStatus` type to get the value of.\n /// @return vmstatus_ The value of the `VMStatus` type as a uint8 type.\n function raw(VMStatus _vmstatus) internal pure returns (uint8 vmstatus_) {\n assembly {\n vmstatus_ := _vmstatus\n }\n }\n}\n\n/// @notice A `GameType` represents the type of game being played.\ntype GameType is uint32;\n\n/// @title LibGameType\n/// @notice This library contains helper functions for working with the `GameType` type.\nlibrary LibGameType {\n /// @notice Get the value of a `GameType` type in the form of the underlying uint32.\n /// @param _gametype The `GameType` type to get the value of.\n /// @return gametype_ The value of the `GameType` type as a uint32 type.\n function raw(GameType _gametype) internal pure returns (uint32 gametype_) {\n assembly {\n gametype_ := _gametype\n }\n }\n}\n","license":"MIT"},"src/dispute/lib/Types.sol":{"keccak256":"0x468fccc8d6ce3ac5b87bdd5002f84b315ac861be7655ceef87a018f596c410a1","urls":[],"content":"// SPDX-License-Identifier: MIT\npragma solidity ^0.8.15;\n\n// Libraries\nimport {\n Position,\n Hash,\n GameType,\n VMStatus,\n Timestamp,\n Duration,\n Clock,\n GameId,\n Claim,\n LibGameId,\n LibClock\n} from \"src/dispute/lib/LibUDT.sol\";\n\n/// @notice The current status of the dispute game.\nenum GameStatus {\n // The game is currently in progress, and has not been resolved.\n IN_PROGRESS,\n // The game has concluded, and the `rootClaim` was challenged successfully.\n CHALLENGER_WINS,\n // The game has concluded, and the `rootClaim` could not be contested.\n DEFENDER_WINS\n}\n\n/// @notice The game's bond distribution type. Games are expected to start in the `UNDECIDED`\n/// state, and then choose either `NORMAL` or `REFUND`.\nenum BondDistributionMode {\n // Bond distribution strategy has not been chosen.\n UNDECIDED,\n // Bonds should be distributed as normal.\n NORMAL,\n // Bonds should be refunded to claimants.\n REFUND\n}\n\n/// @notice Represents an L2 root and the L2 sequence number at which it was generated.\n/// @custom:field root The output root.\n/// @custom:field l2SequenceNumber The L2 Sequence Number ( e.g. block number / timestamp) at which the root was\n/// generated.\nstruct Proposal {\n Hash root;\n uint256 l2SequenceNumber;\n}\n\n/// @title GameTypes\n/// @notice A library that defines the IDs of games that can be played.\nlibrary GameTypes {\n /// @dev A dispute game type the uses the cannon vm.\n GameType internal constant CANNON = GameType.wrap(0);\n\n /// @dev A permissioned dispute game type that uses the cannon vm.\n GameType internal constant PERMISSIONED_CANNON = GameType.wrap(1);\n\n /// @notice A dispute game type that uses the asterisc vm.\n GameType internal constant ASTERISC = GameType.wrap(2);\n\n /// @notice A dispute game type that uses the asterisc vm with Kona.\n GameType internal constant ASTERISC_KONA = GameType.wrap(3);\n\n /// @notice A dispute game type that uses the cannon vm (Super Roots).\n GameType internal constant SUPER_CANNON = GameType.wrap(4);\n\n /// @notice A dispute game type that uses the permissioned cannon vm (Super Roots).\n GameType internal constant SUPER_PERMISSIONED_CANNON = GameType.wrap(5);\n\n /// @notice A dispute game type that uses OP Succinct\n GameType internal constant OP_SUCCINCT = GameType.wrap(6);\n\n /// @notice A dispute game type that uses the asterisc vm with Kona (Super Roots).\n GameType internal constant SUPER_ASTERISC_KONA = GameType.wrap(7);\n\n /// @notice A dispute game type that uses the cannon vm with Kona.\n GameType internal constant CANNON_KONA = GameType.wrap(8);\n\n /// @notice A dispute game type that uses the cannon vm with Kona (Super Roots).\n GameType internal constant SUPER_CANNON_KONA = GameType.wrap(9);\n\n /// @notice A dispute game type with short game duration for testing withdrawals.\n /// Not intended for production use.\n GameType internal constant FAST = GameType.wrap(254);\n\n /// @notice A dispute game type that uses an alphabet vm.\n /// Not intended for production use.\n GameType internal constant ALPHABET = GameType.wrap(255);\n\n /// @notice A dispute game type that uses RISC Zero's Kailua\n GameType internal constant KAILUA = GameType.wrap(1337);\n}\n\n/// @title VMStatuses\n/// @notice Named type aliases for the various valid VM status bytes.\nlibrary VMStatuses {\n /// @notice The VM has executed successfully and the outcome is valid.\n VMStatus internal constant VALID = VMStatus.wrap(0);\n\n /// @notice The VM has executed successfully and the outcome is invalid.\n VMStatus internal constant INVALID = VMStatus.wrap(1);\n\n /// @notice The VM has paniced.\n VMStatus internal constant PANIC = VMStatus.wrap(2);\n\n /// @notice The VM execution is still in progress.\n VMStatus internal constant UNFINISHED = VMStatus.wrap(3);\n}\n\n/// @title LocalPreimageKey\n/// @notice Named type aliases for local `PreimageOracle` key identifiers.\nlibrary LocalPreimageKey {\n /// @notice The identifier for the L1 head hash.\n uint256 internal constant L1_HEAD_HASH = 0x01;\n\n /// @notice The identifier for the starting output root.\n uint256 internal constant STARTING_OUTPUT_ROOT = 0x02;\n\n /// @notice The identifier for the disputed output root.\n uint256 internal constant DISPUTED_OUTPUT_ROOT = 0x03;\n\n /// @notice The identifier for the disputed L2 block number.\n uint256 internal constant DISPUTED_L2_BLOCK_NUMBER = 0x04;\n\n /// @notice The identifier for the chain ID.\n uint256 internal constant CHAIN_ID = 0x05;\n}\n","license":"MIT"}},"version":1},"storageLayout":{"storage":[{"astId":53960,"contract":"scripts/FetchChainInfo.s.sol:FetchChainInfoInput","label":"_systemConfigProxy","offset":0,"slot":"0","type":"t_address"},{"astId":53962,"contract":"scripts/FetchChainInfo.s.sol:FetchChainInfoInput","label":"_l1StandardBridgeProxy","offset":0,"slot":"1","type":"t_address"}],"types":{"t_address":{"encoding":"inplace","label":"address","numberOfBytes":"20"}}},"userdoc":{"version":1,"kind":"user"},"devdoc":{"version":1,"kind":"dev"},"ast":{"absolutePath":"scripts/FetchChainInfo.s.sol","id":56019,"exportedSymbols":{"FetchChainInfo":[56018],"FetchChainInfoInput":[54041],"FetchChainInfoOutput":[54911],"GameType":[70720],"GameTypes":[70870],"IFetcher":[53958],"Script":[5558]},"nodeType":"SourceUnit","src":"32:25120:100","nodes":[{"id":53807,"nodeType":"PragmaDirective","src":"32:23:100","nodes":[],"literals":["solidity","^","0.8",".0"]},{"id":53809,"nodeType":"ImportDirective","src":"57:46:100","nodes":[],"absolutePath":"lib/forge-std/src/Script.sol","file":"forge-std/Script.sol","nameLocation":"-1:-1:-1","scope":56019,"sourceUnit":5559,"symbolAliases":[{"foreign":{"id":53808,"name":"Script","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":5558,"src":"66:6:100","typeDescriptions":{}},"nameLocation":"-1:-1:-1"}],"unitAlias":""},{"id":53812,"nodeType":"ImportDirective","src":"104:64:100","nodes":[],"absolutePath":"src/dispute/lib/Types.sol","file":"src/dispute/lib/Types.sol","nameLocation":"-1:-1:-1","scope":56019,"sourceUnit":70927,"symbolAliases":[{"foreign":{"id":53810,"name":"GameTypes","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":70870,"src":"113:9:100","typeDescriptions":{}},"nameLocation":"-1:-1:-1"},{"foreign":{"id":53811,"name":"GameType","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":70720,"src":"124:8:100","typeDescriptions":{}},"nameLocation":"-1:-1:-1"}],"unitAlias":""},{"id":53958,"nodeType":"ContractDefinition","src":"306:1713:100","nodes":[{"id":53818,"nodeType":"FunctionDefinition","src":"331:52:100","nodes":[],"functionSelector":"452a9320","implemented":false,"kind":"function","modifiers":[],"name":"guardian","nameLocation":"340:8:100","parameters":{"id":53814,"nodeType":"ParameterList","parameters":[],"src":"348:2:100"},"returnParameters":{"id":53817,"nodeType":"ParameterList","parameters":[{"constant":false,"id":53816,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":53818,"src":"374:7:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":53815,"name":"address","nodeType":"ElementaryTypeName","src":"374:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"373:9:100"},"scope":53958,"stateMutability":"view","virtual":false,"visibility":"external"},{"id":53823,"nodeType":"FunctionDefinition","src":"388:52:100","nodes":[],"functionSelector":"724c184c","implemented":false,"kind":"function","modifiers":[],"name":"GUARDIAN","nameLocation":"397:8:100","parameters":{"id":53819,"nodeType":"ParameterList","parameters":[],"src":"405:2:100"},"returnParameters":{"id":53822,"nodeType":"ParameterList","parameters":[{"constant":false,"id":53821,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":53823,"src":"431:7:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":53820,"name":"address","nodeType":"ElementaryTypeName","src":"431:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"430:9:100"},"scope":53958,"stateMutability":"view","virtual":false,"visibility":"external"},{"id":53828,"nodeType":"FunctionDefinition","src":"445:56:100","nodes":[],"functionSelector":"33d7e2bd","implemented":false,"kind":"function","modifiers":[],"name":"systemConfig","nameLocation":"454:12:100","parameters":{"id":53824,"nodeType":"ParameterList","parameters":[],"src":"466:2:100"},"returnParameters":{"id":53827,"nodeType":"ParameterList","parameters":[{"constant":false,"id":53826,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":53828,"src":"492:7:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":53825,"name":"address","nodeType":"ElementaryTypeName","src":"492:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"491:9:100"},"scope":53958,"stateMutability":"view","virtual":false,"visibility":"external"},{"id":53833,"nodeType":"FunctionDefinition","src":"506:57:100","nodes":[],"functionSelector":"f0498750","implemented":false,"kind":"function","modifiers":[],"name":"SYSTEM_CONFIG","nameLocation":"515:13:100","parameters":{"id":53829,"nodeType":"ParameterList","parameters":[],"src":"528:2:100"},"returnParameters":{"id":53832,"nodeType":"ParameterList","parameters":[{"constant":false,"id":53831,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":53833,"src":"554:7:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":53830,"name":"address","nodeType":"ElementaryTypeName","src":"554:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"553:9:100"},"scope":53958,"stateMutability":"view","virtual":false,"visibility":"external"},{"id":53838,"nodeType":"FunctionDefinition","src":"568:62:100","nodes":[],"functionSelector":"f2b4e617","implemented":false,"kind":"function","modifiers":[],"name":"disputeGameFactory","nameLocation":"577:18:100","parameters":{"id":53834,"nodeType":"ParameterList","parameters":[],"src":"595:2:100"},"returnParameters":{"id":53837,"nodeType":"ParameterList","parameters":[{"constant":false,"id":53836,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":53838,"src":"621:7:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":53835,"name":"address","nodeType":"ElementaryTypeName","src":"621:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"620:9:100"},"scope":53958,"stateMutability":"view","virtual":false,"visibility":"external"},{"id":53843,"nodeType":"FunctionDefinition","src":"635:54:100","nodes":[],"functionSelector":"b682c444","implemented":false,"kind":"function","modifiers":[],"name":"ethLockbox","nameLocation":"644:10:100","parameters":{"id":53839,"nodeType":"ParameterList","parameters":[],"src":"654:2:100"},"returnParameters":{"id":53842,"nodeType":"ParameterList","parameters":[{"constant":false,"id":53841,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":53843,"src":"680:7:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":53840,"name":"address","nodeType":"ElementaryTypeName","src":"680:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"679:9:100"},"scope":53958,"stateMutability":"view","virtual":false,"visibility":"external"},{"id":53848,"nodeType":"FunctionDefinition","src":"694:60:100","nodes":[],"functionSelector":"35e80ab3","implemented":false,"kind":"function","modifiers":[],"name":"superchainConfig","nameLocation":"703:16:100","parameters":{"id":53844,"nodeType":"ParameterList","parameters":[],"src":"719:2:100"},"returnParameters":{"id":53847,"nodeType":"ParameterList","parameters":[{"constant":false,"id":53846,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":53848,"src":"745:7:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":53845,"name":"address","nodeType":"ElementaryTypeName","src":"745:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"744:9:100"},"scope":53958,"stateMutability":"view","virtual":false,"visibility":"external"},{"id":53853,"nodeType":"FunctionDefinition","src":"759:53:100","nodes":[],"functionSelector":"3cb747bf","implemented":false,"kind":"function","modifiers":[],"name":"messenger","nameLocation":"768:9:100","parameters":{"id":53849,"nodeType":"ParameterList","parameters":[],"src":"777:2:100"},"returnParameters":{"id":53852,"nodeType":"ParameterList","parameters":[{"constant":false,"id":53851,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":53853,"src":"803:7:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":53850,"name":"address","nodeType":"ElementaryTypeName","src":"803:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"802:9:100"},"scope":53958,"stateMutability":"view","virtual":false,"visibility":"external"},{"id":53858,"nodeType":"FunctionDefinition","src":"817:58:100","nodes":[],"functionSelector":"3ab76e9f","implemented":false,"kind":"function","modifiers":[],"name":"addressManager","nameLocation":"826:14:100","parameters":{"id":53854,"nodeType":"ParameterList","parameters":[],"src":"840:2:100"},"returnParameters":{"id":53857,"nodeType":"ParameterList","parameters":[{"constant":false,"id":53856,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":53858,"src":"866:7:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":53855,"name":"address","nodeType":"ElementaryTypeName","src":"866:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"865:9:100"},"scope":53958,"stateMutability":"view","virtual":false,"visibility":"external"},{"id":53863,"nodeType":"FunctionDefinition","src":"880:50:100","nodes":[],"functionSelector":"0ff754ea","implemented":false,"kind":"function","modifiers":[],"name":"PORTAL","nameLocation":"889:6:100","parameters":{"id":53859,"nodeType":"ParameterList","parameters":[],"src":"895:2:100"},"returnParameters":{"id":53862,"nodeType":"ParameterList","parameters":[{"constant":false,"id":53861,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":53863,"src":"921:7:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":53860,"name":"address","nodeType":"ElementaryTypeName","src":"921:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"920:9:100"},"scope":53958,"stateMutability":"view","virtual":false,"visibility":"external"},{"id":53868,"nodeType":"FunctionDefinition","src":"935:50:100","nodes":[],"functionSelector":"6425666b","implemented":false,"kind":"function","modifiers":[],"name":"portal","nameLocation":"944:6:100","parameters":{"id":53864,"nodeType":"ParameterList","parameters":[],"src":"950:2:100"},"returnParameters":{"id":53867,"nodeType":"ParameterList","parameters":[{"constant":false,"id":53866,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":53868,"src":"976:7:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":53865,"name":"address","nodeType":"ElementaryTypeName","src":"976:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"975:9:100"},"scope":53958,"stateMutability":"view","virtual":false,"visibility":"external"},{"id":53873,"nodeType":"FunctionDefinition","src":"990:58:100","nodes":[],"functionSelector":"c4e8ddfa","implemented":false,"kind":"function","modifiers":[],"name":"l1ERC721Bridge","nameLocation":"999:14:100","parameters":{"id":53869,"nodeType":"ParameterList","parameters":[],"src":"1013:2:100"},"returnParameters":{"id":53872,"nodeType":"ParameterList","parameters":[{"constant":false,"id":53871,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":53873,"src":"1039:7:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":53870,"name":"address","nodeType":"ElementaryTypeName","src":"1039:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"1038:9:100"},"scope":53958,"stateMutability":"view","virtual":false,"visibility":"external"},{"id":53878,"nodeType":"FunctionDefinition","src":"1053:72:100","nodes":[],"functionSelector":"9b7d7f0a","implemented":false,"kind":"function","modifiers":[],"name":"optimismMintableERC20Factory","nameLocation":"1062:28:100","parameters":{"id":53874,"nodeType":"ParameterList","parameters":[],"src":"1090:2:100"},"returnParameters":{"id":53877,"nodeType":"ParameterList","parameters":[{"constant":false,"id":53876,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":53878,"src":"1116:7:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":53875,"name":"address","nodeType":"ElementaryTypeName","src":"1116:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"1115:9:100"},"scope":53958,"stateMutability":"view","virtual":false,"visibility":"external"},{"id":53886,"nodeType":"FunctionDefinition","src":"1130:71:100","nodes":[],"functionSelector":"1b685b9e","implemented":false,"kind":"function","modifiers":[],"name":"gameImpls","nameLocation":"1139:9:100","parameters":{"id":53882,"nodeType":"ParameterList","parameters":[{"constant":false,"id":53881,"mutability":"mutable","name":"_gameType","nameLocation":"1158:9:100","nodeType":"VariableDeclaration","scope":53886,"src":"1149:18:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_userDefinedValueType$_GameType_$70720","typeString":"GameType"},"typeName":{"id":53880,"nodeType":"UserDefinedTypeName","pathNode":{"id":53879,"name":"GameType","nameLocations":["1149:8:100"],"nodeType":"IdentifierPath","referencedDeclaration":70720,"src":"1149:8:100"},"referencedDeclaration":70720,"src":"1149:8:100","typeDescriptions":{"typeIdentifier":"t_userDefinedValueType$_GameType_$70720","typeString":"GameType"}},"visibility":"internal"}],"src":"1148:20:100"},"returnParameters":{"id":53885,"nodeType":"ParameterList","parameters":[{"constant":false,"id":53884,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":53886,"src":"1192:7:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":53883,"name":"address","nodeType":"ElementaryTypeName","src":"1192:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"1191:9:100"},"scope":53958,"stateMutability":"view","virtual":false,"visibility":"external"},{"id":53892,"nodeType":"FunctionDefinition","src":"1206:62:100","nodes":[],"functionSelector":"3c9f397c","implemented":false,"kind":"function","modifiers":[],"name":"respectedGameType","nameLocation":"1215:17:100","parameters":{"id":53887,"nodeType":"ParameterList","parameters":[],"src":"1232:2:100"},"returnParameters":{"id":53891,"nodeType":"ParameterList","parameters":[{"constant":false,"id":53890,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":53892,"src":"1258:8:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_userDefinedValueType$_GameType_$70720","typeString":"GameType"},"typeName":{"id":53889,"nodeType":"UserDefinedTypeName","pathNode":{"id":53888,"name":"GameType","nameLocations":["1258:8:100"],"nodeType":"IdentifierPath","referencedDeclaration":70720,"src":"1258:8:100"},"referencedDeclaration":70720,"src":"1258:8:100","typeDescriptions":{"typeIdentifier":"t_userDefinedValueType$_GameType_$70720","typeString":"GameType"}},"visibility":"internal"}],"src":"1257:10:100"},"scope":53958,"stateMutability":"view","virtual":false,"visibility":"external"},{"id":53897,"nodeType":"FunctionDefinition","src":"1273:63:100","nodes":[],"functionSelector":"5c0cba33","implemented":false,"kind":"function","modifiers":[],"name":"anchorStateRegistry","nameLocation":"1282:19:100","parameters":{"id":53893,"nodeType":"ParameterList","parameters":[],"src":"1301:2:100"},"returnParameters":{"id":53896,"nodeType":"ParameterList","parameters":[{"constant":false,"id":53895,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":53897,"src":"1327:7:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":53894,"name":"address","nodeType":"ElementaryTypeName","src":"1327:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"1326:9:100"},"scope":53958,"stateMutability":"view","virtual":false,"visibility":"external"},{"id":53902,"nodeType":"FunctionDefinition","src":"1341:53:100","nodes":[],"functionSelector":"001c2ff6","implemented":false,"kind":"function","modifiers":[],"name":"L2_ORACLE","nameLocation":"1350:9:100","parameters":{"id":53898,"nodeType":"ParameterList","parameters":[],"src":"1359:2:100"},"returnParameters":{"id":53901,"nodeType":"ParameterList","parameters":[{"constant":false,"id":53900,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":53902,"src":"1385:7:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":53899,"name":"address","nodeType":"ElementaryTypeName","src":"1385:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"1384:9:100"},"scope":53958,"stateMutability":"view","virtual":false,"visibility":"external"},{"id":53907,"nodeType":"FunctionDefinition","src":"1399:52:100","nodes":[],"functionSelector":"9b5f694a","implemented":false,"kind":"function","modifiers":[],"name":"l2Oracle","nameLocation":"1408:8:100","parameters":{"id":53903,"nodeType":"ParameterList","parameters":[],"src":"1416:2:100"},"returnParameters":{"id":53906,"nodeType":"ParameterList","parameters":[{"constant":false,"id":53905,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":53907,"src":"1442:7:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":53904,"name":"address","nodeType":"ElementaryTypeName","src":"1442:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"1441:9:100"},"scope":53958,"stateMutability":"view","virtual":false,"visibility":"external"},{"id":53912,"nodeType":"FunctionDefinition","src":"1456:46:100","nodes":[],"functionSelector":"3a768463","implemented":false,"kind":"function","modifiers":[],"name":"vm","nameLocation":"1465:2:100","parameters":{"id":53908,"nodeType":"ParameterList","parameters":[],"src":"1467:2:100"},"returnParameters":{"id":53911,"nodeType":"ParameterList","parameters":[{"constant":false,"id":53910,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":53912,"src":"1493:7:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":53909,"name":"address","nodeType":"ElementaryTypeName","src":"1493:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"1492:9:100"},"scope":53958,"stateMutability":"view","virtual":false,"visibility":"external"},{"id":53917,"nodeType":"FunctionDefinition","src":"1507:50:100","nodes":[],"functionSelector":"7dc0d1d0","implemented":false,"kind":"function","modifiers":[],"name":"oracle","nameLocation":"1516:6:100","parameters":{"id":53913,"nodeType":"ParameterList","parameters":[],"src":"1522:2:100"},"returnParameters":{"id":53916,"nodeType":"ParameterList","parameters":[{"constant":false,"id":53915,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":53917,"src":"1548:7:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":53914,"name":"address","nodeType":"ElementaryTypeName","src":"1548:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"1547:9:100"},"scope":53958,"stateMutability":"view","virtual":false,"visibility":"external"},{"id":53922,"nodeType":"FunctionDefinition","src":"1562:54:100","nodes":[],"functionSelector":"534db0e2","implemented":false,"kind":"function","modifiers":[],"name":"challenger","nameLocation":"1571:10:100","parameters":{"id":53918,"nodeType":"ParameterList","parameters":[],"src":"1581:2:100"},"returnParameters":{"id":53921,"nodeType":"ParameterList","parameters":[{"constant":false,"id":53920,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":53922,"src":"1607:7:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":53919,"name":"address","nodeType":"ElementaryTypeName","src":"1607:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"1606:9:100"},"scope":53958,"stateMutability":"view","virtual":false,"visibility":"external"},{"id":53927,"nodeType":"FunctionDefinition","src":"1621:52:100","nodes":[],"functionSelector":"a8e4fb90","implemented":false,"kind":"function","modifiers":[],"name":"proposer","nameLocation":"1630:8:100","parameters":{"id":53923,"nodeType":"ParameterList","parameters":[],"src":"1638:2:100"},"returnParameters":{"id":53926,"nodeType":"ParameterList","parameters":[{"constant":false,"id":53925,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":53927,"src":"1664:7:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":53924,"name":"address","nodeType":"ElementaryTypeName","src":"1664:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"1663:9:100"},"scope":53958,"stateMutability":"view","virtual":false,"visibility":"external"},{"id":53932,"nodeType":"FunctionDefinition","src":"1678:52:100","nodes":[],"functionSelector":"bffa7f0f","implemented":false,"kind":"function","modifiers":[],"name":"PROPOSER","nameLocation":"1687:8:100","parameters":{"id":53928,"nodeType":"ParameterList","parameters":[],"src":"1695:2:100"},"returnParameters":{"id":53931,"nodeType":"ParameterList","parameters":[{"constant":false,"id":53930,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":53932,"src":"1721:7:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":53929,"name":"address","nodeType":"ElementaryTypeName","src":"1721:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"1720:9:100"},"scope":53958,"stateMutability":"view","virtual":false,"visibility":"external"},{"id":53937,"nodeType":"FunctionDefinition","src":"1735:55:100","nodes":[],"functionSelector":"e81b2c6d","implemented":false,"kind":"function","modifiers":[],"name":"batcherHash","nameLocation":"1744:11:100","parameters":{"id":53933,"nodeType":"ParameterList","parameters":[],"src":"1755:2:100"},"returnParameters":{"id":53936,"nodeType":"ParameterList","parameters":[{"constant":false,"id":53935,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":53937,"src":"1781:7:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_bytes32","typeString":"bytes32"},"typeName":{"id":53934,"name":"bytes32","nodeType":"ElementaryTypeName","src":"1781:7:100","typeDescriptions":{"typeIdentifier":"t_bytes32","typeString":"bytes32"}},"visibility":"internal"}],"src":"1780:9:100"},"scope":53958,"stateMutability":"view","virtual":false,"visibility":"external"},{"id":53942,"nodeType":"FunctionDefinition","src":"1795:49:100","nodes":[],"functionSelector":"f851a440","implemented":false,"kind":"function","modifiers":[],"name":"admin","nameLocation":"1804:5:100","parameters":{"id":53938,"nodeType":"ParameterList","parameters":[],"src":"1809:2:100"},"returnParameters":{"id":53941,"nodeType":"ParameterList","parameters":[{"constant":false,"id":53940,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":53942,"src":"1835:7:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":53939,"name":"address","nodeType":"ElementaryTypeName","src":"1835:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"1834:9:100"},"scope":53958,"stateMutability":"view","virtual":false,"visibility":"external"},{"id":53947,"nodeType":"FunctionDefinition","src":"1849:49:100","nodes":[],"functionSelector":"8da5cb5b","implemented":false,"kind":"function","modifiers":[],"name":"owner","nameLocation":"1858:5:100","parameters":{"id":53943,"nodeType":"ParameterList","parameters":[],"src":"1863:2:100"},"returnParameters":{"id":53946,"nodeType":"ParameterList","parameters":[{"constant":false,"id":53945,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":53947,"src":"1889:7:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":53944,"name":"address","nodeType":"ElementaryTypeName","src":"1889:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"1888:9:100"},"scope":53958,"stateMutability":"view","virtual":false,"visibility":"external"},{"id":53952,"nodeType":"FunctionDefinition","src":"1903:61:100","nodes":[],"functionSelector":"1fd19ee1","implemented":false,"kind":"function","modifiers":[],"name":"unsafeBlockSigner","nameLocation":"1912:17:100","parameters":{"id":53948,"nodeType":"ParameterList","parameters":[],"src":"1929:2:100"},"returnParameters":{"id":53951,"nodeType":"ParameterList","parameters":[{"constant":false,"id":53950,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":53952,"src":"1955:7:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":53949,"name":"address","nodeType":"ElementaryTypeName","src":"1955:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"1954:9:100"},"scope":53958,"stateMutability":"view","virtual":false,"visibility":"external"},{"id":53957,"nodeType":"FunctionDefinition","src":"1969:48:100","nodes":[],"functionSelector":"3fc8cef3","implemented":false,"kind":"function","modifiers":[],"name":"weth","nameLocation":"1978:4:100","parameters":{"id":53953,"nodeType":"ParameterList","parameters":[],"src":"1982:2:100"},"returnParameters":{"id":53956,"nodeType":"ParameterList","parameters":[{"constant":false,"id":53955,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":53957,"src":"2008:7:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":53954,"name":"address","nodeType":"ElementaryTypeName","src":"2008:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"2007:9:100"},"scope":53958,"stateMutability":"view","virtual":false,"visibility":"external"}],"abstract":false,"baseContracts":[],"canonicalName":"IFetcher","contractDependencies":[],"contractKind":"interface","documentation":{"id":53813,"nodeType":"StructuredDocumentation","src":"170:136:100","text":"@notice Contains getters for arbitrary methods from all L1 contracts, including legacy getters\n that have since been deprecated."},"fullyImplemented":false,"linearizedBaseContracts":[53958],"name":"IFetcher","nameLocation":"316:8:100","scope":56019,"usedErrors":[],"usedEvents":[]},{"id":54041,"nodeType":"ContractDefinition","src":"2021:934:100","nodes":[{"id":53960,"nodeType":"VariableDeclaration","src":"2056:35:100","nodes":[],"constant":false,"mutability":"mutable","name":"_systemConfigProxy","nameLocation":"2073:18:100","scope":54041,"stateVariable":true,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":53959,"name":"address","nodeType":"ElementaryTypeName","src":"2056:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"},{"id":53962,"nodeType":"VariableDeclaration","src":"2097:39:100","nodes":[],"constant":false,"mutability":"mutable","name":"_l1StandardBridgeProxy","nameLocation":"2114:22:100","scope":54041,"stateVariable":true,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":53961,"name":"address","nodeType":"ElementaryTypeName","src":"2097:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"},{"id":54004,"nodeType":"FunctionDefinition","src":"2143:378:100","nodes":[],"body":{"id":54003,"nodeType":"Block","src":"2191:330:100","nodes":[],"statements":[{"expression":{"arguments":[{"commonType":{"typeIdentifier":"t_address","typeString":"address"},"id":53975,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftExpression":{"id":53970,"name":"_addr","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":53966,"src":"2209:5:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"BinaryOperation","operator":"!=","rightExpression":{"arguments":[{"hexValue":"30","id":53973,"isConstant":false,"isLValue":false,"isPure":true,"kind":"number","lValueRequested":false,"nodeType":"Literal","src":"2226:1:100","typeDescriptions":{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"},"value":"0"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"}],"id":53972,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"nodeType":"ElementaryTypeNameExpression","src":"2218:7:100","typeDescriptions":{"typeIdentifier":"t_type$_t_address_$","typeString":"type(address)"},"typeName":{"id":53971,"name":"address","nodeType":"ElementaryTypeName","src":"2218:7:100","typeDescriptions":{}}},"id":53974,"isConstant":false,"isLValue":false,"isPure":true,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"2218:10:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"src":"2209:19:100","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},{"hexValue":"4665746368436861696e496e666f496e7075743a2063616e6e6f7420736574207a65726f2061646472657373","id":53976,"isConstant":false,"isLValue":false,"isPure":true,"kind":"string","lValueRequested":false,"nodeType":"Literal","src":"2230:46:100","typeDescriptions":{"typeIdentifier":"t_stringliteral_0336126ace187312d69da4c7cf05307af6a6596e8c75de2974f56108baf24145","typeString":"literal_string \"FetchChainInfoInput: cannot set zero address\""},"value":"FetchChainInfoInput: cannot set zero address"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_bool","typeString":"bool"},{"typeIdentifier":"t_stringliteral_0336126ace187312d69da4c7cf05307af6a6596e8c75de2974f56108baf24145","typeString":"literal_string \"FetchChainInfoInput: cannot set zero address\""}],"id":53969,"name":"require","nodeType":"Identifier","overloadedDeclarations":[-18,-18,-18],"referencedDeclaration":-18,"src":"2201:7:100","typeDescriptions":{"typeIdentifier":"t_function_require_pure$_t_bool_$_t_string_memory_ptr_$returns$__$","typeString":"function (bool,string memory) pure"}},"id":53977,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"2201:76:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":53978,"nodeType":"ExpressionStatement","src":"2201:76:100"},{"condition":{"commonType":{"typeIdentifier":"t_bytes4","typeString":"bytes4"},"id":53983,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftExpression":{"id":53979,"name":"_sel","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":53964,"src":"2291:4:100","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},"nodeType":"BinaryOperation","operator":"==","rightExpression":{"expression":{"expression":{"id":53980,"name":"this","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":-28,"src":"2299:4:100","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoInput_$54041","typeString":"contract FetchChainInfoInput"}},"id":53981,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"2304:17:100","memberName":"systemConfigProxy","nodeType":"MemberAccess","referencedDeclaration":54022,"src":"2299:22:100","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":53982,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"memberLocation":"2322:8:100","memberName":"selector","nodeType":"MemberAccess","src":"2299:31:100","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},"src":"2291:39:100","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},"falseBody":{"condition":{"commonType":{"typeIdentifier":"t_bytes4","typeString":"bytes4"},"id":53992,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftExpression":{"id":53988,"name":"_sel","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":53964,"src":"2377:4:100","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},"nodeType":"BinaryOperation","operator":"==","rightExpression":{"expression":{"expression":{"id":53989,"name":"this","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":-28,"src":"2385:4:100","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoInput_$54041","typeString":"contract FetchChainInfoInput"}},"id":53990,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"2390:21:100","memberName":"l1StandardBridgeProxy","nodeType":"MemberAccess","referencedDeclaration":54040,"src":"2385:26:100","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":53991,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"memberLocation":"2412:8:100","memberName":"selector","nodeType":"MemberAccess","src":"2385:35:100","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},"src":"2377:43:100","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},"falseBody":{"expression":{"arguments":[{"hexValue":"4665746368436861696e496e666f496e7075743a20756e6b6e6f776e2073656c6563746f72","id":53998,"isConstant":false,"isLValue":false,"isPure":true,"kind":"string","lValueRequested":false,"nodeType":"Literal","src":"2474:39:100","typeDescriptions":{"typeIdentifier":"t_stringliteral_3ec062448196d68b2d186fadb5ffe52c72f0a2b929c9d178cd6e6612281f066b","typeString":"literal_string \"FetchChainInfoInput: unknown selector\""},"value":"FetchChainInfoInput: unknown selector"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_stringliteral_3ec062448196d68b2d186fadb5ffe52c72f0a2b929c9d178cd6e6612281f066b","typeString":"literal_string \"FetchChainInfoInput: unknown selector\""}],"id":53997,"name":"revert","nodeType":"Identifier","overloadedDeclarations":[-19,-19],"referencedDeclaration":-19,"src":"2467:6:100","typeDescriptions":{"typeIdentifier":"t_function_revert_pure$_t_string_memory_ptr_$returns$__$","typeString":"function (string memory) pure"}},"id":53999,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"2467:47:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":54000,"nodeType":"ExpressionStatement","src":"2467:47:100"},"id":54001,"nodeType":"IfStatement","src":"2373:141:100","trueBody":{"expression":{"id":53995,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftHandSide":{"id":53993,"name":"_l1StandardBridgeProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":53962,"src":"2422:22:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"Assignment","operator":"=","rightHandSide":{"id":53994,"name":"_addr","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":53966,"src":"2447:5:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"src":"2422:30:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"id":53996,"nodeType":"ExpressionStatement","src":"2422:30:100"}},"id":54002,"nodeType":"IfStatement","src":"2287:227:100","trueBody":{"expression":{"id":53986,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftHandSide":{"id":53984,"name":"_systemConfigProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":53960,"src":"2332:18:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"Assignment","operator":"=","rightHandSide":{"id":53985,"name":"_addr","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":53966,"src":"2353:5:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"src":"2332:26:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"id":53987,"nodeType":"ExpressionStatement","src":"2332:26:100"}}]},"functionSelector":"c3e39250","implemented":true,"kind":"function","modifiers":[],"name":"set","nameLocation":"2152:3:100","parameters":{"id":53967,"nodeType":"ParameterList","parameters":[{"constant":false,"id":53964,"mutability":"mutable","name":"_sel","nameLocation":"2163:4:100","nodeType":"VariableDeclaration","scope":54004,"src":"2156:11:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"},"typeName":{"id":53963,"name":"bytes4","nodeType":"ElementaryTypeName","src":"2156:6:100","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},"visibility":"internal"},{"constant":false,"id":53966,"mutability":"mutable","name":"_addr","nameLocation":"2177:5:100","nodeType":"VariableDeclaration","scope":54004,"src":"2169:13:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":53965,"name":"address","nodeType":"ElementaryTypeName","src":"2169:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"2155:28:100"},"returnParameters":{"id":53968,"nodeType":"ParameterList","parameters":[],"src":"2191:0:100"},"scope":54041,"stateMutability":"nonpayable","virtual":false,"visibility":"public"},{"id":54022,"nodeType":"FunctionDefinition","src":"2527:202:100","nodes":[],"body":{"id":54021,"nodeType":"Block","src":"2586:143:100","nodes":[],"statements":[{"expression":{"arguments":[{"commonType":{"typeIdentifier":"t_address","typeString":"address"},"id":54015,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftExpression":{"id":54010,"name":"_systemConfigProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":53960,"src":"2604:18:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"BinaryOperation","operator":"!=","rightExpression":{"arguments":[{"hexValue":"30","id":54013,"isConstant":false,"isLValue":false,"isPure":true,"kind":"number","lValueRequested":false,"nodeType":"Literal","src":"2634:1:100","typeDescriptions":{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"},"value":"0"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"}],"id":54012,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"nodeType":"ElementaryTypeNameExpression","src":"2626:7:100","typeDescriptions":{"typeIdentifier":"t_type$_t_address_$","typeString":"type(address)"},"typeName":{"id":54011,"name":"address","nodeType":"ElementaryTypeName","src":"2626:7:100","typeDescriptions":{}}},"id":54014,"isConstant":false,"isLValue":false,"isPure":true,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"2626:10:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"src":"2604:32:100","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},{"hexValue":"4665746368436861696e496e666f496e7075743a2073797374656d436f6e66696750726f7879206e6f7420736574","id":54016,"isConstant":false,"isLValue":false,"isPure":true,"kind":"string","lValueRequested":false,"nodeType":"Literal","src":"2638:48:100","typeDescriptions":{"typeIdentifier":"t_stringliteral_cefeeda9841ab81b734a3e4f7bf39aeeab7704e02e2040531bd67ea944e4d5d3","typeString":"literal_string \"FetchChainInfoInput: systemConfigProxy not set\""},"value":"FetchChainInfoInput: systemConfigProxy not set"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_bool","typeString":"bool"},{"typeIdentifier":"t_stringliteral_cefeeda9841ab81b734a3e4f7bf39aeeab7704e02e2040531bd67ea944e4d5d3","typeString":"literal_string \"FetchChainInfoInput: systemConfigProxy not set\""}],"id":54009,"name":"require","nodeType":"Identifier","overloadedDeclarations":[-18,-18,-18],"referencedDeclaration":-18,"src":"2596:7:100","typeDescriptions":{"typeIdentifier":"t_function_require_pure$_t_bool_$_t_string_memory_ptr_$returns$__$","typeString":"function (bool,string memory) pure"}},"id":54017,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"2596:91:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":54018,"nodeType":"ExpressionStatement","src":"2596:91:100"},{"expression":{"id":54019,"name":"_systemConfigProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":53960,"src":"2704:18:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"functionReturnParameters":54008,"id":54020,"nodeType":"Return","src":"2697:25:100"}]},"functionSelector":"c17db6e3","implemented":true,"kind":"function","modifiers":[],"name":"systemConfigProxy","nameLocation":"2536:17:100","parameters":{"id":54005,"nodeType":"ParameterList","parameters":[],"src":"2553:2:100"},"returnParameters":{"id":54008,"nodeType":"ParameterList","parameters":[{"constant":false,"id":54007,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":54022,"src":"2577:7:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":54006,"name":"address","nodeType":"ElementaryTypeName","src":"2577:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"2576:9:100"},"scope":54041,"stateMutability":"view","virtual":false,"visibility":"public"},{"id":54040,"nodeType":"FunctionDefinition","src":"2735:218:100","nodes":[],"body":{"id":54039,"nodeType":"Block","src":"2798:155:100","nodes":[],"statements":[{"expression":{"arguments":[{"commonType":{"typeIdentifier":"t_address","typeString":"address"},"id":54033,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftExpression":{"id":54028,"name":"_l1StandardBridgeProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":53962,"src":"2816:22:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"BinaryOperation","operator":"!=","rightExpression":{"arguments":[{"hexValue":"30","id":54031,"isConstant":false,"isLValue":false,"isPure":true,"kind":"number","lValueRequested":false,"nodeType":"Literal","src":"2850:1:100","typeDescriptions":{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"},"value":"0"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"}],"id":54030,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"nodeType":"ElementaryTypeNameExpression","src":"2842:7:100","typeDescriptions":{"typeIdentifier":"t_type$_t_address_$","typeString":"type(address)"},"typeName":{"id":54029,"name":"address","nodeType":"ElementaryTypeName","src":"2842:7:100","typeDescriptions":{}}},"id":54032,"isConstant":false,"isLValue":false,"isPure":true,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"2842:10:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"src":"2816:36:100","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},{"hexValue":"4665746368436861696e496e666f496e7075743a206c315374616e6461726442726964676550726f7879206e6f7420736574","id":54034,"isConstant":false,"isLValue":false,"isPure":true,"kind":"string","lValueRequested":false,"nodeType":"Literal","src":"2854:52:100","typeDescriptions":{"typeIdentifier":"t_stringliteral_be85b0ed3fc58e97f8b79e4d9fb1c191539515cae509acde6becd9338254d33b","typeString":"literal_string \"FetchChainInfoInput: l1StandardBridgeProxy not set\""},"value":"FetchChainInfoInput: l1StandardBridgeProxy not set"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_bool","typeString":"bool"},{"typeIdentifier":"t_stringliteral_be85b0ed3fc58e97f8b79e4d9fb1c191539515cae509acde6becd9338254d33b","typeString":"literal_string \"FetchChainInfoInput: l1StandardBridgeProxy not set\""}],"id":54027,"name":"require","nodeType":"Identifier","overloadedDeclarations":[-18,-18,-18],"referencedDeclaration":-18,"src":"2808:7:100","typeDescriptions":{"typeIdentifier":"t_function_require_pure$_t_bool_$_t_string_memory_ptr_$returns$__$","typeString":"function (bool,string memory) pure"}},"id":54035,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"2808:99:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":54036,"nodeType":"ExpressionStatement","src":"2808:99:100"},{"expression":{"id":54037,"name":"_l1StandardBridgeProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":53962,"src":"2924:22:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"functionReturnParameters":54026,"id":54038,"nodeType":"Return","src":"2917:29:100"}]},"functionSelector":"102b6069","implemented":true,"kind":"function","modifiers":[],"name":"l1StandardBridgeProxy","nameLocation":"2744:21:100","parameters":{"id":54023,"nodeType":"ParameterList","parameters":[],"src":"2765:2:100"},"returnParameters":{"id":54026,"nodeType":"ParameterList","parameters":[{"constant":false,"id":54025,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":54040,"src":"2789:7:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":54024,"name":"address","nodeType":"ElementaryTypeName","src":"2789:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"2788:9:100"},"scope":54041,"stateMutability":"view","virtual":false,"visibility":"public"}],"abstract":false,"baseContracts":[],"canonicalName":"FetchChainInfoInput","contractDependencies":[],"contractKind":"contract","fullyImplemented":true,"linearizedBaseContracts":[54041],"name":"FetchChainInfoInput","nameLocation":"2030:19:100","scope":56019,"usedErrors":[],"usedEvents":[]},{"id":54911,"nodeType":"ContractDefinition","src":"2957:10642:100","nodes":[{"id":54043,"nodeType":"VariableDeclaration","src":"3049:39:100","nodes":[],"constant":false,"mutability":"mutable","name":"_superchainConfigProxy","nameLocation":"3066:22:100","scope":54911,"stateVariable":true,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":54042,"name":"address","nodeType":"ElementaryTypeName","src":"3049:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"},{"id":54045,"nodeType":"VariableDeclaration","src":"3129:26:100","nodes":[],"constant":false,"mutability":"mutable","name":"_mipsImpl","nameLocation":"3146:9:100","scope":54911,"stateVariable":true,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":54044,"name":"address","nodeType":"ElementaryTypeName","src":"3129:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"},{"id":54047,"nodeType":"VariableDeclaration","src":"3161:36:100","nodes":[],"constant":false,"mutability":"mutable","name":"_preimageOracleImpl","nameLocation":"3178:19:100","scope":54911,"stateVariable":true,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":54046,"name":"address","nodeType":"ElementaryTypeName","src":"3161:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"},{"id":54049,"nodeType":"VariableDeclaration","src":"3230:36:100","nodes":[],"constant":false,"mutability":"mutable","name":"_addressManagerImpl","nameLocation":"3247:19:100","scope":54911,"stateVariable":true,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":54048,"name":"address","nodeType":"ElementaryTypeName","src":"3230:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"},{"id":54051,"nodeType":"VariableDeclaration","src":"3272:33:100","nodes":[],"constant":false,"mutability":"mutable","name":"_ethLockboxProxy","nameLocation":"3289:16:100","scope":54911,"stateVariable":true,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":54050,"name":"address","nodeType":"ElementaryTypeName","src":"3272:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"},{"id":54053,"nodeType":"VariableDeclaration","src":"3311:45:100","nodes":[],"constant":false,"mutability":"mutable","name":"_l1CrossDomainMessengerProxy","nameLocation":"3328:28:100","scope":54911,"stateVariable":true,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":54052,"name":"address","nodeType":"ElementaryTypeName","src":"3311:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"},{"id":54055,"nodeType":"VariableDeclaration","src":"3362:37:100","nodes":[],"constant":false,"mutability":"mutable","name":"_l1Erc721BridgeProxy","nameLocation":"3379:20:100","scope":54911,"stateVariable":true,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":54054,"name":"address","nodeType":"ElementaryTypeName","src":"3362:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"},{"id":54057,"nodeType":"VariableDeclaration","src":"3405:39:100","nodes":[],"constant":false,"mutability":"mutable","name":"_l1StandardBridgeProxy","nameLocation":"3422:22:100","scope":54911,"stateVariable":true,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":54056,"name":"address","nodeType":"ElementaryTypeName","src":"3405:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"},{"id":54059,"nodeType":"VariableDeclaration","src":"3450:37:100","nodes":[],"constant":false,"mutability":"mutable","name":"_l2OutputOracleProxy","nameLocation":"3467:20:100","scope":54911,"stateVariable":true,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":54058,"name":"address","nodeType":"ElementaryTypeName","src":"3450:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"},{"id":54061,"nodeType":"VariableDeclaration","src":"3493:51:100","nodes":[],"constant":false,"mutability":"mutable","name":"_optimismMintableErc20FactoryProxy","nameLocation":"3510:34:100","scope":54911,"stateVariable":true,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":54060,"name":"address","nodeType":"ElementaryTypeName","src":"3493:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"},{"id":54063,"nodeType":"VariableDeclaration","src":"3550:37:100","nodes":[],"constant":false,"mutability":"mutable","name":"_optimismPortalProxy","nameLocation":"3567:20:100","scope":54911,"stateVariable":true,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":54062,"name":"address","nodeType":"ElementaryTypeName","src":"3550:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"},{"id":54065,"nodeType":"VariableDeclaration","src":"3593:35:100","nodes":[],"constant":false,"mutability":"mutable","name":"_systemConfigProxy","nameLocation":"3610:18:100","scope":54911,"stateVariable":true,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":54064,"name":"address","nodeType":"ElementaryTypeName","src":"3593:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"},{"id":54067,"nodeType":"VariableDeclaration","src":"3634:39:100","nodes":[],"constant":false,"mutability":"mutable","name":"_opChainProxyAdminImpl","nameLocation":"3651:22:100","scope":54911,"stateVariable":true,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":54066,"name":"address","nodeType":"ElementaryTypeName","src":"3634:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"},{"id":54069,"nodeType":"VariableDeclaration","src":"3679:42:100","nodes":[],"constant":false,"mutability":"mutable","name":"_anchorStateRegistryProxy","nameLocation":"3696:25:100","scope":54911,"stateVariable":true,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":54068,"name":"address","nodeType":"ElementaryTypeName","src":"3679:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"},{"id":54071,"nodeType":"VariableDeclaration","src":"3727:50:100","nodes":[],"constant":false,"mutability":"mutable","name":"_delayedWethPermissionedGameProxy","nameLocation":"3744:33:100","scope":54911,"stateVariable":true,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":54070,"name":"address","nodeType":"ElementaryTypeName","src":"3727:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"},{"id":54073,"nodeType":"VariableDeclaration","src":"3783:52:100","nodes":[],"constant":false,"mutability":"mutable","name":"_delayedWethPermissionlessGameProxy","nameLocation":"3800:35:100","scope":54911,"stateVariable":true,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":54072,"name":"address","nodeType":"ElementaryTypeName","src":"3783:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"},{"id":54075,"nodeType":"VariableDeclaration","src":"3841:41:100","nodes":[],"constant":false,"mutability":"mutable","name":"_disputeGameFactoryProxy","nameLocation":"3858:24:100","scope":54911,"stateVariable":true,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":54074,"name":"address","nodeType":"ElementaryTypeName","src":"3841:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"},{"id":54077,"nodeType":"VariableDeclaration","src":"3888:38:100","nodes":[],"constant":false,"mutability":"mutable","name":"_faultDisputeGameImpl","nameLocation":"3905:21:100","scope":54911,"stateVariable":true,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":54076,"name":"address","nodeType":"ElementaryTypeName","src":"3888:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"},{"id":54079,"nodeType":"VariableDeclaration","src":"3932:48:100","nodes":[],"constant":false,"mutability":"mutable","name":"_faultDisputeGameCannonKonaImpl","nameLocation":"3949:31:100","scope":54911,"stateVariable":true,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":54078,"name":"address","nodeType":"ElementaryTypeName","src":"3932:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"},{"id":54081,"nodeType":"VariableDeclaration","src":"3986:45:100","nodes":[],"constant":false,"mutability":"mutable","name":"_permissionedDisputeGameImpl","nameLocation":"4003:28:100","scope":54911,"stateVariable":true,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":54080,"name":"address","nodeType":"ElementaryTypeName","src":"3986:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"},{"id":54083,"nodeType":"VariableDeclaration","src":"4051:35:100","nodes":[],"constant":false,"mutability":"mutable","name":"_systemConfigOwner","nameLocation":"4068:18:100","scope":54911,"stateVariable":true,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":54082,"name":"address","nodeType":"ElementaryTypeName","src":"4051:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"},{"id":54085,"nodeType":"VariableDeclaration","src":"4092:40:100","nodes":[],"constant":false,"mutability":"mutable","name":"_opChainProxyAdminOwner","nameLocation":"4109:23:100","scope":54911,"stateVariable":true,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":54084,"name":"address","nodeType":"ElementaryTypeName","src":"4092:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"},{"id":54087,"nodeType":"VariableDeclaration","src":"4138:33:100","nodes":[],"constant":false,"mutability":"mutable","name":"_opChainGuardian","nameLocation":"4155:16:100","scope":54911,"stateVariable":true,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":54086,"name":"address","nodeType":"ElementaryTypeName","src":"4138:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"},{"id":54089,"nodeType":"VariableDeclaration","src":"4177:28:100","nodes":[],"constant":false,"mutability":"mutable","name":"_challenger","nameLocation":"4194:11:100","scope":54911,"stateVariable":true,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":54088,"name":"address","nodeType":"ElementaryTypeName","src":"4177:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"},{"id":54091,"nodeType":"VariableDeclaration","src":"4211:26:100","nodes":[],"constant":false,"mutability":"mutable","name":"_proposer","nameLocation":"4228:9:100","scope":54911,"stateVariable":true,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":54090,"name":"address","nodeType":"ElementaryTypeName","src":"4211:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"},{"id":54093,"nodeType":"VariableDeclaration","src":"4243:35:100","nodes":[],"constant":false,"mutability":"mutable","name":"_unsafeBlockSigner","nameLocation":"4260:18:100","scope":54911,"stateVariable":true,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":54092,"name":"address","nodeType":"ElementaryTypeName","src":"4243:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"},{"id":54095,"nodeType":"VariableDeclaration","src":"4284:32:100","nodes":[],"constant":false,"mutability":"mutable","name":"_batchSubmitter","nameLocation":"4301:15:100","scope":54911,"stateVariable":true,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":54094,"name":"address","nodeType":"ElementaryTypeName","src":"4284:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"},{"id":54097,"nodeType":"VariableDeclaration","src":"4349:27:100","nodes":[],"constant":false,"mutability":"mutable","name":"_permissioned","nameLocation":"4363:13:100","scope":54911,"stateVariable":true,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"},"typeName":{"id":54096,"name":"bool","nodeType":"ElementaryTypeName","src":"4349:4:100","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},"visibility":"internal"},{"id":54099,"nodeType":"VariableDeclaration","src":"4382:29:100","nodes":[],"constant":false,"mutability":"mutable","name":"_permissionless","nameLocation":"4396:15:100","scope":54911,"stateVariable":true,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"},"typeName":{"id":54098,"name":"bool","nodeType":"ElementaryTypeName","src":"4382:4:100","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},"visibility":"internal"},{"id":54102,"nodeType":"VariableDeclaration","src":"4417:36:100","nodes":[],"constant":false,"mutability":"mutable","name":"_respectedGameType","nameLocation":"4435:18:100","scope":54911,"stateVariable":true,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_userDefinedValueType$_GameType_$70720","typeString":"GameType"},"typeName":{"id":54101,"nodeType":"UserDefinedTypeName","pathNode":{"id":54100,"name":"GameType","nameLocations":["4417:8:100"],"nodeType":"IdentifierPath","referencedDeclaration":70720,"src":"4417:8:100"},"referencedDeclaration":70720,"src":"4417:8:100","typeDescriptions":{"typeIdentifier":"t_userDefinedValueType$_GameType_$70720","typeString":"GameType"}},"visibility":"internal"},{"id":54384,"nodeType":"FunctionDefinition","src":"4460:2746:100","nodes":[],"body":{"id":54383,"nodeType":"Block","src":"4508:2698:100","nodes":[],"statements":[{"condition":{"commonType":{"typeIdentifier":"t_bytes4","typeString":"bytes4"},"id":54113,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftExpression":{"id":54109,"name":"_sel","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54104,"src":"4553:4:100","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},"nodeType":"BinaryOperation","operator":"==","rightExpression":{"expression":{"expression":{"id":54110,"name":"this","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":-28,"src":"4561:4:100","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$54911","typeString":"contract FetchChainInfoOutput"}},"id":54111,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"4566:21:100","memberName":"superchainConfigProxy","nodeType":"MemberAccess","referencedDeclaration":54627,"src":"4561:26:100","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":54112,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"memberLocation":"4588:8:100","memberName":"selector","nodeType":"MemberAccess","src":"4561:35:100","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},"src":"4553:43:100","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},"falseBody":{"condition":{"commonType":{"typeIdentifier":"t_bytes4","typeString":"bytes4"},"id":54122,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftExpression":{"id":54118,"name":"_sel","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54104,"src":"4686:4:100","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},"nodeType":"BinaryOperation","operator":"==","rightExpression":{"expression":{"expression":{"id":54119,"name":"this","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":-28,"src":"4694:4:100","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$54911","typeString":"contract FetchChainInfoOutput"}},"id":54120,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"4699:8:100","memberName":"mipsImpl","nodeType":"MemberAccess","referencedDeclaration":54723,"src":"4694:13:100","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":54121,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"memberLocation":"4708:8:100","memberName":"selector","nodeType":"MemberAccess","src":"4694:22:100","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},"src":"4686:30:100","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},"falseBody":{"condition":{"commonType":{"typeIdentifier":"t_bytes4","typeString":"bytes4"},"id":54131,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftExpression":{"id":54127,"name":"_sel","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54104,"src":"4754:4:100","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},"nodeType":"BinaryOperation","operator":"==","rightExpression":{"expression":{"expression":{"id":54128,"name":"this","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":-28,"src":"4762:4:100","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$54911","typeString":"contract FetchChainInfoOutput"}},"id":54129,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"4767:18:100","memberName":"preimageOracleImpl","nodeType":"MemberAccess","referencedDeclaration":54759,"src":"4762:23:100","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":54130,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"memberLocation":"4786:8:100","memberName":"selector","nodeType":"MemberAccess","src":"4762:32:100","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},"src":"4754:40:100","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},"falseBody":{"condition":{"commonType":{"typeIdentifier":"t_bytes4","typeString":"bytes4"},"id":54140,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftExpression":{"id":54136,"name":"_sel","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54104,"src":"4873:4:100","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},"nodeType":"BinaryOperation","operator":"==","rightExpression":{"expression":{"expression":{"id":54137,"name":"this","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":-28,"src":"4881:4:100","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$54911","typeString":"contract FetchChainInfoOutput"}},"id":54138,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"4886:18:100","memberName":"addressManagerImpl","nodeType":"MemberAccess","referencedDeclaration":54457,"src":"4881:23:100","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":54139,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"memberLocation":"4905:8:100","memberName":"selector","nodeType":"MemberAccess","src":"4881:32:100","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},"src":"4873:40:100","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},"falseBody":{"condition":{"commonType":{"typeIdentifier":"t_bytes4","typeString":"bytes4"},"id":54149,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftExpression":{"id":54145,"name":"_sel","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54104,"src":"4961:4:100","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},"nodeType":"BinaryOperation","operator":"==","rightExpression":{"expression":{"expression":{"id":54146,"name":"this","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":-28,"src":"4969:4:100","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$54911","typeString":"contract FetchChainInfoOutput"}},"id":54147,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"4974:15:100","memberName":"ethLockboxProxy","nodeType":"MemberAccess","referencedDeclaration":54465,"src":"4969:20:100","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":54148,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"memberLocation":"4990:8:100","memberName":"selector","nodeType":"MemberAccess","src":"4969:29:100","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},"src":"4961:37:100","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},"falseBody":{"condition":{"commonType":{"typeIdentifier":"t_bytes4","typeString":"bytes4"},"id":54158,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftExpression":{"id":54154,"name":"_sel","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54104,"src":"5043:4:100","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},"nodeType":"BinaryOperation","operator":"==","rightExpression":{"expression":{"expression":{"id":54155,"name":"this","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":-28,"src":"5051:4:100","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$54911","typeString":"contract FetchChainInfoOutput"}},"id":54156,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"5056:27:100","memberName":"l1CrossDomainMessengerProxy","nodeType":"MemberAccess","referencedDeclaration":54483,"src":"5051:32:100","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":54157,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"memberLocation":"5084:8:100","memberName":"selector","nodeType":"MemberAccess","src":"5051:41:100","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},"src":"5043:49:100","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},"falseBody":{"condition":{"commonType":{"typeIdentifier":"t_bytes4","typeString":"bytes4"},"id":54167,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftExpression":{"id":54163,"name":"_sel","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54104,"src":"5149:4:100","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},"nodeType":"BinaryOperation","operator":"==","rightExpression":{"expression":{"expression":{"id":54164,"name":"this","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":-28,"src":"5157:4:100","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$54911","typeString":"contract FetchChainInfoOutput"}},"id":54165,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"5162:19:100","memberName":"l1Erc721BridgeProxy","nodeType":"MemberAccess","referencedDeclaration":54501,"src":"5157:24:100","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":54166,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"memberLocation":"5182:8:100","memberName":"selector","nodeType":"MemberAccess","src":"5157:33:100","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},"src":"5149:41:100","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},"falseBody":{"condition":{"commonType":{"typeIdentifier":"t_bytes4","typeString":"bytes4"},"id":54176,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftExpression":{"id":54172,"name":"_sel","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54104,"src":"5239:4:100","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},"nodeType":"BinaryOperation","operator":"==","rightExpression":{"expression":{"expression":{"id":54173,"name":"this","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":-28,"src":"5247:4:100","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$54911","typeString":"contract FetchChainInfoOutput"}},"id":54174,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"5252:21:100","memberName":"l1StandardBridgeProxy","nodeType":"MemberAccess","referencedDeclaration":54519,"src":"5247:26:100","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":54175,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"memberLocation":"5274:8:100","memberName":"selector","nodeType":"MemberAccess","src":"5247:35:100","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},"src":"5239:43:100","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},"falseBody":{"condition":{"commonType":{"typeIdentifier":"t_bytes4","typeString":"bytes4"},"id":54185,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftExpression":{"id":54181,"name":"_sel","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54104,"src":"5333:4:100","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},"nodeType":"BinaryOperation","operator":"==","rightExpression":{"expression":{"expression":{"id":54182,"name":"this","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":-28,"src":"5341:4:100","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$54911","typeString":"contract FetchChainInfoOutput"}},"id":54183,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"5346:19:100","memberName":"l2OutputOracleProxy","nodeType":"MemberAccess","referencedDeclaration":54537,"src":"5341:24:100","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":54184,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"memberLocation":"5366:8:100","memberName":"selector","nodeType":"MemberAccess","src":"5341:33:100","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},"src":"5333:41:100","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},"falseBody":{"condition":{"commonType":{"typeIdentifier":"t_bytes4","typeString":"bytes4"},"id":54194,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftExpression":{"id":54190,"name":"_sel","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54104,"src":"5423:4:100","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},"nodeType":"BinaryOperation","operator":"==","rightExpression":{"expression":{"expression":{"id":54191,"name":"this","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":-28,"src":"5431:4:100","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$54911","typeString":"contract FetchChainInfoOutput"}},"id":54192,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"5436:33:100","memberName":"optimismMintableErc20FactoryProxy","nodeType":"MemberAccess","referencedDeclaration":54555,"src":"5431:38:100","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":54193,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"memberLocation":"5470:8:100","memberName":"selector","nodeType":"MemberAccess","src":"5431:47:100","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},"src":"5423:55:100","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},"falseBody":{"condition":{"commonType":{"typeIdentifier":"t_bytes4","typeString":"bytes4"},"id":54203,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftExpression":{"id":54199,"name":"_sel","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54104,"src":"5541:4:100","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},"nodeType":"BinaryOperation","operator":"==","rightExpression":{"expression":{"expression":{"id":54200,"name":"this","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":-28,"src":"5549:4:100","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$54911","typeString":"contract FetchChainInfoOutput"}},"id":54201,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"5554:19:100","memberName":"optimismPortalProxy","nodeType":"MemberAccess","referencedDeclaration":54573,"src":"5549:24:100","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":54202,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"memberLocation":"5574:8:100","memberName":"selector","nodeType":"MemberAccess","src":"5549:33:100","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},"src":"5541:41:100","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},"falseBody":{"condition":{"commonType":{"typeIdentifier":"t_bytes4","typeString":"bytes4"},"id":54212,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftExpression":{"id":54208,"name":"_sel","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54104,"src":"5631:4:100","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},"nodeType":"BinaryOperation","operator":"==","rightExpression":{"expression":{"expression":{"id":54209,"name":"this","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":-28,"src":"5639:4:100","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$54911","typeString":"contract FetchChainInfoOutput"}},"id":54210,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"5644:17:100","memberName":"systemConfigProxy","nodeType":"MemberAccess","referencedDeclaration":54591,"src":"5639:22:100","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":54211,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"memberLocation":"5662:8:100","memberName":"selector","nodeType":"MemberAccess","src":"5639:31:100","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},"src":"5631:39:100","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},"falseBody":{"condition":{"commonType":{"typeIdentifier":"t_bytes4","typeString":"bytes4"},"id":54221,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftExpression":{"id":54217,"name":"_sel","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54104,"src":"5717:4:100","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},"nodeType":"BinaryOperation","operator":"==","rightExpression":{"expression":{"expression":{"id":54218,"name":"this","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":-28,"src":"5725:4:100","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$54911","typeString":"contract FetchChainInfoOutput"}},"id":54219,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"5730:21:100","memberName":"opChainProxyAdminImpl","nodeType":"MemberAccess","referencedDeclaration":54609,"src":"5725:26:100","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":54220,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"memberLocation":"5752:8:100","memberName":"selector","nodeType":"MemberAccess","src":"5725:35:100","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},"src":"5717:43:100","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},"falseBody":{"condition":{"commonType":{"typeIdentifier":"t_bytes4","typeString":"bytes4"},"id":54230,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftExpression":{"id":54226,"name":"_sel","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54104,"src":"5811:4:100","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},"nodeType":"BinaryOperation","operator":"==","rightExpression":{"expression":{"expression":{"id":54227,"name":"this","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":-28,"src":"5819:4:100","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$54911","typeString":"contract FetchChainInfoOutput"}},"id":54228,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"5824:24:100","memberName":"anchorStateRegistryProxy","nodeType":"MemberAccess","referencedDeclaration":54645,"src":"5819:29:100","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":54229,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"memberLocation":"5849:8:100","memberName":"selector","nodeType":"MemberAccess","src":"5819:38:100","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},"src":"5811:46:100","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},"falseBody":{"condition":{"commonType":{"typeIdentifier":"t_bytes4","typeString":"bytes4"},"id":54239,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftExpression":{"id":54235,"name":"_sel","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54104,"src":"5911:4:100","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},"nodeType":"BinaryOperation","operator":"==","rightExpression":{"expression":{"expression":{"id":54236,"name":"this","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":-28,"src":"5919:4:100","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$54911","typeString":"contract FetchChainInfoOutput"}},"id":54237,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"5924:32:100","memberName":"delayedWethPermissionedGameProxy","nodeType":"MemberAccess","referencedDeclaration":54653,"src":"5919:37:100","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":54238,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"memberLocation":"5957:8:100","memberName":"selector","nodeType":"MemberAccess","src":"5919:46:100","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},"src":"5911:54:100","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},"falseBody":{"condition":{"commonType":{"typeIdentifier":"t_bytes4","typeString":"bytes4"},"id":54248,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftExpression":{"id":54244,"name":"_sel","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54104,"src":"6027:4:100","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},"nodeType":"BinaryOperation","operator":"==","rightExpression":{"expression":{"expression":{"id":54245,"name":"this","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":-28,"src":"6035:4:100","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$54911","typeString":"contract FetchChainInfoOutput"}},"id":54246,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"6040:34:100","memberName":"delayedWethPermissionlessGameProxy","nodeType":"MemberAccess","referencedDeclaration":54661,"src":"6035:39:100","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":54247,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"memberLocation":"6075:8:100","memberName":"selector","nodeType":"MemberAccess","src":"6035:48:100","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},"src":"6027:56:100","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},"falseBody":{"condition":{"commonType":{"typeIdentifier":"t_bytes4","typeString":"bytes4"},"id":54257,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftExpression":{"id":54253,"name":"_sel","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54104,"src":"6147:4:100","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},"nodeType":"BinaryOperation","operator":"==","rightExpression":{"expression":{"expression":{"id":54254,"name":"this","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":-28,"src":"6155:4:100","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$54911","typeString":"contract FetchChainInfoOutput"}},"id":54255,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"6160:23:100","memberName":"disputeGameFactoryProxy","nodeType":"MemberAccess","referencedDeclaration":54669,"src":"6155:28:100","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":54256,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"memberLocation":"6184:8:100","memberName":"selector","nodeType":"MemberAccess","src":"6155:37:100","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},"src":"6147:45:100","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},"falseBody":{"condition":{"commonType":{"typeIdentifier":"t_bytes4","typeString":"bytes4"},"id":54266,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftExpression":{"id":54262,"name":"_sel","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54104,"src":"6245:4:100","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},"nodeType":"BinaryOperation","operator":"==","rightExpression":{"expression":{"expression":{"id":54263,"name":"this","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":-28,"src":"6253:4:100","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$54911","typeString":"contract FetchChainInfoOutput"}},"id":54264,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"6258:20:100","memberName":"faultDisputeGameImpl","nodeType":"MemberAccess","referencedDeclaration":54687,"src":"6253:25:100","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":54265,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"memberLocation":"6279:8:100","memberName":"selector","nodeType":"MemberAccess","src":"6253:34:100","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},"src":"6245:42:100","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},"falseBody":{"condition":{"commonType":{"typeIdentifier":"t_bytes4","typeString":"bytes4"},"id":54275,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftExpression":{"id":54271,"name":"_sel","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54104,"src":"6337:4:100","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},"nodeType":"BinaryOperation","operator":"==","rightExpression":{"expression":{"expression":{"id":54272,"name":"this","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":-28,"src":"6345:4:100","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$54911","typeString":"contract FetchChainInfoOutput"}},"id":54273,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"6350:30:100","memberName":"faultDisputeGameCannonKonaImpl","nodeType":"MemberAccess","referencedDeclaration":54705,"src":"6345:35:100","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":54274,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"memberLocation":"6381:8:100","memberName":"selector","nodeType":"MemberAccess","src":"6345:44:100","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},"src":"6337:52:100","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},"falseBody":{"condition":{"commonType":{"typeIdentifier":"t_bytes4","typeString":"bytes4"},"id":54284,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftExpression":{"id":54280,"name":"_sel","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54104,"src":"6449:4:100","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},"nodeType":"BinaryOperation","operator":"==","rightExpression":{"expression":{"expression":{"id":54281,"name":"this","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":-28,"src":"6457:4:100","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$54911","typeString":"contract FetchChainInfoOutput"}},"id":54282,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"6462:27:100","memberName":"permissionedDisputeGameImpl","nodeType":"MemberAccess","referencedDeclaration":54741,"src":"6457:32:100","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":54283,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"memberLocation":"6490:8:100","memberName":"selector","nodeType":"MemberAccess","src":"6457:41:100","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},"src":"6449:49:100","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},"falseBody":{"condition":{"commonType":{"typeIdentifier":"t_bytes4","typeString":"bytes4"},"id":54293,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftExpression":{"id":54289,"name":"_sel","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54104,"src":"6572:4:100","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},"nodeType":"BinaryOperation","operator":"==","rightExpression":{"expression":{"expression":{"id":54290,"name":"this","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":-28,"src":"6580:4:100","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$54911","typeString":"contract FetchChainInfoOutput"}},"id":54291,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"6585:17:100","memberName":"systemConfigOwner","nodeType":"MemberAccess","referencedDeclaration":54777,"src":"6580:22:100","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":54292,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"memberLocation":"6603:8:100","memberName":"selector","nodeType":"MemberAccess","src":"6580:31:100","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},"src":"6572:39:100","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},"falseBody":{"condition":{"commonType":{"typeIdentifier":"t_bytes4","typeString":"bytes4"},"id":54302,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftExpression":{"id":54298,"name":"_sel","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54104,"src":"6658:4:100","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},"nodeType":"BinaryOperation","operator":"==","rightExpression":{"expression":{"expression":{"id":54299,"name":"this","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":-28,"src":"6666:4:100","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$54911","typeString":"contract FetchChainInfoOutput"}},"id":54300,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"6671:22:100","memberName":"opChainProxyAdminOwner","nodeType":"MemberAccess","referencedDeclaration":54795,"src":"6666:27:100","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":54301,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"memberLocation":"6694:8:100","memberName":"selector","nodeType":"MemberAccess","src":"6666:36:100","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},"src":"6658:44:100","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},"falseBody":{"condition":{"commonType":{"typeIdentifier":"t_bytes4","typeString":"bytes4"},"id":54311,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftExpression":{"id":54307,"name":"_sel","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54104,"src":"6754:4:100","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},"nodeType":"BinaryOperation","operator":"==","rightExpression":{"expression":{"expression":{"id":54308,"name":"this","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":-28,"src":"6762:4:100","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$54911","typeString":"contract FetchChainInfoOutput"}},"id":54309,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"6767:15:100","memberName":"opChainGuardian","nodeType":"MemberAccess","referencedDeclaration":54813,"src":"6762:20:100","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":54310,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"memberLocation":"6783:8:100","memberName":"selector","nodeType":"MemberAccess","src":"6762:29:100","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},"src":"6754:37:100","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},"falseBody":{"condition":{"commonType":{"typeIdentifier":"t_bytes4","typeString":"bytes4"},"id":54320,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftExpression":{"id":54316,"name":"_sel","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54104,"src":"6836:4:100","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},"nodeType":"BinaryOperation","operator":"==","rightExpression":{"expression":{"expression":{"id":54317,"name":"this","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":-28,"src":"6844:4:100","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$54911","typeString":"contract FetchChainInfoOutput"}},"id":54318,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"6849:10:100","memberName":"challenger","nodeType":"MemberAccess","referencedDeclaration":54831,"src":"6844:15:100","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":54319,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"memberLocation":"6860:8:100","memberName":"selector","nodeType":"MemberAccess","src":"6844:24:100","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},"src":"6836:32:100","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},"falseBody":{"condition":{"commonType":{"typeIdentifier":"t_bytes4","typeString":"bytes4"},"id":54329,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftExpression":{"id":54325,"name":"_sel","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54104,"src":"6908:4:100","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},"nodeType":"BinaryOperation","operator":"==","rightExpression":{"expression":{"expression":{"id":54326,"name":"this","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":-28,"src":"6916:4:100","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$54911","typeString":"contract FetchChainInfoOutput"}},"id":54327,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"6921:8:100","memberName":"proposer","nodeType":"MemberAccess","referencedDeclaration":54849,"src":"6916:13:100","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":54328,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"memberLocation":"6930:8:100","memberName":"selector","nodeType":"MemberAccess","src":"6916:22:100","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},"src":"6908:30:100","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},"falseBody":{"condition":{"commonType":{"typeIdentifier":"t_bytes4","typeString":"bytes4"},"id":54338,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftExpression":{"id":54334,"name":"_sel","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54104,"src":"6976:4:100","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},"nodeType":"BinaryOperation","operator":"==","rightExpression":{"expression":{"expression":{"id":54335,"name":"this","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":-28,"src":"6984:4:100","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$54911","typeString":"contract FetchChainInfoOutput"}},"id":54336,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"6989:17:100","memberName":"unsafeBlockSigner","nodeType":"MemberAccess","referencedDeclaration":54867,"src":"6984:22:100","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":54337,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"memberLocation":"7007:8:100","memberName":"selector","nodeType":"MemberAccess","src":"6984:31:100","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},"src":"6976:39:100","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},"falseBody":{"condition":{"commonType":{"typeIdentifier":"t_bytes4","typeString":"bytes4"},"id":54347,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftExpression":{"id":54343,"name":"_sel","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54104,"src":"7062:4:100","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},"nodeType":"BinaryOperation","operator":"==","rightExpression":{"expression":{"expression":{"id":54344,"name":"this","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":-28,"src":"7070:4:100","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$54911","typeString":"contract FetchChainInfoOutput"}},"id":54345,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"7075:14:100","memberName":"batchSubmitter","nodeType":"MemberAccess","referencedDeclaration":54885,"src":"7070:19:100","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":54346,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"memberLocation":"7090:8:100","memberName":"selector","nodeType":"MemberAccess","src":"7070:28:100","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},"src":"7062:36:100","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},"falseBody":{"expression":{"arguments":[{"hexValue":"4665746368436861696e496e666f4f75747075743a20756e6b6e6f776e20616464726573732073656c6563746f722074657374","id":54353,"isConstant":false,"isLValue":false,"isPure":true,"kind":"string","lValueRequested":false,"nodeType":"Literal","src":"7145:53:100","typeDescriptions":{"typeIdentifier":"t_stringliteral_8be6a92cba5443877e2b6bededc383e178c3f2718dce3f3864f1721c31f5c065","typeString":"literal_string \"FetchChainInfoOutput: unknown address selector test\""},"value":"FetchChainInfoOutput: unknown address selector test"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_stringliteral_8be6a92cba5443877e2b6bededc383e178c3f2718dce3f3864f1721c31f5c065","typeString":"literal_string \"FetchChainInfoOutput: unknown address selector test\""}],"id":54352,"name":"revert","nodeType":"Identifier","overloadedDeclarations":[-19,-19],"referencedDeclaration":-19,"src":"7138:6:100","typeDescriptions":{"typeIdentifier":"t_function_revert_pure$_t_string_memory_ptr_$returns$__$","typeString":"function (string memory) pure"}},"id":54354,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"7138:61:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":54355,"nodeType":"ExpressionStatement","src":"7138:61:100"},"id":54356,"nodeType":"IfStatement","src":"7058:141:100","trueBody":{"expression":{"id":54350,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftHandSide":{"id":54348,"name":"_batchSubmitter","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54095,"src":"7100:15:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"Assignment","operator":"=","rightHandSide":{"id":54349,"name":"_addr","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54106,"src":"7118:5:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"src":"7100:23:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"id":54351,"nodeType":"ExpressionStatement","src":"7100:23:100"}},"id":54357,"nodeType":"IfStatement","src":"6972:227:100","trueBody":{"expression":{"id":54341,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftHandSide":{"id":54339,"name":"_unsafeBlockSigner","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54093,"src":"7017:18:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"Assignment","operator":"=","rightHandSide":{"id":54340,"name":"_addr","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54106,"src":"7038:5:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"src":"7017:26:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"id":54342,"nodeType":"ExpressionStatement","src":"7017:26:100"}},"id":54358,"nodeType":"IfStatement","src":"6904:295:100","trueBody":{"expression":{"id":54332,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftHandSide":{"id":54330,"name":"_proposer","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54091,"src":"6940:9:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"Assignment","operator":"=","rightHandSide":{"id":54331,"name":"_addr","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54106,"src":"6952:5:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"src":"6940:17:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"id":54333,"nodeType":"ExpressionStatement","src":"6940:17:100"}},"id":54359,"nodeType":"IfStatement","src":"6832:367:100","trueBody":{"expression":{"id":54323,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftHandSide":{"id":54321,"name":"_challenger","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54089,"src":"6870:11:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"Assignment","operator":"=","rightHandSide":{"id":54322,"name":"_addr","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54106,"src":"6884:5:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"src":"6870:19:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"id":54324,"nodeType":"ExpressionStatement","src":"6870:19:100"}},"id":54360,"nodeType":"IfStatement","src":"6750:449:100","trueBody":{"expression":{"id":54314,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftHandSide":{"id":54312,"name":"_opChainGuardian","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54087,"src":"6793:16:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"Assignment","operator":"=","rightHandSide":{"id":54313,"name":"_addr","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54106,"src":"6812:5:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"src":"6793:24:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"id":54315,"nodeType":"ExpressionStatement","src":"6793:24:100"}},"id":54361,"nodeType":"IfStatement","src":"6654:545:100","trueBody":{"expression":{"id":54305,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftHandSide":{"id":54303,"name":"_opChainProxyAdminOwner","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54085,"src":"6704:23:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"Assignment","operator":"=","rightHandSide":{"id":54304,"name":"_addr","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54106,"src":"6730:5:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"src":"6704:31:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"id":54306,"nodeType":"ExpressionStatement","src":"6704:31:100"}},"id":54362,"nodeType":"IfStatement","src":"6568:631:100","trueBody":{"expression":{"id":54296,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftHandSide":{"id":54294,"name":"_systemConfigOwner","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54083,"src":"6613:18:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"Assignment","operator":"=","rightHandSide":{"id":54295,"name":"_addr","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54106,"src":"6634:5:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"src":"6613:26:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"id":54297,"nodeType":"ExpressionStatement","src":"6613:26:100"}},"id":54363,"nodeType":"IfStatement","src":"6445:754:100","trueBody":{"expression":{"id":54287,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftHandSide":{"id":54285,"name":"_permissionedDisputeGameImpl","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54081,"src":"6500:28:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"Assignment","operator":"=","rightHandSide":{"id":54286,"name":"_addr","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54106,"src":"6531:5:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"src":"6500:36:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"id":54288,"nodeType":"ExpressionStatement","src":"6500:36:100"}},"id":54364,"nodeType":"IfStatement","src":"6333:866:100","trueBody":{"expression":{"id":54278,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftHandSide":{"id":54276,"name":"_faultDisputeGameCannonKonaImpl","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54079,"src":"6391:31:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"Assignment","operator":"=","rightHandSide":{"id":54277,"name":"_addr","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54106,"src":"6425:5:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"src":"6391:39:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"id":54279,"nodeType":"ExpressionStatement","src":"6391:39:100"}},"id":54365,"nodeType":"IfStatement","src":"6241:958:100","trueBody":{"expression":{"id":54269,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftHandSide":{"id":54267,"name":"_faultDisputeGameImpl","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54077,"src":"6289:21:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"Assignment","operator":"=","rightHandSide":{"id":54268,"name":"_addr","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54106,"src":"6313:5:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"src":"6289:29:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"id":54270,"nodeType":"ExpressionStatement","src":"6289:29:100"}},"id":54366,"nodeType":"IfStatement","src":"6143:1056:100","trueBody":{"expression":{"id":54260,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftHandSide":{"id":54258,"name":"_disputeGameFactoryProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54075,"src":"6194:24:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"Assignment","operator":"=","rightHandSide":{"id":54259,"name":"_addr","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54106,"src":"6221:5:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"src":"6194:32:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"id":54261,"nodeType":"ExpressionStatement","src":"6194:32:100"}},"id":54367,"nodeType":"IfStatement","src":"6023:1176:100","trueBody":{"expression":{"id":54251,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftHandSide":{"id":54249,"name":"_delayedWethPermissionlessGameProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54073,"src":"6085:35:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"Assignment","operator":"=","rightHandSide":{"id":54250,"name":"_addr","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54106,"src":"6123:5:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"src":"6085:43:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"id":54252,"nodeType":"ExpressionStatement","src":"6085:43:100"}},"id":54368,"nodeType":"IfStatement","src":"5907:1292:100","trueBody":{"expression":{"id":54242,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftHandSide":{"id":54240,"name":"_delayedWethPermissionedGameProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54071,"src":"5967:33:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"Assignment","operator":"=","rightHandSide":{"id":54241,"name":"_addr","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54106,"src":"6003:5:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"src":"5967:41:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"id":54243,"nodeType":"ExpressionStatement","src":"5967:41:100"}},"id":54369,"nodeType":"IfStatement","src":"5807:1392:100","trueBody":{"expression":{"id":54233,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftHandSide":{"id":54231,"name":"_anchorStateRegistryProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54069,"src":"5859:25:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"Assignment","operator":"=","rightHandSide":{"id":54232,"name":"_addr","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54106,"src":"5887:5:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"src":"5859:33:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"id":54234,"nodeType":"ExpressionStatement","src":"5859:33:100"}},"id":54370,"nodeType":"IfStatement","src":"5713:1486:100","trueBody":{"expression":{"id":54224,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftHandSide":{"id":54222,"name":"_opChainProxyAdminImpl","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54067,"src":"5762:22:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"Assignment","operator":"=","rightHandSide":{"id":54223,"name":"_addr","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54106,"src":"5787:5:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"src":"5762:30:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"id":54225,"nodeType":"ExpressionStatement","src":"5762:30:100"}},"id":54371,"nodeType":"IfStatement","src":"5627:1572:100","trueBody":{"expression":{"id":54215,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftHandSide":{"id":54213,"name":"_systemConfigProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54065,"src":"5672:18:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"Assignment","operator":"=","rightHandSide":{"id":54214,"name":"_addr","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54106,"src":"5693:5:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"src":"5672:26:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"id":54216,"nodeType":"ExpressionStatement","src":"5672:26:100"}},"id":54372,"nodeType":"IfStatement","src":"5537:1662:100","trueBody":{"expression":{"id":54206,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftHandSide":{"id":54204,"name":"_optimismPortalProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54063,"src":"5584:20:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"Assignment","operator":"=","rightHandSide":{"id":54205,"name":"_addr","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54106,"src":"5607:5:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"src":"5584:28:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"id":54207,"nodeType":"ExpressionStatement","src":"5584:28:100"}},"id":54373,"nodeType":"IfStatement","src":"5419:1780:100","trueBody":{"expression":{"id":54197,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftHandSide":{"id":54195,"name":"_optimismMintableErc20FactoryProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54061,"src":"5480:34:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"Assignment","operator":"=","rightHandSide":{"id":54196,"name":"_addr","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54106,"src":"5517:5:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"src":"5480:42:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"id":54198,"nodeType":"ExpressionStatement","src":"5480:42:100"}},"id":54374,"nodeType":"IfStatement","src":"5329:1870:100","trueBody":{"expression":{"id":54188,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftHandSide":{"id":54186,"name":"_l2OutputOracleProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54059,"src":"5376:20:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"Assignment","operator":"=","rightHandSide":{"id":54187,"name":"_addr","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54106,"src":"5399:5:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"src":"5376:28:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"id":54189,"nodeType":"ExpressionStatement","src":"5376:28:100"}},"id":54375,"nodeType":"IfStatement","src":"5235:1964:100","trueBody":{"expression":{"id":54179,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftHandSide":{"id":54177,"name":"_l1StandardBridgeProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54057,"src":"5284:22:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"Assignment","operator":"=","rightHandSide":{"id":54178,"name":"_addr","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54106,"src":"5309:5:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"src":"5284:30:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"id":54180,"nodeType":"ExpressionStatement","src":"5284:30:100"}},"id":54376,"nodeType":"IfStatement","src":"5145:2054:100","trueBody":{"expression":{"id":54170,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftHandSide":{"id":54168,"name":"_l1Erc721BridgeProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54055,"src":"5192:20:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"Assignment","operator":"=","rightHandSide":{"id":54169,"name":"_addr","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54106,"src":"5215:5:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"src":"5192:28:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"id":54171,"nodeType":"ExpressionStatement","src":"5192:28:100"}},"id":54377,"nodeType":"IfStatement","src":"5039:2160:100","trueBody":{"expression":{"id":54161,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftHandSide":{"id":54159,"name":"_l1CrossDomainMessengerProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54053,"src":"5094:28:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"Assignment","operator":"=","rightHandSide":{"id":54160,"name":"_addr","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54106,"src":"5125:5:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"src":"5094:36:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"id":54162,"nodeType":"ExpressionStatement","src":"5094:36:100"}},"id":54378,"nodeType":"IfStatement","src":"4957:2242:100","trueBody":{"expression":{"id":54152,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftHandSide":{"id":54150,"name":"_ethLockboxProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54051,"src":"5000:16:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"Assignment","operator":"=","rightHandSide":{"id":54151,"name":"_addr","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54106,"src":"5019:5:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"src":"5000:24:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"id":54153,"nodeType":"ExpressionStatement","src":"5000:24:100"}},"id":54379,"nodeType":"IfStatement","src":"4869:2330:100","trueBody":{"expression":{"id":54143,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftHandSide":{"id":54141,"name":"_addressManagerImpl","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54049,"src":"4915:19:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"Assignment","operator":"=","rightHandSide":{"id":54142,"name":"_addr","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54106,"src":"4937:5:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"src":"4915:27:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"id":54144,"nodeType":"ExpressionStatement","src":"4915:27:100"}},"id":54380,"nodeType":"IfStatement","src":"4750:2449:100","trueBody":{"expression":{"id":54134,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftHandSide":{"id":54132,"name":"_preimageOracleImpl","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54047,"src":"4796:19:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"Assignment","operator":"=","rightHandSide":{"id":54133,"name":"_addr","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54106,"src":"4818:5:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"src":"4796:27:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"id":54135,"nodeType":"ExpressionStatement","src":"4796:27:100"}},"id":54381,"nodeType":"IfStatement","src":"4682:2517:100","trueBody":{"expression":{"id":54125,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftHandSide":{"id":54123,"name":"_mipsImpl","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54045,"src":"4718:9:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"Assignment","operator":"=","rightHandSide":{"id":54124,"name":"_addr","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54106,"src":"4730:5:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"src":"4718:17:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"id":54126,"nodeType":"ExpressionStatement","src":"4718:17:100"}},"id":54382,"nodeType":"IfStatement","src":"4549:2650:100","trueBody":{"expression":{"id":54116,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftHandSide":{"id":54114,"name":"_superchainConfigProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54043,"src":"4598:22:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"Assignment","operator":"=","rightHandSide":{"id":54115,"name":"_addr","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54106,"src":"4623:5:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"src":"4598:30:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"id":54117,"nodeType":"ExpressionStatement","src":"4598:30:100"}}]},"functionSelector":"c3e39250","implemented":true,"kind":"function","modifiers":[],"name":"set","nameLocation":"4469:3:100","parameters":{"id":54107,"nodeType":"ParameterList","parameters":[{"constant":false,"id":54104,"mutability":"mutable","name":"_sel","nameLocation":"4480:4:100","nodeType":"VariableDeclaration","scope":54384,"src":"4473:11:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"},"typeName":{"id":54103,"name":"bytes4","nodeType":"ElementaryTypeName","src":"4473:6:100","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},"visibility":"internal"},{"constant":false,"id":54106,"mutability":"mutable","name":"_addr","nameLocation":"4494:5:100","nodeType":"VariableDeclaration","scope":54384,"src":"4486:13:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":54105,"name":"address","nodeType":"ElementaryTypeName","src":"4486:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"4472:28:100"},"returnParameters":{"id":54108,"nodeType":"ParameterList","parameters":[],"src":"4508:0:100"},"scope":54911,"stateMutability":"nonpayable","virtual":false,"visibility":"public"},{"id":54416,"nodeType":"FunctionDefinition","src":"7212:271:100","nodes":[],"body":{"id":54415,"nodeType":"Block","src":"7257:226:100","nodes":[],"statements":[{"condition":{"commonType":{"typeIdentifier":"t_bytes4","typeString":"bytes4"},"id":54395,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftExpression":{"id":54391,"name":"_sel","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54386,"src":"7271:4:100","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},"nodeType":"BinaryOperation","operator":"==","rightExpression":{"expression":{"expression":{"id":54392,"name":"this","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":-28,"src":"7279:4:100","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$54911","typeString":"contract FetchChainInfoOutput"}},"id":54393,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"7284:12:100","memberName":"permissioned","nodeType":"MemberAccess","referencedDeclaration":54893,"src":"7279:17:100","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_bool_$","typeString":"function () view external returns (bool)"}},"id":54394,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"memberLocation":"7297:8:100","memberName":"selector","nodeType":"MemberAccess","src":"7279:26:100","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},"src":"7271:34:100","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},"falseBody":{"condition":{"commonType":{"typeIdentifier":"t_bytes4","typeString":"bytes4"},"id":54404,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftExpression":{"id":54400,"name":"_sel","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54386,"src":"7347:4:100","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},"nodeType":"BinaryOperation","operator":"==","rightExpression":{"expression":{"expression":{"id":54401,"name":"this","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":-28,"src":"7355:4:100","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$54911","typeString":"contract FetchChainInfoOutput"}},"id":54402,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"7360:14:100","memberName":"permissionless","nodeType":"MemberAccess","referencedDeclaration":54901,"src":"7355:19:100","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_bool_$","typeString":"function () view external returns (bool)"}},"id":54403,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"memberLocation":"7375:8:100","memberName":"selector","nodeType":"MemberAccess","src":"7355:28:100","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},"src":"7347:36:100","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},"falseBody":{"expression":{"arguments":[{"hexValue":"4665746368436861696e496e666f4f75747075743a20756e6b6e6f776e20626f6f6c2073656c6563746f72","id":54410,"isConstant":false,"isLValue":false,"isPure":true,"kind":"string","lValueRequested":false,"nodeType":"Literal","src":"7430:45:100","typeDescriptions":{"typeIdentifier":"t_stringliteral_b43e73201a672ac9d292be9f8dc7215ba0fae6d34ae76c7f77ffd9b31af48fae","typeString":"literal_string \"FetchChainInfoOutput: unknown bool selector\""},"value":"FetchChainInfoOutput: unknown bool selector"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_stringliteral_b43e73201a672ac9d292be9f8dc7215ba0fae6d34ae76c7f77ffd9b31af48fae","typeString":"literal_string \"FetchChainInfoOutput: unknown bool selector\""}],"id":54409,"name":"revert","nodeType":"Identifier","overloadedDeclarations":[-19,-19],"referencedDeclaration":-19,"src":"7423:6:100","typeDescriptions":{"typeIdentifier":"t_function_revert_pure$_t_string_memory_ptr_$returns$__$","typeString":"function (string memory) pure"}},"id":54411,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"7423:53:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":54412,"nodeType":"ExpressionStatement","src":"7423:53:100"},"id":54413,"nodeType":"IfStatement","src":"7343:133:100","trueBody":{"expression":{"id":54407,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftHandSide":{"id":54405,"name":"_permissionless","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54099,"src":"7385:15:100","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},"nodeType":"Assignment","operator":"=","rightHandSide":{"id":54406,"name":"_bool","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54388,"src":"7403:5:100","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},"src":"7385:23:100","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},"id":54408,"nodeType":"ExpressionStatement","src":"7385:23:100"}},"id":54414,"nodeType":"IfStatement","src":"7267:209:100","trueBody":{"expression":{"id":54398,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftHandSide":{"id":54396,"name":"_permissioned","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54097,"src":"7307:13:100","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},"nodeType":"Assignment","operator":"=","rightHandSide":{"id":54397,"name":"_bool","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54388,"src":"7323:5:100","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},"src":"7307:21:100","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},"id":54399,"nodeType":"ExpressionStatement","src":"7307:21:100"}}]},"functionSelector":"baa1e15e","implemented":true,"kind":"function","modifiers":[],"name":"set","nameLocation":"7221:3:100","parameters":{"id":54389,"nodeType":"ParameterList","parameters":[{"constant":false,"id":54386,"mutability":"mutable","name":"_sel","nameLocation":"7232:4:100","nodeType":"VariableDeclaration","scope":54416,"src":"7225:11:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"},"typeName":{"id":54385,"name":"bytes4","nodeType":"ElementaryTypeName","src":"7225:6:100","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},"visibility":"internal"},{"constant":false,"id":54388,"mutability":"mutable","name":"_bool","nameLocation":"7243:5:100","nodeType":"VariableDeclaration","scope":54416,"src":"7238:10:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"},"typeName":{"id":54387,"name":"bool","nodeType":"ElementaryTypeName","src":"7238:4:100","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},"visibility":"internal"}],"src":"7224:25:100"},"returnParameters":{"id":54390,"nodeType":"ParameterList","parameters":[],"src":"7257:0:100"},"scope":54911,"stateMutability":"nonpayable","virtual":false,"visibility":"public"},{"id":54439,"nodeType":"FunctionDefinition","src":"7489:217:100","nodes":[],"body":{"id":54438,"nodeType":"Block","src":"7542:164:100","nodes":[],"statements":[{"condition":{"commonType":{"typeIdentifier":"t_bytes4","typeString":"bytes4"},"id":54428,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftExpression":{"id":54424,"name":"_sel","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54418,"src":"7556:4:100","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},"nodeType":"BinaryOperation","operator":"==","rightExpression":{"expression":{"expression":{"id":54425,"name":"this","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":-28,"src":"7564:4:100","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$54911","typeString":"contract FetchChainInfoOutput"}},"id":54426,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"7569:17:100","memberName":"respectedGameType","nodeType":"MemberAccess","referencedDeclaration":54910,"src":"7564:22:100","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_userDefinedValueType$_GameType_$70720_$","typeString":"function () view external returns (GameType)"}},"id":54427,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"memberLocation":"7587:8:100","memberName":"selector","nodeType":"MemberAccess","src":"7564:31:100","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},"src":"7556:39:100","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},"falseBody":{"expression":{"arguments":[{"hexValue":"4665746368436861696e496e666f4f75747075743a20756e6b6e6f776e2047616d65547970652073656c6563746f72","id":54434,"isConstant":false,"isLValue":false,"isPure":true,"kind":"string","lValueRequested":false,"nodeType":"Literal","src":"7649:49:100","typeDescriptions":{"typeIdentifier":"t_stringliteral_520d3d0cced140fee76c803f92d1db783b790e13f72de1e8f8c229c8c8783afc","typeString":"literal_string \"FetchChainInfoOutput: unknown GameType selector\""},"value":"FetchChainInfoOutput: unknown GameType selector"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_stringliteral_520d3d0cced140fee76c803f92d1db783b790e13f72de1e8f8c229c8c8783afc","typeString":"literal_string \"FetchChainInfoOutput: unknown GameType selector\""}],"id":54433,"name":"revert","nodeType":"Identifier","overloadedDeclarations":[-19,-19],"referencedDeclaration":-19,"src":"7642:6:100","typeDescriptions":{"typeIdentifier":"t_function_revert_pure$_t_string_memory_ptr_$returns$__$","typeString":"function (string memory) pure"}},"id":54435,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"7642:57:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":54436,"nodeType":"ExpressionStatement","src":"7642:57:100"},"id":54437,"nodeType":"IfStatement","src":"7552:147:100","trueBody":{"expression":{"id":54431,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftHandSide":{"id":54429,"name":"_respectedGameType","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54102,"src":"7597:18:100","typeDescriptions":{"typeIdentifier":"t_userDefinedValueType$_GameType_$70720","typeString":"GameType"}},"nodeType":"Assignment","operator":"=","rightHandSide":{"id":54430,"name":"_gameType","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54421,"src":"7618:9:100","typeDescriptions":{"typeIdentifier":"t_userDefinedValueType$_GameType_$70720","typeString":"GameType"}},"src":"7597:30:100","typeDescriptions":{"typeIdentifier":"t_userDefinedValueType$_GameType_$70720","typeString":"GameType"}},"id":54432,"nodeType":"ExpressionStatement","src":"7597:30:100"}}]},"functionSelector":"d08d6066","implemented":true,"kind":"function","modifiers":[],"name":"set","nameLocation":"7498:3:100","parameters":{"id":54422,"nodeType":"ParameterList","parameters":[{"constant":false,"id":54418,"mutability":"mutable","name":"_sel","nameLocation":"7509:4:100","nodeType":"VariableDeclaration","scope":54439,"src":"7502:11:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"},"typeName":{"id":54417,"name":"bytes4","nodeType":"ElementaryTypeName","src":"7502:6:100","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},"visibility":"internal"},{"constant":false,"id":54421,"mutability":"mutable","name":"_gameType","nameLocation":"7524:9:100","nodeType":"VariableDeclaration","scope":54439,"src":"7515:18:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_userDefinedValueType$_GameType_$70720","typeString":"GameType"},"typeName":{"id":54420,"nodeType":"UserDefinedTypeName","pathNode":{"id":54419,"name":"GameType","nameLocations":["7515:8:100"],"nodeType":"IdentifierPath","referencedDeclaration":70720,"src":"7515:8:100"},"referencedDeclaration":70720,"src":"7515:8:100","typeDescriptions":{"typeIdentifier":"t_userDefinedValueType$_GameType_$70720","typeString":"GameType"}},"visibility":"internal"}],"src":"7501:33:100"},"returnParameters":{"id":54423,"nodeType":"ParameterList","parameters":[],"src":"7542:0:100"},"scope":54911,"stateMutability":"nonpayable","virtual":false,"visibility":"public"},{"id":54457,"nodeType":"FunctionDefinition","src":"7712:207:100","nodes":[],"body":{"id":54456,"nodeType":"Block","src":"7772:147:100","nodes":[],"statements":[{"expression":{"arguments":[{"commonType":{"typeIdentifier":"t_address","typeString":"address"},"id":54450,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftExpression":{"id":54445,"name":"_addressManagerImpl","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54049,"src":"7790:19:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"BinaryOperation","operator":"!=","rightExpression":{"arguments":[{"hexValue":"30","id":54448,"isConstant":false,"isLValue":false,"isPure":true,"kind":"number","lValueRequested":false,"nodeType":"Literal","src":"7821:1:100","typeDescriptions":{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"},"value":"0"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"}],"id":54447,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"nodeType":"ElementaryTypeNameExpression","src":"7813:7:100","typeDescriptions":{"typeIdentifier":"t_type$_t_address_$","typeString":"type(address)"},"typeName":{"id":54446,"name":"address","nodeType":"ElementaryTypeName","src":"7813:7:100","typeDescriptions":{}}},"id":54449,"isConstant":false,"isLValue":false,"isPure":true,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"7813:10:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"src":"7790:33:100","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},{"hexValue":"4665746368436861696e496e666f4f75747075743a20616464726573734d616e61676572496d706c206e6f7420736574","id":54451,"isConstant":false,"isLValue":false,"isPure":true,"kind":"string","lValueRequested":false,"nodeType":"Literal","src":"7825:50:100","typeDescriptions":{"typeIdentifier":"t_stringliteral_b154041fe6470d62d16e8ad5c6d8e6c50a46e3e155a380b02703b07321b83f6a","typeString":"literal_string \"FetchChainInfoOutput: addressManagerImpl not set\""},"value":"FetchChainInfoOutput: addressManagerImpl not set"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_bool","typeString":"bool"},{"typeIdentifier":"t_stringliteral_b154041fe6470d62d16e8ad5c6d8e6c50a46e3e155a380b02703b07321b83f6a","typeString":"literal_string \"FetchChainInfoOutput: addressManagerImpl not set\""}],"id":54444,"name":"require","nodeType":"Identifier","overloadedDeclarations":[-18,-18,-18],"referencedDeclaration":-18,"src":"7782:7:100","typeDescriptions":{"typeIdentifier":"t_function_require_pure$_t_bool_$_t_string_memory_ptr_$returns$__$","typeString":"function (bool,string memory) pure"}},"id":54452,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"7782:94:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":54453,"nodeType":"ExpressionStatement","src":"7782:94:100"},{"expression":{"id":54454,"name":"_addressManagerImpl","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54049,"src":"7893:19:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"functionReturnParameters":54443,"id":54455,"nodeType":"Return","src":"7886:26:100"}]},"functionSelector":"bd366b8f","implemented":true,"kind":"function","modifiers":[],"name":"addressManagerImpl","nameLocation":"7721:18:100","parameters":{"id":54440,"nodeType":"ParameterList","parameters":[],"src":"7739:2:100"},"returnParameters":{"id":54443,"nodeType":"ParameterList","parameters":[{"constant":false,"id":54442,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":54457,"src":"7763:7:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":54441,"name":"address","nodeType":"ElementaryTypeName","src":"7763:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"7762:9:100"},"scope":54911,"stateMutability":"view","virtual":false,"visibility":"public"},{"id":54465,"nodeType":"FunctionDefinition","src":"7925:97:100","nodes":[],"body":{"id":54464,"nodeType":"Block","src":"7982:40:100","nodes":[],"statements":[{"expression":{"id":54462,"name":"_ethLockboxProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54051,"src":"7999:16:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"functionReturnParameters":54461,"id":54463,"nodeType":"Return","src":"7992:23:100"}]},"functionSelector":"f646b07c","implemented":true,"kind":"function","modifiers":[],"name":"ethLockboxProxy","nameLocation":"7934:15:100","parameters":{"id":54458,"nodeType":"ParameterList","parameters":[],"src":"7949:2:100"},"returnParameters":{"id":54461,"nodeType":"ParameterList","parameters":[{"constant":false,"id":54460,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":54465,"src":"7973:7:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":54459,"name":"address","nodeType":"ElementaryTypeName","src":"7973:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"7972:9:100"},"scope":54911,"stateMutability":"view","virtual":false,"visibility":"public"},{"id":54483,"nodeType":"FunctionDefinition","src":"8028:243:100","nodes":[],"body":{"id":54482,"nodeType":"Block","src":"8097:174:100","nodes":[],"statements":[{"expression":{"arguments":[{"commonType":{"typeIdentifier":"t_address","typeString":"address"},"id":54476,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftExpression":{"id":54471,"name":"_l1CrossDomainMessengerProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54053,"src":"8115:28:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"BinaryOperation","operator":"!=","rightExpression":{"arguments":[{"hexValue":"30","id":54474,"isConstant":false,"isLValue":false,"isPure":true,"kind":"number","lValueRequested":false,"nodeType":"Literal","src":"8155:1:100","typeDescriptions":{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"},"value":"0"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"}],"id":54473,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"nodeType":"ElementaryTypeNameExpression","src":"8147:7:100","typeDescriptions":{"typeIdentifier":"t_type$_t_address_$","typeString":"type(address)"},"typeName":{"id":54472,"name":"address","nodeType":"ElementaryTypeName","src":"8147:7:100","typeDescriptions":{}}},"id":54475,"isConstant":false,"isLValue":false,"isPure":true,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"8147:10:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"src":"8115:42:100","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},{"hexValue":"4665746368436861696e496e666f4f75747075743a206c3143726f7373446f6d61696e4d657373656e67657250726f7879206e6f7420736574","id":54477,"isConstant":false,"isLValue":false,"isPure":true,"kind":"string","lValueRequested":false,"nodeType":"Literal","src":"8159:59:100","typeDescriptions":{"typeIdentifier":"t_stringliteral_c51216a9bdef996dd7040e19ba4fe817587273a187f1f145abfd19b1308df5eb","typeString":"literal_string \"FetchChainInfoOutput: l1CrossDomainMessengerProxy not set\""},"value":"FetchChainInfoOutput: l1CrossDomainMessengerProxy not set"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_bool","typeString":"bool"},{"typeIdentifier":"t_stringliteral_c51216a9bdef996dd7040e19ba4fe817587273a187f1f145abfd19b1308df5eb","typeString":"literal_string \"FetchChainInfoOutput: l1CrossDomainMessengerProxy not set\""}],"id":54470,"name":"require","nodeType":"Identifier","overloadedDeclarations":[-18,-18,-18],"referencedDeclaration":-18,"src":"8107:7:100","typeDescriptions":{"typeIdentifier":"t_function_require_pure$_t_bool_$_t_string_memory_ptr_$returns$__$","typeString":"function (bool,string memory) pure"}},"id":54478,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"8107:112:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":54479,"nodeType":"ExpressionStatement","src":"8107:112:100"},{"expression":{"id":54480,"name":"_l1CrossDomainMessengerProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54053,"src":"8236:28:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"functionReturnParameters":54469,"id":54481,"nodeType":"Return","src":"8229:35:100"}]},"functionSelector":"54729cfb","implemented":true,"kind":"function","modifiers":[],"name":"l1CrossDomainMessengerProxy","nameLocation":"8037:27:100","parameters":{"id":54466,"nodeType":"ParameterList","parameters":[],"src":"8064:2:100"},"returnParameters":{"id":54469,"nodeType":"ParameterList","parameters":[{"constant":false,"id":54468,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":54483,"src":"8088:7:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":54467,"name":"address","nodeType":"ElementaryTypeName","src":"8088:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"8087:9:100"},"scope":54911,"stateMutability":"view","virtual":false,"visibility":"public"},{"id":54501,"nodeType":"FunctionDefinition","src":"8277:211:100","nodes":[],"body":{"id":54500,"nodeType":"Block","src":"8338:150:100","nodes":[],"statements":[{"expression":{"arguments":[{"commonType":{"typeIdentifier":"t_address","typeString":"address"},"id":54494,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftExpression":{"id":54489,"name":"_l1Erc721BridgeProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54055,"src":"8356:20:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"BinaryOperation","operator":"!=","rightExpression":{"arguments":[{"hexValue":"30","id":54492,"isConstant":false,"isLValue":false,"isPure":true,"kind":"number","lValueRequested":false,"nodeType":"Literal","src":"8388:1:100","typeDescriptions":{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"},"value":"0"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"}],"id":54491,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"nodeType":"ElementaryTypeNameExpression","src":"8380:7:100","typeDescriptions":{"typeIdentifier":"t_type$_t_address_$","typeString":"type(address)"},"typeName":{"id":54490,"name":"address","nodeType":"ElementaryTypeName","src":"8380:7:100","typeDescriptions":{}}},"id":54493,"isConstant":false,"isLValue":false,"isPure":true,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"8380:10:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"src":"8356:34:100","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},{"hexValue":"4665746368436861696e496e666f4f75747075743a206c3145726337323142726964676550726f7879206e6f7420736574","id":54495,"isConstant":false,"isLValue":false,"isPure":true,"kind":"string","lValueRequested":false,"nodeType":"Literal","src":"8392:51:100","typeDescriptions":{"typeIdentifier":"t_stringliteral_bdf5319949d8561b59a02fe667aa58fca11f5f8571bc18997b0bc0ac582aece7","typeString":"literal_string \"FetchChainInfoOutput: l1Erc721BridgeProxy not set\""},"value":"FetchChainInfoOutput: l1Erc721BridgeProxy not set"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_bool","typeString":"bool"},{"typeIdentifier":"t_stringliteral_bdf5319949d8561b59a02fe667aa58fca11f5f8571bc18997b0bc0ac582aece7","typeString":"literal_string \"FetchChainInfoOutput: l1Erc721BridgeProxy not set\""}],"id":54488,"name":"require","nodeType":"Identifier","overloadedDeclarations":[-18,-18,-18],"referencedDeclaration":-18,"src":"8348:7:100","typeDescriptions":{"typeIdentifier":"t_function_require_pure$_t_bool_$_t_string_memory_ptr_$returns$__$","typeString":"function (bool,string memory) pure"}},"id":54496,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"8348:96:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":54497,"nodeType":"ExpressionStatement","src":"8348:96:100"},{"expression":{"id":54498,"name":"_l1Erc721BridgeProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54055,"src":"8461:20:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"functionReturnParameters":54487,"id":54499,"nodeType":"Return","src":"8454:27:100"}]},"functionSelector":"ebfa8409","implemented":true,"kind":"function","modifiers":[],"name":"l1Erc721BridgeProxy","nameLocation":"8286:19:100","parameters":{"id":54484,"nodeType":"ParameterList","parameters":[],"src":"8305:2:100"},"returnParameters":{"id":54487,"nodeType":"ParameterList","parameters":[{"constant":false,"id":54486,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":54501,"src":"8329:7:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":54485,"name":"address","nodeType":"ElementaryTypeName","src":"8329:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"8328:9:100"},"scope":54911,"stateMutability":"view","virtual":false,"visibility":"public"},{"id":54519,"nodeType":"FunctionDefinition","src":"8494:219:100","nodes":[],"body":{"id":54518,"nodeType":"Block","src":"8557:156:100","nodes":[],"statements":[{"expression":{"arguments":[{"commonType":{"typeIdentifier":"t_address","typeString":"address"},"id":54512,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftExpression":{"id":54507,"name":"_l1StandardBridgeProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54057,"src":"8575:22:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"BinaryOperation","operator":"!=","rightExpression":{"arguments":[{"hexValue":"30","id":54510,"isConstant":false,"isLValue":false,"isPure":true,"kind":"number","lValueRequested":false,"nodeType":"Literal","src":"8609:1:100","typeDescriptions":{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"},"value":"0"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"}],"id":54509,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"nodeType":"ElementaryTypeNameExpression","src":"8601:7:100","typeDescriptions":{"typeIdentifier":"t_type$_t_address_$","typeString":"type(address)"},"typeName":{"id":54508,"name":"address","nodeType":"ElementaryTypeName","src":"8601:7:100","typeDescriptions":{}}},"id":54511,"isConstant":false,"isLValue":false,"isPure":true,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"8601:10:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"src":"8575:36:100","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},{"hexValue":"4665746368436861696e496e666f4f75747075743a206c315374616e6461726442726964676550726f7879206e6f7420736574","id":54513,"isConstant":false,"isLValue":false,"isPure":true,"kind":"string","lValueRequested":false,"nodeType":"Literal","src":"8613:53:100","typeDescriptions":{"typeIdentifier":"t_stringliteral_ab3776e760de395cff3bb935602469d5b7c0bd9b5cfaefde9d221be6524302e1","typeString":"literal_string \"FetchChainInfoOutput: l1StandardBridgeProxy not set\""},"value":"FetchChainInfoOutput: l1StandardBridgeProxy not set"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_bool","typeString":"bool"},{"typeIdentifier":"t_stringliteral_ab3776e760de395cff3bb935602469d5b7c0bd9b5cfaefde9d221be6524302e1","typeString":"literal_string \"FetchChainInfoOutput: l1StandardBridgeProxy not set\""}],"id":54506,"name":"require","nodeType":"Identifier","overloadedDeclarations":[-18,-18,-18],"referencedDeclaration":-18,"src":"8567:7:100","typeDescriptions":{"typeIdentifier":"t_function_require_pure$_t_bool_$_t_string_memory_ptr_$returns$__$","typeString":"function (bool,string memory) pure"}},"id":54514,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"8567:100:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":54515,"nodeType":"ExpressionStatement","src":"8567:100:100"},{"expression":{"id":54516,"name":"_l1StandardBridgeProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54057,"src":"8684:22:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"functionReturnParameters":54505,"id":54517,"nodeType":"Return","src":"8677:29:100"}]},"functionSelector":"102b6069","implemented":true,"kind":"function","modifiers":[],"name":"l1StandardBridgeProxy","nameLocation":"8503:21:100","parameters":{"id":54502,"nodeType":"ParameterList","parameters":[],"src":"8524:2:100"},"returnParameters":{"id":54505,"nodeType":"ParameterList","parameters":[{"constant":false,"id":54504,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":54519,"src":"8548:7:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":54503,"name":"address","nodeType":"ElementaryTypeName","src":"8548:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"8547:9:100"},"scope":54911,"stateMutability":"view","virtual":false,"visibility":"public"},{"id":54537,"nodeType":"FunctionDefinition","src":"8719:211:100","nodes":[],"body":{"id":54536,"nodeType":"Block","src":"8780:150:100","nodes":[],"statements":[{"expression":{"arguments":[{"commonType":{"typeIdentifier":"t_address","typeString":"address"},"id":54530,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftExpression":{"id":54525,"name":"_l2OutputOracleProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54059,"src":"8798:20:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"BinaryOperation","operator":"!=","rightExpression":{"arguments":[{"hexValue":"30","id":54528,"isConstant":false,"isLValue":false,"isPure":true,"kind":"number","lValueRequested":false,"nodeType":"Literal","src":"8830:1:100","typeDescriptions":{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"},"value":"0"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"}],"id":54527,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"nodeType":"ElementaryTypeNameExpression","src":"8822:7:100","typeDescriptions":{"typeIdentifier":"t_type$_t_address_$","typeString":"type(address)"},"typeName":{"id":54526,"name":"address","nodeType":"ElementaryTypeName","src":"8822:7:100","typeDescriptions":{}}},"id":54529,"isConstant":false,"isLValue":false,"isPure":true,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"8822:10:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"src":"8798:34:100","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},{"hexValue":"4665746368436861696e496e666f4f75747075743a206c324f75747075744f7261636c6550726f7879206e6f7420736574","id":54531,"isConstant":false,"isLValue":false,"isPure":true,"kind":"string","lValueRequested":false,"nodeType":"Literal","src":"8834:51:100","typeDescriptions":{"typeIdentifier":"t_stringliteral_2f861759874f8f3e0cfa53ef8dfb0556f88f877edbaf1dbc485fc820d67ac86a","typeString":"literal_string \"FetchChainInfoOutput: l2OutputOracleProxy not set\""},"value":"FetchChainInfoOutput: l2OutputOracleProxy not set"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_bool","typeString":"bool"},{"typeIdentifier":"t_stringliteral_2f861759874f8f3e0cfa53ef8dfb0556f88f877edbaf1dbc485fc820d67ac86a","typeString":"literal_string \"FetchChainInfoOutput: l2OutputOracleProxy not set\""}],"id":54524,"name":"require","nodeType":"Identifier","overloadedDeclarations":[-18,-18,-18],"referencedDeclaration":-18,"src":"8790:7:100","typeDescriptions":{"typeIdentifier":"t_function_require_pure$_t_bool_$_t_string_memory_ptr_$returns$__$","typeString":"function (bool,string memory) pure"}},"id":54532,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"8790:96:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":54533,"nodeType":"ExpressionStatement","src":"8790:96:100"},{"expression":{"id":54534,"name":"_l2OutputOracleProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54059,"src":"8903:20:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"functionReturnParameters":54523,"id":54535,"nodeType":"Return","src":"8896:27:100"}]},"functionSelector":"a2c9a89f","implemented":true,"kind":"function","modifiers":[],"name":"l2OutputOracleProxy","nameLocation":"8728:19:100","parameters":{"id":54520,"nodeType":"ParameterList","parameters":[],"src":"8747:2:100"},"returnParameters":{"id":54523,"nodeType":"ParameterList","parameters":[{"constant":false,"id":54522,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":54537,"src":"8771:7:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":54521,"name":"address","nodeType":"ElementaryTypeName","src":"8771:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"8770:9:100"},"scope":54911,"stateMutability":"view","virtual":false,"visibility":"public"},{"id":54555,"nodeType":"FunctionDefinition","src":"8936:301:100","nodes":[],"body":{"id":54554,"nodeType":"Block","src":"9011:226:100","nodes":[],"statements":[{"expression":{"arguments":[{"commonType":{"typeIdentifier":"t_address","typeString":"address"},"id":54548,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftExpression":{"id":54543,"name":"_optimismMintableErc20FactoryProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54061,"src":"9042:34:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"BinaryOperation","operator":"!=","rightExpression":{"arguments":[{"hexValue":"30","id":54546,"isConstant":false,"isLValue":false,"isPure":true,"kind":"number","lValueRequested":false,"nodeType":"Literal","src":"9088:1:100","typeDescriptions":{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"},"value":"0"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"}],"id":54545,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"nodeType":"ElementaryTypeNameExpression","src":"9080:7:100","typeDescriptions":{"typeIdentifier":"t_type$_t_address_$","typeString":"type(address)"},"typeName":{"id":54544,"name":"address","nodeType":"ElementaryTypeName","src":"9080:7:100","typeDescriptions":{}}},"id":54547,"isConstant":false,"isLValue":false,"isPure":true,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"9080:10:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"src":"9042:48:100","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},{"hexValue":"4665746368436861696e496e666f4f75747075743a206f7074696d69736d4d696e7461626c654572633230466163746f727950726f7879206e6f7420736574","id":54549,"isConstant":false,"isLValue":false,"isPure":true,"kind":"string","lValueRequested":false,"nodeType":"Literal","src":"9104:65:100","typeDescriptions":{"typeIdentifier":"t_stringliteral_58c040fbde84bd4afd9f21f5ba3150dab029d767b65aafdf14512bdafdbd9954","typeString":"literal_string \"FetchChainInfoOutput: optimismMintableErc20FactoryProxy not set\""},"value":"FetchChainInfoOutput: optimismMintableErc20FactoryProxy not set"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_bool","typeString":"bool"},{"typeIdentifier":"t_stringliteral_58c040fbde84bd4afd9f21f5ba3150dab029d767b65aafdf14512bdafdbd9954","typeString":"literal_string \"FetchChainInfoOutput: optimismMintableErc20FactoryProxy not set\""}],"id":54542,"name":"require","nodeType":"Identifier","overloadedDeclarations":[-18,-18,-18],"referencedDeclaration":-18,"src":"9021:7:100","typeDescriptions":{"typeIdentifier":"t_function_require_pure$_t_bool_$_t_string_memory_ptr_$returns$__$","typeString":"function (bool,string memory) pure"}},"id":54550,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"9021:158:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":54551,"nodeType":"ExpressionStatement","src":"9021:158:100"},{"expression":{"id":54552,"name":"_optimismMintableErc20FactoryProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54061,"src":"9196:34:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"functionReturnParameters":54541,"id":54553,"nodeType":"Return","src":"9189:41:100"}]},"functionSelector":"8f20c7e4","implemented":true,"kind":"function","modifiers":[],"name":"optimismMintableErc20FactoryProxy","nameLocation":"8945:33:100","parameters":{"id":54538,"nodeType":"ParameterList","parameters":[],"src":"8978:2:100"},"returnParameters":{"id":54541,"nodeType":"ParameterList","parameters":[{"constant":false,"id":54540,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":54555,"src":"9002:7:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":54539,"name":"address","nodeType":"ElementaryTypeName","src":"9002:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"9001:9:100"},"scope":54911,"stateMutability":"view","virtual":false,"visibility":"public"},{"id":54573,"nodeType":"FunctionDefinition","src":"9243:211:100","nodes":[],"body":{"id":54572,"nodeType":"Block","src":"9304:150:100","nodes":[],"statements":[{"expression":{"arguments":[{"commonType":{"typeIdentifier":"t_address","typeString":"address"},"id":54566,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftExpression":{"id":54561,"name":"_optimismPortalProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54063,"src":"9322:20:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"BinaryOperation","operator":"!=","rightExpression":{"arguments":[{"hexValue":"30","id":54564,"isConstant":false,"isLValue":false,"isPure":true,"kind":"number","lValueRequested":false,"nodeType":"Literal","src":"9354:1:100","typeDescriptions":{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"},"value":"0"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"}],"id":54563,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"nodeType":"ElementaryTypeNameExpression","src":"9346:7:100","typeDescriptions":{"typeIdentifier":"t_type$_t_address_$","typeString":"type(address)"},"typeName":{"id":54562,"name":"address","nodeType":"ElementaryTypeName","src":"9346:7:100","typeDescriptions":{}}},"id":54565,"isConstant":false,"isLValue":false,"isPure":true,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"9346:10:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"src":"9322:34:100","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},{"hexValue":"4665746368436861696e496e666f4f75747075743a206f7074696d69736d506f7274616c50726f7879206e6f7420736574","id":54567,"isConstant":false,"isLValue":false,"isPure":true,"kind":"string","lValueRequested":false,"nodeType":"Literal","src":"9358:51:100","typeDescriptions":{"typeIdentifier":"t_stringliteral_ef003bab75ab0cfa4ca81f99eb20b37a3fded08fa7502df7d991f596c8680642","typeString":"literal_string \"FetchChainInfoOutput: optimismPortalProxy not set\""},"value":"FetchChainInfoOutput: optimismPortalProxy not set"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_bool","typeString":"bool"},{"typeIdentifier":"t_stringliteral_ef003bab75ab0cfa4ca81f99eb20b37a3fded08fa7502df7d991f596c8680642","typeString":"literal_string \"FetchChainInfoOutput: optimismPortalProxy not set\""}],"id":54560,"name":"require","nodeType":"Identifier","overloadedDeclarations":[-18,-18,-18],"referencedDeclaration":-18,"src":"9314:7:100","typeDescriptions":{"typeIdentifier":"t_function_require_pure$_t_bool_$_t_string_memory_ptr_$returns$__$","typeString":"function (bool,string memory) pure"}},"id":54568,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"9314:96:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":54569,"nodeType":"ExpressionStatement","src":"9314:96:100"},{"expression":{"id":54570,"name":"_optimismPortalProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54063,"src":"9427:20:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"functionReturnParameters":54559,"id":54571,"nodeType":"Return","src":"9420:27:100"}]},"functionSelector":"04451c49","implemented":true,"kind":"function","modifiers":[],"name":"optimismPortalProxy","nameLocation":"9252:19:100","parameters":{"id":54556,"nodeType":"ParameterList","parameters":[],"src":"9271:2:100"},"returnParameters":{"id":54559,"nodeType":"ParameterList","parameters":[{"constant":false,"id":54558,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":54573,"src":"9295:7:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":54557,"name":"address","nodeType":"ElementaryTypeName","src":"9295:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"9294:9:100"},"scope":54911,"stateMutability":"view","virtual":false,"visibility":"public"},{"id":54591,"nodeType":"FunctionDefinition","src":"9460:203:100","nodes":[],"body":{"id":54590,"nodeType":"Block","src":"9519:144:100","nodes":[],"statements":[{"expression":{"arguments":[{"commonType":{"typeIdentifier":"t_address","typeString":"address"},"id":54584,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftExpression":{"id":54579,"name":"_systemConfigProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54065,"src":"9537:18:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"BinaryOperation","operator":"!=","rightExpression":{"arguments":[{"hexValue":"30","id":54582,"isConstant":false,"isLValue":false,"isPure":true,"kind":"number","lValueRequested":false,"nodeType":"Literal","src":"9567:1:100","typeDescriptions":{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"},"value":"0"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"}],"id":54581,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"nodeType":"ElementaryTypeNameExpression","src":"9559:7:100","typeDescriptions":{"typeIdentifier":"t_type$_t_address_$","typeString":"type(address)"},"typeName":{"id":54580,"name":"address","nodeType":"ElementaryTypeName","src":"9559:7:100","typeDescriptions":{}}},"id":54583,"isConstant":false,"isLValue":false,"isPure":true,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"9559:10:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"src":"9537:32:100","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},{"hexValue":"4665746368436861696e496e666f4f75747075743a2073797374656d436f6e66696750726f7879206e6f7420736574","id":54585,"isConstant":false,"isLValue":false,"isPure":true,"kind":"string","lValueRequested":false,"nodeType":"Literal","src":"9571:49:100","typeDescriptions":{"typeIdentifier":"t_stringliteral_09ada010329fb4e012f4c857519ec176efea734f55c01f382f1b6c7bd752716b","typeString":"literal_string \"FetchChainInfoOutput: systemConfigProxy not set\""},"value":"FetchChainInfoOutput: systemConfigProxy not set"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_bool","typeString":"bool"},{"typeIdentifier":"t_stringliteral_09ada010329fb4e012f4c857519ec176efea734f55c01f382f1b6c7bd752716b","typeString":"literal_string \"FetchChainInfoOutput: systemConfigProxy not set\""}],"id":54578,"name":"require","nodeType":"Identifier","overloadedDeclarations":[-18,-18,-18],"referencedDeclaration":-18,"src":"9529:7:100","typeDescriptions":{"typeIdentifier":"t_function_require_pure$_t_bool_$_t_string_memory_ptr_$returns$__$","typeString":"function (bool,string memory) pure"}},"id":54586,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"9529:92:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":54587,"nodeType":"ExpressionStatement","src":"9529:92:100"},{"expression":{"id":54588,"name":"_systemConfigProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54065,"src":"9638:18:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"functionReturnParameters":54577,"id":54589,"nodeType":"Return","src":"9631:25:100"}]},"functionSelector":"c17db6e3","implemented":true,"kind":"function","modifiers":[],"name":"systemConfigProxy","nameLocation":"9469:17:100","parameters":{"id":54574,"nodeType":"ParameterList","parameters":[],"src":"9486:2:100"},"returnParameters":{"id":54577,"nodeType":"ParameterList","parameters":[{"constant":false,"id":54576,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":54591,"src":"9510:7:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":54575,"name":"address","nodeType":"ElementaryTypeName","src":"9510:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"9509:9:100"},"scope":54911,"stateMutability":"view","virtual":false,"visibility":"public"},{"id":54609,"nodeType":"FunctionDefinition","src":"9669:219:100","nodes":[],"body":{"id":54608,"nodeType":"Block","src":"9732:156:100","nodes":[],"statements":[{"expression":{"arguments":[{"commonType":{"typeIdentifier":"t_address","typeString":"address"},"id":54602,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftExpression":{"id":54597,"name":"_opChainProxyAdminImpl","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54067,"src":"9750:22:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"BinaryOperation","operator":"!=","rightExpression":{"arguments":[{"hexValue":"30","id":54600,"isConstant":false,"isLValue":false,"isPure":true,"kind":"number","lValueRequested":false,"nodeType":"Literal","src":"9784:1:100","typeDescriptions":{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"},"value":"0"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"}],"id":54599,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"nodeType":"ElementaryTypeNameExpression","src":"9776:7:100","typeDescriptions":{"typeIdentifier":"t_type$_t_address_$","typeString":"type(address)"},"typeName":{"id":54598,"name":"address","nodeType":"ElementaryTypeName","src":"9776:7:100","typeDescriptions":{}}},"id":54601,"isConstant":false,"isLValue":false,"isPure":true,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"9776:10:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"src":"9750:36:100","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},{"hexValue":"4665746368436861696e496e666f4f75747075743a206f70436861696e50726f787941646d696e496d706c206e6f7420736574","id":54603,"isConstant":false,"isLValue":false,"isPure":true,"kind":"string","lValueRequested":false,"nodeType":"Literal","src":"9788:53:100","typeDescriptions":{"typeIdentifier":"t_stringliteral_8ebc3647bde8a1129bfd827c7ef2e2d4fea82292bcad8a3c8e3918d70fed8ea8","typeString":"literal_string \"FetchChainInfoOutput: opChainProxyAdminImpl not set\""},"value":"FetchChainInfoOutput: opChainProxyAdminImpl not set"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_bool","typeString":"bool"},{"typeIdentifier":"t_stringliteral_8ebc3647bde8a1129bfd827c7ef2e2d4fea82292bcad8a3c8e3918d70fed8ea8","typeString":"literal_string \"FetchChainInfoOutput: opChainProxyAdminImpl not set\""}],"id":54596,"name":"require","nodeType":"Identifier","overloadedDeclarations":[-18,-18,-18],"referencedDeclaration":-18,"src":"9742:7:100","typeDescriptions":{"typeIdentifier":"t_function_require_pure$_t_bool_$_t_string_memory_ptr_$returns$__$","typeString":"function (bool,string memory) pure"}},"id":54604,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"9742:100:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":54605,"nodeType":"ExpressionStatement","src":"9742:100:100"},{"expression":{"id":54606,"name":"_opChainProxyAdminImpl","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54067,"src":"9859:22:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"functionReturnParameters":54595,"id":54607,"nodeType":"Return","src":"9852:29:100"}]},"functionSelector":"5643665f","implemented":true,"kind":"function","modifiers":[],"name":"opChainProxyAdminImpl","nameLocation":"9678:21:100","parameters":{"id":54592,"nodeType":"ParameterList","parameters":[],"src":"9699:2:100"},"returnParameters":{"id":54595,"nodeType":"ParameterList","parameters":[{"constant":false,"id":54594,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":54609,"src":"9723:7:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":54593,"name":"address","nodeType":"ElementaryTypeName","src":"9723:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"9722:9:100"},"scope":54911,"stateMutability":"view","virtual":false,"visibility":"public"},{"id":54627,"nodeType":"FunctionDefinition","src":"9894:219:100","nodes":[],"body":{"id":54626,"nodeType":"Block","src":"9957:156:100","nodes":[],"statements":[{"expression":{"arguments":[{"commonType":{"typeIdentifier":"t_address","typeString":"address"},"id":54620,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftExpression":{"id":54615,"name":"_superchainConfigProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54043,"src":"9975:22:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"BinaryOperation","operator":"!=","rightExpression":{"arguments":[{"hexValue":"30","id":54618,"isConstant":false,"isLValue":false,"isPure":true,"kind":"number","lValueRequested":false,"nodeType":"Literal","src":"10009:1:100","typeDescriptions":{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"},"value":"0"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"}],"id":54617,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"nodeType":"ElementaryTypeNameExpression","src":"10001:7:100","typeDescriptions":{"typeIdentifier":"t_type$_t_address_$","typeString":"type(address)"},"typeName":{"id":54616,"name":"address","nodeType":"ElementaryTypeName","src":"10001:7:100","typeDescriptions":{}}},"id":54619,"isConstant":false,"isLValue":false,"isPure":true,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"10001:10:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"src":"9975:36:100","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},{"hexValue":"4665746368436861696e496e666f4f75747075743a207375706572636861696e436f6e66696750726f7879206e6f7420736574","id":54621,"isConstant":false,"isLValue":false,"isPure":true,"kind":"string","lValueRequested":false,"nodeType":"Literal","src":"10013:53:100","typeDescriptions":{"typeIdentifier":"t_stringliteral_1b8ad3d2e627aa065fd0fee387bc2d1e5e640177323f7f86733cd157b788a1ce","typeString":"literal_string \"FetchChainInfoOutput: superchainConfigProxy not set\""},"value":"FetchChainInfoOutput: superchainConfigProxy not set"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_bool","typeString":"bool"},{"typeIdentifier":"t_stringliteral_1b8ad3d2e627aa065fd0fee387bc2d1e5e640177323f7f86733cd157b788a1ce","typeString":"literal_string \"FetchChainInfoOutput: superchainConfigProxy not set\""}],"id":54614,"name":"require","nodeType":"Identifier","overloadedDeclarations":[-18,-18,-18],"referencedDeclaration":-18,"src":"9967:7:100","typeDescriptions":{"typeIdentifier":"t_function_require_pure$_t_bool_$_t_string_memory_ptr_$returns$__$","typeString":"function (bool,string memory) pure"}},"id":54622,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"9967:100:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":54623,"nodeType":"ExpressionStatement","src":"9967:100:100"},{"expression":{"id":54624,"name":"_superchainConfigProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54043,"src":"10084:22:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"functionReturnParameters":54613,"id":54625,"nodeType":"Return","src":"10077:29:100"}]},"functionSelector":"84cf2c97","implemented":true,"kind":"function","modifiers":[],"name":"superchainConfigProxy","nameLocation":"9903:21:100","parameters":{"id":54610,"nodeType":"ParameterList","parameters":[],"src":"9924:2:100"},"returnParameters":{"id":54613,"nodeType":"ParameterList","parameters":[{"constant":false,"id":54612,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":54627,"src":"9948:7:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":54611,"name":"address","nodeType":"ElementaryTypeName","src":"9948:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"9947:9:100"},"scope":54911,"stateMutability":"view","virtual":false,"visibility":"public"},{"id":54645,"nodeType":"FunctionDefinition","src":"10119:231:100","nodes":[],"body":{"id":54644,"nodeType":"Block","src":"10185:165:100","nodes":[],"statements":[{"expression":{"arguments":[{"commonType":{"typeIdentifier":"t_address","typeString":"address"},"id":54638,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftExpression":{"id":54633,"name":"_anchorStateRegistryProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54069,"src":"10203:25:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"BinaryOperation","operator":"!=","rightExpression":{"arguments":[{"hexValue":"30","id":54636,"isConstant":false,"isLValue":false,"isPure":true,"kind":"number","lValueRequested":false,"nodeType":"Literal","src":"10240:1:100","typeDescriptions":{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"},"value":"0"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"}],"id":54635,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"nodeType":"ElementaryTypeNameExpression","src":"10232:7:100","typeDescriptions":{"typeIdentifier":"t_type$_t_address_$","typeString":"type(address)"},"typeName":{"id":54634,"name":"address","nodeType":"ElementaryTypeName","src":"10232:7:100","typeDescriptions":{}}},"id":54637,"isConstant":false,"isLValue":false,"isPure":true,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"10232:10:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"src":"10203:39:100","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},{"hexValue":"4665746368436861696e496e666f4f75747075743a20616e63686f725374617465526567697374727950726f7879206e6f7420736574","id":54639,"isConstant":false,"isLValue":false,"isPure":true,"kind":"string","lValueRequested":false,"nodeType":"Literal","src":"10244:56:100","typeDescriptions":{"typeIdentifier":"t_stringliteral_6391076785d7152b9570ce8338ca2e43a749144cb3dbb7f9e5e1de5fabfbae48","typeString":"literal_string \"FetchChainInfoOutput: anchorStateRegistryProxy not set\""},"value":"FetchChainInfoOutput: anchorStateRegistryProxy not set"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_bool","typeString":"bool"},{"typeIdentifier":"t_stringliteral_6391076785d7152b9570ce8338ca2e43a749144cb3dbb7f9e5e1de5fabfbae48","typeString":"literal_string \"FetchChainInfoOutput: anchorStateRegistryProxy not set\""}],"id":54632,"name":"require","nodeType":"Identifier","overloadedDeclarations":[-18,-18,-18],"referencedDeclaration":-18,"src":"10195:7:100","typeDescriptions":{"typeIdentifier":"t_function_require_pure$_t_bool_$_t_string_memory_ptr_$returns$__$","typeString":"function (bool,string memory) pure"}},"id":54640,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"10195:106:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":54641,"nodeType":"ExpressionStatement","src":"10195:106:100"},{"expression":{"id":54642,"name":"_anchorStateRegistryProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54069,"src":"10318:25:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"functionReturnParameters":54631,"id":54643,"nodeType":"Return","src":"10311:32:100"}]},"functionSelector":"35596f76","implemented":true,"kind":"function","modifiers":[],"name":"anchorStateRegistryProxy","nameLocation":"10128:24:100","parameters":{"id":54628,"nodeType":"ParameterList","parameters":[],"src":"10152:2:100"},"returnParameters":{"id":54631,"nodeType":"ParameterList","parameters":[{"constant":false,"id":54630,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":54645,"src":"10176:7:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":54629,"name":"address","nodeType":"ElementaryTypeName","src":"10176:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"10175:9:100"},"scope":54911,"stateMutability":"view","virtual":false,"visibility":"public"},{"id":54653,"nodeType":"FunctionDefinition","src":"10356:131:100","nodes":[],"body":{"id":54652,"nodeType":"Block","src":"10430:57:100","nodes":[],"statements":[{"expression":{"id":54650,"name":"_delayedWethPermissionedGameProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54071,"src":"10447:33:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"functionReturnParameters":54649,"id":54651,"nodeType":"Return","src":"10440:40:100"}]},"functionSelector":"794836d7","implemented":true,"kind":"function","modifiers":[],"name":"delayedWethPermissionedGameProxy","nameLocation":"10365:32:100","parameters":{"id":54646,"nodeType":"ParameterList","parameters":[],"src":"10397:2:100"},"returnParameters":{"id":54649,"nodeType":"ParameterList","parameters":[{"constant":false,"id":54648,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":54653,"src":"10421:7:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":54647,"name":"address","nodeType":"ElementaryTypeName","src":"10421:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"10420:9:100"},"scope":54911,"stateMutability":"view","virtual":false,"visibility":"public"},{"id":54661,"nodeType":"FunctionDefinition","src":"10493:135:100","nodes":[],"body":{"id":54660,"nodeType":"Block","src":"10569:59:100","nodes":[],"statements":[{"expression":{"id":54658,"name":"_delayedWethPermissionlessGameProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54073,"src":"10586:35:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"functionReturnParameters":54657,"id":54659,"nodeType":"Return","src":"10579:42:100"}]},"functionSelector":"97068797","implemented":true,"kind":"function","modifiers":[],"name":"delayedWethPermissionlessGameProxy","nameLocation":"10502:34:100","parameters":{"id":54654,"nodeType":"ParameterList","parameters":[],"src":"10536:2:100"},"returnParameters":{"id":54657,"nodeType":"ParameterList","parameters":[{"constant":false,"id":54656,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":54661,"src":"10560:7:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":54655,"name":"address","nodeType":"ElementaryTypeName","src":"10560:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"10559:9:100"},"scope":54911,"stateMutability":"view","virtual":false,"visibility":"public"},{"id":54669,"nodeType":"FunctionDefinition","src":"10634:113:100","nodes":[],"body":{"id":54668,"nodeType":"Block","src":"10699:48:100","nodes":[],"statements":[{"expression":{"id":54666,"name":"_disputeGameFactoryProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54075,"src":"10716:24:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"functionReturnParameters":54665,"id":54667,"nodeType":"Return","src":"10709:31:100"}]},"functionSelector":"6c4568d1","implemented":true,"kind":"function","modifiers":[],"name":"disputeGameFactoryProxy","nameLocation":"10643:23:100","parameters":{"id":54662,"nodeType":"ParameterList","parameters":[],"src":"10666:2:100"},"returnParameters":{"id":54665,"nodeType":"ParameterList","parameters":[{"constant":false,"id":54664,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":54669,"src":"10690:7:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":54663,"name":"address","nodeType":"ElementaryTypeName","src":"10690:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"10689:9:100"},"scope":54911,"stateMutability":"view","virtual":false,"visibility":"public"},{"id":54687,"nodeType":"FunctionDefinition","src":"10753:215:100","nodes":[],"body":{"id":54686,"nodeType":"Block","src":"10815:153:100","nodes":[],"statements":[{"expression":{"arguments":[{"commonType":{"typeIdentifier":"t_address","typeString":"address"},"id":54680,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftExpression":{"id":54675,"name":"_faultDisputeGameImpl","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54077,"src":"10833:21:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"BinaryOperation","operator":"!=","rightExpression":{"arguments":[{"hexValue":"30","id":54678,"isConstant":false,"isLValue":false,"isPure":true,"kind":"number","lValueRequested":false,"nodeType":"Literal","src":"10866:1:100","typeDescriptions":{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"},"value":"0"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"}],"id":54677,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"nodeType":"ElementaryTypeNameExpression","src":"10858:7:100","typeDescriptions":{"typeIdentifier":"t_type$_t_address_$","typeString":"type(address)"},"typeName":{"id":54676,"name":"address","nodeType":"ElementaryTypeName","src":"10858:7:100","typeDescriptions":{}}},"id":54679,"isConstant":false,"isLValue":false,"isPure":true,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"10858:10:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"src":"10833:35:100","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},{"hexValue":"4665746368436861696e496e666f4f75747075743a206661756c744469737075746547616d65496d706c206e6f7420736574","id":54681,"isConstant":false,"isLValue":false,"isPure":true,"kind":"string","lValueRequested":false,"nodeType":"Literal","src":"10870:52:100","typeDescriptions":{"typeIdentifier":"t_stringliteral_baae18cd0fbc1fbf3c566f5918a7a4a780bb1a3d403d2b65d908417b87c06457","typeString":"literal_string \"FetchChainInfoOutput: faultDisputeGameImpl not set\""},"value":"FetchChainInfoOutput: faultDisputeGameImpl not set"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_bool","typeString":"bool"},{"typeIdentifier":"t_stringliteral_baae18cd0fbc1fbf3c566f5918a7a4a780bb1a3d403d2b65d908417b87c06457","typeString":"literal_string \"FetchChainInfoOutput: faultDisputeGameImpl not set\""}],"id":54674,"name":"require","nodeType":"Identifier","overloadedDeclarations":[-18,-18,-18],"referencedDeclaration":-18,"src":"10825:7:100","typeDescriptions":{"typeIdentifier":"t_function_require_pure$_t_bool_$_t_string_memory_ptr_$returns$__$","typeString":"function (bool,string memory) pure"}},"id":54682,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"10825:98:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":54683,"nodeType":"ExpressionStatement","src":"10825:98:100"},{"expression":{"id":54684,"name":"_faultDisputeGameImpl","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54077,"src":"10940:21:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"functionReturnParameters":54673,"id":54685,"nodeType":"Return","src":"10933:28:100"}]},"functionSelector":"dea21984","implemented":true,"kind":"function","modifiers":[],"name":"faultDisputeGameImpl","nameLocation":"10762:20:100","parameters":{"id":54670,"nodeType":"ParameterList","parameters":[],"src":"10782:2:100"},"returnParameters":{"id":54673,"nodeType":"ParameterList","parameters":[{"constant":false,"id":54672,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":54687,"src":"10806:7:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":54671,"name":"address","nodeType":"ElementaryTypeName","src":"10806:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"10805:9:100"},"scope":54911,"stateMutability":"view","virtual":false,"visibility":"public"},{"id":54705,"nodeType":"FunctionDefinition","src":"10974:289:100","nodes":[],"body":{"id":54704,"nodeType":"Block","src":"11046:217:100","nodes":[],"statements":[{"expression":{"arguments":[{"commonType":{"typeIdentifier":"t_address","typeString":"address"},"id":54698,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftExpression":{"id":54693,"name":"_faultDisputeGameCannonKonaImpl","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54079,"src":"11077:31:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"BinaryOperation","operator":"!=","rightExpression":{"arguments":[{"hexValue":"30","id":54696,"isConstant":false,"isLValue":false,"isPure":true,"kind":"number","lValueRequested":false,"nodeType":"Literal","src":"11120:1:100","typeDescriptions":{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"},"value":"0"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"}],"id":54695,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"nodeType":"ElementaryTypeNameExpression","src":"11112:7:100","typeDescriptions":{"typeIdentifier":"t_type$_t_address_$","typeString":"type(address)"},"typeName":{"id":54694,"name":"address","nodeType":"ElementaryTypeName","src":"11112:7:100","typeDescriptions":{}}},"id":54697,"isConstant":false,"isLValue":false,"isPure":true,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"11112:10:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"src":"11077:45:100","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},{"hexValue":"4665746368436861696e496e666f4f75747075743a206661756c744469737075746547616d6543616e6e6f6e4b6f6e61496d706c206e6f7420736574","id":54699,"isConstant":false,"isLValue":false,"isPure":true,"kind":"string","lValueRequested":false,"nodeType":"Literal","src":"11136:62:100","typeDescriptions":{"typeIdentifier":"t_stringliteral_1a6322899b29428b71a9f44d1d2e4f85d48c09a65bfacd98b10709bf7aff2087","typeString":"literal_string \"FetchChainInfoOutput: faultDisputeGameCannonKonaImpl not set\""},"value":"FetchChainInfoOutput: faultDisputeGameCannonKonaImpl not set"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_bool","typeString":"bool"},{"typeIdentifier":"t_stringliteral_1a6322899b29428b71a9f44d1d2e4f85d48c09a65bfacd98b10709bf7aff2087","typeString":"literal_string \"FetchChainInfoOutput: faultDisputeGameCannonKonaImpl not set\""}],"id":54692,"name":"require","nodeType":"Identifier","overloadedDeclarations":[-18,-18,-18],"referencedDeclaration":-18,"src":"11056:7:100","typeDescriptions":{"typeIdentifier":"t_function_require_pure$_t_bool_$_t_string_memory_ptr_$returns$__$","typeString":"function (bool,string memory) pure"}},"id":54700,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"11056:152:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":54701,"nodeType":"ExpressionStatement","src":"11056:152:100"},{"expression":{"id":54702,"name":"_faultDisputeGameCannonKonaImpl","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54079,"src":"11225:31:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"functionReturnParameters":54691,"id":54703,"nodeType":"Return","src":"11218:38:100"}]},"functionSelector":"5d25b21d","implemented":true,"kind":"function","modifiers":[],"name":"faultDisputeGameCannonKonaImpl","nameLocation":"10983:30:100","parameters":{"id":54688,"nodeType":"ParameterList","parameters":[],"src":"11013:2:100"},"returnParameters":{"id":54691,"nodeType":"ParameterList","parameters":[{"constant":false,"id":54690,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":54705,"src":"11037:7:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":54689,"name":"address","nodeType":"ElementaryTypeName","src":"11037:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"11036:9:100"},"scope":54911,"stateMutability":"view","virtual":false,"visibility":"public"},{"id":54723,"nodeType":"FunctionDefinition","src":"11269:167:100","nodes":[],"body":{"id":54722,"nodeType":"Block","src":"11319:117:100","nodes":[],"statements":[{"expression":{"arguments":[{"commonType":{"typeIdentifier":"t_address","typeString":"address"},"id":54716,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftExpression":{"id":54711,"name":"_mipsImpl","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54045,"src":"11337:9:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"BinaryOperation","operator":"!=","rightExpression":{"arguments":[{"hexValue":"30","id":54714,"isConstant":false,"isLValue":false,"isPure":true,"kind":"number","lValueRequested":false,"nodeType":"Literal","src":"11358:1:100","typeDescriptions":{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"},"value":"0"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"}],"id":54713,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"nodeType":"ElementaryTypeNameExpression","src":"11350:7:100","typeDescriptions":{"typeIdentifier":"t_type$_t_address_$","typeString":"type(address)"},"typeName":{"id":54712,"name":"address","nodeType":"ElementaryTypeName","src":"11350:7:100","typeDescriptions":{}}},"id":54715,"isConstant":false,"isLValue":false,"isPure":true,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"11350:10:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"src":"11337:23:100","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},{"hexValue":"4665746368436861696e496e666f4f75747075743a206d697073496d706c206e6f7420736574","id":54717,"isConstant":false,"isLValue":false,"isPure":true,"kind":"string","lValueRequested":false,"nodeType":"Literal","src":"11362:40:100","typeDescriptions":{"typeIdentifier":"t_stringliteral_178867f585ae7eaee2b47a35fdf118ac2b037c387c5937f3b39b1c51f05d7497","typeString":"literal_string \"FetchChainInfoOutput: mipsImpl not set\""},"value":"FetchChainInfoOutput: mipsImpl not set"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_bool","typeString":"bool"},{"typeIdentifier":"t_stringliteral_178867f585ae7eaee2b47a35fdf118ac2b037c387c5937f3b39b1c51f05d7497","typeString":"literal_string \"FetchChainInfoOutput: mipsImpl not set\""}],"id":54710,"name":"require","nodeType":"Identifier","overloadedDeclarations":[-18,-18,-18],"referencedDeclaration":-18,"src":"11329:7:100","typeDescriptions":{"typeIdentifier":"t_function_require_pure$_t_bool_$_t_string_memory_ptr_$returns$__$","typeString":"function (bool,string memory) pure"}},"id":54718,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"11329:74:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":54719,"nodeType":"ExpressionStatement","src":"11329:74:100"},{"expression":{"id":54720,"name":"_mipsImpl","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54045,"src":"11420:9:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"functionReturnParameters":54709,"id":54721,"nodeType":"Return","src":"11413:16:100"}]},"functionSelector":"e303272c","implemented":true,"kind":"function","modifiers":[],"name":"mipsImpl","nameLocation":"11278:8:100","parameters":{"id":54706,"nodeType":"ParameterList","parameters":[],"src":"11286:2:100"},"returnParameters":{"id":54709,"nodeType":"ParameterList","parameters":[{"constant":false,"id":54708,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":54723,"src":"11310:7:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":54707,"name":"address","nodeType":"ElementaryTypeName","src":"11310:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"11309:9:100"},"scope":54911,"stateMutability":"view","virtual":false,"visibility":"public"},{"id":54741,"nodeType":"FunctionDefinition","src":"11442:243:100","nodes":[],"body":{"id":54740,"nodeType":"Block","src":"11511:174:100","nodes":[],"statements":[{"expression":{"arguments":[{"commonType":{"typeIdentifier":"t_address","typeString":"address"},"id":54734,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftExpression":{"id":54729,"name":"_permissionedDisputeGameImpl","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54081,"src":"11529:28:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"BinaryOperation","operator":"!=","rightExpression":{"arguments":[{"hexValue":"30","id":54732,"isConstant":false,"isLValue":false,"isPure":true,"kind":"number","lValueRequested":false,"nodeType":"Literal","src":"11569:1:100","typeDescriptions":{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"},"value":"0"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"}],"id":54731,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"nodeType":"ElementaryTypeNameExpression","src":"11561:7:100","typeDescriptions":{"typeIdentifier":"t_type$_t_address_$","typeString":"type(address)"},"typeName":{"id":54730,"name":"address","nodeType":"ElementaryTypeName","src":"11561:7:100","typeDescriptions":{}}},"id":54733,"isConstant":false,"isLValue":false,"isPure":true,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"11561:10:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"src":"11529:42:100","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},{"hexValue":"4665746368436861696e496e666f4f75747075743a207065726d697373696f6e65644469737075746547616d65496d706c206e6f7420736574","id":54735,"isConstant":false,"isLValue":false,"isPure":true,"kind":"string","lValueRequested":false,"nodeType":"Literal","src":"11573:59:100","typeDescriptions":{"typeIdentifier":"t_stringliteral_234858b97aab3865b03b564f238f9977c62296b1532cb4f809e12678629cae92","typeString":"literal_string \"FetchChainInfoOutput: permissionedDisputeGameImpl not set\""},"value":"FetchChainInfoOutput: permissionedDisputeGameImpl not set"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_bool","typeString":"bool"},{"typeIdentifier":"t_stringliteral_234858b97aab3865b03b564f238f9977c62296b1532cb4f809e12678629cae92","typeString":"literal_string \"FetchChainInfoOutput: permissionedDisputeGameImpl not set\""}],"id":54728,"name":"require","nodeType":"Identifier","overloadedDeclarations":[-18,-18,-18],"referencedDeclaration":-18,"src":"11521:7:100","typeDescriptions":{"typeIdentifier":"t_function_require_pure$_t_bool_$_t_string_memory_ptr_$returns$__$","typeString":"function (bool,string memory) pure"}},"id":54736,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"11521:112:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":54737,"nodeType":"ExpressionStatement","src":"11521:112:100"},{"expression":{"id":54738,"name":"_permissionedDisputeGameImpl","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54081,"src":"11650:28:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"functionReturnParameters":54727,"id":54739,"nodeType":"Return","src":"11643:35:100"}]},"functionSelector":"98ccec3e","implemented":true,"kind":"function","modifiers":[],"name":"permissionedDisputeGameImpl","nameLocation":"11451:27:100","parameters":{"id":54724,"nodeType":"ParameterList","parameters":[],"src":"11478:2:100"},"returnParameters":{"id":54727,"nodeType":"ParameterList","parameters":[{"constant":false,"id":54726,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":54741,"src":"11502:7:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":54725,"name":"address","nodeType":"ElementaryTypeName","src":"11502:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"11501:9:100"},"scope":54911,"stateMutability":"view","virtual":false,"visibility":"public"},{"id":54759,"nodeType":"FunctionDefinition","src":"11691:207:100","nodes":[],"body":{"id":54758,"nodeType":"Block","src":"11751:147:100","nodes":[],"statements":[{"expression":{"arguments":[{"commonType":{"typeIdentifier":"t_address","typeString":"address"},"id":54752,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftExpression":{"id":54747,"name":"_preimageOracleImpl","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54047,"src":"11769:19:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"BinaryOperation","operator":"!=","rightExpression":{"arguments":[{"hexValue":"30","id":54750,"isConstant":false,"isLValue":false,"isPure":true,"kind":"number","lValueRequested":false,"nodeType":"Literal","src":"11800:1:100","typeDescriptions":{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"},"value":"0"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"}],"id":54749,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"nodeType":"ElementaryTypeNameExpression","src":"11792:7:100","typeDescriptions":{"typeIdentifier":"t_type$_t_address_$","typeString":"type(address)"},"typeName":{"id":54748,"name":"address","nodeType":"ElementaryTypeName","src":"11792:7:100","typeDescriptions":{}}},"id":54751,"isConstant":false,"isLValue":false,"isPure":true,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"11792:10:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"src":"11769:33:100","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},{"hexValue":"4665746368436861696e496e666f4f75747075743a20707265696d6167654f7261636c65496d706c206e6f7420736574","id":54753,"isConstant":false,"isLValue":false,"isPure":true,"kind":"string","lValueRequested":false,"nodeType":"Literal","src":"11804:50:100","typeDescriptions":{"typeIdentifier":"t_stringliteral_2434e23032e7627ba1a13e989a9fbe735952d0d6f49e2760e1b1064b8728d538","typeString":"literal_string \"FetchChainInfoOutput: preimageOracleImpl not set\""},"value":"FetchChainInfoOutput: preimageOracleImpl not set"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_bool","typeString":"bool"},{"typeIdentifier":"t_stringliteral_2434e23032e7627ba1a13e989a9fbe735952d0d6f49e2760e1b1064b8728d538","typeString":"literal_string \"FetchChainInfoOutput: preimageOracleImpl not set\""}],"id":54746,"name":"require","nodeType":"Identifier","overloadedDeclarations":[-18,-18,-18],"referencedDeclaration":-18,"src":"11761:7:100","typeDescriptions":{"typeIdentifier":"t_function_require_pure$_t_bool_$_t_string_memory_ptr_$returns$__$","typeString":"function (bool,string memory) pure"}},"id":54754,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"11761:94:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":54755,"nodeType":"ExpressionStatement","src":"11761:94:100"},{"expression":{"id":54756,"name":"_preimageOracleImpl","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54047,"src":"11872:19:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"functionReturnParameters":54745,"id":54757,"nodeType":"Return","src":"11865:26:100"}]},"functionSelector":"d030d2e8","implemented":true,"kind":"function","modifiers":[],"name":"preimageOracleImpl","nameLocation":"11700:18:100","parameters":{"id":54742,"nodeType":"ParameterList","parameters":[],"src":"11718:2:100"},"returnParameters":{"id":54745,"nodeType":"ParameterList","parameters":[{"constant":false,"id":54744,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":54759,"src":"11742:7:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":54743,"name":"address","nodeType":"ElementaryTypeName","src":"11742:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"11741:9:100"},"scope":54911,"stateMutability":"view","virtual":false,"visibility":"public"},{"id":54777,"nodeType":"FunctionDefinition","src":"11904:203:100","nodes":[],"body":{"id":54776,"nodeType":"Block","src":"11963:144:100","nodes":[],"statements":[{"expression":{"arguments":[{"commonType":{"typeIdentifier":"t_address","typeString":"address"},"id":54770,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftExpression":{"id":54765,"name":"_systemConfigOwner","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54083,"src":"11981:18:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"BinaryOperation","operator":"!=","rightExpression":{"arguments":[{"hexValue":"30","id":54768,"isConstant":false,"isLValue":false,"isPure":true,"kind":"number","lValueRequested":false,"nodeType":"Literal","src":"12011:1:100","typeDescriptions":{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"},"value":"0"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"}],"id":54767,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"nodeType":"ElementaryTypeNameExpression","src":"12003:7:100","typeDescriptions":{"typeIdentifier":"t_type$_t_address_$","typeString":"type(address)"},"typeName":{"id":54766,"name":"address","nodeType":"ElementaryTypeName","src":"12003:7:100","typeDescriptions":{}}},"id":54769,"isConstant":false,"isLValue":false,"isPure":true,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"12003:10:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"src":"11981:32:100","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},{"hexValue":"4665746368436861696e496e666f4f75747075743a2073797374656d436f6e6669674f776e6572206e6f7420736574","id":54771,"isConstant":false,"isLValue":false,"isPure":true,"kind":"string","lValueRequested":false,"nodeType":"Literal","src":"12015:49:100","typeDescriptions":{"typeIdentifier":"t_stringliteral_fc7a67f4775c5e19ca3731b64db9f9f8895dcd37a01bc895f1d1806a7f21c916","typeString":"literal_string \"FetchChainInfoOutput: systemConfigOwner not set\""},"value":"FetchChainInfoOutput: systemConfigOwner not set"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_bool","typeString":"bool"},{"typeIdentifier":"t_stringliteral_fc7a67f4775c5e19ca3731b64db9f9f8895dcd37a01bc895f1d1806a7f21c916","typeString":"literal_string \"FetchChainInfoOutput: systemConfigOwner not set\""}],"id":54764,"name":"require","nodeType":"Identifier","overloadedDeclarations":[-18,-18,-18],"referencedDeclaration":-18,"src":"11973:7:100","typeDescriptions":{"typeIdentifier":"t_function_require_pure$_t_bool_$_t_string_memory_ptr_$returns$__$","typeString":"function (bool,string memory) pure"}},"id":54772,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"11973:92:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":54773,"nodeType":"ExpressionStatement","src":"11973:92:100"},{"expression":{"id":54774,"name":"_systemConfigOwner","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54083,"src":"12082:18:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"functionReturnParameters":54763,"id":54775,"nodeType":"Return","src":"12075:25:100"}]},"functionSelector":"1e229b20","implemented":true,"kind":"function","modifiers":[],"name":"systemConfigOwner","nameLocation":"11913:17:100","parameters":{"id":54760,"nodeType":"ParameterList","parameters":[],"src":"11930:2:100"},"returnParameters":{"id":54763,"nodeType":"ParameterList","parameters":[{"constant":false,"id":54762,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":54777,"src":"11954:7:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":54761,"name":"address","nodeType":"ElementaryTypeName","src":"11954:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"11953:9:100"},"scope":54911,"stateMutability":"view","virtual":false,"visibility":"public"},{"id":54795,"nodeType":"FunctionDefinition","src":"12113:223:100","nodes":[],"body":{"id":54794,"nodeType":"Block","src":"12177:159:100","nodes":[],"statements":[{"expression":{"arguments":[{"commonType":{"typeIdentifier":"t_address","typeString":"address"},"id":54788,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftExpression":{"id":54783,"name":"_opChainProxyAdminOwner","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54085,"src":"12195:23:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"BinaryOperation","operator":"!=","rightExpression":{"arguments":[{"hexValue":"30","id":54786,"isConstant":false,"isLValue":false,"isPure":true,"kind":"number","lValueRequested":false,"nodeType":"Literal","src":"12230:1:100","typeDescriptions":{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"},"value":"0"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"}],"id":54785,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"nodeType":"ElementaryTypeNameExpression","src":"12222:7:100","typeDescriptions":{"typeIdentifier":"t_type$_t_address_$","typeString":"type(address)"},"typeName":{"id":54784,"name":"address","nodeType":"ElementaryTypeName","src":"12222:7:100","typeDescriptions":{}}},"id":54787,"isConstant":false,"isLValue":false,"isPure":true,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"12222:10:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"src":"12195:37:100","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},{"hexValue":"4665746368436861696e496e666f4f75747075743a206f70436861696e50726f787941646d696e4f776e6572206e6f7420736574","id":54789,"isConstant":false,"isLValue":false,"isPure":true,"kind":"string","lValueRequested":false,"nodeType":"Literal","src":"12234:54:100","typeDescriptions":{"typeIdentifier":"t_stringliteral_cc12cbf05d2d853ebebe6e25c8b02d2f78d6af131087a61088362ca7d0befc81","typeString":"literal_string \"FetchChainInfoOutput: opChainProxyAdminOwner not set\""},"value":"FetchChainInfoOutput: opChainProxyAdminOwner not set"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_bool","typeString":"bool"},{"typeIdentifier":"t_stringliteral_cc12cbf05d2d853ebebe6e25c8b02d2f78d6af131087a61088362ca7d0befc81","typeString":"literal_string \"FetchChainInfoOutput: opChainProxyAdminOwner not set\""}],"id":54782,"name":"require","nodeType":"Identifier","overloadedDeclarations":[-18,-18,-18],"referencedDeclaration":-18,"src":"12187:7:100","typeDescriptions":{"typeIdentifier":"t_function_require_pure$_t_bool_$_t_string_memory_ptr_$returns$__$","typeString":"function (bool,string memory) pure"}},"id":54790,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"12187:102:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":54791,"nodeType":"ExpressionStatement","src":"12187:102:100"},{"expression":{"id":54792,"name":"_opChainProxyAdminOwner","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54085,"src":"12306:23:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"functionReturnParameters":54781,"id":54793,"nodeType":"Return","src":"12299:30:100"}]},"functionSelector":"1480f0cc","implemented":true,"kind":"function","modifiers":[],"name":"opChainProxyAdminOwner","nameLocation":"12122:22:100","parameters":{"id":54778,"nodeType":"ParameterList","parameters":[],"src":"12144:2:100"},"returnParameters":{"id":54781,"nodeType":"ParameterList","parameters":[{"constant":false,"id":54780,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":54795,"src":"12168:7:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":54779,"name":"address","nodeType":"ElementaryTypeName","src":"12168:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"12167:9:100"},"scope":54911,"stateMutability":"view","virtual":false,"visibility":"public"},{"id":54813,"nodeType":"FunctionDefinition","src":"12342:195:100","nodes":[],"body":{"id":54812,"nodeType":"Block","src":"12399:138:100","nodes":[],"statements":[{"expression":{"arguments":[{"commonType":{"typeIdentifier":"t_address","typeString":"address"},"id":54806,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftExpression":{"id":54801,"name":"_opChainGuardian","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54087,"src":"12417:16:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"BinaryOperation","operator":"!=","rightExpression":{"arguments":[{"hexValue":"30","id":54804,"isConstant":false,"isLValue":false,"isPure":true,"kind":"number","lValueRequested":false,"nodeType":"Literal","src":"12445:1:100","typeDescriptions":{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"},"value":"0"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"}],"id":54803,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"nodeType":"ElementaryTypeNameExpression","src":"12437:7:100","typeDescriptions":{"typeIdentifier":"t_type$_t_address_$","typeString":"type(address)"},"typeName":{"id":54802,"name":"address","nodeType":"ElementaryTypeName","src":"12437:7:100","typeDescriptions":{}}},"id":54805,"isConstant":false,"isLValue":false,"isPure":true,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"12437:10:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"src":"12417:30:100","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},{"hexValue":"4665746368436861696e496e666f4f75747075743a206f70436861696e477561726469616e206e6f7420736574","id":54807,"isConstant":false,"isLValue":false,"isPure":true,"kind":"string","lValueRequested":false,"nodeType":"Literal","src":"12449:47:100","typeDescriptions":{"typeIdentifier":"t_stringliteral_ab71487628da5c56ff40f228ee915a62d6c0a28ab899f48f84343df6dbc48bb7","typeString":"literal_string \"FetchChainInfoOutput: opChainGuardian not set\""},"value":"FetchChainInfoOutput: opChainGuardian not set"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_bool","typeString":"bool"},{"typeIdentifier":"t_stringliteral_ab71487628da5c56ff40f228ee915a62d6c0a28ab899f48f84343df6dbc48bb7","typeString":"literal_string \"FetchChainInfoOutput: opChainGuardian not set\""}],"id":54800,"name":"require","nodeType":"Identifier","overloadedDeclarations":[-18,-18,-18],"referencedDeclaration":-18,"src":"12409:7:100","typeDescriptions":{"typeIdentifier":"t_function_require_pure$_t_bool_$_t_string_memory_ptr_$returns$__$","typeString":"function (bool,string memory) pure"}},"id":54808,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"12409:88:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":54809,"nodeType":"ExpressionStatement","src":"12409:88:100"},{"expression":{"id":54810,"name":"_opChainGuardian","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54087,"src":"12514:16:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"functionReturnParameters":54799,"id":54811,"nodeType":"Return","src":"12507:23:100"}]},"functionSelector":"4bc2695f","implemented":true,"kind":"function","modifiers":[],"name":"opChainGuardian","nameLocation":"12351:15:100","parameters":{"id":54796,"nodeType":"ParameterList","parameters":[],"src":"12366:2:100"},"returnParameters":{"id":54799,"nodeType":"ParameterList","parameters":[{"constant":false,"id":54798,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":54813,"src":"12390:7:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":54797,"name":"address","nodeType":"ElementaryTypeName","src":"12390:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"12389:9:100"},"scope":54911,"stateMutability":"view","virtual":false,"visibility":"public"},{"id":54831,"nodeType":"FunctionDefinition","src":"12543:175:100","nodes":[],"body":{"id":54830,"nodeType":"Block","src":"12595:123:100","nodes":[],"statements":[{"expression":{"arguments":[{"commonType":{"typeIdentifier":"t_address","typeString":"address"},"id":54824,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftExpression":{"id":54819,"name":"_challenger","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54089,"src":"12613:11:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"BinaryOperation","operator":"!=","rightExpression":{"arguments":[{"hexValue":"30","id":54822,"isConstant":false,"isLValue":false,"isPure":true,"kind":"number","lValueRequested":false,"nodeType":"Literal","src":"12636:1:100","typeDescriptions":{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"},"value":"0"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"}],"id":54821,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"nodeType":"ElementaryTypeNameExpression","src":"12628:7:100","typeDescriptions":{"typeIdentifier":"t_type$_t_address_$","typeString":"type(address)"},"typeName":{"id":54820,"name":"address","nodeType":"ElementaryTypeName","src":"12628:7:100","typeDescriptions":{}}},"id":54823,"isConstant":false,"isLValue":false,"isPure":true,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"12628:10:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"src":"12613:25:100","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},{"hexValue":"4665746368436861696e496e666f4f75747075743a206368616c6c656e676572206e6f7420736574","id":54825,"isConstant":false,"isLValue":false,"isPure":true,"kind":"string","lValueRequested":false,"nodeType":"Literal","src":"12640:42:100","typeDescriptions":{"typeIdentifier":"t_stringliteral_d1dd717c39956ee86b1eb77b9f3cb6dbeca6df99b330f67dd364a35a1174c2ce","typeString":"literal_string \"FetchChainInfoOutput: challenger not set\""},"value":"FetchChainInfoOutput: challenger not set"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_bool","typeString":"bool"},{"typeIdentifier":"t_stringliteral_d1dd717c39956ee86b1eb77b9f3cb6dbeca6df99b330f67dd364a35a1174c2ce","typeString":"literal_string \"FetchChainInfoOutput: challenger not set\""}],"id":54818,"name":"require","nodeType":"Identifier","overloadedDeclarations":[-18,-18,-18],"referencedDeclaration":-18,"src":"12605:7:100","typeDescriptions":{"typeIdentifier":"t_function_require_pure$_t_bool_$_t_string_memory_ptr_$returns$__$","typeString":"function (bool,string memory) pure"}},"id":54826,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"12605:78:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":54827,"nodeType":"ExpressionStatement","src":"12605:78:100"},{"expression":{"id":54828,"name":"_challenger","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54089,"src":"12700:11:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"functionReturnParameters":54817,"id":54829,"nodeType":"Return","src":"12693:18:100"}]},"functionSelector":"534db0e2","implemented":true,"kind":"function","modifiers":[],"name":"challenger","nameLocation":"12552:10:100","parameters":{"id":54814,"nodeType":"ParameterList","parameters":[],"src":"12562:2:100"},"returnParameters":{"id":54817,"nodeType":"ParameterList","parameters":[{"constant":false,"id":54816,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":54831,"src":"12586:7:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":54815,"name":"address","nodeType":"ElementaryTypeName","src":"12586:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"12585:9:100"},"scope":54911,"stateMutability":"view","virtual":false,"visibility":"public"},{"id":54849,"nodeType":"FunctionDefinition","src":"12724:167:100","nodes":[],"body":{"id":54848,"nodeType":"Block","src":"12774:117:100","nodes":[],"statements":[{"expression":{"arguments":[{"commonType":{"typeIdentifier":"t_address","typeString":"address"},"id":54842,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftExpression":{"id":54837,"name":"_proposer","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54091,"src":"12792:9:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"BinaryOperation","operator":"!=","rightExpression":{"arguments":[{"hexValue":"30","id":54840,"isConstant":false,"isLValue":false,"isPure":true,"kind":"number","lValueRequested":false,"nodeType":"Literal","src":"12813:1:100","typeDescriptions":{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"},"value":"0"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"}],"id":54839,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"nodeType":"ElementaryTypeNameExpression","src":"12805:7:100","typeDescriptions":{"typeIdentifier":"t_type$_t_address_$","typeString":"type(address)"},"typeName":{"id":54838,"name":"address","nodeType":"ElementaryTypeName","src":"12805:7:100","typeDescriptions":{}}},"id":54841,"isConstant":false,"isLValue":false,"isPure":true,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"12805:10:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"src":"12792:23:100","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},{"hexValue":"4665746368436861696e496e666f4f75747075743a2070726f706f736572206e6f7420736574","id":54843,"isConstant":false,"isLValue":false,"isPure":true,"kind":"string","lValueRequested":false,"nodeType":"Literal","src":"12817:40:100","typeDescriptions":{"typeIdentifier":"t_stringliteral_c4910753f64240b424591ec2bc873e5a728ff321d57cb1a353788ad2c385da71","typeString":"literal_string \"FetchChainInfoOutput: proposer not set\""},"value":"FetchChainInfoOutput: proposer not set"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_bool","typeString":"bool"},{"typeIdentifier":"t_stringliteral_c4910753f64240b424591ec2bc873e5a728ff321d57cb1a353788ad2c385da71","typeString":"literal_string \"FetchChainInfoOutput: proposer not set\""}],"id":54836,"name":"require","nodeType":"Identifier","overloadedDeclarations":[-18,-18,-18],"referencedDeclaration":-18,"src":"12784:7:100","typeDescriptions":{"typeIdentifier":"t_function_require_pure$_t_bool_$_t_string_memory_ptr_$returns$__$","typeString":"function (bool,string memory) pure"}},"id":54844,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"12784:74:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":54845,"nodeType":"ExpressionStatement","src":"12784:74:100"},{"expression":{"id":54846,"name":"_proposer","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54091,"src":"12875:9:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"functionReturnParameters":54835,"id":54847,"nodeType":"Return","src":"12868:16:100"}]},"functionSelector":"a8e4fb90","implemented":true,"kind":"function","modifiers":[],"name":"proposer","nameLocation":"12733:8:100","parameters":{"id":54832,"nodeType":"ParameterList","parameters":[],"src":"12741:2:100"},"returnParameters":{"id":54835,"nodeType":"ParameterList","parameters":[{"constant":false,"id":54834,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":54849,"src":"12765:7:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":54833,"name":"address","nodeType":"ElementaryTypeName","src":"12765:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"12764:9:100"},"scope":54911,"stateMutability":"view","virtual":false,"visibility":"public"},{"id":54867,"nodeType":"FunctionDefinition","src":"12897:203:100","nodes":[],"body":{"id":54866,"nodeType":"Block","src":"12956:144:100","nodes":[],"statements":[{"expression":{"arguments":[{"commonType":{"typeIdentifier":"t_address","typeString":"address"},"id":54860,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftExpression":{"id":54855,"name":"_unsafeBlockSigner","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54093,"src":"12974:18:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"BinaryOperation","operator":"!=","rightExpression":{"arguments":[{"hexValue":"30","id":54858,"isConstant":false,"isLValue":false,"isPure":true,"kind":"number","lValueRequested":false,"nodeType":"Literal","src":"13004:1:100","typeDescriptions":{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"},"value":"0"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"}],"id":54857,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"nodeType":"ElementaryTypeNameExpression","src":"12996:7:100","typeDescriptions":{"typeIdentifier":"t_type$_t_address_$","typeString":"type(address)"},"typeName":{"id":54856,"name":"address","nodeType":"ElementaryTypeName","src":"12996:7:100","typeDescriptions":{}}},"id":54859,"isConstant":false,"isLValue":false,"isPure":true,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"12996:10:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"src":"12974:32:100","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},{"hexValue":"4665746368436861696e496e666f4f75747075743a20756e73616665426c6f636b5369676e6572206e6f7420736574","id":54861,"isConstant":false,"isLValue":false,"isPure":true,"kind":"string","lValueRequested":false,"nodeType":"Literal","src":"13008:49:100","typeDescriptions":{"typeIdentifier":"t_stringliteral_c0c85432d1596fb73656e29b64f6ea745166dde4a7fa6163bfe6b285aea851d7","typeString":"literal_string \"FetchChainInfoOutput: unsafeBlockSigner not set\""},"value":"FetchChainInfoOutput: unsafeBlockSigner not set"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_bool","typeString":"bool"},{"typeIdentifier":"t_stringliteral_c0c85432d1596fb73656e29b64f6ea745166dde4a7fa6163bfe6b285aea851d7","typeString":"literal_string \"FetchChainInfoOutput: unsafeBlockSigner not set\""}],"id":54854,"name":"require","nodeType":"Identifier","overloadedDeclarations":[-18,-18,-18],"referencedDeclaration":-18,"src":"12966:7:100","typeDescriptions":{"typeIdentifier":"t_function_require_pure$_t_bool_$_t_string_memory_ptr_$returns$__$","typeString":"function (bool,string memory) pure"}},"id":54862,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"12966:92:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":54863,"nodeType":"ExpressionStatement","src":"12966:92:100"},{"expression":{"id":54864,"name":"_unsafeBlockSigner","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54093,"src":"13075:18:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"functionReturnParameters":54853,"id":54865,"nodeType":"Return","src":"13068:25:100"}]},"functionSelector":"1fd19ee1","implemented":true,"kind":"function","modifiers":[],"name":"unsafeBlockSigner","nameLocation":"12906:17:100","parameters":{"id":54850,"nodeType":"ParameterList","parameters":[],"src":"12923:2:100"},"returnParameters":{"id":54853,"nodeType":"ParameterList","parameters":[{"constant":false,"id":54852,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":54867,"src":"12947:7:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":54851,"name":"address","nodeType":"ElementaryTypeName","src":"12947:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"12946:9:100"},"scope":54911,"stateMutability":"view","virtual":false,"visibility":"public"},{"id":54885,"nodeType":"FunctionDefinition","src":"13106:191:100","nodes":[],"body":{"id":54884,"nodeType":"Block","src":"13162:135:100","nodes":[],"statements":[{"expression":{"arguments":[{"commonType":{"typeIdentifier":"t_address","typeString":"address"},"id":54878,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftExpression":{"id":54873,"name":"_batchSubmitter","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54095,"src":"13180:15:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"BinaryOperation","operator":"!=","rightExpression":{"arguments":[{"hexValue":"30","id":54876,"isConstant":false,"isLValue":false,"isPure":true,"kind":"number","lValueRequested":false,"nodeType":"Literal","src":"13207:1:100","typeDescriptions":{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"},"value":"0"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"}],"id":54875,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"nodeType":"ElementaryTypeNameExpression","src":"13199:7:100","typeDescriptions":{"typeIdentifier":"t_type$_t_address_$","typeString":"type(address)"},"typeName":{"id":54874,"name":"address","nodeType":"ElementaryTypeName","src":"13199:7:100","typeDescriptions":{}}},"id":54877,"isConstant":false,"isLValue":false,"isPure":true,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"13199:10:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"src":"13180:29:100","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},{"hexValue":"4665746368436861696e496e666f4f75747075743a2062617463685375626d6974746572206e6f7420736574","id":54879,"isConstant":false,"isLValue":false,"isPure":true,"kind":"string","lValueRequested":false,"nodeType":"Literal","src":"13211:46:100","typeDescriptions":{"typeIdentifier":"t_stringliteral_dc2094d90bbe21c62e4087e13d121e3f8b0b046ea0a70d61432535290d56a2cc","typeString":"literal_string \"FetchChainInfoOutput: batchSubmitter not set\""},"value":"FetchChainInfoOutput: batchSubmitter not set"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_bool","typeString":"bool"},{"typeIdentifier":"t_stringliteral_dc2094d90bbe21c62e4087e13d121e3f8b0b046ea0a70d61432535290d56a2cc","typeString":"literal_string \"FetchChainInfoOutput: batchSubmitter not set\""}],"id":54872,"name":"require","nodeType":"Identifier","overloadedDeclarations":[-18,-18,-18],"referencedDeclaration":-18,"src":"13172:7:100","typeDescriptions":{"typeIdentifier":"t_function_require_pure$_t_bool_$_t_string_memory_ptr_$returns$__$","typeString":"function (bool,string memory) pure"}},"id":54880,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"13172:86:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":54881,"nodeType":"ExpressionStatement","src":"13172:86:100"},{"expression":{"id":54882,"name":"_batchSubmitter","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54095,"src":"13275:15:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"functionReturnParameters":54871,"id":54883,"nodeType":"Return","src":"13268:22:100"}]},"functionSelector":"fb951e9d","implemented":true,"kind":"function","modifiers":[],"name":"batchSubmitter","nameLocation":"13115:14:100","parameters":{"id":54868,"nodeType":"ParameterList","parameters":[],"src":"13129:2:100"},"returnParameters":{"id":54871,"nodeType":"ParameterList","parameters":[{"constant":false,"id":54870,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":54885,"src":"13153:7:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":54869,"name":"address","nodeType":"ElementaryTypeName","src":"13153:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"13152:9:100"},"scope":54911,"stateMutability":"view","virtual":false,"visibility":"public"},{"id":54893,"nodeType":"FunctionDefinition","src":"13303:88:100","nodes":[],"body":{"id":54892,"nodeType":"Block","src":"13354:37:100","nodes":[],"statements":[{"expression":{"id":54890,"name":"_permissioned","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54097,"src":"13371:13:100","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},"functionReturnParameters":54889,"id":54891,"nodeType":"Return","src":"13364:20:100"}]},"functionSelector":"3cc162f1","implemented":true,"kind":"function","modifiers":[],"name":"permissioned","nameLocation":"13312:12:100","parameters":{"id":54886,"nodeType":"ParameterList","parameters":[],"src":"13324:2:100"},"returnParameters":{"id":54889,"nodeType":"ParameterList","parameters":[{"constant":false,"id":54888,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":54893,"src":"13348:4:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"},"typeName":{"id":54887,"name":"bool","nodeType":"ElementaryTypeName","src":"13348:4:100","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},"visibility":"internal"}],"src":"13347:6:100"},"scope":54911,"stateMutability":"view","virtual":false,"visibility":"public"},{"id":54901,"nodeType":"FunctionDefinition","src":"13397:92:100","nodes":[],"body":{"id":54900,"nodeType":"Block","src":"13450:39:100","nodes":[],"statements":[{"expression":{"id":54898,"name":"_permissionless","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54099,"src":"13467:15:100","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},"functionReturnParameters":54897,"id":54899,"nodeType":"Return","src":"13460:22:100"}]},"functionSelector":"a1256f9f","implemented":true,"kind":"function","modifiers":[],"name":"permissionless","nameLocation":"13406:14:100","parameters":{"id":54894,"nodeType":"ParameterList","parameters":[],"src":"13420:2:100"},"returnParameters":{"id":54897,"nodeType":"ParameterList","parameters":[{"constant":false,"id":54896,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":54901,"src":"13444:4:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"},"typeName":{"id":54895,"name":"bool","nodeType":"ElementaryTypeName","src":"13444:4:100","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},"visibility":"internal"}],"src":"13443:6:100"},"scope":54911,"stateMutability":"view","virtual":false,"visibility":"public"},{"id":54910,"nodeType":"FunctionDefinition","src":"13495:102:100","nodes":[],"body":{"id":54909,"nodeType":"Block","src":"13555:42:100","nodes":[],"statements":[{"expression":{"id":54907,"name":"_respectedGameType","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54102,"src":"13572:18:100","typeDescriptions":{"typeIdentifier":"t_userDefinedValueType$_GameType_$70720","typeString":"GameType"}},"functionReturnParameters":54906,"id":54908,"nodeType":"Return","src":"13565:25:100"}]},"functionSelector":"3c9f397c","implemented":true,"kind":"function","modifiers":[],"name":"respectedGameType","nameLocation":"13504:17:100","parameters":{"id":54902,"nodeType":"ParameterList","parameters":[],"src":"13521:2:100"},"returnParameters":{"id":54906,"nodeType":"ParameterList","parameters":[{"constant":false,"id":54905,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":54910,"src":"13545:8:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_userDefinedValueType$_GameType_$70720","typeString":"GameType"},"typeName":{"id":54904,"nodeType":"UserDefinedTypeName","pathNode":{"id":54903,"name":"GameType","nameLocations":["13545:8:100"],"nodeType":"IdentifierPath","referencedDeclaration":70720,"src":"13545:8:100"},"referencedDeclaration":70720,"src":"13545:8:100","typeDescriptions":{"typeIdentifier":"t_userDefinedValueType$_GameType_$70720","typeString":"GameType"}},"visibility":"internal"}],"src":"13544:10:100"},"scope":54911,"stateMutability":"view","virtual":false,"visibility":"public"}],"abstract":false,"baseContracts":[],"canonicalName":"FetchChainInfoOutput","contractDependencies":[],"contractKind":"contract","fullyImplemented":true,"linearizedBaseContracts":[54911],"name":"FetchChainInfoOutput","nameLocation":"2966:20:100","scope":56019,"usedErrors":[],"usedEvents":[]},{"id":56018,"nodeType":"ContractDefinition","src":"13601:11550:100","nodes":[{"id":54937,"nodeType":"FunctionDefinition","src":"13641:198:100","nodes":[],"body":{"id":54936,"nodeType":"Block","src":"13712:127:100","nodes":[],"statements":[{"expression":{"arguments":[{"id":54923,"name":"_fi","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54916,"src":"13743:3:100","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoInput_$54041","typeString":"contract FetchChainInfoInput"}},{"id":54924,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54919,"src":"13748:3:100","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$54911","typeString":"contract FetchChainInfoOutput"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_contract$_FetchChainInfoInput_$54041","typeString":"contract FetchChainInfoInput"},{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$54911","typeString":"contract FetchChainInfoOutput"}],"id":54922,"name":"_processSystemConfig","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55073,"src":"13722:20:100","typeDescriptions":{"typeIdentifier":"t_function_internal_nonpayable$_t_contract$_FetchChainInfoInput_$54041_$_t_contract$_FetchChainInfoOutput_$54911_$returns$__$","typeString":"function (contract FetchChainInfoInput,contract FetchChainInfoOutput)"}},"id":54925,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"13722:30:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":54926,"nodeType":"ExpressionStatement","src":"13722:30:100"},{"expression":{"arguments":[{"id":54928,"name":"_fi","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54916,"src":"13789:3:100","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoInput_$54041","typeString":"contract FetchChainInfoInput"}},{"id":54929,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54919,"src":"13794:3:100","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$54911","typeString":"contract FetchChainInfoOutput"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_contract$_FetchChainInfoInput_$54041","typeString":"contract FetchChainInfoInput"},{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$54911","typeString":"contract FetchChainInfoOutput"}],"id":54927,"name":"_processMessengerAndPortal","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55190,"src":"13762:26:100","typeDescriptions":{"typeIdentifier":"t_function_internal_nonpayable$_t_contract$_FetchChainInfoInput_$54041_$_t_contract$_FetchChainInfoOutput_$54911_$returns$__$","typeString":"function (contract FetchChainInfoInput,contract FetchChainInfoOutput)"}},"id":54930,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"13762:36:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":54931,"nodeType":"ExpressionStatement","src":"13762:36:100"},{"expression":{"arguments":[{"id":54933,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54919,"src":"13828:3:100","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$54911","typeString":"contract FetchChainInfoOutput"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$54911","typeString":"contract FetchChainInfoOutput"}],"id":54932,"name":"_processFaultProofs","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55565,"src":"13808:19:100","typeDescriptions":{"typeIdentifier":"t_function_internal_nonpayable$_t_contract$_FetchChainInfoOutput_$54911_$returns$__$","typeString":"function (contract FetchChainInfoOutput)"}},"id":54934,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"13808:24:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":54935,"nodeType":"ExpressionStatement","src":"13808:24:100"}]},"functionSelector":"fc4dcacb","implemented":true,"kind":"function","modifiers":[],"name":"run","nameLocation":"13650:3:100","parameters":{"id":54920,"nodeType":"ParameterList","parameters":[{"constant":false,"id":54916,"mutability":"mutable","name":"_fi","nameLocation":"13674:3:100","nodeType":"VariableDeclaration","scope":54937,"src":"13654:23:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoInput_$54041","typeString":"contract FetchChainInfoInput"},"typeName":{"id":54915,"nodeType":"UserDefinedTypeName","pathNode":{"id":54914,"name":"FetchChainInfoInput","nameLocations":["13654:19:100"],"nodeType":"IdentifierPath","referencedDeclaration":54041,"src":"13654:19:100"},"referencedDeclaration":54041,"src":"13654:19:100","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoInput_$54041","typeString":"contract FetchChainInfoInput"}},"visibility":"internal"},{"constant":false,"id":54919,"mutability":"mutable","name":"_fo","nameLocation":"13700:3:100","nodeType":"VariableDeclaration","scope":54937,"src":"13679:24:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$54911","typeString":"contract FetchChainInfoOutput"},"typeName":{"id":54918,"nodeType":"UserDefinedTypeName","pathNode":{"id":54917,"name":"FetchChainInfoOutput","nameLocations":["13679:20:100"],"nodeType":"IdentifierPath","referencedDeclaration":54911,"src":"13679:20:100"},"referencedDeclaration":54911,"src":"13679:20:100","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$54911","typeString":"contract FetchChainInfoOutput"}},"visibility":"internal"}],"src":"13653:51:100"},"returnParameters":{"id":54921,"nodeType":"ParameterList","parameters":[],"src":"13712:0:100"},"scope":56018,"stateMutability":"nonpayable","virtual":false,"visibility":"public"},{"id":55073,"nodeType":"FunctionDefinition","src":"13845:1336:100","nodes":[],"body":{"id":55072,"nodeType":"Block","src":"13935:1246:100","nodes":[],"statements":[{"assignments":[54947],"declarations":[{"constant":false,"id":54947,"mutability":"mutable","name":"systemConfigProxy","nameLocation":"13953:17:100","nodeType":"VariableDeclaration","scope":55072,"src":"13945:25:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":54946,"name":"address","nodeType":"ElementaryTypeName","src":"13945:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"id":54951,"initialValue":{"arguments":[],"expression":{"argumentTypes":[],"expression":{"id":54948,"name":"_fi","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54940,"src":"13973:3:100","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoInput_$54041","typeString":"contract FetchChainInfoInput"}},"id":54949,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"13977:17:100","memberName":"systemConfigProxy","nodeType":"MemberAccess","referencedDeclaration":54022,"src":"13973:21:100","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":54950,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"13973:23:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"VariableDeclarationStatement","src":"13945:51:100"},{"expression":{"arguments":[{"expression":{"expression":{"id":54955,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54943,"src":"14014:3:100","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$54911","typeString":"contract FetchChainInfoOutput"}},"id":54956,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"14018:17:100","memberName":"systemConfigProxy","nodeType":"MemberAccess","referencedDeclaration":54591,"src":"14014:21:100","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":54957,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"14036:8:100","memberName":"selector","nodeType":"MemberAccess","src":"14014:30:100","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},{"id":54958,"name":"systemConfigProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54947,"src":"14046:17:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_bytes4","typeString":"bytes4"},{"typeIdentifier":"t_address","typeString":"address"}],"expression":{"id":54952,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54943,"src":"14006:3:100","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$54911","typeString":"contract FetchChainInfoOutput"}},"id":54954,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"14010:3:100","memberName":"set","nodeType":"MemberAccess","referencedDeclaration":54384,"src":"14006:7:100","typeDescriptions":{"typeIdentifier":"t_function_external_nonpayable$_t_bytes4_$_t_address_$returns$__$","typeString":"function (bytes4,address) external"}},"id":54959,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"14006:58:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":54960,"nodeType":"ExpressionStatement","src":"14006:58:100"},{"assignments":[54962],"declarations":[{"constant":false,"id":54962,"mutability":"mutable","name":"systemConfigOwner","nameLocation":"14083:17:100","nodeType":"VariableDeclaration","scope":55072,"src":"14075:25:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":54961,"name":"address","nodeType":"ElementaryTypeName","src":"14075:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"id":54968,"initialValue":{"arguments":[],"expression":{"argumentTypes":[],"expression":{"arguments":[{"id":54964,"name":"systemConfigProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54947,"src":"14112:17:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_address","typeString":"address"}],"id":54963,"name":"IFetcher","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":53958,"src":"14103:8:100","typeDescriptions":{"typeIdentifier":"t_type$_t_contract$_IFetcher_$53958_$","typeString":"type(contract IFetcher)"}},"id":54965,"isConstant":false,"isLValue":false,"isPure":false,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"14103:27:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_contract$_IFetcher_$53958","typeString":"contract IFetcher"}},"id":54966,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"14131:5:100","memberName":"owner","nodeType":"MemberAccess","referencedDeclaration":53947,"src":"14103:33:100","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":54967,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"14103:35:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"VariableDeclarationStatement","src":"14075:63:100"},{"expression":{"arguments":[{"expression":{"expression":{"id":54972,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54943,"src":"14156:3:100","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$54911","typeString":"contract FetchChainInfoOutput"}},"id":54973,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"14160:17:100","memberName":"systemConfigOwner","nodeType":"MemberAccess","referencedDeclaration":54777,"src":"14156:21:100","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":54974,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"14178:8:100","memberName":"selector","nodeType":"MemberAccess","src":"14156:30:100","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},{"id":54975,"name":"systemConfigOwner","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54962,"src":"14188:17:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_bytes4","typeString":"bytes4"},{"typeIdentifier":"t_address","typeString":"address"}],"expression":{"id":54969,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54943,"src":"14148:3:100","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$54911","typeString":"contract FetchChainInfoOutput"}},"id":54971,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"14152:3:100","memberName":"set","nodeType":"MemberAccess","referencedDeclaration":54384,"src":"14148:7:100","typeDescriptions":{"typeIdentifier":"t_function_external_nonpayable$_t_bytes4_$_t_address_$returns$__$","typeString":"function (bytes4,address) external"}},"id":54976,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"14148:58:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":54977,"nodeType":"ExpressionStatement","src":"14148:58:100"},{"assignments":[54979],"declarations":[{"constant":false,"id":54979,"mutability":"mutable","name":"unsafeBlockSigner","nameLocation":"14225:17:100","nodeType":"VariableDeclaration","scope":55072,"src":"14217:25:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":54978,"name":"address","nodeType":"ElementaryTypeName","src":"14217:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"id":54985,"initialValue":{"arguments":[],"expression":{"argumentTypes":[],"expression":{"arguments":[{"id":54981,"name":"systemConfigProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54947,"src":"14254:17:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_address","typeString":"address"}],"id":54980,"name":"IFetcher","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":53958,"src":"14245:8:100","typeDescriptions":{"typeIdentifier":"t_type$_t_contract$_IFetcher_$53958_$","typeString":"type(contract IFetcher)"}},"id":54982,"isConstant":false,"isLValue":false,"isPure":false,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"14245:27:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_contract$_IFetcher_$53958","typeString":"contract IFetcher"}},"id":54983,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"14273:17:100","memberName":"unsafeBlockSigner","nodeType":"MemberAccess","referencedDeclaration":53952,"src":"14245:45:100","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":54984,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"14245:47:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"VariableDeclarationStatement","src":"14217:75:100"},{"expression":{"arguments":[{"expression":{"expression":{"id":54989,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54943,"src":"14310:3:100","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$54911","typeString":"contract FetchChainInfoOutput"}},"id":54990,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"14314:17:100","memberName":"unsafeBlockSigner","nodeType":"MemberAccess","referencedDeclaration":54867,"src":"14310:21:100","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":54991,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"14332:8:100","memberName":"selector","nodeType":"MemberAccess","src":"14310:30:100","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},{"id":54992,"name":"unsafeBlockSigner","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54979,"src":"14342:17:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_bytes4","typeString":"bytes4"},{"typeIdentifier":"t_address","typeString":"address"}],"expression":{"id":54986,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54943,"src":"14302:3:100","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$54911","typeString":"contract FetchChainInfoOutput"}},"id":54988,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"14306:3:100","memberName":"set","nodeType":"MemberAccess","referencedDeclaration":54384,"src":"14302:7:100","typeDescriptions":{"typeIdentifier":"t_function_external_nonpayable$_t_bytes4_$_t_address_$returns$__$","typeString":"function (bytes4,address) external"}},"id":54993,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"14302:58:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":54994,"nodeType":"ExpressionStatement","src":"14302:58:100"},{"assignments":[54996],"declarations":[{"constant":false,"id":54996,"mutability":"mutable","name":"batchSubmitter","nameLocation":"14379:14:100","nodeType":"VariableDeclaration","scope":55072,"src":"14371:22:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":54995,"name":"address","nodeType":"ElementaryTypeName","src":"14371:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"id":55000,"initialValue":{"arguments":[{"id":54998,"name":"systemConfigProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54947,"src":"14415:17:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_address","typeString":"address"}],"id":54997,"name":"_getBatchSubmitter","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55994,"src":"14396:18:100","typeDescriptions":{"typeIdentifier":"t_function_internal_view$_t_address_$returns$_t_address_$","typeString":"function (address) view returns (address)"}},"id":54999,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"14396:37:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"VariableDeclarationStatement","src":"14371:62:100"},{"expression":{"arguments":[{"expression":{"expression":{"id":55004,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54943,"src":"14451:3:100","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$54911","typeString":"contract FetchChainInfoOutput"}},"id":55005,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"14455:14:100","memberName":"batchSubmitter","nodeType":"MemberAccess","referencedDeclaration":54885,"src":"14451:18:100","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":55006,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"14470:8:100","memberName":"selector","nodeType":"MemberAccess","src":"14451:27:100","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},{"id":55007,"name":"batchSubmitter","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54996,"src":"14480:14:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_bytes4","typeString":"bytes4"},{"typeIdentifier":"t_address","typeString":"address"}],"expression":{"id":55001,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54943,"src":"14443:3:100","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$54911","typeString":"contract FetchChainInfoOutput"}},"id":55003,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"14447:3:100","memberName":"set","nodeType":"MemberAccess","referencedDeclaration":54384,"src":"14443:7:100","typeDescriptions":{"typeIdentifier":"t_function_external_nonpayable$_t_bytes4_$_t_address_$returns$__$","typeString":"function (bytes4,address) external"}},"id":55008,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"14443:52:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":55009,"nodeType":"ExpressionStatement","src":"14443:52:100"},{"assignments":[55011],"declarations":[{"constant":false,"id":55011,"mutability":"mutable","name":"opChainProxyAdminImpl","nameLocation":"14514:21:100","nodeType":"VariableDeclaration","scope":55072,"src":"14506:29:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":55010,"name":"address","nodeType":"ElementaryTypeName","src":"14506:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"id":55015,"initialValue":{"arguments":[{"id":55013,"name":"systemConfigProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54947,"src":"14553:17:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_address","typeString":"address"}],"id":55012,"name":"_getProxyAdmin","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":56017,"src":"14538:14:100","typeDescriptions":{"typeIdentifier":"t_function_internal_nonpayable$_t_address_$returns$_t_address_$","typeString":"function (address) returns (address)"}},"id":55014,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"14538:33:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"VariableDeclarationStatement","src":"14506:65:100"},{"expression":{"arguments":[{"expression":{"expression":{"id":55019,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54943,"src":"14589:3:100","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$54911","typeString":"contract FetchChainInfoOutput"}},"id":55020,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"14593:21:100","memberName":"opChainProxyAdminImpl","nodeType":"MemberAccess","referencedDeclaration":54609,"src":"14589:25:100","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":55021,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"14615:8:100","memberName":"selector","nodeType":"MemberAccess","src":"14589:34:100","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},{"id":55022,"name":"opChainProxyAdminImpl","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55011,"src":"14625:21:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_bytes4","typeString":"bytes4"},{"typeIdentifier":"t_address","typeString":"address"}],"expression":{"id":55016,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54943,"src":"14581:3:100","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$54911","typeString":"contract FetchChainInfoOutput"}},"id":55018,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"14585:3:100","memberName":"set","nodeType":"MemberAccess","referencedDeclaration":54384,"src":"14581:7:100","typeDescriptions":{"typeIdentifier":"t_function_external_nonpayable$_t_bytes4_$_t_address_$returns$__$","typeString":"function (bytes4,address) external"}},"id":55023,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"14581:66:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":55024,"nodeType":"ExpressionStatement","src":"14581:66:100"},{"assignments":[55026],"declarations":[{"constant":false,"id":55026,"mutability":"mutable","name":"opChainProxyAdminOwner","nameLocation":"14666:22:100","nodeType":"VariableDeclaration","scope":55072,"src":"14658:30:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":55025,"name":"address","nodeType":"ElementaryTypeName","src":"14658:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"id":55032,"initialValue":{"arguments":[],"expression":{"argumentTypes":[],"expression":{"arguments":[{"id":55028,"name":"opChainProxyAdminImpl","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55011,"src":"14700:21:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_address","typeString":"address"}],"id":55027,"name":"IFetcher","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":53958,"src":"14691:8:100","typeDescriptions":{"typeIdentifier":"t_type$_t_contract$_IFetcher_$53958_$","typeString":"type(contract IFetcher)"}},"id":55029,"isConstant":false,"isLValue":false,"isPure":false,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"14691:31:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_contract$_IFetcher_$53958","typeString":"contract IFetcher"}},"id":55030,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"14723:5:100","memberName":"owner","nodeType":"MemberAccess","referencedDeclaration":53947,"src":"14691:37:100","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":55031,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"14691:39:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"VariableDeclarationStatement","src":"14658:72:100"},{"expression":{"arguments":[{"expression":{"expression":{"id":55036,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54943,"src":"14748:3:100","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$54911","typeString":"contract FetchChainInfoOutput"}},"id":55037,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"14752:22:100","memberName":"opChainProxyAdminOwner","nodeType":"MemberAccess","referencedDeclaration":54795,"src":"14748:26:100","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":55038,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"14775:8:100","memberName":"selector","nodeType":"MemberAccess","src":"14748:35:100","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},{"id":55039,"name":"opChainProxyAdminOwner","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55026,"src":"14785:22:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_bytes4","typeString":"bytes4"},{"typeIdentifier":"t_address","typeString":"address"}],"expression":{"id":55033,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54943,"src":"14740:3:100","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$54911","typeString":"contract FetchChainInfoOutput"}},"id":55035,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"14744:3:100","memberName":"set","nodeType":"MemberAccess","referencedDeclaration":54384,"src":"14740:7:100","typeDescriptions":{"typeIdentifier":"t_function_external_nonpayable$_t_bytes4_$_t_address_$returns$__$","typeString":"function (bytes4,address) external"}},"id":55040,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"14740:68:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":55041,"nodeType":"ExpressionStatement","src":"14740:68:100"},{"assignments":[55043],"declarations":[{"constant":false,"id":55043,"mutability":"mutable","name":"l1Erc721BridgeProxy","nameLocation":"14827:19:100","nodeType":"VariableDeclaration","scope":55072,"src":"14819:27:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":55042,"name":"address","nodeType":"ElementaryTypeName","src":"14819:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"id":55047,"initialValue":{"arguments":[{"id":55045,"name":"systemConfigProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54947,"src":"14873:17:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_address","typeString":"address"}],"id":55044,"name":"_getL1ERC721BridgeProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55718,"src":"14849:23:100","typeDescriptions":{"typeIdentifier":"t_function_internal_view$_t_address_$returns$_t_address_$","typeString":"function (address) view returns (address)"}},"id":55046,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"14849:42:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"VariableDeclarationStatement","src":"14819:72:100"},{"expression":{"arguments":[{"expression":{"expression":{"id":55051,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54943,"src":"14909:3:100","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$54911","typeString":"contract FetchChainInfoOutput"}},"id":55052,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"14913:19:100","memberName":"l1Erc721BridgeProxy","nodeType":"MemberAccess","referencedDeclaration":54501,"src":"14909:23:100","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":55053,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"14933:8:100","memberName":"selector","nodeType":"MemberAccess","src":"14909:32:100","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},{"id":55054,"name":"l1Erc721BridgeProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55043,"src":"14943:19:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_bytes4","typeString":"bytes4"},{"typeIdentifier":"t_address","typeString":"address"}],"expression":{"id":55048,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54943,"src":"14901:3:100","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$54911","typeString":"contract FetchChainInfoOutput"}},"id":55050,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"14905:3:100","memberName":"set","nodeType":"MemberAccess","referencedDeclaration":54384,"src":"14901:7:100","typeDescriptions":{"typeIdentifier":"t_function_external_nonpayable$_t_bytes4_$_t_address_$returns$__$","typeString":"function (bytes4,address) external"}},"id":55055,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"14901:62:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":55056,"nodeType":"ExpressionStatement","src":"14901:62:100"},{"assignments":[55058],"declarations":[{"constant":false,"id":55058,"mutability":"mutable","name":"optimismMintableErc20FactoryProxy","nameLocation":"14982:33:100","nodeType":"VariableDeclaration","scope":55072,"src":"14974:41:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":55057,"name":"address","nodeType":"ElementaryTypeName","src":"14974:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"id":55062,"initialValue":{"arguments":[{"id":55060,"name":"systemConfigProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54947,"src":"15056:17:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_address","typeString":"address"}],"id":55059,"name":"_getOptimismMintableERC20FactoryProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55746,"src":"15018:37:100","typeDescriptions":{"typeIdentifier":"t_function_internal_view$_t_address_$returns$_t_address_$","typeString":"function (address) view returns (address)"}},"id":55061,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"15018:56:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"VariableDeclarationStatement","src":"14974:100:100"},{"expression":{"arguments":[{"expression":{"expression":{"id":55066,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54943,"src":"15092:3:100","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$54911","typeString":"contract FetchChainInfoOutput"}},"id":55067,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"15096:33:100","memberName":"optimismMintableErc20FactoryProxy","nodeType":"MemberAccess","referencedDeclaration":54555,"src":"15092:37:100","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":55068,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"15130:8:100","memberName":"selector","nodeType":"MemberAccess","src":"15092:46:100","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},{"id":55069,"name":"optimismMintableErc20FactoryProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55058,"src":"15140:33:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_bytes4","typeString":"bytes4"},{"typeIdentifier":"t_address","typeString":"address"}],"expression":{"id":55063,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54943,"src":"15084:3:100","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$54911","typeString":"contract FetchChainInfoOutput"}},"id":55065,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"15088:3:100","memberName":"set","nodeType":"MemberAccess","referencedDeclaration":54384,"src":"15084:7:100","typeDescriptions":{"typeIdentifier":"t_function_external_nonpayable$_t_bytes4_$_t_address_$returns$__$","typeString":"function (bytes4,address) external"}},"id":55070,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"15084:90:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":55071,"nodeType":"ExpressionStatement","src":"15084:90:100"}]},"implemented":true,"kind":"function","modifiers":[],"name":"_processSystemConfig","nameLocation":"13854:20:100","parameters":{"id":54944,"nodeType":"ParameterList","parameters":[{"constant":false,"id":54940,"mutability":"mutable","name":"_fi","nameLocation":"13895:3:100","nodeType":"VariableDeclaration","scope":55073,"src":"13875:23:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoInput_$54041","typeString":"contract FetchChainInfoInput"},"typeName":{"id":54939,"nodeType":"UserDefinedTypeName","pathNode":{"id":54938,"name":"FetchChainInfoInput","nameLocations":["13875:19:100"],"nodeType":"IdentifierPath","referencedDeclaration":54041,"src":"13875:19:100"},"referencedDeclaration":54041,"src":"13875:19:100","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoInput_$54041","typeString":"contract FetchChainInfoInput"}},"visibility":"internal"},{"constant":false,"id":54943,"mutability":"mutable","name":"_fo","nameLocation":"13921:3:100","nodeType":"VariableDeclaration","scope":55073,"src":"13900:24:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$54911","typeString":"contract FetchChainInfoOutput"},"typeName":{"id":54942,"nodeType":"UserDefinedTypeName","pathNode":{"id":54941,"name":"FetchChainInfoOutput","nameLocations":["13900:20:100"],"nodeType":"IdentifierPath","referencedDeclaration":54911,"src":"13900:20:100"},"referencedDeclaration":54911,"src":"13900:20:100","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$54911","typeString":"contract FetchChainInfoOutput"}},"visibility":"internal"}],"src":"13874:51:100"},"returnParameters":{"id":54945,"nodeType":"ParameterList","parameters":[],"src":"13935:0:100"},"scope":56018,"stateMutability":"nonpayable","virtual":false,"visibility":"internal"},{"id":55190,"nodeType":"FunctionDefinition","src":"15187:1190:100","nodes":[],"body":{"id":55189,"nodeType":"Block","src":"15283:1094:100","nodes":[],"statements":[{"assignments":[55083],"declarations":[{"constant":false,"id":55083,"mutability":"mutable","name":"l1StandardBridgeProxy","nameLocation":"15301:21:100","nodeType":"VariableDeclaration","scope":55189,"src":"15293:29:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":55082,"name":"address","nodeType":"ElementaryTypeName","src":"15293:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"id":55087,"initialValue":{"arguments":[],"expression":{"argumentTypes":[],"expression":{"id":55084,"name":"_fi","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55076,"src":"15325:3:100","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoInput_$54041","typeString":"contract FetchChainInfoInput"}},"id":55085,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"15329:21:100","memberName":"l1StandardBridgeProxy","nodeType":"MemberAccess","referencedDeclaration":54040,"src":"15325:25:100","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":55086,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"15325:27:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"VariableDeclarationStatement","src":"15293:59:100"},{"expression":{"arguments":[{"expression":{"expression":{"id":55091,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55079,"src":"15370:3:100","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$54911","typeString":"contract FetchChainInfoOutput"}},"id":55092,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"15374:21:100","memberName":"l1StandardBridgeProxy","nodeType":"MemberAccess","referencedDeclaration":54519,"src":"15370:25:100","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":55093,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"15396:8:100","memberName":"selector","nodeType":"MemberAccess","src":"15370:34:100","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},{"id":55094,"name":"l1StandardBridgeProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55083,"src":"15406:21:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_bytes4","typeString":"bytes4"},{"typeIdentifier":"t_address","typeString":"address"}],"expression":{"id":55088,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55079,"src":"15362:3:100","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$54911","typeString":"contract FetchChainInfoOutput"}},"id":55090,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"15366:3:100","memberName":"set","nodeType":"MemberAccess","referencedDeclaration":54384,"src":"15362:7:100","typeDescriptions":{"typeIdentifier":"t_function_external_nonpayable$_t_bytes4_$_t_address_$returns$__$","typeString":"function (bytes4,address) external"}},"id":55095,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"15362:66:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":55096,"nodeType":"ExpressionStatement","src":"15362:66:100"},{"assignments":[55098],"declarations":[{"constant":false,"id":55098,"mutability":"mutable","name":"l1CrossDomainMessengerProxy","nameLocation":"15447:27:100","nodeType":"VariableDeclaration","scope":55189,"src":"15439:35:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":55097,"name":"address","nodeType":"ElementaryTypeName","src":"15439:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"id":55104,"initialValue":{"arguments":[],"expression":{"argumentTypes":[],"expression":{"arguments":[{"id":55100,"name":"l1StandardBridgeProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55083,"src":"15486:21:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_address","typeString":"address"}],"id":55099,"name":"IFetcher","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":53958,"src":"15477:8:100","typeDescriptions":{"typeIdentifier":"t_type$_t_contract$_IFetcher_$53958_$","typeString":"type(contract IFetcher)"}},"id":55101,"isConstant":false,"isLValue":false,"isPure":false,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"15477:31:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_contract$_IFetcher_$53958","typeString":"contract IFetcher"}},"id":55102,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"15509:9:100","memberName":"messenger","nodeType":"MemberAccess","referencedDeclaration":53853,"src":"15477:41:100","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":55103,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"15477:43:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"VariableDeclarationStatement","src":"15439:81:100"},{"expression":{"arguments":[{"expression":{"expression":{"id":55108,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55079,"src":"15538:3:100","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$54911","typeString":"contract FetchChainInfoOutput"}},"id":55109,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"15542:27:100","memberName":"l1CrossDomainMessengerProxy","nodeType":"MemberAccess","referencedDeclaration":54483,"src":"15538:31:100","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":55110,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"15570:8:100","memberName":"selector","nodeType":"MemberAccess","src":"15538:40:100","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},{"id":55111,"name":"l1CrossDomainMessengerProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55098,"src":"15580:27:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_bytes4","typeString":"bytes4"},{"typeIdentifier":"t_address","typeString":"address"}],"expression":{"id":55105,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55079,"src":"15530:3:100","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$54911","typeString":"contract FetchChainInfoOutput"}},"id":55107,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"15534:3:100","memberName":"set","nodeType":"MemberAccess","referencedDeclaration":54384,"src":"15530:7:100","typeDescriptions":{"typeIdentifier":"t_function_external_nonpayable$_t_bytes4_$_t_address_$returns$__$","typeString":"function (bytes4,address) external"}},"id":55112,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"15530:78:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":55113,"nodeType":"ExpressionStatement","src":"15530:78:100"},{"assignments":[55115],"declarations":[{"constant":false,"id":55115,"mutability":"mutable","name":"addressManagerImpl","nameLocation":"15627:18:100","nodeType":"VariableDeclaration","scope":55189,"src":"15619:26:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":55114,"name":"address","nodeType":"ElementaryTypeName","src":"15619:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"id":55119,"initialValue":{"arguments":[{"id":55117,"name":"l1CrossDomainMessengerProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55098,"src":"15667:27:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_address","typeString":"address"}],"id":55116,"name":"_getAddressManager","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55690,"src":"15648:18:100","typeDescriptions":{"typeIdentifier":"t_function_internal_view$_t_address_$returns$_t_address_$","typeString":"function (address) view returns (address)"}},"id":55118,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"15648:47:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"VariableDeclarationStatement","src":"15619:76:100"},{"expression":{"arguments":[{"expression":{"expression":{"id":55123,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55079,"src":"15713:3:100","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$54911","typeString":"contract FetchChainInfoOutput"}},"id":55124,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"15717:18:100","memberName":"addressManagerImpl","nodeType":"MemberAccess","referencedDeclaration":54457,"src":"15713:22:100","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":55125,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"15736:8:100","memberName":"selector","nodeType":"MemberAccess","src":"15713:31:100","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},{"id":55126,"name":"addressManagerImpl","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55115,"src":"15746:18:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_bytes4","typeString":"bytes4"},{"typeIdentifier":"t_address","typeString":"address"}],"expression":{"id":55120,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55079,"src":"15705:3:100","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$54911","typeString":"contract FetchChainInfoOutput"}},"id":55122,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"15709:3:100","memberName":"set","nodeType":"MemberAccess","referencedDeclaration":54384,"src":"15705:7:100","typeDescriptions":{"typeIdentifier":"t_function_external_nonpayable$_t_bytes4_$_t_address_$returns$__$","typeString":"function (bytes4,address) external"}},"id":55127,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"15705:60:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":55128,"nodeType":"ExpressionStatement","src":"15705:60:100"},{"assignments":[55130],"declarations":[{"constant":false,"id":55130,"mutability":"mutable","name":"optimismPortalProxy","nameLocation":"15784:19:100","nodeType":"VariableDeclaration","scope":55189,"src":"15776:27:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":55129,"name":"address","nodeType":"ElementaryTypeName","src":"15776:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"id":55134,"initialValue":{"arguments":[{"id":55132,"name":"l1CrossDomainMessengerProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55098,"src":"15830:27:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_address","typeString":"address"}],"id":55131,"name":"_getOptimismPortalProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55652,"src":"15806:23:100","typeDescriptions":{"typeIdentifier":"t_function_internal_view$_t_address_$returns$_t_address_$","typeString":"function (address) view returns (address)"}},"id":55133,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"15806:52:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"VariableDeclarationStatement","src":"15776:82:100"},{"expression":{"arguments":[{"expression":{"expression":{"id":55138,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55079,"src":"15876:3:100","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$54911","typeString":"contract FetchChainInfoOutput"}},"id":55139,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"15880:19:100","memberName":"optimismPortalProxy","nodeType":"MemberAccess","referencedDeclaration":54573,"src":"15876:23:100","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":55140,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"15900:8:100","memberName":"selector","nodeType":"MemberAccess","src":"15876:32:100","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},{"id":55141,"name":"optimismPortalProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55130,"src":"15910:19:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_bytes4","typeString":"bytes4"},{"typeIdentifier":"t_address","typeString":"address"}],"expression":{"id":55135,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55079,"src":"15868:3:100","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$54911","typeString":"contract FetchChainInfoOutput"}},"id":55137,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"15872:3:100","memberName":"set","nodeType":"MemberAccess","referencedDeclaration":54384,"src":"15868:7:100","typeDescriptions":{"typeIdentifier":"t_function_external_nonpayable$_t_bytes4_$_t_address_$returns$__$","typeString":"function (bytes4,address) external"}},"id":55142,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"15868:62:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":55143,"nodeType":"ExpressionStatement","src":"15868:62:100"},{"assignments":[55145],"declarations":[{"constant":false,"id":55145,"mutability":"mutable","name":"opChainGuardian","nameLocation":"15949:15:100","nodeType":"VariableDeclaration","scope":55189,"src":"15941:23:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":55144,"name":"address","nodeType":"ElementaryTypeName","src":"15941:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"id":55149,"initialValue":{"arguments":[{"id":55147,"name":"optimismPortalProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55130,"src":"15980:19:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_address","typeString":"address"}],"id":55146,"name":"_getGuardian","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55594,"src":"15967:12:100","typeDescriptions":{"typeIdentifier":"t_function_internal_view$_t_address_$returns$_t_address_$","typeString":"function (address) view returns (address)"}},"id":55148,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"15967:33:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"VariableDeclarationStatement","src":"15941:59:100"},{"expression":{"arguments":[{"expression":{"expression":{"id":55153,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55079,"src":"16018:3:100","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$54911","typeString":"contract FetchChainInfoOutput"}},"id":55154,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"16022:15:100","memberName":"opChainGuardian","nodeType":"MemberAccess","referencedDeclaration":54813,"src":"16018:19:100","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":55155,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"16038:8:100","memberName":"selector","nodeType":"MemberAccess","src":"16018:28:100","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},{"id":55156,"name":"opChainGuardian","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55145,"src":"16048:15:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_bytes4","typeString":"bytes4"},{"typeIdentifier":"t_address","typeString":"address"}],"expression":{"id":55150,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55079,"src":"16010:3:100","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$54911","typeString":"contract FetchChainInfoOutput"}},"id":55152,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"16014:3:100","memberName":"set","nodeType":"MemberAccess","referencedDeclaration":54384,"src":"16010:7:100","typeDescriptions":{"typeIdentifier":"t_function_external_nonpayable$_t_bytes4_$_t_address_$returns$__$","typeString":"function (bytes4,address) external"}},"id":55157,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"16010:54:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":55158,"nodeType":"ExpressionStatement","src":"16010:54:100"},{"assignments":[55160],"declarations":[{"constant":false,"id":55160,"mutability":"mutable","name":"ethLockboxProxy","nameLocation":"16083:15:100","nodeType":"VariableDeclaration","scope":55189,"src":"16075:23:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":55159,"name":"address","nodeType":"ElementaryTypeName","src":"16075:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"id":55164,"initialValue":{"arguments":[{"id":55162,"name":"optimismPortalProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55130,"src":"16121:19:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_address","typeString":"address"}],"id":55161,"name":"_getEthLockboxProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55922,"src":"16101:19:100","typeDescriptions":{"typeIdentifier":"t_function_internal_view$_t_address_$returns$_t_address_$","typeString":"function (address) view returns (address)"}},"id":55163,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"16101:40:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"VariableDeclarationStatement","src":"16075:66:100"},{"expression":{"arguments":[{"expression":{"expression":{"id":55168,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55079,"src":"16159:3:100","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$54911","typeString":"contract FetchChainInfoOutput"}},"id":55169,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"16163:15:100","memberName":"ethLockboxProxy","nodeType":"MemberAccess","referencedDeclaration":54465,"src":"16159:19:100","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":55170,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"16179:8:100","memberName":"selector","nodeType":"MemberAccess","src":"16159:28:100","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},{"id":55171,"name":"ethLockboxProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55160,"src":"16189:15:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_bytes4","typeString":"bytes4"},{"typeIdentifier":"t_address","typeString":"address"}],"expression":{"id":55165,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55079,"src":"16151:3:100","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$54911","typeString":"contract FetchChainInfoOutput"}},"id":55167,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"16155:3:100","memberName":"set","nodeType":"MemberAccess","referencedDeclaration":54384,"src":"16151:7:100","typeDescriptions":{"typeIdentifier":"t_function_external_nonpayable$_t_bytes4_$_t_address_$returns$__$","typeString":"function (bytes4,address) external"}},"id":55172,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"16151:54:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":55173,"nodeType":"ExpressionStatement","src":"16151:54:100"},{"assignments":[55175],"declarations":[{"constant":false,"id":55175,"mutability":"mutable","name":"superchainConfigProxy","nameLocation":"16224:21:100","nodeType":"VariableDeclaration","scope":55189,"src":"16216:29:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":55174,"name":"address","nodeType":"ElementaryTypeName","src":"16216:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"id":55179,"initialValue":{"arguments":[{"id":55177,"name":"optimismPortalProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55130,"src":"16274:19:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_address","typeString":"address"}],"id":55176,"name":"_getSuperchainConfigProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55802,"src":"16248:25:100","typeDescriptions":{"typeIdentifier":"t_function_internal_view$_t_address_$returns$_t_address_$","typeString":"function (address) view returns (address)"}},"id":55178,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"16248:46:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"VariableDeclarationStatement","src":"16216:78:100"},{"expression":{"arguments":[{"expression":{"expression":{"id":55183,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55079,"src":"16312:3:100","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$54911","typeString":"contract FetchChainInfoOutput"}},"id":55184,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"16316:21:100","memberName":"superchainConfigProxy","nodeType":"MemberAccess","referencedDeclaration":54627,"src":"16312:25:100","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":55185,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"16338:8:100","memberName":"selector","nodeType":"MemberAccess","src":"16312:34:100","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},{"id":55186,"name":"superchainConfigProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55175,"src":"16348:21:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_bytes4","typeString":"bytes4"},{"typeIdentifier":"t_address","typeString":"address"}],"expression":{"id":55180,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55079,"src":"16304:3:100","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$54911","typeString":"contract FetchChainInfoOutput"}},"id":55182,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"16308:3:100","memberName":"set","nodeType":"MemberAccess","referencedDeclaration":54384,"src":"16304:7:100","typeDescriptions":{"typeIdentifier":"t_function_external_nonpayable$_t_bytes4_$_t_address_$returns$__$","typeString":"function (bytes4,address) external"}},"id":55187,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"16304:66:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":55188,"nodeType":"ExpressionStatement","src":"16304:66:100"}]},"implemented":true,"kind":"function","modifiers":[],"name":"_processMessengerAndPortal","nameLocation":"15196:26:100","parameters":{"id":55080,"nodeType":"ParameterList","parameters":[{"constant":false,"id":55076,"mutability":"mutable","name":"_fi","nameLocation":"15243:3:100","nodeType":"VariableDeclaration","scope":55190,"src":"15223:23:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoInput_$54041","typeString":"contract FetchChainInfoInput"},"typeName":{"id":55075,"nodeType":"UserDefinedTypeName","pathNode":{"id":55074,"name":"FetchChainInfoInput","nameLocations":["15223:19:100"],"nodeType":"IdentifierPath","referencedDeclaration":54041,"src":"15223:19:100"},"referencedDeclaration":54041,"src":"15223:19:100","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoInput_$54041","typeString":"contract FetchChainInfoInput"}},"visibility":"internal"},{"constant":false,"id":55079,"mutability":"mutable","name":"_fo","nameLocation":"15269:3:100","nodeType":"VariableDeclaration","scope":55190,"src":"15248:24:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$54911","typeString":"contract FetchChainInfoOutput"},"typeName":{"id":55078,"nodeType":"UserDefinedTypeName","pathNode":{"id":55077,"name":"FetchChainInfoOutput","nameLocations":["15248:20:100"],"nodeType":"IdentifierPath","referencedDeclaration":54911,"src":"15248:20:100"},"referencedDeclaration":54911,"src":"15248:20:100","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$54911","typeString":"contract FetchChainInfoOutput"}},"visibility":"internal"}],"src":"15222:51:100"},"returnParameters":{"id":55081,"nodeType":"ParameterList","parameters":[],"src":"15283:0:100"},"scope":56018,"stateMutability":"nonpayable","virtual":false,"visibility":"internal"},{"id":55565,"nodeType":"FunctionDefinition","src":"16383:4033:100","nodes":[],"body":{"id":55564,"nodeType":"Block","src":"16447:3969:100","nodes":[],"statements":[{"assignments":[55197],"declarations":[{"constant":false,"id":55197,"mutability":"mutable","name":"systemConfigProxy","nameLocation":"16465:17:100","nodeType":"VariableDeclaration","scope":55564,"src":"16457:25:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":55196,"name":"address","nodeType":"ElementaryTypeName","src":"16457:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"id":55201,"initialValue":{"arguments":[],"expression":{"argumentTypes":[],"expression":{"id":55198,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55193,"src":"16485:3:100","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$54911","typeString":"contract FetchChainInfoOutput"}},"id":55199,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"16489:17:100","memberName":"systemConfigProxy","nodeType":"MemberAccess","referencedDeclaration":54591,"src":"16485:21:100","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":55200,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"16485:23:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"VariableDeclarationStatement","src":"16457:51:100"},{"assignments":[55203],"declarations":[{"constant":false,"id":55203,"mutability":"mutable","name":"optimismPortalProxy","nameLocation":"16526:19:100","nodeType":"VariableDeclaration","scope":55564,"src":"16518:27:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":55202,"name":"address","nodeType":"ElementaryTypeName","src":"16518:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"id":55207,"initialValue":{"arguments":[],"expression":{"argumentTypes":[],"expression":{"id":55204,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55193,"src":"16548:3:100","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$54911","typeString":"contract FetchChainInfoOutput"}},"id":55205,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"16552:19:100","memberName":"optimismPortalProxy","nodeType":"MemberAccess","referencedDeclaration":54573,"src":"16548:23:100","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":55206,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"16548:25:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"VariableDeclarationStatement","src":"16518:55:100"},{"clauses":[{"block":{"id":55226,"nodeType":"Block","src":"16667:75:100","statements":[{"expression":{"arguments":[{"expression":{"expression":{"id":55220,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55193,"src":"16689:3:100","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$54911","typeString":"contract FetchChainInfoOutput"}},"id":55221,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"16693:17:100","memberName":"respectedGameType","nodeType":"MemberAccess","referencedDeclaration":54910,"src":"16689:21:100","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_userDefinedValueType$_GameType_$70720_$","typeString":"function () view external returns (GameType)"}},"id":55222,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"16711:8:100","memberName":"selector","nodeType":"MemberAccess","src":"16689:30:100","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},{"id":55223,"name":"gameType_","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55215,"src":"16721:9:100","typeDescriptions":{"typeIdentifier":"t_userDefinedValueType$_GameType_$70720","typeString":"GameType"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_bytes4","typeString":"bytes4"},{"typeIdentifier":"t_userDefinedValueType$_GameType_$70720","typeString":"GameType"}],"expression":{"id":55217,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55193,"src":"16681:3:100","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$54911","typeString":"contract FetchChainInfoOutput"}},"id":55219,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"16685:3:100","memberName":"set","nodeType":"MemberAccess","referencedDeclaration":54439,"src":"16681:7:100","typeDescriptions":{"typeIdentifier":"t_function_external_nonpayable$_t_bytes4_$_t_userDefinedValueType$_GameType_$70720_$returns$__$","typeString":"function (bytes4,GameType) external"}},"id":55224,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"16681:50:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":55225,"nodeType":"ExpressionStatement","src":"16681:50:100"}]},"errorName":"","id":55227,"nodeType":"TryCatchClause","parameters":{"id":55216,"nodeType":"ParameterList","parameters":[{"constant":false,"id":55215,"mutability":"mutable","name":"gameType_","nameLocation":"16656:9:100","nodeType":"VariableDeclaration","scope":55227,"src":"16647:18:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_userDefinedValueType$_GameType_$70720","typeString":"GameType"},"typeName":{"id":55214,"nodeType":"UserDefinedTypeName","pathNode":{"id":55213,"name":"GameType","nameLocations":["16647:8:100"],"nodeType":"IdentifierPath","referencedDeclaration":70720,"src":"16647:8:100"},"referencedDeclaration":70720,"src":"16647:8:100","typeDescriptions":{"typeIdentifier":"t_userDefinedValueType$_GameType_$70720","typeString":"GameType"}},"visibility":"internal"}],"src":"16646:20:100"},"src":"16638:104:100"},{"block":{"id":55299,"nodeType":"Block","src":"16749:744:100","statements":[{"expression":{"arguments":[{"expression":{"expression":{"id":55231,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55193,"src":"16844:3:100","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$54911","typeString":"contract FetchChainInfoOutput"}},"id":55232,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"16848:17:100","memberName":"respectedGameType","nodeType":"MemberAccess","referencedDeclaration":54910,"src":"16844:21:100","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_userDefinedValueType$_GameType_$70720_$","typeString":"function () view external returns (GameType)"}},"id":55233,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"16866:8:100","memberName":"selector","nodeType":"MemberAccess","src":"16844:30:100","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},{"arguments":[{"expression":{"arguments":[{"id":55238,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"nodeType":"ElementaryTypeNameExpression","src":"16895:6:100","typeDescriptions":{"typeIdentifier":"t_type$_t_uint32_$","typeString":"type(uint32)"},"typeName":{"id":55237,"name":"uint32","nodeType":"ElementaryTypeName","src":"16895:6:100","typeDescriptions":{}}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_type$_t_uint32_$","typeString":"type(uint32)"}],"id":55236,"name":"type","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":-27,"src":"16890:4:100","typeDescriptions":{"typeIdentifier":"t_function_metatype_pure$__$returns$__$","typeString":"function () pure"}},"id":55239,"isConstant":false,"isLValue":false,"isPure":true,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"16890:12:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_magic_meta_type_t_uint32","typeString":"type(uint32)"}},"id":55240,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"memberLocation":"16903:3:100","memberName":"max","nodeType":"MemberAccess","src":"16890:16:100","typeDescriptions":{"typeIdentifier":"t_uint32","typeString":"uint32"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_uint32","typeString":"uint32"}],"expression":{"id":55234,"name":"GameType","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":70720,"src":"16876:8:100","typeDescriptions":{"typeIdentifier":"t_type$_t_userDefinedValueType$_GameType_$70720_$","typeString":"type(GameType)"}},"id":55235,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"memberLocation":"16885:4:100","memberName":"wrap","nodeType":"MemberAccess","src":"16876:13:100","typeDescriptions":{"typeIdentifier":"t_function_wrap_pure$_t_uint32_$returns$_t_userDefinedValueType$_GameType_$70720_$","typeString":"function (uint32) pure returns (GameType)"}},"id":55241,"isConstant":false,"isLValue":false,"isPure":true,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"16876:31:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_userDefinedValueType$_GameType_$70720","typeString":"GameType"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_bytes4","typeString":"bytes4"},{"typeIdentifier":"t_userDefinedValueType$_GameType_$70720","typeString":"GameType"}],"expression":{"id":55228,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55193,"src":"16836:3:100","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$54911","typeString":"contract FetchChainInfoOutput"}},"id":55230,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"16840:3:100","memberName":"set","nodeType":"MemberAccess","referencedDeclaration":54439,"src":"16836:7:100","typeDescriptions":{"typeIdentifier":"t_function_external_nonpayable$_t_bytes4_$_t_userDefinedValueType$_GameType_$70720_$returns$__$","typeString":"function (bytes4,GameType) external"}},"id":55242,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"16836:72:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":55243,"nodeType":"ExpressionStatement","src":"16836:72:100"},{"assignments":[55245],"declarations":[{"constant":false,"id":55245,"mutability":"mutable","name":"l2OutputOracleProxy","nameLocation":"16930:19:100","nodeType":"VariableDeclaration","scope":55299,"src":"16922:27:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":55244,"name":"address","nodeType":"ElementaryTypeName","src":"16922:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"id":55246,"nodeType":"VariableDeclarationStatement","src":"16922:27:100"},{"clauses":[{"block":{"id":55259,"nodeType":"Block","src":"17036:64:100","statements":[{"expression":{"id":55257,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftHandSide":{"id":55255,"name":"l2OutputOracleProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55245,"src":"17054:19:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"Assignment","operator":"=","rightHandSide":{"id":55256,"name":"l2Oracle_","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55253,"src":"17076:9:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"src":"17054:31:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"id":55258,"nodeType":"ExpressionStatement","src":"17054:31:100"}]},"errorName":"","id":55260,"nodeType":"TryCatchClause","parameters":{"id":55254,"nodeType":"ParameterList","parameters":[{"constant":false,"id":55253,"mutability":"mutable","name":"l2Oracle_","nameLocation":"17025:9:100","nodeType":"VariableDeclaration","scope":55260,"src":"17017:17:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":55252,"name":"address","nodeType":"ElementaryTypeName","src":"17017:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"17016:19:100"},"src":"17008:92:100"},{"block":{"id":55269,"nodeType":"Block","src":"17107:96:100","statements":[{"expression":{"id":55267,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftHandSide":{"id":55261,"name":"l2OutputOracleProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55245,"src":"17125:19:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"Assignment","operator":"=","rightHandSide":{"arguments":[],"expression":{"argumentTypes":[],"expression":{"arguments":[{"id":55263,"name":"optimismPortalProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55203,"src":"17156:19:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_address","typeString":"address"}],"id":55262,"name":"IFetcher","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":53958,"src":"17147:8:100","typeDescriptions":{"typeIdentifier":"t_type$_t_contract$_IFetcher_$53958_$","typeString":"type(contract IFetcher)"}},"id":55264,"isConstant":false,"isLValue":false,"isPure":false,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"17147:29:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_contract$_IFetcher_$53958","typeString":"contract IFetcher"}},"id":55265,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"17177:9:100","memberName":"L2_ORACLE","nodeType":"MemberAccess","referencedDeclaration":53902,"src":"17147:39:100","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":55266,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"17147:41:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"src":"17125:63:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"id":55268,"nodeType":"ExpressionStatement","src":"17125:63:100"}]},"errorName":"","id":55270,"nodeType":"TryCatchClause","src":"17101:102:100"}],"externalCall":{"arguments":[],"expression":{"argumentTypes":[],"expression":{"arguments":[{"id":55248,"name":"optimismPortalProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55203,"src":"16976:19:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_address","typeString":"address"}],"id":55247,"name":"IFetcher","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":53958,"src":"16967:8:100","typeDescriptions":{"typeIdentifier":"t_type$_t_contract$_IFetcher_$53958_$","typeString":"type(contract IFetcher)"}},"id":55249,"isConstant":false,"isLValue":false,"isPure":false,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"16967:29:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_contract$_IFetcher_$53958","typeString":"contract IFetcher"}},"id":55250,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"16997:8:100","memberName":"l2Oracle","nodeType":"MemberAccess","referencedDeclaration":53907,"src":"16967:38:100","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":55251,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"16967:40:100","tryCall":true,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"id":55271,"nodeType":"TryStatement","src":"16963:240:100"},{"expression":{"arguments":[{"expression":{"expression":{"id":55275,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55193,"src":"17224:3:100","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$54911","typeString":"contract FetchChainInfoOutput"}},"id":55276,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"17228:19:100","memberName":"l2OutputOracleProxy","nodeType":"MemberAccess","referencedDeclaration":54537,"src":"17224:23:100","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":55277,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"17248:8:100","memberName":"selector","nodeType":"MemberAccess","src":"17224:32:100","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},{"id":55278,"name":"l2OutputOracleProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55245,"src":"17258:19:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_bytes4","typeString":"bytes4"},{"typeIdentifier":"t_address","typeString":"address"}],"expression":{"id":55272,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55193,"src":"17216:3:100","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$54911","typeString":"contract FetchChainInfoOutput"}},"id":55274,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"17220:3:100","memberName":"set","nodeType":"MemberAccess","referencedDeclaration":54384,"src":"17216:7:100","typeDescriptions":{"typeIdentifier":"t_function_external_nonpayable$_t_bytes4_$_t_address_$returns$__$","typeString":"function (bytes4,address) external"}},"id":55279,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"17216:62:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":55280,"nodeType":"ExpressionStatement","src":"17216:62:100"},{"assignments":[55282],"declarations":[{"constant":false,"id":55282,"mutability":"mutable","name":"proposer","nameLocation":"17301:8:100","nodeType":"VariableDeclaration","scope":55299,"src":"17293:16:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":55281,"name":"address","nodeType":"ElementaryTypeName","src":"17293:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"id":55288,"initialValue":{"arguments":[],"expression":{"argumentTypes":[],"expression":{"arguments":[{"id":55284,"name":"l2OutputOracleProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55245,"src":"17321:19:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_address","typeString":"address"}],"id":55283,"name":"IFetcher","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":53958,"src":"17312:8:100","typeDescriptions":{"typeIdentifier":"t_type$_t_contract$_IFetcher_$53958_$","typeString":"type(contract IFetcher)"}},"id":55285,"isConstant":false,"isLValue":false,"isPure":false,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"17312:29:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_contract$_IFetcher_$53958","typeString":"contract IFetcher"}},"id":55286,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"17342:8:100","memberName":"PROPOSER","nodeType":"MemberAccess","referencedDeclaration":53932,"src":"17312:38:100","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":55287,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"17312:40:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"VariableDeclarationStatement","src":"17293:59:100"},{"expression":{"arguments":[{"expression":{"expression":{"id":55292,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55193,"src":"17374:3:100","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$54911","typeString":"contract FetchChainInfoOutput"}},"id":55293,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"17378:8:100","memberName":"proposer","nodeType":"MemberAccess","referencedDeclaration":54849,"src":"17374:12:100","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":55294,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"17387:8:100","memberName":"selector","nodeType":"MemberAccess","src":"17374:21:100","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},{"id":55295,"name":"proposer","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55282,"src":"17397:8:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_bytes4","typeString":"bytes4"},{"typeIdentifier":"t_address","typeString":"address"}],"expression":{"id":55289,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55193,"src":"17366:3:100","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$54911","typeString":"contract FetchChainInfoOutput"}},"id":55291,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"17370:3:100","memberName":"set","nodeType":"MemberAccess","referencedDeclaration":54384,"src":"17366:7:100","typeDescriptions":{"typeIdentifier":"t_function_external_nonpayable$_t_bytes4_$_t_address_$returns$__$","typeString":"function (bytes4,address) external"}},"id":55296,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"17366:40:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":55297,"nodeType":"ExpressionStatement","src":"17366:40:100"},{"functionReturnParameters":55195,"id":55298,"nodeType":"Return","src":"17476:7:100"}]},"errorName":"","id":55300,"nodeType":"TryCatchClause","src":"16743:750:100"}],"externalCall":{"arguments":[],"expression":{"argumentTypes":[],"expression":{"arguments":[{"id":55209,"name":"optimismPortalProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55203,"src":"16597:19:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_address","typeString":"address"}],"id":55208,"name":"IFetcher","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":53958,"src":"16588:8:100","typeDescriptions":{"typeIdentifier":"t_type$_t_contract$_IFetcher_$53958_$","typeString":"type(contract IFetcher)"}},"id":55210,"isConstant":false,"isLValue":false,"isPure":false,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"16588:29:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_contract$_IFetcher_$53958","typeString":"contract IFetcher"}},"id":55211,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"16618:17:100","memberName":"respectedGameType","nodeType":"MemberAccess","referencedDeclaration":53892,"src":"16588:47:100","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_userDefinedValueType$_GameType_$70720_$","typeString":"function () view external returns (GameType)"}},"id":55212,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"16588:49:100","tryCall":true,"typeDescriptions":{"typeIdentifier":"t_userDefinedValueType$_GameType_$70720","typeString":"GameType"}},"id":55301,"nodeType":"TryStatement","src":"16584:909:100"},{"assignments":[55303],"declarations":[{"constant":false,"id":55303,"mutability":"mutable","name":"disputeGameFactoryProxy","nameLocation":"17511:23:100","nodeType":"VariableDeclaration","scope":55564,"src":"17503:31:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":55302,"name":"address","nodeType":"ElementaryTypeName","src":"17503:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"id":55307,"initialValue":{"arguments":[{"id":55305,"name":"systemConfigProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55197,"src":"17565:17:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_address","typeString":"address"}],"id":55304,"name":"_getDisputeGameFactoryProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55774,"src":"17537:27:100","typeDescriptions":{"typeIdentifier":"t_function_internal_view$_t_address_$returns$_t_address_$","typeString":"function (address) view returns (address)"}},"id":55306,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"17537:46:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"VariableDeclarationStatement","src":"17503:80:100"},{"condition":{"commonType":{"typeIdentifier":"t_address","typeString":"address"},"id":55313,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftExpression":{"id":55308,"name":"disputeGameFactoryProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55303,"src":"17597:23:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"BinaryOperation","operator":"!=","rightExpression":{"arguments":[{"hexValue":"30","id":55311,"isConstant":false,"isLValue":false,"isPure":true,"kind":"number","lValueRequested":false,"nodeType":"Literal","src":"17632:1:100","typeDescriptions":{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"},"value":"0"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"}],"id":55310,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"nodeType":"ElementaryTypeNameExpression","src":"17624:7:100","typeDescriptions":{"typeIdentifier":"t_type$_t_address_$","typeString":"type(address)"},"typeName":{"id":55309,"name":"address","nodeType":"ElementaryTypeName","src":"17624:7:100","typeDescriptions":{}}},"id":55312,"isConstant":false,"isLValue":false,"isPure":true,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"17624:10:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"src":"17597:37:100","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},"falseBody":{"id":55562,"nodeType":"Block","src":"20027:383:100","statements":[{"assignments":[55529],"declarations":[{"constant":false,"id":55529,"mutability":"mutable","name":"l2OutputOracleProxy","nameLocation":"20133:19:100","nodeType":"VariableDeclaration","scope":55562,"src":"20125:27:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":55528,"name":"address","nodeType":"ElementaryTypeName","src":"20125:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"id":55535,"initialValue":{"arguments":[],"expression":{"argumentTypes":[],"expression":{"arguments":[{"id":55531,"name":"optimismPortalProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55203,"src":"20164:19:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_address","typeString":"address"}],"id":55530,"name":"IFetcher","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":53958,"src":"20155:8:100","typeDescriptions":{"typeIdentifier":"t_type$_t_contract$_IFetcher_$53958_$","typeString":"type(contract IFetcher)"}},"id":55532,"isConstant":false,"isLValue":false,"isPure":false,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"20155:29:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_contract$_IFetcher_$53958","typeString":"contract IFetcher"}},"id":55533,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"20185:9:100","memberName":"L2_ORACLE","nodeType":"MemberAccess","referencedDeclaration":53902,"src":"20155:39:100","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":55534,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"20155:41:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"VariableDeclarationStatement","src":"20125:71:100"},{"expression":{"arguments":[{"expression":{"expression":{"id":55539,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55193,"src":"20218:3:100","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$54911","typeString":"contract FetchChainInfoOutput"}},"id":55540,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"20222:19:100","memberName":"l2OutputOracleProxy","nodeType":"MemberAccess","referencedDeclaration":54537,"src":"20218:23:100","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":55541,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"20242:8:100","memberName":"selector","nodeType":"MemberAccess","src":"20218:32:100","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},{"id":55542,"name":"l2OutputOracleProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55529,"src":"20252:19:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_bytes4","typeString":"bytes4"},{"typeIdentifier":"t_address","typeString":"address"}],"expression":{"id":55536,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55193,"src":"20210:3:100","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$54911","typeString":"contract FetchChainInfoOutput"}},"id":55538,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"20214:3:100","memberName":"set","nodeType":"MemberAccess","referencedDeclaration":54384,"src":"20210:7:100","typeDescriptions":{"typeIdentifier":"t_function_external_nonpayable$_t_bytes4_$_t_address_$returns$__$","typeString":"function (bytes4,address) external"}},"id":55543,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"20210:62:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":55544,"nodeType":"ExpressionStatement","src":"20210:62:100"},{"assignments":[55546],"declarations":[{"constant":false,"id":55546,"mutability":"mutable","name":"proposer","nameLocation":"20294:8:100","nodeType":"VariableDeclaration","scope":55562,"src":"20286:16:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":55545,"name":"address","nodeType":"ElementaryTypeName","src":"20286:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"id":55552,"initialValue":{"arguments":[],"expression":{"argumentTypes":[],"expression":{"arguments":[{"id":55548,"name":"l2OutputOracleProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55529,"src":"20314:19:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_address","typeString":"address"}],"id":55547,"name":"IFetcher","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":53958,"src":"20305:8:100","typeDescriptions":{"typeIdentifier":"t_type$_t_contract$_IFetcher_$53958_$","typeString":"type(contract IFetcher)"}},"id":55549,"isConstant":false,"isLValue":false,"isPure":false,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"20305:29:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_contract$_IFetcher_$53958","typeString":"contract IFetcher"}},"id":55550,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"20335:8:100","memberName":"PROPOSER","nodeType":"MemberAccess","referencedDeclaration":53932,"src":"20305:38:100","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":55551,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"20305:40:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"VariableDeclarationStatement","src":"20286:59:100"},{"expression":{"arguments":[{"expression":{"expression":{"id":55556,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55193,"src":"20367:3:100","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$54911","typeString":"contract FetchChainInfoOutput"}},"id":55557,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"20371:8:100","memberName":"proposer","nodeType":"MemberAccess","referencedDeclaration":54849,"src":"20367:12:100","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":55558,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"20380:8:100","memberName":"selector","nodeType":"MemberAccess","src":"20367:21:100","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},{"id":55559,"name":"proposer","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55546,"src":"20390:8:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_bytes4","typeString":"bytes4"},{"typeIdentifier":"t_address","typeString":"address"}],"expression":{"id":55553,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55193,"src":"20359:3:100","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$54911","typeString":"contract FetchChainInfoOutput"}},"id":55555,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"20363:3:100","memberName":"set","nodeType":"MemberAccess","referencedDeclaration":54384,"src":"20359:7:100","typeDescriptions":{"typeIdentifier":"t_function_external_nonpayable$_t_bytes4_$_t_address_$returns$__$","typeString":"function (bytes4,address) external"}},"id":55560,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"20359:40:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":55561,"nodeType":"ExpressionStatement","src":"20359:40:100"}]},"id":55563,"nodeType":"IfStatement","src":"17593:2817:100","trueBody":{"id":55527,"nodeType":"Block","src":"17636:2385:100","statements":[{"expression":{"arguments":[{"expression":{"expression":{"id":55317,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55193,"src":"17658:3:100","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$54911","typeString":"contract FetchChainInfoOutput"}},"id":55318,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"17662:23:100","memberName":"disputeGameFactoryProxy","nodeType":"MemberAccess","referencedDeclaration":54669,"src":"17658:27:100","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":55319,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"17686:8:100","memberName":"selector","nodeType":"MemberAccess","src":"17658:36:100","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},{"id":55320,"name":"disputeGameFactoryProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55303,"src":"17696:23:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_bytes4","typeString":"bytes4"},{"typeIdentifier":"t_address","typeString":"address"}],"expression":{"id":55314,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55193,"src":"17650:3:100","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$54911","typeString":"contract FetchChainInfoOutput"}},"id":55316,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"17654:3:100","memberName":"set","nodeType":"MemberAccess","referencedDeclaration":54384,"src":"17650:7:100","typeDescriptions":{"typeIdentifier":"t_function_external_nonpayable$_t_bytes4_$_t_address_$returns$__$","typeString":"function (bytes4,address) external"}},"id":55321,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"17650:70:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":55322,"nodeType":"ExpressionStatement","src":"17650:70:100"},{"assignments":[55324],"declarations":[{"constant":false,"id":55324,"mutability":"mutable","name":"permissionedDisputeGameImpl","nameLocation":"17743:27:100","nodeType":"VariableDeclaration","scope":55527,"src":"17735:35:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":55323,"name":"address","nodeType":"ElementaryTypeName","src":"17735:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"id":55328,"initialValue":{"arguments":[{"id":55326,"name":"disputeGameFactoryProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55303,"src":"17801:23:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_address","typeString":"address"}],"id":55325,"name":"_getPermissionedDisputeGame","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55894,"src":"17773:27:100","typeDescriptions":{"typeIdentifier":"t_function_internal_view$_t_address_$returns$_t_address_$","typeString":"function (address) view returns (address)"}},"id":55327,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"17773:52:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"VariableDeclarationStatement","src":"17735:90:100"},{"condition":{"commonType":{"typeIdentifier":"t_address","typeString":"address"},"id":55334,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftExpression":{"id":55329,"name":"permissionedDisputeGameImpl","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55324,"src":"17843:27:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"BinaryOperation","operator":"!=","rightExpression":{"arguments":[{"hexValue":"30","id":55332,"isConstant":false,"isLValue":false,"isPure":true,"kind":"number","lValueRequested":false,"nodeType":"Literal","src":"17882:1:100","typeDescriptions":{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"},"value":"0"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"}],"id":55331,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"nodeType":"ElementaryTypeNameExpression","src":"17874:7:100","typeDescriptions":{"typeIdentifier":"t_type$_t_address_$","typeString":"type(address)"},"typeName":{"id":55330,"name":"address","nodeType":"ElementaryTypeName","src":"17874:7:100","typeDescriptions":{}}},"id":55333,"isConstant":false,"isLValue":false,"isPure":true,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"17874:10:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"src":"17843:41:100","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},"id":55454,"nodeType":"IfStatement","src":"17839:1278:100","trueBody":{"id":55453,"nodeType":"Block","src":"17886:1231:100","statements":[{"expression":{"arguments":[{"expression":{"expression":{"id":55338,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55193,"src":"17967:3:100","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$54911","typeString":"contract FetchChainInfoOutput"}},"id":55339,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"17971:12:100","memberName":"permissioned","nodeType":"MemberAccess","referencedDeclaration":54893,"src":"17967:16:100","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_bool_$","typeString":"function () view external returns (bool)"}},"id":55340,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"17984:8:100","memberName":"selector","nodeType":"MemberAccess","src":"17967:25:100","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},{"hexValue":"74727565","id":55341,"isConstant":false,"isLValue":false,"isPure":true,"kind":"bool","lValueRequested":false,"nodeType":"Literal","src":"17994:4:100","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"},"value":"true"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_bytes4","typeString":"bytes4"},{"typeIdentifier":"t_bool","typeString":"bool"}],"expression":{"id":55335,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55193,"src":"17959:3:100","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$54911","typeString":"contract FetchChainInfoOutput"}},"id":55337,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"17963:3:100","memberName":"set","nodeType":"MemberAccess","referencedDeclaration":54416,"src":"17959:7:100","typeDescriptions":{"typeIdentifier":"t_function_external_nonpayable$_t_bytes4_$_t_bool_$returns$__$","typeString":"function (bytes4,bool) external"}},"id":55342,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"17959:40:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":55343,"nodeType":"ExpressionStatement","src":"17959:40:100"},{"expression":{"arguments":[{"expression":{"expression":{"id":55347,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55193,"src":"18025:3:100","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$54911","typeString":"contract FetchChainInfoOutput"}},"id":55348,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"18029:27:100","memberName":"permissionedDisputeGameImpl","nodeType":"MemberAccess","referencedDeclaration":54741,"src":"18025:31:100","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":55349,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"18057:8:100","memberName":"selector","nodeType":"MemberAccess","src":"18025:40:100","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},{"id":55350,"name":"permissionedDisputeGameImpl","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55324,"src":"18067:27:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_bytes4","typeString":"bytes4"},{"typeIdentifier":"t_address","typeString":"address"}],"expression":{"id":55344,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55193,"src":"18017:3:100","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$54911","typeString":"contract FetchChainInfoOutput"}},"id":55346,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"18021:3:100","memberName":"set","nodeType":"MemberAccess","referencedDeclaration":54384,"src":"18017:7:100","typeDescriptions":{"typeIdentifier":"t_function_external_nonpayable$_t_bytes4_$_t_address_$returns$__$","typeString":"function (bytes4,address) external"}},"id":55351,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"18017:78:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":55352,"nodeType":"ExpressionStatement","src":"18017:78:100"},{"assignments":[55354],"declarations":[{"constant":false,"id":55354,"mutability":"mutable","name":"challenger","nameLocation":"18122:10:100","nodeType":"VariableDeclaration","scope":55453,"src":"18114:18:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":55353,"name":"address","nodeType":"ElementaryTypeName","src":"18114:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"id":55360,"initialValue":{"arguments":[],"expression":{"argumentTypes":[],"expression":{"arguments":[{"id":55356,"name":"permissionedDisputeGameImpl","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55324,"src":"18144:27:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_address","typeString":"address"}],"id":55355,"name":"IFetcher","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":53958,"src":"18135:8:100","typeDescriptions":{"typeIdentifier":"t_type$_t_contract$_IFetcher_$53958_$","typeString":"type(contract IFetcher)"}},"id":55357,"isConstant":false,"isLValue":false,"isPure":false,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"18135:37:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_contract$_IFetcher_$53958","typeString":"contract IFetcher"}},"id":55358,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"18173:10:100","memberName":"challenger","nodeType":"MemberAccess","referencedDeclaration":53922,"src":"18135:48:100","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":55359,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"18135:50:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"VariableDeclarationStatement","src":"18114:71:100"},{"expression":{"arguments":[{"expression":{"expression":{"id":55364,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55193,"src":"18211:3:100","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$54911","typeString":"contract FetchChainInfoOutput"}},"id":55365,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"18215:10:100","memberName":"challenger","nodeType":"MemberAccess","referencedDeclaration":54831,"src":"18211:14:100","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":55366,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"18226:8:100","memberName":"selector","nodeType":"MemberAccess","src":"18211:23:100","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},{"id":55367,"name":"challenger","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55354,"src":"18236:10:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_bytes4","typeString":"bytes4"},{"typeIdentifier":"t_address","typeString":"address"}],"expression":{"id":55361,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55193,"src":"18203:3:100","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$54911","typeString":"contract FetchChainInfoOutput"}},"id":55363,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"18207:3:100","memberName":"set","nodeType":"MemberAccess","referencedDeclaration":54384,"src":"18203:7:100","typeDescriptions":{"typeIdentifier":"t_function_external_nonpayable$_t_bytes4_$_t_address_$returns$__$","typeString":"function (bytes4,address) external"}},"id":55368,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"18203:44:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":55369,"nodeType":"ExpressionStatement","src":"18203:44:100"},{"assignments":[55371],"declarations":[{"constant":false,"id":55371,"mutability":"mutable","name":"anchorStateRegistryProxy","nameLocation":"18274:24:100","nodeType":"VariableDeclaration","scope":55453,"src":"18266:32:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":55370,"name":"address","nodeType":"ElementaryTypeName","src":"18266:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"id":55377,"initialValue":{"arguments":[],"expression":{"argumentTypes":[],"expression":{"arguments":[{"id":55373,"name":"permissionedDisputeGameImpl","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55324,"src":"18310:27:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_address","typeString":"address"}],"id":55372,"name":"IFetcher","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":53958,"src":"18301:8:100","typeDescriptions":{"typeIdentifier":"t_type$_t_contract$_IFetcher_$53958_$","typeString":"type(contract IFetcher)"}},"id":55374,"isConstant":false,"isLValue":false,"isPure":false,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"18301:37:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_contract$_IFetcher_$53958","typeString":"contract IFetcher"}},"id":55375,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"18339:19:100","memberName":"anchorStateRegistry","nodeType":"MemberAccess","referencedDeclaration":53897,"src":"18301:57:100","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":55376,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"18301:59:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"VariableDeclarationStatement","src":"18266:94:100"},{"expression":{"arguments":[{"expression":{"expression":{"id":55381,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55193,"src":"18386:3:100","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$54911","typeString":"contract FetchChainInfoOutput"}},"id":55382,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"18390:24:100","memberName":"anchorStateRegistryProxy","nodeType":"MemberAccess","referencedDeclaration":54645,"src":"18386:28:100","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":55383,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"18415:8:100","memberName":"selector","nodeType":"MemberAccess","src":"18386:37:100","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},{"id":55384,"name":"anchorStateRegistryProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55371,"src":"18425:24:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_bytes4","typeString":"bytes4"},{"typeIdentifier":"t_address","typeString":"address"}],"expression":{"id":55378,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55193,"src":"18378:3:100","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$54911","typeString":"contract FetchChainInfoOutput"}},"id":55380,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"18382:3:100","memberName":"set","nodeType":"MemberAccess","referencedDeclaration":54384,"src":"18378:7:100","typeDescriptions":{"typeIdentifier":"t_function_external_nonpayable$_t_bytes4_$_t_address_$returns$__$","typeString":"function (bytes4,address) external"}},"id":55385,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"18378:72:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":55386,"nodeType":"ExpressionStatement","src":"18378:72:100"},{"assignments":[55388],"declarations":[{"constant":false,"id":55388,"mutability":"mutable","name":"proposer","nameLocation":"18477:8:100","nodeType":"VariableDeclaration","scope":55453,"src":"18469:16:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":55387,"name":"address","nodeType":"ElementaryTypeName","src":"18469:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"id":55394,"initialValue":{"arguments":[],"expression":{"argumentTypes":[],"expression":{"arguments":[{"id":55390,"name":"permissionedDisputeGameImpl","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55324,"src":"18497:27:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_address","typeString":"address"}],"id":55389,"name":"IFetcher","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":53958,"src":"18488:8:100","typeDescriptions":{"typeIdentifier":"t_type$_t_contract$_IFetcher_$53958_$","typeString":"type(contract IFetcher)"}},"id":55391,"isConstant":false,"isLValue":false,"isPure":false,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"18488:37:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_contract$_IFetcher_$53958","typeString":"contract IFetcher"}},"id":55392,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"18526:8:100","memberName":"proposer","nodeType":"MemberAccess","referencedDeclaration":53927,"src":"18488:46:100","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":55393,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"18488:48:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"VariableDeclarationStatement","src":"18469:67:100"},{"expression":{"arguments":[{"expression":{"expression":{"id":55398,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55193,"src":"18562:3:100","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$54911","typeString":"contract FetchChainInfoOutput"}},"id":55399,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"18566:8:100","memberName":"proposer","nodeType":"MemberAccess","referencedDeclaration":54849,"src":"18562:12:100","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":55400,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"18575:8:100","memberName":"selector","nodeType":"MemberAccess","src":"18562:21:100","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},{"id":55401,"name":"proposer","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55388,"src":"18585:8:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_bytes4","typeString":"bytes4"},{"typeIdentifier":"t_address","typeString":"address"}],"expression":{"id":55395,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55193,"src":"18554:3:100","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$54911","typeString":"contract FetchChainInfoOutput"}},"id":55397,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"18558:3:100","memberName":"set","nodeType":"MemberAccess","referencedDeclaration":54384,"src":"18554:7:100","typeDescriptions":{"typeIdentifier":"t_function_external_nonpayable$_t_bytes4_$_t_address_$returns$__$","typeString":"function (bytes4,address) external"}},"id":55402,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"18554:40:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":55403,"nodeType":"ExpressionStatement","src":"18554:40:100"},{"assignments":[55405],"declarations":[{"constant":false,"id":55405,"mutability":"mutable","name":"delayedWethPermissionedGameProxy","nameLocation":"18621:32:100","nodeType":"VariableDeclaration","scope":55453,"src":"18613:40:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":55404,"name":"address","nodeType":"ElementaryTypeName","src":"18613:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"id":55409,"initialValue":{"arguments":[{"id":55407,"name":"permissionedDisputeGameImpl","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55324,"src":"18677:27:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_address","typeString":"address"}],"id":55406,"name":"_getDelayedWETHProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55967,"src":"18656:20:100","typeDescriptions":{"typeIdentifier":"t_function_internal_view$_t_address_$returns$_t_address_$","typeString":"function (address) view returns (address)"}},"id":55408,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"18656:49:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"VariableDeclarationStatement","src":"18613:92:100"},{"expression":{"arguments":[{"expression":{"expression":{"id":55413,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55193,"src":"18731:3:100","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$54911","typeString":"contract FetchChainInfoOutput"}},"id":55414,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"18735:32:100","memberName":"delayedWethPermissionedGameProxy","nodeType":"MemberAccess","referencedDeclaration":54653,"src":"18731:36:100","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":55415,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"18768:8:100","memberName":"selector","nodeType":"MemberAccess","src":"18731:45:100","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},{"id":55416,"name":"delayedWethPermissionedGameProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55405,"src":"18778:32:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_bytes4","typeString":"bytes4"},{"typeIdentifier":"t_address","typeString":"address"}],"expression":{"id":55410,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55193,"src":"18723:3:100","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$54911","typeString":"contract FetchChainInfoOutput"}},"id":55412,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"18727:3:100","memberName":"set","nodeType":"MemberAccess","referencedDeclaration":54384,"src":"18723:7:100","typeDescriptions":{"typeIdentifier":"t_function_external_nonpayable$_t_bytes4_$_t_address_$returns$__$","typeString":"function (bytes4,address) external"}},"id":55417,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"18723:88:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":55418,"nodeType":"ExpressionStatement","src":"18723:88:100"},{"assignments":[55420],"declarations":[{"constant":false,"id":55420,"mutability":"mutable","name":"mipsImpl","nameLocation":"18838:8:100","nodeType":"VariableDeclaration","scope":55453,"src":"18830:16:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":55419,"name":"address","nodeType":"ElementaryTypeName","src":"18830:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"id":55426,"initialValue":{"arguments":[],"expression":{"argumentTypes":[],"expression":{"arguments":[{"id":55422,"name":"permissionedDisputeGameImpl","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55324,"src":"18858:27:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_address","typeString":"address"}],"id":55421,"name":"IFetcher","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":53958,"src":"18849:8:100","typeDescriptions":{"typeIdentifier":"t_type$_t_contract$_IFetcher_$53958_$","typeString":"type(contract IFetcher)"}},"id":55423,"isConstant":false,"isLValue":false,"isPure":false,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"18849:37:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_contract$_IFetcher_$53958","typeString":"contract IFetcher"}},"id":55424,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"18887:2:100","memberName":"vm","nodeType":"MemberAccess","referencedDeclaration":53912,"src":"18849:40:100","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":55425,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"18849:42:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"VariableDeclarationStatement","src":"18830:61:100"},{"expression":{"arguments":[{"expression":{"expression":{"id":55430,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55193,"src":"18917:3:100","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$54911","typeString":"contract FetchChainInfoOutput"}},"id":55431,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"18921:8:100","memberName":"mipsImpl","nodeType":"MemberAccess","referencedDeclaration":54723,"src":"18917:12:100","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":55432,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"18930:8:100","memberName":"selector","nodeType":"MemberAccess","src":"18917:21:100","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},{"id":55433,"name":"mipsImpl","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55420,"src":"18940:8:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_bytes4","typeString":"bytes4"},{"typeIdentifier":"t_address","typeString":"address"}],"expression":{"id":55427,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55193,"src":"18909:3:100","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$54911","typeString":"contract FetchChainInfoOutput"}},"id":55429,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"18913:3:100","memberName":"set","nodeType":"MemberAccess","referencedDeclaration":54384,"src":"18909:7:100","typeDescriptions":{"typeIdentifier":"t_function_external_nonpayable$_t_bytes4_$_t_address_$returns$__$","typeString":"function (bytes4,address) external"}},"id":55434,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"18909:40:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":55435,"nodeType":"ExpressionStatement","src":"18909:40:100"},{"assignments":[55437],"declarations":[{"constant":false,"id":55437,"mutability":"mutable","name":"preimageOracleImpl","nameLocation":"18976:18:100","nodeType":"VariableDeclaration","scope":55453,"src":"18968:26:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":55436,"name":"address","nodeType":"ElementaryTypeName","src":"18968:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"id":55443,"initialValue":{"arguments":[],"expression":{"argumentTypes":[],"expression":{"arguments":[{"id":55439,"name":"mipsImpl","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55420,"src":"19006:8:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_address","typeString":"address"}],"id":55438,"name":"IFetcher","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":53958,"src":"18997:8:100","typeDescriptions":{"typeIdentifier":"t_type$_t_contract$_IFetcher_$53958_$","typeString":"type(contract IFetcher)"}},"id":55440,"isConstant":false,"isLValue":false,"isPure":false,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"18997:18:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_contract$_IFetcher_$53958","typeString":"contract IFetcher"}},"id":55441,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"19016:6:100","memberName":"oracle","nodeType":"MemberAccess","referencedDeclaration":53917,"src":"18997:25:100","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":55442,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"18997:27:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"VariableDeclarationStatement","src":"18968:56:100"},{"expression":{"arguments":[{"expression":{"expression":{"id":55447,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55193,"src":"19050:3:100","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$54911","typeString":"contract FetchChainInfoOutput"}},"id":55448,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"19054:18:100","memberName":"preimageOracleImpl","nodeType":"MemberAccess","referencedDeclaration":54759,"src":"19050:22:100","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":55449,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"19073:8:100","memberName":"selector","nodeType":"MemberAccess","src":"19050:31:100","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},{"id":55450,"name":"preimageOracleImpl","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55437,"src":"19083:18:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_bytes4","typeString":"bytes4"},{"typeIdentifier":"t_address","typeString":"address"}],"expression":{"id":55444,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55193,"src":"19042:3:100","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$54911","typeString":"contract FetchChainInfoOutput"}},"id":55446,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"19046:3:100","memberName":"set","nodeType":"MemberAccess","referencedDeclaration":54384,"src":"19042:7:100","typeDescriptions":{"typeIdentifier":"t_function_external_nonpayable$_t_bytes4_$_t_address_$returns$__$","typeString":"function (bytes4,address) external"}},"id":55451,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"19042:60:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":55452,"nodeType":"ExpressionStatement","src":"19042:60:100"}]}},{"assignments":[55456],"declarations":[{"constant":false,"id":55456,"mutability":"mutable","name":"faultDisputeGameImpl","nameLocation":"19139:20:100","nodeType":"VariableDeclaration","scope":55527,"src":"19131:28:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":55455,"name":"address","nodeType":"ElementaryTypeName","src":"19131:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"id":55460,"initialValue":{"arguments":[{"id":55458,"name":"disputeGameFactoryProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55303,"src":"19183:23:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_address","typeString":"address"}],"id":55457,"name":"_getFaultDisputeGame","nodeType":"Identifier","overloadedDeclarations":[55832,55864],"referencedDeclaration":55832,"src":"19162:20:100","typeDescriptions":{"typeIdentifier":"t_function_internal_view$_t_address_$returns$_t_address_$","typeString":"function (address) view returns (address)"}},"id":55459,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"19162:45:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"VariableDeclarationStatement","src":"19131:76:100"},{"condition":{"commonType":{"typeIdentifier":"t_address","typeString":"address"},"id":55466,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftExpression":{"id":55461,"name":"faultDisputeGameImpl","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55456,"src":"19225:20:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"BinaryOperation","operator":"!=","rightExpression":{"arguments":[{"hexValue":"30","id":55464,"isConstant":false,"isLValue":false,"isPure":true,"kind":"number","lValueRequested":false,"nodeType":"Literal","src":"19257:1:100","typeDescriptions":{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"},"value":"0"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"}],"id":55463,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"nodeType":"ElementaryTypeNameExpression","src":"19249:7:100","typeDescriptions":{"typeIdentifier":"t_type$_t_address_$","typeString":"type(address)"},"typeName":{"id":55462,"name":"address","nodeType":"ElementaryTypeName","src":"19249:7:100","typeDescriptions":{}}},"id":55465,"isConstant":false,"isLValue":false,"isPure":true,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"19249:10:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"src":"19225:34:100","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},"id":55501,"nodeType":"IfStatement","src":"19221:470:100","trueBody":{"id":55500,"nodeType":"Block","src":"19261:430:100","statements":[{"expression":{"arguments":[{"expression":{"expression":{"id":55470,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55193,"src":"19344:3:100","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$54911","typeString":"contract FetchChainInfoOutput"}},"id":55471,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"19348:20:100","memberName":"faultDisputeGameImpl","nodeType":"MemberAccess","referencedDeclaration":54687,"src":"19344:24:100","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":55472,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"19369:8:100","memberName":"selector","nodeType":"MemberAccess","src":"19344:33:100","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},{"id":55473,"name":"faultDisputeGameImpl","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55456,"src":"19379:20:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_bytes4","typeString":"bytes4"},{"typeIdentifier":"t_address","typeString":"address"}],"expression":{"id":55467,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55193,"src":"19336:3:100","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$54911","typeString":"contract FetchChainInfoOutput"}},"id":55469,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"19340:3:100","memberName":"set","nodeType":"MemberAccess","referencedDeclaration":54384,"src":"19336:7:100","typeDescriptions":{"typeIdentifier":"t_function_external_nonpayable$_t_bytes4_$_t_address_$returns$__$","typeString":"function (bytes4,address) external"}},"id":55474,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"19336:64:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":55475,"nodeType":"ExpressionStatement","src":"19336:64:100"},{"expression":{"arguments":[{"expression":{"expression":{"id":55479,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55193,"src":"19426:3:100","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$54911","typeString":"contract FetchChainInfoOutput"}},"id":55480,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"19430:14:100","memberName":"permissionless","nodeType":"MemberAccess","referencedDeclaration":54901,"src":"19426:18:100","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_bool_$","typeString":"function () view external returns (bool)"}},"id":55481,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"19445:8:100","memberName":"selector","nodeType":"MemberAccess","src":"19426:27:100","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},{"hexValue":"74727565","id":55482,"isConstant":false,"isLValue":false,"isPure":true,"kind":"bool","lValueRequested":false,"nodeType":"Literal","src":"19455:4:100","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"},"value":"true"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_bytes4","typeString":"bytes4"},{"typeIdentifier":"t_bool","typeString":"bool"}],"expression":{"id":55476,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55193,"src":"19418:3:100","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$54911","typeString":"contract FetchChainInfoOutput"}},"id":55478,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"19422:3:100","memberName":"set","nodeType":"MemberAccess","referencedDeclaration":54416,"src":"19418:7:100","typeDescriptions":{"typeIdentifier":"t_function_external_nonpayable$_t_bytes4_$_t_bool_$returns$__$","typeString":"function (bytes4,bool) external"}},"id":55483,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"19418:42:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":55484,"nodeType":"ExpressionStatement","src":"19418:42:100"},{"assignments":[55486],"declarations":[{"constant":false,"id":55486,"mutability":"mutable","name":"delayedWethPermissionlessGameProxy","nameLocation":"19487:34:100","nodeType":"VariableDeclaration","scope":55500,"src":"19479:42:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":55485,"name":"address","nodeType":"ElementaryTypeName","src":"19479:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"id":55490,"initialValue":{"arguments":[{"id":55488,"name":"faultDisputeGameImpl","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55456,"src":"19545:20:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_address","typeString":"address"}],"id":55487,"name":"_getDelayedWETHProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55967,"src":"19524:20:100","typeDescriptions":{"typeIdentifier":"t_function_internal_view$_t_address_$returns$_t_address_$","typeString":"function (address) view returns (address)"}},"id":55489,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"19524:42:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"VariableDeclarationStatement","src":"19479:87:100"},{"expression":{"arguments":[{"expression":{"expression":{"id":55494,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55193,"src":"19592:3:100","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$54911","typeString":"contract FetchChainInfoOutput"}},"id":55495,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"19596:34:100","memberName":"delayedWethPermissionlessGameProxy","nodeType":"MemberAccess","referencedDeclaration":54661,"src":"19592:38:100","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":55496,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"19631:8:100","memberName":"selector","nodeType":"MemberAccess","src":"19592:47:100","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},{"id":55497,"name":"delayedWethPermissionlessGameProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55486,"src":"19641:34:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_bytes4","typeString":"bytes4"},{"typeIdentifier":"t_address","typeString":"address"}],"expression":{"id":55491,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55193,"src":"19584:3:100","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$54911","typeString":"contract FetchChainInfoOutput"}},"id":55493,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"19588:3:100","memberName":"set","nodeType":"MemberAccess","referencedDeclaration":54384,"src":"19584:7:100","typeDescriptions":{"typeIdentifier":"t_function_external_nonpayable$_t_bytes4_$_t_address_$returns$__$","typeString":"function (bytes4,address) external"}},"id":55498,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"19584:92:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":55499,"nodeType":"ExpressionStatement","src":"19584:92:100"}]}},{"assignments":[55503],"declarations":[{"constant":false,"id":55503,"mutability":"mutable","name":"faultDisputeGameCannonKonaImpl","nameLocation":"19713:30:100","nodeType":"VariableDeclaration","scope":55527,"src":"19705:38:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":55502,"name":"address","nodeType":"ElementaryTypeName","src":"19705:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"id":55509,"initialValue":{"arguments":[{"id":55505,"name":"disputeGameFactoryProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55303,"src":"19783:23:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},{"expression":{"id":55506,"name":"GameTypes","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":70870,"src":"19808:9:100","typeDescriptions":{"typeIdentifier":"t_type$_t_contract$_GameTypes_$70870_$","typeString":"type(library GameTypes)"}},"id":55507,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"memberLocation":"19818:11:100","memberName":"CANNON_KONA","nodeType":"MemberAccess","referencedDeclaration":70837,"src":"19808:21:100","typeDescriptions":{"typeIdentifier":"t_userDefinedValueType$_GameType_$70720","typeString":"GameType"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_address","typeString":"address"},{"typeIdentifier":"t_userDefinedValueType$_GameType_$70720","typeString":"GameType"}],"id":55504,"name":"_getFaultDisputeGame","nodeType":"Identifier","overloadedDeclarations":[55832,55864],"referencedDeclaration":55864,"src":"19762:20:100","typeDescriptions":{"typeIdentifier":"t_function_internal_view$_t_address_$_t_userDefinedValueType$_GameType_$70720_$returns$_t_address_$","typeString":"function (address,GameType) view returns (address)"}},"id":55508,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"19762:68:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"VariableDeclarationStatement","src":"19705:125:100"},{"condition":{"commonType":{"typeIdentifier":"t_address","typeString":"address"},"id":55515,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftExpression":{"id":55510,"name":"faultDisputeGameCannonKonaImpl","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55503,"src":"19848:30:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"BinaryOperation","operator":"!=","rightExpression":{"arguments":[{"hexValue":"30","id":55513,"isConstant":false,"isLValue":false,"isPure":true,"kind":"number","lValueRequested":false,"nodeType":"Literal","src":"19890:1:100","typeDescriptions":{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"},"value":"0"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"}],"id":55512,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"nodeType":"ElementaryTypeNameExpression","src":"19882:7:100","typeDescriptions":{"typeIdentifier":"t_type$_t_address_$","typeString":"type(address)"},"typeName":{"id":55511,"name":"address","nodeType":"ElementaryTypeName","src":"19882:7:100","typeDescriptions":{}}},"id":55514,"isConstant":false,"isLValue":false,"isPure":true,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"19882:10:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"src":"19848:44:100","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},"id":55526,"nodeType":"IfStatement","src":"19844:167:100","trueBody":{"id":55525,"nodeType":"Block","src":"19894:117:100","statements":[{"expression":{"arguments":[{"expression":{"expression":{"id":55519,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55193,"src":"19920:3:100","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$54911","typeString":"contract FetchChainInfoOutput"}},"id":55520,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"19924:30:100","memberName":"faultDisputeGameCannonKonaImpl","nodeType":"MemberAccess","referencedDeclaration":54705,"src":"19920:34:100","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":55521,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"19955:8:100","memberName":"selector","nodeType":"MemberAccess","src":"19920:43:100","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},{"id":55522,"name":"faultDisputeGameCannonKonaImpl","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55503,"src":"19965:30:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_bytes4","typeString":"bytes4"},{"typeIdentifier":"t_address","typeString":"address"}],"expression":{"id":55516,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55193,"src":"19912:3:100","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$54911","typeString":"contract FetchChainInfoOutput"}},"id":55518,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"19916:3:100","memberName":"set","nodeType":"MemberAccess","referencedDeclaration":54384,"src":"19912:7:100","typeDescriptions":{"typeIdentifier":"t_function_external_nonpayable$_t_bytes4_$_t_address_$returns$__$","typeString":"function (bytes4,address) external"}},"id":55523,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"19912:84:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":55524,"nodeType":"ExpressionStatement","src":"19912:84:100"}]}}]}}]},"implemented":true,"kind":"function","modifiers":[],"name":"_processFaultProofs","nameLocation":"16392:19:100","parameters":{"id":55194,"nodeType":"ParameterList","parameters":[{"constant":false,"id":55193,"mutability":"mutable","name":"_fo","nameLocation":"16433:3:100","nodeType":"VariableDeclaration","scope":55565,"src":"16412:24:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$54911","typeString":"contract FetchChainInfoOutput"},"typeName":{"id":55192,"nodeType":"UserDefinedTypeName","pathNode":{"id":55191,"name":"FetchChainInfoOutput","nameLocations":["16412:20:100"],"nodeType":"IdentifierPath","referencedDeclaration":54911,"src":"16412:20:100"},"referencedDeclaration":54911,"src":"16412:20:100","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$54911","typeString":"contract FetchChainInfoOutput"}},"visibility":"internal"}],"src":"16411:26:100"},"returnParameters":{"id":55195,"nodeType":"ParameterList","parameters":[],"src":"16447:0:100"},"scope":56018,"stateMutability":"nonpayable","virtual":false,"visibility":"internal"},{"id":55594,"nodeType":"FunctionDefinition","src":"20422:256:100","nodes":[],"body":{"id":55593,"nodeType":"Block","src":"20493:185:100","nodes":[],"statements":[{"clauses":[{"block":{"id":55582,"nodeType":"Block","src":"20564:41:100","statements":[{"expression":{"id":55580,"name":"guardian_","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55578,"src":"20585:9:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"functionReturnParameters":55571,"id":55581,"nodeType":"Return","src":"20578:16:100"}]},"errorName":"","id":55583,"nodeType":"TryCatchClause","parameters":{"id":55579,"nodeType":"ParameterList","parameters":[{"constant":false,"id":55578,"mutability":"mutable","name":"guardian_","nameLocation":"20553:9:100","nodeType":"VariableDeclaration","scope":55583,"src":"20545:17:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":55577,"name":"address","nodeType":"ElementaryTypeName","src":"20545:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"20544:19:100"},"src":"20536:69:100"},{"block":{"id":55590,"nodeType":"Block","src":"20612:60:100","statements":[{"expression":{"arguments":[],"expression":{"argumentTypes":[],"expression":{"arguments":[{"id":55585,"name":"_portal","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55567,"src":"20642:7:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_address","typeString":"address"}],"id":55584,"name":"IFetcher","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":53958,"src":"20633:8:100","typeDescriptions":{"typeIdentifier":"t_type$_t_contract$_IFetcher_$53958_$","typeString":"type(contract IFetcher)"}},"id":55586,"isConstant":false,"isLValue":false,"isPure":false,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"20633:17:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_contract$_IFetcher_$53958","typeString":"contract IFetcher"}},"id":55587,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"20651:8:100","memberName":"GUARDIAN","nodeType":"MemberAccess","referencedDeclaration":53823,"src":"20633:26:100","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":55588,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"20633:28:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"functionReturnParameters":55571,"id":55589,"nodeType":"Return","src":"20626:35:100"}]},"errorName":"","id":55591,"nodeType":"TryCatchClause","src":"20606:66:100"}],"externalCall":{"arguments":[],"expression":{"argumentTypes":[],"expression":{"arguments":[{"id":55573,"name":"_portal","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55567,"src":"20516:7:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_address","typeString":"address"}],"id":55572,"name":"IFetcher","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":53958,"src":"20507:8:100","typeDescriptions":{"typeIdentifier":"t_type$_t_contract$_IFetcher_$53958_$","typeString":"type(contract IFetcher)"}},"id":55574,"isConstant":false,"isLValue":false,"isPure":false,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"20507:17:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_contract$_IFetcher_$53958","typeString":"contract IFetcher"}},"id":55575,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"20525:8:100","memberName":"guardian","nodeType":"MemberAccess","referencedDeclaration":53818,"src":"20507:26:100","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":55576,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"20507:28:100","tryCall":true,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"id":55592,"nodeType":"TryStatement","src":"20503:169:100"}]},"implemented":true,"kind":"function","modifiers":[],"name":"_getGuardian","nameLocation":"20431:12:100","parameters":{"id":55568,"nodeType":"ParameterList","parameters":[{"constant":false,"id":55567,"mutability":"mutable","name":"_portal","nameLocation":"20452:7:100","nodeType":"VariableDeclaration","scope":55594,"src":"20444:15:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":55566,"name":"address","nodeType":"ElementaryTypeName","src":"20444:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"20443:17:100"},"returnParameters":{"id":55571,"nodeType":"ParameterList","parameters":[{"constant":false,"id":55570,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":55594,"src":"20484:7:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":55569,"name":"address","nodeType":"ElementaryTypeName","src":"20484:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"20483:9:100"},"scope":56018,"stateMutability":"view","virtual":false,"visibility":"internal"},{"id":55623,"nodeType":"FunctionDefinition","src":"20684:282:100","nodes":[],"body":{"id":55622,"nodeType":"Block","src":"20764:202:100","nodes":[],"statements":[{"clauses":[{"block":{"id":55611,"nodeType":"Block","src":"20843:45:100","statements":[{"expression":{"id":55609,"name":"systemConfig_","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55607,"src":"20864:13:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"functionReturnParameters":55600,"id":55610,"nodeType":"Return","src":"20857:20:100"}]},"errorName":"","id":55612,"nodeType":"TryCatchClause","parameters":{"id":55608,"nodeType":"ParameterList","parameters":[{"constant":false,"id":55607,"mutability":"mutable","name":"systemConfig_","nameLocation":"20828:13:100","nodeType":"VariableDeclaration","scope":55612,"src":"20820:21:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":55606,"name":"address","nodeType":"ElementaryTypeName","src":"20820:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"20819:23:100"},"src":"20811:77:100"},{"block":{"id":55619,"nodeType":"Block","src":"20895:65:100","statements":[{"expression":{"arguments":[],"expression":{"argumentTypes":[],"expression":{"arguments":[{"id":55614,"name":"_portal","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55596,"src":"20925:7:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_address","typeString":"address"}],"id":55613,"name":"IFetcher","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":53958,"src":"20916:8:100","typeDescriptions":{"typeIdentifier":"t_type$_t_contract$_IFetcher_$53958_$","typeString":"type(contract IFetcher)"}},"id":55615,"isConstant":false,"isLValue":false,"isPure":false,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"20916:17:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_contract$_IFetcher_$53958","typeString":"contract IFetcher"}},"id":55616,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"20934:13:100","memberName":"SYSTEM_CONFIG","nodeType":"MemberAccess","referencedDeclaration":53833,"src":"20916:31:100","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":55617,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"20916:33:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"functionReturnParameters":55600,"id":55618,"nodeType":"Return","src":"20909:40:100"}]},"errorName":"","id":55620,"nodeType":"TryCatchClause","src":"20889:71:100"}],"externalCall":{"arguments":[],"expression":{"argumentTypes":[],"expression":{"arguments":[{"id":55602,"name":"_portal","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55596,"src":"20787:7:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_address","typeString":"address"}],"id":55601,"name":"IFetcher","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":53958,"src":"20778:8:100","typeDescriptions":{"typeIdentifier":"t_type$_t_contract$_IFetcher_$53958_$","typeString":"type(contract IFetcher)"}},"id":55603,"isConstant":false,"isLValue":false,"isPure":false,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"20778:17:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_contract$_IFetcher_$53958","typeString":"contract IFetcher"}},"id":55604,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"20796:12:100","memberName":"systemConfig","nodeType":"MemberAccess","referencedDeclaration":53828,"src":"20778:30:100","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":55605,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"20778:32:100","tryCall":true,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"id":55621,"nodeType":"TryStatement","src":"20774:186:100"}]},"implemented":true,"kind":"function","modifiers":[],"name":"_getSystemConfigProxy","nameLocation":"20693:21:100","parameters":{"id":55597,"nodeType":"ParameterList","parameters":[{"constant":false,"id":55596,"mutability":"mutable","name":"_portal","nameLocation":"20723:7:100","nodeType":"VariableDeclaration","scope":55623,"src":"20715:15:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":55595,"name":"address","nodeType":"ElementaryTypeName","src":"20715:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"20714:17:100"},"returnParameters":{"id":55600,"nodeType":"ParameterList","parameters":[{"constant":false,"id":55599,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":55623,"src":"20755:7:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":55598,"name":"address","nodeType":"ElementaryTypeName","src":"20755:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"20754:9:100"},"scope":56018,"stateMutability":"view","virtual":false,"visibility":"internal"},{"id":55652,"nodeType":"FunctionDefinition","src":"20972:338:100","nodes":[],"body":{"id":55651,"nodeType":"Block","src":"21075:235:100","nodes":[],"statements":[{"clauses":[{"block":{"id":55640,"nodeType":"Block","src":"21171:47:100","statements":[{"expression":{"id":55638,"name":"optimismPortal_","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55636,"src":"21192:15:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"functionReturnParameters":55629,"id":55639,"nodeType":"Return","src":"21185:22:100"}]},"errorName":"","id":55641,"nodeType":"TryCatchClause","parameters":{"id":55637,"nodeType":"ParameterList","parameters":[{"constant":false,"id":55636,"mutability":"mutable","name":"optimismPortal_","nameLocation":"21154:15:100","nodeType":"VariableDeclaration","scope":55641,"src":"21146:23:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":55635,"name":"address","nodeType":"ElementaryTypeName","src":"21146:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"21145:25:100"},"src":"21137:81:100"},{"block":{"id":55648,"nodeType":"Block","src":"21225:79:100","statements":[{"expression":{"arguments":[],"expression":{"argumentTypes":[],"expression":{"arguments":[{"id":55643,"name":"_l1CrossDomainMessengerProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55625,"src":"21255:28:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_address","typeString":"address"}],"id":55642,"name":"IFetcher","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":53958,"src":"21246:8:100","typeDescriptions":{"typeIdentifier":"t_type$_t_contract$_IFetcher_$53958_$","typeString":"type(contract IFetcher)"}},"id":55644,"isConstant":false,"isLValue":false,"isPure":false,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"21246:38:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_contract$_IFetcher_$53958","typeString":"contract IFetcher"}},"id":55645,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"21285:6:100","memberName":"PORTAL","nodeType":"MemberAccess","referencedDeclaration":53863,"src":"21246:45:100","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":55646,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"21246:47:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"functionReturnParameters":55629,"id":55647,"nodeType":"Return","src":"21239:54:100"}]},"errorName":"","id":55649,"nodeType":"TryCatchClause","src":"21219:85:100"}],"externalCall":{"arguments":[],"expression":{"argumentTypes":[],"expression":{"arguments":[{"id":55631,"name":"_l1CrossDomainMessengerProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55625,"src":"21098:28:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_address","typeString":"address"}],"id":55630,"name":"IFetcher","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":53958,"src":"21089:8:100","typeDescriptions":{"typeIdentifier":"t_type$_t_contract$_IFetcher_$53958_$","typeString":"type(contract IFetcher)"}},"id":55632,"isConstant":false,"isLValue":false,"isPure":false,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"21089:38:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_contract$_IFetcher_$53958","typeString":"contract IFetcher"}},"id":55633,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"21128:6:100","memberName":"portal","nodeType":"MemberAccess","referencedDeclaration":53868,"src":"21089:45:100","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":55634,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"21089:47:100","tryCall":true,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"id":55650,"nodeType":"TryStatement","src":"21085:219:100"}]},"implemented":true,"kind":"function","modifiers":[],"name":"_getOptimismPortalProxy","nameLocation":"20981:23:100","parameters":{"id":55626,"nodeType":"ParameterList","parameters":[{"constant":false,"id":55625,"mutability":"mutable","name":"_l1CrossDomainMessengerProxy","nameLocation":"21013:28:100","nodeType":"VariableDeclaration","scope":55652,"src":"21005:36:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":55624,"name":"address","nodeType":"ElementaryTypeName","src":"21005:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"21004:38:100"},"returnParameters":{"id":55629,"nodeType":"ParameterList","parameters":[{"constant":false,"id":55628,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":55652,"src":"21066:7:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":55627,"name":"address","nodeType":"ElementaryTypeName","src":"21066:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"21065:9:100"},"scope":56018,"stateMutability":"view","virtual":false,"visibility":"internal"},{"id":55690,"nodeType":"FunctionDefinition","src":"21316:350:100","nodes":[],"body":{"id":55689,"nodeType":"Block","src":"21414:252:100","nodes":[],"statements":[{"assignments":[55660],"declarations":[{"constant":false,"id":55660,"mutability":"mutable","name":"ADDRESS_MANAGER_MAPPING_SLOT","nameLocation":"21432:28:100","nodeType":"VariableDeclaration","scope":55689,"src":"21424:36:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_uint256","typeString":"uint256"},"typeName":{"id":55659,"name":"uint256","nodeType":"ElementaryTypeName","src":"21424:7:100","typeDescriptions":{"typeIdentifier":"t_uint256","typeString":"uint256"}},"visibility":"internal"}],"id":55662,"initialValue":{"hexValue":"31","id":55661,"isConstant":false,"isLValue":false,"isPure":true,"kind":"number","lValueRequested":false,"nodeType":"Literal","src":"21463:1:100","typeDescriptions":{"typeIdentifier":"t_rational_1_by_1","typeString":"int_const 1"},"value":"1"},"nodeType":"VariableDeclarationStatement","src":"21424:40:100"},{"assignments":[55664],"declarations":[{"constant":false,"id":55664,"mutability":"mutable","name":"slot","nameLocation":"21482:4:100","nodeType":"VariableDeclaration","scope":55689,"src":"21474:12:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_bytes32","typeString":"bytes32"},"typeName":{"id":55663,"name":"bytes32","nodeType":"ElementaryTypeName","src":"21474:7:100","typeDescriptions":{"typeIdentifier":"t_bytes32","typeString":"bytes32"}},"visibility":"internal"}],"id":55672,"initialValue":{"arguments":[{"arguments":[{"id":55668,"name":"_l1CrossDomainMessengerProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55654,"src":"21510:28:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},{"id":55669,"name":"ADDRESS_MANAGER_MAPPING_SLOT","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55660,"src":"21540:28:100","typeDescriptions":{"typeIdentifier":"t_uint256","typeString":"uint256"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_address","typeString":"address"},{"typeIdentifier":"t_uint256","typeString":"uint256"}],"expression":{"id":55666,"name":"abi","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":-1,"src":"21499:3:100","typeDescriptions":{"typeIdentifier":"t_magic_abi","typeString":"abi"}},"id":55667,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"memberLocation":"21503:6:100","memberName":"encode","nodeType":"MemberAccess","src":"21499:10:100","typeDescriptions":{"typeIdentifier":"t_function_abiencode_pure$__$returns$_t_bytes_memory_ptr_$","typeString":"function () pure returns (bytes memory)"}},"id":55670,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"21499:70:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_bytes_memory_ptr","typeString":"bytes memory"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_bytes_memory_ptr","typeString":"bytes memory"}],"id":55665,"name":"keccak256","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":-8,"src":"21489:9:100","typeDescriptions":{"typeIdentifier":"t_function_keccak256_pure$_t_bytes_memory_ptr_$returns$_t_bytes32_$","typeString":"function (bytes memory) pure returns (bytes32)"}},"id":55671,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"21489:81:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_bytes32","typeString":"bytes32"}},"nodeType":"VariableDeclarationStatement","src":"21474:96:100"},{"expression":{"arguments":[{"arguments":[{"arguments":[{"components":[{"arguments":[{"id":55681,"name":"_l1CrossDomainMessengerProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55654,"src":"21620:28:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},{"id":55682,"name":"slot","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55664,"src":"21650:4:100","typeDescriptions":{"typeIdentifier":"t_bytes32","typeString":"bytes32"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_address","typeString":"address"},{"typeIdentifier":"t_bytes32","typeString":"bytes32"}],"expression":{"id":55679,"name":"vm","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":5501,"src":"21612:2:100","typeDescriptions":{"typeIdentifier":"t_contract$_Vm_$23288","typeString":"contract Vm"}},"id":55680,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"21615:4:100","memberName":"load","nodeType":"MemberAccess","referencedDeclaration":19384,"src":"21612:7:100","typeDescriptions":{"typeIdentifier":"t_function_external_view$_t_address_$_t_bytes32_$returns$_t_bytes32_$","typeString":"function (address,bytes32) view external returns (bytes32)"}},"id":55683,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"21612:43:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_bytes32","typeString":"bytes32"}}],"id":55684,"isConstant":false,"isInlineArray":false,"isLValue":false,"isPure":false,"lValueRequested":false,"nodeType":"TupleExpression","src":"21611:45:100","typeDescriptions":{"typeIdentifier":"t_bytes32","typeString":"bytes32"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_bytes32","typeString":"bytes32"}],"id":55678,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"nodeType":"ElementaryTypeNameExpression","src":"21603:7:100","typeDescriptions":{"typeIdentifier":"t_type$_t_uint256_$","typeString":"type(uint256)"},"typeName":{"id":55677,"name":"uint256","nodeType":"ElementaryTypeName","src":"21603:7:100","typeDescriptions":{}}},"id":55685,"isConstant":false,"isLValue":false,"isPure":false,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"21603:54:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_uint256","typeString":"uint256"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_uint256","typeString":"uint256"}],"id":55676,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"nodeType":"ElementaryTypeNameExpression","src":"21595:7:100","typeDescriptions":{"typeIdentifier":"t_type$_t_uint160_$","typeString":"type(uint160)"},"typeName":{"id":55675,"name":"uint160","nodeType":"ElementaryTypeName","src":"21595:7:100","typeDescriptions":{}}},"id":55686,"isConstant":false,"isLValue":false,"isPure":false,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"21595:63:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_uint160","typeString":"uint160"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_uint160","typeString":"uint160"}],"id":55674,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"nodeType":"ElementaryTypeNameExpression","src":"21587:7:100","typeDescriptions":{"typeIdentifier":"t_type$_t_address_$","typeString":"type(address)"},"typeName":{"id":55673,"name":"address","nodeType":"ElementaryTypeName","src":"21587:7:100","typeDescriptions":{}}},"id":55687,"isConstant":false,"isLValue":false,"isPure":false,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"21587:72:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"functionReturnParameters":55658,"id":55688,"nodeType":"Return","src":"21580:79:100"}]},"implemented":true,"kind":"function","modifiers":[],"name":"_getAddressManager","nameLocation":"21325:18:100","parameters":{"id":55655,"nodeType":"ParameterList","parameters":[{"constant":false,"id":55654,"mutability":"mutable","name":"_l1CrossDomainMessengerProxy","nameLocation":"21352:28:100","nodeType":"VariableDeclaration","scope":55690,"src":"21344:36:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":55653,"name":"address","nodeType":"ElementaryTypeName","src":"21344:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"21343:38:100"},"returnParameters":{"id":55658,"nodeType":"ParameterList","parameters":[{"constant":false,"id":55657,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":55690,"src":"21405:7:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":55656,"name":"address","nodeType":"ElementaryTypeName","src":"21405:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"21404:9:100"},"scope":56018,"stateMutability":"view","virtual":false,"visibility":"internal"},{"id":55718,"nodeType":"FunctionDefinition","src":"21672:299:100","nodes":[],"body":{"id":55717,"nodeType":"Block","src":"21765:206:100","nodes":[],"statements":[{"clauses":[{"block":{"id":55707,"nodeType":"Block","src":"21864:52:100","statements":[{"expression":{"id":55705,"name":"l1ERC721BridgeProxy_","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55703,"src":"21885:20:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"functionReturnParameters":55696,"id":55706,"nodeType":"Return","src":"21878:27:100"}]},"errorName":"","id":55708,"nodeType":"TryCatchClause","parameters":{"id":55704,"nodeType":"ParameterList","parameters":[{"constant":false,"id":55703,"mutability":"mutable","name":"l1ERC721BridgeProxy_","nameLocation":"21842:20:100","nodeType":"VariableDeclaration","scope":55708,"src":"21834:28:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":55702,"name":"address","nodeType":"ElementaryTypeName","src":"21834:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"21833:30:100"},"src":"21825:91:100"},{"block":{"id":55714,"nodeType":"Block","src":"21923:42:100","statements":[{"expression":{"arguments":[{"hexValue":"30","id":55711,"isConstant":false,"isLValue":false,"isPure":true,"kind":"number","lValueRequested":false,"nodeType":"Literal","src":"21952:1:100","typeDescriptions":{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"},"value":"0"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"}],"id":55710,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"nodeType":"ElementaryTypeNameExpression","src":"21944:7:100","typeDescriptions":{"typeIdentifier":"t_type$_t_address_$","typeString":"type(address)"},"typeName":{"id":55709,"name":"address","nodeType":"ElementaryTypeName","src":"21944:7:100","typeDescriptions":{}}},"id":55712,"isConstant":false,"isLValue":false,"isPure":true,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"21944:10:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"functionReturnParameters":55696,"id":55713,"nodeType":"Return","src":"21937:17:100"}]},"errorName":"","id":55715,"nodeType":"TryCatchClause","src":"21917:48:100"}],"externalCall":{"arguments":[],"expression":{"argumentTypes":[],"expression":{"arguments":[{"id":55698,"name":"_systemConfigProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55692,"src":"21788:18:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_address","typeString":"address"}],"id":55697,"name":"IFetcher","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":53958,"src":"21779:8:100","typeDescriptions":{"typeIdentifier":"t_type$_t_contract$_IFetcher_$53958_$","typeString":"type(contract IFetcher)"}},"id":55699,"isConstant":false,"isLValue":false,"isPure":false,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"21779:28:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_contract$_IFetcher_$53958","typeString":"contract IFetcher"}},"id":55700,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"21808:14:100","memberName":"l1ERC721Bridge","nodeType":"MemberAccess","referencedDeclaration":53873,"src":"21779:43:100","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":55701,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"21779:45:100","tryCall":true,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"id":55716,"nodeType":"TryStatement","src":"21775:190:100"}]},"implemented":true,"kind":"function","modifiers":[],"name":"_getL1ERC721BridgeProxy","nameLocation":"21681:23:100","parameters":{"id":55693,"nodeType":"ParameterList","parameters":[{"constant":false,"id":55692,"mutability":"mutable","name":"_systemConfigProxy","nameLocation":"21713:18:100","nodeType":"VariableDeclaration","scope":55718,"src":"21705:26:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":55691,"name":"address","nodeType":"ElementaryTypeName","src":"21705:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"21704:28:100"},"returnParameters":{"id":55696,"nodeType":"ParameterList","parameters":[{"constant":false,"id":55695,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":55718,"src":"21756:7:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":55694,"name":"address","nodeType":"ElementaryTypeName","src":"21756:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"21755:9:100"},"scope":56018,"stateMutability":"view","virtual":false,"visibility":"internal"},{"id":55746,"nodeType":"FunctionDefinition","src":"21977:377:100","nodes":[],"body":{"id":55745,"nodeType":"Block","src":"22084:270:100","nodes":[],"statements":[{"clauses":[{"block":{"id":55735,"nodeType":"Block","src":"22233:66:100","statements":[{"expression":{"id":55733,"name":"optimismMintableERC20FactoryProxy_","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55731,"src":"22254:34:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"functionReturnParameters":55724,"id":55734,"nodeType":"Return","src":"22247:41:100"}]},"errorName":"","id":55736,"nodeType":"TryCatchClause","parameters":{"id":55732,"nodeType":"ParameterList","parameters":[{"constant":false,"id":55731,"mutability":"mutable","name":"optimismMintableERC20FactoryProxy_","nameLocation":"22188:34:100","nodeType":"VariableDeclaration","scope":55736,"src":"22180:42:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":55730,"name":"address","nodeType":"ElementaryTypeName","src":"22180:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"22166:66:100"},"src":"22158:141:100"},{"block":{"id":55742,"nodeType":"Block","src":"22306:42:100","statements":[{"expression":{"arguments":[{"hexValue":"30","id":55739,"isConstant":false,"isLValue":false,"isPure":true,"kind":"number","lValueRequested":false,"nodeType":"Literal","src":"22335:1:100","typeDescriptions":{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"},"value":"0"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"}],"id":55738,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"nodeType":"ElementaryTypeNameExpression","src":"22327:7:100","typeDescriptions":{"typeIdentifier":"t_type$_t_address_$","typeString":"type(address)"},"typeName":{"id":55737,"name":"address","nodeType":"ElementaryTypeName","src":"22327:7:100","typeDescriptions":{}}},"id":55740,"isConstant":false,"isLValue":false,"isPure":true,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"22327:10:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"functionReturnParameters":55724,"id":55741,"nodeType":"Return","src":"22320:17:100"}]},"errorName":"","id":55743,"nodeType":"TryCatchClause","src":"22300:48:100"}],"externalCall":{"arguments":[],"expression":{"argumentTypes":[],"expression":{"arguments":[{"id":55726,"name":"_systemConfigProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55720,"src":"22107:18:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_address","typeString":"address"}],"id":55725,"name":"IFetcher","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":53958,"src":"22098:8:100","typeDescriptions":{"typeIdentifier":"t_type$_t_contract$_IFetcher_$53958_$","typeString":"type(contract IFetcher)"}},"id":55727,"isConstant":false,"isLValue":false,"isPure":false,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"22098:28:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_contract$_IFetcher_$53958","typeString":"contract IFetcher"}},"id":55728,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"22127:28:100","memberName":"optimismMintableERC20Factory","nodeType":"MemberAccess","referencedDeclaration":53878,"src":"22098:57:100","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":55729,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"22098:59:100","tryCall":true,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"id":55744,"nodeType":"TryStatement","src":"22094:254:100"}]},"implemented":true,"kind":"function","modifiers":[],"name":"_getOptimismMintableERC20FactoryProxy","nameLocation":"21986:37:100","parameters":{"id":55721,"nodeType":"ParameterList","parameters":[{"constant":false,"id":55720,"mutability":"mutable","name":"_systemConfigProxy","nameLocation":"22032:18:100","nodeType":"VariableDeclaration","scope":55746,"src":"22024:26:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":55719,"name":"address","nodeType":"ElementaryTypeName","src":"22024:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"22023:28:100"},"returnParameters":{"id":55724,"nodeType":"ParameterList","parameters":[{"constant":false,"id":55723,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":55746,"src":"22075:7:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":55722,"name":"address","nodeType":"ElementaryTypeName","src":"22075:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"22074:9:100"},"scope":56018,"stateMutability":"view","virtual":false,"visibility":"internal"},{"id":55774,"nodeType":"FunctionDefinition","src":"22360:398:100","nodes":[],"body":{"id":55773,"nodeType":"Block","src":"22457:301:100","nodes":[],"statements":[{"clauses":[{"block":{"id":55763,"nodeType":"Block","src":"22564:56:100","statements":[{"expression":{"id":55761,"name":"disputeGameFactoryProxy_","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55759,"src":"22585:24:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"functionReturnParameters":55752,"id":55762,"nodeType":"Return","src":"22578:31:100"}]},"errorName":"","id":55764,"nodeType":"TryCatchClause","parameters":{"id":55760,"nodeType":"ParameterList","parameters":[{"constant":false,"id":55759,"mutability":"mutable","name":"disputeGameFactoryProxy_","nameLocation":"22538:24:100","nodeType":"VariableDeclaration","scope":55764,"src":"22530:32:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":55758,"name":"address","nodeType":"ElementaryTypeName","src":"22530:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"22529:34:100"},"src":"22521:99:100"},{"block":{"id":55770,"nodeType":"Block","src":"22627:125:100","statements":[{"expression":{"arguments":[{"hexValue":"30","id":55767,"isConstant":false,"isLValue":false,"isPure":true,"kind":"number","lValueRequested":false,"nodeType":"Literal","src":"22739:1:100","typeDescriptions":{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"},"value":"0"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"}],"id":55766,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"nodeType":"ElementaryTypeNameExpression","src":"22731:7:100","typeDescriptions":{"typeIdentifier":"t_type$_t_address_$","typeString":"type(address)"},"typeName":{"id":55765,"name":"address","nodeType":"ElementaryTypeName","src":"22731:7:100","typeDescriptions":{}}},"id":55768,"isConstant":false,"isLValue":false,"isPure":true,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"22731:10:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"functionReturnParameters":55752,"id":55769,"nodeType":"Return","src":"22724:17:100"}]},"errorName":"","id":55771,"nodeType":"TryCatchClause","src":"22621:131:100"}],"externalCall":{"arguments":[],"expression":{"argumentTypes":[],"expression":{"arguments":[{"id":55754,"name":"_systemConfigProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55748,"src":"22480:18:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_address","typeString":"address"}],"id":55753,"name":"IFetcher","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":53958,"src":"22471:8:100","typeDescriptions":{"typeIdentifier":"t_type$_t_contract$_IFetcher_$53958_$","typeString":"type(contract IFetcher)"}},"id":55755,"isConstant":false,"isLValue":false,"isPure":false,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"22471:28:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_contract$_IFetcher_$53958","typeString":"contract IFetcher"}},"id":55756,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"22500:18:100","memberName":"disputeGameFactory","nodeType":"MemberAccess","referencedDeclaration":53838,"src":"22471:47:100","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":55757,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"22471:49:100","tryCall":true,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"id":55772,"nodeType":"TryStatement","src":"22467:285:100"}]},"implemented":true,"kind":"function","modifiers":[],"name":"_getDisputeGameFactoryProxy","nameLocation":"22369:27:100","parameters":{"id":55749,"nodeType":"ParameterList","parameters":[{"constant":false,"id":55748,"mutability":"mutable","name":"_systemConfigProxy","nameLocation":"22405:18:100","nodeType":"VariableDeclaration","scope":55774,"src":"22397:26:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":55747,"name":"address","nodeType":"ElementaryTypeName","src":"22397:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"22396:28:100"},"returnParameters":{"id":55752,"nodeType":"ParameterList","parameters":[{"constant":false,"id":55751,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":55774,"src":"22448:7:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":55750,"name":"address","nodeType":"ElementaryTypeName","src":"22448:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"22447:9:100"},"scope":56018,"stateMutability":"view","virtual":false,"visibility":"internal"},{"id":55802,"nodeType":"FunctionDefinition","src":"22764:311:100","nodes":[],"body":{"id":55801,"nodeType":"Block","src":"22861:214:100","nodes":[],"statements":[{"clauses":[{"block":{"id":55791,"nodeType":"Block","src":"22966:54:100","statements":[{"expression":{"id":55789,"name":"superchainConfigProxy_","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55787,"src":"22987:22:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"functionReturnParameters":55780,"id":55790,"nodeType":"Return","src":"22980:29:100"}]},"errorName":"","id":55792,"nodeType":"TryCatchClause","parameters":{"id":55788,"nodeType":"ParameterList","parameters":[{"constant":false,"id":55787,"mutability":"mutable","name":"superchainConfigProxy_","nameLocation":"22942:22:100","nodeType":"VariableDeclaration","scope":55792,"src":"22934:30:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":55786,"name":"address","nodeType":"ElementaryTypeName","src":"22934:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"22933:32:100"},"src":"22925:95:100"},{"block":{"id":55798,"nodeType":"Block","src":"23027:42:100","statements":[{"expression":{"arguments":[{"hexValue":"30","id":55795,"isConstant":false,"isLValue":false,"isPure":true,"kind":"number","lValueRequested":false,"nodeType":"Literal","src":"23056:1:100","typeDescriptions":{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"},"value":"0"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"}],"id":55794,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"nodeType":"ElementaryTypeNameExpression","src":"23048:7:100","typeDescriptions":{"typeIdentifier":"t_type$_t_address_$","typeString":"type(address)"},"typeName":{"id":55793,"name":"address","nodeType":"ElementaryTypeName","src":"23048:7:100","typeDescriptions":{}}},"id":55796,"isConstant":false,"isLValue":false,"isPure":true,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"23048:10:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"functionReturnParameters":55780,"id":55797,"nodeType":"Return","src":"23041:17:100"}]},"errorName":"","id":55799,"nodeType":"TryCatchClause","src":"23021:48:100"}],"externalCall":{"arguments":[],"expression":{"argumentTypes":[],"expression":{"arguments":[{"id":55782,"name":"_optimismPortalProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55776,"src":"22884:20:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_address","typeString":"address"}],"id":55781,"name":"IFetcher","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":53958,"src":"22875:8:100","typeDescriptions":{"typeIdentifier":"t_type$_t_contract$_IFetcher_$53958_$","typeString":"type(contract IFetcher)"}},"id":55783,"isConstant":false,"isLValue":false,"isPure":false,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"22875:30:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_contract$_IFetcher_$53958","typeString":"contract IFetcher"}},"id":55784,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"22906:16:100","memberName":"superchainConfig","nodeType":"MemberAccess","referencedDeclaration":53848,"src":"22875:47:100","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":55785,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"22875:49:100","tryCall":true,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"id":55800,"nodeType":"TryStatement","src":"22871:198:100"}]},"implemented":true,"kind":"function","modifiers":[],"name":"_getSuperchainConfigProxy","nameLocation":"22773:25:100","parameters":{"id":55777,"nodeType":"ParameterList","parameters":[{"constant":false,"id":55776,"mutability":"mutable","name":"_optimismPortalProxy","nameLocation":"22807:20:100","nodeType":"VariableDeclaration","scope":55802,"src":"22799:28:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":55775,"name":"address","nodeType":"ElementaryTypeName","src":"22799:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"22798:30:100"},"returnParameters":{"id":55780,"nodeType":"ParameterList","parameters":[{"constant":false,"id":55779,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":55802,"src":"22852:7:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":55778,"name":"address","nodeType":"ElementaryTypeName","src":"22852:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"22851:9:100"},"scope":56018,"stateMutability":"view","virtual":false,"visibility":"internal"},{"id":55832,"nodeType":"FunctionDefinition","src":"23081:313:100","nodes":[],"body":{"id":55831,"nodeType":"Block","src":"23177:217:100","nodes":[],"statements":[{"clauses":[{"block":{"id":55821,"nodeType":"Block","src":"23290:49:100","statements":[{"expression":{"id":55819,"name":"faultDisputeGame_","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55817,"src":"23311:17:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"functionReturnParameters":55808,"id":55820,"nodeType":"Return","src":"23304:24:100"}]},"errorName":"","id":55822,"nodeType":"TryCatchClause","parameters":{"id":55818,"nodeType":"ParameterList","parameters":[{"constant":false,"id":55817,"mutability":"mutable","name":"faultDisputeGame_","nameLocation":"23271:17:100","nodeType":"VariableDeclaration","scope":55822,"src":"23263:25:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":55816,"name":"address","nodeType":"ElementaryTypeName","src":"23263:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"23262:27:100"},"src":"23254:85:100"},{"block":{"id":55828,"nodeType":"Block","src":"23346:42:100","statements":[{"expression":{"arguments":[{"hexValue":"30","id":55825,"isConstant":false,"isLValue":false,"isPure":true,"kind":"number","lValueRequested":false,"nodeType":"Literal","src":"23375:1:100","typeDescriptions":{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"},"value":"0"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"}],"id":55824,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"nodeType":"ElementaryTypeNameExpression","src":"23367:7:100","typeDescriptions":{"typeIdentifier":"t_type$_t_address_$","typeString":"type(address)"},"typeName":{"id":55823,"name":"address","nodeType":"ElementaryTypeName","src":"23367:7:100","typeDescriptions":{}}},"id":55826,"isConstant":false,"isLValue":false,"isPure":true,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"23367:10:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"functionReturnParameters":55808,"id":55827,"nodeType":"Return","src":"23360:17:100"}]},"errorName":"","id":55829,"nodeType":"TryCatchClause","src":"23340:48:100"}],"externalCall":{"arguments":[{"expression":{"id":55813,"name":"GameTypes","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":70870,"src":"23236:9:100","typeDescriptions":{"typeIdentifier":"t_type$_t_contract$_GameTypes_$70870_$","typeString":"type(library GameTypes)"}},"id":55814,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"memberLocation":"23246:6:100","memberName":"CANNON","nodeType":"MemberAccess","referencedDeclaration":70773,"src":"23236:16:100","typeDescriptions":{"typeIdentifier":"t_userDefinedValueType$_GameType_$70720","typeString":"GameType"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_userDefinedValueType$_GameType_$70720","typeString":"GameType"}],"expression":{"arguments":[{"id":55810,"name":"_disputeGameFactoryProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55804,"src":"23200:24:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_address","typeString":"address"}],"id":55809,"name":"IFetcher","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":53958,"src":"23191:8:100","typeDescriptions":{"typeIdentifier":"t_type$_t_contract$_IFetcher_$53958_$","typeString":"type(contract IFetcher)"}},"id":55811,"isConstant":false,"isLValue":false,"isPure":false,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"23191:34:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_contract$_IFetcher_$53958","typeString":"contract IFetcher"}},"id":55812,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"23226:9:100","memberName":"gameImpls","nodeType":"MemberAccess","referencedDeclaration":53886,"src":"23191:44:100","typeDescriptions":{"typeIdentifier":"t_function_external_view$_t_userDefinedValueType$_GameType_$70720_$returns$_t_address_$","typeString":"function (GameType) view external returns (address)"}},"id":55815,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"23191:62:100","tryCall":true,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"id":55830,"nodeType":"TryStatement","src":"23187:201:100"}]},"implemented":true,"kind":"function","modifiers":[],"name":"_getFaultDisputeGame","nameLocation":"23090:20:100","parameters":{"id":55805,"nodeType":"ParameterList","parameters":[{"constant":false,"id":55804,"mutability":"mutable","name":"_disputeGameFactoryProxy","nameLocation":"23119:24:100","nodeType":"VariableDeclaration","scope":55832,"src":"23111:32:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":55803,"name":"address","nodeType":"ElementaryTypeName","src":"23111:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"23110:34:100"},"returnParameters":{"id":55808,"nodeType":"ParameterList","parameters":[{"constant":false,"id":55807,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":55832,"src":"23168:7:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":55806,"name":"address","nodeType":"ElementaryTypeName","src":"23168:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"23167:9:100"},"scope":56018,"stateMutability":"view","virtual":false,"visibility":"internal"},{"id":55864,"nodeType":"FunctionDefinition","src":"23400:376:100","nodes":[],"body":{"id":55863,"nodeType":"Block","src":"23566:210:100","nodes":[],"statements":[{"clauses":[{"block":{"id":55853,"nodeType":"Block","src":"23672:49:100","statements":[{"expression":{"id":55851,"name":"faultDisputeGame_","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55849,"src":"23693:17:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"functionReturnParameters":55841,"id":55852,"nodeType":"Return","src":"23686:24:100"}]},"errorName":"","id":55854,"nodeType":"TryCatchClause","parameters":{"id":55850,"nodeType":"ParameterList","parameters":[{"constant":false,"id":55849,"mutability":"mutable","name":"faultDisputeGame_","nameLocation":"23653:17:100","nodeType":"VariableDeclaration","scope":55854,"src":"23645:25:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":55848,"name":"address","nodeType":"ElementaryTypeName","src":"23645:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"23644:27:100"},"src":"23636:85:100"},{"block":{"id":55860,"nodeType":"Block","src":"23728:42:100","statements":[{"expression":{"arguments":[{"hexValue":"30","id":55857,"isConstant":false,"isLValue":false,"isPure":true,"kind":"number","lValueRequested":false,"nodeType":"Literal","src":"23757:1:100","typeDescriptions":{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"},"value":"0"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"}],"id":55856,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"nodeType":"ElementaryTypeNameExpression","src":"23749:7:100","typeDescriptions":{"typeIdentifier":"t_type$_t_address_$","typeString":"type(address)"},"typeName":{"id":55855,"name":"address","nodeType":"ElementaryTypeName","src":"23749:7:100","typeDescriptions":{}}},"id":55858,"isConstant":false,"isLValue":false,"isPure":true,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"23749:10:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"functionReturnParameters":55841,"id":55859,"nodeType":"Return","src":"23742:17:100"}]},"errorName":"","id":55861,"nodeType":"TryCatchClause","src":"23722:48:100"}],"externalCall":{"arguments":[{"id":55846,"name":"_gameType","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55837,"src":"23625:9:100","typeDescriptions":{"typeIdentifier":"t_userDefinedValueType$_GameType_$70720","typeString":"GameType"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_userDefinedValueType$_GameType_$70720","typeString":"GameType"}],"expression":{"arguments":[{"id":55843,"name":"_disputeGameFactoryProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55834,"src":"23589:24:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_address","typeString":"address"}],"id":55842,"name":"IFetcher","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":53958,"src":"23580:8:100","typeDescriptions":{"typeIdentifier":"t_type$_t_contract$_IFetcher_$53958_$","typeString":"type(contract IFetcher)"}},"id":55844,"isConstant":false,"isLValue":false,"isPure":false,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"23580:34:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_contract$_IFetcher_$53958","typeString":"contract IFetcher"}},"id":55845,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"23615:9:100","memberName":"gameImpls","nodeType":"MemberAccess","referencedDeclaration":53886,"src":"23580:44:100","typeDescriptions":{"typeIdentifier":"t_function_external_view$_t_userDefinedValueType$_GameType_$70720_$returns$_t_address_$","typeString":"function (GameType) view external returns (address)"}},"id":55847,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"23580:55:100","tryCall":true,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"id":55862,"nodeType":"TryStatement","src":"23576:194:100"}]},"implemented":true,"kind":"function","modifiers":[],"name":"_getFaultDisputeGame","nameLocation":"23409:20:100","parameters":{"id":55838,"nodeType":"ParameterList","parameters":[{"constant":false,"id":55834,"mutability":"mutable","name":"_disputeGameFactoryProxy","nameLocation":"23447:24:100","nodeType":"VariableDeclaration","scope":55864,"src":"23439:32:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":55833,"name":"address","nodeType":"ElementaryTypeName","src":"23439:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"},{"constant":false,"id":55837,"mutability":"mutable","name":"_gameType","nameLocation":"23490:9:100","nodeType":"VariableDeclaration","scope":55864,"src":"23481:18:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_userDefinedValueType$_GameType_$70720","typeString":"GameType"},"typeName":{"id":55836,"nodeType":"UserDefinedTypeName","pathNode":{"id":55835,"name":"GameType","nameLocations":["23481:8:100"],"nodeType":"IdentifierPath","referencedDeclaration":70720,"src":"23481:8:100"},"referencedDeclaration":70720,"src":"23481:8:100","typeDescriptions":{"typeIdentifier":"t_userDefinedValueType$_GameType_$70720","typeString":"GameType"}},"visibility":"internal"}],"src":"23429:76:100"},"returnParameters":{"id":55841,"nodeType":"ParameterList","parameters":[{"constant":false,"id":55840,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":55864,"src":"23553:7:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":55839,"name":"address","nodeType":"ElementaryTypeName","src":"23553:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"23552:9:100"},"scope":56018,"stateMutability":"view","virtual":false,"visibility":"internal"},{"id":55894,"nodeType":"FunctionDefinition","src":"23782:369:100","nodes":[],"body":{"id":55893,"nodeType":"Block","src":"23885:266:100","nodes":[],"statements":[{"clauses":[{"block":{"id":55883,"nodeType":"Block","src":"24040:56:100","statements":[{"expression":{"id":55881,"name":"permissionedDisputeGame_","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55879,"src":"24061:24:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"functionReturnParameters":55870,"id":55882,"nodeType":"Return","src":"24054:31:100"}]},"errorName":"","id":55884,"nodeType":"TryCatchClause","parameters":{"id":55880,"nodeType":"ParameterList","parameters":[{"constant":false,"id":55879,"mutability":"mutable","name":"permissionedDisputeGame_","nameLocation":"24005:24:100","nodeType":"VariableDeclaration","scope":55884,"src":"23997:32:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":55878,"name":"address","nodeType":"ElementaryTypeName","src":"23997:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"23983:56:100"},"src":"23975:121:100"},{"block":{"id":55890,"nodeType":"Block","src":"24103:42:100","statements":[{"expression":{"arguments":[{"hexValue":"30","id":55887,"isConstant":false,"isLValue":false,"isPure":true,"kind":"number","lValueRequested":false,"nodeType":"Literal","src":"24132:1:100","typeDescriptions":{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"},"value":"0"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"}],"id":55886,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"nodeType":"ElementaryTypeNameExpression","src":"24124:7:100","typeDescriptions":{"typeIdentifier":"t_type$_t_address_$","typeString":"type(address)"},"typeName":{"id":55885,"name":"address","nodeType":"ElementaryTypeName","src":"24124:7:100","typeDescriptions":{}}},"id":55888,"isConstant":false,"isLValue":false,"isPure":true,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"24124:10:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"functionReturnParameters":55870,"id":55889,"nodeType":"Return","src":"24117:17:100"}]},"errorName":"","id":55891,"nodeType":"TryCatchClause","src":"24097:48:100"}],"externalCall":{"arguments":[{"expression":{"id":55875,"name":"GameTypes","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":70870,"src":"23944:9:100","typeDescriptions":{"typeIdentifier":"t_type$_t_contract$_GameTypes_$70870_$","typeString":"type(library GameTypes)"}},"id":55876,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"memberLocation":"23954:19:100","memberName":"PERMISSIONED_CANNON","nodeType":"MemberAccess","referencedDeclaration":70781,"src":"23944:29:100","typeDescriptions":{"typeIdentifier":"t_userDefinedValueType$_GameType_$70720","typeString":"GameType"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_userDefinedValueType$_GameType_$70720","typeString":"GameType"}],"expression":{"arguments":[{"id":55872,"name":"_disputeGameFactoryProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55866,"src":"23908:24:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_address","typeString":"address"}],"id":55871,"name":"IFetcher","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":53958,"src":"23899:8:100","typeDescriptions":{"typeIdentifier":"t_type$_t_contract$_IFetcher_$53958_$","typeString":"type(contract IFetcher)"}},"id":55873,"isConstant":false,"isLValue":false,"isPure":false,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"23899:34:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_contract$_IFetcher_$53958","typeString":"contract IFetcher"}},"id":55874,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"23934:9:100","memberName":"gameImpls","nodeType":"MemberAccess","referencedDeclaration":53886,"src":"23899:44:100","typeDescriptions":{"typeIdentifier":"t_function_external_view$_t_userDefinedValueType$_GameType_$70720_$returns$_t_address_$","typeString":"function (GameType) view external returns (address)"}},"id":55877,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"23899:75:100","tryCall":true,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"id":55892,"nodeType":"TryStatement","src":"23895:250:100"}]},"implemented":true,"kind":"function","modifiers":[],"name":"_getPermissionedDisputeGame","nameLocation":"23791:27:100","parameters":{"id":55867,"nodeType":"ParameterList","parameters":[{"constant":false,"id":55866,"mutability":"mutable","name":"_disputeGameFactoryProxy","nameLocation":"23827:24:100","nodeType":"VariableDeclaration","scope":55894,"src":"23819:32:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":55865,"name":"address","nodeType":"ElementaryTypeName","src":"23819:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"23818:34:100"},"returnParameters":{"id":55870,"nodeType":"ParameterList","parameters":[{"constant":false,"id":55869,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":55894,"src":"23876:7:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":55868,"name":"address","nodeType":"ElementaryTypeName","src":"23876:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"23875:9:100"},"scope":56018,"stateMutability":"view","virtual":false,"visibility":"internal"},{"id":55922,"nodeType":"FunctionDefinition","src":"24157:277:100","nodes":[],"body":{"id":55921,"nodeType":"Block","src":"24248:186:100","nodes":[],"statements":[{"clauses":[{"block":{"id":55911,"nodeType":"Block","src":"24336:43:100","statements":[{"expression":{"id":55909,"name":"ethLockbox_","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55907,"src":"24357:11:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"functionReturnParameters":55900,"id":55910,"nodeType":"Return","src":"24350:18:100"}]},"errorName":"","id":55912,"nodeType":"TryCatchClause","parameters":{"id":55908,"nodeType":"ParameterList","parameters":[{"constant":false,"id":55907,"mutability":"mutable","name":"ethLockbox_","nameLocation":"24323:11:100","nodeType":"VariableDeclaration","scope":55912,"src":"24315:19:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":55906,"name":"address","nodeType":"ElementaryTypeName","src":"24315:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"24314:21:100"},"src":"24306:73:100"},{"block":{"id":55918,"nodeType":"Block","src":"24386:42:100","statements":[{"expression":{"arguments":[{"hexValue":"30","id":55915,"isConstant":false,"isLValue":false,"isPure":true,"kind":"number","lValueRequested":false,"nodeType":"Literal","src":"24415:1:100","typeDescriptions":{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"},"value":"0"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"}],"id":55914,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"nodeType":"ElementaryTypeNameExpression","src":"24407:7:100","typeDescriptions":{"typeIdentifier":"t_type$_t_address_$","typeString":"type(address)"},"typeName":{"id":55913,"name":"address","nodeType":"ElementaryTypeName","src":"24407:7:100","typeDescriptions":{}}},"id":55916,"isConstant":false,"isLValue":false,"isPure":true,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"24407:10:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"functionReturnParameters":55900,"id":55917,"nodeType":"Return","src":"24400:17:100"}]},"errorName":"","id":55919,"nodeType":"TryCatchClause","src":"24380:48:100"}],"externalCall":{"arguments":[],"expression":{"argumentTypes":[],"expression":{"arguments":[{"id":55902,"name":"_optimismPortalProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55896,"src":"24271:20:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_address","typeString":"address"}],"id":55901,"name":"IFetcher","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":53958,"src":"24262:8:100","typeDescriptions":{"typeIdentifier":"t_type$_t_contract$_IFetcher_$53958_$","typeString":"type(contract IFetcher)"}},"id":55903,"isConstant":false,"isLValue":false,"isPure":false,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"24262:30:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_contract$_IFetcher_$53958","typeString":"contract IFetcher"}},"id":55904,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"24293:10:100","memberName":"ethLockbox","nodeType":"MemberAccess","referencedDeclaration":53843,"src":"24262:41:100","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":55905,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"24262:43:100","tryCall":true,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"id":55920,"nodeType":"TryStatement","src":"24258:170:100"}]},"implemented":true,"kind":"function","modifiers":[],"name":"_getEthLockboxProxy","nameLocation":"24166:19:100","parameters":{"id":55897,"nodeType":"ParameterList","parameters":[{"constant":false,"id":55896,"mutability":"mutable","name":"_optimismPortalProxy","nameLocation":"24194:20:100","nodeType":"VariableDeclaration","scope":55922,"src":"24186:28:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":55895,"name":"address","nodeType":"ElementaryTypeName","src":"24186:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"24185:30:100"},"returnParameters":{"id":55900,"nodeType":"ParameterList","parameters":[{"constant":false,"id":55899,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":55922,"src":"24239:7:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":55898,"name":"address","nodeType":"ElementaryTypeName","src":"24239:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"24238:9:100"},"scope":56018,"stateMutability":"view","virtual":false,"visibility":"internal"},{"id":55967,"nodeType":"FunctionDefinition","src":"24440:304:100","nodes":[],"body":{"id":55966,"nodeType":"Block","src":"24524:220:100","nodes":[],"statements":[{"assignments":[55930,55932],"declarations":[{"constant":false,"id":55930,"mutability":"mutable","name":"ok","nameLocation":"24540:2:100","nodeType":"VariableDeclaration","scope":55966,"src":"24535:7:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"},"typeName":{"id":55929,"name":"bool","nodeType":"ElementaryTypeName","src":"24535:4:100","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},"visibility":"internal"},{"constant":false,"id":55932,"mutability":"mutable","name":"data","nameLocation":"24557:4:100","nodeType":"VariableDeclaration","scope":55966,"src":"24544:17:100","stateVariable":false,"storageLocation":"memory","typeDescriptions":{"typeIdentifier":"t_bytes_memory_ptr","typeString":"bytes"},"typeName":{"id":55931,"name":"bytes","nodeType":"ElementaryTypeName","src":"24544:5:100","typeDescriptions":{"typeIdentifier":"t_bytes_storage_ptr","typeString":"bytes"}},"visibility":"internal"}],"id":55945,"initialValue":{"arguments":[{"arguments":[{"expression":{"id":55940,"name":"IFetcher","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":53958,"src":"24613:8:100","typeDescriptions":{"typeIdentifier":"t_type$_t_contract$_IFetcher_$53958_$","typeString":"type(contract IFetcher)"}},"id":55941,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"memberLocation":"24622:4:100","memberName":"weth","nodeType":"MemberAccess","referencedDeclaration":53957,"src":"24613:13:100","typeDescriptions":{"typeIdentifier":"t_function_declaration_view$__$returns$_t_address_$","typeString":"function IFetcher.weth() view returns (address)"}},{"components":[],"id":55942,"isConstant":false,"isInlineArray":false,"isLValue":false,"isPure":true,"lValueRequested":false,"nodeType":"TupleExpression","src":"24628:2:100","typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_function_declaration_view$__$returns$_t_address_$","typeString":"function IFetcher.weth() view returns (address)"},{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}],"expression":{"id":55938,"name":"abi","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":-1,"src":"24598:3:100","typeDescriptions":{"typeIdentifier":"t_magic_abi","typeString":"abi"}},"id":55939,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"memberLocation":"24602:10:100","memberName":"encodeCall","nodeType":"MemberAccess","src":"24598:14:100","typeDescriptions":{"typeIdentifier":"t_function_abiencodecall_pure$__$returns$_t_bytes_memory_ptr_$","typeString":"function () pure returns (bytes memory)"}},"id":55943,"isConstant":false,"isLValue":false,"isPure":true,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"24598:33:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_bytes_memory_ptr","typeString":"bytes memory"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_bytes_memory_ptr","typeString":"bytes memory"}],"expression":{"arguments":[{"id":55935,"name":"_disputeGame","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55924,"src":"24573:12:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_address","typeString":"address"}],"id":55934,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"nodeType":"ElementaryTypeNameExpression","src":"24565:7:100","typeDescriptions":{"typeIdentifier":"t_type$_t_address_$","typeString":"type(address)"},"typeName":{"id":55933,"name":"address","nodeType":"ElementaryTypeName","src":"24565:7:100","typeDescriptions":{}}},"id":55936,"isConstant":false,"isLValue":false,"isPure":false,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"24565:21:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"id":55937,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"24587:10:100","memberName":"staticcall","nodeType":"MemberAccess","src":"24565:32:100","typeDescriptions":{"typeIdentifier":"t_function_barestaticcall_view$_t_bytes_memory_ptr_$returns$_t_bool_$_t_bytes_memory_ptr_$","typeString":"function (bytes memory) view returns (bool,bytes memory)"}},"id":55944,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"24565:67:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$_t_bool_$_t_bytes_memory_ptr_$","typeString":"tuple(bool,bytes memory)"}},"nodeType":"VariableDeclarationStatement","src":"24534:98:100"},{"condition":{"commonType":{"typeIdentifier":"t_bool","typeString":"bool"},"id":55951,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftExpression":{"id":55946,"name":"ok","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55930,"src":"24646:2:100","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},"nodeType":"BinaryOperation","operator":"&&","rightExpression":{"commonType":{"typeIdentifier":"t_uint256","typeString":"uint256"},"id":55950,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftExpression":{"expression":{"id":55947,"name":"data","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55932,"src":"24652:4:100","typeDescriptions":{"typeIdentifier":"t_bytes_memory_ptr","typeString":"bytes memory"}},"id":55948,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"24657:6:100","memberName":"length","nodeType":"MemberAccess","src":"24652:11:100","typeDescriptions":{"typeIdentifier":"t_uint256","typeString":"uint256"}},"nodeType":"BinaryOperation","operator":"==","rightExpression":{"hexValue":"3332","id":55949,"isConstant":false,"isLValue":false,"isPure":true,"kind":"number","lValueRequested":false,"nodeType":"Literal","src":"24667:2:100","typeDescriptions":{"typeIdentifier":"t_rational_32_by_1","typeString":"int_const 32"},"value":"32"},"src":"24652:17:100","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},"src":"24646:23:100","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},"falseBody":{"expression":{"arguments":[{"hexValue":"30","id":55962,"isConstant":false,"isLValue":false,"isPure":true,"kind":"number","lValueRequested":false,"nodeType":"Literal","src":"24735:1:100","typeDescriptions":{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"},"value":"0"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"}],"id":55961,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"nodeType":"ElementaryTypeNameExpression","src":"24727:7:100","typeDescriptions":{"typeIdentifier":"t_type$_t_address_$","typeString":"type(address)"},"typeName":{"id":55960,"name":"address","nodeType":"ElementaryTypeName","src":"24727:7:100","typeDescriptions":{}}},"id":55963,"isConstant":false,"isLValue":false,"isPure":true,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"24727:10:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"functionReturnParameters":55928,"id":55964,"nodeType":"Return","src":"24720:17:100"},"id":55965,"nodeType":"IfStatement","src":"24642:95:100","trueBody":{"expression":{"arguments":[{"id":55954,"name":"data","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55932,"src":"24689:4:100","typeDescriptions":{"typeIdentifier":"t_bytes_memory_ptr","typeString":"bytes memory"}},{"components":[{"id":55956,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"nodeType":"ElementaryTypeNameExpression","src":"24696:7:100","typeDescriptions":{"typeIdentifier":"t_type$_t_address_$","typeString":"type(address)"},"typeName":{"id":55955,"name":"address","nodeType":"ElementaryTypeName","src":"24696:7:100","typeDescriptions":{}}}],"id":55957,"isConstant":false,"isInlineArray":false,"isLValue":false,"isPure":true,"lValueRequested":false,"nodeType":"TupleExpression","src":"24695:9:100","typeDescriptions":{"typeIdentifier":"t_type$_t_address_$","typeString":"type(address)"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_bytes_memory_ptr","typeString":"bytes memory"},{"typeIdentifier":"t_type$_t_address_$","typeString":"type(address)"}],"expression":{"id":55952,"name":"abi","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":-1,"src":"24678:3:100","typeDescriptions":{"typeIdentifier":"t_magic_abi","typeString":"abi"}},"id":55953,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"memberLocation":"24682:6:100","memberName":"decode","nodeType":"MemberAccess","src":"24678:10:100","typeDescriptions":{"typeIdentifier":"t_function_abidecode_pure$__$returns$__$","typeString":"function () pure"}},"id":55958,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"24678:27:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address_payable","typeString":"address payable"}},"functionReturnParameters":55928,"id":55959,"nodeType":"Return","src":"24671:34:100"}}]},"implemented":true,"kind":"function","modifiers":[],"name":"_getDelayedWETHProxy","nameLocation":"24449:20:100","parameters":{"id":55925,"nodeType":"ParameterList","parameters":[{"constant":false,"id":55924,"mutability":"mutable","name":"_disputeGame","nameLocation":"24478:12:100","nodeType":"VariableDeclaration","scope":55967,"src":"24470:20:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":55923,"name":"address","nodeType":"ElementaryTypeName","src":"24470:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"24469:22:100"},"returnParameters":{"id":55928,"nodeType":"ParameterList","parameters":[{"constant":false,"id":55927,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":55967,"src":"24515:7:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":55926,"name":"address","nodeType":"ElementaryTypeName","src":"24515:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"24514:9:100"},"scope":56018,"stateMutability":"view","virtual":false,"visibility":"internal"},{"id":55994,"nodeType":"FunctionDefinition","src":"24750:224:100","nodes":[],"body":{"id":55993,"nodeType":"Block","src":"24838:136:100","nodes":[],"statements":[{"assignments":[55975],"declarations":[{"constant":false,"id":55975,"mutability":"mutable","name":"batcherHash","nameLocation":"24856:11:100","nodeType":"VariableDeclaration","scope":55993,"src":"24848:19:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_bytes32","typeString":"bytes32"},"typeName":{"id":55974,"name":"bytes32","nodeType":"ElementaryTypeName","src":"24848:7:100","typeDescriptions":{"typeIdentifier":"t_bytes32","typeString":"bytes32"}},"visibility":"internal"}],"id":55981,"initialValue":{"arguments":[],"expression":{"argumentTypes":[],"expression":{"arguments":[{"id":55977,"name":"_systemConfigProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55969,"src":"24879:18:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_address","typeString":"address"}],"id":55976,"name":"IFetcher","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":53958,"src":"24870:8:100","typeDescriptions":{"typeIdentifier":"t_type$_t_contract$_IFetcher_$53958_$","typeString":"type(contract IFetcher)"}},"id":55978,"isConstant":false,"isLValue":false,"isPure":false,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"24870:28:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_contract$_IFetcher_$53958","typeString":"contract IFetcher"}},"id":55979,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"24899:11:100","memberName":"batcherHash","nodeType":"MemberAccess","referencedDeclaration":53937,"src":"24870:40:100","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_bytes32_$","typeString":"function () view external returns (bytes32)"}},"id":55980,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"24870:42:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_bytes32","typeString":"bytes32"}},"nodeType":"VariableDeclarationStatement","src":"24848:64:100"},{"expression":{"arguments":[{"arguments":[{"arguments":[{"id":55988,"name":"batcherHash","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55975,"src":"24953:11:100","typeDescriptions":{"typeIdentifier":"t_bytes32","typeString":"bytes32"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_bytes32","typeString":"bytes32"}],"id":55987,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"nodeType":"ElementaryTypeNameExpression","src":"24945:7:100","typeDescriptions":{"typeIdentifier":"t_type$_t_uint256_$","typeString":"type(uint256)"},"typeName":{"id":55986,"name":"uint256","nodeType":"ElementaryTypeName","src":"24945:7:100","typeDescriptions":{}}},"id":55989,"isConstant":false,"isLValue":false,"isPure":false,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"24945:20:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_uint256","typeString":"uint256"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_uint256","typeString":"uint256"}],"id":55985,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"nodeType":"ElementaryTypeNameExpression","src":"24937:7:100","typeDescriptions":{"typeIdentifier":"t_type$_t_uint160_$","typeString":"type(uint160)"},"typeName":{"id":55984,"name":"uint160","nodeType":"ElementaryTypeName","src":"24937:7:100","typeDescriptions":{}}},"id":55990,"isConstant":false,"isLValue":false,"isPure":false,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"24937:29:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_uint160","typeString":"uint160"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_uint160","typeString":"uint160"}],"id":55983,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"nodeType":"ElementaryTypeNameExpression","src":"24929:7:100","typeDescriptions":{"typeIdentifier":"t_type$_t_address_$","typeString":"type(address)"},"typeName":{"id":55982,"name":"address","nodeType":"ElementaryTypeName","src":"24929:7:100","typeDescriptions":{}}},"id":55991,"isConstant":false,"isLValue":false,"isPure":false,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"24929:38:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"functionReturnParameters":55973,"id":55992,"nodeType":"Return","src":"24922:45:100"}]},"implemented":true,"kind":"function","modifiers":[],"name":"_getBatchSubmitter","nameLocation":"24759:18:100","parameters":{"id":55970,"nodeType":"ParameterList","parameters":[{"constant":false,"id":55969,"mutability":"mutable","name":"_systemConfigProxy","nameLocation":"24786:18:100","nodeType":"VariableDeclaration","scope":55994,"src":"24778:26:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":55968,"name":"address","nodeType":"ElementaryTypeName","src":"24778:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"24777:28:100"},"returnParameters":{"id":55973,"nodeType":"ParameterList","parameters":[{"constant":false,"id":55972,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":55994,"src":"24829:7:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":55971,"name":"address","nodeType":"ElementaryTypeName","src":"24829:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"24828:9:100"},"scope":56018,"stateMutability":"view","virtual":false,"visibility":"internal"},{"id":56017,"nodeType":"FunctionDefinition","src":"24980:169:100","nodes":[],"body":{"id":56016,"nodeType":"Block","src":"25059:90:100","nodes":[],"statements":[{"expression":{"arguments":[{"arguments":[{"hexValue":"30","id":56006,"isConstant":false,"isLValue":false,"isPure":true,"kind":"number","lValueRequested":false,"nodeType":"Literal","src":"25086:1:100","typeDescriptions":{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"},"value":"0"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"}],"id":56005,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"nodeType":"ElementaryTypeNameExpression","src":"25078:7:100","typeDescriptions":{"typeIdentifier":"t_type$_t_address_$","typeString":"type(address)"},"typeName":{"id":56004,"name":"address","nodeType":"ElementaryTypeName","src":"25078:7:100","typeDescriptions":{}}},"id":56007,"isConstant":false,"isLValue":false,"isPure":true,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"25078:10:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_address","typeString":"address"}],"expression":{"id":56001,"name":"vm","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":5501,"src":"25069:2:100","typeDescriptions":{"typeIdentifier":"t_contract$_Vm_$23288","typeString":"contract Vm"}},"id":56003,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"25072:5:100","memberName":"prank","nodeType":"MemberAccess","referencedDeclaration":22581,"src":"25069:8:100","typeDescriptions":{"typeIdentifier":"t_function_external_nonpayable$_t_address_$returns$__$","typeString":"function (address) external"}},"id":56008,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"25069:20:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":56009,"nodeType":"ExpressionStatement","src":"25069:20:100"},{"expression":{"arguments":[],"expression":{"argumentTypes":[],"expression":{"arguments":[{"id":56011,"name":"_systemConfigProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55996,"src":"25115:18:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_address","typeString":"address"}],"id":56010,"name":"IFetcher","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":53958,"src":"25106:8:100","typeDescriptions":{"typeIdentifier":"t_type$_t_contract$_IFetcher_$53958_$","typeString":"type(contract IFetcher)"}},"id":56012,"isConstant":false,"isLValue":false,"isPure":false,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"25106:28:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_contract$_IFetcher_$53958","typeString":"contract IFetcher"}},"id":56013,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"25135:5:100","memberName":"admin","nodeType":"MemberAccess","referencedDeclaration":53942,"src":"25106:34:100","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":56014,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"25106:36:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"functionReturnParameters":56000,"id":56015,"nodeType":"Return","src":"25099:43:100"}]},"implemented":true,"kind":"function","modifiers":[],"name":"_getProxyAdmin","nameLocation":"24989:14:100","parameters":{"id":55997,"nodeType":"ParameterList","parameters":[{"constant":false,"id":55996,"mutability":"mutable","name":"_systemConfigProxy","nameLocation":"25012:18:100","nodeType":"VariableDeclaration","scope":56017,"src":"25004:26:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":55995,"name":"address","nodeType":"ElementaryTypeName","src":"25004:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"25003:28:100"},"returnParameters":{"id":56000,"nodeType":"ParameterList","parameters":[{"constant":false,"id":55999,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":56017,"src":"25050:7:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":55998,"name":"address","nodeType":"ElementaryTypeName","src":"25050:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"25049:9:100"},"scope":56018,"stateMutability":"nonpayable","virtual":false,"visibility":"internal"}],"abstract":false,"baseContracts":[{"baseName":{"id":54912,"name":"Script","nameLocations":["13628:6:100"],"nodeType":"IdentifierPath","referencedDeclaration":5558,"src":"13628:6:100"},"id":54913,"nodeType":"InheritanceSpecifier","src":"13628:6:100"}],"canonicalName":"FetchChainInfo","contractDependencies":[],"contractKind":"contract","fullyImplemented":true,"linearizedBaseContracts":[56018,5558,18381,11222,9132,5517,5505],"name":"FetchChainInfo","nameLocation":"13610:14:100","scope":56019,"usedErrors":[],"usedEvents":[]}],"license":"MIT"},"id":100} \ No newline at end of file diff --git a/op-fetcher/pkg/fetcher/fetch/forge-artifacts/FetchChainInfo.s.sol/FetchChainInfoOutput.json b/op-fetcher/pkg/fetcher/fetch/forge-artifacts/FetchChainInfo.s.sol/FetchChainInfoOutput.json index a627151246b..bb01321087f 100644 --- a/op-fetcher/pkg/fetcher/fetch/forge-artifacts/FetchChainInfo.s.sol/FetchChainInfoOutput.json +++ b/op-fetcher/pkg/fetcher/fetch/forge-artifacts/FetchChainInfo.s.sol/FetchChainInfoOutput.json @@ -1 +1 @@ -{"abi":[{"type":"function","name":"addressManagerImpl","inputs":[],"outputs":[{"name":"","type":"address","internalType":"address"}],"stateMutability":"view"},{"type":"function","name":"anchorStateRegistryProxy","inputs":[],"outputs":[{"name":"","type":"address","internalType":"address"}],"stateMutability":"view"},{"type":"function","name":"batchSubmitter","inputs":[],"outputs":[{"name":"","type":"address","internalType":"address"}],"stateMutability":"view"},{"type":"function","name":"challenger","inputs":[],"outputs":[{"name":"","type":"address","internalType":"address"}],"stateMutability":"view"},{"type":"function","name":"delayedWethPermissionedGameProxy","inputs":[],"outputs":[{"name":"","type":"address","internalType":"address"}],"stateMutability":"view"},{"type":"function","name":"delayedWethPermissionlessGameProxy","inputs":[],"outputs":[{"name":"","type":"address","internalType":"address"}],"stateMutability":"view"},{"type":"function","name":"disputeGameFactoryProxy","inputs":[],"outputs":[{"name":"","type":"address","internalType":"address"}],"stateMutability":"view"},{"type":"function","name":"ethLockboxProxy","inputs":[],"outputs":[{"name":"","type":"address","internalType":"address"}],"stateMutability":"view"},{"type":"function","name":"faultDisputeGameImpl","inputs":[],"outputs":[{"name":"","type":"address","internalType":"address"}],"stateMutability":"view"},{"type":"function","name":"l1CrossDomainMessengerProxy","inputs":[],"outputs":[{"name":"","type":"address","internalType":"address"}],"stateMutability":"view"},{"type":"function","name":"l1Erc721BridgeProxy","inputs":[],"outputs":[{"name":"","type":"address","internalType":"address"}],"stateMutability":"view"},{"type":"function","name":"l1StandardBridgeProxy","inputs":[],"outputs":[{"name":"","type":"address","internalType":"address"}],"stateMutability":"view"},{"type":"function","name":"l2OutputOracleProxy","inputs":[],"outputs":[{"name":"","type":"address","internalType":"address"}],"stateMutability":"view"},{"type":"function","name":"mipsImpl","inputs":[],"outputs":[{"name":"","type":"address","internalType":"address"}],"stateMutability":"view"},{"type":"function","name":"opChainGuardian","inputs":[],"outputs":[{"name":"","type":"address","internalType":"address"}],"stateMutability":"view"},{"type":"function","name":"opChainProxyAdminImpl","inputs":[],"outputs":[{"name":"","type":"address","internalType":"address"}],"stateMutability":"view"},{"type":"function","name":"opChainProxyAdminOwner","inputs":[],"outputs":[{"name":"","type":"address","internalType":"address"}],"stateMutability":"view"},{"type":"function","name":"optimismMintableErc20FactoryProxy","inputs":[],"outputs":[{"name":"","type":"address","internalType":"address"}],"stateMutability":"view"},{"type":"function","name":"optimismPortalProxy","inputs":[],"outputs":[{"name":"","type":"address","internalType":"address"}],"stateMutability":"view"},{"type":"function","name":"permissioned","inputs":[],"outputs":[{"name":"","type":"bool","internalType":"bool"}],"stateMutability":"view"},{"type":"function","name":"permissionedDisputeGameImpl","inputs":[],"outputs":[{"name":"","type":"address","internalType":"address"}],"stateMutability":"view"},{"type":"function","name":"permissionless","inputs":[],"outputs":[{"name":"","type":"bool","internalType":"bool"}],"stateMutability":"view"},{"type":"function","name":"preimageOracleImpl","inputs":[],"outputs":[{"name":"","type":"address","internalType":"address"}],"stateMutability":"view"},{"type":"function","name":"proposer","inputs":[],"outputs":[{"name":"","type":"address","internalType":"address"}],"stateMutability":"view"},{"type":"function","name":"respectedGameType","inputs":[],"outputs":[{"name":"","type":"uint32","internalType":"GameType"}],"stateMutability":"view"},{"type":"function","name":"set","inputs":[{"name":"_sel","type":"bytes4","internalType":"bytes4"},{"name":"_bool","type":"bool","internalType":"bool"}],"outputs":[],"stateMutability":"nonpayable"},{"type":"function","name":"set","inputs":[{"name":"_sel","type":"bytes4","internalType":"bytes4"},{"name":"_addr","type":"address","internalType":"address"}],"outputs":[],"stateMutability":"nonpayable"},{"type":"function","name":"set","inputs":[{"name":"_sel","type":"bytes4","internalType":"bytes4"},{"name":"_gameType","type":"uint32","internalType":"GameType"}],"outputs":[],"stateMutability":"nonpayable"},{"type":"function","name":"superchainConfigProxy","inputs":[],"outputs":[{"name":"","type":"address","internalType":"address"}],"stateMutability":"view"},{"type":"function","name":"systemConfigOwner","inputs":[],"outputs":[{"name":"","type":"address","internalType":"address"}],"stateMutability":"view"},{"type":"function","name":"systemConfigProxy","inputs":[],"outputs":[{"name":"","type":"address","internalType":"address"}],"stateMutability":"view"},{"type":"function","name":"unsafeBlockSigner","inputs":[],"outputs":[{"name":"","type":"address","internalType":"address"}],"stateMutability":"view"}],"bytecode":{"object":"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","sourceMap":"2957:10181:120:-:0;;;;;;;;;;;;;;;;;;;","linkReferences":{}},"deployedBytecode":{"object":"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","sourceMap":"2957:10181:120:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;9077:211;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;8328:219;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;11652:223;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;11443:203;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;12436;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;9953:231;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;13034:102;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;12842:88;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;11881:195;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;12082:175;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;7862:243;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;9503:219;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;10468:113;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;10190:131;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;9728:219;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;8770:301;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;10327:135;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;10981:243;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;12936:92;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;8553:211;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;12263:167;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;7046:271;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;7546:207;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;9294:203;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;4406:2634;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;11230:207;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;7323:217;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;10587:215;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;10808:167;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;8111:211;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;7759:97;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;12645:191;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;9077:211;9129:7;9188:1;9156:34;;:20;;;;;;;;;;;:34;;;9148:96;;;;;;;;;;;;:::i;:::-;;;;;;;;;9261:20;;;;;;;;;;;9254:27;;9077:211;:::o;8328:219::-;8382:7;8443:1;8409:36;;:22;;;;;;;;;;;:36;;;8401:100;;;;;;;;;;;;:::i;:::-;;;;;;;;;8518:22;;;;;;;;;;;8511:29;;8328:219;:::o;11652:223::-;11707:7;11769:1;11734:37;;:23;;;;;;;;;;;:37;;;11726:102;;;;;;;;;;;;:::i;:::-;;;;;;;;;11845:23;;;;;;;;;;;11838:30;;11652:223;:::o;11443:203::-;11493:7;11550:1;11520:32;;:18;;;;;;;;;;;:32;;;11512:92;;;;;;;;;;;;:::i;:::-;;;;;;;;;11621:18;;;;;;;;;;;11614:25;;11443:203;:::o;12436:::-;12486:7;12543:1;12513:32;;:18;;;;;;;;;;;:32;;;12505:92;;;;;;;;;;;;:::i;:::-;;;;;;;;;12614:18;;;;;;;;;;;12607:25;;12436:203;:::o;9953:231::-;10010:7;10074:1;10037:39;;:25;;;;;;;;;;;:39;;;10029:106;;;;;;;;;;;;:::i;:::-;;;;;;;;;10152:25;;;;;;;;;;;10145:32;;9953:231;:::o;13034:102::-;13084:8;13111:18;;;;;;;;;;;13104:25;;13034:102;:::o;12842:88::-;12887:4;12910:13;;;;;;;;;;;12903:20;;12842:88;:::o;11881:195::-;11929:7;11984:1;11956:30;;:16;;;;;;;;;;;:30;;;11948:88;;;;;;;;;;;;:::i;:::-;;;;;;;;;12053:16;;;;;;;;;;;12046:23;;11881:195;:::o;12082:175::-;12125:7;12175:1;12152:25;;:11;;;;;;;;;;;:25;;;12144:78;;;;;;;;;;;;:::i;:::-;;;;;;;;;12239:11;;;;;;;;;;;12232:18;;12082:175;:::o;7862:243::-;7922:7;7989:1;7949:42;;:28;;;;;;;;;;;:42;;;7941:112;;;;;;;;;;;;:::i;:::-;;;;;;;;;8070:28;;;;;;;;;;;8063:35;;7862:243;:::o;9503:219::-;9557:7;9618:1;9584:36;;:22;;;;;;;;;;;:36;;;9576:100;;;;;;;;;;;;:::i;:::-;;;;;;;;;9693:22;;;;;;;;;;;9686:29;;9503:219;:::o;10468:113::-;10524:7;10550:24;;;;;;;;;;;10543:31;;10468:113;:::o;10190:131::-;10255:7;10281:33;;;;;;;;;;;10274:40;;10190:131;:::o;9728:219::-;9782:7;9843:1;9809:36;;:22;;;;;;;;;;:36;;;9801:100;;;;;;;;;;;;:::i;:::-;;;;;;;;;9918:22;;;;;;;;;;9911:29;;9728:219;:::o;8770:301::-;8836:7;8922:1;8876:48;;:34;;;;;;;;;;;:48;;;8855:158;;;;;;;;;;;;:::i;:::-;;;;;;;;;9030:34;;;;;;;;;;;9023:41;;8770:301;:::o;10327:135::-;10394:7;10420:35;;;;;;;;;;;10413:42;;10327:135;:::o;10981:243::-;11041:7;11108:1;11068:42;;:28;;;;;;;;;;;:42;;;11060:112;;;;;;;;;;;;:::i;:::-;;;;;;;;;11189:28;;;;;;;;;;;11182:35;;10981:243;:::o;12936:92::-;12983:4;13006:15;;;;;;;;;;;12999:22;;12936:92;:::o;8553:211::-;8605:7;8664:1;8632:34;;:20;;;;;;;;;;;:34;;;8624:96;;;;;;;;;;;;:::i;:::-;;;;;;;;;8737:20;;;;;;;;;;;8730:27;;8553:211;:::o;12263:167::-;12304:7;12352:1;12331:23;;:9;;;;;;;;;;;:23;;;12323:74;;;;;;;;;;;;:::i;:::-;;;;;;;;;12414:9;;;;;;;;;;;12407:16;;12263:167;:::o;7046:271::-;7113:26;;;7105:34;;;:4;:34;;;;7101:209;;7157:5;7141:13;;:21;;;;;;;;;;;;;;;;;;7101:209;;;7189:28;;;7181:36;;;:4;:36;;;;7177:133;;7237:5;7219:15;;:23;;;;;;;;;;;;;;;;;;7177:133;;;7257:53;;;;;;;;;;:::i;:::-;;;;;;;;7177:133;7101:209;7046:271;;:::o;7546:207::-;7597:7;7655:1;7624:33;;:19;;;;;;;;;;;:33;;;7616:94;;;;;;;;;;;;:::i;:::-;;;;;;;;;7727:19;;;;;;;;;;;7720:26;;7546:207;:::o;9294:203::-;9344:7;9401:1;9371:32;;:18;;;;;;;;;;;:32;;;9363:92;;;;;;;;;;;;:::i;:::-;;;;;;;;;9472:18;;;;;;;;;;;9465:25;;9294:203;:::o;4406:2634::-;4507:35;;;4499:43;;;:4;:43;;;;4495:2538;;4569:5;4544:22;;:30;;;;;;;;;;;;;;;;;;4495:2538;;;4640:22;;;4632:30;;;:4;:30;;;;4628:2405;;4676:5;4664:9;;:17;;;;;;;;;;;;;;;;;;4628:2405;;;4708:32;;;4700:40;;;:4;:40;;;;4696:2337;;4764:5;4742:19;;:27;;;;;;;;;;;;;;;;;;4696:2337;;;4827:32;;;4819:40;;;:4;:40;;;;4815:2218;;4883:5;4861:19;;:27;;;;;;;;;;;;;;;;;;4815:2218;;;4915:29;;;4907:37;;;:4;:37;;;;4903:2130;;4965:5;4946:16;;:24;;;;;;;;;;;;;;;;;;4903:2130;;;4997:41;;;4989:49;;;:4;:49;;;;4985:2048;;5071:5;5040:28;;:36;;;;;;;;;;;;;;;;;;4985:2048;;;5103:33;;;5095:41;;;:4;:41;;;;5091:1942;;5161:5;5138:20;;:28;;;;;;;;;;;;;;;;;;5091:1942;;;5193:35;;;5185:43;;;:4;:43;;;;5181:1852;;5255:5;5230:22;;:30;;;;;;;;;;;;;;;;;;5181:1852;;;5287:33;;;5279:41;;;:4;:41;;;;5275:1758;;5345:5;5322:20;;:28;;;;;;;;;;;;;;;;;;5275:1758;;;5377:47;;;5369:55;;;:4;:55;;;;5365:1668;;5463:5;5426:34;;:42;;;;;;;;;;;;;;;;;;5365:1668;;;5495:33;;;5487:41;;;:4;:41;;;;5483:1550;;5553:5;5530:20;;:28;;;;;;;;;;;;;;;;;;5483:1550;;;5585:31;;;5577:39;;;:4;:39;;;;5573:1460;;5639:5;5618:18;;:26;;;;;;;;;;;;;;;;;;5573:1460;;;5671:35;;;5663:43;;;:4;:43;;;;5659:1374;;5733:5;5708:22;;:30;;;;;;;;;;;;;;;;;;5659:1374;;;5765:38;;;5757:46;;;:4;:46;;;;5753:1280;;5833:5;5805:25;;:33;;;;;;;;;;;;;;;;;;5753:1280;;;5865:46;;;5857:54;;;:4;:54;;;;5853:1180;;5949:5;5913:33;;:41;;;;;;;;;;;;;;;;;;5853:1180;;;5981:48;;;5973:56;;;:4;:56;;;;5969:1064;;6069:5;6031:35;;:43;;;;;;;;;;;;;;;;;;5969:1064;;;6101:37;;;6093:45;;;:4;:45;;;;6089:944;;6167:5;6140:24;;:32;;;;;;;;;;;;;;;;;;6089:944;;;6199:34;;;6191:42;;;:4;:42;;;;6187:846;;6259:5;6235:21;;:29;;;;;;;;;;;;;;;;;;6187:846;;;6291:41;;;6283:49;;;:4;:49;;;;6279:754;;6365:5;6334:28;;:36;;;;;;;;;;;;;;;;;;6279:754;;;6414:31;;;6406:39;;;:4;:39;;;;6402:631;;6468:5;6447:18;;:26;;;;;;;;;;;;;;;;;;6402:631;;;6500:36;;;6492:44;;;:4;:44;;;;6488:545;;6564:5;6538:23;;:31;;;;;;;;;;;;;;;;;;6488:545;;;6596:29;;;6588:37;;;:4;:37;;;;6584:449;;6646:5;6627:16;;:24;;;;;;;;;;;;;;;;;;6584:449;;;6678:24;;;6670:32;;;:4;:32;;;;6666:367;;6718:5;6704:11;;:19;;;;;;;;;;;;;;;;;;6666:367;;;6750:22;;;6742:30;;;:4;:30;;;;6738:295;;6786:5;6774:9;;:17;;;;;;;;;;;;;;;;;;6738:295;;;6818:31;;;6810:39;;;:4;:39;;;;6806:227;;6872:5;6851:18;;:26;;;;;;;;;;;;;;;;;;6806:227;;;6904:28;;;6896:36;;;:4;:36;;;;6892:141;;6952:5;6934:15;;:23;;;;;;;;;;;;;;;;;;6892:141;;;6972:61;;;;;;;;;;:::i;:::-;;;;;;;;6892:141;6806:227;6738:295;6666:367;6584:449;6488:545;6402:631;6279:754;6187:846;6089:944;5969:1064;5853:1180;5753:1280;5659:1374;5573:1460;5483:1550;5365:1668;5275:1758;5181:1852;5091:1942;4985:2048;4903:2130;4815:2218;4696:2337;4628:2405;4495:2538;4406:2634;;:::o;11230:207::-;11281:7;11339:1;11308:33;;:19;;;;;;;;;;;:33;;;11300:94;;;;;;;;;;;;:::i;:::-;;;;;;;;;11411:19;;;;;;;;;;;11404:26;;11230:207;:::o;7323:217::-;7398:31;;;7390:39;;;:4;:39;;;;7386:147;;7452:9;7431:18;;:30;;;;;;;;;;;;;;;;;;7386:147;;;7476:57;;;;;;;;;;:::i;:::-;;;;;;;;7386:147;7323:217;;:::o;10587:215::-;10640:7;10700:1;10667:35;;:21;;;;;;;;;;;:35;;;10659:98;;;;;;;;;;;;:::i;:::-;;;;;;;;;10774:21;;;;;;;;;;;10767:28;;10587:215;:::o;10808:167::-;10849:7;10897:1;10876:23;;:9;;;;;;;;;;;:23;;;10868:74;;;;;;;;;;;;:::i;:::-;;;;;;;;;10959:9;;;;;;;;;;;10952:16;;10808:167;:::o;8111:211::-;8163:7;8222:1;8190:34;;:20;;;;;;;;;;;:34;;;8182:96;;;;;;;;;;;;:::i;:::-;;;;;;;;;8295:20;;;;;;;;;;;8288:27;;8111:211;:::o;7759:97::-;7807:7;7833:16;;;;;;;;;;;7826:23;;7759:97;:::o;12645:191::-;12692:7;12746:1;12719:29;;:15;;;;;;;;;;;:29;;;12711:86;;;;;;;;;;;;:::i;:::-;;;;;;;;;12814:15;;;;;;;;;;;12807:22;;12645:191;:::o;7:126:207:-;44:7;84:42;77:5;73:54;62:65;;7:126;;;:::o;139:96::-;176:7;205:24;223:5;205:24;:::i;:::-;194:35;;139:96;;;:::o;241:118::-;328:24;346:5;328:24;:::i;:::-;323:3;316:37;241:118;;:::o;365:222::-;458:4;496:2;485:9;481:18;473:26;;509:71;577:1;566:9;562:17;553:6;509:71;:::i;:::-;365:222;;;;:::o;593:93::-;629:7;669:10;662:5;658:22;647:33;;593:93;;;:::o;692:60::-;720:3;741:5;734:12;;692:60;;;:::o;758:138::-;806:9;839:51;856:33;865:23;882:5;865:23;:::i;:::-;856:33;:::i;:::-;839:51;:::i;:::-;826:64;;758:138;;;:::o;902:158::-;1018:35;1047:5;1018:35;:::i;:::-;1013:3;1006:48;902:158;;:::o;1066:280::-;1188:4;1226:2;1215:9;1211:18;1203:26;;1239:100;1336:1;1325:9;1321:17;1312:6;1239:100;:::i;:::-;1066:280;;;;:::o;1352:90::-;1386:7;1429:5;1422:13;1415:21;1404:32;;1352:90;;;:::o;1448:109::-;1529:21;1544:5;1529:21;:::i;:::-;1524:3;1517:34;1448:109;;:::o;1563:210::-;1650:4;1688:2;1677:9;1673:18;1665:26;;1701:65;1763:1;1752:9;1748:17;1739:6;1701:65;:::i;:::-;1563:210;;;;:::o;1860:117::-;1969:1;1966;1959:12;2106:149;2142:7;2182:66;2175:5;2171:78;2160:89;;2106:149;;;:::o;2261:120::-;2333:23;2350:5;2333:23;:::i;:::-;2326:5;2323:34;2313:62;;2371:1;2368;2361:12;2313:62;2261:120;:::o;2387:137::-;2432:5;2470:6;2457:20;2448:29;;2486:32;2512:5;2486:32;:::i;:::-;2387:137;;;;:::o;2530:116::-;2600:21;2615:5;2600:21;:::i;:::-;2593:5;2590:32;2580:60;;2636:1;2633;2626:12;2580:60;2530:116;:::o;2652:133::-;2695:5;2733:6;2720:20;2711:29;;2749:30;2773:5;2749:30;:::i;:::-;2652:133;;;;:::o;2791:466::-;2855:6;2863;2912:2;2900:9;2891:7;2887:23;2883:32;2880:119;;;2918:79;;:::i;:::-;2880:119;3038:1;3063:52;3107:7;3098:6;3087:9;3083:22;3063:52;:::i;:::-;3053:62;;3009:116;3164:2;3190:50;3232:7;3223:6;3212:9;3208:22;3190:50;:::i;:::-;3180:60;;3135:115;2791:466;;;;;:::o;3263:122::-;3336:24;3354:5;3336:24;:::i;:::-;3329:5;3326:35;3316:63;;3375:1;3372;3365:12;3316:63;3263:122;:::o;3391:139::-;3437:5;3475:6;3462:20;3453:29;;3491:33;3518:5;3491:33;:::i;:::-;3391:139;;;;:::o;3536:472::-;3603:6;3611;3660:2;3648:9;3639:7;3635:23;3631:32;3628:119;;;3666:79;;:::i;:::-;3628:119;3786:1;3811:52;3855:7;3846:6;3835:9;3831:22;3811:52;:::i;:::-;3801:62;;3757:116;3912:2;3938:53;3983:7;3974:6;3963:9;3959:22;3938:53;:::i;:::-;3928:63;;3883:118;3536:472;;;;;:::o;4014:151::-;4117:23;4134:5;4117:23;:::i;:::-;4110:5;4107:34;4097:62;;4155:1;4152;4145:12;4097:62;4014:151;:::o;4171:199::-;4247:5;4285:6;4272:20;4263:29;;4301:63;4358:5;4301:63;:::i;:::-;4171:199;;;;:::o;4376:532::-;4473:6;4481;4530:2;4518:9;4509:7;4505:23;4501:32;4498:119;;;4536:79;;:::i;:::-;4498:119;4656:1;4681:52;4725:7;4716:6;4705:9;4701:22;4681:52;:::i;:::-;4671:62;;4627:116;4782:2;4808:83;4883:7;4874:6;4863:9;4859:22;4808:83;:::i;:::-;4798:93;;4753:148;4376:532;;;;;:::o;4914:169::-;4998:11;5032:6;5027:3;5020:19;5072:4;5067:3;5063:14;5048:29;;4914:169;;;;:::o;5089:236::-;5229:34;5225:1;5217:6;5213:14;5206:58;5298:19;5293:2;5285:6;5281:15;5274:44;5089:236;:::o;5331:366::-;5473:3;5494:67;5558:2;5553:3;5494:67;:::i;:::-;5487:74;;5570:93;5659:3;5570:93;:::i;:::-;5688:2;5683:3;5679:12;5672:19;;5331:366;;;:::o;5703:419::-;5869:4;5907:2;5896:9;5892:18;5884:26;;5956:9;5950:4;5946:20;5942:1;5931:9;5927:17;5920:47;5984:131;6110:4;5984:131;:::i;:::-;5976:139;;5703:419;;;:::o;6128:238::-;6268:34;6264:1;6256:6;6252:14;6245:58;6337:21;6332:2;6324:6;6320:15;6313:46;6128:238;:::o;6372:366::-;6514:3;6535:67;6599:2;6594:3;6535:67;:::i;:::-;6528:74;;6611:93;6700:3;6611:93;:::i;:::-;6729:2;6724:3;6720:12;6713:19;;6372:366;;;:::o;6744:419::-;6910:4;6948:2;6937:9;6933:18;6925:26;;6997:9;6991:4;6987:20;6983:1;6972:9;6968:17;6961:47;7025:131;7151:4;7025:131;:::i;:::-;7017:139;;6744:419;;;:::o;7169:239::-;7309:34;7305:1;7297:6;7293:14;7286:58;7378:22;7373:2;7365:6;7361:15;7354:47;7169:239;:::o;7414:366::-;7556:3;7577:67;7641:2;7636:3;7577:67;:::i;:::-;7570:74;;7653:93;7742:3;7653:93;:::i;:::-;7771:2;7766:3;7762:12;7755:19;;7414:366;;;:::o;7786:419::-;7952:4;7990:2;7979:9;7975:18;7967:26;;8039:9;8033:4;8029:20;8025:1;8014:9;8010:17;8003:47;8067:131;8193:4;8067:131;:::i;:::-;8059:139;;7786:419;;;:::o;8211:234::-;8351:34;8347:1;8339:6;8335:14;8328:58;8420:17;8415:2;8407:6;8403:15;8396:42;8211:234;:::o;8451:366::-;8593:3;8614:67;8678:2;8673:3;8614:67;:::i;:::-;8607:74;;8690:93;8779:3;8690:93;:::i;:::-;8808:2;8803:3;8799:12;8792:19;;8451:366;;;:::o;8823:419::-;8989:4;9027:2;9016:9;9012:18;9004:26;;9076:9;9070:4;9066:20;9062:1;9051:9;9047:17;9040:47;9104:131;9230:4;9104:131;:::i;:::-;9096:139;;8823:419;;;:::o;9248:234::-;9388:34;9384:1;9376:6;9372:14;9365:58;9457:17;9452:2;9444:6;9440:15;9433:42;9248:234;:::o;9488:366::-;9630:3;9651:67;9715:2;9710:3;9651:67;:::i;:::-;9644:74;;9727:93;9816:3;9727:93;:::i;:::-;9845:2;9840:3;9836:12;9829:19;;9488:366;;;:::o;9860:419::-;10026:4;10064:2;10053:9;10049:18;10041:26;;10113:9;10107:4;10103:20;10099:1;10088:9;10084:17;10077:47;10141:131;10267:4;10141:131;:::i;:::-;10133:139;;9860:419;;;:::o;10285:241::-;10425:34;10421:1;10413:6;10409:14;10402:58;10494:24;10489:2;10481:6;10477:15;10470:49;10285:241;:::o;10532:366::-;10674:3;10695:67;10759:2;10754:3;10695:67;:::i;:::-;10688:74;;10771:93;10860:3;10771:93;:::i;:::-;10889:2;10884:3;10880:12;10873:19;;10532:366;;;:::o;10904:419::-;11070:4;11108:2;11097:9;11093:18;11085:26;;11157:9;11151:4;11147:20;11143:1;11132:9;11128:17;11121:47;11185:131;11311:4;11185:131;:::i;:::-;11177:139;;10904:419;;;:::o;11329:232::-;11469:34;11465:1;11457:6;11453:14;11446:58;11538:15;11533:2;11525:6;11521:15;11514:40;11329:232;:::o;11567:366::-;11709:3;11730:67;11794:2;11789:3;11730:67;:::i;:::-;11723:74;;11806:93;11895:3;11806:93;:::i;:::-;11924:2;11919:3;11915:12;11908:19;;11567:366;;;:::o;11939:419::-;12105:4;12143:2;12132:9;12128:18;12120:26;;12192:9;12186:4;12182:20;12178:1;12167:9;12163:17;12156:47;12220:131;12346:4;12220:131;:::i;:::-;12212:139;;11939:419;;;:::o;12364:227::-;12504:34;12500:1;12492:6;12488:14;12481:58;12573:10;12568:2;12560:6;12556:15;12549:35;12364:227;:::o;12597:366::-;12739:3;12760:67;12824:2;12819:3;12760:67;:::i;:::-;12753:74;;12836:93;12925:3;12836:93;:::i;:::-;12954:2;12949:3;12945:12;12938:19;;12597:366;;;:::o;12969:419::-;13135:4;13173:2;13162:9;13158:18;13150:26;;13222:9;13216:4;13212:20;13208:1;13197:9;13193:17;13186:47;13250:131;13376:4;13250:131;:::i;:::-;13242:139;;12969:419;;;:::o;13394:244::-;13534:34;13530:1;13522:6;13518:14;13511:58;13603:27;13598:2;13590:6;13586:15;13579:52;13394:244;:::o;13644:366::-;13786:3;13807:67;13871:2;13866:3;13807:67;:::i;:::-;13800:74;;13883:93;13972:3;13883:93;:::i;:::-;14001:2;13996:3;13992:12;13985:19;;13644:366;;;:::o;14016:419::-;14182:4;14220:2;14209:9;14205:18;14197:26;;14269:9;14263:4;14259:20;14255:1;14244:9;14240:17;14233:47;14297:131;14423:4;14297:131;:::i;:::-;14289:139;;14016:419;;;:::o;14441:238::-;14581:34;14577:1;14569:6;14565:14;14558:58;14650:21;14645:2;14637:6;14633:15;14626:46;14441:238;:::o;14685:366::-;14827:3;14848:67;14912:2;14907:3;14848:67;:::i;:::-;14841:74;;14924:93;15013:3;14924:93;:::i;:::-;15042:2;15037:3;15033:12;15026:19;;14685:366;;;:::o;15057:419::-;15223:4;15261:2;15250:9;15246:18;15238:26;;15310:9;15304:4;15300:20;15296:1;15285:9;15281:17;15274:47;15338:131;15464:4;15338:131;:::i;:::-;15330:139;;15057:419;;;:::o;15482:238::-;15622:34;15618:1;15610:6;15606:14;15599:58;15691:21;15686:2;15678:6;15674:15;15667:46;15482:238;:::o;15726:366::-;15868:3;15889:67;15953:2;15948:3;15889:67;:::i;:::-;15882:74;;15965:93;16054:3;15965:93;:::i;:::-;16083:2;16078:3;16074:12;16067:19;;15726:366;;;:::o;16098:419::-;16264:4;16302:2;16291:9;16287:18;16279:26;;16351:9;16345:4;16341:20;16337:1;16326:9;16322:17;16315:47;16379:131;16505:4;16379:131;:::i;:::-;16371:139;;16098:419;;;:::o;16523:250::-;16663:34;16659:1;16651:6;16647:14;16640:58;16732:33;16727:2;16719:6;16715:15;16708:58;16523:250;:::o;16779:366::-;16921:3;16942:67;17006:2;17001:3;16942:67;:::i;:::-;16935:74;;17018:93;17107:3;17018:93;:::i;:::-;17136:2;17131:3;17127:12;17120:19;;16779:366;;;:::o;17151:419::-;17317:4;17355:2;17344:9;17340:18;17332:26;;17404:9;17398:4;17394:20;17390:1;17379:9;17375:17;17368:47;17432:131;17558:4;17432:131;:::i;:::-;17424:139;;17151:419;;;:::o;17576:244::-;17716:34;17712:1;17704:6;17700:14;17693:58;17785:27;17780:2;17772:6;17768:15;17761:52;17576:244;:::o;17826:366::-;17968:3;17989:67;18053:2;18048:3;17989:67;:::i;:::-;17982:74;;18065:93;18154:3;18065:93;:::i;:::-;18183:2;18178:3;18174:12;18167:19;;17826:366;;;:::o;18198:419::-;18364:4;18402:2;18391:9;18387:18;18379:26;;18451:9;18445:4;18441:20;18437:1;18426:9;18422:17;18415:47;18479:131;18605:4;18479:131;:::i;:::-;18471:139;;18198:419;;;:::o;18623:236::-;18763:34;18759:1;18751:6;18747:14;18740:58;18832:19;18827:2;18819:6;18815:15;18808:44;18623:236;:::o;18865:366::-;19007:3;19028:67;19092:2;19087:3;19028:67;:::i;:::-;19021:74;;19104:93;19193:3;19104:93;:::i;:::-;19222:2;19217:3;19213:12;19206:19;;18865:366;;;:::o;19237:419::-;19403:4;19441:2;19430:9;19426:18;19418:26;;19490:9;19484:4;19480:20;19476:1;19465:9;19461:17;19454:47;19518:131;19644:4;19518:131;:::i;:::-;19510:139;;19237:419;;;:::o;19662:225::-;19802:34;19798:1;19790:6;19786:14;19779:58;19871:8;19866:2;19858:6;19854:15;19847:33;19662:225;:::o;19893:366::-;20035:3;20056:67;20120:2;20115:3;20056:67;:::i;:::-;20049:74;;20132:93;20221:3;20132:93;:::i;:::-;20250:2;20245:3;20241:12;20234:19;;19893:366;;;:::o;20265:419::-;20431:4;20469:2;20458:9;20454:18;20446:26;;20518:9;20512:4;20508:20;20504:1;20493:9;20489:17;20482:47;20546:131;20672:4;20546:131;:::i;:::-;20538:139;;20265:419;;;:::o;20690:230::-;20830:34;20826:1;20818:6;20814:14;20807:58;20899:13;20894:2;20886:6;20882:15;20875:38;20690:230;:::o;20926:366::-;21068:3;21089:67;21153:2;21148:3;21089:67;:::i;:::-;21082:74;;21165:93;21254:3;21165:93;:::i;:::-;21283:2;21278:3;21274:12;21267:19;;20926:366;;;:::o;21298:419::-;21464:4;21502:2;21491:9;21487:18;21479:26;;21551:9;21545:4;21541:20;21537:1;21526:9;21522:17;21515:47;21579:131;21705:4;21579:131;:::i;:::-;21571:139;;21298:419;;;:::o;21723:235::-;21863:34;21859:1;21851:6;21847:14;21840:58;21932:18;21927:2;21919:6;21915:15;21908:43;21723:235;:::o;21964:366::-;22106:3;22127:67;22191:2;22186:3;22127:67;:::i;:::-;22120:74;;22203:93;22292:3;22203:93;:::i;:::-;22321:2;22316:3;22312:12;22305:19;;21964:366;;;:::o;22336:419::-;22502:4;22540:2;22529:9;22525:18;22517:26;;22589:9;22583:4;22579:20;22575:1;22564:9;22560:17;22553:47;22617:131;22743:4;22617:131;:::i;:::-;22609:139;;22336:419;;;:::o;22761:234::-;22901:34;22897:1;22889:6;22885:14;22878:58;22970:17;22965:2;22957:6;22953:15;22946:42;22761:234;:::o;23001:366::-;23143:3;23164:67;23228:2;23223:3;23164:67;:::i;:::-;23157:74;;23240:93;23329:3;23240:93;:::i;:::-;23358:2;23353:3;23349:12;23342:19;;23001:366;;;:::o;23373:419::-;23539:4;23577:2;23566:9;23562:18;23554:26;;23626:9;23620:4;23616:20;23612:1;23601:9;23597:17;23590:47;23654:131;23780:4;23654:131;:::i;:::-;23646:139;;23373:419;;;:::o;23798:238::-;23938:34;23934:1;23926:6;23922:14;23915:58;24007:21;24002:2;23994:6;23990:15;23983:46;23798:238;:::o;24042:366::-;24184:3;24205:67;24269:2;24264:3;24205:67;:::i;:::-;24198:74;;24281:93;24370:3;24281:93;:::i;:::-;24399:2;24394:3;24390:12;24383:19;;24042:366;;;:::o;24414:419::-;24580:4;24618:2;24607:9;24603:18;24595:26;;24667:9;24661:4;24657:20;24653:1;24642:9;24638:17;24631:47;24695:131;24821:4;24695:131;:::i;:::-;24687:139;;24414:419;;;:::o;24839:235::-;24979:34;24975:1;24967:6;24963:14;24956:58;25048:18;25043:2;25035:6;25031:15;25024:43;24839:235;:::o;25080:366::-;25222:3;25243:67;25307:2;25302:3;25243:67;:::i;:::-;25236:74;;25319:93;25408:3;25319:93;:::i;:::-;25437:2;25432:3;25428:12;25421:19;;25080:366;;;:::o;25452:419::-;25618:4;25656:2;25645:9;25641:18;25633:26;;25705:9;25699:4;25695:20;25691:1;25680:9;25676:17;25669:47;25733:131;25859:4;25733:131;:::i;:::-;25725:139;;25452:419;;;:::o;25877:234::-;26017:34;26013:1;26005:6;26001:14;25994:58;26086:17;26081:2;26073:6;26069:15;26062:42;25877:234;:::o;26117:366::-;26259:3;26280:67;26344:2;26339:3;26280:67;:::i;:::-;26273:74;;26356:93;26445:3;26356:93;:::i;:::-;26474:2;26469:3;26465:12;26458:19;;26117:366;;;:::o;26489:419::-;26655:4;26693:2;26682:9;26678:18;26670:26;;26742:9;26736:4;26732:20;26728:1;26717:9;26713:17;26706:47;26770:131;26896:4;26770:131;:::i;:::-;26762:139;;26489:419;;;:::o;26914:237::-;27054:34;27050:1;27042:6;27038:14;27031:58;27123:20;27118:2;27110:6;27106:15;27099:45;26914:237;:::o;27157:366::-;27299:3;27320:67;27384:2;27379:3;27320:67;:::i;:::-;27313:74;;27396:93;27485:3;27396:93;:::i;:::-;27514:2;27509:3;27505:12;27498:19;;27157:366;;;:::o;27529:419::-;27695:4;27733:2;27722:9;27718:18;27710:26;;27782:9;27776:4;27772:20;27768:1;27757:9;27753:17;27746:47;27810:131;27936:4;27810:131;:::i;:::-;27802:139;;27529:419;;;:::o;27954:225::-;28094:34;28090:1;28082:6;28078:14;28071:58;28163:8;28158:2;28150:6;28146:15;28139:33;27954:225;:::o;28185:366::-;28327:3;28348:67;28412:2;28407:3;28348:67;:::i;:::-;28341:74;;28424:93;28513:3;28424:93;:::i;:::-;28542:2;28537:3;28533:12;28526:19;;28185:366;;;:::o;28557:419::-;28723:4;28761:2;28750:9;28746:18;28738:26;;28810:9;28804:4;28800:20;28796:1;28785:9;28781:17;28774:47;28838:131;28964:4;28838:131;:::i;:::-;28830:139;;28557:419;;;:::o;28982:236::-;29122:34;29118:1;29110:6;29106:14;29099:58;29191:19;29186:2;29178:6;29174:15;29167:44;28982:236;:::o;29224:366::-;29366:3;29387:67;29451:2;29446:3;29387:67;:::i;:::-;29380:74;;29463:93;29552:3;29463:93;:::i;:::-;29581:2;29576:3;29572:12;29565:19;;29224:366;;;:::o;29596:419::-;29762:4;29800:2;29789:9;29785:18;29777:26;;29849:9;29843:4;29839:20;29835:1;29824:9;29820:17;29813:47;29877:131;30003:4;29877:131;:::i;:::-;29869:139;;29596:419;;;:::o;30021:231::-;30161:34;30157:1;30149:6;30145:14;30138:58;30230:14;30225:2;30217:6;30213:15;30206:39;30021:231;:::o;30258:366::-;30400:3;30421:67;30485:2;30480:3;30421:67;:::i;:::-;30414:74;;30497:93;30586:3;30497:93;:::i;:::-;30615:2;30610:3;30606:12;30599:19;;30258:366;;;:::o;30630:419::-;30796:4;30834:2;30823:9;30819:18;30811:26;;30883:9;30877:4;30873:20;30869:1;30858:9;30854:17;30847:47;30911:131;31037:4;30911:131;:::i;:::-;30903:139;;30630:419;;;:::o","linkReferences":{}},"methodIdentifiers":{"addressManagerImpl()":"bd366b8f","anchorStateRegistryProxy()":"35596f76","batchSubmitter()":"fb951e9d","challenger()":"534db0e2","delayedWethPermissionedGameProxy()":"794836d7","delayedWethPermissionlessGameProxy()":"97068797","disputeGameFactoryProxy()":"6c4568d1","ethLockboxProxy()":"f646b07c","faultDisputeGameImpl()":"dea21984","l1CrossDomainMessengerProxy()":"54729cfb","l1Erc721BridgeProxy()":"ebfa8409","l1StandardBridgeProxy()":"102b6069","l2OutputOracleProxy()":"a2c9a89f","mipsImpl()":"e303272c","opChainGuardian()":"4bc2695f","opChainProxyAdminImpl()":"5643665f","opChainProxyAdminOwner()":"1480f0cc","optimismMintableErc20FactoryProxy()":"8f20c7e4","optimismPortalProxy()":"04451c49","permissioned()":"3cc162f1","permissionedDisputeGameImpl()":"98ccec3e","permissionless()":"a1256f9f","preimageOracleImpl()":"d030d2e8","proposer()":"a8e4fb90","respectedGameType()":"3c9f397c","set(bytes4,address)":"c3e39250","set(bytes4,bool)":"baa1e15e","set(bytes4,uint32)":"d08d6066","superchainConfigProxy()":"84cf2c97","systemConfigOwner()":"1e229b20","systemConfigProxy()":"c17db6e3","unsafeBlockSigner()":"1fd19ee1"},"rawMetadata":"{\"compiler\":{\"version\":\"0.8.25+commit.b61c2a91\"},\"language\":\"Solidity\",\"output\":{\"abi\":[{\"inputs\":[],\"name\":\"addressManagerImpl\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"anchorStateRegistryProxy\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"batchSubmitter\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"challenger\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"delayedWethPermissionedGameProxy\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"delayedWethPermissionlessGameProxy\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"disputeGameFactoryProxy\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"ethLockboxProxy\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"faultDisputeGameImpl\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"l1CrossDomainMessengerProxy\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"l1Erc721BridgeProxy\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"l1StandardBridgeProxy\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"l2OutputOracleProxy\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"mipsImpl\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"opChainGuardian\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"opChainProxyAdminImpl\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"opChainProxyAdminOwner\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"optimismMintableErc20FactoryProxy\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"optimismPortalProxy\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"permissioned\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"permissionedDisputeGameImpl\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"permissionless\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"preimageOracleImpl\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"proposer\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"respectedGameType\",\"outputs\":[{\"internalType\":\"GameType\",\"name\":\"\",\"type\":\"uint32\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes4\",\"name\":\"_sel\",\"type\":\"bytes4\"},{\"internalType\":\"bool\",\"name\":\"_bool\",\"type\":\"bool\"}],\"name\":\"set\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes4\",\"name\":\"_sel\",\"type\":\"bytes4\"},{\"internalType\":\"address\",\"name\":\"_addr\",\"type\":\"address\"}],\"name\":\"set\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes4\",\"name\":\"_sel\",\"type\":\"bytes4\"},{\"internalType\":\"GameType\",\"name\":\"_gameType\",\"type\":\"uint32\"}],\"name\":\"set\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"superchainConfigProxy\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"systemConfigOwner\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"systemConfigProxy\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"unsafeBlockSigner\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"}],\"devdoc\":{\"kind\":\"dev\",\"methods\":{},\"version\":1},\"userdoc\":{\"kind\":\"user\",\"methods\":{},\"version\":1}},\"settings\":{\"compilationTarget\":{\"scripts/FetchChainInfo.s.sol\":\"FetchChainInfoOutput\"},\"evmVersion\":\"cancun\",\"libraries\":{},\"metadata\":{\"bytecodeHash\":\"none\",\"useLiteralContent\":true},\"optimizer\":{\"enabled\":false,\"runs\":999999},\"remappings\":[\":@lib-keccak/=lib/lib-keccak/contracts/lib/\",\":@openzeppelin/contracts-upgradeable/=lib/openzeppelin-contracts-upgradeable/contracts/\",\":@openzeppelin/contracts-v5/=lib/openzeppelin-contracts-v5/contracts/\",\":@openzeppelin/contracts/=lib/openzeppelin-contracts/contracts/\",\":@rari-capital/solmate/=lib/solmate/\",\":@solady-test/=lib/lib-keccak/lib/solady/test/\",\":@solady-v0.0.245/=lib/solady-v0.0.245/src/\",\":@solady/=lib/solady/src/\",\":ds-test/=lib/forge-std/lib/ds-test/src/\",\":erc4626-tests/=lib/openzeppelin-contracts-v5/lib/erc4626-tests/\",\":forge-std/=lib/forge-std/src/\",\":interfaces/=interfaces/\",\":kontrol-cheatcodes/=lib/kontrol-cheatcodes/src/\",\":lib-keccak/=lib/lib-keccak/contracts/\",\":openzeppelin-contracts-upgradeable/=lib/openzeppelin-contracts-upgradeable/\",\":openzeppelin-contracts-v5/=lib/openzeppelin-contracts-v5/\",\":openzeppelin-contracts/=lib/openzeppelin-contracts/\",\":safe-contracts/=lib/safe-contracts/contracts/\",\":solady-v0.0.245/=lib/solady-v0.0.245/src/\",\":solady/=lib/solady/\",\":solmate/=lib/solmate/src/\"]},\"sources\":{\"lib/forge-std/src/Base.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity >=0.6.2 <0.9.0;\\n\\nimport {StdStorage} from \\\"./StdStorage.sol\\\";\\nimport {Vm, VmSafe} from \\\"./Vm.sol\\\";\\n\\nabstract contract CommonBase {\\n /// @dev Cheat code address.\\n /// Calculated as `address(uint160(uint256(keccak256(\\\"hevm cheat code\\\"))))`.\\n address internal constant VM_ADDRESS = 0x7109709ECfa91a80626fF3989D68f67F5b1DD12D;\\n /// @dev console.sol and console2.sol work by executing a staticcall to this address.\\n /// Calculated as `address(uint160(uint88(bytes11(\\\"console.log\\\"))))`.\\n address internal constant CONSOLE = 0x000000000000000000636F6e736F6c652e6c6f67;\\n /// @dev Used when deploying with create2.\\n /// Taken from https://github.com/Arachnid/deterministic-deployment-proxy.\\n address internal constant CREATE2_FACTORY = 0x4e59b44847b379578588920cA78FbF26c0B4956C;\\n /// @dev The default address for tx.origin and msg.sender.\\n /// Calculated as `address(uint160(uint256(keccak256(\\\"foundry default caller\\\"))))`.\\n address internal constant DEFAULT_SENDER = 0x1804c8AB1F12E6bbf3894d4083f33e07309d1f38;\\n /// @dev The address of the first contract `CREATE`d by a running test contract.\\n /// When running tests, each test contract is `CREATE`d by `DEFAULT_SENDER` with nonce 1.\\n /// Calculated as `VM.computeCreateAddress(VM.computeCreateAddress(DEFAULT_SENDER, 1), 1)`.\\n address internal constant DEFAULT_TEST_CONTRACT = 0x5615dEB798BB3E4dFa0139dFa1b3D433Cc23b72f;\\n /// @dev Deterministic deployment address of the Multicall3 contract.\\n /// Taken from https://www.multicall3.com.\\n address internal constant MULTICALL3_ADDRESS = 0xcA11bde05977b3631167028862bE2a173976CA11;\\n /// @dev The order of the secp256k1 curve.\\n uint256 internal constant SECP256K1_ORDER =\\n 115792089237316195423570985008687907852837564279074904382605163141518161494337;\\n\\n uint256 internal constant UINT256_MAX =\\n 115792089237316195423570985008687907853269984665640564039457584007913129639935;\\n\\n Vm internal constant vm = Vm(VM_ADDRESS);\\n StdStorage internal stdstore;\\n}\\n\\nabstract contract TestBase is CommonBase {}\\n\\nabstract contract ScriptBase is CommonBase {\\n VmSafe internal constant vmSafe = VmSafe(VM_ADDRESS);\\n}\\n\",\"keccak256\":\"0xa3735a6618a3014e42bb4329ad143e3b2c59cd95094350202e4c4a06c9d585dd\",\"license\":\"MIT\"},\"lib/forge-std/src/Script.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity >=0.6.2 <0.9.0;\\n\\n// \\ud83d\\udcac ABOUT\\n// Forge Std's default Script.\\n\\n// \\ud83e\\udde9 MODULES\\nimport {console} from \\\"./console.sol\\\";\\nimport {console2} from \\\"./console2.sol\\\";\\nimport {safeconsole} from \\\"./safeconsole.sol\\\";\\nimport {StdChains} from \\\"./StdChains.sol\\\";\\nimport {StdCheatsSafe} from \\\"./StdCheats.sol\\\";\\nimport {StdConstants} from \\\"./StdConstants.sol\\\";\\nimport {stdJson} from \\\"./StdJson.sol\\\";\\nimport {stdMath} from \\\"./StdMath.sol\\\";\\nimport {StdStorage, stdStorageSafe} from \\\"./StdStorage.sol\\\";\\nimport {StdStyle} from \\\"./StdStyle.sol\\\";\\nimport {StdUtils} from \\\"./StdUtils.sol\\\";\\nimport {VmSafe} from \\\"./Vm.sol\\\";\\n\\n// \\ud83d\\udce6 BOILERPLATE\\nimport {ScriptBase} from \\\"./Base.sol\\\";\\n\\n// \\u2b50\\ufe0f SCRIPT\\nabstract contract Script is ScriptBase, StdChains, StdCheatsSafe, StdUtils {\\n // Note: IS_SCRIPT() must return true.\\n bool public IS_SCRIPT = true;\\n}\\n\",\"keccak256\":\"0xc942e27c7baae499beb01afbbae99f24d42af9a6e4aae675bc6901b704aa8e9b\",\"license\":\"MIT\"},\"lib/forge-std/src/StdChains.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity >=0.6.2 <0.9.0;\\n\\nimport {VmSafe} from \\\"./Vm.sol\\\";\\n\\n/**\\n * StdChains provides information about EVM compatible chains that can be used in scripts/tests.\\n * For each chain, the chain's name, chain ID, and a default RPC URL are provided. Chains are\\n * identified by their alias, which is the same as the alias in the `[rpc_endpoints]` section of\\n * the `foundry.toml` file. For best UX, ensure the alias in the `foundry.toml` file match the\\n * alias used in this contract, which can be found as the first argument to the\\n * `setChainWithDefaultRpcUrl` call in the `initializeStdChains` function.\\n *\\n * There are two main ways to use this contract:\\n * 1. Set a chain with `setChain(string memory chainAlias, ChainData memory chain)` or\\n * `setChain(string memory chainAlias, Chain memory chain)`\\n * 2. Get a chain with `getChain(string memory chainAlias)` or `getChain(uint256 chainId)`.\\n *\\n * The first time either of those are used, chains are initialized with the default set of RPC URLs.\\n * This is done in `initializeStdChains`, which uses `setChainWithDefaultRpcUrl`. Defaults are recorded in\\n * `defaultRpcUrls`.\\n *\\n * The `setChain` function is straightforward, and it simply saves off the given chain data.\\n *\\n * The `getChain` methods use `getChainWithUpdatedRpcUrl` to return a chain. For example, let's say\\n * we want to retrieve the RPC URL for `mainnet`:\\n * - If you have specified data with `setChain`, it will return that.\\n * - If you have configured a mainnet RPC URL in `foundry.toml`, it will return the URL, provided it\\n * is valid (e.g. a URL is specified, or an environment variable is given and exists).\\n * - If neither of the above conditions is met, the default data is returned.\\n *\\n * Summarizing the above, the prioritization hierarchy is `setChain` -> `foundry.toml` -> environment variable -> defaults.\\n */\\nabstract contract StdChains {\\n VmSafe private constant vm = VmSafe(address(uint160(uint256(keccak256(\\\"hevm cheat code\\\")))));\\n\\n bool private stdChainsInitialized;\\n\\n struct ChainData {\\n string name;\\n uint256 chainId;\\n string rpcUrl;\\n }\\n\\n struct Chain {\\n // The chain name.\\n string name;\\n // The chain's Chain ID.\\n uint256 chainId;\\n // The chain's alias. (i.e. what gets specified in `foundry.toml`).\\n string chainAlias;\\n // A default RPC endpoint for this chain.\\n // NOTE: This default RPC URL is included for convenience to facilitate quick tests and\\n // experimentation. Do not use this RPC URL for production test suites, CI, or other heavy\\n // usage as you will be throttled and this is a disservice to others who need this endpoint.\\n string rpcUrl;\\n }\\n\\n // Maps from the chain's alias (matching the alias in the `foundry.toml` file) to chain data.\\n mapping(string => Chain) private chains;\\n // Maps from the chain's alias to it's default RPC URL.\\n mapping(string => string) private defaultRpcUrls;\\n // Maps from a chain ID to it's alias.\\n mapping(uint256 => string) private idToAlias;\\n\\n bool private fallbackToDefaultRpcUrls = true;\\n\\n // The RPC URL will be fetched from config or defaultRpcUrls if possible.\\n function getChain(string memory chainAlias) internal virtual returns (Chain memory chain) {\\n require(bytes(chainAlias).length != 0, \\\"StdChains getChain(string): Chain alias cannot be the empty string.\\\");\\n\\n initializeStdChains();\\n chain = chains[chainAlias];\\n require(\\n chain.chainId != 0,\\n string(abi.encodePacked(\\\"StdChains getChain(string): Chain with alias \\\\\\\"\\\", chainAlias, \\\"\\\\\\\" not found.\\\"))\\n );\\n\\n chain = getChainWithUpdatedRpcUrl(chainAlias, chain);\\n }\\n\\n function getChain(uint256 chainId) internal virtual returns (Chain memory chain) {\\n require(chainId != 0, \\\"StdChains getChain(uint256): Chain ID cannot be 0.\\\");\\n initializeStdChains();\\n string memory chainAlias = idToAlias[chainId];\\n\\n chain = chains[chainAlias];\\n\\n require(\\n chain.chainId != 0,\\n string(abi.encodePacked(\\\"StdChains getChain(uint256): Chain with ID \\\", vm.toString(chainId), \\\" not found.\\\"))\\n );\\n\\n chain = getChainWithUpdatedRpcUrl(chainAlias, chain);\\n }\\n\\n // set chain info, with priority to argument's rpcUrl field.\\n function setChain(string memory chainAlias, ChainData memory chain) internal virtual {\\n require(\\n bytes(chainAlias).length != 0,\\n \\\"StdChains setChain(string,ChainData): Chain alias cannot be the empty string.\\\"\\n );\\n\\n require(chain.chainId != 0, \\\"StdChains setChain(string,ChainData): Chain ID cannot be 0.\\\");\\n\\n initializeStdChains();\\n string memory foundAlias = idToAlias[chain.chainId];\\n\\n require(\\n bytes(foundAlias).length == 0 || keccak256(bytes(foundAlias)) == keccak256(bytes(chainAlias)),\\n string(\\n abi.encodePacked(\\n \\\"StdChains setChain(string,ChainData): Chain ID \\\",\\n vm.toString(chain.chainId),\\n \\\" already used by \\\\\\\"\\\",\\n foundAlias,\\n \\\"\\\\\\\".\\\"\\n )\\n )\\n );\\n\\n uint256 oldChainId = chains[chainAlias].chainId;\\n delete idToAlias[oldChainId];\\n\\n chains[chainAlias] =\\n Chain({name: chain.name, chainId: chain.chainId, chainAlias: chainAlias, rpcUrl: chain.rpcUrl});\\n idToAlias[chain.chainId] = chainAlias;\\n }\\n\\n // set chain info, with priority to argument's rpcUrl field.\\n function setChain(string memory chainAlias, Chain memory chain) internal virtual {\\n setChain(chainAlias, ChainData({name: chain.name, chainId: chain.chainId, rpcUrl: chain.rpcUrl}));\\n }\\n\\n function _toUpper(string memory str) private pure returns (string memory) {\\n bytes memory strb = bytes(str);\\n bytes memory copy = new bytes(strb.length);\\n for (uint256 i = 0; i < strb.length; i++) {\\n bytes1 b = strb[i];\\n if (b >= 0x61 && b <= 0x7A) {\\n copy[i] = bytes1(uint8(b) - 32);\\n } else {\\n copy[i] = b;\\n }\\n }\\n return string(copy);\\n }\\n\\n // lookup rpcUrl, in descending order of priority:\\n // current -> config (foundry.toml) -> environment variable -> default\\n function getChainWithUpdatedRpcUrl(string memory chainAlias, Chain memory chain)\\n private\\n view\\n returns (Chain memory)\\n {\\n if (bytes(chain.rpcUrl).length == 0) {\\n try vm.rpcUrl(chainAlias) returns (string memory configRpcUrl) {\\n chain.rpcUrl = configRpcUrl;\\n } catch (bytes memory err) {\\n string memory envName = string(abi.encodePacked(_toUpper(chainAlias), \\\"_RPC_URL\\\"));\\n if (fallbackToDefaultRpcUrls) {\\n chain.rpcUrl = vm.envOr(envName, defaultRpcUrls[chainAlias]);\\n } else {\\n chain.rpcUrl = vm.envString(envName);\\n }\\n // Distinguish 'not found' from 'cannot read'\\n // The upstream error thrown by forge for failing cheats changed so we check both the old and new versions\\n bytes memory oldNotFoundError =\\n abi.encodeWithSignature(\\\"CheatCodeError\\\", string(abi.encodePacked(\\\"invalid rpc url \\\", chainAlias)));\\n bytes memory newNotFoundError = abi.encodeWithSignature(\\n \\\"CheatcodeError(string)\\\", string(abi.encodePacked(\\\"invalid rpc url: \\\", chainAlias))\\n );\\n bytes32 errHash = keccak256(err);\\n if (\\n (errHash != keccak256(oldNotFoundError) && errHash != keccak256(newNotFoundError))\\n || bytes(chain.rpcUrl).length == 0\\n ) {\\n /// @solidity memory-safe-assembly\\n assembly {\\n revert(add(32, err), mload(err))\\n }\\n }\\n }\\n }\\n return chain;\\n }\\n\\n function setFallbackToDefaultRpcUrls(bool useDefault) internal {\\n fallbackToDefaultRpcUrls = useDefault;\\n }\\n\\n function initializeStdChains() private {\\n if (stdChainsInitialized) return;\\n\\n stdChainsInitialized = true;\\n\\n // If adding an RPC here, make sure to test the default RPC URL in `test_Rpcs` in `StdChains.t.sol`\\n setChainWithDefaultRpcUrl(\\\"anvil\\\", ChainData(\\\"Anvil\\\", 31337, \\\"http://127.0.0.1:8545\\\"));\\n setChainWithDefaultRpcUrl(\\\"mainnet\\\", ChainData(\\\"Mainnet\\\", 1, \\\"https://eth.llamarpc.com\\\"));\\n setChainWithDefaultRpcUrl(\\n \\\"sepolia\\\", ChainData(\\\"Sepolia\\\", 11155111, \\\"https://sepolia.infura.io/v3/b9794ad1ddf84dfb8c34d6bb5dca2001\\\")\\n );\\n setChainWithDefaultRpcUrl(\\\"holesky\\\", ChainData(\\\"Holesky\\\", 17000, \\\"https://rpc.holesky.ethpandaops.io\\\"));\\n setChainWithDefaultRpcUrl(\\\"optimism\\\", ChainData(\\\"Optimism\\\", 10, \\\"https://mainnet.optimism.io\\\"));\\n setChainWithDefaultRpcUrl(\\n \\\"optimism_sepolia\\\", ChainData(\\\"Optimism Sepolia\\\", 11155420, \\\"https://sepolia.optimism.io\\\")\\n );\\n setChainWithDefaultRpcUrl(\\\"arbitrum_one\\\", ChainData(\\\"Arbitrum One\\\", 42161, \\\"https://arb1.arbitrum.io/rpc\\\"));\\n setChainWithDefaultRpcUrl(\\n \\\"arbitrum_one_sepolia\\\", ChainData(\\\"Arbitrum One Sepolia\\\", 421614, \\\"https://sepolia-rollup.arbitrum.io/rpc\\\")\\n );\\n setChainWithDefaultRpcUrl(\\\"arbitrum_nova\\\", ChainData(\\\"Arbitrum Nova\\\", 42170, \\\"https://nova.arbitrum.io/rpc\\\"));\\n setChainWithDefaultRpcUrl(\\\"polygon\\\", ChainData(\\\"Polygon\\\", 137, \\\"https://polygon-rpc.com\\\"));\\n setChainWithDefaultRpcUrl(\\n \\\"polygon_amoy\\\", ChainData(\\\"Polygon Amoy\\\", 80002, \\\"https://rpc-amoy.polygon.technology\\\")\\n );\\n setChainWithDefaultRpcUrl(\\\"avalanche\\\", ChainData(\\\"Avalanche\\\", 43114, \\\"https://api.avax.network/ext/bc/C/rpc\\\"));\\n setChainWithDefaultRpcUrl(\\n \\\"avalanche_fuji\\\", ChainData(\\\"Avalanche Fuji\\\", 43113, \\\"https://api.avax-test.network/ext/bc/C/rpc\\\")\\n );\\n setChainWithDefaultRpcUrl(\\n \\\"bnb_smart_chain\\\", ChainData(\\\"BNB Smart Chain\\\", 56, \\\"https://bsc-dataseed1.binance.org\\\")\\n );\\n setChainWithDefaultRpcUrl(\\n \\\"bnb_smart_chain_testnet\\\",\\n ChainData(\\\"BNB Smart Chain Testnet\\\", 97, \\\"https://rpc.ankr.com/bsc_testnet_chapel\\\")\\n );\\n setChainWithDefaultRpcUrl(\\\"gnosis_chain\\\", ChainData(\\\"Gnosis Chain\\\", 100, \\\"https://rpc.gnosischain.com\\\"));\\n setChainWithDefaultRpcUrl(\\\"moonbeam\\\", ChainData(\\\"Moonbeam\\\", 1284, \\\"https://rpc.api.moonbeam.network\\\"));\\n setChainWithDefaultRpcUrl(\\n \\\"moonriver\\\", ChainData(\\\"Moonriver\\\", 1285, \\\"https://rpc.api.moonriver.moonbeam.network\\\")\\n );\\n setChainWithDefaultRpcUrl(\\\"moonbase\\\", ChainData(\\\"Moonbase\\\", 1287, \\\"https://rpc.testnet.moonbeam.network\\\"));\\n setChainWithDefaultRpcUrl(\\\"base_sepolia\\\", ChainData(\\\"Base Sepolia\\\", 84532, \\\"https://sepolia.base.org\\\"));\\n setChainWithDefaultRpcUrl(\\\"base\\\", ChainData(\\\"Base\\\", 8453, \\\"https://mainnet.base.org\\\"));\\n setChainWithDefaultRpcUrl(\\\"blast_sepolia\\\", ChainData(\\\"Blast Sepolia\\\", 168587773, \\\"https://sepolia.blast.io\\\"));\\n setChainWithDefaultRpcUrl(\\\"blast\\\", ChainData(\\\"Blast\\\", 81457, \\\"https://rpc.blast.io\\\"));\\n setChainWithDefaultRpcUrl(\\\"fantom_opera\\\", ChainData(\\\"Fantom Opera\\\", 250, \\\"https://rpc.ankr.com/fantom/\\\"));\\n setChainWithDefaultRpcUrl(\\n \\\"fantom_opera_testnet\\\", ChainData(\\\"Fantom Opera Testnet\\\", 4002, \\\"https://rpc.ankr.com/fantom_testnet/\\\")\\n );\\n setChainWithDefaultRpcUrl(\\\"fraxtal\\\", ChainData(\\\"Fraxtal\\\", 252, \\\"https://rpc.frax.com\\\"));\\n setChainWithDefaultRpcUrl(\\\"fraxtal_testnet\\\", ChainData(\\\"Fraxtal Testnet\\\", 2522, \\\"https://rpc.testnet.frax.com\\\"));\\n setChainWithDefaultRpcUrl(\\n \\\"berachain_bartio_testnet\\\", ChainData(\\\"Berachain bArtio Testnet\\\", 80084, \\\"https://bartio.rpc.berachain.com\\\")\\n );\\n setChainWithDefaultRpcUrl(\\\"flare\\\", ChainData(\\\"Flare\\\", 14, \\\"https://flare-api.flare.network/ext/C/rpc\\\"));\\n setChainWithDefaultRpcUrl(\\n \\\"flare_coston2\\\", ChainData(\\\"Flare Coston2\\\", 114, \\\"https://coston2-api.flare.network/ext/C/rpc\\\")\\n );\\n\\n setChainWithDefaultRpcUrl(\\\"mode\\\", ChainData(\\\"Mode\\\", 34443, \\\"https://mode.drpc.org\\\"));\\n setChainWithDefaultRpcUrl(\\\"mode_sepolia\\\", ChainData(\\\"Mode Sepolia\\\", 919, \\\"https://sepolia.mode.network\\\"));\\n\\n setChainWithDefaultRpcUrl(\\\"zora\\\", ChainData(\\\"Zora\\\", 7777777, \\\"https://zora.drpc.org\\\"));\\n setChainWithDefaultRpcUrl(\\n \\\"zora_sepolia\\\", ChainData(\\\"Zora Sepolia\\\", 999999999, \\\"https://sepolia.rpc.zora.energy\\\")\\n );\\n\\n setChainWithDefaultRpcUrl(\\\"race\\\", ChainData(\\\"Race\\\", 6805, \\\"https://racemainnet.io\\\"));\\n setChainWithDefaultRpcUrl(\\\"race_sepolia\\\", ChainData(\\\"Race Sepolia\\\", 6806, \\\"https://racemainnet.io\\\"));\\n\\n setChainWithDefaultRpcUrl(\\\"metal\\\", ChainData(\\\"Metal\\\", 1750, \\\"https://metall2.drpc.org\\\"));\\n setChainWithDefaultRpcUrl(\\\"metal_sepolia\\\", ChainData(\\\"Metal Sepolia\\\", 1740, \\\"https://testnet.rpc.metall2.com\\\"));\\n\\n setChainWithDefaultRpcUrl(\\\"binary\\\", ChainData(\\\"Binary\\\", 624, \\\"https://rpc.zero.thebinaryholdings.com\\\"));\\n setChainWithDefaultRpcUrl(\\n \\\"binary_sepolia\\\", ChainData(\\\"Binary Sepolia\\\", 625, \\\"https://rpc.zero.thebinaryholdings.com\\\")\\n );\\n\\n setChainWithDefaultRpcUrl(\\\"orderly\\\", ChainData(\\\"Orderly\\\", 291, \\\"https://rpc.orderly.network\\\"));\\n setChainWithDefaultRpcUrl(\\n \\\"orderly_sepolia\\\", ChainData(\\\"Orderly Sepolia\\\", 4460, \\\"https://testnet-rpc.orderly.org\\\")\\n );\\n }\\n\\n // set chain info, with priority to chainAlias' rpc url in foundry.toml\\n function setChainWithDefaultRpcUrl(string memory chainAlias, ChainData memory chain) private {\\n string memory rpcUrl = chain.rpcUrl;\\n defaultRpcUrls[chainAlias] = rpcUrl;\\n chain.rpcUrl = \\\"\\\";\\n setChain(chainAlias, chain);\\n chain.rpcUrl = rpcUrl; // restore argument\\n }\\n}\\n\",\"keccak256\":\"0x200b597cd01c229633b4a2317846cac7d36d337e2381b4a2e81faac23c2ad1cf\",\"license\":\"MIT\"},\"lib/forge-std/src/StdCheats.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity >=0.6.2 <0.9.0;\\n\\npragma experimental ABIEncoderV2;\\n\\nimport {StdStorage, stdStorage} from \\\"./StdStorage.sol\\\";\\nimport {console2} from \\\"./console2.sol\\\";\\nimport {Vm} from \\\"./Vm.sol\\\";\\n\\nabstract contract StdCheatsSafe {\\n Vm private constant vm = Vm(address(uint160(uint256(keccak256(\\\"hevm cheat code\\\")))));\\n\\n uint256 private constant UINT256_MAX =\\n 115792089237316195423570985008687907853269984665640564039457584007913129639935;\\n\\n bool private gasMeteringOff;\\n\\n // Data structures to parse Transaction objects from the broadcast artifact\\n // that conform to EIP1559. The Raw structs is what is parsed from the JSON\\n // and then converted to the one that is used by the user for better UX.\\n\\n struct RawTx1559 {\\n string[] arguments;\\n address contractAddress;\\n string contractName;\\n // json value name = function\\n string functionSig;\\n bytes32 hash;\\n // json value name = tx\\n RawTx1559Detail txDetail;\\n // json value name = type\\n string opcode;\\n }\\n\\n struct RawTx1559Detail {\\n AccessList[] accessList;\\n bytes data;\\n address from;\\n bytes gas;\\n bytes nonce;\\n address to;\\n bytes txType;\\n bytes value;\\n }\\n\\n struct Tx1559 {\\n string[] arguments;\\n address contractAddress;\\n string contractName;\\n string functionSig;\\n bytes32 hash;\\n Tx1559Detail txDetail;\\n string opcode;\\n }\\n\\n struct Tx1559Detail {\\n AccessList[] accessList;\\n bytes data;\\n address from;\\n uint256 gas;\\n uint256 nonce;\\n address to;\\n uint256 txType;\\n uint256 value;\\n }\\n\\n // Data structures to parse Transaction objects from the broadcast artifact\\n // that DO NOT conform to EIP1559. The Raw structs is what is parsed from the JSON\\n // and then converted to the one that is used by the user for better UX.\\n\\n struct TxLegacy {\\n string[] arguments;\\n address contractAddress;\\n string contractName;\\n string functionSig;\\n string hash;\\n string opcode;\\n TxDetailLegacy transaction;\\n }\\n\\n struct TxDetailLegacy {\\n AccessList[] accessList;\\n uint256 chainId;\\n bytes data;\\n address from;\\n uint256 gas;\\n uint256 gasPrice;\\n bytes32 hash;\\n uint256 nonce;\\n bytes1 opcode;\\n bytes32 r;\\n bytes32 s;\\n uint256 txType;\\n address to;\\n uint8 v;\\n uint256 value;\\n }\\n\\n struct AccessList {\\n address accessAddress;\\n bytes32[] storageKeys;\\n }\\n\\n // Data structures to parse Receipt objects from the broadcast artifact.\\n // The Raw structs is what is parsed from the JSON\\n // and then converted to the one that is used by the user for better UX.\\n\\n struct RawReceipt {\\n bytes32 blockHash;\\n bytes blockNumber;\\n address contractAddress;\\n bytes cumulativeGasUsed;\\n bytes effectiveGasPrice;\\n address from;\\n bytes gasUsed;\\n RawReceiptLog[] logs;\\n bytes logsBloom;\\n bytes status;\\n address to;\\n bytes32 transactionHash;\\n bytes transactionIndex;\\n }\\n\\n struct Receipt {\\n bytes32 blockHash;\\n uint256 blockNumber;\\n address contractAddress;\\n uint256 cumulativeGasUsed;\\n uint256 effectiveGasPrice;\\n address from;\\n uint256 gasUsed;\\n ReceiptLog[] logs;\\n bytes logsBloom;\\n uint256 status;\\n address to;\\n bytes32 transactionHash;\\n uint256 transactionIndex;\\n }\\n\\n // Data structures to parse the entire broadcast artifact, assuming the\\n // transactions conform to EIP1559.\\n\\n struct EIP1559ScriptArtifact {\\n string[] libraries;\\n string path;\\n string[] pending;\\n Receipt[] receipts;\\n uint256 timestamp;\\n Tx1559[] transactions;\\n TxReturn[] txReturns;\\n }\\n\\n struct RawEIP1559ScriptArtifact {\\n string[] libraries;\\n string path;\\n string[] pending;\\n RawReceipt[] receipts;\\n TxReturn[] txReturns;\\n uint256 timestamp;\\n RawTx1559[] transactions;\\n }\\n\\n struct RawReceiptLog {\\n // json value = address\\n address logAddress;\\n bytes32 blockHash;\\n bytes blockNumber;\\n bytes data;\\n bytes logIndex;\\n bool removed;\\n bytes32[] topics;\\n bytes32 transactionHash;\\n bytes transactionIndex;\\n bytes transactionLogIndex;\\n }\\n\\n struct ReceiptLog {\\n // json value = address\\n address logAddress;\\n bytes32 blockHash;\\n uint256 blockNumber;\\n bytes data;\\n uint256 logIndex;\\n bytes32[] topics;\\n uint256 transactionIndex;\\n uint256 transactionLogIndex;\\n bool removed;\\n }\\n\\n struct TxReturn {\\n string internalType;\\n string value;\\n }\\n\\n struct Account {\\n address addr;\\n uint256 key;\\n }\\n\\n enum AddressType {\\n Payable,\\n NonPayable,\\n ZeroAddress,\\n Precompile,\\n ForgeAddress\\n }\\n\\n // Checks that `addr` is not blacklisted by token contracts that have a blacklist.\\n function assumeNotBlacklisted(address token, address addr) internal view virtual {\\n // Nothing to check if `token` is not a contract.\\n uint256 tokenCodeSize;\\n assembly {\\n tokenCodeSize := extcodesize(token)\\n }\\n require(tokenCodeSize > 0, \\\"StdCheats assumeNotBlacklisted(address,address): Token address is not a contract.\\\");\\n\\n bool success;\\n bytes memory returnData;\\n\\n // 4-byte selector for `isBlacklisted(address)`, used by USDC.\\n (success, returnData) = token.staticcall(abi.encodeWithSelector(0xfe575a87, addr));\\n vm.assume(!success || abi.decode(returnData, (bool)) == false);\\n\\n // 4-byte selector for `isBlackListed(address)`, used by USDT.\\n (success, returnData) = token.staticcall(abi.encodeWithSelector(0xe47d6060, addr));\\n vm.assume(!success || abi.decode(returnData, (bool)) == false);\\n }\\n\\n // Checks that `addr` is not blacklisted by token contracts that have a blacklist.\\n // This is identical to `assumeNotBlacklisted(address,address)` but with a different name, for\\n // backwards compatibility, since this name was used in the original PR which already has\\n // a release. This function can be removed in a future release once we want a breaking change.\\n function assumeNoBlacklisted(address token, address addr) internal view virtual {\\n assumeNotBlacklisted(token, addr);\\n }\\n\\n function assumeAddressIsNot(address addr, AddressType addressType) internal virtual {\\n if (addressType == AddressType.Payable) {\\n assumeNotPayable(addr);\\n } else if (addressType == AddressType.NonPayable) {\\n assumePayable(addr);\\n } else if (addressType == AddressType.ZeroAddress) {\\n assumeNotZeroAddress(addr);\\n } else if (addressType == AddressType.Precompile) {\\n assumeNotPrecompile(addr);\\n } else if (addressType == AddressType.ForgeAddress) {\\n assumeNotForgeAddress(addr);\\n }\\n }\\n\\n function assumeAddressIsNot(address addr, AddressType addressType1, AddressType addressType2) internal virtual {\\n assumeAddressIsNot(addr, addressType1);\\n assumeAddressIsNot(addr, addressType2);\\n }\\n\\n function assumeAddressIsNot(\\n address addr,\\n AddressType addressType1,\\n AddressType addressType2,\\n AddressType addressType3\\n ) internal virtual {\\n assumeAddressIsNot(addr, addressType1);\\n assumeAddressIsNot(addr, addressType2);\\n assumeAddressIsNot(addr, addressType3);\\n }\\n\\n function assumeAddressIsNot(\\n address addr,\\n AddressType addressType1,\\n AddressType addressType2,\\n AddressType addressType3,\\n AddressType addressType4\\n ) internal virtual {\\n assumeAddressIsNot(addr, addressType1);\\n assumeAddressIsNot(addr, addressType2);\\n assumeAddressIsNot(addr, addressType3);\\n assumeAddressIsNot(addr, addressType4);\\n }\\n\\n // This function checks whether an address, `addr`, is payable. It works by sending 1 wei to\\n // `addr` and checking the `success` return value.\\n // NOTE: This function may result in state changes depending on the fallback/receive logic\\n // implemented by `addr`, which should be taken into account when this function is used.\\n function _isPayable(address addr) private returns (bool) {\\n require(\\n addr.balance < UINT256_MAX,\\n \\\"StdCheats _isPayable(address): Balance equals max uint256, so it cannot receive any more funds\\\"\\n );\\n uint256 origBalanceTest = address(this).balance;\\n uint256 origBalanceAddr = address(addr).balance;\\n\\n vm.deal(address(this), 1);\\n (bool success,) = payable(addr).call{value: 1}(\\\"\\\");\\n\\n // reset balances\\n vm.deal(address(this), origBalanceTest);\\n vm.deal(addr, origBalanceAddr);\\n\\n return success;\\n }\\n\\n // NOTE: This function may result in state changes depending on the fallback/receive logic\\n // implemented by `addr`, which should be taken into account when this function is used. See the\\n // `_isPayable` method for more information.\\n function assumePayable(address addr) internal virtual {\\n vm.assume(_isPayable(addr));\\n }\\n\\n function assumeNotPayable(address addr) internal virtual {\\n vm.assume(!_isPayable(addr));\\n }\\n\\n function assumeNotZeroAddress(address addr) internal pure virtual {\\n vm.assume(addr != address(0));\\n }\\n\\n function assumeNotPrecompile(address addr) internal pure virtual {\\n assumeNotPrecompile(addr, _pureChainId());\\n }\\n\\n function assumeNotPrecompile(address addr, uint256 chainId) internal pure virtual {\\n // Note: For some chains like Optimism these are technically predeploys (i.e. bytecode placed at a specific\\n // address), but the same rationale for excluding them applies so we include those too.\\n\\n // These are reserved by Ethereum and may be on all EVM-compatible chains.\\n vm.assume(addr < address(0x1) || addr > address(0xff));\\n\\n // forgefmt: disable-start\\n if (chainId == 10 || chainId == 420) {\\n // https://github.com/ethereum-optimism/optimism/blob/eaa371a0184b56b7ca6d9eb9cb0a2b78b2ccd864/op-bindings/predeploys/addresses.go#L6-L21\\n vm.assume(addr < address(0x4200000000000000000000000000000000000000) || addr > address(0x4200000000000000000000000000000000000800));\\n } else if (chainId == 42161 || chainId == 421613) {\\n // https://developer.arbitrum.io/useful-addresses#arbitrum-precompiles-l2-same-on-all-arb-chains\\n vm.assume(addr < address(0x0000000000000000000000000000000000000064) || addr > address(0x0000000000000000000000000000000000000068));\\n } else if (chainId == 43114 || chainId == 43113) {\\n // https://github.com/ava-labs/subnet-evm/blob/47c03fd007ecaa6de2c52ea081596e0a88401f58/precompile/params.go#L18-L59\\n vm.assume(addr < address(0x0100000000000000000000000000000000000000) || addr > address(0x01000000000000000000000000000000000000ff));\\n vm.assume(addr < address(0x0200000000000000000000000000000000000000) || addr > address(0x02000000000000000000000000000000000000FF));\\n vm.assume(addr < address(0x0300000000000000000000000000000000000000) || addr > address(0x03000000000000000000000000000000000000Ff));\\n }\\n // forgefmt: disable-end\\n }\\n\\n function assumeNotForgeAddress(address addr) internal pure virtual {\\n // vm, console, and Create2Deployer addresses\\n vm.assume(\\n addr != address(vm) && addr != 0x000000000000000000636F6e736F6c652e6c6f67\\n && addr != 0x4e59b44847b379578588920cA78FbF26c0B4956C\\n );\\n }\\n\\n function assumeUnusedAddress(address addr) internal view virtual {\\n uint256 size;\\n assembly {\\n size := extcodesize(addr)\\n }\\n vm.assume(size == 0);\\n\\n assumeNotPrecompile(addr);\\n assumeNotZeroAddress(addr);\\n assumeNotForgeAddress(addr);\\n }\\n\\n function readEIP1559ScriptArtifact(string memory path)\\n internal\\n view\\n virtual\\n returns (EIP1559ScriptArtifact memory)\\n {\\n string memory data = vm.readFile(path);\\n bytes memory parsedData = vm.parseJson(data);\\n RawEIP1559ScriptArtifact memory rawArtifact = abi.decode(parsedData, (RawEIP1559ScriptArtifact));\\n EIP1559ScriptArtifact memory artifact;\\n artifact.libraries = rawArtifact.libraries;\\n artifact.path = rawArtifact.path;\\n artifact.timestamp = rawArtifact.timestamp;\\n artifact.pending = rawArtifact.pending;\\n artifact.txReturns = rawArtifact.txReturns;\\n artifact.receipts = rawToConvertedReceipts(rawArtifact.receipts);\\n artifact.transactions = rawToConvertedEIPTx1559s(rawArtifact.transactions);\\n return artifact;\\n }\\n\\n function rawToConvertedEIPTx1559s(RawTx1559[] memory rawTxs) internal pure virtual returns (Tx1559[] memory) {\\n Tx1559[] memory txs = new Tx1559[](rawTxs.length);\\n for (uint256 i; i < rawTxs.length; i++) {\\n txs[i] = rawToConvertedEIPTx1559(rawTxs[i]);\\n }\\n return txs;\\n }\\n\\n function rawToConvertedEIPTx1559(RawTx1559 memory rawTx) internal pure virtual returns (Tx1559 memory) {\\n Tx1559 memory transaction;\\n transaction.arguments = rawTx.arguments;\\n transaction.contractName = rawTx.contractName;\\n transaction.functionSig = rawTx.functionSig;\\n transaction.hash = rawTx.hash;\\n transaction.txDetail = rawToConvertedEIP1559Detail(rawTx.txDetail);\\n transaction.opcode = rawTx.opcode;\\n return transaction;\\n }\\n\\n function rawToConvertedEIP1559Detail(RawTx1559Detail memory rawDetail)\\n internal\\n pure\\n virtual\\n returns (Tx1559Detail memory)\\n {\\n Tx1559Detail memory txDetail;\\n txDetail.data = rawDetail.data;\\n txDetail.from = rawDetail.from;\\n txDetail.to = rawDetail.to;\\n txDetail.nonce = _bytesToUint(rawDetail.nonce);\\n txDetail.txType = _bytesToUint(rawDetail.txType);\\n txDetail.value = _bytesToUint(rawDetail.value);\\n txDetail.gas = _bytesToUint(rawDetail.gas);\\n txDetail.accessList = rawDetail.accessList;\\n return txDetail;\\n }\\n\\n function readTx1559s(string memory path) internal view virtual returns (Tx1559[] memory) {\\n string memory deployData = vm.readFile(path);\\n bytes memory parsedDeployData = vm.parseJson(deployData, \\\".transactions\\\");\\n RawTx1559[] memory rawTxs = abi.decode(parsedDeployData, (RawTx1559[]));\\n return rawToConvertedEIPTx1559s(rawTxs);\\n }\\n\\n function readTx1559(string memory path, uint256 index) internal view virtual returns (Tx1559 memory) {\\n string memory deployData = vm.readFile(path);\\n string memory key = string(abi.encodePacked(\\\".transactions[\\\", vm.toString(index), \\\"]\\\"));\\n bytes memory parsedDeployData = vm.parseJson(deployData, key);\\n RawTx1559 memory rawTx = abi.decode(parsedDeployData, (RawTx1559));\\n return rawToConvertedEIPTx1559(rawTx);\\n }\\n\\n // Analogous to readTransactions, but for receipts.\\n function readReceipts(string memory path) internal view virtual returns (Receipt[] memory) {\\n string memory deployData = vm.readFile(path);\\n bytes memory parsedDeployData = vm.parseJson(deployData, \\\".receipts\\\");\\n RawReceipt[] memory rawReceipts = abi.decode(parsedDeployData, (RawReceipt[]));\\n return rawToConvertedReceipts(rawReceipts);\\n }\\n\\n function readReceipt(string memory path, uint256 index) internal view virtual returns (Receipt memory) {\\n string memory deployData = vm.readFile(path);\\n string memory key = string(abi.encodePacked(\\\".receipts[\\\", vm.toString(index), \\\"]\\\"));\\n bytes memory parsedDeployData = vm.parseJson(deployData, key);\\n RawReceipt memory rawReceipt = abi.decode(parsedDeployData, (RawReceipt));\\n return rawToConvertedReceipt(rawReceipt);\\n }\\n\\n function rawToConvertedReceipts(RawReceipt[] memory rawReceipts) internal pure virtual returns (Receipt[] memory) {\\n Receipt[] memory receipts = new Receipt[](rawReceipts.length);\\n for (uint256 i; i < rawReceipts.length; i++) {\\n receipts[i] = rawToConvertedReceipt(rawReceipts[i]);\\n }\\n return receipts;\\n }\\n\\n function rawToConvertedReceipt(RawReceipt memory rawReceipt) internal pure virtual returns (Receipt memory) {\\n Receipt memory receipt;\\n receipt.blockHash = rawReceipt.blockHash;\\n receipt.to = rawReceipt.to;\\n receipt.from = rawReceipt.from;\\n receipt.contractAddress = rawReceipt.contractAddress;\\n receipt.effectiveGasPrice = _bytesToUint(rawReceipt.effectiveGasPrice);\\n receipt.cumulativeGasUsed = _bytesToUint(rawReceipt.cumulativeGasUsed);\\n receipt.gasUsed = _bytesToUint(rawReceipt.gasUsed);\\n receipt.status = _bytesToUint(rawReceipt.status);\\n receipt.transactionIndex = _bytesToUint(rawReceipt.transactionIndex);\\n receipt.blockNumber = _bytesToUint(rawReceipt.blockNumber);\\n receipt.logs = rawToConvertedReceiptLogs(rawReceipt.logs);\\n receipt.logsBloom = rawReceipt.logsBloom;\\n receipt.transactionHash = rawReceipt.transactionHash;\\n return receipt;\\n }\\n\\n function rawToConvertedReceiptLogs(RawReceiptLog[] memory rawLogs)\\n internal\\n pure\\n virtual\\n returns (ReceiptLog[] memory)\\n {\\n ReceiptLog[] memory logs = new ReceiptLog[](rawLogs.length);\\n for (uint256 i; i < rawLogs.length; i++) {\\n logs[i].logAddress = rawLogs[i].logAddress;\\n logs[i].blockHash = rawLogs[i].blockHash;\\n logs[i].blockNumber = _bytesToUint(rawLogs[i].blockNumber);\\n logs[i].data = rawLogs[i].data;\\n logs[i].logIndex = _bytesToUint(rawLogs[i].logIndex);\\n logs[i].topics = rawLogs[i].topics;\\n logs[i].transactionIndex = _bytesToUint(rawLogs[i].transactionIndex);\\n logs[i].transactionLogIndex = _bytesToUint(rawLogs[i].transactionLogIndex);\\n logs[i].removed = rawLogs[i].removed;\\n }\\n return logs;\\n }\\n\\n // Deploy a contract by fetching the contract bytecode from\\n // the artifacts directory\\n // e.g. `deployCode(code, abi.encode(arg1,arg2,arg3))`\\n function deployCode(string memory what, bytes memory args) internal virtual returns (address addr) {\\n bytes memory bytecode = abi.encodePacked(vm.getCode(what), args);\\n /// @solidity memory-safe-assembly\\n assembly {\\n addr := create(0, add(bytecode, 0x20), mload(bytecode))\\n }\\n\\n require(addr != address(0), \\\"StdCheats deployCode(string,bytes): Deployment failed.\\\");\\n }\\n\\n function deployCode(string memory what) internal virtual returns (address addr) {\\n bytes memory bytecode = vm.getCode(what);\\n /// @solidity memory-safe-assembly\\n assembly {\\n addr := create(0, add(bytecode, 0x20), mload(bytecode))\\n }\\n\\n require(addr != address(0), \\\"StdCheats deployCode(string): Deployment failed.\\\");\\n }\\n\\n /// @dev deploy contract with value on construction\\n function deployCode(string memory what, bytes memory args, uint256 val) internal virtual returns (address addr) {\\n bytes memory bytecode = abi.encodePacked(vm.getCode(what), args);\\n /// @solidity memory-safe-assembly\\n assembly {\\n addr := create(val, add(bytecode, 0x20), mload(bytecode))\\n }\\n\\n require(addr != address(0), \\\"StdCheats deployCode(string,bytes,uint256): Deployment failed.\\\");\\n }\\n\\n function deployCode(string memory what, uint256 val) internal virtual returns (address addr) {\\n bytes memory bytecode = vm.getCode(what);\\n /// @solidity memory-safe-assembly\\n assembly {\\n addr := create(val, add(bytecode, 0x20), mload(bytecode))\\n }\\n\\n require(addr != address(0), \\\"StdCheats deployCode(string,uint256): Deployment failed.\\\");\\n }\\n\\n // creates a labeled address and the corresponding private key\\n function makeAddrAndKey(string memory name) internal virtual returns (address addr, uint256 privateKey) {\\n privateKey = uint256(keccak256(abi.encodePacked(name)));\\n addr = vm.addr(privateKey);\\n vm.label(addr, name);\\n }\\n\\n // creates a labeled address\\n function makeAddr(string memory name) internal virtual returns (address addr) {\\n (addr,) = makeAddrAndKey(name);\\n }\\n\\n // Destroys an account immediately, sending the balance to beneficiary.\\n // Destroying means: balance will be zero, code will be empty, and nonce will be 0\\n // This is similar to selfdestruct but not identical: selfdestruct destroys code and nonce\\n // only after tx ends, this will run immediately.\\n function destroyAccount(address who, address beneficiary) internal virtual {\\n uint256 currBalance = who.balance;\\n vm.etch(who, abi.encode());\\n vm.deal(who, 0);\\n vm.resetNonce(who);\\n\\n uint256 beneficiaryBalance = beneficiary.balance;\\n vm.deal(beneficiary, currBalance + beneficiaryBalance);\\n }\\n\\n // creates a struct containing both a labeled address and the corresponding private key\\n function makeAccount(string memory name) internal virtual returns (Account memory account) {\\n (account.addr, account.key) = makeAddrAndKey(name);\\n }\\n\\n function deriveRememberKey(string memory mnemonic, uint32 index)\\n internal\\n virtual\\n returns (address who, uint256 privateKey)\\n {\\n privateKey = vm.deriveKey(mnemonic, index);\\n who = vm.rememberKey(privateKey);\\n }\\n\\n function _bytesToUint(bytes memory b) private pure returns (uint256) {\\n require(b.length <= 32, \\\"StdCheats _bytesToUint(bytes): Bytes length exceeds 32.\\\");\\n return abi.decode(abi.encodePacked(new bytes(32 - b.length), b), (uint256));\\n }\\n\\n function isFork() internal view virtual returns (bool status) {\\n try vm.activeFork() {\\n status = true;\\n } catch (bytes memory) {}\\n }\\n\\n modifier skipWhenForking() {\\n if (!isFork()) {\\n _;\\n }\\n }\\n\\n modifier skipWhenNotForking() {\\n if (isFork()) {\\n _;\\n }\\n }\\n\\n modifier noGasMetering() {\\n vm.pauseGasMetering();\\n // To prevent turning gas monitoring back on with nested functions that use this modifier,\\n // we check if gasMetering started in the off position. If it did, we don't want to turn\\n // it back on until we exit the top level function that used the modifier\\n //\\n // i.e. funcA() noGasMetering { funcB() }, where funcB has noGasMetering as well.\\n // funcA will have `gasStartedOff` as false, funcB will have it as true,\\n // so we only turn metering back on at the end of the funcA\\n bool gasStartedOff = gasMeteringOff;\\n gasMeteringOff = true;\\n\\n _;\\n\\n // if gas metering was on when this modifier was called, turn it back on at the end\\n if (!gasStartedOff) {\\n gasMeteringOff = false;\\n vm.resumeGasMetering();\\n }\\n }\\n\\n // We use this complex approach of `_viewChainId` and `_pureChainId` to ensure there are no\\n // compiler warnings when accessing chain ID in any solidity version supported by forge-std. We\\n // can't simply access the chain ID in a normal view or pure function because the solc View Pure\\n // Checker changed `chainid` from pure to view in 0.8.0.\\n function _viewChainId() private view returns (uint256 chainId) {\\n // Assembly required since `block.chainid` was introduced in 0.8.0.\\n assembly {\\n chainId := chainid()\\n }\\n\\n address(this); // Silence warnings in older Solc versions.\\n }\\n\\n function _pureChainId() private pure returns (uint256 chainId) {\\n function() internal view returns (uint256) fnIn = _viewChainId;\\n function() internal pure returns (uint256) pureChainId;\\n assembly {\\n pureChainId := fnIn\\n }\\n chainId = pureChainId();\\n }\\n}\\n\\n// Wrappers around cheatcodes to avoid footguns\\nabstract contract StdCheats is StdCheatsSafe {\\n using stdStorage for StdStorage;\\n\\n StdStorage private stdstore;\\n Vm private constant vm = Vm(address(uint160(uint256(keccak256(\\\"hevm cheat code\\\")))));\\n address private constant CONSOLE2_ADDRESS = 0x000000000000000000636F6e736F6c652e6c6f67;\\n\\n // Skip forward or rewind time by the specified number of seconds\\n function skip(uint256 time) internal virtual {\\n vm.warp(vm.getBlockTimestamp() + time);\\n }\\n\\n function rewind(uint256 time) internal virtual {\\n vm.warp(vm.getBlockTimestamp() - time);\\n }\\n\\n // Setup a prank from an address that has some ether\\n function hoax(address msgSender) internal virtual {\\n vm.deal(msgSender, 1 << 128);\\n vm.prank(msgSender);\\n }\\n\\n function hoax(address msgSender, uint256 give) internal virtual {\\n vm.deal(msgSender, give);\\n vm.prank(msgSender);\\n }\\n\\n function hoax(address msgSender, address origin) internal virtual {\\n vm.deal(msgSender, 1 << 128);\\n vm.prank(msgSender, origin);\\n }\\n\\n function hoax(address msgSender, address origin, uint256 give) internal virtual {\\n vm.deal(msgSender, give);\\n vm.prank(msgSender, origin);\\n }\\n\\n // Start perpetual prank from an address that has some ether\\n function startHoax(address msgSender) internal virtual {\\n vm.deal(msgSender, 1 << 128);\\n vm.startPrank(msgSender);\\n }\\n\\n function startHoax(address msgSender, uint256 give) internal virtual {\\n vm.deal(msgSender, give);\\n vm.startPrank(msgSender);\\n }\\n\\n // Start perpetual prank from an address that has some ether\\n // tx.origin is set to the origin parameter\\n function startHoax(address msgSender, address origin) internal virtual {\\n vm.deal(msgSender, 1 << 128);\\n vm.startPrank(msgSender, origin);\\n }\\n\\n function startHoax(address msgSender, address origin, uint256 give) internal virtual {\\n vm.deal(msgSender, give);\\n vm.startPrank(msgSender, origin);\\n }\\n\\n function changePrank(address msgSender) internal virtual {\\n console2_log_StdCheats(\\\"changePrank is deprecated. Please use vm.startPrank instead.\\\");\\n vm.stopPrank();\\n vm.startPrank(msgSender);\\n }\\n\\n function changePrank(address msgSender, address txOrigin) internal virtual {\\n vm.stopPrank();\\n vm.startPrank(msgSender, txOrigin);\\n }\\n\\n // The same as Vm's `deal`\\n // Use the alternative signature for ERC20 tokens\\n function deal(address to, uint256 give) internal virtual {\\n vm.deal(to, give);\\n }\\n\\n // Set the balance of an account for any ERC20 token\\n // Use the alternative signature to update `totalSupply`\\n function deal(address token, address to, uint256 give) internal virtual {\\n deal(token, to, give, false);\\n }\\n\\n // Set the balance of an account for any ERC1155 token\\n // Use the alternative signature to update `totalSupply`\\n function dealERC1155(address token, address to, uint256 id, uint256 give) internal virtual {\\n dealERC1155(token, to, id, give, false);\\n }\\n\\n function deal(address token, address to, uint256 give, bool adjust) internal virtual {\\n // get current balance\\n (, bytes memory balData) = token.staticcall(abi.encodeWithSelector(0x70a08231, to));\\n uint256 prevBal = abi.decode(balData, (uint256));\\n\\n // update balance\\n stdstore.target(token).sig(0x70a08231).with_key(to).checked_write(give);\\n\\n // update total supply\\n if (adjust) {\\n (, bytes memory totSupData) = token.staticcall(abi.encodeWithSelector(0x18160ddd));\\n uint256 totSup = abi.decode(totSupData, (uint256));\\n if (give < prevBal) {\\n totSup -= (prevBal - give);\\n } else {\\n totSup += (give - prevBal);\\n }\\n stdstore.target(token).sig(0x18160ddd).checked_write(totSup);\\n }\\n }\\n\\n function dealERC1155(address token, address to, uint256 id, uint256 give, bool adjust) internal virtual {\\n // get current balance\\n (, bytes memory balData) = token.staticcall(abi.encodeWithSelector(0x00fdd58e, to, id));\\n uint256 prevBal = abi.decode(balData, (uint256));\\n\\n // update balance\\n stdstore.target(token).sig(0x00fdd58e).with_key(to).with_key(id).checked_write(give);\\n\\n // update total supply\\n if (adjust) {\\n (, bytes memory totSupData) = token.staticcall(abi.encodeWithSelector(0xbd85b039, id));\\n require(\\n totSupData.length != 0,\\n \\\"StdCheats deal(address,address,uint,uint,bool): target contract is not ERC1155Supply.\\\"\\n );\\n uint256 totSup = abi.decode(totSupData, (uint256));\\n if (give < prevBal) {\\n totSup -= (prevBal - give);\\n } else {\\n totSup += (give - prevBal);\\n }\\n stdstore.target(token).sig(0xbd85b039).with_key(id).checked_write(totSup);\\n }\\n }\\n\\n function dealERC721(address token, address to, uint256 id) internal virtual {\\n // check if token id is already minted and the actual owner.\\n (bool successMinted, bytes memory ownerData) = token.staticcall(abi.encodeWithSelector(0x6352211e, id));\\n require(successMinted, \\\"StdCheats deal(address,address,uint,bool): id not minted.\\\");\\n\\n // get owner current balance\\n (, bytes memory fromBalData) =\\n token.staticcall(abi.encodeWithSelector(0x70a08231, abi.decode(ownerData, (address))));\\n uint256 fromPrevBal = abi.decode(fromBalData, (uint256));\\n\\n // get new user current balance\\n (, bytes memory toBalData) = token.staticcall(abi.encodeWithSelector(0x70a08231, to));\\n uint256 toPrevBal = abi.decode(toBalData, (uint256));\\n\\n // update balances\\n stdstore.target(token).sig(0x70a08231).with_key(abi.decode(ownerData, (address))).checked_write(--fromPrevBal);\\n stdstore.target(token).sig(0x70a08231).with_key(to).checked_write(++toPrevBal);\\n\\n // update owner\\n stdstore.target(token).sig(0x6352211e).with_key(id).checked_write(to);\\n }\\n\\n function deployCodeTo(string memory what, address where) internal virtual {\\n deployCodeTo(what, \\\"\\\", 0, where);\\n }\\n\\n function deployCodeTo(string memory what, bytes memory args, address where) internal virtual {\\n deployCodeTo(what, args, 0, where);\\n }\\n\\n function deployCodeTo(string memory what, bytes memory args, uint256 value, address where) internal virtual {\\n bytes memory creationCode = vm.getCode(what);\\n vm.etch(where, abi.encodePacked(creationCode, args));\\n (bool success, bytes memory runtimeBytecode) = where.call{value: value}(\\\"\\\");\\n require(success, \\\"StdCheats deployCodeTo(string,bytes,uint256,address): Failed to create runtime bytecode.\\\");\\n vm.etch(where, runtimeBytecode);\\n }\\n\\n // Used to prevent the compilation of console, which shortens the compilation time when console is not used elsewhere.\\n function console2_log_StdCheats(string memory p0) private view {\\n (bool status,) = address(CONSOLE2_ADDRESS).staticcall(abi.encodeWithSignature(\\\"log(string)\\\", p0));\\n status;\\n }\\n}\\n\",\"keccak256\":\"0x0fa6ec03602648b62cce41aab2096e6b7e052f2846075d967b6958dd586db746\",\"license\":\"MIT\"},\"lib/forge-std/src/StdConstants.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity >=0.6.2 <0.9.0;\\n\\nimport {IMulticall3} from \\\"./interfaces/IMulticall3.sol\\\";\\nimport {Vm} from \\\"./Vm.sol\\\";\\n\\nlibrary StdConstants {\\n /// @dev Cheat code address.\\n /// Calculated as `address(uint160(uint256(keccak256(\\\"hevm cheat code\\\"))))`.\\n Vm internal constant VM = Vm(0x7109709ECfa91a80626fF3989D68f67F5b1DD12D);\\n /// @dev console.sol and console2.sol work by executing a staticcall to this address.\\n /// Calculated as `address(uint160(uint88(bytes11(\\\"console.log\\\"))))`.\\n address internal constant CONSOLE = 0x000000000000000000636F6e736F6c652e6c6f67;\\n /// @dev Used when deploying with create2.\\n /// Taken from https://github.com/Arachnid/deterministic-deployment-proxy.\\n address internal constant CREATE2_FACTORY = 0x4e59b44847b379578588920cA78FbF26c0B4956C;\\n /// @dev The default address for tx.origin and msg.sender.\\n /// Calculated as `address(uint160(uint256(keccak256(\\\"foundry default caller\\\"))))`.\\n address internal constant DEFAULT_SENDER = 0x1804c8AB1F12E6bbf3894d4083f33e07309d1f38;\\n /// @dev The address of the first contract `CREATE`d by a running test contract.\\n /// When running tests, each test contract is `CREATE`d by `DEFAULT_SENDER` with nonce 1.\\n /// Calculated as `VM.computeCreateAddress(VM.computeCreateAddress(DEFAULT_SENDER, 1), 1)`.\\n address internal constant DEFAULT_TEST_CONTRACT = 0x5615dEB798BB3E4dFa0139dFa1b3D433Cc23b72f;\\n /// @dev Deterministic deployment address of the Multicall3 contract.\\n /// Taken from https://www.multicall3.com.\\n IMulticall3 internal constant MULTICALL3_ADDRESS = IMulticall3(0xcA11bde05977b3631167028862bE2a173976CA11);\\n /// @dev The order of the secp256k1 curve.\\n uint256 internal constant SECP256K1_ORDER =\\n 115792089237316195423570985008687907852837564279074904382605163141518161494337;\\n}\\n\",\"keccak256\":\"0x319ccdabfa2c0b2428301445873270ffea20f0e039d4fd5e6eeba65158e4e534\",\"license\":\"MIT\"},\"lib/forge-std/src/StdJson.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity >=0.6.0 <0.9.0;\\n\\npragma experimental ABIEncoderV2;\\n\\nimport {VmSafe} from \\\"./Vm.sol\\\";\\n\\n// Helpers for parsing and writing JSON files\\n// To parse:\\n// ```\\n// using stdJson for string;\\n// string memory json = vm.readFile(\\\"\\\");\\n// json.readUint(\\\"\\\");\\n// ```\\n// To write:\\n// ```\\n// using stdJson for string;\\n// string memory json = \\\"json\\\";\\n// json.serialize(\\\"a\\\", uint256(123));\\n// string memory semiFinal = json.serialize(\\\"b\\\", string(\\\"test\\\"));\\n// string memory finalJson = json.serialize(\\\"c\\\", semiFinal);\\n// finalJson.write(\\\"\\\");\\n// ```\\n\\nlibrary stdJson {\\n VmSafe private constant vm = VmSafe(address(uint160(uint256(keccak256(\\\"hevm cheat code\\\")))));\\n\\n function keyExists(string memory json, string memory key) internal view returns (bool) {\\n return vm.keyExistsJson(json, key);\\n }\\n\\n function parseRaw(string memory json, string memory key) internal pure returns (bytes memory) {\\n return vm.parseJson(json, key);\\n }\\n\\n function readUint(string memory json, string memory key) internal pure returns (uint256) {\\n return vm.parseJsonUint(json, key);\\n }\\n\\n function readUintArray(string memory json, string memory key) internal pure returns (uint256[] memory) {\\n return vm.parseJsonUintArray(json, key);\\n }\\n\\n function readInt(string memory json, string memory key) internal pure returns (int256) {\\n return vm.parseJsonInt(json, key);\\n }\\n\\n function readIntArray(string memory json, string memory key) internal pure returns (int256[] memory) {\\n return vm.parseJsonIntArray(json, key);\\n }\\n\\n function readBytes32(string memory json, string memory key) internal pure returns (bytes32) {\\n return vm.parseJsonBytes32(json, key);\\n }\\n\\n function readBytes32Array(string memory json, string memory key) internal pure returns (bytes32[] memory) {\\n return vm.parseJsonBytes32Array(json, key);\\n }\\n\\n function readString(string memory json, string memory key) internal pure returns (string memory) {\\n return vm.parseJsonString(json, key);\\n }\\n\\n function readStringArray(string memory json, string memory key) internal pure returns (string[] memory) {\\n return vm.parseJsonStringArray(json, key);\\n }\\n\\n function readAddress(string memory json, string memory key) internal pure returns (address) {\\n return vm.parseJsonAddress(json, key);\\n }\\n\\n function readAddressArray(string memory json, string memory key) internal pure returns (address[] memory) {\\n return vm.parseJsonAddressArray(json, key);\\n }\\n\\n function readBool(string memory json, string memory key) internal pure returns (bool) {\\n return vm.parseJsonBool(json, key);\\n }\\n\\n function readBoolArray(string memory json, string memory key) internal pure returns (bool[] memory) {\\n return vm.parseJsonBoolArray(json, key);\\n }\\n\\n function readBytes(string memory json, string memory key) internal pure returns (bytes memory) {\\n return vm.parseJsonBytes(json, key);\\n }\\n\\n function readBytesArray(string memory json, string memory key) internal pure returns (bytes[] memory) {\\n return vm.parseJsonBytesArray(json, key);\\n }\\n\\n function readUintOr(string memory json, string memory key, uint256 defaultValue) internal view returns (uint256) {\\n return keyExists(json, key) ? readUint(json, key) : defaultValue;\\n }\\n\\n function readUintArrayOr(string memory json, string memory key, uint256[] memory defaultValue)\\n internal\\n view\\n returns (uint256[] memory)\\n {\\n return keyExists(json, key) ? readUintArray(json, key) : defaultValue;\\n }\\n\\n function readIntOr(string memory json, string memory key, int256 defaultValue) internal view returns (int256) {\\n return keyExists(json, key) ? readInt(json, key) : defaultValue;\\n }\\n\\n function readIntArrayOr(string memory json, string memory key, int256[] memory defaultValue)\\n internal\\n view\\n returns (int256[] memory)\\n {\\n return keyExists(json, key) ? readIntArray(json, key) : defaultValue;\\n }\\n\\n function readBytes32Or(string memory json, string memory key, bytes32 defaultValue)\\n internal\\n view\\n returns (bytes32)\\n {\\n return keyExists(json, key) ? readBytes32(json, key) : defaultValue;\\n }\\n\\n function readBytes32ArrayOr(string memory json, string memory key, bytes32[] memory defaultValue)\\n internal\\n view\\n returns (bytes32[] memory)\\n {\\n return keyExists(json, key) ? readBytes32Array(json, key) : defaultValue;\\n }\\n\\n function readStringOr(string memory json, string memory key, string memory defaultValue)\\n internal\\n view\\n returns (string memory)\\n {\\n return keyExists(json, key) ? readString(json, key) : defaultValue;\\n }\\n\\n function readStringArrayOr(string memory json, string memory key, string[] memory defaultValue)\\n internal\\n view\\n returns (string[] memory)\\n {\\n return keyExists(json, key) ? readStringArray(json, key) : defaultValue;\\n }\\n\\n function readAddressOr(string memory json, string memory key, address defaultValue)\\n internal\\n view\\n returns (address)\\n {\\n return keyExists(json, key) ? readAddress(json, key) : defaultValue;\\n }\\n\\n function readAddressArrayOr(string memory json, string memory key, address[] memory defaultValue)\\n internal\\n view\\n returns (address[] memory)\\n {\\n return keyExists(json, key) ? readAddressArray(json, key) : defaultValue;\\n }\\n\\n function readBoolOr(string memory json, string memory key, bool defaultValue) internal view returns (bool) {\\n return keyExists(json, key) ? readBool(json, key) : defaultValue;\\n }\\n\\n function readBoolArrayOr(string memory json, string memory key, bool[] memory defaultValue)\\n internal\\n view\\n returns (bool[] memory)\\n {\\n return keyExists(json, key) ? readBoolArray(json, key) : defaultValue;\\n }\\n\\n function readBytesOr(string memory json, string memory key, bytes memory defaultValue)\\n internal\\n view\\n returns (bytes memory)\\n {\\n return keyExists(json, key) ? readBytes(json, key) : defaultValue;\\n }\\n\\n function readBytesArrayOr(string memory json, string memory key, bytes[] memory defaultValue)\\n internal\\n view\\n returns (bytes[] memory)\\n {\\n return keyExists(json, key) ? readBytesArray(json, key) : defaultValue;\\n }\\n\\n function serialize(string memory jsonKey, string memory rootObject) internal returns (string memory) {\\n return vm.serializeJson(jsonKey, rootObject);\\n }\\n\\n function serialize(string memory jsonKey, string memory key, bool value) internal returns (string memory) {\\n return vm.serializeBool(jsonKey, key, value);\\n }\\n\\n function serialize(string memory jsonKey, string memory key, bool[] memory value)\\n internal\\n returns (string memory)\\n {\\n return vm.serializeBool(jsonKey, key, value);\\n }\\n\\n function serialize(string memory jsonKey, string memory key, uint256 value) internal returns (string memory) {\\n return vm.serializeUint(jsonKey, key, value);\\n }\\n\\n function serialize(string memory jsonKey, string memory key, uint256[] memory value)\\n internal\\n returns (string memory)\\n {\\n return vm.serializeUint(jsonKey, key, value);\\n }\\n\\n function serialize(string memory jsonKey, string memory key, int256 value) internal returns (string memory) {\\n return vm.serializeInt(jsonKey, key, value);\\n }\\n\\n function serialize(string memory jsonKey, string memory key, int256[] memory value)\\n internal\\n returns (string memory)\\n {\\n return vm.serializeInt(jsonKey, key, value);\\n }\\n\\n function serialize(string memory jsonKey, string memory key, address value) internal returns (string memory) {\\n return vm.serializeAddress(jsonKey, key, value);\\n }\\n\\n function serialize(string memory jsonKey, string memory key, address[] memory value)\\n internal\\n returns (string memory)\\n {\\n return vm.serializeAddress(jsonKey, key, value);\\n }\\n\\n function serialize(string memory jsonKey, string memory key, bytes32 value) internal returns (string memory) {\\n return vm.serializeBytes32(jsonKey, key, value);\\n }\\n\\n function serialize(string memory jsonKey, string memory key, bytes32[] memory value)\\n internal\\n returns (string memory)\\n {\\n return vm.serializeBytes32(jsonKey, key, value);\\n }\\n\\n function serialize(string memory jsonKey, string memory key, bytes memory value) internal returns (string memory) {\\n return vm.serializeBytes(jsonKey, key, value);\\n }\\n\\n function serialize(string memory jsonKey, string memory key, bytes[] memory value)\\n internal\\n returns (string memory)\\n {\\n return vm.serializeBytes(jsonKey, key, value);\\n }\\n\\n function serialize(string memory jsonKey, string memory key, string memory value)\\n internal\\n returns (string memory)\\n {\\n return vm.serializeString(jsonKey, key, value);\\n }\\n\\n function serialize(string memory jsonKey, string memory key, string[] memory value)\\n internal\\n returns (string memory)\\n {\\n return vm.serializeString(jsonKey, key, value);\\n }\\n\\n function write(string memory jsonKey, string memory path) internal {\\n vm.writeJson(jsonKey, path);\\n }\\n\\n function write(string memory jsonKey, string memory path, string memory valueKey) internal {\\n vm.writeJson(jsonKey, path, valueKey);\\n }\\n}\\n\",\"keccak256\":\"0xbc0132abe1c2accc2867c0f03667afffdf92f3e95a581bb03c9557eaa38ea500\",\"license\":\"MIT\"},\"lib/forge-std/src/StdMath.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity >=0.6.2 <0.9.0;\\n\\nlibrary stdMath {\\n int256 private constant INT256_MIN = -57896044618658097711785492504343953926634992332820282019728792003956564819968;\\n\\n function abs(int256 a) internal pure returns (uint256) {\\n // Required or it will fail when `a = type(int256).min`\\n if (a == INT256_MIN) {\\n return 57896044618658097711785492504343953926634992332820282019728792003956564819968;\\n }\\n\\n return uint256(a > 0 ? a : -a);\\n }\\n\\n function delta(uint256 a, uint256 b) internal pure returns (uint256) {\\n return a > b ? a - b : b - a;\\n }\\n\\n function delta(int256 a, int256 b) internal pure returns (uint256) {\\n // a and b are of the same sign\\n // this works thanks to two's complement, the left-most bit is the sign bit\\n if ((a ^ b) > -1) {\\n return delta(abs(a), abs(b));\\n }\\n\\n // a and b are of opposite signs\\n return abs(a) + abs(b);\\n }\\n\\n function percentDelta(uint256 a, uint256 b) internal pure returns (uint256) {\\n uint256 absDelta = delta(a, b);\\n\\n return absDelta * 1e18 / b;\\n }\\n\\n function percentDelta(int256 a, int256 b) internal pure returns (uint256) {\\n uint256 absDelta = delta(a, b);\\n uint256 absB = abs(b);\\n\\n return absDelta * 1e18 / absB;\\n }\\n}\\n\",\"keccak256\":\"0xd90ad4fd8aeaeb8929964e686e769fdedd5eded3fc3815df194a0ab9f91a3fb2\",\"license\":\"MIT\"},\"lib/forge-std/src/StdStorage.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity >=0.6.2 <0.9.0;\\n\\nimport {Vm} from \\\"./Vm.sol\\\";\\n\\nstruct FindData {\\n uint256 slot;\\n uint256 offsetLeft;\\n uint256 offsetRight;\\n bool found;\\n}\\n\\nstruct StdStorage {\\n mapping(address => mapping(bytes4 => mapping(bytes32 => FindData))) finds;\\n bytes32[] _keys;\\n bytes4 _sig;\\n uint256 _depth;\\n address _target;\\n bytes32 _set;\\n bool _enable_packed_slots;\\n bytes _calldata;\\n}\\n\\nlibrary stdStorageSafe {\\n event SlotFound(address who, bytes4 fsig, bytes32 keysHash, uint256 slot);\\n event WARNING_UninitedSlot(address who, uint256 slot);\\n\\n Vm private constant vm = Vm(address(uint160(uint256(keccak256(\\\"hevm cheat code\\\")))));\\n uint256 constant UINT256_MAX = 115792089237316195423570985008687907853269984665640564039457584007913129639935;\\n\\n function sigs(string memory sigStr) internal pure returns (bytes4) {\\n return bytes4(keccak256(bytes(sigStr)));\\n }\\n\\n function getCallParams(StdStorage storage self) internal view returns (bytes memory) {\\n if (self._calldata.length == 0) {\\n return flatten(self._keys);\\n } else {\\n return self._calldata;\\n }\\n }\\n\\n // Calls target contract with configured parameters\\n function callTarget(StdStorage storage self) internal view returns (bool, bytes32) {\\n bytes memory cald = abi.encodePacked(self._sig, getCallParams(self));\\n (bool success, bytes memory rdat) = self._target.staticcall(cald);\\n bytes32 result = bytesToBytes32(rdat, 32 * self._depth);\\n\\n return (success, result);\\n }\\n\\n // Tries mutating slot value to determine if the targeted value is stored in it.\\n // If current value is 0, then we are setting slot value to type(uint256).max\\n // Otherwise, we set it to 0. That way, return value should always be affected.\\n function checkSlotMutatesCall(StdStorage storage self, bytes32 slot) internal returns (bool) {\\n bytes32 prevSlotValue = vm.load(self._target, slot);\\n (bool success, bytes32 prevReturnValue) = callTarget(self);\\n\\n bytes32 testVal = prevReturnValue == bytes32(0) ? bytes32(UINT256_MAX) : bytes32(0);\\n vm.store(self._target, slot, testVal);\\n\\n (, bytes32 newReturnValue) = callTarget(self);\\n\\n vm.store(self._target, slot, prevSlotValue);\\n\\n return (success && (prevReturnValue != newReturnValue));\\n }\\n\\n // Tries setting one of the bits in slot to 1 until return value changes.\\n // Index of resulted bit is an offset packed slot has from left/right side\\n function findOffset(StdStorage storage self, bytes32 slot, bool left) internal returns (bool, uint256) {\\n for (uint256 offset = 0; offset < 256; offset++) {\\n uint256 valueToPut = left ? (1 << (255 - offset)) : (1 << offset);\\n vm.store(self._target, slot, bytes32(valueToPut));\\n\\n (bool success, bytes32 data) = callTarget(self);\\n\\n if (success && (uint256(data) > 0)) {\\n return (true, offset);\\n }\\n }\\n return (false, 0);\\n }\\n\\n function findOffsets(StdStorage storage self, bytes32 slot) internal returns (bool, uint256, uint256) {\\n bytes32 prevSlotValue = vm.load(self._target, slot);\\n\\n (bool foundLeft, uint256 offsetLeft) = findOffset(self, slot, true);\\n (bool foundRight, uint256 offsetRight) = findOffset(self, slot, false);\\n\\n // `findOffset` may mutate slot value, so we are setting it to initial value\\n vm.store(self._target, slot, prevSlotValue);\\n return (foundLeft && foundRight, offsetLeft, offsetRight);\\n }\\n\\n function find(StdStorage storage self) internal returns (FindData storage) {\\n return find(self, true);\\n }\\n\\n /// @notice find an arbitrary storage slot given a function sig, input data, address of the contract and a value to check against\\n // slot complexity:\\n // if flat, will be bytes32(uint256(uint));\\n // if map, will be keccak256(abi.encode(key, uint(slot)));\\n // if deep map, will be keccak256(abi.encode(key1, keccak256(abi.encode(key0, uint(slot)))));\\n // if map struct, will be bytes32(uint256(keccak256(abi.encode(key1, keccak256(abi.encode(key0, uint(slot)))))) + structFieldDepth);\\n function find(StdStorage storage self, bool _clear) internal returns (FindData storage) {\\n address who = self._target;\\n bytes4 fsig = self._sig;\\n uint256 field_depth = self._depth;\\n bytes memory params = getCallParams(self);\\n\\n // calldata to test against\\n if (self.finds[who][fsig][keccak256(abi.encodePacked(params, field_depth))].found) {\\n if (_clear) {\\n clear(self);\\n }\\n return self.finds[who][fsig][keccak256(abi.encodePacked(params, field_depth))];\\n }\\n vm.record();\\n (, bytes32 callResult) = callTarget(self);\\n (bytes32[] memory reads,) = vm.accesses(address(who));\\n\\n if (reads.length == 0) {\\n revert(\\\"stdStorage find(StdStorage): No storage use detected for target.\\\");\\n } else {\\n for (uint256 i = reads.length; --i >= 0;) {\\n bytes32 prev = vm.load(who, reads[i]);\\n if (prev == bytes32(0)) {\\n emit WARNING_UninitedSlot(who, uint256(reads[i]));\\n }\\n\\n if (!checkSlotMutatesCall(self, reads[i])) {\\n continue;\\n }\\n\\n (uint256 offsetLeft, uint256 offsetRight) = (0, 0);\\n\\n if (self._enable_packed_slots) {\\n bool found;\\n (found, offsetLeft, offsetRight) = findOffsets(self, reads[i]);\\n if (!found) {\\n continue;\\n }\\n }\\n\\n // Check that value between found offsets is equal to the current call result\\n uint256 curVal = (uint256(prev) & getMaskByOffsets(offsetLeft, offsetRight)) >> offsetRight;\\n\\n if (uint256(callResult) != curVal) {\\n continue;\\n }\\n\\n emit SlotFound(who, fsig, keccak256(abi.encodePacked(params, field_depth)), uint256(reads[i]));\\n self.finds[who][fsig][keccak256(abi.encodePacked(params, field_depth))] =\\n FindData(uint256(reads[i]), offsetLeft, offsetRight, true);\\n break;\\n }\\n }\\n\\n require(\\n self.finds[who][fsig][keccak256(abi.encodePacked(params, field_depth))].found,\\n \\\"stdStorage find(StdStorage): Slot(s) not found.\\\"\\n );\\n\\n if (_clear) {\\n clear(self);\\n }\\n return self.finds[who][fsig][keccak256(abi.encodePacked(params, field_depth))];\\n }\\n\\n function target(StdStorage storage self, address _target) internal returns (StdStorage storage) {\\n self._target = _target;\\n return self;\\n }\\n\\n function sig(StdStorage storage self, bytes4 _sig) internal returns (StdStorage storage) {\\n self._sig = _sig;\\n return self;\\n }\\n\\n function sig(StdStorage storage self, string memory _sig) internal returns (StdStorage storage) {\\n self._sig = sigs(_sig);\\n return self;\\n }\\n\\n function with_calldata(StdStorage storage self, bytes memory _calldata) internal returns (StdStorage storage) {\\n self._calldata = _calldata;\\n return self;\\n }\\n\\n function with_key(StdStorage storage self, address who) internal returns (StdStorage storage) {\\n self._keys.push(bytes32(uint256(uint160(who))));\\n return self;\\n }\\n\\n function with_key(StdStorage storage self, uint256 amt) internal returns (StdStorage storage) {\\n self._keys.push(bytes32(amt));\\n return self;\\n }\\n\\n function with_key(StdStorage storage self, bytes32 key) internal returns (StdStorage storage) {\\n self._keys.push(key);\\n return self;\\n }\\n\\n function enable_packed_slots(StdStorage storage self) internal returns (StdStorage storage) {\\n self._enable_packed_slots = true;\\n return self;\\n }\\n\\n function depth(StdStorage storage self, uint256 _depth) internal returns (StdStorage storage) {\\n self._depth = _depth;\\n return self;\\n }\\n\\n function read(StdStorage storage self) private returns (bytes memory) {\\n FindData storage data = find(self, false);\\n uint256 mask = getMaskByOffsets(data.offsetLeft, data.offsetRight);\\n uint256 value = (uint256(vm.load(self._target, bytes32(data.slot))) & mask) >> data.offsetRight;\\n clear(self);\\n return abi.encode(value);\\n }\\n\\n function read_bytes32(StdStorage storage self) internal returns (bytes32) {\\n return abi.decode(read(self), (bytes32));\\n }\\n\\n function read_bool(StdStorage storage self) internal returns (bool) {\\n int256 v = read_int(self);\\n if (v == 0) return false;\\n if (v == 1) return true;\\n revert(\\\"stdStorage read_bool(StdStorage): Cannot decode. Make sure you are reading a bool.\\\");\\n }\\n\\n function read_address(StdStorage storage self) internal returns (address) {\\n return abi.decode(read(self), (address));\\n }\\n\\n function read_uint(StdStorage storage self) internal returns (uint256) {\\n return abi.decode(read(self), (uint256));\\n }\\n\\n function read_int(StdStorage storage self) internal returns (int256) {\\n return abi.decode(read(self), (int256));\\n }\\n\\n function parent(StdStorage storage self) internal returns (uint256, bytes32) {\\n address who = self._target;\\n uint256 field_depth = self._depth;\\n vm.startMappingRecording();\\n uint256 child = find(self, true).slot - field_depth;\\n (bool found, bytes32 key, bytes32 parent_slot) = vm.getMappingKeyAndParentOf(who, bytes32(child));\\n if (!found) {\\n revert(\\n \\\"stdStorage read_bool(StdStorage): Cannot find parent. Make sure you give a slot and startMappingRecording() has been called.\\\"\\n );\\n }\\n return (uint256(parent_slot), key);\\n }\\n\\n function root(StdStorage storage self) internal returns (uint256) {\\n address who = self._target;\\n uint256 field_depth = self._depth;\\n vm.startMappingRecording();\\n uint256 child = find(self, true).slot - field_depth;\\n bool found;\\n bytes32 root_slot;\\n bytes32 parent_slot;\\n (found,, parent_slot) = vm.getMappingKeyAndParentOf(who, bytes32(child));\\n if (!found) {\\n revert(\\n \\\"stdStorage read_bool(StdStorage): Cannot find parent. Make sure you give a slot and startMappingRecording() has been called.\\\"\\n );\\n }\\n while (found) {\\n root_slot = parent_slot;\\n (found,, parent_slot) = vm.getMappingKeyAndParentOf(who, bytes32(root_slot));\\n }\\n return uint256(root_slot);\\n }\\n\\n function bytesToBytes32(bytes memory b, uint256 offset) private pure returns (bytes32) {\\n bytes32 out;\\n\\n uint256 max = b.length > 32 ? 32 : b.length;\\n for (uint256 i = 0; i < max; i++) {\\n out |= bytes32(b[offset + i] & 0xFF) >> (i * 8);\\n }\\n return out;\\n }\\n\\n function flatten(bytes32[] memory b) private pure returns (bytes memory) {\\n bytes memory result = new bytes(b.length * 32);\\n for (uint256 i = 0; i < b.length; i++) {\\n bytes32 k = b[i];\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(add(result, add(32, mul(32, i))), k)\\n }\\n }\\n\\n return result;\\n }\\n\\n function clear(StdStorage storage self) internal {\\n delete self._target;\\n delete self._sig;\\n delete self._keys;\\n delete self._depth;\\n delete self._enable_packed_slots;\\n delete self._calldata;\\n }\\n\\n // Returns mask which contains non-zero bits for values between `offsetLeft` and `offsetRight`\\n // (slotValue & mask) >> offsetRight will be the value of the given packed variable\\n function getMaskByOffsets(uint256 offsetLeft, uint256 offsetRight) internal pure returns (uint256 mask) {\\n // mask = ((1 << (256 - (offsetRight + offsetLeft))) - 1) << offsetRight;\\n // using assembly because (1 << 256) causes overflow\\n assembly {\\n mask := shl(offsetRight, sub(shl(sub(256, add(offsetRight, offsetLeft)), 1), 1))\\n }\\n }\\n\\n // Returns slot value with updated packed variable.\\n function getUpdatedSlotValue(bytes32 curValue, uint256 varValue, uint256 offsetLeft, uint256 offsetRight)\\n internal\\n pure\\n returns (bytes32 newValue)\\n {\\n return bytes32((uint256(curValue) & ~getMaskByOffsets(offsetLeft, offsetRight)) | (varValue << offsetRight));\\n }\\n}\\n\\nlibrary stdStorage {\\n Vm private constant vm = Vm(address(uint160(uint256(keccak256(\\\"hevm cheat code\\\")))));\\n\\n function sigs(string memory sigStr) internal pure returns (bytes4) {\\n return stdStorageSafe.sigs(sigStr);\\n }\\n\\n function find(StdStorage storage self) internal returns (uint256) {\\n return find(self, true);\\n }\\n\\n function find(StdStorage storage self, bool _clear) internal returns (uint256) {\\n return stdStorageSafe.find(self, _clear).slot;\\n }\\n\\n function target(StdStorage storage self, address _target) internal returns (StdStorage storage) {\\n return stdStorageSafe.target(self, _target);\\n }\\n\\n function sig(StdStorage storage self, bytes4 _sig) internal returns (StdStorage storage) {\\n return stdStorageSafe.sig(self, _sig);\\n }\\n\\n function sig(StdStorage storage self, string memory _sig) internal returns (StdStorage storage) {\\n return stdStorageSafe.sig(self, _sig);\\n }\\n\\n function with_key(StdStorage storage self, address who) internal returns (StdStorage storage) {\\n return stdStorageSafe.with_key(self, who);\\n }\\n\\n function with_key(StdStorage storage self, uint256 amt) internal returns (StdStorage storage) {\\n return stdStorageSafe.with_key(self, amt);\\n }\\n\\n function with_key(StdStorage storage self, bytes32 key) internal returns (StdStorage storage) {\\n return stdStorageSafe.with_key(self, key);\\n }\\n\\n function with_calldata(StdStorage storage self, bytes memory _calldata) internal returns (StdStorage storage) {\\n return stdStorageSafe.with_calldata(self, _calldata);\\n }\\n\\n function enable_packed_slots(StdStorage storage self) internal returns (StdStorage storage) {\\n return stdStorageSafe.enable_packed_slots(self);\\n }\\n\\n function depth(StdStorage storage self, uint256 _depth) internal returns (StdStorage storage) {\\n return stdStorageSafe.depth(self, _depth);\\n }\\n\\n function clear(StdStorage storage self) internal {\\n stdStorageSafe.clear(self);\\n }\\n\\n function checked_write(StdStorage storage self, address who) internal {\\n checked_write(self, bytes32(uint256(uint160(who))));\\n }\\n\\n function checked_write(StdStorage storage self, uint256 amt) internal {\\n checked_write(self, bytes32(amt));\\n }\\n\\n function checked_write_int(StdStorage storage self, int256 val) internal {\\n checked_write(self, bytes32(uint256(val)));\\n }\\n\\n function checked_write(StdStorage storage self, bool write) internal {\\n bytes32 t;\\n /// @solidity memory-safe-assembly\\n assembly {\\n t := write\\n }\\n checked_write(self, t);\\n }\\n\\n function checked_write(StdStorage storage self, bytes32 set) internal {\\n address who = self._target;\\n bytes4 fsig = self._sig;\\n uint256 field_depth = self._depth;\\n bytes memory params = stdStorageSafe.getCallParams(self);\\n\\n if (!self.finds[who][fsig][keccak256(abi.encodePacked(params, field_depth))].found) {\\n find(self, false);\\n }\\n FindData storage data = self.finds[who][fsig][keccak256(abi.encodePacked(params, field_depth))];\\n if ((data.offsetLeft + data.offsetRight) > 0) {\\n uint256 maxVal = 2 ** (256 - (data.offsetLeft + data.offsetRight));\\n require(\\n uint256(set) < maxVal,\\n string(\\n abi.encodePacked(\\n \\\"stdStorage find(StdStorage): Packed slot. We can't fit value greater than \\\",\\n vm.toString(maxVal)\\n )\\n )\\n );\\n }\\n bytes32 curVal = vm.load(who, bytes32(data.slot));\\n bytes32 valToSet = stdStorageSafe.getUpdatedSlotValue(curVal, uint256(set), data.offsetLeft, data.offsetRight);\\n\\n vm.store(who, bytes32(data.slot), valToSet);\\n\\n (bool success, bytes32 callResult) = stdStorageSafe.callTarget(self);\\n\\n if (!success || callResult != set) {\\n vm.store(who, bytes32(data.slot), curVal);\\n revert(\\\"stdStorage find(StdStorage): Failed to write value.\\\");\\n }\\n clear(self);\\n }\\n\\n function read_bytes32(StdStorage storage self) internal returns (bytes32) {\\n return stdStorageSafe.read_bytes32(self);\\n }\\n\\n function read_bool(StdStorage storage self) internal returns (bool) {\\n return stdStorageSafe.read_bool(self);\\n }\\n\\n function read_address(StdStorage storage self) internal returns (address) {\\n return stdStorageSafe.read_address(self);\\n }\\n\\n function read_uint(StdStorage storage self) internal returns (uint256) {\\n return stdStorageSafe.read_uint(self);\\n }\\n\\n function read_int(StdStorage storage self) internal returns (int256) {\\n return stdStorageSafe.read_int(self);\\n }\\n\\n function parent(StdStorage storage self) internal returns (uint256, bytes32) {\\n return stdStorageSafe.parent(self);\\n }\\n\\n function root(StdStorage storage self) internal returns (uint256) {\\n return stdStorageSafe.root(self);\\n }\\n}\\n\",\"keccak256\":\"0xb91ab24383a5872b894fc93325eef1add6cbbf981628f18e860068bf88bb7dcc\",\"license\":\"MIT\"},\"lib/forge-std/src/StdStyle.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity >=0.4.22 <0.9.0;\\n\\nimport {VmSafe} from \\\"./Vm.sol\\\";\\n\\nlibrary StdStyle {\\n VmSafe private constant vm = VmSafe(address(uint160(uint256(keccak256(\\\"hevm cheat code\\\")))));\\n\\n string constant RED = \\\"\\\\u001b[91m\\\";\\n string constant GREEN = \\\"\\\\u001b[92m\\\";\\n string constant YELLOW = \\\"\\\\u001b[93m\\\";\\n string constant BLUE = \\\"\\\\u001b[94m\\\";\\n string constant MAGENTA = \\\"\\\\u001b[95m\\\";\\n string constant CYAN = \\\"\\\\u001b[96m\\\";\\n string constant BOLD = \\\"\\\\u001b[1m\\\";\\n string constant DIM = \\\"\\\\u001b[2m\\\";\\n string constant ITALIC = \\\"\\\\u001b[3m\\\";\\n string constant UNDERLINE = \\\"\\\\u001b[4m\\\";\\n string constant INVERSE = \\\"\\\\u001b[7m\\\";\\n string constant RESET = \\\"\\\\u001b[0m\\\";\\n\\n function styleConcat(string memory style, string memory self) private pure returns (string memory) {\\n return string(abi.encodePacked(style, self, RESET));\\n }\\n\\n function red(string memory self) internal pure returns (string memory) {\\n return styleConcat(RED, self);\\n }\\n\\n function red(uint256 self) internal pure returns (string memory) {\\n return red(vm.toString(self));\\n }\\n\\n function red(int256 self) internal pure returns (string memory) {\\n return red(vm.toString(self));\\n }\\n\\n function red(address self) internal pure returns (string memory) {\\n return red(vm.toString(self));\\n }\\n\\n function red(bool self) internal pure returns (string memory) {\\n return red(vm.toString(self));\\n }\\n\\n function redBytes(bytes memory self) internal pure returns (string memory) {\\n return red(vm.toString(self));\\n }\\n\\n function redBytes32(bytes32 self) internal pure returns (string memory) {\\n return red(vm.toString(self));\\n }\\n\\n function green(string memory self) internal pure returns (string memory) {\\n return styleConcat(GREEN, self);\\n }\\n\\n function green(uint256 self) internal pure returns (string memory) {\\n return green(vm.toString(self));\\n }\\n\\n function green(int256 self) internal pure returns (string memory) {\\n return green(vm.toString(self));\\n }\\n\\n function green(address self) internal pure returns (string memory) {\\n return green(vm.toString(self));\\n }\\n\\n function green(bool self) internal pure returns (string memory) {\\n return green(vm.toString(self));\\n }\\n\\n function greenBytes(bytes memory self) internal pure returns (string memory) {\\n return green(vm.toString(self));\\n }\\n\\n function greenBytes32(bytes32 self) internal pure returns (string memory) {\\n return green(vm.toString(self));\\n }\\n\\n function yellow(string memory self) internal pure returns (string memory) {\\n return styleConcat(YELLOW, self);\\n }\\n\\n function yellow(uint256 self) internal pure returns (string memory) {\\n return yellow(vm.toString(self));\\n }\\n\\n function yellow(int256 self) internal pure returns (string memory) {\\n return yellow(vm.toString(self));\\n }\\n\\n function yellow(address self) internal pure returns (string memory) {\\n return yellow(vm.toString(self));\\n }\\n\\n function yellow(bool self) internal pure returns (string memory) {\\n return yellow(vm.toString(self));\\n }\\n\\n function yellowBytes(bytes memory self) internal pure returns (string memory) {\\n return yellow(vm.toString(self));\\n }\\n\\n function yellowBytes32(bytes32 self) internal pure returns (string memory) {\\n return yellow(vm.toString(self));\\n }\\n\\n function blue(string memory self) internal pure returns (string memory) {\\n return styleConcat(BLUE, self);\\n }\\n\\n function blue(uint256 self) internal pure returns (string memory) {\\n return blue(vm.toString(self));\\n }\\n\\n function blue(int256 self) internal pure returns (string memory) {\\n return blue(vm.toString(self));\\n }\\n\\n function blue(address self) internal pure returns (string memory) {\\n return blue(vm.toString(self));\\n }\\n\\n function blue(bool self) internal pure returns (string memory) {\\n return blue(vm.toString(self));\\n }\\n\\n function blueBytes(bytes memory self) internal pure returns (string memory) {\\n return blue(vm.toString(self));\\n }\\n\\n function blueBytes32(bytes32 self) internal pure returns (string memory) {\\n return blue(vm.toString(self));\\n }\\n\\n function magenta(string memory self) internal pure returns (string memory) {\\n return styleConcat(MAGENTA, self);\\n }\\n\\n function magenta(uint256 self) internal pure returns (string memory) {\\n return magenta(vm.toString(self));\\n }\\n\\n function magenta(int256 self) internal pure returns (string memory) {\\n return magenta(vm.toString(self));\\n }\\n\\n function magenta(address self) internal pure returns (string memory) {\\n return magenta(vm.toString(self));\\n }\\n\\n function magenta(bool self) internal pure returns (string memory) {\\n return magenta(vm.toString(self));\\n }\\n\\n function magentaBytes(bytes memory self) internal pure returns (string memory) {\\n return magenta(vm.toString(self));\\n }\\n\\n function magentaBytes32(bytes32 self) internal pure returns (string memory) {\\n return magenta(vm.toString(self));\\n }\\n\\n function cyan(string memory self) internal pure returns (string memory) {\\n return styleConcat(CYAN, self);\\n }\\n\\n function cyan(uint256 self) internal pure returns (string memory) {\\n return cyan(vm.toString(self));\\n }\\n\\n function cyan(int256 self) internal pure returns (string memory) {\\n return cyan(vm.toString(self));\\n }\\n\\n function cyan(address self) internal pure returns (string memory) {\\n return cyan(vm.toString(self));\\n }\\n\\n function cyan(bool self) internal pure returns (string memory) {\\n return cyan(vm.toString(self));\\n }\\n\\n function cyanBytes(bytes memory self) internal pure returns (string memory) {\\n return cyan(vm.toString(self));\\n }\\n\\n function cyanBytes32(bytes32 self) internal pure returns (string memory) {\\n return cyan(vm.toString(self));\\n }\\n\\n function bold(string memory self) internal pure returns (string memory) {\\n return styleConcat(BOLD, self);\\n }\\n\\n function bold(uint256 self) internal pure returns (string memory) {\\n return bold(vm.toString(self));\\n }\\n\\n function bold(int256 self) internal pure returns (string memory) {\\n return bold(vm.toString(self));\\n }\\n\\n function bold(address self) internal pure returns (string memory) {\\n return bold(vm.toString(self));\\n }\\n\\n function bold(bool self) internal pure returns (string memory) {\\n return bold(vm.toString(self));\\n }\\n\\n function boldBytes(bytes memory self) internal pure returns (string memory) {\\n return bold(vm.toString(self));\\n }\\n\\n function boldBytes32(bytes32 self) internal pure returns (string memory) {\\n return bold(vm.toString(self));\\n }\\n\\n function dim(string memory self) internal pure returns (string memory) {\\n return styleConcat(DIM, self);\\n }\\n\\n function dim(uint256 self) internal pure returns (string memory) {\\n return dim(vm.toString(self));\\n }\\n\\n function dim(int256 self) internal pure returns (string memory) {\\n return dim(vm.toString(self));\\n }\\n\\n function dim(address self) internal pure returns (string memory) {\\n return dim(vm.toString(self));\\n }\\n\\n function dim(bool self) internal pure returns (string memory) {\\n return dim(vm.toString(self));\\n }\\n\\n function dimBytes(bytes memory self) internal pure returns (string memory) {\\n return dim(vm.toString(self));\\n }\\n\\n function dimBytes32(bytes32 self) internal pure returns (string memory) {\\n return dim(vm.toString(self));\\n }\\n\\n function italic(string memory self) internal pure returns (string memory) {\\n return styleConcat(ITALIC, self);\\n }\\n\\n function italic(uint256 self) internal pure returns (string memory) {\\n return italic(vm.toString(self));\\n }\\n\\n function italic(int256 self) internal pure returns (string memory) {\\n return italic(vm.toString(self));\\n }\\n\\n function italic(address self) internal pure returns (string memory) {\\n return italic(vm.toString(self));\\n }\\n\\n function italic(bool self) internal pure returns (string memory) {\\n return italic(vm.toString(self));\\n }\\n\\n function italicBytes(bytes memory self) internal pure returns (string memory) {\\n return italic(vm.toString(self));\\n }\\n\\n function italicBytes32(bytes32 self) internal pure returns (string memory) {\\n return italic(vm.toString(self));\\n }\\n\\n function underline(string memory self) internal pure returns (string memory) {\\n return styleConcat(UNDERLINE, self);\\n }\\n\\n function underline(uint256 self) internal pure returns (string memory) {\\n return underline(vm.toString(self));\\n }\\n\\n function underline(int256 self) internal pure returns (string memory) {\\n return underline(vm.toString(self));\\n }\\n\\n function underline(address self) internal pure returns (string memory) {\\n return underline(vm.toString(self));\\n }\\n\\n function underline(bool self) internal pure returns (string memory) {\\n return underline(vm.toString(self));\\n }\\n\\n function underlineBytes(bytes memory self) internal pure returns (string memory) {\\n return underline(vm.toString(self));\\n }\\n\\n function underlineBytes32(bytes32 self) internal pure returns (string memory) {\\n return underline(vm.toString(self));\\n }\\n\\n function inverse(string memory self) internal pure returns (string memory) {\\n return styleConcat(INVERSE, self);\\n }\\n\\n function inverse(uint256 self) internal pure returns (string memory) {\\n return inverse(vm.toString(self));\\n }\\n\\n function inverse(int256 self) internal pure returns (string memory) {\\n return inverse(vm.toString(self));\\n }\\n\\n function inverse(address self) internal pure returns (string memory) {\\n return inverse(vm.toString(self));\\n }\\n\\n function inverse(bool self) internal pure returns (string memory) {\\n return inverse(vm.toString(self));\\n }\\n\\n function inverseBytes(bytes memory self) internal pure returns (string memory) {\\n return inverse(vm.toString(self));\\n }\\n\\n function inverseBytes32(bytes32 self) internal pure returns (string memory) {\\n return inverse(vm.toString(self));\\n }\\n}\\n\",\"keccak256\":\"0x43e2a8a9b9c2574dabe74f11adf6f782df218f463540e3b5b563609fe108597d\",\"license\":\"MIT\"},\"lib/forge-std/src/StdUtils.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity >=0.6.2 <0.9.0;\\n\\npragma experimental ABIEncoderV2;\\n\\nimport {IMulticall3} from \\\"./interfaces/IMulticall3.sol\\\";\\nimport {VmSafe} from \\\"./Vm.sol\\\";\\n\\nabstract contract StdUtils {\\n /*//////////////////////////////////////////////////////////////////////////\\n CONSTANTS\\n //////////////////////////////////////////////////////////////////////////*/\\n\\n IMulticall3 private constant multicall = IMulticall3(0xcA11bde05977b3631167028862bE2a173976CA11);\\n VmSafe private constant vm = VmSafe(address(uint160(uint256(keccak256(\\\"hevm cheat code\\\")))));\\n address private constant CONSOLE2_ADDRESS = 0x000000000000000000636F6e736F6c652e6c6f67;\\n uint256 private constant INT256_MIN_ABS =\\n 57896044618658097711785492504343953926634992332820282019728792003956564819968;\\n uint256 private constant SECP256K1_ORDER =\\n 115792089237316195423570985008687907852837564279074904382605163141518161494337;\\n uint256 private constant UINT256_MAX =\\n 115792089237316195423570985008687907853269984665640564039457584007913129639935;\\n\\n // Used by default when deploying with create2, https://github.com/Arachnid/deterministic-deployment-proxy.\\n address private constant CREATE2_FACTORY = 0x4e59b44847b379578588920cA78FbF26c0B4956C;\\n\\n /*//////////////////////////////////////////////////////////////////////////\\n INTERNAL FUNCTIONS\\n //////////////////////////////////////////////////////////////////////////*/\\n\\n function _bound(uint256 x, uint256 min, uint256 max) internal pure virtual returns (uint256 result) {\\n require(min <= max, \\\"StdUtils bound(uint256,uint256,uint256): Max is less than min.\\\");\\n // If x is between min and max, return x directly. This is to ensure that dictionary values\\n // do not get shifted if the min is nonzero. More info: https://github.com/foundry-rs/forge-std/issues/188\\n if (x >= min && x <= max) return x;\\n\\n uint256 size = max - min + 1;\\n\\n // If the value is 0, 1, 2, 3, wrap that to min, min+1, min+2, min+3. Similarly for the UINT256_MAX side.\\n // This helps ensure coverage of the min/max values.\\n if (x <= 3 && size > x) return min + x;\\n if (x >= UINT256_MAX - 3 && size > UINT256_MAX - x) return max - (UINT256_MAX - x);\\n\\n // Otherwise, wrap x into the range [min, max], i.e. the range is inclusive.\\n if (x > max) {\\n uint256 diff = x - max;\\n uint256 rem = diff % size;\\n if (rem == 0) return max;\\n result = min + rem - 1;\\n } else if (x < min) {\\n uint256 diff = min - x;\\n uint256 rem = diff % size;\\n if (rem == 0) return min;\\n result = max - rem + 1;\\n }\\n }\\n\\n function bound(uint256 x, uint256 min, uint256 max) internal pure virtual returns (uint256 result) {\\n result = _bound(x, min, max);\\n console2_log_StdUtils(\\\"Bound result\\\", result);\\n }\\n\\n function _bound(int256 x, int256 min, int256 max) internal pure virtual returns (int256 result) {\\n require(min <= max, \\\"StdUtils bound(int256,int256,int256): Max is less than min.\\\");\\n\\n // Shifting all int256 values to uint256 to use _bound function. The range of two types are:\\n // int256 : -(2**255) ~ (2**255 - 1)\\n // uint256: 0 ~ (2**256 - 1)\\n // So, add 2**255, INT256_MIN_ABS to the integer values.\\n //\\n // If the given integer value is -2**255, we cannot use `-uint256(-x)` because of the overflow.\\n // So, use `~uint256(x) + 1` instead.\\n uint256 _x = x < 0 ? (INT256_MIN_ABS - ~uint256(x) - 1) : (uint256(x) + INT256_MIN_ABS);\\n uint256 _min = min < 0 ? (INT256_MIN_ABS - ~uint256(min) - 1) : (uint256(min) + INT256_MIN_ABS);\\n uint256 _max = max < 0 ? (INT256_MIN_ABS - ~uint256(max) - 1) : (uint256(max) + INT256_MIN_ABS);\\n\\n uint256 y = _bound(_x, _min, _max);\\n\\n // To move it back to int256 value, subtract INT256_MIN_ABS at here.\\n result = y < INT256_MIN_ABS ? int256(~(INT256_MIN_ABS - y) + 1) : int256(y - INT256_MIN_ABS);\\n }\\n\\n function bound(int256 x, int256 min, int256 max) internal pure virtual returns (int256 result) {\\n result = _bound(x, min, max);\\n console2_log_StdUtils(\\\"Bound result\\\", vm.toString(result));\\n }\\n\\n function boundPrivateKey(uint256 privateKey) internal pure virtual returns (uint256 result) {\\n result = _bound(privateKey, 1, SECP256K1_ORDER - 1);\\n }\\n\\n function bytesToUint(bytes memory b) internal pure virtual returns (uint256) {\\n require(b.length <= 32, \\\"StdUtils bytesToUint(bytes): Bytes length exceeds 32.\\\");\\n return abi.decode(abi.encodePacked(new bytes(32 - b.length), b), (uint256));\\n }\\n\\n /// @dev Compute the address a contract will be deployed at for a given deployer address and nonce\\n /// @notice adapted from Solmate implementation (https://github.com/Rari-Capital/solmate/blob/main/src/utils/LibRLP.sol)\\n function computeCreateAddress(address deployer, uint256 nonce) internal pure virtual returns (address) {\\n console2_log_StdUtils(\\\"computeCreateAddress is deprecated. Please use vm.computeCreateAddress instead.\\\");\\n return vm.computeCreateAddress(deployer, nonce);\\n }\\n\\n function computeCreate2Address(bytes32 salt, bytes32 initcodeHash, address deployer)\\n internal\\n pure\\n virtual\\n returns (address)\\n {\\n console2_log_StdUtils(\\\"computeCreate2Address is deprecated. Please use vm.computeCreate2Address instead.\\\");\\n return vm.computeCreate2Address(salt, initcodeHash, deployer);\\n }\\n\\n /// @dev returns the address of a contract created with CREATE2 using the default CREATE2 deployer\\n function computeCreate2Address(bytes32 salt, bytes32 initCodeHash) internal pure returns (address) {\\n console2_log_StdUtils(\\\"computeCreate2Address is deprecated. Please use vm.computeCreate2Address instead.\\\");\\n return vm.computeCreate2Address(salt, initCodeHash);\\n }\\n\\n /// @dev returns the hash of the init code (creation code + no args) used in CREATE2 with no constructor arguments\\n /// @param creationCode the creation code of a contract C, as returned by type(C).creationCode\\n function hashInitCode(bytes memory creationCode) internal pure returns (bytes32) {\\n return hashInitCode(creationCode, \\\"\\\");\\n }\\n\\n /// @dev returns the hash of the init code (creation code + ABI-encoded args) used in CREATE2\\n /// @param creationCode the creation code of a contract C, as returned by type(C).creationCode\\n /// @param args the ABI-encoded arguments to the constructor of C\\n function hashInitCode(bytes memory creationCode, bytes memory args) internal pure returns (bytes32) {\\n return keccak256(abi.encodePacked(creationCode, args));\\n }\\n\\n // Performs a single call with Multicall3 to query the ERC-20 token balances of the given addresses.\\n function getTokenBalances(address token, address[] memory addresses)\\n internal\\n virtual\\n returns (uint256[] memory balances)\\n {\\n uint256 tokenCodeSize;\\n assembly {\\n tokenCodeSize := extcodesize(token)\\n }\\n require(tokenCodeSize > 0, \\\"StdUtils getTokenBalances(address,address[]): Token address is not a contract.\\\");\\n\\n // ABI encode the aggregate call to Multicall3.\\n uint256 length = addresses.length;\\n IMulticall3.Call[] memory calls = new IMulticall3.Call[](length);\\n for (uint256 i = 0; i < length; ++i) {\\n // 0x70a08231 = bytes4(\\\"balanceOf(address)\\\"))\\n calls[i] = IMulticall3.Call({target: token, callData: abi.encodeWithSelector(0x70a08231, (addresses[i]))});\\n }\\n\\n // Make the aggregate call.\\n (, bytes[] memory returnData) = multicall.aggregate(calls);\\n\\n // ABI decode the return data and return the balances.\\n balances = new uint256[](length);\\n for (uint256 i = 0; i < length; ++i) {\\n balances[i] = abi.decode(returnData[i], (uint256));\\n }\\n }\\n\\n /*//////////////////////////////////////////////////////////////////////////\\n PRIVATE FUNCTIONS\\n //////////////////////////////////////////////////////////////////////////*/\\n\\n function addressFromLast20Bytes(bytes32 bytesValue) private pure returns (address) {\\n return address(uint160(uint256(bytesValue)));\\n }\\n\\n // This section is used to prevent the compilation of console, which shortens the compilation time when console is\\n // not used elsewhere. We also trick the compiler into letting us make the console log methods as `pure` to avoid\\n // any breaking changes to function signatures.\\n function _castLogPayloadViewToPure(function(bytes memory) internal view fnIn)\\n internal\\n pure\\n returns (function(bytes memory) internal pure fnOut)\\n {\\n assembly {\\n fnOut := fnIn\\n }\\n }\\n\\n function _sendLogPayload(bytes memory payload) internal pure {\\n _castLogPayloadViewToPure(_sendLogPayloadView)(payload);\\n }\\n\\n function _sendLogPayloadView(bytes memory payload) private view {\\n uint256 payloadLength = payload.length;\\n address consoleAddress = CONSOLE2_ADDRESS;\\n /// @solidity memory-safe-assembly\\n assembly {\\n let payloadStart := add(payload, 32)\\n let r := staticcall(gas(), consoleAddress, payloadStart, payloadLength, 0, 0)\\n }\\n }\\n\\n function console2_log_StdUtils(string memory p0) private pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string)\\\", p0));\\n }\\n\\n function console2_log_StdUtils(string memory p0, uint256 p1) private pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,uint256)\\\", p0, p1));\\n }\\n\\n function console2_log_StdUtils(string memory p0, string memory p1) private pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,string)\\\", p0, p1));\\n }\\n}\\n\",\"keccak256\":\"0x7274081e11c05164fd8eadde4de8305c033e58a43008dea58065f3170ccf0737\",\"license\":\"MIT\"},\"lib/forge-std/src/Vm.sol\":{\"content\":\"// Automatically @generated by scripts/vm.py. Do not modify manually.\\n\\n// SPDX-License-Identifier: MIT OR Apache-2.0\\npragma solidity >=0.6.2 <0.9.0;\\npragma experimental ABIEncoderV2;\\n\\n/// The `VmSafe` interface does not allow manipulation of the EVM state or other actions that may\\n/// result in Script simulations differing from on-chain execution. It is recommended to only use\\n/// these cheats in scripts.\\ninterface VmSafe {\\n /// A modification applied to either `msg.sender` or `tx.origin`. Returned by `readCallers`.\\n enum CallerMode {\\n // No caller modification is currently active.\\n None,\\n // A one time broadcast triggered by a `vm.broadcast()` call is currently active.\\n Broadcast,\\n // A recurrent broadcast triggered by a `vm.startBroadcast()` call is currently active.\\n RecurrentBroadcast,\\n // A one time prank triggered by a `vm.prank()` call is currently active.\\n Prank,\\n // A recurrent prank triggered by a `vm.startPrank()` call is currently active.\\n RecurrentPrank\\n }\\n\\n /// The kind of account access that occurred.\\n enum AccountAccessKind {\\n // The account was called.\\n Call,\\n // The account was called via delegatecall.\\n DelegateCall,\\n // The account was called via callcode.\\n CallCode,\\n // The account was called via staticcall.\\n StaticCall,\\n // The account was created.\\n Create,\\n // The account was selfdestructed.\\n SelfDestruct,\\n // Synthetic access indicating the current context has resumed after a previous sub-context (AccountAccess).\\n Resume,\\n // The account's balance was read.\\n Balance,\\n // The account's codesize was read.\\n Extcodesize,\\n // The account's codehash was read.\\n Extcodehash,\\n // The account's code was copied.\\n Extcodecopy\\n }\\n\\n /// Forge execution contexts.\\n enum ForgeContext {\\n // Test group execution context (test, coverage or snapshot).\\n TestGroup,\\n // `forge test` execution context.\\n Test,\\n // `forge coverage` execution context.\\n Coverage,\\n // `forge snapshot` execution context.\\n Snapshot,\\n // Script group execution context (dry run, broadcast or resume).\\n ScriptGroup,\\n // `forge script` execution context.\\n ScriptDryRun,\\n // `forge script --broadcast` execution context.\\n ScriptBroadcast,\\n // `forge script --resume` execution context.\\n ScriptResume,\\n // Unknown `forge` execution context.\\n Unknown\\n }\\n\\n /// The transaction type (`txType`) of the broadcast.\\n enum BroadcastTxType {\\n // Represents a CALL broadcast tx.\\n Call,\\n // Represents a CREATE broadcast tx.\\n Create,\\n // Represents a CREATE2 broadcast tx.\\n Create2\\n }\\n\\n /// An Ethereum log. Returned by `getRecordedLogs`.\\n struct Log {\\n // The topics of the log, including the signature, if any.\\n bytes32[] topics;\\n // The raw data of the log.\\n bytes data;\\n // The address of the log's emitter.\\n address emitter;\\n }\\n\\n /// An RPC URL and its alias. Returned by `rpcUrlStructs`.\\n struct Rpc {\\n // The alias of the RPC URL.\\n string key;\\n // The RPC URL.\\n string url;\\n }\\n\\n /// An RPC log object. Returned by `eth_getLogs`.\\n struct EthGetLogs {\\n // The address of the log's emitter.\\n address emitter;\\n // The topics of the log, including the signature, if any.\\n bytes32[] topics;\\n // The raw data of the log.\\n bytes data;\\n // The block hash.\\n bytes32 blockHash;\\n // The block number.\\n uint64 blockNumber;\\n // The transaction hash.\\n bytes32 transactionHash;\\n // The transaction index in the block.\\n uint64 transactionIndex;\\n // The log index.\\n uint256 logIndex;\\n // Whether the log was removed.\\n bool removed;\\n }\\n\\n /// A single entry in a directory listing. Returned by `readDir`.\\n struct DirEntry {\\n // The error message, if any.\\n string errorMessage;\\n // The path of the entry.\\n string path;\\n // The depth of the entry.\\n uint64 depth;\\n // Whether the entry is a directory.\\n bool isDir;\\n // Whether the entry is a symlink.\\n bool isSymlink;\\n }\\n\\n /// Metadata information about a file.\\n /// This structure is returned from the `fsMetadata` function and represents known\\n /// metadata about a file such as its permissions, size, modification\\n /// times, etc.\\n struct FsMetadata {\\n // True if this metadata is for a directory.\\n bool isDir;\\n // True if this metadata is for a symlink.\\n bool isSymlink;\\n // The size of the file, in bytes, this metadata is for.\\n uint256 length;\\n // True if this metadata is for a readonly (unwritable) file.\\n bool readOnly;\\n // The last modification time listed in this metadata.\\n uint256 modified;\\n // The last access time of this metadata.\\n uint256 accessed;\\n // The creation time listed in this metadata.\\n uint256 created;\\n }\\n\\n /// A wallet with a public and private key.\\n struct Wallet {\\n // The wallet's address.\\n address addr;\\n // The wallet's public key `X`.\\n uint256 publicKeyX;\\n // The wallet's public key `Y`.\\n uint256 publicKeyY;\\n // The wallet's private key.\\n uint256 privateKey;\\n }\\n\\n /// The result of a `tryFfi` call.\\n struct FfiResult {\\n // The exit code of the call.\\n int32 exitCode;\\n // The optionally hex-decoded `stdout` data.\\n bytes stdout;\\n // The `stderr` data.\\n bytes stderr;\\n }\\n\\n /// Information on the chain and fork.\\n struct ChainInfo {\\n // The fork identifier. Set to zero if no fork is active.\\n uint256 forkId;\\n // The chain ID of the current fork.\\n uint256 chainId;\\n }\\n\\n /// The result of a `stopAndReturnStateDiff` call.\\n struct AccountAccess {\\n // The chain and fork the access occurred.\\n ChainInfo chainInfo;\\n // The kind of account access that determines what the account is.\\n // If kind is Call, DelegateCall, StaticCall or CallCode, then the account is the callee.\\n // If kind is Create, then the account is the newly created account.\\n // If kind is SelfDestruct, then the account is the selfdestruct recipient.\\n // If kind is a Resume, then account represents a account context that has resumed.\\n AccountAccessKind kind;\\n // The account that was accessed.\\n // It's either the account created, callee or a selfdestruct recipient for CREATE, CALL or SELFDESTRUCT.\\n address account;\\n // What accessed the account.\\n address accessor;\\n // If the account was initialized or empty prior to the access.\\n // An account is considered initialized if it has code, a\\n // non-zero nonce, or a non-zero balance.\\n bool initialized;\\n // The previous balance of the accessed account.\\n uint256 oldBalance;\\n // The potential new balance of the accessed account.\\n // That is, all balance changes are recorded here, even if reverts occurred.\\n uint256 newBalance;\\n // Code of the account deployed by CREATE.\\n bytes deployedCode;\\n // Value passed along with the account access\\n uint256 value;\\n // Input data provided to the CREATE or CALL\\n bytes data;\\n // If this access reverted in either the current or parent context.\\n bool reverted;\\n // An ordered list of storage accesses made during an account access operation.\\n StorageAccess[] storageAccesses;\\n // Call depth traversed during the recording of state differences\\n uint64 depth;\\n }\\n\\n /// The storage accessed during an `AccountAccess`.\\n struct StorageAccess {\\n // The account whose storage was accessed.\\n address account;\\n // The slot that was accessed.\\n bytes32 slot;\\n // If the access was a write.\\n bool isWrite;\\n // The previous value of the slot.\\n bytes32 previousValue;\\n // The new value of the slot.\\n bytes32 newValue;\\n // If the access was reverted.\\n bool reverted;\\n }\\n\\n /// Gas used. Returned by `lastCallGas`.\\n struct Gas {\\n // The gas limit of the call.\\n uint64 gasLimit;\\n // The total gas used.\\n uint64 gasTotalUsed;\\n // DEPRECATED: The amount of gas used for memory expansion. Ref: \\n uint64 gasMemoryUsed;\\n // The amount of gas refunded.\\n int64 gasRefunded;\\n // The amount of gas remaining.\\n uint64 gasRemaining;\\n }\\n\\n /// The result of the `stopDebugTraceRecording` call\\n struct DebugStep {\\n // The stack before executing the step of the run.\\n // stack\\\\[0\\\\] represents the top of the stack.\\n // and only stack data relevant to the opcode execution is contained.\\n uint256[] stack;\\n // The memory input data before executing the step of the run.\\n // only input data relevant to the opcode execution is contained.\\n // e.g. for MLOAD, it will have memory\\\\[offset:offset+32\\\\] copied here.\\n // the offset value can be get by the stack data.\\n bytes memoryInput;\\n // The opcode that was accessed.\\n uint8 opcode;\\n // The call depth of the step.\\n uint64 depth;\\n // Whether the call end up with out of gas error.\\n bool isOutOfGas;\\n // The contract address where the opcode is running\\n address contractAddr;\\n }\\n\\n /// Represents a transaction's broadcast details.\\n struct BroadcastTxSummary {\\n // The hash of the transaction that was broadcasted\\n bytes32 txHash;\\n // Represent the type of transaction among CALL, CREATE, CREATE2\\n BroadcastTxType txType;\\n // The address of the contract that was called or created.\\n // This is address of the contract that is created if the txType is CREATE or CREATE2.\\n address contractAddress;\\n // The block number the transaction landed in.\\n uint64 blockNumber;\\n // Status of the transaction, retrieved from the transaction receipt.\\n bool success;\\n }\\n\\n /// Holds a signed EIP-7702 authorization for an authority account to delegate to an implementation.\\n struct SignedDelegation {\\n // The y-parity of the recovered secp256k1 signature (0 or 1).\\n uint8 v;\\n // First 32 bytes of the signature.\\n bytes32 r;\\n // Second 32 bytes of the signature.\\n bytes32 s;\\n // The current nonce of the authority account at signing time.\\n // Used to ensure signature can't be replayed after account nonce changes.\\n uint64 nonce;\\n // Address of the contract implementation that will be delegated to.\\n // Gets encoded into delegation code: 0xef0100 || implementation.\\n address implementation;\\n }\\n\\n /// Represents a \\\"potential\\\" revert reason from a single subsequent call when using `vm.assumeNoReverts`.\\n /// Reverts that match will result in a FOUNDRY::ASSUME rejection, whereas unmatched reverts will be surfaced\\n /// as normal.\\n struct PotentialRevert {\\n // The allowed origin of the revert opcode; address(0) allows reverts from any address\\n address reverter;\\n // When true, only matches on the beginning of the revert data, otherwise, matches on entire revert data\\n bool partialMatch;\\n // The data to use to match encountered reverts\\n bytes revertData;\\n }\\n\\n /// An EIP-2930 access list item.\\n struct AccessListItem {\\n // The address to be added in access list.\\n address target;\\n // The storage keys to be added in access list.\\n bytes32[] storageKeys;\\n }\\n\\n // ======== Crypto ========\\n\\n /// Derives a private key from the name, labels the account with that name, and returns the wallet.\\n function createWallet(string calldata walletLabel) external returns (Wallet memory wallet);\\n\\n /// Generates a wallet from the private key and returns the wallet.\\n function createWallet(uint256 privateKey) external returns (Wallet memory wallet);\\n\\n /// Generates a wallet from the private key, labels the account with that name, and returns the wallet.\\n function createWallet(uint256 privateKey, string calldata walletLabel) external returns (Wallet memory wallet);\\n\\n /// Derive a private key from a provided mnenomic string (or mnenomic file path)\\n /// at the derivation path `m/44'/60'/0'/0/{index}`.\\n function deriveKey(string calldata mnemonic, uint32 index) external pure returns (uint256 privateKey);\\n\\n /// Derive a private key from a provided mnenomic string (or mnenomic file path)\\n /// at `{derivationPath}{index}`.\\n function deriveKey(string calldata mnemonic, string calldata derivationPath, uint32 index)\\n external\\n pure\\n returns (uint256 privateKey);\\n\\n /// Derive a private key from a provided mnenomic string (or mnenomic file path) in the specified language\\n /// at the derivation path `m/44'/60'/0'/0/{index}`.\\n function deriveKey(string calldata mnemonic, uint32 index, string calldata language)\\n external\\n pure\\n returns (uint256 privateKey);\\n\\n /// Derive a private key from a provided mnenomic string (or mnenomic file path) in the specified language\\n /// at `{derivationPath}{index}`.\\n function deriveKey(string calldata mnemonic, string calldata derivationPath, uint32 index, string calldata language)\\n external\\n pure\\n returns (uint256 privateKey);\\n\\n /// Derives secp256r1 public key from the provided `privateKey`.\\n function publicKeyP256(uint256 privateKey) external pure returns (uint256 publicKeyX, uint256 publicKeyY);\\n\\n /// Adds a private key to the local forge wallet and returns the address.\\n function rememberKey(uint256 privateKey) external returns (address keyAddr);\\n\\n /// Derive a set number of wallets from a mnemonic at the derivation path `m/44'/60'/0'/0/{0..count}`.\\n /// The respective private keys are saved to the local forge wallet for later use and their addresses are returned.\\n function rememberKeys(string calldata mnemonic, string calldata derivationPath, uint32 count)\\n external\\n returns (address[] memory keyAddrs);\\n\\n /// Derive a set number of wallets from a mnemonic in the specified language at the derivation path `m/44'/60'/0'/0/{0..count}`.\\n /// The respective private keys are saved to the local forge wallet for later use and their addresses are returned.\\n function rememberKeys(\\n string calldata mnemonic,\\n string calldata derivationPath,\\n string calldata language,\\n uint32 count\\n ) external returns (address[] memory keyAddrs);\\n\\n /// Signs data with a `Wallet`.\\n /// Returns a compact signature (`r`, `vs`) as per EIP-2098, where `vs` encodes both the\\n /// signature's `s` value, and the recovery id `v` in a single bytes32.\\n /// This format reduces the signature size from 65 to 64 bytes.\\n function signCompact(Wallet calldata wallet, bytes32 digest) external returns (bytes32 r, bytes32 vs);\\n\\n /// Signs `digest` with `privateKey` using the secp256k1 curve.\\n /// Returns a compact signature (`r`, `vs`) as per EIP-2098, where `vs` encodes both the\\n /// signature's `s` value, and the recovery id `v` in a single bytes32.\\n /// This format reduces the signature size from 65 to 64 bytes.\\n function signCompact(uint256 privateKey, bytes32 digest) external pure returns (bytes32 r, bytes32 vs);\\n\\n /// Signs `digest` with signer provided to script using the secp256k1 curve.\\n /// Returns a compact signature (`r`, `vs`) as per EIP-2098, where `vs` encodes both the\\n /// signature's `s` value, and the recovery id `v` in a single bytes32.\\n /// This format reduces the signature size from 65 to 64 bytes.\\n /// If `--sender` is provided, the signer with provided address is used, otherwise,\\n /// if exactly one signer is provided to the script, that signer is used.\\n /// Raises error if signer passed through `--sender` does not match any unlocked signers or\\n /// if `--sender` is not provided and not exactly one signer is passed to the script.\\n function signCompact(bytes32 digest) external pure returns (bytes32 r, bytes32 vs);\\n\\n /// Signs `digest` with signer provided to script using the secp256k1 curve.\\n /// Returns a compact signature (`r`, `vs`) as per EIP-2098, where `vs` encodes both the\\n /// signature's `s` value, and the recovery id `v` in a single bytes32.\\n /// This format reduces the signature size from 65 to 64 bytes.\\n /// Raises error if none of the signers passed into the script have provided address.\\n function signCompact(address signer, bytes32 digest) external pure returns (bytes32 r, bytes32 vs);\\n\\n /// Signs `digest` with `privateKey` using the secp256r1 curve.\\n function signP256(uint256 privateKey, bytes32 digest) external pure returns (bytes32 r, bytes32 s);\\n\\n /// Signs data with a `Wallet`.\\n function sign(Wallet calldata wallet, bytes32 digest) external returns (uint8 v, bytes32 r, bytes32 s);\\n\\n /// Signs `digest` with `privateKey` using the secp256k1 curve.\\n function sign(uint256 privateKey, bytes32 digest) external pure returns (uint8 v, bytes32 r, bytes32 s);\\n\\n /// Signs `digest` with signer provided to script using the secp256k1 curve.\\n /// If `--sender` is provided, the signer with provided address is used, otherwise,\\n /// if exactly one signer is provided to the script, that signer is used.\\n /// Raises error if signer passed through `--sender` does not match any unlocked signers or\\n /// if `--sender` is not provided and not exactly one signer is passed to the script.\\n function sign(bytes32 digest) external pure returns (uint8 v, bytes32 r, bytes32 s);\\n\\n /// Signs `digest` with signer provided to script using the secp256k1 curve.\\n /// Raises error if none of the signers passed into the script have provided address.\\n function sign(address signer, bytes32 digest) external pure returns (uint8 v, bytes32 r, bytes32 s);\\n\\n // ======== Environment ========\\n\\n /// Gets the environment variable `name` and parses it as `address`.\\n /// Reverts if the variable was not found or could not be parsed.\\n function envAddress(string calldata name) external view returns (address value);\\n\\n /// Gets the environment variable `name` and parses it as an array of `address`, delimited by `delim`.\\n /// Reverts if the variable was not found or could not be parsed.\\n function envAddress(string calldata name, string calldata delim) external view returns (address[] memory value);\\n\\n /// Gets the environment variable `name` and parses it as `bool`.\\n /// Reverts if the variable was not found or could not be parsed.\\n function envBool(string calldata name) external view returns (bool value);\\n\\n /// Gets the environment variable `name` and parses it as an array of `bool`, delimited by `delim`.\\n /// Reverts if the variable was not found or could not be parsed.\\n function envBool(string calldata name, string calldata delim) external view returns (bool[] memory value);\\n\\n /// Gets the environment variable `name` and parses it as `bytes32`.\\n /// Reverts if the variable was not found or could not be parsed.\\n function envBytes32(string calldata name) external view returns (bytes32 value);\\n\\n /// Gets the environment variable `name` and parses it as an array of `bytes32`, delimited by `delim`.\\n /// Reverts if the variable was not found or could not be parsed.\\n function envBytes32(string calldata name, string calldata delim) external view returns (bytes32[] memory value);\\n\\n /// Gets the environment variable `name` and parses it as `bytes`.\\n /// Reverts if the variable was not found or could not be parsed.\\n function envBytes(string calldata name) external view returns (bytes memory value);\\n\\n /// Gets the environment variable `name` and parses it as an array of `bytes`, delimited by `delim`.\\n /// Reverts if the variable was not found or could not be parsed.\\n function envBytes(string calldata name, string calldata delim) external view returns (bytes[] memory value);\\n\\n /// Gets the environment variable `name` and returns true if it exists, else returns false.\\n function envExists(string calldata name) external view returns (bool result);\\n\\n /// Gets the environment variable `name` and parses it as `int256`.\\n /// Reverts if the variable was not found or could not be parsed.\\n function envInt(string calldata name) external view returns (int256 value);\\n\\n /// Gets the environment variable `name` and parses it as an array of `int256`, delimited by `delim`.\\n /// Reverts if the variable was not found or could not be parsed.\\n function envInt(string calldata name, string calldata delim) external view returns (int256[] memory value);\\n\\n /// Gets the environment variable `name` and parses it as `bool`.\\n /// Reverts if the variable could not be parsed.\\n /// Returns `defaultValue` if the variable was not found.\\n function envOr(string calldata name, bool defaultValue) external view returns (bool value);\\n\\n /// Gets the environment variable `name` and parses it as `uint256`.\\n /// Reverts if the variable could not be parsed.\\n /// Returns `defaultValue` if the variable was not found.\\n function envOr(string calldata name, uint256 defaultValue) external view returns (uint256 value);\\n\\n /// Gets the environment variable `name` and parses it as an array of `address`, delimited by `delim`.\\n /// Reverts if the variable could not be parsed.\\n /// Returns `defaultValue` if the variable was not found.\\n function envOr(string calldata name, string calldata delim, address[] calldata defaultValue)\\n external\\n view\\n returns (address[] memory value);\\n\\n /// Gets the environment variable `name` and parses it as an array of `bytes32`, delimited by `delim`.\\n /// Reverts if the variable could not be parsed.\\n /// Returns `defaultValue` if the variable was not found.\\n function envOr(string calldata name, string calldata delim, bytes32[] calldata defaultValue)\\n external\\n view\\n returns (bytes32[] memory value);\\n\\n /// Gets the environment variable `name` and parses it as an array of `string`, delimited by `delim`.\\n /// Reverts if the variable could not be parsed.\\n /// Returns `defaultValue` if the variable was not found.\\n function envOr(string calldata name, string calldata delim, string[] calldata defaultValue)\\n external\\n view\\n returns (string[] memory value);\\n\\n /// Gets the environment variable `name` and parses it as an array of `bytes`, delimited by `delim`.\\n /// Reverts if the variable could not be parsed.\\n /// Returns `defaultValue` if the variable was not found.\\n function envOr(string calldata name, string calldata delim, bytes[] calldata defaultValue)\\n external\\n view\\n returns (bytes[] memory value);\\n\\n /// Gets the environment variable `name` and parses it as `int256`.\\n /// Reverts if the variable could not be parsed.\\n /// Returns `defaultValue` if the variable was not found.\\n function envOr(string calldata name, int256 defaultValue) external view returns (int256 value);\\n\\n /// Gets the environment variable `name` and parses it as `address`.\\n /// Reverts if the variable could not be parsed.\\n /// Returns `defaultValue` if the variable was not found.\\n function envOr(string calldata name, address defaultValue) external view returns (address value);\\n\\n /// Gets the environment variable `name` and parses it as `bytes32`.\\n /// Reverts if the variable could not be parsed.\\n /// Returns `defaultValue` if the variable was not found.\\n function envOr(string calldata name, bytes32 defaultValue) external view returns (bytes32 value);\\n\\n /// Gets the environment variable `name` and parses it as `string`.\\n /// Reverts if the variable could not be parsed.\\n /// Returns `defaultValue` if the variable was not found.\\n function envOr(string calldata name, string calldata defaultValue) external view returns (string memory value);\\n\\n /// Gets the environment variable `name` and parses it as `bytes`.\\n /// Reverts if the variable could not be parsed.\\n /// Returns `defaultValue` if the variable was not found.\\n function envOr(string calldata name, bytes calldata defaultValue) external view returns (bytes memory value);\\n\\n /// Gets the environment variable `name` and parses it as an array of `bool`, delimited by `delim`.\\n /// Reverts if the variable could not be parsed.\\n /// Returns `defaultValue` if the variable was not found.\\n function envOr(string calldata name, string calldata delim, bool[] calldata defaultValue)\\n external\\n view\\n returns (bool[] memory value);\\n\\n /// Gets the environment variable `name` and parses it as an array of `uint256`, delimited by `delim`.\\n /// Reverts if the variable could not be parsed.\\n /// Returns `defaultValue` if the variable was not found.\\n function envOr(string calldata name, string calldata delim, uint256[] calldata defaultValue)\\n external\\n view\\n returns (uint256[] memory value);\\n\\n /// Gets the environment variable `name` and parses it as an array of `int256`, delimited by `delim`.\\n /// Reverts if the variable could not be parsed.\\n /// Returns `defaultValue` if the variable was not found.\\n function envOr(string calldata name, string calldata delim, int256[] calldata defaultValue)\\n external\\n view\\n returns (int256[] memory value);\\n\\n /// Gets the environment variable `name` and parses it as `string`.\\n /// Reverts if the variable was not found or could not be parsed.\\n function envString(string calldata name) external view returns (string memory value);\\n\\n /// Gets the environment variable `name` and parses it as an array of `string`, delimited by `delim`.\\n /// Reverts if the variable was not found or could not be parsed.\\n function envString(string calldata name, string calldata delim) external view returns (string[] memory value);\\n\\n /// Gets the environment variable `name` and parses it as `uint256`.\\n /// Reverts if the variable was not found or could not be parsed.\\n function envUint(string calldata name) external view returns (uint256 value);\\n\\n /// Gets the environment variable `name` and parses it as an array of `uint256`, delimited by `delim`.\\n /// Reverts if the variable was not found or could not be parsed.\\n function envUint(string calldata name, string calldata delim) external view returns (uint256[] memory value);\\n\\n /// Returns true if `forge` command was executed in given context.\\n function isContext(ForgeContext context) external view returns (bool result);\\n\\n /// Sets environment variables.\\n function setEnv(string calldata name, string calldata value) external;\\n\\n // ======== EVM ========\\n\\n /// Gets all accessed reads and write slot from a `vm.record` session, for a given address.\\n function accesses(address target) external returns (bytes32[] memory readSlots, bytes32[] memory writeSlots);\\n\\n /// Gets the address for a given private key.\\n function addr(uint256 privateKey) external pure returns (address keyAddr);\\n\\n /// Gets all the logs according to specified filter.\\n function eth_getLogs(uint256 fromBlock, uint256 toBlock, address target, bytes32[] calldata topics)\\n external\\n returns (EthGetLogs[] memory logs);\\n\\n /// Gets the current `block.blobbasefee`.\\n /// You should use this instead of `block.blobbasefee` if you use `vm.blobBaseFee`, as `block.blobbasefee` is assumed to be constant across a transaction,\\n /// and as a result will get optimized out by the compiler.\\n /// See https://github.com/foundry-rs/foundry/issues/6180\\n function getBlobBaseFee() external view returns (uint256 blobBaseFee);\\n\\n /// Gets the current `block.number`.\\n /// You should use this instead of `block.number` if you use `vm.roll`, as `block.number` is assumed to be constant across a transaction,\\n /// and as a result will get optimized out by the compiler.\\n /// See https://github.com/foundry-rs/foundry/issues/6180\\n function getBlockNumber() external view returns (uint256 height);\\n\\n /// Gets the current `block.timestamp`.\\n /// You should use this instead of `block.timestamp` if you use `vm.warp`, as `block.timestamp` is assumed to be constant across a transaction,\\n /// and as a result will get optimized out by the compiler.\\n /// See https://github.com/foundry-rs/foundry/issues/6180\\n function getBlockTimestamp() external view returns (uint256 timestamp);\\n\\n /// Gets the map key and parent of a mapping at a given slot, for a given address.\\n function getMappingKeyAndParentOf(address target, bytes32 elementSlot)\\n external\\n returns (bool found, bytes32 key, bytes32 parent);\\n\\n /// Gets the number of elements in the mapping at the given slot, for a given address.\\n function getMappingLength(address target, bytes32 mappingSlot) external returns (uint256 length);\\n\\n /// Gets the elements at index idx of the mapping at the given slot, for a given address. The\\n /// index must be less than the length of the mapping (i.e. the number of keys in the mapping).\\n function getMappingSlotAt(address target, bytes32 mappingSlot, uint256 idx) external returns (bytes32 value);\\n\\n /// Gets the nonce of an account.\\n function getNonce(address account) external view returns (uint64 nonce);\\n\\n /// Get the nonce of a `Wallet`.\\n function getNonce(Wallet calldata wallet) external returns (uint64 nonce);\\n\\n /// Gets all the recorded logs.\\n function getRecordedLogs() external returns (Log[] memory logs);\\n\\n /// Returns state diffs from current `vm.startStateDiffRecording` session.\\n function getStateDiff() external view returns (string memory diff);\\n\\n /// Returns state diffs from current `vm.startStateDiffRecording` session, in json format.\\n function getStateDiffJson() external view returns (string memory diff);\\n\\n /// Gets the gas used in the last call from the callee perspective.\\n function lastCallGas() external view returns (Gas memory gas);\\n\\n /// Loads a storage slot from an address.\\n function load(address target, bytes32 slot) external view returns (bytes32 data);\\n\\n /// Pauses gas metering (i.e. gas usage is not counted). Noop if already paused.\\n function pauseGasMetering() external;\\n\\n /// Records all storage reads and writes.\\n function record() external;\\n\\n /// Record all the transaction logs.\\n function recordLogs() external;\\n\\n /// Reset gas metering (i.e. gas usage is set to gas limit).\\n function resetGasMetering() external;\\n\\n /// Resumes gas metering (i.e. gas usage is counted again). Noop if already on.\\n function resumeGasMetering() external;\\n\\n /// Performs an Ethereum JSON-RPC request to the current fork URL.\\n function rpc(string calldata method, string calldata params) external returns (bytes memory data);\\n\\n /// Performs an Ethereum JSON-RPC request to the given endpoint.\\n function rpc(string calldata urlOrAlias, string calldata method, string calldata params)\\n external\\n returns (bytes memory data);\\n\\n /// Records the debug trace during the run.\\n function startDebugTraceRecording() external;\\n\\n /// Starts recording all map SSTOREs for later retrieval.\\n function startMappingRecording() external;\\n\\n /// Record all account accesses as part of CREATE, CALL or SELFDESTRUCT opcodes in order,\\n /// along with the context of the calls\\n function startStateDiffRecording() external;\\n\\n /// Stop debug trace recording and returns the recorded debug trace.\\n function stopAndReturnDebugTraceRecording() external returns (DebugStep[] memory step);\\n\\n /// Returns an ordered array of all account accesses from a `vm.startStateDiffRecording` session.\\n function stopAndReturnStateDiff() external returns (AccountAccess[] memory accountAccesses);\\n\\n /// Stops recording all map SSTOREs for later retrieval and clears the recorded data.\\n function stopMappingRecording() external;\\n\\n // ======== Filesystem ========\\n\\n /// Closes file for reading, resetting the offset and allowing to read it from beginning with readLine.\\n /// `path` is relative to the project root.\\n function closeFile(string calldata path) external;\\n\\n /// Copies the contents of one file to another. This function will **overwrite** the contents of `to`.\\n /// On success, the total number of bytes copied is returned and it is equal to the length of the `to` file as reported by `metadata`.\\n /// Both `from` and `to` are relative to the project root.\\n function copyFile(string calldata from, string calldata to) external returns (uint64 copied);\\n\\n /// Creates a new, empty directory at the provided path.\\n /// This cheatcode will revert in the following situations, but is not limited to just these cases:\\n /// - User lacks permissions to modify `path`.\\n /// - A parent of the given path doesn't exist and `recursive` is false.\\n /// - `path` already exists and `recursive` is false.\\n /// `path` is relative to the project root.\\n function createDir(string calldata path, bool recursive) external;\\n\\n /// Deploys a contract from an artifact file. Takes in the relative path to the json file or the path to the\\n /// artifact in the form of :: where and parts are optional.\\n function deployCode(string calldata artifactPath) external returns (address deployedAddress);\\n\\n /// Deploys a contract from an artifact file. Takes in the relative path to the json file or the path to the\\n /// artifact in the form of :: where and parts are optional.\\n /// Additionally accepts abi-encoded constructor arguments.\\n function deployCode(string calldata artifactPath, bytes calldata constructorArgs)\\n external\\n returns (address deployedAddress);\\n\\n /// Returns true if the given path points to an existing entity, else returns false.\\n function exists(string calldata path) external view returns (bool result);\\n\\n /// Performs a foreign function call via the terminal.\\n function ffi(string[] calldata commandInput) external returns (bytes memory result);\\n\\n /// Given a path, query the file system to get information about a file, directory, etc.\\n function fsMetadata(string calldata path) external view returns (FsMetadata memory metadata);\\n\\n /// Gets the artifact path from code (aka. creation code).\\n function getArtifactPathByCode(bytes calldata code) external view returns (string memory path);\\n\\n /// Gets the artifact path from deployed code (aka. runtime code).\\n function getArtifactPathByDeployedCode(bytes calldata deployedCode) external view returns (string memory path);\\n\\n /// Returns the most recent broadcast for the given contract on `chainId` matching `txType`.\\n /// For example:\\n /// The most recent deployment can be fetched by passing `txType` as `CREATE` or `CREATE2`.\\n /// The most recent call can be fetched by passing `txType` as `CALL`.\\n function getBroadcast(string calldata contractName, uint64 chainId, BroadcastTxType txType)\\n external\\n view\\n returns (BroadcastTxSummary memory);\\n\\n /// Returns all broadcasts for the given contract on `chainId` with the specified `txType`.\\n /// Sorted such that the most recent broadcast is the first element, and the oldest is the last. i.e descending order of BroadcastTxSummary.blockNumber.\\n function getBroadcasts(string calldata contractName, uint64 chainId, BroadcastTxType txType)\\n external\\n view\\n returns (BroadcastTxSummary[] memory);\\n\\n /// Returns all broadcasts for the given contract on `chainId`.\\n /// Sorted such that the most recent broadcast is the first element, and the oldest is the last. i.e descending order of BroadcastTxSummary.blockNumber.\\n function getBroadcasts(string calldata contractName, uint64 chainId)\\n external\\n view\\n returns (BroadcastTxSummary[] memory);\\n\\n /// Gets the creation bytecode from an artifact file. Takes in the relative path to the json file or the path to the\\n /// artifact in the form of :: where and parts are optional.\\n function getCode(string calldata artifactPath) external view returns (bytes memory creationBytecode);\\n\\n /// Gets the deployed bytecode from an artifact file. Takes in the relative path to the json file or the path to the\\n /// artifact in the form of :: where and parts are optional.\\n function getDeployedCode(string calldata artifactPath) external view returns (bytes memory runtimeBytecode);\\n\\n /// Returns the most recent deployment for the current `chainId`.\\n function getDeployment(string calldata contractName) external view returns (address deployedAddress);\\n\\n /// Returns the most recent deployment for the given contract on `chainId`\\n function getDeployment(string calldata contractName, uint64 chainId)\\n external\\n view\\n returns (address deployedAddress);\\n\\n /// Returns all deployments for the given contract on `chainId`\\n /// Sorted in descending order of deployment time i.e descending order of BroadcastTxSummary.blockNumber.\\n /// The most recent deployment is the first element, and the oldest is the last.\\n function getDeployments(string calldata contractName, uint64 chainId)\\n external\\n view\\n returns (address[] memory deployedAddresses);\\n\\n /// Returns true if the path exists on disk and is pointing at a directory, else returns false.\\n function isDir(string calldata path) external view returns (bool result);\\n\\n /// Returns true if the path exists on disk and is pointing at a regular file, else returns false.\\n function isFile(string calldata path) external view returns (bool result);\\n\\n /// Get the path of the current project root.\\n function projectRoot() external view returns (string memory path);\\n\\n /// Prompts the user for a string value in the terminal.\\n function prompt(string calldata promptText) external returns (string memory input);\\n\\n /// Prompts the user for an address in the terminal.\\n function promptAddress(string calldata promptText) external returns (address);\\n\\n /// Prompts the user for a hidden string value in the terminal.\\n function promptSecret(string calldata promptText) external returns (string memory input);\\n\\n /// Prompts the user for hidden uint256 in the terminal (usually pk).\\n function promptSecretUint(string calldata promptText) external returns (uint256);\\n\\n /// Prompts the user for uint256 in the terminal.\\n function promptUint(string calldata promptText) external returns (uint256);\\n\\n /// Reads the directory at the given path recursively, up to `maxDepth`.\\n /// `maxDepth` defaults to 1, meaning only the direct children of the given directory will be returned.\\n /// Follows symbolic links if `followLinks` is true.\\n function readDir(string calldata path) external view returns (DirEntry[] memory entries);\\n\\n /// See `readDir(string)`.\\n function readDir(string calldata path, uint64 maxDepth) external view returns (DirEntry[] memory entries);\\n\\n /// See `readDir(string)`.\\n function readDir(string calldata path, uint64 maxDepth, bool followLinks)\\n external\\n view\\n returns (DirEntry[] memory entries);\\n\\n /// Reads the entire content of file to string. `path` is relative to the project root.\\n function readFile(string calldata path) external view returns (string memory data);\\n\\n /// Reads the entire content of file as binary. `path` is relative to the project root.\\n function readFileBinary(string calldata path) external view returns (bytes memory data);\\n\\n /// Reads next line of file to string.\\n function readLine(string calldata path) external view returns (string memory line);\\n\\n /// Reads a symbolic link, returning the path that the link points to.\\n /// This cheatcode will revert in the following situations, but is not limited to just these cases:\\n /// - `path` is not a symbolic link.\\n /// - `path` does not exist.\\n function readLink(string calldata linkPath) external view returns (string memory targetPath);\\n\\n /// Removes a directory at the provided path.\\n /// This cheatcode will revert in the following situations, but is not limited to just these cases:\\n /// - `path` doesn't exist.\\n /// - `path` isn't a directory.\\n /// - User lacks permissions to modify `path`.\\n /// - The directory is not empty and `recursive` is false.\\n /// `path` is relative to the project root.\\n function removeDir(string calldata path, bool recursive) external;\\n\\n /// Removes a file from the filesystem.\\n /// This cheatcode will revert in the following situations, but is not limited to just these cases:\\n /// - `path` points to a directory.\\n /// - The file doesn't exist.\\n /// - The user lacks permissions to remove the file.\\n /// `path` is relative to the project root.\\n function removeFile(string calldata path) external;\\n\\n /// Performs a foreign function call via terminal and returns the exit code, stdout, and stderr.\\n function tryFfi(string[] calldata commandInput) external returns (FfiResult memory result);\\n\\n /// Returns the time since unix epoch in milliseconds.\\n function unixTime() external view returns (uint256 milliseconds);\\n\\n /// Writes data to file, creating a file if it does not exist, and entirely replacing its contents if it does.\\n /// `path` is relative to the project root.\\n function writeFile(string calldata path, string calldata data) external;\\n\\n /// Writes binary data to a file, creating a file if it does not exist, and entirely replacing its contents if it does.\\n /// `path` is relative to the project root.\\n function writeFileBinary(string calldata path, bytes calldata data) external;\\n\\n /// Writes line to file, creating a file if it does not exist.\\n /// `path` is relative to the project root.\\n function writeLine(string calldata path, string calldata data) external;\\n\\n // ======== JSON ========\\n\\n /// Checks if `key` exists in a JSON object.\\n function keyExistsJson(string calldata json, string calldata key) external view returns (bool);\\n\\n /// Parses a string of JSON data at `key` and coerces it to `address`.\\n function parseJsonAddress(string calldata json, string calldata key) external pure returns (address);\\n\\n /// Parses a string of JSON data at `key` and coerces it to `address[]`.\\n function parseJsonAddressArray(string calldata json, string calldata key)\\n external\\n pure\\n returns (address[] memory);\\n\\n /// Parses a string of JSON data at `key` and coerces it to `bool`.\\n function parseJsonBool(string calldata json, string calldata key) external pure returns (bool);\\n\\n /// Parses a string of JSON data at `key` and coerces it to `bool[]`.\\n function parseJsonBoolArray(string calldata json, string calldata key) external pure returns (bool[] memory);\\n\\n /// Parses a string of JSON data at `key` and coerces it to `bytes`.\\n function parseJsonBytes(string calldata json, string calldata key) external pure returns (bytes memory);\\n\\n /// Parses a string of JSON data at `key` and coerces it to `bytes32`.\\n function parseJsonBytes32(string calldata json, string calldata key) external pure returns (bytes32);\\n\\n /// Parses a string of JSON data at `key` and coerces it to `bytes32[]`.\\n function parseJsonBytes32Array(string calldata json, string calldata key)\\n external\\n pure\\n returns (bytes32[] memory);\\n\\n /// Parses a string of JSON data at `key` and coerces it to `bytes[]`.\\n function parseJsonBytesArray(string calldata json, string calldata key) external pure returns (bytes[] memory);\\n\\n /// Parses a string of JSON data at `key` and coerces it to `int256`.\\n function parseJsonInt(string calldata json, string calldata key) external pure returns (int256);\\n\\n /// Parses a string of JSON data at `key` and coerces it to `int256[]`.\\n function parseJsonIntArray(string calldata json, string calldata key) external pure returns (int256[] memory);\\n\\n /// Returns an array of all the keys in a JSON object.\\n function parseJsonKeys(string calldata json, string calldata key) external pure returns (string[] memory keys);\\n\\n /// Parses a string of JSON data at `key` and coerces it to `string`.\\n function parseJsonString(string calldata json, string calldata key) external pure returns (string memory);\\n\\n /// Parses a string of JSON data at `key` and coerces it to `string[]`.\\n function parseJsonStringArray(string calldata json, string calldata key) external pure returns (string[] memory);\\n\\n /// Parses a string of JSON data at `key` and coerces it to type array corresponding to `typeDescription`.\\n function parseJsonTypeArray(string calldata json, string calldata key, string calldata typeDescription)\\n external\\n pure\\n returns (bytes memory);\\n\\n /// Parses a string of JSON data and coerces it to type corresponding to `typeDescription`.\\n function parseJsonType(string calldata json, string calldata typeDescription)\\n external\\n pure\\n returns (bytes memory);\\n\\n /// Parses a string of JSON data at `key` and coerces it to type corresponding to `typeDescription`.\\n function parseJsonType(string calldata json, string calldata key, string calldata typeDescription)\\n external\\n pure\\n returns (bytes memory);\\n\\n /// Parses a string of JSON data at `key` and coerces it to `uint256`.\\n function parseJsonUint(string calldata json, string calldata key) external pure returns (uint256);\\n\\n /// Parses a string of JSON data at `key` and coerces it to `uint256[]`.\\n function parseJsonUintArray(string calldata json, string calldata key) external pure returns (uint256[] memory);\\n\\n /// ABI-encodes a JSON object.\\n function parseJson(string calldata json) external pure returns (bytes memory abiEncodedData);\\n\\n /// ABI-encodes a JSON object at `key`.\\n function parseJson(string calldata json, string calldata key) external pure returns (bytes memory abiEncodedData);\\n\\n /// See `serializeJson`.\\n function serializeAddress(string calldata objectKey, string calldata valueKey, address value)\\n external\\n returns (string memory json);\\n\\n /// See `serializeJson`.\\n function serializeAddress(string calldata objectKey, string calldata valueKey, address[] calldata values)\\n external\\n returns (string memory json);\\n\\n /// See `serializeJson`.\\n function serializeBool(string calldata objectKey, string calldata valueKey, bool value)\\n external\\n returns (string memory json);\\n\\n /// See `serializeJson`.\\n function serializeBool(string calldata objectKey, string calldata valueKey, bool[] calldata values)\\n external\\n returns (string memory json);\\n\\n /// See `serializeJson`.\\n function serializeBytes32(string calldata objectKey, string calldata valueKey, bytes32 value)\\n external\\n returns (string memory json);\\n\\n /// See `serializeJson`.\\n function serializeBytes32(string calldata objectKey, string calldata valueKey, bytes32[] calldata values)\\n external\\n returns (string memory json);\\n\\n /// See `serializeJson`.\\n function serializeBytes(string calldata objectKey, string calldata valueKey, bytes calldata value)\\n external\\n returns (string memory json);\\n\\n /// See `serializeJson`.\\n function serializeBytes(string calldata objectKey, string calldata valueKey, bytes[] calldata values)\\n external\\n returns (string memory json);\\n\\n /// See `serializeJson`.\\n function serializeInt(string calldata objectKey, string calldata valueKey, int256 value)\\n external\\n returns (string memory json);\\n\\n /// See `serializeJson`.\\n function serializeInt(string calldata objectKey, string calldata valueKey, int256[] calldata values)\\n external\\n returns (string memory json);\\n\\n /// Serializes a key and value to a JSON object stored in-memory that can be later written to a file.\\n /// Returns the stringified version of the specific JSON file up to that moment.\\n function serializeJson(string calldata objectKey, string calldata value) external returns (string memory json);\\n\\n /// See `serializeJson`.\\n function serializeJsonType(string calldata typeDescription, bytes calldata value)\\n external\\n pure\\n returns (string memory json);\\n\\n /// See `serializeJson`.\\n function serializeJsonType(\\n string calldata objectKey,\\n string calldata valueKey,\\n string calldata typeDescription,\\n bytes calldata value\\n ) external returns (string memory json);\\n\\n /// See `serializeJson`.\\n function serializeString(string calldata objectKey, string calldata valueKey, string calldata value)\\n external\\n returns (string memory json);\\n\\n /// See `serializeJson`.\\n function serializeString(string calldata objectKey, string calldata valueKey, string[] calldata values)\\n external\\n returns (string memory json);\\n\\n /// See `serializeJson`.\\n function serializeUintToHex(string calldata objectKey, string calldata valueKey, uint256 value)\\n external\\n returns (string memory json);\\n\\n /// See `serializeJson`.\\n function serializeUint(string calldata objectKey, string calldata valueKey, uint256 value)\\n external\\n returns (string memory json);\\n\\n /// See `serializeJson`.\\n function serializeUint(string calldata objectKey, string calldata valueKey, uint256[] calldata values)\\n external\\n returns (string memory json);\\n\\n /// Write a serialized JSON object to a file. If the file exists, it will be overwritten.\\n function writeJson(string calldata json, string calldata path) external;\\n\\n /// Write a serialized JSON object to an **existing** JSON file, replacing a value with key = \\n /// This is useful to replace a specific value of a JSON file, without having to parse the entire thing.\\n function writeJson(string calldata json, string calldata path, string calldata valueKey) external;\\n\\n /// Checks if `key` exists in a JSON object\\n /// `keyExists` is being deprecated in favor of `keyExistsJson`. It will be removed in future versions.\\n function keyExists(string calldata json, string calldata key) external view returns (bool);\\n\\n // ======== Scripting ========\\n\\n /// Designate the next call as an EIP-7702 transaction\\n function attachDelegation(SignedDelegation calldata signedDelegation) external;\\n\\n /// Takes a signed transaction and broadcasts it to the network.\\n function broadcastRawTransaction(bytes calldata data) external;\\n\\n /// Has the next call (at this call depth only) create transactions that can later be signed and sent onchain.\\n /// Broadcasting address is determined by checking the following in order:\\n /// 1. If `--sender` argument was provided, that address is used.\\n /// 2. If exactly one signer (e.g. private key, hw wallet, keystore) is set when `forge broadcast` is invoked, that signer is used.\\n /// 3. Otherwise, default foundry sender (1804c8AB1F12E6bbf3894d4083f33e07309d1f38) is used.\\n function broadcast() external;\\n\\n /// Has the next call (at this call depth only) create a transaction with the address provided\\n /// as the sender that can later be signed and sent onchain.\\n function broadcast(address signer) external;\\n\\n /// Has the next call (at this call depth only) create a transaction with the private key\\n /// provided as the sender that can later be signed and sent onchain.\\n function broadcast(uint256 privateKey) external;\\n\\n /// Returns addresses of available unlocked wallets in the script environment.\\n function getWallets() external returns (address[] memory wallets);\\n\\n /// Sign an EIP-7702 authorization and designate the next call as an EIP-7702 transaction\\n function signAndAttachDelegation(address implementation, uint256 privateKey)\\n external\\n returns (SignedDelegation memory signedDelegation);\\n\\n /// Sign an EIP-7702 authorization for delegation\\n function signDelegation(address implementation, uint256 privateKey)\\n external\\n returns (SignedDelegation memory signedDelegation);\\n\\n /// Has all subsequent calls (at this call depth only) create transactions that can later be signed and sent onchain.\\n /// Broadcasting address is determined by checking the following in order:\\n /// 1. If `--sender` argument was provided, that address is used.\\n /// 2. If exactly one signer (e.g. private key, hw wallet, keystore) is set when `forge broadcast` is invoked, that signer is used.\\n /// 3. Otherwise, default foundry sender (1804c8AB1F12E6bbf3894d4083f33e07309d1f38) is used.\\n function startBroadcast() external;\\n\\n /// Has all subsequent calls (at this call depth only) create transactions with the address\\n /// provided that can later be signed and sent onchain.\\n function startBroadcast(address signer) external;\\n\\n /// Has all subsequent calls (at this call depth only) create transactions with the private key\\n /// provided that can later be signed and sent onchain.\\n function startBroadcast(uint256 privateKey) external;\\n\\n /// Stops collecting onchain transactions.\\n function stopBroadcast() external;\\n\\n // ======== String ========\\n\\n /// Returns true if `search` is found in `subject`, false otherwise.\\n function contains(string calldata subject, string calldata search) external returns (bool result);\\n\\n /// Returns the index of the first occurrence of a `key` in an `input` string.\\n /// Returns `NOT_FOUND` (i.e. `type(uint256).max`) if the `key` is not found.\\n /// Returns 0 in case of an empty `key`.\\n function indexOf(string calldata input, string calldata key) external pure returns (uint256);\\n\\n /// Parses the given `string` into an `address`.\\n function parseAddress(string calldata stringifiedValue) external pure returns (address parsedValue);\\n\\n /// Parses the given `string` into a `bool`.\\n function parseBool(string calldata stringifiedValue) external pure returns (bool parsedValue);\\n\\n /// Parses the given `string` into `bytes`.\\n function parseBytes(string calldata stringifiedValue) external pure returns (bytes memory parsedValue);\\n\\n /// Parses the given `string` into a `bytes32`.\\n function parseBytes32(string calldata stringifiedValue) external pure returns (bytes32 parsedValue);\\n\\n /// Parses the given `string` into a `int256`.\\n function parseInt(string calldata stringifiedValue) external pure returns (int256 parsedValue);\\n\\n /// Parses the given `string` into a `uint256`.\\n function parseUint(string calldata stringifiedValue) external pure returns (uint256 parsedValue);\\n\\n /// Replaces occurrences of `from` in the given `string` with `to`.\\n function replace(string calldata input, string calldata from, string calldata to)\\n external\\n pure\\n returns (string memory output);\\n\\n /// Splits the given `string` into an array of strings divided by the `delimiter`.\\n function split(string calldata input, string calldata delimiter) external pure returns (string[] memory outputs);\\n\\n /// Converts the given `string` value to Lowercase.\\n function toLowercase(string calldata input) external pure returns (string memory output);\\n\\n /// Converts the given value to a `string`.\\n function toString(address value) external pure returns (string memory stringifiedValue);\\n\\n /// Converts the given value to a `string`.\\n function toString(bytes calldata value) external pure returns (string memory stringifiedValue);\\n\\n /// Converts the given value to a `string`.\\n function toString(bytes32 value) external pure returns (string memory stringifiedValue);\\n\\n /// Converts the given value to a `string`.\\n function toString(bool value) external pure returns (string memory stringifiedValue);\\n\\n /// Converts the given value to a `string`.\\n function toString(uint256 value) external pure returns (string memory stringifiedValue);\\n\\n /// Converts the given value to a `string`.\\n function toString(int256 value) external pure returns (string memory stringifiedValue);\\n\\n /// Converts the given `string` value to Uppercase.\\n function toUppercase(string calldata input) external pure returns (string memory output);\\n\\n /// Trims leading and trailing whitespace from the given `string` value.\\n function trim(string calldata input) external pure returns (string memory output);\\n\\n // ======== Testing ========\\n\\n /// Compares two `uint256` values. Expects difference to be less than or equal to `maxDelta`.\\n /// Formats values with decimals in failure message.\\n function assertApproxEqAbsDecimal(uint256 left, uint256 right, uint256 maxDelta, uint256 decimals) external pure;\\n\\n /// Compares two `uint256` values. Expects difference to be less than or equal to `maxDelta`.\\n /// Formats values with decimals in failure message. Includes error message into revert string on failure.\\n function assertApproxEqAbsDecimal(\\n uint256 left,\\n uint256 right,\\n uint256 maxDelta,\\n uint256 decimals,\\n string calldata error\\n ) external pure;\\n\\n /// Compares two `int256` values. Expects difference to be less than or equal to `maxDelta`.\\n /// Formats values with decimals in failure message.\\n function assertApproxEqAbsDecimal(int256 left, int256 right, uint256 maxDelta, uint256 decimals) external pure;\\n\\n /// Compares two `int256` values. Expects difference to be less than or equal to `maxDelta`.\\n /// Formats values with decimals in failure message. Includes error message into revert string on failure.\\n function assertApproxEqAbsDecimal(\\n int256 left,\\n int256 right,\\n uint256 maxDelta,\\n uint256 decimals,\\n string calldata error\\n ) external pure;\\n\\n /// Compares two `uint256` values. Expects difference to be less than or equal to `maxDelta`.\\n function assertApproxEqAbs(uint256 left, uint256 right, uint256 maxDelta) external pure;\\n\\n /// Compares two `uint256` values. Expects difference to be less than or equal to `maxDelta`.\\n /// Includes error message into revert string on failure.\\n function assertApproxEqAbs(uint256 left, uint256 right, uint256 maxDelta, string calldata error) external pure;\\n\\n /// Compares two `int256` values. Expects difference to be less than or equal to `maxDelta`.\\n function assertApproxEqAbs(int256 left, int256 right, uint256 maxDelta) external pure;\\n\\n /// Compares two `int256` values. Expects difference to be less than or equal to `maxDelta`.\\n /// Includes error message into revert string on failure.\\n function assertApproxEqAbs(int256 left, int256 right, uint256 maxDelta, string calldata error) external pure;\\n\\n /// Compares two `uint256` values. Expects relative difference in percents to be less than or equal to `maxPercentDelta`.\\n /// `maxPercentDelta` is an 18 decimal fixed point number, where 1e18 == 100%\\n /// Formats values with decimals in failure message.\\n function assertApproxEqRelDecimal(uint256 left, uint256 right, uint256 maxPercentDelta, uint256 decimals)\\n external\\n pure;\\n\\n /// Compares two `uint256` values. Expects relative difference in percents to be less than or equal to `maxPercentDelta`.\\n /// `maxPercentDelta` is an 18 decimal fixed point number, where 1e18 == 100%\\n /// Formats values with decimals in failure message. Includes error message into revert string on failure.\\n function assertApproxEqRelDecimal(\\n uint256 left,\\n uint256 right,\\n uint256 maxPercentDelta,\\n uint256 decimals,\\n string calldata error\\n ) external pure;\\n\\n /// Compares two `int256` values. Expects relative difference in percents to be less than or equal to `maxPercentDelta`.\\n /// `maxPercentDelta` is an 18 decimal fixed point number, where 1e18 == 100%\\n /// Formats values with decimals in failure message.\\n function assertApproxEqRelDecimal(int256 left, int256 right, uint256 maxPercentDelta, uint256 decimals)\\n external\\n pure;\\n\\n /// Compares two `int256` values. Expects relative difference in percents to be less than or equal to `maxPercentDelta`.\\n /// `maxPercentDelta` is an 18 decimal fixed point number, where 1e18 == 100%\\n /// Formats values with decimals in failure message. Includes error message into revert string on failure.\\n function assertApproxEqRelDecimal(\\n int256 left,\\n int256 right,\\n uint256 maxPercentDelta,\\n uint256 decimals,\\n string calldata error\\n ) external pure;\\n\\n /// Compares two `uint256` values. Expects relative difference in percents to be less than or equal to `maxPercentDelta`.\\n /// `maxPercentDelta` is an 18 decimal fixed point number, where 1e18 == 100%\\n function assertApproxEqRel(uint256 left, uint256 right, uint256 maxPercentDelta) external pure;\\n\\n /// Compares two `uint256` values. Expects relative difference in percents to be less than or equal to `maxPercentDelta`.\\n /// `maxPercentDelta` is an 18 decimal fixed point number, where 1e18 == 100%\\n /// Includes error message into revert string on failure.\\n function assertApproxEqRel(uint256 left, uint256 right, uint256 maxPercentDelta, string calldata error)\\n external\\n pure;\\n\\n /// Compares two `int256` values. Expects relative difference in percents to be less than or equal to `maxPercentDelta`.\\n /// `maxPercentDelta` is an 18 decimal fixed point number, where 1e18 == 100%\\n function assertApproxEqRel(int256 left, int256 right, uint256 maxPercentDelta) external pure;\\n\\n /// Compares two `int256` values. Expects relative difference in percents to be less than or equal to `maxPercentDelta`.\\n /// `maxPercentDelta` is an 18 decimal fixed point number, where 1e18 == 100%\\n /// Includes error message into revert string on failure.\\n function assertApproxEqRel(int256 left, int256 right, uint256 maxPercentDelta, string calldata error)\\n external\\n pure;\\n\\n /// Asserts that two `uint256` values are equal, formatting them with decimals in failure message.\\n function assertEqDecimal(uint256 left, uint256 right, uint256 decimals) external pure;\\n\\n /// Asserts that two `uint256` values are equal, formatting them with decimals in failure message.\\n /// Includes error message into revert string on failure.\\n function assertEqDecimal(uint256 left, uint256 right, uint256 decimals, string calldata error) external pure;\\n\\n /// Asserts that two `int256` values are equal, formatting them with decimals in failure message.\\n function assertEqDecimal(int256 left, int256 right, uint256 decimals) external pure;\\n\\n /// Asserts that two `int256` values are equal, formatting them with decimals in failure message.\\n /// Includes error message into revert string on failure.\\n function assertEqDecimal(int256 left, int256 right, uint256 decimals, string calldata error) external pure;\\n\\n /// Asserts that two `bool` values are equal.\\n function assertEq(bool left, bool right) external pure;\\n\\n /// Asserts that two `bool` values are equal and includes error message into revert string on failure.\\n function assertEq(bool left, bool right, string calldata error) external pure;\\n\\n /// Asserts that two `string` values are equal.\\n function assertEq(string calldata left, string calldata right) external pure;\\n\\n /// Asserts that two `string` values are equal and includes error message into revert string on failure.\\n function assertEq(string calldata left, string calldata right, string calldata error) external pure;\\n\\n /// Asserts that two `bytes` values are equal.\\n function assertEq(bytes calldata left, bytes calldata right) external pure;\\n\\n /// Asserts that two `bytes` values are equal and includes error message into revert string on failure.\\n function assertEq(bytes calldata left, bytes calldata right, string calldata error) external pure;\\n\\n /// Asserts that two arrays of `bool` values are equal.\\n function assertEq(bool[] calldata left, bool[] calldata right) external pure;\\n\\n /// Asserts that two arrays of `bool` values are equal and includes error message into revert string on failure.\\n function assertEq(bool[] calldata left, bool[] calldata right, string calldata error) external pure;\\n\\n /// Asserts that two arrays of `uint256 values are equal.\\n function assertEq(uint256[] calldata left, uint256[] calldata right) external pure;\\n\\n /// Asserts that two arrays of `uint256` values are equal and includes error message into revert string on failure.\\n function assertEq(uint256[] calldata left, uint256[] calldata right, string calldata error) external pure;\\n\\n /// Asserts that two arrays of `int256` values are equal.\\n function assertEq(int256[] calldata left, int256[] calldata right) external pure;\\n\\n /// Asserts that two arrays of `int256` values are equal and includes error message into revert string on failure.\\n function assertEq(int256[] calldata left, int256[] calldata right, string calldata error) external pure;\\n\\n /// Asserts that two `uint256` values are equal.\\n function assertEq(uint256 left, uint256 right) external pure;\\n\\n /// Asserts that two arrays of `address` values are equal.\\n function assertEq(address[] calldata left, address[] calldata right) external pure;\\n\\n /// Asserts that two arrays of `address` values are equal and includes error message into revert string on failure.\\n function assertEq(address[] calldata left, address[] calldata right, string calldata error) external pure;\\n\\n /// Asserts that two arrays of `bytes32` values are equal.\\n function assertEq(bytes32[] calldata left, bytes32[] calldata right) external pure;\\n\\n /// Asserts that two arrays of `bytes32` values are equal and includes error message into revert string on failure.\\n function assertEq(bytes32[] calldata left, bytes32[] calldata right, string calldata error) external pure;\\n\\n /// Asserts that two arrays of `string` values are equal.\\n function assertEq(string[] calldata left, string[] calldata right) external pure;\\n\\n /// Asserts that two arrays of `string` values are equal and includes error message into revert string on failure.\\n function assertEq(string[] calldata left, string[] calldata right, string calldata error) external pure;\\n\\n /// Asserts that two arrays of `bytes` values are equal.\\n function assertEq(bytes[] calldata left, bytes[] calldata right) external pure;\\n\\n /// Asserts that two arrays of `bytes` values are equal and includes error message into revert string on failure.\\n function assertEq(bytes[] calldata left, bytes[] calldata right, string calldata error) external pure;\\n\\n /// Asserts that two `uint256` values are equal and includes error message into revert string on failure.\\n function assertEq(uint256 left, uint256 right, string calldata error) external pure;\\n\\n /// Asserts that two `int256` values are equal.\\n function assertEq(int256 left, int256 right) external pure;\\n\\n /// Asserts that two `int256` values are equal and includes error message into revert string on failure.\\n function assertEq(int256 left, int256 right, string calldata error) external pure;\\n\\n /// Asserts that two `address` values are equal.\\n function assertEq(address left, address right) external pure;\\n\\n /// Asserts that two `address` values are equal and includes error message into revert string on failure.\\n function assertEq(address left, address right, string calldata error) external pure;\\n\\n /// Asserts that two `bytes32` values are equal.\\n function assertEq(bytes32 left, bytes32 right) external pure;\\n\\n /// Asserts that two `bytes32` values are equal and includes error message into revert string on failure.\\n function assertEq(bytes32 left, bytes32 right, string calldata error) external pure;\\n\\n /// Asserts that the given condition is false.\\n function assertFalse(bool condition) external pure;\\n\\n /// Asserts that the given condition is false and includes error message into revert string on failure.\\n function assertFalse(bool condition, string calldata error) external pure;\\n\\n /// Compares two `uint256` values. Expects first value to be greater than or equal to second.\\n /// Formats values with decimals in failure message.\\n function assertGeDecimal(uint256 left, uint256 right, uint256 decimals) external pure;\\n\\n /// Compares two `uint256` values. Expects first value to be greater than or equal to second.\\n /// Formats values with decimals in failure message. Includes error message into revert string on failure.\\n function assertGeDecimal(uint256 left, uint256 right, uint256 decimals, string calldata error) external pure;\\n\\n /// Compares two `int256` values. Expects first value to be greater than or equal to second.\\n /// Formats values with decimals in failure message.\\n function assertGeDecimal(int256 left, int256 right, uint256 decimals) external pure;\\n\\n /// Compares two `int256` values. Expects first value to be greater than or equal to second.\\n /// Formats values with decimals in failure message. Includes error message into revert string on failure.\\n function assertGeDecimal(int256 left, int256 right, uint256 decimals, string calldata error) external pure;\\n\\n /// Compares two `uint256` values. Expects first value to be greater than or equal to second.\\n function assertGe(uint256 left, uint256 right) external pure;\\n\\n /// Compares two `uint256` values. Expects first value to be greater than or equal to second.\\n /// Includes error message into revert string on failure.\\n function assertGe(uint256 left, uint256 right, string calldata error) external pure;\\n\\n /// Compares two `int256` values. Expects first value to be greater than or equal to second.\\n function assertGe(int256 left, int256 right) external pure;\\n\\n /// Compares two `int256` values. Expects first value to be greater than or equal to second.\\n /// Includes error message into revert string on failure.\\n function assertGe(int256 left, int256 right, string calldata error) external pure;\\n\\n /// Compares two `uint256` values. Expects first value to be greater than second.\\n /// Formats values with decimals in failure message.\\n function assertGtDecimal(uint256 left, uint256 right, uint256 decimals) external pure;\\n\\n /// Compares two `uint256` values. Expects first value to be greater than second.\\n /// Formats values with decimals in failure message. Includes error message into revert string on failure.\\n function assertGtDecimal(uint256 left, uint256 right, uint256 decimals, string calldata error) external pure;\\n\\n /// Compares two `int256` values. Expects first value to be greater than second.\\n /// Formats values with decimals in failure message.\\n function assertGtDecimal(int256 left, int256 right, uint256 decimals) external pure;\\n\\n /// Compares two `int256` values. Expects first value to be greater than second.\\n /// Formats values with decimals in failure message. Includes error message into revert string on failure.\\n function assertGtDecimal(int256 left, int256 right, uint256 decimals, string calldata error) external pure;\\n\\n /// Compares two `uint256` values. Expects first value to be greater than second.\\n function assertGt(uint256 left, uint256 right) external pure;\\n\\n /// Compares two `uint256` values. Expects first value to be greater than second.\\n /// Includes error message into revert string on failure.\\n function assertGt(uint256 left, uint256 right, string calldata error) external pure;\\n\\n /// Compares two `int256` values. Expects first value to be greater than second.\\n function assertGt(int256 left, int256 right) external pure;\\n\\n /// Compares two `int256` values. Expects first value to be greater than second.\\n /// Includes error message into revert string on failure.\\n function assertGt(int256 left, int256 right, string calldata error) external pure;\\n\\n /// Compares two `uint256` values. Expects first value to be less than or equal to second.\\n /// Formats values with decimals in failure message.\\n function assertLeDecimal(uint256 left, uint256 right, uint256 decimals) external pure;\\n\\n /// Compares two `uint256` values. Expects first value to be less than or equal to second.\\n /// Formats values with decimals in failure message. Includes error message into revert string on failure.\\n function assertLeDecimal(uint256 left, uint256 right, uint256 decimals, string calldata error) external pure;\\n\\n /// Compares two `int256` values. Expects first value to be less than or equal to second.\\n /// Formats values with decimals in failure message.\\n function assertLeDecimal(int256 left, int256 right, uint256 decimals) external pure;\\n\\n /// Compares two `int256` values. Expects first value to be less than or equal to second.\\n /// Formats values with decimals in failure message. Includes error message into revert string on failure.\\n function assertLeDecimal(int256 left, int256 right, uint256 decimals, string calldata error) external pure;\\n\\n /// Compares two `uint256` values. Expects first value to be less than or equal to second.\\n function assertLe(uint256 left, uint256 right) external pure;\\n\\n /// Compares two `uint256` values. Expects first value to be less than or equal to second.\\n /// Includes error message into revert string on failure.\\n function assertLe(uint256 left, uint256 right, string calldata error) external pure;\\n\\n /// Compares two `int256` values. Expects first value to be less than or equal to second.\\n function assertLe(int256 left, int256 right) external pure;\\n\\n /// Compares two `int256` values. Expects first value to be less than or equal to second.\\n /// Includes error message into revert string on failure.\\n function assertLe(int256 left, int256 right, string calldata error) external pure;\\n\\n /// Compares two `uint256` values. Expects first value to be less than second.\\n /// Formats values with decimals in failure message.\\n function assertLtDecimal(uint256 left, uint256 right, uint256 decimals) external pure;\\n\\n /// Compares two `uint256` values. Expects first value to be less than second.\\n /// Formats values with decimals in failure message. Includes error message into revert string on failure.\\n function assertLtDecimal(uint256 left, uint256 right, uint256 decimals, string calldata error) external pure;\\n\\n /// Compares two `int256` values. Expects first value to be less than second.\\n /// Formats values with decimals in failure message.\\n function assertLtDecimal(int256 left, int256 right, uint256 decimals) external pure;\\n\\n /// Compares two `int256` values. Expects first value to be less than second.\\n /// Formats values with decimals in failure message. Includes error message into revert string on failure.\\n function assertLtDecimal(int256 left, int256 right, uint256 decimals, string calldata error) external pure;\\n\\n /// Compares two `uint256` values. Expects first value to be less than second.\\n function assertLt(uint256 left, uint256 right) external pure;\\n\\n /// Compares two `uint256` values. Expects first value to be less than second.\\n /// Includes error message into revert string on failure.\\n function assertLt(uint256 left, uint256 right, string calldata error) external pure;\\n\\n /// Compares two `int256` values. Expects first value to be less than second.\\n function assertLt(int256 left, int256 right) external pure;\\n\\n /// Compares two `int256` values. Expects first value to be less than second.\\n /// Includes error message into revert string on failure.\\n function assertLt(int256 left, int256 right, string calldata error) external pure;\\n\\n /// Asserts that two `uint256` values are not equal, formatting them with decimals in failure message.\\n function assertNotEqDecimal(uint256 left, uint256 right, uint256 decimals) external pure;\\n\\n /// Asserts that two `uint256` values are not equal, formatting them with decimals in failure message.\\n /// Includes error message into revert string on failure.\\n function assertNotEqDecimal(uint256 left, uint256 right, uint256 decimals, string calldata error) external pure;\\n\\n /// Asserts that two `int256` values are not equal, formatting them with decimals in failure message.\\n function assertNotEqDecimal(int256 left, int256 right, uint256 decimals) external pure;\\n\\n /// Asserts that two `int256` values are not equal, formatting them with decimals in failure message.\\n /// Includes error message into revert string on failure.\\n function assertNotEqDecimal(int256 left, int256 right, uint256 decimals, string calldata error) external pure;\\n\\n /// Asserts that two `bool` values are not equal.\\n function assertNotEq(bool left, bool right) external pure;\\n\\n /// Asserts that two `bool` values are not equal and includes error message into revert string on failure.\\n function assertNotEq(bool left, bool right, string calldata error) external pure;\\n\\n /// Asserts that two `string` values are not equal.\\n function assertNotEq(string calldata left, string calldata right) external pure;\\n\\n /// Asserts that two `string` values are not equal and includes error message into revert string on failure.\\n function assertNotEq(string calldata left, string calldata right, string calldata error) external pure;\\n\\n /// Asserts that two `bytes` values are not equal.\\n function assertNotEq(bytes calldata left, bytes calldata right) external pure;\\n\\n /// Asserts that two `bytes` values are not equal and includes error message into revert string on failure.\\n function assertNotEq(bytes calldata left, bytes calldata right, string calldata error) external pure;\\n\\n /// Asserts that two arrays of `bool` values are not equal.\\n function assertNotEq(bool[] calldata left, bool[] calldata right) external pure;\\n\\n /// Asserts that two arrays of `bool` values are not equal and includes error message into revert string on failure.\\n function assertNotEq(bool[] calldata left, bool[] calldata right, string calldata error) external pure;\\n\\n /// Asserts that two arrays of `uint256` values are not equal.\\n function assertNotEq(uint256[] calldata left, uint256[] calldata right) external pure;\\n\\n /// Asserts that two arrays of `uint256` values are not equal and includes error message into revert string on failure.\\n function assertNotEq(uint256[] calldata left, uint256[] calldata right, string calldata error) external pure;\\n\\n /// Asserts that two arrays of `int256` values are not equal.\\n function assertNotEq(int256[] calldata left, int256[] calldata right) external pure;\\n\\n /// Asserts that two arrays of `int256` values are not equal and includes error message into revert string on failure.\\n function assertNotEq(int256[] calldata left, int256[] calldata right, string calldata error) external pure;\\n\\n /// Asserts that two `uint256` values are not equal.\\n function assertNotEq(uint256 left, uint256 right) external pure;\\n\\n /// Asserts that two arrays of `address` values are not equal.\\n function assertNotEq(address[] calldata left, address[] calldata right) external pure;\\n\\n /// Asserts that two arrays of `address` values are not equal and includes error message into revert string on failure.\\n function assertNotEq(address[] calldata left, address[] calldata right, string calldata error) external pure;\\n\\n /// Asserts that two arrays of `bytes32` values are not equal.\\n function assertNotEq(bytes32[] calldata left, bytes32[] calldata right) external pure;\\n\\n /// Asserts that two arrays of `bytes32` values are not equal and includes error message into revert string on failure.\\n function assertNotEq(bytes32[] calldata left, bytes32[] calldata right, string calldata error) external pure;\\n\\n /// Asserts that two arrays of `string` values are not equal.\\n function assertNotEq(string[] calldata left, string[] calldata right) external pure;\\n\\n /// Asserts that two arrays of `string` values are not equal and includes error message into revert string on failure.\\n function assertNotEq(string[] calldata left, string[] calldata right, string calldata error) external pure;\\n\\n /// Asserts that two arrays of `bytes` values are not equal.\\n function assertNotEq(bytes[] calldata left, bytes[] calldata right) external pure;\\n\\n /// Asserts that two arrays of `bytes` values are not equal and includes error message into revert string on failure.\\n function assertNotEq(bytes[] calldata left, bytes[] calldata right, string calldata error) external pure;\\n\\n /// Asserts that two `uint256` values are not equal and includes error message into revert string on failure.\\n function assertNotEq(uint256 left, uint256 right, string calldata error) external pure;\\n\\n /// Asserts that two `int256` values are not equal.\\n function assertNotEq(int256 left, int256 right) external pure;\\n\\n /// Asserts that two `int256` values are not equal and includes error message into revert string on failure.\\n function assertNotEq(int256 left, int256 right, string calldata error) external pure;\\n\\n /// Asserts that two `address` values are not equal.\\n function assertNotEq(address left, address right) external pure;\\n\\n /// Asserts that two `address` values are not equal and includes error message into revert string on failure.\\n function assertNotEq(address left, address right, string calldata error) external pure;\\n\\n /// Asserts that two `bytes32` values are not equal.\\n function assertNotEq(bytes32 left, bytes32 right) external pure;\\n\\n /// Asserts that two `bytes32` values are not equal and includes error message into revert string on failure.\\n function assertNotEq(bytes32 left, bytes32 right, string calldata error) external pure;\\n\\n /// Asserts that the given condition is true.\\n function assertTrue(bool condition) external pure;\\n\\n /// Asserts that the given condition is true and includes error message into revert string on failure.\\n function assertTrue(bool condition, string calldata error) external pure;\\n\\n /// If the condition is false, discard this run's fuzz inputs and generate new ones.\\n function assume(bool condition) external pure;\\n\\n /// Discard this run's fuzz inputs and generate new ones if next call reverted.\\n function assumeNoRevert() external pure;\\n\\n /// Discard this run's fuzz inputs and generate new ones if next call reverts with the potential revert parameters.\\n function assumeNoRevert(PotentialRevert calldata potentialRevert) external pure;\\n\\n /// Discard this run's fuzz inputs and generate new ones if next call reverts with the any of the potential revert parameters.\\n function assumeNoRevert(PotentialRevert[] calldata potentialReverts) external pure;\\n\\n /// Writes a breakpoint to jump to in the debugger.\\n function breakpoint(string calldata char) external pure;\\n\\n /// Writes a conditional breakpoint to jump to in the debugger.\\n function breakpoint(string calldata char, bool value) external pure;\\n\\n /// Returns true if the current Foundry version is greater than or equal to the given version.\\n /// The given version string must be in the format `major.minor.patch`.\\n /// This is equivalent to `foundryVersionCmp(version) >= 0`.\\n function foundryVersionAtLeast(string calldata version) external view returns (bool);\\n\\n /// Compares the current Foundry version with the given version string.\\n /// The given version string must be in the format `major.minor.patch`.\\n /// Returns:\\n /// -1 if current Foundry version is less than the given version\\n /// 0 if current Foundry version equals the given version\\n /// 1 if current Foundry version is greater than the given version\\n /// This result can then be used with a comparison operator against `0`.\\n /// For example, to check if the current Foundry version is greater than or equal to `1.0.0`:\\n /// `if (foundryVersionCmp(\\\"1.0.0\\\") >= 0) { ... }`\\n function foundryVersionCmp(string calldata version) external view returns (int256);\\n\\n /// Returns the Foundry version.\\n /// Format: -+..\\n /// Sample output: 0.3.0-nightly+3cb96bde9b.1737036656.debug\\n /// Note: Build timestamps may vary slightly across platforms due to separate CI jobs.\\n /// For reliable version comparisons, use UNIX format (e.g., >= 1700000000)\\n /// to compare timestamps while ignoring minor time differences.\\n function getFoundryVersion() external view returns (string memory version);\\n\\n /// Returns the RPC url for the given alias.\\n function rpcUrl(string calldata rpcAlias) external view returns (string memory json);\\n\\n /// Returns all rpc urls and their aliases as structs.\\n function rpcUrlStructs() external view returns (Rpc[] memory urls);\\n\\n /// Returns all rpc urls and their aliases `[alias, url][]`.\\n function rpcUrls() external view returns (string[2][] memory urls);\\n\\n /// Suspends execution of the main thread for `duration` milliseconds.\\n function sleep(uint256 duration) external;\\n\\n // ======== Toml ========\\n\\n /// Checks if `key` exists in a TOML table.\\n function keyExistsToml(string calldata toml, string calldata key) external view returns (bool);\\n\\n /// Parses a string of TOML data at `key` and coerces it to `address`.\\n function parseTomlAddress(string calldata toml, string calldata key) external pure returns (address);\\n\\n /// Parses a string of TOML data at `key` and coerces it to `address[]`.\\n function parseTomlAddressArray(string calldata toml, string calldata key)\\n external\\n pure\\n returns (address[] memory);\\n\\n /// Parses a string of TOML data at `key` and coerces it to `bool`.\\n function parseTomlBool(string calldata toml, string calldata key) external pure returns (bool);\\n\\n /// Parses a string of TOML data at `key` and coerces it to `bool[]`.\\n function parseTomlBoolArray(string calldata toml, string calldata key) external pure returns (bool[] memory);\\n\\n /// Parses a string of TOML data at `key` and coerces it to `bytes`.\\n function parseTomlBytes(string calldata toml, string calldata key) external pure returns (bytes memory);\\n\\n /// Parses a string of TOML data at `key` and coerces it to `bytes32`.\\n function parseTomlBytes32(string calldata toml, string calldata key) external pure returns (bytes32);\\n\\n /// Parses a string of TOML data at `key` and coerces it to `bytes32[]`.\\n function parseTomlBytes32Array(string calldata toml, string calldata key)\\n external\\n pure\\n returns (bytes32[] memory);\\n\\n /// Parses a string of TOML data at `key` and coerces it to `bytes[]`.\\n function parseTomlBytesArray(string calldata toml, string calldata key) external pure returns (bytes[] memory);\\n\\n /// Parses a string of TOML data at `key` and coerces it to `int256`.\\n function parseTomlInt(string calldata toml, string calldata key) external pure returns (int256);\\n\\n /// Parses a string of TOML data at `key` and coerces it to `int256[]`.\\n function parseTomlIntArray(string calldata toml, string calldata key) external pure returns (int256[] memory);\\n\\n /// Returns an array of all the keys in a TOML table.\\n function parseTomlKeys(string calldata toml, string calldata key) external pure returns (string[] memory keys);\\n\\n /// Parses a string of TOML data at `key` and coerces it to `string`.\\n function parseTomlString(string calldata toml, string calldata key) external pure returns (string memory);\\n\\n /// Parses a string of TOML data at `key` and coerces it to `string[]`.\\n function parseTomlStringArray(string calldata toml, string calldata key) external pure returns (string[] memory);\\n\\n /// Parses a string of TOML data at `key` and coerces it to type array corresponding to `typeDescription`.\\n function parseTomlTypeArray(string calldata toml, string calldata key, string calldata typeDescription)\\n external\\n pure\\n returns (bytes memory);\\n\\n /// Parses a string of TOML data and coerces it to type corresponding to `typeDescription`.\\n function parseTomlType(string calldata toml, string calldata typeDescription)\\n external\\n pure\\n returns (bytes memory);\\n\\n /// Parses a string of TOML data at `key` and coerces it to type corresponding to `typeDescription`.\\n function parseTomlType(string calldata toml, string calldata key, string calldata typeDescription)\\n external\\n pure\\n returns (bytes memory);\\n\\n /// Parses a string of TOML data at `key` and coerces it to `uint256`.\\n function parseTomlUint(string calldata toml, string calldata key) external pure returns (uint256);\\n\\n /// Parses a string of TOML data at `key` and coerces it to `uint256[]`.\\n function parseTomlUintArray(string calldata toml, string calldata key) external pure returns (uint256[] memory);\\n\\n /// ABI-encodes a TOML table.\\n function parseToml(string calldata toml) external pure returns (bytes memory abiEncodedData);\\n\\n /// ABI-encodes a TOML table at `key`.\\n function parseToml(string calldata toml, string calldata key) external pure returns (bytes memory abiEncodedData);\\n\\n /// Takes serialized JSON, converts to TOML and write a serialized TOML to a file.\\n function writeToml(string calldata json, string calldata path) external;\\n\\n /// Takes serialized JSON, converts to TOML and write a serialized TOML table to an **existing** TOML file, replacing a value with key = \\n /// This is useful to replace a specific value of a TOML file, without having to parse the entire thing.\\n function writeToml(string calldata json, string calldata path, string calldata valueKey) external;\\n\\n // ======== Utilities ========\\n\\n /// Compute the address of a contract created with CREATE2 using the given CREATE2 deployer.\\n function computeCreate2Address(bytes32 salt, bytes32 initCodeHash, address deployer)\\n external\\n pure\\n returns (address);\\n\\n /// Compute the address of a contract created with CREATE2 using the default CREATE2 deployer.\\n function computeCreate2Address(bytes32 salt, bytes32 initCodeHash) external pure returns (address);\\n\\n /// Compute the address a contract will be deployed at for a given deployer address and nonce.\\n function computeCreateAddress(address deployer, uint256 nonce) external pure returns (address);\\n\\n /// Utility cheatcode to copy storage of `from` contract to another `to` contract.\\n function copyStorage(address from, address to) external;\\n\\n /// Returns ENS namehash for provided string.\\n function ensNamehash(string calldata name) external pure returns (bytes32);\\n\\n /// Gets the label for the specified address.\\n function getLabel(address account) external view returns (string memory currentLabel);\\n\\n /// Labels an address in call traces.\\n function label(address account, string calldata newLabel) external;\\n\\n /// Pauses collection of call traces. Useful in cases when you want to skip tracing of\\n /// complex calls which are not useful for debugging.\\n function pauseTracing() external view;\\n\\n /// Returns a random `address`.\\n function randomAddress() external returns (address);\\n\\n /// Returns a random `bool`.\\n function randomBool() external view returns (bool);\\n\\n /// Returns a random byte array value of the given length.\\n function randomBytes(uint256 len) external view returns (bytes memory);\\n\\n /// Returns a random fixed-size byte array of length 4.\\n function randomBytes4() external view returns (bytes4);\\n\\n /// Returns a random fixed-size byte array of length 8.\\n function randomBytes8() external view returns (bytes8);\\n\\n /// Returns a random `int256` value.\\n function randomInt() external view returns (int256);\\n\\n /// Returns a random `int256` value of given bits.\\n function randomInt(uint256 bits) external view returns (int256);\\n\\n /// Returns a random uint256 value.\\n function randomUint() external returns (uint256);\\n\\n /// Returns random uint256 value between the provided range (=min..=max).\\n function randomUint(uint256 min, uint256 max) external returns (uint256);\\n\\n /// Returns a random `uint256` value of given bits.\\n function randomUint(uint256 bits) external view returns (uint256);\\n\\n /// Unpauses collection of call traces.\\n function resumeTracing() external view;\\n\\n /// Utility cheatcode to set arbitrary storage for given target address.\\n function setArbitraryStorage(address target) external;\\n\\n /// Encodes a `bytes` value to a base64url string.\\n function toBase64URL(bytes calldata data) external pure returns (string memory);\\n\\n /// Encodes a `string` value to a base64url string.\\n function toBase64URL(string calldata data) external pure returns (string memory);\\n\\n /// Encodes a `bytes` value to a base64 string.\\n function toBase64(bytes calldata data) external pure returns (string memory);\\n\\n /// Encodes a `string` value to a base64 string.\\n function toBase64(string calldata data) external pure returns (string memory);\\n}\\n\\n/// The `Vm` interface does allow manipulation of the EVM state. These are all intended to be used\\n/// in tests, but it is not recommended to use these cheats in scripts.\\ninterface Vm is VmSafe {\\n // ======== EVM ========\\n\\n /// Utility cheatcode to set an EIP-2930 access list for all subsequent transactions.\\n function accessList(AccessListItem[] calldata access) external;\\n\\n /// Returns the identifier of the currently active fork. Reverts if no fork is currently active.\\n function activeFork() external view returns (uint256 forkId);\\n\\n /// In forking mode, explicitly grant the given address cheatcode access.\\n function allowCheatcodes(address account) external;\\n\\n /// Sets `block.blobbasefee`\\n function blobBaseFee(uint256 newBlobBaseFee) external;\\n\\n /// Sets the blobhashes in the transaction.\\n /// Not available on EVM versions before Cancun.\\n /// If used on unsupported EVM versions it will revert.\\n function blobhashes(bytes32[] calldata hashes) external;\\n\\n /// Sets `block.chainid`.\\n function chainId(uint256 newChainId) external;\\n\\n /// Clears all mocked calls.\\n function clearMockedCalls() external;\\n\\n /// Clones a source account code, state, balance and nonce to a target account and updates in-memory EVM state.\\n function cloneAccount(address source, address target) external;\\n\\n /// Sets `block.coinbase`.\\n function coinbase(address newCoinbase) external;\\n\\n /// Marks the slots of an account and the account address as cold.\\n function cool(address target) external;\\n\\n /// Utility cheatcode to mark specific storage slot as cold, simulating no prior read.\\n function coolSlot(address target, bytes32 slot) external;\\n\\n /// Creates a new fork with the given endpoint and the _latest_ block and returns the identifier of the fork.\\n function createFork(string calldata urlOrAlias) external returns (uint256 forkId);\\n\\n /// Creates a new fork with the given endpoint and block and returns the identifier of the fork.\\n function createFork(string calldata urlOrAlias, uint256 blockNumber) external returns (uint256 forkId);\\n\\n /// Creates a new fork with the given endpoint and at the block the given transaction was mined in,\\n /// replays all transaction mined in the block before the transaction, and returns the identifier of the fork.\\n function createFork(string calldata urlOrAlias, bytes32 txHash) external returns (uint256 forkId);\\n\\n /// Creates and also selects a new fork with the given endpoint and the latest block and returns the identifier of the fork.\\n function createSelectFork(string calldata urlOrAlias) external returns (uint256 forkId);\\n\\n /// Creates and also selects a new fork with the given endpoint and block and returns the identifier of the fork.\\n function createSelectFork(string calldata urlOrAlias, uint256 blockNumber) external returns (uint256 forkId);\\n\\n /// Creates and also selects new fork with the given endpoint and at the block the given transaction was mined in,\\n /// replays all transaction mined in the block before the transaction, returns the identifier of the fork.\\n function createSelectFork(string calldata urlOrAlias, bytes32 txHash) external returns (uint256 forkId);\\n\\n /// Sets an address' balance.\\n function deal(address account, uint256 newBalance) external;\\n\\n /// Removes the snapshot with the given ID created by `snapshot`.\\n /// Takes the snapshot ID to delete.\\n /// Returns `true` if the snapshot was successfully deleted.\\n /// Returns `false` if the snapshot does not exist.\\n function deleteStateSnapshot(uint256 snapshotId) external returns (bool success);\\n\\n /// Removes _all_ snapshots previously created by `snapshot`.\\n function deleteStateSnapshots() external;\\n\\n /// Sets `block.difficulty`.\\n /// Not available on EVM versions from Paris onwards. Use `prevrandao` instead.\\n /// Reverts if used on unsupported EVM versions.\\n function difficulty(uint256 newDifficulty) external;\\n\\n /// Dump a genesis JSON file's `allocs` to disk.\\n function dumpState(string calldata pathToStateJson) external;\\n\\n /// Sets an address' code.\\n function etch(address target, bytes calldata newRuntimeBytecode) external;\\n\\n /// Sets `block.basefee`.\\n function fee(uint256 newBasefee) external;\\n\\n /// Gets the blockhashes from the current transaction.\\n /// Not available on EVM versions before Cancun.\\n /// If used on unsupported EVM versions it will revert.\\n function getBlobhashes() external view returns (bytes32[] memory hashes);\\n\\n /// Returns true if the account is marked as persistent.\\n function isPersistent(address account) external view returns (bool persistent);\\n\\n /// Load a genesis JSON file's `allocs` into the in-memory EVM state.\\n function loadAllocs(string calldata pathToAllocsJson) external;\\n\\n /// Marks that the account(s) should use persistent storage across fork swaps in a multifork setup\\n /// Meaning, changes made to the state of this account will be kept when switching forks.\\n function makePersistent(address account) external;\\n\\n /// See `makePersistent(address)`.\\n function makePersistent(address account0, address account1) external;\\n\\n /// See `makePersistent(address)`.\\n function makePersistent(address account0, address account1, address account2) external;\\n\\n /// See `makePersistent(address)`.\\n function makePersistent(address[] calldata accounts) external;\\n\\n /// Reverts a call to an address with specified revert data.\\n function mockCallRevert(address callee, bytes calldata data, bytes calldata revertData) external;\\n\\n /// Reverts a call to an address with a specific `msg.value`, with specified revert data.\\n function mockCallRevert(address callee, uint256 msgValue, bytes calldata data, bytes calldata revertData)\\n external;\\n\\n /// Reverts a call to an address with specified revert data.\\n /// Overload to pass the function selector directly `token.approve.selector` instead of `abi.encodeWithSelector(token.approve.selector)`.\\n function mockCallRevert(address callee, bytes4 data, bytes calldata revertData) external;\\n\\n /// Reverts a call to an address with a specific `msg.value`, with specified revert data.\\n /// Overload to pass the function selector directly `token.approve.selector` instead of `abi.encodeWithSelector(token.approve.selector)`.\\n function mockCallRevert(address callee, uint256 msgValue, bytes4 data, bytes calldata revertData) external;\\n\\n /// Mocks a call to an address, returning specified data.\\n /// Calldata can either be strict or a partial match, e.g. if you only\\n /// pass a Solidity selector to the expected calldata, then the entire Solidity\\n /// function will be mocked.\\n function mockCall(address callee, bytes calldata data, bytes calldata returnData) external;\\n\\n /// Mocks a call to an address with a specific `msg.value`, returning specified data.\\n /// Calldata match takes precedence over `msg.value` in case of ambiguity.\\n function mockCall(address callee, uint256 msgValue, bytes calldata data, bytes calldata returnData) external;\\n\\n /// Mocks a call to an address, returning specified data.\\n /// Calldata can either be strict or a partial match, e.g. if you only\\n /// pass a Solidity selector to the expected calldata, then the entire Solidity\\n /// function will be mocked.\\n /// Overload to pass the function selector directly `token.approve.selector` instead of `abi.encodeWithSelector(token.approve.selector)`.\\n function mockCall(address callee, bytes4 data, bytes calldata returnData) external;\\n\\n /// Mocks a call to an address with a specific `msg.value`, returning specified data.\\n /// Calldata match takes precedence over `msg.value` in case of ambiguity.\\n /// Overload to pass the function selector directly `token.approve.selector` instead of `abi.encodeWithSelector(token.approve.selector)`.\\n function mockCall(address callee, uint256 msgValue, bytes4 data, bytes calldata returnData) external;\\n\\n /// Mocks multiple calls to an address, returning specified data for each call.\\n function mockCalls(address callee, bytes calldata data, bytes[] calldata returnData) external;\\n\\n /// Mocks multiple calls to an address with a specific `msg.value`, returning specified data for each call.\\n function mockCalls(address callee, uint256 msgValue, bytes calldata data, bytes[] calldata returnData) external;\\n\\n /// Whenever a call is made to `callee` with calldata `data`, this cheatcode instead calls\\n /// `target` with the same calldata. This functionality is similar to a delegate call made to\\n /// `target` contract from `callee`.\\n /// Can be used to substitute a call to a function with another implementation that captures\\n /// the primary logic of the original function but is easier to reason about.\\n /// If calldata is not a strict match then partial match by selector is attempted.\\n function mockFunction(address callee, address target, bytes calldata data) external;\\n\\n /// Utility cheatcode to remove any EIP-2930 access list set by `accessList` cheatcode.\\n function noAccessList() external;\\n\\n /// Sets the *next* call's `msg.sender` to be the input address.\\n function prank(address msgSender) external;\\n\\n /// Sets the *next* call's `msg.sender` to be the input address, and the `tx.origin` to be the second input.\\n function prank(address msgSender, address txOrigin) external;\\n\\n /// Sets the *next* delegate call's `msg.sender` to be the input address.\\n function prank(address msgSender, bool delegateCall) external;\\n\\n /// Sets the *next* delegate call's `msg.sender` to be the input address, and the `tx.origin` to be the second input.\\n function prank(address msgSender, address txOrigin, bool delegateCall) external;\\n\\n /// Sets `block.prevrandao`.\\n /// Not available on EVM versions before Paris. Use `difficulty` instead.\\n /// If used on unsupported EVM versions it will revert.\\n function prevrandao(bytes32 newPrevrandao) external;\\n\\n /// Sets `block.prevrandao`.\\n /// Not available on EVM versions before Paris. Use `difficulty` instead.\\n /// If used on unsupported EVM versions it will revert.\\n function prevrandao(uint256 newPrevrandao) external;\\n\\n /// Reads the current `msg.sender` and `tx.origin` from state and reports if there is any active caller modification.\\n function readCallers() external returns (CallerMode callerMode, address msgSender, address txOrigin);\\n\\n /// Resets the nonce of an account to 0 for EOAs and 1 for contract accounts.\\n function resetNonce(address account) external;\\n\\n /// Revert the state of the EVM to a previous snapshot\\n /// Takes the snapshot ID to revert to.\\n /// Returns `true` if the snapshot was successfully reverted.\\n /// Returns `false` if the snapshot does not exist.\\n /// **Note:** This does not automatically delete the snapshot. To delete the snapshot use `deleteStateSnapshot`.\\n function revertToState(uint256 snapshotId) external returns (bool success);\\n\\n /// Revert the state of the EVM to a previous snapshot and automatically deletes the snapshots\\n /// Takes the snapshot ID to revert to.\\n /// Returns `true` if the snapshot was successfully reverted and deleted.\\n /// Returns `false` if the snapshot does not exist.\\n function revertToStateAndDelete(uint256 snapshotId) external returns (bool success);\\n\\n /// Revokes persistent status from the address, previously added via `makePersistent`.\\n function revokePersistent(address account) external;\\n\\n /// See `revokePersistent(address)`.\\n function revokePersistent(address[] calldata accounts) external;\\n\\n /// Sets `block.height`.\\n function roll(uint256 newHeight) external;\\n\\n /// Updates the currently active fork to given block number\\n /// This is similar to `roll` but for the currently active fork.\\n function rollFork(uint256 blockNumber) external;\\n\\n /// Updates the currently active fork to given transaction. This will `rollFork` with the number\\n /// of the block the transaction was mined in and replays all transaction mined before it in the block.\\n function rollFork(bytes32 txHash) external;\\n\\n /// Updates the given fork to given block number.\\n function rollFork(uint256 forkId, uint256 blockNumber) external;\\n\\n /// Updates the given fork to block number of the given transaction and replays all transaction mined before it in the block.\\n function rollFork(uint256 forkId, bytes32 txHash) external;\\n\\n /// Takes a fork identifier created by `createFork` and sets the corresponding forked state as active.\\n function selectFork(uint256 forkId) external;\\n\\n /// Set blockhash for the current block.\\n /// It only sets the blockhash for blocks where `block.number - 256 <= number < block.number`.\\n function setBlockhash(uint256 blockNumber, bytes32 blockHash) external;\\n\\n /// Sets the nonce of an account. Must be higher than the current nonce of the account.\\n function setNonce(address account, uint64 newNonce) external;\\n\\n /// Sets the nonce of an account to an arbitrary value.\\n function setNonceUnsafe(address account, uint64 newNonce) external;\\n\\n /// Snapshot capture the gas usage of the last call by name from the callee perspective.\\n function snapshotGasLastCall(string calldata name) external returns (uint256 gasUsed);\\n\\n /// Snapshot capture the gas usage of the last call by name in a group from the callee perspective.\\n function snapshotGasLastCall(string calldata group, string calldata name) external returns (uint256 gasUsed);\\n\\n /// Snapshot the current state of the evm.\\n /// Returns the ID of the snapshot that was created.\\n /// To revert a snapshot use `revertToState`.\\n function snapshotState() external returns (uint256 snapshotId);\\n\\n /// Snapshot capture an arbitrary numerical value by name.\\n /// The group name is derived from the contract name.\\n function snapshotValue(string calldata name, uint256 value) external;\\n\\n /// Snapshot capture an arbitrary numerical value by name in a group.\\n function snapshotValue(string calldata group, string calldata name, uint256 value) external;\\n\\n /// Sets all subsequent calls' `msg.sender` to be the input address until `stopPrank` is called.\\n function startPrank(address msgSender) external;\\n\\n /// Sets all subsequent calls' `msg.sender` to be the input address until `stopPrank` is called, and the `tx.origin` to be the second input.\\n function startPrank(address msgSender, address txOrigin) external;\\n\\n /// Sets all subsequent delegate calls' `msg.sender` to be the input address until `stopPrank` is called.\\n function startPrank(address msgSender, bool delegateCall) external;\\n\\n /// Sets all subsequent delegate calls' `msg.sender` to be the input address until `stopPrank` is called, and the `tx.origin` to be the second input.\\n function startPrank(address msgSender, address txOrigin, bool delegateCall) external;\\n\\n /// Start a snapshot capture of the current gas usage by name.\\n /// The group name is derived from the contract name.\\n function startSnapshotGas(string calldata name) external;\\n\\n /// Start a snapshot capture of the current gas usage by name in a group.\\n function startSnapshotGas(string calldata group, string calldata name) external;\\n\\n /// Resets subsequent calls' `msg.sender` to be `address(this)`.\\n function stopPrank() external;\\n\\n /// Stop the snapshot capture of the current gas by latest snapshot name, capturing the gas used since the start.\\n function stopSnapshotGas() external returns (uint256 gasUsed);\\n\\n /// Stop the snapshot capture of the current gas usage by name, capturing the gas used since the start.\\n /// The group name is derived from the contract name.\\n function stopSnapshotGas(string calldata name) external returns (uint256 gasUsed);\\n\\n /// Stop the snapshot capture of the current gas usage by name in a group, capturing the gas used since the start.\\n function stopSnapshotGas(string calldata group, string calldata name) external returns (uint256 gasUsed);\\n\\n /// Stores a value to an address' storage slot.\\n function store(address target, bytes32 slot, bytes32 value) external;\\n\\n /// Fetches the given transaction from the active fork and executes it on the current state.\\n function transact(bytes32 txHash) external;\\n\\n /// Fetches the given transaction from the given fork and executes it on the current state.\\n function transact(uint256 forkId, bytes32 txHash) external;\\n\\n /// Sets `tx.gasprice`.\\n function txGasPrice(uint256 newGasPrice) external;\\n\\n /// Utility cheatcode to mark specific storage slot as warm, simulating a prior read.\\n function warmSlot(address target, bytes32 slot) external;\\n\\n /// Sets `block.timestamp`.\\n function warp(uint256 newTimestamp) external;\\n\\n /// `deleteSnapshot` is being deprecated in favor of `deleteStateSnapshot`. It will be removed in future versions.\\n function deleteSnapshot(uint256 snapshotId) external returns (bool success);\\n\\n /// `deleteSnapshots` is being deprecated in favor of `deleteStateSnapshots`. It will be removed in future versions.\\n function deleteSnapshots() external;\\n\\n /// `revertToAndDelete` is being deprecated in favor of `revertToStateAndDelete`. It will be removed in future versions.\\n function revertToAndDelete(uint256 snapshotId) external returns (bool success);\\n\\n /// `revertTo` is being deprecated in favor of `revertToState`. It will be removed in future versions.\\n function revertTo(uint256 snapshotId) external returns (bool success);\\n\\n /// `snapshot` is being deprecated in favor of `snapshotState`. It will be removed in future versions.\\n function snapshot() external returns (uint256 snapshotId);\\n\\n // ======== Testing ========\\n\\n /// Expect a call to an address with the specified `msg.value` and calldata, and a *minimum* amount of gas.\\n function expectCallMinGas(address callee, uint256 msgValue, uint64 minGas, bytes calldata data) external;\\n\\n /// Expect given number of calls to an address with the specified `msg.value` and calldata, and a *minimum* amount of gas.\\n function expectCallMinGas(address callee, uint256 msgValue, uint64 minGas, bytes calldata data, uint64 count)\\n external;\\n\\n /// Expects a call to an address with the specified calldata.\\n /// Calldata can either be a strict or a partial match.\\n function expectCall(address callee, bytes calldata data) external;\\n\\n /// Expects given number of calls to an address with the specified calldata.\\n function expectCall(address callee, bytes calldata data, uint64 count) external;\\n\\n /// Expects a call to an address with the specified `msg.value` and calldata.\\n function expectCall(address callee, uint256 msgValue, bytes calldata data) external;\\n\\n /// Expects given number of calls to an address with the specified `msg.value` and calldata.\\n function expectCall(address callee, uint256 msgValue, bytes calldata data, uint64 count) external;\\n\\n /// Expect a call to an address with the specified `msg.value`, gas, and calldata.\\n function expectCall(address callee, uint256 msgValue, uint64 gas, bytes calldata data) external;\\n\\n /// Expects given number of calls to an address with the specified `msg.value`, gas, and calldata.\\n function expectCall(address callee, uint256 msgValue, uint64 gas, bytes calldata data, uint64 count) external;\\n\\n /// Expects the deployment of the specified bytecode by the specified address using the CREATE opcode\\n function expectCreate(bytes calldata bytecode, address deployer) external;\\n\\n /// Expects the deployment of the specified bytecode by the specified address using the CREATE2 opcode\\n function expectCreate2(bytes calldata bytecode, address deployer) external;\\n\\n /// Prepare an expected anonymous log with (bool checkTopic1, bool checkTopic2, bool checkTopic3, bool checkData.).\\n /// Call this function, then emit an anonymous event, then call a function. Internally after the call, we check if\\n /// logs were emitted in the expected order with the expected topics and data (as specified by the booleans).\\n function expectEmitAnonymous(bool checkTopic0, bool checkTopic1, bool checkTopic2, bool checkTopic3, bool checkData)\\n external;\\n\\n /// Same as the previous method, but also checks supplied address against emitting contract.\\n function expectEmitAnonymous(\\n bool checkTopic0,\\n bool checkTopic1,\\n bool checkTopic2,\\n bool checkTopic3,\\n bool checkData,\\n address emitter\\n ) external;\\n\\n /// Prepare an expected anonymous log with all topic and data checks enabled.\\n /// Call this function, then emit an anonymous event, then call a function. Internally after the call, we check if\\n /// logs were emitted in the expected order with the expected topics and data.\\n function expectEmitAnonymous() external;\\n\\n /// Same as the previous method, but also checks supplied address against emitting contract.\\n function expectEmitAnonymous(address emitter) external;\\n\\n /// Prepare an expected log with (bool checkTopic1, bool checkTopic2, bool checkTopic3, bool checkData.).\\n /// Call this function, then emit an event, then call a function. Internally after the call, we check if\\n /// logs were emitted in the expected order with the expected topics and data (as specified by the booleans).\\n function expectEmit(bool checkTopic1, bool checkTopic2, bool checkTopic3, bool checkData) external;\\n\\n /// Same as the previous method, but also checks supplied address against emitting contract.\\n function expectEmit(bool checkTopic1, bool checkTopic2, bool checkTopic3, bool checkData, address emitter)\\n external;\\n\\n /// Prepare an expected log with all topic and data checks enabled.\\n /// Call this function, then emit an event, then call a function. Internally after the call, we check if\\n /// logs were emitted in the expected order with the expected topics and data.\\n function expectEmit() external;\\n\\n /// Same as the previous method, but also checks supplied address against emitting contract.\\n function expectEmit(address emitter) external;\\n\\n /// Expect a given number of logs with the provided topics.\\n function expectEmit(bool checkTopic1, bool checkTopic2, bool checkTopic3, bool checkData, uint64 count) external;\\n\\n /// Expect a given number of logs from a specific emitter with the provided topics.\\n function expectEmit(\\n bool checkTopic1,\\n bool checkTopic2,\\n bool checkTopic3,\\n bool checkData,\\n address emitter,\\n uint64 count\\n ) external;\\n\\n /// Expect a given number of logs with all topic and data checks enabled.\\n function expectEmit(uint64 count) external;\\n\\n /// Expect a given number of logs from a specific emitter with all topic and data checks enabled.\\n function expectEmit(address emitter, uint64 count) external;\\n\\n /// Expects an error on next call that starts with the revert data.\\n function expectPartialRevert(bytes4 revertData) external;\\n\\n /// Expects an error on next call to reverter address, that starts with the revert data.\\n function expectPartialRevert(bytes4 revertData, address reverter) external;\\n\\n /// Expects an error on next call with any revert data.\\n function expectRevert() external;\\n\\n /// Expects an error on next call that exactly matches the revert data.\\n function expectRevert(bytes4 revertData) external;\\n\\n /// Expects a `count` number of reverts from the upcoming calls from the reverter address that match the revert data.\\n function expectRevert(bytes4 revertData, address reverter, uint64 count) external;\\n\\n /// Expects a `count` number of reverts from the upcoming calls from the reverter address that exactly match the revert data.\\n function expectRevert(bytes calldata revertData, address reverter, uint64 count) external;\\n\\n /// Expects an error on next call that exactly matches the revert data.\\n function expectRevert(bytes calldata revertData) external;\\n\\n /// Expects an error with any revert data on next call to reverter address.\\n function expectRevert(address reverter) external;\\n\\n /// Expects an error from reverter address on next call, with any revert data.\\n function expectRevert(bytes4 revertData, address reverter) external;\\n\\n /// Expects an error from reverter address on next call, that exactly matches the revert data.\\n function expectRevert(bytes calldata revertData, address reverter) external;\\n\\n /// Expects a `count` number of reverts from the upcoming calls with any revert data or reverter.\\n function expectRevert(uint64 count) external;\\n\\n /// Expects a `count` number of reverts from the upcoming calls that match the revert data.\\n function expectRevert(bytes4 revertData, uint64 count) external;\\n\\n /// Expects a `count` number of reverts from the upcoming calls that exactly match the revert data.\\n function expectRevert(bytes calldata revertData, uint64 count) external;\\n\\n /// Expects a `count` number of reverts from the upcoming calls from the reverter address.\\n function expectRevert(address reverter, uint64 count) external;\\n\\n /// Only allows memory writes to offsets [0x00, 0x60) \\u222a [min, max) in the current subcontext. If any other\\n /// memory is written to, the test will fail. Can be called multiple times to add more ranges to the set.\\n function expectSafeMemory(uint64 min, uint64 max) external;\\n\\n /// Only allows memory writes to offsets [0x00, 0x60) \\u222a [min, max) in the next created subcontext.\\n /// If any other memory is written to, the test will fail. Can be called multiple times to add more ranges\\n /// to the set.\\n function expectSafeMemoryCall(uint64 min, uint64 max) external;\\n\\n /// Marks a test as skipped. Must be called at the top level of a test.\\n function skip(bool skipTest) external;\\n\\n /// Marks a test as skipped with a reason. Must be called at the top level of a test.\\n function skip(bool skipTest, string calldata reason) external;\\n\\n /// Stops all safe memory expectation in the current subcontext.\\n function stopExpectSafeMemory() external;\\n}\\n\",\"keccak256\":\"0xd91fb0df409fbd22463e937b48b9682d9333c5d4528d8fe7b36102a0323c44bf\",\"license\":\"MIT OR Apache-2.0\"},\"lib/forge-std/src/console.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity >=0.4.22 <0.9.0;\\n\\nlibrary console {\\n address constant CONSOLE_ADDRESS =\\n 0x000000000000000000636F6e736F6c652e6c6f67;\\n\\n function _sendLogPayloadImplementation(bytes memory payload) internal view {\\n address consoleAddress = CONSOLE_ADDRESS;\\n /// @solidity memory-safe-assembly\\n assembly {\\n pop(\\n staticcall(\\n gas(),\\n consoleAddress,\\n add(payload, 32),\\n mload(payload),\\n 0,\\n 0\\n )\\n )\\n }\\n }\\n\\n function _castToPure(\\n function(bytes memory) internal view fnIn\\n ) internal pure returns (function(bytes memory) pure fnOut) {\\n assembly {\\n fnOut := fnIn\\n }\\n }\\n\\n function _sendLogPayload(bytes memory payload) internal pure {\\n _castToPure(_sendLogPayloadImplementation)(payload);\\n }\\n\\n function log() internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log()\\\"));\\n }\\n\\n function logInt(int256 p0) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(int256)\\\", p0));\\n }\\n\\n function logUint(uint256 p0) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256)\\\", p0));\\n }\\n\\n function logString(string memory p0) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string)\\\", p0));\\n }\\n\\n function logBool(bool p0) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool)\\\", p0));\\n }\\n\\n function logAddress(address p0) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address)\\\", p0));\\n }\\n\\n function logBytes(bytes memory p0) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bytes)\\\", p0));\\n }\\n\\n function logBytes1(bytes1 p0) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bytes1)\\\", p0));\\n }\\n\\n function logBytes2(bytes2 p0) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bytes2)\\\", p0));\\n }\\n\\n function logBytes3(bytes3 p0) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bytes3)\\\", p0));\\n }\\n\\n function logBytes4(bytes4 p0) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bytes4)\\\", p0));\\n }\\n\\n function logBytes5(bytes5 p0) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bytes5)\\\", p0));\\n }\\n\\n function logBytes6(bytes6 p0) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bytes6)\\\", p0));\\n }\\n\\n function logBytes7(bytes7 p0) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bytes7)\\\", p0));\\n }\\n\\n function logBytes8(bytes8 p0) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bytes8)\\\", p0));\\n }\\n\\n function logBytes9(bytes9 p0) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bytes9)\\\", p0));\\n }\\n\\n function logBytes10(bytes10 p0) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bytes10)\\\", p0));\\n }\\n\\n function logBytes11(bytes11 p0) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bytes11)\\\", p0));\\n }\\n\\n function logBytes12(bytes12 p0) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bytes12)\\\", p0));\\n }\\n\\n function logBytes13(bytes13 p0) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bytes13)\\\", p0));\\n }\\n\\n function logBytes14(bytes14 p0) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bytes14)\\\", p0));\\n }\\n\\n function logBytes15(bytes15 p0) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bytes15)\\\", p0));\\n }\\n\\n function logBytes16(bytes16 p0) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bytes16)\\\", p0));\\n }\\n\\n function logBytes17(bytes17 p0) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bytes17)\\\", p0));\\n }\\n\\n function logBytes18(bytes18 p0) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bytes18)\\\", p0));\\n }\\n\\n function logBytes19(bytes19 p0) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bytes19)\\\", p0));\\n }\\n\\n function logBytes20(bytes20 p0) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bytes20)\\\", p0));\\n }\\n\\n function logBytes21(bytes21 p0) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bytes21)\\\", p0));\\n }\\n\\n function logBytes22(bytes22 p0) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bytes22)\\\", p0));\\n }\\n\\n function logBytes23(bytes23 p0) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bytes23)\\\", p0));\\n }\\n\\n function logBytes24(bytes24 p0) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bytes24)\\\", p0));\\n }\\n\\n function logBytes25(bytes25 p0) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bytes25)\\\", p0));\\n }\\n\\n function logBytes26(bytes26 p0) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bytes26)\\\", p0));\\n }\\n\\n function logBytes27(bytes27 p0) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bytes27)\\\", p0));\\n }\\n\\n function logBytes28(bytes28 p0) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bytes28)\\\", p0));\\n }\\n\\n function logBytes29(bytes29 p0) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bytes29)\\\", p0));\\n }\\n\\n function logBytes30(bytes30 p0) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bytes30)\\\", p0));\\n }\\n\\n function logBytes31(bytes31 p0) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bytes31)\\\", p0));\\n }\\n\\n function logBytes32(bytes32 p0) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bytes32)\\\", p0));\\n }\\n\\n function log(uint256 p0) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256)\\\", p0));\\n }\\n\\n function log(int256 p0) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(int256)\\\", p0));\\n }\\n\\n function log(string memory p0) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string)\\\", p0));\\n }\\n\\n function log(bool p0) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool)\\\", p0));\\n }\\n\\n function log(address p0) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address)\\\", p0));\\n }\\n\\n function log(uint256 p0, uint256 p1) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,uint256)\\\", p0, p1));\\n }\\n\\n function log(uint256 p0, string memory p1) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,string)\\\", p0, p1));\\n }\\n\\n function log(uint256 p0, bool p1) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,bool)\\\", p0, p1));\\n }\\n\\n function log(uint256 p0, address p1) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,address)\\\", p0, p1));\\n }\\n\\n function log(string memory p0, uint256 p1) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,uint256)\\\", p0, p1));\\n }\\n\\n function log(string memory p0, int256 p1) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,int256)\\\", p0, p1));\\n }\\n\\n function log(string memory p0, string memory p1) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,string)\\\", p0, p1));\\n }\\n\\n function log(string memory p0, bool p1) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,bool)\\\", p0, p1));\\n }\\n\\n function log(string memory p0, address p1) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,address)\\\", p0, p1));\\n }\\n\\n function log(bool p0, uint256 p1) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,uint256)\\\", p0, p1));\\n }\\n\\n function log(bool p0, string memory p1) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,string)\\\", p0, p1));\\n }\\n\\n function log(bool p0, bool p1) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,bool)\\\", p0, p1));\\n }\\n\\n function log(bool p0, address p1) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,address)\\\", p0, p1));\\n }\\n\\n function log(address p0, uint256 p1) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,uint256)\\\", p0, p1));\\n }\\n\\n function log(address p0, string memory p1) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,string)\\\", p0, p1));\\n }\\n\\n function log(address p0, bool p1) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,bool)\\\", p0, p1));\\n }\\n\\n function log(address p0, address p1) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,address)\\\", p0, p1));\\n }\\n\\n function log(uint256 p0, uint256 p1, uint256 p2) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,uint256,uint256)\\\", p0, p1, p2));\\n }\\n\\n function log(uint256 p0, uint256 p1, string memory p2) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,uint256,string)\\\", p0, p1, p2));\\n }\\n\\n function log(uint256 p0, uint256 p1, bool p2) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,uint256,bool)\\\", p0, p1, p2));\\n }\\n\\n function log(uint256 p0, uint256 p1, address p2) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,uint256,address)\\\", p0, p1, p2));\\n }\\n\\n function log(uint256 p0, string memory p1, uint256 p2) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,string,uint256)\\\", p0, p1, p2));\\n }\\n\\n function log(uint256 p0, string memory p1, string memory p2) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,string,string)\\\", p0, p1, p2));\\n }\\n\\n function log(uint256 p0, string memory p1, bool p2) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,string,bool)\\\", p0, p1, p2));\\n }\\n\\n function log(uint256 p0, string memory p1, address p2) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,string,address)\\\", p0, p1, p2));\\n }\\n\\n function log(uint256 p0, bool p1, uint256 p2) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,bool,uint256)\\\", p0, p1, p2));\\n }\\n\\n function log(uint256 p0, bool p1, string memory p2) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,bool,string)\\\", p0, p1, p2));\\n }\\n\\n function log(uint256 p0, bool p1, bool p2) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,bool,bool)\\\", p0, p1, p2));\\n }\\n\\n function log(uint256 p0, bool p1, address p2) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,bool,address)\\\", p0, p1, p2));\\n }\\n\\n function log(uint256 p0, address p1, uint256 p2) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,address,uint256)\\\", p0, p1, p2));\\n }\\n\\n function log(uint256 p0, address p1, string memory p2) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,address,string)\\\", p0, p1, p2));\\n }\\n\\n function log(uint256 p0, address p1, bool p2) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,address,bool)\\\", p0, p1, p2));\\n }\\n\\n function log(uint256 p0, address p1, address p2) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,address,address)\\\", p0, p1, p2));\\n }\\n\\n function log(string memory p0, uint256 p1, uint256 p2) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,uint256,uint256)\\\", p0, p1, p2));\\n }\\n\\n function log(string memory p0, uint256 p1, string memory p2) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,uint256,string)\\\", p0, p1, p2));\\n }\\n\\n function log(string memory p0, uint256 p1, bool p2) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,uint256,bool)\\\", p0, p1, p2));\\n }\\n\\n function log(string memory p0, uint256 p1, address p2) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,uint256,address)\\\", p0, p1, p2));\\n }\\n\\n function log(string memory p0, string memory p1, uint256 p2) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,string,uint256)\\\", p0, p1, p2));\\n }\\n\\n function log(string memory p0, string memory p1, string memory p2) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,string,string)\\\", p0, p1, p2));\\n }\\n\\n function log(string memory p0, string memory p1, bool p2) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,string,bool)\\\", p0, p1, p2));\\n }\\n\\n function log(string memory p0, string memory p1, address p2) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,string,address)\\\", p0, p1, p2));\\n }\\n\\n function log(string memory p0, bool p1, uint256 p2) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,bool,uint256)\\\", p0, p1, p2));\\n }\\n\\n function log(string memory p0, bool p1, string memory p2) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,bool,string)\\\", p0, p1, p2));\\n }\\n\\n function log(string memory p0, bool p1, bool p2) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,bool,bool)\\\", p0, p1, p2));\\n }\\n\\n function log(string memory p0, bool p1, address p2) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,bool,address)\\\", p0, p1, p2));\\n }\\n\\n function log(string memory p0, address p1, uint256 p2) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,address,uint256)\\\", p0, p1, p2));\\n }\\n\\n function log(string memory p0, address p1, string memory p2) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,address,string)\\\", p0, p1, p2));\\n }\\n\\n function log(string memory p0, address p1, bool p2) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,address,bool)\\\", p0, p1, p2));\\n }\\n\\n function log(string memory p0, address p1, address p2) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,address,address)\\\", p0, p1, p2));\\n }\\n\\n function log(bool p0, uint256 p1, uint256 p2) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,uint256,uint256)\\\", p0, p1, p2));\\n }\\n\\n function log(bool p0, uint256 p1, string memory p2) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,uint256,string)\\\", p0, p1, p2));\\n }\\n\\n function log(bool p0, uint256 p1, bool p2) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,uint256,bool)\\\", p0, p1, p2));\\n }\\n\\n function log(bool p0, uint256 p1, address p2) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,uint256,address)\\\", p0, p1, p2));\\n }\\n\\n function log(bool p0, string memory p1, uint256 p2) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,string,uint256)\\\", p0, p1, p2));\\n }\\n\\n function log(bool p0, string memory p1, string memory p2) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,string,string)\\\", p0, p1, p2));\\n }\\n\\n function log(bool p0, string memory p1, bool p2) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,string,bool)\\\", p0, p1, p2));\\n }\\n\\n function log(bool p0, string memory p1, address p2) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,string,address)\\\", p0, p1, p2));\\n }\\n\\n function log(bool p0, bool p1, uint256 p2) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,bool,uint256)\\\", p0, p1, p2));\\n }\\n\\n function log(bool p0, bool p1, string memory p2) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,bool,string)\\\", p0, p1, p2));\\n }\\n\\n function log(bool p0, bool p1, bool p2) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,bool,bool)\\\", p0, p1, p2));\\n }\\n\\n function log(bool p0, bool p1, address p2) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,bool,address)\\\", p0, p1, p2));\\n }\\n\\n function log(bool p0, address p1, uint256 p2) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,address,uint256)\\\", p0, p1, p2));\\n }\\n\\n function log(bool p0, address p1, string memory p2) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,address,string)\\\", p0, p1, p2));\\n }\\n\\n function log(bool p0, address p1, bool p2) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,address,bool)\\\", p0, p1, p2));\\n }\\n\\n function log(bool p0, address p1, address p2) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,address,address)\\\", p0, p1, p2));\\n }\\n\\n function log(address p0, uint256 p1, uint256 p2) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,uint256,uint256)\\\", p0, p1, p2));\\n }\\n\\n function log(address p0, uint256 p1, string memory p2) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,uint256,string)\\\", p0, p1, p2));\\n }\\n\\n function log(address p0, uint256 p1, bool p2) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,uint256,bool)\\\", p0, p1, p2));\\n }\\n\\n function log(address p0, uint256 p1, address p2) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,uint256,address)\\\", p0, p1, p2));\\n }\\n\\n function log(address p0, string memory p1, uint256 p2) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,string,uint256)\\\", p0, p1, p2));\\n }\\n\\n function log(address p0, string memory p1, string memory p2) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,string,string)\\\", p0, p1, p2));\\n }\\n\\n function log(address p0, string memory p1, bool p2) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,string,bool)\\\", p0, p1, p2));\\n }\\n\\n function log(address p0, string memory p1, address p2) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,string,address)\\\", p0, p1, p2));\\n }\\n\\n function log(address p0, bool p1, uint256 p2) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,bool,uint256)\\\", p0, p1, p2));\\n }\\n\\n function log(address p0, bool p1, string memory p2) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,bool,string)\\\", p0, p1, p2));\\n }\\n\\n function log(address p0, bool p1, bool p2) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,bool,bool)\\\", p0, p1, p2));\\n }\\n\\n function log(address p0, bool p1, address p2) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,bool,address)\\\", p0, p1, p2));\\n }\\n\\n function log(address p0, address p1, uint256 p2) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,address,uint256)\\\", p0, p1, p2));\\n }\\n\\n function log(address p0, address p1, string memory p2) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,address,string)\\\", p0, p1, p2));\\n }\\n\\n function log(address p0, address p1, bool p2) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,address,bool)\\\", p0, p1, p2));\\n }\\n\\n function log(address p0, address p1, address p2) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,address,address)\\\", p0, p1, p2));\\n }\\n\\n function log(uint256 p0, uint256 p1, uint256 p2, uint256 p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,uint256,uint256,uint256)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(uint256 p0, uint256 p1, uint256 p2, string memory p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,uint256,uint256,string)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(uint256 p0, uint256 p1, uint256 p2, bool p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,uint256,uint256,bool)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(uint256 p0, uint256 p1, uint256 p2, address p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,uint256,uint256,address)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(uint256 p0, uint256 p1, string memory p2, uint256 p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,uint256,string,uint256)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(uint256 p0, uint256 p1, string memory p2, string memory p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,uint256,string,string)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(uint256 p0, uint256 p1, string memory p2, bool p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,uint256,string,bool)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(uint256 p0, uint256 p1, string memory p2, address p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,uint256,string,address)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(uint256 p0, uint256 p1, bool p2, uint256 p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,uint256,bool,uint256)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(uint256 p0, uint256 p1, bool p2, string memory p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,uint256,bool,string)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(uint256 p0, uint256 p1, bool p2, bool p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,uint256,bool,bool)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(uint256 p0, uint256 p1, bool p2, address p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,uint256,bool,address)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(uint256 p0, uint256 p1, address p2, uint256 p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,uint256,address,uint256)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(uint256 p0, uint256 p1, address p2, string memory p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,uint256,address,string)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(uint256 p0, uint256 p1, address p2, bool p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,uint256,address,bool)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(uint256 p0, uint256 p1, address p2, address p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,uint256,address,address)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(uint256 p0, string memory p1, uint256 p2, uint256 p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,string,uint256,uint256)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(uint256 p0, string memory p1, uint256 p2, string memory p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,string,uint256,string)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(uint256 p0, string memory p1, uint256 p2, bool p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,string,uint256,bool)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(uint256 p0, string memory p1, uint256 p2, address p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,string,uint256,address)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(uint256 p0, string memory p1, string memory p2, uint256 p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,string,string,uint256)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(uint256 p0, string memory p1, string memory p2, string memory p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,string,string,string)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(uint256 p0, string memory p1, string memory p2, bool p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,string,string,bool)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(uint256 p0, string memory p1, string memory p2, address p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,string,string,address)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(uint256 p0, string memory p1, bool p2, uint256 p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,string,bool,uint256)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(uint256 p0, string memory p1, bool p2, string memory p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,string,bool,string)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(uint256 p0, string memory p1, bool p2, bool p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,string,bool,bool)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(uint256 p0, string memory p1, bool p2, address p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,string,bool,address)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(uint256 p0, string memory p1, address p2, uint256 p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,string,address,uint256)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(uint256 p0, string memory p1, address p2, string memory p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,string,address,string)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(uint256 p0, string memory p1, address p2, bool p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,string,address,bool)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(uint256 p0, string memory p1, address p2, address p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,string,address,address)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(uint256 p0, bool p1, uint256 p2, uint256 p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,bool,uint256,uint256)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(uint256 p0, bool p1, uint256 p2, string memory p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,bool,uint256,string)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(uint256 p0, bool p1, uint256 p2, bool p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,bool,uint256,bool)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(uint256 p0, bool p1, uint256 p2, address p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,bool,uint256,address)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(uint256 p0, bool p1, string memory p2, uint256 p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,bool,string,uint256)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(uint256 p0, bool p1, string memory p2, string memory p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,bool,string,string)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(uint256 p0, bool p1, string memory p2, bool p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,bool,string,bool)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(uint256 p0, bool p1, string memory p2, address p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,bool,string,address)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(uint256 p0, bool p1, bool p2, uint256 p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,bool,bool,uint256)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(uint256 p0, bool p1, bool p2, string memory p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,bool,bool,string)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(uint256 p0, bool p1, bool p2, bool p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,bool,bool,bool)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(uint256 p0, bool p1, bool p2, address p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,bool,bool,address)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(uint256 p0, bool p1, address p2, uint256 p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,bool,address,uint256)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(uint256 p0, bool p1, address p2, string memory p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,bool,address,string)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(uint256 p0, bool p1, address p2, bool p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,bool,address,bool)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(uint256 p0, bool p1, address p2, address p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,bool,address,address)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(uint256 p0, address p1, uint256 p2, uint256 p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,address,uint256,uint256)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(uint256 p0, address p1, uint256 p2, string memory p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,address,uint256,string)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(uint256 p0, address p1, uint256 p2, bool p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,address,uint256,bool)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(uint256 p0, address p1, uint256 p2, address p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,address,uint256,address)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(uint256 p0, address p1, string memory p2, uint256 p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,address,string,uint256)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(uint256 p0, address p1, string memory p2, string memory p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,address,string,string)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(uint256 p0, address p1, string memory p2, bool p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,address,string,bool)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(uint256 p0, address p1, string memory p2, address p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,address,string,address)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(uint256 p0, address p1, bool p2, uint256 p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,address,bool,uint256)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(uint256 p0, address p1, bool p2, string memory p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,address,bool,string)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(uint256 p0, address p1, bool p2, bool p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,address,bool,bool)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(uint256 p0, address p1, bool p2, address p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,address,bool,address)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(uint256 p0, address p1, address p2, uint256 p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,address,address,uint256)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(uint256 p0, address p1, address p2, string memory p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,address,address,string)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(uint256 p0, address p1, address p2, bool p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,address,address,bool)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(uint256 p0, address p1, address p2, address p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,address,address,address)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(string memory p0, uint256 p1, uint256 p2, uint256 p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,uint256,uint256,uint256)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(string memory p0, uint256 p1, uint256 p2, string memory p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,uint256,uint256,string)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(string memory p0, uint256 p1, uint256 p2, bool p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,uint256,uint256,bool)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(string memory p0, uint256 p1, uint256 p2, address p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,uint256,uint256,address)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(string memory p0, uint256 p1, string memory p2, uint256 p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,uint256,string,uint256)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(string memory p0, uint256 p1, string memory p2, string memory p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,uint256,string,string)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(string memory p0, uint256 p1, string memory p2, bool p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,uint256,string,bool)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(string memory p0, uint256 p1, string memory p2, address p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,uint256,string,address)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(string memory p0, uint256 p1, bool p2, uint256 p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,uint256,bool,uint256)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(string memory p0, uint256 p1, bool p2, string memory p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,uint256,bool,string)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(string memory p0, uint256 p1, bool p2, bool p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,uint256,bool,bool)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(string memory p0, uint256 p1, bool p2, address p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,uint256,bool,address)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(string memory p0, uint256 p1, address p2, uint256 p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,uint256,address,uint256)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(string memory p0, uint256 p1, address p2, string memory p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,uint256,address,string)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(string memory p0, uint256 p1, address p2, bool p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,uint256,address,bool)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(string memory p0, uint256 p1, address p2, address p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,uint256,address,address)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(string memory p0, string memory p1, uint256 p2, uint256 p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,string,uint256,uint256)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(string memory p0, string memory p1, uint256 p2, string memory p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,string,uint256,string)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(string memory p0, string memory p1, uint256 p2, bool p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,string,uint256,bool)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(string memory p0, string memory p1, uint256 p2, address p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,string,uint256,address)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(string memory p0, string memory p1, string memory p2, uint256 p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,string,string,uint256)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(string memory p0, string memory p1, string memory p2, string memory p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,string,string,string)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(string memory p0, string memory p1, string memory p2, bool p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,string,string,bool)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(string memory p0, string memory p1, string memory p2, address p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,string,string,address)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(string memory p0, string memory p1, bool p2, uint256 p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,string,bool,uint256)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(string memory p0, string memory p1, bool p2, string memory p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,string,bool,string)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(string memory p0, string memory p1, bool p2, bool p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,string,bool,bool)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(string memory p0, string memory p1, bool p2, address p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,string,bool,address)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(string memory p0, string memory p1, address p2, uint256 p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,string,address,uint256)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(string memory p0, string memory p1, address p2, string memory p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,string,address,string)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(string memory p0, string memory p1, address p2, bool p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,string,address,bool)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(string memory p0, string memory p1, address p2, address p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,string,address,address)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(string memory p0, bool p1, uint256 p2, uint256 p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,bool,uint256,uint256)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(string memory p0, bool p1, uint256 p2, string memory p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,bool,uint256,string)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(string memory p0, bool p1, uint256 p2, bool p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,bool,uint256,bool)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(string memory p0, bool p1, uint256 p2, address p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,bool,uint256,address)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(string memory p0, bool p1, string memory p2, uint256 p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,bool,string,uint256)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(string memory p0, bool p1, string memory p2, string memory p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,bool,string,string)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(string memory p0, bool p1, string memory p2, bool p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,bool,string,bool)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(string memory p0, bool p1, string memory p2, address p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,bool,string,address)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(string memory p0, bool p1, bool p2, uint256 p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,bool,bool,uint256)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(string memory p0, bool p1, bool p2, string memory p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,bool,bool,string)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(string memory p0, bool p1, bool p2, bool p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,bool,bool,bool)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(string memory p0, bool p1, bool p2, address p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,bool,bool,address)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(string memory p0, bool p1, address p2, uint256 p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,bool,address,uint256)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(string memory p0, bool p1, address p2, string memory p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,bool,address,string)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(string memory p0, bool p1, address p2, bool p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,bool,address,bool)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(string memory p0, bool p1, address p2, address p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,bool,address,address)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(string memory p0, address p1, uint256 p2, uint256 p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,address,uint256,uint256)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(string memory p0, address p1, uint256 p2, string memory p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,address,uint256,string)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(string memory p0, address p1, uint256 p2, bool p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,address,uint256,bool)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(string memory p0, address p1, uint256 p2, address p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,address,uint256,address)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(string memory p0, address p1, string memory p2, uint256 p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,address,string,uint256)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(string memory p0, address p1, string memory p2, string memory p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,address,string,string)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(string memory p0, address p1, string memory p2, bool p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,address,string,bool)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(string memory p0, address p1, string memory p2, address p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,address,string,address)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(string memory p0, address p1, bool p2, uint256 p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,address,bool,uint256)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(string memory p0, address p1, bool p2, string memory p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,address,bool,string)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(string memory p0, address p1, bool p2, bool p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,address,bool,bool)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(string memory p0, address p1, bool p2, address p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,address,bool,address)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(string memory p0, address p1, address p2, uint256 p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,address,address,uint256)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(string memory p0, address p1, address p2, string memory p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,address,address,string)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(string memory p0, address p1, address p2, bool p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,address,address,bool)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(string memory p0, address p1, address p2, address p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,address,address,address)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(bool p0, uint256 p1, uint256 p2, uint256 p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,uint256,uint256,uint256)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(bool p0, uint256 p1, uint256 p2, string memory p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,uint256,uint256,string)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(bool p0, uint256 p1, uint256 p2, bool p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,uint256,uint256,bool)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(bool p0, uint256 p1, uint256 p2, address p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,uint256,uint256,address)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(bool p0, uint256 p1, string memory p2, uint256 p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,uint256,string,uint256)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(bool p0, uint256 p1, string memory p2, string memory p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,uint256,string,string)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(bool p0, uint256 p1, string memory p2, bool p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,uint256,string,bool)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(bool p0, uint256 p1, string memory p2, address p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,uint256,string,address)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(bool p0, uint256 p1, bool p2, uint256 p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,uint256,bool,uint256)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(bool p0, uint256 p1, bool p2, string memory p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,uint256,bool,string)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(bool p0, uint256 p1, bool p2, bool p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,uint256,bool,bool)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(bool p0, uint256 p1, bool p2, address p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,uint256,bool,address)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(bool p0, uint256 p1, address p2, uint256 p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,uint256,address,uint256)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(bool p0, uint256 p1, address p2, string memory p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,uint256,address,string)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(bool p0, uint256 p1, address p2, bool p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,uint256,address,bool)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(bool p0, uint256 p1, address p2, address p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,uint256,address,address)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(bool p0, string memory p1, uint256 p2, uint256 p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,string,uint256,uint256)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(bool p0, string memory p1, uint256 p2, string memory p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,string,uint256,string)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(bool p0, string memory p1, uint256 p2, bool p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,string,uint256,bool)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(bool p0, string memory p1, uint256 p2, address p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,string,uint256,address)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(bool p0, string memory p1, string memory p2, uint256 p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,string,string,uint256)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(bool p0, string memory p1, string memory p2, string memory p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,string,string,string)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(bool p0, string memory p1, string memory p2, bool p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,string,string,bool)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(bool p0, string memory p1, string memory p2, address p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,string,string,address)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(bool p0, string memory p1, bool p2, uint256 p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,string,bool,uint256)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(bool p0, string memory p1, bool p2, string memory p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,string,bool,string)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(bool p0, string memory p1, bool p2, bool p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,string,bool,bool)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(bool p0, string memory p1, bool p2, address p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,string,bool,address)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(bool p0, string memory p1, address p2, uint256 p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,string,address,uint256)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(bool p0, string memory p1, address p2, string memory p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,string,address,string)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(bool p0, string memory p1, address p2, bool p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,string,address,bool)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(bool p0, string memory p1, address p2, address p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,string,address,address)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(bool p0, bool p1, uint256 p2, uint256 p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,bool,uint256,uint256)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(bool p0, bool p1, uint256 p2, string memory p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,bool,uint256,string)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(bool p0, bool p1, uint256 p2, bool p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,bool,uint256,bool)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(bool p0, bool p1, uint256 p2, address p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,bool,uint256,address)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(bool p0, bool p1, string memory p2, uint256 p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,bool,string,uint256)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(bool p0, bool p1, string memory p2, string memory p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,bool,string,string)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(bool p0, bool p1, string memory p2, bool p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,bool,string,bool)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(bool p0, bool p1, string memory p2, address p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,bool,string,address)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(bool p0, bool p1, bool p2, uint256 p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,bool,bool,uint256)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(bool p0, bool p1, bool p2, string memory p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,bool,bool,string)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(bool p0, bool p1, bool p2, bool p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,bool,bool,bool)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(bool p0, bool p1, bool p2, address p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,bool,bool,address)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(bool p0, bool p1, address p2, uint256 p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,bool,address,uint256)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(bool p0, bool p1, address p2, string memory p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,bool,address,string)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(bool p0, bool p1, address p2, bool p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,bool,address,bool)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(bool p0, bool p1, address p2, address p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,bool,address,address)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(bool p0, address p1, uint256 p2, uint256 p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,address,uint256,uint256)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(bool p0, address p1, uint256 p2, string memory p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,address,uint256,string)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(bool p0, address p1, uint256 p2, bool p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,address,uint256,bool)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(bool p0, address p1, uint256 p2, address p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,address,uint256,address)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(bool p0, address p1, string memory p2, uint256 p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,address,string,uint256)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(bool p0, address p1, string memory p2, string memory p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,address,string,string)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(bool p0, address p1, string memory p2, bool p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,address,string,bool)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(bool p0, address p1, string memory p2, address p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,address,string,address)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(bool p0, address p1, bool p2, uint256 p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,address,bool,uint256)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(bool p0, address p1, bool p2, string memory p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,address,bool,string)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(bool p0, address p1, bool p2, bool p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,address,bool,bool)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(bool p0, address p1, bool p2, address p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,address,bool,address)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(bool p0, address p1, address p2, uint256 p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,address,address,uint256)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(bool p0, address p1, address p2, string memory p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,address,address,string)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(bool p0, address p1, address p2, bool p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,address,address,bool)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(bool p0, address p1, address p2, address p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,address,address,address)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(address p0, uint256 p1, uint256 p2, uint256 p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,uint256,uint256,uint256)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(address p0, uint256 p1, uint256 p2, string memory p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,uint256,uint256,string)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(address p0, uint256 p1, uint256 p2, bool p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,uint256,uint256,bool)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(address p0, uint256 p1, uint256 p2, address p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,uint256,uint256,address)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(address p0, uint256 p1, string memory p2, uint256 p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,uint256,string,uint256)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(address p0, uint256 p1, string memory p2, string memory p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,uint256,string,string)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(address p0, uint256 p1, string memory p2, bool p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,uint256,string,bool)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(address p0, uint256 p1, string memory p2, address p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,uint256,string,address)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(address p0, uint256 p1, bool p2, uint256 p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,uint256,bool,uint256)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(address p0, uint256 p1, bool p2, string memory p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,uint256,bool,string)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(address p0, uint256 p1, bool p2, bool p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,uint256,bool,bool)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(address p0, uint256 p1, bool p2, address p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,uint256,bool,address)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(address p0, uint256 p1, address p2, uint256 p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,uint256,address,uint256)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(address p0, uint256 p1, address p2, string memory p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,uint256,address,string)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(address p0, uint256 p1, address p2, bool p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,uint256,address,bool)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(address p0, uint256 p1, address p2, address p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,uint256,address,address)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(address p0, string memory p1, uint256 p2, uint256 p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,string,uint256,uint256)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(address p0, string memory p1, uint256 p2, string memory p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,string,uint256,string)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(address p0, string memory p1, uint256 p2, bool p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,string,uint256,bool)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(address p0, string memory p1, uint256 p2, address p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,string,uint256,address)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(address p0, string memory p1, string memory p2, uint256 p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,string,string,uint256)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(address p0, string memory p1, string memory p2, string memory p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,string,string,string)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(address p0, string memory p1, string memory p2, bool p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,string,string,bool)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(address p0, string memory p1, string memory p2, address p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,string,string,address)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(address p0, string memory p1, bool p2, uint256 p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,string,bool,uint256)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(address p0, string memory p1, bool p2, string memory p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,string,bool,string)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(address p0, string memory p1, bool p2, bool p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,string,bool,bool)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(address p0, string memory p1, bool p2, address p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,string,bool,address)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(address p0, string memory p1, address p2, uint256 p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,string,address,uint256)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(address p0, string memory p1, address p2, string memory p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,string,address,string)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(address p0, string memory p1, address p2, bool p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,string,address,bool)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(address p0, string memory p1, address p2, address p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,string,address,address)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(address p0, bool p1, uint256 p2, uint256 p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,bool,uint256,uint256)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(address p0, bool p1, uint256 p2, string memory p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,bool,uint256,string)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(address p0, bool p1, uint256 p2, bool p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,bool,uint256,bool)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(address p0, bool p1, uint256 p2, address p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,bool,uint256,address)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(address p0, bool p1, string memory p2, uint256 p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,bool,string,uint256)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(address p0, bool p1, string memory p2, string memory p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,bool,string,string)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(address p0, bool p1, string memory p2, bool p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,bool,string,bool)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(address p0, bool p1, string memory p2, address p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,bool,string,address)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(address p0, bool p1, bool p2, uint256 p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,bool,bool,uint256)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(address p0, bool p1, bool p2, string memory p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,bool,bool,string)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(address p0, bool p1, bool p2, bool p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,bool,bool,bool)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(address p0, bool p1, bool p2, address p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,bool,bool,address)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(address p0, bool p1, address p2, uint256 p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,bool,address,uint256)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(address p0, bool p1, address p2, string memory p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,bool,address,string)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(address p0, bool p1, address p2, bool p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,bool,address,bool)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(address p0, bool p1, address p2, address p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,bool,address,address)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(address p0, address p1, uint256 p2, uint256 p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,address,uint256,uint256)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(address p0, address p1, uint256 p2, string memory p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,address,uint256,string)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(address p0, address p1, uint256 p2, bool p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,address,uint256,bool)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(address p0, address p1, uint256 p2, address p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,address,uint256,address)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(address p0, address p1, string memory p2, uint256 p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,address,string,uint256)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(address p0, address p1, string memory p2, string memory p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,address,string,string)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(address p0, address p1, string memory p2, bool p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,address,string,bool)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(address p0, address p1, string memory p2, address p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,address,string,address)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(address p0, address p1, bool p2, uint256 p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,address,bool,uint256)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(address p0, address p1, bool p2, string memory p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,address,bool,string)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(address p0, address p1, bool p2, bool p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,address,bool,bool)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(address p0, address p1, bool p2, address p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,address,bool,address)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(address p0, address p1, address p2, uint256 p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,address,address,uint256)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(address p0, address p1, address p2, string memory p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,address,address,string)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(address p0, address p1, address p2, bool p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,address,address,bool)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(address p0, address p1, address p2, address p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,address,address,address)\\\", p0, p1, p2, p3));\\n }\\n}\\n\",\"keccak256\":\"0x4bbf47eb762cef93729d6ef15e78789957147039b113e5d4df48e3d3fd16d0f5\",\"license\":\"MIT\"},\"lib/forge-std/src/console2.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity >=0.4.22 <0.9.0;\\n\\nimport {console as console2} from \\\"./console.sol\\\";\\n\",\"keccak256\":\"0x3b8fe79f48f065a4e4d35362171304a33784c3a90febae5f2787805a438de12f\",\"license\":\"MIT\"},\"lib/forge-std/src/interfaces/IMulticall3.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity >=0.6.2 <0.9.0;\\n\\npragma experimental ABIEncoderV2;\\n\\ninterface IMulticall3 {\\n struct Call {\\n address target;\\n bytes callData;\\n }\\n\\n struct Call3 {\\n address target;\\n bool allowFailure;\\n bytes callData;\\n }\\n\\n struct Call3Value {\\n address target;\\n bool allowFailure;\\n uint256 value;\\n bytes callData;\\n }\\n\\n struct Result {\\n bool success;\\n bytes returnData;\\n }\\n\\n function aggregate(Call[] calldata calls)\\n external\\n payable\\n returns (uint256 blockNumber, bytes[] memory returnData);\\n\\n function aggregate3(Call3[] calldata calls) external payable returns (Result[] memory returnData);\\n\\n function aggregate3Value(Call3Value[] calldata calls) external payable returns (Result[] memory returnData);\\n\\n function blockAndAggregate(Call[] calldata calls)\\n external\\n payable\\n returns (uint256 blockNumber, bytes32 blockHash, Result[] memory returnData);\\n\\n function getBasefee() external view returns (uint256 basefee);\\n\\n function getBlockHash(uint256 blockNumber) external view returns (bytes32 blockHash);\\n\\n function getBlockNumber() external view returns (uint256 blockNumber);\\n\\n function getChainId() external view returns (uint256 chainid);\\n\\n function getCurrentBlockCoinbase() external view returns (address coinbase);\\n\\n function getCurrentBlockDifficulty() external view returns (uint256 difficulty);\\n\\n function getCurrentBlockGasLimit() external view returns (uint256 gaslimit);\\n\\n function getCurrentBlockTimestamp() external view returns (uint256 timestamp);\\n\\n function getEthBalance(address addr) external view returns (uint256 balance);\\n\\n function getLastBlockHash() external view returns (bytes32 blockHash);\\n\\n function tryAggregate(bool requireSuccess, Call[] calldata calls)\\n external\\n payable\\n returns (Result[] memory returnData);\\n\\n function tryBlockAndAggregate(bool requireSuccess, Call[] calldata calls)\\n external\\n payable\\n returns (uint256 blockNumber, bytes32 blockHash, Result[] memory returnData);\\n}\\n\",\"keccak256\":\"0x7aac1389150499a922d1f9ef5749c908cef127cb2075b92fa17e9cb611263d0a\",\"license\":\"MIT\"},\"lib/forge-std/src/safeconsole.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity >=0.6.2 <0.9.0;\\n\\n/// @author philogy \\n/// @dev Code generated automatically by script.\\nlibrary safeconsole {\\n uint256 constant CONSOLE_ADDR = 0x000000000000000000000000000000000000000000636F6e736F6c652e6c6f67;\\n\\n // Credit to [0age](https://twitter.com/z0age/status/1654922202930888704) and [0xdapper](https://github.com/foundry-rs/forge-std/pull/374)\\n // for the view-to-pure log trick.\\n function _sendLogPayload(uint256 offset, uint256 size) private pure {\\n function(uint256, uint256) internal view fnIn = _sendLogPayloadView;\\n function(uint256, uint256) internal pure pureSendLogPayload;\\n /// @solidity memory-safe-assembly\\n assembly {\\n pureSendLogPayload := fnIn\\n }\\n pureSendLogPayload(offset, size);\\n }\\n\\n function _sendLogPayloadView(uint256 offset, uint256 size) private view {\\n /// @solidity memory-safe-assembly\\n assembly {\\n pop(staticcall(gas(), CONSOLE_ADDR, offset, size, 0x0, 0x0))\\n }\\n }\\n\\n function _memcopy(uint256 fromOffset, uint256 toOffset, uint256 length) private pure {\\n function(uint256, uint256, uint256) internal view fnIn = _memcopyView;\\n function(uint256, uint256, uint256) internal pure pureMemcopy;\\n /// @solidity memory-safe-assembly\\n assembly {\\n pureMemcopy := fnIn\\n }\\n pureMemcopy(fromOffset, toOffset, length);\\n }\\n\\n function _memcopyView(uint256 fromOffset, uint256 toOffset, uint256 length) private view {\\n /// @solidity memory-safe-assembly\\n assembly {\\n pop(staticcall(gas(), 0x4, fromOffset, length, toOffset, length))\\n }\\n }\\n\\n function logMemory(uint256 offset, uint256 length) internal pure {\\n if (offset >= 0x60) {\\n // Sufficient memory before slice to prepare call header.\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(sub(offset, 0x60))\\n m1 := mload(sub(offset, 0x40))\\n m2 := mload(sub(offset, 0x20))\\n // Selector of `log(bytes)`.\\n mstore(sub(offset, 0x60), 0x0be77f56)\\n mstore(sub(offset, 0x40), 0x20)\\n mstore(sub(offset, 0x20), length)\\n }\\n _sendLogPayload(offset - 0x44, length + 0x44);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(sub(offset, 0x60), m0)\\n mstore(sub(offset, 0x40), m1)\\n mstore(sub(offset, 0x20), m2)\\n }\\n } else {\\n // Insufficient space, so copy slice forward, add header and reverse.\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n uint256 endOffset = offset + length;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(add(endOffset, 0x00))\\n m1 := mload(add(endOffset, 0x20))\\n m2 := mload(add(endOffset, 0x40))\\n }\\n _memcopy(offset, offset + 0x60, length);\\n /// @solidity memory-safe-assembly\\n assembly {\\n // Selector of `log(bytes)`.\\n mstore(add(offset, 0x00), 0x0be77f56)\\n mstore(add(offset, 0x20), 0x20)\\n mstore(add(offset, 0x40), length)\\n }\\n _sendLogPayload(offset + 0x1c, length + 0x44);\\n _memcopy(offset + 0x60, offset, length);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(add(endOffset, 0x00), m0)\\n mstore(add(endOffset, 0x20), m1)\\n mstore(add(endOffset, 0x40), m2)\\n }\\n }\\n }\\n\\n function log(address p0) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n // Selector of `log(address)`.\\n mstore(0x00, 0x2c2ecbc2)\\n mstore(0x20, p0)\\n }\\n _sendLogPayload(0x1c, 0x24);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n }\\n }\\n\\n function log(bool p0) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n // Selector of `log(bool)`.\\n mstore(0x00, 0x32458eed)\\n mstore(0x20, p0)\\n }\\n _sendLogPayload(0x1c, 0x24);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n }\\n }\\n\\n function log(uint256 p0) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n // Selector of `log(uint256)`.\\n mstore(0x00, 0xf82c50f1)\\n mstore(0x20, p0)\\n }\\n _sendLogPayload(0x1c, 0x24);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n }\\n }\\n\\n function log(bytes32 p0) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n // Selector of `log(string)`.\\n mstore(0x00, 0x41304fac)\\n mstore(0x20, 0x20)\\n writeString(0x40, p0)\\n }\\n _sendLogPayload(0x1c, 0x64);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n }\\n }\\n\\n function log(address p0, address p1) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n // Selector of `log(address,address)`.\\n mstore(0x00, 0xdaf0d4aa)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n }\\n _sendLogPayload(0x1c, 0x44);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n }\\n }\\n\\n function log(address p0, bool p1) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n // Selector of `log(address,bool)`.\\n mstore(0x00, 0x75b605d3)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n }\\n _sendLogPayload(0x1c, 0x44);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n }\\n }\\n\\n function log(address p0, uint256 p1) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n // Selector of `log(address,uint256)`.\\n mstore(0x00, 0x8309e8a8)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n }\\n _sendLogPayload(0x1c, 0x44);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n }\\n }\\n\\n function log(address p0, bytes32 p1) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(address,string)`.\\n mstore(0x00, 0x759f86bb)\\n mstore(0x20, p0)\\n mstore(0x40, 0x40)\\n writeString(0x60, p1)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(bool p0, address p1) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n // Selector of `log(bool,address)`.\\n mstore(0x00, 0x853c4849)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n }\\n _sendLogPayload(0x1c, 0x44);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n }\\n }\\n\\n function log(bool p0, bool p1) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n // Selector of `log(bool,bool)`.\\n mstore(0x00, 0x2a110e83)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n }\\n _sendLogPayload(0x1c, 0x44);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n }\\n }\\n\\n function log(bool p0, uint256 p1) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n // Selector of `log(bool,uint256)`.\\n mstore(0x00, 0x399174d3)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n }\\n _sendLogPayload(0x1c, 0x44);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n }\\n }\\n\\n function log(bool p0, bytes32 p1) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(bool,string)`.\\n mstore(0x00, 0x8feac525)\\n mstore(0x20, p0)\\n mstore(0x40, 0x40)\\n writeString(0x60, p1)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(uint256 p0, address p1) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n // Selector of `log(uint256,address)`.\\n mstore(0x00, 0x69276c86)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n }\\n _sendLogPayload(0x1c, 0x44);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n }\\n }\\n\\n function log(uint256 p0, bool p1) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n // Selector of `log(uint256,bool)`.\\n mstore(0x00, 0x1c9d7eb3)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n }\\n _sendLogPayload(0x1c, 0x44);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n }\\n }\\n\\n function log(uint256 p0, uint256 p1) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n // Selector of `log(uint256,uint256)`.\\n mstore(0x00, 0xf666715a)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n }\\n _sendLogPayload(0x1c, 0x44);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n }\\n }\\n\\n function log(uint256 p0, bytes32 p1) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(uint256,string)`.\\n mstore(0x00, 0x643fd0df)\\n mstore(0x20, p0)\\n mstore(0x40, 0x40)\\n writeString(0x60, p1)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(bytes32 p0, address p1) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(string,address)`.\\n mstore(0x00, 0x319af333)\\n mstore(0x20, 0x40)\\n mstore(0x40, p1)\\n writeString(0x60, p0)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(bytes32 p0, bool p1) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(string,bool)`.\\n mstore(0x00, 0xc3b55635)\\n mstore(0x20, 0x40)\\n mstore(0x40, p1)\\n writeString(0x60, p0)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(bytes32 p0, uint256 p1) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(string,uint256)`.\\n mstore(0x00, 0xb60e72cc)\\n mstore(0x20, 0x40)\\n mstore(0x40, p1)\\n writeString(0x60, p0)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(bytes32 p0, bytes32 p1) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(string,string)`.\\n mstore(0x00, 0x4b5c4277)\\n mstore(0x20, 0x40)\\n mstore(0x40, 0x80)\\n writeString(0x60, p0)\\n writeString(0xa0, p1)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(address p0, address p1, address p2) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n // Selector of `log(address,address,address)`.\\n mstore(0x00, 0x018c84c2)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n }\\n _sendLogPayload(0x1c, 0x64);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n }\\n }\\n\\n function log(address p0, address p1, bool p2) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n // Selector of `log(address,address,bool)`.\\n mstore(0x00, 0xf2a66286)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n }\\n _sendLogPayload(0x1c, 0x64);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n }\\n }\\n\\n function log(address p0, address p1, uint256 p2) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n // Selector of `log(address,address,uint256)`.\\n mstore(0x00, 0x17fe6185)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n }\\n _sendLogPayload(0x1c, 0x64);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n }\\n }\\n\\n function log(address p0, address p1, bytes32 p2) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n // Selector of `log(address,address,string)`.\\n mstore(0x00, 0x007150be)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, 0x60)\\n writeString(0x80, p2)\\n }\\n _sendLogPayload(0x1c, 0xa4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n }\\n }\\n\\n function log(address p0, bool p1, address p2) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n // Selector of `log(address,bool,address)`.\\n mstore(0x00, 0xf11699ed)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n }\\n _sendLogPayload(0x1c, 0x64);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n }\\n }\\n\\n function log(address p0, bool p1, bool p2) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n // Selector of `log(address,bool,bool)`.\\n mstore(0x00, 0xeb830c92)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n }\\n _sendLogPayload(0x1c, 0x64);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n }\\n }\\n\\n function log(address p0, bool p1, uint256 p2) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n // Selector of `log(address,bool,uint256)`.\\n mstore(0x00, 0x9c4f99fb)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n }\\n _sendLogPayload(0x1c, 0x64);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n }\\n }\\n\\n function log(address p0, bool p1, bytes32 p2) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n // Selector of `log(address,bool,string)`.\\n mstore(0x00, 0x212255cc)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, 0x60)\\n writeString(0x80, p2)\\n }\\n _sendLogPayload(0x1c, 0xa4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n }\\n }\\n\\n function log(address p0, uint256 p1, address p2) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n // Selector of `log(address,uint256,address)`.\\n mstore(0x00, 0x7bc0d848)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n }\\n _sendLogPayload(0x1c, 0x64);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n }\\n }\\n\\n function log(address p0, uint256 p1, bool p2) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n // Selector of `log(address,uint256,bool)`.\\n mstore(0x00, 0x678209a8)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n }\\n _sendLogPayload(0x1c, 0x64);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n }\\n }\\n\\n function log(address p0, uint256 p1, uint256 p2) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n // Selector of `log(address,uint256,uint256)`.\\n mstore(0x00, 0xb69bcaf6)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n }\\n _sendLogPayload(0x1c, 0x64);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n }\\n }\\n\\n function log(address p0, uint256 p1, bytes32 p2) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n // Selector of `log(address,uint256,string)`.\\n mstore(0x00, 0xa1f2e8aa)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, 0x60)\\n writeString(0x80, p2)\\n }\\n _sendLogPayload(0x1c, 0xa4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n }\\n }\\n\\n function log(address p0, bytes32 p1, address p2) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n // Selector of `log(address,string,address)`.\\n mstore(0x00, 0xf08744e8)\\n mstore(0x20, p0)\\n mstore(0x40, 0x60)\\n mstore(0x60, p2)\\n writeString(0x80, p1)\\n }\\n _sendLogPayload(0x1c, 0xa4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n }\\n }\\n\\n function log(address p0, bytes32 p1, bool p2) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n // Selector of `log(address,string,bool)`.\\n mstore(0x00, 0xcf020fb1)\\n mstore(0x20, p0)\\n mstore(0x40, 0x60)\\n mstore(0x60, p2)\\n writeString(0x80, p1)\\n }\\n _sendLogPayload(0x1c, 0xa4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n }\\n }\\n\\n function log(address p0, bytes32 p1, uint256 p2) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n // Selector of `log(address,string,uint256)`.\\n mstore(0x00, 0x67dd6ff1)\\n mstore(0x20, p0)\\n mstore(0x40, 0x60)\\n mstore(0x60, p2)\\n writeString(0x80, p1)\\n }\\n _sendLogPayload(0x1c, 0xa4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n }\\n }\\n\\n function log(address p0, bytes32 p1, bytes32 p2) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n // Selector of `log(address,string,string)`.\\n mstore(0x00, 0xfb772265)\\n mstore(0x20, p0)\\n mstore(0x40, 0x60)\\n mstore(0x60, 0xa0)\\n writeString(0x80, p1)\\n writeString(0xc0, p2)\\n }\\n _sendLogPayload(0x1c, 0xe4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n }\\n }\\n\\n function log(bool p0, address p1, address p2) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n // Selector of `log(bool,address,address)`.\\n mstore(0x00, 0xd2763667)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n }\\n _sendLogPayload(0x1c, 0x64);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n }\\n }\\n\\n function log(bool p0, address p1, bool p2) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n // Selector of `log(bool,address,bool)`.\\n mstore(0x00, 0x18c9c746)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n }\\n _sendLogPayload(0x1c, 0x64);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n }\\n }\\n\\n function log(bool p0, address p1, uint256 p2) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n // Selector of `log(bool,address,uint256)`.\\n mstore(0x00, 0x5f7b9afb)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n }\\n _sendLogPayload(0x1c, 0x64);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n }\\n }\\n\\n function log(bool p0, address p1, bytes32 p2) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n // Selector of `log(bool,address,string)`.\\n mstore(0x00, 0xde9a9270)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, 0x60)\\n writeString(0x80, p2)\\n }\\n _sendLogPayload(0x1c, 0xa4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n }\\n }\\n\\n function log(bool p0, bool p1, address p2) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n // Selector of `log(bool,bool,address)`.\\n mstore(0x00, 0x1078f68d)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n }\\n _sendLogPayload(0x1c, 0x64);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n }\\n }\\n\\n function log(bool p0, bool p1, bool p2) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n // Selector of `log(bool,bool,bool)`.\\n mstore(0x00, 0x50709698)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n }\\n _sendLogPayload(0x1c, 0x64);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n }\\n }\\n\\n function log(bool p0, bool p1, uint256 p2) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n // Selector of `log(bool,bool,uint256)`.\\n mstore(0x00, 0x12f21602)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n }\\n _sendLogPayload(0x1c, 0x64);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n }\\n }\\n\\n function log(bool p0, bool p1, bytes32 p2) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n // Selector of `log(bool,bool,string)`.\\n mstore(0x00, 0x2555fa46)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, 0x60)\\n writeString(0x80, p2)\\n }\\n _sendLogPayload(0x1c, 0xa4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n }\\n }\\n\\n function log(bool p0, uint256 p1, address p2) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n // Selector of `log(bool,uint256,address)`.\\n mstore(0x00, 0x088ef9d2)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n }\\n _sendLogPayload(0x1c, 0x64);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n }\\n }\\n\\n function log(bool p0, uint256 p1, bool p2) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n // Selector of `log(bool,uint256,bool)`.\\n mstore(0x00, 0xe8defba9)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n }\\n _sendLogPayload(0x1c, 0x64);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n }\\n }\\n\\n function log(bool p0, uint256 p1, uint256 p2) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n // Selector of `log(bool,uint256,uint256)`.\\n mstore(0x00, 0x37103367)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n }\\n _sendLogPayload(0x1c, 0x64);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n }\\n }\\n\\n function log(bool p0, uint256 p1, bytes32 p2) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n // Selector of `log(bool,uint256,string)`.\\n mstore(0x00, 0xc3fc3970)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, 0x60)\\n writeString(0x80, p2)\\n }\\n _sendLogPayload(0x1c, 0xa4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n }\\n }\\n\\n function log(bool p0, bytes32 p1, address p2) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n // Selector of `log(bool,string,address)`.\\n mstore(0x00, 0x9591b953)\\n mstore(0x20, p0)\\n mstore(0x40, 0x60)\\n mstore(0x60, p2)\\n writeString(0x80, p1)\\n }\\n _sendLogPayload(0x1c, 0xa4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n }\\n }\\n\\n function log(bool p0, bytes32 p1, bool p2) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n // Selector of `log(bool,string,bool)`.\\n mstore(0x00, 0xdbb4c247)\\n mstore(0x20, p0)\\n mstore(0x40, 0x60)\\n mstore(0x60, p2)\\n writeString(0x80, p1)\\n }\\n _sendLogPayload(0x1c, 0xa4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n }\\n }\\n\\n function log(bool p0, bytes32 p1, uint256 p2) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n // Selector of `log(bool,string,uint256)`.\\n mstore(0x00, 0x1093ee11)\\n mstore(0x20, p0)\\n mstore(0x40, 0x60)\\n mstore(0x60, p2)\\n writeString(0x80, p1)\\n }\\n _sendLogPayload(0x1c, 0xa4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n }\\n }\\n\\n function log(bool p0, bytes32 p1, bytes32 p2) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n // Selector of `log(bool,string,string)`.\\n mstore(0x00, 0xb076847f)\\n mstore(0x20, p0)\\n mstore(0x40, 0x60)\\n mstore(0x60, 0xa0)\\n writeString(0x80, p1)\\n writeString(0xc0, p2)\\n }\\n _sendLogPayload(0x1c, 0xe4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n }\\n }\\n\\n function log(uint256 p0, address p1, address p2) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n // Selector of `log(uint256,address,address)`.\\n mstore(0x00, 0xbcfd9be0)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n }\\n _sendLogPayload(0x1c, 0x64);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n }\\n }\\n\\n function log(uint256 p0, address p1, bool p2) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n // Selector of `log(uint256,address,bool)`.\\n mstore(0x00, 0x9b6ec042)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n }\\n _sendLogPayload(0x1c, 0x64);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n }\\n }\\n\\n function log(uint256 p0, address p1, uint256 p2) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n // Selector of `log(uint256,address,uint256)`.\\n mstore(0x00, 0x5a9b5ed5)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n }\\n _sendLogPayload(0x1c, 0x64);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n }\\n }\\n\\n function log(uint256 p0, address p1, bytes32 p2) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n // Selector of `log(uint256,address,string)`.\\n mstore(0x00, 0x63cb41f9)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, 0x60)\\n writeString(0x80, p2)\\n }\\n _sendLogPayload(0x1c, 0xa4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n }\\n }\\n\\n function log(uint256 p0, bool p1, address p2) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n // Selector of `log(uint256,bool,address)`.\\n mstore(0x00, 0x35085f7b)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n }\\n _sendLogPayload(0x1c, 0x64);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n }\\n }\\n\\n function log(uint256 p0, bool p1, bool p2) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n // Selector of `log(uint256,bool,bool)`.\\n mstore(0x00, 0x20718650)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n }\\n _sendLogPayload(0x1c, 0x64);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n }\\n }\\n\\n function log(uint256 p0, bool p1, uint256 p2) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n // Selector of `log(uint256,bool,uint256)`.\\n mstore(0x00, 0x20098014)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n }\\n _sendLogPayload(0x1c, 0x64);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n }\\n }\\n\\n function log(uint256 p0, bool p1, bytes32 p2) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n // Selector of `log(uint256,bool,string)`.\\n mstore(0x00, 0x85775021)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, 0x60)\\n writeString(0x80, p2)\\n }\\n _sendLogPayload(0x1c, 0xa4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n }\\n }\\n\\n function log(uint256 p0, uint256 p1, address p2) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n // Selector of `log(uint256,uint256,address)`.\\n mstore(0x00, 0x5c96b331)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n }\\n _sendLogPayload(0x1c, 0x64);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n }\\n }\\n\\n function log(uint256 p0, uint256 p1, bool p2) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n // Selector of `log(uint256,uint256,bool)`.\\n mstore(0x00, 0x4766da72)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n }\\n _sendLogPayload(0x1c, 0x64);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n }\\n }\\n\\n function log(uint256 p0, uint256 p1, uint256 p2) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n // Selector of `log(uint256,uint256,uint256)`.\\n mstore(0x00, 0xd1ed7a3c)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n }\\n _sendLogPayload(0x1c, 0x64);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n }\\n }\\n\\n function log(uint256 p0, uint256 p1, bytes32 p2) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n // Selector of `log(uint256,uint256,string)`.\\n mstore(0x00, 0x71d04af2)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, 0x60)\\n writeString(0x80, p2)\\n }\\n _sendLogPayload(0x1c, 0xa4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n }\\n }\\n\\n function log(uint256 p0, bytes32 p1, address p2) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n // Selector of `log(uint256,string,address)`.\\n mstore(0x00, 0x7afac959)\\n mstore(0x20, p0)\\n mstore(0x40, 0x60)\\n mstore(0x60, p2)\\n writeString(0x80, p1)\\n }\\n _sendLogPayload(0x1c, 0xa4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n }\\n }\\n\\n function log(uint256 p0, bytes32 p1, bool p2) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n // Selector of `log(uint256,string,bool)`.\\n mstore(0x00, 0x4ceda75a)\\n mstore(0x20, p0)\\n mstore(0x40, 0x60)\\n mstore(0x60, p2)\\n writeString(0x80, p1)\\n }\\n _sendLogPayload(0x1c, 0xa4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n }\\n }\\n\\n function log(uint256 p0, bytes32 p1, uint256 p2) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n // Selector of `log(uint256,string,uint256)`.\\n mstore(0x00, 0x37aa7d4c)\\n mstore(0x20, p0)\\n mstore(0x40, 0x60)\\n mstore(0x60, p2)\\n writeString(0x80, p1)\\n }\\n _sendLogPayload(0x1c, 0xa4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n }\\n }\\n\\n function log(uint256 p0, bytes32 p1, bytes32 p2) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n // Selector of `log(uint256,string,string)`.\\n mstore(0x00, 0xb115611f)\\n mstore(0x20, p0)\\n mstore(0x40, 0x60)\\n mstore(0x60, 0xa0)\\n writeString(0x80, p1)\\n writeString(0xc0, p2)\\n }\\n _sendLogPayload(0x1c, 0xe4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n }\\n }\\n\\n function log(bytes32 p0, address p1, address p2) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n // Selector of `log(string,address,address)`.\\n mstore(0x00, 0xfcec75e0)\\n mstore(0x20, 0x60)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n writeString(0x80, p0)\\n }\\n _sendLogPayload(0x1c, 0xa4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n }\\n }\\n\\n function log(bytes32 p0, address p1, bool p2) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n // Selector of `log(string,address,bool)`.\\n mstore(0x00, 0xc91d5ed4)\\n mstore(0x20, 0x60)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n writeString(0x80, p0)\\n }\\n _sendLogPayload(0x1c, 0xa4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n }\\n }\\n\\n function log(bytes32 p0, address p1, uint256 p2) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n // Selector of `log(string,address,uint256)`.\\n mstore(0x00, 0x0d26b925)\\n mstore(0x20, 0x60)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n writeString(0x80, p0)\\n }\\n _sendLogPayload(0x1c, 0xa4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n }\\n }\\n\\n function log(bytes32 p0, address p1, bytes32 p2) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n // Selector of `log(string,address,string)`.\\n mstore(0x00, 0xe0e9ad4f)\\n mstore(0x20, 0x60)\\n mstore(0x40, p1)\\n mstore(0x60, 0xa0)\\n writeString(0x80, p0)\\n writeString(0xc0, p2)\\n }\\n _sendLogPayload(0x1c, 0xe4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n }\\n }\\n\\n function log(bytes32 p0, bool p1, address p2) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n // Selector of `log(string,bool,address)`.\\n mstore(0x00, 0x932bbb38)\\n mstore(0x20, 0x60)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n writeString(0x80, p0)\\n }\\n _sendLogPayload(0x1c, 0xa4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n }\\n }\\n\\n function log(bytes32 p0, bool p1, bool p2) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n // Selector of `log(string,bool,bool)`.\\n mstore(0x00, 0x850b7ad6)\\n mstore(0x20, 0x60)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n writeString(0x80, p0)\\n }\\n _sendLogPayload(0x1c, 0xa4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n }\\n }\\n\\n function log(bytes32 p0, bool p1, uint256 p2) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n // Selector of `log(string,bool,uint256)`.\\n mstore(0x00, 0xc95958d6)\\n mstore(0x20, 0x60)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n writeString(0x80, p0)\\n }\\n _sendLogPayload(0x1c, 0xa4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n }\\n }\\n\\n function log(bytes32 p0, bool p1, bytes32 p2) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n // Selector of `log(string,bool,string)`.\\n mstore(0x00, 0xe298f47d)\\n mstore(0x20, 0x60)\\n mstore(0x40, p1)\\n mstore(0x60, 0xa0)\\n writeString(0x80, p0)\\n writeString(0xc0, p2)\\n }\\n _sendLogPayload(0x1c, 0xe4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n }\\n }\\n\\n function log(bytes32 p0, uint256 p1, address p2) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n // Selector of `log(string,uint256,address)`.\\n mstore(0x00, 0x1c7ec448)\\n mstore(0x20, 0x60)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n writeString(0x80, p0)\\n }\\n _sendLogPayload(0x1c, 0xa4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n }\\n }\\n\\n function log(bytes32 p0, uint256 p1, bool p2) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n // Selector of `log(string,uint256,bool)`.\\n mstore(0x00, 0xca7733b1)\\n mstore(0x20, 0x60)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n writeString(0x80, p0)\\n }\\n _sendLogPayload(0x1c, 0xa4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n }\\n }\\n\\n function log(bytes32 p0, uint256 p1, uint256 p2) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n // Selector of `log(string,uint256,uint256)`.\\n mstore(0x00, 0xca47c4eb)\\n mstore(0x20, 0x60)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n writeString(0x80, p0)\\n }\\n _sendLogPayload(0x1c, 0xa4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n }\\n }\\n\\n function log(bytes32 p0, uint256 p1, bytes32 p2) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n // Selector of `log(string,uint256,string)`.\\n mstore(0x00, 0x5970e089)\\n mstore(0x20, 0x60)\\n mstore(0x40, p1)\\n mstore(0x60, 0xa0)\\n writeString(0x80, p0)\\n writeString(0xc0, p2)\\n }\\n _sendLogPayload(0x1c, 0xe4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n }\\n }\\n\\n function log(bytes32 p0, bytes32 p1, address p2) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n // Selector of `log(string,string,address)`.\\n mstore(0x00, 0x95ed0195)\\n mstore(0x20, 0x60)\\n mstore(0x40, 0xa0)\\n mstore(0x60, p2)\\n writeString(0x80, p0)\\n writeString(0xc0, p1)\\n }\\n _sendLogPayload(0x1c, 0xe4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n }\\n }\\n\\n function log(bytes32 p0, bytes32 p1, bool p2) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n // Selector of `log(string,string,bool)`.\\n mstore(0x00, 0xb0e0f9b5)\\n mstore(0x20, 0x60)\\n mstore(0x40, 0xa0)\\n mstore(0x60, p2)\\n writeString(0x80, p0)\\n writeString(0xc0, p1)\\n }\\n _sendLogPayload(0x1c, 0xe4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n }\\n }\\n\\n function log(bytes32 p0, bytes32 p1, uint256 p2) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n // Selector of `log(string,string,uint256)`.\\n mstore(0x00, 0x5821efa1)\\n mstore(0x20, 0x60)\\n mstore(0x40, 0xa0)\\n mstore(0x60, p2)\\n writeString(0x80, p0)\\n writeString(0xc0, p1)\\n }\\n _sendLogPayload(0x1c, 0xe4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n }\\n }\\n\\n function log(bytes32 p0, bytes32 p1, bytes32 p2) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n bytes32 m9;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n m9 := mload(0x120)\\n // Selector of `log(string,string,string)`.\\n mstore(0x00, 0x2ced7cef)\\n mstore(0x20, 0x60)\\n mstore(0x40, 0xa0)\\n mstore(0x60, 0xe0)\\n writeString(0x80, p0)\\n writeString(0xc0, p1)\\n writeString(0x100, p2)\\n }\\n _sendLogPayload(0x1c, 0x124);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n mstore(0x120, m9)\\n }\\n }\\n\\n function log(address p0, address p1, address p2, address p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(address,address,address,address)`.\\n mstore(0x00, 0x665bf134)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(address p0, address p1, address p2, bool p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(address,address,address,bool)`.\\n mstore(0x00, 0x0e378994)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(address p0, address p1, address p2, uint256 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(address,address,address,uint256)`.\\n mstore(0x00, 0x94250d77)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(address p0, address p1, address p2, bytes32 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(address,address,address,string)`.\\n mstore(0x00, 0xf808da20)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, 0x80)\\n writeString(0xa0, p3)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(address p0, address p1, bool p2, address p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(address,address,bool,address)`.\\n mstore(0x00, 0x9f1bc36e)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(address p0, address p1, bool p2, bool p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(address,address,bool,bool)`.\\n mstore(0x00, 0x2cd4134a)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(address p0, address p1, bool p2, uint256 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(address,address,bool,uint256)`.\\n mstore(0x00, 0x3971e78c)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(address p0, address p1, bool p2, bytes32 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(address,address,bool,string)`.\\n mstore(0x00, 0xaa6540c8)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, 0x80)\\n writeString(0xa0, p3)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(address p0, address p1, uint256 p2, address p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(address,address,uint256,address)`.\\n mstore(0x00, 0x8da6def5)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(address p0, address p1, uint256 p2, bool p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(address,address,uint256,bool)`.\\n mstore(0x00, 0x9b4254e2)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(address p0, address p1, uint256 p2, uint256 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(address,address,uint256,uint256)`.\\n mstore(0x00, 0xbe553481)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(address p0, address p1, uint256 p2, bytes32 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(address,address,uint256,string)`.\\n mstore(0x00, 0xfdb4f990)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, 0x80)\\n writeString(0xa0, p3)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(address p0, address p1, bytes32 p2, address p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(address,address,string,address)`.\\n mstore(0x00, 0x8f736d16)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, 0x80)\\n mstore(0x80, p3)\\n writeString(0xa0, p2)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(address p0, address p1, bytes32 p2, bool p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(address,address,string,bool)`.\\n mstore(0x00, 0x6f1a594e)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, 0x80)\\n mstore(0x80, p3)\\n writeString(0xa0, p2)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(address p0, address p1, bytes32 p2, uint256 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(address,address,string,uint256)`.\\n mstore(0x00, 0xef1cefe7)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, 0x80)\\n mstore(0x80, p3)\\n writeString(0xa0, p2)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(address p0, address p1, bytes32 p2, bytes32 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n // Selector of `log(address,address,string,string)`.\\n mstore(0x00, 0x21bdaf25)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, 0x80)\\n mstore(0x80, 0xc0)\\n writeString(0xa0, p2)\\n writeString(0xe0, p3)\\n }\\n _sendLogPayload(0x1c, 0x104);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n }\\n }\\n\\n function log(address p0, bool p1, address p2, address p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(address,bool,address,address)`.\\n mstore(0x00, 0x660375dd)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(address p0, bool p1, address p2, bool p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(address,bool,address,bool)`.\\n mstore(0x00, 0xa6f50b0f)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(address p0, bool p1, address p2, uint256 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(address,bool,address,uint256)`.\\n mstore(0x00, 0xa75c59de)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(address p0, bool p1, address p2, bytes32 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(address,bool,address,string)`.\\n mstore(0x00, 0x2dd778e6)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, 0x80)\\n writeString(0xa0, p3)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(address p0, bool p1, bool p2, address p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(address,bool,bool,address)`.\\n mstore(0x00, 0xcf394485)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(address p0, bool p1, bool p2, bool p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(address,bool,bool,bool)`.\\n mstore(0x00, 0xcac43479)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(address p0, bool p1, bool p2, uint256 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(address,bool,bool,uint256)`.\\n mstore(0x00, 0x8c4e5de6)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(address p0, bool p1, bool p2, bytes32 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(address,bool,bool,string)`.\\n mstore(0x00, 0xdfc4a2e8)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, 0x80)\\n writeString(0xa0, p3)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(address p0, bool p1, uint256 p2, address p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(address,bool,uint256,address)`.\\n mstore(0x00, 0xccf790a1)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(address p0, bool p1, uint256 p2, bool p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(address,bool,uint256,bool)`.\\n mstore(0x00, 0xc4643e20)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(address p0, bool p1, uint256 p2, uint256 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(address,bool,uint256,uint256)`.\\n mstore(0x00, 0x386ff5f4)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(address p0, bool p1, uint256 p2, bytes32 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(address,bool,uint256,string)`.\\n mstore(0x00, 0x0aa6cfad)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, 0x80)\\n writeString(0xa0, p3)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(address p0, bool p1, bytes32 p2, address p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(address,bool,string,address)`.\\n mstore(0x00, 0x19fd4956)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, 0x80)\\n mstore(0x80, p3)\\n writeString(0xa0, p2)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(address p0, bool p1, bytes32 p2, bool p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(address,bool,string,bool)`.\\n mstore(0x00, 0x50ad461d)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, 0x80)\\n mstore(0x80, p3)\\n writeString(0xa0, p2)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(address p0, bool p1, bytes32 p2, uint256 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(address,bool,string,uint256)`.\\n mstore(0x00, 0x80e6a20b)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, 0x80)\\n mstore(0x80, p3)\\n writeString(0xa0, p2)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(address p0, bool p1, bytes32 p2, bytes32 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n // Selector of `log(address,bool,string,string)`.\\n mstore(0x00, 0x475c5c33)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, 0x80)\\n mstore(0x80, 0xc0)\\n writeString(0xa0, p2)\\n writeString(0xe0, p3)\\n }\\n _sendLogPayload(0x1c, 0x104);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n }\\n }\\n\\n function log(address p0, uint256 p1, address p2, address p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(address,uint256,address,address)`.\\n mstore(0x00, 0x478d1c62)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(address p0, uint256 p1, address p2, bool p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(address,uint256,address,bool)`.\\n mstore(0x00, 0xa1bcc9b3)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(address p0, uint256 p1, address p2, uint256 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(address,uint256,address,uint256)`.\\n mstore(0x00, 0x100f650e)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(address p0, uint256 p1, address p2, bytes32 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(address,uint256,address,string)`.\\n mstore(0x00, 0x1da986ea)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, 0x80)\\n writeString(0xa0, p3)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(address p0, uint256 p1, bool p2, address p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(address,uint256,bool,address)`.\\n mstore(0x00, 0xa31bfdcc)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(address p0, uint256 p1, bool p2, bool p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(address,uint256,bool,bool)`.\\n mstore(0x00, 0x3bf5e537)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(address p0, uint256 p1, bool p2, uint256 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(address,uint256,bool,uint256)`.\\n mstore(0x00, 0x22f6b999)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(address p0, uint256 p1, bool p2, bytes32 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(address,uint256,bool,string)`.\\n mstore(0x00, 0xc5ad85f9)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, 0x80)\\n writeString(0xa0, p3)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(address p0, uint256 p1, uint256 p2, address p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(address,uint256,uint256,address)`.\\n mstore(0x00, 0x20e3984d)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(address p0, uint256 p1, uint256 p2, bool p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(address,uint256,uint256,bool)`.\\n mstore(0x00, 0x66f1bc67)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(address p0, uint256 p1, uint256 p2, uint256 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(address,uint256,uint256,uint256)`.\\n mstore(0x00, 0x34f0e636)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(address p0, uint256 p1, uint256 p2, bytes32 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(address,uint256,uint256,string)`.\\n mstore(0x00, 0x4a28c017)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, 0x80)\\n writeString(0xa0, p3)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(address p0, uint256 p1, bytes32 p2, address p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(address,uint256,string,address)`.\\n mstore(0x00, 0x5c430d47)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, 0x80)\\n mstore(0x80, p3)\\n writeString(0xa0, p2)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(address p0, uint256 p1, bytes32 p2, bool p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(address,uint256,string,bool)`.\\n mstore(0x00, 0xcf18105c)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, 0x80)\\n mstore(0x80, p3)\\n writeString(0xa0, p2)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(address p0, uint256 p1, bytes32 p2, uint256 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(address,uint256,string,uint256)`.\\n mstore(0x00, 0xbf01f891)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, 0x80)\\n mstore(0x80, p3)\\n writeString(0xa0, p2)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(address p0, uint256 p1, bytes32 p2, bytes32 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n // Selector of `log(address,uint256,string,string)`.\\n mstore(0x00, 0x88a8c406)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, 0x80)\\n mstore(0x80, 0xc0)\\n writeString(0xa0, p2)\\n writeString(0xe0, p3)\\n }\\n _sendLogPayload(0x1c, 0x104);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n }\\n }\\n\\n function log(address p0, bytes32 p1, address p2, address p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(address,string,address,address)`.\\n mstore(0x00, 0x0d36fa20)\\n mstore(0x20, p0)\\n mstore(0x40, 0x80)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n writeString(0xa0, p1)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(address p0, bytes32 p1, address p2, bool p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(address,string,address,bool)`.\\n mstore(0x00, 0x0df12b76)\\n mstore(0x20, p0)\\n mstore(0x40, 0x80)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n writeString(0xa0, p1)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(address p0, bytes32 p1, address p2, uint256 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(address,string,address,uint256)`.\\n mstore(0x00, 0x457fe3cf)\\n mstore(0x20, p0)\\n mstore(0x40, 0x80)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n writeString(0xa0, p1)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(address p0, bytes32 p1, address p2, bytes32 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n // Selector of `log(address,string,address,string)`.\\n mstore(0x00, 0xf7e36245)\\n mstore(0x20, p0)\\n mstore(0x40, 0x80)\\n mstore(0x60, p2)\\n mstore(0x80, 0xc0)\\n writeString(0xa0, p1)\\n writeString(0xe0, p3)\\n }\\n _sendLogPayload(0x1c, 0x104);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n }\\n }\\n\\n function log(address p0, bytes32 p1, bool p2, address p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(address,string,bool,address)`.\\n mstore(0x00, 0x205871c2)\\n mstore(0x20, p0)\\n mstore(0x40, 0x80)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n writeString(0xa0, p1)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(address p0, bytes32 p1, bool p2, bool p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(address,string,bool,bool)`.\\n mstore(0x00, 0x5f1d5c9f)\\n mstore(0x20, p0)\\n mstore(0x40, 0x80)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n writeString(0xa0, p1)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(address p0, bytes32 p1, bool p2, uint256 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(address,string,bool,uint256)`.\\n mstore(0x00, 0x515e38b6)\\n mstore(0x20, p0)\\n mstore(0x40, 0x80)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n writeString(0xa0, p1)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(address p0, bytes32 p1, bool p2, bytes32 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n // Selector of `log(address,string,bool,string)`.\\n mstore(0x00, 0xbc0b61fe)\\n mstore(0x20, p0)\\n mstore(0x40, 0x80)\\n mstore(0x60, p2)\\n mstore(0x80, 0xc0)\\n writeString(0xa0, p1)\\n writeString(0xe0, p3)\\n }\\n _sendLogPayload(0x1c, 0x104);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n }\\n }\\n\\n function log(address p0, bytes32 p1, uint256 p2, address p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(address,string,uint256,address)`.\\n mstore(0x00, 0x63183678)\\n mstore(0x20, p0)\\n mstore(0x40, 0x80)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n writeString(0xa0, p1)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(address p0, bytes32 p1, uint256 p2, bool p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(address,string,uint256,bool)`.\\n mstore(0x00, 0x0ef7e050)\\n mstore(0x20, p0)\\n mstore(0x40, 0x80)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n writeString(0xa0, p1)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(address p0, bytes32 p1, uint256 p2, uint256 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(address,string,uint256,uint256)`.\\n mstore(0x00, 0x1dc8e1b8)\\n mstore(0x20, p0)\\n mstore(0x40, 0x80)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n writeString(0xa0, p1)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(address p0, bytes32 p1, uint256 p2, bytes32 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n // Selector of `log(address,string,uint256,string)`.\\n mstore(0x00, 0x448830a8)\\n mstore(0x20, p0)\\n mstore(0x40, 0x80)\\n mstore(0x60, p2)\\n mstore(0x80, 0xc0)\\n writeString(0xa0, p1)\\n writeString(0xe0, p3)\\n }\\n _sendLogPayload(0x1c, 0x104);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n }\\n }\\n\\n function log(address p0, bytes32 p1, bytes32 p2, address p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n // Selector of `log(address,string,string,address)`.\\n mstore(0x00, 0xa04e2f87)\\n mstore(0x20, p0)\\n mstore(0x40, 0x80)\\n mstore(0x60, 0xc0)\\n mstore(0x80, p3)\\n writeString(0xa0, p1)\\n writeString(0xe0, p2)\\n }\\n _sendLogPayload(0x1c, 0x104);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n }\\n }\\n\\n function log(address p0, bytes32 p1, bytes32 p2, bool p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n // Selector of `log(address,string,string,bool)`.\\n mstore(0x00, 0x35a5071f)\\n mstore(0x20, p0)\\n mstore(0x40, 0x80)\\n mstore(0x60, 0xc0)\\n mstore(0x80, p3)\\n writeString(0xa0, p1)\\n writeString(0xe0, p2)\\n }\\n _sendLogPayload(0x1c, 0x104);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n }\\n }\\n\\n function log(address p0, bytes32 p1, bytes32 p2, uint256 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n // Selector of `log(address,string,string,uint256)`.\\n mstore(0x00, 0x159f8927)\\n mstore(0x20, p0)\\n mstore(0x40, 0x80)\\n mstore(0x60, 0xc0)\\n mstore(0x80, p3)\\n writeString(0xa0, p1)\\n writeString(0xe0, p2)\\n }\\n _sendLogPayload(0x1c, 0x104);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n }\\n }\\n\\n function log(address p0, bytes32 p1, bytes32 p2, bytes32 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n bytes32 m9;\\n bytes32 m10;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n m9 := mload(0x120)\\n m10 := mload(0x140)\\n // Selector of `log(address,string,string,string)`.\\n mstore(0x00, 0x5d02c50b)\\n mstore(0x20, p0)\\n mstore(0x40, 0x80)\\n mstore(0x60, 0xc0)\\n mstore(0x80, 0x100)\\n writeString(0xa0, p1)\\n writeString(0xe0, p2)\\n writeString(0x120, p3)\\n }\\n _sendLogPayload(0x1c, 0x144);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n mstore(0x120, m9)\\n mstore(0x140, m10)\\n }\\n }\\n\\n function log(bool p0, address p1, address p2, address p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(bool,address,address,address)`.\\n mstore(0x00, 0x1d14d001)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(bool p0, address p1, address p2, bool p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(bool,address,address,bool)`.\\n mstore(0x00, 0x46600be0)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(bool p0, address p1, address p2, uint256 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(bool,address,address,uint256)`.\\n mstore(0x00, 0x0c66d1be)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(bool p0, address p1, address p2, bytes32 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(bool,address,address,string)`.\\n mstore(0x00, 0xd812a167)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, 0x80)\\n writeString(0xa0, p3)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(bool p0, address p1, bool p2, address p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(bool,address,bool,address)`.\\n mstore(0x00, 0x1c41a336)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(bool p0, address p1, bool p2, bool p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(bool,address,bool,bool)`.\\n mstore(0x00, 0x6a9c478b)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(bool p0, address p1, bool p2, uint256 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(bool,address,bool,uint256)`.\\n mstore(0x00, 0x07831502)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(bool p0, address p1, bool p2, bytes32 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(bool,address,bool,string)`.\\n mstore(0x00, 0x4a66cb34)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, 0x80)\\n writeString(0xa0, p3)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(bool p0, address p1, uint256 p2, address p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(bool,address,uint256,address)`.\\n mstore(0x00, 0x136b05dd)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(bool p0, address p1, uint256 p2, bool p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(bool,address,uint256,bool)`.\\n mstore(0x00, 0xd6019f1c)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(bool p0, address p1, uint256 p2, uint256 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(bool,address,uint256,uint256)`.\\n mstore(0x00, 0x7bf181a1)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(bool p0, address p1, uint256 p2, bytes32 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(bool,address,uint256,string)`.\\n mstore(0x00, 0x51f09ff8)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, 0x80)\\n writeString(0xa0, p3)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(bool p0, address p1, bytes32 p2, address p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(bool,address,string,address)`.\\n mstore(0x00, 0x6f7c603e)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, 0x80)\\n mstore(0x80, p3)\\n writeString(0xa0, p2)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(bool p0, address p1, bytes32 p2, bool p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(bool,address,string,bool)`.\\n mstore(0x00, 0xe2bfd60b)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, 0x80)\\n mstore(0x80, p3)\\n writeString(0xa0, p2)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(bool p0, address p1, bytes32 p2, uint256 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(bool,address,string,uint256)`.\\n mstore(0x00, 0xc21f64c7)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, 0x80)\\n mstore(0x80, p3)\\n writeString(0xa0, p2)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(bool p0, address p1, bytes32 p2, bytes32 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n // Selector of `log(bool,address,string,string)`.\\n mstore(0x00, 0xa73c1db6)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, 0x80)\\n mstore(0x80, 0xc0)\\n writeString(0xa0, p2)\\n writeString(0xe0, p3)\\n }\\n _sendLogPayload(0x1c, 0x104);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n }\\n }\\n\\n function log(bool p0, bool p1, address p2, address p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(bool,bool,address,address)`.\\n mstore(0x00, 0xf4880ea4)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(bool p0, bool p1, address p2, bool p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(bool,bool,address,bool)`.\\n mstore(0x00, 0xc0a302d8)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(bool p0, bool p1, address p2, uint256 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(bool,bool,address,uint256)`.\\n mstore(0x00, 0x4c123d57)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(bool p0, bool p1, address p2, bytes32 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(bool,bool,address,string)`.\\n mstore(0x00, 0xa0a47963)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, 0x80)\\n writeString(0xa0, p3)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(bool p0, bool p1, bool p2, address p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(bool,bool,bool,address)`.\\n mstore(0x00, 0x8c329b1a)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(bool p0, bool p1, bool p2, bool p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(bool,bool,bool,bool)`.\\n mstore(0x00, 0x3b2a5ce0)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(bool p0, bool p1, bool p2, uint256 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(bool,bool,bool,uint256)`.\\n mstore(0x00, 0x6d7045c1)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(bool p0, bool p1, bool p2, bytes32 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(bool,bool,bool,string)`.\\n mstore(0x00, 0x2ae408d4)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, 0x80)\\n writeString(0xa0, p3)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(bool p0, bool p1, uint256 p2, address p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(bool,bool,uint256,address)`.\\n mstore(0x00, 0x54a7a9a0)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(bool p0, bool p1, uint256 p2, bool p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(bool,bool,uint256,bool)`.\\n mstore(0x00, 0x619e4d0e)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(bool p0, bool p1, uint256 p2, uint256 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(bool,bool,uint256,uint256)`.\\n mstore(0x00, 0x0bb00eab)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(bool p0, bool p1, uint256 p2, bytes32 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(bool,bool,uint256,string)`.\\n mstore(0x00, 0x7dd4d0e0)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, 0x80)\\n writeString(0xa0, p3)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(bool p0, bool p1, bytes32 p2, address p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(bool,bool,string,address)`.\\n mstore(0x00, 0xf9ad2b89)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, 0x80)\\n mstore(0x80, p3)\\n writeString(0xa0, p2)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(bool p0, bool p1, bytes32 p2, bool p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(bool,bool,string,bool)`.\\n mstore(0x00, 0xb857163a)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, 0x80)\\n mstore(0x80, p3)\\n writeString(0xa0, p2)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(bool p0, bool p1, bytes32 p2, uint256 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(bool,bool,string,uint256)`.\\n mstore(0x00, 0xe3a9ca2f)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, 0x80)\\n mstore(0x80, p3)\\n writeString(0xa0, p2)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(bool p0, bool p1, bytes32 p2, bytes32 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n // Selector of `log(bool,bool,string,string)`.\\n mstore(0x00, 0x6d1e8751)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, 0x80)\\n mstore(0x80, 0xc0)\\n writeString(0xa0, p2)\\n writeString(0xe0, p3)\\n }\\n _sendLogPayload(0x1c, 0x104);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n }\\n }\\n\\n function log(bool p0, uint256 p1, address p2, address p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(bool,uint256,address,address)`.\\n mstore(0x00, 0x26f560a8)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(bool p0, uint256 p1, address p2, bool p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(bool,uint256,address,bool)`.\\n mstore(0x00, 0xb4c314ff)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(bool p0, uint256 p1, address p2, uint256 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(bool,uint256,address,uint256)`.\\n mstore(0x00, 0x1537dc87)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(bool p0, uint256 p1, address p2, bytes32 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(bool,uint256,address,string)`.\\n mstore(0x00, 0x1bb3b09a)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, 0x80)\\n writeString(0xa0, p3)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(bool p0, uint256 p1, bool p2, address p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(bool,uint256,bool,address)`.\\n mstore(0x00, 0x9acd3616)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(bool p0, uint256 p1, bool p2, bool p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(bool,uint256,bool,bool)`.\\n mstore(0x00, 0xceb5f4d7)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(bool p0, uint256 p1, bool p2, uint256 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(bool,uint256,bool,uint256)`.\\n mstore(0x00, 0x7f9bbca2)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(bool p0, uint256 p1, bool p2, bytes32 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(bool,uint256,bool,string)`.\\n mstore(0x00, 0x9143dbb1)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, 0x80)\\n writeString(0xa0, p3)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(bool p0, uint256 p1, uint256 p2, address p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(bool,uint256,uint256,address)`.\\n mstore(0x00, 0x00dd87b9)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(bool p0, uint256 p1, uint256 p2, bool p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(bool,uint256,uint256,bool)`.\\n mstore(0x00, 0xbe984353)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(bool p0, uint256 p1, uint256 p2, uint256 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(bool,uint256,uint256,uint256)`.\\n mstore(0x00, 0x374bb4b2)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(bool p0, uint256 p1, uint256 p2, bytes32 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(bool,uint256,uint256,string)`.\\n mstore(0x00, 0x8e69fb5d)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, 0x80)\\n writeString(0xa0, p3)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(bool p0, uint256 p1, bytes32 p2, address p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(bool,uint256,string,address)`.\\n mstore(0x00, 0xfedd1fff)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, 0x80)\\n mstore(0x80, p3)\\n writeString(0xa0, p2)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(bool p0, uint256 p1, bytes32 p2, bool p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(bool,uint256,string,bool)`.\\n mstore(0x00, 0xe5e70b2b)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, 0x80)\\n mstore(0x80, p3)\\n writeString(0xa0, p2)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(bool p0, uint256 p1, bytes32 p2, uint256 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(bool,uint256,string,uint256)`.\\n mstore(0x00, 0x6a1199e2)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, 0x80)\\n mstore(0x80, p3)\\n writeString(0xa0, p2)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(bool p0, uint256 p1, bytes32 p2, bytes32 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n // Selector of `log(bool,uint256,string,string)`.\\n mstore(0x00, 0xf5bc2249)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, 0x80)\\n mstore(0x80, 0xc0)\\n writeString(0xa0, p2)\\n writeString(0xe0, p3)\\n }\\n _sendLogPayload(0x1c, 0x104);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n }\\n }\\n\\n function log(bool p0, bytes32 p1, address p2, address p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(bool,string,address,address)`.\\n mstore(0x00, 0x2b2b18dc)\\n mstore(0x20, p0)\\n mstore(0x40, 0x80)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n writeString(0xa0, p1)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(bool p0, bytes32 p1, address p2, bool p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(bool,string,address,bool)`.\\n mstore(0x00, 0x6dd434ca)\\n mstore(0x20, p0)\\n mstore(0x40, 0x80)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n writeString(0xa0, p1)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(bool p0, bytes32 p1, address p2, uint256 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(bool,string,address,uint256)`.\\n mstore(0x00, 0xa5cada94)\\n mstore(0x20, p0)\\n mstore(0x40, 0x80)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n writeString(0xa0, p1)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(bool p0, bytes32 p1, address p2, bytes32 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n // Selector of `log(bool,string,address,string)`.\\n mstore(0x00, 0x12d6c788)\\n mstore(0x20, p0)\\n mstore(0x40, 0x80)\\n mstore(0x60, p2)\\n mstore(0x80, 0xc0)\\n writeString(0xa0, p1)\\n writeString(0xe0, p3)\\n }\\n _sendLogPayload(0x1c, 0x104);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n }\\n }\\n\\n function log(bool p0, bytes32 p1, bool p2, address p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(bool,string,bool,address)`.\\n mstore(0x00, 0x538e06ab)\\n mstore(0x20, p0)\\n mstore(0x40, 0x80)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n writeString(0xa0, p1)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(bool p0, bytes32 p1, bool p2, bool p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(bool,string,bool,bool)`.\\n mstore(0x00, 0xdc5e935b)\\n mstore(0x20, p0)\\n mstore(0x40, 0x80)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n writeString(0xa0, p1)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(bool p0, bytes32 p1, bool p2, uint256 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(bool,string,bool,uint256)`.\\n mstore(0x00, 0x1606a393)\\n mstore(0x20, p0)\\n mstore(0x40, 0x80)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n writeString(0xa0, p1)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(bool p0, bytes32 p1, bool p2, bytes32 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n // Selector of `log(bool,string,bool,string)`.\\n mstore(0x00, 0x483d0416)\\n mstore(0x20, p0)\\n mstore(0x40, 0x80)\\n mstore(0x60, p2)\\n mstore(0x80, 0xc0)\\n writeString(0xa0, p1)\\n writeString(0xe0, p3)\\n }\\n _sendLogPayload(0x1c, 0x104);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n }\\n }\\n\\n function log(bool p0, bytes32 p1, uint256 p2, address p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(bool,string,uint256,address)`.\\n mstore(0x00, 0x1596a1ce)\\n mstore(0x20, p0)\\n mstore(0x40, 0x80)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n writeString(0xa0, p1)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(bool p0, bytes32 p1, uint256 p2, bool p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(bool,string,uint256,bool)`.\\n mstore(0x00, 0x6b0e5d53)\\n mstore(0x20, p0)\\n mstore(0x40, 0x80)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n writeString(0xa0, p1)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(bool p0, bytes32 p1, uint256 p2, uint256 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(bool,string,uint256,uint256)`.\\n mstore(0x00, 0x28863fcb)\\n mstore(0x20, p0)\\n mstore(0x40, 0x80)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n writeString(0xa0, p1)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(bool p0, bytes32 p1, uint256 p2, bytes32 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n // Selector of `log(bool,string,uint256,string)`.\\n mstore(0x00, 0x1ad96de6)\\n mstore(0x20, p0)\\n mstore(0x40, 0x80)\\n mstore(0x60, p2)\\n mstore(0x80, 0xc0)\\n writeString(0xa0, p1)\\n writeString(0xe0, p3)\\n }\\n _sendLogPayload(0x1c, 0x104);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n }\\n }\\n\\n function log(bool p0, bytes32 p1, bytes32 p2, address p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n // Selector of `log(bool,string,string,address)`.\\n mstore(0x00, 0x97d394d8)\\n mstore(0x20, p0)\\n mstore(0x40, 0x80)\\n mstore(0x60, 0xc0)\\n mstore(0x80, p3)\\n writeString(0xa0, p1)\\n writeString(0xe0, p2)\\n }\\n _sendLogPayload(0x1c, 0x104);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n }\\n }\\n\\n function log(bool p0, bytes32 p1, bytes32 p2, bool p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n // Selector of `log(bool,string,string,bool)`.\\n mstore(0x00, 0x1e4b87e5)\\n mstore(0x20, p0)\\n mstore(0x40, 0x80)\\n mstore(0x60, 0xc0)\\n mstore(0x80, p3)\\n writeString(0xa0, p1)\\n writeString(0xe0, p2)\\n }\\n _sendLogPayload(0x1c, 0x104);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n }\\n }\\n\\n function log(bool p0, bytes32 p1, bytes32 p2, uint256 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n // Selector of `log(bool,string,string,uint256)`.\\n mstore(0x00, 0x7be0c3eb)\\n mstore(0x20, p0)\\n mstore(0x40, 0x80)\\n mstore(0x60, 0xc0)\\n mstore(0x80, p3)\\n writeString(0xa0, p1)\\n writeString(0xe0, p2)\\n }\\n _sendLogPayload(0x1c, 0x104);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n }\\n }\\n\\n function log(bool p0, bytes32 p1, bytes32 p2, bytes32 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n bytes32 m9;\\n bytes32 m10;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n m9 := mload(0x120)\\n m10 := mload(0x140)\\n // Selector of `log(bool,string,string,string)`.\\n mstore(0x00, 0x1762e32a)\\n mstore(0x20, p0)\\n mstore(0x40, 0x80)\\n mstore(0x60, 0xc0)\\n mstore(0x80, 0x100)\\n writeString(0xa0, p1)\\n writeString(0xe0, p2)\\n writeString(0x120, p3)\\n }\\n _sendLogPayload(0x1c, 0x144);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n mstore(0x120, m9)\\n mstore(0x140, m10)\\n }\\n }\\n\\n function log(uint256 p0, address p1, address p2, address p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(uint256,address,address,address)`.\\n mstore(0x00, 0x2488b414)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(uint256 p0, address p1, address p2, bool p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(uint256,address,address,bool)`.\\n mstore(0x00, 0x091ffaf5)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(uint256 p0, address p1, address p2, uint256 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(uint256,address,address,uint256)`.\\n mstore(0x00, 0x736efbb6)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(uint256 p0, address p1, address p2, bytes32 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(uint256,address,address,string)`.\\n mstore(0x00, 0x031c6f73)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, 0x80)\\n writeString(0xa0, p3)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(uint256 p0, address p1, bool p2, address p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(uint256,address,bool,address)`.\\n mstore(0x00, 0xef72c513)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(uint256 p0, address p1, bool p2, bool p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(uint256,address,bool,bool)`.\\n mstore(0x00, 0xe351140f)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(uint256 p0, address p1, bool p2, uint256 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(uint256,address,bool,uint256)`.\\n mstore(0x00, 0x5abd992a)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(uint256 p0, address p1, bool p2, bytes32 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(uint256,address,bool,string)`.\\n mstore(0x00, 0x90fb06aa)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, 0x80)\\n writeString(0xa0, p3)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(uint256 p0, address p1, uint256 p2, address p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(uint256,address,uint256,address)`.\\n mstore(0x00, 0x15c127b5)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(uint256 p0, address p1, uint256 p2, bool p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(uint256,address,uint256,bool)`.\\n mstore(0x00, 0x5f743a7c)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(uint256 p0, address p1, uint256 p2, uint256 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(uint256,address,uint256,uint256)`.\\n mstore(0x00, 0x0c9cd9c1)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(uint256 p0, address p1, uint256 p2, bytes32 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(uint256,address,uint256,string)`.\\n mstore(0x00, 0xddb06521)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, 0x80)\\n writeString(0xa0, p3)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(uint256 p0, address p1, bytes32 p2, address p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(uint256,address,string,address)`.\\n mstore(0x00, 0x9cba8fff)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, 0x80)\\n mstore(0x80, p3)\\n writeString(0xa0, p2)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(uint256 p0, address p1, bytes32 p2, bool p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(uint256,address,string,bool)`.\\n mstore(0x00, 0xcc32ab07)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, 0x80)\\n mstore(0x80, p3)\\n writeString(0xa0, p2)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(uint256 p0, address p1, bytes32 p2, uint256 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(uint256,address,string,uint256)`.\\n mstore(0x00, 0x46826b5d)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, 0x80)\\n mstore(0x80, p3)\\n writeString(0xa0, p2)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(uint256 p0, address p1, bytes32 p2, bytes32 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n // Selector of `log(uint256,address,string,string)`.\\n mstore(0x00, 0x3e128ca3)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, 0x80)\\n mstore(0x80, 0xc0)\\n writeString(0xa0, p2)\\n writeString(0xe0, p3)\\n }\\n _sendLogPayload(0x1c, 0x104);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n }\\n }\\n\\n function log(uint256 p0, bool p1, address p2, address p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(uint256,bool,address,address)`.\\n mstore(0x00, 0xa1ef4cbb)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(uint256 p0, bool p1, address p2, bool p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(uint256,bool,address,bool)`.\\n mstore(0x00, 0x454d54a5)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(uint256 p0, bool p1, address p2, uint256 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(uint256,bool,address,uint256)`.\\n mstore(0x00, 0x078287f5)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(uint256 p0, bool p1, address p2, bytes32 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(uint256,bool,address,string)`.\\n mstore(0x00, 0xade052c7)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, 0x80)\\n writeString(0xa0, p3)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(uint256 p0, bool p1, bool p2, address p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(uint256,bool,bool,address)`.\\n mstore(0x00, 0x69640b59)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(uint256 p0, bool p1, bool p2, bool p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(uint256,bool,bool,bool)`.\\n mstore(0x00, 0xb6f577a1)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(uint256 p0, bool p1, bool p2, uint256 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(uint256,bool,bool,uint256)`.\\n mstore(0x00, 0x7464ce23)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(uint256 p0, bool p1, bool p2, bytes32 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(uint256,bool,bool,string)`.\\n mstore(0x00, 0xdddb9561)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, 0x80)\\n writeString(0xa0, p3)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(uint256 p0, bool p1, uint256 p2, address p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(uint256,bool,uint256,address)`.\\n mstore(0x00, 0x88cb6041)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(uint256 p0, bool p1, uint256 p2, bool p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(uint256,bool,uint256,bool)`.\\n mstore(0x00, 0x91a02e2a)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(uint256 p0, bool p1, uint256 p2, uint256 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(uint256,bool,uint256,uint256)`.\\n mstore(0x00, 0xc6acc7a8)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(uint256 p0, bool p1, uint256 p2, bytes32 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(uint256,bool,uint256,string)`.\\n mstore(0x00, 0xde03e774)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, 0x80)\\n writeString(0xa0, p3)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(uint256 p0, bool p1, bytes32 p2, address p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(uint256,bool,string,address)`.\\n mstore(0x00, 0xef529018)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, 0x80)\\n mstore(0x80, p3)\\n writeString(0xa0, p2)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(uint256 p0, bool p1, bytes32 p2, bool p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(uint256,bool,string,bool)`.\\n mstore(0x00, 0xeb928d7f)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, 0x80)\\n mstore(0x80, p3)\\n writeString(0xa0, p2)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(uint256 p0, bool p1, bytes32 p2, uint256 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(uint256,bool,string,uint256)`.\\n mstore(0x00, 0x2c1d0746)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, 0x80)\\n mstore(0x80, p3)\\n writeString(0xa0, p2)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(uint256 p0, bool p1, bytes32 p2, bytes32 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n // Selector of `log(uint256,bool,string,string)`.\\n mstore(0x00, 0x68c8b8bd)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, 0x80)\\n mstore(0x80, 0xc0)\\n writeString(0xa0, p2)\\n writeString(0xe0, p3)\\n }\\n _sendLogPayload(0x1c, 0x104);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n }\\n }\\n\\n function log(uint256 p0, uint256 p1, address p2, address p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(uint256,uint256,address,address)`.\\n mstore(0x00, 0x56a5d1b1)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(uint256 p0, uint256 p1, address p2, bool p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(uint256,uint256,address,bool)`.\\n mstore(0x00, 0x15cac476)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(uint256 p0, uint256 p1, address p2, uint256 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(uint256,uint256,address,uint256)`.\\n mstore(0x00, 0x88f6e4b2)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(uint256 p0, uint256 p1, address p2, bytes32 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(uint256,uint256,address,string)`.\\n mstore(0x00, 0x6cde40b8)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, 0x80)\\n writeString(0xa0, p3)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(uint256 p0, uint256 p1, bool p2, address p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(uint256,uint256,bool,address)`.\\n mstore(0x00, 0x9a816a83)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(uint256 p0, uint256 p1, bool p2, bool p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(uint256,uint256,bool,bool)`.\\n mstore(0x00, 0xab085ae6)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(uint256 p0, uint256 p1, bool p2, uint256 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(uint256,uint256,bool,uint256)`.\\n mstore(0x00, 0xeb7f6fd2)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(uint256 p0, uint256 p1, bool p2, bytes32 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(uint256,uint256,bool,string)`.\\n mstore(0x00, 0xa5b4fc99)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, 0x80)\\n writeString(0xa0, p3)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(uint256 p0, uint256 p1, uint256 p2, address p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(uint256,uint256,uint256,address)`.\\n mstore(0x00, 0xfa8185af)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(uint256 p0, uint256 p1, uint256 p2, bool p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(uint256,uint256,uint256,bool)`.\\n mstore(0x00, 0xc598d185)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(uint256 p0, uint256 p1, uint256 p2, uint256 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(uint256,uint256,uint256,uint256)`.\\n mstore(0x00, 0x193fb800)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(uint256 p0, uint256 p1, uint256 p2, bytes32 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(uint256,uint256,uint256,string)`.\\n mstore(0x00, 0x59cfcbe3)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, 0x80)\\n writeString(0xa0, p3)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(uint256 p0, uint256 p1, bytes32 p2, address p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(uint256,uint256,string,address)`.\\n mstore(0x00, 0x42d21db7)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, 0x80)\\n mstore(0x80, p3)\\n writeString(0xa0, p2)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(uint256 p0, uint256 p1, bytes32 p2, bool p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(uint256,uint256,string,bool)`.\\n mstore(0x00, 0x7af6ab25)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, 0x80)\\n mstore(0x80, p3)\\n writeString(0xa0, p2)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(uint256 p0, uint256 p1, bytes32 p2, uint256 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(uint256,uint256,string,uint256)`.\\n mstore(0x00, 0x5da297eb)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, 0x80)\\n mstore(0x80, p3)\\n writeString(0xa0, p2)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(uint256 p0, uint256 p1, bytes32 p2, bytes32 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n // Selector of `log(uint256,uint256,string,string)`.\\n mstore(0x00, 0x27d8afd2)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, 0x80)\\n mstore(0x80, 0xc0)\\n writeString(0xa0, p2)\\n writeString(0xe0, p3)\\n }\\n _sendLogPayload(0x1c, 0x104);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n }\\n }\\n\\n function log(uint256 p0, bytes32 p1, address p2, address p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(uint256,string,address,address)`.\\n mstore(0x00, 0x6168ed61)\\n mstore(0x20, p0)\\n mstore(0x40, 0x80)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n writeString(0xa0, p1)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(uint256 p0, bytes32 p1, address p2, bool p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(uint256,string,address,bool)`.\\n mstore(0x00, 0x90c30a56)\\n mstore(0x20, p0)\\n mstore(0x40, 0x80)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n writeString(0xa0, p1)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(uint256 p0, bytes32 p1, address p2, uint256 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(uint256,string,address,uint256)`.\\n mstore(0x00, 0xe8d3018d)\\n mstore(0x20, p0)\\n mstore(0x40, 0x80)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n writeString(0xa0, p1)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(uint256 p0, bytes32 p1, address p2, bytes32 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n // Selector of `log(uint256,string,address,string)`.\\n mstore(0x00, 0x9c3adfa1)\\n mstore(0x20, p0)\\n mstore(0x40, 0x80)\\n mstore(0x60, p2)\\n mstore(0x80, 0xc0)\\n writeString(0xa0, p1)\\n writeString(0xe0, p3)\\n }\\n _sendLogPayload(0x1c, 0x104);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n }\\n }\\n\\n function log(uint256 p0, bytes32 p1, bool p2, address p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(uint256,string,bool,address)`.\\n mstore(0x00, 0xae2ec581)\\n mstore(0x20, p0)\\n mstore(0x40, 0x80)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n writeString(0xa0, p1)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(uint256 p0, bytes32 p1, bool p2, bool p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(uint256,string,bool,bool)`.\\n mstore(0x00, 0xba535d9c)\\n mstore(0x20, p0)\\n mstore(0x40, 0x80)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n writeString(0xa0, p1)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(uint256 p0, bytes32 p1, bool p2, uint256 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(uint256,string,bool,uint256)`.\\n mstore(0x00, 0xcf009880)\\n mstore(0x20, p0)\\n mstore(0x40, 0x80)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n writeString(0xa0, p1)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(uint256 p0, bytes32 p1, bool p2, bytes32 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n // Selector of `log(uint256,string,bool,string)`.\\n mstore(0x00, 0xd2d423cd)\\n mstore(0x20, p0)\\n mstore(0x40, 0x80)\\n mstore(0x60, p2)\\n mstore(0x80, 0xc0)\\n writeString(0xa0, p1)\\n writeString(0xe0, p3)\\n }\\n _sendLogPayload(0x1c, 0x104);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n }\\n }\\n\\n function log(uint256 p0, bytes32 p1, uint256 p2, address p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(uint256,string,uint256,address)`.\\n mstore(0x00, 0x3b2279b4)\\n mstore(0x20, p0)\\n mstore(0x40, 0x80)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n writeString(0xa0, p1)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(uint256 p0, bytes32 p1, uint256 p2, bool p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(uint256,string,uint256,bool)`.\\n mstore(0x00, 0x691a8f74)\\n mstore(0x20, p0)\\n mstore(0x40, 0x80)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n writeString(0xa0, p1)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(uint256 p0, bytes32 p1, uint256 p2, uint256 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(uint256,string,uint256,uint256)`.\\n mstore(0x00, 0x82c25b74)\\n mstore(0x20, p0)\\n mstore(0x40, 0x80)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n writeString(0xa0, p1)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(uint256 p0, bytes32 p1, uint256 p2, bytes32 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n // Selector of `log(uint256,string,uint256,string)`.\\n mstore(0x00, 0xb7b914ca)\\n mstore(0x20, p0)\\n mstore(0x40, 0x80)\\n mstore(0x60, p2)\\n mstore(0x80, 0xc0)\\n writeString(0xa0, p1)\\n writeString(0xe0, p3)\\n }\\n _sendLogPayload(0x1c, 0x104);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n }\\n }\\n\\n function log(uint256 p0, bytes32 p1, bytes32 p2, address p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n // Selector of `log(uint256,string,string,address)`.\\n mstore(0x00, 0xd583c602)\\n mstore(0x20, p0)\\n mstore(0x40, 0x80)\\n mstore(0x60, 0xc0)\\n mstore(0x80, p3)\\n writeString(0xa0, p1)\\n writeString(0xe0, p2)\\n }\\n _sendLogPayload(0x1c, 0x104);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n }\\n }\\n\\n function log(uint256 p0, bytes32 p1, bytes32 p2, bool p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n // Selector of `log(uint256,string,string,bool)`.\\n mstore(0x00, 0xb3a6b6bd)\\n mstore(0x20, p0)\\n mstore(0x40, 0x80)\\n mstore(0x60, 0xc0)\\n mstore(0x80, p3)\\n writeString(0xa0, p1)\\n writeString(0xe0, p2)\\n }\\n _sendLogPayload(0x1c, 0x104);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n }\\n }\\n\\n function log(uint256 p0, bytes32 p1, bytes32 p2, uint256 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n // Selector of `log(uint256,string,string,uint256)`.\\n mstore(0x00, 0xb028c9bd)\\n mstore(0x20, p0)\\n mstore(0x40, 0x80)\\n mstore(0x60, 0xc0)\\n mstore(0x80, p3)\\n writeString(0xa0, p1)\\n writeString(0xe0, p2)\\n }\\n _sendLogPayload(0x1c, 0x104);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n }\\n }\\n\\n function log(uint256 p0, bytes32 p1, bytes32 p2, bytes32 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n bytes32 m9;\\n bytes32 m10;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n m9 := mload(0x120)\\n m10 := mload(0x140)\\n // Selector of `log(uint256,string,string,string)`.\\n mstore(0x00, 0x21ad0683)\\n mstore(0x20, p0)\\n mstore(0x40, 0x80)\\n mstore(0x60, 0xc0)\\n mstore(0x80, 0x100)\\n writeString(0xa0, p1)\\n writeString(0xe0, p2)\\n writeString(0x120, p3)\\n }\\n _sendLogPayload(0x1c, 0x144);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n mstore(0x120, m9)\\n mstore(0x140, m10)\\n }\\n }\\n\\n function log(bytes32 p0, address p1, address p2, address p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(string,address,address,address)`.\\n mstore(0x00, 0xed8f28f6)\\n mstore(0x20, 0x80)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n writeString(0xa0, p0)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(bytes32 p0, address p1, address p2, bool p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(string,address,address,bool)`.\\n mstore(0x00, 0xb59dbd60)\\n mstore(0x20, 0x80)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n writeString(0xa0, p0)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(bytes32 p0, address p1, address p2, uint256 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(string,address,address,uint256)`.\\n mstore(0x00, 0x8ef3f399)\\n mstore(0x20, 0x80)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n writeString(0xa0, p0)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(bytes32 p0, address p1, address p2, bytes32 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n // Selector of `log(string,address,address,string)`.\\n mstore(0x00, 0x800a1c67)\\n mstore(0x20, 0x80)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, 0xc0)\\n writeString(0xa0, p0)\\n writeString(0xe0, p3)\\n }\\n _sendLogPayload(0x1c, 0x104);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n }\\n }\\n\\n function log(bytes32 p0, address p1, bool p2, address p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(string,address,bool,address)`.\\n mstore(0x00, 0x223603bd)\\n mstore(0x20, 0x80)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n writeString(0xa0, p0)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(bytes32 p0, address p1, bool p2, bool p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(string,address,bool,bool)`.\\n mstore(0x00, 0x79884c2b)\\n mstore(0x20, 0x80)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n writeString(0xa0, p0)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(bytes32 p0, address p1, bool p2, uint256 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(string,address,bool,uint256)`.\\n mstore(0x00, 0x3e9f866a)\\n mstore(0x20, 0x80)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n writeString(0xa0, p0)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(bytes32 p0, address p1, bool p2, bytes32 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n // Selector of `log(string,address,bool,string)`.\\n mstore(0x00, 0x0454c079)\\n mstore(0x20, 0x80)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, 0xc0)\\n writeString(0xa0, p0)\\n writeString(0xe0, p3)\\n }\\n _sendLogPayload(0x1c, 0x104);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n }\\n }\\n\\n function log(bytes32 p0, address p1, uint256 p2, address p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(string,address,uint256,address)`.\\n mstore(0x00, 0x63fb8bc5)\\n mstore(0x20, 0x80)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n writeString(0xa0, p0)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(bytes32 p0, address p1, uint256 p2, bool p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(string,address,uint256,bool)`.\\n mstore(0x00, 0xfc4845f0)\\n mstore(0x20, 0x80)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n writeString(0xa0, p0)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(bytes32 p0, address p1, uint256 p2, uint256 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(string,address,uint256,uint256)`.\\n mstore(0x00, 0xf8f51b1e)\\n mstore(0x20, 0x80)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n writeString(0xa0, p0)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(bytes32 p0, address p1, uint256 p2, bytes32 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n // Selector of `log(string,address,uint256,string)`.\\n mstore(0x00, 0x5a477632)\\n mstore(0x20, 0x80)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, 0xc0)\\n writeString(0xa0, p0)\\n writeString(0xe0, p3)\\n }\\n _sendLogPayload(0x1c, 0x104);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n }\\n }\\n\\n function log(bytes32 p0, address p1, bytes32 p2, address p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n // Selector of `log(string,address,string,address)`.\\n mstore(0x00, 0xaabc9a31)\\n mstore(0x20, 0x80)\\n mstore(0x40, p1)\\n mstore(0x60, 0xc0)\\n mstore(0x80, p3)\\n writeString(0xa0, p0)\\n writeString(0xe0, p2)\\n }\\n _sendLogPayload(0x1c, 0x104);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n }\\n }\\n\\n function log(bytes32 p0, address p1, bytes32 p2, bool p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n // Selector of `log(string,address,string,bool)`.\\n mstore(0x00, 0x5f15d28c)\\n mstore(0x20, 0x80)\\n mstore(0x40, p1)\\n mstore(0x60, 0xc0)\\n mstore(0x80, p3)\\n writeString(0xa0, p0)\\n writeString(0xe0, p2)\\n }\\n _sendLogPayload(0x1c, 0x104);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n }\\n }\\n\\n function log(bytes32 p0, address p1, bytes32 p2, uint256 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n // Selector of `log(string,address,string,uint256)`.\\n mstore(0x00, 0x91d1112e)\\n mstore(0x20, 0x80)\\n mstore(0x40, p1)\\n mstore(0x60, 0xc0)\\n mstore(0x80, p3)\\n writeString(0xa0, p0)\\n writeString(0xe0, p2)\\n }\\n _sendLogPayload(0x1c, 0x104);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n }\\n }\\n\\n function log(bytes32 p0, address p1, bytes32 p2, bytes32 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n bytes32 m9;\\n bytes32 m10;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n m9 := mload(0x120)\\n m10 := mload(0x140)\\n // Selector of `log(string,address,string,string)`.\\n mstore(0x00, 0x245986f2)\\n mstore(0x20, 0x80)\\n mstore(0x40, p1)\\n mstore(0x60, 0xc0)\\n mstore(0x80, 0x100)\\n writeString(0xa0, p0)\\n writeString(0xe0, p2)\\n writeString(0x120, p3)\\n }\\n _sendLogPayload(0x1c, 0x144);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n mstore(0x120, m9)\\n mstore(0x140, m10)\\n }\\n }\\n\\n function log(bytes32 p0, bool p1, address p2, address p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(string,bool,address,address)`.\\n mstore(0x00, 0x33e9dd1d)\\n mstore(0x20, 0x80)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n writeString(0xa0, p0)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(bytes32 p0, bool p1, address p2, bool p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(string,bool,address,bool)`.\\n mstore(0x00, 0x958c28c6)\\n mstore(0x20, 0x80)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n writeString(0xa0, p0)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(bytes32 p0, bool p1, address p2, uint256 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(string,bool,address,uint256)`.\\n mstore(0x00, 0x5d08bb05)\\n mstore(0x20, 0x80)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n writeString(0xa0, p0)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(bytes32 p0, bool p1, address p2, bytes32 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n // Selector of `log(string,bool,address,string)`.\\n mstore(0x00, 0x2d8e33a4)\\n mstore(0x20, 0x80)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, 0xc0)\\n writeString(0xa0, p0)\\n writeString(0xe0, p3)\\n }\\n _sendLogPayload(0x1c, 0x104);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n }\\n }\\n\\n function log(bytes32 p0, bool p1, bool p2, address p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(string,bool,bool,address)`.\\n mstore(0x00, 0x7190a529)\\n mstore(0x20, 0x80)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n writeString(0xa0, p0)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(bytes32 p0, bool p1, bool p2, bool p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(string,bool,bool,bool)`.\\n mstore(0x00, 0x895af8c5)\\n mstore(0x20, 0x80)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n writeString(0xa0, p0)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(bytes32 p0, bool p1, bool p2, uint256 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(string,bool,bool,uint256)`.\\n mstore(0x00, 0x8e3f78a9)\\n mstore(0x20, 0x80)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n writeString(0xa0, p0)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(bytes32 p0, bool p1, bool p2, bytes32 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n // Selector of `log(string,bool,bool,string)`.\\n mstore(0x00, 0x9d22d5dd)\\n mstore(0x20, 0x80)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, 0xc0)\\n writeString(0xa0, p0)\\n writeString(0xe0, p3)\\n }\\n _sendLogPayload(0x1c, 0x104);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n }\\n }\\n\\n function log(bytes32 p0, bool p1, uint256 p2, address p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(string,bool,uint256,address)`.\\n mstore(0x00, 0x935e09bf)\\n mstore(0x20, 0x80)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n writeString(0xa0, p0)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(bytes32 p0, bool p1, uint256 p2, bool p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(string,bool,uint256,bool)`.\\n mstore(0x00, 0x8af7cf8a)\\n mstore(0x20, 0x80)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n writeString(0xa0, p0)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(bytes32 p0, bool p1, uint256 p2, uint256 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(string,bool,uint256,uint256)`.\\n mstore(0x00, 0x64b5bb67)\\n mstore(0x20, 0x80)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n writeString(0xa0, p0)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(bytes32 p0, bool p1, uint256 p2, bytes32 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n // Selector of `log(string,bool,uint256,string)`.\\n mstore(0x00, 0x742d6ee7)\\n mstore(0x20, 0x80)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, 0xc0)\\n writeString(0xa0, p0)\\n writeString(0xe0, p3)\\n }\\n _sendLogPayload(0x1c, 0x104);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n }\\n }\\n\\n function log(bytes32 p0, bool p1, bytes32 p2, address p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n // Selector of `log(string,bool,string,address)`.\\n mstore(0x00, 0xe0625b29)\\n mstore(0x20, 0x80)\\n mstore(0x40, p1)\\n mstore(0x60, 0xc0)\\n mstore(0x80, p3)\\n writeString(0xa0, p0)\\n writeString(0xe0, p2)\\n }\\n _sendLogPayload(0x1c, 0x104);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n }\\n }\\n\\n function log(bytes32 p0, bool p1, bytes32 p2, bool p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n // Selector of `log(string,bool,string,bool)`.\\n mstore(0x00, 0x3f8a701d)\\n mstore(0x20, 0x80)\\n mstore(0x40, p1)\\n mstore(0x60, 0xc0)\\n mstore(0x80, p3)\\n writeString(0xa0, p0)\\n writeString(0xe0, p2)\\n }\\n _sendLogPayload(0x1c, 0x104);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n }\\n }\\n\\n function log(bytes32 p0, bool p1, bytes32 p2, uint256 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n // Selector of `log(string,bool,string,uint256)`.\\n mstore(0x00, 0x24f91465)\\n mstore(0x20, 0x80)\\n mstore(0x40, p1)\\n mstore(0x60, 0xc0)\\n mstore(0x80, p3)\\n writeString(0xa0, p0)\\n writeString(0xe0, p2)\\n }\\n _sendLogPayload(0x1c, 0x104);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n }\\n }\\n\\n function log(bytes32 p0, bool p1, bytes32 p2, bytes32 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n bytes32 m9;\\n bytes32 m10;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n m9 := mload(0x120)\\n m10 := mload(0x140)\\n // Selector of `log(string,bool,string,string)`.\\n mstore(0x00, 0xa826caeb)\\n mstore(0x20, 0x80)\\n mstore(0x40, p1)\\n mstore(0x60, 0xc0)\\n mstore(0x80, 0x100)\\n writeString(0xa0, p0)\\n writeString(0xe0, p2)\\n writeString(0x120, p3)\\n }\\n _sendLogPayload(0x1c, 0x144);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n mstore(0x120, m9)\\n mstore(0x140, m10)\\n }\\n }\\n\\n function log(bytes32 p0, uint256 p1, address p2, address p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(string,uint256,address,address)`.\\n mstore(0x00, 0x5ea2b7ae)\\n mstore(0x20, 0x80)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n writeString(0xa0, p0)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(bytes32 p0, uint256 p1, address p2, bool p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(string,uint256,address,bool)`.\\n mstore(0x00, 0x82112a42)\\n mstore(0x20, 0x80)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n writeString(0xa0, p0)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(bytes32 p0, uint256 p1, address p2, uint256 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(string,uint256,address,uint256)`.\\n mstore(0x00, 0x4f04fdc6)\\n mstore(0x20, 0x80)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n writeString(0xa0, p0)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(bytes32 p0, uint256 p1, address p2, bytes32 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n // Selector of `log(string,uint256,address,string)`.\\n mstore(0x00, 0x9ffb2f93)\\n mstore(0x20, 0x80)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, 0xc0)\\n writeString(0xa0, p0)\\n writeString(0xe0, p3)\\n }\\n _sendLogPayload(0x1c, 0x104);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n }\\n }\\n\\n function log(bytes32 p0, uint256 p1, bool p2, address p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(string,uint256,bool,address)`.\\n mstore(0x00, 0xe0e95b98)\\n mstore(0x20, 0x80)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n writeString(0xa0, p0)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(bytes32 p0, uint256 p1, bool p2, bool p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(string,uint256,bool,bool)`.\\n mstore(0x00, 0x354c36d6)\\n mstore(0x20, 0x80)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n writeString(0xa0, p0)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(bytes32 p0, uint256 p1, bool p2, uint256 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(string,uint256,bool,uint256)`.\\n mstore(0x00, 0xe41b6f6f)\\n mstore(0x20, 0x80)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n writeString(0xa0, p0)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(bytes32 p0, uint256 p1, bool p2, bytes32 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n // Selector of `log(string,uint256,bool,string)`.\\n mstore(0x00, 0xabf73a98)\\n mstore(0x20, 0x80)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, 0xc0)\\n writeString(0xa0, p0)\\n writeString(0xe0, p3)\\n }\\n _sendLogPayload(0x1c, 0x104);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n }\\n }\\n\\n function log(bytes32 p0, uint256 p1, uint256 p2, address p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(string,uint256,uint256,address)`.\\n mstore(0x00, 0xe21de278)\\n mstore(0x20, 0x80)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n writeString(0xa0, p0)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(bytes32 p0, uint256 p1, uint256 p2, bool p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(string,uint256,uint256,bool)`.\\n mstore(0x00, 0x7626db92)\\n mstore(0x20, 0x80)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n writeString(0xa0, p0)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(bytes32 p0, uint256 p1, uint256 p2, uint256 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(string,uint256,uint256,uint256)`.\\n mstore(0x00, 0xa7a87853)\\n mstore(0x20, 0x80)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n writeString(0xa0, p0)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(bytes32 p0, uint256 p1, uint256 p2, bytes32 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n // Selector of `log(string,uint256,uint256,string)`.\\n mstore(0x00, 0x854b3496)\\n mstore(0x20, 0x80)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, 0xc0)\\n writeString(0xa0, p0)\\n writeString(0xe0, p3)\\n }\\n _sendLogPayload(0x1c, 0x104);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n }\\n }\\n\\n function log(bytes32 p0, uint256 p1, bytes32 p2, address p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n // Selector of `log(string,uint256,string,address)`.\\n mstore(0x00, 0x7c4632a4)\\n mstore(0x20, 0x80)\\n mstore(0x40, p1)\\n mstore(0x60, 0xc0)\\n mstore(0x80, p3)\\n writeString(0xa0, p0)\\n writeString(0xe0, p2)\\n }\\n _sendLogPayload(0x1c, 0x104);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n }\\n }\\n\\n function log(bytes32 p0, uint256 p1, bytes32 p2, bool p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n // Selector of `log(string,uint256,string,bool)`.\\n mstore(0x00, 0x7d24491d)\\n mstore(0x20, 0x80)\\n mstore(0x40, p1)\\n mstore(0x60, 0xc0)\\n mstore(0x80, p3)\\n writeString(0xa0, p0)\\n writeString(0xe0, p2)\\n }\\n _sendLogPayload(0x1c, 0x104);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n }\\n }\\n\\n function log(bytes32 p0, uint256 p1, bytes32 p2, uint256 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n // Selector of `log(string,uint256,string,uint256)`.\\n mstore(0x00, 0xc67ea9d1)\\n mstore(0x20, 0x80)\\n mstore(0x40, p1)\\n mstore(0x60, 0xc0)\\n mstore(0x80, p3)\\n writeString(0xa0, p0)\\n writeString(0xe0, p2)\\n }\\n _sendLogPayload(0x1c, 0x104);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n }\\n }\\n\\n function log(bytes32 p0, uint256 p1, bytes32 p2, bytes32 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n bytes32 m9;\\n bytes32 m10;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n m9 := mload(0x120)\\n m10 := mload(0x140)\\n // Selector of `log(string,uint256,string,string)`.\\n mstore(0x00, 0x5ab84e1f)\\n mstore(0x20, 0x80)\\n mstore(0x40, p1)\\n mstore(0x60, 0xc0)\\n mstore(0x80, 0x100)\\n writeString(0xa0, p0)\\n writeString(0xe0, p2)\\n writeString(0x120, p3)\\n }\\n _sendLogPayload(0x1c, 0x144);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n mstore(0x120, m9)\\n mstore(0x140, m10)\\n }\\n }\\n\\n function log(bytes32 p0, bytes32 p1, address p2, address p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n // Selector of `log(string,string,address,address)`.\\n mstore(0x00, 0x439c7bef)\\n mstore(0x20, 0x80)\\n mstore(0x40, 0xc0)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n writeString(0xa0, p0)\\n writeString(0xe0, p1)\\n }\\n _sendLogPayload(0x1c, 0x104);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n }\\n }\\n\\n function log(bytes32 p0, bytes32 p1, address p2, bool p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n // Selector of `log(string,string,address,bool)`.\\n mstore(0x00, 0x5ccd4e37)\\n mstore(0x20, 0x80)\\n mstore(0x40, 0xc0)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n writeString(0xa0, p0)\\n writeString(0xe0, p1)\\n }\\n _sendLogPayload(0x1c, 0x104);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n }\\n }\\n\\n function log(bytes32 p0, bytes32 p1, address p2, uint256 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n // Selector of `log(string,string,address,uint256)`.\\n mstore(0x00, 0x7cc3c607)\\n mstore(0x20, 0x80)\\n mstore(0x40, 0xc0)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n writeString(0xa0, p0)\\n writeString(0xe0, p1)\\n }\\n _sendLogPayload(0x1c, 0x104);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n }\\n }\\n\\n function log(bytes32 p0, bytes32 p1, address p2, bytes32 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n bytes32 m9;\\n bytes32 m10;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n m9 := mload(0x120)\\n m10 := mload(0x140)\\n // Selector of `log(string,string,address,string)`.\\n mstore(0x00, 0xeb1bff80)\\n mstore(0x20, 0x80)\\n mstore(0x40, 0xc0)\\n mstore(0x60, p2)\\n mstore(0x80, 0x100)\\n writeString(0xa0, p0)\\n writeString(0xe0, p1)\\n writeString(0x120, p3)\\n }\\n _sendLogPayload(0x1c, 0x144);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n mstore(0x120, m9)\\n mstore(0x140, m10)\\n }\\n }\\n\\n function log(bytes32 p0, bytes32 p1, bool p2, address p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n // Selector of `log(string,string,bool,address)`.\\n mstore(0x00, 0xc371c7db)\\n mstore(0x20, 0x80)\\n mstore(0x40, 0xc0)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n writeString(0xa0, p0)\\n writeString(0xe0, p1)\\n }\\n _sendLogPayload(0x1c, 0x104);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n }\\n }\\n\\n function log(bytes32 p0, bytes32 p1, bool p2, bool p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n // Selector of `log(string,string,bool,bool)`.\\n mstore(0x00, 0x40785869)\\n mstore(0x20, 0x80)\\n mstore(0x40, 0xc0)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n writeString(0xa0, p0)\\n writeString(0xe0, p1)\\n }\\n _sendLogPayload(0x1c, 0x104);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n }\\n }\\n\\n function log(bytes32 p0, bytes32 p1, bool p2, uint256 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n // Selector of `log(string,string,bool,uint256)`.\\n mstore(0x00, 0xd6aefad2)\\n mstore(0x20, 0x80)\\n mstore(0x40, 0xc0)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n writeString(0xa0, p0)\\n writeString(0xe0, p1)\\n }\\n _sendLogPayload(0x1c, 0x104);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n }\\n }\\n\\n function log(bytes32 p0, bytes32 p1, bool p2, bytes32 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n bytes32 m9;\\n bytes32 m10;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n m9 := mload(0x120)\\n m10 := mload(0x140)\\n // Selector of `log(string,string,bool,string)`.\\n mstore(0x00, 0x5e84b0ea)\\n mstore(0x20, 0x80)\\n mstore(0x40, 0xc0)\\n mstore(0x60, p2)\\n mstore(0x80, 0x100)\\n writeString(0xa0, p0)\\n writeString(0xe0, p1)\\n writeString(0x120, p3)\\n }\\n _sendLogPayload(0x1c, 0x144);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n mstore(0x120, m9)\\n mstore(0x140, m10)\\n }\\n }\\n\\n function log(bytes32 p0, bytes32 p1, uint256 p2, address p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n // Selector of `log(string,string,uint256,address)`.\\n mstore(0x00, 0x1023f7b2)\\n mstore(0x20, 0x80)\\n mstore(0x40, 0xc0)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n writeString(0xa0, p0)\\n writeString(0xe0, p1)\\n }\\n _sendLogPayload(0x1c, 0x104);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n }\\n }\\n\\n function log(bytes32 p0, bytes32 p1, uint256 p2, bool p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n // Selector of `log(string,string,uint256,bool)`.\\n mstore(0x00, 0xc3a8a654)\\n mstore(0x20, 0x80)\\n mstore(0x40, 0xc0)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n writeString(0xa0, p0)\\n writeString(0xe0, p1)\\n }\\n _sendLogPayload(0x1c, 0x104);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n }\\n }\\n\\n function log(bytes32 p0, bytes32 p1, uint256 p2, uint256 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n // Selector of `log(string,string,uint256,uint256)`.\\n mstore(0x00, 0xf45d7d2c)\\n mstore(0x20, 0x80)\\n mstore(0x40, 0xc0)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n writeString(0xa0, p0)\\n writeString(0xe0, p1)\\n }\\n _sendLogPayload(0x1c, 0x104);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n }\\n }\\n\\n function log(bytes32 p0, bytes32 p1, uint256 p2, bytes32 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n bytes32 m9;\\n bytes32 m10;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n m9 := mload(0x120)\\n m10 := mload(0x140)\\n // Selector of `log(string,string,uint256,string)`.\\n mstore(0x00, 0x5d1a971a)\\n mstore(0x20, 0x80)\\n mstore(0x40, 0xc0)\\n mstore(0x60, p2)\\n mstore(0x80, 0x100)\\n writeString(0xa0, p0)\\n writeString(0xe0, p1)\\n writeString(0x120, p3)\\n }\\n _sendLogPayload(0x1c, 0x144);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n mstore(0x120, m9)\\n mstore(0x140, m10)\\n }\\n }\\n\\n function log(bytes32 p0, bytes32 p1, bytes32 p2, address p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n bytes32 m9;\\n bytes32 m10;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n m9 := mload(0x120)\\n m10 := mload(0x140)\\n // Selector of `log(string,string,string,address)`.\\n mstore(0x00, 0x6d572f44)\\n mstore(0x20, 0x80)\\n mstore(0x40, 0xc0)\\n mstore(0x60, 0x100)\\n mstore(0x80, p3)\\n writeString(0xa0, p0)\\n writeString(0xe0, p1)\\n writeString(0x120, p2)\\n }\\n _sendLogPayload(0x1c, 0x144);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n mstore(0x120, m9)\\n mstore(0x140, m10)\\n }\\n }\\n\\n function log(bytes32 p0, bytes32 p1, bytes32 p2, bool p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n bytes32 m9;\\n bytes32 m10;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n m9 := mload(0x120)\\n m10 := mload(0x140)\\n // Selector of `log(string,string,string,bool)`.\\n mstore(0x00, 0x2c1754ed)\\n mstore(0x20, 0x80)\\n mstore(0x40, 0xc0)\\n mstore(0x60, 0x100)\\n mstore(0x80, p3)\\n writeString(0xa0, p0)\\n writeString(0xe0, p1)\\n writeString(0x120, p2)\\n }\\n _sendLogPayload(0x1c, 0x144);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n mstore(0x120, m9)\\n mstore(0x140, m10)\\n }\\n }\\n\\n function log(bytes32 p0, bytes32 p1, bytes32 p2, uint256 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n bytes32 m9;\\n bytes32 m10;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n m9 := mload(0x120)\\n m10 := mload(0x140)\\n // Selector of `log(string,string,string,uint256)`.\\n mstore(0x00, 0x8eafb02b)\\n mstore(0x20, 0x80)\\n mstore(0x40, 0xc0)\\n mstore(0x60, 0x100)\\n mstore(0x80, p3)\\n writeString(0xa0, p0)\\n writeString(0xe0, p1)\\n writeString(0x120, p2)\\n }\\n _sendLogPayload(0x1c, 0x144);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n mstore(0x120, m9)\\n mstore(0x140, m10)\\n }\\n }\\n\\n function log(bytes32 p0, bytes32 p1, bytes32 p2, bytes32 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n bytes32 m9;\\n bytes32 m10;\\n bytes32 m11;\\n bytes32 m12;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n m9 := mload(0x120)\\n m10 := mload(0x140)\\n m11 := mload(0x160)\\n m12 := mload(0x180)\\n // Selector of `log(string,string,string,string)`.\\n mstore(0x00, 0xde68f20a)\\n mstore(0x20, 0x80)\\n mstore(0x40, 0xc0)\\n mstore(0x60, 0x100)\\n mstore(0x80, 0x140)\\n writeString(0xa0, p0)\\n writeString(0xe0, p1)\\n writeString(0x120, p2)\\n writeString(0x160, p3)\\n }\\n _sendLogPayload(0x1c, 0x184);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n mstore(0x120, m9)\\n mstore(0x140, m10)\\n mstore(0x160, m11)\\n mstore(0x180, m12)\\n }\\n }\\n}\\n\",\"keccak256\":\"0xbef9786cb49d3eade757bad87568c49c8c8f35721f0193c95ffb055d9e466e11\",\"license\":\"MIT\"},\"scripts/FetchChainInfo.s.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\nimport { Script } from \\\"forge-std/Script.sol\\\";\\nimport { GameTypes, GameType } from \\\"src/dispute/lib/Types.sol\\\";\\n\\n/// @notice Contains getters for arbitrary methods from all L1 contracts, including legacy getters\\n/// that have since been deprecated.\\ninterface IFetcher {\\n function guardian() external view returns (address);\\n function GUARDIAN() external view returns (address);\\n function systemConfig() external view returns (address);\\n function SYSTEM_CONFIG() external view returns (address);\\n function disputeGameFactory() external view returns (address);\\n function ethLockbox() external view returns (address);\\n function superchainConfig() external view returns (address);\\n function messenger() external view returns (address);\\n function addressManager() external view returns (address);\\n function PORTAL() external view returns (address);\\n function portal() external view returns (address);\\n function l1ERC721Bridge() external view returns (address);\\n function optimismMintableERC20Factory() external view returns (address);\\n function gameImpls(GameType _gameType) external view returns (address);\\n function respectedGameType() external view returns (GameType);\\n function anchorStateRegistry() external view returns (address);\\n function L2_ORACLE() external view returns (address);\\n function l2Oracle() external view returns (address);\\n function vm() external view returns (address);\\n function oracle() external view returns (address);\\n function challenger() external view returns (address);\\n function proposer() external view returns (address);\\n function PROPOSER() external view returns (address);\\n function batcherHash() external view returns (bytes32);\\n function admin() external view returns (address);\\n function owner() external view returns (address);\\n function unsafeBlockSigner() external view returns (address);\\n function weth() external view returns (address);\\n}\\n\\ncontract FetchChainInfoInput {\\n address internal _systemConfigProxy;\\n address internal _l1StandardBridgeProxy;\\n\\n function set(bytes4 _sel, address _addr) public {\\n require(_addr != address(0), \\\"FetchChainInfoInput: cannot set zero address\\\");\\n if (_sel == this.systemConfigProxy.selector) _systemConfigProxy = _addr;\\n else if (_sel == this.l1StandardBridgeProxy.selector) _l1StandardBridgeProxy = _addr;\\n else revert(\\\"FetchChainInfoInput: unknown selector\\\");\\n }\\n\\n function systemConfigProxy() public view returns (address) {\\n require(_systemConfigProxy != address(0), \\\"FetchChainInfoInput: systemConfigProxy not set\\\");\\n return _systemConfigProxy;\\n }\\n\\n function l1StandardBridgeProxy() public view returns (address) {\\n require(_l1StandardBridgeProxy != address(0), \\\"FetchChainInfoInput: l1StandardBridgeProxy not set\\\");\\n return _l1StandardBridgeProxy;\\n }\\n}\\n\\ncontract FetchChainInfoOutput {\\n // contract addresses\\n // - SuperchainContracts\\n address internal _superchainConfigProxy;\\n // - ImplementationsContracts\\n address internal _mipsImpl;\\n address internal _preimageOracleImpl;\\n // - OpChainContracts\\n address internal _addressManagerImpl;\\n address internal _ethLockboxProxy;\\n address internal _l1CrossDomainMessengerProxy;\\n address internal _l1Erc721BridgeProxy;\\n address internal _l1StandardBridgeProxy;\\n address internal _l2OutputOracleProxy;\\n address internal _optimismMintableErc20FactoryProxy;\\n address internal _optimismPortalProxy;\\n address internal _systemConfigProxy;\\n address internal _opChainProxyAdminImpl;\\n address internal _anchorStateRegistryProxy;\\n address internal _delayedWethPermissionedGameProxy;\\n address internal _delayedWethPermissionlessGameProxy;\\n address internal _disputeGameFactoryProxy;\\n address internal _faultDisputeGameImpl;\\n address internal _permissionedDisputeGameImpl;\\n\\n // roles\\n address internal _systemConfigOwner;\\n address internal _opChainProxyAdminOwner;\\n address internal _opChainGuardian;\\n address internal _challenger;\\n address internal _proposer;\\n address internal _unsafeBlockSigner;\\n address internal _batchSubmitter;\\n\\n // fault proof status\\n bool internal _permissioned;\\n bool internal _permissionless;\\n GameType internal _respectedGameType;\\n\\n function set(bytes4 _sel, address _addr) public {\\n // SuperchainContracts\\n if (_sel == this.superchainConfigProxy.selector) _superchainConfigProxy = _addr;\\n // - ImplementationsContracts\\n else if (_sel == this.mipsImpl.selector) _mipsImpl = _addr;\\n else if (_sel == this.preimageOracleImpl.selector) _preimageOracleImpl = _addr;\\n // - OpChainContracts\\n else if (_sel == this.addressManagerImpl.selector) _addressManagerImpl = _addr;\\n else if (_sel == this.ethLockboxProxy.selector) _ethLockboxProxy = _addr;\\n else if (_sel == this.l1CrossDomainMessengerProxy.selector) _l1CrossDomainMessengerProxy = _addr;\\n else if (_sel == this.l1Erc721BridgeProxy.selector) _l1Erc721BridgeProxy = _addr;\\n else if (_sel == this.l1StandardBridgeProxy.selector) _l1StandardBridgeProxy = _addr;\\n else if (_sel == this.l2OutputOracleProxy.selector) _l2OutputOracleProxy = _addr;\\n else if (_sel == this.optimismMintableErc20FactoryProxy.selector) _optimismMintableErc20FactoryProxy = _addr;\\n else if (_sel == this.optimismPortalProxy.selector) _optimismPortalProxy = _addr;\\n else if (_sel == this.systemConfigProxy.selector) _systemConfigProxy = _addr;\\n else if (_sel == this.opChainProxyAdminImpl.selector) _opChainProxyAdminImpl = _addr;\\n else if (_sel == this.anchorStateRegistryProxy.selector) _anchorStateRegistryProxy = _addr;\\n else if (_sel == this.delayedWethPermissionedGameProxy.selector) _delayedWethPermissionedGameProxy = _addr;\\n else if (_sel == this.delayedWethPermissionlessGameProxy.selector) _delayedWethPermissionlessGameProxy = _addr;\\n else if (_sel == this.disputeGameFactoryProxy.selector) _disputeGameFactoryProxy = _addr;\\n else if (_sel == this.faultDisputeGameImpl.selector) _faultDisputeGameImpl = _addr;\\n else if (_sel == this.permissionedDisputeGameImpl.selector) _permissionedDisputeGameImpl = _addr;\\n // roles\\n else if (_sel == this.systemConfigOwner.selector) _systemConfigOwner = _addr;\\n else if (_sel == this.opChainProxyAdminOwner.selector) _opChainProxyAdminOwner = _addr;\\n else if (_sel == this.opChainGuardian.selector) _opChainGuardian = _addr;\\n else if (_sel == this.challenger.selector) _challenger = _addr;\\n else if (_sel == this.proposer.selector) _proposer = _addr;\\n else if (_sel == this.unsafeBlockSigner.selector) _unsafeBlockSigner = _addr;\\n else if (_sel == this.batchSubmitter.selector) _batchSubmitter = _addr;\\n else revert(\\\"FetchChainInfoOutput: unknown address selector test\\\");\\n }\\n\\n function set(bytes4 _sel, bool _bool) public {\\n if (_sel == this.permissioned.selector) _permissioned = _bool;\\n else if (_sel == this.permissionless.selector) _permissionless = _bool;\\n else revert(\\\"FetchChainInfoOutput: unknown bool selector\\\");\\n }\\n\\n function set(bytes4 _sel, GameType _gameType) public {\\n if (_sel == this.respectedGameType.selector) _respectedGameType = _gameType;\\n else revert(\\\"FetchChainInfoOutput: unknown GameType selector\\\");\\n }\\n\\n function addressManagerImpl() public view returns (address) {\\n require(_addressManagerImpl != address(0), \\\"FetchChainInfoOutput: addressManagerImpl not set\\\");\\n return _addressManagerImpl;\\n }\\n\\n function ethLockboxProxy() public view returns (address) {\\n return _ethLockboxProxy;\\n }\\n\\n function l1CrossDomainMessengerProxy() public view returns (address) {\\n require(_l1CrossDomainMessengerProxy != address(0), \\\"FetchChainInfoOutput: l1CrossDomainMessengerProxy not set\\\");\\n return _l1CrossDomainMessengerProxy;\\n }\\n\\n function l1Erc721BridgeProxy() public view returns (address) {\\n require(_l1Erc721BridgeProxy != address(0), \\\"FetchChainInfoOutput: l1Erc721BridgeProxy not set\\\");\\n return _l1Erc721BridgeProxy;\\n }\\n\\n function l1StandardBridgeProxy() public view returns (address) {\\n require(_l1StandardBridgeProxy != address(0), \\\"FetchChainInfoOutput: l1StandardBridgeProxy not set\\\");\\n return _l1StandardBridgeProxy;\\n }\\n\\n function l2OutputOracleProxy() public view returns (address) {\\n require(_l2OutputOracleProxy != address(0), \\\"FetchChainInfoOutput: l2OutputOracleProxy not set\\\");\\n return _l2OutputOracleProxy;\\n }\\n\\n function optimismMintableErc20FactoryProxy() public view returns (address) {\\n require(\\n _optimismMintableErc20FactoryProxy != address(0),\\n \\\"FetchChainInfoOutput: optimismMintableErc20FactoryProxy not set\\\"\\n );\\n return _optimismMintableErc20FactoryProxy;\\n }\\n\\n function optimismPortalProxy() public view returns (address) {\\n require(_optimismPortalProxy != address(0), \\\"FetchChainInfoOutput: optimismPortalProxy not set\\\");\\n return _optimismPortalProxy;\\n }\\n\\n function systemConfigProxy() public view returns (address) {\\n require(_systemConfigProxy != address(0), \\\"FetchChainInfoOutput: systemConfigProxy not set\\\");\\n return _systemConfigProxy;\\n }\\n\\n function opChainProxyAdminImpl() public view returns (address) {\\n require(_opChainProxyAdminImpl != address(0), \\\"FetchChainInfoOutput: opChainProxyAdminImpl not set\\\");\\n return _opChainProxyAdminImpl;\\n }\\n\\n function superchainConfigProxy() public view returns (address) {\\n require(_superchainConfigProxy != address(0), \\\"FetchChainInfoOutput: superchainConfigProxy not set\\\");\\n return _superchainConfigProxy;\\n }\\n\\n function anchorStateRegistryProxy() public view returns (address) {\\n require(_anchorStateRegistryProxy != address(0), \\\"FetchChainInfoOutput: anchorStateRegistryProxy not set\\\");\\n return _anchorStateRegistryProxy;\\n }\\n\\n function delayedWethPermissionedGameProxy() public view returns (address) {\\n return _delayedWethPermissionedGameProxy;\\n }\\n\\n function delayedWethPermissionlessGameProxy() public view returns (address) {\\n return _delayedWethPermissionlessGameProxy;\\n }\\n\\n function disputeGameFactoryProxy() public view returns (address) {\\n return _disputeGameFactoryProxy;\\n }\\n\\n function faultDisputeGameImpl() public view returns (address) {\\n require(_faultDisputeGameImpl != address(0), \\\"FetchChainInfoOutput: faultDisputeGameImpl not set\\\");\\n return _faultDisputeGameImpl;\\n }\\n\\n function mipsImpl() public view returns (address) {\\n require(_mipsImpl != address(0), \\\"FetchChainInfoOutput: mipsImpl not set\\\");\\n return _mipsImpl;\\n }\\n\\n function permissionedDisputeGameImpl() public view returns (address) {\\n require(_permissionedDisputeGameImpl != address(0), \\\"FetchChainInfoOutput: permissionedDisputeGameImpl not set\\\");\\n return _permissionedDisputeGameImpl;\\n }\\n\\n function preimageOracleImpl() public view returns (address) {\\n require(_preimageOracleImpl != address(0), \\\"FetchChainInfoOutput: preimageOracleImpl not set\\\");\\n return _preimageOracleImpl;\\n }\\n\\n function systemConfigOwner() public view returns (address) {\\n require(_systemConfigOwner != address(0), \\\"FetchChainInfoOutput: systemConfigOwner not set\\\");\\n return _systemConfigOwner;\\n }\\n\\n function opChainProxyAdminOwner() public view returns (address) {\\n require(_opChainProxyAdminOwner != address(0), \\\"FetchChainInfoOutput: opChainProxyAdminOwner not set\\\");\\n return _opChainProxyAdminOwner;\\n }\\n\\n function opChainGuardian() public view returns (address) {\\n require(_opChainGuardian != address(0), \\\"FetchChainInfoOutput: opChainGuardian not set\\\");\\n return _opChainGuardian;\\n }\\n\\n function challenger() public view returns (address) {\\n require(_challenger != address(0), \\\"FetchChainInfoOutput: challenger not set\\\");\\n return _challenger;\\n }\\n\\n function proposer() public view returns (address) {\\n require(_proposer != address(0), \\\"FetchChainInfoOutput: proposer not set\\\");\\n return _proposer;\\n }\\n\\n function unsafeBlockSigner() public view returns (address) {\\n require(_unsafeBlockSigner != address(0), \\\"FetchChainInfoOutput: unsafeBlockSigner not set\\\");\\n return _unsafeBlockSigner;\\n }\\n\\n function batchSubmitter() public view returns (address) {\\n require(_batchSubmitter != address(0), \\\"FetchChainInfoOutput: batchSubmitter not set\\\");\\n return _batchSubmitter;\\n }\\n\\n function permissioned() public view returns (bool) {\\n return _permissioned;\\n }\\n\\n function permissionless() public view returns (bool) {\\n return _permissionless;\\n }\\n\\n function respectedGameType() public view returns (GameType) {\\n return _respectedGameType;\\n }\\n}\\n\\ncontract FetchChainInfo is Script {\\n function run(FetchChainInfoInput _fi, FetchChainInfoOutput _fo) public {\\n _processSystemConfig(_fi, _fo);\\n _processMessengerAndPortal(_fi, _fo);\\n _processFaultProofs(_fo);\\n }\\n\\n function _processSystemConfig(FetchChainInfoInput _fi, FetchChainInfoOutput _fo) internal {\\n address systemConfigProxy = _fi.systemConfigProxy();\\n _fo.set(_fo.systemConfigProxy.selector, systemConfigProxy);\\n\\n address systemConfigOwner = IFetcher(systemConfigProxy).owner();\\n _fo.set(_fo.systemConfigOwner.selector, systemConfigOwner);\\n\\n address unsafeBlockSigner = IFetcher(systemConfigProxy).unsafeBlockSigner();\\n _fo.set(_fo.unsafeBlockSigner.selector, unsafeBlockSigner);\\n\\n address batchSubmitter = _getBatchSubmitter(systemConfigProxy);\\n _fo.set(_fo.batchSubmitter.selector, batchSubmitter);\\n\\n address opChainProxyAdminImpl = _getProxyAdmin(systemConfigProxy);\\n _fo.set(_fo.opChainProxyAdminImpl.selector, opChainProxyAdminImpl);\\n\\n address opChainProxyAdminOwner = IFetcher(opChainProxyAdminImpl).owner();\\n _fo.set(_fo.opChainProxyAdminOwner.selector, opChainProxyAdminOwner);\\n\\n address l1Erc721BridgeProxy = _getL1ERC721BridgeProxy(systemConfigProxy);\\n _fo.set(_fo.l1Erc721BridgeProxy.selector, l1Erc721BridgeProxy);\\n\\n address optimismMintableErc20FactoryProxy = _getOptimismMintableERC20FactoryProxy(systemConfigProxy);\\n _fo.set(_fo.optimismMintableErc20FactoryProxy.selector, optimismMintableErc20FactoryProxy);\\n }\\n\\n function _processMessengerAndPortal(FetchChainInfoInput _fi, FetchChainInfoOutput _fo) internal {\\n address l1StandardBridgeProxy = _fi.l1StandardBridgeProxy();\\n _fo.set(_fo.l1StandardBridgeProxy.selector, l1StandardBridgeProxy);\\n\\n address l1CrossDomainMessengerProxy = IFetcher(l1StandardBridgeProxy).messenger();\\n _fo.set(_fo.l1CrossDomainMessengerProxy.selector, l1CrossDomainMessengerProxy);\\n\\n address addressManagerImpl = _getAddressManager(l1CrossDomainMessengerProxy);\\n _fo.set(_fo.addressManagerImpl.selector, addressManagerImpl);\\n\\n address optimismPortalProxy = _getOptimismPortalProxy(l1CrossDomainMessengerProxy);\\n _fo.set(_fo.optimismPortalProxy.selector, optimismPortalProxy);\\n\\n address opChainGuardian = _getGuardian(optimismPortalProxy);\\n _fo.set(_fo.opChainGuardian.selector, opChainGuardian);\\n\\n address ethLockboxProxy = _getEthLockboxProxy(optimismPortalProxy);\\n _fo.set(_fo.ethLockboxProxy.selector, ethLockboxProxy);\\n\\n address superchainConfigProxy = _getSuperchainConfigProxy(optimismPortalProxy);\\n _fo.set(_fo.superchainConfigProxy.selector, superchainConfigProxy);\\n }\\n\\n function _processFaultProofs(FetchChainInfoOutput _fo) internal {\\n address systemConfigProxy = _fo.systemConfigProxy();\\n address optimismPortalProxy = _fo.optimismPortalProxy();\\n\\n try IFetcher(optimismPortalProxy).respectedGameType() returns (GameType gameType_) {\\n _fo.set(_fo.respectedGameType.selector, gameType_);\\n } catch {\\n // default respectedGameType to uint32.max since 0 == CANNON\\n _fo.set(_fo.respectedGameType.selector, GameType.wrap(type(uint32).max));\\n address l2OutputOracleProxy;\\n try IFetcher(optimismPortalProxy).l2Oracle() returns (address l2Oracle_) {\\n l2OutputOracleProxy = l2Oracle_;\\n } catch {\\n l2OutputOracleProxy = IFetcher(optimismPortalProxy).L2_ORACLE();\\n }\\n _fo.set(_fo.l2OutputOracleProxy.selector, l2OutputOracleProxy);\\n\\n address proposer = IFetcher(l2OutputOracleProxy).PROPOSER();\\n _fo.set(_fo.proposer.selector, proposer);\\n\\n // no fault proofs installed so we're done\\n return;\\n }\\n\\n address disputeGameFactoryProxy = _getDisputeGameFactoryProxy(systemConfigProxy);\\n if (disputeGameFactoryProxy != address(0)) {\\n _fo.set(_fo.disputeGameFactoryProxy.selector, disputeGameFactoryProxy);\\n\\n address permissionedDisputeGameImpl = _getPermissionedDisputeGame(disputeGameFactoryProxy);\\n if (permissionedDisputeGameImpl != address(0)) {\\n // permissioned fault proofs installed\\n _fo.set(_fo.permissioned.selector, true);\\n _fo.set(_fo.permissionedDisputeGameImpl.selector, permissionedDisputeGameImpl);\\n\\n address challenger = IFetcher(permissionedDisputeGameImpl).challenger();\\n _fo.set(_fo.challenger.selector, challenger);\\n\\n address anchorStateRegistryProxy = IFetcher(permissionedDisputeGameImpl).anchorStateRegistry();\\n _fo.set(_fo.anchorStateRegistryProxy.selector, anchorStateRegistryProxy);\\n\\n address proposer = IFetcher(permissionedDisputeGameImpl).proposer();\\n _fo.set(_fo.proposer.selector, proposer);\\n\\n address delayedWethPermissionedGameProxy = _getDelayedWETHProxy(permissionedDisputeGameImpl);\\n _fo.set(_fo.delayedWethPermissionedGameProxy.selector, delayedWethPermissionedGameProxy);\\n\\n address mipsImpl = IFetcher(permissionedDisputeGameImpl).vm();\\n _fo.set(_fo.mipsImpl.selector, mipsImpl);\\n\\n address preimageOracleImpl = IFetcher(mipsImpl).oracle();\\n _fo.set(_fo.preimageOracleImpl.selector, preimageOracleImpl);\\n }\\n\\n address faultDisputeGameImpl = _getFaultDisputeGame(disputeGameFactoryProxy);\\n if (faultDisputeGameImpl != address(0)) {\\n // permissionless fault proofs installed\\n _fo.set(_fo.faultDisputeGameImpl.selector, faultDisputeGameImpl);\\n _fo.set(_fo.permissionless.selector, true);\\n\\n address delayedWethPermissionlessGameProxy = _getDelayedWETHProxy(faultDisputeGameImpl);\\n _fo.set(_fo.delayedWethPermissionlessGameProxy.selector, delayedWethPermissionlessGameProxy);\\n }\\n } else {\\n // some older chains have L2OutputOracle instead of DisputeGameFactory.\\n address l2OutputOracleProxy = IFetcher(optimismPortalProxy).L2_ORACLE();\\n _fo.set(_fo.l2OutputOracleProxy.selector, l2OutputOracleProxy);\\n address proposer = IFetcher(l2OutputOracleProxy).PROPOSER();\\n _fo.set(_fo.proposer.selector, proposer);\\n }\\n }\\n\\n function _getGuardian(address _portal) internal view returns (address) {\\n try IFetcher(_portal).guardian() returns (address guardian_) {\\n return guardian_;\\n } catch {\\n return IFetcher(_portal).GUARDIAN();\\n }\\n }\\n\\n function _getSystemConfigProxy(address _portal) internal view returns (address) {\\n try IFetcher(_portal).systemConfig() returns (address systemConfig_) {\\n return systemConfig_;\\n } catch {\\n return IFetcher(_portal).SYSTEM_CONFIG();\\n }\\n }\\n\\n function _getOptimismPortalProxy(address _l1CrossDomainMessengerProxy) internal view returns (address) {\\n try IFetcher(_l1CrossDomainMessengerProxy).portal() returns (address optimismPortal_) {\\n return optimismPortal_;\\n } catch {\\n return IFetcher(_l1CrossDomainMessengerProxy).PORTAL();\\n }\\n }\\n\\n function _getAddressManager(address _l1CrossDomainMessengerProxy) internal view returns (address) {\\n uint256 ADDRESS_MANAGER_MAPPING_SLOT = 1;\\n bytes32 slot = keccak256(abi.encode(_l1CrossDomainMessengerProxy, ADDRESS_MANAGER_MAPPING_SLOT));\\n return address(uint160(uint256((vm.load(_l1CrossDomainMessengerProxy, slot)))));\\n }\\n\\n function _getL1ERC721BridgeProxy(address _systemConfigProxy) internal view returns (address) {\\n try IFetcher(_systemConfigProxy).l1ERC721Bridge() returns (address l1ERC721BridgeProxy_) {\\n return l1ERC721BridgeProxy_;\\n } catch {\\n return address(0);\\n }\\n }\\n\\n function _getOptimismMintableERC20FactoryProxy(address _systemConfigProxy) internal view returns (address) {\\n try IFetcher(_systemConfigProxy).optimismMintableERC20Factory() returns (\\n address optimismMintableERC20FactoryProxy_\\n ) {\\n return optimismMintableERC20FactoryProxy_;\\n } catch {\\n return address(0);\\n }\\n }\\n\\n function _getDisputeGameFactoryProxy(address _systemConfigProxy) internal view returns (address) {\\n try IFetcher(_systemConfigProxy).disputeGameFactory() returns (address disputeGameFactoryProxy_) {\\n return disputeGameFactoryProxy_;\\n } catch {\\n // Some older chains have L2OutputOracle instead of DisputeGameFactory\\n return address(0);\\n }\\n }\\n\\n function _getSuperchainConfigProxy(address _optimismPortalProxy) internal view returns (address) {\\n try IFetcher(_optimismPortalProxy).superchainConfig() returns (address superchainConfigProxy_) {\\n return superchainConfigProxy_;\\n } catch {\\n return address(0);\\n }\\n }\\n\\n function _getFaultDisputeGame(address _disputeGameFactoryProxy) internal view returns (address) {\\n try IFetcher(_disputeGameFactoryProxy).gameImpls(GameTypes.CANNON) returns (address faultDisputeGame_) {\\n return faultDisputeGame_;\\n } catch {\\n return address(0);\\n }\\n }\\n\\n function _getPermissionedDisputeGame(address _disputeGameFactoryProxy) internal view returns (address) {\\n try IFetcher(_disputeGameFactoryProxy).gameImpls(GameTypes.PERMISSIONED_CANNON) returns (\\n address permissionedDisputeGame_\\n ) {\\n return permissionedDisputeGame_;\\n } catch {\\n return address(0);\\n }\\n }\\n\\n function _getEthLockboxProxy(address _optimismPortalProxy) internal view returns (address) {\\n try IFetcher(_optimismPortalProxy).ethLockbox() returns (address ethLockbox_) {\\n return ethLockbox_;\\n } catch {\\n return address(0);\\n }\\n }\\n\\n function _getDelayedWETHProxy(address _disputeGame) internal view returns (address) {\\n (bool ok, bytes memory data) = address(_disputeGame).staticcall(abi.encodeCall(IFetcher.weth, ()));\\n if (ok && data.length == 32) return abi.decode(data, (address));\\n else return address(0);\\n }\\n\\n function _getBatchSubmitter(address _systemConfigProxy) internal view returns (address) {\\n bytes32 batcherHash = IFetcher(_systemConfigProxy).batcherHash();\\n return address(uint160(uint256(batcherHash)));\\n }\\n\\n function _getProxyAdmin(address _systemConfigProxy) internal returns (address) {\\n vm.prank(address(0));\\n return IFetcher(_systemConfigProxy).admin();\\n }\\n}\\n\",\"keccak256\":\"0x202fb27a5a78b7d8c96c3a4ea69981dc4eeda765aa2747699ac80b8499feb709\",\"license\":\"MIT\"},\"src/dispute/lib/LibPosition.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.15;\\n\\nusing LibPosition for Position global;\\n\\n/// @notice A `Position` represents a position of a claim within the game tree.\\n/// @dev This is represented as a \\\"generalized index\\\" where the high-order bit\\n/// is the level in the tree and the remaining bits is a unique bit pattern, allowing\\n/// a unique identifier for each node in the tree. Mathematically, it is calculated\\n/// as 2^{depth} + indexAtDepth.\\ntype Position is uint128;\\n\\n/// @title LibPosition\\n/// @notice This library contains helper functions for working with the `Position` type.\\nlibrary LibPosition {\\n /// @notice the `MAX_POSITION_BITLEN` is the number of bits that the `Position` type, and the implementation of\\n /// its behavior within this library, can safely support.\\n uint8 internal constant MAX_POSITION_BITLEN = 126;\\n\\n /// @notice Computes a generalized index (2^{depth} + indexAtDepth).\\n /// @param _depth The depth of the position.\\n /// @param _indexAtDepth The index at the depth of the position.\\n /// @return position_ The computed generalized index.\\n function wrap(uint8 _depth, uint128 _indexAtDepth) internal pure returns (Position position_) {\\n assembly {\\n // gindex = 2^{_depth} + _indexAtDepth\\n position_ := add(shl(_depth, 1), _indexAtDepth)\\n }\\n }\\n\\n /// @notice Pulls the `depth` out of a `Position` type.\\n /// @param _position The generalized index to get the `depth` of.\\n /// @return depth_ The `depth` of the `position` gindex.\\n /// @custom:attribution Solady \\n function depth(Position _position) internal pure returns (uint8 depth_) {\\n // Return the most significant bit offset, which signifies the depth of the gindex.\\n assembly {\\n depth_ := or(depth_, shl(6, lt(0xffffffffffffffff, shr(depth_, _position))))\\n depth_ := or(depth_, shl(5, lt(0xffffffff, shr(depth_, _position))))\\n\\n // For the remaining 32 bits, use a De Bruijn lookup.\\n _position := shr(depth_, _position)\\n _position := or(_position, shr(1, _position))\\n _position := or(_position, shr(2, _position))\\n _position := or(_position, shr(4, _position))\\n _position := or(_position, shr(8, _position))\\n _position := or(_position, shr(16, _position))\\n\\n depth_ :=\\n or(\\n depth_,\\n byte(\\n shr(251, mul(_position, shl(224, 0x07c4acdd))),\\n 0x0009010a0d15021d0b0e10121619031e080c141c0f111807131b17061a05041f\\n )\\n )\\n }\\n }\\n\\n /// @notice Pulls the `indexAtDepth` out of a `Position` type.\\n /// The `indexAtDepth` is the left/right index of a position at a specific depth within\\n /// the binary tree, starting from index 0. For example, at gindex 2, the `depth` = 1\\n /// and the `indexAtDepth` = 0.\\n /// @param _position The generalized index to get the `indexAtDepth` of.\\n /// @return indexAtDepth_ The `indexAtDepth` of the `position` gindex.\\n function indexAtDepth(Position _position) internal pure returns (uint128 indexAtDepth_) {\\n // Return bits p_{msb-1}...p_{0}. This effectively pulls the 2^{depth} out of the gindex,\\n // leaving only the `indexAtDepth`.\\n uint256 msb = depth(_position);\\n assembly {\\n indexAtDepth_ := sub(_position, shl(msb, 1))\\n }\\n }\\n\\n /// @notice Get the left child of `_position`.\\n /// @param _position The position to get the left position of.\\n /// @return left_ The position to the left of `position`.\\n function left(Position _position) internal pure returns (Position left_) {\\n assembly {\\n left_ := shl(1, _position)\\n }\\n }\\n\\n /// @notice Get the right child of `_position`\\n /// @param _position The position to get the right position of.\\n /// @return right_ The position to the right of `position`.\\n function right(Position _position) internal pure returns (Position right_) {\\n assembly {\\n right_ := or(1, shl(1, _position))\\n }\\n }\\n\\n /// @notice Get the parent position of `_position`.\\n /// @param _position The position to get the parent position of.\\n /// @return parent_ The parent position of `position`.\\n function parent(Position _position) internal pure returns (Position parent_) {\\n assembly {\\n parent_ := shr(1, _position)\\n }\\n }\\n\\n /// @notice Get the deepest, right most gindex relative to the `position`. This is equivalent to\\n /// calling `right` on a position until the maximum depth is reached.\\n /// @param _position The position to get the relative deepest, right most gindex of.\\n /// @param _maxDepth The maximum depth of the game.\\n /// @return rightIndex_ The deepest, right most gindex relative to the `position`.\\n function rightIndex(Position _position, uint256 _maxDepth) internal pure returns (Position rightIndex_) {\\n uint256 msb = depth(_position);\\n assembly {\\n let remaining := sub(_maxDepth, msb)\\n rightIndex_ := or(shl(remaining, _position), sub(shl(remaining, 1), 1))\\n }\\n }\\n\\n /// @notice Get the deepest, right most trace index relative to the `position`. This is\\n /// equivalent to calling `right` on a position until the maximum depth is reached and\\n /// then finding its index at depth.\\n /// @param _position The position to get the relative trace index of.\\n /// @param _maxDepth The maximum depth of the game.\\n /// @return traceIndex_ The trace index relative to the `position`.\\n function traceIndex(Position _position, uint256 _maxDepth) internal pure returns (uint256 traceIndex_) {\\n uint256 msb = depth(_position);\\n assembly {\\n let remaining := sub(_maxDepth, msb)\\n traceIndex_ := sub(or(shl(remaining, _position), sub(shl(remaining, 1), 1)), shl(_maxDepth, 1))\\n }\\n }\\n\\n /// @notice Gets the position of the highest ancestor of `_position` that commits to the same\\n /// trace index.\\n /// @param _position The position to get the highest ancestor of.\\n /// @return ancestor_ The highest ancestor of `position` that commits to the same trace index.\\n function traceAncestor(Position _position) internal pure returns (Position ancestor_) {\\n // Create a field with only the lowest unset bit of `_position` set.\\n Position lsb;\\n assembly {\\n lsb := and(not(_position), add(_position, 1))\\n }\\n // Find the index of the lowest unset bit within the field.\\n uint256 msb = depth(lsb);\\n // The highest ancestor that commits to the same trace index is the original position\\n // shifted right by the index of the lowest unset bit.\\n assembly {\\n let a := shr(msb, _position)\\n // Bound the ancestor to the minimum gindex, 1.\\n ancestor_ := or(a, iszero(a))\\n }\\n }\\n\\n /// @notice Gets the position of the highest ancestor of `_position` that commits to the same\\n /// trace index, while still being below `_upperBoundExclusive`.\\n /// @param _position The position to get the highest ancestor of.\\n /// @param _upperBoundExclusive The exclusive upper depth bound, used to inform where to stop in order\\n /// to not escape a sub-tree.\\n /// @return ancestor_ The highest ancestor of `position` that commits to the same trace index.\\n function traceAncestorBounded(\\n Position _position,\\n uint256 _upperBoundExclusive\\n )\\n internal\\n pure\\n returns (Position ancestor_)\\n {\\n // This function only works for positions that are below the upper bound.\\n if (_position.depth() <= _upperBoundExclusive) {\\n assembly {\\n // Revert with `ClaimAboveSplit()`\\n mstore(0x00, 0xb34b5c22)\\n revert(0x1C, 0x04)\\n }\\n }\\n\\n // Grab the global trace ancestor.\\n ancestor_ = traceAncestor(_position);\\n\\n // If the ancestor is above or at the upper bound, shift it to be below the upper bound.\\n // This should be a special case that only covers positions that commit to the final leaf\\n // in a sub-tree.\\n if (ancestor_.depth() <= _upperBoundExclusive) {\\n ancestor_ = ancestor_.rightIndex(_upperBoundExclusive + 1);\\n }\\n }\\n\\n /// @notice Get the move position of `_position`, which is the left child of:\\n /// 1. `_position` if `_isAttack` is true.\\n /// 2. `_position | 1` if `_isAttack` is false.\\n /// @param _position The position to get the relative attack/defense position of.\\n /// @param _isAttack Whether or not the move is an attack move.\\n /// @return move_ The move position relative to `position`.\\n function move(Position _position, bool _isAttack) internal pure returns (Position move_) {\\n assembly {\\n move_ := shl(1, or(iszero(_isAttack), _position))\\n }\\n }\\n\\n /// @notice Get the value of a `Position` type in the form of the underlying uint128.\\n /// @param _position The position to get the value of.\\n /// @return raw_ The value of the `position` as a uint128 type.\\n function raw(Position _position) internal pure returns (uint128 raw_) {\\n assembly {\\n raw_ := _position\\n }\\n }\\n}\\n\",\"keccak256\":\"0x7c5f19f8f54f06de2ce1c6cdcc5c7af65ac405130a4066cdaf146ca315818241\",\"license\":\"MIT\"},\"src/dispute/lib/LibUDT.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.15;\\n\\n// Libraries\\nimport { Position } from \\\"src/dispute/lib/LibPosition.sol\\\";\\n\\nusing LibClaim for Claim global;\\nusing LibHash for Hash global;\\nusing LibDuration for Duration global;\\nusing LibClock for Clock global;\\nusing LibGameId for GameId global;\\nusing LibTimestamp for Timestamp global;\\nusing LibVMStatus for VMStatus global;\\nusing LibGameType for GameType global;\\n\\n/// @notice A `Clock` represents a packed `Duration` and `Timestamp`\\n/// @dev The packed layout of this type is as follows:\\n/// \\u250c\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u252c\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2510\\n/// \\u2502 Bits \\u2502 Value \\u2502\\n/// \\u251c\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u253c\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2524\\n/// \\u2502 [0, 64) \\u2502 Duration \\u2502\\n/// \\u2502 [64, 128) \\u2502 Timestamp \\u2502\\n/// \\u2514\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2534\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2518\\ntype Clock is uint128;\\n\\n/// @title LibClock\\n/// @notice This library contains helper functions for working with the `Clock` type.\\nlibrary LibClock {\\n /// @notice Packs a `Duration` and `Timestamp` into a `Clock` type.\\n /// @param _duration The `Duration` to pack into the `Clock` type.\\n /// @param _timestamp The `Timestamp` to pack into the `Clock` type.\\n /// @return clock_ The `Clock` containing the `_duration` and `_timestamp`.\\n function wrap(Duration _duration, Timestamp _timestamp) internal pure returns (Clock clock_) {\\n assembly {\\n clock_ := or(shl(0x40, _duration), _timestamp)\\n }\\n }\\n\\n /// @notice Pull the `Duration` out of a `Clock` type.\\n /// @param _clock The `Clock` type to pull the `Duration` out of.\\n /// @return duration_ The `Duration` pulled out of `_clock`.\\n function duration(Clock _clock) internal pure returns (Duration duration_) {\\n // Shift the high-order 64 bits into the low-order 64 bits, leaving only the `duration`.\\n assembly {\\n duration_ := shr(0x40, _clock)\\n }\\n }\\n\\n /// @notice Pull the `Timestamp` out of a `Clock` type.\\n /// @param _clock The `Clock` type to pull the `Timestamp` out of.\\n /// @return timestamp_ The `Timestamp` pulled out of `_clock`.\\n function timestamp(Clock _clock) internal pure returns (Timestamp timestamp_) {\\n // Clean the high-order 192 bits by shifting the clock left and then right again, leaving\\n // only the `timestamp`.\\n assembly {\\n timestamp_ := shr(0xC0, shl(0xC0, _clock))\\n }\\n }\\n\\n /// @notice Get the value of a `Clock` type in the form of the underlying uint128.\\n /// @param _clock The `Clock` type to get the value of.\\n /// @return clock_ The value of the `Clock` type as a uint128 type.\\n function raw(Clock _clock) internal pure returns (uint128 clock_) {\\n assembly {\\n clock_ := _clock\\n }\\n }\\n}\\n\\n/// @notice A `GameId` represents a packed 4 byte game ID, a 8 byte timestamp, and a 20 byte address.\\n/// @dev The packed layout of this type is as follows:\\n/// \\u250c\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u252c\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2510\\n/// \\u2502 Bits \\u2502 Value \\u2502\\n/// \\u251c\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u253c\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2524\\n/// \\u2502 [0, 32) \\u2502 Game Type \\u2502\\n/// \\u2502 [32, 96) \\u2502 Timestamp \\u2502\\n/// \\u2502 [96, 256) \\u2502 Address \\u2502\\n/// \\u2514\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2534\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2518\\ntype GameId is bytes32;\\n\\n/// @title LibGameId\\n/// @notice Utility functions for packing and unpacking GameIds.\\nlibrary LibGameId {\\n /// @notice Packs values into a 32 byte GameId type.\\n /// @param _gameType The game type.\\n /// @param _timestamp The timestamp of the game's creation.\\n /// @param _gameProxy The game proxy address.\\n /// @return gameId_ The packed GameId.\\n function pack(\\n GameType _gameType,\\n Timestamp _timestamp,\\n address _gameProxy\\n )\\n internal\\n pure\\n returns (GameId gameId_)\\n {\\n assembly {\\n gameId_ := or(or(shl(224, _gameType), shl(160, _timestamp)), _gameProxy)\\n }\\n }\\n\\n /// @notice Unpacks values from a 32 byte GameId type.\\n /// @param _gameId The packed GameId.\\n /// @return gameType_ The game type.\\n /// @return timestamp_ The timestamp of the game's creation.\\n /// @return gameProxy_ The game proxy address.\\n function unpack(GameId _gameId)\\n internal\\n pure\\n returns (GameType gameType_, Timestamp timestamp_, address gameProxy_)\\n {\\n assembly {\\n gameType_ := shr(224, _gameId)\\n timestamp_ := and(shr(160, _gameId), 0xFFFFFFFFFFFFFFFF)\\n gameProxy_ := and(_gameId, 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF)\\n }\\n }\\n}\\n\\n/// @notice A claim represents an MPT root representing the state of the fault proof program.\\ntype Claim is bytes32;\\n\\n/// @title LibClaim\\n/// @notice This library contains helper functions for working with the `Claim` type.\\nlibrary LibClaim {\\n /// @notice Get the value of a `Claim` type in the form of the underlying bytes32.\\n /// @param _claim The `Claim` type to get the value of.\\n /// @return claim_ The value of the `Claim` type as a bytes32 type.\\n function raw(Claim _claim) internal pure returns (bytes32 claim_) {\\n assembly {\\n claim_ := _claim\\n }\\n }\\n\\n /// @notice Hashes a claim and a position together.\\n /// @param _claim A Claim type.\\n /// @param _position The position of `claim`.\\n /// @param _challengeIndex The index of the claim being moved against.\\n /// @return claimHash_ A hash of abi.encodePacked(claim, position|challengeIndex);\\n function hashClaimPos(\\n Claim _claim,\\n Position _position,\\n uint256 _challengeIndex\\n )\\n internal\\n pure\\n returns (Hash claimHash_)\\n {\\n assembly {\\n mstore(0x00, _claim)\\n mstore(0x20, or(shl(128, _position), and(0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF, _challengeIndex)))\\n claimHash_ := keccak256(0x00, 0x40)\\n }\\n }\\n}\\n\\n/// @notice A dedicated duration type.\\n/// @dev Unit: seconds\\ntype Duration is uint64;\\n\\n/// @title LibDuration\\n/// @notice This library contains helper functions for working with the `Duration` type.\\nlibrary LibDuration {\\n /// @notice Get the value of a `Duration` type in the form of the underlying uint64.\\n /// @param _duration The `Duration` type to get the value of.\\n /// @return duration_ The value of the `Duration` type as a uint64 type.\\n function raw(Duration _duration) internal pure returns (uint64 duration_) {\\n assembly {\\n duration_ := _duration\\n }\\n }\\n}\\n\\n/// @notice A custom type for a generic hash.\\ntype Hash is bytes32;\\n\\n/// @title LibHash\\n/// @notice This library contains helper functions for working with the `Hash` type.\\nlibrary LibHash {\\n /// @notice Get the value of a `Hash` type in the form of the underlying bytes32.\\n /// @param _hash The `Hash` type to get the value of.\\n /// @return hash_ The value of the `Hash` type as a bytes32 type.\\n function raw(Hash _hash) internal pure returns (bytes32 hash_) {\\n assembly {\\n hash_ := _hash\\n }\\n }\\n}\\n\\n/// @notice A dedicated timestamp type.\\ntype Timestamp is uint64;\\n\\n/// @title LibTimestamp\\n/// @notice This library contains helper functions for working with the `Timestamp` type.\\nlibrary LibTimestamp {\\n /// @notice Get the value of a `Timestamp` type in the form of the underlying uint64.\\n /// @param _timestamp The `Timestamp` type to get the value of.\\n /// @return timestamp_ The value of the `Timestamp` type as a uint64 type.\\n function raw(Timestamp _timestamp) internal pure returns (uint64 timestamp_) {\\n assembly {\\n timestamp_ := _timestamp\\n }\\n }\\n}\\n\\n/// @notice A `VMStatus` represents the status of a VM execution.\\ntype VMStatus is uint8;\\n\\n/// @title LibVMStatus\\n/// @notice This library contains helper functions for working with the `VMStatus` type.\\nlibrary LibVMStatus {\\n /// @notice Get the value of a `VMStatus` type in the form of the underlying uint8.\\n /// @param _vmstatus The `VMStatus` type to get the value of.\\n /// @return vmstatus_ The value of the `VMStatus` type as a uint8 type.\\n function raw(VMStatus _vmstatus) internal pure returns (uint8 vmstatus_) {\\n assembly {\\n vmstatus_ := _vmstatus\\n }\\n }\\n}\\n\\n/// @notice A `GameType` represents the type of game being played.\\ntype GameType is uint32;\\n\\n/// @title LibGameType\\n/// @notice This library contains helper functions for working with the `GameType` type.\\nlibrary LibGameType {\\n /// @notice Get the value of a `GameType` type in the form of the underlying uint32.\\n /// @param _gametype The `GameType` type to get the value of.\\n /// @return gametype_ The value of the `GameType` type as a uint32 type.\\n function raw(GameType _gametype) internal pure returns (uint32 gametype_) {\\n assembly {\\n gametype_ := _gametype\\n }\\n }\\n}\\n\",\"keccak256\":\"0x41d55e9c74d979b5b797198e38449e7cef4f925e04d61f7699e9c150c4a659d3\",\"license\":\"MIT\"},\"src/dispute/lib/Types.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.15;\\n\\n// Libraries\\nimport {\\n Position,\\n Hash,\\n GameType,\\n VMStatus,\\n Timestamp,\\n Duration,\\n Clock,\\n GameId,\\n Claim,\\n LibGameId,\\n LibClock\\n} from \\\"src/dispute/lib/LibUDT.sol\\\";\\n\\n/// @notice The current status of the dispute game.\\nenum GameStatus {\\n // The game is currently in progress, and has not been resolved.\\n IN_PROGRESS,\\n // The game has concluded, and the `rootClaim` was challenged successfully.\\n CHALLENGER_WINS,\\n // The game has concluded, and the `rootClaim` could not be contested.\\n DEFENDER_WINS\\n}\\n\\n/// @notice The game's bond distribution type. Games are expected to start in the `UNDECIDED`\\n/// state, and then choose either `NORMAL` or `REFUND`.\\nenum BondDistributionMode {\\n // Bond distribution strategy has not been chosen.\\n UNDECIDED,\\n // Bonds should be distributed as normal.\\n NORMAL,\\n // Bonds should be refunded to claimants.\\n REFUND\\n}\\n\\n/// @notice Represents an L2 root and the L2 sequence number at which it was generated.\\n/// @custom:field root The output root.\\n/// @custom:field l2SequenceNumber The L2 Sequence Number ( e.g. block number / timestamp) at which the root was\\n/// generated.\\nstruct Proposal {\\n Hash root;\\n uint256 l2SequenceNumber;\\n}\\n\\n/// @title GameTypes\\n/// @notice A library that defines the IDs of games that can be played.\\nlibrary GameTypes {\\n /// @dev A dispute game type the uses the cannon vm.\\n GameType internal constant CANNON = GameType.wrap(0);\\n\\n /// @dev A permissioned dispute game type that uses the cannon vm.\\n GameType internal constant PERMISSIONED_CANNON = GameType.wrap(1);\\n\\n /// @notice A dispute game type that uses the asterisc vm.\\n GameType internal constant ASTERISC = GameType.wrap(2);\\n\\n /// @notice A dispute game type that uses the asterisc vm with Kona.\\n GameType internal constant ASTERISC_KONA = GameType.wrap(3);\\n\\n /// @notice A dispute game type that uses the cannon vm (Super Roots).\\n GameType internal constant SUPER_CANNON = GameType.wrap(4);\\n\\n /// @notice A dispute game type that uses the permissioned cannon vm (Super Roots).\\n GameType internal constant SUPER_PERMISSIONED_CANNON = GameType.wrap(5);\\n\\n /// @notice A dispute game type that uses OP Succinct\\n GameType internal constant OP_SUCCINCT = GameType.wrap(6);\\n\\n /// @notice A dispute game type with short game duration for testing withdrawals.\\n /// Not intended for production use.\\n GameType internal constant FAST = GameType.wrap(254);\\n\\n /// @notice A dispute game type that uses an alphabet vm.\\n /// Not intended for production use.\\n GameType internal constant ALPHABET = GameType.wrap(255);\\n\\n /// @notice A dispute game type that uses RISC Zero's Kailua\\n GameType internal constant KAILUA = GameType.wrap(1337);\\n}\\n\\n/// @title VMStatuses\\n/// @notice Named type aliases for the various valid VM status bytes.\\nlibrary VMStatuses {\\n /// @notice The VM has executed successfully and the outcome is valid.\\n VMStatus internal constant VALID = VMStatus.wrap(0);\\n\\n /// @notice The VM has executed successfully and the outcome is invalid.\\n VMStatus internal constant INVALID = VMStatus.wrap(1);\\n\\n /// @notice The VM has paniced.\\n VMStatus internal constant PANIC = VMStatus.wrap(2);\\n\\n /// @notice The VM execution is still in progress.\\n VMStatus internal constant UNFINISHED = VMStatus.wrap(3);\\n}\\n\\n/// @title LocalPreimageKey\\n/// @notice Named type aliases for local `PreimageOracle` key identifiers.\\nlibrary LocalPreimageKey {\\n /// @notice The identifier for the L1 head hash.\\n uint256 internal constant L1_HEAD_HASH = 0x01;\\n\\n /// @notice The identifier for the starting output root.\\n uint256 internal constant STARTING_OUTPUT_ROOT = 0x02;\\n\\n /// @notice The identifier for the disputed output root.\\n uint256 internal constant DISPUTED_OUTPUT_ROOT = 0x03;\\n\\n /// @notice The identifier for the disputed L2 block number.\\n uint256 internal constant DISPUTED_L2_BLOCK_NUMBER = 0x04;\\n\\n /// @notice The identifier for the chain ID.\\n uint256 internal constant CHAIN_ID = 0x05;\\n}\\n\",\"keccak256\":\"0x7cc2960ea5c5223d81ae2156a966fa0226b70f9666932aca63a0a2a45c9182ae\",\"license\":\"MIT\"}},\"version\":1}","metadata":{"compiler":{"version":"0.8.25+commit.b61c2a91"},"language":"Solidity","output":{"abi":[{"inputs":[],"stateMutability":"view","type":"function","name":"addressManagerImpl","outputs":[{"internalType":"address","name":"","type":"address"}]},{"inputs":[],"stateMutability":"view","type":"function","name":"anchorStateRegistryProxy","outputs":[{"internalType":"address","name":"","type":"address"}]},{"inputs":[],"stateMutability":"view","type":"function","name":"batchSubmitter","outputs":[{"internalType":"address","name":"","type":"address"}]},{"inputs":[],"stateMutability":"view","type":"function","name":"challenger","outputs":[{"internalType":"address","name":"","type":"address"}]},{"inputs":[],"stateMutability":"view","type":"function","name":"delayedWethPermissionedGameProxy","outputs":[{"internalType":"address","name":"","type":"address"}]},{"inputs":[],"stateMutability":"view","type":"function","name":"delayedWethPermissionlessGameProxy","outputs":[{"internalType":"address","name":"","type":"address"}]},{"inputs":[],"stateMutability":"view","type":"function","name":"disputeGameFactoryProxy","outputs":[{"internalType":"address","name":"","type":"address"}]},{"inputs":[],"stateMutability":"view","type":"function","name":"ethLockboxProxy","outputs":[{"internalType":"address","name":"","type":"address"}]},{"inputs":[],"stateMutability":"view","type":"function","name":"faultDisputeGameImpl","outputs":[{"internalType":"address","name":"","type":"address"}]},{"inputs":[],"stateMutability":"view","type":"function","name":"l1CrossDomainMessengerProxy","outputs":[{"internalType":"address","name":"","type":"address"}]},{"inputs":[],"stateMutability":"view","type":"function","name":"l1Erc721BridgeProxy","outputs":[{"internalType":"address","name":"","type":"address"}]},{"inputs":[],"stateMutability":"view","type":"function","name":"l1StandardBridgeProxy","outputs":[{"internalType":"address","name":"","type":"address"}]},{"inputs":[],"stateMutability":"view","type":"function","name":"l2OutputOracleProxy","outputs":[{"internalType":"address","name":"","type":"address"}]},{"inputs":[],"stateMutability":"view","type":"function","name":"mipsImpl","outputs":[{"internalType":"address","name":"","type":"address"}]},{"inputs":[],"stateMutability":"view","type":"function","name":"opChainGuardian","outputs":[{"internalType":"address","name":"","type":"address"}]},{"inputs":[],"stateMutability":"view","type":"function","name":"opChainProxyAdminImpl","outputs":[{"internalType":"address","name":"","type":"address"}]},{"inputs":[],"stateMutability":"view","type":"function","name":"opChainProxyAdminOwner","outputs":[{"internalType":"address","name":"","type":"address"}]},{"inputs":[],"stateMutability":"view","type":"function","name":"optimismMintableErc20FactoryProxy","outputs":[{"internalType":"address","name":"","type":"address"}]},{"inputs":[],"stateMutability":"view","type":"function","name":"optimismPortalProxy","outputs":[{"internalType":"address","name":"","type":"address"}]},{"inputs":[],"stateMutability":"view","type":"function","name":"permissioned","outputs":[{"internalType":"bool","name":"","type":"bool"}]},{"inputs":[],"stateMutability":"view","type":"function","name":"permissionedDisputeGameImpl","outputs":[{"internalType":"address","name":"","type":"address"}]},{"inputs":[],"stateMutability":"view","type":"function","name":"permissionless","outputs":[{"internalType":"bool","name":"","type":"bool"}]},{"inputs":[],"stateMutability":"view","type":"function","name":"preimageOracleImpl","outputs":[{"internalType":"address","name":"","type":"address"}]},{"inputs":[],"stateMutability":"view","type":"function","name":"proposer","outputs":[{"internalType":"address","name":"","type":"address"}]},{"inputs":[],"stateMutability":"view","type":"function","name":"respectedGameType","outputs":[{"internalType":"GameType","name":"","type":"uint32"}]},{"inputs":[{"internalType":"bytes4","name":"_sel","type":"bytes4"},{"internalType":"bool","name":"_bool","type":"bool"}],"stateMutability":"nonpayable","type":"function","name":"set"},{"inputs":[{"internalType":"bytes4","name":"_sel","type":"bytes4"},{"internalType":"address","name":"_addr","type":"address"}],"stateMutability":"nonpayable","type":"function","name":"set"},{"inputs":[{"internalType":"bytes4","name":"_sel","type":"bytes4"},{"internalType":"GameType","name":"_gameType","type":"uint32"}],"stateMutability":"nonpayable","type":"function","name":"set"},{"inputs":[],"stateMutability":"view","type":"function","name":"superchainConfigProxy","outputs":[{"internalType":"address","name":"","type":"address"}]},{"inputs":[],"stateMutability":"view","type":"function","name":"systemConfigOwner","outputs":[{"internalType":"address","name":"","type":"address"}]},{"inputs":[],"stateMutability":"view","type":"function","name":"systemConfigProxy","outputs":[{"internalType":"address","name":"","type":"address"}]},{"inputs":[],"stateMutability":"view","type":"function","name":"unsafeBlockSigner","outputs":[{"internalType":"address","name":"","type":"address"}]}],"devdoc":{"kind":"dev","methods":{},"version":1},"userdoc":{"kind":"user","methods":{},"version":1}},"settings":{"remappings":["@lib-keccak/=lib/lib-keccak/contracts/lib/","@openzeppelin/contracts-upgradeable/=lib/openzeppelin-contracts-upgradeable/contracts/","@openzeppelin/contracts-v5/=lib/openzeppelin-contracts-v5/contracts/","@openzeppelin/contracts/=lib/openzeppelin-contracts/contracts/","@rari-capital/solmate/=lib/solmate/","@solady-test/=lib/lib-keccak/lib/solady/test/","@solady-v0.0.245/=lib/solady-v0.0.245/src/","@solady/=lib/solady/src/","ds-test/=lib/forge-std/lib/ds-test/src/","erc4626-tests/=lib/openzeppelin-contracts-v5/lib/erc4626-tests/","forge-std/=lib/forge-std/src/","interfaces/=interfaces/","kontrol-cheatcodes/=lib/kontrol-cheatcodes/src/","lib-keccak/=lib/lib-keccak/contracts/","openzeppelin-contracts-upgradeable/=lib/openzeppelin-contracts-upgradeable/","openzeppelin-contracts-v5/=lib/openzeppelin-contracts-v5/","openzeppelin-contracts/=lib/openzeppelin-contracts/","safe-contracts/=lib/safe-contracts/contracts/","solady-v0.0.245/=lib/solady-v0.0.245/src/","solady/=lib/solady/","solmate/=lib/solmate/src/"],"optimizer":{"enabled":false,"runs":999999},"metadata":{"useLiteralContent":true,"bytecodeHash":"none"},"compilationTarget":{"scripts/FetchChainInfo.s.sol":"FetchChainInfoOutput"},"evmVersion":"cancun","libraries":{}},"sources":{"lib/forge-std/src/Base.sol":{"keccak256":"0xa3735a6618a3014e42bb4329ad143e3b2c59cd95094350202e4c4a06c9d585dd","urls":[],"content":"// SPDX-License-Identifier: MIT\npragma solidity >=0.6.2 <0.9.0;\n\nimport {StdStorage} from \"./StdStorage.sol\";\nimport {Vm, VmSafe} from \"./Vm.sol\";\n\nabstract contract CommonBase {\n /// @dev Cheat code address.\n /// Calculated as `address(uint160(uint256(keccak256(\"hevm cheat code\"))))`.\n address internal constant VM_ADDRESS = 0x7109709ECfa91a80626fF3989D68f67F5b1DD12D;\n /// @dev console.sol and console2.sol work by executing a staticcall to this address.\n /// Calculated as `address(uint160(uint88(bytes11(\"console.log\"))))`.\n address internal constant CONSOLE = 0x000000000000000000636F6e736F6c652e6c6f67;\n /// @dev Used when deploying with create2.\n /// Taken from https://github.com/Arachnid/deterministic-deployment-proxy.\n address internal constant CREATE2_FACTORY = 0x4e59b44847b379578588920cA78FbF26c0B4956C;\n /// @dev The default address for tx.origin and msg.sender.\n /// Calculated as `address(uint160(uint256(keccak256(\"foundry default caller\"))))`.\n address internal constant DEFAULT_SENDER = 0x1804c8AB1F12E6bbf3894d4083f33e07309d1f38;\n /// @dev The address of the first contract `CREATE`d by a running test contract.\n /// When running tests, each test contract is `CREATE`d by `DEFAULT_SENDER` with nonce 1.\n /// Calculated as `VM.computeCreateAddress(VM.computeCreateAddress(DEFAULT_SENDER, 1), 1)`.\n address internal constant DEFAULT_TEST_CONTRACT = 0x5615dEB798BB3E4dFa0139dFa1b3D433Cc23b72f;\n /// @dev Deterministic deployment address of the Multicall3 contract.\n /// Taken from https://www.multicall3.com.\n address internal constant MULTICALL3_ADDRESS = 0xcA11bde05977b3631167028862bE2a173976CA11;\n /// @dev The order of the secp256k1 curve.\n uint256 internal constant SECP256K1_ORDER =\n 115792089237316195423570985008687907852837564279074904382605163141518161494337;\n\n uint256 internal constant UINT256_MAX =\n 115792089237316195423570985008687907853269984665640564039457584007913129639935;\n\n Vm internal constant vm = Vm(VM_ADDRESS);\n StdStorage internal stdstore;\n}\n\nabstract contract TestBase is CommonBase {}\n\nabstract contract ScriptBase is CommonBase {\n VmSafe internal constant vmSafe = VmSafe(VM_ADDRESS);\n}\n","license":"MIT"},"lib/forge-std/src/Script.sol":{"keccak256":"0xc942e27c7baae499beb01afbbae99f24d42af9a6e4aae675bc6901b704aa8e9b","urls":[],"content":"// SPDX-License-Identifier: MIT\npragma solidity >=0.6.2 <0.9.0;\n\n// 💬 ABOUT\n// Forge Std's default Script.\n\n// 🧩 MODULES\nimport {console} from \"./console.sol\";\nimport {console2} from \"./console2.sol\";\nimport {safeconsole} from \"./safeconsole.sol\";\nimport {StdChains} from \"./StdChains.sol\";\nimport {StdCheatsSafe} from \"./StdCheats.sol\";\nimport {StdConstants} from \"./StdConstants.sol\";\nimport {stdJson} from \"./StdJson.sol\";\nimport {stdMath} from \"./StdMath.sol\";\nimport {StdStorage, stdStorageSafe} from \"./StdStorage.sol\";\nimport {StdStyle} from \"./StdStyle.sol\";\nimport {StdUtils} from \"./StdUtils.sol\";\nimport {VmSafe} from \"./Vm.sol\";\n\n// 📦 BOILERPLATE\nimport {ScriptBase} from \"./Base.sol\";\n\n// ⭐️ SCRIPT\nabstract contract Script is ScriptBase, StdChains, StdCheatsSafe, StdUtils {\n // Note: IS_SCRIPT() must return true.\n bool public IS_SCRIPT = true;\n}\n","license":"MIT"},"lib/forge-std/src/StdChains.sol":{"keccak256":"0x200b597cd01c229633b4a2317846cac7d36d337e2381b4a2e81faac23c2ad1cf","urls":[],"content":"// SPDX-License-Identifier: MIT\npragma solidity >=0.6.2 <0.9.0;\n\nimport {VmSafe} from \"./Vm.sol\";\n\n/**\n * StdChains provides information about EVM compatible chains that can be used in scripts/tests.\n * For each chain, the chain's name, chain ID, and a default RPC URL are provided. Chains are\n * identified by their alias, which is the same as the alias in the `[rpc_endpoints]` section of\n * the `foundry.toml` file. For best UX, ensure the alias in the `foundry.toml` file match the\n * alias used in this contract, which can be found as the first argument to the\n * `setChainWithDefaultRpcUrl` call in the `initializeStdChains` function.\n *\n * There are two main ways to use this contract:\n * 1. Set a chain with `setChain(string memory chainAlias, ChainData memory chain)` or\n * `setChain(string memory chainAlias, Chain memory chain)`\n * 2. Get a chain with `getChain(string memory chainAlias)` or `getChain(uint256 chainId)`.\n *\n * The first time either of those are used, chains are initialized with the default set of RPC URLs.\n * This is done in `initializeStdChains`, which uses `setChainWithDefaultRpcUrl`. Defaults are recorded in\n * `defaultRpcUrls`.\n *\n * The `setChain` function is straightforward, and it simply saves off the given chain data.\n *\n * The `getChain` methods use `getChainWithUpdatedRpcUrl` to return a chain. For example, let's say\n * we want to retrieve the RPC URL for `mainnet`:\n * - If you have specified data with `setChain`, it will return that.\n * - If you have configured a mainnet RPC URL in `foundry.toml`, it will return the URL, provided it\n * is valid (e.g. a URL is specified, or an environment variable is given and exists).\n * - If neither of the above conditions is met, the default data is returned.\n *\n * Summarizing the above, the prioritization hierarchy is `setChain` -> `foundry.toml` -> environment variable -> defaults.\n */\nabstract contract StdChains {\n VmSafe private constant vm = VmSafe(address(uint160(uint256(keccak256(\"hevm cheat code\")))));\n\n bool private stdChainsInitialized;\n\n struct ChainData {\n string name;\n uint256 chainId;\n string rpcUrl;\n }\n\n struct Chain {\n // The chain name.\n string name;\n // The chain's Chain ID.\n uint256 chainId;\n // The chain's alias. (i.e. what gets specified in `foundry.toml`).\n string chainAlias;\n // A default RPC endpoint for this chain.\n // NOTE: This default RPC URL is included for convenience to facilitate quick tests and\n // experimentation. Do not use this RPC URL for production test suites, CI, or other heavy\n // usage as you will be throttled and this is a disservice to others who need this endpoint.\n string rpcUrl;\n }\n\n // Maps from the chain's alias (matching the alias in the `foundry.toml` file) to chain data.\n mapping(string => Chain) private chains;\n // Maps from the chain's alias to it's default RPC URL.\n mapping(string => string) private defaultRpcUrls;\n // Maps from a chain ID to it's alias.\n mapping(uint256 => string) private idToAlias;\n\n bool private fallbackToDefaultRpcUrls = true;\n\n // The RPC URL will be fetched from config or defaultRpcUrls if possible.\n function getChain(string memory chainAlias) internal virtual returns (Chain memory chain) {\n require(bytes(chainAlias).length != 0, \"StdChains getChain(string): Chain alias cannot be the empty string.\");\n\n initializeStdChains();\n chain = chains[chainAlias];\n require(\n chain.chainId != 0,\n string(abi.encodePacked(\"StdChains getChain(string): Chain with alias \\\"\", chainAlias, \"\\\" not found.\"))\n );\n\n chain = getChainWithUpdatedRpcUrl(chainAlias, chain);\n }\n\n function getChain(uint256 chainId) internal virtual returns (Chain memory chain) {\n require(chainId != 0, \"StdChains getChain(uint256): Chain ID cannot be 0.\");\n initializeStdChains();\n string memory chainAlias = idToAlias[chainId];\n\n chain = chains[chainAlias];\n\n require(\n chain.chainId != 0,\n string(abi.encodePacked(\"StdChains getChain(uint256): Chain with ID \", vm.toString(chainId), \" not found.\"))\n );\n\n chain = getChainWithUpdatedRpcUrl(chainAlias, chain);\n }\n\n // set chain info, with priority to argument's rpcUrl field.\n function setChain(string memory chainAlias, ChainData memory chain) internal virtual {\n require(\n bytes(chainAlias).length != 0,\n \"StdChains setChain(string,ChainData): Chain alias cannot be the empty string.\"\n );\n\n require(chain.chainId != 0, \"StdChains setChain(string,ChainData): Chain ID cannot be 0.\");\n\n initializeStdChains();\n string memory foundAlias = idToAlias[chain.chainId];\n\n require(\n bytes(foundAlias).length == 0 || keccak256(bytes(foundAlias)) == keccak256(bytes(chainAlias)),\n string(\n abi.encodePacked(\n \"StdChains setChain(string,ChainData): Chain ID \",\n vm.toString(chain.chainId),\n \" already used by \\\"\",\n foundAlias,\n \"\\\".\"\n )\n )\n );\n\n uint256 oldChainId = chains[chainAlias].chainId;\n delete idToAlias[oldChainId];\n\n chains[chainAlias] =\n Chain({name: chain.name, chainId: chain.chainId, chainAlias: chainAlias, rpcUrl: chain.rpcUrl});\n idToAlias[chain.chainId] = chainAlias;\n }\n\n // set chain info, with priority to argument's rpcUrl field.\n function setChain(string memory chainAlias, Chain memory chain) internal virtual {\n setChain(chainAlias, ChainData({name: chain.name, chainId: chain.chainId, rpcUrl: chain.rpcUrl}));\n }\n\n function _toUpper(string memory str) private pure returns (string memory) {\n bytes memory strb = bytes(str);\n bytes memory copy = new bytes(strb.length);\n for (uint256 i = 0; i < strb.length; i++) {\n bytes1 b = strb[i];\n if (b >= 0x61 && b <= 0x7A) {\n copy[i] = bytes1(uint8(b) - 32);\n } else {\n copy[i] = b;\n }\n }\n return string(copy);\n }\n\n // lookup rpcUrl, in descending order of priority:\n // current -> config (foundry.toml) -> environment variable -> default\n function getChainWithUpdatedRpcUrl(string memory chainAlias, Chain memory chain)\n private\n view\n returns (Chain memory)\n {\n if (bytes(chain.rpcUrl).length == 0) {\n try vm.rpcUrl(chainAlias) returns (string memory configRpcUrl) {\n chain.rpcUrl = configRpcUrl;\n } catch (bytes memory err) {\n string memory envName = string(abi.encodePacked(_toUpper(chainAlias), \"_RPC_URL\"));\n if (fallbackToDefaultRpcUrls) {\n chain.rpcUrl = vm.envOr(envName, defaultRpcUrls[chainAlias]);\n } else {\n chain.rpcUrl = vm.envString(envName);\n }\n // Distinguish 'not found' from 'cannot read'\n // The upstream error thrown by forge for failing cheats changed so we check both the old and new versions\n bytes memory oldNotFoundError =\n abi.encodeWithSignature(\"CheatCodeError\", string(abi.encodePacked(\"invalid rpc url \", chainAlias)));\n bytes memory newNotFoundError = abi.encodeWithSignature(\n \"CheatcodeError(string)\", string(abi.encodePacked(\"invalid rpc url: \", chainAlias))\n );\n bytes32 errHash = keccak256(err);\n if (\n (errHash != keccak256(oldNotFoundError) && errHash != keccak256(newNotFoundError))\n || bytes(chain.rpcUrl).length == 0\n ) {\n /// @solidity memory-safe-assembly\n assembly {\n revert(add(32, err), mload(err))\n }\n }\n }\n }\n return chain;\n }\n\n function setFallbackToDefaultRpcUrls(bool useDefault) internal {\n fallbackToDefaultRpcUrls = useDefault;\n }\n\n function initializeStdChains() private {\n if (stdChainsInitialized) return;\n\n stdChainsInitialized = true;\n\n // If adding an RPC here, make sure to test the default RPC URL in `test_Rpcs` in `StdChains.t.sol`\n setChainWithDefaultRpcUrl(\"anvil\", ChainData(\"Anvil\", 31337, \"http://127.0.0.1:8545\"));\n setChainWithDefaultRpcUrl(\"mainnet\", ChainData(\"Mainnet\", 1, \"https://eth.llamarpc.com\"));\n setChainWithDefaultRpcUrl(\n \"sepolia\", ChainData(\"Sepolia\", 11155111, \"https://sepolia.infura.io/v3/b9794ad1ddf84dfb8c34d6bb5dca2001\")\n );\n setChainWithDefaultRpcUrl(\"holesky\", ChainData(\"Holesky\", 17000, \"https://rpc.holesky.ethpandaops.io\"));\n setChainWithDefaultRpcUrl(\"optimism\", ChainData(\"Optimism\", 10, \"https://mainnet.optimism.io\"));\n setChainWithDefaultRpcUrl(\n \"optimism_sepolia\", ChainData(\"Optimism Sepolia\", 11155420, \"https://sepolia.optimism.io\")\n );\n setChainWithDefaultRpcUrl(\"arbitrum_one\", ChainData(\"Arbitrum One\", 42161, \"https://arb1.arbitrum.io/rpc\"));\n setChainWithDefaultRpcUrl(\n \"arbitrum_one_sepolia\", ChainData(\"Arbitrum One Sepolia\", 421614, \"https://sepolia-rollup.arbitrum.io/rpc\")\n );\n setChainWithDefaultRpcUrl(\"arbitrum_nova\", ChainData(\"Arbitrum Nova\", 42170, \"https://nova.arbitrum.io/rpc\"));\n setChainWithDefaultRpcUrl(\"polygon\", ChainData(\"Polygon\", 137, \"https://polygon-rpc.com\"));\n setChainWithDefaultRpcUrl(\n \"polygon_amoy\", ChainData(\"Polygon Amoy\", 80002, \"https://rpc-amoy.polygon.technology\")\n );\n setChainWithDefaultRpcUrl(\"avalanche\", ChainData(\"Avalanche\", 43114, \"https://api.avax.network/ext/bc/C/rpc\"));\n setChainWithDefaultRpcUrl(\n \"avalanche_fuji\", ChainData(\"Avalanche Fuji\", 43113, \"https://api.avax-test.network/ext/bc/C/rpc\")\n );\n setChainWithDefaultRpcUrl(\n \"bnb_smart_chain\", ChainData(\"BNB Smart Chain\", 56, \"https://bsc-dataseed1.binance.org\")\n );\n setChainWithDefaultRpcUrl(\n \"bnb_smart_chain_testnet\",\n ChainData(\"BNB Smart Chain Testnet\", 97, \"https://rpc.ankr.com/bsc_testnet_chapel\")\n );\n setChainWithDefaultRpcUrl(\"gnosis_chain\", ChainData(\"Gnosis Chain\", 100, \"https://rpc.gnosischain.com\"));\n setChainWithDefaultRpcUrl(\"moonbeam\", ChainData(\"Moonbeam\", 1284, \"https://rpc.api.moonbeam.network\"));\n setChainWithDefaultRpcUrl(\n \"moonriver\", ChainData(\"Moonriver\", 1285, \"https://rpc.api.moonriver.moonbeam.network\")\n );\n setChainWithDefaultRpcUrl(\"moonbase\", ChainData(\"Moonbase\", 1287, \"https://rpc.testnet.moonbeam.network\"));\n setChainWithDefaultRpcUrl(\"base_sepolia\", ChainData(\"Base Sepolia\", 84532, \"https://sepolia.base.org\"));\n setChainWithDefaultRpcUrl(\"base\", ChainData(\"Base\", 8453, \"https://mainnet.base.org\"));\n setChainWithDefaultRpcUrl(\"blast_sepolia\", ChainData(\"Blast Sepolia\", 168587773, \"https://sepolia.blast.io\"));\n setChainWithDefaultRpcUrl(\"blast\", ChainData(\"Blast\", 81457, \"https://rpc.blast.io\"));\n setChainWithDefaultRpcUrl(\"fantom_opera\", ChainData(\"Fantom Opera\", 250, \"https://rpc.ankr.com/fantom/\"));\n setChainWithDefaultRpcUrl(\n \"fantom_opera_testnet\", ChainData(\"Fantom Opera Testnet\", 4002, \"https://rpc.ankr.com/fantom_testnet/\")\n );\n setChainWithDefaultRpcUrl(\"fraxtal\", ChainData(\"Fraxtal\", 252, \"https://rpc.frax.com\"));\n setChainWithDefaultRpcUrl(\"fraxtal_testnet\", ChainData(\"Fraxtal Testnet\", 2522, \"https://rpc.testnet.frax.com\"));\n setChainWithDefaultRpcUrl(\n \"berachain_bartio_testnet\", ChainData(\"Berachain bArtio Testnet\", 80084, \"https://bartio.rpc.berachain.com\")\n );\n setChainWithDefaultRpcUrl(\"flare\", ChainData(\"Flare\", 14, \"https://flare-api.flare.network/ext/C/rpc\"));\n setChainWithDefaultRpcUrl(\n \"flare_coston2\", ChainData(\"Flare Coston2\", 114, \"https://coston2-api.flare.network/ext/C/rpc\")\n );\n\n setChainWithDefaultRpcUrl(\"mode\", ChainData(\"Mode\", 34443, \"https://mode.drpc.org\"));\n setChainWithDefaultRpcUrl(\"mode_sepolia\", ChainData(\"Mode Sepolia\", 919, \"https://sepolia.mode.network\"));\n\n setChainWithDefaultRpcUrl(\"zora\", ChainData(\"Zora\", 7777777, \"https://zora.drpc.org\"));\n setChainWithDefaultRpcUrl(\n \"zora_sepolia\", ChainData(\"Zora Sepolia\", 999999999, \"https://sepolia.rpc.zora.energy\")\n );\n\n setChainWithDefaultRpcUrl(\"race\", ChainData(\"Race\", 6805, \"https://racemainnet.io\"));\n setChainWithDefaultRpcUrl(\"race_sepolia\", ChainData(\"Race Sepolia\", 6806, \"https://racemainnet.io\"));\n\n setChainWithDefaultRpcUrl(\"metal\", ChainData(\"Metal\", 1750, \"https://metall2.drpc.org\"));\n setChainWithDefaultRpcUrl(\"metal_sepolia\", ChainData(\"Metal Sepolia\", 1740, \"https://testnet.rpc.metall2.com\"));\n\n setChainWithDefaultRpcUrl(\"binary\", ChainData(\"Binary\", 624, \"https://rpc.zero.thebinaryholdings.com\"));\n setChainWithDefaultRpcUrl(\n \"binary_sepolia\", ChainData(\"Binary Sepolia\", 625, \"https://rpc.zero.thebinaryholdings.com\")\n );\n\n setChainWithDefaultRpcUrl(\"orderly\", ChainData(\"Orderly\", 291, \"https://rpc.orderly.network\"));\n setChainWithDefaultRpcUrl(\n \"orderly_sepolia\", ChainData(\"Orderly Sepolia\", 4460, \"https://testnet-rpc.orderly.org\")\n );\n }\n\n // set chain info, with priority to chainAlias' rpc url in foundry.toml\n function setChainWithDefaultRpcUrl(string memory chainAlias, ChainData memory chain) private {\n string memory rpcUrl = chain.rpcUrl;\n defaultRpcUrls[chainAlias] = rpcUrl;\n chain.rpcUrl = \"\";\n setChain(chainAlias, chain);\n chain.rpcUrl = rpcUrl; // restore argument\n }\n}\n","license":"MIT"},"lib/forge-std/src/StdCheats.sol":{"keccak256":"0x0fa6ec03602648b62cce41aab2096e6b7e052f2846075d967b6958dd586db746","urls":[],"content":"// SPDX-License-Identifier: MIT\npragma solidity >=0.6.2 <0.9.0;\n\npragma experimental ABIEncoderV2;\n\nimport {StdStorage, stdStorage} from \"./StdStorage.sol\";\nimport {console2} from \"./console2.sol\";\nimport {Vm} from \"./Vm.sol\";\n\nabstract contract StdCheatsSafe {\n Vm private constant vm = Vm(address(uint160(uint256(keccak256(\"hevm cheat code\")))));\n\n uint256 private constant UINT256_MAX =\n 115792089237316195423570985008687907853269984665640564039457584007913129639935;\n\n bool private gasMeteringOff;\n\n // Data structures to parse Transaction objects from the broadcast artifact\n // that conform to EIP1559. The Raw structs is what is parsed from the JSON\n // and then converted to the one that is used by the user for better UX.\n\n struct RawTx1559 {\n string[] arguments;\n address contractAddress;\n string contractName;\n // json value name = function\n string functionSig;\n bytes32 hash;\n // json value name = tx\n RawTx1559Detail txDetail;\n // json value name = type\n string opcode;\n }\n\n struct RawTx1559Detail {\n AccessList[] accessList;\n bytes data;\n address from;\n bytes gas;\n bytes nonce;\n address to;\n bytes txType;\n bytes value;\n }\n\n struct Tx1559 {\n string[] arguments;\n address contractAddress;\n string contractName;\n string functionSig;\n bytes32 hash;\n Tx1559Detail txDetail;\n string opcode;\n }\n\n struct Tx1559Detail {\n AccessList[] accessList;\n bytes data;\n address from;\n uint256 gas;\n uint256 nonce;\n address to;\n uint256 txType;\n uint256 value;\n }\n\n // Data structures to parse Transaction objects from the broadcast artifact\n // that DO NOT conform to EIP1559. The Raw structs is what is parsed from the JSON\n // and then converted to the one that is used by the user for better UX.\n\n struct TxLegacy {\n string[] arguments;\n address contractAddress;\n string contractName;\n string functionSig;\n string hash;\n string opcode;\n TxDetailLegacy transaction;\n }\n\n struct TxDetailLegacy {\n AccessList[] accessList;\n uint256 chainId;\n bytes data;\n address from;\n uint256 gas;\n uint256 gasPrice;\n bytes32 hash;\n uint256 nonce;\n bytes1 opcode;\n bytes32 r;\n bytes32 s;\n uint256 txType;\n address to;\n uint8 v;\n uint256 value;\n }\n\n struct AccessList {\n address accessAddress;\n bytes32[] storageKeys;\n }\n\n // Data structures to parse Receipt objects from the broadcast artifact.\n // The Raw structs is what is parsed from the JSON\n // and then converted to the one that is used by the user for better UX.\n\n struct RawReceipt {\n bytes32 blockHash;\n bytes blockNumber;\n address contractAddress;\n bytes cumulativeGasUsed;\n bytes effectiveGasPrice;\n address from;\n bytes gasUsed;\n RawReceiptLog[] logs;\n bytes logsBloom;\n bytes status;\n address to;\n bytes32 transactionHash;\n bytes transactionIndex;\n }\n\n struct Receipt {\n bytes32 blockHash;\n uint256 blockNumber;\n address contractAddress;\n uint256 cumulativeGasUsed;\n uint256 effectiveGasPrice;\n address from;\n uint256 gasUsed;\n ReceiptLog[] logs;\n bytes logsBloom;\n uint256 status;\n address to;\n bytes32 transactionHash;\n uint256 transactionIndex;\n }\n\n // Data structures to parse the entire broadcast artifact, assuming the\n // transactions conform to EIP1559.\n\n struct EIP1559ScriptArtifact {\n string[] libraries;\n string path;\n string[] pending;\n Receipt[] receipts;\n uint256 timestamp;\n Tx1559[] transactions;\n TxReturn[] txReturns;\n }\n\n struct RawEIP1559ScriptArtifact {\n string[] libraries;\n string path;\n string[] pending;\n RawReceipt[] receipts;\n TxReturn[] txReturns;\n uint256 timestamp;\n RawTx1559[] transactions;\n }\n\n struct RawReceiptLog {\n // json value = address\n address logAddress;\n bytes32 blockHash;\n bytes blockNumber;\n bytes data;\n bytes logIndex;\n bool removed;\n bytes32[] topics;\n bytes32 transactionHash;\n bytes transactionIndex;\n bytes transactionLogIndex;\n }\n\n struct ReceiptLog {\n // json value = address\n address logAddress;\n bytes32 blockHash;\n uint256 blockNumber;\n bytes data;\n uint256 logIndex;\n bytes32[] topics;\n uint256 transactionIndex;\n uint256 transactionLogIndex;\n bool removed;\n }\n\n struct TxReturn {\n string internalType;\n string value;\n }\n\n struct Account {\n address addr;\n uint256 key;\n }\n\n enum AddressType {\n Payable,\n NonPayable,\n ZeroAddress,\n Precompile,\n ForgeAddress\n }\n\n // Checks that `addr` is not blacklisted by token contracts that have a blacklist.\n function assumeNotBlacklisted(address token, address addr) internal view virtual {\n // Nothing to check if `token` is not a contract.\n uint256 tokenCodeSize;\n assembly {\n tokenCodeSize := extcodesize(token)\n }\n require(tokenCodeSize > 0, \"StdCheats assumeNotBlacklisted(address,address): Token address is not a contract.\");\n\n bool success;\n bytes memory returnData;\n\n // 4-byte selector for `isBlacklisted(address)`, used by USDC.\n (success, returnData) = token.staticcall(abi.encodeWithSelector(0xfe575a87, addr));\n vm.assume(!success || abi.decode(returnData, (bool)) == false);\n\n // 4-byte selector for `isBlackListed(address)`, used by USDT.\n (success, returnData) = token.staticcall(abi.encodeWithSelector(0xe47d6060, addr));\n vm.assume(!success || abi.decode(returnData, (bool)) == false);\n }\n\n // Checks that `addr` is not blacklisted by token contracts that have a blacklist.\n // This is identical to `assumeNotBlacklisted(address,address)` but with a different name, for\n // backwards compatibility, since this name was used in the original PR which already has\n // a release. This function can be removed in a future release once we want a breaking change.\n function assumeNoBlacklisted(address token, address addr) internal view virtual {\n assumeNotBlacklisted(token, addr);\n }\n\n function assumeAddressIsNot(address addr, AddressType addressType) internal virtual {\n if (addressType == AddressType.Payable) {\n assumeNotPayable(addr);\n } else if (addressType == AddressType.NonPayable) {\n assumePayable(addr);\n } else if (addressType == AddressType.ZeroAddress) {\n assumeNotZeroAddress(addr);\n } else if (addressType == AddressType.Precompile) {\n assumeNotPrecompile(addr);\n } else if (addressType == AddressType.ForgeAddress) {\n assumeNotForgeAddress(addr);\n }\n }\n\n function assumeAddressIsNot(address addr, AddressType addressType1, AddressType addressType2) internal virtual {\n assumeAddressIsNot(addr, addressType1);\n assumeAddressIsNot(addr, addressType2);\n }\n\n function assumeAddressIsNot(\n address addr,\n AddressType addressType1,\n AddressType addressType2,\n AddressType addressType3\n ) internal virtual {\n assumeAddressIsNot(addr, addressType1);\n assumeAddressIsNot(addr, addressType2);\n assumeAddressIsNot(addr, addressType3);\n }\n\n function assumeAddressIsNot(\n address addr,\n AddressType addressType1,\n AddressType addressType2,\n AddressType addressType3,\n AddressType addressType4\n ) internal virtual {\n assumeAddressIsNot(addr, addressType1);\n assumeAddressIsNot(addr, addressType2);\n assumeAddressIsNot(addr, addressType3);\n assumeAddressIsNot(addr, addressType4);\n }\n\n // This function checks whether an address, `addr`, is payable. It works by sending 1 wei to\n // `addr` and checking the `success` return value.\n // NOTE: This function may result in state changes depending on the fallback/receive logic\n // implemented by `addr`, which should be taken into account when this function is used.\n function _isPayable(address addr) private returns (bool) {\n require(\n addr.balance < UINT256_MAX,\n \"StdCheats _isPayable(address): Balance equals max uint256, so it cannot receive any more funds\"\n );\n uint256 origBalanceTest = address(this).balance;\n uint256 origBalanceAddr = address(addr).balance;\n\n vm.deal(address(this), 1);\n (bool success,) = payable(addr).call{value: 1}(\"\");\n\n // reset balances\n vm.deal(address(this), origBalanceTest);\n vm.deal(addr, origBalanceAddr);\n\n return success;\n }\n\n // NOTE: This function may result in state changes depending on the fallback/receive logic\n // implemented by `addr`, which should be taken into account when this function is used. See the\n // `_isPayable` method for more information.\n function assumePayable(address addr) internal virtual {\n vm.assume(_isPayable(addr));\n }\n\n function assumeNotPayable(address addr) internal virtual {\n vm.assume(!_isPayable(addr));\n }\n\n function assumeNotZeroAddress(address addr) internal pure virtual {\n vm.assume(addr != address(0));\n }\n\n function assumeNotPrecompile(address addr) internal pure virtual {\n assumeNotPrecompile(addr, _pureChainId());\n }\n\n function assumeNotPrecompile(address addr, uint256 chainId) internal pure virtual {\n // Note: For some chains like Optimism these are technically predeploys (i.e. bytecode placed at a specific\n // address), but the same rationale for excluding them applies so we include those too.\n\n // These are reserved by Ethereum and may be on all EVM-compatible chains.\n vm.assume(addr < address(0x1) || addr > address(0xff));\n\n // forgefmt: disable-start\n if (chainId == 10 || chainId == 420) {\n // https://github.com/ethereum-optimism/optimism/blob/eaa371a0184b56b7ca6d9eb9cb0a2b78b2ccd864/op-bindings/predeploys/addresses.go#L6-L21\n vm.assume(addr < address(0x4200000000000000000000000000000000000000) || addr > address(0x4200000000000000000000000000000000000800));\n } else if (chainId == 42161 || chainId == 421613) {\n // https://developer.arbitrum.io/useful-addresses#arbitrum-precompiles-l2-same-on-all-arb-chains\n vm.assume(addr < address(0x0000000000000000000000000000000000000064) || addr > address(0x0000000000000000000000000000000000000068));\n } else if (chainId == 43114 || chainId == 43113) {\n // https://github.com/ava-labs/subnet-evm/blob/47c03fd007ecaa6de2c52ea081596e0a88401f58/precompile/params.go#L18-L59\n vm.assume(addr < address(0x0100000000000000000000000000000000000000) || addr > address(0x01000000000000000000000000000000000000ff));\n vm.assume(addr < address(0x0200000000000000000000000000000000000000) || addr > address(0x02000000000000000000000000000000000000FF));\n vm.assume(addr < address(0x0300000000000000000000000000000000000000) || addr > address(0x03000000000000000000000000000000000000Ff));\n }\n // forgefmt: disable-end\n }\n\n function assumeNotForgeAddress(address addr) internal pure virtual {\n // vm, console, and Create2Deployer addresses\n vm.assume(\n addr != address(vm) && addr != 0x000000000000000000636F6e736F6c652e6c6f67\n && addr != 0x4e59b44847b379578588920cA78FbF26c0B4956C\n );\n }\n\n function assumeUnusedAddress(address addr) internal view virtual {\n uint256 size;\n assembly {\n size := extcodesize(addr)\n }\n vm.assume(size == 0);\n\n assumeNotPrecompile(addr);\n assumeNotZeroAddress(addr);\n assumeNotForgeAddress(addr);\n }\n\n function readEIP1559ScriptArtifact(string memory path)\n internal\n view\n virtual\n returns (EIP1559ScriptArtifact memory)\n {\n string memory data = vm.readFile(path);\n bytes memory parsedData = vm.parseJson(data);\n RawEIP1559ScriptArtifact memory rawArtifact = abi.decode(parsedData, (RawEIP1559ScriptArtifact));\n EIP1559ScriptArtifact memory artifact;\n artifact.libraries = rawArtifact.libraries;\n artifact.path = rawArtifact.path;\n artifact.timestamp = rawArtifact.timestamp;\n artifact.pending = rawArtifact.pending;\n artifact.txReturns = rawArtifact.txReturns;\n artifact.receipts = rawToConvertedReceipts(rawArtifact.receipts);\n artifact.transactions = rawToConvertedEIPTx1559s(rawArtifact.transactions);\n return artifact;\n }\n\n function rawToConvertedEIPTx1559s(RawTx1559[] memory rawTxs) internal pure virtual returns (Tx1559[] memory) {\n Tx1559[] memory txs = new Tx1559[](rawTxs.length);\n for (uint256 i; i < rawTxs.length; i++) {\n txs[i] = rawToConvertedEIPTx1559(rawTxs[i]);\n }\n return txs;\n }\n\n function rawToConvertedEIPTx1559(RawTx1559 memory rawTx) internal pure virtual returns (Tx1559 memory) {\n Tx1559 memory transaction;\n transaction.arguments = rawTx.arguments;\n transaction.contractName = rawTx.contractName;\n transaction.functionSig = rawTx.functionSig;\n transaction.hash = rawTx.hash;\n transaction.txDetail = rawToConvertedEIP1559Detail(rawTx.txDetail);\n transaction.opcode = rawTx.opcode;\n return transaction;\n }\n\n function rawToConvertedEIP1559Detail(RawTx1559Detail memory rawDetail)\n internal\n pure\n virtual\n returns (Tx1559Detail memory)\n {\n Tx1559Detail memory txDetail;\n txDetail.data = rawDetail.data;\n txDetail.from = rawDetail.from;\n txDetail.to = rawDetail.to;\n txDetail.nonce = _bytesToUint(rawDetail.nonce);\n txDetail.txType = _bytesToUint(rawDetail.txType);\n txDetail.value = _bytesToUint(rawDetail.value);\n txDetail.gas = _bytesToUint(rawDetail.gas);\n txDetail.accessList = rawDetail.accessList;\n return txDetail;\n }\n\n function readTx1559s(string memory path) internal view virtual returns (Tx1559[] memory) {\n string memory deployData = vm.readFile(path);\n bytes memory parsedDeployData = vm.parseJson(deployData, \".transactions\");\n RawTx1559[] memory rawTxs = abi.decode(parsedDeployData, (RawTx1559[]));\n return rawToConvertedEIPTx1559s(rawTxs);\n }\n\n function readTx1559(string memory path, uint256 index) internal view virtual returns (Tx1559 memory) {\n string memory deployData = vm.readFile(path);\n string memory key = string(abi.encodePacked(\".transactions[\", vm.toString(index), \"]\"));\n bytes memory parsedDeployData = vm.parseJson(deployData, key);\n RawTx1559 memory rawTx = abi.decode(parsedDeployData, (RawTx1559));\n return rawToConvertedEIPTx1559(rawTx);\n }\n\n // Analogous to readTransactions, but for receipts.\n function readReceipts(string memory path) internal view virtual returns (Receipt[] memory) {\n string memory deployData = vm.readFile(path);\n bytes memory parsedDeployData = vm.parseJson(deployData, \".receipts\");\n RawReceipt[] memory rawReceipts = abi.decode(parsedDeployData, (RawReceipt[]));\n return rawToConvertedReceipts(rawReceipts);\n }\n\n function readReceipt(string memory path, uint256 index) internal view virtual returns (Receipt memory) {\n string memory deployData = vm.readFile(path);\n string memory key = string(abi.encodePacked(\".receipts[\", vm.toString(index), \"]\"));\n bytes memory parsedDeployData = vm.parseJson(deployData, key);\n RawReceipt memory rawReceipt = abi.decode(parsedDeployData, (RawReceipt));\n return rawToConvertedReceipt(rawReceipt);\n }\n\n function rawToConvertedReceipts(RawReceipt[] memory rawReceipts) internal pure virtual returns (Receipt[] memory) {\n Receipt[] memory receipts = new Receipt[](rawReceipts.length);\n for (uint256 i; i < rawReceipts.length; i++) {\n receipts[i] = rawToConvertedReceipt(rawReceipts[i]);\n }\n return receipts;\n }\n\n function rawToConvertedReceipt(RawReceipt memory rawReceipt) internal pure virtual returns (Receipt memory) {\n Receipt memory receipt;\n receipt.blockHash = rawReceipt.blockHash;\n receipt.to = rawReceipt.to;\n receipt.from = rawReceipt.from;\n receipt.contractAddress = rawReceipt.contractAddress;\n receipt.effectiveGasPrice = _bytesToUint(rawReceipt.effectiveGasPrice);\n receipt.cumulativeGasUsed = _bytesToUint(rawReceipt.cumulativeGasUsed);\n receipt.gasUsed = _bytesToUint(rawReceipt.gasUsed);\n receipt.status = _bytesToUint(rawReceipt.status);\n receipt.transactionIndex = _bytesToUint(rawReceipt.transactionIndex);\n receipt.blockNumber = _bytesToUint(rawReceipt.blockNumber);\n receipt.logs = rawToConvertedReceiptLogs(rawReceipt.logs);\n receipt.logsBloom = rawReceipt.logsBloom;\n receipt.transactionHash = rawReceipt.transactionHash;\n return receipt;\n }\n\n function rawToConvertedReceiptLogs(RawReceiptLog[] memory rawLogs)\n internal\n pure\n virtual\n returns (ReceiptLog[] memory)\n {\n ReceiptLog[] memory logs = new ReceiptLog[](rawLogs.length);\n for (uint256 i; i < rawLogs.length; i++) {\n logs[i].logAddress = rawLogs[i].logAddress;\n logs[i].blockHash = rawLogs[i].blockHash;\n logs[i].blockNumber = _bytesToUint(rawLogs[i].blockNumber);\n logs[i].data = rawLogs[i].data;\n logs[i].logIndex = _bytesToUint(rawLogs[i].logIndex);\n logs[i].topics = rawLogs[i].topics;\n logs[i].transactionIndex = _bytesToUint(rawLogs[i].transactionIndex);\n logs[i].transactionLogIndex = _bytesToUint(rawLogs[i].transactionLogIndex);\n logs[i].removed = rawLogs[i].removed;\n }\n return logs;\n }\n\n // Deploy a contract by fetching the contract bytecode from\n // the artifacts directory\n // e.g. `deployCode(code, abi.encode(arg1,arg2,arg3))`\n function deployCode(string memory what, bytes memory args) internal virtual returns (address addr) {\n bytes memory bytecode = abi.encodePacked(vm.getCode(what), args);\n /// @solidity memory-safe-assembly\n assembly {\n addr := create(0, add(bytecode, 0x20), mload(bytecode))\n }\n\n require(addr != address(0), \"StdCheats deployCode(string,bytes): Deployment failed.\");\n }\n\n function deployCode(string memory what) internal virtual returns (address addr) {\n bytes memory bytecode = vm.getCode(what);\n /// @solidity memory-safe-assembly\n assembly {\n addr := create(0, add(bytecode, 0x20), mload(bytecode))\n }\n\n require(addr != address(0), \"StdCheats deployCode(string): Deployment failed.\");\n }\n\n /// @dev deploy contract with value on construction\n function deployCode(string memory what, bytes memory args, uint256 val) internal virtual returns (address addr) {\n bytes memory bytecode = abi.encodePacked(vm.getCode(what), args);\n /// @solidity memory-safe-assembly\n assembly {\n addr := create(val, add(bytecode, 0x20), mload(bytecode))\n }\n\n require(addr != address(0), \"StdCheats deployCode(string,bytes,uint256): Deployment failed.\");\n }\n\n function deployCode(string memory what, uint256 val) internal virtual returns (address addr) {\n bytes memory bytecode = vm.getCode(what);\n /// @solidity memory-safe-assembly\n assembly {\n addr := create(val, add(bytecode, 0x20), mload(bytecode))\n }\n\n require(addr != address(0), \"StdCheats deployCode(string,uint256): Deployment failed.\");\n }\n\n // creates a labeled address and the corresponding private key\n function makeAddrAndKey(string memory name) internal virtual returns (address addr, uint256 privateKey) {\n privateKey = uint256(keccak256(abi.encodePacked(name)));\n addr = vm.addr(privateKey);\n vm.label(addr, name);\n }\n\n // creates a labeled address\n function makeAddr(string memory name) internal virtual returns (address addr) {\n (addr,) = makeAddrAndKey(name);\n }\n\n // Destroys an account immediately, sending the balance to beneficiary.\n // Destroying means: balance will be zero, code will be empty, and nonce will be 0\n // This is similar to selfdestruct but not identical: selfdestruct destroys code and nonce\n // only after tx ends, this will run immediately.\n function destroyAccount(address who, address beneficiary) internal virtual {\n uint256 currBalance = who.balance;\n vm.etch(who, abi.encode());\n vm.deal(who, 0);\n vm.resetNonce(who);\n\n uint256 beneficiaryBalance = beneficiary.balance;\n vm.deal(beneficiary, currBalance + beneficiaryBalance);\n }\n\n // creates a struct containing both a labeled address and the corresponding private key\n function makeAccount(string memory name) internal virtual returns (Account memory account) {\n (account.addr, account.key) = makeAddrAndKey(name);\n }\n\n function deriveRememberKey(string memory mnemonic, uint32 index)\n internal\n virtual\n returns (address who, uint256 privateKey)\n {\n privateKey = vm.deriveKey(mnemonic, index);\n who = vm.rememberKey(privateKey);\n }\n\n function _bytesToUint(bytes memory b) private pure returns (uint256) {\n require(b.length <= 32, \"StdCheats _bytesToUint(bytes): Bytes length exceeds 32.\");\n return abi.decode(abi.encodePacked(new bytes(32 - b.length), b), (uint256));\n }\n\n function isFork() internal view virtual returns (bool status) {\n try vm.activeFork() {\n status = true;\n } catch (bytes memory) {}\n }\n\n modifier skipWhenForking() {\n if (!isFork()) {\n _;\n }\n }\n\n modifier skipWhenNotForking() {\n if (isFork()) {\n _;\n }\n }\n\n modifier noGasMetering() {\n vm.pauseGasMetering();\n // To prevent turning gas monitoring back on with nested functions that use this modifier,\n // we check if gasMetering started in the off position. If it did, we don't want to turn\n // it back on until we exit the top level function that used the modifier\n //\n // i.e. funcA() noGasMetering { funcB() }, where funcB has noGasMetering as well.\n // funcA will have `gasStartedOff` as false, funcB will have it as true,\n // so we only turn metering back on at the end of the funcA\n bool gasStartedOff = gasMeteringOff;\n gasMeteringOff = true;\n\n _;\n\n // if gas metering was on when this modifier was called, turn it back on at the end\n if (!gasStartedOff) {\n gasMeteringOff = false;\n vm.resumeGasMetering();\n }\n }\n\n // We use this complex approach of `_viewChainId` and `_pureChainId` to ensure there are no\n // compiler warnings when accessing chain ID in any solidity version supported by forge-std. We\n // can't simply access the chain ID in a normal view or pure function because the solc View Pure\n // Checker changed `chainid` from pure to view in 0.8.0.\n function _viewChainId() private view returns (uint256 chainId) {\n // Assembly required since `block.chainid` was introduced in 0.8.0.\n assembly {\n chainId := chainid()\n }\n\n address(this); // Silence warnings in older Solc versions.\n }\n\n function _pureChainId() private pure returns (uint256 chainId) {\n function() internal view returns (uint256) fnIn = _viewChainId;\n function() internal pure returns (uint256) pureChainId;\n assembly {\n pureChainId := fnIn\n }\n chainId = pureChainId();\n }\n}\n\n// Wrappers around cheatcodes to avoid footguns\nabstract contract StdCheats is StdCheatsSafe {\n using stdStorage for StdStorage;\n\n StdStorage private stdstore;\n Vm private constant vm = Vm(address(uint160(uint256(keccak256(\"hevm cheat code\")))));\n address private constant CONSOLE2_ADDRESS = 0x000000000000000000636F6e736F6c652e6c6f67;\n\n // Skip forward or rewind time by the specified number of seconds\n function skip(uint256 time) internal virtual {\n vm.warp(vm.getBlockTimestamp() + time);\n }\n\n function rewind(uint256 time) internal virtual {\n vm.warp(vm.getBlockTimestamp() - time);\n }\n\n // Setup a prank from an address that has some ether\n function hoax(address msgSender) internal virtual {\n vm.deal(msgSender, 1 << 128);\n vm.prank(msgSender);\n }\n\n function hoax(address msgSender, uint256 give) internal virtual {\n vm.deal(msgSender, give);\n vm.prank(msgSender);\n }\n\n function hoax(address msgSender, address origin) internal virtual {\n vm.deal(msgSender, 1 << 128);\n vm.prank(msgSender, origin);\n }\n\n function hoax(address msgSender, address origin, uint256 give) internal virtual {\n vm.deal(msgSender, give);\n vm.prank(msgSender, origin);\n }\n\n // Start perpetual prank from an address that has some ether\n function startHoax(address msgSender) internal virtual {\n vm.deal(msgSender, 1 << 128);\n vm.startPrank(msgSender);\n }\n\n function startHoax(address msgSender, uint256 give) internal virtual {\n vm.deal(msgSender, give);\n vm.startPrank(msgSender);\n }\n\n // Start perpetual prank from an address that has some ether\n // tx.origin is set to the origin parameter\n function startHoax(address msgSender, address origin) internal virtual {\n vm.deal(msgSender, 1 << 128);\n vm.startPrank(msgSender, origin);\n }\n\n function startHoax(address msgSender, address origin, uint256 give) internal virtual {\n vm.deal(msgSender, give);\n vm.startPrank(msgSender, origin);\n }\n\n function changePrank(address msgSender) internal virtual {\n console2_log_StdCheats(\"changePrank is deprecated. Please use vm.startPrank instead.\");\n vm.stopPrank();\n vm.startPrank(msgSender);\n }\n\n function changePrank(address msgSender, address txOrigin) internal virtual {\n vm.stopPrank();\n vm.startPrank(msgSender, txOrigin);\n }\n\n // The same as Vm's `deal`\n // Use the alternative signature for ERC20 tokens\n function deal(address to, uint256 give) internal virtual {\n vm.deal(to, give);\n }\n\n // Set the balance of an account for any ERC20 token\n // Use the alternative signature to update `totalSupply`\n function deal(address token, address to, uint256 give) internal virtual {\n deal(token, to, give, false);\n }\n\n // Set the balance of an account for any ERC1155 token\n // Use the alternative signature to update `totalSupply`\n function dealERC1155(address token, address to, uint256 id, uint256 give) internal virtual {\n dealERC1155(token, to, id, give, false);\n }\n\n function deal(address token, address to, uint256 give, bool adjust) internal virtual {\n // get current balance\n (, bytes memory balData) = token.staticcall(abi.encodeWithSelector(0x70a08231, to));\n uint256 prevBal = abi.decode(balData, (uint256));\n\n // update balance\n stdstore.target(token).sig(0x70a08231).with_key(to).checked_write(give);\n\n // update total supply\n if (adjust) {\n (, bytes memory totSupData) = token.staticcall(abi.encodeWithSelector(0x18160ddd));\n uint256 totSup = abi.decode(totSupData, (uint256));\n if (give < prevBal) {\n totSup -= (prevBal - give);\n } else {\n totSup += (give - prevBal);\n }\n stdstore.target(token).sig(0x18160ddd).checked_write(totSup);\n }\n }\n\n function dealERC1155(address token, address to, uint256 id, uint256 give, bool adjust) internal virtual {\n // get current balance\n (, bytes memory balData) = token.staticcall(abi.encodeWithSelector(0x00fdd58e, to, id));\n uint256 prevBal = abi.decode(balData, (uint256));\n\n // update balance\n stdstore.target(token).sig(0x00fdd58e).with_key(to).with_key(id).checked_write(give);\n\n // update total supply\n if (adjust) {\n (, bytes memory totSupData) = token.staticcall(abi.encodeWithSelector(0xbd85b039, id));\n require(\n totSupData.length != 0,\n \"StdCheats deal(address,address,uint,uint,bool): target contract is not ERC1155Supply.\"\n );\n uint256 totSup = abi.decode(totSupData, (uint256));\n if (give < prevBal) {\n totSup -= (prevBal - give);\n } else {\n totSup += (give - prevBal);\n }\n stdstore.target(token).sig(0xbd85b039).with_key(id).checked_write(totSup);\n }\n }\n\n function dealERC721(address token, address to, uint256 id) internal virtual {\n // check if token id is already minted and the actual owner.\n (bool successMinted, bytes memory ownerData) = token.staticcall(abi.encodeWithSelector(0x6352211e, id));\n require(successMinted, \"StdCheats deal(address,address,uint,bool): id not minted.\");\n\n // get owner current balance\n (, bytes memory fromBalData) =\n token.staticcall(abi.encodeWithSelector(0x70a08231, abi.decode(ownerData, (address))));\n uint256 fromPrevBal = abi.decode(fromBalData, (uint256));\n\n // get new user current balance\n (, bytes memory toBalData) = token.staticcall(abi.encodeWithSelector(0x70a08231, to));\n uint256 toPrevBal = abi.decode(toBalData, (uint256));\n\n // update balances\n stdstore.target(token).sig(0x70a08231).with_key(abi.decode(ownerData, (address))).checked_write(--fromPrevBal);\n stdstore.target(token).sig(0x70a08231).with_key(to).checked_write(++toPrevBal);\n\n // update owner\n stdstore.target(token).sig(0x6352211e).with_key(id).checked_write(to);\n }\n\n function deployCodeTo(string memory what, address where) internal virtual {\n deployCodeTo(what, \"\", 0, where);\n }\n\n function deployCodeTo(string memory what, bytes memory args, address where) internal virtual {\n deployCodeTo(what, args, 0, where);\n }\n\n function deployCodeTo(string memory what, bytes memory args, uint256 value, address where) internal virtual {\n bytes memory creationCode = vm.getCode(what);\n vm.etch(where, abi.encodePacked(creationCode, args));\n (bool success, bytes memory runtimeBytecode) = where.call{value: value}(\"\");\n require(success, \"StdCheats deployCodeTo(string,bytes,uint256,address): Failed to create runtime bytecode.\");\n vm.etch(where, runtimeBytecode);\n }\n\n // Used to prevent the compilation of console, which shortens the compilation time when console is not used elsewhere.\n function console2_log_StdCheats(string memory p0) private view {\n (bool status,) = address(CONSOLE2_ADDRESS).staticcall(abi.encodeWithSignature(\"log(string)\", p0));\n status;\n }\n}\n","license":"MIT"},"lib/forge-std/src/StdConstants.sol":{"keccak256":"0x319ccdabfa2c0b2428301445873270ffea20f0e039d4fd5e6eeba65158e4e534","urls":[],"content":"// SPDX-License-Identifier: MIT\npragma solidity >=0.6.2 <0.9.0;\n\nimport {IMulticall3} from \"./interfaces/IMulticall3.sol\";\nimport {Vm} from \"./Vm.sol\";\n\nlibrary StdConstants {\n /// @dev Cheat code address.\n /// Calculated as `address(uint160(uint256(keccak256(\"hevm cheat code\"))))`.\n Vm internal constant VM = Vm(0x7109709ECfa91a80626fF3989D68f67F5b1DD12D);\n /// @dev console.sol and console2.sol work by executing a staticcall to this address.\n /// Calculated as `address(uint160(uint88(bytes11(\"console.log\"))))`.\n address internal constant CONSOLE = 0x000000000000000000636F6e736F6c652e6c6f67;\n /// @dev Used when deploying with create2.\n /// Taken from https://github.com/Arachnid/deterministic-deployment-proxy.\n address internal constant CREATE2_FACTORY = 0x4e59b44847b379578588920cA78FbF26c0B4956C;\n /// @dev The default address for tx.origin and msg.sender.\n /// Calculated as `address(uint160(uint256(keccak256(\"foundry default caller\"))))`.\n address internal constant DEFAULT_SENDER = 0x1804c8AB1F12E6bbf3894d4083f33e07309d1f38;\n /// @dev The address of the first contract `CREATE`d by a running test contract.\n /// When running tests, each test contract is `CREATE`d by `DEFAULT_SENDER` with nonce 1.\n /// Calculated as `VM.computeCreateAddress(VM.computeCreateAddress(DEFAULT_SENDER, 1), 1)`.\n address internal constant DEFAULT_TEST_CONTRACT = 0x5615dEB798BB3E4dFa0139dFa1b3D433Cc23b72f;\n /// @dev Deterministic deployment address of the Multicall3 contract.\n /// Taken from https://www.multicall3.com.\n IMulticall3 internal constant MULTICALL3_ADDRESS = IMulticall3(0xcA11bde05977b3631167028862bE2a173976CA11);\n /// @dev The order of the secp256k1 curve.\n uint256 internal constant SECP256K1_ORDER =\n 115792089237316195423570985008687907852837564279074904382605163141518161494337;\n}\n","license":"MIT"},"lib/forge-std/src/StdJson.sol":{"keccak256":"0xbc0132abe1c2accc2867c0f03667afffdf92f3e95a581bb03c9557eaa38ea500","urls":[],"content":"// SPDX-License-Identifier: MIT\npragma solidity >=0.6.0 <0.9.0;\n\npragma experimental ABIEncoderV2;\n\nimport {VmSafe} from \"./Vm.sol\";\n\n// Helpers for parsing and writing JSON files\n// To parse:\n// ```\n// using stdJson for string;\n// string memory json = vm.readFile(\"\");\n// json.readUint(\"\");\n// ```\n// To write:\n// ```\n// using stdJson for string;\n// string memory json = \"json\";\n// json.serialize(\"a\", uint256(123));\n// string memory semiFinal = json.serialize(\"b\", string(\"test\"));\n// string memory finalJson = json.serialize(\"c\", semiFinal);\n// finalJson.write(\"\");\n// ```\n\nlibrary stdJson {\n VmSafe private constant vm = VmSafe(address(uint160(uint256(keccak256(\"hevm cheat code\")))));\n\n function keyExists(string memory json, string memory key) internal view returns (bool) {\n return vm.keyExistsJson(json, key);\n }\n\n function parseRaw(string memory json, string memory key) internal pure returns (bytes memory) {\n return vm.parseJson(json, key);\n }\n\n function readUint(string memory json, string memory key) internal pure returns (uint256) {\n return vm.parseJsonUint(json, key);\n }\n\n function readUintArray(string memory json, string memory key) internal pure returns (uint256[] memory) {\n return vm.parseJsonUintArray(json, key);\n }\n\n function readInt(string memory json, string memory key) internal pure returns (int256) {\n return vm.parseJsonInt(json, key);\n }\n\n function readIntArray(string memory json, string memory key) internal pure returns (int256[] memory) {\n return vm.parseJsonIntArray(json, key);\n }\n\n function readBytes32(string memory json, string memory key) internal pure returns (bytes32) {\n return vm.parseJsonBytes32(json, key);\n }\n\n function readBytes32Array(string memory json, string memory key) internal pure returns (bytes32[] memory) {\n return vm.parseJsonBytes32Array(json, key);\n }\n\n function readString(string memory json, string memory key) internal pure returns (string memory) {\n return vm.parseJsonString(json, key);\n }\n\n function readStringArray(string memory json, string memory key) internal pure returns (string[] memory) {\n return vm.parseJsonStringArray(json, key);\n }\n\n function readAddress(string memory json, string memory key) internal pure returns (address) {\n return vm.parseJsonAddress(json, key);\n }\n\n function readAddressArray(string memory json, string memory key) internal pure returns (address[] memory) {\n return vm.parseJsonAddressArray(json, key);\n }\n\n function readBool(string memory json, string memory key) internal pure returns (bool) {\n return vm.parseJsonBool(json, key);\n }\n\n function readBoolArray(string memory json, string memory key) internal pure returns (bool[] memory) {\n return vm.parseJsonBoolArray(json, key);\n }\n\n function readBytes(string memory json, string memory key) internal pure returns (bytes memory) {\n return vm.parseJsonBytes(json, key);\n }\n\n function readBytesArray(string memory json, string memory key) internal pure returns (bytes[] memory) {\n return vm.parseJsonBytesArray(json, key);\n }\n\n function readUintOr(string memory json, string memory key, uint256 defaultValue) internal view returns (uint256) {\n return keyExists(json, key) ? readUint(json, key) : defaultValue;\n }\n\n function readUintArrayOr(string memory json, string memory key, uint256[] memory defaultValue)\n internal\n view\n returns (uint256[] memory)\n {\n return keyExists(json, key) ? readUintArray(json, key) : defaultValue;\n }\n\n function readIntOr(string memory json, string memory key, int256 defaultValue) internal view returns (int256) {\n return keyExists(json, key) ? readInt(json, key) : defaultValue;\n }\n\n function readIntArrayOr(string memory json, string memory key, int256[] memory defaultValue)\n internal\n view\n returns (int256[] memory)\n {\n return keyExists(json, key) ? readIntArray(json, key) : defaultValue;\n }\n\n function readBytes32Or(string memory json, string memory key, bytes32 defaultValue)\n internal\n view\n returns (bytes32)\n {\n return keyExists(json, key) ? readBytes32(json, key) : defaultValue;\n }\n\n function readBytes32ArrayOr(string memory json, string memory key, bytes32[] memory defaultValue)\n internal\n view\n returns (bytes32[] memory)\n {\n return keyExists(json, key) ? readBytes32Array(json, key) : defaultValue;\n }\n\n function readStringOr(string memory json, string memory key, string memory defaultValue)\n internal\n view\n returns (string memory)\n {\n return keyExists(json, key) ? readString(json, key) : defaultValue;\n }\n\n function readStringArrayOr(string memory json, string memory key, string[] memory defaultValue)\n internal\n view\n returns (string[] memory)\n {\n return keyExists(json, key) ? readStringArray(json, key) : defaultValue;\n }\n\n function readAddressOr(string memory json, string memory key, address defaultValue)\n internal\n view\n returns (address)\n {\n return keyExists(json, key) ? readAddress(json, key) : defaultValue;\n }\n\n function readAddressArrayOr(string memory json, string memory key, address[] memory defaultValue)\n internal\n view\n returns (address[] memory)\n {\n return keyExists(json, key) ? readAddressArray(json, key) : defaultValue;\n }\n\n function readBoolOr(string memory json, string memory key, bool defaultValue) internal view returns (bool) {\n return keyExists(json, key) ? readBool(json, key) : defaultValue;\n }\n\n function readBoolArrayOr(string memory json, string memory key, bool[] memory defaultValue)\n internal\n view\n returns (bool[] memory)\n {\n return keyExists(json, key) ? readBoolArray(json, key) : defaultValue;\n }\n\n function readBytesOr(string memory json, string memory key, bytes memory defaultValue)\n internal\n view\n returns (bytes memory)\n {\n return keyExists(json, key) ? readBytes(json, key) : defaultValue;\n }\n\n function readBytesArrayOr(string memory json, string memory key, bytes[] memory defaultValue)\n internal\n view\n returns (bytes[] memory)\n {\n return keyExists(json, key) ? readBytesArray(json, key) : defaultValue;\n }\n\n function serialize(string memory jsonKey, string memory rootObject) internal returns (string memory) {\n return vm.serializeJson(jsonKey, rootObject);\n }\n\n function serialize(string memory jsonKey, string memory key, bool value) internal returns (string memory) {\n return vm.serializeBool(jsonKey, key, value);\n }\n\n function serialize(string memory jsonKey, string memory key, bool[] memory value)\n internal\n returns (string memory)\n {\n return vm.serializeBool(jsonKey, key, value);\n }\n\n function serialize(string memory jsonKey, string memory key, uint256 value) internal returns (string memory) {\n return vm.serializeUint(jsonKey, key, value);\n }\n\n function serialize(string memory jsonKey, string memory key, uint256[] memory value)\n internal\n returns (string memory)\n {\n return vm.serializeUint(jsonKey, key, value);\n }\n\n function serialize(string memory jsonKey, string memory key, int256 value) internal returns (string memory) {\n return vm.serializeInt(jsonKey, key, value);\n }\n\n function serialize(string memory jsonKey, string memory key, int256[] memory value)\n internal\n returns (string memory)\n {\n return vm.serializeInt(jsonKey, key, value);\n }\n\n function serialize(string memory jsonKey, string memory key, address value) internal returns (string memory) {\n return vm.serializeAddress(jsonKey, key, value);\n }\n\n function serialize(string memory jsonKey, string memory key, address[] memory value)\n internal\n returns (string memory)\n {\n return vm.serializeAddress(jsonKey, key, value);\n }\n\n function serialize(string memory jsonKey, string memory key, bytes32 value) internal returns (string memory) {\n return vm.serializeBytes32(jsonKey, key, value);\n }\n\n function serialize(string memory jsonKey, string memory key, bytes32[] memory value)\n internal\n returns (string memory)\n {\n return vm.serializeBytes32(jsonKey, key, value);\n }\n\n function serialize(string memory jsonKey, string memory key, bytes memory value) internal returns (string memory) {\n return vm.serializeBytes(jsonKey, key, value);\n }\n\n function serialize(string memory jsonKey, string memory key, bytes[] memory value)\n internal\n returns (string memory)\n {\n return vm.serializeBytes(jsonKey, key, value);\n }\n\n function serialize(string memory jsonKey, string memory key, string memory value)\n internal\n returns (string memory)\n {\n return vm.serializeString(jsonKey, key, value);\n }\n\n function serialize(string memory jsonKey, string memory key, string[] memory value)\n internal\n returns (string memory)\n {\n return vm.serializeString(jsonKey, key, value);\n }\n\n function write(string memory jsonKey, string memory path) internal {\n vm.writeJson(jsonKey, path);\n }\n\n function write(string memory jsonKey, string memory path, string memory valueKey) internal {\n vm.writeJson(jsonKey, path, valueKey);\n }\n}\n","license":"MIT"},"lib/forge-std/src/StdMath.sol":{"keccak256":"0xd90ad4fd8aeaeb8929964e686e769fdedd5eded3fc3815df194a0ab9f91a3fb2","urls":[],"content":"// SPDX-License-Identifier: MIT\npragma solidity >=0.6.2 <0.9.0;\n\nlibrary stdMath {\n int256 private constant INT256_MIN = -57896044618658097711785492504343953926634992332820282019728792003956564819968;\n\n function abs(int256 a) internal pure returns (uint256) {\n // Required or it will fail when `a = type(int256).min`\n if (a == INT256_MIN) {\n return 57896044618658097711785492504343953926634992332820282019728792003956564819968;\n }\n\n return uint256(a > 0 ? a : -a);\n }\n\n function delta(uint256 a, uint256 b) internal pure returns (uint256) {\n return a > b ? a - b : b - a;\n }\n\n function delta(int256 a, int256 b) internal pure returns (uint256) {\n // a and b are of the same sign\n // this works thanks to two's complement, the left-most bit is the sign bit\n if ((a ^ b) > -1) {\n return delta(abs(a), abs(b));\n }\n\n // a and b are of opposite signs\n return abs(a) + abs(b);\n }\n\n function percentDelta(uint256 a, uint256 b) internal pure returns (uint256) {\n uint256 absDelta = delta(a, b);\n\n return absDelta * 1e18 / b;\n }\n\n function percentDelta(int256 a, int256 b) internal pure returns (uint256) {\n uint256 absDelta = delta(a, b);\n uint256 absB = abs(b);\n\n return absDelta * 1e18 / absB;\n }\n}\n","license":"MIT"},"lib/forge-std/src/StdStorage.sol":{"keccak256":"0xb91ab24383a5872b894fc93325eef1add6cbbf981628f18e860068bf88bb7dcc","urls":[],"content":"// SPDX-License-Identifier: MIT\npragma solidity >=0.6.2 <0.9.0;\n\nimport {Vm} from \"./Vm.sol\";\n\nstruct FindData {\n uint256 slot;\n uint256 offsetLeft;\n uint256 offsetRight;\n bool found;\n}\n\nstruct StdStorage {\n mapping(address => mapping(bytes4 => mapping(bytes32 => FindData))) finds;\n bytes32[] _keys;\n bytes4 _sig;\n uint256 _depth;\n address _target;\n bytes32 _set;\n bool _enable_packed_slots;\n bytes _calldata;\n}\n\nlibrary stdStorageSafe {\n event SlotFound(address who, bytes4 fsig, bytes32 keysHash, uint256 slot);\n event WARNING_UninitedSlot(address who, uint256 slot);\n\n Vm private constant vm = Vm(address(uint160(uint256(keccak256(\"hevm cheat code\")))));\n uint256 constant UINT256_MAX = 115792089237316195423570985008687907853269984665640564039457584007913129639935;\n\n function sigs(string memory sigStr) internal pure returns (bytes4) {\n return bytes4(keccak256(bytes(sigStr)));\n }\n\n function getCallParams(StdStorage storage self) internal view returns (bytes memory) {\n if (self._calldata.length == 0) {\n return flatten(self._keys);\n } else {\n return self._calldata;\n }\n }\n\n // Calls target contract with configured parameters\n function callTarget(StdStorage storage self) internal view returns (bool, bytes32) {\n bytes memory cald = abi.encodePacked(self._sig, getCallParams(self));\n (bool success, bytes memory rdat) = self._target.staticcall(cald);\n bytes32 result = bytesToBytes32(rdat, 32 * self._depth);\n\n return (success, result);\n }\n\n // Tries mutating slot value to determine if the targeted value is stored in it.\n // If current value is 0, then we are setting slot value to type(uint256).max\n // Otherwise, we set it to 0. That way, return value should always be affected.\n function checkSlotMutatesCall(StdStorage storage self, bytes32 slot) internal returns (bool) {\n bytes32 prevSlotValue = vm.load(self._target, slot);\n (bool success, bytes32 prevReturnValue) = callTarget(self);\n\n bytes32 testVal = prevReturnValue == bytes32(0) ? bytes32(UINT256_MAX) : bytes32(0);\n vm.store(self._target, slot, testVal);\n\n (, bytes32 newReturnValue) = callTarget(self);\n\n vm.store(self._target, slot, prevSlotValue);\n\n return (success && (prevReturnValue != newReturnValue));\n }\n\n // Tries setting one of the bits in slot to 1 until return value changes.\n // Index of resulted bit is an offset packed slot has from left/right side\n function findOffset(StdStorage storage self, bytes32 slot, bool left) internal returns (bool, uint256) {\n for (uint256 offset = 0; offset < 256; offset++) {\n uint256 valueToPut = left ? (1 << (255 - offset)) : (1 << offset);\n vm.store(self._target, slot, bytes32(valueToPut));\n\n (bool success, bytes32 data) = callTarget(self);\n\n if (success && (uint256(data) > 0)) {\n return (true, offset);\n }\n }\n return (false, 0);\n }\n\n function findOffsets(StdStorage storage self, bytes32 slot) internal returns (bool, uint256, uint256) {\n bytes32 prevSlotValue = vm.load(self._target, slot);\n\n (bool foundLeft, uint256 offsetLeft) = findOffset(self, slot, true);\n (bool foundRight, uint256 offsetRight) = findOffset(self, slot, false);\n\n // `findOffset` may mutate slot value, so we are setting it to initial value\n vm.store(self._target, slot, prevSlotValue);\n return (foundLeft && foundRight, offsetLeft, offsetRight);\n }\n\n function find(StdStorage storage self) internal returns (FindData storage) {\n return find(self, true);\n }\n\n /// @notice find an arbitrary storage slot given a function sig, input data, address of the contract and a value to check against\n // slot complexity:\n // if flat, will be bytes32(uint256(uint));\n // if map, will be keccak256(abi.encode(key, uint(slot)));\n // if deep map, will be keccak256(abi.encode(key1, keccak256(abi.encode(key0, uint(slot)))));\n // if map struct, will be bytes32(uint256(keccak256(abi.encode(key1, keccak256(abi.encode(key0, uint(slot)))))) + structFieldDepth);\n function find(StdStorage storage self, bool _clear) internal returns (FindData storage) {\n address who = self._target;\n bytes4 fsig = self._sig;\n uint256 field_depth = self._depth;\n bytes memory params = getCallParams(self);\n\n // calldata to test against\n if (self.finds[who][fsig][keccak256(abi.encodePacked(params, field_depth))].found) {\n if (_clear) {\n clear(self);\n }\n return self.finds[who][fsig][keccak256(abi.encodePacked(params, field_depth))];\n }\n vm.record();\n (, bytes32 callResult) = callTarget(self);\n (bytes32[] memory reads,) = vm.accesses(address(who));\n\n if (reads.length == 0) {\n revert(\"stdStorage find(StdStorage): No storage use detected for target.\");\n } else {\n for (uint256 i = reads.length; --i >= 0;) {\n bytes32 prev = vm.load(who, reads[i]);\n if (prev == bytes32(0)) {\n emit WARNING_UninitedSlot(who, uint256(reads[i]));\n }\n\n if (!checkSlotMutatesCall(self, reads[i])) {\n continue;\n }\n\n (uint256 offsetLeft, uint256 offsetRight) = (0, 0);\n\n if (self._enable_packed_slots) {\n bool found;\n (found, offsetLeft, offsetRight) = findOffsets(self, reads[i]);\n if (!found) {\n continue;\n }\n }\n\n // Check that value between found offsets is equal to the current call result\n uint256 curVal = (uint256(prev) & getMaskByOffsets(offsetLeft, offsetRight)) >> offsetRight;\n\n if (uint256(callResult) != curVal) {\n continue;\n }\n\n emit SlotFound(who, fsig, keccak256(abi.encodePacked(params, field_depth)), uint256(reads[i]));\n self.finds[who][fsig][keccak256(abi.encodePacked(params, field_depth))] =\n FindData(uint256(reads[i]), offsetLeft, offsetRight, true);\n break;\n }\n }\n\n require(\n self.finds[who][fsig][keccak256(abi.encodePacked(params, field_depth))].found,\n \"stdStorage find(StdStorage): Slot(s) not found.\"\n );\n\n if (_clear) {\n clear(self);\n }\n return self.finds[who][fsig][keccak256(abi.encodePacked(params, field_depth))];\n }\n\n function target(StdStorage storage self, address _target) internal returns (StdStorage storage) {\n self._target = _target;\n return self;\n }\n\n function sig(StdStorage storage self, bytes4 _sig) internal returns (StdStorage storage) {\n self._sig = _sig;\n return self;\n }\n\n function sig(StdStorage storage self, string memory _sig) internal returns (StdStorage storage) {\n self._sig = sigs(_sig);\n return self;\n }\n\n function with_calldata(StdStorage storage self, bytes memory _calldata) internal returns (StdStorage storage) {\n self._calldata = _calldata;\n return self;\n }\n\n function with_key(StdStorage storage self, address who) internal returns (StdStorage storage) {\n self._keys.push(bytes32(uint256(uint160(who))));\n return self;\n }\n\n function with_key(StdStorage storage self, uint256 amt) internal returns (StdStorage storage) {\n self._keys.push(bytes32(amt));\n return self;\n }\n\n function with_key(StdStorage storage self, bytes32 key) internal returns (StdStorage storage) {\n self._keys.push(key);\n return self;\n }\n\n function enable_packed_slots(StdStorage storage self) internal returns (StdStorage storage) {\n self._enable_packed_slots = true;\n return self;\n }\n\n function depth(StdStorage storage self, uint256 _depth) internal returns (StdStorage storage) {\n self._depth = _depth;\n return self;\n }\n\n function read(StdStorage storage self) private returns (bytes memory) {\n FindData storage data = find(self, false);\n uint256 mask = getMaskByOffsets(data.offsetLeft, data.offsetRight);\n uint256 value = (uint256(vm.load(self._target, bytes32(data.slot))) & mask) >> data.offsetRight;\n clear(self);\n return abi.encode(value);\n }\n\n function read_bytes32(StdStorage storage self) internal returns (bytes32) {\n return abi.decode(read(self), (bytes32));\n }\n\n function read_bool(StdStorage storage self) internal returns (bool) {\n int256 v = read_int(self);\n if (v == 0) return false;\n if (v == 1) return true;\n revert(\"stdStorage read_bool(StdStorage): Cannot decode. Make sure you are reading a bool.\");\n }\n\n function read_address(StdStorage storage self) internal returns (address) {\n return abi.decode(read(self), (address));\n }\n\n function read_uint(StdStorage storage self) internal returns (uint256) {\n return abi.decode(read(self), (uint256));\n }\n\n function read_int(StdStorage storage self) internal returns (int256) {\n return abi.decode(read(self), (int256));\n }\n\n function parent(StdStorage storage self) internal returns (uint256, bytes32) {\n address who = self._target;\n uint256 field_depth = self._depth;\n vm.startMappingRecording();\n uint256 child = find(self, true).slot - field_depth;\n (bool found, bytes32 key, bytes32 parent_slot) = vm.getMappingKeyAndParentOf(who, bytes32(child));\n if (!found) {\n revert(\n \"stdStorage read_bool(StdStorage): Cannot find parent. Make sure you give a slot and startMappingRecording() has been called.\"\n );\n }\n return (uint256(parent_slot), key);\n }\n\n function root(StdStorage storage self) internal returns (uint256) {\n address who = self._target;\n uint256 field_depth = self._depth;\n vm.startMappingRecording();\n uint256 child = find(self, true).slot - field_depth;\n bool found;\n bytes32 root_slot;\n bytes32 parent_slot;\n (found,, parent_slot) = vm.getMappingKeyAndParentOf(who, bytes32(child));\n if (!found) {\n revert(\n \"stdStorage read_bool(StdStorage): Cannot find parent. Make sure you give a slot and startMappingRecording() has been called.\"\n );\n }\n while (found) {\n root_slot = parent_slot;\n (found,, parent_slot) = vm.getMappingKeyAndParentOf(who, bytes32(root_slot));\n }\n return uint256(root_slot);\n }\n\n function bytesToBytes32(bytes memory b, uint256 offset) private pure returns (bytes32) {\n bytes32 out;\n\n uint256 max = b.length > 32 ? 32 : b.length;\n for (uint256 i = 0; i < max; i++) {\n out |= bytes32(b[offset + i] & 0xFF) >> (i * 8);\n }\n return out;\n }\n\n function flatten(bytes32[] memory b) private pure returns (bytes memory) {\n bytes memory result = new bytes(b.length * 32);\n for (uint256 i = 0; i < b.length; i++) {\n bytes32 k = b[i];\n /// @solidity memory-safe-assembly\n assembly {\n mstore(add(result, add(32, mul(32, i))), k)\n }\n }\n\n return result;\n }\n\n function clear(StdStorage storage self) internal {\n delete self._target;\n delete self._sig;\n delete self._keys;\n delete self._depth;\n delete self._enable_packed_slots;\n delete self._calldata;\n }\n\n // Returns mask which contains non-zero bits for values between `offsetLeft` and `offsetRight`\n // (slotValue & mask) >> offsetRight will be the value of the given packed variable\n function getMaskByOffsets(uint256 offsetLeft, uint256 offsetRight) internal pure returns (uint256 mask) {\n // mask = ((1 << (256 - (offsetRight + offsetLeft))) - 1) << offsetRight;\n // using assembly because (1 << 256) causes overflow\n assembly {\n mask := shl(offsetRight, sub(shl(sub(256, add(offsetRight, offsetLeft)), 1), 1))\n }\n }\n\n // Returns slot value with updated packed variable.\n function getUpdatedSlotValue(bytes32 curValue, uint256 varValue, uint256 offsetLeft, uint256 offsetRight)\n internal\n pure\n returns (bytes32 newValue)\n {\n return bytes32((uint256(curValue) & ~getMaskByOffsets(offsetLeft, offsetRight)) | (varValue << offsetRight));\n }\n}\n\nlibrary stdStorage {\n Vm private constant vm = Vm(address(uint160(uint256(keccak256(\"hevm cheat code\")))));\n\n function sigs(string memory sigStr) internal pure returns (bytes4) {\n return stdStorageSafe.sigs(sigStr);\n }\n\n function find(StdStorage storage self) internal returns (uint256) {\n return find(self, true);\n }\n\n function find(StdStorage storage self, bool _clear) internal returns (uint256) {\n return stdStorageSafe.find(self, _clear).slot;\n }\n\n function target(StdStorage storage self, address _target) internal returns (StdStorage storage) {\n return stdStorageSafe.target(self, _target);\n }\n\n function sig(StdStorage storage self, bytes4 _sig) internal returns (StdStorage storage) {\n return stdStorageSafe.sig(self, _sig);\n }\n\n function sig(StdStorage storage self, string memory _sig) internal returns (StdStorage storage) {\n return stdStorageSafe.sig(self, _sig);\n }\n\n function with_key(StdStorage storage self, address who) internal returns (StdStorage storage) {\n return stdStorageSafe.with_key(self, who);\n }\n\n function with_key(StdStorage storage self, uint256 amt) internal returns (StdStorage storage) {\n return stdStorageSafe.with_key(self, amt);\n }\n\n function with_key(StdStorage storage self, bytes32 key) internal returns (StdStorage storage) {\n return stdStorageSafe.with_key(self, key);\n }\n\n function with_calldata(StdStorage storage self, bytes memory _calldata) internal returns (StdStorage storage) {\n return stdStorageSafe.with_calldata(self, _calldata);\n }\n\n function enable_packed_slots(StdStorage storage self) internal returns (StdStorage storage) {\n return stdStorageSafe.enable_packed_slots(self);\n }\n\n function depth(StdStorage storage self, uint256 _depth) internal returns (StdStorage storage) {\n return stdStorageSafe.depth(self, _depth);\n }\n\n function clear(StdStorage storage self) internal {\n stdStorageSafe.clear(self);\n }\n\n function checked_write(StdStorage storage self, address who) internal {\n checked_write(self, bytes32(uint256(uint160(who))));\n }\n\n function checked_write(StdStorage storage self, uint256 amt) internal {\n checked_write(self, bytes32(amt));\n }\n\n function checked_write_int(StdStorage storage self, int256 val) internal {\n checked_write(self, bytes32(uint256(val)));\n }\n\n function checked_write(StdStorage storage self, bool write) internal {\n bytes32 t;\n /// @solidity memory-safe-assembly\n assembly {\n t := write\n }\n checked_write(self, t);\n }\n\n function checked_write(StdStorage storage self, bytes32 set) internal {\n address who = self._target;\n bytes4 fsig = self._sig;\n uint256 field_depth = self._depth;\n bytes memory params = stdStorageSafe.getCallParams(self);\n\n if (!self.finds[who][fsig][keccak256(abi.encodePacked(params, field_depth))].found) {\n find(self, false);\n }\n FindData storage data = self.finds[who][fsig][keccak256(abi.encodePacked(params, field_depth))];\n if ((data.offsetLeft + data.offsetRight) > 0) {\n uint256 maxVal = 2 ** (256 - (data.offsetLeft + data.offsetRight));\n require(\n uint256(set) < maxVal,\n string(\n abi.encodePacked(\n \"stdStorage find(StdStorage): Packed slot. We can't fit value greater than \",\n vm.toString(maxVal)\n )\n )\n );\n }\n bytes32 curVal = vm.load(who, bytes32(data.slot));\n bytes32 valToSet = stdStorageSafe.getUpdatedSlotValue(curVal, uint256(set), data.offsetLeft, data.offsetRight);\n\n vm.store(who, bytes32(data.slot), valToSet);\n\n (bool success, bytes32 callResult) = stdStorageSafe.callTarget(self);\n\n if (!success || callResult != set) {\n vm.store(who, bytes32(data.slot), curVal);\n revert(\"stdStorage find(StdStorage): Failed to write value.\");\n }\n clear(self);\n }\n\n function read_bytes32(StdStorage storage self) internal returns (bytes32) {\n return stdStorageSafe.read_bytes32(self);\n }\n\n function read_bool(StdStorage storage self) internal returns (bool) {\n return stdStorageSafe.read_bool(self);\n }\n\n function read_address(StdStorage storage self) internal returns (address) {\n return stdStorageSafe.read_address(self);\n }\n\n function read_uint(StdStorage storage self) internal returns (uint256) {\n return stdStorageSafe.read_uint(self);\n }\n\n function read_int(StdStorage storage self) internal returns (int256) {\n return stdStorageSafe.read_int(self);\n }\n\n function parent(StdStorage storage self) internal returns (uint256, bytes32) {\n return stdStorageSafe.parent(self);\n }\n\n function root(StdStorage storage self) internal returns (uint256) {\n return stdStorageSafe.root(self);\n }\n}\n","license":"MIT"},"lib/forge-std/src/StdStyle.sol":{"keccak256":"0x43e2a8a9b9c2574dabe74f11adf6f782df218f463540e3b5b563609fe108597d","urls":[],"content":"// SPDX-License-Identifier: MIT\npragma solidity >=0.4.22 <0.9.0;\n\nimport {VmSafe} from \"./Vm.sol\";\n\nlibrary StdStyle {\n VmSafe private constant vm = VmSafe(address(uint160(uint256(keccak256(\"hevm cheat code\")))));\n\n string constant RED = \"\\u001b[91m\";\n string constant GREEN = \"\\u001b[92m\";\n string constant YELLOW = \"\\u001b[93m\";\n string constant BLUE = \"\\u001b[94m\";\n string constant MAGENTA = \"\\u001b[95m\";\n string constant CYAN = \"\\u001b[96m\";\n string constant BOLD = \"\\u001b[1m\";\n string constant DIM = \"\\u001b[2m\";\n string constant ITALIC = \"\\u001b[3m\";\n string constant UNDERLINE = \"\\u001b[4m\";\n string constant INVERSE = \"\\u001b[7m\";\n string constant RESET = \"\\u001b[0m\";\n\n function styleConcat(string memory style, string memory self) private pure returns (string memory) {\n return string(abi.encodePacked(style, self, RESET));\n }\n\n function red(string memory self) internal pure returns (string memory) {\n return styleConcat(RED, self);\n }\n\n function red(uint256 self) internal pure returns (string memory) {\n return red(vm.toString(self));\n }\n\n function red(int256 self) internal pure returns (string memory) {\n return red(vm.toString(self));\n }\n\n function red(address self) internal pure returns (string memory) {\n return red(vm.toString(self));\n }\n\n function red(bool self) internal pure returns (string memory) {\n return red(vm.toString(self));\n }\n\n function redBytes(bytes memory self) internal pure returns (string memory) {\n return red(vm.toString(self));\n }\n\n function redBytes32(bytes32 self) internal pure returns (string memory) {\n return red(vm.toString(self));\n }\n\n function green(string memory self) internal pure returns (string memory) {\n return styleConcat(GREEN, self);\n }\n\n function green(uint256 self) internal pure returns (string memory) {\n return green(vm.toString(self));\n }\n\n function green(int256 self) internal pure returns (string memory) {\n return green(vm.toString(self));\n }\n\n function green(address self) internal pure returns (string memory) {\n return green(vm.toString(self));\n }\n\n function green(bool self) internal pure returns (string memory) {\n return green(vm.toString(self));\n }\n\n function greenBytes(bytes memory self) internal pure returns (string memory) {\n return green(vm.toString(self));\n }\n\n function greenBytes32(bytes32 self) internal pure returns (string memory) {\n return green(vm.toString(self));\n }\n\n function yellow(string memory self) internal pure returns (string memory) {\n return styleConcat(YELLOW, self);\n }\n\n function yellow(uint256 self) internal pure returns (string memory) {\n return yellow(vm.toString(self));\n }\n\n function yellow(int256 self) internal pure returns (string memory) {\n return yellow(vm.toString(self));\n }\n\n function yellow(address self) internal pure returns (string memory) {\n return yellow(vm.toString(self));\n }\n\n function yellow(bool self) internal pure returns (string memory) {\n return yellow(vm.toString(self));\n }\n\n function yellowBytes(bytes memory self) internal pure returns (string memory) {\n return yellow(vm.toString(self));\n }\n\n function yellowBytes32(bytes32 self) internal pure returns (string memory) {\n return yellow(vm.toString(self));\n }\n\n function blue(string memory self) internal pure returns (string memory) {\n return styleConcat(BLUE, self);\n }\n\n function blue(uint256 self) internal pure returns (string memory) {\n return blue(vm.toString(self));\n }\n\n function blue(int256 self) internal pure returns (string memory) {\n return blue(vm.toString(self));\n }\n\n function blue(address self) internal pure returns (string memory) {\n return blue(vm.toString(self));\n }\n\n function blue(bool self) internal pure returns (string memory) {\n return blue(vm.toString(self));\n }\n\n function blueBytes(bytes memory self) internal pure returns (string memory) {\n return blue(vm.toString(self));\n }\n\n function blueBytes32(bytes32 self) internal pure returns (string memory) {\n return blue(vm.toString(self));\n }\n\n function magenta(string memory self) internal pure returns (string memory) {\n return styleConcat(MAGENTA, self);\n }\n\n function magenta(uint256 self) internal pure returns (string memory) {\n return magenta(vm.toString(self));\n }\n\n function magenta(int256 self) internal pure returns (string memory) {\n return magenta(vm.toString(self));\n }\n\n function magenta(address self) internal pure returns (string memory) {\n return magenta(vm.toString(self));\n }\n\n function magenta(bool self) internal pure returns (string memory) {\n return magenta(vm.toString(self));\n }\n\n function magentaBytes(bytes memory self) internal pure returns (string memory) {\n return magenta(vm.toString(self));\n }\n\n function magentaBytes32(bytes32 self) internal pure returns (string memory) {\n return magenta(vm.toString(self));\n }\n\n function cyan(string memory self) internal pure returns (string memory) {\n return styleConcat(CYAN, self);\n }\n\n function cyan(uint256 self) internal pure returns (string memory) {\n return cyan(vm.toString(self));\n }\n\n function cyan(int256 self) internal pure returns (string memory) {\n return cyan(vm.toString(self));\n }\n\n function cyan(address self) internal pure returns (string memory) {\n return cyan(vm.toString(self));\n }\n\n function cyan(bool self) internal pure returns (string memory) {\n return cyan(vm.toString(self));\n }\n\n function cyanBytes(bytes memory self) internal pure returns (string memory) {\n return cyan(vm.toString(self));\n }\n\n function cyanBytes32(bytes32 self) internal pure returns (string memory) {\n return cyan(vm.toString(self));\n }\n\n function bold(string memory self) internal pure returns (string memory) {\n return styleConcat(BOLD, self);\n }\n\n function bold(uint256 self) internal pure returns (string memory) {\n return bold(vm.toString(self));\n }\n\n function bold(int256 self) internal pure returns (string memory) {\n return bold(vm.toString(self));\n }\n\n function bold(address self) internal pure returns (string memory) {\n return bold(vm.toString(self));\n }\n\n function bold(bool self) internal pure returns (string memory) {\n return bold(vm.toString(self));\n }\n\n function boldBytes(bytes memory self) internal pure returns (string memory) {\n return bold(vm.toString(self));\n }\n\n function boldBytes32(bytes32 self) internal pure returns (string memory) {\n return bold(vm.toString(self));\n }\n\n function dim(string memory self) internal pure returns (string memory) {\n return styleConcat(DIM, self);\n }\n\n function dim(uint256 self) internal pure returns (string memory) {\n return dim(vm.toString(self));\n }\n\n function dim(int256 self) internal pure returns (string memory) {\n return dim(vm.toString(self));\n }\n\n function dim(address self) internal pure returns (string memory) {\n return dim(vm.toString(self));\n }\n\n function dim(bool self) internal pure returns (string memory) {\n return dim(vm.toString(self));\n }\n\n function dimBytes(bytes memory self) internal pure returns (string memory) {\n return dim(vm.toString(self));\n }\n\n function dimBytes32(bytes32 self) internal pure returns (string memory) {\n return dim(vm.toString(self));\n }\n\n function italic(string memory self) internal pure returns (string memory) {\n return styleConcat(ITALIC, self);\n }\n\n function italic(uint256 self) internal pure returns (string memory) {\n return italic(vm.toString(self));\n }\n\n function italic(int256 self) internal pure returns (string memory) {\n return italic(vm.toString(self));\n }\n\n function italic(address self) internal pure returns (string memory) {\n return italic(vm.toString(self));\n }\n\n function italic(bool self) internal pure returns (string memory) {\n return italic(vm.toString(self));\n }\n\n function italicBytes(bytes memory self) internal pure returns (string memory) {\n return italic(vm.toString(self));\n }\n\n function italicBytes32(bytes32 self) internal pure returns (string memory) {\n return italic(vm.toString(self));\n }\n\n function underline(string memory self) internal pure returns (string memory) {\n return styleConcat(UNDERLINE, self);\n }\n\n function underline(uint256 self) internal pure returns (string memory) {\n return underline(vm.toString(self));\n }\n\n function underline(int256 self) internal pure returns (string memory) {\n return underline(vm.toString(self));\n }\n\n function underline(address self) internal pure returns (string memory) {\n return underline(vm.toString(self));\n }\n\n function underline(bool self) internal pure returns (string memory) {\n return underline(vm.toString(self));\n }\n\n function underlineBytes(bytes memory self) internal pure returns (string memory) {\n return underline(vm.toString(self));\n }\n\n function underlineBytes32(bytes32 self) internal pure returns (string memory) {\n return underline(vm.toString(self));\n }\n\n function inverse(string memory self) internal pure returns (string memory) {\n return styleConcat(INVERSE, self);\n }\n\n function inverse(uint256 self) internal pure returns (string memory) {\n return inverse(vm.toString(self));\n }\n\n function inverse(int256 self) internal pure returns (string memory) {\n return inverse(vm.toString(self));\n }\n\n function inverse(address self) internal pure returns (string memory) {\n return inverse(vm.toString(self));\n }\n\n function inverse(bool self) internal pure returns (string memory) {\n return inverse(vm.toString(self));\n }\n\n function inverseBytes(bytes memory self) internal pure returns (string memory) {\n return inverse(vm.toString(self));\n }\n\n function inverseBytes32(bytes32 self) internal pure returns (string memory) {\n return inverse(vm.toString(self));\n }\n}\n","license":"MIT"},"lib/forge-std/src/StdUtils.sol":{"keccak256":"0x7274081e11c05164fd8eadde4de8305c033e58a43008dea58065f3170ccf0737","urls":[],"content":"// SPDX-License-Identifier: MIT\npragma solidity >=0.6.2 <0.9.0;\n\npragma experimental ABIEncoderV2;\n\nimport {IMulticall3} from \"./interfaces/IMulticall3.sol\";\nimport {VmSafe} from \"./Vm.sol\";\n\nabstract contract StdUtils {\n /*//////////////////////////////////////////////////////////////////////////\n CONSTANTS\n //////////////////////////////////////////////////////////////////////////*/\n\n IMulticall3 private constant multicall = IMulticall3(0xcA11bde05977b3631167028862bE2a173976CA11);\n VmSafe private constant vm = VmSafe(address(uint160(uint256(keccak256(\"hevm cheat code\")))));\n address private constant CONSOLE2_ADDRESS = 0x000000000000000000636F6e736F6c652e6c6f67;\n uint256 private constant INT256_MIN_ABS =\n 57896044618658097711785492504343953926634992332820282019728792003956564819968;\n uint256 private constant SECP256K1_ORDER =\n 115792089237316195423570985008687907852837564279074904382605163141518161494337;\n uint256 private constant UINT256_MAX =\n 115792089237316195423570985008687907853269984665640564039457584007913129639935;\n\n // Used by default when deploying with create2, https://github.com/Arachnid/deterministic-deployment-proxy.\n address private constant CREATE2_FACTORY = 0x4e59b44847b379578588920cA78FbF26c0B4956C;\n\n /*//////////////////////////////////////////////////////////////////////////\n INTERNAL FUNCTIONS\n //////////////////////////////////////////////////////////////////////////*/\n\n function _bound(uint256 x, uint256 min, uint256 max) internal pure virtual returns (uint256 result) {\n require(min <= max, \"StdUtils bound(uint256,uint256,uint256): Max is less than min.\");\n // If x is between min and max, return x directly. This is to ensure that dictionary values\n // do not get shifted if the min is nonzero. More info: https://github.com/foundry-rs/forge-std/issues/188\n if (x >= min && x <= max) return x;\n\n uint256 size = max - min + 1;\n\n // If the value is 0, 1, 2, 3, wrap that to min, min+1, min+2, min+3. Similarly for the UINT256_MAX side.\n // This helps ensure coverage of the min/max values.\n if (x <= 3 && size > x) return min + x;\n if (x >= UINT256_MAX - 3 && size > UINT256_MAX - x) return max - (UINT256_MAX - x);\n\n // Otherwise, wrap x into the range [min, max], i.e. the range is inclusive.\n if (x > max) {\n uint256 diff = x - max;\n uint256 rem = diff % size;\n if (rem == 0) return max;\n result = min + rem - 1;\n } else if (x < min) {\n uint256 diff = min - x;\n uint256 rem = diff % size;\n if (rem == 0) return min;\n result = max - rem + 1;\n }\n }\n\n function bound(uint256 x, uint256 min, uint256 max) internal pure virtual returns (uint256 result) {\n result = _bound(x, min, max);\n console2_log_StdUtils(\"Bound result\", result);\n }\n\n function _bound(int256 x, int256 min, int256 max) internal pure virtual returns (int256 result) {\n require(min <= max, \"StdUtils bound(int256,int256,int256): Max is less than min.\");\n\n // Shifting all int256 values to uint256 to use _bound function. The range of two types are:\n // int256 : -(2**255) ~ (2**255 - 1)\n // uint256: 0 ~ (2**256 - 1)\n // So, add 2**255, INT256_MIN_ABS to the integer values.\n //\n // If the given integer value is -2**255, we cannot use `-uint256(-x)` because of the overflow.\n // So, use `~uint256(x) + 1` instead.\n uint256 _x = x < 0 ? (INT256_MIN_ABS - ~uint256(x) - 1) : (uint256(x) + INT256_MIN_ABS);\n uint256 _min = min < 0 ? (INT256_MIN_ABS - ~uint256(min) - 1) : (uint256(min) + INT256_MIN_ABS);\n uint256 _max = max < 0 ? (INT256_MIN_ABS - ~uint256(max) - 1) : (uint256(max) + INT256_MIN_ABS);\n\n uint256 y = _bound(_x, _min, _max);\n\n // To move it back to int256 value, subtract INT256_MIN_ABS at here.\n result = y < INT256_MIN_ABS ? int256(~(INT256_MIN_ABS - y) + 1) : int256(y - INT256_MIN_ABS);\n }\n\n function bound(int256 x, int256 min, int256 max) internal pure virtual returns (int256 result) {\n result = _bound(x, min, max);\n console2_log_StdUtils(\"Bound result\", vm.toString(result));\n }\n\n function boundPrivateKey(uint256 privateKey) internal pure virtual returns (uint256 result) {\n result = _bound(privateKey, 1, SECP256K1_ORDER - 1);\n }\n\n function bytesToUint(bytes memory b) internal pure virtual returns (uint256) {\n require(b.length <= 32, \"StdUtils bytesToUint(bytes): Bytes length exceeds 32.\");\n return abi.decode(abi.encodePacked(new bytes(32 - b.length), b), (uint256));\n }\n\n /// @dev Compute the address a contract will be deployed at for a given deployer address and nonce\n /// @notice adapted from Solmate implementation (https://github.com/Rari-Capital/solmate/blob/main/src/utils/LibRLP.sol)\n function computeCreateAddress(address deployer, uint256 nonce) internal pure virtual returns (address) {\n console2_log_StdUtils(\"computeCreateAddress is deprecated. Please use vm.computeCreateAddress instead.\");\n return vm.computeCreateAddress(deployer, nonce);\n }\n\n function computeCreate2Address(bytes32 salt, bytes32 initcodeHash, address deployer)\n internal\n pure\n virtual\n returns (address)\n {\n console2_log_StdUtils(\"computeCreate2Address is deprecated. Please use vm.computeCreate2Address instead.\");\n return vm.computeCreate2Address(salt, initcodeHash, deployer);\n }\n\n /// @dev returns the address of a contract created with CREATE2 using the default CREATE2 deployer\n function computeCreate2Address(bytes32 salt, bytes32 initCodeHash) internal pure returns (address) {\n console2_log_StdUtils(\"computeCreate2Address is deprecated. Please use vm.computeCreate2Address instead.\");\n return vm.computeCreate2Address(salt, initCodeHash);\n }\n\n /// @dev returns the hash of the init code (creation code + no args) used in CREATE2 with no constructor arguments\n /// @param creationCode the creation code of a contract C, as returned by type(C).creationCode\n function hashInitCode(bytes memory creationCode) internal pure returns (bytes32) {\n return hashInitCode(creationCode, \"\");\n }\n\n /// @dev returns the hash of the init code (creation code + ABI-encoded args) used in CREATE2\n /// @param creationCode the creation code of a contract C, as returned by type(C).creationCode\n /// @param args the ABI-encoded arguments to the constructor of C\n function hashInitCode(bytes memory creationCode, bytes memory args) internal pure returns (bytes32) {\n return keccak256(abi.encodePacked(creationCode, args));\n }\n\n // Performs a single call with Multicall3 to query the ERC-20 token balances of the given addresses.\n function getTokenBalances(address token, address[] memory addresses)\n internal\n virtual\n returns (uint256[] memory balances)\n {\n uint256 tokenCodeSize;\n assembly {\n tokenCodeSize := extcodesize(token)\n }\n require(tokenCodeSize > 0, \"StdUtils getTokenBalances(address,address[]): Token address is not a contract.\");\n\n // ABI encode the aggregate call to Multicall3.\n uint256 length = addresses.length;\n IMulticall3.Call[] memory calls = new IMulticall3.Call[](length);\n for (uint256 i = 0; i < length; ++i) {\n // 0x70a08231 = bytes4(\"balanceOf(address)\"))\n calls[i] = IMulticall3.Call({target: token, callData: abi.encodeWithSelector(0x70a08231, (addresses[i]))});\n }\n\n // Make the aggregate call.\n (, bytes[] memory returnData) = multicall.aggregate(calls);\n\n // ABI decode the return data and return the balances.\n balances = new uint256[](length);\n for (uint256 i = 0; i < length; ++i) {\n balances[i] = abi.decode(returnData[i], (uint256));\n }\n }\n\n /*//////////////////////////////////////////////////////////////////////////\n PRIVATE FUNCTIONS\n //////////////////////////////////////////////////////////////////////////*/\n\n function addressFromLast20Bytes(bytes32 bytesValue) private pure returns (address) {\n return address(uint160(uint256(bytesValue)));\n }\n\n // This section is used to prevent the compilation of console, which shortens the compilation time when console is\n // not used elsewhere. We also trick the compiler into letting us make the console log methods as `pure` to avoid\n // any breaking changes to function signatures.\n function _castLogPayloadViewToPure(function(bytes memory) internal view fnIn)\n internal\n pure\n returns (function(bytes memory) internal pure fnOut)\n {\n assembly {\n fnOut := fnIn\n }\n }\n\n function _sendLogPayload(bytes memory payload) internal pure {\n _castLogPayloadViewToPure(_sendLogPayloadView)(payload);\n }\n\n function _sendLogPayloadView(bytes memory payload) private view {\n uint256 payloadLength = payload.length;\n address consoleAddress = CONSOLE2_ADDRESS;\n /// @solidity memory-safe-assembly\n assembly {\n let payloadStart := add(payload, 32)\n let r := staticcall(gas(), consoleAddress, payloadStart, payloadLength, 0, 0)\n }\n }\n\n function console2_log_StdUtils(string memory p0) private pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string)\", p0));\n }\n\n function console2_log_StdUtils(string memory p0, uint256 p1) private pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,uint256)\", p0, p1));\n }\n\n function console2_log_StdUtils(string memory p0, string memory p1) private pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,string)\", p0, p1));\n }\n}\n","license":"MIT"},"lib/forge-std/src/Vm.sol":{"keccak256":"0xd91fb0df409fbd22463e937b48b9682d9333c5d4528d8fe7b36102a0323c44bf","urls":[],"content":"// Automatically @generated by scripts/vm.py. Do not modify manually.\n\n// SPDX-License-Identifier: MIT OR Apache-2.0\npragma solidity >=0.6.2 <0.9.0;\npragma experimental ABIEncoderV2;\n\n/// The `VmSafe` interface does not allow manipulation of the EVM state or other actions that may\n/// result in Script simulations differing from on-chain execution. It is recommended to only use\n/// these cheats in scripts.\ninterface VmSafe {\n /// A modification applied to either `msg.sender` or `tx.origin`. Returned by `readCallers`.\n enum CallerMode {\n // No caller modification is currently active.\n None,\n // A one time broadcast triggered by a `vm.broadcast()` call is currently active.\n Broadcast,\n // A recurrent broadcast triggered by a `vm.startBroadcast()` call is currently active.\n RecurrentBroadcast,\n // A one time prank triggered by a `vm.prank()` call is currently active.\n Prank,\n // A recurrent prank triggered by a `vm.startPrank()` call is currently active.\n RecurrentPrank\n }\n\n /// The kind of account access that occurred.\n enum AccountAccessKind {\n // The account was called.\n Call,\n // The account was called via delegatecall.\n DelegateCall,\n // The account was called via callcode.\n CallCode,\n // The account was called via staticcall.\n StaticCall,\n // The account was created.\n Create,\n // The account was selfdestructed.\n SelfDestruct,\n // Synthetic access indicating the current context has resumed after a previous sub-context (AccountAccess).\n Resume,\n // The account's balance was read.\n Balance,\n // The account's codesize was read.\n Extcodesize,\n // The account's codehash was read.\n Extcodehash,\n // The account's code was copied.\n Extcodecopy\n }\n\n /// Forge execution contexts.\n enum ForgeContext {\n // Test group execution context (test, coverage or snapshot).\n TestGroup,\n // `forge test` execution context.\n Test,\n // `forge coverage` execution context.\n Coverage,\n // `forge snapshot` execution context.\n Snapshot,\n // Script group execution context (dry run, broadcast or resume).\n ScriptGroup,\n // `forge script` execution context.\n ScriptDryRun,\n // `forge script --broadcast` execution context.\n ScriptBroadcast,\n // `forge script --resume` execution context.\n ScriptResume,\n // Unknown `forge` execution context.\n Unknown\n }\n\n /// The transaction type (`txType`) of the broadcast.\n enum BroadcastTxType {\n // Represents a CALL broadcast tx.\n Call,\n // Represents a CREATE broadcast tx.\n Create,\n // Represents a CREATE2 broadcast tx.\n Create2\n }\n\n /// An Ethereum log. Returned by `getRecordedLogs`.\n struct Log {\n // The topics of the log, including the signature, if any.\n bytes32[] topics;\n // The raw data of the log.\n bytes data;\n // The address of the log's emitter.\n address emitter;\n }\n\n /// An RPC URL and its alias. Returned by `rpcUrlStructs`.\n struct Rpc {\n // The alias of the RPC URL.\n string key;\n // The RPC URL.\n string url;\n }\n\n /// An RPC log object. Returned by `eth_getLogs`.\n struct EthGetLogs {\n // The address of the log's emitter.\n address emitter;\n // The topics of the log, including the signature, if any.\n bytes32[] topics;\n // The raw data of the log.\n bytes data;\n // The block hash.\n bytes32 blockHash;\n // The block number.\n uint64 blockNumber;\n // The transaction hash.\n bytes32 transactionHash;\n // The transaction index in the block.\n uint64 transactionIndex;\n // The log index.\n uint256 logIndex;\n // Whether the log was removed.\n bool removed;\n }\n\n /// A single entry in a directory listing. Returned by `readDir`.\n struct DirEntry {\n // The error message, if any.\n string errorMessage;\n // The path of the entry.\n string path;\n // The depth of the entry.\n uint64 depth;\n // Whether the entry is a directory.\n bool isDir;\n // Whether the entry is a symlink.\n bool isSymlink;\n }\n\n /// Metadata information about a file.\n /// This structure is returned from the `fsMetadata` function and represents known\n /// metadata about a file such as its permissions, size, modification\n /// times, etc.\n struct FsMetadata {\n // True if this metadata is for a directory.\n bool isDir;\n // True if this metadata is for a symlink.\n bool isSymlink;\n // The size of the file, in bytes, this metadata is for.\n uint256 length;\n // True if this metadata is for a readonly (unwritable) file.\n bool readOnly;\n // The last modification time listed in this metadata.\n uint256 modified;\n // The last access time of this metadata.\n uint256 accessed;\n // The creation time listed in this metadata.\n uint256 created;\n }\n\n /// A wallet with a public and private key.\n struct Wallet {\n // The wallet's address.\n address addr;\n // The wallet's public key `X`.\n uint256 publicKeyX;\n // The wallet's public key `Y`.\n uint256 publicKeyY;\n // The wallet's private key.\n uint256 privateKey;\n }\n\n /// The result of a `tryFfi` call.\n struct FfiResult {\n // The exit code of the call.\n int32 exitCode;\n // The optionally hex-decoded `stdout` data.\n bytes stdout;\n // The `stderr` data.\n bytes stderr;\n }\n\n /// Information on the chain and fork.\n struct ChainInfo {\n // The fork identifier. Set to zero if no fork is active.\n uint256 forkId;\n // The chain ID of the current fork.\n uint256 chainId;\n }\n\n /// The result of a `stopAndReturnStateDiff` call.\n struct AccountAccess {\n // The chain and fork the access occurred.\n ChainInfo chainInfo;\n // The kind of account access that determines what the account is.\n // If kind is Call, DelegateCall, StaticCall or CallCode, then the account is the callee.\n // If kind is Create, then the account is the newly created account.\n // If kind is SelfDestruct, then the account is the selfdestruct recipient.\n // If kind is a Resume, then account represents a account context that has resumed.\n AccountAccessKind kind;\n // The account that was accessed.\n // It's either the account created, callee or a selfdestruct recipient for CREATE, CALL or SELFDESTRUCT.\n address account;\n // What accessed the account.\n address accessor;\n // If the account was initialized or empty prior to the access.\n // An account is considered initialized if it has code, a\n // non-zero nonce, or a non-zero balance.\n bool initialized;\n // The previous balance of the accessed account.\n uint256 oldBalance;\n // The potential new balance of the accessed account.\n // That is, all balance changes are recorded here, even if reverts occurred.\n uint256 newBalance;\n // Code of the account deployed by CREATE.\n bytes deployedCode;\n // Value passed along with the account access\n uint256 value;\n // Input data provided to the CREATE or CALL\n bytes data;\n // If this access reverted in either the current or parent context.\n bool reverted;\n // An ordered list of storage accesses made during an account access operation.\n StorageAccess[] storageAccesses;\n // Call depth traversed during the recording of state differences\n uint64 depth;\n }\n\n /// The storage accessed during an `AccountAccess`.\n struct StorageAccess {\n // The account whose storage was accessed.\n address account;\n // The slot that was accessed.\n bytes32 slot;\n // If the access was a write.\n bool isWrite;\n // The previous value of the slot.\n bytes32 previousValue;\n // The new value of the slot.\n bytes32 newValue;\n // If the access was reverted.\n bool reverted;\n }\n\n /// Gas used. Returned by `lastCallGas`.\n struct Gas {\n // The gas limit of the call.\n uint64 gasLimit;\n // The total gas used.\n uint64 gasTotalUsed;\n // DEPRECATED: The amount of gas used for memory expansion. Ref: \n uint64 gasMemoryUsed;\n // The amount of gas refunded.\n int64 gasRefunded;\n // The amount of gas remaining.\n uint64 gasRemaining;\n }\n\n /// The result of the `stopDebugTraceRecording` call\n struct DebugStep {\n // The stack before executing the step of the run.\n // stack\\[0\\] represents the top of the stack.\n // and only stack data relevant to the opcode execution is contained.\n uint256[] stack;\n // The memory input data before executing the step of the run.\n // only input data relevant to the opcode execution is contained.\n // e.g. for MLOAD, it will have memory\\[offset:offset+32\\] copied here.\n // the offset value can be get by the stack data.\n bytes memoryInput;\n // The opcode that was accessed.\n uint8 opcode;\n // The call depth of the step.\n uint64 depth;\n // Whether the call end up with out of gas error.\n bool isOutOfGas;\n // The contract address where the opcode is running\n address contractAddr;\n }\n\n /// Represents a transaction's broadcast details.\n struct BroadcastTxSummary {\n // The hash of the transaction that was broadcasted\n bytes32 txHash;\n // Represent the type of transaction among CALL, CREATE, CREATE2\n BroadcastTxType txType;\n // The address of the contract that was called or created.\n // This is address of the contract that is created if the txType is CREATE or CREATE2.\n address contractAddress;\n // The block number the transaction landed in.\n uint64 blockNumber;\n // Status of the transaction, retrieved from the transaction receipt.\n bool success;\n }\n\n /// Holds a signed EIP-7702 authorization for an authority account to delegate to an implementation.\n struct SignedDelegation {\n // The y-parity of the recovered secp256k1 signature (0 or 1).\n uint8 v;\n // First 32 bytes of the signature.\n bytes32 r;\n // Second 32 bytes of the signature.\n bytes32 s;\n // The current nonce of the authority account at signing time.\n // Used to ensure signature can't be replayed after account nonce changes.\n uint64 nonce;\n // Address of the contract implementation that will be delegated to.\n // Gets encoded into delegation code: 0xef0100 || implementation.\n address implementation;\n }\n\n /// Represents a \"potential\" revert reason from a single subsequent call when using `vm.assumeNoReverts`.\n /// Reverts that match will result in a FOUNDRY::ASSUME rejection, whereas unmatched reverts will be surfaced\n /// as normal.\n struct PotentialRevert {\n // The allowed origin of the revert opcode; address(0) allows reverts from any address\n address reverter;\n // When true, only matches on the beginning of the revert data, otherwise, matches on entire revert data\n bool partialMatch;\n // The data to use to match encountered reverts\n bytes revertData;\n }\n\n /// An EIP-2930 access list item.\n struct AccessListItem {\n // The address to be added in access list.\n address target;\n // The storage keys to be added in access list.\n bytes32[] storageKeys;\n }\n\n // ======== Crypto ========\n\n /// Derives a private key from the name, labels the account with that name, and returns the wallet.\n function createWallet(string calldata walletLabel) external returns (Wallet memory wallet);\n\n /// Generates a wallet from the private key and returns the wallet.\n function createWallet(uint256 privateKey) external returns (Wallet memory wallet);\n\n /// Generates a wallet from the private key, labels the account with that name, and returns the wallet.\n function createWallet(uint256 privateKey, string calldata walletLabel) external returns (Wallet memory wallet);\n\n /// Derive a private key from a provided mnenomic string (or mnenomic file path)\n /// at the derivation path `m/44'/60'/0'/0/{index}`.\n function deriveKey(string calldata mnemonic, uint32 index) external pure returns (uint256 privateKey);\n\n /// Derive a private key from a provided mnenomic string (or mnenomic file path)\n /// at `{derivationPath}{index}`.\n function deriveKey(string calldata mnemonic, string calldata derivationPath, uint32 index)\n external\n pure\n returns (uint256 privateKey);\n\n /// Derive a private key from a provided mnenomic string (or mnenomic file path) in the specified language\n /// at the derivation path `m/44'/60'/0'/0/{index}`.\n function deriveKey(string calldata mnemonic, uint32 index, string calldata language)\n external\n pure\n returns (uint256 privateKey);\n\n /// Derive a private key from a provided mnenomic string (or mnenomic file path) in the specified language\n /// at `{derivationPath}{index}`.\n function deriveKey(string calldata mnemonic, string calldata derivationPath, uint32 index, string calldata language)\n external\n pure\n returns (uint256 privateKey);\n\n /// Derives secp256r1 public key from the provided `privateKey`.\n function publicKeyP256(uint256 privateKey) external pure returns (uint256 publicKeyX, uint256 publicKeyY);\n\n /// Adds a private key to the local forge wallet and returns the address.\n function rememberKey(uint256 privateKey) external returns (address keyAddr);\n\n /// Derive a set number of wallets from a mnemonic at the derivation path `m/44'/60'/0'/0/{0..count}`.\n /// The respective private keys are saved to the local forge wallet for later use and their addresses are returned.\n function rememberKeys(string calldata mnemonic, string calldata derivationPath, uint32 count)\n external\n returns (address[] memory keyAddrs);\n\n /// Derive a set number of wallets from a mnemonic in the specified language at the derivation path `m/44'/60'/0'/0/{0..count}`.\n /// The respective private keys are saved to the local forge wallet for later use and their addresses are returned.\n function rememberKeys(\n string calldata mnemonic,\n string calldata derivationPath,\n string calldata language,\n uint32 count\n ) external returns (address[] memory keyAddrs);\n\n /// Signs data with a `Wallet`.\n /// Returns a compact signature (`r`, `vs`) as per EIP-2098, where `vs` encodes both the\n /// signature's `s` value, and the recovery id `v` in a single bytes32.\n /// This format reduces the signature size from 65 to 64 bytes.\n function signCompact(Wallet calldata wallet, bytes32 digest) external returns (bytes32 r, bytes32 vs);\n\n /// Signs `digest` with `privateKey` using the secp256k1 curve.\n /// Returns a compact signature (`r`, `vs`) as per EIP-2098, where `vs` encodes both the\n /// signature's `s` value, and the recovery id `v` in a single bytes32.\n /// This format reduces the signature size from 65 to 64 bytes.\n function signCompact(uint256 privateKey, bytes32 digest) external pure returns (bytes32 r, bytes32 vs);\n\n /// Signs `digest` with signer provided to script using the secp256k1 curve.\n /// Returns a compact signature (`r`, `vs`) as per EIP-2098, where `vs` encodes both the\n /// signature's `s` value, and the recovery id `v` in a single bytes32.\n /// This format reduces the signature size from 65 to 64 bytes.\n /// If `--sender` is provided, the signer with provided address is used, otherwise,\n /// if exactly one signer is provided to the script, that signer is used.\n /// Raises error if signer passed through `--sender` does not match any unlocked signers or\n /// if `--sender` is not provided and not exactly one signer is passed to the script.\n function signCompact(bytes32 digest) external pure returns (bytes32 r, bytes32 vs);\n\n /// Signs `digest` with signer provided to script using the secp256k1 curve.\n /// Returns a compact signature (`r`, `vs`) as per EIP-2098, where `vs` encodes both the\n /// signature's `s` value, and the recovery id `v` in a single bytes32.\n /// This format reduces the signature size from 65 to 64 bytes.\n /// Raises error if none of the signers passed into the script have provided address.\n function signCompact(address signer, bytes32 digest) external pure returns (bytes32 r, bytes32 vs);\n\n /// Signs `digest` with `privateKey` using the secp256r1 curve.\n function signP256(uint256 privateKey, bytes32 digest) external pure returns (bytes32 r, bytes32 s);\n\n /// Signs data with a `Wallet`.\n function sign(Wallet calldata wallet, bytes32 digest) external returns (uint8 v, bytes32 r, bytes32 s);\n\n /// Signs `digest` with `privateKey` using the secp256k1 curve.\n function sign(uint256 privateKey, bytes32 digest) external pure returns (uint8 v, bytes32 r, bytes32 s);\n\n /// Signs `digest` with signer provided to script using the secp256k1 curve.\n /// If `--sender` is provided, the signer with provided address is used, otherwise,\n /// if exactly one signer is provided to the script, that signer is used.\n /// Raises error if signer passed through `--sender` does not match any unlocked signers or\n /// if `--sender` is not provided and not exactly one signer is passed to the script.\n function sign(bytes32 digest) external pure returns (uint8 v, bytes32 r, bytes32 s);\n\n /// Signs `digest` with signer provided to script using the secp256k1 curve.\n /// Raises error if none of the signers passed into the script have provided address.\n function sign(address signer, bytes32 digest) external pure returns (uint8 v, bytes32 r, bytes32 s);\n\n // ======== Environment ========\n\n /// Gets the environment variable `name` and parses it as `address`.\n /// Reverts if the variable was not found or could not be parsed.\n function envAddress(string calldata name) external view returns (address value);\n\n /// Gets the environment variable `name` and parses it as an array of `address`, delimited by `delim`.\n /// Reverts if the variable was not found or could not be parsed.\n function envAddress(string calldata name, string calldata delim) external view returns (address[] memory value);\n\n /// Gets the environment variable `name` and parses it as `bool`.\n /// Reverts if the variable was not found or could not be parsed.\n function envBool(string calldata name) external view returns (bool value);\n\n /// Gets the environment variable `name` and parses it as an array of `bool`, delimited by `delim`.\n /// Reverts if the variable was not found or could not be parsed.\n function envBool(string calldata name, string calldata delim) external view returns (bool[] memory value);\n\n /// Gets the environment variable `name` and parses it as `bytes32`.\n /// Reverts if the variable was not found or could not be parsed.\n function envBytes32(string calldata name) external view returns (bytes32 value);\n\n /// Gets the environment variable `name` and parses it as an array of `bytes32`, delimited by `delim`.\n /// Reverts if the variable was not found or could not be parsed.\n function envBytes32(string calldata name, string calldata delim) external view returns (bytes32[] memory value);\n\n /// Gets the environment variable `name` and parses it as `bytes`.\n /// Reverts if the variable was not found or could not be parsed.\n function envBytes(string calldata name) external view returns (bytes memory value);\n\n /// Gets the environment variable `name` and parses it as an array of `bytes`, delimited by `delim`.\n /// Reverts if the variable was not found or could not be parsed.\n function envBytes(string calldata name, string calldata delim) external view returns (bytes[] memory value);\n\n /// Gets the environment variable `name` and returns true if it exists, else returns false.\n function envExists(string calldata name) external view returns (bool result);\n\n /// Gets the environment variable `name` and parses it as `int256`.\n /// Reverts if the variable was not found or could not be parsed.\n function envInt(string calldata name) external view returns (int256 value);\n\n /// Gets the environment variable `name` and parses it as an array of `int256`, delimited by `delim`.\n /// Reverts if the variable was not found or could not be parsed.\n function envInt(string calldata name, string calldata delim) external view returns (int256[] memory value);\n\n /// Gets the environment variable `name` and parses it as `bool`.\n /// Reverts if the variable could not be parsed.\n /// Returns `defaultValue` if the variable was not found.\n function envOr(string calldata name, bool defaultValue) external view returns (bool value);\n\n /// Gets the environment variable `name` and parses it as `uint256`.\n /// Reverts if the variable could not be parsed.\n /// Returns `defaultValue` if the variable was not found.\n function envOr(string calldata name, uint256 defaultValue) external view returns (uint256 value);\n\n /// Gets the environment variable `name` and parses it as an array of `address`, delimited by `delim`.\n /// Reverts if the variable could not be parsed.\n /// Returns `defaultValue` if the variable was not found.\n function envOr(string calldata name, string calldata delim, address[] calldata defaultValue)\n external\n view\n returns (address[] memory value);\n\n /// Gets the environment variable `name` and parses it as an array of `bytes32`, delimited by `delim`.\n /// Reverts if the variable could not be parsed.\n /// Returns `defaultValue` if the variable was not found.\n function envOr(string calldata name, string calldata delim, bytes32[] calldata defaultValue)\n external\n view\n returns (bytes32[] memory value);\n\n /// Gets the environment variable `name` and parses it as an array of `string`, delimited by `delim`.\n /// Reverts if the variable could not be parsed.\n /// Returns `defaultValue` if the variable was not found.\n function envOr(string calldata name, string calldata delim, string[] calldata defaultValue)\n external\n view\n returns (string[] memory value);\n\n /// Gets the environment variable `name` and parses it as an array of `bytes`, delimited by `delim`.\n /// Reverts if the variable could not be parsed.\n /// Returns `defaultValue` if the variable was not found.\n function envOr(string calldata name, string calldata delim, bytes[] calldata defaultValue)\n external\n view\n returns (bytes[] memory value);\n\n /// Gets the environment variable `name` and parses it as `int256`.\n /// Reverts if the variable could not be parsed.\n /// Returns `defaultValue` if the variable was not found.\n function envOr(string calldata name, int256 defaultValue) external view returns (int256 value);\n\n /// Gets the environment variable `name` and parses it as `address`.\n /// Reverts if the variable could not be parsed.\n /// Returns `defaultValue` if the variable was not found.\n function envOr(string calldata name, address defaultValue) external view returns (address value);\n\n /// Gets the environment variable `name` and parses it as `bytes32`.\n /// Reverts if the variable could not be parsed.\n /// Returns `defaultValue` if the variable was not found.\n function envOr(string calldata name, bytes32 defaultValue) external view returns (bytes32 value);\n\n /// Gets the environment variable `name` and parses it as `string`.\n /// Reverts if the variable could not be parsed.\n /// Returns `defaultValue` if the variable was not found.\n function envOr(string calldata name, string calldata defaultValue) external view returns (string memory value);\n\n /// Gets the environment variable `name` and parses it as `bytes`.\n /// Reverts if the variable could not be parsed.\n /// Returns `defaultValue` if the variable was not found.\n function envOr(string calldata name, bytes calldata defaultValue) external view returns (bytes memory value);\n\n /// Gets the environment variable `name` and parses it as an array of `bool`, delimited by `delim`.\n /// Reverts if the variable could not be parsed.\n /// Returns `defaultValue` if the variable was not found.\n function envOr(string calldata name, string calldata delim, bool[] calldata defaultValue)\n external\n view\n returns (bool[] memory value);\n\n /// Gets the environment variable `name` and parses it as an array of `uint256`, delimited by `delim`.\n /// Reverts if the variable could not be parsed.\n /// Returns `defaultValue` if the variable was not found.\n function envOr(string calldata name, string calldata delim, uint256[] calldata defaultValue)\n external\n view\n returns (uint256[] memory value);\n\n /// Gets the environment variable `name` and parses it as an array of `int256`, delimited by `delim`.\n /// Reverts if the variable could not be parsed.\n /// Returns `defaultValue` if the variable was not found.\n function envOr(string calldata name, string calldata delim, int256[] calldata defaultValue)\n external\n view\n returns (int256[] memory value);\n\n /// Gets the environment variable `name` and parses it as `string`.\n /// Reverts if the variable was not found or could not be parsed.\n function envString(string calldata name) external view returns (string memory value);\n\n /// Gets the environment variable `name` and parses it as an array of `string`, delimited by `delim`.\n /// Reverts if the variable was not found or could not be parsed.\n function envString(string calldata name, string calldata delim) external view returns (string[] memory value);\n\n /// Gets the environment variable `name` and parses it as `uint256`.\n /// Reverts if the variable was not found or could not be parsed.\n function envUint(string calldata name) external view returns (uint256 value);\n\n /// Gets the environment variable `name` and parses it as an array of `uint256`, delimited by `delim`.\n /// Reverts if the variable was not found or could not be parsed.\n function envUint(string calldata name, string calldata delim) external view returns (uint256[] memory value);\n\n /// Returns true if `forge` command was executed in given context.\n function isContext(ForgeContext context) external view returns (bool result);\n\n /// Sets environment variables.\n function setEnv(string calldata name, string calldata value) external;\n\n // ======== EVM ========\n\n /// Gets all accessed reads and write slot from a `vm.record` session, for a given address.\n function accesses(address target) external returns (bytes32[] memory readSlots, bytes32[] memory writeSlots);\n\n /// Gets the address for a given private key.\n function addr(uint256 privateKey) external pure returns (address keyAddr);\n\n /// Gets all the logs according to specified filter.\n function eth_getLogs(uint256 fromBlock, uint256 toBlock, address target, bytes32[] calldata topics)\n external\n returns (EthGetLogs[] memory logs);\n\n /// Gets the current `block.blobbasefee`.\n /// You should use this instead of `block.blobbasefee` if you use `vm.blobBaseFee`, as `block.blobbasefee` is assumed to be constant across a transaction,\n /// and as a result will get optimized out by the compiler.\n /// See https://github.com/foundry-rs/foundry/issues/6180\n function getBlobBaseFee() external view returns (uint256 blobBaseFee);\n\n /// Gets the current `block.number`.\n /// You should use this instead of `block.number` if you use `vm.roll`, as `block.number` is assumed to be constant across a transaction,\n /// and as a result will get optimized out by the compiler.\n /// See https://github.com/foundry-rs/foundry/issues/6180\n function getBlockNumber() external view returns (uint256 height);\n\n /// Gets the current `block.timestamp`.\n /// You should use this instead of `block.timestamp` if you use `vm.warp`, as `block.timestamp` is assumed to be constant across a transaction,\n /// and as a result will get optimized out by the compiler.\n /// See https://github.com/foundry-rs/foundry/issues/6180\n function getBlockTimestamp() external view returns (uint256 timestamp);\n\n /// Gets the map key and parent of a mapping at a given slot, for a given address.\n function getMappingKeyAndParentOf(address target, bytes32 elementSlot)\n external\n returns (bool found, bytes32 key, bytes32 parent);\n\n /// Gets the number of elements in the mapping at the given slot, for a given address.\n function getMappingLength(address target, bytes32 mappingSlot) external returns (uint256 length);\n\n /// Gets the elements at index idx of the mapping at the given slot, for a given address. The\n /// index must be less than the length of the mapping (i.e. the number of keys in the mapping).\n function getMappingSlotAt(address target, bytes32 mappingSlot, uint256 idx) external returns (bytes32 value);\n\n /// Gets the nonce of an account.\n function getNonce(address account) external view returns (uint64 nonce);\n\n /// Get the nonce of a `Wallet`.\n function getNonce(Wallet calldata wallet) external returns (uint64 nonce);\n\n /// Gets all the recorded logs.\n function getRecordedLogs() external returns (Log[] memory logs);\n\n /// Returns state diffs from current `vm.startStateDiffRecording` session.\n function getStateDiff() external view returns (string memory diff);\n\n /// Returns state diffs from current `vm.startStateDiffRecording` session, in json format.\n function getStateDiffJson() external view returns (string memory diff);\n\n /// Gets the gas used in the last call from the callee perspective.\n function lastCallGas() external view returns (Gas memory gas);\n\n /// Loads a storage slot from an address.\n function load(address target, bytes32 slot) external view returns (bytes32 data);\n\n /// Pauses gas metering (i.e. gas usage is not counted). Noop if already paused.\n function pauseGasMetering() external;\n\n /// Records all storage reads and writes.\n function record() external;\n\n /// Record all the transaction logs.\n function recordLogs() external;\n\n /// Reset gas metering (i.e. gas usage is set to gas limit).\n function resetGasMetering() external;\n\n /// Resumes gas metering (i.e. gas usage is counted again). Noop if already on.\n function resumeGasMetering() external;\n\n /// Performs an Ethereum JSON-RPC request to the current fork URL.\n function rpc(string calldata method, string calldata params) external returns (bytes memory data);\n\n /// Performs an Ethereum JSON-RPC request to the given endpoint.\n function rpc(string calldata urlOrAlias, string calldata method, string calldata params)\n external\n returns (bytes memory data);\n\n /// Records the debug trace during the run.\n function startDebugTraceRecording() external;\n\n /// Starts recording all map SSTOREs for later retrieval.\n function startMappingRecording() external;\n\n /// Record all account accesses as part of CREATE, CALL or SELFDESTRUCT opcodes in order,\n /// along with the context of the calls\n function startStateDiffRecording() external;\n\n /// Stop debug trace recording and returns the recorded debug trace.\n function stopAndReturnDebugTraceRecording() external returns (DebugStep[] memory step);\n\n /// Returns an ordered array of all account accesses from a `vm.startStateDiffRecording` session.\n function stopAndReturnStateDiff() external returns (AccountAccess[] memory accountAccesses);\n\n /// Stops recording all map SSTOREs for later retrieval and clears the recorded data.\n function stopMappingRecording() external;\n\n // ======== Filesystem ========\n\n /// Closes file for reading, resetting the offset and allowing to read it from beginning with readLine.\n /// `path` is relative to the project root.\n function closeFile(string calldata path) external;\n\n /// Copies the contents of one file to another. This function will **overwrite** the contents of `to`.\n /// On success, the total number of bytes copied is returned and it is equal to the length of the `to` file as reported by `metadata`.\n /// Both `from` and `to` are relative to the project root.\n function copyFile(string calldata from, string calldata to) external returns (uint64 copied);\n\n /// Creates a new, empty directory at the provided path.\n /// This cheatcode will revert in the following situations, but is not limited to just these cases:\n /// - User lacks permissions to modify `path`.\n /// - A parent of the given path doesn't exist and `recursive` is false.\n /// - `path` already exists and `recursive` is false.\n /// `path` is relative to the project root.\n function createDir(string calldata path, bool recursive) external;\n\n /// Deploys a contract from an artifact file. Takes in the relative path to the json file or the path to the\n /// artifact in the form of :: where and parts are optional.\n function deployCode(string calldata artifactPath) external returns (address deployedAddress);\n\n /// Deploys a contract from an artifact file. Takes in the relative path to the json file or the path to the\n /// artifact in the form of :: where and parts are optional.\n /// Additionally accepts abi-encoded constructor arguments.\n function deployCode(string calldata artifactPath, bytes calldata constructorArgs)\n external\n returns (address deployedAddress);\n\n /// Returns true if the given path points to an existing entity, else returns false.\n function exists(string calldata path) external view returns (bool result);\n\n /// Performs a foreign function call via the terminal.\n function ffi(string[] calldata commandInput) external returns (bytes memory result);\n\n /// Given a path, query the file system to get information about a file, directory, etc.\n function fsMetadata(string calldata path) external view returns (FsMetadata memory metadata);\n\n /// Gets the artifact path from code (aka. creation code).\n function getArtifactPathByCode(bytes calldata code) external view returns (string memory path);\n\n /// Gets the artifact path from deployed code (aka. runtime code).\n function getArtifactPathByDeployedCode(bytes calldata deployedCode) external view returns (string memory path);\n\n /// Returns the most recent broadcast for the given contract on `chainId` matching `txType`.\n /// For example:\n /// The most recent deployment can be fetched by passing `txType` as `CREATE` or `CREATE2`.\n /// The most recent call can be fetched by passing `txType` as `CALL`.\n function getBroadcast(string calldata contractName, uint64 chainId, BroadcastTxType txType)\n external\n view\n returns (BroadcastTxSummary memory);\n\n /// Returns all broadcasts for the given contract on `chainId` with the specified `txType`.\n /// Sorted such that the most recent broadcast is the first element, and the oldest is the last. i.e descending order of BroadcastTxSummary.blockNumber.\n function getBroadcasts(string calldata contractName, uint64 chainId, BroadcastTxType txType)\n external\n view\n returns (BroadcastTxSummary[] memory);\n\n /// Returns all broadcasts for the given contract on `chainId`.\n /// Sorted such that the most recent broadcast is the first element, and the oldest is the last. i.e descending order of BroadcastTxSummary.blockNumber.\n function getBroadcasts(string calldata contractName, uint64 chainId)\n external\n view\n returns (BroadcastTxSummary[] memory);\n\n /// Gets the creation bytecode from an artifact file. Takes in the relative path to the json file or the path to the\n /// artifact in the form of :: where and parts are optional.\n function getCode(string calldata artifactPath) external view returns (bytes memory creationBytecode);\n\n /// Gets the deployed bytecode from an artifact file. Takes in the relative path to the json file or the path to the\n /// artifact in the form of :: where and parts are optional.\n function getDeployedCode(string calldata artifactPath) external view returns (bytes memory runtimeBytecode);\n\n /// Returns the most recent deployment for the current `chainId`.\n function getDeployment(string calldata contractName) external view returns (address deployedAddress);\n\n /// Returns the most recent deployment for the given contract on `chainId`\n function getDeployment(string calldata contractName, uint64 chainId)\n external\n view\n returns (address deployedAddress);\n\n /// Returns all deployments for the given contract on `chainId`\n /// Sorted in descending order of deployment time i.e descending order of BroadcastTxSummary.blockNumber.\n /// The most recent deployment is the first element, and the oldest is the last.\n function getDeployments(string calldata contractName, uint64 chainId)\n external\n view\n returns (address[] memory deployedAddresses);\n\n /// Returns true if the path exists on disk and is pointing at a directory, else returns false.\n function isDir(string calldata path) external view returns (bool result);\n\n /// Returns true if the path exists on disk and is pointing at a regular file, else returns false.\n function isFile(string calldata path) external view returns (bool result);\n\n /// Get the path of the current project root.\n function projectRoot() external view returns (string memory path);\n\n /// Prompts the user for a string value in the terminal.\n function prompt(string calldata promptText) external returns (string memory input);\n\n /// Prompts the user for an address in the terminal.\n function promptAddress(string calldata promptText) external returns (address);\n\n /// Prompts the user for a hidden string value in the terminal.\n function promptSecret(string calldata promptText) external returns (string memory input);\n\n /// Prompts the user for hidden uint256 in the terminal (usually pk).\n function promptSecretUint(string calldata promptText) external returns (uint256);\n\n /// Prompts the user for uint256 in the terminal.\n function promptUint(string calldata promptText) external returns (uint256);\n\n /// Reads the directory at the given path recursively, up to `maxDepth`.\n /// `maxDepth` defaults to 1, meaning only the direct children of the given directory will be returned.\n /// Follows symbolic links if `followLinks` is true.\n function readDir(string calldata path) external view returns (DirEntry[] memory entries);\n\n /// See `readDir(string)`.\n function readDir(string calldata path, uint64 maxDepth) external view returns (DirEntry[] memory entries);\n\n /// See `readDir(string)`.\n function readDir(string calldata path, uint64 maxDepth, bool followLinks)\n external\n view\n returns (DirEntry[] memory entries);\n\n /// Reads the entire content of file to string. `path` is relative to the project root.\n function readFile(string calldata path) external view returns (string memory data);\n\n /// Reads the entire content of file as binary. `path` is relative to the project root.\n function readFileBinary(string calldata path) external view returns (bytes memory data);\n\n /// Reads next line of file to string.\n function readLine(string calldata path) external view returns (string memory line);\n\n /// Reads a symbolic link, returning the path that the link points to.\n /// This cheatcode will revert in the following situations, but is not limited to just these cases:\n /// - `path` is not a symbolic link.\n /// - `path` does not exist.\n function readLink(string calldata linkPath) external view returns (string memory targetPath);\n\n /// Removes a directory at the provided path.\n /// This cheatcode will revert in the following situations, but is not limited to just these cases:\n /// - `path` doesn't exist.\n /// - `path` isn't a directory.\n /// - User lacks permissions to modify `path`.\n /// - The directory is not empty and `recursive` is false.\n /// `path` is relative to the project root.\n function removeDir(string calldata path, bool recursive) external;\n\n /// Removes a file from the filesystem.\n /// This cheatcode will revert in the following situations, but is not limited to just these cases:\n /// - `path` points to a directory.\n /// - The file doesn't exist.\n /// - The user lacks permissions to remove the file.\n /// `path` is relative to the project root.\n function removeFile(string calldata path) external;\n\n /// Performs a foreign function call via terminal and returns the exit code, stdout, and stderr.\n function tryFfi(string[] calldata commandInput) external returns (FfiResult memory result);\n\n /// Returns the time since unix epoch in milliseconds.\n function unixTime() external view returns (uint256 milliseconds);\n\n /// Writes data to file, creating a file if it does not exist, and entirely replacing its contents if it does.\n /// `path` is relative to the project root.\n function writeFile(string calldata path, string calldata data) external;\n\n /// Writes binary data to a file, creating a file if it does not exist, and entirely replacing its contents if it does.\n /// `path` is relative to the project root.\n function writeFileBinary(string calldata path, bytes calldata data) external;\n\n /// Writes line to file, creating a file if it does not exist.\n /// `path` is relative to the project root.\n function writeLine(string calldata path, string calldata data) external;\n\n // ======== JSON ========\n\n /// Checks if `key` exists in a JSON object.\n function keyExistsJson(string calldata json, string calldata key) external view returns (bool);\n\n /// Parses a string of JSON data at `key` and coerces it to `address`.\n function parseJsonAddress(string calldata json, string calldata key) external pure returns (address);\n\n /// Parses a string of JSON data at `key` and coerces it to `address[]`.\n function parseJsonAddressArray(string calldata json, string calldata key)\n external\n pure\n returns (address[] memory);\n\n /// Parses a string of JSON data at `key` and coerces it to `bool`.\n function parseJsonBool(string calldata json, string calldata key) external pure returns (bool);\n\n /// Parses a string of JSON data at `key` and coerces it to `bool[]`.\n function parseJsonBoolArray(string calldata json, string calldata key) external pure returns (bool[] memory);\n\n /// Parses a string of JSON data at `key` and coerces it to `bytes`.\n function parseJsonBytes(string calldata json, string calldata key) external pure returns (bytes memory);\n\n /// Parses a string of JSON data at `key` and coerces it to `bytes32`.\n function parseJsonBytes32(string calldata json, string calldata key) external pure returns (bytes32);\n\n /// Parses a string of JSON data at `key` and coerces it to `bytes32[]`.\n function parseJsonBytes32Array(string calldata json, string calldata key)\n external\n pure\n returns (bytes32[] memory);\n\n /// Parses a string of JSON data at `key` and coerces it to `bytes[]`.\n function parseJsonBytesArray(string calldata json, string calldata key) external pure returns (bytes[] memory);\n\n /// Parses a string of JSON data at `key` and coerces it to `int256`.\n function parseJsonInt(string calldata json, string calldata key) external pure returns (int256);\n\n /// Parses a string of JSON data at `key` and coerces it to `int256[]`.\n function parseJsonIntArray(string calldata json, string calldata key) external pure returns (int256[] memory);\n\n /// Returns an array of all the keys in a JSON object.\n function parseJsonKeys(string calldata json, string calldata key) external pure returns (string[] memory keys);\n\n /// Parses a string of JSON data at `key` and coerces it to `string`.\n function parseJsonString(string calldata json, string calldata key) external pure returns (string memory);\n\n /// Parses a string of JSON data at `key` and coerces it to `string[]`.\n function parseJsonStringArray(string calldata json, string calldata key) external pure returns (string[] memory);\n\n /// Parses a string of JSON data at `key` and coerces it to type array corresponding to `typeDescription`.\n function parseJsonTypeArray(string calldata json, string calldata key, string calldata typeDescription)\n external\n pure\n returns (bytes memory);\n\n /// Parses a string of JSON data and coerces it to type corresponding to `typeDescription`.\n function parseJsonType(string calldata json, string calldata typeDescription)\n external\n pure\n returns (bytes memory);\n\n /// Parses a string of JSON data at `key` and coerces it to type corresponding to `typeDescription`.\n function parseJsonType(string calldata json, string calldata key, string calldata typeDescription)\n external\n pure\n returns (bytes memory);\n\n /// Parses a string of JSON data at `key` and coerces it to `uint256`.\n function parseJsonUint(string calldata json, string calldata key) external pure returns (uint256);\n\n /// Parses a string of JSON data at `key` and coerces it to `uint256[]`.\n function parseJsonUintArray(string calldata json, string calldata key) external pure returns (uint256[] memory);\n\n /// ABI-encodes a JSON object.\n function parseJson(string calldata json) external pure returns (bytes memory abiEncodedData);\n\n /// ABI-encodes a JSON object at `key`.\n function parseJson(string calldata json, string calldata key) external pure returns (bytes memory abiEncodedData);\n\n /// See `serializeJson`.\n function serializeAddress(string calldata objectKey, string calldata valueKey, address value)\n external\n returns (string memory json);\n\n /// See `serializeJson`.\n function serializeAddress(string calldata objectKey, string calldata valueKey, address[] calldata values)\n external\n returns (string memory json);\n\n /// See `serializeJson`.\n function serializeBool(string calldata objectKey, string calldata valueKey, bool value)\n external\n returns (string memory json);\n\n /// See `serializeJson`.\n function serializeBool(string calldata objectKey, string calldata valueKey, bool[] calldata values)\n external\n returns (string memory json);\n\n /// See `serializeJson`.\n function serializeBytes32(string calldata objectKey, string calldata valueKey, bytes32 value)\n external\n returns (string memory json);\n\n /// See `serializeJson`.\n function serializeBytes32(string calldata objectKey, string calldata valueKey, bytes32[] calldata values)\n external\n returns (string memory json);\n\n /// See `serializeJson`.\n function serializeBytes(string calldata objectKey, string calldata valueKey, bytes calldata value)\n external\n returns (string memory json);\n\n /// See `serializeJson`.\n function serializeBytes(string calldata objectKey, string calldata valueKey, bytes[] calldata values)\n external\n returns (string memory json);\n\n /// See `serializeJson`.\n function serializeInt(string calldata objectKey, string calldata valueKey, int256 value)\n external\n returns (string memory json);\n\n /// See `serializeJson`.\n function serializeInt(string calldata objectKey, string calldata valueKey, int256[] calldata values)\n external\n returns (string memory json);\n\n /// Serializes a key and value to a JSON object stored in-memory that can be later written to a file.\n /// Returns the stringified version of the specific JSON file up to that moment.\n function serializeJson(string calldata objectKey, string calldata value) external returns (string memory json);\n\n /// See `serializeJson`.\n function serializeJsonType(string calldata typeDescription, bytes calldata value)\n external\n pure\n returns (string memory json);\n\n /// See `serializeJson`.\n function serializeJsonType(\n string calldata objectKey,\n string calldata valueKey,\n string calldata typeDescription,\n bytes calldata value\n ) external returns (string memory json);\n\n /// See `serializeJson`.\n function serializeString(string calldata objectKey, string calldata valueKey, string calldata value)\n external\n returns (string memory json);\n\n /// See `serializeJson`.\n function serializeString(string calldata objectKey, string calldata valueKey, string[] calldata values)\n external\n returns (string memory json);\n\n /// See `serializeJson`.\n function serializeUintToHex(string calldata objectKey, string calldata valueKey, uint256 value)\n external\n returns (string memory json);\n\n /// See `serializeJson`.\n function serializeUint(string calldata objectKey, string calldata valueKey, uint256 value)\n external\n returns (string memory json);\n\n /// See `serializeJson`.\n function serializeUint(string calldata objectKey, string calldata valueKey, uint256[] calldata values)\n external\n returns (string memory json);\n\n /// Write a serialized JSON object to a file. If the file exists, it will be overwritten.\n function writeJson(string calldata json, string calldata path) external;\n\n /// Write a serialized JSON object to an **existing** JSON file, replacing a value with key = \n /// This is useful to replace a specific value of a JSON file, without having to parse the entire thing.\n function writeJson(string calldata json, string calldata path, string calldata valueKey) external;\n\n /// Checks if `key` exists in a JSON object\n /// `keyExists` is being deprecated in favor of `keyExistsJson`. It will be removed in future versions.\n function keyExists(string calldata json, string calldata key) external view returns (bool);\n\n // ======== Scripting ========\n\n /// Designate the next call as an EIP-7702 transaction\n function attachDelegation(SignedDelegation calldata signedDelegation) external;\n\n /// Takes a signed transaction and broadcasts it to the network.\n function broadcastRawTransaction(bytes calldata data) external;\n\n /// Has the next call (at this call depth only) create transactions that can later be signed and sent onchain.\n /// Broadcasting address is determined by checking the following in order:\n /// 1. If `--sender` argument was provided, that address is used.\n /// 2. If exactly one signer (e.g. private key, hw wallet, keystore) is set when `forge broadcast` is invoked, that signer is used.\n /// 3. Otherwise, default foundry sender (1804c8AB1F12E6bbf3894d4083f33e07309d1f38) is used.\n function broadcast() external;\n\n /// Has the next call (at this call depth only) create a transaction with the address provided\n /// as the sender that can later be signed and sent onchain.\n function broadcast(address signer) external;\n\n /// Has the next call (at this call depth only) create a transaction with the private key\n /// provided as the sender that can later be signed and sent onchain.\n function broadcast(uint256 privateKey) external;\n\n /// Returns addresses of available unlocked wallets in the script environment.\n function getWallets() external returns (address[] memory wallets);\n\n /// Sign an EIP-7702 authorization and designate the next call as an EIP-7702 transaction\n function signAndAttachDelegation(address implementation, uint256 privateKey)\n external\n returns (SignedDelegation memory signedDelegation);\n\n /// Sign an EIP-7702 authorization for delegation\n function signDelegation(address implementation, uint256 privateKey)\n external\n returns (SignedDelegation memory signedDelegation);\n\n /// Has all subsequent calls (at this call depth only) create transactions that can later be signed and sent onchain.\n /// Broadcasting address is determined by checking the following in order:\n /// 1. If `--sender` argument was provided, that address is used.\n /// 2. If exactly one signer (e.g. private key, hw wallet, keystore) is set when `forge broadcast` is invoked, that signer is used.\n /// 3. Otherwise, default foundry sender (1804c8AB1F12E6bbf3894d4083f33e07309d1f38) is used.\n function startBroadcast() external;\n\n /// Has all subsequent calls (at this call depth only) create transactions with the address\n /// provided that can later be signed and sent onchain.\n function startBroadcast(address signer) external;\n\n /// Has all subsequent calls (at this call depth only) create transactions with the private key\n /// provided that can later be signed and sent onchain.\n function startBroadcast(uint256 privateKey) external;\n\n /// Stops collecting onchain transactions.\n function stopBroadcast() external;\n\n // ======== String ========\n\n /// Returns true if `search` is found in `subject`, false otherwise.\n function contains(string calldata subject, string calldata search) external returns (bool result);\n\n /// Returns the index of the first occurrence of a `key` in an `input` string.\n /// Returns `NOT_FOUND` (i.e. `type(uint256).max`) if the `key` is not found.\n /// Returns 0 in case of an empty `key`.\n function indexOf(string calldata input, string calldata key) external pure returns (uint256);\n\n /// Parses the given `string` into an `address`.\n function parseAddress(string calldata stringifiedValue) external pure returns (address parsedValue);\n\n /// Parses the given `string` into a `bool`.\n function parseBool(string calldata stringifiedValue) external pure returns (bool parsedValue);\n\n /// Parses the given `string` into `bytes`.\n function parseBytes(string calldata stringifiedValue) external pure returns (bytes memory parsedValue);\n\n /// Parses the given `string` into a `bytes32`.\n function parseBytes32(string calldata stringifiedValue) external pure returns (bytes32 parsedValue);\n\n /// Parses the given `string` into a `int256`.\n function parseInt(string calldata stringifiedValue) external pure returns (int256 parsedValue);\n\n /// Parses the given `string` into a `uint256`.\n function parseUint(string calldata stringifiedValue) external pure returns (uint256 parsedValue);\n\n /// Replaces occurrences of `from` in the given `string` with `to`.\n function replace(string calldata input, string calldata from, string calldata to)\n external\n pure\n returns (string memory output);\n\n /// Splits the given `string` into an array of strings divided by the `delimiter`.\n function split(string calldata input, string calldata delimiter) external pure returns (string[] memory outputs);\n\n /// Converts the given `string` value to Lowercase.\n function toLowercase(string calldata input) external pure returns (string memory output);\n\n /// Converts the given value to a `string`.\n function toString(address value) external pure returns (string memory stringifiedValue);\n\n /// Converts the given value to a `string`.\n function toString(bytes calldata value) external pure returns (string memory stringifiedValue);\n\n /// Converts the given value to a `string`.\n function toString(bytes32 value) external pure returns (string memory stringifiedValue);\n\n /// Converts the given value to a `string`.\n function toString(bool value) external pure returns (string memory stringifiedValue);\n\n /// Converts the given value to a `string`.\n function toString(uint256 value) external pure returns (string memory stringifiedValue);\n\n /// Converts the given value to a `string`.\n function toString(int256 value) external pure returns (string memory stringifiedValue);\n\n /// Converts the given `string` value to Uppercase.\n function toUppercase(string calldata input) external pure returns (string memory output);\n\n /// Trims leading and trailing whitespace from the given `string` value.\n function trim(string calldata input) external pure returns (string memory output);\n\n // ======== Testing ========\n\n /// Compares two `uint256` values. Expects difference to be less than or equal to `maxDelta`.\n /// Formats values with decimals in failure message.\n function assertApproxEqAbsDecimal(uint256 left, uint256 right, uint256 maxDelta, uint256 decimals) external pure;\n\n /// Compares two `uint256` values. Expects difference to be less than or equal to `maxDelta`.\n /// Formats values with decimals in failure message. Includes error message into revert string on failure.\n function assertApproxEqAbsDecimal(\n uint256 left,\n uint256 right,\n uint256 maxDelta,\n uint256 decimals,\n string calldata error\n ) external pure;\n\n /// Compares two `int256` values. Expects difference to be less than or equal to `maxDelta`.\n /// Formats values with decimals in failure message.\n function assertApproxEqAbsDecimal(int256 left, int256 right, uint256 maxDelta, uint256 decimals) external pure;\n\n /// Compares two `int256` values. Expects difference to be less than or equal to `maxDelta`.\n /// Formats values with decimals in failure message. Includes error message into revert string on failure.\n function assertApproxEqAbsDecimal(\n int256 left,\n int256 right,\n uint256 maxDelta,\n uint256 decimals,\n string calldata error\n ) external pure;\n\n /// Compares two `uint256` values. Expects difference to be less than or equal to `maxDelta`.\n function assertApproxEqAbs(uint256 left, uint256 right, uint256 maxDelta) external pure;\n\n /// Compares two `uint256` values. Expects difference to be less than or equal to `maxDelta`.\n /// Includes error message into revert string on failure.\n function assertApproxEqAbs(uint256 left, uint256 right, uint256 maxDelta, string calldata error) external pure;\n\n /// Compares two `int256` values. Expects difference to be less than or equal to `maxDelta`.\n function assertApproxEqAbs(int256 left, int256 right, uint256 maxDelta) external pure;\n\n /// Compares two `int256` values. Expects difference to be less than or equal to `maxDelta`.\n /// Includes error message into revert string on failure.\n function assertApproxEqAbs(int256 left, int256 right, uint256 maxDelta, string calldata error) external pure;\n\n /// Compares two `uint256` values. Expects relative difference in percents to be less than or equal to `maxPercentDelta`.\n /// `maxPercentDelta` is an 18 decimal fixed point number, where 1e18 == 100%\n /// Formats values with decimals in failure message.\n function assertApproxEqRelDecimal(uint256 left, uint256 right, uint256 maxPercentDelta, uint256 decimals)\n external\n pure;\n\n /// Compares two `uint256` values. Expects relative difference in percents to be less than or equal to `maxPercentDelta`.\n /// `maxPercentDelta` is an 18 decimal fixed point number, where 1e18 == 100%\n /// Formats values with decimals in failure message. Includes error message into revert string on failure.\n function assertApproxEqRelDecimal(\n uint256 left,\n uint256 right,\n uint256 maxPercentDelta,\n uint256 decimals,\n string calldata error\n ) external pure;\n\n /// Compares two `int256` values. Expects relative difference in percents to be less than or equal to `maxPercentDelta`.\n /// `maxPercentDelta` is an 18 decimal fixed point number, where 1e18 == 100%\n /// Formats values with decimals in failure message.\n function assertApproxEqRelDecimal(int256 left, int256 right, uint256 maxPercentDelta, uint256 decimals)\n external\n pure;\n\n /// Compares two `int256` values. Expects relative difference in percents to be less than or equal to `maxPercentDelta`.\n /// `maxPercentDelta` is an 18 decimal fixed point number, where 1e18 == 100%\n /// Formats values with decimals in failure message. Includes error message into revert string on failure.\n function assertApproxEqRelDecimal(\n int256 left,\n int256 right,\n uint256 maxPercentDelta,\n uint256 decimals,\n string calldata error\n ) external pure;\n\n /// Compares two `uint256` values. Expects relative difference in percents to be less than or equal to `maxPercentDelta`.\n /// `maxPercentDelta` is an 18 decimal fixed point number, where 1e18 == 100%\n function assertApproxEqRel(uint256 left, uint256 right, uint256 maxPercentDelta) external pure;\n\n /// Compares two `uint256` values. Expects relative difference in percents to be less than or equal to `maxPercentDelta`.\n /// `maxPercentDelta` is an 18 decimal fixed point number, where 1e18 == 100%\n /// Includes error message into revert string on failure.\n function assertApproxEqRel(uint256 left, uint256 right, uint256 maxPercentDelta, string calldata error)\n external\n pure;\n\n /// Compares two `int256` values. Expects relative difference in percents to be less than or equal to `maxPercentDelta`.\n /// `maxPercentDelta` is an 18 decimal fixed point number, where 1e18 == 100%\n function assertApproxEqRel(int256 left, int256 right, uint256 maxPercentDelta) external pure;\n\n /// Compares two `int256` values. Expects relative difference in percents to be less than or equal to `maxPercentDelta`.\n /// `maxPercentDelta` is an 18 decimal fixed point number, where 1e18 == 100%\n /// Includes error message into revert string on failure.\n function assertApproxEqRel(int256 left, int256 right, uint256 maxPercentDelta, string calldata error)\n external\n pure;\n\n /// Asserts that two `uint256` values are equal, formatting them with decimals in failure message.\n function assertEqDecimal(uint256 left, uint256 right, uint256 decimals) external pure;\n\n /// Asserts that two `uint256` values are equal, formatting them with decimals in failure message.\n /// Includes error message into revert string on failure.\n function assertEqDecimal(uint256 left, uint256 right, uint256 decimals, string calldata error) external pure;\n\n /// Asserts that two `int256` values are equal, formatting them with decimals in failure message.\n function assertEqDecimal(int256 left, int256 right, uint256 decimals) external pure;\n\n /// Asserts that two `int256` values are equal, formatting them with decimals in failure message.\n /// Includes error message into revert string on failure.\n function assertEqDecimal(int256 left, int256 right, uint256 decimals, string calldata error) external pure;\n\n /// Asserts that two `bool` values are equal.\n function assertEq(bool left, bool right) external pure;\n\n /// Asserts that two `bool` values are equal and includes error message into revert string on failure.\n function assertEq(bool left, bool right, string calldata error) external pure;\n\n /// Asserts that two `string` values are equal.\n function assertEq(string calldata left, string calldata right) external pure;\n\n /// Asserts that two `string` values are equal and includes error message into revert string on failure.\n function assertEq(string calldata left, string calldata right, string calldata error) external pure;\n\n /// Asserts that two `bytes` values are equal.\n function assertEq(bytes calldata left, bytes calldata right) external pure;\n\n /// Asserts that two `bytes` values are equal and includes error message into revert string on failure.\n function assertEq(bytes calldata left, bytes calldata right, string calldata error) external pure;\n\n /// Asserts that two arrays of `bool` values are equal.\n function assertEq(bool[] calldata left, bool[] calldata right) external pure;\n\n /// Asserts that two arrays of `bool` values are equal and includes error message into revert string on failure.\n function assertEq(bool[] calldata left, bool[] calldata right, string calldata error) external pure;\n\n /// Asserts that two arrays of `uint256 values are equal.\n function assertEq(uint256[] calldata left, uint256[] calldata right) external pure;\n\n /// Asserts that two arrays of `uint256` values are equal and includes error message into revert string on failure.\n function assertEq(uint256[] calldata left, uint256[] calldata right, string calldata error) external pure;\n\n /// Asserts that two arrays of `int256` values are equal.\n function assertEq(int256[] calldata left, int256[] calldata right) external pure;\n\n /// Asserts that two arrays of `int256` values are equal and includes error message into revert string on failure.\n function assertEq(int256[] calldata left, int256[] calldata right, string calldata error) external pure;\n\n /// Asserts that two `uint256` values are equal.\n function assertEq(uint256 left, uint256 right) external pure;\n\n /// Asserts that two arrays of `address` values are equal.\n function assertEq(address[] calldata left, address[] calldata right) external pure;\n\n /// Asserts that two arrays of `address` values are equal and includes error message into revert string on failure.\n function assertEq(address[] calldata left, address[] calldata right, string calldata error) external pure;\n\n /// Asserts that two arrays of `bytes32` values are equal.\n function assertEq(bytes32[] calldata left, bytes32[] calldata right) external pure;\n\n /// Asserts that two arrays of `bytes32` values are equal and includes error message into revert string on failure.\n function assertEq(bytes32[] calldata left, bytes32[] calldata right, string calldata error) external pure;\n\n /// Asserts that two arrays of `string` values are equal.\n function assertEq(string[] calldata left, string[] calldata right) external pure;\n\n /// Asserts that two arrays of `string` values are equal and includes error message into revert string on failure.\n function assertEq(string[] calldata left, string[] calldata right, string calldata error) external pure;\n\n /// Asserts that two arrays of `bytes` values are equal.\n function assertEq(bytes[] calldata left, bytes[] calldata right) external pure;\n\n /// Asserts that two arrays of `bytes` values are equal and includes error message into revert string on failure.\n function assertEq(bytes[] calldata left, bytes[] calldata right, string calldata error) external pure;\n\n /// Asserts that two `uint256` values are equal and includes error message into revert string on failure.\n function assertEq(uint256 left, uint256 right, string calldata error) external pure;\n\n /// Asserts that two `int256` values are equal.\n function assertEq(int256 left, int256 right) external pure;\n\n /// Asserts that two `int256` values are equal and includes error message into revert string on failure.\n function assertEq(int256 left, int256 right, string calldata error) external pure;\n\n /// Asserts that two `address` values are equal.\n function assertEq(address left, address right) external pure;\n\n /// Asserts that two `address` values are equal and includes error message into revert string on failure.\n function assertEq(address left, address right, string calldata error) external pure;\n\n /// Asserts that two `bytes32` values are equal.\n function assertEq(bytes32 left, bytes32 right) external pure;\n\n /// Asserts that two `bytes32` values are equal and includes error message into revert string on failure.\n function assertEq(bytes32 left, bytes32 right, string calldata error) external pure;\n\n /// Asserts that the given condition is false.\n function assertFalse(bool condition) external pure;\n\n /// Asserts that the given condition is false and includes error message into revert string on failure.\n function assertFalse(bool condition, string calldata error) external pure;\n\n /// Compares two `uint256` values. Expects first value to be greater than or equal to second.\n /// Formats values with decimals in failure message.\n function assertGeDecimal(uint256 left, uint256 right, uint256 decimals) external pure;\n\n /// Compares two `uint256` values. Expects first value to be greater than or equal to second.\n /// Formats values with decimals in failure message. Includes error message into revert string on failure.\n function assertGeDecimal(uint256 left, uint256 right, uint256 decimals, string calldata error) external pure;\n\n /// Compares two `int256` values. Expects first value to be greater than or equal to second.\n /// Formats values with decimals in failure message.\n function assertGeDecimal(int256 left, int256 right, uint256 decimals) external pure;\n\n /// Compares two `int256` values. Expects first value to be greater than or equal to second.\n /// Formats values with decimals in failure message. Includes error message into revert string on failure.\n function assertGeDecimal(int256 left, int256 right, uint256 decimals, string calldata error) external pure;\n\n /// Compares two `uint256` values. Expects first value to be greater than or equal to second.\n function assertGe(uint256 left, uint256 right) external pure;\n\n /// Compares two `uint256` values. Expects first value to be greater than or equal to second.\n /// Includes error message into revert string on failure.\n function assertGe(uint256 left, uint256 right, string calldata error) external pure;\n\n /// Compares two `int256` values. Expects first value to be greater than or equal to second.\n function assertGe(int256 left, int256 right) external pure;\n\n /// Compares two `int256` values. Expects first value to be greater than or equal to second.\n /// Includes error message into revert string on failure.\n function assertGe(int256 left, int256 right, string calldata error) external pure;\n\n /// Compares two `uint256` values. Expects first value to be greater than second.\n /// Formats values with decimals in failure message.\n function assertGtDecimal(uint256 left, uint256 right, uint256 decimals) external pure;\n\n /// Compares two `uint256` values. Expects first value to be greater than second.\n /// Formats values with decimals in failure message. Includes error message into revert string on failure.\n function assertGtDecimal(uint256 left, uint256 right, uint256 decimals, string calldata error) external pure;\n\n /// Compares two `int256` values. Expects first value to be greater than second.\n /// Formats values with decimals in failure message.\n function assertGtDecimal(int256 left, int256 right, uint256 decimals) external pure;\n\n /// Compares two `int256` values. Expects first value to be greater than second.\n /// Formats values with decimals in failure message. Includes error message into revert string on failure.\n function assertGtDecimal(int256 left, int256 right, uint256 decimals, string calldata error) external pure;\n\n /// Compares two `uint256` values. Expects first value to be greater than second.\n function assertGt(uint256 left, uint256 right) external pure;\n\n /// Compares two `uint256` values. Expects first value to be greater than second.\n /// Includes error message into revert string on failure.\n function assertGt(uint256 left, uint256 right, string calldata error) external pure;\n\n /// Compares two `int256` values. Expects first value to be greater than second.\n function assertGt(int256 left, int256 right) external pure;\n\n /// Compares two `int256` values. Expects first value to be greater than second.\n /// Includes error message into revert string on failure.\n function assertGt(int256 left, int256 right, string calldata error) external pure;\n\n /// Compares two `uint256` values. Expects first value to be less than or equal to second.\n /// Formats values with decimals in failure message.\n function assertLeDecimal(uint256 left, uint256 right, uint256 decimals) external pure;\n\n /// Compares two `uint256` values. Expects first value to be less than or equal to second.\n /// Formats values with decimals in failure message. Includes error message into revert string on failure.\n function assertLeDecimal(uint256 left, uint256 right, uint256 decimals, string calldata error) external pure;\n\n /// Compares two `int256` values. Expects first value to be less than or equal to second.\n /// Formats values with decimals in failure message.\n function assertLeDecimal(int256 left, int256 right, uint256 decimals) external pure;\n\n /// Compares two `int256` values. Expects first value to be less than or equal to second.\n /// Formats values with decimals in failure message. Includes error message into revert string on failure.\n function assertLeDecimal(int256 left, int256 right, uint256 decimals, string calldata error) external pure;\n\n /// Compares two `uint256` values. Expects first value to be less than or equal to second.\n function assertLe(uint256 left, uint256 right) external pure;\n\n /// Compares two `uint256` values. Expects first value to be less than or equal to second.\n /// Includes error message into revert string on failure.\n function assertLe(uint256 left, uint256 right, string calldata error) external pure;\n\n /// Compares two `int256` values. Expects first value to be less than or equal to second.\n function assertLe(int256 left, int256 right) external pure;\n\n /// Compares two `int256` values. Expects first value to be less than or equal to second.\n /// Includes error message into revert string on failure.\n function assertLe(int256 left, int256 right, string calldata error) external pure;\n\n /// Compares two `uint256` values. Expects first value to be less than second.\n /// Formats values with decimals in failure message.\n function assertLtDecimal(uint256 left, uint256 right, uint256 decimals) external pure;\n\n /// Compares two `uint256` values. Expects first value to be less than second.\n /// Formats values with decimals in failure message. Includes error message into revert string on failure.\n function assertLtDecimal(uint256 left, uint256 right, uint256 decimals, string calldata error) external pure;\n\n /// Compares two `int256` values. Expects first value to be less than second.\n /// Formats values with decimals in failure message.\n function assertLtDecimal(int256 left, int256 right, uint256 decimals) external pure;\n\n /// Compares two `int256` values. Expects first value to be less than second.\n /// Formats values with decimals in failure message. Includes error message into revert string on failure.\n function assertLtDecimal(int256 left, int256 right, uint256 decimals, string calldata error) external pure;\n\n /// Compares two `uint256` values. Expects first value to be less than second.\n function assertLt(uint256 left, uint256 right) external pure;\n\n /// Compares two `uint256` values. Expects first value to be less than second.\n /// Includes error message into revert string on failure.\n function assertLt(uint256 left, uint256 right, string calldata error) external pure;\n\n /// Compares two `int256` values. Expects first value to be less than second.\n function assertLt(int256 left, int256 right) external pure;\n\n /// Compares two `int256` values. Expects first value to be less than second.\n /// Includes error message into revert string on failure.\n function assertLt(int256 left, int256 right, string calldata error) external pure;\n\n /// Asserts that two `uint256` values are not equal, formatting them with decimals in failure message.\n function assertNotEqDecimal(uint256 left, uint256 right, uint256 decimals) external pure;\n\n /// Asserts that two `uint256` values are not equal, formatting them with decimals in failure message.\n /// Includes error message into revert string on failure.\n function assertNotEqDecimal(uint256 left, uint256 right, uint256 decimals, string calldata error) external pure;\n\n /// Asserts that two `int256` values are not equal, formatting them with decimals in failure message.\n function assertNotEqDecimal(int256 left, int256 right, uint256 decimals) external pure;\n\n /// Asserts that two `int256` values are not equal, formatting them with decimals in failure message.\n /// Includes error message into revert string on failure.\n function assertNotEqDecimal(int256 left, int256 right, uint256 decimals, string calldata error) external pure;\n\n /// Asserts that two `bool` values are not equal.\n function assertNotEq(bool left, bool right) external pure;\n\n /// Asserts that two `bool` values are not equal and includes error message into revert string on failure.\n function assertNotEq(bool left, bool right, string calldata error) external pure;\n\n /// Asserts that two `string` values are not equal.\n function assertNotEq(string calldata left, string calldata right) external pure;\n\n /// Asserts that two `string` values are not equal and includes error message into revert string on failure.\n function assertNotEq(string calldata left, string calldata right, string calldata error) external pure;\n\n /// Asserts that two `bytes` values are not equal.\n function assertNotEq(bytes calldata left, bytes calldata right) external pure;\n\n /// Asserts that two `bytes` values are not equal and includes error message into revert string on failure.\n function assertNotEq(bytes calldata left, bytes calldata right, string calldata error) external pure;\n\n /// Asserts that two arrays of `bool` values are not equal.\n function assertNotEq(bool[] calldata left, bool[] calldata right) external pure;\n\n /// Asserts that two arrays of `bool` values are not equal and includes error message into revert string on failure.\n function assertNotEq(bool[] calldata left, bool[] calldata right, string calldata error) external pure;\n\n /// Asserts that two arrays of `uint256` values are not equal.\n function assertNotEq(uint256[] calldata left, uint256[] calldata right) external pure;\n\n /// Asserts that two arrays of `uint256` values are not equal and includes error message into revert string on failure.\n function assertNotEq(uint256[] calldata left, uint256[] calldata right, string calldata error) external pure;\n\n /// Asserts that two arrays of `int256` values are not equal.\n function assertNotEq(int256[] calldata left, int256[] calldata right) external pure;\n\n /// Asserts that two arrays of `int256` values are not equal and includes error message into revert string on failure.\n function assertNotEq(int256[] calldata left, int256[] calldata right, string calldata error) external pure;\n\n /// Asserts that two `uint256` values are not equal.\n function assertNotEq(uint256 left, uint256 right) external pure;\n\n /// Asserts that two arrays of `address` values are not equal.\n function assertNotEq(address[] calldata left, address[] calldata right) external pure;\n\n /// Asserts that two arrays of `address` values are not equal and includes error message into revert string on failure.\n function assertNotEq(address[] calldata left, address[] calldata right, string calldata error) external pure;\n\n /// Asserts that two arrays of `bytes32` values are not equal.\n function assertNotEq(bytes32[] calldata left, bytes32[] calldata right) external pure;\n\n /// Asserts that two arrays of `bytes32` values are not equal and includes error message into revert string on failure.\n function assertNotEq(bytes32[] calldata left, bytes32[] calldata right, string calldata error) external pure;\n\n /// Asserts that two arrays of `string` values are not equal.\n function assertNotEq(string[] calldata left, string[] calldata right) external pure;\n\n /// Asserts that two arrays of `string` values are not equal and includes error message into revert string on failure.\n function assertNotEq(string[] calldata left, string[] calldata right, string calldata error) external pure;\n\n /// Asserts that two arrays of `bytes` values are not equal.\n function assertNotEq(bytes[] calldata left, bytes[] calldata right) external pure;\n\n /// Asserts that two arrays of `bytes` values are not equal and includes error message into revert string on failure.\n function assertNotEq(bytes[] calldata left, bytes[] calldata right, string calldata error) external pure;\n\n /// Asserts that two `uint256` values are not equal and includes error message into revert string on failure.\n function assertNotEq(uint256 left, uint256 right, string calldata error) external pure;\n\n /// Asserts that two `int256` values are not equal.\n function assertNotEq(int256 left, int256 right) external pure;\n\n /// Asserts that two `int256` values are not equal and includes error message into revert string on failure.\n function assertNotEq(int256 left, int256 right, string calldata error) external pure;\n\n /// Asserts that two `address` values are not equal.\n function assertNotEq(address left, address right) external pure;\n\n /// Asserts that two `address` values are not equal and includes error message into revert string on failure.\n function assertNotEq(address left, address right, string calldata error) external pure;\n\n /// Asserts that two `bytes32` values are not equal.\n function assertNotEq(bytes32 left, bytes32 right) external pure;\n\n /// Asserts that two `bytes32` values are not equal and includes error message into revert string on failure.\n function assertNotEq(bytes32 left, bytes32 right, string calldata error) external pure;\n\n /// Asserts that the given condition is true.\n function assertTrue(bool condition) external pure;\n\n /// Asserts that the given condition is true and includes error message into revert string on failure.\n function assertTrue(bool condition, string calldata error) external pure;\n\n /// If the condition is false, discard this run's fuzz inputs and generate new ones.\n function assume(bool condition) external pure;\n\n /// Discard this run's fuzz inputs and generate new ones if next call reverted.\n function assumeNoRevert() external pure;\n\n /// Discard this run's fuzz inputs and generate new ones if next call reverts with the potential revert parameters.\n function assumeNoRevert(PotentialRevert calldata potentialRevert) external pure;\n\n /// Discard this run's fuzz inputs and generate new ones if next call reverts with the any of the potential revert parameters.\n function assumeNoRevert(PotentialRevert[] calldata potentialReverts) external pure;\n\n /// Writes a breakpoint to jump to in the debugger.\n function breakpoint(string calldata char) external pure;\n\n /// Writes a conditional breakpoint to jump to in the debugger.\n function breakpoint(string calldata char, bool value) external pure;\n\n /// Returns true if the current Foundry version is greater than or equal to the given version.\n /// The given version string must be in the format `major.minor.patch`.\n /// This is equivalent to `foundryVersionCmp(version) >= 0`.\n function foundryVersionAtLeast(string calldata version) external view returns (bool);\n\n /// Compares the current Foundry version with the given version string.\n /// The given version string must be in the format `major.minor.patch`.\n /// Returns:\n /// -1 if current Foundry version is less than the given version\n /// 0 if current Foundry version equals the given version\n /// 1 if current Foundry version is greater than the given version\n /// This result can then be used with a comparison operator against `0`.\n /// For example, to check if the current Foundry version is greater than or equal to `1.0.0`:\n /// `if (foundryVersionCmp(\"1.0.0\") >= 0) { ... }`\n function foundryVersionCmp(string calldata version) external view returns (int256);\n\n /// Returns the Foundry version.\n /// Format: -+..\n /// Sample output: 0.3.0-nightly+3cb96bde9b.1737036656.debug\n /// Note: Build timestamps may vary slightly across platforms due to separate CI jobs.\n /// For reliable version comparisons, use UNIX format (e.g., >= 1700000000)\n /// to compare timestamps while ignoring minor time differences.\n function getFoundryVersion() external view returns (string memory version);\n\n /// Returns the RPC url for the given alias.\n function rpcUrl(string calldata rpcAlias) external view returns (string memory json);\n\n /// Returns all rpc urls and their aliases as structs.\n function rpcUrlStructs() external view returns (Rpc[] memory urls);\n\n /// Returns all rpc urls and their aliases `[alias, url][]`.\n function rpcUrls() external view returns (string[2][] memory urls);\n\n /// Suspends execution of the main thread for `duration` milliseconds.\n function sleep(uint256 duration) external;\n\n // ======== Toml ========\n\n /// Checks if `key` exists in a TOML table.\n function keyExistsToml(string calldata toml, string calldata key) external view returns (bool);\n\n /// Parses a string of TOML data at `key` and coerces it to `address`.\n function parseTomlAddress(string calldata toml, string calldata key) external pure returns (address);\n\n /// Parses a string of TOML data at `key` and coerces it to `address[]`.\n function parseTomlAddressArray(string calldata toml, string calldata key)\n external\n pure\n returns (address[] memory);\n\n /// Parses a string of TOML data at `key` and coerces it to `bool`.\n function parseTomlBool(string calldata toml, string calldata key) external pure returns (bool);\n\n /// Parses a string of TOML data at `key` and coerces it to `bool[]`.\n function parseTomlBoolArray(string calldata toml, string calldata key) external pure returns (bool[] memory);\n\n /// Parses a string of TOML data at `key` and coerces it to `bytes`.\n function parseTomlBytes(string calldata toml, string calldata key) external pure returns (bytes memory);\n\n /// Parses a string of TOML data at `key` and coerces it to `bytes32`.\n function parseTomlBytes32(string calldata toml, string calldata key) external pure returns (bytes32);\n\n /// Parses a string of TOML data at `key` and coerces it to `bytes32[]`.\n function parseTomlBytes32Array(string calldata toml, string calldata key)\n external\n pure\n returns (bytes32[] memory);\n\n /// Parses a string of TOML data at `key` and coerces it to `bytes[]`.\n function parseTomlBytesArray(string calldata toml, string calldata key) external pure returns (bytes[] memory);\n\n /// Parses a string of TOML data at `key` and coerces it to `int256`.\n function parseTomlInt(string calldata toml, string calldata key) external pure returns (int256);\n\n /// Parses a string of TOML data at `key` and coerces it to `int256[]`.\n function parseTomlIntArray(string calldata toml, string calldata key) external pure returns (int256[] memory);\n\n /// Returns an array of all the keys in a TOML table.\n function parseTomlKeys(string calldata toml, string calldata key) external pure returns (string[] memory keys);\n\n /// Parses a string of TOML data at `key` and coerces it to `string`.\n function parseTomlString(string calldata toml, string calldata key) external pure returns (string memory);\n\n /// Parses a string of TOML data at `key` and coerces it to `string[]`.\n function parseTomlStringArray(string calldata toml, string calldata key) external pure returns (string[] memory);\n\n /// Parses a string of TOML data at `key` and coerces it to type array corresponding to `typeDescription`.\n function parseTomlTypeArray(string calldata toml, string calldata key, string calldata typeDescription)\n external\n pure\n returns (bytes memory);\n\n /// Parses a string of TOML data and coerces it to type corresponding to `typeDescription`.\n function parseTomlType(string calldata toml, string calldata typeDescription)\n external\n pure\n returns (bytes memory);\n\n /// Parses a string of TOML data at `key` and coerces it to type corresponding to `typeDescription`.\n function parseTomlType(string calldata toml, string calldata key, string calldata typeDescription)\n external\n pure\n returns (bytes memory);\n\n /// Parses a string of TOML data at `key` and coerces it to `uint256`.\n function parseTomlUint(string calldata toml, string calldata key) external pure returns (uint256);\n\n /// Parses a string of TOML data at `key` and coerces it to `uint256[]`.\n function parseTomlUintArray(string calldata toml, string calldata key) external pure returns (uint256[] memory);\n\n /// ABI-encodes a TOML table.\n function parseToml(string calldata toml) external pure returns (bytes memory abiEncodedData);\n\n /// ABI-encodes a TOML table at `key`.\n function parseToml(string calldata toml, string calldata key) external pure returns (bytes memory abiEncodedData);\n\n /// Takes serialized JSON, converts to TOML and write a serialized TOML to a file.\n function writeToml(string calldata json, string calldata path) external;\n\n /// Takes serialized JSON, converts to TOML and write a serialized TOML table to an **existing** TOML file, replacing a value with key = \n /// This is useful to replace a specific value of a TOML file, without having to parse the entire thing.\n function writeToml(string calldata json, string calldata path, string calldata valueKey) external;\n\n // ======== Utilities ========\n\n /// Compute the address of a contract created with CREATE2 using the given CREATE2 deployer.\n function computeCreate2Address(bytes32 salt, bytes32 initCodeHash, address deployer)\n external\n pure\n returns (address);\n\n /// Compute the address of a contract created with CREATE2 using the default CREATE2 deployer.\n function computeCreate2Address(bytes32 salt, bytes32 initCodeHash) external pure returns (address);\n\n /// Compute the address a contract will be deployed at for a given deployer address and nonce.\n function computeCreateAddress(address deployer, uint256 nonce) external pure returns (address);\n\n /// Utility cheatcode to copy storage of `from` contract to another `to` contract.\n function copyStorage(address from, address to) external;\n\n /// Returns ENS namehash for provided string.\n function ensNamehash(string calldata name) external pure returns (bytes32);\n\n /// Gets the label for the specified address.\n function getLabel(address account) external view returns (string memory currentLabel);\n\n /// Labels an address in call traces.\n function label(address account, string calldata newLabel) external;\n\n /// Pauses collection of call traces. Useful in cases when you want to skip tracing of\n /// complex calls which are not useful for debugging.\n function pauseTracing() external view;\n\n /// Returns a random `address`.\n function randomAddress() external returns (address);\n\n /// Returns a random `bool`.\n function randomBool() external view returns (bool);\n\n /// Returns a random byte array value of the given length.\n function randomBytes(uint256 len) external view returns (bytes memory);\n\n /// Returns a random fixed-size byte array of length 4.\n function randomBytes4() external view returns (bytes4);\n\n /// Returns a random fixed-size byte array of length 8.\n function randomBytes8() external view returns (bytes8);\n\n /// Returns a random `int256` value.\n function randomInt() external view returns (int256);\n\n /// Returns a random `int256` value of given bits.\n function randomInt(uint256 bits) external view returns (int256);\n\n /// Returns a random uint256 value.\n function randomUint() external returns (uint256);\n\n /// Returns random uint256 value between the provided range (=min..=max).\n function randomUint(uint256 min, uint256 max) external returns (uint256);\n\n /// Returns a random `uint256` value of given bits.\n function randomUint(uint256 bits) external view returns (uint256);\n\n /// Unpauses collection of call traces.\n function resumeTracing() external view;\n\n /// Utility cheatcode to set arbitrary storage for given target address.\n function setArbitraryStorage(address target) external;\n\n /// Encodes a `bytes` value to a base64url string.\n function toBase64URL(bytes calldata data) external pure returns (string memory);\n\n /// Encodes a `string` value to a base64url string.\n function toBase64URL(string calldata data) external pure returns (string memory);\n\n /// Encodes a `bytes` value to a base64 string.\n function toBase64(bytes calldata data) external pure returns (string memory);\n\n /// Encodes a `string` value to a base64 string.\n function toBase64(string calldata data) external pure returns (string memory);\n}\n\n/// The `Vm` interface does allow manipulation of the EVM state. These are all intended to be used\n/// in tests, but it is not recommended to use these cheats in scripts.\ninterface Vm is VmSafe {\n // ======== EVM ========\n\n /// Utility cheatcode to set an EIP-2930 access list for all subsequent transactions.\n function accessList(AccessListItem[] calldata access) external;\n\n /// Returns the identifier of the currently active fork. Reverts if no fork is currently active.\n function activeFork() external view returns (uint256 forkId);\n\n /// In forking mode, explicitly grant the given address cheatcode access.\n function allowCheatcodes(address account) external;\n\n /// Sets `block.blobbasefee`\n function blobBaseFee(uint256 newBlobBaseFee) external;\n\n /// Sets the blobhashes in the transaction.\n /// Not available on EVM versions before Cancun.\n /// If used on unsupported EVM versions it will revert.\n function blobhashes(bytes32[] calldata hashes) external;\n\n /// Sets `block.chainid`.\n function chainId(uint256 newChainId) external;\n\n /// Clears all mocked calls.\n function clearMockedCalls() external;\n\n /// Clones a source account code, state, balance and nonce to a target account and updates in-memory EVM state.\n function cloneAccount(address source, address target) external;\n\n /// Sets `block.coinbase`.\n function coinbase(address newCoinbase) external;\n\n /// Marks the slots of an account and the account address as cold.\n function cool(address target) external;\n\n /// Utility cheatcode to mark specific storage slot as cold, simulating no prior read.\n function coolSlot(address target, bytes32 slot) external;\n\n /// Creates a new fork with the given endpoint and the _latest_ block and returns the identifier of the fork.\n function createFork(string calldata urlOrAlias) external returns (uint256 forkId);\n\n /// Creates a new fork with the given endpoint and block and returns the identifier of the fork.\n function createFork(string calldata urlOrAlias, uint256 blockNumber) external returns (uint256 forkId);\n\n /// Creates a new fork with the given endpoint and at the block the given transaction was mined in,\n /// replays all transaction mined in the block before the transaction, and returns the identifier of the fork.\n function createFork(string calldata urlOrAlias, bytes32 txHash) external returns (uint256 forkId);\n\n /// Creates and also selects a new fork with the given endpoint and the latest block and returns the identifier of the fork.\n function createSelectFork(string calldata urlOrAlias) external returns (uint256 forkId);\n\n /// Creates and also selects a new fork with the given endpoint and block and returns the identifier of the fork.\n function createSelectFork(string calldata urlOrAlias, uint256 blockNumber) external returns (uint256 forkId);\n\n /// Creates and also selects new fork with the given endpoint and at the block the given transaction was mined in,\n /// replays all transaction mined in the block before the transaction, returns the identifier of the fork.\n function createSelectFork(string calldata urlOrAlias, bytes32 txHash) external returns (uint256 forkId);\n\n /// Sets an address' balance.\n function deal(address account, uint256 newBalance) external;\n\n /// Removes the snapshot with the given ID created by `snapshot`.\n /// Takes the snapshot ID to delete.\n /// Returns `true` if the snapshot was successfully deleted.\n /// Returns `false` if the snapshot does not exist.\n function deleteStateSnapshot(uint256 snapshotId) external returns (bool success);\n\n /// Removes _all_ snapshots previously created by `snapshot`.\n function deleteStateSnapshots() external;\n\n /// Sets `block.difficulty`.\n /// Not available on EVM versions from Paris onwards. Use `prevrandao` instead.\n /// Reverts if used on unsupported EVM versions.\n function difficulty(uint256 newDifficulty) external;\n\n /// Dump a genesis JSON file's `allocs` to disk.\n function dumpState(string calldata pathToStateJson) external;\n\n /// Sets an address' code.\n function etch(address target, bytes calldata newRuntimeBytecode) external;\n\n /// Sets `block.basefee`.\n function fee(uint256 newBasefee) external;\n\n /// Gets the blockhashes from the current transaction.\n /// Not available on EVM versions before Cancun.\n /// If used on unsupported EVM versions it will revert.\n function getBlobhashes() external view returns (bytes32[] memory hashes);\n\n /// Returns true if the account is marked as persistent.\n function isPersistent(address account) external view returns (bool persistent);\n\n /// Load a genesis JSON file's `allocs` into the in-memory EVM state.\n function loadAllocs(string calldata pathToAllocsJson) external;\n\n /// Marks that the account(s) should use persistent storage across fork swaps in a multifork setup\n /// Meaning, changes made to the state of this account will be kept when switching forks.\n function makePersistent(address account) external;\n\n /// See `makePersistent(address)`.\n function makePersistent(address account0, address account1) external;\n\n /// See `makePersistent(address)`.\n function makePersistent(address account0, address account1, address account2) external;\n\n /// See `makePersistent(address)`.\n function makePersistent(address[] calldata accounts) external;\n\n /// Reverts a call to an address with specified revert data.\n function mockCallRevert(address callee, bytes calldata data, bytes calldata revertData) external;\n\n /// Reverts a call to an address with a specific `msg.value`, with specified revert data.\n function mockCallRevert(address callee, uint256 msgValue, bytes calldata data, bytes calldata revertData)\n external;\n\n /// Reverts a call to an address with specified revert data.\n /// Overload to pass the function selector directly `token.approve.selector` instead of `abi.encodeWithSelector(token.approve.selector)`.\n function mockCallRevert(address callee, bytes4 data, bytes calldata revertData) external;\n\n /// Reverts a call to an address with a specific `msg.value`, with specified revert data.\n /// Overload to pass the function selector directly `token.approve.selector` instead of `abi.encodeWithSelector(token.approve.selector)`.\n function mockCallRevert(address callee, uint256 msgValue, bytes4 data, bytes calldata revertData) external;\n\n /// Mocks a call to an address, returning specified data.\n /// Calldata can either be strict or a partial match, e.g. if you only\n /// pass a Solidity selector to the expected calldata, then the entire Solidity\n /// function will be mocked.\n function mockCall(address callee, bytes calldata data, bytes calldata returnData) external;\n\n /// Mocks a call to an address with a specific `msg.value`, returning specified data.\n /// Calldata match takes precedence over `msg.value` in case of ambiguity.\n function mockCall(address callee, uint256 msgValue, bytes calldata data, bytes calldata returnData) external;\n\n /// Mocks a call to an address, returning specified data.\n /// Calldata can either be strict or a partial match, e.g. if you only\n /// pass a Solidity selector to the expected calldata, then the entire Solidity\n /// function will be mocked.\n /// Overload to pass the function selector directly `token.approve.selector` instead of `abi.encodeWithSelector(token.approve.selector)`.\n function mockCall(address callee, bytes4 data, bytes calldata returnData) external;\n\n /// Mocks a call to an address with a specific `msg.value`, returning specified data.\n /// Calldata match takes precedence over `msg.value` in case of ambiguity.\n /// Overload to pass the function selector directly `token.approve.selector` instead of `abi.encodeWithSelector(token.approve.selector)`.\n function mockCall(address callee, uint256 msgValue, bytes4 data, bytes calldata returnData) external;\n\n /// Mocks multiple calls to an address, returning specified data for each call.\n function mockCalls(address callee, bytes calldata data, bytes[] calldata returnData) external;\n\n /// Mocks multiple calls to an address with a specific `msg.value`, returning specified data for each call.\n function mockCalls(address callee, uint256 msgValue, bytes calldata data, bytes[] calldata returnData) external;\n\n /// Whenever a call is made to `callee` with calldata `data`, this cheatcode instead calls\n /// `target` with the same calldata. This functionality is similar to a delegate call made to\n /// `target` contract from `callee`.\n /// Can be used to substitute a call to a function with another implementation that captures\n /// the primary logic of the original function but is easier to reason about.\n /// If calldata is not a strict match then partial match by selector is attempted.\n function mockFunction(address callee, address target, bytes calldata data) external;\n\n /// Utility cheatcode to remove any EIP-2930 access list set by `accessList` cheatcode.\n function noAccessList() external;\n\n /// Sets the *next* call's `msg.sender` to be the input address.\n function prank(address msgSender) external;\n\n /// Sets the *next* call's `msg.sender` to be the input address, and the `tx.origin` to be the second input.\n function prank(address msgSender, address txOrigin) external;\n\n /// Sets the *next* delegate call's `msg.sender` to be the input address.\n function prank(address msgSender, bool delegateCall) external;\n\n /// Sets the *next* delegate call's `msg.sender` to be the input address, and the `tx.origin` to be the second input.\n function prank(address msgSender, address txOrigin, bool delegateCall) external;\n\n /// Sets `block.prevrandao`.\n /// Not available on EVM versions before Paris. Use `difficulty` instead.\n /// If used on unsupported EVM versions it will revert.\n function prevrandao(bytes32 newPrevrandao) external;\n\n /// Sets `block.prevrandao`.\n /// Not available on EVM versions before Paris. Use `difficulty` instead.\n /// If used on unsupported EVM versions it will revert.\n function prevrandao(uint256 newPrevrandao) external;\n\n /// Reads the current `msg.sender` and `tx.origin` from state and reports if there is any active caller modification.\n function readCallers() external returns (CallerMode callerMode, address msgSender, address txOrigin);\n\n /// Resets the nonce of an account to 0 for EOAs and 1 for contract accounts.\n function resetNonce(address account) external;\n\n /// Revert the state of the EVM to a previous snapshot\n /// Takes the snapshot ID to revert to.\n /// Returns `true` if the snapshot was successfully reverted.\n /// Returns `false` if the snapshot does not exist.\n /// **Note:** This does not automatically delete the snapshot. To delete the snapshot use `deleteStateSnapshot`.\n function revertToState(uint256 snapshotId) external returns (bool success);\n\n /// Revert the state of the EVM to a previous snapshot and automatically deletes the snapshots\n /// Takes the snapshot ID to revert to.\n /// Returns `true` if the snapshot was successfully reverted and deleted.\n /// Returns `false` if the snapshot does not exist.\n function revertToStateAndDelete(uint256 snapshotId) external returns (bool success);\n\n /// Revokes persistent status from the address, previously added via `makePersistent`.\n function revokePersistent(address account) external;\n\n /// See `revokePersistent(address)`.\n function revokePersistent(address[] calldata accounts) external;\n\n /// Sets `block.height`.\n function roll(uint256 newHeight) external;\n\n /// Updates the currently active fork to given block number\n /// This is similar to `roll` but for the currently active fork.\n function rollFork(uint256 blockNumber) external;\n\n /// Updates the currently active fork to given transaction. This will `rollFork` with the number\n /// of the block the transaction was mined in and replays all transaction mined before it in the block.\n function rollFork(bytes32 txHash) external;\n\n /// Updates the given fork to given block number.\n function rollFork(uint256 forkId, uint256 blockNumber) external;\n\n /// Updates the given fork to block number of the given transaction and replays all transaction mined before it in the block.\n function rollFork(uint256 forkId, bytes32 txHash) external;\n\n /// Takes a fork identifier created by `createFork` and sets the corresponding forked state as active.\n function selectFork(uint256 forkId) external;\n\n /// Set blockhash for the current block.\n /// It only sets the blockhash for blocks where `block.number - 256 <= number < block.number`.\n function setBlockhash(uint256 blockNumber, bytes32 blockHash) external;\n\n /// Sets the nonce of an account. Must be higher than the current nonce of the account.\n function setNonce(address account, uint64 newNonce) external;\n\n /// Sets the nonce of an account to an arbitrary value.\n function setNonceUnsafe(address account, uint64 newNonce) external;\n\n /// Snapshot capture the gas usage of the last call by name from the callee perspective.\n function snapshotGasLastCall(string calldata name) external returns (uint256 gasUsed);\n\n /// Snapshot capture the gas usage of the last call by name in a group from the callee perspective.\n function snapshotGasLastCall(string calldata group, string calldata name) external returns (uint256 gasUsed);\n\n /// Snapshot the current state of the evm.\n /// Returns the ID of the snapshot that was created.\n /// To revert a snapshot use `revertToState`.\n function snapshotState() external returns (uint256 snapshotId);\n\n /// Snapshot capture an arbitrary numerical value by name.\n /// The group name is derived from the contract name.\n function snapshotValue(string calldata name, uint256 value) external;\n\n /// Snapshot capture an arbitrary numerical value by name in a group.\n function snapshotValue(string calldata group, string calldata name, uint256 value) external;\n\n /// Sets all subsequent calls' `msg.sender` to be the input address until `stopPrank` is called.\n function startPrank(address msgSender) external;\n\n /// Sets all subsequent calls' `msg.sender` to be the input address until `stopPrank` is called, and the `tx.origin` to be the second input.\n function startPrank(address msgSender, address txOrigin) external;\n\n /// Sets all subsequent delegate calls' `msg.sender` to be the input address until `stopPrank` is called.\n function startPrank(address msgSender, bool delegateCall) external;\n\n /// Sets all subsequent delegate calls' `msg.sender` to be the input address until `stopPrank` is called, and the `tx.origin` to be the second input.\n function startPrank(address msgSender, address txOrigin, bool delegateCall) external;\n\n /// Start a snapshot capture of the current gas usage by name.\n /// The group name is derived from the contract name.\n function startSnapshotGas(string calldata name) external;\n\n /// Start a snapshot capture of the current gas usage by name in a group.\n function startSnapshotGas(string calldata group, string calldata name) external;\n\n /// Resets subsequent calls' `msg.sender` to be `address(this)`.\n function stopPrank() external;\n\n /// Stop the snapshot capture of the current gas by latest snapshot name, capturing the gas used since the start.\n function stopSnapshotGas() external returns (uint256 gasUsed);\n\n /// Stop the snapshot capture of the current gas usage by name, capturing the gas used since the start.\n /// The group name is derived from the contract name.\n function stopSnapshotGas(string calldata name) external returns (uint256 gasUsed);\n\n /// Stop the snapshot capture of the current gas usage by name in a group, capturing the gas used since the start.\n function stopSnapshotGas(string calldata group, string calldata name) external returns (uint256 gasUsed);\n\n /// Stores a value to an address' storage slot.\n function store(address target, bytes32 slot, bytes32 value) external;\n\n /// Fetches the given transaction from the active fork and executes it on the current state.\n function transact(bytes32 txHash) external;\n\n /// Fetches the given transaction from the given fork and executes it on the current state.\n function transact(uint256 forkId, bytes32 txHash) external;\n\n /// Sets `tx.gasprice`.\n function txGasPrice(uint256 newGasPrice) external;\n\n /// Utility cheatcode to mark specific storage slot as warm, simulating a prior read.\n function warmSlot(address target, bytes32 slot) external;\n\n /// Sets `block.timestamp`.\n function warp(uint256 newTimestamp) external;\n\n /// `deleteSnapshot` is being deprecated in favor of `deleteStateSnapshot`. It will be removed in future versions.\n function deleteSnapshot(uint256 snapshotId) external returns (bool success);\n\n /// `deleteSnapshots` is being deprecated in favor of `deleteStateSnapshots`. It will be removed in future versions.\n function deleteSnapshots() external;\n\n /// `revertToAndDelete` is being deprecated in favor of `revertToStateAndDelete`. It will be removed in future versions.\n function revertToAndDelete(uint256 snapshotId) external returns (bool success);\n\n /// `revertTo` is being deprecated in favor of `revertToState`. It will be removed in future versions.\n function revertTo(uint256 snapshotId) external returns (bool success);\n\n /// `snapshot` is being deprecated in favor of `snapshotState`. It will be removed in future versions.\n function snapshot() external returns (uint256 snapshotId);\n\n // ======== Testing ========\n\n /// Expect a call to an address with the specified `msg.value` and calldata, and a *minimum* amount of gas.\n function expectCallMinGas(address callee, uint256 msgValue, uint64 minGas, bytes calldata data) external;\n\n /// Expect given number of calls to an address with the specified `msg.value` and calldata, and a *minimum* amount of gas.\n function expectCallMinGas(address callee, uint256 msgValue, uint64 minGas, bytes calldata data, uint64 count)\n external;\n\n /// Expects a call to an address with the specified calldata.\n /// Calldata can either be a strict or a partial match.\n function expectCall(address callee, bytes calldata data) external;\n\n /// Expects given number of calls to an address with the specified calldata.\n function expectCall(address callee, bytes calldata data, uint64 count) external;\n\n /// Expects a call to an address with the specified `msg.value` and calldata.\n function expectCall(address callee, uint256 msgValue, bytes calldata data) external;\n\n /// Expects given number of calls to an address with the specified `msg.value` and calldata.\n function expectCall(address callee, uint256 msgValue, bytes calldata data, uint64 count) external;\n\n /// Expect a call to an address with the specified `msg.value`, gas, and calldata.\n function expectCall(address callee, uint256 msgValue, uint64 gas, bytes calldata data) external;\n\n /// Expects given number of calls to an address with the specified `msg.value`, gas, and calldata.\n function expectCall(address callee, uint256 msgValue, uint64 gas, bytes calldata data, uint64 count) external;\n\n /// Expects the deployment of the specified bytecode by the specified address using the CREATE opcode\n function expectCreate(bytes calldata bytecode, address deployer) external;\n\n /// Expects the deployment of the specified bytecode by the specified address using the CREATE2 opcode\n function expectCreate2(bytes calldata bytecode, address deployer) external;\n\n /// Prepare an expected anonymous log with (bool checkTopic1, bool checkTopic2, bool checkTopic3, bool checkData.).\n /// Call this function, then emit an anonymous event, then call a function. Internally after the call, we check if\n /// logs were emitted in the expected order with the expected topics and data (as specified by the booleans).\n function expectEmitAnonymous(bool checkTopic0, bool checkTopic1, bool checkTopic2, bool checkTopic3, bool checkData)\n external;\n\n /// Same as the previous method, but also checks supplied address against emitting contract.\n function expectEmitAnonymous(\n bool checkTopic0,\n bool checkTopic1,\n bool checkTopic2,\n bool checkTopic3,\n bool checkData,\n address emitter\n ) external;\n\n /// Prepare an expected anonymous log with all topic and data checks enabled.\n /// Call this function, then emit an anonymous event, then call a function. Internally after the call, we check if\n /// logs were emitted in the expected order with the expected topics and data.\n function expectEmitAnonymous() external;\n\n /// Same as the previous method, but also checks supplied address against emitting contract.\n function expectEmitAnonymous(address emitter) external;\n\n /// Prepare an expected log with (bool checkTopic1, bool checkTopic2, bool checkTopic3, bool checkData.).\n /// Call this function, then emit an event, then call a function. Internally after the call, we check if\n /// logs were emitted in the expected order with the expected topics and data (as specified by the booleans).\n function expectEmit(bool checkTopic1, bool checkTopic2, bool checkTopic3, bool checkData) external;\n\n /// Same as the previous method, but also checks supplied address against emitting contract.\n function expectEmit(bool checkTopic1, bool checkTopic2, bool checkTopic3, bool checkData, address emitter)\n external;\n\n /// Prepare an expected log with all topic and data checks enabled.\n /// Call this function, then emit an event, then call a function. Internally after the call, we check if\n /// logs were emitted in the expected order with the expected topics and data.\n function expectEmit() external;\n\n /// Same as the previous method, but also checks supplied address against emitting contract.\n function expectEmit(address emitter) external;\n\n /// Expect a given number of logs with the provided topics.\n function expectEmit(bool checkTopic1, bool checkTopic2, bool checkTopic3, bool checkData, uint64 count) external;\n\n /// Expect a given number of logs from a specific emitter with the provided topics.\n function expectEmit(\n bool checkTopic1,\n bool checkTopic2,\n bool checkTopic3,\n bool checkData,\n address emitter,\n uint64 count\n ) external;\n\n /// Expect a given number of logs with all topic and data checks enabled.\n function expectEmit(uint64 count) external;\n\n /// Expect a given number of logs from a specific emitter with all topic and data checks enabled.\n function expectEmit(address emitter, uint64 count) external;\n\n /// Expects an error on next call that starts with the revert data.\n function expectPartialRevert(bytes4 revertData) external;\n\n /// Expects an error on next call to reverter address, that starts with the revert data.\n function expectPartialRevert(bytes4 revertData, address reverter) external;\n\n /// Expects an error on next call with any revert data.\n function expectRevert() external;\n\n /// Expects an error on next call that exactly matches the revert data.\n function expectRevert(bytes4 revertData) external;\n\n /// Expects a `count` number of reverts from the upcoming calls from the reverter address that match the revert data.\n function expectRevert(bytes4 revertData, address reverter, uint64 count) external;\n\n /// Expects a `count` number of reverts from the upcoming calls from the reverter address that exactly match the revert data.\n function expectRevert(bytes calldata revertData, address reverter, uint64 count) external;\n\n /// Expects an error on next call that exactly matches the revert data.\n function expectRevert(bytes calldata revertData) external;\n\n /// Expects an error with any revert data on next call to reverter address.\n function expectRevert(address reverter) external;\n\n /// Expects an error from reverter address on next call, with any revert data.\n function expectRevert(bytes4 revertData, address reverter) external;\n\n /// Expects an error from reverter address on next call, that exactly matches the revert data.\n function expectRevert(bytes calldata revertData, address reverter) external;\n\n /// Expects a `count` number of reverts from the upcoming calls with any revert data or reverter.\n function expectRevert(uint64 count) external;\n\n /// Expects a `count` number of reverts from the upcoming calls that match the revert data.\n function expectRevert(bytes4 revertData, uint64 count) external;\n\n /// Expects a `count` number of reverts from the upcoming calls that exactly match the revert data.\n function expectRevert(bytes calldata revertData, uint64 count) external;\n\n /// Expects a `count` number of reverts from the upcoming calls from the reverter address.\n function expectRevert(address reverter, uint64 count) external;\n\n /// Only allows memory writes to offsets [0x00, 0x60) ∪ [min, max) in the current subcontext. If any other\n /// memory is written to, the test will fail. Can be called multiple times to add more ranges to the set.\n function expectSafeMemory(uint64 min, uint64 max) external;\n\n /// Only allows memory writes to offsets [0x00, 0x60) ∪ [min, max) in the next created subcontext.\n /// If any other memory is written to, the test will fail. Can be called multiple times to add more ranges\n /// to the set.\n function expectSafeMemoryCall(uint64 min, uint64 max) external;\n\n /// Marks a test as skipped. Must be called at the top level of a test.\n function skip(bool skipTest) external;\n\n /// Marks a test as skipped with a reason. Must be called at the top level of a test.\n function skip(bool skipTest, string calldata reason) external;\n\n /// Stops all safe memory expectation in the current subcontext.\n function stopExpectSafeMemory() external;\n}\n","license":"MIT OR Apache-2.0"},"lib/forge-std/src/console.sol":{"keccak256":"0x4bbf47eb762cef93729d6ef15e78789957147039b113e5d4df48e3d3fd16d0f5","urls":[],"content":"// SPDX-License-Identifier: MIT\npragma solidity >=0.4.22 <0.9.0;\n\nlibrary console {\n address constant CONSOLE_ADDRESS =\n 0x000000000000000000636F6e736F6c652e6c6f67;\n\n function _sendLogPayloadImplementation(bytes memory payload) internal view {\n address consoleAddress = CONSOLE_ADDRESS;\n /// @solidity memory-safe-assembly\n assembly {\n pop(\n staticcall(\n gas(),\n consoleAddress,\n add(payload, 32),\n mload(payload),\n 0,\n 0\n )\n )\n }\n }\n\n function _castToPure(\n function(bytes memory) internal view fnIn\n ) internal pure returns (function(bytes memory) pure fnOut) {\n assembly {\n fnOut := fnIn\n }\n }\n\n function _sendLogPayload(bytes memory payload) internal pure {\n _castToPure(_sendLogPayloadImplementation)(payload);\n }\n\n function log() internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log()\"));\n }\n\n function logInt(int256 p0) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(int256)\", p0));\n }\n\n function logUint(uint256 p0) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256)\", p0));\n }\n\n function logString(string memory p0) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string)\", p0));\n }\n\n function logBool(bool p0) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool)\", p0));\n }\n\n function logAddress(address p0) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address)\", p0));\n }\n\n function logBytes(bytes memory p0) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bytes)\", p0));\n }\n\n function logBytes1(bytes1 p0) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bytes1)\", p0));\n }\n\n function logBytes2(bytes2 p0) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bytes2)\", p0));\n }\n\n function logBytes3(bytes3 p0) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bytes3)\", p0));\n }\n\n function logBytes4(bytes4 p0) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bytes4)\", p0));\n }\n\n function logBytes5(bytes5 p0) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bytes5)\", p0));\n }\n\n function logBytes6(bytes6 p0) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bytes6)\", p0));\n }\n\n function logBytes7(bytes7 p0) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bytes7)\", p0));\n }\n\n function logBytes8(bytes8 p0) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bytes8)\", p0));\n }\n\n function logBytes9(bytes9 p0) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bytes9)\", p0));\n }\n\n function logBytes10(bytes10 p0) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bytes10)\", p0));\n }\n\n function logBytes11(bytes11 p0) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bytes11)\", p0));\n }\n\n function logBytes12(bytes12 p0) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bytes12)\", p0));\n }\n\n function logBytes13(bytes13 p0) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bytes13)\", p0));\n }\n\n function logBytes14(bytes14 p0) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bytes14)\", p0));\n }\n\n function logBytes15(bytes15 p0) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bytes15)\", p0));\n }\n\n function logBytes16(bytes16 p0) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bytes16)\", p0));\n }\n\n function logBytes17(bytes17 p0) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bytes17)\", p0));\n }\n\n function logBytes18(bytes18 p0) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bytes18)\", p0));\n }\n\n function logBytes19(bytes19 p0) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bytes19)\", p0));\n }\n\n function logBytes20(bytes20 p0) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bytes20)\", p0));\n }\n\n function logBytes21(bytes21 p0) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bytes21)\", p0));\n }\n\n function logBytes22(bytes22 p0) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bytes22)\", p0));\n }\n\n function logBytes23(bytes23 p0) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bytes23)\", p0));\n }\n\n function logBytes24(bytes24 p0) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bytes24)\", p0));\n }\n\n function logBytes25(bytes25 p0) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bytes25)\", p0));\n }\n\n function logBytes26(bytes26 p0) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bytes26)\", p0));\n }\n\n function logBytes27(bytes27 p0) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bytes27)\", p0));\n }\n\n function logBytes28(bytes28 p0) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bytes28)\", p0));\n }\n\n function logBytes29(bytes29 p0) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bytes29)\", p0));\n }\n\n function logBytes30(bytes30 p0) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bytes30)\", p0));\n }\n\n function logBytes31(bytes31 p0) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bytes31)\", p0));\n }\n\n function logBytes32(bytes32 p0) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bytes32)\", p0));\n }\n\n function log(uint256 p0) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256)\", p0));\n }\n\n function log(int256 p0) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(int256)\", p0));\n }\n\n function log(string memory p0) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string)\", p0));\n }\n\n function log(bool p0) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool)\", p0));\n }\n\n function log(address p0) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address)\", p0));\n }\n\n function log(uint256 p0, uint256 p1) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,uint256)\", p0, p1));\n }\n\n function log(uint256 p0, string memory p1) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,string)\", p0, p1));\n }\n\n function log(uint256 p0, bool p1) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,bool)\", p0, p1));\n }\n\n function log(uint256 p0, address p1) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,address)\", p0, p1));\n }\n\n function log(string memory p0, uint256 p1) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,uint256)\", p0, p1));\n }\n\n function log(string memory p0, int256 p1) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,int256)\", p0, p1));\n }\n\n function log(string memory p0, string memory p1) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,string)\", p0, p1));\n }\n\n function log(string memory p0, bool p1) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,bool)\", p0, p1));\n }\n\n function log(string memory p0, address p1) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,address)\", p0, p1));\n }\n\n function log(bool p0, uint256 p1) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,uint256)\", p0, p1));\n }\n\n function log(bool p0, string memory p1) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,string)\", p0, p1));\n }\n\n function log(bool p0, bool p1) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,bool)\", p0, p1));\n }\n\n function log(bool p0, address p1) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,address)\", p0, p1));\n }\n\n function log(address p0, uint256 p1) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,uint256)\", p0, p1));\n }\n\n function log(address p0, string memory p1) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,string)\", p0, p1));\n }\n\n function log(address p0, bool p1) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,bool)\", p0, p1));\n }\n\n function log(address p0, address p1) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,address)\", p0, p1));\n }\n\n function log(uint256 p0, uint256 p1, uint256 p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,uint256,uint256)\", p0, p1, p2));\n }\n\n function log(uint256 p0, uint256 p1, string memory p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,uint256,string)\", p0, p1, p2));\n }\n\n function log(uint256 p0, uint256 p1, bool p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,uint256,bool)\", p0, p1, p2));\n }\n\n function log(uint256 p0, uint256 p1, address p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,uint256,address)\", p0, p1, p2));\n }\n\n function log(uint256 p0, string memory p1, uint256 p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,string,uint256)\", p0, p1, p2));\n }\n\n function log(uint256 p0, string memory p1, string memory p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,string,string)\", p0, p1, p2));\n }\n\n function log(uint256 p0, string memory p1, bool p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,string,bool)\", p0, p1, p2));\n }\n\n function log(uint256 p0, string memory p1, address p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,string,address)\", p0, p1, p2));\n }\n\n function log(uint256 p0, bool p1, uint256 p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,bool,uint256)\", p0, p1, p2));\n }\n\n function log(uint256 p0, bool p1, string memory p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,bool,string)\", p0, p1, p2));\n }\n\n function log(uint256 p0, bool p1, bool p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,bool,bool)\", p0, p1, p2));\n }\n\n function log(uint256 p0, bool p1, address p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,bool,address)\", p0, p1, p2));\n }\n\n function log(uint256 p0, address p1, uint256 p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,address,uint256)\", p0, p1, p2));\n }\n\n function log(uint256 p0, address p1, string memory p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,address,string)\", p0, p1, p2));\n }\n\n function log(uint256 p0, address p1, bool p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,address,bool)\", p0, p1, p2));\n }\n\n function log(uint256 p0, address p1, address p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,address,address)\", p0, p1, p2));\n }\n\n function log(string memory p0, uint256 p1, uint256 p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,uint256,uint256)\", p0, p1, p2));\n }\n\n function log(string memory p0, uint256 p1, string memory p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,uint256,string)\", p0, p1, p2));\n }\n\n function log(string memory p0, uint256 p1, bool p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,uint256,bool)\", p0, p1, p2));\n }\n\n function log(string memory p0, uint256 p1, address p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,uint256,address)\", p0, p1, p2));\n }\n\n function log(string memory p0, string memory p1, uint256 p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,string,uint256)\", p0, p1, p2));\n }\n\n function log(string memory p0, string memory p1, string memory p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,string,string)\", p0, p1, p2));\n }\n\n function log(string memory p0, string memory p1, bool p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,string,bool)\", p0, p1, p2));\n }\n\n function log(string memory p0, string memory p1, address p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,string,address)\", p0, p1, p2));\n }\n\n function log(string memory p0, bool p1, uint256 p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,bool,uint256)\", p0, p1, p2));\n }\n\n function log(string memory p0, bool p1, string memory p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,bool,string)\", p0, p1, p2));\n }\n\n function log(string memory p0, bool p1, bool p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,bool,bool)\", p0, p1, p2));\n }\n\n function log(string memory p0, bool p1, address p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,bool,address)\", p0, p1, p2));\n }\n\n function log(string memory p0, address p1, uint256 p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,address,uint256)\", p0, p1, p2));\n }\n\n function log(string memory p0, address p1, string memory p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,address,string)\", p0, p1, p2));\n }\n\n function log(string memory p0, address p1, bool p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,address,bool)\", p0, p1, p2));\n }\n\n function log(string memory p0, address p1, address p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,address,address)\", p0, p1, p2));\n }\n\n function log(bool p0, uint256 p1, uint256 p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,uint256,uint256)\", p0, p1, p2));\n }\n\n function log(bool p0, uint256 p1, string memory p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,uint256,string)\", p0, p1, p2));\n }\n\n function log(bool p0, uint256 p1, bool p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,uint256,bool)\", p0, p1, p2));\n }\n\n function log(bool p0, uint256 p1, address p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,uint256,address)\", p0, p1, p2));\n }\n\n function log(bool p0, string memory p1, uint256 p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,string,uint256)\", p0, p1, p2));\n }\n\n function log(bool p0, string memory p1, string memory p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,string,string)\", p0, p1, p2));\n }\n\n function log(bool p0, string memory p1, bool p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,string,bool)\", p0, p1, p2));\n }\n\n function log(bool p0, string memory p1, address p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,string,address)\", p0, p1, p2));\n }\n\n function log(bool p0, bool p1, uint256 p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,bool,uint256)\", p0, p1, p2));\n }\n\n function log(bool p0, bool p1, string memory p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,bool,string)\", p0, p1, p2));\n }\n\n function log(bool p0, bool p1, bool p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,bool,bool)\", p0, p1, p2));\n }\n\n function log(bool p0, bool p1, address p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,bool,address)\", p0, p1, p2));\n }\n\n function log(bool p0, address p1, uint256 p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,address,uint256)\", p0, p1, p2));\n }\n\n function log(bool p0, address p1, string memory p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,address,string)\", p0, p1, p2));\n }\n\n function log(bool p0, address p1, bool p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,address,bool)\", p0, p1, p2));\n }\n\n function log(bool p0, address p1, address p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,address,address)\", p0, p1, p2));\n }\n\n function log(address p0, uint256 p1, uint256 p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,uint256,uint256)\", p0, p1, p2));\n }\n\n function log(address p0, uint256 p1, string memory p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,uint256,string)\", p0, p1, p2));\n }\n\n function log(address p0, uint256 p1, bool p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,uint256,bool)\", p0, p1, p2));\n }\n\n function log(address p0, uint256 p1, address p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,uint256,address)\", p0, p1, p2));\n }\n\n function log(address p0, string memory p1, uint256 p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,string,uint256)\", p0, p1, p2));\n }\n\n function log(address p0, string memory p1, string memory p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,string,string)\", p0, p1, p2));\n }\n\n function log(address p0, string memory p1, bool p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,string,bool)\", p0, p1, p2));\n }\n\n function log(address p0, string memory p1, address p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,string,address)\", p0, p1, p2));\n }\n\n function log(address p0, bool p1, uint256 p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,bool,uint256)\", p0, p1, p2));\n }\n\n function log(address p0, bool p1, string memory p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,bool,string)\", p0, p1, p2));\n }\n\n function log(address p0, bool p1, bool p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,bool,bool)\", p0, p1, p2));\n }\n\n function log(address p0, bool p1, address p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,bool,address)\", p0, p1, p2));\n }\n\n function log(address p0, address p1, uint256 p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,address,uint256)\", p0, p1, p2));\n }\n\n function log(address p0, address p1, string memory p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,address,string)\", p0, p1, p2));\n }\n\n function log(address p0, address p1, bool p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,address,bool)\", p0, p1, p2));\n }\n\n function log(address p0, address p1, address p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,address,address)\", p0, p1, p2));\n }\n\n function log(uint256 p0, uint256 p1, uint256 p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,uint256,uint256,uint256)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, uint256 p1, uint256 p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,uint256,uint256,string)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, uint256 p1, uint256 p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,uint256,uint256,bool)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, uint256 p1, uint256 p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,uint256,uint256,address)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, uint256 p1, string memory p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,uint256,string,uint256)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, uint256 p1, string memory p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,uint256,string,string)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, uint256 p1, string memory p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,uint256,string,bool)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, uint256 p1, string memory p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,uint256,string,address)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, uint256 p1, bool p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,uint256,bool,uint256)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, uint256 p1, bool p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,uint256,bool,string)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, uint256 p1, bool p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,uint256,bool,bool)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, uint256 p1, bool p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,uint256,bool,address)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, uint256 p1, address p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,uint256,address,uint256)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, uint256 p1, address p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,uint256,address,string)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, uint256 p1, address p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,uint256,address,bool)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, uint256 p1, address p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,uint256,address,address)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, string memory p1, uint256 p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,string,uint256,uint256)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, string memory p1, uint256 p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,string,uint256,string)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, string memory p1, uint256 p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,string,uint256,bool)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, string memory p1, uint256 p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,string,uint256,address)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, string memory p1, string memory p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,string,string,uint256)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, string memory p1, string memory p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,string,string,string)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, string memory p1, string memory p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,string,string,bool)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, string memory p1, string memory p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,string,string,address)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, string memory p1, bool p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,string,bool,uint256)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, string memory p1, bool p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,string,bool,string)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, string memory p1, bool p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,string,bool,bool)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, string memory p1, bool p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,string,bool,address)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, string memory p1, address p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,string,address,uint256)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, string memory p1, address p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,string,address,string)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, string memory p1, address p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,string,address,bool)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, string memory p1, address p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,string,address,address)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, bool p1, uint256 p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,bool,uint256,uint256)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, bool p1, uint256 p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,bool,uint256,string)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, bool p1, uint256 p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,bool,uint256,bool)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, bool p1, uint256 p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,bool,uint256,address)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, bool p1, string memory p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,bool,string,uint256)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, bool p1, string memory p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,bool,string,string)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, bool p1, string memory p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,bool,string,bool)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, bool p1, string memory p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,bool,string,address)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, bool p1, bool p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,bool,bool,uint256)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, bool p1, bool p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,bool,bool,string)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, bool p1, bool p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,bool,bool,bool)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, bool p1, bool p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,bool,bool,address)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, bool p1, address p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,bool,address,uint256)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, bool p1, address p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,bool,address,string)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, bool p1, address p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,bool,address,bool)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, bool p1, address p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,bool,address,address)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, address p1, uint256 p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,address,uint256,uint256)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, address p1, uint256 p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,address,uint256,string)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, address p1, uint256 p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,address,uint256,bool)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, address p1, uint256 p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,address,uint256,address)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, address p1, string memory p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,address,string,uint256)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, address p1, string memory p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,address,string,string)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, address p1, string memory p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,address,string,bool)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, address p1, string memory p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,address,string,address)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, address p1, bool p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,address,bool,uint256)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, address p1, bool p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,address,bool,string)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, address p1, bool p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,address,bool,bool)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, address p1, bool p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,address,bool,address)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, address p1, address p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,address,address,uint256)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, address p1, address p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,address,address,string)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, address p1, address p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,address,address,bool)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, address p1, address p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,address,address,address)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, uint256 p1, uint256 p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,uint256,uint256,uint256)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, uint256 p1, uint256 p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,uint256,uint256,string)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, uint256 p1, uint256 p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,uint256,uint256,bool)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, uint256 p1, uint256 p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,uint256,uint256,address)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, uint256 p1, string memory p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,uint256,string,uint256)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, uint256 p1, string memory p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,uint256,string,string)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, uint256 p1, string memory p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,uint256,string,bool)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, uint256 p1, string memory p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,uint256,string,address)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, uint256 p1, bool p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,uint256,bool,uint256)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, uint256 p1, bool p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,uint256,bool,string)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, uint256 p1, bool p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,uint256,bool,bool)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, uint256 p1, bool p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,uint256,bool,address)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, uint256 p1, address p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,uint256,address,uint256)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, uint256 p1, address p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,uint256,address,string)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, uint256 p1, address p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,uint256,address,bool)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, uint256 p1, address p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,uint256,address,address)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, string memory p1, uint256 p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,string,uint256,uint256)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, string memory p1, uint256 p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,string,uint256,string)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, string memory p1, uint256 p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,string,uint256,bool)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, string memory p1, uint256 p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,string,uint256,address)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, string memory p1, string memory p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,string,string,uint256)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, string memory p1, string memory p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,string,string,string)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, string memory p1, string memory p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,string,string,bool)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, string memory p1, string memory p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,string,string,address)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, string memory p1, bool p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,string,bool,uint256)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, string memory p1, bool p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,string,bool,string)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, string memory p1, bool p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,string,bool,bool)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, string memory p1, bool p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,string,bool,address)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, string memory p1, address p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,string,address,uint256)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, string memory p1, address p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,string,address,string)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, string memory p1, address p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,string,address,bool)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, string memory p1, address p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,string,address,address)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, bool p1, uint256 p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,bool,uint256,uint256)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, bool p1, uint256 p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,bool,uint256,string)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, bool p1, uint256 p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,bool,uint256,bool)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, bool p1, uint256 p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,bool,uint256,address)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, bool p1, string memory p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,bool,string,uint256)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, bool p1, string memory p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,bool,string,string)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, bool p1, string memory p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,bool,string,bool)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, bool p1, string memory p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,bool,string,address)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, bool p1, bool p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,bool,bool,uint256)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, bool p1, bool p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,bool,bool,string)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, bool p1, bool p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,bool,bool,bool)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, bool p1, bool p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,bool,bool,address)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, bool p1, address p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,bool,address,uint256)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, bool p1, address p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,bool,address,string)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, bool p1, address p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,bool,address,bool)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, bool p1, address p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,bool,address,address)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, address p1, uint256 p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,address,uint256,uint256)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, address p1, uint256 p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,address,uint256,string)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, address p1, uint256 p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,address,uint256,bool)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, address p1, uint256 p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,address,uint256,address)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, address p1, string memory p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,address,string,uint256)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, address p1, string memory p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,address,string,string)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, address p1, string memory p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,address,string,bool)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, address p1, string memory p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,address,string,address)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, address p1, bool p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,address,bool,uint256)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, address p1, bool p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,address,bool,string)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, address p1, bool p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,address,bool,bool)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, address p1, bool p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,address,bool,address)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, address p1, address p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,address,address,uint256)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, address p1, address p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,address,address,string)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, address p1, address p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,address,address,bool)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, address p1, address p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,address,address,address)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, uint256 p1, uint256 p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,uint256,uint256,uint256)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, uint256 p1, uint256 p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,uint256,uint256,string)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, uint256 p1, uint256 p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,uint256,uint256,bool)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, uint256 p1, uint256 p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,uint256,uint256,address)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, uint256 p1, string memory p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,uint256,string,uint256)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, uint256 p1, string memory p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,uint256,string,string)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, uint256 p1, string memory p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,uint256,string,bool)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, uint256 p1, string memory p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,uint256,string,address)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, uint256 p1, bool p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,uint256,bool,uint256)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, uint256 p1, bool p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,uint256,bool,string)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, uint256 p1, bool p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,uint256,bool,bool)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, uint256 p1, bool p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,uint256,bool,address)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, uint256 p1, address p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,uint256,address,uint256)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, uint256 p1, address p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,uint256,address,string)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, uint256 p1, address p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,uint256,address,bool)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, uint256 p1, address p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,uint256,address,address)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, string memory p1, uint256 p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,string,uint256,uint256)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, string memory p1, uint256 p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,string,uint256,string)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, string memory p1, uint256 p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,string,uint256,bool)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, string memory p1, uint256 p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,string,uint256,address)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, string memory p1, string memory p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,string,string,uint256)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, string memory p1, string memory p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,string,string,string)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, string memory p1, string memory p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,string,string,bool)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, string memory p1, string memory p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,string,string,address)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, string memory p1, bool p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,string,bool,uint256)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, string memory p1, bool p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,string,bool,string)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, string memory p1, bool p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,string,bool,bool)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, string memory p1, bool p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,string,bool,address)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, string memory p1, address p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,string,address,uint256)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, string memory p1, address p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,string,address,string)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, string memory p1, address p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,string,address,bool)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, string memory p1, address p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,string,address,address)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, bool p1, uint256 p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,bool,uint256,uint256)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, bool p1, uint256 p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,bool,uint256,string)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, bool p1, uint256 p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,bool,uint256,bool)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, bool p1, uint256 p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,bool,uint256,address)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, bool p1, string memory p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,bool,string,uint256)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, bool p1, string memory p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,bool,string,string)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, bool p1, string memory p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,bool,string,bool)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, bool p1, string memory p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,bool,string,address)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, bool p1, bool p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,bool,bool,uint256)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, bool p1, bool p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,bool,bool,string)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, bool p1, bool p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,bool,bool,bool)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, bool p1, bool p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,bool,bool,address)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, bool p1, address p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,bool,address,uint256)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, bool p1, address p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,bool,address,string)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, bool p1, address p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,bool,address,bool)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, bool p1, address p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,bool,address,address)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, address p1, uint256 p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,address,uint256,uint256)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, address p1, uint256 p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,address,uint256,string)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, address p1, uint256 p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,address,uint256,bool)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, address p1, uint256 p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,address,uint256,address)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, address p1, string memory p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,address,string,uint256)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, address p1, string memory p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,address,string,string)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, address p1, string memory p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,address,string,bool)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, address p1, string memory p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,address,string,address)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, address p1, bool p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,address,bool,uint256)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, address p1, bool p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,address,bool,string)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, address p1, bool p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,address,bool,bool)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, address p1, bool p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,address,bool,address)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, address p1, address p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,address,address,uint256)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, address p1, address p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,address,address,string)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, address p1, address p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,address,address,bool)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, address p1, address p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,address,address,address)\", p0, p1, p2, p3));\n }\n\n function log(address p0, uint256 p1, uint256 p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,uint256,uint256,uint256)\", p0, p1, p2, p3));\n }\n\n function log(address p0, uint256 p1, uint256 p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,uint256,uint256,string)\", p0, p1, p2, p3));\n }\n\n function log(address p0, uint256 p1, uint256 p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,uint256,uint256,bool)\", p0, p1, p2, p3));\n }\n\n function log(address p0, uint256 p1, uint256 p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,uint256,uint256,address)\", p0, p1, p2, p3));\n }\n\n function log(address p0, uint256 p1, string memory p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,uint256,string,uint256)\", p0, p1, p2, p3));\n }\n\n function log(address p0, uint256 p1, string memory p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,uint256,string,string)\", p0, p1, p2, p3));\n }\n\n function log(address p0, uint256 p1, string memory p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,uint256,string,bool)\", p0, p1, p2, p3));\n }\n\n function log(address p0, uint256 p1, string memory p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,uint256,string,address)\", p0, p1, p2, p3));\n }\n\n function log(address p0, uint256 p1, bool p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,uint256,bool,uint256)\", p0, p1, p2, p3));\n }\n\n function log(address p0, uint256 p1, bool p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,uint256,bool,string)\", p0, p1, p2, p3));\n }\n\n function log(address p0, uint256 p1, bool p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,uint256,bool,bool)\", p0, p1, p2, p3));\n }\n\n function log(address p0, uint256 p1, bool p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,uint256,bool,address)\", p0, p1, p2, p3));\n }\n\n function log(address p0, uint256 p1, address p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,uint256,address,uint256)\", p0, p1, p2, p3));\n }\n\n function log(address p0, uint256 p1, address p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,uint256,address,string)\", p0, p1, p2, p3));\n }\n\n function log(address p0, uint256 p1, address p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,uint256,address,bool)\", p0, p1, p2, p3));\n }\n\n function log(address p0, uint256 p1, address p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,uint256,address,address)\", p0, p1, p2, p3));\n }\n\n function log(address p0, string memory p1, uint256 p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,string,uint256,uint256)\", p0, p1, p2, p3));\n }\n\n function log(address p0, string memory p1, uint256 p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,string,uint256,string)\", p0, p1, p2, p3));\n }\n\n function log(address p0, string memory p1, uint256 p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,string,uint256,bool)\", p0, p1, p2, p3));\n }\n\n function log(address p0, string memory p1, uint256 p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,string,uint256,address)\", p0, p1, p2, p3));\n }\n\n function log(address p0, string memory p1, string memory p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,string,string,uint256)\", p0, p1, p2, p3));\n }\n\n function log(address p0, string memory p1, string memory p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,string,string,string)\", p0, p1, p2, p3));\n }\n\n function log(address p0, string memory p1, string memory p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,string,string,bool)\", p0, p1, p2, p3));\n }\n\n function log(address p0, string memory p1, string memory p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,string,string,address)\", p0, p1, p2, p3));\n }\n\n function log(address p0, string memory p1, bool p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,string,bool,uint256)\", p0, p1, p2, p3));\n }\n\n function log(address p0, string memory p1, bool p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,string,bool,string)\", p0, p1, p2, p3));\n }\n\n function log(address p0, string memory p1, bool p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,string,bool,bool)\", p0, p1, p2, p3));\n }\n\n function log(address p0, string memory p1, bool p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,string,bool,address)\", p0, p1, p2, p3));\n }\n\n function log(address p0, string memory p1, address p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,string,address,uint256)\", p0, p1, p2, p3));\n }\n\n function log(address p0, string memory p1, address p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,string,address,string)\", p0, p1, p2, p3));\n }\n\n function log(address p0, string memory p1, address p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,string,address,bool)\", p0, p1, p2, p3));\n }\n\n function log(address p0, string memory p1, address p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,string,address,address)\", p0, p1, p2, p3));\n }\n\n function log(address p0, bool p1, uint256 p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,bool,uint256,uint256)\", p0, p1, p2, p3));\n }\n\n function log(address p0, bool p1, uint256 p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,bool,uint256,string)\", p0, p1, p2, p3));\n }\n\n function log(address p0, bool p1, uint256 p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,bool,uint256,bool)\", p0, p1, p2, p3));\n }\n\n function log(address p0, bool p1, uint256 p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,bool,uint256,address)\", p0, p1, p2, p3));\n }\n\n function log(address p0, bool p1, string memory p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,bool,string,uint256)\", p0, p1, p2, p3));\n }\n\n function log(address p0, bool p1, string memory p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,bool,string,string)\", p0, p1, p2, p3));\n }\n\n function log(address p0, bool p1, string memory p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,bool,string,bool)\", p0, p1, p2, p3));\n }\n\n function log(address p0, bool p1, string memory p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,bool,string,address)\", p0, p1, p2, p3));\n }\n\n function log(address p0, bool p1, bool p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,bool,bool,uint256)\", p0, p1, p2, p3));\n }\n\n function log(address p0, bool p1, bool p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,bool,bool,string)\", p0, p1, p2, p3));\n }\n\n function log(address p0, bool p1, bool p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,bool,bool,bool)\", p0, p1, p2, p3));\n }\n\n function log(address p0, bool p1, bool p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,bool,bool,address)\", p0, p1, p2, p3));\n }\n\n function log(address p0, bool p1, address p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,bool,address,uint256)\", p0, p1, p2, p3));\n }\n\n function log(address p0, bool p1, address p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,bool,address,string)\", p0, p1, p2, p3));\n }\n\n function log(address p0, bool p1, address p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,bool,address,bool)\", p0, p1, p2, p3));\n }\n\n function log(address p0, bool p1, address p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,bool,address,address)\", p0, p1, p2, p3));\n }\n\n function log(address p0, address p1, uint256 p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,address,uint256,uint256)\", p0, p1, p2, p3));\n }\n\n function log(address p0, address p1, uint256 p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,address,uint256,string)\", p0, p1, p2, p3));\n }\n\n function log(address p0, address p1, uint256 p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,address,uint256,bool)\", p0, p1, p2, p3));\n }\n\n function log(address p0, address p1, uint256 p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,address,uint256,address)\", p0, p1, p2, p3));\n }\n\n function log(address p0, address p1, string memory p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,address,string,uint256)\", p0, p1, p2, p3));\n }\n\n function log(address p0, address p1, string memory p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,address,string,string)\", p0, p1, p2, p3));\n }\n\n function log(address p0, address p1, string memory p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,address,string,bool)\", p0, p1, p2, p3));\n }\n\n function log(address p0, address p1, string memory p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,address,string,address)\", p0, p1, p2, p3));\n }\n\n function log(address p0, address p1, bool p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,address,bool,uint256)\", p0, p1, p2, p3));\n }\n\n function log(address p0, address p1, bool p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,address,bool,string)\", p0, p1, p2, p3));\n }\n\n function log(address p0, address p1, bool p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,address,bool,bool)\", p0, p1, p2, p3));\n }\n\n function log(address p0, address p1, bool p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,address,bool,address)\", p0, p1, p2, p3));\n }\n\n function log(address p0, address p1, address p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,address,address,uint256)\", p0, p1, p2, p3));\n }\n\n function log(address p0, address p1, address p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,address,address,string)\", p0, p1, p2, p3));\n }\n\n function log(address p0, address p1, address p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,address,address,bool)\", p0, p1, p2, p3));\n }\n\n function log(address p0, address p1, address p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,address,address,address)\", p0, p1, p2, p3));\n }\n}\n","license":"MIT"},"lib/forge-std/src/console2.sol":{"keccak256":"0x3b8fe79f48f065a4e4d35362171304a33784c3a90febae5f2787805a438de12f","urls":[],"content":"// SPDX-License-Identifier: MIT\npragma solidity >=0.4.22 <0.9.0;\n\nimport {console as console2} from \"./console.sol\";\n","license":"MIT"},"lib/forge-std/src/interfaces/IMulticall3.sol":{"keccak256":"0x7aac1389150499a922d1f9ef5749c908cef127cb2075b92fa17e9cb611263d0a","urls":[],"content":"// SPDX-License-Identifier: MIT\npragma solidity >=0.6.2 <0.9.0;\n\npragma experimental ABIEncoderV2;\n\ninterface IMulticall3 {\n struct Call {\n address target;\n bytes callData;\n }\n\n struct Call3 {\n address target;\n bool allowFailure;\n bytes callData;\n }\n\n struct Call3Value {\n address target;\n bool allowFailure;\n uint256 value;\n bytes callData;\n }\n\n struct Result {\n bool success;\n bytes returnData;\n }\n\n function aggregate(Call[] calldata calls)\n external\n payable\n returns (uint256 blockNumber, bytes[] memory returnData);\n\n function aggregate3(Call3[] calldata calls) external payable returns (Result[] memory returnData);\n\n function aggregate3Value(Call3Value[] calldata calls) external payable returns (Result[] memory returnData);\n\n function blockAndAggregate(Call[] calldata calls)\n external\n payable\n returns (uint256 blockNumber, bytes32 blockHash, Result[] memory returnData);\n\n function getBasefee() external view returns (uint256 basefee);\n\n function getBlockHash(uint256 blockNumber) external view returns (bytes32 blockHash);\n\n function getBlockNumber() external view returns (uint256 blockNumber);\n\n function getChainId() external view returns (uint256 chainid);\n\n function getCurrentBlockCoinbase() external view returns (address coinbase);\n\n function getCurrentBlockDifficulty() external view returns (uint256 difficulty);\n\n function getCurrentBlockGasLimit() external view returns (uint256 gaslimit);\n\n function getCurrentBlockTimestamp() external view returns (uint256 timestamp);\n\n function getEthBalance(address addr) external view returns (uint256 balance);\n\n function getLastBlockHash() external view returns (bytes32 blockHash);\n\n function tryAggregate(bool requireSuccess, Call[] calldata calls)\n external\n payable\n returns (Result[] memory returnData);\n\n function tryBlockAndAggregate(bool requireSuccess, Call[] calldata calls)\n external\n payable\n returns (uint256 blockNumber, bytes32 blockHash, Result[] memory returnData);\n}\n","license":"MIT"},"lib/forge-std/src/safeconsole.sol":{"keccak256":"0xbef9786cb49d3eade757bad87568c49c8c8f35721f0193c95ffb055d9e466e11","urls":[],"content":"// SPDX-License-Identifier: MIT\npragma solidity >=0.6.2 <0.9.0;\n\n/// @author philogy \n/// @dev Code generated automatically by script.\nlibrary safeconsole {\n uint256 constant CONSOLE_ADDR = 0x000000000000000000000000000000000000000000636F6e736F6c652e6c6f67;\n\n // Credit to [0age](https://twitter.com/z0age/status/1654922202930888704) and [0xdapper](https://github.com/foundry-rs/forge-std/pull/374)\n // for the view-to-pure log trick.\n function _sendLogPayload(uint256 offset, uint256 size) private pure {\n function(uint256, uint256) internal view fnIn = _sendLogPayloadView;\n function(uint256, uint256) internal pure pureSendLogPayload;\n /// @solidity memory-safe-assembly\n assembly {\n pureSendLogPayload := fnIn\n }\n pureSendLogPayload(offset, size);\n }\n\n function _sendLogPayloadView(uint256 offset, uint256 size) private view {\n /// @solidity memory-safe-assembly\n assembly {\n pop(staticcall(gas(), CONSOLE_ADDR, offset, size, 0x0, 0x0))\n }\n }\n\n function _memcopy(uint256 fromOffset, uint256 toOffset, uint256 length) private pure {\n function(uint256, uint256, uint256) internal view fnIn = _memcopyView;\n function(uint256, uint256, uint256) internal pure pureMemcopy;\n /// @solidity memory-safe-assembly\n assembly {\n pureMemcopy := fnIn\n }\n pureMemcopy(fromOffset, toOffset, length);\n }\n\n function _memcopyView(uint256 fromOffset, uint256 toOffset, uint256 length) private view {\n /// @solidity memory-safe-assembly\n assembly {\n pop(staticcall(gas(), 0x4, fromOffset, length, toOffset, length))\n }\n }\n\n function logMemory(uint256 offset, uint256 length) internal pure {\n if (offset >= 0x60) {\n // Sufficient memory before slice to prepare call header.\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(sub(offset, 0x60))\n m1 := mload(sub(offset, 0x40))\n m2 := mload(sub(offset, 0x20))\n // Selector of `log(bytes)`.\n mstore(sub(offset, 0x60), 0x0be77f56)\n mstore(sub(offset, 0x40), 0x20)\n mstore(sub(offset, 0x20), length)\n }\n _sendLogPayload(offset - 0x44, length + 0x44);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(sub(offset, 0x60), m0)\n mstore(sub(offset, 0x40), m1)\n mstore(sub(offset, 0x20), m2)\n }\n } else {\n // Insufficient space, so copy slice forward, add header and reverse.\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n uint256 endOffset = offset + length;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(add(endOffset, 0x00))\n m1 := mload(add(endOffset, 0x20))\n m2 := mload(add(endOffset, 0x40))\n }\n _memcopy(offset, offset + 0x60, length);\n /// @solidity memory-safe-assembly\n assembly {\n // Selector of `log(bytes)`.\n mstore(add(offset, 0x00), 0x0be77f56)\n mstore(add(offset, 0x20), 0x20)\n mstore(add(offset, 0x40), length)\n }\n _sendLogPayload(offset + 0x1c, length + 0x44);\n _memcopy(offset + 0x60, offset, length);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(add(endOffset, 0x00), m0)\n mstore(add(endOffset, 0x20), m1)\n mstore(add(endOffset, 0x40), m2)\n }\n }\n }\n\n function log(address p0) internal pure {\n bytes32 m0;\n bytes32 m1;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n // Selector of `log(address)`.\n mstore(0x00, 0x2c2ecbc2)\n mstore(0x20, p0)\n }\n _sendLogPayload(0x1c, 0x24);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n }\n }\n\n function log(bool p0) internal pure {\n bytes32 m0;\n bytes32 m1;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n // Selector of `log(bool)`.\n mstore(0x00, 0x32458eed)\n mstore(0x20, p0)\n }\n _sendLogPayload(0x1c, 0x24);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n }\n }\n\n function log(uint256 p0) internal pure {\n bytes32 m0;\n bytes32 m1;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n // Selector of `log(uint256)`.\n mstore(0x00, 0xf82c50f1)\n mstore(0x20, p0)\n }\n _sendLogPayload(0x1c, 0x24);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n }\n }\n\n function log(bytes32 p0) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n // Selector of `log(string)`.\n mstore(0x00, 0x41304fac)\n mstore(0x20, 0x20)\n writeString(0x40, p0)\n }\n _sendLogPayload(0x1c, 0x64);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n }\n }\n\n function log(address p0, address p1) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n // Selector of `log(address,address)`.\n mstore(0x00, 0xdaf0d4aa)\n mstore(0x20, p0)\n mstore(0x40, p1)\n }\n _sendLogPayload(0x1c, 0x44);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n }\n }\n\n function log(address p0, bool p1) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n // Selector of `log(address,bool)`.\n mstore(0x00, 0x75b605d3)\n mstore(0x20, p0)\n mstore(0x40, p1)\n }\n _sendLogPayload(0x1c, 0x44);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n }\n }\n\n function log(address p0, uint256 p1) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n // Selector of `log(address,uint256)`.\n mstore(0x00, 0x8309e8a8)\n mstore(0x20, p0)\n mstore(0x40, p1)\n }\n _sendLogPayload(0x1c, 0x44);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n }\n }\n\n function log(address p0, bytes32 p1) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(address,string)`.\n mstore(0x00, 0x759f86bb)\n mstore(0x20, p0)\n mstore(0x40, 0x40)\n writeString(0x60, p1)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(bool p0, address p1) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n // Selector of `log(bool,address)`.\n mstore(0x00, 0x853c4849)\n mstore(0x20, p0)\n mstore(0x40, p1)\n }\n _sendLogPayload(0x1c, 0x44);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n }\n }\n\n function log(bool p0, bool p1) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n // Selector of `log(bool,bool)`.\n mstore(0x00, 0x2a110e83)\n mstore(0x20, p0)\n mstore(0x40, p1)\n }\n _sendLogPayload(0x1c, 0x44);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n }\n }\n\n function log(bool p0, uint256 p1) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n // Selector of `log(bool,uint256)`.\n mstore(0x00, 0x399174d3)\n mstore(0x20, p0)\n mstore(0x40, p1)\n }\n _sendLogPayload(0x1c, 0x44);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n }\n }\n\n function log(bool p0, bytes32 p1) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(bool,string)`.\n mstore(0x00, 0x8feac525)\n mstore(0x20, p0)\n mstore(0x40, 0x40)\n writeString(0x60, p1)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(uint256 p0, address p1) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n // Selector of `log(uint256,address)`.\n mstore(0x00, 0x69276c86)\n mstore(0x20, p0)\n mstore(0x40, p1)\n }\n _sendLogPayload(0x1c, 0x44);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n }\n }\n\n function log(uint256 p0, bool p1) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n // Selector of `log(uint256,bool)`.\n mstore(0x00, 0x1c9d7eb3)\n mstore(0x20, p0)\n mstore(0x40, p1)\n }\n _sendLogPayload(0x1c, 0x44);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n }\n }\n\n function log(uint256 p0, uint256 p1) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n // Selector of `log(uint256,uint256)`.\n mstore(0x00, 0xf666715a)\n mstore(0x20, p0)\n mstore(0x40, p1)\n }\n _sendLogPayload(0x1c, 0x44);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n }\n }\n\n function log(uint256 p0, bytes32 p1) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(uint256,string)`.\n mstore(0x00, 0x643fd0df)\n mstore(0x20, p0)\n mstore(0x40, 0x40)\n writeString(0x60, p1)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(bytes32 p0, address p1) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(string,address)`.\n mstore(0x00, 0x319af333)\n mstore(0x20, 0x40)\n mstore(0x40, p1)\n writeString(0x60, p0)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(bytes32 p0, bool p1) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(string,bool)`.\n mstore(0x00, 0xc3b55635)\n mstore(0x20, 0x40)\n mstore(0x40, p1)\n writeString(0x60, p0)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(bytes32 p0, uint256 p1) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(string,uint256)`.\n mstore(0x00, 0xb60e72cc)\n mstore(0x20, 0x40)\n mstore(0x40, p1)\n writeString(0x60, p0)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(bytes32 p0, bytes32 p1) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(string,string)`.\n mstore(0x00, 0x4b5c4277)\n mstore(0x20, 0x40)\n mstore(0x40, 0x80)\n writeString(0x60, p0)\n writeString(0xa0, p1)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(address p0, address p1, address p2) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n // Selector of `log(address,address,address)`.\n mstore(0x00, 0x018c84c2)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n }\n _sendLogPayload(0x1c, 0x64);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n }\n }\n\n function log(address p0, address p1, bool p2) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n // Selector of `log(address,address,bool)`.\n mstore(0x00, 0xf2a66286)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n }\n _sendLogPayload(0x1c, 0x64);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n }\n }\n\n function log(address p0, address p1, uint256 p2) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n // Selector of `log(address,address,uint256)`.\n mstore(0x00, 0x17fe6185)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n }\n _sendLogPayload(0x1c, 0x64);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n }\n }\n\n function log(address p0, address p1, bytes32 p2) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n // Selector of `log(address,address,string)`.\n mstore(0x00, 0x007150be)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, 0x60)\n writeString(0x80, p2)\n }\n _sendLogPayload(0x1c, 0xa4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n }\n }\n\n function log(address p0, bool p1, address p2) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n // Selector of `log(address,bool,address)`.\n mstore(0x00, 0xf11699ed)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n }\n _sendLogPayload(0x1c, 0x64);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n }\n }\n\n function log(address p0, bool p1, bool p2) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n // Selector of `log(address,bool,bool)`.\n mstore(0x00, 0xeb830c92)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n }\n _sendLogPayload(0x1c, 0x64);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n }\n }\n\n function log(address p0, bool p1, uint256 p2) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n // Selector of `log(address,bool,uint256)`.\n mstore(0x00, 0x9c4f99fb)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n }\n _sendLogPayload(0x1c, 0x64);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n }\n }\n\n function log(address p0, bool p1, bytes32 p2) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n // Selector of `log(address,bool,string)`.\n mstore(0x00, 0x212255cc)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, 0x60)\n writeString(0x80, p2)\n }\n _sendLogPayload(0x1c, 0xa4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n }\n }\n\n function log(address p0, uint256 p1, address p2) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n // Selector of `log(address,uint256,address)`.\n mstore(0x00, 0x7bc0d848)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n }\n _sendLogPayload(0x1c, 0x64);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n }\n }\n\n function log(address p0, uint256 p1, bool p2) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n // Selector of `log(address,uint256,bool)`.\n mstore(0x00, 0x678209a8)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n }\n _sendLogPayload(0x1c, 0x64);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n }\n }\n\n function log(address p0, uint256 p1, uint256 p2) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n // Selector of `log(address,uint256,uint256)`.\n mstore(0x00, 0xb69bcaf6)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n }\n _sendLogPayload(0x1c, 0x64);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n }\n }\n\n function log(address p0, uint256 p1, bytes32 p2) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n // Selector of `log(address,uint256,string)`.\n mstore(0x00, 0xa1f2e8aa)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, 0x60)\n writeString(0x80, p2)\n }\n _sendLogPayload(0x1c, 0xa4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n }\n }\n\n function log(address p0, bytes32 p1, address p2) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n // Selector of `log(address,string,address)`.\n mstore(0x00, 0xf08744e8)\n mstore(0x20, p0)\n mstore(0x40, 0x60)\n mstore(0x60, p2)\n writeString(0x80, p1)\n }\n _sendLogPayload(0x1c, 0xa4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n }\n }\n\n function log(address p0, bytes32 p1, bool p2) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n // Selector of `log(address,string,bool)`.\n mstore(0x00, 0xcf020fb1)\n mstore(0x20, p0)\n mstore(0x40, 0x60)\n mstore(0x60, p2)\n writeString(0x80, p1)\n }\n _sendLogPayload(0x1c, 0xa4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n }\n }\n\n function log(address p0, bytes32 p1, uint256 p2) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n // Selector of `log(address,string,uint256)`.\n mstore(0x00, 0x67dd6ff1)\n mstore(0x20, p0)\n mstore(0x40, 0x60)\n mstore(0x60, p2)\n writeString(0x80, p1)\n }\n _sendLogPayload(0x1c, 0xa4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n }\n }\n\n function log(address p0, bytes32 p1, bytes32 p2) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n // Selector of `log(address,string,string)`.\n mstore(0x00, 0xfb772265)\n mstore(0x20, p0)\n mstore(0x40, 0x60)\n mstore(0x60, 0xa0)\n writeString(0x80, p1)\n writeString(0xc0, p2)\n }\n _sendLogPayload(0x1c, 0xe4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n }\n }\n\n function log(bool p0, address p1, address p2) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n // Selector of `log(bool,address,address)`.\n mstore(0x00, 0xd2763667)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n }\n _sendLogPayload(0x1c, 0x64);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n }\n }\n\n function log(bool p0, address p1, bool p2) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n // Selector of `log(bool,address,bool)`.\n mstore(0x00, 0x18c9c746)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n }\n _sendLogPayload(0x1c, 0x64);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n }\n }\n\n function log(bool p0, address p1, uint256 p2) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n // Selector of `log(bool,address,uint256)`.\n mstore(0x00, 0x5f7b9afb)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n }\n _sendLogPayload(0x1c, 0x64);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n }\n }\n\n function log(bool p0, address p1, bytes32 p2) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n // Selector of `log(bool,address,string)`.\n mstore(0x00, 0xde9a9270)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, 0x60)\n writeString(0x80, p2)\n }\n _sendLogPayload(0x1c, 0xa4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n }\n }\n\n function log(bool p0, bool p1, address p2) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n // Selector of `log(bool,bool,address)`.\n mstore(0x00, 0x1078f68d)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n }\n _sendLogPayload(0x1c, 0x64);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n }\n }\n\n function log(bool p0, bool p1, bool p2) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n // Selector of `log(bool,bool,bool)`.\n mstore(0x00, 0x50709698)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n }\n _sendLogPayload(0x1c, 0x64);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n }\n }\n\n function log(bool p0, bool p1, uint256 p2) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n // Selector of `log(bool,bool,uint256)`.\n mstore(0x00, 0x12f21602)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n }\n _sendLogPayload(0x1c, 0x64);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n }\n }\n\n function log(bool p0, bool p1, bytes32 p2) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n // Selector of `log(bool,bool,string)`.\n mstore(0x00, 0x2555fa46)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, 0x60)\n writeString(0x80, p2)\n }\n _sendLogPayload(0x1c, 0xa4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n }\n }\n\n function log(bool p0, uint256 p1, address p2) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n // Selector of `log(bool,uint256,address)`.\n mstore(0x00, 0x088ef9d2)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n }\n _sendLogPayload(0x1c, 0x64);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n }\n }\n\n function log(bool p0, uint256 p1, bool p2) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n // Selector of `log(bool,uint256,bool)`.\n mstore(0x00, 0xe8defba9)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n }\n _sendLogPayload(0x1c, 0x64);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n }\n }\n\n function log(bool p0, uint256 p1, uint256 p2) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n // Selector of `log(bool,uint256,uint256)`.\n mstore(0x00, 0x37103367)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n }\n _sendLogPayload(0x1c, 0x64);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n }\n }\n\n function log(bool p0, uint256 p1, bytes32 p2) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n // Selector of `log(bool,uint256,string)`.\n mstore(0x00, 0xc3fc3970)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, 0x60)\n writeString(0x80, p2)\n }\n _sendLogPayload(0x1c, 0xa4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n }\n }\n\n function log(bool p0, bytes32 p1, address p2) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n // Selector of `log(bool,string,address)`.\n mstore(0x00, 0x9591b953)\n mstore(0x20, p0)\n mstore(0x40, 0x60)\n mstore(0x60, p2)\n writeString(0x80, p1)\n }\n _sendLogPayload(0x1c, 0xa4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n }\n }\n\n function log(bool p0, bytes32 p1, bool p2) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n // Selector of `log(bool,string,bool)`.\n mstore(0x00, 0xdbb4c247)\n mstore(0x20, p0)\n mstore(0x40, 0x60)\n mstore(0x60, p2)\n writeString(0x80, p1)\n }\n _sendLogPayload(0x1c, 0xa4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n }\n }\n\n function log(bool p0, bytes32 p1, uint256 p2) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n // Selector of `log(bool,string,uint256)`.\n mstore(0x00, 0x1093ee11)\n mstore(0x20, p0)\n mstore(0x40, 0x60)\n mstore(0x60, p2)\n writeString(0x80, p1)\n }\n _sendLogPayload(0x1c, 0xa4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n }\n }\n\n function log(bool p0, bytes32 p1, bytes32 p2) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n // Selector of `log(bool,string,string)`.\n mstore(0x00, 0xb076847f)\n mstore(0x20, p0)\n mstore(0x40, 0x60)\n mstore(0x60, 0xa0)\n writeString(0x80, p1)\n writeString(0xc0, p2)\n }\n _sendLogPayload(0x1c, 0xe4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n }\n }\n\n function log(uint256 p0, address p1, address p2) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n // Selector of `log(uint256,address,address)`.\n mstore(0x00, 0xbcfd9be0)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n }\n _sendLogPayload(0x1c, 0x64);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n }\n }\n\n function log(uint256 p0, address p1, bool p2) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n // Selector of `log(uint256,address,bool)`.\n mstore(0x00, 0x9b6ec042)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n }\n _sendLogPayload(0x1c, 0x64);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n }\n }\n\n function log(uint256 p0, address p1, uint256 p2) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n // Selector of `log(uint256,address,uint256)`.\n mstore(0x00, 0x5a9b5ed5)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n }\n _sendLogPayload(0x1c, 0x64);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n }\n }\n\n function log(uint256 p0, address p1, bytes32 p2) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n // Selector of `log(uint256,address,string)`.\n mstore(0x00, 0x63cb41f9)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, 0x60)\n writeString(0x80, p2)\n }\n _sendLogPayload(0x1c, 0xa4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n }\n }\n\n function log(uint256 p0, bool p1, address p2) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n // Selector of `log(uint256,bool,address)`.\n mstore(0x00, 0x35085f7b)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n }\n _sendLogPayload(0x1c, 0x64);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n }\n }\n\n function log(uint256 p0, bool p1, bool p2) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n // Selector of `log(uint256,bool,bool)`.\n mstore(0x00, 0x20718650)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n }\n _sendLogPayload(0x1c, 0x64);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n }\n }\n\n function log(uint256 p0, bool p1, uint256 p2) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n // Selector of `log(uint256,bool,uint256)`.\n mstore(0x00, 0x20098014)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n }\n _sendLogPayload(0x1c, 0x64);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n }\n }\n\n function log(uint256 p0, bool p1, bytes32 p2) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n // Selector of `log(uint256,bool,string)`.\n mstore(0x00, 0x85775021)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, 0x60)\n writeString(0x80, p2)\n }\n _sendLogPayload(0x1c, 0xa4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n }\n }\n\n function log(uint256 p0, uint256 p1, address p2) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n // Selector of `log(uint256,uint256,address)`.\n mstore(0x00, 0x5c96b331)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n }\n _sendLogPayload(0x1c, 0x64);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n }\n }\n\n function log(uint256 p0, uint256 p1, bool p2) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n // Selector of `log(uint256,uint256,bool)`.\n mstore(0x00, 0x4766da72)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n }\n _sendLogPayload(0x1c, 0x64);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n }\n }\n\n function log(uint256 p0, uint256 p1, uint256 p2) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n // Selector of `log(uint256,uint256,uint256)`.\n mstore(0x00, 0xd1ed7a3c)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n }\n _sendLogPayload(0x1c, 0x64);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n }\n }\n\n function log(uint256 p0, uint256 p1, bytes32 p2) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n // Selector of `log(uint256,uint256,string)`.\n mstore(0x00, 0x71d04af2)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, 0x60)\n writeString(0x80, p2)\n }\n _sendLogPayload(0x1c, 0xa4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n }\n }\n\n function log(uint256 p0, bytes32 p1, address p2) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n // Selector of `log(uint256,string,address)`.\n mstore(0x00, 0x7afac959)\n mstore(0x20, p0)\n mstore(0x40, 0x60)\n mstore(0x60, p2)\n writeString(0x80, p1)\n }\n _sendLogPayload(0x1c, 0xa4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n }\n }\n\n function log(uint256 p0, bytes32 p1, bool p2) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n // Selector of `log(uint256,string,bool)`.\n mstore(0x00, 0x4ceda75a)\n mstore(0x20, p0)\n mstore(0x40, 0x60)\n mstore(0x60, p2)\n writeString(0x80, p1)\n }\n _sendLogPayload(0x1c, 0xa4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n }\n }\n\n function log(uint256 p0, bytes32 p1, uint256 p2) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n // Selector of `log(uint256,string,uint256)`.\n mstore(0x00, 0x37aa7d4c)\n mstore(0x20, p0)\n mstore(0x40, 0x60)\n mstore(0x60, p2)\n writeString(0x80, p1)\n }\n _sendLogPayload(0x1c, 0xa4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n }\n }\n\n function log(uint256 p0, bytes32 p1, bytes32 p2) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n // Selector of `log(uint256,string,string)`.\n mstore(0x00, 0xb115611f)\n mstore(0x20, p0)\n mstore(0x40, 0x60)\n mstore(0x60, 0xa0)\n writeString(0x80, p1)\n writeString(0xc0, p2)\n }\n _sendLogPayload(0x1c, 0xe4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n }\n }\n\n function log(bytes32 p0, address p1, address p2) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n // Selector of `log(string,address,address)`.\n mstore(0x00, 0xfcec75e0)\n mstore(0x20, 0x60)\n mstore(0x40, p1)\n mstore(0x60, p2)\n writeString(0x80, p0)\n }\n _sendLogPayload(0x1c, 0xa4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n }\n }\n\n function log(bytes32 p0, address p1, bool p2) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n // Selector of `log(string,address,bool)`.\n mstore(0x00, 0xc91d5ed4)\n mstore(0x20, 0x60)\n mstore(0x40, p1)\n mstore(0x60, p2)\n writeString(0x80, p0)\n }\n _sendLogPayload(0x1c, 0xa4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n }\n }\n\n function log(bytes32 p0, address p1, uint256 p2) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n // Selector of `log(string,address,uint256)`.\n mstore(0x00, 0x0d26b925)\n mstore(0x20, 0x60)\n mstore(0x40, p1)\n mstore(0x60, p2)\n writeString(0x80, p0)\n }\n _sendLogPayload(0x1c, 0xa4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n }\n }\n\n function log(bytes32 p0, address p1, bytes32 p2) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n // Selector of `log(string,address,string)`.\n mstore(0x00, 0xe0e9ad4f)\n mstore(0x20, 0x60)\n mstore(0x40, p1)\n mstore(0x60, 0xa0)\n writeString(0x80, p0)\n writeString(0xc0, p2)\n }\n _sendLogPayload(0x1c, 0xe4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n }\n }\n\n function log(bytes32 p0, bool p1, address p2) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n // Selector of `log(string,bool,address)`.\n mstore(0x00, 0x932bbb38)\n mstore(0x20, 0x60)\n mstore(0x40, p1)\n mstore(0x60, p2)\n writeString(0x80, p0)\n }\n _sendLogPayload(0x1c, 0xa4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n }\n }\n\n function log(bytes32 p0, bool p1, bool p2) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n // Selector of `log(string,bool,bool)`.\n mstore(0x00, 0x850b7ad6)\n mstore(0x20, 0x60)\n mstore(0x40, p1)\n mstore(0x60, p2)\n writeString(0x80, p0)\n }\n _sendLogPayload(0x1c, 0xa4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n }\n }\n\n function log(bytes32 p0, bool p1, uint256 p2) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n // Selector of `log(string,bool,uint256)`.\n mstore(0x00, 0xc95958d6)\n mstore(0x20, 0x60)\n mstore(0x40, p1)\n mstore(0x60, p2)\n writeString(0x80, p0)\n }\n _sendLogPayload(0x1c, 0xa4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n }\n }\n\n function log(bytes32 p0, bool p1, bytes32 p2) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n // Selector of `log(string,bool,string)`.\n mstore(0x00, 0xe298f47d)\n mstore(0x20, 0x60)\n mstore(0x40, p1)\n mstore(0x60, 0xa0)\n writeString(0x80, p0)\n writeString(0xc0, p2)\n }\n _sendLogPayload(0x1c, 0xe4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n }\n }\n\n function log(bytes32 p0, uint256 p1, address p2) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n // Selector of `log(string,uint256,address)`.\n mstore(0x00, 0x1c7ec448)\n mstore(0x20, 0x60)\n mstore(0x40, p1)\n mstore(0x60, p2)\n writeString(0x80, p0)\n }\n _sendLogPayload(0x1c, 0xa4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n }\n }\n\n function log(bytes32 p0, uint256 p1, bool p2) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n // Selector of `log(string,uint256,bool)`.\n mstore(0x00, 0xca7733b1)\n mstore(0x20, 0x60)\n mstore(0x40, p1)\n mstore(0x60, p2)\n writeString(0x80, p0)\n }\n _sendLogPayload(0x1c, 0xa4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n }\n }\n\n function log(bytes32 p0, uint256 p1, uint256 p2) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n // Selector of `log(string,uint256,uint256)`.\n mstore(0x00, 0xca47c4eb)\n mstore(0x20, 0x60)\n mstore(0x40, p1)\n mstore(0x60, p2)\n writeString(0x80, p0)\n }\n _sendLogPayload(0x1c, 0xa4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n }\n }\n\n function log(bytes32 p0, uint256 p1, bytes32 p2) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n // Selector of `log(string,uint256,string)`.\n mstore(0x00, 0x5970e089)\n mstore(0x20, 0x60)\n mstore(0x40, p1)\n mstore(0x60, 0xa0)\n writeString(0x80, p0)\n writeString(0xc0, p2)\n }\n _sendLogPayload(0x1c, 0xe4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n }\n }\n\n function log(bytes32 p0, bytes32 p1, address p2) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n // Selector of `log(string,string,address)`.\n mstore(0x00, 0x95ed0195)\n mstore(0x20, 0x60)\n mstore(0x40, 0xa0)\n mstore(0x60, p2)\n writeString(0x80, p0)\n writeString(0xc0, p1)\n }\n _sendLogPayload(0x1c, 0xe4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n }\n }\n\n function log(bytes32 p0, bytes32 p1, bool p2) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n // Selector of `log(string,string,bool)`.\n mstore(0x00, 0xb0e0f9b5)\n mstore(0x20, 0x60)\n mstore(0x40, 0xa0)\n mstore(0x60, p2)\n writeString(0x80, p0)\n writeString(0xc0, p1)\n }\n _sendLogPayload(0x1c, 0xe4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n }\n }\n\n function log(bytes32 p0, bytes32 p1, uint256 p2) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n // Selector of `log(string,string,uint256)`.\n mstore(0x00, 0x5821efa1)\n mstore(0x20, 0x60)\n mstore(0x40, 0xa0)\n mstore(0x60, p2)\n writeString(0x80, p0)\n writeString(0xc0, p1)\n }\n _sendLogPayload(0x1c, 0xe4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n }\n }\n\n function log(bytes32 p0, bytes32 p1, bytes32 p2) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n bytes32 m9;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n m9 := mload(0x120)\n // Selector of `log(string,string,string)`.\n mstore(0x00, 0x2ced7cef)\n mstore(0x20, 0x60)\n mstore(0x40, 0xa0)\n mstore(0x60, 0xe0)\n writeString(0x80, p0)\n writeString(0xc0, p1)\n writeString(0x100, p2)\n }\n _sendLogPayload(0x1c, 0x124);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n mstore(0x120, m9)\n }\n }\n\n function log(address p0, address p1, address p2, address p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(address,address,address,address)`.\n mstore(0x00, 0x665bf134)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(address p0, address p1, address p2, bool p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(address,address,address,bool)`.\n mstore(0x00, 0x0e378994)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(address p0, address p1, address p2, uint256 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(address,address,address,uint256)`.\n mstore(0x00, 0x94250d77)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(address p0, address p1, address p2, bytes32 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(address,address,address,string)`.\n mstore(0x00, 0xf808da20)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, 0x80)\n writeString(0xa0, p3)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(address p0, address p1, bool p2, address p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(address,address,bool,address)`.\n mstore(0x00, 0x9f1bc36e)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(address p0, address p1, bool p2, bool p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(address,address,bool,bool)`.\n mstore(0x00, 0x2cd4134a)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(address p0, address p1, bool p2, uint256 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(address,address,bool,uint256)`.\n mstore(0x00, 0x3971e78c)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(address p0, address p1, bool p2, bytes32 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(address,address,bool,string)`.\n mstore(0x00, 0xaa6540c8)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, 0x80)\n writeString(0xa0, p3)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(address p0, address p1, uint256 p2, address p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(address,address,uint256,address)`.\n mstore(0x00, 0x8da6def5)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(address p0, address p1, uint256 p2, bool p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(address,address,uint256,bool)`.\n mstore(0x00, 0x9b4254e2)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(address p0, address p1, uint256 p2, uint256 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(address,address,uint256,uint256)`.\n mstore(0x00, 0xbe553481)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(address p0, address p1, uint256 p2, bytes32 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(address,address,uint256,string)`.\n mstore(0x00, 0xfdb4f990)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, 0x80)\n writeString(0xa0, p3)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(address p0, address p1, bytes32 p2, address p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(address,address,string,address)`.\n mstore(0x00, 0x8f736d16)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, 0x80)\n mstore(0x80, p3)\n writeString(0xa0, p2)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(address p0, address p1, bytes32 p2, bool p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(address,address,string,bool)`.\n mstore(0x00, 0x6f1a594e)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, 0x80)\n mstore(0x80, p3)\n writeString(0xa0, p2)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(address p0, address p1, bytes32 p2, uint256 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(address,address,string,uint256)`.\n mstore(0x00, 0xef1cefe7)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, 0x80)\n mstore(0x80, p3)\n writeString(0xa0, p2)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(address p0, address p1, bytes32 p2, bytes32 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n // Selector of `log(address,address,string,string)`.\n mstore(0x00, 0x21bdaf25)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, 0x80)\n mstore(0x80, 0xc0)\n writeString(0xa0, p2)\n writeString(0xe0, p3)\n }\n _sendLogPayload(0x1c, 0x104);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n }\n }\n\n function log(address p0, bool p1, address p2, address p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(address,bool,address,address)`.\n mstore(0x00, 0x660375dd)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(address p0, bool p1, address p2, bool p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(address,bool,address,bool)`.\n mstore(0x00, 0xa6f50b0f)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(address p0, bool p1, address p2, uint256 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(address,bool,address,uint256)`.\n mstore(0x00, 0xa75c59de)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(address p0, bool p1, address p2, bytes32 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(address,bool,address,string)`.\n mstore(0x00, 0x2dd778e6)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, 0x80)\n writeString(0xa0, p3)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(address p0, bool p1, bool p2, address p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(address,bool,bool,address)`.\n mstore(0x00, 0xcf394485)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(address p0, bool p1, bool p2, bool p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(address,bool,bool,bool)`.\n mstore(0x00, 0xcac43479)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(address p0, bool p1, bool p2, uint256 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(address,bool,bool,uint256)`.\n mstore(0x00, 0x8c4e5de6)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(address p0, bool p1, bool p2, bytes32 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(address,bool,bool,string)`.\n mstore(0x00, 0xdfc4a2e8)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, 0x80)\n writeString(0xa0, p3)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(address p0, bool p1, uint256 p2, address p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(address,bool,uint256,address)`.\n mstore(0x00, 0xccf790a1)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(address p0, bool p1, uint256 p2, bool p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(address,bool,uint256,bool)`.\n mstore(0x00, 0xc4643e20)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(address p0, bool p1, uint256 p2, uint256 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(address,bool,uint256,uint256)`.\n mstore(0x00, 0x386ff5f4)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(address p0, bool p1, uint256 p2, bytes32 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(address,bool,uint256,string)`.\n mstore(0x00, 0x0aa6cfad)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, 0x80)\n writeString(0xa0, p3)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(address p0, bool p1, bytes32 p2, address p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(address,bool,string,address)`.\n mstore(0x00, 0x19fd4956)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, 0x80)\n mstore(0x80, p3)\n writeString(0xa0, p2)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(address p0, bool p1, bytes32 p2, bool p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(address,bool,string,bool)`.\n mstore(0x00, 0x50ad461d)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, 0x80)\n mstore(0x80, p3)\n writeString(0xa0, p2)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(address p0, bool p1, bytes32 p2, uint256 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(address,bool,string,uint256)`.\n mstore(0x00, 0x80e6a20b)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, 0x80)\n mstore(0x80, p3)\n writeString(0xa0, p2)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(address p0, bool p1, bytes32 p2, bytes32 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n // Selector of `log(address,bool,string,string)`.\n mstore(0x00, 0x475c5c33)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, 0x80)\n mstore(0x80, 0xc0)\n writeString(0xa0, p2)\n writeString(0xe0, p3)\n }\n _sendLogPayload(0x1c, 0x104);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n }\n }\n\n function log(address p0, uint256 p1, address p2, address p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(address,uint256,address,address)`.\n mstore(0x00, 0x478d1c62)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(address p0, uint256 p1, address p2, bool p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(address,uint256,address,bool)`.\n mstore(0x00, 0xa1bcc9b3)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(address p0, uint256 p1, address p2, uint256 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(address,uint256,address,uint256)`.\n mstore(0x00, 0x100f650e)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(address p0, uint256 p1, address p2, bytes32 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(address,uint256,address,string)`.\n mstore(0x00, 0x1da986ea)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, 0x80)\n writeString(0xa0, p3)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(address p0, uint256 p1, bool p2, address p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(address,uint256,bool,address)`.\n mstore(0x00, 0xa31bfdcc)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(address p0, uint256 p1, bool p2, bool p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(address,uint256,bool,bool)`.\n mstore(0x00, 0x3bf5e537)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(address p0, uint256 p1, bool p2, uint256 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(address,uint256,bool,uint256)`.\n mstore(0x00, 0x22f6b999)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(address p0, uint256 p1, bool p2, bytes32 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(address,uint256,bool,string)`.\n mstore(0x00, 0xc5ad85f9)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, 0x80)\n writeString(0xa0, p3)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(address p0, uint256 p1, uint256 p2, address p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(address,uint256,uint256,address)`.\n mstore(0x00, 0x20e3984d)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(address p0, uint256 p1, uint256 p2, bool p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(address,uint256,uint256,bool)`.\n mstore(0x00, 0x66f1bc67)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(address p0, uint256 p1, uint256 p2, uint256 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(address,uint256,uint256,uint256)`.\n mstore(0x00, 0x34f0e636)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(address p0, uint256 p1, uint256 p2, bytes32 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(address,uint256,uint256,string)`.\n mstore(0x00, 0x4a28c017)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, 0x80)\n writeString(0xa0, p3)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(address p0, uint256 p1, bytes32 p2, address p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(address,uint256,string,address)`.\n mstore(0x00, 0x5c430d47)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, 0x80)\n mstore(0x80, p3)\n writeString(0xa0, p2)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(address p0, uint256 p1, bytes32 p2, bool p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(address,uint256,string,bool)`.\n mstore(0x00, 0xcf18105c)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, 0x80)\n mstore(0x80, p3)\n writeString(0xa0, p2)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(address p0, uint256 p1, bytes32 p2, uint256 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(address,uint256,string,uint256)`.\n mstore(0x00, 0xbf01f891)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, 0x80)\n mstore(0x80, p3)\n writeString(0xa0, p2)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(address p0, uint256 p1, bytes32 p2, bytes32 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n // Selector of `log(address,uint256,string,string)`.\n mstore(0x00, 0x88a8c406)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, 0x80)\n mstore(0x80, 0xc0)\n writeString(0xa0, p2)\n writeString(0xe0, p3)\n }\n _sendLogPayload(0x1c, 0x104);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n }\n }\n\n function log(address p0, bytes32 p1, address p2, address p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(address,string,address,address)`.\n mstore(0x00, 0x0d36fa20)\n mstore(0x20, p0)\n mstore(0x40, 0x80)\n mstore(0x60, p2)\n mstore(0x80, p3)\n writeString(0xa0, p1)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(address p0, bytes32 p1, address p2, bool p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(address,string,address,bool)`.\n mstore(0x00, 0x0df12b76)\n mstore(0x20, p0)\n mstore(0x40, 0x80)\n mstore(0x60, p2)\n mstore(0x80, p3)\n writeString(0xa0, p1)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(address p0, bytes32 p1, address p2, uint256 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(address,string,address,uint256)`.\n mstore(0x00, 0x457fe3cf)\n mstore(0x20, p0)\n mstore(0x40, 0x80)\n mstore(0x60, p2)\n mstore(0x80, p3)\n writeString(0xa0, p1)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(address p0, bytes32 p1, address p2, bytes32 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n // Selector of `log(address,string,address,string)`.\n mstore(0x00, 0xf7e36245)\n mstore(0x20, p0)\n mstore(0x40, 0x80)\n mstore(0x60, p2)\n mstore(0x80, 0xc0)\n writeString(0xa0, p1)\n writeString(0xe0, p3)\n }\n _sendLogPayload(0x1c, 0x104);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n }\n }\n\n function log(address p0, bytes32 p1, bool p2, address p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(address,string,bool,address)`.\n mstore(0x00, 0x205871c2)\n mstore(0x20, p0)\n mstore(0x40, 0x80)\n mstore(0x60, p2)\n mstore(0x80, p3)\n writeString(0xa0, p1)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(address p0, bytes32 p1, bool p2, bool p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(address,string,bool,bool)`.\n mstore(0x00, 0x5f1d5c9f)\n mstore(0x20, p0)\n mstore(0x40, 0x80)\n mstore(0x60, p2)\n mstore(0x80, p3)\n writeString(0xa0, p1)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(address p0, bytes32 p1, bool p2, uint256 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(address,string,bool,uint256)`.\n mstore(0x00, 0x515e38b6)\n mstore(0x20, p0)\n mstore(0x40, 0x80)\n mstore(0x60, p2)\n mstore(0x80, p3)\n writeString(0xa0, p1)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(address p0, bytes32 p1, bool p2, bytes32 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n // Selector of `log(address,string,bool,string)`.\n mstore(0x00, 0xbc0b61fe)\n mstore(0x20, p0)\n mstore(0x40, 0x80)\n mstore(0x60, p2)\n mstore(0x80, 0xc0)\n writeString(0xa0, p1)\n writeString(0xe0, p3)\n }\n _sendLogPayload(0x1c, 0x104);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n }\n }\n\n function log(address p0, bytes32 p1, uint256 p2, address p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(address,string,uint256,address)`.\n mstore(0x00, 0x63183678)\n mstore(0x20, p0)\n mstore(0x40, 0x80)\n mstore(0x60, p2)\n mstore(0x80, p3)\n writeString(0xa0, p1)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(address p0, bytes32 p1, uint256 p2, bool p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(address,string,uint256,bool)`.\n mstore(0x00, 0x0ef7e050)\n mstore(0x20, p0)\n mstore(0x40, 0x80)\n mstore(0x60, p2)\n mstore(0x80, p3)\n writeString(0xa0, p1)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(address p0, bytes32 p1, uint256 p2, uint256 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(address,string,uint256,uint256)`.\n mstore(0x00, 0x1dc8e1b8)\n mstore(0x20, p0)\n mstore(0x40, 0x80)\n mstore(0x60, p2)\n mstore(0x80, p3)\n writeString(0xa0, p1)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(address p0, bytes32 p1, uint256 p2, bytes32 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n // Selector of `log(address,string,uint256,string)`.\n mstore(0x00, 0x448830a8)\n mstore(0x20, p0)\n mstore(0x40, 0x80)\n mstore(0x60, p2)\n mstore(0x80, 0xc0)\n writeString(0xa0, p1)\n writeString(0xe0, p3)\n }\n _sendLogPayload(0x1c, 0x104);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n }\n }\n\n function log(address p0, bytes32 p1, bytes32 p2, address p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n // Selector of `log(address,string,string,address)`.\n mstore(0x00, 0xa04e2f87)\n mstore(0x20, p0)\n mstore(0x40, 0x80)\n mstore(0x60, 0xc0)\n mstore(0x80, p3)\n writeString(0xa0, p1)\n writeString(0xe0, p2)\n }\n _sendLogPayload(0x1c, 0x104);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n }\n }\n\n function log(address p0, bytes32 p1, bytes32 p2, bool p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n // Selector of `log(address,string,string,bool)`.\n mstore(0x00, 0x35a5071f)\n mstore(0x20, p0)\n mstore(0x40, 0x80)\n mstore(0x60, 0xc0)\n mstore(0x80, p3)\n writeString(0xa0, p1)\n writeString(0xe0, p2)\n }\n _sendLogPayload(0x1c, 0x104);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n }\n }\n\n function log(address p0, bytes32 p1, bytes32 p2, uint256 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n // Selector of `log(address,string,string,uint256)`.\n mstore(0x00, 0x159f8927)\n mstore(0x20, p0)\n mstore(0x40, 0x80)\n mstore(0x60, 0xc0)\n mstore(0x80, p3)\n writeString(0xa0, p1)\n writeString(0xe0, p2)\n }\n _sendLogPayload(0x1c, 0x104);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n }\n }\n\n function log(address p0, bytes32 p1, bytes32 p2, bytes32 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n bytes32 m9;\n bytes32 m10;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n m9 := mload(0x120)\n m10 := mload(0x140)\n // Selector of `log(address,string,string,string)`.\n mstore(0x00, 0x5d02c50b)\n mstore(0x20, p0)\n mstore(0x40, 0x80)\n mstore(0x60, 0xc0)\n mstore(0x80, 0x100)\n writeString(0xa0, p1)\n writeString(0xe0, p2)\n writeString(0x120, p3)\n }\n _sendLogPayload(0x1c, 0x144);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n mstore(0x120, m9)\n mstore(0x140, m10)\n }\n }\n\n function log(bool p0, address p1, address p2, address p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(bool,address,address,address)`.\n mstore(0x00, 0x1d14d001)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(bool p0, address p1, address p2, bool p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(bool,address,address,bool)`.\n mstore(0x00, 0x46600be0)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(bool p0, address p1, address p2, uint256 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(bool,address,address,uint256)`.\n mstore(0x00, 0x0c66d1be)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(bool p0, address p1, address p2, bytes32 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(bool,address,address,string)`.\n mstore(0x00, 0xd812a167)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, 0x80)\n writeString(0xa0, p3)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(bool p0, address p1, bool p2, address p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(bool,address,bool,address)`.\n mstore(0x00, 0x1c41a336)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(bool p0, address p1, bool p2, bool p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(bool,address,bool,bool)`.\n mstore(0x00, 0x6a9c478b)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(bool p0, address p1, bool p2, uint256 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(bool,address,bool,uint256)`.\n mstore(0x00, 0x07831502)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(bool p0, address p1, bool p2, bytes32 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(bool,address,bool,string)`.\n mstore(0x00, 0x4a66cb34)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, 0x80)\n writeString(0xa0, p3)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(bool p0, address p1, uint256 p2, address p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(bool,address,uint256,address)`.\n mstore(0x00, 0x136b05dd)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(bool p0, address p1, uint256 p2, bool p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(bool,address,uint256,bool)`.\n mstore(0x00, 0xd6019f1c)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(bool p0, address p1, uint256 p2, uint256 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(bool,address,uint256,uint256)`.\n mstore(0x00, 0x7bf181a1)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(bool p0, address p1, uint256 p2, bytes32 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(bool,address,uint256,string)`.\n mstore(0x00, 0x51f09ff8)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, 0x80)\n writeString(0xa0, p3)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(bool p0, address p1, bytes32 p2, address p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(bool,address,string,address)`.\n mstore(0x00, 0x6f7c603e)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, 0x80)\n mstore(0x80, p3)\n writeString(0xa0, p2)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(bool p0, address p1, bytes32 p2, bool p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(bool,address,string,bool)`.\n mstore(0x00, 0xe2bfd60b)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, 0x80)\n mstore(0x80, p3)\n writeString(0xa0, p2)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(bool p0, address p1, bytes32 p2, uint256 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(bool,address,string,uint256)`.\n mstore(0x00, 0xc21f64c7)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, 0x80)\n mstore(0x80, p3)\n writeString(0xa0, p2)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(bool p0, address p1, bytes32 p2, bytes32 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n // Selector of `log(bool,address,string,string)`.\n mstore(0x00, 0xa73c1db6)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, 0x80)\n mstore(0x80, 0xc0)\n writeString(0xa0, p2)\n writeString(0xe0, p3)\n }\n _sendLogPayload(0x1c, 0x104);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n }\n }\n\n function log(bool p0, bool p1, address p2, address p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(bool,bool,address,address)`.\n mstore(0x00, 0xf4880ea4)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(bool p0, bool p1, address p2, bool p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(bool,bool,address,bool)`.\n mstore(0x00, 0xc0a302d8)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(bool p0, bool p1, address p2, uint256 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(bool,bool,address,uint256)`.\n mstore(0x00, 0x4c123d57)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(bool p0, bool p1, address p2, bytes32 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(bool,bool,address,string)`.\n mstore(0x00, 0xa0a47963)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, 0x80)\n writeString(0xa0, p3)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(bool p0, bool p1, bool p2, address p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(bool,bool,bool,address)`.\n mstore(0x00, 0x8c329b1a)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(bool p0, bool p1, bool p2, bool p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(bool,bool,bool,bool)`.\n mstore(0x00, 0x3b2a5ce0)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(bool p0, bool p1, bool p2, uint256 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(bool,bool,bool,uint256)`.\n mstore(0x00, 0x6d7045c1)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(bool p0, bool p1, bool p2, bytes32 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(bool,bool,bool,string)`.\n mstore(0x00, 0x2ae408d4)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, 0x80)\n writeString(0xa0, p3)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(bool p0, bool p1, uint256 p2, address p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(bool,bool,uint256,address)`.\n mstore(0x00, 0x54a7a9a0)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(bool p0, bool p1, uint256 p2, bool p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(bool,bool,uint256,bool)`.\n mstore(0x00, 0x619e4d0e)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(bool p0, bool p1, uint256 p2, uint256 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(bool,bool,uint256,uint256)`.\n mstore(0x00, 0x0bb00eab)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(bool p0, bool p1, uint256 p2, bytes32 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(bool,bool,uint256,string)`.\n mstore(0x00, 0x7dd4d0e0)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, 0x80)\n writeString(0xa0, p3)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(bool p0, bool p1, bytes32 p2, address p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(bool,bool,string,address)`.\n mstore(0x00, 0xf9ad2b89)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, 0x80)\n mstore(0x80, p3)\n writeString(0xa0, p2)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(bool p0, bool p1, bytes32 p2, bool p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(bool,bool,string,bool)`.\n mstore(0x00, 0xb857163a)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, 0x80)\n mstore(0x80, p3)\n writeString(0xa0, p2)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(bool p0, bool p1, bytes32 p2, uint256 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(bool,bool,string,uint256)`.\n mstore(0x00, 0xe3a9ca2f)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, 0x80)\n mstore(0x80, p3)\n writeString(0xa0, p2)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(bool p0, bool p1, bytes32 p2, bytes32 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n // Selector of `log(bool,bool,string,string)`.\n mstore(0x00, 0x6d1e8751)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, 0x80)\n mstore(0x80, 0xc0)\n writeString(0xa0, p2)\n writeString(0xe0, p3)\n }\n _sendLogPayload(0x1c, 0x104);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n }\n }\n\n function log(bool p0, uint256 p1, address p2, address p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(bool,uint256,address,address)`.\n mstore(0x00, 0x26f560a8)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(bool p0, uint256 p1, address p2, bool p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(bool,uint256,address,bool)`.\n mstore(0x00, 0xb4c314ff)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(bool p0, uint256 p1, address p2, uint256 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(bool,uint256,address,uint256)`.\n mstore(0x00, 0x1537dc87)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(bool p0, uint256 p1, address p2, bytes32 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(bool,uint256,address,string)`.\n mstore(0x00, 0x1bb3b09a)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, 0x80)\n writeString(0xa0, p3)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(bool p0, uint256 p1, bool p2, address p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(bool,uint256,bool,address)`.\n mstore(0x00, 0x9acd3616)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(bool p0, uint256 p1, bool p2, bool p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(bool,uint256,bool,bool)`.\n mstore(0x00, 0xceb5f4d7)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(bool p0, uint256 p1, bool p2, uint256 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(bool,uint256,bool,uint256)`.\n mstore(0x00, 0x7f9bbca2)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(bool p0, uint256 p1, bool p2, bytes32 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(bool,uint256,bool,string)`.\n mstore(0x00, 0x9143dbb1)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, 0x80)\n writeString(0xa0, p3)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(bool p0, uint256 p1, uint256 p2, address p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(bool,uint256,uint256,address)`.\n mstore(0x00, 0x00dd87b9)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(bool p0, uint256 p1, uint256 p2, bool p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(bool,uint256,uint256,bool)`.\n mstore(0x00, 0xbe984353)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(bool p0, uint256 p1, uint256 p2, uint256 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(bool,uint256,uint256,uint256)`.\n mstore(0x00, 0x374bb4b2)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(bool p0, uint256 p1, uint256 p2, bytes32 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(bool,uint256,uint256,string)`.\n mstore(0x00, 0x8e69fb5d)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, 0x80)\n writeString(0xa0, p3)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(bool p0, uint256 p1, bytes32 p2, address p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(bool,uint256,string,address)`.\n mstore(0x00, 0xfedd1fff)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, 0x80)\n mstore(0x80, p3)\n writeString(0xa0, p2)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(bool p0, uint256 p1, bytes32 p2, bool p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(bool,uint256,string,bool)`.\n mstore(0x00, 0xe5e70b2b)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, 0x80)\n mstore(0x80, p3)\n writeString(0xa0, p2)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(bool p0, uint256 p1, bytes32 p2, uint256 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(bool,uint256,string,uint256)`.\n mstore(0x00, 0x6a1199e2)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, 0x80)\n mstore(0x80, p3)\n writeString(0xa0, p2)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(bool p0, uint256 p1, bytes32 p2, bytes32 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n // Selector of `log(bool,uint256,string,string)`.\n mstore(0x00, 0xf5bc2249)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, 0x80)\n mstore(0x80, 0xc0)\n writeString(0xa0, p2)\n writeString(0xe0, p3)\n }\n _sendLogPayload(0x1c, 0x104);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n }\n }\n\n function log(bool p0, bytes32 p1, address p2, address p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(bool,string,address,address)`.\n mstore(0x00, 0x2b2b18dc)\n mstore(0x20, p0)\n mstore(0x40, 0x80)\n mstore(0x60, p2)\n mstore(0x80, p3)\n writeString(0xa0, p1)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(bool p0, bytes32 p1, address p2, bool p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(bool,string,address,bool)`.\n mstore(0x00, 0x6dd434ca)\n mstore(0x20, p0)\n mstore(0x40, 0x80)\n mstore(0x60, p2)\n mstore(0x80, p3)\n writeString(0xa0, p1)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(bool p0, bytes32 p1, address p2, uint256 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(bool,string,address,uint256)`.\n mstore(0x00, 0xa5cada94)\n mstore(0x20, p0)\n mstore(0x40, 0x80)\n mstore(0x60, p2)\n mstore(0x80, p3)\n writeString(0xa0, p1)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(bool p0, bytes32 p1, address p2, bytes32 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n // Selector of `log(bool,string,address,string)`.\n mstore(0x00, 0x12d6c788)\n mstore(0x20, p0)\n mstore(0x40, 0x80)\n mstore(0x60, p2)\n mstore(0x80, 0xc0)\n writeString(0xa0, p1)\n writeString(0xe0, p3)\n }\n _sendLogPayload(0x1c, 0x104);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n }\n }\n\n function log(bool p0, bytes32 p1, bool p2, address p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(bool,string,bool,address)`.\n mstore(0x00, 0x538e06ab)\n mstore(0x20, p0)\n mstore(0x40, 0x80)\n mstore(0x60, p2)\n mstore(0x80, p3)\n writeString(0xa0, p1)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(bool p0, bytes32 p1, bool p2, bool p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(bool,string,bool,bool)`.\n mstore(0x00, 0xdc5e935b)\n mstore(0x20, p0)\n mstore(0x40, 0x80)\n mstore(0x60, p2)\n mstore(0x80, p3)\n writeString(0xa0, p1)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(bool p0, bytes32 p1, bool p2, uint256 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(bool,string,bool,uint256)`.\n mstore(0x00, 0x1606a393)\n mstore(0x20, p0)\n mstore(0x40, 0x80)\n mstore(0x60, p2)\n mstore(0x80, p3)\n writeString(0xa0, p1)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(bool p0, bytes32 p1, bool p2, bytes32 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n // Selector of `log(bool,string,bool,string)`.\n mstore(0x00, 0x483d0416)\n mstore(0x20, p0)\n mstore(0x40, 0x80)\n mstore(0x60, p2)\n mstore(0x80, 0xc0)\n writeString(0xa0, p1)\n writeString(0xe0, p3)\n }\n _sendLogPayload(0x1c, 0x104);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n }\n }\n\n function log(bool p0, bytes32 p1, uint256 p2, address p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(bool,string,uint256,address)`.\n mstore(0x00, 0x1596a1ce)\n mstore(0x20, p0)\n mstore(0x40, 0x80)\n mstore(0x60, p2)\n mstore(0x80, p3)\n writeString(0xa0, p1)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(bool p0, bytes32 p1, uint256 p2, bool p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(bool,string,uint256,bool)`.\n mstore(0x00, 0x6b0e5d53)\n mstore(0x20, p0)\n mstore(0x40, 0x80)\n mstore(0x60, p2)\n mstore(0x80, p3)\n writeString(0xa0, p1)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(bool p0, bytes32 p1, uint256 p2, uint256 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(bool,string,uint256,uint256)`.\n mstore(0x00, 0x28863fcb)\n mstore(0x20, p0)\n mstore(0x40, 0x80)\n mstore(0x60, p2)\n mstore(0x80, p3)\n writeString(0xa0, p1)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(bool p0, bytes32 p1, uint256 p2, bytes32 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n // Selector of `log(bool,string,uint256,string)`.\n mstore(0x00, 0x1ad96de6)\n mstore(0x20, p0)\n mstore(0x40, 0x80)\n mstore(0x60, p2)\n mstore(0x80, 0xc0)\n writeString(0xa0, p1)\n writeString(0xe0, p3)\n }\n _sendLogPayload(0x1c, 0x104);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n }\n }\n\n function log(bool p0, bytes32 p1, bytes32 p2, address p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n // Selector of `log(bool,string,string,address)`.\n mstore(0x00, 0x97d394d8)\n mstore(0x20, p0)\n mstore(0x40, 0x80)\n mstore(0x60, 0xc0)\n mstore(0x80, p3)\n writeString(0xa0, p1)\n writeString(0xe0, p2)\n }\n _sendLogPayload(0x1c, 0x104);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n }\n }\n\n function log(bool p0, bytes32 p1, bytes32 p2, bool p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n // Selector of `log(bool,string,string,bool)`.\n mstore(0x00, 0x1e4b87e5)\n mstore(0x20, p0)\n mstore(0x40, 0x80)\n mstore(0x60, 0xc0)\n mstore(0x80, p3)\n writeString(0xa0, p1)\n writeString(0xe0, p2)\n }\n _sendLogPayload(0x1c, 0x104);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n }\n }\n\n function log(bool p0, bytes32 p1, bytes32 p2, uint256 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n // Selector of `log(bool,string,string,uint256)`.\n mstore(0x00, 0x7be0c3eb)\n mstore(0x20, p0)\n mstore(0x40, 0x80)\n mstore(0x60, 0xc0)\n mstore(0x80, p3)\n writeString(0xa0, p1)\n writeString(0xe0, p2)\n }\n _sendLogPayload(0x1c, 0x104);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n }\n }\n\n function log(bool p0, bytes32 p1, bytes32 p2, bytes32 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n bytes32 m9;\n bytes32 m10;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n m9 := mload(0x120)\n m10 := mload(0x140)\n // Selector of `log(bool,string,string,string)`.\n mstore(0x00, 0x1762e32a)\n mstore(0x20, p0)\n mstore(0x40, 0x80)\n mstore(0x60, 0xc0)\n mstore(0x80, 0x100)\n writeString(0xa0, p1)\n writeString(0xe0, p2)\n writeString(0x120, p3)\n }\n _sendLogPayload(0x1c, 0x144);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n mstore(0x120, m9)\n mstore(0x140, m10)\n }\n }\n\n function log(uint256 p0, address p1, address p2, address p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(uint256,address,address,address)`.\n mstore(0x00, 0x2488b414)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(uint256 p0, address p1, address p2, bool p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(uint256,address,address,bool)`.\n mstore(0x00, 0x091ffaf5)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(uint256 p0, address p1, address p2, uint256 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(uint256,address,address,uint256)`.\n mstore(0x00, 0x736efbb6)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(uint256 p0, address p1, address p2, bytes32 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(uint256,address,address,string)`.\n mstore(0x00, 0x031c6f73)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, 0x80)\n writeString(0xa0, p3)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(uint256 p0, address p1, bool p2, address p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(uint256,address,bool,address)`.\n mstore(0x00, 0xef72c513)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(uint256 p0, address p1, bool p2, bool p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(uint256,address,bool,bool)`.\n mstore(0x00, 0xe351140f)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(uint256 p0, address p1, bool p2, uint256 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(uint256,address,bool,uint256)`.\n mstore(0x00, 0x5abd992a)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(uint256 p0, address p1, bool p2, bytes32 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(uint256,address,bool,string)`.\n mstore(0x00, 0x90fb06aa)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, 0x80)\n writeString(0xa0, p3)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(uint256 p0, address p1, uint256 p2, address p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(uint256,address,uint256,address)`.\n mstore(0x00, 0x15c127b5)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(uint256 p0, address p1, uint256 p2, bool p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(uint256,address,uint256,bool)`.\n mstore(0x00, 0x5f743a7c)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(uint256 p0, address p1, uint256 p2, uint256 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(uint256,address,uint256,uint256)`.\n mstore(0x00, 0x0c9cd9c1)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(uint256 p0, address p1, uint256 p2, bytes32 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(uint256,address,uint256,string)`.\n mstore(0x00, 0xddb06521)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, 0x80)\n writeString(0xa0, p3)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(uint256 p0, address p1, bytes32 p2, address p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(uint256,address,string,address)`.\n mstore(0x00, 0x9cba8fff)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, 0x80)\n mstore(0x80, p3)\n writeString(0xa0, p2)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(uint256 p0, address p1, bytes32 p2, bool p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(uint256,address,string,bool)`.\n mstore(0x00, 0xcc32ab07)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, 0x80)\n mstore(0x80, p3)\n writeString(0xa0, p2)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(uint256 p0, address p1, bytes32 p2, uint256 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(uint256,address,string,uint256)`.\n mstore(0x00, 0x46826b5d)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, 0x80)\n mstore(0x80, p3)\n writeString(0xa0, p2)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(uint256 p0, address p1, bytes32 p2, bytes32 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n // Selector of `log(uint256,address,string,string)`.\n mstore(0x00, 0x3e128ca3)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, 0x80)\n mstore(0x80, 0xc0)\n writeString(0xa0, p2)\n writeString(0xe0, p3)\n }\n _sendLogPayload(0x1c, 0x104);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n }\n }\n\n function log(uint256 p0, bool p1, address p2, address p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(uint256,bool,address,address)`.\n mstore(0x00, 0xa1ef4cbb)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(uint256 p0, bool p1, address p2, bool p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(uint256,bool,address,bool)`.\n mstore(0x00, 0x454d54a5)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(uint256 p0, bool p1, address p2, uint256 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(uint256,bool,address,uint256)`.\n mstore(0x00, 0x078287f5)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(uint256 p0, bool p1, address p2, bytes32 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(uint256,bool,address,string)`.\n mstore(0x00, 0xade052c7)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, 0x80)\n writeString(0xa0, p3)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(uint256 p0, bool p1, bool p2, address p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(uint256,bool,bool,address)`.\n mstore(0x00, 0x69640b59)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(uint256 p0, bool p1, bool p2, bool p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(uint256,bool,bool,bool)`.\n mstore(0x00, 0xb6f577a1)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(uint256 p0, bool p1, bool p2, uint256 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(uint256,bool,bool,uint256)`.\n mstore(0x00, 0x7464ce23)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(uint256 p0, bool p1, bool p2, bytes32 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(uint256,bool,bool,string)`.\n mstore(0x00, 0xdddb9561)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, 0x80)\n writeString(0xa0, p3)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(uint256 p0, bool p1, uint256 p2, address p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(uint256,bool,uint256,address)`.\n mstore(0x00, 0x88cb6041)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(uint256 p0, bool p1, uint256 p2, bool p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(uint256,bool,uint256,bool)`.\n mstore(0x00, 0x91a02e2a)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(uint256 p0, bool p1, uint256 p2, uint256 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(uint256,bool,uint256,uint256)`.\n mstore(0x00, 0xc6acc7a8)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(uint256 p0, bool p1, uint256 p2, bytes32 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(uint256,bool,uint256,string)`.\n mstore(0x00, 0xde03e774)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, 0x80)\n writeString(0xa0, p3)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(uint256 p0, bool p1, bytes32 p2, address p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(uint256,bool,string,address)`.\n mstore(0x00, 0xef529018)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, 0x80)\n mstore(0x80, p3)\n writeString(0xa0, p2)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(uint256 p0, bool p1, bytes32 p2, bool p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(uint256,bool,string,bool)`.\n mstore(0x00, 0xeb928d7f)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, 0x80)\n mstore(0x80, p3)\n writeString(0xa0, p2)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(uint256 p0, bool p1, bytes32 p2, uint256 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(uint256,bool,string,uint256)`.\n mstore(0x00, 0x2c1d0746)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, 0x80)\n mstore(0x80, p3)\n writeString(0xa0, p2)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(uint256 p0, bool p1, bytes32 p2, bytes32 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n // Selector of `log(uint256,bool,string,string)`.\n mstore(0x00, 0x68c8b8bd)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, 0x80)\n mstore(0x80, 0xc0)\n writeString(0xa0, p2)\n writeString(0xe0, p3)\n }\n _sendLogPayload(0x1c, 0x104);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n }\n }\n\n function log(uint256 p0, uint256 p1, address p2, address p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(uint256,uint256,address,address)`.\n mstore(0x00, 0x56a5d1b1)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(uint256 p0, uint256 p1, address p2, bool p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(uint256,uint256,address,bool)`.\n mstore(0x00, 0x15cac476)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(uint256 p0, uint256 p1, address p2, uint256 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(uint256,uint256,address,uint256)`.\n mstore(0x00, 0x88f6e4b2)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(uint256 p0, uint256 p1, address p2, bytes32 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(uint256,uint256,address,string)`.\n mstore(0x00, 0x6cde40b8)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, 0x80)\n writeString(0xa0, p3)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(uint256 p0, uint256 p1, bool p2, address p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(uint256,uint256,bool,address)`.\n mstore(0x00, 0x9a816a83)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(uint256 p0, uint256 p1, bool p2, bool p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(uint256,uint256,bool,bool)`.\n mstore(0x00, 0xab085ae6)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(uint256 p0, uint256 p1, bool p2, uint256 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(uint256,uint256,bool,uint256)`.\n mstore(0x00, 0xeb7f6fd2)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(uint256 p0, uint256 p1, bool p2, bytes32 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(uint256,uint256,bool,string)`.\n mstore(0x00, 0xa5b4fc99)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, 0x80)\n writeString(0xa0, p3)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(uint256 p0, uint256 p1, uint256 p2, address p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(uint256,uint256,uint256,address)`.\n mstore(0x00, 0xfa8185af)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(uint256 p0, uint256 p1, uint256 p2, bool p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(uint256,uint256,uint256,bool)`.\n mstore(0x00, 0xc598d185)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(uint256 p0, uint256 p1, uint256 p2, uint256 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(uint256,uint256,uint256,uint256)`.\n mstore(0x00, 0x193fb800)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(uint256 p0, uint256 p1, uint256 p2, bytes32 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(uint256,uint256,uint256,string)`.\n mstore(0x00, 0x59cfcbe3)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, 0x80)\n writeString(0xa0, p3)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(uint256 p0, uint256 p1, bytes32 p2, address p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(uint256,uint256,string,address)`.\n mstore(0x00, 0x42d21db7)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, 0x80)\n mstore(0x80, p3)\n writeString(0xa0, p2)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(uint256 p0, uint256 p1, bytes32 p2, bool p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(uint256,uint256,string,bool)`.\n mstore(0x00, 0x7af6ab25)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, 0x80)\n mstore(0x80, p3)\n writeString(0xa0, p2)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(uint256 p0, uint256 p1, bytes32 p2, uint256 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(uint256,uint256,string,uint256)`.\n mstore(0x00, 0x5da297eb)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, 0x80)\n mstore(0x80, p3)\n writeString(0xa0, p2)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(uint256 p0, uint256 p1, bytes32 p2, bytes32 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n // Selector of `log(uint256,uint256,string,string)`.\n mstore(0x00, 0x27d8afd2)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, 0x80)\n mstore(0x80, 0xc0)\n writeString(0xa0, p2)\n writeString(0xe0, p3)\n }\n _sendLogPayload(0x1c, 0x104);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n }\n }\n\n function log(uint256 p0, bytes32 p1, address p2, address p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(uint256,string,address,address)`.\n mstore(0x00, 0x6168ed61)\n mstore(0x20, p0)\n mstore(0x40, 0x80)\n mstore(0x60, p2)\n mstore(0x80, p3)\n writeString(0xa0, p1)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(uint256 p0, bytes32 p1, address p2, bool p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(uint256,string,address,bool)`.\n mstore(0x00, 0x90c30a56)\n mstore(0x20, p0)\n mstore(0x40, 0x80)\n mstore(0x60, p2)\n mstore(0x80, p3)\n writeString(0xa0, p1)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(uint256 p0, bytes32 p1, address p2, uint256 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(uint256,string,address,uint256)`.\n mstore(0x00, 0xe8d3018d)\n mstore(0x20, p0)\n mstore(0x40, 0x80)\n mstore(0x60, p2)\n mstore(0x80, p3)\n writeString(0xa0, p1)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(uint256 p0, bytes32 p1, address p2, bytes32 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n // Selector of `log(uint256,string,address,string)`.\n mstore(0x00, 0x9c3adfa1)\n mstore(0x20, p0)\n mstore(0x40, 0x80)\n mstore(0x60, p2)\n mstore(0x80, 0xc0)\n writeString(0xa0, p1)\n writeString(0xe0, p3)\n }\n _sendLogPayload(0x1c, 0x104);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n }\n }\n\n function log(uint256 p0, bytes32 p1, bool p2, address p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(uint256,string,bool,address)`.\n mstore(0x00, 0xae2ec581)\n mstore(0x20, p0)\n mstore(0x40, 0x80)\n mstore(0x60, p2)\n mstore(0x80, p3)\n writeString(0xa0, p1)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(uint256 p0, bytes32 p1, bool p2, bool p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(uint256,string,bool,bool)`.\n mstore(0x00, 0xba535d9c)\n mstore(0x20, p0)\n mstore(0x40, 0x80)\n mstore(0x60, p2)\n mstore(0x80, p3)\n writeString(0xa0, p1)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(uint256 p0, bytes32 p1, bool p2, uint256 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(uint256,string,bool,uint256)`.\n mstore(0x00, 0xcf009880)\n mstore(0x20, p0)\n mstore(0x40, 0x80)\n mstore(0x60, p2)\n mstore(0x80, p3)\n writeString(0xa0, p1)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(uint256 p0, bytes32 p1, bool p2, bytes32 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n // Selector of `log(uint256,string,bool,string)`.\n mstore(0x00, 0xd2d423cd)\n mstore(0x20, p0)\n mstore(0x40, 0x80)\n mstore(0x60, p2)\n mstore(0x80, 0xc0)\n writeString(0xa0, p1)\n writeString(0xe0, p3)\n }\n _sendLogPayload(0x1c, 0x104);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n }\n }\n\n function log(uint256 p0, bytes32 p1, uint256 p2, address p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(uint256,string,uint256,address)`.\n mstore(0x00, 0x3b2279b4)\n mstore(0x20, p0)\n mstore(0x40, 0x80)\n mstore(0x60, p2)\n mstore(0x80, p3)\n writeString(0xa0, p1)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(uint256 p0, bytes32 p1, uint256 p2, bool p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(uint256,string,uint256,bool)`.\n mstore(0x00, 0x691a8f74)\n mstore(0x20, p0)\n mstore(0x40, 0x80)\n mstore(0x60, p2)\n mstore(0x80, p3)\n writeString(0xa0, p1)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(uint256 p0, bytes32 p1, uint256 p2, uint256 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(uint256,string,uint256,uint256)`.\n mstore(0x00, 0x82c25b74)\n mstore(0x20, p0)\n mstore(0x40, 0x80)\n mstore(0x60, p2)\n mstore(0x80, p3)\n writeString(0xa0, p1)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(uint256 p0, bytes32 p1, uint256 p2, bytes32 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n // Selector of `log(uint256,string,uint256,string)`.\n mstore(0x00, 0xb7b914ca)\n mstore(0x20, p0)\n mstore(0x40, 0x80)\n mstore(0x60, p2)\n mstore(0x80, 0xc0)\n writeString(0xa0, p1)\n writeString(0xe0, p3)\n }\n _sendLogPayload(0x1c, 0x104);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n }\n }\n\n function log(uint256 p0, bytes32 p1, bytes32 p2, address p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n // Selector of `log(uint256,string,string,address)`.\n mstore(0x00, 0xd583c602)\n mstore(0x20, p0)\n mstore(0x40, 0x80)\n mstore(0x60, 0xc0)\n mstore(0x80, p3)\n writeString(0xa0, p1)\n writeString(0xe0, p2)\n }\n _sendLogPayload(0x1c, 0x104);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n }\n }\n\n function log(uint256 p0, bytes32 p1, bytes32 p2, bool p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n // Selector of `log(uint256,string,string,bool)`.\n mstore(0x00, 0xb3a6b6bd)\n mstore(0x20, p0)\n mstore(0x40, 0x80)\n mstore(0x60, 0xc0)\n mstore(0x80, p3)\n writeString(0xa0, p1)\n writeString(0xe0, p2)\n }\n _sendLogPayload(0x1c, 0x104);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n }\n }\n\n function log(uint256 p0, bytes32 p1, bytes32 p2, uint256 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n // Selector of `log(uint256,string,string,uint256)`.\n mstore(0x00, 0xb028c9bd)\n mstore(0x20, p0)\n mstore(0x40, 0x80)\n mstore(0x60, 0xc0)\n mstore(0x80, p3)\n writeString(0xa0, p1)\n writeString(0xe0, p2)\n }\n _sendLogPayload(0x1c, 0x104);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n }\n }\n\n function log(uint256 p0, bytes32 p1, bytes32 p2, bytes32 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n bytes32 m9;\n bytes32 m10;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n m9 := mload(0x120)\n m10 := mload(0x140)\n // Selector of `log(uint256,string,string,string)`.\n mstore(0x00, 0x21ad0683)\n mstore(0x20, p0)\n mstore(0x40, 0x80)\n mstore(0x60, 0xc0)\n mstore(0x80, 0x100)\n writeString(0xa0, p1)\n writeString(0xe0, p2)\n writeString(0x120, p3)\n }\n _sendLogPayload(0x1c, 0x144);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n mstore(0x120, m9)\n mstore(0x140, m10)\n }\n }\n\n function log(bytes32 p0, address p1, address p2, address p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(string,address,address,address)`.\n mstore(0x00, 0xed8f28f6)\n mstore(0x20, 0x80)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n writeString(0xa0, p0)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(bytes32 p0, address p1, address p2, bool p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(string,address,address,bool)`.\n mstore(0x00, 0xb59dbd60)\n mstore(0x20, 0x80)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n writeString(0xa0, p0)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(bytes32 p0, address p1, address p2, uint256 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(string,address,address,uint256)`.\n mstore(0x00, 0x8ef3f399)\n mstore(0x20, 0x80)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n writeString(0xa0, p0)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(bytes32 p0, address p1, address p2, bytes32 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n // Selector of `log(string,address,address,string)`.\n mstore(0x00, 0x800a1c67)\n mstore(0x20, 0x80)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, 0xc0)\n writeString(0xa0, p0)\n writeString(0xe0, p3)\n }\n _sendLogPayload(0x1c, 0x104);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n }\n }\n\n function log(bytes32 p0, address p1, bool p2, address p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(string,address,bool,address)`.\n mstore(0x00, 0x223603bd)\n mstore(0x20, 0x80)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n writeString(0xa0, p0)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(bytes32 p0, address p1, bool p2, bool p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(string,address,bool,bool)`.\n mstore(0x00, 0x79884c2b)\n mstore(0x20, 0x80)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n writeString(0xa0, p0)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(bytes32 p0, address p1, bool p2, uint256 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(string,address,bool,uint256)`.\n mstore(0x00, 0x3e9f866a)\n mstore(0x20, 0x80)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n writeString(0xa0, p0)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(bytes32 p0, address p1, bool p2, bytes32 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n // Selector of `log(string,address,bool,string)`.\n mstore(0x00, 0x0454c079)\n mstore(0x20, 0x80)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, 0xc0)\n writeString(0xa0, p0)\n writeString(0xe0, p3)\n }\n _sendLogPayload(0x1c, 0x104);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n }\n }\n\n function log(bytes32 p0, address p1, uint256 p2, address p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(string,address,uint256,address)`.\n mstore(0x00, 0x63fb8bc5)\n mstore(0x20, 0x80)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n writeString(0xa0, p0)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(bytes32 p0, address p1, uint256 p2, bool p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(string,address,uint256,bool)`.\n mstore(0x00, 0xfc4845f0)\n mstore(0x20, 0x80)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n writeString(0xa0, p0)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(bytes32 p0, address p1, uint256 p2, uint256 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(string,address,uint256,uint256)`.\n mstore(0x00, 0xf8f51b1e)\n mstore(0x20, 0x80)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n writeString(0xa0, p0)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(bytes32 p0, address p1, uint256 p2, bytes32 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n // Selector of `log(string,address,uint256,string)`.\n mstore(0x00, 0x5a477632)\n mstore(0x20, 0x80)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, 0xc0)\n writeString(0xa0, p0)\n writeString(0xe0, p3)\n }\n _sendLogPayload(0x1c, 0x104);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n }\n }\n\n function log(bytes32 p0, address p1, bytes32 p2, address p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n // Selector of `log(string,address,string,address)`.\n mstore(0x00, 0xaabc9a31)\n mstore(0x20, 0x80)\n mstore(0x40, p1)\n mstore(0x60, 0xc0)\n mstore(0x80, p3)\n writeString(0xa0, p0)\n writeString(0xe0, p2)\n }\n _sendLogPayload(0x1c, 0x104);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n }\n }\n\n function log(bytes32 p0, address p1, bytes32 p2, bool p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n // Selector of `log(string,address,string,bool)`.\n mstore(0x00, 0x5f15d28c)\n mstore(0x20, 0x80)\n mstore(0x40, p1)\n mstore(0x60, 0xc0)\n mstore(0x80, p3)\n writeString(0xa0, p0)\n writeString(0xe0, p2)\n }\n _sendLogPayload(0x1c, 0x104);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n }\n }\n\n function log(bytes32 p0, address p1, bytes32 p2, uint256 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n // Selector of `log(string,address,string,uint256)`.\n mstore(0x00, 0x91d1112e)\n mstore(0x20, 0x80)\n mstore(0x40, p1)\n mstore(0x60, 0xc0)\n mstore(0x80, p3)\n writeString(0xa0, p0)\n writeString(0xe0, p2)\n }\n _sendLogPayload(0x1c, 0x104);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n }\n }\n\n function log(bytes32 p0, address p1, bytes32 p2, bytes32 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n bytes32 m9;\n bytes32 m10;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n m9 := mload(0x120)\n m10 := mload(0x140)\n // Selector of `log(string,address,string,string)`.\n mstore(0x00, 0x245986f2)\n mstore(0x20, 0x80)\n mstore(0x40, p1)\n mstore(0x60, 0xc0)\n mstore(0x80, 0x100)\n writeString(0xa0, p0)\n writeString(0xe0, p2)\n writeString(0x120, p3)\n }\n _sendLogPayload(0x1c, 0x144);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n mstore(0x120, m9)\n mstore(0x140, m10)\n }\n }\n\n function log(bytes32 p0, bool p1, address p2, address p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(string,bool,address,address)`.\n mstore(0x00, 0x33e9dd1d)\n mstore(0x20, 0x80)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n writeString(0xa0, p0)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(bytes32 p0, bool p1, address p2, bool p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(string,bool,address,bool)`.\n mstore(0x00, 0x958c28c6)\n mstore(0x20, 0x80)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n writeString(0xa0, p0)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(bytes32 p0, bool p1, address p2, uint256 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(string,bool,address,uint256)`.\n mstore(0x00, 0x5d08bb05)\n mstore(0x20, 0x80)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n writeString(0xa0, p0)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(bytes32 p0, bool p1, address p2, bytes32 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n // Selector of `log(string,bool,address,string)`.\n mstore(0x00, 0x2d8e33a4)\n mstore(0x20, 0x80)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, 0xc0)\n writeString(0xa0, p0)\n writeString(0xe0, p3)\n }\n _sendLogPayload(0x1c, 0x104);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n }\n }\n\n function log(bytes32 p0, bool p1, bool p2, address p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(string,bool,bool,address)`.\n mstore(0x00, 0x7190a529)\n mstore(0x20, 0x80)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n writeString(0xa0, p0)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(bytes32 p0, bool p1, bool p2, bool p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(string,bool,bool,bool)`.\n mstore(0x00, 0x895af8c5)\n mstore(0x20, 0x80)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n writeString(0xa0, p0)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(bytes32 p0, bool p1, bool p2, uint256 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(string,bool,bool,uint256)`.\n mstore(0x00, 0x8e3f78a9)\n mstore(0x20, 0x80)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n writeString(0xa0, p0)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(bytes32 p0, bool p1, bool p2, bytes32 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n // Selector of `log(string,bool,bool,string)`.\n mstore(0x00, 0x9d22d5dd)\n mstore(0x20, 0x80)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, 0xc0)\n writeString(0xa0, p0)\n writeString(0xe0, p3)\n }\n _sendLogPayload(0x1c, 0x104);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n }\n }\n\n function log(bytes32 p0, bool p1, uint256 p2, address p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(string,bool,uint256,address)`.\n mstore(0x00, 0x935e09bf)\n mstore(0x20, 0x80)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n writeString(0xa0, p0)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(bytes32 p0, bool p1, uint256 p2, bool p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(string,bool,uint256,bool)`.\n mstore(0x00, 0x8af7cf8a)\n mstore(0x20, 0x80)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n writeString(0xa0, p0)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(bytes32 p0, bool p1, uint256 p2, uint256 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(string,bool,uint256,uint256)`.\n mstore(0x00, 0x64b5bb67)\n mstore(0x20, 0x80)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n writeString(0xa0, p0)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(bytes32 p0, bool p1, uint256 p2, bytes32 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n // Selector of `log(string,bool,uint256,string)`.\n mstore(0x00, 0x742d6ee7)\n mstore(0x20, 0x80)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, 0xc0)\n writeString(0xa0, p0)\n writeString(0xe0, p3)\n }\n _sendLogPayload(0x1c, 0x104);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n }\n }\n\n function log(bytes32 p0, bool p1, bytes32 p2, address p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n // Selector of `log(string,bool,string,address)`.\n mstore(0x00, 0xe0625b29)\n mstore(0x20, 0x80)\n mstore(0x40, p1)\n mstore(0x60, 0xc0)\n mstore(0x80, p3)\n writeString(0xa0, p0)\n writeString(0xe0, p2)\n }\n _sendLogPayload(0x1c, 0x104);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n }\n }\n\n function log(bytes32 p0, bool p1, bytes32 p2, bool p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n // Selector of `log(string,bool,string,bool)`.\n mstore(0x00, 0x3f8a701d)\n mstore(0x20, 0x80)\n mstore(0x40, p1)\n mstore(0x60, 0xc0)\n mstore(0x80, p3)\n writeString(0xa0, p0)\n writeString(0xe0, p2)\n }\n _sendLogPayload(0x1c, 0x104);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n }\n }\n\n function log(bytes32 p0, bool p1, bytes32 p2, uint256 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n // Selector of `log(string,bool,string,uint256)`.\n mstore(0x00, 0x24f91465)\n mstore(0x20, 0x80)\n mstore(0x40, p1)\n mstore(0x60, 0xc0)\n mstore(0x80, p3)\n writeString(0xa0, p0)\n writeString(0xe0, p2)\n }\n _sendLogPayload(0x1c, 0x104);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n }\n }\n\n function log(bytes32 p0, bool p1, bytes32 p2, bytes32 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n bytes32 m9;\n bytes32 m10;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n m9 := mload(0x120)\n m10 := mload(0x140)\n // Selector of `log(string,bool,string,string)`.\n mstore(0x00, 0xa826caeb)\n mstore(0x20, 0x80)\n mstore(0x40, p1)\n mstore(0x60, 0xc0)\n mstore(0x80, 0x100)\n writeString(0xa0, p0)\n writeString(0xe0, p2)\n writeString(0x120, p3)\n }\n _sendLogPayload(0x1c, 0x144);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n mstore(0x120, m9)\n mstore(0x140, m10)\n }\n }\n\n function log(bytes32 p0, uint256 p1, address p2, address p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(string,uint256,address,address)`.\n mstore(0x00, 0x5ea2b7ae)\n mstore(0x20, 0x80)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n writeString(0xa0, p0)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(bytes32 p0, uint256 p1, address p2, bool p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(string,uint256,address,bool)`.\n mstore(0x00, 0x82112a42)\n mstore(0x20, 0x80)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n writeString(0xa0, p0)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(bytes32 p0, uint256 p1, address p2, uint256 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(string,uint256,address,uint256)`.\n mstore(0x00, 0x4f04fdc6)\n mstore(0x20, 0x80)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n writeString(0xa0, p0)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(bytes32 p0, uint256 p1, address p2, bytes32 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n // Selector of `log(string,uint256,address,string)`.\n mstore(0x00, 0x9ffb2f93)\n mstore(0x20, 0x80)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, 0xc0)\n writeString(0xa0, p0)\n writeString(0xe0, p3)\n }\n _sendLogPayload(0x1c, 0x104);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n }\n }\n\n function log(bytes32 p0, uint256 p1, bool p2, address p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(string,uint256,bool,address)`.\n mstore(0x00, 0xe0e95b98)\n mstore(0x20, 0x80)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n writeString(0xa0, p0)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(bytes32 p0, uint256 p1, bool p2, bool p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(string,uint256,bool,bool)`.\n mstore(0x00, 0x354c36d6)\n mstore(0x20, 0x80)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n writeString(0xa0, p0)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(bytes32 p0, uint256 p1, bool p2, uint256 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(string,uint256,bool,uint256)`.\n mstore(0x00, 0xe41b6f6f)\n mstore(0x20, 0x80)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n writeString(0xa0, p0)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(bytes32 p0, uint256 p1, bool p2, bytes32 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n // Selector of `log(string,uint256,bool,string)`.\n mstore(0x00, 0xabf73a98)\n mstore(0x20, 0x80)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, 0xc0)\n writeString(0xa0, p0)\n writeString(0xe0, p3)\n }\n _sendLogPayload(0x1c, 0x104);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n }\n }\n\n function log(bytes32 p0, uint256 p1, uint256 p2, address p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(string,uint256,uint256,address)`.\n mstore(0x00, 0xe21de278)\n mstore(0x20, 0x80)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n writeString(0xa0, p0)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(bytes32 p0, uint256 p1, uint256 p2, bool p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(string,uint256,uint256,bool)`.\n mstore(0x00, 0x7626db92)\n mstore(0x20, 0x80)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n writeString(0xa0, p0)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(bytes32 p0, uint256 p1, uint256 p2, uint256 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(string,uint256,uint256,uint256)`.\n mstore(0x00, 0xa7a87853)\n mstore(0x20, 0x80)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n writeString(0xa0, p0)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(bytes32 p0, uint256 p1, uint256 p2, bytes32 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n // Selector of `log(string,uint256,uint256,string)`.\n mstore(0x00, 0x854b3496)\n mstore(0x20, 0x80)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, 0xc0)\n writeString(0xa0, p0)\n writeString(0xe0, p3)\n }\n _sendLogPayload(0x1c, 0x104);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n }\n }\n\n function log(bytes32 p0, uint256 p1, bytes32 p2, address p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n // Selector of `log(string,uint256,string,address)`.\n mstore(0x00, 0x7c4632a4)\n mstore(0x20, 0x80)\n mstore(0x40, p1)\n mstore(0x60, 0xc0)\n mstore(0x80, p3)\n writeString(0xa0, p0)\n writeString(0xe0, p2)\n }\n _sendLogPayload(0x1c, 0x104);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n }\n }\n\n function log(bytes32 p0, uint256 p1, bytes32 p2, bool p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n // Selector of `log(string,uint256,string,bool)`.\n mstore(0x00, 0x7d24491d)\n mstore(0x20, 0x80)\n mstore(0x40, p1)\n mstore(0x60, 0xc0)\n mstore(0x80, p3)\n writeString(0xa0, p0)\n writeString(0xe0, p2)\n }\n _sendLogPayload(0x1c, 0x104);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n }\n }\n\n function log(bytes32 p0, uint256 p1, bytes32 p2, uint256 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n // Selector of `log(string,uint256,string,uint256)`.\n mstore(0x00, 0xc67ea9d1)\n mstore(0x20, 0x80)\n mstore(0x40, p1)\n mstore(0x60, 0xc0)\n mstore(0x80, p3)\n writeString(0xa0, p0)\n writeString(0xe0, p2)\n }\n _sendLogPayload(0x1c, 0x104);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n }\n }\n\n function log(bytes32 p0, uint256 p1, bytes32 p2, bytes32 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n bytes32 m9;\n bytes32 m10;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n m9 := mload(0x120)\n m10 := mload(0x140)\n // Selector of `log(string,uint256,string,string)`.\n mstore(0x00, 0x5ab84e1f)\n mstore(0x20, 0x80)\n mstore(0x40, p1)\n mstore(0x60, 0xc0)\n mstore(0x80, 0x100)\n writeString(0xa0, p0)\n writeString(0xe0, p2)\n writeString(0x120, p3)\n }\n _sendLogPayload(0x1c, 0x144);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n mstore(0x120, m9)\n mstore(0x140, m10)\n }\n }\n\n function log(bytes32 p0, bytes32 p1, address p2, address p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n // Selector of `log(string,string,address,address)`.\n mstore(0x00, 0x439c7bef)\n mstore(0x20, 0x80)\n mstore(0x40, 0xc0)\n mstore(0x60, p2)\n mstore(0x80, p3)\n writeString(0xa0, p0)\n writeString(0xe0, p1)\n }\n _sendLogPayload(0x1c, 0x104);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n }\n }\n\n function log(bytes32 p0, bytes32 p1, address p2, bool p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n // Selector of `log(string,string,address,bool)`.\n mstore(0x00, 0x5ccd4e37)\n mstore(0x20, 0x80)\n mstore(0x40, 0xc0)\n mstore(0x60, p2)\n mstore(0x80, p3)\n writeString(0xa0, p0)\n writeString(0xe0, p1)\n }\n _sendLogPayload(0x1c, 0x104);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n }\n }\n\n function log(bytes32 p0, bytes32 p1, address p2, uint256 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n // Selector of `log(string,string,address,uint256)`.\n mstore(0x00, 0x7cc3c607)\n mstore(0x20, 0x80)\n mstore(0x40, 0xc0)\n mstore(0x60, p2)\n mstore(0x80, p3)\n writeString(0xa0, p0)\n writeString(0xe0, p1)\n }\n _sendLogPayload(0x1c, 0x104);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n }\n }\n\n function log(bytes32 p0, bytes32 p1, address p2, bytes32 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n bytes32 m9;\n bytes32 m10;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n m9 := mload(0x120)\n m10 := mload(0x140)\n // Selector of `log(string,string,address,string)`.\n mstore(0x00, 0xeb1bff80)\n mstore(0x20, 0x80)\n mstore(0x40, 0xc0)\n mstore(0x60, p2)\n mstore(0x80, 0x100)\n writeString(0xa0, p0)\n writeString(0xe0, p1)\n writeString(0x120, p3)\n }\n _sendLogPayload(0x1c, 0x144);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n mstore(0x120, m9)\n mstore(0x140, m10)\n }\n }\n\n function log(bytes32 p0, bytes32 p1, bool p2, address p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n // Selector of `log(string,string,bool,address)`.\n mstore(0x00, 0xc371c7db)\n mstore(0x20, 0x80)\n mstore(0x40, 0xc0)\n mstore(0x60, p2)\n mstore(0x80, p3)\n writeString(0xa0, p0)\n writeString(0xe0, p1)\n }\n _sendLogPayload(0x1c, 0x104);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n }\n }\n\n function log(bytes32 p0, bytes32 p1, bool p2, bool p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n // Selector of `log(string,string,bool,bool)`.\n mstore(0x00, 0x40785869)\n mstore(0x20, 0x80)\n mstore(0x40, 0xc0)\n mstore(0x60, p2)\n mstore(0x80, p3)\n writeString(0xa0, p0)\n writeString(0xe0, p1)\n }\n _sendLogPayload(0x1c, 0x104);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n }\n }\n\n function log(bytes32 p0, bytes32 p1, bool p2, uint256 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n // Selector of `log(string,string,bool,uint256)`.\n mstore(0x00, 0xd6aefad2)\n mstore(0x20, 0x80)\n mstore(0x40, 0xc0)\n mstore(0x60, p2)\n mstore(0x80, p3)\n writeString(0xa0, p0)\n writeString(0xe0, p1)\n }\n _sendLogPayload(0x1c, 0x104);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n }\n }\n\n function log(bytes32 p0, bytes32 p1, bool p2, bytes32 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n bytes32 m9;\n bytes32 m10;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n m9 := mload(0x120)\n m10 := mload(0x140)\n // Selector of `log(string,string,bool,string)`.\n mstore(0x00, 0x5e84b0ea)\n mstore(0x20, 0x80)\n mstore(0x40, 0xc0)\n mstore(0x60, p2)\n mstore(0x80, 0x100)\n writeString(0xa0, p0)\n writeString(0xe0, p1)\n writeString(0x120, p3)\n }\n _sendLogPayload(0x1c, 0x144);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n mstore(0x120, m9)\n mstore(0x140, m10)\n }\n }\n\n function log(bytes32 p0, bytes32 p1, uint256 p2, address p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n // Selector of `log(string,string,uint256,address)`.\n mstore(0x00, 0x1023f7b2)\n mstore(0x20, 0x80)\n mstore(0x40, 0xc0)\n mstore(0x60, p2)\n mstore(0x80, p3)\n writeString(0xa0, p0)\n writeString(0xe0, p1)\n }\n _sendLogPayload(0x1c, 0x104);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n }\n }\n\n function log(bytes32 p0, bytes32 p1, uint256 p2, bool p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n // Selector of `log(string,string,uint256,bool)`.\n mstore(0x00, 0xc3a8a654)\n mstore(0x20, 0x80)\n mstore(0x40, 0xc0)\n mstore(0x60, p2)\n mstore(0x80, p3)\n writeString(0xa0, p0)\n writeString(0xe0, p1)\n }\n _sendLogPayload(0x1c, 0x104);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n }\n }\n\n function log(bytes32 p0, bytes32 p1, uint256 p2, uint256 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n // Selector of `log(string,string,uint256,uint256)`.\n mstore(0x00, 0xf45d7d2c)\n mstore(0x20, 0x80)\n mstore(0x40, 0xc0)\n mstore(0x60, p2)\n mstore(0x80, p3)\n writeString(0xa0, p0)\n writeString(0xe0, p1)\n }\n _sendLogPayload(0x1c, 0x104);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n }\n }\n\n function log(bytes32 p0, bytes32 p1, uint256 p2, bytes32 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n bytes32 m9;\n bytes32 m10;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n m9 := mload(0x120)\n m10 := mload(0x140)\n // Selector of `log(string,string,uint256,string)`.\n mstore(0x00, 0x5d1a971a)\n mstore(0x20, 0x80)\n mstore(0x40, 0xc0)\n mstore(0x60, p2)\n mstore(0x80, 0x100)\n writeString(0xa0, p0)\n writeString(0xe0, p1)\n writeString(0x120, p3)\n }\n _sendLogPayload(0x1c, 0x144);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n mstore(0x120, m9)\n mstore(0x140, m10)\n }\n }\n\n function log(bytes32 p0, bytes32 p1, bytes32 p2, address p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n bytes32 m9;\n bytes32 m10;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n m9 := mload(0x120)\n m10 := mload(0x140)\n // Selector of `log(string,string,string,address)`.\n mstore(0x00, 0x6d572f44)\n mstore(0x20, 0x80)\n mstore(0x40, 0xc0)\n mstore(0x60, 0x100)\n mstore(0x80, p3)\n writeString(0xa0, p0)\n writeString(0xe0, p1)\n writeString(0x120, p2)\n }\n _sendLogPayload(0x1c, 0x144);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n mstore(0x120, m9)\n mstore(0x140, m10)\n }\n }\n\n function log(bytes32 p0, bytes32 p1, bytes32 p2, bool p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n bytes32 m9;\n bytes32 m10;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n m9 := mload(0x120)\n m10 := mload(0x140)\n // Selector of `log(string,string,string,bool)`.\n mstore(0x00, 0x2c1754ed)\n mstore(0x20, 0x80)\n mstore(0x40, 0xc0)\n mstore(0x60, 0x100)\n mstore(0x80, p3)\n writeString(0xa0, p0)\n writeString(0xe0, p1)\n writeString(0x120, p2)\n }\n _sendLogPayload(0x1c, 0x144);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n mstore(0x120, m9)\n mstore(0x140, m10)\n }\n }\n\n function log(bytes32 p0, bytes32 p1, bytes32 p2, uint256 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n bytes32 m9;\n bytes32 m10;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n m9 := mload(0x120)\n m10 := mload(0x140)\n // Selector of `log(string,string,string,uint256)`.\n mstore(0x00, 0x8eafb02b)\n mstore(0x20, 0x80)\n mstore(0x40, 0xc0)\n mstore(0x60, 0x100)\n mstore(0x80, p3)\n writeString(0xa0, p0)\n writeString(0xe0, p1)\n writeString(0x120, p2)\n }\n _sendLogPayload(0x1c, 0x144);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n mstore(0x120, m9)\n mstore(0x140, m10)\n }\n }\n\n function log(bytes32 p0, bytes32 p1, bytes32 p2, bytes32 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n bytes32 m9;\n bytes32 m10;\n bytes32 m11;\n bytes32 m12;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n m9 := mload(0x120)\n m10 := mload(0x140)\n m11 := mload(0x160)\n m12 := mload(0x180)\n // Selector of `log(string,string,string,string)`.\n mstore(0x00, 0xde68f20a)\n mstore(0x20, 0x80)\n mstore(0x40, 0xc0)\n mstore(0x60, 0x100)\n mstore(0x80, 0x140)\n writeString(0xa0, p0)\n writeString(0xe0, p1)\n writeString(0x120, p2)\n writeString(0x160, p3)\n }\n _sendLogPayload(0x1c, 0x184);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n mstore(0x120, m9)\n mstore(0x140, m10)\n mstore(0x160, m11)\n mstore(0x180, m12)\n }\n }\n}\n","license":"MIT"},"scripts/FetchChainInfo.s.sol":{"keccak256":"0x202fb27a5a78b7d8c96c3a4ea69981dc4eeda765aa2747699ac80b8499feb709","urls":[],"content":"// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\nimport { Script } from \"forge-std/Script.sol\";\nimport { GameTypes, GameType } from \"src/dispute/lib/Types.sol\";\n\n/// @notice Contains getters for arbitrary methods from all L1 contracts, including legacy getters\n/// that have since been deprecated.\ninterface IFetcher {\n function guardian() external view returns (address);\n function GUARDIAN() external view returns (address);\n function systemConfig() external view returns (address);\n function SYSTEM_CONFIG() external view returns (address);\n function disputeGameFactory() external view returns (address);\n function ethLockbox() external view returns (address);\n function superchainConfig() external view returns (address);\n function messenger() external view returns (address);\n function addressManager() external view returns (address);\n function PORTAL() external view returns (address);\n function portal() external view returns (address);\n function l1ERC721Bridge() external view returns (address);\n function optimismMintableERC20Factory() external view returns (address);\n function gameImpls(GameType _gameType) external view returns (address);\n function respectedGameType() external view returns (GameType);\n function anchorStateRegistry() external view returns (address);\n function L2_ORACLE() external view returns (address);\n function l2Oracle() external view returns (address);\n function vm() external view returns (address);\n function oracle() external view returns (address);\n function challenger() external view returns (address);\n function proposer() external view returns (address);\n function PROPOSER() external view returns (address);\n function batcherHash() external view returns (bytes32);\n function admin() external view returns (address);\n function owner() external view returns (address);\n function unsafeBlockSigner() external view returns (address);\n function weth() external view returns (address);\n}\n\ncontract FetchChainInfoInput {\n address internal _systemConfigProxy;\n address internal _l1StandardBridgeProxy;\n\n function set(bytes4 _sel, address _addr) public {\n require(_addr != address(0), \"FetchChainInfoInput: cannot set zero address\");\n if (_sel == this.systemConfigProxy.selector) _systemConfigProxy = _addr;\n else if (_sel == this.l1StandardBridgeProxy.selector) _l1StandardBridgeProxy = _addr;\n else revert(\"FetchChainInfoInput: unknown selector\");\n }\n\n function systemConfigProxy() public view returns (address) {\n require(_systemConfigProxy != address(0), \"FetchChainInfoInput: systemConfigProxy not set\");\n return _systemConfigProxy;\n }\n\n function l1StandardBridgeProxy() public view returns (address) {\n require(_l1StandardBridgeProxy != address(0), \"FetchChainInfoInput: l1StandardBridgeProxy not set\");\n return _l1StandardBridgeProxy;\n }\n}\n\ncontract FetchChainInfoOutput {\n // contract addresses\n // - SuperchainContracts\n address internal _superchainConfigProxy;\n // - ImplementationsContracts\n address internal _mipsImpl;\n address internal _preimageOracleImpl;\n // - OpChainContracts\n address internal _addressManagerImpl;\n address internal _ethLockboxProxy;\n address internal _l1CrossDomainMessengerProxy;\n address internal _l1Erc721BridgeProxy;\n address internal _l1StandardBridgeProxy;\n address internal _l2OutputOracleProxy;\n address internal _optimismMintableErc20FactoryProxy;\n address internal _optimismPortalProxy;\n address internal _systemConfigProxy;\n address internal _opChainProxyAdminImpl;\n address internal _anchorStateRegistryProxy;\n address internal _delayedWethPermissionedGameProxy;\n address internal _delayedWethPermissionlessGameProxy;\n address internal _disputeGameFactoryProxy;\n address internal _faultDisputeGameImpl;\n address internal _permissionedDisputeGameImpl;\n\n // roles\n address internal _systemConfigOwner;\n address internal _opChainProxyAdminOwner;\n address internal _opChainGuardian;\n address internal _challenger;\n address internal _proposer;\n address internal _unsafeBlockSigner;\n address internal _batchSubmitter;\n\n // fault proof status\n bool internal _permissioned;\n bool internal _permissionless;\n GameType internal _respectedGameType;\n\n function set(bytes4 _sel, address _addr) public {\n // SuperchainContracts\n if (_sel == this.superchainConfigProxy.selector) _superchainConfigProxy = _addr;\n // - ImplementationsContracts\n else if (_sel == this.mipsImpl.selector) _mipsImpl = _addr;\n else if (_sel == this.preimageOracleImpl.selector) _preimageOracleImpl = _addr;\n // - OpChainContracts\n else if (_sel == this.addressManagerImpl.selector) _addressManagerImpl = _addr;\n else if (_sel == this.ethLockboxProxy.selector) _ethLockboxProxy = _addr;\n else if (_sel == this.l1CrossDomainMessengerProxy.selector) _l1CrossDomainMessengerProxy = _addr;\n else if (_sel == this.l1Erc721BridgeProxy.selector) _l1Erc721BridgeProxy = _addr;\n else if (_sel == this.l1StandardBridgeProxy.selector) _l1StandardBridgeProxy = _addr;\n else if (_sel == this.l2OutputOracleProxy.selector) _l2OutputOracleProxy = _addr;\n else if (_sel == this.optimismMintableErc20FactoryProxy.selector) _optimismMintableErc20FactoryProxy = _addr;\n else if (_sel == this.optimismPortalProxy.selector) _optimismPortalProxy = _addr;\n else if (_sel == this.systemConfigProxy.selector) _systemConfigProxy = _addr;\n else if (_sel == this.opChainProxyAdminImpl.selector) _opChainProxyAdminImpl = _addr;\n else if (_sel == this.anchorStateRegistryProxy.selector) _anchorStateRegistryProxy = _addr;\n else if (_sel == this.delayedWethPermissionedGameProxy.selector) _delayedWethPermissionedGameProxy = _addr;\n else if (_sel == this.delayedWethPermissionlessGameProxy.selector) _delayedWethPermissionlessGameProxy = _addr;\n else if (_sel == this.disputeGameFactoryProxy.selector) _disputeGameFactoryProxy = _addr;\n else if (_sel == this.faultDisputeGameImpl.selector) _faultDisputeGameImpl = _addr;\n else if (_sel == this.permissionedDisputeGameImpl.selector) _permissionedDisputeGameImpl = _addr;\n // roles\n else if (_sel == this.systemConfigOwner.selector) _systemConfigOwner = _addr;\n else if (_sel == this.opChainProxyAdminOwner.selector) _opChainProxyAdminOwner = _addr;\n else if (_sel == this.opChainGuardian.selector) _opChainGuardian = _addr;\n else if (_sel == this.challenger.selector) _challenger = _addr;\n else if (_sel == this.proposer.selector) _proposer = _addr;\n else if (_sel == this.unsafeBlockSigner.selector) _unsafeBlockSigner = _addr;\n else if (_sel == this.batchSubmitter.selector) _batchSubmitter = _addr;\n else revert(\"FetchChainInfoOutput: unknown address selector test\");\n }\n\n function set(bytes4 _sel, bool _bool) public {\n if (_sel == this.permissioned.selector) _permissioned = _bool;\n else if (_sel == this.permissionless.selector) _permissionless = _bool;\n else revert(\"FetchChainInfoOutput: unknown bool selector\");\n }\n\n function set(bytes4 _sel, GameType _gameType) public {\n if (_sel == this.respectedGameType.selector) _respectedGameType = _gameType;\n else revert(\"FetchChainInfoOutput: unknown GameType selector\");\n }\n\n function addressManagerImpl() public view returns (address) {\n require(_addressManagerImpl != address(0), \"FetchChainInfoOutput: addressManagerImpl not set\");\n return _addressManagerImpl;\n }\n\n function ethLockboxProxy() public view returns (address) {\n return _ethLockboxProxy;\n }\n\n function l1CrossDomainMessengerProxy() public view returns (address) {\n require(_l1CrossDomainMessengerProxy != address(0), \"FetchChainInfoOutput: l1CrossDomainMessengerProxy not set\");\n return _l1CrossDomainMessengerProxy;\n }\n\n function l1Erc721BridgeProxy() public view returns (address) {\n require(_l1Erc721BridgeProxy != address(0), \"FetchChainInfoOutput: l1Erc721BridgeProxy not set\");\n return _l1Erc721BridgeProxy;\n }\n\n function l1StandardBridgeProxy() public view returns (address) {\n require(_l1StandardBridgeProxy != address(0), \"FetchChainInfoOutput: l1StandardBridgeProxy not set\");\n return _l1StandardBridgeProxy;\n }\n\n function l2OutputOracleProxy() public view returns (address) {\n require(_l2OutputOracleProxy != address(0), \"FetchChainInfoOutput: l2OutputOracleProxy not set\");\n return _l2OutputOracleProxy;\n }\n\n function optimismMintableErc20FactoryProxy() public view returns (address) {\n require(\n _optimismMintableErc20FactoryProxy != address(0),\n \"FetchChainInfoOutput: optimismMintableErc20FactoryProxy not set\"\n );\n return _optimismMintableErc20FactoryProxy;\n }\n\n function optimismPortalProxy() public view returns (address) {\n require(_optimismPortalProxy != address(0), \"FetchChainInfoOutput: optimismPortalProxy not set\");\n return _optimismPortalProxy;\n }\n\n function systemConfigProxy() public view returns (address) {\n require(_systemConfigProxy != address(0), \"FetchChainInfoOutput: systemConfigProxy not set\");\n return _systemConfigProxy;\n }\n\n function opChainProxyAdminImpl() public view returns (address) {\n require(_opChainProxyAdminImpl != address(0), \"FetchChainInfoOutput: opChainProxyAdminImpl not set\");\n return _opChainProxyAdminImpl;\n }\n\n function superchainConfigProxy() public view returns (address) {\n require(_superchainConfigProxy != address(0), \"FetchChainInfoOutput: superchainConfigProxy not set\");\n return _superchainConfigProxy;\n }\n\n function anchorStateRegistryProxy() public view returns (address) {\n require(_anchorStateRegistryProxy != address(0), \"FetchChainInfoOutput: anchorStateRegistryProxy not set\");\n return _anchorStateRegistryProxy;\n }\n\n function delayedWethPermissionedGameProxy() public view returns (address) {\n return _delayedWethPermissionedGameProxy;\n }\n\n function delayedWethPermissionlessGameProxy() public view returns (address) {\n return _delayedWethPermissionlessGameProxy;\n }\n\n function disputeGameFactoryProxy() public view returns (address) {\n return _disputeGameFactoryProxy;\n }\n\n function faultDisputeGameImpl() public view returns (address) {\n require(_faultDisputeGameImpl != address(0), \"FetchChainInfoOutput: faultDisputeGameImpl not set\");\n return _faultDisputeGameImpl;\n }\n\n function mipsImpl() public view returns (address) {\n require(_mipsImpl != address(0), \"FetchChainInfoOutput: mipsImpl not set\");\n return _mipsImpl;\n }\n\n function permissionedDisputeGameImpl() public view returns (address) {\n require(_permissionedDisputeGameImpl != address(0), \"FetchChainInfoOutput: permissionedDisputeGameImpl not set\");\n return _permissionedDisputeGameImpl;\n }\n\n function preimageOracleImpl() public view returns (address) {\n require(_preimageOracleImpl != address(0), \"FetchChainInfoOutput: preimageOracleImpl not set\");\n return _preimageOracleImpl;\n }\n\n function systemConfigOwner() public view returns (address) {\n require(_systemConfigOwner != address(0), \"FetchChainInfoOutput: systemConfigOwner not set\");\n return _systemConfigOwner;\n }\n\n function opChainProxyAdminOwner() public view returns (address) {\n require(_opChainProxyAdminOwner != address(0), \"FetchChainInfoOutput: opChainProxyAdminOwner not set\");\n return _opChainProxyAdminOwner;\n }\n\n function opChainGuardian() public view returns (address) {\n require(_opChainGuardian != address(0), \"FetchChainInfoOutput: opChainGuardian not set\");\n return _opChainGuardian;\n }\n\n function challenger() public view returns (address) {\n require(_challenger != address(0), \"FetchChainInfoOutput: challenger not set\");\n return _challenger;\n }\n\n function proposer() public view returns (address) {\n require(_proposer != address(0), \"FetchChainInfoOutput: proposer not set\");\n return _proposer;\n }\n\n function unsafeBlockSigner() public view returns (address) {\n require(_unsafeBlockSigner != address(0), \"FetchChainInfoOutput: unsafeBlockSigner not set\");\n return _unsafeBlockSigner;\n }\n\n function batchSubmitter() public view returns (address) {\n require(_batchSubmitter != address(0), \"FetchChainInfoOutput: batchSubmitter not set\");\n return _batchSubmitter;\n }\n\n function permissioned() public view returns (bool) {\n return _permissioned;\n }\n\n function permissionless() public view returns (bool) {\n return _permissionless;\n }\n\n function respectedGameType() public view returns (GameType) {\n return _respectedGameType;\n }\n}\n\ncontract FetchChainInfo is Script {\n function run(FetchChainInfoInput _fi, FetchChainInfoOutput _fo) public {\n _processSystemConfig(_fi, _fo);\n _processMessengerAndPortal(_fi, _fo);\n _processFaultProofs(_fo);\n }\n\n function _processSystemConfig(FetchChainInfoInput _fi, FetchChainInfoOutput _fo) internal {\n address systemConfigProxy = _fi.systemConfigProxy();\n _fo.set(_fo.systemConfigProxy.selector, systemConfigProxy);\n\n address systemConfigOwner = IFetcher(systemConfigProxy).owner();\n _fo.set(_fo.systemConfigOwner.selector, systemConfigOwner);\n\n address unsafeBlockSigner = IFetcher(systemConfigProxy).unsafeBlockSigner();\n _fo.set(_fo.unsafeBlockSigner.selector, unsafeBlockSigner);\n\n address batchSubmitter = _getBatchSubmitter(systemConfigProxy);\n _fo.set(_fo.batchSubmitter.selector, batchSubmitter);\n\n address opChainProxyAdminImpl = _getProxyAdmin(systemConfigProxy);\n _fo.set(_fo.opChainProxyAdminImpl.selector, opChainProxyAdminImpl);\n\n address opChainProxyAdminOwner = IFetcher(opChainProxyAdminImpl).owner();\n _fo.set(_fo.opChainProxyAdminOwner.selector, opChainProxyAdminOwner);\n\n address l1Erc721BridgeProxy = _getL1ERC721BridgeProxy(systemConfigProxy);\n _fo.set(_fo.l1Erc721BridgeProxy.selector, l1Erc721BridgeProxy);\n\n address optimismMintableErc20FactoryProxy = _getOptimismMintableERC20FactoryProxy(systemConfigProxy);\n _fo.set(_fo.optimismMintableErc20FactoryProxy.selector, optimismMintableErc20FactoryProxy);\n }\n\n function _processMessengerAndPortal(FetchChainInfoInput _fi, FetchChainInfoOutput _fo) internal {\n address l1StandardBridgeProxy = _fi.l1StandardBridgeProxy();\n _fo.set(_fo.l1StandardBridgeProxy.selector, l1StandardBridgeProxy);\n\n address l1CrossDomainMessengerProxy = IFetcher(l1StandardBridgeProxy).messenger();\n _fo.set(_fo.l1CrossDomainMessengerProxy.selector, l1CrossDomainMessengerProxy);\n\n address addressManagerImpl = _getAddressManager(l1CrossDomainMessengerProxy);\n _fo.set(_fo.addressManagerImpl.selector, addressManagerImpl);\n\n address optimismPortalProxy = _getOptimismPortalProxy(l1CrossDomainMessengerProxy);\n _fo.set(_fo.optimismPortalProxy.selector, optimismPortalProxy);\n\n address opChainGuardian = _getGuardian(optimismPortalProxy);\n _fo.set(_fo.opChainGuardian.selector, opChainGuardian);\n\n address ethLockboxProxy = _getEthLockboxProxy(optimismPortalProxy);\n _fo.set(_fo.ethLockboxProxy.selector, ethLockboxProxy);\n\n address superchainConfigProxy = _getSuperchainConfigProxy(optimismPortalProxy);\n _fo.set(_fo.superchainConfigProxy.selector, superchainConfigProxy);\n }\n\n function _processFaultProofs(FetchChainInfoOutput _fo) internal {\n address systemConfigProxy = _fo.systemConfigProxy();\n address optimismPortalProxy = _fo.optimismPortalProxy();\n\n try IFetcher(optimismPortalProxy).respectedGameType() returns (GameType gameType_) {\n _fo.set(_fo.respectedGameType.selector, gameType_);\n } catch {\n // default respectedGameType to uint32.max since 0 == CANNON\n _fo.set(_fo.respectedGameType.selector, GameType.wrap(type(uint32).max));\n address l2OutputOracleProxy;\n try IFetcher(optimismPortalProxy).l2Oracle() returns (address l2Oracle_) {\n l2OutputOracleProxy = l2Oracle_;\n } catch {\n l2OutputOracleProxy = IFetcher(optimismPortalProxy).L2_ORACLE();\n }\n _fo.set(_fo.l2OutputOracleProxy.selector, l2OutputOracleProxy);\n\n address proposer = IFetcher(l2OutputOracleProxy).PROPOSER();\n _fo.set(_fo.proposer.selector, proposer);\n\n // no fault proofs installed so we're done\n return;\n }\n\n address disputeGameFactoryProxy = _getDisputeGameFactoryProxy(systemConfigProxy);\n if (disputeGameFactoryProxy != address(0)) {\n _fo.set(_fo.disputeGameFactoryProxy.selector, disputeGameFactoryProxy);\n\n address permissionedDisputeGameImpl = _getPermissionedDisputeGame(disputeGameFactoryProxy);\n if (permissionedDisputeGameImpl != address(0)) {\n // permissioned fault proofs installed\n _fo.set(_fo.permissioned.selector, true);\n _fo.set(_fo.permissionedDisputeGameImpl.selector, permissionedDisputeGameImpl);\n\n address challenger = IFetcher(permissionedDisputeGameImpl).challenger();\n _fo.set(_fo.challenger.selector, challenger);\n\n address anchorStateRegistryProxy = IFetcher(permissionedDisputeGameImpl).anchorStateRegistry();\n _fo.set(_fo.anchorStateRegistryProxy.selector, anchorStateRegistryProxy);\n\n address proposer = IFetcher(permissionedDisputeGameImpl).proposer();\n _fo.set(_fo.proposer.selector, proposer);\n\n address delayedWethPermissionedGameProxy = _getDelayedWETHProxy(permissionedDisputeGameImpl);\n _fo.set(_fo.delayedWethPermissionedGameProxy.selector, delayedWethPermissionedGameProxy);\n\n address mipsImpl = IFetcher(permissionedDisputeGameImpl).vm();\n _fo.set(_fo.mipsImpl.selector, mipsImpl);\n\n address preimageOracleImpl = IFetcher(mipsImpl).oracle();\n _fo.set(_fo.preimageOracleImpl.selector, preimageOracleImpl);\n }\n\n address faultDisputeGameImpl = _getFaultDisputeGame(disputeGameFactoryProxy);\n if (faultDisputeGameImpl != address(0)) {\n // permissionless fault proofs installed\n _fo.set(_fo.faultDisputeGameImpl.selector, faultDisputeGameImpl);\n _fo.set(_fo.permissionless.selector, true);\n\n address delayedWethPermissionlessGameProxy = _getDelayedWETHProxy(faultDisputeGameImpl);\n _fo.set(_fo.delayedWethPermissionlessGameProxy.selector, delayedWethPermissionlessGameProxy);\n }\n } else {\n // some older chains have L2OutputOracle instead of DisputeGameFactory.\n address l2OutputOracleProxy = IFetcher(optimismPortalProxy).L2_ORACLE();\n _fo.set(_fo.l2OutputOracleProxy.selector, l2OutputOracleProxy);\n address proposer = IFetcher(l2OutputOracleProxy).PROPOSER();\n _fo.set(_fo.proposer.selector, proposer);\n }\n }\n\n function _getGuardian(address _portal) internal view returns (address) {\n try IFetcher(_portal).guardian() returns (address guardian_) {\n return guardian_;\n } catch {\n return IFetcher(_portal).GUARDIAN();\n }\n }\n\n function _getSystemConfigProxy(address _portal) internal view returns (address) {\n try IFetcher(_portal).systemConfig() returns (address systemConfig_) {\n return systemConfig_;\n } catch {\n return IFetcher(_portal).SYSTEM_CONFIG();\n }\n }\n\n function _getOptimismPortalProxy(address _l1CrossDomainMessengerProxy) internal view returns (address) {\n try IFetcher(_l1CrossDomainMessengerProxy).portal() returns (address optimismPortal_) {\n return optimismPortal_;\n } catch {\n return IFetcher(_l1CrossDomainMessengerProxy).PORTAL();\n }\n }\n\n function _getAddressManager(address _l1CrossDomainMessengerProxy) internal view returns (address) {\n uint256 ADDRESS_MANAGER_MAPPING_SLOT = 1;\n bytes32 slot = keccak256(abi.encode(_l1CrossDomainMessengerProxy, ADDRESS_MANAGER_MAPPING_SLOT));\n return address(uint160(uint256((vm.load(_l1CrossDomainMessengerProxy, slot)))));\n }\n\n function _getL1ERC721BridgeProxy(address _systemConfigProxy) internal view returns (address) {\n try IFetcher(_systemConfigProxy).l1ERC721Bridge() returns (address l1ERC721BridgeProxy_) {\n return l1ERC721BridgeProxy_;\n } catch {\n return address(0);\n }\n }\n\n function _getOptimismMintableERC20FactoryProxy(address _systemConfigProxy) internal view returns (address) {\n try IFetcher(_systemConfigProxy).optimismMintableERC20Factory() returns (\n address optimismMintableERC20FactoryProxy_\n ) {\n return optimismMintableERC20FactoryProxy_;\n } catch {\n return address(0);\n }\n }\n\n function _getDisputeGameFactoryProxy(address _systemConfigProxy) internal view returns (address) {\n try IFetcher(_systemConfigProxy).disputeGameFactory() returns (address disputeGameFactoryProxy_) {\n return disputeGameFactoryProxy_;\n } catch {\n // Some older chains have L2OutputOracle instead of DisputeGameFactory\n return address(0);\n }\n }\n\n function _getSuperchainConfigProxy(address _optimismPortalProxy) internal view returns (address) {\n try IFetcher(_optimismPortalProxy).superchainConfig() returns (address superchainConfigProxy_) {\n return superchainConfigProxy_;\n } catch {\n return address(0);\n }\n }\n\n function _getFaultDisputeGame(address _disputeGameFactoryProxy) internal view returns (address) {\n try IFetcher(_disputeGameFactoryProxy).gameImpls(GameTypes.CANNON) returns (address faultDisputeGame_) {\n return faultDisputeGame_;\n } catch {\n return address(0);\n }\n }\n\n function _getPermissionedDisputeGame(address _disputeGameFactoryProxy) internal view returns (address) {\n try IFetcher(_disputeGameFactoryProxy).gameImpls(GameTypes.PERMISSIONED_CANNON) returns (\n address permissionedDisputeGame_\n ) {\n return permissionedDisputeGame_;\n } catch {\n return address(0);\n }\n }\n\n function _getEthLockboxProxy(address _optimismPortalProxy) internal view returns (address) {\n try IFetcher(_optimismPortalProxy).ethLockbox() returns (address ethLockbox_) {\n return ethLockbox_;\n } catch {\n return address(0);\n }\n }\n\n function _getDelayedWETHProxy(address _disputeGame) internal view returns (address) {\n (bool ok, bytes memory data) = address(_disputeGame).staticcall(abi.encodeCall(IFetcher.weth, ()));\n if (ok && data.length == 32) return abi.decode(data, (address));\n else return address(0);\n }\n\n function _getBatchSubmitter(address _systemConfigProxy) internal view returns (address) {\n bytes32 batcherHash = IFetcher(_systemConfigProxy).batcherHash();\n return address(uint160(uint256(batcherHash)));\n }\n\n function _getProxyAdmin(address _systemConfigProxy) internal returns (address) {\n vm.prank(address(0));\n return IFetcher(_systemConfigProxy).admin();\n }\n}\n","license":"MIT"},"src/dispute/lib/LibPosition.sol":{"keccak256":"0x7c5f19f8f54f06de2ce1c6cdcc5c7af65ac405130a4066cdaf146ca315818241","urls":[],"content":"// SPDX-License-Identifier: MIT\npragma solidity ^0.8.15;\n\nusing LibPosition for Position global;\n\n/// @notice A `Position` represents a position of a claim within the game tree.\n/// @dev This is represented as a \"generalized index\" where the high-order bit\n/// is the level in the tree and the remaining bits is a unique bit pattern, allowing\n/// a unique identifier for each node in the tree. Mathematically, it is calculated\n/// as 2^{depth} + indexAtDepth.\ntype Position is uint128;\n\n/// @title LibPosition\n/// @notice This library contains helper functions for working with the `Position` type.\nlibrary LibPosition {\n /// @notice the `MAX_POSITION_BITLEN` is the number of bits that the `Position` type, and the implementation of\n /// its behavior within this library, can safely support.\n uint8 internal constant MAX_POSITION_BITLEN = 126;\n\n /// @notice Computes a generalized index (2^{depth} + indexAtDepth).\n /// @param _depth The depth of the position.\n /// @param _indexAtDepth The index at the depth of the position.\n /// @return position_ The computed generalized index.\n function wrap(uint8 _depth, uint128 _indexAtDepth) internal pure returns (Position position_) {\n assembly {\n // gindex = 2^{_depth} + _indexAtDepth\n position_ := add(shl(_depth, 1), _indexAtDepth)\n }\n }\n\n /// @notice Pulls the `depth` out of a `Position` type.\n /// @param _position The generalized index to get the `depth` of.\n /// @return depth_ The `depth` of the `position` gindex.\n /// @custom:attribution Solady \n function depth(Position _position) internal pure returns (uint8 depth_) {\n // Return the most significant bit offset, which signifies the depth of the gindex.\n assembly {\n depth_ := or(depth_, shl(6, lt(0xffffffffffffffff, shr(depth_, _position))))\n depth_ := or(depth_, shl(5, lt(0xffffffff, shr(depth_, _position))))\n\n // For the remaining 32 bits, use a De Bruijn lookup.\n _position := shr(depth_, _position)\n _position := or(_position, shr(1, _position))\n _position := or(_position, shr(2, _position))\n _position := or(_position, shr(4, _position))\n _position := or(_position, shr(8, _position))\n _position := or(_position, shr(16, _position))\n\n depth_ :=\n or(\n depth_,\n byte(\n shr(251, mul(_position, shl(224, 0x07c4acdd))),\n 0x0009010a0d15021d0b0e10121619031e080c141c0f111807131b17061a05041f\n )\n )\n }\n }\n\n /// @notice Pulls the `indexAtDepth` out of a `Position` type.\n /// The `indexAtDepth` is the left/right index of a position at a specific depth within\n /// the binary tree, starting from index 0. For example, at gindex 2, the `depth` = 1\n /// and the `indexAtDepth` = 0.\n /// @param _position The generalized index to get the `indexAtDepth` of.\n /// @return indexAtDepth_ The `indexAtDepth` of the `position` gindex.\n function indexAtDepth(Position _position) internal pure returns (uint128 indexAtDepth_) {\n // Return bits p_{msb-1}...p_{0}. This effectively pulls the 2^{depth} out of the gindex,\n // leaving only the `indexAtDepth`.\n uint256 msb = depth(_position);\n assembly {\n indexAtDepth_ := sub(_position, shl(msb, 1))\n }\n }\n\n /// @notice Get the left child of `_position`.\n /// @param _position The position to get the left position of.\n /// @return left_ The position to the left of `position`.\n function left(Position _position) internal pure returns (Position left_) {\n assembly {\n left_ := shl(1, _position)\n }\n }\n\n /// @notice Get the right child of `_position`\n /// @param _position The position to get the right position of.\n /// @return right_ The position to the right of `position`.\n function right(Position _position) internal pure returns (Position right_) {\n assembly {\n right_ := or(1, shl(1, _position))\n }\n }\n\n /// @notice Get the parent position of `_position`.\n /// @param _position The position to get the parent position of.\n /// @return parent_ The parent position of `position`.\n function parent(Position _position) internal pure returns (Position parent_) {\n assembly {\n parent_ := shr(1, _position)\n }\n }\n\n /// @notice Get the deepest, right most gindex relative to the `position`. This is equivalent to\n /// calling `right` on a position until the maximum depth is reached.\n /// @param _position The position to get the relative deepest, right most gindex of.\n /// @param _maxDepth The maximum depth of the game.\n /// @return rightIndex_ The deepest, right most gindex relative to the `position`.\n function rightIndex(Position _position, uint256 _maxDepth) internal pure returns (Position rightIndex_) {\n uint256 msb = depth(_position);\n assembly {\n let remaining := sub(_maxDepth, msb)\n rightIndex_ := or(shl(remaining, _position), sub(shl(remaining, 1), 1))\n }\n }\n\n /// @notice Get the deepest, right most trace index relative to the `position`. This is\n /// equivalent to calling `right` on a position until the maximum depth is reached and\n /// then finding its index at depth.\n /// @param _position The position to get the relative trace index of.\n /// @param _maxDepth The maximum depth of the game.\n /// @return traceIndex_ The trace index relative to the `position`.\n function traceIndex(Position _position, uint256 _maxDepth) internal pure returns (uint256 traceIndex_) {\n uint256 msb = depth(_position);\n assembly {\n let remaining := sub(_maxDepth, msb)\n traceIndex_ := sub(or(shl(remaining, _position), sub(shl(remaining, 1), 1)), shl(_maxDepth, 1))\n }\n }\n\n /// @notice Gets the position of the highest ancestor of `_position` that commits to the same\n /// trace index.\n /// @param _position The position to get the highest ancestor of.\n /// @return ancestor_ The highest ancestor of `position` that commits to the same trace index.\n function traceAncestor(Position _position) internal pure returns (Position ancestor_) {\n // Create a field with only the lowest unset bit of `_position` set.\n Position lsb;\n assembly {\n lsb := and(not(_position), add(_position, 1))\n }\n // Find the index of the lowest unset bit within the field.\n uint256 msb = depth(lsb);\n // The highest ancestor that commits to the same trace index is the original position\n // shifted right by the index of the lowest unset bit.\n assembly {\n let a := shr(msb, _position)\n // Bound the ancestor to the minimum gindex, 1.\n ancestor_ := or(a, iszero(a))\n }\n }\n\n /// @notice Gets the position of the highest ancestor of `_position` that commits to the same\n /// trace index, while still being below `_upperBoundExclusive`.\n /// @param _position The position to get the highest ancestor of.\n /// @param _upperBoundExclusive The exclusive upper depth bound, used to inform where to stop in order\n /// to not escape a sub-tree.\n /// @return ancestor_ The highest ancestor of `position` that commits to the same trace index.\n function traceAncestorBounded(\n Position _position,\n uint256 _upperBoundExclusive\n )\n internal\n pure\n returns (Position ancestor_)\n {\n // This function only works for positions that are below the upper bound.\n if (_position.depth() <= _upperBoundExclusive) {\n assembly {\n // Revert with `ClaimAboveSplit()`\n mstore(0x00, 0xb34b5c22)\n revert(0x1C, 0x04)\n }\n }\n\n // Grab the global trace ancestor.\n ancestor_ = traceAncestor(_position);\n\n // If the ancestor is above or at the upper bound, shift it to be below the upper bound.\n // This should be a special case that only covers positions that commit to the final leaf\n // in a sub-tree.\n if (ancestor_.depth() <= _upperBoundExclusive) {\n ancestor_ = ancestor_.rightIndex(_upperBoundExclusive + 1);\n }\n }\n\n /// @notice Get the move position of `_position`, which is the left child of:\n /// 1. `_position` if `_isAttack` is true.\n /// 2. `_position | 1` if `_isAttack` is false.\n /// @param _position The position to get the relative attack/defense position of.\n /// @param _isAttack Whether or not the move is an attack move.\n /// @return move_ The move position relative to `position`.\n function move(Position _position, bool _isAttack) internal pure returns (Position move_) {\n assembly {\n move_ := shl(1, or(iszero(_isAttack), _position))\n }\n }\n\n /// @notice Get the value of a `Position` type in the form of the underlying uint128.\n /// @param _position The position to get the value of.\n /// @return raw_ The value of the `position` as a uint128 type.\n function raw(Position _position) internal pure returns (uint128 raw_) {\n assembly {\n raw_ := _position\n }\n }\n}\n","license":"MIT"},"src/dispute/lib/LibUDT.sol":{"keccak256":"0x41d55e9c74d979b5b797198e38449e7cef4f925e04d61f7699e9c150c4a659d3","urls":[],"content":"// SPDX-License-Identifier: MIT\npragma solidity ^0.8.15;\n\n// Libraries\nimport { Position } from \"src/dispute/lib/LibPosition.sol\";\n\nusing LibClaim for Claim global;\nusing LibHash for Hash global;\nusing LibDuration for Duration global;\nusing LibClock for Clock global;\nusing LibGameId for GameId global;\nusing LibTimestamp for Timestamp global;\nusing LibVMStatus for VMStatus global;\nusing LibGameType for GameType global;\n\n/// @notice A `Clock` represents a packed `Duration` and `Timestamp`\n/// @dev The packed layout of this type is as follows:\n/// ┌────────────┬────────────────┐\n/// │ Bits │ Value │\n/// ├────────────┼────────────────┤\n/// │ [0, 64) │ Duration │\n/// │ [64, 128) │ Timestamp │\n/// └────────────┴────────────────┘\ntype Clock is uint128;\n\n/// @title LibClock\n/// @notice This library contains helper functions for working with the `Clock` type.\nlibrary LibClock {\n /// @notice Packs a `Duration` and `Timestamp` into a `Clock` type.\n /// @param _duration The `Duration` to pack into the `Clock` type.\n /// @param _timestamp The `Timestamp` to pack into the `Clock` type.\n /// @return clock_ The `Clock` containing the `_duration` and `_timestamp`.\n function wrap(Duration _duration, Timestamp _timestamp) internal pure returns (Clock clock_) {\n assembly {\n clock_ := or(shl(0x40, _duration), _timestamp)\n }\n }\n\n /// @notice Pull the `Duration` out of a `Clock` type.\n /// @param _clock The `Clock` type to pull the `Duration` out of.\n /// @return duration_ The `Duration` pulled out of `_clock`.\n function duration(Clock _clock) internal pure returns (Duration duration_) {\n // Shift the high-order 64 bits into the low-order 64 bits, leaving only the `duration`.\n assembly {\n duration_ := shr(0x40, _clock)\n }\n }\n\n /// @notice Pull the `Timestamp` out of a `Clock` type.\n /// @param _clock The `Clock` type to pull the `Timestamp` out of.\n /// @return timestamp_ The `Timestamp` pulled out of `_clock`.\n function timestamp(Clock _clock) internal pure returns (Timestamp timestamp_) {\n // Clean the high-order 192 bits by shifting the clock left and then right again, leaving\n // only the `timestamp`.\n assembly {\n timestamp_ := shr(0xC0, shl(0xC0, _clock))\n }\n }\n\n /// @notice Get the value of a `Clock` type in the form of the underlying uint128.\n /// @param _clock The `Clock` type to get the value of.\n /// @return clock_ The value of the `Clock` type as a uint128 type.\n function raw(Clock _clock) internal pure returns (uint128 clock_) {\n assembly {\n clock_ := _clock\n }\n }\n}\n\n/// @notice A `GameId` represents a packed 4 byte game ID, a 8 byte timestamp, and a 20 byte address.\n/// @dev The packed layout of this type is as follows:\n/// ┌───────────┬───────────┐\n/// │ Bits │ Value │\n/// ├───────────┼───────────┤\n/// │ [0, 32) │ Game Type │\n/// │ [32, 96) │ Timestamp │\n/// │ [96, 256) │ Address │\n/// └───────────┴───────────┘\ntype GameId is bytes32;\n\n/// @title LibGameId\n/// @notice Utility functions for packing and unpacking GameIds.\nlibrary LibGameId {\n /// @notice Packs values into a 32 byte GameId type.\n /// @param _gameType The game type.\n /// @param _timestamp The timestamp of the game's creation.\n /// @param _gameProxy The game proxy address.\n /// @return gameId_ The packed GameId.\n function pack(\n GameType _gameType,\n Timestamp _timestamp,\n address _gameProxy\n )\n internal\n pure\n returns (GameId gameId_)\n {\n assembly {\n gameId_ := or(or(shl(224, _gameType), shl(160, _timestamp)), _gameProxy)\n }\n }\n\n /// @notice Unpacks values from a 32 byte GameId type.\n /// @param _gameId The packed GameId.\n /// @return gameType_ The game type.\n /// @return timestamp_ The timestamp of the game's creation.\n /// @return gameProxy_ The game proxy address.\n function unpack(GameId _gameId)\n internal\n pure\n returns (GameType gameType_, Timestamp timestamp_, address gameProxy_)\n {\n assembly {\n gameType_ := shr(224, _gameId)\n timestamp_ := and(shr(160, _gameId), 0xFFFFFFFFFFFFFFFF)\n gameProxy_ := and(_gameId, 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF)\n }\n }\n}\n\n/// @notice A claim represents an MPT root representing the state of the fault proof program.\ntype Claim is bytes32;\n\n/// @title LibClaim\n/// @notice This library contains helper functions for working with the `Claim` type.\nlibrary LibClaim {\n /// @notice Get the value of a `Claim` type in the form of the underlying bytes32.\n /// @param _claim The `Claim` type to get the value of.\n /// @return claim_ The value of the `Claim` type as a bytes32 type.\n function raw(Claim _claim) internal pure returns (bytes32 claim_) {\n assembly {\n claim_ := _claim\n }\n }\n\n /// @notice Hashes a claim and a position together.\n /// @param _claim A Claim type.\n /// @param _position The position of `claim`.\n /// @param _challengeIndex The index of the claim being moved against.\n /// @return claimHash_ A hash of abi.encodePacked(claim, position|challengeIndex);\n function hashClaimPos(\n Claim _claim,\n Position _position,\n uint256 _challengeIndex\n )\n internal\n pure\n returns (Hash claimHash_)\n {\n assembly {\n mstore(0x00, _claim)\n mstore(0x20, or(shl(128, _position), and(0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF, _challengeIndex)))\n claimHash_ := keccak256(0x00, 0x40)\n }\n }\n}\n\n/// @notice A dedicated duration type.\n/// @dev Unit: seconds\ntype Duration is uint64;\n\n/// @title LibDuration\n/// @notice This library contains helper functions for working with the `Duration` type.\nlibrary LibDuration {\n /// @notice Get the value of a `Duration` type in the form of the underlying uint64.\n /// @param _duration The `Duration` type to get the value of.\n /// @return duration_ The value of the `Duration` type as a uint64 type.\n function raw(Duration _duration) internal pure returns (uint64 duration_) {\n assembly {\n duration_ := _duration\n }\n }\n}\n\n/// @notice A custom type for a generic hash.\ntype Hash is bytes32;\n\n/// @title LibHash\n/// @notice This library contains helper functions for working with the `Hash` type.\nlibrary LibHash {\n /// @notice Get the value of a `Hash` type in the form of the underlying bytes32.\n /// @param _hash The `Hash` type to get the value of.\n /// @return hash_ The value of the `Hash` type as a bytes32 type.\n function raw(Hash _hash) internal pure returns (bytes32 hash_) {\n assembly {\n hash_ := _hash\n }\n }\n}\n\n/// @notice A dedicated timestamp type.\ntype Timestamp is uint64;\n\n/// @title LibTimestamp\n/// @notice This library contains helper functions for working with the `Timestamp` type.\nlibrary LibTimestamp {\n /// @notice Get the value of a `Timestamp` type in the form of the underlying uint64.\n /// @param _timestamp The `Timestamp` type to get the value of.\n /// @return timestamp_ The value of the `Timestamp` type as a uint64 type.\n function raw(Timestamp _timestamp) internal pure returns (uint64 timestamp_) {\n assembly {\n timestamp_ := _timestamp\n }\n }\n}\n\n/// @notice A `VMStatus` represents the status of a VM execution.\ntype VMStatus is uint8;\n\n/// @title LibVMStatus\n/// @notice This library contains helper functions for working with the `VMStatus` type.\nlibrary LibVMStatus {\n /// @notice Get the value of a `VMStatus` type in the form of the underlying uint8.\n /// @param _vmstatus The `VMStatus` type to get the value of.\n /// @return vmstatus_ The value of the `VMStatus` type as a uint8 type.\n function raw(VMStatus _vmstatus) internal pure returns (uint8 vmstatus_) {\n assembly {\n vmstatus_ := _vmstatus\n }\n }\n}\n\n/// @notice A `GameType` represents the type of game being played.\ntype GameType is uint32;\n\n/// @title LibGameType\n/// @notice This library contains helper functions for working with the `GameType` type.\nlibrary LibGameType {\n /// @notice Get the value of a `GameType` type in the form of the underlying uint32.\n /// @param _gametype The `GameType` type to get the value of.\n /// @return gametype_ The value of the `GameType` type as a uint32 type.\n function raw(GameType _gametype) internal pure returns (uint32 gametype_) {\n assembly {\n gametype_ := _gametype\n }\n }\n}\n","license":"MIT"},"src/dispute/lib/Types.sol":{"keccak256":"0x7cc2960ea5c5223d81ae2156a966fa0226b70f9666932aca63a0a2a45c9182ae","urls":[],"content":"// SPDX-License-Identifier: MIT\npragma solidity ^0.8.15;\n\n// Libraries\nimport {\n Position,\n Hash,\n GameType,\n VMStatus,\n Timestamp,\n Duration,\n Clock,\n GameId,\n Claim,\n LibGameId,\n LibClock\n} from \"src/dispute/lib/LibUDT.sol\";\n\n/// @notice The current status of the dispute game.\nenum GameStatus {\n // The game is currently in progress, and has not been resolved.\n IN_PROGRESS,\n // The game has concluded, and the `rootClaim` was challenged successfully.\n CHALLENGER_WINS,\n // The game has concluded, and the `rootClaim` could not be contested.\n DEFENDER_WINS\n}\n\n/// @notice The game's bond distribution type. Games are expected to start in the `UNDECIDED`\n/// state, and then choose either `NORMAL` or `REFUND`.\nenum BondDistributionMode {\n // Bond distribution strategy has not been chosen.\n UNDECIDED,\n // Bonds should be distributed as normal.\n NORMAL,\n // Bonds should be refunded to claimants.\n REFUND\n}\n\n/// @notice Represents an L2 root and the L2 sequence number at which it was generated.\n/// @custom:field root The output root.\n/// @custom:field l2SequenceNumber The L2 Sequence Number ( e.g. block number / timestamp) at which the root was\n/// generated.\nstruct Proposal {\n Hash root;\n uint256 l2SequenceNumber;\n}\n\n/// @title GameTypes\n/// @notice A library that defines the IDs of games that can be played.\nlibrary GameTypes {\n /// @dev A dispute game type the uses the cannon vm.\n GameType internal constant CANNON = GameType.wrap(0);\n\n /// @dev A permissioned dispute game type that uses the cannon vm.\n GameType internal constant PERMISSIONED_CANNON = GameType.wrap(1);\n\n /// @notice A dispute game type that uses the asterisc vm.\n GameType internal constant ASTERISC = GameType.wrap(2);\n\n /// @notice A dispute game type that uses the asterisc vm with Kona.\n GameType internal constant ASTERISC_KONA = GameType.wrap(3);\n\n /// @notice A dispute game type that uses the cannon vm (Super Roots).\n GameType internal constant SUPER_CANNON = GameType.wrap(4);\n\n /// @notice A dispute game type that uses the permissioned cannon vm (Super Roots).\n GameType internal constant SUPER_PERMISSIONED_CANNON = GameType.wrap(5);\n\n /// @notice A dispute game type that uses OP Succinct\n GameType internal constant OP_SUCCINCT = GameType.wrap(6);\n\n /// @notice A dispute game type with short game duration for testing withdrawals.\n /// Not intended for production use.\n GameType internal constant FAST = GameType.wrap(254);\n\n /// @notice A dispute game type that uses an alphabet vm.\n /// Not intended for production use.\n GameType internal constant ALPHABET = GameType.wrap(255);\n\n /// @notice A dispute game type that uses RISC Zero's Kailua\n GameType internal constant KAILUA = GameType.wrap(1337);\n}\n\n/// @title VMStatuses\n/// @notice Named type aliases for the various valid VM status bytes.\nlibrary VMStatuses {\n /// @notice The VM has executed successfully and the outcome is valid.\n VMStatus internal constant VALID = VMStatus.wrap(0);\n\n /// @notice The VM has executed successfully and the outcome is invalid.\n VMStatus internal constant INVALID = VMStatus.wrap(1);\n\n /// @notice The VM has paniced.\n VMStatus internal constant PANIC = VMStatus.wrap(2);\n\n /// @notice The VM execution is still in progress.\n VMStatus internal constant UNFINISHED = VMStatus.wrap(3);\n}\n\n/// @title LocalPreimageKey\n/// @notice Named type aliases for local `PreimageOracle` key identifiers.\nlibrary LocalPreimageKey {\n /// @notice The identifier for the L1 head hash.\n uint256 internal constant L1_HEAD_HASH = 0x01;\n\n /// @notice The identifier for the starting output root.\n uint256 internal constant STARTING_OUTPUT_ROOT = 0x02;\n\n /// @notice The identifier for the disputed output root.\n uint256 internal constant DISPUTED_OUTPUT_ROOT = 0x03;\n\n /// @notice The identifier for the disputed L2 block number.\n uint256 internal constant DISPUTED_L2_BLOCK_NUMBER = 0x04;\n\n /// @notice The identifier for the chain ID.\n uint256 internal constant CHAIN_ID = 0x05;\n}\n","license":"MIT"}},"version":1},"storageLayout":{"storage":[{"astId":57411,"contract":"scripts/FetchChainInfo.s.sol:FetchChainInfoOutput","label":"_superchainConfigProxy","offset":0,"slot":"0","type":"t_address"},{"astId":57413,"contract":"scripts/FetchChainInfo.s.sol:FetchChainInfoOutput","label":"_mipsImpl","offset":0,"slot":"1","type":"t_address"},{"astId":57415,"contract":"scripts/FetchChainInfo.s.sol:FetchChainInfoOutput","label":"_preimageOracleImpl","offset":0,"slot":"2","type":"t_address"},{"astId":57417,"contract":"scripts/FetchChainInfo.s.sol:FetchChainInfoOutput","label":"_addressManagerImpl","offset":0,"slot":"3","type":"t_address"},{"astId":57419,"contract":"scripts/FetchChainInfo.s.sol:FetchChainInfoOutput","label":"_ethLockboxProxy","offset":0,"slot":"4","type":"t_address"},{"astId":57421,"contract":"scripts/FetchChainInfo.s.sol:FetchChainInfoOutput","label":"_l1CrossDomainMessengerProxy","offset":0,"slot":"5","type":"t_address"},{"astId":57423,"contract":"scripts/FetchChainInfo.s.sol:FetchChainInfoOutput","label":"_l1Erc721BridgeProxy","offset":0,"slot":"6","type":"t_address"},{"astId":57425,"contract":"scripts/FetchChainInfo.s.sol:FetchChainInfoOutput","label":"_l1StandardBridgeProxy","offset":0,"slot":"7","type":"t_address"},{"astId":57427,"contract":"scripts/FetchChainInfo.s.sol:FetchChainInfoOutput","label":"_l2OutputOracleProxy","offset":0,"slot":"8","type":"t_address"},{"astId":57429,"contract":"scripts/FetchChainInfo.s.sol:FetchChainInfoOutput","label":"_optimismMintableErc20FactoryProxy","offset":0,"slot":"9","type":"t_address"},{"astId":57431,"contract":"scripts/FetchChainInfo.s.sol:FetchChainInfoOutput","label":"_optimismPortalProxy","offset":0,"slot":"10","type":"t_address"},{"astId":57433,"contract":"scripts/FetchChainInfo.s.sol:FetchChainInfoOutput","label":"_systemConfigProxy","offset":0,"slot":"11","type":"t_address"},{"astId":57435,"contract":"scripts/FetchChainInfo.s.sol:FetchChainInfoOutput","label":"_opChainProxyAdminImpl","offset":0,"slot":"12","type":"t_address"},{"astId":57437,"contract":"scripts/FetchChainInfo.s.sol:FetchChainInfoOutput","label":"_anchorStateRegistryProxy","offset":0,"slot":"13","type":"t_address"},{"astId":57439,"contract":"scripts/FetchChainInfo.s.sol:FetchChainInfoOutput","label":"_delayedWethPermissionedGameProxy","offset":0,"slot":"14","type":"t_address"},{"astId":57441,"contract":"scripts/FetchChainInfo.s.sol:FetchChainInfoOutput","label":"_delayedWethPermissionlessGameProxy","offset":0,"slot":"15","type":"t_address"},{"astId":57443,"contract":"scripts/FetchChainInfo.s.sol:FetchChainInfoOutput","label":"_disputeGameFactoryProxy","offset":0,"slot":"16","type":"t_address"},{"astId":57445,"contract":"scripts/FetchChainInfo.s.sol:FetchChainInfoOutput","label":"_faultDisputeGameImpl","offset":0,"slot":"17","type":"t_address"},{"astId":57447,"contract":"scripts/FetchChainInfo.s.sol:FetchChainInfoOutput","label":"_permissionedDisputeGameImpl","offset":0,"slot":"18","type":"t_address"},{"astId":57449,"contract":"scripts/FetchChainInfo.s.sol:FetchChainInfoOutput","label":"_systemConfigOwner","offset":0,"slot":"19","type":"t_address"},{"astId":57451,"contract":"scripts/FetchChainInfo.s.sol:FetchChainInfoOutput","label":"_opChainProxyAdminOwner","offset":0,"slot":"20","type":"t_address"},{"astId":57453,"contract":"scripts/FetchChainInfo.s.sol:FetchChainInfoOutput","label":"_opChainGuardian","offset":0,"slot":"21","type":"t_address"},{"astId":57455,"contract":"scripts/FetchChainInfo.s.sol:FetchChainInfoOutput","label":"_challenger","offset":0,"slot":"22","type":"t_address"},{"astId":57457,"contract":"scripts/FetchChainInfo.s.sol:FetchChainInfoOutput","label":"_proposer","offset":0,"slot":"23","type":"t_address"},{"astId":57459,"contract":"scripts/FetchChainInfo.s.sol:FetchChainInfoOutput","label":"_unsafeBlockSigner","offset":0,"slot":"24","type":"t_address"},{"astId":57461,"contract":"scripts/FetchChainInfo.s.sol:FetchChainInfoOutput","label":"_batchSubmitter","offset":0,"slot":"25","type":"t_address"},{"astId":57463,"contract":"scripts/FetchChainInfo.s.sol:FetchChainInfoOutput","label":"_permissioned","offset":20,"slot":"25","type":"t_bool"},{"astId":57465,"contract":"scripts/FetchChainInfo.s.sol:FetchChainInfoOutput","label":"_permissionless","offset":21,"slot":"25","type":"t_bool"},{"astId":57468,"contract":"scripts/FetchChainInfo.s.sol:FetchChainInfoOutput","label":"_respectedGameType","offset":22,"slot":"25","type":"t_userDefinedValueType(GameType)75355"}],"types":{"t_address":{"encoding":"inplace","label":"address","numberOfBytes":"20"},"t_bool":{"encoding":"inplace","label":"bool","numberOfBytes":"1"},"t_userDefinedValueType(GameType)75355":{"encoding":"inplace","label":"GameType","numberOfBytes":"4"}}},"userdoc":{"version":1,"kind":"user"},"devdoc":{"version":1,"kind":"dev"},"ast":{"absolutePath":"scripts/FetchChainInfo.s.sol","id":59300,"exportedSymbols":{"FetchChainInfo":[59299],"FetchChainInfoInput":[57409],"FetchChainInfoOutput":[58249],"GameType":[75355],"GameTypes":[75481],"IFetcher":[57326],"Script":[6037]},"nodeType":"SourceUnit","src":"32:23957:120","nodes":[{"id":57175,"nodeType":"PragmaDirective","src":"32:23:120","nodes":[],"literals":["solidity","^","0.8",".0"]},{"id":57177,"nodeType":"ImportDirective","src":"57:46:120","nodes":[],"absolutePath":"lib/forge-std/src/Script.sol","file":"forge-std/Script.sol","nameLocation":"-1:-1:-1","scope":59300,"sourceUnit":6038,"symbolAliases":[{"foreign":{"id":57176,"name":"Script","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":6037,"src":"66:6:120","typeDescriptions":{}},"nameLocation":"-1:-1:-1"}],"unitAlias":""},{"id":57180,"nodeType":"ImportDirective","src":"104:64:120","nodes":[],"absolutePath":"src/dispute/lib/Types.sol","file":"src/dispute/lib/Types.sol","nameLocation":"-1:-1:-1","scope":59300,"sourceUnit":75538,"symbolAliases":[{"foreign":{"id":57178,"name":"GameTypes","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":75481,"src":"113:9:120","typeDescriptions":{}},"nameLocation":"-1:-1:-1"},{"foreign":{"id":57179,"name":"GameType","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":75355,"src":"124:8:120","typeDescriptions":{}},"nameLocation":"-1:-1:-1"}],"unitAlias":""},{"id":57326,"nodeType":"ContractDefinition","src":"306:1713:120","nodes":[{"id":57186,"nodeType":"FunctionDefinition","src":"331:52:120","nodes":[],"functionSelector":"452a9320","implemented":false,"kind":"function","modifiers":[],"name":"guardian","nameLocation":"340:8:120","parameters":{"id":57182,"nodeType":"ParameterList","parameters":[],"src":"348:2:120"},"returnParameters":{"id":57185,"nodeType":"ParameterList","parameters":[{"constant":false,"id":57184,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":57186,"src":"374:7:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":57183,"name":"address","nodeType":"ElementaryTypeName","src":"374:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"373:9:120"},"scope":57326,"stateMutability":"view","virtual":false,"visibility":"external"},{"id":57191,"nodeType":"FunctionDefinition","src":"388:52:120","nodes":[],"functionSelector":"724c184c","implemented":false,"kind":"function","modifiers":[],"name":"GUARDIAN","nameLocation":"397:8:120","parameters":{"id":57187,"nodeType":"ParameterList","parameters":[],"src":"405:2:120"},"returnParameters":{"id":57190,"nodeType":"ParameterList","parameters":[{"constant":false,"id":57189,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":57191,"src":"431:7:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":57188,"name":"address","nodeType":"ElementaryTypeName","src":"431:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"430:9:120"},"scope":57326,"stateMutability":"view","virtual":false,"visibility":"external"},{"id":57196,"nodeType":"FunctionDefinition","src":"445:56:120","nodes":[],"functionSelector":"33d7e2bd","implemented":false,"kind":"function","modifiers":[],"name":"systemConfig","nameLocation":"454:12:120","parameters":{"id":57192,"nodeType":"ParameterList","parameters":[],"src":"466:2:120"},"returnParameters":{"id":57195,"nodeType":"ParameterList","parameters":[{"constant":false,"id":57194,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":57196,"src":"492:7:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":57193,"name":"address","nodeType":"ElementaryTypeName","src":"492:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"491:9:120"},"scope":57326,"stateMutability":"view","virtual":false,"visibility":"external"},{"id":57201,"nodeType":"FunctionDefinition","src":"506:57:120","nodes":[],"functionSelector":"f0498750","implemented":false,"kind":"function","modifiers":[],"name":"SYSTEM_CONFIG","nameLocation":"515:13:120","parameters":{"id":57197,"nodeType":"ParameterList","parameters":[],"src":"528:2:120"},"returnParameters":{"id":57200,"nodeType":"ParameterList","parameters":[{"constant":false,"id":57199,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":57201,"src":"554:7:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":57198,"name":"address","nodeType":"ElementaryTypeName","src":"554:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"553:9:120"},"scope":57326,"stateMutability":"view","virtual":false,"visibility":"external"},{"id":57206,"nodeType":"FunctionDefinition","src":"568:62:120","nodes":[],"functionSelector":"f2b4e617","implemented":false,"kind":"function","modifiers":[],"name":"disputeGameFactory","nameLocation":"577:18:120","parameters":{"id":57202,"nodeType":"ParameterList","parameters":[],"src":"595:2:120"},"returnParameters":{"id":57205,"nodeType":"ParameterList","parameters":[{"constant":false,"id":57204,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":57206,"src":"621:7:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":57203,"name":"address","nodeType":"ElementaryTypeName","src":"621:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"620:9:120"},"scope":57326,"stateMutability":"view","virtual":false,"visibility":"external"},{"id":57211,"nodeType":"FunctionDefinition","src":"635:54:120","nodes":[],"functionSelector":"b682c444","implemented":false,"kind":"function","modifiers":[],"name":"ethLockbox","nameLocation":"644:10:120","parameters":{"id":57207,"nodeType":"ParameterList","parameters":[],"src":"654:2:120"},"returnParameters":{"id":57210,"nodeType":"ParameterList","parameters":[{"constant":false,"id":57209,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":57211,"src":"680:7:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":57208,"name":"address","nodeType":"ElementaryTypeName","src":"680:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"679:9:120"},"scope":57326,"stateMutability":"view","virtual":false,"visibility":"external"},{"id":57216,"nodeType":"FunctionDefinition","src":"694:60:120","nodes":[],"functionSelector":"35e80ab3","implemented":false,"kind":"function","modifiers":[],"name":"superchainConfig","nameLocation":"703:16:120","parameters":{"id":57212,"nodeType":"ParameterList","parameters":[],"src":"719:2:120"},"returnParameters":{"id":57215,"nodeType":"ParameterList","parameters":[{"constant":false,"id":57214,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":57216,"src":"745:7:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":57213,"name":"address","nodeType":"ElementaryTypeName","src":"745:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"744:9:120"},"scope":57326,"stateMutability":"view","virtual":false,"visibility":"external"},{"id":57221,"nodeType":"FunctionDefinition","src":"759:53:120","nodes":[],"functionSelector":"3cb747bf","implemented":false,"kind":"function","modifiers":[],"name":"messenger","nameLocation":"768:9:120","parameters":{"id":57217,"nodeType":"ParameterList","parameters":[],"src":"777:2:120"},"returnParameters":{"id":57220,"nodeType":"ParameterList","parameters":[{"constant":false,"id":57219,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":57221,"src":"803:7:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":57218,"name":"address","nodeType":"ElementaryTypeName","src":"803:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"802:9:120"},"scope":57326,"stateMutability":"view","virtual":false,"visibility":"external"},{"id":57226,"nodeType":"FunctionDefinition","src":"817:58:120","nodes":[],"functionSelector":"3ab76e9f","implemented":false,"kind":"function","modifiers":[],"name":"addressManager","nameLocation":"826:14:120","parameters":{"id":57222,"nodeType":"ParameterList","parameters":[],"src":"840:2:120"},"returnParameters":{"id":57225,"nodeType":"ParameterList","parameters":[{"constant":false,"id":57224,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":57226,"src":"866:7:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":57223,"name":"address","nodeType":"ElementaryTypeName","src":"866:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"865:9:120"},"scope":57326,"stateMutability":"view","virtual":false,"visibility":"external"},{"id":57231,"nodeType":"FunctionDefinition","src":"880:50:120","nodes":[],"functionSelector":"0ff754ea","implemented":false,"kind":"function","modifiers":[],"name":"PORTAL","nameLocation":"889:6:120","parameters":{"id":57227,"nodeType":"ParameterList","parameters":[],"src":"895:2:120"},"returnParameters":{"id":57230,"nodeType":"ParameterList","parameters":[{"constant":false,"id":57229,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":57231,"src":"921:7:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":57228,"name":"address","nodeType":"ElementaryTypeName","src":"921:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"920:9:120"},"scope":57326,"stateMutability":"view","virtual":false,"visibility":"external"},{"id":57236,"nodeType":"FunctionDefinition","src":"935:50:120","nodes":[],"functionSelector":"6425666b","implemented":false,"kind":"function","modifiers":[],"name":"portal","nameLocation":"944:6:120","parameters":{"id":57232,"nodeType":"ParameterList","parameters":[],"src":"950:2:120"},"returnParameters":{"id":57235,"nodeType":"ParameterList","parameters":[{"constant":false,"id":57234,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":57236,"src":"976:7:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":57233,"name":"address","nodeType":"ElementaryTypeName","src":"976:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"975:9:120"},"scope":57326,"stateMutability":"view","virtual":false,"visibility":"external"},{"id":57241,"nodeType":"FunctionDefinition","src":"990:58:120","nodes":[],"functionSelector":"c4e8ddfa","implemented":false,"kind":"function","modifiers":[],"name":"l1ERC721Bridge","nameLocation":"999:14:120","parameters":{"id":57237,"nodeType":"ParameterList","parameters":[],"src":"1013:2:120"},"returnParameters":{"id":57240,"nodeType":"ParameterList","parameters":[{"constant":false,"id":57239,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":57241,"src":"1039:7:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":57238,"name":"address","nodeType":"ElementaryTypeName","src":"1039:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"1038:9:120"},"scope":57326,"stateMutability":"view","virtual":false,"visibility":"external"},{"id":57246,"nodeType":"FunctionDefinition","src":"1053:72:120","nodes":[],"functionSelector":"9b7d7f0a","implemented":false,"kind":"function","modifiers":[],"name":"optimismMintableERC20Factory","nameLocation":"1062:28:120","parameters":{"id":57242,"nodeType":"ParameterList","parameters":[],"src":"1090:2:120"},"returnParameters":{"id":57245,"nodeType":"ParameterList","parameters":[{"constant":false,"id":57244,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":57246,"src":"1116:7:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":57243,"name":"address","nodeType":"ElementaryTypeName","src":"1116:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"1115:9:120"},"scope":57326,"stateMutability":"view","virtual":false,"visibility":"external"},{"id":57254,"nodeType":"FunctionDefinition","src":"1130:71:120","nodes":[],"functionSelector":"1b685b9e","implemented":false,"kind":"function","modifiers":[],"name":"gameImpls","nameLocation":"1139:9:120","parameters":{"id":57250,"nodeType":"ParameterList","parameters":[{"constant":false,"id":57249,"mutability":"mutable","name":"_gameType","nameLocation":"1158:9:120","nodeType":"VariableDeclaration","scope":57254,"src":"1149:18:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_userDefinedValueType$_GameType_$75355","typeString":"GameType"},"typeName":{"id":57248,"nodeType":"UserDefinedTypeName","pathNode":{"id":57247,"name":"GameType","nameLocations":["1149:8:120"],"nodeType":"IdentifierPath","referencedDeclaration":75355,"src":"1149:8:120"},"referencedDeclaration":75355,"src":"1149:8:120","typeDescriptions":{"typeIdentifier":"t_userDefinedValueType$_GameType_$75355","typeString":"GameType"}},"visibility":"internal"}],"src":"1148:20:120"},"returnParameters":{"id":57253,"nodeType":"ParameterList","parameters":[{"constant":false,"id":57252,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":57254,"src":"1192:7:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":57251,"name":"address","nodeType":"ElementaryTypeName","src":"1192:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"1191:9:120"},"scope":57326,"stateMutability":"view","virtual":false,"visibility":"external"},{"id":57260,"nodeType":"FunctionDefinition","src":"1206:62:120","nodes":[],"functionSelector":"3c9f397c","implemented":false,"kind":"function","modifiers":[],"name":"respectedGameType","nameLocation":"1215:17:120","parameters":{"id":57255,"nodeType":"ParameterList","parameters":[],"src":"1232:2:120"},"returnParameters":{"id":57259,"nodeType":"ParameterList","parameters":[{"constant":false,"id":57258,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":57260,"src":"1258:8:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_userDefinedValueType$_GameType_$75355","typeString":"GameType"},"typeName":{"id":57257,"nodeType":"UserDefinedTypeName","pathNode":{"id":57256,"name":"GameType","nameLocations":["1258:8:120"],"nodeType":"IdentifierPath","referencedDeclaration":75355,"src":"1258:8:120"},"referencedDeclaration":75355,"src":"1258:8:120","typeDescriptions":{"typeIdentifier":"t_userDefinedValueType$_GameType_$75355","typeString":"GameType"}},"visibility":"internal"}],"src":"1257:10:120"},"scope":57326,"stateMutability":"view","virtual":false,"visibility":"external"},{"id":57265,"nodeType":"FunctionDefinition","src":"1273:63:120","nodes":[],"functionSelector":"5c0cba33","implemented":false,"kind":"function","modifiers":[],"name":"anchorStateRegistry","nameLocation":"1282:19:120","parameters":{"id":57261,"nodeType":"ParameterList","parameters":[],"src":"1301:2:120"},"returnParameters":{"id":57264,"nodeType":"ParameterList","parameters":[{"constant":false,"id":57263,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":57265,"src":"1327:7:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":57262,"name":"address","nodeType":"ElementaryTypeName","src":"1327:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"1326:9:120"},"scope":57326,"stateMutability":"view","virtual":false,"visibility":"external"},{"id":57270,"nodeType":"FunctionDefinition","src":"1341:53:120","nodes":[],"functionSelector":"001c2ff6","implemented":false,"kind":"function","modifiers":[],"name":"L2_ORACLE","nameLocation":"1350:9:120","parameters":{"id":57266,"nodeType":"ParameterList","parameters":[],"src":"1359:2:120"},"returnParameters":{"id":57269,"nodeType":"ParameterList","parameters":[{"constant":false,"id":57268,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":57270,"src":"1385:7:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":57267,"name":"address","nodeType":"ElementaryTypeName","src":"1385:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"1384:9:120"},"scope":57326,"stateMutability":"view","virtual":false,"visibility":"external"},{"id":57275,"nodeType":"FunctionDefinition","src":"1399:52:120","nodes":[],"functionSelector":"9b5f694a","implemented":false,"kind":"function","modifiers":[],"name":"l2Oracle","nameLocation":"1408:8:120","parameters":{"id":57271,"nodeType":"ParameterList","parameters":[],"src":"1416:2:120"},"returnParameters":{"id":57274,"nodeType":"ParameterList","parameters":[{"constant":false,"id":57273,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":57275,"src":"1442:7:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":57272,"name":"address","nodeType":"ElementaryTypeName","src":"1442:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"1441:9:120"},"scope":57326,"stateMutability":"view","virtual":false,"visibility":"external"},{"id":57280,"nodeType":"FunctionDefinition","src":"1456:46:120","nodes":[],"functionSelector":"3a768463","implemented":false,"kind":"function","modifiers":[],"name":"vm","nameLocation":"1465:2:120","parameters":{"id":57276,"nodeType":"ParameterList","parameters":[],"src":"1467:2:120"},"returnParameters":{"id":57279,"nodeType":"ParameterList","parameters":[{"constant":false,"id":57278,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":57280,"src":"1493:7:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":57277,"name":"address","nodeType":"ElementaryTypeName","src":"1493:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"1492:9:120"},"scope":57326,"stateMutability":"view","virtual":false,"visibility":"external"},{"id":57285,"nodeType":"FunctionDefinition","src":"1507:50:120","nodes":[],"functionSelector":"7dc0d1d0","implemented":false,"kind":"function","modifiers":[],"name":"oracle","nameLocation":"1516:6:120","parameters":{"id":57281,"nodeType":"ParameterList","parameters":[],"src":"1522:2:120"},"returnParameters":{"id":57284,"nodeType":"ParameterList","parameters":[{"constant":false,"id":57283,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":57285,"src":"1548:7:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":57282,"name":"address","nodeType":"ElementaryTypeName","src":"1548:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"1547:9:120"},"scope":57326,"stateMutability":"view","virtual":false,"visibility":"external"},{"id":57290,"nodeType":"FunctionDefinition","src":"1562:54:120","nodes":[],"functionSelector":"534db0e2","implemented":false,"kind":"function","modifiers":[],"name":"challenger","nameLocation":"1571:10:120","parameters":{"id":57286,"nodeType":"ParameterList","parameters":[],"src":"1581:2:120"},"returnParameters":{"id":57289,"nodeType":"ParameterList","parameters":[{"constant":false,"id":57288,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":57290,"src":"1607:7:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":57287,"name":"address","nodeType":"ElementaryTypeName","src":"1607:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"1606:9:120"},"scope":57326,"stateMutability":"view","virtual":false,"visibility":"external"},{"id":57295,"nodeType":"FunctionDefinition","src":"1621:52:120","nodes":[],"functionSelector":"a8e4fb90","implemented":false,"kind":"function","modifiers":[],"name":"proposer","nameLocation":"1630:8:120","parameters":{"id":57291,"nodeType":"ParameterList","parameters":[],"src":"1638:2:120"},"returnParameters":{"id":57294,"nodeType":"ParameterList","parameters":[{"constant":false,"id":57293,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":57295,"src":"1664:7:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":57292,"name":"address","nodeType":"ElementaryTypeName","src":"1664:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"1663:9:120"},"scope":57326,"stateMutability":"view","virtual":false,"visibility":"external"},{"id":57300,"nodeType":"FunctionDefinition","src":"1678:52:120","nodes":[],"functionSelector":"bffa7f0f","implemented":false,"kind":"function","modifiers":[],"name":"PROPOSER","nameLocation":"1687:8:120","parameters":{"id":57296,"nodeType":"ParameterList","parameters":[],"src":"1695:2:120"},"returnParameters":{"id":57299,"nodeType":"ParameterList","parameters":[{"constant":false,"id":57298,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":57300,"src":"1721:7:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":57297,"name":"address","nodeType":"ElementaryTypeName","src":"1721:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"1720:9:120"},"scope":57326,"stateMutability":"view","virtual":false,"visibility":"external"},{"id":57305,"nodeType":"FunctionDefinition","src":"1735:55:120","nodes":[],"functionSelector":"e81b2c6d","implemented":false,"kind":"function","modifiers":[],"name":"batcherHash","nameLocation":"1744:11:120","parameters":{"id":57301,"nodeType":"ParameterList","parameters":[],"src":"1755:2:120"},"returnParameters":{"id":57304,"nodeType":"ParameterList","parameters":[{"constant":false,"id":57303,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":57305,"src":"1781:7:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_bytes32","typeString":"bytes32"},"typeName":{"id":57302,"name":"bytes32","nodeType":"ElementaryTypeName","src":"1781:7:120","typeDescriptions":{"typeIdentifier":"t_bytes32","typeString":"bytes32"}},"visibility":"internal"}],"src":"1780:9:120"},"scope":57326,"stateMutability":"view","virtual":false,"visibility":"external"},{"id":57310,"nodeType":"FunctionDefinition","src":"1795:49:120","nodes":[],"functionSelector":"f851a440","implemented":false,"kind":"function","modifiers":[],"name":"admin","nameLocation":"1804:5:120","parameters":{"id":57306,"nodeType":"ParameterList","parameters":[],"src":"1809:2:120"},"returnParameters":{"id":57309,"nodeType":"ParameterList","parameters":[{"constant":false,"id":57308,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":57310,"src":"1835:7:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":57307,"name":"address","nodeType":"ElementaryTypeName","src":"1835:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"1834:9:120"},"scope":57326,"stateMutability":"view","virtual":false,"visibility":"external"},{"id":57315,"nodeType":"FunctionDefinition","src":"1849:49:120","nodes":[],"functionSelector":"8da5cb5b","implemented":false,"kind":"function","modifiers":[],"name":"owner","nameLocation":"1858:5:120","parameters":{"id":57311,"nodeType":"ParameterList","parameters":[],"src":"1863:2:120"},"returnParameters":{"id":57314,"nodeType":"ParameterList","parameters":[{"constant":false,"id":57313,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":57315,"src":"1889:7:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":57312,"name":"address","nodeType":"ElementaryTypeName","src":"1889:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"1888:9:120"},"scope":57326,"stateMutability":"view","virtual":false,"visibility":"external"},{"id":57320,"nodeType":"FunctionDefinition","src":"1903:61:120","nodes":[],"functionSelector":"1fd19ee1","implemented":false,"kind":"function","modifiers":[],"name":"unsafeBlockSigner","nameLocation":"1912:17:120","parameters":{"id":57316,"nodeType":"ParameterList","parameters":[],"src":"1929:2:120"},"returnParameters":{"id":57319,"nodeType":"ParameterList","parameters":[{"constant":false,"id":57318,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":57320,"src":"1955:7:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":57317,"name":"address","nodeType":"ElementaryTypeName","src":"1955:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"1954:9:120"},"scope":57326,"stateMutability":"view","virtual":false,"visibility":"external"},{"id":57325,"nodeType":"FunctionDefinition","src":"1969:48:120","nodes":[],"functionSelector":"3fc8cef3","implemented":false,"kind":"function","modifiers":[],"name":"weth","nameLocation":"1978:4:120","parameters":{"id":57321,"nodeType":"ParameterList","parameters":[],"src":"1982:2:120"},"returnParameters":{"id":57324,"nodeType":"ParameterList","parameters":[{"constant":false,"id":57323,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":57325,"src":"2008:7:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":57322,"name":"address","nodeType":"ElementaryTypeName","src":"2008:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"2007:9:120"},"scope":57326,"stateMutability":"view","virtual":false,"visibility":"external"}],"abstract":false,"baseContracts":[],"canonicalName":"IFetcher","contractDependencies":[],"contractKind":"interface","documentation":{"id":57181,"nodeType":"StructuredDocumentation","src":"170:136:120","text":"@notice Contains getters for arbitrary methods from all L1 contracts, including legacy getters\n that have since been deprecated."},"fullyImplemented":false,"linearizedBaseContracts":[57326],"name":"IFetcher","nameLocation":"316:8:120","scope":59300,"usedErrors":[],"usedEvents":[]},{"id":57409,"nodeType":"ContractDefinition","src":"2021:934:120","nodes":[{"id":57328,"nodeType":"VariableDeclaration","src":"2056:35:120","nodes":[],"constant":false,"mutability":"mutable","name":"_systemConfigProxy","nameLocation":"2073:18:120","scope":57409,"stateVariable":true,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":57327,"name":"address","nodeType":"ElementaryTypeName","src":"2056:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"},{"id":57330,"nodeType":"VariableDeclaration","src":"2097:39:120","nodes":[],"constant":false,"mutability":"mutable","name":"_l1StandardBridgeProxy","nameLocation":"2114:22:120","scope":57409,"stateVariable":true,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":57329,"name":"address","nodeType":"ElementaryTypeName","src":"2097:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"},{"id":57372,"nodeType":"FunctionDefinition","src":"2143:378:120","nodes":[],"body":{"id":57371,"nodeType":"Block","src":"2191:330:120","nodes":[],"statements":[{"expression":{"arguments":[{"commonType":{"typeIdentifier":"t_address","typeString":"address"},"id":57343,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftExpression":{"id":57338,"name":"_addr","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57334,"src":"2209:5:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"BinaryOperation","operator":"!=","rightExpression":{"arguments":[{"hexValue":"30","id":57341,"isConstant":false,"isLValue":false,"isPure":true,"kind":"number","lValueRequested":false,"nodeType":"Literal","src":"2226:1:120","typeDescriptions":{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"},"value":"0"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"}],"id":57340,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"nodeType":"ElementaryTypeNameExpression","src":"2218:7:120","typeDescriptions":{"typeIdentifier":"t_type$_t_address_$","typeString":"type(address)"},"typeName":{"id":57339,"name":"address","nodeType":"ElementaryTypeName","src":"2218:7:120","typeDescriptions":{}}},"id":57342,"isConstant":false,"isLValue":false,"isPure":true,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"2218:10:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"src":"2209:19:120","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},{"hexValue":"4665746368436861696e496e666f496e7075743a2063616e6e6f7420736574207a65726f2061646472657373","id":57344,"isConstant":false,"isLValue":false,"isPure":true,"kind":"string","lValueRequested":false,"nodeType":"Literal","src":"2230:46:120","typeDescriptions":{"typeIdentifier":"t_stringliteral_0336126ace187312d69da4c7cf05307af6a6596e8c75de2974f56108baf24145","typeString":"literal_string \"FetchChainInfoInput: cannot set zero address\""},"value":"FetchChainInfoInput: cannot set zero address"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_bool","typeString":"bool"},{"typeIdentifier":"t_stringliteral_0336126ace187312d69da4c7cf05307af6a6596e8c75de2974f56108baf24145","typeString":"literal_string \"FetchChainInfoInput: cannot set zero address\""}],"id":57337,"name":"require","nodeType":"Identifier","overloadedDeclarations":[-18,-18],"referencedDeclaration":-18,"src":"2201:7:120","typeDescriptions":{"typeIdentifier":"t_function_require_pure$_t_bool_$_t_string_memory_ptr_$returns$__$","typeString":"function (bool,string memory) pure"}},"id":57345,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"2201:76:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":57346,"nodeType":"ExpressionStatement","src":"2201:76:120"},{"condition":{"commonType":{"typeIdentifier":"t_bytes4","typeString":"bytes4"},"id":57351,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftExpression":{"id":57347,"name":"_sel","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57332,"src":"2291:4:120","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},"nodeType":"BinaryOperation","operator":"==","rightExpression":{"expression":{"expression":{"id":57348,"name":"this","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":-28,"src":"2299:4:120","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoInput_$57409","typeString":"contract FetchChainInfoInput"}},"id":57349,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"2304:17:120","memberName":"systemConfigProxy","nodeType":"MemberAccess","referencedDeclaration":57390,"src":"2299:22:120","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":57350,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"memberLocation":"2322:8:120","memberName":"selector","nodeType":"MemberAccess","src":"2299:31:120","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},"src":"2291:39:120","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},"falseBody":{"condition":{"commonType":{"typeIdentifier":"t_bytes4","typeString":"bytes4"},"id":57360,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftExpression":{"id":57356,"name":"_sel","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57332,"src":"2377:4:120","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},"nodeType":"BinaryOperation","operator":"==","rightExpression":{"expression":{"expression":{"id":57357,"name":"this","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":-28,"src":"2385:4:120","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoInput_$57409","typeString":"contract FetchChainInfoInput"}},"id":57358,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"2390:21:120","memberName":"l1StandardBridgeProxy","nodeType":"MemberAccess","referencedDeclaration":57408,"src":"2385:26:120","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":57359,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"memberLocation":"2412:8:120","memberName":"selector","nodeType":"MemberAccess","src":"2385:35:120","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},"src":"2377:43:120","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},"falseBody":{"expression":{"arguments":[{"hexValue":"4665746368436861696e496e666f496e7075743a20756e6b6e6f776e2073656c6563746f72","id":57366,"isConstant":false,"isLValue":false,"isPure":true,"kind":"string","lValueRequested":false,"nodeType":"Literal","src":"2474:39:120","typeDescriptions":{"typeIdentifier":"t_stringliteral_3ec062448196d68b2d186fadb5ffe52c72f0a2b929c9d178cd6e6612281f066b","typeString":"literal_string \"FetchChainInfoInput: unknown selector\""},"value":"FetchChainInfoInput: unknown selector"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_stringliteral_3ec062448196d68b2d186fadb5ffe52c72f0a2b929c9d178cd6e6612281f066b","typeString":"literal_string \"FetchChainInfoInput: unknown selector\""}],"id":57365,"name":"revert","nodeType":"Identifier","overloadedDeclarations":[-19,-19],"referencedDeclaration":-19,"src":"2467:6:120","typeDescriptions":{"typeIdentifier":"t_function_revert_pure$_t_string_memory_ptr_$returns$__$","typeString":"function (string memory) pure"}},"id":57367,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"2467:47:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":57368,"nodeType":"ExpressionStatement","src":"2467:47:120"},"id":57369,"nodeType":"IfStatement","src":"2373:141:120","trueBody":{"expression":{"id":57363,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftHandSide":{"id":57361,"name":"_l1StandardBridgeProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57330,"src":"2422:22:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"Assignment","operator":"=","rightHandSide":{"id":57362,"name":"_addr","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57334,"src":"2447:5:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"src":"2422:30:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"id":57364,"nodeType":"ExpressionStatement","src":"2422:30:120"}},"id":57370,"nodeType":"IfStatement","src":"2287:227:120","trueBody":{"expression":{"id":57354,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftHandSide":{"id":57352,"name":"_systemConfigProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57328,"src":"2332:18:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"Assignment","operator":"=","rightHandSide":{"id":57353,"name":"_addr","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57334,"src":"2353:5:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"src":"2332:26:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"id":57355,"nodeType":"ExpressionStatement","src":"2332:26:120"}}]},"functionSelector":"c3e39250","implemented":true,"kind":"function","modifiers":[],"name":"set","nameLocation":"2152:3:120","parameters":{"id":57335,"nodeType":"ParameterList","parameters":[{"constant":false,"id":57332,"mutability":"mutable","name":"_sel","nameLocation":"2163:4:120","nodeType":"VariableDeclaration","scope":57372,"src":"2156:11:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"},"typeName":{"id":57331,"name":"bytes4","nodeType":"ElementaryTypeName","src":"2156:6:120","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},"visibility":"internal"},{"constant":false,"id":57334,"mutability":"mutable","name":"_addr","nameLocation":"2177:5:120","nodeType":"VariableDeclaration","scope":57372,"src":"2169:13:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":57333,"name":"address","nodeType":"ElementaryTypeName","src":"2169:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"2155:28:120"},"returnParameters":{"id":57336,"nodeType":"ParameterList","parameters":[],"src":"2191:0:120"},"scope":57409,"stateMutability":"nonpayable","virtual":false,"visibility":"public"},{"id":57390,"nodeType":"FunctionDefinition","src":"2527:202:120","nodes":[],"body":{"id":57389,"nodeType":"Block","src":"2586:143:120","nodes":[],"statements":[{"expression":{"arguments":[{"commonType":{"typeIdentifier":"t_address","typeString":"address"},"id":57383,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftExpression":{"id":57378,"name":"_systemConfigProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57328,"src":"2604:18:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"BinaryOperation","operator":"!=","rightExpression":{"arguments":[{"hexValue":"30","id":57381,"isConstant":false,"isLValue":false,"isPure":true,"kind":"number","lValueRequested":false,"nodeType":"Literal","src":"2634:1:120","typeDescriptions":{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"},"value":"0"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"}],"id":57380,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"nodeType":"ElementaryTypeNameExpression","src":"2626:7:120","typeDescriptions":{"typeIdentifier":"t_type$_t_address_$","typeString":"type(address)"},"typeName":{"id":57379,"name":"address","nodeType":"ElementaryTypeName","src":"2626:7:120","typeDescriptions":{}}},"id":57382,"isConstant":false,"isLValue":false,"isPure":true,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"2626:10:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"src":"2604:32:120","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},{"hexValue":"4665746368436861696e496e666f496e7075743a2073797374656d436f6e66696750726f7879206e6f7420736574","id":57384,"isConstant":false,"isLValue":false,"isPure":true,"kind":"string","lValueRequested":false,"nodeType":"Literal","src":"2638:48:120","typeDescriptions":{"typeIdentifier":"t_stringliteral_cefeeda9841ab81b734a3e4f7bf39aeeab7704e02e2040531bd67ea944e4d5d3","typeString":"literal_string \"FetchChainInfoInput: systemConfigProxy not set\""},"value":"FetchChainInfoInput: systemConfigProxy not set"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_bool","typeString":"bool"},{"typeIdentifier":"t_stringliteral_cefeeda9841ab81b734a3e4f7bf39aeeab7704e02e2040531bd67ea944e4d5d3","typeString":"literal_string \"FetchChainInfoInput: systemConfigProxy not set\""}],"id":57377,"name":"require","nodeType":"Identifier","overloadedDeclarations":[-18,-18],"referencedDeclaration":-18,"src":"2596:7:120","typeDescriptions":{"typeIdentifier":"t_function_require_pure$_t_bool_$_t_string_memory_ptr_$returns$__$","typeString":"function (bool,string memory) pure"}},"id":57385,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"2596:91:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":57386,"nodeType":"ExpressionStatement","src":"2596:91:120"},{"expression":{"id":57387,"name":"_systemConfigProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57328,"src":"2704:18:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"functionReturnParameters":57376,"id":57388,"nodeType":"Return","src":"2697:25:120"}]},"functionSelector":"c17db6e3","implemented":true,"kind":"function","modifiers":[],"name":"systemConfigProxy","nameLocation":"2536:17:120","parameters":{"id":57373,"nodeType":"ParameterList","parameters":[],"src":"2553:2:120"},"returnParameters":{"id":57376,"nodeType":"ParameterList","parameters":[{"constant":false,"id":57375,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":57390,"src":"2577:7:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":57374,"name":"address","nodeType":"ElementaryTypeName","src":"2577:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"2576:9:120"},"scope":57409,"stateMutability":"view","virtual":false,"visibility":"public"},{"id":57408,"nodeType":"FunctionDefinition","src":"2735:218:120","nodes":[],"body":{"id":57407,"nodeType":"Block","src":"2798:155:120","nodes":[],"statements":[{"expression":{"arguments":[{"commonType":{"typeIdentifier":"t_address","typeString":"address"},"id":57401,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftExpression":{"id":57396,"name":"_l1StandardBridgeProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57330,"src":"2816:22:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"BinaryOperation","operator":"!=","rightExpression":{"arguments":[{"hexValue":"30","id":57399,"isConstant":false,"isLValue":false,"isPure":true,"kind":"number","lValueRequested":false,"nodeType":"Literal","src":"2850:1:120","typeDescriptions":{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"},"value":"0"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"}],"id":57398,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"nodeType":"ElementaryTypeNameExpression","src":"2842:7:120","typeDescriptions":{"typeIdentifier":"t_type$_t_address_$","typeString":"type(address)"},"typeName":{"id":57397,"name":"address","nodeType":"ElementaryTypeName","src":"2842:7:120","typeDescriptions":{}}},"id":57400,"isConstant":false,"isLValue":false,"isPure":true,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"2842:10:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"src":"2816:36:120","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},{"hexValue":"4665746368436861696e496e666f496e7075743a206c315374616e6461726442726964676550726f7879206e6f7420736574","id":57402,"isConstant":false,"isLValue":false,"isPure":true,"kind":"string","lValueRequested":false,"nodeType":"Literal","src":"2854:52:120","typeDescriptions":{"typeIdentifier":"t_stringliteral_be85b0ed3fc58e97f8b79e4d9fb1c191539515cae509acde6becd9338254d33b","typeString":"literal_string \"FetchChainInfoInput: l1StandardBridgeProxy not set\""},"value":"FetchChainInfoInput: l1StandardBridgeProxy not set"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_bool","typeString":"bool"},{"typeIdentifier":"t_stringliteral_be85b0ed3fc58e97f8b79e4d9fb1c191539515cae509acde6becd9338254d33b","typeString":"literal_string \"FetchChainInfoInput: l1StandardBridgeProxy not set\""}],"id":57395,"name":"require","nodeType":"Identifier","overloadedDeclarations":[-18,-18],"referencedDeclaration":-18,"src":"2808:7:120","typeDescriptions":{"typeIdentifier":"t_function_require_pure$_t_bool_$_t_string_memory_ptr_$returns$__$","typeString":"function (bool,string memory) pure"}},"id":57403,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"2808:99:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":57404,"nodeType":"ExpressionStatement","src":"2808:99:120"},{"expression":{"id":57405,"name":"_l1StandardBridgeProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57330,"src":"2924:22:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"functionReturnParameters":57394,"id":57406,"nodeType":"Return","src":"2917:29:120"}]},"functionSelector":"102b6069","implemented":true,"kind":"function","modifiers":[],"name":"l1StandardBridgeProxy","nameLocation":"2744:21:120","parameters":{"id":57391,"nodeType":"ParameterList","parameters":[],"src":"2765:2:120"},"returnParameters":{"id":57394,"nodeType":"ParameterList","parameters":[{"constant":false,"id":57393,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":57408,"src":"2789:7:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":57392,"name":"address","nodeType":"ElementaryTypeName","src":"2789:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"2788:9:120"},"scope":57409,"stateMutability":"view","virtual":false,"visibility":"public"}],"abstract":false,"baseContracts":[],"canonicalName":"FetchChainInfoInput","contractDependencies":[],"contractKind":"contract","fullyImplemented":true,"linearizedBaseContracts":[57409],"name":"FetchChainInfoInput","nameLocation":"2030:19:120","scope":59300,"usedErrors":[],"usedEvents":[]},{"id":58249,"nodeType":"ContractDefinition","src":"2957:10181:120","nodes":[{"id":57411,"nodeType":"VariableDeclaration","src":"3049:39:120","nodes":[],"constant":false,"mutability":"mutable","name":"_superchainConfigProxy","nameLocation":"3066:22:120","scope":58249,"stateVariable":true,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":57410,"name":"address","nodeType":"ElementaryTypeName","src":"3049:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"},{"id":57413,"nodeType":"VariableDeclaration","src":"3129:26:120","nodes":[],"constant":false,"mutability":"mutable","name":"_mipsImpl","nameLocation":"3146:9:120","scope":58249,"stateVariable":true,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":57412,"name":"address","nodeType":"ElementaryTypeName","src":"3129:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"},{"id":57415,"nodeType":"VariableDeclaration","src":"3161:36:120","nodes":[],"constant":false,"mutability":"mutable","name":"_preimageOracleImpl","nameLocation":"3178:19:120","scope":58249,"stateVariable":true,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":57414,"name":"address","nodeType":"ElementaryTypeName","src":"3161:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"},{"id":57417,"nodeType":"VariableDeclaration","src":"3230:36:120","nodes":[],"constant":false,"mutability":"mutable","name":"_addressManagerImpl","nameLocation":"3247:19:120","scope":58249,"stateVariable":true,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":57416,"name":"address","nodeType":"ElementaryTypeName","src":"3230:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"},{"id":57419,"nodeType":"VariableDeclaration","src":"3272:33:120","nodes":[],"constant":false,"mutability":"mutable","name":"_ethLockboxProxy","nameLocation":"3289:16:120","scope":58249,"stateVariable":true,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":57418,"name":"address","nodeType":"ElementaryTypeName","src":"3272:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"},{"id":57421,"nodeType":"VariableDeclaration","src":"3311:45:120","nodes":[],"constant":false,"mutability":"mutable","name":"_l1CrossDomainMessengerProxy","nameLocation":"3328:28:120","scope":58249,"stateVariable":true,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":57420,"name":"address","nodeType":"ElementaryTypeName","src":"3311:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"},{"id":57423,"nodeType":"VariableDeclaration","src":"3362:37:120","nodes":[],"constant":false,"mutability":"mutable","name":"_l1Erc721BridgeProxy","nameLocation":"3379:20:120","scope":58249,"stateVariable":true,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":57422,"name":"address","nodeType":"ElementaryTypeName","src":"3362:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"},{"id":57425,"nodeType":"VariableDeclaration","src":"3405:39:120","nodes":[],"constant":false,"mutability":"mutable","name":"_l1StandardBridgeProxy","nameLocation":"3422:22:120","scope":58249,"stateVariable":true,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":57424,"name":"address","nodeType":"ElementaryTypeName","src":"3405:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"},{"id":57427,"nodeType":"VariableDeclaration","src":"3450:37:120","nodes":[],"constant":false,"mutability":"mutable","name":"_l2OutputOracleProxy","nameLocation":"3467:20:120","scope":58249,"stateVariable":true,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":57426,"name":"address","nodeType":"ElementaryTypeName","src":"3450:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"},{"id":57429,"nodeType":"VariableDeclaration","src":"3493:51:120","nodes":[],"constant":false,"mutability":"mutable","name":"_optimismMintableErc20FactoryProxy","nameLocation":"3510:34:120","scope":58249,"stateVariable":true,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":57428,"name":"address","nodeType":"ElementaryTypeName","src":"3493:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"},{"id":57431,"nodeType":"VariableDeclaration","src":"3550:37:120","nodes":[],"constant":false,"mutability":"mutable","name":"_optimismPortalProxy","nameLocation":"3567:20:120","scope":58249,"stateVariable":true,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":57430,"name":"address","nodeType":"ElementaryTypeName","src":"3550:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"},{"id":57433,"nodeType":"VariableDeclaration","src":"3593:35:120","nodes":[],"constant":false,"mutability":"mutable","name":"_systemConfigProxy","nameLocation":"3610:18:120","scope":58249,"stateVariable":true,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":57432,"name":"address","nodeType":"ElementaryTypeName","src":"3593:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"},{"id":57435,"nodeType":"VariableDeclaration","src":"3634:39:120","nodes":[],"constant":false,"mutability":"mutable","name":"_opChainProxyAdminImpl","nameLocation":"3651:22:120","scope":58249,"stateVariable":true,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":57434,"name":"address","nodeType":"ElementaryTypeName","src":"3634:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"},{"id":57437,"nodeType":"VariableDeclaration","src":"3679:42:120","nodes":[],"constant":false,"mutability":"mutable","name":"_anchorStateRegistryProxy","nameLocation":"3696:25:120","scope":58249,"stateVariable":true,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":57436,"name":"address","nodeType":"ElementaryTypeName","src":"3679:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"},{"id":57439,"nodeType":"VariableDeclaration","src":"3727:50:120","nodes":[],"constant":false,"mutability":"mutable","name":"_delayedWethPermissionedGameProxy","nameLocation":"3744:33:120","scope":58249,"stateVariable":true,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":57438,"name":"address","nodeType":"ElementaryTypeName","src":"3727:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"},{"id":57441,"nodeType":"VariableDeclaration","src":"3783:52:120","nodes":[],"constant":false,"mutability":"mutable","name":"_delayedWethPermissionlessGameProxy","nameLocation":"3800:35:120","scope":58249,"stateVariable":true,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":57440,"name":"address","nodeType":"ElementaryTypeName","src":"3783:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"},{"id":57443,"nodeType":"VariableDeclaration","src":"3841:41:120","nodes":[],"constant":false,"mutability":"mutable","name":"_disputeGameFactoryProxy","nameLocation":"3858:24:120","scope":58249,"stateVariable":true,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":57442,"name":"address","nodeType":"ElementaryTypeName","src":"3841:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"},{"id":57445,"nodeType":"VariableDeclaration","src":"3888:38:120","nodes":[],"constant":false,"mutability":"mutable","name":"_faultDisputeGameImpl","nameLocation":"3905:21:120","scope":58249,"stateVariable":true,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":57444,"name":"address","nodeType":"ElementaryTypeName","src":"3888:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"},{"id":57447,"nodeType":"VariableDeclaration","src":"3932:45:120","nodes":[],"constant":false,"mutability":"mutable","name":"_permissionedDisputeGameImpl","nameLocation":"3949:28:120","scope":58249,"stateVariable":true,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":57446,"name":"address","nodeType":"ElementaryTypeName","src":"3932:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"},{"id":57449,"nodeType":"VariableDeclaration","src":"3997:35:120","nodes":[],"constant":false,"mutability":"mutable","name":"_systemConfigOwner","nameLocation":"4014:18:120","scope":58249,"stateVariable":true,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":57448,"name":"address","nodeType":"ElementaryTypeName","src":"3997:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"},{"id":57451,"nodeType":"VariableDeclaration","src":"4038:40:120","nodes":[],"constant":false,"mutability":"mutable","name":"_opChainProxyAdminOwner","nameLocation":"4055:23:120","scope":58249,"stateVariable":true,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":57450,"name":"address","nodeType":"ElementaryTypeName","src":"4038:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"},{"id":57453,"nodeType":"VariableDeclaration","src":"4084:33:120","nodes":[],"constant":false,"mutability":"mutable","name":"_opChainGuardian","nameLocation":"4101:16:120","scope":58249,"stateVariable":true,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":57452,"name":"address","nodeType":"ElementaryTypeName","src":"4084:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"},{"id":57455,"nodeType":"VariableDeclaration","src":"4123:28:120","nodes":[],"constant":false,"mutability":"mutable","name":"_challenger","nameLocation":"4140:11:120","scope":58249,"stateVariable":true,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":57454,"name":"address","nodeType":"ElementaryTypeName","src":"4123:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"},{"id":57457,"nodeType":"VariableDeclaration","src":"4157:26:120","nodes":[],"constant":false,"mutability":"mutable","name":"_proposer","nameLocation":"4174:9:120","scope":58249,"stateVariable":true,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":57456,"name":"address","nodeType":"ElementaryTypeName","src":"4157:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"},{"id":57459,"nodeType":"VariableDeclaration","src":"4189:35:120","nodes":[],"constant":false,"mutability":"mutable","name":"_unsafeBlockSigner","nameLocation":"4206:18:120","scope":58249,"stateVariable":true,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":57458,"name":"address","nodeType":"ElementaryTypeName","src":"4189:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"},{"id":57461,"nodeType":"VariableDeclaration","src":"4230:32:120","nodes":[],"constant":false,"mutability":"mutable","name":"_batchSubmitter","nameLocation":"4247:15:120","scope":58249,"stateVariable":true,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":57460,"name":"address","nodeType":"ElementaryTypeName","src":"4230:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"},{"id":57463,"nodeType":"VariableDeclaration","src":"4295:27:120","nodes":[],"constant":false,"mutability":"mutable","name":"_permissioned","nameLocation":"4309:13:120","scope":58249,"stateVariable":true,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"},"typeName":{"id":57462,"name":"bool","nodeType":"ElementaryTypeName","src":"4295:4:120","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},"visibility":"internal"},{"id":57465,"nodeType":"VariableDeclaration","src":"4328:29:120","nodes":[],"constant":false,"mutability":"mutable","name":"_permissionless","nameLocation":"4342:15:120","scope":58249,"stateVariable":true,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"},"typeName":{"id":57464,"name":"bool","nodeType":"ElementaryTypeName","src":"4328:4:120","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},"visibility":"internal"},{"id":57468,"nodeType":"VariableDeclaration","src":"4363:36:120","nodes":[],"constant":false,"mutability":"mutable","name":"_respectedGameType","nameLocation":"4381:18:120","scope":58249,"stateVariable":true,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_userDefinedValueType$_GameType_$75355","typeString":"GameType"},"typeName":{"id":57467,"nodeType":"UserDefinedTypeName","pathNode":{"id":57466,"name":"GameType","nameLocations":["4363:8:120"],"nodeType":"IdentifierPath","referencedDeclaration":75355,"src":"4363:8:120"},"referencedDeclaration":75355,"src":"4363:8:120","typeDescriptions":{"typeIdentifier":"t_userDefinedValueType$_GameType_$75355","typeString":"GameType"}},"visibility":"internal"},{"id":57740,"nodeType":"FunctionDefinition","src":"4406:2634:120","nodes":[],"body":{"id":57739,"nodeType":"Block","src":"4454:2586:120","nodes":[],"statements":[{"condition":{"commonType":{"typeIdentifier":"t_bytes4","typeString":"bytes4"},"id":57479,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftExpression":{"id":57475,"name":"_sel","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57470,"src":"4499:4:120","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},"nodeType":"BinaryOperation","operator":"==","rightExpression":{"expression":{"expression":{"id":57476,"name":"this","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":-28,"src":"4507:4:120","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$58249","typeString":"contract FetchChainInfoOutput"}},"id":57477,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"4512:21:120","memberName":"superchainConfigProxy","nodeType":"MemberAccess","referencedDeclaration":57983,"src":"4507:26:120","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":57478,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"memberLocation":"4534:8:120","memberName":"selector","nodeType":"MemberAccess","src":"4507:35:120","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},"src":"4499:43:120","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},"falseBody":{"condition":{"commonType":{"typeIdentifier":"t_bytes4","typeString":"bytes4"},"id":57488,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftExpression":{"id":57484,"name":"_sel","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57470,"src":"4632:4:120","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},"nodeType":"BinaryOperation","operator":"==","rightExpression":{"expression":{"expression":{"id":57485,"name":"this","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":-28,"src":"4640:4:120","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$58249","typeString":"contract FetchChainInfoOutput"}},"id":57486,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"4645:8:120","memberName":"mipsImpl","nodeType":"MemberAccess","referencedDeclaration":58061,"src":"4640:13:120","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":57487,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"memberLocation":"4654:8:120","memberName":"selector","nodeType":"MemberAccess","src":"4640:22:120","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},"src":"4632:30:120","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},"falseBody":{"condition":{"commonType":{"typeIdentifier":"t_bytes4","typeString":"bytes4"},"id":57497,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftExpression":{"id":57493,"name":"_sel","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57470,"src":"4700:4:120","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},"nodeType":"BinaryOperation","operator":"==","rightExpression":{"expression":{"expression":{"id":57494,"name":"this","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":-28,"src":"4708:4:120","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$58249","typeString":"contract FetchChainInfoOutput"}},"id":57495,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"4713:18:120","memberName":"preimageOracleImpl","nodeType":"MemberAccess","referencedDeclaration":58097,"src":"4708:23:120","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":57496,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"memberLocation":"4732:8:120","memberName":"selector","nodeType":"MemberAccess","src":"4708:32:120","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},"src":"4700:40:120","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},"falseBody":{"condition":{"commonType":{"typeIdentifier":"t_bytes4","typeString":"bytes4"},"id":57506,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftExpression":{"id":57502,"name":"_sel","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57470,"src":"4819:4:120","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},"nodeType":"BinaryOperation","operator":"==","rightExpression":{"expression":{"expression":{"id":57503,"name":"this","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":-28,"src":"4827:4:120","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$58249","typeString":"contract FetchChainInfoOutput"}},"id":57504,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"4832:18:120","memberName":"addressManagerImpl","nodeType":"MemberAccess","referencedDeclaration":57813,"src":"4827:23:120","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":57505,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"memberLocation":"4851:8:120","memberName":"selector","nodeType":"MemberAccess","src":"4827:32:120","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},"src":"4819:40:120","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},"falseBody":{"condition":{"commonType":{"typeIdentifier":"t_bytes4","typeString":"bytes4"},"id":57515,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftExpression":{"id":57511,"name":"_sel","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57470,"src":"4907:4:120","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},"nodeType":"BinaryOperation","operator":"==","rightExpression":{"expression":{"expression":{"id":57512,"name":"this","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":-28,"src":"4915:4:120","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$58249","typeString":"contract FetchChainInfoOutput"}},"id":57513,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"4920:15:120","memberName":"ethLockboxProxy","nodeType":"MemberAccess","referencedDeclaration":57821,"src":"4915:20:120","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":57514,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"memberLocation":"4936:8:120","memberName":"selector","nodeType":"MemberAccess","src":"4915:29:120","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},"src":"4907:37:120","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},"falseBody":{"condition":{"commonType":{"typeIdentifier":"t_bytes4","typeString":"bytes4"},"id":57524,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftExpression":{"id":57520,"name":"_sel","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57470,"src":"4989:4:120","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},"nodeType":"BinaryOperation","operator":"==","rightExpression":{"expression":{"expression":{"id":57521,"name":"this","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":-28,"src":"4997:4:120","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$58249","typeString":"contract FetchChainInfoOutput"}},"id":57522,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"5002:27:120","memberName":"l1CrossDomainMessengerProxy","nodeType":"MemberAccess","referencedDeclaration":57839,"src":"4997:32:120","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":57523,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"memberLocation":"5030:8:120","memberName":"selector","nodeType":"MemberAccess","src":"4997:41:120","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},"src":"4989:49:120","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},"falseBody":{"condition":{"commonType":{"typeIdentifier":"t_bytes4","typeString":"bytes4"},"id":57533,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftExpression":{"id":57529,"name":"_sel","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57470,"src":"5095:4:120","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},"nodeType":"BinaryOperation","operator":"==","rightExpression":{"expression":{"expression":{"id":57530,"name":"this","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":-28,"src":"5103:4:120","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$58249","typeString":"contract FetchChainInfoOutput"}},"id":57531,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"5108:19:120","memberName":"l1Erc721BridgeProxy","nodeType":"MemberAccess","referencedDeclaration":57857,"src":"5103:24:120","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":57532,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"memberLocation":"5128:8:120","memberName":"selector","nodeType":"MemberAccess","src":"5103:33:120","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},"src":"5095:41:120","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},"falseBody":{"condition":{"commonType":{"typeIdentifier":"t_bytes4","typeString":"bytes4"},"id":57542,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftExpression":{"id":57538,"name":"_sel","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57470,"src":"5185:4:120","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},"nodeType":"BinaryOperation","operator":"==","rightExpression":{"expression":{"expression":{"id":57539,"name":"this","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":-28,"src":"5193:4:120","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$58249","typeString":"contract FetchChainInfoOutput"}},"id":57540,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"5198:21:120","memberName":"l1StandardBridgeProxy","nodeType":"MemberAccess","referencedDeclaration":57875,"src":"5193:26:120","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":57541,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"memberLocation":"5220:8:120","memberName":"selector","nodeType":"MemberAccess","src":"5193:35:120","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},"src":"5185:43:120","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},"falseBody":{"condition":{"commonType":{"typeIdentifier":"t_bytes4","typeString":"bytes4"},"id":57551,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftExpression":{"id":57547,"name":"_sel","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57470,"src":"5279:4:120","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},"nodeType":"BinaryOperation","operator":"==","rightExpression":{"expression":{"expression":{"id":57548,"name":"this","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":-28,"src":"5287:4:120","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$58249","typeString":"contract FetchChainInfoOutput"}},"id":57549,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"5292:19:120","memberName":"l2OutputOracleProxy","nodeType":"MemberAccess","referencedDeclaration":57893,"src":"5287:24:120","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":57550,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"memberLocation":"5312:8:120","memberName":"selector","nodeType":"MemberAccess","src":"5287:33:120","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},"src":"5279:41:120","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},"falseBody":{"condition":{"commonType":{"typeIdentifier":"t_bytes4","typeString":"bytes4"},"id":57560,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftExpression":{"id":57556,"name":"_sel","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57470,"src":"5369:4:120","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},"nodeType":"BinaryOperation","operator":"==","rightExpression":{"expression":{"expression":{"id":57557,"name":"this","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":-28,"src":"5377:4:120","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$58249","typeString":"contract FetchChainInfoOutput"}},"id":57558,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"5382:33:120","memberName":"optimismMintableErc20FactoryProxy","nodeType":"MemberAccess","referencedDeclaration":57911,"src":"5377:38:120","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":57559,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"memberLocation":"5416:8:120","memberName":"selector","nodeType":"MemberAccess","src":"5377:47:120","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},"src":"5369:55:120","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},"falseBody":{"condition":{"commonType":{"typeIdentifier":"t_bytes4","typeString":"bytes4"},"id":57569,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftExpression":{"id":57565,"name":"_sel","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57470,"src":"5487:4:120","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},"nodeType":"BinaryOperation","operator":"==","rightExpression":{"expression":{"expression":{"id":57566,"name":"this","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":-28,"src":"5495:4:120","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$58249","typeString":"contract FetchChainInfoOutput"}},"id":57567,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"5500:19:120","memberName":"optimismPortalProxy","nodeType":"MemberAccess","referencedDeclaration":57929,"src":"5495:24:120","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":57568,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"memberLocation":"5520:8:120","memberName":"selector","nodeType":"MemberAccess","src":"5495:33:120","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},"src":"5487:41:120","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},"falseBody":{"condition":{"commonType":{"typeIdentifier":"t_bytes4","typeString":"bytes4"},"id":57578,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftExpression":{"id":57574,"name":"_sel","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57470,"src":"5577:4:120","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},"nodeType":"BinaryOperation","operator":"==","rightExpression":{"expression":{"expression":{"id":57575,"name":"this","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":-28,"src":"5585:4:120","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$58249","typeString":"contract FetchChainInfoOutput"}},"id":57576,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"5590:17:120","memberName":"systemConfigProxy","nodeType":"MemberAccess","referencedDeclaration":57947,"src":"5585:22:120","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":57577,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"memberLocation":"5608:8:120","memberName":"selector","nodeType":"MemberAccess","src":"5585:31:120","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},"src":"5577:39:120","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},"falseBody":{"condition":{"commonType":{"typeIdentifier":"t_bytes4","typeString":"bytes4"},"id":57587,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftExpression":{"id":57583,"name":"_sel","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57470,"src":"5663:4:120","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},"nodeType":"BinaryOperation","operator":"==","rightExpression":{"expression":{"expression":{"id":57584,"name":"this","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":-28,"src":"5671:4:120","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$58249","typeString":"contract FetchChainInfoOutput"}},"id":57585,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"5676:21:120","memberName":"opChainProxyAdminImpl","nodeType":"MemberAccess","referencedDeclaration":57965,"src":"5671:26:120","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":57586,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"memberLocation":"5698:8:120","memberName":"selector","nodeType":"MemberAccess","src":"5671:35:120","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},"src":"5663:43:120","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},"falseBody":{"condition":{"commonType":{"typeIdentifier":"t_bytes4","typeString":"bytes4"},"id":57596,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftExpression":{"id":57592,"name":"_sel","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57470,"src":"5757:4:120","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},"nodeType":"BinaryOperation","operator":"==","rightExpression":{"expression":{"expression":{"id":57593,"name":"this","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":-28,"src":"5765:4:120","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$58249","typeString":"contract FetchChainInfoOutput"}},"id":57594,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"5770:24:120","memberName":"anchorStateRegistryProxy","nodeType":"MemberAccess","referencedDeclaration":58001,"src":"5765:29:120","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":57595,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"memberLocation":"5795:8:120","memberName":"selector","nodeType":"MemberAccess","src":"5765:38:120","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},"src":"5757:46:120","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},"falseBody":{"condition":{"commonType":{"typeIdentifier":"t_bytes4","typeString":"bytes4"},"id":57605,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftExpression":{"id":57601,"name":"_sel","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57470,"src":"5857:4:120","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},"nodeType":"BinaryOperation","operator":"==","rightExpression":{"expression":{"expression":{"id":57602,"name":"this","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":-28,"src":"5865:4:120","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$58249","typeString":"contract FetchChainInfoOutput"}},"id":57603,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"5870:32:120","memberName":"delayedWethPermissionedGameProxy","nodeType":"MemberAccess","referencedDeclaration":58009,"src":"5865:37:120","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":57604,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"memberLocation":"5903:8:120","memberName":"selector","nodeType":"MemberAccess","src":"5865:46:120","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},"src":"5857:54:120","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},"falseBody":{"condition":{"commonType":{"typeIdentifier":"t_bytes4","typeString":"bytes4"},"id":57614,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftExpression":{"id":57610,"name":"_sel","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57470,"src":"5973:4:120","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},"nodeType":"BinaryOperation","operator":"==","rightExpression":{"expression":{"expression":{"id":57611,"name":"this","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":-28,"src":"5981:4:120","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$58249","typeString":"contract FetchChainInfoOutput"}},"id":57612,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"5986:34:120","memberName":"delayedWethPermissionlessGameProxy","nodeType":"MemberAccess","referencedDeclaration":58017,"src":"5981:39:120","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":57613,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"memberLocation":"6021:8:120","memberName":"selector","nodeType":"MemberAccess","src":"5981:48:120","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},"src":"5973:56:120","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},"falseBody":{"condition":{"commonType":{"typeIdentifier":"t_bytes4","typeString":"bytes4"},"id":57623,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftExpression":{"id":57619,"name":"_sel","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57470,"src":"6093:4:120","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},"nodeType":"BinaryOperation","operator":"==","rightExpression":{"expression":{"expression":{"id":57620,"name":"this","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":-28,"src":"6101:4:120","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$58249","typeString":"contract FetchChainInfoOutput"}},"id":57621,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"6106:23:120","memberName":"disputeGameFactoryProxy","nodeType":"MemberAccess","referencedDeclaration":58025,"src":"6101:28:120","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":57622,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"memberLocation":"6130:8:120","memberName":"selector","nodeType":"MemberAccess","src":"6101:37:120","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},"src":"6093:45:120","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},"falseBody":{"condition":{"commonType":{"typeIdentifier":"t_bytes4","typeString":"bytes4"},"id":57632,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftExpression":{"id":57628,"name":"_sel","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57470,"src":"6191:4:120","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},"nodeType":"BinaryOperation","operator":"==","rightExpression":{"expression":{"expression":{"id":57629,"name":"this","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":-28,"src":"6199:4:120","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$58249","typeString":"contract FetchChainInfoOutput"}},"id":57630,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"6204:20:120","memberName":"faultDisputeGameImpl","nodeType":"MemberAccess","referencedDeclaration":58043,"src":"6199:25:120","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":57631,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"memberLocation":"6225:8:120","memberName":"selector","nodeType":"MemberAccess","src":"6199:34:120","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},"src":"6191:42:120","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},"falseBody":{"condition":{"commonType":{"typeIdentifier":"t_bytes4","typeString":"bytes4"},"id":57641,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftExpression":{"id":57637,"name":"_sel","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57470,"src":"6283:4:120","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},"nodeType":"BinaryOperation","operator":"==","rightExpression":{"expression":{"expression":{"id":57638,"name":"this","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":-28,"src":"6291:4:120","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$58249","typeString":"contract FetchChainInfoOutput"}},"id":57639,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"6296:27:120","memberName":"permissionedDisputeGameImpl","nodeType":"MemberAccess","referencedDeclaration":58079,"src":"6291:32:120","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":57640,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"memberLocation":"6324:8:120","memberName":"selector","nodeType":"MemberAccess","src":"6291:41:120","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},"src":"6283:49:120","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},"falseBody":{"condition":{"commonType":{"typeIdentifier":"t_bytes4","typeString":"bytes4"},"id":57650,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftExpression":{"id":57646,"name":"_sel","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57470,"src":"6406:4:120","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},"nodeType":"BinaryOperation","operator":"==","rightExpression":{"expression":{"expression":{"id":57647,"name":"this","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":-28,"src":"6414:4:120","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$58249","typeString":"contract FetchChainInfoOutput"}},"id":57648,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"6419:17:120","memberName":"systemConfigOwner","nodeType":"MemberAccess","referencedDeclaration":58115,"src":"6414:22:120","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":57649,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"memberLocation":"6437:8:120","memberName":"selector","nodeType":"MemberAccess","src":"6414:31:120","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},"src":"6406:39:120","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},"falseBody":{"condition":{"commonType":{"typeIdentifier":"t_bytes4","typeString":"bytes4"},"id":57659,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftExpression":{"id":57655,"name":"_sel","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57470,"src":"6492:4:120","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},"nodeType":"BinaryOperation","operator":"==","rightExpression":{"expression":{"expression":{"id":57656,"name":"this","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":-28,"src":"6500:4:120","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$58249","typeString":"contract FetchChainInfoOutput"}},"id":57657,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"6505:22:120","memberName":"opChainProxyAdminOwner","nodeType":"MemberAccess","referencedDeclaration":58133,"src":"6500:27:120","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":57658,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"memberLocation":"6528:8:120","memberName":"selector","nodeType":"MemberAccess","src":"6500:36:120","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},"src":"6492:44:120","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},"falseBody":{"condition":{"commonType":{"typeIdentifier":"t_bytes4","typeString":"bytes4"},"id":57668,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftExpression":{"id":57664,"name":"_sel","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57470,"src":"6588:4:120","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},"nodeType":"BinaryOperation","operator":"==","rightExpression":{"expression":{"expression":{"id":57665,"name":"this","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":-28,"src":"6596:4:120","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$58249","typeString":"contract FetchChainInfoOutput"}},"id":57666,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"6601:15:120","memberName":"opChainGuardian","nodeType":"MemberAccess","referencedDeclaration":58151,"src":"6596:20:120","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":57667,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"memberLocation":"6617:8:120","memberName":"selector","nodeType":"MemberAccess","src":"6596:29:120","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},"src":"6588:37:120","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},"falseBody":{"condition":{"commonType":{"typeIdentifier":"t_bytes4","typeString":"bytes4"},"id":57677,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftExpression":{"id":57673,"name":"_sel","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57470,"src":"6670:4:120","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},"nodeType":"BinaryOperation","operator":"==","rightExpression":{"expression":{"expression":{"id":57674,"name":"this","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":-28,"src":"6678:4:120","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$58249","typeString":"contract FetchChainInfoOutput"}},"id":57675,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"6683:10:120","memberName":"challenger","nodeType":"MemberAccess","referencedDeclaration":58169,"src":"6678:15:120","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":57676,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"memberLocation":"6694:8:120","memberName":"selector","nodeType":"MemberAccess","src":"6678:24:120","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},"src":"6670:32:120","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},"falseBody":{"condition":{"commonType":{"typeIdentifier":"t_bytes4","typeString":"bytes4"},"id":57686,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftExpression":{"id":57682,"name":"_sel","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57470,"src":"6742:4:120","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},"nodeType":"BinaryOperation","operator":"==","rightExpression":{"expression":{"expression":{"id":57683,"name":"this","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":-28,"src":"6750:4:120","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$58249","typeString":"contract FetchChainInfoOutput"}},"id":57684,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"6755:8:120","memberName":"proposer","nodeType":"MemberAccess","referencedDeclaration":58187,"src":"6750:13:120","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":57685,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"memberLocation":"6764:8:120","memberName":"selector","nodeType":"MemberAccess","src":"6750:22:120","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},"src":"6742:30:120","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},"falseBody":{"condition":{"commonType":{"typeIdentifier":"t_bytes4","typeString":"bytes4"},"id":57695,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftExpression":{"id":57691,"name":"_sel","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57470,"src":"6810:4:120","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},"nodeType":"BinaryOperation","operator":"==","rightExpression":{"expression":{"expression":{"id":57692,"name":"this","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":-28,"src":"6818:4:120","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$58249","typeString":"contract FetchChainInfoOutput"}},"id":57693,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"6823:17:120","memberName":"unsafeBlockSigner","nodeType":"MemberAccess","referencedDeclaration":58205,"src":"6818:22:120","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":57694,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"memberLocation":"6841:8:120","memberName":"selector","nodeType":"MemberAccess","src":"6818:31:120","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},"src":"6810:39:120","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},"falseBody":{"condition":{"commonType":{"typeIdentifier":"t_bytes4","typeString":"bytes4"},"id":57704,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftExpression":{"id":57700,"name":"_sel","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57470,"src":"6896:4:120","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},"nodeType":"BinaryOperation","operator":"==","rightExpression":{"expression":{"expression":{"id":57701,"name":"this","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":-28,"src":"6904:4:120","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$58249","typeString":"contract FetchChainInfoOutput"}},"id":57702,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"6909:14:120","memberName":"batchSubmitter","nodeType":"MemberAccess","referencedDeclaration":58223,"src":"6904:19:120","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":57703,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"memberLocation":"6924:8:120","memberName":"selector","nodeType":"MemberAccess","src":"6904:28:120","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},"src":"6896:36:120","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},"falseBody":{"expression":{"arguments":[{"hexValue":"4665746368436861696e496e666f4f75747075743a20756e6b6e6f776e20616464726573732073656c6563746f722074657374","id":57710,"isConstant":false,"isLValue":false,"isPure":true,"kind":"string","lValueRequested":false,"nodeType":"Literal","src":"6979:53:120","typeDescriptions":{"typeIdentifier":"t_stringliteral_8be6a92cba5443877e2b6bededc383e178c3f2718dce3f3864f1721c31f5c065","typeString":"literal_string \"FetchChainInfoOutput: unknown address selector test\""},"value":"FetchChainInfoOutput: unknown address selector test"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_stringliteral_8be6a92cba5443877e2b6bededc383e178c3f2718dce3f3864f1721c31f5c065","typeString":"literal_string \"FetchChainInfoOutput: unknown address selector test\""}],"id":57709,"name":"revert","nodeType":"Identifier","overloadedDeclarations":[-19,-19],"referencedDeclaration":-19,"src":"6972:6:120","typeDescriptions":{"typeIdentifier":"t_function_revert_pure$_t_string_memory_ptr_$returns$__$","typeString":"function (string memory) pure"}},"id":57711,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"6972:61:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":57712,"nodeType":"ExpressionStatement","src":"6972:61:120"},"id":57713,"nodeType":"IfStatement","src":"6892:141:120","trueBody":{"expression":{"id":57707,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftHandSide":{"id":57705,"name":"_batchSubmitter","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57461,"src":"6934:15:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"Assignment","operator":"=","rightHandSide":{"id":57706,"name":"_addr","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57472,"src":"6952:5:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"src":"6934:23:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"id":57708,"nodeType":"ExpressionStatement","src":"6934:23:120"}},"id":57714,"nodeType":"IfStatement","src":"6806:227:120","trueBody":{"expression":{"id":57698,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftHandSide":{"id":57696,"name":"_unsafeBlockSigner","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57459,"src":"6851:18:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"Assignment","operator":"=","rightHandSide":{"id":57697,"name":"_addr","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57472,"src":"6872:5:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"src":"6851:26:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"id":57699,"nodeType":"ExpressionStatement","src":"6851:26:120"}},"id":57715,"nodeType":"IfStatement","src":"6738:295:120","trueBody":{"expression":{"id":57689,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftHandSide":{"id":57687,"name":"_proposer","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57457,"src":"6774:9:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"Assignment","operator":"=","rightHandSide":{"id":57688,"name":"_addr","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57472,"src":"6786:5:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"src":"6774:17:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"id":57690,"nodeType":"ExpressionStatement","src":"6774:17:120"}},"id":57716,"nodeType":"IfStatement","src":"6666:367:120","trueBody":{"expression":{"id":57680,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftHandSide":{"id":57678,"name":"_challenger","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57455,"src":"6704:11:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"Assignment","operator":"=","rightHandSide":{"id":57679,"name":"_addr","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57472,"src":"6718:5:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"src":"6704:19:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"id":57681,"nodeType":"ExpressionStatement","src":"6704:19:120"}},"id":57717,"nodeType":"IfStatement","src":"6584:449:120","trueBody":{"expression":{"id":57671,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftHandSide":{"id":57669,"name":"_opChainGuardian","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57453,"src":"6627:16:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"Assignment","operator":"=","rightHandSide":{"id":57670,"name":"_addr","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57472,"src":"6646:5:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"src":"6627:24:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"id":57672,"nodeType":"ExpressionStatement","src":"6627:24:120"}},"id":57718,"nodeType":"IfStatement","src":"6488:545:120","trueBody":{"expression":{"id":57662,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftHandSide":{"id":57660,"name":"_opChainProxyAdminOwner","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57451,"src":"6538:23:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"Assignment","operator":"=","rightHandSide":{"id":57661,"name":"_addr","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57472,"src":"6564:5:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"src":"6538:31:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"id":57663,"nodeType":"ExpressionStatement","src":"6538:31:120"}},"id":57719,"nodeType":"IfStatement","src":"6402:631:120","trueBody":{"expression":{"id":57653,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftHandSide":{"id":57651,"name":"_systemConfigOwner","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57449,"src":"6447:18:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"Assignment","operator":"=","rightHandSide":{"id":57652,"name":"_addr","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57472,"src":"6468:5:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"src":"6447:26:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"id":57654,"nodeType":"ExpressionStatement","src":"6447:26:120"}},"id":57720,"nodeType":"IfStatement","src":"6279:754:120","trueBody":{"expression":{"id":57644,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftHandSide":{"id":57642,"name":"_permissionedDisputeGameImpl","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57447,"src":"6334:28:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"Assignment","operator":"=","rightHandSide":{"id":57643,"name":"_addr","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57472,"src":"6365:5:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"src":"6334:36:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"id":57645,"nodeType":"ExpressionStatement","src":"6334:36:120"}},"id":57721,"nodeType":"IfStatement","src":"6187:846:120","trueBody":{"expression":{"id":57635,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftHandSide":{"id":57633,"name":"_faultDisputeGameImpl","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57445,"src":"6235:21:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"Assignment","operator":"=","rightHandSide":{"id":57634,"name":"_addr","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57472,"src":"6259:5:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"src":"6235:29:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"id":57636,"nodeType":"ExpressionStatement","src":"6235:29:120"}},"id":57722,"nodeType":"IfStatement","src":"6089:944:120","trueBody":{"expression":{"id":57626,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftHandSide":{"id":57624,"name":"_disputeGameFactoryProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57443,"src":"6140:24:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"Assignment","operator":"=","rightHandSide":{"id":57625,"name":"_addr","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57472,"src":"6167:5:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"src":"6140:32:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"id":57627,"nodeType":"ExpressionStatement","src":"6140:32:120"}},"id":57723,"nodeType":"IfStatement","src":"5969:1064:120","trueBody":{"expression":{"id":57617,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftHandSide":{"id":57615,"name":"_delayedWethPermissionlessGameProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57441,"src":"6031:35:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"Assignment","operator":"=","rightHandSide":{"id":57616,"name":"_addr","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57472,"src":"6069:5:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"src":"6031:43:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"id":57618,"nodeType":"ExpressionStatement","src":"6031:43:120"}},"id":57724,"nodeType":"IfStatement","src":"5853:1180:120","trueBody":{"expression":{"id":57608,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftHandSide":{"id":57606,"name":"_delayedWethPermissionedGameProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57439,"src":"5913:33:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"Assignment","operator":"=","rightHandSide":{"id":57607,"name":"_addr","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57472,"src":"5949:5:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"src":"5913:41:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"id":57609,"nodeType":"ExpressionStatement","src":"5913:41:120"}},"id":57725,"nodeType":"IfStatement","src":"5753:1280:120","trueBody":{"expression":{"id":57599,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftHandSide":{"id":57597,"name":"_anchorStateRegistryProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57437,"src":"5805:25:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"Assignment","operator":"=","rightHandSide":{"id":57598,"name":"_addr","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57472,"src":"5833:5:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"src":"5805:33:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"id":57600,"nodeType":"ExpressionStatement","src":"5805:33:120"}},"id":57726,"nodeType":"IfStatement","src":"5659:1374:120","trueBody":{"expression":{"id":57590,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftHandSide":{"id":57588,"name":"_opChainProxyAdminImpl","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57435,"src":"5708:22:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"Assignment","operator":"=","rightHandSide":{"id":57589,"name":"_addr","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57472,"src":"5733:5:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"src":"5708:30:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"id":57591,"nodeType":"ExpressionStatement","src":"5708:30:120"}},"id":57727,"nodeType":"IfStatement","src":"5573:1460:120","trueBody":{"expression":{"id":57581,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftHandSide":{"id":57579,"name":"_systemConfigProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57433,"src":"5618:18:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"Assignment","operator":"=","rightHandSide":{"id":57580,"name":"_addr","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57472,"src":"5639:5:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"src":"5618:26:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"id":57582,"nodeType":"ExpressionStatement","src":"5618:26:120"}},"id":57728,"nodeType":"IfStatement","src":"5483:1550:120","trueBody":{"expression":{"id":57572,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftHandSide":{"id":57570,"name":"_optimismPortalProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57431,"src":"5530:20:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"Assignment","operator":"=","rightHandSide":{"id":57571,"name":"_addr","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57472,"src":"5553:5:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"src":"5530:28:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"id":57573,"nodeType":"ExpressionStatement","src":"5530:28:120"}},"id":57729,"nodeType":"IfStatement","src":"5365:1668:120","trueBody":{"expression":{"id":57563,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftHandSide":{"id":57561,"name":"_optimismMintableErc20FactoryProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57429,"src":"5426:34:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"Assignment","operator":"=","rightHandSide":{"id":57562,"name":"_addr","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57472,"src":"5463:5:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"src":"5426:42:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"id":57564,"nodeType":"ExpressionStatement","src":"5426:42:120"}},"id":57730,"nodeType":"IfStatement","src":"5275:1758:120","trueBody":{"expression":{"id":57554,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftHandSide":{"id":57552,"name":"_l2OutputOracleProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57427,"src":"5322:20:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"Assignment","operator":"=","rightHandSide":{"id":57553,"name":"_addr","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57472,"src":"5345:5:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"src":"5322:28:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"id":57555,"nodeType":"ExpressionStatement","src":"5322:28:120"}},"id":57731,"nodeType":"IfStatement","src":"5181:1852:120","trueBody":{"expression":{"id":57545,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftHandSide":{"id":57543,"name":"_l1StandardBridgeProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57425,"src":"5230:22:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"Assignment","operator":"=","rightHandSide":{"id":57544,"name":"_addr","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57472,"src":"5255:5:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"src":"5230:30:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"id":57546,"nodeType":"ExpressionStatement","src":"5230:30:120"}},"id":57732,"nodeType":"IfStatement","src":"5091:1942:120","trueBody":{"expression":{"id":57536,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftHandSide":{"id":57534,"name":"_l1Erc721BridgeProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57423,"src":"5138:20:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"Assignment","operator":"=","rightHandSide":{"id":57535,"name":"_addr","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57472,"src":"5161:5:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"src":"5138:28:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"id":57537,"nodeType":"ExpressionStatement","src":"5138:28:120"}},"id":57733,"nodeType":"IfStatement","src":"4985:2048:120","trueBody":{"expression":{"id":57527,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftHandSide":{"id":57525,"name":"_l1CrossDomainMessengerProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57421,"src":"5040:28:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"Assignment","operator":"=","rightHandSide":{"id":57526,"name":"_addr","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57472,"src":"5071:5:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"src":"5040:36:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"id":57528,"nodeType":"ExpressionStatement","src":"5040:36:120"}},"id":57734,"nodeType":"IfStatement","src":"4903:2130:120","trueBody":{"expression":{"id":57518,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftHandSide":{"id":57516,"name":"_ethLockboxProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57419,"src":"4946:16:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"Assignment","operator":"=","rightHandSide":{"id":57517,"name":"_addr","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57472,"src":"4965:5:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"src":"4946:24:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"id":57519,"nodeType":"ExpressionStatement","src":"4946:24:120"}},"id":57735,"nodeType":"IfStatement","src":"4815:2218:120","trueBody":{"expression":{"id":57509,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftHandSide":{"id":57507,"name":"_addressManagerImpl","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57417,"src":"4861:19:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"Assignment","operator":"=","rightHandSide":{"id":57508,"name":"_addr","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57472,"src":"4883:5:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"src":"4861:27:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"id":57510,"nodeType":"ExpressionStatement","src":"4861:27:120"}},"id":57736,"nodeType":"IfStatement","src":"4696:2337:120","trueBody":{"expression":{"id":57500,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftHandSide":{"id":57498,"name":"_preimageOracleImpl","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57415,"src":"4742:19:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"Assignment","operator":"=","rightHandSide":{"id":57499,"name":"_addr","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57472,"src":"4764:5:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"src":"4742:27:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"id":57501,"nodeType":"ExpressionStatement","src":"4742:27:120"}},"id":57737,"nodeType":"IfStatement","src":"4628:2405:120","trueBody":{"expression":{"id":57491,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftHandSide":{"id":57489,"name":"_mipsImpl","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57413,"src":"4664:9:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"Assignment","operator":"=","rightHandSide":{"id":57490,"name":"_addr","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57472,"src":"4676:5:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"src":"4664:17:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"id":57492,"nodeType":"ExpressionStatement","src":"4664:17:120"}},"id":57738,"nodeType":"IfStatement","src":"4495:2538:120","trueBody":{"expression":{"id":57482,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftHandSide":{"id":57480,"name":"_superchainConfigProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57411,"src":"4544:22:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"Assignment","operator":"=","rightHandSide":{"id":57481,"name":"_addr","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57472,"src":"4569:5:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"src":"4544:30:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"id":57483,"nodeType":"ExpressionStatement","src":"4544:30:120"}}]},"functionSelector":"c3e39250","implemented":true,"kind":"function","modifiers":[],"name":"set","nameLocation":"4415:3:120","parameters":{"id":57473,"nodeType":"ParameterList","parameters":[{"constant":false,"id":57470,"mutability":"mutable","name":"_sel","nameLocation":"4426:4:120","nodeType":"VariableDeclaration","scope":57740,"src":"4419:11:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"},"typeName":{"id":57469,"name":"bytes4","nodeType":"ElementaryTypeName","src":"4419:6:120","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},"visibility":"internal"},{"constant":false,"id":57472,"mutability":"mutable","name":"_addr","nameLocation":"4440:5:120","nodeType":"VariableDeclaration","scope":57740,"src":"4432:13:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":57471,"name":"address","nodeType":"ElementaryTypeName","src":"4432:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"4418:28:120"},"returnParameters":{"id":57474,"nodeType":"ParameterList","parameters":[],"src":"4454:0:120"},"scope":58249,"stateMutability":"nonpayable","virtual":false,"visibility":"public"},{"id":57772,"nodeType":"FunctionDefinition","src":"7046:271:120","nodes":[],"body":{"id":57771,"nodeType":"Block","src":"7091:226:120","nodes":[],"statements":[{"condition":{"commonType":{"typeIdentifier":"t_bytes4","typeString":"bytes4"},"id":57751,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftExpression":{"id":57747,"name":"_sel","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57742,"src":"7105:4:120","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},"nodeType":"BinaryOperation","operator":"==","rightExpression":{"expression":{"expression":{"id":57748,"name":"this","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":-28,"src":"7113:4:120","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$58249","typeString":"contract FetchChainInfoOutput"}},"id":57749,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"7118:12:120","memberName":"permissioned","nodeType":"MemberAccess","referencedDeclaration":58231,"src":"7113:17:120","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_bool_$","typeString":"function () view external returns (bool)"}},"id":57750,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"memberLocation":"7131:8:120","memberName":"selector","nodeType":"MemberAccess","src":"7113:26:120","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},"src":"7105:34:120","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},"falseBody":{"condition":{"commonType":{"typeIdentifier":"t_bytes4","typeString":"bytes4"},"id":57760,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftExpression":{"id":57756,"name":"_sel","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57742,"src":"7181:4:120","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},"nodeType":"BinaryOperation","operator":"==","rightExpression":{"expression":{"expression":{"id":57757,"name":"this","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":-28,"src":"7189:4:120","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$58249","typeString":"contract FetchChainInfoOutput"}},"id":57758,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"7194:14:120","memberName":"permissionless","nodeType":"MemberAccess","referencedDeclaration":58239,"src":"7189:19:120","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_bool_$","typeString":"function () view external returns (bool)"}},"id":57759,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"memberLocation":"7209:8:120","memberName":"selector","nodeType":"MemberAccess","src":"7189:28:120","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},"src":"7181:36:120","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},"falseBody":{"expression":{"arguments":[{"hexValue":"4665746368436861696e496e666f4f75747075743a20756e6b6e6f776e20626f6f6c2073656c6563746f72","id":57766,"isConstant":false,"isLValue":false,"isPure":true,"kind":"string","lValueRequested":false,"nodeType":"Literal","src":"7264:45:120","typeDescriptions":{"typeIdentifier":"t_stringliteral_b43e73201a672ac9d292be9f8dc7215ba0fae6d34ae76c7f77ffd9b31af48fae","typeString":"literal_string \"FetchChainInfoOutput: unknown bool selector\""},"value":"FetchChainInfoOutput: unknown bool selector"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_stringliteral_b43e73201a672ac9d292be9f8dc7215ba0fae6d34ae76c7f77ffd9b31af48fae","typeString":"literal_string \"FetchChainInfoOutput: unknown bool selector\""}],"id":57765,"name":"revert","nodeType":"Identifier","overloadedDeclarations":[-19,-19],"referencedDeclaration":-19,"src":"7257:6:120","typeDescriptions":{"typeIdentifier":"t_function_revert_pure$_t_string_memory_ptr_$returns$__$","typeString":"function (string memory) pure"}},"id":57767,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"7257:53:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":57768,"nodeType":"ExpressionStatement","src":"7257:53:120"},"id":57769,"nodeType":"IfStatement","src":"7177:133:120","trueBody":{"expression":{"id":57763,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftHandSide":{"id":57761,"name":"_permissionless","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57465,"src":"7219:15:120","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},"nodeType":"Assignment","operator":"=","rightHandSide":{"id":57762,"name":"_bool","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57744,"src":"7237:5:120","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},"src":"7219:23:120","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},"id":57764,"nodeType":"ExpressionStatement","src":"7219:23:120"}},"id":57770,"nodeType":"IfStatement","src":"7101:209:120","trueBody":{"expression":{"id":57754,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftHandSide":{"id":57752,"name":"_permissioned","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57463,"src":"7141:13:120","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},"nodeType":"Assignment","operator":"=","rightHandSide":{"id":57753,"name":"_bool","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57744,"src":"7157:5:120","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},"src":"7141:21:120","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},"id":57755,"nodeType":"ExpressionStatement","src":"7141:21:120"}}]},"functionSelector":"baa1e15e","implemented":true,"kind":"function","modifiers":[],"name":"set","nameLocation":"7055:3:120","parameters":{"id":57745,"nodeType":"ParameterList","parameters":[{"constant":false,"id":57742,"mutability":"mutable","name":"_sel","nameLocation":"7066:4:120","nodeType":"VariableDeclaration","scope":57772,"src":"7059:11:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"},"typeName":{"id":57741,"name":"bytes4","nodeType":"ElementaryTypeName","src":"7059:6:120","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},"visibility":"internal"},{"constant":false,"id":57744,"mutability":"mutable","name":"_bool","nameLocation":"7077:5:120","nodeType":"VariableDeclaration","scope":57772,"src":"7072:10:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"},"typeName":{"id":57743,"name":"bool","nodeType":"ElementaryTypeName","src":"7072:4:120","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},"visibility":"internal"}],"src":"7058:25:120"},"returnParameters":{"id":57746,"nodeType":"ParameterList","parameters":[],"src":"7091:0:120"},"scope":58249,"stateMutability":"nonpayable","virtual":false,"visibility":"public"},{"id":57795,"nodeType":"FunctionDefinition","src":"7323:217:120","nodes":[],"body":{"id":57794,"nodeType":"Block","src":"7376:164:120","nodes":[],"statements":[{"condition":{"commonType":{"typeIdentifier":"t_bytes4","typeString":"bytes4"},"id":57784,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftExpression":{"id":57780,"name":"_sel","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57774,"src":"7390:4:120","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},"nodeType":"BinaryOperation","operator":"==","rightExpression":{"expression":{"expression":{"id":57781,"name":"this","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":-28,"src":"7398:4:120","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$58249","typeString":"contract FetchChainInfoOutput"}},"id":57782,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"7403:17:120","memberName":"respectedGameType","nodeType":"MemberAccess","referencedDeclaration":58248,"src":"7398:22:120","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_userDefinedValueType$_GameType_$75355_$","typeString":"function () view external returns (GameType)"}},"id":57783,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"memberLocation":"7421:8:120","memberName":"selector","nodeType":"MemberAccess","src":"7398:31:120","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},"src":"7390:39:120","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},"falseBody":{"expression":{"arguments":[{"hexValue":"4665746368436861696e496e666f4f75747075743a20756e6b6e6f776e2047616d65547970652073656c6563746f72","id":57790,"isConstant":false,"isLValue":false,"isPure":true,"kind":"string","lValueRequested":false,"nodeType":"Literal","src":"7483:49:120","typeDescriptions":{"typeIdentifier":"t_stringliteral_520d3d0cced140fee76c803f92d1db783b790e13f72de1e8f8c229c8c8783afc","typeString":"literal_string \"FetchChainInfoOutput: unknown GameType selector\""},"value":"FetchChainInfoOutput: unknown GameType selector"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_stringliteral_520d3d0cced140fee76c803f92d1db783b790e13f72de1e8f8c229c8c8783afc","typeString":"literal_string \"FetchChainInfoOutput: unknown GameType selector\""}],"id":57789,"name":"revert","nodeType":"Identifier","overloadedDeclarations":[-19,-19],"referencedDeclaration":-19,"src":"7476:6:120","typeDescriptions":{"typeIdentifier":"t_function_revert_pure$_t_string_memory_ptr_$returns$__$","typeString":"function (string memory) pure"}},"id":57791,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"7476:57:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":57792,"nodeType":"ExpressionStatement","src":"7476:57:120"},"id":57793,"nodeType":"IfStatement","src":"7386:147:120","trueBody":{"expression":{"id":57787,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftHandSide":{"id":57785,"name":"_respectedGameType","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57468,"src":"7431:18:120","typeDescriptions":{"typeIdentifier":"t_userDefinedValueType$_GameType_$75355","typeString":"GameType"}},"nodeType":"Assignment","operator":"=","rightHandSide":{"id":57786,"name":"_gameType","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57777,"src":"7452:9:120","typeDescriptions":{"typeIdentifier":"t_userDefinedValueType$_GameType_$75355","typeString":"GameType"}},"src":"7431:30:120","typeDescriptions":{"typeIdentifier":"t_userDefinedValueType$_GameType_$75355","typeString":"GameType"}},"id":57788,"nodeType":"ExpressionStatement","src":"7431:30:120"}}]},"functionSelector":"d08d6066","implemented":true,"kind":"function","modifiers":[],"name":"set","nameLocation":"7332:3:120","parameters":{"id":57778,"nodeType":"ParameterList","parameters":[{"constant":false,"id":57774,"mutability":"mutable","name":"_sel","nameLocation":"7343:4:120","nodeType":"VariableDeclaration","scope":57795,"src":"7336:11:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"},"typeName":{"id":57773,"name":"bytes4","nodeType":"ElementaryTypeName","src":"7336:6:120","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},"visibility":"internal"},{"constant":false,"id":57777,"mutability":"mutable","name":"_gameType","nameLocation":"7358:9:120","nodeType":"VariableDeclaration","scope":57795,"src":"7349:18:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_userDefinedValueType$_GameType_$75355","typeString":"GameType"},"typeName":{"id":57776,"nodeType":"UserDefinedTypeName","pathNode":{"id":57775,"name":"GameType","nameLocations":["7349:8:120"],"nodeType":"IdentifierPath","referencedDeclaration":75355,"src":"7349:8:120"},"referencedDeclaration":75355,"src":"7349:8:120","typeDescriptions":{"typeIdentifier":"t_userDefinedValueType$_GameType_$75355","typeString":"GameType"}},"visibility":"internal"}],"src":"7335:33:120"},"returnParameters":{"id":57779,"nodeType":"ParameterList","parameters":[],"src":"7376:0:120"},"scope":58249,"stateMutability":"nonpayable","virtual":false,"visibility":"public"},{"id":57813,"nodeType":"FunctionDefinition","src":"7546:207:120","nodes":[],"body":{"id":57812,"nodeType":"Block","src":"7606:147:120","nodes":[],"statements":[{"expression":{"arguments":[{"commonType":{"typeIdentifier":"t_address","typeString":"address"},"id":57806,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftExpression":{"id":57801,"name":"_addressManagerImpl","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57417,"src":"7624:19:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"BinaryOperation","operator":"!=","rightExpression":{"arguments":[{"hexValue":"30","id":57804,"isConstant":false,"isLValue":false,"isPure":true,"kind":"number","lValueRequested":false,"nodeType":"Literal","src":"7655:1:120","typeDescriptions":{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"},"value":"0"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"}],"id":57803,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"nodeType":"ElementaryTypeNameExpression","src":"7647:7:120","typeDescriptions":{"typeIdentifier":"t_type$_t_address_$","typeString":"type(address)"},"typeName":{"id":57802,"name":"address","nodeType":"ElementaryTypeName","src":"7647:7:120","typeDescriptions":{}}},"id":57805,"isConstant":false,"isLValue":false,"isPure":true,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"7647:10:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"src":"7624:33:120","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},{"hexValue":"4665746368436861696e496e666f4f75747075743a20616464726573734d616e61676572496d706c206e6f7420736574","id":57807,"isConstant":false,"isLValue":false,"isPure":true,"kind":"string","lValueRequested":false,"nodeType":"Literal","src":"7659:50:120","typeDescriptions":{"typeIdentifier":"t_stringliteral_b154041fe6470d62d16e8ad5c6d8e6c50a46e3e155a380b02703b07321b83f6a","typeString":"literal_string \"FetchChainInfoOutput: addressManagerImpl not set\""},"value":"FetchChainInfoOutput: addressManagerImpl not set"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_bool","typeString":"bool"},{"typeIdentifier":"t_stringliteral_b154041fe6470d62d16e8ad5c6d8e6c50a46e3e155a380b02703b07321b83f6a","typeString":"literal_string \"FetchChainInfoOutput: addressManagerImpl not set\""}],"id":57800,"name":"require","nodeType":"Identifier","overloadedDeclarations":[-18,-18],"referencedDeclaration":-18,"src":"7616:7:120","typeDescriptions":{"typeIdentifier":"t_function_require_pure$_t_bool_$_t_string_memory_ptr_$returns$__$","typeString":"function (bool,string memory) pure"}},"id":57808,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"7616:94:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":57809,"nodeType":"ExpressionStatement","src":"7616:94:120"},{"expression":{"id":57810,"name":"_addressManagerImpl","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57417,"src":"7727:19:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"functionReturnParameters":57799,"id":57811,"nodeType":"Return","src":"7720:26:120"}]},"functionSelector":"bd366b8f","implemented":true,"kind":"function","modifiers":[],"name":"addressManagerImpl","nameLocation":"7555:18:120","parameters":{"id":57796,"nodeType":"ParameterList","parameters":[],"src":"7573:2:120"},"returnParameters":{"id":57799,"nodeType":"ParameterList","parameters":[{"constant":false,"id":57798,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":57813,"src":"7597:7:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":57797,"name":"address","nodeType":"ElementaryTypeName","src":"7597:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"7596:9:120"},"scope":58249,"stateMutability":"view","virtual":false,"visibility":"public"},{"id":57821,"nodeType":"FunctionDefinition","src":"7759:97:120","nodes":[],"body":{"id":57820,"nodeType":"Block","src":"7816:40:120","nodes":[],"statements":[{"expression":{"id":57818,"name":"_ethLockboxProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57419,"src":"7833:16:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"functionReturnParameters":57817,"id":57819,"nodeType":"Return","src":"7826:23:120"}]},"functionSelector":"f646b07c","implemented":true,"kind":"function","modifiers":[],"name":"ethLockboxProxy","nameLocation":"7768:15:120","parameters":{"id":57814,"nodeType":"ParameterList","parameters":[],"src":"7783:2:120"},"returnParameters":{"id":57817,"nodeType":"ParameterList","parameters":[{"constant":false,"id":57816,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":57821,"src":"7807:7:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":57815,"name":"address","nodeType":"ElementaryTypeName","src":"7807:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"7806:9:120"},"scope":58249,"stateMutability":"view","virtual":false,"visibility":"public"},{"id":57839,"nodeType":"FunctionDefinition","src":"7862:243:120","nodes":[],"body":{"id":57838,"nodeType":"Block","src":"7931:174:120","nodes":[],"statements":[{"expression":{"arguments":[{"commonType":{"typeIdentifier":"t_address","typeString":"address"},"id":57832,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftExpression":{"id":57827,"name":"_l1CrossDomainMessengerProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57421,"src":"7949:28:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"BinaryOperation","operator":"!=","rightExpression":{"arguments":[{"hexValue":"30","id":57830,"isConstant":false,"isLValue":false,"isPure":true,"kind":"number","lValueRequested":false,"nodeType":"Literal","src":"7989:1:120","typeDescriptions":{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"},"value":"0"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"}],"id":57829,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"nodeType":"ElementaryTypeNameExpression","src":"7981:7:120","typeDescriptions":{"typeIdentifier":"t_type$_t_address_$","typeString":"type(address)"},"typeName":{"id":57828,"name":"address","nodeType":"ElementaryTypeName","src":"7981:7:120","typeDescriptions":{}}},"id":57831,"isConstant":false,"isLValue":false,"isPure":true,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"7981:10:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"src":"7949:42:120","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},{"hexValue":"4665746368436861696e496e666f4f75747075743a206c3143726f7373446f6d61696e4d657373656e67657250726f7879206e6f7420736574","id":57833,"isConstant":false,"isLValue":false,"isPure":true,"kind":"string","lValueRequested":false,"nodeType":"Literal","src":"7993:59:120","typeDescriptions":{"typeIdentifier":"t_stringliteral_c51216a9bdef996dd7040e19ba4fe817587273a187f1f145abfd19b1308df5eb","typeString":"literal_string \"FetchChainInfoOutput: l1CrossDomainMessengerProxy not set\""},"value":"FetchChainInfoOutput: l1CrossDomainMessengerProxy not set"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_bool","typeString":"bool"},{"typeIdentifier":"t_stringliteral_c51216a9bdef996dd7040e19ba4fe817587273a187f1f145abfd19b1308df5eb","typeString":"literal_string \"FetchChainInfoOutput: l1CrossDomainMessengerProxy not set\""}],"id":57826,"name":"require","nodeType":"Identifier","overloadedDeclarations":[-18,-18],"referencedDeclaration":-18,"src":"7941:7:120","typeDescriptions":{"typeIdentifier":"t_function_require_pure$_t_bool_$_t_string_memory_ptr_$returns$__$","typeString":"function (bool,string memory) pure"}},"id":57834,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"7941:112:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":57835,"nodeType":"ExpressionStatement","src":"7941:112:120"},{"expression":{"id":57836,"name":"_l1CrossDomainMessengerProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57421,"src":"8070:28:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"functionReturnParameters":57825,"id":57837,"nodeType":"Return","src":"8063:35:120"}]},"functionSelector":"54729cfb","implemented":true,"kind":"function","modifiers":[],"name":"l1CrossDomainMessengerProxy","nameLocation":"7871:27:120","parameters":{"id":57822,"nodeType":"ParameterList","parameters":[],"src":"7898:2:120"},"returnParameters":{"id":57825,"nodeType":"ParameterList","parameters":[{"constant":false,"id":57824,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":57839,"src":"7922:7:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":57823,"name":"address","nodeType":"ElementaryTypeName","src":"7922:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"7921:9:120"},"scope":58249,"stateMutability":"view","virtual":false,"visibility":"public"},{"id":57857,"nodeType":"FunctionDefinition","src":"8111:211:120","nodes":[],"body":{"id":57856,"nodeType":"Block","src":"8172:150:120","nodes":[],"statements":[{"expression":{"arguments":[{"commonType":{"typeIdentifier":"t_address","typeString":"address"},"id":57850,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftExpression":{"id":57845,"name":"_l1Erc721BridgeProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57423,"src":"8190:20:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"BinaryOperation","operator":"!=","rightExpression":{"arguments":[{"hexValue":"30","id":57848,"isConstant":false,"isLValue":false,"isPure":true,"kind":"number","lValueRequested":false,"nodeType":"Literal","src":"8222:1:120","typeDescriptions":{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"},"value":"0"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"}],"id":57847,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"nodeType":"ElementaryTypeNameExpression","src":"8214:7:120","typeDescriptions":{"typeIdentifier":"t_type$_t_address_$","typeString":"type(address)"},"typeName":{"id":57846,"name":"address","nodeType":"ElementaryTypeName","src":"8214:7:120","typeDescriptions":{}}},"id":57849,"isConstant":false,"isLValue":false,"isPure":true,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"8214:10:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"src":"8190:34:120","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},{"hexValue":"4665746368436861696e496e666f4f75747075743a206c3145726337323142726964676550726f7879206e6f7420736574","id":57851,"isConstant":false,"isLValue":false,"isPure":true,"kind":"string","lValueRequested":false,"nodeType":"Literal","src":"8226:51:120","typeDescriptions":{"typeIdentifier":"t_stringliteral_bdf5319949d8561b59a02fe667aa58fca11f5f8571bc18997b0bc0ac582aece7","typeString":"literal_string \"FetchChainInfoOutput: l1Erc721BridgeProxy not set\""},"value":"FetchChainInfoOutput: l1Erc721BridgeProxy not set"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_bool","typeString":"bool"},{"typeIdentifier":"t_stringliteral_bdf5319949d8561b59a02fe667aa58fca11f5f8571bc18997b0bc0ac582aece7","typeString":"literal_string \"FetchChainInfoOutput: l1Erc721BridgeProxy not set\""}],"id":57844,"name":"require","nodeType":"Identifier","overloadedDeclarations":[-18,-18],"referencedDeclaration":-18,"src":"8182:7:120","typeDescriptions":{"typeIdentifier":"t_function_require_pure$_t_bool_$_t_string_memory_ptr_$returns$__$","typeString":"function (bool,string memory) pure"}},"id":57852,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"8182:96:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":57853,"nodeType":"ExpressionStatement","src":"8182:96:120"},{"expression":{"id":57854,"name":"_l1Erc721BridgeProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57423,"src":"8295:20:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"functionReturnParameters":57843,"id":57855,"nodeType":"Return","src":"8288:27:120"}]},"functionSelector":"ebfa8409","implemented":true,"kind":"function","modifiers":[],"name":"l1Erc721BridgeProxy","nameLocation":"8120:19:120","parameters":{"id":57840,"nodeType":"ParameterList","parameters":[],"src":"8139:2:120"},"returnParameters":{"id":57843,"nodeType":"ParameterList","parameters":[{"constant":false,"id":57842,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":57857,"src":"8163:7:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":57841,"name":"address","nodeType":"ElementaryTypeName","src":"8163:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"8162:9:120"},"scope":58249,"stateMutability":"view","virtual":false,"visibility":"public"},{"id":57875,"nodeType":"FunctionDefinition","src":"8328:219:120","nodes":[],"body":{"id":57874,"nodeType":"Block","src":"8391:156:120","nodes":[],"statements":[{"expression":{"arguments":[{"commonType":{"typeIdentifier":"t_address","typeString":"address"},"id":57868,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftExpression":{"id":57863,"name":"_l1StandardBridgeProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57425,"src":"8409:22:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"BinaryOperation","operator":"!=","rightExpression":{"arguments":[{"hexValue":"30","id":57866,"isConstant":false,"isLValue":false,"isPure":true,"kind":"number","lValueRequested":false,"nodeType":"Literal","src":"8443:1:120","typeDescriptions":{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"},"value":"0"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"}],"id":57865,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"nodeType":"ElementaryTypeNameExpression","src":"8435:7:120","typeDescriptions":{"typeIdentifier":"t_type$_t_address_$","typeString":"type(address)"},"typeName":{"id":57864,"name":"address","nodeType":"ElementaryTypeName","src":"8435:7:120","typeDescriptions":{}}},"id":57867,"isConstant":false,"isLValue":false,"isPure":true,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"8435:10:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"src":"8409:36:120","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},{"hexValue":"4665746368436861696e496e666f4f75747075743a206c315374616e6461726442726964676550726f7879206e6f7420736574","id":57869,"isConstant":false,"isLValue":false,"isPure":true,"kind":"string","lValueRequested":false,"nodeType":"Literal","src":"8447:53:120","typeDescriptions":{"typeIdentifier":"t_stringliteral_ab3776e760de395cff3bb935602469d5b7c0bd9b5cfaefde9d221be6524302e1","typeString":"literal_string \"FetchChainInfoOutput: l1StandardBridgeProxy not set\""},"value":"FetchChainInfoOutput: l1StandardBridgeProxy not set"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_bool","typeString":"bool"},{"typeIdentifier":"t_stringliteral_ab3776e760de395cff3bb935602469d5b7c0bd9b5cfaefde9d221be6524302e1","typeString":"literal_string \"FetchChainInfoOutput: l1StandardBridgeProxy not set\""}],"id":57862,"name":"require","nodeType":"Identifier","overloadedDeclarations":[-18,-18],"referencedDeclaration":-18,"src":"8401:7:120","typeDescriptions":{"typeIdentifier":"t_function_require_pure$_t_bool_$_t_string_memory_ptr_$returns$__$","typeString":"function (bool,string memory) pure"}},"id":57870,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"8401:100:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":57871,"nodeType":"ExpressionStatement","src":"8401:100:120"},{"expression":{"id":57872,"name":"_l1StandardBridgeProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57425,"src":"8518:22:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"functionReturnParameters":57861,"id":57873,"nodeType":"Return","src":"8511:29:120"}]},"functionSelector":"102b6069","implemented":true,"kind":"function","modifiers":[],"name":"l1StandardBridgeProxy","nameLocation":"8337:21:120","parameters":{"id":57858,"nodeType":"ParameterList","parameters":[],"src":"8358:2:120"},"returnParameters":{"id":57861,"nodeType":"ParameterList","parameters":[{"constant":false,"id":57860,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":57875,"src":"8382:7:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":57859,"name":"address","nodeType":"ElementaryTypeName","src":"8382:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"8381:9:120"},"scope":58249,"stateMutability":"view","virtual":false,"visibility":"public"},{"id":57893,"nodeType":"FunctionDefinition","src":"8553:211:120","nodes":[],"body":{"id":57892,"nodeType":"Block","src":"8614:150:120","nodes":[],"statements":[{"expression":{"arguments":[{"commonType":{"typeIdentifier":"t_address","typeString":"address"},"id":57886,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftExpression":{"id":57881,"name":"_l2OutputOracleProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57427,"src":"8632:20:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"BinaryOperation","operator":"!=","rightExpression":{"arguments":[{"hexValue":"30","id":57884,"isConstant":false,"isLValue":false,"isPure":true,"kind":"number","lValueRequested":false,"nodeType":"Literal","src":"8664:1:120","typeDescriptions":{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"},"value":"0"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"}],"id":57883,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"nodeType":"ElementaryTypeNameExpression","src":"8656:7:120","typeDescriptions":{"typeIdentifier":"t_type$_t_address_$","typeString":"type(address)"},"typeName":{"id":57882,"name":"address","nodeType":"ElementaryTypeName","src":"8656:7:120","typeDescriptions":{}}},"id":57885,"isConstant":false,"isLValue":false,"isPure":true,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"8656:10:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"src":"8632:34:120","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},{"hexValue":"4665746368436861696e496e666f4f75747075743a206c324f75747075744f7261636c6550726f7879206e6f7420736574","id":57887,"isConstant":false,"isLValue":false,"isPure":true,"kind":"string","lValueRequested":false,"nodeType":"Literal","src":"8668:51:120","typeDescriptions":{"typeIdentifier":"t_stringliteral_2f861759874f8f3e0cfa53ef8dfb0556f88f877edbaf1dbc485fc820d67ac86a","typeString":"literal_string \"FetchChainInfoOutput: l2OutputOracleProxy not set\""},"value":"FetchChainInfoOutput: l2OutputOracleProxy not set"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_bool","typeString":"bool"},{"typeIdentifier":"t_stringliteral_2f861759874f8f3e0cfa53ef8dfb0556f88f877edbaf1dbc485fc820d67ac86a","typeString":"literal_string \"FetchChainInfoOutput: l2OutputOracleProxy not set\""}],"id":57880,"name":"require","nodeType":"Identifier","overloadedDeclarations":[-18,-18],"referencedDeclaration":-18,"src":"8624:7:120","typeDescriptions":{"typeIdentifier":"t_function_require_pure$_t_bool_$_t_string_memory_ptr_$returns$__$","typeString":"function (bool,string memory) pure"}},"id":57888,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"8624:96:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":57889,"nodeType":"ExpressionStatement","src":"8624:96:120"},{"expression":{"id":57890,"name":"_l2OutputOracleProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57427,"src":"8737:20:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"functionReturnParameters":57879,"id":57891,"nodeType":"Return","src":"8730:27:120"}]},"functionSelector":"a2c9a89f","implemented":true,"kind":"function","modifiers":[],"name":"l2OutputOracleProxy","nameLocation":"8562:19:120","parameters":{"id":57876,"nodeType":"ParameterList","parameters":[],"src":"8581:2:120"},"returnParameters":{"id":57879,"nodeType":"ParameterList","parameters":[{"constant":false,"id":57878,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":57893,"src":"8605:7:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":57877,"name":"address","nodeType":"ElementaryTypeName","src":"8605:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"8604:9:120"},"scope":58249,"stateMutability":"view","virtual":false,"visibility":"public"},{"id":57911,"nodeType":"FunctionDefinition","src":"8770:301:120","nodes":[],"body":{"id":57910,"nodeType":"Block","src":"8845:226:120","nodes":[],"statements":[{"expression":{"arguments":[{"commonType":{"typeIdentifier":"t_address","typeString":"address"},"id":57904,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftExpression":{"id":57899,"name":"_optimismMintableErc20FactoryProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57429,"src":"8876:34:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"BinaryOperation","operator":"!=","rightExpression":{"arguments":[{"hexValue":"30","id":57902,"isConstant":false,"isLValue":false,"isPure":true,"kind":"number","lValueRequested":false,"nodeType":"Literal","src":"8922:1:120","typeDescriptions":{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"},"value":"0"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"}],"id":57901,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"nodeType":"ElementaryTypeNameExpression","src":"8914:7:120","typeDescriptions":{"typeIdentifier":"t_type$_t_address_$","typeString":"type(address)"},"typeName":{"id":57900,"name":"address","nodeType":"ElementaryTypeName","src":"8914:7:120","typeDescriptions":{}}},"id":57903,"isConstant":false,"isLValue":false,"isPure":true,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"8914:10:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"src":"8876:48:120","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},{"hexValue":"4665746368436861696e496e666f4f75747075743a206f7074696d69736d4d696e7461626c654572633230466163746f727950726f7879206e6f7420736574","id":57905,"isConstant":false,"isLValue":false,"isPure":true,"kind":"string","lValueRequested":false,"nodeType":"Literal","src":"8938:65:120","typeDescriptions":{"typeIdentifier":"t_stringliteral_58c040fbde84bd4afd9f21f5ba3150dab029d767b65aafdf14512bdafdbd9954","typeString":"literal_string \"FetchChainInfoOutput: optimismMintableErc20FactoryProxy not set\""},"value":"FetchChainInfoOutput: optimismMintableErc20FactoryProxy not set"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_bool","typeString":"bool"},{"typeIdentifier":"t_stringliteral_58c040fbde84bd4afd9f21f5ba3150dab029d767b65aafdf14512bdafdbd9954","typeString":"literal_string \"FetchChainInfoOutput: optimismMintableErc20FactoryProxy not set\""}],"id":57898,"name":"require","nodeType":"Identifier","overloadedDeclarations":[-18,-18],"referencedDeclaration":-18,"src":"8855:7:120","typeDescriptions":{"typeIdentifier":"t_function_require_pure$_t_bool_$_t_string_memory_ptr_$returns$__$","typeString":"function (bool,string memory) pure"}},"id":57906,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"8855:158:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":57907,"nodeType":"ExpressionStatement","src":"8855:158:120"},{"expression":{"id":57908,"name":"_optimismMintableErc20FactoryProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57429,"src":"9030:34:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"functionReturnParameters":57897,"id":57909,"nodeType":"Return","src":"9023:41:120"}]},"functionSelector":"8f20c7e4","implemented":true,"kind":"function","modifiers":[],"name":"optimismMintableErc20FactoryProxy","nameLocation":"8779:33:120","parameters":{"id":57894,"nodeType":"ParameterList","parameters":[],"src":"8812:2:120"},"returnParameters":{"id":57897,"nodeType":"ParameterList","parameters":[{"constant":false,"id":57896,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":57911,"src":"8836:7:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":57895,"name":"address","nodeType":"ElementaryTypeName","src":"8836:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"8835:9:120"},"scope":58249,"stateMutability":"view","virtual":false,"visibility":"public"},{"id":57929,"nodeType":"FunctionDefinition","src":"9077:211:120","nodes":[],"body":{"id":57928,"nodeType":"Block","src":"9138:150:120","nodes":[],"statements":[{"expression":{"arguments":[{"commonType":{"typeIdentifier":"t_address","typeString":"address"},"id":57922,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftExpression":{"id":57917,"name":"_optimismPortalProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57431,"src":"9156:20:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"BinaryOperation","operator":"!=","rightExpression":{"arguments":[{"hexValue":"30","id":57920,"isConstant":false,"isLValue":false,"isPure":true,"kind":"number","lValueRequested":false,"nodeType":"Literal","src":"9188:1:120","typeDescriptions":{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"},"value":"0"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"}],"id":57919,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"nodeType":"ElementaryTypeNameExpression","src":"9180:7:120","typeDescriptions":{"typeIdentifier":"t_type$_t_address_$","typeString":"type(address)"},"typeName":{"id":57918,"name":"address","nodeType":"ElementaryTypeName","src":"9180:7:120","typeDescriptions":{}}},"id":57921,"isConstant":false,"isLValue":false,"isPure":true,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"9180:10:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"src":"9156:34:120","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},{"hexValue":"4665746368436861696e496e666f4f75747075743a206f7074696d69736d506f7274616c50726f7879206e6f7420736574","id":57923,"isConstant":false,"isLValue":false,"isPure":true,"kind":"string","lValueRequested":false,"nodeType":"Literal","src":"9192:51:120","typeDescriptions":{"typeIdentifier":"t_stringliteral_ef003bab75ab0cfa4ca81f99eb20b37a3fded08fa7502df7d991f596c8680642","typeString":"literal_string \"FetchChainInfoOutput: optimismPortalProxy not set\""},"value":"FetchChainInfoOutput: optimismPortalProxy not set"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_bool","typeString":"bool"},{"typeIdentifier":"t_stringliteral_ef003bab75ab0cfa4ca81f99eb20b37a3fded08fa7502df7d991f596c8680642","typeString":"literal_string \"FetchChainInfoOutput: optimismPortalProxy not set\""}],"id":57916,"name":"require","nodeType":"Identifier","overloadedDeclarations":[-18,-18],"referencedDeclaration":-18,"src":"9148:7:120","typeDescriptions":{"typeIdentifier":"t_function_require_pure$_t_bool_$_t_string_memory_ptr_$returns$__$","typeString":"function (bool,string memory) pure"}},"id":57924,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"9148:96:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":57925,"nodeType":"ExpressionStatement","src":"9148:96:120"},{"expression":{"id":57926,"name":"_optimismPortalProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57431,"src":"9261:20:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"functionReturnParameters":57915,"id":57927,"nodeType":"Return","src":"9254:27:120"}]},"functionSelector":"04451c49","implemented":true,"kind":"function","modifiers":[],"name":"optimismPortalProxy","nameLocation":"9086:19:120","parameters":{"id":57912,"nodeType":"ParameterList","parameters":[],"src":"9105:2:120"},"returnParameters":{"id":57915,"nodeType":"ParameterList","parameters":[{"constant":false,"id":57914,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":57929,"src":"9129:7:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":57913,"name":"address","nodeType":"ElementaryTypeName","src":"9129:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"9128:9:120"},"scope":58249,"stateMutability":"view","virtual":false,"visibility":"public"},{"id":57947,"nodeType":"FunctionDefinition","src":"9294:203:120","nodes":[],"body":{"id":57946,"nodeType":"Block","src":"9353:144:120","nodes":[],"statements":[{"expression":{"arguments":[{"commonType":{"typeIdentifier":"t_address","typeString":"address"},"id":57940,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftExpression":{"id":57935,"name":"_systemConfigProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57433,"src":"9371:18:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"BinaryOperation","operator":"!=","rightExpression":{"arguments":[{"hexValue":"30","id":57938,"isConstant":false,"isLValue":false,"isPure":true,"kind":"number","lValueRequested":false,"nodeType":"Literal","src":"9401:1:120","typeDescriptions":{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"},"value":"0"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"}],"id":57937,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"nodeType":"ElementaryTypeNameExpression","src":"9393:7:120","typeDescriptions":{"typeIdentifier":"t_type$_t_address_$","typeString":"type(address)"},"typeName":{"id":57936,"name":"address","nodeType":"ElementaryTypeName","src":"9393:7:120","typeDescriptions":{}}},"id":57939,"isConstant":false,"isLValue":false,"isPure":true,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"9393:10:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"src":"9371:32:120","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},{"hexValue":"4665746368436861696e496e666f4f75747075743a2073797374656d436f6e66696750726f7879206e6f7420736574","id":57941,"isConstant":false,"isLValue":false,"isPure":true,"kind":"string","lValueRequested":false,"nodeType":"Literal","src":"9405:49:120","typeDescriptions":{"typeIdentifier":"t_stringliteral_09ada010329fb4e012f4c857519ec176efea734f55c01f382f1b6c7bd752716b","typeString":"literal_string \"FetchChainInfoOutput: systemConfigProxy not set\""},"value":"FetchChainInfoOutput: systemConfigProxy not set"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_bool","typeString":"bool"},{"typeIdentifier":"t_stringliteral_09ada010329fb4e012f4c857519ec176efea734f55c01f382f1b6c7bd752716b","typeString":"literal_string \"FetchChainInfoOutput: systemConfigProxy not set\""}],"id":57934,"name":"require","nodeType":"Identifier","overloadedDeclarations":[-18,-18],"referencedDeclaration":-18,"src":"9363:7:120","typeDescriptions":{"typeIdentifier":"t_function_require_pure$_t_bool_$_t_string_memory_ptr_$returns$__$","typeString":"function (bool,string memory) pure"}},"id":57942,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"9363:92:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":57943,"nodeType":"ExpressionStatement","src":"9363:92:120"},{"expression":{"id":57944,"name":"_systemConfigProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57433,"src":"9472:18:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"functionReturnParameters":57933,"id":57945,"nodeType":"Return","src":"9465:25:120"}]},"functionSelector":"c17db6e3","implemented":true,"kind":"function","modifiers":[],"name":"systemConfigProxy","nameLocation":"9303:17:120","parameters":{"id":57930,"nodeType":"ParameterList","parameters":[],"src":"9320:2:120"},"returnParameters":{"id":57933,"nodeType":"ParameterList","parameters":[{"constant":false,"id":57932,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":57947,"src":"9344:7:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":57931,"name":"address","nodeType":"ElementaryTypeName","src":"9344:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"9343:9:120"},"scope":58249,"stateMutability":"view","virtual":false,"visibility":"public"},{"id":57965,"nodeType":"FunctionDefinition","src":"9503:219:120","nodes":[],"body":{"id":57964,"nodeType":"Block","src":"9566:156:120","nodes":[],"statements":[{"expression":{"arguments":[{"commonType":{"typeIdentifier":"t_address","typeString":"address"},"id":57958,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftExpression":{"id":57953,"name":"_opChainProxyAdminImpl","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57435,"src":"9584:22:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"BinaryOperation","operator":"!=","rightExpression":{"arguments":[{"hexValue":"30","id":57956,"isConstant":false,"isLValue":false,"isPure":true,"kind":"number","lValueRequested":false,"nodeType":"Literal","src":"9618:1:120","typeDescriptions":{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"},"value":"0"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"}],"id":57955,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"nodeType":"ElementaryTypeNameExpression","src":"9610:7:120","typeDescriptions":{"typeIdentifier":"t_type$_t_address_$","typeString":"type(address)"},"typeName":{"id":57954,"name":"address","nodeType":"ElementaryTypeName","src":"9610:7:120","typeDescriptions":{}}},"id":57957,"isConstant":false,"isLValue":false,"isPure":true,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"9610:10:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"src":"9584:36:120","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},{"hexValue":"4665746368436861696e496e666f4f75747075743a206f70436861696e50726f787941646d696e496d706c206e6f7420736574","id":57959,"isConstant":false,"isLValue":false,"isPure":true,"kind":"string","lValueRequested":false,"nodeType":"Literal","src":"9622:53:120","typeDescriptions":{"typeIdentifier":"t_stringliteral_8ebc3647bde8a1129bfd827c7ef2e2d4fea82292bcad8a3c8e3918d70fed8ea8","typeString":"literal_string \"FetchChainInfoOutput: opChainProxyAdminImpl not set\""},"value":"FetchChainInfoOutput: opChainProxyAdminImpl not set"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_bool","typeString":"bool"},{"typeIdentifier":"t_stringliteral_8ebc3647bde8a1129bfd827c7ef2e2d4fea82292bcad8a3c8e3918d70fed8ea8","typeString":"literal_string \"FetchChainInfoOutput: opChainProxyAdminImpl not set\""}],"id":57952,"name":"require","nodeType":"Identifier","overloadedDeclarations":[-18,-18],"referencedDeclaration":-18,"src":"9576:7:120","typeDescriptions":{"typeIdentifier":"t_function_require_pure$_t_bool_$_t_string_memory_ptr_$returns$__$","typeString":"function (bool,string memory) pure"}},"id":57960,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"9576:100:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":57961,"nodeType":"ExpressionStatement","src":"9576:100:120"},{"expression":{"id":57962,"name":"_opChainProxyAdminImpl","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57435,"src":"9693:22:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"functionReturnParameters":57951,"id":57963,"nodeType":"Return","src":"9686:29:120"}]},"functionSelector":"5643665f","implemented":true,"kind":"function","modifiers":[],"name":"opChainProxyAdminImpl","nameLocation":"9512:21:120","parameters":{"id":57948,"nodeType":"ParameterList","parameters":[],"src":"9533:2:120"},"returnParameters":{"id":57951,"nodeType":"ParameterList","parameters":[{"constant":false,"id":57950,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":57965,"src":"9557:7:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":57949,"name":"address","nodeType":"ElementaryTypeName","src":"9557:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"9556:9:120"},"scope":58249,"stateMutability":"view","virtual":false,"visibility":"public"},{"id":57983,"nodeType":"FunctionDefinition","src":"9728:219:120","nodes":[],"body":{"id":57982,"nodeType":"Block","src":"9791:156:120","nodes":[],"statements":[{"expression":{"arguments":[{"commonType":{"typeIdentifier":"t_address","typeString":"address"},"id":57976,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftExpression":{"id":57971,"name":"_superchainConfigProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57411,"src":"9809:22:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"BinaryOperation","operator":"!=","rightExpression":{"arguments":[{"hexValue":"30","id":57974,"isConstant":false,"isLValue":false,"isPure":true,"kind":"number","lValueRequested":false,"nodeType":"Literal","src":"9843:1:120","typeDescriptions":{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"},"value":"0"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"}],"id":57973,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"nodeType":"ElementaryTypeNameExpression","src":"9835:7:120","typeDescriptions":{"typeIdentifier":"t_type$_t_address_$","typeString":"type(address)"},"typeName":{"id":57972,"name":"address","nodeType":"ElementaryTypeName","src":"9835:7:120","typeDescriptions":{}}},"id":57975,"isConstant":false,"isLValue":false,"isPure":true,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"9835:10:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"src":"9809:36:120","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},{"hexValue":"4665746368436861696e496e666f4f75747075743a207375706572636861696e436f6e66696750726f7879206e6f7420736574","id":57977,"isConstant":false,"isLValue":false,"isPure":true,"kind":"string","lValueRequested":false,"nodeType":"Literal","src":"9847:53:120","typeDescriptions":{"typeIdentifier":"t_stringliteral_1b8ad3d2e627aa065fd0fee387bc2d1e5e640177323f7f86733cd157b788a1ce","typeString":"literal_string \"FetchChainInfoOutput: superchainConfigProxy not set\""},"value":"FetchChainInfoOutput: superchainConfigProxy not set"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_bool","typeString":"bool"},{"typeIdentifier":"t_stringliteral_1b8ad3d2e627aa065fd0fee387bc2d1e5e640177323f7f86733cd157b788a1ce","typeString":"literal_string \"FetchChainInfoOutput: superchainConfigProxy not set\""}],"id":57970,"name":"require","nodeType":"Identifier","overloadedDeclarations":[-18,-18],"referencedDeclaration":-18,"src":"9801:7:120","typeDescriptions":{"typeIdentifier":"t_function_require_pure$_t_bool_$_t_string_memory_ptr_$returns$__$","typeString":"function (bool,string memory) pure"}},"id":57978,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"9801:100:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":57979,"nodeType":"ExpressionStatement","src":"9801:100:120"},{"expression":{"id":57980,"name":"_superchainConfigProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57411,"src":"9918:22:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"functionReturnParameters":57969,"id":57981,"nodeType":"Return","src":"9911:29:120"}]},"functionSelector":"84cf2c97","implemented":true,"kind":"function","modifiers":[],"name":"superchainConfigProxy","nameLocation":"9737:21:120","parameters":{"id":57966,"nodeType":"ParameterList","parameters":[],"src":"9758:2:120"},"returnParameters":{"id":57969,"nodeType":"ParameterList","parameters":[{"constant":false,"id":57968,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":57983,"src":"9782:7:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":57967,"name":"address","nodeType":"ElementaryTypeName","src":"9782:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"9781:9:120"},"scope":58249,"stateMutability":"view","virtual":false,"visibility":"public"},{"id":58001,"nodeType":"FunctionDefinition","src":"9953:231:120","nodes":[],"body":{"id":58000,"nodeType":"Block","src":"10019:165:120","nodes":[],"statements":[{"expression":{"arguments":[{"commonType":{"typeIdentifier":"t_address","typeString":"address"},"id":57994,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftExpression":{"id":57989,"name":"_anchorStateRegistryProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57437,"src":"10037:25:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"BinaryOperation","operator":"!=","rightExpression":{"arguments":[{"hexValue":"30","id":57992,"isConstant":false,"isLValue":false,"isPure":true,"kind":"number","lValueRequested":false,"nodeType":"Literal","src":"10074:1:120","typeDescriptions":{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"},"value":"0"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"}],"id":57991,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"nodeType":"ElementaryTypeNameExpression","src":"10066:7:120","typeDescriptions":{"typeIdentifier":"t_type$_t_address_$","typeString":"type(address)"},"typeName":{"id":57990,"name":"address","nodeType":"ElementaryTypeName","src":"10066:7:120","typeDescriptions":{}}},"id":57993,"isConstant":false,"isLValue":false,"isPure":true,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"10066:10:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"src":"10037:39:120","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},{"hexValue":"4665746368436861696e496e666f4f75747075743a20616e63686f725374617465526567697374727950726f7879206e6f7420736574","id":57995,"isConstant":false,"isLValue":false,"isPure":true,"kind":"string","lValueRequested":false,"nodeType":"Literal","src":"10078:56:120","typeDescriptions":{"typeIdentifier":"t_stringliteral_6391076785d7152b9570ce8338ca2e43a749144cb3dbb7f9e5e1de5fabfbae48","typeString":"literal_string \"FetchChainInfoOutput: anchorStateRegistryProxy not set\""},"value":"FetchChainInfoOutput: anchorStateRegistryProxy not set"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_bool","typeString":"bool"},{"typeIdentifier":"t_stringliteral_6391076785d7152b9570ce8338ca2e43a749144cb3dbb7f9e5e1de5fabfbae48","typeString":"literal_string \"FetchChainInfoOutput: anchorStateRegistryProxy not set\""}],"id":57988,"name":"require","nodeType":"Identifier","overloadedDeclarations":[-18,-18],"referencedDeclaration":-18,"src":"10029:7:120","typeDescriptions":{"typeIdentifier":"t_function_require_pure$_t_bool_$_t_string_memory_ptr_$returns$__$","typeString":"function (bool,string memory) pure"}},"id":57996,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"10029:106:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":57997,"nodeType":"ExpressionStatement","src":"10029:106:120"},{"expression":{"id":57998,"name":"_anchorStateRegistryProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57437,"src":"10152:25:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"functionReturnParameters":57987,"id":57999,"nodeType":"Return","src":"10145:32:120"}]},"functionSelector":"35596f76","implemented":true,"kind":"function","modifiers":[],"name":"anchorStateRegistryProxy","nameLocation":"9962:24:120","parameters":{"id":57984,"nodeType":"ParameterList","parameters":[],"src":"9986:2:120"},"returnParameters":{"id":57987,"nodeType":"ParameterList","parameters":[{"constant":false,"id":57986,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":58001,"src":"10010:7:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":57985,"name":"address","nodeType":"ElementaryTypeName","src":"10010:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"10009:9:120"},"scope":58249,"stateMutability":"view","virtual":false,"visibility":"public"},{"id":58009,"nodeType":"FunctionDefinition","src":"10190:131:120","nodes":[],"body":{"id":58008,"nodeType":"Block","src":"10264:57:120","nodes":[],"statements":[{"expression":{"id":58006,"name":"_delayedWethPermissionedGameProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57439,"src":"10281:33:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"functionReturnParameters":58005,"id":58007,"nodeType":"Return","src":"10274:40:120"}]},"functionSelector":"794836d7","implemented":true,"kind":"function","modifiers":[],"name":"delayedWethPermissionedGameProxy","nameLocation":"10199:32:120","parameters":{"id":58002,"nodeType":"ParameterList","parameters":[],"src":"10231:2:120"},"returnParameters":{"id":58005,"nodeType":"ParameterList","parameters":[{"constant":false,"id":58004,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":58009,"src":"10255:7:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":58003,"name":"address","nodeType":"ElementaryTypeName","src":"10255:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"10254:9:120"},"scope":58249,"stateMutability":"view","virtual":false,"visibility":"public"},{"id":58017,"nodeType":"FunctionDefinition","src":"10327:135:120","nodes":[],"body":{"id":58016,"nodeType":"Block","src":"10403:59:120","nodes":[],"statements":[{"expression":{"id":58014,"name":"_delayedWethPermissionlessGameProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57441,"src":"10420:35:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"functionReturnParameters":58013,"id":58015,"nodeType":"Return","src":"10413:42:120"}]},"functionSelector":"97068797","implemented":true,"kind":"function","modifiers":[],"name":"delayedWethPermissionlessGameProxy","nameLocation":"10336:34:120","parameters":{"id":58010,"nodeType":"ParameterList","parameters":[],"src":"10370:2:120"},"returnParameters":{"id":58013,"nodeType":"ParameterList","parameters":[{"constant":false,"id":58012,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":58017,"src":"10394:7:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":58011,"name":"address","nodeType":"ElementaryTypeName","src":"10394:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"10393:9:120"},"scope":58249,"stateMutability":"view","virtual":false,"visibility":"public"},{"id":58025,"nodeType":"FunctionDefinition","src":"10468:113:120","nodes":[],"body":{"id":58024,"nodeType":"Block","src":"10533:48:120","nodes":[],"statements":[{"expression":{"id":58022,"name":"_disputeGameFactoryProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57443,"src":"10550:24:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"functionReturnParameters":58021,"id":58023,"nodeType":"Return","src":"10543:31:120"}]},"functionSelector":"6c4568d1","implemented":true,"kind":"function","modifiers":[],"name":"disputeGameFactoryProxy","nameLocation":"10477:23:120","parameters":{"id":58018,"nodeType":"ParameterList","parameters":[],"src":"10500:2:120"},"returnParameters":{"id":58021,"nodeType":"ParameterList","parameters":[{"constant":false,"id":58020,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":58025,"src":"10524:7:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":58019,"name":"address","nodeType":"ElementaryTypeName","src":"10524:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"10523:9:120"},"scope":58249,"stateMutability":"view","virtual":false,"visibility":"public"},{"id":58043,"nodeType":"FunctionDefinition","src":"10587:215:120","nodes":[],"body":{"id":58042,"nodeType":"Block","src":"10649:153:120","nodes":[],"statements":[{"expression":{"arguments":[{"commonType":{"typeIdentifier":"t_address","typeString":"address"},"id":58036,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftExpression":{"id":58031,"name":"_faultDisputeGameImpl","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57445,"src":"10667:21:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"BinaryOperation","operator":"!=","rightExpression":{"arguments":[{"hexValue":"30","id":58034,"isConstant":false,"isLValue":false,"isPure":true,"kind":"number","lValueRequested":false,"nodeType":"Literal","src":"10700:1:120","typeDescriptions":{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"},"value":"0"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"}],"id":58033,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"nodeType":"ElementaryTypeNameExpression","src":"10692:7:120","typeDescriptions":{"typeIdentifier":"t_type$_t_address_$","typeString":"type(address)"},"typeName":{"id":58032,"name":"address","nodeType":"ElementaryTypeName","src":"10692:7:120","typeDescriptions":{}}},"id":58035,"isConstant":false,"isLValue":false,"isPure":true,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"10692:10:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"src":"10667:35:120","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},{"hexValue":"4665746368436861696e496e666f4f75747075743a206661756c744469737075746547616d65496d706c206e6f7420736574","id":58037,"isConstant":false,"isLValue":false,"isPure":true,"kind":"string","lValueRequested":false,"nodeType":"Literal","src":"10704:52:120","typeDescriptions":{"typeIdentifier":"t_stringliteral_baae18cd0fbc1fbf3c566f5918a7a4a780bb1a3d403d2b65d908417b87c06457","typeString":"literal_string \"FetchChainInfoOutput: faultDisputeGameImpl not set\""},"value":"FetchChainInfoOutput: faultDisputeGameImpl not set"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_bool","typeString":"bool"},{"typeIdentifier":"t_stringliteral_baae18cd0fbc1fbf3c566f5918a7a4a780bb1a3d403d2b65d908417b87c06457","typeString":"literal_string \"FetchChainInfoOutput: faultDisputeGameImpl not set\""}],"id":58030,"name":"require","nodeType":"Identifier","overloadedDeclarations":[-18,-18],"referencedDeclaration":-18,"src":"10659:7:120","typeDescriptions":{"typeIdentifier":"t_function_require_pure$_t_bool_$_t_string_memory_ptr_$returns$__$","typeString":"function (bool,string memory) pure"}},"id":58038,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"10659:98:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":58039,"nodeType":"ExpressionStatement","src":"10659:98:120"},{"expression":{"id":58040,"name":"_faultDisputeGameImpl","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57445,"src":"10774:21:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"functionReturnParameters":58029,"id":58041,"nodeType":"Return","src":"10767:28:120"}]},"functionSelector":"dea21984","implemented":true,"kind":"function","modifiers":[],"name":"faultDisputeGameImpl","nameLocation":"10596:20:120","parameters":{"id":58026,"nodeType":"ParameterList","parameters":[],"src":"10616:2:120"},"returnParameters":{"id":58029,"nodeType":"ParameterList","parameters":[{"constant":false,"id":58028,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":58043,"src":"10640:7:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":58027,"name":"address","nodeType":"ElementaryTypeName","src":"10640:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"10639:9:120"},"scope":58249,"stateMutability":"view","virtual":false,"visibility":"public"},{"id":58061,"nodeType":"FunctionDefinition","src":"10808:167:120","nodes":[],"body":{"id":58060,"nodeType":"Block","src":"10858:117:120","nodes":[],"statements":[{"expression":{"arguments":[{"commonType":{"typeIdentifier":"t_address","typeString":"address"},"id":58054,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftExpression":{"id":58049,"name":"_mipsImpl","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57413,"src":"10876:9:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"BinaryOperation","operator":"!=","rightExpression":{"arguments":[{"hexValue":"30","id":58052,"isConstant":false,"isLValue":false,"isPure":true,"kind":"number","lValueRequested":false,"nodeType":"Literal","src":"10897:1:120","typeDescriptions":{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"},"value":"0"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"}],"id":58051,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"nodeType":"ElementaryTypeNameExpression","src":"10889:7:120","typeDescriptions":{"typeIdentifier":"t_type$_t_address_$","typeString":"type(address)"},"typeName":{"id":58050,"name":"address","nodeType":"ElementaryTypeName","src":"10889:7:120","typeDescriptions":{}}},"id":58053,"isConstant":false,"isLValue":false,"isPure":true,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"10889:10:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"src":"10876:23:120","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},{"hexValue":"4665746368436861696e496e666f4f75747075743a206d697073496d706c206e6f7420736574","id":58055,"isConstant":false,"isLValue":false,"isPure":true,"kind":"string","lValueRequested":false,"nodeType":"Literal","src":"10901:40:120","typeDescriptions":{"typeIdentifier":"t_stringliteral_178867f585ae7eaee2b47a35fdf118ac2b037c387c5937f3b39b1c51f05d7497","typeString":"literal_string \"FetchChainInfoOutput: mipsImpl not set\""},"value":"FetchChainInfoOutput: mipsImpl not set"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_bool","typeString":"bool"},{"typeIdentifier":"t_stringliteral_178867f585ae7eaee2b47a35fdf118ac2b037c387c5937f3b39b1c51f05d7497","typeString":"literal_string \"FetchChainInfoOutput: mipsImpl not set\""}],"id":58048,"name":"require","nodeType":"Identifier","overloadedDeclarations":[-18,-18],"referencedDeclaration":-18,"src":"10868:7:120","typeDescriptions":{"typeIdentifier":"t_function_require_pure$_t_bool_$_t_string_memory_ptr_$returns$__$","typeString":"function (bool,string memory) pure"}},"id":58056,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"10868:74:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":58057,"nodeType":"ExpressionStatement","src":"10868:74:120"},{"expression":{"id":58058,"name":"_mipsImpl","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57413,"src":"10959:9:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"functionReturnParameters":58047,"id":58059,"nodeType":"Return","src":"10952:16:120"}]},"functionSelector":"e303272c","implemented":true,"kind":"function","modifiers":[],"name":"mipsImpl","nameLocation":"10817:8:120","parameters":{"id":58044,"nodeType":"ParameterList","parameters":[],"src":"10825:2:120"},"returnParameters":{"id":58047,"nodeType":"ParameterList","parameters":[{"constant":false,"id":58046,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":58061,"src":"10849:7:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":58045,"name":"address","nodeType":"ElementaryTypeName","src":"10849:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"10848:9:120"},"scope":58249,"stateMutability":"view","virtual":false,"visibility":"public"},{"id":58079,"nodeType":"FunctionDefinition","src":"10981:243:120","nodes":[],"body":{"id":58078,"nodeType":"Block","src":"11050:174:120","nodes":[],"statements":[{"expression":{"arguments":[{"commonType":{"typeIdentifier":"t_address","typeString":"address"},"id":58072,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftExpression":{"id":58067,"name":"_permissionedDisputeGameImpl","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57447,"src":"11068:28:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"BinaryOperation","operator":"!=","rightExpression":{"arguments":[{"hexValue":"30","id":58070,"isConstant":false,"isLValue":false,"isPure":true,"kind":"number","lValueRequested":false,"nodeType":"Literal","src":"11108:1:120","typeDescriptions":{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"},"value":"0"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"}],"id":58069,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"nodeType":"ElementaryTypeNameExpression","src":"11100:7:120","typeDescriptions":{"typeIdentifier":"t_type$_t_address_$","typeString":"type(address)"},"typeName":{"id":58068,"name":"address","nodeType":"ElementaryTypeName","src":"11100:7:120","typeDescriptions":{}}},"id":58071,"isConstant":false,"isLValue":false,"isPure":true,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"11100:10:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"src":"11068:42:120","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},{"hexValue":"4665746368436861696e496e666f4f75747075743a207065726d697373696f6e65644469737075746547616d65496d706c206e6f7420736574","id":58073,"isConstant":false,"isLValue":false,"isPure":true,"kind":"string","lValueRequested":false,"nodeType":"Literal","src":"11112:59:120","typeDescriptions":{"typeIdentifier":"t_stringliteral_234858b97aab3865b03b564f238f9977c62296b1532cb4f809e12678629cae92","typeString":"literal_string \"FetchChainInfoOutput: permissionedDisputeGameImpl not set\""},"value":"FetchChainInfoOutput: permissionedDisputeGameImpl not set"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_bool","typeString":"bool"},{"typeIdentifier":"t_stringliteral_234858b97aab3865b03b564f238f9977c62296b1532cb4f809e12678629cae92","typeString":"literal_string \"FetchChainInfoOutput: permissionedDisputeGameImpl not set\""}],"id":58066,"name":"require","nodeType":"Identifier","overloadedDeclarations":[-18,-18],"referencedDeclaration":-18,"src":"11060:7:120","typeDescriptions":{"typeIdentifier":"t_function_require_pure$_t_bool_$_t_string_memory_ptr_$returns$__$","typeString":"function (bool,string memory) pure"}},"id":58074,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"11060:112:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":58075,"nodeType":"ExpressionStatement","src":"11060:112:120"},{"expression":{"id":58076,"name":"_permissionedDisputeGameImpl","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57447,"src":"11189:28:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"functionReturnParameters":58065,"id":58077,"nodeType":"Return","src":"11182:35:120"}]},"functionSelector":"98ccec3e","implemented":true,"kind":"function","modifiers":[],"name":"permissionedDisputeGameImpl","nameLocation":"10990:27:120","parameters":{"id":58062,"nodeType":"ParameterList","parameters":[],"src":"11017:2:120"},"returnParameters":{"id":58065,"nodeType":"ParameterList","parameters":[{"constant":false,"id":58064,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":58079,"src":"11041:7:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":58063,"name":"address","nodeType":"ElementaryTypeName","src":"11041:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"11040:9:120"},"scope":58249,"stateMutability":"view","virtual":false,"visibility":"public"},{"id":58097,"nodeType":"FunctionDefinition","src":"11230:207:120","nodes":[],"body":{"id":58096,"nodeType":"Block","src":"11290:147:120","nodes":[],"statements":[{"expression":{"arguments":[{"commonType":{"typeIdentifier":"t_address","typeString":"address"},"id":58090,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftExpression":{"id":58085,"name":"_preimageOracleImpl","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57415,"src":"11308:19:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"BinaryOperation","operator":"!=","rightExpression":{"arguments":[{"hexValue":"30","id":58088,"isConstant":false,"isLValue":false,"isPure":true,"kind":"number","lValueRequested":false,"nodeType":"Literal","src":"11339:1:120","typeDescriptions":{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"},"value":"0"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"}],"id":58087,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"nodeType":"ElementaryTypeNameExpression","src":"11331:7:120","typeDescriptions":{"typeIdentifier":"t_type$_t_address_$","typeString":"type(address)"},"typeName":{"id":58086,"name":"address","nodeType":"ElementaryTypeName","src":"11331:7:120","typeDescriptions":{}}},"id":58089,"isConstant":false,"isLValue":false,"isPure":true,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"11331:10:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"src":"11308:33:120","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},{"hexValue":"4665746368436861696e496e666f4f75747075743a20707265696d6167654f7261636c65496d706c206e6f7420736574","id":58091,"isConstant":false,"isLValue":false,"isPure":true,"kind":"string","lValueRequested":false,"nodeType":"Literal","src":"11343:50:120","typeDescriptions":{"typeIdentifier":"t_stringliteral_2434e23032e7627ba1a13e989a9fbe735952d0d6f49e2760e1b1064b8728d538","typeString":"literal_string \"FetchChainInfoOutput: preimageOracleImpl not set\""},"value":"FetchChainInfoOutput: preimageOracleImpl not set"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_bool","typeString":"bool"},{"typeIdentifier":"t_stringliteral_2434e23032e7627ba1a13e989a9fbe735952d0d6f49e2760e1b1064b8728d538","typeString":"literal_string \"FetchChainInfoOutput: preimageOracleImpl not set\""}],"id":58084,"name":"require","nodeType":"Identifier","overloadedDeclarations":[-18,-18],"referencedDeclaration":-18,"src":"11300:7:120","typeDescriptions":{"typeIdentifier":"t_function_require_pure$_t_bool_$_t_string_memory_ptr_$returns$__$","typeString":"function (bool,string memory) pure"}},"id":58092,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"11300:94:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":58093,"nodeType":"ExpressionStatement","src":"11300:94:120"},{"expression":{"id":58094,"name":"_preimageOracleImpl","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57415,"src":"11411:19:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"functionReturnParameters":58083,"id":58095,"nodeType":"Return","src":"11404:26:120"}]},"functionSelector":"d030d2e8","implemented":true,"kind":"function","modifiers":[],"name":"preimageOracleImpl","nameLocation":"11239:18:120","parameters":{"id":58080,"nodeType":"ParameterList","parameters":[],"src":"11257:2:120"},"returnParameters":{"id":58083,"nodeType":"ParameterList","parameters":[{"constant":false,"id":58082,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":58097,"src":"11281:7:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":58081,"name":"address","nodeType":"ElementaryTypeName","src":"11281:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"11280:9:120"},"scope":58249,"stateMutability":"view","virtual":false,"visibility":"public"},{"id":58115,"nodeType":"FunctionDefinition","src":"11443:203:120","nodes":[],"body":{"id":58114,"nodeType":"Block","src":"11502:144:120","nodes":[],"statements":[{"expression":{"arguments":[{"commonType":{"typeIdentifier":"t_address","typeString":"address"},"id":58108,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftExpression":{"id":58103,"name":"_systemConfigOwner","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57449,"src":"11520:18:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"BinaryOperation","operator":"!=","rightExpression":{"arguments":[{"hexValue":"30","id":58106,"isConstant":false,"isLValue":false,"isPure":true,"kind":"number","lValueRequested":false,"nodeType":"Literal","src":"11550:1:120","typeDescriptions":{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"},"value":"0"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"}],"id":58105,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"nodeType":"ElementaryTypeNameExpression","src":"11542:7:120","typeDescriptions":{"typeIdentifier":"t_type$_t_address_$","typeString":"type(address)"},"typeName":{"id":58104,"name":"address","nodeType":"ElementaryTypeName","src":"11542:7:120","typeDescriptions":{}}},"id":58107,"isConstant":false,"isLValue":false,"isPure":true,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"11542:10:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"src":"11520:32:120","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},{"hexValue":"4665746368436861696e496e666f4f75747075743a2073797374656d436f6e6669674f776e6572206e6f7420736574","id":58109,"isConstant":false,"isLValue":false,"isPure":true,"kind":"string","lValueRequested":false,"nodeType":"Literal","src":"11554:49:120","typeDescriptions":{"typeIdentifier":"t_stringliteral_fc7a67f4775c5e19ca3731b64db9f9f8895dcd37a01bc895f1d1806a7f21c916","typeString":"literal_string \"FetchChainInfoOutput: systemConfigOwner not set\""},"value":"FetchChainInfoOutput: systemConfigOwner not set"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_bool","typeString":"bool"},{"typeIdentifier":"t_stringliteral_fc7a67f4775c5e19ca3731b64db9f9f8895dcd37a01bc895f1d1806a7f21c916","typeString":"literal_string \"FetchChainInfoOutput: systemConfigOwner not set\""}],"id":58102,"name":"require","nodeType":"Identifier","overloadedDeclarations":[-18,-18],"referencedDeclaration":-18,"src":"11512:7:120","typeDescriptions":{"typeIdentifier":"t_function_require_pure$_t_bool_$_t_string_memory_ptr_$returns$__$","typeString":"function (bool,string memory) pure"}},"id":58110,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"11512:92:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":58111,"nodeType":"ExpressionStatement","src":"11512:92:120"},{"expression":{"id":58112,"name":"_systemConfigOwner","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57449,"src":"11621:18:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"functionReturnParameters":58101,"id":58113,"nodeType":"Return","src":"11614:25:120"}]},"functionSelector":"1e229b20","implemented":true,"kind":"function","modifiers":[],"name":"systemConfigOwner","nameLocation":"11452:17:120","parameters":{"id":58098,"nodeType":"ParameterList","parameters":[],"src":"11469:2:120"},"returnParameters":{"id":58101,"nodeType":"ParameterList","parameters":[{"constant":false,"id":58100,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":58115,"src":"11493:7:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":58099,"name":"address","nodeType":"ElementaryTypeName","src":"11493:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"11492:9:120"},"scope":58249,"stateMutability":"view","virtual":false,"visibility":"public"},{"id":58133,"nodeType":"FunctionDefinition","src":"11652:223:120","nodes":[],"body":{"id":58132,"nodeType":"Block","src":"11716:159:120","nodes":[],"statements":[{"expression":{"arguments":[{"commonType":{"typeIdentifier":"t_address","typeString":"address"},"id":58126,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftExpression":{"id":58121,"name":"_opChainProxyAdminOwner","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57451,"src":"11734:23:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"BinaryOperation","operator":"!=","rightExpression":{"arguments":[{"hexValue":"30","id":58124,"isConstant":false,"isLValue":false,"isPure":true,"kind":"number","lValueRequested":false,"nodeType":"Literal","src":"11769:1:120","typeDescriptions":{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"},"value":"0"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"}],"id":58123,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"nodeType":"ElementaryTypeNameExpression","src":"11761:7:120","typeDescriptions":{"typeIdentifier":"t_type$_t_address_$","typeString":"type(address)"},"typeName":{"id":58122,"name":"address","nodeType":"ElementaryTypeName","src":"11761:7:120","typeDescriptions":{}}},"id":58125,"isConstant":false,"isLValue":false,"isPure":true,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"11761:10:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"src":"11734:37:120","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},{"hexValue":"4665746368436861696e496e666f4f75747075743a206f70436861696e50726f787941646d696e4f776e6572206e6f7420736574","id":58127,"isConstant":false,"isLValue":false,"isPure":true,"kind":"string","lValueRequested":false,"nodeType":"Literal","src":"11773:54:120","typeDescriptions":{"typeIdentifier":"t_stringliteral_cc12cbf05d2d853ebebe6e25c8b02d2f78d6af131087a61088362ca7d0befc81","typeString":"literal_string \"FetchChainInfoOutput: opChainProxyAdminOwner not set\""},"value":"FetchChainInfoOutput: opChainProxyAdminOwner not set"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_bool","typeString":"bool"},{"typeIdentifier":"t_stringliteral_cc12cbf05d2d853ebebe6e25c8b02d2f78d6af131087a61088362ca7d0befc81","typeString":"literal_string \"FetchChainInfoOutput: opChainProxyAdminOwner not set\""}],"id":58120,"name":"require","nodeType":"Identifier","overloadedDeclarations":[-18,-18],"referencedDeclaration":-18,"src":"11726:7:120","typeDescriptions":{"typeIdentifier":"t_function_require_pure$_t_bool_$_t_string_memory_ptr_$returns$__$","typeString":"function (bool,string memory) pure"}},"id":58128,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"11726:102:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":58129,"nodeType":"ExpressionStatement","src":"11726:102:120"},{"expression":{"id":58130,"name":"_opChainProxyAdminOwner","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57451,"src":"11845:23:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"functionReturnParameters":58119,"id":58131,"nodeType":"Return","src":"11838:30:120"}]},"functionSelector":"1480f0cc","implemented":true,"kind":"function","modifiers":[],"name":"opChainProxyAdminOwner","nameLocation":"11661:22:120","parameters":{"id":58116,"nodeType":"ParameterList","parameters":[],"src":"11683:2:120"},"returnParameters":{"id":58119,"nodeType":"ParameterList","parameters":[{"constant":false,"id":58118,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":58133,"src":"11707:7:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":58117,"name":"address","nodeType":"ElementaryTypeName","src":"11707:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"11706:9:120"},"scope":58249,"stateMutability":"view","virtual":false,"visibility":"public"},{"id":58151,"nodeType":"FunctionDefinition","src":"11881:195:120","nodes":[],"body":{"id":58150,"nodeType":"Block","src":"11938:138:120","nodes":[],"statements":[{"expression":{"arguments":[{"commonType":{"typeIdentifier":"t_address","typeString":"address"},"id":58144,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftExpression":{"id":58139,"name":"_opChainGuardian","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57453,"src":"11956:16:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"BinaryOperation","operator":"!=","rightExpression":{"arguments":[{"hexValue":"30","id":58142,"isConstant":false,"isLValue":false,"isPure":true,"kind":"number","lValueRequested":false,"nodeType":"Literal","src":"11984:1:120","typeDescriptions":{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"},"value":"0"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"}],"id":58141,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"nodeType":"ElementaryTypeNameExpression","src":"11976:7:120","typeDescriptions":{"typeIdentifier":"t_type$_t_address_$","typeString":"type(address)"},"typeName":{"id":58140,"name":"address","nodeType":"ElementaryTypeName","src":"11976:7:120","typeDescriptions":{}}},"id":58143,"isConstant":false,"isLValue":false,"isPure":true,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"11976:10:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"src":"11956:30:120","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},{"hexValue":"4665746368436861696e496e666f4f75747075743a206f70436861696e477561726469616e206e6f7420736574","id":58145,"isConstant":false,"isLValue":false,"isPure":true,"kind":"string","lValueRequested":false,"nodeType":"Literal","src":"11988:47:120","typeDescriptions":{"typeIdentifier":"t_stringliteral_ab71487628da5c56ff40f228ee915a62d6c0a28ab899f48f84343df6dbc48bb7","typeString":"literal_string \"FetchChainInfoOutput: opChainGuardian not set\""},"value":"FetchChainInfoOutput: opChainGuardian not set"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_bool","typeString":"bool"},{"typeIdentifier":"t_stringliteral_ab71487628da5c56ff40f228ee915a62d6c0a28ab899f48f84343df6dbc48bb7","typeString":"literal_string \"FetchChainInfoOutput: opChainGuardian not set\""}],"id":58138,"name":"require","nodeType":"Identifier","overloadedDeclarations":[-18,-18],"referencedDeclaration":-18,"src":"11948:7:120","typeDescriptions":{"typeIdentifier":"t_function_require_pure$_t_bool_$_t_string_memory_ptr_$returns$__$","typeString":"function (bool,string memory) pure"}},"id":58146,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"11948:88:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":58147,"nodeType":"ExpressionStatement","src":"11948:88:120"},{"expression":{"id":58148,"name":"_opChainGuardian","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57453,"src":"12053:16:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"functionReturnParameters":58137,"id":58149,"nodeType":"Return","src":"12046:23:120"}]},"functionSelector":"4bc2695f","implemented":true,"kind":"function","modifiers":[],"name":"opChainGuardian","nameLocation":"11890:15:120","parameters":{"id":58134,"nodeType":"ParameterList","parameters":[],"src":"11905:2:120"},"returnParameters":{"id":58137,"nodeType":"ParameterList","parameters":[{"constant":false,"id":58136,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":58151,"src":"11929:7:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":58135,"name":"address","nodeType":"ElementaryTypeName","src":"11929:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"11928:9:120"},"scope":58249,"stateMutability":"view","virtual":false,"visibility":"public"},{"id":58169,"nodeType":"FunctionDefinition","src":"12082:175:120","nodes":[],"body":{"id":58168,"nodeType":"Block","src":"12134:123:120","nodes":[],"statements":[{"expression":{"arguments":[{"commonType":{"typeIdentifier":"t_address","typeString":"address"},"id":58162,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftExpression":{"id":58157,"name":"_challenger","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57455,"src":"12152:11:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"BinaryOperation","operator":"!=","rightExpression":{"arguments":[{"hexValue":"30","id":58160,"isConstant":false,"isLValue":false,"isPure":true,"kind":"number","lValueRequested":false,"nodeType":"Literal","src":"12175:1:120","typeDescriptions":{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"},"value":"0"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"}],"id":58159,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"nodeType":"ElementaryTypeNameExpression","src":"12167:7:120","typeDescriptions":{"typeIdentifier":"t_type$_t_address_$","typeString":"type(address)"},"typeName":{"id":58158,"name":"address","nodeType":"ElementaryTypeName","src":"12167:7:120","typeDescriptions":{}}},"id":58161,"isConstant":false,"isLValue":false,"isPure":true,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"12167:10:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"src":"12152:25:120","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},{"hexValue":"4665746368436861696e496e666f4f75747075743a206368616c6c656e676572206e6f7420736574","id":58163,"isConstant":false,"isLValue":false,"isPure":true,"kind":"string","lValueRequested":false,"nodeType":"Literal","src":"12179:42:120","typeDescriptions":{"typeIdentifier":"t_stringliteral_d1dd717c39956ee86b1eb77b9f3cb6dbeca6df99b330f67dd364a35a1174c2ce","typeString":"literal_string \"FetchChainInfoOutput: challenger not set\""},"value":"FetchChainInfoOutput: challenger not set"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_bool","typeString":"bool"},{"typeIdentifier":"t_stringliteral_d1dd717c39956ee86b1eb77b9f3cb6dbeca6df99b330f67dd364a35a1174c2ce","typeString":"literal_string \"FetchChainInfoOutput: challenger not set\""}],"id":58156,"name":"require","nodeType":"Identifier","overloadedDeclarations":[-18,-18],"referencedDeclaration":-18,"src":"12144:7:120","typeDescriptions":{"typeIdentifier":"t_function_require_pure$_t_bool_$_t_string_memory_ptr_$returns$__$","typeString":"function (bool,string memory) pure"}},"id":58164,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"12144:78:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":58165,"nodeType":"ExpressionStatement","src":"12144:78:120"},{"expression":{"id":58166,"name":"_challenger","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57455,"src":"12239:11:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"functionReturnParameters":58155,"id":58167,"nodeType":"Return","src":"12232:18:120"}]},"functionSelector":"534db0e2","implemented":true,"kind":"function","modifiers":[],"name":"challenger","nameLocation":"12091:10:120","parameters":{"id":58152,"nodeType":"ParameterList","parameters":[],"src":"12101:2:120"},"returnParameters":{"id":58155,"nodeType":"ParameterList","parameters":[{"constant":false,"id":58154,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":58169,"src":"12125:7:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":58153,"name":"address","nodeType":"ElementaryTypeName","src":"12125:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"12124:9:120"},"scope":58249,"stateMutability":"view","virtual":false,"visibility":"public"},{"id":58187,"nodeType":"FunctionDefinition","src":"12263:167:120","nodes":[],"body":{"id":58186,"nodeType":"Block","src":"12313:117:120","nodes":[],"statements":[{"expression":{"arguments":[{"commonType":{"typeIdentifier":"t_address","typeString":"address"},"id":58180,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftExpression":{"id":58175,"name":"_proposer","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57457,"src":"12331:9:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"BinaryOperation","operator":"!=","rightExpression":{"arguments":[{"hexValue":"30","id":58178,"isConstant":false,"isLValue":false,"isPure":true,"kind":"number","lValueRequested":false,"nodeType":"Literal","src":"12352:1:120","typeDescriptions":{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"},"value":"0"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"}],"id":58177,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"nodeType":"ElementaryTypeNameExpression","src":"12344:7:120","typeDescriptions":{"typeIdentifier":"t_type$_t_address_$","typeString":"type(address)"},"typeName":{"id":58176,"name":"address","nodeType":"ElementaryTypeName","src":"12344:7:120","typeDescriptions":{}}},"id":58179,"isConstant":false,"isLValue":false,"isPure":true,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"12344:10:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"src":"12331:23:120","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},{"hexValue":"4665746368436861696e496e666f4f75747075743a2070726f706f736572206e6f7420736574","id":58181,"isConstant":false,"isLValue":false,"isPure":true,"kind":"string","lValueRequested":false,"nodeType":"Literal","src":"12356:40:120","typeDescriptions":{"typeIdentifier":"t_stringliteral_c4910753f64240b424591ec2bc873e5a728ff321d57cb1a353788ad2c385da71","typeString":"literal_string \"FetchChainInfoOutput: proposer not set\""},"value":"FetchChainInfoOutput: proposer not set"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_bool","typeString":"bool"},{"typeIdentifier":"t_stringliteral_c4910753f64240b424591ec2bc873e5a728ff321d57cb1a353788ad2c385da71","typeString":"literal_string \"FetchChainInfoOutput: proposer not set\""}],"id":58174,"name":"require","nodeType":"Identifier","overloadedDeclarations":[-18,-18],"referencedDeclaration":-18,"src":"12323:7:120","typeDescriptions":{"typeIdentifier":"t_function_require_pure$_t_bool_$_t_string_memory_ptr_$returns$__$","typeString":"function (bool,string memory) pure"}},"id":58182,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"12323:74:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":58183,"nodeType":"ExpressionStatement","src":"12323:74:120"},{"expression":{"id":58184,"name":"_proposer","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57457,"src":"12414:9:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"functionReturnParameters":58173,"id":58185,"nodeType":"Return","src":"12407:16:120"}]},"functionSelector":"a8e4fb90","implemented":true,"kind":"function","modifiers":[],"name":"proposer","nameLocation":"12272:8:120","parameters":{"id":58170,"nodeType":"ParameterList","parameters":[],"src":"12280:2:120"},"returnParameters":{"id":58173,"nodeType":"ParameterList","parameters":[{"constant":false,"id":58172,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":58187,"src":"12304:7:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":58171,"name":"address","nodeType":"ElementaryTypeName","src":"12304:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"12303:9:120"},"scope":58249,"stateMutability":"view","virtual":false,"visibility":"public"},{"id":58205,"nodeType":"FunctionDefinition","src":"12436:203:120","nodes":[],"body":{"id":58204,"nodeType":"Block","src":"12495:144:120","nodes":[],"statements":[{"expression":{"arguments":[{"commonType":{"typeIdentifier":"t_address","typeString":"address"},"id":58198,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftExpression":{"id":58193,"name":"_unsafeBlockSigner","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57459,"src":"12513:18:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"BinaryOperation","operator":"!=","rightExpression":{"arguments":[{"hexValue":"30","id":58196,"isConstant":false,"isLValue":false,"isPure":true,"kind":"number","lValueRequested":false,"nodeType":"Literal","src":"12543:1:120","typeDescriptions":{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"},"value":"0"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"}],"id":58195,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"nodeType":"ElementaryTypeNameExpression","src":"12535:7:120","typeDescriptions":{"typeIdentifier":"t_type$_t_address_$","typeString":"type(address)"},"typeName":{"id":58194,"name":"address","nodeType":"ElementaryTypeName","src":"12535:7:120","typeDescriptions":{}}},"id":58197,"isConstant":false,"isLValue":false,"isPure":true,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"12535:10:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"src":"12513:32:120","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},{"hexValue":"4665746368436861696e496e666f4f75747075743a20756e73616665426c6f636b5369676e6572206e6f7420736574","id":58199,"isConstant":false,"isLValue":false,"isPure":true,"kind":"string","lValueRequested":false,"nodeType":"Literal","src":"12547:49:120","typeDescriptions":{"typeIdentifier":"t_stringliteral_c0c85432d1596fb73656e29b64f6ea745166dde4a7fa6163bfe6b285aea851d7","typeString":"literal_string \"FetchChainInfoOutput: unsafeBlockSigner not set\""},"value":"FetchChainInfoOutput: unsafeBlockSigner not set"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_bool","typeString":"bool"},{"typeIdentifier":"t_stringliteral_c0c85432d1596fb73656e29b64f6ea745166dde4a7fa6163bfe6b285aea851d7","typeString":"literal_string \"FetchChainInfoOutput: unsafeBlockSigner not set\""}],"id":58192,"name":"require","nodeType":"Identifier","overloadedDeclarations":[-18,-18],"referencedDeclaration":-18,"src":"12505:7:120","typeDescriptions":{"typeIdentifier":"t_function_require_pure$_t_bool_$_t_string_memory_ptr_$returns$__$","typeString":"function (bool,string memory) pure"}},"id":58200,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"12505:92:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":58201,"nodeType":"ExpressionStatement","src":"12505:92:120"},{"expression":{"id":58202,"name":"_unsafeBlockSigner","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57459,"src":"12614:18:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"functionReturnParameters":58191,"id":58203,"nodeType":"Return","src":"12607:25:120"}]},"functionSelector":"1fd19ee1","implemented":true,"kind":"function","modifiers":[],"name":"unsafeBlockSigner","nameLocation":"12445:17:120","parameters":{"id":58188,"nodeType":"ParameterList","parameters":[],"src":"12462:2:120"},"returnParameters":{"id":58191,"nodeType":"ParameterList","parameters":[{"constant":false,"id":58190,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":58205,"src":"12486:7:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":58189,"name":"address","nodeType":"ElementaryTypeName","src":"12486:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"12485:9:120"},"scope":58249,"stateMutability":"view","virtual":false,"visibility":"public"},{"id":58223,"nodeType":"FunctionDefinition","src":"12645:191:120","nodes":[],"body":{"id":58222,"nodeType":"Block","src":"12701:135:120","nodes":[],"statements":[{"expression":{"arguments":[{"commonType":{"typeIdentifier":"t_address","typeString":"address"},"id":58216,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftExpression":{"id":58211,"name":"_batchSubmitter","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57461,"src":"12719:15:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"BinaryOperation","operator":"!=","rightExpression":{"arguments":[{"hexValue":"30","id":58214,"isConstant":false,"isLValue":false,"isPure":true,"kind":"number","lValueRequested":false,"nodeType":"Literal","src":"12746:1:120","typeDescriptions":{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"},"value":"0"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"}],"id":58213,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"nodeType":"ElementaryTypeNameExpression","src":"12738:7:120","typeDescriptions":{"typeIdentifier":"t_type$_t_address_$","typeString":"type(address)"},"typeName":{"id":58212,"name":"address","nodeType":"ElementaryTypeName","src":"12738:7:120","typeDescriptions":{}}},"id":58215,"isConstant":false,"isLValue":false,"isPure":true,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"12738:10:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"src":"12719:29:120","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},{"hexValue":"4665746368436861696e496e666f4f75747075743a2062617463685375626d6974746572206e6f7420736574","id":58217,"isConstant":false,"isLValue":false,"isPure":true,"kind":"string","lValueRequested":false,"nodeType":"Literal","src":"12750:46:120","typeDescriptions":{"typeIdentifier":"t_stringliteral_dc2094d90bbe21c62e4087e13d121e3f8b0b046ea0a70d61432535290d56a2cc","typeString":"literal_string \"FetchChainInfoOutput: batchSubmitter not set\""},"value":"FetchChainInfoOutput: batchSubmitter not set"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_bool","typeString":"bool"},{"typeIdentifier":"t_stringliteral_dc2094d90bbe21c62e4087e13d121e3f8b0b046ea0a70d61432535290d56a2cc","typeString":"literal_string \"FetchChainInfoOutput: batchSubmitter not set\""}],"id":58210,"name":"require","nodeType":"Identifier","overloadedDeclarations":[-18,-18],"referencedDeclaration":-18,"src":"12711:7:120","typeDescriptions":{"typeIdentifier":"t_function_require_pure$_t_bool_$_t_string_memory_ptr_$returns$__$","typeString":"function (bool,string memory) pure"}},"id":58218,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"12711:86:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":58219,"nodeType":"ExpressionStatement","src":"12711:86:120"},{"expression":{"id":58220,"name":"_batchSubmitter","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57461,"src":"12814:15:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"functionReturnParameters":58209,"id":58221,"nodeType":"Return","src":"12807:22:120"}]},"functionSelector":"fb951e9d","implemented":true,"kind":"function","modifiers":[],"name":"batchSubmitter","nameLocation":"12654:14:120","parameters":{"id":58206,"nodeType":"ParameterList","parameters":[],"src":"12668:2:120"},"returnParameters":{"id":58209,"nodeType":"ParameterList","parameters":[{"constant":false,"id":58208,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":58223,"src":"12692:7:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":58207,"name":"address","nodeType":"ElementaryTypeName","src":"12692:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"12691:9:120"},"scope":58249,"stateMutability":"view","virtual":false,"visibility":"public"},{"id":58231,"nodeType":"FunctionDefinition","src":"12842:88:120","nodes":[],"body":{"id":58230,"nodeType":"Block","src":"12893:37:120","nodes":[],"statements":[{"expression":{"id":58228,"name":"_permissioned","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57463,"src":"12910:13:120","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},"functionReturnParameters":58227,"id":58229,"nodeType":"Return","src":"12903:20:120"}]},"functionSelector":"3cc162f1","implemented":true,"kind":"function","modifiers":[],"name":"permissioned","nameLocation":"12851:12:120","parameters":{"id":58224,"nodeType":"ParameterList","parameters":[],"src":"12863:2:120"},"returnParameters":{"id":58227,"nodeType":"ParameterList","parameters":[{"constant":false,"id":58226,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":58231,"src":"12887:4:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"},"typeName":{"id":58225,"name":"bool","nodeType":"ElementaryTypeName","src":"12887:4:120","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},"visibility":"internal"}],"src":"12886:6:120"},"scope":58249,"stateMutability":"view","virtual":false,"visibility":"public"},{"id":58239,"nodeType":"FunctionDefinition","src":"12936:92:120","nodes":[],"body":{"id":58238,"nodeType":"Block","src":"12989:39:120","nodes":[],"statements":[{"expression":{"id":58236,"name":"_permissionless","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57465,"src":"13006:15:120","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},"functionReturnParameters":58235,"id":58237,"nodeType":"Return","src":"12999:22:120"}]},"functionSelector":"a1256f9f","implemented":true,"kind":"function","modifiers":[],"name":"permissionless","nameLocation":"12945:14:120","parameters":{"id":58232,"nodeType":"ParameterList","parameters":[],"src":"12959:2:120"},"returnParameters":{"id":58235,"nodeType":"ParameterList","parameters":[{"constant":false,"id":58234,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":58239,"src":"12983:4:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"},"typeName":{"id":58233,"name":"bool","nodeType":"ElementaryTypeName","src":"12983:4:120","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},"visibility":"internal"}],"src":"12982:6:120"},"scope":58249,"stateMutability":"view","virtual":false,"visibility":"public"},{"id":58248,"nodeType":"FunctionDefinition","src":"13034:102:120","nodes":[],"body":{"id":58247,"nodeType":"Block","src":"13094:42:120","nodes":[],"statements":[{"expression":{"id":58245,"name":"_respectedGameType","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57468,"src":"13111:18:120","typeDescriptions":{"typeIdentifier":"t_userDefinedValueType$_GameType_$75355","typeString":"GameType"}},"functionReturnParameters":58244,"id":58246,"nodeType":"Return","src":"13104:25:120"}]},"functionSelector":"3c9f397c","implemented":true,"kind":"function","modifiers":[],"name":"respectedGameType","nameLocation":"13043:17:120","parameters":{"id":58240,"nodeType":"ParameterList","parameters":[],"src":"13060:2:120"},"returnParameters":{"id":58244,"nodeType":"ParameterList","parameters":[{"constant":false,"id":58243,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":58248,"src":"13084:8:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_userDefinedValueType$_GameType_$75355","typeString":"GameType"},"typeName":{"id":58242,"nodeType":"UserDefinedTypeName","pathNode":{"id":58241,"name":"GameType","nameLocations":["13084:8:120"],"nodeType":"IdentifierPath","referencedDeclaration":75355,"src":"13084:8:120"},"referencedDeclaration":75355,"src":"13084:8:120","typeDescriptions":{"typeIdentifier":"t_userDefinedValueType$_GameType_$75355","typeString":"GameType"}},"visibility":"internal"}],"src":"13083:10:120"},"scope":58249,"stateMutability":"view","virtual":false,"visibility":"public"}],"abstract":false,"baseContracts":[],"canonicalName":"FetchChainInfoOutput","contractDependencies":[],"contractKind":"contract","fullyImplemented":true,"linearizedBaseContracts":[58249],"name":"FetchChainInfoOutput","nameLocation":"2966:20:120","scope":59300,"usedErrors":[],"usedEvents":[]},{"id":59299,"nodeType":"ContractDefinition","src":"13140:10848:120","nodes":[{"id":58275,"nodeType":"FunctionDefinition","src":"13180:198:120","nodes":[],"body":{"id":58274,"nodeType":"Block","src":"13251:127:120","nodes":[],"statements":[{"expression":{"arguments":[{"id":58261,"name":"_fi","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58254,"src":"13282:3:120","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoInput_$57409","typeString":"contract FetchChainInfoInput"}},{"id":58262,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58257,"src":"13287:3:120","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$58249","typeString":"contract FetchChainInfoOutput"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_contract$_FetchChainInfoInput_$57409","typeString":"contract FetchChainInfoInput"},{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$58249","typeString":"contract FetchChainInfoOutput"}],"id":58260,"name":"_processSystemConfig","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58411,"src":"13261:20:120","typeDescriptions":{"typeIdentifier":"t_function_internal_nonpayable$_t_contract$_FetchChainInfoInput_$57409_$_t_contract$_FetchChainInfoOutput_$58249_$returns$__$","typeString":"function (contract FetchChainInfoInput,contract FetchChainInfoOutput)"}},"id":58263,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"13261:30:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":58264,"nodeType":"ExpressionStatement","src":"13261:30:120"},{"expression":{"arguments":[{"id":58266,"name":"_fi","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58254,"src":"13328:3:120","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoInput_$57409","typeString":"contract FetchChainInfoInput"}},{"id":58267,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58257,"src":"13333:3:120","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$58249","typeString":"contract FetchChainInfoOutput"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_contract$_FetchChainInfoInput_$57409","typeString":"contract FetchChainInfoInput"},{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$58249","typeString":"contract FetchChainInfoOutput"}],"id":58265,"name":"_processMessengerAndPortal","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58528,"src":"13301:26:120","typeDescriptions":{"typeIdentifier":"t_function_internal_nonpayable$_t_contract$_FetchChainInfoInput_$57409_$_t_contract$_FetchChainInfoOutput_$58249_$returns$__$","typeString":"function (contract FetchChainInfoInput,contract FetchChainInfoOutput)"}},"id":58268,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"13301:36:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":58269,"nodeType":"ExpressionStatement","src":"13301:36:120"},{"expression":{"arguments":[{"id":58271,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58257,"src":"13367:3:120","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$58249","typeString":"contract FetchChainInfoOutput"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$58249","typeString":"contract FetchChainInfoOutput"}],"id":58270,"name":"_processFaultProofs","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58878,"src":"13347:19:120","typeDescriptions":{"typeIdentifier":"t_function_internal_nonpayable$_t_contract$_FetchChainInfoOutput_$58249_$returns$__$","typeString":"function (contract FetchChainInfoOutput)"}},"id":58272,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"13347:24:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":58273,"nodeType":"ExpressionStatement","src":"13347:24:120"}]},"functionSelector":"fc4dcacb","implemented":true,"kind":"function","modifiers":[],"name":"run","nameLocation":"13189:3:120","parameters":{"id":58258,"nodeType":"ParameterList","parameters":[{"constant":false,"id":58254,"mutability":"mutable","name":"_fi","nameLocation":"13213:3:120","nodeType":"VariableDeclaration","scope":58275,"src":"13193:23:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoInput_$57409","typeString":"contract FetchChainInfoInput"},"typeName":{"id":58253,"nodeType":"UserDefinedTypeName","pathNode":{"id":58252,"name":"FetchChainInfoInput","nameLocations":["13193:19:120"],"nodeType":"IdentifierPath","referencedDeclaration":57409,"src":"13193:19:120"},"referencedDeclaration":57409,"src":"13193:19:120","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoInput_$57409","typeString":"contract FetchChainInfoInput"}},"visibility":"internal"},{"constant":false,"id":58257,"mutability":"mutable","name":"_fo","nameLocation":"13239:3:120","nodeType":"VariableDeclaration","scope":58275,"src":"13218:24:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$58249","typeString":"contract FetchChainInfoOutput"},"typeName":{"id":58256,"nodeType":"UserDefinedTypeName","pathNode":{"id":58255,"name":"FetchChainInfoOutput","nameLocations":["13218:20:120"],"nodeType":"IdentifierPath","referencedDeclaration":58249,"src":"13218:20:120"},"referencedDeclaration":58249,"src":"13218:20:120","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$58249","typeString":"contract FetchChainInfoOutput"}},"visibility":"internal"}],"src":"13192:51:120"},"returnParameters":{"id":58259,"nodeType":"ParameterList","parameters":[],"src":"13251:0:120"},"scope":59299,"stateMutability":"nonpayable","virtual":false,"visibility":"public"},{"id":58411,"nodeType":"FunctionDefinition","src":"13384:1336:120","nodes":[],"body":{"id":58410,"nodeType":"Block","src":"13474:1246:120","nodes":[],"statements":[{"assignments":[58285],"declarations":[{"constant":false,"id":58285,"mutability":"mutable","name":"systemConfigProxy","nameLocation":"13492:17:120","nodeType":"VariableDeclaration","scope":58410,"src":"13484:25:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":58284,"name":"address","nodeType":"ElementaryTypeName","src":"13484:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"id":58289,"initialValue":{"arguments":[],"expression":{"argumentTypes":[],"expression":{"id":58286,"name":"_fi","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58278,"src":"13512:3:120","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoInput_$57409","typeString":"contract FetchChainInfoInput"}},"id":58287,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"13516:17:120","memberName":"systemConfigProxy","nodeType":"MemberAccess","referencedDeclaration":57390,"src":"13512:21:120","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":58288,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"13512:23:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"VariableDeclarationStatement","src":"13484:51:120"},{"expression":{"arguments":[{"expression":{"expression":{"id":58293,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58281,"src":"13553:3:120","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$58249","typeString":"contract FetchChainInfoOutput"}},"id":58294,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"13557:17:120","memberName":"systemConfigProxy","nodeType":"MemberAccess","referencedDeclaration":57947,"src":"13553:21:120","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":58295,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"13575:8:120","memberName":"selector","nodeType":"MemberAccess","src":"13553:30:120","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},{"id":58296,"name":"systemConfigProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58285,"src":"13585:17:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_bytes4","typeString":"bytes4"},{"typeIdentifier":"t_address","typeString":"address"}],"expression":{"id":58290,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58281,"src":"13545:3:120","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$58249","typeString":"contract FetchChainInfoOutput"}},"id":58292,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"13549:3:120","memberName":"set","nodeType":"MemberAccess","referencedDeclaration":57740,"src":"13545:7:120","typeDescriptions":{"typeIdentifier":"t_function_external_nonpayable$_t_bytes4_$_t_address_$returns$__$","typeString":"function (bytes4,address) external"}},"id":58297,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"13545:58:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":58298,"nodeType":"ExpressionStatement","src":"13545:58:120"},{"assignments":[58300],"declarations":[{"constant":false,"id":58300,"mutability":"mutable","name":"systemConfigOwner","nameLocation":"13622:17:120","nodeType":"VariableDeclaration","scope":58410,"src":"13614:25:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":58299,"name":"address","nodeType":"ElementaryTypeName","src":"13614:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"id":58306,"initialValue":{"arguments":[],"expression":{"argumentTypes":[],"expression":{"arguments":[{"id":58302,"name":"systemConfigProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58285,"src":"13651:17:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_address","typeString":"address"}],"id":58301,"name":"IFetcher","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57326,"src":"13642:8:120","typeDescriptions":{"typeIdentifier":"t_type$_t_contract$_IFetcher_$57326_$","typeString":"type(contract IFetcher)"}},"id":58303,"isConstant":false,"isLValue":false,"isPure":false,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"13642:27:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_contract$_IFetcher_$57326","typeString":"contract IFetcher"}},"id":58304,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"13670:5:120","memberName":"owner","nodeType":"MemberAccess","referencedDeclaration":57315,"src":"13642:33:120","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":58305,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"13642:35:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"VariableDeclarationStatement","src":"13614:63:120"},{"expression":{"arguments":[{"expression":{"expression":{"id":58310,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58281,"src":"13695:3:120","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$58249","typeString":"contract FetchChainInfoOutput"}},"id":58311,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"13699:17:120","memberName":"systemConfigOwner","nodeType":"MemberAccess","referencedDeclaration":58115,"src":"13695:21:120","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":58312,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"13717:8:120","memberName":"selector","nodeType":"MemberAccess","src":"13695:30:120","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},{"id":58313,"name":"systemConfigOwner","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58300,"src":"13727:17:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_bytes4","typeString":"bytes4"},{"typeIdentifier":"t_address","typeString":"address"}],"expression":{"id":58307,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58281,"src":"13687:3:120","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$58249","typeString":"contract FetchChainInfoOutput"}},"id":58309,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"13691:3:120","memberName":"set","nodeType":"MemberAccess","referencedDeclaration":57740,"src":"13687:7:120","typeDescriptions":{"typeIdentifier":"t_function_external_nonpayable$_t_bytes4_$_t_address_$returns$__$","typeString":"function (bytes4,address) external"}},"id":58314,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"13687:58:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":58315,"nodeType":"ExpressionStatement","src":"13687:58:120"},{"assignments":[58317],"declarations":[{"constant":false,"id":58317,"mutability":"mutable","name":"unsafeBlockSigner","nameLocation":"13764:17:120","nodeType":"VariableDeclaration","scope":58410,"src":"13756:25:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":58316,"name":"address","nodeType":"ElementaryTypeName","src":"13756:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"id":58323,"initialValue":{"arguments":[],"expression":{"argumentTypes":[],"expression":{"arguments":[{"id":58319,"name":"systemConfigProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58285,"src":"13793:17:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_address","typeString":"address"}],"id":58318,"name":"IFetcher","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57326,"src":"13784:8:120","typeDescriptions":{"typeIdentifier":"t_type$_t_contract$_IFetcher_$57326_$","typeString":"type(contract IFetcher)"}},"id":58320,"isConstant":false,"isLValue":false,"isPure":false,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"13784:27:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_contract$_IFetcher_$57326","typeString":"contract IFetcher"}},"id":58321,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"13812:17:120","memberName":"unsafeBlockSigner","nodeType":"MemberAccess","referencedDeclaration":57320,"src":"13784:45:120","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":58322,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"13784:47:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"VariableDeclarationStatement","src":"13756:75:120"},{"expression":{"arguments":[{"expression":{"expression":{"id":58327,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58281,"src":"13849:3:120","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$58249","typeString":"contract FetchChainInfoOutput"}},"id":58328,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"13853:17:120","memberName":"unsafeBlockSigner","nodeType":"MemberAccess","referencedDeclaration":58205,"src":"13849:21:120","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":58329,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"13871:8:120","memberName":"selector","nodeType":"MemberAccess","src":"13849:30:120","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},{"id":58330,"name":"unsafeBlockSigner","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58317,"src":"13881:17:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_bytes4","typeString":"bytes4"},{"typeIdentifier":"t_address","typeString":"address"}],"expression":{"id":58324,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58281,"src":"13841:3:120","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$58249","typeString":"contract FetchChainInfoOutput"}},"id":58326,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"13845:3:120","memberName":"set","nodeType":"MemberAccess","referencedDeclaration":57740,"src":"13841:7:120","typeDescriptions":{"typeIdentifier":"t_function_external_nonpayable$_t_bytes4_$_t_address_$returns$__$","typeString":"function (bytes4,address) external"}},"id":58331,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"13841:58:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":58332,"nodeType":"ExpressionStatement","src":"13841:58:120"},{"assignments":[58334],"declarations":[{"constant":false,"id":58334,"mutability":"mutable","name":"batchSubmitter","nameLocation":"13918:14:120","nodeType":"VariableDeclaration","scope":58410,"src":"13910:22:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":58333,"name":"address","nodeType":"ElementaryTypeName","src":"13910:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"id":58338,"initialValue":{"arguments":[{"id":58336,"name":"systemConfigProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58285,"src":"13954:17:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_address","typeString":"address"}],"id":58335,"name":"_getBatchSubmitter","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":59275,"src":"13935:18:120","typeDescriptions":{"typeIdentifier":"t_function_internal_view$_t_address_$returns$_t_address_$","typeString":"function (address) view returns (address)"}},"id":58337,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"13935:37:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"VariableDeclarationStatement","src":"13910:62:120"},{"expression":{"arguments":[{"expression":{"expression":{"id":58342,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58281,"src":"13990:3:120","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$58249","typeString":"contract FetchChainInfoOutput"}},"id":58343,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"13994:14:120","memberName":"batchSubmitter","nodeType":"MemberAccess","referencedDeclaration":58223,"src":"13990:18:120","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":58344,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"14009:8:120","memberName":"selector","nodeType":"MemberAccess","src":"13990:27:120","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},{"id":58345,"name":"batchSubmitter","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58334,"src":"14019:14:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_bytes4","typeString":"bytes4"},{"typeIdentifier":"t_address","typeString":"address"}],"expression":{"id":58339,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58281,"src":"13982:3:120","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$58249","typeString":"contract FetchChainInfoOutput"}},"id":58341,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"13986:3:120","memberName":"set","nodeType":"MemberAccess","referencedDeclaration":57740,"src":"13982:7:120","typeDescriptions":{"typeIdentifier":"t_function_external_nonpayable$_t_bytes4_$_t_address_$returns$__$","typeString":"function (bytes4,address) external"}},"id":58346,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"13982:52:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":58347,"nodeType":"ExpressionStatement","src":"13982:52:120"},{"assignments":[58349],"declarations":[{"constant":false,"id":58349,"mutability":"mutable","name":"opChainProxyAdminImpl","nameLocation":"14053:21:120","nodeType":"VariableDeclaration","scope":58410,"src":"14045:29:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":58348,"name":"address","nodeType":"ElementaryTypeName","src":"14045:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"id":58353,"initialValue":{"arguments":[{"id":58351,"name":"systemConfigProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58285,"src":"14092:17:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_address","typeString":"address"}],"id":58350,"name":"_getProxyAdmin","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":59298,"src":"14077:14:120","typeDescriptions":{"typeIdentifier":"t_function_internal_nonpayable$_t_address_$returns$_t_address_$","typeString":"function (address) returns (address)"}},"id":58352,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"14077:33:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"VariableDeclarationStatement","src":"14045:65:120"},{"expression":{"arguments":[{"expression":{"expression":{"id":58357,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58281,"src":"14128:3:120","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$58249","typeString":"contract FetchChainInfoOutput"}},"id":58358,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"14132:21:120","memberName":"opChainProxyAdminImpl","nodeType":"MemberAccess","referencedDeclaration":57965,"src":"14128:25:120","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":58359,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"14154:8:120","memberName":"selector","nodeType":"MemberAccess","src":"14128:34:120","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},{"id":58360,"name":"opChainProxyAdminImpl","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58349,"src":"14164:21:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_bytes4","typeString":"bytes4"},{"typeIdentifier":"t_address","typeString":"address"}],"expression":{"id":58354,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58281,"src":"14120:3:120","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$58249","typeString":"contract FetchChainInfoOutput"}},"id":58356,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"14124:3:120","memberName":"set","nodeType":"MemberAccess","referencedDeclaration":57740,"src":"14120:7:120","typeDescriptions":{"typeIdentifier":"t_function_external_nonpayable$_t_bytes4_$_t_address_$returns$__$","typeString":"function (bytes4,address) external"}},"id":58361,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"14120:66:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":58362,"nodeType":"ExpressionStatement","src":"14120:66:120"},{"assignments":[58364],"declarations":[{"constant":false,"id":58364,"mutability":"mutable","name":"opChainProxyAdminOwner","nameLocation":"14205:22:120","nodeType":"VariableDeclaration","scope":58410,"src":"14197:30:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":58363,"name":"address","nodeType":"ElementaryTypeName","src":"14197:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"id":58370,"initialValue":{"arguments":[],"expression":{"argumentTypes":[],"expression":{"arguments":[{"id":58366,"name":"opChainProxyAdminImpl","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58349,"src":"14239:21:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_address","typeString":"address"}],"id":58365,"name":"IFetcher","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57326,"src":"14230:8:120","typeDescriptions":{"typeIdentifier":"t_type$_t_contract$_IFetcher_$57326_$","typeString":"type(contract IFetcher)"}},"id":58367,"isConstant":false,"isLValue":false,"isPure":false,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"14230:31:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_contract$_IFetcher_$57326","typeString":"contract IFetcher"}},"id":58368,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"14262:5:120","memberName":"owner","nodeType":"MemberAccess","referencedDeclaration":57315,"src":"14230:37:120","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":58369,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"14230:39:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"VariableDeclarationStatement","src":"14197:72:120"},{"expression":{"arguments":[{"expression":{"expression":{"id":58374,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58281,"src":"14287:3:120","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$58249","typeString":"contract FetchChainInfoOutput"}},"id":58375,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"14291:22:120","memberName":"opChainProxyAdminOwner","nodeType":"MemberAccess","referencedDeclaration":58133,"src":"14287:26:120","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":58376,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"14314:8:120","memberName":"selector","nodeType":"MemberAccess","src":"14287:35:120","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},{"id":58377,"name":"opChainProxyAdminOwner","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58364,"src":"14324:22:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_bytes4","typeString":"bytes4"},{"typeIdentifier":"t_address","typeString":"address"}],"expression":{"id":58371,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58281,"src":"14279:3:120","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$58249","typeString":"contract FetchChainInfoOutput"}},"id":58373,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"14283:3:120","memberName":"set","nodeType":"MemberAccess","referencedDeclaration":57740,"src":"14279:7:120","typeDescriptions":{"typeIdentifier":"t_function_external_nonpayable$_t_bytes4_$_t_address_$returns$__$","typeString":"function (bytes4,address) external"}},"id":58378,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"14279:68:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":58379,"nodeType":"ExpressionStatement","src":"14279:68:120"},{"assignments":[58381],"declarations":[{"constant":false,"id":58381,"mutability":"mutable","name":"l1Erc721BridgeProxy","nameLocation":"14366:19:120","nodeType":"VariableDeclaration","scope":58410,"src":"14358:27:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":58380,"name":"address","nodeType":"ElementaryTypeName","src":"14358:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"id":58385,"initialValue":{"arguments":[{"id":58383,"name":"systemConfigProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58285,"src":"14412:17:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_address","typeString":"address"}],"id":58382,"name":"_getL1ERC721BridgeProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":59031,"src":"14388:23:120","typeDescriptions":{"typeIdentifier":"t_function_internal_view$_t_address_$returns$_t_address_$","typeString":"function (address) view returns (address)"}},"id":58384,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"14388:42:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"VariableDeclarationStatement","src":"14358:72:120"},{"expression":{"arguments":[{"expression":{"expression":{"id":58389,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58281,"src":"14448:3:120","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$58249","typeString":"contract FetchChainInfoOutput"}},"id":58390,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"14452:19:120","memberName":"l1Erc721BridgeProxy","nodeType":"MemberAccess","referencedDeclaration":57857,"src":"14448:23:120","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":58391,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"14472:8:120","memberName":"selector","nodeType":"MemberAccess","src":"14448:32:120","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},{"id":58392,"name":"l1Erc721BridgeProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58381,"src":"14482:19:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_bytes4","typeString":"bytes4"},{"typeIdentifier":"t_address","typeString":"address"}],"expression":{"id":58386,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58281,"src":"14440:3:120","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$58249","typeString":"contract FetchChainInfoOutput"}},"id":58388,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"14444:3:120","memberName":"set","nodeType":"MemberAccess","referencedDeclaration":57740,"src":"14440:7:120","typeDescriptions":{"typeIdentifier":"t_function_external_nonpayable$_t_bytes4_$_t_address_$returns$__$","typeString":"function (bytes4,address) external"}},"id":58393,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"14440:62:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":58394,"nodeType":"ExpressionStatement","src":"14440:62:120"},{"assignments":[58396],"declarations":[{"constant":false,"id":58396,"mutability":"mutable","name":"optimismMintableErc20FactoryProxy","nameLocation":"14521:33:120","nodeType":"VariableDeclaration","scope":58410,"src":"14513:41:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":58395,"name":"address","nodeType":"ElementaryTypeName","src":"14513:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"id":58400,"initialValue":{"arguments":[{"id":58398,"name":"systemConfigProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58285,"src":"14595:17:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_address","typeString":"address"}],"id":58397,"name":"_getOptimismMintableERC20FactoryProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":59059,"src":"14557:37:120","typeDescriptions":{"typeIdentifier":"t_function_internal_view$_t_address_$returns$_t_address_$","typeString":"function (address) view returns (address)"}},"id":58399,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"14557:56:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"VariableDeclarationStatement","src":"14513:100:120"},{"expression":{"arguments":[{"expression":{"expression":{"id":58404,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58281,"src":"14631:3:120","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$58249","typeString":"contract FetchChainInfoOutput"}},"id":58405,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"14635:33:120","memberName":"optimismMintableErc20FactoryProxy","nodeType":"MemberAccess","referencedDeclaration":57911,"src":"14631:37:120","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":58406,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"14669:8:120","memberName":"selector","nodeType":"MemberAccess","src":"14631:46:120","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},{"id":58407,"name":"optimismMintableErc20FactoryProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58396,"src":"14679:33:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_bytes4","typeString":"bytes4"},{"typeIdentifier":"t_address","typeString":"address"}],"expression":{"id":58401,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58281,"src":"14623:3:120","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$58249","typeString":"contract FetchChainInfoOutput"}},"id":58403,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"14627:3:120","memberName":"set","nodeType":"MemberAccess","referencedDeclaration":57740,"src":"14623:7:120","typeDescriptions":{"typeIdentifier":"t_function_external_nonpayable$_t_bytes4_$_t_address_$returns$__$","typeString":"function (bytes4,address) external"}},"id":58408,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"14623:90:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":58409,"nodeType":"ExpressionStatement","src":"14623:90:120"}]},"implemented":true,"kind":"function","modifiers":[],"name":"_processSystemConfig","nameLocation":"13393:20:120","parameters":{"id":58282,"nodeType":"ParameterList","parameters":[{"constant":false,"id":58278,"mutability":"mutable","name":"_fi","nameLocation":"13434:3:120","nodeType":"VariableDeclaration","scope":58411,"src":"13414:23:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoInput_$57409","typeString":"contract FetchChainInfoInput"},"typeName":{"id":58277,"nodeType":"UserDefinedTypeName","pathNode":{"id":58276,"name":"FetchChainInfoInput","nameLocations":["13414:19:120"],"nodeType":"IdentifierPath","referencedDeclaration":57409,"src":"13414:19:120"},"referencedDeclaration":57409,"src":"13414:19:120","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoInput_$57409","typeString":"contract FetchChainInfoInput"}},"visibility":"internal"},{"constant":false,"id":58281,"mutability":"mutable","name":"_fo","nameLocation":"13460:3:120","nodeType":"VariableDeclaration","scope":58411,"src":"13439:24:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$58249","typeString":"contract FetchChainInfoOutput"},"typeName":{"id":58280,"nodeType":"UserDefinedTypeName","pathNode":{"id":58279,"name":"FetchChainInfoOutput","nameLocations":["13439:20:120"],"nodeType":"IdentifierPath","referencedDeclaration":58249,"src":"13439:20:120"},"referencedDeclaration":58249,"src":"13439:20:120","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$58249","typeString":"contract FetchChainInfoOutput"}},"visibility":"internal"}],"src":"13413:51:120"},"returnParameters":{"id":58283,"nodeType":"ParameterList","parameters":[],"src":"13474:0:120"},"scope":59299,"stateMutability":"nonpayable","virtual":false,"visibility":"internal"},{"id":58528,"nodeType":"FunctionDefinition","src":"14726:1190:120","nodes":[],"body":{"id":58527,"nodeType":"Block","src":"14822:1094:120","nodes":[],"statements":[{"assignments":[58421],"declarations":[{"constant":false,"id":58421,"mutability":"mutable","name":"l1StandardBridgeProxy","nameLocation":"14840:21:120","nodeType":"VariableDeclaration","scope":58527,"src":"14832:29:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":58420,"name":"address","nodeType":"ElementaryTypeName","src":"14832:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"id":58425,"initialValue":{"arguments":[],"expression":{"argumentTypes":[],"expression":{"id":58422,"name":"_fi","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58414,"src":"14864:3:120","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoInput_$57409","typeString":"contract FetchChainInfoInput"}},"id":58423,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"14868:21:120","memberName":"l1StandardBridgeProxy","nodeType":"MemberAccess","referencedDeclaration":57408,"src":"14864:25:120","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":58424,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"14864:27:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"VariableDeclarationStatement","src":"14832:59:120"},{"expression":{"arguments":[{"expression":{"expression":{"id":58429,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58417,"src":"14909:3:120","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$58249","typeString":"contract FetchChainInfoOutput"}},"id":58430,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"14913:21:120","memberName":"l1StandardBridgeProxy","nodeType":"MemberAccess","referencedDeclaration":57875,"src":"14909:25:120","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":58431,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"14935:8:120","memberName":"selector","nodeType":"MemberAccess","src":"14909:34:120","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},{"id":58432,"name":"l1StandardBridgeProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58421,"src":"14945:21:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_bytes4","typeString":"bytes4"},{"typeIdentifier":"t_address","typeString":"address"}],"expression":{"id":58426,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58417,"src":"14901:3:120","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$58249","typeString":"contract FetchChainInfoOutput"}},"id":58428,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"14905:3:120","memberName":"set","nodeType":"MemberAccess","referencedDeclaration":57740,"src":"14901:7:120","typeDescriptions":{"typeIdentifier":"t_function_external_nonpayable$_t_bytes4_$_t_address_$returns$__$","typeString":"function (bytes4,address) external"}},"id":58433,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"14901:66:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":58434,"nodeType":"ExpressionStatement","src":"14901:66:120"},{"assignments":[58436],"declarations":[{"constant":false,"id":58436,"mutability":"mutable","name":"l1CrossDomainMessengerProxy","nameLocation":"14986:27:120","nodeType":"VariableDeclaration","scope":58527,"src":"14978:35:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":58435,"name":"address","nodeType":"ElementaryTypeName","src":"14978:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"id":58442,"initialValue":{"arguments":[],"expression":{"argumentTypes":[],"expression":{"arguments":[{"id":58438,"name":"l1StandardBridgeProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58421,"src":"15025:21:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_address","typeString":"address"}],"id":58437,"name":"IFetcher","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57326,"src":"15016:8:120","typeDescriptions":{"typeIdentifier":"t_type$_t_contract$_IFetcher_$57326_$","typeString":"type(contract IFetcher)"}},"id":58439,"isConstant":false,"isLValue":false,"isPure":false,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"15016:31:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_contract$_IFetcher_$57326","typeString":"contract IFetcher"}},"id":58440,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"15048:9:120","memberName":"messenger","nodeType":"MemberAccess","referencedDeclaration":57221,"src":"15016:41:120","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":58441,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"15016:43:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"VariableDeclarationStatement","src":"14978:81:120"},{"expression":{"arguments":[{"expression":{"expression":{"id":58446,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58417,"src":"15077:3:120","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$58249","typeString":"contract FetchChainInfoOutput"}},"id":58447,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"15081:27:120","memberName":"l1CrossDomainMessengerProxy","nodeType":"MemberAccess","referencedDeclaration":57839,"src":"15077:31:120","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":58448,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"15109:8:120","memberName":"selector","nodeType":"MemberAccess","src":"15077:40:120","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},{"id":58449,"name":"l1CrossDomainMessengerProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58436,"src":"15119:27:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_bytes4","typeString":"bytes4"},{"typeIdentifier":"t_address","typeString":"address"}],"expression":{"id":58443,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58417,"src":"15069:3:120","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$58249","typeString":"contract FetchChainInfoOutput"}},"id":58445,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"15073:3:120","memberName":"set","nodeType":"MemberAccess","referencedDeclaration":57740,"src":"15069:7:120","typeDescriptions":{"typeIdentifier":"t_function_external_nonpayable$_t_bytes4_$_t_address_$returns$__$","typeString":"function (bytes4,address) external"}},"id":58450,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"15069:78:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":58451,"nodeType":"ExpressionStatement","src":"15069:78:120"},{"assignments":[58453],"declarations":[{"constant":false,"id":58453,"mutability":"mutable","name":"addressManagerImpl","nameLocation":"15166:18:120","nodeType":"VariableDeclaration","scope":58527,"src":"15158:26:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":58452,"name":"address","nodeType":"ElementaryTypeName","src":"15158:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"id":58457,"initialValue":{"arguments":[{"id":58455,"name":"l1CrossDomainMessengerProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58436,"src":"15206:27:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_address","typeString":"address"}],"id":58454,"name":"_getAddressManager","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":59003,"src":"15187:18:120","typeDescriptions":{"typeIdentifier":"t_function_internal_view$_t_address_$returns$_t_address_$","typeString":"function (address) view returns (address)"}},"id":58456,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"15187:47:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"VariableDeclarationStatement","src":"15158:76:120"},{"expression":{"arguments":[{"expression":{"expression":{"id":58461,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58417,"src":"15252:3:120","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$58249","typeString":"contract FetchChainInfoOutput"}},"id":58462,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"15256:18:120","memberName":"addressManagerImpl","nodeType":"MemberAccess","referencedDeclaration":57813,"src":"15252:22:120","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":58463,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"15275:8:120","memberName":"selector","nodeType":"MemberAccess","src":"15252:31:120","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},{"id":58464,"name":"addressManagerImpl","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58453,"src":"15285:18:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_bytes4","typeString":"bytes4"},{"typeIdentifier":"t_address","typeString":"address"}],"expression":{"id":58458,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58417,"src":"15244:3:120","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$58249","typeString":"contract FetchChainInfoOutput"}},"id":58460,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"15248:3:120","memberName":"set","nodeType":"MemberAccess","referencedDeclaration":57740,"src":"15244:7:120","typeDescriptions":{"typeIdentifier":"t_function_external_nonpayable$_t_bytes4_$_t_address_$returns$__$","typeString":"function (bytes4,address) external"}},"id":58465,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"15244:60:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":58466,"nodeType":"ExpressionStatement","src":"15244:60:120"},{"assignments":[58468],"declarations":[{"constant":false,"id":58468,"mutability":"mutable","name":"optimismPortalProxy","nameLocation":"15323:19:120","nodeType":"VariableDeclaration","scope":58527,"src":"15315:27:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":58467,"name":"address","nodeType":"ElementaryTypeName","src":"15315:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"id":58472,"initialValue":{"arguments":[{"id":58470,"name":"l1CrossDomainMessengerProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58436,"src":"15369:27:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_address","typeString":"address"}],"id":58469,"name":"_getOptimismPortalProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58965,"src":"15345:23:120","typeDescriptions":{"typeIdentifier":"t_function_internal_view$_t_address_$returns$_t_address_$","typeString":"function (address) view returns (address)"}},"id":58471,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"15345:52:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"VariableDeclarationStatement","src":"15315:82:120"},{"expression":{"arguments":[{"expression":{"expression":{"id":58476,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58417,"src":"15415:3:120","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$58249","typeString":"contract FetchChainInfoOutput"}},"id":58477,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"15419:19:120","memberName":"optimismPortalProxy","nodeType":"MemberAccess","referencedDeclaration":57929,"src":"15415:23:120","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":58478,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"15439:8:120","memberName":"selector","nodeType":"MemberAccess","src":"15415:32:120","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},{"id":58479,"name":"optimismPortalProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58468,"src":"15449:19:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_bytes4","typeString":"bytes4"},{"typeIdentifier":"t_address","typeString":"address"}],"expression":{"id":58473,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58417,"src":"15407:3:120","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$58249","typeString":"contract FetchChainInfoOutput"}},"id":58475,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"15411:3:120","memberName":"set","nodeType":"MemberAccess","referencedDeclaration":57740,"src":"15407:7:120","typeDescriptions":{"typeIdentifier":"t_function_external_nonpayable$_t_bytes4_$_t_address_$returns$__$","typeString":"function (bytes4,address) external"}},"id":58480,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"15407:62:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":58481,"nodeType":"ExpressionStatement","src":"15407:62:120"},{"assignments":[58483],"declarations":[{"constant":false,"id":58483,"mutability":"mutable","name":"opChainGuardian","nameLocation":"15488:15:120","nodeType":"VariableDeclaration","scope":58527,"src":"15480:23:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":58482,"name":"address","nodeType":"ElementaryTypeName","src":"15480:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"id":58487,"initialValue":{"arguments":[{"id":58485,"name":"optimismPortalProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58468,"src":"15519:19:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_address","typeString":"address"}],"id":58484,"name":"_getGuardian","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58907,"src":"15506:12:120","typeDescriptions":{"typeIdentifier":"t_function_internal_view$_t_address_$returns$_t_address_$","typeString":"function (address) view returns (address)"}},"id":58486,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"15506:33:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"VariableDeclarationStatement","src":"15480:59:120"},{"expression":{"arguments":[{"expression":{"expression":{"id":58491,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58417,"src":"15557:3:120","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$58249","typeString":"contract FetchChainInfoOutput"}},"id":58492,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"15561:15:120","memberName":"opChainGuardian","nodeType":"MemberAccess","referencedDeclaration":58151,"src":"15557:19:120","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":58493,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"15577:8:120","memberName":"selector","nodeType":"MemberAccess","src":"15557:28:120","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},{"id":58494,"name":"opChainGuardian","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58483,"src":"15587:15:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_bytes4","typeString":"bytes4"},{"typeIdentifier":"t_address","typeString":"address"}],"expression":{"id":58488,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58417,"src":"15549:3:120","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$58249","typeString":"contract FetchChainInfoOutput"}},"id":58490,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"15553:3:120","memberName":"set","nodeType":"MemberAccess","referencedDeclaration":57740,"src":"15549:7:120","typeDescriptions":{"typeIdentifier":"t_function_external_nonpayable$_t_bytes4_$_t_address_$returns$__$","typeString":"function (bytes4,address) external"}},"id":58495,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"15549:54:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":58496,"nodeType":"ExpressionStatement","src":"15549:54:120"},{"assignments":[58498],"declarations":[{"constant":false,"id":58498,"mutability":"mutable","name":"ethLockboxProxy","nameLocation":"15622:15:120","nodeType":"VariableDeclaration","scope":58527,"src":"15614:23:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":58497,"name":"address","nodeType":"ElementaryTypeName","src":"15614:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"id":58502,"initialValue":{"arguments":[{"id":58500,"name":"optimismPortalProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58468,"src":"15660:19:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_address","typeString":"address"}],"id":58499,"name":"_getEthLockboxProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":59203,"src":"15640:19:120","typeDescriptions":{"typeIdentifier":"t_function_internal_view$_t_address_$returns$_t_address_$","typeString":"function (address) view returns (address)"}},"id":58501,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"15640:40:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"VariableDeclarationStatement","src":"15614:66:120"},{"expression":{"arguments":[{"expression":{"expression":{"id":58506,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58417,"src":"15698:3:120","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$58249","typeString":"contract FetchChainInfoOutput"}},"id":58507,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"15702:15:120","memberName":"ethLockboxProxy","nodeType":"MemberAccess","referencedDeclaration":57821,"src":"15698:19:120","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":58508,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"15718:8:120","memberName":"selector","nodeType":"MemberAccess","src":"15698:28:120","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},{"id":58509,"name":"ethLockboxProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58498,"src":"15728:15:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_bytes4","typeString":"bytes4"},{"typeIdentifier":"t_address","typeString":"address"}],"expression":{"id":58503,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58417,"src":"15690:3:120","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$58249","typeString":"contract FetchChainInfoOutput"}},"id":58505,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"15694:3:120","memberName":"set","nodeType":"MemberAccess","referencedDeclaration":57740,"src":"15690:7:120","typeDescriptions":{"typeIdentifier":"t_function_external_nonpayable$_t_bytes4_$_t_address_$returns$__$","typeString":"function (bytes4,address) external"}},"id":58510,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"15690:54:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":58511,"nodeType":"ExpressionStatement","src":"15690:54:120"},{"assignments":[58513],"declarations":[{"constant":false,"id":58513,"mutability":"mutable","name":"superchainConfigProxy","nameLocation":"15763:21:120","nodeType":"VariableDeclaration","scope":58527,"src":"15755:29:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":58512,"name":"address","nodeType":"ElementaryTypeName","src":"15755:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"id":58517,"initialValue":{"arguments":[{"id":58515,"name":"optimismPortalProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58468,"src":"15813:19:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_address","typeString":"address"}],"id":58514,"name":"_getSuperchainConfigProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":59115,"src":"15787:25:120","typeDescriptions":{"typeIdentifier":"t_function_internal_view$_t_address_$returns$_t_address_$","typeString":"function (address) view returns (address)"}},"id":58516,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"15787:46:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"VariableDeclarationStatement","src":"15755:78:120"},{"expression":{"arguments":[{"expression":{"expression":{"id":58521,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58417,"src":"15851:3:120","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$58249","typeString":"contract FetchChainInfoOutput"}},"id":58522,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"15855:21:120","memberName":"superchainConfigProxy","nodeType":"MemberAccess","referencedDeclaration":57983,"src":"15851:25:120","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":58523,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"15877:8:120","memberName":"selector","nodeType":"MemberAccess","src":"15851:34:120","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},{"id":58524,"name":"superchainConfigProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58513,"src":"15887:21:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_bytes4","typeString":"bytes4"},{"typeIdentifier":"t_address","typeString":"address"}],"expression":{"id":58518,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58417,"src":"15843:3:120","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$58249","typeString":"contract FetchChainInfoOutput"}},"id":58520,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"15847:3:120","memberName":"set","nodeType":"MemberAccess","referencedDeclaration":57740,"src":"15843:7:120","typeDescriptions":{"typeIdentifier":"t_function_external_nonpayable$_t_bytes4_$_t_address_$returns$__$","typeString":"function (bytes4,address) external"}},"id":58525,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"15843:66:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":58526,"nodeType":"ExpressionStatement","src":"15843:66:120"}]},"implemented":true,"kind":"function","modifiers":[],"name":"_processMessengerAndPortal","nameLocation":"14735:26:120","parameters":{"id":58418,"nodeType":"ParameterList","parameters":[{"constant":false,"id":58414,"mutability":"mutable","name":"_fi","nameLocation":"14782:3:120","nodeType":"VariableDeclaration","scope":58528,"src":"14762:23:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoInput_$57409","typeString":"contract FetchChainInfoInput"},"typeName":{"id":58413,"nodeType":"UserDefinedTypeName","pathNode":{"id":58412,"name":"FetchChainInfoInput","nameLocations":["14762:19:120"],"nodeType":"IdentifierPath","referencedDeclaration":57409,"src":"14762:19:120"},"referencedDeclaration":57409,"src":"14762:19:120","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoInput_$57409","typeString":"contract FetchChainInfoInput"}},"visibility":"internal"},{"constant":false,"id":58417,"mutability":"mutable","name":"_fo","nameLocation":"14808:3:120","nodeType":"VariableDeclaration","scope":58528,"src":"14787:24:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$58249","typeString":"contract FetchChainInfoOutput"},"typeName":{"id":58416,"nodeType":"UserDefinedTypeName","pathNode":{"id":58415,"name":"FetchChainInfoOutput","nameLocations":["14787:20:120"],"nodeType":"IdentifierPath","referencedDeclaration":58249,"src":"14787:20:120"},"referencedDeclaration":58249,"src":"14787:20:120","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$58249","typeString":"contract FetchChainInfoOutput"}},"visibility":"internal"}],"src":"14761:51:120"},"returnParameters":{"id":58419,"nodeType":"ParameterList","parameters":[],"src":"14822:0:120"},"scope":59299,"stateMutability":"nonpayable","virtual":false,"visibility":"internal"},{"id":58878,"nodeType":"FunctionDefinition","src":"15922:3713:120","nodes":[],"body":{"id":58877,"nodeType":"Block","src":"15986:3649:120","nodes":[],"statements":[{"assignments":[58535],"declarations":[{"constant":false,"id":58535,"mutability":"mutable","name":"systemConfigProxy","nameLocation":"16004:17:120","nodeType":"VariableDeclaration","scope":58877,"src":"15996:25:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":58534,"name":"address","nodeType":"ElementaryTypeName","src":"15996:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"id":58539,"initialValue":{"arguments":[],"expression":{"argumentTypes":[],"expression":{"id":58536,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58531,"src":"16024:3:120","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$58249","typeString":"contract FetchChainInfoOutput"}},"id":58537,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"16028:17:120","memberName":"systemConfigProxy","nodeType":"MemberAccess","referencedDeclaration":57947,"src":"16024:21:120","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":58538,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"16024:23:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"VariableDeclarationStatement","src":"15996:51:120"},{"assignments":[58541],"declarations":[{"constant":false,"id":58541,"mutability":"mutable","name":"optimismPortalProxy","nameLocation":"16065:19:120","nodeType":"VariableDeclaration","scope":58877,"src":"16057:27:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":58540,"name":"address","nodeType":"ElementaryTypeName","src":"16057:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"id":58545,"initialValue":{"arguments":[],"expression":{"argumentTypes":[],"expression":{"id":58542,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58531,"src":"16087:3:120","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$58249","typeString":"contract FetchChainInfoOutput"}},"id":58543,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"16091:19:120","memberName":"optimismPortalProxy","nodeType":"MemberAccess","referencedDeclaration":57929,"src":"16087:23:120","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":58544,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"16087:25:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"VariableDeclarationStatement","src":"16057:55:120"},{"clauses":[{"block":{"id":58564,"nodeType":"Block","src":"16206:75:120","statements":[{"expression":{"arguments":[{"expression":{"expression":{"id":58558,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58531,"src":"16228:3:120","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$58249","typeString":"contract FetchChainInfoOutput"}},"id":58559,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"16232:17:120","memberName":"respectedGameType","nodeType":"MemberAccess","referencedDeclaration":58248,"src":"16228:21:120","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_userDefinedValueType$_GameType_$75355_$","typeString":"function () view external returns (GameType)"}},"id":58560,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"16250:8:120","memberName":"selector","nodeType":"MemberAccess","src":"16228:30:120","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},{"id":58561,"name":"gameType_","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58553,"src":"16260:9:120","typeDescriptions":{"typeIdentifier":"t_userDefinedValueType$_GameType_$75355","typeString":"GameType"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_bytes4","typeString":"bytes4"},{"typeIdentifier":"t_userDefinedValueType$_GameType_$75355","typeString":"GameType"}],"expression":{"id":58555,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58531,"src":"16220:3:120","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$58249","typeString":"contract FetchChainInfoOutput"}},"id":58557,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"16224:3:120","memberName":"set","nodeType":"MemberAccess","referencedDeclaration":57795,"src":"16220:7:120","typeDescriptions":{"typeIdentifier":"t_function_external_nonpayable$_t_bytes4_$_t_userDefinedValueType$_GameType_$75355_$returns$__$","typeString":"function (bytes4,GameType) external"}},"id":58562,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"16220:50:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":58563,"nodeType":"ExpressionStatement","src":"16220:50:120"}]},"errorName":"","id":58565,"nodeType":"TryCatchClause","parameters":{"id":58554,"nodeType":"ParameterList","parameters":[{"constant":false,"id":58553,"mutability":"mutable","name":"gameType_","nameLocation":"16195:9:120","nodeType":"VariableDeclaration","scope":58565,"src":"16186:18:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_userDefinedValueType$_GameType_$75355","typeString":"GameType"},"typeName":{"id":58552,"nodeType":"UserDefinedTypeName","pathNode":{"id":58551,"name":"GameType","nameLocations":["16186:8:120"],"nodeType":"IdentifierPath","referencedDeclaration":75355,"src":"16186:8:120"},"referencedDeclaration":75355,"src":"16186:8:120","typeDescriptions":{"typeIdentifier":"t_userDefinedValueType$_GameType_$75355","typeString":"GameType"}},"visibility":"internal"}],"src":"16185:20:120"},"src":"16177:104:120"},{"block":{"id":58637,"nodeType":"Block","src":"16288:744:120","statements":[{"expression":{"arguments":[{"expression":{"expression":{"id":58569,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58531,"src":"16383:3:120","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$58249","typeString":"contract FetchChainInfoOutput"}},"id":58570,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"16387:17:120","memberName":"respectedGameType","nodeType":"MemberAccess","referencedDeclaration":58248,"src":"16383:21:120","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_userDefinedValueType$_GameType_$75355_$","typeString":"function () view external returns (GameType)"}},"id":58571,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"16405:8:120","memberName":"selector","nodeType":"MemberAccess","src":"16383:30:120","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},{"arguments":[{"expression":{"arguments":[{"id":58576,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"nodeType":"ElementaryTypeNameExpression","src":"16434:6:120","typeDescriptions":{"typeIdentifier":"t_type$_t_uint32_$","typeString":"type(uint32)"},"typeName":{"id":58575,"name":"uint32","nodeType":"ElementaryTypeName","src":"16434:6:120","typeDescriptions":{}}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_type$_t_uint32_$","typeString":"type(uint32)"}],"id":58574,"name":"type","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":-27,"src":"16429:4:120","typeDescriptions":{"typeIdentifier":"t_function_metatype_pure$__$returns$__$","typeString":"function () pure"}},"id":58577,"isConstant":false,"isLValue":false,"isPure":true,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"16429:12:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_magic_meta_type_t_uint32","typeString":"type(uint32)"}},"id":58578,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"memberLocation":"16442:3:120","memberName":"max","nodeType":"MemberAccess","src":"16429:16:120","typeDescriptions":{"typeIdentifier":"t_uint32","typeString":"uint32"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_uint32","typeString":"uint32"}],"expression":{"id":58572,"name":"GameType","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":75355,"src":"16415:8:120","typeDescriptions":{"typeIdentifier":"t_type$_t_userDefinedValueType$_GameType_$75355_$","typeString":"type(GameType)"}},"id":58573,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"memberLocation":"16424:4:120","memberName":"wrap","nodeType":"MemberAccess","src":"16415:13:120","typeDescriptions":{"typeIdentifier":"t_function_wrap_pure$_t_uint32_$returns$_t_userDefinedValueType$_GameType_$75355_$","typeString":"function (uint32) pure returns (GameType)"}},"id":58579,"isConstant":false,"isLValue":false,"isPure":true,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"16415:31:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_userDefinedValueType$_GameType_$75355","typeString":"GameType"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_bytes4","typeString":"bytes4"},{"typeIdentifier":"t_userDefinedValueType$_GameType_$75355","typeString":"GameType"}],"expression":{"id":58566,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58531,"src":"16375:3:120","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$58249","typeString":"contract FetchChainInfoOutput"}},"id":58568,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"16379:3:120","memberName":"set","nodeType":"MemberAccess","referencedDeclaration":57795,"src":"16375:7:120","typeDescriptions":{"typeIdentifier":"t_function_external_nonpayable$_t_bytes4_$_t_userDefinedValueType$_GameType_$75355_$returns$__$","typeString":"function (bytes4,GameType) external"}},"id":58580,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"16375:72:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":58581,"nodeType":"ExpressionStatement","src":"16375:72:120"},{"assignments":[58583],"declarations":[{"constant":false,"id":58583,"mutability":"mutable","name":"l2OutputOracleProxy","nameLocation":"16469:19:120","nodeType":"VariableDeclaration","scope":58637,"src":"16461:27:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":58582,"name":"address","nodeType":"ElementaryTypeName","src":"16461:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"id":58584,"nodeType":"VariableDeclarationStatement","src":"16461:27:120"},{"clauses":[{"block":{"id":58597,"nodeType":"Block","src":"16575:64:120","statements":[{"expression":{"id":58595,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftHandSide":{"id":58593,"name":"l2OutputOracleProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58583,"src":"16593:19:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"Assignment","operator":"=","rightHandSide":{"id":58594,"name":"l2Oracle_","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58591,"src":"16615:9:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"src":"16593:31:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"id":58596,"nodeType":"ExpressionStatement","src":"16593:31:120"}]},"errorName":"","id":58598,"nodeType":"TryCatchClause","parameters":{"id":58592,"nodeType":"ParameterList","parameters":[{"constant":false,"id":58591,"mutability":"mutable","name":"l2Oracle_","nameLocation":"16564:9:120","nodeType":"VariableDeclaration","scope":58598,"src":"16556:17:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":58590,"name":"address","nodeType":"ElementaryTypeName","src":"16556:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"16555:19:120"},"src":"16547:92:120"},{"block":{"id":58607,"nodeType":"Block","src":"16646:96:120","statements":[{"expression":{"id":58605,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftHandSide":{"id":58599,"name":"l2OutputOracleProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58583,"src":"16664:19:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"Assignment","operator":"=","rightHandSide":{"arguments":[],"expression":{"argumentTypes":[],"expression":{"arguments":[{"id":58601,"name":"optimismPortalProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58541,"src":"16695:19:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_address","typeString":"address"}],"id":58600,"name":"IFetcher","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57326,"src":"16686:8:120","typeDescriptions":{"typeIdentifier":"t_type$_t_contract$_IFetcher_$57326_$","typeString":"type(contract IFetcher)"}},"id":58602,"isConstant":false,"isLValue":false,"isPure":false,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"16686:29:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_contract$_IFetcher_$57326","typeString":"contract IFetcher"}},"id":58603,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"16716:9:120","memberName":"L2_ORACLE","nodeType":"MemberAccess","referencedDeclaration":57270,"src":"16686:39:120","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":58604,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"16686:41:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"src":"16664:63:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"id":58606,"nodeType":"ExpressionStatement","src":"16664:63:120"}]},"errorName":"","id":58608,"nodeType":"TryCatchClause","src":"16640:102:120"}],"externalCall":{"arguments":[],"expression":{"argumentTypes":[],"expression":{"arguments":[{"id":58586,"name":"optimismPortalProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58541,"src":"16515:19:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_address","typeString":"address"}],"id":58585,"name":"IFetcher","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57326,"src":"16506:8:120","typeDescriptions":{"typeIdentifier":"t_type$_t_contract$_IFetcher_$57326_$","typeString":"type(contract IFetcher)"}},"id":58587,"isConstant":false,"isLValue":false,"isPure":false,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"16506:29:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_contract$_IFetcher_$57326","typeString":"contract IFetcher"}},"id":58588,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"16536:8:120","memberName":"l2Oracle","nodeType":"MemberAccess","referencedDeclaration":57275,"src":"16506:38:120","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":58589,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"16506:40:120","tryCall":true,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"id":58609,"nodeType":"TryStatement","src":"16502:240:120"},{"expression":{"arguments":[{"expression":{"expression":{"id":58613,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58531,"src":"16763:3:120","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$58249","typeString":"contract FetchChainInfoOutput"}},"id":58614,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"16767:19:120","memberName":"l2OutputOracleProxy","nodeType":"MemberAccess","referencedDeclaration":57893,"src":"16763:23:120","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":58615,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"16787:8:120","memberName":"selector","nodeType":"MemberAccess","src":"16763:32:120","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},{"id":58616,"name":"l2OutputOracleProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58583,"src":"16797:19:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_bytes4","typeString":"bytes4"},{"typeIdentifier":"t_address","typeString":"address"}],"expression":{"id":58610,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58531,"src":"16755:3:120","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$58249","typeString":"contract FetchChainInfoOutput"}},"id":58612,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"16759:3:120","memberName":"set","nodeType":"MemberAccess","referencedDeclaration":57740,"src":"16755:7:120","typeDescriptions":{"typeIdentifier":"t_function_external_nonpayable$_t_bytes4_$_t_address_$returns$__$","typeString":"function (bytes4,address) external"}},"id":58617,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"16755:62:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":58618,"nodeType":"ExpressionStatement","src":"16755:62:120"},{"assignments":[58620],"declarations":[{"constant":false,"id":58620,"mutability":"mutable","name":"proposer","nameLocation":"16840:8:120","nodeType":"VariableDeclaration","scope":58637,"src":"16832:16:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":58619,"name":"address","nodeType":"ElementaryTypeName","src":"16832:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"id":58626,"initialValue":{"arguments":[],"expression":{"argumentTypes":[],"expression":{"arguments":[{"id":58622,"name":"l2OutputOracleProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58583,"src":"16860:19:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_address","typeString":"address"}],"id":58621,"name":"IFetcher","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57326,"src":"16851:8:120","typeDescriptions":{"typeIdentifier":"t_type$_t_contract$_IFetcher_$57326_$","typeString":"type(contract IFetcher)"}},"id":58623,"isConstant":false,"isLValue":false,"isPure":false,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"16851:29:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_contract$_IFetcher_$57326","typeString":"contract IFetcher"}},"id":58624,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"16881:8:120","memberName":"PROPOSER","nodeType":"MemberAccess","referencedDeclaration":57300,"src":"16851:38:120","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":58625,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"16851:40:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"VariableDeclarationStatement","src":"16832:59:120"},{"expression":{"arguments":[{"expression":{"expression":{"id":58630,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58531,"src":"16913:3:120","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$58249","typeString":"contract FetchChainInfoOutput"}},"id":58631,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"16917:8:120","memberName":"proposer","nodeType":"MemberAccess","referencedDeclaration":58187,"src":"16913:12:120","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":58632,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"16926:8:120","memberName":"selector","nodeType":"MemberAccess","src":"16913:21:120","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},{"id":58633,"name":"proposer","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58620,"src":"16936:8:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_bytes4","typeString":"bytes4"},{"typeIdentifier":"t_address","typeString":"address"}],"expression":{"id":58627,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58531,"src":"16905:3:120","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$58249","typeString":"contract FetchChainInfoOutput"}},"id":58629,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"16909:3:120","memberName":"set","nodeType":"MemberAccess","referencedDeclaration":57740,"src":"16905:7:120","typeDescriptions":{"typeIdentifier":"t_function_external_nonpayable$_t_bytes4_$_t_address_$returns$__$","typeString":"function (bytes4,address) external"}},"id":58634,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"16905:40:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":58635,"nodeType":"ExpressionStatement","src":"16905:40:120"},{"functionReturnParameters":58533,"id":58636,"nodeType":"Return","src":"17015:7:120"}]},"errorName":"","id":58638,"nodeType":"TryCatchClause","src":"16282:750:120"}],"externalCall":{"arguments":[],"expression":{"argumentTypes":[],"expression":{"arguments":[{"id":58547,"name":"optimismPortalProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58541,"src":"16136:19:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_address","typeString":"address"}],"id":58546,"name":"IFetcher","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57326,"src":"16127:8:120","typeDescriptions":{"typeIdentifier":"t_type$_t_contract$_IFetcher_$57326_$","typeString":"type(contract IFetcher)"}},"id":58548,"isConstant":false,"isLValue":false,"isPure":false,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"16127:29:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_contract$_IFetcher_$57326","typeString":"contract IFetcher"}},"id":58549,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"16157:17:120","memberName":"respectedGameType","nodeType":"MemberAccess","referencedDeclaration":57260,"src":"16127:47:120","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_userDefinedValueType$_GameType_$75355_$","typeString":"function () view external returns (GameType)"}},"id":58550,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"16127:49:120","tryCall":true,"typeDescriptions":{"typeIdentifier":"t_userDefinedValueType$_GameType_$75355","typeString":"GameType"}},"id":58639,"nodeType":"TryStatement","src":"16123:909:120"},{"assignments":[58641],"declarations":[{"constant":false,"id":58641,"mutability":"mutable","name":"disputeGameFactoryProxy","nameLocation":"17050:23:120","nodeType":"VariableDeclaration","scope":58877,"src":"17042:31:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":58640,"name":"address","nodeType":"ElementaryTypeName","src":"17042:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"id":58645,"initialValue":{"arguments":[{"id":58643,"name":"systemConfigProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58535,"src":"17104:17:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_address","typeString":"address"}],"id":58642,"name":"_getDisputeGameFactoryProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":59087,"src":"17076:27:120","typeDescriptions":{"typeIdentifier":"t_function_internal_view$_t_address_$returns$_t_address_$","typeString":"function (address) view returns (address)"}},"id":58644,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"17076:46:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"VariableDeclarationStatement","src":"17042:80:120"},{"condition":{"commonType":{"typeIdentifier":"t_address","typeString":"address"},"id":58651,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftExpression":{"id":58646,"name":"disputeGameFactoryProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58641,"src":"17136:23:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"BinaryOperation","operator":"!=","rightExpression":{"arguments":[{"hexValue":"30","id":58649,"isConstant":false,"isLValue":false,"isPure":true,"kind":"number","lValueRequested":false,"nodeType":"Literal","src":"17171:1:120","typeDescriptions":{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"},"value":"0"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"}],"id":58648,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"nodeType":"ElementaryTypeNameExpression","src":"17163:7:120","typeDescriptions":{"typeIdentifier":"t_type$_t_address_$","typeString":"type(address)"},"typeName":{"id":58647,"name":"address","nodeType":"ElementaryTypeName","src":"17163:7:120","typeDescriptions":{}}},"id":58650,"isConstant":false,"isLValue":false,"isPure":true,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"17163:10:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"src":"17136:37:120","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},"falseBody":{"id":58875,"nodeType":"Block","src":"19246:383:120","statements":[{"assignments":[58842],"declarations":[{"constant":false,"id":58842,"mutability":"mutable","name":"l2OutputOracleProxy","nameLocation":"19352:19:120","nodeType":"VariableDeclaration","scope":58875,"src":"19344:27:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":58841,"name":"address","nodeType":"ElementaryTypeName","src":"19344:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"id":58848,"initialValue":{"arguments":[],"expression":{"argumentTypes":[],"expression":{"arguments":[{"id":58844,"name":"optimismPortalProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58541,"src":"19383:19:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_address","typeString":"address"}],"id":58843,"name":"IFetcher","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57326,"src":"19374:8:120","typeDescriptions":{"typeIdentifier":"t_type$_t_contract$_IFetcher_$57326_$","typeString":"type(contract IFetcher)"}},"id":58845,"isConstant":false,"isLValue":false,"isPure":false,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"19374:29:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_contract$_IFetcher_$57326","typeString":"contract IFetcher"}},"id":58846,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"19404:9:120","memberName":"L2_ORACLE","nodeType":"MemberAccess","referencedDeclaration":57270,"src":"19374:39:120","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":58847,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"19374:41:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"VariableDeclarationStatement","src":"19344:71:120"},{"expression":{"arguments":[{"expression":{"expression":{"id":58852,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58531,"src":"19437:3:120","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$58249","typeString":"contract FetchChainInfoOutput"}},"id":58853,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"19441:19:120","memberName":"l2OutputOracleProxy","nodeType":"MemberAccess","referencedDeclaration":57893,"src":"19437:23:120","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":58854,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"19461:8:120","memberName":"selector","nodeType":"MemberAccess","src":"19437:32:120","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},{"id":58855,"name":"l2OutputOracleProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58842,"src":"19471:19:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_bytes4","typeString":"bytes4"},{"typeIdentifier":"t_address","typeString":"address"}],"expression":{"id":58849,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58531,"src":"19429:3:120","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$58249","typeString":"contract FetchChainInfoOutput"}},"id":58851,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"19433:3:120","memberName":"set","nodeType":"MemberAccess","referencedDeclaration":57740,"src":"19429:7:120","typeDescriptions":{"typeIdentifier":"t_function_external_nonpayable$_t_bytes4_$_t_address_$returns$__$","typeString":"function (bytes4,address) external"}},"id":58856,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"19429:62:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":58857,"nodeType":"ExpressionStatement","src":"19429:62:120"},{"assignments":[58859],"declarations":[{"constant":false,"id":58859,"mutability":"mutable","name":"proposer","nameLocation":"19513:8:120","nodeType":"VariableDeclaration","scope":58875,"src":"19505:16:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":58858,"name":"address","nodeType":"ElementaryTypeName","src":"19505:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"id":58865,"initialValue":{"arguments":[],"expression":{"argumentTypes":[],"expression":{"arguments":[{"id":58861,"name":"l2OutputOracleProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58842,"src":"19533:19:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_address","typeString":"address"}],"id":58860,"name":"IFetcher","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57326,"src":"19524:8:120","typeDescriptions":{"typeIdentifier":"t_type$_t_contract$_IFetcher_$57326_$","typeString":"type(contract IFetcher)"}},"id":58862,"isConstant":false,"isLValue":false,"isPure":false,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"19524:29:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_contract$_IFetcher_$57326","typeString":"contract IFetcher"}},"id":58863,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"19554:8:120","memberName":"PROPOSER","nodeType":"MemberAccess","referencedDeclaration":57300,"src":"19524:38:120","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":58864,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"19524:40:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"VariableDeclarationStatement","src":"19505:59:120"},{"expression":{"arguments":[{"expression":{"expression":{"id":58869,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58531,"src":"19586:3:120","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$58249","typeString":"contract FetchChainInfoOutput"}},"id":58870,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"19590:8:120","memberName":"proposer","nodeType":"MemberAccess","referencedDeclaration":58187,"src":"19586:12:120","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":58871,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"19599:8:120","memberName":"selector","nodeType":"MemberAccess","src":"19586:21:120","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},{"id":58872,"name":"proposer","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58859,"src":"19609:8:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_bytes4","typeString":"bytes4"},{"typeIdentifier":"t_address","typeString":"address"}],"expression":{"id":58866,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58531,"src":"19578:3:120","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$58249","typeString":"contract FetchChainInfoOutput"}},"id":58868,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"19582:3:120","memberName":"set","nodeType":"MemberAccess","referencedDeclaration":57740,"src":"19578:7:120","typeDescriptions":{"typeIdentifier":"t_function_external_nonpayable$_t_bytes4_$_t_address_$returns$__$","typeString":"function (bytes4,address) external"}},"id":58873,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"19578:40:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":58874,"nodeType":"ExpressionStatement","src":"19578:40:120"}]},"id":58876,"nodeType":"IfStatement","src":"17132:2497:120","trueBody":{"id":58840,"nodeType":"Block","src":"17175:2065:120","statements":[{"expression":{"arguments":[{"expression":{"expression":{"id":58655,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58531,"src":"17197:3:120","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$58249","typeString":"contract FetchChainInfoOutput"}},"id":58656,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"17201:23:120","memberName":"disputeGameFactoryProxy","nodeType":"MemberAccess","referencedDeclaration":58025,"src":"17197:27:120","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":58657,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"17225:8:120","memberName":"selector","nodeType":"MemberAccess","src":"17197:36:120","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},{"id":58658,"name":"disputeGameFactoryProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58641,"src":"17235:23:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_bytes4","typeString":"bytes4"},{"typeIdentifier":"t_address","typeString":"address"}],"expression":{"id":58652,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58531,"src":"17189:3:120","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$58249","typeString":"contract FetchChainInfoOutput"}},"id":58654,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"17193:3:120","memberName":"set","nodeType":"MemberAccess","referencedDeclaration":57740,"src":"17189:7:120","typeDescriptions":{"typeIdentifier":"t_function_external_nonpayable$_t_bytes4_$_t_address_$returns$__$","typeString":"function (bytes4,address) external"}},"id":58659,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"17189:70:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":58660,"nodeType":"ExpressionStatement","src":"17189:70:120"},{"assignments":[58662],"declarations":[{"constant":false,"id":58662,"mutability":"mutable","name":"permissionedDisputeGameImpl","nameLocation":"17282:27:120","nodeType":"VariableDeclaration","scope":58840,"src":"17274:35:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":58661,"name":"address","nodeType":"ElementaryTypeName","src":"17274:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"id":58666,"initialValue":{"arguments":[{"id":58664,"name":"disputeGameFactoryProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58641,"src":"17340:23:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_address","typeString":"address"}],"id":58663,"name":"_getPermissionedDisputeGame","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":59175,"src":"17312:27:120","typeDescriptions":{"typeIdentifier":"t_function_internal_view$_t_address_$returns$_t_address_$","typeString":"function (address) view returns (address)"}},"id":58665,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"17312:52:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"VariableDeclarationStatement","src":"17274:90:120"},{"condition":{"commonType":{"typeIdentifier":"t_address","typeString":"address"},"id":58672,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftExpression":{"id":58667,"name":"permissionedDisputeGameImpl","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58662,"src":"17382:27:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"BinaryOperation","operator":"!=","rightExpression":{"arguments":[{"hexValue":"30","id":58670,"isConstant":false,"isLValue":false,"isPure":true,"kind":"number","lValueRequested":false,"nodeType":"Literal","src":"17421:1:120","typeDescriptions":{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"},"value":"0"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"}],"id":58669,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"nodeType":"ElementaryTypeNameExpression","src":"17413:7:120","typeDescriptions":{"typeIdentifier":"t_type$_t_address_$","typeString":"type(address)"},"typeName":{"id":58668,"name":"address","nodeType":"ElementaryTypeName","src":"17413:7:120","typeDescriptions":{}}},"id":58671,"isConstant":false,"isLValue":false,"isPure":true,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"17413:10:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"src":"17382:41:120","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},"id":58792,"nodeType":"IfStatement","src":"17378:1278:120","trueBody":{"id":58791,"nodeType":"Block","src":"17425:1231:120","statements":[{"expression":{"arguments":[{"expression":{"expression":{"id":58676,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58531,"src":"17506:3:120","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$58249","typeString":"contract FetchChainInfoOutput"}},"id":58677,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"17510:12:120","memberName":"permissioned","nodeType":"MemberAccess","referencedDeclaration":58231,"src":"17506:16:120","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_bool_$","typeString":"function () view external returns (bool)"}},"id":58678,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"17523:8:120","memberName":"selector","nodeType":"MemberAccess","src":"17506:25:120","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},{"hexValue":"74727565","id":58679,"isConstant":false,"isLValue":false,"isPure":true,"kind":"bool","lValueRequested":false,"nodeType":"Literal","src":"17533:4:120","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"},"value":"true"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_bytes4","typeString":"bytes4"},{"typeIdentifier":"t_bool","typeString":"bool"}],"expression":{"id":58673,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58531,"src":"17498:3:120","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$58249","typeString":"contract FetchChainInfoOutput"}},"id":58675,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"17502:3:120","memberName":"set","nodeType":"MemberAccess","referencedDeclaration":57772,"src":"17498:7:120","typeDescriptions":{"typeIdentifier":"t_function_external_nonpayable$_t_bytes4_$_t_bool_$returns$__$","typeString":"function (bytes4,bool) external"}},"id":58680,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"17498:40:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":58681,"nodeType":"ExpressionStatement","src":"17498:40:120"},{"expression":{"arguments":[{"expression":{"expression":{"id":58685,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58531,"src":"17564:3:120","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$58249","typeString":"contract FetchChainInfoOutput"}},"id":58686,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"17568:27:120","memberName":"permissionedDisputeGameImpl","nodeType":"MemberAccess","referencedDeclaration":58079,"src":"17564:31:120","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":58687,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"17596:8:120","memberName":"selector","nodeType":"MemberAccess","src":"17564:40:120","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},{"id":58688,"name":"permissionedDisputeGameImpl","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58662,"src":"17606:27:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_bytes4","typeString":"bytes4"},{"typeIdentifier":"t_address","typeString":"address"}],"expression":{"id":58682,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58531,"src":"17556:3:120","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$58249","typeString":"contract FetchChainInfoOutput"}},"id":58684,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"17560:3:120","memberName":"set","nodeType":"MemberAccess","referencedDeclaration":57740,"src":"17556:7:120","typeDescriptions":{"typeIdentifier":"t_function_external_nonpayable$_t_bytes4_$_t_address_$returns$__$","typeString":"function (bytes4,address) external"}},"id":58689,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"17556:78:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":58690,"nodeType":"ExpressionStatement","src":"17556:78:120"},{"assignments":[58692],"declarations":[{"constant":false,"id":58692,"mutability":"mutable","name":"challenger","nameLocation":"17661:10:120","nodeType":"VariableDeclaration","scope":58791,"src":"17653:18:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":58691,"name":"address","nodeType":"ElementaryTypeName","src":"17653:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"id":58698,"initialValue":{"arguments":[],"expression":{"argumentTypes":[],"expression":{"arguments":[{"id":58694,"name":"permissionedDisputeGameImpl","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58662,"src":"17683:27:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_address","typeString":"address"}],"id":58693,"name":"IFetcher","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57326,"src":"17674:8:120","typeDescriptions":{"typeIdentifier":"t_type$_t_contract$_IFetcher_$57326_$","typeString":"type(contract IFetcher)"}},"id":58695,"isConstant":false,"isLValue":false,"isPure":false,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"17674:37:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_contract$_IFetcher_$57326","typeString":"contract IFetcher"}},"id":58696,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"17712:10:120","memberName":"challenger","nodeType":"MemberAccess","referencedDeclaration":57290,"src":"17674:48:120","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":58697,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"17674:50:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"VariableDeclarationStatement","src":"17653:71:120"},{"expression":{"arguments":[{"expression":{"expression":{"id":58702,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58531,"src":"17750:3:120","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$58249","typeString":"contract FetchChainInfoOutput"}},"id":58703,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"17754:10:120","memberName":"challenger","nodeType":"MemberAccess","referencedDeclaration":58169,"src":"17750:14:120","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":58704,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"17765:8:120","memberName":"selector","nodeType":"MemberAccess","src":"17750:23:120","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},{"id":58705,"name":"challenger","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58692,"src":"17775:10:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_bytes4","typeString":"bytes4"},{"typeIdentifier":"t_address","typeString":"address"}],"expression":{"id":58699,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58531,"src":"17742:3:120","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$58249","typeString":"contract FetchChainInfoOutput"}},"id":58701,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"17746:3:120","memberName":"set","nodeType":"MemberAccess","referencedDeclaration":57740,"src":"17742:7:120","typeDescriptions":{"typeIdentifier":"t_function_external_nonpayable$_t_bytes4_$_t_address_$returns$__$","typeString":"function (bytes4,address) external"}},"id":58706,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"17742:44:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":58707,"nodeType":"ExpressionStatement","src":"17742:44:120"},{"assignments":[58709],"declarations":[{"constant":false,"id":58709,"mutability":"mutable","name":"anchorStateRegistryProxy","nameLocation":"17813:24:120","nodeType":"VariableDeclaration","scope":58791,"src":"17805:32:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":58708,"name":"address","nodeType":"ElementaryTypeName","src":"17805:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"id":58715,"initialValue":{"arguments":[],"expression":{"argumentTypes":[],"expression":{"arguments":[{"id":58711,"name":"permissionedDisputeGameImpl","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58662,"src":"17849:27:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_address","typeString":"address"}],"id":58710,"name":"IFetcher","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57326,"src":"17840:8:120","typeDescriptions":{"typeIdentifier":"t_type$_t_contract$_IFetcher_$57326_$","typeString":"type(contract IFetcher)"}},"id":58712,"isConstant":false,"isLValue":false,"isPure":false,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"17840:37:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_contract$_IFetcher_$57326","typeString":"contract IFetcher"}},"id":58713,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"17878:19:120","memberName":"anchorStateRegistry","nodeType":"MemberAccess","referencedDeclaration":57265,"src":"17840:57:120","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":58714,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"17840:59:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"VariableDeclarationStatement","src":"17805:94:120"},{"expression":{"arguments":[{"expression":{"expression":{"id":58719,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58531,"src":"17925:3:120","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$58249","typeString":"contract FetchChainInfoOutput"}},"id":58720,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"17929:24:120","memberName":"anchorStateRegistryProxy","nodeType":"MemberAccess","referencedDeclaration":58001,"src":"17925:28:120","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":58721,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"17954:8:120","memberName":"selector","nodeType":"MemberAccess","src":"17925:37:120","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},{"id":58722,"name":"anchorStateRegistryProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58709,"src":"17964:24:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_bytes4","typeString":"bytes4"},{"typeIdentifier":"t_address","typeString":"address"}],"expression":{"id":58716,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58531,"src":"17917:3:120","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$58249","typeString":"contract FetchChainInfoOutput"}},"id":58718,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"17921:3:120","memberName":"set","nodeType":"MemberAccess","referencedDeclaration":57740,"src":"17917:7:120","typeDescriptions":{"typeIdentifier":"t_function_external_nonpayable$_t_bytes4_$_t_address_$returns$__$","typeString":"function (bytes4,address) external"}},"id":58723,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"17917:72:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":58724,"nodeType":"ExpressionStatement","src":"17917:72:120"},{"assignments":[58726],"declarations":[{"constant":false,"id":58726,"mutability":"mutable","name":"proposer","nameLocation":"18016:8:120","nodeType":"VariableDeclaration","scope":58791,"src":"18008:16:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":58725,"name":"address","nodeType":"ElementaryTypeName","src":"18008:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"id":58732,"initialValue":{"arguments":[],"expression":{"argumentTypes":[],"expression":{"arguments":[{"id":58728,"name":"permissionedDisputeGameImpl","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58662,"src":"18036:27:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_address","typeString":"address"}],"id":58727,"name":"IFetcher","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57326,"src":"18027:8:120","typeDescriptions":{"typeIdentifier":"t_type$_t_contract$_IFetcher_$57326_$","typeString":"type(contract IFetcher)"}},"id":58729,"isConstant":false,"isLValue":false,"isPure":false,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"18027:37:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_contract$_IFetcher_$57326","typeString":"contract IFetcher"}},"id":58730,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"18065:8:120","memberName":"proposer","nodeType":"MemberAccess","referencedDeclaration":57295,"src":"18027:46:120","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":58731,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"18027:48:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"VariableDeclarationStatement","src":"18008:67:120"},{"expression":{"arguments":[{"expression":{"expression":{"id":58736,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58531,"src":"18101:3:120","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$58249","typeString":"contract FetchChainInfoOutput"}},"id":58737,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"18105:8:120","memberName":"proposer","nodeType":"MemberAccess","referencedDeclaration":58187,"src":"18101:12:120","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":58738,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"18114:8:120","memberName":"selector","nodeType":"MemberAccess","src":"18101:21:120","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},{"id":58739,"name":"proposer","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58726,"src":"18124:8:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_bytes4","typeString":"bytes4"},{"typeIdentifier":"t_address","typeString":"address"}],"expression":{"id":58733,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58531,"src":"18093:3:120","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$58249","typeString":"contract FetchChainInfoOutput"}},"id":58735,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"18097:3:120","memberName":"set","nodeType":"MemberAccess","referencedDeclaration":57740,"src":"18093:7:120","typeDescriptions":{"typeIdentifier":"t_function_external_nonpayable$_t_bytes4_$_t_address_$returns$__$","typeString":"function (bytes4,address) external"}},"id":58740,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"18093:40:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":58741,"nodeType":"ExpressionStatement","src":"18093:40:120"},{"assignments":[58743],"declarations":[{"constant":false,"id":58743,"mutability":"mutable","name":"delayedWethPermissionedGameProxy","nameLocation":"18160:32:120","nodeType":"VariableDeclaration","scope":58791,"src":"18152:40:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":58742,"name":"address","nodeType":"ElementaryTypeName","src":"18152:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"id":58747,"initialValue":{"arguments":[{"id":58745,"name":"permissionedDisputeGameImpl","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58662,"src":"18216:27:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_address","typeString":"address"}],"id":58744,"name":"_getDelayedWETHProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":59248,"src":"18195:20:120","typeDescriptions":{"typeIdentifier":"t_function_internal_view$_t_address_$returns$_t_address_$","typeString":"function (address) view returns (address)"}},"id":58746,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"18195:49:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"VariableDeclarationStatement","src":"18152:92:120"},{"expression":{"arguments":[{"expression":{"expression":{"id":58751,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58531,"src":"18270:3:120","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$58249","typeString":"contract FetchChainInfoOutput"}},"id":58752,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"18274:32:120","memberName":"delayedWethPermissionedGameProxy","nodeType":"MemberAccess","referencedDeclaration":58009,"src":"18270:36:120","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":58753,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"18307:8:120","memberName":"selector","nodeType":"MemberAccess","src":"18270:45:120","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},{"id":58754,"name":"delayedWethPermissionedGameProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58743,"src":"18317:32:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_bytes4","typeString":"bytes4"},{"typeIdentifier":"t_address","typeString":"address"}],"expression":{"id":58748,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58531,"src":"18262:3:120","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$58249","typeString":"contract FetchChainInfoOutput"}},"id":58750,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"18266:3:120","memberName":"set","nodeType":"MemberAccess","referencedDeclaration":57740,"src":"18262:7:120","typeDescriptions":{"typeIdentifier":"t_function_external_nonpayable$_t_bytes4_$_t_address_$returns$__$","typeString":"function (bytes4,address) external"}},"id":58755,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"18262:88:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":58756,"nodeType":"ExpressionStatement","src":"18262:88:120"},{"assignments":[58758],"declarations":[{"constant":false,"id":58758,"mutability":"mutable","name":"mipsImpl","nameLocation":"18377:8:120","nodeType":"VariableDeclaration","scope":58791,"src":"18369:16:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":58757,"name":"address","nodeType":"ElementaryTypeName","src":"18369:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"id":58764,"initialValue":{"arguments":[],"expression":{"argumentTypes":[],"expression":{"arguments":[{"id":58760,"name":"permissionedDisputeGameImpl","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58662,"src":"18397:27:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_address","typeString":"address"}],"id":58759,"name":"IFetcher","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57326,"src":"18388:8:120","typeDescriptions":{"typeIdentifier":"t_type$_t_contract$_IFetcher_$57326_$","typeString":"type(contract IFetcher)"}},"id":58761,"isConstant":false,"isLValue":false,"isPure":false,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"18388:37:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_contract$_IFetcher_$57326","typeString":"contract IFetcher"}},"id":58762,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"18426:2:120","memberName":"vm","nodeType":"MemberAccess","referencedDeclaration":57280,"src":"18388:40:120","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":58763,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"18388:42:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"VariableDeclarationStatement","src":"18369:61:120"},{"expression":{"arguments":[{"expression":{"expression":{"id":58768,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58531,"src":"18456:3:120","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$58249","typeString":"contract FetchChainInfoOutput"}},"id":58769,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"18460:8:120","memberName":"mipsImpl","nodeType":"MemberAccess","referencedDeclaration":58061,"src":"18456:12:120","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":58770,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"18469:8:120","memberName":"selector","nodeType":"MemberAccess","src":"18456:21:120","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},{"id":58771,"name":"mipsImpl","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58758,"src":"18479:8:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_bytes4","typeString":"bytes4"},{"typeIdentifier":"t_address","typeString":"address"}],"expression":{"id":58765,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58531,"src":"18448:3:120","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$58249","typeString":"contract FetchChainInfoOutput"}},"id":58767,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"18452:3:120","memberName":"set","nodeType":"MemberAccess","referencedDeclaration":57740,"src":"18448:7:120","typeDescriptions":{"typeIdentifier":"t_function_external_nonpayable$_t_bytes4_$_t_address_$returns$__$","typeString":"function (bytes4,address) external"}},"id":58772,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"18448:40:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":58773,"nodeType":"ExpressionStatement","src":"18448:40:120"},{"assignments":[58775],"declarations":[{"constant":false,"id":58775,"mutability":"mutable","name":"preimageOracleImpl","nameLocation":"18515:18:120","nodeType":"VariableDeclaration","scope":58791,"src":"18507:26:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":58774,"name":"address","nodeType":"ElementaryTypeName","src":"18507:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"id":58781,"initialValue":{"arguments":[],"expression":{"argumentTypes":[],"expression":{"arguments":[{"id":58777,"name":"mipsImpl","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58758,"src":"18545:8:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_address","typeString":"address"}],"id":58776,"name":"IFetcher","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57326,"src":"18536:8:120","typeDescriptions":{"typeIdentifier":"t_type$_t_contract$_IFetcher_$57326_$","typeString":"type(contract IFetcher)"}},"id":58778,"isConstant":false,"isLValue":false,"isPure":false,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"18536:18:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_contract$_IFetcher_$57326","typeString":"contract IFetcher"}},"id":58779,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"18555:6:120","memberName":"oracle","nodeType":"MemberAccess","referencedDeclaration":57285,"src":"18536:25:120","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":58780,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"18536:27:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"VariableDeclarationStatement","src":"18507:56:120"},{"expression":{"arguments":[{"expression":{"expression":{"id":58785,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58531,"src":"18589:3:120","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$58249","typeString":"contract FetchChainInfoOutput"}},"id":58786,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"18593:18:120","memberName":"preimageOracleImpl","nodeType":"MemberAccess","referencedDeclaration":58097,"src":"18589:22:120","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":58787,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"18612:8:120","memberName":"selector","nodeType":"MemberAccess","src":"18589:31:120","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},{"id":58788,"name":"preimageOracleImpl","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58775,"src":"18622:18:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_bytes4","typeString":"bytes4"},{"typeIdentifier":"t_address","typeString":"address"}],"expression":{"id":58782,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58531,"src":"18581:3:120","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$58249","typeString":"contract FetchChainInfoOutput"}},"id":58784,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"18585:3:120","memberName":"set","nodeType":"MemberAccess","referencedDeclaration":57740,"src":"18581:7:120","typeDescriptions":{"typeIdentifier":"t_function_external_nonpayable$_t_bytes4_$_t_address_$returns$__$","typeString":"function (bytes4,address) external"}},"id":58789,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"18581:60:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":58790,"nodeType":"ExpressionStatement","src":"18581:60:120"}]}},{"assignments":[58794],"declarations":[{"constant":false,"id":58794,"mutability":"mutable","name":"faultDisputeGameImpl","nameLocation":"18678:20:120","nodeType":"VariableDeclaration","scope":58840,"src":"18670:28:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":58793,"name":"address","nodeType":"ElementaryTypeName","src":"18670:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"id":58798,"initialValue":{"arguments":[{"id":58796,"name":"disputeGameFactoryProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58641,"src":"18722:23:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_address","typeString":"address"}],"id":58795,"name":"_getFaultDisputeGame","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":59145,"src":"18701:20:120","typeDescriptions":{"typeIdentifier":"t_function_internal_view$_t_address_$returns$_t_address_$","typeString":"function (address) view returns (address)"}},"id":58797,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"18701:45:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"VariableDeclarationStatement","src":"18670:76:120"},{"condition":{"commonType":{"typeIdentifier":"t_address","typeString":"address"},"id":58804,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftExpression":{"id":58799,"name":"faultDisputeGameImpl","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58794,"src":"18764:20:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"BinaryOperation","operator":"!=","rightExpression":{"arguments":[{"hexValue":"30","id":58802,"isConstant":false,"isLValue":false,"isPure":true,"kind":"number","lValueRequested":false,"nodeType":"Literal","src":"18796:1:120","typeDescriptions":{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"},"value":"0"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"}],"id":58801,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"nodeType":"ElementaryTypeNameExpression","src":"18788:7:120","typeDescriptions":{"typeIdentifier":"t_type$_t_address_$","typeString":"type(address)"},"typeName":{"id":58800,"name":"address","nodeType":"ElementaryTypeName","src":"18788:7:120","typeDescriptions":{}}},"id":58803,"isConstant":false,"isLValue":false,"isPure":true,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"18788:10:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"src":"18764:34:120","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},"id":58839,"nodeType":"IfStatement","src":"18760:470:120","trueBody":{"id":58838,"nodeType":"Block","src":"18800:430:120","statements":[{"expression":{"arguments":[{"expression":{"expression":{"id":58808,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58531,"src":"18883:3:120","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$58249","typeString":"contract FetchChainInfoOutput"}},"id":58809,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"18887:20:120","memberName":"faultDisputeGameImpl","nodeType":"MemberAccess","referencedDeclaration":58043,"src":"18883:24:120","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":58810,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"18908:8:120","memberName":"selector","nodeType":"MemberAccess","src":"18883:33:120","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},{"id":58811,"name":"faultDisputeGameImpl","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58794,"src":"18918:20:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_bytes4","typeString":"bytes4"},{"typeIdentifier":"t_address","typeString":"address"}],"expression":{"id":58805,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58531,"src":"18875:3:120","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$58249","typeString":"contract FetchChainInfoOutput"}},"id":58807,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"18879:3:120","memberName":"set","nodeType":"MemberAccess","referencedDeclaration":57740,"src":"18875:7:120","typeDescriptions":{"typeIdentifier":"t_function_external_nonpayable$_t_bytes4_$_t_address_$returns$__$","typeString":"function (bytes4,address) external"}},"id":58812,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"18875:64:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":58813,"nodeType":"ExpressionStatement","src":"18875:64:120"},{"expression":{"arguments":[{"expression":{"expression":{"id":58817,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58531,"src":"18965:3:120","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$58249","typeString":"contract FetchChainInfoOutput"}},"id":58818,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"18969:14:120","memberName":"permissionless","nodeType":"MemberAccess","referencedDeclaration":58239,"src":"18965:18:120","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_bool_$","typeString":"function () view external returns (bool)"}},"id":58819,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"18984:8:120","memberName":"selector","nodeType":"MemberAccess","src":"18965:27:120","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},{"hexValue":"74727565","id":58820,"isConstant":false,"isLValue":false,"isPure":true,"kind":"bool","lValueRequested":false,"nodeType":"Literal","src":"18994:4:120","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"},"value":"true"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_bytes4","typeString":"bytes4"},{"typeIdentifier":"t_bool","typeString":"bool"}],"expression":{"id":58814,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58531,"src":"18957:3:120","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$58249","typeString":"contract FetchChainInfoOutput"}},"id":58816,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"18961:3:120","memberName":"set","nodeType":"MemberAccess","referencedDeclaration":57772,"src":"18957:7:120","typeDescriptions":{"typeIdentifier":"t_function_external_nonpayable$_t_bytes4_$_t_bool_$returns$__$","typeString":"function (bytes4,bool) external"}},"id":58821,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"18957:42:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":58822,"nodeType":"ExpressionStatement","src":"18957:42:120"},{"assignments":[58824],"declarations":[{"constant":false,"id":58824,"mutability":"mutable","name":"delayedWethPermissionlessGameProxy","nameLocation":"19026:34:120","nodeType":"VariableDeclaration","scope":58838,"src":"19018:42:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":58823,"name":"address","nodeType":"ElementaryTypeName","src":"19018:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"id":58828,"initialValue":{"arguments":[{"id":58826,"name":"faultDisputeGameImpl","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58794,"src":"19084:20:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_address","typeString":"address"}],"id":58825,"name":"_getDelayedWETHProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":59248,"src":"19063:20:120","typeDescriptions":{"typeIdentifier":"t_function_internal_view$_t_address_$returns$_t_address_$","typeString":"function (address) view returns (address)"}},"id":58827,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"19063:42:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"VariableDeclarationStatement","src":"19018:87:120"},{"expression":{"arguments":[{"expression":{"expression":{"id":58832,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58531,"src":"19131:3:120","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$58249","typeString":"contract FetchChainInfoOutput"}},"id":58833,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"19135:34:120","memberName":"delayedWethPermissionlessGameProxy","nodeType":"MemberAccess","referencedDeclaration":58017,"src":"19131:38:120","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":58834,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"19170:8:120","memberName":"selector","nodeType":"MemberAccess","src":"19131:47:120","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},{"id":58835,"name":"delayedWethPermissionlessGameProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58824,"src":"19180:34:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_bytes4","typeString":"bytes4"},{"typeIdentifier":"t_address","typeString":"address"}],"expression":{"id":58829,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58531,"src":"19123:3:120","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$58249","typeString":"contract FetchChainInfoOutput"}},"id":58831,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"19127:3:120","memberName":"set","nodeType":"MemberAccess","referencedDeclaration":57740,"src":"19123:7:120","typeDescriptions":{"typeIdentifier":"t_function_external_nonpayable$_t_bytes4_$_t_address_$returns$__$","typeString":"function (bytes4,address) external"}},"id":58836,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"19123:92:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":58837,"nodeType":"ExpressionStatement","src":"19123:92:120"}]}}]}}]},"implemented":true,"kind":"function","modifiers":[],"name":"_processFaultProofs","nameLocation":"15931:19:120","parameters":{"id":58532,"nodeType":"ParameterList","parameters":[{"constant":false,"id":58531,"mutability":"mutable","name":"_fo","nameLocation":"15972:3:120","nodeType":"VariableDeclaration","scope":58878,"src":"15951:24:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$58249","typeString":"contract FetchChainInfoOutput"},"typeName":{"id":58530,"nodeType":"UserDefinedTypeName","pathNode":{"id":58529,"name":"FetchChainInfoOutput","nameLocations":["15951:20:120"],"nodeType":"IdentifierPath","referencedDeclaration":58249,"src":"15951:20:120"},"referencedDeclaration":58249,"src":"15951:20:120","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$58249","typeString":"contract FetchChainInfoOutput"}},"visibility":"internal"}],"src":"15950:26:120"},"returnParameters":{"id":58533,"nodeType":"ParameterList","parameters":[],"src":"15986:0:120"},"scope":59299,"stateMutability":"nonpayable","virtual":false,"visibility":"internal"},{"id":58907,"nodeType":"FunctionDefinition","src":"19641:256:120","nodes":[],"body":{"id":58906,"nodeType":"Block","src":"19712:185:120","nodes":[],"statements":[{"clauses":[{"block":{"id":58895,"nodeType":"Block","src":"19783:41:120","statements":[{"expression":{"id":58893,"name":"guardian_","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58891,"src":"19804:9:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"functionReturnParameters":58884,"id":58894,"nodeType":"Return","src":"19797:16:120"}]},"errorName":"","id":58896,"nodeType":"TryCatchClause","parameters":{"id":58892,"nodeType":"ParameterList","parameters":[{"constant":false,"id":58891,"mutability":"mutable","name":"guardian_","nameLocation":"19772:9:120","nodeType":"VariableDeclaration","scope":58896,"src":"19764:17:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":58890,"name":"address","nodeType":"ElementaryTypeName","src":"19764:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"19763:19:120"},"src":"19755:69:120"},{"block":{"id":58903,"nodeType":"Block","src":"19831:60:120","statements":[{"expression":{"arguments":[],"expression":{"argumentTypes":[],"expression":{"arguments":[{"id":58898,"name":"_portal","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58880,"src":"19861:7:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_address","typeString":"address"}],"id":58897,"name":"IFetcher","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57326,"src":"19852:8:120","typeDescriptions":{"typeIdentifier":"t_type$_t_contract$_IFetcher_$57326_$","typeString":"type(contract IFetcher)"}},"id":58899,"isConstant":false,"isLValue":false,"isPure":false,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"19852:17:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_contract$_IFetcher_$57326","typeString":"contract IFetcher"}},"id":58900,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"19870:8:120","memberName":"GUARDIAN","nodeType":"MemberAccess","referencedDeclaration":57191,"src":"19852:26:120","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":58901,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"19852:28:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"functionReturnParameters":58884,"id":58902,"nodeType":"Return","src":"19845:35:120"}]},"errorName":"","id":58904,"nodeType":"TryCatchClause","src":"19825:66:120"}],"externalCall":{"arguments":[],"expression":{"argumentTypes":[],"expression":{"arguments":[{"id":58886,"name":"_portal","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58880,"src":"19735:7:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_address","typeString":"address"}],"id":58885,"name":"IFetcher","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57326,"src":"19726:8:120","typeDescriptions":{"typeIdentifier":"t_type$_t_contract$_IFetcher_$57326_$","typeString":"type(contract IFetcher)"}},"id":58887,"isConstant":false,"isLValue":false,"isPure":false,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"19726:17:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_contract$_IFetcher_$57326","typeString":"contract IFetcher"}},"id":58888,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"19744:8:120","memberName":"guardian","nodeType":"MemberAccess","referencedDeclaration":57186,"src":"19726:26:120","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":58889,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"19726:28:120","tryCall":true,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"id":58905,"nodeType":"TryStatement","src":"19722:169:120"}]},"implemented":true,"kind":"function","modifiers":[],"name":"_getGuardian","nameLocation":"19650:12:120","parameters":{"id":58881,"nodeType":"ParameterList","parameters":[{"constant":false,"id":58880,"mutability":"mutable","name":"_portal","nameLocation":"19671:7:120","nodeType":"VariableDeclaration","scope":58907,"src":"19663:15:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":58879,"name":"address","nodeType":"ElementaryTypeName","src":"19663:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"19662:17:120"},"returnParameters":{"id":58884,"nodeType":"ParameterList","parameters":[{"constant":false,"id":58883,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":58907,"src":"19703:7:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":58882,"name":"address","nodeType":"ElementaryTypeName","src":"19703:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"19702:9:120"},"scope":59299,"stateMutability":"view","virtual":false,"visibility":"internal"},{"id":58936,"nodeType":"FunctionDefinition","src":"19903:282:120","nodes":[],"body":{"id":58935,"nodeType":"Block","src":"19983:202:120","nodes":[],"statements":[{"clauses":[{"block":{"id":58924,"nodeType":"Block","src":"20062:45:120","statements":[{"expression":{"id":58922,"name":"systemConfig_","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58920,"src":"20083:13:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"functionReturnParameters":58913,"id":58923,"nodeType":"Return","src":"20076:20:120"}]},"errorName":"","id":58925,"nodeType":"TryCatchClause","parameters":{"id":58921,"nodeType":"ParameterList","parameters":[{"constant":false,"id":58920,"mutability":"mutable","name":"systemConfig_","nameLocation":"20047:13:120","nodeType":"VariableDeclaration","scope":58925,"src":"20039:21:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":58919,"name":"address","nodeType":"ElementaryTypeName","src":"20039:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"20038:23:120"},"src":"20030:77:120"},{"block":{"id":58932,"nodeType":"Block","src":"20114:65:120","statements":[{"expression":{"arguments":[],"expression":{"argumentTypes":[],"expression":{"arguments":[{"id":58927,"name":"_portal","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58909,"src":"20144:7:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_address","typeString":"address"}],"id":58926,"name":"IFetcher","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57326,"src":"20135:8:120","typeDescriptions":{"typeIdentifier":"t_type$_t_contract$_IFetcher_$57326_$","typeString":"type(contract IFetcher)"}},"id":58928,"isConstant":false,"isLValue":false,"isPure":false,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"20135:17:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_contract$_IFetcher_$57326","typeString":"contract IFetcher"}},"id":58929,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"20153:13:120","memberName":"SYSTEM_CONFIG","nodeType":"MemberAccess","referencedDeclaration":57201,"src":"20135:31:120","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":58930,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"20135:33:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"functionReturnParameters":58913,"id":58931,"nodeType":"Return","src":"20128:40:120"}]},"errorName":"","id":58933,"nodeType":"TryCatchClause","src":"20108:71:120"}],"externalCall":{"arguments":[],"expression":{"argumentTypes":[],"expression":{"arguments":[{"id":58915,"name":"_portal","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58909,"src":"20006:7:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_address","typeString":"address"}],"id":58914,"name":"IFetcher","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57326,"src":"19997:8:120","typeDescriptions":{"typeIdentifier":"t_type$_t_contract$_IFetcher_$57326_$","typeString":"type(contract IFetcher)"}},"id":58916,"isConstant":false,"isLValue":false,"isPure":false,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"19997:17:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_contract$_IFetcher_$57326","typeString":"contract IFetcher"}},"id":58917,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"20015:12:120","memberName":"systemConfig","nodeType":"MemberAccess","referencedDeclaration":57196,"src":"19997:30:120","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":58918,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"19997:32:120","tryCall":true,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"id":58934,"nodeType":"TryStatement","src":"19993:186:120"}]},"implemented":true,"kind":"function","modifiers":[],"name":"_getSystemConfigProxy","nameLocation":"19912:21:120","parameters":{"id":58910,"nodeType":"ParameterList","parameters":[{"constant":false,"id":58909,"mutability":"mutable","name":"_portal","nameLocation":"19942:7:120","nodeType":"VariableDeclaration","scope":58936,"src":"19934:15:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":58908,"name":"address","nodeType":"ElementaryTypeName","src":"19934:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"19933:17:120"},"returnParameters":{"id":58913,"nodeType":"ParameterList","parameters":[{"constant":false,"id":58912,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":58936,"src":"19974:7:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":58911,"name":"address","nodeType":"ElementaryTypeName","src":"19974:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"19973:9:120"},"scope":59299,"stateMutability":"view","virtual":false,"visibility":"internal"},{"id":58965,"nodeType":"FunctionDefinition","src":"20191:338:120","nodes":[],"body":{"id":58964,"nodeType":"Block","src":"20294:235:120","nodes":[],"statements":[{"clauses":[{"block":{"id":58953,"nodeType":"Block","src":"20390:47:120","statements":[{"expression":{"id":58951,"name":"optimismPortal_","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58949,"src":"20411:15:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"functionReturnParameters":58942,"id":58952,"nodeType":"Return","src":"20404:22:120"}]},"errorName":"","id":58954,"nodeType":"TryCatchClause","parameters":{"id":58950,"nodeType":"ParameterList","parameters":[{"constant":false,"id":58949,"mutability":"mutable","name":"optimismPortal_","nameLocation":"20373:15:120","nodeType":"VariableDeclaration","scope":58954,"src":"20365:23:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":58948,"name":"address","nodeType":"ElementaryTypeName","src":"20365:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"20364:25:120"},"src":"20356:81:120"},{"block":{"id":58961,"nodeType":"Block","src":"20444:79:120","statements":[{"expression":{"arguments":[],"expression":{"argumentTypes":[],"expression":{"arguments":[{"id":58956,"name":"_l1CrossDomainMessengerProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58938,"src":"20474:28:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_address","typeString":"address"}],"id":58955,"name":"IFetcher","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57326,"src":"20465:8:120","typeDescriptions":{"typeIdentifier":"t_type$_t_contract$_IFetcher_$57326_$","typeString":"type(contract IFetcher)"}},"id":58957,"isConstant":false,"isLValue":false,"isPure":false,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"20465:38:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_contract$_IFetcher_$57326","typeString":"contract IFetcher"}},"id":58958,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"20504:6:120","memberName":"PORTAL","nodeType":"MemberAccess","referencedDeclaration":57231,"src":"20465:45:120","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":58959,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"20465:47:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"functionReturnParameters":58942,"id":58960,"nodeType":"Return","src":"20458:54:120"}]},"errorName":"","id":58962,"nodeType":"TryCatchClause","src":"20438:85:120"}],"externalCall":{"arguments":[],"expression":{"argumentTypes":[],"expression":{"arguments":[{"id":58944,"name":"_l1CrossDomainMessengerProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58938,"src":"20317:28:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_address","typeString":"address"}],"id":58943,"name":"IFetcher","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57326,"src":"20308:8:120","typeDescriptions":{"typeIdentifier":"t_type$_t_contract$_IFetcher_$57326_$","typeString":"type(contract IFetcher)"}},"id":58945,"isConstant":false,"isLValue":false,"isPure":false,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"20308:38:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_contract$_IFetcher_$57326","typeString":"contract IFetcher"}},"id":58946,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"20347:6:120","memberName":"portal","nodeType":"MemberAccess","referencedDeclaration":57236,"src":"20308:45:120","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":58947,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"20308:47:120","tryCall":true,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"id":58963,"nodeType":"TryStatement","src":"20304:219:120"}]},"implemented":true,"kind":"function","modifiers":[],"name":"_getOptimismPortalProxy","nameLocation":"20200:23:120","parameters":{"id":58939,"nodeType":"ParameterList","parameters":[{"constant":false,"id":58938,"mutability":"mutable","name":"_l1CrossDomainMessengerProxy","nameLocation":"20232:28:120","nodeType":"VariableDeclaration","scope":58965,"src":"20224:36:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":58937,"name":"address","nodeType":"ElementaryTypeName","src":"20224:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"20223:38:120"},"returnParameters":{"id":58942,"nodeType":"ParameterList","parameters":[{"constant":false,"id":58941,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":58965,"src":"20285:7:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":58940,"name":"address","nodeType":"ElementaryTypeName","src":"20285:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"20284:9:120"},"scope":59299,"stateMutability":"view","virtual":false,"visibility":"internal"},{"id":59003,"nodeType":"FunctionDefinition","src":"20535:350:120","nodes":[],"body":{"id":59002,"nodeType":"Block","src":"20633:252:120","nodes":[],"statements":[{"assignments":[58973],"declarations":[{"constant":false,"id":58973,"mutability":"mutable","name":"ADDRESS_MANAGER_MAPPING_SLOT","nameLocation":"20651:28:120","nodeType":"VariableDeclaration","scope":59002,"src":"20643:36:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_uint256","typeString":"uint256"},"typeName":{"id":58972,"name":"uint256","nodeType":"ElementaryTypeName","src":"20643:7:120","typeDescriptions":{"typeIdentifier":"t_uint256","typeString":"uint256"}},"visibility":"internal"}],"id":58975,"initialValue":{"hexValue":"31","id":58974,"isConstant":false,"isLValue":false,"isPure":true,"kind":"number","lValueRequested":false,"nodeType":"Literal","src":"20682:1:120","typeDescriptions":{"typeIdentifier":"t_rational_1_by_1","typeString":"int_const 1"},"value":"1"},"nodeType":"VariableDeclarationStatement","src":"20643:40:120"},{"assignments":[58977],"declarations":[{"constant":false,"id":58977,"mutability":"mutable","name":"slot","nameLocation":"20701:4:120","nodeType":"VariableDeclaration","scope":59002,"src":"20693:12:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_bytes32","typeString":"bytes32"},"typeName":{"id":58976,"name":"bytes32","nodeType":"ElementaryTypeName","src":"20693:7:120","typeDescriptions":{"typeIdentifier":"t_bytes32","typeString":"bytes32"}},"visibility":"internal"}],"id":58985,"initialValue":{"arguments":[{"arguments":[{"id":58981,"name":"_l1CrossDomainMessengerProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58967,"src":"20729:28:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},{"id":58982,"name":"ADDRESS_MANAGER_MAPPING_SLOT","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58973,"src":"20759:28:120","typeDescriptions":{"typeIdentifier":"t_uint256","typeString":"uint256"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_address","typeString":"address"},{"typeIdentifier":"t_uint256","typeString":"uint256"}],"expression":{"id":58979,"name":"abi","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":-1,"src":"20718:3:120","typeDescriptions":{"typeIdentifier":"t_magic_abi","typeString":"abi"}},"id":58980,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"memberLocation":"20722:6:120","memberName":"encode","nodeType":"MemberAccess","src":"20718:10:120","typeDescriptions":{"typeIdentifier":"t_function_abiencode_pure$__$returns$_t_bytes_memory_ptr_$","typeString":"function () pure returns (bytes memory)"}},"id":58983,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"20718:70:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_bytes_memory_ptr","typeString":"bytes memory"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_bytes_memory_ptr","typeString":"bytes memory"}],"id":58978,"name":"keccak256","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":-8,"src":"20708:9:120","typeDescriptions":{"typeIdentifier":"t_function_keccak256_pure$_t_bytes_memory_ptr_$returns$_t_bytes32_$","typeString":"function (bytes memory) pure returns (bytes32)"}},"id":58984,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"20708:81:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_bytes32","typeString":"bytes32"}},"nodeType":"VariableDeclarationStatement","src":"20693:96:120"},{"expression":{"arguments":[{"arguments":[{"arguments":[{"components":[{"arguments":[{"id":58994,"name":"_l1CrossDomainMessengerProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58967,"src":"20839:28:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},{"id":58995,"name":"slot","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58977,"src":"20869:4:120","typeDescriptions":{"typeIdentifier":"t_bytes32","typeString":"bytes32"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_address","typeString":"address"},{"typeIdentifier":"t_bytes32","typeString":"bytes32"}],"expression":{"id":58992,"name":"vm","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":5980,"src":"20831:2:120","typeDescriptions":{"typeIdentifier":"t_contract$_Vm_$23767","typeString":"contract Vm"}},"id":58993,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"20834:4:120","memberName":"load","nodeType":"MemberAccess","referencedDeclaration":19863,"src":"20831:7:120","typeDescriptions":{"typeIdentifier":"t_function_external_view$_t_address_$_t_bytes32_$returns$_t_bytes32_$","typeString":"function (address,bytes32) view external returns (bytes32)"}},"id":58996,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"20831:43:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_bytes32","typeString":"bytes32"}}],"id":58997,"isConstant":false,"isInlineArray":false,"isLValue":false,"isPure":false,"lValueRequested":false,"nodeType":"TupleExpression","src":"20830:45:120","typeDescriptions":{"typeIdentifier":"t_bytes32","typeString":"bytes32"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_bytes32","typeString":"bytes32"}],"id":58991,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"nodeType":"ElementaryTypeNameExpression","src":"20822:7:120","typeDescriptions":{"typeIdentifier":"t_type$_t_uint256_$","typeString":"type(uint256)"},"typeName":{"id":58990,"name":"uint256","nodeType":"ElementaryTypeName","src":"20822:7:120","typeDescriptions":{}}},"id":58998,"isConstant":false,"isLValue":false,"isPure":false,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"20822:54:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_uint256","typeString":"uint256"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_uint256","typeString":"uint256"}],"id":58989,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"nodeType":"ElementaryTypeNameExpression","src":"20814:7:120","typeDescriptions":{"typeIdentifier":"t_type$_t_uint160_$","typeString":"type(uint160)"},"typeName":{"id":58988,"name":"uint160","nodeType":"ElementaryTypeName","src":"20814:7:120","typeDescriptions":{}}},"id":58999,"isConstant":false,"isLValue":false,"isPure":false,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"20814:63:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_uint160","typeString":"uint160"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_uint160","typeString":"uint160"}],"id":58987,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"nodeType":"ElementaryTypeNameExpression","src":"20806:7:120","typeDescriptions":{"typeIdentifier":"t_type$_t_address_$","typeString":"type(address)"},"typeName":{"id":58986,"name":"address","nodeType":"ElementaryTypeName","src":"20806:7:120","typeDescriptions":{}}},"id":59000,"isConstant":false,"isLValue":false,"isPure":false,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"20806:72:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"functionReturnParameters":58971,"id":59001,"nodeType":"Return","src":"20799:79:120"}]},"implemented":true,"kind":"function","modifiers":[],"name":"_getAddressManager","nameLocation":"20544:18:120","parameters":{"id":58968,"nodeType":"ParameterList","parameters":[{"constant":false,"id":58967,"mutability":"mutable","name":"_l1CrossDomainMessengerProxy","nameLocation":"20571:28:120","nodeType":"VariableDeclaration","scope":59003,"src":"20563:36:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":58966,"name":"address","nodeType":"ElementaryTypeName","src":"20563:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"20562:38:120"},"returnParameters":{"id":58971,"nodeType":"ParameterList","parameters":[{"constant":false,"id":58970,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":59003,"src":"20624:7:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":58969,"name":"address","nodeType":"ElementaryTypeName","src":"20624:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"20623:9:120"},"scope":59299,"stateMutability":"view","virtual":false,"visibility":"internal"},{"id":59031,"nodeType":"FunctionDefinition","src":"20891:299:120","nodes":[],"body":{"id":59030,"nodeType":"Block","src":"20984:206:120","nodes":[],"statements":[{"clauses":[{"block":{"id":59020,"nodeType":"Block","src":"21083:52:120","statements":[{"expression":{"id":59018,"name":"l1ERC721BridgeProxy_","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":59016,"src":"21104:20:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"functionReturnParameters":59009,"id":59019,"nodeType":"Return","src":"21097:27:120"}]},"errorName":"","id":59021,"nodeType":"TryCatchClause","parameters":{"id":59017,"nodeType":"ParameterList","parameters":[{"constant":false,"id":59016,"mutability":"mutable","name":"l1ERC721BridgeProxy_","nameLocation":"21061:20:120","nodeType":"VariableDeclaration","scope":59021,"src":"21053:28:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":59015,"name":"address","nodeType":"ElementaryTypeName","src":"21053:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"21052:30:120"},"src":"21044:91:120"},{"block":{"id":59027,"nodeType":"Block","src":"21142:42:120","statements":[{"expression":{"arguments":[{"hexValue":"30","id":59024,"isConstant":false,"isLValue":false,"isPure":true,"kind":"number","lValueRequested":false,"nodeType":"Literal","src":"21171:1:120","typeDescriptions":{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"},"value":"0"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"}],"id":59023,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"nodeType":"ElementaryTypeNameExpression","src":"21163:7:120","typeDescriptions":{"typeIdentifier":"t_type$_t_address_$","typeString":"type(address)"},"typeName":{"id":59022,"name":"address","nodeType":"ElementaryTypeName","src":"21163:7:120","typeDescriptions":{}}},"id":59025,"isConstant":false,"isLValue":false,"isPure":true,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"21163:10:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"functionReturnParameters":59009,"id":59026,"nodeType":"Return","src":"21156:17:120"}]},"errorName":"","id":59028,"nodeType":"TryCatchClause","src":"21136:48:120"}],"externalCall":{"arguments":[],"expression":{"argumentTypes":[],"expression":{"arguments":[{"id":59011,"name":"_systemConfigProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":59005,"src":"21007:18:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_address","typeString":"address"}],"id":59010,"name":"IFetcher","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57326,"src":"20998:8:120","typeDescriptions":{"typeIdentifier":"t_type$_t_contract$_IFetcher_$57326_$","typeString":"type(contract IFetcher)"}},"id":59012,"isConstant":false,"isLValue":false,"isPure":false,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"20998:28:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_contract$_IFetcher_$57326","typeString":"contract IFetcher"}},"id":59013,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"21027:14:120","memberName":"l1ERC721Bridge","nodeType":"MemberAccess","referencedDeclaration":57241,"src":"20998:43:120","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":59014,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"20998:45:120","tryCall":true,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"id":59029,"nodeType":"TryStatement","src":"20994:190:120"}]},"implemented":true,"kind":"function","modifiers":[],"name":"_getL1ERC721BridgeProxy","nameLocation":"20900:23:120","parameters":{"id":59006,"nodeType":"ParameterList","parameters":[{"constant":false,"id":59005,"mutability":"mutable","name":"_systemConfigProxy","nameLocation":"20932:18:120","nodeType":"VariableDeclaration","scope":59031,"src":"20924:26:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":59004,"name":"address","nodeType":"ElementaryTypeName","src":"20924:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"20923:28:120"},"returnParameters":{"id":59009,"nodeType":"ParameterList","parameters":[{"constant":false,"id":59008,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":59031,"src":"20975:7:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":59007,"name":"address","nodeType":"ElementaryTypeName","src":"20975:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"20974:9:120"},"scope":59299,"stateMutability":"view","virtual":false,"visibility":"internal"},{"id":59059,"nodeType":"FunctionDefinition","src":"21196:377:120","nodes":[],"body":{"id":59058,"nodeType":"Block","src":"21303:270:120","nodes":[],"statements":[{"clauses":[{"block":{"id":59048,"nodeType":"Block","src":"21452:66:120","statements":[{"expression":{"id":59046,"name":"optimismMintableERC20FactoryProxy_","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":59044,"src":"21473:34:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"functionReturnParameters":59037,"id":59047,"nodeType":"Return","src":"21466:41:120"}]},"errorName":"","id":59049,"nodeType":"TryCatchClause","parameters":{"id":59045,"nodeType":"ParameterList","parameters":[{"constant":false,"id":59044,"mutability":"mutable","name":"optimismMintableERC20FactoryProxy_","nameLocation":"21407:34:120","nodeType":"VariableDeclaration","scope":59049,"src":"21399:42:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":59043,"name":"address","nodeType":"ElementaryTypeName","src":"21399:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"21385:66:120"},"src":"21377:141:120"},{"block":{"id":59055,"nodeType":"Block","src":"21525:42:120","statements":[{"expression":{"arguments":[{"hexValue":"30","id":59052,"isConstant":false,"isLValue":false,"isPure":true,"kind":"number","lValueRequested":false,"nodeType":"Literal","src":"21554:1:120","typeDescriptions":{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"},"value":"0"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"}],"id":59051,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"nodeType":"ElementaryTypeNameExpression","src":"21546:7:120","typeDescriptions":{"typeIdentifier":"t_type$_t_address_$","typeString":"type(address)"},"typeName":{"id":59050,"name":"address","nodeType":"ElementaryTypeName","src":"21546:7:120","typeDescriptions":{}}},"id":59053,"isConstant":false,"isLValue":false,"isPure":true,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"21546:10:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"functionReturnParameters":59037,"id":59054,"nodeType":"Return","src":"21539:17:120"}]},"errorName":"","id":59056,"nodeType":"TryCatchClause","src":"21519:48:120"}],"externalCall":{"arguments":[],"expression":{"argumentTypes":[],"expression":{"arguments":[{"id":59039,"name":"_systemConfigProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":59033,"src":"21326:18:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_address","typeString":"address"}],"id":59038,"name":"IFetcher","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57326,"src":"21317:8:120","typeDescriptions":{"typeIdentifier":"t_type$_t_contract$_IFetcher_$57326_$","typeString":"type(contract IFetcher)"}},"id":59040,"isConstant":false,"isLValue":false,"isPure":false,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"21317:28:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_contract$_IFetcher_$57326","typeString":"contract IFetcher"}},"id":59041,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"21346:28:120","memberName":"optimismMintableERC20Factory","nodeType":"MemberAccess","referencedDeclaration":57246,"src":"21317:57:120","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":59042,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"21317:59:120","tryCall":true,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"id":59057,"nodeType":"TryStatement","src":"21313:254:120"}]},"implemented":true,"kind":"function","modifiers":[],"name":"_getOptimismMintableERC20FactoryProxy","nameLocation":"21205:37:120","parameters":{"id":59034,"nodeType":"ParameterList","parameters":[{"constant":false,"id":59033,"mutability":"mutable","name":"_systemConfigProxy","nameLocation":"21251:18:120","nodeType":"VariableDeclaration","scope":59059,"src":"21243:26:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":59032,"name":"address","nodeType":"ElementaryTypeName","src":"21243:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"21242:28:120"},"returnParameters":{"id":59037,"nodeType":"ParameterList","parameters":[{"constant":false,"id":59036,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":59059,"src":"21294:7:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":59035,"name":"address","nodeType":"ElementaryTypeName","src":"21294:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"21293:9:120"},"scope":59299,"stateMutability":"view","virtual":false,"visibility":"internal"},{"id":59087,"nodeType":"FunctionDefinition","src":"21579:398:120","nodes":[],"body":{"id":59086,"nodeType":"Block","src":"21676:301:120","nodes":[],"statements":[{"clauses":[{"block":{"id":59076,"nodeType":"Block","src":"21783:56:120","statements":[{"expression":{"id":59074,"name":"disputeGameFactoryProxy_","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":59072,"src":"21804:24:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"functionReturnParameters":59065,"id":59075,"nodeType":"Return","src":"21797:31:120"}]},"errorName":"","id":59077,"nodeType":"TryCatchClause","parameters":{"id":59073,"nodeType":"ParameterList","parameters":[{"constant":false,"id":59072,"mutability":"mutable","name":"disputeGameFactoryProxy_","nameLocation":"21757:24:120","nodeType":"VariableDeclaration","scope":59077,"src":"21749:32:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":59071,"name":"address","nodeType":"ElementaryTypeName","src":"21749:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"21748:34:120"},"src":"21740:99:120"},{"block":{"id":59083,"nodeType":"Block","src":"21846:125:120","statements":[{"expression":{"arguments":[{"hexValue":"30","id":59080,"isConstant":false,"isLValue":false,"isPure":true,"kind":"number","lValueRequested":false,"nodeType":"Literal","src":"21958:1:120","typeDescriptions":{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"},"value":"0"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"}],"id":59079,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"nodeType":"ElementaryTypeNameExpression","src":"21950:7:120","typeDescriptions":{"typeIdentifier":"t_type$_t_address_$","typeString":"type(address)"},"typeName":{"id":59078,"name":"address","nodeType":"ElementaryTypeName","src":"21950:7:120","typeDescriptions":{}}},"id":59081,"isConstant":false,"isLValue":false,"isPure":true,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"21950:10:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"functionReturnParameters":59065,"id":59082,"nodeType":"Return","src":"21943:17:120"}]},"errorName":"","id":59084,"nodeType":"TryCatchClause","src":"21840:131:120"}],"externalCall":{"arguments":[],"expression":{"argumentTypes":[],"expression":{"arguments":[{"id":59067,"name":"_systemConfigProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":59061,"src":"21699:18:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_address","typeString":"address"}],"id":59066,"name":"IFetcher","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57326,"src":"21690:8:120","typeDescriptions":{"typeIdentifier":"t_type$_t_contract$_IFetcher_$57326_$","typeString":"type(contract IFetcher)"}},"id":59068,"isConstant":false,"isLValue":false,"isPure":false,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"21690:28:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_contract$_IFetcher_$57326","typeString":"contract IFetcher"}},"id":59069,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"21719:18:120","memberName":"disputeGameFactory","nodeType":"MemberAccess","referencedDeclaration":57206,"src":"21690:47:120","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":59070,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"21690:49:120","tryCall":true,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"id":59085,"nodeType":"TryStatement","src":"21686:285:120"}]},"implemented":true,"kind":"function","modifiers":[],"name":"_getDisputeGameFactoryProxy","nameLocation":"21588:27:120","parameters":{"id":59062,"nodeType":"ParameterList","parameters":[{"constant":false,"id":59061,"mutability":"mutable","name":"_systemConfigProxy","nameLocation":"21624:18:120","nodeType":"VariableDeclaration","scope":59087,"src":"21616:26:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":59060,"name":"address","nodeType":"ElementaryTypeName","src":"21616:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"21615:28:120"},"returnParameters":{"id":59065,"nodeType":"ParameterList","parameters":[{"constant":false,"id":59064,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":59087,"src":"21667:7:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":59063,"name":"address","nodeType":"ElementaryTypeName","src":"21667:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"21666:9:120"},"scope":59299,"stateMutability":"view","virtual":false,"visibility":"internal"},{"id":59115,"nodeType":"FunctionDefinition","src":"21983:311:120","nodes":[],"body":{"id":59114,"nodeType":"Block","src":"22080:214:120","nodes":[],"statements":[{"clauses":[{"block":{"id":59104,"nodeType":"Block","src":"22185:54:120","statements":[{"expression":{"id":59102,"name":"superchainConfigProxy_","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":59100,"src":"22206:22:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"functionReturnParameters":59093,"id":59103,"nodeType":"Return","src":"22199:29:120"}]},"errorName":"","id":59105,"nodeType":"TryCatchClause","parameters":{"id":59101,"nodeType":"ParameterList","parameters":[{"constant":false,"id":59100,"mutability":"mutable","name":"superchainConfigProxy_","nameLocation":"22161:22:120","nodeType":"VariableDeclaration","scope":59105,"src":"22153:30:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":59099,"name":"address","nodeType":"ElementaryTypeName","src":"22153:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"22152:32:120"},"src":"22144:95:120"},{"block":{"id":59111,"nodeType":"Block","src":"22246:42:120","statements":[{"expression":{"arguments":[{"hexValue":"30","id":59108,"isConstant":false,"isLValue":false,"isPure":true,"kind":"number","lValueRequested":false,"nodeType":"Literal","src":"22275:1:120","typeDescriptions":{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"},"value":"0"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"}],"id":59107,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"nodeType":"ElementaryTypeNameExpression","src":"22267:7:120","typeDescriptions":{"typeIdentifier":"t_type$_t_address_$","typeString":"type(address)"},"typeName":{"id":59106,"name":"address","nodeType":"ElementaryTypeName","src":"22267:7:120","typeDescriptions":{}}},"id":59109,"isConstant":false,"isLValue":false,"isPure":true,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"22267:10:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"functionReturnParameters":59093,"id":59110,"nodeType":"Return","src":"22260:17:120"}]},"errorName":"","id":59112,"nodeType":"TryCatchClause","src":"22240:48:120"}],"externalCall":{"arguments":[],"expression":{"argumentTypes":[],"expression":{"arguments":[{"id":59095,"name":"_optimismPortalProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":59089,"src":"22103:20:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_address","typeString":"address"}],"id":59094,"name":"IFetcher","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57326,"src":"22094:8:120","typeDescriptions":{"typeIdentifier":"t_type$_t_contract$_IFetcher_$57326_$","typeString":"type(contract IFetcher)"}},"id":59096,"isConstant":false,"isLValue":false,"isPure":false,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"22094:30:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_contract$_IFetcher_$57326","typeString":"contract IFetcher"}},"id":59097,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"22125:16:120","memberName":"superchainConfig","nodeType":"MemberAccess","referencedDeclaration":57216,"src":"22094:47:120","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":59098,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"22094:49:120","tryCall":true,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"id":59113,"nodeType":"TryStatement","src":"22090:198:120"}]},"implemented":true,"kind":"function","modifiers":[],"name":"_getSuperchainConfigProxy","nameLocation":"21992:25:120","parameters":{"id":59090,"nodeType":"ParameterList","parameters":[{"constant":false,"id":59089,"mutability":"mutable","name":"_optimismPortalProxy","nameLocation":"22026:20:120","nodeType":"VariableDeclaration","scope":59115,"src":"22018:28:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":59088,"name":"address","nodeType":"ElementaryTypeName","src":"22018:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"22017:30:120"},"returnParameters":{"id":59093,"nodeType":"ParameterList","parameters":[{"constant":false,"id":59092,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":59115,"src":"22071:7:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":59091,"name":"address","nodeType":"ElementaryTypeName","src":"22071:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"22070:9:120"},"scope":59299,"stateMutability":"view","virtual":false,"visibility":"internal"},{"id":59145,"nodeType":"FunctionDefinition","src":"22300:313:120","nodes":[],"body":{"id":59144,"nodeType":"Block","src":"22396:217:120","nodes":[],"statements":[{"clauses":[{"block":{"id":59134,"nodeType":"Block","src":"22509:49:120","statements":[{"expression":{"id":59132,"name":"faultDisputeGame_","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":59130,"src":"22530:17:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"functionReturnParameters":59121,"id":59133,"nodeType":"Return","src":"22523:24:120"}]},"errorName":"","id":59135,"nodeType":"TryCatchClause","parameters":{"id":59131,"nodeType":"ParameterList","parameters":[{"constant":false,"id":59130,"mutability":"mutable","name":"faultDisputeGame_","nameLocation":"22490:17:120","nodeType":"VariableDeclaration","scope":59135,"src":"22482:25:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":59129,"name":"address","nodeType":"ElementaryTypeName","src":"22482:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"22481:27:120"},"src":"22473:85:120"},{"block":{"id":59141,"nodeType":"Block","src":"22565:42:120","statements":[{"expression":{"arguments":[{"hexValue":"30","id":59138,"isConstant":false,"isLValue":false,"isPure":true,"kind":"number","lValueRequested":false,"nodeType":"Literal","src":"22594:1:120","typeDescriptions":{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"},"value":"0"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"}],"id":59137,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"nodeType":"ElementaryTypeNameExpression","src":"22586:7:120","typeDescriptions":{"typeIdentifier":"t_type$_t_address_$","typeString":"type(address)"},"typeName":{"id":59136,"name":"address","nodeType":"ElementaryTypeName","src":"22586:7:120","typeDescriptions":{}}},"id":59139,"isConstant":false,"isLValue":false,"isPure":true,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"22586:10:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"functionReturnParameters":59121,"id":59140,"nodeType":"Return","src":"22579:17:120"}]},"errorName":"","id":59142,"nodeType":"TryCatchClause","src":"22559:48:120"}],"externalCall":{"arguments":[{"expression":{"id":59126,"name":"GameTypes","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":75481,"src":"22455:9:120","typeDescriptions":{"typeIdentifier":"t_type$_t_contract$_GameTypes_$75481_$","typeString":"type(library GameTypes)"}},"id":59127,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"memberLocation":"22465:6:120","memberName":"CANNON","nodeType":"MemberAccess","referencedDeclaration":75408,"src":"22455:16:120","typeDescriptions":{"typeIdentifier":"t_userDefinedValueType$_GameType_$75355","typeString":"GameType"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_userDefinedValueType$_GameType_$75355","typeString":"GameType"}],"expression":{"arguments":[{"id":59123,"name":"_disputeGameFactoryProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":59117,"src":"22419:24:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_address","typeString":"address"}],"id":59122,"name":"IFetcher","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57326,"src":"22410:8:120","typeDescriptions":{"typeIdentifier":"t_type$_t_contract$_IFetcher_$57326_$","typeString":"type(contract IFetcher)"}},"id":59124,"isConstant":false,"isLValue":false,"isPure":false,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"22410:34:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_contract$_IFetcher_$57326","typeString":"contract IFetcher"}},"id":59125,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"22445:9:120","memberName":"gameImpls","nodeType":"MemberAccess","referencedDeclaration":57254,"src":"22410:44:120","typeDescriptions":{"typeIdentifier":"t_function_external_view$_t_userDefinedValueType$_GameType_$75355_$returns$_t_address_$","typeString":"function (GameType) view external returns (address)"}},"id":59128,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"22410:62:120","tryCall":true,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"id":59143,"nodeType":"TryStatement","src":"22406:201:120"}]},"implemented":true,"kind":"function","modifiers":[],"name":"_getFaultDisputeGame","nameLocation":"22309:20:120","parameters":{"id":59118,"nodeType":"ParameterList","parameters":[{"constant":false,"id":59117,"mutability":"mutable","name":"_disputeGameFactoryProxy","nameLocation":"22338:24:120","nodeType":"VariableDeclaration","scope":59145,"src":"22330:32:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":59116,"name":"address","nodeType":"ElementaryTypeName","src":"22330:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"22329:34:120"},"returnParameters":{"id":59121,"nodeType":"ParameterList","parameters":[{"constant":false,"id":59120,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":59145,"src":"22387:7:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":59119,"name":"address","nodeType":"ElementaryTypeName","src":"22387:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"22386:9:120"},"scope":59299,"stateMutability":"view","virtual":false,"visibility":"internal"},{"id":59175,"nodeType":"FunctionDefinition","src":"22619:369:120","nodes":[],"body":{"id":59174,"nodeType":"Block","src":"22722:266:120","nodes":[],"statements":[{"clauses":[{"block":{"id":59164,"nodeType":"Block","src":"22877:56:120","statements":[{"expression":{"id":59162,"name":"permissionedDisputeGame_","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":59160,"src":"22898:24:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"functionReturnParameters":59151,"id":59163,"nodeType":"Return","src":"22891:31:120"}]},"errorName":"","id":59165,"nodeType":"TryCatchClause","parameters":{"id":59161,"nodeType":"ParameterList","parameters":[{"constant":false,"id":59160,"mutability":"mutable","name":"permissionedDisputeGame_","nameLocation":"22842:24:120","nodeType":"VariableDeclaration","scope":59165,"src":"22834:32:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":59159,"name":"address","nodeType":"ElementaryTypeName","src":"22834:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"22820:56:120"},"src":"22812:121:120"},{"block":{"id":59171,"nodeType":"Block","src":"22940:42:120","statements":[{"expression":{"arguments":[{"hexValue":"30","id":59168,"isConstant":false,"isLValue":false,"isPure":true,"kind":"number","lValueRequested":false,"nodeType":"Literal","src":"22969:1:120","typeDescriptions":{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"},"value":"0"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"}],"id":59167,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"nodeType":"ElementaryTypeNameExpression","src":"22961:7:120","typeDescriptions":{"typeIdentifier":"t_type$_t_address_$","typeString":"type(address)"},"typeName":{"id":59166,"name":"address","nodeType":"ElementaryTypeName","src":"22961:7:120","typeDescriptions":{}}},"id":59169,"isConstant":false,"isLValue":false,"isPure":true,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"22961:10:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"functionReturnParameters":59151,"id":59170,"nodeType":"Return","src":"22954:17:120"}]},"errorName":"","id":59172,"nodeType":"TryCatchClause","src":"22934:48:120"}],"externalCall":{"arguments":[{"expression":{"id":59156,"name":"GameTypes","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":75481,"src":"22781:9:120","typeDescriptions":{"typeIdentifier":"t_type$_t_contract$_GameTypes_$75481_$","typeString":"type(library GameTypes)"}},"id":59157,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"memberLocation":"22791:19:120","memberName":"PERMISSIONED_CANNON","nodeType":"MemberAccess","referencedDeclaration":75416,"src":"22781:29:120","typeDescriptions":{"typeIdentifier":"t_userDefinedValueType$_GameType_$75355","typeString":"GameType"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_userDefinedValueType$_GameType_$75355","typeString":"GameType"}],"expression":{"arguments":[{"id":59153,"name":"_disputeGameFactoryProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":59147,"src":"22745:24:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_address","typeString":"address"}],"id":59152,"name":"IFetcher","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57326,"src":"22736:8:120","typeDescriptions":{"typeIdentifier":"t_type$_t_contract$_IFetcher_$57326_$","typeString":"type(contract IFetcher)"}},"id":59154,"isConstant":false,"isLValue":false,"isPure":false,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"22736:34:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_contract$_IFetcher_$57326","typeString":"contract IFetcher"}},"id":59155,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"22771:9:120","memberName":"gameImpls","nodeType":"MemberAccess","referencedDeclaration":57254,"src":"22736:44:120","typeDescriptions":{"typeIdentifier":"t_function_external_view$_t_userDefinedValueType$_GameType_$75355_$returns$_t_address_$","typeString":"function (GameType) view external returns (address)"}},"id":59158,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"22736:75:120","tryCall":true,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"id":59173,"nodeType":"TryStatement","src":"22732:250:120"}]},"implemented":true,"kind":"function","modifiers":[],"name":"_getPermissionedDisputeGame","nameLocation":"22628:27:120","parameters":{"id":59148,"nodeType":"ParameterList","parameters":[{"constant":false,"id":59147,"mutability":"mutable","name":"_disputeGameFactoryProxy","nameLocation":"22664:24:120","nodeType":"VariableDeclaration","scope":59175,"src":"22656:32:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":59146,"name":"address","nodeType":"ElementaryTypeName","src":"22656:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"22655:34:120"},"returnParameters":{"id":59151,"nodeType":"ParameterList","parameters":[{"constant":false,"id":59150,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":59175,"src":"22713:7:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":59149,"name":"address","nodeType":"ElementaryTypeName","src":"22713:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"22712:9:120"},"scope":59299,"stateMutability":"view","virtual":false,"visibility":"internal"},{"id":59203,"nodeType":"FunctionDefinition","src":"22994:277:120","nodes":[],"body":{"id":59202,"nodeType":"Block","src":"23085:186:120","nodes":[],"statements":[{"clauses":[{"block":{"id":59192,"nodeType":"Block","src":"23173:43:120","statements":[{"expression":{"id":59190,"name":"ethLockbox_","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":59188,"src":"23194:11:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"functionReturnParameters":59181,"id":59191,"nodeType":"Return","src":"23187:18:120"}]},"errorName":"","id":59193,"nodeType":"TryCatchClause","parameters":{"id":59189,"nodeType":"ParameterList","parameters":[{"constant":false,"id":59188,"mutability":"mutable","name":"ethLockbox_","nameLocation":"23160:11:120","nodeType":"VariableDeclaration","scope":59193,"src":"23152:19:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":59187,"name":"address","nodeType":"ElementaryTypeName","src":"23152:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"23151:21:120"},"src":"23143:73:120"},{"block":{"id":59199,"nodeType":"Block","src":"23223:42:120","statements":[{"expression":{"arguments":[{"hexValue":"30","id":59196,"isConstant":false,"isLValue":false,"isPure":true,"kind":"number","lValueRequested":false,"nodeType":"Literal","src":"23252:1:120","typeDescriptions":{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"},"value":"0"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"}],"id":59195,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"nodeType":"ElementaryTypeNameExpression","src":"23244:7:120","typeDescriptions":{"typeIdentifier":"t_type$_t_address_$","typeString":"type(address)"},"typeName":{"id":59194,"name":"address","nodeType":"ElementaryTypeName","src":"23244:7:120","typeDescriptions":{}}},"id":59197,"isConstant":false,"isLValue":false,"isPure":true,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"23244:10:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"functionReturnParameters":59181,"id":59198,"nodeType":"Return","src":"23237:17:120"}]},"errorName":"","id":59200,"nodeType":"TryCatchClause","src":"23217:48:120"}],"externalCall":{"arguments":[],"expression":{"argumentTypes":[],"expression":{"arguments":[{"id":59183,"name":"_optimismPortalProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":59177,"src":"23108:20:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_address","typeString":"address"}],"id":59182,"name":"IFetcher","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57326,"src":"23099:8:120","typeDescriptions":{"typeIdentifier":"t_type$_t_contract$_IFetcher_$57326_$","typeString":"type(contract IFetcher)"}},"id":59184,"isConstant":false,"isLValue":false,"isPure":false,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"23099:30:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_contract$_IFetcher_$57326","typeString":"contract IFetcher"}},"id":59185,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"23130:10:120","memberName":"ethLockbox","nodeType":"MemberAccess","referencedDeclaration":57211,"src":"23099:41:120","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":59186,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"23099:43:120","tryCall":true,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"id":59201,"nodeType":"TryStatement","src":"23095:170:120"}]},"implemented":true,"kind":"function","modifiers":[],"name":"_getEthLockboxProxy","nameLocation":"23003:19:120","parameters":{"id":59178,"nodeType":"ParameterList","parameters":[{"constant":false,"id":59177,"mutability":"mutable","name":"_optimismPortalProxy","nameLocation":"23031:20:120","nodeType":"VariableDeclaration","scope":59203,"src":"23023:28:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":59176,"name":"address","nodeType":"ElementaryTypeName","src":"23023:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"23022:30:120"},"returnParameters":{"id":59181,"nodeType":"ParameterList","parameters":[{"constant":false,"id":59180,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":59203,"src":"23076:7:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":59179,"name":"address","nodeType":"ElementaryTypeName","src":"23076:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"23075:9:120"},"scope":59299,"stateMutability":"view","virtual":false,"visibility":"internal"},{"id":59248,"nodeType":"FunctionDefinition","src":"23277:304:120","nodes":[],"body":{"id":59247,"nodeType":"Block","src":"23361:220:120","nodes":[],"statements":[{"assignments":[59211,59213],"declarations":[{"constant":false,"id":59211,"mutability":"mutable","name":"ok","nameLocation":"23377:2:120","nodeType":"VariableDeclaration","scope":59247,"src":"23372:7:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"},"typeName":{"id":59210,"name":"bool","nodeType":"ElementaryTypeName","src":"23372:4:120","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},"visibility":"internal"},{"constant":false,"id":59213,"mutability":"mutable","name":"data","nameLocation":"23394:4:120","nodeType":"VariableDeclaration","scope":59247,"src":"23381:17:120","stateVariable":false,"storageLocation":"memory","typeDescriptions":{"typeIdentifier":"t_bytes_memory_ptr","typeString":"bytes"},"typeName":{"id":59212,"name":"bytes","nodeType":"ElementaryTypeName","src":"23381:5:120","typeDescriptions":{"typeIdentifier":"t_bytes_storage_ptr","typeString":"bytes"}},"visibility":"internal"}],"id":59226,"initialValue":{"arguments":[{"arguments":[{"expression":{"id":59221,"name":"IFetcher","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57326,"src":"23450:8:120","typeDescriptions":{"typeIdentifier":"t_type$_t_contract$_IFetcher_$57326_$","typeString":"type(contract IFetcher)"}},"id":59222,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"memberLocation":"23459:4:120","memberName":"weth","nodeType":"MemberAccess","referencedDeclaration":57325,"src":"23450:13:120","typeDescriptions":{"typeIdentifier":"t_function_declaration_view$__$returns$_t_address_$","typeString":"function IFetcher.weth() view returns (address)"}},{"components":[],"id":59223,"isConstant":false,"isInlineArray":false,"isLValue":false,"isPure":true,"lValueRequested":false,"nodeType":"TupleExpression","src":"23465:2:120","typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_function_declaration_view$__$returns$_t_address_$","typeString":"function IFetcher.weth() view returns (address)"},{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}],"expression":{"id":59219,"name":"abi","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":-1,"src":"23435:3:120","typeDescriptions":{"typeIdentifier":"t_magic_abi","typeString":"abi"}},"id":59220,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"memberLocation":"23439:10:120","memberName":"encodeCall","nodeType":"MemberAccess","src":"23435:14:120","typeDescriptions":{"typeIdentifier":"t_function_abiencodecall_pure$__$returns$_t_bytes_memory_ptr_$","typeString":"function () pure returns (bytes memory)"}},"id":59224,"isConstant":false,"isLValue":false,"isPure":true,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"23435:33:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_bytes_memory_ptr","typeString":"bytes memory"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_bytes_memory_ptr","typeString":"bytes memory"}],"expression":{"arguments":[{"id":59216,"name":"_disputeGame","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":59205,"src":"23410:12:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_address","typeString":"address"}],"id":59215,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"nodeType":"ElementaryTypeNameExpression","src":"23402:7:120","typeDescriptions":{"typeIdentifier":"t_type$_t_address_$","typeString":"type(address)"},"typeName":{"id":59214,"name":"address","nodeType":"ElementaryTypeName","src":"23402:7:120","typeDescriptions":{}}},"id":59217,"isConstant":false,"isLValue":false,"isPure":false,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"23402:21:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"id":59218,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"23424:10:120","memberName":"staticcall","nodeType":"MemberAccess","src":"23402:32:120","typeDescriptions":{"typeIdentifier":"t_function_barestaticcall_view$_t_bytes_memory_ptr_$returns$_t_bool_$_t_bytes_memory_ptr_$","typeString":"function (bytes memory) view returns (bool,bytes memory)"}},"id":59225,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"23402:67:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$_t_bool_$_t_bytes_memory_ptr_$","typeString":"tuple(bool,bytes memory)"}},"nodeType":"VariableDeclarationStatement","src":"23371:98:120"},{"condition":{"commonType":{"typeIdentifier":"t_bool","typeString":"bool"},"id":59232,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftExpression":{"id":59227,"name":"ok","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":59211,"src":"23483:2:120","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},"nodeType":"BinaryOperation","operator":"&&","rightExpression":{"commonType":{"typeIdentifier":"t_uint256","typeString":"uint256"},"id":59231,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftExpression":{"expression":{"id":59228,"name":"data","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":59213,"src":"23489:4:120","typeDescriptions":{"typeIdentifier":"t_bytes_memory_ptr","typeString":"bytes memory"}},"id":59229,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"23494:6:120","memberName":"length","nodeType":"MemberAccess","src":"23489:11:120","typeDescriptions":{"typeIdentifier":"t_uint256","typeString":"uint256"}},"nodeType":"BinaryOperation","operator":"==","rightExpression":{"hexValue":"3332","id":59230,"isConstant":false,"isLValue":false,"isPure":true,"kind":"number","lValueRequested":false,"nodeType":"Literal","src":"23504:2:120","typeDescriptions":{"typeIdentifier":"t_rational_32_by_1","typeString":"int_const 32"},"value":"32"},"src":"23489:17:120","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},"src":"23483:23:120","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},"falseBody":{"expression":{"arguments":[{"hexValue":"30","id":59243,"isConstant":false,"isLValue":false,"isPure":true,"kind":"number","lValueRequested":false,"nodeType":"Literal","src":"23572:1:120","typeDescriptions":{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"},"value":"0"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"}],"id":59242,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"nodeType":"ElementaryTypeNameExpression","src":"23564:7:120","typeDescriptions":{"typeIdentifier":"t_type$_t_address_$","typeString":"type(address)"},"typeName":{"id":59241,"name":"address","nodeType":"ElementaryTypeName","src":"23564:7:120","typeDescriptions":{}}},"id":59244,"isConstant":false,"isLValue":false,"isPure":true,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"23564:10:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"functionReturnParameters":59209,"id":59245,"nodeType":"Return","src":"23557:17:120"},"id":59246,"nodeType":"IfStatement","src":"23479:95:120","trueBody":{"expression":{"arguments":[{"id":59235,"name":"data","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":59213,"src":"23526:4:120","typeDescriptions":{"typeIdentifier":"t_bytes_memory_ptr","typeString":"bytes memory"}},{"components":[{"id":59237,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"nodeType":"ElementaryTypeNameExpression","src":"23533:7:120","typeDescriptions":{"typeIdentifier":"t_type$_t_address_$","typeString":"type(address)"},"typeName":{"id":59236,"name":"address","nodeType":"ElementaryTypeName","src":"23533:7:120","typeDescriptions":{}}}],"id":59238,"isConstant":false,"isInlineArray":false,"isLValue":false,"isPure":true,"lValueRequested":false,"nodeType":"TupleExpression","src":"23532:9:120","typeDescriptions":{"typeIdentifier":"t_type$_t_address_$","typeString":"type(address)"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_bytes_memory_ptr","typeString":"bytes memory"},{"typeIdentifier":"t_type$_t_address_$","typeString":"type(address)"}],"expression":{"id":59233,"name":"abi","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":-1,"src":"23515:3:120","typeDescriptions":{"typeIdentifier":"t_magic_abi","typeString":"abi"}},"id":59234,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"memberLocation":"23519:6:120","memberName":"decode","nodeType":"MemberAccess","src":"23515:10:120","typeDescriptions":{"typeIdentifier":"t_function_abidecode_pure$__$returns$__$","typeString":"function () pure"}},"id":59239,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"23515:27:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address_payable","typeString":"address payable"}},"functionReturnParameters":59209,"id":59240,"nodeType":"Return","src":"23508:34:120"}}]},"implemented":true,"kind":"function","modifiers":[],"name":"_getDelayedWETHProxy","nameLocation":"23286:20:120","parameters":{"id":59206,"nodeType":"ParameterList","parameters":[{"constant":false,"id":59205,"mutability":"mutable","name":"_disputeGame","nameLocation":"23315:12:120","nodeType":"VariableDeclaration","scope":59248,"src":"23307:20:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":59204,"name":"address","nodeType":"ElementaryTypeName","src":"23307:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"23306:22:120"},"returnParameters":{"id":59209,"nodeType":"ParameterList","parameters":[{"constant":false,"id":59208,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":59248,"src":"23352:7:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":59207,"name":"address","nodeType":"ElementaryTypeName","src":"23352:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"23351:9:120"},"scope":59299,"stateMutability":"view","virtual":false,"visibility":"internal"},{"id":59275,"nodeType":"FunctionDefinition","src":"23587:224:120","nodes":[],"body":{"id":59274,"nodeType":"Block","src":"23675:136:120","nodes":[],"statements":[{"assignments":[59256],"declarations":[{"constant":false,"id":59256,"mutability":"mutable","name":"batcherHash","nameLocation":"23693:11:120","nodeType":"VariableDeclaration","scope":59274,"src":"23685:19:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_bytes32","typeString":"bytes32"},"typeName":{"id":59255,"name":"bytes32","nodeType":"ElementaryTypeName","src":"23685:7:120","typeDescriptions":{"typeIdentifier":"t_bytes32","typeString":"bytes32"}},"visibility":"internal"}],"id":59262,"initialValue":{"arguments":[],"expression":{"argumentTypes":[],"expression":{"arguments":[{"id":59258,"name":"_systemConfigProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":59250,"src":"23716:18:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_address","typeString":"address"}],"id":59257,"name":"IFetcher","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57326,"src":"23707:8:120","typeDescriptions":{"typeIdentifier":"t_type$_t_contract$_IFetcher_$57326_$","typeString":"type(contract IFetcher)"}},"id":59259,"isConstant":false,"isLValue":false,"isPure":false,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"23707:28:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_contract$_IFetcher_$57326","typeString":"contract IFetcher"}},"id":59260,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"23736:11:120","memberName":"batcherHash","nodeType":"MemberAccess","referencedDeclaration":57305,"src":"23707:40:120","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_bytes32_$","typeString":"function () view external returns (bytes32)"}},"id":59261,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"23707:42:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_bytes32","typeString":"bytes32"}},"nodeType":"VariableDeclarationStatement","src":"23685:64:120"},{"expression":{"arguments":[{"arguments":[{"arguments":[{"id":59269,"name":"batcherHash","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":59256,"src":"23790:11:120","typeDescriptions":{"typeIdentifier":"t_bytes32","typeString":"bytes32"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_bytes32","typeString":"bytes32"}],"id":59268,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"nodeType":"ElementaryTypeNameExpression","src":"23782:7:120","typeDescriptions":{"typeIdentifier":"t_type$_t_uint256_$","typeString":"type(uint256)"},"typeName":{"id":59267,"name":"uint256","nodeType":"ElementaryTypeName","src":"23782:7:120","typeDescriptions":{}}},"id":59270,"isConstant":false,"isLValue":false,"isPure":false,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"23782:20:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_uint256","typeString":"uint256"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_uint256","typeString":"uint256"}],"id":59266,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"nodeType":"ElementaryTypeNameExpression","src":"23774:7:120","typeDescriptions":{"typeIdentifier":"t_type$_t_uint160_$","typeString":"type(uint160)"},"typeName":{"id":59265,"name":"uint160","nodeType":"ElementaryTypeName","src":"23774:7:120","typeDescriptions":{}}},"id":59271,"isConstant":false,"isLValue":false,"isPure":false,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"23774:29:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_uint160","typeString":"uint160"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_uint160","typeString":"uint160"}],"id":59264,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"nodeType":"ElementaryTypeNameExpression","src":"23766:7:120","typeDescriptions":{"typeIdentifier":"t_type$_t_address_$","typeString":"type(address)"},"typeName":{"id":59263,"name":"address","nodeType":"ElementaryTypeName","src":"23766:7:120","typeDescriptions":{}}},"id":59272,"isConstant":false,"isLValue":false,"isPure":false,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"23766:38:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"functionReturnParameters":59254,"id":59273,"nodeType":"Return","src":"23759:45:120"}]},"implemented":true,"kind":"function","modifiers":[],"name":"_getBatchSubmitter","nameLocation":"23596:18:120","parameters":{"id":59251,"nodeType":"ParameterList","parameters":[{"constant":false,"id":59250,"mutability":"mutable","name":"_systemConfigProxy","nameLocation":"23623:18:120","nodeType":"VariableDeclaration","scope":59275,"src":"23615:26:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":59249,"name":"address","nodeType":"ElementaryTypeName","src":"23615:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"23614:28:120"},"returnParameters":{"id":59254,"nodeType":"ParameterList","parameters":[{"constant":false,"id":59253,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":59275,"src":"23666:7:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":59252,"name":"address","nodeType":"ElementaryTypeName","src":"23666:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"23665:9:120"},"scope":59299,"stateMutability":"view","virtual":false,"visibility":"internal"},{"id":59298,"nodeType":"FunctionDefinition","src":"23817:169:120","nodes":[],"body":{"id":59297,"nodeType":"Block","src":"23896:90:120","nodes":[],"statements":[{"expression":{"arguments":[{"arguments":[{"hexValue":"30","id":59287,"isConstant":false,"isLValue":false,"isPure":true,"kind":"number","lValueRequested":false,"nodeType":"Literal","src":"23923:1:120","typeDescriptions":{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"},"value":"0"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"}],"id":59286,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"nodeType":"ElementaryTypeNameExpression","src":"23915:7:120","typeDescriptions":{"typeIdentifier":"t_type$_t_address_$","typeString":"type(address)"},"typeName":{"id":59285,"name":"address","nodeType":"ElementaryTypeName","src":"23915:7:120","typeDescriptions":{}}},"id":59288,"isConstant":false,"isLValue":false,"isPure":true,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"23915:10:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_address","typeString":"address"}],"expression":{"id":59282,"name":"vm","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":5980,"src":"23906:2:120","typeDescriptions":{"typeIdentifier":"t_contract$_Vm_$23767","typeString":"contract Vm"}},"id":59284,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"23909:5:120","memberName":"prank","nodeType":"MemberAccess","referencedDeclaration":23060,"src":"23906:8:120","typeDescriptions":{"typeIdentifier":"t_function_external_nonpayable$_t_address_$returns$__$","typeString":"function (address) external"}},"id":59289,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"23906:20:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":59290,"nodeType":"ExpressionStatement","src":"23906:20:120"},{"expression":{"arguments":[],"expression":{"argumentTypes":[],"expression":{"arguments":[{"id":59292,"name":"_systemConfigProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":59277,"src":"23952:18:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_address","typeString":"address"}],"id":59291,"name":"IFetcher","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57326,"src":"23943:8:120","typeDescriptions":{"typeIdentifier":"t_type$_t_contract$_IFetcher_$57326_$","typeString":"type(contract IFetcher)"}},"id":59293,"isConstant":false,"isLValue":false,"isPure":false,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"23943:28:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_contract$_IFetcher_$57326","typeString":"contract IFetcher"}},"id":59294,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"23972:5:120","memberName":"admin","nodeType":"MemberAccess","referencedDeclaration":57310,"src":"23943:34:120","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":59295,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"23943:36:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"functionReturnParameters":59281,"id":59296,"nodeType":"Return","src":"23936:43:120"}]},"implemented":true,"kind":"function","modifiers":[],"name":"_getProxyAdmin","nameLocation":"23826:14:120","parameters":{"id":59278,"nodeType":"ParameterList","parameters":[{"constant":false,"id":59277,"mutability":"mutable","name":"_systemConfigProxy","nameLocation":"23849:18:120","nodeType":"VariableDeclaration","scope":59298,"src":"23841:26:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":59276,"name":"address","nodeType":"ElementaryTypeName","src":"23841:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"23840:28:120"},"returnParameters":{"id":59281,"nodeType":"ParameterList","parameters":[{"constant":false,"id":59280,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":59298,"src":"23887:7:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":59279,"name":"address","nodeType":"ElementaryTypeName","src":"23887:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"23886:9:120"},"scope":59299,"stateMutability":"nonpayable","virtual":false,"visibility":"internal"}],"abstract":false,"baseContracts":[{"baseName":{"id":58250,"name":"Script","nameLocations":["13167:6:120"],"nodeType":"IdentifierPath","referencedDeclaration":6037,"src":"13167:6:120"},"id":58251,"nodeType":"InheritanceSpecifier","src":"13167:6:120"}],"canonicalName":"FetchChainInfo","contractDependencies":[],"contractKind":"contract","fullyImplemented":true,"linearizedBaseContracts":[59299,6037,18860,11701,9611,5996,5984],"name":"FetchChainInfo","nameLocation":"13149:14:120","scope":59300,"usedErrors":[],"usedEvents":[]}],"license":"MIT"},"id":120} \ No newline at end of file +{"abi":[{"type":"function","name":"addressManagerImpl","inputs":[],"outputs":[{"name":"","type":"address","internalType":"address"}],"stateMutability":"view"},{"type":"function","name":"anchorStateRegistryProxy","inputs":[],"outputs":[{"name":"","type":"address","internalType":"address"}],"stateMutability":"view"},{"type":"function","name":"batchSubmitter","inputs":[],"outputs":[{"name":"","type":"address","internalType":"address"}],"stateMutability":"view"},{"type":"function","name":"challenger","inputs":[],"outputs":[{"name":"","type":"address","internalType":"address"}],"stateMutability":"view"},{"type":"function","name":"delayedWethPermissionedGameProxy","inputs":[],"outputs":[{"name":"","type":"address","internalType":"address"}],"stateMutability":"view"},{"type":"function","name":"delayedWethPermissionlessGameProxy","inputs":[],"outputs":[{"name":"","type":"address","internalType":"address"}],"stateMutability":"view"},{"type":"function","name":"disputeGameFactoryProxy","inputs":[],"outputs":[{"name":"","type":"address","internalType":"address"}],"stateMutability":"view"},{"type":"function","name":"ethLockboxProxy","inputs":[],"outputs":[{"name":"","type":"address","internalType":"address"}],"stateMutability":"view"},{"type":"function","name":"faultDisputeGameCannonKonaImpl","inputs":[],"outputs":[{"name":"","type":"address","internalType":"address"}],"stateMutability":"view"},{"type":"function","name":"faultDisputeGameImpl","inputs":[],"outputs":[{"name":"","type":"address","internalType":"address"}],"stateMutability":"view"},{"type":"function","name":"l1CrossDomainMessengerProxy","inputs":[],"outputs":[{"name":"","type":"address","internalType":"address"}],"stateMutability":"view"},{"type":"function","name":"l1Erc721BridgeProxy","inputs":[],"outputs":[{"name":"","type":"address","internalType":"address"}],"stateMutability":"view"},{"type":"function","name":"l1StandardBridgeProxy","inputs":[],"outputs":[{"name":"","type":"address","internalType":"address"}],"stateMutability":"view"},{"type":"function","name":"l2OutputOracleProxy","inputs":[],"outputs":[{"name":"","type":"address","internalType":"address"}],"stateMutability":"view"},{"type":"function","name":"mipsImpl","inputs":[],"outputs":[{"name":"","type":"address","internalType":"address"}],"stateMutability":"view"},{"type":"function","name":"opChainGuardian","inputs":[],"outputs":[{"name":"","type":"address","internalType":"address"}],"stateMutability":"view"},{"type":"function","name":"opChainProxyAdminImpl","inputs":[],"outputs":[{"name":"","type":"address","internalType":"address"}],"stateMutability":"view"},{"type":"function","name":"opChainProxyAdminOwner","inputs":[],"outputs":[{"name":"","type":"address","internalType":"address"}],"stateMutability":"view"},{"type":"function","name":"optimismMintableErc20FactoryProxy","inputs":[],"outputs":[{"name":"","type":"address","internalType":"address"}],"stateMutability":"view"},{"type":"function","name":"optimismPortalProxy","inputs":[],"outputs":[{"name":"","type":"address","internalType":"address"}],"stateMutability":"view"},{"type":"function","name":"permissioned","inputs":[],"outputs":[{"name":"","type":"bool","internalType":"bool"}],"stateMutability":"view"},{"type":"function","name":"permissionedDisputeGameImpl","inputs":[],"outputs":[{"name":"","type":"address","internalType":"address"}],"stateMutability":"view"},{"type":"function","name":"permissionless","inputs":[],"outputs":[{"name":"","type":"bool","internalType":"bool"}],"stateMutability":"view"},{"type":"function","name":"preimageOracleImpl","inputs":[],"outputs":[{"name":"","type":"address","internalType":"address"}],"stateMutability":"view"},{"type":"function","name":"proposer","inputs":[],"outputs":[{"name":"","type":"address","internalType":"address"}],"stateMutability":"view"},{"type":"function","name":"respectedGameType","inputs":[],"outputs":[{"name":"","type":"uint32","internalType":"GameType"}],"stateMutability":"view"},{"type":"function","name":"set","inputs":[{"name":"_sel","type":"bytes4","internalType":"bytes4"},{"name":"_bool","type":"bool","internalType":"bool"}],"outputs":[],"stateMutability":"nonpayable"},{"type":"function","name":"set","inputs":[{"name":"_sel","type":"bytes4","internalType":"bytes4"},{"name":"_addr","type":"address","internalType":"address"}],"outputs":[],"stateMutability":"nonpayable"},{"type":"function","name":"set","inputs":[{"name":"_sel","type":"bytes4","internalType":"bytes4"},{"name":"_gameType","type":"uint32","internalType":"GameType"}],"outputs":[],"stateMutability":"nonpayable"},{"type":"function","name":"superchainConfigProxy","inputs":[],"outputs":[{"name":"","type":"address","internalType":"address"}],"stateMutability":"view"},{"type":"function","name":"systemConfigOwner","inputs":[],"outputs":[{"name":"","type":"address","internalType":"address"}],"stateMutability":"view"},{"type":"function","name":"systemConfigProxy","inputs":[],"outputs":[{"name":"","type":"address","internalType":"address"}],"stateMutability":"view"},{"type":"function","name":"unsafeBlockSigner","inputs":[],"outputs":[{"name":"","type":"address","internalType":"address"}],"stateMutability":"view"}],"bytecode":{"object":"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","sourceMap":"2957:10642:100:-:0;;;;;;;;;;;;;;;;;;;","linkReferences":{}},"deployedBytecode":{"object":"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","sourceMap":"2957:10642:100:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;9243:211;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;8494:219;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;12113:223;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;11904:203;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;12897;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;10119:231;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;13495:102;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;13303:88;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;12342:195;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;12543:175;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;8028:243;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;9669:219;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;10974:289;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;10634:113;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;10356:131;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;9894:219;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;8936:301;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;10493:135;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;11442:243;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;13397:92;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;8719:211;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;12724:167;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;7212:271;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;7712:207;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;9460:203;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;4460:2746;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;11691:207;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;7489:217;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;10753:215;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;11269:167;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;8277:211;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;7925:97;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;13106:191;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;9243:211;9295:7;9354:1;9322:34;;:20;;;;;;;;;;;:34;;;9314:96;;;;;;;;;;;;:::i;:::-;;;;;;;;;9427:20;;;;;;;;;;;9420:27;;9243:211;:::o;8494:219::-;8548:7;8609:1;8575:36;;:22;;;;;;;;;;;:36;;;8567:100;;;;;;;;;;;;:::i;:::-;;;;;;;;;8684:22;;;;;;;;;;;8677:29;;8494:219;:::o;12113:223::-;12168:7;12230:1;12195:37;;:23;;;;;;;;;;;:37;;;12187:102;;;;;;;;;;;;:::i;:::-;;;;;;;;;12306:23;;;;;;;;;;;12299:30;;12113:223;:::o;11904:203::-;11954:7;12011:1;11981:32;;:18;;;;;;;;;;;:32;;;11973:92;;;;;;;;;;;;:::i;:::-;;;;;;;;;12082:18;;;;;;;;;;;12075:25;;11904:203;:::o;12897:::-;12947:7;13004:1;12974:32;;:18;;;;;;;;;;;:32;;;12966:92;;;;;;;;;;;;:::i;:::-;;;;;;;;;13075:18;;;;;;;;;;;13068:25;;12897:203;:::o;10119:231::-;10176:7;10240:1;10203:39;;:25;;;;;;;;;;;:39;;;10195:106;;;;;;;;;;;;:::i;:::-;;;;;;;;;10318:25;;;;;;;;;;;10311:32;;10119:231;:::o;13495:102::-;13545:8;13572:18;;;;;;;;;;;13565:25;;13495:102;:::o;13303:88::-;13348:4;13371:13;;;;;;;;;;;13364:20;;13303:88;:::o;12342:195::-;12390:7;12445:1;12417:30;;:16;;;;;;;;;;;:30;;;12409:88;;;;;;;;;;;;:::i;:::-;;;;;;;;;12514:16;;;;;;;;;;;12507:23;;12342:195;:::o;12543:175::-;12586:7;12636:1;12613:25;;:11;;;;;;;;;;;:25;;;12605:78;;;;;;;;;;;;:::i;:::-;;;;;;;;;12700:11;;;;;;;;;;;12693:18;;12543:175;:::o;8028:243::-;8088:7;8155:1;8115:42;;:28;;;;;;;;;;;:42;;;8107:112;;;;;;;;;;;;:::i;:::-;;;;;;;;;8236:28;;;;;;;;;;;8229:35;;8028:243;:::o;9669:219::-;9723:7;9784:1;9750:36;;:22;;;;;;;;;;;:36;;;9742:100;;;;;;;;;;;;:::i;:::-;;;;;;;;;9859:22;;;;;;;;;;;9852:29;;9669:219;:::o;10974:289::-;11037:7;11120:1;11077:45;;:31;;;;;;;;;;;:45;;;11056:152;;;;;;;;;;;;:::i;:::-;;;;;;;;;11225:31;;;;;;;;;;;11218:38;;10974:289;:::o;10634:113::-;10690:7;10716:24;;;;;;;;;;;10709:31;;10634:113;:::o;10356:131::-;10421:7;10447:33;;;;;;;;;;;10440:40;;10356:131;:::o;9894:219::-;9948:7;10009:1;9975:36;;:22;;;;;;;;;;;:36;;;9967:100;;;;;;;;;;;;:::i;:::-;;;;;;;;;10084:22;;;;;;;;;;;10077:29;;9894:219;:::o;8936:301::-;9002:7;9088:1;9042:48;;:34;;;;;;;;;;;:48;;;9021:158;;;;;;;;;;;;:::i;:::-;;;;;;;;;9196:34;;;;;;;;;;;9189:41;;8936:301;:::o;10493:135::-;10560:7;10586:35;;;;;;;;;;;10579:42;;10493:135;:::o;11442:243::-;11502:7;11569:1;11529:42;;:28;;;;;;;;;;;:42;;;11521:112;;;;;;;;;;;;:::i;:::-;;;;;;;;;11650:28;;;;;;;;;;;11643:35;;11442:243;:::o;13397:92::-;13444:4;13467:15;;;;;;;;;;;13460:22;;13397:92;:::o;8719:211::-;8771:7;8830:1;8798:34;;:20;;;;;;;;;;;:34;;;8790:96;;;;;;;;;;;;:::i;:::-;;;;;;;;;8903:20;;;;;;;;;;;8896:27;;8719:211;:::o;12724:167::-;12765:7;12813:1;12792:23;;:9;;;;;;;;;;;:23;;;12784:74;;;;;;;;;;;;:::i;:::-;;;;;;;;;12875:9;;;;;;;;;;;12868:16;;12724:167;:::o;7212:271::-;7279:26;;;7271:34;;;:4;:34;;;;7267:209;;7323:5;7307:13;;:21;;;;;;;;;;;;;;;;;;7267:209;;;7355:28;;;7347:36;;;:4;:36;;;;7343:133;;7403:5;7385:15;;:23;;;;;;;;;;;;;;;;;;7343:133;;;7423:53;;;;;;;;;;:::i;:::-;;;;;;;;7343:133;7267:209;7212:271;;:::o;7712:207::-;7763:7;7821:1;7790:33;;:19;;;;;;;;;;;:33;;;7782:94;;;;;;;;;;;;:::i;:::-;;;;;;;;;7893:19;;;;;;;;;;;7886:26;;7712:207;:::o;9460:203::-;9510:7;9567:1;9537:32;;:18;;;;;;;;;;;:32;;;9529:92;;;;;;;;;;;;:::i;:::-;;;;;;;;;9638:18;;;;;;;;;;;9631:25;;9460:203;:::o;4460:2746::-;4561:35;;;4553:43;;;:4;:43;;;;4549:2650;;4623:5;4598:22;;:30;;;;;;;;;;;;;;;;;;4549:2650;;;4694:22;;;4686:30;;;:4;:30;;;;4682:2517;;4730:5;4718:9;;:17;;;;;;;;;;;;;;;;;;4682:2517;;;4762:32;;;4754:40;;;:4;:40;;;;4750:2449;;4818:5;4796:19;;:27;;;;;;;;;;;;;;;;;;4750:2449;;;4881:32;;;4873:40;;;:4;:40;;;;4869:2330;;4937:5;4915:19;;:27;;;;;;;;;;;;;;;;;;4869:2330;;;4969:29;;;4961:37;;;:4;:37;;;;4957:2242;;5019:5;5000:16;;:24;;;;;;;;;;;;;;;;;;4957:2242;;;5051:41;;;5043:49;;;:4;:49;;;;5039:2160;;5125:5;5094:28;;:36;;;;;;;;;;;;;;;;;;5039:2160;;;5157:33;;;5149:41;;;:4;:41;;;;5145:2054;;5215:5;5192:20;;:28;;;;;;;;;;;;;;;;;;5145:2054;;;5247:35;;;5239:43;;;:4;:43;;;;5235:1964;;5309:5;5284:22;;:30;;;;;;;;;;;;;;;;;;5235:1964;;;5341:33;;;5333:41;;;:4;:41;;;;5329:1870;;5399:5;5376:20;;:28;;;;;;;;;;;;;;;;;;5329:1870;;;5431:47;;;5423:55;;;:4;:55;;;;5419:1780;;5517:5;5480:34;;:42;;;;;;;;;;;;;;;;;;5419:1780;;;5549:33;;;5541:41;;;:4;:41;;;;5537:1662;;5607:5;5584:20;;:28;;;;;;;;;;;;;;;;;;5537:1662;;;5639:31;;;5631:39;;;:4;:39;;;;5627:1572;;5693:5;5672:18;;:26;;;;;;;;;;;;;;;;;;5627:1572;;;5725:35;;;5717:43;;;:4;:43;;;;5713:1486;;5787:5;5762:22;;:30;;;;;;;;;;;;;;;;;;5713:1486;;;5819:38;;;5811:46;;;:4;:46;;;;5807:1392;;5887:5;5859:25;;:33;;;;;;;;;;;;;;;;;;5807:1392;;;5919:46;;;5911:54;;;:4;:54;;;;5907:1292;;6003:5;5967:33;;:41;;;;;;;;;;;;;;;;;;5907:1292;;;6035:48;;;6027:56;;;:4;:56;;;;6023:1176;;6123:5;6085:35;;:43;;;;;;;;;;;;;;;;;;6023:1176;;;6155:37;;;6147:45;;;:4;:45;;;;6143:1056;;6221:5;6194:24;;:32;;;;;;;;;;;;;;;;;;6143:1056;;;6253:34;;;6245:42;;;:4;:42;;;;6241:958;;6313:5;6289:21;;:29;;;;;;;;;;;;;;;;;;6241:958;;;6345:44;;;6337:52;;;:4;:52;;;;6333:866;;6425:5;6391:31;;:39;;;;;;;;;;;;;;;;;;6333:866;;;6457:41;;;6449:49;;;:4;:49;;;;6445:754;;6531:5;6500:28;;:36;;;;;;;;;;;;;;;;;;6445:754;;;6580:31;;;6572:39;;;:4;:39;;;;6568:631;;6634:5;6613:18;;:26;;;;;;;;;;;;;;;;;;6568:631;;;6666:36;;;6658:44;;;:4;:44;;;;6654:545;;6730:5;6704:23;;:31;;;;;;;;;;;;;;;;;;6654:545;;;6762:29;;;6754:37;;;:4;:37;;;;6750:449;;6812:5;6793:16;;:24;;;;;;;;;;;;;;;;;;6750:449;;;6844:24;;;6836:32;;;:4;:32;;;;6832:367;;6884:5;6870:11;;:19;;;;;;;;;;;;;;;;;;6832:367;;;6916:22;;;6908:30;;;:4;:30;;;;6904:295;;6952:5;6940:9;;:17;;;;;;;;;;;;;;;;;;6904:295;;;6984:31;;;6976:39;;;:4;:39;;;;6972:227;;7038:5;7017:18;;:26;;;;;;;;;;;;;;;;;;6972:227;;;7070:28;;;7062:36;;;:4;:36;;;;7058:141;;7118:5;7100:15;;:23;;;;;;;;;;;;;;;;;;7058:141;;;7138:61;;;;;;;;;;:::i;:::-;;;;;;;;7058:141;6972:227;6904:295;6832:367;6750:449;6654:545;6568:631;6445:754;6333:866;6241:958;6143:1056;6023:1176;5907:1292;5807:1392;5713:1486;5627:1572;5537:1662;5419:1780;5329:1870;5235:1964;5145:2054;5039:2160;4957:2242;4869:2330;4750:2449;4682:2517;4549:2650;4460:2746;;:::o;11691:207::-;11742:7;11800:1;11769:33;;:19;;;;;;;;;;;:33;;;11761:94;;;;;;;;;;;;:::i;:::-;;;;;;;;;11872:19;;;;;;;;;;;11865:26;;11691:207;:::o;7489:217::-;7564:31;;;7556:39;;;:4;:39;;;;7552:147;;7618:9;7597:18;;:30;;;;;;;;;;;;;;;;;;7552:147;;;7642:57;;;;;;;;;;:::i;:::-;;;;;;;;7552:147;7489:217;;:::o;10753:215::-;10806:7;10866:1;10833:35;;:21;;;;;;;;;;;:35;;;10825:98;;;;;;;;;;;;:::i;:::-;;;;;;;;;10940:21;;;;;;;;;;;10933:28;;10753:215;:::o;11269:167::-;11310:7;11358:1;11337:23;;:9;;;;;;;;;;;:23;;;11329:74;;;;;;;;;;;;:::i;:::-;;;;;;;;;11420:9;;;;;;;;;;;11413:16;;11269:167;:::o;8277:211::-;8329:7;8388:1;8356:34;;:20;;;;;;;;;;;:34;;;8348:96;;;;;;;;;;;;:::i;:::-;;;;;;;;;8461:20;;;;;;;;;;;8454:27;;8277:211;:::o;7925:97::-;7973:7;7999:16;;;;;;;;;;;7992:23;;7925:97;:::o;13106:191::-;13153:7;13207:1;13180:29;;:15;;;;;;;;;;;:29;;;13172:86;;;;;;;;;;;;:::i;:::-;;;;;;;;;13275:15;;;;;;;;;;;13268:22;;13106:191;:::o;7:126:182:-;44:7;84:42;77:5;73:54;62:65;;7:126;;;:::o;139:96::-;176:7;205:24;223:5;205:24;:::i;:::-;194:35;;139:96;;;:::o;241:118::-;328:24;346:5;328:24;:::i;:::-;323:3;316:37;241:118;;:::o;365:222::-;458:4;496:2;485:9;481:18;473:26;;509:71;577:1;566:9;562:17;553:6;509:71;:::i;:::-;365:222;;;;:::o;593:93::-;629:7;669:10;662:5;658:22;647:33;;593:93;;;:::o;692:60::-;720:3;741:5;734:12;;692:60;;;:::o;758:138::-;806:9;839:51;856:33;865:23;882:5;865:23;:::i;:::-;856:33;:::i;:::-;839:51;:::i;:::-;826:64;;758:138;;;:::o;902:158::-;1018:35;1047:5;1018:35;:::i;:::-;1013:3;1006:48;902:158;;:::o;1066:280::-;1188:4;1226:2;1215:9;1211:18;1203:26;;1239:100;1336:1;1325:9;1321:17;1312:6;1239:100;:::i;:::-;1066:280;;;;:::o;1352:90::-;1386:7;1429:5;1422:13;1415:21;1404:32;;1352:90;;;:::o;1448:109::-;1529:21;1544:5;1529:21;:::i;:::-;1524:3;1517:34;1448:109;;:::o;1563:210::-;1650:4;1688:2;1677:9;1673:18;1665:26;;1701:65;1763:1;1752:9;1748:17;1739:6;1701:65;:::i;:::-;1563:210;;;;:::o;1860:117::-;1969:1;1966;1959:12;2106:149;2142:7;2182:66;2175:5;2171:78;2160:89;;2106:149;;;:::o;2261:120::-;2333:23;2350:5;2333:23;:::i;:::-;2326:5;2323:34;2313:62;;2371:1;2368;2361:12;2313:62;2261:120;:::o;2387:137::-;2432:5;2470:6;2457:20;2448:29;;2486:32;2512:5;2486:32;:::i;:::-;2387:137;;;;:::o;2530:116::-;2600:21;2615:5;2600:21;:::i;:::-;2593:5;2590:32;2580:60;;2636:1;2633;2626:12;2580:60;2530:116;:::o;2652:133::-;2695:5;2733:6;2720:20;2711:29;;2749:30;2773:5;2749:30;:::i;:::-;2652:133;;;;:::o;2791:466::-;2855:6;2863;2912:2;2900:9;2891:7;2887:23;2883:32;2880:119;;;2918:79;;:::i;:::-;2880:119;3038:1;3063:52;3107:7;3098:6;3087:9;3083:22;3063:52;:::i;:::-;3053:62;;3009:116;3164:2;3190:50;3232:7;3223:6;3212:9;3208:22;3190:50;:::i;:::-;3180:60;;3135:115;2791:466;;;;;:::o;3263:122::-;3336:24;3354:5;3336:24;:::i;:::-;3329:5;3326:35;3316:63;;3375:1;3372;3365:12;3316:63;3263:122;:::o;3391:139::-;3437:5;3475:6;3462:20;3453:29;;3491:33;3518:5;3491:33;:::i;:::-;3391:139;;;;:::o;3536:472::-;3603:6;3611;3660:2;3648:9;3639:7;3635:23;3631:32;3628:119;;;3666:79;;:::i;:::-;3628:119;3786:1;3811:52;3855:7;3846:6;3835:9;3831:22;3811:52;:::i;:::-;3801:62;;3757:116;3912:2;3938:53;3983:7;3974:6;3963:9;3959:22;3938:53;:::i;:::-;3928:63;;3883:118;3536:472;;;;;:::o;4014:151::-;4117:23;4134:5;4117:23;:::i;:::-;4110:5;4107:34;4097:62;;4155:1;4152;4145:12;4097:62;4014:151;:::o;4171:199::-;4247:5;4285:6;4272:20;4263:29;;4301:63;4358:5;4301:63;:::i;:::-;4171:199;;;;:::o;4376:532::-;4473:6;4481;4530:2;4518:9;4509:7;4505:23;4501:32;4498:119;;;4536:79;;:::i;:::-;4498:119;4656:1;4681:52;4725:7;4716:6;4705:9;4701:22;4681:52;:::i;:::-;4671:62;;4627:116;4782:2;4808:83;4883:7;4874:6;4863:9;4859:22;4808:83;:::i;:::-;4798:93;;4753:148;4376:532;;;;;:::o;4914:169::-;4998:11;5032:6;5027:3;5020:19;5072:4;5067:3;5063:14;5048:29;;4914:169;;;;:::o;5089:236::-;5229:34;5225:1;5217:6;5213:14;5206:58;5298:19;5293:2;5285:6;5281:15;5274:44;5089:236;:::o;5331:366::-;5473:3;5494:67;5558:2;5553:3;5494:67;:::i;:::-;5487:74;;5570:93;5659:3;5570:93;:::i;:::-;5688:2;5683:3;5679:12;5672:19;;5331:366;;;:::o;5703:419::-;5869:4;5907:2;5896:9;5892:18;5884:26;;5956:9;5950:4;5946:20;5942:1;5931:9;5927:17;5920:47;5984:131;6110:4;5984:131;:::i;:::-;5976:139;;5703:419;;;:::o;6128:238::-;6268:34;6264:1;6256:6;6252:14;6245:58;6337:21;6332:2;6324:6;6320:15;6313:46;6128:238;:::o;6372:366::-;6514:3;6535:67;6599:2;6594:3;6535:67;:::i;:::-;6528:74;;6611:93;6700:3;6611:93;:::i;:::-;6729:2;6724:3;6720:12;6713:19;;6372:366;;;:::o;6744:419::-;6910:4;6948:2;6937:9;6933:18;6925:26;;6997:9;6991:4;6987:20;6983:1;6972:9;6968:17;6961:47;7025:131;7151:4;7025:131;:::i;:::-;7017:139;;6744:419;;;:::o;7169:239::-;7309:34;7305:1;7297:6;7293:14;7286:58;7378:22;7373:2;7365:6;7361:15;7354:47;7169:239;:::o;7414:366::-;7556:3;7577:67;7641:2;7636:3;7577:67;:::i;:::-;7570:74;;7653:93;7742:3;7653:93;:::i;:::-;7771:2;7766:3;7762:12;7755:19;;7414:366;;;:::o;7786:419::-;7952:4;7990:2;7979:9;7975:18;7967:26;;8039:9;8033:4;8029:20;8025:1;8014:9;8010:17;8003:47;8067:131;8193:4;8067:131;:::i;:::-;8059:139;;7786:419;;;:::o;8211:234::-;8351:34;8347:1;8339:6;8335:14;8328:58;8420:17;8415:2;8407:6;8403:15;8396:42;8211:234;:::o;8451:366::-;8593:3;8614:67;8678:2;8673:3;8614:67;:::i;:::-;8607:74;;8690:93;8779:3;8690:93;:::i;:::-;8808:2;8803:3;8799:12;8792:19;;8451:366;;;:::o;8823:419::-;8989:4;9027:2;9016:9;9012:18;9004:26;;9076:9;9070:4;9066:20;9062:1;9051:9;9047:17;9040:47;9104:131;9230:4;9104:131;:::i;:::-;9096:139;;8823:419;;;:::o;9248:234::-;9388:34;9384:1;9376:6;9372:14;9365:58;9457:17;9452:2;9444:6;9440:15;9433:42;9248:234;:::o;9488:366::-;9630:3;9651:67;9715:2;9710:3;9651:67;:::i;:::-;9644:74;;9727:93;9816:3;9727:93;:::i;:::-;9845:2;9840:3;9836:12;9829:19;;9488:366;;;:::o;9860:419::-;10026:4;10064:2;10053:9;10049:18;10041:26;;10113:9;10107:4;10103:20;10099:1;10088:9;10084:17;10077:47;10141:131;10267:4;10141:131;:::i;:::-;10133:139;;9860:419;;;:::o;10285:241::-;10425:34;10421:1;10413:6;10409:14;10402:58;10494:24;10489:2;10481:6;10477:15;10470:49;10285:241;:::o;10532:366::-;10674:3;10695:67;10759:2;10754:3;10695:67;:::i;:::-;10688:74;;10771:93;10860:3;10771:93;:::i;:::-;10889:2;10884:3;10880:12;10873:19;;10532:366;;;:::o;10904:419::-;11070:4;11108:2;11097:9;11093:18;11085:26;;11157:9;11151:4;11147:20;11143:1;11132:9;11128:17;11121:47;11185:131;11311:4;11185:131;:::i;:::-;11177:139;;10904:419;;;:::o;11329:232::-;11469:34;11465:1;11457:6;11453:14;11446:58;11538:15;11533:2;11525:6;11521:15;11514:40;11329:232;:::o;11567:366::-;11709:3;11730:67;11794:2;11789:3;11730:67;:::i;:::-;11723:74;;11806:93;11895:3;11806:93;:::i;:::-;11924:2;11919:3;11915:12;11908:19;;11567:366;;;:::o;11939:419::-;12105:4;12143:2;12132:9;12128:18;12120:26;;12192:9;12186:4;12182:20;12178:1;12167:9;12163:17;12156:47;12220:131;12346:4;12220:131;:::i;:::-;12212:139;;11939:419;;;:::o;12364:227::-;12504:34;12500:1;12492:6;12488:14;12481:58;12573:10;12568:2;12560:6;12556:15;12549:35;12364:227;:::o;12597:366::-;12739:3;12760:67;12824:2;12819:3;12760:67;:::i;:::-;12753:74;;12836:93;12925:3;12836:93;:::i;:::-;12954:2;12949:3;12945:12;12938:19;;12597:366;;;:::o;12969:419::-;13135:4;13173:2;13162:9;13158:18;13150:26;;13222:9;13216:4;13212:20;13208:1;13197:9;13193:17;13186:47;13250:131;13376:4;13250:131;:::i;:::-;13242:139;;12969:419;;;:::o;13394:244::-;13534:34;13530:1;13522:6;13518:14;13511:58;13603:27;13598:2;13590:6;13586:15;13579:52;13394:244;:::o;13644:366::-;13786:3;13807:67;13871:2;13866:3;13807:67;:::i;:::-;13800:74;;13883:93;13972:3;13883:93;:::i;:::-;14001:2;13996:3;13992:12;13985:19;;13644:366;;;:::o;14016:419::-;14182:4;14220:2;14209:9;14205:18;14197:26;;14269:9;14263:4;14259:20;14255:1;14244:9;14240:17;14233:47;14297:131;14423:4;14297:131;:::i;:::-;14289:139;;14016:419;;;:::o;14441:238::-;14581:34;14577:1;14569:6;14565:14;14558:58;14650:21;14645:2;14637:6;14633:15;14626:46;14441:238;:::o;14685:366::-;14827:3;14848:67;14912:2;14907:3;14848:67;:::i;:::-;14841:74;;14924:93;15013:3;14924:93;:::i;:::-;15042:2;15037:3;15033:12;15026:19;;14685:366;;;:::o;15057:419::-;15223:4;15261:2;15250:9;15246:18;15238:26;;15310:9;15304:4;15300:20;15296:1;15285:9;15281:17;15274:47;15338:131;15464:4;15338:131;:::i;:::-;15330:139;;15057:419;;;:::o;15482:247::-;15622:34;15618:1;15610:6;15606:14;15599:58;15691:30;15686:2;15678:6;15674:15;15667:55;15482:247;:::o;15735:366::-;15877:3;15898:67;15962:2;15957:3;15898:67;:::i;:::-;15891:74;;15974:93;16063:3;15974:93;:::i;:::-;16092:2;16087:3;16083:12;16076:19;;15735:366;;;:::o;16107:419::-;16273:4;16311:2;16300:9;16296:18;16288:26;;16360:9;16354:4;16350:20;16346:1;16335:9;16331:17;16324:47;16388:131;16514:4;16388:131;:::i;:::-;16380:139;;16107:419;;;:::o;16532:238::-;16672:34;16668:1;16660:6;16656:14;16649:58;16741:21;16736:2;16728:6;16724:15;16717:46;16532:238;:::o;16776:366::-;16918:3;16939:67;17003:2;16998:3;16939:67;:::i;:::-;16932:74;;17015:93;17104:3;17015:93;:::i;:::-;17133:2;17128:3;17124:12;17117:19;;16776:366;;;:::o;17148:419::-;17314:4;17352:2;17341:9;17337:18;17329:26;;17401:9;17395:4;17391:20;17387:1;17376:9;17372:17;17365:47;17429:131;17555:4;17429:131;:::i;:::-;17421:139;;17148:419;;;:::o;17573:250::-;17713:34;17709:1;17701:6;17697:14;17690:58;17782:33;17777:2;17769:6;17765:15;17758:58;17573:250;:::o;17829:366::-;17971:3;17992:67;18056:2;18051:3;17992:67;:::i;:::-;17985:74;;18068:93;18157:3;18068:93;:::i;:::-;18186:2;18181:3;18177:12;18170:19;;17829:366;;;:::o;18201:419::-;18367:4;18405:2;18394:9;18390:18;18382:26;;18454:9;18448:4;18444:20;18440:1;18429:9;18425:17;18418:47;18482:131;18608:4;18482:131;:::i;:::-;18474:139;;18201:419;;;:::o;18626:244::-;18766:34;18762:1;18754:6;18750:14;18743:58;18835:27;18830:2;18822:6;18818:15;18811:52;18626:244;:::o;18876:366::-;19018:3;19039:67;19103:2;19098:3;19039:67;:::i;:::-;19032:74;;19115:93;19204:3;19115:93;:::i;:::-;19233:2;19228:3;19224:12;19217:19;;18876:366;;;:::o;19248:419::-;19414:4;19452:2;19441:9;19437:18;19429:26;;19501:9;19495:4;19491:20;19487:1;19476:9;19472:17;19465:47;19529:131;19655:4;19529:131;:::i;:::-;19521:139;;19248:419;;;:::o;19673:236::-;19813:34;19809:1;19801:6;19797:14;19790:58;19882:19;19877:2;19869:6;19865:15;19858:44;19673:236;:::o;19915:366::-;20057:3;20078:67;20142:2;20137:3;20078:67;:::i;:::-;20071:74;;20154:93;20243:3;20154:93;:::i;:::-;20272:2;20267:3;20263:12;20256:19;;19915:366;;;:::o;20287:419::-;20453:4;20491:2;20480:9;20476:18;20468:26;;20540:9;20534:4;20530:20;20526:1;20515:9;20511:17;20504:47;20568:131;20694:4;20568:131;:::i;:::-;20560:139;;20287:419;;;:::o;20712:225::-;20852:34;20848:1;20840:6;20836:14;20829:58;20921:8;20916:2;20908:6;20904:15;20897:33;20712:225;:::o;20943:366::-;21085:3;21106:67;21170:2;21165:3;21106:67;:::i;:::-;21099:74;;21182:93;21271:3;21182:93;:::i;:::-;21300:2;21295:3;21291:12;21284:19;;20943:366;;;:::o;21315:419::-;21481:4;21519:2;21508:9;21504:18;21496:26;;21568:9;21562:4;21558:20;21554:1;21543:9;21539:17;21532:47;21596:131;21722:4;21596:131;:::i;:::-;21588:139;;21315:419;;;:::o;21740:230::-;21880:34;21876:1;21868:6;21864:14;21857:58;21949:13;21944:2;21936:6;21932:15;21925:38;21740:230;:::o;21976:366::-;22118:3;22139:67;22203:2;22198:3;22139:67;:::i;:::-;22132:74;;22215:93;22304:3;22215:93;:::i;:::-;22333:2;22328:3;22324:12;22317:19;;21976:366;;;:::o;22348:419::-;22514:4;22552:2;22541:9;22537:18;22529:26;;22601:9;22595:4;22591:20;22587:1;22576:9;22572:17;22565:47;22629:131;22755:4;22629:131;:::i;:::-;22621:139;;22348:419;;;:::o;22773:235::-;22913:34;22909:1;22901:6;22897:14;22890:58;22982:18;22977:2;22969:6;22965:15;22958:43;22773:235;:::o;23014:366::-;23156:3;23177:67;23241:2;23236:3;23177:67;:::i;:::-;23170:74;;23253:93;23342:3;23253:93;:::i;:::-;23371:2;23366:3;23362:12;23355:19;;23014:366;;;:::o;23386:419::-;23552:4;23590:2;23579:9;23575:18;23567:26;;23639:9;23633:4;23629:20;23625:1;23614:9;23610:17;23603:47;23667:131;23793:4;23667:131;:::i;:::-;23659:139;;23386:419;;;:::o;23811:234::-;23951:34;23947:1;23939:6;23935:14;23928:58;24020:17;24015:2;24007:6;24003:15;23996:42;23811:234;:::o;24051:366::-;24193:3;24214:67;24278:2;24273:3;24214:67;:::i;:::-;24207:74;;24290:93;24379:3;24290:93;:::i;:::-;24408:2;24403:3;24399:12;24392:19;;24051:366;;;:::o;24423:419::-;24589:4;24627:2;24616:9;24612:18;24604:26;;24676:9;24670:4;24666:20;24662:1;24651:9;24647:17;24640:47;24704:131;24830:4;24704:131;:::i;:::-;24696:139;;24423:419;;;:::o;24848:238::-;24988:34;24984:1;24976:6;24972:14;24965:58;25057:21;25052:2;25044:6;25040:15;25033:46;24848:238;:::o;25092:366::-;25234:3;25255:67;25319:2;25314:3;25255:67;:::i;:::-;25248:74;;25331:93;25420:3;25331:93;:::i;:::-;25449:2;25444:3;25440:12;25433:19;;25092:366;;;:::o;25464:419::-;25630:4;25668:2;25657:9;25653:18;25645:26;;25717:9;25711:4;25707:20;25703:1;25692:9;25688:17;25681:47;25745:131;25871:4;25745:131;:::i;:::-;25737:139;;25464:419;;;:::o;25889:235::-;26029:34;26025:1;26017:6;26013:14;26006:58;26098:18;26093:2;26085:6;26081:15;26074:43;25889:235;:::o;26130:366::-;26272:3;26293:67;26357:2;26352:3;26293:67;:::i;:::-;26286:74;;26369:93;26458:3;26369:93;:::i;:::-;26487:2;26482:3;26478:12;26471:19;;26130:366;;;:::o;26502:419::-;26668:4;26706:2;26695:9;26691:18;26683:26;;26755:9;26749:4;26745:20;26741:1;26730:9;26726:17;26719:47;26783:131;26909:4;26783:131;:::i;:::-;26775:139;;26502:419;;;:::o;26927:234::-;27067:34;27063:1;27055:6;27051:14;27044:58;27136:17;27131:2;27123:6;27119:15;27112:42;26927:234;:::o;27167:366::-;27309:3;27330:67;27394:2;27389:3;27330:67;:::i;:::-;27323:74;;27406:93;27495:3;27406:93;:::i;:::-;27524:2;27519:3;27515:12;27508:19;;27167:366;;;:::o;27539:419::-;27705:4;27743:2;27732:9;27728:18;27720:26;;27792:9;27786:4;27782:20;27778:1;27767:9;27763:17;27756:47;27820:131;27946:4;27820:131;:::i;:::-;27812:139;;27539:419;;;:::o;27964:237::-;28104:34;28100:1;28092:6;28088:14;28081:58;28173:20;28168:2;28160:6;28156:15;28149:45;27964:237;:::o;28207:366::-;28349:3;28370:67;28434:2;28429:3;28370:67;:::i;:::-;28363:74;;28446:93;28535:3;28446:93;:::i;:::-;28564:2;28559:3;28555:12;28548:19;;28207:366;;;:::o;28579:419::-;28745:4;28783:2;28772:9;28768:18;28760:26;;28832:9;28826:4;28822:20;28818:1;28807:9;28803:17;28796:47;28860:131;28986:4;28860:131;:::i;:::-;28852:139;;28579:419;;;:::o;29004:225::-;29144:34;29140:1;29132:6;29128:14;29121:58;29213:8;29208:2;29200:6;29196:15;29189:33;29004:225;:::o;29235:366::-;29377:3;29398:67;29462:2;29457:3;29398:67;:::i;:::-;29391:74;;29474:93;29563:3;29474:93;:::i;:::-;29592:2;29587:3;29583:12;29576:19;;29235:366;;;:::o;29607:419::-;29773:4;29811:2;29800:9;29796:18;29788:26;;29860:9;29854:4;29850:20;29846:1;29835:9;29831:17;29824:47;29888:131;30014:4;29888:131;:::i;:::-;29880:139;;29607:419;;;:::o;30032:236::-;30172:34;30168:1;30160:6;30156:14;30149:58;30241:19;30236:2;30228:6;30224:15;30217:44;30032:236;:::o;30274:366::-;30416:3;30437:67;30501:2;30496:3;30437:67;:::i;:::-;30430:74;;30513:93;30602:3;30513:93;:::i;:::-;30631:2;30626:3;30622:12;30615:19;;30274:366;;;:::o;30646:419::-;30812:4;30850:2;30839:9;30835:18;30827:26;;30899:9;30893:4;30889:20;30885:1;30874:9;30870:17;30863:47;30927:131;31053:4;30927:131;:::i;:::-;30919:139;;30646:419;;;:::o;31071:231::-;31211:34;31207:1;31199:6;31195:14;31188:58;31280:14;31275:2;31267:6;31263:15;31256:39;31071:231;:::o;31308:366::-;31450:3;31471:67;31535:2;31530:3;31471:67;:::i;:::-;31464:74;;31547:93;31636:3;31547:93;:::i;:::-;31665:2;31660:3;31656:12;31649:19;;31308:366;;;:::o;31680:419::-;31846:4;31884:2;31873:9;31869:18;31861:26;;31933:9;31927:4;31923:20;31919:1;31908:9;31904:17;31897:47;31961:131;32087:4;31961:131;:::i;:::-;31953:139;;31680:419;;;:::o","linkReferences":{}},"methodIdentifiers":{"addressManagerImpl()":"bd366b8f","anchorStateRegistryProxy()":"35596f76","batchSubmitter()":"fb951e9d","challenger()":"534db0e2","delayedWethPermissionedGameProxy()":"794836d7","delayedWethPermissionlessGameProxy()":"97068797","disputeGameFactoryProxy()":"6c4568d1","ethLockboxProxy()":"f646b07c","faultDisputeGameCannonKonaImpl()":"5d25b21d","faultDisputeGameImpl()":"dea21984","l1CrossDomainMessengerProxy()":"54729cfb","l1Erc721BridgeProxy()":"ebfa8409","l1StandardBridgeProxy()":"102b6069","l2OutputOracleProxy()":"a2c9a89f","mipsImpl()":"e303272c","opChainGuardian()":"4bc2695f","opChainProxyAdminImpl()":"5643665f","opChainProxyAdminOwner()":"1480f0cc","optimismMintableErc20FactoryProxy()":"8f20c7e4","optimismPortalProxy()":"04451c49","permissioned()":"3cc162f1","permissionedDisputeGameImpl()":"98ccec3e","permissionless()":"a1256f9f","preimageOracleImpl()":"d030d2e8","proposer()":"a8e4fb90","respectedGameType()":"3c9f397c","set(bytes4,address)":"c3e39250","set(bytes4,bool)":"baa1e15e","set(bytes4,uint32)":"d08d6066","superchainConfigProxy()":"84cf2c97","systemConfigOwner()":"1e229b20","systemConfigProxy()":"c17db6e3","unsafeBlockSigner()":"1fd19ee1"},"rawMetadata":"{\"compiler\":{\"version\":\"0.8.27+commit.40a35a09\"},\"language\":\"Solidity\",\"output\":{\"abi\":[{\"inputs\":[],\"name\":\"addressManagerImpl\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"anchorStateRegistryProxy\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"batchSubmitter\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"challenger\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"delayedWethPermissionedGameProxy\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"delayedWethPermissionlessGameProxy\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"disputeGameFactoryProxy\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"ethLockboxProxy\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"faultDisputeGameCannonKonaImpl\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"faultDisputeGameImpl\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"l1CrossDomainMessengerProxy\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"l1Erc721BridgeProxy\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"l1StandardBridgeProxy\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"l2OutputOracleProxy\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"mipsImpl\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"opChainGuardian\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"opChainProxyAdminImpl\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"opChainProxyAdminOwner\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"optimismMintableErc20FactoryProxy\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"optimismPortalProxy\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"permissioned\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"permissionedDisputeGameImpl\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"permissionless\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"preimageOracleImpl\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"proposer\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"respectedGameType\",\"outputs\":[{\"internalType\":\"GameType\",\"name\":\"\",\"type\":\"uint32\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes4\",\"name\":\"_sel\",\"type\":\"bytes4\"},{\"internalType\":\"bool\",\"name\":\"_bool\",\"type\":\"bool\"}],\"name\":\"set\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes4\",\"name\":\"_sel\",\"type\":\"bytes4\"},{\"internalType\":\"address\",\"name\":\"_addr\",\"type\":\"address\"}],\"name\":\"set\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes4\",\"name\":\"_sel\",\"type\":\"bytes4\"},{\"internalType\":\"GameType\",\"name\":\"_gameType\",\"type\":\"uint32\"}],\"name\":\"set\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"superchainConfigProxy\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"systemConfigOwner\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"systemConfigProxy\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"unsafeBlockSigner\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"}],\"devdoc\":{\"kind\":\"dev\",\"methods\":{},\"version\":1},\"userdoc\":{\"kind\":\"user\",\"methods\":{},\"version\":1}},\"settings\":{\"compilationTarget\":{\"scripts/FetchChainInfo.s.sol\":\"FetchChainInfoOutput\"},\"evmVersion\":\"cancun\",\"libraries\":{},\"metadata\":{\"bytecodeHash\":\"none\",\"useLiteralContent\":true},\"optimizer\":{\"enabled\":false,\"runs\":0},\"remappings\":[\":@lib-keccak/=lib/lib-keccak/contracts/lib/\",\":@openzeppelin/contracts-upgradeable/=lib/openzeppelin-contracts-upgradeable/contracts/\",\":@openzeppelin/contracts-v5/=lib/openzeppelin-contracts-v5/contracts/\",\":@openzeppelin/contracts/=lib/openzeppelin-contracts/contracts/\",\":@rari-capital/solmate/=lib/solmate/\",\":@solady-test/=lib/lib-keccak/lib/solady/test/\",\":@solady-v0.0.245/=lib/solady-v0.0.245/src/\",\":@solady/=lib/solady/src/\",\":ds-test/=lib/forge-std/lib/ds-test/src/\",\":erc4626-tests/=lib/openzeppelin-contracts-v5/lib/erc4626-tests/\",\":forge-std/=lib/forge-std/src/\",\":interfaces/=interfaces/\",\":kontrol-cheatcodes/=lib/kontrol-cheatcodes/src/\",\":lib-keccak/=lib/lib-keccak/contracts/\",\":openzeppelin-contracts-upgradeable/=lib/openzeppelin-contracts-upgradeable/\",\":openzeppelin-contracts-v5/=lib/openzeppelin-contracts-v5/\",\":openzeppelin-contracts/=lib/openzeppelin-contracts/\",\":safe-contracts/=lib/safe-contracts/contracts/\",\":solady-v0.0.245/=lib/solady-v0.0.245/src/\",\":solady/=lib/solady/\",\":solmate/=lib/solmate/src/\"]},\"sources\":{\"lib/forge-std/src/Base.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity >=0.6.2 <0.9.0;\\n\\nimport {StdStorage} from \\\"./StdStorage.sol\\\";\\nimport {Vm, VmSafe} from \\\"./Vm.sol\\\";\\n\\nabstract contract CommonBase {\\n /// @dev Cheat code address.\\n /// Calculated as `address(uint160(uint256(keccak256(\\\"hevm cheat code\\\"))))`.\\n address internal constant VM_ADDRESS = 0x7109709ECfa91a80626fF3989D68f67F5b1DD12D;\\n /// @dev console.sol and console2.sol work by executing a staticcall to this address.\\n /// Calculated as `address(uint160(uint88(bytes11(\\\"console.log\\\"))))`.\\n address internal constant CONSOLE = 0x000000000000000000636F6e736F6c652e6c6f67;\\n /// @dev Used when deploying with create2.\\n /// Taken from https://github.com/Arachnid/deterministic-deployment-proxy.\\n address internal constant CREATE2_FACTORY = 0x4e59b44847b379578588920cA78FbF26c0B4956C;\\n /// @dev The default address for tx.origin and msg.sender.\\n /// Calculated as `address(uint160(uint256(keccak256(\\\"foundry default caller\\\"))))`.\\n address internal constant DEFAULT_SENDER = 0x1804c8AB1F12E6bbf3894d4083f33e07309d1f38;\\n /// @dev The address of the first contract `CREATE`d by a running test contract.\\n /// When running tests, each test contract is `CREATE`d by `DEFAULT_SENDER` with nonce 1.\\n /// Calculated as `VM.computeCreateAddress(VM.computeCreateAddress(DEFAULT_SENDER, 1), 1)`.\\n address internal constant DEFAULT_TEST_CONTRACT = 0x5615dEB798BB3E4dFa0139dFa1b3D433Cc23b72f;\\n /// @dev Deterministic deployment address of the Multicall3 contract.\\n /// Taken from https://www.multicall3.com.\\n address internal constant MULTICALL3_ADDRESS = 0xcA11bde05977b3631167028862bE2a173976CA11;\\n /// @dev The order of the secp256k1 curve.\\n uint256 internal constant SECP256K1_ORDER =\\n 115792089237316195423570985008687907852837564279074904382605163141518161494337;\\n\\n uint256 internal constant UINT256_MAX =\\n 115792089237316195423570985008687907853269984665640564039457584007913129639935;\\n\\n Vm internal constant vm = Vm(VM_ADDRESS);\\n StdStorage internal stdstore;\\n}\\n\\nabstract contract TestBase is CommonBase {}\\n\\nabstract contract ScriptBase is CommonBase {\\n VmSafe internal constant vmSafe = VmSafe(VM_ADDRESS);\\n}\\n\",\"keccak256\":\"0xa3735a6618a3014e42bb4329ad143e3b2c59cd95094350202e4c4a06c9d585dd\",\"license\":\"MIT\"},\"lib/forge-std/src/Script.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity >=0.6.2 <0.9.0;\\n\\n// \\ud83d\\udcac ABOUT\\n// Forge Std's default Script.\\n\\n// \\ud83e\\udde9 MODULES\\nimport {console} from \\\"./console.sol\\\";\\nimport {console2} from \\\"./console2.sol\\\";\\nimport {safeconsole} from \\\"./safeconsole.sol\\\";\\nimport {StdChains} from \\\"./StdChains.sol\\\";\\nimport {StdCheatsSafe} from \\\"./StdCheats.sol\\\";\\nimport {StdConstants} from \\\"./StdConstants.sol\\\";\\nimport {stdJson} from \\\"./StdJson.sol\\\";\\nimport {stdMath} from \\\"./StdMath.sol\\\";\\nimport {StdStorage, stdStorageSafe} from \\\"./StdStorage.sol\\\";\\nimport {StdStyle} from \\\"./StdStyle.sol\\\";\\nimport {StdUtils} from \\\"./StdUtils.sol\\\";\\nimport {VmSafe} from \\\"./Vm.sol\\\";\\n\\n// \\ud83d\\udce6 BOILERPLATE\\nimport {ScriptBase} from \\\"./Base.sol\\\";\\n\\n// \\u2b50\\ufe0f SCRIPT\\nabstract contract Script is ScriptBase, StdChains, StdCheatsSafe, StdUtils {\\n // Note: IS_SCRIPT() must return true.\\n bool public IS_SCRIPT = true;\\n}\\n\",\"keccak256\":\"0xc942e27c7baae499beb01afbbae99f24d42af9a6e4aae675bc6901b704aa8e9b\",\"license\":\"MIT\"},\"lib/forge-std/src/StdChains.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity >=0.6.2 <0.9.0;\\n\\nimport {VmSafe} from \\\"./Vm.sol\\\";\\n\\n/**\\n * StdChains provides information about EVM compatible chains that can be used in scripts/tests.\\n * For each chain, the chain's name, chain ID, and a default RPC URL are provided. Chains are\\n * identified by their alias, which is the same as the alias in the `[rpc_endpoints]` section of\\n * the `foundry.toml` file. For best UX, ensure the alias in the `foundry.toml` file match the\\n * alias used in this contract, which can be found as the first argument to the\\n * `setChainWithDefaultRpcUrl` call in the `initializeStdChains` function.\\n *\\n * There are two main ways to use this contract:\\n * 1. Set a chain with `setChain(string memory chainAlias, ChainData memory chain)` or\\n * `setChain(string memory chainAlias, Chain memory chain)`\\n * 2. Get a chain with `getChain(string memory chainAlias)` or `getChain(uint256 chainId)`.\\n *\\n * The first time either of those are used, chains are initialized with the default set of RPC URLs.\\n * This is done in `initializeStdChains`, which uses `setChainWithDefaultRpcUrl`. Defaults are recorded in\\n * `defaultRpcUrls`.\\n *\\n * The `setChain` function is straightforward, and it simply saves off the given chain data.\\n *\\n * The `getChain` methods use `getChainWithUpdatedRpcUrl` to return a chain. For example, let's say\\n * we want to retrieve the RPC URL for `mainnet`:\\n * - If you have specified data with `setChain`, it will return that.\\n * - If you have configured a mainnet RPC URL in `foundry.toml`, it will return the URL, provided it\\n * is valid (e.g. a URL is specified, or an environment variable is given and exists).\\n * - If neither of the above conditions is met, the default data is returned.\\n *\\n * Summarizing the above, the prioritization hierarchy is `setChain` -> `foundry.toml` -> environment variable -> defaults.\\n */\\nabstract contract StdChains {\\n VmSafe private constant vm = VmSafe(address(uint160(uint256(keccak256(\\\"hevm cheat code\\\")))));\\n\\n bool private stdChainsInitialized;\\n\\n struct ChainData {\\n string name;\\n uint256 chainId;\\n string rpcUrl;\\n }\\n\\n struct Chain {\\n // The chain name.\\n string name;\\n // The chain's Chain ID.\\n uint256 chainId;\\n // The chain's alias. (i.e. what gets specified in `foundry.toml`).\\n string chainAlias;\\n // A default RPC endpoint for this chain.\\n // NOTE: This default RPC URL is included for convenience to facilitate quick tests and\\n // experimentation. Do not use this RPC URL for production test suites, CI, or other heavy\\n // usage as you will be throttled and this is a disservice to others who need this endpoint.\\n string rpcUrl;\\n }\\n\\n // Maps from the chain's alias (matching the alias in the `foundry.toml` file) to chain data.\\n mapping(string => Chain) private chains;\\n // Maps from the chain's alias to it's default RPC URL.\\n mapping(string => string) private defaultRpcUrls;\\n // Maps from a chain ID to it's alias.\\n mapping(uint256 => string) private idToAlias;\\n\\n bool private fallbackToDefaultRpcUrls = true;\\n\\n // The RPC URL will be fetched from config or defaultRpcUrls if possible.\\n function getChain(string memory chainAlias) internal virtual returns (Chain memory chain) {\\n require(bytes(chainAlias).length != 0, \\\"StdChains getChain(string): Chain alias cannot be the empty string.\\\");\\n\\n initializeStdChains();\\n chain = chains[chainAlias];\\n require(\\n chain.chainId != 0,\\n string(abi.encodePacked(\\\"StdChains getChain(string): Chain with alias \\\\\\\"\\\", chainAlias, \\\"\\\\\\\" not found.\\\"))\\n );\\n\\n chain = getChainWithUpdatedRpcUrl(chainAlias, chain);\\n }\\n\\n function getChain(uint256 chainId) internal virtual returns (Chain memory chain) {\\n require(chainId != 0, \\\"StdChains getChain(uint256): Chain ID cannot be 0.\\\");\\n initializeStdChains();\\n string memory chainAlias = idToAlias[chainId];\\n\\n chain = chains[chainAlias];\\n\\n require(\\n chain.chainId != 0,\\n string(abi.encodePacked(\\\"StdChains getChain(uint256): Chain with ID \\\", vm.toString(chainId), \\\" not found.\\\"))\\n );\\n\\n chain = getChainWithUpdatedRpcUrl(chainAlias, chain);\\n }\\n\\n // set chain info, with priority to argument's rpcUrl field.\\n function setChain(string memory chainAlias, ChainData memory chain) internal virtual {\\n require(\\n bytes(chainAlias).length != 0,\\n \\\"StdChains setChain(string,ChainData): Chain alias cannot be the empty string.\\\"\\n );\\n\\n require(chain.chainId != 0, \\\"StdChains setChain(string,ChainData): Chain ID cannot be 0.\\\");\\n\\n initializeStdChains();\\n string memory foundAlias = idToAlias[chain.chainId];\\n\\n require(\\n bytes(foundAlias).length == 0 || keccak256(bytes(foundAlias)) == keccak256(bytes(chainAlias)),\\n string(\\n abi.encodePacked(\\n \\\"StdChains setChain(string,ChainData): Chain ID \\\",\\n vm.toString(chain.chainId),\\n \\\" already used by \\\\\\\"\\\",\\n foundAlias,\\n \\\"\\\\\\\".\\\"\\n )\\n )\\n );\\n\\n uint256 oldChainId = chains[chainAlias].chainId;\\n delete idToAlias[oldChainId];\\n\\n chains[chainAlias] =\\n Chain({name: chain.name, chainId: chain.chainId, chainAlias: chainAlias, rpcUrl: chain.rpcUrl});\\n idToAlias[chain.chainId] = chainAlias;\\n }\\n\\n // set chain info, with priority to argument's rpcUrl field.\\n function setChain(string memory chainAlias, Chain memory chain) internal virtual {\\n setChain(chainAlias, ChainData({name: chain.name, chainId: chain.chainId, rpcUrl: chain.rpcUrl}));\\n }\\n\\n function _toUpper(string memory str) private pure returns (string memory) {\\n bytes memory strb = bytes(str);\\n bytes memory copy = new bytes(strb.length);\\n for (uint256 i = 0; i < strb.length; i++) {\\n bytes1 b = strb[i];\\n if (b >= 0x61 && b <= 0x7A) {\\n copy[i] = bytes1(uint8(b) - 32);\\n } else {\\n copy[i] = b;\\n }\\n }\\n return string(copy);\\n }\\n\\n // lookup rpcUrl, in descending order of priority:\\n // current -> config (foundry.toml) -> environment variable -> default\\n function getChainWithUpdatedRpcUrl(string memory chainAlias, Chain memory chain)\\n private\\n view\\n returns (Chain memory)\\n {\\n if (bytes(chain.rpcUrl).length == 0) {\\n try vm.rpcUrl(chainAlias) returns (string memory configRpcUrl) {\\n chain.rpcUrl = configRpcUrl;\\n } catch (bytes memory err) {\\n string memory envName = string(abi.encodePacked(_toUpper(chainAlias), \\\"_RPC_URL\\\"));\\n if (fallbackToDefaultRpcUrls) {\\n chain.rpcUrl = vm.envOr(envName, defaultRpcUrls[chainAlias]);\\n } else {\\n chain.rpcUrl = vm.envString(envName);\\n }\\n // Distinguish 'not found' from 'cannot read'\\n // The upstream error thrown by forge for failing cheats changed so we check both the old and new versions\\n bytes memory oldNotFoundError =\\n abi.encodeWithSignature(\\\"CheatCodeError\\\", string(abi.encodePacked(\\\"invalid rpc url \\\", chainAlias)));\\n bytes memory newNotFoundError = abi.encodeWithSignature(\\n \\\"CheatcodeError(string)\\\", string(abi.encodePacked(\\\"invalid rpc url: \\\", chainAlias))\\n );\\n bytes32 errHash = keccak256(err);\\n if (\\n (errHash != keccak256(oldNotFoundError) && errHash != keccak256(newNotFoundError))\\n || bytes(chain.rpcUrl).length == 0\\n ) {\\n /// @solidity memory-safe-assembly\\n assembly {\\n revert(add(32, err), mload(err))\\n }\\n }\\n }\\n }\\n return chain;\\n }\\n\\n function setFallbackToDefaultRpcUrls(bool useDefault) internal {\\n fallbackToDefaultRpcUrls = useDefault;\\n }\\n\\n function initializeStdChains() private {\\n if (stdChainsInitialized) return;\\n\\n stdChainsInitialized = true;\\n\\n // If adding an RPC here, make sure to test the default RPC URL in `test_Rpcs` in `StdChains.t.sol`\\n setChainWithDefaultRpcUrl(\\\"anvil\\\", ChainData(\\\"Anvil\\\", 31337, \\\"http://127.0.0.1:8545\\\"));\\n setChainWithDefaultRpcUrl(\\\"mainnet\\\", ChainData(\\\"Mainnet\\\", 1, \\\"https://eth.llamarpc.com\\\"));\\n setChainWithDefaultRpcUrl(\\n \\\"sepolia\\\", ChainData(\\\"Sepolia\\\", 11155111, \\\"https://sepolia.infura.io/v3/b9794ad1ddf84dfb8c34d6bb5dca2001\\\")\\n );\\n setChainWithDefaultRpcUrl(\\\"holesky\\\", ChainData(\\\"Holesky\\\", 17000, \\\"https://rpc.holesky.ethpandaops.io\\\"));\\n setChainWithDefaultRpcUrl(\\\"optimism\\\", ChainData(\\\"Optimism\\\", 10, \\\"https://mainnet.optimism.io\\\"));\\n setChainWithDefaultRpcUrl(\\n \\\"optimism_sepolia\\\", ChainData(\\\"Optimism Sepolia\\\", 11155420, \\\"https://sepolia.optimism.io\\\")\\n );\\n setChainWithDefaultRpcUrl(\\\"arbitrum_one\\\", ChainData(\\\"Arbitrum One\\\", 42161, \\\"https://arb1.arbitrum.io/rpc\\\"));\\n setChainWithDefaultRpcUrl(\\n \\\"arbitrum_one_sepolia\\\", ChainData(\\\"Arbitrum One Sepolia\\\", 421614, \\\"https://sepolia-rollup.arbitrum.io/rpc\\\")\\n );\\n setChainWithDefaultRpcUrl(\\\"arbitrum_nova\\\", ChainData(\\\"Arbitrum Nova\\\", 42170, \\\"https://nova.arbitrum.io/rpc\\\"));\\n setChainWithDefaultRpcUrl(\\\"polygon\\\", ChainData(\\\"Polygon\\\", 137, \\\"https://polygon-rpc.com\\\"));\\n setChainWithDefaultRpcUrl(\\n \\\"polygon_amoy\\\", ChainData(\\\"Polygon Amoy\\\", 80002, \\\"https://rpc-amoy.polygon.technology\\\")\\n );\\n setChainWithDefaultRpcUrl(\\\"avalanche\\\", ChainData(\\\"Avalanche\\\", 43114, \\\"https://api.avax.network/ext/bc/C/rpc\\\"));\\n setChainWithDefaultRpcUrl(\\n \\\"avalanche_fuji\\\", ChainData(\\\"Avalanche Fuji\\\", 43113, \\\"https://api.avax-test.network/ext/bc/C/rpc\\\")\\n );\\n setChainWithDefaultRpcUrl(\\n \\\"bnb_smart_chain\\\", ChainData(\\\"BNB Smart Chain\\\", 56, \\\"https://bsc-dataseed1.binance.org\\\")\\n );\\n setChainWithDefaultRpcUrl(\\n \\\"bnb_smart_chain_testnet\\\",\\n ChainData(\\\"BNB Smart Chain Testnet\\\", 97, \\\"https://rpc.ankr.com/bsc_testnet_chapel\\\")\\n );\\n setChainWithDefaultRpcUrl(\\\"gnosis_chain\\\", ChainData(\\\"Gnosis Chain\\\", 100, \\\"https://rpc.gnosischain.com\\\"));\\n setChainWithDefaultRpcUrl(\\\"moonbeam\\\", ChainData(\\\"Moonbeam\\\", 1284, \\\"https://rpc.api.moonbeam.network\\\"));\\n setChainWithDefaultRpcUrl(\\n \\\"moonriver\\\", ChainData(\\\"Moonriver\\\", 1285, \\\"https://rpc.api.moonriver.moonbeam.network\\\")\\n );\\n setChainWithDefaultRpcUrl(\\\"moonbase\\\", ChainData(\\\"Moonbase\\\", 1287, \\\"https://rpc.testnet.moonbeam.network\\\"));\\n setChainWithDefaultRpcUrl(\\\"base_sepolia\\\", ChainData(\\\"Base Sepolia\\\", 84532, \\\"https://sepolia.base.org\\\"));\\n setChainWithDefaultRpcUrl(\\\"base\\\", ChainData(\\\"Base\\\", 8453, \\\"https://mainnet.base.org\\\"));\\n setChainWithDefaultRpcUrl(\\\"blast_sepolia\\\", ChainData(\\\"Blast Sepolia\\\", 168587773, \\\"https://sepolia.blast.io\\\"));\\n setChainWithDefaultRpcUrl(\\\"blast\\\", ChainData(\\\"Blast\\\", 81457, \\\"https://rpc.blast.io\\\"));\\n setChainWithDefaultRpcUrl(\\\"fantom_opera\\\", ChainData(\\\"Fantom Opera\\\", 250, \\\"https://rpc.ankr.com/fantom/\\\"));\\n setChainWithDefaultRpcUrl(\\n \\\"fantom_opera_testnet\\\", ChainData(\\\"Fantom Opera Testnet\\\", 4002, \\\"https://rpc.ankr.com/fantom_testnet/\\\")\\n );\\n setChainWithDefaultRpcUrl(\\\"fraxtal\\\", ChainData(\\\"Fraxtal\\\", 252, \\\"https://rpc.frax.com\\\"));\\n setChainWithDefaultRpcUrl(\\\"fraxtal_testnet\\\", ChainData(\\\"Fraxtal Testnet\\\", 2522, \\\"https://rpc.testnet.frax.com\\\"));\\n setChainWithDefaultRpcUrl(\\n \\\"berachain_bartio_testnet\\\", ChainData(\\\"Berachain bArtio Testnet\\\", 80084, \\\"https://bartio.rpc.berachain.com\\\")\\n );\\n setChainWithDefaultRpcUrl(\\\"flare\\\", ChainData(\\\"Flare\\\", 14, \\\"https://flare-api.flare.network/ext/C/rpc\\\"));\\n setChainWithDefaultRpcUrl(\\n \\\"flare_coston2\\\", ChainData(\\\"Flare Coston2\\\", 114, \\\"https://coston2-api.flare.network/ext/C/rpc\\\")\\n );\\n\\n setChainWithDefaultRpcUrl(\\\"mode\\\", ChainData(\\\"Mode\\\", 34443, \\\"https://mode.drpc.org\\\"));\\n setChainWithDefaultRpcUrl(\\\"mode_sepolia\\\", ChainData(\\\"Mode Sepolia\\\", 919, \\\"https://sepolia.mode.network\\\"));\\n\\n setChainWithDefaultRpcUrl(\\\"zora\\\", ChainData(\\\"Zora\\\", 7777777, \\\"https://zora.drpc.org\\\"));\\n setChainWithDefaultRpcUrl(\\n \\\"zora_sepolia\\\", ChainData(\\\"Zora Sepolia\\\", 999999999, \\\"https://sepolia.rpc.zora.energy\\\")\\n );\\n\\n setChainWithDefaultRpcUrl(\\\"race\\\", ChainData(\\\"Race\\\", 6805, \\\"https://racemainnet.io\\\"));\\n setChainWithDefaultRpcUrl(\\\"race_sepolia\\\", ChainData(\\\"Race Sepolia\\\", 6806, \\\"https://racemainnet.io\\\"));\\n\\n setChainWithDefaultRpcUrl(\\\"metal\\\", ChainData(\\\"Metal\\\", 1750, \\\"https://metall2.drpc.org\\\"));\\n setChainWithDefaultRpcUrl(\\\"metal_sepolia\\\", ChainData(\\\"Metal Sepolia\\\", 1740, \\\"https://testnet.rpc.metall2.com\\\"));\\n\\n setChainWithDefaultRpcUrl(\\\"binary\\\", ChainData(\\\"Binary\\\", 624, \\\"https://rpc.zero.thebinaryholdings.com\\\"));\\n setChainWithDefaultRpcUrl(\\n \\\"binary_sepolia\\\", ChainData(\\\"Binary Sepolia\\\", 625, \\\"https://rpc.zero.thebinaryholdings.com\\\")\\n );\\n\\n setChainWithDefaultRpcUrl(\\\"orderly\\\", ChainData(\\\"Orderly\\\", 291, \\\"https://rpc.orderly.network\\\"));\\n setChainWithDefaultRpcUrl(\\n \\\"orderly_sepolia\\\", ChainData(\\\"Orderly Sepolia\\\", 4460, \\\"https://testnet-rpc.orderly.org\\\")\\n );\\n }\\n\\n // set chain info, with priority to chainAlias' rpc url in foundry.toml\\n function setChainWithDefaultRpcUrl(string memory chainAlias, ChainData memory chain) private {\\n string memory rpcUrl = chain.rpcUrl;\\n defaultRpcUrls[chainAlias] = rpcUrl;\\n chain.rpcUrl = \\\"\\\";\\n setChain(chainAlias, chain);\\n chain.rpcUrl = rpcUrl; // restore argument\\n }\\n}\\n\",\"keccak256\":\"0x200b597cd01c229633b4a2317846cac7d36d337e2381b4a2e81faac23c2ad1cf\",\"license\":\"MIT\"},\"lib/forge-std/src/StdCheats.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity >=0.6.2 <0.9.0;\\n\\npragma experimental ABIEncoderV2;\\n\\nimport {StdStorage, stdStorage} from \\\"./StdStorage.sol\\\";\\nimport {console2} from \\\"./console2.sol\\\";\\nimport {Vm} from \\\"./Vm.sol\\\";\\n\\nabstract contract StdCheatsSafe {\\n Vm private constant vm = Vm(address(uint160(uint256(keccak256(\\\"hevm cheat code\\\")))));\\n\\n uint256 private constant UINT256_MAX =\\n 115792089237316195423570985008687907853269984665640564039457584007913129639935;\\n\\n bool private gasMeteringOff;\\n\\n // Data structures to parse Transaction objects from the broadcast artifact\\n // that conform to EIP1559. The Raw structs is what is parsed from the JSON\\n // and then converted to the one that is used by the user for better UX.\\n\\n struct RawTx1559 {\\n string[] arguments;\\n address contractAddress;\\n string contractName;\\n // json value name = function\\n string functionSig;\\n bytes32 hash;\\n // json value name = tx\\n RawTx1559Detail txDetail;\\n // json value name = type\\n string opcode;\\n }\\n\\n struct RawTx1559Detail {\\n AccessList[] accessList;\\n bytes data;\\n address from;\\n bytes gas;\\n bytes nonce;\\n address to;\\n bytes txType;\\n bytes value;\\n }\\n\\n struct Tx1559 {\\n string[] arguments;\\n address contractAddress;\\n string contractName;\\n string functionSig;\\n bytes32 hash;\\n Tx1559Detail txDetail;\\n string opcode;\\n }\\n\\n struct Tx1559Detail {\\n AccessList[] accessList;\\n bytes data;\\n address from;\\n uint256 gas;\\n uint256 nonce;\\n address to;\\n uint256 txType;\\n uint256 value;\\n }\\n\\n // Data structures to parse Transaction objects from the broadcast artifact\\n // that DO NOT conform to EIP1559. The Raw structs is what is parsed from the JSON\\n // and then converted to the one that is used by the user for better UX.\\n\\n struct TxLegacy {\\n string[] arguments;\\n address contractAddress;\\n string contractName;\\n string functionSig;\\n string hash;\\n string opcode;\\n TxDetailLegacy transaction;\\n }\\n\\n struct TxDetailLegacy {\\n AccessList[] accessList;\\n uint256 chainId;\\n bytes data;\\n address from;\\n uint256 gas;\\n uint256 gasPrice;\\n bytes32 hash;\\n uint256 nonce;\\n bytes1 opcode;\\n bytes32 r;\\n bytes32 s;\\n uint256 txType;\\n address to;\\n uint8 v;\\n uint256 value;\\n }\\n\\n struct AccessList {\\n address accessAddress;\\n bytes32[] storageKeys;\\n }\\n\\n // Data structures to parse Receipt objects from the broadcast artifact.\\n // The Raw structs is what is parsed from the JSON\\n // and then converted to the one that is used by the user for better UX.\\n\\n struct RawReceipt {\\n bytes32 blockHash;\\n bytes blockNumber;\\n address contractAddress;\\n bytes cumulativeGasUsed;\\n bytes effectiveGasPrice;\\n address from;\\n bytes gasUsed;\\n RawReceiptLog[] logs;\\n bytes logsBloom;\\n bytes status;\\n address to;\\n bytes32 transactionHash;\\n bytes transactionIndex;\\n }\\n\\n struct Receipt {\\n bytes32 blockHash;\\n uint256 blockNumber;\\n address contractAddress;\\n uint256 cumulativeGasUsed;\\n uint256 effectiveGasPrice;\\n address from;\\n uint256 gasUsed;\\n ReceiptLog[] logs;\\n bytes logsBloom;\\n uint256 status;\\n address to;\\n bytes32 transactionHash;\\n uint256 transactionIndex;\\n }\\n\\n // Data structures to parse the entire broadcast artifact, assuming the\\n // transactions conform to EIP1559.\\n\\n struct EIP1559ScriptArtifact {\\n string[] libraries;\\n string path;\\n string[] pending;\\n Receipt[] receipts;\\n uint256 timestamp;\\n Tx1559[] transactions;\\n TxReturn[] txReturns;\\n }\\n\\n struct RawEIP1559ScriptArtifact {\\n string[] libraries;\\n string path;\\n string[] pending;\\n RawReceipt[] receipts;\\n TxReturn[] txReturns;\\n uint256 timestamp;\\n RawTx1559[] transactions;\\n }\\n\\n struct RawReceiptLog {\\n // json value = address\\n address logAddress;\\n bytes32 blockHash;\\n bytes blockNumber;\\n bytes data;\\n bytes logIndex;\\n bool removed;\\n bytes32[] topics;\\n bytes32 transactionHash;\\n bytes transactionIndex;\\n bytes transactionLogIndex;\\n }\\n\\n struct ReceiptLog {\\n // json value = address\\n address logAddress;\\n bytes32 blockHash;\\n uint256 blockNumber;\\n bytes data;\\n uint256 logIndex;\\n bytes32[] topics;\\n uint256 transactionIndex;\\n uint256 transactionLogIndex;\\n bool removed;\\n }\\n\\n struct TxReturn {\\n string internalType;\\n string value;\\n }\\n\\n struct Account {\\n address addr;\\n uint256 key;\\n }\\n\\n enum AddressType {\\n Payable,\\n NonPayable,\\n ZeroAddress,\\n Precompile,\\n ForgeAddress\\n }\\n\\n // Checks that `addr` is not blacklisted by token contracts that have a blacklist.\\n function assumeNotBlacklisted(address token, address addr) internal view virtual {\\n // Nothing to check if `token` is not a contract.\\n uint256 tokenCodeSize;\\n assembly {\\n tokenCodeSize := extcodesize(token)\\n }\\n require(tokenCodeSize > 0, \\\"StdCheats assumeNotBlacklisted(address,address): Token address is not a contract.\\\");\\n\\n bool success;\\n bytes memory returnData;\\n\\n // 4-byte selector for `isBlacklisted(address)`, used by USDC.\\n (success, returnData) = token.staticcall(abi.encodeWithSelector(0xfe575a87, addr));\\n vm.assume(!success || abi.decode(returnData, (bool)) == false);\\n\\n // 4-byte selector for `isBlackListed(address)`, used by USDT.\\n (success, returnData) = token.staticcall(abi.encodeWithSelector(0xe47d6060, addr));\\n vm.assume(!success || abi.decode(returnData, (bool)) == false);\\n }\\n\\n // Checks that `addr` is not blacklisted by token contracts that have a blacklist.\\n // This is identical to `assumeNotBlacklisted(address,address)` but with a different name, for\\n // backwards compatibility, since this name was used in the original PR which already has\\n // a release. This function can be removed in a future release once we want a breaking change.\\n function assumeNoBlacklisted(address token, address addr) internal view virtual {\\n assumeNotBlacklisted(token, addr);\\n }\\n\\n function assumeAddressIsNot(address addr, AddressType addressType) internal virtual {\\n if (addressType == AddressType.Payable) {\\n assumeNotPayable(addr);\\n } else if (addressType == AddressType.NonPayable) {\\n assumePayable(addr);\\n } else if (addressType == AddressType.ZeroAddress) {\\n assumeNotZeroAddress(addr);\\n } else if (addressType == AddressType.Precompile) {\\n assumeNotPrecompile(addr);\\n } else if (addressType == AddressType.ForgeAddress) {\\n assumeNotForgeAddress(addr);\\n }\\n }\\n\\n function assumeAddressIsNot(address addr, AddressType addressType1, AddressType addressType2) internal virtual {\\n assumeAddressIsNot(addr, addressType1);\\n assumeAddressIsNot(addr, addressType2);\\n }\\n\\n function assumeAddressIsNot(\\n address addr,\\n AddressType addressType1,\\n AddressType addressType2,\\n AddressType addressType3\\n ) internal virtual {\\n assumeAddressIsNot(addr, addressType1);\\n assumeAddressIsNot(addr, addressType2);\\n assumeAddressIsNot(addr, addressType3);\\n }\\n\\n function assumeAddressIsNot(\\n address addr,\\n AddressType addressType1,\\n AddressType addressType2,\\n AddressType addressType3,\\n AddressType addressType4\\n ) internal virtual {\\n assumeAddressIsNot(addr, addressType1);\\n assumeAddressIsNot(addr, addressType2);\\n assumeAddressIsNot(addr, addressType3);\\n assumeAddressIsNot(addr, addressType4);\\n }\\n\\n // This function checks whether an address, `addr`, is payable. It works by sending 1 wei to\\n // `addr` and checking the `success` return value.\\n // NOTE: This function may result in state changes depending on the fallback/receive logic\\n // implemented by `addr`, which should be taken into account when this function is used.\\n function _isPayable(address addr) private returns (bool) {\\n require(\\n addr.balance < UINT256_MAX,\\n \\\"StdCheats _isPayable(address): Balance equals max uint256, so it cannot receive any more funds\\\"\\n );\\n uint256 origBalanceTest = address(this).balance;\\n uint256 origBalanceAddr = address(addr).balance;\\n\\n vm.deal(address(this), 1);\\n (bool success,) = payable(addr).call{value: 1}(\\\"\\\");\\n\\n // reset balances\\n vm.deal(address(this), origBalanceTest);\\n vm.deal(addr, origBalanceAddr);\\n\\n return success;\\n }\\n\\n // NOTE: This function may result in state changes depending on the fallback/receive logic\\n // implemented by `addr`, which should be taken into account when this function is used. See the\\n // `_isPayable` method for more information.\\n function assumePayable(address addr) internal virtual {\\n vm.assume(_isPayable(addr));\\n }\\n\\n function assumeNotPayable(address addr) internal virtual {\\n vm.assume(!_isPayable(addr));\\n }\\n\\n function assumeNotZeroAddress(address addr) internal pure virtual {\\n vm.assume(addr != address(0));\\n }\\n\\n function assumeNotPrecompile(address addr) internal pure virtual {\\n assumeNotPrecompile(addr, _pureChainId());\\n }\\n\\n function assumeNotPrecompile(address addr, uint256 chainId) internal pure virtual {\\n // Note: For some chains like Optimism these are technically predeploys (i.e. bytecode placed at a specific\\n // address), but the same rationale for excluding them applies so we include those too.\\n\\n // These are reserved by Ethereum and may be on all EVM-compatible chains.\\n vm.assume(addr < address(0x1) || addr > address(0xff));\\n\\n // forgefmt: disable-start\\n if (chainId == 10 || chainId == 420) {\\n // https://github.com/ethereum-optimism/optimism/blob/eaa371a0184b56b7ca6d9eb9cb0a2b78b2ccd864/op-bindings/predeploys/addresses.go#L6-L21\\n vm.assume(addr < address(0x4200000000000000000000000000000000000000) || addr > address(0x4200000000000000000000000000000000000800));\\n } else if (chainId == 42161 || chainId == 421613) {\\n // https://developer.arbitrum.io/useful-addresses#arbitrum-precompiles-l2-same-on-all-arb-chains\\n vm.assume(addr < address(0x0000000000000000000000000000000000000064) || addr > address(0x0000000000000000000000000000000000000068));\\n } else if (chainId == 43114 || chainId == 43113) {\\n // https://github.com/ava-labs/subnet-evm/blob/47c03fd007ecaa6de2c52ea081596e0a88401f58/precompile/params.go#L18-L59\\n vm.assume(addr < address(0x0100000000000000000000000000000000000000) || addr > address(0x01000000000000000000000000000000000000ff));\\n vm.assume(addr < address(0x0200000000000000000000000000000000000000) || addr > address(0x02000000000000000000000000000000000000FF));\\n vm.assume(addr < address(0x0300000000000000000000000000000000000000) || addr > address(0x03000000000000000000000000000000000000Ff));\\n }\\n // forgefmt: disable-end\\n }\\n\\n function assumeNotForgeAddress(address addr) internal pure virtual {\\n // vm, console, and Create2Deployer addresses\\n vm.assume(\\n addr != address(vm) && addr != 0x000000000000000000636F6e736F6c652e6c6f67\\n && addr != 0x4e59b44847b379578588920cA78FbF26c0B4956C\\n );\\n }\\n\\n function assumeUnusedAddress(address addr) internal view virtual {\\n uint256 size;\\n assembly {\\n size := extcodesize(addr)\\n }\\n vm.assume(size == 0);\\n\\n assumeNotPrecompile(addr);\\n assumeNotZeroAddress(addr);\\n assumeNotForgeAddress(addr);\\n }\\n\\n function readEIP1559ScriptArtifact(string memory path)\\n internal\\n view\\n virtual\\n returns (EIP1559ScriptArtifact memory)\\n {\\n string memory data = vm.readFile(path);\\n bytes memory parsedData = vm.parseJson(data);\\n RawEIP1559ScriptArtifact memory rawArtifact = abi.decode(parsedData, (RawEIP1559ScriptArtifact));\\n EIP1559ScriptArtifact memory artifact;\\n artifact.libraries = rawArtifact.libraries;\\n artifact.path = rawArtifact.path;\\n artifact.timestamp = rawArtifact.timestamp;\\n artifact.pending = rawArtifact.pending;\\n artifact.txReturns = rawArtifact.txReturns;\\n artifact.receipts = rawToConvertedReceipts(rawArtifact.receipts);\\n artifact.transactions = rawToConvertedEIPTx1559s(rawArtifact.transactions);\\n return artifact;\\n }\\n\\n function rawToConvertedEIPTx1559s(RawTx1559[] memory rawTxs) internal pure virtual returns (Tx1559[] memory) {\\n Tx1559[] memory txs = new Tx1559[](rawTxs.length);\\n for (uint256 i; i < rawTxs.length; i++) {\\n txs[i] = rawToConvertedEIPTx1559(rawTxs[i]);\\n }\\n return txs;\\n }\\n\\n function rawToConvertedEIPTx1559(RawTx1559 memory rawTx) internal pure virtual returns (Tx1559 memory) {\\n Tx1559 memory transaction;\\n transaction.arguments = rawTx.arguments;\\n transaction.contractName = rawTx.contractName;\\n transaction.functionSig = rawTx.functionSig;\\n transaction.hash = rawTx.hash;\\n transaction.txDetail = rawToConvertedEIP1559Detail(rawTx.txDetail);\\n transaction.opcode = rawTx.opcode;\\n return transaction;\\n }\\n\\n function rawToConvertedEIP1559Detail(RawTx1559Detail memory rawDetail)\\n internal\\n pure\\n virtual\\n returns (Tx1559Detail memory)\\n {\\n Tx1559Detail memory txDetail;\\n txDetail.data = rawDetail.data;\\n txDetail.from = rawDetail.from;\\n txDetail.to = rawDetail.to;\\n txDetail.nonce = _bytesToUint(rawDetail.nonce);\\n txDetail.txType = _bytesToUint(rawDetail.txType);\\n txDetail.value = _bytesToUint(rawDetail.value);\\n txDetail.gas = _bytesToUint(rawDetail.gas);\\n txDetail.accessList = rawDetail.accessList;\\n return txDetail;\\n }\\n\\n function readTx1559s(string memory path) internal view virtual returns (Tx1559[] memory) {\\n string memory deployData = vm.readFile(path);\\n bytes memory parsedDeployData = vm.parseJson(deployData, \\\".transactions\\\");\\n RawTx1559[] memory rawTxs = abi.decode(parsedDeployData, (RawTx1559[]));\\n return rawToConvertedEIPTx1559s(rawTxs);\\n }\\n\\n function readTx1559(string memory path, uint256 index) internal view virtual returns (Tx1559 memory) {\\n string memory deployData = vm.readFile(path);\\n string memory key = string(abi.encodePacked(\\\".transactions[\\\", vm.toString(index), \\\"]\\\"));\\n bytes memory parsedDeployData = vm.parseJson(deployData, key);\\n RawTx1559 memory rawTx = abi.decode(parsedDeployData, (RawTx1559));\\n return rawToConvertedEIPTx1559(rawTx);\\n }\\n\\n // Analogous to readTransactions, but for receipts.\\n function readReceipts(string memory path) internal view virtual returns (Receipt[] memory) {\\n string memory deployData = vm.readFile(path);\\n bytes memory parsedDeployData = vm.parseJson(deployData, \\\".receipts\\\");\\n RawReceipt[] memory rawReceipts = abi.decode(parsedDeployData, (RawReceipt[]));\\n return rawToConvertedReceipts(rawReceipts);\\n }\\n\\n function readReceipt(string memory path, uint256 index) internal view virtual returns (Receipt memory) {\\n string memory deployData = vm.readFile(path);\\n string memory key = string(abi.encodePacked(\\\".receipts[\\\", vm.toString(index), \\\"]\\\"));\\n bytes memory parsedDeployData = vm.parseJson(deployData, key);\\n RawReceipt memory rawReceipt = abi.decode(parsedDeployData, (RawReceipt));\\n return rawToConvertedReceipt(rawReceipt);\\n }\\n\\n function rawToConvertedReceipts(RawReceipt[] memory rawReceipts) internal pure virtual returns (Receipt[] memory) {\\n Receipt[] memory receipts = new Receipt[](rawReceipts.length);\\n for (uint256 i; i < rawReceipts.length; i++) {\\n receipts[i] = rawToConvertedReceipt(rawReceipts[i]);\\n }\\n return receipts;\\n }\\n\\n function rawToConvertedReceipt(RawReceipt memory rawReceipt) internal pure virtual returns (Receipt memory) {\\n Receipt memory receipt;\\n receipt.blockHash = rawReceipt.blockHash;\\n receipt.to = rawReceipt.to;\\n receipt.from = rawReceipt.from;\\n receipt.contractAddress = rawReceipt.contractAddress;\\n receipt.effectiveGasPrice = _bytesToUint(rawReceipt.effectiveGasPrice);\\n receipt.cumulativeGasUsed = _bytesToUint(rawReceipt.cumulativeGasUsed);\\n receipt.gasUsed = _bytesToUint(rawReceipt.gasUsed);\\n receipt.status = _bytesToUint(rawReceipt.status);\\n receipt.transactionIndex = _bytesToUint(rawReceipt.transactionIndex);\\n receipt.blockNumber = _bytesToUint(rawReceipt.blockNumber);\\n receipt.logs = rawToConvertedReceiptLogs(rawReceipt.logs);\\n receipt.logsBloom = rawReceipt.logsBloom;\\n receipt.transactionHash = rawReceipt.transactionHash;\\n return receipt;\\n }\\n\\n function rawToConvertedReceiptLogs(RawReceiptLog[] memory rawLogs)\\n internal\\n pure\\n virtual\\n returns (ReceiptLog[] memory)\\n {\\n ReceiptLog[] memory logs = new ReceiptLog[](rawLogs.length);\\n for (uint256 i; i < rawLogs.length; i++) {\\n logs[i].logAddress = rawLogs[i].logAddress;\\n logs[i].blockHash = rawLogs[i].blockHash;\\n logs[i].blockNumber = _bytesToUint(rawLogs[i].blockNumber);\\n logs[i].data = rawLogs[i].data;\\n logs[i].logIndex = _bytesToUint(rawLogs[i].logIndex);\\n logs[i].topics = rawLogs[i].topics;\\n logs[i].transactionIndex = _bytesToUint(rawLogs[i].transactionIndex);\\n logs[i].transactionLogIndex = _bytesToUint(rawLogs[i].transactionLogIndex);\\n logs[i].removed = rawLogs[i].removed;\\n }\\n return logs;\\n }\\n\\n // Deploy a contract by fetching the contract bytecode from\\n // the artifacts directory\\n // e.g. `deployCode(code, abi.encode(arg1,arg2,arg3))`\\n function deployCode(string memory what, bytes memory args) internal virtual returns (address addr) {\\n bytes memory bytecode = abi.encodePacked(vm.getCode(what), args);\\n /// @solidity memory-safe-assembly\\n assembly {\\n addr := create(0, add(bytecode, 0x20), mload(bytecode))\\n }\\n\\n require(addr != address(0), \\\"StdCheats deployCode(string,bytes): Deployment failed.\\\");\\n }\\n\\n function deployCode(string memory what) internal virtual returns (address addr) {\\n bytes memory bytecode = vm.getCode(what);\\n /// @solidity memory-safe-assembly\\n assembly {\\n addr := create(0, add(bytecode, 0x20), mload(bytecode))\\n }\\n\\n require(addr != address(0), \\\"StdCheats deployCode(string): Deployment failed.\\\");\\n }\\n\\n /// @dev deploy contract with value on construction\\n function deployCode(string memory what, bytes memory args, uint256 val) internal virtual returns (address addr) {\\n bytes memory bytecode = abi.encodePacked(vm.getCode(what), args);\\n /// @solidity memory-safe-assembly\\n assembly {\\n addr := create(val, add(bytecode, 0x20), mload(bytecode))\\n }\\n\\n require(addr != address(0), \\\"StdCheats deployCode(string,bytes,uint256): Deployment failed.\\\");\\n }\\n\\n function deployCode(string memory what, uint256 val) internal virtual returns (address addr) {\\n bytes memory bytecode = vm.getCode(what);\\n /// @solidity memory-safe-assembly\\n assembly {\\n addr := create(val, add(bytecode, 0x20), mload(bytecode))\\n }\\n\\n require(addr != address(0), \\\"StdCheats deployCode(string,uint256): Deployment failed.\\\");\\n }\\n\\n // creates a labeled address and the corresponding private key\\n function makeAddrAndKey(string memory name) internal virtual returns (address addr, uint256 privateKey) {\\n privateKey = uint256(keccak256(abi.encodePacked(name)));\\n addr = vm.addr(privateKey);\\n vm.label(addr, name);\\n }\\n\\n // creates a labeled address\\n function makeAddr(string memory name) internal virtual returns (address addr) {\\n (addr,) = makeAddrAndKey(name);\\n }\\n\\n // Destroys an account immediately, sending the balance to beneficiary.\\n // Destroying means: balance will be zero, code will be empty, and nonce will be 0\\n // This is similar to selfdestruct but not identical: selfdestruct destroys code and nonce\\n // only after tx ends, this will run immediately.\\n function destroyAccount(address who, address beneficiary) internal virtual {\\n uint256 currBalance = who.balance;\\n vm.etch(who, abi.encode());\\n vm.deal(who, 0);\\n vm.resetNonce(who);\\n\\n uint256 beneficiaryBalance = beneficiary.balance;\\n vm.deal(beneficiary, currBalance + beneficiaryBalance);\\n }\\n\\n // creates a struct containing both a labeled address and the corresponding private key\\n function makeAccount(string memory name) internal virtual returns (Account memory account) {\\n (account.addr, account.key) = makeAddrAndKey(name);\\n }\\n\\n function deriveRememberKey(string memory mnemonic, uint32 index)\\n internal\\n virtual\\n returns (address who, uint256 privateKey)\\n {\\n privateKey = vm.deriveKey(mnemonic, index);\\n who = vm.rememberKey(privateKey);\\n }\\n\\n function _bytesToUint(bytes memory b) private pure returns (uint256) {\\n require(b.length <= 32, \\\"StdCheats _bytesToUint(bytes): Bytes length exceeds 32.\\\");\\n return abi.decode(abi.encodePacked(new bytes(32 - b.length), b), (uint256));\\n }\\n\\n function isFork() internal view virtual returns (bool status) {\\n try vm.activeFork() {\\n status = true;\\n } catch (bytes memory) {}\\n }\\n\\n modifier skipWhenForking() {\\n if (!isFork()) {\\n _;\\n }\\n }\\n\\n modifier skipWhenNotForking() {\\n if (isFork()) {\\n _;\\n }\\n }\\n\\n modifier noGasMetering() {\\n vm.pauseGasMetering();\\n // To prevent turning gas monitoring back on with nested functions that use this modifier,\\n // we check if gasMetering started in the off position. If it did, we don't want to turn\\n // it back on until we exit the top level function that used the modifier\\n //\\n // i.e. funcA() noGasMetering { funcB() }, where funcB has noGasMetering as well.\\n // funcA will have `gasStartedOff` as false, funcB will have it as true,\\n // so we only turn metering back on at the end of the funcA\\n bool gasStartedOff = gasMeteringOff;\\n gasMeteringOff = true;\\n\\n _;\\n\\n // if gas metering was on when this modifier was called, turn it back on at the end\\n if (!gasStartedOff) {\\n gasMeteringOff = false;\\n vm.resumeGasMetering();\\n }\\n }\\n\\n // We use this complex approach of `_viewChainId` and `_pureChainId` to ensure there are no\\n // compiler warnings when accessing chain ID in any solidity version supported by forge-std. We\\n // can't simply access the chain ID in a normal view or pure function because the solc View Pure\\n // Checker changed `chainid` from pure to view in 0.8.0.\\n function _viewChainId() private view returns (uint256 chainId) {\\n // Assembly required since `block.chainid` was introduced in 0.8.0.\\n assembly {\\n chainId := chainid()\\n }\\n\\n address(this); // Silence warnings in older Solc versions.\\n }\\n\\n function _pureChainId() private pure returns (uint256 chainId) {\\n function() internal view returns (uint256) fnIn = _viewChainId;\\n function() internal pure returns (uint256) pureChainId;\\n assembly {\\n pureChainId := fnIn\\n }\\n chainId = pureChainId();\\n }\\n}\\n\\n// Wrappers around cheatcodes to avoid footguns\\nabstract contract StdCheats is StdCheatsSafe {\\n using stdStorage for StdStorage;\\n\\n StdStorage private stdstore;\\n Vm private constant vm = Vm(address(uint160(uint256(keccak256(\\\"hevm cheat code\\\")))));\\n address private constant CONSOLE2_ADDRESS = 0x000000000000000000636F6e736F6c652e6c6f67;\\n\\n // Skip forward or rewind time by the specified number of seconds\\n function skip(uint256 time) internal virtual {\\n vm.warp(vm.getBlockTimestamp() + time);\\n }\\n\\n function rewind(uint256 time) internal virtual {\\n vm.warp(vm.getBlockTimestamp() - time);\\n }\\n\\n // Setup a prank from an address that has some ether\\n function hoax(address msgSender) internal virtual {\\n vm.deal(msgSender, 1 << 128);\\n vm.prank(msgSender);\\n }\\n\\n function hoax(address msgSender, uint256 give) internal virtual {\\n vm.deal(msgSender, give);\\n vm.prank(msgSender);\\n }\\n\\n function hoax(address msgSender, address origin) internal virtual {\\n vm.deal(msgSender, 1 << 128);\\n vm.prank(msgSender, origin);\\n }\\n\\n function hoax(address msgSender, address origin, uint256 give) internal virtual {\\n vm.deal(msgSender, give);\\n vm.prank(msgSender, origin);\\n }\\n\\n // Start perpetual prank from an address that has some ether\\n function startHoax(address msgSender) internal virtual {\\n vm.deal(msgSender, 1 << 128);\\n vm.startPrank(msgSender);\\n }\\n\\n function startHoax(address msgSender, uint256 give) internal virtual {\\n vm.deal(msgSender, give);\\n vm.startPrank(msgSender);\\n }\\n\\n // Start perpetual prank from an address that has some ether\\n // tx.origin is set to the origin parameter\\n function startHoax(address msgSender, address origin) internal virtual {\\n vm.deal(msgSender, 1 << 128);\\n vm.startPrank(msgSender, origin);\\n }\\n\\n function startHoax(address msgSender, address origin, uint256 give) internal virtual {\\n vm.deal(msgSender, give);\\n vm.startPrank(msgSender, origin);\\n }\\n\\n function changePrank(address msgSender) internal virtual {\\n console2_log_StdCheats(\\\"changePrank is deprecated. Please use vm.startPrank instead.\\\");\\n vm.stopPrank();\\n vm.startPrank(msgSender);\\n }\\n\\n function changePrank(address msgSender, address txOrigin) internal virtual {\\n vm.stopPrank();\\n vm.startPrank(msgSender, txOrigin);\\n }\\n\\n // The same as Vm's `deal`\\n // Use the alternative signature for ERC20 tokens\\n function deal(address to, uint256 give) internal virtual {\\n vm.deal(to, give);\\n }\\n\\n // Set the balance of an account for any ERC20 token\\n // Use the alternative signature to update `totalSupply`\\n function deal(address token, address to, uint256 give) internal virtual {\\n deal(token, to, give, false);\\n }\\n\\n // Set the balance of an account for any ERC1155 token\\n // Use the alternative signature to update `totalSupply`\\n function dealERC1155(address token, address to, uint256 id, uint256 give) internal virtual {\\n dealERC1155(token, to, id, give, false);\\n }\\n\\n function deal(address token, address to, uint256 give, bool adjust) internal virtual {\\n // get current balance\\n (, bytes memory balData) = token.staticcall(abi.encodeWithSelector(0x70a08231, to));\\n uint256 prevBal = abi.decode(balData, (uint256));\\n\\n // update balance\\n stdstore.target(token).sig(0x70a08231).with_key(to).checked_write(give);\\n\\n // update total supply\\n if (adjust) {\\n (, bytes memory totSupData) = token.staticcall(abi.encodeWithSelector(0x18160ddd));\\n uint256 totSup = abi.decode(totSupData, (uint256));\\n if (give < prevBal) {\\n totSup -= (prevBal - give);\\n } else {\\n totSup += (give - prevBal);\\n }\\n stdstore.target(token).sig(0x18160ddd).checked_write(totSup);\\n }\\n }\\n\\n function dealERC1155(address token, address to, uint256 id, uint256 give, bool adjust) internal virtual {\\n // get current balance\\n (, bytes memory balData) = token.staticcall(abi.encodeWithSelector(0x00fdd58e, to, id));\\n uint256 prevBal = abi.decode(balData, (uint256));\\n\\n // update balance\\n stdstore.target(token).sig(0x00fdd58e).with_key(to).with_key(id).checked_write(give);\\n\\n // update total supply\\n if (adjust) {\\n (, bytes memory totSupData) = token.staticcall(abi.encodeWithSelector(0xbd85b039, id));\\n require(\\n totSupData.length != 0,\\n \\\"StdCheats deal(address,address,uint,uint,bool): target contract is not ERC1155Supply.\\\"\\n );\\n uint256 totSup = abi.decode(totSupData, (uint256));\\n if (give < prevBal) {\\n totSup -= (prevBal - give);\\n } else {\\n totSup += (give - prevBal);\\n }\\n stdstore.target(token).sig(0xbd85b039).with_key(id).checked_write(totSup);\\n }\\n }\\n\\n function dealERC721(address token, address to, uint256 id) internal virtual {\\n // check if token id is already minted and the actual owner.\\n (bool successMinted, bytes memory ownerData) = token.staticcall(abi.encodeWithSelector(0x6352211e, id));\\n require(successMinted, \\\"StdCheats deal(address,address,uint,bool): id not minted.\\\");\\n\\n // get owner current balance\\n (, bytes memory fromBalData) =\\n token.staticcall(abi.encodeWithSelector(0x70a08231, abi.decode(ownerData, (address))));\\n uint256 fromPrevBal = abi.decode(fromBalData, (uint256));\\n\\n // get new user current balance\\n (, bytes memory toBalData) = token.staticcall(abi.encodeWithSelector(0x70a08231, to));\\n uint256 toPrevBal = abi.decode(toBalData, (uint256));\\n\\n // update balances\\n stdstore.target(token).sig(0x70a08231).with_key(abi.decode(ownerData, (address))).checked_write(--fromPrevBal);\\n stdstore.target(token).sig(0x70a08231).with_key(to).checked_write(++toPrevBal);\\n\\n // update owner\\n stdstore.target(token).sig(0x6352211e).with_key(id).checked_write(to);\\n }\\n\\n function deployCodeTo(string memory what, address where) internal virtual {\\n deployCodeTo(what, \\\"\\\", 0, where);\\n }\\n\\n function deployCodeTo(string memory what, bytes memory args, address where) internal virtual {\\n deployCodeTo(what, args, 0, where);\\n }\\n\\n function deployCodeTo(string memory what, bytes memory args, uint256 value, address where) internal virtual {\\n bytes memory creationCode = vm.getCode(what);\\n vm.etch(where, abi.encodePacked(creationCode, args));\\n (bool success, bytes memory runtimeBytecode) = where.call{value: value}(\\\"\\\");\\n require(success, \\\"StdCheats deployCodeTo(string,bytes,uint256,address): Failed to create runtime bytecode.\\\");\\n vm.etch(where, runtimeBytecode);\\n }\\n\\n // Used to prevent the compilation of console, which shortens the compilation time when console is not used elsewhere.\\n function console2_log_StdCheats(string memory p0) private view {\\n (bool status,) = address(CONSOLE2_ADDRESS).staticcall(abi.encodeWithSignature(\\\"log(string)\\\", p0));\\n status;\\n }\\n}\\n\",\"keccak256\":\"0x0fa6ec03602648b62cce41aab2096e6b7e052f2846075d967b6958dd586db746\",\"license\":\"MIT\"},\"lib/forge-std/src/StdConstants.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity >=0.6.2 <0.9.0;\\n\\nimport {IMulticall3} from \\\"./interfaces/IMulticall3.sol\\\";\\nimport {Vm} from \\\"./Vm.sol\\\";\\n\\nlibrary StdConstants {\\n /// @dev Cheat code address.\\n /// Calculated as `address(uint160(uint256(keccak256(\\\"hevm cheat code\\\"))))`.\\n Vm internal constant VM = Vm(0x7109709ECfa91a80626fF3989D68f67F5b1DD12D);\\n /// @dev console.sol and console2.sol work by executing a staticcall to this address.\\n /// Calculated as `address(uint160(uint88(bytes11(\\\"console.log\\\"))))`.\\n address internal constant CONSOLE = 0x000000000000000000636F6e736F6c652e6c6f67;\\n /// @dev Used when deploying with create2.\\n /// Taken from https://github.com/Arachnid/deterministic-deployment-proxy.\\n address internal constant CREATE2_FACTORY = 0x4e59b44847b379578588920cA78FbF26c0B4956C;\\n /// @dev The default address for tx.origin and msg.sender.\\n /// Calculated as `address(uint160(uint256(keccak256(\\\"foundry default caller\\\"))))`.\\n address internal constant DEFAULT_SENDER = 0x1804c8AB1F12E6bbf3894d4083f33e07309d1f38;\\n /// @dev The address of the first contract `CREATE`d by a running test contract.\\n /// When running tests, each test contract is `CREATE`d by `DEFAULT_SENDER` with nonce 1.\\n /// Calculated as `VM.computeCreateAddress(VM.computeCreateAddress(DEFAULT_SENDER, 1), 1)`.\\n address internal constant DEFAULT_TEST_CONTRACT = 0x5615dEB798BB3E4dFa0139dFa1b3D433Cc23b72f;\\n /// @dev Deterministic deployment address of the Multicall3 contract.\\n /// Taken from https://www.multicall3.com.\\n IMulticall3 internal constant MULTICALL3_ADDRESS = IMulticall3(0xcA11bde05977b3631167028862bE2a173976CA11);\\n /// @dev The order of the secp256k1 curve.\\n uint256 internal constant SECP256K1_ORDER =\\n 115792089237316195423570985008687907852837564279074904382605163141518161494337;\\n}\\n\",\"keccak256\":\"0x319ccdabfa2c0b2428301445873270ffea20f0e039d4fd5e6eeba65158e4e534\",\"license\":\"MIT\"},\"lib/forge-std/src/StdJson.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity >=0.6.0 <0.9.0;\\n\\npragma experimental ABIEncoderV2;\\n\\nimport {VmSafe} from \\\"./Vm.sol\\\";\\n\\n// Helpers for parsing and writing JSON files\\n// To parse:\\n// ```\\n// using stdJson for string;\\n// string memory json = vm.readFile(\\\"\\\");\\n// json.readUint(\\\"\\\");\\n// ```\\n// To write:\\n// ```\\n// using stdJson for string;\\n// string memory json = \\\"json\\\";\\n// json.serialize(\\\"a\\\", uint256(123));\\n// string memory semiFinal = json.serialize(\\\"b\\\", string(\\\"test\\\"));\\n// string memory finalJson = json.serialize(\\\"c\\\", semiFinal);\\n// finalJson.write(\\\"\\\");\\n// ```\\n\\nlibrary stdJson {\\n VmSafe private constant vm = VmSafe(address(uint160(uint256(keccak256(\\\"hevm cheat code\\\")))));\\n\\n function keyExists(string memory json, string memory key) internal view returns (bool) {\\n return vm.keyExistsJson(json, key);\\n }\\n\\n function parseRaw(string memory json, string memory key) internal pure returns (bytes memory) {\\n return vm.parseJson(json, key);\\n }\\n\\n function readUint(string memory json, string memory key) internal pure returns (uint256) {\\n return vm.parseJsonUint(json, key);\\n }\\n\\n function readUintArray(string memory json, string memory key) internal pure returns (uint256[] memory) {\\n return vm.parseJsonUintArray(json, key);\\n }\\n\\n function readInt(string memory json, string memory key) internal pure returns (int256) {\\n return vm.parseJsonInt(json, key);\\n }\\n\\n function readIntArray(string memory json, string memory key) internal pure returns (int256[] memory) {\\n return vm.parseJsonIntArray(json, key);\\n }\\n\\n function readBytes32(string memory json, string memory key) internal pure returns (bytes32) {\\n return vm.parseJsonBytes32(json, key);\\n }\\n\\n function readBytes32Array(string memory json, string memory key) internal pure returns (bytes32[] memory) {\\n return vm.parseJsonBytes32Array(json, key);\\n }\\n\\n function readString(string memory json, string memory key) internal pure returns (string memory) {\\n return vm.parseJsonString(json, key);\\n }\\n\\n function readStringArray(string memory json, string memory key) internal pure returns (string[] memory) {\\n return vm.parseJsonStringArray(json, key);\\n }\\n\\n function readAddress(string memory json, string memory key) internal pure returns (address) {\\n return vm.parseJsonAddress(json, key);\\n }\\n\\n function readAddressArray(string memory json, string memory key) internal pure returns (address[] memory) {\\n return vm.parseJsonAddressArray(json, key);\\n }\\n\\n function readBool(string memory json, string memory key) internal pure returns (bool) {\\n return vm.parseJsonBool(json, key);\\n }\\n\\n function readBoolArray(string memory json, string memory key) internal pure returns (bool[] memory) {\\n return vm.parseJsonBoolArray(json, key);\\n }\\n\\n function readBytes(string memory json, string memory key) internal pure returns (bytes memory) {\\n return vm.parseJsonBytes(json, key);\\n }\\n\\n function readBytesArray(string memory json, string memory key) internal pure returns (bytes[] memory) {\\n return vm.parseJsonBytesArray(json, key);\\n }\\n\\n function readUintOr(string memory json, string memory key, uint256 defaultValue) internal view returns (uint256) {\\n return keyExists(json, key) ? readUint(json, key) : defaultValue;\\n }\\n\\n function readUintArrayOr(string memory json, string memory key, uint256[] memory defaultValue)\\n internal\\n view\\n returns (uint256[] memory)\\n {\\n return keyExists(json, key) ? readUintArray(json, key) : defaultValue;\\n }\\n\\n function readIntOr(string memory json, string memory key, int256 defaultValue) internal view returns (int256) {\\n return keyExists(json, key) ? readInt(json, key) : defaultValue;\\n }\\n\\n function readIntArrayOr(string memory json, string memory key, int256[] memory defaultValue)\\n internal\\n view\\n returns (int256[] memory)\\n {\\n return keyExists(json, key) ? readIntArray(json, key) : defaultValue;\\n }\\n\\n function readBytes32Or(string memory json, string memory key, bytes32 defaultValue)\\n internal\\n view\\n returns (bytes32)\\n {\\n return keyExists(json, key) ? readBytes32(json, key) : defaultValue;\\n }\\n\\n function readBytes32ArrayOr(string memory json, string memory key, bytes32[] memory defaultValue)\\n internal\\n view\\n returns (bytes32[] memory)\\n {\\n return keyExists(json, key) ? readBytes32Array(json, key) : defaultValue;\\n }\\n\\n function readStringOr(string memory json, string memory key, string memory defaultValue)\\n internal\\n view\\n returns (string memory)\\n {\\n return keyExists(json, key) ? readString(json, key) : defaultValue;\\n }\\n\\n function readStringArrayOr(string memory json, string memory key, string[] memory defaultValue)\\n internal\\n view\\n returns (string[] memory)\\n {\\n return keyExists(json, key) ? readStringArray(json, key) : defaultValue;\\n }\\n\\n function readAddressOr(string memory json, string memory key, address defaultValue)\\n internal\\n view\\n returns (address)\\n {\\n return keyExists(json, key) ? readAddress(json, key) : defaultValue;\\n }\\n\\n function readAddressArrayOr(string memory json, string memory key, address[] memory defaultValue)\\n internal\\n view\\n returns (address[] memory)\\n {\\n return keyExists(json, key) ? readAddressArray(json, key) : defaultValue;\\n }\\n\\n function readBoolOr(string memory json, string memory key, bool defaultValue) internal view returns (bool) {\\n return keyExists(json, key) ? readBool(json, key) : defaultValue;\\n }\\n\\n function readBoolArrayOr(string memory json, string memory key, bool[] memory defaultValue)\\n internal\\n view\\n returns (bool[] memory)\\n {\\n return keyExists(json, key) ? readBoolArray(json, key) : defaultValue;\\n }\\n\\n function readBytesOr(string memory json, string memory key, bytes memory defaultValue)\\n internal\\n view\\n returns (bytes memory)\\n {\\n return keyExists(json, key) ? readBytes(json, key) : defaultValue;\\n }\\n\\n function readBytesArrayOr(string memory json, string memory key, bytes[] memory defaultValue)\\n internal\\n view\\n returns (bytes[] memory)\\n {\\n return keyExists(json, key) ? readBytesArray(json, key) : defaultValue;\\n }\\n\\n function serialize(string memory jsonKey, string memory rootObject) internal returns (string memory) {\\n return vm.serializeJson(jsonKey, rootObject);\\n }\\n\\n function serialize(string memory jsonKey, string memory key, bool value) internal returns (string memory) {\\n return vm.serializeBool(jsonKey, key, value);\\n }\\n\\n function serialize(string memory jsonKey, string memory key, bool[] memory value)\\n internal\\n returns (string memory)\\n {\\n return vm.serializeBool(jsonKey, key, value);\\n }\\n\\n function serialize(string memory jsonKey, string memory key, uint256 value) internal returns (string memory) {\\n return vm.serializeUint(jsonKey, key, value);\\n }\\n\\n function serialize(string memory jsonKey, string memory key, uint256[] memory value)\\n internal\\n returns (string memory)\\n {\\n return vm.serializeUint(jsonKey, key, value);\\n }\\n\\n function serialize(string memory jsonKey, string memory key, int256 value) internal returns (string memory) {\\n return vm.serializeInt(jsonKey, key, value);\\n }\\n\\n function serialize(string memory jsonKey, string memory key, int256[] memory value)\\n internal\\n returns (string memory)\\n {\\n return vm.serializeInt(jsonKey, key, value);\\n }\\n\\n function serialize(string memory jsonKey, string memory key, address value) internal returns (string memory) {\\n return vm.serializeAddress(jsonKey, key, value);\\n }\\n\\n function serialize(string memory jsonKey, string memory key, address[] memory value)\\n internal\\n returns (string memory)\\n {\\n return vm.serializeAddress(jsonKey, key, value);\\n }\\n\\n function serialize(string memory jsonKey, string memory key, bytes32 value) internal returns (string memory) {\\n return vm.serializeBytes32(jsonKey, key, value);\\n }\\n\\n function serialize(string memory jsonKey, string memory key, bytes32[] memory value)\\n internal\\n returns (string memory)\\n {\\n return vm.serializeBytes32(jsonKey, key, value);\\n }\\n\\n function serialize(string memory jsonKey, string memory key, bytes memory value) internal returns (string memory) {\\n return vm.serializeBytes(jsonKey, key, value);\\n }\\n\\n function serialize(string memory jsonKey, string memory key, bytes[] memory value)\\n internal\\n returns (string memory)\\n {\\n return vm.serializeBytes(jsonKey, key, value);\\n }\\n\\n function serialize(string memory jsonKey, string memory key, string memory value)\\n internal\\n returns (string memory)\\n {\\n return vm.serializeString(jsonKey, key, value);\\n }\\n\\n function serialize(string memory jsonKey, string memory key, string[] memory value)\\n internal\\n returns (string memory)\\n {\\n return vm.serializeString(jsonKey, key, value);\\n }\\n\\n function write(string memory jsonKey, string memory path) internal {\\n vm.writeJson(jsonKey, path);\\n }\\n\\n function write(string memory jsonKey, string memory path, string memory valueKey) internal {\\n vm.writeJson(jsonKey, path, valueKey);\\n }\\n}\\n\",\"keccak256\":\"0xbc0132abe1c2accc2867c0f03667afffdf92f3e95a581bb03c9557eaa38ea500\",\"license\":\"MIT\"},\"lib/forge-std/src/StdMath.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity >=0.6.2 <0.9.0;\\n\\nlibrary stdMath {\\n int256 private constant INT256_MIN = -57896044618658097711785492504343953926634992332820282019728792003956564819968;\\n\\n function abs(int256 a) internal pure returns (uint256) {\\n // Required or it will fail when `a = type(int256).min`\\n if (a == INT256_MIN) {\\n return 57896044618658097711785492504343953926634992332820282019728792003956564819968;\\n }\\n\\n return uint256(a > 0 ? a : -a);\\n }\\n\\n function delta(uint256 a, uint256 b) internal pure returns (uint256) {\\n return a > b ? a - b : b - a;\\n }\\n\\n function delta(int256 a, int256 b) internal pure returns (uint256) {\\n // a and b are of the same sign\\n // this works thanks to two's complement, the left-most bit is the sign bit\\n if ((a ^ b) > -1) {\\n return delta(abs(a), abs(b));\\n }\\n\\n // a and b are of opposite signs\\n return abs(a) + abs(b);\\n }\\n\\n function percentDelta(uint256 a, uint256 b) internal pure returns (uint256) {\\n uint256 absDelta = delta(a, b);\\n\\n return absDelta * 1e18 / b;\\n }\\n\\n function percentDelta(int256 a, int256 b) internal pure returns (uint256) {\\n uint256 absDelta = delta(a, b);\\n uint256 absB = abs(b);\\n\\n return absDelta * 1e18 / absB;\\n }\\n}\\n\",\"keccak256\":\"0xd90ad4fd8aeaeb8929964e686e769fdedd5eded3fc3815df194a0ab9f91a3fb2\",\"license\":\"MIT\"},\"lib/forge-std/src/StdStorage.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity >=0.6.2 <0.9.0;\\n\\nimport {Vm} from \\\"./Vm.sol\\\";\\n\\nstruct FindData {\\n uint256 slot;\\n uint256 offsetLeft;\\n uint256 offsetRight;\\n bool found;\\n}\\n\\nstruct StdStorage {\\n mapping(address => mapping(bytes4 => mapping(bytes32 => FindData))) finds;\\n bytes32[] _keys;\\n bytes4 _sig;\\n uint256 _depth;\\n address _target;\\n bytes32 _set;\\n bool _enable_packed_slots;\\n bytes _calldata;\\n}\\n\\nlibrary stdStorageSafe {\\n event SlotFound(address who, bytes4 fsig, bytes32 keysHash, uint256 slot);\\n event WARNING_UninitedSlot(address who, uint256 slot);\\n\\n Vm private constant vm = Vm(address(uint160(uint256(keccak256(\\\"hevm cheat code\\\")))));\\n uint256 constant UINT256_MAX = 115792089237316195423570985008687907853269984665640564039457584007913129639935;\\n\\n function sigs(string memory sigStr) internal pure returns (bytes4) {\\n return bytes4(keccak256(bytes(sigStr)));\\n }\\n\\n function getCallParams(StdStorage storage self) internal view returns (bytes memory) {\\n if (self._calldata.length == 0) {\\n return flatten(self._keys);\\n } else {\\n return self._calldata;\\n }\\n }\\n\\n // Calls target contract with configured parameters\\n function callTarget(StdStorage storage self) internal view returns (bool, bytes32) {\\n bytes memory cald = abi.encodePacked(self._sig, getCallParams(self));\\n (bool success, bytes memory rdat) = self._target.staticcall(cald);\\n bytes32 result = bytesToBytes32(rdat, 32 * self._depth);\\n\\n return (success, result);\\n }\\n\\n // Tries mutating slot value to determine if the targeted value is stored in it.\\n // If current value is 0, then we are setting slot value to type(uint256).max\\n // Otherwise, we set it to 0. That way, return value should always be affected.\\n function checkSlotMutatesCall(StdStorage storage self, bytes32 slot) internal returns (bool) {\\n bytes32 prevSlotValue = vm.load(self._target, slot);\\n (bool success, bytes32 prevReturnValue) = callTarget(self);\\n\\n bytes32 testVal = prevReturnValue == bytes32(0) ? bytes32(UINT256_MAX) : bytes32(0);\\n vm.store(self._target, slot, testVal);\\n\\n (, bytes32 newReturnValue) = callTarget(self);\\n\\n vm.store(self._target, slot, prevSlotValue);\\n\\n return (success && (prevReturnValue != newReturnValue));\\n }\\n\\n // Tries setting one of the bits in slot to 1 until return value changes.\\n // Index of resulted bit is an offset packed slot has from left/right side\\n function findOffset(StdStorage storage self, bytes32 slot, bool left) internal returns (bool, uint256) {\\n for (uint256 offset = 0; offset < 256; offset++) {\\n uint256 valueToPut = left ? (1 << (255 - offset)) : (1 << offset);\\n vm.store(self._target, slot, bytes32(valueToPut));\\n\\n (bool success, bytes32 data) = callTarget(self);\\n\\n if (success && (uint256(data) > 0)) {\\n return (true, offset);\\n }\\n }\\n return (false, 0);\\n }\\n\\n function findOffsets(StdStorage storage self, bytes32 slot) internal returns (bool, uint256, uint256) {\\n bytes32 prevSlotValue = vm.load(self._target, slot);\\n\\n (bool foundLeft, uint256 offsetLeft) = findOffset(self, slot, true);\\n (bool foundRight, uint256 offsetRight) = findOffset(self, slot, false);\\n\\n // `findOffset` may mutate slot value, so we are setting it to initial value\\n vm.store(self._target, slot, prevSlotValue);\\n return (foundLeft && foundRight, offsetLeft, offsetRight);\\n }\\n\\n function find(StdStorage storage self) internal returns (FindData storage) {\\n return find(self, true);\\n }\\n\\n /// @notice find an arbitrary storage slot given a function sig, input data, address of the contract and a value to check against\\n // slot complexity:\\n // if flat, will be bytes32(uint256(uint));\\n // if map, will be keccak256(abi.encode(key, uint(slot)));\\n // if deep map, will be keccak256(abi.encode(key1, keccak256(abi.encode(key0, uint(slot)))));\\n // if map struct, will be bytes32(uint256(keccak256(abi.encode(key1, keccak256(abi.encode(key0, uint(slot)))))) + structFieldDepth);\\n function find(StdStorage storage self, bool _clear) internal returns (FindData storage) {\\n address who = self._target;\\n bytes4 fsig = self._sig;\\n uint256 field_depth = self._depth;\\n bytes memory params = getCallParams(self);\\n\\n // calldata to test against\\n if (self.finds[who][fsig][keccak256(abi.encodePacked(params, field_depth))].found) {\\n if (_clear) {\\n clear(self);\\n }\\n return self.finds[who][fsig][keccak256(abi.encodePacked(params, field_depth))];\\n }\\n vm.record();\\n (, bytes32 callResult) = callTarget(self);\\n (bytes32[] memory reads,) = vm.accesses(address(who));\\n\\n if (reads.length == 0) {\\n revert(\\\"stdStorage find(StdStorage): No storage use detected for target.\\\");\\n } else {\\n for (uint256 i = reads.length; --i >= 0;) {\\n bytes32 prev = vm.load(who, reads[i]);\\n if (prev == bytes32(0)) {\\n emit WARNING_UninitedSlot(who, uint256(reads[i]));\\n }\\n\\n if (!checkSlotMutatesCall(self, reads[i])) {\\n continue;\\n }\\n\\n (uint256 offsetLeft, uint256 offsetRight) = (0, 0);\\n\\n if (self._enable_packed_slots) {\\n bool found;\\n (found, offsetLeft, offsetRight) = findOffsets(self, reads[i]);\\n if (!found) {\\n continue;\\n }\\n }\\n\\n // Check that value between found offsets is equal to the current call result\\n uint256 curVal = (uint256(prev) & getMaskByOffsets(offsetLeft, offsetRight)) >> offsetRight;\\n\\n if (uint256(callResult) != curVal) {\\n continue;\\n }\\n\\n emit SlotFound(who, fsig, keccak256(abi.encodePacked(params, field_depth)), uint256(reads[i]));\\n self.finds[who][fsig][keccak256(abi.encodePacked(params, field_depth))] =\\n FindData(uint256(reads[i]), offsetLeft, offsetRight, true);\\n break;\\n }\\n }\\n\\n require(\\n self.finds[who][fsig][keccak256(abi.encodePacked(params, field_depth))].found,\\n \\\"stdStorage find(StdStorage): Slot(s) not found.\\\"\\n );\\n\\n if (_clear) {\\n clear(self);\\n }\\n return self.finds[who][fsig][keccak256(abi.encodePacked(params, field_depth))];\\n }\\n\\n function target(StdStorage storage self, address _target) internal returns (StdStorage storage) {\\n self._target = _target;\\n return self;\\n }\\n\\n function sig(StdStorage storage self, bytes4 _sig) internal returns (StdStorage storage) {\\n self._sig = _sig;\\n return self;\\n }\\n\\n function sig(StdStorage storage self, string memory _sig) internal returns (StdStorage storage) {\\n self._sig = sigs(_sig);\\n return self;\\n }\\n\\n function with_calldata(StdStorage storage self, bytes memory _calldata) internal returns (StdStorage storage) {\\n self._calldata = _calldata;\\n return self;\\n }\\n\\n function with_key(StdStorage storage self, address who) internal returns (StdStorage storage) {\\n self._keys.push(bytes32(uint256(uint160(who))));\\n return self;\\n }\\n\\n function with_key(StdStorage storage self, uint256 amt) internal returns (StdStorage storage) {\\n self._keys.push(bytes32(amt));\\n return self;\\n }\\n\\n function with_key(StdStorage storage self, bytes32 key) internal returns (StdStorage storage) {\\n self._keys.push(key);\\n return self;\\n }\\n\\n function enable_packed_slots(StdStorage storage self) internal returns (StdStorage storage) {\\n self._enable_packed_slots = true;\\n return self;\\n }\\n\\n function depth(StdStorage storage self, uint256 _depth) internal returns (StdStorage storage) {\\n self._depth = _depth;\\n return self;\\n }\\n\\n function read(StdStorage storage self) private returns (bytes memory) {\\n FindData storage data = find(self, false);\\n uint256 mask = getMaskByOffsets(data.offsetLeft, data.offsetRight);\\n uint256 value = (uint256(vm.load(self._target, bytes32(data.slot))) & mask) >> data.offsetRight;\\n clear(self);\\n return abi.encode(value);\\n }\\n\\n function read_bytes32(StdStorage storage self) internal returns (bytes32) {\\n return abi.decode(read(self), (bytes32));\\n }\\n\\n function read_bool(StdStorage storage self) internal returns (bool) {\\n int256 v = read_int(self);\\n if (v == 0) return false;\\n if (v == 1) return true;\\n revert(\\\"stdStorage read_bool(StdStorage): Cannot decode. Make sure you are reading a bool.\\\");\\n }\\n\\n function read_address(StdStorage storage self) internal returns (address) {\\n return abi.decode(read(self), (address));\\n }\\n\\n function read_uint(StdStorage storage self) internal returns (uint256) {\\n return abi.decode(read(self), (uint256));\\n }\\n\\n function read_int(StdStorage storage self) internal returns (int256) {\\n return abi.decode(read(self), (int256));\\n }\\n\\n function parent(StdStorage storage self) internal returns (uint256, bytes32) {\\n address who = self._target;\\n uint256 field_depth = self._depth;\\n vm.startMappingRecording();\\n uint256 child = find(self, true).slot - field_depth;\\n (bool found, bytes32 key, bytes32 parent_slot) = vm.getMappingKeyAndParentOf(who, bytes32(child));\\n if (!found) {\\n revert(\\n \\\"stdStorage read_bool(StdStorage): Cannot find parent. Make sure you give a slot and startMappingRecording() has been called.\\\"\\n );\\n }\\n return (uint256(parent_slot), key);\\n }\\n\\n function root(StdStorage storage self) internal returns (uint256) {\\n address who = self._target;\\n uint256 field_depth = self._depth;\\n vm.startMappingRecording();\\n uint256 child = find(self, true).slot - field_depth;\\n bool found;\\n bytes32 root_slot;\\n bytes32 parent_slot;\\n (found,, parent_slot) = vm.getMappingKeyAndParentOf(who, bytes32(child));\\n if (!found) {\\n revert(\\n \\\"stdStorage read_bool(StdStorage): Cannot find parent. Make sure you give a slot and startMappingRecording() has been called.\\\"\\n );\\n }\\n while (found) {\\n root_slot = parent_slot;\\n (found,, parent_slot) = vm.getMappingKeyAndParentOf(who, bytes32(root_slot));\\n }\\n return uint256(root_slot);\\n }\\n\\n function bytesToBytes32(bytes memory b, uint256 offset) private pure returns (bytes32) {\\n bytes32 out;\\n\\n uint256 max = b.length > 32 ? 32 : b.length;\\n for (uint256 i = 0; i < max; i++) {\\n out |= bytes32(b[offset + i] & 0xFF) >> (i * 8);\\n }\\n return out;\\n }\\n\\n function flatten(bytes32[] memory b) private pure returns (bytes memory) {\\n bytes memory result = new bytes(b.length * 32);\\n for (uint256 i = 0; i < b.length; i++) {\\n bytes32 k = b[i];\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(add(result, add(32, mul(32, i))), k)\\n }\\n }\\n\\n return result;\\n }\\n\\n function clear(StdStorage storage self) internal {\\n delete self._target;\\n delete self._sig;\\n delete self._keys;\\n delete self._depth;\\n delete self._enable_packed_slots;\\n delete self._calldata;\\n }\\n\\n // Returns mask which contains non-zero bits for values between `offsetLeft` and `offsetRight`\\n // (slotValue & mask) >> offsetRight will be the value of the given packed variable\\n function getMaskByOffsets(uint256 offsetLeft, uint256 offsetRight) internal pure returns (uint256 mask) {\\n // mask = ((1 << (256 - (offsetRight + offsetLeft))) - 1) << offsetRight;\\n // using assembly because (1 << 256) causes overflow\\n assembly {\\n mask := shl(offsetRight, sub(shl(sub(256, add(offsetRight, offsetLeft)), 1), 1))\\n }\\n }\\n\\n // Returns slot value with updated packed variable.\\n function getUpdatedSlotValue(bytes32 curValue, uint256 varValue, uint256 offsetLeft, uint256 offsetRight)\\n internal\\n pure\\n returns (bytes32 newValue)\\n {\\n return bytes32((uint256(curValue) & ~getMaskByOffsets(offsetLeft, offsetRight)) | (varValue << offsetRight));\\n }\\n}\\n\\nlibrary stdStorage {\\n Vm private constant vm = Vm(address(uint160(uint256(keccak256(\\\"hevm cheat code\\\")))));\\n\\n function sigs(string memory sigStr) internal pure returns (bytes4) {\\n return stdStorageSafe.sigs(sigStr);\\n }\\n\\n function find(StdStorage storage self) internal returns (uint256) {\\n return find(self, true);\\n }\\n\\n function find(StdStorage storage self, bool _clear) internal returns (uint256) {\\n return stdStorageSafe.find(self, _clear).slot;\\n }\\n\\n function target(StdStorage storage self, address _target) internal returns (StdStorage storage) {\\n return stdStorageSafe.target(self, _target);\\n }\\n\\n function sig(StdStorage storage self, bytes4 _sig) internal returns (StdStorage storage) {\\n return stdStorageSafe.sig(self, _sig);\\n }\\n\\n function sig(StdStorage storage self, string memory _sig) internal returns (StdStorage storage) {\\n return stdStorageSafe.sig(self, _sig);\\n }\\n\\n function with_key(StdStorage storage self, address who) internal returns (StdStorage storage) {\\n return stdStorageSafe.with_key(self, who);\\n }\\n\\n function with_key(StdStorage storage self, uint256 amt) internal returns (StdStorage storage) {\\n return stdStorageSafe.with_key(self, amt);\\n }\\n\\n function with_key(StdStorage storage self, bytes32 key) internal returns (StdStorage storage) {\\n return stdStorageSafe.with_key(self, key);\\n }\\n\\n function with_calldata(StdStorage storage self, bytes memory _calldata) internal returns (StdStorage storage) {\\n return stdStorageSafe.with_calldata(self, _calldata);\\n }\\n\\n function enable_packed_slots(StdStorage storage self) internal returns (StdStorage storage) {\\n return stdStorageSafe.enable_packed_slots(self);\\n }\\n\\n function depth(StdStorage storage self, uint256 _depth) internal returns (StdStorage storage) {\\n return stdStorageSafe.depth(self, _depth);\\n }\\n\\n function clear(StdStorage storage self) internal {\\n stdStorageSafe.clear(self);\\n }\\n\\n function checked_write(StdStorage storage self, address who) internal {\\n checked_write(self, bytes32(uint256(uint160(who))));\\n }\\n\\n function checked_write(StdStorage storage self, uint256 amt) internal {\\n checked_write(self, bytes32(amt));\\n }\\n\\n function checked_write_int(StdStorage storage self, int256 val) internal {\\n checked_write(self, bytes32(uint256(val)));\\n }\\n\\n function checked_write(StdStorage storage self, bool write) internal {\\n bytes32 t;\\n /// @solidity memory-safe-assembly\\n assembly {\\n t := write\\n }\\n checked_write(self, t);\\n }\\n\\n function checked_write(StdStorage storage self, bytes32 set) internal {\\n address who = self._target;\\n bytes4 fsig = self._sig;\\n uint256 field_depth = self._depth;\\n bytes memory params = stdStorageSafe.getCallParams(self);\\n\\n if (!self.finds[who][fsig][keccak256(abi.encodePacked(params, field_depth))].found) {\\n find(self, false);\\n }\\n FindData storage data = self.finds[who][fsig][keccak256(abi.encodePacked(params, field_depth))];\\n if ((data.offsetLeft + data.offsetRight) > 0) {\\n uint256 maxVal = 2 ** (256 - (data.offsetLeft + data.offsetRight));\\n require(\\n uint256(set) < maxVal,\\n string(\\n abi.encodePacked(\\n \\\"stdStorage find(StdStorage): Packed slot. We can't fit value greater than \\\",\\n vm.toString(maxVal)\\n )\\n )\\n );\\n }\\n bytes32 curVal = vm.load(who, bytes32(data.slot));\\n bytes32 valToSet = stdStorageSafe.getUpdatedSlotValue(curVal, uint256(set), data.offsetLeft, data.offsetRight);\\n\\n vm.store(who, bytes32(data.slot), valToSet);\\n\\n (bool success, bytes32 callResult) = stdStorageSafe.callTarget(self);\\n\\n if (!success || callResult != set) {\\n vm.store(who, bytes32(data.slot), curVal);\\n revert(\\\"stdStorage find(StdStorage): Failed to write value.\\\");\\n }\\n clear(self);\\n }\\n\\n function read_bytes32(StdStorage storage self) internal returns (bytes32) {\\n return stdStorageSafe.read_bytes32(self);\\n }\\n\\n function read_bool(StdStorage storage self) internal returns (bool) {\\n return stdStorageSafe.read_bool(self);\\n }\\n\\n function read_address(StdStorage storage self) internal returns (address) {\\n return stdStorageSafe.read_address(self);\\n }\\n\\n function read_uint(StdStorage storage self) internal returns (uint256) {\\n return stdStorageSafe.read_uint(self);\\n }\\n\\n function read_int(StdStorage storage self) internal returns (int256) {\\n return stdStorageSafe.read_int(self);\\n }\\n\\n function parent(StdStorage storage self) internal returns (uint256, bytes32) {\\n return stdStorageSafe.parent(self);\\n }\\n\\n function root(StdStorage storage self) internal returns (uint256) {\\n return stdStorageSafe.root(self);\\n }\\n}\\n\",\"keccak256\":\"0xb91ab24383a5872b894fc93325eef1add6cbbf981628f18e860068bf88bb7dcc\",\"license\":\"MIT\"},\"lib/forge-std/src/StdStyle.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity >=0.4.22 <0.9.0;\\n\\nimport {VmSafe} from \\\"./Vm.sol\\\";\\n\\nlibrary StdStyle {\\n VmSafe private constant vm = VmSafe(address(uint160(uint256(keccak256(\\\"hevm cheat code\\\")))));\\n\\n string constant RED = \\\"\\\\u001b[91m\\\";\\n string constant GREEN = \\\"\\\\u001b[92m\\\";\\n string constant YELLOW = \\\"\\\\u001b[93m\\\";\\n string constant BLUE = \\\"\\\\u001b[94m\\\";\\n string constant MAGENTA = \\\"\\\\u001b[95m\\\";\\n string constant CYAN = \\\"\\\\u001b[96m\\\";\\n string constant BOLD = \\\"\\\\u001b[1m\\\";\\n string constant DIM = \\\"\\\\u001b[2m\\\";\\n string constant ITALIC = \\\"\\\\u001b[3m\\\";\\n string constant UNDERLINE = \\\"\\\\u001b[4m\\\";\\n string constant INVERSE = \\\"\\\\u001b[7m\\\";\\n string constant RESET = \\\"\\\\u001b[0m\\\";\\n\\n function styleConcat(string memory style, string memory self) private pure returns (string memory) {\\n return string(abi.encodePacked(style, self, RESET));\\n }\\n\\n function red(string memory self) internal pure returns (string memory) {\\n return styleConcat(RED, self);\\n }\\n\\n function red(uint256 self) internal pure returns (string memory) {\\n return red(vm.toString(self));\\n }\\n\\n function red(int256 self) internal pure returns (string memory) {\\n return red(vm.toString(self));\\n }\\n\\n function red(address self) internal pure returns (string memory) {\\n return red(vm.toString(self));\\n }\\n\\n function red(bool self) internal pure returns (string memory) {\\n return red(vm.toString(self));\\n }\\n\\n function redBytes(bytes memory self) internal pure returns (string memory) {\\n return red(vm.toString(self));\\n }\\n\\n function redBytes32(bytes32 self) internal pure returns (string memory) {\\n return red(vm.toString(self));\\n }\\n\\n function green(string memory self) internal pure returns (string memory) {\\n return styleConcat(GREEN, self);\\n }\\n\\n function green(uint256 self) internal pure returns (string memory) {\\n return green(vm.toString(self));\\n }\\n\\n function green(int256 self) internal pure returns (string memory) {\\n return green(vm.toString(self));\\n }\\n\\n function green(address self) internal pure returns (string memory) {\\n return green(vm.toString(self));\\n }\\n\\n function green(bool self) internal pure returns (string memory) {\\n return green(vm.toString(self));\\n }\\n\\n function greenBytes(bytes memory self) internal pure returns (string memory) {\\n return green(vm.toString(self));\\n }\\n\\n function greenBytes32(bytes32 self) internal pure returns (string memory) {\\n return green(vm.toString(self));\\n }\\n\\n function yellow(string memory self) internal pure returns (string memory) {\\n return styleConcat(YELLOW, self);\\n }\\n\\n function yellow(uint256 self) internal pure returns (string memory) {\\n return yellow(vm.toString(self));\\n }\\n\\n function yellow(int256 self) internal pure returns (string memory) {\\n return yellow(vm.toString(self));\\n }\\n\\n function yellow(address self) internal pure returns (string memory) {\\n return yellow(vm.toString(self));\\n }\\n\\n function yellow(bool self) internal pure returns (string memory) {\\n return yellow(vm.toString(self));\\n }\\n\\n function yellowBytes(bytes memory self) internal pure returns (string memory) {\\n return yellow(vm.toString(self));\\n }\\n\\n function yellowBytes32(bytes32 self) internal pure returns (string memory) {\\n return yellow(vm.toString(self));\\n }\\n\\n function blue(string memory self) internal pure returns (string memory) {\\n return styleConcat(BLUE, self);\\n }\\n\\n function blue(uint256 self) internal pure returns (string memory) {\\n return blue(vm.toString(self));\\n }\\n\\n function blue(int256 self) internal pure returns (string memory) {\\n return blue(vm.toString(self));\\n }\\n\\n function blue(address self) internal pure returns (string memory) {\\n return blue(vm.toString(self));\\n }\\n\\n function blue(bool self) internal pure returns (string memory) {\\n return blue(vm.toString(self));\\n }\\n\\n function blueBytes(bytes memory self) internal pure returns (string memory) {\\n return blue(vm.toString(self));\\n }\\n\\n function blueBytes32(bytes32 self) internal pure returns (string memory) {\\n return blue(vm.toString(self));\\n }\\n\\n function magenta(string memory self) internal pure returns (string memory) {\\n return styleConcat(MAGENTA, self);\\n }\\n\\n function magenta(uint256 self) internal pure returns (string memory) {\\n return magenta(vm.toString(self));\\n }\\n\\n function magenta(int256 self) internal pure returns (string memory) {\\n return magenta(vm.toString(self));\\n }\\n\\n function magenta(address self) internal pure returns (string memory) {\\n return magenta(vm.toString(self));\\n }\\n\\n function magenta(bool self) internal pure returns (string memory) {\\n return magenta(vm.toString(self));\\n }\\n\\n function magentaBytes(bytes memory self) internal pure returns (string memory) {\\n return magenta(vm.toString(self));\\n }\\n\\n function magentaBytes32(bytes32 self) internal pure returns (string memory) {\\n return magenta(vm.toString(self));\\n }\\n\\n function cyan(string memory self) internal pure returns (string memory) {\\n return styleConcat(CYAN, self);\\n }\\n\\n function cyan(uint256 self) internal pure returns (string memory) {\\n return cyan(vm.toString(self));\\n }\\n\\n function cyan(int256 self) internal pure returns (string memory) {\\n return cyan(vm.toString(self));\\n }\\n\\n function cyan(address self) internal pure returns (string memory) {\\n return cyan(vm.toString(self));\\n }\\n\\n function cyan(bool self) internal pure returns (string memory) {\\n return cyan(vm.toString(self));\\n }\\n\\n function cyanBytes(bytes memory self) internal pure returns (string memory) {\\n return cyan(vm.toString(self));\\n }\\n\\n function cyanBytes32(bytes32 self) internal pure returns (string memory) {\\n return cyan(vm.toString(self));\\n }\\n\\n function bold(string memory self) internal pure returns (string memory) {\\n return styleConcat(BOLD, self);\\n }\\n\\n function bold(uint256 self) internal pure returns (string memory) {\\n return bold(vm.toString(self));\\n }\\n\\n function bold(int256 self) internal pure returns (string memory) {\\n return bold(vm.toString(self));\\n }\\n\\n function bold(address self) internal pure returns (string memory) {\\n return bold(vm.toString(self));\\n }\\n\\n function bold(bool self) internal pure returns (string memory) {\\n return bold(vm.toString(self));\\n }\\n\\n function boldBytes(bytes memory self) internal pure returns (string memory) {\\n return bold(vm.toString(self));\\n }\\n\\n function boldBytes32(bytes32 self) internal pure returns (string memory) {\\n return bold(vm.toString(self));\\n }\\n\\n function dim(string memory self) internal pure returns (string memory) {\\n return styleConcat(DIM, self);\\n }\\n\\n function dim(uint256 self) internal pure returns (string memory) {\\n return dim(vm.toString(self));\\n }\\n\\n function dim(int256 self) internal pure returns (string memory) {\\n return dim(vm.toString(self));\\n }\\n\\n function dim(address self) internal pure returns (string memory) {\\n return dim(vm.toString(self));\\n }\\n\\n function dim(bool self) internal pure returns (string memory) {\\n return dim(vm.toString(self));\\n }\\n\\n function dimBytes(bytes memory self) internal pure returns (string memory) {\\n return dim(vm.toString(self));\\n }\\n\\n function dimBytes32(bytes32 self) internal pure returns (string memory) {\\n return dim(vm.toString(self));\\n }\\n\\n function italic(string memory self) internal pure returns (string memory) {\\n return styleConcat(ITALIC, self);\\n }\\n\\n function italic(uint256 self) internal pure returns (string memory) {\\n return italic(vm.toString(self));\\n }\\n\\n function italic(int256 self) internal pure returns (string memory) {\\n return italic(vm.toString(self));\\n }\\n\\n function italic(address self) internal pure returns (string memory) {\\n return italic(vm.toString(self));\\n }\\n\\n function italic(bool self) internal pure returns (string memory) {\\n return italic(vm.toString(self));\\n }\\n\\n function italicBytes(bytes memory self) internal pure returns (string memory) {\\n return italic(vm.toString(self));\\n }\\n\\n function italicBytes32(bytes32 self) internal pure returns (string memory) {\\n return italic(vm.toString(self));\\n }\\n\\n function underline(string memory self) internal pure returns (string memory) {\\n return styleConcat(UNDERLINE, self);\\n }\\n\\n function underline(uint256 self) internal pure returns (string memory) {\\n return underline(vm.toString(self));\\n }\\n\\n function underline(int256 self) internal pure returns (string memory) {\\n return underline(vm.toString(self));\\n }\\n\\n function underline(address self) internal pure returns (string memory) {\\n return underline(vm.toString(self));\\n }\\n\\n function underline(bool self) internal pure returns (string memory) {\\n return underline(vm.toString(self));\\n }\\n\\n function underlineBytes(bytes memory self) internal pure returns (string memory) {\\n return underline(vm.toString(self));\\n }\\n\\n function underlineBytes32(bytes32 self) internal pure returns (string memory) {\\n return underline(vm.toString(self));\\n }\\n\\n function inverse(string memory self) internal pure returns (string memory) {\\n return styleConcat(INVERSE, self);\\n }\\n\\n function inverse(uint256 self) internal pure returns (string memory) {\\n return inverse(vm.toString(self));\\n }\\n\\n function inverse(int256 self) internal pure returns (string memory) {\\n return inverse(vm.toString(self));\\n }\\n\\n function inverse(address self) internal pure returns (string memory) {\\n return inverse(vm.toString(self));\\n }\\n\\n function inverse(bool self) internal pure returns (string memory) {\\n return inverse(vm.toString(self));\\n }\\n\\n function inverseBytes(bytes memory self) internal pure returns (string memory) {\\n return inverse(vm.toString(self));\\n }\\n\\n function inverseBytes32(bytes32 self) internal pure returns (string memory) {\\n return inverse(vm.toString(self));\\n }\\n}\\n\",\"keccak256\":\"0x43e2a8a9b9c2574dabe74f11adf6f782df218f463540e3b5b563609fe108597d\",\"license\":\"MIT\"},\"lib/forge-std/src/StdUtils.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity >=0.6.2 <0.9.0;\\n\\npragma experimental ABIEncoderV2;\\n\\nimport {IMulticall3} from \\\"./interfaces/IMulticall3.sol\\\";\\nimport {VmSafe} from \\\"./Vm.sol\\\";\\n\\nabstract contract StdUtils {\\n /*//////////////////////////////////////////////////////////////////////////\\n CONSTANTS\\n //////////////////////////////////////////////////////////////////////////*/\\n\\n IMulticall3 private constant multicall = IMulticall3(0xcA11bde05977b3631167028862bE2a173976CA11);\\n VmSafe private constant vm = VmSafe(address(uint160(uint256(keccak256(\\\"hevm cheat code\\\")))));\\n address private constant CONSOLE2_ADDRESS = 0x000000000000000000636F6e736F6c652e6c6f67;\\n uint256 private constant INT256_MIN_ABS =\\n 57896044618658097711785492504343953926634992332820282019728792003956564819968;\\n uint256 private constant SECP256K1_ORDER =\\n 115792089237316195423570985008687907852837564279074904382605163141518161494337;\\n uint256 private constant UINT256_MAX =\\n 115792089237316195423570985008687907853269984665640564039457584007913129639935;\\n\\n // Used by default when deploying with create2, https://github.com/Arachnid/deterministic-deployment-proxy.\\n address private constant CREATE2_FACTORY = 0x4e59b44847b379578588920cA78FbF26c0B4956C;\\n\\n /*//////////////////////////////////////////////////////////////////////////\\n INTERNAL FUNCTIONS\\n //////////////////////////////////////////////////////////////////////////*/\\n\\n function _bound(uint256 x, uint256 min, uint256 max) internal pure virtual returns (uint256 result) {\\n require(min <= max, \\\"StdUtils bound(uint256,uint256,uint256): Max is less than min.\\\");\\n // If x is between min and max, return x directly. This is to ensure that dictionary values\\n // do not get shifted if the min is nonzero. More info: https://github.com/foundry-rs/forge-std/issues/188\\n if (x >= min && x <= max) return x;\\n\\n uint256 size = max - min + 1;\\n\\n // If the value is 0, 1, 2, 3, wrap that to min, min+1, min+2, min+3. Similarly for the UINT256_MAX side.\\n // This helps ensure coverage of the min/max values.\\n if (x <= 3 && size > x) return min + x;\\n if (x >= UINT256_MAX - 3 && size > UINT256_MAX - x) return max - (UINT256_MAX - x);\\n\\n // Otherwise, wrap x into the range [min, max], i.e. the range is inclusive.\\n if (x > max) {\\n uint256 diff = x - max;\\n uint256 rem = diff % size;\\n if (rem == 0) return max;\\n result = min + rem - 1;\\n } else if (x < min) {\\n uint256 diff = min - x;\\n uint256 rem = diff % size;\\n if (rem == 0) return min;\\n result = max - rem + 1;\\n }\\n }\\n\\n function bound(uint256 x, uint256 min, uint256 max) internal pure virtual returns (uint256 result) {\\n result = _bound(x, min, max);\\n console2_log_StdUtils(\\\"Bound result\\\", result);\\n }\\n\\n function _bound(int256 x, int256 min, int256 max) internal pure virtual returns (int256 result) {\\n require(min <= max, \\\"StdUtils bound(int256,int256,int256): Max is less than min.\\\");\\n\\n // Shifting all int256 values to uint256 to use _bound function. The range of two types are:\\n // int256 : -(2**255) ~ (2**255 - 1)\\n // uint256: 0 ~ (2**256 - 1)\\n // So, add 2**255, INT256_MIN_ABS to the integer values.\\n //\\n // If the given integer value is -2**255, we cannot use `-uint256(-x)` because of the overflow.\\n // So, use `~uint256(x) + 1` instead.\\n uint256 _x = x < 0 ? (INT256_MIN_ABS - ~uint256(x) - 1) : (uint256(x) + INT256_MIN_ABS);\\n uint256 _min = min < 0 ? (INT256_MIN_ABS - ~uint256(min) - 1) : (uint256(min) + INT256_MIN_ABS);\\n uint256 _max = max < 0 ? (INT256_MIN_ABS - ~uint256(max) - 1) : (uint256(max) + INT256_MIN_ABS);\\n\\n uint256 y = _bound(_x, _min, _max);\\n\\n // To move it back to int256 value, subtract INT256_MIN_ABS at here.\\n result = y < INT256_MIN_ABS ? int256(~(INT256_MIN_ABS - y) + 1) : int256(y - INT256_MIN_ABS);\\n }\\n\\n function bound(int256 x, int256 min, int256 max) internal pure virtual returns (int256 result) {\\n result = _bound(x, min, max);\\n console2_log_StdUtils(\\\"Bound result\\\", vm.toString(result));\\n }\\n\\n function boundPrivateKey(uint256 privateKey) internal pure virtual returns (uint256 result) {\\n result = _bound(privateKey, 1, SECP256K1_ORDER - 1);\\n }\\n\\n function bytesToUint(bytes memory b) internal pure virtual returns (uint256) {\\n require(b.length <= 32, \\\"StdUtils bytesToUint(bytes): Bytes length exceeds 32.\\\");\\n return abi.decode(abi.encodePacked(new bytes(32 - b.length), b), (uint256));\\n }\\n\\n /// @dev Compute the address a contract will be deployed at for a given deployer address and nonce\\n /// @notice adapted from Solmate implementation (https://github.com/Rari-Capital/solmate/blob/main/src/utils/LibRLP.sol)\\n function computeCreateAddress(address deployer, uint256 nonce) internal pure virtual returns (address) {\\n console2_log_StdUtils(\\\"computeCreateAddress is deprecated. Please use vm.computeCreateAddress instead.\\\");\\n return vm.computeCreateAddress(deployer, nonce);\\n }\\n\\n function computeCreate2Address(bytes32 salt, bytes32 initcodeHash, address deployer)\\n internal\\n pure\\n virtual\\n returns (address)\\n {\\n console2_log_StdUtils(\\\"computeCreate2Address is deprecated. Please use vm.computeCreate2Address instead.\\\");\\n return vm.computeCreate2Address(salt, initcodeHash, deployer);\\n }\\n\\n /// @dev returns the address of a contract created with CREATE2 using the default CREATE2 deployer\\n function computeCreate2Address(bytes32 salt, bytes32 initCodeHash) internal pure returns (address) {\\n console2_log_StdUtils(\\\"computeCreate2Address is deprecated. Please use vm.computeCreate2Address instead.\\\");\\n return vm.computeCreate2Address(salt, initCodeHash);\\n }\\n\\n /// @dev returns the hash of the init code (creation code + no args) used in CREATE2 with no constructor arguments\\n /// @param creationCode the creation code of a contract C, as returned by type(C).creationCode\\n function hashInitCode(bytes memory creationCode) internal pure returns (bytes32) {\\n return hashInitCode(creationCode, \\\"\\\");\\n }\\n\\n /// @dev returns the hash of the init code (creation code + ABI-encoded args) used in CREATE2\\n /// @param creationCode the creation code of a contract C, as returned by type(C).creationCode\\n /// @param args the ABI-encoded arguments to the constructor of C\\n function hashInitCode(bytes memory creationCode, bytes memory args) internal pure returns (bytes32) {\\n return keccak256(abi.encodePacked(creationCode, args));\\n }\\n\\n // Performs a single call with Multicall3 to query the ERC-20 token balances of the given addresses.\\n function getTokenBalances(address token, address[] memory addresses)\\n internal\\n virtual\\n returns (uint256[] memory balances)\\n {\\n uint256 tokenCodeSize;\\n assembly {\\n tokenCodeSize := extcodesize(token)\\n }\\n require(tokenCodeSize > 0, \\\"StdUtils getTokenBalances(address,address[]): Token address is not a contract.\\\");\\n\\n // ABI encode the aggregate call to Multicall3.\\n uint256 length = addresses.length;\\n IMulticall3.Call[] memory calls = new IMulticall3.Call[](length);\\n for (uint256 i = 0; i < length; ++i) {\\n // 0x70a08231 = bytes4(\\\"balanceOf(address)\\\"))\\n calls[i] = IMulticall3.Call({target: token, callData: abi.encodeWithSelector(0x70a08231, (addresses[i]))});\\n }\\n\\n // Make the aggregate call.\\n (, bytes[] memory returnData) = multicall.aggregate(calls);\\n\\n // ABI decode the return data and return the balances.\\n balances = new uint256[](length);\\n for (uint256 i = 0; i < length; ++i) {\\n balances[i] = abi.decode(returnData[i], (uint256));\\n }\\n }\\n\\n /*//////////////////////////////////////////////////////////////////////////\\n PRIVATE FUNCTIONS\\n //////////////////////////////////////////////////////////////////////////*/\\n\\n function addressFromLast20Bytes(bytes32 bytesValue) private pure returns (address) {\\n return address(uint160(uint256(bytesValue)));\\n }\\n\\n // This section is used to prevent the compilation of console, which shortens the compilation time when console is\\n // not used elsewhere. We also trick the compiler into letting us make the console log methods as `pure` to avoid\\n // any breaking changes to function signatures.\\n function _castLogPayloadViewToPure(function(bytes memory) internal view fnIn)\\n internal\\n pure\\n returns (function(bytes memory) internal pure fnOut)\\n {\\n assembly {\\n fnOut := fnIn\\n }\\n }\\n\\n function _sendLogPayload(bytes memory payload) internal pure {\\n _castLogPayloadViewToPure(_sendLogPayloadView)(payload);\\n }\\n\\n function _sendLogPayloadView(bytes memory payload) private view {\\n uint256 payloadLength = payload.length;\\n address consoleAddress = CONSOLE2_ADDRESS;\\n /// @solidity memory-safe-assembly\\n assembly {\\n let payloadStart := add(payload, 32)\\n let r := staticcall(gas(), consoleAddress, payloadStart, payloadLength, 0, 0)\\n }\\n }\\n\\n function console2_log_StdUtils(string memory p0) private pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string)\\\", p0));\\n }\\n\\n function console2_log_StdUtils(string memory p0, uint256 p1) private pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,uint256)\\\", p0, p1));\\n }\\n\\n function console2_log_StdUtils(string memory p0, string memory p1) private pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,string)\\\", p0, p1));\\n }\\n}\\n\",\"keccak256\":\"0x7274081e11c05164fd8eadde4de8305c033e58a43008dea58065f3170ccf0737\",\"license\":\"MIT\"},\"lib/forge-std/src/Vm.sol\":{\"content\":\"// Automatically @generated by scripts/vm.py. Do not modify manually.\\n\\n// SPDX-License-Identifier: MIT OR Apache-2.0\\npragma solidity >=0.6.2 <0.9.0;\\npragma experimental ABIEncoderV2;\\n\\n/// The `VmSafe` interface does not allow manipulation of the EVM state or other actions that may\\n/// result in Script simulations differing from on-chain execution. It is recommended to only use\\n/// these cheats in scripts.\\ninterface VmSafe {\\n /// A modification applied to either `msg.sender` or `tx.origin`. Returned by `readCallers`.\\n enum CallerMode {\\n // No caller modification is currently active.\\n None,\\n // A one time broadcast triggered by a `vm.broadcast()` call is currently active.\\n Broadcast,\\n // A recurrent broadcast triggered by a `vm.startBroadcast()` call is currently active.\\n RecurrentBroadcast,\\n // A one time prank triggered by a `vm.prank()` call is currently active.\\n Prank,\\n // A recurrent prank triggered by a `vm.startPrank()` call is currently active.\\n RecurrentPrank\\n }\\n\\n /// The kind of account access that occurred.\\n enum AccountAccessKind {\\n // The account was called.\\n Call,\\n // The account was called via delegatecall.\\n DelegateCall,\\n // The account was called via callcode.\\n CallCode,\\n // The account was called via staticcall.\\n StaticCall,\\n // The account was created.\\n Create,\\n // The account was selfdestructed.\\n SelfDestruct,\\n // Synthetic access indicating the current context has resumed after a previous sub-context (AccountAccess).\\n Resume,\\n // The account's balance was read.\\n Balance,\\n // The account's codesize was read.\\n Extcodesize,\\n // The account's codehash was read.\\n Extcodehash,\\n // The account's code was copied.\\n Extcodecopy\\n }\\n\\n /// Forge execution contexts.\\n enum ForgeContext {\\n // Test group execution context (test, coverage or snapshot).\\n TestGroup,\\n // `forge test` execution context.\\n Test,\\n // `forge coverage` execution context.\\n Coverage,\\n // `forge snapshot` execution context.\\n Snapshot,\\n // Script group execution context (dry run, broadcast or resume).\\n ScriptGroup,\\n // `forge script` execution context.\\n ScriptDryRun,\\n // `forge script --broadcast` execution context.\\n ScriptBroadcast,\\n // `forge script --resume` execution context.\\n ScriptResume,\\n // Unknown `forge` execution context.\\n Unknown\\n }\\n\\n /// The transaction type (`txType`) of the broadcast.\\n enum BroadcastTxType {\\n // Represents a CALL broadcast tx.\\n Call,\\n // Represents a CREATE broadcast tx.\\n Create,\\n // Represents a CREATE2 broadcast tx.\\n Create2\\n }\\n\\n /// An Ethereum log. Returned by `getRecordedLogs`.\\n struct Log {\\n // The topics of the log, including the signature, if any.\\n bytes32[] topics;\\n // The raw data of the log.\\n bytes data;\\n // The address of the log's emitter.\\n address emitter;\\n }\\n\\n /// An RPC URL and its alias. Returned by `rpcUrlStructs`.\\n struct Rpc {\\n // The alias of the RPC URL.\\n string key;\\n // The RPC URL.\\n string url;\\n }\\n\\n /// An RPC log object. Returned by `eth_getLogs`.\\n struct EthGetLogs {\\n // The address of the log's emitter.\\n address emitter;\\n // The topics of the log, including the signature, if any.\\n bytes32[] topics;\\n // The raw data of the log.\\n bytes data;\\n // The block hash.\\n bytes32 blockHash;\\n // The block number.\\n uint64 blockNumber;\\n // The transaction hash.\\n bytes32 transactionHash;\\n // The transaction index in the block.\\n uint64 transactionIndex;\\n // The log index.\\n uint256 logIndex;\\n // Whether the log was removed.\\n bool removed;\\n }\\n\\n /// A single entry in a directory listing. Returned by `readDir`.\\n struct DirEntry {\\n // The error message, if any.\\n string errorMessage;\\n // The path of the entry.\\n string path;\\n // The depth of the entry.\\n uint64 depth;\\n // Whether the entry is a directory.\\n bool isDir;\\n // Whether the entry is a symlink.\\n bool isSymlink;\\n }\\n\\n /// Metadata information about a file.\\n /// This structure is returned from the `fsMetadata` function and represents known\\n /// metadata about a file such as its permissions, size, modification\\n /// times, etc.\\n struct FsMetadata {\\n // True if this metadata is for a directory.\\n bool isDir;\\n // True if this metadata is for a symlink.\\n bool isSymlink;\\n // The size of the file, in bytes, this metadata is for.\\n uint256 length;\\n // True if this metadata is for a readonly (unwritable) file.\\n bool readOnly;\\n // The last modification time listed in this metadata.\\n uint256 modified;\\n // The last access time of this metadata.\\n uint256 accessed;\\n // The creation time listed in this metadata.\\n uint256 created;\\n }\\n\\n /// A wallet with a public and private key.\\n struct Wallet {\\n // The wallet's address.\\n address addr;\\n // The wallet's public key `X`.\\n uint256 publicKeyX;\\n // The wallet's public key `Y`.\\n uint256 publicKeyY;\\n // The wallet's private key.\\n uint256 privateKey;\\n }\\n\\n /// The result of a `tryFfi` call.\\n struct FfiResult {\\n // The exit code of the call.\\n int32 exitCode;\\n // The optionally hex-decoded `stdout` data.\\n bytes stdout;\\n // The `stderr` data.\\n bytes stderr;\\n }\\n\\n /// Information on the chain and fork.\\n struct ChainInfo {\\n // The fork identifier. Set to zero if no fork is active.\\n uint256 forkId;\\n // The chain ID of the current fork.\\n uint256 chainId;\\n }\\n\\n /// The result of a `stopAndReturnStateDiff` call.\\n struct AccountAccess {\\n // The chain and fork the access occurred.\\n ChainInfo chainInfo;\\n // The kind of account access that determines what the account is.\\n // If kind is Call, DelegateCall, StaticCall or CallCode, then the account is the callee.\\n // If kind is Create, then the account is the newly created account.\\n // If kind is SelfDestruct, then the account is the selfdestruct recipient.\\n // If kind is a Resume, then account represents a account context that has resumed.\\n AccountAccessKind kind;\\n // The account that was accessed.\\n // It's either the account created, callee or a selfdestruct recipient for CREATE, CALL or SELFDESTRUCT.\\n address account;\\n // What accessed the account.\\n address accessor;\\n // If the account was initialized or empty prior to the access.\\n // An account is considered initialized if it has code, a\\n // non-zero nonce, or a non-zero balance.\\n bool initialized;\\n // The previous balance of the accessed account.\\n uint256 oldBalance;\\n // The potential new balance of the accessed account.\\n // That is, all balance changes are recorded here, even if reverts occurred.\\n uint256 newBalance;\\n // Code of the account deployed by CREATE.\\n bytes deployedCode;\\n // Value passed along with the account access\\n uint256 value;\\n // Input data provided to the CREATE or CALL\\n bytes data;\\n // If this access reverted in either the current or parent context.\\n bool reverted;\\n // An ordered list of storage accesses made during an account access operation.\\n StorageAccess[] storageAccesses;\\n // Call depth traversed during the recording of state differences\\n uint64 depth;\\n }\\n\\n /// The storage accessed during an `AccountAccess`.\\n struct StorageAccess {\\n // The account whose storage was accessed.\\n address account;\\n // The slot that was accessed.\\n bytes32 slot;\\n // If the access was a write.\\n bool isWrite;\\n // The previous value of the slot.\\n bytes32 previousValue;\\n // The new value of the slot.\\n bytes32 newValue;\\n // If the access was reverted.\\n bool reverted;\\n }\\n\\n /// Gas used. Returned by `lastCallGas`.\\n struct Gas {\\n // The gas limit of the call.\\n uint64 gasLimit;\\n // The total gas used.\\n uint64 gasTotalUsed;\\n // DEPRECATED: The amount of gas used for memory expansion. Ref: \\n uint64 gasMemoryUsed;\\n // The amount of gas refunded.\\n int64 gasRefunded;\\n // The amount of gas remaining.\\n uint64 gasRemaining;\\n }\\n\\n /// The result of the `stopDebugTraceRecording` call\\n struct DebugStep {\\n // The stack before executing the step of the run.\\n // stack\\\\[0\\\\] represents the top of the stack.\\n // and only stack data relevant to the opcode execution is contained.\\n uint256[] stack;\\n // The memory input data before executing the step of the run.\\n // only input data relevant to the opcode execution is contained.\\n // e.g. for MLOAD, it will have memory\\\\[offset:offset+32\\\\] copied here.\\n // the offset value can be get by the stack data.\\n bytes memoryInput;\\n // The opcode that was accessed.\\n uint8 opcode;\\n // The call depth of the step.\\n uint64 depth;\\n // Whether the call end up with out of gas error.\\n bool isOutOfGas;\\n // The contract address where the opcode is running\\n address contractAddr;\\n }\\n\\n /// Represents a transaction's broadcast details.\\n struct BroadcastTxSummary {\\n // The hash of the transaction that was broadcasted\\n bytes32 txHash;\\n // Represent the type of transaction among CALL, CREATE, CREATE2\\n BroadcastTxType txType;\\n // The address of the contract that was called or created.\\n // This is address of the contract that is created if the txType is CREATE or CREATE2.\\n address contractAddress;\\n // The block number the transaction landed in.\\n uint64 blockNumber;\\n // Status of the transaction, retrieved from the transaction receipt.\\n bool success;\\n }\\n\\n /// Holds a signed EIP-7702 authorization for an authority account to delegate to an implementation.\\n struct SignedDelegation {\\n // The y-parity of the recovered secp256k1 signature (0 or 1).\\n uint8 v;\\n // First 32 bytes of the signature.\\n bytes32 r;\\n // Second 32 bytes of the signature.\\n bytes32 s;\\n // The current nonce of the authority account at signing time.\\n // Used to ensure signature can't be replayed after account nonce changes.\\n uint64 nonce;\\n // Address of the contract implementation that will be delegated to.\\n // Gets encoded into delegation code: 0xef0100 || implementation.\\n address implementation;\\n }\\n\\n /// Represents a \\\"potential\\\" revert reason from a single subsequent call when using `vm.assumeNoReverts`.\\n /// Reverts that match will result in a FOUNDRY::ASSUME rejection, whereas unmatched reverts will be surfaced\\n /// as normal.\\n struct PotentialRevert {\\n // The allowed origin of the revert opcode; address(0) allows reverts from any address\\n address reverter;\\n // When true, only matches on the beginning of the revert data, otherwise, matches on entire revert data\\n bool partialMatch;\\n // The data to use to match encountered reverts\\n bytes revertData;\\n }\\n\\n /// An EIP-2930 access list item.\\n struct AccessListItem {\\n // The address to be added in access list.\\n address target;\\n // The storage keys to be added in access list.\\n bytes32[] storageKeys;\\n }\\n\\n // ======== Crypto ========\\n\\n /// Derives a private key from the name, labels the account with that name, and returns the wallet.\\n function createWallet(string calldata walletLabel) external returns (Wallet memory wallet);\\n\\n /// Generates a wallet from the private key and returns the wallet.\\n function createWallet(uint256 privateKey) external returns (Wallet memory wallet);\\n\\n /// Generates a wallet from the private key, labels the account with that name, and returns the wallet.\\n function createWallet(uint256 privateKey, string calldata walletLabel) external returns (Wallet memory wallet);\\n\\n /// Derive a private key from a provided mnenomic string (or mnenomic file path)\\n /// at the derivation path `m/44'/60'/0'/0/{index}`.\\n function deriveKey(string calldata mnemonic, uint32 index) external pure returns (uint256 privateKey);\\n\\n /// Derive a private key from a provided mnenomic string (or mnenomic file path)\\n /// at `{derivationPath}{index}`.\\n function deriveKey(string calldata mnemonic, string calldata derivationPath, uint32 index)\\n external\\n pure\\n returns (uint256 privateKey);\\n\\n /// Derive a private key from a provided mnenomic string (or mnenomic file path) in the specified language\\n /// at the derivation path `m/44'/60'/0'/0/{index}`.\\n function deriveKey(string calldata mnemonic, uint32 index, string calldata language)\\n external\\n pure\\n returns (uint256 privateKey);\\n\\n /// Derive a private key from a provided mnenomic string (or mnenomic file path) in the specified language\\n /// at `{derivationPath}{index}`.\\n function deriveKey(string calldata mnemonic, string calldata derivationPath, uint32 index, string calldata language)\\n external\\n pure\\n returns (uint256 privateKey);\\n\\n /// Derives secp256r1 public key from the provided `privateKey`.\\n function publicKeyP256(uint256 privateKey) external pure returns (uint256 publicKeyX, uint256 publicKeyY);\\n\\n /// Adds a private key to the local forge wallet and returns the address.\\n function rememberKey(uint256 privateKey) external returns (address keyAddr);\\n\\n /// Derive a set number of wallets from a mnemonic at the derivation path `m/44'/60'/0'/0/{0..count}`.\\n /// The respective private keys are saved to the local forge wallet for later use and their addresses are returned.\\n function rememberKeys(string calldata mnemonic, string calldata derivationPath, uint32 count)\\n external\\n returns (address[] memory keyAddrs);\\n\\n /// Derive a set number of wallets from a mnemonic in the specified language at the derivation path `m/44'/60'/0'/0/{0..count}`.\\n /// The respective private keys are saved to the local forge wallet for later use and their addresses are returned.\\n function rememberKeys(\\n string calldata mnemonic,\\n string calldata derivationPath,\\n string calldata language,\\n uint32 count\\n ) external returns (address[] memory keyAddrs);\\n\\n /// Signs data with a `Wallet`.\\n /// Returns a compact signature (`r`, `vs`) as per EIP-2098, where `vs` encodes both the\\n /// signature's `s` value, and the recovery id `v` in a single bytes32.\\n /// This format reduces the signature size from 65 to 64 bytes.\\n function signCompact(Wallet calldata wallet, bytes32 digest) external returns (bytes32 r, bytes32 vs);\\n\\n /// Signs `digest` with `privateKey` using the secp256k1 curve.\\n /// Returns a compact signature (`r`, `vs`) as per EIP-2098, where `vs` encodes both the\\n /// signature's `s` value, and the recovery id `v` in a single bytes32.\\n /// This format reduces the signature size from 65 to 64 bytes.\\n function signCompact(uint256 privateKey, bytes32 digest) external pure returns (bytes32 r, bytes32 vs);\\n\\n /// Signs `digest` with signer provided to script using the secp256k1 curve.\\n /// Returns a compact signature (`r`, `vs`) as per EIP-2098, where `vs` encodes both the\\n /// signature's `s` value, and the recovery id `v` in a single bytes32.\\n /// This format reduces the signature size from 65 to 64 bytes.\\n /// If `--sender` is provided, the signer with provided address is used, otherwise,\\n /// if exactly one signer is provided to the script, that signer is used.\\n /// Raises error if signer passed through `--sender` does not match any unlocked signers or\\n /// if `--sender` is not provided and not exactly one signer is passed to the script.\\n function signCompact(bytes32 digest) external pure returns (bytes32 r, bytes32 vs);\\n\\n /// Signs `digest` with signer provided to script using the secp256k1 curve.\\n /// Returns a compact signature (`r`, `vs`) as per EIP-2098, where `vs` encodes both the\\n /// signature's `s` value, and the recovery id `v` in a single bytes32.\\n /// This format reduces the signature size from 65 to 64 bytes.\\n /// Raises error if none of the signers passed into the script have provided address.\\n function signCompact(address signer, bytes32 digest) external pure returns (bytes32 r, bytes32 vs);\\n\\n /// Signs `digest` with `privateKey` using the secp256r1 curve.\\n function signP256(uint256 privateKey, bytes32 digest) external pure returns (bytes32 r, bytes32 s);\\n\\n /// Signs data with a `Wallet`.\\n function sign(Wallet calldata wallet, bytes32 digest) external returns (uint8 v, bytes32 r, bytes32 s);\\n\\n /// Signs `digest` with `privateKey` using the secp256k1 curve.\\n function sign(uint256 privateKey, bytes32 digest) external pure returns (uint8 v, bytes32 r, bytes32 s);\\n\\n /// Signs `digest` with signer provided to script using the secp256k1 curve.\\n /// If `--sender` is provided, the signer with provided address is used, otherwise,\\n /// if exactly one signer is provided to the script, that signer is used.\\n /// Raises error if signer passed through `--sender` does not match any unlocked signers or\\n /// if `--sender` is not provided and not exactly one signer is passed to the script.\\n function sign(bytes32 digest) external pure returns (uint8 v, bytes32 r, bytes32 s);\\n\\n /// Signs `digest` with signer provided to script using the secp256k1 curve.\\n /// Raises error if none of the signers passed into the script have provided address.\\n function sign(address signer, bytes32 digest) external pure returns (uint8 v, bytes32 r, bytes32 s);\\n\\n // ======== Environment ========\\n\\n /// Gets the environment variable `name` and parses it as `address`.\\n /// Reverts if the variable was not found or could not be parsed.\\n function envAddress(string calldata name) external view returns (address value);\\n\\n /// Gets the environment variable `name` and parses it as an array of `address`, delimited by `delim`.\\n /// Reverts if the variable was not found or could not be parsed.\\n function envAddress(string calldata name, string calldata delim) external view returns (address[] memory value);\\n\\n /// Gets the environment variable `name` and parses it as `bool`.\\n /// Reverts if the variable was not found or could not be parsed.\\n function envBool(string calldata name) external view returns (bool value);\\n\\n /// Gets the environment variable `name` and parses it as an array of `bool`, delimited by `delim`.\\n /// Reverts if the variable was not found or could not be parsed.\\n function envBool(string calldata name, string calldata delim) external view returns (bool[] memory value);\\n\\n /// Gets the environment variable `name` and parses it as `bytes32`.\\n /// Reverts if the variable was not found or could not be parsed.\\n function envBytes32(string calldata name) external view returns (bytes32 value);\\n\\n /// Gets the environment variable `name` and parses it as an array of `bytes32`, delimited by `delim`.\\n /// Reverts if the variable was not found or could not be parsed.\\n function envBytes32(string calldata name, string calldata delim) external view returns (bytes32[] memory value);\\n\\n /// Gets the environment variable `name` and parses it as `bytes`.\\n /// Reverts if the variable was not found or could not be parsed.\\n function envBytes(string calldata name) external view returns (bytes memory value);\\n\\n /// Gets the environment variable `name` and parses it as an array of `bytes`, delimited by `delim`.\\n /// Reverts if the variable was not found or could not be parsed.\\n function envBytes(string calldata name, string calldata delim) external view returns (bytes[] memory value);\\n\\n /// Gets the environment variable `name` and returns true if it exists, else returns false.\\n function envExists(string calldata name) external view returns (bool result);\\n\\n /// Gets the environment variable `name` and parses it as `int256`.\\n /// Reverts if the variable was not found or could not be parsed.\\n function envInt(string calldata name) external view returns (int256 value);\\n\\n /// Gets the environment variable `name` and parses it as an array of `int256`, delimited by `delim`.\\n /// Reverts if the variable was not found or could not be parsed.\\n function envInt(string calldata name, string calldata delim) external view returns (int256[] memory value);\\n\\n /// Gets the environment variable `name` and parses it as `bool`.\\n /// Reverts if the variable could not be parsed.\\n /// Returns `defaultValue` if the variable was not found.\\n function envOr(string calldata name, bool defaultValue) external view returns (bool value);\\n\\n /// Gets the environment variable `name` and parses it as `uint256`.\\n /// Reverts if the variable could not be parsed.\\n /// Returns `defaultValue` if the variable was not found.\\n function envOr(string calldata name, uint256 defaultValue) external view returns (uint256 value);\\n\\n /// Gets the environment variable `name` and parses it as an array of `address`, delimited by `delim`.\\n /// Reverts if the variable could not be parsed.\\n /// Returns `defaultValue` if the variable was not found.\\n function envOr(string calldata name, string calldata delim, address[] calldata defaultValue)\\n external\\n view\\n returns (address[] memory value);\\n\\n /// Gets the environment variable `name` and parses it as an array of `bytes32`, delimited by `delim`.\\n /// Reverts if the variable could not be parsed.\\n /// Returns `defaultValue` if the variable was not found.\\n function envOr(string calldata name, string calldata delim, bytes32[] calldata defaultValue)\\n external\\n view\\n returns (bytes32[] memory value);\\n\\n /// Gets the environment variable `name` and parses it as an array of `string`, delimited by `delim`.\\n /// Reverts if the variable could not be parsed.\\n /// Returns `defaultValue` if the variable was not found.\\n function envOr(string calldata name, string calldata delim, string[] calldata defaultValue)\\n external\\n view\\n returns (string[] memory value);\\n\\n /// Gets the environment variable `name` and parses it as an array of `bytes`, delimited by `delim`.\\n /// Reverts if the variable could not be parsed.\\n /// Returns `defaultValue` if the variable was not found.\\n function envOr(string calldata name, string calldata delim, bytes[] calldata defaultValue)\\n external\\n view\\n returns (bytes[] memory value);\\n\\n /// Gets the environment variable `name` and parses it as `int256`.\\n /// Reverts if the variable could not be parsed.\\n /// Returns `defaultValue` if the variable was not found.\\n function envOr(string calldata name, int256 defaultValue) external view returns (int256 value);\\n\\n /// Gets the environment variable `name` and parses it as `address`.\\n /// Reverts if the variable could not be parsed.\\n /// Returns `defaultValue` if the variable was not found.\\n function envOr(string calldata name, address defaultValue) external view returns (address value);\\n\\n /// Gets the environment variable `name` and parses it as `bytes32`.\\n /// Reverts if the variable could not be parsed.\\n /// Returns `defaultValue` if the variable was not found.\\n function envOr(string calldata name, bytes32 defaultValue) external view returns (bytes32 value);\\n\\n /// Gets the environment variable `name` and parses it as `string`.\\n /// Reverts if the variable could not be parsed.\\n /// Returns `defaultValue` if the variable was not found.\\n function envOr(string calldata name, string calldata defaultValue) external view returns (string memory value);\\n\\n /// Gets the environment variable `name` and parses it as `bytes`.\\n /// Reverts if the variable could not be parsed.\\n /// Returns `defaultValue` if the variable was not found.\\n function envOr(string calldata name, bytes calldata defaultValue) external view returns (bytes memory value);\\n\\n /// Gets the environment variable `name` and parses it as an array of `bool`, delimited by `delim`.\\n /// Reverts if the variable could not be parsed.\\n /// Returns `defaultValue` if the variable was not found.\\n function envOr(string calldata name, string calldata delim, bool[] calldata defaultValue)\\n external\\n view\\n returns (bool[] memory value);\\n\\n /// Gets the environment variable `name` and parses it as an array of `uint256`, delimited by `delim`.\\n /// Reverts if the variable could not be parsed.\\n /// Returns `defaultValue` if the variable was not found.\\n function envOr(string calldata name, string calldata delim, uint256[] calldata defaultValue)\\n external\\n view\\n returns (uint256[] memory value);\\n\\n /// Gets the environment variable `name` and parses it as an array of `int256`, delimited by `delim`.\\n /// Reverts if the variable could not be parsed.\\n /// Returns `defaultValue` if the variable was not found.\\n function envOr(string calldata name, string calldata delim, int256[] calldata defaultValue)\\n external\\n view\\n returns (int256[] memory value);\\n\\n /// Gets the environment variable `name` and parses it as `string`.\\n /// Reverts if the variable was not found or could not be parsed.\\n function envString(string calldata name) external view returns (string memory value);\\n\\n /// Gets the environment variable `name` and parses it as an array of `string`, delimited by `delim`.\\n /// Reverts if the variable was not found or could not be parsed.\\n function envString(string calldata name, string calldata delim) external view returns (string[] memory value);\\n\\n /// Gets the environment variable `name` and parses it as `uint256`.\\n /// Reverts if the variable was not found or could not be parsed.\\n function envUint(string calldata name) external view returns (uint256 value);\\n\\n /// Gets the environment variable `name` and parses it as an array of `uint256`, delimited by `delim`.\\n /// Reverts if the variable was not found or could not be parsed.\\n function envUint(string calldata name, string calldata delim) external view returns (uint256[] memory value);\\n\\n /// Returns true if `forge` command was executed in given context.\\n function isContext(ForgeContext context) external view returns (bool result);\\n\\n /// Sets environment variables.\\n function setEnv(string calldata name, string calldata value) external;\\n\\n // ======== EVM ========\\n\\n /// Gets all accessed reads and write slot from a `vm.record` session, for a given address.\\n function accesses(address target) external returns (bytes32[] memory readSlots, bytes32[] memory writeSlots);\\n\\n /// Gets the address for a given private key.\\n function addr(uint256 privateKey) external pure returns (address keyAddr);\\n\\n /// Gets all the logs according to specified filter.\\n function eth_getLogs(uint256 fromBlock, uint256 toBlock, address target, bytes32[] calldata topics)\\n external\\n returns (EthGetLogs[] memory logs);\\n\\n /// Gets the current `block.blobbasefee`.\\n /// You should use this instead of `block.blobbasefee` if you use `vm.blobBaseFee`, as `block.blobbasefee` is assumed to be constant across a transaction,\\n /// and as a result will get optimized out by the compiler.\\n /// See https://github.com/foundry-rs/foundry/issues/6180\\n function getBlobBaseFee() external view returns (uint256 blobBaseFee);\\n\\n /// Gets the current `block.number`.\\n /// You should use this instead of `block.number` if you use `vm.roll`, as `block.number` is assumed to be constant across a transaction,\\n /// and as a result will get optimized out by the compiler.\\n /// See https://github.com/foundry-rs/foundry/issues/6180\\n function getBlockNumber() external view returns (uint256 height);\\n\\n /// Gets the current `block.timestamp`.\\n /// You should use this instead of `block.timestamp` if you use `vm.warp`, as `block.timestamp` is assumed to be constant across a transaction,\\n /// and as a result will get optimized out by the compiler.\\n /// See https://github.com/foundry-rs/foundry/issues/6180\\n function getBlockTimestamp() external view returns (uint256 timestamp);\\n\\n /// Gets the map key and parent of a mapping at a given slot, for a given address.\\n function getMappingKeyAndParentOf(address target, bytes32 elementSlot)\\n external\\n returns (bool found, bytes32 key, bytes32 parent);\\n\\n /// Gets the number of elements in the mapping at the given slot, for a given address.\\n function getMappingLength(address target, bytes32 mappingSlot) external returns (uint256 length);\\n\\n /// Gets the elements at index idx of the mapping at the given slot, for a given address. The\\n /// index must be less than the length of the mapping (i.e. the number of keys in the mapping).\\n function getMappingSlotAt(address target, bytes32 mappingSlot, uint256 idx) external returns (bytes32 value);\\n\\n /// Gets the nonce of an account.\\n function getNonce(address account) external view returns (uint64 nonce);\\n\\n /// Get the nonce of a `Wallet`.\\n function getNonce(Wallet calldata wallet) external returns (uint64 nonce);\\n\\n /// Gets all the recorded logs.\\n function getRecordedLogs() external returns (Log[] memory logs);\\n\\n /// Returns state diffs from current `vm.startStateDiffRecording` session.\\n function getStateDiff() external view returns (string memory diff);\\n\\n /// Returns state diffs from current `vm.startStateDiffRecording` session, in json format.\\n function getStateDiffJson() external view returns (string memory diff);\\n\\n /// Gets the gas used in the last call from the callee perspective.\\n function lastCallGas() external view returns (Gas memory gas);\\n\\n /// Loads a storage slot from an address.\\n function load(address target, bytes32 slot) external view returns (bytes32 data);\\n\\n /// Pauses gas metering (i.e. gas usage is not counted). Noop if already paused.\\n function pauseGasMetering() external;\\n\\n /// Records all storage reads and writes.\\n function record() external;\\n\\n /// Record all the transaction logs.\\n function recordLogs() external;\\n\\n /// Reset gas metering (i.e. gas usage is set to gas limit).\\n function resetGasMetering() external;\\n\\n /// Resumes gas metering (i.e. gas usage is counted again). Noop if already on.\\n function resumeGasMetering() external;\\n\\n /// Performs an Ethereum JSON-RPC request to the current fork URL.\\n function rpc(string calldata method, string calldata params) external returns (bytes memory data);\\n\\n /// Performs an Ethereum JSON-RPC request to the given endpoint.\\n function rpc(string calldata urlOrAlias, string calldata method, string calldata params)\\n external\\n returns (bytes memory data);\\n\\n /// Records the debug trace during the run.\\n function startDebugTraceRecording() external;\\n\\n /// Starts recording all map SSTOREs for later retrieval.\\n function startMappingRecording() external;\\n\\n /// Record all account accesses as part of CREATE, CALL or SELFDESTRUCT opcodes in order,\\n /// along with the context of the calls\\n function startStateDiffRecording() external;\\n\\n /// Stop debug trace recording and returns the recorded debug trace.\\n function stopAndReturnDebugTraceRecording() external returns (DebugStep[] memory step);\\n\\n /// Returns an ordered array of all account accesses from a `vm.startStateDiffRecording` session.\\n function stopAndReturnStateDiff() external returns (AccountAccess[] memory accountAccesses);\\n\\n /// Stops recording all map SSTOREs for later retrieval and clears the recorded data.\\n function stopMappingRecording() external;\\n\\n // ======== Filesystem ========\\n\\n /// Closes file for reading, resetting the offset and allowing to read it from beginning with readLine.\\n /// `path` is relative to the project root.\\n function closeFile(string calldata path) external;\\n\\n /// Copies the contents of one file to another. This function will **overwrite** the contents of `to`.\\n /// On success, the total number of bytes copied is returned and it is equal to the length of the `to` file as reported by `metadata`.\\n /// Both `from` and `to` are relative to the project root.\\n function copyFile(string calldata from, string calldata to) external returns (uint64 copied);\\n\\n /// Creates a new, empty directory at the provided path.\\n /// This cheatcode will revert in the following situations, but is not limited to just these cases:\\n /// - User lacks permissions to modify `path`.\\n /// - A parent of the given path doesn't exist and `recursive` is false.\\n /// - `path` already exists and `recursive` is false.\\n /// `path` is relative to the project root.\\n function createDir(string calldata path, bool recursive) external;\\n\\n /// Deploys a contract from an artifact file. Takes in the relative path to the json file or the path to the\\n /// artifact in the form of :: where and parts are optional.\\n function deployCode(string calldata artifactPath) external returns (address deployedAddress);\\n\\n /// Deploys a contract from an artifact file. Takes in the relative path to the json file or the path to the\\n /// artifact in the form of :: where and parts are optional.\\n /// Additionally accepts abi-encoded constructor arguments.\\n function deployCode(string calldata artifactPath, bytes calldata constructorArgs)\\n external\\n returns (address deployedAddress);\\n\\n /// Returns true if the given path points to an existing entity, else returns false.\\n function exists(string calldata path) external view returns (bool result);\\n\\n /// Performs a foreign function call via the terminal.\\n function ffi(string[] calldata commandInput) external returns (bytes memory result);\\n\\n /// Given a path, query the file system to get information about a file, directory, etc.\\n function fsMetadata(string calldata path) external view returns (FsMetadata memory metadata);\\n\\n /// Gets the artifact path from code (aka. creation code).\\n function getArtifactPathByCode(bytes calldata code) external view returns (string memory path);\\n\\n /// Gets the artifact path from deployed code (aka. runtime code).\\n function getArtifactPathByDeployedCode(bytes calldata deployedCode) external view returns (string memory path);\\n\\n /// Returns the most recent broadcast for the given contract on `chainId` matching `txType`.\\n /// For example:\\n /// The most recent deployment can be fetched by passing `txType` as `CREATE` or `CREATE2`.\\n /// The most recent call can be fetched by passing `txType` as `CALL`.\\n function getBroadcast(string calldata contractName, uint64 chainId, BroadcastTxType txType)\\n external\\n view\\n returns (BroadcastTxSummary memory);\\n\\n /// Returns all broadcasts for the given contract on `chainId` with the specified `txType`.\\n /// Sorted such that the most recent broadcast is the first element, and the oldest is the last. i.e descending order of BroadcastTxSummary.blockNumber.\\n function getBroadcasts(string calldata contractName, uint64 chainId, BroadcastTxType txType)\\n external\\n view\\n returns (BroadcastTxSummary[] memory);\\n\\n /// Returns all broadcasts for the given contract on `chainId`.\\n /// Sorted such that the most recent broadcast is the first element, and the oldest is the last. i.e descending order of BroadcastTxSummary.blockNumber.\\n function getBroadcasts(string calldata contractName, uint64 chainId)\\n external\\n view\\n returns (BroadcastTxSummary[] memory);\\n\\n /// Gets the creation bytecode from an artifact file. Takes in the relative path to the json file or the path to the\\n /// artifact in the form of :: where and parts are optional.\\n function getCode(string calldata artifactPath) external view returns (bytes memory creationBytecode);\\n\\n /// Gets the deployed bytecode from an artifact file. Takes in the relative path to the json file or the path to the\\n /// artifact in the form of :: where and parts are optional.\\n function getDeployedCode(string calldata artifactPath) external view returns (bytes memory runtimeBytecode);\\n\\n /// Returns the most recent deployment for the current `chainId`.\\n function getDeployment(string calldata contractName) external view returns (address deployedAddress);\\n\\n /// Returns the most recent deployment for the given contract on `chainId`\\n function getDeployment(string calldata contractName, uint64 chainId)\\n external\\n view\\n returns (address deployedAddress);\\n\\n /// Returns all deployments for the given contract on `chainId`\\n /// Sorted in descending order of deployment time i.e descending order of BroadcastTxSummary.blockNumber.\\n /// The most recent deployment is the first element, and the oldest is the last.\\n function getDeployments(string calldata contractName, uint64 chainId)\\n external\\n view\\n returns (address[] memory deployedAddresses);\\n\\n /// Returns true if the path exists on disk and is pointing at a directory, else returns false.\\n function isDir(string calldata path) external view returns (bool result);\\n\\n /// Returns true if the path exists on disk and is pointing at a regular file, else returns false.\\n function isFile(string calldata path) external view returns (bool result);\\n\\n /// Get the path of the current project root.\\n function projectRoot() external view returns (string memory path);\\n\\n /// Prompts the user for a string value in the terminal.\\n function prompt(string calldata promptText) external returns (string memory input);\\n\\n /// Prompts the user for an address in the terminal.\\n function promptAddress(string calldata promptText) external returns (address);\\n\\n /// Prompts the user for a hidden string value in the terminal.\\n function promptSecret(string calldata promptText) external returns (string memory input);\\n\\n /// Prompts the user for hidden uint256 in the terminal (usually pk).\\n function promptSecretUint(string calldata promptText) external returns (uint256);\\n\\n /// Prompts the user for uint256 in the terminal.\\n function promptUint(string calldata promptText) external returns (uint256);\\n\\n /// Reads the directory at the given path recursively, up to `maxDepth`.\\n /// `maxDepth` defaults to 1, meaning only the direct children of the given directory will be returned.\\n /// Follows symbolic links if `followLinks` is true.\\n function readDir(string calldata path) external view returns (DirEntry[] memory entries);\\n\\n /// See `readDir(string)`.\\n function readDir(string calldata path, uint64 maxDepth) external view returns (DirEntry[] memory entries);\\n\\n /// See `readDir(string)`.\\n function readDir(string calldata path, uint64 maxDepth, bool followLinks)\\n external\\n view\\n returns (DirEntry[] memory entries);\\n\\n /// Reads the entire content of file to string. `path` is relative to the project root.\\n function readFile(string calldata path) external view returns (string memory data);\\n\\n /// Reads the entire content of file as binary. `path` is relative to the project root.\\n function readFileBinary(string calldata path) external view returns (bytes memory data);\\n\\n /// Reads next line of file to string.\\n function readLine(string calldata path) external view returns (string memory line);\\n\\n /// Reads a symbolic link, returning the path that the link points to.\\n /// This cheatcode will revert in the following situations, but is not limited to just these cases:\\n /// - `path` is not a symbolic link.\\n /// - `path` does not exist.\\n function readLink(string calldata linkPath) external view returns (string memory targetPath);\\n\\n /// Removes a directory at the provided path.\\n /// This cheatcode will revert in the following situations, but is not limited to just these cases:\\n /// - `path` doesn't exist.\\n /// - `path` isn't a directory.\\n /// - User lacks permissions to modify `path`.\\n /// - The directory is not empty and `recursive` is false.\\n /// `path` is relative to the project root.\\n function removeDir(string calldata path, bool recursive) external;\\n\\n /// Removes a file from the filesystem.\\n /// This cheatcode will revert in the following situations, but is not limited to just these cases:\\n /// - `path` points to a directory.\\n /// - The file doesn't exist.\\n /// - The user lacks permissions to remove the file.\\n /// `path` is relative to the project root.\\n function removeFile(string calldata path) external;\\n\\n /// Performs a foreign function call via terminal and returns the exit code, stdout, and stderr.\\n function tryFfi(string[] calldata commandInput) external returns (FfiResult memory result);\\n\\n /// Returns the time since unix epoch in milliseconds.\\n function unixTime() external view returns (uint256 milliseconds);\\n\\n /// Writes data to file, creating a file if it does not exist, and entirely replacing its contents if it does.\\n /// `path` is relative to the project root.\\n function writeFile(string calldata path, string calldata data) external;\\n\\n /// Writes binary data to a file, creating a file if it does not exist, and entirely replacing its contents if it does.\\n /// `path` is relative to the project root.\\n function writeFileBinary(string calldata path, bytes calldata data) external;\\n\\n /// Writes line to file, creating a file if it does not exist.\\n /// `path` is relative to the project root.\\n function writeLine(string calldata path, string calldata data) external;\\n\\n // ======== JSON ========\\n\\n /// Checks if `key` exists in a JSON object.\\n function keyExistsJson(string calldata json, string calldata key) external view returns (bool);\\n\\n /// Parses a string of JSON data at `key` and coerces it to `address`.\\n function parseJsonAddress(string calldata json, string calldata key) external pure returns (address);\\n\\n /// Parses a string of JSON data at `key` and coerces it to `address[]`.\\n function parseJsonAddressArray(string calldata json, string calldata key)\\n external\\n pure\\n returns (address[] memory);\\n\\n /// Parses a string of JSON data at `key` and coerces it to `bool`.\\n function parseJsonBool(string calldata json, string calldata key) external pure returns (bool);\\n\\n /// Parses a string of JSON data at `key` and coerces it to `bool[]`.\\n function parseJsonBoolArray(string calldata json, string calldata key) external pure returns (bool[] memory);\\n\\n /// Parses a string of JSON data at `key` and coerces it to `bytes`.\\n function parseJsonBytes(string calldata json, string calldata key) external pure returns (bytes memory);\\n\\n /// Parses a string of JSON data at `key` and coerces it to `bytes32`.\\n function parseJsonBytes32(string calldata json, string calldata key) external pure returns (bytes32);\\n\\n /// Parses a string of JSON data at `key` and coerces it to `bytes32[]`.\\n function parseJsonBytes32Array(string calldata json, string calldata key)\\n external\\n pure\\n returns (bytes32[] memory);\\n\\n /// Parses a string of JSON data at `key` and coerces it to `bytes[]`.\\n function parseJsonBytesArray(string calldata json, string calldata key) external pure returns (bytes[] memory);\\n\\n /// Parses a string of JSON data at `key` and coerces it to `int256`.\\n function parseJsonInt(string calldata json, string calldata key) external pure returns (int256);\\n\\n /// Parses a string of JSON data at `key` and coerces it to `int256[]`.\\n function parseJsonIntArray(string calldata json, string calldata key) external pure returns (int256[] memory);\\n\\n /// Returns an array of all the keys in a JSON object.\\n function parseJsonKeys(string calldata json, string calldata key) external pure returns (string[] memory keys);\\n\\n /// Parses a string of JSON data at `key` and coerces it to `string`.\\n function parseJsonString(string calldata json, string calldata key) external pure returns (string memory);\\n\\n /// Parses a string of JSON data at `key` and coerces it to `string[]`.\\n function parseJsonStringArray(string calldata json, string calldata key) external pure returns (string[] memory);\\n\\n /// Parses a string of JSON data at `key` and coerces it to type array corresponding to `typeDescription`.\\n function parseJsonTypeArray(string calldata json, string calldata key, string calldata typeDescription)\\n external\\n pure\\n returns (bytes memory);\\n\\n /// Parses a string of JSON data and coerces it to type corresponding to `typeDescription`.\\n function parseJsonType(string calldata json, string calldata typeDescription)\\n external\\n pure\\n returns (bytes memory);\\n\\n /// Parses a string of JSON data at `key` and coerces it to type corresponding to `typeDescription`.\\n function parseJsonType(string calldata json, string calldata key, string calldata typeDescription)\\n external\\n pure\\n returns (bytes memory);\\n\\n /// Parses a string of JSON data at `key` and coerces it to `uint256`.\\n function parseJsonUint(string calldata json, string calldata key) external pure returns (uint256);\\n\\n /// Parses a string of JSON data at `key` and coerces it to `uint256[]`.\\n function parseJsonUintArray(string calldata json, string calldata key) external pure returns (uint256[] memory);\\n\\n /// ABI-encodes a JSON object.\\n function parseJson(string calldata json) external pure returns (bytes memory abiEncodedData);\\n\\n /// ABI-encodes a JSON object at `key`.\\n function parseJson(string calldata json, string calldata key) external pure returns (bytes memory abiEncodedData);\\n\\n /// See `serializeJson`.\\n function serializeAddress(string calldata objectKey, string calldata valueKey, address value)\\n external\\n returns (string memory json);\\n\\n /// See `serializeJson`.\\n function serializeAddress(string calldata objectKey, string calldata valueKey, address[] calldata values)\\n external\\n returns (string memory json);\\n\\n /// See `serializeJson`.\\n function serializeBool(string calldata objectKey, string calldata valueKey, bool value)\\n external\\n returns (string memory json);\\n\\n /// See `serializeJson`.\\n function serializeBool(string calldata objectKey, string calldata valueKey, bool[] calldata values)\\n external\\n returns (string memory json);\\n\\n /// See `serializeJson`.\\n function serializeBytes32(string calldata objectKey, string calldata valueKey, bytes32 value)\\n external\\n returns (string memory json);\\n\\n /// See `serializeJson`.\\n function serializeBytes32(string calldata objectKey, string calldata valueKey, bytes32[] calldata values)\\n external\\n returns (string memory json);\\n\\n /// See `serializeJson`.\\n function serializeBytes(string calldata objectKey, string calldata valueKey, bytes calldata value)\\n external\\n returns (string memory json);\\n\\n /// See `serializeJson`.\\n function serializeBytes(string calldata objectKey, string calldata valueKey, bytes[] calldata values)\\n external\\n returns (string memory json);\\n\\n /// See `serializeJson`.\\n function serializeInt(string calldata objectKey, string calldata valueKey, int256 value)\\n external\\n returns (string memory json);\\n\\n /// See `serializeJson`.\\n function serializeInt(string calldata objectKey, string calldata valueKey, int256[] calldata values)\\n external\\n returns (string memory json);\\n\\n /// Serializes a key and value to a JSON object stored in-memory that can be later written to a file.\\n /// Returns the stringified version of the specific JSON file up to that moment.\\n function serializeJson(string calldata objectKey, string calldata value) external returns (string memory json);\\n\\n /// See `serializeJson`.\\n function serializeJsonType(string calldata typeDescription, bytes calldata value)\\n external\\n pure\\n returns (string memory json);\\n\\n /// See `serializeJson`.\\n function serializeJsonType(\\n string calldata objectKey,\\n string calldata valueKey,\\n string calldata typeDescription,\\n bytes calldata value\\n ) external returns (string memory json);\\n\\n /// See `serializeJson`.\\n function serializeString(string calldata objectKey, string calldata valueKey, string calldata value)\\n external\\n returns (string memory json);\\n\\n /// See `serializeJson`.\\n function serializeString(string calldata objectKey, string calldata valueKey, string[] calldata values)\\n external\\n returns (string memory json);\\n\\n /// See `serializeJson`.\\n function serializeUintToHex(string calldata objectKey, string calldata valueKey, uint256 value)\\n external\\n returns (string memory json);\\n\\n /// See `serializeJson`.\\n function serializeUint(string calldata objectKey, string calldata valueKey, uint256 value)\\n external\\n returns (string memory json);\\n\\n /// See `serializeJson`.\\n function serializeUint(string calldata objectKey, string calldata valueKey, uint256[] calldata values)\\n external\\n returns (string memory json);\\n\\n /// Write a serialized JSON object to a file. If the file exists, it will be overwritten.\\n function writeJson(string calldata json, string calldata path) external;\\n\\n /// Write a serialized JSON object to an **existing** JSON file, replacing a value with key = \\n /// This is useful to replace a specific value of a JSON file, without having to parse the entire thing.\\n function writeJson(string calldata json, string calldata path, string calldata valueKey) external;\\n\\n /// Checks if `key` exists in a JSON object\\n /// `keyExists` is being deprecated in favor of `keyExistsJson`. It will be removed in future versions.\\n function keyExists(string calldata json, string calldata key) external view returns (bool);\\n\\n // ======== Scripting ========\\n\\n /// Designate the next call as an EIP-7702 transaction\\n function attachDelegation(SignedDelegation calldata signedDelegation) external;\\n\\n /// Takes a signed transaction and broadcasts it to the network.\\n function broadcastRawTransaction(bytes calldata data) external;\\n\\n /// Has the next call (at this call depth only) create transactions that can later be signed and sent onchain.\\n /// Broadcasting address is determined by checking the following in order:\\n /// 1. If `--sender` argument was provided, that address is used.\\n /// 2. If exactly one signer (e.g. private key, hw wallet, keystore) is set when `forge broadcast` is invoked, that signer is used.\\n /// 3. Otherwise, default foundry sender (1804c8AB1F12E6bbf3894d4083f33e07309d1f38) is used.\\n function broadcast() external;\\n\\n /// Has the next call (at this call depth only) create a transaction with the address provided\\n /// as the sender that can later be signed and sent onchain.\\n function broadcast(address signer) external;\\n\\n /// Has the next call (at this call depth only) create a transaction with the private key\\n /// provided as the sender that can later be signed and sent onchain.\\n function broadcast(uint256 privateKey) external;\\n\\n /// Returns addresses of available unlocked wallets in the script environment.\\n function getWallets() external returns (address[] memory wallets);\\n\\n /// Sign an EIP-7702 authorization and designate the next call as an EIP-7702 transaction\\n function signAndAttachDelegation(address implementation, uint256 privateKey)\\n external\\n returns (SignedDelegation memory signedDelegation);\\n\\n /// Sign an EIP-7702 authorization for delegation\\n function signDelegation(address implementation, uint256 privateKey)\\n external\\n returns (SignedDelegation memory signedDelegation);\\n\\n /// Has all subsequent calls (at this call depth only) create transactions that can later be signed and sent onchain.\\n /// Broadcasting address is determined by checking the following in order:\\n /// 1. If `--sender` argument was provided, that address is used.\\n /// 2. If exactly one signer (e.g. private key, hw wallet, keystore) is set when `forge broadcast` is invoked, that signer is used.\\n /// 3. Otherwise, default foundry sender (1804c8AB1F12E6bbf3894d4083f33e07309d1f38) is used.\\n function startBroadcast() external;\\n\\n /// Has all subsequent calls (at this call depth only) create transactions with the address\\n /// provided that can later be signed and sent onchain.\\n function startBroadcast(address signer) external;\\n\\n /// Has all subsequent calls (at this call depth only) create transactions with the private key\\n /// provided that can later be signed and sent onchain.\\n function startBroadcast(uint256 privateKey) external;\\n\\n /// Stops collecting onchain transactions.\\n function stopBroadcast() external;\\n\\n // ======== String ========\\n\\n /// Returns true if `search` is found in `subject`, false otherwise.\\n function contains(string calldata subject, string calldata search) external returns (bool result);\\n\\n /// Returns the index of the first occurrence of a `key` in an `input` string.\\n /// Returns `NOT_FOUND` (i.e. `type(uint256).max`) if the `key` is not found.\\n /// Returns 0 in case of an empty `key`.\\n function indexOf(string calldata input, string calldata key) external pure returns (uint256);\\n\\n /// Parses the given `string` into an `address`.\\n function parseAddress(string calldata stringifiedValue) external pure returns (address parsedValue);\\n\\n /// Parses the given `string` into a `bool`.\\n function parseBool(string calldata stringifiedValue) external pure returns (bool parsedValue);\\n\\n /// Parses the given `string` into `bytes`.\\n function parseBytes(string calldata stringifiedValue) external pure returns (bytes memory parsedValue);\\n\\n /// Parses the given `string` into a `bytes32`.\\n function parseBytes32(string calldata stringifiedValue) external pure returns (bytes32 parsedValue);\\n\\n /// Parses the given `string` into a `int256`.\\n function parseInt(string calldata stringifiedValue) external pure returns (int256 parsedValue);\\n\\n /// Parses the given `string` into a `uint256`.\\n function parseUint(string calldata stringifiedValue) external pure returns (uint256 parsedValue);\\n\\n /// Replaces occurrences of `from` in the given `string` with `to`.\\n function replace(string calldata input, string calldata from, string calldata to)\\n external\\n pure\\n returns (string memory output);\\n\\n /// Splits the given `string` into an array of strings divided by the `delimiter`.\\n function split(string calldata input, string calldata delimiter) external pure returns (string[] memory outputs);\\n\\n /// Converts the given `string` value to Lowercase.\\n function toLowercase(string calldata input) external pure returns (string memory output);\\n\\n /// Converts the given value to a `string`.\\n function toString(address value) external pure returns (string memory stringifiedValue);\\n\\n /// Converts the given value to a `string`.\\n function toString(bytes calldata value) external pure returns (string memory stringifiedValue);\\n\\n /// Converts the given value to a `string`.\\n function toString(bytes32 value) external pure returns (string memory stringifiedValue);\\n\\n /// Converts the given value to a `string`.\\n function toString(bool value) external pure returns (string memory stringifiedValue);\\n\\n /// Converts the given value to a `string`.\\n function toString(uint256 value) external pure returns (string memory stringifiedValue);\\n\\n /// Converts the given value to a `string`.\\n function toString(int256 value) external pure returns (string memory stringifiedValue);\\n\\n /// Converts the given `string` value to Uppercase.\\n function toUppercase(string calldata input) external pure returns (string memory output);\\n\\n /// Trims leading and trailing whitespace from the given `string` value.\\n function trim(string calldata input) external pure returns (string memory output);\\n\\n // ======== Testing ========\\n\\n /// Compares two `uint256` values. Expects difference to be less than or equal to `maxDelta`.\\n /// Formats values with decimals in failure message.\\n function assertApproxEqAbsDecimal(uint256 left, uint256 right, uint256 maxDelta, uint256 decimals) external pure;\\n\\n /// Compares two `uint256` values. Expects difference to be less than or equal to `maxDelta`.\\n /// Formats values with decimals in failure message. Includes error message into revert string on failure.\\n function assertApproxEqAbsDecimal(\\n uint256 left,\\n uint256 right,\\n uint256 maxDelta,\\n uint256 decimals,\\n string calldata error\\n ) external pure;\\n\\n /// Compares two `int256` values. Expects difference to be less than or equal to `maxDelta`.\\n /// Formats values with decimals in failure message.\\n function assertApproxEqAbsDecimal(int256 left, int256 right, uint256 maxDelta, uint256 decimals) external pure;\\n\\n /// Compares two `int256` values. Expects difference to be less than or equal to `maxDelta`.\\n /// Formats values with decimals in failure message. Includes error message into revert string on failure.\\n function assertApproxEqAbsDecimal(\\n int256 left,\\n int256 right,\\n uint256 maxDelta,\\n uint256 decimals,\\n string calldata error\\n ) external pure;\\n\\n /// Compares two `uint256` values. Expects difference to be less than or equal to `maxDelta`.\\n function assertApproxEqAbs(uint256 left, uint256 right, uint256 maxDelta) external pure;\\n\\n /// Compares two `uint256` values. Expects difference to be less than or equal to `maxDelta`.\\n /// Includes error message into revert string on failure.\\n function assertApproxEqAbs(uint256 left, uint256 right, uint256 maxDelta, string calldata error) external pure;\\n\\n /// Compares two `int256` values. Expects difference to be less than or equal to `maxDelta`.\\n function assertApproxEqAbs(int256 left, int256 right, uint256 maxDelta) external pure;\\n\\n /// Compares two `int256` values. Expects difference to be less than or equal to `maxDelta`.\\n /// Includes error message into revert string on failure.\\n function assertApproxEqAbs(int256 left, int256 right, uint256 maxDelta, string calldata error) external pure;\\n\\n /// Compares two `uint256` values. Expects relative difference in percents to be less than or equal to `maxPercentDelta`.\\n /// `maxPercentDelta` is an 18 decimal fixed point number, where 1e18 == 100%\\n /// Formats values with decimals in failure message.\\n function assertApproxEqRelDecimal(uint256 left, uint256 right, uint256 maxPercentDelta, uint256 decimals)\\n external\\n pure;\\n\\n /// Compares two `uint256` values. Expects relative difference in percents to be less than or equal to `maxPercentDelta`.\\n /// `maxPercentDelta` is an 18 decimal fixed point number, where 1e18 == 100%\\n /// Formats values with decimals in failure message. Includes error message into revert string on failure.\\n function assertApproxEqRelDecimal(\\n uint256 left,\\n uint256 right,\\n uint256 maxPercentDelta,\\n uint256 decimals,\\n string calldata error\\n ) external pure;\\n\\n /// Compares two `int256` values. Expects relative difference in percents to be less than or equal to `maxPercentDelta`.\\n /// `maxPercentDelta` is an 18 decimal fixed point number, where 1e18 == 100%\\n /// Formats values with decimals in failure message.\\n function assertApproxEqRelDecimal(int256 left, int256 right, uint256 maxPercentDelta, uint256 decimals)\\n external\\n pure;\\n\\n /// Compares two `int256` values. Expects relative difference in percents to be less than or equal to `maxPercentDelta`.\\n /// `maxPercentDelta` is an 18 decimal fixed point number, where 1e18 == 100%\\n /// Formats values with decimals in failure message. Includes error message into revert string on failure.\\n function assertApproxEqRelDecimal(\\n int256 left,\\n int256 right,\\n uint256 maxPercentDelta,\\n uint256 decimals,\\n string calldata error\\n ) external pure;\\n\\n /// Compares two `uint256` values. Expects relative difference in percents to be less than or equal to `maxPercentDelta`.\\n /// `maxPercentDelta` is an 18 decimal fixed point number, where 1e18 == 100%\\n function assertApproxEqRel(uint256 left, uint256 right, uint256 maxPercentDelta) external pure;\\n\\n /// Compares two `uint256` values. Expects relative difference in percents to be less than or equal to `maxPercentDelta`.\\n /// `maxPercentDelta` is an 18 decimal fixed point number, where 1e18 == 100%\\n /// Includes error message into revert string on failure.\\n function assertApproxEqRel(uint256 left, uint256 right, uint256 maxPercentDelta, string calldata error)\\n external\\n pure;\\n\\n /// Compares two `int256` values. Expects relative difference in percents to be less than or equal to `maxPercentDelta`.\\n /// `maxPercentDelta` is an 18 decimal fixed point number, where 1e18 == 100%\\n function assertApproxEqRel(int256 left, int256 right, uint256 maxPercentDelta) external pure;\\n\\n /// Compares two `int256` values. Expects relative difference in percents to be less than or equal to `maxPercentDelta`.\\n /// `maxPercentDelta` is an 18 decimal fixed point number, where 1e18 == 100%\\n /// Includes error message into revert string on failure.\\n function assertApproxEqRel(int256 left, int256 right, uint256 maxPercentDelta, string calldata error)\\n external\\n pure;\\n\\n /// Asserts that two `uint256` values are equal, formatting them with decimals in failure message.\\n function assertEqDecimal(uint256 left, uint256 right, uint256 decimals) external pure;\\n\\n /// Asserts that two `uint256` values are equal, formatting them with decimals in failure message.\\n /// Includes error message into revert string on failure.\\n function assertEqDecimal(uint256 left, uint256 right, uint256 decimals, string calldata error) external pure;\\n\\n /// Asserts that two `int256` values are equal, formatting them with decimals in failure message.\\n function assertEqDecimal(int256 left, int256 right, uint256 decimals) external pure;\\n\\n /// Asserts that two `int256` values are equal, formatting them with decimals in failure message.\\n /// Includes error message into revert string on failure.\\n function assertEqDecimal(int256 left, int256 right, uint256 decimals, string calldata error) external pure;\\n\\n /// Asserts that two `bool` values are equal.\\n function assertEq(bool left, bool right) external pure;\\n\\n /// Asserts that two `bool` values are equal and includes error message into revert string on failure.\\n function assertEq(bool left, bool right, string calldata error) external pure;\\n\\n /// Asserts that two `string` values are equal.\\n function assertEq(string calldata left, string calldata right) external pure;\\n\\n /// Asserts that two `string` values are equal and includes error message into revert string on failure.\\n function assertEq(string calldata left, string calldata right, string calldata error) external pure;\\n\\n /// Asserts that two `bytes` values are equal.\\n function assertEq(bytes calldata left, bytes calldata right) external pure;\\n\\n /// Asserts that two `bytes` values are equal and includes error message into revert string on failure.\\n function assertEq(bytes calldata left, bytes calldata right, string calldata error) external pure;\\n\\n /// Asserts that two arrays of `bool` values are equal.\\n function assertEq(bool[] calldata left, bool[] calldata right) external pure;\\n\\n /// Asserts that two arrays of `bool` values are equal and includes error message into revert string on failure.\\n function assertEq(bool[] calldata left, bool[] calldata right, string calldata error) external pure;\\n\\n /// Asserts that two arrays of `uint256 values are equal.\\n function assertEq(uint256[] calldata left, uint256[] calldata right) external pure;\\n\\n /// Asserts that two arrays of `uint256` values are equal and includes error message into revert string on failure.\\n function assertEq(uint256[] calldata left, uint256[] calldata right, string calldata error) external pure;\\n\\n /// Asserts that two arrays of `int256` values are equal.\\n function assertEq(int256[] calldata left, int256[] calldata right) external pure;\\n\\n /// Asserts that two arrays of `int256` values are equal and includes error message into revert string on failure.\\n function assertEq(int256[] calldata left, int256[] calldata right, string calldata error) external pure;\\n\\n /// Asserts that two `uint256` values are equal.\\n function assertEq(uint256 left, uint256 right) external pure;\\n\\n /// Asserts that two arrays of `address` values are equal.\\n function assertEq(address[] calldata left, address[] calldata right) external pure;\\n\\n /// Asserts that two arrays of `address` values are equal and includes error message into revert string on failure.\\n function assertEq(address[] calldata left, address[] calldata right, string calldata error) external pure;\\n\\n /// Asserts that two arrays of `bytes32` values are equal.\\n function assertEq(bytes32[] calldata left, bytes32[] calldata right) external pure;\\n\\n /// Asserts that two arrays of `bytes32` values are equal and includes error message into revert string on failure.\\n function assertEq(bytes32[] calldata left, bytes32[] calldata right, string calldata error) external pure;\\n\\n /// Asserts that two arrays of `string` values are equal.\\n function assertEq(string[] calldata left, string[] calldata right) external pure;\\n\\n /// Asserts that two arrays of `string` values are equal and includes error message into revert string on failure.\\n function assertEq(string[] calldata left, string[] calldata right, string calldata error) external pure;\\n\\n /// Asserts that two arrays of `bytes` values are equal.\\n function assertEq(bytes[] calldata left, bytes[] calldata right) external pure;\\n\\n /// Asserts that two arrays of `bytes` values are equal and includes error message into revert string on failure.\\n function assertEq(bytes[] calldata left, bytes[] calldata right, string calldata error) external pure;\\n\\n /// Asserts that two `uint256` values are equal and includes error message into revert string on failure.\\n function assertEq(uint256 left, uint256 right, string calldata error) external pure;\\n\\n /// Asserts that two `int256` values are equal.\\n function assertEq(int256 left, int256 right) external pure;\\n\\n /// Asserts that two `int256` values are equal and includes error message into revert string on failure.\\n function assertEq(int256 left, int256 right, string calldata error) external pure;\\n\\n /// Asserts that two `address` values are equal.\\n function assertEq(address left, address right) external pure;\\n\\n /// Asserts that two `address` values are equal and includes error message into revert string on failure.\\n function assertEq(address left, address right, string calldata error) external pure;\\n\\n /// Asserts that two `bytes32` values are equal.\\n function assertEq(bytes32 left, bytes32 right) external pure;\\n\\n /// Asserts that two `bytes32` values are equal and includes error message into revert string on failure.\\n function assertEq(bytes32 left, bytes32 right, string calldata error) external pure;\\n\\n /// Asserts that the given condition is false.\\n function assertFalse(bool condition) external pure;\\n\\n /// Asserts that the given condition is false and includes error message into revert string on failure.\\n function assertFalse(bool condition, string calldata error) external pure;\\n\\n /// Compares two `uint256` values. Expects first value to be greater than or equal to second.\\n /// Formats values with decimals in failure message.\\n function assertGeDecimal(uint256 left, uint256 right, uint256 decimals) external pure;\\n\\n /// Compares two `uint256` values. Expects first value to be greater than or equal to second.\\n /// Formats values with decimals in failure message. Includes error message into revert string on failure.\\n function assertGeDecimal(uint256 left, uint256 right, uint256 decimals, string calldata error) external pure;\\n\\n /// Compares two `int256` values. Expects first value to be greater than or equal to second.\\n /// Formats values with decimals in failure message.\\n function assertGeDecimal(int256 left, int256 right, uint256 decimals) external pure;\\n\\n /// Compares two `int256` values. Expects first value to be greater than or equal to second.\\n /// Formats values with decimals in failure message. Includes error message into revert string on failure.\\n function assertGeDecimal(int256 left, int256 right, uint256 decimals, string calldata error) external pure;\\n\\n /// Compares two `uint256` values. Expects first value to be greater than or equal to second.\\n function assertGe(uint256 left, uint256 right) external pure;\\n\\n /// Compares two `uint256` values. Expects first value to be greater than or equal to second.\\n /// Includes error message into revert string on failure.\\n function assertGe(uint256 left, uint256 right, string calldata error) external pure;\\n\\n /// Compares two `int256` values. Expects first value to be greater than or equal to second.\\n function assertGe(int256 left, int256 right) external pure;\\n\\n /// Compares two `int256` values. Expects first value to be greater than or equal to second.\\n /// Includes error message into revert string on failure.\\n function assertGe(int256 left, int256 right, string calldata error) external pure;\\n\\n /// Compares two `uint256` values. Expects first value to be greater than second.\\n /// Formats values with decimals in failure message.\\n function assertGtDecimal(uint256 left, uint256 right, uint256 decimals) external pure;\\n\\n /// Compares two `uint256` values. Expects first value to be greater than second.\\n /// Formats values with decimals in failure message. Includes error message into revert string on failure.\\n function assertGtDecimal(uint256 left, uint256 right, uint256 decimals, string calldata error) external pure;\\n\\n /// Compares two `int256` values. Expects first value to be greater than second.\\n /// Formats values with decimals in failure message.\\n function assertGtDecimal(int256 left, int256 right, uint256 decimals) external pure;\\n\\n /// Compares two `int256` values. Expects first value to be greater than second.\\n /// Formats values with decimals in failure message. Includes error message into revert string on failure.\\n function assertGtDecimal(int256 left, int256 right, uint256 decimals, string calldata error) external pure;\\n\\n /// Compares two `uint256` values. Expects first value to be greater than second.\\n function assertGt(uint256 left, uint256 right) external pure;\\n\\n /// Compares two `uint256` values. Expects first value to be greater than second.\\n /// Includes error message into revert string on failure.\\n function assertGt(uint256 left, uint256 right, string calldata error) external pure;\\n\\n /// Compares two `int256` values. Expects first value to be greater than second.\\n function assertGt(int256 left, int256 right) external pure;\\n\\n /// Compares two `int256` values. Expects first value to be greater than second.\\n /// Includes error message into revert string on failure.\\n function assertGt(int256 left, int256 right, string calldata error) external pure;\\n\\n /// Compares two `uint256` values. Expects first value to be less than or equal to second.\\n /// Formats values with decimals in failure message.\\n function assertLeDecimal(uint256 left, uint256 right, uint256 decimals) external pure;\\n\\n /// Compares two `uint256` values. Expects first value to be less than or equal to second.\\n /// Formats values with decimals in failure message. Includes error message into revert string on failure.\\n function assertLeDecimal(uint256 left, uint256 right, uint256 decimals, string calldata error) external pure;\\n\\n /// Compares two `int256` values. Expects first value to be less than or equal to second.\\n /// Formats values with decimals in failure message.\\n function assertLeDecimal(int256 left, int256 right, uint256 decimals) external pure;\\n\\n /// Compares two `int256` values. Expects first value to be less than or equal to second.\\n /// Formats values with decimals in failure message. Includes error message into revert string on failure.\\n function assertLeDecimal(int256 left, int256 right, uint256 decimals, string calldata error) external pure;\\n\\n /// Compares two `uint256` values. Expects first value to be less than or equal to second.\\n function assertLe(uint256 left, uint256 right) external pure;\\n\\n /// Compares two `uint256` values. Expects first value to be less than or equal to second.\\n /// Includes error message into revert string on failure.\\n function assertLe(uint256 left, uint256 right, string calldata error) external pure;\\n\\n /// Compares two `int256` values. Expects first value to be less than or equal to second.\\n function assertLe(int256 left, int256 right) external pure;\\n\\n /// Compares two `int256` values. Expects first value to be less than or equal to second.\\n /// Includes error message into revert string on failure.\\n function assertLe(int256 left, int256 right, string calldata error) external pure;\\n\\n /// Compares two `uint256` values. Expects first value to be less than second.\\n /// Formats values with decimals in failure message.\\n function assertLtDecimal(uint256 left, uint256 right, uint256 decimals) external pure;\\n\\n /// Compares two `uint256` values. Expects first value to be less than second.\\n /// Formats values with decimals in failure message. Includes error message into revert string on failure.\\n function assertLtDecimal(uint256 left, uint256 right, uint256 decimals, string calldata error) external pure;\\n\\n /// Compares two `int256` values. Expects first value to be less than second.\\n /// Formats values with decimals in failure message.\\n function assertLtDecimal(int256 left, int256 right, uint256 decimals) external pure;\\n\\n /// Compares two `int256` values. Expects first value to be less than second.\\n /// Formats values with decimals in failure message. Includes error message into revert string on failure.\\n function assertLtDecimal(int256 left, int256 right, uint256 decimals, string calldata error) external pure;\\n\\n /// Compares two `uint256` values. Expects first value to be less than second.\\n function assertLt(uint256 left, uint256 right) external pure;\\n\\n /// Compares two `uint256` values. Expects first value to be less than second.\\n /// Includes error message into revert string on failure.\\n function assertLt(uint256 left, uint256 right, string calldata error) external pure;\\n\\n /// Compares two `int256` values. Expects first value to be less than second.\\n function assertLt(int256 left, int256 right) external pure;\\n\\n /// Compares two `int256` values. Expects first value to be less than second.\\n /// Includes error message into revert string on failure.\\n function assertLt(int256 left, int256 right, string calldata error) external pure;\\n\\n /// Asserts that two `uint256` values are not equal, formatting them with decimals in failure message.\\n function assertNotEqDecimal(uint256 left, uint256 right, uint256 decimals) external pure;\\n\\n /// Asserts that two `uint256` values are not equal, formatting them with decimals in failure message.\\n /// Includes error message into revert string on failure.\\n function assertNotEqDecimal(uint256 left, uint256 right, uint256 decimals, string calldata error) external pure;\\n\\n /// Asserts that two `int256` values are not equal, formatting them with decimals in failure message.\\n function assertNotEqDecimal(int256 left, int256 right, uint256 decimals) external pure;\\n\\n /// Asserts that two `int256` values are not equal, formatting them with decimals in failure message.\\n /// Includes error message into revert string on failure.\\n function assertNotEqDecimal(int256 left, int256 right, uint256 decimals, string calldata error) external pure;\\n\\n /// Asserts that two `bool` values are not equal.\\n function assertNotEq(bool left, bool right) external pure;\\n\\n /// Asserts that two `bool` values are not equal and includes error message into revert string on failure.\\n function assertNotEq(bool left, bool right, string calldata error) external pure;\\n\\n /// Asserts that two `string` values are not equal.\\n function assertNotEq(string calldata left, string calldata right) external pure;\\n\\n /// Asserts that two `string` values are not equal and includes error message into revert string on failure.\\n function assertNotEq(string calldata left, string calldata right, string calldata error) external pure;\\n\\n /// Asserts that two `bytes` values are not equal.\\n function assertNotEq(bytes calldata left, bytes calldata right) external pure;\\n\\n /// Asserts that two `bytes` values are not equal and includes error message into revert string on failure.\\n function assertNotEq(bytes calldata left, bytes calldata right, string calldata error) external pure;\\n\\n /// Asserts that two arrays of `bool` values are not equal.\\n function assertNotEq(bool[] calldata left, bool[] calldata right) external pure;\\n\\n /// Asserts that two arrays of `bool` values are not equal and includes error message into revert string on failure.\\n function assertNotEq(bool[] calldata left, bool[] calldata right, string calldata error) external pure;\\n\\n /// Asserts that two arrays of `uint256` values are not equal.\\n function assertNotEq(uint256[] calldata left, uint256[] calldata right) external pure;\\n\\n /// Asserts that two arrays of `uint256` values are not equal and includes error message into revert string on failure.\\n function assertNotEq(uint256[] calldata left, uint256[] calldata right, string calldata error) external pure;\\n\\n /// Asserts that two arrays of `int256` values are not equal.\\n function assertNotEq(int256[] calldata left, int256[] calldata right) external pure;\\n\\n /// Asserts that two arrays of `int256` values are not equal and includes error message into revert string on failure.\\n function assertNotEq(int256[] calldata left, int256[] calldata right, string calldata error) external pure;\\n\\n /// Asserts that two `uint256` values are not equal.\\n function assertNotEq(uint256 left, uint256 right) external pure;\\n\\n /// Asserts that two arrays of `address` values are not equal.\\n function assertNotEq(address[] calldata left, address[] calldata right) external pure;\\n\\n /// Asserts that two arrays of `address` values are not equal and includes error message into revert string on failure.\\n function assertNotEq(address[] calldata left, address[] calldata right, string calldata error) external pure;\\n\\n /// Asserts that two arrays of `bytes32` values are not equal.\\n function assertNotEq(bytes32[] calldata left, bytes32[] calldata right) external pure;\\n\\n /// Asserts that two arrays of `bytes32` values are not equal and includes error message into revert string on failure.\\n function assertNotEq(bytes32[] calldata left, bytes32[] calldata right, string calldata error) external pure;\\n\\n /// Asserts that two arrays of `string` values are not equal.\\n function assertNotEq(string[] calldata left, string[] calldata right) external pure;\\n\\n /// Asserts that two arrays of `string` values are not equal and includes error message into revert string on failure.\\n function assertNotEq(string[] calldata left, string[] calldata right, string calldata error) external pure;\\n\\n /// Asserts that two arrays of `bytes` values are not equal.\\n function assertNotEq(bytes[] calldata left, bytes[] calldata right) external pure;\\n\\n /// Asserts that two arrays of `bytes` values are not equal and includes error message into revert string on failure.\\n function assertNotEq(bytes[] calldata left, bytes[] calldata right, string calldata error) external pure;\\n\\n /// Asserts that two `uint256` values are not equal and includes error message into revert string on failure.\\n function assertNotEq(uint256 left, uint256 right, string calldata error) external pure;\\n\\n /// Asserts that two `int256` values are not equal.\\n function assertNotEq(int256 left, int256 right) external pure;\\n\\n /// Asserts that two `int256` values are not equal and includes error message into revert string on failure.\\n function assertNotEq(int256 left, int256 right, string calldata error) external pure;\\n\\n /// Asserts that two `address` values are not equal.\\n function assertNotEq(address left, address right) external pure;\\n\\n /// Asserts that two `address` values are not equal and includes error message into revert string on failure.\\n function assertNotEq(address left, address right, string calldata error) external pure;\\n\\n /// Asserts that two `bytes32` values are not equal.\\n function assertNotEq(bytes32 left, bytes32 right) external pure;\\n\\n /// Asserts that two `bytes32` values are not equal and includes error message into revert string on failure.\\n function assertNotEq(bytes32 left, bytes32 right, string calldata error) external pure;\\n\\n /// Asserts that the given condition is true.\\n function assertTrue(bool condition) external pure;\\n\\n /// Asserts that the given condition is true and includes error message into revert string on failure.\\n function assertTrue(bool condition, string calldata error) external pure;\\n\\n /// If the condition is false, discard this run's fuzz inputs and generate new ones.\\n function assume(bool condition) external pure;\\n\\n /// Discard this run's fuzz inputs and generate new ones if next call reverted.\\n function assumeNoRevert() external pure;\\n\\n /// Discard this run's fuzz inputs and generate new ones if next call reverts with the potential revert parameters.\\n function assumeNoRevert(PotentialRevert calldata potentialRevert) external pure;\\n\\n /// Discard this run's fuzz inputs and generate new ones if next call reverts with the any of the potential revert parameters.\\n function assumeNoRevert(PotentialRevert[] calldata potentialReverts) external pure;\\n\\n /// Writes a breakpoint to jump to in the debugger.\\n function breakpoint(string calldata char) external pure;\\n\\n /// Writes a conditional breakpoint to jump to in the debugger.\\n function breakpoint(string calldata char, bool value) external pure;\\n\\n /// Returns true if the current Foundry version is greater than or equal to the given version.\\n /// The given version string must be in the format `major.minor.patch`.\\n /// This is equivalent to `foundryVersionCmp(version) >= 0`.\\n function foundryVersionAtLeast(string calldata version) external view returns (bool);\\n\\n /// Compares the current Foundry version with the given version string.\\n /// The given version string must be in the format `major.minor.patch`.\\n /// Returns:\\n /// -1 if current Foundry version is less than the given version\\n /// 0 if current Foundry version equals the given version\\n /// 1 if current Foundry version is greater than the given version\\n /// This result can then be used with a comparison operator against `0`.\\n /// For example, to check if the current Foundry version is greater than or equal to `1.0.0`:\\n /// `if (foundryVersionCmp(\\\"1.0.0\\\") >= 0) { ... }`\\n function foundryVersionCmp(string calldata version) external view returns (int256);\\n\\n /// Returns the Foundry version.\\n /// Format: -+..\\n /// Sample output: 0.3.0-nightly+3cb96bde9b.1737036656.debug\\n /// Note: Build timestamps may vary slightly across platforms due to separate CI jobs.\\n /// For reliable version comparisons, use UNIX format (e.g., >= 1700000000)\\n /// to compare timestamps while ignoring minor time differences.\\n function getFoundryVersion() external view returns (string memory version);\\n\\n /// Returns the RPC url for the given alias.\\n function rpcUrl(string calldata rpcAlias) external view returns (string memory json);\\n\\n /// Returns all rpc urls and their aliases as structs.\\n function rpcUrlStructs() external view returns (Rpc[] memory urls);\\n\\n /// Returns all rpc urls and their aliases `[alias, url][]`.\\n function rpcUrls() external view returns (string[2][] memory urls);\\n\\n /// Suspends execution of the main thread for `duration` milliseconds.\\n function sleep(uint256 duration) external;\\n\\n // ======== Toml ========\\n\\n /// Checks if `key` exists in a TOML table.\\n function keyExistsToml(string calldata toml, string calldata key) external view returns (bool);\\n\\n /// Parses a string of TOML data at `key` and coerces it to `address`.\\n function parseTomlAddress(string calldata toml, string calldata key) external pure returns (address);\\n\\n /// Parses a string of TOML data at `key` and coerces it to `address[]`.\\n function parseTomlAddressArray(string calldata toml, string calldata key)\\n external\\n pure\\n returns (address[] memory);\\n\\n /// Parses a string of TOML data at `key` and coerces it to `bool`.\\n function parseTomlBool(string calldata toml, string calldata key) external pure returns (bool);\\n\\n /// Parses a string of TOML data at `key` and coerces it to `bool[]`.\\n function parseTomlBoolArray(string calldata toml, string calldata key) external pure returns (bool[] memory);\\n\\n /// Parses a string of TOML data at `key` and coerces it to `bytes`.\\n function parseTomlBytes(string calldata toml, string calldata key) external pure returns (bytes memory);\\n\\n /// Parses a string of TOML data at `key` and coerces it to `bytes32`.\\n function parseTomlBytes32(string calldata toml, string calldata key) external pure returns (bytes32);\\n\\n /// Parses a string of TOML data at `key` and coerces it to `bytes32[]`.\\n function parseTomlBytes32Array(string calldata toml, string calldata key)\\n external\\n pure\\n returns (bytes32[] memory);\\n\\n /// Parses a string of TOML data at `key` and coerces it to `bytes[]`.\\n function parseTomlBytesArray(string calldata toml, string calldata key) external pure returns (bytes[] memory);\\n\\n /// Parses a string of TOML data at `key` and coerces it to `int256`.\\n function parseTomlInt(string calldata toml, string calldata key) external pure returns (int256);\\n\\n /// Parses a string of TOML data at `key` and coerces it to `int256[]`.\\n function parseTomlIntArray(string calldata toml, string calldata key) external pure returns (int256[] memory);\\n\\n /// Returns an array of all the keys in a TOML table.\\n function parseTomlKeys(string calldata toml, string calldata key) external pure returns (string[] memory keys);\\n\\n /// Parses a string of TOML data at `key` and coerces it to `string`.\\n function parseTomlString(string calldata toml, string calldata key) external pure returns (string memory);\\n\\n /// Parses a string of TOML data at `key` and coerces it to `string[]`.\\n function parseTomlStringArray(string calldata toml, string calldata key) external pure returns (string[] memory);\\n\\n /// Parses a string of TOML data at `key` and coerces it to type array corresponding to `typeDescription`.\\n function parseTomlTypeArray(string calldata toml, string calldata key, string calldata typeDescription)\\n external\\n pure\\n returns (bytes memory);\\n\\n /// Parses a string of TOML data and coerces it to type corresponding to `typeDescription`.\\n function parseTomlType(string calldata toml, string calldata typeDescription)\\n external\\n pure\\n returns (bytes memory);\\n\\n /// Parses a string of TOML data at `key` and coerces it to type corresponding to `typeDescription`.\\n function parseTomlType(string calldata toml, string calldata key, string calldata typeDescription)\\n external\\n pure\\n returns (bytes memory);\\n\\n /// Parses a string of TOML data at `key` and coerces it to `uint256`.\\n function parseTomlUint(string calldata toml, string calldata key) external pure returns (uint256);\\n\\n /// Parses a string of TOML data at `key` and coerces it to `uint256[]`.\\n function parseTomlUintArray(string calldata toml, string calldata key) external pure returns (uint256[] memory);\\n\\n /// ABI-encodes a TOML table.\\n function parseToml(string calldata toml) external pure returns (bytes memory abiEncodedData);\\n\\n /// ABI-encodes a TOML table at `key`.\\n function parseToml(string calldata toml, string calldata key) external pure returns (bytes memory abiEncodedData);\\n\\n /// Takes serialized JSON, converts to TOML and write a serialized TOML to a file.\\n function writeToml(string calldata json, string calldata path) external;\\n\\n /// Takes serialized JSON, converts to TOML and write a serialized TOML table to an **existing** TOML file, replacing a value with key = \\n /// This is useful to replace a specific value of a TOML file, without having to parse the entire thing.\\n function writeToml(string calldata json, string calldata path, string calldata valueKey) external;\\n\\n // ======== Utilities ========\\n\\n /// Compute the address of a contract created with CREATE2 using the given CREATE2 deployer.\\n function computeCreate2Address(bytes32 salt, bytes32 initCodeHash, address deployer)\\n external\\n pure\\n returns (address);\\n\\n /// Compute the address of a contract created with CREATE2 using the default CREATE2 deployer.\\n function computeCreate2Address(bytes32 salt, bytes32 initCodeHash) external pure returns (address);\\n\\n /// Compute the address a contract will be deployed at for a given deployer address and nonce.\\n function computeCreateAddress(address deployer, uint256 nonce) external pure returns (address);\\n\\n /// Utility cheatcode to copy storage of `from` contract to another `to` contract.\\n function copyStorage(address from, address to) external;\\n\\n /// Returns ENS namehash for provided string.\\n function ensNamehash(string calldata name) external pure returns (bytes32);\\n\\n /// Gets the label for the specified address.\\n function getLabel(address account) external view returns (string memory currentLabel);\\n\\n /// Labels an address in call traces.\\n function label(address account, string calldata newLabel) external;\\n\\n /// Pauses collection of call traces. Useful in cases when you want to skip tracing of\\n /// complex calls which are not useful for debugging.\\n function pauseTracing() external view;\\n\\n /// Returns a random `address`.\\n function randomAddress() external returns (address);\\n\\n /// Returns a random `bool`.\\n function randomBool() external view returns (bool);\\n\\n /// Returns a random byte array value of the given length.\\n function randomBytes(uint256 len) external view returns (bytes memory);\\n\\n /// Returns a random fixed-size byte array of length 4.\\n function randomBytes4() external view returns (bytes4);\\n\\n /// Returns a random fixed-size byte array of length 8.\\n function randomBytes8() external view returns (bytes8);\\n\\n /// Returns a random `int256` value.\\n function randomInt() external view returns (int256);\\n\\n /// Returns a random `int256` value of given bits.\\n function randomInt(uint256 bits) external view returns (int256);\\n\\n /// Returns a random uint256 value.\\n function randomUint() external returns (uint256);\\n\\n /// Returns random uint256 value between the provided range (=min..=max).\\n function randomUint(uint256 min, uint256 max) external returns (uint256);\\n\\n /// Returns a random `uint256` value of given bits.\\n function randomUint(uint256 bits) external view returns (uint256);\\n\\n /// Unpauses collection of call traces.\\n function resumeTracing() external view;\\n\\n /// Utility cheatcode to set arbitrary storage for given target address.\\n function setArbitraryStorage(address target) external;\\n\\n /// Encodes a `bytes` value to a base64url string.\\n function toBase64URL(bytes calldata data) external pure returns (string memory);\\n\\n /// Encodes a `string` value to a base64url string.\\n function toBase64URL(string calldata data) external pure returns (string memory);\\n\\n /// Encodes a `bytes` value to a base64 string.\\n function toBase64(bytes calldata data) external pure returns (string memory);\\n\\n /// Encodes a `string` value to a base64 string.\\n function toBase64(string calldata data) external pure returns (string memory);\\n}\\n\\n/// The `Vm` interface does allow manipulation of the EVM state. These are all intended to be used\\n/// in tests, but it is not recommended to use these cheats in scripts.\\ninterface Vm is VmSafe {\\n // ======== EVM ========\\n\\n /// Utility cheatcode to set an EIP-2930 access list for all subsequent transactions.\\n function accessList(AccessListItem[] calldata access) external;\\n\\n /// Returns the identifier of the currently active fork. Reverts if no fork is currently active.\\n function activeFork() external view returns (uint256 forkId);\\n\\n /// In forking mode, explicitly grant the given address cheatcode access.\\n function allowCheatcodes(address account) external;\\n\\n /// Sets `block.blobbasefee`\\n function blobBaseFee(uint256 newBlobBaseFee) external;\\n\\n /// Sets the blobhashes in the transaction.\\n /// Not available on EVM versions before Cancun.\\n /// If used on unsupported EVM versions it will revert.\\n function blobhashes(bytes32[] calldata hashes) external;\\n\\n /// Sets `block.chainid`.\\n function chainId(uint256 newChainId) external;\\n\\n /// Clears all mocked calls.\\n function clearMockedCalls() external;\\n\\n /// Clones a source account code, state, balance and nonce to a target account and updates in-memory EVM state.\\n function cloneAccount(address source, address target) external;\\n\\n /// Sets `block.coinbase`.\\n function coinbase(address newCoinbase) external;\\n\\n /// Marks the slots of an account and the account address as cold.\\n function cool(address target) external;\\n\\n /// Utility cheatcode to mark specific storage slot as cold, simulating no prior read.\\n function coolSlot(address target, bytes32 slot) external;\\n\\n /// Creates a new fork with the given endpoint and the _latest_ block and returns the identifier of the fork.\\n function createFork(string calldata urlOrAlias) external returns (uint256 forkId);\\n\\n /// Creates a new fork with the given endpoint and block and returns the identifier of the fork.\\n function createFork(string calldata urlOrAlias, uint256 blockNumber) external returns (uint256 forkId);\\n\\n /// Creates a new fork with the given endpoint and at the block the given transaction was mined in,\\n /// replays all transaction mined in the block before the transaction, and returns the identifier of the fork.\\n function createFork(string calldata urlOrAlias, bytes32 txHash) external returns (uint256 forkId);\\n\\n /// Creates and also selects a new fork with the given endpoint and the latest block and returns the identifier of the fork.\\n function createSelectFork(string calldata urlOrAlias) external returns (uint256 forkId);\\n\\n /// Creates and also selects a new fork with the given endpoint and block and returns the identifier of the fork.\\n function createSelectFork(string calldata urlOrAlias, uint256 blockNumber) external returns (uint256 forkId);\\n\\n /// Creates and also selects new fork with the given endpoint and at the block the given transaction was mined in,\\n /// replays all transaction mined in the block before the transaction, returns the identifier of the fork.\\n function createSelectFork(string calldata urlOrAlias, bytes32 txHash) external returns (uint256 forkId);\\n\\n /// Sets an address' balance.\\n function deal(address account, uint256 newBalance) external;\\n\\n /// Removes the snapshot with the given ID created by `snapshot`.\\n /// Takes the snapshot ID to delete.\\n /// Returns `true` if the snapshot was successfully deleted.\\n /// Returns `false` if the snapshot does not exist.\\n function deleteStateSnapshot(uint256 snapshotId) external returns (bool success);\\n\\n /// Removes _all_ snapshots previously created by `snapshot`.\\n function deleteStateSnapshots() external;\\n\\n /// Sets `block.difficulty`.\\n /// Not available on EVM versions from Paris onwards. Use `prevrandao` instead.\\n /// Reverts if used on unsupported EVM versions.\\n function difficulty(uint256 newDifficulty) external;\\n\\n /// Dump a genesis JSON file's `allocs` to disk.\\n function dumpState(string calldata pathToStateJson) external;\\n\\n /// Sets an address' code.\\n function etch(address target, bytes calldata newRuntimeBytecode) external;\\n\\n /// Sets `block.basefee`.\\n function fee(uint256 newBasefee) external;\\n\\n /// Gets the blockhashes from the current transaction.\\n /// Not available on EVM versions before Cancun.\\n /// If used on unsupported EVM versions it will revert.\\n function getBlobhashes() external view returns (bytes32[] memory hashes);\\n\\n /// Returns true if the account is marked as persistent.\\n function isPersistent(address account) external view returns (bool persistent);\\n\\n /// Load a genesis JSON file's `allocs` into the in-memory EVM state.\\n function loadAllocs(string calldata pathToAllocsJson) external;\\n\\n /// Marks that the account(s) should use persistent storage across fork swaps in a multifork setup\\n /// Meaning, changes made to the state of this account will be kept when switching forks.\\n function makePersistent(address account) external;\\n\\n /// See `makePersistent(address)`.\\n function makePersistent(address account0, address account1) external;\\n\\n /// See `makePersistent(address)`.\\n function makePersistent(address account0, address account1, address account2) external;\\n\\n /// See `makePersistent(address)`.\\n function makePersistent(address[] calldata accounts) external;\\n\\n /// Reverts a call to an address with specified revert data.\\n function mockCallRevert(address callee, bytes calldata data, bytes calldata revertData) external;\\n\\n /// Reverts a call to an address with a specific `msg.value`, with specified revert data.\\n function mockCallRevert(address callee, uint256 msgValue, bytes calldata data, bytes calldata revertData)\\n external;\\n\\n /// Reverts a call to an address with specified revert data.\\n /// Overload to pass the function selector directly `token.approve.selector` instead of `abi.encodeWithSelector(token.approve.selector)`.\\n function mockCallRevert(address callee, bytes4 data, bytes calldata revertData) external;\\n\\n /// Reverts a call to an address with a specific `msg.value`, with specified revert data.\\n /// Overload to pass the function selector directly `token.approve.selector` instead of `abi.encodeWithSelector(token.approve.selector)`.\\n function mockCallRevert(address callee, uint256 msgValue, bytes4 data, bytes calldata revertData) external;\\n\\n /// Mocks a call to an address, returning specified data.\\n /// Calldata can either be strict or a partial match, e.g. if you only\\n /// pass a Solidity selector to the expected calldata, then the entire Solidity\\n /// function will be mocked.\\n function mockCall(address callee, bytes calldata data, bytes calldata returnData) external;\\n\\n /// Mocks a call to an address with a specific `msg.value`, returning specified data.\\n /// Calldata match takes precedence over `msg.value` in case of ambiguity.\\n function mockCall(address callee, uint256 msgValue, bytes calldata data, bytes calldata returnData) external;\\n\\n /// Mocks a call to an address, returning specified data.\\n /// Calldata can either be strict or a partial match, e.g. if you only\\n /// pass a Solidity selector to the expected calldata, then the entire Solidity\\n /// function will be mocked.\\n /// Overload to pass the function selector directly `token.approve.selector` instead of `abi.encodeWithSelector(token.approve.selector)`.\\n function mockCall(address callee, bytes4 data, bytes calldata returnData) external;\\n\\n /// Mocks a call to an address with a specific `msg.value`, returning specified data.\\n /// Calldata match takes precedence over `msg.value` in case of ambiguity.\\n /// Overload to pass the function selector directly `token.approve.selector` instead of `abi.encodeWithSelector(token.approve.selector)`.\\n function mockCall(address callee, uint256 msgValue, bytes4 data, bytes calldata returnData) external;\\n\\n /// Mocks multiple calls to an address, returning specified data for each call.\\n function mockCalls(address callee, bytes calldata data, bytes[] calldata returnData) external;\\n\\n /// Mocks multiple calls to an address with a specific `msg.value`, returning specified data for each call.\\n function mockCalls(address callee, uint256 msgValue, bytes calldata data, bytes[] calldata returnData) external;\\n\\n /// Whenever a call is made to `callee` with calldata `data`, this cheatcode instead calls\\n /// `target` with the same calldata. This functionality is similar to a delegate call made to\\n /// `target` contract from `callee`.\\n /// Can be used to substitute a call to a function with another implementation that captures\\n /// the primary logic of the original function but is easier to reason about.\\n /// If calldata is not a strict match then partial match by selector is attempted.\\n function mockFunction(address callee, address target, bytes calldata data) external;\\n\\n /// Utility cheatcode to remove any EIP-2930 access list set by `accessList` cheatcode.\\n function noAccessList() external;\\n\\n /// Sets the *next* call's `msg.sender` to be the input address.\\n function prank(address msgSender) external;\\n\\n /// Sets the *next* call's `msg.sender` to be the input address, and the `tx.origin` to be the second input.\\n function prank(address msgSender, address txOrigin) external;\\n\\n /// Sets the *next* delegate call's `msg.sender` to be the input address.\\n function prank(address msgSender, bool delegateCall) external;\\n\\n /// Sets the *next* delegate call's `msg.sender` to be the input address, and the `tx.origin` to be the second input.\\n function prank(address msgSender, address txOrigin, bool delegateCall) external;\\n\\n /// Sets `block.prevrandao`.\\n /// Not available on EVM versions before Paris. Use `difficulty` instead.\\n /// If used on unsupported EVM versions it will revert.\\n function prevrandao(bytes32 newPrevrandao) external;\\n\\n /// Sets `block.prevrandao`.\\n /// Not available on EVM versions before Paris. Use `difficulty` instead.\\n /// If used on unsupported EVM versions it will revert.\\n function prevrandao(uint256 newPrevrandao) external;\\n\\n /// Reads the current `msg.sender` and `tx.origin` from state and reports if there is any active caller modification.\\n function readCallers() external returns (CallerMode callerMode, address msgSender, address txOrigin);\\n\\n /// Resets the nonce of an account to 0 for EOAs and 1 for contract accounts.\\n function resetNonce(address account) external;\\n\\n /// Revert the state of the EVM to a previous snapshot\\n /// Takes the snapshot ID to revert to.\\n /// Returns `true` if the snapshot was successfully reverted.\\n /// Returns `false` if the snapshot does not exist.\\n /// **Note:** This does not automatically delete the snapshot. To delete the snapshot use `deleteStateSnapshot`.\\n function revertToState(uint256 snapshotId) external returns (bool success);\\n\\n /// Revert the state of the EVM to a previous snapshot and automatically deletes the snapshots\\n /// Takes the snapshot ID to revert to.\\n /// Returns `true` if the snapshot was successfully reverted and deleted.\\n /// Returns `false` if the snapshot does not exist.\\n function revertToStateAndDelete(uint256 snapshotId) external returns (bool success);\\n\\n /// Revokes persistent status from the address, previously added via `makePersistent`.\\n function revokePersistent(address account) external;\\n\\n /// See `revokePersistent(address)`.\\n function revokePersistent(address[] calldata accounts) external;\\n\\n /// Sets `block.height`.\\n function roll(uint256 newHeight) external;\\n\\n /// Updates the currently active fork to given block number\\n /// This is similar to `roll` but for the currently active fork.\\n function rollFork(uint256 blockNumber) external;\\n\\n /// Updates the currently active fork to given transaction. This will `rollFork` with the number\\n /// of the block the transaction was mined in and replays all transaction mined before it in the block.\\n function rollFork(bytes32 txHash) external;\\n\\n /// Updates the given fork to given block number.\\n function rollFork(uint256 forkId, uint256 blockNumber) external;\\n\\n /// Updates the given fork to block number of the given transaction and replays all transaction mined before it in the block.\\n function rollFork(uint256 forkId, bytes32 txHash) external;\\n\\n /// Takes a fork identifier created by `createFork` and sets the corresponding forked state as active.\\n function selectFork(uint256 forkId) external;\\n\\n /// Set blockhash for the current block.\\n /// It only sets the blockhash for blocks where `block.number - 256 <= number < block.number`.\\n function setBlockhash(uint256 blockNumber, bytes32 blockHash) external;\\n\\n /// Sets the nonce of an account. Must be higher than the current nonce of the account.\\n function setNonce(address account, uint64 newNonce) external;\\n\\n /// Sets the nonce of an account to an arbitrary value.\\n function setNonceUnsafe(address account, uint64 newNonce) external;\\n\\n /// Snapshot capture the gas usage of the last call by name from the callee perspective.\\n function snapshotGasLastCall(string calldata name) external returns (uint256 gasUsed);\\n\\n /// Snapshot capture the gas usage of the last call by name in a group from the callee perspective.\\n function snapshotGasLastCall(string calldata group, string calldata name) external returns (uint256 gasUsed);\\n\\n /// Snapshot the current state of the evm.\\n /// Returns the ID of the snapshot that was created.\\n /// To revert a snapshot use `revertToState`.\\n function snapshotState() external returns (uint256 snapshotId);\\n\\n /// Snapshot capture an arbitrary numerical value by name.\\n /// The group name is derived from the contract name.\\n function snapshotValue(string calldata name, uint256 value) external;\\n\\n /// Snapshot capture an arbitrary numerical value by name in a group.\\n function snapshotValue(string calldata group, string calldata name, uint256 value) external;\\n\\n /// Sets all subsequent calls' `msg.sender` to be the input address until `stopPrank` is called.\\n function startPrank(address msgSender) external;\\n\\n /// Sets all subsequent calls' `msg.sender` to be the input address until `stopPrank` is called, and the `tx.origin` to be the second input.\\n function startPrank(address msgSender, address txOrigin) external;\\n\\n /// Sets all subsequent delegate calls' `msg.sender` to be the input address until `stopPrank` is called.\\n function startPrank(address msgSender, bool delegateCall) external;\\n\\n /// Sets all subsequent delegate calls' `msg.sender` to be the input address until `stopPrank` is called, and the `tx.origin` to be the second input.\\n function startPrank(address msgSender, address txOrigin, bool delegateCall) external;\\n\\n /// Start a snapshot capture of the current gas usage by name.\\n /// The group name is derived from the contract name.\\n function startSnapshotGas(string calldata name) external;\\n\\n /// Start a snapshot capture of the current gas usage by name in a group.\\n function startSnapshotGas(string calldata group, string calldata name) external;\\n\\n /// Resets subsequent calls' `msg.sender` to be `address(this)`.\\n function stopPrank() external;\\n\\n /// Stop the snapshot capture of the current gas by latest snapshot name, capturing the gas used since the start.\\n function stopSnapshotGas() external returns (uint256 gasUsed);\\n\\n /// Stop the snapshot capture of the current gas usage by name, capturing the gas used since the start.\\n /// The group name is derived from the contract name.\\n function stopSnapshotGas(string calldata name) external returns (uint256 gasUsed);\\n\\n /// Stop the snapshot capture of the current gas usage by name in a group, capturing the gas used since the start.\\n function stopSnapshotGas(string calldata group, string calldata name) external returns (uint256 gasUsed);\\n\\n /// Stores a value to an address' storage slot.\\n function store(address target, bytes32 slot, bytes32 value) external;\\n\\n /// Fetches the given transaction from the active fork and executes it on the current state.\\n function transact(bytes32 txHash) external;\\n\\n /// Fetches the given transaction from the given fork and executes it on the current state.\\n function transact(uint256 forkId, bytes32 txHash) external;\\n\\n /// Sets `tx.gasprice`.\\n function txGasPrice(uint256 newGasPrice) external;\\n\\n /// Utility cheatcode to mark specific storage slot as warm, simulating a prior read.\\n function warmSlot(address target, bytes32 slot) external;\\n\\n /// Sets `block.timestamp`.\\n function warp(uint256 newTimestamp) external;\\n\\n /// `deleteSnapshot` is being deprecated in favor of `deleteStateSnapshot`. It will be removed in future versions.\\n function deleteSnapshot(uint256 snapshotId) external returns (bool success);\\n\\n /// `deleteSnapshots` is being deprecated in favor of `deleteStateSnapshots`. It will be removed in future versions.\\n function deleteSnapshots() external;\\n\\n /// `revertToAndDelete` is being deprecated in favor of `revertToStateAndDelete`. It will be removed in future versions.\\n function revertToAndDelete(uint256 snapshotId) external returns (bool success);\\n\\n /// `revertTo` is being deprecated in favor of `revertToState`. It will be removed in future versions.\\n function revertTo(uint256 snapshotId) external returns (bool success);\\n\\n /// `snapshot` is being deprecated in favor of `snapshotState`. It will be removed in future versions.\\n function snapshot() external returns (uint256 snapshotId);\\n\\n // ======== Testing ========\\n\\n /// Expect a call to an address with the specified `msg.value` and calldata, and a *minimum* amount of gas.\\n function expectCallMinGas(address callee, uint256 msgValue, uint64 minGas, bytes calldata data) external;\\n\\n /// Expect given number of calls to an address with the specified `msg.value` and calldata, and a *minimum* amount of gas.\\n function expectCallMinGas(address callee, uint256 msgValue, uint64 minGas, bytes calldata data, uint64 count)\\n external;\\n\\n /// Expects a call to an address with the specified calldata.\\n /// Calldata can either be a strict or a partial match.\\n function expectCall(address callee, bytes calldata data) external;\\n\\n /// Expects given number of calls to an address with the specified calldata.\\n function expectCall(address callee, bytes calldata data, uint64 count) external;\\n\\n /// Expects a call to an address with the specified `msg.value` and calldata.\\n function expectCall(address callee, uint256 msgValue, bytes calldata data) external;\\n\\n /// Expects given number of calls to an address with the specified `msg.value` and calldata.\\n function expectCall(address callee, uint256 msgValue, bytes calldata data, uint64 count) external;\\n\\n /// Expect a call to an address with the specified `msg.value`, gas, and calldata.\\n function expectCall(address callee, uint256 msgValue, uint64 gas, bytes calldata data) external;\\n\\n /// Expects given number of calls to an address with the specified `msg.value`, gas, and calldata.\\n function expectCall(address callee, uint256 msgValue, uint64 gas, bytes calldata data, uint64 count) external;\\n\\n /// Expects the deployment of the specified bytecode by the specified address using the CREATE opcode\\n function expectCreate(bytes calldata bytecode, address deployer) external;\\n\\n /// Expects the deployment of the specified bytecode by the specified address using the CREATE2 opcode\\n function expectCreate2(bytes calldata bytecode, address deployer) external;\\n\\n /// Prepare an expected anonymous log with (bool checkTopic1, bool checkTopic2, bool checkTopic3, bool checkData.).\\n /// Call this function, then emit an anonymous event, then call a function. Internally after the call, we check if\\n /// logs were emitted in the expected order with the expected topics and data (as specified by the booleans).\\n function expectEmitAnonymous(bool checkTopic0, bool checkTopic1, bool checkTopic2, bool checkTopic3, bool checkData)\\n external;\\n\\n /// Same as the previous method, but also checks supplied address against emitting contract.\\n function expectEmitAnonymous(\\n bool checkTopic0,\\n bool checkTopic1,\\n bool checkTopic2,\\n bool checkTopic3,\\n bool checkData,\\n address emitter\\n ) external;\\n\\n /// Prepare an expected anonymous log with all topic and data checks enabled.\\n /// Call this function, then emit an anonymous event, then call a function. Internally after the call, we check if\\n /// logs were emitted in the expected order with the expected topics and data.\\n function expectEmitAnonymous() external;\\n\\n /// Same as the previous method, but also checks supplied address against emitting contract.\\n function expectEmitAnonymous(address emitter) external;\\n\\n /// Prepare an expected log with (bool checkTopic1, bool checkTopic2, bool checkTopic3, bool checkData.).\\n /// Call this function, then emit an event, then call a function. Internally after the call, we check if\\n /// logs were emitted in the expected order with the expected topics and data (as specified by the booleans).\\n function expectEmit(bool checkTopic1, bool checkTopic2, bool checkTopic3, bool checkData) external;\\n\\n /// Same as the previous method, but also checks supplied address against emitting contract.\\n function expectEmit(bool checkTopic1, bool checkTopic2, bool checkTopic3, bool checkData, address emitter)\\n external;\\n\\n /// Prepare an expected log with all topic and data checks enabled.\\n /// Call this function, then emit an event, then call a function. Internally after the call, we check if\\n /// logs were emitted in the expected order with the expected topics and data.\\n function expectEmit() external;\\n\\n /// Same as the previous method, but also checks supplied address against emitting contract.\\n function expectEmit(address emitter) external;\\n\\n /// Expect a given number of logs with the provided topics.\\n function expectEmit(bool checkTopic1, bool checkTopic2, bool checkTopic3, bool checkData, uint64 count) external;\\n\\n /// Expect a given number of logs from a specific emitter with the provided topics.\\n function expectEmit(\\n bool checkTopic1,\\n bool checkTopic2,\\n bool checkTopic3,\\n bool checkData,\\n address emitter,\\n uint64 count\\n ) external;\\n\\n /// Expect a given number of logs with all topic and data checks enabled.\\n function expectEmit(uint64 count) external;\\n\\n /// Expect a given number of logs from a specific emitter with all topic and data checks enabled.\\n function expectEmit(address emitter, uint64 count) external;\\n\\n /// Expects an error on next call that starts with the revert data.\\n function expectPartialRevert(bytes4 revertData) external;\\n\\n /// Expects an error on next call to reverter address, that starts with the revert data.\\n function expectPartialRevert(bytes4 revertData, address reverter) external;\\n\\n /// Expects an error on next call with any revert data.\\n function expectRevert() external;\\n\\n /// Expects an error on next call that exactly matches the revert data.\\n function expectRevert(bytes4 revertData) external;\\n\\n /// Expects a `count` number of reverts from the upcoming calls from the reverter address that match the revert data.\\n function expectRevert(bytes4 revertData, address reverter, uint64 count) external;\\n\\n /// Expects a `count` number of reverts from the upcoming calls from the reverter address that exactly match the revert data.\\n function expectRevert(bytes calldata revertData, address reverter, uint64 count) external;\\n\\n /// Expects an error on next call that exactly matches the revert data.\\n function expectRevert(bytes calldata revertData) external;\\n\\n /// Expects an error with any revert data on next call to reverter address.\\n function expectRevert(address reverter) external;\\n\\n /// Expects an error from reverter address on next call, with any revert data.\\n function expectRevert(bytes4 revertData, address reverter) external;\\n\\n /// Expects an error from reverter address on next call, that exactly matches the revert data.\\n function expectRevert(bytes calldata revertData, address reverter) external;\\n\\n /// Expects a `count` number of reverts from the upcoming calls with any revert data or reverter.\\n function expectRevert(uint64 count) external;\\n\\n /// Expects a `count` number of reverts from the upcoming calls that match the revert data.\\n function expectRevert(bytes4 revertData, uint64 count) external;\\n\\n /// Expects a `count` number of reverts from the upcoming calls that exactly match the revert data.\\n function expectRevert(bytes calldata revertData, uint64 count) external;\\n\\n /// Expects a `count` number of reverts from the upcoming calls from the reverter address.\\n function expectRevert(address reverter, uint64 count) external;\\n\\n /// Only allows memory writes to offsets [0x00, 0x60) \\u222a [min, max) in the current subcontext. If any other\\n /// memory is written to, the test will fail. Can be called multiple times to add more ranges to the set.\\n function expectSafeMemory(uint64 min, uint64 max) external;\\n\\n /// Only allows memory writes to offsets [0x00, 0x60) \\u222a [min, max) in the next created subcontext.\\n /// If any other memory is written to, the test will fail. Can be called multiple times to add more ranges\\n /// to the set.\\n function expectSafeMemoryCall(uint64 min, uint64 max) external;\\n\\n /// Marks a test as skipped. Must be called at the top level of a test.\\n function skip(bool skipTest) external;\\n\\n /// Marks a test as skipped with a reason. Must be called at the top level of a test.\\n function skip(bool skipTest, string calldata reason) external;\\n\\n /// Stops all safe memory expectation in the current subcontext.\\n function stopExpectSafeMemory() external;\\n}\\n\",\"keccak256\":\"0xd91fb0df409fbd22463e937b48b9682d9333c5d4528d8fe7b36102a0323c44bf\",\"license\":\"MIT OR Apache-2.0\"},\"lib/forge-std/src/console.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity >=0.4.22 <0.9.0;\\n\\nlibrary console {\\n address constant CONSOLE_ADDRESS =\\n 0x000000000000000000636F6e736F6c652e6c6f67;\\n\\n function _sendLogPayloadImplementation(bytes memory payload) internal view {\\n address consoleAddress = CONSOLE_ADDRESS;\\n /// @solidity memory-safe-assembly\\n assembly {\\n pop(\\n staticcall(\\n gas(),\\n consoleAddress,\\n add(payload, 32),\\n mload(payload),\\n 0,\\n 0\\n )\\n )\\n }\\n }\\n\\n function _castToPure(\\n function(bytes memory) internal view fnIn\\n ) internal pure returns (function(bytes memory) pure fnOut) {\\n assembly {\\n fnOut := fnIn\\n }\\n }\\n\\n function _sendLogPayload(bytes memory payload) internal pure {\\n _castToPure(_sendLogPayloadImplementation)(payload);\\n }\\n\\n function log() internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log()\\\"));\\n }\\n\\n function logInt(int256 p0) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(int256)\\\", p0));\\n }\\n\\n function logUint(uint256 p0) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256)\\\", p0));\\n }\\n\\n function logString(string memory p0) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string)\\\", p0));\\n }\\n\\n function logBool(bool p0) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool)\\\", p0));\\n }\\n\\n function logAddress(address p0) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address)\\\", p0));\\n }\\n\\n function logBytes(bytes memory p0) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bytes)\\\", p0));\\n }\\n\\n function logBytes1(bytes1 p0) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bytes1)\\\", p0));\\n }\\n\\n function logBytes2(bytes2 p0) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bytes2)\\\", p0));\\n }\\n\\n function logBytes3(bytes3 p0) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bytes3)\\\", p0));\\n }\\n\\n function logBytes4(bytes4 p0) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bytes4)\\\", p0));\\n }\\n\\n function logBytes5(bytes5 p0) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bytes5)\\\", p0));\\n }\\n\\n function logBytes6(bytes6 p0) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bytes6)\\\", p0));\\n }\\n\\n function logBytes7(bytes7 p0) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bytes7)\\\", p0));\\n }\\n\\n function logBytes8(bytes8 p0) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bytes8)\\\", p0));\\n }\\n\\n function logBytes9(bytes9 p0) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bytes9)\\\", p0));\\n }\\n\\n function logBytes10(bytes10 p0) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bytes10)\\\", p0));\\n }\\n\\n function logBytes11(bytes11 p0) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bytes11)\\\", p0));\\n }\\n\\n function logBytes12(bytes12 p0) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bytes12)\\\", p0));\\n }\\n\\n function logBytes13(bytes13 p0) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bytes13)\\\", p0));\\n }\\n\\n function logBytes14(bytes14 p0) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bytes14)\\\", p0));\\n }\\n\\n function logBytes15(bytes15 p0) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bytes15)\\\", p0));\\n }\\n\\n function logBytes16(bytes16 p0) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bytes16)\\\", p0));\\n }\\n\\n function logBytes17(bytes17 p0) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bytes17)\\\", p0));\\n }\\n\\n function logBytes18(bytes18 p0) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bytes18)\\\", p0));\\n }\\n\\n function logBytes19(bytes19 p0) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bytes19)\\\", p0));\\n }\\n\\n function logBytes20(bytes20 p0) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bytes20)\\\", p0));\\n }\\n\\n function logBytes21(bytes21 p0) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bytes21)\\\", p0));\\n }\\n\\n function logBytes22(bytes22 p0) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bytes22)\\\", p0));\\n }\\n\\n function logBytes23(bytes23 p0) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bytes23)\\\", p0));\\n }\\n\\n function logBytes24(bytes24 p0) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bytes24)\\\", p0));\\n }\\n\\n function logBytes25(bytes25 p0) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bytes25)\\\", p0));\\n }\\n\\n function logBytes26(bytes26 p0) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bytes26)\\\", p0));\\n }\\n\\n function logBytes27(bytes27 p0) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bytes27)\\\", p0));\\n }\\n\\n function logBytes28(bytes28 p0) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bytes28)\\\", p0));\\n }\\n\\n function logBytes29(bytes29 p0) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bytes29)\\\", p0));\\n }\\n\\n function logBytes30(bytes30 p0) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bytes30)\\\", p0));\\n }\\n\\n function logBytes31(bytes31 p0) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bytes31)\\\", p0));\\n }\\n\\n function logBytes32(bytes32 p0) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bytes32)\\\", p0));\\n }\\n\\n function log(uint256 p0) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256)\\\", p0));\\n }\\n\\n function log(int256 p0) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(int256)\\\", p0));\\n }\\n\\n function log(string memory p0) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string)\\\", p0));\\n }\\n\\n function log(bool p0) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool)\\\", p0));\\n }\\n\\n function log(address p0) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address)\\\", p0));\\n }\\n\\n function log(uint256 p0, uint256 p1) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,uint256)\\\", p0, p1));\\n }\\n\\n function log(uint256 p0, string memory p1) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,string)\\\", p0, p1));\\n }\\n\\n function log(uint256 p0, bool p1) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,bool)\\\", p0, p1));\\n }\\n\\n function log(uint256 p0, address p1) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,address)\\\", p0, p1));\\n }\\n\\n function log(string memory p0, uint256 p1) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,uint256)\\\", p0, p1));\\n }\\n\\n function log(string memory p0, int256 p1) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,int256)\\\", p0, p1));\\n }\\n\\n function log(string memory p0, string memory p1) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,string)\\\", p0, p1));\\n }\\n\\n function log(string memory p0, bool p1) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,bool)\\\", p0, p1));\\n }\\n\\n function log(string memory p0, address p1) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,address)\\\", p0, p1));\\n }\\n\\n function log(bool p0, uint256 p1) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,uint256)\\\", p0, p1));\\n }\\n\\n function log(bool p0, string memory p1) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,string)\\\", p0, p1));\\n }\\n\\n function log(bool p0, bool p1) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,bool)\\\", p0, p1));\\n }\\n\\n function log(bool p0, address p1) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,address)\\\", p0, p1));\\n }\\n\\n function log(address p0, uint256 p1) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,uint256)\\\", p0, p1));\\n }\\n\\n function log(address p0, string memory p1) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,string)\\\", p0, p1));\\n }\\n\\n function log(address p0, bool p1) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,bool)\\\", p0, p1));\\n }\\n\\n function log(address p0, address p1) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,address)\\\", p0, p1));\\n }\\n\\n function log(uint256 p0, uint256 p1, uint256 p2) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,uint256,uint256)\\\", p0, p1, p2));\\n }\\n\\n function log(uint256 p0, uint256 p1, string memory p2) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,uint256,string)\\\", p0, p1, p2));\\n }\\n\\n function log(uint256 p0, uint256 p1, bool p2) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,uint256,bool)\\\", p0, p1, p2));\\n }\\n\\n function log(uint256 p0, uint256 p1, address p2) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,uint256,address)\\\", p0, p1, p2));\\n }\\n\\n function log(uint256 p0, string memory p1, uint256 p2) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,string,uint256)\\\", p0, p1, p2));\\n }\\n\\n function log(uint256 p0, string memory p1, string memory p2) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,string,string)\\\", p0, p1, p2));\\n }\\n\\n function log(uint256 p0, string memory p1, bool p2) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,string,bool)\\\", p0, p1, p2));\\n }\\n\\n function log(uint256 p0, string memory p1, address p2) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,string,address)\\\", p0, p1, p2));\\n }\\n\\n function log(uint256 p0, bool p1, uint256 p2) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,bool,uint256)\\\", p0, p1, p2));\\n }\\n\\n function log(uint256 p0, bool p1, string memory p2) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,bool,string)\\\", p0, p1, p2));\\n }\\n\\n function log(uint256 p0, bool p1, bool p2) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,bool,bool)\\\", p0, p1, p2));\\n }\\n\\n function log(uint256 p0, bool p1, address p2) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,bool,address)\\\", p0, p1, p2));\\n }\\n\\n function log(uint256 p0, address p1, uint256 p2) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,address,uint256)\\\", p0, p1, p2));\\n }\\n\\n function log(uint256 p0, address p1, string memory p2) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,address,string)\\\", p0, p1, p2));\\n }\\n\\n function log(uint256 p0, address p1, bool p2) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,address,bool)\\\", p0, p1, p2));\\n }\\n\\n function log(uint256 p0, address p1, address p2) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,address,address)\\\", p0, p1, p2));\\n }\\n\\n function log(string memory p0, uint256 p1, uint256 p2) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,uint256,uint256)\\\", p0, p1, p2));\\n }\\n\\n function log(string memory p0, uint256 p1, string memory p2) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,uint256,string)\\\", p0, p1, p2));\\n }\\n\\n function log(string memory p0, uint256 p1, bool p2) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,uint256,bool)\\\", p0, p1, p2));\\n }\\n\\n function log(string memory p0, uint256 p1, address p2) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,uint256,address)\\\", p0, p1, p2));\\n }\\n\\n function log(string memory p0, string memory p1, uint256 p2) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,string,uint256)\\\", p0, p1, p2));\\n }\\n\\n function log(string memory p0, string memory p1, string memory p2) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,string,string)\\\", p0, p1, p2));\\n }\\n\\n function log(string memory p0, string memory p1, bool p2) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,string,bool)\\\", p0, p1, p2));\\n }\\n\\n function log(string memory p0, string memory p1, address p2) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,string,address)\\\", p0, p1, p2));\\n }\\n\\n function log(string memory p0, bool p1, uint256 p2) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,bool,uint256)\\\", p0, p1, p2));\\n }\\n\\n function log(string memory p0, bool p1, string memory p2) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,bool,string)\\\", p0, p1, p2));\\n }\\n\\n function log(string memory p0, bool p1, bool p2) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,bool,bool)\\\", p0, p1, p2));\\n }\\n\\n function log(string memory p0, bool p1, address p2) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,bool,address)\\\", p0, p1, p2));\\n }\\n\\n function log(string memory p0, address p1, uint256 p2) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,address,uint256)\\\", p0, p1, p2));\\n }\\n\\n function log(string memory p0, address p1, string memory p2) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,address,string)\\\", p0, p1, p2));\\n }\\n\\n function log(string memory p0, address p1, bool p2) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,address,bool)\\\", p0, p1, p2));\\n }\\n\\n function log(string memory p0, address p1, address p2) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,address,address)\\\", p0, p1, p2));\\n }\\n\\n function log(bool p0, uint256 p1, uint256 p2) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,uint256,uint256)\\\", p0, p1, p2));\\n }\\n\\n function log(bool p0, uint256 p1, string memory p2) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,uint256,string)\\\", p0, p1, p2));\\n }\\n\\n function log(bool p0, uint256 p1, bool p2) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,uint256,bool)\\\", p0, p1, p2));\\n }\\n\\n function log(bool p0, uint256 p1, address p2) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,uint256,address)\\\", p0, p1, p2));\\n }\\n\\n function log(bool p0, string memory p1, uint256 p2) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,string,uint256)\\\", p0, p1, p2));\\n }\\n\\n function log(bool p0, string memory p1, string memory p2) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,string,string)\\\", p0, p1, p2));\\n }\\n\\n function log(bool p0, string memory p1, bool p2) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,string,bool)\\\", p0, p1, p2));\\n }\\n\\n function log(bool p0, string memory p1, address p2) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,string,address)\\\", p0, p1, p2));\\n }\\n\\n function log(bool p0, bool p1, uint256 p2) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,bool,uint256)\\\", p0, p1, p2));\\n }\\n\\n function log(bool p0, bool p1, string memory p2) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,bool,string)\\\", p0, p1, p2));\\n }\\n\\n function log(bool p0, bool p1, bool p2) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,bool,bool)\\\", p0, p1, p2));\\n }\\n\\n function log(bool p0, bool p1, address p2) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,bool,address)\\\", p0, p1, p2));\\n }\\n\\n function log(bool p0, address p1, uint256 p2) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,address,uint256)\\\", p0, p1, p2));\\n }\\n\\n function log(bool p0, address p1, string memory p2) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,address,string)\\\", p0, p1, p2));\\n }\\n\\n function log(bool p0, address p1, bool p2) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,address,bool)\\\", p0, p1, p2));\\n }\\n\\n function log(bool p0, address p1, address p2) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,address,address)\\\", p0, p1, p2));\\n }\\n\\n function log(address p0, uint256 p1, uint256 p2) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,uint256,uint256)\\\", p0, p1, p2));\\n }\\n\\n function log(address p0, uint256 p1, string memory p2) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,uint256,string)\\\", p0, p1, p2));\\n }\\n\\n function log(address p0, uint256 p1, bool p2) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,uint256,bool)\\\", p0, p1, p2));\\n }\\n\\n function log(address p0, uint256 p1, address p2) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,uint256,address)\\\", p0, p1, p2));\\n }\\n\\n function log(address p0, string memory p1, uint256 p2) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,string,uint256)\\\", p0, p1, p2));\\n }\\n\\n function log(address p0, string memory p1, string memory p2) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,string,string)\\\", p0, p1, p2));\\n }\\n\\n function log(address p0, string memory p1, bool p2) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,string,bool)\\\", p0, p1, p2));\\n }\\n\\n function log(address p0, string memory p1, address p2) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,string,address)\\\", p0, p1, p2));\\n }\\n\\n function log(address p0, bool p1, uint256 p2) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,bool,uint256)\\\", p0, p1, p2));\\n }\\n\\n function log(address p0, bool p1, string memory p2) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,bool,string)\\\", p0, p1, p2));\\n }\\n\\n function log(address p0, bool p1, bool p2) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,bool,bool)\\\", p0, p1, p2));\\n }\\n\\n function log(address p0, bool p1, address p2) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,bool,address)\\\", p0, p1, p2));\\n }\\n\\n function log(address p0, address p1, uint256 p2) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,address,uint256)\\\", p0, p1, p2));\\n }\\n\\n function log(address p0, address p1, string memory p2) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,address,string)\\\", p0, p1, p2));\\n }\\n\\n function log(address p0, address p1, bool p2) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,address,bool)\\\", p0, p1, p2));\\n }\\n\\n function log(address p0, address p1, address p2) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,address,address)\\\", p0, p1, p2));\\n }\\n\\n function log(uint256 p0, uint256 p1, uint256 p2, uint256 p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,uint256,uint256,uint256)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(uint256 p0, uint256 p1, uint256 p2, string memory p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,uint256,uint256,string)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(uint256 p0, uint256 p1, uint256 p2, bool p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,uint256,uint256,bool)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(uint256 p0, uint256 p1, uint256 p2, address p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,uint256,uint256,address)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(uint256 p0, uint256 p1, string memory p2, uint256 p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,uint256,string,uint256)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(uint256 p0, uint256 p1, string memory p2, string memory p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,uint256,string,string)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(uint256 p0, uint256 p1, string memory p2, bool p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,uint256,string,bool)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(uint256 p0, uint256 p1, string memory p2, address p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,uint256,string,address)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(uint256 p0, uint256 p1, bool p2, uint256 p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,uint256,bool,uint256)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(uint256 p0, uint256 p1, bool p2, string memory p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,uint256,bool,string)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(uint256 p0, uint256 p1, bool p2, bool p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,uint256,bool,bool)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(uint256 p0, uint256 p1, bool p2, address p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,uint256,bool,address)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(uint256 p0, uint256 p1, address p2, uint256 p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,uint256,address,uint256)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(uint256 p0, uint256 p1, address p2, string memory p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,uint256,address,string)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(uint256 p0, uint256 p1, address p2, bool p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,uint256,address,bool)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(uint256 p0, uint256 p1, address p2, address p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,uint256,address,address)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(uint256 p0, string memory p1, uint256 p2, uint256 p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,string,uint256,uint256)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(uint256 p0, string memory p1, uint256 p2, string memory p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,string,uint256,string)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(uint256 p0, string memory p1, uint256 p2, bool p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,string,uint256,bool)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(uint256 p0, string memory p1, uint256 p2, address p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,string,uint256,address)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(uint256 p0, string memory p1, string memory p2, uint256 p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,string,string,uint256)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(uint256 p0, string memory p1, string memory p2, string memory p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,string,string,string)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(uint256 p0, string memory p1, string memory p2, bool p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,string,string,bool)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(uint256 p0, string memory p1, string memory p2, address p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,string,string,address)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(uint256 p0, string memory p1, bool p2, uint256 p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,string,bool,uint256)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(uint256 p0, string memory p1, bool p2, string memory p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,string,bool,string)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(uint256 p0, string memory p1, bool p2, bool p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,string,bool,bool)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(uint256 p0, string memory p1, bool p2, address p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,string,bool,address)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(uint256 p0, string memory p1, address p2, uint256 p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,string,address,uint256)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(uint256 p0, string memory p1, address p2, string memory p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,string,address,string)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(uint256 p0, string memory p1, address p2, bool p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,string,address,bool)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(uint256 p0, string memory p1, address p2, address p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,string,address,address)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(uint256 p0, bool p1, uint256 p2, uint256 p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,bool,uint256,uint256)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(uint256 p0, bool p1, uint256 p2, string memory p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,bool,uint256,string)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(uint256 p0, bool p1, uint256 p2, bool p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,bool,uint256,bool)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(uint256 p0, bool p1, uint256 p2, address p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,bool,uint256,address)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(uint256 p0, bool p1, string memory p2, uint256 p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,bool,string,uint256)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(uint256 p0, bool p1, string memory p2, string memory p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,bool,string,string)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(uint256 p0, bool p1, string memory p2, bool p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,bool,string,bool)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(uint256 p0, bool p1, string memory p2, address p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,bool,string,address)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(uint256 p0, bool p1, bool p2, uint256 p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,bool,bool,uint256)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(uint256 p0, bool p1, bool p2, string memory p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,bool,bool,string)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(uint256 p0, bool p1, bool p2, bool p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,bool,bool,bool)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(uint256 p0, bool p1, bool p2, address p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,bool,bool,address)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(uint256 p0, bool p1, address p2, uint256 p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,bool,address,uint256)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(uint256 p0, bool p1, address p2, string memory p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,bool,address,string)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(uint256 p0, bool p1, address p2, bool p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,bool,address,bool)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(uint256 p0, bool p1, address p2, address p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,bool,address,address)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(uint256 p0, address p1, uint256 p2, uint256 p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,address,uint256,uint256)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(uint256 p0, address p1, uint256 p2, string memory p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,address,uint256,string)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(uint256 p0, address p1, uint256 p2, bool p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,address,uint256,bool)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(uint256 p0, address p1, uint256 p2, address p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,address,uint256,address)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(uint256 p0, address p1, string memory p2, uint256 p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,address,string,uint256)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(uint256 p0, address p1, string memory p2, string memory p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,address,string,string)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(uint256 p0, address p1, string memory p2, bool p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,address,string,bool)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(uint256 p0, address p1, string memory p2, address p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,address,string,address)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(uint256 p0, address p1, bool p2, uint256 p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,address,bool,uint256)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(uint256 p0, address p1, bool p2, string memory p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,address,bool,string)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(uint256 p0, address p1, bool p2, bool p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,address,bool,bool)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(uint256 p0, address p1, bool p2, address p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,address,bool,address)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(uint256 p0, address p1, address p2, uint256 p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,address,address,uint256)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(uint256 p0, address p1, address p2, string memory p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,address,address,string)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(uint256 p0, address p1, address p2, bool p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,address,address,bool)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(uint256 p0, address p1, address p2, address p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,address,address,address)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(string memory p0, uint256 p1, uint256 p2, uint256 p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,uint256,uint256,uint256)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(string memory p0, uint256 p1, uint256 p2, string memory p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,uint256,uint256,string)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(string memory p0, uint256 p1, uint256 p2, bool p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,uint256,uint256,bool)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(string memory p0, uint256 p1, uint256 p2, address p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,uint256,uint256,address)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(string memory p0, uint256 p1, string memory p2, uint256 p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,uint256,string,uint256)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(string memory p0, uint256 p1, string memory p2, string memory p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,uint256,string,string)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(string memory p0, uint256 p1, string memory p2, bool p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,uint256,string,bool)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(string memory p0, uint256 p1, string memory p2, address p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,uint256,string,address)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(string memory p0, uint256 p1, bool p2, uint256 p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,uint256,bool,uint256)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(string memory p0, uint256 p1, bool p2, string memory p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,uint256,bool,string)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(string memory p0, uint256 p1, bool p2, bool p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,uint256,bool,bool)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(string memory p0, uint256 p1, bool p2, address p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,uint256,bool,address)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(string memory p0, uint256 p1, address p2, uint256 p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,uint256,address,uint256)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(string memory p0, uint256 p1, address p2, string memory p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,uint256,address,string)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(string memory p0, uint256 p1, address p2, bool p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,uint256,address,bool)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(string memory p0, uint256 p1, address p2, address p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,uint256,address,address)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(string memory p0, string memory p1, uint256 p2, uint256 p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,string,uint256,uint256)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(string memory p0, string memory p1, uint256 p2, string memory p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,string,uint256,string)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(string memory p0, string memory p1, uint256 p2, bool p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,string,uint256,bool)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(string memory p0, string memory p1, uint256 p2, address p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,string,uint256,address)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(string memory p0, string memory p1, string memory p2, uint256 p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,string,string,uint256)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(string memory p0, string memory p1, string memory p2, string memory p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,string,string,string)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(string memory p0, string memory p1, string memory p2, bool p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,string,string,bool)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(string memory p0, string memory p1, string memory p2, address p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,string,string,address)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(string memory p0, string memory p1, bool p2, uint256 p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,string,bool,uint256)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(string memory p0, string memory p1, bool p2, string memory p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,string,bool,string)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(string memory p0, string memory p1, bool p2, bool p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,string,bool,bool)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(string memory p0, string memory p1, bool p2, address p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,string,bool,address)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(string memory p0, string memory p1, address p2, uint256 p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,string,address,uint256)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(string memory p0, string memory p1, address p2, string memory p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,string,address,string)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(string memory p0, string memory p1, address p2, bool p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,string,address,bool)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(string memory p0, string memory p1, address p2, address p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,string,address,address)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(string memory p0, bool p1, uint256 p2, uint256 p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,bool,uint256,uint256)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(string memory p0, bool p1, uint256 p2, string memory p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,bool,uint256,string)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(string memory p0, bool p1, uint256 p2, bool p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,bool,uint256,bool)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(string memory p0, bool p1, uint256 p2, address p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,bool,uint256,address)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(string memory p0, bool p1, string memory p2, uint256 p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,bool,string,uint256)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(string memory p0, bool p1, string memory p2, string memory p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,bool,string,string)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(string memory p0, bool p1, string memory p2, bool p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,bool,string,bool)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(string memory p0, bool p1, string memory p2, address p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,bool,string,address)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(string memory p0, bool p1, bool p2, uint256 p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,bool,bool,uint256)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(string memory p0, bool p1, bool p2, string memory p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,bool,bool,string)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(string memory p0, bool p1, bool p2, bool p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,bool,bool,bool)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(string memory p0, bool p1, bool p2, address p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,bool,bool,address)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(string memory p0, bool p1, address p2, uint256 p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,bool,address,uint256)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(string memory p0, bool p1, address p2, string memory p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,bool,address,string)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(string memory p0, bool p1, address p2, bool p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,bool,address,bool)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(string memory p0, bool p1, address p2, address p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,bool,address,address)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(string memory p0, address p1, uint256 p2, uint256 p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,address,uint256,uint256)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(string memory p0, address p1, uint256 p2, string memory p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,address,uint256,string)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(string memory p0, address p1, uint256 p2, bool p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,address,uint256,bool)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(string memory p0, address p1, uint256 p2, address p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,address,uint256,address)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(string memory p0, address p1, string memory p2, uint256 p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,address,string,uint256)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(string memory p0, address p1, string memory p2, string memory p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,address,string,string)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(string memory p0, address p1, string memory p2, bool p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,address,string,bool)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(string memory p0, address p1, string memory p2, address p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,address,string,address)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(string memory p0, address p1, bool p2, uint256 p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,address,bool,uint256)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(string memory p0, address p1, bool p2, string memory p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,address,bool,string)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(string memory p0, address p1, bool p2, bool p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,address,bool,bool)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(string memory p0, address p1, bool p2, address p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,address,bool,address)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(string memory p0, address p1, address p2, uint256 p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,address,address,uint256)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(string memory p0, address p1, address p2, string memory p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,address,address,string)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(string memory p0, address p1, address p2, bool p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,address,address,bool)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(string memory p0, address p1, address p2, address p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,address,address,address)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(bool p0, uint256 p1, uint256 p2, uint256 p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,uint256,uint256,uint256)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(bool p0, uint256 p1, uint256 p2, string memory p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,uint256,uint256,string)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(bool p0, uint256 p1, uint256 p2, bool p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,uint256,uint256,bool)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(bool p0, uint256 p1, uint256 p2, address p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,uint256,uint256,address)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(bool p0, uint256 p1, string memory p2, uint256 p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,uint256,string,uint256)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(bool p0, uint256 p1, string memory p2, string memory p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,uint256,string,string)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(bool p0, uint256 p1, string memory p2, bool p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,uint256,string,bool)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(bool p0, uint256 p1, string memory p2, address p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,uint256,string,address)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(bool p0, uint256 p1, bool p2, uint256 p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,uint256,bool,uint256)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(bool p0, uint256 p1, bool p2, string memory p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,uint256,bool,string)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(bool p0, uint256 p1, bool p2, bool p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,uint256,bool,bool)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(bool p0, uint256 p1, bool p2, address p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,uint256,bool,address)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(bool p0, uint256 p1, address p2, uint256 p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,uint256,address,uint256)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(bool p0, uint256 p1, address p2, string memory p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,uint256,address,string)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(bool p0, uint256 p1, address p2, bool p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,uint256,address,bool)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(bool p0, uint256 p1, address p2, address p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,uint256,address,address)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(bool p0, string memory p1, uint256 p2, uint256 p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,string,uint256,uint256)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(bool p0, string memory p1, uint256 p2, string memory p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,string,uint256,string)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(bool p0, string memory p1, uint256 p2, bool p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,string,uint256,bool)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(bool p0, string memory p1, uint256 p2, address p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,string,uint256,address)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(bool p0, string memory p1, string memory p2, uint256 p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,string,string,uint256)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(bool p0, string memory p1, string memory p2, string memory p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,string,string,string)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(bool p0, string memory p1, string memory p2, bool p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,string,string,bool)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(bool p0, string memory p1, string memory p2, address p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,string,string,address)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(bool p0, string memory p1, bool p2, uint256 p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,string,bool,uint256)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(bool p0, string memory p1, bool p2, string memory p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,string,bool,string)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(bool p0, string memory p1, bool p2, bool p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,string,bool,bool)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(bool p0, string memory p1, bool p2, address p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,string,bool,address)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(bool p0, string memory p1, address p2, uint256 p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,string,address,uint256)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(bool p0, string memory p1, address p2, string memory p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,string,address,string)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(bool p0, string memory p1, address p2, bool p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,string,address,bool)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(bool p0, string memory p1, address p2, address p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,string,address,address)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(bool p0, bool p1, uint256 p2, uint256 p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,bool,uint256,uint256)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(bool p0, bool p1, uint256 p2, string memory p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,bool,uint256,string)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(bool p0, bool p1, uint256 p2, bool p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,bool,uint256,bool)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(bool p0, bool p1, uint256 p2, address p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,bool,uint256,address)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(bool p0, bool p1, string memory p2, uint256 p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,bool,string,uint256)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(bool p0, bool p1, string memory p2, string memory p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,bool,string,string)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(bool p0, bool p1, string memory p2, bool p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,bool,string,bool)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(bool p0, bool p1, string memory p2, address p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,bool,string,address)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(bool p0, bool p1, bool p2, uint256 p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,bool,bool,uint256)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(bool p0, bool p1, bool p2, string memory p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,bool,bool,string)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(bool p0, bool p1, bool p2, bool p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,bool,bool,bool)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(bool p0, bool p1, bool p2, address p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,bool,bool,address)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(bool p0, bool p1, address p2, uint256 p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,bool,address,uint256)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(bool p0, bool p1, address p2, string memory p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,bool,address,string)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(bool p0, bool p1, address p2, bool p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,bool,address,bool)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(bool p0, bool p1, address p2, address p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,bool,address,address)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(bool p0, address p1, uint256 p2, uint256 p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,address,uint256,uint256)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(bool p0, address p1, uint256 p2, string memory p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,address,uint256,string)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(bool p0, address p1, uint256 p2, bool p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,address,uint256,bool)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(bool p0, address p1, uint256 p2, address p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,address,uint256,address)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(bool p0, address p1, string memory p2, uint256 p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,address,string,uint256)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(bool p0, address p1, string memory p2, string memory p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,address,string,string)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(bool p0, address p1, string memory p2, bool p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,address,string,bool)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(bool p0, address p1, string memory p2, address p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,address,string,address)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(bool p0, address p1, bool p2, uint256 p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,address,bool,uint256)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(bool p0, address p1, bool p2, string memory p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,address,bool,string)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(bool p0, address p1, bool p2, bool p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,address,bool,bool)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(bool p0, address p1, bool p2, address p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,address,bool,address)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(bool p0, address p1, address p2, uint256 p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,address,address,uint256)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(bool p0, address p1, address p2, string memory p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,address,address,string)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(bool p0, address p1, address p2, bool p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,address,address,bool)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(bool p0, address p1, address p2, address p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,address,address,address)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(address p0, uint256 p1, uint256 p2, uint256 p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,uint256,uint256,uint256)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(address p0, uint256 p1, uint256 p2, string memory p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,uint256,uint256,string)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(address p0, uint256 p1, uint256 p2, bool p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,uint256,uint256,bool)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(address p0, uint256 p1, uint256 p2, address p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,uint256,uint256,address)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(address p0, uint256 p1, string memory p2, uint256 p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,uint256,string,uint256)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(address p0, uint256 p1, string memory p2, string memory p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,uint256,string,string)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(address p0, uint256 p1, string memory p2, bool p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,uint256,string,bool)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(address p0, uint256 p1, string memory p2, address p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,uint256,string,address)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(address p0, uint256 p1, bool p2, uint256 p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,uint256,bool,uint256)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(address p0, uint256 p1, bool p2, string memory p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,uint256,bool,string)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(address p0, uint256 p1, bool p2, bool p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,uint256,bool,bool)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(address p0, uint256 p1, bool p2, address p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,uint256,bool,address)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(address p0, uint256 p1, address p2, uint256 p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,uint256,address,uint256)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(address p0, uint256 p1, address p2, string memory p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,uint256,address,string)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(address p0, uint256 p1, address p2, bool p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,uint256,address,bool)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(address p0, uint256 p1, address p2, address p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,uint256,address,address)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(address p0, string memory p1, uint256 p2, uint256 p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,string,uint256,uint256)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(address p0, string memory p1, uint256 p2, string memory p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,string,uint256,string)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(address p0, string memory p1, uint256 p2, bool p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,string,uint256,bool)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(address p0, string memory p1, uint256 p2, address p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,string,uint256,address)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(address p0, string memory p1, string memory p2, uint256 p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,string,string,uint256)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(address p0, string memory p1, string memory p2, string memory p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,string,string,string)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(address p0, string memory p1, string memory p2, bool p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,string,string,bool)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(address p0, string memory p1, string memory p2, address p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,string,string,address)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(address p0, string memory p1, bool p2, uint256 p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,string,bool,uint256)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(address p0, string memory p1, bool p2, string memory p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,string,bool,string)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(address p0, string memory p1, bool p2, bool p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,string,bool,bool)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(address p0, string memory p1, bool p2, address p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,string,bool,address)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(address p0, string memory p1, address p2, uint256 p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,string,address,uint256)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(address p0, string memory p1, address p2, string memory p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,string,address,string)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(address p0, string memory p1, address p2, bool p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,string,address,bool)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(address p0, string memory p1, address p2, address p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,string,address,address)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(address p0, bool p1, uint256 p2, uint256 p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,bool,uint256,uint256)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(address p0, bool p1, uint256 p2, string memory p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,bool,uint256,string)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(address p0, bool p1, uint256 p2, bool p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,bool,uint256,bool)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(address p0, bool p1, uint256 p2, address p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,bool,uint256,address)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(address p0, bool p1, string memory p2, uint256 p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,bool,string,uint256)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(address p0, bool p1, string memory p2, string memory p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,bool,string,string)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(address p0, bool p1, string memory p2, bool p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,bool,string,bool)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(address p0, bool p1, string memory p2, address p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,bool,string,address)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(address p0, bool p1, bool p2, uint256 p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,bool,bool,uint256)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(address p0, bool p1, bool p2, string memory p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,bool,bool,string)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(address p0, bool p1, bool p2, bool p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,bool,bool,bool)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(address p0, bool p1, bool p2, address p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,bool,bool,address)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(address p0, bool p1, address p2, uint256 p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,bool,address,uint256)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(address p0, bool p1, address p2, string memory p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,bool,address,string)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(address p0, bool p1, address p2, bool p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,bool,address,bool)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(address p0, bool p1, address p2, address p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,bool,address,address)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(address p0, address p1, uint256 p2, uint256 p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,address,uint256,uint256)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(address p0, address p1, uint256 p2, string memory p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,address,uint256,string)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(address p0, address p1, uint256 p2, bool p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,address,uint256,bool)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(address p0, address p1, uint256 p2, address p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,address,uint256,address)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(address p0, address p1, string memory p2, uint256 p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,address,string,uint256)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(address p0, address p1, string memory p2, string memory p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,address,string,string)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(address p0, address p1, string memory p2, bool p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,address,string,bool)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(address p0, address p1, string memory p2, address p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,address,string,address)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(address p0, address p1, bool p2, uint256 p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,address,bool,uint256)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(address p0, address p1, bool p2, string memory p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,address,bool,string)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(address p0, address p1, bool p2, bool p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,address,bool,bool)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(address p0, address p1, bool p2, address p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,address,bool,address)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(address p0, address p1, address p2, uint256 p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,address,address,uint256)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(address p0, address p1, address p2, string memory p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,address,address,string)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(address p0, address p1, address p2, bool p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,address,address,bool)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(address p0, address p1, address p2, address p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,address,address,address)\\\", p0, p1, p2, p3));\\n }\\n}\\n\",\"keccak256\":\"0x4bbf47eb762cef93729d6ef15e78789957147039b113e5d4df48e3d3fd16d0f5\",\"license\":\"MIT\"},\"lib/forge-std/src/console2.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity >=0.4.22 <0.9.0;\\n\\nimport {console as console2} from \\\"./console.sol\\\";\\n\",\"keccak256\":\"0x3b8fe79f48f065a4e4d35362171304a33784c3a90febae5f2787805a438de12f\",\"license\":\"MIT\"},\"lib/forge-std/src/interfaces/IMulticall3.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity >=0.6.2 <0.9.0;\\n\\npragma experimental ABIEncoderV2;\\n\\ninterface IMulticall3 {\\n struct Call {\\n address target;\\n bytes callData;\\n }\\n\\n struct Call3 {\\n address target;\\n bool allowFailure;\\n bytes callData;\\n }\\n\\n struct Call3Value {\\n address target;\\n bool allowFailure;\\n uint256 value;\\n bytes callData;\\n }\\n\\n struct Result {\\n bool success;\\n bytes returnData;\\n }\\n\\n function aggregate(Call[] calldata calls)\\n external\\n payable\\n returns (uint256 blockNumber, bytes[] memory returnData);\\n\\n function aggregate3(Call3[] calldata calls) external payable returns (Result[] memory returnData);\\n\\n function aggregate3Value(Call3Value[] calldata calls) external payable returns (Result[] memory returnData);\\n\\n function blockAndAggregate(Call[] calldata calls)\\n external\\n payable\\n returns (uint256 blockNumber, bytes32 blockHash, Result[] memory returnData);\\n\\n function getBasefee() external view returns (uint256 basefee);\\n\\n function getBlockHash(uint256 blockNumber) external view returns (bytes32 blockHash);\\n\\n function getBlockNumber() external view returns (uint256 blockNumber);\\n\\n function getChainId() external view returns (uint256 chainid);\\n\\n function getCurrentBlockCoinbase() external view returns (address coinbase);\\n\\n function getCurrentBlockDifficulty() external view returns (uint256 difficulty);\\n\\n function getCurrentBlockGasLimit() external view returns (uint256 gaslimit);\\n\\n function getCurrentBlockTimestamp() external view returns (uint256 timestamp);\\n\\n function getEthBalance(address addr) external view returns (uint256 balance);\\n\\n function getLastBlockHash() external view returns (bytes32 blockHash);\\n\\n function tryAggregate(bool requireSuccess, Call[] calldata calls)\\n external\\n payable\\n returns (Result[] memory returnData);\\n\\n function tryBlockAndAggregate(bool requireSuccess, Call[] calldata calls)\\n external\\n payable\\n returns (uint256 blockNumber, bytes32 blockHash, Result[] memory returnData);\\n}\\n\",\"keccak256\":\"0x7aac1389150499a922d1f9ef5749c908cef127cb2075b92fa17e9cb611263d0a\",\"license\":\"MIT\"},\"lib/forge-std/src/safeconsole.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity >=0.6.2 <0.9.0;\\n\\n/// @author philogy \\n/// @dev Code generated automatically by script.\\nlibrary safeconsole {\\n uint256 constant CONSOLE_ADDR = 0x000000000000000000000000000000000000000000636F6e736F6c652e6c6f67;\\n\\n // Credit to [0age](https://twitter.com/z0age/status/1654922202930888704) and [0xdapper](https://github.com/foundry-rs/forge-std/pull/374)\\n // for the view-to-pure log trick.\\n function _sendLogPayload(uint256 offset, uint256 size) private pure {\\n function(uint256, uint256) internal view fnIn = _sendLogPayloadView;\\n function(uint256, uint256) internal pure pureSendLogPayload;\\n /// @solidity memory-safe-assembly\\n assembly {\\n pureSendLogPayload := fnIn\\n }\\n pureSendLogPayload(offset, size);\\n }\\n\\n function _sendLogPayloadView(uint256 offset, uint256 size) private view {\\n /// @solidity memory-safe-assembly\\n assembly {\\n pop(staticcall(gas(), CONSOLE_ADDR, offset, size, 0x0, 0x0))\\n }\\n }\\n\\n function _memcopy(uint256 fromOffset, uint256 toOffset, uint256 length) private pure {\\n function(uint256, uint256, uint256) internal view fnIn = _memcopyView;\\n function(uint256, uint256, uint256) internal pure pureMemcopy;\\n /// @solidity memory-safe-assembly\\n assembly {\\n pureMemcopy := fnIn\\n }\\n pureMemcopy(fromOffset, toOffset, length);\\n }\\n\\n function _memcopyView(uint256 fromOffset, uint256 toOffset, uint256 length) private view {\\n /// @solidity memory-safe-assembly\\n assembly {\\n pop(staticcall(gas(), 0x4, fromOffset, length, toOffset, length))\\n }\\n }\\n\\n function logMemory(uint256 offset, uint256 length) internal pure {\\n if (offset >= 0x60) {\\n // Sufficient memory before slice to prepare call header.\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(sub(offset, 0x60))\\n m1 := mload(sub(offset, 0x40))\\n m2 := mload(sub(offset, 0x20))\\n // Selector of `log(bytes)`.\\n mstore(sub(offset, 0x60), 0x0be77f56)\\n mstore(sub(offset, 0x40), 0x20)\\n mstore(sub(offset, 0x20), length)\\n }\\n _sendLogPayload(offset - 0x44, length + 0x44);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(sub(offset, 0x60), m0)\\n mstore(sub(offset, 0x40), m1)\\n mstore(sub(offset, 0x20), m2)\\n }\\n } else {\\n // Insufficient space, so copy slice forward, add header and reverse.\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n uint256 endOffset = offset + length;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(add(endOffset, 0x00))\\n m1 := mload(add(endOffset, 0x20))\\n m2 := mload(add(endOffset, 0x40))\\n }\\n _memcopy(offset, offset + 0x60, length);\\n /// @solidity memory-safe-assembly\\n assembly {\\n // Selector of `log(bytes)`.\\n mstore(add(offset, 0x00), 0x0be77f56)\\n mstore(add(offset, 0x20), 0x20)\\n mstore(add(offset, 0x40), length)\\n }\\n _sendLogPayload(offset + 0x1c, length + 0x44);\\n _memcopy(offset + 0x60, offset, length);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(add(endOffset, 0x00), m0)\\n mstore(add(endOffset, 0x20), m1)\\n mstore(add(endOffset, 0x40), m2)\\n }\\n }\\n }\\n\\n function log(address p0) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n // Selector of `log(address)`.\\n mstore(0x00, 0x2c2ecbc2)\\n mstore(0x20, p0)\\n }\\n _sendLogPayload(0x1c, 0x24);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n }\\n }\\n\\n function log(bool p0) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n // Selector of `log(bool)`.\\n mstore(0x00, 0x32458eed)\\n mstore(0x20, p0)\\n }\\n _sendLogPayload(0x1c, 0x24);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n }\\n }\\n\\n function log(uint256 p0) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n // Selector of `log(uint256)`.\\n mstore(0x00, 0xf82c50f1)\\n mstore(0x20, p0)\\n }\\n _sendLogPayload(0x1c, 0x24);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n }\\n }\\n\\n function log(bytes32 p0) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n // Selector of `log(string)`.\\n mstore(0x00, 0x41304fac)\\n mstore(0x20, 0x20)\\n writeString(0x40, p0)\\n }\\n _sendLogPayload(0x1c, 0x64);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n }\\n }\\n\\n function log(address p0, address p1) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n // Selector of `log(address,address)`.\\n mstore(0x00, 0xdaf0d4aa)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n }\\n _sendLogPayload(0x1c, 0x44);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n }\\n }\\n\\n function log(address p0, bool p1) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n // Selector of `log(address,bool)`.\\n mstore(0x00, 0x75b605d3)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n }\\n _sendLogPayload(0x1c, 0x44);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n }\\n }\\n\\n function log(address p0, uint256 p1) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n // Selector of `log(address,uint256)`.\\n mstore(0x00, 0x8309e8a8)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n }\\n _sendLogPayload(0x1c, 0x44);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n }\\n }\\n\\n function log(address p0, bytes32 p1) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(address,string)`.\\n mstore(0x00, 0x759f86bb)\\n mstore(0x20, p0)\\n mstore(0x40, 0x40)\\n writeString(0x60, p1)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(bool p0, address p1) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n // Selector of `log(bool,address)`.\\n mstore(0x00, 0x853c4849)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n }\\n _sendLogPayload(0x1c, 0x44);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n }\\n }\\n\\n function log(bool p0, bool p1) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n // Selector of `log(bool,bool)`.\\n mstore(0x00, 0x2a110e83)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n }\\n _sendLogPayload(0x1c, 0x44);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n }\\n }\\n\\n function log(bool p0, uint256 p1) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n // Selector of `log(bool,uint256)`.\\n mstore(0x00, 0x399174d3)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n }\\n _sendLogPayload(0x1c, 0x44);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n }\\n }\\n\\n function log(bool p0, bytes32 p1) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(bool,string)`.\\n mstore(0x00, 0x8feac525)\\n mstore(0x20, p0)\\n mstore(0x40, 0x40)\\n writeString(0x60, p1)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(uint256 p0, address p1) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n // Selector of `log(uint256,address)`.\\n mstore(0x00, 0x69276c86)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n }\\n _sendLogPayload(0x1c, 0x44);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n }\\n }\\n\\n function log(uint256 p0, bool p1) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n // Selector of `log(uint256,bool)`.\\n mstore(0x00, 0x1c9d7eb3)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n }\\n _sendLogPayload(0x1c, 0x44);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n }\\n }\\n\\n function log(uint256 p0, uint256 p1) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n // Selector of `log(uint256,uint256)`.\\n mstore(0x00, 0xf666715a)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n }\\n _sendLogPayload(0x1c, 0x44);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n }\\n }\\n\\n function log(uint256 p0, bytes32 p1) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(uint256,string)`.\\n mstore(0x00, 0x643fd0df)\\n mstore(0x20, p0)\\n mstore(0x40, 0x40)\\n writeString(0x60, p1)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(bytes32 p0, address p1) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(string,address)`.\\n mstore(0x00, 0x319af333)\\n mstore(0x20, 0x40)\\n mstore(0x40, p1)\\n writeString(0x60, p0)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(bytes32 p0, bool p1) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(string,bool)`.\\n mstore(0x00, 0xc3b55635)\\n mstore(0x20, 0x40)\\n mstore(0x40, p1)\\n writeString(0x60, p0)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(bytes32 p0, uint256 p1) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(string,uint256)`.\\n mstore(0x00, 0xb60e72cc)\\n mstore(0x20, 0x40)\\n mstore(0x40, p1)\\n writeString(0x60, p0)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(bytes32 p0, bytes32 p1) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(string,string)`.\\n mstore(0x00, 0x4b5c4277)\\n mstore(0x20, 0x40)\\n mstore(0x40, 0x80)\\n writeString(0x60, p0)\\n writeString(0xa0, p1)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(address p0, address p1, address p2) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n // Selector of `log(address,address,address)`.\\n mstore(0x00, 0x018c84c2)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n }\\n _sendLogPayload(0x1c, 0x64);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n }\\n }\\n\\n function log(address p0, address p1, bool p2) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n // Selector of `log(address,address,bool)`.\\n mstore(0x00, 0xf2a66286)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n }\\n _sendLogPayload(0x1c, 0x64);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n }\\n }\\n\\n function log(address p0, address p1, uint256 p2) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n // Selector of `log(address,address,uint256)`.\\n mstore(0x00, 0x17fe6185)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n }\\n _sendLogPayload(0x1c, 0x64);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n }\\n }\\n\\n function log(address p0, address p1, bytes32 p2) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n // Selector of `log(address,address,string)`.\\n mstore(0x00, 0x007150be)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, 0x60)\\n writeString(0x80, p2)\\n }\\n _sendLogPayload(0x1c, 0xa4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n }\\n }\\n\\n function log(address p0, bool p1, address p2) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n // Selector of `log(address,bool,address)`.\\n mstore(0x00, 0xf11699ed)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n }\\n _sendLogPayload(0x1c, 0x64);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n }\\n }\\n\\n function log(address p0, bool p1, bool p2) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n // Selector of `log(address,bool,bool)`.\\n mstore(0x00, 0xeb830c92)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n }\\n _sendLogPayload(0x1c, 0x64);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n }\\n }\\n\\n function log(address p0, bool p1, uint256 p2) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n // Selector of `log(address,bool,uint256)`.\\n mstore(0x00, 0x9c4f99fb)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n }\\n _sendLogPayload(0x1c, 0x64);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n }\\n }\\n\\n function log(address p0, bool p1, bytes32 p2) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n // Selector of `log(address,bool,string)`.\\n mstore(0x00, 0x212255cc)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, 0x60)\\n writeString(0x80, p2)\\n }\\n _sendLogPayload(0x1c, 0xa4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n }\\n }\\n\\n function log(address p0, uint256 p1, address p2) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n // Selector of `log(address,uint256,address)`.\\n mstore(0x00, 0x7bc0d848)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n }\\n _sendLogPayload(0x1c, 0x64);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n }\\n }\\n\\n function log(address p0, uint256 p1, bool p2) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n // Selector of `log(address,uint256,bool)`.\\n mstore(0x00, 0x678209a8)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n }\\n _sendLogPayload(0x1c, 0x64);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n }\\n }\\n\\n function log(address p0, uint256 p1, uint256 p2) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n // Selector of `log(address,uint256,uint256)`.\\n mstore(0x00, 0xb69bcaf6)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n }\\n _sendLogPayload(0x1c, 0x64);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n }\\n }\\n\\n function log(address p0, uint256 p1, bytes32 p2) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n // Selector of `log(address,uint256,string)`.\\n mstore(0x00, 0xa1f2e8aa)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, 0x60)\\n writeString(0x80, p2)\\n }\\n _sendLogPayload(0x1c, 0xa4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n }\\n }\\n\\n function log(address p0, bytes32 p1, address p2) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n // Selector of `log(address,string,address)`.\\n mstore(0x00, 0xf08744e8)\\n mstore(0x20, p0)\\n mstore(0x40, 0x60)\\n mstore(0x60, p2)\\n writeString(0x80, p1)\\n }\\n _sendLogPayload(0x1c, 0xa4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n }\\n }\\n\\n function log(address p0, bytes32 p1, bool p2) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n // Selector of `log(address,string,bool)`.\\n mstore(0x00, 0xcf020fb1)\\n mstore(0x20, p0)\\n mstore(0x40, 0x60)\\n mstore(0x60, p2)\\n writeString(0x80, p1)\\n }\\n _sendLogPayload(0x1c, 0xa4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n }\\n }\\n\\n function log(address p0, bytes32 p1, uint256 p2) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n // Selector of `log(address,string,uint256)`.\\n mstore(0x00, 0x67dd6ff1)\\n mstore(0x20, p0)\\n mstore(0x40, 0x60)\\n mstore(0x60, p2)\\n writeString(0x80, p1)\\n }\\n _sendLogPayload(0x1c, 0xa4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n }\\n }\\n\\n function log(address p0, bytes32 p1, bytes32 p2) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n // Selector of `log(address,string,string)`.\\n mstore(0x00, 0xfb772265)\\n mstore(0x20, p0)\\n mstore(0x40, 0x60)\\n mstore(0x60, 0xa0)\\n writeString(0x80, p1)\\n writeString(0xc0, p2)\\n }\\n _sendLogPayload(0x1c, 0xe4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n }\\n }\\n\\n function log(bool p0, address p1, address p2) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n // Selector of `log(bool,address,address)`.\\n mstore(0x00, 0xd2763667)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n }\\n _sendLogPayload(0x1c, 0x64);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n }\\n }\\n\\n function log(bool p0, address p1, bool p2) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n // Selector of `log(bool,address,bool)`.\\n mstore(0x00, 0x18c9c746)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n }\\n _sendLogPayload(0x1c, 0x64);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n }\\n }\\n\\n function log(bool p0, address p1, uint256 p2) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n // Selector of `log(bool,address,uint256)`.\\n mstore(0x00, 0x5f7b9afb)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n }\\n _sendLogPayload(0x1c, 0x64);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n }\\n }\\n\\n function log(bool p0, address p1, bytes32 p2) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n // Selector of `log(bool,address,string)`.\\n mstore(0x00, 0xde9a9270)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, 0x60)\\n writeString(0x80, p2)\\n }\\n _sendLogPayload(0x1c, 0xa4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n }\\n }\\n\\n function log(bool p0, bool p1, address p2) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n // Selector of `log(bool,bool,address)`.\\n mstore(0x00, 0x1078f68d)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n }\\n _sendLogPayload(0x1c, 0x64);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n }\\n }\\n\\n function log(bool p0, bool p1, bool p2) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n // Selector of `log(bool,bool,bool)`.\\n mstore(0x00, 0x50709698)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n }\\n _sendLogPayload(0x1c, 0x64);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n }\\n }\\n\\n function log(bool p0, bool p1, uint256 p2) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n // Selector of `log(bool,bool,uint256)`.\\n mstore(0x00, 0x12f21602)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n }\\n _sendLogPayload(0x1c, 0x64);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n }\\n }\\n\\n function log(bool p0, bool p1, bytes32 p2) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n // Selector of `log(bool,bool,string)`.\\n mstore(0x00, 0x2555fa46)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, 0x60)\\n writeString(0x80, p2)\\n }\\n _sendLogPayload(0x1c, 0xa4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n }\\n }\\n\\n function log(bool p0, uint256 p1, address p2) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n // Selector of `log(bool,uint256,address)`.\\n mstore(0x00, 0x088ef9d2)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n }\\n _sendLogPayload(0x1c, 0x64);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n }\\n }\\n\\n function log(bool p0, uint256 p1, bool p2) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n // Selector of `log(bool,uint256,bool)`.\\n mstore(0x00, 0xe8defba9)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n }\\n _sendLogPayload(0x1c, 0x64);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n }\\n }\\n\\n function log(bool p0, uint256 p1, uint256 p2) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n // Selector of `log(bool,uint256,uint256)`.\\n mstore(0x00, 0x37103367)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n }\\n _sendLogPayload(0x1c, 0x64);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n }\\n }\\n\\n function log(bool p0, uint256 p1, bytes32 p2) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n // Selector of `log(bool,uint256,string)`.\\n mstore(0x00, 0xc3fc3970)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, 0x60)\\n writeString(0x80, p2)\\n }\\n _sendLogPayload(0x1c, 0xa4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n }\\n }\\n\\n function log(bool p0, bytes32 p1, address p2) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n // Selector of `log(bool,string,address)`.\\n mstore(0x00, 0x9591b953)\\n mstore(0x20, p0)\\n mstore(0x40, 0x60)\\n mstore(0x60, p2)\\n writeString(0x80, p1)\\n }\\n _sendLogPayload(0x1c, 0xa4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n }\\n }\\n\\n function log(bool p0, bytes32 p1, bool p2) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n // Selector of `log(bool,string,bool)`.\\n mstore(0x00, 0xdbb4c247)\\n mstore(0x20, p0)\\n mstore(0x40, 0x60)\\n mstore(0x60, p2)\\n writeString(0x80, p1)\\n }\\n _sendLogPayload(0x1c, 0xa4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n }\\n }\\n\\n function log(bool p0, bytes32 p1, uint256 p2) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n // Selector of `log(bool,string,uint256)`.\\n mstore(0x00, 0x1093ee11)\\n mstore(0x20, p0)\\n mstore(0x40, 0x60)\\n mstore(0x60, p2)\\n writeString(0x80, p1)\\n }\\n _sendLogPayload(0x1c, 0xa4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n }\\n }\\n\\n function log(bool p0, bytes32 p1, bytes32 p2) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n // Selector of `log(bool,string,string)`.\\n mstore(0x00, 0xb076847f)\\n mstore(0x20, p0)\\n mstore(0x40, 0x60)\\n mstore(0x60, 0xa0)\\n writeString(0x80, p1)\\n writeString(0xc0, p2)\\n }\\n _sendLogPayload(0x1c, 0xe4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n }\\n }\\n\\n function log(uint256 p0, address p1, address p2) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n // Selector of `log(uint256,address,address)`.\\n mstore(0x00, 0xbcfd9be0)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n }\\n _sendLogPayload(0x1c, 0x64);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n }\\n }\\n\\n function log(uint256 p0, address p1, bool p2) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n // Selector of `log(uint256,address,bool)`.\\n mstore(0x00, 0x9b6ec042)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n }\\n _sendLogPayload(0x1c, 0x64);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n }\\n }\\n\\n function log(uint256 p0, address p1, uint256 p2) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n // Selector of `log(uint256,address,uint256)`.\\n mstore(0x00, 0x5a9b5ed5)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n }\\n _sendLogPayload(0x1c, 0x64);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n }\\n }\\n\\n function log(uint256 p0, address p1, bytes32 p2) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n // Selector of `log(uint256,address,string)`.\\n mstore(0x00, 0x63cb41f9)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, 0x60)\\n writeString(0x80, p2)\\n }\\n _sendLogPayload(0x1c, 0xa4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n }\\n }\\n\\n function log(uint256 p0, bool p1, address p2) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n // Selector of `log(uint256,bool,address)`.\\n mstore(0x00, 0x35085f7b)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n }\\n _sendLogPayload(0x1c, 0x64);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n }\\n }\\n\\n function log(uint256 p0, bool p1, bool p2) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n // Selector of `log(uint256,bool,bool)`.\\n mstore(0x00, 0x20718650)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n }\\n _sendLogPayload(0x1c, 0x64);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n }\\n }\\n\\n function log(uint256 p0, bool p1, uint256 p2) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n // Selector of `log(uint256,bool,uint256)`.\\n mstore(0x00, 0x20098014)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n }\\n _sendLogPayload(0x1c, 0x64);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n }\\n }\\n\\n function log(uint256 p0, bool p1, bytes32 p2) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n // Selector of `log(uint256,bool,string)`.\\n mstore(0x00, 0x85775021)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, 0x60)\\n writeString(0x80, p2)\\n }\\n _sendLogPayload(0x1c, 0xa4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n }\\n }\\n\\n function log(uint256 p0, uint256 p1, address p2) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n // Selector of `log(uint256,uint256,address)`.\\n mstore(0x00, 0x5c96b331)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n }\\n _sendLogPayload(0x1c, 0x64);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n }\\n }\\n\\n function log(uint256 p0, uint256 p1, bool p2) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n // Selector of `log(uint256,uint256,bool)`.\\n mstore(0x00, 0x4766da72)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n }\\n _sendLogPayload(0x1c, 0x64);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n }\\n }\\n\\n function log(uint256 p0, uint256 p1, uint256 p2) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n // Selector of `log(uint256,uint256,uint256)`.\\n mstore(0x00, 0xd1ed7a3c)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n }\\n _sendLogPayload(0x1c, 0x64);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n }\\n }\\n\\n function log(uint256 p0, uint256 p1, bytes32 p2) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n // Selector of `log(uint256,uint256,string)`.\\n mstore(0x00, 0x71d04af2)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, 0x60)\\n writeString(0x80, p2)\\n }\\n _sendLogPayload(0x1c, 0xa4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n }\\n }\\n\\n function log(uint256 p0, bytes32 p1, address p2) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n // Selector of `log(uint256,string,address)`.\\n mstore(0x00, 0x7afac959)\\n mstore(0x20, p0)\\n mstore(0x40, 0x60)\\n mstore(0x60, p2)\\n writeString(0x80, p1)\\n }\\n _sendLogPayload(0x1c, 0xa4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n }\\n }\\n\\n function log(uint256 p0, bytes32 p1, bool p2) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n // Selector of `log(uint256,string,bool)`.\\n mstore(0x00, 0x4ceda75a)\\n mstore(0x20, p0)\\n mstore(0x40, 0x60)\\n mstore(0x60, p2)\\n writeString(0x80, p1)\\n }\\n _sendLogPayload(0x1c, 0xa4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n }\\n }\\n\\n function log(uint256 p0, bytes32 p1, uint256 p2) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n // Selector of `log(uint256,string,uint256)`.\\n mstore(0x00, 0x37aa7d4c)\\n mstore(0x20, p0)\\n mstore(0x40, 0x60)\\n mstore(0x60, p2)\\n writeString(0x80, p1)\\n }\\n _sendLogPayload(0x1c, 0xa4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n }\\n }\\n\\n function log(uint256 p0, bytes32 p1, bytes32 p2) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n // Selector of `log(uint256,string,string)`.\\n mstore(0x00, 0xb115611f)\\n mstore(0x20, p0)\\n mstore(0x40, 0x60)\\n mstore(0x60, 0xa0)\\n writeString(0x80, p1)\\n writeString(0xc0, p2)\\n }\\n _sendLogPayload(0x1c, 0xe4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n }\\n }\\n\\n function log(bytes32 p0, address p1, address p2) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n // Selector of `log(string,address,address)`.\\n mstore(0x00, 0xfcec75e0)\\n mstore(0x20, 0x60)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n writeString(0x80, p0)\\n }\\n _sendLogPayload(0x1c, 0xa4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n }\\n }\\n\\n function log(bytes32 p0, address p1, bool p2) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n // Selector of `log(string,address,bool)`.\\n mstore(0x00, 0xc91d5ed4)\\n mstore(0x20, 0x60)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n writeString(0x80, p0)\\n }\\n _sendLogPayload(0x1c, 0xa4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n }\\n }\\n\\n function log(bytes32 p0, address p1, uint256 p2) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n // Selector of `log(string,address,uint256)`.\\n mstore(0x00, 0x0d26b925)\\n mstore(0x20, 0x60)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n writeString(0x80, p0)\\n }\\n _sendLogPayload(0x1c, 0xa4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n }\\n }\\n\\n function log(bytes32 p0, address p1, bytes32 p2) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n // Selector of `log(string,address,string)`.\\n mstore(0x00, 0xe0e9ad4f)\\n mstore(0x20, 0x60)\\n mstore(0x40, p1)\\n mstore(0x60, 0xa0)\\n writeString(0x80, p0)\\n writeString(0xc0, p2)\\n }\\n _sendLogPayload(0x1c, 0xe4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n }\\n }\\n\\n function log(bytes32 p0, bool p1, address p2) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n // Selector of `log(string,bool,address)`.\\n mstore(0x00, 0x932bbb38)\\n mstore(0x20, 0x60)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n writeString(0x80, p0)\\n }\\n _sendLogPayload(0x1c, 0xa4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n }\\n }\\n\\n function log(bytes32 p0, bool p1, bool p2) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n // Selector of `log(string,bool,bool)`.\\n mstore(0x00, 0x850b7ad6)\\n mstore(0x20, 0x60)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n writeString(0x80, p0)\\n }\\n _sendLogPayload(0x1c, 0xa4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n }\\n }\\n\\n function log(bytes32 p0, bool p1, uint256 p2) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n // Selector of `log(string,bool,uint256)`.\\n mstore(0x00, 0xc95958d6)\\n mstore(0x20, 0x60)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n writeString(0x80, p0)\\n }\\n _sendLogPayload(0x1c, 0xa4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n }\\n }\\n\\n function log(bytes32 p0, bool p1, bytes32 p2) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n // Selector of `log(string,bool,string)`.\\n mstore(0x00, 0xe298f47d)\\n mstore(0x20, 0x60)\\n mstore(0x40, p1)\\n mstore(0x60, 0xa0)\\n writeString(0x80, p0)\\n writeString(0xc0, p2)\\n }\\n _sendLogPayload(0x1c, 0xe4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n }\\n }\\n\\n function log(bytes32 p0, uint256 p1, address p2) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n // Selector of `log(string,uint256,address)`.\\n mstore(0x00, 0x1c7ec448)\\n mstore(0x20, 0x60)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n writeString(0x80, p0)\\n }\\n _sendLogPayload(0x1c, 0xa4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n }\\n }\\n\\n function log(bytes32 p0, uint256 p1, bool p2) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n // Selector of `log(string,uint256,bool)`.\\n mstore(0x00, 0xca7733b1)\\n mstore(0x20, 0x60)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n writeString(0x80, p0)\\n }\\n _sendLogPayload(0x1c, 0xa4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n }\\n }\\n\\n function log(bytes32 p0, uint256 p1, uint256 p2) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n // Selector of `log(string,uint256,uint256)`.\\n mstore(0x00, 0xca47c4eb)\\n mstore(0x20, 0x60)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n writeString(0x80, p0)\\n }\\n _sendLogPayload(0x1c, 0xa4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n }\\n }\\n\\n function log(bytes32 p0, uint256 p1, bytes32 p2) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n // Selector of `log(string,uint256,string)`.\\n mstore(0x00, 0x5970e089)\\n mstore(0x20, 0x60)\\n mstore(0x40, p1)\\n mstore(0x60, 0xa0)\\n writeString(0x80, p0)\\n writeString(0xc0, p2)\\n }\\n _sendLogPayload(0x1c, 0xe4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n }\\n }\\n\\n function log(bytes32 p0, bytes32 p1, address p2) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n // Selector of `log(string,string,address)`.\\n mstore(0x00, 0x95ed0195)\\n mstore(0x20, 0x60)\\n mstore(0x40, 0xa0)\\n mstore(0x60, p2)\\n writeString(0x80, p0)\\n writeString(0xc0, p1)\\n }\\n _sendLogPayload(0x1c, 0xe4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n }\\n }\\n\\n function log(bytes32 p0, bytes32 p1, bool p2) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n // Selector of `log(string,string,bool)`.\\n mstore(0x00, 0xb0e0f9b5)\\n mstore(0x20, 0x60)\\n mstore(0x40, 0xa0)\\n mstore(0x60, p2)\\n writeString(0x80, p0)\\n writeString(0xc0, p1)\\n }\\n _sendLogPayload(0x1c, 0xe4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n }\\n }\\n\\n function log(bytes32 p0, bytes32 p1, uint256 p2) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n // Selector of `log(string,string,uint256)`.\\n mstore(0x00, 0x5821efa1)\\n mstore(0x20, 0x60)\\n mstore(0x40, 0xa0)\\n mstore(0x60, p2)\\n writeString(0x80, p0)\\n writeString(0xc0, p1)\\n }\\n _sendLogPayload(0x1c, 0xe4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n }\\n }\\n\\n function log(bytes32 p0, bytes32 p1, bytes32 p2) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n bytes32 m9;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n m9 := mload(0x120)\\n // Selector of `log(string,string,string)`.\\n mstore(0x00, 0x2ced7cef)\\n mstore(0x20, 0x60)\\n mstore(0x40, 0xa0)\\n mstore(0x60, 0xe0)\\n writeString(0x80, p0)\\n writeString(0xc0, p1)\\n writeString(0x100, p2)\\n }\\n _sendLogPayload(0x1c, 0x124);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n mstore(0x120, m9)\\n }\\n }\\n\\n function log(address p0, address p1, address p2, address p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(address,address,address,address)`.\\n mstore(0x00, 0x665bf134)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(address p0, address p1, address p2, bool p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(address,address,address,bool)`.\\n mstore(0x00, 0x0e378994)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(address p0, address p1, address p2, uint256 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(address,address,address,uint256)`.\\n mstore(0x00, 0x94250d77)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(address p0, address p1, address p2, bytes32 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(address,address,address,string)`.\\n mstore(0x00, 0xf808da20)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, 0x80)\\n writeString(0xa0, p3)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(address p0, address p1, bool p2, address p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(address,address,bool,address)`.\\n mstore(0x00, 0x9f1bc36e)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(address p0, address p1, bool p2, bool p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(address,address,bool,bool)`.\\n mstore(0x00, 0x2cd4134a)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(address p0, address p1, bool p2, uint256 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(address,address,bool,uint256)`.\\n mstore(0x00, 0x3971e78c)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(address p0, address p1, bool p2, bytes32 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(address,address,bool,string)`.\\n mstore(0x00, 0xaa6540c8)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, 0x80)\\n writeString(0xa0, p3)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(address p0, address p1, uint256 p2, address p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(address,address,uint256,address)`.\\n mstore(0x00, 0x8da6def5)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(address p0, address p1, uint256 p2, bool p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(address,address,uint256,bool)`.\\n mstore(0x00, 0x9b4254e2)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(address p0, address p1, uint256 p2, uint256 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(address,address,uint256,uint256)`.\\n mstore(0x00, 0xbe553481)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(address p0, address p1, uint256 p2, bytes32 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(address,address,uint256,string)`.\\n mstore(0x00, 0xfdb4f990)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, 0x80)\\n writeString(0xa0, p3)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(address p0, address p1, bytes32 p2, address p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(address,address,string,address)`.\\n mstore(0x00, 0x8f736d16)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, 0x80)\\n mstore(0x80, p3)\\n writeString(0xa0, p2)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(address p0, address p1, bytes32 p2, bool p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(address,address,string,bool)`.\\n mstore(0x00, 0x6f1a594e)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, 0x80)\\n mstore(0x80, p3)\\n writeString(0xa0, p2)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(address p0, address p1, bytes32 p2, uint256 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(address,address,string,uint256)`.\\n mstore(0x00, 0xef1cefe7)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, 0x80)\\n mstore(0x80, p3)\\n writeString(0xa0, p2)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(address p0, address p1, bytes32 p2, bytes32 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n // Selector of `log(address,address,string,string)`.\\n mstore(0x00, 0x21bdaf25)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, 0x80)\\n mstore(0x80, 0xc0)\\n writeString(0xa0, p2)\\n writeString(0xe0, p3)\\n }\\n _sendLogPayload(0x1c, 0x104);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n }\\n }\\n\\n function log(address p0, bool p1, address p2, address p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(address,bool,address,address)`.\\n mstore(0x00, 0x660375dd)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(address p0, bool p1, address p2, bool p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(address,bool,address,bool)`.\\n mstore(0x00, 0xa6f50b0f)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(address p0, bool p1, address p2, uint256 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(address,bool,address,uint256)`.\\n mstore(0x00, 0xa75c59de)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(address p0, bool p1, address p2, bytes32 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(address,bool,address,string)`.\\n mstore(0x00, 0x2dd778e6)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, 0x80)\\n writeString(0xa0, p3)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(address p0, bool p1, bool p2, address p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(address,bool,bool,address)`.\\n mstore(0x00, 0xcf394485)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(address p0, bool p1, bool p2, bool p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(address,bool,bool,bool)`.\\n mstore(0x00, 0xcac43479)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(address p0, bool p1, bool p2, uint256 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(address,bool,bool,uint256)`.\\n mstore(0x00, 0x8c4e5de6)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(address p0, bool p1, bool p2, bytes32 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(address,bool,bool,string)`.\\n mstore(0x00, 0xdfc4a2e8)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, 0x80)\\n writeString(0xa0, p3)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(address p0, bool p1, uint256 p2, address p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(address,bool,uint256,address)`.\\n mstore(0x00, 0xccf790a1)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(address p0, bool p1, uint256 p2, bool p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(address,bool,uint256,bool)`.\\n mstore(0x00, 0xc4643e20)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(address p0, bool p1, uint256 p2, uint256 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(address,bool,uint256,uint256)`.\\n mstore(0x00, 0x386ff5f4)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(address p0, bool p1, uint256 p2, bytes32 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(address,bool,uint256,string)`.\\n mstore(0x00, 0x0aa6cfad)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, 0x80)\\n writeString(0xa0, p3)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(address p0, bool p1, bytes32 p2, address p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(address,bool,string,address)`.\\n mstore(0x00, 0x19fd4956)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, 0x80)\\n mstore(0x80, p3)\\n writeString(0xa0, p2)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(address p0, bool p1, bytes32 p2, bool p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(address,bool,string,bool)`.\\n mstore(0x00, 0x50ad461d)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, 0x80)\\n mstore(0x80, p3)\\n writeString(0xa0, p2)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(address p0, bool p1, bytes32 p2, uint256 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(address,bool,string,uint256)`.\\n mstore(0x00, 0x80e6a20b)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, 0x80)\\n mstore(0x80, p3)\\n writeString(0xa0, p2)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(address p0, bool p1, bytes32 p2, bytes32 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n // Selector of `log(address,bool,string,string)`.\\n mstore(0x00, 0x475c5c33)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, 0x80)\\n mstore(0x80, 0xc0)\\n writeString(0xa0, p2)\\n writeString(0xe0, p3)\\n }\\n _sendLogPayload(0x1c, 0x104);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n }\\n }\\n\\n function log(address p0, uint256 p1, address p2, address p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(address,uint256,address,address)`.\\n mstore(0x00, 0x478d1c62)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(address p0, uint256 p1, address p2, bool p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(address,uint256,address,bool)`.\\n mstore(0x00, 0xa1bcc9b3)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(address p0, uint256 p1, address p2, uint256 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(address,uint256,address,uint256)`.\\n mstore(0x00, 0x100f650e)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(address p0, uint256 p1, address p2, bytes32 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(address,uint256,address,string)`.\\n mstore(0x00, 0x1da986ea)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, 0x80)\\n writeString(0xa0, p3)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(address p0, uint256 p1, bool p2, address p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(address,uint256,bool,address)`.\\n mstore(0x00, 0xa31bfdcc)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(address p0, uint256 p1, bool p2, bool p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(address,uint256,bool,bool)`.\\n mstore(0x00, 0x3bf5e537)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(address p0, uint256 p1, bool p2, uint256 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(address,uint256,bool,uint256)`.\\n mstore(0x00, 0x22f6b999)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(address p0, uint256 p1, bool p2, bytes32 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(address,uint256,bool,string)`.\\n mstore(0x00, 0xc5ad85f9)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, 0x80)\\n writeString(0xa0, p3)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(address p0, uint256 p1, uint256 p2, address p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(address,uint256,uint256,address)`.\\n mstore(0x00, 0x20e3984d)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(address p0, uint256 p1, uint256 p2, bool p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(address,uint256,uint256,bool)`.\\n mstore(0x00, 0x66f1bc67)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(address p0, uint256 p1, uint256 p2, uint256 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(address,uint256,uint256,uint256)`.\\n mstore(0x00, 0x34f0e636)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(address p0, uint256 p1, uint256 p2, bytes32 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(address,uint256,uint256,string)`.\\n mstore(0x00, 0x4a28c017)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, 0x80)\\n writeString(0xa0, p3)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(address p0, uint256 p1, bytes32 p2, address p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(address,uint256,string,address)`.\\n mstore(0x00, 0x5c430d47)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, 0x80)\\n mstore(0x80, p3)\\n writeString(0xa0, p2)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(address p0, uint256 p1, bytes32 p2, bool p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(address,uint256,string,bool)`.\\n mstore(0x00, 0xcf18105c)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, 0x80)\\n mstore(0x80, p3)\\n writeString(0xa0, p2)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(address p0, uint256 p1, bytes32 p2, uint256 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(address,uint256,string,uint256)`.\\n mstore(0x00, 0xbf01f891)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, 0x80)\\n mstore(0x80, p3)\\n writeString(0xa0, p2)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(address p0, uint256 p1, bytes32 p2, bytes32 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n // Selector of `log(address,uint256,string,string)`.\\n mstore(0x00, 0x88a8c406)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, 0x80)\\n mstore(0x80, 0xc0)\\n writeString(0xa0, p2)\\n writeString(0xe0, p3)\\n }\\n _sendLogPayload(0x1c, 0x104);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n }\\n }\\n\\n function log(address p0, bytes32 p1, address p2, address p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(address,string,address,address)`.\\n mstore(0x00, 0x0d36fa20)\\n mstore(0x20, p0)\\n mstore(0x40, 0x80)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n writeString(0xa0, p1)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(address p0, bytes32 p1, address p2, bool p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(address,string,address,bool)`.\\n mstore(0x00, 0x0df12b76)\\n mstore(0x20, p0)\\n mstore(0x40, 0x80)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n writeString(0xa0, p1)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(address p0, bytes32 p1, address p2, uint256 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(address,string,address,uint256)`.\\n mstore(0x00, 0x457fe3cf)\\n mstore(0x20, p0)\\n mstore(0x40, 0x80)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n writeString(0xa0, p1)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(address p0, bytes32 p1, address p2, bytes32 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n // Selector of `log(address,string,address,string)`.\\n mstore(0x00, 0xf7e36245)\\n mstore(0x20, p0)\\n mstore(0x40, 0x80)\\n mstore(0x60, p2)\\n mstore(0x80, 0xc0)\\n writeString(0xa0, p1)\\n writeString(0xe0, p3)\\n }\\n _sendLogPayload(0x1c, 0x104);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n }\\n }\\n\\n function log(address p0, bytes32 p1, bool p2, address p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(address,string,bool,address)`.\\n mstore(0x00, 0x205871c2)\\n mstore(0x20, p0)\\n mstore(0x40, 0x80)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n writeString(0xa0, p1)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(address p0, bytes32 p1, bool p2, bool p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(address,string,bool,bool)`.\\n mstore(0x00, 0x5f1d5c9f)\\n mstore(0x20, p0)\\n mstore(0x40, 0x80)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n writeString(0xa0, p1)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(address p0, bytes32 p1, bool p2, uint256 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(address,string,bool,uint256)`.\\n mstore(0x00, 0x515e38b6)\\n mstore(0x20, p0)\\n mstore(0x40, 0x80)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n writeString(0xa0, p1)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(address p0, bytes32 p1, bool p2, bytes32 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n // Selector of `log(address,string,bool,string)`.\\n mstore(0x00, 0xbc0b61fe)\\n mstore(0x20, p0)\\n mstore(0x40, 0x80)\\n mstore(0x60, p2)\\n mstore(0x80, 0xc0)\\n writeString(0xa0, p1)\\n writeString(0xe0, p3)\\n }\\n _sendLogPayload(0x1c, 0x104);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n }\\n }\\n\\n function log(address p0, bytes32 p1, uint256 p2, address p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(address,string,uint256,address)`.\\n mstore(0x00, 0x63183678)\\n mstore(0x20, p0)\\n mstore(0x40, 0x80)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n writeString(0xa0, p1)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(address p0, bytes32 p1, uint256 p2, bool p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(address,string,uint256,bool)`.\\n mstore(0x00, 0x0ef7e050)\\n mstore(0x20, p0)\\n mstore(0x40, 0x80)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n writeString(0xa0, p1)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(address p0, bytes32 p1, uint256 p2, uint256 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(address,string,uint256,uint256)`.\\n mstore(0x00, 0x1dc8e1b8)\\n mstore(0x20, p0)\\n mstore(0x40, 0x80)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n writeString(0xa0, p1)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(address p0, bytes32 p1, uint256 p2, bytes32 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n // Selector of `log(address,string,uint256,string)`.\\n mstore(0x00, 0x448830a8)\\n mstore(0x20, p0)\\n mstore(0x40, 0x80)\\n mstore(0x60, p2)\\n mstore(0x80, 0xc0)\\n writeString(0xa0, p1)\\n writeString(0xe0, p3)\\n }\\n _sendLogPayload(0x1c, 0x104);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n }\\n }\\n\\n function log(address p0, bytes32 p1, bytes32 p2, address p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n // Selector of `log(address,string,string,address)`.\\n mstore(0x00, 0xa04e2f87)\\n mstore(0x20, p0)\\n mstore(0x40, 0x80)\\n mstore(0x60, 0xc0)\\n mstore(0x80, p3)\\n writeString(0xa0, p1)\\n writeString(0xe0, p2)\\n }\\n _sendLogPayload(0x1c, 0x104);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n }\\n }\\n\\n function log(address p0, bytes32 p1, bytes32 p2, bool p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n // Selector of `log(address,string,string,bool)`.\\n mstore(0x00, 0x35a5071f)\\n mstore(0x20, p0)\\n mstore(0x40, 0x80)\\n mstore(0x60, 0xc0)\\n mstore(0x80, p3)\\n writeString(0xa0, p1)\\n writeString(0xe0, p2)\\n }\\n _sendLogPayload(0x1c, 0x104);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n }\\n }\\n\\n function log(address p0, bytes32 p1, bytes32 p2, uint256 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n // Selector of `log(address,string,string,uint256)`.\\n mstore(0x00, 0x159f8927)\\n mstore(0x20, p0)\\n mstore(0x40, 0x80)\\n mstore(0x60, 0xc0)\\n mstore(0x80, p3)\\n writeString(0xa0, p1)\\n writeString(0xe0, p2)\\n }\\n _sendLogPayload(0x1c, 0x104);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n }\\n }\\n\\n function log(address p0, bytes32 p1, bytes32 p2, bytes32 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n bytes32 m9;\\n bytes32 m10;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n m9 := mload(0x120)\\n m10 := mload(0x140)\\n // Selector of `log(address,string,string,string)`.\\n mstore(0x00, 0x5d02c50b)\\n mstore(0x20, p0)\\n mstore(0x40, 0x80)\\n mstore(0x60, 0xc0)\\n mstore(0x80, 0x100)\\n writeString(0xa0, p1)\\n writeString(0xe0, p2)\\n writeString(0x120, p3)\\n }\\n _sendLogPayload(0x1c, 0x144);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n mstore(0x120, m9)\\n mstore(0x140, m10)\\n }\\n }\\n\\n function log(bool p0, address p1, address p2, address p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(bool,address,address,address)`.\\n mstore(0x00, 0x1d14d001)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(bool p0, address p1, address p2, bool p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(bool,address,address,bool)`.\\n mstore(0x00, 0x46600be0)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(bool p0, address p1, address p2, uint256 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(bool,address,address,uint256)`.\\n mstore(0x00, 0x0c66d1be)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(bool p0, address p1, address p2, bytes32 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(bool,address,address,string)`.\\n mstore(0x00, 0xd812a167)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, 0x80)\\n writeString(0xa0, p3)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(bool p0, address p1, bool p2, address p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(bool,address,bool,address)`.\\n mstore(0x00, 0x1c41a336)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(bool p0, address p1, bool p2, bool p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(bool,address,bool,bool)`.\\n mstore(0x00, 0x6a9c478b)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(bool p0, address p1, bool p2, uint256 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(bool,address,bool,uint256)`.\\n mstore(0x00, 0x07831502)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(bool p0, address p1, bool p2, bytes32 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(bool,address,bool,string)`.\\n mstore(0x00, 0x4a66cb34)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, 0x80)\\n writeString(0xa0, p3)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(bool p0, address p1, uint256 p2, address p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(bool,address,uint256,address)`.\\n mstore(0x00, 0x136b05dd)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(bool p0, address p1, uint256 p2, bool p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(bool,address,uint256,bool)`.\\n mstore(0x00, 0xd6019f1c)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(bool p0, address p1, uint256 p2, uint256 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(bool,address,uint256,uint256)`.\\n mstore(0x00, 0x7bf181a1)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(bool p0, address p1, uint256 p2, bytes32 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(bool,address,uint256,string)`.\\n mstore(0x00, 0x51f09ff8)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, 0x80)\\n writeString(0xa0, p3)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(bool p0, address p1, bytes32 p2, address p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(bool,address,string,address)`.\\n mstore(0x00, 0x6f7c603e)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, 0x80)\\n mstore(0x80, p3)\\n writeString(0xa0, p2)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(bool p0, address p1, bytes32 p2, bool p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(bool,address,string,bool)`.\\n mstore(0x00, 0xe2bfd60b)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, 0x80)\\n mstore(0x80, p3)\\n writeString(0xa0, p2)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(bool p0, address p1, bytes32 p2, uint256 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(bool,address,string,uint256)`.\\n mstore(0x00, 0xc21f64c7)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, 0x80)\\n mstore(0x80, p3)\\n writeString(0xa0, p2)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(bool p0, address p1, bytes32 p2, bytes32 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n // Selector of `log(bool,address,string,string)`.\\n mstore(0x00, 0xa73c1db6)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, 0x80)\\n mstore(0x80, 0xc0)\\n writeString(0xa0, p2)\\n writeString(0xe0, p3)\\n }\\n _sendLogPayload(0x1c, 0x104);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n }\\n }\\n\\n function log(bool p0, bool p1, address p2, address p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(bool,bool,address,address)`.\\n mstore(0x00, 0xf4880ea4)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(bool p0, bool p1, address p2, bool p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(bool,bool,address,bool)`.\\n mstore(0x00, 0xc0a302d8)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(bool p0, bool p1, address p2, uint256 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(bool,bool,address,uint256)`.\\n mstore(0x00, 0x4c123d57)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(bool p0, bool p1, address p2, bytes32 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(bool,bool,address,string)`.\\n mstore(0x00, 0xa0a47963)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, 0x80)\\n writeString(0xa0, p3)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(bool p0, bool p1, bool p2, address p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(bool,bool,bool,address)`.\\n mstore(0x00, 0x8c329b1a)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(bool p0, bool p1, bool p2, bool p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(bool,bool,bool,bool)`.\\n mstore(0x00, 0x3b2a5ce0)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(bool p0, bool p1, bool p2, uint256 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(bool,bool,bool,uint256)`.\\n mstore(0x00, 0x6d7045c1)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(bool p0, bool p1, bool p2, bytes32 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(bool,bool,bool,string)`.\\n mstore(0x00, 0x2ae408d4)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, 0x80)\\n writeString(0xa0, p3)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(bool p0, bool p1, uint256 p2, address p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(bool,bool,uint256,address)`.\\n mstore(0x00, 0x54a7a9a0)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(bool p0, bool p1, uint256 p2, bool p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(bool,bool,uint256,bool)`.\\n mstore(0x00, 0x619e4d0e)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(bool p0, bool p1, uint256 p2, uint256 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(bool,bool,uint256,uint256)`.\\n mstore(0x00, 0x0bb00eab)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(bool p0, bool p1, uint256 p2, bytes32 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(bool,bool,uint256,string)`.\\n mstore(0x00, 0x7dd4d0e0)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, 0x80)\\n writeString(0xa0, p3)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(bool p0, bool p1, bytes32 p2, address p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(bool,bool,string,address)`.\\n mstore(0x00, 0xf9ad2b89)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, 0x80)\\n mstore(0x80, p3)\\n writeString(0xa0, p2)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(bool p0, bool p1, bytes32 p2, bool p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(bool,bool,string,bool)`.\\n mstore(0x00, 0xb857163a)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, 0x80)\\n mstore(0x80, p3)\\n writeString(0xa0, p2)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(bool p0, bool p1, bytes32 p2, uint256 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(bool,bool,string,uint256)`.\\n mstore(0x00, 0xe3a9ca2f)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, 0x80)\\n mstore(0x80, p3)\\n writeString(0xa0, p2)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(bool p0, bool p1, bytes32 p2, bytes32 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n // Selector of `log(bool,bool,string,string)`.\\n mstore(0x00, 0x6d1e8751)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, 0x80)\\n mstore(0x80, 0xc0)\\n writeString(0xa0, p2)\\n writeString(0xe0, p3)\\n }\\n _sendLogPayload(0x1c, 0x104);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n }\\n }\\n\\n function log(bool p0, uint256 p1, address p2, address p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(bool,uint256,address,address)`.\\n mstore(0x00, 0x26f560a8)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(bool p0, uint256 p1, address p2, bool p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(bool,uint256,address,bool)`.\\n mstore(0x00, 0xb4c314ff)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(bool p0, uint256 p1, address p2, uint256 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(bool,uint256,address,uint256)`.\\n mstore(0x00, 0x1537dc87)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(bool p0, uint256 p1, address p2, bytes32 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(bool,uint256,address,string)`.\\n mstore(0x00, 0x1bb3b09a)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, 0x80)\\n writeString(0xa0, p3)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(bool p0, uint256 p1, bool p2, address p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(bool,uint256,bool,address)`.\\n mstore(0x00, 0x9acd3616)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(bool p0, uint256 p1, bool p2, bool p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(bool,uint256,bool,bool)`.\\n mstore(0x00, 0xceb5f4d7)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(bool p0, uint256 p1, bool p2, uint256 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(bool,uint256,bool,uint256)`.\\n mstore(0x00, 0x7f9bbca2)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(bool p0, uint256 p1, bool p2, bytes32 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(bool,uint256,bool,string)`.\\n mstore(0x00, 0x9143dbb1)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, 0x80)\\n writeString(0xa0, p3)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(bool p0, uint256 p1, uint256 p2, address p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(bool,uint256,uint256,address)`.\\n mstore(0x00, 0x00dd87b9)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(bool p0, uint256 p1, uint256 p2, bool p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(bool,uint256,uint256,bool)`.\\n mstore(0x00, 0xbe984353)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(bool p0, uint256 p1, uint256 p2, uint256 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(bool,uint256,uint256,uint256)`.\\n mstore(0x00, 0x374bb4b2)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(bool p0, uint256 p1, uint256 p2, bytes32 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(bool,uint256,uint256,string)`.\\n mstore(0x00, 0x8e69fb5d)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, 0x80)\\n writeString(0xa0, p3)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(bool p0, uint256 p1, bytes32 p2, address p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(bool,uint256,string,address)`.\\n mstore(0x00, 0xfedd1fff)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, 0x80)\\n mstore(0x80, p3)\\n writeString(0xa0, p2)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(bool p0, uint256 p1, bytes32 p2, bool p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(bool,uint256,string,bool)`.\\n mstore(0x00, 0xe5e70b2b)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, 0x80)\\n mstore(0x80, p3)\\n writeString(0xa0, p2)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(bool p0, uint256 p1, bytes32 p2, uint256 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(bool,uint256,string,uint256)`.\\n mstore(0x00, 0x6a1199e2)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, 0x80)\\n mstore(0x80, p3)\\n writeString(0xa0, p2)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(bool p0, uint256 p1, bytes32 p2, bytes32 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n // Selector of `log(bool,uint256,string,string)`.\\n mstore(0x00, 0xf5bc2249)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, 0x80)\\n mstore(0x80, 0xc0)\\n writeString(0xa0, p2)\\n writeString(0xe0, p3)\\n }\\n _sendLogPayload(0x1c, 0x104);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n }\\n }\\n\\n function log(bool p0, bytes32 p1, address p2, address p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(bool,string,address,address)`.\\n mstore(0x00, 0x2b2b18dc)\\n mstore(0x20, p0)\\n mstore(0x40, 0x80)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n writeString(0xa0, p1)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(bool p0, bytes32 p1, address p2, bool p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(bool,string,address,bool)`.\\n mstore(0x00, 0x6dd434ca)\\n mstore(0x20, p0)\\n mstore(0x40, 0x80)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n writeString(0xa0, p1)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(bool p0, bytes32 p1, address p2, uint256 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(bool,string,address,uint256)`.\\n mstore(0x00, 0xa5cada94)\\n mstore(0x20, p0)\\n mstore(0x40, 0x80)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n writeString(0xa0, p1)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(bool p0, bytes32 p1, address p2, bytes32 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n // Selector of `log(bool,string,address,string)`.\\n mstore(0x00, 0x12d6c788)\\n mstore(0x20, p0)\\n mstore(0x40, 0x80)\\n mstore(0x60, p2)\\n mstore(0x80, 0xc0)\\n writeString(0xa0, p1)\\n writeString(0xe0, p3)\\n }\\n _sendLogPayload(0x1c, 0x104);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n }\\n }\\n\\n function log(bool p0, bytes32 p1, bool p2, address p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(bool,string,bool,address)`.\\n mstore(0x00, 0x538e06ab)\\n mstore(0x20, p0)\\n mstore(0x40, 0x80)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n writeString(0xa0, p1)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(bool p0, bytes32 p1, bool p2, bool p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(bool,string,bool,bool)`.\\n mstore(0x00, 0xdc5e935b)\\n mstore(0x20, p0)\\n mstore(0x40, 0x80)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n writeString(0xa0, p1)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(bool p0, bytes32 p1, bool p2, uint256 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(bool,string,bool,uint256)`.\\n mstore(0x00, 0x1606a393)\\n mstore(0x20, p0)\\n mstore(0x40, 0x80)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n writeString(0xa0, p1)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(bool p0, bytes32 p1, bool p2, bytes32 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n // Selector of `log(bool,string,bool,string)`.\\n mstore(0x00, 0x483d0416)\\n mstore(0x20, p0)\\n mstore(0x40, 0x80)\\n mstore(0x60, p2)\\n mstore(0x80, 0xc0)\\n writeString(0xa0, p1)\\n writeString(0xe0, p3)\\n }\\n _sendLogPayload(0x1c, 0x104);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n }\\n }\\n\\n function log(bool p0, bytes32 p1, uint256 p2, address p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(bool,string,uint256,address)`.\\n mstore(0x00, 0x1596a1ce)\\n mstore(0x20, p0)\\n mstore(0x40, 0x80)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n writeString(0xa0, p1)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(bool p0, bytes32 p1, uint256 p2, bool p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(bool,string,uint256,bool)`.\\n mstore(0x00, 0x6b0e5d53)\\n mstore(0x20, p0)\\n mstore(0x40, 0x80)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n writeString(0xa0, p1)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(bool p0, bytes32 p1, uint256 p2, uint256 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(bool,string,uint256,uint256)`.\\n mstore(0x00, 0x28863fcb)\\n mstore(0x20, p0)\\n mstore(0x40, 0x80)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n writeString(0xa0, p1)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(bool p0, bytes32 p1, uint256 p2, bytes32 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n // Selector of `log(bool,string,uint256,string)`.\\n mstore(0x00, 0x1ad96de6)\\n mstore(0x20, p0)\\n mstore(0x40, 0x80)\\n mstore(0x60, p2)\\n mstore(0x80, 0xc0)\\n writeString(0xa0, p1)\\n writeString(0xe0, p3)\\n }\\n _sendLogPayload(0x1c, 0x104);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n }\\n }\\n\\n function log(bool p0, bytes32 p1, bytes32 p2, address p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n // Selector of `log(bool,string,string,address)`.\\n mstore(0x00, 0x97d394d8)\\n mstore(0x20, p0)\\n mstore(0x40, 0x80)\\n mstore(0x60, 0xc0)\\n mstore(0x80, p3)\\n writeString(0xa0, p1)\\n writeString(0xe0, p2)\\n }\\n _sendLogPayload(0x1c, 0x104);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n }\\n }\\n\\n function log(bool p0, bytes32 p1, bytes32 p2, bool p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n // Selector of `log(bool,string,string,bool)`.\\n mstore(0x00, 0x1e4b87e5)\\n mstore(0x20, p0)\\n mstore(0x40, 0x80)\\n mstore(0x60, 0xc0)\\n mstore(0x80, p3)\\n writeString(0xa0, p1)\\n writeString(0xe0, p2)\\n }\\n _sendLogPayload(0x1c, 0x104);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n }\\n }\\n\\n function log(bool p0, bytes32 p1, bytes32 p2, uint256 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n // Selector of `log(bool,string,string,uint256)`.\\n mstore(0x00, 0x7be0c3eb)\\n mstore(0x20, p0)\\n mstore(0x40, 0x80)\\n mstore(0x60, 0xc0)\\n mstore(0x80, p3)\\n writeString(0xa0, p1)\\n writeString(0xe0, p2)\\n }\\n _sendLogPayload(0x1c, 0x104);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n }\\n }\\n\\n function log(bool p0, bytes32 p1, bytes32 p2, bytes32 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n bytes32 m9;\\n bytes32 m10;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n m9 := mload(0x120)\\n m10 := mload(0x140)\\n // Selector of `log(bool,string,string,string)`.\\n mstore(0x00, 0x1762e32a)\\n mstore(0x20, p0)\\n mstore(0x40, 0x80)\\n mstore(0x60, 0xc0)\\n mstore(0x80, 0x100)\\n writeString(0xa0, p1)\\n writeString(0xe0, p2)\\n writeString(0x120, p3)\\n }\\n _sendLogPayload(0x1c, 0x144);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n mstore(0x120, m9)\\n mstore(0x140, m10)\\n }\\n }\\n\\n function log(uint256 p0, address p1, address p2, address p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(uint256,address,address,address)`.\\n mstore(0x00, 0x2488b414)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(uint256 p0, address p1, address p2, bool p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(uint256,address,address,bool)`.\\n mstore(0x00, 0x091ffaf5)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(uint256 p0, address p1, address p2, uint256 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(uint256,address,address,uint256)`.\\n mstore(0x00, 0x736efbb6)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(uint256 p0, address p1, address p2, bytes32 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(uint256,address,address,string)`.\\n mstore(0x00, 0x031c6f73)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, 0x80)\\n writeString(0xa0, p3)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(uint256 p0, address p1, bool p2, address p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(uint256,address,bool,address)`.\\n mstore(0x00, 0xef72c513)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(uint256 p0, address p1, bool p2, bool p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(uint256,address,bool,bool)`.\\n mstore(0x00, 0xe351140f)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(uint256 p0, address p1, bool p2, uint256 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(uint256,address,bool,uint256)`.\\n mstore(0x00, 0x5abd992a)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(uint256 p0, address p1, bool p2, bytes32 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(uint256,address,bool,string)`.\\n mstore(0x00, 0x90fb06aa)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, 0x80)\\n writeString(0xa0, p3)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(uint256 p0, address p1, uint256 p2, address p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(uint256,address,uint256,address)`.\\n mstore(0x00, 0x15c127b5)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(uint256 p0, address p1, uint256 p2, bool p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(uint256,address,uint256,bool)`.\\n mstore(0x00, 0x5f743a7c)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(uint256 p0, address p1, uint256 p2, uint256 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(uint256,address,uint256,uint256)`.\\n mstore(0x00, 0x0c9cd9c1)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(uint256 p0, address p1, uint256 p2, bytes32 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(uint256,address,uint256,string)`.\\n mstore(0x00, 0xddb06521)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, 0x80)\\n writeString(0xa0, p3)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(uint256 p0, address p1, bytes32 p2, address p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(uint256,address,string,address)`.\\n mstore(0x00, 0x9cba8fff)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, 0x80)\\n mstore(0x80, p3)\\n writeString(0xa0, p2)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(uint256 p0, address p1, bytes32 p2, bool p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(uint256,address,string,bool)`.\\n mstore(0x00, 0xcc32ab07)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, 0x80)\\n mstore(0x80, p3)\\n writeString(0xa0, p2)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(uint256 p0, address p1, bytes32 p2, uint256 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(uint256,address,string,uint256)`.\\n mstore(0x00, 0x46826b5d)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, 0x80)\\n mstore(0x80, p3)\\n writeString(0xa0, p2)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(uint256 p0, address p1, bytes32 p2, bytes32 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n // Selector of `log(uint256,address,string,string)`.\\n mstore(0x00, 0x3e128ca3)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, 0x80)\\n mstore(0x80, 0xc0)\\n writeString(0xa0, p2)\\n writeString(0xe0, p3)\\n }\\n _sendLogPayload(0x1c, 0x104);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n }\\n }\\n\\n function log(uint256 p0, bool p1, address p2, address p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(uint256,bool,address,address)`.\\n mstore(0x00, 0xa1ef4cbb)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(uint256 p0, bool p1, address p2, bool p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(uint256,bool,address,bool)`.\\n mstore(0x00, 0x454d54a5)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(uint256 p0, bool p1, address p2, uint256 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(uint256,bool,address,uint256)`.\\n mstore(0x00, 0x078287f5)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(uint256 p0, bool p1, address p2, bytes32 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(uint256,bool,address,string)`.\\n mstore(0x00, 0xade052c7)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, 0x80)\\n writeString(0xa0, p3)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(uint256 p0, bool p1, bool p2, address p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(uint256,bool,bool,address)`.\\n mstore(0x00, 0x69640b59)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(uint256 p0, bool p1, bool p2, bool p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(uint256,bool,bool,bool)`.\\n mstore(0x00, 0xb6f577a1)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(uint256 p0, bool p1, bool p2, uint256 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(uint256,bool,bool,uint256)`.\\n mstore(0x00, 0x7464ce23)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(uint256 p0, bool p1, bool p2, bytes32 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(uint256,bool,bool,string)`.\\n mstore(0x00, 0xdddb9561)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, 0x80)\\n writeString(0xa0, p3)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(uint256 p0, bool p1, uint256 p2, address p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(uint256,bool,uint256,address)`.\\n mstore(0x00, 0x88cb6041)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(uint256 p0, bool p1, uint256 p2, bool p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(uint256,bool,uint256,bool)`.\\n mstore(0x00, 0x91a02e2a)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(uint256 p0, bool p1, uint256 p2, uint256 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(uint256,bool,uint256,uint256)`.\\n mstore(0x00, 0xc6acc7a8)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(uint256 p0, bool p1, uint256 p2, bytes32 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(uint256,bool,uint256,string)`.\\n mstore(0x00, 0xde03e774)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, 0x80)\\n writeString(0xa0, p3)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(uint256 p0, bool p1, bytes32 p2, address p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(uint256,bool,string,address)`.\\n mstore(0x00, 0xef529018)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, 0x80)\\n mstore(0x80, p3)\\n writeString(0xa0, p2)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(uint256 p0, bool p1, bytes32 p2, bool p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(uint256,bool,string,bool)`.\\n mstore(0x00, 0xeb928d7f)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, 0x80)\\n mstore(0x80, p3)\\n writeString(0xa0, p2)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(uint256 p0, bool p1, bytes32 p2, uint256 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(uint256,bool,string,uint256)`.\\n mstore(0x00, 0x2c1d0746)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, 0x80)\\n mstore(0x80, p3)\\n writeString(0xa0, p2)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(uint256 p0, bool p1, bytes32 p2, bytes32 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n // Selector of `log(uint256,bool,string,string)`.\\n mstore(0x00, 0x68c8b8bd)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, 0x80)\\n mstore(0x80, 0xc0)\\n writeString(0xa0, p2)\\n writeString(0xe0, p3)\\n }\\n _sendLogPayload(0x1c, 0x104);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n }\\n }\\n\\n function log(uint256 p0, uint256 p1, address p2, address p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(uint256,uint256,address,address)`.\\n mstore(0x00, 0x56a5d1b1)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(uint256 p0, uint256 p1, address p2, bool p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(uint256,uint256,address,bool)`.\\n mstore(0x00, 0x15cac476)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(uint256 p0, uint256 p1, address p2, uint256 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(uint256,uint256,address,uint256)`.\\n mstore(0x00, 0x88f6e4b2)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(uint256 p0, uint256 p1, address p2, bytes32 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(uint256,uint256,address,string)`.\\n mstore(0x00, 0x6cde40b8)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, 0x80)\\n writeString(0xa0, p3)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(uint256 p0, uint256 p1, bool p2, address p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(uint256,uint256,bool,address)`.\\n mstore(0x00, 0x9a816a83)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(uint256 p0, uint256 p1, bool p2, bool p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(uint256,uint256,bool,bool)`.\\n mstore(0x00, 0xab085ae6)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(uint256 p0, uint256 p1, bool p2, uint256 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(uint256,uint256,bool,uint256)`.\\n mstore(0x00, 0xeb7f6fd2)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(uint256 p0, uint256 p1, bool p2, bytes32 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(uint256,uint256,bool,string)`.\\n mstore(0x00, 0xa5b4fc99)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, 0x80)\\n writeString(0xa0, p3)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(uint256 p0, uint256 p1, uint256 p2, address p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(uint256,uint256,uint256,address)`.\\n mstore(0x00, 0xfa8185af)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(uint256 p0, uint256 p1, uint256 p2, bool p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(uint256,uint256,uint256,bool)`.\\n mstore(0x00, 0xc598d185)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(uint256 p0, uint256 p1, uint256 p2, uint256 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(uint256,uint256,uint256,uint256)`.\\n mstore(0x00, 0x193fb800)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(uint256 p0, uint256 p1, uint256 p2, bytes32 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(uint256,uint256,uint256,string)`.\\n mstore(0x00, 0x59cfcbe3)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, 0x80)\\n writeString(0xa0, p3)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(uint256 p0, uint256 p1, bytes32 p2, address p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(uint256,uint256,string,address)`.\\n mstore(0x00, 0x42d21db7)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, 0x80)\\n mstore(0x80, p3)\\n writeString(0xa0, p2)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(uint256 p0, uint256 p1, bytes32 p2, bool p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(uint256,uint256,string,bool)`.\\n mstore(0x00, 0x7af6ab25)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, 0x80)\\n mstore(0x80, p3)\\n writeString(0xa0, p2)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(uint256 p0, uint256 p1, bytes32 p2, uint256 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(uint256,uint256,string,uint256)`.\\n mstore(0x00, 0x5da297eb)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, 0x80)\\n mstore(0x80, p3)\\n writeString(0xa0, p2)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(uint256 p0, uint256 p1, bytes32 p2, bytes32 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n // Selector of `log(uint256,uint256,string,string)`.\\n mstore(0x00, 0x27d8afd2)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, 0x80)\\n mstore(0x80, 0xc0)\\n writeString(0xa0, p2)\\n writeString(0xe0, p3)\\n }\\n _sendLogPayload(0x1c, 0x104);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n }\\n }\\n\\n function log(uint256 p0, bytes32 p1, address p2, address p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(uint256,string,address,address)`.\\n mstore(0x00, 0x6168ed61)\\n mstore(0x20, p0)\\n mstore(0x40, 0x80)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n writeString(0xa0, p1)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(uint256 p0, bytes32 p1, address p2, bool p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(uint256,string,address,bool)`.\\n mstore(0x00, 0x90c30a56)\\n mstore(0x20, p0)\\n mstore(0x40, 0x80)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n writeString(0xa0, p1)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(uint256 p0, bytes32 p1, address p2, uint256 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(uint256,string,address,uint256)`.\\n mstore(0x00, 0xe8d3018d)\\n mstore(0x20, p0)\\n mstore(0x40, 0x80)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n writeString(0xa0, p1)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(uint256 p0, bytes32 p1, address p2, bytes32 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n // Selector of `log(uint256,string,address,string)`.\\n mstore(0x00, 0x9c3adfa1)\\n mstore(0x20, p0)\\n mstore(0x40, 0x80)\\n mstore(0x60, p2)\\n mstore(0x80, 0xc0)\\n writeString(0xa0, p1)\\n writeString(0xe0, p3)\\n }\\n _sendLogPayload(0x1c, 0x104);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n }\\n }\\n\\n function log(uint256 p0, bytes32 p1, bool p2, address p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(uint256,string,bool,address)`.\\n mstore(0x00, 0xae2ec581)\\n mstore(0x20, p0)\\n mstore(0x40, 0x80)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n writeString(0xa0, p1)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(uint256 p0, bytes32 p1, bool p2, bool p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(uint256,string,bool,bool)`.\\n mstore(0x00, 0xba535d9c)\\n mstore(0x20, p0)\\n mstore(0x40, 0x80)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n writeString(0xa0, p1)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(uint256 p0, bytes32 p1, bool p2, uint256 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(uint256,string,bool,uint256)`.\\n mstore(0x00, 0xcf009880)\\n mstore(0x20, p0)\\n mstore(0x40, 0x80)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n writeString(0xa0, p1)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(uint256 p0, bytes32 p1, bool p2, bytes32 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n // Selector of `log(uint256,string,bool,string)`.\\n mstore(0x00, 0xd2d423cd)\\n mstore(0x20, p0)\\n mstore(0x40, 0x80)\\n mstore(0x60, p2)\\n mstore(0x80, 0xc0)\\n writeString(0xa0, p1)\\n writeString(0xe0, p3)\\n }\\n _sendLogPayload(0x1c, 0x104);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n }\\n }\\n\\n function log(uint256 p0, bytes32 p1, uint256 p2, address p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(uint256,string,uint256,address)`.\\n mstore(0x00, 0x3b2279b4)\\n mstore(0x20, p0)\\n mstore(0x40, 0x80)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n writeString(0xa0, p1)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(uint256 p0, bytes32 p1, uint256 p2, bool p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(uint256,string,uint256,bool)`.\\n mstore(0x00, 0x691a8f74)\\n mstore(0x20, p0)\\n mstore(0x40, 0x80)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n writeString(0xa0, p1)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(uint256 p0, bytes32 p1, uint256 p2, uint256 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(uint256,string,uint256,uint256)`.\\n mstore(0x00, 0x82c25b74)\\n mstore(0x20, p0)\\n mstore(0x40, 0x80)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n writeString(0xa0, p1)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(uint256 p0, bytes32 p1, uint256 p2, bytes32 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n // Selector of `log(uint256,string,uint256,string)`.\\n mstore(0x00, 0xb7b914ca)\\n mstore(0x20, p0)\\n mstore(0x40, 0x80)\\n mstore(0x60, p2)\\n mstore(0x80, 0xc0)\\n writeString(0xa0, p1)\\n writeString(0xe0, p3)\\n }\\n _sendLogPayload(0x1c, 0x104);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n }\\n }\\n\\n function log(uint256 p0, bytes32 p1, bytes32 p2, address p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n // Selector of `log(uint256,string,string,address)`.\\n mstore(0x00, 0xd583c602)\\n mstore(0x20, p0)\\n mstore(0x40, 0x80)\\n mstore(0x60, 0xc0)\\n mstore(0x80, p3)\\n writeString(0xa0, p1)\\n writeString(0xe0, p2)\\n }\\n _sendLogPayload(0x1c, 0x104);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n }\\n }\\n\\n function log(uint256 p0, bytes32 p1, bytes32 p2, bool p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n // Selector of `log(uint256,string,string,bool)`.\\n mstore(0x00, 0xb3a6b6bd)\\n mstore(0x20, p0)\\n mstore(0x40, 0x80)\\n mstore(0x60, 0xc0)\\n mstore(0x80, p3)\\n writeString(0xa0, p1)\\n writeString(0xe0, p2)\\n }\\n _sendLogPayload(0x1c, 0x104);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n }\\n }\\n\\n function log(uint256 p0, bytes32 p1, bytes32 p2, uint256 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n // Selector of `log(uint256,string,string,uint256)`.\\n mstore(0x00, 0xb028c9bd)\\n mstore(0x20, p0)\\n mstore(0x40, 0x80)\\n mstore(0x60, 0xc0)\\n mstore(0x80, p3)\\n writeString(0xa0, p1)\\n writeString(0xe0, p2)\\n }\\n _sendLogPayload(0x1c, 0x104);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n }\\n }\\n\\n function log(uint256 p0, bytes32 p1, bytes32 p2, bytes32 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n bytes32 m9;\\n bytes32 m10;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n m9 := mload(0x120)\\n m10 := mload(0x140)\\n // Selector of `log(uint256,string,string,string)`.\\n mstore(0x00, 0x21ad0683)\\n mstore(0x20, p0)\\n mstore(0x40, 0x80)\\n mstore(0x60, 0xc0)\\n mstore(0x80, 0x100)\\n writeString(0xa0, p1)\\n writeString(0xe0, p2)\\n writeString(0x120, p3)\\n }\\n _sendLogPayload(0x1c, 0x144);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n mstore(0x120, m9)\\n mstore(0x140, m10)\\n }\\n }\\n\\n function log(bytes32 p0, address p1, address p2, address p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(string,address,address,address)`.\\n mstore(0x00, 0xed8f28f6)\\n mstore(0x20, 0x80)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n writeString(0xa0, p0)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(bytes32 p0, address p1, address p2, bool p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(string,address,address,bool)`.\\n mstore(0x00, 0xb59dbd60)\\n mstore(0x20, 0x80)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n writeString(0xa0, p0)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(bytes32 p0, address p1, address p2, uint256 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(string,address,address,uint256)`.\\n mstore(0x00, 0x8ef3f399)\\n mstore(0x20, 0x80)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n writeString(0xa0, p0)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(bytes32 p0, address p1, address p2, bytes32 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n // Selector of `log(string,address,address,string)`.\\n mstore(0x00, 0x800a1c67)\\n mstore(0x20, 0x80)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, 0xc0)\\n writeString(0xa0, p0)\\n writeString(0xe0, p3)\\n }\\n _sendLogPayload(0x1c, 0x104);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n }\\n }\\n\\n function log(bytes32 p0, address p1, bool p2, address p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(string,address,bool,address)`.\\n mstore(0x00, 0x223603bd)\\n mstore(0x20, 0x80)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n writeString(0xa0, p0)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(bytes32 p0, address p1, bool p2, bool p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(string,address,bool,bool)`.\\n mstore(0x00, 0x79884c2b)\\n mstore(0x20, 0x80)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n writeString(0xa0, p0)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(bytes32 p0, address p1, bool p2, uint256 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(string,address,bool,uint256)`.\\n mstore(0x00, 0x3e9f866a)\\n mstore(0x20, 0x80)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n writeString(0xa0, p0)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(bytes32 p0, address p1, bool p2, bytes32 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n // Selector of `log(string,address,bool,string)`.\\n mstore(0x00, 0x0454c079)\\n mstore(0x20, 0x80)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, 0xc0)\\n writeString(0xa0, p0)\\n writeString(0xe0, p3)\\n }\\n _sendLogPayload(0x1c, 0x104);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n }\\n }\\n\\n function log(bytes32 p0, address p1, uint256 p2, address p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(string,address,uint256,address)`.\\n mstore(0x00, 0x63fb8bc5)\\n mstore(0x20, 0x80)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n writeString(0xa0, p0)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(bytes32 p0, address p1, uint256 p2, bool p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(string,address,uint256,bool)`.\\n mstore(0x00, 0xfc4845f0)\\n mstore(0x20, 0x80)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n writeString(0xa0, p0)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(bytes32 p0, address p1, uint256 p2, uint256 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(string,address,uint256,uint256)`.\\n mstore(0x00, 0xf8f51b1e)\\n mstore(0x20, 0x80)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n writeString(0xa0, p0)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(bytes32 p0, address p1, uint256 p2, bytes32 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n // Selector of `log(string,address,uint256,string)`.\\n mstore(0x00, 0x5a477632)\\n mstore(0x20, 0x80)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, 0xc0)\\n writeString(0xa0, p0)\\n writeString(0xe0, p3)\\n }\\n _sendLogPayload(0x1c, 0x104);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n }\\n }\\n\\n function log(bytes32 p0, address p1, bytes32 p2, address p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n // Selector of `log(string,address,string,address)`.\\n mstore(0x00, 0xaabc9a31)\\n mstore(0x20, 0x80)\\n mstore(0x40, p1)\\n mstore(0x60, 0xc0)\\n mstore(0x80, p3)\\n writeString(0xa0, p0)\\n writeString(0xe0, p2)\\n }\\n _sendLogPayload(0x1c, 0x104);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n }\\n }\\n\\n function log(bytes32 p0, address p1, bytes32 p2, bool p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n // Selector of `log(string,address,string,bool)`.\\n mstore(0x00, 0x5f15d28c)\\n mstore(0x20, 0x80)\\n mstore(0x40, p1)\\n mstore(0x60, 0xc0)\\n mstore(0x80, p3)\\n writeString(0xa0, p0)\\n writeString(0xe0, p2)\\n }\\n _sendLogPayload(0x1c, 0x104);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n }\\n }\\n\\n function log(bytes32 p0, address p1, bytes32 p2, uint256 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n // Selector of `log(string,address,string,uint256)`.\\n mstore(0x00, 0x91d1112e)\\n mstore(0x20, 0x80)\\n mstore(0x40, p1)\\n mstore(0x60, 0xc0)\\n mstore(0x80, p3)\\n writeString(0xa0, p0)\\n writeString(0xe0, p2)\\n }\\n _sendLogPayload(0x1c, 0x104);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n }\\n }\\n\\n function log(bytes32 p0, address p1, bytes32 p2, bytes32 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n bytes32 m9;\\n bytes32 m10;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n m9 := mload(0x120)\\n m10 := mload(0x140)\\n // Selector of `log(string,address,string,string)`.\\n mstore(0x00, 0x245986f2)\\n mstore(0x20, 0x80)\\n mstore(0x40, p1)\\n mstore(0x60, 0xc0)\\n mstore(0x80, 0x100)\\n writeString(0xa0, p0)\\n writeString(0xe0, p2)\\n writeString(0x120, p3)\\n }\\n _sendLogPayload(0x1c, 0x144);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n mstore(0x120, m9)\\n mstore(0x140, m10)\\n }\\n }\\n\\n function log(bytes32 p0, bool p1, address p2, address p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(string,bool,address,address)`.\\n mstore(0x00, 0x33e9dd1d)\\n mstore(0x20, 0x80)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n writeString(0xa0, p0)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(bytes32 p0, bool p1, address p2, bool p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(string,bool,address,bool)`.\\n mstore(0x00, 0x958c28c6)\\n mstore(0x20, 0x80)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n writeString(0xa0, p0)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(bytes32 p0, bool p1, address p2, uint256 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(string,bool,address,uint256)`.\\n mstore(0x00, 0x5d08bb05)\\n mstore(0x20, 0x80)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n writeString(0xa0, p0)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(bytes32 p0, bool p1, address p2, bytes32 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n // Selector of `log(string,bool,address,string)`.\\n mstore(0x00, 0x2d8e33a4)\\n mstore(0x20, 0x80)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, 0xc0)\\n writeString(0xa0, p0)\\n writeString(0xe0, p3)\\n }\\n _sendLogPayload(0x1c, 0x104);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n }\\n }\\n\\n function log(bytes32 p0, bool p1, bool p2, address p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(string,bool,bool,address)`.\\n mstore(0x00, 0x7190a529)\\n mstore(0x20, 0x80)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n writeString(0xa0, p0)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(bytes32 p0, bool p1, bool p2, bool p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(string,bool,bool,bool)`.\\n mstore(0x00, 0x895af8c5)\\n mstore(0x20, 0x80)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n writeString(0xa0, p0)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(bytes32 p0, bool p1, bool p2, uint256 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(string,bool,bool,uint256)`.\\n mstore(0x00, 0x8e3f78a9)\\n mstore(0x20, 0x80)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n writeString(0xa0, p0)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(bytes32 p0, bool p1, bool p2, bytes32 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n // Selector of `log(string,bool,bool,string)`.\\n mstore(0x00, 0x9d22d5dd)\\n mstore(0x20, 0x80)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, 0xc0)\\n writeString(0xa0, p0)\\n writeString(0xe0, p3)\\n }\\n _sendLogPayload(0x1c, 0x104);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n }\\n }\\n\\n function log(bytes32 p0, bool p1, uint256 p2, address p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(string,bool,uint256,address)`.\\n mstore(0x00, 0x935e09bf)\\n mstore(0x20, 0x80)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n writeString(0xa0, p0)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(bytes32 p0, bool p1, uint256 p2, bool p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(string,bool,uint256,bool)`.\\n mstore(0x00, 0x8af7cf8a)\\n mstore(0x20, 0x80)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n writeString(0xa0, p0)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(bytes32 p0, bool p1, uint256 p2, uint256 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(string,bool,uint256,uint256)`.\\n mstore(0x00, 0x64b5bb67)\\n mstore(0x20, 0x80)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n writeString(0xa0, p0)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(bytes32 p0, bool p1, uint256 p2, bytes32 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n // Selector of `log(string,bool,uint256,string)`.\\n mstore(0x00, 0x742d6ee7)\\n mstore(0x20, 0x80)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, 0xc0)\\n writeString(0xa0, p0)\\n writeString(0xe0, p3)\\n }\\n _sendLogPayload(0x1c, 0x104);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n }\\n }\\n\\n function log(bytes32 p0, bool p1, bytes32 p2, address p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n // Selector of `log(string,bool,string,address)`.\\n mstore(0x00, 0xe0625b29)\\n mstore(0x20, 0x80)\\n mstore(0x40, p1)\\n mstore(0x60, 0xc0)\\n mstore(0x80, p3)\\n writeString(0xa0, p0)\\n writeString(0xe0, p2)\\n }\\n _sendLogPayload(0x1c, 0x104);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n }\\n }\\n\\n function log(bytes32 p0, bool p1, bytes32 p2, bool p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n // Selector of `log(string,bool,string,bool)`.\\n mstore(0x00, 0x3f8a701d)\\n mstore(0x20, 0x80)\\n mstore(0x40, p1)\\n mstore(0x60, 0xc0)\\n mstore(0x80, p3)\\n writeString(0xa0, p0)\\n writeString(0xe0, p2)\\n }\\n _sendLogPayload(0x1c, 0x104);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n }\\n }\\n\\n function log(bytes32 p0, bool p1, bytes32 p2, uint256 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n // Selector of `log(string,bool,string,uint256)`.\\n mstore(0x00, 0x24f91465)\\n mstore(0x20, 0x80)\\n mstore(0x40, p1)\\n mstore(0x60, 0xc0)\\n mstore(0x80, p3)\\n writeString(0xa0, p0)\\n writeString(0xe0, p2)\\n }\\n _sendLogPayload(0x1c, 0x104);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n }\\n }\\n\\n function log(bytes32 p0, bool p1, bytes32 p2, bytes32 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n bytes32 m9;\\n bytes32 m10;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n m9 := mload(0x120)\\n m10 := mload(0x140)\\n // Selector of `log(string,bool,string,string)`.\\n mstore(0x00, 0xa826caeb)\\n mstore(0x20, 0x80)\\n mstore(0x40, p1)\\n mstore(0x60, 0xc0)\\n mstore(0x80, 0x100)\\n writeString(0xa0, p0)\\n writeString(0xe0, p2)\\n writeString(0x120, p3)\\n }\\n _sendLogPayload(0x1c, 0x144);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n mstore(0x120, m9)\\n mstore(0x140, m10)\\n }\\n }\\n\\n function log(bytes32 p0, uint256 p1, address p2, address p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(string,uint256,address,address)`.\\n mstore(0x00, 0x5ea2b7ae)\\n mstore(0x20, 0x80)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n writeString(0xa0, p0)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(bytes32 p0, uint256 p1, address p2, bool p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(string,uint256,address,bool)`.\\n mstore(0x00, 0x82112a42)\\n mstore(0x20, 0x80)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n writeString(0xa0, p0)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(bytes32 p0, uint256 p1, address p2, uint256 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(string,uint256,address,uint256)`.\\n mstore(0x00, 0x4f04fdc6)\\n mstore(0x20, 0x80)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n writeString(0xa0, p0)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(bytes32 p0, uint256 p1, address p2, bytes32 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n // Selector of `log(string,uint256,address,string)`.\\n mstore(0x00, 0x9ffb2f93)\\n mstore(0x20, 0x80)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, 0xc0)\\n writeString(0xa0, p0)\\n writeString(0xe0, p3)\\n }\\n _sendLogPayload(0x1c, 0x104);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n }\\n }\\n\\n function log(bytes32 p0, uint256 p1, bool p2, address p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(string,uint256,bool,address)`.\\n mstore(0x00, 0xe0e95b98)\\n mstore(0x20, 0x80)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n writeString(0xa0, p0)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(bytes32 p0, uint256 p1, bool p2, bool p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(string,uint256,bool,bool)`.\\n mstore(0x00, 0x354c36d6)\\n mstore(0x20, 0x80)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n writeString(0xa0, p0)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(bytes32 p0, uint256 p1, bool p2, uint256 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(string,uint256,bool,uint256)`.\\n mstore(0x00, 0xe41b6f6f)\\n mstore(0x20, 0x80)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n writeString(0xa0, p0)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(bytes32 p0, uint256 p1, bool p2, bytes32 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n // Selector of `log(string,uint256,bool,string)`.\\n mstore(0x00, 0xabf73a98)\\n mstore(0x20, 0x80)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, 0xc0)\\n writeString(0xa0, p0)\\n writeString(0xe0, p3)\\n }\\n _sendLogPayload(0x1c, 0x104);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n }\\n }\\n\\n function log(bytes32 p0, uint256 p1, uint256 p2, address p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(string,uint256,uint256,address)`.\\n mstore(0x00, 0xe21de278)\\n mstore(0x20, 0x80)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n writeString(0xa0, p0)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(bytes32 p0, uint256 p1, uint256 p2, bool p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(string,uint256,uint256,bool)`.\\n mstore(0x00, 0x7626db92)\\n mstore(0x20, 0x80)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n writeString(0xa0, p0)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(bytes32 p0, uint256 p1, uint256 p2, uint256 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(string,uint256,uint256,uint256)`.\\n mstore(0x00, 0xa7a87853)\\n mstore(0x20, 0x80)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n writeString(0xa0, p0)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(bytes32 p0, uint256 p1, uint256 p2, bytes32 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n // Selector of `log(string,uint256,uint256,string)`.\\n mstore(0x00, 0x854b3496)\\n mstore(0x20, 0x80)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, 0xc0)\\n writeString(0xa0, p0)\\n writeString(0xe0, p3)\\n }\\n _sendLogPayload(0x1c, 0x104);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n }\\n }\\n\\n function log(bytes32 p0, uint256 p1, bytes32 p2, address p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n // Selector of `log(string,uint256,string,address)`.\\n mstore(0x00, 0x7c4632a4)\\n mstore(0x20, 0x80)\\n mstore(0x40, p1)\\n mstore(0x60, 0xc0)\\n mstore(0x80, p3)\\n writeString(0xa0, p0)\\n writeString(0xe0, p2)\\n }\\n _sendLogPayload(0x1c, 0x104);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n }\\n }\\n\\n function log(bytes32 p0, uint256 p1, bytes32 p2, bool p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n // Selector of `log(string,uint256,string,bool)`.\\n mstore(0x00, 0x7d24491d)\\n mstore(0x20, 0x80)\\n mstore(0x40, p1)\\n mstore(0x60, 0xc0)\\n mstore(0x80, p3)\\n writeString(0xa0, p0)\\n writeString(0xe0, p2)\\n }\\n _sendLogPayload(0x1c, 0x104);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n }\\n }\\n\\n function log(bytes32 p0, uint256 p1, bytes32 p2, uint256 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n // Selector of `log(string,uint256,string,uint256)`.\\n mstore(0x00, 0xc67ea9d1)\\n mstore(0x20, 0x80)\\n mstore(0x40, p1)\\n mstore(0x60, 0xc0)\\n mstore(0x80, p3)\\n writeString(0xa0, p0)\\n writeString(0xe0, p2)\\n }\\n _sendLogPayload(0x1c, 0x104);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n }\\n }\\n\\n function log(bytes32 p0, uint256 p1, bytes32 p2, bytes32 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n bytes32 m9;\\n bytes32 m10;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n m9 := mload(0x120)\\n m10 := mload(0x140)\\n // Selector of `log(string,uint256,string,string)`.\\n mstore(0x00, 0x5ab84e1f)\\n mstore(0x20, 0x80)\\n mstore(0x40, p1)\\n mstore(0x60, 0xc0)\\n mstore(0x80, 0x100)\\n writeString(0xa0, p0)\\n writeString(0xe0, p2)\\n writeString(0x120, p3)\\n }\\n _sendLogPayload(0x1c, 0x144);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n mstore(0x120, m9)\\n mstore(0x140, m10)\\n }\\n }\\n\\n function log(bytes32 p0, bytes32 p1, address p2, address p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n // Selector of `log(string,string,address,address)`.\\n mstore(0x00, 0x439c7bef)\\n mstore(0x20, 0x80)\\n mstore(0x40, 0xc0)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n writeString(0xa0, p0)\\n writeString(0xe0, p1)\\n }\\n _sendLogPayload(0x1c, 0x104);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n }\\n }\\n\\n function log(bytes32 p0, bytes32 p1, address p2, bool p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n // Selector of `log(string,string,address,bool)`.\\n mstore(0x00, 0x5ccd4e37)\\n mstore(0x20, 0x80)\\n mstore(0x40, 0xc0)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n writeString(0xa0, p0)\\n writeString(0xe0, p1)\\n }\\n _sendLogPayload(0x1c, 0x104);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n }\\n }\\n\\n function log(bytes32 p0, bytes32 p1, address p2, uint256 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n // Selector of `log(string,string,address,uint256)`.\\n mstore(0x00, 0x7cc3c607)\\n mstore(0x20, 0x80)\\n mstore(0x40, 0xc0)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n writeString(0xa0, p0)\\n writeString(0xe0, p1)\\n }\\n _sendLogPayload(0x1c, 0x104);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n }\\n }\\n\\n function log(bytes32 p0, bytes32 p1, address p2, bytes32 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n bytes32 m9;\\n bytes32 m10;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n m9 := mload(0x120)\\n m10 := mload(0x140)\\n // Selector of `log(string,string,address,string)`.\\n mstore(0x00, 0xeb1bff80)\\n mstore(0x20, 0x80)\\n mstore(0x40, 0xc0)\\n mstore(0x60, p2)\\n mstore(0x80, 0x100)\\n writeString(0xa0, p0)\\n writeString(0xe0, p1)\\n writeString(0x120, p3)\\n }\\n _sendLogPayload(0x1c, 0x144);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n mstore(0x120, m9)\\n mstore(0x140, m10)\\n }\\n }\\n\\n function log(bytes32 p0, bytes32 p1, bool p2, address p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n // Selector of `log(string,string,bool,address)`.\\n mstore(0x00, 0xc371c7db)\\n mstore(0x20, 0x80)\\n mstore(0x40, 0xc0)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n writeString(0xa0, p0)\\n writeString(0xe0, p1)\\n }\\n _sendLogPayload(0x1c, 0x104);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n }\\n }\\n\\n function log(bytes32 p0, bytes32 p1, bool p2, bool p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n // Selector of `log(string,string,bool,bool)`.\\n mstore(0x00, 0x40785869)\\n mstore(0x20, 0x80)\\n mstore(0x40, 0xc0)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n writeString(0xa0, p0)\\n writeString(0xe0, p1)\\n }\\n _sendLogPayload(0x1c, 0x104);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n }\\n }\\n\\n function log(bytes32 p0, bytes32 p1, bool p2, uint256 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n // Selector of `log(string,string,bool,uint256)`.\\n mstore(0x00, 0xd6aefad2)\\n mstore(0x20, 0x80)\\n mstore(0x40, 0xc0)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n writeString(0xa0, p0)\\n writeString(0xe0, p1)\\n }\\n _sendLogPayload(0x1c, 0x104);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n }\\n }\\n\\n function log(bytes32 p0, bytes32 p1, bool p2, bytes32 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n bytes32 m9;\\n bytes32 m10;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n m9 := mload(0x120)\\n m10 := mload(0x140)\\n // Selector of `log(string,string,bool,string)`.\\n mstore(0x00, 0x5e84b0ea)\\n mstore(0x20, 0x80)\\n mstore(0x40, 0xc0)\\n mstore(0x60, p2)\\n mstore(0x80, 0x100)\\n writeString(0xa0, p0)\\n writeString(0xe0, p1)\\n writeString(0x120, p3)\\n }\\n _sendLogPayload(0x1c, 0x144);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n mstore(0x120, m9)\\n mstore(0x140, m10)\\n }\\n }\\n\\n function log(bytes32 p0, bytes32 p1, uint256 p2, address p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n // Selector of `log(string,string,uint256,address)`.\\n mstore(0x00, 0x1023f7b2)\\n mstore(0x20, 0x80)\\n mstore(0x40, 0xc0)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n writeString(0xa0, p0)\\n writeString(0xe0, p1)\\n }\\n _sendLogPayload(0x1c, 0x104);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n }\\n }\\n\\n function log(bytes32 p0, bytes32 p1, uint256 p2, bool p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n // Selector of `log(string,string,uint256,bool)`.\\n mstore(0x00, 0xc3a8a654)\\n mstore(0x20, 0x80)\\n mstore(0x40, 0xc0)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n writeString(0xa0, p0)\\n writeString(0xe0, p1)\\n }\\n _sendLogPayload(0x1c, 0x104);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n }\\n }\\n\\n function log(bytes32 p0, bytes32 p1, uint256 p2, uint256 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n // Selector of `log(string,string,uint256,uint256)`.\\n mstore(0x00, 0xf45d7d2c)\\n mstore(0x20, 0x80)\\n mstore(0x40, 0xc0)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n writeString(0xa0, p0)\\n writeString(0xe0, p1)\\n }\\n _sendLogPayload(0x1c, 0x104);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n }\\n }\\n\\n function log(bytes32 p0, bytes32 p1, uint256 p2, bytes32 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n bytes32 m9;\\n bytes32 m10;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n m9 := mload(0x120)\\n m10 := mload(0x140)\\n // Selector of `log(string,string,uint256,string)`.\\n mstore(0x00, 0x5d1a971a)\\n mstore(0x20, 0x80)\\n mstore(0x40, 0xc0)\\n mstore(0x60, p2)\\n mstore(0x80, 0x100)\\n writeString(0xa0, p0)\\n writeString(0xe0, p1)\\n writeString(0x120, p3)\\n }\\n _sendLogPayload(0x1c, 0x144);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n mstore(0x120, m9)\\n mstore(0x140, m10)\\n }\\n }\\n\\n function log(bytes32 p0, bytes32 p1, bytes32 p2, address p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n bytes32 m9;\\n bytes32 m10;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n m9 := mload(0x120)\\n m10 := mload(0x140)\\n // Selector of `log(string,string,string,address)`.\\n mstore(0x00, 0x6d572f44)\\n mstore(0x20, 0x80)\\n mstore(0x40, 0xc0)\\n mstore(0x60, 0x100)\\n mstore(0x80, p3)\\n writeString(0xa0, p0)\\n writeString(0xe0, p1)\\n writeString(0x120, p2)\\n }\\n _sendLogPayload(0x1c, 0x144);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n mstore(0x120, m9)\\n mstore(0x140, m10)\\n }\\n }\\n\\n function log(bytes32 p0, bytes32 p1, bytes32 p2, bool p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n bytes32 m9;\\n bytes32 m10;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n m9 := mload(0x120)\\n m10 := mload(0x140)\\n // Selector of `log(string,string,string,bool)`.\\n mstore(0x00, 0x2c1754ed)\\n mstore(0x20, 0x80)\\n mstore(0x40, 0xc0)\\n mstore(0x60, 0x100)\\n mstore(0x80, p3)\\n writeString(0xa0, p0)\\n writeString(0xe0, p1)\\n writeString(0x120, p2)\\n }\\n _sendLogPayload(0x1c, 0x144);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n mstore(0x120, m9)\\n mstore(0x140, m10)\\n }\\n }\\n\\n function log(bytes32 p0, bytes32 p1, bytes32 p2, uint256 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n bytes32 m9;\\n bytes32 m10;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n m9 := mload(0x120)\\n m10 := mload(0x140)\\n // Selector of `log(string,string,string,uint256)`.\\n mstore(0x00, 0x8eafb02b)\\n mstore(0x20, 0x80)\\n mstore(0x40, 0xc0)\\n mstore(0x60, 0x100)\\n mstore(0x80, p3)\\n writeString(0xa0, p0)\\n writeString(0xe0, p1)\\n writeString(0x120, p2)\\n }\\n _sendLogPayload(0x1c, 0x144);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n mstore(0x120, m9)\\n mstore(0x140, m10)\\n }\\n }\\n\\n function log(bytes32 p0, bytes32 p1, bytes32 p2, bytes32 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n bytes32 m9;\\n bytes32 m10;\\n bytes32 m11;\\n bytes32 m12;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n m9 := mload(0x120)\\n m10 := mload(0x140)\\n m11 := mload(0x160)\\n m12 := mload(0x180)\\n // Selector of `log(string,string,string,string)`.\\n mstore(0x00, 0xde68f20a)\\n mstore(0x20, 0x80)\\n mstore(0x40, 0xc0)\\n mstore(0x60, 0x100)\\n mstore(0x80, 0x140)\\n writeString(0xa0, p0)\\n writeString(0xe0, p1)\\n writeString(0x120, p2)\\n writeString(0x160, p3)\\n }\\n _sendLogPayload(0x1c, 0x184);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n mstore(0x120, m9)\\n mstore(0x140, m10)\\n mstore(0x160, m11)\\n mstore(0x180, m12)\\n }\\n }\\n}\\n\",\"keccak256\":\"0xbef9786cb49d3eade757bad87568c49c8c8f35721f0193c95ffb055d9e466e11\",\"license\":\"MIT\"},\"scripts/FetchChainInfo.s.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\nimport { Script } from \\\"forge-std/Script.sol\\\";\\nimport { GameTypes, GameType } from \\\"src/dispute/lib/Types.sol\\\";\\n\\n/// @notice Contains getters for arbitrary methods from all L1 contracts, including legacy getters\\n/// that have since been deprecated.\\ninterface IFetcher {\\n function guardian() external view returns (address);\\n function GUARDIAN() external view returns (address);\\n function systemConfig() external view returns (address);\\n function SYSTEM_CONFIG() external view returns (address);\\n function disputeGameFactory() external view returns (address);\\n function ethLockbox() external view returns (address);\\n function superchainConfig() external view returns (address);\\n function messenger() external view returns (address);\\n function addressManager() external view returns (address);\\n function PORTAL() external view returns (address);\\n function portal() external view returns (address);\\n function l1ERC721Bridge() external view returns (address);\\n function optimismMintableERC20Factory() external view returns (address);\\n function gameImpls(GameType _gameType) external view returns (address);\\n function respectedGameType() external view returns (GameType);\\n function anchorStateRegistry() external view returns (address);\\n function L2_ORACLE() external view returns (address);\\n function l2Oracle() external view returns (address);\\n function vm() external view returns (address);\\n function oracle() external view returns (address);\\n function challenger() external view returns (address);\\n function proposer() external view returns (address);\\n function PROPOSER() external view returns (address);\\n function batcherHash() external view returns (bytes32);\\n function admin() external view returns (address);\\n function owner() external view returns (address);\\n function unsafeBlockSigner() external view returns (address);\\n function weth() external view returns (address);\\n}\\n\\ncontract FetchChainInfoInput {\\n address internal _systemConfigProxy;\\n address internal _l1StandardBridgeProxy;\\n\\n function set(bytes4 _sel, address _addr) public {\\n require(_addr != address(0), \\\"FetchChainInfoInput: cannot set zero address\\\");\\n if (_sel == this.systemConfigProxy.selector) _systemConfigProxy = _addr;\\n else if (_sel == this.l1StandardBridgeProxy.selector) _l1StandardBridgeProxy = _addr;\\n else revert(\\\"FetchChainInfoInput: unknown selector\\\");\\n }\\n\\n function systemConfigProxy() public view returns (address) {\\n require(_systemConfigProxy != address(0), \\\"FetchChainInfoInput: systemConfigProxy not set\\\");\\n return _systemConfigProxy;\\n }\\n\\n function l1StandardBridgeProxy() public view returns (address) {\\n require(_l1StandardBridgeProxy != address(0), \\\"FetchChainInfoInput: l1StandardBridgeProxy not set\\\");\\n return _l1StandardBridgeProxy;\\n }\\n}\\n\\ncontract FetchChainInfoOutput {\\n // contract addresses\\n // - SuperchainContracts\\n address internal _superchainConfigProxy;\\n // - ImplementationsContracts\\n address internal _mipsImpl;\\n address internal _preimageOracleImpl;\\n // - OpChainContracts\\n address internal _addressManagerImpl;\\n address internal _ethLockboxProxy;\\n address internal _l1CrossDomainMessengerProxy;\\n address internal _l1Erc721BridgeProxy;\\n address internal _l1StandardBridgeProxy;\\n address internal _l2OutputOracleProxy;\\n address internal _optimismMintableErc20FactoryProxy;\\n address internal _optimismPortalProxy;\\n address internal _systemConfigProxy;\\n address internal _opChainProxyAdminImpl;\\n address internal _anchorStateRegistryProxy;\\n address internal _delayedWethPermissionedGameProxy;\\n address internal _delayedWethPermissionlessGameProxy;\\n address internal _disputeGameFactoryProxy;\\n address internal _faultDisputeGameImpl;\\n address internal _faultDisputeGameCannonKonaImpl;\\n address internal _permissionedDisputeGameImpl;\\n\\n // roles\\n address internal _systemConfigOwner;\\n address internal _opChainProxyAdminOwner;\\n address internal _opChainGuardian;\\n address internal _challenger;\\n address internal _proposer;\\n address internal _unsafeBlockSigner;\\n address internal _batchSubmitter;\\n\\n // fault proof status\\n bool internal _permissioned;\\n bool internal _permissionless;\\n GameType internal _respectedGameType;\\n\\n function set(bytes4 _sel, address _addr) public {\\n // SuperchainContracts\\n if (_sel == this.superchainConfigProxy.selector) _superchainConfigProxy = _addr;\\n // - ImplementationsContracts\\n else if (_sel == this.mipsImpl.selector) _mipsImpl = _addr;\\n else if (_sel == this.preimageOracleImpl.selector) _preimageOracleImpl = _addr;\\n // - OpChainContracts\\n else if (_sel == this.addressManagerImpl.selector) _addressManagerImpl = _addr;\\n else if (_sel == this.ethLockboxProxy.selector) _ethLockboxProxy = _addr;\\n else if (_sel == this.l1CrossDomainMessengerProxy.selector) _l1CrossDomainMessengerProxy = _addr;\\n else if (_sel == this.l1Erc721BridgeProxy.selector) _l1Erc721BridgeProxy = _addr;\\n else if (_sel == this.l1StandardBridgeProxy.selector) _l1StandardBridgeProxy = _addr;\\n else if (_sel == this.l2OutputOracleProxy.selector) _l2OutputOracleProxy = _addr;\\n else if (_sel == this.optimismMintableErc20FactoryProxy.selector) _optimismMintableErc20FactoryProxy = _addr;\\n else if (_sel == this.optimismPortalProxy.selector) _optimismPortalProxy = _addr;\\n else if (_sel == this.systemConfigProxy.selector) _systemConfigProxy = _addr;\\n else if (_sel == this.opChainProxyAdminImpl.selector) _opChainProxyAdminImpl = _addr;\\n else if (_sel == this.anchorStateRegistryProxy.selector) _anchorStateRegistryProxy = _addr;\\n else if (_sel == this.delayedWethPermissionedGameProxy.selector) _delayedWethPermissionedGameProxy = _addr;\\n else if (_sel == this.delayedWethPermissionlessGameProxy.selector) _delayedWethPermissionlessGameProxy = _addr;\\n else if (_sel == this.disputeGameFactoryProxy.selector) _disputeGameFactoryProxy = _addr;\\n else if (_sel == this.faultDisputeGameImpl.selector) _faultDisputeGameImpl = _addr;\\n else if (_sel == this.faultDisputeGameCannonKonaImpl.selector) _faultDisputeGameCannonKonaImpl = _addr;\\n else if (_sel == this.permissionedDisputeGameImpl.selector) _permissionedDisputeGameImpl = _addr;\\n // roles\\n else if (_sel == this.systemConfigOwner.selector) _systemConfigOwner = _addr;\\n else if (_sel == this.opChainProxyAdminOwner.selector) _opChainProxyAdminOwner = _addr;\\n else if (_sel == this.opChainGuardian.selector) _opChainGuardian = _addr;\\n else if (_sel == this.challenger.selector) _challenger = _addr;\\n else if (_sel == this.proposer.selector) _proposer = _addr;\\n else if (_sel == this.unsafeBlockSigner.selector) _unsafeBlockSigner = _addr;\\n else if (_sel == this.batchSubmitter.selector) _batchSubmitter = _addr;\\n else revert(\\\"FetchChainInfoOutput: unknown address selector test\\\");\\n }\\n\\n function set(bytes4 _sel, bool _bool) public {\\n if (_sel == this.permissioned.selector) _permissioned = _bool;\\n else if (_sel == this.permissionless.selector) _permissionless = _bool;\\n else revert(\\\"FetchChainInfoOutput: unknown bool selector\\\");\\n }\\n\\n function set(bytes4 _sel, GameType _gameType) public {\\n if (_sel == this.respectedGameType.selector) _respectedGameType = _gameType;\\n else revert(\\\"FetchChainInfoOutput: unknown GameType selector\\\");\\n }\\n\\n function addressManagerImpl() public view returns (address) {\\n require(_addressManagerImpl != address(0), \\\"FetchChainInfoOutput: addressManagerImpl not set\\\");\\n return _addressManagerImpl;\\n }\\n\\n function ethLockboxProxy() public view returns (address) {\\n return _ethLockboxProxy;\\n }\\n\\n function l1CrossDomainMessengerProxy() public view returns (address) {\\n require(_l1CrossDomainMessengerProxy != address(0), \\\"FetchChainInfoOutput: l1CrossDomainMessengerProxy not set\\\");\\n return _l1CrossDomainMessengerProxy;\\n }\\n\\n function l1Erc721BridgeProxy() public view returns (address) {\\n require(_l1Erc721BridgeProxy != address(0), \\\"FetchChainInfoOutput: l1Erc721BridgeProxy not set\\\");\\n return _l1Erc721BridgeProxy;\\n }\\n\\n function l1StandardBridgeProxy() public view returns (address) {\\n require(_l1StandardBridgeProxy != address(0), \\\"FetchChainInfoOutput: l1StandardBridgeProxy not set\\\");\\n return _l1StandardBridgeProxy;\\n }\\n\\n function l2OutputOracleProxy() public view returns (address) {\\n require(_l2OutputOracleProxy != address(0), \\\"FetchChainInfoOutput: l2OutputOracleProxy not set\\\");\\n return _l2OutputOracleProxy;\\n }\\n\\n function optimismMintableErc20FactoryProxy() public view returns (address) {\\n require(\\n _optimismMintableErc20FactoryProxy != address(0),\\n \\\"FetchChainInfoOutput: optimismMintableErc20FactoryProxy not set\\\"\\n );\\n return _optimismMintableErc20FactoryProxy;\\n }\\n\\n function optimismPortalProxy() public view returns (address) {\\n require(_optimismPortalProxy != address(0), \\\"FetchChainInfoOutput: optimismPortalProxy not set\\\");\\n return _optimismPortalProxy;\\n }\\n\\n function systemConfigProxy() public view returns (address) {\\n require(_systemConfigProxy != address(0), \\\"FetchChainInfoOutput: systemConfigProxy not set\\\");\\n return _systemConfigProxy;\\n }\\n\\n function opChainProxyAdminImpl() public view returns (address) {\\n require(_opChainProxyAdminImpl != address(0), \\\"FetchChainInfoOutput: opChainProxyAdminImpl not set\\\");\\n return _opChainProxyAdminImpl;\\n }\\n\\n function superchainConfigProxy() public view returns (address) {\\n require(_superchainConfigProxy != address(0), \\\"FetchChainInfoOutput: superchainConfigProxy not set\\\");\\n return _superchainConfigProxy;\\n }\\n\\n function anchorStateRegistryProxy() public view returns (address) {\\n require(_anchorStateRegistryProxy != address(0), \\\"FetchChainInfoOutput: anchorStateRegistryProxy not set\\\");\\n return _anchorStateRegistryProxy;\\n }\\n\\n function delayedWethPermissionedGameProxy() public view returns (address) {\\n return _delayedWethPermissionedGameProxy;\\n }\\n\\n function delayedWethPermissionlessGameProxy() public view returns (address) {\\n return _delayedWethPermissionlessGameProxy;\\n }\\n\\n function disputeGameFactoryProxy() public view returns (address) {\\n return _disputeGameFactoryProxy;\\n }\\n\\n function faultDisputeGameImpl() public view returns (address) {\\n require(_faultDisputeGameImpl != address(0), \\\"FetchChainInfoOutput: faultDisputeGameImpl not set\\\");\\n return _faultDisputeGameImpl;\\n }\\n\\n function faultDisputeGameCannonKonaImpl() public view returns (address) {\\n require(\\n _faultDisputeGameCannonKonaImpl != address(0),\\n \\\"FetchChainInfoOutput: faultDisputeGameCannonKonaImpl not set\\\"\\n );\\n return _faultDisputeGameCannonKonaImpl;\\n }\\n\\n function mipsImpl() public view returns (address) {\\n require(_mipsImpl != address(0), \\\"FetchChainInfoOutput: mipsImpl not set\\\");\\n return _mipsImpl;\\n }\\n\\n function permissionedDisputeGameImpl() public view returns (address) {\\n require(_permissionedDisputeGameImpl != address(0), \\\"FetchChainInfoOutput: permissionedDisputeGameImpl not set\\\");\\n return _permissionedDisputeGameImpl;\\n }\\n\\n function preimageOracleImpl() public view returns (address) {\\n require(_preimageOracleImpl != address(0), \\\"FetchChainInfoOutput: preimageOracleImpl not set\\\");\\n return _preimageOracleImpl;\\n }\\n\\n function systemConfigOwner() public view returns (address) {\\n require(_systemConfigOwner != address(0), \\\"FetchChainInfoOutput: systemConfigOwner not set\\\");\\n return _systemConfigOwner;\\n }\\n\\n function opChainProxyAdminOwner() public view returns (address) {\\n require(_opChainProxyAdminOwner != address(0), \\\"FetchChainInfoOutput: opChainProxyAdminOwner not set\\\");\\n return _opChainProxyAdminOwner;\\n }\\n\\n function opChainGuardian() public view returns (address) {\\n require(_opChainGuardian != address(0), \\\"FetchChainInfoOutput: opChainGuardian not set\\\");\\n return _opChainGuardian;\\n }\\n\\n function challenger() public view returns (address) {\\n require(_challenger != address(0), \\\"FetchChainInfoOutput: challenger not set\\\");\\n return _challenger;\\n }\\n\\n function proposer() public view returns (address) {\\n require(_proposer != address(0), \\\"FetchChainInfoOutput: proposer not set\\\");\\n return _proposer;\\n }\\n\\n function unsafeBlockSigner() public view returns (address) {\\n require(_unsafeBlockSigner != address(0), \\\"FetchChainInfoOutput: unsafeBlockSigner not set\\\");\\n return _unsafeBlockSigner;\\n }\\n\\n function batchSubmitter() public view returns (address) {\\n require(_batchSubmitter != address(0), \\\"FetchChainInfoOutput: batchSubmitter not set\\\");\\n return _batchSubmitter;\\n }\\n\\n function permissioned() public view returns (bool) {\\n return _permissioned;\\n }\\n\\n function permissionless() public view returns (bool) {\\n return _permissionless;\\n }\\n\\n function respectedGameType() public view returns (GameType) {\\n return _respectedGameType;\\n }\\n}\\n\\ncontract FetchChainInfo is Script {\\n function run(FetchChainInfoInput _fi, FetchChainInfoOutput _fo) public {\\n _processSystemConfig(_fi, _fo);\\n _processMessengerAndPortal(_fi, _fo);\\n _processFaultProofs(_fo);\\n }\\n\\n function _processSystemConfig(FetchChainInfoInput _fi, FetchChainInfoOutput _fo) internal {\\n address systemConfigProxy = _fi.systemConfigProxy();\\n _fo.set(_fo.systemConfigProxy.selector, systemConfigProxy);\\n\\n address systemConfigOwner = IFetcher(systemConfigProxy).owner();\\n _fo.set(_fo.systemConfigOwner.selector, systemConfigOwner);\\n\\n address unsafeBlockSigner = IFetcher(systemConfigProxy).unsafeBlockSigner();\\n _fo.set(_fo.unsafeBlockSigner.selector, unsafeBlockSigner);\\n\\n address batchSubmitter = _getBatchSubmitter(systemConfigProxy);\\n _fo.set(_fo.batchSubmitter.selector, batchSubmitter);\\n\\n address opChainProxyAdminImpl = _getProxyAdmin(systemConfigProxy);\\n _fo.set(_fo.opChainProxyAdminImpl.selector, opChainProxyAdminImpl);\\n\\n address opChainProxyAdminOwner = IFetcher(opChainProxyAdminImpl).owner();\\n _fo.set(_fo.opChainProxyAdminOwner.selector, opChainProxyAdminOwner);\\n\\n address l1Erc721BridgeProxy = _getL1ERC721BridgeProxy(systemConfigProxy);\\n _fo.set(_fo.l1Erc721BridgeProxy.selector, l1Erc721BridgeProxy);\\n\\n address optimismMintableErc20FactoryProxy = _getOptimismMintableERC20FactoryProxy(systemConfigProxy);\\n _fo.set(_fo.optimismMintableErc20FactoryProxy.selector, optimismMintableErc20FactoryProxy);\\n }\\n\\n function _processMessengerAndPortal(FetchChainInfoInput _fi, FetchChainInfoOutput _fo) internal {\\n address l1StandardBridgeProxy = _fi.l1StandardBridgeProxy();\\n _fo.set(_fo.l1StandardBridgeProxy.selector, l1StandardBridgeProxy);\\n\\n address l1CrossDomainMessengerProxy = IFetcher(l1StandardBridgeProxy).messenger();\\n _fo.set(_fo.l1CrossDomainMessengerProxy.selector, l1CrossDomainMessengerProxy);\\n\\n address addressManagerImpl = _getAddressManager(l1CrossDomainMessengerProxy);\\n _fo.set(_fo.addressManagerImpl.selector, addressManagerImpl);\\n\\n address optimismPortalProxy = _getOptimismPortalProxy(l1CrossDomainMessengerProxy);\\n _fo.set(_fo.optimismPortalProxy.selector, optimismPortalProxy);\\n\\n address opChainGuardian = _getGuardian(optimismPortalProxy);\\n _fo.set(_fo.opChainGuardian.selector, opChainGuardian);\\n\\n address ethLockboxProxy = _getEthLockboxProxy(optimismPortalProxy);\\n _fo.set(_fo.ethLockboxProxy.selector, ethLockboxProxy);\\n\\n address superchainConfigProxy = _getSuperchainConfigProxy(optimismPortalProxy);\\n _fo.set(_fo.superchainConfigProxy.selector, superchainConfigProxy);\\n }\\n\\n function _processFaultProofs(FetchChainInfoOutput _fo) internal {\\n address systemConfigProxy = _fo.systemConfigProxy();\\n address optimismPortalProxy = _fo.optimismPortalProxy();\\n\\n try IFetcher(optimismPortalProxy).respectedGameType() returns (GameType gameType_) {\\n _fo.set(_fo.respectedGameType.selector, gameType_);\\n } catch {\\n // default respectedGameType to uint32.max since 0 == CANNON\\n _fo.set(_fo.respectedGameType.selector, GameType.wrap(type(uint32).max));\\n address l2OutputOracleProxy;\\n try IFetcher(optimismPortalProxy).l2Oracle() returns (address l2Oracle_) {\\n l2OutputOracleProxy = l2Oracle_;\\n } catch {\\n l2OutputOracleProxy = IFetcher(optimismPortalProxy).L2_ORACLE();\\n }\\n _fo.set(_fo.l2OutputOracleProxy.selector, l2OutputOracleProxy);\\n\\n address proposer = IFetcher(l2OutputOracleProxy).PROPOSER();\\n _fo.set(_fo.proposer.selector, proposer);\\n\\n // no fault proofs installed so we're done\\n return;\\n }\\n\\n address disputeGameFactoryProxy = _getDisputeGameFactoryProxy(systemConfigProxy);\\n if (disputeGameFactoryProxy != address(0)) {\\n _fo.set(_fo.disputeGameFactoryProxy.selector, disputeGameFactoryProxy);\\n\\n address permissionedDisputeGameImpl = _getPermissionedDisputeGame(disputeGameFactoryProxy);\\n if (permissionedDisputeGameImpl != address(0)) {\\n // permissioned fault proofs installed\\n _fo.set(_fo.permissioned.selector, true);\\n _fo.set(_fo.permissionedDisputeGameImpl.selector, permissionedDisputeGameImpl);\\n\\n address challenger = IFetcher(permissionedDisputeGameImpl).challenger();\\n _fo.set(_fo.challenger.selector, challenger);\\n\\n address anchorStateRegistryProxy = IFetcher(permissionedDisputeGameImpl).anchorStateRegistry();\\n _fo.set(_fo.anchorStateRegistryProxy.selector, anchorStateRegistryProxy);\\n\\n address proposer = IFetcher(permissionedDisputeGameImpl).proposer();\\n _fo.set(_fo.proposer.selector, proposer);\\n\\n address delayedWethPermissionedGameProxy = _getDelayedWETHProxy(permissionedDisputeGameImpl);\\n _fo.set(_fo.delayedWethPermissionedGameProxy.selector, delayedWethPermissionedGameProxy);\\n\\n address mipsImpl = IFetcher(permissionedDisputeGameImpl).vm();\\n _fo.set(_fo.mipsImpl.selector, mipsImpl);\\n\\n address preimageOracleImpl = IFetcher(mipsImpl).oracle();\\n _fo.set(_fo.preimageOracleImpl.selector, preimageOracleImpl);\\n }\\n\\n address faultDisputeGameImpl = _getFaultDisputeGame(disputeGameFactoryProxy);\\n if (faultDisputeGameImpl != address(0)) {\\n // permissionless fault proofs installed\\n _fo.set(_fo.faultDisputeGameImpl.selector, faultDisputeGameImpl);\\n _fo.set(_fo.permissionless.selector, true);\\n\\n address delayedWethPermissionlessGameProxy = _getDelayedWETHProxy(faultDisputeGameImpl);\\n _fo.set(_fo.delayedWethPermissionlessGameProxy.selector, delayedWethPermissionlessGameProxy);\\n }\\n\\n address faultDisputeGameCannonKonaImpl =\\n _getFaultDisputeGame(disputeGameFactoryProxy, GameTypes.CANNON_KONA);\\n if (faultDisputeGameCannonKonaImpl != address(0)) {\\n _fo.set(_fo.faultDisputeGameCannonKonaImpl.selector, faultDisputeGameCannonKonaImpl);\\n }\\n } else {\\n // some older chains have L2OutputOracle instead of DisputeGameFactory.\\n address l2OutputOracleProxy = IFetcher(optimismPortalProxy).L2_ORACLE();\\n _fo.set(_fo.l2OutputOracleProxy.selector, l2OutputOracleProxy);\\n address proposer = IFetcher(l2OutputOracleProxy).PROPOSER();\\n _fo.set(_fo.proposer.selector, proposer);\\n }\\n }\\n\\n function _getGuardian(address _portal) internal view returns (address) {\\n try IFetcher(_portal).guardian() returns (address guardian_) {\\n return guardian_;\\n } catch {\\n return IFetcher(_portal).GUARDIAN();\\n }\\n }\\n\\n function _getSystemConfigProxy(address _portal) internal view returns (address) {\\n try IFetcher(_portal).systemConfig() returns (address systemConfig_) {\\n return systemConfig_;\\n } catch {\\n return IFetcher(_portal).SYSTEM_CONFIG();\\n }\\n }\\n\\n function _getOptimismPortalProxy(address _l1CrossDomainMessengerProxy) internal view returns (address) {\\n try IFetcher(_l1CrossDomainMessengerProxy).portal() returns (address optimismPortal_) {\\n return optimismPortal_;\\n } catch {\\n return IFetcher(_l1CrossDomainMessengerProxy).PORTAL();\\n }\\n }\\n\\n function _getAddressManager(address _l1CrossDomainMessengerProxy) internal view returns (address) {\\n uint256 ADDRESS_MANAGER_MAPPING_SLOT = 1;\\n bytes32 slot = keccak256(abi.encode(_l1CrossDomainMessengerProxy, ADDRESS_MANAGER_MAPPING_SLOT));\\n return address(uint160(uint256((vm.load(_l1CrossDomainMessengerProxy, slot)))));\\n }\\n\\n function _getL1ERC721BridgeProxy(address _systemConfigProxy) internal view returns (address) {\\n try IFetcher(_systemConfigProxy).l1ERC721Bridge() returns (address l1ERC721BridgeProxy_) {\\n return l1ERC721BridgeProxy_;\\n } catch {\\n return address(0);\\n }\\n }\\n\\n function _getOptimismMintableERC20FactoryProxy(address _systemConfigProxy) internal view returns (address) {\\n try IFetcher(_systemConfigProxy).optimismMintableERC20Factory() returns (\\n address optimismMintableERC20FactoryProxy_\\n ) {\\n return optimismMintableERC20FactoryProxy_;\\n } catch {\\n return address(0);\\n }\\n }\\n\\n function _getDisputeGameFactoryProxy(address _systemConfigProxy) internal view returns (address) {\\n try IFetcher(_systemConfigProxy).disputeGameFactory() returns (address disputeGameFactoryProxy_) {\\n return disputeGameFactoryProxy_;\\n } catch {\\n // Some older chains have L2OutputOracle instead of DisputeGameFactory\\n return address(0);\\n }\\n }\\n\\n function _getSuperchainConfigProxy(address _optimismPortalProxy) internal view returns (address) {\\n try IFetcher(_optimismPortalProxy).superchainConfig() returns (address superchainConfigProxy_) {\\n return superchainConfigProxy_;\\n } catch {\\n return address(0);\\n }\\n }\\n\\n function _getFaultDisputeGame(address _disputeGameFactoryProxy) internal view returns (address) {\\n try IFetcher(_disputeGameFactoryProxy).gameImpls(GameTypes.CANNON) returns (address faultDisputeGame_) {\\n return faultDisputeGame_;\\n } catch {\\n return address(0);\\n }\\n }\\n\\n function _getFaultDisputeGame(\\n address _disputeGameFactoryProxy,\\n GameType _gameType\\n )\\n internal\\n view\\n returns (address)\\n {\\n try IFetcher(_disputeGameFactoryProxy).gameImpls(_gameType) returns (address faultDisputeGame_) {\\n return faultDisputeGame_;\\n } catch {\\n return address(0);\\n }\\n }\\n\\n function _getPermissionedDisputeGame(address _disputeGameFactoryProxy) internal view returns (address) {\\n try IFetcher(_disputeGameFactoryProxy).gameImpls(GameTypes.PERMISSIONED_CANNON) returns (\\n address permissionedDisputeGame_\\n ) {\\n return permissionedDisputeGame_;\\n } catch {\\n return address(0);\\n }\\n }\\n\\n function _getEthLockboxProxy(address _optimismPortalProxy) internal view returns (address) {\\n try IFetcher(_optimismPortalProxy).ethLockbox() returns (address ethLockbox_) {\\n return ethLockbox_;\\n } catch {\\n return address(0);\\n }\\n }\\n\\n function _getDelayedWETHProxy(address _disputeGame) internal view returns (address) {\\n (bool ok, bytes memory data) = address(_disputeGame).staticcall(abi.encodeCall(IFetcher.weth, ()));\\n if (ok && data.length == 32) return abi.decode(data, (address));\\n else return address(0);\\n }\\n\\n function _getBatchSubmitter(address _systemConfigProxy) internal view returns (address) {\\n bytes32 batcherHash = IFetcher(_systemConfigProxy).batcherHash();\\n return address(uint160(uint256(batcherHash)));\\n }\\n\\n function _getProxyAdmin(address _systemConfigProxy) internal returns (address) {\\n vm.prank(address(0));\\n return IFetcher(_systemConfigProxy).admin();\\n }\\n}\\n\",\"keccak256\":\"0xb90e4f9a834c4dc584b4ad8c0503e35fdd8338533e0e75a7ca497f655ae12821\",\"license\":\"MIT\"},\"src/dispute/lib/LibPosition.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.15;\\n\\nusing LibPosition for Position global;\\n\\n/// @notice A `Position` represents a position of a claim within the game tree.\\n/// @dev This is represented as a \\\"generalized index\\\" where the high-order bit\\n/// is the level in the tree and the remaining bits is a unique bit pattern, allowing\\n/// a unique identifier for each node in the tree. Mathematically, it is calculated\\n/// as 2^{depth} + indexAtDepth.\\ntype Position is uint128;\\n\\n/// @title LibPosition\\n/// @notice This library contains helper functions for working with the `Position` type.\\nlibrary LibPosition {\\n /// @notice the `MAX_POSITION_BITLEN` is the number of bits that the `Position` type, and the implementation of\\n /// its behavior within this library, can safely support.\\n uint8 internal constant MAX_POSITION_BITLEN = 126;\\n\\n /// @notice Computes a generalized index (2^{depth} + indexAtDepth).\\n /// @param _depth The depth of the position.\\n /// @param _indexAtDepth The index at the depth of the position.\\n /// @return position_ The computed generalized index.\\n function wrap(uint8 _depth, uint128 _indexAtDepth) internal pure returns (Position position_) {\\n assembly {\\n // gindex = 2^{_depth} + _indexAtDepth\\n position_ := add(shl(_depth, 1), _indexAtDepth)\\n }\\n }\\n\\n /// @notice Pulls the `depth` out of a `Position` type.\\n /// @param _position The generalized index to get the `depth` of.\\n /// @return depth_ The `depth` of the `position` gindex.\\n /// @custom:attribution Solady \\n function depth(Position _position) internal pure returns (uint8 depth_) {\\n // Return the most significant bit offset, which signifies the depth of the gindex.\\n assembly {\\n depth_ := or(depth_, shl(6, lt(0xffffffffffffffff, shr(depth_, _position))))\\n depth_ := or(depth_, shl(5, lt(0xffffffff, shr(depth_, _position))))\\n\\n // For the remaining 32 bits, use a De Bruijn lookup.\\n _position := shr(depth_, _position)\\n _position := or(_position, shr(1, _position))\\n _position := or(_position, shr(2, _position))\\n _position := or(_position, shr(4, _position))\\n _position := or(_position, shr(8, _position))\\n _position := or(_position, shr(16, _position))\\n\\n depth_ :=\\n or(\\n depth_,\\n byte(\\n shr(251, mul(_position, shl(224, 0x07c4acdd))),\\n 0x0009010a0d15021d0b0e10121619031e080c141c0f111807131b17061a05041f\\n )\\n )\\n }\\n }\\n\\n /// @notice Pulls the `indexAtDepth` out of a `Position` type.\\n /// The `indexAtDepth` is the left/right index of a position at a specific depth within\\n /// the binary tree, starting from index 0. For example, at gindex 2, the `depth` = 1\\n /// and the `indexAtDepth` = 0.\\n /// @param _position The generalized index to get the `indexAtDepth` of.\\n /// @return indexAtDepth_ The `indexAtDepth` of the `position` gindex.\\n function indexAtDepth(Position _position) internal pure returns (uint128 indexAtDepth_) {\\n // Return bits p_{msb-1}...p_{0}. This effectively pulls the 2^{depth} out of the gindex,\\n // leaving only the `indexAtDepth`.\\n uint256 msb = depth(_position);\\n assembly {\\n indexAtDepth_ := sub(_position, shl(msb, 1))\\n }\\n }\\n\\n /// @notice Get the left child of `_position`.\\n /// @param _position The position to get the left position of.\\n /// @return left_ The position to the left of `position`.\\n function left(Position _position) internal pure returns (Position left_) {\\n assembly {\\n left_ := shl(1, _position)\\n }\\n }\\n\\n /// @notice Get the right child of `_position`\\n /// @param _position The position to get the right position of.\\n /// @return right_ The position to the right of `position`.\\n function right(Position _position) internal pure returns (Position right_) {\\n assembly {\\n right_ := or(1, shl(1, _position))\\n }\\n }\\n\\n /// @notice Get the parent position of `_position`.\\n /// @param _position The position to get the parent position of.\\n /// @return parent_ The parent position of `position`.\\n function parent(Position _position) internal pure returns (Position parent_) {\\n assembly {\\n parent_ := shr(1, _position)\\n }\\n }\\n\\n /// @notice Get the deepest, right most gindex relative to the `position`. This is equivalent to\\n /// calling `right` on a position until the maximum depth is reached.\\n /// @param _position The position to get the relative deepest, right most gindex of.\\n /// @param _maxDepth The maximum depth of the game.\\n /// @return rightIndex_ The deepest, right most gindex relative to the `position`.\\n function rightIndex(Position _position, uint256 _maxDepth) internal pure returns (Position rightIndex_) {\\n uint256 msb = depth(_position);\\n assembly {\\n let remaining := sub(_maxDepth, msb)\\n rightIndex_ := or(shl(remaining, _position), sub(shl(remaining, 1), 1))\\n }\\n }\\n\\n /// @notice Get the deepest, right most trace index relative to the `position`. This is\\n /// equivalent to calling `right` on a position until the maximum depth is reached and\\n /// then finding its index at depth.\\n /// @param _position The position to get the relative trace index of.\\n /// @param _maxDepth The maximum depth of the game.\\n /// @return traceIndex_ The trace index relative to the `position`.\\n function traceIndex(Position _position, uint256 _maxDepth) internal pure returns (uint256 traceIndex_) {\\n uint256 msb = depth(_position);\\n assembly {\\n let remaining := sub(_maxDepth, msb)\\n traceIndex_ := sub(or(shl(remaining, _position), sub(shl(remaining, 1), 1)), shl(_maxDepth, 1))\\n }\\n }\\n\\n /// @notice Gets the position of the highest ancestor of `_position` that commits to the same\\n /// trace index.\\n /// @param _position The position to get the highest ancestor of.\\n /// @return ancestor_ The highest ancestor of `position` that commits to the same trace index.\\n function traceAncestor(Position _position) internal pure returns (Position ancestor_) {\\n // Create a field with only the lowest unset bit of `_position` set.\\n Position lsb;\\n assembly {\\n lsb := and(not(_position), add(_position, 1))\\n }\\n // Find the index of the lowest unset bit within the field.\\n uint256 msb = depth(lsb);\\n // The highest ancestor that commits to the same trace index is the original position\\n // shifted right by the index of the lowest unset bit.\\n assembly {\\n let a := shr(msb, _position)\\n // Bound the ancestor to the minimum gindex, 1.\\n ancestor_ := or(a, iszero(a))\\n }\\n }\\n\\n /// @notice Gets the position of the highest ancestor of `_position` that commits to the same\\n /// trace index, while still being below `_upperBoundExclusive`.\\n /// @param _position The position to get the highest ancestor of.\\n /// @param _upperBoundExclusive The exclusive upper depth bound, used to inform where to stop in order\\n /// to not escape a sub-tree.\\n /// @return ancestor_ The highest ancestor of `position` that commits to the same trace index.\\n function traceAncestorBounded(\\n Position _position,\\n uint256 _upperBoundExclusive\\n )\\n internal\\n pure\\n returns (Position ancestor_)\\n {\\n // This function only works for positions that are below the upper bound.\\n if (_position.depth() <= _upperBoundExclusive) {\\n assembly {\\n // Revert with `ClaimAboveSplit()`\\n mstore(0x00, 0xb34b5c22)\\n revert(0x1C, 0x04)\\n }\\n }\\n\\n // Grab the global trace ancestor.\\n ancestor_ = traceAncestor(_position);\\n\\n // If the ancestor is above or at the upper bound, shift it to be below the upper bound.\\n // This should be a special case that only covers positions that commit to the final leaf\\n // in a sub-tree.\\n if (ancestor_.depth() <= _upperBoundExclusive) {\\n ancestor_ = ancestor_.rightIndex(_upperBoundExclusive + 1);\\n }\\n }\\n\\n /// @notice Get the move position of `_position`, which is the left child of:\\n /// 1. `_position` if `_isAttack` is true.\\n /// 2. `_position | 1` if `_isAttack` is false.\\n /// @param _position The position to get the relative attack/defense position of.\\n /// @param _isAttack Whether or not the move is an attack move.\\n /// @return move_ The move position relative to `position`.\\n function move(Position _position, bool _isAttack) internal pure returns (Position move_) {\\n assembly {\\n move_ := shl(1, or(iszero(_isAttack), _position))\\n }\\n }\\n\\n /// @notice Get the value of a `Position` type in the form of the underlying uint128.\\n /// @param _position The position to get the value of.\\n /// @return raw_ The value of the `position` as a uint128 type.\\n function raw(Position _position) internal pure returns (uint128 raw_) {\\n assembly {\\n raw_ := _position\\n }\\n }\\n}\\n\",\"keccak256\":\"0x7c5f19f8f54f06de2ce1c6cdcc5c7af65ac405130a4066cdaf146ca315818241\",\"license\":\"MIT\"},\"src/dispute/lib/LibUDT.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.15;\\n\\n// Libraries\\nimport { Position } from \\\"src/dispute/lib/LibPosition.sol\\\";\\n\\nusing LibClaim for Claim global;\\nusing LibHash for Hash global;\\nusing LibDuration for Duration global;\\nusing LibClock for Clock global;\\nusing LibGameId for GameId global;\\nusing LibTimestamp for Timestamp global;\\nusing LibVMStatus for VMStatus global;\\nusing LibGameType for GameType global;\\n\\n/// @notice A `Clock` represents a packed `Duration` and `Timestamp`\\n/// @dev The packed layout of this type is as follows:\\n/// \\u250c\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u252c\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2510\\n/// \\u2502 Bits \\u2502 Value \\u2502\\n/// \\u251c\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u253c\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2524\\n/// \\u2502 [0, 64) \\u2502 Duration \\u2502\\n/// \\u2502 [64, 128) \\u2502 Timestamp \\u2502\\n/// \\u2514\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2534\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2518\\ntype Clock is uint128;\\n\\n/// @title LibClock\\n/// @notice This library contains helper functions for working with the `Clock` type.\\nlibrary LibClock {\\n /// @notice Packs a `Duration` and `Timestamp` into a `Clock` type.\\n /// @param _duration The `Duration` to pack into the `Clock` type.\\n /// @param _timestamp The `Timestamp` to pack into the `Clock` type.\\n /// @return clock_ The `Clock` containing the `_duration` and `_timestamp`.\\n function wrap(Duration _duration, Timestamp _timestamp) internal pure returns (Clock clock_) {\\n assembly {\\n clock_ := or(shl(0x40, _duration), _timestamp)\\n }\\n }\\n\\n /// @notice Pull the `Duration` out of a `Clock` type.\\n /// @param _clock The `Clock` type to pull the `Duration` out of.\\n /// @return duration_ The `Duration` pulled out of `_clock`.\\n function duration(Clock _clock) internal pure returns (Duration duration_) {\\n // Shift the high-order 64 bits into the low-order 64 bits, leaving only the `duration`.\\n assembly {\\n duration_ := shr(0x40, _clock)\\n }\\n }\\n\\n /// @notice Pull the `Timestamp` out of a `Clock` type.\\n /// @param _clock The `Clock` type to pull the `Timestamp` out of.\\n /// @return timestamp_ The `Timestamp` pulled out of `_clock`.\\n function timestamp(Clock _clock) internal pure returns (Timestamp timestamp_) {\\n // Clean the high-order 192 bits by shifting the clock left and then right again, leaving\\n // only the `timestamp`.\\n assembly {\\n timestamp_ := shr(0xC0, shl(0xC0, _clock))\\n }\\n }\\n\\n /// @notice Get the value of a `Clock` type in the form of the underlying uint128.\\n /// @param _clock The `Clock` type to get the value of.\\n /// @return clock_ The value of the `Clock` type as a uint128 type.\\n function raw(Clock _clock) internal pure returns (uint128 clock_) {\\n assembly {\\n clock_ := _clock\\n }\\n }\\n}\\n\\n/// @notice A `GameId` represents a packed 4 byte game ID, a 8 byte timestamp, and a 20 byte address.\\n/// @dev The packed layout of this type is as follows:\\n/// \\u250c\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u252c\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2510\\n/// \\u2502 Bits \\u2502 Value \\u2502\\n/// \\u251c\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u253c\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2524\\n/// \\u2502 [0, 32) \\u2502 Game Type \\u2502\\n/// \\u2502 [32, 96) \\u2502 Timestamp \\u2502\\n/// \\u2502 [96, 256) \\u2502 Address \\u2502\\n/// \\u2514\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2534\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2518\\ntype GameId is bytes32;\\n\\n/// @title LibGameId\\n/// @notice Utility functions for packing and unpacking GameIds.\\nlibrary LibGameId {\\n /// @notice Packs values into a 32 byte GameId type.\\n /// @param _gameType The game type.\\n /// @param _timestamp The timestamp of the game's creation.\\n /// @param _gameProxy The game proxy address.\\n /// @return gameId_ The packed GameId.\\n function pack(\\n GameType _gameType,\\n Timestamp _timestamp,\\n address _gameProxy\\n )\\n internal\\n pure\\n returns (GameId gameId_)\\n {\\n assembly {\\n gameId_ := or(or(shl(224, _gameType), shl(160, _timestamp)), _gameProxy)\\n }\\n }\\n\\n /// @notice Unpacks values from a 32 byte GameId type.\\n /// @param _gameId The packed GameId.\\n /// @return gameType_ The game type.\\n /// @return timestamp_ The timestamp of the game's creation.\\n /// @return gameProxy_ The game proxy address.\\n function unpack(GameId _gameId)\\n internal\\n pure\\n returns (GameType gameType_, Timestamp timestamp_, address gameProxy_)\\n {\\n assembly {\\n gameType_ := shr(224, _gameId)\\n timestamp_ := and(shr(160, _gameId), 0xFFFFFFFFFFFFFFFF)\\n gameProxy_ := and(_gameId, 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF)\\n }\\n }\\n}\\n\\n/// @notice A claim represents an MPT root representing the state of the fault proof program.\\ntype Claim is bytes32;\\n\\n/// @title LibClaim\\n/// @notice This library contains helper functions for working with the `Claim` type.\\nlibrary LibClaim {\\n /// @notice Get the value of a `Claim` type in the form of the underlying bytes32.\\n /// @param _claim The `Claim` type to get the value of.\\n /// @return claim_ The value of the `Claim` type as a bytes32 type.\\n function raw(Claim _claim) internal pure returns (bytes32 claim_) {\\n assembly {\\n claim_ := _claim\\n }\\n }\\n\\n /// @notice Hashes a claim and a position together.\\n /// @param _claim A Claim type.\\n /// @param _position The position of `claim`.\\n /// @param _challengeIndex The index of the claim being moved against.\\n /// @return claimHash_ A hash of abi.encodePacked(claim, position|challengeIndex);\\n function hashClaimPos(\\n Claim _claim,\\n Position _position,\\n uint256 _challengeIndex\\n )\\n internal\\n pure\\n returns (Hash claimHash_)\\n {\\n assembly {\\n mstore(0x00, _claim)\\n mstore(0x20, or(shl(128, _position), and(0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF, _challengeIndex)))\\n claimHash_ := keccak256(0x00, 0x40)\\n }\\n }\\n}\\n\\n/// @notice A dedicated duration type.\\n/// @dev Unit: seconds\\ntype Duration is uint64;\\n\\n/// @title LibDuration\\n/// @notice This library contains helper functions for working with the `Duration` type.\\nlibrary LibDuration {\\n /// @notice Get the value of a `Duration` type in the form of the underlying uint64.\\n /// @param _duration The `Duration` type to get the value of.\\n /// @return duration_ The value of the `Duration` type as a uint64 type.\\n function raw(Duration _duration) internal pure returns (uint64 duration_) {\\n assembly {\\n duration_ := _duration\\n }\\n }\\n}\\n\\n/// @notice A custom type for a generic hash.\\ntype Hash is bytes32;\\n\\n/// @title LibHash\\n/// @notice This library contains helper functions for working with the `Hash` type.\\nlibrary LibHash {\\n /// @notice Get the value of a `Hash` type in the form of the underlying bytes32.\\n /// @param _hash The `Hash` type to get the value of.\\n /// @return hash_ The value of the `Hash` type as a bytes32 type.\\n function raw(Hash _hash) internal pure returns (bytes32 hash_) {\\n assembly {\\n hash_ := _hash\\n }\\n }\\n}\\n\\n/// @notice A dedicated timestamp type.\\ntype Timestamp is uint64;\\n\\n/// @title LibTimestamp\\n/// @notice This library contains helper functions for working with the `Timestamp` type.\\nlibrary LibTimestamp {\\n /// @notice Get the value of a `Timestamp` type in the form of the underlying uint64.\\n /// @param _timestamp The `Timestamp` type to get the value of.\\n /// @return timestamp_ The value of the `Timestamp` type as a uint64 type.\\n function raw(Timestamp _timestamp) internal pure returns (uint64 timestamp_) {\\n assembly {\\n timestamp_ := _timestamp\\n }\\n }\\n}\\n\\n/// @notice A `VMStatus` represents the status of a VM execution.\\ntype VMStatus is uint8;\\n\\n/// @title LibVMStatus\\n/// @notice This library contains helper functions for working with the `VMStatus` type.\\nlibrary LibVMStatus {\\n /// @notice Get the value of a `VMStatus` type in the form of the underlying uint8.\\n /// @param _vmstatus The `VMStatus` type to get the value of.\\n /// @return vmstatus_ The value of the `VMStatus` type as a uint8 type.\\n function raw(VMStatus _vmstatus) internal pure returns (uint8 vmstatus_) {\\n assembly {\\n vmstatus_ := _vmstatus\\n }\\n }\\n}\\n\\n/// @notice A `GameType` represents the type of game being played.\\ntype GameType is uint32;\\n\\n/// @title LibGameType\\n/// @notice This library contains helper functions for working with the `GameType` type.\\nlibrary LibGameType {\\n /// @notice Get the value of a `GameType` type in the form of the underlying uint32.\\n /// @param _gametype The `GameType` type to get the value of.\\n /// @return gametype_ The value of the `GameType` type as a uint32 type.\\n function raw(GameType _gametype) internal pure returns (uint32 gametype_) {\\n assembly {\\n gametype_ := _gametype\\n }\\n }\\n}\\n\",\"keccak256\":\"0x41d55e9c74d979b5b797198e38449e7cef4f925e04d61f7699e9c150c4a659d3\",\"license\":\"MIT\"},\"src/dispute/lib/Types.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.15;\\n\\n// Libraries\\nimport {\\n Position,\\n Hash,\\n GameType,\\n VMStatus,\\n Timestamp,\\n Duration,\\n Clock,\\n GameId,\\n Claim,\\n LibGameId,\\n LibClock\\n} from \\\"src/dispute/lib/LibUDT.sol\\\";\\n\\n/// @notice The current status of the dispute game.\\nenum GameStatus {\\n // The game is currently in progress, and has not been resolved.\\n IN_PROGRESS,\\n // The game has concluded, and the `rootClaim` was challenged successfully.\\n CHALLENGER_WINS,\\n // The game has concluded, and the `rootClaim` could not be contested.\\n DEFENDER_WINS\\n}\\n\\n/// @notice The game's bond distribution type. Games are expected to start in the `UNDECIDED`\\n/// state, and then choose either `NORMAL` or `REFUND`.\\nenum BondDistributionMode {\\n // Bond distribution strategy has not been chosen.\\n UNDECIDED,\\n // Bonds should be distributed as normal.\\n NORMAL,\\n // Bonds should be refunded to claimants.\\n REFUND\\n}\\n\\n/// @notice Represents an L2 root and the L2 sequence number at which it was generated.\\n/// @custom:field root The output root.\\n/// @custom:field l2SequenceNumber The L2 Sequence Number ( e.g. block number / timestamp) at which the root was\\n/// generated.\\nstruct Proposal {\\n Hash root;\\n uint256 l2SequenceNumber;\\n}\\n\\n/// @title GameTypes\\n/// @notice A library that defines the IDs of games that can be played.\\nlibrary GameTypes {\\n /// @dev A dispute game type the uses the cannon vm.\\n GameType internal constant CANNON = GameType.wrap(0);\\n\\n /// @dev A permissioned dispute game type that uses the cannon vm.\\n GameType internal constant PERMISSIONED_CANNON = GameType.wrap(1);\\n\\n /// @notice A dispute game type that uses the asterisc vm.\\n GameType internal constant ASTERISC = GameType.wrap(2);\\n\\n /// @notice A dispute game type that uses the asterisc vm with Kona.\\n GameType internal constant ASTERISC_KONA = GameType.wrap(3);\\n\\n /// @notice A dispute game type that uses the cannon vm (Super Roots).\\n GameType internal constant SUPER_CANNON = GameType.wrap(4);\\n\\n /// @notice A dispute game type that uses the permissioned cannon vm (Super Roots).\\n GameType internal constant SUPER_PERMISSIONED_CANNON = GameType.wrap(5);\\n\\n /// @notice A dispute game type that uses OP Succinct\\n GameType internal constant OP_SUCCINCT = GameType.wrap(6);\\n\\n /// @notice A dispute game type that uses the asterisc vm with Kona (Super Roots).\\n GameType internal constant SUPER_ASTERISC_KONA = GameType.wrap(7);\\n\\n /// @notice A dispute game type that uses the cannon vm with Kona.\\n GameType internal constant CANNON_KONA = GameType.wrap(8);\\n\\n /// @notice A dispute game type that uses the cannon vm with Kona (Super Roots).\\n GameType internal constant SUPER_CANNON_KONA = GameType.wrap(9);\\n\\n /// @notice A dispute game type with short game duration for testing withdrawals.\\n /// Not intended for production use.\\n GameType internal constant FAST = GameType.wrap(254);\\n\\n /// @notice A dispute game type that uses an alphabet vm.\\n /// Not intended for production use.\\n GameType internal constant ALPHABET = GameType.wrap(255);\\n\\n /// @notice A dispute game type that uses RISC Zero's Kailua\\n GameType internal constant KAILUA = GameType.wrap(1337);\\n}\\n\\n/// @title VMStatuses\\n/// @notice Named type aliases for the various valid VM status bytes.\\nlibrary VMStatuses {\\n /// @notice The VM has executed successfully and the outcome is valid.\\n VMStatus internal constant VALID = VMStatus.wrap(0);\\n\\n /// @notice The VM has executed successfully and the outcome is invalid.\\n VMStatus internal constant INVALID = VMStatus.wrap(1);\\n\\n /// @notice The VM has paniced.\\n VMStatus internal constant PANIC = VMStatus.wrap(2);\\n\\n /// @notice The VM execution is still in progress.\\n VMStatus internal constant UNFINISHED = VMStatus.wrap(3);\\n}\\n\\n/// @title LocalPreimageKey\\n/// @notice Named type aliases for local `PreimageOracle` key identifiers.\\nlibrary LocalPreimageKey {\\n /// @notice The identifier for the L1 head hash.\\n uint256 internal constant L1_HEAD_HASH = 0x01;\\n\\n /// @notice The identifier for the starting output root.\\n uint256 internal constant STARTING_OUTPUT_ROOT = 0x02;\\n\\n /// @notice The identifier for the disputed output root.\\n uint256 internal constant DISPUTED_OUTPUT_ROOT = 0x03;\\n\\n /// @notice The identifier for the disputed L2 block number.\\n uint256 internal constant DISPUTED_L2_BLOCK_NUMBER = 0x04;\\n\\n /// @notice The identifier for the chain ID.\\n uint256 internal constant CHAIN_ID = 0x05;\\n}\\n\",\"keccak256\":\"0x468fccc8d6ce3ac5b87bdd5002f84b315ac861be7655ceef87a018f596c410a1\",\"license\":\"MIT\"}},\"version\":1}","metadata":{"compiler":{"version":"0.8.27+commit.40a35a09"},"language":"Solidity","output":{"abi":[{"inputs":[],"stateMutability":"view","type":"function","name":"addressManagerImpl","outputs":[{"internalType":"address","name":"","type":"address"}]},{"inputs":[],"stateMutability":"view","type":"function","name":"anchorStateRegistryProxy","outputs":[{"internalType":"address","name":"","type":"address"}]},{"inputs":[],"stateMutability":"view","type":"function","name":"batchSubmitter","outputs":[{"internalType":"address","name":"","type":"address"}]},{"inputs":[],"stateMutability":"view","type":"function","name":"challenger","outputs":[{"internalType":"address","name":"","type":"address"}]},{"inputs":[],"stateMutability":"view","type":"function","name":"delayedWethPermissionedGameProxy","outputs":[{"internalType":"address","name":"","type":"address"}]},{"inputs":[],"stateMutability":"view","type":"function","name":"delayedWethPermissionlessGameProxy","outputs":[{"internalType":"address","name":"","type":"address"}]},{"inputs":[],"stateMutability":"view","type":"function","name":"disputeGameFactoryProxy","outputs":[{"internalType":"address","name":"","type":"address"}]},{"inputs":[],"stateMutability":"view","type":"function","name":"ethLockboxProxy","outputs":[{"internalType":"address","name":"","type":"address"}]},{"inputs":[],"stateMutability":"view","type":"function","name":"faultDisputeGameCannonKonaImpl","outputs":[{"internalType":"address","name":"","type":"address"}]},{"inputs":[],"stateMutability":"view","type":"function","name":"faultDisputeGameImpl","outputs":[{"internalType":"address","name":"","type":"address"}]},{"inputs":[],"stateMutability":"view","type":"function","name":"l1CrossDomainMessengerProxy","outputs":[{"internalType":"address","name":"","type":"address"}]},{"inputs":[],"stateMutability":"view","type":"function","name":"l1Erc721BridgeProxy","outputs":[{"internalType":"address","name":"","type":"address"}]},{"inputs":[],"stateMutability":"view","type":"function","name":"l1StandardBridgeProxy","outputs":[{"internalType":"address","name":"","type":"address"}]},{"inputs":[],"stateMutability":"view","type":"function","name":"l2OutputOracleProxy","outputs":[{"internalType":"address","name":"","type":"address"}]},{"inputs":[],"stateMutability":"view","type":"function","name":"mipsImpl","outputs":[{"internalType":"address","name":"","type":"address"}]},{"inputs":[],"stateMutability":"view","type":"function","name":"opChainGuardian","outputs":[{"internalType":"address","name":"","type":"address"}]},{"inputs":[],"stateMutability":"view","type":"function","name":"opChainProxyAdminImpl","outputs":[{"internalType":"address","name":"","type":"address"}]},{"inputs":[],"stateMutability":"view","type":"function","name":"opChainProxyAdminOwner","outputs":[{"internalType":"address","name":"","type":"address"}]},{"inputs":[],"stateMutability":"view","type":"function","name":"optimismMintableErc20FactoryProxy","outputs":[{"internalType":"address","name":"","type":"address"}]},{"inputs":[],"stateMutability":"view","type":"function","name":"optimismPortalProxy","outputs":[{"internalType":"address","name":"","type":"address"}]},{"inputs":[],"stateMutability":"view","type":"function","name":"permissioned","outputs":[{"internalType":"bool","name":"","type":"bool"}]},{"inputs":[],"stateMutability":"view","type":"function","name":"permissionedDisputeGameImpl","outputs":[{"internalType":"address","name":"","type":"address"}]},{"inputs":[],"stateMutability":"view","type":"function","name":"permissionless","outputs":[{"internalType":"bool","name":"","type":"bool"}]},{"inputs":[],"stateMutability":"view","type":"function","name":"preimageOracleImpl","outputs":[{"internalType":"address","name":"","type":"address"}]},{"inputs":[],"stateMutability":"view","type":"function","name":"proposer","outputs":[{"internalType":"address","name":"","type":"address"}]},{"inputs":[],"stateMutability":"view","type":"function","name":"respectedGameType","outputs":[{"internalType":"GameType","name":"","type":"uint32"}]},{"inputs":[{"internalType":"bytes4","name":"_sel","type":"bytes4"},{"internalType":"bool","name":"_bool","type":"bool"}],"stateMutability":"nonpayable","type":"function","name":"set"},{"inputs":[{"internalType":"bytes4","name":"_sel","type":"bytes4"},{"internalType":"address","name":"_addr","type":"address"}],"stateMutability":"nonpayable","type":"function","name":"set"},{"inputs":[{"internalType":"bytes4","name":"_sel","type":"bytes4"},{"internalType":"GameType","name":"_gameType","type":"uint32"}],"stateMutability":"nonpayable","type":"function","name":"set"},{"inputs":[],"stateMutability":"view","type":"function","name":"superchainConfigProxy","outputs":[{"internalType":"address","name":"","type":"address"}]},{"inputs":[],"stateMutability":"view","type":"function","name":"systemConfigOwner","outputs":[{"internalType":"address","name":"","type":"address"}]},{"inputs":[],"stateMutability":"view","type":"function","name":"systemConfigProxy","outputs":[{"internalType":"address","name":"","type":"address"}]},{"inputs":[],"stateMutability":"view","type":"function","name":"unsafeBlockSigner","outputs":[{"internalType":"address","name":"","type":"address"}]}],"devdoc":{"kind":"dev","methods":{},"version":1},"userdoc":{"kind":"user","methods":{},"version":1}},"settings":{"remappings":["@lib-keccak/=lib/lib-keccak/contracts/lib/","@openzeppelin/contracts-upgradeable/=lib/openzeppelin-contracts-upgradeable/contracts/","@openzeppelin/contracts-v5/=lib/openzeppelin-contracts-v5/contracts/","@openzeppelin/contracts/=lib/openzeppelin-contracts/contracts/","@rari-capital/solmate/=lib/solmate/","@solady-test/=lib/lib-keccak/lib/solady/test/","@solady-v0.0.245/=lib/solady-v0.0.245/src/","@solady/=lib/solady/src/","ds-test/=lib/forge-std/lib/ds-test/src/","erc4626-tests/=lib/openzeppelin-contracts-v5/lib/erc4626-tests/","forge-std/=lib/forge-std/src/","interfaces/=interfaces/","kontrol-cheatcodes/=lib/kontrol-cheatcodes/src/","lib-keccak/=lib/lib-keccak/contracts/","openzeppelin-contracts-upgradeable/=lib/openzeppelin-contracts-upgradeable/","openzeppelin-contracts-v5/=lib/openzeppelin-contracts-v5/","openzeppelin-contracts/=lib/openzeppelin-contracts/","safe-contracts/=lib/safe-contracts/contracts/","solady-v0.0.245/=lib/solady-v0.0.245/src/","solady/=lib/solady/","solmate/=lib/solmate/src/"],"optimizer":{"enabled":false,"runs":0},"metadata":{"useLiteralContent":true,"bytecodeHash":"none"},"compilationTarget":{"scripts/FetchChainInfo.s.sol":"FetchChainInfoOutput"},"evmVersion":"cancun","libraries":{}},"sources":{"lib/forge-std/src/Base.sol":{"keccak256":"0xa3735a6618a3014e42bb4329ad143e3b2c59cd95094350202e4c4a06c9d585dd","urls":[],"content":"// SPDX-License-Identifier: MIT\npragma solidity >=0.6.2 <0.9.0;\n\nimport {StdStorage} from \"./StdStorage.sol\";\nimport {Vm, VmSafe} from \"./Vm.sol\";\n\nabstract contract CommonBase {\n /// @dev Cheat code address.\n /// Calculated as `address(uint160(uint256(keccak256(\"hevm cheat code\"))))`.\n address internal constant VM_ADDRESS = 0x7109709ECfa91a80626fF3989D68f67F5b1DD12D;\n /// @dev console.sol and console2.sol work by executing a staticcall to this address.\n /// Calculated as `address(uint160(uint88(bytes11(\"console.log\"))))`.\n address internal constant CONSOLE = 0x000000000000000000636F6e736F6c652e6c6f67;\n /// @dev Used when deploying with create2.\n /// Taken from https://github.com/Arachnid/deterministic-deployment-proxy.\n address internal constant CREATE2_FACTORY = 0x4e59b44847b379578588920cA78FbF26c0B4956C;\n /// @dev The default address for tx.origin and msg.sender.\n /// Calculated as `address(uint160(uint256(keccak256(\"foundry default caller\"))))`.\n address internal constant DEFAULT_SENDER = 0x1804c8AB1F12E6bbf3894d4083f33e07309d1f38;\n /// @dev The address of the first contract `CREATE`d by a running test contract.\n /// When running tests, each test contract is `CREATE`d by `DEFAULT_SENDER` with nonce 1.\n /// Calculated as `VM.computeCreateAddress(VM.computeCreateAddress(DEFAULT_SENDER, 1), 1)`.\n address internal constant DEFAULT_TEST_CONTRACT = 0x5615dEB798BB3E4dFa0139dFa1b3D433Cc23b72f;\n /// @dev Deterministic deployment address of the Multicall3 contract.\n /// Taken from https://www.multicall3.com.\n address internal constant MULTICALL3_ADDRESS = 0xcA11bde05977b3631167028862bE2a173976CA11;\n /// @dev The order of the secp256k1 curve.\n uint256 internal constant SECP256K1_ORDER =\n 115792089237316195423570985008687907852837564279074904382605163141518161494337;\n\n uint256 internal constant UINT256_MAX =\n 115792089237316195423570985008687907853269984665640564039457584007913129639935;\n\n Vm internal constant vm = Vm(VM_ADDRESS);\n StdStorage internal stdstore;\n}\n\nabstract contract TestBase is CommonBase {}\n\nabstract contract ScriptBase is CommonBase {\n VmSafe internal constant vmSafe = VmSafe(VM_ADDRESS);\n}\n","license":"MIT"},"lib/forge-std/src/Script.sol":{"keccak256":"0xc942e27c7baae499beb01afbbae99f24d42af9a6e4aae675bc6901b704aa8e9b","urls":[],"content":"// SPDX-License-Identifier: MIT\npragma solidity >=0.6.2 <0.9.0;\n\n// 💬 ABOUT\n// Forge Std's default Script.\n\n// 🧩 MODULES\nimport {console} from \"./console.sol\";\nimport {console2} from \"./console2.sol\";\nimport {safeconsole} from \"./safeconsole.sol\";\nimport {StdChains} from \"./StdChains.sol\";\nimport {StdCheatsSafe} from \"./StdCheats.sol\";\nimport {StdConstants} from \"./StdConstants.sol\";\nimport {stdJson} from \"./StdJson.sol\";\nimport {stdMath} from \"./StdMath.sol\";\nimport {StdStorage, stdStorageSafe} from \"./StdStorage.sol\";\nimport {StdStyle} from \"./StdStyle.sol\";\nimport {StdUtils} from \"./StdUtils.sol\";\nimport {VmSafe} from \"./Vm.sol\";\n\n// 📦 BOILERPLATE\nimport {ScriptBase} from \"./Base.sol\";\n\n// ⭐️ SCRIPT\nabstract contract Script is ScriptBase, StdChains, StdCheatsSafe, StdUtils {\n // Note: IS_SCRIPT() must return true.\n bool public IS_SCRIPT = true;\n}\n","license":"MIT"},"lib/forge-std/src/StdChains.sol":{"keccak256":"0x200b597cd01c229633b4a2317846cac7d36d337e2381b4a2e81faac23c2ad1cf","urls":[],"content":"// SPDX-License-Identifier: MIT\npragma solidity >=0.6.2 <0.9.0;\n\nimport {VmSafe} from \"./Vm.sol\";\n\n/**\n * StdChains provides information about EVM compatible chains that can be used in scripts/tests.\n * For each chain, the chain's name, chain ID, and a default RPC URL are provided. Chains are\n * identified by their alias, which is the same as the alias in the `[rpc_endpoints]` section of\n * the `foundry.toml` file. For best UX, ensure the alias in the `foundry.toml` file match the\n * alias used in this contract, which can be found as the first argument to the\n * `setChainWithDefaultRpcUrl` call in the `initializeStdChains` function.\n *\n * There are two main ways to use this contract:\n * 1. Set a chain with `setChain(string memory chainAlias, ChainData memory chain)` or\n * `setChain(string memory chainAlias, Chain memory chain)`\n * 2. Get a chain with `getChain(string memory chainAlias)` or `getChain(uint256 chainId)`.\n *\n * The first time either of those are used, chains are initialized with the default set of RPC URLs.\n * This is done in `initializeStdChains`, which uses `setChainWithDefaultRpcUrl`. Defaults are recorded in\n * `defaultRpcUrls`.\n *\n * The `setChain` function is straightforward, and it simply saves off the given chain data.\n *\n * The `getChain` methods use `getChainWithUpdatedRpcUrl` to return a chain. For example, let's say\n * we want to retrieve the RPC URL for `mainnet`:\n * - If you have specified data with `setChain`, it will return that.\n * - If you have configured a mainnet RPC URL in `foundry.toml`, it will return the URL, provided it\n * is valid (e.g. a URL is specified, or an environment variable is given and exists).\n * - If neither of the above conditions is met, the default data is returned.\n *\n * Summarizing the above, the prioritization hierarchy is `setChain` -> `foundry.toml` -> environment variable -> defaults.\n */\nabstract contract StdChains {\n VmSafe private constant vm = VmSafe(address(uint160(uint256(keccak256(\"hevm cheat code\")))));\n\n bool private stdChainsInitialized;\n\n struct ChainData {\n string name;\n uint256 chainId;\n string rpcUrl;\n }\n\n struct Chain {\n // The chain name.\n string name;\n // The chain's Chain ID.\n uint256 chainId;\n // The chain's alias. (i.e. what gets specified in `foundry.toml`).\n string chainAlias;\n // A default RPC endpoint for this chain.\n // NOTE: This default RPC URL is included for convenience to facilitate quick tests and\n // experimentation. Do not use this RPC URL for production test suites, CI, or other heavy\n // usage as you will be throttled and this is a disservice to others who need this endpoint.\n string rpcUrl;\n }\n\n // Maps from the chain's alias (matching the alias in the `foundry.toml` file) to chain data.\n mapping(string => Chain) private chains;\n // Maps from the chain's alias to it's default RPC URL.\n mapping(string => string) private defaultRpcUrls;\n // Maps from a chain ID to it's alias.\n mapping(uint256 => string) private idToAlias;\n\n bool private fallbackToDefaultRpcUrls = true;\n\n // The RPC URL will be fetched from config or defaultRpcUrls if possible.\n function getChain(string memory chainAlias) internal virtual returns (Chain memory chain) {\n require(bytes(chainAlias).length != 0, \"StdChains getChain(string): Chain alias cannot be the empty string.\");\n\n initializeStdChains();\n chain = chains[chainAlias];\n require(\n chain.chainId != 0,\n string(abi.encodePacked(\"StdChains getChain(string): Chain with alias \\\"\", chainAlias, \"\\\" not found.\"))\n );\n\n chain = getChainWithUpdatedRpcUrl(chainAlias, chain);\n }\n\n function getChain(uint256 chainId) internal virtual returns (Chain memory chain) {\n require(chainId != 0, \"StdChains getChain(uint256): Chain ID cannot be 0.\");\n initializeStdChains();\n string memory chainAlias = idToAlias[chainId];\n\n chain = chains[chainAlias];\n\n require(\n chain.chainId != 0,\n string(abi.encodePacked(\"StdChains getChain(uint256): Chain with ID \", vm.toString(chainId), \" not found.\"))\n );\n\n chain = getChainWithUpdatedRpcUrl(chainAlias, chain);\n }\n\n // set chain info, with priority to argument's rpcUrl field.\n function setChain(string memory chainAlias, ChainData memory chain) internal virtual {\n require(\n bytes(chainAlias).length != 0,\n \"StdChains setChain(string,ChainData): Chain alias cannot be the empty string.\"\n );\n\n require(chain.chainId != 0, \"StdChains setChain(string,ChainData): Chain ID cannot be 0.\");\n\n initializeStdChains();\n string memory foundAlias = idToAlias[chain.chainId];\n\n require(\n bytes(foundAlias).length == 0 || keccak256(bytes(foundAlias)) == keccak256(bytes(chainAlias)),\n string(\n abi.encodePacked(\n \"StdChains setChain(string,ChainData): Chain ID \",\n vm.toString(chain.chainId),\n \" already used by \\\"\",\n foundAlias,\n \"\\\".\"\n )\n )\n );\n\n uint256 oldChainId = chains[chainAlias].chainId;\n delete idToAlias[oldChainId];\n\n chains[chainAlias] =\n Chain({name: chain.name, chainId: chain.chainId, chainAlias: chainAlias, rpcUrl: chain.rpcUrl});\n idToAlias[chain.chainId] = chainAlias;\n }\n\n // set chain info, with priority to argument's rpcUrl field.\n function setChain(string memory chainAlias, Chain memory chain) internal virtual {\n setChain(chainAlias, ChainData({name: chain.name, chainId: chain.chainId, rpcUrl: chain.rpcUrl}));\n }\n\n function _toUpper(string memory str) private pure returns (string memory) {\n bytes memory strb = bytes(str);\n bytes memory copy = new bytes(strb.length);\n for (uint256 i = 0; i < strb.length; i++) {\n bytes1 b = strb[i];\n if (b >= 0x61 && b <= 0x7A) {\n copy[i] = bytes1(uint8(b) - 32);\n } else {\n copy[i] = b;\n }\n }\n return string(copy);\n }\n\n // lookup rpcUrl, in descending order of priority:\n // current -> config (foundry.toml) -> environment variable -> default\n function getChainWithUpdatedRpcUrl(string memory chainAlias, Chain memory chain)\n private\n view\n returns (Chain memory)\n {\n if (bytes(chain.rpcUrl).length == 0) {\n try vm.rpcUrl(chainAlias) returns (string memory configRpcUrl) {\n chain.rpcUrl = configRpcUrl;\n } catch (bytes memory err) {\n string memory envName = string(abi.encodePacked(_toUpper(chainAlias), \"_RPC_URL\"));\n if (fallbackToDefaultRpcUrls) {\n chain.rpcUrl = vm.envOr(envName, defaultRpcUrls[chainAlias]);\n } else {\n chain.rpcUrl = vm.envString(envName);\n }\n // Distinguish 'not found' from 'cannot read'\n // The upstream error thrown by forge for failing cheats changed so we check both the old and new versions\n bytes memory oldNotFoundError =\n abi.encodeWithSignature(\"CheatCodeError\", string(abi.encodePacked(\"invalid rpc url \", chainAlias)));\n bytes memory newNotFoundError = abi.encodeWithSignature(\n \"CheatcodeError(string)\", string(abi.encodePacked(\"invalid rpc url: \", chainAlias))\n );\n bytes32 errHash = keccak256(err);\n if (\n (errHash != keccak256(oldNotFoundError) && errHash != keccak256(newNotFoundError))\n || bytes(chain.rpcUrl).length == 0\n ) {\n /// @solidity memory-safe-assembly\n assembly {\n revert(add(32, err), mload(err))\n }\n }\n }\n }\n return chain;\n }\n\n function setFallbackToDefaultRpcUrls(bool useDefault) internal {\n fallbackToDefaultRpcUrls = useDefault;\n }\n\n function initializeStdChains() private {\n if (stdChainsInitialized) return;\n\n stdChainsInitialized = true;\n\n // If adding an RPC here, make sure to test the default RPC URL in `test_Rpcs` in `StdChains.t.sol`\n setChainWithDefaultRpcUrl(\"anvil\", ChainData(\"Anvil\", 31337, \"http://127.0.0.1:8545\"));\n setChainWithDefaultRpcUrl(\"mainnet\", ChainData(\"Mainnet\", 1, \"https://eth.llamarpc.com\"));\n setChainWithDefaultRpcUrl(\n \"sepolia\", ChainData(\"Sepolia\", 11155111, \"https://sepolia.infura.io/v3/b9794ad1ddf84dfb8c34d6bb5dca2001\")\n );\n setChainWithDefaultRpcUrl(\"holesky\", ChainData(\"Holesky\", 17000, \"https://rpc.holesky.ethpandaops.io\"));\n setChainWithDefaultRpcUrl(\"optimism\", ChainData(\"Optimism\", 10, \"https://mainnet.optimism.io\"));\n setChainWithDefaultRpcUrl(\n \"optimism_sepolia\", ChainData(\"Optimism Sepolia\", 11155420, \"https://sepolia.optimism.io\")\n );\n setChainWithDefaultRpcUrl(\"arbitrum_one\", ChainData(\"Arbitrum One\", 42161, \"https://arb1.arbitrum.io/rpc\"));\n setChainWithDefaultRpcUrl(\n \"arbitrum_one_sepolia\", ChainData(\"Arbitrum One Sepolia\", 421614, \"https://sepolia-rollup.arbitrum.io/rpc\")\n );\n setChainWithDefaultRpcUrl(\"arbitrum_nova\", ChainData(\"Arbitrum Nova\", 42170, \"https://nova.arbitrum.io/rpc\"));\n setChainWithDefaultRpcUrl(\"polygon\", ChainData(\"Polygon\", 137, \"https://polygon-rpc.com\"));\n setChainWithDefaultRpcUrl(\n \"polygon_amoy\", ChainData(\"Polygon Amoy\", 80002, \"https://rpc-amoy.polygon.technology\")\n );\n setChainWithDefaultRpcUrl(\"avalanche\", ChainData(\"Avalanche\", 43114, \"https://api.avax.network/ext/bc/C/rpc\"));\n setChainWithDefaultRpcUrl(\n \"avalanche_fuji\", ChainData(\"Avalanche Fuji\", 43113, \"https://api.avax-test.network/ext/bc/C/rpc\")\n );\n setChainWithDefaultRpcUrl(\n \"bnb_smart_chain\", ChainData(\"BNB Smart Chain\", 56, \"https://bsc-dataseed1.binance.org\")\n );\n setChainWithDefaultRpcUrl(\n \"bnb_smart_chain_testnet\",\n ChainData(\"BNB Smart Chain Testnet\", 97, \"https://rpc.ankr.com/bsc_testnet_chapel\")\n );\n setChainWithDefaultRpcUrl(\"gnosis_chain\", ChainData(\"Gnosis Chain\", 100, \"https://rpc.gnosischain.com\"));\n setChainWithDefaultRpcUrl(\"moonbeam\", ChainData(\"Moonbeam\", 1284, \"https://rpc.api.moonbeam.network\"));\n setChainWithDefaultRpcUrl(\n \"moonriver\", ChainData(\"Moonriver\", 1285, \"https://rpc.api.moonriver.moonbeam.network\")\n );\n setChainWithDefaultRpcUrl(\"moonbase\", ChainData(\"Moonbase\", 1287, \"https://rpc.testnet.moonbeam.network\"));\n setChainWithDefaultRpcUrl(\"base_sepolia\", ChainData(\"Base Sepolia\", 84532, \"https://sepolia.base.org\"));\n setChainWithDefaultRpcUrl(\"base\", ChainData(\"Base\", 8453, \"https://mainnet.base.org\"));\n setChainWithDefaultRpcUrl(\"blast_sepolia\", ChainData(\"Blast Sepolia\", 168587773, \"https://sepolia.blast.io\"));\n setChainWithDefaultRpcUrl(\"blast\", ChainData(\"Blast\", 81457, \"https://rpc.blast.io\"));\n setChainWithDefaultRpcUrl(\"fantom_opera\", ChainData(\"Fantom Opera\", 250, \"https://rpc.ankr.com/fantom/\"));\n setChainWithDefaultRpcUrl(\n \"fantom_opera_testnet\", ChainData(\"Fantom Opera Testnet\", 4002, \"https://rpc.ankr.com/fantom_testnet/\")\n );\n setChainWithDefaultRpcUrl(\"fraxtal\", ChainData(\"Fraxtal\", 252, \"https://rpc.frax.com\"));\n setChainWithDefaultRpcUrl(\"fraxtal_testnet\", ChainData(\"Fraxtal Testnet\", 2522, \"https://rpc.testnet.frax.com\"));\n setChainWithDefaultRpcUrl(\n \"berachain_bartio_testnet\", ChainData(\"Berachain bArtio Testnet\", 80084, \"https://bartio.rpc.berachain.com\")\n );\n setChainWithDefaultRpcUrl(\"flare\", ChainData(\"Flare\", 14, \"https://flare-api.flare.network/ext/C/rpc\"));\n setChainWithDefaultRpcUrl(\n \"flare_coston2\", ChainData(\"Flare Coston2\", 114, \"https://coston2-api.flare.network/ext/C/rpc\")\n );\n\n setChainWithDefaultRpcUrl(\"mode\", ChainData(\"Mode\", 34443, \"https://mode.drpc.org\"));\n setChainWithDefaultRpcUrl(\"mode_sepolia\", ChainData(\"Mode Sepolia\", 919, \"https://sepolia.mode.network\"));\n\n setChainWithDefaultRpcUrl(\"zora\", ChainData(\"Zora\", 7777777, \"https://zora.drpc.org\"));\n setChainWithDefaultRpcUrl(\n \"zora_sepolia\", ChainData(\"Zora Sepolia\", 999999999, \"https://sepolia.rpc.zora.energy\")\n );\n\n setChainWithDefaultRpcUrl(\"race\", ChainData(\"Race\", 6805, \"https://racemainnet.io\"));\n setChainWithDefaultRpcUrl(\"race_sepolia\", ChainData(\"Race Sepolia\", 6806, \"https://racemainnet.io\"));\n\n setChainWithDefaultRpcUrl(\"metal\", ChainData(\"Metal\", 1750, \"https://metall2.drpc.org\"));\n setChainWithDefaultRpcUrl(\"metal_sepolia\", ChainData(\"Metal Sepolia\", 1740, \"https://testnet.rpc.metall2.com\"));\n\n setChainWithDefaultRpcUrl(\"binary\", ChainData(\"Binary\", 624, \"https://rpc.zero.thebinaryholdings.com\"));\n setChainWithDefaultRpcUrl(\n \"binary_sepolia\", ChainData(\"Binary Sepolia\", 625, \"https://rpc.zero.thebinaryholdings.com\")\n );\n\n setChainWithDefaultRpcUrl(\"orderly\", ChainData(\"Orderly\", 291, \"https://rpc.orderly.network\"));\n setChainWithDefaultRpcUrl(\n \"orderly_sepolia\", ChainData(\"Orderly Sepolia\", 4460, \"https://testnet-rpc.orderly.org\")\n );\n }\n\n // set chain info, with priority to chainAlias' rpc url in foundry.toml\n function setChainWithDefaultRpcUrl(string memory chainAlias, ChainData memory chain) private {\n string memory rpcUrl = chain.rpcUrl;\n defaultRpcUrls[chainAlias] = rpcUrl;\n chain.rpcUrl = \"\";\n setChain(chainAlias, chain);\n chain.rpcUrl = rpcUrl; // restore argument\n }\n}\n","license":"MIT"},"lib/forge-std/src/StdCheats.sol":{"keccak256":"0x0fa6ec03602648b62cce41aab2096e6b7e052f2846075d967b6958dd586db746","urls":[],"content":"// SPDX-License-Identifier: MIT\npragma solidity >=0.6.2 <0.9.0;\n\npragma experimental ABIEncoderV2;\n\nimport {StdStorage, stdStorage} from \"./StdStorage.sol\";\nimport {console2} from \"./console2.sol\";\nimport {Vm} from \"./Vm.sol\";\n\nabstract contract StdCheatsSafe {\n Vm private constant vm = Vm(address(uint160(uint256(keccak256(\"hevm cheat code\")))));\n\n uint256 private constant UINT256_MAX =\n 115792089237316195423570985008687907853269984665640564039457584007913129639935;\n\n bool private gasMeteringOff;\n\n // Data structures to parse Transaction objects from the broadcast artifact\n // that conform to EIP1559. The Raw structs is what is parsed from the JSON\n // and then converted to the one that is used by the user for better UX.\n\n struct RawTx1559 {\n string[] arguments;\n address contractAddress;\n string contractName;\n // json value name = function\n string functionSig;\n bytes32 hash;\n // json value name = tx\n RawTx1559Detail txDetail;\n // json value name = type\n string opcode;\n }\n\n struct RawTx1559Detail {\n AccessList[] accessList;\n bytes data;\n address from;\n bytes gas;\n bytes nonce;\n address to;\n bytes txType;\n bytes value;\n }\n\n struct Tx1559 {\n string[] arguments;\n address contractAddress;\n string contractName;\n string functionSig;\n bytes32 hash;\n Tx1559Detail txDetail;\n string opcode;\n }\n\n struct Tx1559Detail {\n AccessList[] accessList;\n bytes data;\n address from;\n uint256 gas;\n uint256 nonce;\n address to;\n uint256 txType;\n uint256 value;\n }\n\n // Data structures to parse Transaction objects from the broadcast artifact\n // that DO NOT conform to EIP1559. The Raw structs is what is parsed from the JSON\n // and then converted to the one that is used by the user for better UX.\n\n struct TxLegacy {\n string[] arguments;\n address contractAddress;\n string contractName;\n string functionSig;\n string hash;\n string opcode;\n TxDetailLegacy transaction;\n }\n\n struct TxDetailLegacy {\n AccessList[] accessList;\n uint256 chainId;\n bytes data;\n address from;\n uint256 gas;\n uint256 gasPrice;\n bytes32 hash;\n uint256 nonce;\n bytes1 opcode;\n bytes32 r;\n bytes32 s;\n uint256 txType;\n address to;\n uint8 v;\n uint256 value;\n }\n\n struct AccessList {\n address accessAddress;\n bytes32[] storageKeys;\n }\n\n // Data structures to parse Receipt objects from the broadcast artifact.\n // The Raw structs is what is parsed from the JSON\n // and then converted to the one that is used by the user for better UX.\n\n struct RawReceipt {\n bytes32 blockHash;\n bytes blockNumber;\n address contractAddress;\n bytes cumulativeGasUsed;\n bytes effectiveGasPrice;\n address from;\n bytes gasUsed;\n RawReceiptLog[] logs;\n bytes logsBloom;\n bytes status;\n address to;\n bytes32 transactionHash;\n bytes transactionIndex;\n }\n\n struct Receipt {\n bytes32 blockHash;\n uint256 blockNumber;\n address contractAddress;\n uint256 cumulativeGasUsed;\n uint256 effectiveGasPrice;\n address from;\n uint256 gasUsed;\n ReceiptLog[] logs;\n bytes logsBloom;\n uint256 status;\n address to;\n bytes32 transactionHash;\n uint256 transactionIndex;\n }\n\n // Data structures to parse the entire broadcast artifact, assuming the\n // transactions conform to EIP1559.\n\n struct EIP1559ScriptArtifact {\n string[] libraries;\n string path;\n string[] pending;\n Receipt[] receipts;\n uint256 timestamp;\n Tx1559[] transactions;\n TxReturn[] txReturns;\n }\n\n struct RawEIP1559ScriptArtifact {\n string[] libraries;\n string path;\n string[] pending;\n RawReceipt[] receipts;\n TxReturn[] txReturns;\n uint256 timestamp;\n RawTx1559[] transactions;\n }\n\n struct RawReceiptLog {\n // json value = address\n address logAddress;\n bytes32 blockHash;\n bytes blockNumber;\n bytes data;\n bytes logIndex;\n bool removed;\n bytes32[] topics;\n bytes32 transactionHash;\n bytes transactionIndex;\n bytes transactionLogIndex;\n }\n\n struct ReceiptLog {\n // json value = address\n address logAddress;\n bytes32 blockHash;\n uint256 blockNumber;\n bytes data;\n uint256 logIndex;\n bytes32[] topics;\n uint256 transactionIndex;\n uint256 transactionLogIndex;\n bool removed;\n }\n\n struct TxReturn {\n string internalType;\n string value;\n }\n\n struct Account {\n address addr;\n uint256 key;\n }\n\n enum AddressType {\n Payable,\n NonPayable,\n ZeroAddress,\n Precompile,\n ForgeAddress\n }\n\n // Checks that `addr` is not blacklisted by token contracts that have a blacklist.\n function assumeNotBlacklisted(address token, address addr) internal view virtual {\n // Nothing to check if `token` is not a contract.\n uint256 tokenCodeSize;\n assembly {\n tokenCodeSize := extcodesize(token)\n }\n require(tokenCodeSize > 0, \"StdCheats assumeNotBlacklisted(address,address): Token address is not a contract.\");\n\n bool success;\n bytes memory returnData;\n\n // 4-byte selector for `isBlacklisted(address)`, used by USDC.\n (success, returnData) = token.staticcall(abi.encodeWithSelector(0xfe575a87, addr));\n vm.assume(!success || abi.decode(returnData, (bool)) == false);\n\n // 4-byte selector for `isBlackListed(address)`, used by USDT.\n (success, returnData) = token.staticcall(abi.encodeWithSelector(0xe47d6060, addr));\n vm.assume(!success || abi.decode(returnData, (bool)) == false);\n }\n\n // Checks that `addr` is not blacklisted by token contracts that have a blacklist.\n // This is identical to `assumeNotBlacklisted(address,address)` but with a different name, for\n // backwards compatibility, since this name was used in the original PR which already has\n // a release. This function can be removed in a future release once we want a breaking change.\n function assumeNoBlacklisted(address token, address addr) internal view virtual {\n assumeNotBlacklisted(token, addr);\n }\n\n function assumeAddressIsNot(address addr, AddressType addressType) internal virtual {\n if (addressType == AddressType.Payable) {\n assumeNotPayable(addr);\n } else if (addressType == AddressType.NonPayable) {\n assumePayable(addr);\n } else if (addressType == AddressType.ZeroAddress) {\n assumeNotZeroAddress(addr);\n } else if (addressType == AddressType.Precompile) {\n assumeNotPrecompile(addr);\n } else if (addressType == AddressType.ForgeAddress) {\n assumeNotForgeAddress(addr);\n }\n }\n\n function assumeAddressIsNot(address addr, AddressType addressType1, AddressType addressType2) internal virtual {\n assumeAddressIsNot(addr, addressType1);\n assumeAddressIsNot(addr, addressType2);\n }\n\n function assumeAddressIsNot(\n address addr,\n AddressType addressType1,\n AddressType addressType2,\n AddressType addressType3\n ) internal virtual {\n assumeAddressIsNot(addr, addressType1);\n assumeAddressIsNot(addr, addressType2);\n assumeAddressIsNot(addr, addressType3);\n }\n\n function assumeAddressIsNot(\n address addr,\n AddressType addressType1,\n AddressType addressType2,\n AddressType addressType3,\n AddressType addressType4\n ) internal virtual {\n assumeAddressIsNot(addr, addressType1);\n assumeAddressIsNot(addr, addressType2);\n assumeAddressIsNot(addr, addressType3);\n assumeAddressIsNot(addr, addressType4);\n }\n\n // This function checks whether an address, `addr`, is payable. It works by sending 1 wei to\n // `addr` and checking the `success` return value.\n // NOTE: This function may result in state changes depending on the fallback/receive logic\n // implemented by `addr`, which should be taken into account when this function is used.\n function _isPayable(address addr) private returns (bool) {\n require(\n addr.balance < UINT256_MAX,\n \"StdCheats _isPayable(address): Balance equals max uint256, so it cannot receive any more funds\"\n );\n uint256 origBalanceTest = address(this).balance;\n uint256 origBalanceAddr = address(addr).balance;\n\n vm.deal(address(this), 1);\n (bool success,) = payable(addr).call{value: 1}(\"\");\n\n // reset balances\n vm.deal(address(this), origBalanceTest);\n vm.deal(addr, origBalanceAddr);\n\n return success;\n }\n\n // NOTE: This function may result in state changes depending on the fallback/receive logic\n // implemented by `addr`, which should be taken into account when this function is used. See the\n // `_isPayable` method for more information.\n function assumePayable(address addr) internal virtual {\n vm.assume(_isPayable(addr));\n }\n\n function assumeNotPayable(address addr) internal virtual {\n vm.assume(!_isPayable(addr));\n }\n\n function assumeNotZeroAddress(address addr) internal pure virtual {\n vm.assume(addr != address(0));\n }\n\n function assumeNotPrecompile(address addr) internal pure virtual {\n assumeNotPrecompile(addr, _pureChainId());\n }\n\n function assumeNotPrecompile(address addr, uint256 chainId) internal pure virtual {\n // Note: For some chains like Optimism these are technically predeploys (i.e. bytecode placed at a specific\n // address), but the same rationale for excluding them applies so we include those too.\n\n // These are reserved by Ethereum and may be on all EVM-compatible chains.\n vm.assume(addr < address(0x1) || addr > address(0xff));\n\n // forgefmt: disable-start\n if (chainId == 10 || chainId == 420) {\n // https://github.com/ethereum-optimism/optimism/blob/eaa371a0184b56b7ca6d9eb9cb0a2b78b2ccd864/op-bindings/predeploys/addresses.go#L6-L21\n vm.assume(addr < address(0x4200000000000000000000000000000000000000) || addr > address(0x4200000000000000000000000000000000000800));\n } else if (chainId == 42161 || chainId == 421613) {\n // https://developer.arbitrum.io/useful-addresses#arbitrum-precompiles-l2-same-on-all-arb-chains\n vm.assume(addr < address(0x0000000000000000000000000000000000000064) || addr > address(0x0000000000000000000000000000000000000068));\n } else if (chainId == 43114 || chainId == 43113) {\n // https://github.com/ava-labs/subnet-evm/blob/47c03fd007ecaa6de2c52ea081596e0a88401f58/precompile/params.go#L18-L59\n vm.assume(addr < address(0x0100000000000000000000000000000000000000) || addr > address(0x01000000000000000000000000000000000000ff));\n vm.assume(addr < address(0x0200000000000000000000000000000000000000) || addr > address(0x02000000000000000000000000000000000000FF));\n vm.assume(addr < address(0x0300000000000000000000000000000000000000) || addr > address(0x03000000000000000000000000000000000000Ff));\n }\n // forgefmt: disable-end\n }\n\n function assumeNotForgeAddress(address addr) internal pure virtual {\n // vm, console, and Create2Deployer addresses\n vm.assume(\n addr != address(vm) && addr != 0x000000000000000000636F6e736F6c652e6c6f67\n && addr != 0x4e59b44847b379578588920cA78FbF26c0B4956C\n );\n }\n\n function assumeUnusedAddress(address addr) internal view virtual {\n uint256 size;\n assembly {\n size := extcodesize(addr)\n }\n vm.assume(size == 0);\n\n assumeNotPrecompile(addr);\n assumeNotZeroAddress(addr);\n assumeNotForgeAddress(addr);\n }\n\n function readEIP1559ScriptArtifact(string memory path)\n internal\n view\n virtual\n returns (EIP1559ScriptArtifact memory)\n {\n string memory data = vm.readFile(path);\n bytes memory parsedData = vm.parseJson(data);\n RawEIP1559ScriptArtifact memory rawArtifact = abi.decode(parsedData, (RawEIP1559ScriptArtifact));\n EIP1559ScriptArtifact memory artifact;\n artifact.libraries = rawArtifact.libraries;\n artifact.path = rawArtifact.path;\n artifact.timestamp = rawArtifact.timestamp;\n artifact.pending = rawArtifact.pending;\n artifact.txReturns = rawArtifact.txReturns;\n artifact.receipts = rawToConvertedReceipts(rawArtifact.receipts);\n artifact.transactions = rawToConvertedEIPTx1559s(rawArtifact.transactions);\n return artifact;\n }\n\n function rawToConvertedEIPTx1559s(RawTx1559[] memory rawTxs) internal pure virtual returns (Tx1559[] memory) {\n Tx1559[] memory txs = new Tx1559[](rawTxs.length);\n for (uint256 i; i < rawTxs.length; i++) {\n txs[i] = rawToConvertedEIPTx1559(rawTxs[i]);\n }\n return txs;\n }\n\n function rawToConvertedEIPTx1559(RawTx1559 memory rawTx) internal pure virtual returns (Tx1559 memory) {\n Tx1559 memory transaction;\n transaction.arguments = rawTx.arguments;\n transaction.contractName = rawTx.contractName;\n transaction.functionSig = rawTx.functionSig;\n transaction.hash = rawTx.hash;\n transaction.txDetail = rawToConvertedEIP1559Detail(rawTx.txDetail);\n transaction.opcode = rawTx.opcode;\n return transaction;\n }\n\n function rawToConvertedEIP1559Detail(RawTx1559Detail memory rawDetail)\n internal\n pure\n virtual\n returns (Tx1559Detail memory)\n {\n Tx1559Detail memory txDetail;\n txDetail.data = rawDetail.data;\n txDetail.from = rawDetail.from;\n txDetail.to = rawDetail.to;\n txDetail.nonce = _bytesToUint(rawDetail.nonce);\n txDetail.txType = _bytesToUint(rawDetail.txType);\n txDetail.value = _bytesToUint(rawDetail.value);\n txDetail.gas = _bytesToUint(rawDetail.gas);\n txDetail.accessList = rawDetail.accessList;\n return txDetail;\n }\n\n function readTx1559s(string memory path) internal view virtual returns (Tx1559[] memory) {\n string memory deployData = vm.readFile(path);\n bytes memory parsedDeployData = vm.parseJson(deployData, \".transactions\");\n RawTx1559[] memory rawTxs = abi.decode(parsedDeployData, (RawTx1559[]));\n return rawToConvertedEIPTx1559s(rawTxs);\n }\n\n function readTx1559(string memory path, uint256 index) internal view virtual returns (Tx1559 memory) {\n string memory deployData = vm.readFile(path);\n string memory key = string(abi.encodePacked(\".transactions[\", vm.toString(index), \"]\"));\n bytes memory parsedDeployData = vm.parseJson(deployData, key);\n RawTx1559 memory rawTx = abi.decode(parsedDeployData, (RawTx1559));\n return rawToConvertedEIPTx1559(rawTx);\n }\n\n // Analogous to readTransactions, but for receipts.\n function readReceipts(string memory path) internal view virtual returns (Receipt[] memory) {\n string memory deployData = vm.readFile(path);\n bytes memory parsedDeployData = vm.parseJson(deployData, \".receipts\");\n RawReceipt[] memory rawReceipts = abi.decode(parsedDeployData, (RawReceipt[]));\n return rawToConvertedReceipts(rawReceipts);\n }\n\n function readReceipt(string memory path, uint256 index) internal view virtual returns (Receipt memory) {\n string memory deployData = vm.readFile(path);\n string memory key = string(abi.encodePacked(\".receipts[\", vm.toString(index), \"]\"));\n bytes memory parsedDeployData = vm.parseJson(deployData, key);\n RawReceipt memory rawReceipt = abi.decode(parsedDeployData, (RawReceipt));\n return rawToConvertedReceipt(rawReceipt);\n }\n\n function rawToConvertedReceipts(RawReceipt[] memory rawReceipts) internal pure virtual returns (Receipt[] memory) {\n Receipt[] memory receipts = new Receipt[](rawReceipts.length);\n for (uint256 i; i < rawReceipts.length; i++) {\n receipts[i] = rawToConvertedReceipt(rawReceipts[i]);\n }\n return receipts;\n }\n\n function rawToConvertedReceipt(RawReceipt memory rawReceipt) internal pure virtual returns (Receipt memory) {\n Receipt memory receipt;\n receipt.blockHash = rawReceipt.blockHash;\n receipt.to = rawReceipt.to;\n receipt.from = rawReceipt.from;\n receipt.contractAddress = rawReceipt.contractAddress;\n receipt.effectiveGasPrice = _bytesToUint(rawReceipt.effectiveGasPrice);\n receipt.cumulativeGasUsed = _bytesToUint(rawReceipt.cumulativeGasUsed);\n receipt.gasUsed = _bytesToUint(rawReceipt.gasUsed);\n receipt.status = _bytesToUint(rawReceipt.status);\n receipt.transactionIndex = _bytesToUint(rawReceipt.transactionIndex);\n receipt.blockNumber = _bytesToUint(rawReceipt.blockNumber);\n receipt.logs = rawToConvertedReceiptLogs(rawReceipt.logs);\n receipt.logsBloom = rawReceipt.logsBloom;\n receipt.transactionHash = rawReceipt.transactionHash;\n return receipt;\n }\n\n function rawToConvertedReceiptLogs(RawReceiptLog[] memory rawLogs)\n internal\n pure\n virtual\n returns (ReceiptLog[] memory)\n {\n ReceiptLog[] memory logs = new ReceiptLog[](rawLogs.length);\n for (uint256 i; i < rawLogs.length; i++) {\n logs[i].logAddress = rawLogs[i].logAddress;\n logs[i].blockHash = rawLogs[i].blockHash;\n logs[i].blockNumber = _bytesToUint(rawLogs[i].blockNumber);\n logs[i].data = rawLogs[i].data;\n logs[i].logIndex = _bytesToUint(rawLogs[i].logIndex);\n logs[i].topics = rawLogs[i].topics;\n logs[i].transactionIndex = _bytesToUint(rawLogs[i].transactionIndex);\n logs[i].transactionLogIndex = _bytesToUint(rawLogs[i].transactionLogIndex);\n logs[i].removed = rawLogs[i].removed;\n }\n return logs;\n }\n\n // Deploy a contract by fetching the contract bytecode from\n // the artifacts directory\n // e.g. `deployCode(code, abi.encode(arg1,arg2,arg3))`\n function deployCode(string memory what, bytes memory args) internal virtual returns (address addr) {\n bytes memory bytecode = abi.encodePacked(vm.getCode(what), args);\n /// @solidity memory-safe-assembly\n assembly {\n addr := create(0, add(bytecode, 0x20), mload(bytecode))\n }\n\n require(addr != address(0), \"StdCheats deployCode(string,bytes): Deployment failed.\");\n }\n\n function deployCode(string memory what) internal virtual returns (address addr) {\n bytes memory bytecode = vm.getCode(what);\n /// @solidity memory-safe-assembly\n assembly {\n addr := create(0, add(bytecode, 0x20), mload(bytecode))\n }\n\n require(addr != address(0), \"StdCheats deployCode(string): Deployment failed.\");\n }\n\n /// @dev deploy contract with value on construction\n function deployCode(string memory what, bytes memory args, uint256 val) internal virtual returns (address addr) {\n bytes memory bytecode = abi.encodePacked(vm.getCode(what), args);\n /// @solidity memory-safe-assembly\n assembly {\n addr := create(val, add(bytecode, 0x20), mload(bytecode))\n }\n\n require(addr != address(0), \"StdCheats deployCode(string,bytes,uint256): Deployment failed.\");\n }\n\n function deployCode(string memory what, uint256 val) internal virtual returns (address addr) {\n bytes memory bytecode = vm.getCode(what);\n /// @solidity memory-safe-assembly\n assembly {\n addr := create(val, add(bytecode, 0x20), mload(bytecode))\n }\n\n require(addr != address(0), \"StdCheats deployCode(string,uint256): Deployment failed.\");\n }\n\n // creates a labeled address and the corresponding private key\n function makeAddrAndKey(string memory name) internal virtual returns (address addr, uint256 privateKey) {\n privateKey = uint256(keccak256(abi.encodePacked(name)));\n addr = vm.addr(privateKey);\n vm.label(addr, name);\n }\n\n // creates a labeled address\n function makeAddr(string memory name) internal virtual returns (address addr) {\n (addr,) = makeAddrAndKey(name);\n }\n\n // Destroys an account immediately, sending the balance to beneficiary.\n // Destroying means: balance will be zero, code will be empty, and nonce will be 0\n // This is similar to selfdestruct but not identical: selfdestruct destroys code and nonce\n // only after tx ends, this will run immediately.\n function destroyAccount(address who, address beneficiary) internal virtual {\n uint256 currBalance = who.balance;\n vm.etch(who, abi.encode());\n vm.deal(who, 0);\n vm.resetNonce(who);\n\n uint256 beneficiaryBalance = beneficiary.balance;\n vm.deal(beneficiary, currBalance + beneficiaryBalance);\n }\n\n // creates a struct containing both a labeled address and the corresponding private key\n function makeAccount(string memory name) internal virtual returns (Account memory account) {\n (account.addr, account.key) = makeAddrAndKey(name);\n }\n\n function deriveRememberKey(string memory mnemonic, uint32 index)\n internal\n virtual\n returns (address who, uint256 privateKey)\n {\n privateKey = vm.deriveKey(mnemonic, index);\n who = vm.rememberKey(privateKey);\n }\n\n function _bytesToUint(bytes memory b) private pure returns (uint256) {\n require(b.length <= 32, \"StdCheats _bytesToUint(bytes): Bytes length exceeds 32.\");\n return abi.decode(abi.encodePacked(new bytes(32 - b.length), b), (uint256));\n }\n\n function isFork() internal view virtual returns (bool status) {\n try vm.activeFork() {\n status = true;\n } catch (bytes memory) {}\n }\n\n modifier skipWhenForking() {\n if (!isFork()) {\n _;\n }\n }\n\n modifier skipWhenNotForking() {\n if (isFork()) {\n _;\n }\n }\n\n modifier noGasMetering() {\n vm.pauseGasMetering();\n // To prevent turning gas monitoring back on with nested functions that use this modifier,\n // we check if gasMetering started in the off position. If it did, we don't want to turn\n // it back on until we exit the top level function that used the modifier\n //\n // i.e. funcA() noGasMetering { funcB() }, where funcB has noGasMetering as well.\n // funcA will have `gasStartedOff` as false, funcB will have it as true,\n // so we only turn metering back on at the end of the funcA\n bool gasStartedOff = gasMeteringOff;\n gasMeteringOff = true;\n\n _;\n\n // if gas metering was on when this modifier was called, turn it back on at the end\n if (!gasStartedOff) {\n gasMeteringOff = false;\n vm.resumeGasMetering();\n }\n }\n\n // We use this complex approach of `_viewChainId` and `_pureChainId` to ensure there are no\n // compiler warnings when accessing chain ID in any solidity version supported by forge-std. We\n // can't simply access the chain ID in a normal view or pure function because the solc View Pure\n // Checker changed `chainid` from pure to view in 0.8.0.\n function _viewChainId() private view returns (uint256 chainId) {\n // Assembly required since `block.chainid` was introduced in 0.8.0.\n assembly {\n chainId := chainid()\n }\n\n address(this); // Silence warnings in older Solc versions.\n }\n\n function _pureChainId() private pure returns (uint256 chainId) {\n function() internal view returns (uint256) fnIn = _viewChainId;\n function() internal pure returns (uint256) pureChainId;\n assembly {\n pureChainId := fnIn\n }\n chainId = pureChainId();\n }\n}\n\n// Wrappers around cheatcodes to avoid footguns\nabstract contract StdCheats is StdCheatsSafe {\n using stdStorage for StdStorage;\n\n StdStorage private stdstore;\n Vm private constant vm = Vm(address(uint160(uint256(keccak256(\"hevm cheat code\")))));\n address private constant CONSOLE2_ADDRESS = 0x000000000000000000636F6e736F6c652e6c6f67;\n\n // Skip forward or rewind time by the specified number of seconds\n function skip(uint256 time) internal virtual {\n vm.warp(vm.getBlockTimestamp() + time);\n }\n\n function rewind(uint256 time) internal virtual {\n vm.warp(vm.getBlockTimestamp() - time);\n }\n\n // Setup a prank from an address that has some ether\n function hoax(address msgSender) internal virtual {\n vm.deal(msgSender, 1 << 128);\n vm.prank(msgSender);\n }\n\n function hoax(address msgSender, uint256 give) internal virtual {\n vm.deal(msgSender, give);\n vm.prank(msgSender);\n }\n\n function hoax(address msgSender, address origin) internal virtual {\n vm.deal(msgSender, 1 << 128);\n vm.prank(msgSender, origin);\n }\n\n function hoax(address msgSender, address origin, uint256 give) internal virtual {\n vm.deal(msgSender, give);\n vm.prank(msgSender, origin);\n }\n\n // Start perpetual prank from an address that has some ether\n function startHoax(address msgSender) internal virtual {\n vm.deal(msgSender, 1 << 128);\n vm.startPrank(msgSender);\n }\n\n function startHoax(address msgSender, uint256 give) internal virtual {\n vm.deal(msgSender, give);\n vm.startPrank(msgSender);\n }\n\n // Start perpetual prank from an address that has some ether\n // tx.origin is set to the origin parameter\n function startHoax(address msgSender, address origin) internal virtual {\n vm.deal(msgSender, 1 << 128);\n vm.startPrank(msgSender, origin);\n }\n\n function startHoax(address msgSender, address origin, uint256 give) internal virtual {\n vm.deal(msgSender, give);\n vm.startPrank(msgSender, origin);\n }\n\n function changePrank(address msgSender) internal virtual {\n console2_log_StdCheats(\"changePrank is deprecated. Please use vm.startPrank instead.\");\n vm.stopPrank();\n vm.startPrank(msgSender);\n }\n\n function changePrank(address msgSender, address txOrigin) internal virtual {\n vm.stopPrank();\n vm.startPrank(msgSender, txOrigin);\n }\n\n // The same as Vm's `deal`\n // Use the alternative signature for ERC20 tokens\n function deal(address to, uint256 give) internal virtual {\n vm.deal(to, give);\n }\n\n // Set the balance of an account for any ERC20 token\n // Use the alternative signature to update `totalSupply`\n function deal(address token, address to, uint256 give) internal virtual {\n deal(token, to, give, false);\n }\n\n // Set the balance of an account for any ERC1155 token\n // Use the alternative signature to update `totalSupply`\n function dealERC1155(address token, address to, uint256 id, uint256 give) internal virtual {\n dealERC1155(token, to, id, give, false);\n }\n\n function deal(address token, address to, uint256 give, bool adjust) internal virtual {\n // get current balance\n (, bytes memory balData) = token.staticcall(abi.encodeWithSelector(0x70a08231, to));\n uint256 prevBal = abi.decode(balData, (uint256));\n\n // update balance\n stdstore.target(token).sig(0x70a08231).with_key(to).checked_write(give);\n\n // update total supply\n if (adjust) {\n (, bytes memory totSupData) = token.staticcall(abi.encodeWithSelector(0x18160ddd));\n uint256 totSup = abi.decode(totSupData, (uint256));\n if (give < prevBal) {\n totSup -= (prevBal - give);\n } else {\n totSup += (give - prevBal);\n }\n stdstore.target(token).sig(0x18160ddd).checked_write(totSup);\n }\n }\n\n function dealERC1155(address token, address to, uint256 id, uint256 give, bool adjust) internal virtual {\n // get current balance\n (, bytes memory balData) = token.staticcall(abi.encodeWithSelector(0x00fdd58e, to, id));\n uint256 prevBal = abi.decode(balData, (uint256));\n\n // update balance\n stdstore.target(token).sig(0x00fdd58e).with_key(to).with_key(id).checked_write(give);\n\n // update total supply\n if (adjust) {\n (, bytes memory totSupData) = token.staticcall(abi.encodeWithSelector(0xbd85b039, id));\n require(\n totSupData.length != 0,\n \"StdCheats deal(address,address,uint,uint,bool): target contract is not ERC1155Supply.\"\n );\n uint256 totSup = abi.decode(totSupData, (uint256));\n if (give < prevBal) {\n totSup -= (prevBal - give);\n } else {\n totSup += (give - prevBal);\n }\n stdstore.target(token).sig(0xbd85b039).with_key(id).checked_write(totSup);\n }\n }\n\n function dealERC721(address token, address to, uint256 id) internal virtual {\n // check if token id is already minted and the actual owner.\n (bool successMinted, bytes memory ownerData) = token.staticcall(abi.encodeWithSelector(0x6352211e, id));\n require(successMinted, \"StdCheats deal(address,address,uint,bool): id not minted.\");\n\n // get owner current balance\n (, bytes memory fromBalData) =\n token.staticcall(abi.encodeWithSelector(0x70a08231, abi.decode(ownerData, (address))));\n uint256 fromPrevBal = abi.decode(fromBalData, (uint256));\n\n // get new user current balance\n (, bytes memory toBalData) = token.staticcall(abi.encodeWithSelector(0x70a08231, to));\n uint256 toPrevBal = abi.decode(toBalData, (uint256));\n\n // update balances\n stdstore.target(token).sig(0x70a08231).with_key(abi.decode(ownerData, (address))).checked_write(--fromPrevBal);\n stdstore.target(token).sig(0x70a08231).with_key(to).checked_write(++toPrevBal);\n\n // update owner\n stdstore.target(token).sig(0x6352211e).with_key(id).checked_write(to);\n }\n\n function deployCodeTo(string memory what, address where) internal virtual {\n deployCodeTo(what, \"\", 0, where);\n }\n\n function deployCodeTo(string memory what, bytes memory args, address where) internal virtual {\n deployCodeTo(what, args, 0, where);\n }\n\n function deployCodeTo(string memory what, bytes memory args, uint256 value, address where) internal virtual {\n bytes memory creationCode = vm.getCode(what);\n vm.etch(where, abi.encodePacked(creationCode, args));\n (bool success, bytes memory runtimeBytecode) = where.call{value: value}(\"\");\n require(success, \"StdCheats deployCodeTo(string,bytes,uint256,address): Failed to create runtime bytecode.\");\n vm.etch(where, runtimeBytecode);\n }\n\n // Used to prevent the compilation of console, which shortens the compilation time when console is not used elsewhere.\n function console2_log_StdCheats(string memory p0) private view {\n (bool status,) = address(CONSOLE2_ADDRESS).staticcall(abi.encodeWithSignature(\"log(string)\", p0));\n status;\n }\n}\n","license":"MIT"},"lib/forge-std/src/StdConstants.sol":{"keccak256":"0x319ccdabfa2c0b2428301445873270ffea20f0e039d4fd5e6eeba65158e4e534","urls":[],"content":"// SPDX-License-Identifier: MIT\npragma solidity >=0.6.2 <0.9.0;\n\nimport {IMulticall3} from \"./interfaces/IMulticall3.sol\";\nimport {Vm} from \"./Vm.sol\";\n\nlibrary StdConstants {\n /// @dev Cheat code address.\n /// Calculated as `address(uint160(uint256(keccak256(\"hevm cheat code\"))))`.\n Vm internal constant VM = Vm(0x7109709ECfa91a80626fF3989D68f67F5b1DD12D);\n /// @dev console.sol and console2.sol work by executing a staticcall to this address.\n /// Calculated as `address(uint160(uint88(bytes11(\"console.log\"))))`.\n address internal constant CONSOLE = 0x000000000000000000636F6e736F6c652e6c6f67;\n /// @dev Used when deploying with create2.\n /// Taken from https://github.com/Arachnid/deterministic-deployment-proxy.\n address internal constant CREATE2_FACTORY = 0x4e59b44847b379578588920cA78FbF26c0B4956C;\n /// @dev The default address for tx.origin and msg.sender.\n /// Calculated as `address(uint160(uint256(keccak256(\"foundry default caller\"))))`.\n address internal constant DEFAULT_SENDER = 0x1804c8AB1F12E6bbf3894d4083f33e07309d1f38;\n /// @dev The address of the first contract `CREATE`d by a running test contract.\n /// When running tests, each test contract is `CREATE`d by `DEFAULT_SENDER` with nonce 1.\n /// Calculated as `VM.computeCreateAddress(VM.computeCreateAddress(DEFAULT_SENDER, 1), 1)`.\n address internal constant DEFAULT_TEST_CONTRACT = 0x5615dEB798BB3E4dFa0139dFa1b3D433Cc23b72f;\n /// @dev Deterministic deployment address of the Multicall3 contract.\n /// Taken from https://www.multicall3.com.\n IMulticall3 internal constant MULTICALL3_ADDRESS = IMulticall3(0xcA11bde05977b3631167028862bE2a173976CA11);\n /// @dev The order of the secp256k1 curve.\n uint256 internal constant SECP256K1_ORDER =\n 115792089237316195423570985008687907852837564279074904382605163141518161494337;\n}\n","license":"MIT"},"lib/forge-std/src/StdJson.sol":{"keccak256":"0xbc0132abe1c2accc2867c0f03667afffdf92f3e95a581bb03c9557eaa38ea500","urls":[],"content":"// SPDX-License-Identifier: MIT\npragma solidity >=0.6.0 <0.9.0;\n\npragma experimental ABIEncoderV2;\n\nimport {VmSafe} from \"./Vm.sol\";\n\n// Helpers for parsing and writing JSON files\n// To parse:\n// ```\n// using stdJson for string;\n// string memory json = vm.readFile(\"\");\n// json.readUint(\"\");\n// ```\n// To write:\n// ```\n// using stdJson for string;\n// string memory json = \"json\";\n// json.serialize(\"a\", uint256(123));\n// string memory semiFinal = json.serialize(\"b\", string(\"test\"));\n// string memory finalJson = json.serialize(\"c\", semiFinal);\n// finalJson.write(\"\");\n// ```\n\nlibrary stdJson {\n VmSafe private constant vm = VmSafe(address(uint160(uint256(keccak256(\"hevm cheat code\")))));\n\n function keyExists(string memory json, string memory key) internal view returns (bool) {\n return vm.keyExistsJson(json, key);\n }\n\n function parseRaw(string memory json, string memory key) internal pure returns (bytes memory) {\n return vm.parseJson(json, key);\n }\n\n function readUint(string memory json, string memory key) internal pure returns (uint256) {\n return vm.parseJsonUint(json, key);\n }\n\n function readUintArray(string memory json, string memory key) internal pure returns (uint256[] memory) {\n return vm.parseJsonUintArray(json, key);\n }\n\n function readInt(string memory json, string memory key) internal pure returns (int256) {\n return vm.parseJsonInt(json, key);\n }\n\n function readIntArray(string memory json, string memory key) internal pure returns (int256[] memory) {\n return vm.parseJsonIntArray(json, key);\n }\n\n function readBytes32(string memory json, string memory key) internal pure returns (bytes32) {\n return vm.parseJsonBytes32(json, key);\n }\n\n function readBytes32Array(string memory json, string memory key) internal pure returns (bytes32[] memory) {\n return vm.parseJsonBytes32Array(json, key);\n }\n\n function readString(string memory json, string memory key) internal pure returns (string memory) {\n return vm.parseJsonString(json, key);\n }\n\n function readStringArray(string memory json, string memory key) internal pure returns (string[] memory) {\n return vm.parseJsonStringArray(json, key);\n }\n\n function readAddress(string memory json, string memory key) internal pure returns (address) {\n return vm.parseJsonAddress(json, key);\n }\n\n function readAddressArray(string memory json, string memory key) internal pure returns (address[] memory) {\n return vm.parseJsonAddressArray(json, key);\n }\n\n function readBool(string memory json, string memory key) internal pure returns (bool) {\n return vm.parseJsonBool(json, key);\n }\n\n function readBoolArray(string memory json, string memory key) internal pure returns (bool[] memory) {\n return vm.parseJsonBoolArray(json, key);\n }\n\n function readBytes(string memory json, string memory key) internal pure returns (bytes memory) {\n return vm.parseJsonBytes(json, key);\n }\n\n function readBytesArray(string memory json, string memory key) internal pure returns (bytes[] memory) {\n return vm.parseJsonBytesArray(json, key);\n }\n\n function readUintOr(string memory json, string memory key, uint256 defaultValue) internal view returns (uint256) {\n return keyExists(json, key) ? readUint(json, key) : defaultValue;\n }\n\n function readUintArrayOr(string memory json, string memory key, uint256[] memory defaultValue)\n internal\n view\n returns (uint256[] memory)\n {\n return keyExists(json, key) ? readUintArray(json, key) : defaultValue;\n }\n\n function readIntOr(string memory json, string memory key, int256 defaultValue) internal view returns (int256) {\n return keyExists(json, key) ? readInt(json, key) : defaultValue;\n }\n\n function readIntArrayOr(string memory json, string memory key, int256[] memory defaultValue)\n internal\n view\n returns (int256[] memory)\n {\n return keyExists(json, key) ? readIntArray(json, key) : defaultValue;\n }\n\n function readBytes32Or(string memory json, string memory key, bytes32 defaultValue)\n internal\n view\n returns (bytes32)\n {\n return keyExists(json, key) ? readBytes32(json, key) : defaultValue;\n }\n\n function readBytes32ArrayOr(string memory json, string memory key, bytes32[] memory defaultValue)\n internal\n view\n returns (bytes32[] memory)\n {\n return keyExists(json, key) ? readBytes32Array(json, key) : defaultValue;\n }\n\n function readStringOr(string memory json, string memory key, string memory defaultValue)\n internal\n view\n returns (string memory)\n {\n return keyExists(json, key) ? readString(json, key) : defaultValue;\n }\n\n function readStringArrayOr(string memory json, string memory key, string[] memory defaultValue)\n internal\n view\n returns (string[] memory)\n {\n return keyExists(json, key) ? readStringArray(json, key) : defaultValue;\n }\n\n function readAddressOr(string memory json, string memory key, address defaultValue)\n internal\n view\n returns (address)\n {\n return keyExists(json, key) ? readAddress(json, key) : defaultValue;\n }\n\n function readAddressArrayOr(string memory json, string memory key, address[] memory defaultValue)\n internal\n view\n returns (address[] memory)\n {\n return keyExists(json, key) ? readAddressArray(json, key) : defaultValue;\n }\n\n function readBoolOr(string memory json, string memory key, bool defaultValue) internal view returns (bool) {\n return keyExists(json, key) ? readBool(json, key) : defaultValue;\n }\n\n function readBoolArrayOr(string memory json, string memory key, bool[] memory defaultValue)\n internal\n view\n returns (bool[] memory)\n {\n return keyExists(json, key) ? readBoolArray(json, key) : defaultValue;\n }\n\n function readBytesOr(string memory json, string memory key, bytes memory defaultValue)\n internal\n view\n returns (bytes memory)\n {\n return keyExists(json, key) ? readBytes(json, key) : defaultValue;\n }\n\n function readBytesArrayOr(string memory json, string memory key, bytes[] memory defaultValue)\n internal\n view\n returns (bytes[] memory)\n {\n return keyExists(json, key) ? readBytesArray(json, key) : defaultValue;\n }\n\n function serialize(string memory jsonKey, string memory rootObject) internal returns (string memory) {\n return vm.serializeJson(jsonKey, rootObject);\n }\n\n function serialize(string memory jsonKey, string memory key, bool value) internal returns (string memory) {\n return vm.serializeBool(jsonKey, key, value);\n }\n\n function serialize(string memory jsonKey, string memory key, bool[] memory value)\n internal\n returns (string memory)\n {\n return vm.serializeBool(jsonKey, key, value);\n }\n\n function serialize(string memory jsonKey, string memory key, uint256 value) internal returns (string memory) {\n return vm.serializeUint(jsonKey, key, value);\n }\n\n function serialize(string memory jsonKey, string memory key, uint256[] memory value)\n internal\n returns (string memory)\n {\n return vm.serializeUint(jsonKey, key, value);\n }\n\n function serialize(string memory jsonKey, string memory key, int256 value) internal returns (string memory) {\n return vm.serializeInt(jsonKey, key, value);\n }\n\n function serialize(string memory jsonKey, string memory key, int256[] memory value)\n internal\n returns (string memory)\n {\n return vm.serializeInt(jsonKey, key, value);\n }\n\n function serialize(string memory jsonKey, string memory key, address value) internal returns (string memory) {\n return vm.serializeAddress(jsonKey, key, value);\n }\n\n function serialize(string memory jsonKey, string memory key, address[] memory value)\n internal\n returns (string memory)\n {\n return vm.serializeAddress(jsonKey, key, value);\n }\n\n function serialize(string memory jsonKey, string memory key, bytes32 value) internal returns (string memory) {\n return vm.serializeBytes32(jsonKey, key, value);\n }\n\n function serialize(string memory jsonKey, string memory key, bytes32[] memory value)\n internal\n returns (string memory)\n {\n return vm.serializeBytes32(jsonKey, key, value);\n }\n\n function serialize(string memory jsonKey, string memory key, bytes memory value) internal returns (string memory) {\n return vm.serializeBytes(jsonKey, key, value);\n }\n\n function serialize(string memory jsonKey, string memory key, bytes[] memory value)\n internal\n returns (string memory)\n {\n return vm.serializeBytes(jsonKey, key, value);\n }\n\n function serialize(string memory jsonKey, string memory key, string memory value)\n internal\n returns (string memory)\n {\n return vm.serializeString(jsonKey, key, value);\n }\n\n function serialize(string memory jsonKey, string memory key, string[] memory value)\n internal\n returns (string memory)\n {\n return vm.serializeString(jsonKey, key, value);\n }\n\n function write(string memory jsonKey, string memory path) internal {\n vm.writeJson(jsonKey, path);\n }\n\n function write(string memory jsonKey, string memory path, string memory valueKey) internal {\n vm.writeJson(jsonKey, path, valueKey);\n }\n}\n","license":"MIT"},"lib/forge-std/src/StdMath.sol":{"keccak256":"0xd90ad4fd8aeaeb8929964e686e769fdedd5eded3fc3815df194a0ab9f91a3fb2","urls":[],"content":"// SPDX-License-Identifier: MIT\npragma solidity >=0.6.2 <0.9.0;\n\nlibrary stdMath {\n int256 private constant INT256_MIN = -57896044618658097711785492504343953926634992332820282019728792003956564819968;\n\n function abs(int256 a) internal pure returns (uint256) {\n // Required or it will fail when `a = type(int256).min`\n if (a == INT256_MIN) {\n return 57896044618658097711785492504343953926634992332820282019728792003956564819968;\n }\n\n return uint256(a > 0 ? a : -a);\n }\n\n function delta(uint256 a, uint256 b) internal pure returns (uint256) {\n return a > b ? a - b : b - a;\n }\n\n function delta(int256 a, int256 b) internal pure returns (uint256) {\n // a and b are of the same sign\n // this works thanks to two's complement, the left-most bit is the sign bit\n if ((a ^ b) > -1) {\n return delta(abs(a), abs(b));\n }\n\n // a and b are of opposite signs\n return abs(a) + abs(b);\n }\n\n function percentDelta(uint256 a, uint256 b) internal pure returns (uint256) {\n uint256 absDelta = delta(a, b);\n\n return absDelta * 1e18 / b;\n }\n\n function percentDelta(int256 a, int256 b) internal pure returns (uint256) {\n uint256 absDelta = delta(a, b);\n uint256 absB = abs(b);\n\n return absDelta * 1e18 / absB;\n }\n}\n","license":"MIT"},"lib/forge-std/src/StdStorage.sol":{"keccak256":"0xb91ab24383a5872b894fc93325eef1add6cbbf981628f18e860068bf88bb7dcc","urls":[],"content":"// SPDX-License-Identifier: MIT\npragma solidity >=0.6.2 <0.9.0;\n\nimport {Vm} from \"./Vm.sol\";\n\nstruct FindData {\n uint256 slot;\n uint256 offsetLeft;\n uint256 offsetRight;\n bool found;\n}\n\nstruct StdStorage {\n mapping(address => mapping(bytes4 => mapping(bytes32 => FindData))) finds;\n bytes32[] _keys;\n bytes4 _sig;\n uint256 _depth;\n address _target;\n bytes32 _set;\n bool _enable_packed_slots;\n bytes _calldata;\n}\n\nlibrary stdStorageSafe {\n event SlotFound(address who, bytes4 fsig, bytes32 keysHash, uint256 slot);\n event WARNING_UninitedSlot(address who, uint256 slot);\n\n Vm private constant vm = Vm(address(uint160(uint256(keccak256(\"hevm cheat code\")))));\n uint256 constant UINT256_MAX = 115792089237316195423570985008687907853269984665640564039457584007913129639935;\n\n function sigs(string memory sigStr) internal pure returns (bytes4) {\n return bytes4(keccak256(bytes(sigStr)));\n }\n\n function getCallParams(StdStorage storage self) internal view returns (bytes memory) {\n if (self._calldata.length == 0) {\n return flatten(self._keys);\n } else {\n return self._calldata;\n }\n }\n\n // Calls target contract with configured parameters\n function callTarget(StdStorage storage self) internal view returns (bool, bytes32) {\n bytes memory cald = abi.encodePacked(self._sig, getCallParams(self));\n (bool success, bytes memory rdat) = self._target.staticcall(cald);\n bytes32 result = bytesToBytes32(rdat, 32 * self._depth);\n\n return (success, result);\n }\n\n // Tries mutating slot value to determine if the targeted value is stored in it.\n // If current value is 0, then we are setting slot value to type(uint256).max\n // Otherwise, we set it to 0. That way, return value should always be affected.\n function checkSlotMutatesCall(StdStorage storage self, bytes32 slot) internal returns (bool) {\n bytes32 prevSlotValue = vm.load(self._target, slot);\n (bool success, bytes32 prevReturnValue) = callTarget(self);\n\n bytes32 testVal = prevReturnValue == bytes32(0) ? bytes32(UINT256_MAX) : bytes32(0);\n vm.store(self._target, slot, testVal);\n\n (, bytes32 newReturnValue) = callTarget(self);\n\n vm.store(self._target, slot, prevSlotValue);\n\n return (success && (prevReturnValue != newReturnValue));\n }\n\n // Tries setting one of the bits in slot to 1 until return value changes.\n // Index of resulted bit is an offset packed slot has from left/right side\n function findOffset(StdStorage storage self, bytes32 slot, bool left) internal returns (bool, uint256) {\n for (uint256 offset = 0; offset < 256; offset++) {\n uint256 valueToPut = left ? (1 << (255 - offset)) : (1 << offset);\n vm.store(self._target, slot, bytes32(valueToPut));\n\n (bool success, bytes32 data) = callTarget(self);\n\n if (success && (uint256(data) > 0)) {\n return (true, offset);\n }\n }\n return (false, 0);\n }\n\n function findOffsets(StdStorage storage self, bytes32 slot) internal returns (bool, uint256, uint256) {\n bytes32 prevSlotValue = vm.load(self._target, slot);\n\n (bool foundLeft, uint256 offsetLeft) = findOffset(self, slot, true);\n (bool foundRight, uint256 offsetRight) = findOffset(self, slot, false);\n\n // `findOffset` may mutate slot value, so we are setting it to initial value\n vm.store(self._target, slot, prevSlotValue);\n return (foundLeft && foundRight, offsetLeft, offsetRight);\n }\n\n function find(StdStorage storage self) internal returns (FindData storage) {\n return find(self, true);\n }\n\n /// @notice find an arbitrary storage slot given a function sig, input data, address of the contract and a value to check against\n // slot complexity:\n // if flat, will be bytes32(uint256(uint));\n // if map, will be keccak256(abi.encode(key, uint(slot)));\n // if deep map, will be keccak256(abi.encode(key1, keccak256(abi.encode(key0, uint(slot)))));\n // if map struct, will be bytes32(uint256(keccak256(abi.encode(key1, keccak256(abi.encode(key0, uint(slot)))))) + structFieldDepth);\n function find(StdStorage storage self, bool _clear) internal returns (FindData storage) {\n address who = self._target;\n bytes4 fsig = self._sig;\n uint256 field_depth = self._depth;\n bytes memory params = getCallParams(self);\n\n // calldata to test against\n if (self.finds[who][fsig][keccak256(abi.encodePacked(params, field_depth))].found) {\n if (_clear) {\n clear(self);\n }\n return self.finds[who][fsig][keccak256(abi.encodePacked(params, field_depth))];\n }\n vm.record();\n (, bytes32 callResult) = callTarget(self);\n (bytes32[] memory reads,) = vm.accesses(address(who));\n\n if (reads.length == 0) {\n revert(\"stdStorage find(StdStorage): No storage use detected for target.\");\n } else {\n for (uint256 i = reads.length; --i >= 0;) {\n bytes32 prev = vm.load(who, reads[i]);\n if (prev == bytes32(0)) {\n emit WARNING_UninitedSlot(who, uint256(reads[i]));\n }\n\n if (!checkSlotMutatesCall(self, reads[i])) {\n continue;\n }\n\n (uint256 offsetLeft, uint256 offsetRight) = (0, 0);\n\n if (self._enable_packed_slots) {\n bool found;\n (found, offsetLeft, offsetRight) = findOffsets(self, reads[i]);\n if (!found) {\n continue;\n }\n }\n\n // Check that value between found offsets is equal to the current call result\n uint256 curVal = (uint256(prev) & getMaskByOffsets(offsetLeft, offsetRight)) >> offsetRight;\n\n if (uint256(callResult) != curVal) {\n continue;\n }\n\n emit SlotFound(who, fsig, keccak256(abi.encodePacked(params, field_depth)), uint256(reads[i]));\n self.finds[who][fsig][keccak256(abi.encodePacked(params, field_depth))] =\n FindData(uint256(reads[i]), offsetLeft, offsetRight, true);\n break;\n }\n }\n\n require(\n self.finds[who][fsig][keccak256(abi.encodePacked(params, field_depth))].found,\n \"stdStorage find(StdStorage): Slot(s) not found.\"\n );\n\n if (_clear) {\n clear(self);\n }\n return self.finds[who][fsig][keccak256(abi.encodePacked(params, field_depth))];\n }\n\n function target(StdStorage storage self, address _target) internal returns (StdStorage storage) {\n self._target = _target;\n return self;\n }\n\n function sig(StdStorage storage self, bytes4 _sig) internal returns (StdStorage storage) {\n self._sig = _sig;\n return self;\n }\n\n function sig(StdStorage storage self, string memory _sig) internal returns (StdStorage storage) {\n self._sig = sigs(_sig);\n return self;\n }\n\n function with_calldata(StdStorage storage self, bytes memory _calldata) internal returns (StdStorage storage) {\n self._calldata = _calldata;\n return self;\n }\n\n function with_key(StdStorage storage self, address who) internal returns (StdStorage storage) {\n self._keys.push(bytes32(uint256(uint160(who))));\n return self;\n }\n\n function with_key(StdStorage storage self, uint256 amt) internal returns (StdStorage storage) {\n self._keys.push(bytes32(amt));\n return self;\n }\n\n function with_key(StdStorage storage self, bytes32 key) internal returns (StdStorage storage) {\n self._keys.push(key);\n return self;\n }\n\n function enable_packed_slots(StdStorage storage self) internal returns (StdStorage storage) {\n self._enable_packed_slots = true;\n return self;\n }\n\n function depth(StdStorage storage self, uint256 _depth) internal returns (StdStorage storage) {\n self._depth = _depth;\n return self;\n }\n\n function read(StdStorage storage self) private returns (bytes memory) {\n FindData storage data = find(self, false);\n uint256 mask = getMaskByOffsets(data.offsetLeft, data.offsetRight);\n uint256 value = (uint256(vm.load(self._target, bytes32(data.slot))) & mask) >> data.offsetRight;\n clear(self);\n return abi.encode(value);\n }\n\n function read_bytes32(StdStorage storage self) internal returns (bytes32) {\n return abi.decode(read(self), (bytes32));\n }\n\n function read_bool(StdStorage storage self) internal returns (bool) {\n int256 v = read_int(self);\n if (v == 0) return false;\n if (v == 1) return true;\n revert(\"stdStorage read_bool(StdStorage): Cannot decode. Make sure you are reading a bool.\");\n }\n\n function read_address(StdStorage storage self) internal returns (address) {\n return abi.decode(read(self), (address));\n }\n\n function read_uint(StdStorage storage self) internal returns (uint256) {\n return abi.decode(read(self), (uint256));\n }\n\n function read_int(StdStorage storage self) internal returns (int256) {\n return abi.decode(read(self), (int256));\n }\n\n function parent(StdStorage storage self) internal returns (uint256, bytes32) {\n address who = self._target;\n uint256 field_depth = self._depth;\n vm.startMappingRecording();\n uint256 child = find(self, true).slot - field_depth;\n (bool found, bytes32 key, bytes32 parent_slot) = vm.getMappingKeyAndParentOf(who, bytes32(child));\n if (!found) {\n revert(\n \"stdStorage read_bool(StdStorage): Cannot find parent. Make sure you give a slot and startMappingRecording() has been called.\"\n );\n }\n return (uint256(parent_slot), key);\n }\n\n function root(StdStorage storage self) internal returns (uint256) {\n address who = self._target;\n uint256 field_depth = self._depth;\n vm.startMappingRecording();\n uint256 child = find(self, true).slot - field_depth;\n bool found;\n bytes32 root_slot;\n bytes32 parent_slot;\n (found,, parent_slot) = vm.getMappingKeyAndParentOf(who, bytes32(child));\n if (!found) {\n revert(\n \"stdStorage read_bool(StdStorage): Cannot find parent. Make sure you give a slot and startMappingRecording() has been called.\"\n );\n }\n while (found) {\n root_slot = parent_slot;\n (found,, parent_slot) = vm.getMappingKeyAndParentOf(who, bytes32(root_slot));\n }\n return uint256(root_slot);\n }\n\n function bytesToBytes32(bytes memory b, uint256 offset) private pure returns (bytes32) {\n bytes32 out;\n\n uint256 max = b.length > 32 ? 32 : b.length;\n for (uint256 i = 0; i < max; i++) {\n out |= bytes32(b[offset + i] & 0xFF) >> (i * 8);\n }\n return out;\n }\n\n function flatten(bytes32[] memory b) private pure returns (bytes memory) {\n bytes memory result = new bytes(b.length * 32);\n for (uint256 i = 0; i < b.length; i++) {\n bytes32 k = b[i];\n /// @solidity memory-safe-assembly\n assembly {\n mstore(add(result, add(32, mul(32, i))), k)\n }\n }\n\n return result;\n }\n\n function clear(StdStorage storage self) internal {\n delete self._target;\n delete self._sig;\n delete self._keys;\n delete self._depth;\n delete self._enable_packed_slots;\n delete self._calldata;\n }\n\n // Returns mask which contains non-zero bits for values between `offsetLeft` and `offsetRight`\n // (slotValue & mask) >> offsetRight will be the value of the given packed variable\n function getMaskByOffsets(uint256 offsetLeft, uint256 offsetRight) internal pure returns (uint256 mask) {\n // mask = ((1 << (256 - (offsetRight + offsetLeft))) - 1) << offsetRight;\n // using assembly because (1 << 256) causes overflow\n assembly {\n mask := shl(offsetRight, sub(shl(sub(256, add(offsetRight, offsetLeft)), 1), 1))\n }\n }\n\n // Returns slot value with updated packed variable.\n function getUpdatedSlotValue(bytes32 curValue, uint256 varValue, uint256 offsetLeft, uint256 offsetRight)\n internal\n pure\n returns (bytes32 newValue)\n {\n return bytes32((uint256(curValue) & ~getMaskByOffsets(offsetLeft, offsetRight)) | (varValue << offsetRight));\n }\n}\n\nlibrary stdStorage {\n Vm private constant vm = Vm(address(uint160(uint256(keccak256(\"hevm cheat code\")))));\n\n function sigs(string memory sigStr) internal pure returns (bytes4) {\n return stdStorageSafe.sigs(sigStr);\n }\n\n function find(StdStorage storage self) internal returns (uint256) {\n return find(self, true);\n }\n\n function find(StdStorage storage self, bool _clear) internal returns (uint256) {\n return stdStorageSafe.find(self, _clear).slot;\n }\n\n function target(StdStorage storage self, address _target) internal returns (StdStorage storage) {\n return stdStorageSafe.target(self, _target);\n }\n\n function sig(StdStorage storage self, bytes4 _sig) internal returns (StdStorage storage) {\n return stdStorageSafe.sig(self, _sig);\n }\n\n function sig(StdStorage storage self, string memory _sig) internal returns (StdStorage storage) {\n return stdStorageSafe.sig(self, _sig);\n }\n\n function with_key(StdStorage storage self, address who) internal returns (StdStorage storage) {\n return stdStorageSafe.with_key(self, who);\n }\n\n function with_key(StdStorage storage self, uint256 amt) internal returns (StdStorage storage) {\n return stdStorageSafe.with_key(self, amt);\n }\n\n function with_key(StdStorage storage self, bytes32 key) internal returns (StdStorage storage) {\n return stdStorageSafe.with_key(self, key);\n }\n\n function with_calldata(StdStorage storage self, bytes memory _calldata) internal returns (StdStorage storage) {\n return stdStorageSafe.with_calldata(self, _calldata);\n }\n\n function enable_packed_slots(StdStorage storage self) internal returns (StdStorage storage) {\n return stdStorageSafe.enable_packed_slots(self);\n }\n\n function depth(StdStorage storage self, uint256 _depth) internal returns (StdStorage storage) {\n return stdStorageSafe.depth(self, _depth);\n }\n\n function clear(StdStorage storage self) internal {\n stdStorageSafe.clear(self);\n }\n\n function checked_write(StdStorage storage self, address who) internal {\n checked_write(self, bytes32(uint256(uint160(who))));\n }\n\n function checked_write(StdStorage storage self, uint256 amt) internal {\n checked_write(self, bytes32(amt));\n }\n\n function checked_write_int(StdStorage storage self, int256 val) internal {\n checked_write(self, bytes32(uint256(val)));\n }\n\n function checked_write(StdStorage storage self, bool write) internal {\n bytes32 t;\n /// @solidity memory-safe-assembly\n assembly {\n t := write\n }\n checked_write(self, t);\n }\n\n function checked_write(StdStorage storage self, bytes32 set) internal {\n address who = self._target;\n bytes4 fsig = self._sig;\n uint256 field_depth = self._depth;\n bytes memory params = stdStorageSafe.getCallParams(self);\n\n if (!self.finds[who][fsig][keccak256(abi.encodePacked(params, field_depth))].found) {\n find(self, false);\n }\n FindData storage data = self.finds[who][fsig][keccak256(abi.encodePacked(params, field_depth))];\n if ((data.offsetLeft + data.offsetRight) > 0) {\n uint256 maxVal = 2 ** (256 - (data.offsetLeft + data.offsetRight));\n require(\n uint256(set) < maxVal,\n string(\n abi.encodePacked(\n \"stdStorage find(StdStorage): Packed slot. We can't fit value greater than \",\n vm.toString(maxVal)\n )\n )\n );\n }\n bytes32 curVal = vm.load(who, bytes32(data.slot));\n bytes32 valToSet = stdStorageSafe.getUpdatedSlotValue(curVal, uint256(set), data.offsetLeft, data.offsetRight);\n\n vm.store(who, bytes32(data.slot), valToSet);\n\n (bool success, bytes32 callResult) = stdStorageSafe.callTarget(self);\n\n if (!success || callResult != set) {\n vm.store(who, bytes32(data.slot), curVal);\n revert(\"stdStorage find(StdStorage): Failed to write value.\");\n }\n clear(self);\n }\n\n function read_bytes32(StdStorage storage self) internal returns (bytes32) {\n return stdStorageSafe.read_bytes32(self);\n }\n\n function read_bool(StdStorage storage self) internal returns (bool) {\n return stdStorageSafe.read_bool(self);\n }\n\n function read_address(StdStorage storage self) internal returns (address) {\n return stdStorageSafe.read_address(self);\n }\n\n function read_uint(StdStorage storage self) internal returns (uint256) {\n return stdStorageSafe.read_uint(self);\n }\n\n function read_int(StdStorage storage self) internal returns (int256) {\n return stdStorageSafe.read_int(self);\n }\n\n function parent(StdStorage storage self) internal returns (uint256, bytes32) {\n return stdStorageSafe.parent(self);\n }\n\n function root(StdStorage storage self) internal returns (uint256) {\n return stdStorageSafe.root(self);\n }\n}\n","license":"MIT"},"lib/forge-std/src/StdStyle.sol":{"keccak256":"0x43e2a8a9b9c2574dabe74f11adf6f782df218f463540e3b5b563609fe108597d","urls":[],"content":"// SPDX-License-Identifier: MIT\npragma solidity >=0.4.22 <0.9.0;\n\nimport {VmSafe} from \"./Vm.sol\";\n\nlibrary StdStyle {\n VmSafe private constant vm = VmSafe(address(uint160(uint256(keccak256(\"hevm cheat code\")))));\n\n string constant RED = \"\\u001b[91m\";\n string constant GREEN = \"\\u001b[92m\";\n string constant YELLOW = \"\\u001b[93m\";\n string constant BLUE = \"\\u001b[94m\";\n string constant MAGENTA = \"\\u001b[95m\";\n string constant CYAN = \"\\u001b[96m\";\n string constant BOLD = \"\\u001b[1m\";\n string constant DIM = \"\\u001b[2m\";\n string constant ITALIC = \"\\u001b[3m\";\n string constant UNDERLINE = \"\\u001b[4m\";\n string constant INVERSE = \"\\u001b[7m\";\n string constant RESET = \"\\u001b[0m\";\n\n function styleConcat(string memory style, string memory self) private pure returns (string memory) {\n return string(abi.encodePacked(style, self, RESET));\n }\n\n function red(string memory self) internal pure returns (string memory) {\n return styleConcat(RED, self);\n }\n\n function red(uint256 self) internal pure returns (string memory) {\n return red(vm.toString(self));\n }\n\n function red(int256 self) internal pure returns (string memory) {\n return red(vm.toString(self));\n }\n\n function red(address self) internal pure returns (string memory) {\n return red(vm.toString(self));\n }\n\n function red(bool self) internal pure returns (string memory) {\n return red(vm.toString(self));\n }\n\n function redBytes(bytes memory self) internal pure returns (string memory) {\n return red(vm.toString(self));\n }\n\n function redBytes32(bytes32 self) internal pure returns (string memory) {\n return red(vm.toString(self));\n }\n\n function green(string memory self) internal pure returns (string memory) {\n return styleConcat(GREEN, self);\n }\n\n function green(uint256 self) internal pure returns (string memory) {\n return green(vm.toString(self));\n }\n\n function green(int256 self) internal pure returns (string memory) {\n return green(vm.toString(self));\n }\n\n function green(address self) internal pure returns (string memory) {\n return green(vm.toString(self));\n }\n\n function green(bool self) internal pure returns (string memory) {\n return green(vm.toString(self));\n }\n\n function greenBytes(bytes memory self) internal pure returns (string memory) {\n return green(vm.toString(self));\n }\n\n function greenBytes32(bytes32 self) internal pure returns (string memory) {\n return green(vm.toString(self));\n }\n\n function yellow(string memory self) internal pure returns (string memory) {\n return styleConcat(YELLOW, self);\n }\n\n function yellow(uint256 self) internal pure returns (string memory) {\n return yellow(vm.toString(self));\n }\n\n function yellow(int256 self) internal pure returns (string memory) {\n return yellow(vm.toString(self));\n }\n\n function yellow(address self) internal pure returns (string memory) {\n return yellow(vm.toString(self));\n }\n\n function yellow(bool self) internal pure returns (string memory) {\n return yellow(vm.toString(self));\n }\n\n function yellowBytes(bytes memory self) internal pure returns (string memory) {\n return yellow(vm.toString(self));\n }\n\n function yellowBytes32(bytes32 self) internal pure returns (string memory) {\n return yellow(vm.toString(self));\n }\n\n function blue(string memory self) internal pure returns (string memory) {\n return styleConcat(BLUE, self);\n }\n\n function blue(uint256 self) internal pure returns (string memory) {\n return blue(vm.toString(self));\n }\n\n function blue(int256 self) internal pure returns (string memory) {\n return blue(vm.toString(self));\n }\n\n function blue(address self) internal pure returns (string memory) {\n return blue(vm.toString(self));\n }\n\n function blue(bool self) internal pure returns (string memory) {\n return blue(vm.toString(self));\n }\n\n function blueBytes(bytes memory self) internal pure returns (string memory) {\n return blue(vm.toString(self));\n }\n\n function blueBytes32(bytes32 self) internal pure returns (string memory) {\n return blue(vm.toString(self));\n }\n\n function magenta(string memory self) internal pure returns (string memory) {\n return styleConcat(MAGENTA, self);\n }\n\n function magenta(uint256 self) internal pure returns (string memory) {\n return magenta(vm.toString(self));\n }\n\n function magenta(int256 self) internal pure returns (string memory) {\n return magenta(vm.toString(self));\n }\n\n function magenta(address self) internal pure returns (string memory) {\n return magenta(vm.toString(self));\n }\n\n function magenta(bool self) internal pure returns (string memory) {\n return magenta(vm.toString(self));\n }\n\n function magentaBytes(bytes memory self) internal pure returns (string memory) {\n return magenta(vm.toString(self));\n }\n\n function magentaBytes32(bytes32 self) internal pure returns (string memory) {\n return magenta(vm.toString(self));\n }\n\n function cyan(string memory self) internal pure returns (string memory) {\n return styleConcat(CYAN, self);\n }\n\n function cyan(uint256 self) internal pure returns (string memory) {\n return cyan(vm.toString(self));\n }\n\n function cyan(int256 self) internal pure returns (string memory) {\n return cyan(vm.toString(self));\n }\n\n function cyan(address self) internal pure returns (string memory) {\n return cyan(vm.toString(self));\n }\n\n function cyan(bool self) internal pure returns (string memory) {\n return cyan(vm.toString(self));\n }\n\n function cyanBytes(bytes memory self) internal pure returns (string memory) {\n return cyan(vm.toString(self));\n }\n\n function cyanBytes32(bytes32 self) internal pure returns (string memory) {\n return cyan(vm.toString(self));\n }\n\n function bold(string memory self) internal pure returns (string memory) {\n return styleConcat(BOLD, self);\n }\n\n function bold(uint256 self) internal pure returns (string memory) {\n return bold(vm.toString(self));\n }\n\n function bold(int256 self) internal pure returns (string memory) {\n return bold(vm.toString(self));\n }\n\n function bold(address self) internal pure returns (string memory) {\n return bold(vm.toString(self));\n }\n\n function bold(bool self) internal pure returns (string memory) {\n return bold(vm.toString(self));\n }\n\n function boldBytes(bytes memory self) internal pure returns (string memory) {\n return bold(vm.toString(self));\n }\n\n function boldBytes32(bytes32 self) internal pure returns (string memory) {\n return bold(vm.toString(self));\n }\n\n function dim(string memory self) internal pure returns (string memory) {\n return styleConcat(DIM, self);\n }\n\n function dim(uint256 self) internal pure returns (string memory) {\n return dim(vm.toString(self));\n }\n\n function dim(int256 self) internal pure returns (string memory) {\n return dim(vm.toString(self));\n }\n\n function dim(address self) internal pure returns (string memory) {\n return dim(vm.toString(self));\n }\n\n function dim(bool self) internal pure returns (string memory) {\n return dim(vm.toString(self));\n }\n\n function dimBytes(bytes memory self) internal pure returns (string memory) {\n return dim(vm.toString(self));\n }\n\n function dimBytes32(bytes32 self) internal pure returns (string memory) {\n return dim(vm.toString(self));\n }\n\n function italic(string memory self) internal pure returns (string memory) {\n return styleConcat(ITALIC, self);\n }\n\n function italic(uint256 self) internal pure returns (string memory) {\n return italic(vm.toString(self));\n }\n\n function italic(int256 self) internal pure returns (string memory) {\n return italic(vm.toString(self));\n }\n\n function italic(address self) internal pure returns (string memory) {\n return italic(vm.toString(self));\n }\n\n function italic(bool self) internal pure returns (string memory) {\n return italic(vm.toString(self));\n }\n\n function italicBytes(bytes memory self) internal pure returns (string memory) {\n return italic(vm.toString(self));\n }\n\n function italicBytes32(bytes32 self) internal pure returns (string memory) {\n return italic(vm.toString(self));\n }\n\n function underline(string memory self) internal pure returns (string memory) {\n return styleConcat(UNDERLINE, self);\n }\n\n function underline(uint256 self) internal pure returns (string memory) {\n return underline(vm.toString(self));\n }\n\n function underline(int256 self) internal pure returns (string memory) {\n return underline(vm.toString(self));\n }\n\n function underline(address self) internal pure returns (string memory) {\n return underline(vm.toString(self));\n }\n\n function underline(bool self) internal pure returns (string memory) {\n return underline(vm.toString(self));\n }\n\n function underlineBytes(bytes memory self) internal pure returns (string memory) {\n return underline(vm.toString(self));\n }\n\n function underlineBytes32(bytes32 self) internal pure returns (string memory) {\n return underline(vm.toString(self));\n }\n\n function inverse(string memory self) internal pure returns (string memory) {\n return styleConcat(INVERSE, self);\n }\n\n function inverse(uint256 self) internal pure returns (string memory) {\n return inverse(vm.toString(self));\n }\n\n function inverse(int256 self) internal pure returns (string memory) {\n return inverse(vm.toString(self));\n }\n\n function inverse(address self) internal pure returns (string memory) {\n return inverse(vm.toString(self));\n }\n\n function inverse(bool self) internal pure returns (string memory) {\n return inverse(vm.toString(self));\n }\n\n function inverseBytes(bytes memory self) internal pure returns (string memory) {\n return inverse(vm.toString(self));\n }\n\n function inverseBytes32(bytes32 self) internal pure returns (string memory) {\n return inverse(vm.toString(self));\n }\n}\n","license":"MIT"},"lib/forge-std/src/StdUtils.sol":{"keccak256":"0x7274081e11c05164fd8eadde4de8305c033e58a43008dea58065f3170ccf0737","urls":[],"content":"// SPDX-License-Identifier: MIT\npragma solidity >=0.6.2 <0.9.0;\n\npragma experimental ABIEncoderV2;\n\nimport {IMulticall3} from \"./interfaces/IMulticall3.sol\";\nimport {VmSafe} from \"./Vm.sol\";\n\nabstract contract StdUtils {\n /*//////////////////////////////////////////////////////////////////////////\n CONSTANTS\n //////////////////////////////////////////////////////////////////////////*/\n\n IMulticall3 private constant multicall = IMulticall3(0xcA11bde05977b3631167028862bE2a173976CA11);\n VmSafe private constant vm = VmSafe(address(uint160(uint256(keccak256(\"hevm cheat code\")))));\n address private constant CONSOLE2_ADDRESS = 0x000000000000000000636F6e736F6c652e6c6f67;\n uint256 private constant INT256_MIN_ABS =\n 57896044618658097711785492504343953926634992332820282019728792003956564819968;\n uint256 private constant SECP256K1_ORDER =\n 115792089237316195423570985008687907852837564279074904382605163141518161494337;\n uint256 private constant UINT256_MAX =\n 115792089237316195423570985008687907853269984665640564039457584007913129639935;\n\n // Used by default when deploying with create2, https://github.com/Arachnid/deterministic-deployment-proxy.\n address private constant CREATE2_FACTORY = 0x4e59b44847b379578588920cA78FbF26c0B4956C;\n\n /*//////////////////////////////////////////////////////////////////////////\n INTERNAL FUNCTIONS\n //////////////////////////////////////////////////////////////////////////*/\n\n function _bound(uint256 x, uint256 min, uint256 max) internal pure virtual returns (uint256 result) {\n require(min <= max, \"StdUtils bound(uint256,uint256,uint256): Max is less than min.\");\n // If x is between min and max, return x directly. This is to ensure that dictionary values\n // do not get shifted if the min is nonzero. More info: https://github.com/foundry-rs/forge-std/issues/188\n if (x >= min && x <= max) return x;\n\n uint256 size = max - min + 1;\n\n // If the value is 0, 1, 2, 3, wrap that to min, min+1, min+2, min+3. Similarly for the UINT256_MAX side.\n // This helps ensure coverage of the min/max values.\n if (x <= 3 && size > x) return min + x;\n if (x >= UINT256_MAX - 3 && size > UINT256_MAX - x) return max - (UINT256_MAX - x);\n\n // Otherwise, wrap x into the range [min, max], i.e. the range is inclusive.\n if (x > max) {\n uint256 diff = x - max;\n uint256 rem = diff % size;\n if (rem == 0) return max;\n result = min + rem - 1;\n } else if (x < min) {\n uint256 diff = min - x;\n uint256 rem = diff % size;\n if (rem == 0) return min;\n result = max - rem + 1;\n }\n }\n\n function bound(uint256 x, uint256 min, uint256 max) internal pure virtual returns (uint256 result) {\n result = _bound(x, min, max);\n console2_log_StdUtils(\"Bound result\", result);\n }\n\n function _bound(int256 x, int256 min, int256 max) internal pure virtual returns (int256 result) {\n require(min <= max, \"StdUtils bound(int256,int256,int256): Max is less than min.\");\n\n // Shifting all int256 values to uint256 to use _bound function. The range of two types are:\n // int256 : -(2**255) ~ (2**255 - 1)\n // uint256: 0 ~ (2**256 - 1)\n // So, add 2**255, INT256_MIN_ABS to the integer values.\n //\n // If the given integer value is -2**255, we cannot use `-uint256(-x)` because of the overflow.\n // So, use `~uint256(x) + 1` instead.\n uint256 _x = x < 0 ? (INT256_MIN_ABS - ~uint256(x) - 1) : (uint256(x) + INT256_MIN_ABS);\n uint256 _min = min < 0 ? (INT256_MIN_ABS - ~uint256(min) - 1) : (uint256(min) + INT256_MIN_ABS);\n uint256 _max = max < 0 ? (INT256_MIN_ABS - ~uint256(max) - 1) : (uint256(max) + INT256_MIN_ABS);\n\n uint256 y = _bound(_x, _min, _max);\n\n // To move it back to int256 value, subtract INT256_MIN_ABS at here.\n result = y < INT256_MIN_ABS ? int256(~(INT256_MIN_ABS - y) + 1) : int256(y - INT256_MIN_ABS);\n }\n\n function bound(int256 x, int256 min, int256 max) internal pure virtual returns (int256 result) {\n result = _bound(x, min, max);\n console2_log_StdUtils(\"Bound result\", vm.toString(result));\n }\n\n function boundPrivateKey(uint256 privateKey) internal pure virtual returns (uint256 result) {\n result = _bound(privateKey, 1, SECP256K1_ORDER - 1);\n }\n\n function bytesToUint(bytes memory b) internal pure virtual returns (uint256) {\n require(b.length <= 32, \"StdUtils bytesToUint(bytes): Bytes length exceeds 32.\");\n return abi.decode(abi.encodePacked(new bytes(32 - b.length), b), (uint256));\n }\n\n /// @dev Compute the address a contract will be deployed at for a given deployer address and nonce\n /// @notice adapted from Solmate implementation (https://github.com/Rari-Capital/solmate/blob/main/src/utils/LibRLP.sol)\n function computeCreateAddress(address deployer, uint256 nonce) internal pure virtual returns (address) {\n console2_log_StdUtils(\"computeCreateAddress is deprecated. Please use vm.computeCreateAddress instead.\");\n return vm.computeCreateAddress(deployer, nonce);\n }\n\n function computeCreate2Address(bytes32 salt, bytes32 initcodeHash, address deployer)\n internal\n pure\n virtual\n returns (address)\n {\n console2_log_StdUtils(\"computeCreate2Address is deprecated. Please use vm.computeCreate2Address instead.\");\n return vm.computeCreate2Address(salt, initcodeHash, deployer);\n }\n\n /// @dev returns the address of a contract created with CREATE2 using the default CREATE2 deployer\n function computeCreate2Address(bytes32 salt, bytes32 initCodeHash) internal pure returns (address) {\n console2_log_StdUtils(\"computeCreate2Address is deprecated. Please use vm.computeCreate2Address instead.\");\n return vm.computeCreate2Address(salt, initCodeHash);\n }\n\n /// @dev returns the hash of the init code (creation code + no args) used in CREATE2 with no constructor arguments\n /// @param creationCode the creation code of a contract C, as returned by type(C).creationCode\n function hashInitCode(bytes memory creationCode) internal pure returns (bytes32) {\n return hashInitCode(creationCode, \"\");\n }\n\n /// @dev returns the hash of the init code (creation code + ABI-encoded args) used in CREATE2\n /// @param creationCode the creation code of a contract C, as returned by type(C).creationCode\n /// @param args the ABI-encoded arguments to the constructor of C\n function hashInitCode(bytes memory creationCode, bytes memory args) internal pure returns (bytes32) {\n return keccak256(abi.encodePacked(creationCode, args));\n }\n\n // Performs a single call with Multicall3 to query the ERC-20 token balances of the given addresses.\n function getTokenBalances(address token, address[] memory addresses)\n internal\n virtual\n returns (uint256[] memory balances)\n {\n uint256 tokenCodeSize;\n assembly {\n tokenCodeSize := extcodesize(token)\n }\n require(tokenCodeSize > 0, \"StdUtils getTokenBalances(address,address[]): Token address is not a contract.\");\n\n // ABI encode the aggregate call to Multicall3.\n uint256 length = addresses.length;\n IMulticall3.Call[] memory calls = new IMulticall3.Call[](length);\n for (uint256 i = 0; i < length; ++i) {\n // 0x70a08231 = bytes4(\"balanceOf(address)\"))\n calls[i] = IMulticall3.Call({target: token, callData: abi.encodeWithSelector(0x70a08231, (addresses[i]))});\n }\n\n // Make the aggregate call.\n (, bytes[] memory returnData) = multicall.aggregate(calls);\n\n // ABI decode the return data and return the balances.\n balances = new uint256[](length);\n for (uint256 i = 0; i < length; ++i) {\n balances[i] = abi.decode(returnData[i], (uint256));\n }\n }\n\n /*//////////////////////////////////////////////////////////////////////////\n PRIVATE FUNCTIONS\n //////////////////////////////////////////////////////////////////////////*/\n\n function addressFromLast20Bytes(bytes32 bytesValue) private pure returns (address) {\n return address(uint160(uint256(bytesValue)));\n }\n\n // This section is used to prevent the compilation of console, which shortens the compilation time when console is\n // not used elsewhere. We also trick the compiler into letting us make the console log methods as `pure` to avoid\n // any breaking changes to function signatures.\n function _castLogPayloadViewToPure(function(bytes memory) internal view fnIn)\n internal\n pure\n returns (function(bytes memory) internal pure fnOut)\n {\n assembly {\n fnOut := fnIn\n }\n }\n\n function _sendLogPayload(bytes memory payload) internal pure {\n _castLogPayloadViewToPure(_sendLogPayloadView)(payload);\n }\n\n function _sendLogPayloadView(bytes memory payload) private view {\n uint256 payloadLength = payload.length;\n address consoleAddress = CONSOLE2_ADDRESS;\n /// @solidity memory-safe-assembly\n assembly {\n let payloadStart := add(payload, 32)\n let r := staticcall(gas(), consoleAddress, payloadStart, payloadLength, 0, 0)\n }\n }\n\n function console2_log_StdUtils(string memory p0) private pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string)\", p0));\n }\n\n function console2_log_StdUtils(string memory p0, uint256 p1) private pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,uint256)\", p0, p1));\n }\n\n function console2_log_StdUtils(string memory p0, string memory p1) private pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,string)\", p0, p1));\n }\n}\n","license":"MIT"},"lib/forge-std/src/Vm.sol":{"keccak256":"0xd91fb0df409fbd22463e937b48b9682d9333c5d4528d8fe7b36102a0323c44bf","urls":[],"content":"// Automatically @generated by scripts/vm.py. Do not modify manually.\n\n// SPDX-License-Identifier: MIT OR Apache-2.0\npragma solidity >=0.6.2 <0.9.0;\npragma experimental ABIEncoderV2;\n\n/// The `VmSafe` interface does not allow manipulation of the EVM state or other actions that may\n/// result in Script simulations differing from on-chain execution. It is recommended to only use\n/// these cheats in scripts.\ninterface VmSafe {\n /// A modification applied to either `msg.sender` or `tx.origin`. Returned by `readCallers`.\n enum CallerMode {\n // No caller modification is currently active.\n None,\n // A one time broadcast triggered by a `vm.broadcast()` call is currently active.\n Broadcast,\n // A recurrent broadcast triggered by a `vm.startBroadcast()` call is currently active.\n RecurrentBroadcast,\n // A one time prank triggered by a `vm.prank()` call is currently active.\n Prank,\n // A recurrent prank triggered by a `vm.startPrank()` call is currently active.\n RecurrentPrank\n }\n\n /// The kind of account access that occurred.\n enum AccountAccessKind {\n // The account was called.\n Call,\n // The account was called via delegatecall.\n DelegateCall,\n // The account was called via callcode.\n CallCode,\n // The account was called via staticcall.\n StaticCall,\n // The account was created.\n Create,\n // The account was selfdestructed.\n SelfDestruct,\n // Synthetic access indicating the current context has resumed after a previous sub-context (AccountAccess).\n Resume,\n // The account's balance was read.\n Balance,\n // The account's codesize was read.\n Extcodesize,\n // The account's codehash was read.\n Extcodehash,\n // The account's code was copied.\n Extcodecopy\n }\n\n /// Forge execution contexts.\n enum ForgeContext {\n // Test group execution context (test, coverage or snapshot).\n TestGroup,\n // `forge test` execution context.\n Test,\n // `forge coverage` execution context.\n Coverage,\n // `forge snapshot` execution context.\n Snapshot,\n // Script group execution context (dry run, broadcast or resume).\n ScriptGroup,\n // `forge script` execution context.\n ScriptDryRun,\n // `forge script --broadcast` execution context.\n ScriptBroadcast,\n // `forge script --resume` execution context.\n ScriptResume,\n // Unknown `forge` execution context.\n Unknown\n }\n\n /// The transaction type (`txType`) of the broadcast.\n enum BroadcastTxType {\n // Represents a CALL broadcast tx.\n Call,\n // Represents a CREATE broadcast tx.\n Create,\n // Represents a CREATE2 broadcast tx.\n Create2\n }\n\n /// An Ethereum log. Returned by `getRecordedLogs`.\n struct Log {\n // The topics of the log, including the signature, if any.\n bytes32[] topics;\n // The raw data of the log.\n bytes data;\n // The address of the log's emitter.\n address emitter;\n }\n\n /// An RPC URL and its alias. Returned by `rpcUrlStructs`.\n struct Rpc {\n // The alias of the RPC URL.\n string key;\n // The RPC URL.\n string url;\n }\n\n /// An RPC log object. Returned by `eth_getLogs`.\n struct EthGetLogs {\n // The address of the log's emitter.\n address emitter;\n // The topics of the log, including the signature, if any.\n bytes32[] topics;\n // The raw data of the log.\n bytes data;\n // The block hash.\n bytes32 blockHash;\n // The block number.\n uint64 blockNumber;\n // The transaction hash.\n bytes32 transactionHash;\n // The transaction index in the block.\n uint64 transactionIndex;\n // The log index.\n uint256 logIndex;\n // Whether the log was removed.\n bool removed;\n }\n\n /// A single entry in a directory listing. Returned by `readDir`.\n struct DirEntry {\n // The error message, if any.\n string errorMessage;\n // The path of the entry.\n string path;\n // The depth of the entry.\n uint64 depth;\n // Whether the entry is a directory.\n bool isDir;\n // Whether the entry is a symlink.\n bool isSymlink;\n }\n\n /// Metadata information about a file.\n /// This structure is returned from the `fsMetadata` function and represents known\n /// metadata about a file such as its permissions, size, modification\n /// times, etc.\n struct FsMetadata {\n // True if this metadata is for a directory.\n bool isDir;\n // True if this metadata is for a symlink.\n bool isSymlink;\n // The size of the file, in bytes, this metadata is for.\n uint256 length;\n // True if this metadata is for a readonly (unwritable) file.\n bool readOnly;\n // The last modification time listed in this metadata.\n uint256 modified;\n // The last access time of this metadata.\n uint256 accessed;\n // The creation time listed in this metadata.\n uint256 created;\n }\n\n /// A wallet with a public and private key.\n struct Wallet {\n // The wallet's address.\n address addr;\n // The wallet's public key `X`.\n uint256 publicKeyX;\n // The wallet's public key `Y`.\n uint256 publicKeyY;\n // The wallet's private key.\n uint256 privateKey;\n }\n\n /// The result of a `tryFfi` call.\n struct FfiResult {\n // The exit code of the call.\n int32 exitCode;\n // The optionally hex-decoded `stdout` data.\n bytes stdout;\n // The `stderr` data.\n bytes stderr;\n }\n\n /// Information on the chain and fork.\n struct ChainInfo {\n // The fork identifier. Set to zero if no fork is active.\n uint256 forkId;\n // The chain ID of the current fork.\n uint256 chainId;\n }\n\n /// The result of a `stopAndReturnStateDiff` call.\n struct AccountAccess {\n // The chain and fork the access occurred.\n ChainInfo chainInfo;\n // The kind of account access that determines what the account is.\n // If kind is Call, DelegateCall, StaticCall or CallCode, then the account is the callee.\n // If kind is Create, then the account is the newly created account.\n // If kind is SelfDestruct, then the account is the selfdestruct recipient.\n // If kind is a Resume, then account represents a account context that has resumed.\n AccountAccessKind kind;\n // The account that was accessed.\n // It's either the account created, callee or a selfdestruct recipient for CREATE, CALL or SELFDESTRUCT.\n address account;\n // What accessed the account.\n address accessor;\n // If the account was initialized or empty prior to the access.\n // An account is considered initialized if it has code, a\n // non-zero nonce, or a non-zero balance.\n bool initialized;\n // The previous balance of the accessed account.\n uint256 oldBalance;\n // The potential new balance of the accessed account.\n // That is, all balance changes are recorded here, even if reverts occurred.\n uint256 newBalance;\n // Code of the account deployed by CREATE.\n bytes deployedCode;\n // Value passed along with the account access\n uint256 value;\n // Input data provided to the CREATE or CALL\n bytes data;\n // If this access reverted in either the current or parent context.\n bool reverted;\n // An ordered list of storage accesses made during an account access operation.\n StorageAccess[] storageAccesses;\n // Call depth traversed during the recording of state differences\n uint64 depth;\n }\n\n /// The storage accessed during an `AccountAccess`.\n struct StorageAccess {\n // The account whose storage was accessed.\n address account;\n // The slot that was accessed.\n bytes32 slot;\n // If the access was a write.\n bool isWrite;\n // The previous value of the slot.\n bytes32 previousValue;\n // The new value of the slot.\n bytes32 newValue;\n // If the access was reverted.\n bool reverted;\n }\n\n /// Gas used. Returned by `lastCallGas`.\n struct Gas {\n // The gas limit of the call.\n uint64 gasLimit;\n // The total gas used.\n uint64 gasTotalUsed;\n // DEPRECATED: The amount of gas used for memory expansion. Ref: \n uint64 gasMemoryUsed;\n // The amount of gas refunded.\n int64 gasRefunded;\n // The amount of gas remaining.\n uint64 gasRemaining;\n }\n\n /// The result of the `stopDebugTraceRecording` call\n struct DebugStep {\n // The stack before executing the step of the run.\n // stack\\[0\\] represents the top of the stack.\n // and only stack data relevant to the opcode execution is contained.\n uint256[] stack;\n // The memory input data before executing the step of the run.\n // only input data relevant to the opcode execution is contained.\n // e.g. for MLOAD, it will have memory\\[offset:offset+32\\] copied here.\n // the offset value can be get by the stack data.\n bytes memoryInput;\n // The opcode that was accessed.\n uint8 opcode;\n // The call depth of the step.\n uint64 depth;\n // Whether the call end up with out of gas error.\n bool isOutOfGas;\n // The contract address where the opcode is running\n address contractAddr;\n }\n\n /// Represents a transaction's broadcast details.\n struct BroadcastTxSummary {\n // The hash of the transaction that was broadcasted\n bytes32 txHash;\n // Represent the type of transaction among CALL, CREATE, CREATE2\n BroadcastTxType txType;\n // The address of the contract that was called or created.\n // This is address of the contract that is created if the txType is CREATE or CREATE2.\n address contractAddress;\n // The block number the transaction landed in.\n uint64 blockNumber;\n // Status of the transaction, retrieved from the transaction receipt.\n bool success;\n }\n\n /// Holds a signed EIP-7702 authorization for an authority account to delegate to an implementation.\n struct SignedDelegation {\n // The y-parity of the recovered secp256k1 signature (0 or 1).\n uint8 v;\n // First 32 bytes of the signature.\n bytes32 r;\n // Second 32 bytes of the signature.\n bytes32 s;\n // The current nonce of the authority account at signing time.\n // Used to ensure signature can't be replayed after account nonce changes.\n uint64 nonce;\n // Address of the contract implementation that will be delegated to.\n // Gets encoded into delegation code: 0xef0100 || implementation.\n address implementation;\n }\n\n /// Represents a \"potential\" revert reason from a single subsequent call when using `vm.assumeNoReverts`.\n /// Reverts that match will result in a FOUNDRY::ASSUME rejection, whereas unmatched reverts will be surfaced\n /// as normal.\n struct PotentialRevert {\n // The allowed origin of the revert opcode; address(0) allows reverts from any address\n address reverter;\n // When true, only matches on the beginning of the revert data, otherwise, matches on entire revert data\n bool partialMatch;\n // The data to use to match encountered reverts\n bytes revertData;\n }\n\n /// An EIP-2930 access list item.\n struct AccessListItem {\n // The address to be added in access list.\n address target;\n // The storage keys to be added in access list.\n bytes32[] storageKeys;\n }\n\n // ======== Crypto ========\n\n /// Derives a private key from the name, labels the account with that name, and returns the wallet.\n function createWallet(string calldata walletLabel) external returns (Wallet memory wallet);\n\n /// Generates a wallet from the private key and returns the wallet.\n function createWallet(uint256 privateKey) external returns (Wallet memory wallet);\n\n /// Generates a wallet from the private key, labels the account with that name, and returns the wallet.\n function createWallet(uint256 privateKey, string calldata walletLabel) external returns (Wallet memory wallet);\n\n /// Derive a private key from a provided mnenomic string (or mnenomic file path)\n /// at the derivation path `m/44'/60'/0'/0/{index}`.\n function deriveKey(string calldata mnemonic, uint32 index) external pure returns (uint256 privateKey);\n\n /// Derive a private key from a provided mnenomic string (or mnenomic file path)\n /// at `{derivationPath}{index}`.\n function deriveKey(string calldata mnemonic, string calldata derivationPath, uint32 index)\n external\n pure\n returns (uint256 privateKey);\n\n /// Derive a private key from a provided mnenomic string (or mnenomic file path) in the specified language\n /// at the derivation path `m/44'/60'/0'/0/{index}`.\n function deriveKey(string calldata mnemonic, uint32 index, string calldata language)\n external\n pure\n returns (uint256 privateKey);\n\n /// Derive a private key from a provided mnenomic string (or mnenomic file path) in the specified language\n /// at `{derivationPath}{index}`.\n function deriveKey(string calldata mnemonic, string calldata derivationPath, uint32 index, string calldata language)\n external\n pure\n returns (uint256 privateKey);\n\n /// Derives secp256r1 public key from the provided `privateKey`.\n function publicKeyP256(uint256 privateKey) external pure returns (uint256 publicKeyX, uint256 publicKeyY);\n\n /// Adds a private key to the local forge wallet and returns the address.\n function rememberKey(uint256 privateKey) external returns (address keyAddr);\n\n /// Derive a set number of wallets from a mnemonic at the derivation path `m/44'/60'/0'/0/{0..count}`.\n /// The respective private keys are saved to the local forge wallet for later use and their addresses are returned.\n function rememberKeys(string calldata mnemonic, string calldata derivationPath, uint32 count)\n external\n returns (address[] memory keyAddrs);\n\n /// Derive a set number of wallets from a mnemonic in the specified language at the derivation path `m/44'/60'/0'/0/{0..count}`.\n /// The respective private keys are saved to the local forge wallet for later use and their addresses are returned.\n function rememberKeys(\n string calldata mnemonic,\n string calldata derivationPath,\n string calldata language,\n uint32 count\n ) external returns (address[] memory keyAddrs);\n\n /// Signs data with a `Wallet`.\n /// Returns a compact signature (`r`, `vs`) as per EIP-2098, where `vs` encodes both the\n /// signature's `s` value, and the recovery id `v` in a single bytes32.\n /// This format reduces the signature size from 65 to 64 bytes.\n function signCompact(Wallet calldata wallet, bytes32 digest) external returns (bytes32 r, bytes32 vs);\n\n /// Signs `digest` with `privateKey` using the secp256k1 curve.\n /// Returns a compact signature (`r`, `vs`) as per EIP-2098, where `vs` encodes both the\n /// signature's `s` value, and the recovery id `v` in a single bytes32.\n /// This format reduces the signature size from 65 to 64 bytes.\n function signCompact(uint256 privateKey, bytes32 digest) external pure returns (bytes32 r, bytes32 vs);\n\n /// Signs `digest` with signer provided to script using the secp256k1 curve.\n /// Returns a compact signature (`r`, `vs`) as per EIP-2098, where `vs` encodes both the\n /// signature's `s` value, and the recovery id `v` in a single bytes32.\n /// This format reduces the signature size from 65 to 64 bytes.\n /// If `--sender` is provided, the signer with provided address is used, otherwise,\n /// if exactly one signer is provided to the script, that signer is used.\n /// Raises error if signer passed through `--sender` does not match any unlocked signers or\n /// if `--sender` is not provided and not exactly one signer is passed to the script.\n function signCompact(bytes32 digest) external pure returns (bytes32 r, bytes32 vs);\n\n /// Signs `digest` with signer provided to script using the secp256k1 curve.\n /// Returns a compact signature (`r`, `vs`) as per EIP-2098, where `vs` encodes both the\n /// signature's `s` value, and the recovery id `v` in a single bytes32.\n /// This format reduces the signature size from 65 to 64 bytes.\n /// Raises error if none of the signers passed into the script have provided address.\n function signCompact(address signer, bytes32 digest) external pure returns (bytes32 r, bytes32 vs);\n\n /// Signs `digest` with `privateKey` using the secp256r1 curve.\n function signP256(uint256 privateKey, bytes32 digest) external pure returns (bytes32 r, bytes32 s);\n\n /// Signs data with a `Wallet`.\n function sign(Wallet calldata wallet, bytes32 digest) external returns (uint8 v, bytes32 r, bytes32 s);\n\n /// Signs `digest` with `privateKey` using the secp256k1 curve.\n function sign(uint256 privateKey, bytes32 digest) external pure returns (uint8 v, bytes32 r, bytes32 s);\n\n /// Signs `digest` with signer provided to script using the secp256k1 curve.\n /// If `--sender` is provided, the signer with provided address is used, otherwise,\n /// if exactly one signer is provided to the script, that signer is used.\n /// Raises error if signer passed through `--sender` does not match any unlocked signers or\n /// if `--sender` is not provided and not exactly one signer is passed to the script.\n function sign(bytes32 digest) external pure returns (uint8 v, bytes32 r, bytes32 s);\n\n /// Signs `digest` with signer provided to script using the secp256k1 curve.\n /// Raises error if none of the signers passed into the script have provided address.\n function sign(address signer, bytes32 digest) external pure returns (uint8 v, bytes32 r, bytes32 s);\n\n // ======== Environment ========\n\n /// Gets the environment variable `name` and parses it as `address`.\n /// Reverts if the variable was not found or could not be parsed.\n function envAddress(string calldata name) external view returns (address value);\n\n /// Gets the environment variable `name` and parses it as an array of `address`, delimited by `delim`.\n /// Reverts if the variable was not found or could not be parsed.\n function envAddress(string calldata name, string calldata delim) external view returns (address[] memory value);\n\n /// Gets the environment variable `name` and parses it as `bool`.\n /// Reverts if the variable was not found or could not be parsed.\n function envBool(string calldata name) external view returns (bool value);\n\n /// Gets the environment variable `name` and parses it as an array of `bool`, delimited by `delim`.\n /// Reverts if the variable was not found or could not be parsed.\n function envBool(string calldata name, string calldata delim) external view returns (bool[] memory value);\n\n /// Gets the environment variable `name` and parses it as `bytes32`.\n /// Reverts if the variable was not found or could not be parsed.\n function envBytes32(string calldata name) external view returns (bytes32 value);\n\n /// Gets the environment variable `name` and parses it as an array of `bytes32`, delimited by `delim`.\n /// Reverts if the variable was not found or could not be parsed.\n function envBytes32(string calldata name, string calldata delim) external view returns (bytes32[] memory value);\n\n /// Gets the environment variable `name` and parses it as `bytes`.\n /// Reverts if the variable was not found or could not be parsed.\n function envBytes(string calldata name) external view returns (bytes memory value);\n\n /// Gets the environment variable `name` and parses it as an array of `bytes`, delimited by `delim`.\n /// Reverts if the variable was not found or could not be parsed.\n function envBytes(string calldata name, string calldata delim) external view returns (bytes[] memory value);\n\n /// Gets the environment variable `name` and returns true if it exists, else returns false.\n function envExists(string calldata name) external view returns (bool result);\n\n /// Gets the environment variable `name` and parses it as `int256`.\n /// Reverts if the variable was not found or could not be parsed.\n function envInt(string calldata name) external view returns (int256 value);\n\n /// Gets the environment variable `name` and parses it as an array of `int256`, delimited by `delim`.\n /// Reverts if the variable was not found or could not be parsed.\n function envInt(string calldata name, string calldata delim) external view returns (int256[] memory value);\n\n /// Gets the environment variable `name` and parses it as `bool`.\n /// Reverts if the variable could not be parsed.\n /// Returns `defaultValue` if the variable was not found.\n function envOr(string calldata name, bool defaultValue) external view returns (bool value);\n\n /// Gets the environment variable `name` and parses it as `uint256`.\n /// Reverts if the variable could not be parsed.\n /// Returns `defaultValue` if the variable was not found.\n function envOr(string calldata name, uint256 defaultValue) external view returns (uint256 value);\n\n /// Gets the environment variable `name` and parses it as an array of `address`, delimited by `delim`.\n /// Reverts if the variable could not be parsed.\n /// Returns `defaultValue` if the variable was not found.\n function envOr(string calldata name, string calldata delim, address[] calldata defaultValue)\n external\n view\n returns (address[] memory value);\n\n /// Gets the environment variable `name` and parses it as an array of `bytes32`, delimited by `delim`.\n /// Reverts if the variable could not be parsed.\n /// Returns `defaultValue` if the variable was not found.\n function envOr(string calldata name, string calldata delim, bytes32[] calldata defaultValue)\n external\n view\n returns (bytes32[] memory value);\n\n /// Gets the environment variable `name` and parses it as an array of `string`, delimited by `delim`.\n /// Reverts if the variable could not be parsed.\n /// Returns `defaultValue` if the variable was not found.\n function envOr(string calldata name, string calldata delim, string[] calldata defaultValue)\n external\n view\n returns (string[] memory value);\n\n /// Gets the environment variable `name` and parses it as an array of `bytes`, delimited by `delim`.\n /// Reverts if the variable could not be parsed.\n /// Returns `defaultValue` if the variable was not found.\n function envOr(string calldata name, string calldata delim, bytes[] calldata defaultValue)\n external\n view\n returns (bytes[] memory value);\n\n /// Gets the environment variable `name` and parses it as `int256`.\n /// Reverts if the variable could not be parsed.\n /// Returns `defaultValue` if the variable was not found.\n function envOr(string calldata name, int256 defaultValue) external view returns (int256 value);\n\n /// Gets the environment variable `name` and parses it as `address`.\n /// Reverts if the variable could not be parsed.\n /// Returns `defaultValue` if the variable was not found.\n function envOr(string calldata name, address defaultValue) external view returns (address value);\n\n /// Gets the environment variable `name` and parses it as `bytes32`.\n /// Reverts if the variable could not be parsed.\n /// Returns `defaultValue` if the variable was not found.\n function envOr(string calldata name, bytes32 defaultValue) external view returns (bytes32 value);\n\n /// Gets the environment variable `name` and parses it as `string`.\n /// Reverts if the variable could not be parsed.\n /// Returns `defaultValue` if the variable was not found.\n function envOr(string calldata name, string calldata defaultValue) external view returns (string memory value);\n\n /// Gets the environment variable `name` and parses it as `bytes`.\n /// Reverts if the variable could not be parsed.\n /// Returns `defaultValue` if the variable was not found.\n function envOr(string calldata name, bytes calldata defaultValue) external view returns (bytes memory value);\n\n /// Gets the environment variable `name` and parses it as an array of `bool`, delimited by `delim`.\n /// Reverts if the variable could not be parsed.\n /// Returns `defaultValue` if the variable was not found.\n function envOr(string calldata name, string calldata delim, bool[] calldata defaultValue)\n external\n view\n returns (bool[] memory value);\n\n /// Gets the environment variable `name` and parses it as an array of `uint256`, delimited by `delim`.\n /// Reverts if the variable could not be parsed.\n /// Returns `defaultValue` if the variable was not found.\n function envOr(string calldata name, string calldata delim, uint256[] calldata defaultValue)\n external\n view\n returns (uint256[] memory value);\n\n /// Gets the environment variable `name` and parses it as an array of `int256`, delimited by `delim`.\n /// Reverts if the variable could not be parsed.\n /// Returns `defaultValue` if the variable was not found.\n function envOr(string calldata name, string calldata delim, int256[] calldata defaultValue)\n external\n view\n returns (int256[] memory value);\n\n /// Gets the environment variable `name` and parses it as `string`.\n /// Reverts if the variable was not found or could not be parsed.\n function envString(string calldata name) external view returns (string memory value);\n\n /// Gets the environment variable `name` and parses it as an array of `string`, delimited by `delim`.\n /// Reverts if the variable was not found or could not be parsed.\n function envString(string calldata name, string calldata delim) external view returns (string[] memory value);\n\n /// Gets the environment variable `name` and parses it as `uint256`.\n /// Reverts if the variable was not found or could not be parsed.\n function envUint(string calldata name) external view returns (uint256 value);\n\n /// Gets the environment variable `name` and parses it as an array of `uint256`, delimited by `delim`.\n /// Reverts if the variable was not found or could not be parsed.\n function envUint(string calldata name, string calldata delim) external view returns (uint256[] memory value);\n\n /// Returns true if `forge` command was executed in given context.\n function isContext(ForgeContext context) external view returns (bool result);\n\n /// Sets environment variables.\n function setEnv(string calldata name, string calldata value) external;\n\n // ======== EVM ========\n\n /// Gets all accessed reads and write slot from a `vm.record` session, for a given address.\n function accesses(address target) external returns (bytes32[] memory readSlots, bytes32[] memory writeSlots);\n\n /// Gets the address for a given private key.\n function addr(uint256 privateKey) external pure returns (address keyAddr);\n\n /// Gets all the logs according to specified filter.\n function eth_getLogs(uint256 fromBlock, uint256 toBlock, address target, bytes32[] calldata topics)\n external\n returns (EthGetLogs[] memory logs);\n\n /// Gets the current `block.blobbasefee`.\n /// You should use this instead of `block.blobbasefee` if you use `vm.blobBaseFee`, as `block.blobbasefee` is assumed to be constant across a transaction,\n /// and as a result will get optimized out by the compiler.\n /// See https://github.com/foundry-rs/foundry/issues/6180\n function getBlobBaseFee() external view returns (uint256 blobBaseFee);\n\n /// Gets the current `block.number`.\n /// You should use this instead of `block.number` if you use `vm.roll`, as `block.number` is assumed to be constant across a transaction,\n /// and as a result will get optimized out by the compiler.\n /// See https://github.com/foundry-rs/foundry/issues/6180\n function getBlockNumber() external view returns (uint256 height);\n\n /// Gets the current `block.timestamp`.\n /// You should use this instead of `block.timestamp` if you use `vm.warp`, as `block.timestamp` is assumed to be constant across a transaction,\n /// and as a result will get optimized out by the compiler.\n /// See https://github.com/foundry-rs/foundry/issues/6180\n function getBlockTimestamp() external view returns (uint256 timestamp);\n\n /// Gets the map key and parent of a mapping at a given slot, for a given address.\n function getMappingKeyAndParentOf(address target, bytes32 elementSlot)\n external\n returns (bool found, bytes32 key, bytes32 parent);\n\n /// Gets the number of elements in the mapping at the given slot, for a given address.\n function getMappingLength(address target, bytes32 mappingSlot) external returns (uint256 length);\n\n /// Gets the elements at index idx of the mapping at the given slot, for a given address. The\n /// index must be less than the length of the mapping (i.e. the number of keys in the mapping).\n function getMappingSlotAt(address target, bytes32 mappingSlot, uint256 idx) external returns (bytes32 value);\n\n /// Gets the nonce of an account.\n function getNonce(address account) external view returns (uint64 nonce);\n\n /// Get the nonce of a `Wallet`.\n function getNonce(Wallet calldata wallet) external returns (uint64 nonce);\n\n /// Gets all the recorded logs.\n function getRecordedLogs() external returns (Log[] memory logs);\n\n /// Returns state diffs from current `vm.startStateDiffRecording` session.\n function getStateDiff() external view returns (string memory diff);\n\n /// Returns state diffs from current `vm.startStateDiffRecording` session, in json format.\n function getStateDiffJson() external view returns (string memory diff);\n\n /// Gets the gas used in the last call from the callee perspective.\n function lastCallGas() external view returns (Gas memory gas);\n\n /// Loads a storage slot from an address.\n function load(address target, bytes32 slot) external view returns (bytes32 data);\n\n /// Pauses gas metering (i.e. gas usage is not counted). Noop if already paused.\n function pauseGasMetering() external;\n\n /// Records all storage reads and writes.\n function record() external;\n\n /// Record all the transaction logs.\n function recordLogs() external;\n\n /// Reset gas metering (i.e. gas usage is set to gas limit).\n function resetGasMetering() external;\n\n /// Resumes gas metering (i.e. gas usage is counted again). Noop if already on.\n function resumeGasMetering() external;\n\n /// Performs an Ethereum JSON-RPC request to the current fork URL.\n function rpc(string calldata method, string calldata params) external returns (bytes memory data);\n\n /// Performs an Ethereum JSON-RPC request to the given endpoint.\n function rpc(string calldata urlOrAlias, string calldata method, string calldata params)\n external\n returns (bytes memory data);\n\n /// Records the debug trace during the run.\n function startDebugTraceRecording() external;\n\n /// Starts recording all map SSTOREs for later retrieval.\n function startMappingRecording() external;\n\n /// Record all account accesses as part of CREATE, CALL or SELFDESTRUCT opcodes in order,\n /// along with the context of the calls\n function startStateDiffRecording() external;\n\n /// Stop debug trace recording and returns the recorded debug trace.\n function stopAndReturnDebugTraceRecording() external returns (DebugStep[] memory step);\n\n /// Returns an ordered array of all account accesses from a `vm.startStateDiffRecording` session.\n function stopAndReturnStateDiff() external returns (AccountAccess[] memory accountAccesses);\n\n /// Stops recording all map SSTOREs for later retrieval and clears the recorded data.\n function stopMappingRecording() external;\n\n // ======== Filesystem ========\n\n /// Closes file for reading, resetting the offset and allowing to read it from beginning with readLine.\n /// `path` is relative to the project root.\n function closeFile(string calldata path) external;\n\n /// Copies the contents of one file to another. This function will **overwrite** the contents of `to`.\n /// On success, the total number of bytes copied is returned and it is equal to the length of the `to` file as reported by `metadata`.\n /// Both `from` and `to` are relative to the project root.\n function copyFile(string calldata from, string calldata to) external returns (uint64 copied);\n\n /// Creates a new, empty directory at the provided path.\n /// This cheatcode will revert in the following situations, but is not limited to just these cases:\n /// - User lacks permissions to modify `path`.\n /// - A parent of the given path doesn't exist and `recursive` is false.\n /// - `path` already exists and `recursive` is false.\n /// `path` is relative to the project root.\n function createDir(string calldata path, bool recursive) external;\n\n /// Deploys a contract from an artifact file. Takes in the relative path to the json file or the path to the\n /// artifact in the form of :: where and parts are optional.\n function deployCode(string calldata artifactPath) external returns (address deployedAddress);\n\n /// Deploys a contract from an artifact file. Takes in the relative path to the json file or the path to the\n /// artifact in the form of :: where and parts are optional.\n /// Additionally accepts abi-encoded constructor arguments.\n function deployCode(string calldata artifactPath, bytes calldata constructorArgs)\n external\n returns (address deployedAddress);\n\n /// Returns true if the given path points to an existing entity, else returns false.\n function exists(string calldata path) external view returns (bool result);\n\n /// Performs a foreign function call via the terminal.\n function ffi(string[] calldata commandInput) external returns (bytes memory result);\n\n /// Given a path, query the file system to get information about a file, directory, etc.\n function fsMetadata(string calldata path) external view returns (FsMetadata memory metadata);\n\n /// Gets the artifact path from code (aka. creation code).\n function getArtifactPathByCode(bytes calldata code) external view returns (string memory path);\n\n /// Gets the artifact path from deployed code (aka. runtime code).\n function getArtifactPathByDeployedCode(bytes calldata deployedCode) external view returns (string memory path);\n\n /// Returns the most recent broadcast for the given contract on `chainId` matching `txType`.\n /// For example:\n /// The most recent deployment can be fetched by passing `txType` as `CREATE` or `CREATE2`.\n /// The most recent call can be fetched by passing `txType` as `CALL`.\n function getBroadcast(string calldata contractName, uint64 chainId, BroadcastTxType txType)\n external\n view\n returns (BroadcastTxSummary memory);\n\n /// Returns all broadcasts for the given contract on `chainId` with the specified `txType`.\n /// Sorted such that the most recent broadcast is the first element, and the oldest is the last. i.e descending order of BroadcastTxSummary.blockNumber.\n function getBroadcasts(string calldata contractName, uint64 chainId, BroadcastTxType txType)\n external\n view\n returns (BroadcastTxSummary[] memory);\n\n /// Returns all broadcasts for the given contract on `chainId`.\n /// Sorted such that the most recent broadcast is the first element, and the oldest is the last. i.e descending order of BroadcastTxSummary.blockNumber.\n function getBroadcasts(string calldata contractName, uint64 chainId)\n external\n view\n returns (BroadcastTxSummary[] memory);\n\n /// Gets the creation bytecode from an artifact file. Takes in the relative path to the json file or the path to the\n /// artifact in the form of :: where and parts are optional.\n function getCode(string calldata artifactPath) external view returns (bytes memory creationBytecode);\n\n /// Gets the deployed bytecode from an artifact file. Takes in the relative path to the json file or the path to the\n /// artifact in the form of :: where and parts are optional.\n function getDeployedCode(string calldata artifactPath) external view returns (bytes memory runtimeBytecode);\n\n /// Returns the most recent deployment for the current `chainId`.\n function getDeployment(string calldata contractName) external view returns (address deployedAddress);\n\n /// Returns the most recent deployment for the given contract on `chainId`\n function getDeployment(string calldata contractName, uint64 chainId)\n external\n view\n returns (address deployedAddress);\n\n /// Returns all deployments for the given contract on `chainId`\n /// Sorted in descending order of deployment time i.e descending order of BroadcastTxSummary.blockNumber.\n /// The most recent deployment is the first element, and the oldest is the last.\n function getDeployments(string calldata contractName, uint64 chainId)\n external\n view\n returns (address[] memory deployedAddresses);\n\n /// Returns true if the path exists on disk and is pointing at a directory, else returns false.\n function isDir(string calldata path) external view returns (bool result);\n\n /// Returns true if the path exists on disk and is pointing at a regular file, else returns false.\n function isFile(string calldata path) external view returns (bool result);\n\n /// Get the path of the current project root.\n function projectRoot() external view returns (string memory path);\n\n /// Prompts the user for a string value in the terminal.\n function prompt(string calldata promptText) external returns (string memory input);\n\n /// Prompts the user for an address in the terminal.\n function promptAddress(string calldata promptText) external returns (address);\n\n /// Prompts the user for a hidden string value in the terminal.\n function promptSecret(string calldata promptText) external returns (string memory input);\n\n /// Prompts the user for hidden uint256 in the terminal (usually pk).\n function promptSecretUint(string calldata promptText) external returns (uint256);\n\n /// Prompts the user for uint256 in the terminal.\n function promptUint(string calldata promptText) external returns (uint256);\n\n /// Reads the directory at the given path recursively, up to `maxDepth`.\n /// `maxDepth` defaults to 1, meaning only the direct children of the given directory will be returned.\n /// Follows symbolic links if `followLinks` is true.\n function readDir(string calldata path) external view returns (DirEntry[] memory entries);\n\n /// See `readDir(string)`.\n function readDir(string calldata path, uint64 maxDepth) external view returns (DirEntry[] memory entries);\n\n /// See `readDir(string)`.\n function readDir(string calldata path, uint64 maxDepth, bool followLinks)\n external\n view\n returns (DirEntry[] memory entries);\n\n /// Reads the entire content of file to string. `path` is relative to the project root.\n function readFile(string calldata path) external view returns (string memory data);\n\n /// Reads the entire content of file as binary. `path` is relative to the project root.\n function readFileBinary(string calldata path) external view returns (bytes memory data);\n\n /// Reads next line of file to string.\n function readLine(string calldata path) external view returns (string memory line);\n\n /// Reads a symbolic link, returning the path that the link points to.\n /// This cheatcode will revert in the following situations, but is not limited to just these cases:\n /// - `path` is not a symbolic link.\n /// - `path` does not exist.\n function readLink(string calldata linkPath) external view returns (string memory targetPath);\n\n /// Removes a directory at the provided path.\n /// This cheatcode will revert in the following situations, but is not limited to just these cases:\n /// - `path` doesn't exist.\n /// - `path` isn't a directory.\n /// - User lacks permissions to modify `path`.\n /// - The directory is not empty and `recursive` is false.\n /// `path` is relative to the project root.\n function removeDir(string calldata path, bool recursive) external;\n\n /// Removes a file from the filesystem.\n /// This cheatcode will revert in the following situations, but is not limited to just these cases:\n /// - `path` points to a directory.\n /// - The file doesn't exist.\n /// - The user lacks permissions to remove the file.\n /// `path` is relative to the project root.\n function removeFile(string calldata path) external;\n\n /// Performs a foreign function call via terminal and returns the exit code, stdout, and stderr.\n function tryFfi(string[] calldata commandInput) external returns (FfiResult memory result);\n\n /// Returns the time since unix epoch in milliseconds.\n function unixTime() external view returns (uint256 milliseconds);\n\n /// Writes data to file, creating a file if it does not exist, and entirely replacing its contents if it does.\n /// `path` is relative to the project root.\n function writeFile(string calldata path, string calldata data) external;\n\n /// Writes binary data to a file, creating a file if it does not exist, and entirely replacing its contents if it does.\n /// `path` is relative to the project root.\n function writeFileBinary(string calldata path, bytes calldata data) external;\n\n /// Writes line to file, creating a file if it does not exist.\n /// `path` is relative to the project root.\n function writeLine(string calldata path, string calldata data) external;\n\n // ======== JSON ========\n\n /// Checks if `key` exists in a JSON object.\n function keyExistsJson(string calldata json, string calldata key) external view returns (bool);\n\n /// Parses a string of JSON data at `key` and coerces it to `address`.\n function parseJsonAddress(string calldata json, string calldata key) external pure returns (address);\n\n /// Parses a string of JSON data at `key` and coerces it to `address[]`.\n function parseJsonAddressArray(string calldata json, string calldata key)\n external\n pure\n returns (address[] memory);\n\n /// Parses a string of JSON data at `key` and coerces it to `bool`.\n function parseJsonBool(string calldata json, string calldata key) external pure returns (bool);\n\n /// Parses a string of JSON data at `key` and coerces it to `bool[]`.\n function parseJsonBoolArray(string calldata json, string calldata key) external pure returns (bool[] memory);\n\n /// Parses a string of JSON data at `key` and coerces it to `bytes`.\n function parseJsonBytes(string calldata json, string calldata key) external pure returns (bytes memory);\n\n /// Parses a string of JSON data at `key` and coerces it to `bytes32`.\n function parseJsonBytes32(string calldata json, string calldata key) external pure returns (bytes32);\n\n /// Parses a string of JSON data at `key` and coerces it to `bytes32[]`.\n function parseJsonBytes32Array(string calldata json, string calldata key)\n external\n pure\n returns (bytes32[] memory);\n\n /// Parses a string of JSON data at `key` and coerces it to `bytes[]`.\n function parseJsonBytesArray(string calldata json, string calldata key) external pure returns (bytes[] memory);\n\n /// Parses a string of JSON data at `key` and coerces it to `int256`.\n function parseJsonInt(string calldata json, string calldata key) external pure returns (int256);\n\n /// Parses a string of JSON data at `key` and coerces it to `int256[]`.\n function parseJsonIntArray(string calldata json, string calldata key) external pure returns (int256[] memory);\n\n /// Returns an array of all the keys in a JSON object.\n function parseJsonKeys(string calldata json, string calldata key) external pure returns (string[] memory keys);\n\n /// Parses a string of JSON data at `key` and coerces it to `string`.\n function parseJsonString(string calldata json, string calldata key) external pure returns (string memory);\n\n /// Parses a string of JSON data at `key` and coerces it to `string[]`.\n function parseJsonStringArray(string calldata json, string calldata key) external pure returns (string[] memory);\n\n /// Parses a string of JSON data at `key` and coerces it to type array corresponding to `typeDescription`.\n function parseJsonTypeArray(string calldata json, string calldata key, string calldata typeDescription)\n external\n pure\n returns (bytes memory);\n\n /// Parses a string of JSON data and coerces it to type corresponding to `typeDescription`.\n function parseJsonType(string calldata json, string calldata typeDescription)\n external\n pure\n returns (bytes memory);\n\n /// Parses a string of JSON data at `key` and coerces it to type corresponding to `typeDescription`.\n function parseJsonType(string calldata json, string calldata key, string calldata typeDescription)\n external\n pure\n returns (bytes memory);\n\n /// Parses a string of JSON data at `key` and coerces it to `uint256`.\n function parseJsonUint(string calldata json, string calldata key) external pure returns (uint256);\n\n /// Parses a string of JSON data at `key` and coerces it to `uint256[]`.\n function parseJsonUintArray(string calldata json, string calldata key) external pure returns (uint256[] memory);\n\n /// ABI-encodes a JSON object.\n function parseJson(string calldata json) external pure returns (bytes memory abiEncodedData);\n\n /// ABI-encodes a JSON object at `key`.\n function parseJson(string calldata json, string calldata key) external pure returns (bytes memory abiEncodedData);\n\n /// See `serializeJson`.\n function serializeAddress(string calldata objectKey, string calldata valueKey, address value)\n external\n returns (string memory json);\n\n /// See `serializeJson`.\n function serializeAddress(string calldata objectKey, string calldata valueKey, address[] calldata values)\n external\n returns (string memory json);\n\n /// See `serializeJson`.\n function serializeBool(string calldata objectKey, string calldata valueKey, bool value)\n external\n returns (string memory json);\n\n /// See `serializeJson`.\n function serializeBool(string calldata objectKey, string calldata valueKey, bool[] calldata values)\n external\n returns (string memory json);\n\n /// See `serializeJson`.\n function serializeBytes32(string calldata objectKey, string calldata valueKey, bytes32 value)\n external\n returns (string memory json);\n\n /// See `serializeJson`.\n function serializeBytes32(string calldata objectKey, string calldata valueKey, bytes32[] calldata values)\n external\n returns (string memory json);\n\n /// See `serializeJson`.\n function serializeBytes(string calldata objectKey, string calldata valueKey, bytes calldata value)\n external\n returns (string memory json);\n\n /// See `serializeJson`.\n function serializeBytes(string calldata objectKey, string calldata valueKey, bytes[] calldata values)\n external\n returns (string memory json);\n\n /// See `serializeJson`.\n function serializeInt(string calldata objectKey, string calldata valueKey, int256 value)\n external\n returns (string memory json);\n\n /// See `serializeJson`.\n function serializeInt(string calldata objectKey, string calldata valueKey, int256[] calldata values)\n external\n returns (string memory json);\n\n /// Serializes a key and value to a JSON object stored in-memory that can be later written to a file.\n /// Returns the stringified version of the specific JSON file up to that moment.\n function serializeJson(string calldata objectKey, string calldata value) external returns (string memory json);\n\n /// See `serializeJson`.\n function serializeJsonType(string calldata typeDescription, bytes calldata value)\n external\n pure\n returns (string memory json);\n\n /// See `serializeJson`.\n function serializeJsonType(\n string calldata objectKey,\n string calldata valueKey,\n string calldata typeDescription,\n bytes calldata value\n ) external returns (string memory json);\n\n /// See `serializeJson`.\n function serializeString(string calldata objectKey, string calldata valueKey, string calldata value)\n external\n returns (string memory json);\n\n /// See `serializeJson`.\n function serializeString(string calldata objectKey, string calldata valueKey, string[] calldata values)\n external\n returns (string memory json);\n\n /// See `serializeJson`.\n function serializeUintToHex(string calldata objectKey, string calldata valueKey, uint256 value)\n external\n returns (string memory json);\n\n /// See `serializeJson`.\n function serializeUint(string calldata objectKey, string calldata valueKey, uint256 value)\n external\n returns (string memory json);\n\n /// See `serializeJson`.\n function serializeUint(string calldata objectKey, string calldata valueKey, uint256[] calldata values)\n external\n returns (string memory json);\n\n /// Write a serialized JSON object to a file. If the file exists, it will be overwritten.\n function writeJson(string calldata json, string calldata path) external;\n\n /// Write a serialized JSON object to an **existing** JSON file, replacing a value with key = \n /// This is useful to replace a specific value of a JSON file, without having to parse the entire thing.\n function writeJson(string calldata json, string calldata path, string calldata valueKey) external;\n\n /// Checks if `key` exists in a JSON object\n /// `keyExists` is being deprecated in favor of `keyExistsJson`. It will be removed in future versions.\n function keyExists(string calldata json, string calldata key) external view returns (bool);\n\n // ======== Scripting ========\n\n /// Designate the next call as an EIP-7702 transaction\n function attachDelegation(SignedDelegation calldata signedDelegation) external;\n\n /// Takes a signed transaction and broadcasts it to the network.\n function broadcastRawTransaction(bytes calldata data) external;\n\n /// Has the next call (at this call depth only) create transactions that can later be signed and sent onchain.\n /// Broadcasting address is determined by checking the following in order:\n /// 1. If `--sender` argument was provided, that address is used.\n /// 2. If exactly one signer (e.g. private key, hw wallet, keystore) is set when `forge broadcast` is invoked, that signer is used.\n /// 3. Otherwise, default foundry sender (1804c8AB1F12E6bbf3894d4083f33e07309d1f38) is used.\n function broadcast() external;\n\n /// Has the next call (at this call depth only) create a transaction with the address provided\n /// as the sender that can later be signed and sent onchain.\n function broadcast(address signer) external;\n\n /// Has the next call (at this call depth only) create a transaction with the private key\n /// provided as the sender that can later be signed and sent onchain.\n function broadcast(uint256 privateKey) external;\n\n /// Returns addresses of available unlocked wallets in the script environment.\n function getWallets() external returns (address[] memory wallets);\n\n /// Sign an EIP-7702 authorization and designate the next call as an EIP-7702 transaction\n function signAndAttachDelegation(address implementation, uint256 privateKey)\n external\n returns (SignedDelegation memory signedDelegation);\n\n /// Sign an EIP-7702 authorization for delegation\n function signDelegation(address implementation, uint256 privateKey)\n external\n returns (SignedDelegation memory signedDelegation);\n\n /// Has all subsequent calls (at this call depth only) create transactions that can later be signed and sent onchain.\n /// Broadcasting address is determined by checking the following in order:\n /// 1. If `--sender` argument was provided, that address is used.\n /// 2. If exactly one signer (e.g. private key, hw wallet, keystore) is set when `forge broadcast` is invoked, that signer is used.\n /// 3. Otherwise, default foundry sender (1804c8AB1F12E6bbf3894d4083f33e07309d1f38) is used.\n function startBroadcast() external;\n\n /// Has all subsequent calls (at this call depth only) create transactions with the address\n /// provided that can later be signed and sent onchain.\n function startBroadcast(address signer) external;\n\n /// Has all subsequent calls (at this call depth only) create transactions with the private key\n /// provided that can later be signed and sent onchain.\n function startBroadcast(uint256 privateKey) external;\n\n /// Stops collecting onchain transactions.\n function stopBroadcast() external;\n\n // ======== String ========\n\n /// Returns true if `search` is found in `subject`, false otherwise.\n function contains(string calldata subject, string calldata search) external returns (bool result);\n\n /// Returns the index of the first occurrence of a `key` in an `input` string.\n /// Returns `NOT_FOUND` (i.e. `type(uint256).max`) if the `key` is not found.\n /// Returns 0 in case of an empty `key`.\n function indexOf(string calldata input, string calldata key) external pure returns (uint256);\n\n /// Parses the given `string` into an `address`.\n function parseAddress(string calldata stringifiedValue) external pure returns (address parsedValue);\n\n /// Parses the given `string` into a `bool`.\n function parseBool(string calldata stringifiedValue) external pure returns (bool parsedValue);\n\n /// Parses the given `string` into `bytes`.\n function parseBytes(string calldata stringifiedValue) external pure returns (bytes memory parsedValue);\n\n /// Parses the given `string` into a `bytes32`.\n function parseBytes32(string calldata stringifiedValue) external pure returns (bytes32 parsedValue);\n\n /// Parses the given `string` into a `int256`.\n function parseInt(string calldata stringifiedValue) external pure returns (int256 parsedValue);\n\n /// Parses the given `string` into a `uint256`.\n function parseUint(string calldata stringifiedValue) external pure returns (uint256 parsedValue);\n\n /// Replaces occurrences of `from` in the given `string` with `to`.\n function replace(string calldata input, string calldata from, string calldata to)\n external\n pure\n returns (string memory output);\n\n /// Splits the given `string` into an array of strings divided by the `delimiter`.\n function split(string calldata input, string calldata delimiter) external pure returns (string[] memory outputs);\n\n /// Converts the given `string` value to Lowercase.\n function toLowercase(string calldata input) external pure returns (string memory output);\n\n /// Converts the given value to a `string`.\n function toString(address value) external pure returns (string memory stringifiedValue);\n\n /// Converts the given value to a `string`.\n function toString(bytes calldata value) external pure returns (string memory stringifiedValue);\n\n /// Converts the given value to a `string`.\n function toString(bytes32 value) external pure returns (string memory stringifiedValue);\n\n /// Converts the given value to a `string`.\n function toString(bool value) external pure returns (string memory stringifiedValue);\n\n /// Converts the given value to a `string`.\n function toString(uint256 value) external pure returns (string memory stringifiedValue);\n\n /// Converts the given value to a `string`.\n function toString(int256 value) external pure returns (string memory stringifiedValue);\n\n /// Converts the given `string` value to Uppercase.\n function toUppercase(string calldata input) external pure returns (string memory output);\n\n /// Trims leading and trailing whitespace from the given `string` value.\n function trim(string calldata input) external pure returns (string memory output);\n\n // ======== Testing ========\n\n /// Compares two `uint256` values. Expects difference to be less than or equal to `maxDelta`.\n /// Formats values with decimals in failure message.\n function assertApproxEqAbsDecimal(uint256 left, uint256 right, uint256 maxDelta, uint256 decimals) external pure;\n\n /// Compares two `uint256` values. Expects difference to be less than or equal to `maxDelta`.\n /// Formats values with decimals in failure message. Includes error message into revert string on failure.\n function assertApproxEqAbsDecimal(\n uint256 left,\n uint256 right,\n uint256 maxDelta,\n uint256 decimals,\n string calldata error\n ) external pure;\n\n /// Compares two `int256` values. Expects difference to be less than or equal to `maxDelta`.\n /// Formats values with decimals in failure message.\n function assertApproxEqAbsDecimal(int256 left, int256 right, uint256 maxDelta, uint256 decimals) external pure;\n\n /// Compares two `int256` values. Expects difference to be less than or equal to `maxDelta`.\n /// Formats values with decimals in failure message. Includes error message into revert string on failure.\n function assertApproxEqAbsDecimal(\n int256 left,\n int256 right,\n uint256 maxDelta,\n uint256 decimals,\n string calldata error\n ) external pure;\n\n /// Compares two `uint256` values. Expects difference to be less than or equal to `maxDelta`.\n function assertApproxEqAbs(uint256 left, uint256 right, uint256 maxDelta) external pure;\n\n /// Compares two `uint256` values. Expects difference to be less than or equal to `maxDelta`.\n /// Includes error message into revert string on failure.\n function assertApproxEqAbs(uint256 left, uint256 right, uint256 maxDelta, string calldata error) external pure;\n\n /// Compares two `int256` values. Expects difference to be less than or equal to `maxDelta`.\n function assertApproxEqAbs(int256 left, int256 right, uint256 maxDelta) external pure;\n\n /// Compares two `int256` values. Expects difference to be less than or equal to `maxDelta`.\n /// Includes error message into revert string on failure.\n function assertApproxEqAbs(int256 left, int256 right, uint256 maxDelta, string calldata error) external pure;\n\n /// Compares two `uint256` values. Expects relative difference in percents to be less than or equal to `maxPercentDelta`.\n /// `maxPercentDelta` is an 18 decimal fixed point number, where 1e18 == 100%\n /// Formats values with decimals in failure message.\n function assertApproxEqRelDecimal(uint256 left, uint256 right, uint256 maxPercentDelta, uint256 decimals)\n external\n pure;\n\n /// Compares two `uint256` values. Expects relative difference in percents to be less than or equal to `maxPercentDelta`.\n /// `maxPercentDelta` is an 18 decimal fixed point number, where 1e18 == 100%\n /// Formats values with decimals in failure message. Includes error message into revert string on failure.\n function assertApproxEqRelDecimal(\n uint256 left,\n uint256 right,\n uint256 maxPercentDelta,\n uint256 decimals,\n string calldata error\n ) external pure;\n\n /// Compares two `int256` values. Expects relative difference in percents to be less than or equal to `maxPercentDelta`.\n /// `maxPercentDelta` is an 18 decimal fixed point number, where 1e18 == 100%\n /// Formats values with decimals in failure message.\n function assertApproxEqRelDecimal(int256 left, int256 right, uint256 maxPercentDelta, uint256 decimals)\n external\n pure;\n\n /// Compares two `int256` values. Expects relative difference in percents to be less than or equal to `maxPercentDelta`.\n /// `maxPercentDelta` is an 18 decimal fixed point number, where 1e18 == 100%\n /// Formats values with decimals in failure message. Includes error message into revert string on failure.\n function assertApproxEqRelDecimal(\n int256 left,\n int256 right,\n uint256 maxPercentDelta,\n uint256 decimals,\n string calldata error\n ) external pure;\n\n /// Compares two `uint256` values. Expects relative difference in percents to be less than or equal to `maxPercentDelta`.\n /// `maxPercentDelta` is an 18 decimal fixed point number, where 1e18 == 100%\n function assertApproxEqRel(uint256 left, uint256 right, uint256 maxPercentDelta) external pure;\n\n /// Compares two `uint256` values. Expects relative difference in percents to be less than or equal to `maxPercentDelta`.\n /// `maxPercentDelta` is an 18 decimal fixed point number, where 1e18 == 100%\n /// Includes error message into revert string on failure.\n function assertApproxEqRel(uint256 left, uint256 right, uint256 maxPercentDelta, string calldata error)\n external\n pure;\n\n /// Compares two `int256` values. Expects relative difference in percents to be less than or equal to `maxPercentDelta`.\n /// `maxPercentDelta` is an 18 decimal fixed point number, where 1e18 == 100%\n function assertApproxEqRel(int256 left, int256 right, uint256 maxPercentDelta) external pure;\n\n /// Compares two `int256` values. Expects relative difference in percents to be less than or equal to `maxPercentDelta`.\n /// `maxPercentDelta` is an 18 decimal fixed point number, where 1e18 == 100%\n /// Includes error message into revert string on failure.\n function assertApproxEqRel(int256 left, int256 right, uint256 maxPercentDelta, string calldata error)\n external\n pure;\n\n /// Asserts that two `uint256` values are equal, formatting them with decimals in failure message.\n function assertEqDecimal(uint256 left, uint256 right, uint256 decimals) external pure;\n\n /// Asserts that two `uint256` values are equal, formatting them with decimals in failure message.\n /// Includes error message into revert string on failure.\n function assertEqDecimal(uint256 left, uint256 right, uint256 decimals, string calldata error) external pure;\n\n /// Asserts that two `int256` values are equal, formatting them with decimals in failure message.\n function assertEqDecimal(int256 left, int256 right, uint256 decimals) external pure;\n\n /// Asserts that two `int256` values are equal, formatting them with decimals in failure message.\n /// Includes error message into revert string on failure.\n function assertEqDecimal(int256 left, int256 right, uint256 decimals, string calldata error) external pure;\n\n /// Asserts that two `bool` values are equal.\n function assertEq(bool left, bool right) external pure;\n\n /// Asserts that two `bool` values are equal and includes error message into revert string on failure.\n function assertEq(bool left, bool right, string calldata error) external pure;\n\n /// Asserts that two `string` values are equal.\n function assertEq(string calldata left, string calldata right) external pure;\n\n /// Asserts that two `string` values are equal and includes error message into revert string on failure.\n function assertEq(string calldata left, string calldata right, string calldata error) external pure;\n\n /// Asserts that two `bytes` values are equal.\n function assertEq(bytes calldata left, bytes calldata right) external pure;\n\n /// Asserts that two `bytes` values are equal and includes error message into revert string on failure.\n function assertEq(bytes calldata left, bytes calldata right, string calldata error) external pure;\n\n /// Asserts that two arrays of `bool` values are equal.\n function assertEq(bool[] calldata left, bool[] calldata right) external pure;\n\n /// Asserts that two arrays of `bool` values are equal and includes error message into revert string on failure.\n function assertEq(bool[] calldata left, bool[] calldata right, string calldata error) external pure;\n\n /// Asserts that two arrays of `uint256 values are equal.\n function assertEq(uint256[] calldata left, uint256[] calldata right) external pure;\n\n /// Asserts that two arrays of `uint256` values are equal and includes error message into revert string on failure.\n function assertEq(uint256[] calldata left, uint256[] calldata right, string calldata error) external pure;\n\n /// Asserts that two arrays of `int256` values are equal.\n function assertEq(int256[] calldata left, int256[] calldata right) external pure;\n\n /// Asserts that two arrays of `int256` values are equal and includes error message into revert string on failure.\n function assertEq(int256[] calldata left, int256[] calldata right, string calldata error) external pure;\n\n /// Asserts that two `uint256` values are equal.\n function assertEq(uint256 left, uint256 right) external pure;\n\n /// Asserts that two arrays of `address` values are equal.\n function assertEq(address[] calldata left, address[] calldata right) external pure;\n\n /// Asserts that two arrays of `address` values are equal and includes error message into revert string on failure.\n function assertEq(address[] calldata left, address[] calldata right, string calldata error) external pure;\n\n /// Asserts that two arrays of `bytes32` values are equal.\n function assertEq(bytes32[] calldata left, bytes32[] calldata right) external pure;\n\n /// Asserts that two arrays of `bytes32` values are equal and includes error message into revert string on failure.\n function assertEq(bytes32[] calldata left, bytes32[] calldata right, string calldata error) external pure;\n\n /// Asserts that two arrays of `string` values are equal.\n function assertEq(string[] calldata left, string[] calldata right) external pure;\n\n /// Asserts that two arrays of `string` values are equal and includes error message into revert string on failure.\n function assertEq(string[] calldata left, string[] calldata right, string calldata error) external pure;\n\n /// Asserts that two arrays of `bytes` values are equal.\n function assertEq(bytes[] calldata left, bytes[] calldata right) external pure;\n\n /// Asserts that two arrays of `bytes` values are equal and includes error message into revert string on failure.\n function assertEq(bytes[] calldata left, bytes[] calldata right, string calldata error) external pure;\n\n /// Asserts that two `uint256` values are equal and includes error message into revert string on failure.\n function assertEq(uint256 left, uint256 right, string calldata error) external pure;\n\n /// Asserts that two `int256` values are equal.\n function assertEq(int256 left, int256 right) external pure;\n\n /// Asserts that two `int256` values are equal and includes error message into revert string on failure.\n function assertEq(int256 left, int256 right, string calldata error) external pure;\n\n /// Asserts that two `address` values are equal.\n function assertEq(address left, address right) external pure;\n\n /// Asserts that two `address` values are equal and includes error message into revert string on failure.\n function assertEq(address left, address right, string calldata error) external pure;\n\n /// Asserts that two `bytes32` values are equal.\n function assertEq(bytes32 left, bytes32 right) external pure;\n\n /// Asserts that two `bytes32` values are equal and includes error message into revert string on failure.\n function assertEq(bytes32 left, bytes32 right, string calldata error) external pure;\n\n /// Asserts that the given condition is false.\n function assertFalse(bool condition) external pure;\n\n /// Asserts that the given condition is false and includes error message into revert string on failure.\n function assertFalse(bool condition, string calldata error) external pure;\n\n /// Compares two `uint256` values. Expects first value to be greater than or equal to second.\n /// Formats values with decimals in failure message.\n function assertGeDecimal(uint256 left, uint256 right, uint256 decimals) external pure;\n\n /// Compares two `uint256` values. Expects first value to be greater than or equal to second.\n /// Formats values with decimals in failure message. Includes error message into revert string on failure.\n function assertGeDecimal(uint256 left, uint256 right, uint256 decimals, string calldata error) external pure;\n\n /// Compares two `int256` values. Expects first value to be greater than or equal to second.\n /// Formats values with decimals in failure message.\n function assertGeDecimal(int256 left, int256 right, uint256 decimals) external pure;\n\n /// Compares two `int256` values. Expects first value to be greater than or equal to second.\n /// Formats values with decimals in failure message. Includes error message into revert string on failure.\n function assertGeDecimal(int256 left, int256 right, uint256 decimals, string calldata error) external pure;\n\n /// Compares two `uint256` values. Expects first value to be greater than or equal to second.\n function assertGe(uint256 left, uint256 right) external pure;\n\n /// Compares two `uint256` values. Expects first value to be greater than or equal to second.\n /// Includes error message into revert string on failure.\n function assertGe(uint256 left, uint256 right, string calldata error) external pure;\n\n /// Compares two `int256` values. Expects first value to be greater than or equal to second.\n function assertGe(int256 left, int256 right) external pure;\n\n /// Compares two `int256` values. Expects first value to be greater than or equal to second.\n /// Includes error message into revert string on failure.\n function assertGe(int256 left, int256 right, string calldata error) external pure;\n\n /// Compares two `uint256` values. Expects first value to be greater than second.\n /// Formats values with decimals in failure message.\n function assertGtDecimal(uint256 left, uint256 right, uint256 decimals) external pure;\n\n /// Compares two `uint256` values. Expects first value to be greater than second.\n /// Formats values with decimals in failure message. Includes error message into revert string on failure.\n function assertGtDecimal(uint256 left, uint256 right, uint256 decimals, string calldata error) external pure;\n\n /// Compares two `int256` values. Expects first value to be greater than second.\n /// Formats values with decimals in failure message.\n function assertGtDecimal(int256 left, int256 right, uint256 decimals) external pure;\n\n /// Compares two `int256` values. Expects first value to be greater than second.\n /// Formats values with decimals in failure message. Includes error message into revert string on failure.\n function assertGtDecimal(int256 left, int256 right, uint256 decimals, string calldata error) external pure;\n\n /// Compares two `uint256` values. Expects first value to be greater than second.\n function assertGt(uint256 left, uint256 right) external pure;\n\n /// Compares two `uint256` values. Expects first value to be greater than second.\n /// Includes error message into revert string on failure.\n function assertGt(uint256 left, uint256 right, string calldata error) external pure;\n\n /// Compares two `int256` values. Expects first value to be greater than second.\n function assertGt(int256 left, int256 right) external pure;\n\n /// Compares two `int256` values. Expects first value to be greater than second.\n /// Includes error message into revert string on failure.\n function assertGt(int256 left, int256 right, string calldata error) external pure;\n\n /// Compares two `uint256` values. Expects first value to be less than or equal to second.\n /// Formats values with decimals in failure message.\n function assertLeDecimal(uint256 left, uint256 right, uint256 decimals) external pure;\n\n /// Compares two `uint256` values. Expects first value to be less than or equal to second.\n /// Formats values with decimals in failure message. Includes error message into revert string on failure.\n function assertLeDecimal(uint256 left, uint256 right, uint256 decimals, string calldata error) external pure;\n\n /// Compares two `int256` values. Expects first value to be less than or equal to second.\n /// Formats values with decimals in failure message.\n function assertLeDecimal(int256 left, int256 right, uint256 decimals) external pure;\n\n /// Compares two `int256` values. Expects first value to be less than or equal to second.\n /// Formats values with decimals in failure message. Includes error message into revert string on failure.\n function assertLeDecimal(int256 left, int256 right, uint256 decimals, string calldata error) external pure;\n\n /// Compares two `uint256` values. Expects first value to be less than or equal to second.\n function assertLe(uint256 left, uint256 right) external pure;\n\n /// Compares two `uint256` values. Expects first value to be less than or equal to second.\n /// Includes error message into revert string on failure.\n function assertLe(uint256 left, uint256 right, string calldata error) external pure;\n\n /// Compares two `int256` values. Expects first value to be less than or equal to second.\n function assertLe(int256 left, int256 right) external pure;\n\n /// Compares two `int256` values. Expects first value to be less than or equal to second.\n /// Includes error message into revert string on failure.\n function assertLe(int256 left, int256 right, string calldata error) external pure;\n\n /// Compares two `uint256` values. Expects first value to be less than second.\n /// Formats values with decimals in failure message.\n function assertLtDecimal(uint256 left, uint256 right, uint256 decimals) external pure;\n\n /// Compares two `uint256` values. Expects first value to be less than second.\n /// Formats values with decimals in failure message. Includes error message into revert string on failure.\n function assertLtDecimal(uint256 left, uint256 right, uint256 decimals, string calldata error) external pure;\n\n /// Compares two `int256` values. Expects first value to be less than second.\n /// Formats values with decimals in failure message.\n function assertLtDecimal(int256 left, int256 right, uint256 decimals) external pure;\n\n /// Compares two `int256` values. Expects first value to be less than second.\n /// Formats values with decimals in failure message. Includes error message into revert string on failure.\n function assertLtDecimal(int256 left, int256 right, uint256 decimals, string calldata error) external pure;\n\n /// Compares two `uint256` values. Expects first value to be less than second.\n function assertLt(uint256 left, uint256 right) external pure;\n\n /// Compares two `uint256` values. Expects first value to be less than second.\n /// Includes error message into revert string on failure.\n function assertLt(uint256 left, uint256 right, string calldata error) external pure;\n\n /// Compares two `int256` values. Expects first value to be less than second.\n function assertLt(int256 left, int256 right) external pure;\n\n /// Compares two `int256` values. Expects first value to be less than second.\n /// Includes error message into revert string on failure.\n function assertLt(int256 left, int256 right, string calldata error) external pure;\n\n /// Asserts that two `uint256` values are not equal, formatting them with decimals in failure message.\n function assertNotEqDecimal(uint256 left, uint256 right, uint256 decimals) external pure;\n\n /// Asserts that two `uint256` values are not equal, formatting them with decimals in failure message.\n /// Includes error message into revert string on failure.\n function assertNotEqDecimal(uint256 left, uint256 right, uint256 decimals, string calldata error) external pure;\n\n /// Asserts that two `int256` values are not equal, formatting them with decimals in failure message.\n function assertNotEqDecimal(int256 left, int256 right, uint256 decimals) external pure;\n\n /// Asserts that two `int256` values are not equal, formatting them with decimals in failure message.\n /// Includes error message into revert string on failure.\n function assertNotEqDecimal(int256 left, int256 right, uint256 decimals, string calldata error) external pure;\n\n /// Asserts that two `bool` values are not equal.\n function assertNotEq(bool left, bool right) external pure;\n\n /// Asserts that two `bool` values are not equal and includes error message into revert string on failure.\n function assertNotEq(bool left, bool right, string calldata error) external pure;\n\n /// Asserts that two `string` values are not equal.\n function assertNotEq(string calldata left, string calldata right) external pure;\n\n /// Asserts that two `string` values are not equal and includes error message into revert string on failure.\n function assertNotEq(string calldata left, string calldata right, string calldata error) external pure;\n\n /// Asserts that two `bytes` values are not equal.\n function assertNotEq(bytes calldata left, bytes calldata right) external pure;\n\n /// Asserts that two `bytes` values are not equal and includes error message into revert string on failure.\n function assertNotEq(bytes calldata left, bytes calldata right, string calldata error) external pure;\n\n /// Asserts that two arrays of `bool` values are not equal.\n function assertNotEq(bool[] calldata left, bool[] calldata right) external pure;\n\n /// Asserts that two arrays of `bool` values are not equal and includes error message into revert string on failure.\n function assertNotEq(bool[] calldata left, bool[] calldata right, string calldata error) external pure;\n\n /// Asserts that two arrays of `uint256` values are not equal.\n function assertNotEq(uint256[] calldata left, uint256[] calldata right) external pure;\n\n /// Asserts that two arrays of `uint256` values are not equal and includes error message into revert string on failure.\n function assertNotEq(uint256[] calldata left, uint256[] calldata right, string calldata error) external pure;\n\n /// Asserts that two arrays of `int256` values are not equal.\n function assertNotEq(int256[] calldata left, int256[] calldata right) external pure;\n\n /// Asserts that two arrays of `int256` values are not equal and includes error message into revert string on failure.\n function assertNotEq(int256[] calldata left, int256[] calldata right, string calldata error) external pure;\n\n /// Asserts that two `uint256` values are not equal.\n function assertNotEq(uint256 left, uint256 right) external pure;\n\n /// Asserts that two arrays of `address` values are not equal.\n function assertNotEq(address[] calldata left, address[] calldata right) external pure;\n\n /// Asserts that two arrays of `address` values are not equal and includes error message into revert string on failure.\n function assertNotEq(address[] calldata left, address[] calldata right, string calldata error) external pure;\n\n /// Asserts that two arrays of `bytes32` values are not equal.\n function assertNotEq(bytes32[] calldata left, bytes32[] calldata right) external pure;\n\n /// Asserts that two arrays of `bytes32` values are not equal and includes error message into revert string on failure.\n function assertNotEq(bytes32[] calldata left, bytes32[] calldata right, string calldata error) external pure;\n\n /// Asserts that two arrays of `string` values are not equal.\n function assertNotEq(string[] calldata left, string[] calldata right) external pure;\n\n /// Asserts that two arrays of `string` values are not equal and includes error message into revert string on failure.\n function assertNotEq(string[] calldata left, string[] calldata right, string calldata error) external pure;\n\n /// Asserts that two arrays of `bytes` values are not equal.\n function assertNotEq(bytes[] calldata left, bytes[] calldata right) external pure;\n\n /// Asserts that two arrays of `bytes` values are not equal and includes error message into revert string on failure.\n function assertNotEq(bytes[] calldata left, bytes[] calldata right, string calldata error) external pure;\n\n /// Asserts that two `uint256` values are not equal and includes error message into revert string on failure.\n function assertNotEq(uint256 left, uint256 right, string calldata error) external pure;\n\n /// Asserts that two `int256` values are not equal.\n function assertNotEq(int256 left, int256 right) external pure;\n\n /// Asserts that two `int256` values are not equal and includes error message into revert string on failure.\n function assertNotEq(int256 left, int256 right, string calldata error) external pure;\n\n /// Asserts that two `address` values are not equal.\n function assertNotEq(address left, address right) external pure;\n\n /// Asserts that two `address` values are not equal and includes error message into revert string on failure.\n function assertNotEq(address left, address right, string calldata error) external pure;\n\n /// Asserts that two `bytes32` values are not equal.\n function assertNotEq(bytes32 left, bytes32 right) external pure;\n\n /// Asserts that two `bytes32` values are not equal and includes error message into revert string on failure.\n function assertNotEq(bytes32 left, bytes32 right, string calldata error) external pure;\n\n /// Asserts that the given condition is true.\n function assertTrue(bool condition) external pure;\n\n /// Asserts that the given condition is true and includes error message into revert string on failure.\n function assertTrue(bool condition, string calldata error) external pure;\n\n /// If the condition is false, discard this run's fuzz inputs and generate new ones.\n function assume(bool condition) external pure;\n\n /// Discard this run's fuzz inputs and generate new ones if next call reverted.\n function assumeNoRevert() external pure;\n\n /// Discard this run's fuzz inputs and generate new ones if next call reverts with the potential revert parameters.\n function assumeNoRevert(PotentialRevert calldata potentialRevert) external pure;\n\n /// Discard this run's fuzz inputs and generate new ones if next call reverts with the any of the potential revert parameters.\n function assumeNoRevert(PotentialRevert[] calldata potentialReverts) external pure;\n\n /// Writes a breakpoint to jump to in the debugger.\n function breakpoint(string calldata char) external pure;\n\n /// Writes a conditional breakpoint to jump to in the debugger.\n function breakpoint(string calldata char, bool value) external pure;\n\n /// Returns true if the current Foundry version is greater than or equal to the given version.\n /// The given version string must be in the format `major.minor.patch`.\n /// This is equivalent to `foundryVersionCmp(version) >= 0`.\n function foundryVersionAtLeast(string calldata version) external view returns (bool);\n\n /// Compares the current Foundry version with the given version string.\n /// The given version string must be in the format `major.minor.patch`.\n /// Returns:\n /// -1 if current Foundry version is less than the given version\n /// 0 if current Foundry version equals the given version\n /// 1 if current Foundry version is greater than the given version\n /// This result can then be used with a comparison operator against `0`.\n /// For example, to check if the current Foundry version is greater than or equal to `1.0.0`:\n /// `if (foundryVersionCmp(\"1.0.0\") >= 0) { ... }`\n function foundryVersionCmp(string calldata version) external view returns (int256);\n\n /// Returns the Foundry version.\n /// Format: -+..\n /// Sample output: 0.3.0-nightly+3cb96bde9b.1737036656.debug\n /// Note: Build timestamps may vary slightly across platforms due to separate CI jobs.\n /// For reliable version comparisons, use UNIX format (e.g., >= 1700000000)\n /// to compare timestamps while ignoring minor time differences.\n function getFoundryVersion() external view returns (string memory version);\n\n /// Returns the RPC url for the given alias.\n function rpcUrl(string calldata rpcAlias) external view returns (string memory json);\n\n /// Returns all rpc urls and their aliases as structs.\n function rpcUrlStructs() external view returns (Rpc[] memory urls);\n\n /// Returns all rpc urls and their aliases `[alias, url][]`.\n function rpcUrls() external view returns (string[2][] memory urls);\n\n /// Suspends execution of the main thread for `duration` milliseconds.\n function sleep(uint256 duration) external;\n\n // ======== Toml ========\n\n /// Checks if `key` exists in a TOML table.\n function keyExistsToml(string calldata toml, string calldata key) external view returns (bool);\n\n /// Parses a string of TOML data at `key` and coerces it to `address`.\n function parseTomlAddress(string calldata toml, string calldata key) external pure returns (address);\n\n /// Parses a string of TOML data at `key` and coerces it to `address[]`.\n function parseTomlAddressArray(string calldata toml, string calldata key)\n external\n pure\n returns (address[] memory);\n\n /// Parses a string of TOML data at `key` and coerces it to `bool`.\n function parseTomlBool(string calldata toml, string calldata key) external pure returns (bool);\n\n /// Parses a string of TOML data at `key` and coerces it to `bool[]`.\n function parseTomlBoolArray(string calldata toml, string calldata key) external pure returns (bool[] memory);\n\n /// Parses a string of TOML data at `key` and coerces it to `bytes`.\n function parseTomlBytes(string calldata toml, string calldata key) external pure returns (bytes memory);\n\n /// Parses a string of TOML data at `key` and coerces it to `bytes32`.\n function parseTomlBytes32(string calldata toml, string calldata key) external pure returns (bytes32);\n\n /// Parses a string of TOML data at `key` and coerces it to `bytes32[]`.\n function parseTomlBytes32Array(string calldata toml, string calldata key)\n external\n pure\n returns (bytes32[] memory);\n\n /// Parses a string of TOML data at `key` and coerces it to `bytes[]`.\n function parseTomlBytesArray(string calldata toml, string calldata key) external pure returns (bytes[] memory);\n\n /// Parses a string of TOML data at `key` and coerces it to `int256`.\n function parseTomlInt(string calldata toml, string calldata key) external pure returns (int256);\n\n /// Parses a string of TOML data at `key` and coerces it to `int256[]`.\n function parseTomlIntArray(string calldata toml, string calldata key) external pure returns (int256[] memory);\n\n /// Returns an array of all the keys in a TOML table.\n function parseTomlKeys(string calldata toml, string calldata key) external pure returns (string[] memory keys);\n\n /// Parses a string of TOML data at `key` and coerces it to `string`.\n function parseTomlString(string calldata toml, string calldata key) external pure returns (string memory);\n\n /// Parses a string of TOML data at `key` and coerces it to `string[]`.\n function parseTomlStringArray(string calldata toml, string calldata key) external pure returns (string[] memory);\n\n /// Parses a string of TOML data at `key` and coerces it to type array corresponding to `typeDescription`.\n function parseTomlTypeArray(string calldata toml, string calldata key, string calldata typeDescription)\n external\n pure\n returns (bytes memory);\n\n /// Parses a string of TOML data and coerces it to type corresponding to `typeDescription`.\n function parseTomlType(string calldata toml, string calldata typeDescription)\n external\n pure\n returns (bytes memory);\n\n /// Parses a string of TOML data at `key` and coerces it to type corresponding to `typeDescription`.\n function parseTomlType(string calldata toml, string calldata key, string calldata typeDescription)\n external\n pure\n returns (bytes memory);\n\n /// Parses a string of TOML data at `key` and coerces it to `uint256`.\n function parseTomlUint(string calldata toml, string calldata key) external pure returns (uint256);\n\n /// Parses a string of TOML data at `key` and coerces it to `uint256[]`.\n function parseTomlUintArray(string calldata toml, string calldata key) external pure returns (uint256[] memory);\n\n /// ABI-encodes a TOML table.\n function parseToml(string calldata toml) external pure returns (bytes memory abiEncodedData);\n\n /// ABI-encodes a TOML table at `key`.\n function parseToml(string calldata toml, string calldata key) external pure returns (bytes memory abiEncodedData);\n\n /// Takes serialized JSON, converts to TOML and write a serialized TOML to a file.\n function writeToml(string calldata json, string calldata path) external;\n\n /// Takes serialized JSON, converts to TOML and write a serialized TOML table to an **existing** TOML file, replacing a value with key = \n /// This is useful to replace a specific value of a TOML file, without having to parse the entire thing.\n function writeToml(string calldata json, string calldata path, string calldata valueKey) external;\n\n // ======== Utilities ========\n\n /// Compute the address of a contract created with CREATE2 using the given CREATE2 deployer.\n function computeCreate2Address(bytes32 salt, bytes32 initCodeHash, address deployer)\n external\n pure\n returns (address);\n\n /// Compute the address of a contract created with CREATE2 using the default CREATE2 deployer.\n function computeCreate2Address(bytes32 salt, bytes32 initCodeHash) external pure returns (address);\n\n /// Compute the address a contract will be deployed at for a given deployer address and nonce.\n function computeCreateAddress(address deployer, uint256 nonce) external pure returns (address);\n\n /// Utility cheatcode to copy storage of `from` contract to another `to` contract.\n function copyStorage(address from, address to) external;\n\n /// Returns ENS namehash for provided string.\n function ensNamehash(string calldata name) external pure returns (bytes32);\n\n /// Gets the label for the specified address.\n function getLabel(address account) external view returns (string memory currentLabel);\n\n /// Labels an address in call traces.\n function label(address account, string calldata newLabel) external;\n\n /// Pauses collection of call traces. Useful in cases when you want to skip tracing of\n /// complex calls which are not useful for debugging.\n function pauseTracing() external view;\n\n /// Returns a random `address`.\n function randomAddress() external returns (address);\n\n /// Returns a random `bool`.\n function randomBool() external view returns (bool);\n\n /// Returns a random byte array value of the given length.\n function randomBytes(uint256 len) external view returns (bytes memory);\n\n /// Returns a random fixed-size byte array of length 4.\n function randomBytes4() external view returns (bytes4);\n\n /// Returns a random fixed-size byte array of length 8.\n function randomBytes8() external view returns (bytes8);\n\n /// Returns a random `int256` value.\n function randomInt() external view returns (int256);\n\n /// Returns a random `int256` value of given bits.\n function randomInt(uint256 bits) external view returns (int256);\n\n /// Returns a random uint256 value.\n function randomUint() external returns (uint256);\n\n /// Returns random uint256 value between the provided range (=min..=max).\n function randomUint(uint256 min, uint256 max) external returns (uint256);\n\n /// Returns a random `uint256` value of given bits.\n function randomUint(uint256 bits) external view returns (uint256);\n\n /// Unpauses collection of call traces.\n function resumeTracing() external view;\n\n /// Utility cheatcode to set arbitrary storage for given target address.\n function setArbitraryStorage(address target) external;\n\n /// Encodes a `bytes` value to a base64url string.\n function toBase64URL(bytes calldata data) external pure returns (string memory);\n\n /// Encodes a `string` value to a base64url string.\n function toBase64URL(string calldata data) external pure returns (string memory);\n\n /// Encodes a `bytes` value to a base64 string.\n function toBase64(bytes calldata data) external pure returns (string memory);\n\n /// Encodes a `string` value to a base64 string.\n function toBase64(string calldata data) external pure returns (string memory);\n}\n\n/// The `Vm` interface does allow manipulation of the EVM state. These are all intended to be used\n/// in tests, but it is not recommended to use these cheats in scripts.\ninterface Vm is VmSafe {\n // ======== EVM ========\n\n /// Utility cheatcode to set an EIP-2930 access list for all subsequent transactions.\n function accessList(AccessListItem[] calldata access) external;\n\n /// Returns the identifier of the currently active fork. Reverts if no fork is currently active.\n function activeFork() external view returns (uint256 forkId);\n\n /// In forking mode, explicitly grant the given address cheatcode access.\n function allowCheatcodes(address account) external;\n\n /// Sets `block.blobbasefee`\n function blobBaseFee(uint256 newBlobBaseFee) external;\n\n /// Sets the blobhashes in the transaction.\n /// Not available on EVM versions before Cancun.\n /// If used on unsupported EVM versions it will revert.\n function blobhashes(bytes32[] calldata hashes) external;\n\n /// Sets `block.chainid`.\n function chainId(uint256 newChainId) external;\n\n /// Clears all mocked calls.\n function clearMockedCalls() external;\n\n /// Clones a source account code, state, balance and nonce to a target account and updates in-memory EVM state.\n function cloneAccount(address source, address target) external;\n\n /// Sets `block.coinbase`.\n function coinbase(address newCoinbase) external;\n\n /// Marks the slots of an account and the account address as cold.\n function cool(address target) external;\n\n /// Utility cheatcode to mark specific storage slot as cold, simulating no prior read.\n function coolSlot(address target, bytes32 slot) external;\n\n /// Creates a new fork with the given endpoint and the _latest_ block and returns the identifier of the fork.\n function createFork(string calldata urlOrAlias) external returns (uint256 forkId);\n\n /// Creates a new fork with the given endpoint and block and returns the identifier of the fork.\n function createFork(string calldata urlOrAlias, uint256 blockNumber) external returns (uint256 forkId);\n\n /// Creates a new fork with the given endpoint and at the block the given transaction was mined in,\n /// replays all transaction mined in the block before the transaction, and returns the identifier of the fork.\n function createFork(string calldata urlOrAlias, bytes32 txHash) external returns (uint256 forkId);\n\n /// Creates and also selects a new fork with the given endpoint and the latest block and returns the identifier of the fork.\n function createSelectFork(string calldata urlOrAlias) external returns (uint256 forkId);\n\n /// Creates and also selects a new fork with the given endpoint and block and returns the identifier of the fork.\n function createSelectFork(string calldata urlOrAlias, uint256 blockNumber) external returns (uint256 forkId);\n\n /// Creates and also selects new fork with the given endpoint and at the block the given transaction was mined in,\n /// replays all transaction mined in the block before the transaction, returns the identifier of the fork.\n function createSelectFork(string calldata urlOrAlias, bytes32 txHash) external returns (uint256 forkId);\n\n /// Sets an address' balance.\n function deal(address account, uint256 newBalance) external;\n\n /// Removes the snapshot with the given ID created by `snapshot`.\n /// Takes the snapshot ID to delete.\n /// Returns `true` if the snapshot was successfully deleted.\n /// Returns `false` if the snapshot does not exist.\n function deleteStateSnapshot(uint256 snapshotId) external returns (bool success);\n\n /// Removes _all_ snapshots previously created by `snapshot`.\n function deleteStateSnapshots() external;\n\n /// Sets `block.difficulty`.\n /// Not available on EVM versions from Paris onwards. Use `prevrandao` instead.\n /// Reverts if used on unsupported EVM versions.\n function difficulty(uint256 newDifficulty) external;\n\n /// Dump a genesis JSON file's `allocs` to disk.\n function dumpState(string calldata pathToStateJson) external;\n\n /// Sets an address' code.\n function etch(address target, bytes calldata newRuntimeBytecode) external;\n\n /// Sets `block.basefee`.\n function fee(uint256 newBasefee) external;\n\n /// Gets the blockhashes from the current transaction.\n /// Not available on EVM versions before Cancun.\n /// If used on unsupported EVM versions it will revert.\n function getBlobhashes() external view returns (bytes32[] memory hashes);\n\n /// Returns true if the account is marked as persistent.\n function isPersistent(address account) external view returns (bool persistent);\n\n /// Load a genesis JSON file's `allocs` into the in-memory EVM state.\n function loadAllocs(string calldata pathToAllocsJson) external;\n\n /// Marks that the account(s) should use persistent storage across fork swaps in a multifork setup\n /// Meaning, changes made to the state of this account will be kept when switching forks.\n function makePersistent(address account) external;\n\n /// See `makePersistent(address)`.\n function makePersistent(address account0, address account1) external;\n\n /// See `makePersistent(address)`.\n function makePersistent(address account0, address account1, address account2) external;\n\n /// See `makePersistent(address)`.\n function makePersistent(address[] calldata accounts) external;\n\n /// Reverts a call to an address with specified revert data.\n function mockCallRevert(address callee, bytes calldata data, bytes calldata revertData) external;\n\n /// Reverts a call to an address with a specific `msg.value`, with specified revert data.\n function mockCallRevert(address callee, uint256 msgValue, bytes calldata data, bytes calldata revertData)\n external;\n\n /// Reverts a call to an address with specified revert data.\n /// Overload to pass the function selector directly `token.approve.selector` instead of `abi.encodeWithSelector(token.approve.selector)`.\n function mockCallRevert(address callee, bytes4 data, bytes calldata revertData) external;\n\n /// Reverts a call to an address with a specific `msg.value`, with specified revert data.\n /// Overload to pass the function selector directly `token.approve.selector` instead of `abi.encodeWithSelector(token.approve.selector)`.\n function mockCallRevert(address callee, uint256 msgValue, bytes4 data, bytes calldata revertData) external;\n\n /// Mocks a call to an address, returning specified data.\n /// Calldata can either be strict or a partial match, e.g. if you only\n /// pass a Solidity selector to the expected calldata, then the entire Solidity\n /// function will be mocked.\n function mockCall(address callee, bytes calldata data, bytes calldata returnData) external;\n\n /// Mocks a call to an address with a specific `msg.value`, returning specified data.\n /// Calldata match takes precedence over `msg.value` in case of ambiguity.\n function mockCall(address callee, uint256 msgValue, bytes calldata data, bytes calldata returnData) external;\n\n /// Mocks a call to an address, returning specified data.\n /// Calldata can either be strict or a partial match, e.g. if you only\n /// pass a Solidity selector to the expected calldata, then the entire Solidity\n /// function will be mocked.\n /// Overload to pass the function selector directly `token.approve.selector` instead of `abi.encodeWithSelector(token.approve.selector)`.\n function mockCall(address callee, bytes4 data, bytes calldata returnData) external;\n\n /// Mocks a call to an address with a specific `msg.value`, returning specified data.\n /// Calldata match takes precedence over `msg.value` in case of ambiguity.\n /// Overload to pass the function selector directly `token.approve.selector` instead of `abi.encodeWithSelector(token.approve.selector)`.\n function mockCall(address callee, uint256 msgValue, bytes4 data, bytes calldata returnData) external;\n\n /// Mocks multiple calls to an address, returning specified data for each call.\n function mockCalls(address callee, bytes calldata data, bytes[] calldata returnData) external;\n\n /// Mocks multiple calls to an address with a specific `msg.value`, returning specified data for each call.\n function mockCalls(address callee, uint256 msgValue, bytes calldata data, bytes[] calldata returnData) external;\n\n /// Whenever a call is made to `callee` with calldata `data`, this cheatcode instead calls\n /// `target` with the same calldata. This functionality is similar to a delegate call made to\n /// `target` contract from `callee`.\n /// Can be used to substitute a call to a function with another implementation that captures\n /// the primary logic of the original function but is easier to reason about.\n /// If calldata is not a strict match then partial match by selector is attempted.\n function mockFunction(address callee, address target, bytes calldata data) external;\n\n /// Utility cheatcode to remove any EIP-2930 access list set by `accessList` cheatcode.\n function noAccessList() external;\n\n /// Sets the *next* call's `msg.sender` to be the input address.\n function prank(address msgSender) external;\n\n /// Sets the *next* call's `msg.sender` to be the input address, and the `tx.origin` to be the second input.\n function prank(address msgSender, address txOrigin) external;\n\n /// Sets the *next* delegate call's `msg.sender` to be the input address.\n function prank(address msgSender, bool delegateCall) external;\n\n /// Sets the *next* delegate call's `msg.sender` to be the input address, and the `tx.origin` to be the second input.\n function prank(address msgSender, address txOrigin, bool delegateCall) external;\n\n /// Sets `block.prevrandao`.\n /// Not available on EVM versions before Paris. Use `difficulty` instead.\n /// If used on unsupported EVM versions it will revert.\n function prevrandao(bytes32 newPrevrandao) external;\n\n /// Sets `block.prevrandao`.\n /// Not available on EVM versions before Paris. Use `difficulty` instead.\n /// If used on unsupported EVM versions it will revert.\n function prevrandao(uint256 newPrevrandao) external;\n\n /// Reads the current `msg.sender` and `tx.origin` from state and reports if there is any active caller modification.\n function readCallers() external returns (CallerMode callerMode, address msgSender, address txOrigin);\n\n /// Resets the nonce of an account to 0 for EOAs and 1 for contract accounts.\n function resetNonce(address account) external;\n\n /// Revert the state of the EVM to a previous snapshot\n /// Takes the snapshot ID to revert to.\n /// Returns `true` if the snapshot was successfully reverted.\n /// Returns `false` if the snapshot does not exist.\n /// **Note:** This does not automatically delete the snapshot. To delete the snapshot use `deleteStateSnapshot`.\n function revertToState(uint256 snapshotId) external returns (bool success);\n\n /// Revert the state of the EVM to a previous snapshot and automatically deletes the snapshots\n /// Takes the snapshot ID to revert to.\n /// Returns `true` if the snapshot was successfully reverted and deleted.\n /// Returns `false` if the snapshot does not exist.\n function revertToStateAndDelete(uint256 snapshotId) external returns (bool success);\n\n /// Revokes persistent status from the address, previously added via `makePersistent`.\n function revokePersistent(address account) external;\n\n /// See `revokePersistent(address)`.\n function revokePersistent(address[] calldata accounts) external;\n\n /// Sets `block.height`.\n function roll(uint256 newHeight) external;\n\n /// Updates the currently active fork to given block number\n /// This is similar to `roll` but for the currently active fork.\n function rollFork(uint256 blockNumber) external;\n\n /// Updates the currently active fork to given transaction. This will `rollFork` with the number\n /// of the block the transaction was mined in and replays all transaction mined before it in the block.\n function rollFork(bytes32 txHash) external;\n\n /// Updates the given fork to given block number.\n function rollFork(uint256 forkId, uint256 blockNumber) external;\n\n /// Updates the given fork to block number of the given transaction and replays all transaction mined before it in the block.\n function rollFork(uint256 forkId, bytes32 txHash) external;\n\n /// Takes a fork identifier created by `createFork` and sets the corresponding forked state as active.\n function selectFork(uint256 forkId) external;\n\n /// Set blockhash for the current block.\n /// It only sets the blockhash for blocks where `block.number - 256 <= number < block.number`.\n function setBlockhash(uint256 blockNumber, bytes32 blockHash) external;\n\n /// Sets the nonce of an account. Must be higher than the current nonce of the account.\n function setNonce(address account, uint64 newNonce) external;\n\n /// Sets the nonce of an account to an arbitrary value.\n function setNonceUnsafe(address account, uint64 newNonce) external;\n\n /// Snapshot capture the gas usage of the last call by name from the callee perspective.\n function snapshotGasLastCall(string calldata name) external returns (uint256 gasUsed);\n\n /// Snapshot capture the gas usage of the last call by name in a group from the callee perspective.\n function snapshotGasLastCall(string calldata group, string calldata name) external returns (uint256 gasUsed);\n\n /// Snapshot the current state of the evm.\n /// Returns the ID of the snapshot that was created.\n /// To revert a snapshot use `revertToState`.\n function snapshotState() external returns (uint256 snapshotId);\n\n /// Snapshot capture an arbitrary numerical value by name.\n /// The group name is derived from the contract name.\n function snapshotValue(string calldata name, uint256 value) external;\n\n /// Snapshot capture an arbitrary numerical value by name in a group.\n function snapshotValue(string calldata group, string calldata name, uint256 value) external;\n\n /// Sets all subsequent calls' `msg.sender` to be the input address until `stopPrank` is called.\n function startPrank(address msgSender) external;\n\n /// Sets all subsequent calls' `msg.sender` to be the input address until `stopPrank` is called, and the `tx.origin` to be the second input.\n function startPrank(address msgSender, address txOrigin) external;\n\n /// Sets all subsequent delegate calls' `msg.sender` to be the input address until `stopPrank` is called.\n function startPrank(address msgSender, bool delegateCall) external;\n\n /// Sets all subsequent delegate calls' `msg.sender` to be the input address until `stopPrank` is called, and the `tx.origin` to be the second input.\n function startPrank(address msgSender, address txOrigin, bool delegateCall) external;\n\n /// Start a snapshot capture of the current gas usage by name.\n /// The group name is derived from the contract name.\n function startSnapshotGas(string calldata name) external;\n\n /// Start a snapshot capture of the current gas usage by name in a group.\n function startSnapshotGas(string calldata group, string calldata name) external;\n\n /// Resets subsequent calls' `msg.sender` to be `address(this)`.\n function stopPrank() external;\n\n /// Stop the snapshot capture of the current gas by latest snapshot name, capturing the gas used since the start.\n function stopSnapshotGas() external returns (uint256 gasUsed);\n\n /// Stop the snapshot capture of the current gas usage by name, capturing the gas used since the start.\n /// The group name is derived from the contract name.\n function stopSnapshotGas(string calldata name) external returns (uint256 gasUsed);\n\n /// Stop the snapshot capture of the current gas usage by name in a group, capturing the gas used since the start.\n function stopSnapshotGas(string calldata group, string calldata name) external returns (uint256 gasUsed);\n\n /// Stores a value to an address' storage slot.\n function store(address target, bytes32 slot, bytes32 value) external;\n\n /// Fetches the given transaction from the active fork and executes it on the current state.\n function transact(bytes32 txHash) external;\n\n /// Fetches the given transaction from the given fork and executes it on the current state.\n function transact(uint256 forkId, bytes32 txHash) external;\n\n /// Sets `tx.gasprice`.\n function txGasPrice(uint256 newGasPrice) external;\n\n /// Utility cheatcode to mark specific storage slot as warm, simulating a prior read.\n function warmSlot(address target, bytes32 slot) external;\n\n /// Sets `block.timestamp`.\n function warp(uint256 newTimestamp) external;\n\n /// `deleteSnapshot` is being deprecated in favor of `deleteStateSnapshot`. It will be removed in future versions.\n function deleteSnapshot(uint256 snapshotId) external returns (bool success);\n\n /// `deleteSnapshots` is being deprecated in favor of `deleteStateSnapshots`. It will be removed in future versions.\n function deleteSnapshots() external;\n\n /// `revertToAndDelete` is being deprecated in favor of `revertToStateAndDelete`. It will be removed in future versions.\n function revertToAndDelete(uint256 snapshotId) external returns (bool success);\n\n /// `revertTo` is being deprecated in favor of `revertToState`. It will be removed in future versions.\n function revertTo(uint256 snapshotId) external returns (bool success);\n\n /// `snapshot` is being deprecated in favor of `snapshotState`. It will be removed in future versions.\n function snapshot() external returns (uint256 snapshotId);\n\n // ======== Testing ========\n\n /// Expect a call to an address with the specified `msg.value` and calldata, and a *minimum* amount of gas.\n function expectCallMinGas(address callee, uint256 msgValue, uint64 minGas, bytes calldata data) external;\n\n /// Expect given number of calls to an address with the specified `msg.value` and calldata, and a *minimum* amount of gas.\n function expectCallMinGas(address callee, uint256 msgValue, uint64 minGas, bytes calldata data, uint64 count)\n external;\n\n /// Expects a call to an address with the specified calldata.\n /// Calldata can either be a strict or a partial match.\n function expectCall(address callee, bytes calldata data) external;\n\n /// Expects given number of calls to an address with the specified calldata.\n function expectCall(address callee, bytes calldata data, uint64 count) external;\n\n /// Expects a call to an address with the specified `msg.value` and calldata.\n function expectCall(address callee, uint256 msgValue, bytes calldata data) external;\n\n /// Expects given number of calls to an address with the specified `msg.value` and calldata.\n function expectCall(address callee, uint256 msgValue, bytes calldata data, uint64 count) external;\n\n /// Expect a call to an address with the specified `msg.value`, gas, and calldata.\n function expectCall(address callee, uint256 msgValue, uint64 gas, bytes calldata data) external;\n\n /// Expects given number of calls to an address with the specified `msg.value`, gas, and calldata.\n function expectCall(address callee, uint256 msgValue, uint64 gas, bytes calldata data, uint64 count) external;\n\n /// Expects the deployment of the specified bytecode by the specified address using the CREATE opcode\n function expectCreate(bytes calldata bytecode, address deployer) external;\n\n /// Expects the deployment of the specified bytecode by the specified address using the CREATE2 opcode\n function expectCreate2(bytes calldata bytecode, address deployer) external;\n\n /// Prepare an expected anonymous log with (bool checkTopic1, bool checkTopic2, bool checkTopic3, bool checkData.).\n /// Call this function, then emit an anonymous event, then call a function. Internally after the call, we check if\n /// logs were emitted in the expected order with the expected topics and data (as specified by the booleans).\n function expectEmitAnonymous(bool checkTopic0, bool checkTopic1, bool checkTopic2, bool checkTopic3, bool checkData)\n external;\n\n /// Same as the previous method, but also checks supplied address against emitting contract.\n function expectEmitAnonymous(\n bool checkTopic0,\n bool checkTopic1,\n bool checkTopic2,\n bool checkTopic3,\n bool checkData,\n address emitter\n ) external;\n\n /// Prepare an expected anonymous log with all topic and data checks enabled.\n /// Call this function, then emit an anonymous event, then call a function. Internally after the call, we check if\n /// logs were emitted in the expected order with the expected topics and data.\n function expectEmitAnonymous() external;\n\n /// Same as the previous method, but also checks supplied address against emitting contract.\n function expectEmitAnonymous(address emitter) external;\n\n /// Prepare an expected log with (bool checkTopic1, bool checkTopic2, bool checkTopic3, bool checkData.).\n /// Call this function, then emit an event, then call a function. Internally after the call, we check if\n /// logs were emitted in the expected order with the expected topics and data (as specified by the booleans).\n function expectEmit(bool checkTopic1, bool checkTopic2, bool checkTopic3, bool checkData) external;\n\n /// Same as the previous method, but also checks supplied address against emitting contract.\n function expectEmit(bool checkTopic1, bool checkTopic2, bool checkTopic3, bool checkData, address emitter)\n external;\n\n /// Prepare an expected log with all topic and data checks enabled.\n /// Call this function, then emit an event, then call a function. Internally after the call, we check if\n /// logs were emitted in the expected order with the expected topics and data.\n function expectEmit() external;\n\n /// Same as the previous method, but also checks supplied address against emitting contract.\n function expectEmit(address emitter) external;\n\n /// Expect a given number of logs with the provided topics.\n function expectEmit(bool checkTopic1, bool checkTopic2, bool checkTopic3, bool checkData, uint64 count) external;\n\n /// Expect a given number of logs from a specific emitter with the provided topics.\n function expectEmit(\n bool checkTopic1,\n bool checkTopic2,\n bool checkTopic3,\n bool checkData,\n address emitter,\n uint64 count\n ) external;\n\n /// Expect a given number of logs with all topic and data checks enabled.\n function expectEmit(uint64 count) external;\n\n /// Expect a given number of logs from a specific emitter with all topic and data checks enabled.\n function expectEmit(address emitter, uint64 count) external;\n\n /// Expects an error on next call that starts with the revert data.\n function expectPartialRevert(bytes4 revertData) external;\n\n /// Expects an error on next call to reverter address, that starts with the revert data.\n function expectPartialRevert(bytes4 revertData, address reverter) external;\n\n /// Expects an error on next call with any revert data.\n function expectRevert() external;\n\n /// Expects an error on next call that exactly matches the revert data.\n function expectRevert(bytes4 revertData) external;\n\n /// Expects a `count` number of reverts from the upcoming calls from the reverter address that match the revert data.\n function expectRevert(bytes4 revertData, address reverter, uint64 count) external;\n\n /// Expects a `count` number of reverts from the upcoming calls from the reverter address that exactly match the revert data.\n function expectRevert(bytes calldata revertData, address reverter, uint64 count) external;\n\n /// Expects an error on next call that exactly matches the revert data.\n function expectRevert(bytes calldata revertData) external;\n\n /// Expects an error with any revert data on next call to reverter address.\n function expectRevert(address reverter) external;\n\n /// Expects an error from reverter address on next call, with any revert data.\n function expectRevert(bytes4 revertData, address reverter) external;\n\n /// Expects an error from reverter address on next call, that exactly matches the revert data.\n function expectRevert(bytes calldata revertData, address reverter) external;\n\n /// Expects a `count` number of reverts from the upcoming calls with any revert data or reverter.\n function expectRevert(uint64 count) external;\n\n /// Expects a `count` number of reverts from the upcoming calls that match the revert data.\n function expectRevert(bytes4 revertData, uint64 count) external;\n\n /// Expects a `count` number of reverts from the upcoming calls that exactly match the revert data.\n function expectRevert(bytes calldata revertData, uint64 count) external;\n\n /// Expects a `count` number of reverts from the upcoming calls from the reverter address.\n function expectRevert(address reverter, uint64 count) external;\n\n /// Only allows memory writes to offsets [0x00, 0x60) ∪ [min, max) in the current subcontext. If any other\n /// memory is written to, the test will fail. Can be called multiple times to add more ranges to the set.\n function expectSafeMemory(uint64 min, uint64 max) external;\n\n /// Only allows memory writes to offsets [0x00, 0x60) ∪ [min, max) in the next created subcontext.\n /// If any other memory is written to, the test will fail. Can be called multiple times to add more ranges\n /// to the set.\n function expectSafeMemoryCall(uint64 min, uint64 max) external;\n\n /// Marks a test as skipped. Must be called at the top level of a test.\n function skip(bool skipTest) external;\n\n /// Marks a test as skipped with a reason. Must be called at the top level of a test.\n function skip(bool skipTest, string calldata reason) external;\n\n /// Stops all safe memory expectation in the current subcontext.\n function stopExpectSafeMemory() external;\n}\n","license":"MIT OR Apache-2.0"},"lib/forge-std/src/console.sol":{"keccak256":"0x4bbf47eb762cef93729d6ef15e78789957147039b113e5d4df48e3d3fd16d0f5","urls":[],"content":"// SPDX-License-Identifier: MIT\npragma solidity >=0.4.22 <0.9.0;\n\nlibrary console {\n address constant CONSOLE_ADDRESS =\n 0x000000000000000000636F6e736F6c652e6c6f67;\n\n function _sendLogPayloadImplementation(bytes memory payload) internal view {\n address consoleAddress = CONSOLE_ADDRESS;\n /// @solidity memory-safe-assembly\n assembly {\n pop(\n staticcall(\n gas(),\n consoleAddress,\n add(payload, 32),\n mload(payload),\n 0,\n 0\n )\n )\n }\n }\n\n function _castToPure(\n function(bytes memory) internal view fnIn\n ) internal pure returns (function(bytes memory) pure fnOut) {\n assembly {\n fnOut := fnIn\n }\n }\n\n function _sendLogPayload(bytes memory payload) internal pure {\n _castToPure(_sendLogPayloadImplementation)(payload);\n }\n\n function log() internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log()\"));\n }\n\n function logInt(int256 p0) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(int256)\", p0));\n }\n\n function logUint(uint256 p0) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256)\", p0));\n }\n\n function logString(string memory p0) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string)\", p0));\n }\n\n function logBool(bool p0) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool)\", p0));\n }\n\n function logAddress(address p0) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address)\", p0));\n }\n\n function logBytes(bytes memory p0) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bytes)\", p0));\n }\n\n function logBytes1(bytes1 p0) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bytes1)\", p0));\n }\n\n function logBytes2(bytes2 p0) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bytes2)\", p0));\n }\n\n function logBytes3(bytes3 p0) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bytes3)\", p0));\n }\n\n function logBytes4(bytes4 p0) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bytes4)\", p0));\n }\n\n function logBytes5(bytes5 p0) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bytes5)\", p0));\n }\n\n function logBytes6(bytes6 p0) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bytes6)\", p0));\n }\n\n function logBytes7(bytes7 p0) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bytes7)\", p0));\n }\n\n function logBytes8(bytes8 p0) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bytes8)\", p0));\n }\n\n function logBytes9(bytes9 p0) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bytes9)\", p0));\n }\n\n function logBytes10(bytes10 p0) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bytes10)\", p0));\n }\n\n function logBytes11(bytes11 p0) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bytes11)\", p0));\n }\n\n function logBytes12(bytes12 p0) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bytes12)\", p0));\n }\n\n function logBytes13(bytes13 p0) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bytes13)\", p0));\n }\n\n function logBytes14(bytes14 p0) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bytes14)\", p0));\n }\n\n function logBytes15(bytes15 p0) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bytes15)\", p0));\n }\n\n function logBytes16(bytes16 p0) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bytes16)\", p0));\n }\n\n function logBytes17(bytes17 p0) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bytes17)\", p0));\n }\n\n function logBytes18(bytes18 p0) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bytes18)\", p0));\n }\n\n function logBytes19(bytes19 p0) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bytes19)\", p0));\n }\n\n function logBytes20(bytes20 p0) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bytes20)\", p0));\n }\n\n function logBytes21(bytes21 p0) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bytes21)\", p0));\n }\n\n function logBytes22(bytes22 p0) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bytes22)\", p0));\n }\n\n function logBytes23(bytes23 p0) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bytes23)\", p0));\n }\n\n function logBytes24(bytes24 p0) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bytes24)\", p0));\n }\n\n function logBytes25(bytes25 p0) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bytes25)\", p0));\n }\n\n function logBytes26(bytes26 p0) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bytes26)\", p0));\n }\n\n function logBytes27(bytes27 p0) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bytes27)\", p0));\n }\n\n function logBytes28(bytes28 p0) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bytes28)\", p0));\n }\n\n function logBytes29(bytes29 p0) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bytes29)\", p0));\n }\n\n function logBytes30(bytes30 p0) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bytes30)\", p0));\n }\n\n function logBytes31(bytes31 p0) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bytes31)\", p0));\n }\n\n function logBytes32(bytes32 p0) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bytes32)\", p0));\n }\n\n function log(uint256 p0) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256)\", p0));\n }\n\n function log(int256 p0) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(int256)\", p0));\n }\n\n function log(string memory p0) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string)\", p0));\n }\n\n function log(bool p0) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool)\", p0));\n }\n\n function log(address p0) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address)\", p0));\n }\n\n function log(uint256 p0, uint256 p1) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,uint256)\", p0, p1));\n }\n\n function log(uint256 p0, string memory p1) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,string)\", p0, p1));\n }\n\n function log(uint256 p0, bool p1) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,bool)\", p0, p1));\n }\n\n function log(uint256 p0, address p1) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,address)\", p0, p1));\n }\n\n function log(string memory p0, uint256 p1) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,uint256)\", p0, p1));\n }\n\n function log(string memory p0, int256 p1) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,int256)\", p0, p1));\n }\n\n function log(string memory p0, string memory p1) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,string)\", p0, p1));\n }\n\n function log(string memory p0, bool p1) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,bool)\", p0, p1));\n }\n\n function log(string memory p0, address p1) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,address)\", p0, p1));\n }\n\n function log(bool p0, uint256 p1) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,uint256)\", p0, p1));\n }\n\n function log(bool p0, string memory p1) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,string)\", p0, p1));\n }\n\n function log(bool p0, bool p1) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,bool)\", p0, p1));\n }\n\n function log(bool p0, address p1) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,address)\", p0, p1));\n }\n\n function log(address p0, uint256 p1) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,uint256)\", p0, p1));\n }\n\n function log(address p0, string memory p1) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,string)\", p0, p1));\n }\n\n function log(address p0, bool p1) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,bool)\", p0, p1));\n }\n\n function log(address p0, address p1) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,address)\", p0, p1));\n }\n\n function log(uint256 p0, uint256 p1, uint256 p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,uint256,uint256)\", p0, p1, p2));\n }\n\n function log(uint256 p0, uint256 p1, string memory p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,uint256,string)\", p0, p1, p2));\n }\n\n function log(uint256 p0, uint256 p1, bool p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,uint256,bool)\", p0, p1, p2));\n }\n\n function log(uint256 p0, uint256 p1, address p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,uint256,address)\", p0, p1, p2));\n }\n\n function log(uint256 p0, string memory p1, uint256 p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,string,uint256)\", p0, p1, p2));\n }\n\n function log(uint256 p0, string memory p1, string memory p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,string,string)\", p0, p1, p2));\n }\n\n function log(uint256 p0, string memory p1, bool p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,string,bool)\", p0, p1, p2));\n }\n\n function log(uint256 p0, string memory p1, address p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,string,address)\", p0, p1, p2));\n }\n\n function log(uint256 p0, bool p1, uint256 p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,bool,uint256)\", p0, p1, p2));\n }\n\n function log(uint256 p0, bool p1, string memory p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,bool,string)\", p0, p1, p2));\n }\n\n function log(uint256 p0, bool p1, bool p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,bool,bool)\", p0, p1, p2));\n }\n\n function log(uint256 p0, bool p1, address p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,bool,address)\", p0, p1, p2));\n }\n\n function log(uint256 p0, address p1, uint256 p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,address,uint256)\", p0, p1, p2));\n }\n\n function log(uint256 p0, address p1, string memory p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,address,string)\", p0, p1, p2));\n }\n\n function log(uint256 p0, address p1, bool p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,address,bool)\", p0, p1, p2));\n }\n\n function log(uint256 p0, address p1, address p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,address,address)\", p0, p1, p2));\n }\n\n function log(string memory p0, uint256 p1, uint256 p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,uint256,uint256)\", p0, p1, p2));\n }\n\n function log(string memory p0, uint256 p1, string memory p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,uint256,string)\", p0, p1, p2));\n }\n\n function log(string memory p0, uint256 p1, bool p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,uint256,bool)\", p0, p1, p2));\n }\n\n function log(string memory p0, uint256 p1, address p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,uint256,address)\", p0, p1, p2));\n }\n\n function log(string memory p0, string memory p1, uint256 p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,string,uint256)\", p0, p1, p2));\n }\n\n function log(string memory p0, string memory p1, string memory p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,string,string)\", p0, p1, p2));\n }\n\n function log(string memory p0, string memory p1, bool p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,string,bool)\", p0, p1, p2));\n }\n\n function log(string memory p0, string memory p1, address p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,string,address)\", p0, p1, p2));\n }\n\n function log(string memory p0, bool p1, uint256 p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,bool,uint256)\", p0, p1, p2));\n }\n\n function log(string memory p0, bool p1, string memory p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,bool,string)\", p0, p1, p2));\n }\n\n function log(string memory p0, bool p1, bool p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,bool,bool)\", p0, p1, p2));\n }\n\n function log(string memory p0, bool p1, address p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,bool,address)\", p0, p1, p2));\n }\n\n function log(string memory p0, address p1, uint256 p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,address,uint256)\", p0, p1, p2));\n }\n\n function log(string memory p0, address p1, string memory p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,address,string)\", p0, p1, p2));\n }\n\n function log(string memory p0, address p1, bool p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,address,bool)\", p0, p1, p2));\n }\n\n function log(string memory p0, address p1, address p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,address,address)\", p0, p1, p2));\n }\n\n function log(bool p0, uint256 p1, uint256 p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,uint256,uint256)\", p0, p1, p2));\n }\n\n function log(bool p0, uint256 p1, string memory p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,uint256,string)\", p0, p1, p2));\n }\n\n function log(bool p0, uint256 p1, bool p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,uint256,bool)\", p0, p1, p2));\n }\n\n function log(bool p0, uint256 p1, address p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,uint256,address)\", p0, p1, p2));\n }\n\n function log(bool p0, string memory p1, uint256 p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,string,uint256)\", p0, p1, p2));\n }\n\n function log(bool p0, string memory p1, string memory p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,string,string)\", p0, p1, p2));\n }\n\n function log(bool p0, string memory p1, bool p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,string,bool)\", p0, p1, p2));\n }\n\n function log(bool p0, string memory p1, address p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,string,address)\", p0, p1, p2));\n }\n\n function log(bool p0, bool p1, uint256 p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,bool,uint256)\", p0, p1, p2));\n }\n\n function log(bool p0, bool p1, string memory p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,bool,string)\", p0, p1, p2));\n }\n\n function log(bool p0, bool p1, bool p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,bool,bool)\", p0, p1, p2));\n }\n\n function log(bool p0, bool p1, address p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,bool,address)\", p0, p1, p2));\n }\n\n function log(bool p0, address p1, uint256 p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,address,uint256)\", p0, p1, p2));\n }\n\n function log(bool p0, address p1, string memory p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,address,string)\", p0, p1, p2));\n }\n\n function log(bool p0, address p1, bool p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,address,bool)\", p0, p1, p2));\n }\n\n function log(bool p0, address p1, address p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,address,address)\", p0, p1, p2));\n }\n\n function log(address p0, uint256 p1, uint256 p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,uint256,uint256)\", p0, p1, p2));\n }\n\n function log(address p0, uint256 p1, string memory p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,uint256,string)\", p0, p1, p2));\n }\n\n function log(address p0, uint256 p1, bool p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,uint256,bool)\", p0, p1, p2));\n }\n\n function log(address p0, uint256 p1, address p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,uint256,address)\", p0, p1, p2));\n }\n\n function log(address p0, string memory p1, uint256 p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,string,uint256)\", p0, p1, p2));\n }\n\n function log(address p0, string memory p1, string memory p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,string,string)\", p0, p1, p2));\n }\n\n function log(address p0, string memory p1, bool p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,string,bool)\", p0, p1, p2));\n }\n\n function log(address p0, string memory p1, address p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,string,address)\", p0, p1, p2));\n }\n\n function log(address p0, bool p1, uint256 p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,bool,uint256)\", p0, p1, p2));\n }\n\n function log(address p0, bool p1, string memory p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,bool,string)\", p0, p1, p2));\n }\n\n function log(address p0, bool p1, bool p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,bool,bool)\", p0, p1, p2));\n }\n\n function log(address p0, bool p1, address p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,bool,address)\", p0, p1, p2));\n }\n\n function log(address p0, address p1, uint256 p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,address,uint256)\", p0, p1, p2));\n }\n\n function log(address p0, address p1, string memory p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,address,string)\", p0, p1, p2));\n }\n\n function log(address p0, address p1, bool p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,address,bool)\", p0, p1, p2));\n }\n\n function log(address p0, address p1, address p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,address,address)\", p0, p1, p2));\n }\n\n function log(uint256 p0, uint256 p1, uint256 p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,uint256,uint256,uint256)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, uint256 p1, uint256 p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,uint256,uint256,string)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, uint256 p1, uint256 p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,uint256,uint256,bool)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, uint256 p1, uint256 p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,uint256,uint256,address)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, uint256 p1, string memory p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,uint256,string,uint256)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, uint256 p1, string memory p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,uint256,string,string)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, uint256 p1, string memory p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,uint256,string,bool)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, uint256 p1, string memory p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,uint256,string,address)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, uint256 p1, bool p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,uint256,bool,uint256)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, uint256 p1, bool p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,uint256,bool,string)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, uint256 p1, bool p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,uint256,bool,bool)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, uint256 p1, bool p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,uint256,bool,address)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, uint256 p1, address p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,uint256,address,uint256)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, uint256 p1, address p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,uint256,address,string)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, uint256 p1, address p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,uint256,address,bool)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, uint256 p1, address p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,uint256,address,address)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, string memory p1, uint256 p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,string,uint256,uint256)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, string memory p1, uint256 p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,string,uint256,string)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, string memory p1, uint256 p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,string,uint256,bool)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, string memory p1, uint256 p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,string,uint256,address)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, string memory p1, string memory p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,string,string,uint256)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, string memory p1, string memory p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,string,string,string)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, string memory p1, string memory p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,string,string,bool)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, string memory p1, string memory p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,string,string,address)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, string memory p1, bool p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,string,bool,uint256)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, string memory p1, bool p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,string,bool,string)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, string memory p1, bool p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,string,bool,bool)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, string memory p1, bool p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,string,bool,address)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, string memory p1, address p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,string,address,uint256)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, string memory p1, address p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,string,address,string)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, string memory p1, address p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,string,address,bool)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, string memory p1, address p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,string,address,address)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, bool p1, uint256 p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,bool,uint256,uint256)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, bool p1, uint256 p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,bool,uint256,string)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, bool p1, uint256 p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,bool,uint256,bool)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, bool p1, uint256 p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,bool,uint256,address)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, bool p1, string memory p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,bool,string,uint256)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, bool p1, string memory p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,bool,string,string)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, bool p1, string memory p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,bool,string,bool)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, bool p1, string memory p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,bool,string,address)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, bool p1, bool p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,bool,bool,uint256)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, bool p1, bool p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,bool,bool,string)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, bool p1, bool p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,bool,bool,bool)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, bool p1, bool p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,bool,bool,address)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, bool p1, address p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,bool,address,uint256)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, bool p1, address p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,bool,address,string)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, bool p1, address p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,bool,address,bool)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, bool p1, address p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,bool,address,address)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, address p1, uint256 p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,address,uint256,uint256)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, address p1, uint256 p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,address,uint256,string)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, address p1, uint256 p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,address,uint256,bool)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, address p1, uint256 p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,address,uint256,address)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, address p1, string memory p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,address,string,uint256)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, address p1, string memory p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,address,string,string)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, address p1, string memory p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,address,string,bool)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, address p1, string memory p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,address,string,address)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, address p1, bool p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,address,bool,uint256)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, address p1, bool p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,address,bool,string)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, address p1, bool p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,address,bool,bool)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, address p1, bool p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,address,bool,address)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, address p1, address p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,address,address,uint256)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, address p1, address p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,address,address,string)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, address p1, address p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,address,address,bool)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, address p1, address p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,address,address,address)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, uint256 p1, uint256 p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,uint256,uint256,uint256)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, uint256 p1, uint256 p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,uint256,uint256,string)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, uint256 p1, uint256 p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,uint256,uint256,bool)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, uint256 p1, uint256 p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,uint256,uint256,address)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, uint256 p1, string memory p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,uint256,string,uint256)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, uint256 p1, string memory p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,uint256,string,string)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, uint256 p1, string memory p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,uint256,string,bool)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, uint256 p1, string memory p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,uint256,string,address)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, uint256 p1, bool p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,uint256,bool,uint256)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, uint256 p1, bool p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,uint256,bool,string)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, uint256 p1, bool p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,uint256,bool,bool)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, uint256 p1, bool p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,uint256,bool,address)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, uint256 p1, address p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,uint256,address,uint256)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, uint256 p1, address p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,uint256,address,string)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, uint256 p1, address p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,uint256,address,bool)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, uint256 p1, address p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,uint256,address,address)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, string memory p1, uint256 p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,string,uint256,uint256)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, string memory p1, uint256 p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,string,uint256,string)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, string memory p1, uint256 p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,string,uint256,bool)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, string memory p1, uint256 p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,string,uint256,address)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, string memory p1, string memory p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,string,string,uint256)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, string memory p1, string memory p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,string,string,string)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, string memory p1, string memory p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,string,string,bool)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, string memory p1, string memory p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,string,string,address)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, string memory p1, bool p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,string,bool,uint256)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, string memory p1, bool p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,string,bool,string)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, string memory p1, bool p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,string,bool,bool)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, string memory p1, bool p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,string,bool,address)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, string memory p1, address p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,string,address,uint256)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, string memory p1, address p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,string,address,string)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, string memory p1, address p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,string,address,bool)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, string memory p1, address p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,string,address,address)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, bool p1, uint256 p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,bool,uint256,uint256)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, bool p1, uint256 p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,bool,uint256,string)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, bool p1, uint256 p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,bool,uint256,bool)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, bool p1, uint256 p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,bool,uint256,address)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, bool p1, string memory p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,bool,string,uint256)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, bool p1, string memory p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,bool,string,string)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, bool p1, string memory p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,bool,string,bool)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, bool p1, string memory p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,bool,string,address)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, bool p1, bool p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,bool,bool,uint256)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, bool p1, bool p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,bool,bool,string)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, bool p1, bool p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,bool,bool,bool)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, bool p1, bool p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,bool,bool,address)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, bool p1, address p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,bool,address,uint256)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, bool p1, address p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,bool,address,string)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, bool p1, address p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,bool,address,bool)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, bool p1, address p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,bool,address,address)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, address p1, uint256 p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,address,uint256,uint256)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, address p1, uint256 p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,address,uint256,string)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, address p1, uint256 p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,address,uint256,bool)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, address p1, uint256 p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,address,uint256,address)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, address p1, string memory p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,address,string,uint256)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, address p1, string memory p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,address,string,string)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, address p1, string memory p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,address,string,bool)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, address p1, string memory p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,address,string,address)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, address p1, bool p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,address,bool,uint256)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, address p1, bool p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,address,bool,string)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, address p1, bool p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,address,bool,bool)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, address p1, bool p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,address,bool,address)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, address p1, address p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,address,address,uint256)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, address p1, address p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,address,address,string)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, address p1, address p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,address,address,bool)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, address p1, address p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,address,address,address)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, uint256 p1, uint256 p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,uint256,uint256,uint256)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, uint256 p1, uint256 p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,uint256,uint256,string)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, uint256 p1, uint256 p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,uint256,uint256,bool)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, uint256 p1, uint256 p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,uint256,uint256,address)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, uint256 p1, string memory p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,uint256,string,uint256)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, uint256 p1, string memory p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,uint256,string,string)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, uint256 p1, string memory p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,uint256,string,bool)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, uint256 p1, string memory p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,uint256,string,address)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, uint256 p1, bool p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,uint256,bool,uint256)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, uint256 p1, bool p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,uint256,bool,string)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, uint256 p1, bool p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,uint256,bool,bool)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, uint256 p1, bool p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,uint256,bool,address)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, uint256 p1, address p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,uint256,address,uint256)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, uint256 p1, address p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,uint256,address,string)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, uint256 p1, address p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,uint256,address,bool)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, uint256 p1, address p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,uint256,address,address)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, string memory p1, uint256 p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,string,uint256,uint256)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, string memory p1, uint256 p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,string,uint256,string)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, string memory p1, uint256 p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,string,uint256,bool)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, string memory p1, uint256 p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,string,uint256,address)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, string memory p1, string memory p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,string,string,uint256)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, string memory p1, string memory p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,string,string,string)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, string memory p1, string memory p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,string,string,bool)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, string memory p1, string memory p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,string,string,address)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, string memory p1, bool p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,string,bool,uint256)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, string memory p1, bool p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,string,bool,string)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, string memory p1, bool p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,string,bool,bool)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, string memory p1, bool p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,string,bool,address)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, string memory p1, address p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,string,address,uint256)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, string memory p1, address p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,string,address,string)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, string memory p1, address p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,string,address,bool)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, string memory p1, address p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,string,address,address)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, bool p1, uint256 p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,bool,uint256,uint256)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, bool p1, uint256 p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,bool,uint256,string)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, bool p1, uint256 p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,bool,uint256,bool)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, bool p1, uint256 p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,bool,uint256,address)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, bool p1, string memory p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,bool,string,uint256)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, bool p1, string memory p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,bool,string,string)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, bool p1, string memory p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,bool,string,bool)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, bool p1, string memory p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,bool,string,address)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, bool p1, bool p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,bool,bool,uint256)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, bool p1, bool p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,bool,bool,string)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, bool p1, bool p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,bool,bool,bool)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, bool p1, bool p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,bool,bool,address)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, bool p1, address p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,bool,address,uint256)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, bool p1, address p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,bool,address,string)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, bool p1, address p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,bool,address,bool)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, bool p1, address p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,bool,address,address)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, address p1, uint256 p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,address,uint256,uint256)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, address p1, uint256 p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,address,uint256,string)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, address p1, uint256 p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,address,uint256,bool)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, address p1, uint256 p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,address,uint256,address)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, address p1, string memory p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,address,string,uint256)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, address p1, string memory p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,address,string,string)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, address p1, string memory p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,address,string,bool)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, address p1, string memory p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,address,string,address)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, address p1, bool p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,address,bool,uint256)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, address p1, bool p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,address,bool,string)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, address p1, bool p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,address,bool,bool)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, address p1, bool p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,address,bool,address)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, address p1, address p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,address,address,uint256)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, address p1, address p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,address,address,string)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, address p1, address p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,address,address,bool)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, address p1, address p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,address,address,address)\", p0, p1, p2, p3));\n }\n\n function log(address p0, uint256 p1, uint256 p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,uint256,uint256,uint256)\", p0, p1, p2, p3));\n }\n\n function log(address p0, uint256 p1, uint256 p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,uint256,uint256,string)\", p0, p1, p2, p3));\n }\n\n function log(address p0, uint256 p1, uint256 p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,uint256,uint256,bool)\", p0, p1, p2, p3));\n }\n\n function log(address p0, uint256 p1, uint256 p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,uint256,uint256,address)\", p0, p1, p2, p3));\n }\n\n function log(address p0, uint256 p1, string memory p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,uint256,string,uint256)\", p0, p1, p2, p3));\n }\n\n function log(address p0, uint256 p1, string memory p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,uint256,string,string)\", p0, p1, p2, p3));\n }\n\n function log(address p0, uint256 p1, string memory p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,uint256,string,bool)\", p0, p1, p2, p3));\n }\n\n function log(address p0, uint256 p1, string memory p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,uint256,string,address)\", p0, p1, p2, p3));\n }\n\n function log(address p0, uint256 p1, bool p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,uint256,bool,uint256)\", p0, p1, p2, p3));\n }\n\n function log(address p0, uint256 p1, bool p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,uint256,bool,string)\", p0, p1, p2, p3));\n }\n\n function log(address p0, uint256 p1, bool p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,uint256,bool,bool)\", p0, p1, p2, p3));\n }\n\n function log(address p0, uint256 p1, bool p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,uint256,bool,address)\", p0, p1, p2, p3));\n }\n\n function log(address p0, uint256 p1, address p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,uint256,address,uint256)\", p0, p1, p2, p3));\n }\n\n function log(address p0, uint256 p1, address p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,uint256,address,string)\", p0, p1, p2, p3));\n }\n\n function log(address p0, uint256 p1, address p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,uint256,address,bool)\", p0, p1, p2, p3));\n }\n\n function log(address p0, uint256 p1, address p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,uint256,address,address)\", p0, p1, p2, p3));\n }\n\n function log(address p0, string memory p1, uint256 p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,string,uint256,uint256)\", p0, p1, p2, p3));\n }\n\n function log(address p0, string memory p1, uint256 p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,string,uint256,string)\", p0, p1, p2, p3));\n }\n\n function log(address p0, string memory p1, uint256 p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,string,uint256,bool)\", p0, p1, p2, p3));\n }\n\n function log(address p0, string memory p1, uint256 p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,string,uint256,address)\", p0, p1, p2, p3));\n }\n\n function log(address p0, string memory p1, string memory p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,string,string,uint256)\", p0, p1, p2, p3));\n }\n\n function log(address p0, string memory p1, string memory p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,string,string,string)\", p0, p1, p2, p3));\n }\n\n function log(address p0, string memory p1, string memory p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,string,string,bool)\", p0, p1, p2, p3));\n }\n\n function log(address p0, string memory p1, string memory p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,string,string,address)\", p0, p1, p2, p3));\n }\n\n function log(address p0, string memory p1, bool p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,string,bool,uint256)\", p0, p1, p2, p3));\n }\n\n function log(address p0, string memory p1, bool p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,string,bool,string)\", p0, p1, p2, p3));\n }\n\n function log(address p0, string memory p1, bool p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,string,bool,bool)\", p0, p1, p2, p3));\n }\n\n function log(address p0, string memory p1, bool p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,string,bool,address)\", p0, p1, p2, p3));\n }\n\n function log(address p0, string memory p1, address p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,string,address,uint256)\", p0, p1, p2, p3));\n }\n\n function log(address p0, string memory p1, address p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,string,address,string)\", p0, p1, p2, p3));\n }\n\n function log(address p0, string memory p1, address p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,string,address,bool)\", p0, p1, p2, p3));\n }\n\n function log(address p0, string memory p1, address p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,string,address,address)\", p0, p1, p2, p3));\n }\n\n function log(address p0, bool p1, uint256 p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,bool,uint256,uint256)\", p0, p1, p2, p3));\n }\n\n function log(address p0, bool p1, uint256 p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,bool,uint256,string)\", p0, p1, p2, p3));\n }\n\n function log(address p0, bool p1, uint256 p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,bool,uint256,bool)\", p0, p1, p2, p3));\n }\n\n function log(address p0, bool p1, uint256 p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,bool,uint256,address)\", p0, p1, p2, p3));\n }\n\n function log(address p0, bool p1, string memory p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,bool,string,uint256)\", p0, p1, p2, p3));\n }\n\n function log(address p0, bool p1, string memory p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,bool,string,string)\", p0, p1, p2, p3));\n }\n\n function log(address p0, bool p1, string memory p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,bool,string,bool)\", p0, p1, p2, p3));\n }\n\n function log(address p0, bool p1, string memory p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,bool,string,address)\", p0, p1, p2, p3));\n }\n\n function log(address p0, bool p1, bool p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,bool,bool,uint256)\", p0, p1, p2, p3));\n }\n\n function log(address p0, bool p1, bool p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,bool,bool,string)\", p0, p1, p2, p3));\n }\n\n function log(address p0, bool p1, bool p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,bool,bool,bool)\", p0, p1, p2, p3));\n }\n\n function log(address p0, bool p1, bool p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,bool,bool,address)\", p0, p1, p2, p3));\n }\n\n function log(address p0, bool p1, address p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,bool,address,uint256)\", p0, p1, p2, p3));\n }\n\n function log(address p0, bool p1, address p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,bool,address,string)\", p0, p1, p2, p3));\n }\n\n function log(address p0, bool p1, address p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,bool,address,bool)\", p0, p1, p2, p3));\n }\n\n function log(address p0, bool p1, address p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,bool,address,address)\", p0, p1, p2, p3));\n }\n\n function log(address p0, address p1, uint256 p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,address,uint256,uint256)\", p0, p1, p2, p3));\n }\n\n function log(address p0, address p1, uint256 p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,address,uint256,string)\", p0, p1, p2, p3));\n }\n\n function log(address p0, address p1, uint256 p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,address,uint256,bool)\", p0, p1, p2, p3));\n }\n\n function log(address p0, address p1, uint256 p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,address,uint256,address)\", p0, p1, p2, p3));\n }\n\n function log(address p0, address p1, string memory p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,address,string,uint256)\", p0, p1, p2, p3));\n }\n\n function log(address p0, address p1, string memory p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,address,string,string)\", p0, p1, p2, p3));\n }\n\n function log(address p0, address p1, string memory p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,address,string,bool)\", p0, p1, p2, p3));\n }\n\n function log(address p0, address p1, string memory p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,address,string,address)\", p0, p1, p2, p3));\n }\n\n function log(address p0, address p1, bool p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,address,bool,uint256)\", p0, p1, p2, p3));\n }\n\n function log(address p0, address p1, bool p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,address,bool,string)\", p0, p1, p2, p3));\n }\n\n function log(address p0, address p1, bool p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,address,bool,bool)\", p0, p1, p2, p3));\n }\n\n function log(address p0, address p1, bool p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,address,bool,address)\", p0, p1, p2, p3));\n }\n\n function log(address p0, address p1, address p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,address,address,uint256)\", p0, p1, p2, p3));\n }\n\n function log(address p0, address p1, address p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,address,address,string)\", p0, p1, p2, p3));\n }\n\n function log(address p0, address p1, address p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,address,address,bool)\", p0, p1, p2, p3));\n }\n\n function log(address p0, address p1, address p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,address,address,address)\", p0, p1, p2, p3));\n }\n}\n","license":"MIT"},"lib/forge-std/src/console2.sol":{"keccak256":"0x3b8fe79f48f065a4e4d35362171304a33784c3a90febae5f2787805a438de12f","urls":[],"content":"// SPDX-License-Identifier: MIT\npragma solidity >=0.4.22 <0.9.0;\n\nimport {console as console2} from \"./console.sol\";\n","license":"MIT"},"lib/forge-std/src/interfaces/IMulticall3.sol":{"keccak256":"0x7aac1389150499a922d1f9ef5749c908cef127cb2075b92fa17e9cb611263d0a","urls":[],"content":"// SPDX-License-Identifier: MIT\npragma solidity >=0.6.2 <0.9.0;\n\npragma experimental ABIEncoderV2;\n\ninterface IMulticall3 {\n struct Call {\n address target;\n bytes callData;\n }\n\n struct Call3 {\n address target;\n bool allowFailure;\n bytes callData;\n }\n\n struct Call3Value {\n address target;\n bool allowFailure;\n uint256 value;\n bytes callData;\n }\n\n struct Result {\n bool success;\n bytes returnData;\n }\n\n function aggregate(Call[] calldata calls)\n external\n payable\n returns (uint256 blockNumber, bytes[] memory returnData);\n\n function aggregate3(Call3[] calldata calls) external payable returns (Result[] memory returnData);\n\n function aggregate3Value(Call3Value[] calldata calls) external payable returns (Result[] memory returnData);\n\n function blockAndAggregate(Call[] calldata calls)\n external\n payable\n returns (uint256 blockNumber, bytes32 blockHash, Result[] memory returnData);\n\n function getBasefee() external view returns (uint256 basefee);\n\n function getBlockHash(uint256 blockNumber) external view returns (bytes32 blockHash);\n\n function getBlockNumber() external view returns (uint256 blockNumber);\n\n function getChainId() external view returns (uint256 chainid);\n\n function getCurrentBlockCoinbase() external view returns (address coinbase);\n\n function getCurrentBlockDifficulty() external view returns (uint256 difficulty);\n\n function getCurrentBlockGasLimit() external view returns (uint256 gaslimit);\n\n function getCurrentBlockTimestamp() external view returns (uint256 timestamp);\n\n function getEthBalance(address addr) external view returns (uint256 balance);\n\n function getLastBlockHash() external view returns (bytes32 blockHash);\n\n function tryAggregate(bool requireSuccess, Call[] calldata calls)\n external\n payable\n returns (Result[] memory returnData);\n\n function tryBlockAndAggregate(bool requireSuccess, Call[] calldata calls)\n external\n payable\n returns (uint256 blockNumber, bytes32 blockHash, Result[] memory returnData);\n}\n","license":"MIT"},"lib/forge-std/src/safeconsole.sol":{"keccak256":"0xbef9786cb49d3eade757bad87568c49c8c8f35721f0193c95ffb055d9e466e11","urls":[],"content":"// SPDX-License-Identifier: MIT\npragma solidity >=0.6.2 <0.9.0;\n\n/// @author philogy \n/// @dev Code generated automatically by script.\nlibrary safeconsole {\n uint256 constant CONSOLE_ADDR = 0x000000000000000000000000000000000000000000636F6e736F6c652e6c6f67;\n\n // Credit to [0age](https://twitter.com/z0age/status/1654922202930888704) and [0xdapper](https://github.com/foundry-rs/forge-std/pull/374)\n // for the view-to-pure log trick.\n function _sendLogPayload(uint256 offset, uint256 size) private pure {\n function(uint256, uint256) internal view fnIn = _sendLogPayloadView;\n function(uint256, uint256) internal pure pureSendLogPayload;\n /// @solidity memory-safe-assembly\n assembly {\n pureSendLogPayload := fnIn\n }\n pureSendLogPayload(offset, size);\n }\n\n function _sendLogPayloadView(uint256 offset, uint256 size) private view {\n /// @solidity memory-safe-assembly\n assembly {\n pop(staticcall(gas(), CONSOLE_ADDR, offset, size, 0x0, 0x0))\n }\n }\n\n function _memcopy(uint256 fromOffset, uint256 toOffset, uint256 length) private pure {\n function(uint256, uint256, uint256) internal view fnIn = _memcopyView;\n function(uint256, uint256, uint256) internal pure pureMemcopy;\n /// @solidity memory-safe-assembly\n assembly {\n pureMemcopy := fnIn\n }\n pureMemcopy(fromOffset, toOffset, length);\n }\n\n function _memcopyView(uint256 fromOffset, uint256 toOffset, uint256 length) private view {\n /// @solidity memory-safe-assembly\n assembly {\n pop(staticcall(gas(), 0x4, fromOffset, length, toOffset, length))\n }\n }\n\n function logMemory(uint256 offset, uint256 length) internal pure {\n if (offset >= 0x60) {\n // Sufficient memory before slice to prepare call header.\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(sub(offset, 0x60))\n m1 := mload(sub(offset, 0x40))\n m2 := mload(sub(offset, 0x20))\n // Selector of `log(bytes)`.\n mstore(sub(offset, 0x60), 0x0be77f56)\n mstore(sub(offset, 0x40), 0x20)\n mstore(sub(offset, 0x20), length)\n }\n _sendLogPayload(offset - 0x44, length + 0x44);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(sub(offset, 0x60), m0)\n mstore(sub(offset, 0x40), m1)\n mstore(sub(offset, 0x20), m2)\n }\n } else {\n // Insufficient space, so copy slice forward, add header and reverse.\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n uint256 endOffset = offset + length;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(add(endOffset, 0x00))\n m1 := mload(add(endOffset, 0x20))\n m2 := mload(add(endOffset, 0x40))\n }\n _memcopy(offset, offset + 0x60, length);\n /// @solidity memory-safe-assembly\n assembly {\n // Selector of `log(bytes)`.\n mstore(add(offset, 0x00), 0x0be77f56)\n mstore(add(offset, 0x20), 0x20)\n mstore(add(offset, 0x40), length)\n }\n _sendLogPayload(offset + 0x1c, length + 0x44);\n _memcopy(offset + 0x60, offset, length);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(add(endOffset, 0x00), m0)\n mstore(add(endOffset, 0x20), m1)\n mstore(add(endOffset, 0x40), m2)\n }\n }\n }\n\n function log(address p0) internal pure {\n bytes32 m0;\n bytes32 m1;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n // Selector of `log(address)`.\n mstore(0x00, 0x2c2ecbc2)\n mstore(0x20, p0)\n }\n _sendLogPayload(0x1c, 0x24);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n }\n }\n\n function log(bool p0) internal pure {\n bytes32 m0;\n bytes32 m1;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n // Selector of `log(bool)`.\n mstore(0x00, 0x32458eed)\n mstore(0x20, p0)\n }\n _sendLogPayload(0x1c, 0x24);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n }\n }\n\n function log(uint256 p0) internal pure {\n bytes32 m0;\n bytes32 m1;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n // Selector of `log(uint256)`.\n mstore(0x00, 0xf82c50f1)\n mstore(0x20, p0)\n }\n _sendLogPayload(0x1c, 0x24);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n }\n }\n\n function log(bytes32 p0) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n // Selector of `log(string)`.\n mstore(0x00, 0x41304fac)\n mstore(0x20, 0x20)\n writeString(0x40, p0)\n }\n _sendLogPayload(0x1c, 0x64);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n }\n }\n\n function log(address p0, address p1) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n // Selector of `log(address,address)`.\n mstore(0x00, 0xdaf0d4aa)\n mstore(0x20, p0)\n mstore(0x40, p1)\n }\n _sendLogPayload(0x1c, 0x44);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n }\n }\n\n function log(address p0, bool p1) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n // Selector of `log(address,bool)`.\n mstore(0x00, 0x75b605d3)\n mstore(0x20, p0)\n mstore(0x40, p1)\n }\n _sendLogPayload(0x1c, 0x44);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n }\n }\n\n function log(address p0, uint256 p1) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n // Selector of `log(address,uint256)`.\n mstore(0x00, 0x8309e8a8)\n mstore(0x20, p0)\n mstore(0x40, p1)\n }\n _sendLogPayload(0x1c, 0x44);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n }\n }\n\n function log(address p0, bytes32 p1) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(address,string)`.\n mstore(0x00, 0x759f86bb)\n mstore(0x20, p0)\n mstore(0x40, 0x40)\n writeString(0x60, p1)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(bool p0, address p1) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n // Selector of `log(bool,address)`.\n mstore(0x00, 0x853c4849)\n mstore(0x20, p0)\n mstore(0x40, p1)\n }\n _sendLogPayload(0x1c, 0x44);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n }\n }\n\n function log(bool p0, bool p1) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n // Selector of `log(bool,bool)`.\n mstore(0x00, 0x2a110e83)\n mstore(0x20, p0)\n mstore(0x40, p1)\n }\n _sendLogPayload(0x1c, 0x44);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n }\n }\n\n function log(bool p0, uint256 p1) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n // Selector of `log(bool,uint256)`.\n mstore(0x00, 0x399174d3)\n mstore(0x20, p0)\n mstore(0x40, p1)\n }\n _sendLogPayload(0x1c, 0x44);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n }\n }\n\n function log(bool p0, bytes32 p1) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(bool,string)`.\n mstore(0x00, 0x8feac525)\n mstore(0x20, p0)\n mstore(0x40, 0x40)\n writeString(0x60, p1)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(uint256 p0, address p1) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n // Selector of `log(uint256,address)`.\n mstore(0x00, 0x69276c86)\n mstore(0x20, p0)\n mstore(0x40, p1)\n }\n _sendLogPayload(0x1c, 0x44);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n }\n }\n\n function log(uint256 p0, bool p1) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n // Selector of `log(uint256,bool)`.\n mstore(0x00, 0x1c9d7eb3)\n mstore(0x20, p0)\n mstore(0x40, p1)\n }\n _sendLogPayload(0x1c, 0x44);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n }\n }\n\n function log(uint256 p0, uint256 p1) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n // Selector of `log(uint256,uint256)`.\n mstore(0x00, 0xf666715a)\n mstore(0x20, p0)\n mstore(0x40, p1)\n }\n _sendLogPayload(0x1c, 0x44);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n }\n }\n\n function log(uint256 p0, bytes32 p1) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(uint256,string)`.\n mstore(0x00, 0x643fd0df)\n mstore(0x20, p0)\n mstore(0x40, 0x40)\n writeString(0x60, p1)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(bytes32 p0, address p1) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(string,address)`.\n mstore(0x00, 0x319af333)\n mstore(0x20, 0x40)\n mstore(0x40, p1)\n writeString(0x60, p0)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(bytes32 p0, bool p1) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(string,bool)`.\n mstore(0x00, 0xc3b55635)\n mstore(0x20, 0x40)\n mstore(0x40, p1)\n writeString(0x60, p0)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(bytes32 p0, uint256 p1) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(string,uint256)`.\n mstore(0x00, 0xb60e72cc)\n mstore(0x20, 0x40)\n mstore(0x40, p1)\n writeString(0x60, p0)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(bytes32 p0, bytes32 p1) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(string,string)`.\n mstore(0x00, 0x4b5c4277)\n mstore(0x20, 0x40)\n mstore(0x40, 0x80)\n writeString(0x60, p0)\n writeString(0xa0, p1)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(address p0, address p1, address p2) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n // Selector of `log(address,address,address)`.\n mstore(0x00, 0x018c84c2)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n }\n _sendLogPayload(0x1c, 0x64);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n }\n }\n\n function log(address p0, address p1, bool p2) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n // Selector of `log(address,address,bool)`.\n mstore(0x00, 0xf2a66286)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n }\n _sendLogPayload(0x1c, 0x64);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n }\n }\n\n function log(address p0, address p1, uint256 p2) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n // Selector of `log(address,address,uint256)`.\n mstore(0x00, 0x17fe6185)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n }\n _sendLogPayload(0x1c, 0x64);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n }\n }\n\n function log(address p0, address p1, bytes32 p2) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n // Selector of `log(address,address,string)`.\n mstore(0x00, 0x007150be)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, 0x60)\n writeString(0x80, p2)\n }\n _sendLogPayload(0x1c, 0xa4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n }\n }\n\n function log(address p0, bool p1, address p2) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n // Selector of `log(address,bool,address)`.\n mstore(0x00, 0xf11699ed)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n }\n _sendLogPayload(0x1c, 0x64);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n }\n }\n\n function log(address p0, bool p1, bool p2) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n // Selector of `log(address,bool,bool)`.\n mstore(0x00, 0xeb830c92)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n }\n _sendLogPayload(0x1c, 0x64);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n }\n }\n\n function log(address p0, bool p1, uint256 p2) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n // Selector of `log(address,bool,uint256)`.\n mstore(0x00, 0x9c4f99fb)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n }\n _sendLogPayload(0x1c, 0x64);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n }\n }\n\n function log(address p0, bool p1, bytes32 p2) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n // Selector of `log(address,bool,string)`.\n mstore(0x00, 0x212255cc)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, 0x60)\n writeString(0x80, p2)\n }\n _sendLogPayload(0x1c, 0xa4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n }\n }\n\n function log(address p0, uint256 p1, address p2) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n // Selector of `log(address,uint256,address)`.\n mstore(0x00, 0x7bc0d848)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n }\n _sendLogPayload(0x1c, 0x64);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n }\n }\n\n function log(address p0, uint256 p1, bool p2) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n // Selector of `log(address,uint256,bool)`.\n mstore(0x00, 0x678209a8)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n }\n _sendLogPayload(0x1c, 0x64);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n }\n }\n\n function log(address p0, uint256 p1, uint256 p2) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n // Selector of `log(address,uint256,uint256)`.\n mstore(0x00, 0xb69bcaf6)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n }\n _sendLogPayload(0x1c, 0x64);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n }\n }\n\n function log(address p0, uint256 p1, bytes32 p2) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n // Selector of `log(address,uint256,string)`.\n mstore(0x00, 0xa1f2e8aa)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, 0x60)\n writeString(0x80, p2)\n }\n _sendLogPayload(0x1c, 0xa4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n }\n }\n\n function log(address p0, bytes32 p1, address p2) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n // Selector of `log(address,string,address)`.\n mstore(0x00, 0xf08744e8)\n mstore(0x20, p0)\n mstore(0x40, 0x60)\n mstore(0x60, p2)\n writeString(0x80, p1)\n }\n _sendLogPayload(0x1c, 0xa4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n }\n }\n\n function log(address p0, bytes32 p1, bool p2) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n // Selector of `log(address,string,bool)`.\n mstore(0x00, 0xcf020fb1)\n mstore(0x20, p0)\n mstore(0x40, 0x60)\n mstore(0x60, p2)\n writeString(0x80, p1)\n }\n _sendLogPayload(0x1c, 0xa4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n }\n }\n\n function log(address p0, bytes32 p1, uint256 p2) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n // Selector of `log(address,string,uint256)`.\n mstore(0x00, 0x67dd6ff1)\n mstore(0x20, p0)\n mstore(0x40, 0x60)\n mstore(0x60, p2)\n writeString(0x80, p1)\n }\n _sendLogPayload(0x1c, 0xa4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n }\n }\n\n function log(address p0, bytes32 p1, bytes32 p2) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n // Selector of `log(address,string,string)`.\n mstore(0x00, 0xfb772265)\n mstore(0x20, p0)\n mstore(0x40, 0x60)\n mstore(0x60, 0xa0)\n writeString(0x80, p1)\n writeString(0xc0, p2)\n }\n _sendLogPayload(0x1c, 0xe4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n }\n }\n\n function log(bool p0, address p1, address p2) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n // Selector of `log(bool,address,address)`.\n mstore(0x00, 0xd2763667)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n }\n _sendLogPayload(0x1c, 0x64);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n }\n }\n\n function log(bool p0, address p1, bool p2) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n // Selector of `log(bool,address,bool)`.\n mstore(0x00, 0x18c9c746)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n }\n _sendLogPayload(0x1c, 0x64);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n }\n }\n\n function log(bool p0, address p1, uint256 p2) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n // Selector of `log(bool,address,uint256)`.\n mstore(0x00, 0x5f7b9afb)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n }\n _sendLogPayload(0x1c, 0x64);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n }\n }\n\n function log(bool p0, address p1, bytes32 p2) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n // Selector of `log(bool,address,string)`.\n mstore(0x00, 0xde9a9270)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, 0x60)\n writeString(0x80, p2)\n }\n _sendLogPayload(0x1c, 0xa4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n }\n }\n\n function log(bool p0, bool p1, address p2) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n // Selector of `log(bool,bool,address)`.\n mstore(0x00, 0x1078f68d)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n }\n _sendLogPayload(0x1c, 0x64);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n }\n }\n\n function log(bool p0, bool p1, bool p2) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n // Selector of `log(bool,bool,bool)`.\n mstore(0x00, 0x50709698)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n }\n _sendLogPayload(0x1c, 0x64);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n }\n }\n\n function log(bool p0, bool p1, uint256 p2) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n // Selector of `log(bool,bool,uint256)`.\n mstore(0x00, 0x12f21602)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n }\n _sendLogPayload(0x1c, 0x64);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n }\n }\n\n function log(bool p0, bool p1, bytes32 p2) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n // Selector of `log(bool,bool,string)`.\n mstore(0x00, 0x2555fa46)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, 0x60)\n writeString(0x80, p2)\n }\n _sendLogPayload(0x1c, 0xa4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n }\n }\n\n function log(bool p0, uint256 p1, address p2) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n // Selector of `log(bool,uint256,address)`.\n mstore(0x00, 0x088ef9d2)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n }\n _sendLogPayload(0x1c, 0x64);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n }\n }\n\n function log(bool p0, uint256 p1, bool p2) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n // Selector of `log(bool,uint256,bool)`.\n mstore(0x00, 0xe8defba9)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n }\n _sendLogPayload(0x1c, 0x64);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n }\n }\n\n function log(bool p0, uint256 p1, uint256 p2) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n // Selector of `log(bool,uint256,uint256)`.\n mstore(0x00, 0x37103367)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n }\n _sendLogPayload(0x1c, 0x64);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n }\n }\n\n function log(bool p0, uint256 p1, bytes32 p2) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n // Selector of `log(bool,uint256,string)`.\n mstore(0x00, 0xc3fc3970)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, 0x60)\n writeString(0x80, p2)\n }\n _sendLogPayload(0x1c, 0xa4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n }\n }\n\n function log(bool p0, bytes32 p1, address p2) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n // Selector of `log(bool,string,address)`.\n mstore(0x00, 0x9591b953)\n mstore(0x20, p0)\n mstore(0x40, 0x60)\n mstore(0x60, p2)\n writeString(0x80, p1)\n }\n _sendLogPayload(0x1c, 0xa4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n }\n }\n\n function log(bool p0, bytes32 p1, bool p2) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n // Selector of `log(bool,string,bool)`.\n mstore(0x00, 0xdbb4c247)\n mstore(0x20, p0)\n mstore(0x40, 0x60)\n mstore(0x60, p2)\n writeString(0x80, p1)\n }\n _sendLogPayload(0x1c, 0xa4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n }\n }\n\n function log(bool p0, bytes32 p1, uint256 p2) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n // Selector of `log(bool,string,uint256)`.\n mstore(0x00, 0x1093ee11)\n mstore(0x20, p0)\n mstore(0x40, 0x60)\n mstore(0x60, p2)\n writeString(0x80, p1)\n }\n _sendLogPayload(0x1c, 0xa4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n }\n }\n\n function log(bool p0, bytes32 p1, bytes32 p2) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n // Selector of `log(bool,string,string)`.\n mstore(0x00, 0xb076847f)\n mstore(0x20, p0)\n mstore(0x40, 0x60)\n mstore(0x60, 0xa0)\n writeString(0x80, p1)\n writeString(0xc0, p2)\n }\n _sendLogPayload(0x1c, 0xe4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n }\n }\n\n function log(uint256 p0, address p1, address p2) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n // Selector of `log(uint256,address,address)`.\n mstore(0x00, 0xbcfd9be0)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n }\n _sendLogPayload(0x1c, 0x64);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n }\n }\n\n function log(uint256 p0, address p1, bool p2) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n // Selector of `log(uint256,address,bool)`.\n mstore(0x00, 0x9b6ec042)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n }\n _sendLogPayload(0x1c, 0x64);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n }\n }\n\n function log(uint256 p0, address p1, uint256 p2) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n // Selector of `log(uint256,address,uint256)`.\n mstore(0x00, 0x5a9b5ed5)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n }\n _sendLogPayload(0x1c, 0x64);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n }\n }\n\n function log(uint256 p0, address p1, bytes32 p2) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n // Selector of `log(uint256,address,string)`.\n mstore(0x00, 0x63cb41f9)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, 0x60)\n writeString(0x80, p2)\n }\n _sendLogPayload(0x1c, 0xa4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n }\n }\n\n function log(uint256 p0, bool p1, address p2) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n // Selector of `log(uint256,bool,address)`.\n mstore(0x00, 0x35085f7b)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n }\n _sendLogPayload(0x1c, 0x64);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n }\n }\n\n function log(uint256 p0, bool p1, bool p2) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n // Selector of `log(uint256,bool,bool)`.\n mstore(0x00, 0x20718650)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n }\n _sendLogPayload(0x1c, 0x64);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n }\n }\n\n function log(uint256 p0, bool p1, uint256 p2) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n // Selector of `log(uint256,bool,uint256)`.\n mstore(0x00, 0x20098014)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n }\n _sendLogPayload(0x1c, 0x64);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n }\n }\n\n function log(uint256 p0, bool p1, bytes32 p2) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n // Selector of `log(uint256,bool,string)`.\n mstore(0x00, 0x85775021)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, 0x60)\n writeString(0x80, p2)\n }\n _sendLogPayload(0x1c, 0xa4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n }\n }\n\n function log(uint256 p0, uint256 p1, address p2) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n // Selector of `log(uint256,uint256,address)`.\n mstore(0x00, 0x5c96b331)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n }\n _sendLogPayload(0x1c, 0x64);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n }\n }\n\n function log(uint256 p0, uint256 p1, bool p2) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n // Selector of `log(uint256,uint256,bool)`.\n mstore(0x00, 0x4766da72)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n }\n _sendLogPayload(0x1c, 0x64);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n }\n }\n\n function log(uint256 p0, uint256 p1, uint256 p2) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n // Selector of `log(uint256,uint256,uint256)`.\n mstore(0x00, 0xd1ed7a3c)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n }\n _sendLogPayload(0x1c, 0x64);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n }\n }\n\n function log(uint256 p0, uint256 p1, bytes32 p2) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n // Selector of `log(uint256,uint256,string)`.\n mstore(0x00, 0x71d04af2)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, 0x60)\n writeString(0x80, p2)\n }\n _sendLogPayload(0x1c, 0xa4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n }\n }\n\n function log(uint256 p0, bytes32 p1, address p2) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n // Selector of `log(uint256,string,address)`.\n mstore(0x00, 0x7afac959)\n mstore(0x20, p0)\n mstore(0x40, 0x60)\n mstore(0x60, p2)\n writeString(0x80, p1)\n }\n _sendLogPayload(0x1c, 0xa4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n }\n }\n\n function log(uint256 p0, bytes32 p1, bool p2) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n // Selector of `log(uint256,string,bool)`.\n mstore(0x00, 0x4ceda75a)\n mstore(0x20, p0)\n mstore(0x40, 0x60)\n mstore(0x60, p2)\n writeString(0x80, p1)\n }\n _sendLogPayload(0x1c, 0xa4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n }\n }\n\n function log(uint256 p0, bytes32 p1, uint256 p2) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n // Selector of `log(uint256,string,uint256)`.\n mstore(0x00, 0x37aa7d4c)\n mstore(0x20, p0)\n mstore(0x40, 0x60)\n mstore(0x60, p2)\n writeString(0x80, p1)\n }\n _sendLogPayload(0x1c, 0xa4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n }\n }\n\n function log(uint256 p0, bytes32 p1, bytes32 p2) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n // Selector of `log(uint256,string,string)`.\n mstore(0x00, 0xb115611f)\n mstore(0x20, p0)\n mstore(0x40, 0x60)\n mstore(0x60, 0xa0)\n writeString(0x80, p1)\n writeString(0xc0, p2)\n }\n _sendLogPayload(0x1c, 0xe4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n }\n }\n\n function log(bytes32 p0, address p1, address p2) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n // Selector of `log(string,address,address)`.\n mstore(0x00, 0xfcec75e0)\n mstore(0x20, 0x60)\n mstore(0x40, p1)\n mstore(0x60, p2)\n writeString(0x80, p0)\n }\n _sendLogPayload(0x1c, 0xa4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n }\n }\n\n function log(bytes32 p0, address p1, bool p2) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n // Selector of `log(string,address,bool)`.\n mstore(0x00, 0xc91d5ed4)\n mstore(0x20, 0x60)\n mstore(0x40, p1)\n mstore(0x60, p2)\n writeString(0x80, p0)\n }\n _sendLogPayload(0x1c, 0xa4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n }\n }\n\n function log(bytes32 p0, address p1, uint256 p2) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n // Selector of `log(string,address,uint256)`.\n mstore(0x00, 0x0d26b925)\n mstore(0x20, 0x60)\n mstore(0x40, p1)\n mstore(0x60, p2)\n writeString(0x80, p0)\n }\n _sendLogPayload(0x1c, 0xa4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n }\n }\n\n function log(bytes32 p0, address p1, bytes32 p2) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n // Selector of `log(string,address,string)`.\n mstore(0x00, 0xe0e9ad4f)\n mstore(0x20, 0x60)\n mstore(0x40, p1)\n mstore(0x60, 0xa0)\n writeString(0x80, p0)\n writeString(0xc0, p2)\n }\n _sendLogPayload(0x1c, 0xe4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n }\n }\n\n function log(bytes32 p0, bool p1, address p2) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n // Selector of `log(string,bool,address)`.\n mstore(0x00, 0x932bbb38)\n mstore(0x20, 0x60)\n mstore(0x40, p1)\n mstore(0x60, p2)\n writeString(0x80, p0)\n }\n _sendLogPayload(0x1c, 0xa4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n }\n }\n\n function log(bytes32 p0, bool p1, bool p2) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n // Selector of `log(string,bool,bool)`.\n mstore(0x00, 0x850b7ad6)\n mstore(0x20, 0x60)\n mstore(0x40, p1)\n mstore(0x60, p2)\n writeString(0x80, p0)\n }\n _sendLogPayload(0x1c, 0xa4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n }\n }\n\n function log(bytes32 p0, bool p1, uint256 p2) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n // Selector of `log(string,bool,uint256)`.\n mstore(0x00, 0xc95958d6)\n mstore(0x20, 0x60)\n mstore(0x40, p1)\n mstore(0x60, p2)\n writeString(0x80, p0)\n }\n _sendLogPayload(0x1c, 0xa4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n }\n }\n\n function log(bytes32 p0, bool p1, bytes32 p2) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n // Selector of `log(string,bool,string)`.\n mstore(0x00, 0xe298f47d)\n mstore(0x20, 0x60)\n mstore(0x40, p1)\n mstore(0x60, 0xa0)\n writeString(0x80, p0)\n writeString(0xc0, p2)\n }\n _sendLogPayload(0x1c, 0xe4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n }\n }\n\n function log(bytes32 p0, uint256 p1, address p2) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n // Selector of `log(string,uint256,address)`.\n mstore(0x00, 0x1c7ec448)\n mstore(0x20, 0x60)\n mstore(0x40, p1)\n mstore(0x60, p2)\n writeString(0x80, p0)\n }\n _sendLogPayload(0x1c, 0xa4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n }\n }\n\n function log(bytes32 p0, uint256 p1, bool p2) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n // Selector of `log(string,uint256,bool)`.\n mstore(0x00, 0xca7733b1)\n mstore(0x20, 0x60)\n mstore(0x40, p1)\n mstore(0x60, p2)\n writeString(0x80, p0)\n }\n _sendLogPayload(0x1c, 0xa4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n }\n }\n\n function log(bytes32 p0, uint256 p1, uint256 p2) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n // Selector of `log(string,uint256,uint256)`.\n mstore(0x00, 0xca47c4eb)\n mstore(0x20, 0x60)\n mstore(0x40, p1)\n mstore(0x60, p2)\n writeString(0x80, p0)\n }\n _sendLogPayload(0x1c, 0xa4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n }\n }\n\n function log(bytes32 p0, uint256 p1, bytes32 p2) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n // Selector of `log(string,uint256,string)`.\n mstore(0x00, 0x5970e089)\n mstore(0x20, 0x60)\n mstore(0x40, p1)\n mstore(0x60, 0xa0)\n writeString(0x80, p0)\n writeString(0xc0, p2)\n }\n _sendLogPayload(0x1c, 0xe4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n }\n }\n\n function log(bytes32 p0, bytes32 p1, address p2) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n // Selector of `log(string,string,address)`.\n mstore(0x00, 0x95ed0195)\n mstore(0x20, 0x60)\n mstore(0x40, 0xa0)\n mstore(0x60, p2)\n writeString(0x80, p0)\n writeString(0xc0, p1)\n }\n _sendLogPayload(0x1c, 0xe4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n }\n }\n\n function log(bytes32 p0, bytes32 p1, bool p2) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n // Selector of `log(string,string,bool)`.\n mstore(0x00, 0xb0e0f9b5)\n mstore(0x20, 0x60)\n mstore(0x40, 0xa0)\n mstore(0x60, p2)\n writeString(0x80, p0)\n writeString(0xc0, p1)\n }\n _sendLogPayload(0x1c, 0xe4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n }\n }\n\n function log(bytes32 p0, bytes32 p1, uint256 p2) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n // Selector of `log(string,string,uint256)`.\n mstore(0x00, 0x5821efa1)\n mstore(0x20, 0x60)\n mstore(0x40, 0xa0)\n mstore(0x60, p2)\n writeString(0x80, p0)\n writeString(0xc0, p1)\n }\n _sendLogPayload(0x1c, 0xe4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n }\n }\n\n function log(bytes32 p0, bytes32 p1, bytes32 p2) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n bytes32 m9;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n m9 := mload(0x120)\n // Selector of `log(string,string,string)`.\n mstore(0x00, 0x2ced7cef)\n mstore(0x20, 0x60)\n mstore(0x40, 0xa0)\n mstore(0x60, 0xe0)\n writeString(0x80, p0)\n writeString(0xc0, p1)\n writeString(0x100, p2)\n }\n _sendLogPayload(0x1c, 0x124);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n mstore(0x120, m9)\n }\n }\n\n function log(address p0, address p1, address p2, address p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(address,address,address,address)`.\n mstore(0x00, 0x665bf134)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(address p0, address p1, address p2, bool p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(address,address,address,bool)`.\n mstore(0x00, 0x0e378994)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(address p0, address p1, address p2, uint256 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(address,address,address,uint256)`.\n mstore(0x00, 0x94250d77)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(address p0, address p1, address p2, bytes32 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(address,address,address,string)`.\n mstore(0x00, 0xf808da20)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, 0x80)\n writeString(0xa0, p3)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(address p0, address p1, bool p2, address p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(address,address,bool,address)`.\n mstore(0x00, 0x9f1bc36e)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(address p0, address p1, bool p2, bool p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(address,address,bool,bool)`.\n mstore(0x00, 0x2cd4134a)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(address p0, address p1, bool p2, uint256 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(address,address,bool,uint256)`.\n mstore(0x00, 0x3971e78c)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(address p0, address p1, bool p2, bytes32 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(address,address,bool,string)`.\n mstore(0x00, 0xaa6540c8)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, 0x80)\n writeString(0xa0, p3)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(address p0, address p1, uint256 p2, address p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(address,address,uint256,address)`.\n mstore(0x00, 0x8da6def5)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(address p0, address p1, uint256 p2, bool p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(address,address,uint256,bool)`.\n mstore(0x00, 0x9b4254e2)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(address p0, address p1, uint256 p2, uint256 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(address,address,uint256,uint256)`.\n mstore(0x00, 0xbe553481)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(address p0, address p1, uint256 p2, bytes32 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(address,address,uint256,string)`.\n mstore(0x00, 0xfdb4f990)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, 0x80)\n writeString(0xa0, p3)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(address p0, address p1, bytes32 p2, address p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(address,address,string,address)`.\n mstore(0x00, 0x8f736d16)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, 0x80)\n mstore(0x80, p3)\n writeString(0xa0, p2)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(address p0, address p1, bytes32 p2, bool p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(address,address,string,bool)`.\n mstore(0x00, 0x6f1a594e)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, 0x80)\n mstore(0x80, p3)\n writeString(0xa0, p2)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(address p0, address p1, bytes32 p2, uint256 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(address,address,string,uint256)`.\n mstore(0x00, 0xef1cefe7)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, 0x80)\n mstore(0x80, p3)\n writeString(0xa0, p2)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(address p0, address p1, bytes32 p2, bytes32 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n // Selector of `log(address,address,string,string)`.\n mstore(0x00, 0x21bdaf25)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, 0x80)\n mstore(0x80, 0xc0)\n writeString(0xa0, p2)\n writeString(0xe0, p3)\n }\n _sendLogPayload(0x1c, 0x104);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n }\n }\n\n function log(address p0, bool p1, address p2, address p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(address,bool,address,address)`.\n mstore(0x00, 0x660375dd)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(address p0, bool p1, address p2, bool p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(address,bool,address,bool)`.\n mstore(0x00, 0xa6f50b0f)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(address p0, bool p1, address p2, uint256 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(address,bool,address,uint256)`.\n mstore(0x00, 0xa75c59de)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(address p0, bool p1, address p2, bytes32 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(address,bool,address,string)`.\n mstore(0x00, 0x2dd778e6)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, 0x80)\n writeString(0xa0, p3)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(address p0, bool p1, bool p2, address p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(address,bool,bool,address)`.\n mstore(0x00, 0xcf394485)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(address p0, bool p1, bool p2, bool p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(address,bool,bool,bool)`.\n mstore(0x00, 0xcac43479)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(address p0, bool p1, bool p2, uint256 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(address,bool,bool,uint256)`.\n mstore(0x00, 0x8c4e5de6)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(address p0, bool p1, bool p2, bytes32 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(address,bool,bool,string)`.\n mstore(0x00, 0xdfc4a2e8)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, 0x80)\n writeString(0xa0, p3)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(address p0, bool p1, uint256 p2, address p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(address,bool,uint256,address)`.\n mstore(0x00, 0xccf790a1)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(address p0, bool p1, uint256 p2, bool p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(address,bool,uint256,bool)`.\n mstore(0x00, 0xc4643e20)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(address p0, bool p1, uint256 p2, uint256 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(address,bool,uint256,uint256)`.\n mstore(0x00, 0x386ff5f4)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(address p0, bool p1, uint256 p2, bytes32 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(address,bool,uint256,string)`.\n mstore(0x00, 0x0aa6cfad)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, 0x80)\n writeString(0xa0, p3)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(address p0, bool p1, bytes32 p2, address p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(address,bool,string,address)`.\n mstore(0x00, 0x19fd4956)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, 0x80)\n mstore(0x80, p3)\n writeString(0xa0, p2)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(address p0, bool p1, bytes32 p2, bool p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(address,bool,string,bool)`.\n mstore(0x00, 0x50ad461d)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, 0x80)\n mstore(0x80, p3)\n writeString(0xa0, p2)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(address p0, bool p1, bytes32 p2, uint256 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(address,bool,string,uint256)`.\n mstore(0x00, 0x80e6a20b)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, 0x80)\n mstore(0x80, p3)\n writeString(0xa0, p2)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(address p0, bool p1, bytes32 p2, bytes32 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n // Selector of `log(address,bool,string,string)`.\n mstore(0x00, 0x475c5c33)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, 0x80)\n mstore(0x80, 0xc0)\n writeString(0xa0, p2)\n writeString(0xe0, p3)\n }\n _sendLogPayload(0x1c, 0x104);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n }\n }\n\n function log(address p0, uint256 p1, address p2, address p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(address,uint256,address,address)`.\n mstore(0x00, 0x478d1c62)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(address p0, uint256 p1, address p2, bool p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(address,uint256,address,bool)`.\n mstore(0x00, 0xa1bcc9b3)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(address p0, uint256 p1, address p2, uint256 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(address,uint256,address,uint256)`.\n mstore(0x00, 0x100f650e)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(address p0, uint256 p1, address p2, bytes32 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(address,uint256,address,string)`.\n mstore(0x00, 0x1da986ea)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, 0x80)\n writeString(0xa0, p3)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(address p0, uint256 p1, bool p2, address p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(address,uint256,bool,address)`.\n mstore(0x00, 0xa31bfdcc)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(address p0, uint256 p1, bool p2, bool p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(address,uint256,bool,bool)`.\n mstore(0x00, 0x3bf5e537)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(address p0, uint256 p1, bool p2, uint256 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(address,uint256,bool,uint256)`.\n mstore(0x00, 0x22f6b999)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(address p0, uint256 p1, bool p2, bytes32 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(address,uint256,bool,string)`.\n mstore(0x00, 0xc5ad85f9)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, 0x80)\n writeString(0xa0, p3)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(address p0, uint256 p1, uint256 p2, address p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(address,uint256,uint256,address)`.\n mstore(0x00, 0x20e3984d)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(address p0, uint256 p1, uint256 p2, bool p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(address,uint256,uint256,bool)`.\n mstore(0x00, 0x66f1bc67)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(address p0, uint256 p1, uint256 p2, uint256 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(address,uint256,uint256,uint256)`.\n mstore(0x00, 0x34f0e636)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(address p0, uint256 p1, uint256 p2, bytes32 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(address,uint256,uint256,string)`.\n mstore(0x00, 0x4a28c017)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, 0x80)\n writeString(0xa0, p3)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(address p0, uint256 p1, bytes32 p2, address p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(address,uint256,string,address)`.\n mstore(0x00, 0x5c430d47)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, 0x80)\n mstore(0x80, p3)\n writeString(0xa0, p2)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(address p0, uint256 p1, bytes32 p2, bool p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(address,uint256,string,bool)`.\n mstore(0x00, 0xcf18105c)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, 0x80)\n mstore(0x80, p3)\n writeString(0xa0, p2)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(address p0, uint256 p1, bytes32 p2, uint256 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(address,uint256,string,uint256)`.\n mstore(0x00, 0xbf01f891)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, 0x80)\n mstore(0x80, p3)\n writeString(0xa0, p2)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(address p0, uint256 p1, bytes32 p2, bytes32 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n // Selector of `log(address,uint256,string,string)`.\n mstore(0x00, 0x88a8c406)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, 0x80)\n mstore(0x80, 0xc0)\n writeString(0xa0, p2)\n writeString(0xe0, p3)\n }\n _sendLogPayload(0x1c, 0x104);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n }\n }\n\n function log(address p0, bytes32 p1, address p2, address p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(address,string,address,address)`.\n mstore(0x00, 0x0d36fa20)\n mstore(0x20, p0)\n mstore(0x40, 0x80)\n mstore(0x60, p2)\n mstore(0x80, p3)\n writeString(0xa0, p1)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(address p0, bytes32 p1, address p2, bool p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(address,string,address,bool)`.\n mstore(0x00, 0x0df12b76)\n mstore(0x20, p0)\n mstore(0x40, 0x80)\n mstore(0x60, p2)\n mstore(0x80, p3)\n writeString(0xa0, p1)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(address p0, bytes32 p1, address p2, uint256 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(address,string,address,uint256)`.\n mstore(0x00, 0x457fe3cf)\n mstore(0x20, p0)\n mstore(0x40, 0x80)\n mstore(0x60, p2)\n mstore(0x80, p3)\n writeString(0xa0, p1)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(address p0, bytes32 p1, address p2, bytes32 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n // Selector of `log(address,string,address,string)`.\n mstore(0x00, 0xf7e36245)\n mstore(0x20, p0)\n mstore(0x40, 0x80)\n mstore(0x60, p2)\n mstore(0x80, 0xc0)\n writeString(0xa0, p1)\n writeString(0xe0, p3)\n }\n _sendLogPayload(0x1c, 0x104);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n }\n }\n\n function log(address p0, bytes32 p1, bool p2, address p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(address,string,bool,address)`.\n mstore(0x00, 0x205871c2)\n mstore(0x20, p0)\n mstore(0x40, 0x80)\n mstore(0x60, p2)\n mstore(0x80, p3)\n writeString(0xa0, p1)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(address p0, bytes32 p1, bool p2, bool p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(address,string,bool,bool)`.\n mstore(0x00, 0x5f1d5c9f)\n mstore(0x20, p0)\n mstore(0x40, 0x80)\n mstore(0x60, p2)\n mstore(0x80, p3)\n writeString(0xa0, p1)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(address p0, bytes32 p1, bool p2, uint256 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(address,string,bool,uint256)`.\n mstore(0x00, 0x515e38b6)\n mstore(0x20, p0)\n mstore(0x40, 0x80)\n mstore(0x60, p2)\n mstore(0x80, p3)\n writeString(0xa0, p1)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(address p0, bytes32 p1, bool p2, bytes32 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n // Selector of `log(address,string,bool,string)`.\n mstore(0x00, 0xbc0b61fe)\n mstore(0x20, p0)\n mstore(0x40, 0x80)\n mstore(0x60, p2)\n mstore(0x80, 0xc0)\n writeString(0xa0, p1)\n writeString(0xe0, p3)\n }\n _sendLogPayload(0x1c, 0x104);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n }\n }\n\n function log(address p0, bytes32 p1, uint256 p2, address p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(address,string,uint256,address)`.\n mstore(0x00, 0x63183678)\n mstore(0x20, p0)\n mstore(0x40, 0x80)\n mstore(0x60, p2)\n mstore(0x80, p3)\n writeString(0xa0, p1)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(address p0, bytes32 p1, uint256 p2, bool p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(address,string,uint256,bool)`.\n mstore(0x00, 0x0ef7e050)\n mstore(0x20, p0)\n mstore(0x40, 0x80)\n mstore(0x60, p2)\n mstore(0x80, p3)\n writeString(0xa0, p1)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(address p0, bytes32 p1, uint256 p2, uint256 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(address,string,uint256,uint256)`.\n mstore(0x00, 0x1dc8e1b8)\n mstore(0x20, p0)\n mstore(0x40, 0x80)\n mstore(0x60, p2)\n mstore(0x80, p3)\n writeString(0xa0, p1)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(address p0, bytes32 p1, uint256 p2, bytes32 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n // Selector of `log(address,string,uint256,string)`.\n mstore(0x00, 0x448830a8)\n mstore(0x20, p0)\n mstore(0x40, 0x80)\n mstore(0x60, p2)\n mstore(0x80, 0xc0)\n writeString(0xa0, p1)\n writeString(0xe0, p3)\n }\n _sendLogPayload(0x1c, 0x104);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n }\n }\n\n function log(address p0, bytes32 p1, bytes32 p2, address p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n // Selector of `log(address,string,string,address)`.\n mstore(0x00, 0xa04e2f87)\n mstore(0x20, p0)\n mstore(0x40, 0x80)\n mstore(0x60, 0xc0)\n mstore(0x80, p3)\n writeString(0xa0, p1)\n writeString(0xe0, p2)\n }\n _sendLogPayload(0x1c, 0x104);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n }\n }\n\n function log(address p0, bytes32 p1, bytes32 p2, bool p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n // Selector of `log(address,string,string,bool)`.\n mstore(0x00, 0x35a5071f)\n mstore(0x20, p0)\n mstore(0x40, 0x80)\n mstore(0x60, 0xc0)\n mstore(0x80, p3)\n writeString(0xa0, p1)\n writeString(0xe0, p2)\n }\n _sendLogPayload(0x1c, 0x104);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n }\n }\n\n function log(address p0, bytes32 p1, bytes32 p2, uint256 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n // Selector of `log(address,string,string,uint256)`.\n mstore(0x00, 0x159f8927)\n mstore(0x20, p0)\n mstore(0x40, 0x80)\n mstore(0x60, 0xc0)\n mstore(0x80, p3)\n writeString(0xa0, p1)\n writeString(0xe0, p2)\n }\n _sendLogPayload(0x1c, 0x104);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n }\n }\n\n function log(address p0, bytes32 p1, bytes32 p2, bytes32 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n bytes32 m9;\n bytes32 m10;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n m9 := mload(0x120)\n m10 := mload(0x140)\n // Selector of `log(address,string,string,string)`.\n mstore(0x00, 0x5d02c50b)\n mstore(0x20, p0)\n mstore(0x40, 0x80)\n mstore(0x60, 0xc0)\n mstore(0x80, 0x100)\n writeString(0xa0, p1)\n writeString(0xe0, p2)\n writeString(0x120, p3)\n }\n _sendLogPayload(0x1c, 0x144);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n mstore(0x120, m9)\n mstore(0x140, m10)\n }\n }\n\n function log(bool p0, address p1, address p2, address p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(bool,address,address,address)`.\n mstore(0x00, 0x1d14d001)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(bool p0, address p1, address p2, bool p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(bool,address,address,bool)`.\n mstore(0x00, 0x46600be0)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(bool p0, address p1, address p2, uint256 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(bool,address,address,uint256)`.\n mstore(0x00, 0x0c66d1be)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(bool p0, address p1, address p2, bytes32 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(bool,address,address,string)`.\n mstore(0x00, 0xd812a167)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, 0x80)\n writeString(0xa0, p3)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(bool p0, address p1, bool p2, address p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(bool,address,bool,address)`.\n mstore(0x00, 0x1c41a336)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(bool p0, address p1, bool p2, bool p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(bool,address,bool,bool)`.\n mstore(0x00, 0x6a9c478b)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(bool p0, address p1, bool p2, uint256 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(bool,address,bool,uint256)`.\n mstore(0x00, 0x07831502)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(bool p0, address p1, bool p2, bytes32 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(bool,address,bool,string)`.\n mstore(0x00, 0x4a66cb34)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, 0x80)\n writeString(0xa0, p3)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(bool p0, address p1, uint256 p2, address p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(bool,address,uint256,address)`.\n mstore(0x00, 0x136b05dd)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(bool p0, address p1, uint256 p2, bool p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(bool,address,uint256,bool)`.\n mstore(0x00, 0xd6019f1c)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(bool p0, address p1, uint256 p2, uint256 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(bool,address,uint256,uint256)`.\n mstore(0x00, 0x7bf181a1)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(bool p0, address p1, uint256 p2, bytes32 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(bool,address,uint256,string)`.\n mstore(0x00, 0x51f09ff8)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, 0x80)\n writeString(0xa0, p3)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(bool p0, address p1, bytes32 p2, address p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(bool,address,string,address)`.\n mstore(0x00, 0x6f7c603e)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, 0x80)\n mstore(0x80, p3)\n writeString(0xa0, p2)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(bool p0, address p1, bytes32 p2, bool p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(bool,address,string,bool)`.\n mstore(0x00, 0xe2bfd60b)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, 0x80)\n mstore(0x80, p3)\n writeString(0xa0, p2)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(bool p0, address p1, bytes32 p2, uint256 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(bool,address,string,uint256)`.\n mstore(0x00, 0xc21f64c7)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, 0x80)\n mstore(0x80, p3)\n writeString(0xa0, p2)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(bool p0, address p1, bytes32 p2, bytes32 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n // Selector of `log(bool,address,string,string)`.\n mstore(0x00, 0xa73c1db6)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, 0x80)\n mstore(0x80, 0xc0)\n writeString(0xa0, p2)\n writeString(0xe0, p3)\n }\n _sendLogPayload(0x1c, 0x104);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n }\n }\n\n function log(bool p0, bool p1, address p2, address p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(bool,bool,address,address)`.\n mstore(0x00, 0xf4880ea4)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(bool p0, bool p1, address p2, bool p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(bool,bool,address,bool)`.\n mstore(0x00, 0xc0a302d8)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(bool p0, bool p1, address p2, uint256 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(bool,bool,address,uint256)`.\n mstore(0x00, 0x4c123d57)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(bool p0, bool p1, address p2, bytes32 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(bool,bool,address,string)`.\n mstore(0x00, 0xa0a47963)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, 0x80)\n writeString(0xa0, p3)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(bool p0, bool p1, bool p2, address p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(bool,bool,bool,address)`.\n mstore(0x00, 0x8c329b1a)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(bool p0, bool p1, bool p2, bool p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(bool,bool,bool,bool)`.\n mstore(0x00, 0x3b2a5ce0)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(bool p0, bool p1, bool p2, uint256 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(bool,bool,bool,uint256)`.\n mstore(0x00, 0x6d7045c1)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(bool p0, bool p1, bool p2, bytes32 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(bool,bool,bool,string)`.\n mstore(0x00, 0x2ae408d4)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, 0x80)\n writeString(0xa0, p3)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(bool p0, bool p1, uint256 p2, address p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(bool,bool,uint256,address)`.\n mstore(0x00, 0x54a7a9a0)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(bool p0, bool p1, uint256 p2, bool p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(bool,bool,uint256,bool)`.\n mstore(0x00, 0x619e4d0e)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(bool p0, bool p1, uint256 p2, uint256 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(bool,bool,uint256,uint256)`.\n mstore(0x00, 0x0bb00eab)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(bool p0, bool p1, uint256 p2, bytes32 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(bool,bool,uint256,string)`.\n mstore(0x00, 0x7dd4d0e0)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, 0x80)\n writeString(0xa0, p3)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(bool p0, bool p1, bytes32 p2, address p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(bool,bool,string,address)`.\n mstore(0x00, 0xf9ad2b89)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, 0x80)\n mstore(0x80, p3)\n writeString(0xa0, p2)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(bool p0, bool p1, bytes32 p2, bool p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(bool,bool,string,bool)`.\n mstore(0x00, 0xb857163a)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, 0x80)\n mstore(0x80, p3)\n writeString(0xa0, p2)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(bool p0, bool p1, bytes32 p2, uint256 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(bool,bool,string,uint256)`.\n mstore(0x00, 0xe3a9ca2f)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, 0x80)\n mstore(0x80, p3)\n writeString(0xa0, p2)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(bool p0, bool p1, bytes32 p2, bytes32 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n // Selector of `log(bool,bool,string,string)`.\n mstore(0x00, 0x6d1e8751)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, 0x80)\n mstore(0x80, 0xc0)\n writeString(0xa0, p2)\n writeString(0xe0, p3)\n }\n _sendLogPayload(0x1c, 0x104);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n }\n }\n\n function log(bool p0, uint256 p1, address p2, address p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(bool,uint256,address,address)`.\n mstore(0x00, 0x26f560a8)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(bool p0, uint256 p1, address p2, bool p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(bool,uint256,address,bool)`.\n mstore(0x00, 0xb4c314ff)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(bool p0, uint256 p1, address p2, uint256 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(bool,uint256,address,uint256)`.\n mstore(0x00, 0x1537dc87)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(bool p0, uint256 p1, address p2, bytes32 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(bool,uint256,address,string)`.\n mstore(0x00, 0x1bb3b09a)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, 0x80)\n writeString(0xa0, p3)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(bool p0, uint256 p1, bool p2, address p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(bool,uint256,bool,address)`.\n mstore(0x00, 0x9acd3616)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(bool p0, uint256 p1, bool p2, bool p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(bool,uint256,bool,bool)`.\n mstore(0x00, 0xceb5f4d7)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(bool p0, uint256 p1, bool p2, uint256 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(bool,uint256,bool,uint256)`.\n mstore(0x00, 0x7f9bbca2)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(bool p0, uint256 p1, bool p2, bytes32 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(bool,uint256,bool,string)`.\n mstore(0x00, 0x9143dbb1)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, 0x80)\n writeString(0xa0, p3)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(bool p0, uint256 p1, uint256 p2, address p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(bool,uint256,uint256,address)`.\n mstore(0x00, 0x00dd87b9)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(bool p0, uint256 p1, uint256 p2, bool p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(bool,uint256,uint256,bool)`.\n mstore(0x00, 0xbe984353)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(bool p0, uint256 p1, uint256 p2, uint256 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(bool,uint256,uint256,uint256)`.\n mstore(0x00, 0x374bb4b2)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(bool p0, uint256 p1, uint256 p2, bytes32 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(bool,uint256,uint256,string)`.\n mstore(0x00, 0x8e69fb5d)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, 0x80)\n writeString(0xa0, p3)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(bool p0, uint256 p1, bytes32 p2, address p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(bool,uint256,string,address)`.\n mstore(0x00, 0xfedd1fff)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, 0x80)\n mstore(0x80, p3)\n writeString(0xa0, p2)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(bool p0, uint256 p1, bytes32 p2, bool p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(bool,uint256,string,bool)`.\n mstore(0x00, 0xe5e70b2b)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, 0x80)\n mstore(0x80, p3)\n writeString(0xa0, p2)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(bool p0, uint256 p1, bytes32 p2, uint256 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(bool,uint256,string,uint256)`.\n mstore(0x00, 0x6a1199e2)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, 0x80)\n mstore(0x80, p3)\n writeString(0xa0, p2)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(bool p0, uint256 p1, bytes32 p2, bytes32 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n // Selector of `log(bool,uint256,string,string)`.\n mstore(0x00, 0xf5bc2249)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, 0x80)\n mstore(0x80, 0xc0)\n writeString(0xa0, p2)\n writeString(0xe0, p3)\n }\n _sendLogPayload(0x1c, 0x104);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n }\n }\n\n function log(bool p0, bytes32 p1, address p2, address p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(bool,string,address,address)`.\n mstore(0x00, 0x2b2b18dc)\n mstore(0x20, p0)\n mstore(0x40, 0x80)\n mstore(0x60, p2)\n mstore(0x80, p3)\n writeString(0xa0, p1)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(bool p0, bytes32 p1, address p2, bool p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(bool,string,address,bool)`.\n mstore(0x00, 0x6dd434ca)\n mstore(0x20, p0)\n mstore(0x40, 0x80)\n mstore(0x60, p2)\n mstore(0x80, p3)\n writeString(0xa0, p1)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(bool p0, bytes32 p1, address p2, uint256 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(bool,string,address,uint256)`.\n mstore(0x00, 0xa5cada94)\n mstore(0x20, p0)\n mstore(0x40, 0x80)\n mstore(0x60, p2)\n mstore(0x80, p3)\n writeString(0xa0, p1)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(bool p0, bytes32 p1, address p2, bytes32 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n // Selector of `log(bool,string,address,string)`.\n mstore(0x00, 0x12d6c788)\n mstore(0x20, p0)\n mstore(0x40, 0x80)\n mstore(0x60, p2)\n mstore(0x80, 0xc0)\n writeString(0xa0, p1)\n writeString(0xe0, p3)\n }\n _sendLogPayload(0x1c, 0x104);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n }\n }\n\n function log(bool p0, bytes32 p1, bool p2, address p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(bool,string,bool,address)`.\n mstore(0x00, 0x538e06ab)\n mstore(0x20, p0)\n mstore(0x40, 0x80)\n mstore(0x60, p2)\n mstore(0x80, p3)\n writeString(0xa0, p1)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(bool p0, bytes32 p1, bool p2, bool p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(bool,string,bool,bool)`.\n mstore(0x00, 0xdc5e935b)\n mstore(0x20, p0)\n mstore(0x40, 0x80)\n mstore(0x60, p2)\n mstore(0x80, p3)\n writeString(0xa0, p1)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(bool p0, bytes32 p1, bool p2, uint256 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(bool,string,bool,uint256)`.\n mstore(0x00, 0x1606a393)\n mstore(0x20, p0)\n mstore(0x40, 0x80)\n mstore(0x60, p2)\n mstore(0x80, p3)\n writeString(0xa0, p1)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(bool p0, bytes32 p1, bool p2, bytes32 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n // Selector of `log(bool,string,bool,string)`.\n mstore(0x00, 0x483d0416)\n mstore(0x20, p0)\n mstore(0x40, 0x80)\n mstore(0x60, p2)\n mstore(0x80, 0xc0)\n writeString(0xa0, p1)\n writeString(0xe0, p3)\n }\n _sendLogPayload(0x1c, 0x104);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n }\n }\n\n function log(bool p0, bytes32 p1, uint256 p2, address p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(bool,string,uint256,address)`.\n mstore(0x00, 0x1596a1ce)\n mstore(0x20, p0)\n mstore(0x40, 0x80)\n mstore(0x60, p2)\n mstore(0x80, p3)\n writeString(0xa0, p1)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(bool p0, bytes32 p1, uint256 p2, bool p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(bool,string,uint256,bool)`.\n mstore(0x00, 0x6b0e5d53)\n mstore(0x20, p0)\n mstore(0x40, 0x80)\n mstore(0x60, p2)\n mstore(0x80, p3)\n writeString(0xa0, p1)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(bool p0, bytes32 p1, uint256 p2, uint256 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(bool,string,uint256,uint256)`.\n mstore(0x00, 0x28863fcb)\n mstore(0x20, p0)\n mstore(0x40, 0x80)\n mstore(0x60, p2)\n mstore(0x80, p3)\n writeString(0xa0, p1)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(bool p0, bytes32 p1, uint256 p2, bytes32 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n // Selector of `log(bool,string,uint256,string)`.\n mstore(0x00, 0x1ad96de6)\n mstore(0x20, p0)\n mstore(0x40, 0x80)\n mstore(0x60, p2)\n mstore(0x80, 0xc0)\n writeString(0xa0, p1)\n writeString(0xe0, p3)\n }\n _sendLogPayload(0x1c, 0x104);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n }\n }\n\n function log(bool p0, bytes32 p1, bytes32 p2, address p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n // Selector of `log(bool,string,string,address)`.\n mstore(0x00, 0x97d394d8)\n mstore(0x20, p0)\n mstore(0x40, 0x80)\n mstore(0x60, 0xc0)\n mstore(0x80, p3)\n writeString(0xa0, p1)\n writeString(0xe0, p2)\n }\n _sendLogPayload(0x1c, 0x104);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n }\n }\n\n function log(bool p0, bytes32 p1, bytes32 p2, bool p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n // Selector of `log(bool,string,string,bool)`.\n mstore(0x00, 0x1e4b87e5)\n mstore(0x20, p0)\n mstore(0x40, 0x80)\n mstore(0x60, 0xc0)\n mstore(0x80, p3)\n writeString(0xa0, p1)\n writeString(0xe0, p2)\n }\n _sendLogPayload(0x1c, 0x104);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n }\n }\n\n function log(bool p0, bytes32 p1, bytes32 p2, uint256 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n // Selector of `log(bool,string,string,uint256)`.\n mstore(0x00, 0x7be0c3eb)\n mstore(0x20, p0)\n mstore(0x40, 0x80)\n mstore(0x60, 0xc0)\n mstore(0x80, p3)\n writeString(0xa0, p1)\n writeString(0xe0, p2)\n }\n _sendLogPayload(0x1c, 0x104);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n }\n }\n\n function log(bool p0, bytes32 p1, bytes32 p2, bytes32 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n bytes32 m9;\n bytes32 m10;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n m9 := mload(0x120)\n m10 := mload(0x140)\n // Selector of `log(bool,string,string,string)`.\n mstore(0x00, 0x1762e32a)\n mstore(0x20, p0)\n mstore(0x40, 0x80)\n mstore(0x60, 0xc0)\n mstore(0x80, 0x100)\n writeString(0xa0, p1)\n writeString(0xe0, p2)\n writeString(0x120, p3)\n }\n _sendLogPayload(0x1c, 0x144);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n mstore(0x120, m9)\n mstore(0x140, m10)\n }\n }\n\n function log(uint256 p0, address p1, address p2, address p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(uint256,address,address,address)`.\n mstore(0x00, 0x2488b414)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(uint256 p0, address p1, address p2, bool p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(uint256,address,address,bool)`.\n mstore(0x00, 0x091ffaf5)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(uint256 p0, address p1, address p2, uint256 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(uint256,address,address,uint256)`.\n mstore(0x00, 0x736efbb6)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(uint256 p0, address p1, address p2, bytes32 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(uint256,address,address,string)`.\n mstore(0x00, 0x031c6f73)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, 0x80)\n writeString(0xa0, p3)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(uint256 p0, address p1, bool p2, address p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(uint256,address,bool,address)`.\n mstore(0x00, 0xef72c513)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(uint256 p0, address p1, bool p2, bool p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(uint256,address,bool,bool)`.\n mstore(0x00, 0xe351140f)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(uint256 p0, address p1, bool p2, uint256 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(uint256,address,bool,uint256)`.\n mstore(0x00, 0x5abd992a)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(uint256 p0, address p1, bool p2, bytes32 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(uint256,address,bool,string)`.\n mstore(0x00, 0x90fb06aa)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, 0x80)\n writeString(0xa0, p3)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(uint256 p0, address p1, uint256 p2, address p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(uint256,address,uint256,address)`.\n mstore(0x00, 0x15c127b5)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(uint256 p0, address p1, uint256 p2, bool p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(uint256,address,uint256,bool)`.\n mstore(0x00, 0x5f743a7c)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(uint256 p0, address p1, uint256 p2, uint256 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(uint256,address,uint256,uint256)`.\n mstore(0x00, 0x0c9cd9c1)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(uint256 p0, address p1, uint256 p2, bytes32 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(uint256,address,uint256,string)`.\n mstore(0x00, 0xddb06521)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, 0x80)\n writeString(0xa0, p3)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(uint256 p0, address p1, bytes32 p2, address p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(uint256,address,string,address)`.\n mstore(0x00, 0x9cba8fff)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, 0x80)\n mstore(0x80, p3)\n writeString(0xa0, p2)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(uint256 p0, address p1, bytes32 p2, bool p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(uint256,address,string,bool)`.\n mstore(0x00, 0xcc32ab07)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, 0x80)\n mstore(0x80, p3)\n writeString(0xa0, p2)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(uint256 p0, address p1, bytes32 p2, uint256 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(uint256,address,string,uint256)`.\n mstore(0x00, 0x46826b5d)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, 0x80)\n mstore(0x80, p3)\n writeString(0xa0, p2)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(uint256 p0, address p1, bytes32 p2, bytes32 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n // Selector of `log(uint256,address,string,string)`.\n mstore(0x00, 0x3e128ca3)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, 0x80)\n mstore(0x80, 0xc0)\n writeString(0xa0, p2)\n writeString(0xe0, p3)\n }\n _sendLogPayload(0x1c, 0x104);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n }\n }\n\n function log(uint256 p0, bool p1, address p2, address p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(uint256,bool,address,address)`.\n mstore(0x00, 0xa1ef4cbb)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(uint256 p0, bool p1, address p2, bool p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(uint256,bool,address,bool)`.\n mstore(0x00, 0x454d54a5)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(uint256 p0, bool p1, address p2, uint256 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(uint256,bool,address,uint256)`.\n mstore(0x00, 0x078287f5)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(uint256 p0, bool p1, address p2, bytes32 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(uint256,bool,address,string)`.\n mstore(0x00, 0xade052c7)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, 0x80)\n writeString(0xa0, p3)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(uint256 p0, bool p1, bool p2, address p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(uint256,bool,bool,address)`.\n mstore(0x00, 0x69640b59)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(uint256 p0, bool p1, bool p2, bool p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(uint256,bool,bool,bool)`.\n mstore(0x00, 0xb6f577a1)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(uint256 p0, bool p1, bool p2, uint256 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(uint256,bool,bool,uint256)`.\n mstore(0x00, 0x7464ce23)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(uint256 p0, bool p1, bool p2, bytes32 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(uint256,bool,bool,string)`.\n mstore(0x00, 0xdddb9561)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, 0x80)\n writeString(0xa0, p3)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(uint256 p0, bool p1, uint256 p2, address p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(uint256,bool,uint256,address)`.\n mstore(0x00, 0x88cb6041)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(uint256 p0, bool p1, uint256 p2, bool p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(uint256,bool,uint256,bool)`.\n mstore(0x00, 0x91a02e2a)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(uint256 p0, bool p1, uint256 p2, uint256 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(uint256,bool,uint256,uint256)`.\n mstore(0x00, 0xc6acc7a8)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(uint256 p0, bool p1, uint256 p2, bytes32 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(uint256,bool,uint256,string)`.\n mstore(0x00, 0xde03e774)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, 0x80)\n writeString(0xa0, p3)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(uint256 p0, bool p1, bytes32 p2, address p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(uint256,bool,string,address)`.\n mstore(0x00, 0xef529018)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, 0x80)\n mstore(0x80, p3)\n writeString(0xa0, p2)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(uint256 p0, bool p1, bytes32 p2, bool p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(uint256,bool,string,bool)`.\n mstore(0x00, 0xeb928d7f)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, 0x80)\n mstore(0x80, p3)\n writeString(0xa0, p2)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(uint256 p0, bool p1, bytes32 p2, uint256 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(uint256,bool,string,uint256)`.\n mstore(0x00, 0x2c1d0746)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, 0x80)\n mstore(0x80, p3)\n writeString(0xa0, p2)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(uint256 p0, bool p1, bytes32 p2, bytes32 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n // Selector of `log(uint256,bool,string,string)`.\n mstore(0x00, 0x68c8b8bd)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, 0x80)\n mstore(0x80, 0xc0)\n writeString(0xa0, p2)\n writeString(0xe0, p3)\n }\n _sendLogPayload(0x1c, 0x104);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n }\n }\n\n function log(uint256 p0, uint256 p1, address p2, address p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(uint256,uint256,address,address)`.\n mstore(0x00, 0x56a5d1b1)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(uint256 p0, uint256 p1, address p2, bool p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(uint256,uint256,address,bool)`.\n mstore(0x00, 0x15cac476)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(uint256 p0, uint256 p1, address p2, uint256 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(uint256,uint256,address,uint256)`.\n mstore(0x00, 0x88f6e4b2)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(uint256 p0, uint256 p1, address p2, bytes32 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(uint256,uint256,address,string)`.\n mstore(0x00, 0x6cde40b8)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, 0x80)\n writeString(0xa0, p3)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(uint256 p0, uint256 p1, bool p2, address p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(uint256,uint256,bool,address)`.\n mstore(0x00, 0x9a816a83)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(uint256 p0, uint256 p1, bool p2, bool p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(uint256,uint256,bool,bool)`.\n mstore(0x00, 0xab085ae6)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(uint256 p0, uint256 p1, bool p2, uint256 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(uint256,uint256,bool,uint256)`.\n mstore(0x00, 0xeb7f6fd2)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(uint256 p0, uint256 p1, bool p2, bytes32 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(uint256,uint256,bool,string)`.\n mstore(0x00, 0xa5b4fc99)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, 0x80)\n writeString(0xa0, p3)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(uint256 p0, uint256 p1, uint256 p2, address p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(uint256,uint256,uint256,address)`.\n mstore(0x00, 0xfa8185af)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(uint256 p0, uint256 p1, uint256 p2, bool p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(uint256,uint256,uint256,bool)`.\n mstore(0x00, 0xc598d185)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(uint256 p0, uint256 p1, uint256 p2, uint256 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(uint256,uint256,uint256,uint256)`.\n mstore(0x00, 0x193fb800)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(uint256 p0, uint256 p1, uint256 p2, bytes32 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(uint256,uint256,uint256,string)`.\n mstore(0x00, 0x59cfcbe3)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, 0x80)\n writeString(0xa0, p3)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(uint256 p0, uint256 p1, bytes32 p2, address p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(uint256,uint256,string,address)`.\n mstore(0x00, 0x42d21db7)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, 0x80)\n mstore(0x80, p3)\n writeString(0xa0, p2)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(uint256 p0, uint256 p1, bytes32 p2, bool p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(uint256,uint256,string,bool)`.\n mstore(0x00, 0x7af6ab25)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, 0x80)\n mstore(0x80, p3)\n writeString(0xa0, p2)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(uint256 p0, uint256 p1, bytes32 p2, uint256 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(uint256,uint256,string,uint256)`.\n mstore(0x00, 0x5da297eb)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, 0x80)\n mstore(0x80, p3)\n writeString(0xa0, p2)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(uint256 p0, uint256 p1, bytes32 p2, bytes32 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n // Selector of `log(uint256,uint256,string,string)`.\n mstore(0x00, 0x27d8afd2)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, 0x80)\n mstore(0x80, 0xc0)\n writeString(0xa0, p2)\n writeString(0xe0, p3)\n }\n _sendLogPayload(0x1c, 0x104);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n }\n }\n\n function log(uint256 p0, bytes32 p1, address p2, address p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(uint256,string,address,address)`.\n mstore(0x00, 0x6168ed61)\n mstore(0x20, p0)\n mstore(0x40, 0x80)\n mstore(0x60, p2)\n mstore(0x80, p3)\n writeString(0xa0, p1)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(uint256 p0, bytes32 p1, address p2, bool p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(uint256,string,address,bool)`.\n mstore(0x00, 0x90c30a56)\n mstore(0x20, p0)\n mstore(0x40, 0x80)\n mstore(0x60, p2)\n mstore(0x80, p3)\n writeString(0xa0, p1)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(uint256 p0, bytes32 p1, address p2, uint256 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(uint256,string,address,uint256)`.\n mstore(0x00, 0xe8d3018d)\n mstore(0x20, p0)\n mstore(0x40, 0x80)\n mstore(0x60, p2)\n mstore(0x80, p3)\n writeString(0xa0, p1)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(uint256 p0, bytes32 p1, address p2, bytes32 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n // Selector of `log(uint256,string,address,string)`.\n mstore(0x00, 0x9c3adfa1)\n mstore(0x20, p0)\n mstore(0x40, 0x80)\n mstore(0x60, p2)\n mstore(0x80, 0xc0)\n writeString(0xa0, p1)\n writeString(0xe0, p3)\n }\n _sendLogPayload(0x1c, 0x104);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n }\n }\n\n function log(uint256 p0, bytes32 p1, bool p2, address p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(uint256,string,bool,address)`.\n mstore(0x00, 0xae2ec581)\n mstore(0x20, p0)\n mstore(0x40, 0x80)\n mstore(0x60, p2)\n mstore(0x80, p3)\n writeString(0xa0, p1)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(uint256 p0, bytes32 p1, bool p2, bool p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(uint256,string,bool,bool)`.\n mstore(0x00, 0xba535d9c)\n mstore(0x20, p0)\n mstore(0x40, 0x80)\n mstore(0x60, p2)\n mstore(0x80, p3)\n writeString(0xa0, p1)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(uint256 p0, bytes32 p1, bool p2, uint256 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(uint256,string,bool,uint256)`.\n mstore(0x00, 0xcf009880)\n mstore(0x20, p0)\n mstore(0x40, 0x80)\n mstore(0x60, p2)\n mstore(0x80, p3)\n writeString(0xa0, p1)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(uint256 p0, bytes32 p1, bool p2, bytes32 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n // Selector of `log(uint256,string,bool,string)`.\n mstore(0x00, 0xd2d423cd)\n mstore(0x20, p0)\n mstore(0x40, 0x80)\n mstore(0x60, p2)\n mstore(0x80, 0xc0)\n writeString(0xa0, p1)\n writeString(0xe0, p3)\n }\n _sendLogPayload(0x1c, 0x104);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n }\n }\n\n function log(uint256 p0, bytes32 p1, uint256 p2, address p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(uint256,string,uint256,address)`.\n mstore(0x00, 0x3b2279b4)\n mstore(0x20, p0)\n mstore(0x40, 0x80)\n mstore(0x60, p2)\n mstore(0x80, p3)\n writeString(0xa0, p1)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(uint256 p0, bytes32 p1, uint256 p2, bool p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(uint256,string,uint256,bool)`.\n mstore(0x00, 0x691a8f74)\n mstore(0x20, p0)\n mstore(0x40, 0x80)\n mstore(0x60, p2)\n mstore(0x80, p3)\n writeString(0xa0, p1)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(uint256 p0, bytes32 p1, uint256 p2, uint256 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(uint256,string,uint256,uint256)`.\n mstore(0x00, 0x82c25b74)\n mstore(0x20, p0)\n mstore(0x40, 0x80)\n mstore(0x60, p2)\n mstore(0x80, p3)\n writeString(0xa0, p1)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(uint256 p0, bytes32 p1, uint256 p2, bytes32 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n // Selector of `log(uint256,string,uint256,string)`.\n mstore(0x00, 0xb7b914ca)\n mstore(0x20, p0)\n mstore(0x40, 0x80)\n mstore(0x60, p2)\n mstore(0x80, 0xc0)\n writeString(0xa0, p1)\n writeString(0xe0, p3)\n }\n _sendLogPayload(0x1c, 0x104);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n }\n }\n\n function log(uint256 p0, bytes32 p1, bytes32 p2, address p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n // Selector of `log(uint256,string,string,address)`.\n mstore(0x00, 0xd583c602)\n mstore(0x20, p0)\n mstore(0x40, 0x80)\n mstore(0x60, 0xc0)\n mstore(0x80, p3)\n writeString(0xa0, p1)\n writeString(0xe0, p2)\n }\n _sendLogPayload(0x1c, 0x104);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n }\n }\n\n function log(uint256 p0, bytes32 p1, bytes32 p2, bool p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n // Selector of `log(uint256,string,string,bool)`.\n mstore(0x00, 0xb3a6b6bd)\n mstore(0x20, p0)\n mstore(0x40, 0x80)\n mstore(0x60, 0xc0)\n mstore(0x80, p3)\n writeString(0xa0, p1)\n writeString(0xe0, p2)\n }\n _sendLogPayload(0x1c, 0x104);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n }\n }\n\n function log(uint256 p0, bytes32 p1, bytes32 p2, uint256 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n // Selector of `log(uint256,string,string,uint256)`.\n mstore(0x00, 0xb028c9bd)\n mstore(0x20, p0)\n mstore(0x40, 0x80)\n mstore(0x60, 0xc0)\n mstore(0x80, p3)\n writeString(0xa0, p1)\n writeString(0xe0, p2)\n }\n _sendLogPayload(0x1c, 0x104);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n }\n }\n\n function log(uint256 p0, bytes32 p1, bytes32 p2, bytes32 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n bytes32 m9;\n bytes32 m10;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n m9 := mload(0x120)\n m10 := mload(0x140)\n // Selector of `log(uint256,string,string,string)`.\n mstore(0x00, 0x21ad0683)\n mstore(0x20, p0)\n mstore(0x40, 0x80)\n mstore(0x60, 0xc0)\n mstore(0x80, 0x100)\n writeString(0xa0, p1)\n writeString(0xe0, p2)\n writeString(0x120, p3)\n }\n _sendLogPayload(0x1c, 0x144);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n mstore(0x120, m9)\n mstore(0x140, m10)\n }\n }\n\n function log(bytes32 p0, address p1, address p2, address p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(string,address,address,address)`.\n mstore(0x00, 0xed8f28f6)\n mstore(0x20, 0x80)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n writeString(0xa0, p0)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(bytes32 p0, address p1, address p2, bool p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(string,address,address,bool)`.\n mstore(0x00, 0xb59dbd60)\n mstore(0x20, 0x80)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n writeString(0xa0, p0)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(bytes32 p0, address p1, address p2, uint256 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(string,address,address,uint256)`.\n mstore(0x00, 0x8ef3f399)\n mstore(0x20, 0x80)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n writeString(0xa0, p0)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(bytes32 p0, address p1, address p2, bytes32 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n // Selector of `log(string,address,address,string)`.\n mstore(0x00, 0x800a1c67)\n mstore(0x20, 0x80)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, 0xc0)\n writeString(0xa0, p0)\n writeString(0xe0, p3)\n }\n _sendLogPayload(0x1c, 0x104);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n }\n }\n\n function log(bytes32 p0, address p1, bool p2, address p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(string,address,bool,address)`.\n mstore(0x00, 0x223603bd)\n mstore(0x20, 0x80)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n writeString(0xa0, p0)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(bytes32 p0, address p1, bool p2, bool p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(string,address,bool,bool)`.\n mstore(0x00, 0x79884c2b)\n mstore(0x20, 0x80)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n writeString(0xa0, p0)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(bytes32 p0, address p1, bool p2, uint256 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(string,address,bool,uint256)`.\n mstore(0x00, 0x3e9f866a)\n mstore(0x20, 0x80)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n writeString(0xa0, p0)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(bytes32 p0, address p1, bool p2, bytes32 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n // Selector of `log(string,address,bool,string)`.\n mstore(0x00, 0x0454c079)\n mstore(0x20, 0x80)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, 0xc0)\n writeString(0xa0, p0)\n writeString(0xe0, p3)\n }\n _sendLogPayload(0x1c, 0x104);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n }\n }\n\n function log(bytes32 p0, address p1, uint256 p2, address p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(string,address,uint256,address)`.\n mstore(0x00, 0x63fb8bc5)\n mstore(0x20, 0x80)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n writeString(0xa0, p0)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(bytes32 p0, address p1, uint256 p2, bool p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(string,address,uint256,bool)`.\n mstore(0x00, 0xfc4845f0)\n mstore(0x20, 0x80)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n writeString(0xa0, p0)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(bytes32 p0, address p1, uint256 p2, uint256 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(string,address,uint256,uint256)`.\n mstore(0x00, 0xf8f51b1e)\n mstore(0x20, 0x80)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n writeString(0xa0, p0)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(bytes32 p0, address p1, uint256 p2, bytes32 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n // Selector of `log(string,address,uint256,string)`.\n mstore(0x00, 0x5a477632)\n mstore(0x20, 0x80)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, 0xc0)\n writeString(0xa0, p0)\n writeString(0xe0, p3)\n }\n _sendLogPayload(0x1c, 0x104);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n }\n }\n\n function log(bytes32 p0, address p1, bytes32 p2, address p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n // Selector of `log(string,address,string,address)`.\n mstore(0x00, 0xaabc9a31)\n mstore(0x20, 0x80)\n mstore(0x40, p1)\n mstore(0x60, 0xc0)\n mstore(0x80, p3)\n writeString(0xa0, p0)\n writeString(0xe0, p2)\n }\n _sendLogPayload(0x1c, 0x104);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n }\n }\n\n function log(bytes32 p0, address p1, bytes32 p2, bool p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n // Selector of `log(string,address,string,bool)`.\n mstore(0x00, 0x5f15d28c)\n mstore(0x20, 0x80)\n mstore(0x40, p1)\n mstore(0x60, 0xc0)\n mstore(0x80, p3)\n writeString(0xa0, p0)\n writeString(0xe0, p2)\n }\n _sendLogPayload(0x1c, 0x104);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n }\n }\n\n function log(bytes32 p0, address p1, bytes32 p2, uint256 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n // Selector of `log(string,address,string,uint256)`.\n mstore(0x00, 0x91d1112e)\n mstore(0x20, 0x80)\n mstore(0x40, p1)\n mstore(0x60, 0xc0)\n mstore(0x80, p3)\n writeString(0xa0, p0)\n writeString(0xe0, p2)\n }\n _sendLogPayload(0x1c, 0x104);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n }\n }\n\n function log(bytes32 p0, address p1, bytes32 p2, bytes32 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n bytes32 m9;\n bytes32 m10;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n m9 := mload(0x120)\n m10 := mload(0x140)\n // Selector of `log(string,address,string,string)`.\n mstore(0x00, 0x245986f2)\n mstore(0x20, 0x80)\n mstore(0x40, p1)\n mstore(0x60, 0xc0)\n mstore(0x80, 0x100)\n writeString(0xa0, p0)\n writeString(0xe0, p2)\n writeString(0x120, p3)\n }\n _sendLogPayload(0x1c, 0x144);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n mstore(0x120, m9)\n mstore(0x140, m10)\n }\n }\n\n function log(bytes32 p0, bool p1, address p2, address p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(string,bool,address,address)`.\n mstore(0x00, 0x33e9dd1d)\n mstore(0x20, 0x80)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n writeString(0xa0, p0)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(bytes32 p0, bool p1, address p2, bool p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(string,bool,address,bool)`.\n mstore(0x00, 0x958c28c6)\n mstore(0x20, 0x80)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n writeString(0xa0, p0)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(bytes32 p0, bool p1, address p2, uint256 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(string,bool,address,uint256)`.\n mstore(0x00, 0x5d08bb05)\n mstore(0x20, 0x80)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n writeString(0xa0, p0)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(bytes32 p0, bool p1, address p2, bytes32 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n // Selector of `log(string,bool,address,string)`.\n mstore(0x00, 0x2d8e33a4)\n mstore(0x20, 0x80)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, 0xc0)\n writeString(0xa0, p0)\n writeString(0xe0, p3)\n }\n _sendLogPayload(0x1c, 0x104);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n }\n }\n\n function log(bytes32 p0, bool p1, bool p2, address p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(string,bool,bool,address)`.\n mstore(0x00, 0x7190a529)\n mstore(0x20, 0x80)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n writeString(0xa0, p0)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(bytes32 p0, bool p1, bool p2, bool p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(string,bool,bool,bool)`.\n mstore(0x00, 0x895af8c5)\n mstore(0x20, 0x80)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n writeString(0xa0, p0)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(bytes32 p0, bool p1, bool p2, uint256 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(string,bool,bool,uint256)`.\n mstore(0x00, 0x8e3f78a9)\n mstore(0x20, 0x80)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n writeString(0xa0, p0)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(bytes32 p0, bool p1, bool p2, bytes32 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n // Selector of `log(string,bool,bool,string)`.\n mstore(0x00, 0x9d22d5dd)\n mstore(0x20, 0x80)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, 0xc0)\n writeString(0xa0, p0)\n writeString(0xe0, p3)\n }\n _sendLogPayload(0x1c, 0x104);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n }\n }\n\n function log(bytes32 p0, bool p1, uint256 p2, address p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(string,bool,uint256,address)`.\n mstore(0x00, 0x935e09bf)\n mstore(0x20, 0x80)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n writeString(0xa0, p0)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(bytes32 p0, bool p1, uint256 p2, bool p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(string,bool,uint256,bool)`.\n mstore(0x00, 0x8af7cf8a)\n mstore(0x20, 0x80)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n writeString(0xa0, p0)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(bytes32 p0, bool p1, uint256 p2, uint256 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(string,bool,uint256,uint256)`.\n mstore(0x00, 0x64b5bb67)\n mstore(0x20, 0x80)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n writeString(0xa0, p0)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(bytes32 p0, bool p1, uint256 p2, bytes32 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n // Selector of `log(string,bool,uint256,string)`.\n mstore(0x00, 0x742d6ee7)\n mstore(0x20, 0x80)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, 0xc0)\n writeString(0xa0, p0)\n writeString(0xe0, p3)\n }\n _sendLogPayload(0x1c, 0x104);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n }\n }\n\n function log(bytes32 p0, bool p1, bytes32 p2, address p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n // Selector of `log(string,bool,string,address)`.\n mstore(0x00, 0xe0625b29)\n mstore(0x20, 0x80)\n mstore(0x40, p1)\n mstore(0x60, 0xc0)\n mstore(0x80, p3)\n writeString(0xa0, p0)\n writeString(0xe0, p2)\n }\n _sendLogPayload(0x1c, 0x104);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n }\n }\n\n function log(bytes32 p0, bool p1, bytes32 p2, bool p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n // Selector of `log(string,bool,string,bool)`.\n mstore(0x00, 0x3f8a701d)\n mstore(0x20, 0x80)\n mstore(0x40, p1)\n mstore(0x60, 0xc0)\n mstore(0x80, p3)\n writeString(0xa0, p0)\n writeString(0xe0, p2)\n }\n _sendLogPayload(0x1c, 0x104);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n }\n }\n\n function log(bytes32 p0, bool p1, bytes32 p2, uint256 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n // Selector of `log(string,bool,string,uint256)`.\n mstore(0x00, 0x24f91465)\n mstore(0x20, 0x80)\n mstore(0x40, p1)\n mstore(0x60, 0xc0)\n mstore(0x80, p3)\n writeString(0xa0, p0)\n writeString(0xe0, p2)\n }\n _sendLogPayload(0x1c, 0x104);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n }\n }\n\n function log(bytes32 p0, bool p1, bytes32 p2, bytes32 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n bytes32 m9;\n bytes32 m10;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n m9 := mload(0x120)\n m10 := mload(0x140)\n // Selector of `log(string,bool,string,string)`.\n mstore(0x00, 0xa826caeb)\n mstore(0x20, 0x80)\n mstore(0x40, p1)\n mstore(0x60, 0xc0)\n mstore(0x80, 0x100)\n writeString(0xa0, p0)\n writeString(0xe0, p2)\n writeString(0x120, p3)\n }\n _sendLogPayload(0x1c, 0x144);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n mstore(0x120, m9)\n mstore(0x140, m10)\n }\n }\n\n function log(bytes32 p0, uint256 p1, address p2, address p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(string,uint256,address,address)`.\n mstore(0x00, 0x5ea2b7ae)\n mstore(0x20, 0x80)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n writeString(0xa0, p0)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(bytes32 p0, uint256 p1, address p2, bool p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(string,uint256,address,bool)`.\n mstore(0x00, 0x82112a42)\n mstore(0x20, 0x80)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n writeString(0xa0, p0)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(bytes32 p0, uint256 p1, address p2, uint256 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(string,uint256,address,uint256)`.\n mstore(0x00, 0x4f04fdc6)\n mstore(0x20, 0x80)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n writeString(0xa0, p0)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(bytes32 p0, uint256 p1, address p2, bytes32 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n // Selector of `log(string,uint256,address,string)`.\n mstore(0x00, 0x9ffb2f93)\n mstore(0x20, 0x80)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, 0xc0)\n writeString(0xa0, p0)\n writeString(0xe0, p3)\n }\n _sendLogPayload(0x1c, 0x104);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n }\n }\n\n function log(bytes32 p0, uint256 p1, bool p2, address p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(string,uint256,bool,address)`.\n mstore(0x00, 0xe0e95b98)\n mstore(0x20, 0x80)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n writeString(0xa0, p0)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(bytes32 p0, uint256 p1, bool p2, bool p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(string,uint256,bool,bool)`.\n mstore(0x00, 0x354c36d6)\n mstore(0x20, 0x80)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n writeString(0xa0, p0)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(bytes32 p0, uint256 p1, bool p2, uint256 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(string,uint256,bool,uint256)`.\n mstore(0x00, 0xe41b6f6f)\n mstore(0x20, 0x80)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n writeString(0xa0, p0)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(bytes32 p0, uint256 p1, bool p2, bytes32 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n // Selector of `log(string,uint256,bool,string)`.\n mstore(0x00, 0xabf73a98)\n mstore(0x20, 0x80)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, 0xc0)\n writeString(0xa0, p0)\n writeString(0xe0, p3)\n }\n _sendLogPayload(0x1c, 0x104);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n }\n }\n\n function log(bytes32 p0, uint256 p1, uint256 p2, address p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(string,uint256,uint256,address)`.\n mstore(0x00, 0xe21de278)\n mstore(0x20, 0x80)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n writeString(0xa0, p0)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(bytes32 p0, uint256 p1, uint256 p2, bool p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(string,uint256,uint256,bool)`.\n mstore(0x00, 0x7626db92)\n mstore(0x20, 0x80)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n writeString(0xa0, p0)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(bytes32 p0, uint256 p1, uint256 p2, uint256 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(string,uint256,uint256,uint256)`.\n mstore(0x00, 0xa7a87853)\n mstore(0x20, 0x80)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n writeString(0xa0, p0)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(bytes32 p0, uint256 p1, uint256 p2, bytes32 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n // Selector of `log(string,uint256,uint256,string)`.\n mstore(0x00, 0x854b3496)\n mstore(0x20, 0x80)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, 0xc0)\n writeString(0xa0, p0)\n writeString(0xe0, p3)\n }\n _sendLogPayload(0x1c, 0x104);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n }\n }\n\n function log(bytes32 p0, uint256 p1, bytes32 p2, address p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n // Selector of `log(string,uint256,string,address)`.\n mstore(0x00, 0x7c4632a4)\n mstore(0x20, 0x80)\n mstore(0x40, p1)\n mstore(0x60, 0xc0)\n mstore(0x80, p3)\n writeString(0xa0, p0)\n writeString(0xe0, p2)\n }\n _sendLogPayload(0x1c, 0x104);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n }\n }\n\n function log(bytes32 p0, uint256 p1, bytes32 p2, bool p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n // Selector of `log(string,uint256,string,bool)`.\n mstore(0x00, 0x7d24491d)\n mstore(0x20, 0x80)\n mstore(0x40, p1)\n mstore(0x60, 0xc0)\n mstore(0x80, p3)\n writeString(0xa0, p0)\n writeString(0xe0, p2)\n }\n _sendLogPayload(0x1c, 0x104);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n }\n }\n\n function log(bytes32 p0, uint256 p1, bytes32 p2, uint256 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n // Selector of `log(string,uint256,string,uint256)`.\n mstore(0x00, 0xc67ea9d1)\n mstore(0x20, 0x80)\n mstore(0x40, p1)\n mstore(0x60, 0xc0)\n mstore(0x80, p3)\n writeString(0xa0, p0)\n writeString(0xe0, p2)\n }\n _sendLogPayload(0x1c, 0x104);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n }\n }\n\n function log(bytes32 p0, uint256 p1, bytes32 p2, bytes32 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n bytes32 m9;\n bytes32 m10;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n m9 := mload(0x120)\n m10 := mload(0x140)\n // Selector of `log(string,uint256,string,string)`.\n mstore(0x00, 0x5ab84e1f)\n mstore(0x20, 0x80)\n mstore(0x40, p1)\n mstore(0x60, 0xc0)\n mstore(0x80, 0x100)\n writeString(0xa0, p0)\n writeString(0xe0, p2)\n writeString(0x120, p3)\n }\n _sendLogPayload(0x1c, 0x144);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n mstore(0x120, m9)\n mstore(0x140, m10)\n }\n }\n\n function log(bytes32 p0, bytes32 p1, address p2, address p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n // Selector of `log(string,string,address,address)`.\n mstore(0x00, 0x439c7bef)\n mstore(0x20, 0x80)\n mstore(0x40, 0xc0)\n mstore(0x60, p2)\n mstore(0x80, p3)\n writeString(0xa0, p0)\n writeString(0xe0, p1)\n }\n _sendLogPayload(0x1c, 0x104);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n }\n }\n\n function log(bytes32 p0, bytes32 p1, address p2, bool p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n // Selector of `log(string,string,address,bool)`.\n mstore(0x00, 0x5ccd4e37)\n mstore(0x20, 0x80)\n mstore(0x40, 0xc0)\n mstore(0x60, p2)\n mstore(0x80, p3)\n writeString(0xa0, p0)\n writeString(0xe0, p1)\n }\n _sendLogPayload(0x1c, 0x104);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n }\n }\n\n function log(bytes32 p0, bytes32 p1, address p2, uint256 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n // Selector of `log(string,string,address,uint256)`.\n mstore(0x00, 0x7cc3c607)\n mstore(0x20, 0x80)\n mstore(0x40, 0xc0)\n mstore(0x60, p2)\n mstore(0x80, p3)\n writeString(0xa0, p0)\n writeString(0xe0, p1)\n }\n _sendLogPayload(0x1c, 0x104);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n }\n }\n\n function log(bytes32 p0, bytes32 p1, address p2, bytes32 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n bytes32 m9;\n bytes32 m10;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n m9 := mload(0x120)\n m10 := mload(0x140)\n // Selector of `log(string,string,address,string)`.\n mstore(0x00, 0xeb1bff80)\n mstore(0x20, 0x80)\n mstore(0x40, 0xc0)\n mstore(0x60, p2)\n mstore(0x80, 0x100)\n writeString(0xa0, p0)\n writeString(0xe0, p1)\n writeString(0x120, p3)\n }\n _sendLogPayload(0x1c, 0x144);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n mstore(0x120, m9)\n mstore(0x140, m10)\n }\n }\n\n function log(bytes32 p0, bytes32 p1, bool p2, address p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n // Selector of `log(string,string,bool,address)`.\n mstore(0x00, 0xc371c7db)\n mstore(0x20, 0x80)\n mstore(0x40, 0xc0)\n mstore(0x60, p2)\n mstore(0x80, p3)\n writeString(0xa0, p0)\n writeString(0xe0, p1)\n }\n _sendLogPayload(0x1c, 0x104);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n }\n }\n\n function log(bytes32 p0, bytes32 p1, bool p2, bool p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n // Selector of `log(string,string,bool,bool)`.\n mstore(0x00, 0x40785869)\n mstore(0x20, 0x80)\n mstore(0x40, 0xc0)\n mstore(0x60, p2)\n mstore(0x80, p3)\n writeString(0xa0, p0)\n writeString(0xe0, p1)\n }\n _sendLogPayload(0x1c, 0x104);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n }\n }\n\n function log(bytes32 p0, bytes32 p1, bool p2, uint256 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n // Selector of `log(string,string,bool,uint256)`.\n mstore(0x00, 0xd6aefad2)\n mstore(0x20, 0x80)\n mstore(0x40, 0xc0)\n mstore(0x60, p2)\n mstore(0x80, p3)\n writeString(0xa0, p0)\n writeString(0xe0, p1)\n }\n _sendLogPayload(0x1c, 0x104);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n }\n }\n\n function log(bytes32 p0, bytes32 p1, bool p2, bytes32 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n bytes32 m9;\n bytes32 m10;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n m9 := mload(0x120)\n m10 := mload(0x140)\n // Selector of `log(string,string,bool,string)`.\n mstore(0x00, 0x5e84b0ea)\n mstore(0x20, 0x80)\n mstore(0x40, 0xc0)\n mstore(0x60, p2)\n mstore(0x80, 0x100)\n writeString(0xa0, p0)\n writeString(0xe0, p1)\n writeString(0x120, p3)\n }\n _sendLogPayload(0x1c, 0x144);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n mstore(0x120, m9)\n mstore(0x140, m10)\n }\n }\n\n function log(bytes32 p0, bytes32 p1, uint256 p2, address p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n // Selector of `log(string,string,uint256,address)`.\n mstore(0x00, 0x1023f7b2)\n mstore(0x20, 0x80)\n mstore(0x40, 0xc0)\n mstore(0x60, p2)\n mstore(0x80, p3)\n writeString(0xa0, p0)\n writeString(0xe0, p1)\n }\n _sendLogPayload(0x1c, 0x104);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n }\n }\n\n function log(bytes32 p0, bytes32 p1, uint256 p2, bool p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n // Selector of `log(string,string,uint256,bool)`.\n mstore(0x00, 0xc3a8a654)\n mstore(0x20, 0x80)\n mstore(0x40, 0xc0)\n mstore(0x60, p2)\n mstore(0x80, p3)\n writeString(0xa0, p0)\n writeString(0xe0, p1)\n }\n _sendLogPayload(0x1c, 0x104);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n }\n }\n\n function log(bytes32 p0, bytes32 p1, uint256 p2, uint256 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n // Selector of `log(string,string,uint256,uint256)`.\n mstore(0x00, 0xf45d7d2c)\n mstore(0x20, 0x80)\n mstore(0x40, 0xc0)\n mstore(0x60, p2)\n mstore(0x80, p3)\n writeString(0xa0, p0)\n writeString(0xe0, p1)\n }\n _sendLogPayload(0x1c, 0x104);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n }\n }\n\n function log(bytes32 p0, bytes32 p1, uint256 p2, bytes32 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n bytes32 m9;\n bytes32 m10;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n m9 := mload(0x120)\n m10 := mload(0x140)\n // Selector of `log(string,string,uint256,string)`.\n mstore(0x00, 0x5d1a971a)\n mstore(0x20, 0x80)\n mstore(0x40, 0xc0)\n mstore(0x60, p2)\n mstore(0x80, 0x100)\n writeString(0xa0, p0)\n writeString(0xe0, p1)\n writeString(0x120, p3)\n }\n _sendLogPayload(0x1c, 0x144);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n mstore(0x120, m9)\n mstore(0x140, m10)\n }\n }\n\n function log(bytes32 p0, bytes32 p1, bytes32 p2, address p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n bytes32 m9;\n bytes32 m10;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n m9 := mload(0x120)\n m10 := mload(0x140)\n // Selector of `log(string,string,string,address)`.\n mstore(0x00, 0x6d572f44)\n mstore(0x20, 0x80)\n mstore(0x40, 0xc0)\n mstore(0x60, 0x100)\n mstore(0x80, p3)\n writeString(0xa0, p0)\n writeString(0xe0, p1)\n writeString(0x120, p2)\n }\n _sendLogPayload(0x1c, 0x144);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n mstore(0x120, m9)\n mstore(0x140, m10)\n }\n }\n\n function log(bytes32 p0, bytes32 p1, bytes32 p2, bool p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n bytes32 m9;\n bytes32 m10;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n m9 := mload(0x120)\n m10 := mload(0x140)\n // Selector of `log(string,string,string,bool)`.\n mstore(0x00, 0x2c1754ed)\n mstore(0x20, 0x80)\n mstore(0x40, 0xc0)\n mstore(0x60, 0x100)\n mstore(0x80, p3)\n writeString(0xa0, p0)\n writeString(0xe0, p1)\n writeString(0x120, p2)\n }\n _sendLogPayload(0x1c, 0x144);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n mstore(0x120, m9)\n mstore(0x140, m10)\n }\n }\n\n function log(bytes32 p0, bytes32 p1, bytes32 p2, uint256 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n bytes32 m9;\n bytes32 m10;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n m9 := mload(0x120)\n m10 := mload(0x140)\n // Selector of `log(string,string,string,uint256)`.\n mstore(0x00, 0x8eafb02b)\n mstore(0x20, 0x80)\n mstore(0x40, 0xc0)\n mstore(0x60, 0x100)\n mstore(0x80, p3)\n writeString(0xa0, p0)\n writeString(0xe0, p1)\n writeString(0x120, p2)\n }\n _sendLogPayload(0x1c, 0x144);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n mstore(0x120, m9)\n mstore(0x140, m10)\n }\n }\n\n function log(bytes32 p0, bytes32 p1, bytes32 p2, bytes32 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n bytes32 m9;\n bytes32 m10;\n bytes32 m11;\n bytes32 m12;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n m9 := mload(0x120)\n m10 := mload(0x140)\n m11 := mload(0x160)\n m12 := mload(0x180)\n // Selector of `log(string,string,string,string)`.\n mstore(0x00, 0xde68f20a)\n mstore(0x20, 0x80)\n mstore(0x40, 0xc0)\n mstore(0x60, 0x100)\n mstore(0x80, 0x140)\n writeString(0xa0, p0)\n writeString(0xe0, p1)\n writeString(0x120, p2)\n writeString(0x160, p3)\n }\n _sendLogPayload(0x1c, 0x184);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n mstore(0x120, m9)\n mstore(0x140, m10)\n mstore(0x160, m11)\n mstore(0x180, m12)\n }\n }\n}\n","license":"MIT"},"scripts/FetchChainInfo.s.sol":{"keccak256":"0xb90e4f9a834c4dc584b4ad8c0503e35fdd8338533e0e75a7ca497f655ae12821","urls":[],"content":"// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\nimport { Script } from \"forge-std/Script.sol\";\nimport { GameTypes, GameType } from \"src/dispute/lib/Types.sol\";\n\n/// @notice Contains getters for arbitrary methods from all L1 contracts, including legacy getters\n/// that have since been deprecated.\ninterface IFetcher {\n function guardian() external view returns (address);\n function GUARDIAN() external view returns (address);\n function systemConfig() external view returns (address);\n function SYSTEM_CONFIG() external view returns (address);\n function disputeGameFactory() external view returns (address);\n function ethLockbox() external view returns (address);\n function superchainConfig() external view returns (address);\n function messenger() external view returns (address);\n function addressManager() external view returns (address);\n function PORTAL() external view returns (address);\n function portal() external view returns (address);\n function l1ERC721Bridge() external view returns (address);\n function optimismMintableERC20Factory() external view returns (address);\n function gameImpls(GameType _gameType) external view returns (address);\n function respectedGameType() external view returns (GameType);\n function anchorStateRegistry() external view returns (address);\n function L2_ORACLE() external view returns (address);\n function l2Oracle() external view returns (address);\n function vm() external view returns (address);\n function oracle() external view returns (address);\n function challenger() external view returns (address);\n function proposer() external view returns (address);\n function PROPOSER() external view returns (address);\n function batcherHash() external view returns (bytes32);\n function admin() external view returns (address);\n function owner() external view returns (address);\n function unsafeBlockSigner() external view returns (address);\n function weth() external view returns (address);\n}\n\ncontract FetchChainInfoInput {\n address internal _systemConfigProxy;\n address internal _l1StandardBridgeProxy;\n\n function set(bytes4 _sel, address _addr) public {\n require(_addr != address(0), \"FetchChainInfoInput: cannot set zero address\");\n if (_sel == this.systemConfigProxy.selector) _systemConfigProxy = _addr;\n else if (_sel == this.l1StandardBridgeProxy.selector) _l1StandardBridgeProxy = _addr;\n else revert(\"FetchChainInfoInput: unknown selector\");\n }\n\n function systemConfigProxy() public view returns (address) {\n require(_systemConfigProxy != address(0), \"FetchChainInfoInput: systemConfigProxy not set\");\n return _systemConfigProxy;\n }\n\n function l1StandardBridgeProxy() public view returns (address) {\n require(_l1StandardBridgeProxy != address(0), \"FetchChainInfoInput: l1StandardBridgeProxy not set\");\n return _l1StandardBridgeProxy;\n }\n}\n\ncontract FetchChainInfoOutput {\n // contract addresses\n // - SuperchainContracts\n address internal _superchainConfigProxy;\n // - ImplementationsContracts\n address internal _mipsImpl;\n address internal _preimageOracleImpl;\n // - OpChainContracts\n address internal _addressManagerImpl;\n address internal _ethLockboxProxy;\n address internal _l1CrossDomainMessengerProxy;\n address internal _l1Erc721BridgeProxy;\n address internal _l1StandardBridgeProxy;\n address internal _l2OutputOracleProxy;\n address internal _optimismMintableErc20FactoryProxy;\n address internal _optimismPortalProxy;\n address internal _systemConfigProxy;\n address internal _opChainProxyAdminImpl;\n address internal _anchorStateRegistryProxy;\n address internal _delayedWethPermissionedGameProxy;\n address internal _delayedWethPermissionlessGameProxy;\n address internal _disputeGameFactoryProxy;\n address internal _faultDisputeGameImpl;\n address internal _faultDisputeGameCannonKonaImpl;\n address internal _permissionedDisputeGameImpl;\n\n // roles\n address internal _systemConfigOwner;\n address internal _opChainProxyAdminOwner;\n address internal _opChainGuardian;\n address internal _challenger;\n address internal _proposer;\n address internal _unsafeBlockSigner;\n address internal _batchSubmitter;\n\n // fault proof status\n bool internal _permissioned;\n bool internal _permissionless;\n GameType internal _respectedGameType;\n\n function set(bytes4 _sel, address _addr) public {\n // SuperchainContracts\n if (_sel == this.superchainConfigProxy.selector) _superchainConfigProxy = _addr;\n // - ImplementationsContracts\n else if (_sel == this.mipsImpl.selector) _mipsImpl = _addr;\n else if (_sel == this.preimageOracleImpl.selector) _preimageOracleImpl = _addr;\n // - OpChainContracts\n else if (_sel == this.addressManagerImpl.selector) _addressManagerImpl = _addr;\n else if (_sel == this.ethLockboxProxy.selector) _ethLockboxProxy = _addr;\n else if (_sel == this.l1CrossDomainMessengerProxy.selector) _l1CrossDomainMessengerProxy = _addr;\n else if (_sel == this.l1Erc721BridgeProxy.selector) _l1Erc721BridgeProxy = _addr;\n else if (_sel == this.l1StandardBridgeProxy.selector) _l1StandardBridgeProxy = _addr;\n else if (_sel == this.l2OutputOracleProxy.selector) _l2OutputOracleProxy = _addr;\n else if (_sel == this.optimismMintableErc20FactoryProxy.selector) _optimismMintableErc20FactoryProxy = _addr;\n else if (_sel == this.optimismPortalProxy.selector) _optimismPortalProxy = _addr;\n else if (_sel == this.systemConfigProxy.selector) _systemConfigProxy = _addr;\n else if (_sel == this.opChainProxyAdminImpl.selector) _opChainProxyAdminImpl = _addr;\n else if (_sel == this.anchorStateRegistryProxy.selector) _anchorStateRegistryProxy = _addr;\n else if (_sel == this.delayedWethPermissionedGameProxy.selector) _delayedWethPermissionedGameProxy = _addr;\n else if (_sel == this.delayedWethPermissionlessGameProxy.selector) _delayedWethPermissionlessGameProxy = _addr;\n else if (_sel == this.disputeGameFactoryProxy.selector) _disputeGameFactoryProxy = _addr;\n else if (_sel == this.faultDisputeGameImpl.selector) _faultDisputeGameImpl = _addr;\n else if (_sel == this.faultDisputeGameCannonKonaImpl.selector) _faultDisputeGameCannonKonaImpl = _addr;\n else if (_sel == this.permissionedDisputeGameImpl.selector) _permissionedDisputeGameImpl = _addr;\n // roles\n else if (_sel == this.systemConfigOwner.selector) _systemConfigOwner = _addr;\n else if (_sel == this.opChainProxyAdminOwner.selector) _opChainProxyAdminOwner = _addr;\n else if (_sel == this.opChainGuardian.selector) _opChainGuardian = _addr;\n else if (_sel == this.challenger.selector) _challenger = _addr;\n else if (_sel == this.proposer.selector) _proposer = _addr;\n else if (_sel == this.unsafeBlockSigner.selector) _unsafeBlockSigner = _addr;\n else if (_sel == this.batchSubmitter.selector) _batchSubmitter = _addr;\n else revert(\"FetchChainInfoOutput: unknown address selector test\");\n }\n\n function set(bytes4 _sel, bool _bool) public {\n if (_sel == this.permissioned.selector) _permissioned = _bool;\n else if (_sel == this.permissionless.selector) _permissionless = _bool;\n else revert(\"FetchChainInfoOutput: unknown bool selector\");\n }\n\n function set(bytes4 _sel, GameType _gameType) public {\n if (_sel == this.respectedGameType.selector) _respectedGameType = _gameType;\n else revert(\"FetchChainInfoOutput: unknown GameType selector\");\n }\n\n function addressManagerImpl() public view returns (address) {\n require(_addressManagerImpl != address(0), \"FetchChainInfoOutput: addressManagerImpl not set\");\n return _addressManagerImpl;\n }\n\n function ethLockboxProxy() public view returns (address) {\n return _ethLockboxProxy;\n }\n\n function l1CrossDomainMessengerProxy() public view returns (address) {\n require(_l1CrossDomainMessengerProxy != address(0), \"FetchChainInfoOutput: l1CrossDomainMessengerProxy not set\");\n return _l1CrossDomainMessengerProxy;\n }\n\n function l1Erc721BridgeProxy() public view returns (address) {\n require(_l1Erc721BridgeProxy != address(0), \"FetchChainInfoOutput: l1Erc721BridgeProxy not set\");\n return _l1Erc721BridgeProxy;\n }\n\n function l1StandardBridgeProxy() public view returns (address) {\n require(_l1StandardBridgeProxy != address(0), \"FetchChainInfoOutput: l1StandardBridgeProxy not set\");\n return _l1StandardBridgeProxy;\n }\n\n function l2OutputOracleProxy() public view returns (address) {\n require(_l2OutputOracleProxy != address(0), \"FetchChainInfoOutput: l2OutputOracleProxy not set\");\n return _l2OutputOracleProxy;\n }\n\n function optimismMintableErc20FactoryProxy() public view returns (address) {\n require(\n _optimismMintableErc20FactoryProxy != address(0),\n \"FetchChainInfoOutput: optimismMintableErc20FactoryProxy not set\"\n );\n return _optimismMintableErc20FactoryProxy;\n }\n\n function optimismPortalProxy() public view returns (address) {\n require(_optimismPortalProxy != address(0), \"FetchChainInfoOutput: optimismPortalProxy not set\");\n return _optimismPortalProxy;\n }\n\n function systemConfigProxy() public view returns (address) {\n require(_systemConfigProxy != address(0), \"FetchChainInfoOutput: systemConfigProxy not set\");\n return _systemConfigProxy;\n }\n\n function opChainProxyAdminImpl() public view returns (address) {\n require(_opChainProxyAdminImpl != address(0), \"FetchChainInfoOutput: opChainProxyAdminImpl not set\");\n return _opChainProxyAdminImpl;\n }\n\n function superchainConfigProxy() public view returns (address) {\n require(_superchainConfigProxy != address(0), \"FetchChainInfoOutput: superchainConfigProxy not set\");\n return _superchainConfigProxy;\n }\n\n function anchorStateRegistryProxy() public view returns (address) {\n require(_anchorStateRegistryProxy != address(0), \"FetchChainInfoOutput: anchorStateRegistryProxy not set\");\n return _anchorStateRegistryProxy;\n }\n\n function delayedWethPermissionedGameProxy() public view returns (address) {\n return _delayedWethPermissionedGameProxy;\n }\n\n function delayedWethPermissionlessGameProxy() public view returns (address) {\n return _delayedWethPermissionlessGameProxy;\n }\n\n function disputeGameFactoryProxy() public view returns (address) {\n return _disputeGameFactoryProxy;\n }\n\n function faultDisputeGameImpl() public view returns (address) {\n require(_faultDisputeGameImpl != address(0), \"FetchChainInfoOutput: faultDisputeGameImpl not set\");\n return _faultDisputeGameImpl;\n }\n\n function faultDisputeGameCannonKonaImpl() public view returns (address) {\n require(\n _faultDisputeGameCannonKonaImpl != address(0),\n \"FetchChainInfoOutput: faultDisputeGameCannonKonaImpl not set\"\n );\n return _faultDisputeGameCannonKonaImpl;\n }\n\n function mipsImpl() public view returns (address) {\n require(_mipsImpl != address(0), \"FetchChainInfoOutput: mipsImpl not set\");\n return _mipsImpl;\n }\n\n function permissionedDisputeGameImpl() public view returns (address) {\n require(_permissionedDisputeGameImpl != address(0), \"FetchChainInfoOutput: permissionedDisputeGameImpl not set\");\n return _permissionedDisputeGameImpl;\n }\n\n function preimageOracleImpl() public view returns (address) {\n require(_preimageOracleImpl != address(0), \"FetchChainInfoOutput: preimageOracleImpl not set\");\n return _preimageOracleImpl;\n }\n\n function systemConfigOwner() public view returns (address) {\n require(_systemConfigOwner != address(0), \"FetchChainInfoOutput: systemConfigOwner not set\");\n return _systemConfigOwner;\n }\n\n function opChainProxyAdminOwner() public view returns (address) {\n require(_opChainProxyAdminOwner != address(0), \"FetchChainInfoOutput: opChainProxyAdminOwner not set\");\n return _opChainProxyAdminOwner;\n }\n\n function opChainGuardian() public view returns (address) {\n require(_opChainGuardian != address(0), \"FetchChainInfoOutput: opChainGuardian not set\");\n return _opChainGuardian;\n }\n\n function challenger() public view returns (address) {\n require(_challenger != address(0), \"FetchChainInfoOutput: challenger not set\");\n return _challenger;\n }\n\n function proposer() public view returns (address) {\n require(_proposer != address(0), \"FetchChainInfoOutput: proposer not set\");\n return _proposer;\n }\n\n function unsafeBlockSigner() public view returns (address) {\n require(_unsafeBlockSigner != address(0), \"FetchChainInfoOutput: unsafeBlockSigner not set\");\n return _unsafeBlockSigner;\n }\n\n function batchSubmitter() public view returns (address) {\n require(_batchSubmitter != address(0), \"FetchChainInfoOutput: batchSubmitter not set\");\n return _batchSubmitter;\n }\n\n function permissioned() public view returns (bool) {\n return _permissioned;\n }\n\n function permissionless() public view returns (bool) {\n return _permissionless;\n }\n\n function respectedGameType() public view returns (GameType) {\n return _respectedGameType;\n }\n}\n\ncontract FetchChainInfo is Script {\n function run(FetchChainInfoInput _fi, FetchChainInfoOutput _fo) public {\n _processSystemConfig(_fi, _fo);\n _processMessengerAndPortal(_fi, _fo);\n _processFaultProofs(_fo);\n }\n\n function _processSystemConfig(FetchChainInfoInput _fi, FetchChainInfoOutput _fo) internal {\n address systemConfigProxy = _fi.systemConfigProxy();\n _fo.set(_fo.systemConfigProxy.selector, systemConfigProxy);\n\n address systemConfigOwner = IFetcher(systemConfigProxy).owner();\n _fo.set(_fo.systemConfigOwner.selector, systemConfigOwner);\n\n address unsafeBlockSigner = IFetcher(systemConfigProxy).unsafeBlockSigner();\n _fo.set(_fo.unsafeBlockSigner.selector, unsafeBlockSigner);\n\n address batchSubmitter = _getBatchSubmitter(systemConfigProxy);\n _fo.set(_fo.batchSubmitter.selector, batchSubmitter);\n\n address opChainProxyAdminImpl = _getProxyAdmin(systemConfigProxy);\n _fo.set(_fo.opChainProxyAdminImpl.selector, opChainProxyAdminImpl);\n\n address opChainProxyAdminOwner = IFetcher(opChainProxyAdminImpl).owner();\n _fo.set(_fo.opChainProxyAdminOwner.selector, opChainProxyAdminOwner);\n\n address l1Erc721BridgeProxy = _getL1ERC721BridgeProxy(systemConfigProxy);\n _fo.set(_fo.l1Erc721BridgeProxy.selector, l1Erc721BridgeProxy);\n\n address optimismMintableErc20FactoryProxy = _getOptimismMintableERC20FactoryProxy(systemConfigProxy);\n _fo.set(_fo.optimismMintableErc20FactoryProxy.selector, optimismMintableErc20FactoryProxy);\n }\n\n function _processMessengerAndPortal(FetchChainInfoInput _fi, FetchChainInfoOutput _fo) internal {\n address l1StandardBridgeProxy = _fi.l1StandardBridgeProxy();\n _fo.set(_fo.l1StandardBridgeProxy.selector, l1StandardBridgeProxy);\n\n address l1CrossDomainMessengerProxy = IFetcher(l1StandardBridgeProxy).messenger();\n _fo.set(_fo.l1CrossDomainMessengerProxy.selector, l1CrossDomainMessengerProxy);\n\n address addressManagerImpl = _getAddressManager(l1CrossDomainMessengerProxy);\n _fo.set(_fo.addressManagerImpl.selector, addressManagerImpl);\n\n address optimismPortalProxy = _getOptimismPortalProxy(l1CrossDomainMessengerProxy);\n _fo.set(_fo.optimismPortalProxy.selector, optimismPortalProxy);\n\n address opChainGuardian = _getGuardian(optimismPortalProxy);\n _fo.set(_fo.opChainGuardian.selector, opChainGuardian);\n\n address ethLockboxProxy = _getEthLockboxProxy(optimismPortalProxy);\n _fo.set(_fo.ethLockboxProxy.selector, ethLockboxProxy);\n\n address superchainConfigProxy = _getSuperchainConfigProxy(optimismPortalProxy);\n _fo.set(_fo.superchainConfigProxy.selector, superchainConfigProxy);\n }\n\n function _processFaultProofs(FetchChainInfoOutput _fo) internal {\n address systemConfigProxy = _fo.systemConfigProxy();\n address optimismPortalProxy = _fo.optimismPortalProxy();\n\n try IFetcher(optimismPortalProxy).respectedGameType() returns (GameType gameType_) {\n _fo.set(_fo.respectedGameType.selector, gameType_);\n } catch {\n // default respectedGameType to uint32.max since 0 == CANNON\n _fo.set(_fo.respectedGameType.selector, GameType.wrap(type(uint32).max));\n address l2OutputOracleProxy;\n try IFetcher(optimismPortalProxy).l2Oracle() returns (address l2Oracle_) {\n l2OutputOracleProxy = l2Oracle_;\n } catch {\n l2OutputOracleProxy = IFetcher(optimismPortalProxy).L2_ORACLE();\n }\n _fo.set(_fo.l2OutputOracleProxy.selector, l2OutputOracleProxy);\n\n address proposer = IFetcher(l2OutputOracleProxy).PROPOSER();\n _fo.set(_fo.proposer.selector, proposer);\n\n // no fault proofs installed so we're done\n return;\n }\n\n address disputeGameFactoryProxy = _getDisputeGameFactoryProxy(systemConfigProxy);\n if (disputeGameFactoryProxy != address(0)) {\n _fo.set(_fo.disputeGameFactoryProxy.selector, disputeGameFactoryProxy);\n\n address permissionedDisputeGameImpl = _getPermissionedDisputeGame(disputeGameFactoryProxy);\n if (permissionedDisputeGameImpl != address(0)) {\n // permissioned fault proofs installed\n _fo.set(_fo.permissioned.selector, true);\n _fo.set(_fo.permissionedDisputeGameImpl.selector, permissionedDisputeGameImpl);\n\n address challenger = IFetcher(permissionedDisputeGameImpl).challenger();\n _fo.set(_fo.challenger.selector, challenger);\n\n address anchorStateRegistryProxy = IFetcher(permissionedDisputeGameImpl).anchorStateRegistry();\n _fo.set(_fo.anchorStateRegistryProxy.selector, anchorStateRegistryProxy);\n\n address proposer = IFetcher(permissionedDisputeGameImpl).proposer();\n _fo.set(_fo.proposer.selector, proposer);\n\n address delayedWethPermissionedGameProxy = _getDelayedWETHProxy(permissionedDisputeGameImpl);\n _fo.set(_fo.delayedWethPermissionedGameProxy.selector, delayedWethPermissionedGameProxy);\n\n address mipsImpl = IFetcher(permissionedDisputeGameImpl).vm();\n _fo.set(_fo.mipsImpl.selector, mipsImpl);\n\n address preimageOracleImpl = IFetcher(mipsImpl).oracle();\n _fo.set(_fo.preimageOracleImpl.selector, preimageOracleImpl);\n }\n\n address faultDisputeGameImpl = _getFaultDisputeGame(disputeGameFactoryProxy);\n if (faultDisputeGameImpl != address(0)) {\n // permissionless fault proofs installed\n _fo.set(_fo.faultDisputeGameImpl.selector, faultDisputeGameImpl);\n _fo.set(_fo.permissionless.selector, true);\n\n address delayedWethPermissionlessGameProxy = _getDelayedWETHProxy(faultDisputeGameImpl);\n _fo.set(_fo.delayedWethPermissionlessGameProxy.selector, delayedWethPermissionlessGameProxy);\n }\n\n address faultDisputeGameCannonKonaImpl =\n _getFaultDisputeGame(disputeGameFactoryProxy, GameTypes.CANNON_KONA);\n if (faultDisputeGameCannonKonaImpl != address(0)) {\n _fo.set(_fo.faultDisputeGameCannonKonaImpl.selector, faultDisputeGameCannonKonaImpl);\n }\n } else {\n // some older chains have L2OutputOracle instead of DisputeGameFactory.\n address l2OutputOracleProxy = IFetcher(optimismPortalProxy).L2_ORACLE();\n _fo.set(_fo.l2OutputOracleProxy.selector, l2OutputOracleProxy);\n address proposer = IFetcher(l2OutputOracleProxy).PROPOSER();\n _fo.set(_fo.proposer.selector, proposer);\n }\n }\n\n function _getGuardian(address _portal) internal view returns (address) {\n try IFetcher(_portal).guardian() returns (address guardian_) {\n return guardian_;\n } catch {\n return IFetcher(_portal).GUARDIAN();\n }\n }\n\n function _getSystemConfigProxy(address _portal) internal view returns (address) {\n try IFetcher(_portal).systemConfig() returns (address systemConfig_) {\n return systemConfig_;\n } catch {\n return IFetcher(_portal).SYSTEM_CONFIG();\n }\n }\n\n function _getOptimismPortalProxy(address _l1CrossDomainMessengerProxy) internal view returns (address) {\n try IFetcher(_l1CrossDomainMessengerProxy).portal() returns (address optimismPortal_) {\n return optimismPortal_;\n } catch {\n return IFetcher(_l1CrossDomainMessengerProxy).PORTAL();\n }\n }\n\n function _getAddressManager(address _l1CrossDomainMessengerProxy) internal view returns (address) {\n uint256 ADDRESS_MANAGER_MAPPING_SLOT = 1;\n bytes32 slot = keccak256(abi.encode(_l1CrossDomainMessengerProxy, ADDRESS_MANAGER_MAPPING_SLOT));\n return address(uint160(uint256((vm.load(_l1CrossDomainMessengerProxy, slot)))));\n }\n\n function _getL1ERC721BridgeProxy(address _systemConfigProxy) internal view returns (address) {\n try IFetcher(_systemConfigProxy).l1ERC721Bridge() returns (address l1ERC721BridgeProxy_) {\n return l1ERC721BridgeProxy_;\n } catch {\n return address(0);\n }\n }\n\n function _getOptimismMintableERC20FactoryProxy(address _systemConfigProxy) internal view returns (address) {\n try IFetcher(_systemConfigProxy).optimismMintableERC20Factory() returns (\n address optimismMintableERC20FactoryProxy_\n ) {\n return optimismMintableERC20FactoryProxy_;\n } catch {\n return address(0);\n }\n }\n\n function _getDisputeGameFactoryProxy(address _systemConfigProxy) internal view returns (address) {\n try IFetcher(_systemConfigProxy).disputeGameFactory() returns (address disputeGameFactoryProxy_) {\n return disputeGameFactoryProxy_;\n } catch {\n // Some older chains have L2OutputOracle instead of DisputeGameFactory\n return address(0);\n }\n }\n\n function _getSuperchainConfigProxy(address _optimismPortalProxy) internal view returns (address) {\n try IFetcher(_optimismPortalProxy).superchainConfig() returns (address superchainConfigProxy_) {\n return superchainConfigProxy_;\n } catch {\n return address(0);\n }\n }\n\n function _getFaultDisputeGame(address _disputeGameFactoryProxy) internal view returns (address) {\n try IFetcher(_disputeGameFactoryProxy).gameImpls(GameTypes.CANNON) returns (address faultDisputeGame_) {\n return faultDisputeGame_;\n } catch {\n return address(0);\n }\n }\n\n function _getFaultDisputeGame(\n address _disputeGameFactoryProxy,\n GameType _gameType\n )\n internal\n view\n returns (address)\n {\n try IFetcher(_disputeGameFactoryProxy).gameImpls(_gameType) returns (address faultDisputeGame_) {\n return faultDisputeGame_;\n } catch {\n return address(0);\n }\n }\n\n function _getPermissionedDisputeGame(address _disputeGameFactoryProxy) internal view returns (address) {\n try IFetcher(_disputeGameFactoryProxy).gameImpls(GameTypes.PERMISSIONED_CANNON) returns (\n address permissionedDisputeGame_\n ) {\n return permissionedDisputeGame_;\n } catch {\n return address(0);\n }\n }\n\n function _getEthLockboxProxy(address _optimismPortalProxy) internal view returns (address) {\n try IFetcher(_optimismPortalProxy).ethLockbox() returns (address ethLockbox_) {\n return ethLockbox_;\n } catch {\n return address(0);\n }\n }\n\n function _getDelayedWETHProxy(address _disputeGame) internal view returns (address) {\n (bool ok, bytes memory data) = address(_disputeGame).staticcall(abi.encodeCall(IFetcher.weth, ()));\n if (ok && data.length == 32) return abi.decode(data, (address));\n else return address(0);\n }\n\n function _getBatchSubmitter(address _systemConfigProxy) internal view returns (address) {\n bytes32 batcherHash = IFetcher(_systemConfigProxy).batcherHash();\n return address(uint160(uint256(batcherHash)));\n }\n\n function _getProxyAdmin(address _systemConfigProxy) internal returns (address) {\n vm.prank(address(0));\n return IFetcher(_systemConfigProxy).admin();\n }\n}\n","license":"MIT"},"src/dispute/lib/LibPosition.sol":{"keccak256":"0x7c5f19f8f54f06de2ce1c6cdcc5c7af65ac405130a4066cdaf146ca315818241","urls":[],"content":"// SPDX-License-Identifier: MIT\npragma solidity ^0.8.15;\n\nusing LibPosition for Position global;\n\n/// @notice A `Position` represents a position of a claim within the game tree.\n/// @dev This is represented as a \"generalized index\" where the high-order bit\n/// is the level in the tree and the remaining bits is a unique bit pattern, allowing\n/// a unique identifier for each node in the tree. Mathematically, it is calculated\n/// as 2^{depth} + indexAtDepth.\ntype Position is uint128;\n\n/// @title LibPosition\n/// @notice This library contains helper functions for working with the `Position` type.\nlibrary LibPosition {\n /// @notice the `MAX_POSITION_BITLEN` is the number of bits that the `Position` type, and the implementation of\n /// its behavior within this library, can safely support.\n uint8 internal constant MAX_POSITION_BITLEN = 126;\n\n /// @notice Computes a generalized index (2^{depth} + indexAtDepth).\n /// @param _depth The depth of the position.\n /// @param _indexAtDepth The index at the depth of the position.\n /// @return position_ The computed generalized index.\n function wrap(uint8 _depth, uint128 _indexAtDepth) internal pure returns (Position position_) {\n assembly {\n // gindex = 2^{_depth} + _indexAtDepth\n position_ := add(shl(_depth, 1), _indexAtDepth)\n }\n }\n\n /// @notice Pulls the `depth` out of a `Position` type.\n /// @param _position The generalized index to get the `depth` of.\n /// @return depth_ The `depth` of the `position` gindex.\n /// @custom:attribution Solady \n function depth(Position _position) internal pure returns (uint8 depth_) {\n // Return the most significant bit offset, which signifies the depth of the gindex.\n assembly {\n depth_ := or(depth_, shl(6, lt(0xffffffffffffffff, shr(depth_, _position))))\n depth_ := or(depth_, shl(5, lt(0xffffffff, shr(depth_, _position))))\n\n // For the remaining 32 bits, use a De Bruijn lookup.\n _position := shr(depth_, _position)\n _position := or(_position, shr(1, _position))\n _position := or(_position, shr(2, _position))\n _position := or(_position, shr(4, _position))\n _position := or(_position, shr(8, _position))\n _position := or(_position, shr(16, _position))\n\n depth_ :=\n or(\n depth_,\n byte(\n shr(251, mul(_position, shl(224, 0x07c4acdd))),\n 0x0009010a0d15021d0b0e10121619031e080c141c0f111807131b17061a05041f\n )\n )\n }\n }\n\n /// @notice Pulls the `indexAtDepth` out of a `Position` type.\n /// The `indexAtDepth` is the left/right index of a position at a specific depth within\n /// the binary tree, starting from index 0. For example, at gindex 2, the `depth` = 1\n /// and the `indexAtDepth` = 0.\n /// @param _position The generalized index to get the `indexAtDepth` of.\n /// @return indexAtDepth_ The `indexAtDepth` of the `position` gindex.\n function indexAtDepth(Position _position) internal pure returns (uint128 indexAtDepth_) {\n // Return bits p_{msb-1}...p_{0}. This effectively pulls the 2^{depth} out of the gindex,\n // leaving only the `indexAtDepth`.\n uint256 msb = depth(_position);\n assembly {\n indexAtDepth_ := sub(_position, shl(msb, 1))\n }\n }\n\n /// @notice Get the left child of `_position`.\n /// @param _position The position to get the left position of.\n /// @return left_ The position to the left of `position`.\n function left(Position _position) internal pure returns (Position left_) {\n assembly {\n left_ := shl(1, _position)\n }\n }\n\n /// @notice Get the right child of `_position`\n /// @param _position The position to get the right position of.\n /// @return right_ The position to the right of `position`.\n function right(Position _position) internal pure returns (Position right_) {\n assembly {\n right_ := or(1, shl(1, _position))\n }\n }\n\n /// @notice Get the parent position of `_position`.\n /// @param _position The position to get the parent position of.\n /// @return parent_ The parent position of `position`.\n function parent(Position _position) internal pure returns (Position parent_) {\n assembly {\n parent_ := shr(1, _position)\n }\n }\n\n /// @notice Get the deepest, right most gindex relative to the `position`. This is equivalent to\n /// calling `right` on a position until the maximum depth is reached.\n /// @param _position The position to get the relative deepest, right most gindex of.\n /// @param _maxDepth The maximum depth of the game.\n /// @return rightIndex_ The deepest, right most gindex relative to the `position`.\n function rightIndex(Position _position, uint256 _maxDepth) internal pure returns (Position rightIndex_) {\n uint256 msb = depth(_position);\n assembly {\n let remaining := sub(_maxDepth, msb)\n rightIndex_ := or(shl(remaining, _position), sub(shl(remaining, 1), 1))\n }\n }\n\n /// @notice Get the deepest, right most trace index relative to the `position`. This is\n /// equivalent to calling `right` on a position until the maximum depth is reached and\n /// then finding its index at depth.\n /// @param _position The position to get the relative trace index of.\n /// @param _maxDepth The maximum depth of the game.\n /// @return traceIndex_ The trace index relative to the `position`.\n function traceIndex(Position _position, uint256 _maxDepth) internal pure returns (uint256 traceIndex_) {\n uint256 msb = depth(_position);\n assembly {\n let remaining := sub(_maxDepth, msb)\n traceIndex_ := sub(or(shl(remaining, _position), sub(shl(remaining, 1), 1)), shl(_maxDepth, 1))\n }\n }\n\n /// @notice Gets the position of the highest ancestor of `_position` that commits to the same\n /// trace index.\n /// @param _position The position to get the highest ancestor of.\n /// @return ancestor_ The highest ancestor of `position` that commits to the same trace index.\n function traceAncestor(Position _position) internal pure returns (Position ancestor_) {\n // Create a field with only the lowest unset bit of `_position` set.\n Position lsb;\n assembly {\n lsb := and(not(_position), add(_position, 1))\n }\n // Find the index of the lowest unset bit within the field.\n uint256 msb = depth(lsb);\n // The highest ancestor that commits to the same trace index is the original position\n // shifted right by the index of the lowest unset bit.\n assembly {\n let a := shr(msb, _position)\n // Bound the ancestor to the minimum gindex, 1.\n ancestor_ := or(a, iszero(a))\n }\n }\n\n /// @notice Gets the position of the highest ancestor of `_position` that commits to the same\n /// trace index, while still being below `_upperBoundExclusive`.\n /// @param _position The position to get the highest ancestor of.\n /// @param _upperBoundExclusive The exclusive upper depth bound, used to inform where to stop in order\n /// to not escape a sub-tree.\n /// @return ancestor_ The highest ancestor of `position` that commits to the same trace index.\n function traceAncestorBounded(\n Position _position,\n uint256 _upperBoundExclusive\n )\n internal\n pure\n returns (Position ancestor_)\n {\n // This function only works for positions that are below the upper bound.\n if (_position.depth() <= _upperBoundExclusive) {\n assembly {\n // Revert with `ClaimAboveSplit()`\n mstore(0x00, 0xb34b5c22)\n revert(0x1C, 0x04)\n }\n }\n\n // Grab the global trace ancestor.\n ancestor_ = traceAncestor(_position);\n\n // If the ancestor is above or at the upper bound, shift it to be below the upper bound.\n // This should be a special case that only covers positions that commit to the final leaf\n // in a sub-tree.\n if (ancestor_.depth() <= _upperBoundExclusive) {\n ancestor_ = ancestor_.rightIndex(_upperBoundExclusive + 1);\n }\n }\n\n /// @notice Get the move position of `_position`, which is the left child of:\n /// 1. `_position` if `_isAttack` is true.\n /// 2. `_position | 1` if `_isAttack` is false.\n /// @param _position The position to get the relative attack/defense position of.\n /// @param _isAttack Whether or not the move is an attack move.\n /// @return move_ The move position relative to `position`.\n function move(Position _position, bool _isAttack) internal pure returns (Position move_) {\n assembly {\n move_ := shl(1, or(iszero(_isAttack), _position))\n }\n }\n\n /// @notice Get the value of a `Position` type in the form of the underlying uint128.\n /// @param _position The position to get the value of.\n /// @return raw_ The value of the `position` as a uint128 type.\n function raw(Position _position) internal pure returns (uint128 raw_) {\n assembly {\n raw_ := _position\n }\n }\n}\n","license":"MIT"},"src/dispute/lib/LibUDT.sol":{"keccak256":"0x41d55e9c74d979b5b797198e38449e7cef4f925e04d61f7699e9c150c4a659d3","urls":[],"content":"// SPDX-License-Identifier: MIT\npragma solidity ^0.8.15;\n\n// Libraries\nimport { Position } from \"src/dispute/lib/LibPosition.sol\";\n\nusing LibClaim for Claim global;\nusing LibHash for Hash global;\nusing LibDuration for Duration global;\nusing LibClock for Clock global;\nusing LibGameId for GameId global;\nusing LibTimestamp for Timestamp global;\nusing LibVMStatus for VMStatus global;\nusing LibGameType for GameType global;\n\n/// @notice A `Clock` represents a packed `Duration` and `Timestamp`\n/// @dev The packed layout of this type is as follows:\n/// ┌────────────┬────────────────┐\n/// │ Bits │ Value │\n/// ├────────────┼────────────────┤\n/// │ [0, 64) │ Duration │\n/// │ [64, 128) │ Timestamp │\n/// └────────────┴────────────────┘\ntype Clock is uint128;\n\n/// @title LibClock\n/// @notice This library contains helper functions for working with the `Clock` type.\nlibrary LibClock {\n /// @notice Packs a `Duration` and `Timestamp` into a `Clock` type.\n /// @param _duration The `Duration` to pack into the `Clock` type.\n /// @param _timestamp The `Timestamp` to pack into the `Clock` type.\n /// @return clock_ The `Clock` containing the `_duration` and `_timestamp`.\n function wrap(Duration _duration, Timestamp _timestamp) internal pure returns (Clock clock_) {\n assembly {\n clock_ := or(shl(0x40, _duration), _timestamp)\n }\n }\n\n /// @notice Pull the `Duration` out of a `Clock` type.\n /// @param _clock The `Clock` type to pull the `Duration` out of.\n /// @return duration_ The `Duration` pulled out of `_clock`.\n function duration(Clock _clock) internal pure returns (Duration duration_) {\n // Shift the high-order 64 bits into the low-order 64 bits, leaving only the `duration`.\n assembly {\n duration_ := shr(0x40, _clock)\n }\n }\n\n /// @notice Pull the `Timestamp` out of a `Clock` type.\n /// @param _clock The `Clock` type to pull the `Timestamp` out of.\n /// @return timestamp_ The `Timestamp` pulled out of `_clock`.\n function timestamp(Clock _clock) internal pure returns (Timestamp timestamp_) {\n // Clean the high-order 192 bits by shifting the clock left and then right again, leaving\n // only the `timestamp`.\n assembly {\n timestamp_ := shr(0xC0, shl(0xC0, _clock))\n }\n }\n\n /// @notice Get the value of a `Clock` type in the form of the underlying uint128.\n /// @param _clock The `Clock` type to get the value of.\n /// @return clock_ The value of the `Clock` type as a uint128 type.\n function raw(Clock _clock) internal pure returns (uint128 clock_) {\n assembly {\n clock_ := _clock\n }\n }\n}\n\n/// @notice A `GameId` represents a packed 4 byte game ID, a 8 byte timestamp, and a 20 byte address.\n/// @dev The packed layout of this type is as follows:\n/// ┌───────────┬───────────┐\n/// │ Bits │ Value │\n/// ├───────────┼───────────┤\n/// │ [0, 32) │ Game Type │\n/// │ [32, 96) │ Timestamp │\n/// │ [96, 256) │ Address │\n/// └───────────┴───────────┘\ntype GameId is bytes32;\n\n/// @title LibGameId\n/// @notice Utility functions for packing and unpacking GameIds.\nlibrary LibGameId {\n /// @notice Packs values into a 32 byte GameId type.\n /// @param _gameType The game type.\n /// @param _timestamp The timestamp of the game's creation.\n /// @param _gameProxy The game proxy address.\n /// @return gameId_ The packed GameId.\n function pack(\n GameType _gameType,\n Timestamp _timestamp,\n address _gameProxy\n )\n internal\n pure\n returns (GameId gameId_)\n {\n assembly {\n gameId_ := or(or(shl(224, _gameType), shl(160, _timestamp)), _gameProxy)\n }\n }\n\n /// @notice Unpacks values from a 32 byte GameId type.\n /// @param _gameId The packed GameId.\n /// @return gameType_ The game type.\n /// @return timestamp_ The timestamp of the game's creation.\n /// @return gameProxy_ The game proxy address.\n function unpack(GameId _gameId)\n internal\n pure\n returns (GameType gameType_, Timestamp timestamp_, address gameProxy_)\n {\n assembly {\n gameType_ := shr(224, _gameId)\n timestamp_ := and(shr(160, _gameId), 0xFFFFFFFFFFFFFFFF)\n gameProxy_ := and(_gameId, 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF)\n }\n }\n}\n\n/// @notice A claim represents an MPT root representing the state of the fault proof program.\ntype Claim is bytes32;\n\n/// @title LibClaim\n/// @notice This library contains helper functions for working with the `Claim` type.\nlibrary LibClaim {\n /// @notice Get the value of a `Claim` type in the form of the underlying bytes32.\n /// @param _claim The `Claim` type to get the value of.\n /// @return claim_ The value of the `Claim` type as a bytes32 type.\n function raw(Claim _claim) internal pure returns (bytes32 claim_) {\n assembly {\n claim_ := _claim\n }\n }\n\n /// @notice Hashes a claim and a position together.\n /// @param _claim A Claim type.\n /// @param _position The position of `claim`.\n /// @param _challengeIndex The index of the claim being moved against.\n /// @return claimHash_ A hash of abi.encodePacked(claim, position|challengeIndex);\n function hashClaimPos(\n Claim _claim,\n Position _position,\n uint256 _challengeIndex\n )\n internal\n pure\n returns (Hash claimHash_)\n {\n assembly {\n mstore(0x00, _claim)\n mstore(0x20, or(shl(128, _position), and(0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF, _challengeIndex)))\n claimHash_ := keccak256(0x00, 0x40)\n }\n }\n}\n\n/// @notice A dedicated duration type.\n/// @dev Unit: seconds\ntype Duration is uint64;\n\n/// @title LibDuration\n/// @notice This library contains helper functions for working with the `Duration` type.\nlibrary LibDuration {\n /// @notice Get the value of a `Duration` type in the form of the underlying uint64.\n /// @param _duration The `Duration` type to get the value of.\n /// @return duration_ The value of the `Duration` type as a uint64 type.\n function raw(Duration _duration) internal pure returns (uint64 duration_) {\n assembly {\n duration_ := _duration\n }\n }\n}\n\n/// @notice A custom type for a generic hash.\ntype Hash is bytes32;\n\n/// @title LibHash\n/// @notice This library contains helper functions for working with the `Hash` type.\nlibrary LibHash {\n /// @notice Get the value of a `Hash` type in the form of the underlying bytes32.\n /// @param _hash The `Hash` type to get the value of.\n /// @return hash_ The value of the `Hash` type as a bytes32 type.\n function raw(Hash _hash) internal pure returns (bytes32 hash_) {\n assembly {\n hash_ := _hash\n }\n }\n}\n\n/// @notice A dedicated timestamp type.\ntype Timestamp is uint64;\n\n/// @title LibTimestamp\n/// @notice This library contains helper functions for working with the `Timestamp` type.\nlibrary LibTimestamp {\n /// @notice Get the value of a `Timestamp` type in the form of the underlying uint64.\n /// @param _timestamp The `Timestamp` type to get the value of.\n /// @return timestamp_ The value of the `Timestamp` type as a uint64 type.\n function raw(Timestamp _timestamp) internal pure returns (uint64 timestamp_) {\n assembly {\n timestamp_ := _timestamp\n }\n }\n}\n\n/// @notice A `VMStatus` represents the status of a VM execution.\ntype VMStatus is uint8;\n\n/// @title LibVMStatus\n/// @notice This library contains helper functions for working with the `VMStatus` type.\nlibrary LibVMStatus {\n /// @notice Get the value of a `VMStatus` type in the form of the underlying uint8.\n /// @param _vmstatus The `VMStatus` type to get the value of.\n /// @return vmstatus_ The value of the `VMStatus` type as a uint8 type.\n function raw(VMStatus _vmstatus) internal pure returns (uint8 vmstatus_) {\n assembly {\n vmstatus_ := _vmstatus\n }\n }\n}\n\n/// @notice A `GameType` represents the type of game being played.\ntype GameType is uint32;\n\n/// @title LibGameType\n/// @notice This library contains helper functions for working with the `GameType` type.\nlibrary LibGameType {\n /// @notice Get the value of a `GameType` type in the form of the underlying uint32.\n /// @param _gametype The `GameType` type to get the value of.\n /// @return gametype_ The value of the `GameType` type as a uint32 type.\n function raw(GameType _gametype) internal pure returns (uint32 gametype_) {\n assembly {\n gametype_ := _gametype\n }\n }\n}\n","license":"MIT"},"src/dispute/lib/Types.sol":{"keccak256":"0x468fccc8d6ce3ac5b87bdd5002f84b315ac861be7655ceef87a018f596c410a1","urls":[],"content":"// SPDX-License-Identifier: MIT\npragma solidity ^0.8.15;\n\n// Libraries\nimport {\n Position,\n Hash,\n GameType,\n VMStatus,\n Timestamp,\n Duration,\n Clock,\n GameId,\n Claim,\n LibGameId,\n LibClock\n} from \"src/dispute/lib/LibUDT.sol\";\n\n/// @notice The current status of the dispute game.\nenum GameStatus {\n // The game is currently in progress, and has not been resolved.\n IN_PROGRESS,\n // The game has concluded, and the `rootClaim` was challenged successfully.\n CHALLENGER_WINS,\n // The game has concluded, and the `rootClaim` could not be contested.\n DEFENDER_WINS\n}\n\n/// @notice The game's bond distribution type. Games are expected to start in the `UNDECIDED`\n/// state, and then choose either `NORMAL` or `REFUND`.\nenum BondDistributionMode {\n // Bond distribution strategy has not been chosen.\n UNDECIDED,\n // Bonds should be distributed as normal.\n NORMAL,\n // Bonds should be refunded to claimants.\n REFUND\n}\n\n/// @notice Represents an L2 root and the L2 sequence number at which it was generated.\n/// @custom:field root The output root.\n/// @custom:field l2SequenceNumber The L2 Sequence Number ( e.g. block number / timestamp) at which the root was\n/// generated.\nstruct Proposal {\n Hash root;\n uint256 l2SequenceNumber;\n}\n\n/// @title GameTypes\n/// @notice A library that defines the IDs of games that can be played.\nlibrary GameTypes {\n /// @dev A dispute game type the uses the cannon vm.\n GameType internal constant CANNON = GameType.wrap(0);\n\n /// @dev A permissioned dispute game type that uses the cannon vm.\n GameType internal constant PERMISSIONED_CANNON = GameType.wrap(1);\n\n /// @notice A dispute game type that uses the asterisc vm.\n GameType internal constant ASTERISC = GameType.wrap(2);\n\n /// @notice A dispute game type that uses the asterisc vm with Kona.\n GameType internal constant ASTERISC_KONA = GameType.wrap(3);\n\n /// @notice A dispute game type that uses the cannon vm (Super Roots).\n GameType internal constant SUPER_CANNON = GameType.wrap(4);\n\n /// @notice A dispute game type that uses the permissioned cannon vm (Super Roots).\n GameType internal constant SUPER_PERMISSIONED_CANNON = GameType.wrap(5);\n\n /// @notice A dispute game type that uses OP Succinct\n GameType internal constant OP_SUCCINCT = GameType.wrap(6);\n\n /// @notice A dispute game type that uses the asterisc vm with Kona (Super Roots).\n GameType internal constant SUPER_ASTERISC_KONA = GameType.wrap(7);\n\n /// @notice A dispute game type that uses the cannon vm with Kona.\n GameType internal constant CANNON_KONA = GameType.wrap(8);\n\n /// @notice A dispute game type that uses the cannon vm with Kona (Super Roots).\n GameType internal constant SUPER_CANNON_KONA = GameType.wrap(9);\n\n /// @notice A dispute game type with short game duration for testing withdrawals.\n /// Not intended for production use.\n GameType internal constant FAST = GameType.wrap(254);\n\n /// @notice A dispute game type that uses an alphabet vm.\n /// Not intended for production use.\n GameType internal constant ALPHABET = GameType.wrap(255);\n\n /// @notice A dispute game type that uses RISC Zero's Kailua\n GameType internal constant KAILUA = GameType.wrap(1337);\n}\n\n/// @title VMStatuses\n/// @notice Named type aliases for the various valid VM status bytes.\nlibrary VMStatuses {\n /// @notice The VM has executed successfully and the outcome is valid.\n VMStatus internal constant VALID = VMStatus.wrap(0);\n\n /// @notice The VM has executed successfully and the outcome is invalid.\n VMStatus internal constant INVALID = VMStatus.wrap(1);\n\n /// @notice The VM has paniced.\n VMStatus internal constant PANIC = VMStatus.wrap(2);\n\n /// @notice The VM execution is still in progress.\n VMStatus internal constant UNFINISHED = VMStatus.wrap(3);\n}\n\n/// @title LocalPreimageKey\n/// @notice Named type aliases for local `PreimageOracle` key identifiers.\nlibrary LocalPreimageKey {\n /// @notice The identifier for the L1 head hash.\n uint256 internal constant L1_HEAD_HASH = 0x01;\n\n /// @notice The identifier for the starting output root.\n uint256 internal constant STARTING_OUTPUT_ROOT = 0x02;\n\n /// @notice The identifier for the disputed output root.\n uint256 internal constant DISPUTED_OUTPUT_ROOT = 0x03;\n\n /// @notice The identifier for the disputed L2 block number.\n uint256 internal constant DISPUTED_L2_BLOCK_NUMBER = 0x04;\n\n /// @notice The identifier for the chain ID.\n uint256 internal constant CHAIN_ID = 0x05;\n}\n","license":"MIT"}},"version":1},"storageLayout":{"storage":[{"astId":54043,"contract":"scripts/FetchChainInfo.s.sol:FetchChainInfoOutput","label":"_superchainConfigProxy","offset":0,"slot":"0","type":"t_address"},{"astId":54045,"contract":"scripts/FetchChainInfo.s.sol:FetchChainInfoOutput","label":"_mipsImpl","offset":0,"slot":"1","type":"t_address"},{"astId":54047,"contract":"scripts/FetchChainInfo.s.sol:FetchChainInfoOutput","label":"_preimageOracleImpl","offset":0,"slot":"2","type":"t_address"},{"astId":54049,"contract":"scripts/FetchChainInfo.s.sol:FetchChainInfoOutput","label":"_addressManagerImpl","offset":0,"slot":"3","type":"t_address"},{"astId":54051,"contract":"scripts/FetchChainInfo.s.sol:FetchChainInfoOutput","label":"_ethLockboxProxy","offset":0,"slot":"4","type":"t_address"},{"astId":54053,"contract":"scripts/FetchChainInfo.s.sol:FetchChainInfoOutput","label":"_l1CrossDomainMessengerProxy","offset":0,"slot":"5","type":"t_address"},{"astId":54055,"contract":"scripts/FetchChainInfo.s.sol:FetchChainInfoOutput","label":"_l1Erc721BridgeProxy","offset":0,"slot":"6","type":"t_address"},{"astId":54057,"contract":"scripts/FetchChainInfo.s.sol:FetchChainInfoOutput","label":"_l1StandardBridgeProxy","offset":0,"slot":"7","type":"t_address"},{"astId":54059,"contract":"scripts/FetchChainInfo.s.sol:FetchChainInfoOutput","label":"_l2OutputOracleProxy","offset":0,"slot":"8","type":"t_address"},{"astId":54061,"contract":"scripts/FetchChainInfo.s.sol:FetchChainInfoOutput","label":"_optimismMintableErc20FactoryProxy","offset":0,"slot":"9","type":"t_address"},{"astId":54063,"contract":"scripts/FetchChainInfo.s.sol:FetchChainInfoOutput","label":"_optimismPortalProxy","offset":0,"slot":"10","type":"t_address"},{"astId":54065,"contract":"scripts/FetchChainInfo.s.sol:FetchChainInfoOutput","label":"_systemConfigProxy","offset":0,"slot":"11","type":"t_address"},{"astId":54067,"contract":"scripts/FetchChainInfo.s.sol:FetchChainInfoOutput","label":"_opChainProxyAdminImpl","offset":0,"slot":"12","type":"t_address"},{"astId":54069,"contract":"scripts/FetchChainInfo.s.sol:FetchChainInfoOutput","label":"_anchorStateRegistryProxy","offset":0,"slot":"13","type":"t_address"},{"astId":54071,"contract":"scripts/FetchChainInfo.s.sol:FetchChainInfoOutput","label":"_delayedWethPermissionedGameProxy","offset":0,"slot":"14","type":"t_address"},{"astId":54073,"contract":"scripts/FetchChainInfo.s.sol:FetchChainInfoOutput","label":"_delayedWethPermissionlessGameProxy","offset":0,"slot":"15","type":"t_address"},{"astId":54075,"contract":"scripts/FetchChainInfo.s.sol:FetchChainInfoOutput","label":"_disputeGameFactoryProxy","offset":0,"slot":"16","type":"t_address"},{"astId":54077,"contract":"scripts/FetchChainInfo.s.sol:FetchChainInfoOutput","label":"_faultDisputeGameImpl","offset":0,"slot":"17","type":"t_address"},{"astId":54079,"contract":"scripts/FetchChainInfo.s.sol:FetchChainInfoOutput","label":"_faultDisputeGameCannonKonaImpl","offset":0,"slot":"18","type":"t_address"},{"astId":54081,"contract":"scripts/FetchChainInfo.s.sol:FetchChainInfoOutput","label":"_permissionedDisputeGameImpl","offset":0,"slot":"19","type":"t_address"},{"astId":54083,"contract":"scripts/FetchChainInfo.s.sol:FetchChainInfoOutput","label":"_systemConfigOwner","offset":0,"slot":"20","type":"t_address"},{"astId":54085,"contract":"scripts/FetchChainInfo.s.sol:FetchChainInfoOutput","label":"_opChainProxyAdminOwner","offset":0,"slot":"21","type":"t_address"},{"astId":54087,"contract":"scripts/FetchChainInfo.s.sol:FetchChainInfoOutput","label":"_opChainGuardian","offset":0,"slot":"22","type":"t_address"},{"astId":54089,"contract":"scripts/FetchChainInfo.s.sol:FetchChainInfoOutput","label":"_challenger","offset":0,"slot":"23","type":"t_address"},{"astId":54091,"contract":"scripts/FetchChainInfo.s.sol:FetchChainInfoOutput","label":"_proposer","offset":0,"slot":"24","type":"t_address"},{"astId":54093,"contract":"scripts/FetchChainInfo.s.sol:FetchChainInfoOutput","label":"_unsafeBlockSigner","offset":0,"slot":"25","type":"t_address"},{"astId":54095,"contract":"scripts/FetchChainInfo.s.sol:FetchChainInfoOutput","label":"_batchSubmitter","offset":0,"slot":"26","type":"t_address"},{"astId":54097,"contract":"scripts/FetchChainInfo.s.sol:FetchChainInfoOutput","label":"_permissioned","offset":20,"slot":"26","type":"t_bool"},{"astId":54099,"contract":"scripts/FetchChainInfo.s.sol:FetchChainInfoOutput","label":"_permissionless","offset":21,"slot":"26","type":"t_bool"},{"astId":54102,"contract":"scripts/FetchChainInfo.s.sol:FetchChainInfoOutput","label":"_respectedGameType","offset":22,"slot":"26","type":"t_userDefinedValueType(GameType)70720"}],"types":{"t_address":{"encoding":"inplace","label":"address","numberOfBytes":"20"},"t_bool":{"encoding":"inplace","label":"bool","numberOfBytes":"1"},"t_userDefinedValueType(GameType)70720":{"encoding":"inplace","label":"GameType","numberOfBytes":"4"}}},"userdoc":{"version":1,"kind":"user"},"devdoc":{"version":1,"kind":"dev"},"ast":{"absolutePath":"scripts/FetchChainInfo.s.sol","id":56019,"exportedSymbols":{"FetchChainInfo":[56018],"FetchChainInfoInput":[54041],"FetchChainInfoOutput":[54911],"GameType":[70720],"GameTypes":[70870],"IFetcher":[53958],"Script":[5558]},"nodeType":"SourceUnit","src":"32:25120:100","nodes":[{"id":53807,"nodeType":"PragmaDirective","src":"32:23:100","nodes":[],"literals":["solidity","^","0.8",".0"]},{"id":53809,"nodeType":"ImportDirective","src":"57:46:100","nodes":[],"absolutePath":"lib/forge-std/src/Script.sol","file":"forge-std/Script.sol","nameLocation":"-1:-1:-1","scope":56019,"sourceUnit":5559,"symbolAliases":[{"foreign":{"id":53808,"name":"Script","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":5558,"src":"66:6:100","typeDescriptions":{}},"nameLocation":"-1:-1:-1"}],"unitAlias":""},{"id":53812,"nodeType":"ImportDirective","src":"104:64:100","nodes":[],"absolutePath":"src/dispute/lib/Types.sol","file":"src/dispute/lib/Types.sol","nameLocation":"-1:-1:-1","scope":56019,"sourceUnit":70927,"symbolAliases":[{"foreign":{"id":53810,"name":"GameTypes","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":70870,"src":"113:9:100","typeDescriptions":{}},"nameLocation":"-1:-1:-1"},{"foreign":{"id":53811,"name":"GameType","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":70720,"src":"124:8:100","typeDescriptions":{}},"nameLocation":"-1:-1:-1"}],"unitAlias":""},{"id":53958,"nodeType":"ContractDefinition","src":"306:1713:100","nodes":[{"id":53818,"nodeType":"FunctionDefinition","src":"331:52:100","nodes":[],"functionSelector":"452a9320","implemented":false,"kind":"function","modifiers":[],"name":"guardian","nameLocation":"340:8:100","parameters":{"id":53814,"nodeType":"ParameterList","parameters":[],"src":"348:2:100"},"returnParameters":{"id":53817,"nodeType":"ParameterList","parameters":[{"constant":false,"id":53816,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":53818,"src":"374:7:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":53815,"name":"address","nodeType":"ElementaryTypeName","src":"374:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"373:9:100"},"scope":53958,"stateMutability":"view","virtual":false,"visibility":"external"},{"id":53823,"nodeType":"FunctionDefinition","src":"388:52:100","nodes":[],"functionSelector":"724c184c","implemented":false,"kind":"function","modifiers":[],"name":"GUARDIAN","nameLocation":"397:8:100","parameters":{"id":53819,"nodeType":"ParameterList","parameters":[],"src":"405:2:100"},"returnParameters":{"id":53822,"nodeType":"ParameterList","parameters":[{"constant":false,"id":53821,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":53823,"src":"431:7:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":53820,"name":"address","nodeType":"ElementaryTypeName","src":"431:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"430:9:100"},"scope":53958,"stateMutability":"view","virtual":false,"visibility":"external"},{"id":53828,"nodeType":"FunctionDefinition","src":"445:56:100","nodes":[],"functionSelector":"33d7e2bd","implemented":false,"kind":"function","modifiers":[],"name":"systemConfig","nameLocation":"454:12:100","parameters":{"id":53824,"nodeType":"ParameterList","parameters":[],"src":"466:2:100"},"returnParameters":{"id":53827,"nodeType":"ParameterList","parameters":[{"constant":false,"id":53826,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":53828,"src":"492:7:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":53825,"name":"address","nodeType":"ElementaryTypeName","src":"492:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"491:9:100"},"scope":53958,"stateMutability":"view","virtual":false,"visibility":"external"},{"id":53833,"nodeType":"FunctionDefinition","src":"506:57:100","nodes":[],"functionSelector":"f0498750","implemented":false,"kind":"function","modifiers":[],"name":"SYSTEM_CONFIG","nameLocation":"515:13:100","parameters":{"id":53829,"nodeType":"ParameterList","parameters":[],"src":"528:2:100"},"returnParameters":{"id":53832,"nodeType":"ParameterList","parameters":[{"constant":false,"id":53831,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":53833,"src":"554:7:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":53830,"name":"address","nodeType":"ElementaryTypeName","src":"554:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"553:9:100"},"scope":53958,"stateMutability":"view","virtual":false,"visibility":"external"},{"id":53838,"nodeType":"FunctionDefinition","src":"568:62:100","nodes":[],"functionSelector":"f2b4e617","implemented":false,"kind":"function","modifiers":[],"name":"disputeGameFactory","nameLocation":"577:18:100","parameters":{"id":53834,"nodeType":"ParameterList","parameters":[],"src":"595:2:100"},"returnParameters":{"id":53837,"nodeType":"ParameterList","parameters":[{"constant":false,"id":53836,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":53838,"src":"621:7:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":53835,"name":"address","nodeType":"ElementaryTypeName","src":"621:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"620:9:100"},"scope":53958,"stateMutability":"view","virtual":false,"visibility":"external"},{"id":53843,"nodeType":"FunctionDefinition","src":"635:54:100","nodes":[],"functionSelector":"b682c444","implemented":false,"kind":"function","modifiers":[],"name":"ethLockbox","nameLocation":"644:10:100","parameters":{"id":53839,"nodeType":"ParameterList","parameters":[],"src":"654:2:100"},"returnParameters":{"id":53842,"nodeType":"ParameterList","parameters":[{"constant":false,"id":53841,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":53843,"src":"680:7:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":53840,"name":"address","nodeType":"ElementaryTypeName","src":"680:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"679:9:100"},"scope":53958,"stateMutability":"view","virtual":false,"visibility":"external"},{"id":53848,"nodeType":"FunctionDefinition","src":"694:60:100","nodes":[],"functionSelector":"35e80ab3","implemented":false,"kind":"function","modifiers":[],"name":"superchainConfig","nameLocation":"703:16:100","parameters":{"id":53844,"nodeType":"ParameterList","parameters":[],"src":"719:2:100"},"returnParameters":{"id":53847,"nodeType":"ParameterList","parameters":[{"constant":false,"id":53846,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":53848,"src":"745:7:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":53845,"name":"address","nodeType":"ElementaryTypeName","src":"745:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"744:9:100"},"scope":53958,"stateMutability":"view","virtual":false,"visibility":"external"},{"id":53853,"nodeType":"FunctionDefinition","src":"759:53:100","nodes":[],"functionSelector":"3cb747bf","implemented":false,"kind":"function","modifiers":[],"name":"messenger","nameLocation":"768:9:100","parameters":{"id":53849,"nodeType":"ParameterList","parameters":[],"src":"777:2:100"},"returnParameters":{"id":53852,"nodeType":"ParameterList","parameters":[{"constant":false,"id":53851,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":53853,"src":"803:7:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":53850,"name":"address","nodeType":"ElementaryTypeName","src":"803:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"802:9:100"},"scope":53958,"stateMutability":"view","virtual":false,"visibility":"external"},{"id":53858,"nodeType":"FunctionDefinition","src":"817:58:100","nodes":[],"functionSelector":"3ab76e9f","implemented":false,"kind":"function","modifiers":[],"name":"addressManager","nameLocation":"826:14:100","parameters":{"id":53854,"nodeType":"ParameterList","parameters":[],"src":"840:2:100"},"returnParameters":{"id":53857,"nodeType":"ParameterList","parameters":[{"constant":false,"id":53856,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":53858,"src":"866:7:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":53855,"name":"address","nodeType":"ElementaryTypeName","src":"866:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"865:9:100"},"scope":53958,"stateMutability":"view","virtual":false,"visibility":"external"},{"id":53863,"nodeType":"FunctionDefinition","src":"880:50:100","nodes":[],"functionSelector":"0ff754ea","implemented":false,"kind":"function","modifiers":[],"name":"PORTAL","nameLocation":"889:6:100","parameters":{"id":53859,"nodeType":"ParameterList","parameters":[],"src":"895:2:100"},"returnParameters":{"id":53862,"nodeType":"ParameterList","parameters":[{"constant":false,"id":53861,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":53863,"src":"921:7:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":53860,"name":"address","nodeType":"ElementaryTypeName","src":"921:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"920:9:100"},"scope":53958,"stateMutability":"view","virtual":false,"visibility":"external"},{"id":53868,"nodeType":"FunctionDefinition","src":"935:50:100","nodes":[],"functionSelector":"6425666b","implemented":false,"kind":"function","modifiers":[],"name":"portal","nameLocation":"944:6:100","parameters":{"id":53864,"nodeType":"ParameterList","parameters":[],"src":"950:2:100"},"returnParameters":{"id":53867,"nodeType":"ParameterList","parameters":[{"constant":false,"id":53866,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":53868,"src":"976:7:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":53865,"name":"address","nodeType":"ElementaryTypeName","src":"976:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"975:9:100"},"scope":53958,"stateMutability":"view","virtual":false,"visibility":"external"},{"id":53873,"nodeType":"FunctionDefinition","src":"990:58:100","nodes":[],"functionSelector":"c4e8ddfa","implemented":false,"kind":"function","modifiers":[],"name":"l1ERC721Bridge","nameLocation":"999:14:100","parameters":{"id":53869,"nodeType":"ParameterList","parameters":[],"src":"1013:2:100"},"returnParameters":{"id":53872,"nodeType":"ParameterList","parameters":[{"constant":false,"id":53871,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":53873,"src":"1039:7:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":53870,"name":"address","nodeType":"ElementaryTypeName","src":"1039:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"1038:9:100"},"scope":53958,"stateMutability":"view","virtual":false,"visibility":"external"},{"id":53878,"nodeType":"FunctionDefinition","src":"1053:72:100","nodes":[],"functionSelector":"9b7d7f0a","implemented":false,"kind":"function","modifiers":[],"name":"optimismMintableERC20Factory","nameLocation":"1062:28:100","parameters":{"id":53874,"nodeType":"ParameterList","parameters":[],"src":"1090:2:100"},"returnParameters":{"id":53877,"nodeType":"ParameterList","parameters":[{"constant":false,"id":53876,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":53878,"src":"1116:7:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":53875,"name":"address","nodeType":"ElementaryTypeName","src":"1116:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"1115:9:100"},"scope":53958,"stateMutability":"view","virtual":false,"visibility":"external"},{"id":53886,"nodeType":"FunctionDefinition","src":"1130:71:100","nodes":[],"functionSelector":"1b685b9e","implemented":false,"kind":"function","modifiers":[],"name":"gameImpls","nameLocation":"1139:9:100","parameters":{"id":53882,"nodeType":"ParameterList","parameters":[{"constant":false,"id":53881,"mutability":"mutable","name":"_gameType","nameLocation":"1158:9:100","nodeType":"VariableDeclaration","scope":53886,"src":"1149:18:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_userDefinedValueType$_GameType_$70720","typeString":"GameType"},"typeName":{"id":53880,"nodeType":"UserDefinedTypeName","pathNode":{"id":53879,"name":"GameType","nameLocations":["1149:8:100"],"nodeType":"IdentifierPath","referencedDeclaration":70720,"src":"1149:8:100"},"referencedDeclaration":70720,"src":"1149:8:100","typeDescriptions":{"typeIdentifier":"t_userDefinedValueType$_GameType_$70720","typeString":"GameType"}},"visibility":"internal"}],"src":"1148:20:100"},"returnParameters":{"id":53885,"nodeType":"ParameterList","parameters":[{"constant":false,"id":53884,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":53886,"src":"1192:7:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":53883,"name":"address","nodeType":"ElementaryTypeName","src":"1192:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"1191:9:100"},"scope":53958,"stateMutability":"view","virtual":false,"visibility":"external"},{"id":53892,"nodeType":"FunctionDefinition","src":"1206:62:100","nodes":[],"functionSelector":"3c9f397c","implemented":false,"kind":"function","modifiers":[],"name":"respectedGameType","nameLocation":"1215:17:100","parameters":{"id":53887,"nodeType":"ParameterList","parameters":[],"src":"1232:2:100"},"returnParameters":{"id":53891,"nodeType":"ParameterList","parameters":[{"constant":false,"id":53890,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":53892,"src":"1258:8:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_userDefinedValueType$_GameType_$70720","typeString":"GameType"},"typeName":{"id":53889,"nodeType":"UserDefinedTypeName","pathNode":{"id":53888,"name":"GameType","nameLocations":["1258:8:100"],"nodeType":"IdentifierPath","referencedDeclaration":70720,"src":"1258:8:100"},"referencedDeclaration":70720,"src":"1258:8:100","typeDescriptions":{"typeIdentifier":"t_userDefinedValueType$_GameType_$70720","typeString":"GameType"}},"visibility":"internal"}],"src":"1257:10:100"},"scope":53958,"stateMutability":"view","virtual":false,"visibility":"external"},{"id":53897,"nodeType":"FunctionDefinition","src":"1273:63:100","nodes":[],"functionSelector":"5c0cba33","implemented":false,"kind":"function","modifiers":[],"name":"anchorStateRegistry","nameLocation":"1282:19:100","parameters":{"id":53893,"nodeType":"ParameterList","parameters":[],"src":"1301:2:100"},"returnParameters":{"id":53896,"nodeType":"ParameterList","parameters":[{"constant":false,"id":53895,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":53897,"src":"1327:7:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":53894,"name":"address","nodeType":"ElementaryTypeName","src":"1327:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"1326:9:100"},"scope":53958,"stateMutability":"view","virtual":false,"visibility":"external"},{"id":53902,"nodeType":"FunctionDefinition","src":"1341:53:100","nodes":[],"functionSelector":"001c2ff6","implemented":false,"kind":"function","modifiers":[],"name":"L2_ORACLE","nameLocation":"1350:9:100","parameters":{"id":53898,"nodeType":"ParameterList","parameters":[],"src":"1359:2:100"},"returnParameters":{"id":53901,"nodeType":"ParameterList","parameters":[{"constant":false,"id":53900,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":53902,"src":"1385:7:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":53899,"name":"address","nodeType":"ElementaryTypeName","src":"1385:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"1384:9:100"},"scope":53958,"stateMutability":"view","virtual":false,"visibility":"external"},{"id":53907,"nodeType":"FunctionDefinition","src":"1399:52:100","nodes":[],"functionSelector":"9b5f694a","implemented":false,"kind":"function","modifiers":[],"name":"l2Oracle","nameLocation":"1408:8:100","parameters":{"id":53903,"nodeType":"ParameterList","parameters":[],"src":"1416:2:100"},"returnParameters":{"id":53906,"nodeType":"ParameterList","parameters":[{"constant":false,"id":53905,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":53907,"src":"1442:7:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":53904,"name":"address","nodeType":"ElementaryTypeName","src":"1442:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"1441:9:100"},"scope":53958,"stateMutability":"view","virtual":false,"visibility":"external"},{"id":53912,"nodeType":"FunctionDefinition","src":"1456:46:100","nodes":[],"functionSelector":"3a768463","implemented":false,"kind":"function","modifiers":[],"name":"vm","nameLocation":"1465:2:100","parameters":{"id":53908,"nodeType":"ParameterList","parameters":[],"src":"1467:2:100"},"returnParameters":{"id":53911,"nodeType":"ParameterList","parameters":[{"constant":false,"id":53910,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":53912,"src":"1493:7:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":53909,"name":"address","nodeType":"ElementaryTypeName","src":"1493:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"1492:9:100"},"scope":53958,"stateMutability":"view","virtual":false,"visibility":"external"},{"id":53917,"nodeType":"FunctionDefinition","src":"1507:50:100","nodes":[],"functionSelector":"7dc0d1d0","implemented":false,"kind":"function","modifiers":[],"name":"oracle","nameLocation":"1516:6:100","parameters":{"id":53913,"nodeType":"ParameterList","parameters":[],"src":"1522:2:100"},"returnParameters":{"id":53916,"nodeType":"ParameterList","parameters":[{"constant":false,"id":53915,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":53917,"src":"1548:7:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":53914,"name":"address","nodeType":"ElementaryTypeName","src":"1548:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"1547:9:100"},"scope":53958,"stateMutability":"view","virtual":false,"visibility":"external"},{"id":53922,"nodeType":"FunctionDefinition","src":"1562:54:100","nodes":[],"functionSelector":"534db0e2","implemented":false,"kind":"function","modifiers":[],"name":"challenger","nameLocation":"1571:10:100","parameters":{"id":53918,"nodeType":"ParameterList","parameters":[],"src":"1581:2:100"},"returnParameters":{"id":53921,"nodeType":"ParameterList","parameters":[{"constant":false,"id":53920,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":53922,"src":"1607:7:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":53919,"name":"address","nodeType":"ElementaryTypeName","src":"1607:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"1606:9:100"},"scope":53958,"stateMutability":"view","virtual":false,"visibility":"external"},{"id":53927,"nodeType":"FunctionDefinition","src":"1621:52:100","nodes":[],"functionSelector":"a8e4fb90","implemented":false,"kind":"function","modifiers":[],"name":"proposer","nameLocation":"1630:8:100","parameters":{"id":53923,"nodeType":"ParameterList","parameters":[],"src":"1638:2:100"},"returnParameters":{"id":53926,"nodeType":"ParameterList","parameters":[{"constant":false,"id":53925,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":53927,"src":"1664:7:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":53924,"name":"address","nodeType":"ElementaryTypeName","src":"1664:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"1663:9:100"},"scope":53958,"stateMutability":"view","virtual":false,"visibility":"external"},{"id":53932,"nodeType":"FunctionDefinition","src":"1678:52:100","nodes":[],"functionSelector":"bffa7f0f","implemented":false,"kind":"function","modifiers":[],"name":"PROPOSER","nameLocation":"1687:8:100","parameters":{"id":53928,"nodeType":"ParameterList","parameters":[],"src":"1695:2:100"},"returnParameters":{"id":53931,"nodeType":"ParameterList","parameters":[{"constant":false,"id":53930,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":53932,"src":"1721:7:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":53929,"name":"address","nodeType":"ElementaryTypeName","src":"1721:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"1720:9:100"},"scope":53958,"stateMutability":"view","virtual":false,"visibility":"external"},{"id":53937,"nodeType":"FunctionDefinition","src":"1735:55:100","nodes":[],"functionSelector":"e81b2c6d","implemented":false,"kind":"function","modifiers":[],"name":"batcherHash","nameLocation":"1744:11:100","parameters":{"id":53933,"nodeType":"ParameterList","parameters":[],"src":"1755:2:100"},"returnParameters":{"id":53936,"nodeType":"ParameterList","parameters":[{"constant":false,"id":53935,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":53937,"src":"1781:7:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_bytes32","typeString":"bytes32"},"typeName":{"id":53934,"name":"bytes32","nodeType":"ElementaryTypeName","src":"1781:7:100","typeDescriptions":{"typeIdentifier":"t_bytes32","typeString":"bytes32"}},"visibility":"internal"}],"src":"1780:9:100"},"scope":53958,"stateMutability":"view","virtual":false,"visibility":"external"},{"id":53942,"nodeType":"FunctionDefinition","src":"1795:49:100","nodes":[],"functionSelector":"f851a440","implemented":false,"kind":"function","modifiers":[],"name":"admin","nameLocation":"1804:5:100","parameters":{"id":53938,"nodeType":"ParameterList","parameters":[],"src":"1809:2:100"},"returnParameters":{"id":53941,"nodeType":"ParameterList","parameters":[{"constant":false,"id":53940,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":53942,"src":"1835:7:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":53939,"name":"address","nodeType":"ElementaryTypeName","src":"1835:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"1834:9:100"},"scope":53958,"stateMutability":"view","virtual":false,"visibility":"external"},{"id":53947,"nodeType":"FunctionDefinition","src":"1849:49:100","nodes":[],"functionSelector":"8da5cb5b","implemented":false,"kind":"function","modifiers":[],"name":"owner","nameLocation":"1858:5:100","parameters":{"id":53943,"nodeType":"ParameterList","parameters":[],"src":"1863:2:100"},"returnParameters":{"id":53946,"nodeType":"ParameterList","parameters":[{"constant":false,"id":53945,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":53947,"src":"1889:7:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":53944,"name":"address","nodeType":"ElementaryTypeName","src":"1889:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"1888:9:100"},"scope":53958,"stateMutability":"view","virtual":false,"visibility":"external"},{"id":53952,"nodeType":"FunctionDefinition","src":"1903:61:100","nodes":[],"functionSelector":"1fd19ee1","implemented":false,"kind":"function","modifiers":[],"name":"unsafeBlockSigner","nameLocation":"1912:17:100","parameters":{"id":53948,"nodeType":"ParameterList","parameters":[],"src":"1929:2:100"},"returnParameters":{"id":53951,"nodeType":"ParameterList","parameters":[{"constant":false,"id":53950,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":53952,"src":"1955:7:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":53949,"name":"address","nodeType":"ElementaryTypeName","src":"1955:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"1954:9:100"},"scope":53958,"stateMutability":"view","virtual":false,"visibility":"external"},{"id":53957,"nodeType":"FunctionDefinition","src":"1969:48:100","nodes":[],"functionSelector":"3fc8cef3","implemented":false,"kind":"function","modifiers":[],"name":"weth","nameLocation":"1978:4:100","parameters":{"id":53953,"nodeType":"ParameterList","parameters":[],"src":"1982:2:100"},"returnParameters":{"id":53956,"nodeType":"ParameterList","parameters":[{"constant":false,"id":53955,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":53957,"src":"2008:7:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":53954,"name":"address","nodeType":"ElementaryTypeName","src":"2008:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"2007:9:100"},"scope":53958,"stateMutability":"view","virtual":false,"visibility":"external"}],"abstract":false,"baseContracts":[],"canonicalName":"IFetcher","contractDependencies":[],"contractKind":"interface","documentation":{"id":53813,"nodeType":"StructuredDocumentation","src":"170:136:100","text":"@notice Contains getters for arbitrary methods from all L1 contracts, including legacy getters\n that have since been deprecated."},"fullyImplemented":false,"linearizedBaseContracts":[53958],"name":"IFetcher","nameLocation":"316:8:100","scope":56019,"usedErrors":[],"usedEvents":[]},{"id":54041,"nodeType":"ContractDefinition","src":"2021:934:100","nodes":[{"id":53960,"nodeType":"VariableDeclaration","src":"2056:35:100","nodes":[],"constant":false,"mutability":"mutable","name":"_systemConfigProxy","nameLocation":"2073:18:100","scope":54041,"stateVariable":true,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":53959,"name":"address","nodeType":"ElementaryTypeName","src":"2056:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"},{"id":53962,"nodeType":"VariableDeclaration","src":"2097:39:100","nodes":[],"constant":false,"mutability":"mutable","name":"_l1StandardBridgeProxy","nameLocation":"2114:22:100","scope":54041,"stateVariable":true,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":53961,"name":"address","nodeType":"ElementaryTypeName","src":"2097:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"},{"id":54004,"nodeType":"FunctionDefinition","src":"2143:378:100","nodes":[],"body":{"id":54003,"nodeType":"Block","src":"2191:330:100","nodes":[],"statements":[{"expression":{"arguments":[{"commonType":{"typeIdentifier":"t_address","typeString":"address"},"id":53975,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftExpression":{"id":53970,"name":"_addr","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":53966,"src":"2209:5:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"BinaryOperation","operator":"!=","rightExpression":{"arguments":[{"hexValue":"30","id":53973,"isConstant":false,"isLValue":false,"isPure":true,"kind":"number","lValueRequested":false,"nodeType":"Literal","src":"2226:1:100","typeDescriptions":{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"},"value":"0"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"}],"id":53972,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"nodeType":"ElementaryTypeNameExpression","src":"2218:7:100","typeDescriptions":{"typeIdentifier":"t_type$_t_address_$","typeString":"type(address)"},"typeName":{"id":53971,"name":"address","nodeType":"ElementaryTypeName","src":"2218:7:100","typeDescriptions":{}}},"id":53974,"isConstant":false,"isLValue":false,"isPure":true,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"2218:10:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"src":"2209:19:100","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},{"hexValue":"4665746368436861696e496e666f496e7075743a2063616e6e6f7420736574207a65726f2061646472657373","id":53976,"isConstant":false,"isLValue":false,"isPure":true,"kind":"string","lValueRequested":false,"nodeType":"Literal","src":"2230:46:100","typeDescriptions":{"typeIdentifier":"t_stringliteral_0336126ace187312d69da4c7cf05307af6a6596e8c75de2974f56108baf24145","typeString":"literal_string \"FetchChainInfoInput: cannot set zero address\""},"value":"FetchChainInfoInput: cannot set zero address"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_bool","typeString":"bool"},{"typeIdentifier":"t_stringliteral_0336126ace187312d69da4c7cf05307af6a6596e8c75de2974f56108baf24145","typeString":"literal_string \"FetchChainInfoInput: cannot set zero address\""}],"id":53969,"name":"require","nodeType":"Identifier","overloadedDeclarations":[-18,-18,-18],"referencedDeclaration":-18,"src":"2201:7:100","typeDescriptions":{"typeIdentifier":"t_function_require_pure$_t_bool_$_t_string_memory_ptr_$returns$__$","typeString":"function (bool,string memory) pure"}},"id":53977,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"2201:76:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":53978,"nodeType":"ExpressionStatement","src":"2201:76:100"},{"condition":{"commonType":{"typeIdentifier":"t_bytes4","typeString":"bytes4"},"id":53983,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftExpression":{"id":53979,"name":"_sel","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":53964,"src":"2291:4:100","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},"nodeType":"BinaryOperation","operator":"==","rightExpression":{"expression":{"expression":{"id":53980,"name":"this","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":-28,"src":"2299:4:100","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoInput_$54041","typeString":"contract FetchChainInfoInput"}},"id":53981,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"2304:17:100","memberName":"systemConfigProxy","nodeType":"MemberAccess","referencedDeclaration":54022,"src":"2299:22:100","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":53982,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"memberLocation":"2322:8:100","memberName":"selector","nodeType":"MemberAccess","src":"2299:31:100","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},"src":"2291:39:100","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},"falseBody":{"condition":{"commonType":{"typeIdentifier":"t_bytes4","typeString":"bytes4"},"id":53992,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftExpression":{"id":53988,"name":"_sel","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":53964,"src":"2377:4:100","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},"nodeType":"BinaryOperation","operator":"==","rightExpression":{"expression":{"expression":{"id":53989,"name":"this","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":-28,"src":"2385:4:100","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoInput_$54041","typeString":"contract FetchChainInfoInput"}},"id":53990,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"2390:21:100","memberName":"l1StandardBridgeProxy","nodeType":"MemberAccess","referencedDeclaration":54040,"src":"2385:26:100","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":53991,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"memberLocation":"2412:8:100","memberName":"selector","nodeType":"MemberAccess","src":"2385:35:100","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},"src":"2377:43:100","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},"falseBody":{"expression":{"arguments":[{"hexValue":"4665746368436861696e496e666f496e7075743a20756e6b6e6f776e2073656c6563746f72","id":53998,"isConstant":false,"isLValue":false,"isPure":true,"kind":"string","lValueRequested":false,"nodeType":"Literal","src":"2474:39:100","typeDescriptions":{"typeIdentifier":"t_stringliteral_3ec062448196d68b2d186fadb5ffe52c72f0a2b929c9d178cd6e6612281f066b","typeString":"literal_string \"FetchChainInfoInput: unknown selector\""},"value":"FetchChainInfoInput: unknown selector"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_stringliteral_3ec062448196d68b2d186fadb5ffe52c72f0a2b929c9d178cd6e6612281f066b","typeString":"literal_string \"FetchChainInfoInput: unknown selector\""}],"id":53997,"name":"revert","nodeType":"Identifier","overloadedDeclarations":[-19,-19],"referencedDeclaration":-19,"src":"2467:6:100","typeDescriptions":{"typeIdentifier":"t_function_revert_pure$_t_string_memory_ptr_$returns$__$","typeString":"function (string memory) pure"}},"id":53999,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"2467:47:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":54000,"nodeType":"ExpressionStatement","src":"2467:47:100"},"id":54001,"nodeType":"IfStatement","src":"2373:141:100","trueBody":{"expression":{"id":53995,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftHandSide":{"id":53993,"name":"_l1StandardBridgeProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":53962,"src":"2422:22:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"Assignment","operator":"=","rightHandSide":{"id":53994,"name":"_addr","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":53966,"src":"2447:5:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"src":"2422:30:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"id":53996,"nodeType":"ExpressionStatement","src":"2422:30:100"}},"id":54002,"nodeType":"IfStatement","src":"2287:227:100","trueBody":{"expression":{"id":53986,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftHandSide":{"id":53984,"name":"_systemConfigProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":53960,"src":"2332:18:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"Assignment","operator":"=","rightHandSide":{"id":53985,"name":"_addr","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":53966,"src":"2353:5:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"src":"2332:26:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"id":53987,"nodeType":"ExpressionStatement","src":"2332:26:100"}}]},"functionSelector":"c3e39250","implemented":true,"kind":"function","modifiers":[],"name":"set","nameLocation":"2152:3:100","parameters":{"id":53967,"nodeType":"ParameterList","parameters":[{"constant":false,"id":53964,"mutability":"mutable","name":"_sel","nameLocation":"2163:4:100","nodeType":"VariableDeclaration","scope":54004,"src":"2156:11:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"},"typeName":{"id":53963,"name":"bytes4","nodeType":"ElementaryTypeName","src":"2156:6:100","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},"visibility":"internal"},{"constant":false,"id":53966,"mutability":"mutable","name":"_addr","nameLocation":"2177:5:100","nodeType":"VariableDeclaration","scope":54004,"src":"2169:13:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":53965,"name":"address","nodeType":"ElementaryTypeName","src":"2169:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"2155:28:100"},"returnParameters":{"id":53968,"nodeType":"ParameterList","parameters":[],"src":"2191:0:100"},"scope":54041,"stateMutability":"nonpayable","virtual":false,"visibility":"public"},{"id":54022,"nodeType":"FunctionDefinition","src":"2527:202:100","nodes":[],"body":{"id":54021,"nodeType":"Block","src":"2586:143:100","nodes":[],"statements":[{"expression":{"arguments":[{"commonType":{"typeIdentifier":"t_address","typeString":"address"},"id":54015,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftExpression":{"id":54010,"name":"_systemConfigProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":53960,"src":"2604:18:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"BinaryOperation","operator":"!=","rightExpression":{"arguments":[{"hexValue":"30","id":54013,"isConstant":false,"isLValue":false,"isPure":true,"kind":"number","lValueRequested":false,"nodeType":"Literal","src":"2634:1:100","typeDescriptions":{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"},"value":"0"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"}],"id":54012,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"nodeType":"ElementaryTypeNameExpression","src":"2626:7:100","typeDescriptions":{"typeIdentifier":"t_type$_t_address_$","typeString":"type(address)"},"typeName":{"id":54011,"name":"address","nodeType":"ElementaryTypeName","src":"2626:7:100","typeDescriptions":{}}},"id":54014,"isConstant":false,"isLValue":false,"isPure":true,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"2626:10:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"src":"2604:32:100","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},{"hexValue":"4665746368436861696e496e666f496e7075743a2073797374656d436f6e66696750726f7879206e6f7420736574","id":54016,"isConstant":false,"isLValue":false,"isPure":true,"kind":"string","lValueRequested":false,"nodeType":"Literal","src":"2638:48:100","typeDescriptions":{"typeIdentifier":"t_stringliteral_cefeeda9841ab81b734a3e4f7bf39aeeab7704e02e2040531bd67ea944e4d5d3","typeString":"literal_string \"FetchChainInfoInput: systemConfigProxy not set\""},"value":"FetchChainInfoInput: systemConfigProxy not set"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_bool","typeString":"bool"},{"typeIdentifier":"t_stringliteral_cefeeda9841ab81b734a3e4f7bf39aeeab7704e02e2040531bd67ea944e4d5d3","typeString":"literal_string \"FetchChainInfoInput: systemConfigProxy not set\""}],"id":54009,"name":"require","nodeType":"Identifier","overloadedDeclarations":[-18,-18,-18],"referencedDeclaration":-18,"src":"2596:7:100","typeDescriptions":{"typeIdentifier":"t_function_require_pure$_t_bool_$_t_string_memory_ptr_$returns$__$","typeString":"function (bool,string memory) pure"}},"id":54017,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"2596:91:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":54018,"nodeType":"ExpressionStatement","src":"2596:91:100"},{"expression":{"id":54019,"name":"_systemConfigProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":53960,"src":"2704:18:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"functionReturnParameters":54008,"id":54020,"nodeType":"Return","src":"2697:25:100"}]},"functionSelector":"c17db6e3","implemented":true,"kind":"function","modifiers":[],"name":"systemConfigProxy","nameLocation":"2536:17:100","parameters":{"id":54005,"nodeType":"ParameterList","parameters":[],"src":"2553:2:100"},"returnParameters":{"id":54008,"nodeType":"ParameterList","parameters":[{"constant":false,"id":54007,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":54022,"src":"2577:7:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":54006,"name":"address","nodeType":"ElementaryTypeName","src":"2577:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"2576:9:100"},"scope":54041,"stateMutability":"view","virtual":false,"visibility":"public"},{"id":54040,"nodeType":"FunctionDefinition","src":"2735:218:100","nodes":[],"body":{"id":54039,"nodeType":"Block","src":"2798:155:100","nodes":[],"statements":[{"expression":{"arguments":[{"commonType":{"typeIdentifier":"t_address","typeString":"address"},"id":54033,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftExpression":{"id":54028,"name":"_l1StandardBridgeProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":53962,"src":"2816:22:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"BinaryOperation","operator":"!=","rightExpression":{"arguments":[{"hexValue":"30","id":54031,"isConstant":false,"isLValue":false,"isPure":true,"kind":"number","lValueRequested":false,"nodeType":"Literal","src":"2850:1:100","typeDescriptions":{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"},"value":"0"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"}],"id":54030,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"nodeType":"ElementaryTypeNameExpression","src":"2842:7:100","typeDescriptions":{"typeIdentifier":"t_type$_t_address_$","typeString":"type(address)"},"typeName":{"id":54029,"name":"address","nodeType":"ElementaryTypeName","src":"2842:7:100","typeDescriptions":{}}},"id":54032,"isConstant":false,"isLValue":false,"isPure":true,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"2842:10:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"src":"2816:36:100","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},{"hexValue":"4665746368436861696e496e666f496e7075743a206c315374616e6461726442726964676550726f7879206e6f7420736574","id":54034,"isConstant":false,"isLValue":false,"isPure":true,"kind":"string","lValueRequested":false,"nodeType":"Literal","src":"2854:52:100","typeDescriptions":{"typeIdentifier":"t_stringliteral_be85b0ed3fc58e97f8b79e4d9fb1c191539515cae509acde6becd9338254d33b","typeString":"literal_string \"FetchChainInfoInput: l1StandardBridgeProxy not set\""},"value":"FetchChainInfoInput: l1StandardBridgeProxy not set"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_bool","typeString":"bool"},{"typeIdentifier":"t_stringliteral_be85b0ed3fc58e97f8b79e4d9fb1c191539515cae509acde6becd9338254d33b","typeString":"literal_string \"FetchChainInfoInput: l1StandardBridgeProxy not set\""}],"id":54027,"name":"require","nodeType":"Identifier","overloadedDeclarations":[-18,-18,-18],"referencedDeclaration":-18,"src":"2808:7:100","typeDescriptions":{"typeIdentifier":"t_function_require_pure$_t_bool_$_t_string_memory_ptr_$returns$__$","typeString":"function (bool,string memory) pure"}},"id":54035,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"2808:99:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":54036,"nodeType":"ExpressionStatement","src":"2808:99:100"},{"expression":{"id":54037,"name":"_l1StandardBridgeProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":53962,"src":"2924:22:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"functionReturnParameters":54026,"id":54038,"nodeType":"Return","src":"2917:29:100"}]},"functionSelector":"102b6069","implemented":true,"kind":"function","modifiers":[],"name":"l1StandardBridgeProxy","nameLocation":"2744:21:100","parameters":{"id":54023,"nodeType":"ParameterList","parameters":[],"src":"2765:2:100"},"returnParameters":{"id":54026,"nodeType":"ParameterList","parameters":[{"constant":false,"id":54025,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":54040,"src":"2789:7:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":54024,"name":"address","nodeType":"ElementaryTypeName","src":"2789:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"2788:9:100"},"scope":54041,"stateMutability":"view","virtual":false,"visibility":"public"}],"abstract":false,"baseContracts":[],"canonicalName":"FetchChainInfoInput","contractDependencies":[],"contractKind":"contract","fullyImplemented":true,"linearizedBaseContracts":[54041],"name":"FetchChainInfoInput","nameLocation":"2030:19:100","scope":56019,"usedErrors":[],"usedEvents":[]},{"id":54911,"nodeType":"ContractDefinition","src":"2957:10642:100","nodes":[{"id":54043,"nodeType":"VariableDeclaration","src":"3049:39:100","nodes":[],"constant":false,"mutability":"mutable","name":"_superchainConfigProxy","nameLocation":"3066:22:100","scope":54911,"stateVariable":true,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":54042,"name":"address","nodeType":"ElementaryTypeName","src":"3049:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"},{"id":54045,"nodeType":"VariableDeclaration","src":"3129:26:100","nodes":[],"constant":false,"mutability":"mutable","name":"_mipsImpl","nameLocation":"3146:9:100","scope":54911,"stateVariable":true,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":54044,"name":"address","nodeType":"ElementaryTypeName","src":"3129:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"},{"id":54047,"nodeType":"VariableDeclaration","src":"3161:36:100","nodes":[],"constant":false,"mutability":"mutable","name":"_preimageOracleImpl","nameLocation":"3178:19:100","scope":54911,"stateVariable":true,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":54046,"name":"address","nodeType":"ElementaryTypeName","src":"3161:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"},{"id":54049,"nodeType":"VariableDeclaration","src":"3230:36:100","nodes":[],"constant":false,"mutability":"mutable","name":"_addressManagerImpl","nameLocation":"3247:19:100","scope":54911,"stateVariable":true,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":54048,"name":"address","nodeType":"ElementaryTypeName","src":"3230:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"},{"id":54051,"nodeType":"VariableDeclaration","src":"3272:33:100","nodes":[],"constant":false,"mutability":"mutable","name":"_ethLockboxProxy","nameLocation":"3289:16:100","scope":54911,"stateVariable":true,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":54050,"name":"address","nodeType":"ElementaryTypeName","src":"3272:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"},{"id":54053,"nodeType":"VariableDeclaration","src":"3311:45:100","nodes":[],"constant":false,"mutability":"mutable","name":"_l1CrossDomainMessengerProxy","nameLocation":"3328:28:100","scope":54911,"stateVariable":true,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":54052,"name":"address","nodeType":"ElementaryTypeName","src":"3311:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"},{"id":54055,"nodeType":"VariableDeclaration","src":"3362:37:100","nodes":[],"constant":false,"mutability":"mutable","name":"_l1Erc721BridgeProxy","nameLocation":"3379:20:100","scope":54911,"stateVariable":true,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":54054,"name":"address","nodeType":"ElementaryTypeName","src":"3362:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"},{"id":54057,"nodeType":"VariableDeclaration","src":"3405:39:100","nodes":[],"constant":false,"mutability":"mutable","name":"_l1StandardBridgeProxy","nameLocation":"3422:22:100","scope":54911,"stateVariable":true,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":54056,"name":"address","nodeType":"ElementaryTypeName","src":"3405:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"},{"id":54059,"nodeType":"VariableDeclaration","src":"3450:37:100","nodes":[],"constant":false,"mutability":"mutable","name":"_l2OutputOracleProxy","nameLocation":"3467:20:100","scope":54911,"stateVariable":true,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":54058,"name":"address","nodeType":"ElementaryTypeName","src":"3450:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"},{"id":54061,"nodeType":"VariableDeclaration","src":"3493:51:100","nodes":[],"constant":false,"mutability":"mutable","name":"_optimismMintableErc20FactoryProxy","nameLocation":"3510:34:100","scope":54911,"stateVariable":true,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":54060,"name":"address","nodeType":"ElementaryTypeName","src":"3493:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"},{"id":54063,"nodeType":"VariableDeclaration","src":"3550:37:100","nodes":[],"constant":false,"mutability":"mutable","name":"_optimismPortalProxy","nameLocation":"3567:20:100","scope":54911,"stateVariable":true,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":54062,"name":"address","nodeType":"ElementaryTypeName","src":"3550:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"},{"id":54065,"nodeType":"VariableDeclaration","src":"3593:35:100","nodes":[],"constant":false,"mutability":"mutable","name":"_systemConfigProxy","nameLocation":"3610:18:100","scope":54911,"stateVariable":true,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":54064,"name":"address","nodeType":"ElementaryTypeName","src":"3593:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"},{"id":54067,"nodeType":"VariableDeclaration","src":"3634:39:100","nodes":[],"constant":false,"mutability":"mutable","name":"_opChainProxyAdminImpl","nameLocation":"3651:22:100","scope":54911,"stateVariable":true,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":54066,"name":"address","nodeType":"ElementaryTypeName","src":"3634:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"},{"id":54069,"nodeType":"VariableDeclaration","src":"3679:42:100","nodes":[],"constant":false,"mutability":"mutable","name":"_anchorStateRegistryProxy","nameLocation":"3696:25:100","scope":54911,"stateVariable":true,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":54068,"name":"address","nodeType":"ElementaryTypeName","src":"3679:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"},{"id":54071,"nodeType":"VariableDeclaration","src":"3727:50:100","nodes":[],"constant":false,"mutability":"mutable","name":"_delayedWethPermissionedGameProxy","nameLocation":"3744:33:100","scope":54911,"stateVariable":true,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":54070,"name":"address","nodeType":"ElementaryTypeName","src":"3727:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"},{"id":54073,"nodeType":"VariableDeclaration","src":"3783:52:100","nodes":[],"constant":false,"mutability":"mutable","name":"_delayedWethPermissionlessGameProxy","nameLocation":"3800:35:100","scope":54911,"stateVariable":true,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":54072,"name":"address","nodeType":"ElementaryTypeName","src":"3783:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"},{"id":54075,"nodeType":"VariableDeclaration","src":"3841:41:100","nodes":[],"constant":false,"mutability":"mutable","name":"_disputeGameFactoryProxy","nameLocation":"3858:24:100","scope":54911,"stateVariable":true,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":54074,"name":"address","nodeType":"ElementaryTypeName","src":"3841:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"},{"id":54077,"nodeType":"VariableDeclaration","src":"3888:38:100","nodes":[],"constant":false,"mutability":"mutable","name":"_faultDisputeGameImpl","nameLocation":"3905:21:100","scope":54911,"stateVariable":true,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":54076,"name":"address","nodeType":"ElementaryTypeName","src":"3888:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"},{"id":54079,"nodeType":"VariableDeclaration","src":"3932:48:100","nodes":[],"constant":false,"mutability":"mutable","name":"_faultDisputeGameCannonKonaImpl","nameLocation":"3949:31:100","scope":54911,"stateVariable":true,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":54078,"name":"address","nodeType":"ElementaryTypeName","src":"3932:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"},{"id":54081,"nodeType":"VariableDeclaration","src":"3986:45:100","nodes":[],"constant":false,"mutability":"mutable","name":"_permissionedDisputeGameImpl","nameLocation":"4003:28:100","scope":54911,"stateVariable":true,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":54080,"name":"address","nodeType":"ElementaryTypeName","src":"3986:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"},{"id":54083,"nodeType":"VariableDeclaration","src":"4051:35:100","nodes":[],"constant":false,"mutability":"mutable","name":"_systemConfigOwner","nameLocation":"4068:18:100","scope":54911,"stateVariable":true,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":54082,"name":"address","nodeType":"ElementaryTypeName","src":"4051:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"},{"id":54085,"nodeType":"VariableDeclaration","src":"4092:40:100","nodes":[],"constant":false,"mutability":"mutable","name":"_opChainProxyAdminOwner","nameLocation":"4109:23:100","scope":54911,"stateVariable":true,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":54084,"name":"address","nodeType":"ElementaryTypeName","src":"4092:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"},{"id":54087,"nodeType":"VariableDeclaration","src":"4138:33:100","nodes":[],"constant":false,"mutability":"mutable","name":"_opChainGuardian","nameLocation":"4155:16:100","scope":54911,"stateVariable":true,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":54086,"name":"address","nodeType":"ElementaryTypeName","src":"4138:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"},{"id":54089,"nodeType":"VariableDeclaration","src":"4177:28:100","nodes":[],"constant":false,"mutability":"mutable","name":"_challenger","nameLocation":"4194:11:100","scope":54911,"stateVariable":true,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":54088,"name":"address","nodeType":"ElementaryTypeName","src":"4177:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"},{"id":54091,"nodeType":"VariableDeclaration","src":"4211:26:100","nodes":[],"constant":false,"mutability":"mutable","name":"_proposer","nameLocation":"4228:9:100","scope":54911,"stateVariable":true,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":54090,"name":"address","nodeType":"ElementaryTypeName","src":"4211:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"},{"id":54093,"nodeType":"VariableDeclaration","src":"4243:35:100","nodes":[],"constant":false,"mutability":"mutable","name":"_unsafeBlockSigner","nameLocation":"4260:18:100","scope":54911,"stateVariable":true,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":54092,"name":"address","nodeType":"ElementaryTypeName","src":"4243:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"},{"id":54095,"nodeType":"VariableDeclaration","src":"4284:32:100","nodes":[],"constant":false,"mutability":"mutable","name":"_batchSubmitter","nameLocation":"4301:15:100","scope":54911,"stateVariable":true,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":54094,"name":"address","nodeType":"ElementaryTypeName","src":"4284:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"},{"id":54097,"nodeType":"VariableDeclaration","src":"4349:27:100","nodes":[],"constant":false,"mutability":"mutable","name":"_permissioned","nameLocation":"4363:13:100","scope":54911,"stateVariable":true,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"},"typeName":{"id":54096,"name":"bool","nodeType":"ElementaryTypeName","src":"4349:4:100","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},"visibility":"internal"},{"id":54099,"nodeType":"VariableDeclaration","src":"4382:29:100","nodes":[],"constant":false,"mutability":"mutable","name":"_permissionless","nameLocation":"4396:15:100","scope":54911,"stateVariable":true,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"},"typeName":{"id":54098,"name":"bool","nodeType":"ElementaryTypeName","src":"4382:4:100","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},"visibility":"internal"},{"id":54102,"nodeType":"VariableDeclaration","src":"4417:36:100","nodes":[],"constant":false,"mutability":"mutable","name":"_respectedGameType","nameLocation":"4435:18:100","scope":54911,"stateVariable":true,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_userDefinedValueType$_GameType_$70720","typeString":"GameType"},"typeName":{"id":54101,"nodeType":"UserDefinedTypeName","pathNode":{"id":54100,"name":"GameType","nameLocations":["4417:8:100"],"nodeType":"IdentifierPath","referencedDeclaration":70720,"src":"4417:8:100"},"referencedDeclaration":70720,"src":"4417:8:100","typeDescriptions":{"typeIdentifier":"t_userDefinedValueType$_GameType_$70720","typeString":"GameType"}},"visibility":"internal"},{"id":54384,"nodeType":"FunctionDefinition","src":"4460:2746:100","nodes":[],"body":{"id":54383,"nodeType":"Block","src":"4508:2698:100","nodes":[],"statements":[{"condition":{"commonType":{"typeIdentifier":"t_bytes4","typeString":"bytes4"},"id":54113,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftExpression":{"id":54109,"name":"_sel","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54104,"src":"4553:4:100","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},"nodeType":"BinaryOperation","operator":"==","rightExpression":{"expression":{"expression":{"id":54110,"name":"this","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":-28,"src":"4561:4:100","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$54911","typeString":"contract FetchChainInfoOutput"}},"id":54111,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"4566:21:100","memberName":"superchainConfigProxy","nodeType":"MemberAccess","referencedDeclaration":54627,"src":"4561:26:100","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":54112,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"memberLocation":"4588:8:100","memberName":"selector","nodeType":"MemberAccess","src":"4561:35:100","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},"src":"4553:43:100","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},"falseBody":{"condition":{"commonType":{"typeIdentifier":"t_bytes4","typeString":"bytes4"},"id":54122,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftExpression":{"id":54118,"name":"_sel","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54104,"src":"4686:4:100","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},"nodeType":"BinaryOperation","operator":"==","rightExpression":{"expression":{"expression":{"id":54119,"name":"this","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":-28,"src":"4694:4:100","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$54911","typeString":"contract FetchChainInfoOutput"}},"id":54120,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"4699:8:100","memberName":"mipsImpl","nodeType":"MemberAccess","referencedDeclaration":54723,"src":"4694:13:100","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":54121,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"memberLocation":"4708:8:100","memberName":"selector","nodeType":"MemberAccess","src":"4694:22:100","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},"src":"4686:30:100","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},"falseBody":{"condition":{"commonType":{"typeIdentifier":"t_bytes4","typeString":"bytes4"},"id":54131,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftExpression":{"id":54127,"name":"_sel","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54104,"src":"4754:4:100","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},"nodeType":"BinaryOperation","operator":"==","rightExpression":{"expression":{"expression":{"id":54128,"name":"this","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":-28,"src":"4762:4:100","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$54911","typeString":"contract FetchChainInfoOutput"}},"id":54129,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"4767:18:100","memberName":"preimageOracleImpl","nodeType":"MemberAccess","referencedDeclaration":54759,"src":"4762:23:100","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":54130,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"memberLocation":"4786:8:100","memberName":"selector","nodeType":"MemberAccess","src":"4762:32:100","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},"src":"4754:40:100","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},"falseBody":{"condition":{"commonType":{"typeIdentifier":"t_bytes4","typeString":"bytes4"},"id":54140,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftExpression":{"id":54136,"name":"_sel","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54104,"src":"4873:4:100","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},"nodeType":"BinaryOperation","operator":"==","rightExpression":{"expression":{"expression":{"id":54137,"name":"this","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":-28,"src":"4881:4:100","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$54911","typeString":"contract FetchChainInfoOutput"}},"id":54138,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"4886:18:100","memberName":"addressManagerImpl","nodeType":"MemberAccess","referencedDeclaration":54457,"src":"4881:23:100","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":54139,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"memberLocation":"4905:8:100","memberName":"selector","nodeType":"MemberAccess","src":"4881:32:100","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},"src":"4873:40:100","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},"falseBody":{"condition":{"commonType":{"typeIdentifier":"t_bytes4","typeString":"bytes4"},"id":54149,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftExpression":{"id":54145,"name":"_sel","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54104,"src":"4961:4:100","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},"nodeType":"BinaryOperation","operator":"==","rightExpression":{"expression":{"expression":{"id":54146,"name":"this","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":-28,"src":"4969:4:100","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$54911","typeString":"contract FetchChainInfoOutput"}},"id":54147,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"4974:15:100","memberName":"ethLockboxProxy","nodeType":"MemberAccess","referencedDeclaration":54465,"src":"4969:20:100","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":54148,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"memberLocation":"4990:8:100","memberName":"selector","nodeType":"MemberAccess","src":"4969:29:100","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},"src":"4961:37:100","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},"falseBody":{"condition":{"commonType":{"typeIdentifier":"t_bytes4","typeString":"bytes4"},"id":54158,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftExpression":{"id":54154,"name":"_sel","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54104,"src":"5043:4:100","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},"nodeType":"BinaryOperation","operator":"==","rightExpression":{"expression":{"expression":{"id":54155,"name":"this","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":-28,"src":"5051:4:100","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$54911","typeString":"contract FetchChainInfoOutput"}},"id":54156,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"5056:27:100","memberName":"l1CrossDomainMessengerProxy","nodeType":"MemberAccess","referencedDeclaration":54483,"src":"5051:32:100","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":54157,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"memberLocation":"5084:8:100","memberName":"selector","nodeType":"MemberAccess","src":"5051:41:100","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},"src":"5043:49:100","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},"falseBody":{"condition":{"commonType":{"typeIdentifier":"t_bytes4","typeString":"bytes4"},"id":54167,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftExpression":{"id":54163,"name":"_sel","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54104,"src":"5149:4:100","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},"nodeType":"BinaryOperation","operator":"==","rightExpression":{"expression":{"expression":{"id":54164,"name":"this","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":-28,"src":"5157:4:100","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$54911","typeString":"contract FetchChainInfoOutput"}},"id":54165,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"5162:19:100","memberName":"l1Erc721BridgeProxy","nodeType":"MemberAccess","referencedDeclaration":54501,"src":"5157:24:100","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":54166,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"memberLocation":"5182:8:100","memberName":"selector","nodeType":"MemberAccess","src":"5157:33:100","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},"src":"5149:41:100","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},"falseBody":{"condition":{"commonType":{"typeIdentifier":"t_bytes4","typeString":"bytes4"},"id":54176,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftExpression":{"id":54172,"name":"_sel","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54104,"src":"5239:4:100","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},"nodeType":"BinaryOperation","operator":"==","rightExpression":{"expression":{"expression":{"id":54173,"name":"this","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":-28,"src":"5247:4:100","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$54911","typeString":"contract FetchChainInfoOutput"}},"id":54174,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"5252:21:100","memberName":"l1StandardBridgeProxy","nodeType":"MemberAccess","referencedDeclaration":54519,"src":"5247:26:100","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":54175,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"memberLocation":"5274:8:100","memberName":"selector","nodeType":"MemberAccess","src":"5247:35:100","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},"src":"5239:43:100","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},"falseBody":{"condition":{"commonType":{"typeIdentifier":"t_bytes4","typeString":"bytes4"},"id":54185,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftExpression":{"id":54181,"name":"_sel","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54104,"src":"5333:4:100","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},"nodeType":"BinaryOperation","operator":"==","rightExpression":{"expression":{"expression":{"id":54182,"name":"this","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":-28,"src":"5341:4:100","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$54911","typeString":"contract FetchChainInfoOutput"}},"id":54183,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"5346:19:100","memberName":"l2OutputOracleProxy","nodeType":"MemberAccess","referencedDeclaration":54537,"src":"5341:24:100","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":54184,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"memberLocation":"5366:8:100","memberName":"selector","nodeType":"MemberAccess","src":"5341:33:100","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},"src":"5333:41:100","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},"falseBody":{"condition":{"commonType":{"typeIdentifier":"t_bytes4","typeString":"bytes4"},"id":54194,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftExpression":{"id":54190,"name":"_sel","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54104,"src":"5423:4:100","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},"nodeType":"BinaryOperation","operator":"==","rightExpression":{"expression":{"expression":{"id":54191,"name":"this","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":-28,"src":"5431:4:100","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$54911","typeString":"contract FetchChainInfoOutput"}},"id":54192,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"5436:33:100","memberName":"optimismMintableErc20FactoryProxy","nodeType":"MemberAccess","referencedDeclaration":54555,"src":"5431:38:100","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":54193,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"memberLocation":"5470:8:100","memberName":"selector","nodeType":"MemberAccess","src":"5431:47:100","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},"src":"5423:55:100","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},"falseBody":{"condition":{"commonType":{"typeIdentifier":"t_bytes4","typeString":"bytes4"},"id":54203,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftExpression":{"id":54199,"name":"_sel","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54104,"src":"5541:4:100","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},"nodeType":"BinaryOperation","operator":"==","rightExpression":{"expression":{"expression":{"id":54200,"name":"this","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":-28,"src":"5549:4:100","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$54911","typeString":"contract FetchChainInfoOutput"}},"id":54201,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"5554:19:100","memberName":"optimismPortalProxy","nodeType":"MemberAccess","referencedDeclaration":54573,"src":"5549:24:100","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":54202,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"memberLocation":"5574:8:100","memberName":"selector","nodeType":"MemberAccess","src":"5549:33:100","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},"src":"5541:41:100","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},"falseBody":{"condition":{"commonType":{"typeIdentifier":"t_bytes4","typeString":"bytes4"},"id":54212,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftExpression":{"id":54208,"name":"_sel","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54104,"src":"5631:4:100","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},"nodeType":"BinaryOperation","operator":"==","rightExpression":{"expression":{"expression":{"id":54209,"name":"this","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":-28,"src":"5639:4:100","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$54911","typeString":"contract FetchChainInfoOutput"}},"id":54210,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"5644:17:100","memberName":"systemConfigProxy","nodeType":"MemberAccess","referencedDeclaration":54591,"src":"5639:22:100","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":54211,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"memberLocation":"5662:8:100","memberName":"selector","nodeType":"MemberAccess","src":"5639:31:100","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},"src":"5631:39:100","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},"falseBody":{"condition":{"commonType":{"typeIdentifier":"t_bytes4","typeString":"bytes4"},"id":54221,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftExpression":{"id":54217,"name":"_sel","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54104,"src":"5717:4:100","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},"nodeType":"BinaryOperation","operator":"==","rightExpression":{"expression":{"expression":{"id":54218,"name":"this","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":-28,"src":"5725:4:100","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$54911","typeString":"contract FetchChainInfoOutput"}},"id":54219,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"5730:21:100","memberName":"opChainProxyAdminImpl","nodeType":"MemberAccess","referencedDeclaration":54609,"src":"5725:26:100","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":54220,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"memberLocation":"5752:8:100","memberName":"selector","nodeType":"MemberAccess","src":"5725:35:100","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},"src":"5717:43:100","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},"falseBody":{"condition":{"commonType":{"typeIdentifier":"t_bytes4","typeString":"bytes4"},"id":54230,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftExpression":{"id":54226,"name":"_sel","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54104,"src":"5811:4:100","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},"nodeType":"BinaryOperation","operator":"==","rightExpression":{"expression":{"expression":{"id":54227,"name":"this","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":-28,"src":"5819:4:100","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$54911","typeString":"contract FetchChainInfoOutput"}},"id":54228,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"5824:24:100","memberName":"anchorStateRegistryProxy","nodeType":"MemberAccess","referencedDeclaration":54645,"src":"5819:29:100","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":54229,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"memberLocation":"5849:8:100","memberName":"selector","nodeType":"MemberAccess","src":"5819:38:100","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},"src":"5811:46:100","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},"falseBody":{"condition":{"commonType":{"typeIdentifier":"t_bytes4","typeString":"bytes4"},"id":54239,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftExpression":{"id":54235,"name":"_sel","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54104,"src":"5911:4:100","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},"nodeType":"BinaryOperation","operator":"==","rightExpression":{"expression":{"expression":{"id":54236,"name":"this","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":-28,"src":"5919:4:100","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$54911","typeString":"contract FetchChainInfoOutput"}},"id":54237,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"5924:32:100","memberName":"delayedWethPermissionedGameProxy","nodeType":"MemberAccess","referencedDeclaration":54653,"src":"5919:37:100","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":54238,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"memberLocation":"5957:8:100","memberName":"selector","nodeType":"MemberAccess","src":"5919:46:100","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},"src":"5911:54:100","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},"falseBody":{"condition":{"commonType":{"typeIdentifier":"t_bytes4","typeString":"bytes4"},"id":54248,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftExpression":{"id":54244,"name":"_sel","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54104,"src":"6027:4:100","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},"nodeType":"BinaryOperation","operator":"==","rightExpression":{"expression":{"expression":{"id":54245,"name":"this","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":-28,"src":"6035:4:100","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$54911","typeString":"contract FetchChainInfoOutput"}},"id":54246,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"6040:34:100","memberName":"delayedWethPermissionlessGameProxy","nodeType":"MemberAccess","referencedDeclaration":54661,"src":"6035:39:100","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":54247,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"memberLocation":"6075:8:100","memberName":"selector","nodeType":"MemberAccess","src":"6035:48:100","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},"src":"6027:56:100","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},"falseBody":{"condition":{"commonType":{"typeIdentifier":"t_bytes4","typeString":"bytes4"},"id":54257,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftExpression":{"id":54253,"name":"_sel","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54104,"src":"6147:4:100","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},"nodeType":"BinaryOperation","operator":"==","rightExpression":{"expression":{"expression":{"id":54254,"name":"this","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":-28,"src":"6155:4:100","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$54911","typeString":"contract FetchChainInfoOutput"}},"id":54255,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"6160:23:100","memberName":"disputeGameFactoryProxy","nodeType":"MemberAccess","referencedDeclaration":54669,"src":"6155:28:100","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":54256,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"memberLocation":"6184:8:100","memberName":"selector","nodeType":"MemberAccess","src":"6155:37:100","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},"src":"6147:45:100","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},"falseBody":{"condition":{"commonType":{"typeIdentifier":"t_bytes4","typeString":"bytes4"},"id":54266,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftExpression":{"id":54262,"name":"_sel","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54104,"src":"6245:4:100","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},"nodeType":"BinaryOperation","operator":"==","rightExpression":{"expression":{"expression":{"id":54263,"name":"this","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":-28,"src":"6253:4:100","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$54911","typeString":"contract FetchChainInfoOutput"}},"id":54264,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"6258:20:100","memberName":"faultDisputeGameImpl","nodeType":"MemberAccess","referencedDeclaration":54687,"src":"6253:25:100","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":54265,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"memberLocation":"6279:8:100","memberName":"selector","nodeType":"MemberAccess","src":"6253:34:100","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},"src":"6245:42:100","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},"falseBody":{"condition":{"commonType":{"typeIdentifier":"t_bytes4","typeString":"bytes4"},"id":54275,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftExpression":{"id":54271,"name":"_sel","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54104,"src":"6337:4:100","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},"nodeType":"BinaryOperation","operator":"==","rightExpression":{"expression":{"expression":{"id":54272,"name":"this","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":-28,"src":"6345:4:100","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$54911","typeString":"contract FetchChainInfoOutput"}},"id":54273,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"6350:30:100","memberName":"faultDisputeGameCannonKonaImpl","nodeType":"MemberAccess","referencedDeclaration":54705,"src":"6345:35:100","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":54274,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"memberLocation":"6381:8:100","memberName":"selector","nodeType":"MemberAccess","src":"6345:44:100","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},"src":"6337:52:100","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},"falseBody":{"condition":{"commonType":{"typeIdentifier":"t_bytes4","typeString":"bytes4"},"id":54284,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftExpression":{"id":54280,"name":"_sel","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54104,"src":"6449:4:100","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},"nodeType":"BinaryOperation","operator":"==","rightExpression":{"expression":{"expression":{"id":54281,"name":"this","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":-28,"src":"6457:4:100","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$54911","typeString":"contract FetchChainInfoOutput"}},"id":54282,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"6462:27:100","memberName":"permissionedDisputeGameImpl","nodeType":"MemberAccess","referencedDeclaration":54741,"src":"6457:32:100","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":54283,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"memberLocation":"6490:8:100","memberName":"selector","nodeType":"MemberAccess","src":"6457:41:100","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},"src":"6449:49:100","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},"falseBody":{"condition":{"commonType":{"typeIdentifier":"t_bytes4","typeString":"bytes4"},"id":54293,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftExpression":{"id":54289,"name":"_sel","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54104,"src":"6572:4:100","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},"nodeType":"BinaryOperation","operator":"==","rightExpression":{"expression":{"expression":{"id":54290,"name":"this","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":-28,"src":"6580:4:100","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$54911","typeString":"contract FetchChainInfoOutput"}},"id":54291,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"6585:17:100","memberName":"systemConfigOwner","nodeType":"MemberAccess","referencedDeclaration":54777,"src":"6580:22:100","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":54292,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"memberLocation":"6603:8:100","memberName":"selector","nodeType":"MemberAccess","src":"6580:31:100","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},"src":"6572:39:100","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},"falseBody":{"condition":{"commonType":{"typeIdentifier":"t_bytes4","typeString":"bytes4"},"id":54302,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftExpression":{"id":54298,"name":"_sel","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54104,"src":"6658:4:100","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},"nodeType":"BinaryOperation","operator":"==","rightExpression":{"expression":{"expression":{"id":54299,"name":"this","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":-28,"src":"6666:4:100","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$54911","typeString":"contract FetchChainInfoOutput"}},"id":54300,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"6671:22:100","memberName":"opChainProxyAdminOwner","nodeType":"MemberAccess","referencedDeclaration":54795,"src":"6666:27:100","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":54301,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"memberLocation":"6694:8:100","memberName":"selector","nodeType":"MemberAccess","src":"6666:36:100","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},"src":"6658:44:100","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},"falseBody":{"condition":{"commonType":{"typeIdentifier":"t_bytes4","typeString":"bytes4"},"id":54311,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftExpression":{"id":54307,"name":"_sel","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54104,"src":"6754:4:100","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},"nodeType":"BinaryOperation","operator":"==","rightExpression":{"expression":{"expression":{"id":54308,"name":"this","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":-28,"src":"6762:4:100","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$54911","typeString":"contract FetchChainInfoOutput"}},"id":54309,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"6767:15:100","memberName":"opChainGuardian","nodeType":"MemberAccess","referencedDeclaration":54813,"src":"6762:20:100","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":54310,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"memberLocation":"6783:8:100","memberName":"selector","nodeType":"MemberAccess","src":"6762:29:100","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},"src":"6754:37:100","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},"falseBody":{"condition":{"commonType":{"typeIdentifier":"t_bytes4","typeString":"bytes4"},"id":54320,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftExpression":{"id":54316,"name":"_sel","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54104,"src":"6836:4:100","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},"nodeType":"BinaryOperation","operator":"==","rightExpression":{"expression":{"expression":{"id":54317,"name":"this","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":-28,"src":"6844:4:100","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$54911","typeString":"contract FetchChainInfoOutput"}},"id":54318,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"6849:10:100","memberName":"challenger","nodeType":"MemberAccess","referencedDeclaration":54831,"src":"6844:15:100","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":54319,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"memberLocation":"6860:8:100","memberName":"selector","nodeType":"MemberAccess","src":"6844:24:100","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},"src":"6836:32:100","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},"falseBody":{"condition":{"commonType":{"typeIdentifier":"t_bytes4","typeString":"bytes4"},"id":54329,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftExpression":{"id":54325,"name":"_sel","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54104,"src":"6908:4:100","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},"nodeType":"BinaryOperation","operator":"==","rightExpression":{"expression":{"expression":{"id":54326,"name":"this","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":-28,"src":"6916:4:100","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$54911","typeString":"contract FetchChainInfoOutput"}},"id":54327,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"6921:8:100","memberName":"proposer","nodeType":"MemberAccess","referencedDeclaration":54849,"src":"6916:13:100","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":54328,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"memberLocation":"6930:8:100","memberName":"selector","nodeType":"MemberAccess","src":"6916:22:100","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},"src":"6908:30:100","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},"falseBody":{"condition":{"commonType":{"typeIdentifier":"t_bytes4","typeString":"bytes4"},"id":54338,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftExpression":{"id":54334,"name":"_sel","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54104,"src":"6976:4:100","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},"nodeType":"BinaryOperation","operator":"==","rightExpression":{"expression":{"expression":{"id":54335,"name":"this","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":-28,"src":"6984:4:100","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$54911","typeString":"contract FetchChainInfoOutput"}},"id":54336,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"6989:17:100","memberName":"unsafeBlockSigner","nodeType":"MemberAccess","referencedDeclaration":54867,"src":"6984:22:100","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":54337,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"memberLocation":"7007:8:100","memberName":"selector","nodeType":"MemberAccess","src":"6984:31:100","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},"src":"6976:39:100","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},"falseBody":{"condition":{"commonType":{"typeIdentifier":"t_bytes4","typeString":"bytes4"},"id":54347,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftExpression":{"id":54343,"name":"_sel","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54104,"src":"7062:4:100","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},"nodeType":"BinaryOperation","operator":"==","rightExpression":{"expression":{"expression":{"id":54344,"name":"this","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":-28,"src":"7070:4:100","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$54911","typeString":"contract FetchChainInfoOutput"}},"id":54345,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"7075:14:100","memberName":"batchSubmitter","nodeType":"MemberAccess","referencedDeclaration":54885,"src":"7070:19:100","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":54346,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"memberLocation":"7090:8:100","memberName":"selector","nodeType":"MemberAccess","src":"7070:28:100","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},"src":"7062:36:100","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},"falseBody":{"expression":{"arguments":[{"hexValue":"4665746368436861696e496e666f4f75747075743a20756e6b6e6f776e20616464726573732073656c6563746f722074657374","id":54353,"isConstant":false,"isLValue":false,"isPure":true,"kind":"string","lValueRequested":false,"nodeType":"Literal","src":"7145:53:100","typeDescriptions":{"typeIdentifier":"t_stringliteral_8be6a92cba5443877e2b6bededc383e178c3f2718dce3f3864f1721c31f5c065","typeString":"literal_string \"FetchChainInfoOutput: unknown address selector test\""},"value":"FetchChainInfoOutput: unknown address selector test"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_stringliteral_8be6a92cba5443877e2b6bededc383e178c3f2718dce3f3864f1721c31f5c065","typeString":"literal_string \"FetchChainInfoOutput: unknown address selector test\""}],"id":54352,"name":"revert","nodeType":"Identifier","overloadedDeclarations":[-19,-19],"referencedDeclaration":-19,"src":"7138:6:100","typeDescriptions":{"typeIdentifier":"t_function_revert_pure$_t_string_memory_ptr_$returns$__$","typeString":"function (string memory) pure"}},"id":54354,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"7138:61:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":54355,"nodeType":"ExpressionStatement","src":"7138:61:100"},"id":54356,"nodeType":"IfStatement","src":"7058:141:100","trueBody":{"expression":{"id":54350,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftHandSide":{"id":54348,"name":"_batchSubmitter","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54095,"src":"7100:15:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"Assignment","operator":"=","rightHandSide":{"id":54349,"name":"_addr","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54106,"src":"7118:5:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"src":"7100:23:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"id":54351,"nodeType":"ExpressionStatement","src":"7100:23:100"}},"id":54357,"nodeType":"IfStatement","src":"6972:227:100","trueBody":{"expression":{"id":54341,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftHandSide":{"id":54339,"name":"_unsafeBlockSigner","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54093,"src":"7017:18:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"Assignment","operator":"=","rightHandSide":{"id":54340,"name":"_addr","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54106,"src":"7038:5:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"src":"7017:26:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"id":54342,"nodeType":"ExpressionStatement","src":"7017:26:100"}},"id":54358,"nodeType":"IfStatement","src":"6904:295:100","trueBody":{"expression":{"id":54332,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftHandSide":{"id":54330,"name":"_proposer","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54091,"src":"6940:9:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"Assignment","operator":"=","rightHandSide":{"id":54331,"name":"_addr","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54106,"src":"6952:5:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"src":"6940:17:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"id":54333,"nodeType":"ExpressionStatement","src":"6940:17:100"}},"id":54359,"nodeType":"IfStatement","src":"6832:367:100","trueBody":{"expression":{"id":54323,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftHandSide":{"id":54321,"name":"_challenger","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54089,"src":"6870:11:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"Assignment","operator":"=","rightHandSide":{"id":54322,"name":"_addr","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54106,"src":"6884:5:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"src":"6870:19:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"id":54324,"nodeType":"ExpressionStatement","src":"6870:19:100"}},"id":54360,"nodeType":"IfStatement","src":"6750:449:100","trueBody":{"expression":{"id":54314,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftHandSide":{"id":54312,"name":"_opChainGuardian","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54087,"src":"6793:16:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"Assignment","operator":"=","rightHandSide":{"id":54313,"name":"_addr","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54106,"src":"6812:5:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"src":"6793:24:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"id":54315,"nodeType":"ExpressionStatement","src":"6793:24:100"}},"id":54361,"nodeType":"IfStatement","src":"6654:545:100","trueBody":{"expression":{"id":54305,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftHandSide":{"id":54303,"name":"_opChainProxyAdminOwner","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54085,"src":"6704:23:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"Assignment","operator":"=","rightHandSide":{"id":54304,"name":"_addr","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54106,"src":"6730:5:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"src":"6704:31:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"id":54306,"nodeType":"ExpressionStatement","src":"6704:31:100"}},"id":54362,"nodeType":"IfStatement","src":"6568:631:100","trueBody":{"expression":{"id":54296,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftHandSide":{"id":54294,"name":"_systemConfigOwner","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54083,"src":"6613:18:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"Assignment","operator":"=","rightHandSide":{"id":54295,"name":"_addr","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54106,"src":"6634:5:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"src":"6613:26:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"id":54297,"nodeType":"ExpressionStatement","src":"6613:26:100"}},"id":54363,"nodeType":"IfStatement","src":"6445:754:100","trueBody":{"expression":{"id":54287,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftHandSide":{"id":54285,"name":"_permissionedDisputeGameImpl","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54081,"src":"6500:28:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"Assignment","operator":"=","rightHandSide":{"id":54286,"name":"_addr","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54106,"src":"6531:5:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"src":"6500:36:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"id":54288,"nodeType":"ExpressionStatement","src":"6500:36:100"}},"id":54364,"nodeType":"IfStatement","src":"6333:866:100","trueBody":{"expression":{"id":54278,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftHandSide":{"id":54276,"name":"_faultDisputeGameCannonKonaImpl","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54079,"src":"6391:31:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"Assignment","operator":"=","rightHandSide":{"id":54277,"name":"_addr","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54106,"src":"6425:5:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"src":"6391:39:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"id":54279,"nodeType":"ExpressionStatement","src":"6391:39:100"}},"id":54365,"nodeType":"IfStatement","src":"6241:958:100","trueBody":{"expression":{"id":54269,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftHandSide":{"id":54267,"name":"_faultDisputeGameImpl","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54077,"src":"6289:21:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"Assignment","operator":"=","rightHandSide":{"id":54268,"name":"_addr","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54106,"src":"6313:5:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"src":"6289:29:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"id":54270,"nodeType":"ExpressionStatement","src":"6289:29:100"}},"id":54366,"nodeType":"IfStatement","src":"6143:1056:100","trueBody":{"expression":{"id":54260,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftHandSide":{"id":54258,"name":"_disputeGameFactoryProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54075,"src":"6194:24:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"Assignment","operator":"=","rightHandSide":{"id":54259,"name":"_addr","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54106,"src":"6221:5:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"src":"6194:32:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"id":54261,"nodeType":"ExpressionStatement","src":"6194:32:100"}},"id":54367,"nodeType":"IfStatement","src":"6023:1176:100","trueBody":{"expression":{"id":54251,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftHandSide":{"id":54249,"name":"_delayedWethPermissionlessGameProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54073,"src":"6085:35:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"Assignment","operator":"=","rightHandSide":{"id":54250,"name":"_addr","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54106,"src":"6123:5:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"src":"6085:43:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"id":54252,"nodeType":"ExpressionStatement","src":"6085:43:100"}},"id":54368,"nodeType":"IfStatement","src":"5907:1292:100","trueBody":{"expression":{"id":54242,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftHandSide":{"id":54240,"name":"_delayedWethPermissionedGameProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54071,"src":"5967:33:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"Assignment","operator":"=","rightHandSide":{"id":54241,"name":"_addr","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54106,"src":"6003:5:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"src":"5967:41:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"id":54243,"nodeType":"ExpressionStatement","src":"5967:41:100"}},"id":54369,"nodeType":"IfStatement","src":"5807:1392:100","trueBody":{"expression":{"id":54233,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftHandSide":{"id":54231,"name":"_anchorStateRegistryProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54069,"src":"5859:25:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"Assignment","operator":"=","rightHandSide":{"id":54232,"name":"_addr","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54106,"src":"5887:5:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"src":"5859:33:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"id":54234,"nodeType":"ExpressionStatement","src":"5859:33:100"}},"id":54370,"nodeType":"IfStatement","src":"5713:1486:100","trueBody":{"expression":{"id":54224,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftHandSide":{"id":54222,"name":"_opChainProxyAdminImpl","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54067,"src":"5762:22:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"Assignment","operator":"=","rightHandSide":{"id":54223,"name":"_addr","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54106,"src":"5787:5:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"src":"5762:30:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"id":54225,"nodeType":"ExpressionStatement","src":"5762:30:100"}},"id":54371,"nodeType":"IfStatement","src":"5627:1572:100","trueBody":{"expression":{"id":54215,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftHandSide":{"id":54213,"name":"_systemConfigProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54065,"src":"5672:18:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"Assignment","operator":"=","rightHandSide":{"id":54214,"name":"_addr","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54106,"src":"5693:5:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"src":"5672:26:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"id":54216,"nodeType":"ExpressionStatement","src":"5672:26:100"}},"id":54372,"nodeType":"IfStatement","src":"5537:1662:100","trueBody":{"expression":{"id":54206,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftHandSide":{"id":54204,"name":"_optimismPortalProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54063,"src":"5584:20:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"Assignment","operator":"=","rightHandSide":{"id":54205,"name":"_addr","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54106,"src":"5607:5:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"src":"5584:28:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"id":54207,"nodeType":"ExpressionStatement","src":"5584:28:100"}},"id":54373,"nodeType":"IfStatement","src":"5419:1780:100","trueBody":{"expression":{"id":54197,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftHandSide":{"id":54195,"name":"_optimismMintableErc20FactoryProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54061,"src":"5480:34:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"Assignment","operator":"=","rightHandSide":{"id":54196,"name":"_addr","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54106,"src":"5517:5:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"src":"5480:42:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"id":54198,"nodeType":"ExpressionStatement","src":"5480:42:100"}},"id":54374,"nodeType":"IfStatement","src":"5329:1870:100","trueBody":{"expression":{"id":54188,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftHandSide":{"id":54186,"name":"_l2OutputOracleProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54059,"src":"5376:20:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"Assignment","operator":"=","rightHandSide":{"id":54187,"name":"_addr","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54106,"src":"5399:5:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"src":"5376:28:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"id":54189,"nodeType":"ExpressionStatement","src":"5376:28:100"}},"id":54375,"nodeType":"IfStatement","src":"5235:1964:100","trueBody":{"expression":{"id":54179,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftHandSide":{"id":54177,"name":"_l1StandardBridgeProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54057,"src":"5284:22:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"Assignment","operator":"=","rightHandSide":{"id":54178,"name":"_addr","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54106,"src":"5309:5:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"src":"5284:30:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"id":54180,"nodeType":"ExpressionStatement","src":"5284:30:100"}},"id":54376,"nodeType":"IfStatement","src":"5145:2054:100","trueBody":{"expression":{"id":54170,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftHandSide":{"id":54168,"name":"_l1Erc721BridgeProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54055,"src":"5192:20:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"Assignment","operator":"=","rightHandSide":{"id":54169,"name":"_addr","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54106,"src":"5215:5:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"src":"5192:28:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"id":54171,"nodeType":"ExpressionStatement","src":"5192:28:100"}},"id":54377,"nodeType":"IfStatement","src":"5039:2160:100","trueBody":{"expression":{"id":54161,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftHandSide":{"id":54159,"name":"_l1CrossDomainMessengerProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54053,"src":"5094:28:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"Assignment","operator":"=","rightHandSide":{"id":54160,"name":"_addr","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54106,"src":"5125:5:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"src":"5094:36:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"id":54162,"nodeType":"ExpressionStatement","src":"5094:36:100"}},"id":54378,"nodeType":"IfStatement","src":"4957:2242:100","trueBody":{"expression":{"id":54152,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftHandSide":{"id":54150,"name":"_ethLockboxProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54051,"src":"5000:16:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"Assignment","operator":"=","rightHandSide":{"id":54151,"name":"_addr","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54106,"src":"5019:5:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"src":"5000:24:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"id":54153,"nodeType":"ExpressionStatement","src":"5000:24:100"}},"id":54379,"nodeType":"IfStatement","src":"4869:2330:100","trueBody":{"expression":{"id":54143,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftHandSide":{"id":54141,"name":"_addressManagerImpl","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54049,"src":"4915:19:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"Assignment","operator":"=","rightHandSide":{"id":54142,"name":"_addr","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54106,"src":"4937:5:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"src":"4915:27:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"id":54144,"nodeType":"ExpressionStatement","src":"4915:27:100"}},"id":54380,"nodeType":"IfStatement","src":"4750:2449:100","trueBody":{"expression":{"id":54134,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftHandSide":{"id":54132,"name":"_preimageOracleImpl","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54047,"src":"4796:19:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"Assignment","operator":"=","rightHandSide":{"id":54133,"name":"_addr","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54106,"src":"4818:5:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"src":"4796:27:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"id":54135,"nodeType":"ExpressionStatement","src":"4796:27:100"}},"id":54381,"nodeType":"IfStatement","src":"4682:2517:100","trueBody":{"expression":{"id":54125,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftHandSide":{"id":54123,"name":"_mipsImpl","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54045,"src":"4718:9:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"Assignment","operator":"=","rightHandSide":{"id":54124,"name":"_addr","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54106,"src":"4730:5:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"src":"4718:17:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"id":54126,"nodeType":"ExpressionStatement","src":"4718:17:100"}},"id":54382,"nodeType":"IfStatement","src":"4549:2650:100","trueBody":{"expression":{"id":54116,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftHandSide":{"id":54114,"name":"_superchainConfigProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54043,"src":"4598:22:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"Assignment","operator":"=","rightHandSide":{"id":54115,"name":"_addr","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54106,"src":"4623:5:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"src":"4598:30:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"id":54117,"nodeType":"ExpressionStatement","src":"4598:30:100"}}]},"functionSelector":"c3e39250","implemented":true,"kind":"function","modifiers":[],"name":"set","nameLocation":"4469:3:100","parameters":{"id":54107,"nodeType":"ParameterList","parameters":[{"constant":false,"id":54104,"mutability":"mutable","name":"_sel","nameLocation":"4480:4:100","nodeType":"VariableDeclaration","scope":54384,"src":"4473:11:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"},"typeName":{"id":54103,"name":"bytes4","nodeType":"ElementaryTypeName","src":"4473:6:100","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},"visibility":"internal"},{"constant":false,"id":54106,"mutability":"mutable","name":"_addr","nameLocation":"4494:5:100","nodeType":"VariableDeclaration","scope":54384,"src":"4486:13:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":54105,"name":"address","nodeType":"ElementaryTypeName","src":"4486:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"4472:28:100"},"returnParameters":{"id":54108,"nodeType":"ParameterList","parameters":[],"src":"4508:0:100"},"scope":54911,"stateMutability":"nonpayable","virtual":false,"visibility":"public"},{"id":54416,"nodeType":"FunctionDefinition","src":"7212:271:100","nodes":[],"body":{"id":54415,"nodeType":"Block","src":"7257:226:100","nodes":[],"statements":[{"condition":{"commonType":{"typeIdentifier":"t_bytes4","typeString":"bytes4"},"id":54395,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftExpression":{"id":54391,"name":"_sel","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54386,"src":"7271:4:100","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},"nodeType":"BinaryOperation","operator":"==","rightExpression":{"expression":{"expression":{"id":54392,"name":"this","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":-28,"src":"7279:4:100","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$54911","typeString":"contract FetchChainInfoOutput"}},"id":54393,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"7284:12:100","memberName":"permissioned","nodeType":"MemberAccess","referencedDeclaration":54893,"src":"7279:17:100","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_bool_$","typeString":"function () view external returns (bool)"}},"id":54394,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"memberLocation":"7297:8:100","memberName":"selector","nodeType":"MemberAccess","src":"7279:26:100","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},"src":"7271:34:100","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},"falseBody":{"condition":{"commonType":{"typeIdentifier":"t_bytes4","typeString":"bytes4"},"id":54404,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftExpression":{"id":54400,"name":"_sel","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54386,"src":"7347:4:100","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},"nodeType":"BinaryOperation","operator":"==","rightExpression":{"expression":{"expression":{"id":54401,"name":"this","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":-28,"src":"7355:4:100","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$54911","typeString":"contract FetchChainInfoOutput"}},"id":54402,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"7360:14:100","memberName":"permissionless","nodeType":"MemberAccess","referencedDeclaration":54901,"src":"7355:19:100","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_bool_$","typeString":"function () view external returns (bool)"}},"id":54403,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"memberLocation":"7375:8:100","memberName":"selector","nodeType":"MemberAccess","src":"7355:28:100","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},"src":"7347:36:100","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},"falseBody":{"expression":{"arguments":[{"hexValue":"4665746368436861696e496e666f4f75747075743a20756e6b6e6f776e20626f6f6c2073656c6563746f72","id":54410,"isConstant":false,"isLValue":false,"isPure":true,"kind":"string","lValueRequested":false,"nodeType":"Literal","src":"7430:45:100","typeDescriptions":{"typeIdentifier":"t_stringliteral_b43e73201a672ac9d292be9f8dc7215ba0fae6d34ae76c7f77ffd9b31af48fae","typeString":"literal_string \"FetchChainInfoOutput: unknown bool selector\""},"value":"FetchChainInfoOutput: unknown bool selector"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_stringliteral_b43e73201a672ac9d292be9f8dc7215ba0fae6d34ae76c7f77ffd9b31af48fae","typeString":"literal_string \"FetchChainInfoOutput: unknown bool selector\""}],"id":54409,"name":"revert","nodeType":"Identifier","overloadedDeclarations":[-19,-19],"referencedDeclaration":-19,"src":"7423:6:100","typeDescriptions":{"typeIdentifier":"t_function_revert_pure$_t_string_memory_ptr_$returns$__$","typeString":"function (string memory) pure"}},"id":54411,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"7423:53:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":54412,"nodeType":"ExpressionStatement","src":"7423:53:100"},"id":54413,"nodeType":"IfStatement","src":"7343:133:100","trueBody":{"expression":{"id":54407,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftHandSide":{"id":54405,"name":"_permissionless","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54099,"src":"7385:15:100","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},"nodeType":"Assignment","operator":"=","rightHandSide":{"id":54406,"name":"_bool","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54388,"src":"7403:5:100","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},"src":"7385:23:100","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},"id":54408,"nodeType":"ExpressionStatement","src":"7385:23:100"}},"id":54414,"nodeType":"IfStatement","src":"7267:209:100","trueBody":{"expression":{"id":54398,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftHandSide":{"id":54396,"name":"_permissioned","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54097,"src":"7307:13:100","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},"nodeType":"Assignment","operator":"=","rightHandSide":{"id":54397,"name":"_bool","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54388,"src":"7323:5:100","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},"src":"7307:21:100","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},"id":54399,"nodeType":"ExpressionStatement","src":"7307:21:100"}}]},"functionSelector":"baa1e15e","implemented":true,"kind":"function","modifiers":[],"name":"set","nameLocation":"7221:3:100","parameters":{"id":54389,"nodeType":"ParameterList","parameters":[{"constant":false,"id":54386,"mutability":"mutable","name":"_sel","nameLocation":"7232:4:100","nodeType":"VariableDeclaration","scope":54416,"src":"7225:11:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"},"typeName":{"id":54385,"name":"bytes4","nodeType":"ElementaryTypeName","src":"7225:6:100","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},"visibility":"internal"},{"constant":false,"id":54388,"mutability":"mutable","name":"_bool","nameLocation":"7243:5:100","nodeType":"VariableDeclaration","scope":54416,"src":"7238:10:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"},"typeName":{"id":54387,"name":"bool","nodeType":"ElementaryTypeName","src":"7238:4:100","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},"visibility":"internal"}],"src":"7224:25:100"},"returnParameters":{"id":54390,"nodeType":"ParameterList","parameters":[],"src":"7257:0:100"},"scope":54911,"stateMutability":"nonpayable","virtual":false,"visibility":"public"},{"id":54439,"nodeType":"FunctionDefinition","src":"7489:217:100","nodes":[],"body":{"id":54438,"nodeType":"Block","src":"7542:164:100","nodes":[],"statements":[{"condition":{"commonType":{"typeIdentifier":"t_bytes4","typeString":"bytes4"},"id":54428,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftExpression":{"id":54424,"name":"_sel","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54418,"src":"7556:4:100","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},"nodeType":"BinaryOperation","operator":"==","rightExpression":{"expression":{"expression":{"id":54425,"name":"this","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":-28,"src":"7564:4:100","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$54911","typeString":"contract FetchChainInfoOutput"}},"id":54426,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"7569:17:100","memberName":"respectedGameType","nodeType":"MemberAccess","referencedDeclaration":54910,"src":"7564:22:100","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_userDefinedValueType$_GameType_$70720_$","typeString":"function () view external returns (GameType)"}},"id":54427,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"memberLocation":"7587:8:100","memberName":"selector","nodeType":"MemberAccess","src":"7564:31:100","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},"src":"7556:39:100","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},"falseBody":{"expression":{"arguments":[{"hexValue":"4665746368436861696e496e666f4f75747075743a20756e6b6e6f776e2047616d65547970652073656c6563746f72","id":54434,"isConstant":false,"isLValue":false,"isPure":true,"kind":"string","lValueRequested":false,"nodeType":"Literal","src":"7649:49:100","typeDescriptions":{"typeIdentifier":"t_stringliteral_520d3d0cced140fee76c803f92d1db783b790e13f72de1e8f8c229c8c8783afc","typeString":"literal_string \"FetchChainInfoOutput: unknown GameType selector\""},"value":"FetchChainInfoOutput: unknown GameType selector"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_stringliteral_520d3d0cced140fee76c803f92d1db783b790e13f72de1e8f8c229c8c8783afc","typeString":"literal_string \"FetchChainInfoOutput: unknown GameType selector\""}],"id":54433,"name":"revert","nodeType":"Identifier","overloadedDeclarations":[-19,-19],"referencedDeclaration":-19,"src":"7642:6:100","typeDescriptions":{"typeIdentifier":"t_function_revert_pure$_t_string_memory_ptr_$returns$__$","typeString":"function (string memory) pure"}},"id":54435,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"7642:57:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":54436,"nodeType":"ExpressionStatement","src":"7642:57:100"},"id":54437,"nodeType":"IfStatement","src":"7552:147:100","trueBody":{"expression":{"id":54431,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftHandSide":{"id":54429,"name":"_respectedGameType","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54102,"src":"7597:18:100","typeDescriptions":{"typeIdentifier":"t_userDefinedValueType$_GameType_$70720","typeString":"GameType"}},"nodeType":"Assignment","operator":"=","rightHandSide":{"id":54430,"name":"_gameType","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54421,"src":"7618:9:100","typeDescriptions":{"typeIdentifier":"t_userDefinedValueType$_GameType_$70720","typeString":"GameType"}},"src":"7597:30:100","typeDescriptions":{"typeIdentifier":"t_userDefinedValueType$_GameType_$70720","typeString":"GameType"}},"id":54432,"nodeType":"ExpressionStatement","src":"7597:30:100"}}]},"functionSelector":"d08d6066","implemented":true,"kind":"function","modifiers":[],"name":"set","nameLocation":"7498:3:100","parameters":{"id":54422,"nodeType":"ParameterList","parameters":[{"constant":false,"id":54418,"mutability":"mutable","name":"_sel","nameLocation":"7509:4:100","nodeType":"VariableDeclaration","scope":54439,"src":"7502:11:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"},"typeName":{"id":54417,"name":"bytes4","nodeType":"ElementaryTypeName","src":"7502:6:100","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},"visibility":"internal"},{"constant":false,"id":54421,"mutability":"mutable","name":"_gameType","nameLocation":"7524:9:100","nodeType":"VariableDeclaration","scope":54439,"src":"7515:18:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_userDefinedValueType$_GameType_$70720","typeString":"GameType"},"typeName":{"id":54420,"nodeType":"UserDefinedTypeName","pathNode":{"id":54419,"name":"GameType","nameLocations":["7515:8:100"],"nodeType":"IdentifierPath","referencedDeclaration":70720,"src":"7515:8:100"},"referencedDeclaration":70720,"src":"7515:8:100","typeDescriptions":{"typeIdentifier":"t_userDefinedValueType$_GameType_$70720","typeString":"GameType"}},"visibility":"internal"}],"src":"7501:33:100"},"returnParameters":{"id":54423,"nodeType":"ParameterList","parameters":[],"src":"7542:0:100"},"scope":54911,"stateMutability":"nonpayable","virtual":false,"visibility":"public"},{"id":54457,"nodeType":"FunctionDefinition","src":"7712:207:100","nodes":[],"body":{"id":54456,"nodeType":"Block","src":"7772:147:100","nodes":[],"statements":[{"expression":{"arguments":[{"commonType":{"typeIdentifier":"t_address","typeString":"address"},"id":54450,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftExpression":{"id":54445,"name":"_addressManagerImpl","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54049,"src":"7790:19:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"BinaryOperation","operator":"!=","rightExpression":{"arguments":[{"hexValue":"30","id":54448,"isConstant":false,"isLValue":false,"isPure":true,"kind":"number","lValueRequested":false,"nodeType":"Literal","src":"7821:1:100","typeDescriptions":{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"},"value":"0"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"}],"id":54447,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"nodeType":"ElementaryTypeNameExpression","src":"7813:7:100","typeDescriptions":{"typeIdentifier":"t_type$_t_address_$","typeString":"type(address)"},"typeName":{"id":54446,"name":"address","nodeType":"ElementaryTypeName","src":"7813:7:100","typeDescriptions":{}}},"id":54449,"isConstant":false,"isLValue":false,"isPure":true,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"7813:10:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"src":"7790:33:100","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},{"hexValue":"4665746368436861696e496e666f4f75747075743a20616464726573734d616e61676572496d706c206e6f7420736574","id":54451,"isConstant":false,"isLValue":false,"isPure":true,"kind":"string","lValueRequested":false,"nodeType":"Literal","src":"7825:50:100","typeDescriptions":{"typeIdentifier":"t_stringliteral_b154041fe6470d62d16e8ad5c6d8e6c50a46e3e155a380b02703b07321b83f6a","typeString":"literal_string \"FetchChainInfoOutput: addressManagerImpl not set\""},"value":"FetchChainInfoOutput: addressManagerImpl not set"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_bool","typeString":"bool"},{"typeIdentifier":"t_stringliteral_b154041fe6470d62d16e8ad5c6d8e6c50a46e3e155a380b02703b07321b83f6a","typeString":"literal_string \"FetchChainInfoOutput: addressManagerImpl not set\""}],"id":54444,"name":"require","nodeType":"Identifier","overloadedDeclarations":[-18,-18,-18],"referencedDeclaration":-18,"src":"7782:7:100","typeDescriptions":{"typeIdentifier":"t_function_require_pure$_t_bool_$_t_string_memory_ptr_$returns$__$","typeString":"function (bool,string memory) pure"}},"id":54452,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"7782:94:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":54453,"nodeType":"ExpressionStatement","src":"7782:94:100"},{"expression":{"id":54454,"name":"_addressManagerImpl","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54049,"src":"7893:19:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"functionReturnParameters":54443,"id":54455,"nodeType":"Return","src":"7886:26:100"}]},"functionSelector":"bd366b8f","implemented":true,"kind":"function","modifiers":[],"name":"addressManagerImpl","nameLocation":"7721:18:100","parameters":{"id":54440,"nodeType":"ParameterList","parameters":[],"src":"7739:2:100"},"returnParameters":{"id":54443,"nodeType":"ParameterList","parameters":[{"constant":false,"id":54442,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":54457,"src":"7763:7:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":54441,"name":"address","nodeType":"ElementaryTypeName","src":"7763:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"7762:9:100"},"scope":54911,"stateMutability":"view","virtual":false,"visibility":"public"},{"id":54465,"nodeType":"FunctionDefinition","src":"7925:97:100","nodes":[],"body":{"id":54464,"nodeType":"Block","src":"7982:40:100","nodes":[],"statements":[{"expression":{"id":54462,"name":"_ethLockboxProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54051,"src":"7999:16:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"functionReturnParameters":54461,"id":54463,"nodeType":"Return","src":"7992:23:100"}]},"functionSelector":"f646b07c","implemented":true,"kind":"function","modifiers":[],"name":"ethLockboxProxy","nameLocation":"7934:15:100","parameters":{"id":54458,"nodeType":"ParameterList","parameters":[],"src":"7949:2:100"},"returnParameters":{"id":54461,"nodeType":"ParameterList","parameters":[{"constant":false,"id":54460,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":54465,"src":"7973:7:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":54459,"name":"address","nodeType":"ElementaryTypeName","src":"7973:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"7972:9:100"},"scope":54911,"stateMutability":"view","virtual":false,"visibility":"public"},{"id":54483,"nodeType":"FunctionDefinition","src":"8028:243:100","nodes":[],"body":{"id":54482,"nodeType":"Block","src":"8097:174:100","nodes":[],"statements":[{"expression":{"arguments":[{"commonType":{"typeIdentifier":"t_address","typeString":"address"},"id":54476,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftExpression":{"id":54471,"name":"_l1CrossDomainMessengerProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54053,"src":"8115:28:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"BinaryOperation","operator":"!=","rightExpression":{"arguments":[{"hexValue":"30","id":54474,"isConstant":false,"isLValue":false,"isPure":true,"kind":"number","lValueRequested":false,"nodeType":"Literal","src":"8155:1:100","typeDescriptions":{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"},"value":"0"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"}],"id":54473,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"nodeType":"ElementaryTypeNameExpression","src":"8147:7:100","typeDescriptions":{"typeIdentifier":"t_type$_t_address_$","typeString":"type(address)"},"typeName":{"id":54472,"name":"address","nodeType":"ElementaryTypeName","src":"8147:7:100","typeDescriptions":{}}},"id":54475,"isConstant":false,"isLValue":false,"isPure":true,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"8147:10:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"src":"8115:42:100","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},{"hexValue":"4665746368436861696e496e666f4f75747075743a206c3143726f7373446f6d61696e4d657373656e67657250726f7879206e6f7420736574","id":54477,"isConstant":false,"isLValue":false,"isPure":true,"kind":"string","lValueRequested":false,"nodeType":"Literal","src":"8159:59:100","typeDescriptions":{"typeIdentifier":"t_stringliteral_c51216a9bdef996dd7040e19ba4fe817587273a187f1f145abfd19b1308df5eb","typeString":"literal_string \"FetchChainInfoOutput: l1CrossDomainMessengerProxy not set\""},"value":"FetchChainInfoOutput: l1CrossDomainMessengerProxy not set"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_bool","typeString":"bool"},{"typeIdentifier":"t_stringliteral_c51216a9bdef996dd7040e19ba4fe817587273a187f1f145abfd19b1308df5eb","typeString":"literal_string \"FetchChainInfoOutput: l1CrossDomainMessengerProxy not set\""}],"id":54470,"name":"require","nodeType":"Identifier","overloadedDeclarations":[-18,-18,-18],"referencedDeclaration":-18,"src":"8107:7:100","typeDescriptions":{"typeIdentifier":"t_function_require_pure$_t_bool_$_t_string_memory_ptr_$returns$__$","typeString":"function (bool,string memory) pure"}},"id":54478,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"8107:112:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":54479,"nodeType":"ExpressionStatement","src":"8107:112:100"},{"expression":{"id":54480,"name":"_l1CrossDomainMessengerProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54053,"src":"8236:28:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"functionReturnParameters":54469,"id":54481,"nodeType":"Return","src":"8229:35:100"}]},"functionSelector":"54729cfb","implemented":true,"kind":"function","modifiers":[],"name":"l1CrossDomainMessengerProxy","nameLocation":"8037:27:100","parameters":{"id":54466,"nodeType":"ParameterList","parameters":[],"src":"8064:2:100"},"returnParameters":{"id":54469,"nodeType":"ParameterList","parameters":[{"constant":false,"id":54468,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":54483,"src":"8088:7:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":54467,"name":"address","nodeType":"ElementaryTypeName","src":"8088:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"8087:9:100"},"scope":54911,"stateMutability":"view","virtual":false,"visibility":"public"},{"id":54501,"nodeType":"FunctionDefinition","src":"8277:211:100","nodes":[],"body":{"id":54500,"nodeType":"Block","src":"8338:150:100","nodes":[],"statements":[{"expression":{"arguments":[{"commonType":{"typeIdentifier":"t_address","typeString":"address"},"id":54494,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftExpression":{"id":54489,"name":"_l1Erc721BridgeProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54055,"src":"8356:20:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"BinaryOperation","operator":"!=","rightExpression":{"arguments":[{"hexValue":"30","id":54492,"isConstant":false,"isLValue":false,"isPure":true,"kind":"number","lValueRequested":false,"nodeType":"Literal","src":"8388:1:100","typeDescriptions":{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"},"value":"0"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"}],"id":54491,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"nodeType":"ElementaryTypeNameExpression","src":"8380:7:100","typeDescriptions":{"typeIdentifier":"t_type$_t_address_$","typeString":"type(address)"},"typeName":{"id":54490,"name":"address","nodeType":"ElementaryTypeName","src":"8380:7:100","typeDescriptions":{}}},"id":54493,"isConstant":false,"isLValue":false,"isPure":true,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"8380:10:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"src":"8356:34:100","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},{"hexValue":"4665746368436861696e496e666f4f75747075743a206c3145726337323142726964676550726f7879206e6f7420736574","id":54495,"isConstant":false,"isLValue":false,"isPure":true,"kind":"string","lValueRequested":false,"nodeType":"Literal","src":"8392:51:100","typeDescriptions":{"typeIdentifier":"t_stringliteral_bdf5319949d8561b59a02fe667aa58fca11f5f8571bc18997b0bc0ac582aece7","typeString":"literal_string \"FetchChainInfoOutput: l1Erc721BridgeProxy not set\""},"value":"FetchChainInfoOutput: l1Erc721BridgeProxy not set"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_bool","typeString":"bool"},{"typeIdentifier":"t_stringliteral_bdf5319949d8561b59a02fe667aa58fca11f5f8571bc18997b0bc0ac582aece7","typeString":"literal_string \"FetchChainInfoOutput: l1Erc721BridgeProxy not set\""}],"id":54488,"name":"require","nodeType":"Identifier","overloadedDeclarations":[-18,-18,-18],"referencedDeclaration":-18,"src":"8348:7:100","typeDescriptions":{"typeIdentifier":"t_function_require_pure$_t_bool_$_t_string_memory_ptr_$returns$__$","typeString":"function (bool,string memory) pure"}},"id":54496,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"8348:96:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":54497,"nodeType":"ExpressionStatement","src":"8348:96:100"},{"expression":{"id":54498,"name":"_l1Erc721BridgeProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54055,"src":"8461:20:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"functionReturnParameters":54487,"id":54499,"nodeType":"Return","src":"8454:27:100"}]},"functionSelector":"ebfa8409","implemented":true,"kind":"function","modifiers":[],"name":"l1Erc721BridgeProxy","nameLocation":"8286:19:100","parameters":{"id":54484,"nodeType":"ParameterList","parameters":[],"src":"8305:2:100"},"returnParameters":{"id":54487,"nodeType":"ParameterList","parameters":[{"constant":false,"id":54486,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":54501,"src":"8329:7:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":54485,"name":"address","nodeType":"ElementaryTypeName","src":"8329:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"8328:9:100"},"scope":54911,"stateMutability":"view","virtual":false,"visibility":"public"},{"id":54519,"nodeType":"FunctionDefinition","src":"8494:219:100","nodes":[],"body":{"id":54518,"nodeType":"Block","src":"8557:156:100","nodes":[],"statements":[{"expression":{"arguments":[{"commonType":{"typeIdentifier":"t_address","typeString":"address"},"id":54512,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftExpression":{"id":54507,"name":"_l1StandardBridgeProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54057,"src":"8575:22:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"BinaryOperation","operator":"!=","rightExpression":{"arguments":[{"hexValue":"30","id":54510,"isConstant":false,"isLValue":false,"isPure":true,"kind":"number","lValueRequested":false,"nodeType":"Literal","src":"8609:1:100","typeDescriptions":{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"},"value":"0"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"}],"id":54509,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"nodeType":"ElementaryTypeNameExpression","src":"8601:7:100","typeDescriptions":{"typeIdentifier":"t_type$_t_address_$","typeString":"type(address)"},"typeName":{"id":54508,"name":"address","nodeType":"ElementaryTypeName","src":"8601:7:100","typeDescriptions":{}}},"id":54511,"isConstant":false,"isLValue":false,"isPure":true,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"8601:10:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"src":"8575:36:100","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},{"hexValue":"4665746368436861696e496e666f4f75747075743a206c315374616e6461726442726964676550726f7879206e6f7420736574","id":54513,"isConstant":false,"isLValue":false,"isPure":true,"kind":"string","lValueRequested":false,"nodeType":"Literal","src":"8613:53:100","typeDescriptions":{"typeIdentifier":"t_stringliteral_ab3776e760de395cff3bb935602469d5b7c0bd9b5cfaefde9d221be6524302e1","typeString":"literal_string \"FetchChainInfoOutput: l1StandardBridgeProxy not set\""},"value":"FetchChainInfoOutput: l1StandardBridgeProxy not set"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_bool","typeString":"bool"},{"typeIdentifier":"t_stringliteral_ab3776e760de395cff3bb935602469d5b7c0bd9b5cfaefde9d221be6524302e1","typeString":"literal_string \"FetchChainInfoOutput: l1StandardBridgeProxy not set\""}],"id":54506,"name":"require","nodeType":"Identifier","overloadedDeclarations":[-18,-18,-18],"referencedDeclaration":-18,"src":"8567:7:100","typeDescriptions":{"typeIdentifier":"t_function_require_pure$_t_bool_$_t_string_memory_ptr_$returns$__$","typeString":"function (bool,string memory) pure"}},"id":54514,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"8567:100:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":54515,"nodeType":"ExpressionStatement","src":"8567:100:100"},{"expression":{"id":54516,"name":"_l1StandardBridgeProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54057,"src":"8684:22:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"functionReturnParameters":54505,"id":54517,"nodeType":"Return","src":"8677:29:100"}]},"functionSelector":"102b6069","implemented":true,"kind":"function","modifiers":[],"name":"l1StandardBridgeProxy","nameLocation":"8503:21:100","parameters":{"id":54502,"nodeType":"ParameterList","parameters":[],"src":"8524:2:100"},"returnParameters":{"id":54505,"nodeType":"ParameterList","parameters":[{"constant":false,"id":54504,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":54519,"src":"8548:7:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":54503,"name":"address","nodeType":"ElementaryTypeName","src":"8548:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"8547:9:100"},"scope":54911,"stateMutability":"view","virtual":false,"visibility":"public"},{"id":54537,"nodeType":"FunctionDefinition","src":"8719:211:100","nodes":[],"body":{"id":54536,"nodeType":"Block","src":"8780:150:100","nodes":[],"statements":[{"expression":{"arguments":[{"commonType":{"typeIdentifier":"t_address","typeString":"address"},"id":54530,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftExpression":{"id":54525,"name":"_l2OutputOracleProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54059,"src":"8798:20:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"BinaryOperation","operator":"!=","rightExpression":{"arguments":[{"hexValue":"30","id":54528,"isConstant":false,"isLValue":false,"isPure":true,"kind":"number","lValueRequested":false,"nodeType":"Literal","src":"8830:1:100","typeDescriptions":{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"},"value":"0"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"}],"id":54527,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"nodeType":"ElementaryTypeNameExpression","src":"8822:7:100","typeDescriptions":{"typeIdentifier":"t_type$_t_address_$","typeString":"type(address)"},"typeName":{"id":54526,"name":"address","nodeType":"ElementaryTypeName","src":"8822:7:100","typeDescriptions":{}}},"id":54529,"isConstant":false,"isLValue":false,"isPure":true,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"8822:10:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"src":"8798:34:100","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},{"hexValue":"4665746368436861696e496e666f4f75747075743a206c324f75747075744f7261636c6550726f7879206e6f7420736574","id":54531,"isConstant":false,"isLValue":false,"isPure":true,"kind":"string","lValueRequested":false,"nodeType":"Literal","src":"8834:51:100","typeDescriptions":{"typeIdentifier":"t_stringliteral_2f861759874f8f3e0cfa53ef8dfb0556f88f877edbaf1dbc485fc820d67ac86a","typeString":"literal_string \"FetchChainInfoOutput: l2OutputOracleProxy not set\""},"value":"FetchChainInfoOutput: l2OutputOracleProxy not set"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_bool","typeString":"bool"},{"typeIdentifier":"t_stringliteral_2f861759874f8f3e0cfa53ef8dfb0556f88f877edbaf1dbc485fc820d67ac86a","typeString":"literal_string \"FetchChainInfoOutput: l2OutputOracleProxy not set\""}],"id":54524,"name":"require","nodeType":"Identifier","overloadedDeclarations":[-18,-18,-18],"referencedDeclaration":-18,"src":"8790:7:100","typeDescriptions":{"typeIdentifier":"t_function_require_pure$_t_bool_$_t_string_memory_ptr_$returns$__$","typeString":"function (bool,string memory) pure"}},"id":54532,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"8790:96:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":54533,"nodeType":"ExpressionStatement","src":"8790:96:100"},{"expression":{"id":54534,"name":"_l2OutputOracleProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54059,"src":"8903:20:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"functionReturnParameters":54523,"id":54535,"nodeType":"Return","src":"8896:27:100"}]},"functionSelector":"a2c9a89f","implemented":true,"kind":"function","modifiers":[],"name":"l2OutputOracleProxy","nameLocation":"8728:19:100","parameters":{"id":54520,"nodeType":"ParameterList","parameters":[],"src":"8747:2:100"},"returnParameters":{"id":54523,"nodeType":"ParameterList","parameters":[{"constant":false,"id":54522,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":54537,"src":"8771:7:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":54521,"name":"address","nodeType":"ElementaryTypeName","src":"8771:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"8770:9:100"},"scope":54911,"stateMutability":"view","virtual":false,"visibility":"public"},{"id":54555,"nodeType":"FunctionDefinition","src":"8936:301:100","nodes":[],"body":{"id":54554,"nodeType":"Block","src":"9011:226:100","nodes":[],"statements":[{"expression":{"arguments":[{"commonType":{"typeIdentifier":"t_address","typeString":"address"},"id":54548,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftExpression":{"id":54543,"name":"_optimismMintableErc20FactoryProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54061,"src":"9042:34:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"BinaryOperation","operator":"!=","rightExpression":{"arguments":[{"hexValue":"30","id":54546,"isConstant":false,"isLValue":false,"isPure":true,"kind":"number","lValueRequested":false,"nodeType":"Literal","src":"9088:1:100","typeDescriptions":{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"},"value":"0"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"}],"id":54545,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"nodeType":"ElementaryTypeNameExpression","src":"9080:7:100","typeDescriptions":{"typeIdentifier":"t_type$_t_address_$","typeString":"type(address)"},"typeName":{"id":54544,"name":"address","nodeType":"ElementaryTypeName","src":"9080:7:100","typeDescriptions":{}}},"id":54547,"isConstant":false,"isLValue":false,"isPure":true,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"9080:10:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"src":"9042:48:100","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},{"hexValue":"4665746368436861696e496e666f4f75747075743a206f7074696d69736d4d696e7461626c654572633230466163746f727950726f7879206e6f7420736574","id":54549,"isConstant":false,"isLValue":false,"isPure":true,"kind":"string","lValueRequested":false,"nodeType":"Literal","src":"9104:65:100","typeDescriptions":{"typeIdentifier":"t_stringliteral_58c040fbde84bd4afd9f21f5ba3150dab029d767b65aafdf14512bdafdbd9954","typeString":"literal_string \"FetchChainInfoOutput: optimismMintableErc20FactoryProxy not set\""},"value":"FetchChainInfoOutput: optimismMintableErc20FactoryProxy not set"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_bool","typeString":"bool"},{"typeIdentifier":"t_stringliteral_58c040fbde84bd4afd9f21f5ba3150dab029d767b65aafdf14512bdafdbd9954","typeString":"literal_string \"FetchChainInfoOutput: optimismMintableErc20FactoryProxy not set\""}],"id":54542,"name":"require","nodeType":"Identifier","overloadedDeclarations":[-18,-18,-18],"referencedDeclaration":-18,"src":"9021:7:100","typeDescriptions":{"typeIdentifier":"t_function_require_pure$_t_bool_$_t_string_memory_ptr_$returns$__$","typeString":"function (bool,string memory) pure"}},"id":54550,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"9021:158:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":54551,"nodeType":"ExpressionStatement","src":"9021:158:100"},{"expression":{"id":54552,"name":"_optimismMintableErc20FactoryProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54061,"src":"9196:34:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"functionReturnParameters":54541,"id":54553,"nodeType":"Return","src":"9189:41:100"}]},"functionSelector":"8f20c7e4","implemented":true,"kind":"function","modifiers":[],"name":"optimismMintableErc20FactoryProxy","nameLocation":"8945:33:100","parameters":{"id":54538,"nodeType":"ParameterList","parameters":[],"src":"8978:2:100"},"returnParameters":{"id":54541,"nodeType":"ParameterList","parameters":[{"constant":false,"id":54540,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":54555,"src":"9002:7:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":54539,"name":"address","nodeType":"ElementaryTypeName","src":"9002:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"9001:9:100"},"scope":54911,"stateMutability":"view","virtual":false,"visibility":"public"},{"id":54573,"nodeType":"FunctionDefinition","src":"9243:211:100","nodes":[],"body":{"id":54572,"nodeType":"Block","src":"9304:150:100","nodes":[],"statements":[{"expression":{"arguments":[{"commonType":{"typeIdentifier":"t_address","typeString":"address"},"id":54566,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftExpression":{"id":54561,"name":"_optimismPortalProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54063,"src":"9322:20:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"BinaryOperation","operator":"!=","rightExpression":{"arguments":[{"hexValue":"30","id":54564,"isConstant":false,"isLValue":false,"isPure":true,"kind":"number","lValueRequested":false,"nodeType":"Literal","src":"9354:1:100","typeDescriptions":{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"},"value":"0"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"}],"id":54563,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"nodeType":"ElementaryTypeNameExpression","src":"9346:7:100","typeDescriptions":{"typeIdentifier":"t_type$_t_address_$","typeString":"type(address)"},"typeName":{"id":54562,"name":"address","nodeType":"ElementaryTypeName","src":"9346:7:100","typeDescriptions":{}}},"id":54565,"isConstant":false,"isLValue":false,"isPure":true,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"9346:10:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"src":"9322:34:100","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},{"hexValue":"4665746368436861696e496e666f4f75747075743a206f7074696d69736d506f7274616c50726f7879206e6f7420736574","id":54567,"isConstant":false,"isLValue":false,"isPure":true,"kind":"string","lValueRequested":false,"nodeType":"Literal","src":"9358:51:100","typeDescriptions":{"typeIdentifier":"t_stringliteral_ef003bab75ab0cfa4ca81f99eb20b37a3fded08fa7502df7d991f596c8680642","typeString":"literal_string \"FetchChainInfoOutput: optimismPortalProxy not set\""},"value":"FetchChainInfoOutput: optimismPortalProxy not set"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_bool","typeString":"bool"},{"typeIdentifier":"t_stringliteral_ef003bab75ab0cfa4ca81f99eb20b37a3fded08fa7502df7d991f596c8680642","typeString":"literal_string \"FetchChainInfoOutput: optimismPortalProxy not set\""}],"id":54560,"name":"require","nodeType":"Identifier","overloadedDeclarations":[-18,-18,-18],"referencedDeclaration":-18,"src":"9314:7:100","typeDescriptions":{"typeIdentifier":"t_function_require_pure$_t_bool_$_t_string_memory_ptr_$returns$__$","typeString":"function (bool,string memory) pure"}},"id":54568,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"9314:96:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":54569,"nodeType":"ExpressionStatement","src":"9314:96:100"},{"expression":{"id":54570,"name":"_optimismPortalProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54063,"src":"9427:20:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"functionReturnParameters":54559,"id":54571,"nodeType":"Return","src":"9420:27:100"}]},"functionSelector":"04451c49","implemented":true,"kind":"function","modifiers":[],"name":"optimismPortalProxy","nameLocation":"9252:19:100","parameters":{"id":54556,"nodeType":"ParameterList","parameters":[],"src":"9271:2:100"},"returnParameters":{"id":54559,"nodeType":"ParameterList","parameters":[{"constant":false,"id":54558,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":54573,"src":"9295:7:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":54557,"name":"address","nodeType":"ElementaryTypeName","src":"9295:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"9294:9:100"},"scope":54911,"stateMutability":"view","virtual":false,"visibility":"public"},{"id":54591,"nodeType":"FunctionDefinition","src":"9460:203:100","nodes":[],"body":{"id":54590,"nodeType":"Block","src":"9519:144:100","nodes":[],"statements":[{"expression":{"arguments":[{"commonType":{"typeIdentifier":"t_address","typeString":"address"},"id":54584,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftExpression":{"id":54579,"name":"_systemConfigProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54065,"src":"9537:18:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"BinaryOperation","operator":"!=","rightExpression":{"arguments":[{"hexValue":"30","id":54582,"isConstant":false,"isLValue":false,"isPure":true,"kind":"number","lValueRequested":false,"nodeType":"Literal","src":"9567:1:100","typeDescriptions":{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"},"value":"0"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"}],"id":54581,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"nodeType":"ElementaryTypeNameExpression","src":"9559:7:100","typeDescriptions":{"typeIdentifier":"t_type$_t_address_$","typeString":"type(address)"},"typeName":{"id":54580,"name":"address","nodeType":"ElementaryTypeName","src":"9559:7:100","typeDescriptions":{}}},"id":54583,"isConstant":false,"isLValue":false,"isPure":true,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"9559:10:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"src":"9537:32:100","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},{"hexValue":"4665746368436861696e496e666f4f75747075743a2073797374656d436f6e66696750726f7879206e6f7420736574","id":54585,"isConstant":false,"isLValue":false,"isPure":true,"kind":"string","lValueRequested":false,"nodeType":"Literal","src":"9571:49:100","typeDescriptions":{"typeIdentifier":"t_stringliteral_09ada010329fb4e012f4c857519ec176efea734f55c01f382f1b6c7bd752716b","typeString":"literal_string \"FetchChainInfoOutput: systemConfigProxy not set\""},"value":"FetchChainInfoOutput: systemConfigProxy not set"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_bool","typeString":"bool"},{"typeIdentifier":"t_stringliteral_09ada010329fb4e012f4c857519ec176efea734f55c01f382f1b6c7bd752716b","typeString":"literal_string \"FetchChainInfoOutput: systemConfigProxy not set\""}],"id":54578,"name":"require","nodeType":"Identifier","overloadedDeclarations":[-18,-18,-18],"referencedDeclaration":-18,"src":"9529:7:100","typeDescriptions":{"typeIdentifier":"t_function_require_pure$_t_bool_$_t_string_memory_ptr_$returns$__$","typeString":"function (bool,string memory) pure"}},"id":54586,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"9529:92:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":54587,"nodeType":"ExpressionStatement","src":"9529:92:100"},{"expression":{"id":54588,"name":"_systemConfigProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54065,"src":"9638:18:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"functionReturnParameters":54577,"id":54589,"nodeType":"Return","src":"9631:25:100"}]},"functionSelector":"c17db6e3","implemented":true,"kind":"function","modifiers":[],"name":"systemConfigProxy","nameLocation":"9469:17:100","parameters":{"id":54574,"nodeType":"ParameterList","parameters":[],"src":"9486:2:100"},"returnParameters":{"id":54577,"nodeType":"ParameterList","parameters":[{"constant":false,"id":54576,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":54591,"src":"9510:7:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":54575,"name":"address","nodeType":"ElementaryTypeName","src":"9510:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"9509:9:100"},"scope":54911,"stateMutability":"view","virtual":false,"visibility":"public"},{"id":54609,"nodeType":"FunctionDefinition","src":"9669:219:100","nodes":[],"body":{"id":54608,"nodeType":"Block","src":"9732:156:100","nodes":[],"statements":[{"expression":{"arguments":[{"commonType":{"typeIdentifier":"t_address","typeString":"address"},"id":54602,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftExpression":{"id":54597,"name":"_opChainProxyAdminImpl","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54067,"src":"9750:22:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"BinaryOperation","operator":"!=","rightExpression":{"arguments":[{"hexValue":"30","id":54600,"isConstant":false,"isLValue":false,"isPure":true,"kind":"number","lValueRequested":false,"nodeType":"Literal","src":"9784:1:100","typeDescriptions":{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"},"value":"0"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"}],"id":54599,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"nodeType":"ElementaryTypeNameExpression","src":"9776:7:100","typeDescriptions":{"typeIdentifier":"t_type$_t_address_$","typeString":"type(address)"},"typeName":{"id":54598,"name":"address","nodeType":"ElementaryTypeName","src":"9776:7:100","typeDescriptions":{}}},"id":54601,"isConstant":false,"isLValue":false,"isPure":true,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"9776:10:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"src":"9750:36:100","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},{"hexValue":"4665746368436861696e496e666f4f75747075743a206f70436861696e50726f787941646d696e496d706c206e6f7420736574","id":54603,"isConstant":false,"isLValue":false,"isPure":true,"kind":"string","lValueRequested":false,"nodeType":"Literal","src":"9788:53:100","typeDescriptions":{"typeIdentifier":"t_stringliteral_8ebc3647bde8a1129bfd827c7ef2e2d4fea82292bcad8a3c8e3918d70fed8ea8","typeString":"literal_string \"FetchChainInfoOutput: opChainProxyAdminImpl not set\""},"value":"FetchChainInfoOutput: opChainProxyAdminImpl not set"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_bool","typeString":"bool"},{"typeIdentifier":"t_stringliteral_8ebc3647bde8a1129bfd827c7ef2e2d4fea82292bcad8a3c8e3918d70fed8ea8","typeString":"literal_string \"FetchChainInfoOutput: opChainProxyAdminImpl not set\""}],"id":54596,"name":"require","nodeType":"Identifier","overloadedDeclarations":[-18,-18,-18],"referencedDeclaration":-18,"src":"9742:7:100","typeDescriptions":{"typeIdentifier":"t_function_require_pure$_t_bool_$_t_string_memory_ptr_$returns$__$","typeString":"function (bool,string memory) pure"}},"id":54604,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"9742:100:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":54605,"nodeType":"ExpressionStatement","src":"9742:100:100"},{"expression":{"id":54606,"name":"_opChainProxyAdminImpl","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54067,"src":"9859:22:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"functionReturnParameters":54595,"id":54607,"nodeType":"Return","src":"9852:29:100"}]},"functionSelector":"5643665f","implemented":true,"kind":"function","modifiers":[],"name":"opChainProxyAdminImpl","nameLocation":"9678:21:100","parameters":{"id":54592,"nodeType":"ParameterList","parameters":[],"src":"9699:2:100"},"returnParameters":{"id":54595,"nodeType":"ParameterList","parameters":[{"constant":false,"id":54594,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":54609,"src":"9723:7:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":54593,"name":"address","nodeType":"ElementaryTypeName","src":"9723:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"9722:9:100"},"scope":54911,"stateMutability":"view","virtual":false,"visibility":"public"},{"id":54627,"nodeType":"FunctionDefinition","src":"9894:219:100","nodes":[],"body":{"id":54626,"nodeType":"Block","src":"9957:156:100","nodes":[],"statements":[{"expression":{"arguments":[{"commonType":{"typeIdentifier":"t_address","typeString":"address"},"id":54620,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftExpression":{"id":54615,"name":"_superchainConfigProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54043,"src":"9975:22:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"BinaryOperation","operator":"!=","rightExpression":{"arguments":[{"hexValue":"30","id":54618,"isConstant":false,"isLValue":false,"isPure":true,"kind":"number","lValueRequested":false,"nodeType":"Literal","src":"10009:1:100","typeDescriptions":{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"},"value":"0"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"}],"id":54617,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"nodeType":"ElementaryTypeNameExpression","src":"10001:7:100","typeDescriptions":{"typeIdentifier":"t_type$_t_address_$","typeString":"type(address)"},"typeName":{"id":54616,"name":"address","nodeType":"ElementaryTypeName","src":"10001:7:100","typeDescriptions":{}}},"id":54619,"isConstant":false,"isLValue":false,"isPure":true,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"10001:10:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"src":"9975:36:100","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},{"hexValue":"4665746368436861696e496e666f4f75747075743a207375706572636861696e436f6e66696750726f7879206e6f7420736574","id":54621,"isConstant":false,"isLValue":false,"isPure":true,"kind":"string","lValueRequested":false,"nodeType":"Literal","src":"10013:53:100","typeDescriptions":{"typeIdentifier":"t_stringliteral_1b8ad3d2e627aa065fd0fee387bc2d1e5e640177323f7f86733cd157b788a1ce","typeString":"literal_string \"FetchChainInfoOutput: superchainConfigProxy not set\""},"value":"FetchChainInfoOutput: superchainConfigProxy not set"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_bool","typeString":"bool"},{"typeIdentifier":"t_stringliteral_1b8ad3d2e627aa065fd0fee387bc2d1e5e640177323f7f86733cd157b788a1ce","typeString":"literal_string \"FetchChainInfoOutput: superchainConfigProxy not set\""}],"id":54614,"name":"require","nodeType":"Identifier","overloadedDeclarations":[-18,-18,-18],"referencedDeclaration":-18,"src":"9967:7:100","typeDescriptions":{"typeIdentifier":"t_function_require_pure$_t_bool_$_t_string_memory_ptr_$returns$__$","typeString":"function (bool,string memory) pure"}},"id":54622,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"9967:100:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":54623,"nodeType":"ExpressionStatement","src":"9967:100:100"},{"expression":{"id":54624,"name":"_superchainConfigProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54043,"src":"10084:22:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"functionReturnParameters":54613,"id":54625,"nodeType":"Return","src":"10077:29:100"}]},"functionSelector":"84cf2c97","implemented":true,"kind":"function","modifiers":[],"name":"superchainConfigProxy","nameLocation":"9903:21:100","parameters":{"id":54610,"nodeType":"ParameterList","parameters":[],"src":"9924:2:100"},"returnParameters":{"id":54613,"nodeType":"ParameterList","parameters":[{"constant":false,"id":54612,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":54627,"src":"9948:7:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":54611,"name":"address","nodeType":"ElementaryTypeName","src":"9948:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"9947:9:100"},"scope":54911,"stateMutability":"view","virtual":false,"visibility":"public"},{"id":54645,"nodeType":"FunctionDefinition","src":"10119:231:100","nodes":[],"body":{"id":54644,"nodeType":"Block","src":"10185:165:100","nodes":[],"statements":[{"expression":{"arguments":[{"commonType":{"typeIdentifier":"t_address","typeString":"address"},"id":54638,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftExpression":{"id":54633,"name":"_anchorStateRegistryProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54069,"src":"10203:25:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"BinaryOperation","operator":"!=","rightExpression":{"arguments":[{"hexValue":"30","id":54636,"isConstant":false,"isLValue":false,"isPure":true,"kind":"number","lValueRequested":false,"nodeType":"Literal","src":"10240:1:100","typeDescriptions":{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"},"value":"0"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"}],"id":54635,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"nodeType":"ElementaryTypeNameExpression","src":"10232:7:100","typeDescriptions":{"typeIdentifier":"t_type$_t_address_$","typeString":"type(address)"},"typeName":{"id":54634,"name":"address","nodeType":"ElementaryTypeName","src":"10232:7:100","typeDescriptions":{}}},"id":54637,"isConstant":false,"isLValue":false,"isPure":true,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"10232:10:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"src":"10203:39:100","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},{"hexValue":"4665746368436861696e496e666f4f75747075743a20616e63686f725374617465526567697374727950726f7879206e6f7420736574","id":54639,"isConstant":false,"isLValue":false,"isPure":true,"kind":"string","lValueRequested":false,"nodeType":"Literal","src":"10244:56:100","typeDescriptions":{"typeIdentifier":"t_stringliteral_6391076785d7152b9570ce8338ca2e43a749144cb3dbb7f9e5e1de5fabfbae48","typeString":"literal_string \"FetchChainInfoOutput: anchorStateRegistryProxy not set\""},"value":"FetchChainInfoOutput: anchorStateRegistryProxy not set"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_bool","typeString":"bool"},{"typeIdentifier":"t_stringliteral_6391076785d7152b9570ce8338ca2e43a749144cb3dbb7f9e5e1de5fabfbae48","typeString":"literal_string \"FetchChainInfoOutput: anchorStateRegistryProxy not set\""}],"id":54632,"name":"require","nodeType":"Identifier","overloadedDeclarations":[-18,-18,-18],"referencedDeclaration":-18,"src":"10195:7:100","typeDescriptions":{"typeIdentifier":"t_function_require_pure$_t_bool_$_t_string_memory_ptr_$returns$__$","typeString":"function (bool,string memory) pure"}},"id":54640,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"10195:106:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":54641,"nodeType":"ExpressionStatement","src":"10195:106:100"},{"expression":{"id":54642,"name":"_anchorStateRegistryProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54069,"src":"10318:25:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"functionReturnParameters":54631,"id":54643,"nodeType":"Return","src":"10311:32:100"}]},"functionSelector":"35596f76","implemented":true,"kind":"function","modifiers":[],"name":"anchorStateRegistryProxy","nameLocation":"10128:24:100","parameters":{"id":54628,"nodeType":"ParameterList","parameters":[],"src":"10152:2:100"},"returnParameters":{"id":54631,"nodeType":"ParameterList","parameters":[{"constant":false,"id":54630,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":54645,"src":"10176:7:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":54629,"name":"address","nodeType":"ElementaryTypeName","src":"10176:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"10175:9:100"},"scope":54911,"stateMutability":"view","virtual":false,"visibility":"public"},{"id":54653,"nodeType":"FunctionDefinition","src":"10356:131:100","nodes":[],"body":{"id":54652,"nodeType":"Block","src":"10430:57:100","nodes":[],"statements":[{"expression":{"id":54650,"name":"_delayedWethPermissionedGameProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54071,"src":"10447:33:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"functionReturnParameters":54649,"id":54651,"nodeType":"Return","src":"10440:40:100"}]},"functionSelector":"794836d7","implemented":true,"kind":"function","modifiers":[],"name":"delayedWethPermissionedGameProxy","nameLocation":"10365:32:100","parameters":{"id":54646,"nodeType":"ParameterList","parameters":[],"src":"10397:2:100"},"returnParameters":{"id":54649,"nodeType":"ParameterList","parameters":[{"constant":false,"id":54648,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":54653,"src":"10421:7:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":54647,"name":"address","nodeType":"ElementaryTypeName","src":"10421:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"10420:9:100"},"scope":54911,"stateMutability":"view","virtual":false,"visibility":"public"},{"id":54661,"nodeType":"FunctionDefinition","src":"10493:135:100","nodes":[],"body":{"id":54660,"nodeType":"Block","src":"10569:59:100","nodes":[],"statements":[{"expression":{"id":54658,"name":"_delayedWethPermissionlessGameProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54073,"src":"10586:35:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"functionReturnParameters":54657,"id":54659,"nodeType":"Return","src":"10579:42:100"}]},"functionSelector":"97068797","implemented":true,"kind":"function","modifiers":[],"name":"delayedWethPermissionlessGameProxy","nameLocation":"10502:34:100","parameters":{"id":54654,"nodeType":"ParameterList","parameters":[],"src":"10536:2:100"},"returnParameters":{"id":54657,"nodeType":"ParameterList","parameters":[{"constant":false,"id":54656,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":54661,"src":"10560:7:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":54655,"name":"address","nodeType":"ElementaryTypeName","src":"10560:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"10559:9:100"},"scope":54911,"stateMutability":"view","virtual":false,"visibility":"public"},{"id":54669,"nodeType":"FunctionDefinition","src":"10634:113:100","nodes":[],"body":{"id":54668,"nodeType":"Block","src":"10699:48:100","nodes":[],"statements":[{"expression":{"id":54666,"name":"_disputeGameFactoryProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54075,"src":"10716:24:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"functionReturnParameters":54665,"id":54667,"nodeType":"Return","src":"10709:31:100"}]},"functionSelector":"6c4568d1","implemented":true,"kind":"function","modifiers":[],"name":"disputeGameFactoryProxy","nameLocation":"10643:23:100","parameters":{"id":54662,"nodeType":"ParameterList","parameters":[],"src":"10666:2:100"},"returnParameters":{"id":54665,"nodeType":"ParameterList","parameters":[{"constant":false,"id":54664,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":54669,"src":"10690:7:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":54663,"name":"address","nodeType":"ElementaryTypeName","src":"10690:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"10689:9:100"},"scope":54911,"stateMutability":"view","virtual":false,"visibility":"public"},{"id":54687,"nodeType":"FunctionDefinition","src":"10753:215:100","nodes":[],"body":{"id":54686,"nodeType":"Block","src":"10815:153:100","nodes":[],"statements":[{"expression":{"arguments":[{"commonType":{"typeIdentifier":"t_address","typeString":"address"},"id":54680,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftExpression":{"id":54675,"name":"_faultDisputeGameImpl","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54077,"src":"10833:21:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"BinaryOperation","operator":"!=","rightExpression":{"arguments":[{"hexValue":"30","id":54678,"isConstant":false,"isLValue":false,"isPure":true,"kind":"number","lValueRequested":false,"nodeType":"Literal","src":"10866:1:100","typeDescriptions":{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"},"value":"0"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"}],"id":54677,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"nodeType":"ElementaryTypeNameExpression","src":"10858:7:100","typeDescriptions":{"typeIdentifier":"t_type$_t_address_$","typeString":"type(address)"},"typeName":{"id":54676,"name":"address","nodeType":"ElementaryTypeName","src":"10858:7:100","typeDescriptions":{}}},"id":54679,"isConstant":false,"isLValue":false,"isPure":true,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"10858:10:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"src":"10833:35:100","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},{"hexValue":"4665746368436861696e496e666f4f75747075743a206661756c744469737075746547616d65496d706c206e6f7420736574","id":54681,"isConstant":false,"isLValue":false,"isPure":true,"kind":"string","lValueRequested":false,"nodeType":"Literal","src":"10870:52:100","typeDescriptions":{"typeIdentifier":"t_stringliteral_baae18cd0fbc1fbf3c566f5918a7a4a780bb1a3d403d2b65d908417b87c06457","typeString":"literal_string \"FetchChainInfoOutput: faultDisputeGameImpl not set\""},"value":"FetchChainInfoOutput: faultDisputeGameImpl not set"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_bool","typeString":"bool"},{"typeIdentifier":"t_stringliteral_baae18cd0fbc1fbf3c566f5918a7a4a780bb1a3d403d2b65d908417b87c06457","typeString":"literal_string \"FetchChainInfoOutput: faultDisputeGameImpl not set\""}],"id":54674,"name":"require","nodeType":"Identifier","overloadedDeclarations":[-18,-18,-18],"referencedDeclaration":-18,"src":"10825:7:100","typeDescriptions":{"typeIdentifier":"t_function_require_pure$_t_bool_$_t_string_memory_ptr_$returns$__$","typeString":"function (bool,string memory) pure"}},"id":54682,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"10825:98:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":54683,"nodeType":"ExpressionStatement","src":"10825:98:100"},{"expression":{"id":54684,"name":"_faultDisputeGameImpl","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54077,"src":"10940:21:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"functionReturnParameters":54673,"id":54685,"nodeType":"Return","src":"10933:28:100"}]},"functionSelector":"dea21984","implemented":true,"kind":"function","modifiers":[],"name":"faultDisputeGameImpl","nameLocation":"10762:20:100","parameters":{"id":54670,"nodeType":"ParameterList","parameters":[],"src":"10782:2:100"},"returnParameters":{"id":54673,"nodeType":"ParameterList","parameters":[{"constant":false,"id":54672,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":54687,"src":"10806:7:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":54671,"name":"address","nodeType":"ElementaryTypeName","src":"10806:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"10805:9:100"},"scope":54911,"stateMutability":"view","virtual":false,"visibility":"public"},{"id":54705,"nodeType":"FunctionDefinition","src":"10974:289:100","nodes":[],"body":{"id":54704,"nodeType":"Block","src":"11046:217:100","nodes":[],"statements":[{"expression":{"arguments":[{"commonType":{"typeIdentifier":"t_address","typeString":"address"},"id":54698,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftExpression":{"id":54693,"name":"_faultDisputeGameCannonKonaImpl","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54079,"src":"11077:31:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"BinaryOperation","operator":"!=","rightExpression":{"arguments":[{"hexValue":"30","id":54696,"isConstant":false,"isLValue":false,"isPure":true,"kind":"number","lValueRequested":false,"nodeType":"Literal","src":"11120:1:100","typeDescriptions":{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"},"value":"0"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"}],"id":54695,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"nodeType":"ElementaryTypeNameExpression","src":"11112:7:100","typeDescriptions":{"typeIdentifier":"t_type$_t_address_$","typeString":"type(address)"},"typeName":{"id":54694,"name":"address","nodeType":"ElementaryTypeName","src":"11112:7:100","typeDescriptions":{}}},"id":54697,"isConstant":false,"isLValue":false,"isPure":true,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"11112:10:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"src":"11077:45:100","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},{"hexValue":"4665746368436861696e496e666f4f75747075743a206661756c744469737075746547616d6543616e6e6f6e4b6f6e61496d706c206e6f7420736574","id":54699,"isConstant":false,"isLValue":false,"isPure":true,"kind":"string","lValueRequested":false,"nodeType":"Literal","src":"11136:62:100","typeDescriptions":{"typeIdentifier":"t_stringliteral_1a6322899b29428b71a9f44d1d2e4f85d48c09a65bfacd98b10709bf7aff2087","typeString":"literal_string \"FetchChainInfoOutput: faultDisputeGameCannonKonaImpl not set\""},"value":"FetchChainInfoOutput: faultDisputeGameCannonKonaImpl not set"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_bool","typeString":"bool"},{"typeIdentifier":"t_stringliteral_1a6322899b29428b71a9f44d1d2e4f85d48c09a65bfacd98b10709bf7aff2087","typeString":"literal_string \"FetchChainInfoOutput: faultDisputeGameCannonKonaImpl not set\""}],"id":54692,"name":"require","nodeType":"Identifier","overloadedDeclarations":[-18,-18,-18],"referencedDeclaration":-18,"src":"11056:7:100","typeDescriptions":{"typeIdentifier":"t_function_require_pure$_t_bool_$_t_string_memory_ptr_$returns$__$","typeString":"function (bool,string memory) pure"}},"id":54700,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"11056:152:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":54701,"nodeType":"ExpressionStatement","src":"11056:152:100"},{"expression":{"id":54702,"name":"_faultDisputeGameCannonKonaImpl","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54079,"src":"11225:31:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"functionReturnParameters":54691,"id":54703,"nodeType":"Return","src":"11218:38:100"}]},"functionSelector":"5d25b21d","implemented":true,"kind":"function","modifiers":[],"name":"faultDisputeGameCannonKonaImpl","nameLocation":"10983:30:100","parameters":{"id":54688,"nodeType":"ParameterList","parameters":[],"src":"11013:2:100"},"returnParameters":{"id":54691,"nodeType":"ParameterList","parameters":[{"constant":false,"id":54690,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":54705,"src":"11037:7:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":54689,"name":"address","nodeType":"ElementaryTypeName","src":"11037:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"11036:9:100"},"scope":54911,"stateMutability":"view","virtual":false,"visibility":"public"},{"id":54723,"nodeType":"FunctionDefinition","src":"11269:167:100","nodes":[],"body":{"id":54722,"nodeType":"Block","src":"11319:117:100","nodes":[],"statements":[{"expression":{"arguments":[{"commonType":{"typeIdentifier":"t_address","typeString":"address"},"id":54716,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftExpression":{"id":54711,"name":"_mipsImpl","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54045,"src":"11337:9:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"BinaryOperation","operator":"!=","rightExpression":{"arguments":[{"hexValue":"30","id":54714,"isConstant":false,"isLValue":false,"isPure":true,"kind":"number","lValueRequested":false,"nodeType":"Literal","src":"11358:1:100","typeDescriptions":{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"},"value":"0"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"}],"id":54713,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"nodeType":"ElementaryTypeNameExpression","src":"11350:7:100","typeDescriptions":{"typeIdentifier":"t_type$_t_address_$","typeString":"type(address)"},"typeName":{"id":54712,"name":"address","nodeType":"ElementaryTypeName","src":"11350:7:100","typeDescriptions":{}}},"id":54715,"isConstant":false,"isLValue":false,"isPure":true,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"11350:10:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"src":"11337:23:100","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},{"hexValue":"4665746368436861696e496e666f4f75747075743a206d697073496d706c206e6f7420736574","id":54717,"isConstant":false,"isLValue":false,"isPure":true,"kind":"string","lValueRequested":false,"nodeType":"Literal","src":"11362:40:100","typeDescriptions":{"typeIdentifier":"t_stringliteral_178867f585ae7eaee2b47a35fdf118ac2b037c387c5937f3b39b1c51f05d7497","typeString":"literal_string \"FetchChainInfoOutput: mipsImpl not set\""},"value":"FetchChainInfoOutput: mipsImpl not set"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_bool","typeString":"bool"},{"typeIdentifier":"t_stringliteral_178867f585ae7eaee2b47a35fdf118ac2b037c387c5937f3b39b1c51f05d7497","typeString":"literal_string \"FetchChainInfoOutput: mipsImpl not set\""}],"id":54710,"name":"require","nodeType":"Identifier","overloadedDeclarations":[-18,-18,-18],"referencedDeclaration":-18,"src":"11329:7:100","typeDescriptions":{"typeIdentifier":"t_function_require_pure$_t_bool_$_t_string_memory_ptr_$returns$__$","typeString":"function (bool,string memory) pure"}},"id":54718,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"11329:74:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":54719,"nodeType":"ExpressionStatement","src":"11329:74:100"},{"expression":{"id":54720,"name":"_mipsImpl","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54045,"src":"11420:9:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"functionReturnParameters":54709,"id":54721,"nodeType":"Return","src":"11413:16:100"}]},"functionSelector":"e303272c","implemented":true,"kind":"function","modifiers":[],"name":"mipsImpl","nameLocation":"11278:8:100","parameters":{"id":54706,"nodeType":"ParameterList","parameters":[],"src":"11286:2:100"},"returnParameters":{"id":54709,"nodeType":"ParameterList","parameters":[{"constant":false,"id":54708,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":54723,"src":"11310:7:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":54707,"name":"address","nodeType":"ElementaryTypeName","src":"11310:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"11309:9:100"},"scope":54911,"stateMutability":"view","virtual":false,"visibility":"public"},{"id":54741,"nodeType":"FunctionDefinition","src":"11442:243:100","nodes":[],"body":{"id":54740,"nodeType":"Block","src":"11511:174:100","nodes":[],"statements":[{"expression":{"arguments":[{"commonType":{"typeIdentifier":"t_address","typeString":"address"},"id":54734,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftExpression":{"id":54729,"name":"_permissionedDisputeGameImpl","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54081,"src":"11529:28:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"BinaryOperation","operator":"!=","rightExpression":{"arguments":[{"hexValue":"30","id":54732,"isConstant":false,"isLValue":false,"isPure":true,"kind":"number","lValueRequested":false,"nodeType":"Literal","src":"11569:1:100","typeDescriptions":{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"},"value":"0"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"}],"id":54731,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"nodeType":"ElementaryTypeNameExpression","src":"11561:7:100","typeDescriptions":{"typeIdentifier":"t_type$_t_address_$","typeString":"type(address)"},"typeName":{"id":54730,"name":"address","nodeType":"ElementaryTypeName","src":"11561:7:100","typeDescriptions":{}}},"id":54733,"isConstant":false,"isLValue":false,"isPure":true,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"11561:10:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"src":"11529:42:100","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},{"hexValue":"4665746368436861696e496e666f4f75747075743a207065726d697373696f6e65644469737075746547616d65496d706c206e6f7420736574","id":54735,"isConstant":false,"isLValue":false,"isPure":true,"kind":"string","lValueRequested":false,"nodeType":"Literal","src":"11573:59:100","typeDescriptions":{"typeIdentifier":"t_stringliteral_234858b97aab3865b03b564f238f9977c62296b1532cb4f809e12678629cae92","typeString":"literal_string \"FetchChainInfoOutput: permissionedDisputeGameImpl not set\""},"value":"FetchChainInfoOutput: permissionedDisputeGameImpl not set"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_bool","typeString":"bool"},{"typeIdentifier":"t_stringliteral_234858b97aab3865b03b564f238f9977c62296b1532cb4f809e12678629cae92","typeString":"literal_string \"FetchChainInfoOutput: permissionedDisputeGameImpl not set\""}],"id":54728,"name":"require","nodeType":"Identifier","overloadedDeclarations":[-18,-18,-18],"referencedDeclaration":-18,"src":"11521:7:100","typeDescriptions":{"typeIdentifier":"t_function_require_pure$_t_bool_$_t_string_memory_ptr_$returns$__$","typeString":"function (bool,string memory) pure"}},"id":54736,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"11521:112:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":54737,"nodeType":"ExpressionStatement","src":"11521:112:100"},{"expression":{"id":54738,"name":"_permissionedDisputeGameImpl","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54081,"src":"11650:28:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"functionReturnParameters":54727,"id":54739,"nodeType":"Return","src":"11643:35:100"}]},"functionSelector":"98ccec3e","implemented":true,"kind":"function","modifiers":[],"name":"permissionedDisputeGameImpl","nameLocation":"11451:27:100","parameters":{"id":54724,"nodeType":"ParameterList","parameters":[],"src":"11478:2:100"},"returnParameters":{"id":54727,"nodeType":"ParameterList","parameters":[{"constant":false,"id":54726,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":54741,"src":"11502:7:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":54725,"name":"address","nodeType":"ElementaryTypeName","src":"11502:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"11501:9:100"},"scope":54911,"stateMutability":"view","virtual":false,"visibility":"public"},{"id":54759,"nodeType":"FunctionDefinition","src":"11691:207:100","nodes":[],"body":{"id":54758,"nodeType":"Block","src":"11751:147:100","nodes":[],"statements":[{"expression":{"arguments":[{"commonType":{"typeIdentifier":"t_address","typeString":"address"},"id":54752,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftExpression":{"id":54747,"name":"_preimageOracleImpl","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54047,"src":"11769:19:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"BinaryOperation","operator":"!=","rightExpression":{"arguments":[{"hexValue":"30","id":54750,"isConstant":false,"isLValue":false,"isPure":true,"kind":"number","lValueRequested":false,"nodeType":"Literal","src":"11800:1:100","typeDescriptions":{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"},"value":"0"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"}],"id":54749,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"nodeType":"ElementaryTypeNameExpression","src":"11792:7:100","typeDescriptions":{"typeIdentifier":"t_type$_t_address_$","typeString":"type(address)"},"typeName":{"id":54748,"name":"address","nodeType":"ElementaryTypeName","src":"11792:7:100","typeDescriptions":{}}},"id":54751,"isConstant":false,"isLValue":false,"isPure":true,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"11792:10:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"src":"11769:33:100","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},{"hexValue":"4665746368436861696e496e666f4f75747075743a20707265696d6167654f7261636c65496d706c206e6f7420736574","id":54753,"isConstant":false,"isLValue":false,"isPure":true,"kind":"string","lValueRequested":false,"nodeType":"Literal","src":"11804:50:100","typeDescriptions":{"typeIdentifier":"t_stringliteral_2434e23032e7627ba1a13e989a9fbe735952d0d6f49e2760e1b1064b8728d538","typeString":"literal_string \"FetchChainInfoOutput: preimageOracleImpl not set\""},"value":"FetchChainInfoOutput: preimageOracleImpl not set"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_bool","typeString":"bool"},{"typeIdentifier":"t_stringliteral_2434e23032e7627ba1a13e989a9fbe735952d0d6f49e2760e1b1064b8728d538","typeString":"literal_string \"FetchChainInfoOutput: preimageOracleImpl not set\""}],"id":54746,"name":"require","nodeType":"Identifier","overloadedDeclarations":[-18,-18,-18],"referencedDeclaration":-18,"src":"11761:7:100","typeDescriptions":{"typeIdentifier":"t_function_require_pure$_t_bool_$_t_string_memory_ptr_$returns$__$","typeString":"function (bool,string memory) pure"}},"id":54754,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"11761:94:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":54755,"nodeType":"ExpressionStatement","src":"11761:94:100"},{"expression":{"id":54756,"name":"_preimageOracleImpl","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54047,"src":"11872:19:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"functionReturnParameters":54745,"id":54757,"nodeType":"Return","src":"11865:26:100"}]},"functionSelector":"d030d2e8","implemented":true,"kind":"function","modifiers":[],"name":"preimageOracleImpl","nameLocation":"11700:18:100","parameters":{"id":54742,"nodeType":"ParameterList","parameters":[],"src":"11718:2:100"},"returnParameters":{"id":54745,"nodeType":"ParameterList","parameters":[{"constant":false,"id":54744,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":54759,"src":"11742:7:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":54743,"name":"address","nodeType":"ElementaryTypeName","src":"11742:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"11741:9:100"},"scope":54911,"stateMutability":"view","virtual":false,"visibility":"public"},{"id":54777,"nodeType":"FunctionDefinition","src":"11904:203:100","nodes":[],"body":{"id":54776,"nodeType":"Block","src":"11963:144:100","nodes":[],"statements":[{"expression":{"arguments":[{"commonType":{"typeIdentifier":"t_address","typeString":"address"},"id":54770,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftExpression":{"id":54765,"name":"_systemConfigOwner","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54083,"src":"11981:18:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"BinaryOperation","operator":"!=","rightExpression":{"arguments":[{"hexValue":"30","id":54768,"isConstant":false,"isLValue":false,"isPure":true,"kind":"number","lValueRequested":false,"nodeType":"Literal","src":"12011:1:100","typeDescriptions":{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"},"value":"0"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"}],"id":54767,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"nodeType":"ElementaryTypeNameExpression","src":"12003:7:100","typeDescriptions":{"typeIdentifier":"t_type$_t_address_$","typeString":"type(address)"},"typeName":{"id":54766,"name":"address","nodeType":"ElementaryTypeName","src":"12003:7:100","typeDescriptions":{}}},"id":54769,"isConstant":false,"isLValue":false,"isPure":true,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"12003:10:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"src":"11981:32:100","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},{"hexValue":"4665746368436861696e496e666f4f75747075743a2073797374656d436f6e6669674f776e6572206e6f7420736574","id":54771,"isConstant":false,"isLValue":false,"isPure":true,"kind":"string","lValueRequested":false,"nodeType":"Literal","src":"12015:49:100","typeDescriptions":{"typeIdentifier":"t_stringliteral_fc7a67f4775c5e19ca3731b64db9f9f8895dcd37a01bc895f1d1806a7f21c916","typeString":"literal_string \"FetchChainInfoOutput: systemConfigOwner not set\""},"value":"FetchChainInfoOutput: systemConfigOwner not set"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_bool","typeString":"bool"},{"typeIdentifier":"t_stringliteral_fc7a67f4775c5e19ca3731b64db9f9f8895dcd37a01bc895f1d1806a7f21c916","typeString":"literal_string \"FetchChainInfoOutput: systemConfigOwner not set\""}],"id":54764,"name":"require","nodeType":"Identifier","overloadedDeclarations":[-18,-18,-18],"referencedDeclaration":-18,"src":"11973:7:100","typeDescriptions":{"typeIdentifier":"t_function_require_pure$_t_bool_$_t_string_memory_ptr_$returns$__$","typeString":"function (bool,string memory) pure"}},"id":54772,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"11973:92:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":54773,"nodeType":"ExpressionStatement","src":"11973:92:100"},{"expression":{"id":54774,"name":"_systemConfigOwner","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54083,"src":"12082:18:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"functionReturnParameters":54763,"id":54775,"nodeType":"Return","src":"12075:25:100"}]},"functionSelector":"1e229b20","implemented":true,"kind":"function","modifiers":[],"name":"systemConfigOwner","nameLocation":"11913:17:100","parameters":{"id":54760,"nodeType":"ParameterList","parameters":[],"src":"11930:2:100"},"returnParameters":{"id":54763,"nodeType":"ParameterList","parameters":[{"constant":false,"id":54762,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":54777,"src":"11954:7:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":54761,"name":"address","nodeType":"ElementaryTypeName","src":"11954:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"11953:9:100"},"scope":54911,"stateMutability":"view","virtual":false,"visibility":"public"},{"id":54795,"nodeType":"FunctionDefinition","src":"12113:223:100","nodes":[],"body":{"id":54794,"nodeType":"Block","src":"12177:159:100","nodes":[],"statements":[{"expression":{"arguments":[{"commonType":{"typeIdentifier":"t_address","typeString":"address"},"id":54788,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftExpression":{"id":54783,"name":"_opChainProxyAdminOwner","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54085,"src":"12195:23:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"BinaryOperation","operator":"!=","rightExpression":{"arguments":[{"hexValue":"30","id":54786,"isConstant":false,"isLValue":false,"isPure":true,"kind":"number","lValueRequested":false,"nodeType":"Literal","src":"12230:1:100","typeDescriptions":{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"},"value":"0"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"}],"id":54785,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"nodeType":"ElementaryTypeNameExpression","src":"12222:7:100","typeDescriptions":{"typeIdentifier":"t_type$_t_address_$","typeString":"type(address)"},"typeName":{"id":54784,"name":"address","nodeType":"ElementaryTypeName","src":"12222:7:100","typeDescriptions":{}}},"id":54787,"isConstant":false,"isLValue":false,"isPure":true,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"12222:10:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"src":"12195:37:100","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},{"hexValue":"4665746368436861696e496e666f4f75747075743a206f70436861696e50726f787941646d696e4f776e6572206e6f7420736574","id":54789,"isConstant":false,"isLValue":false,"isPure":true,"kind":"string","lValueRequested":false,"nodeType":"Literal","src":"12234:54:100","typeDescriptions":{"typeIdentifier":"t_stringliteral_cc12cbf05d2d853ebebe6e25c8b02d2f78d6af131087a61088362ca7d0befc81","typeString":"literal_string \"FetchChainInfoOutput: opChainProxyAdminOwner not set\""},"value":"FetchChainInfoOutput: opChainProxyAdminOwner not set"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_bool","typeString":"bool"},{"typeIdentifier":"t_stringliteral_cc12cbf05d2d853ebebe6e25c8b02d2f78d6af131087a61088362ca7d0befc81","typeString":"literal_string \"FetchChainInfoOutput: opChainProxyAdminOwner not set\""}],"id":54782,"name":"require","nodeType":"Identifier","overloadedDeclarations":[-18,-18,-18],"referencedDeclaration":-18,"src":"12187:7:100","typeDescriptions":{"typeIdentifier":"t_function_require_pure$_t_bool_$_t_string_memory_ptr_$returns$__$","typeString":"function (bool,string memory) pure"}},"id":54790,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"12187:102:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":54791,"nodeType":"ExpressionStatement","src":"12187:102:100"},{"expression":{"id":54792,"name":"_opChainProxyAdminOwner","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54085,"src":"12306:23:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"functionReturnParameters":54781,"id":54793,"nodeType":"Return","src":"12299:30:100"}]},"functionSelector":"1480f0cc","implemented":true,"kind":"function","modifiers":[],"name":"opChainProxyAdminOwner","nameLocation":"12122:22:100","parameters":{"id":54778,"nodeType":"ParameterList","parameters":[],"src":"12144:2:100"},"returnParameters":{"id":54781,"nodeType":"ParameterList","parameters":[{"constant":false,"id":54780,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":54795,"src":"12168:7:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":54779,"name":"address","nodeType":"ElementaryTypeName","src":"12168:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"12167:9:100"},"scope":54911,"stateMutability":"view","virtual":false,"visibility":"public"},{"id":54813,"nodeType":"FunctionDefinition","src":"12342:195:100","nodes":[],"body":{"id":54812,"nodeType":"Block","src":"12399:138:100","nodes":[],"statements":[{"expression":{"arguments":[{"commonType":{"typeIdentifier":"t_address","typeString":"address"},"id":54806,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftExpression":{"id":54801,"name":"_opChainGuardian","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54087,"src":"12417:16:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"BinaryOperation","operator":"!=","rightExpression":{"arguments":[{"hexValue":"30","id":54804,"isConstant":false,"isLValue":false,"isPure":true,"kind":"number","lValueRequested":false,"nodeType":"Literal","src":"12445:1:100","typeDescriptions":{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"},"value":"0"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"}],"id":54803,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"nodeType":"ElementaryTypeNameExpression","src":"12437:7:100","typeDescriptions":{"typeIdentifier":"t_type$_t_address_$","typeString":"type(address)"},"typeName":{"id":54802,"name":"address","nodeType":"ElementaryTypeName","src":"12437:7:100","typeDescriptions":{}}},"id":54805,"isConstant":false,"isLValue":false,"isPure":true,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"12437:10:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"src":"12417:30:100","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},{"hexValue":"4665746368436861696e496e666f4f75747075743a206f70436861696e477561726469616e206e6f7420736574","id":54807,"isConstant":false,"isLValue":false,"isPure":true,"kind":"string","lValueRequested":false,"nodeType":"Literal","src":"12449:47:100","typeDescriptions":{"typeIdentifier":"t_stringliteral_ab71487628da5c56ff40f228ee915a62d6c0a28ab899f48f84343df6dbc48bb7","typeString":"literal_string \"FetchChainInfoOutput: opChainGuardian not set\""},"value":"FetchChainInfoOutput: opChainGuardian not set"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_bool","typeString":"bool"},{"typeIdentifier":"t_stringliteral_ab71487628da5c56ff40f228ee915a62d6c0a28ab899f48f84343df6dbc48bb7","typeString":"literal_string \"FetchChainInfoOutput: opChainGuardian not set\""}],"id":54800,"name":"require","nodeType":"Identifier","overloadedDeclarations":[-18,-18,-18],"referencedDeclaration":-18,"src":"12409:7:100","typeDescriptions":{"typeIdentifier":"t_function_require_pure$_t_bool_$_t_string_memory_ptr_$returns$__$","typeString":"function (bool,string memory) pure"}},"id":54808,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"12409:88:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":54809,"nodeType":"ExpressionStatement","src":"12409:88:100"},{"expression":{"id":54810,"name":"_opChainGuardian","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54087,"src":"12514:16:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"functionReturnParameters":54799,"id":54811,"nodeType":"Return","src":"12507:23:100"}]},"functionSelector":"4bc2695f","implemented":true,"kind":"function","modifiers":[],"name":"opChainGuardian","nameLocation":"12351:15:100","parameters":{"id":54796,"nodeType":"ParameterList","parameters":[],"src":"12366:2:100"},"returnParameters":{"id":54799,"nodeType":"ParameterList","parameters":[{"constant":false,"id":54798,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":54813,"src":"12390:7:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":54797,"name":"address","nodeType":"ElementaryTypeName","src":"12390:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"12389:9:100"},"scope":54911,"stateMutability":"view","virtual":false,"visibility":"public"},{"id":54831,"nodeType":"FunctionDefinition","src":"12543:175:100","nodes":[],"body":{"id":54830,"nodeType":"Block","src":"12595:123:100","nodes":[],"statements":[{"expression":{"arguments":[{"commonType":{"typeIdentifier":"t_address","typeString":"address"},"id":54824,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftExpression":{"id":54819,"name":"_challenger","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54089,"src":"12613:11:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"BinaryOperation","operator":"!=","rightExpression":{"arguments":[{"hexValue":"30","id":54822,"isConstant":false,"isLValue":false,"isPure":true,"kind":"number","lValueRequested":false,"nodeType":"Literal","src":"12636:1:100","typeDescriptions":{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"},"value":"0"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"}],"id":54821,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"nodeType":"ElementaryTypeNameExpression","src":"12628:7:100","typeDescriptions":{"typeIdentifier":"t_type$_t_address_$","typeString":"type(address)"},"typeName":{"id":54820,"name":"address","nodeType":"ElementaryTypeName","src":"12628:7:100","typeDescriptions":{}}},"id":54823,"isConstant":false,"isLValue":false,"isPure":true,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"12628:10:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"src":"12613:25:100","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},{"hexValue":"4665746368436861696e496e666f4f75747075743a206368616c6c656e676572206e6f7420736574","id":54825,"isConstant":false,"isLValue":false,"isPure":true,"kind":"string","lValueRequested":false,"nodeType":"Literal","src":"12640:42:100","typeDescriptions":{"typeIdentifier":"t_stringliteral_d1dd717c39956ee86b1eb77b9f3cb6dbeca6df99b330f67dd364a35a1174c2ce","typeString":"literal_string \"FetchChainInfoOutput: challenger not set\""},"value":"FetchChainInfoOutput: challenger not set"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_bool","typeString":"bool"},{"typeIdentifier":"t_stringliteral_d1dd717c39956ee86b1eb77b9f3cb6dbeca6df99b330f67dd364a35a1174c2ce","typeString":"literal_string \"FetchChainInfoOutput: challenger not set\""}],"id":54818,"name":"require","nodeType":"Identifier","overloadedDeclarations":[-18,-18,-18],"referencedDeclaration":-18,"src":"12605:7:100","typeDescriptions":{"typeIdentifier":"t_function_require_pure$_t_bool_$_t_string_memory_ptr_$returns$__$","typeString":"function (bool,string memory) pure"}},"id":54826,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"12605:78:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":54827,"nodeType":"ExpressionStatement","src":"12605:78:100"},{"expression":{"id":54828,"name":"_challenger","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54089,"src":"12700:11:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"functionReturnParameters":54817,"id":54829,"nodeType":"Return","src":"12693:18:100"}]},"functionSelector":"534db0e2","implemented":true,"kind":"function","modifiers":[],"name":"challenger","nameLocation":"12552:10:100","parameters":{"id":54814,"nodeType":"ParameterList","parameters":[],"src":"12562:2:100"},"returnParameters":{"id":54817,"nodeType":"ParameterList","parameters":[{"constant":false,"id":54816,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":54831,"src":"12586:7:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":54815,"name":"address","nodeType":"ElementaryTypeName","src":"12586:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"12585:9:100"},"scope":54911,"stateMutability":"view","virtual":false,"visibility":"public"},{"id":54849,"nodeType":"FunctionDefinition","src":"12724:167:100","nodes":[],"body":{"id":54848,"nodeType":"Block","src":"12774:117:100","nodes":[],"statements":[{"expression":{"arguments":[{"commonType":{"typeIdentifier":"t_address","typeString":"address"},"id":54842,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftExpression":{"id":54837,"name":"_proposer","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54091,"src":"12792:9:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"BinaryOperation","operator":"!=","rightExpression":{"arguments":[{"hexValue":"30","id":54840,"isConstant":false,"isLValue":false,"isPure":true,"kind":"number","lValueRequested":false,"nodeType":"Literal","src":"12813:1:100","typeDescriptions":{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"},"value":"0"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"}],"id":54839,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"nodeType":"ElementaryTypeNameExpression","src":"12805:7:100","typeDescriptions":{"typeIdentifier":"t_type$_t_address_$","typeString":"type(address)"},"typeName":{"id":54838,"name":"address","nodeType":"ElementaryTypeName","src":"12805:7:100","typeDescriptions":{}}},"id":54841,"isConstant":false,"isLValue":false,"isPure":true,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"12805:10:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"src":"12792:23:100","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},{"hexValue":"4665746368436861696e496e666f4f75747075743a2070726f706f736572206e6f7420736574","id":54843,"isConstant":false,"isLValue":false,"isPure":true,"kind":"string","lValueRequested":false,"nodeType":"Literal","src":"12817:40:100","typeDescriptions":{"typeIdentifier":"t_stringliteral_c4910753f64240b424591ec2bc873e5a728ff321d57cb1a353788ad2c385da71","typeString":"literal_string \"FetchChainInfoOutput: proposer not set\""},"value":"FetchChainInfoOutput: proposer not set"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_bool","typeString":"bool"},{"typeIdentifier":"t_stringliteral_c4910753f64240b424591ec2bc873e5a728ff321d57cb1a353788ad2c385da71","typeString":"literal_string \"FetchChainInfoOutput: proposer not set\""}],"id":54836,"name":"require","nodeType":"Identifier","overloadedDeclarations":[-18,-18,-18],"referencedDeclaration":-18,"src":"12784:7:100","typeDescriptions":{"typeIdentifier":"t_function_require_pure$_t_bool_$_t_string_memory_ptr_$returns$__$","typeString":"function (bool,string memory) pure"}},"id":54844,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"12784:74:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":54845,"nodeType":"ExpressionStatement","src":"12784:74:100"},{"expression":{"id":54846,"name":"_proposer","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54091,"src":"12875:9:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"functionReturnParameters":54835,"id":54847,"nodeType":"Return","src":"12868:16:100"}]},"functionSelector":"a8e4fb90","implemented":true,"kind":"function","modifiers":[],"name":"proposer","nameLocation":"12733:8:100","parameters":{"id":54832,"nodeType":"ParameterList","parameters":[],"src":"12741:2:100"},"returnParameters":{"id":54835,"nodeType":"ParameterList","parameters":[{"constant":false,"id":54834,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":54849,"src":"12765:7:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":54833,"name":"address","nodeType":"ElementaryTypeName","src":"12765:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"12764:9:100"},"scope":54911,"stateMutability":"view","virtual":false,"visibility":"public"},{"id":54867,"nodeType":"FunctionDefinition","src":"12897:203:100","nodes":[],"body":{"id":54866,"nodeType":"Block","src":"12956:144:100","nodes":[],"statements":[{"expression":{"arguments":[{"commonType":{"typeIdentifier":"t_address","typeString":"address"},"id":54860,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftExpression":{"id":54855,"name":"_unsafeBlockSigner","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54093,"src":"12974:18:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"BinaryOperation","operator":"!=","rightExpression":{"arguments":[{"hexValue":"30","id":54858,"isConstant":false,"isLValue":false,"isPure":true,"kind":"number","lValueRequested":false,"nodeType":"Literal","src":"13004:1:100","typeDescriptions":{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"},"value":"0"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"}],"id":54857,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"nodeType":"ElementaryTypeNameExpression","src":"12996:7:100","typeDescriptions":{"typeIdentifier":"t_type$_t_address_$","typeString":"type(address)"},"typeName":{"id":54856,"name":"address","nodeType":"ElementaryTypeName","src":"12996:7:100","typeDescriptions":{}}},"id":54859,"isConstant":false,"isLValue":false,"isPure":true,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"12996:10:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"src":"12974:32:100","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},{"hexValue":"4665746368436861696e496e666f4f75747075743a20756e73616665426c6f636b5369676e6572206e6f7420736574","id":54861,"isConstant":false,"isLValue":false,"isPure":true,"kind":"string","lValueRequested":false,"nodeType":"Literal","src":"13008:49:100","typeDescriptions":{"typeIdentifier":"t_stringliteral_c0c85432d1596fb73656e29b64f6ea745166dde4a7fa6163bfe6b285aea851d7","typeString":"literal_string \"FetchChainInfoOutput: unsafeBlockSigner not set\""},"value":"FetchChainInfoOutput: unsafeBlockSigner not set"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_bool","typeString":"bool"},{"typeIdentifier":"t_stringliteral_c0c85432d1596fb73656e29b64f6ea745166dde4a7fa6163bfe6b285aea851d7","typeString":"literal_string \"FetchChainInfoOutput: unsafeBlockSigner not set\""}],"id":54854,"name":"require","nodeType":"Identifier","overloadedDeclarations":[-18,-18,-18],"referencedDeclaration":-18,"src":"12966:7:100","typeDescriptions":{"typeIdentifier":"t_function_require_pure$_t_bool_$_t_string_memory_ptr_$returns$__$","typeString":"function (bool,string memory) pure"}},"id":54862,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"12966:92:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":54863,"nodeType":"ExpressionStatement","src":"12966:92:100"},{"expression":{"id":54864,"name":"_unsafeBlockSigner","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54093,"src":"13075:18:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"functionReturnParameters":54853,"id":54865,"nodeType":"Return","src":"13068:25:100"}]},"functionSelector":"1fd19ee1","implemented":true,"kind":"function","modifiers":[],"name":"unsafeBlockSigner","nameLocation":"12906:17:100","parameters":{"id":54850,"nodeType":"ParameterList","parameters":[],"src":"12923:2:100"},"returnParameters":{"id":54853,"nodeType":"ParameterList","parameters":[{"constant":false,"id":54852,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":54867,"src":"12947:7:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":54851,"name":"address","nodeType":"ElementaryTypeName","src":"12947:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"12946:9:100"},"scope":54911,"stateMutability":"view","virtual":false,"visibility":"public"},{"id":54885,"nodeType":"FunctionDefinition","src":"13106:191:100","nodes":[],"body":{"id":54884,"nodeType":"Block","src":"13162:135:100","nodes":[],"statements":[{"expression":{"arguments":[{"commonType":{"typeIdentifier":"t_address","typeString":"address"},"id":54878,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftExpression":{"id":54873,"name":"_batchSubmitter","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54095,"src":"13180:15:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"BinaryOperation","operator":"!=","rightExpression":{"arguments":[{"hexValue":"30","id":54876,"isConstant":false,"isLValue":false,"isPure":true,"kind":"number","lValueRequested":false,"nodeType":"Literal","src":"13207:1:100","typeDescriptions":{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"},"value":"0"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"}],"id":54875,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"nodeType":"ElementaryTypeNameExpression","src":"13199:7:100","typeDescriptions":{"typeIdentifier":"t_type$_t_address_$","typeString":"type(address)"},"typeName":{"id":54874,"name":"address","nodeType":"ElementaryTypeName","src":"13199:7:100","typeDescriptions":{}}},"id":54877,"isConstant":false,"isLValue":false,"isPure":true,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"13199:10:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"src":"13180:29:100","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},{"hexValue":"4665746368436861696e496e666f4f75747075743a2062617463685375626d6974746572206e6f7420736574","id":54879,"isConstant":false,"isLValue":false,"isPure":true,"kind":"string","lValueRequested":false,"nodeType":"Literal","src":"13211:46:100","typeDescriptions":{"typeIdentifier":"t_stringliteral_dc2094d90bbe21c62e4087e13d121e3f8b0b046ea0a70d61432535290d56a2cc","typeString":"literal_string \"FetchChainInfoOutput: batchSubmitter not set\""},"value":"FetchChainInfoOutput: batchSubmitter not set"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_bool","typeString":"bool"},{"typeIdentifier":"t_stringliteral_dc2094d90bbe21c62e4087e13d121e3f8b0b046ea0a70d61432535290d56a2cc","typeString":"literal_string \"FetchChainInfoOutput: batchSubmitter not set\""}],"id":54872,"name":"require","nodeType":"Identifier","overloadedDeclarations":[-18,-18,-18],"referencedDeclaration":-18,"src":"13172:7:100","typeDescriptions":{"typeIdentifier":"t_function_require_pure$_t_bool_$_t_string_memory_ptr_$returns$__$","typeString":"function (bool,string memory) pure"}},"id":54880,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"13172:86:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":54881,"nodeType":"ExpressionStatement","src":"13172:86:100"},{"expression":{"id":54882,"name":"_batchSubmitter","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54095,"src":"13275:15:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"functionReturnParameters":54871,"id":54883,"nodeType":"Return","src":"13268:22:100"}]},"functionSelector":"fb951e9d","implemented":true,"kind":"function","modifiers":[],"name":"batchSubmitter","nameLocation":"13115:14:100","parameters":{"id":54868,"nodeType":"ParameterList","parameters":[],"src":"13129:2:100"},"returnParameters":{"id":54871,"nodeType":"ParameterList","parameters":[{"constant":false,"id":54870,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":54885,"src":"13153:7:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":54869,"name":"address","nodeType":"ElementaryTypeName","src":"13153:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"13152:9:100"},"scope":54911,"stateMutability":"view","virtual":false,"visibility":"public"},{"id":54893,"nodeType":"FunctionDefinition","src":"13303:88:100","nodes":[],"body":{"id":54892,"nodeType":"Block","src":"13354:37:100","nodes":[],"statements":[{"expression":{"id":54890,"name":"_permissioned","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54097,"src":"13371:13:100","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},"functionReturnParameters":54889,"id":54891,"nodeType":"Return","src":"13364:20:100"}]},"functionSelector":"3cc162f1","implemented":true,"kind":"function","modifiers":[],"name":"permissioned","nameLocation":"13312:12:100","parameters":{"id":54886,"nodeType":"ParameterList","parameters":[],"src":"13324:2:100"},"returnParameters":{"id":54889,"nodeType":"ParameterList","parameters":[{"constant":false,"id":54888,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":54893,"src":"13348:4:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"},"typeName":{"id":54887,"name":"bool","nodeType":"ElementaryTypeName","src":"13348:4:100","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},"visibility":"internal"}],"src":"13347:6:100"},"scope":54911,"stateMutability":"view","virtual":false,"visibility":"public"},{"id":54901,"nodeType":"FunctionDefinition","src":"13397:92:100","nodes":[],"body":{"id":54900,"nodeType":"Block","src":"13450:39:100","nodes":[],"statements":[{"expression":{"id":54898,"name":"_permissionless","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54099,"src":"13467:15:100","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},"functionReturnParameters":54897,"id":54899,"nodeType":"Return","src":"13460:22:100"}]},"functionSelector":"a1256f9f","implemented":true,"kind":"function","modifiers":[],"name":"permissionless","nameLocation":"13406:14:100","parameters":{"id":54894,"nodeType":"ParameterList","parameters":[],"src":"13420:2:100"},"returnParameters":{"id":54897,"nodeType":"ParameterList","parameters":[{"constant":false,"id":54896,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":54901,"src":"13444:4:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"},"typeName":{"id":54895,"name":"bool","nodeType":"ElementaryTypeName","src":"13444:4:100","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},"visibility":"internal"}],"src":"13443:6:100"},"scope":54911,"stateMutability":"view","virtual":false,"visibility":"public"},{"id":54910,"nodeType":"FunctionDefinition","src":"13495:102:100","nodes":[],"body":{"id":54909,"nodeType":"Block","src":"13555:42:100","nodes":[],"statements":[{"expression":{"id":54907,"name":"_respectedGameType","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54102,"src":"13572:18:100","typeDescriptions":{"typeIdentifier":"t_userDefinedValueType$_GameType_$70720","typeString":"GameType"}},"functionReturnParameters":54906,"id":54908,"nodeType":"Return","src":"13565:25:100"}]},"functionSelector":"3c9f397c","implemented":true,"kind":"function","modifiers":[],"name":"respectedGameType","nameLocation":"13504:17:100","parameters":{"id":54902,"nodeType":"ParameterList","parameters":[],"src":"13521:2:100"},"returnParameters":{"id":54906,"nodeType":"ParameterList","parameters":[{"constant":false,"id":54905,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":54910,"src":"13545:8:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_userDefinedValueType$_GameType_$70720","typeString":"GameType"},"typeName":{"id":54904,"nodeType":"UserDefinedTypeName","pathNode":{"id":54903,"name":"GameType","nameLocations":["13545:8:100"],"nodeType":"IdentifierPath","referencedDeclaration":70720,"src":"13545:8:100"},"referencedDeclaration":70720,"src":"13545:8:100","typeDescriptions":{"typeIdentifier":"t_userDefinedValueType$_GameType_$70720","typeString":"GameType"}},"visibility":"internal"}],"src":"13544:10:100"},"scope":54911,"stateMutability":"view","virtual":false,"visibility":"public"}],"abstract":false,"baseContracts":[],"canonicalName":"FetchChainInfoOutput","contractDependencies":[],"contractKind":"contract","fullyImplemented":true,"linearizedBaseContracts":[54911],"name":"FetchChainInfoOutput","nameLocation":"2966:20:100","scope":56019,"usedErrors":[],"usedEvents":[]},{"id":56018,"nodeType":"ContractDefinition","src":"13601:11550:100","nodes":[{"id":54937,"nodeType":"FunctionDefinition","src":"13641:198:100","nodes":[],"body":{"id":54936,"nodeType":"Block","src":"13712:127:100","nodes":[],"statements":[{"expression":{"arguments":[{"id":54923,"name":"_fi","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54916,"src":"13743:3:100","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoInput_$54041","typeString":"contract FetchChainInfoInput"}},{"id":54924,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54919,"src":"13748:3:100","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$54911","typeString":"contract FetchChainInfoOutput"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_contract$_FetchChainInfoInput_$54041","typeString":"contract FetchChainInfoInput"},{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$54911","typeString":"contract FetchChainInfoOutput"}],"id":54922,"name":"_processSystemConfig","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55073,"src":"13722:20:100","typeDescriptions":{"typeIdentifier":"t_function_internal_nonpayable$_t_contract$_FetchChainInfoInput_$54041_$_t_contract$_FetchChainInfoOutput_$54911_$returns$__$","typeString":"function (contract FetchChainInfoInput,contract FetchChainInfoOutput)"}},"id":54925,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"13722:30:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":54926,"nodeType":"ExpressionStatement","src":"13722:30:100"},{"expression":{"arguments":[{"id":54928,"name":"_fi","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54916,"src":"13789:3:100","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoInput_$54041","typeString":"contract FetchChainInfoInput"}},{"id":54929,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54919,"src":"13794:3:100","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$54911","typeString":"contract FetchChainInfoOutput"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_contract$_FetchChainInfoInput_$54041","typeString":"contract FetchChainInfoInput"},{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$54911","typeString":"contract FetchChainInfoOutput"}],"id":54927,"name":"_processMessengerAndPortal","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55190,"src":"13762:26:100","typeDescriptions":{"typeIdentifier":"t_function_internal_nonpayable$_t_contract$_FetchChainInfoInput_$54041_$_t_contract$_FetchChainInfoOutput_$54911_$returns$__$","typeString":"function (contract FetchChainInfoInput,contract FetchChainInfoOutput)"}},"id":54930,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"13762:36:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":54931,"nodeType":"ExpressionStatement","src":"13762:36:100"},{"expression":{"arguments":[{"id":54933,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54919,"src":"13828:3:100","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$54911","typeString":"contract FetchChainInfoOutput"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$54911","typeString":"contract FetchChainInfoOutput"}],"id":54932,"name":"_processFaultProofs","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55565,"src":"13808:19:100","typeDescriptions":{"typeIdentifier":"t_function_internal_nonpayable$_t_contract$_FetchChainInfoOutput_$54911_$returns$__$","typeString":"function (contract FetchChainInfoOutput)"}},"id":54934,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"13808:24:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":54935,"nodeType":"ExpressionStatement","src":"13808:24:100"}]},"functionSelector":"fc4dcacb","implemented":true,"kind":"function","modifiers":[],"name":"run","nameLocation":"13650:3:100","parameters":{"id":54920,"nodeType":"ParameterList","parameters":[{"constant":false,"id":54916,"mutability":"mutable","name":"_fi","nameLocation":"13674:3:100","nodeType":"VariableDeclaration","scope":54937,"src":"13654:23:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoInput_$54041","typeString":"contract FetchChainInfoInput"},"typeName":{"id":54915,"nodeType":"UserDefinedTypeName","pathNode":{"id":54914,"name":"FetchChainInfoInput","nameLocations":["13654:19:100"],"nodeType":"IdentifierPath","referencedDeclaration":54041,"src":"13654:19:100"},"referencedDeclaration":54041,"src":"13654:19:100","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoInput_$54041","typeString":"contract FetchChainInfoInput"}},"visibility":"internal"},{"constant":false,"id":54919,"mutability":"mutable","name":"_fo","nameLocation":"13700:3:100","nodeType":"VariableDeclaration","scope":54937,"src":"13679:24:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$54911","typeString":"contract FetchChainInfoOutput"},"typeName":{"id":54918,"nodeType":"UserDefinedTypeName","pathNode":{"id":54917,"name":"FetchChainInfoOutput","nameLocations":["13679:20:100"],"nodeType":"IdentifierPath","referencedDeclaration":54911,"src":"13679:20:100"},"referencedDeclaration":54911,"src":"13679:20:100","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$54911","typeString":"contract FetchChainInfoOutput"}},"visibility":"internal"}],"src":"13653:51:100"},"returnParameters":{"id":54921,"nodeType":"ParameterList","parameters":[],"src":"13712:0:100"},"scope":56018,"stateMutability":"nonpayable","virtual":false,"visibility":"public"},{"id":55073,"nodeType":"FunctionDefinition","src":"13845:1336:100","nodes":[],"body":{"id":55072,"nodeType":"Block","src":"13935:1246:100","nodes":[],"statements":[{"assignments":[54947],"declarations":[{"constant":false,"id":54947,"mutability":"mutable","name":"systemConfigProxy","nameLocation":"13953:17:100","nodeType":"VariableDeclaration","scope":55072,"src":"13945:25:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":54946,"name":"address","nodeType":"ElementaryTypeName","src":"13945:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"id":54951,"initialValue":{"arguments":[],"expression":{"argumentTypes":[],"expression":{"id":54948,"name":"_fi","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54940,"src":"13973:3:100","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoInput_$54041","typeString":"contract FetchChainInfoInput"}},"id":54949,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"13977:17:100","memberName":"systemConfigProxy","nodeType":"MemberAccess","referencedDeclaration":54022,"src":"13973:21:100","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":54950,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"13973:23:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"VariableDeclarationStatement","src":"13945:51:100"},{"expression":{"arguments":[{"expression":{"expression":{"id":54955,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54943,"src":"14014:3:100","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$54911","typeString":"contract FetchChainInfoOutput"}},"id":54956,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"14018:17:100","memberName":"systemConfigProxy","nodeType":"MemberAccess","referencedDeclaration":54591,"src":"14014:21:100","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":54957,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"14036:8:100","memberName":"selector","nodeType":"MemberAccess","src":"14014:30:100","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},{"id":54958,"name":"systemConfigProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54947,"src":"14046:17:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_bytes4","typeString":"bytes4"},{"typeIdentifier":"t_address","typeString":"address"}],"expression":{"id":54952,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54943,"src":"14006:3:100","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$54911","typeString":"contract FetchChainInfoOutput"}},"id":54954,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"14010:3:100","memberName":"set","nodeType":"MemberAccess","referencedDeclaration":54384,"src":"14006:7:100","typeDescriptions":{"typeIdentifier":"t_function_external_nonpayable$_t_bytes4_$_t_address_$returns$__$","typeString":"function (bytes4,address) external"}},"id":54959,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"14006:58:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":54960,"nodeType":"ExpressionStatement","src":"14006:58:100"},{"assignments":[54962],"declarations":[{"constant":false,"id":54962,"mutability":"mutable","name":"systemConfigOwner","nameLocation":"14083:17:100","nodeType":"VariableDeclaration","scope":55072,"src":"14075:25:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":54961,"name":"address","nodeType":"ElementaryTypeName","src":"14075:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"id":54968,"initialValue":{"arguments":[],"expression":{"argumentTypes":[],"expression":{"arguments":[{"id":54964,"name":"systemConfigProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54947,"src":"14112:17:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_address","typeString":"address"}],"id":54963,"name":"IFetcher","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":53958,"src":"14103:8:100","typeDescriptions":{"typeIdentifier":"t_type$_t_contract$_IFetcher_$53958_$","typeString":"type(contract IFetcher)"}},"id":54965,"isConstant":false,"isLValue":false,"isPure":false,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"14103:27:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_contract$_IFetcher_$53958","typeString":"contract IFetcher"}},"id":54966,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"14131:5:100","memberName":"owner","nodeType":"MemberAccess","referencedDeclaration":53947,"src":"14103:33:100","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":54967,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"14103:35:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"VariableDeclarationStatement","src":"14075:63:100"},{"expression":{"arguments":[{"expression":{"expression":{"id":54972,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54943,"src":"14156:3:100","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$54911","typeString":"contract FetchChainInfoOutput"}},"id":54973,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"14160:17:100","memberName":"systemConfigOwner","nodeType":"MemberAccess","referencedDeclaration":54777,"src":"14156:21:100","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":54974,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"14178:8:100","memberName":"selector","nodeType":"MemberAccess","src":"14156:30:100","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},{"id":54975,"name":"systemConfigOwner","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54962,"src":"14188:17:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_bytes4","typeString":"bytes4"},{"typeIdentifier":"t_address","typeString":"address"}],"expression":{"id":54969,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54943,"src":"14148:3:100","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$54911","typeString":"contract FetchChainInfoOutput"}},"id":54971,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"14152:3:100","memberName":"set","nodeType":"MemberAccess","referencedDeclaration":54384,"src":"14148:7:100","typeDescriptions":{"typeIdentifier":"t_function_external_nonpayable$_t_bytes4_$_t_address_$returns$__$","typeString":"function (bytes4,address) external"}},"id":54976,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"14148:58:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":54977,"nodeType":"ExpressionStatement","src":"14148:58:100"},{"assignments":[54979],"declarations":[{"constant":false,"id":54979,"mutability":"mutable","name":"unsafeBlockSigner","nameLocation":"14225:17:100","nodeType":"VariableDeclaration","scope":55072,"src":"14217:25:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":54978,"name":"address","nodeType":"ElementaryTypeName","src":"14217:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"id":54985,"initialValue":{"arguments":[],"expression":{"argumentTypes":[],"expression":{"arguments":[{"id":54981,"name":"systemConfigProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54947,"src":"14254:17:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_address","typeString":"address"}],"id":54980,"name":"IFetcher","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":53958,"src":"14245:8:100","typeDescriptions":{"typeIdentifier":"t_type$_t_contract$_IFetcher_$53958_$","typeString":"type(contract IFetcher)"}},"id":54982,"isConstant":false,"isLValue":false,"isPure":false,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"14245:27:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_contract$_IFetcher_$53958","typeString":"contract IFetcher"}},"id":54983,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"14273:17:100","memberName":"unsafeBlockSigner","nodeType":"MemberAccess","referencedDeclaration":53952,"src":"14245:45:100","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":54984,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"14245:47:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"VariableDeclarationStatement","src":"14217:75:100"},{"expression":{"arguments":[{"expression":{"expression":{"id":54989,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54943,"src":"14310:3:100","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$54911","typeString":"contract FetchChainInfoOutput"}},"id":54990,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"14314:17:100","memberName":"unsafeBlockSigner","nodeType":"MemberAccess","referencedDeclaration":54867,"src":"14310:21:100","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":54991,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"14332:8:100","memberName":"selector","nodeType":"MemberAccess","src":"14310:30:100","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},{"id":54992,"name":"unsafeBlockSigner","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54979,"src":"14342:17:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_bytes4","typeString":"bytes4"},{"typeIdentifier":"t_address","typeString":"address"}],"expression":{"id":54986,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54943,"src":"14302:3:100","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$54911","typeString":"contract FetchChainInfoOutput"}},"id":54988,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"14306:3:100","memberName":"set","nodeType":"MemberAccess","referencedDeclaration":54384,"src":"14302:7:100","typeDescriptions":{"typeIdentifier":"t_function_external_nonpayable$_t_bytes4_$_t_address_$returns$__$","typeString":"function (bytes4,address) external"}},"id":54993,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"14302:58:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":54994,"nodeType":"ExpressionStatement","src":"14302:58:100"},{"assignments":[54996],"declarations":[{"constant":false,"id":54996,"mutability":"mutable","name":"batchSubmitter","nameLocation":"14379:14:100","nodeType":"VariableDeclaration","scope":55072,"src":"14371:22:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":54995,"name":"address","nodeType":"ElementaryTypeName","src":"14371:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"id":55000,"initialValue":{"arguments":[{"id":54998,"name":"systemConfigProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54947,"src":"14415:17:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_address","typeString":"address"}],"id":54997,"name":"_getBatchSubmitter","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55994,"src":"14396:18:100","typeDescriptions":{"typeIdentifier":"t_function_internal_view$_t_address_$returns$_t_address_$","typeString":"function (address) view returns (address)"}},"id":54999,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"14396:37:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"VariableDeclarationStatement","src":"14371:62:100"},{"expression":{"arguments":[{"expression":{"expression":{"id":55004,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54943,"src":"14451:3:100","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$54911","typeString":"contract FetchChainInfoOutput"}},"id":55005,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"14455:14:100","memberName":"batchSubmitter","nodeType":"MemberAccess","referencedDeclaration":54885,"src":"14451:18:100","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":55006,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"14470:8:100","memberName":"selector","nodeType":"MemberAccess","src":"14451:27:100","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},{"id":55007,"name":"batchSubmitter","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54996,"src":"14480:14:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_bytes4","typeString":"bytes4"},{"typeIdentifier":"t_address","typeString":"address"}],"expression":{"id":55001,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54943,"src":"14443:3:100","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$54911","typeString":"contract FetchChainInfoOutput"}},"id":55003,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"14447:3:100","memberName":"set","nodeType":"MemberAccess","referencedDeclaration":54384,"src":"14443:7:100","typeDescriptions":{"typeIdentifier":"t_function_external_nonpayable$_t_bytes4_$_t_address_$returns$__$","typeString":"function (bytes4,address) external"}},"id":55008,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"14443:52:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":55009,"nodeType":"ExpressionStatement","src":"14443:52:100"},{"assignments":[55011],"declarations":[{"constant":false,"id":55011,"mutability":"mutable","name":"opChainProxyAdminImpl","nameLocation":"14514:21:100","nodeType":"VariableDeclaration","scope":55072,"src":"14506:29:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":55010,"name":"address","nodeType":"ElementaryTypeName","src":"14506:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"id":55015,"initialValue":{"arguments":[{"id":55013,"name":"systemConfigProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54947,"src":"14553:17:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_address","typeString":"address"}],"id":55012,"name":"_getProxyAdmin","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":56017,"src":"14538:14:100","typeDescriptions":{"typeIdentifier":"t_function_internal_nonpayable$_t_address_$returns$_t_address_$","typeString":"function (address) returns (address)"}},"id":55014,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"14538:33:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"VariableDeclarationStatement","src":"14506:65:100"},{"expression":{"arguments":[{"expression":{"expression":{"id":55019,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54943,"src":"14589:3:100","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$54911","typeString":"contract FetchChainInfoOutput"}},"id":55020,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"14593:21:100","memberName":"opChainProxyAdminImpl","nodeType":"MemberAccess","referencedDeclaration":54609,"src":"14589:25:100","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":55021,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"14615:8:100","memberName":"selector","nodeType":"MemberAccess","src":"14589:34:100","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},{"id":55022,"name":"opChainProxyAdminImpl","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55011,"src":"14625:21:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_bytes4","typeString":"bytes4"},{"typeIdentifier":"t_address","typeString":"address"}],"expression":{"id":55016,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54943,"src":"14581:3:100","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$54911","typeString":"contract FetchChainInfoOutput"}},"id":55018,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"14585:3:100","memberName":"set","nodeType":"MemberAccess","referencedDeclaration":54384,"src":"14581:7:100","typeDescriptions":{"typeIdentifier":"t_function_external_nonpayable$_t_bytes4_$_t_address_$returns$__$","typeString":"function (bytes4,address) external"}},"id":55023,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"14581:66:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":55024,"nodeType":"ExpressionStatement","src":"14581:66:100"},{"assignments":[55026],"declarations":[{"constant":false,"id":55026,"mutability":"mutable","name":"opChainProxyAdminOwner","nameLocation":"14666:22:100","nodeType":"VariableDeclaration","scope":55072,"src":"14658:30:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":55025,"name":"address","nodeType":"ElementaryTypeName","src":"14658:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"id":55032,"initialValue":{"arguments":[],"expression":{"argumentTypes":[],"expression":{"arguments":[{"id":55028,"name":"opChainProxyAdminImpl","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55011,"src":"14700:21:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_address","typeString":"address"}],"id":55027,"name":"IFetcher","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":53958,"src":"14691:8:100","typeDescriptions":{"typeIdentifier":"t_type$_t_contract$_IFetcher_$53958_$","typeString":"type(contract IFetcher)"}},"id":55029,"isConstant":false,"isLValue":false,"isPure":false,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"14691:31:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_contract$_IFetcher_$53958","typeString":"contract IFetcher"}},"id":55030,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"14723:5:100","memberName":"owner","nodeType":"MemberAccess","referencedDeclaration":53947,"src":"14691:37:100","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":55031,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"14691:39:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"VariableDeclarationStatement","src":"14658:72:100"},{"expression":{"arguments":[{"expression":{"expression":{"id":55036,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54943,"src":"14748:3:100","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$54911","typeString":"contract FetchChainInfoOutput"}},"id":55037,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"14752:22:100","memberName":"opChainProxyAdminOwner","nodeType":"MemberAccess","referencedDeclaration":54795,"src":"14748:26:100","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":55038,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"14775:8:100","memberName":"selector","nodeType":"MemberAccess","src":"14748:35:100","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},{"id":55039,"name":"opChainProxyAdminOwner","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55026,"src":"14785:22:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_bytes4","typeString":"bytes4"},{"typeIdentifier":"t_address","typeString":"address"}],"expression":{"id":55033,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54943,"src":"14740:3:100","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$54911","typeString":"contract FetchChainInfoOutput"}},"id":55035,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"14744:3:100","memberName":"set","nodeType":"MemberAccess","referencedDeclaration":54384,"src":"14740:7:100","typeDescriptions":{"typeIdentifier":"t_function_external_nonpayable$_t_bytes4_$_t_address_$returns$__$","typeString":"function (bytes4,address) external"}},"id":55040,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"14740:68:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":55041,"nodeType":"ExpressionStatement","src":"14740:68:100"},{"assignments":[55043],"declarations":[{"constant":false,"id":55043,"mutability":"mutable","name":"l1Erc721BridgeProxy","nameLocation":"14827:19:100","nodeType":"VariableDeclaration","scope":55072,"src":"14819:27:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":55042,"name":"address","nodeType":"ElementaryTypeName","src":"14819:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"id":55047,"initialValue":{"arguments":[{"id":55045,"name":"systemConfigProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54947,"src":"14873:17:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_address","typeString":"address"}],"id":55044,"name":"_getL1ERC721BridgeProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55718,"src":"14849:23:100","typeDescriptions":{"typeIdentifier":"t_function_internal_view$_t_address_$returns$_t_address_$","typeString":"function (address) view returns (address)"}},"id":55046,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"14849:42:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"VariableDeclarationStatement","src":"14819:72:100"},{"expression":{"arguments":[{"expression":{"expression":{"id":55051,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54943,"src":"14909:3:100","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$54911","typeString":"contract FetchChainInfoOutput"}},"id":55052,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"14913:19:100","memberName":"l1Erc721BridgeProxy","nodeType":"MemberAccess","referencedDeclaration":54501,"src":"14909:23:100","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":55053,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"14933:8:100","memberName":"selector","nodeType":"MemberAccess","src":"14909:32:100","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},{"id":55054,"name":"l1Erc721BridgeProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55043,"src":"14943:19:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_bytes4","typeString":"bytes4"},{"typeIdentifier":"t_address","typeString":"address"}],"expression":{"id":55048,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54943,"src":"14901:3:100","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$54911","typeString":"contract FetchChainInfoOutput"}},"id":55050,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"14905:3:100","memberName":"set","nodeType":"MemberAccess","referencedDeclaration":54384,"src":"14901:7:100","typeDescriptions":{"typeIdentifier":"t_function_external_nonpayable$_t_bytes4_$_t_address_$returns$__$","typeString":"function (bytes4,address) external"}},"id":55055,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"14901:62:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":55056,"nodeType":"ExpressionStatement","src":"14901:62:100"},{"assignments":[55058],"declarations":[{"constant":false,"id":55058,"mutability":"mutable","name":"optimismMintableErc20FactoryProxy","nameLocation":"14982:33:100","nodeType":"VariableDeclaration","scope":55072,"src":"14974:41:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":55057,"name":"address","nodeType":"ElementaryTypeName","src":"14974:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"id":55062,"initialValue":{"arguments":[{"id":55060,"name":"systemConfigProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54947,"src":"15056:17:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_address","typeString":"address"}],"id":55059,"name":"_getOptimismMintableERC20FactoryProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55746,"src":"15018:37:100","typeDescriptions":{"typeIdentifier":"t_function_internal_view$_t_address_$returns$_t_address_$","typeString":"function (address) view returns (address)"}},"id":55061,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"15018:56:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"VariableDeclarationStatement","src":"14974:100:100"},{"expression":{"arguments":[{"expression":{"expression":{"id":55066,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54943,"src":"15092:3:100","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$54911","typeString":"contract FetchChainInfoOutput"}},"id":55067,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"15096:33:100","memberName":"optimismMintableErc20FactoryProxy","nodeType":"MemberAccess","referencedDeclaration":54555,"src":"15092:37:100","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":55068,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"15130:8:100","memberName":"selector","nodeType":"MemberAccess","src":"15092:46:100","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},{"id":55069,"name":"optimismMintableErc20FactoryProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55058,"src":"15140:33:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_bytes4","typeString":"bytes4"},{"typeIdentifier":"t_address","typeString":"address"}],"expression":{"id":55063,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54943,"src":"15084:3:100","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$54911","typeString":"contract FetchChainInfoOutput"}},"id":55065,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"15088:3:100","memberName":"set","nodeType":"MemberAccess","referencedDeclaration":54384,"src":"15084:7:100","typeDescriptions":{"typeIdentifier":"t_function_external_nonpayable$_t_bytes4_$_t_address_$returns$__$","typeString":"function (bytes4,address) external"}},"id":55070,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"15084:90:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":55071,"nodeType":"ExpressionStatement","src":"15084:90:100"}]},"implemented":true,"kind":"function","modifiers":[],"name":"_processSystemConfig","nameLocation":"13854:20:100","parameters":{"id":54944,"nodeType":"ParameterList","parameters":[{"constant":false,"id":54940,"mutability":"mutable","name":"_fi","nameLocation":"13895:3:100","nodeType":"VariableDeclaration","scope":55073,"src":"13875:23:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoInput_$54041","typeString":"contract FetchChainInfoInput"},"typeName":{"id":54939,"nodeType":"UserDefinedTypeName","pathNode":{"id":54938,"name":"FetchChainInfoInput","nameLocations":["13875:19:100"],"nodeType":"IdentifierPath","referencedDeclaration":54041,"src":"13875:19:100"},"referencedDeclaration":54041,"src":"13875:19:100","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoInput_$54041","typeString":"contract FetchChainInfoInput"}},"visibility":"internal"},{"constant":false,"id":54943,"mutability":"mutable","name":"_fo","nameLocation":"13921:3:100","nodeType":"VariableDeclaration","scope":55073,"src":"13900:24:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$54911","typeString":"contract FetchChainInfoOutput"},"typeName":{"id":54942,"nodeType":"UserDefinedTypeName","pathNode":{"id":54941,"name":"FetchChainInfoOutput","nameLocations":["13900:20:100"],"nodeType":"IdentifierPath","referencedDeclaration":54911,"src":"13900:20:100"},"referencedDeclaration":54911,"src":"13900:20:100","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$54911","typeString":"contract FetchChainInfoOutput"}},"visibility":"internal"}],"src":"13874:51:100"},"returnParameters":{"id":54945,"nodeType":"ParameterList","parameters":[],"src":"13935:0:100"},"scope":56018,"stateMutability":"nonpayable","virtual":false,"visibility":"internal"},{"id":55190,"nodeType":"FunctionDefinition","src":"15187:1190:100","nodes":[],"body":{"id":55189,"nodeType":"Block","src":"15283:1094:100","nodes":[],"statements":[{"assignments":[55083],"declarations":[{"constant":false,"id":55083,"mutability":"mutable","name":"l1StandardBridgeProxy","nameLocation":"15301:21:100","nodeType":"VariableDeclaration","scope":55189,"src":"15293:29:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":55082,"name":"address","nodeType":"ElementaryTypeName","src":"15293:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"id":55087,"initialValue":{"arguments":[],"expression":{"argumentTypes":[],"expression":{"id":55084,"name":"_fi","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55076,"src":"15325:3:100","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoInput_$54041","typeString":"contract FetchChainInfoInput"}},"id":55085,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"15329:21:100","memberName":"l1StandardBridgeProxy","nodeType":"MemberAccess","referencedDeclaration":54040,"src":"15325:25:100","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":55086,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"15325:27:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"VariableDeclarationStatement","src":"15293:59:100"},{"expression":{"arguments":[{"expression":{"expression":{"id":55091,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55079,"src":"15370:3:100","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$54911","typeString":"contract FetchChainInfoOutput"}},"id":55092,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"15374:21:100","memberName":"l1StandardBridgeProxy","nodeType":"MemberAccess","referencedDeclaration":54519,"src":"15370:25:100","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":55093,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"15396:8:100","memberName":"selector","nodeType":"MemberAccess","src":"15370:34:100","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},{"id":55094,"name":"l1StandardBridgeProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55083,"src":"15406:21:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_bytes4","typeString":"bytes4"},{"typeIdentifier":"t_address","typeString":"address"}],"expression":{"id":55088,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55079,"src":"15362:3:100","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$54911","typeString":"contract FetchChainInfoOutput"}},"id":55090,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"15366:3:100","memberName":"set","nodeType":"MemberAccess","referencedDeclaration":54384,"src":"15362:7:100","typeDescriptions":{"typeIdentifier":"t_function_external_nonpayable$_t_bytes4_$_t_address_$returns$__$","typeString":"function (bytes4,address) external"}},"id":55095,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"15362:66:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":55096,"nodeType":"ExpressionStatement","src":"15362:66:100"},{"assignments":[55098],"declarations":[{"constant":false,"id":55098,"mutability":"mutable","name":"l1CrossDomainMessengerProxy","nameLocation":"15447:27:100","nodeType":"VariableDeclaration","scope":55189,"src":"15439:35:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":55097,"name":"address","nodeType":"ElementaryTypeName","src":"15439:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"id":55104,"initialValue":{"arguments":[],"expression":{"argumentTypes":[],"expression":{"arguments":[{"id":55100,"name":"l1StandardBridgeProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55083,"src":"15486:21:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_address","typeString":"address"}],"id":55099,"name":"IFetcher","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":53958,"src":"15477:8:100","typeDescriptions":{"typeIdentifier":"t_type$_t_contract$_IFetcher_$53958_$","typeString":"type(contract IFetcher)"}},"id":55101,"isConstant":false,"isLValue":false,"isPure":false,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"15477:31:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_contract$_IFetcher_$53958","typeString":"contract IFetcher"}},"id":55102,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"15509:9:100","memberName":"messenger","nodeType":"MemberAccess","referencedDeclaration":53853,"src":"15477:41:100","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":55103,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"15477:43:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"VariableDeclarationStatement","src":"15439:81:100"},{"expression":{"arguments":[{"expression":{"expression":{"id":55108,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55079,"src":"15538:3:100","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$54911","typeString":"contract FetchChainInfoOutput"}},"id":55109,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"15542:27:100","memberName":"l1CrossDomainMessengerProxy","nodeType":"MemberAccess","referencedDeclaration":54483,"src":"15538:31:100","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":55110,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"15570:8:100","memberName":"selector","nodeType":"MemberAccess","src":"15538:40:100","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},{"id":55111,"name":"l1CrossDomainMessengerProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55098,"src":"15580:27:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_bytes4","typeString":"bytes4"},{"typeIdentifier":"t_address","typeString":"address"}],"expression":{"id":55105,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55079,"src":"15530:3:100","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$54911","typeString":"contract FetchChainInfoOutput"}},"id":55107,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"15534:3:100","memberName":"set","nodeType":"MemberAccess","referencedDeclaration":54384,"src":"15530:7:100","typeDescriptions":{"typeIdentifier":"t_function_external_nonpayable$_t_bytes4_$_t_address_$returns$__$","typeString":"function (bytes4,address) external"}},"id":55112,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"15530:78:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":55113,"nodeType":"ExpressionStatement","src":"15530:78:100"},{"assignments":[55115],"declarations":[{"constant":false,"id":55115,"mutability":"mutable","name":"addressManagerImpl","nameLocation":"15627:18:100","nodeType":"VariableDeclaration","scope":55189,"src":"15619:26:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":55114,"name":"address","nodeType":"ElementaryTypeName","src":"15619:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"id":55119,"initialValue":{"arguments":[{"id":55117,"name":"l1CrossDomainMessengerProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55098,"src":"15667:27:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_address","typeString":"address"}],"id":55116,"name":"_getAddressManager","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55690,"src":"15648:18:100","typeDescriptions":{"typeIdentifier":"t_function_internal_view$_t_address_$returns$_t_address_$","typeString":"function (address) view returns (address)"}},"id":55118,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"15648:47:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"VariableDeclarationStatement","src":"15619:76:100"},{"expression":{"arguments":[{"expression":{"expression":{"id":55123,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55079,"src":"15713:3:100","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$54911","typeString":"contract FetchChainInfoOutput"}},"id":55124,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"15717:18:100","memberName":"addressManagerImpl","nodeType":"MemberAccess","referencedDeclaration":54457,"src":"15713:22:100","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":55125,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"15736:8:100","memberName":"selector","nodeType":"MemberAccess","src":"15713:31:100","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},{"id":55126,"name":"addressManagerImpl","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55115,"src":"15746:18:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_bytes4","typeString":"bytes4"},{"typeIdentifier":"t_address","typeString":"address"}],"expression":{"id":55120,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55079,"src":"15705:3:100","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$54911","typeString":"contract FetchChainInfoOutput"}},"id":55122,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"15709:3:100","memberName":"set","nodeType":"MemberAccess","referencedDeclaration":54384,"src":"15705:7:100","typeDescriptions":{"typeIdentifier":"t_function_external_nonpayable$_t_bytes4_$_t_address_$returns$__$","typeString":"function (bytes4,address) external"}},"id":55127,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"15705:60:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":55128,"nodeType":"ExpressionStatement","src":"15705:60:100"},{"assignments":[55130],"declarations":[{"constant":false,"id":55130,"mutability":"mutable","name":"optimismPortalProxy","nameLocation":"15784:19:100","nodeType":"VariableDeclaration","scope":55189,"src":"15776:27:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":55129,"name":"address","nodeType":"ElementaryTypeName","src":"15776:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"id":55134,"initialValue":{"arguments":[{"id":55132,"name":"l1CrossDomainMessengerProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55098,"src":"15830:27:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_address","typeString":"address"}],"id":55131,"name":"_getOptimismPortalProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55652,"src":"15806:23:100","typeDescriptions":{"typeIdentifier":"t_function_internal_view$_t_address_$returns$_t_address_$","typeString":"function (address) view returns (address)"}},"id":55133,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"15806:52:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"VariableDeclarationStatement","src":"15776:82:100"},{"expression":{"arguments":[{"expression":{"expression":{"id":55138,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55079,"src":"15876:3:100","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$54911","typeString":"contract FetchChainInfoOutput"}},"id":55139,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"15880:19:100","memberName":"optimismPortalProxy","nodeType":"MemberAccess","referencedDeclaration":54573,"src":"15876:23:100","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":55140,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"15900:8:100","memberName":"selector","nodeType":"MemberAccess","src":"15876:32:100","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},{"id":55141,"name":"optimismPortalProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55130,"src":"15910:19:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_bytes4","typeString":"bytes4"},{"typeIdentifier":"t_address","typeString":"address"}],"expression":{"id":55135,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55079,"src":"15868:3:100","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$54911","typeString":"contract FetchChainInfoOutput"}},"id":55137,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"15872:3:100","memberName":"set","nodeType":"MemberAccess","referencedDeclaration":54384,"src":"15868:7:100","typeDescriptions":{"typeIdentifier":"t_function_external_nonpayable$_t_bytes4_$_t_address_$returns$__$","typeString":"function (bytes4,address) external"}},"id":55142,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"15868:62:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":55143,"nodeType":"ExpressionStatement","src":"15868:62:100"},{"assignments":[55145],"declarations":[{"constant":false,"id":55145,"mutability":"mutable","name":"opChainGuardian","nameLocation":"15949:15:100","nodeType":"VariableDeclaration","scope":55189,"src":"15941:23:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":55144,"name":"address","nodeType":"ElementaryTypeName","src":"15941:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"id":55149,"initialValue":{"arguments":[{"id":55147,"name":"optimismPortalProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55130,"src":"15980:19:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_address","typeString":"address"}],"id":55146,"name":"_getGuardian","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55594,"src":"15967:12:100","typeDescriptions":{"typeIdentifier":"t_function_internal_view$_t_address_$returns$_t_address_$","typeString":"function (address) view returns (address)"}},"id":55148,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"15967:33:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"VariableDeclarationStatement","src":"15941:59:100"},{"expression":{"arguments":[{"expression":{"expression":{"id":55153,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55079,"src":"16018:3:100","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$54911","typeString":"contract FetchChainInfoOutput"}},"id":55154,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"16022:15:100","memberName":"opChainGuardian","nodeType":"MemberAccess","referencedDeclaration":54813,"src":"16018:19:100","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":55155,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"16038:8:100","memberName":"selector","nodeType":"MemberAccess","src":"16018:28:100","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},{"id":55156,"name":"opChainGuardian","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55145,"src":"16048:15:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_bytes4","typeString":"bytes4"},{"typeIdentifier":"t_address","typeString":"address"}],"expression":{"id":55150,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55079,"src":"16010:3:100","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$54911","typeString":"contract FetchChainInfoOutput"}},"id":55152,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"16014:3:100","memberName":"set","nodeType":"MemberAccess","referencedDeclaration":54384,"src":"16010:7:100","typeDescriptions":{"typeIdentifier":"t_function_external_nonpayable$_t_bytes4_$_t_address_$returns$__$","typeString":"function (bytes4,address) external"}},"id":55157,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"16010:54:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":55158,"nodeType":"ExpressionStatement","src":"16010:54:100"},{"assignments":[55160],"declarations":[{"constant":false,"id":55160,"mutability":"mutable","name":"ethLockboxProxy","nameLocation":"16083:15:100","nodeType":"VariableDeclaration","scope":55189,"src":"16075:23:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":55159,"name":"address","nodeType":"ElementaryTypeName","src":"16075:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"id":55164,"initialValue":{"arguments":[{"id":55162,"name":"optimismPortalProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55130,"src":"16121:19:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_address","typeString":"address"}],"id":55161,"name":"_getEthLockboxProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55922,"src":"16101:19:100","typeDescriptions":{"typeIdentifier":"t_function_internal_view$_t_address_$returns$_t_address_$","typeString":"function (address) view returns (address)"}},"id":55163,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"16101:40:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"VariableDeclarationStatement","src":"16075:66:100"},{"expression":{"arguments":[{"expression":{"expression":{"id":55168,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55079,"src":"16159:3:100","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$54911","typeString":"contract FetchChainInfoOutput"}},"id":55169,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"16163:15:100","memberName":"ethLockboxProxy","nodeType":"MemberAccess","referencedDeclaration":54465,"src":"16159:19:100","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":55170,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"16179:8:100","memberName":"selector","nodeType":"MemberAccess","src":"16159:28:100","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},{"id":55171,"name":"ethLockboxProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55160,"src":"16189:15:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_bytes4","typeString":"bytes4"},{"typeIdentifier":"t_address","typeString":"address"}],"expression":{"id":55165,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55079,"src":"16151:3:100","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$54911","typeString":"contract FetchChainInfoOutput"}},"id":55167,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"16155:3:100","memberName":"set","nodeType":"MemberAccess","referencedDeclaration":54384,"src":"16151:7:100","typeDescriptions":{"typeIdentifier":"t_function_external_nonpayable$_t_bytes4_$_t_address_$returns$__$","typeString":"function (bytes4,address) external"}},"id":55172,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"16151:54:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":55173,"nodeType":"ExpressionStatement","src":"16151:54:100"},{"assignments":[55175],"declarations":[{"constant":false,"id":55175,"mutability":"mutable","name":"superchainConfigProxy","nameLocation":"16224:21:100","nodeType":"VariableDeclaration","scope":55189,"src":"16216:29:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":55174,"name":"address","nodeType":"ElementaryTypeName","src":"16216:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"id":55179,"initialValue":{"arguments":[{"id":55177,"name":"optimismPortalProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55130,"src":"16274:19:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_address","typeString":"address"}],"id":55176,"name":"_getSuperchainConfigProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55802,"src":"16248:25:100","typeDescriptions":{"typeIdentifier":"t_function_internal_view$_t_address_$returns$_t_address_$","typeString":"function (address) view returns (address)"}},"id":55178,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"16248:46:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"VariableDeclarationStatement","src":"16216:78:100"},{"expression":{"arguments":[{"expression":{"expression":{"id":55183,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55079,"src":"16312:3:100","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$54911","typeString":"contract FetchChainInfoOutput"}},"id":55184,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"16316:21:100","memberName":"superchainConfigProxy","nodeType":"MemberAccess","referencedDeclaration":54627,"src":"16312:25:100","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":55185,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"16338:8:100","memberName":"selector","nodeType":"MemberAccess","src":"16312:34:100","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},{"id":55186,"name":"superchainConfigProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55175,"src":"16348:21:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_bytes4","typeString":"bytes4"},{"typeIdentifier":"t_address","typeString":"address"}],"expression":{"id":55180,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55079,"src":"16304:3:100","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$54911","typeString":"contract FetchChainInfoOutput"}},"id":55182,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"16308:3:100","memberName":"set","nodeType":"MemberAccess","referencedDeclaration":54384,"src":"16304:7:100","typeDescriptions":{"typeIdentifier":"t_function_external_nonpayable$_t_bytes4_$_t_address_$returns$__$","typeString":"function (bytes4,address) external"}},"id":55187,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"16304:66:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":55188,"nodeType":"ExpressionStatement","src":"16304:66:100"}]},"implemented":true,"kind":"function","modifiers":[],"name":"_processMessengerAndPortal","nameLocation":"15196:26:100","parameters":{"id":55080,"nodeType":"ParameterList","parameters":[{"constant":false,"id":55076,"mutability":"mutable","name":"_fi","nameLocation":"15243:3:100","nodeType":"VariableDeclaration","scope":55190,"src":"15223:23:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoInput_$54041","typeString":"contract FetchChainInfoInput"},"typeName":{"id":55075,"nodeType":"UserDefinedTypeName","pathNode":{"id":55074,"name":"FetchChainInfoInput","nameLocations":["15223:19:100"],"nodeType":"IdentifierPath","referencedDeclaration":54041,"src":"15223:19:100"},"referencedDeclaration":54041,"src":"15223:19:100","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoInput_$54041","typeString":"contract FetchChainInfoInput"}},"visibility":"internal"},{"constant":false,"id":55079,"mutability":"mutable","name":"_fo","nameLocation":"15269:3:100","nodeType":"VariableDeclaration","scope":55190,"src":"15248:24:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$54911","typeString":"contract FetchChainInfoOutput"},"typeName":{"id":55078,"nodeType":"UserDefinedTypeName","pathNode":{"id":55077,"name":"FetchChainInfoOutput","nameLocations":["15248:20:100"],"nodeType":"IdentifierPath","referencedDeclaration":54911,"src":"15248:20:100"},"referencedDeclaration":54911,"src":"15248:20:100","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$54911","typeString":"contract FetchChainInfoOutput"}},"visibility":"internal"}],"src":"15222:51:100"},"returnParameters":{"id":55081,"nodeType":"ParameterList","parameters":[],"src":"15283:0:100"},"scope":56018,"stateMutability":"nonpayable","virtual":false,"visibility":"internal"},{"id":55565,"nodeType":"FunctionDefinition","src":"16383:4033:100","nodes":[],"body":{"id":55564,"nodeType":"Block","src":"16447:3969:100","nodes":[],"statements":[{"assignments":[55197],"declarations":[{"constant":false,"id":55197,"mutability":"mutable","name":"systemConfigProxy","nameLocation":"16465:17:100","nodeType":"VariableDeclaration","scope":55564,"src":"16457:25:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":55196,"name":"address","nodeType":"ElementaryTypeName","src":"16457:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"id":55201,"initialValue":{"arguments":[],"expression":{"argumentTypes":[],"expression":{"id":55198,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55193,"src":"16485:3:100","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$54911","typeString":"contract FetchChainInfoOutput"}},"id":55199,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"16489:17:100","memberName":"systemConfigProxy","nodeType":"MemberAccess","referencedDeclaration":54591,"src":"16485:21:100","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":55200,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"16485:23:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"VariableDeclarationStatement","src":"16457:51:100"},{"assignments":[55203],"declarations":[{"constant":false,"id":55203,"mutability":"mutable","name":"optimismPortalProxy","nameLocation":"16526:19:100","nodeType":"VariableDeclaration","scope":55564,"src":"16518:27:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":55202,"name":"address","nodeType":"ElementaryTypeName","src":"16518:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"id":55207,"initialValue":{"arguments":[],"expression":{"argumentTypes":[],"expression":{"id":55204,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55193,"src":"16548:3:100","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$54911","typeString":"contract FetchChainInfoOutput"}},"id":55205,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"16552:19:100","memberName":"optimismPortalProxy","nodeType":"MemberAccess","referencedDeclaration":54573,"src":"16548:23:100","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":55206,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"16548:25:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"VariableDeclarationStatement","src":"16518:55:100"},{"clauses":[{"block":{"id":55226,"nodeType":"Block","src":"16667:75:100","statements":[{"expression":{"arguments":[{"expression":{"expression":{"id":55220,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55193,"src":"16689:3:100","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$54911","typeString":"contract FetchChainInfoOutput"}},"id":55221,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"16693:17:100","memberName":"respectedGameType","nodeType":"MemberAccess","referencedDeclaration":54910,"src":"16689:21:100","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_userDefinedValueType$_GameType_$70720_$","typeString":"function () view external returns (GameType)"}},"id":55222,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"16711:8:100","memberName":"selector","nodeType":"MemberAccess","src":"16689:30:100","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},{"id":55223,"name":"gameType_","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55215,"src":"16721:9:100","typeDescriptions":{"typeIdentifier":"t_userDefinedValueType$_GameType_$70720","typeString":"GameType"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_bytes4","typeString":"bytes4"},{"typeIdentifier":"t_userDefinedValueType$_GameType_$70720","typeString":"GameType"}],"expression":{"id":55217,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55193,"src":"16681:3:100","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$54911","typeString":"contract FetchChainInfoOutput"}},"id":55219,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"16685:3:100","memberName":"set","nodeType":"MemberAccess","referencedDeclaration":54439,"src":"16681:7:100","typeDescriptions":{"typeIdentifier":"t_function_external_nonpayable$_t_bytes4_$_t_userDefinedValueType$_GameType_$70720_$returns$__$","typeString":"function (bytes4,GameType) external"}},"id":55224,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"16681:50:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":55225,"nodeType":"ExpressionStatement","src":"16681:50:100"}]},"errorName":"","id":55227,"nodeType":"TryCatchClause","parameters":{"id":55216,"nodeType":"ParameterList","parameters":[{"constant":false,"id":55215,"mutability":"mutable","name":"gameType_","nameLocation":"16656:9:100","nodeType":"VariableDeclaration","scope":55227,"src":"16647:18:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_userDefinedValueType$_GameType_$70720","typeString":"GameType"},"typeName":{"id":55214,"nodeType":"UserDefinedTypeName","pathNode":{"id":55213,"name":"GameType","nameLocations":["16647:8:100"],"nodeType":"IdentifierPath","referencedDeclaration":70720,"src":"16647:8:100"},"referencedDeclaration":70720,"src":"16647:8:100","typeDescriptions":{"typeIdentifier":"t_userDefinedValueType$_GameType_$70720","typeString":"GameType"}},"visibility":"internal"}],"src":"16646:20:100"},"src":"16638:104:100"},{"block":{"id":55299,"nodeType":"Block","src":"16749:744:100","statements":[{"expression":{"arguments":[{"expression":{"expression":{"id":55231,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55193,"src":"16844:3:100","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$54911","typeString":"contract FetchChainInfoOutput"}},"id":55232,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"16848:17:100","memberName":"respectedGameType","nodeType":"MemberAccess","referencedDeclaration":54910,"src":"16844:21:100","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_userDefinedValueType$_GameType_$70720_$","typeString":"function () view external returns (GameType)"}},"id":55233,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"16866:8:100","memberName":"selector","nodeType":"MemberAccess","src":"16844:30:100","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},{"arguments":[{"expression":{"arguments":[{"id":55238,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"nodeType":"ElementaryTypeNameExpression","src":"16895:6:100","typeDescriptions":{"typeIdentifier":"t_type$_t_uint32_$","typeString":"type(uint32)"},"typeName":{"id":55237,"name":"uint32","nodeType":"ElementaryTypeName","src":"16895:6:100","typeDescriptions":{}}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_type$_t_uint32_$","typeString":"type(uint32)"}],"id":55236,"name":"type","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":-27,"src":"16890:4:100","typeDescriptions":{"typeIdentifier":"t_function_metatype_pure$__$returns$__$","typeString":"function () pure"}},"id":55239,"isConstant":false,"isLValue":false,"isPure":true,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"16890:12:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_magic_meta_type_t_uint32","typeString":"type(uint32)"}},"id":55240,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"memberLocation":"16903:3:100","memberName":"max","nodeType":"MemberAccess","src":"16890:16:100","typeDescriptions":{"typeIdentifier":"t_uint32","typeString":"uint32"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_uint32","typeString":"uint32"}],"expression":{"id":55234,"name":"GameType","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":70720,"src":"16876:8:100","typeDescriptions":{"typeIdentifier":"t_type$_t_userDefinedValueType$_GameType_$70720_$","typeString":"type(GameType)"}},"id":55235,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"memberLocation":"16885:4:100","memberName":"wrap","nodeType":"MemberAccess","src":"16876:13:100","typeDescriptions":{"typeIdentifier":"t_function_wrap_pure$_t_uint32_$returns$_t_userDefinedValueType$_GameType_$70720_$","typeString":"function (uint32) pure returns (GameType)"}},"id":55241,"isConstant":false,"isLValue":false,"isPure":true,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"16876:31:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_userDefinedValueType$_GameType_$70720","typeString":"GameType"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_bytes4","typeString":"bytes4"},{"typeIdentifier":"t_userDefinedValueType$_GameType_$70720","typeString":"GameType"}],"expression":{"id":55228,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55193,"src":"16836:3:100","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$54911","typeString":"contract FetchChainInfoOutput"}},"id":55230,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"16840:3:100","memberName":"set","nodeType":"MemberAccess","referencedDeclaration":54439,"src":"16836:7:100","typeDescriptions":{"typeIdentifier":"t_function_external_nonpayable$_t_bytes4_$_t_userDefinedValueType$_GameType_$70720_$returns$__$","typeString":"function (bytes4,GameType) external"}},"id":55242,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"16836:72:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":55243,"nodeType":"ExpressionStatement","src":"16836:72:100"},{"assignments":[55245],"declarations":[{"constant":false,"id":55245,"mutability":"mutable","name":"l2OutputOracleProxy","nameLocation":"16930:19:100","nodeType":"VariableDeclaration","scope":55299,"src":"16922:27:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":55244,"name":"address","nodeType":"ElementaryTypeName","src":"16922:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"id":55246,"nodeType":"VariableDeclarationStatement","src":"16922:27:100"},{"clauses":[{"block":{"id":55259,"nodeType":"Block","src":"17036:64:100","statements":[{"expression":{"id":55257,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftHandSide":{"id":55255,"name":"l2OutputOracleProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55245,"src":"17054:19:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"Assignment","operator":"=","rightHandSide":{"id":55256,"name":"l2Oracle_","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55253,"src":"17076:9:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"src":"17054:31:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"id":55258,"nodeType":"ExpressionStatement","src":"17054:31:100"}]},"errorName":"","id":55260,"nodeType":"TryCatchClause","parameters":{"id":55254,"nodeType":"ParameterList","parameters":[{"constant":false,"id":55253,"mutability":"mutable","name":"l2Oracle_","nameLocation":"17025:9:100","nodeType":"VariableDeclaration","scope":55260,"src":"17017:17:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":55252,"name":"address","nodeType":"ElementaryTypeName","src":"17017:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"17016:19:100"},"src":"17008:92:100"},{"block":{"id":55269,"nodeType":"Block","src":"17107:96:100","statements":[{"expression":{"id":55267,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftHandSide":{"id":55261,"name":"l2OutputOracleProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55245,"src":"17125:19:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"Assignment","operator":"=","rightHandSide":{"arguments":[],"expression":{"argumentTypes":[],"expression":{"arguments":[{"id":55263,"name":"optimismPortalProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55203,"src":"17156:19:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_address","typeString":"address"}],"id":55262,"name":"IFetcher","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":53958,"src":"17147:8:100","typeDescriptions":{"typeIdentifier":"t_type$_t_contract$_IFetcher_$53958_$","typeString":"type(contract IFetcher)"}},"id":55264,"isConstant":false,"isLValue":false,"isPure":false,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"17147:29:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_contract$_IFetcher_$53958","typeString":"contract IFetcher"}},"id":55265,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"17177:9:100","memberName":"L2_ORACLE","nodeType":"MemberAccess","referencedDeclaration":53902,"src":"17147:39:100","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":55266,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"17147:41:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"src":"17125:63:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"id":55268,"nodeType":"ExpressionStatement","src":"17125:63:100"}]},"errorName":"","id":55270,"nodeType":"TryCatchClause","src":"17101:102:100"}],"externalCall":{"arguments":[],"expression":{"argumentTypes":[],"expression":{"arguments":[{"id":55248,"name":"optimismPortalProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55203,"src":"16976:19:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_address","typeString":"address"}],"id":55247,"name":"IFetcher","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":53958,"src":"16967:8:100","typeDescriptions":{"typeIdentifier":"t_type$_t_contract$_IFetcher_$53958_$","typeString":"type(contract IFetcher)"}},"id":55249,"isConstant":false,"isLValue":false,"isPure":false,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"16967:29:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_contract$_IFetcher_$53958","typeString":"contract IFetcher"}},"id":55250,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"16997:8:100","memberName":"l2Oracle","nodeType":"MemberAccess","referencedDeclaration":53907,"src":"16967:38:100","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":55251,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"16967:40:100","tryCall":true,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"id":55271,"nodeType":"TryStatement","src":"16963:240:100"},{"expression":{"arguments":[{"expression":{"expression":{"id":55275,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55193,"src":"17224:3:100","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$54911","typeString":"contract FetchChainInfoOutput"}},"id":55276,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"17228:19:100","memberName":"l2OutputOracleProxy","nodeType":"MemberAccess","referencedDeclaration":54537,"src":"17224:23:100","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":55277,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"17248:8:100","memberName":"selector","nodeType":"MemberAccess","src":"17224:32:100","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},{"id":55278,"name":"l2OutputOracleProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55245,"src":"17258:19:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_bytes4","typeString":"bytes4"},{"typeIdentifier":"t_address","typeString":"address"}],"expression":{"id":55272,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55193,"src":"17216:3:100","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$54911","typeString":"contract FetchChainInfoOutput"}},"id":55274,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"17220:3:100","memberName":"set","nodeType":"MemberAccess","referencedDeclaration":54384,"src":"17216:7:100","typeDescriptions":{"typeIdentifier":"t_function_external_nonpayable$_t_bytes4_$_t_address_$returns$__$","typeString":"function (bytes4,address) external"}},"id":55279,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"17216:62:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":55280,"nodeType":"ExpressionStatement","src":"17216:62:100"},{"assignments":[55282],"declarations":[{"constant":false,"id":55282,"mutability":"mutable","name":"proposer","nameLocation":"17301:8:100","nodeType":"VariableDeclaration","scope":55299,"src":"17293:16:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":55281,"name":"address","nodeType":"ElementaryTypeName","src":"17293:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"id":55288,"initialValue":{"arguments":[],"expression":{"argumentTypes":[],"expression":{"arguments":[{"id":55284,"name":"l2OutputOracleProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55245,"src":"17321:19:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_address","typeString":"address"}],"id":55283,"name":"IFetcher","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":53958,"src":"17312:8:100","typeDescriptions":{"typeIdentifier":"t_type$_t_contract$_IFetcher_$53958_$","typeString":"type(contract IFetcher)"}},"id":55285,"isConstant":false,"isLValue":false,"isPure":false,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"17312:29:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_contract$_IFetcher_$53958","typeString":"contract IFetcher"}},"id":55286,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"17342:8:100","memberName":"PROPOSER","nodeType":"MemberAccess","referencedDeclaration":53932,"src":"17312:38:100","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":55287,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"17312:40:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"VariableDeclarationStatement","src":"17293:59:100"},{"expression":{"arguments":[{"expression":{"expression":{"id":55292,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55193,"src":"17374:3:100","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$54911","typeString":"contract FetchChainInfoOutput"}},"id":55293,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"17378:8:100","memberName":"proposer","nodeType":"MemberAccess","referencedDeclaration":54849,"src":"17374:12:100","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":55294,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"17387:8:100","memberName":"selector","nodeType":"MemberAccess","src":"17374:21:100","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},{"id":55295,"name":"proposer","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55282,"src":"17397:8:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_bytes4","typeString":"bytes4"},{"typeIdentifier":"t_address","typeString":"address"}],"expression":{"id":55289,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55193,"src":"17366:3:100","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$54911","typeString":"contract FetchChainInfoOutput"}},"id":55291,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"17370:3:100","memberName":"set","nodeType":"MemberAccess","referencedDeclaration":54384,"src":"17366:7:100","typeDescriptions":{"typeIdentifier":"t_function_external_nonpayable$_t_bytes4_$_t_address_$returns$__$","typeString":"function (bytes4,address) external"}},"id":55296,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"17366:40:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":55297,"nodeType":"ExpressionStatement","src":"17366:40:100"},{"functionReturnParameters":55195,"id":55298,"nodeType":"Return","src":"17476:7:100"}]},"errorName":"","id":55300,"nodeType":"TryCatchClause","src":"16743:750:100"}],"externalCall":{"arguments":[],"expression":{"argumentTypes":[],"expression":{"arguments":[{"id":55209,"name":"optimismPortalProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55203,"src":"16597:19:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_address","typeString":"address"}],"id":55208,"name":"IFetcher","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":53958,"src":"16588:8:100","typeDescriptions":{"typeIdentifier":"t_type$_t_contract$_IFetcher_$53958_$","typeString":"type(contract IFetcher)"}},"id":55210,"isConstant":false,"isLValue":false,"isPure":false,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"16588:29:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_contract$_IFetcher_$53958","typeString":"contract IFetcher"}},"id":55211,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"16618:17:100","memberName":"respectedGameType","nodeType":"MemberAccess","referencedDeclaration":53892,"src":"16588:47:100","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_userDefinedValueType$_GameType_$70720_$","typeString":"function () view external returns (GameType)"}},"id":55212,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"16588:49:100","tryCall":true,"typeDescriptions":{"typeIdentifier":"t_userDefinedValueType$_GameType_$70720","typeString":"GameType"}},"id":55301,"nodeType":"TryStatement","src":"16584:909:100"},{"assignments":[55303],"declarations":[{"constant":false,"id":55303,"mutability":"mutable","name":"disputeGameFactoryProxy","nameLocation":"17511:23:100","nodeType":"VariableDeclaration","scope":55564,"src":"17503:31:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":55302,"name":"address","nodeType":"ElementaryTypeName","src":"17503:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"id":55307,"initialValue":{"arguments":[{"id":55305,"name":"systemConfigProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55197,"src":"17565:17:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_address","typeString":"address"}],"id":55304,"name":"_getDisputeGameFactoryProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55774,"src":"17537:27:100","typeDescriptions":{"typeIdentifier":"t_function_internal_view$_t_address_$returns$_t_address_$","typeString":"function (address) view returns (address)"}},"id":55306,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"17537:46:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"VariableDeclarationStatement","src":"17503:80:100"},{"condition":{"commonType":{"typeIdentifier":"t_address","typeString":"address"},"id":55313,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftExpression":{"id":55308,"name":"disputeGameFactoryProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55303,"src":"17597:23:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"BinaryOperation","operator":"!=","rightExpression":{"arguments":[{"hexValue":"30","id":55311,"isConstant":false,"isLValue":false,"isPure":true,"kind":"number","lValueRequested":false,"nodeType":"Literal","src":"17632:1:100","typeDescriptions":{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"},"value":"0"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"}],"id":55310,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"nodeType":"ElementaryTypeNameExpression","src":"17624:7:100","typeDescriptions":{"typeIdentifier":"t_type$_t_address_$","typeString":"type(address)"},"typeName":{"id":55309,"name":"address","nodeType":"ElementaryTypeName","src":"17624:7:100","typeDescriptions":{}}},"id":55312,"isConstant":false,"isLValue":false,"isPure":true,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"17624:10:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"src":"17597:37:100","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},"falseBody":{"id":55562,"nodeType":"Block","src":"20027:383:100","statements":[{"assignments":[55529],"declarations":[{"constant":false,"id":55529,"mutability":"mutable","name":"l2OutputOracleProxy","nameLocation":"20133:19:100","nodeType":"VariableDeclaration","scope":55562,"src":"20125:27:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":55528,"name":"address","nodeType":"ElementaryTypeName","src":"20125:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"id":55535,"initialValue":{"arguments":[],"expression":{"argumentTypes":[],"expression":{"arguments":[{"id":55531,"name":"optimismPortalProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55203,"src":"20164:19:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_address","typeString":"address"}],"id":55530,"name":"IFetcher","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":53958,"src":"20155:8:100","typeDescriptions":{"typeIdentifier":"t_type$_t_contract$_IFetcher_$53958_$","typeString":"type(contract IFetcher)"}},"id":55532,"isConstant":false,"isLValue":false,"isPure":false,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"20155:29:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_contract$_IFetcher_$53958","typeString":"contract IFetcher"}},"id":55533,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"20185:9:100","memberName":"L2_ORACLE","nodeType":"MemberAccess","referencedDeclaration":53902,"src":"20155:39:100","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":55534,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"20155:41:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"VariableDeclarationStatement","src":"20125:71:100"},{"expression":{"arguments":[{"expression":{"expression":{"id":55539,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55193,"src":"20218:3:100","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$54911","typeString":"contract FetchChainInfoOutput"}},"id":55540,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"20222:19:100","memberName":"l2OutputOracleProxy","nodeType":"MemberAccess","referencedDeclaration":54537,"src":"20218:23:100","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":55541,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"20242:8:100","memberName":"selector","nodeType":"MemberAccess","src":"20218:32:100","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},{"id":55542,"name":"l2OutputOracleProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55529,"src":"20252:19:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_bytes4","typeString":"bytes4"},{"typeIdentifier":"t_address","typeString":"address"}],"expression":{"id":55536,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55193,"src":"20210:3:100","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$54911","typeString":"contract FetchChainInfoOutput"}},"id":55538,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"20214:3:100","memberName":"set","nodeType":"MemberAccess","referencedDeclaration":54384,"src":"20210:7:100","typeDescriptions":{"typeIdentifier":"t_function_external_nonpayable$_t_bytes4_$_t_address_$returns$__$","typeString":"function (bytes4,address) external"}},"id":55543,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"20210:62:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":55544,"nodeType":"ExpressionStatement","src":"20210:62:100"},{"assignments":[55546],"declarations":[{"constant":false,"id":55546,"mutability":"mutable","name":"proposer","nameLocation":"20294:8:100","nodeType":"VariableDeclaration","scope":55562,"src":"20286:16:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":55545,"name":"address","nodeType":"ElementaryTypeName","src":"20286:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"id":55552,"initialValue":{"arguments":[],"expression":{"argumentTypes":[],"expression":{"arguments":[{"id":55548,"name":"l2OutputOracleProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55529,"src":"20314:19:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_address","typeString":"address"}],"id":55547,"name":"IFetcher","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":53958,"src":"20305:8:100","typeDescriptions":{"typeIdentifier":"t_type$_t_contract$_IFetcher_$53958_$","typeString":"type(contract IFetcher)"}},"id":55549,"isConstant":false,"isLValue":false,"isPure":false,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"20305:29:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_contract$_IFetcher_$53958","typeString":"contract IFetcher"}},"id":55550,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"20335:8:100","memberName":"PROPOSER","nodeType":"MemberAccess","referencedDeclaration":53932,"src":"20305:38:100","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":55551,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"20305:40:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"VariableDeclarationStatement","src":"20286:59:100"},{"expression":{"arguments":[{"expression":{"expression":{"id":55556,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55193,"src":"20367:3:100","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$54911","typeString":"contract FetchChainInfoOutput"}},"id":55557,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"20371:8:100","memberName":"proposer","nodeType":"MemberAccess","referencedDeclaration":54849,"src":"20367:12:100","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":55558,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"20380:8:100","memberName":"selector","nodeType":"MemberAccess","src":"20367:21:100","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},{"id":55559,"name":"proposer","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55546,"src":"20390:8:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_bytes4","typeString":"bytes4"},{"typeIdentifier":"t_address","typeString":"address"}],"expression":{"id":55553,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55193,"src":"20359:3:100","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$54911","typeString":"contract FetchChainInfoOutput"}},"id":55555,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"20363:3:100","memberName":"set","nodeType":"MemberAccess","referencedDeclaration":54384,"src":"20359:7:100","typeDescriptions":{"typeIdentifier":"t_function_external_nonpayable$_t_bytes4_$_t_address_$returns$__$","typeString":"function (bytes4,address) external"}},"id":55560,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"20359:40:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":55561,"nodeType":"ExpressionStatement","src":"20359:40:100"}]},"id":55563,"nodeType":"IfStatement","src":"17593:2817:100","trueBody":{"id":55527,"nodeType":"Block","src":"17636:2385:100","statements":[{"expression":{"arguments":[{"expression":{"expression":{"id":55317,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55193,"src":"17658:3:100","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$54911","typeString":"contract FetchChainInfoOutput"}},"id":55318,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"17662:23:100","memberName":"disputeGameFactoryProxy","nodeType":"MemberAccess","referencedDeclaration":54669,"src":"17658:27:100","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":55319,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"17686:8:100","memberName":"selector","nodeType":"MemberAccess","src":"17658:36:100","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},{"id":55320,"name":"disputeGameFactoryProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55303,"src":"17696:23:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_bytes4","typeString":"bytes4"},{"typeIdentifier":"t_address","typeString":"address"}],"expression":{"id":55314,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55193,"src":"17650:3:100","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$54911","typeString":"contract FetchChainInfoOutput"}},"id":55316,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"17654:3:100","memberName":"set","nodeType":"MemberAccess","referencedDeclaration":54384,"src":"17650:7:100","typeDescriptions":{"typeIdentifier":"t_function_external_nonpayable$_t_bytes4_$_t_address_$returns$__$","typeString":"function (bytes4,address) external"}},"id":55321,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"17650:70:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":55322,"nodeType":"ExpressionStatement","src":"17650:70:100"},{"assignments":[55324],"declarations":[{"constant":false,"id":55324,"mutability":"mutable","name":"permissionedDisputeGameImpl","nameLocation":"17743:27:100","nodeType":"VariableDeclaration","scope":55527,"src":"17735:35:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":55323,"name":"address","nodeType":"ElementaryTypeName","src":"17735:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"id":55328,"initialValue":{"arguments":[{"id":55326,"name":"disputeGameFactoryProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55303,"src":"17801:23:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_address","typeString":"address"}],"id":55325,"name":"_getPermissionedDisputeGame","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55894,"src":"17773:27:100","typeDescriptions":{"typeIdentifier":"t_function_internal_view$_t_address_$returns$_t_address_$","typeString":"function (address) view returns (address)"}},"id":55327,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"17773:52:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"VariableDeclarationStatement","src":"17735:90:100"},{"condition":{"commonType":{"typeIdentifier":"t_address","typeString":"address"},"id":55334,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftExpression":{"id":55329,"name":"permissionedDisputeGameImpl","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55324,"src":"17843:27:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"BinaryOperation","operator":"!=","rightExpression":{"arguments":[{"hexValue":"30","id":55332,"isConstant":false,"isLValue":false,"isPure":true,"kind":"number","lValueRequested":false,"nodeType":"Literal","src":"17882:1:100","typeDescriptions":{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"},"value":"0"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"}],"id":55331,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"nodeType":"ElementaryTypeNameExpression","src":"17874:7:100","typeDescriptions":{"typeIdentifier":"t_type$_t_address_$","typeString":"type(address)"},"typeName":{"id":55330,"name":"address","nodeType":"ElementaryTypeName","src":"17874:7:100","typeDescriptions":{}}},"id":55333,"isConstant":false,"isLValue":false,"isPure":true,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"17874:10:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"src":"17843:41:100","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},"id":55454,"nodeType":"IfStatement","src":"17839:1278:100","trueBody":{"id":55453,"nodeType":"Block","src":"17886:1231:100","statements":[{"expression":{"arguments":[{"expression":{"expression":{"id":55338,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55193,"src":"17967:3:100","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$54911","typeString":"contract FetchChainInfoOutput"}},"id":55339,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"17971:12:100","memberName":"permissioned","nodeType":"MemberAccess","referencedDeclaration":54893,"src":"17967:16:100","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_bool_$","typeString":"function () view external returns (bool)"}},"id":55340,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"17984:8:100","memberName":"selector","nodeType":"MemberAccess","src":"17967:25:100","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},{"hexValue":"74727565","id":55341,"isConstant":false,"isLValue":false,"isPure":true,"kind":"bool","lValueRequested":false,"nodeType":"Literal","src":"17994:4:100","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"},"value":"true"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_bytes4","typeString":"bytes4"},{"typeIdentifier":"t_bool","typeString":"bool"}],"expression":{"id":55335,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55193,"src":"17959:3:100","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$54911","typeString":"contract FetchChainInfoOutput"}},"id":55337,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"17963:3:100","memberName":"set","nodeType":"MemberAccess","referencedDeclaration":54416,"src":"17959:7:100","typeDescriptions":{"typeIdentifier":"t_function_external_nonpayable$_t_bytes4_$_t_bool_$returns$__$","typeString":"function (bytes4,bool) external"}},"id":55342,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"17959:40:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":55343,"nodeType":"ExpressionStatement","src":"17959:40:100"},{"expression":{"arguments":[{"expression":{"expression":{"id":55347,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55193,"src":"18025:3:100","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$54911","typeString":"contract FetchChainInfoOutput"}},"id":55348,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"18029:27:100","memberName":"permissionedDisputeGameImpl","nodeType":"MemberAccess","referencedDeclaration":54741,"src":"18025:31:100","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":55349,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"18057:8:100","memberName":"selector","nodeType":"MemberAccess","src":"18025:40:100","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},{"id":55350,"name":"permissionedDisputeGameImpl","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55324,"src":"18067:27:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_bytes4","typeString":"bytes4"},{"typeIdentifier":"t_address","typeString":"address"}],"expression":{"id":55344,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55193,"src":"18017:3:100","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$54911","typeString":"contract FetchChainInfoOutput"}},"id":55346,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"18021:3:100","memberName":"set","nodeType":"MemberAccess","referencedDeclaration":54384,"src":"18017:7:100","typeDescriptions":{"typeIdentifier":"t_function_external_nonpayable$_t_bytes4_$_t_address_$returns$__$","typeString":"function (bytes4,address) external"}},"id":55351,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"18017:78:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":55352,"nodeType":"ExpressionStatement","src":"18017:78:100"},{"assignments":[55354],"declarations":[{"constant":false,"id":55354,"mutability":"mutable","name":"challenger","nameLocation":"18122:10:100","nodeType":"VariableDeclaration","scope":55453,"src":"18114:18:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":55353,"name":"address","nodeType":"ElementaryTypeName","src":"18114:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"id":55360,"initialValue":{"arguments":[],"expression":{"argumentTypes":[],"expression":{"arguments":[{"id":55356,"name":"permissionedDisputeGameImpl","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55324,"src":"18144:27:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_address","typeString":"address"}],"id":55355,"name":"IFetcher","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":53958,"src":"18135:8:100","typeDescriptions":{"typeIdentifier":"t_type$_t_contract$_IFetcher_$53958_$","typeString":"type(contract IFetcher)"}},"id":55357,"isConstant":false,"isLValue":false,"isPure":false,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"18135:37:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_contract$_IFetcher_$53958","typeString":"contract IFetcher"}},"id":55358,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"18173:10:100","memberName":"challenger","nodeType":"MemberAccess","referencedDeclaration":53922,"src":"18135:48:100","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":55359,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"18135:50:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"VariableDeclarationStatement","src":"18114:71:100"},{"expression":{"arguments":[{"expression":{"expression":{"id":55364,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55193,"src":"18211:3:100","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$54911","typeString":"contract FetchChainInfoOutput"}},"id":55365,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"18215:10:100","memberName":"challenger","nodeType":"MemberAccess","referencedDeclaration":54831,"src":"18211:14:100","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":55366,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"18226:8:100","memberName":"selector","nodeType":"MemberAccess","src":"18211:23:100","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},{"id":55367,"name":"challenger","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55354,"src":"18236:10:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_bytes4","typeString":"bytes4"},{"typeIdentifier":"t_address","typeString":"address"}],"expression":{"id":55361,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55193,"src":"18203:3:100","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$54911","typeString":"contract FetchChainInfoOutput"}},"id":55363,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"18207:3:100","memberName":"set","nodeType":"MemberAccess","referencedDeclaration":54384,"src":"18203:7:100","typeDescriptions":{"typeIdentifier":"t_function_external_nonpayable$_t_bytes4_$_t_address_$returns$__$","typeString":"function (bytes4,address) external"}},"id":55368,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"18203:44:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":55369,"nodeType":"ExpressionStatement","src":"18203:44:100"},{"assignments":[55371],"declarations":[{"constant":false,"id":55371,"mutability":"mutable","name":"anchorStateRegistryProxy","nameLocation":"18274:24:100","nodeType":"VariableDeclaration","scope":55453,"src":"18266:32:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":55370,"name":"address","nodeType":"ElementaryTypeName","src":"18266:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"id":55377,"initialValue":{"arguments":[],"expression":{"argumentTypes":[],"expression":{"arguments":[{"id":55373,"name":"permissionedDisputeGameImpl","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55324,"src":"18310:27:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_address","typeString":"address"}],"id":55372,"name":"IFetcher","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":53958,"src":"18301:8:100","typeDescriptions":{"typeIdentifier":"t_type$_t_contract$_IFetcher_$53958_$","typeString":"type(contract IFetcher)"}},"id":55374,"isConstant":false,"isLValue":false,"isPure":false,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"18301:37:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_contract$_IFetcher_$53958","typeString":"contract IFetcher"}},"id":55375,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"18339:19:100","memberName":"anchorStateRegistry","nodeType":"MemberAccess","referencedDeclaration":53897,"src":"18301:57:100","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":55376,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"18301:59:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"VariableDeclarationStatement","src":"18266:94:100"},{"expression":{"arguments":[{"expression":{"expression":{"id":55381,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55193,"src":"18386:3:100","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$54911","typeString":"contract FetchChainInfoOutput"}},"id":55382,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"18390:24:100","memberName":"anchorStateRegistryProxy","nodeType":"MemberAccess","referencedDeclaration":54645,"src":"18386:28:100","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":55383,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"18415:8:100","memberName":"selector","nodeType":"MemberAccess","src":"18386:37:100","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},{"id":55384,"name":"anchorStateRegistryProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55371,"src":"18425:24:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_bytes4","typeString":"bytes4"},{"typeIdentifier":"t_address","typeString":"address"}],"expression":{"id":55378,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55193,"src":"18378:3:100","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$54911","typeString":"contract FetchChainInfoOutput"}},"id":55380,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"18382:3:100","memberName":"set","nodeType":"MemberAccess","referencedDeclaration":54384,"src":"18378:7:100","typeDescriptions":{"typeIdentifier":"t_function_external_nonpayable$_t_bytes4_$_t_address_$returns$__$","typeString":"function (bytes4,address) external"}},"id":55385,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"18378:72:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":55386,"nodeType":"ExpressionStatement","src":"18378:72:100"},{"assignments":[55388],"declarations":[{"constant":false,"id":55388,"mutability":"mutable","name":"proposer","nameLocation":"18477:8:100","nodeType":"VariableDeclaration","scope":55453,"src":"18469:16:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":55387,"name":"address","nodeType":"ElementaryTypeName","src":"18469:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"id":55394,"initialValue":{"arguments":[],"expression":{"argumentTypes":[],"expression":{"arguments":[{"id":55390,"name":"permissionedDisputeGameImpl","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55324,"src":"18497:27:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_address","typeString":"address"}],"id":55389,"name":"IFetcher","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":53958,"src":"18488:8:100","typeDescriptions":{"typeIdentifier":"t_type$_t_contract$_IFetcher_$53958_$","typeString":"type(contract IFetcher)"}},"id":55391,"isConstant":false,"isLValue":false,"isPure":false,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"18488:37:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_contract$_IFetcher_$53958","typeString":"contract IFetcher"}},"id":55392,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"18526:8:100","memberName":"proposer","nodeType":"MemberAccess","referencedDeclaration":53927,"src":"18488:46:100","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":55393,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"18488:48:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"VariableDeclarationStatement","src":"18469:67:100"},{"expression":{"arguments":[{"expression":{"expression":{"id":55398,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55193,"src":"18562:3:100","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$54911","typeString":"contract FetchChainInfoOutput"}},"id":55399,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"18566:8:100","memberName":"proposer","nodeType":"MemberAccess","referencedDeclaration":54849,"src":"18562:12:100","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":55400,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"18575:8:100","memberName":"selector","nodeType":"MemberAccess","src":"18562:21:100","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},{"id":55401,"name":"proposer","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55388,"src":"18585:8:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_bytes4","typeString":"bytes4"},{"typeIdentifier":"t_address","typeString":"address"}],"expression":{"id":55395,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55193,"src":"18554:3:100","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$54911","typeString":"contract FetchChainInfoOutput"}},"id":55397,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"18558:3:100","memberName":"set","nodeType":"MemberAccess","referencedDeclaration":54384,"src":"18554:7:100","typeDescriptions":{"typeIdentifier":"t_function_external_nonpayable$_t_bytes4_$_t_address_$returns$__$","typeString":"function (bytes4,address) external"}},"id":55402,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"18554:40:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":55403,"nodeType":"ExpressionStatement","src":"18554:40:100"},{"assignments":[55405],"declarations":[{"constant":false,"id":55405,"mutability":"mutable","name":"delayedWethPermissionedGameProxy","nameLocation":"18621:32:100","nodeType":"VariableDeclaration","scope":55453,"src":"18613:40:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":55404,"name":"address","nodeType":"ElementaryTypeName","src":"18613:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"id":55409,"initialValue":{"arguments":[{"id":55407,"name":"permissionedDisputeGameImpl","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55324,"src":"18677:27:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_address","typeString":"address"}],"id":55406,"name":"_getDelayedWETHProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55967,"src":"18656:20:100","typeDescriptions":{"typeIdentifier":"t_function_internal_view$_t_address_$returns$_t_address_$","typeString":"function (address) view returns (address)"}},"id":55408,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"18656:49:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"VariableDeclarationStatement","src":"18613:92:100"},{"expression":{"arguments":[{"expression":{"expression":{"id":55413,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55193,"src":"18731:3:100","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$54911","typeString":"contract FetchChainInfoOutput"}},"id":55414,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"18735:32:100","memberName":"delayedWethPermissionedGameProxy","nodeType":"MemberAccess","referencedDeclaration":54653,"src":"18731:36:100","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":55415,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"18768:8:100","memberName":"selector","nodeType":"MemberAccess","src":"18731:45:100","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},{"id":55416,"name":"delayedWethPermissionedGameProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55405,"src":"18778:32:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_bytes4","typeString":"bytes4"},{"typeIdentifier":"t_address","typeString":"address"}],"expression":{"id":55410,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55193,"src":"18723:3:100","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$54911","typeString":"contract FetchChainInfoOutput"}},"id":55412,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"18727:3:100","memberName":"set","nodeType":"MemberAccess","referencedDeclaration":54384,"src":"18723:7:100","typeDescriptions":{"typeIdentifier":"t_function_external_nonpayable$_t_bytes4_$_t_address_$returns$__$","typeString":"function (bytes4,address) external"}},"id":55417,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"18723:88:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":55418,"nodeType":"ExpressionStatement","src":"18723:88:100"},{"assignments":[55420],"declarations":[{"constant":false,"id":55420,"mutability":"mutable","name":"mipsImpl","nameLocation":"18838:8:100","nodeType":"VariableDeclaration","scope":55453,"src":"18830:16:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":55419,"name":"address","nodeType":"ElementaryTypeName","src":"18830:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"id":55426,"initialValue":{"arguments":[],"expression":{"argumentTypes":[],"expression":{"arguments":[{"id":55422,"name":"permissionedDisputeGameImpl","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55324,"src":"18858:27:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_address","typeString":"address"}],"id":55421,"name":"IFetcher","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":53958,"src":"18849:8:100","typeDescriptions":{"typeIdentifier":"t_type$_t_contract$_IFetcher_$53958_$","typeString":"type(contract IFetcher)"}},"id":55423,"isConstant":false,"isLValue":false,"isPure":false,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"18849:37:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_contract$_IFetcher_$53958","typeString":"contract IFetcher"}},"id":55424,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"18887:2:100","memberName":"vm","nodeType":"MemberAccess","referencedDeclaration":53912,"src":"18849:40:100","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":55425,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"18849:42:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"VariableDeclarationStatement","src":"18830:61:100"},{"expression":{"arguments":[{"expression":{"expression":{"id":55430,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55193,"src":"18917:3:100","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$54911","typeString":"contract FetchChainInfoOutput"}},"id":55431,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"18921:8:100","memberName":"mipsImpl","nodeType":"MemberAccess","referencedDeclaration":54723,"src":"18917:12:100","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":55432,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"18930:8:100","memberName":"selector","nodeType":"MemberAccess","src":"18917:21:100","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},{"id":55433,"name":"mipsImpl","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55420,"src":"18940:8:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_bytes4","typeString":"bytes4"},{"typeIdentifier":"t_address","typeString":"address"}],"expression":{"id":55427,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55193,"src":"18909:3:100","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$54911","typeString":"contract FetchChainInfoOutput"}},"id":55429,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"18913:3:100","memberName":"set","nodeType":"MemberAccess","referencedDeclaration":54384,"src":"18909:7:100","typeDescriptions":{"typeIdentifier":"t_function_external_nonpayable$_t_bytes4_$_t_address_$returns$__$","typeString":"function (bytes4,address) external"}},"id":55434,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"18909:40:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":55435,"nodeType":"ExpressionStatement","src":"18909:40:100"},{"assignments":[55437],"declarations":[{"constant":false,"id":55437,"mutability":"mutable","name":"preimageOracleImpl","nameLocation":"18976:18:100","nodeType":"VariableDeclaration","scope":55453,"src":"18968:26:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":55436,"name":"address","nodeType":"ElementaryTypeName","src":"18968:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"id":55443,"initialValue":{"arguments":[],"expression":{"argumentTypes":[],"expression":{"arguments":[{"id":55439,"name":"mipsImpl","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55420,"src":"19006:8:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_address","typeString":"address"}],"id":55438,"name":"IFetcher","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":53958,"src":"18997:8:100","typeDescriptions":{"typeIdentifier":"t_type$_t_contract$_IFetcher_$53958_$","typeString":"type(contract IFetcher)"}},"id":55440,"isConstant":false,"isLValue":false,"isPure":false,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"18997:18:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_contract$_IFetcher_$53958","typeString":"contract IFetcher"}},"id":55441,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"19016:6:100","memberName":"oracle","nodeType":"MemberAccess","referencedDeclaration":53917,"src":"18997:25:100","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":55442,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"18997:27:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"VariableDeclarationStatement","src":"18968:56:100"},{"expression":{"arguments":[{"expression":{"expression":{"id":55447,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55193,"src":"19050:3:100","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$54911","typeString":"contract FetchChainInfoOutput"}},"id":55448,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"19054:18:100","memberName":"preimageOracleImpl","nodeType":"MemberAccess","referencedDeclaration":54759,"src":"19050:22:100","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":55449,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"19073:8:100","memberName":"selector","nodeType":"MemberAccess","src":"19050:31:100","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},{"id":55450,"name":"preimageOracleImpl","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55437,"src":"19083:18:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_bytes4","typeString":"bytes4"},{"typeIdentifier":"t_address","typeString":"address"}],"expression":{"id":55444,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55193,"src":"19042:3:100","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$54911","typeString":"contract FetchChainInfoOutput"}},"id":55446,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"19046:3:100","memberName":"set","nodeType":"MemberAccess","referencedDeclaration":54384,"src":"19042:7:100","typeDescriptions":{"typeIdentifier":"t_function_external_nonpayable$_t_bytes4_$_t_address_$returns$__$","typeString":"function (bytes4,address) external"}},"id":55451,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"19042:60:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":55452,"nodeType":"ExpressionStatement","src":"19042:60:100"}]}},{"assignments":[55456],"declarations":[{"constant":false,"id":55456,"mutability":"mutable","name":"faultDisputeGameImpl","nameLocation":"19139:20:100","nodeType":"VariableDeclaration","scope":55527,"src":"19131:28:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":55455,"name":"address","nodeType":"ElementaryTypeName","src":"19131:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"id":55460,"initialValue":{"arguments":[{"id":55458,"name":"disputeGameFactoryProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55303,"src":"19183:23:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_address","typeString":"address"}],"id":55457,"name":"_getFaultDisputeGame","nodeType":"Identifier","overloadedDeclarations":[55832,55864],"referencedDeclaration":55832,"src":"19162:20:100","typeDescriptions":{"typeIdentifier":"t_function_internal_view$_t_address_$returns$_t_address_$","typeString":"function (address) view returns (address)"}},"id":55459,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"19162:45:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"VariableDeclarationStatement","src":"19131:76:100"},{"condition":{"commonType":{"typeIdentifier":"t_address","typeString":"address"},"id":55466,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftExpression":{"id":55461,"name":"faultDisputeGameImpl","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55456,"src":"19225:20:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"BinaryOperation","operator":"!=","rightExpression":{"arguments":[{"hexValue":"30","id":55464,"isConstant":false,"isLValue":false,"isPure":true,"kind":"number","lValueRequested":false,"nodeType":"Literal","src":"19257:1:100","typeDescriptions":{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"},"value":"0"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"}],"id":55463,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"nodeType":"ElementaryTypeNameExpression","src":"19249:7:100","typeDescriptions":{"typeIdentifier":"t_type$_t_address_$","typeString":"type(address)"},"typeName":{"id":55462,"name":"address","nodeType":"ElementaryTypeName","src":"19249:7:100","typeDescriptions":{}}},"id":55465,"isConstant":false,"isLValue":false,"isPure":true,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"19249:10:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"src":"19225:34:100","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},"id":55501,"nodeType":"IfStatement","src":"19221:470:100","trueBody":{"id":55500,"nodeType":"Block","src":"19261:430:100","statements":[{"expression":{"arguments":[{"expression":{"expression":{"id":55470,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55193,"src":"19344:3:100","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$54911","typeString":"contract FetchChainInfoOutput"}},"id":55471,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"19348:20:100","memberName":"faultDisputeGameImpl","nodeType":"MemberAccess","referencedDeclaration":54687,"src":"19344:24:100","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":55472,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"19369:8:100","memberName":"selector","nodeType":"MemberAccess","src":"19344:33:100","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},{"id":55473,"name":"faultDisputeGameImpl","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55456,"src":"19379:20:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_bytes4","typeString":"bytes4"},{"typeIdentifier":"t_address","typeString":"address"}],"expression":{"id":55467,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55193,"src":"19336:3:100","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$54911","typeString":"contract FetchChainInfoOutput"}},"id":55469,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"19340:3:100","memberName":"set","nodeType":"MemberAccess","referencedDeclaration":54384,"src":"19336:7:100","typeDescriptions":{"typeIdentifier":"t_function_external_nonpayable$_t_bytes4_$_t_address_$returns$__$","typeString":"function (bytes4,address) external"}},"id":55474,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"19336:64:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":55475,"nodeType":"ExpressionStatement","src":"19336:64:100"},{"expression":{"arguments":[{"expression":{"expression":{"id":55479,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55193,"src":"19426:3:100","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$54911","typeString":"contract FetchChainInfoOutput"}},"id":55480,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"19430:14:100","memberName":"permissionless","nodeType":"MemberAccess","referencedDeclaration":54901,"src":"19426:18:100","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_bool_$","typeString":"function () view external returns (bool)"}},"id":55481,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"19445:8:100","memberName":"selector","nodeType":"MemberAccess","src":"19426:27:100","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},{"hexValue":"74727565","id":55482,"isConstant":false,"isLValue":false,"isPure":true,"kind":"bool","lValueRequested":false,"nodeType":"Literal","src":"19455:4:100","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"},"value":"true"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_bytes4","typeString":"bytes4"},{"typeIdentifier":"t_bool","typeString":"bool"}],"expression":{"id":55476,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55193,"src":"19418:3:100","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$54911","typeString":"contract FetchChainInfoOutput"}},"id":55478,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"19422:3:100","memberName":"set","nodeType":"MemberAccess","referencedDeclaration":54416,"src":"19418:7:100","typeDescriptions":{"typeIdentifier":"t_function_external_nonpayable$_t_bytes4_$_t_bool_$returns$__$","typeString":"function (bytes4,bool) external"}},"id":55483,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"19418:42:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":55484,"nodeType":"ExpressionStatement","src":"19418:42:100"},{"assignments":[55486],"declarations":[{"constant":false,"id":55486,"mutability":"mutable","name":"delayedWethPermissionlessGameProxy","nameLocation":"19487:34:100","nodeType":"VariableDeclaration","scope":55500,"src":"19479:42:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":55485,"name":"address","nodeType":"ElementaryTypeName","src":"19479:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"id":55490,"initialValue":{"arguments":[{"id":55488,"name":"faultDisputeGameImpl","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55456,"src":"19545:20:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_address","typeString":"address"}],"id":55487,"name":"_getDelayedWETHProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55967,"src":"19524:20:100","typeDescriptions":{"typeIdentifier":"t_function_internal_view$_t_address_$returns$_t_address_$","typeString":"function (address) view returns (address)"}},"id":55489,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"19524:42:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"VariableDeclarationStatement","src":"19479:87:100"},{"expression":{"arguments":[{"expression":{"expression":{"id":55494,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55193,"src":"19592:3:100","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$54911","typeString":"contract FetchChainInfoOutput"}},"id":55495,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"19596:34:100","memberName":"delayedWethPermissionlessGameProxy","nodeType":"MemberAccess","referencedDeclaration":54661,"src":"19592:38:100","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":55496,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"19631:8:100","memberName":"selector","nodeType":"MemberAccess","src":"19592:47:100","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},{"id":55497,"name":"delayedWethPermissionlessGameProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55486,"src":"19641:34:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_bytes4","typeString":"bytes4"},{"typeIdentifier":"t_address","typeString":"address"}],"expression":{"id":55491,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55193,"src":"19584:3:100","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$54911","typeString":"contract FetchChainInfoOutput"}},"id":55493,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"19588:3:100","memberName":"set","nodeType":"MemberAccess","referencedDeclaration":54384,"src":"19584:7:100","typeDescriptions":{"typeIdentifier":"t_function_external_nonpayable$_t_bytes4_$_t_address_$returns$__$","typeString":"function (bytes4,address) external"}},"id":55498,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"19584:92:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":55499,"nodeType":"ExpressionStatement","src":"19584:92:100"}]}},{"assignments":[55503],"declarations":[{"constant":false,"id":55503,"mutability":"mutable","name":"faultDisputeGameCannonKonaImpl","nameLocation":"19713:30:100","nodeType":"VariableDeclaration","scope":55527,"src":"19705:38:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":55502,"name":"address","nodeType":"ElementaryTypeName","src":"19705:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"id":55509,"initialValue":{"arguments":[{"id":55505,"name":"disputeGameFactoryProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55303,"src":"19783:23:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},{"expression":{"id":55506,"name":"GameTypes","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":70870,"src":"19808:9:100","typeDescriptions":{"typeIdentifier":"t_type$_t_contract$_GameTypes_$70870_$","typeString":"type(library GameTypes)"}},"id":55507,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"memberLocation":"19818:11:100","memberName":"CANNON_KONA","nodeType":"MemberAccess","referencedDeclaration":70837,"src":"19808:21:100","typeDescriptions":{"typeIdentifier":"t_userDefinedValueType$_GameType_$70720","typeString":"GameType"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_address","typeString":"address"},{"typeIdentifier":"t_userDefinedValueType$_GameType_$70720","typeString":"GameType"}],"id":55504,"name":"_getFaultDisputeGame","nodeType":"Identifier","overloadedDeclarations":[55832,55864],"referencedDeclaration":55864,"src":"19762:20:100","typeDescriptions":{"typeIdentifier":"t_function_internal_view$_t_address_$_t_userDefinedValueType$_GameType_$70720_$returns$_t_address_$","typeString":"function (address,GameType) view returns (address)"}},"id":55508,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"19762:68:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"VariableDeclarationStatement","src":"19705:125:100"},{"condition":{"commonType":{"typeIdentifier":"t_address","typeString":"address"},"id":55515,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftExpression":{"id":55510,"name":"faultDisputeGameCannonKonaImpl","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55503,"src":"19848:30:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"BinaryOperation","operator":"!=","rightExpression":{"arguments":[{"hexValue":"30","id":55513,"isConstant":false,"isLValue":false,"isPure":true,"kind":"number","lValueRequested":false,"nodeType":"Literal","src":"19890:1:100","typeDescriptions":{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"},"value":"0"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"}],"id":55512,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"nodeType":"ElementaryTypeNameExpression","src":"19882:7:100","typeDescriptions":{"typeIdentifier":"t_type$_t_address_$","typeString":"type(address)"},"typeName":{"id":55511,"name":"address","nodeType":"ElementaryTypeName","src":"19882:7:100","typeDescriptions":{}}},"id":55514,"isConstant":false,"isLValue":false,"isPure":true,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"19882:10:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"src":"19848:44:100","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},"id":55526,"nodeType":"IfStatement","src":"19844:167:100","trueBody":{"id":55525,"nodeType":"Block","src":"19894:117:100","statements":[{"expression":{"arguments":[{"expression":{"expression":{"id":55519,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55193,"src":"19920:3:100","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$54911","typeString":"contract FetchChainInfoOutput"}},"id":55520,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"19924:30:100","memberName":"faultDisputeGameCannonKonaImpl","nodeType":"MemberAccess","referencedDeclaration":54705,"src":"19920:34:100","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":55521,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"19955:8:100","memberName":"selector","nodeType":"MemberAccess","src":"19920:43:100","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},{"id":55522,"name":"faultDisputeGameCannonKonaImpl","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55503,"src":"19965:30:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_bytes4","typeString":"bytes4"},{"typeIdentifier":"t_address","typeString":"address"}],"expression":{"id":55516,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55193,"src":"19912:3:100","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$54911","typeString":"contract FetchChainInfoOutput"}},"id":55518,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"19916:3:100","memberName":"set","nodeType":"MemberAccess","referencedDeclaration":54384,"src":"19912:7:100","typeDescriptions":{"typeIdentifier":"t_function_external_nonpayable$_t_bytes4_$_t_address_$returns$__$","typeString":"function (bytes4,address) external"}},"id":55523,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"19912:84:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":55524,"nodeType":"ExpressionStatement","src":"19912:84:100"}]}}]}}]},"implemented":true,"kind":"function","modifiers":[],"name":"_processFaultProofs","nameLocation":"16392:19:100","parameters":{"id":55194,"nodeType":"ParameterList","parameters":[{"constant":false,"id":55193,"mutability":"mutable","name":"_fo","nameLocation":"16433:3:100","nodeType":"VariableDeclaration","scope":55565,"src":"16412:24:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$54911","typeString":"contract FetchChainInfoOutput"},"typeName":{"id":55192,"nodeType":"UserDefinedTypeName","pathNode":{"id":55191,"name":"FetchChainInfoOutput","nameLocations":["16412:20:100"],"nodeType":"IdentifierPath","referencedDeclaration":54911,"src":"16412:20:100"},"referencedDeclaration":54911,"src":"16412:20:100","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$54911","typeString":"contract FetchChainInfoOutput"}},"visibility":"internal"}],"src":"16411:26:100"},"returnParameters":{"id":55195,"nodeType":"ParameterList","parameters":[],"src":"16447:0:100"},"scope":56018,"stateMutability":"nonpayable","virtual":false,"visibility":"internal"},{"id":55594,"nodeType":"FunctionDefinition","src":"20422:256:100","nodes":[],"body":{"id":55593,"nodeType":"Block","src":"20493:185:100","nodes":[],"statements":[{"clauses":[{"block":{"id":55582,"nodeType":"Block","src":"20564:41:100","statements":[{"expression":{"id":55580,"name":"guardian_","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55578,"src":"20585:9:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"functionReturnParameters":55571,"id":55581,"nodeType":"Return","src":"20578:16:100"}]},"errorName":"","id":55583,"nodeType":"TryCatchClause","parameters":{"id":55579,"nodeType":"ParameterList","parameters":[{"constant":false,"id":55578,"mutability":"mutable","name":"guardian_","nameLocation":"20553:9:100","nodeType":"VariableDeclaration","scope":55583,"src":"20545:17:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":55577,"name":"address","nodeType":"ElementaryTypeName","src":"20545:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"20544:19:100"},"src":"20536:69:100"},{"block":{"id":55590,"nodeType":"Block","src":"20612:60:100","statements":[{"expression":{"arguments":[],"expression":{"argumentTypes":[],"expression":{"arguments":[{"id":55585,"name":"_portal","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55567,"src":"20642:7:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_address","typeString":"address"}],"id":55584,"name":"IFetcher","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":53958,"src":"20633:8:100","typeDescriptions":{"typeIdentifier":"t_type$_t_contract$_IFetcher_$53958_$","typeString":"type(contract IFetcher)"}},"id":55586,"isConstant":false,"isLValue":false,"isPure":false,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"20633:17:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_contract$_IFetcher_$53958","typeString":"contract IFetcher"}},"id":55587,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"20651:8:100","memberName":"GUARDIAN","nodeType":"MemberAccess","referencedDeclaration":53823,"src":"20633:26:100","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":55588,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"20633:28:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"functionReturnParameters":55571,"id":55589,"nodeType":"Return","src":"20626:35:100"}]},"errorName":"","id":55591,"nodeType":"TryCatchClause","src":"20606:66:100"}],"externalCall":{"arguments":[],"expression":{"argumentTypes":[],"expression":{"arguments":[{"id":55573,"name":"_portal","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55567,"src":"20516:7:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_address","typeString":"address"}],"id":55572,"name":"IFetcher","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":53958,"src":"20507:8:100","typeDescriptions":{"typeIdentifier":"t_type$_t_contract$_IFetcher_$53958_$","typeString":"type(contract IFetcher)"}},"id":55574,"isConstant":false,"isLValue":false,"isPure":false,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"20507:17:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_contract$_IFetcher_$53958","typeString":"contract IFetcher"}},"id":55575,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"20525:8:100","memberName":"guardian","nodeType":"MemberAccess","referencedDeclaration":53818,"src":"20507:26:100","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":55576,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"20507:28:100","tryCall":true,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"id":55592,"nodeType":"TryStatement","src":"20503:169:100"}]},"implemented":true,"kind":"function","modifiers":[],"name":"_getGuardian","nameLocation":"20431:12:100","parameters":{"id":55568,"nodeType":"ParameterList","parameters":[{"constant":false,"id":55567,"mutability":"mutable","name":"_portal","nameLocation":"20452:7:100","nodeType":"VariableDeclaration","scope":55594,"src":"20444:15:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":55566,"name":"address","nodeType":"ElementaryTypeName","src":"20444:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"20443:17:100"},"returnParameters":{"id":55571,"nodeType":"ParameterList","parameters":[{"constant":false,"id":55570,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":55594,"src":"20484:7:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":55569,"name":"address","nodeType":"ElementaryTypeName","src":"20484:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"20483:9:100"},"scope":56018,"stateMutability":"view","virtual":false,"visibility":"internal"},{"id":55623,"nodeType":"FunctionDefinition","src":"20684:282:100","nodes":[],"body":{"id":55622,"nodeType":"Block","src":"20764:202:100","nodes":[],"statements":[{"clauses":[{"block":{"id":55611,"nodeType":"Block","src":"20843:45:100","statements":[{"expression":{"id":55609,"name":"systemConfig_","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55607,"src":"20864:13:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"functionReturnParameters":55600,"id":55610,"nodeType":"Return","src":"20857:20:100"}]},"errorName":"","id":55612,"nodeType":"TryCatchClause","parameters":{"id":55608,"nodeType":"ParameterList","parameters":[{"constant":false,"id":55607,"mutability":"mutable","name":"systemConfig_","nameLocation":"20828:13:100","nodeType":"VariableDeclaration","scope":55612,"src":"20820:21:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":55606,"name":"address","nodeType":"ElementaryTypeName","src":"20820:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"20819:23:100"},"src":"20811:77:100"},{"block":{"id":55619,"nodeType":"Block","src":"20895:65:100","statements":[{"expression":{"arguments":[],"expression":{"argumentTypes":[],"expression":{"arguments":[{"id":55614,"name":"_portal","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55596,"src":"20925:7:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_address","typeString":"address"}],"id":55613,"name":"IFetcher","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":53958,"src":"20916:8:100","typeDescriptions":{"typeIdentifier":"t_type$_t_contract$_IFetcher_$53958_$","typeString":"type(contract IFetcher)"}},"id":55615,"isConstant":false,"isLValue":false,"isPure":false,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"20916:17:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_contract$_IFetcher_$53958","typeString":"contract IFetcher"}},"id":55616,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"20934:13:100","memberName":"SYSTEM_CONFIG","nodeType":"MemberAccess","referencedDeclaration":53833,"src":"20916:31:100","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":55617,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"20916:33:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"functionReturnParameters":55600,"id":55618,"nodeType":"Return","src":"20909:40:100"}]},"errorName":"","id":55620,"nodeType":"TryCatchClause","src":"20889:71:100"}],"externalCall":{"arguments":[],"expression":{"argumentTypes":[],"expression":{"arguments":[{"id":55602,"name":"_portal","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55596,"src":"20787:7:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_address","typeString":"address"}],"id":55601,"name":"IFetcher","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":53958,"src":"20778:8:100","typeDescriptions":{"typeIdentifier":"t_type$_t_contract$_IFetcher_$53958_$","typeString":"type(contract IFetcher)"}},"id":55603,"isConstant":false,"isLValue":false,"isPure":false,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"20778:17:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_contract$_IFetcher_$53958","typeString":"contract IFetcher"}},"id":55604,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"20796:12:100","memberName":"systemConfig","nodeType":"MemberAccess","referencedDeclaration":53828,"src":"20778:30:100","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":55605,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"20778:32:100","tryCall":true,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"id":55621,"nodeType":"TryStatement","src":"20774:186:100"}]},"implemented":true,"kind":"function","modifiers":[],"name":"_getSystemConfigProxy","nameLocation":"20693:21:100","parameters":{"id":55597,"nodeType":"ParameterList","parameters":[{"constant":false,"id":55596,"mutability":"mutable","name":"_portal","nameLocation":"20723:7:100","nodeType":"VariableDeclaration","scope":55623,"src":"20715:15:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":55595,"name":"address","nodeType":"ElementaryTypeName","src":"20715:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"20714:17:100"},"returnParameters":{"id":55600,"nodeType":"ParameterList","parameters":[{"constant":false,"id":55599,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":55623,"src":"20755:7:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":55598,"name":"address","nodeType":"ElementaryTypeName","src":"20755:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"20754:9:100"},"scope":56018,"stateMutability":"view","virtual":false,"visibility":"internal"},{"id":55652,"nodeType":"FunctionDefinition","src":"20972:338:100","nodes":[],"body":{"id":55651,"nodeType":"Block","src":"21075:235:100","nodes":[],"statements":[{"clauses":[{"block":{"id":55640,"nodeType":"Block","src":"21171:47:100","statements":[{"expression":{"id":55638,"name":"optimismPortal_","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55636,"src":"21192:15:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"functionReturnParameters":55629,"id":55639,"nodeType":"Return","src":"21185:22:100"}]},"errorName":"","id":55641,"nodeType":"TryCatchClause","parameters":{"id":55637,"nodeType":"ParameterList","parameters":[{"constant":false,"id":55636,"mutability":"mutable","name":"optimismPortal_","nameLocation":"21154:15:100","nodeType":"VariableDeclaration","scope":55641,"src":"21146:23:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":55635,"name":"address","nodeType":"ElementaryTypeName","src":"21146:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"21145:25:100"},"src":"21137:81:100"},{"block":{"id":55648,"nodeType":"Block","src":"21225:79:100","statements":[{"expression":{"arguments":[],"expression":{"argumentTypes":[],"expression":{"arguments":[{"id":55643,"name":"_l1CrossDomainMessengerProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55625,"src":"21255:28:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_address","typeString":"address"}],"id":55642,"name":"IFetcher","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":53958,"src":"21246:8:100","typeDescriptions":{"typeIdentifier":"t_type$_t_contract$_IFetcher_$53958_$","typeString":"type(contract IFetcher)"}},"id":55644,"isConstant":false,"isLValue":false,"isPure":false,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"21246:38:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_contract$_IFetcher_$53958","typeString":"contract IFetcher"}},"id":55645,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"21285:6:100","memberName":"PORTAL","nodeType":"MemberAccess","referencedDeclaration":53863,"src":"21246:45:100","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":55646,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"21246:47:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"functionReturnParameters":55629,"id":55647,"nodeType":"Return","src":"21239:54:100"}]},"errorName":"","id":55649,"nodeType":"TryCatchClause","src":"21219:85:100"}],"externalCall":{"arguments":[],"expression":{"argumentTypes":[],"expression":{"arguments":[{"id":55631,"name":"_l1CrossDomainMessengerProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55625,"src":"21098:28:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_address","typeString":"address"}],"id":55630,"name":"IFetcher","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":53958,"src":"21089:8:100","typeDescriptions":{"typeIdentifier":"t_type$_t_contract$_IFetcher_$53958_$","typeString":"type(contract IFetcher)"}},"id":55632,"isConstant":false,"isLValue":false,"isPure":false,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"21089:38:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_contract$_IFetcher_$53958","typeString":"contract IFetcher"}},"id":55633,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"21128:6:100","memberName":"portal","nodeType":"MemberAccess","referencedDeclaration":53868,"src":"21089:45:100","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":55634,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"21089:47:100","tryCall":true,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"id":55650,"nodeType":"TryStatement","src":"21085:219:100"}]},"implemented":true,"kind":"function","modifiers":[],"name":"_getOptimismPortalProxy","nameLocation":"20981:23:100","parameters":{"id":55626,"nodeType":"ParameterList","parameters":[{"constant":false,"id":55625,"mutability":"mutable","name":"_l1CrossDomainMessengerProxy","nameLocation":"21013:28:100","nodeType":"VariableDeclaration","scope":55652,"src":"21005:36:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":55624,"name":"address","nodeType":"ElementaryTypeName","src":"21005:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"21004:38:100"},"returnParameters":{"id":55629,"nodeType":"ParameterList","parameters":[{"constant":false,"id":55628,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":55652,"src":"21066:7:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":55627,"name":"address","nodeType":"ElementaryTypeName","src":"21066:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"21065:9:100"},"scope":56018,"stateMutability":"view","virtual":false,"visibility":"internal"},{"id":55690,"nodeType":"FunctionDefinition","src":"21316:350:100","nodes":[],"body":{"id":55689,"nodeType":"Block","src":"21414:252:100","nodes":[],"statements":[{"assignments":[55660],"declarations":[{"constant":false,"id":55660,"mutability":"mutable","name":"ADDRESS_MANAGER_MAPPING_SLOT","nameLocation":"21432:28:100","nodeType":"VariableDeclaration","scope":55689,"src":"21424:36:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_uint256","typeString":"uint256"},"typeName":{"id":55659,"name":"uint256","nodeType":"ElementaryTypeName","src":"21424:7:100","typeDescriptions":{"typeIdentifier":"t_uint256","typeString":"uint256"}},"visibility":"internal"}],"id":55662,"initialValue":{"hexValue":"31","id":55661,"isConstant":false,"isLValue":false,"isPure":true,"kind":"number","lValueRequested":false,"nodeType":"Literal","src":"21463:1:100","typeDescriptions":{"typeIdentifier":"t_rational_1_by_1","typeString":"int_const 1"},"value":"1"},"nodeType":"VariableDeclarationStatement","src":"21424:40:100"},{"assignments":[55664],"declarations":[{"constant":false,"id":55664,"mutability":"mutable","name":"slot","nameLocation":"21482:4:100","nodeType":"VariableDeclaration","scope":55689,"src":"21474:12:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_bytes32","typeString":"bytes32"},"typeName":{"id":55663,"name":"bytes32","nodeType":"ElementaryTypeName","src":"21474:7:100","typeDescriptions":{"typeIdentifier":"t_bytes32","typeString":"bytes32"}},"visibility":"internal"}],"id":55672,"initialValue":{"arguments":[{"arguments":[{"id":55668,"name":"_l1CrossDomainMessengerProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55654,"src":"21510:28:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},{"id":55669,"name":"ADDRESS_MANAGER_MAPPING_SLOT","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55660,"src":"21540:28:100","typeDescriptions":{"typeIdentifier":"t_uint256","typeString":"uint256"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_address","typeString":"address"},{"typeIdentifier":"t_uint256","typeString":"uint256"}],"expression":{"id":55666,"name":"abi","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":-1,"src":"21499:3:100","typeDescriptions":{"typeIdentifier":"t_magic_abi","typeString":"abi"}},"id":55667,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"memberLocation":"21503:6:100","memberName":"encode","nodeType":"MemberAccess","src":"21499:10:100","typeDescriptions":{"typeIdentifier":"t_function_abiencode_pure$__$returns$_t_bytes_memory_ptr_$","typeString":"function () pure returns (bytes memory)"}},"id":55670,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"21499:70:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_bytes_memory_ptr","typeString":"bytes memory"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_bytes_memory_ptr","typeString":"bytes memory"}],"id":55665,"name":"keccak256","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":-8,"src":"21489:9:100","typeDescriptions":{"typeIdentifier":"t_function_keccak256_pure$_t_bytes_memory_ptr_$returns$_t_bytes32_$","typeString":"function (bytes memory) pure returns (bytes32)"}},"id":55671,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"21489:81:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_bytes32","typeString":"bytes32"}},"nodeType":"VariableDeclarationStatement","src":"21474:96:100"},{"expression":{"arguments":[{"arguments":[{"arguments":[{"components":[{"arguments":[{"id":55681,"name":"_l1CrossDomainMessengerProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55654,"src":"21620:28:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},{"id":55682,"name":"slot","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55664,"src":"21650:4:100","typeDescriptions":{"typeIdentifier":"t_bytes32","typeString":"bytes32"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_address","typeString":"address"},{"typeIdentifier":"t_bytes32","typeString":"bytes32"}],"expression":{"id":55679,"name":"vm","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":5501,"src":"21612:2:100","typeDescriptions":{"typeIdentifier":"t_contract$_Vm_$23288","typeString":"contract Vm"}},"id":55680,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"21615:4:100","memberName":"load","nodeType":"MemberAccess","referencedDeclaration":19384,"src":"21612:7:100","typeDescriptions":{"typeIdentifier":"t_function_external_view$_t_address_$_t_bytes32_$returns$_t_bytes32_$","typeString":"function (address,bytes32) view external returns (bytes32)"}},"id":55683,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"21612:43:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_bytes32","typeString":"bytes32"}}],"id":55684,"isConstant":false,"isInlineArray":false,"isLValue":false,"isPure":false,"lValueRequested":false,"nodeType":"TupleExpression","src":"21611:45:100","typeDescriptions":{"typeIdentifier":"t_bytes32","typeString":"bytes32"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_bytes32","typeString":"bytes32"}],"id":55678,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"nodeType":"ElementaryTypeNameExpression","src":"21603:7:100","typeDescriptions":{"typeIdentifier":"t_type$_t_uint256_$","typeString":"type(uint256)"},"typeName":{"id":55677,"name":"uint256","nodeType":"ElementaryTypeName","src":"21603:7:100","typeDescriptions":{}}},"id":55685,"isConstant":false,"isLValue":false,"isPure":false,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"21603:54:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_uint256","typeString":"uint256"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_uint256","typeString":"uint256"}],"id":55676,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"nodeType":"ElementaryTypeNameExpression","src":"21595:7:100","typeDescriptions":{"typeIdentifier":"t_type$_t_uint160_$","typeString":"type(uint160)"},"typeName":{"id":55675,"name":"uint160","nodeType":"ElementaryTypeName","src":"21595:7:100","typeDescriptions":{}}},"id":55686,"isConstant":false,"isLValue":false,"isPure":false,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"21595:63:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_uint160","typeString":"uint160"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_uint160","typeString":"uint160"}],"id":55674,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"nodeType":"ElementaryTypeNameExpression","src":"21587:7:100","typeDescriptions":{"typeIdentifier":"t_type$_t_address_$","typeString":"type(address)"},"typeName":{"id":55673,"name":"address","nodeType":"ElementaryTypeName","src":"21587:7:100","typeDescriptions":{}}},"id":55687,"isConstant":false,"isLValue":false,"isPure":false,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"21587:72:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"functionReturnParameters":55658,"id":55688,"nodeType":"Return","src":"21580:79:100"}]},"implemented":true,"kind":"function","modifiers":[],"name":"_getAddressManager","nameLocation":"21325:18:100","parameters":{"id":55655,"nodeType":"ParameterList","parameters":[{"constant":false,"id":55654,"mutability":"mutable","name":"_l1CrossDomainMessengerProxy","nameLocation":"21352:28:100","nodeType":"VariableDeclaration","scope":55690,"src":"21344:36:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":55653,"name":"address","nodeType":"ElementaryTypeName","src":"21344:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"21343:38:100"},"returnParameters":{"id":55658,"nodeType":"ParameterList","parameters":[{"constant":false,"id":55657,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":55690,"src":"21405:7:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":55656,"name":"address","nodeType":"ElementaryTypeName","src":"21405:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"21404:9:100"},"scope":56018,"stateMutability":"view","virtual":false,"visibility":"internal"},{"id":55718,"nodeType":"FunctionDefinition","src":"21672:299:100","nodes":[],"body":{"id":55717,"nodeType":"Block","src":"21765:206:100","nodes":[],"statements":[{"clauses":[{"block":{"id":55707,"nodeType":"Block","src":"21864:52:100","statements":[{"expression":{"id":55705,"name":"l1ERC721BridgeProxy_","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55703,"src":"21885:20:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"functionReturnParameters":55696,"id":55706,"nodeType":"Return","src":"21878:27:100"}]},"errorName":"","id":55708,"nodeType":"TryCatchClause","parameters":{"id":55704,"nodeType":"ParameterList","parameters":[{"constant":false,"id":55703,"mutability":"mutable","name":"l1ERC721BridgeProxy_","nameLocation":"21842:20:100","nodeType":"VariableDeclaration","scope":55708,"src":"21834:28:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":55702,"name":"address","nodeType":"ElementaryTypeName","src":"21834:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"21833:30:100"},"src":"21825:91:100"},{"block":{"id":55714,"nodeType":"Block","src":"21923:42:100","statements":[{"expression":{"arguments":[{"hexValue":"30","id":55711,"isConstant":false,"isLValue":false,"isPure":true,"kind":"number","lValueRequested":false,"nodeType":"Literal","src":"21952:1:100","typeDescriptions":{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"},"value":"0"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"}],"id":55710,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"nodeType":"ElementaryTypeNameExpression","src":"21944:7:100","typeDescriptions":{"typeIdentifier":"t_type$_t_address_$","typeString":"type(address)"},"typeName":{"id":55709,"name":"address","nodeType":"ElementaryTypeName","src":"21944:7:100","typeDescriptions":{}}},"id":55712,"isConstant":false,"isLValue":false,"isPure":true,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"21944:10:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"functionReturnParameters":55696,"id":55713,"nodeType":"Return","src":"21937:17:100"}]},"errorName":"","id":55715,"nodeType":"TryCatchClause","src":"21917:48:100"}],"externalCall":{"arguments":[],"expression":{"argumentTypes":[],"expression":{"arguments":[{"id":55698,"name":"_systemConfigProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55692,"src":"21788:18:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_address","typeString":"address"}],"id":55697,"name":"IFetcher","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":53958,"src":"21779:8:100","typeDescriptions":{"typeIdentifier":"t_type$_t_contract$_IFetcher_$53958_$","typeString":"type(contract IFetcher)"}},"id":55699,"isConstant":false,"isLValue":false,"isPure":false,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"21779:28:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_contract$_IFetcher_$53958","typeString":"contract IFetcher"}},"id":55700,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"21808:14:100","memberName":"l1ERC721Bridge","nodeType":"MemberAccess","referencedDeclaration":53873,"src":"21779:43:100","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":55701,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"21779:45:100","tryCall":true,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"id":55716,"nodeType":"TryStatement","src":"21775:190:100"}]},"implemented":true,"kind":"function","modifiers":[],"name":"_getL1ERC721BridgeProxy","nameLocation":"21681:23:100","parameters":{"id":55693,"nodeType":"ParameterList","parameters":[{"constant":false,"id":55692,"mutability":"mutable","name":"_systemConfigProxy","nameLocation":"21713:18:100","nodeType":"VariableDeclaration","scope":55718,"src":"21705:26:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":55691,"name":"address","nodeType":"ElementaryTypeName","src":"21705:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"21704:28:100"},"returnParameters":{"id":55696,"nodeType":"ParameterList","parameters":[{"constant":false,"id":55695,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":55718,"src":"21756:7:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":55694,"name":"address","nodeType":"ElementaryTypeName","src":"21756:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"21755:9:100"},"scope":56018,"stateMutability":"view","virtual":false,"visibility":"internal"},{"id":55746,"nodeType":"FunctionDefinition","src":"21977:377:100","nodes":[],"body":{"id":55745,"nodeType":"Block","src":"22084:270:100","nodes":[],"statements":[{"clauses":[{"block":{"id":55735,"nodeType":"Block","src":"22233:66:100","statements":[{"expression":{"id":55733,"name":"optimismMintableERC20FactoryProxy_","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55731,"src":"22254:34:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"functionReturnParameters":55724,"id":55734,"nodeType":"Return","src":"22247:41:100"}]},"errorName":"","id":55736,"nodeType":"TryCatchClause","parameters":{"id":55732,"nodeType":"ParameterList","parameters":[{"constant":false,"id":55731,"mutability":"mutable","name":"optimismMintableERC20FactoryProxy_","nameLocation":"22188:34:100","nodeType":"VariableDeclaration","scope":55736,"src":"22180:42:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":55730,"name":"address","nodeType":"ElementaryTypeName","src":"22180:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"22166:66:100"},"src":"22158:141:100"},{"block":{"id":55742,"nodeType":"Block","src":"22306:42:100","statements":[{"expression":{"arguments":[{"hexValue":"30","id":55739,"isConstant":false,"isLValue":false,"isPure":true,"kind":"number","lValueRequested":false,"nodeType":"Literal","src":"22335:1:100","typeDescriptions":{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"},"value":"0"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"}],"id":55738,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"nodeType":"ElementaryTypeNameExpression","src":"22327:7:100","typeDescriptions":{"typeIdentifier":"t_type$_t_address_$","typeString":"type(address)"},"typeName":{"id":55737,"name":"address","nodeType":"ElementaryTypeName","src":"22327:7:100","typeDescriptions":{}}},"id":55740,"isConstant":false,"isLValue":false,"isPure":true,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"22327:10:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"functionReturnParameters":55724,"id":55741,"nodeType":"Return","src":"22320:17:100"}]},"errorName":"","id":55743,"nodeType":"TryCatchClause","src":"22300:48:100"}],"externalCall":{"arguments":[],"expression":{"argumentTypes":[],"expression":{"arguments":[{"id":55726,"name":"_systemConfigProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55720,"src":"22107:18:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_address","typeString":"address"}],"id":55725,"name":"IFetcher","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":53958,"src":"22098:8:100","typeDescriptions":{"typeIdentifier":"t_type$_t_contract$_IFetcher_$53958_$","typeString":"type(contract IFetcher)"}},"id":55727,"isConstant":false,"isLValue":false,"isPure":false,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"22098:28:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_contract$_IFetcher_$53958","typeString":"contract IFetcher"}},"id":55728,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"22127:28:100","memberName":"optimismMintableERC20Factory","nodeType":"MemberAccess","referencedDeclaration":53878,"src":"22098:57:100","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":55729,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"22098:59:100","tryCall":true,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"id":55744,"nodeType":"TryStatement","src":"22094:254:100"}]},"implemented":true,"kind":"function","modifiers":[],"name":"_getOptimismMintableERC20FactoryProxy","nameLocation":"21986:37:100","parameters":{"id":55721,"nodeType":"ParameterList","parameters":[{"constant":false,"id":55720,"mutability":"mutable","name":"_systemConfigProxy","nameLocation":"22032:18:100","nodeType":"VariableDeclaration","scope":55746,"src":"22024:26:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":55719,"name":"address","nodeType":"ElementaryTypeName","src":"22024:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"22023:28:100"},"returnParameters":{"id":55724,"nodeType":"ParameterList","parameters":[{"constant":false,"id":55723,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":55746,"src":"22075:7:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":55722,"name":"address","nodeType":"ElementaryTypeName","src":"22075:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"22074:9:100"},"scope":56018,"stateMutability":"view","virtual":false,"visibility":"internal"},{"id":55774,"nodeType":"FunctionDefinition","src":"22360:398:100","nodes":[],"body":{"id":55773,"nodeType":"Block","src":"22457:301:100","nodes":[],"statements":[{"clauses":[{"block":{"id":55763,"nodeType":"Block","src":"22564:56:100","statements":[{"expression":{"id":55761,"name":"disputeGameFactoryProxy_","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55759,"src":"22585:24:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"functionReturnParameters":55752,"id":55762,"nodeType":"Return","src":"22578:31:100"}]},"errorName":"","id":55764,"nodeType":"TryCatchClause","parameters":{"id":55760,"nodeType":"ParameterList","parameters":[{"constant":false,"id":55759,"mutability":"mutable","name":"disputeGameFactoryProxy_","nameLocation":"22538:24:100","nodeType":"VariableDeclaration","scope":55764,"src":"22530:32:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":55758,"name":"address","nodeType":"ElementaryTypeName","src":"22530:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"22529:34:100"},"src":"22521:99:100"},{"block":{"id":55770,"nodeType":"Block","src":"22627:125:100","statements":[{"expression":{"arguments":[{"hexValue":"30","id":55767,"isConstant":false,"isLValue":false,"isPure":true,"kind":"number","lValueRequested":false,"nodeType":"Literal","src":"22739:1:100","typeDescriptions":{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"},"value":"0"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"}],"id":55766,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"nodeType":"ElementaryTypeNameExpression","src":"22731:7:100","typeDescriptions":{"typeIdentifier":"t_type$_t_address_$","typeString":"type(address)"},"typeName":{"id":55765,"name":"address","nodeType":"ElementaryTypeName","src":"22731:7:100","typeDescriptions":{}}},"id":55768,"isConstant":false,"isLValue":false,"isPure":true,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"22731:10:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"functionReturnParameters":55752,"id":55769,"nodeType":"Return","src":"22724:17:100"}]},"errorName":"","id":55771,"nodeType":"TryCatchClause","src":"22621:131:100"}],"externalCall":{"arguments":[],"expression":{"argumentTypes":[],"expression":{"arguments":[{"id":55754,"name":"_systemConfigProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55748,"src":"22480:18:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_address","typeString":"address"}],"id":55753,"name":"IFetcher","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":53958,"src":"22471:8:100","typeDescriptions":{"typeIdentifier":"t_type$_t_contract$_IFetcher_$53958_$","typeString":"type(contract IFetcher)"}},"id":55755,"isConstant":false,"isLValue":false,"isPure":false,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"22471:28:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_contract$_IFetcher_$53958","typeString":"contract IFetcher"}},"id":55756,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"22500:18:100","memberName":"disputeGameFactory","nodeType":"MemberAccess","referencedDeclaration":53838,"src":"22471:47:100","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":55757,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"22471:49:100","tryCall":true,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"id":55772,"nodeType":"TryStatement","src":"22467:285:100"}]},"implemented":true,"kind":"function","modifiers":[],"name":"_getDisputeGameFactoryProxy","nameLocation":"22369:27:100","parameters":{"id":55749,"nodeType":"ParameterList","parameters":[{"constant":false,"id":55748,"mutability":"mutable","name":"_systemConfigProxy","nameLocation":"22405:18:100","nodeType":"VariableDeclaration","scope":55774,"src":"22397:26:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":55747,"name":"address","nodeType":"ElementaryTypeName","src":"22397:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"22396:28:100"},"returnParameters":{"id":55752,"nodeType":"ParameterList","parameters":[{"constant":false,"id":55751,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":55774,"src":"22448:7:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":55750,"name":"address","nodeType":"ElementaryTypeName","src":"22448:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"22447:9:100"},"scope":56018,"stateMutability":"view","virtual":false,"visibility":"internal"},{"id":55802,"nodeType":"FunctionDefinition","src":"22764:311:100","nodes":[],"body":{"id":55801,"nodeType":"Block","src":"22861:214:100","nodes":[],"statements":[{"clauses":[{"block":{"id":55791,"nodeType":"Block","src":"22966:54:100","statements":[{"expression":{"id":55789,"name":"superchainConfigProxy_","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55787,"src":"22987:22:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"functionReturnParameters":55780,"id":55790,"nodeType":"Return","src":"22980:29:100"}]},"errorName":"","id":55792,"nodeType":"TryCatchClause","parameters":{"id":55788,"nodeType":"ParameterList","parameters":[{"constant":false,"id":55787,"mutability":"mutable","name":"superchainConfigProxy_","nameLocation":"22942:22:100","nodeType":"VariableDeclaration","scope":55792,"src":"22934:30:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":55786,"name":"address","nodeType":"ElementaryTypeName","src":"22934:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"22933:32:100"},"src":"22925:95:100"},{"block":{"id":55798,"nodeType":"Block","src":"23027:42:100","statements":[{"expression":{"arguments":[{"hexValue":"30","id":55795,"isConstant":false,"isLValue":false,"isPure":true,"kind":"number","lValueRequested":false,"nodeType":"Literal","src":"23056:1:100","typeDescriptions":{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"},"value":"0"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"}],"id":55794,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"nodeType":"ElementaryTypeNameExpression","src":"23048:7:100","typeDescriptions":{"typeIdentifier":"t_type$_t_address_$","typeString":"type(address)"},"typeName":{"id":55793,"name":"address","nodeType":"ElementaryTypeName","src":"23048:7:100","typeDescriptions":{}}},"id":55796,"isConstant":false,"isLValue":false,"isPure":true,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"23048:10:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"functionReturnParameters":55780,"id":55797,"nodeType":"Return","src":"23041:17:100"}]},"errorName":"","id":55799,"nodeType":"TryCatchClause","src":"23021:48:100"}],"externalCall":{"arguments":[],"expression":{"argumentTypes":[],"expression":{"arguments":[{"id":55782,"name":"_optimismPortalProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55776,"src":"22884:20:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_address","typeString":"address"}],"id":55781,"name":"IFetcher","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":53958,"src":"22875:8:100","typeDescriptions":{"typeIdentifier":"t_type$_t_contract$_IFetcher_$53958_$","typeString":"type(contract IFetcher)"}},"id":55783,"isConstant":false,"isLValue":false,"isPure":false,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"22875:30:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_contract$_IFetcher_$53958","typeString":"contract IFetcher"}},"id":55784,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"22906:16:100","memberName":"superchainConfig","nodeType":"MemberAccess","referencedDeclaration":53848,"src":"22875:47:100","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":55785,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"22875:49:100","tryCall":true,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"id":55800,"nodeType":"TryStatement","src":"22871:198:100"}]},"implemented":true,"kind":"function","modifiers":[],"name":"_getSuperchainConfigProxy","nameLocation":"22773:25:100","parameters":{"id":55777,"nodeType":"ParameterList","parameters":[{"constant":false,"id":55776,"mutability":"mutable","name":"_optimismPortalProxy","nameLocation":"22807:20:100","nodeType":"VariableDeclaration","scope":55802,"src":"22799:28:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":55775,"name":"address","nodeType":"ElementaryTypeName","src":"22799:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"22798:30:100"},"returnParameters":{"id":55780,"nodeType":"ParameterList","parameters":[{"constant":false,"id":55779,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":55802,"src":"22852:7:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":55778,"name":"address","nodeType":"ElementaryTypeName","src":"22852:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"22851:9:100"},"scope":56018,"stateMutability":"view","virtual":false,"visibility":"internal"},{"id":55832,"nodeType":"FunctionDefinition","src":"23081:313:100","nodes":[],"body":{"id":55831,"nodeType":"Block","src":"23177:217:100","nodes":[],"statements":[{"clauses":[{"block":{"id":55821,"nodeType":"Block","src":"23290:49:100","statements":[{"expression":{"id":55819,"name":"faultDisputeGame_","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55817,"src":"23311:17:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"functionReturnParameters":55808,"id":55820,"nodeType":"Return","src":"23304:24:100"}]},"errorName":"","id":55822,"nodeType":"TryCatchClause","parameters":{"id":55818,"nodeType":"ParameterList","parameters":[{"constant":false,"id":55817,"mutability":"mutable","name":"faultDisputeGame_","nameLocation":"23271:17:100","nodeType":"VariableDeclaration","scope":55822,"src":"23263:25:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":55816,"name":"address","nodeType":"ElementaryTypeName","src":"23263:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"23262:27:100"},"src":"23254:85:100"},{"block":{"id":55828,"nodeType":"Block","src":"23346:42:100","statements":[{"expression":{"arguments":[{"hexValue":"30","id":55825,"isConstant":false,"isLValue":false,"isPure":true,"kind":"number","lValueRequested":false,"nodeType":"Literal","src":"23375:1:100","typeDescriptions":{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"},"value":"0"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"}],"id":55824,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"nodeType":"ElementaryTypeNameExpression","src":"23367:7:100","typeDescriptions":{"typeIdentifier":"t_type$_t_address_$","typeString":"type(address)"},"typeName":{"id":55823,"name":"address","nodeType":"ElementaryTypeName","src":"23367:7:100","typeDescriptions":{}}},"id":55826,"isConstant":false,"isLValue":false,"isPure":true,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"23367:10:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"functionReturnParameters":55808,"id":55827,"nodeType":"Return","src":"23360:17:100"}]},"errorName":"","id":55829,"nodeType":"TryCatchClause","src":"23340:48:100"}],"externalCall":{"arguments":[{"expression":{"id":55813,"name":"GameTypes","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":70870,"src":"23236:9:100","typeDescriptions":{"typeIdentifier":"t_type$_t_contract$_GameTypes_$70870_$","typeString":"type(library GameTypes)"}},"id":55814,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"memberLocation":"23246:6:100","memberName":"CANNON","nodeType":"MemberAccess","referencedDeclaration":70773,"src":"23236:16:100","typeDescriptions":{"typeIdentifier":"t_userDefinedValueType$_GameType_$70720","typeString":"GameType"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_userDefinedValueType$_GameType_$70720","typeString":"GameType"}],"expression":{"arguments":[{"id":55810,"name":"_disputeGameFactoryProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55804,"src":"23200:24:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_address","typeString":"address"}],"id":55809,"name":"IFetcher","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":53958,"src":"23191:8:100","typeDescriptions":{"typeIdentifier":"t_type$_t_contract$_IFetcher_$53958_$","typeString":"type(contract IFetcher)"}},"id":55811,"isConstant":false,"isLValue":false,"isPure":false,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"23191:34:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_contract$_IFetcher_$53958","typeString":"contract IFetcher"}},"id":55812,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"23226:9:100","memberName":"gameImpls","nodeType":"MemberAccess","referencedDeclaration":53886,"src":"23191:44:100","typeDescriptions":{"typeIdentifier":"t_function_external_view$_t_userDefinedValueType$_GameType_$70720_$returns$_t_address_$","typeString":"function (GameType) view external returns (address)"}},"id":55815,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"23191:62:100","tryCall":true,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"id":55830,"nodeType":"TryStatement","src":"23187:201:100"}]},"implemented":true,"kind":"function","modifiers":[],"name":"_getFaultDisputeGame","nameLocation":"23090:20:100","parameters":{"id":55805,"nodeType":"ParameterList","parameters":[{"constant":false,"id":55804,"mutability":"mutable","name":"_disputeGameFactoryProxy","nameLocation":"23119:24:100","nodeType":"VariableDeclaration","scope":55832,"src":"23111:32:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":55803,"name":"address","nodeType":"ElementaryTypeName","src":"23111:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"23110:34:100"},"returnParameters":{"id":55808,"nodeType":"ParameterList","parameters":[{"constant":false,"id":55807,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":55832,"src":"23168:7:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":55806,"name":"address","nodeType":"ElementaryTypeName","src":"23168:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"23167:9:100"},"scope":56018,"stateMutability":"view","virtual":false,"visibility":"internal"},{"id":55864,"nodeType":"FunctionDefinition","src":"23400:376:100","nodes":[],"body":{"id":55863,"nodeType":"Block","src":"23566:210:100","nodes":[],"statements":[{"clauses":[{"block":{"id":55853,"nodeType":"Block","src":"23672:49:100","statements":[{"expression":{"id":55851,"name":"faultDisputeGame_","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55849,"src":"23693:17:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"functionReturnParameters":55841,"id":55852,"nodeType":"Return","src":"23686:24:100"}]},"errorName":"","id":55854,"nodeType":"TryCatchClause","parameters":{"id":55850,"nodeType":"ParameterList","parameters":[{"constant":false,"id":55849,"mutability":"mutable","name":"faultDisputeGame_","nameLocation":"23653:17:100","nodeType":"VariableDeclaration","scope":55854,"src":"23645:25:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":55848,"name":"address","nodeType":"ElementaryTypeName","src":"23645:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"23644:27:100"},"src":"23636:85:100"},{"block":{"id":55860,"nodeType":"Block","src":"23728:42:100","statements":[{"expression":{"arguments":[{"hexValue":"30","id":55857,"isConstant":false,"isLValue":false,"isPure":true,"kind":"number","lValueRequested":false,"nodeType":"Literal","src":"23757:1:100","typeDescriptions":{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"},"value":"0"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"}],"id":55856,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"nodeType":"ElementaryTypeNameExpression","src":"23749:7:100","typeDescriptions":{"typeIdentifier":"t_type$_t_address_$","typeString":"type(address)"},"typeName":{"id":55855,"name":"address","nodeType":"ElementaryTypeName","src":"23749:7:100","typeDescriptions":{}}},"id":55858,"isConstant":false,"isLValue":false,"isPure":true,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"23749:10:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"functionReturnParameters":55841,"id":55859,"nodeType":"Return","src":"23742:17:100"}]},"errorName":"","id":55861,"nodeType":"TryCatchClause","src":"23722:48:100"}],"externalCall":{"arguments":[{"id":55846,"name":"_gameType","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55837,"src":"23625:9:100","typeDescriptions":{"typeIdentifier":"t_userDefinedValueType$_GameType_$70720","typeString":"GameType"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_userDefinedValueType$_GameType_$70720","typeString":"GameType"}],"expression":{"arguments":[{"id":55843,"name":"_disputeGameFactoryProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55834,"src":"23589:24:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_address","typeString":"address"}],"id":55842,"name":"IFetcher","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":53958,"src":"23580:8:100","typeDescriptions":{"typeIdentifier":"t_type$_t_contract$_IFetcher_$53958_$","typeString":"type(contract IFetcher)"}},"id":55844,"isConstant":false,"isLValue":false,"isPure":false,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"23580:34:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_contract$_IFetcher_$53958","typeString":"contract IFetcher"}},"id":55845,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"23615:9:100","memberName":"gameImpls","nodeType":"MemberAccess","referencedDeclaration":53886,"src":"23580:44:100","typeDescriptions":{"typeIdentifier":"t_function_external_view$_t_userDefinedValueType$_GameType_$70720_$returns$_t_address_$","typeString":"function (GameType) view external returns (address)"}},"id":55847,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"23580:55:100","tryCall":true,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"id":55862,"nodeType":"TryStatement","src":"23576:194:100"}]},"implemented":true,"kind":"function","modifiers":[],"name":"_getFaultDisputeGame","nameLocation":"23409:20:100","parameters":{"id":55838,"nodeType":"ParameterList","parameters":[{"constant":false,"id":55834,"mutability":"mutable","name":"_disputeGameFactoryProxy","nameLocation":"23447:24:100","nodeType":"VariableDeclaration","scope":55864,"src":"23439:32:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":55833,"name":"address","nodeType":"ElementaryTypeName","src":"23439:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"},{"constant":false,"id":55837,"mutability":"mutable","name":"_gameType","nameLocation":"23490:9:100","nodeType":"VariableDeclaration","scope":55864,"src":"23481:18:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_userDefinedValueType$_GameType_$70720","typeString":"GameType"},"typeName":{"id":55836,"nodeType":"UserDefinedTypeName","pathNode":{"id":55835,"name":"GameType","nameLocations":["23481:8:100"],"nodeType":"IdentifierPath","referencedDeclaration":70720,"src":"23481:8:100"},"referencedDeclaration":70720,"src":"23481:8:100","typeDescriptions":{"typeIdentifier":"t_userDefinedValueType$_GameType_$70720","typeString":"GameType"}},"visibility":"internal"}],"src":"23429:76:100"},"returnParameters":{"id":55841,"nodeType":"ParameterList","parameters":[{"constant":false,"id":55840,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":55864,"src":"23553:7:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":55839,"name":"address","nodeType":"ElementaryTypeName","src":"23553:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"23552:9:100"},"scope":56018,"stateMutability":"view","virtual":false,"visibility":"internal"},{"id":55894,"nodeType":"FunctionDefinition","src":"23782:369:100","nodes":[],"body":{"id":55893,"nodeType":"Block","src":"23885:266:100","nodes":[],"statements":[{"clauses":[{"block":{"id":55883,"nodeType":"Block","src":"24040:56:100","statements":[{"expression":{"id":55881,"name":"permissionedDisputeGame_","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55879,"src":"24061:24:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"functionReturnParameters":55870,"id":55882,"nodeType":"Return","src":"24054:31:100"}]},"errorName":"","id":55884,"nodeType":"TryCatchClause","parameters":{"id":55880,"nodeType":"ParameterList","parameters":[{"constant":false,"id":55879,"mutability":"mutable","name":"permissionedDisputeGame_","nameLocation":"24005:24:100","nodeType":"VariableDeclaration","scope":55884,"src":"23997:32:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":55878,"name":"address","nodeType":"ElementaryTypeName","src":"23997:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"23983:56:100"},"src":"23975:121:100"},{"block":{"id":55890,"nodeType":"Block","src":"24103:42:100","statements":[{"expression":{"arguments":[{"hexValue":"30","id":55887,"isConstant":false,"isLValue":false,"isPure":true,"kind":"number","lValueRequested":false,"nodeType":"Literal","src":"24132:1:100","typeDescriptions":{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"},"value":"0"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"}],"id":55886,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"nodeType":"ElementaryTypeNameExpression","src":"24124:7:100","typeDescriptions":{"typeIdentifier":"t_type$_t_address_$","typeString":"type(address)"},"typeName":{"id":55885,"name":"address","nodeType":"ElementaryTypeName","src":"24124:7:100","typeDescriptions":{}}},"id":55888,"isConstant":false,"isLValue":false,"isPure":true,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"24124:10:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"functionReturnParameters":55870,"id":55889,"nodeType":"Return","src":"24117:17:100"}]},"errorName":"","id":55891,"nodeType":"TryCatchClause","src":"24097:48:100"}],"externalCall":{"arguments":[{"expression":{"id":55875,"name":"GameTypes","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":70870,"src":"23944:9:100","typeDescriptions":{"typeIdentifier":"t_type$_t_contract$_GameTypes_$70870_$","typeString":"type(library GameTypes)"}},"id":55876,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"memberLocation":"23954:19:100","memberName":"PERMISSIONED_CANNON","nodeType":"MemberAccess","referencedDeclaration":70781,"src":"23944:29:100","typeDescriptions":{"typeIdentifier":"t_userDefinedValueType$_GameType_$70720","typeString":"GameType"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_userDefinedValueType$_GameType_$70720","typeString":"GameType"}],"expression":{"arguments":[{"id":55872,"name":"_disputeGameFactoryProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55866,"src":"23908:24:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_address","typeString":"address"}],"id":55871,"name":"IFetcher","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":53958,"src":"23899:8:100","typeDescriptions":{"typeIdentifier":"t_type$_t_contract$_IFetcher_$53958_$","typeString":"type(contract IFetcher)"}},"id":55873,"isConstant":false,"isLValue":false,"isPure":false,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"23899:34:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_contract$_IFetcher_$53958","typeString":"contract IFetcher"}},"id":55874,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"23934:9:100","memberName":"gameImpls","nodeType":"MemberAccess","referencedDeclaration":53886,"src":"23899:44:100","typeDescriptions":{"typeIdentifier":"t_function_external_view$_t_userDefinedValueType$_GameType_$70720_$returns$_t_address_$","typeString":"function (GameType) view external returns (address)"}},"id":55877,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"23899:75:100","tryCall":true,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"id":55892,"nodeType":"TryStatement","src":"23895:250:100"}]},"implemented":true,"kind":"function","modifiers":[],"name":"_getPermissionedDisputeGame","nameLocation":"23791:27:100","parameters":{"id":55867,"nodeType":"ParameterList","parameters":[{"constant":false,"id":55866,"mutability":"mutable","name":"_disputeGameFactoryProxy","nameLocation":"23827:24:100","nodeType":"VariableDeclaration","scope":55894,"src":"23819:32:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":55865,"name":"address","nodeType":"ElementaryTypeName","src":"23819:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"23818:34:100"},"returnParameters":{"id":55870,"nodeType":"ParameterList","parameters":[{"constant":false,"id":55869,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":55894,"src":"23876:7:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":55868,"name":"address","nodeType":"ElementaryTypeName","src":"23876:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"23875:9:100"},"scope":56018,"stateMutability":"view","virtual":false,"visibility":"internal"},{"id":55922,"nodeType":"FunctionDefinition","src":"24157:277:100","nodes":[],"body":{"id":55921,"nodeType":"Block","src":"24248:186:100","nodes":[],"statements":[{"clauses":[{"block":{"id":55911,"nodeType":"Block","src":"24336:43:100","statements":[{"expression":{"id":55909,"name":"ethLockbox_","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55907,"src":"24357:11:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"functionReturnParameters":55900,"id":55910,"nodeType":"Return","src":"24350:18:100"}]},"errorName":"","id":55912,"nodeType":"TryCatchClause","parameters":{"id":55908,"nodeType":"ParameterList","parameters":[{"constant":false,"id":55907,"mutability":"mutable","name":"ethLockbox_","nameLocation":"24323:11:100","nodeType":"VariableDeclaration","scope":55912,"src":"24315:19:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":55906,"name":"address","nodeType":"ElementaryTypeName","src":"24315:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"24314:21:100"},"src":"24306:73:100"},{"block":{"id":55918,"nodeType":"Block","src":"24386:42:100","statements":[{"expression":{"arguments":[{"hexValue":"30","id":55915,"isConstant":false,"isLValue":false,"isPure":true,"kind":"number","lValueRequested":false,"nodeType":"Literal","src":"24415:1:100","typeDescriptions":{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"},"value":"0"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"}],"id":55914,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"nodeType":"ElementaryTypeNameExpression","src":"24407:7:100","typeDescriptions":{"typeIdentifier":"t_type$_t_address_$","typeString":"type(address)"},"typeName":{"id":55913,"name":"address","nodeType":"ElementaryTypeName","src":"24407:7:100","typeDescriptions":{}}},"id":55916,"isConstant":false,"isLValue":false,"isPure":true,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"24407:10:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"functionReturnParameters":55900,"id":55917,"nodeType":"Return","src":"24400:17:100"}]},"errorName":"","id":55919,"nodeType":"TryCatchClause","src":"24380:48:100"}],"externalCall":{"arguments":[],"expression":{"argumentTypes":[],"expression":{"arguments":[{"id":55902,"name":"_optimismPortalProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55896,"src":"24271:20:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_address","typeString":"address"}],"id":55901,"name":"IFetcher","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":53958,"src":"24262:8:100","typeDescriptions":{"typeIdentifier":"t_type$_t_contract$_IFetcher_$53958_$","typeString":"type(contract IFetcher)"}},"id":55903,"isConstant":false,"isLValue":false,"isPure":false,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"24262:30:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_contract$_IFetcher_$53958","typeString":"contract IFetcher"}},"id":55904,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"24293:10:100","memberName":"ethLockbox","nodeType":"MemberAccess","referencedDeclaration":53843,"src":"24262:41:100","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":55905,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"24262:43:100","tryCall":true,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"id":55920,"nodeType":"TryStatement","src":"24258:170:100"}]},"implemented":true,"kind":"function","modifiers":[],"name":"_getEthLockboxProxy","nameLocation":"24166:19:100","parameters":{"id":55897,"nodeType":"ParameterList","parameters":[{"constant":false,"id":55896,"mutability":"mutable","name":"_optimismPortalProxy","nameLocation":"24194:20:100","nodeType":"VariableDeclaration","scope":55922,"src":"24186:28:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":55895,"name":"address","nodeType":"ElementaryTypeName","src":"24186:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"24185:30:100"},"returnParameters":{"id":55900,"nodeType":"ParameterList","parameters":[{"constant":false,"id":55899,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":55922,"src":"24239:7:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":55898,"name":"address","nodeType":"ElementaryTypeName","src":"24239:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"24238:9:100"},"scope":56018,"stateMutability":"view","virtual":false,"visibility":"internal"},{"id":55967,"nodeType":"FunctionDefinition","src":"24440:304:100","nodes":[],"body":{"id":55966,"nodeType":"Block","src":"24524:220:100","nodes":[],"statements":[{"assignments":[55930,55932],"declarations":[{"constant":false,"id":55930,"mutability":"mutable","name":"ok","nameLocation":"24540:2:100","nodeType":"VariableDeclaration","scope":55966,"src":"24535:7:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"},"typeName":{"id":55929,"name":"bool","nodeType":"ElementaryTypeName","src":"24535:4:100","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},"visibility":"internal"},{"constant":false,"id":55932,"mutability":"mutable","name":"data","nameLocation":"24557:4:100","nodeType":"VariableDeclaration","scope":55966,"src":"24544:17:100","stateVariable":false,"storageLocation":"memory","typeDescriptions":{"typeIdentifier":"t_bytes_memory_ptr","typeString":"bytes"},"typeName":{"id":55931,"name":"bytes","nodeType":"ElementaryTypeName","src":"24544:5:100","typeDescriptions":{"typeIdentifier":"t_bytes_storage_ptr","typeString":"bytes"}},"visibility":"internal"}],"id":55945,"initialValue":{"arguments":[{"arguments":[{"expression":{"id":55940,"name":"IFetcher","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":53958,"src":"24613:8:100","typeDescriptions":{"typeIdentifier":"t_type$_t_contract$_IFetcher_$53958_$","typeString":"type(contract IFetcher)"}},"id":55941,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"memberLocation":"24622:4:100","memberName":"weth","nodeType":"MemberAccess","referencedDeclaration":53957,"src":"24613:13:100","typeDescriptions":{"typeIdentifier":"t_function_declaration_view$__$returns$_t_address_$","typeString":"function IFetcher.weth() view returns (address)"}},{"components":[],"id":55942,"isConstant":false,"isInlineArray":false,"isLValue":false,"isPure":true,"lValueRequested":false,"nodeType":"TupleExpression","src":"24628:2:100","typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_function_declaration_view$__$returns$_t_address_$","typeString":"function IFetcher.weth() view returns (address)"},{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}],"expression":{"id":55938,"name":"abi","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":-1,"src":"24598:3:100","typeDescriptions":{"typeIdentifier":"t_magic_abi","typeString":"abi"}},"id":55939,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"memberLocation":"24602:10:100","memberName":"encodeCall","nodeType":"MemberAccess","src":"24598:14:100","typeDescriptions":{"typeIdentifier":"t_function_abiencodecall_pure$__$returns$_t_bytes_memory_ptr_$","typeString":"function () pure returns (bytes memory)"}},"id":55943,"isConstant":false,"isLValue":false,"isPure":true,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"24598:33:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_bytes_memory_ptr","typeString":"bytes memory"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_bytes_memory_ptr","typeString":"bytes memory"}],"expression":{"arguments":[{"id":55935,"name":"_disputeGame","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55924,"src":"24573:12:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_address","typeString":"address"}],"id":55934,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"nodeType":"ElementaryTypeNameExpression","src":"24565:7:100","typeDescriptions":{"typeIdentifier":"t_type$_t_address_$","typeString":"type(address)"},"typeName":{"id":55933,"name":"address","nodeType":"ElementaryTypeName","src":"24565:7:100","typeDescriptions":{}}},"id":55936,"isConstant":false,"isLValue":false,"isPure":false,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"24565:21:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"id":55937,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"24587:10:100","memberName":"staticcall","nodeType":"MemberAccess","src":"24565:32:100","typeDescriptions":{"typeIdentifier":"t_function_barestaticcall_view$_t_bytes_memory_ptr_$returns$_t_bool_$_t_bytes_memory_ptr_$","typeString":"function (bytes memory) view returns (bool,bytes memory)"}},"id":55944,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"24565:67:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$_t_bool_$_t_bytes_memory_ptr_$","typeString":"tuple(bool,bytes memory)"}},"nodeType":"VariableDeclarationStatement","src":"24534:98:100"},{"condition":{"commonType":{"typeIdentifier":"t_bool","typeString":"bool"},"id":55951,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftExpression":{"id":55946,"name":"ok","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55930,"src":"24646:2:100","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},"nodeType":"BinaryOperation","operator":"&&","rightExpression":{"commonType":{"typeIdentifier":"t_uint256","typeString":"uint256"},"id":55950,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftExpression":{"expression":{"id":55947,"name":"data","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55932,"src":"24652:4:100","typeDescriptions":{"typeIdentifier":"t_bytes_memory_ptr","typeString":"bytes memory"}},"id":55948,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"24657:6:100","memberName":"length","nodeType":"MemberAccess","src":"24652:11:100","typeDescriptions":{"typeIdentifier":"t_uint256","typeString":"uint256"}},"nodeType":"BinaryOperation","operator":"==","rightExpression":{"hexValue":"3332","id":55949,"isConstant":false,"isLValue":false,"isPure":true,"kind":"number","lValueRequested":false,"nodeType":"Literal","src":"24667:2:100","typeDescriptions":{"typeIdentifier":"t_rational_32_by_1","typeString":"int_const 32"},"value":"32"},"src":"24652:17:100","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},"src":"24646:23:100","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},"falseBody":{"expression":{"arguments":[{"hexValue":"30","id":55962,"isConstant":false,"isLValue":false,"isPure":true,"kind":"number","lValueRequested":false,"nodeType":"Literal","src":"24735:1:100","typeDescriptions":{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"},"value":"0"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"}],"id":55961,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"nodeType":"ElementaryTypeNameExpression","src":"24727:7:100","typeDescriptions":{"typeIdentifier":"t_type$_t_address_$","typeString":"type(address)"},"typeName":{"id":55960,"name":"address","nodeType":"ElementaryTypeName","src":"24727:7:100","typeDescriptions":{}}},"id":55963,"isConstant":false,"isLValue":false,"isPure":true,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"24727:10:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"functionReturnParameters":55928,"id":55964,"nodeType":"Return","src":"24720:17:100"},"id":55965,"nodeType":"IfStatement","src":"24642:95:100","trueBody":{"expression":{"arguments":[{"id":55954,"name":"data","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55932,"src":"24689:4:100","typeDescriptions":{"typeIdentifier":"t_bytes_memory_ptr","typeString":"bytes memory"}},{"components":[{"id":55956,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"nodeType":"ElementaryTypeNameExpression","src":"24696:7:100","typeDescriptions":{"typeIdentifier":"t_type$_t_address_$","typeString":"type(address)"},"typeName":{"id":55955,"name":"address","nodeType":"ElementaryTypeName","src":"24696:7:100","typeDescriptions":{}}}],"id":55957,"isConstant":false,"isInlineArray":false,"isLValue":false,"isPure":true,"lValueRequested":false,"nodeType":"TupleExpression","src":"24695:9:100","typeDescriptions":{"typeIdentifier":"t_type$_t_address_$","typeString":"type(address)"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_bytes_memory_ptr","typeString":"bytes memory"},{"typeIdentifier":"t_type$_t_address_$","typeString":"type(address)"}],"expression":{"id":55952,"name":"abi","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":-1,"src":"24678:3:100","typeDescriptions":{"typeIdentifier":"t_magic_abi","typeString":"abi"}},"id":55953,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"memberLocation":"24682:6:100","memberName":"decode","nodeType":"MemberAccess","src":"24678:10:100","typeDescriptions":{"typeIdentifier":"t_function_abidecode_pure$__$returns$__$","typeString":"function () pure"}},"id":55958,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"24678:27:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address_payable","typeString":"address payable"}},"functionReturnParameters":55928,"id":55959,"nodeType":"Return","src":"24671:34:100"}}]},"implemented":true,"kind":"function","modifiers":[],"name":"_getDelayedWETHProxy","nameLocation":"24449:20:100","parameters":{"id":55925,"nodeType":"ParameterList","parameters":[{"constant":false,"id":55924,"mutability":"mutable","name":"_disputeGame","nameLocation":"24478:12:100","nodeType":"VariableDeclaration","scope":55967,"src":"24470:20:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":55923,"name":"address","nodeType":"ElementaryTypeName","src":"24470:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"24469:22:100"},"returnParameters":{"id":55928,"nodeType":"ParameterList","parameters":[{"constant":false,"id":55927,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":55967,"src":"24515:7:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":55926,"name":"address","nodeType":"ElementaryTypeName","src":"24515:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"24514:9:100"},"scope":56018,"stateMutability":"view","virtual":false,"visibility":"internal"},{"id":55994,"nodeType":"FunctionDefinition","src":"24750:224:100","nodes":[],"body":{"id":55993,"nodeType":"Block","src":"24838:136:100","nodes":[],"statements":[{"assignments":[55975],"declarations":[{"constant":false,"id":55975,"mutability":"mutable","name":"batcherHash","nameLocation":"24856:11:100","nodeType":"VariableDeclaration","scope":55993,"src":"24848:19:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_bytes32","typeString":"bytes32"},"typeName":{"id":55974,"name":"bytes32","nodeType":"ElementaryTypeName","src":"24848:7:100","typeDescriptions":{"typeIdentifier":"t_bytes32","typeString":"bytes32"}},"visibility":"internal"}],"id":55981,"initialValue":{"arguments":[],"expression":{"argumentTypes":[],"expression":{"arguments":[{"id":55977,"name":"_systemConfigProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55969,"src":"24879:18:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_address","typeString":"address"}],"id":55976,"name":"IFetcher","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":53958,"src":"24870:8:100","typeDescriptions":{"typeIdentifier":"t_type$_t_contract$_IFetcher_$53958_$","typeString":"type(contract IFetcher)"}},"id":55978,"isConstant":false,"isLValue":false,"isPure":false,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"24870:28:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_contract$_IFetcher_$53958","typeString":"contract IFetcher"}},"id":55979,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"24899:11:100","memberName":"batcherHash","nodeType":"MemberAccess","referencedDeclaration":53937,"src":"24870:40:100","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_bytes32_$","typeString":"function () view external returns (bytes32)"}},"id":55980,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"24870:42:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_bytes32","typeString":"bytes32"}},"nodeType":"VariableDeclarationStatement","src":"24848:64:100"},{"expression":{"arguments":[{"arguments":[{"arguments":[{"id":55988,"name":"batcherHash","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55975,"src":"24953:11:100","typeDescriptions":{"typeIdentifier":"t_bytes32","typeString":"bytes32"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_bytes32","typeString":"bytes32"}],"id":55987,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"nodeType":"ElementaryTypeNameExpression","src":"24945:7:100","typeDescriptions":{"typeIdentifier":"t_type$_t_uint256_$","typeString":"type(uint256)"},"typeName":{"id":55986,"name":"uint256","nodeType":"ElementaryTypeName","src":"24945:7:100","typeDescriptions":{}}},"id":55989,"isConstant":false,"isLValue":false,"isPure":false,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"24945:20:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_uint256","typeString":"uint256"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_uint256","typeString":"uint256"}],"id":55985,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"nodeType":"ElementaryTypeNameExpression","src":"24937:7:100","typeDescriptions":{"typeIdentifier":"t_type$_t_uint160_$","typeString":"type(uint160)"},"typeName":{"id":55984,"name":"uint160","nodeType":"ElementaryTypeName","src":"24937:7:100","typeDescriptions":{}}},"id":55990,"isConstant":false,"isLValue":false,"isPure":false,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"24937:29:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_uint160","typeString":"uint160"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_uint160","typeString":"uint160"}],"id":55983,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"nodeType":"ElementaryTypeNameExpression","src":"24929:7:100","typeDescriptions":{"typeIdentifier":"t_type$_t_address_$","typeString":"type(address)"},"typeName":{"id":55982,"name":"address","nodeType":"ElementaryTypeName","src":"24929:7:100","typeDescriptions":{}}},"id":55991,"isConstant":false,"isLValue":false,"isPure":false,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"24929:38:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"functionReturnParameters":55973,"id":55992,"nodeType":"Return","src":"24922:45:100"}]},"implemented":true,"kind":"function","modifiers":[],"name":"_getBatchSubmitter","nameLocation":"24759:18:100","parameters":{"id":55970,"nodeType":"ParameterList","parameters":[{"constant":false,"id":55969,"mutability":"mutable","name":"_systemConfigProxy","nameLocation":"24786:18:100","nodeType":"VariableDeclaration","scope":55994,"src":"24778:26:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":55968,"name":"address","nodeType":"ElementaryTypeName","src":"24778:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"24777:28:100"},"returnParameters":{"id":55973,"nodeType":"ParameterList","parameters":[{"constant":false,"id":55972,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":55994,"src":"24829:7:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":55971,"name":"address","nodeType":"ElementaryTypeName","src":"24829:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"24828:9:100"},"scope":56018,"stateMutability":"view","virtual":false,"visibility":"internal"},{"id":56017,"nodeType":"FunctionDefinition","src":"24980:169:100","nodes":[],"body":{"id":56016,"nodeType":"Block","src":"25059:90:100","nodes":[],"statements":[{"expression":{"arguments":[{"arguments":[{"hexValue":"30","id":56006,"isConstant":false,"isLValue":false,"isPure":true,"kind":"number","lValueRequested":false,"nodeType":"Literal","src":"25086:1:100","typeDescriptions":{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"},"value":"0"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"}],"id":56005,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"nodeType":"ElementaryTypeNameExpression","src":"25078:7:100","typeDescriptions":{"typeIdentifier":"t_type$_t_address_$","typeString":"type(address)"},"typeName":{"id":56004,"name":"address","nodeType":"ElementaryTypeName","src":"25078:7:100","typeDescriptions":{}}},"id":56007,"isConstant":false,"isLValue":false,"isPure":true,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"25078:10:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_address","typeString":"address"}],"expression":{"id":56001,"name":"vm","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":5501,"src":"25069:2:100","typeDescriptions":{"typeIdentifier":"t_contract$_Vm_$23288","typeString":"contract Vm"}},"id":56003,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"25072:5:100","memberName":"prank","nodeType":"MemberAccess","referencedDeclaration":22581,"src":"25069:8:100","typeDescriptions":{"typeIdentifier":"t_function_external_nonpayable$_t_address_$returns$__$","typeString":"function (address) external"}},"id":56008,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"25069:20:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":56009,"nodeType":"ExpressionStatement","src":"25069:20:100"},{"expression":{"arguments":[],"expression":{"argumentTypes":[],"expression":{"arguments":[{"id":56011,"name":"_systemConfigProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55996,"src":"25115:18:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_address","typeString":"address"}],"id":56010,"name":"IFetcher","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":53958,"src":"25106:8:100","typeDescriptions":{"typeIdentifier":"t_type$_t_contract$_IFetcher_$53958_$","typeString":"type(contract IFetcher)"}},"id":56012,"isConstant":false,"isLValue":false,"isPure":false,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"25106:28:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_contract$_IFetcher_$53958","typeString":"contract IFetcher"}},"id":56013,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"25135:5:100","memberName":"admin","nodeType":"MemberAccess","referencedDeclaration":53942,"src":"25106:34:100","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":56014,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"25106:36:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"functionReturnParameters":56000,"id":56015,"nodeType":"Return","src":"25099:43:100"}]},"implemented":true,"kind":"function","modifiers":[],"name":"_getProxyAdmin","nameLocation":"24989:14:100","parameters":{"id":55997,"nodeType":"ParameterList","parameters":[{"constant":false,"id":55996,"mutability":"mutable","name":"_systemConfigProxy","nameLocation":"25012:18:100","nodeType":"VariableDeclaration","scope":56017,"src":"25004:26:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":55995,"name":"address","nodeType":"ElementaryTypeName","src":"25004:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"25003:28:100"},"returnParameters":{"id":56000,"nodeType":"ParameterList","parameters":[{"constant":false,"id":55999,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":56017,"src":"25050:7:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":55998,"name":"address","nodeType":"ElementaryTypeName","src":"25050:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"25049:9:100"},"scope":56018,"stateMutability":"nonpayable","virtual":false,"visibility":"internal"}],"abstract":false,"baseContracts":[{"baseName":{"id":54912,"name":"Script","nameLocations":["13628:6:100"],"nodeType":"IdentifierPath","referencedDeclaration":5558,"src":"13628:6:100"},"id":54913,"nodeType":"InheritanceSpecifier","src":"13628:6:100"}],"canonicalName":"FetchChainInfo","contractDependencies":[],"contractKind":"contract","fullyImplemented":true,"linearizedBaseContracts":[56018,5558,18381,11222,9132,5517,5505],"name":"FetchChainInfo","nameLocation":"13610:14:100","scope":56019,"usedErrors":[],"usedEvents":[]}],"license":"MIT"},"id":100} \ No newline at end of file diff --git a/op-fetcher/pkg/fetcher/fetch/forge-artifacts/FetchChainInfo.s.sol/IFetcher.json b/op-fetcher/pkg/fetcher/fetch/forge-artifacts/FetchChainInfo.s.sol/IFetcher.json index 89a7b3d9dcb..9c085686291 100644 --- a/op-fetcher/pkg/fetcher/fetch/forge-artifacts/FetchChainInfo.s.sol/IFetcher.json +++ b/op-fetcher/pkg/fetcher/fetch/forge-artifacts/FetchChainInfo.s.sol/IFetcher.json @@ -1 +1 @@ -{"abi":[{"type":"function","name":"GUARDIAN","inputs":[],"outputs":[{"name":"","type":"address","internalType":"address"}],"stateMutability":"view"},{"type":"function","name":"L2_ORACLE","inputs":[],"outputs":[{"name":"","type":"address","internalType":"address"}],"stateMutability":"view"},{"type":"function","name":"PORTAL","inputs":[],"outputs":[{"name":"","type":"address","internalType":"address"}],"stateMutability":"view"},{"type":"function","name":"PROPOSER","inputs":[],"outputs":[{"name":"","type":"address","internalType":"address"}],"stateMutability":"view"},{"type":"function","name":"SYSTEM_CONFIG","inputs":[],"outputs":[{"name":"","type":"address","internalType":"address"}],"stateMutability":"view"},{"type":"function","name":"addressManager","inputs":[],"outputs":[{"name":"","type":"address","internalType":"address"}],"stateMutability":"view"},{"type":"function","name":"admin","inputs":[],"outputs":[{"name":"","type":"address","internalType":"address"}],"stateMutability":"view"},{"type":"function","name":"anchorStateRegistry","inputs":[],"outputs":[{"name":"","type":"address","internalType":"address"}],"stateMutability":"view"},{"type":"function","name":"batcherHash","inputs":[],"outputs":[{"name":"","type":"bytes32","internalType":"bytes32"}],"stateMutability":"view"},{"type":"function","name":"challenger","inputs":[],"outputs":[{"name":"","type":"address","internalType":"address"}],"stateMutability":"view"},{"type":"function","name":"disputeGameFactory","inputs":[],"outputs":[{"name":"","type":"address","internalType":"address"}],"stateMutability":"view"},{"type":"function","name":"ethLockbox","inputs":[],"outputs":[{"name":"","type":"address","internalType":"address"}],"stateMutability":"view"},{"type":"function","name":"gameImpls","inputs":[{"name":"_gameType","type":"uint32","internalType":"GameType"}],"outputs":[{"name":"","type":"address","internalType":"address"}],"stateMutability":"view"},{"type":"function","name":"guardian","inputs":[],"outputs":[{"name":"","type":"address","internalType":"address"}],"stateMutability":"view"},{"type":"function","name":"l1ERC721Bridge","inputs":[],"outputs":[{"name":"","type":"address","internalType":"address"}],"stateMutability":"view"},{"type":"function","name":"l2Oracle","inputs":[],"outputs":[{"name":"","type":"address","internalType":"address"}],"stateMutability":"view"},{"type":"function","name":"messenger","inputs":[],"outputs":[{"name":"","type":"address","internalType":"address"}],"stateMutability":"view"},{"type":"function","name":"optimismMintableERC20Factory","inputs":[],"outputs":[{"name":"","type":"address","internalType":"address"}],"stateMutability":"view"},{"type":"function","name":"oracle","inputs":[],"outputs":[{"name":"","type":"address","internalType":"address"}],"stateMutability":"view"},{"type":"function","name":"owner","inputs":[],"outputs":[{"name":"","type":"address","internalType":"address"}],"stateMutability":"view"},{"type":"function","name":"portal","inputs":[],"outputs":[{"name":"","type":"address","internalType":"address"}],"stateMutability":"view"},{"type":"function","name":"proposer","inputs":[],"outputs":[{"name":"","type":"address","internalType":"address"}],"stateMutability":"view"},{"type":"function","name":"respectedGameType","inputs":[],"outputs":[{"name":"","type":"uint32","internalType":"GameType"}],"stateMutability":"view"},{"type":"function","name":"superchainConfig","inputs":[],"outputs":[{"name":"","type":"address","internalType":"address"}],"stateMutability":"view"},{"type":"function","name":"systemConfig","inputs":[],"outputs":[{"name":"","type":"address","internalType":"address"}],"stateMutability":"view"},{"type":"function","name":"unsafeBlockSigner","inputs":[],"outputs":[{"name":"","type":"address","internalType":"address"}],"stateMutability":"view"},{"type":"function","name":"vm","inputs":[],"outputs":[{"name":"","type":"address","internalType":"address"}],"stateMutability":"view"},{"type":"function","name":"weth","inputs":[],"outputs":[{"name":"","type":"address","internalType":"address"}],"stateMutability":"view"}],"bytecode":{"object":"0x","sourceMap":"","linkReferences":{}},"deployedBytecode":{"object":"0x","sourceMap":"","linkReferences":{}},"methodIdentifiers":{"GUARDIAN()":"724c184c","L2_ORACLE()":"001c2ff6","PORTAL()":"0ff754ea","PROPOSER()":"bffa7f0f","SYSTEM_CONFIG()":"f0498750","addressManager()":"3ab76e9f","admin()":"f851a440","anchorStateRegistry()":"5c0cba33","batcherHash()":"e81b2c6d","challenger()":"534db0e2","disputeGameFactory()":"f2b4e617","ethLockbox()":"b682c444","gameImpls(uint32)":"1b685b9e","guardian()":"452a9320","l1ERC721Bridge()":"c4e8ddfa","l2Oracle()":"9b5f694a","messenger()":"3cb747bf","optimismMintableERC20Factory()":"9b7d7f0a","oracle()":"7dc0d1d0","owner()":"8da5cb5b","portal()":"6425666b","proposer()":"a8e4fb90","respectedGameType()":"3c9f397c","superchainConfig()":"35e80ab3","systemConfig()":"33d7e2bd","unsafeBlockSigner()":"1fd19ee1","vm()":"3a768463","weth()":"3fc8cef3"},"rawMetadata":"{\"compiler\":{\"version\":\"0.8.25+commit.b61c2a91\"},\"language\":\"Solidity\",\"output\":{\"abi\":[{\"inputs\":[],\"name\":\"GUARDIAN\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"L2_ORACLE\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"PORTAL\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"PROPOSER\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"SYSTEM_CONFIG\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"addressManager\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"admin\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"anchorStateRegistry\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"batcherHash\",\"outputs\":[{\"internalType\":\"bytes32\",\"name\":\"\",\"type\":\"bytes32\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"challenger\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"disputeGameFactory\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"ethLockbox\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"GameType\",\"name\":\"_gameType\",\"type\":\"uint32\"}],\"name\":\"gameImpls\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"guardian\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"l1ERC721Bridge\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"l2Oracle\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"messenger\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"optimismMintableERC20Factory\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"oracle\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"owner\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"portal\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"proposer\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"respectedGameType\",\"outputs\":[{\"internalType\":\"GameType\",\"name\":\"\",\"type\":\"uint32\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"superchainConfig\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"systemConfig\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"unsafeBlockSigner\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"vm\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"weth\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"}],\"devdoc\":{\"kind\":\"dev\",\"methods\":{},\"version\":1},\"userdoc\":{\"kind\":\"user\",\"methods\":{},\"notice\":\"Contains getters for arbitrary methods from all L1 contracts, including legacy getters that have since been deprecated.\",\"version\":1}},\"settings\":{\"compilationTarget\":{\"scripts/FetchChainInfo.s.sol\":\"IFetcher\"},\"evmVersion\":\"cancun\",\"libraries\":{},\"metadata\":{\"bytecodeHash\":\"none\",\"useLiteralContent\":true},\"optimizer\":{\"enabled\":false,\"runs\":999999},\"remappings\":[\":@lib-keccak/=lib/lib-keccak/contracts/lib/\",\":@openzeppelin/contracts-upgradeable/=lib/openzeppelin-contracts-upgradeable/contracts/\",\":@openzeppelin/contracts-v5/=lib/openzeppelin-contracts-v5/contracts/\",\":@openzeppelin/contracts/=lib/openzeppelin-contracts/contracts/\",\":@rari-capital/solmate/=lib/solmate/\",\":@solady-test/=lib/lib-keccak/lib/solady/test/\",\":@solady-v0.0.245/=lib/solady-v0.0.245/src/\",\":@solady/=lib/solady/src/\",\":ds-test/=lib/forge-std/lib/ds-test/src/\",\":erc4626-tests/=lib/openzeppelin-contracts-v5/lib/erc4626-tests/\",\":forge-std/=lib/forge-std/src/\",\":interfaces/=interfaces/\",\":kontrol-cheatcodes/=lib/kontrol-cheatcodes/src/\",\":lib-keccak/=lib/lib-keccak/contracts/\",\":openzeppelin-contracts-upgradeable/=lib/openzeppelin-contracts-upgradeable/\",\":openzeppelin-contracts-v5/=lib/openzeppelin-contracts-v5/\",\":openzeppelin-contracts/=lib/openzeppelin-contracts/\",\":safe-contracts/=lib/safe-contracts/contracts/\",\":solady-v0.0.245/=lib/solady-v0.0.245/src/\",\":solady/=lib/solady/\",\":solmate/=lib/solmate/src/\"]},\"sources\":{\"lib/forge-std/src/Base.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity >=0.6.2 <0.9.0;\\n\\nimport {StdStorage} from \\\"./StdStorage.sol\\\";\\nimport {Vm, VmSafe} from \\\"./Vm.sol\\\";\\n\\nabstract contract CommonBase {\\n /// @dev Cheat code address.\\n /// Calculated as `address(uint160(uint256(keccak256(\\\"hevm cheat code\\\"))))`.\\n address internal constant VM_ADDRESS = 0x7109709ECfa91a80626fF3989D68f67F5b1DD12D;\\n /// @dev console.sol and console2.sol work by executing a staticcall to this address.\\n /// Calculated as `address(uint160(uint88(bytes11(\\\"console.log\\\"))))`.\\n address internal constant CONSOLE = 0x000000000000000000636F6e736F6c652e6c6f67;\\n /// @dev Used when deploying with create2.\\n /// Taken from https://github.com/Arachnid/deterministic-deployment-proxy.\\n address internal constant CREATE2_FACTORY = 0x4e59b44847b379578588920cA78FbF26c0B4956C;\\n /// @dev The default address for tx.origin and msg.sender.\\n /// Calculated as `address(uint160(uint256(keccak256(\\\"foundry default caller\\\"))))`.\\n address internal constant DEFAULT_SENDER = 0x1804c8AB1F12E6bbf3894d4083f33e07309d1f38;\\n /// @dev The address of the first contract `CREATE`d by a running test contract.\\n /// When running tests, each test contract is `CREATE`d by `DEFAULT_SENDER` with nonce 1.\\n /// Calculated as `VM.computeCreateAddress(VM.computeCreateAddress(DEFAULT_SENDER, 1), 1)`.\\n address internal constant DEFAULT_TEST_CONTRACT = 0x5615dEB798BB3E4dFa0139dFa1b3D433Cc23b72f;\\n /// @dev Deterministic deployment address of the Multicall3 contract.\\n /// Taken from https://www.multicall3.com.\\n address internal constant MULTICALL3_ADDRESS = 0xcA11bde05977b3631167028862bE2a173976CA11;\\n /// @dev The order of the secp256k1 curve.\\n uint256 internal constant SECP256K1_ORDER =\\n 115792089237316195423570985008687907852837564279074904382605163141518161494337;\\n\\n uint256 internal constant UINT256_MAX =\\n 115792089237316195423570985008687907853269984665640564039457584007913129639935;\\n\\n Vm internal constant vm = Vm(VM_ADDRESS);\\n StdStorage internal stdstore;\\n}\\n\\nabstract contract TestBase is CommonBase {}\\n\\nabstract contract ScriptBase is CommonBase {\\n VmSafe internal constant vmSafe = VmSafe(VM_ADDRESS);\\n}\\n\",\"keccak256\":\"0xa3735a6618a3014e42bb4329ad143e3b2c59cd95094350202e4c4a06c9d585dd\",\"license\":\"MIT\"},\"lib/forge-std/src/Script.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity >=0.6.2 <0.9.0;\\n\\n// \\ud83d\\udcac ABOUT\\n// Forge Std's default Script.\\n\\n// \\ud83e\\udde9 MODULES\\nimport {console} from \\\"./console.sol\\\";\\nimport {console2} from \\\"./console2.sol\\\";\\nimport {safeconsole} from \\\"./safeconsole.sol\\\";\\nimport {StdChains} from \\\"./StdChains.sol\\\";\\nimport {StdCheatsSafe} from \\\"./StdCheats.sol\\\";\\nimport {StdConstants} from \\\"./StdConstants.sol\\\";\\nimport {stdJson} from \\\"./StdJson.sol\\\";\\nimport {stdMath} from \\\"./StdMath.sol\\\";\\nimport {StdStorage, stdStorageSafe} from \\\"./StdStorage.sol\\\";\\nimport {StdStyle} from \\\"./StdStyle.sol\\\";\\nimport {StdUtils} from \\\"./StdUtils.sol\\\";\\nimport {VmSafe} from \\\"./Vm.sol\\\";\\n\\n// \\ud83d\\udce6 BOILERPLATE\\nimport {ScriptBase} from \\\"./Base.sol\\\";\\n\\n// \\u2b50\\ufe0f SCRIPT\\nabstract contract Script is ScriptBase, StdChains, StdCheatsSafe, StdUtils {\\n // Note: IS_SCRIPT() must return true.\\n bool public IS_SCRIPT = true;\\n}\\n\",\"keccak256\":\"0xc942e27c7baae499beb01afbbae99f24d42af9a6e4aae675bc6901b704aa8e9b\",\"license\":\"MIT\"},\"lib/forge-std/src/StdChains.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity >=0.6.2 <0.9.0;\\n\\nimport {VmSafe} from \\\"./Vm.sol\\\";\\n\\n/**\\n * StdChains provides information about EVM compatible chains that can be used in scripts/tests.\\n * For each chain, the chain's name, chain ID, and a default RPC URL are provided. Chains are\\n * identified by their alias, which is the same as the alias in the `[rpc_endpoints]` section of\\n * the `foundry.toml` file. For best UX, ensure the alias in the `foundry.toml` file match the\\n * alias used in this contract, which can be found as the first argument to the\\n * `setChainWithDefaultRpcUrl` call in the `initializeStdChains` function.\\n *\\n * There are two main ways to use this contract:\\n * 1. Set a chain with `setChain(string memory chainAlias, ChainData memory chain)` or\\n * `setChain(string memory chainAlias, Chain memory chain)`\\n * 2. Get a chain with `getChain(string memory chainAlias)` or `getChain(uint256 chainId)`.\\n *\\n * The first time either of those are used, chains are initialized with the default set of RPC URLs.\\n * This is done in `initializeStdChains`, which uses `setChainWithDefaultRpcUrl`. Defaults are recorded in\\n * `defaultRpcUrls`.\\n *\\n * The `setChain` function is straightforward, and it simply saves off the given chain data.\\n *\\n * The `getChain` methods use `getChainWithUpdatedRpcUrl` to return a chain. For example, let's say\\n * we want to retrieve the RPC URL for `mainnet`:\\n * - If you have specified data with `setChain`, it will return that.\\n * - If you have configured a mainnet RPC URL in `foundry.toml`, it will return the URL, provided it\\n * is valid (e.g. a URL is specified, or an environment variable is given and exists).\\n * - If neither of the above conditions is met, the default data is returned.\\n *\\n * Summarizing the above, the prioritization hierarchy is `setChain` -> `foundry.toml` -> environment variable -> defaults.\\n */\\nabstract contract StdChains {\\n VmSafe private constant vm = VmSafe(address(uint160(uint256(keccak256(\\\"hevm cheat code\\\")))));\\n\\n bool private stdChainsInitialized;\\n\\n struct ChainData {\\n string name;\\n uint256 chainId;\\n string rpcUrl;\\n }\\n\\n struct Chain {\\n // The chain name.\\n string name;\\n // The chain's Chain ID.\\n uint256 chainId;\\n // The chain's alias. (i.e. what gets specified in `foundry.toml`).\\n string chainAlias;\\n // A default RPC endpoint for this chain.\\n // NOTE: This default RPC URL is included for convenience to facilitate quick tests and\\n // experimentation. Do not use this RPC URL for production test suites, CI, or other heavy\\n // usage as you will be throttled and this is a disservice to others who need this endpoint.\\n string rpcUrl;\\n }\\n\\n // Maps from the chain's alias (matching the alias in the `foundry.toml` file) to chain data.\\n mapping(string => Chain) private chains;\\n // Maps from the chain's alias to it's default RPC URL.\\n mapping(string => string) private defaultRpcUrls;\\n // Maps from a chain ID to it's alias.\\n mapping(uint256 => string) private idToAlias;\\n\\n bool private fallbackToDefaultRpcUrls = true;\\n\\n // The RPC URL will be fetched from config or defaultRpcUrls if possible.\\n function getChain(string memory chainAlias) internal virtual returns (Chain memory chain) {\\n require(bytes(chainAlias).length != 0, \\\"StdChains getChain(string): Chain alias cannot be the empty string.\\\");\\n\\n initializeStdChains();\\n chain = chains[chainAlias];\\n require(\\n chain.chainId != 0,\\n string(abi.encodePacked(\\\"StdChains getChain(string): Chain with alias \\\\\\\"\\\", chainAlias, \\\"\\\\\\\" not found.\\\"))\\n );\\n\\n chain = getChainWithUpdatedRpcUrl(chainAlias, chain);\\n }\\n\\n function getChain(uint256 chainId) internal virtual returns (Chain memory chain) {\\n require(chainId != 0, \\\"StdChains getChain(uint256): Chain ID cannot be 0.\\\");\\n initializeStdChains();\\n string memory chainAlias = idToAlias[chainId];\\n\\n chain = chains[chainAlias];\\n\\n require(\\n chain.chainId != 0,\\n string(abi.encodePacked(\\\"StdChains getChain(uint256): Chain with ID \\\", vm.toString(chainId), \\\" not found.\\\"))\\n );\\n\\n chain = getChainWithUpdatedRpcUrl(chainAlias, chain);\\n }\\n\\n // set chain info, with priority to argument's rpcUrl field.\\n function setChain(string memory chainAlias, ChainData memory chain) internal virtual {\\n require(\\n bytes(chainAlias).length != 0,\\n \\\"StdChains setChain(string,ChainData): Chain alias cannot be the empty string.\\\"\\n );\\n\\n require(chain.chainId != 0, \\\"StdChains setChain(string,ChainData): Chain ID cannot be 0.\\\");\\n\\n initializeStdChains();\\n string memory foundAlias = idToAlias[chain.chainId];\\n\\n require(\\n bytes(foundAlias).length == 0 || keccak256(bytes(foundAlias)) == keccak256(bytes(chainAlias)),\\n string(\\n abi.encodePacked(\\n \\\"StdChains setChain(string,ChainData): Chain ID \\\",\\n vm.toString(chain.chainId),\\n \\\" already used by \\\\\\\"\\\",\\n foundAlias,\\n \\\"\\\\\\\".\\\"\\n )\\n )\\n );\\n\\n uint256 oldChainId = chains[chainAlias].chainId;\\n delete idToAlias[oldChainId];\\n\\n chains[chainAlias] =\\n Chain({name: chain.name, chainId: chain.chainId, chainAlias: chainAlias, rpcUrl: chain.rpcUrl});\\n idToAlias[chain.chainId] = chainAlias;\\n }\\n\\n // set chain info, with priority to argument's rpcUrl field.\\n function setChain(string memory chainAlias, Chain memory chain) internal virtual {\\n setChain(chainAlias, ChainData({name: chain.name, chainId: chain.chainId, rpcUrl: chain.rpcUrl}));\\n }\\n\\n function _toUpper(string memory str) private pure returns (string memory) {\\n bytes memory strb = bytes(str);\\n bytes memory copy = new bytes(strb.length);\\n for (uint256 i = 0; i < strb.length; i++) {\\n bytes1 b = strb[i];\\n if (b >= 0x61 && b <= 0x7A) {\\n copy[i] = bytes1(uint8(b) - 32);\\n } else {\\n copy[i] = b;\\n }\\n }\\n return string(copy);\\n }\\n\\n // lookup rpcUrl, in descending order of priority:\\n // current -> config (foundry.toml) -> environment variable -> default\\n function getChainWithUpdatedRpcUrl(string memory chainAlias, Chain memory chain)\\n private\\n view\\n returns (Chain memory)\\n {\\n if (bytes(chain.rpcUrl).length == 0) {\\n try vm.rpcUrl(chainAlias) returns (string memory configRpcUrl) {\\n chain.rpcUrl = configRpcUrl;\\n } catch (bytes memory err) {\\n string memory envName = string(abi.encodePacked(_toUpper(chainAlias), \\\"_RPC_URL\\\"));\\n if (fallbackToDefaultRpcUrls) {\\n chain.rpcUrl = vm.envOr(envName, defaultRpcUrls[chainAlias]);\\n } else {\\n chain.rpcUrl = vm.envString(envName);\\n }\\n // Distinguish 'not found' from 'cannot read'\\n // The upstream error thrown by forge for failing cheats changed so we check both the old and new versions\\n bytes memory oldNotFoundError =\\n abi.encodeWithSignature(\\\"CheatCodeError\\\", string(abi.encodePacked(\\\"invalid rpc url \\\", chainAlias)));\\n bytes memory newNotFoundError = abi.encodeWithSignature(\\n \\\"CheatcodeError(string)\\\", string(abi.encodePacked(\\\"invalid rpc url: \\\", chainAlias))\\n );\\n bytes32 errHash = keccak256(err);\\n if (\\n (errHash != keccak256(oldNotFoundError) && errHash != keccak256(newNotFoundError))\\n || bytes(chain.rpcUrl).length == 0\\n ) {\\n /// @solidity memory-safe-assembly\\n assembly {\\n revert(add(32, err), mload(err))\\n }\\n }\\n }\\n }\\n return chain;\\n }\\n\\n function setFallbackToDefaultRpcUrls(bool useDefault) internal {\\n fallbackToDefaultRpcUrls = useDefault;\\n }\\n\\n function initializeStdChains() private {\\n if (stdChainsInitialized) return;\\n\\n stdChainsInitialized = true;\\n\\n // If adding an RPC here, make sure to test the default RPC URL in `test_Rpcs` in `StdChains.t.sol`\\n setChainWithDefaultRpcUrl(\\\"anvil\\\", ChainData(\\\"Anvil\\\", 31337, \\\"http://127.0.0.1:8545\\\"));\\n setChainWithDefaultRpcUrl(\\\"mainnet\\\", ChainData(\\\"Mainnet\\\", 1, \\\"https://eth.llamarpc.com\\\"));\\n setChainWithDefaultRpcUrl(\\n \\\"sepolia\\\", ChainData(\\\"Sepolia\\\", 11155111, \\\"https://sepolia.infura.io/v3/b9794ad1ddf84dfb8c34d6bb5dca2001\\\")\\n );\\n setChainWithDefaultRpcUrl(\\\"holesky\\\", ChainData(\\\"Holesky\\\", 17000, \\\"https://rpc.holesky.ethpandaops.io\\\"));\\n setChainWithDefaultRpcUrl(\\\"optimism\\\", ChainData(\\\"Optimism\\\", 10, \\\"https://mainnet.optimism.io\\\"));\\n setChainWithDefaultRpcUrl(\\n \\\"optimism_sepolia\\\", ChainData(\\\"Optimism Sepolia\\\", 11155420, \\\"https://sepolia.optimism.io\\\")\\n );\\n setChainWithDefaultRpcUrl(\\\"arbitrum_one\\\", ChainData(\\\"Arbitrum One\\\", 42161, \\\"https://arb1.arbitrum.io/rpc\\\"));\\n setChainWithDefaultRpcUrl(\\n \\\"arbitrum_one_sepolia\\\", ChainData(\\\"Arbitrum One Sepolia\\\", 421614, \\\"https://sepolia-rollup.arbitrum.io/rpc\\\")\\n );\\n setChainWithDefaultRpcUrl(\\\"arbitrum_nova\\\", ChainData(\\\"Arbitrum Nova\\\", 42170, \\\"https://nova.arbitrum.io/rpc\\\"));\\n setChainWithDefaultRpcUrl(\\\"polygon\\\", ChainData(\\\"Polygon\\\", 137, \\\"https://polygon-rpc.com\\\"));\\n setChainWithDefaultRpcUrl(\\n \\\"polygon_amoy\\\", ChainData(\\\"Polygon Amoy\\\", 80002, \\\"https://rpc-amoy.polygon.technology\\\")\\n );\\n setChainWithDefaultRpcUrl(\\\"avalanche\\\", ChainData(\\\"Avalanche\\\", 43114, \\\"https://api.avax.network/ext/bc/C/rpc\\\"));\\n setChainWithDefaultRpcUrl(\\n \\\"avalanche_fuji\\\", ChainData(\\\"Avalanche Fuji\\\", 43113, \\\"https://api.avax-test.network/ext/bc/C/rpc\\\")\\n );\\n setChainWithDefaultRpcUrl(\\n \\\"bnb_smart_chain\\\", ChainData(\\\"BNB Smart Chain\\\", 56, \\\"https://bsc-dataseed1.binance.org\\\")\\n );\\n setChainWithDefaultRpcUrl(\\n \\\"bnb_smart_chain_testnet\\\",\\n ChainData(\\\"BNB Smart Chain Testnet\\\", 97, \\\"https://rpc.ankr.com/bsc_testnet_chapel\\\")\\n );\\n setChainWithDefaultRpcUrl(\\\"gnosis_chain\\\", ChainData(\\\"Gnosis Chain\\\", 100, \\\"https://rpc.gnosischain.com\\\"));\\n setChainWithDefaultRpcUrl(\\\"moonbeam\\\", ChainData(\\\"Moonbeam\\\", 1284, \\\"https://rpc.api.moonbeam.network\\\"));\\n setChainWithDefaultRpcUrl(\\n \\\"moonriver\\\", ChainData(\\\"Moonriver\\\", 1285, \\\"https://rpc.api.moonriver.moonbeam.network\\\")\\n );\\n setChainWithDefaultRpcUrl(\\\"moonbase\\\", ChainData(\\\"Moonbase\\\", 1287, \\\"https://rpc.testnet.moonbeam.network\\\"));\\n setChainWithDefaultRpcUrl(\\\"base_sepolia\\\", ChainData(\\\"Base Sepolia\\\", 84532, \\\"https://sepolia.base.org\\\"));\\n setChainWithDefaultRpcUrl(\\\"base\\\", ChainData(\\\"Base\\\", 8453, \\\"https://mainnet.base.org\\\"));\\n setChainWithDefaultRpcUrl(\\\"blast_sepolia\\\", ChainData(\\\"Blast Sepolia\\\", 168587773, \\\"https://sepolia.blast.io\\\"));\\n setChainWithDefaultRpcUrl(\\\"blast\\\", ChainData(\\\"Blast\\\", 81457, \\\"https://rpc.blast.io\\\"));\\n setChainWithDefaultRpcUrl(\\\"fantom_opera\\\", ChainData(\\\"Fantom Opera\\\", 250, \\\"https://rpc.ankr.com/fantom/\\\"));\\n setChainWithDefaultRpcUrl(\\n \\\"fantom_opera_testnet\\\", ChainData(\\\"Fantom Opera Testnet\\\", 4002, \\\"https://rpc.ankr.com/fantom_testnet/\\\")\\n );\\n setChainWithDefaultRpcUrl(\\\"fraxtal\\\", ChainData(\\\"Fraxtal\\\", 252, \\\"https://rpc.frax.com\\\"));\\n setChainWithDefaultRpcUrl(\\\"fraxtal_testnet\\\", ChainData(\\\"Fraxtal Testnet\\\", 2522, \\\"https://rpc.testnet.frax.com\\\"));\\n setChainWithDefaultRpcUrl(\\n \\\"berachain_bartio_testnet\\\", ChainData(\\\"Berachain bArtio Testnet\\\", 80084, \\\"https://bartio.rpc.berachain.com\\\")\\n );\\n setChainWithDefaultRpcUrl(\\\"flare\\\", ChainData(\\\"Flare\\\", 14, \\\"https://flare-api.flare.network/ext/C/rpc\\\"));\\n setChainWithDefaultRpcUrl(\\n \\\"flare_coston2\\\", ChainData(\\\"Flare Coston2\\\", 114, \\\"https://coston2-api.flare.network/ext/C/rpc\\\")\\n );\\n\\n setChainWithDefaultRpcUrl(\\\"mode\\\", ChainData(\\\"Mode\\\", 34443, \\\"https://mode.drpc.org\\\"));\\n setChainWithDefaultRpcUrl(\\\"mode_sepolia\\\", ChainData(\\\"Mode Sepolia\\\", 919, \\\"https://sepolia.mode.network\\\"));\\n\\n setChainWithDefaultRpcUrl(\\\"zora\\\", ChainData(\\\"Zora\\\", 7777777, \\\"https://zora.drpc.org\\\"));\\n setChainWithDefaultRpcUrl(\\n \\\"zora_sepolia\\\", ChainData(\\\"Zora Sepolia\\\", 999999999, \\\"https://sepolia.rpc.zora.energy\\\")\\n );\\n\\n setChainWithDefaultRpcUrl(\\\"race\\\", ChainData(\\\"Race\\\", 6805, \\\"https://racemainnet.io\\\"));\\n setChainWithDefaultRpcUrl(\\\"race_sepolia\\\", ChainData(\\\"Race Sepolia\\\", 6806, \\\"https://racemainnet.io\\\"));\\n\\n setChainWithDefaultRpcUrl(\\\"metal\\\", ChainData(\\\"Metal\\\", 1750, \\\"https://metall2.drpc.org\\\"));\\n setChainWithDefaultRpcUrl(\\\"metal_sepolia\\\", ChainData(\\\"Metal Sepolia\\\", 1740, \\\"https://testnet.rpc.metall2.com\\\"));\\n\\n setChainWithDefaultRpcUrl(\\\"binary\\\", ChainData(\\\"Binary\\\", 624, \\\"https://rpc.zero.thebinaryholdings.com\\\"));\\n setChainWithDefaultRpcUrl(\\n \\\"binary_sepolia\\\", ChainData(\\\"Binary Sepolia\\\", 625, \\\"https://rpc.zero.thebinaryholdings.com\\\")\\n );\\n\\n setChainWithDefaultRpcUrl(\\\"orderly\\\", ChainData(\\\"Orderly\\\", 291, \\\"https://rpc.orderly.network\\\"));\\n setChainWithDefaultRpcUrl(\\n \\\"orderly_sepolia\\\", ChainData(\\\"Orderly Sepolia\\\", 4460, \\\"https://testnet-rpc.orderly.org\\\")\\n );\\n }\\n\\n // set chain info, with priority to chainAlias' rpc url in foundry.toml\\n function setChainWithDefaultRpcUrl(string memory chainAlias, ChainData memory chain) private {\\n string memory rpcUrl = chain.rpcUrl;\\n defaultRpcUrls[chainAlias] = rpcUrl;\\n chain.rpcUrl = \\\"\\\";\\n setChain(chainAlias, chain);\\n chain.rpcUrl = rpcUrl; // restore argument\\n }\\n}\\n\",\"keccak256\":\"0x200b597cd01c229633b4a2317846cac7d36d337e2381b4a2e81faac23c2ad1cf\",\"license\":\"MIT\"},\"lib/forge-std/src/StdCheats.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity >=0.6.2 <0.9.0;\\n\\npragma experimental ABIEncoderV2;\\n\\nimport {StdStorage, stdStorage} from \\\"./StdStorage.sol\\\";\\nimport {console2} from \\\"./console2.sol\\\";\\nimport {Vm} from \\\"./Vm.sol\\\";\\n\\nabstract contract StdCheatsSafe {\\n Vm private constant vm = Vm(address(uint160(uint256(keccak256(\\\"hevm cheat code\\\")))));\\n\\n uint256 private constant UINT256_MAX =\\n 115792089237316195423570985008687907853269984665640564039457584007913129639935;\\n\\n bool private gasMeteringOff;\\n\\n // Data structures to parse Transaction objects from the broadcast artifact\\n // that conform to EIP1559. The Raw structs is what is parsed from the JSON\\n // and then converted to the one that is used by the user for better UX.\\n\\n struct RawTx1559 {\\n string[] arguments;\\n address contractAddress;\\n string contractName;\\n // json value name = function\\n string functionSig;\\n bytes32 hash;\\n // json value name = tx\\n RawTx1559Detail txDetail;\\n // json value name = type\\n string opcode;\\n }\\n\\n struct RawTx1559Detail {\\n AccessList[] accessList;\\n bytes data;\\n address from;\\n bytes gas;\\n bytes nonce;\\n address to;\\n bytes txType;\\n bytes value;\\n }\\n\\n struct Tx1559 {\\n string[] arguments;\\n address contractAddress;\\n string contractName;\\n string functionSig;\\n bytes32 hash;\\n Tx1559Detail txDetail;\\n string opcode;\\n }\\n\\n struct Tx1559Detail {\\n AccessList[] accessList;\\n bytes data;\\n address from;\\n uint256 gas;\\n uint256 nonce;\\n address to;\\n uint256 txType;\\n uint256 value;\\n }\\n\\n // Data structures to parse Transaction objects from the broadcast artifact\\n // that DO NOT conform to EIP1559. The Raw structs is what is parsed from the JSON\\n // and then converted to the one that is used by the user for better UX.\\n\\n struct TxLegacy {\\n string[] arguments;\\n address contractAddress;\\n string contractName;\\n string functionSig;\\n string hash;\\n string opcode;\\n TxDetailLegacy transaction;\\n }\\n\\n struct TxDetailLegacy {\\n AccessList[] accessList;\\n uint256 chainId;\\n bytes data;\\n address from;\\n uint256 gas;\\n uint256 gasPrice;\\n bytes32 hash;\\n uint256 nonce;\\n bytes1 opcode;\\n bytes32 r;\\n bytes32 s;\\n uint256 txType;\\n address to;\\n uint8 v;\\n uint256 value;\\n }\\n\\n struct AccessList {\\n address accessAddress;\\n bytes32[] storageKeys;\\n }\\n\\n // Data structures to parse Receipt objects from the broadcast artifact.\\n // The Raw structs is what is parsed from the JSON\\n // and then converted to the one that is used by the user for better UX.\\n\\n struct RawReceipt {\\n bytes32 blockHash;\\n bytes blockNumber;\\n address contractAddress;\\n bytes cumulativeGasUsed;\\n bytes effectiveGasPrice;\\n address from;\\n bytes gasUsed;\\n RawReceiptLog[] logs;\\n bytes logsBloom;\\n bytes status;\\n address to;\\n bytes32 transactionHash;\\n bytes transactionIndex;\\n }\\n\\n struct Receipt {\\n bytes32 blockHash;\\n uint256 blockNumber;\\n address contractAddress;\\n uint256 cumulativeGasUsed;\\n uint256 effectiveGasPrice;\\n address from;\\n uint256 gasUsed;\\n ReceiptLog[] logs;\\n bytes logsBloom;\\n uint256 status;\\n address to;\\n bytes32 transactionHash;\\n uint256 transactionIndex;\\n }\\n\\n // Data structures to parse the entire broadcast artifact, assuming the\\n // transactions conform to EIP1559.\\n\\n struct EIP1559ScriptArtifact {\\n string[] libraries;\\n string path;\\n string[] pending;\\n Receipt[] receipts;\\n uint256 timestamp;\\n Tx1559[] transactions;\\n TxReturn[] txReturns;\\n }\\n\\n struct RawEIP1559ScriptArtifact {\\n string[] libraries;\\n string path;\\n string[] pending;\\n RawReceipt[] receipts;\\n TxReturn[] txReturns;\\n uint256 timestamp;\\n RawTx1559[] transactions;\\n }\\n\\n struct RawReceiptLog {\\n // json value = address\\n address logAddress;\\n bytes32 blockHash;\\n bytes blockNumber;\\n bytes data;\\n bytes logIndex;\\n bool removed;\\n bytes32[] topics;\\n bytes32 transactionHash;\\n bytes transactionIndex;\\n bytes transactionLogIndex;\\n }\\n\\n struct ReceiptLog {\\n // json value = address\\n address logAddress;\\n bytes32 blockHash;\\n uint256 blockNumber;\\n bytes data;\\n uint256 logIndex;\\n bytes32[] topics;\\n uint256 transactionIndex;\\n uint256 transactionLogIndex;\\n bool removed;\\n }\\n\\n struct TxReturn {\\n string internalType;\\n string value;\\n }\\n\\n struct Account {\\n address addr;\\n uint256 key;\\n }\\n\\n enum AddressType {\\n Payable,\\n NonPayable,\\n ZeroAddress,\\n Precompile,\\n ForgeAddress\\n }\\n\\n // Checks that `addr` is not blacklisted by token contracts that have a blacklist.\\n function assumeNotBlacklisted(address token, address addr) internal view virtual {\\n // Nothing to check if `token` is not a contract.\\n uint256 tokenCodeSize;\\n assembly {\\n tokenCodeSize := extcodesize(token)\\n }\\n require(tokenCodeSize > 0, \\\"StdCheats assumeNotBlacklisted(address,address): Token address is not a contract.\\\");\\n\\n bool success;\\n bytes memory returnData;\\n\\n // 4-byte selector for `isBlacklisted(address)`, used by USDC.\\n (success, returnData) = token.staticcall(abi.encodeWithSelector(0xfe575a87, addr));\\n vm.assume(!success || abi.decode(returnData, (bool)) == false);\\n\\n // 4-byte selector for `isBlackListed(address)`, used by USDT.\\n (success, returnData) = token.staticcall(abi.encodeWithSelector(0xe47d6060, addr));\\n vm.assume(!success || abi.decode(returnData, (bool)) == false);\\n }\\n\\n // Checks that `addr` is not blacklisted by token contracts that have a blacklist.\\n // This is identical to `assumeNotBlacklisted(address,address)` but with a different name, for\\n // backwards compatibility, since this name was used in the original PR which already has\\n // a release. This function can be removed in a future release once we want a breaking change.\\n function assumeNoBlacklisted(address token, address addr) internal view virtual {\\n assumeNotBlacklisted(token, addr);\\n }\\n\\n function assumeAddressIsNot(address addr, AddressType addressType) internal virtual {\\n if (addressType == AddressType.Payable) {\\n assumeNotPayable(addr);\\n } else if (addressType == AddressType.NonPayable) {\\n assumePayable(addr);\\n } else if (addressType == AddressType.ZeroAddress) {\\n assumeNotZeroAddress(addr);\\n } else if (addressType == AddressType.Precompile) {\\n assumeNotPrecompile(addr);\\n } else if (addressType == AddressType.ForgeAddress) {\\n assumeNotForgeAddress(addr);\\n }\\n }\\n\\n function assumeAddressIsNot(address addr, AddressType addressType1, AddressType addressType2) internal virtual {\\n assumeAddressIsNot(addr, addressType1);\\n assumeAddressIsNot(addr, addressType2);\\n }\\n\\n function assumeAddressIsNot(\\n address addr,\\n AddressType addressType1,\\n AddressType addressType2,\\n AddressType addressType3\\n ) internal virtual {\\n assumeAddressIsNot(addr, addressType1);\\n assumeAddressIsNot(addr, addressType2);\\n assumeAddressIsNot(addr, addressType3);\\n }\\n\\n function assumeAddressIsNot(\\n address addr,\\n AddressType addressType1,\\n AddressType addressType2,\\n AddressType addressType3,\\n AddressType addressType4\\n ) internal virtual {\\n assumeAddressIsNot(addr, addressType1);\\n assumeAddressIsNot(addr, addressType2);\\n assumeAddressIsNot(addr, addressType3);\\n assumeAddressIsNot(addr, addressType4);\\n }\\n\\n // This function checks whether an address, `addr`, is payable. It works by sending 1 wei to\\n // `addr` and checking the `success` return value.\\n // NOTE: This function may result in state changes depending on the fallback/receive logic\\n // implemented by `addr`, which should be taken into account when this function is used.\\n function _isPayable(address addr) private returns (bool) {\\n require(\\n addr.balance < UINT256_MAX,\\n \\\"StdCheats _isPayable(address): Balance equals max uint256, so it cannot receive any more funds\\\"\\n );\\n uint256 origBalanceTest = address(this).balance;\\n uint256 origBalanceAddr = address(addr).balance;\\n\\n vm.deal(address(this), 1);\\n (bool success,) = payable(addr).call{value: 1}(\\\"\\\");\\n\\n // reset balances\\n vm.deal(address(this), origBalanceTest);\\n vm.deal(addr, origBalanceAddr);\\n\\n return success;\\n }\\n\\n // NOTE: This function may result in state changes depending on the fallback/receive logic\\n // implemented by `addr`, which should be taken into account when this function is used. See the\\n // `_isPayable` method for more information.\\n function assumePayable(address addr) internal virtual {\\n vm.assume(_isPayable(addr));\\n }\\n\\n function assumeNotPayable(address addr) internal virtual {\\n vm.assume(!_isPayable(addr));\\n }\\n\\n function assumeNotZeroAddress(address addr) internal pure virtual {\\n vm.assume(addr != address(0));\\n }\\n\\n function assumeNotPrecompile(address addr) internal pure virtual {\\n assumeNotPrecompile(addr, _pureChainId());\\n }\\n\\n function assumeNotPrecompile(address addr, uint256 chainId) internal pure virtual {\\n // Note: For some chains like Optimism these are technically predeploys (i.e. bytecode placed at a specific\\n // address), but the same rationale for excluding them applies so we include those too.\\n\\n // These are reserved by Ethereum and may be on all EVM-compatible chains.\\n vm.assume(addr < address(0x1) || addr > address(0xff));\\n\\n // forgefmt: disable-start\\n if (chainId == 10 || chainId == 420) {\\n // https://github.com/ethereum-optimism/optimism/blob/eaa371a0184b56b7ca6d9eb9cb0a2b78b2ccd864/op-bindings/predeploys/addresses.go#L6-L21\\n vm.assume(addr < address(0x4200000000000000000000000000000000000000) || addr > address(0x4200000000000000000000000000000000000800));\\n } else if (chainId == 42161 || chainId == 421613) {\\n // https://developer.arbitrum.io/useful-addresses#arbitrum-precompiles-l2-same-on-all-arb-chains\\n vm.assume(addr < address(0x0000000000000000000000000000000000000064) || addr > address(0x0000000000000000000000000000000000000068));\\n } else if (chainId == 43114 || chainId == 43113) {\\n // https://github.com/ava-labs/subnet-evm/blob/47c03fd007ecaa6de2c52ea081596e0a88401f58/precompile/params.go#L18-L59\\n vm.assume(addr < address(0x0100000000000000000000000000000000000000) || addr > address(0x01000000000000000000000000000000000000ff));\\n vm.assume(addr < address(0x0200000000000000000000000000000000000000) || addr > address(0x02000000000000000000000000000000000000FF));\\n vm.assume(addr < address(0x0300000000000000000000000000000000000000) || addr > address(0x03000000000000000000000000000000000000Ff));\\n }\\n // forgefmt: disable-end\\n }\\n\\n function assumeNotForgeAddress(address addr) internal pure virtual {\\n // vm, console, and Create2Deployer addresses\\n vm.assume(\\n addr != address(vm) && addr != 0x000000000000000000636F6e736F6c652e6c6f67\\n && addr != 0x4e59b44847b379578588920cA78FbF26c0B4956C\\n );\\n }\\n\\n function assumeUnusedAddress(address addr) internal view virtual {\\n uint256 size;\\n assembly {\\n size := extcodesize(addr)\\n }\\n vm.assume(size == 0);\\n\\n assumeNotPrecompile(addr);\\n assumeNotZeroAddress(addr);\\n assumeNotForgeAddress(addr);\\n }\\n\\n function readEIP1559ScriptArtifact(string memory path)\\n internal\\n view\\n virtual\\n returns (EIP1559ScriptArtifact memory)\\n {\\n string memory data = vm.readFile(path);\\n bytes memory parsedData = vm.parseJson(data);\\n RawEIP1559ScriptArtifact memory rawArtifact = abi.decode(parsedData, (RawEIP1559ScriptArtifact));\\n EIP1559ScriptArtifact memory artifact;\\n artifact.libraries = rawArtifact.libraries;\\n artifact.path = rawArtifact.path;\\n artifact.timestamp = rawArtifact.timestamp;\\n artifact.pending = rawArtifact.pending;\\n artifact.txReturns = rawArtifact.txReturns;\\n artifact.receipts = rawToConvertedReceipts(rawArtifact.receipts);\\n artifact.transactions = rawToConvertedEIPTx1559s(rawArtifact.transactions);\\n return artifact;\\n }\\n\\n function rawToConvertedEIPTx1559s(RawTx1559[] memory rawTxs) internal pure virtual returns (Tx1559[] memory) {\\n Tx1559[] memory txs = new Tx1559[](rawTxs.length);\\n for (uint256 i; i < rawTxs.length; i++) {\\n txs[i] = rawToConvertedEIPTx1559(rawTxs[i]);\\n }\\n return txs;\\n }\\n\\n function rawToConvertedEIPTx1559(RawTx1559 memory rawTx) internal pure virtual returns (Tx1559 memory) {\\n Tx1559 memory transaction;\\n transaction.arguments = rawTx.arguments;\\n transaction.contractName = rawTx.contractName;\\n transaction.functionSig = rawTx.functionSig;\\n transaction.hash = rawTx.hash;\\n transaction.txDetail = rawToConvertedEIP1559Detail(rawTx.txDetail);\\n transaction.opcode = rawTx.opcode;\\n return transaction;\\n }\\n\\n function rawToConvertedEIP1559Detail(RawTx1559Detail memory rawDetail)\\n internal\\n pure\\n virtual\\n returns (Tx1559Detail memory)\\n {\\n Tx1559Detail memory txDetail;\\n txDetail.data = rawDetail.data;\\n txDetail.from = rawDetail.from;\\n txDetail.to = rawDetail.to;\\n txDetail.nonce = _bytesToUint(rawDetail.nonce);\\n txDetail.txType = _bytesToUint(rawDetail.txType);\\n txDetail.value = _bytesToUint(rawDetail.value);\\n txDetail.gas = _bytesToUint(rawDetail.gas);\\n txDetail.accessList = rawDetail.accessList;\\n return txDetail;\\n }\\n\\n function readTx1559s(string memory path) internal view virtual returns (Tx1559[] memory) {\\n string memory deployData = vm.readFile(path);\\n bytes memory parsedDeployData = vm.parseJson(deployData, \\\".transactions\\\");\\n RawTx1559[] memory rawTxs = abi.decode(parsedDeployData, (RawTx1559[]));\\n return rawToConvertedEIPTx1559s(rawTxs);\\n }\\n\\n function readTx1559(string memory path, uint256 index) internal view virtual returns (Tx1559 memory) {\\n string memory deployData = vm.readFile(path);\\n string memory key = string(abi.encodePacked(\\\".transactions[\\\", vm.toString(index), \\\"]\\\"));\\n bytes memory parsedDeployData = vm.parseJson(deployData, key);\\n RawTx1559 memory rawTx = abi.decode(parsedDeployData, (RawTx1559));\\n return rawToConvertedEIPTx1559(rawTx);\\n }\\n\\n // Analogous to readTransactions, but for receipts.\\n function readReceipts(string memory path) internal view virtual returns (Receipt[] memory) {\\n string memory deployData = vm.readFile(path);\\n bytes memory parsedDeployData = vm.parseJson(deployData, \\\".receipts\\\");\\n RawReceipt[] memory rawReceipts = abi.decode(parsedDeployData, (RawReceipt[]));\\n return rawToConvertedReceipts(rawReceipts);\\n }\\n\\n function readReceipt(string memory path, uint256 index) internal view virtual returns (Receipt memory) {\\n string memory deployData = vm.readFile(path);\\n string memory key = string(abi.encodePacked(\\\".receipts[\\\", vm.toString(index), \\\"]\\\"));\\n bytes memory parsedDeployData = vm.parseJson(deployData, key);\\n RawReceipt memory rawReceipt = abi.decode(parsedDeployData, (RawReceipt));\\n return rawToConvertedReceipt(rawReceipt);\\n }\\n\\n function rawToConvertedReceipts(RawReceipt[] memory rawReceipts) internal pure virtual returns (Receipt[] memory) {\\n Receipt[] memory receipts = new Receipt[](rawReceipts.length);\\n for (uint256 i; i < rawReceipts.length; i++) {\\n receipts[i] = rawToConvertedReceipt(rawReceipts[i]);\\n }\\n return receipts;\\n }\\n\\n function rawToConvertedReceipt(RawReceipt memory rawReceipt) internal pure virtual returns (Receipt memory) {\\n Receipt memory receipt;\\n receipt.blockHash = rawReceipt.blockHash;\\n receipt.to = rawReceipt.to;\\n receipt.from = rawReceipt.from;\\n receipt.contractAddress = rawReceipt.contractAddress;\\n receipt.effectiveGasPrice = _bytesToUint(rawReceipt.effectiveGasPrice);\\n receipt.cumulativeGasUsed = _bytesToUint(rawReceipt.cumulativeGasUsed);\\n receipt.gasUsed = _bytesToUint(rawReceipt.gasUsed);\\n receipt.status = _bytesToUint(rawReceipt.status);\\n receipt.transactionIndex = _bytesToUint(rawReceipt.transactionIndex);\\n receipt.blockNumber = _bytesToUint(rawReceipt.blockNumber);\\n receipt.logs = rawToConvertedReceiptLogs(rawReceipt.logs);\\n receipt.logsBloom = rawReceipt.logsBloom;\\n receipt.transactionHash = rawReceipt.transactionHash;\\n return receipt;\\n }\\n\\n function rawToConvertedReceiptLogs(RawReceiptLog[] memory rawLogs)\\n internal\\n pure\\n virtual\\n returns (ReceiptLog[] memory)\\n {\\n ReceiptLog[] memory logs = new ReceiptLog[](rawLogs.length);\\n for (uint256 i; i < rawLogs.length; i++) {\\n logs[i].logAddress = rawLogs[i].logAddress;\\n logs[i].blockHash = rawLogs[i].blockHash;\\n logs[i].blockNumber = _bytesToUint(rawLogs[i].blockNumber);\\n logs[i].data = rawLogs[i].data;\\n logs[i].logIndex = _bytesToUint(rawLogs[i].logIndex);\\n logs[i].topics = rawLogs[i].topics;\\n logs[i].transactionIndex = _bytesToUint(rawLogs[i].transactionIndex);\\n logs[i].transactionLogIndex = _bytesToUint(rawLogs[i].transactionLogIndex);\\n logs[i].removed = rawLogs[i].removed;\\n }\\n return logs;\\n }\\n\\n // Deploy a contract by fetching the contract bytecode from\\n // the artifacts directory\\n // e.g. `deployCode(code, abi.encode(arg1,arg2,arg3))`\\n function deployCode(string memory what, bytes memory args) internal virtual returns (address addr) {\\n bytes memory bytecode = abi.encodePacked(vm.getCode(what), args);\\n /// @solidity memory-safe-assembly\\n assembly {\\n addr := create(0, add(bytecode, 0x20), mload(bytecode))\\n }\\n\\n require(addr != address(0), \\\"StdCheats deployCode(string,bytes): Deployment failed.\\\");\\n }\\n\\n function deployCode(string memory what) internal virtual returns (address addr) {\\n bytes memory bytecode = vm.getCode(what);\\n /// @solidity memory-safe-assembly\\n assembly {\\n addr := create(0, add(bytecode, 0x20), mload(bytecode))\\n }\\n\\n require(addr != address(0), \\\"StdCheats deployCode(string): Deployment failed.\\\");\\n }\\n\\n /// @dev deploy contract with value on construction\\n function deployCode(string memory what, bytes memory args, uint256 val) internal virtual returns (address addr) {\\n bytes memory bytecode = abi.encodePacked(vm.getCode(what), args);\\n /// @solidity memory-safe-assembly\\n assembly {\\n addr := create(val, add(bytecode, 0x20), mload(bytecode))\\n }\\n\\n require(addr != address(0), \\\"StdCheats deployCode(string,bytes,uint256): Deployment failed.\\\");\\n }\\n\\n function deployCode(string memory what, uint256 val) internal virtual returns (address addr) {\\n bytes memory bytecode = vm.getCode(what);\\n /// @solidity memory-safe-assembly\\n assembly {\\n addr := create(val, add(bytecode, 0x20), mload(bytecode))\\n }\\n\\n require(addr != address(0), \\\"StdCheats deployCode(string,uint256): Deployment failed.\\\");\\n }\\n\\n // creates a labeled address and the corresponding private key\\n function makeAddrAndKey(string memory name) internal virtual returns (address addr, uint256 privateKey) {\\n privateKey = uint256(keccak256(abi.encodePacked(name)));\\n addr = vm.addr(privateKey);\\n vm.label(addr, name);\\n }\\n\\n // creates a labeled address\\n function makeAddr(string memory name) internal virtual returns (address addr) {\\n (addr,) = makeAddrAndKey(name);\\n }\\n\\n // Destroys an account immediately, sending the balance to beneficiary.\\n // Destroying means: balance will be zero, code will be empty, and nonce will be 0\\n // This is similar to selfdestruct but not identical: selfdestruct destroys code and nonce\\n // only after tx ends, this will run immediately.\\n function destroyAccount(address who, address beneficiary) internal virtual {\\n uint256 currBalance = who.balance;\\n vm.etch(who, abi.encode());\\n vm.deal(who, 0);\\n vm.resetNonce(who);\\n\\n uint256 beneficiaryBalance = beneficiary.balance;\\n vm.deal(beneficiary, currBalance + beneficiaryBalance);\\n }\\n\\n // creates a struct containing both a labeled address and the corresponding private key\\n function makeAccount(string memory name) internal virtual returns (Account memory account) {\\n (account.addr, account.key) = makeAddrAndKey(name);\\n }\\n\\n function deriveRememberKey(string memory mnemonic, uint32 index)\\n internal\\n virtual\\n returns (address who, uint256 privateKey)\\n {\\n privateKey = vm.deriveKey(mnemonic, index);\\n who = vm.rememberKey(privateKey);\\n }\\n\\n function _bytesToUint(bytes memory b) private pure returns (uint256) {\\n require(b.length <= 32, \\\"StdCheats _bytesToUint(bytes): Bytes length exceeds 32.\\\");\\n return abi.decode(abi.encodePacked(new bytes(32 - b.length), b), (uint256));\\n }\\n\\n function isFork() internal view virtual returns (bool status) {\\n try vm.activeFork() {\\n status = true;\\n } catch (bytes memory) {}\\n }\\n\\n modifier skipWhenForking() {\\n if (!isFork()) {\\n _;\\n }\\n }\\n\\n modifier skipWhenNotForking() {\\n if (isFork()) {\\n _;\\n }\\n }\\n\\n modifier noGasMetering() {\\n vm.pauseGasMetering();\\n // To prevent turning gas monitoring back on with nested functions that use this modifier,\\n // we check if gasMetering started in the off position. If it did, we don't want to turn\\n // it back on until we exit the top level function that used the modifier\\n //\\n // i.e. funcA() noGasMetering { funcB() }, where funcB has noGasMetering as well.\\n // funcA will have `gasStartedOff` as false, funcB will have it as true,\\n // so we only turn metering back on at the end of the funcA\\n bool gasStartedOff = gasMeteringOff;\\n gasMeteringOff = true;\\n\\n _;\\n\\n // if gas metering was on when this modifier was called, turn it back on at the end\\n if (!gasStartedOff) {\\n gasMeteringOff = false;\\n vm.resumeGasMetering();\\n }\\n }\\n\\n // We use this complex approach of `_viewChainId` and `_pureChainId` to ensure there are no\\n // compiler warnings when accessing chain ID in any solidity version supported by forge-std. We\\n // can't simply access the chain ID in a normal view or pure function because the solc View Pure\\n // Checker changed `chainid` from pure to view in 0.8.0.\\n function _viewChainId() private view returns (uint256 chainId) {\\n // Assembly required since `block.chainid` was introduced in 0.8.0.\\n assembly {\\n chainId := chainid()\\n }\\n\\n address(this); // Silence warnings in older Solc versions.\\n }\\n\\n function _pureChainId() private pure returns (uint256 chainId) {\\n function() internal view returns (uint256) fnIn = _viewChainId;\\n function() internal pure returns (uint256) pureChainId;\\n assembly {\\n pureChainId := fnIn\\n }\\n chainId = pureChainId();\\n }\\n}\\n\\n// Wrappers around cheatcodes to avoid footguns\\nabstract contract StdCheats is StdCheatsSafe {\\n using stdStorage for StdStorage;\\n\\n StdStorage private stdstore;\\n Vm private constant vm = Vm(address(uint160(uint256(keccak256(\\\"hevm cheat code\\\")))));\\n address private constant CONSOLE2_ADDRESS = 0x000000000000000000636F6e736F6c652e6c6f67;\\n\\n // Skip forward or rewind time by the specified number of seconds\\n function skip(uint256 time) internal virtual {\\n vm.warp(vm.getBlockTimestamp() + time);\\n }\\n\\n function rewind(uint256 time) internal virtual {\\n vm.warp(vm.getBlockTimestamp() - time);\\n }\\n\\n // Setup a prank from an address that has some ether\\n function hoax(address msgSender) internal virtual {\\n vm.deal(msgSender, 1 << 128);\\n vm.prank(msgSender);\\n }\\n\\n function hoax(address msgSender, uint256 give) internal virtual {\\n vm.deal(msgSender, give);\\n vm.prank(msgSender);\\n }\\n\\n function hoax(address msgSender, address origin) internal virtual {\\n vm.deal(msgSender, 1 << 128);\\n vm.prank(msgSender, origin);\\n }\\n\\n function hoax(address msgSender, address origin, uint256 give) internal virtual {\\n vm.deal(msgSender, give);\\n vm.prank(msgSender, origin);\\n }\\n\\n // Start perpetual prank from an address that has some ether\\n function startHoax(address msgSender) internal virtual {\\n vm.deal(msgSender, 1 << 128);\\n vm.startPrank(msgSender);\\n }\\n\\n function startHoax(address msgSender, uint256 give) internal virtual {\\n vm.deal(msgSender, give);\\n vm.startPrank(msgSender);\\n }\\n\\n // Start perpetual prank from an address that has some ether\\n // tx.origin is set to the origin parameter\\n function startHoax(address msgSender, address origin) internal virtual {\\n vm.deal(msgSender, 1 << 128);\\n vm.startPrank(msgSender, origin);\\n }\\n\\n function startHoax(address msgSender, address origin, uint256 give) internal virtual {\\n vm.deal(msgSender, give);\\n vm.startPrank(msgSender, origin);\\n }\\n\\n function changePrank(address msgSender) internal virtual {\\n console2_log_StdCheats(\\\"changePrank is deprecated. Please use vm.startPrank instead.\\\");\\n vm.stopPrank();\\n vm.startPrank(msgSender);\\n }\\n\\n function changePrank(address msgSender, address txOrigin) internal virtual {\\n vm.stopPrank();\\n vm.startPrank(msgSender, txOrigin);\\n }\\n\\n // The same as Vm's `deal`\\n // Use the alternative signature for ERC20 tokens\\n function deal(address to, uint256 give) internal virtual {\\n vm.deal(to, give);\\n }\\n\\n // Set the balance of an account for any ERC20 token\\n // Use the alternative signature to update `totalSupply`\\n function deal(address token, address to, uint256 give) internal virtual {\\n deal(token, to, give, false);\\n }\\n\\n // Set the balance of an account for any ERC1155 token\\n // Use the alternative signature to update `totalSupply`\\n function dealERC1155(address token, address to, uint256 id, uint256 give) internal virtual {\\n dealERC1155(token, to, id, give, false);\\n }\\n\\n function deal(address token, address to, uint256 give, bool adjust) internal virtual {\\n // get current balance\\n (, bytes memory balData) = token.staticcall(abi.encodeWithSelector(0x70a08231, to));\\n uint256 prevBal = abi.decode(balData, (uint256));\\n\\n // update balance\\n stdstore.target(token).sig(0x70a08231).with_key(to).checked_write(give);\\n\\n // update total supply\\n if (adjust) {\\n (, bytes memory totSupData) = token.staticcall(abi.encodeWithSelector(0x18160ddd));\\n uint256 totSup = abi.decode(totSupData, (uint256));\\n if (give < prevBal) {\\n totSup -= (prevBal - give);\\n } else {\\n totSup += (give - prevBal);\\n }\\n stdstore.target(token).sig(0x18160ddd).checked_write(totSup);\\n }\\n }\\n\\n function dealERC1155(address token, address to, uint256 id, uint256 give, bool adjust) internal virtual {\\n // get current balance\\n (, bytes memory balData) = token.staticcall(abi.encodeWithSelector(0x00fdd58e, to, id));\\n uint256 prevBal = abi.decode(balData, (uint256));\\n\\n // update balance\\n stdstore.target(token).sig(0x00fdd58e).with_key(to).with_key(id).checked_write(give);\\n\\n // update total supply\\n if (adjust) {\\n (, bytes memory totSupData) = token.staticcall(abi.encodeWithSelector(0xbd85b039, id));\\n require(\\n totSupData.length != 0,\\n \\\"StdCheats deal(address,address,uint,uint,bool): target contract is not ERC1155Supply.\\\"\\n );\\n uint256 totSup = abi.decode(totSupData, (uint256));\\n if (give < prevBal) {\\n totSup -= (prevBal - give);\\n } else {\\n totSup += (give - prevBal);\\n }\\n stdstore.target(token).sig(0xbd85b039).with_key(id).checked_write(totSup);\\n }\\n }\\n\\n function dealERC721(address token, address to, uint256 id) internal virtual {\\n // check if token id is already minted and the actual owner.\\n (bool successMinted, bytes memory ownerData) = token.staticcall(abi.encodeWithSelector(0x6352211e, id));\\n require(successMinted, \\\"StdCheats deal(address,address,uint,bool): id not minted.\\\");\\n\\n // get owner current balance\\n (, bytes memory fromBalData) =\\n token.staticcall(abi.encodeWithSelector(0x70a08231, abi.decode(ownerData, (address))));\\n uint256 fromPrevBal = abi.decode(fromBalData, (uint256));\\n\\n // get new user current balance\\n (, bytes memory toBalData) = token.staticcall(abi.encodeWithSelector(0x70a08231, to));\\n uint256 toPrevBal = abi.decode(toBalData, (uint256));\\n\\n // update balances\\n stdstore.target(token).sig(0x70a08231).with_key(abi.decode(ownerData, (address))).checked_write(--fromPrevBal);\\n stdstore.target(token).sig(0x70a08231).with_key(to).checked_write(++toPrevBal);\\n\\n // update owner\\n stdstore.target(token).sig(0x6352211e).with_key(id).checked_write(to);\\n }\\n\\n function deployCodeTo(string memory what, address where) internal virtual {\\n deployCodeTo(what, \\\"\\\", 0, where);\\n }\\n\\n function deployCodeTo(string memory what, bytes memory args, address where) internal virtual {\\n deployCodeTo(what, args, 0, where);\\n }\\n\\n function deployCodeTo(string memory what, bytes memory args, uint256 value, address where) internal virtual {\\n bytes memory creationCode = vm.getCode(what);\\n vm.etch(where, abi.encodePacked(creationCode, args));\\n (bool success, bytes memory runtimeBytecode) = where.call{value: value}(\\\"\\\");\\n require(success, \\\"StdCheats deployCodeTo(string,bytes,uint256,address): Failed to create runtime bytecode.\\\");\\n vm.etch(where, runtimeBytecode);\\n }\\n\\n // Used to prevent the compilation of console, which shortens the compilation time when console is not used elsewhere.\\n function console2_log_StdCheats(string memory p0) private view {\\n (bool status,) = address(CONSOLE2_ADDRESS).staticcall(abi.encodeWithSignature(\\\"log(string)\\\", p0));\\n status;\\n }\\n}\\n\",\"keccak256\":\"0x0fa6ec03602648b62cce41aab2096e6b7e052f2846075d967b6958dd586db746\",\"license\":\"MIT\"},\"lib/forge-std/src/StdConstants.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity >=0.6.2 <0.9.0;\\n\\nimport {IMulticall3} from \\\"./interfaces/IMulticall3.sol\\\";\\nimport {Vm} from \\\"./Vm.sol\\\";\\n\\nlibrary StdConstants {\\n /// @dev Cheat code address.\\n /// Calculated as `address(uint160(uint256(keccak256(\\\"hevm cheat code\\\"))))`.\\n Vm internal constant VM = Vm(0x7109709ECfa91a80626fF3989D68f67F5b1DD12D);\\n /// @dev console.sol and console2.sol work by executing a staticcall to this address.\\n /// Calculated as `address(uint160(uint88(bytes11(\\\"console.log\\\"))))`.\\n address internal constant CONSOLE = 0x000000000000000000636F6e736F6c652e6c6f67;\\n /// @dev Used when deploying with create2.\\n /// Taken from https://github.com/Arachnid/deterministic-deployment-proxy.\\n address internal constant CREATE2_FACTORY = 0x4e59b44847b379578588920cA78FbF26c0B4956C;\\n /// @dev The default address for tx.origin and msg.sender.\\n /// Calculated as `address(uint160(uint256(keccak256(\\\"foundry default caller\\\"))))`.\\n address internal constant DEFAULT_SENDER = 0x1804c8AB1F12E6bbf3894d4083f33e07309d1f38;\\n /// @dev The address of the first contract `CREATE`d by a running test contract.\\n /// When running tests, each test contract is `CREATE`d by `DEFAULT_SENDER` with nonce 1.\\n /// Calculated as `VM.computeCreateAddress(VM.computeCreateAddress(DEFAULT_SENDER, 1), 1)`.\\n address internal constant DEFAULT_TEST_CONTRACT = 0x5615dEB798BB3E4dFa0139dFa1b3D433Cc23b72f;\\n /// @dev Deterministic deployment address of the Multicall3 contract.\\n /// Taken from https://www.multicall3.com.\\n IMulticall3 internal constant MULTICALL3_ADDRESS = IMulticall3(0xcA11bde05977b3631167028862bE2a173976CA11);\\n /// @dev The order of the secp256k1 curve.\\n uint256 internal constant SECP256K1_ORDER =\\n 115792089237316195423570985008687907852837564279074904382605163141518161494337;\\n}\\n\",\"keccak256\":\"0x319ccdabfa2c0b2428301445873270ffea20f0e039d4fd5e6eeba65158e4e534\",\"license\":\"MIT\"},\"lib/forge-std/src/StdJson.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity >=0.6.0 <0.9.0;\\n\\npragma experimental ABIEncoderV2;\\n\\nimport {VmSafe} from \\\"./Vm.sol\\\";\\n\\n// Helpers for parsing and writing JSON files\\n// To parse:\\n// ```\\n// using stdJson for string;\\n// string memory json = vm.readFile(\\\"\\\");\\n// json.readUint(\\\"\\\");\\n// ```\\n// To write:\\n// ```\\n// using stdJson for string;\\n// string memory json = \\\"json\\\";\\n// json.serialize(\\\"a\\\", uint256(123));\\n// string memory semiFinal = json.serialize(\\\"b\\\", string(\\\"test\\\"));\\n// string memory finalJson = json.serialize(\\\"c\\\", semiFinal);\\n// finalJson.write(\\\"\\\");\\n// ```\\n\\nlibrary stdJson {\\n VmSafe private constant vm = VmSafe(address(uint160(uint256(keccak256(\\\"hevm cheat code\\\")))));\\n\\n function keyExists(string memory json, string memory key) internal view returns (bool) {\\n return vm.keyExistsJson(json, key);\\n }\\n\\n function parseRaw(string memory json, string memory key) internal pure returns (bytes memory) {\\n return vm.parseJson(json, key);\\n }\\n\\n function readUint(string memory json, string memory key) internal pure returns (uint256) {\\n return vm.parseJsonUint(json, key);\\n }\\n\\n function readUintArray(string memory json, string memory key) internal pure returns (uint256[] memory) {\\n return vm.parseJsonUintArray(json, key);\\n }\\n\\n function readInt(string memory json, string memory key) internal pure returns (int256) {\\n return vm.parseJsonInt(json, key);\\n }\\n\\n function readIntArray(string memory json, string memory key) internal pure returns (int256[] memory) {\\n return vm.parseJsonIntArray(json, key);\\n }\\n\\n function readBytes32(string memory json, string memory key) internal pure returns (bytes32) {\\n return vm.parseJsonBytes32(json, key);\\n }\\n\\n function readBytes32Array(string memory json, string memory key) internal pure returns (bytes32[] memory) {\\n return vm.parseJsonBytes32Array(json, key);\\n }\\n\\n function readString(string memory json, string memory key) internal pure returns (string memory) {\\n return vm.parseJsonString(json, key);\\n }\\n\\n function readStringArray(string memory json, string memory key) internal pure returns (string[] memory) {\\n return vm.parseJsonStringArray(json, key);\\n }\\n\\n function readAddress(string memory json, string memory key) internal pure returns (address) {\\n return vm.parseJsonAddress(json, key);\\n }\\n\\n function readAddressArray(string memory json, string memory key) internal pure returns (address[] memory) {\\n return vm.parseJsonAddressArray(json, key);\\n }\\n\\n function readBool(string memory json, string memory key) internal pure returns (bool) {\\n return vm.parseJsonBool(json, key);\\n }\\n\\n function readBoolArray(string memory json, string memory key) internal pure returns (bool[] memory) {\\n return vm.parseJsonBoolArray(json, key);\\n }\\n\\n function readBytes(string memory json, string memory key) internal pure returns (bytes memory) {\\n return vm.parseJsonBytes(json, key);\\n }\\n\\n function readBytesArray(string memory json, string memory key) internal pure returns (bytes[] memory) {\\n return vm.parseJsonBytesArray(json, key);\\n }\\n\\n function readUintOr(string memory json, string memory key, uint256 defaultValue) internal view returns (uint256) {\\n return keyExists(json, key) ? readUint(json, key) : defaultValue;\\n }\\n\\n function readUintArrayOr(string memory json, string memory key, uint256[] memory defaultValue)\\n internal\\n view\\n returns (uint256[] memory)\\n {\\n return keyExists(json, key) ? readUintArray(json, key) : defaultValue;\\n }\\n\\n function readIntOr(string memory json, string memory key, int256 defaultValue) internal view returns (int256) {\\n return keyExists(json, key) ? readInt(json, key) : defaultValue;\\n }\\n\\n function readIntArrayOr(string memory json, string memory key, int256[] memory defaultValue)\\n internal\\n view\\n returns (int256[] memory)\\n {\\n return keyExists(json, key) ? readIntArray(json, key) : defaultValue;\\n }\\n\\n function readBytes32Or(string memory json, string memory key, bytes32 defaultValue)\\n internal\\n view\\n returns (bytes32)\\n {\\n return keyExists(json, key) ? readBytes32(json, key) : defaultValue;\\n }\\n\\n function readBytes32ArrayOr(string memory json, string memory key, bytes32[] memory defaultValue)\\n internal\\n view\\n returns (bytes32[] memory)\\n {\\n return keyExists(json, key) ? readBytes32Array(json, key) : defaultValue;\\n }\\n\\n function readStringOr(string memory json, string memory key, string memory defaultValue)\\n internal\\n view\\n returns (string memory)\\n {\\n return keyExists(json, key) ? readString(json, key) : defaultValue;\\n }\\n\\n function readStringArrayOr(string memory json, string memory key, string[] memory defaultValue)\\n internal\\n view\\n returns (string[] memory)\\n {\\n return keyExists(json, key) ? readStringArray(json, key) : defaultValue;\\n }\\n\\n function readAddressOr(string memory json, string memory key, address defaultValue)\\n internal\\n view\\n returns (address)\\n {\\n return keyExists(json, key) ? readAddress(json, key) : defaultValue;\\n }\\n\\n function readAddressArrayOr(string memory json, string memory key, address[] memory defaultValue)\\n internal\\n view\\n returns (address[] memory)\\n {\\n return keyExists(json, key) ? readAddressArray(json, key) : defaultValue;\\n }\\n\\n function readBoolOr(string memory json, string memory key, bool defaultValue) internal view returns (bool) {\\n return keyExists(json, key) ? readBool(json, key) : defaultValue;\\n }\\n\\n function readBoolArrayOr(string memory json, string memory key, bool[] memory defaultValue)\\n internal\\n view\\n returns (bool[] memory)\\n {\\n return keyExists(json, key) ? readBoolArray(json, key) : defaultValue;\\n }\\n\\n function readBytesOr(string memory json, string memory key, bytes memory defaultValue)\\n internal\\n view\\n returns (bytes memory)\\n {\\n return keyExists(json, key) ? readBytes(json, key) : defaultValue;\\n }\\n\\n function readBytesArrayOr(string memory json, string memory key, bytes[] memory defaultValue)\\n internal\\n view\\n returns (bytes[] memory)\\n {\\n return keyExists(json, key) ? readBytesArray(json, key) : defaultValue;\\n }\\n\\n function serialize(string memory jsonKey, string memory rootObject) internal returns (string memory) {\\n return vm.serializeJson(jsonKey, rootObject);\\n }\\n\\n function serialize(string memory jsonKey, string memory key, bool value) internal returns (string memory) {\\n return vm.serializeBool(jsonKey, key, value);\\n }\\n\\n function serialize(string memory jsonKey, string memory key, bool[] memory value)\\n internal\\n returns (string memory)\\n {\\n return vm.serializeBool(jsonKey, key, value);\\n }\\n\\n function serialize(string memory jsonKey, string memory key, uint256 value) internal returns (string memory) {\\n return vm.serializeUint(jsonKey, key, value);\\n }\\n\\n function serialize(string memory jsonKey, string memory key, uint256[] memory value)\\n internal\\n returns (string memory)\\n {\\n return vm.serializeUint(jsonKey, key, value);\\n }\\n\\n function serialize(string memory jsonKey, string memory key, int256 value) internal returns (string memory) {\\n return vm.serializeInt(jsonKey, key, value);\\n }\\n\\n function serialize(string memory jsonKey, string memory key, int256[] memory value)\\n internal\\n returns (string memory)\\n {\\n return vm.serializeInt(jsonKey, key, value);\\n }\\n\\n function serialize(string memory jsonKey, string memory key, address value) internal returns (string memory) {\\n return vm.serializeAddress(jsonKey, key, value);\\n }\\n\\n function serialize(string memory jsonKey, string memory key, address[] memory value)\\n internal\\n returns (string memory)\\n {\\n return vm.serializeAddress(jsonKey, key, value);\\n }\\n\\n function serialize(string memory jsonKey, string memory key, bytes32 value) internal returns (string memory) {\\n return vm.serializeBytes32(jsonKey, key, value);\\n }\\n\\n function serialize(string memory jsonKey, string memory key, bytes32[] memory value)\\n internal\\n returns (string memory)\\n {\\n return vm.serializeBytes32(jsonKey, key, value);\\n }\\n\\n function serialize(string memory jsonKey, string memory key, bytes memory value) internal returns (string memory) {\\n return vm.serializeBytes(jsonKey, key, value);\\n }\\n\\n function serialize(string memory jsonKey, string memory key, bytes[] memory value)\\n internal\\n returns (string memory)\\n {\\n return vm.serializeBytes(jsonKey, key, value);\\n }\\n\\n function serialize(string memory jsonKey, string memory key, string memory value)\\n internal\\n returns (string memory)\\n {\\n return vm.serializeString(jsonKey, key, value);\\n }\\n\\n function serialize(string memory jsonKey, string memory key, string[] memory value)\\n internal\\n returns (string memory)\\n {\\n return vm.serializeString(jsonKey, key, value);\\n }\\n\\n function write(string memory jsonKey, string memory path) internal {\\n vm.writeJson(jsonKey, path);\\n }\\n\\n function write(string memory jsonKey, string memory path, string memory valueKey) internal {\\n vm.writeJson(jsonKey, path, valueKey);\\n }\\n}\\n\",\"keccak256\":\"0xbc0132abe1c2accc2867c0f03667afffdf92f3e95a581bb03c9557eaa38ea500\",\"license\":\"MIT\"},\"lib/forge-std/src/StdMath.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity >=0.6.2 <0.9.0;\\n\\nlibrary stdMath {\\n int256 private constant INT256_MIN = -57896044618658097711785492504343953926634992332820282019728792003956564819968;\\n\\n function abs(int256 a) internal pure returns (uint256) {\\n // Required or it will fail when `a = type(int256).min`\\n if (a == INT256_MIN) {\\n return 57896044618658097711785492504343953926634992332820282019728792003956564819968;\\n }\\n\\n return uint256(a > 0 ? a : -a);\\n }\\n\\n function delta(uint256 a, uint256 b) internal pure returns (uint256) {\\n return a > b ? a - b : b - a;\\n }\\n\\n function delta(int256 a, int256 b) internal pure returns (uint256) {\\n // a and b are of the same sign\\n // this works thanks to two's complement, the left-most bit is the sign bit\\n if ((a ^ b) > -1) {\\n return delta(abs(a), abs(b));\\n }\\n\\n // a and b are of opposite signs\\n return abs(a) + abs(b);\\n }\\n\\n function percentDelta(uint256 a, uint256 b) internal pure returns (uint256) {\\n uint256 absDelta = delta(a, b);\\n\\n return absDelta * 1e18 / b;\\n }\\n\\n function percentDelta(int256 a, int256 b) internal pure returns (uint256) {\\n uint256 absDelta = delta(a, b);\\n uint256 absB = abs(b);\\n\\n return absDelta * 1e18 / absB;\\n }\\n}\\n\",\"keccak256\":\"0xd90ad4fd8aeaeb8929964e686e769fdedd5eded3fc3815df194a0ab9f91a3fb2\",\"license\":\"MIT\"},\"lib/forge-std/src/StdStorage.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity >=0.6.2 <0.9.0;\\n\\nimport {Vm} from \\\"./Vm.sol\\\";\\n\\nstruct FindData {\\n uint256 slot;\\n uint256 offsetLeft;\\n uint256 offsetRight;\\n bool found;\\n}\\n\\nstruct StdStorage {\\n mapping(address => mapping(bytes4 => mapping(bytes32 => FindData))) finds;\\n bytes32[] _keys;\\n bytes4 _sig;\\n uint256 _depth;\\n address _target;\\n bytes32 _set;\\n bool _enable_packed_slots;\\n bytes _calldata;\\n}\\n\\nlibrary stdStorageSafe {\\n event SlotFound(address who, bytes4 fsig, bytes32 keysHash, uint256 slot);\\n event WARNING_UninitedSlot(address who, uint256 slot);\\n\\n Vm private constant vm = Vm(address(uint160(uint256(keccak256(\\\"hevm cheat code\\\")))));\\n uint256 constant UINT256_MAX = 115792089237316195423570985008687907853269984665640564039457584007913129639935;\\n\\n function sigs(string memory sigStr) internal pure returns (bytes4) {\\n return bytes4(keccak256(bytes(sigStr)));\\n }\\n\\n function getCallParams(StdStorage storage self) internal view returns (bytes memory) {\\n if (self._calldata.length == 0) {\\n return flatten(self._keys);\\n } else {\\n return self._calldata;\\n }\\n }\\n\\n // Calls target contract with configured parameters\\n function callTarget(StdStorage storage self) internal view returns (bool, bytes32) {\\n bytes memory cald = abi.encodePacked(self._sig, getCallParams(self));\\n (bool success, bytes memory rdat) = self._target.staticcall(cald);\\n bytes32 result = bytesToBytes32(rdat, 32 * self._depth);\\n\\n return (success, result);\\n }\\n\\n // Tries mutating slot value to determine if the targeted value is stored in it.\\n // If current value is 0, then we are setting slot value to type(uint256).max\\n // Otherwise, we set it to 0. That way, return value should always be affected.\\n function checkSlotMutatesCall(StdStorage storage self, bytes32 slot) internal returns (bool) {\\n bytes32 prevSlotValue = vm.load(self._target, slot);\\n (bool success, bytes32 prevReturnValue) = callTarget(self);\\n\\n bytes32 testVal = prevReturnValue == bytes32(0) ? bytes32(UINT256_MAX) : bytes32(0);\\n vm.store(self._target, slot, testVal);\\n\\n (, bytes32 newReturnValue) = callTarget(self);\\n\\n vm.store(self._target, slot, prevSlotValue);\\n\\n return (success && (prevReturnValue != newReturnValue));\\n }\\n\\n // Tries setting one of the bits in slot to 1 until return value changes.\\n // Index of resulted bit is an offset packed slot has from left/right side\\n function findOffset(StdStorage storage self, bytes32 slot, bool left) internal returns (bool, uint256) {\\n for (uint256 offset = 0; offset < 256; offset++) {\\n uint256 valueToPut = left ? (1 << (255 - offset)) : (1 << offset);\\n vm.store(self._target, slot, bytes32(valueToPut));\\n\\n (bool success, bytes32 data) = callTarget(self);\\n\\n if (success && (uint256(data) > 0)) {\\n return (true, offset);\\n }\\n }\\n return (false, 0);\\n }\\n\\n function findOffsets(StdStorage storage self, bytes32 slot) internal returns (bool, uint256, uint256) {\\n bytes32 prevSlotValue = vm.load(self._target, slot);\\n\\n (bool foundLeft, uint256 offsetLeft) = findOffset(self, slot, true);\\n (bool foundRight, uint256 offsetRight) = findOffset(self, slot, false);\\n\\n // `findOffset` may mutate slot value, so we are setting it to initial value\\n vm.store(self._target, slot, prevSlotValue);\\n return (foundLeft && foundRight, offsetLeft, offsetRight);\\n }\\n\\n function find(StdStorage storage self) internal returns (FindData storage) {\\n return find(self, true);\\n }\\n\\n /// @notice find an arbitrary storage slot given a function sig, input data, address of the contract and a value to check against\\n // slot complexity:\\n // if flat, will be bytes32(uint256(uint));\\n // if map, will be keccak256(abi.encode(key, uint(slot)));\\n // if deep map, will be keccak256(abi.encode(key1, keccak256(abi.encode(key0, uint(slot)))));\\n // if map struct, will be bytes32(uint256(keccak256(abi.encode(key1, keccak256(abi.encode(key0, uint(slot)))))) + structFieldDepth);\\n function find(StdStorage storage self, bool _clear) internal returns (FindData storage) {\\n address who = self._target;\\n bytes4 fsig = self._sig;\\n uint256 field_depth = self._depth;\\n bytes memory params = getCallParams(self);\\n\\n // calldata to test against\\n if (self.finds[who][fsig][keccak256(abi.encodePacked(params, field_depth))].found) {\\n if (_clear) {\\n clear(self);\\n }\\n return self.finds[who][fsig][keccak256(abi.encodePacked(params, field_depth))];\\n }\\n vm.record();\\n (, bytes32 callResult) = callTarget(self);\\n (bytes32[] memory reads,) = vm.accesses(address(who));\\n\\n if (reads.length == 0) {\\n revert(\\\"stdStorage find(StdStorage): No storage use detected for target.\\\");\\n } else {\\n for (uint256 i = reads.length; --i >= 0;) {\\n bytes32 prev = vm.load(who, reads[i]);\\n if (prev == bytes32(0)) {\\n emit WARNING_UninitedSlot(who, uint256(reads[i]));\\n }\\n\\n if (!checkSlotMutatesCall(self, reads[i])) {\\n continue;\\n }\\n\\n (uint256 offsetLeft, uint256 offsetRight) = (0, 0);\\n\\n if (self._enable_packed_slots) {\\n bool found;\\n (found, offsetLeft, offsetRight) = findOffsets(self, reads[i]);\\n if (!found) {\\n continue;\\n }\\n }\\n\\n // Check that value between found offsets is equal to the current call result\\n uint256 curVal = (uint256(prev) & getMaskByOffsets(offsetLeft, offsetRight)) >> offsetRight;\\n\\n if (uint256(callResult) != curVal) {\\n continue;\\n }\\n\\n emit SlotFound(who, fsig, keccak256(abi.encodePacked(params, field_depth)), uint256(reads[i]));\\n self.finds[who][fsig][keccak256(abi.encodePacked(params, field_depth))] =\\n FindData(uint256(reads[i]), offsetLeft, offsetRight, true);\\n break;\\n }\\n }\\n\\n require(\\n self.finds[who][fsig][keccak256(abi.encodePacked(params, field_depth))].found,\\n \\\"stdStorage find(StdStorage): Slot(s) not found.\\\"\\n );\\n\\n if (_clear) {\\n clear(self);\\n }\\n return self.finds[who][fsig][keccak256(abi.encodePacked(params, field_depth))];\\n }\\n\\n function target(StdStorage storage self, address _target) internal returns (StdStorage storage) {\\n self._target = _target;\\n return self;\\n }\\n\\n function sig(StdStorage storage self, bytes4 _sig) internal returns (StdStorage storage) {\\n self._sig = _sig;\\n return self;\\n }\\n\\n function sig(StdStorage storage self, string memory _sig) internal returns (StdStorage storage) {\\n self._sig = sigs(_sig);\\n return self;\\n }\\n\\n function with_calldata(StdStorage storage self, bytes memory _calldata) internal returns (StdStorage storage) {\\n self._calldata = _calldata;\\n return self;\\n }\\n\\n function with_key(StdStorage storage self, address who) internal returns (StdStorage storage) {\\n self._keys.push(bytes32(uint256(uint160(who))));\\n return self;\\n }\\n\\n function with_key(StdStorage storage self, uint256 amt) internal returns (StdStorage storage) {\\n self._keys.push(bytes32(amt));\\n return self;\\n }\\n\\n function with_key(StdStorage storage self, bytes32 key) internal returns (StdStorage storage) {\\n self._keys.push(key);\\n return self;\\n }\\n\\n function enable_packed_slots(StdStorage storage self) internal returns (StdStorage storage) {\\n self._enable_packed_slots = true;\\n return self;\\n }\\n\\n function depth(StdStorage storage self, uint256 _depth) internal returns (StdStorage storage) {\\n self._depth = _depth;\\n return self;\\n }\\n\\n function read(StdStorage storage self) private returns (bytes memory) {\\n FindData storage data = find(self, false);\\n uint256 mask = getMaskByOffsets(data.offsetLeft, data.offsetRight);\\n uint256 value = (uint256(vm.load(self._target, bytes32(data.slot))) & mask) >> data.offsetRight;\\n clear(self);\\n return abi.encode(value);\\n }\\n\\n function read_bytes32(StdStorage storage self) internal returns (bytes32) {\\n return abi.decode(read(self), (bytes32));\\n }\\n\\n function read_bool(StdStorage storage self) internal returns (bool) {\\n int256 v = read_int(self);\\n if (v == 0) return false;\\n if (v == 1) return true;\\n revert(\\\"stdStorage read_bool(StdStorage): Cannot decode. Make sure you are reading a bool.\\\");\\n }\\n\\n function read_address(StdStorage storage self) internal returns (address) {\\n return abi.decode(read(self), (address));\\n }\\n\\n function read_uint(StdStorage storage self) internal returns (uint256) {\\n return abi.decode(read(self), (uint256));\\n }\\n\\n function read_int(StdStorage storage self) internal returns (int256) {\\n return abi.decode(read(self), (int256));\\n }\\n\\n function parent(StdStorage storage self) internal returns (uint256, bytes32) {\\n address who = self._target;\\n uint256 field_depth = self._depth;\\n vm.startMappingRecording();\\n uint256 child = find(self, true).slot - field_depth;\\n (bool found, bytes32 key, bytes32 parent_slot) = vm.getMappingKeyAndParentOf(who, bytes32(child));\\n if (!found) {\\n revert(\\n \\\"stdStorage read_bool(StdStorage): Cannot find parent. Make sure you give a slot and startMappingRecording() has been called.\\\"\\n );\\n }\\n return (uint256(parent_slot), key);\\n }\\n\\n function root(StdStorage storage self) internal returns (uint256) {\\n address who = self._target;\\n uint256 field_depth = self._depth;\\n vm.startMappingRecording();\\n uint256 child = find(self, true).slot - field_depth;\\n bool found;\\n bytes32 root_slot;\\n bytes32 parent_slot;\\n (found,, parent_slot) = vm.getMappingKeyAndParentOf(who, bytes32(child));\\n if (!found) {\\n revert(\\n \\\"stdStorage read_bool(StdStorage): Cannot find parent. Make sure you give a slot and startMappingRecording() has been called.\\\"\\n );\\n }\\n while (found) {\\n root_slot = parent_slot;\\n (found,, parent_slot) = vm.getMappingKeyAndParentOf(who, bytes32(root_slot));\\n }\\n return uint256(root_slot);\\n }\\n\\n function bytesToBytes32(bytes memory b, uint256 offset) private pure returns (bytes32) {\\n bytes32 out;\\n\\n uint256 max = b.length > 32 ? 32 : b.length;\\n for (uint256 i = 0; i < max; i++) {\\n out |= bytes32(b[offset + i] & 0xFF) >> (i * 8);\\n }\\n return out;\\n }\\n\\n function flatten(bytes32[] memory b) private pure returns (bytes memory) {\\n bytes memory result = new bytes(b.length * 32);\\n for (uint256 i = 0; i < b.length; i++) {\\n bytes32 k = b[i];\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(add(result, add(32, mul(32, i))), k)\\n }\\n }\\n\\n return result;\\n }\\n\\n function clear(StdStorage storage self) internal {\\n delete self._target;\\n delete self._sig;\\n delete self._keys;\\n delete self._depth;\\n delete self._enable_packed_slots;\\n delete self._calldata;\\n }\\n\\n // Returns mask which contains non-zero bits for values between `offsetLeft` and `offsetRight`\\n // (slotValue & mask) >> offsetRight will be the value of the given packed variable\\n function getMaskByOffsets(uint256 offsetLeft, uint256 offsetRight) internal pure returns (uint256 mask) {\\n // mask = ((1 << (256 - (offsetRight + offsetLeft))) - 1) << offsetRight;\\n // using assembly because (1 << 256) causes overflow\\n assembly {\\n mask := shl(offsetRight, sub(shl(sub(256, add(offsetRight, offsetLeft)), 1), 1))\\n }\\n }\\n\\n // Returns slot value with updated packed variable.\\n function getUpdatedSlotValue(bytes32 curValue, uint256 varValue, uint256 offsetLeft, uint256 offsetRight)\\n internal\\n pure\\n returns (bytes32 newValue)\\n {\\n return bytes32((uint256(curValue) & ~getMaskByOffsets(offsetLeft, offsetRight)) | (varValue << offsetRight));\\n }\\n}\\n\\nlibrary stdStorage {\\n Vm private constant vm = Vm(address(uint160(uint256(keccak256(\\\"hevm cheat code\\\")))));\\n\\n function sigs(string memory sigStr) internal pure returns (bytes4) {\\n return stdStorageSafe.sigs(sigStr);\\n }\\n\\n function find(StdStorage storage self) internal returns (uint256) {\\n return find(self, true);\\n }\\n\\n function find(StdStorage storage self, bool _clear) internal returns (uint256) {\\n return stdStorageSafe.find(self, _clear).slot;\\n }\\n\\n function target(StdStorage storage self, address _target) internal returns (StdStorage storage) {\\n return stdStorageSafe.target(self, _target);\\n }\\n\\n function sig(StdStorage storage self, bytes4 _sig) internal returns (StdStorage storage) {\\n return stdStorageSafe.sig(self, _sig);\\n }\\n\\n function sig(StdStorage storage self, string memory _sig) internal returns (StdStorage storage) {\\n return stdStorageSafe.sig(self, _sig);\\n }\\n\\n function with_key(StdStorage storage self, address who) internal returns (StdStorage storage) {\\n return stdStorageSafe.with_key(self, who);\\n }\\n\\n function with_key(StdStorage storage self, uint256 amt) internal returns (StdStorage storage) {\\n return stdStorageSafe.with_key(self, amt);\\n }\\n\\n function with_key(StdStorage storage self, bytes32 key) internal returns (StdStorage storage) {\\n return stdStorageSafe.with_key(self, key);\\n }\\n\\n function with_calldata(StdStorage storage self, bytes memory _calldata) internal returns (StdStorage storage) {\\n return stdStorageSafe.with_calldata(self, _calldata);\\n }\\n\\n function enable_packed_slots(StdStorage storage self) internal returns (StdStorage storage) {\\n return stdStorageSafe.enable_packed_slots(self);\\n }\\n\\n function depth(StdStorage storage self, uint256 _depth) internal returns (StdStorage storage) {\\n return stdStorageSafe.depth(self, _depth);\\n }\\n\\n function clear(StdStorage storage self) internal {\\n stdStorageSafe.clear(self);\\n }\\n\\n function checked_write(StdStorage storage self, address who) internal {\\n checked_write(self, bytes32(uint256(uint160(who))));\\n }\\n\\n function checked_write(StdStorage storage self, uint256 amt) internal {\\n checked_write(self, bytes32(amt));\\n }\\n\\n function checked_write_int(StdStorage storage self, int256 val) internal {\\n checked_write(self, bytes32(uint256(val)));\\n }\\n\\n function checked_write(StdStorage storage self, bool write) internal {\\n bytes32 t;\\n /// @solidity memory-safe-assembly\\n assembly {\\n t := write\\n }\\n checked_write(self, t);\\n }\\n\\n function checked_write(StdStorage storage self, bytes32 set) internal {\\n address who = self._target;\\n bytes4 fsig = self._sig;\\n uint256 field_depth = self._depth;\\n bytes memory params = stdStorageSafe.getCallParams(self);\\n\\n if (!self.finds[who][fsig][keccak256(abi.encodePacked(params, field_depth))].found) {\\n find(self, false);\\n }\\n FindData storage data = self.finds[who][fsig][keccak256(abi.encodePacked(params, field_depth))];\\n if ((data.offsetLeft + data.offsetRight) > 0) {\\n uint256 maxVal = 2 ** (256 - (data.offsetLeft + data.offsetRight));\\n require(\\n uint256(set) < maxVal,\\n string(\\n abi.encodePacked(\\n \\\"stdStorage find(StdStorage): Packed slot. We can't fit value greater than \\\",\\n vm.toString(maxVal)\\n )\\n )\\n );\\n }\\n bytes32 curVal = vm.load(who, bytes32(data.slot));\\n bytes32 valToSet = stdStorageSafe.getUpdatedSlotValue(curVal, uint256(set), data.offsetLeft, data.offsetRight);\\n\\n vm.store(who, bytes32(data.slot), valToSet);\\n\\n (bool success, bytes32 callResult) = stdStorageSafe.callTarget(self);\\n\\n if (!success || callResult != set) {\\n vm.store(who, bytes32(data.slot), curVal);\\n revert(\\\"stdStorage find(StdStorage): Failed to write value.\\\");\\n }\\n clear(self);\\n }\\n\\n function read_bytes32(StdStorage storage self) internal returns (bytes32) {\\n return stdStorageSafe.read_bytes32(self);\\n }\\n\\n function read_bool(StdStorage storage self) internal returns (bool) {\\n return stdStorageSafe.read_bool(self);\\n }\\n\\n function read_address(StdStorage storage self) internal returns (address) {\\n return stdStorageSafe.read_address(self);\\n }\\n\\n function read_uint(StdStorage storage self) internal returns (uint256) {\\n return stdStorageSafe.read_uint(self);\\n }\\n\\n function read_int(StdStorage storage self) internal returns (int256) {\\n return stdStorageSafe.read_int(self);\\n }\\n\\n function parent(StdStorage storage self) internal returns (uint256, bytes32) {\\n return stdStorageSafe.parent(self);\\n }\\n\\n function root(StdStorage storage self) internal returns (uint256) {\\n return stdStorageSafe.root(self);\\n }\\n}\\n\",\"keccak256\":\"0xb91ab24383a5872b894fc93325eef1add6cbbf981628f18e860068bf88bb7dcc\",\"license\":\"MIT\"},\"lib/forge-std/src/StdStyle.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity >=0.4.22 <0.9.0;\\n\\nimport {VmSafe} from \\\"./Vm.sol\\\";\\n\\nlibrary StdStyle {\\n VmSafe private constant vm = VmSafe(address(uint160(uint256(keccak256(\\\"hevm cheat code\\\")))));\\n\\n string constant RED = \\\"\\\\u001b[91m\\\";\\n string constant GREEN = \\\"\\\\u001b[92m\\\";\\n string constant YELLOW = \\\"\\\\u001b[93m\\\";\\n string constant BLUE = \\\"\\\\u001b[94m\\\";\\n string constant MAGENTA = \\\"\\\\u001b[95m\\\";\\n string constant CYAN = \\\"\\\\u001b[96m\\\";\\n string constant BOLD = \\\"\\\\u001b[1m\\\";\\n string constant DIM = \\\"\\\\u001b[2m\\\";\\n string constant ITALIC = \\\"\\\\u001b[3m\\\";\\n string constant UNDERLINE = \\\"\\\\u001b[4m\\\";\\n string constant INVERSE = \\\"\\\\u001b[7m\\\";\\n string constant RESET = \\\"\\\\u001b[0m\\\";\\n\\n function styleConcat(string memory style, string memory self) private pure returns (string memory) {\\n return string(abi.encodePacked(style, self, RESET));\\n }\\n\\n function red(string memory self) internal pure returns (string memory) {\\n return styleConcat(RED, self);\\n }\\n\\n function red(uint256 self) internal pure returns (string memory) {\\n return red(vm.toString(self));\\n }\\n\\n function red(int256 self) internal pure returns (string memory) {\\n return red(vm.toString(self));\\n }\\n\\n function red(address self) internal pure returns (string memory) {\\n return red(vm.toString(self));\\n }\\n\\n function red(bool self) internal pure returns (string memory) {\\n return red(vm.toString(self));\\n }\\n\\n function redBytes(bytes memory self) internal pure returns (string memory) {\\n return red(vm.toString(self));\\n }\\n\\n function redBytes32(bytes32 self) internal pure returns (string memory) {\\n return red(vm.toString(self));\\n }\\n\\n function green(string memory self) internal pure returns (string memory) {\\n return styleConcat(GREEN, self);\\n }\\n\\n function green(uint256 self) internal pure returns (string memory) {\\n return green(vm.toString(self));\\n }\\n\\n function green(int256 self) internal pure returns (string memory) {\\n return green(vm.toString(self));\\n }\\n\\n function green(address self) internal pure returns (string memory) {\\n return green(vm.toString(self));\\n }\\n\\n function green(bool self) internal pure returns (string memory) {\\n return green(vm.toString(self));\\n }\\n\\n function greenBytes(bytes memory self) internal pure returns (string memory) {\\n return green(vm.toString(self));\\n }\\n\\n function greenBytes32(bytes32 self) internal pure returns (string memory) {\\n return green(vm.toString(self));\\n }\\n\\n function yellow(string memory self) internal pure returns (string memory) {\\n return styleConcat(YELLOW, self);\\n }\\n\\n function yellow(uint256 self) internal pure returns (string memory) {\\n return yellow(vm.toString(self));\\n }\\n\\n function yellow(int256 self) internal pure returns (string memory) {\\n return yellow(vm.toString(self));\\n }\\n\\n function yellow(address self) internal pure returns (string memory) {\\n return yellow(vm.toString(self));\\n }\\n\\n function yellow(bool self) internal pure returns (string memory) {\\n return yellow(vm.toString(self));\\n }\\n\\n function yellowBytes(bytes memory self) internal pure returns (string memory) {\\n return yellow(vm.toString(self));\\n }\\n\\n function yellowBytes32(bytes32 self) internal pure returns (string memory) {\\n return yellow(vm.toString(self));\\n }\\n\\n function blue(string memory self) internal pure returns (string memory) {\\n return styleConcat(BLUE, self);\\n }\\n\\n function blue(uint256 self) internal pure returns (string memory) {\\n return blue(vm.toString(self));\\n }\\n\\n function blue(int256 self) internal pure returns (string memory) {\\n return blue(vm.toString(self));\\n }\\n\\n function blue(address self) internal pure returns (string memory) {\\n return blue(vm.toString(self));\\n }\\n\\n function blue(bool self) internal pure returns (string memory) {\\n return blue(vm.toString(self));\\n }\\n\\n function blueBytes(bytes memory self) internal pure returns (string memory) {\\n return blue(vm.toString(self));\\n }\\n\\n function blueBytes32(bytes32 self) internal pure returns (string memory) {\\n return blue(vm.toString(self));\\n }\\n\\n function magenta(string memory self) internal pure returns (string memory) {\\n return styleConcat(MAGENTA, self);\\n }\\n\\n function magenta(uint256 self) internal pure returns (string memory) {\\n return magenta(vm.toString(self));\\n }\\n\\n function magenta(int256 self) internal pure returns (string memory) {\\n return magenta(vm.toString(self));\\n }\\n\\n function magenta(address self) internal pure returns (string memory) {\\n return magenta(vm.toString(self));\\n }\\n\\n function magenta(bool self) internal pure returns (string memory) {\\n return magenta(vm.toString(self));\\n }\\n\\n function magentaBytes(bytes memory self) internal pure returns (string memory) {\\n return magenta(vm.toString(self));\\n }\\n\\n function magentaBytes32(bytes32 self) internal pure returns (string memory) {\\n return magenta(vm.toString(self));\\n }\\n\\n function cyan(string memory self) internal pure returns (string memory) {\\n return styleConcat(CYAN, self);\\n }\\n\\n function cyan(uint256 self) internal pure returns (string memory) {\\n return cyan(vm.toString(self));\\n }\\n\\n function cyan(int256 self) internal pure returns (string memory) {\\n return cyan(vm.toString(self));\\n }\\n\\n function cyan(address self) internal pure returns (string memory) {\\n return cyan(vm.toString(self));\\n }\\n\\n function cyan(bool self) internal pure returns (string memory) {\\n return cyan(vm.toString(self));\\n }\\n\\n function cyanBytes(bytes memory self) internal pure returns (string memory) {\\n return cyan(vm.toString(self));\\n }\\n\\n function cyanBytes32(bytes32 self) internal pure returns (string memory) {\\n return cyan(vm.toString(self));\\n }\\n\\n function bold(string memory self) internal pure returns (string memory) {\\n return styleConcat(BOLD, self);\\n }\\n\\n function bold(uint256 self) internal pure returns (string memory) {\\n return bold(vm.toString(self));\\n }\\n\\n function bold(int256 self) internal pure returns (string memory) {\\n return bold(vm.toString(self));\\n }\\n\\n function bold(address self) internal pure returns (string memory) {\\n return bold(vm.toString(self));\\n }\\n\\n function bold(bool self) internal pure returns (string memory) {\\n return bold(vm.toString(self));\\n }\\n\\n function boldBytes(bytes memory self) internal pure returns (string memory) {\\n return bold(vm.toString(self));\\n }\\n\\n function boldBytes32(bytes32 self) internal pure returns (string memory) {\\n return bold(vm.toString(self));\\n }\\n\\n function dim(string memory self) internal pure returns (string memory) {\\n return styleConcat(DIM, self);\\n }\\n\\n function dim(uint256 self) internal pure returns (string memory) {\\n return dim(vm.toString(self));\\n }\\n\\n function dim(int256 self) internal pure returns (string memory) {\\n return dim(vm.toString(self));\\n }\\n\\n function dim(address self) internal pure returns (string memory) {\\n return dim(vm.toString(self));\\n }\\n\\n function dim(bool self) internal pure returns (string memory) {\\n return dim(vm.toString(self));\\n }\\n\\n function dimBytes(bytes memory self) internal pure returns (string memory) {\\n return dim(vm.toString(self));\\n }\\n\\n function dimBytes32(bytes32 self) internal pure returns (string memory) {\\n return dim(vm.toString(self));\\n }\\n\\n function italic(string memory self) internal pure returns (string memory) {\\n return styleConcat(ITALIC, self);\\n }\\n\\n function italic(uint256 self) internal pure returns (string memory) {\\n return italic(vm.toString(self));\\n }\\n\\n function italic(int256 self) internal pure returns (string memory) {\\n return italic(vm.toString(self));\\n }\\n\\n function italic(address self) internal pure returns (string memory) {\\n return italic(vm.toString(self));\\n }\\n\\n function italic(bool self) internal pure returns (string memory) {\\n return italic(vm.toString(self));\\n }\\n\\n function italicBytes(bytes memory self) internal pure returns (string memory) {\\n return italic(vm.toString(self));\\n }\\n\\n function italicBytes32(bytes32 self) internal pure returns (string memory) {\\n return italic(vm.toString(self));\\n }\\n\\n function underline(string memory self) internal pure returns (string memory) {\\n return styleConcat(UNDERLINE, self);\\n }\\n\\n function underline(uint256 self) internal pure returns (string memory) {\\n return underline(vm.toString(self));\\n }\\n\\n function underline(int256 self) internal pure returns (string memory) {\\n return underline(vm.toString(self));\\n }\\n\\n function underline(address self) internal pure returns (string memory) {\\n return underline(vm.toString(self));\\n }\\n\\n function underline(bool self) internal pure returns (string memory) {\\n return underline(vm.toString(self));\\n }\\n\\n function underlineBytes(bytes memory self) internal pure returns (string memory) {\\n return underline(vm.toString(self));\\n }\\n\\n function underlineBytes32(bytes32 self) internal pure returns (string memory) {\\n return underline(vm.toString(self));\\n }\\n\\n function inverse(string memory self) internal pure returns (string memory) {\\n return styleConcat(INVERSE, self);\\n }\\n\\n function inverse(uint256 self) internal pure returns (string memory) {\\n return inverse(vm.toString(self));\\n }\\n\\n function inverse(int256 self) internal pure returns (string memory) {\\n return inverse(vm.toString(self));\\n }\\n\\n function inverse(address self) internal pure returns (string memory) {\\n return inverse(vm.toString(self));\\n }\\n\\n function inverse(bool self) internal pure returns (string memory) {\\n return inverse(vm.toString(self));\\n }\\n\\n function inverseBytes(bytes memory self) internal pure returns (string memory) {\\n return inverse(vm.toString(self));\\n }\\n\\n function inverseBytes32(bytes32 self) internal pure returns (string memory) {\\n return inverse(vm.toString(self));\\n }\\n}\\n\",\"keccak256\":\"0x43e2a8a9b9c2574dabe74f11adf6f782df218f463540e3b5b563609fe108597d\",\"license\":\"MIT\"},\"lib/forge-std/src/StdUtils.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity >=0.6.2 <0.9.0;\\n\\npragma experimental ABIEncoderV2;\\n\\nimport {IMulticall3} from \\\"./interfaces/IMulticall3.sol\\\";\\nimport {VmSafe} from \\\"./Vm.sol\\\";\\n\\nabstract contract StdUtils {\\n /*//////////////////////////////////////////////////////////////////////////\\n CONSTANTS\\n //////////////////////////////////////////////////////////////////////////*/\\n\\n IMulticall3 private constant multicall = IMulticall3(0xcA11bde05977b3631167028862bE2a173976CA11);\\n VmSafe private constant vm = VmSafe(address(uint160(uint256(keccak256(\\\"hevm cheat code\\\")))));\\n address private constant CONSOLE2_ADDRESS = 0x000000000000000000636F6e736F6c652e6c6f67;\\n uint256 private constant INT256_MIN_ABS =\\n 57896044618658097711785492504343953926634992332820282019728792003956564819968;\\n uint256 private constant SECP256K1_ORDER =\\n 115792089237316195423570985008687907852837564279074904382605163141518161494337;\\n uint256 private constant UINT256_MAX =\\n 115792089237316195423570985008687907853269984665640564039457584007913129639935;\\n\\n // Used by default when deploying with create2, https://github.com/Arachnid/deterministic-deployment-proxy.\\n address private constant CREATE2_FACTORY = 0x4e59b44847b379578588920cA78FbF26c0B4956C;\\n\\n /*//////////////////////////////////////////////////////////////////////////\\n INTERNAL FUNCTIONS\\n //////////////////////////////////////////////////////////////////////////*/\\n\\n function _bound(uint256 x, uint256 min, uint256 max) internal pure virtual returns (uint256 result) {\\n require(min <= max, \\\"StdUtils bound(uint256,uint256,uint256): Max is less than min.\\\");\\n // If x is between min and max, return x directly. This is to ensure that dictionary values\\n // do not get shifted if the min is nonzero. More info: https://github.com/foundry-rs/forge-std/issues/188\\n if (x >= min && x <= max) return x;\\n\\n uint256 size = max - min + 1;\\n\\n // If the value is 0, 1, 2, 3, wrap that to min, min+1, min+2, min+3. Similarly for the UINT256_MAX side.\\n // This helps ensure coverage of the min/max values.\\n if (x <= 3 && size > x) return min + x;\\n if (x >= UINT256_MAX - 3 && size > UINT256_MAX - x) return max - (UINT256_MAX - x);\\n\\n // Otherwise, wrap x into the range [min, max], i.e. the range is inclusive.\\n if (x > max) {\\n uint256 diff = x - max;\\n uint256 rem = diff % size;\\n if (rem == 0) return max;\\n result = min + rem - 1;\\n } else if (x < min) {\\n uint256 diff = min - x;\\n uint256 rem = diff % size;\\n if (rem == 0) return min;\\n result = max - rem + 1;\\n }\\n }\\n\\n function bound(uint256 x, uint256 min, uint256 max) internal pure virtual returns (uint256 result) {\\n result = _bound(x, min, max);\\n console2_log_StdUtils(\\\"Bound result\\\", result);\\n }\\n\\n function _bound(int256 x, int256 min, int256 max) internal pure virtual returns (int256 result) {\\n require(min <= max, \\\"StdUtils bound(int256,int256,int256): Max is less than min.\\\");\\n\\n // Shifting all int256 values to uint256 to use _bound function. The range of two types are:\\n // int256 : -(2**255) ~ (2**255 - 1)\\n // uint256: 0 ~ (2**256 - 1)\\n // So, add 2**255, INT256_MIN_ABS to the integer values.\\n //\\n // If the given integer value is -2**255, we cannot use `-uint256(-x)` because of the overflow.\\n // So, use `~uint256(x) + 1` instead.\\n uint256 _x = x < 0 ? (INT256_MIN_ABS - ~uint256(x) - 1) : (uint256(x) + INT256_MIN_ABS);\\n uint256 _min = min < 0 ? (INT256_MIN_ABS - ~uint256(min) - 1) : (uint256(min) + INT256_MIN_ABS);\\n uint256 _max = max < 0 ? (INT256_MIN_ABS - ~uint256(max) - 1) : (uint256(max) + INT256_MIN_ABS);\\n\\n uint256 y = _bound(_x, _min, _max);\\n\\n // To move it back to int256 value, subtract INT256_MIN_ABS at here.\\n result = y < INT256_MIN_ABS ? int256(~(INT256_MIN_ABS - y) + 1) : int256(y - INT256_MIN_ABS);\\n }\\n\\n function bound(int256 x, int256 min, int256 max) internal pure virtual returns (int256 result) {\\n result = _bound(x, min, max);\\n console2_log_StdUtils(\\\"Bound result\\\", vm.toString(result));\\n }\\n\\n function boundPrivateKey(uint256 privateKey) internal pure virtual returns (uint256 result) {\\n result = _bound(privateKey, 1, SECP256K1_ORDER - 1);\\n }\\n\\n function bytesToUint(bytes memory b) internal pure virtual returns (uint256) {\\n require(b.length <= 32, \\\"StdUtils bytesToUint(bytes): Bytes length exceeds 32.\\\");\\n return abi.decode(abi.encodePacked(new bytes(32 - b.length), b), (uint256));\\n }\\n\\n /// @dev Compute the address a contract will be deployed at for a given deployer address and nonce\\n /// @notice adapted from Solmate implementation (https://github.com/Rari-Capital/solmate/blob/main/src/utils/LibRLP.sol)\\n function computeCreateAddress(address deployer, uint256 nonce) internal pure virtual returns (address) {\\n console2_log_StdUtils(\\\"computeCreateAddress is deprecated. Please use vm.computeCreateAddress instead.\\\");\\n return vm.computeCreateAddress(deployer, nonce);\\n }\\n\\n function computeCreate2Address(bytes32 salt, bytes32 initcodeHash, address deployer)\\n internal\\n pure\\n virtual\\n returns (address)\\n {\\n console2_log_StdUtils(\\\"computeCreate2Address is deprecated. Please use vm.computeCreate2Address instead.\\\");\\n return vm.computeCreate2Address(salt, initcodeHash, deployer);\\n }\\n\\n /// @dev returns the address of a contract created with CREATE2 using the default CREATE2 deployer\\n function computeCreate2Address(bytes32 salt, bytes32 initCodeHash) internal pure returns (address) {\\n console2_log_StdUtils(\\\"computeCreate2Address is deprecated. Please use vm.computeCreate2Address instead.\\\");\\n return vm.computeCreate2Address(salt, initCodeHash);\\n }\\n\\n /// @dev returns the hash of the init code (creation code + no args) used in CREATE2 with no constructor arguments\\n /// @param creationCode the creation code of a contract C, as returned by type(C).creationCode\\n function hashInitCode(bytes memory creationCode) internal pure returns (bytes32) {\\n return hashInitCode(creationCode, \\\"\\\");\\n }\\n\\n /// @dev returns the hash of the init code (creation code + ABI-encoded args) used in CREATE2\\n /// @param creationCode the creation code of a contract C, as returned by type(C).creationCode\\n /// @param args the ABI-encoded arguments to the constructor of C\\n function hashInitCode(bytes memory creationCode, bytes memory args) internal pure returns (bytes32) {\\n return keccak256(abi.encodePacked(creationCode, args));\\n }\\n\\n // Performs a single call with Multicall3 to query the ERC-20 token balances of the given addresses.\\n function getTokenBalances(address token, address[] memory addresses)\\n internal\\n virtual\\n returns (uint256[] memory balances)\\n {\\n uint256 tokenCodeSize;\\n assembly {\\n tokenCodeSize := extcodesize(token)\\n }\\n require(tokenCodeSize > 0, \\\"StdUtils getTokenBalances(address,address[]): Token address is not a contract.\\\");\\n\\n // ABI encode the aggregate call to Multicall3.\\n uint256 length = addresses.length;\\n IMulticall3.Call[] memory calls = new IMulticall3.Call[](length);\\n for (uint256 i = 0; i < length; ++i) {\\n // 0x70a08231 = bytes4(\\\"balanceOf(address)\\\"))\\n calls[i] = IMulticall3.Call({target: token, callData: abi.encodeWithSelector(0x70a08231, (addresses[i]))});\\n }\\n\\n // Make the aggregate call.\\n (, bytes[] memory returnData) = multicall.aggregate(calls);\\n\\n // ABI decode the return data and return the balances.\\n balances = new uint256[](length);\\n for (uint256 i = 0; i < length; ++i) {\\n balances[i] = abi.decode(returnData[i], (uint256));\\n }\\n }\\n\\n /*//////////////////////////////////////////////////////////////////////////\\n PRIVATE FUNCTIONS\\n //////////////////////////////////////////////////////////////////////////*/\\n\\n function addressFromLast20Bytes(bytes32 bytesValue) private pure returns (address) {\\n return address(uint160(uint256(bytesValue)));\\n }\\n\\n // This section is used to prevent the compilation of console, which shortens the compilation time when console is\\n // not used elsewhere. We also trick the compiler into letting us make the console log methods as `pure` to avoid\\n // any breaking changes to function signatures.\\n function _castLogPayloadViewToPure(function(bytes memory) internal view fnIn)\\n internal\\n pure\\n returns (function(bytes memory) internal pure fnOut)\\n {\\n assembly {\\n fnOut := fnIn\\n }\\n }\\n\\n function _sendLogPayload(bytes memory payload) internal pure {\\n _castLogPayloadViewToPure(_sendLogPayloadView)(payload);\\n }\\n\\n function _sendLogPayloadView(bytes memory payload) private view {\\n uint256 payloadLength = payload.length;\\n address consoleAddress = CONSOLE2_ADDRESS;\\n /// @solidity memory-safe-assembly\\n assembly {\\n let payloadStart := add(payload, 32)\\n let r := staticcall(gas(), consoleAddress, payloadStart, payloadLength, 0, 0)\\n }\\n }\\n\\n function console2_log_StdUtils(string memory p0) private pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string)\\\", p0));\\n }\\n\\n function console2_log_StdUtils(string memory p0, uint256 p1) private pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,uint256)\\\", p0, p1));\\n }\\n\\n function console2_log_StdUtils(string memory p0, string memory p1) private pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,string)\\\", p0, p1));\\n }\\n}\\n\",\"keccak256\":\"0x7274081e11c05164fd8eadde4de8305c033e58a43008dea58065f3170ccf0737\",\"license\":\"MIT\"},\"lib/forge-std/src/Vm.sol\":{\"content\":\"// Automatically @generated by scripts/vm.py. Do not modify manually.\\n\\n// SPDX-License-Identifier: MIT OR Apache-2.0\\npragma solidity >=0.6.2 <0.9.0;\\npragma experimental ABIEncoderV2;\\n\\n/// The `VmSafe` interface does not allow manipulation of the EVM state or other actions that may\\n/// result in Script simulations differing from on-chain execution. It is recommended to only use\\n/// these cheats in scripts.\\ninterface VmSafe {\\n /// A modification applied to either `msg.sender` or `tx.origin`. Returned by `readCallers`.\\n enum CallerMode {\\n // No caller modification is currently active.\\n None,\\n // A one time broadcast triggered by a `vm.broadcast()` call is currently active.\\n Broadcast,\\n // A recurrent broadcast triggered by a `vm.startBroadcast()` call is currently active.\\n RecurrentBroadcast,\\n // A one time prank triggered by a `vm.prank()` call is currently active.\\n Prank,\\n // A recurrent prank triggered by a `vm.startPrank()` call is currently active.\\n RecurrentPrank\\n }\\n\\n /// The kind of account access that occurred.\\n enum AccountAccessKind {\\n // The account was called.\\n Call,\\n // The account was called via delegatecall.\\n DelegateCall,\\n // The account was called via callcode.\\n CallCode,\\n // The account was called via staticcall.\\n StaticCall,\\n // The account was created.\\n Create,\\n // The account was selfdestructed.\\n SelfDestruct,\\n // Synthetic access indicating the current context has resumed after a previous sub-context (AccountAccess).\\n Resume,\\n // The account's balance was read.\\n Balance,\\n // The account's codesize was read.\\n Extcodesize,\\n // The account's codehash was read.\\n Extcodehash,\\n // The account's code was copied.\\n Extcodecopy\\n }\\n\\n /// Forge execution contexts.\\n enum ForgeContext {\\n // Test group execution context (test, coverage or snapshot).\\n TestGroup,\\n // `forge test` execution context.\\n Test,\\n // `forge coverage` execution context.\\n Coverage,\\n // `forge snapshot` execution context.\\n Snapshot,\\n // Script group execution context (dry run, broadcast or resume).\\n ScriptGroup,\\n // `forge script` execution context.\\n ScriptDryRun,\\n // `forge script --broadcast` execution context.\\n ScriptBroadcast,\\n // `forge script --resume` execution context.\\n ScriptResume,\\n // Unknown `forge` execution context.\\n Unknown\\n }\\n\\n /// The transaction type (`txType`) of the broadcast.\\n enum BroadcastTxType {\\n // Represents a CALL broadcast tx.\\n Call,\\n // Represents a CREATE broadcast tx.\\n Create,\\n // Represents a CREATE2 broadcast tx.\\n Create2\\n }\\n\\n /// An Ethereum log. Returned by `getRecordedLogs`.\\n struct Log {\\n // The topics of the log, including the signature, if any.\\n bytes32[] topics;\\n // The raw data of the log.\\n bytes data;\\n // The address of the log's emitter.\\n address emitter;\\n }\\n\\n /// An RPC URL and its alias. Returned by `rpcUrlStructs`.\\n struct Rpc {\\n // The alias of the RPC URL.\\n string key;\\n // The RPC URL.\\n string url;\\n }\\n\\n /// An RPC log object. Returned by `eth_getLogs`.\\n struct EthGetLogs {\\n // The address of the log's emitter.\\n address emitter;\\n // The topics of the log, including the signature, if any.\\n bytes32[] topics;\\n // The raw data of the log.\\n bytes data;\\n // The block hash.\\n bytes32 blockHash;\\n // The block number.\\n uint64 blockNumber;\\n // The transaction hash.\\n bytes32 transactionHash;\\n // The transaction index in the block.\\n uint64 transactionIndex;\\n // The log index.\\n uint256 logIndex;\\n // Whether the log was removed.\\n bool removed;\\n }\\n\\n /// A single entry in a directory listing. Returned by `readDir`.\\n struct DirEntry {\\n // The error message, if any.\\n string errorMessage;\\n // The path of the entry.\\n string path;\\n // The depth of the entry.\\n uint64 depth;\\n // Whether the entry is a directory.\\n bool isDir;\\n // Whether the entry is a symlink.\\n bool isSymlink;\\n }\\n\\n /// Metadata information about a file.\\n /// This structure is returned from the `fsMetadata` function and represents known\\n /// metadata about a file such as its permissions, size, modification\\n /// times, etc.\\n struct FsMetadata {\\n // True if this metadata is for a directory.\\n bool isDir;\\n // True if this metadata is for a symlink.\\n bool isSymlink;\\n // The size of the file, in bytes, this metadata is for.\\n uint256 length;\\n // True if this metadata is for a readonly (unwritable) file.\\n bool readOnly;\\n // The last modification time listed in this metadata.\\n uint256 modified;\\n // The last access time of this metadata.\\n uint256 accessed;\\n // The creation time listed in this metadata.\\n uint256 created;\\n }\\n\\n /// A wallet with a public and private key.\\n struct Wallet {\\n // The wallet's address.\\n address addr;\\n // The wallet's public key `X`.\\n uint256 publicKeyX;\\n // The wallet's public key `Y`.\\n uint256 publicKeyY;\\n // The wallet's private key.\\n uint256 privateKey;\\n }\\n\\n /// The result of a `tryFfi` call.\\n struct FfiResult {\\n // The exit code of the call.\\n int32 exitCode;\\n // The optionally hex-decoded `stdout` data.\\n bytes stdout;\\n // The `stderr` data.\\n bytes stderr;\\n }\\n\\n /// Information on the chain and fork.\\n struct ChainInfo {\\n // The fork identifier. Set to zero if no fork is active.\\n uint256 forkId;\\n // The chain ID of the current fork.\\n uint256 chainId;\\n }\\n\\n /// The result of a `stopAndReturnStateDiff` call.\\n struct AccountAccess {\\n // The chain and fork the access occurred.\\n ChainInfo chainInfo;\\n // The kind of account access that determines what the account is.\\n // If kind is Call, DelegateCall, StaticCall or CallCode, then the account is the callee.\\n // If kind is Create, then the account is the newly created account.\\n // If kind is SelfDestruct, then the account is the selfdestruct recipient.\\n // If kind is a Resume, then account represents a account context that has resumed.\\n AccountAccessKind kind;\\n // The account that was accessed.\\n // It's either the account created, callee or a selfdestruct recipient for CREATE, CALL or SELFDESTRUCT.\\n address account;\\n // What accessed the account.\\n address accessor;\\n // If the account was initialized or empty prior to the access.\\n // An account is considered initialized if it has code, a\\n // non-zero nonce, or a non-zero balance.\\n bool initialized;\\n // The previous balance of the accessed account.\\n uint256 oldBalance;\\n // The potential new balance of the accessed account.\\n // That is, all balance changes are recorded here, even if reverts occurred.\\n uint256 newBalance;\\n // Code of the account deployed by CREATE.\\n bytes deployedCode;\\n // Value passed along with the account access\\n uint256 value;\\n // Input data provided to the CREATE or CALL\\n bytes data;\\n // If this access reverted in either the current or parent context.\\n bool reverted;\\n // An ordered list of storage accesses made during an account access operation.\\n StorageAccess[] storageAccesses;\\n // Call depth traversed during the recording of state differences\\n uint64 depth;\\n }\\n\\n /// The storage accessed during an `AccountAccess`.\\n struct StorageAccess {\\n // The account whose storage was accessed.\\n address account;\\n // The slot that was accessed.\\n bytes32 slot;\\n // If the access was a write.\\n bool isWrite;\\n // The previous value of the slot.\\n bytes32 previousValue;\\n // The new value of the slot.\\n bytes32 newValue;\\n // If the access was reverted.\\n bool reverted;\\n }\\n\\n /// Gas used. Returned by `lastCallGas`.\\n struct Gas {\\n // The gas limit of the call.\\n uint64 gasLimit;\\n // The total gas used.\\n uint64 gasTotalUsed;\\n // DEPRECATED: The amount of gas used for memory expansion. Ref: \\n uint64 gasMemoryUsed;\\n // The amount of gas refunded.\\n int64 gasRefunded;\\n // The amount of gas remaining.\\n uint64 gasRemaining;\\n }\\n\\n /// The result of the `stopDebugTraceRecording` call\\n struct DebugStep {\\n // The stack before executing the step of the run.\\n // stack\\\\[0\\\\] represents the top of the stack.\\n // and only stack data relevant to the opcode execution is contained.\\n uint256[] stack;\\n // The memory input data before executing the step of the run.\\n // only input data relevant to the opcode execution is contained.\\n // e.g. for MLOAD, it will have memory\\\\[offset:offset+32\\\\] copied here.\\n // the offset value can be get by the stack data.\\n bytes memoryInput;\\n // The opcode that was accessed.\\n uint8 opcode;\\n // The call depth of the step.\\n uint64 depth;\\n // Whether the call end up with out of gas error.\\n bool isOutOfGas;\\n // The contract address where the opcode is running\\n address contractAddr;\\n }\\n\\n /// Represents a transaction's broadcast details.\\n struct BroadcastTxSummary {\\n // The hash of the transaction that was broadcasted\\n bytes32 txHash;\\n // Represent the type of transaction among CALL, CREATE, CREATE2\\n BroadcastTxType txType;\\n // The address of the contract that was called or created.\\n // This is address of the contract that is created if the txType is CREATE or CREATE2.\\n address contractAddress;\\n // The block number the transaction landed in.\\n uint64 blockNumber;\\n // Status of the transaction, retrieved from the transaction receipt.\\n bool success;\\n }\\n\\n /// Holds a signed EIP-7702 authorization for an authority account to delegate to an implementation.\\n struct SignedDelegation {\\n // The y-parity of the recovered secp256k1 signature (0 or 1).\\n uint8 v;\\n // First 32 bytes of the signature.\\n bytes32 r;\\n // Second 32 bytes of the signature.\\n bytes32 s;\\n // The current nonce of the authority account at signing time.\\n // Used to ensure signature can't be replayed after account nonce changes.\\n uint64 nonce;\\n // Address of the contract implementation that will be delegated to.\\n // Gets encoded into delegation code: 0xef0100 || implementation.\\n address implementation;\\n }\\n\\n /// Represents a \\\"potential\\\" revert reason from a single subsequent call when using `vm.assumeNoReverts`.\\n /// Reverts that match will result in a FOUNDRY::ASSUME rejection, whereas unmatched reverts will be surfaced\\n /// as normal.\\n struct PotentialRevert {\\n // The allowed origin of the revert opcode; address(0) allows reverts from any address\\n address reverter;\\n // When true, only matches on the beginning of the revert data, otherwise, matches on entire revert data\\n bool partialMatch;\\n // The data to use to match encountered reverts\\n bytes revertData;\\n }\\n\\n /// An EIP-2930 access list item.\\n struct AccessListItem {\\n // The address to be added in access list.\\n address target;\\n // The storage keys to be added in access list.\\n bytes32[] storageKeys;\\n }\\n\\n // ======== Crypto ========\\n\\n /// Derives a private key from the name, labels the account with that name, and returns the wallet.\\n function createWallet(string calldata walletLabel) external returns (Wallet memory wallet);\\n\\n /// Generates a wallet from the private key and returns the wallet.\\n function createWallet(uint256 privateKey) external returns (Wallet memory wallet);\\n\\n /// Generates a wallet from the private key, labels the account with that name, and returns the wallet.\\n function createWallet(uint256 privateKey, string calldata walletLabel) external returns (Wallet memory wallet);\\n\\n /// Derive a private key from a provided mnenomic string (or mnenomic file path)\\n /// at the derivation path `m/44'/60'/0'/0/{index}`.\\n function deriveKey(string calldata mnemonic, uint32 index) external pure returns (uint256 privateKey);\\n\\n /// Derive a private key from a provided mnenomic string (or mnenomic file path)\\n /// at `{derivationPath}{index}`.\\n function deriveKey(string calldata mnemonic, string calldata derivationPath, uint32 index)\\n external\\n pure\\n returns (uint256 privateKey);\\n\\n /// Derive a private key from a provided mnenomic string (or mnenomic file path) in the specified language\\n /// at the derivation path `m/44'/60'/0'/0/{index}`.\\n function deriveKey(string calldata mnemonic, uint32 index, string calldata language)\\n external\\n pure\\n returns (uint256 privateKey);\\n\\n /// Derive a private key from a provided mnenomic string (or mnenomic file path) in the specified language\\n /// at `{derivationPath}{index}`.\\n function deriveKey(string calldata mnemonic, string calldata derivationPath, uint32 index, string calldata language)\\n external\\n pure\\n returns (uint256 privateKey);\\n\\n /// Derives secp256r1 public key from the provided `privateKey`.\\n function publicKeyP256(uint256 privateKey) external pure returns (uint256 publicKeyX, uint256 publicKeyY);\\n\\n /// Adds a private key to the local forge wallet and returns the address.\\n function rememberKey(uint256 privateKey) external returns (address keyAddr);\\n\\n /// Derive a set number of wallets from a mnemonic at the derivation path `m/44'/60'/0'/0/{0..count}`.\\n /// The respective private keys are saved to the local forge wallet for later use and their addresses are returned.\\n function rememberKeys(string calldata mnemonic, string calldata derivationPath, uint32 count)\\n external\\n returns (address[] memory keyAddrs);\\n\\n /// Derive a set number of wallets from a mnemonic in the specified language at the derivation path `m/44'/60'/0'/0/{0..count}`.\\n /// The respective private keys are saved to the local forge wallet for later use and their addresses are returned.\\n function rememberKeys(\\n string calldata mnemonic,\\n string calldata derivationPath,\\n string calldata language,\\n uint32 count\\n ) external returns (address[] memory keyAddrs);\\n\\n /// Signs data with a `Wallet`.\\n /// Returns a compact signature (`r`, `vs`) as per EIP-2098, where `vs` encodes both the\\n /// signature's `s` value, and the recovery id `v` in a single bytes32.\\n /// This format reduces the signature size from 65 to 64 bytes.\\n function signCompact(Wallet calldata wallet, bytes32 digest) external returns (bytes32 r, bytes32 vs);\\n\\n /// Signs `digest` with `privateKey` using the secp256k1 curve.\\n /// Returns a compact signature (`r`, `vs`) as per EIP-2098, where `vs` encodes both the\\n /// signature's `s` value, and the recovery id `v` in a single bytes32.\\n /// This format reduces the signature size from 65 to 64 bytes.\\n function signCompact(uint256 privateKey, bytes32 digest) external pure returns (bytes32 r, bytes32 vs);\\n\\n /// Signs `digest` with signer provided to script using the secp256k1 curve.\\n /// Returns a compact signature (`r`, `vs`) as per EIP-2098, where `vs` encodes both the\\n /// signature's `s` value, and the recovery id `v` in a single bytes32.\\n /// This format reduces the signature size from 65 to 64 bytes.\\n /// If `--sender` is provided, the signer with provided address is used, otherwise,\\n /// if exactly one signer is provided to the script, that signer is used.\\n /// Raises error if signer passed through `--sender` does not match any unlocked signers or\\n /// if `--sender` is not provided and not exactly one signer is passed to the script.\\n function signCompact(bytes32 digest) external pure returns (bytes32 r, bytes32 vs);\\n\\n /// Signs `digest` with signer provided to script using the secp256k1 curve.\\n /// Returns a compact signature (`r`, `vs`) as per EIP-2098, where `vs` encodes both the\\n /// signature's `s` value, and the recovery id `v` in a single bytes32.\\n /// This format reduces the signature size from 65 to 64 bytes.\\n /// Raises error if none of the signers passed into the script have provided address.\\n function signCompact(address signer, bytes32 digest) external pure returns (bytes32 r, bytes32 vs);\\n\\n /// Signs `digest` with `privateKey` using the secp256r1 curve.\\n function signP256(uint256 privateKey, bytes32 digest) external pure returns (bytes32 r, bytes32 s);\\n\\n /// Signs data with a `Wallet`.\\n function sign(Wallet calldata wallet, bytes32 digest) external returns (uint8 v, bytes32 r, bytes32 s);\\n\\n /// Signs `digest` with `privateKey` using the secp256k1 curve.\\n function sign(uint256 privateKey, bytes32 digest) external pure returns (uint8 v, bytes32 r, bytes32 s);\\n\\n /// Signs `digest` with signer provided to script using the secp256k1 curve.\\n /// If `--sender` is provided, the signer with provided address is used, otherwise,\\n /// if exactly one signer is provided to the script, that signer is used.\\n /// Raises error if signer passed through `--sender` does not match any unlocked signers or\\n /// if `--sender` is not provided and not exactly one signer is passed to the script.\\n function sign(bytes32 digest) external pure returns (uint8 v, bytes32 r, bytes32 s);\\n\\n /// Signs `digest` with signer provided to script using the secp256k1 curve.\\n /// Raises error if none of the signers passed into the script have provided address.\\n function sign(address signer, bytes32 digest) external pure returns (uint8 v, bytes32 r, bytes32 s);\\n\\n // ======== Environment ========\\n\\n /// Gets the environment variable `name` and parses it as `address`.\\n /// Reverts if the variable was not found or could not be parsed.\\n function envAddress(string calldata name) external view returns (address value);\\n\\n /// Gets the environment variable `name` and parses it as an array of `address`, delimited by `delim`.\\n /// Reverts if the variable was not found or could not be parsed.\\n function envAddress(string calldata name, string calldata delim) external view returns (address[] memory value);\\n\\n /// Gets the environment variable `name` and parses it as `bool`.\\n /// Reverts if the variable was not found or could not be parsed.\\n function envBool(string calldata name) external view returns (bool value);\\n\\n /// Gets the environment variable `name` and parses it as an array of `bool`, delimited by `delim`.\\n /// Reverts if the variable was not found or could not be parsed.\\n function envBool(string calldata name, string calldata delim) external view returns (bool[] memory value);\\n\\n /// Gets the environment variable `name` and parses it as `bytes32`.\\n /// Reverts if the variable was not found or could not be parsed.\\n function envBytes32(string calldata name) external view returns (bytes32 value);\\n\\n /// Gets the environment variable `name` and parses it as an array of `bytes32`, delimited by `delim`.\\n /// Reverts if the variable was not found or could not be parsed.\\n function envBytes32(string calldata name, string calldata delim) external view returns (bytes32[] memory value);\\n\\n /// Gets the environment variable `name` and parses it as `bytes`.\\n /// Reverts if the variable was not found or could not be parsed.\\n function envBytes(string calldata name) external view returns (bytes memory value);\\n\\n /// Gets the environment variable `name` and parses it as an array of `bytes`, delimited by `delim`.\\n /// Reverts if the variable was not found or could not be parsed.\\n function envBytes(string calldata name, string calldata delim) external view returns (bytes[] memory value);\\n\\n /// Gets the environment variable `name` and returns true if it exists, else returns false.\\n function envExists(string calldata name) external view returns (bool result);\\n\\n /// Gets the environment variable `name` and parses it as `int256`.\\n /// Reverts if the variable was not found or could not be parsed.\\n function envInt(string calldata name) external view returns (int256 value);\\n\\n /// Gets the environment variable `name` and parses it as an array of `int256`, delimited by `delim`.\\n /// Reverts if the variable was not found or could not be parsed.\\n function envInt(string calldata name, string calldata delim) external view returns (int256[] memory value);\\n\\n /// Gets the environment variable `name` and parses it as `bool`.\\n /// Reverts if the variable could not be parsed.\\n /// Returns `defaultValue` if the variable was not found.\\n function envOr(string calldata name, bool defaultValue) external view returns (bool value);\\n\\n /// Gets the environment variable `name` and parses it as `uint256`.\\n /// Reverts if the variable could not be parsed.\\n /// Returns `defaultValue` if the variable was not found.\\n function envOr(string calldata name, uint256 defaultValue) external view returns (uint256 value);\\n\\n /// Gets the environment variable `name` and parses it as an array of `address`, delimited by `delim`.\\n /// Reverts if the variable could not be parsed.\\n /// Returns `defaultValue` if the variable was not found.\\n function envOr(string calldata name, string calldata delim, address[] calldata defaultValue)\\n external\\n view\\n returns (address[] memory value);\\n\\n /// Gets the environment variable `name` and parses it as an array of `bytes32`, delimited by `delim`.\\n /// Reverts if the variable could not be parsed.\\n /// Returns `defaultValue` if the variable was not found.\\n function envOr(string calldata name, string calldata delim, bytes32[] calldata defaultValue)\\n external\\n view\\n returns (bytes32[] memory value);\\n\\n /// Gets the environment variable `name` and parses it as an array of `string`, delimited by `delim`.\\n /// Reverts if the variable could not be parsed.\\n /// Returns `defaultValue` if the variable was not found.\\n function envOr(string calldata name, string calldata delim, string[] calldata defaultValue)\\n external\\n view\\n returns (string[] memory value);\\n\\n /// Gets the environment variable `name` and parses it as an array of `bytes`, delimited by `delim`.\\n /// Reverts if the variable could not be parsed.\\n /// Returns `defaultValue` if the variable was not found.\\n function envOr(string calldata name, string calldata delim, bytes[] calldata defaultValue)\\n external\\n view\\n returns (bytes[] memory value);\\n\\n /// Gets the environment variable `name` and parses it as `int256`.\\n /// Reverts if the variable could not be parsed.\\n /// Returns `defaultValue` if the variable was not found.\\n function envOr(string calldata name, int256 defaultValue) external view returns (int256 value);\\n\\n /// Gets the environment variable `name` and parses it as `address`.\\n /// Reverts if the variable could not be parsed.\\n /// Returns `defaultValue` if the variable was not found.\\n function envOr(string calldata name, address defaultValue) external view returns (address value);\\n\\n /// Gets the environment variable `name` and parses it as `bytes32`.\\n /// Reverts if the variable could not be parsed.\\n /// Returns `defaultValue` if the variable was not found.\\n function envOr(string calldata name, bytes32 defaultValue) external view returns (bytes32 value);\\n\\n /// Gets the environment variable `name` and parses it as `string`.\\n /// Reverts if the variable could not be parsed.\\n /// Returns `defaultValue` if the variable was not found.\\n function envOr(string calldata name, string calldata defaultValue) external view returns (string memory value);\\n\\n /// Gets the environment variable `name` and parses it as `bytes`.\\n /// Reverts if the variable could not be parsed.\\n /// Returns `defaultValue` if the variable was not found.\\n function envOr(string calldata name, bytes calldata defaultValue) external view returns (bytes memory value);\\n\\n /// Gets the environment variable `name` and parses it as an array of `bool`, delimited by `delim`.\\n /// Reverts if the variable could not be parsed.\\n /// Returns `defaultValue` if the variable was not found.\\n function envOr(string calldata name, string calldata delim, bool[] calldata defaultValue)\\n external\\n view\\n returns (bool[] memory value);\\n\\n /// Gets the environment variable `name` and parses it as an array of `uint256`, delimited by `delim`.\\n /// Reverts if the variable could not be parsed.\\n /// Returns `defaultValue` if the variable was not found.\\n function envOr(string calldata name, string calldata delim, uint256[] calldata defaultValue)\\n external\\n view\\n returns (uint256[] memory value);\\n\\n /// Gets the environment variable `name` and parses it as an array of `int256`, delimited by `delim`.\\n /// Reverts if the variable could not be parsed.\\n /// Returns `defaultValue` if the variable was not found.\\n function envOr(string calldata name, string calldata delim, int256[] calldata defaultValue)\\n external\\n view\\n returns (int256[] memory value);\\n\\n /// Gets the environment variable `name` and parses it as `string`.\\n /// Reverts if the variable was not found or could not be parsed.\\n function envString(string calldata name) external view returns (string memory value);\\n\\n /// Gets the environment variable `name` and parses it as an array of `string`, delimited by `delim`.\\n /// Reverts if the variable was not found or could not be parsed.\\n function envString(string calldata name, string calldata delim) external view returns (string[] memory value);\\n\\n /// Gets the environment variable `name` and parses it as `uint256`.\\n /// Reverts if the variable was not found or could not be parsed.\\n function envUint(string calldata name) external view returns (uint256 value);\\n\\n /// Gets the environment variable `name` and parses it as an array of `uint256`, delimited by `delim`.\\n /// Reverts if the variable was not found or could not be parsed.\\n function envUint(string calldata name, string calldata delim) external view returns (uint256[] memory value);\\n\\n /// Returns true if `forge` command was executed in given context.\\n function isContext(ForgeContext context) external view returns (bool result);\\n\\n /// Sets environment variables.\\n function setEnv(string calldata name, string calldata value) external;\\n\\n // ======== EVM ========\\n\\n /// Gets all accessed reads and write slot from a `vm.record` session, for a given address.\\n function accesses(address target) external returns (bytes32[] memory readSlots, bytes32[] memory writeSlots);\\n\\n /// Gets the address for a given private key.\\n function addr(uint256 privateKey) external pure returns (address keyAddr);\\n\\n /// Gets all the logs according to specified filter.\\n function eth_getLogs(uint256 fromBlock, uint256 toBlock, address target, bytes32[] calldata topics)\\n external\\n returns (EthGetLogs[] memory logs);\\n\\n /// Gets the current `block.blobbasefee`.\\n /// You should use this instead of `block.blobbasefee` if you use `vm.blobBaseFee`, as `block.blobbasefee` is assumed to be constant across a transaction,\\n /// and as a result will get optimized out by the compiler.\\n /// See https://github.com/foundry-rs/foundry/issues/6180\\n function getBlobBaseFee() external view returns (uint256 blobBaseFee);\\n\\n /// Gets the current `block.number`.\\n /// You should use this instead of `block.number` if you use `vm.roll`, as `block.number` is assumed to be constant across a transaction,\\n /// and as a result will get optimized out by the compiler.\\n /// See https://github.com/foundry-rs/foundry/issues/6180\\n function getBlockNumber() external view returns (uint256 height);\\n\\n /// Gets the current `block.timestamp`.\\n /// You should use this instead of `block.timestamp` if you use `vm.warp`, as `block.timestamp` is assumed to be constant across a transaction,\\n /// and as a result will get optimized out by the compiler.\\n /// See https://github.com/foundry-rs/foundry/issues/6180\\n function getBlockTimestamp() external view returns (uint256 timestamp);\\n\\n /// Gets the map key and parent of a mapping at a given slot, for a given address.\\n function getMappingKeyAndParentOf(address target, bytes32 elementSlot)\\n external\\n returns (bool found, bytes32 key, bytes32 parent);\\n\\n /// Gets the number of elements in the mapping at the given slot, for a given address.\\n function getMappingLength(address target, bytes32 mappingSlot) external returns (uint256 length);\\n\\n /// Gets the elements at index idx of the mapping at the given slot, for a given address. The\\n /// index must be less than the length of the mapping (i.e. the number of keys in the mapping).\\n function getMappingSlotAt(address target, bytes32 mappingSlot, uint256 idx) external returns (bytes32 value);\\n\\n /// Gets the nonce of an account.\\n function getNonce(address account) external view returns (uint64 nonce);\\n\\n /// Get the nonce of a `Wallet`.\\n function getNonce(Wallet calldata wallet) external returns (uint64 nonce);\\n\\n /// Gets all the recorded logs.\\n function getRecordedLogs() external returns (Log[] memory logs);\\n\\n /// Returns state diffs from current `vm.startStateDiffRecording` session.\\n function getStateDiff() external view returns (string memory diff);\\n\\n /// Returns state diffs from current `vm.startStateDiffRecording` session, in json format.\\n function getStateDiffJson() external view returns (string memory diff);\\n\\n /// Gets the gas used in the last call from the callee perspective.\\n function lastCallGas() external view returns (Gas memory gas);\\n\\n /// Loads a storage slot from an address.\\n function load(address target, bytes32 slot) external view returns (bytes32 data);\\n\\n /// Pauses gas metering (i.e. gas usage is not counted). Noop if already paused.\\n function pauseGasMetering() external;\\n\\n /// Records all storage reads and writes.\\n function record() external;\\n\\n /// Record all the transaction logs.\\n function recordLogs() external;\\n\\n /// Reset gas metering (i.e. gas usage is set to gas limit).\\n function resetGasMetering() external;\\n\\n /// Resumes gas metering (i.e. gas usage is counted again). Noop if already on.\\n function resumeGasMetering() external;\\n\\n /// Performs an Ethereum JSON-RPC request to the current fork URL.\\n function rpc(string calldata method, string calldata params) external returns (bytes memory data);\\n\\n /// Performs an Ethereum JSON-RPC request to the given endpoint.\\n function rpc(string calldata urlOrAlias, string calldata method, string calldata params)\\n external\\n returns (bytes memory data);\\n\\n /// Records the debug trace during the run.\\n function startDebugTraceRecording() external;\\n\\n /// Starts recording all map SSTOREs for later retrieval.\\n function startMappingRecording() external;\\n\\n /// Record all account accesses as part of CREATE, CALL or SELFDESTRUCT opcodes in order,\\n /// along with the context of the calls\\n function startStateDiffRecording() external;\\n\\n /// Stop debug trace recording and returns the recorded debug trace.\\n function stopAndReturnDebugTraceRecording() external returns (DebugStep[] memory step);\\n\\n /// Returns an ordered array of all account accesses from a `vm.startStateDiffRecording` session.\\n function stopAndReturnStateDiff() external returns (AccountAccess[] memory accountAccesses);\\n\\n /// Stops recording all map SSTOREs for later retrieval and clears the recorded data.\\n function stopMappingRecording() external;\\n\\n // ======== Filesystem ========\\n\\n /// Closes file for reading, resetting the offset and allowing to read it from beginning with readLine.\\n /// `path` is relative to the project root.\\n function closeFile(string calldata path) external;\\n\\n /// Copies the contents of one file to another. This function will **overwrite** the contents of `to`.\\n /// On success, the total number of bytes copied is returned and it is equal to the length of the `to` file as reported by `metadata`.\\n /// Both `from` and `to` are relative to the project root.\\n function copyFile(string calldata from, string calldata to) external returns (uint64 copied);\\n\\n /// Creates a new, empty directory at the provided path.\\n /// This cheatcode will revert in the following situations, but is not limited to just these cases:\\n /// - User lacks permissions to modify `path`.\\n /// - A parent of the given path doesn't exist and `recursive` is false.\\n /// - `path` already exists and `recursive` is false.\\n /// `path` is relative to the project root.\\n function createDir(string calldata path, bool recursive) external;\\n\\n /// Deploys a contract from an artifact file. Takes in the relative path to the json file or the path to the\\n /// artifact in the form of :: where and parts are optional.\\n function deployCode(string calldata artifactPath) external returns (address deployedAddress);\\n\\n /// Deploys a contract from an artifact file. Takes in the relative path to the json file or the path to the\\n /// artifact in the form of :: where and parts are optional.\\n /// Additionally accepts abi-encoded constructor arguments.\\n function deployCode(string calldata artifactPath, bytes calldata constructorArgs)\\n external\\n returns (address deployedAddress);\\n\\n /// Returns true if the given path points to an existing entity, else returns false.\\n function exists(string calldata path) external view returns (bool result);\\n\\n /// Performs a foreign function call via the terminal.\\n function ffi(string[] calldata commandInput) external returns (bytes memory result);\\n\\n /// Given a path, query the file system to get information about a file, directory, etc.\\n function fsMetadata(string calldata path) external view returns (FsMetadata memory metadata);\\n\\n /// Gets the artifact path from code (aka. creation code).\\n function getArtifactPathByCode(bytes calldata code) external view returns (string memory path);\\n\\n /// Gets the artifact path from deployed code (aka. runtime code).\\n function getArtifactPathByDeployedCode(bytes calldata deployedCode) external view returns (string memory path);\\n\\n /// Returns the most recent broadcast for the given contract on `chainId` matching `txType`.\\n /// For example:\\n /// The most recent deployment can be fetched by passing `txType` as `CREATE` or `CREATE2`.\\n /// The most recent call can be fetched by passing `txType` as `CALL`.\\n function getBroadcast(string calldata contractName, uint64 chainId, BroadcastTxType txType)\\n external\\n view\\n returns (BroadcastTxSummary memory);\\n\\n /// Returns all broadcasts for the given contract on `chainId` with the specified `txType`.\\n /// Sorted such that the most recent broadcast is the first element, and the oldest is the last. i.e descending order of BroadcastTxSummary.blockNumber.\\n function getBroadcasts(string calldata contractName, uint64 chainId, BroadcastTxType txType)\\n external\\n view\\n returns (BroadcastTxSummary[] memory);\\n\\n /// Returns all broadcasts for the given contract on `chainId`.\\n /// Sorted such that the most recent broadcast is the first element, and the oldest is the last. i.e descending order of BroadcastTxSummary.blockNumber.\\n function getBroadcasts(string calldata contractName, uint64 chainId)\\n external\\n view\\n returns (BroadcastTxSummary[] memory);\\n\\n /// Gets the creation bytecode from an artifact file. Takes in the relative path to the json file or the path to the\\n /// artifact in the form of :: where and parts are optional.\\n function getCode(string calldata artifactPath) external view returns (bytes memory creationBytecode);\\n\\n /// Gets the deployed bytecode from an artifact file. Takes in the relative path to the json file or the path to the\\n /// artifact in the form of :: where and parts are optional.\\n function getDeployedCode(string calldata artifactPath) external view returns (bytes memory runtimeBytecode);\\n\\n /// Returns the most recent deployment for the current `chainId`.\\n function getDeployment(string calldata contractName) external view returns (address deployedAddress);\\n\\n /// Returns the most recent deployment for the given contract on `chainId`\\n function getDeployment(string calldata contractName, uint64 chainId)\\n external\\n view\\n returns (address deployedAddress);\\n\\n /// Returns all deployments for the given contract on `chainId`\\n /// Sorted in descending order of deployment time i.e descending order of BroadcastTxSummary.blockNumber.\\n /// The most recent deployment is the first element, and the oldest is the last.\\n function getDeployments(string calldata contractName, uint64 chainId)\\n external\\n view\\n returns (address[] memory deployedAddresses);\\n\\n /// Returns true if the path exists on disk and is pointing at a directory, else returns false.\\n function isDir(string calldata path) external view returns (bool result);\\n\\n /// Returns true if the path exists on disk and is pointing at a regular file, else returns false.\\n function isFile(string calldata path) external view returns (bool result);\\n\\n /// Get the path of the current project root.\\n function projectRoot() external view returns (string memory path);\\n\\n /// Prompts the user for a string value in the terminal.\\n function prompt(string calldata promptText) external returns (string memory input);\\n\\n /// Prompts the user for an address in the terminal.\\n function promptAddress(string calldata promptText) external returns (address);\\n\\n /// Prompts the user for a hidden string value in the terminal.\\n function promptSecret(string calldata promptText) external returns (string memory input);\\n\\n /// Prompts the user for hidden uint256 in the terminal (usually pk).\\n function promptSecretUint(string calldata promptText) external returns (uint256);\\n\\n /// Prompts the user for uint256 in the terminal.\\n function promptUint(string calldata promptText) external returns (uint256);\\n\\n /// Reads the directory at the given path recursively, up to `maxDepth`.\\n /// `maxDepth` defaults to 1, meaning only the direct children of the given directory will be returned.\\n /// Follows symbolic links if `followLinks` is true.\\n function readDir(string calldata path) external view returns (DirEntry[] memory entries);\\n\\n /// See `readDir(string)`.\\n function readDir(string calldata path, uint64 maxDepth) external view returns (DirEntry[] memory entries);\\n\\n /// See `readDir(string)`.\\n function readDir(string calldata path, uint64 maxDepth, bool followLinks)\\n external\\n view\\n returns (DirEntry[] memory entries);\\n\\n /// Reads the entire content of file to string. `path` is relative to the project root.\\n function readFile(string calldata path) external view returns (string memory data);\\n\\n /// Reads the entire content of file as binary. `path` is relative to the project root.\\n function readFileBinary(string calldata path) external view returns (bytes memory data);\\n\\n /// Reads next line of file to string.\\n function readLine(string calldata path) external view returns (string memory line);\\n\\n /// Reads a symbolic link, returning the path that the link points to.\\n /// This cheatcode will revert in the following situations, but is not limited to just these cases:\\n /// - `path` is not a symbolic link.\\n /// - `path` does not exist.\\n function readLink(string calldata linkPath) external view returns (string memory targetPath);\\n\\n /// Removes a directory at the provided path.\\n /// This cheatcode will revert in the following situations, but is not limited to just these cases:\\n /// - `path` doesn't exist.\\n /// - `path` isn't a directory.\\n /// - User lacks permissions to modify `path`.\\n /// - The directory is not empty and `recursive` is false.\\n /// `path` is relative to the project root.\\n function removeDir(string calldata path, bool recursive) external;\\n\\n /// Removes a file from the filesystem.\\n /// This cheatcode will revert in the following situations, but is not limited to just these cases:\\n /// - `path` points to a directory.\\n /// - The file doesn't exist.\\n /// - The user lacks permissions to remove the file.\\n /// `path` is relative to the project root.\\n function removeFile(string calldata path) external;\\n\\n /// Performs a foreign function call via terminal and returns the exit code, stdout, and stderr.\\n function tryFfi(string[] calldata commandInput) external returns (FfiResult memory result);\\n\\n /// Returns the time since unix epoch in milliseconds.\\n function unixTime() external view returns (uint256 milliseconds);\\n\\n /// Writes data to file, creating a file if it does not exist, and entirely replacing its contents if it does.\\n /// `path` is relative to the project root.\\n function writeFile(string calldata path, string calldata data) external;\\n\\n /// Writes binary data to a file, creating a file if it does not exist, and entirely replacing its contents if it does.\\n /// `path` is relative to the project root.\\n function writeFileBinary(string calldata path, bytes calldata data) external;\\n\\n /// Writes line to file, creating a file if it does not exist.\\n /// `path` is relative to the project root.\\n function writeLine(string calldata path, string calldata data) external;\\n\\n // ======== JSON ========\\n\\n /// Checks if `key` exists in a JSON object.\\n function keyExistsJson(string calldata json, string calldata key) external view returns (bool);\\n\\n /// Parses a string of JSON data at `key` and coerces it to `address`.\\n function parseJsonAddress(string calldata json, string calldata key) external pure returns (address);\\n\\n /// Parses a string of JSON data at `key` and coerces it to `address[]`.\\n function parseJsonAddressArray(string calldata json, string calldata key)\\n external\\n pure\\n returns (address[] memory);\\n\\n /// Parses a string of JSON data at `key` and coerces it to `bool`.\\n function parseJsonBool(string calldata json, string calldata key) external pure returns (bool);\\n\\n /// Parses a string of JSON data at `key` and coerces it to `bool[]`.\\n function parseJsonBoolArray(string calldata json, string calldata key) external pure returns (bool[] memory);\\n\\n /// Parses a string of JSON data at `key` and coerces it to `bytes`.\\n function parseJsonBytes(string calldata json, string calldata key) external pure returns (bytes memory);\\n\\n /// Parses a string of JSON data at `key` and coerces it to `bytes32`.\\n function parseJsonBytes32(string calldata json, string calldata key) external pure returns (bytes32);\\n\\n /// Parses a string of JSON data at `key` and coerces it to `bytes32[]`.\\n function parseJsonBytes32Array(string calldata json, string calldata key)\\n external\\n pure\\n returns (bytes32[] memory);\\n\\n /// Parses a string of JSON data at `key` and coerces it to `bytes[]`.\\n function parseJsonBytesArray(string calldata json, string calldata key) external pure returns (bytes[] memory);\\n\\n /// Parses a string of JSON data at `key` and coerces it to `int256`.\\n function parseJsonInt(string calldata json, string calldata key) external pure returns (int256);\\n\\n /// Parses a string of JSON data at `key` and coerces it to `int256[]`.\\n function parseJsonIntArray(string calldata json, string calldata key) external pure returns (int256[] memory);\\n\\n /// Returns an array of all the keys in a JSON object.\\n function parseJsonKeys(string calldata json, string calldata key) external pure returns (string[] memory keys);\\n\\n /// Parses a string of JSON data at `key` and coerces it to `string`.\\n function parseJsonString(string calldata json, string calldata key) external pure returns (string memory);\\n\\n /// Parses a string of JSON data at `key` and coerces it to `string[]`.\\n function parseJsonStringArray(string calldata json, string calldata key) external pure returns (string[] memory);\\n\\n /// Parses a string of JSON data at `key` and coerces it to type array corresponding to `typeDescription`.\\n function parseJsonTypeArray(string calldata json, string calldata key, string calldata typeDescription)\\n external\\n pure\\n returns (bytes memory);\\n\\n /// Parses a string of JSON data and coerces it to type corresponding to `typeDescription`.\\n function parseJsonType(string calldata json, string calldata typeDescription)\\n external\\n pure\\n returns (bytes memory);\\n\\n /// Parses a string of JSON data at `key` and coerces it to type corresponding to `typeDescription`.\\n function parseJsonType(string calldata json, string calldata key, string calldata typeDescription)\\n external\\n pure\\n returns (bytes memory);\\n\\n /// Parses a string of JSON data at `key` and coerces it to `uint256`.\\n function parseJsonUint(string calldata json, string calldata key) external pure returns (uint256);\\n\\n /// Parses a string of JSON data at `key` and coerces it to `uint256[]`.\\n function parseJsonUintArray(string calldata json, string calldata key) external pure returns (uint256[] memory);\\n\\n /// ABI-encodes a JSON object.\\n function parseJson(string calldata json) external pure returns (bytes memory abiEncodedData);\\n\\n /// ABI-encodes a JSON object at `key`.\\n function parseJson(string calldata json, string calldata key) external pure returns (bytes memory abiEncodedData);\\n\\n /// See `serializeJson`.\\n function serializeAddress(string calldata objectKey, string calldata valueKey, address value)\\n external\\n returns (string memory json);\\n\\n /// See `serializeJson`.\\n function serializeAddress(string calldata objectKey, string calldata valueKey, address[] calldata values)\\n external\\n returns (string memory json);\\n\\n /// See `serializeJson`.\\n function serializeBool(string calldata objectKey, string calldata valueKey, bool value)\\n external\\n returns (string memory json);\\n\\n /// See `serializeJson`.\\n function serializeBool(string calldata objectKey, string calldata valueKey, bool[] calldata values)\\n external\\n returns (string memory json);\\n\\n /// See `serializeJson`.\\n function serializeBytes32(string calldata objectKey, string calldata valueKey, bytes32 value)\\n external\\n returns (string memory json);\\n\\n /// See `serializeJson`.\\n function serializeBytes32(string calldata objectKey, string calldata valueKey, bytes32[] calldata values)\\n external\\n returns (string memory json);\\n\\n /// See `serializeJson`.\\n function serializeBytes(string calldata objectKey, string calldata valueKey, bytes calldata value)\\n external\\n returns (string memory json);\\n\\n /// See `serializeJson`.\\n function serializeBytes(string calldata objectKey, string calldata valueKey, bytes[] calldata values)\\n external\\n returns (string memory json);\\n\\n /// See `serializeJson`.\\n function serializeInt(string calldata objectKey, string calldata valueKey, int256 value)\\n external\\n returns (string memory json);\\n\\n /// See `serializeJson`.\\n function serializeInt(string calldata objectKey, string calldata valueKey, int256[] calldata values)\\n external\\n returns (string memory json);\\n\\n /// Serializes a key and value to a JSON object stored in-memory that can be later written to a file.\\n /// Returns the stringified version of the specific JSON file up to that moment.\\n function serializeJson(string calldata objectKey, string calldata value) external returns (string memory json);\\n\\n /// See `serializeJson`.\\n function serializeJsonType(string calldata typeDescription, bytes calldata value)\\n external\\n pure\\n returns (string memory json);\\n\\n /// See `serializeJson`.\\n function serializeJsonType(\\n string calldata objectKey,\\n string calldata valueKey,\\n string calldata typeDescription,\\n bytes calldata value\\n ) external returns (string memory json);\\n\\n /// See `serializeJson`.\\n function serializeString(string calldata objectKey, string calldata valueKey, string calldata value)\\n external\\n returns (string memory json);\\n\\n /// See `serializeJson`.\\n function serializeString(string calldata objectKey, string calldata valueKey, string[] calldata values)\\n external\\n returns (string memory json);\\n\\n /// See `serializeJson`.\\n function serializeUintToHex(string calldata objectKey, string calldata valueKey, uint256 value)\\n external\\n returns (string memory json);\\n\\n /// See `serializeJson`.\\n function serializeUint(string calldata objectKey, string calldata valueKey, uint256 value)\\n external\\n returns (string memory json);\\n\\n /// See `serializeJson`.\\n function serializeUint(string calldata objectKey, string calldata valueKey, uint256[] calldata values)\\n external\\n returns (string memory json);\\n\\n /// Write a serialized JSON object to a file. If the file exists, it will be overwritten.\\n function writeJson(string calldata json, string calldata path) external;\\n\\n /// Write a serialized JSON object to an **existing** JSON file, replacing a value with key = \\n /// This is useful to replace a specific value of a JSON file, without having to parse the entire thing.\\n function writeJson(string calldata json, string calldata path, string calldata valueKey) external;\\n\\n /// Checks if `key` exists in a JSON object\\n /// `keyExists` is being deprecated in favor of `keyExistsJson`. It will be removed in future versions.\\n function keyExists(string calldata json, string calldata key) external view returns (bool);\\n\\n // ======== Scripting ========\\n\\n /// Designate the next call as an EIP-7702 transaction\\n function attachDelegation(SignedDelegation calldata signedDelegation) external;\\n\\n /// Takes a signed transaction and broadcasts it to the network.\\n function broadcastRawTransaction(bytes calldata data) external;\\n\\n /// Has the next call (at this call depth only) create transactions that can later be signed and sent onchain.\\n /// Broadcasting address is determined by checking the following in order:\\n /// 1. If `--sender` argument was provided, that address is used.\\n /// 2. If exactly one signer (e.g. private key, hw wallet, keystore) is set when `forge broadcast` is invoked, that signer is used.\\n /// 3. Otherwise, default foundry sender (1804c8AB1F12E6bbf3894d4083f33e07309d1f38) is used.\\n function broadcast() external;\\n\\n /// Has the next call (at this call depth only) create a transaction with the address provided\\n /// as the sender that can later be signed and sent onchain.\\n function broadcast(address signer) external;\\n\\n /// Has the next call (at this call depth only) create a transaction with the private key\\n /// provided as the sender that can later be signed and sent onchain.\\n function broadcast(uint256 privateKey) external;\\n\\n /// Returns addresses of available unlocked wallets in the script environment.\\n function getWallets() external returns (address[] memory wallets);\\n\\n /// Sign an EIP-7702 authorization and designate the next call as an EIP-7702 transaction\\n function signAndAttachDelegation(address implementation, uint256 privateKey)\\n external\\n returns (SignedDelegation memory signedDelegation);\\n\\n /// Sign an EIP-7702 authorization for delegation\\n function signDelegation(address implementation, uint256 privateKey)\\n external\\n returns (SignedDelegation memory signedDelegation);\\n\\n /// Has all subsequent calls (at this call depth only) create transactions that can later be signed and sent onchain.\\n /// Broadcasting address is determined by checking the following in order:\\n /// 1. If `--sender` argument was provided, that address is used.\\n /// 2. If exactly one signer (e.g. private key, hw wallet, keystore) is set when `forge broadcast` is invoked, that signer is used.\\n /// 3. Otherwise, default foundry sender (1804c8AB1F12E6bbf3894d4083f33e07309d1f38) is used.\\n function startBroadcast() external;\\n\\n /// Has all subsequent calls (at this call depth only) create transactions with the address\\n /// provided that can later be signed and sent onchain.\\n function startBroadcast(address signer) external;\\n\\n /// Has all subsequent calls (at this call depth only) create transactions with the private key\\n /// provided that can later be signed and sent onchain.\\n function startBroadcast(uint256 privateKey) external;\\n\\n /// Stops collecting onchain transactions.\\n function stopBroadcast() external;\\n\\n // ======== String ========\\n\\n /// Returns true if `search` is found in `subject`, false otherwise.\\n function contains(string calldata subject, string calldata search) external returns (bool result);\\n\\n /// Returns the index of the first occurrence of a `key` in an `input` string.\\n /// Returns `NOT_FOUND` (i.e. `type(uint256).max`) if the `key` is not found.\\n /// Returns 0 in case of an empty `key`.\\n function indexOf(string calldata input, string calldata key) external pure returns (uint256);\\n\\n /// Parses the given `string` into an `address`.\\n function parseAddress(string calldata stringifiedValue) external pure returns (address parsedValue);\\n\\n /// Parses the given `string` into a `bool`.\\n function parseBool(string calldata stringifiedValue) external pure returns (bool parsedValue);\\n\\n /// Parses the given `string` into `bytes`.\\n function parseBytes(string calldata stringifiedValue) external pure returns (bytes memory parsedValue);\\n\\n /// Parses the given `string` into a `bytes32`.\\n function parseBytes32(string calldata stringifiedValue) external pure returns (bytes32 parsedValue);\\n\\n /// Parses the given `string` into a `int256`.\\n function parseInt(string calldata stringifiedValue) external pure returns (int256 parsedValue);\\n\\n /// Parses the given `string` into a `uint256`.\\n function parseUint(string calldata stringifiedValue) external pure returns (uint256 parsedValue);\\n\\n /// Replaces occurrences of `from` in the given `string` with `to`.\\n function replace(string calldata input, string calldata from, string calldata to)\\n external\\n pure\\n returns (string memory output);\\n\\n /// Splits the given `string` into an array of strings divided by the `delimiter`.\\n function split(string calldata input, string calldata delimiter) external pure returns (string[] memory outputs);\\n\\n /// Converts the given `string` value to Lowercase.\\n function toLowercase(string calldata input) external pure returns (string memory output);\\n\\n /// Converts the given value to a `string`.\\n function toString(address value) external pure returns (string memory stringifiedValue);\\n\\n /// Converts the given value to a `string`.\\n function toString(bytes calldata value) external pure returns (string memory stringifiedValue);\\n\\n /// Converts the given value to a `string`.\\n function toString(bytes32 value) external pure returns (string memory stringifiedValue);\\n\\n /// Converts the given value to a `string`.\\n function toString(bool value) external pure returns (string memory stringifiedValue);\\n\\n /// Converts the given value to a `string`.\\n function toString(uint256 value) external pure returns (string memory stringifiedValue);\\n\\n /// Converts the given value to a `string`.\\n function toString(int256 value) external pure returns (string memory stringifiedValue);\\n\\n /// Converts the given `string` value to Uppercase.\\n function toUppercase(string calldata input) external pure returns (string memory output);\\n\\n /// Trims leading and trailing whitespace from the given `string` value.\\n function trim(string calldata input) external pure returns (string memory output);\\n\\n // ======== Testing ========\\n\\n /// Compares two `uint256` values. Expects difference to be less than or equal to `maxDelta`.\\n /// Formats values with decimals in failure message.\\n function assertApproxEqAbsDecimal(uint256 left, uint256 right, uint256 maxDelta, uint256 decimals) external pure;\\n\\n /// Compares two `uint256` values. Expects difference to be less than or equal to `maxDelta`.\\n /// Formats values with decimals in failure message. Includes error message into revert string on failure.\\n function assertApproxEqAbsDecimal(\\n uint256 left,\\n uint256 right,\\n uint256 maxDelta,\\n uint256 decimals,\\n string calldata error\\n ) external pure;\\n\\n /// Compares two `int256` values. Expects difference to be less than or equal to `maxDelta`.\\n /// Formats values with decimals in failure message.\\n function assertApproxEqAbsDecimal(int256 left, int256 right, uint256 maxDelta, uint256 decimals) external pure;\\n\\n /// Compares two `int256` values. Expects difference to be less than or equal to `maxDelta`.\\n /// Formats values with decimals in failure message. Includes error message into revert string on failure.\\n function assertApproxEqAbsDecimal(\\n int256 left,\\n int256 right,\\n uint256 maxDelta,\\n uint256 decimals,\\n string calldata error\\n ) external pure;\\n\\n /// Compares two `uint256` values. Expects difference to be less than or equal to `maxDelta`.\\n function assertApproxEqAbs(uint256 left, uint256 right, uint256 maxDelta) external pure;\\n\\n /// Compares two `uint256` values. Expects difference to be less than or equal to `maxDelta`.\\n /// Includes error message into revert string on failure.\\n function assertApproxEqAbs(uint256 left, uint256 right, uint256 maxDelta, string calldata error) external pure;\\n\\n /// Compares two `int256` values. Expects difference to be less than or equal to `maxDelta`.\\n function assertApproxEqAbs(int256 left, int256 right, uint256 maxDelta) external pure;\\n\\n /// Compares two `int256` values. Expects difference to be less than or equal to `maxDelta`.\\n /// Includes error message into revert string on failure.\\n function assertApproxEqAbs(int256 left, int256 right, uint256 maxDelta, string calldata error) external pure;\\n\\n /// Compares two `uint256` values. Expects relative difference in percents to be less than or equal to `maxPercentDelta`.\\n /// `maxPercentDelta` is an 18 decimal fixed point number, where 1e18 == 100%\\n /// Formats values with decimals in failure message.\\n function assertApproxEqRelDecimal(uint256 left, uint256 right, uint256 maxPercentDelta, uint256 decimals)\\n external\\n pure;\\n\\n /// Compares two `uint256` values. Expects relative difference in percents to be less than or equal to `maxPercentDelta`.\\n /// `maxPercentDelta` is an 18 decimal fixed point number, where 1e18 == 100%\\n /// Formats values with decimals in failure message. Includes error message into revert string on failure.\\n function assertApproxEqRelDecimal(\\n uint256 left,\\n uint256 right,\\n uint256 maxPercentDelta,\\n uint256 decimals,\\n string calldata error\\n ) external pure;\\n\\n /// Compares two `int256` values. Expects relative difference in percents to be less than or equal to `maxPercentDelta`.\\n /// `maxPercentDelta` is an 18 decimal fixed point number, where 1e18 == 100%\\n /// Formats values with decimals in failure message.\\n function assertApproxEqRelDecimal(int256 left, int256 right, uint256 maxPercentDelta, uint256 decimals)\\n external\\n pure;\\n\\n /// Compares two `int256` values. Expects relative difference in percents to be less than or equal to `maxPercentDelta`.\\n /// `maxPercentDelta` is an 18 decimal fixed point number, where 1e18 == 100%\\n /// Formats values with decimals in failure message. Includes error message into revert string on failure.\\n function assertApproxEqRelDecimal(\\n int256 left,\\n int256 right,\\n uint256 maxPercentDelta,\\n uint256 decimals,\\n string calldata error\\n ) external pure;\\n\\n /// Compares two `uint256` values. Expects relative difference in percents to be less than or equal to `maxPercentDelta`.\\n /// `maxPercentDelta` is an 18 decimal fixed point number, where 1e18 == 100%\\n function assertApproxEqRel(uint256 left, uint256 right, uint256 maxPercentDelta) external pure;\\n\\n /// Compares two `uint256` values. Expects relative difference in percents to be less than or equal to `maxPercentDelta`.\\n /// `maxPercentDelta` is an 18 decimal fixed point number, where 1e18 == 100%\\n /// Includes error message into revert string on failure.\\n function assertApproxEqRel(uint256 left, uint256 right, uint256 maxPercentDelta, string calldata error)\\n external\\n pure;\\n\\n /// Compares two `int256` values. Expects relative difference in percents to be less than or equal to `maxPercentDelta`.\\n /// `maxPercentDelta` is an 18 decimal fixed point number, where 1e18 == 100%\\n function assertApproxEqRel(int256 left, int256 right, uint256 maxPercentDelta) external pure;\\n\\n /// Compares two `int256` values. Expects relative difference in percents to be less than or equal to `maxPercentDelta`.\\n /// `maxPercentDelta` is an 18 decimal fixed point number, where 1e18 == 100%\\n /// Includes error message into revert string on failure.\\n function assertApproxEqRel(int256 left, int256 right, uint256 maxPercentDelta, string calldata error)\\n external\\n pure;\\n\\n /// Asserts that two `uint256` values are equal, formatting them with decimals in failure message.\\n function assertEqDecimal(uint256 left, uint256 right, uint256 decimals) external pure;\\n\\n /// Asserts that two `uint256` values are equal, formatting them with decimals in failure message.\\n /// Includes error message into revert string on failure.\\n function assertEqDecimal(uint256 left, uint256 right, uint256 decimals, string calldata error) external pure;\\n\\n /// Asserts that two `int256` values are equal, formatting them with decimals in failure message.\\n function assertEqDecimal(int256 left, int256 right, uint256 decimals) external pure;\\n\\n /// Asserts that two `int256` values are equal, formatting them with decimals in failure message.\\n /// Includes error message into revert string on failure.\\n function assertEqDecimal(int256 left, int256 right, uint256 decimals, string calldata error) external pure;\\n\\n /// Asserts that two `bool` values are equal.\\n function assertEq(bool left, bool right) external pure;\\n\\n /// Asserts that two `bool` values are equal and includes error message into revert string on failure.\\n function assertEq(bool left, bool right, string calldata error) external pure;\\n\\n /// Asserts that two `string` values are equal.\\n function assertEq(string calldata left, string calldata right) external pure;\\n\\n /// Asserts that two `string` values are equal and includes error message into revert string on failure.\\n function assertEq(string calldata left, string calldata right, string calldata error) external pure;\\n\\n /// Asserts that two `bytes` values are equal.\\n function assertEq(bytes calldata left, bytes calldata right) external pure;\\n\\n /// Asserts that two `bytes` values are equal and includes error message into revert string on failure.\\n function assertEq(bytes calldata left, bytes calldata right, string calldata error) external pure;\\n\\n /// Asserts that two arrays of `bool` values are equal.\\n function assertEq(bool[] calldata left, bool[] calldata right) external pure;\\n\\n /// Asserts that two arrays of `bool` values are equal and includes error message into revert string on failure.\\n function assertEq(bool[] calldata left, bool[] calldata right, string calldata error) external pure;\\n\\n /// Asserts that two arrays of `uint256 values are equal.\\n function assertEq(uint256[] calldata left, uint256[] calldata right) external pure;\\n\\n /// Asserts that two arrays of `uint256` values are equal and includes error message into revert string on failure.\\n function assertEq(uint256[] calldata left, uint256[] calldata right, string calldata error) external pure;\\n\\n /// Asserts that two arrays of `int256` values are equal.\\n function assertEq(int256[] calldata left, int256[] calldata right) external pure;\\n\\n /// Asserts that two arrays of `int256` values are equal and includes error message into revert string on failure.\\n function assertEq(int256[] calldata left, int256[] calldata right, string calldata error) external pure;\\n\\n /// Asserts that two `uint256` values are equal.\\n function assertEq(uint256 left, uint256 right) external pure;\\n\\n /// Asserts that two arrays of `address` values are equal.\\n function assertEq(address[] calldata left, address[] calldata right) external pure;\\n\\n /// Asserts that two arrays of `address` values are equal and includes error message into revert string on failure.\\n function assertEq(address[] calldata left, address[] calldata right, string calldata error) external pure;\\n\\n /// Asserts that two arrays of `bytes32` values are equal.\\n function assertEq(bytes32[] calldata left, bytes32[] calldata right) external pure;\\n\\n /// Asserts that two arrays of `bytes32` values are equal and includes error message into revert string on failure.\\n function assertEq(bytes32[] calldata left, bytes32[] calldata right, string calldata error) external pure;\\n\\n /// Asserts that two arrays of `string` values are equal.\\n function assertEq(string[] calldata left, string[] calldata right) external pure;\\n\\n /// Asserts that two arrays of `string` values are equal and includes error message into revert string on failure.\\n function assertEq(string[] calldata left, string[] calldata right, string calldata error) external pure;\\n\\n /// Asserts that two arrays of `bytes` values are equal.\\n function assertEq(bytes[] calldata left, bytes[] calldata right) external pure;\\n\\n /// Asserts that two arrays of `bytes` values are equal and includes error message into revert string on failure.\\n function assertEq(bytes[] calldata left, bytes[] calldata right, string calldata error) external pure;\\n\\n /// Asserts that two `uint256` values are equal and includes error message into revert string on failure.\\n function assertEq(uint256 left, uint256 right, string calldata error) external pure;\\n\\n /// Asserts that two `int256` values are equal.\\n function assertEq(int256 left, int256 right) external pure;\\n\\n /// Asserts that two `int256` values are equal and includes error message into revert string on failure.\\n function assertEq(int256 left, int256 right, string calldata error) external pure;\\n\\n /// Asserts that two `address` values are equal.\\n function assertEq(address left, address right) external pure;\\n\\n /// Asserts that two `address` values are equal and includes error message into revert string on failure.\\n function assertEq(address left, address right, string calldata error) external pure;\\n\\n /// Asserts that two `bytes32` values are equal.\\n function assertEq(bytes32 left, bytes32 right) external pure;\\n\\n /// Asserts that two `bytes32` values are equal and includes error message into revert string on failure.\\n function assertEq(bytes32 left, bytes32 right, string calldata error) external pure;\\n\\n /// Asserts that the given condition is false.\\n function assertFalse(bool condition) external pure;\\n\\n /// Asserts that the given condition is false and includes error message into revert string on failure.\\n function assertFalse(bool condition, string calldata error) external pure;\\n\\n /// Compares two `uint256` values. Expects first value to be greater than or equal to second.\\n /// Formats values with decimals in failure message.\\n function assertGeDecimal(uint256 left, uint256 right, uint256 decimals) external pure;\\n\\n /// Compares two `uint256` values. Expects first value to be greater than or equal to second.\\n /// Formats values with decimals in failure message. Includes error message into revert string on failure.\\n function assertGeDecimal(uint256 left, uint256 right, uint256 decimals, string calldata error) external pure;\\n\\n /// Compares two `int256` values. Expects first value to be greater than or equal to second.\\n /// Formats values with decimals in failure message.\\n function assertGeDecimal(int256 left, int256 right, uint256 decimals) external pure;\\n\\n /// Compares two `int256` values. Expects first value to be greater than or equal to second.\\n /// Formats values with decimals in failure message. Includes error message into revert string on failure.\\n function assertGeDecimal(int256 left, int256 right, uint256 decimals, string calldata error) external pure;\\n\\n /// Compares two `uint256` values. Expects first value to be greater than or equal to second.\\n function assertGe(uint256 left, uint256 right) external pure;\\n\\n /// Compares two `uint256` values. Expects first value to be greater than or equal to second.\\n /// Includes error message into revert string on failure.\\n function assertGe(uint256 left, uint256 right, string calldata error) external pure;\\n\\n /// Compares two `int256` values. Expects first value to be greater than or equal to second.\\n function assertGe(int256 left, int256 right) external pure;\\n\\n /// Compares two `int256` values. Expects first value to be greater than or equal to second.\\n /// Includes error message into revert string on failure.\\n function assertGe(int256 left, int256 right, string calldata error) external pure;\\n\\n /// Compares two `uint256` values. Expects first value to be greater than second.\\n /// Formats values with decimals in failure message.\\n function assertGtDecimal(uint256 left, uint256 right, uint256 decimals) external pure;\\n\\n /// Compares two `uint256` values. Expects first value to be greater than second.\\n /// Formats values with decimals in failure message. Includes error message into revert string on failure.\\n function assertGtDecimal(uint256 left, uint256 right, uint256 decimals, string calldata error) external pure;\\n\\n /// Compares two `int256` values. Expects first value to be greater than second.\\n /// Formats values with decimals in failure message.\\n function assertGtDecimal(int256 left, int256 right, uint256 decimals) external pure;\\n\\n /// Compares two `int256` values. Expects first value to be greater than second.\\n /// Formats values with decimals in failure message. Includes error message into revert string on failure.\\n function assertGtDecimal(int256 left, int256 right, uint256 decimals, string calldata error) external pure;\\n\\n /// Compares two `uint256` values. Expects first value to be greater than second.\\n function assertGt(uint256 left, uint256 right) external pure;\\n\\n /// Compares two `uint256` values. Expects first value to be greater than second.\\n /// Includes error message into revert string on failure.\\n function assertGt(uint256 left, uint256 right, string calldata error) external pure;\\n\\n /// Compares two `int256` values. Expects first value to be greater than second.\\n function assertGt(int256 left, int256 right) external pure;\\n\\n /// Compares two `int256` values. Expects first value to be greater than second.\\n /// Includes error message into revert string on failure.\\n function assertGt(int256 left, int256 right, string calldata error) external pure;\\n\\n /// Compares two `uint256` values. Expects first value to be less than or equal to second.\\n /// Formats values with decimals in failure message.\\n function assertLeDecimal(uint256 left, uint256 right, uint256 decimals) external pure;\\n\\n /// Compares two `uint256` values. Expects first value to be less than or equal to second.\\n /// Formats values with decimals in failure message. Includes error message into revert string on failure.\\n function assertLeDecimal(uint256 left, uint256 right, uint256 decimals, string calldata error) external pure;\\n\\n /// Compares two `int256` values. Expects first value to be less than or equal to second.\\n /// Formats values with decimals in failure message.\\n function assertLeDecimal(int256 left, int256 right, uint256 decimals) external pure;\\n\\n /// Compares two `int256` values. Expects first value to be less than or equal to second.\\n /// Formats values with decimals in failure message. Includes error message into revert string on failure.\\n function assertLeDecimal(int256 left, int256 right, uint256 decimals, string calldata error) external pure;\\n\\n /// Compares two `uint256` values. Expects first value to be less than or equal to second.\\n function assertLe(uint256 left, uint256 right) external pure;\\n\\n /// Compares two `uint256` values. Expects first value to be less than or equal to second.\\n /// Includes error message into revert string on failure.\\n function assertLe(uint256 left, uint256 right, string calldata error) external pure;\\n\\n /// Compares two `int256` values. Expects first value to be less than or equal to second.\\n function assertLe(int256 left, int256 right) external pure;\\n\\n /// Compares two `int256` values. Expects first value to be less than or equal to second.\\n /// Includes error message into revert string on failure.\\n function assertLe(int256 left, int256 right, string calldata error) external pure;\\n\\n /// Compares two `uint256` values. Expects first value to be less than second.\\n /// Formats values with decimals in failure message.\\n function assertLtDecimal(uint256 left, uint256 right, uint256 decimals) external pure;\\n\\n /// Compares two `uint256` values. Expects first value to be less than second.\\n /// Formats values with decimals in failure message. Includes error message into revert string on failure.\\n function assertLtDecimal(uint256 left, uint256 right, uint256 decimals, string calldata error) external pure;\\n\\n /// Compares two `int256` values. Expects first value to be less than second.\\n /// Formats values with decimals in failure message.\\n function assertLtDecimal(int256 left, int256 right, uint256 decimals) external pure;\\n\\n /// Compares two `int256` values. Expects first value to be less than second.\\n /// Formats values with decimals in failure message. Includes error message into revert string on failure.\\n function assertLtDecimal(int256 left, int256 right, uint256 decimals, string calldata error) external pure;\\n\\n /// Compares two `uint256` values. Expects first value to be less than second.\\n function assertLt(uint256 left, uint256 right) external pure;\\n\\n /// Compares two `uint256` values. Expects first value to be less than second.\\n /// Includes error message into revert string on failure.\\n function assertLt(uint256 left, uint256 right, string calldata error) external pure;\\n\\n /// Compares two `int256` values. Expects first value to be less than second.\\n function assertLt(int256 left, int256 right) external pure;\\n\\n /// Compares two `int256` values. Expects first value to be less than second.\\n /// Includes error message into revert string on failure.\\n function assertLt(int256 left, int256 right, string calldata error) external pure;\\n\\n /// Asserts that two `uint256` values are not equal, formatting them with decimals in failure message.\\n function assertNotEqDecimal(uint256 left, uint256 right, uint256 decimals) external pure;\\n\\n /// Asserts that two `uint256` values are not equal, formatting them with decimals in failure message.\\n /// Includes error message into revert string on failure.\\n function assertNotEqDecimal(uint256 left, uint256 right, uint256 decimals, string calldata error) external pure;\\n\\n /// Asserts that two `int256` values are not equal, formatting them with decimals in failure message.\\n function assertNotEqDecimal(int256 left, int256 right, uint256 decimals) external pure;\\n\\n /// Asserts that two `int256` values are not equal, formatting them with decimals in failure message.\\n /// Includes error message into revert string on failure.\\n function assertNotEqDecimal(int256 left, int256 right, uint256 decimals, string calldata error) external pure;\\n\\n /// Asserts that two `bool` values are not equal.\\n function assertNotEq(bool left, bool right) external pure;\\n\\n /// Asserts that two `bool` values are not equal and includes error message into revert string on failure.\\n function assertNotEq(bool left, bool right, string calldata error) external pure;\\n\\n /// Asserts that two `string` values are not equal.\\n function assertNotEq(string calldata left, string calldata right) external pure;\\n\\n /// Asserts that two `string` values are not equal and includes error message into revert string on failure.\\n function assertNotEq(string calldata left, string calldata right, string calldata error) external pure;\\n\\n /// Asserts that two `bytes` values are not equal.\\n function assertNotEq(bytes calldata left, bytes calldata right) external pure;\\n\\n /// Asserts that two `bytes` values are not equal and includes error message into revert string on failure.\\n function assertNotEq(bytes calldata left, bytes calldata right, string calldata error) external pure;\\n\\n /// Asserts that two arrays of `bool` values are not equal.\\n function assertNotEq(bool[] calldata left, bool[] calldata right) external pure;\\n\\n /// Asserts that two arrays of `bool` values are not equal and includes error message into revert string on failure.\\n function assertNotEq(bool[] calldata left, bool[] calldata right, string calldata error) external pure;\\n\\n /// Asserts that two arrays of `uint256` values are not equal.\\n function assertNotEq(uint256[] calldata left, uint256[] calldata right) external pure;\\n\\n /// Asserts that two arrays of `uint256` values are not equal and includes error message into revert string on failure.\\n function assertNotEq(uint256[] calldata left, uint256[] calldata right, string calldata error) external pure;\\n\\n /// Asserts that two arrays of `int256` values are not equal.\\n function assertNotEq(int256[] calldata left, int256[] calldata right) external pure;\\n\\n /// Asserts that two arrays of `int256` values are not equal and includes error message into revert string on failure.\\n function assertNotEq(int256[] calldata left, int256[] calldata right, string calldata error) external pure;\\n\\n /// Asserts that two `uint256` values are not equal.\\n function assertNotEq(uint256 left, uint256 right) external pure;\\n\\n /// Asserts that two arrays of `address` values are not equal.\\n function assertNotEq(address[] calldata left, address[] calldata right) external pure;\\n\\n /// Asserts that two arrays of `address` values are not equal and includes error message into revert string on failure.\\n function assertNotEq(address[] calldata left, address[] calldata right, string calldata error) external pure;\\n\\n /// Asserts that two arrays of `bytes32` values are not equal.\\n function assertNotEq(bytes32[] calldata left, bytes32[] calldata right) external pure;\\n\\n /// Asserts that two arrays of `bytes32` values are not equal and includes error message into revert string on failure.\\n function assertNotEq(bytes32[] calldata left, bytes32[] calldata right, string calldata error) external pure;\\n\\n /// Asserts that two arrays of `string` values are not equal.\\n function assertNotEq(string[] calldata left, string[] calldata right) external pure;\\n\\n /// Asserts that two arrays of `string` values are not equal and includes error message into revert string on failure.\\n function assertNotEq(string[] calldata left, string[] calldata right, string calldata error) external pure;\\n\\n /// Asserts that two arrays of `bytes` values are not equal.\\n function assertNotEq(bytes[] calldata left, bytes[] calldata right) external pure;\\n\\n /// Asserts that two arrays of `bytes` values are not equal and includes error message into revert string on failure.\\n function assertNotEq(bytes[] calldata left, bytes[] calldata right, string calldata error) external pure;\\n\\n /// Asserts that two `uint256` values are not equal and includes error message into revert string on failure.\\n function assertNotEq(uint256 left, uint256 right, string calldata error) external pure;\\n\\n /// Asserts that two `int256` values are not equal.\\n function assertNotEq(int256 left, int256 right) external pure;\\n\\n /// Asserts that two `int256` values are not equal and includes error message into revert string on failure.\\n function assertNotEq(int256 left, int256 right, string calldata error) external pure;\\n\\n /// Asserts that two `address` values are not equal.\\n function assertNotEq(address left, address right) external pure;\\n\\n /// Asserts that two `address` values are not equal and includes error message into revert string on failure.\\n function assertNotEq(address left, address right, string calldata error) external pure;\\n\\n /// Asserts that two `bytes32` values are not equal.\\n function assertNotEq(bytes32 left, bytes32 right) external pure;\\n\\n /// Asserts that two `bytes32` values are not equal and includes error message into revert string on failure.\\n function assertNotEq(bytes32 left, bytes32 right, string calldata error) external pure;\\n\\n /// Asserts that the given condition is true.\\n function assertTrue(bool condition) external pure;\\n\\n /// Asserts that the given condition is true and includes error message into revert string on failure.\\n function assertTrue(bool condition, string calldata error) external pure;\\n\\n /// If the condition is false, discard this run's fuzz inputs and generate new ones.\\n function assume(bool condition) external pure;\\n\\n /// Discard this run's fuzz inputs and generate new ones if next call reverted.\\n function assumeNoRevert() external pure;\\n\\n /// Discard this run's fuzz inputs and generate new ones if next call reverts with the potential revert parameters.\\n function assumeNoRevert(PotentialRevert calldata potentialRevert) external pure;\\n\\n /// Discard this run's fuzz inputs and generate new ones if next call reverts with the any of the potential revert parameters.\\n function assumeNoRevert(PotentialRevert[] calldata potentialReverts) external pure;\\n\\n /// Writes a breakpoint to jump to in the debugger.\\n function breakpoint(string calldata char) external pure;\\n\\n /// Writes a conditional breakpoint to jump to in the debugger.\\n function breakpoint(string calldata char, bool value) external pure;\\n\\n /// Returns true if the current Foundry version is greater than or equal to the given version.\\n /// The given version string must be in the format `major.minor.patch`.\\n /// This is equivalent to `foundryVersionCmp(version) >= 0`.\\n function foundryVersionAtLeast(string calldata version) external view returns (bool);\\n\\n /// Compares the current Foundry version with the given version string.\\n /// The given version string must be in the format `major.minor.patch`.\\n /// Returns:\\n /// -1 if current Foundry version is less than the given version\\n /// 0 if current Foundry version equals the given version\\n /// 1 if current Foundry version is greater than the given version\\n /// This result can then be used with a comparison operator against `0`.\\n /// For example, to check if the current Foundry version is greater than or equal to `1.0.0`:\\n /// `if (foundryVersionCmp(\\\"1.0.0\\\") >= 0) { ... }`\\n function foundryVersionCmp(string calldata version) external view returns (int256);\\n\\n /// Returns the Foundry version.\\n /// Format: -+..\\n /// Sample output: 0.3.0-nightly+3cb96bde9b.1737036656.debug\\n /// Note: Build timestamps may vary slightly across platforms due to separate CI jobs.\\n /// For reliable version comparisons, use UNIX format (e.g., >= 1700000000)\\n /// to compare timestamps while ignoring minor time differences.\\n function getFoundryVersion() external view returns (string memory version);\\n\\n /// Returns the RPC url for the given alias.\\n function rpcUrl(string calldata rpcAlias) external view returns (string memory json);\\n\\n /// Returns all rpc urls and their aliases as structs.\\n function rpcUrlStructs() external view returns (Rpc[] memory urls);\\n\\n /// Returns all rpc urls and their aliases `[alias, url][]`.\\n function rpcUrls() external view returns (string[2][] memory urls);\\n\\n /// Suspends execution of the main thread for `duration` milliseconds.\\n function sleep(uint256 duration) external;\\n\\n // ======== Toml ========\\n\\n /// Checks if `key` exists in a TOML table.\\n function keyExistsToml(string calldata toml, string calldata key) external view returns (bool);\\n\\n /// Parses a string of TOML data at `key` and coerces it to `address`.\\n function parseTomlAddress(string calldata toml, string calldata key) external pure returns (address);\\n\\n /// Parses a string of TOML data at `key` and coerces it to `address[]`.\\n function parseTomlAddressArray(string calldata toml, string calldata key)\\n external\\n pure\\n returns (address[] memory);\\n\\n /// Parses a string of TOML data at `key` and coerces it to `bool`.\\n function parseTomlBool(string calldata toml, string calldata key) external pure returns (bool);\\n\\n /// Parses a string of TOML data at `key` and coerces it to `bool[]`.\\n function parseTomlBoolArray(string calldata toml, string calldata key) external pure returns (bool[] memory);\\n\\n /// Parses a string of TOML data at `key` and coerces it to `bytes`.\\n function parseTomlBytes(string calldata toml, string calldata key) external pure returns (bytes memory);\\n\\n /// Parses a string of TOML data at `key` and coerces it to `bytes32`.\\n function parseTomlBytes32(string calldata toml, string calldata key) external pure returns (bytes32);\\n\\n /// Parses a string of TOML data at `key` and coerces it to `bytes32[]`.\\n function parseTomlBytes32Array(string calldata toml, string calldata key)\\n external\\n pure\\n returns (bytes32[] memory);\\n\\n /// Parses a string of TOML data at `key` and coerces it to `bytes[]`.\\n function parseTomlBytesArray(string calldata toml, string calldata key) external pure returns (bytes[] memory);\\n\\n /// Parses a string of TOML data at `key` and coerces it to `int256`.\\n function parseTomlInt(string calldata toml, string calldata key) external pure returns (int256);\\n\\n /// Parses a string of TOML data at `key` and coerces it to `int256[]`.\\n function parseTomlIntArray(string calldata toml, string calldata key) external pure returns (int256[] memory);\\n\\n /// Returns an array of all the keys in a TOML table.\\n function parseTomlKeys(string calldata toml, string calldata key) external pure returns (string[] memory keys);\\n\\n /// Parses a string of TOML data at `key` and coerces it to `string`.\\n function parseTomlString(string calldata toml, string calldata key) external pure returns (string memory);\\n\\n /// Parses a string of TOML data at `key` and coerces it to `string[]`.\\n function parseTomlStringArray(string calldata toml, string calldata key) external pure returns (string[] memory);\\n\\n /// Parses a string of TOML data at `key` and coerces it to type array corresponding to `typeDescription`.\\n function parseTomlTypeArray(string calldata toml, string calldata key, string calldata typeDescription)\\n external\\n pure\\n returns (bytes memory);\\n\\n /// Parses a string of TOML data and coerces it to type corresponding to `typeDescription`.\\n function parseTomlType(string calldata toml, string calldata typeDescription)\\n external\\n pure\\n returns (bytes memory);\\n\\n /// Parses a string of TOML data at `key` and coerces it to type corresponding to `typeDescription`.\\n function parseTomlType(string calldata toml, string calldata key, string calldata typeDescription)\\n external\\n pure\\n returns (bytes memory);\\n\\n /// Parses a string of TOML data at `key` and coerces it to `uint256`.\\n function parseTomlUint(string calldata toml, string calldata key) external pure returns (uint256);\\n\\n /// Parses a string of TOML data at `key` and coerces it to `uint256[]`.\\n function parseTomlUintArray(string calldata toml, string calldata key) external pure returns (uint256[] memory);\\n\\n /// ABI-encodes a TOML table.\\n function parseToml(string calldata toml) external pure returns (bytes memory abiEncodedData);\\n\\n /// ABI-encodes a TOML table at `key`.\\n function parseToml(string calldata toml, string calldata key) external pure returns (bytes memory abiEncodedData);\\n\\n /// Takes serialized JSON, converts to TOML and write a serialized TOML to a file.\\n function writeToml(string calldata json, string calldata path) external;\\n\\n /// Takes serialized JSON, converts to TOML and write a serialized TOML table to an **existing** TOML file, replacing a value with key = \\n /// This is useful to replace a specific value of a TOML file, without having to parse the entire thing.\\n function writeToml(string calldata json, string calldata path, string calldata valueKey) external;\\n\\n // ======== Utilities ========\\n\\n /// Compute the address of a contract created with CREATE2 using the given CREATE2 deployer.\\n function computeCreate2Address(bytes32 salt, bytes32 initCodeHash, address deployer)\\n external\\n pure\\n returns (address);\\n\\n /// Compute the address of a contract created with CREATE2 using the default CREATE2 deployer.\\n function computeCreate2Address(bytes32 salt, bytes32 initCodeHash) external pure returns (address);\\n\\n /// Compute the address a contract will be deployed at for a given deployer address and nonce.\\n function computeCreateAddress(address deployer, uint256 nonce) external pure returns (address);\\n\\n /// Utility cheatcode to copy storage of `from` contract to another `to` contract.\\n function copyStorage(address from, address to) external;\\n\\n /// Returns ENS namehash for provided string.\\n function ensNamehash(string calldata name) external pure returns (bytes32);\\n\\n /// Gets the label for the specified address.\\n function getLabel(address account) external view returns (string memory currentLabel);\\n\\n /// Labels an address in call traces.\\n function label(address account, string calldata newLabel) external;\\n\\n /// Pauses collection of call traces. Useful in cases when you want to skip tracing of\\n /// complex calls which are not useful for debugging.\\n function pauseTracing() external view;\\n\\n /// Returns a random `address`.\\n function randomAddress() external returns (address);\\n\\n /// Returns a random `bool`.\\n function randomBool() external view returns (bool);\\n\\n /// Returns a random byte array value of the given length.\\n function randomBytes(uint256 len) external view returns (bytes memory);\\n\\n /// Returns a random fixed-size byte array of length 4.\\n function randomBytes4() external view returns (bytes4);\\n\\n /// Returns a random fixed-size byte array of length 8.\\n function randomBytes8() external view returns (bytes8);\\n\\n /// Returns a random `int256` value.\\n function randomInt() external view returns (int256);\\n\\n /// Returns a random `int256` value of given bits.\\n function randomInt(uint256 bits) external view returns (int256);\\n\\n /// Returns a random uint256 value.\\n function randomUint() external returns (uint256);\\n\\n /// Returns random uint256 value between the provided range (=min..=max).\\n function randomUint(uint256 min, uint256 max) external returns (uint256);\\n\\n /// Returns a random `uint256` value of given bits.\\n function randomUint(uint256 bits) external view returns (uint256);\\n\\n /// Unpauses collection of call traces.\\n function resumeTracing() external view;\\n\\n /// Utility cheatcode to set arbitrary storage for given target address.\\n function setArbitraryStorage(address target) external;\\n\\n /// Encodes a `bytes` value to a base64url string.\\n function toBase64URL(bytes calldata data) external pure returns (string memory);\\n\\n /// Encodes a `string` value to a base64url string.\\n function toBase64URL(string calldata data) external pure returns (string memory);\\n\\n /// Encodes a `bytes` value to a base64 string.\\n function toBase64(bytes calldata data) external pure returns (string memory);\\n\\n /// Encodes a `string` value to a base64 string.\\n function toBase64(string calldata data) external pure returns (string memory);\\n}\\n\\n/// The `Vm` interface does allow manipulation of the EVM state. These are all intended to be used\\n/// in tests, but it is not recommended to use these cheats in scripts.\\ninterface Vm is VmSafe {\\n // ======== EVM ========\\n\\n /// Utility cheatcode to set an EIP-2930 access list for all subsequent transactions.\\n function accessList(AccessListItem[] calldata access) external;\\n\\n /// Returns the identifier of the currently active fork. Reverts if no fork is currently active.\\n function activeFork() external view returns (uint256 forkId);\\n\\n /// In forking mode, explicitly grant the given address cheatcode access.\\n function allowCheatcodes(address account) external;\\n\\n /// Sets `block.blobbasefee`\\n function blobBaseFee(uint256 newBlobBaseFee) external;\\n\\n /// Sets the blobhashes in the transaction.\\n /// Not available on EVM versions before Cancun.\\n /// If used on unsupported EVM versions it will revert.\\n function blobhashes(bytes32[] calldata hashes) external;\\n\\n /// Sets `block.chainid`.\\n function chainId(uint256 newChainId) external;\\n\\n /// Clears all mocked calls.\\n function clearMockedCalls() external;\\n\\n /// Clones a source account code, state, balance and nonce to a target account and updates in-memory EVM state.\\n function cloneAccount(address source, address target) external;\\n\\n /// Sets `block.coinbase`.\\n function coinbase(address newCoinbase) external;\\n\\n /// Marks the slots of an account and the account address as cold.\\n function cool(address target) external;\\n\\n /// Utility cheatcode to mark specific storage slot as cold, simulating no prior read.\\n function coolSlot(address target, bytes32 slot) external;\\n\\n /// Creates a new fork with the given endpoint and the _latest_ block and returns the identifier of the fork.\\n function createFork(string calldata urlOrAlias) external returns (uint256 forkId);\\n\\n /// Creates a new fork with the given endpoint and block and returns the identifier of the fork.\\n function createFork(string calldata urlOrAlias, uint256 blockNumber) external returns (uint256 forkId);\\n\\n /// Creates a new fork with the given endpoint and at the block the given transaction was mined in,\\n /// replays all transaction mined in the block before the transaction, and returns the identifier of the fork.\\n function createFork(string calldata urlOrAlias, bytes32 txHash) external returns (uint256 forkId);\\n\\n /// Creates and also selects a new fork with the given endpoint and the latest block and returns the identifier of the fork.\\n function createSelectFork(string calldata urlOrAlias) external returns (uint256 forkId);\\n\\n /// Creates and also selects a new fork with the given endpoint and block and returns the identifier of the fork.\\n function createSelectFork(string calldata urlOrAlias, uint256 blockNumber) external returns (uint256 forkId);\\n\\n /// Creates and also selects new fork with the given endpoint and at the block the given transaction was mined in,\\n /// replays all transaction mined in the block before the transaction, returns the identifier of the fork.\\n function createSelectFork(string calldata urlOrAlias, bytes32 txHash) external returns (uint256 forkId);\\n\\n /// Sets an address' balance.\\n function deal(address account, uint256 newBalance) external;\\n\\n /// Removes the snapshot with the given ID created by `snapshot`.\\n /// Takes the snapshot ID to delete.\\n /// Returns `true` if the snapshot was successfully deleted.\\n /// Returns `false` if the snapshot does not exist.\\n function deleteStateSnapshot(uint256 snapshotId) external returns (bool success);\\n\\n /// Removes _all_ snapshots previously created by `snapshot`.\\n function deleteStateSnapshots() external;\\n\\n /// Sets `block.difficulty`.\\n /// Not available on EVM versions from Paris onwards. Use `prevrandao` instead.\\n /// Reverts if used on unsupported EVM versions.\\n function difficulty(uint256 newDifficulty) external;\\n\\n /// Dump a genesis JSON file's `allocs` to disk.\\n function dumpState(string calldata pathToStateJson) external;\\n\\n /// Sets an address' code.\\n function etch(address target, bytes calldata newRuntimeBytecode) external;\\n\\n /// Sets `block.basefee`.\\n function fee(uint256 newBasefee) external;\\n\\n /// Gets the blockhashes from the current transaction.\\n /// Not available on EVM versions before Cancun.\\n /// If used on unsupported EVM versions it will revert.\\n function getBlobhashes() external view returns (bytes32[] memory hashes);\\n\\n /// Returns true if the account is marked as persistent.\\n function isPersistent(address account) external view returns (bool persistent);\\n\\n /// Load a genesis JSON file's `allocs` into the in-memory EVM state.\\n function loadAllocs(string calldata pathToAllocsJson) external;\\n\\n /// Marks that the account(s) should use persistent storage across fork swaps in a multifork setup\\n /// Meaning, changes made to the state of this account will be kept when switching forks.\\n function makePersistent(address account) external;\\n\\n /// See `makePersistent(address)`.\\n function makePersistent(address account0, address account1) external;\\n\\n /// See `makePersistent(address)`.\\n function makePersistent(address account0, address account1, address account2) external;\\n\\n /// See `makePersistent(address)`.\\n function makePersistent(address[] calldata accounts) external;\\n\\n /// Reverts a call to an address with specified revert data.\\n function mockCallRevert(address callee, bytes calldata data, bytes calldata revertData) external;\\n\\n /// Reverts a call to an address with a specific `msg.value`, with specified revert data.\\n function mockCallRevert(address callee, uint256 msgValue, bytes calldata data, bytes calldata revertData)\\n external;\\n\\n /// Reverts a call to an address with specified revert data.\\n /// Overload to pass the function selector directly `token.approve.selector` instead of `abi.encodeWithSelector(token.approve.selector)`.\\n function mockCallRevert(address callee, bytes4 data, bytes calldata revertData) external;\\n\\n /// Reverts a call to an address with a specific `msg.value`, with specified revert data.\\n /// Overload to pass the function selector directly `token.approve.selector` instead of `abi.encodeWithSelector(token.approve.selector)`.\\n function mockCallRevert(address callee, uint256 msgValue, bytes4 data, bytes calldata revertData) external;\\n\\n /// Mocks a call to an address, returning specified data.\\n /// Calldata can either be strict or a partial match, e.g. if you only\\n /// pass a Solidity selector to the expected calldata, then the entire Solidity\\n /// function will be mocked.\\n function mockCall(address callee, bytes calldata data, bytes calldata returnData) external;\\n\\n /// Mocks a call to an address with a specific `msg.value`, returning specified data.\\n /// Calldata match takes precedence over `msg.value` in case of ambiguity.\\n function mockCall(address callee, uint256 msgValue, bytes calldata data, bytes calldata returnData) external;\\n\\n /// Mocks a call to an address, returning specified data.\\n /// Calldata can either be strict or a partial match, e.g. if you only\\n /// pass a Solidity selector to the expected calldata, then the entire Solidity\\n /// function will be mocked.\\n /// Overload to pass the function selector directly `token.approve.selector` instead of `abi.encodeWithSelector(token.approve.selector)`.\\n function mockCall(address callee, bytes4 data, bytes calldata returnData) external;\\n\\n /// Mocks a call to an address with a specific `msg.value`, returning specified data.\\n /// Calldata match takes precedence over `msg.value` in case of ambiguity.\\n /// Overload to pass the function selector directly `token.approve.selector` instead of `abi.encodeWithSelector(token.approve.selector)`.\\n function mockCall(address callee, uint256 msgValue, bytes4 data, bytes calldata returnData) external;\\n\\n /// Mocks multiple calls to an address, returning specified data for each call.\\n function mockCalls(address callee, bytes calldata data, bytes[] calldata returnData) external;\\n\\n /// Mocks multiple calls to an address with a specific `msg.value`, returning specified data for each call.\\n function mockCalls(address callee, uint256 msgValue, bytes calldata data, bytes[] calldata returnData) external;\\n\\n /// Whenever a call is made to `callee` with calldata `data`, this cheatcode instead calls\\n /// `target` with the same calldata. This functionality is similar to a delegate call made to\\n /// `target` contract from `callee`.\\n /// Can be used to substitute a call to a function with another implementation that captures\\n /// the primary logic of the original function but is easier to reason about.\\n /// If calldata is not a strict match then partial match by selector is attempted.\\n function mockFunction(address callee, address target, bytes calldata data) external;\\n\\n /// Utility cheatcode to remove any EIP-2930 access list set by `accessList` cheatcode.\\n function noAccessList() external;\\n\\n /// Sets the *next* call's `msg.sender` to be the input address.\\n function prank(address msgSender) external;\\n\\n /// Sets the *next* call's `msg.sender` to be the input address, and the `tx.origin` to be the second input.\\n function prank(address msgSender, address txOrigin) external;\\n\\n /// Sets the *next* delegate call's `msg.sender` to be the input address.\\n function prank(address msgSender, bool delegateCall) external;\\n\\n /// Sets the *next* delegate call's `msg.sender` to be the input address, and the `tx.origin` to be the second input.\\n function prank(address msgSender, address txOrigin, bool delegateCall) external;\\n\\n /// Sets `block.prevrandao`.\\n /// Not available on EVM versions before Paris. Use `difficulty` instead.\\n /// If used on unsupported EVM versions it will revert.\\n function prevrandao(bytes32 newPrevrandao) external;\\n\\n /// Sets `block.prevrandao`.\\n /// Not available on EVM versions before Paris. Use `difficulty` instead.\\n /// If used on unsupported EVM versions it will revert.\\n function prevrandao(uint256 newPrevrandao) external;\\n\\n /// Reads the current `msg.sender` and `tx.origin` from state and reports if there is any active caller modification.\\n function readCallers() external returns (CallerMode callerMode, address msgSender, address txOrigin);\\n\\n /// Resets the nonce of an account to 0 for EOAs and 1 for contract accounts.\\n function resetNonce(address account) external;\\n\\n /// Revert the state of the EVM to a previous snapshot\\n /// Takes the snapshot ID to revert to.\\n /// Returns `true` if the snapshot was successfully reverted.\\n /// Returns `false` if the snapshot does not exist.\\n /// **Note:** This does not automatically delete the snapshot. To delete the snapshot use `deleteStateSnapshot`.\\n function revertToState(uint256 snapshotId) external returns (bool success);\\n\\n /// Revert the state of the EVM to a previous snapshot and automatically deletes the snapshots\\n /// Takes the snapshot ID to revert to.\\n /// Returns `true` if the snapshot was successfully reverted and deleted.\\n /// Returns `false` if the snapshot does not exist.\\n function revertToStateAndDelete(uint256 snapshotId) external returns (bool success);\\n\\n /// Revokes persistent status from the address, previously added via `makePersistent`.\\n function revokePersistent(address account) external;\\n\\n /// See `revokePersistent(address)`.\\n function revokePersistent(address[] calldata accounts) external;\\n\\n /// Sets `block.height`.\\n function roll(uint256 newHeight) external;\\n\\n /// Updates the currently active fork to given block number\\n /// This is similar to `roll` but for the currently active fork.\\n function rollFork(uint256 blockNumber) external;\\n\\n /// Updates the currently active fork to given transaction. This will `rollFork` with the number\\n /// of the block the transaction was mined in and replays all transaction mined before it in the block.\\n function rollFork(bytes32 txHash) external;\\n\\n /// Updates the given fork to given block number.\\n function rollFork(uint256 forkId, uint256 blockNumber) external;\\n\\n /// Updates the given fork to block number of the given transaction and replays all transaction mined before it in the block.\\n function rollFork(uint256 forkId, bytes32 txHash) external;\\n\\n /// Takes a fork identifier created by `createFork` and sets the corresponding forked state as active.\\n function selectFork(uint256 forkId) external;\\n\\n /// Set blockhash for the current block.\\n /// It only sets the blockhash for blocks where `block.number - 256 <= number < block.number`.\\n function setBlockhash(uint256 blockNumber, bytes32 blockHash) external;\\n\\n /// Sets the nonce of an account. Must be higher than the current nonce of the account.\\n function setNonce(address account, uint64 newNonce) external;\\n\\n /// Sets the nonce of an account to an arbitrary value.\\n function setNonceUnsafe(address account, uint64 newNonce) external;\\n\\n /// Snapshot capture the gas usage of the last call by name from the callee perspective.\\n function snapshotGasLastCall(string calldata name) external returns (uint256 gasUsed);\\n\\n /// Snapshot capture the gas usage of the last call by name in a group from the callee perspective.\\n function snapshotGasLastCall(string calldata group, string calldata name) external returns (uint256 gasUsed);\\n\\n /// Snapshot the current state of the evm.\\n /// Returns the ID of the snapshot that was created.\\n /// To revert a snapshot use `revertToState`.\\n function snapshotState() external returns (uint256 snapshotId);\\n\\n /// Snapshot capture an arbitrary numerical value by name.\\n /// The group name is derived from the contract name.\\n function snapshotValue(string calldata name, uint256 value) external;\\n\\n /// Snapshot capture an arbitrary numerical value by name in a group.\\n function snapshotValue(string calldata group, string calldata name, uint256 value) external;\\n\\n /// Sets all subsequent calls' `msg.sender` to be the input address until `stopPrank` is called.\\n function startPrank(address msgSender) external;\\n\\n /// Sets all subsequent calls' `msg.sender` to be the input address until `stopPrank` is called, and the `tx.origin` to be the second input.\\n function startPrank(address msgSender, address txOrigin) external;\\n\\n /// Sets all subsequent delegate calls' `msg.sender` to be the input address until `stopPrank` is called.\\n function startPrank(address msgSender, bool delegateCall) external;\\n\\n /// Sets all subsequent delegate calls' `msg.sender` to be the input address until `stopPrank` is called, and the `tx.origin` to be the second input.\\n function startPrank(address msgSender, address txOrigin, bool delegateCall) external;\\n\\n /// Start a snapshot capture of the current gas usage by name.\\n /// The group name is derived from the contract name.\\n function startSnapshotGas(string calldata name) external;\\n\\n /// Start a snapshot capture of the current gas usage by name in a group.\\n function startSnapshotGas(string calldata group, string calldata name) external;\\n\\n /// Resets subsequent calls' `msg.sender` to be `address(this)`.\\n function stopPrank() external;\\n\\n /// Stop the snapshot capture of the current gas by latest snapshot name, capturing the gas used since the start.\\n function stopSnapshotGas() external returns (uint256 gasUsed);\\n\\n /// Stop the snapshot capture of the current gas usage by name, capturing the gas used since the start.\\n /// The group name is derived from the contract name.\\n function stopSnapshotGas(string calldata name) external returns (uint256 gasUsed);\\n\\n /// Stop the snapshot capture of the current gas usage by name in a group, capturing the gas used since the start.\\n function stopSnapshotGas(string calldata group, string calldata name) external returns (uint256 gasUsed);\\n\\n /// Stores a value to an address' storage slot.\\n function store(address target, bytes32 slot, bytes32 value) external;\\n\\n /// Fetches the given transaction from the active fork and executes it on the current state.\\n function transact(bytes32 txHash) external;\\n\\n /// Fetches the given transaction from the given fork and executes it on the current state.\\n function transact(uint256 forkId, bytes32 txHash) external;\\n\\n /// Sets `tx.gasprice`.\\n function txGasPrice(uint256 newGasPrice) external;\\n\\n /// Utility cheatcode to mark specific storage slot as warm, simulating a prior read.\\n function warmSlot(address target, bytes32 slot) external;\\n\\n /// Sets `block.timestamp`.\\n function warp(uint256 newTimestamp) external;\\n\\n /// `deleteSnapshot` is being deprecated in favor of `deleteStateSnapshot`. It will be removed in future versions.\\n function deleteSnapshot(uint256 snapshotId) external returns (bool success);\\n\\n /// `deleteSnapshots` is being deprecated in favor of `deleteStateSnapshots`. It will be removed in future versions.\\n function deleteSnapshots() external;\\n\\n /// `revertToAndDelete` is being deprecated in favor of `revertToStateAndDelete`. It will be removed in future versions.\\n function revertToAndDelete(uint256 snapshotId) external returns (bool success);\\n\\n /// `revertTo` is being deprecated in favor of `revertToState`. It will be removed in future versions.\\n function revertTo(uint256 snapshotId) external returns (bool success);\\n\\n /// `snapshot` is being deprecated in favor of `snapshotState`. It will be removed in future versions.\\n function snapshot() external returns (uint256 snapshotId);\\n\\n // ======== Testing ========\\n\\n /// Expect a call to an address with the specified `msg.value` and calldata, and a *minimum* amount of gas.\\n function expectCallMinGas(address callee, uint256 msgValue, uint64 minGas, bytes calldata data) external;\\n\\n /// Expect given number of calls to an address with the specified `msg.value` and calldata, and a *minimum* amount of gas.\\n function expectCallMinGas(address callee, uint256 msgValue, uint64 minGas, bytes calldata data, uint64 count)\\n external;\\n\\n /// Expects a call to an address with the specified calldata.\\n /// Calldata can either be a strict or a partial match.\\n function expectCall(address callee, bytes calldata data) external;\\n\\n /// Expects given number of calls to an address with the specified calldata.\\n function expectCall(address callee, bytes calldata data, uint64 count) external;\\n\\n /// Expects a call to an address with the specified `msg.value` and calldata.\\n function expectCall(address callee, uint256 msgValue, bytes calldata data) external;\\n\\n /// Expects given number of calls to an address with the specified `msg.value` and calldata.\\n function expectCall(address callee, uint256 msgValue, bytes calldata data, uint64 count) external;\\n\\n /// Expect a call to an address with the specified `msg.value`, gas, and calldata.\\n function expectCall(address callee, uint256 msgValue, uint64 gas, bytes calldata data) external;\\n\\n /// Expects given number of calls to an address with the specified `msg.value`, gas, and calldata.\\n function expectCall(address callee, uint256 msgValue, uint64 gas, bytes calldata data, uint64 count) external;\\n\\n /// Expects the deployment of the specified bytecode by the specified address using the CREATE opcode\\n function expectCreate(bytes calldata bytecode, address deployer) external;\\n\\n /// Expects the deployment of the specified bytecode by the specified address using the CREATE2 opcode\\n function expectCreate2(bytes calldata bytecode, address deployer) external;\\n\\n /// Prepare an expected anonymous log with (bool checkTopic1, bool checkTopic2, bool checkTopic3, bool checkData.).\\n /// Call this function, then emit an anonymous event, then call a function. Internally after the call, we check if\\n /// logs were emitted in the expected order with the expected topics and data (as specified by the booleans).\\n function expectEmitAnonymous(bool checkTopic0, bool checkTopic1, bool checkTopic2, bool checkTopic3, bool checkData)\\n external;\\n\\n /// Same as the previous method, but also checks supplied address against emitting contract.\\n function expectEmitAnonymous(\\n bool checkTopic0,\\n bool checkTopic1,\\n bool checkTopic2,\\n bool checkTopic3,\\n bool checkData,\\n address emitter\\n ) external;\\n\\n /// Prepare an expected anonymous log with all topic and data checks enabled.\\n /// Call this function, then emit an anonymous event, then call a function. Internally after the call, we check if\\n /// logs were emitted in the expected order with the expected topics and data.\\n function expectEmitAnonymous() external;\\n\\n /// Same as the previous method, but also checks supplied address against emitting contract.\\n function expectEmitAnonymous(address emitter) external;\\n\\n /// Prepare an expected log with (bool checkTopic1, bool checkTopic2, bool checkTopic3, bool checkData.).\\n /// Call this function, then emit an event, then call a function. Internally after the call, we check if\\n /// logs were emitted in the expected order with the expected topics and data (as specified by the booleans).\\n function expectEmit(bool checkTopic1, bool checkTopic2, bool checkTopic3, bool checkData) external;\\n\\n /// Same as the previous method, but also checks supplied address against emitting contract.\\n function expectEmit(bool checkTopic1, bool checkTopic2, bool checkTopic3, bool checkData, address emitter)\\n external;\\n\\n /// Prepare an expected log with all topic and data checks enabled.\\n /// Call this function, then emit an event, then call a function. Internally after the call, we check if\\n /// logs were emitted in the expected order with the expected topics and data.\\n function expectEmit() external;\\n\\n /// Same as the previous method, but also checks supplied address against emitting contract.\\n function expectEmit(address emitter) external;\\n\\n /// Expect a given number of logs with the provided topics.\\n function expectEmit(bool checkTopic1, bool checkTopic2, bool checkTopic3, bool checkData, uint64 count) external;\\n\\n /// Expect a given number of logs from a specific emitter with the provided topics.\\n function expectEmit(\\n bool checkTopic1,\\n bool checkTopic2,\\n bool checkTopic3,\\n bool checkData,\\n address emitter,\\n uint64 count\\n ) external;\\n\\n /// Expect a given number of logs with all topic and data checks enabled.\\n function expectEmit(uint64 count) external;\\n\\n /// Expect a given number of logs from a specific emitter with all topic and data checks enabled.\\n function expectEmit(address emitter, uint64 count) external;\\n\\n /// Expects an error on next call that starts with the revert data.\\n function expectPartialRevert(bytes4 revertData) external;\\n\\n /// Expects an error on next call to reverter address, that starts with the revert data.\\n function expectPartialRevert(bytes4 revertData, address reverter) external;\\n\\n /// Expects an error on next call with any revert data.\\n function expectRevert() external;\\n\\n /// Expects an error on next call that exactly matches the revert data.\\n function expectRevert(bytes4 revertData) external;\\n\\n /// Expects a `count` number of reverts from the upcoming calls from the reverter address that match the revert data.\\n function expectRevert(bytes4 revertData, address reverter, uint64 count) external;\\n\\n /// Expects a `count` number of reverts from the upcoming calls from the reverter address that exactly match the revert data.\\n function expectRevert(bytes calldata revertData, address reverter, uint64 count) external;\\n\\n /// Expects an error on next call that exactly matches the revert data.\\n function expectRevert(bytes calldata revertData) external;\\n\\n /// Expects an error with any revert data on next call to reverter address.\\n function expectRevert(address reverter) external;\\n\\n /// Expects an error from reverter address on next call, with any revert data.\\n function expectRevert(bytes4 revertData, address reverter) external;\\n\\n /// Expects an error from reverter address on next call, that exactly matches the revert data.\\n function expectRevert(bytes calldata revertData, address reverter) external;\\n\\n /// Expects a `count` number of reverts from the upcoming calls with any revert data or reverter.\\n function expectRevert(uint64 count) external;\\n\\n /// Expects a `count` number of reverts from the upcoming calls that match the revert data.\\n function expectRevert(bytes4 revertData, uint64 count) external;\\n\\n /// Expects a `count` number of reverts from the upcoming calls that exactly match the revert data.\\n function expectRevert(bytes calldata revertData, uint64 count) external;\\n\\n /// Expects a `count` number of reverts from the upcoming calls from the reverter address.\\n function expectRevert(address reverter, uint64 count) external;\\n\\n /// Only allows memory writes to offsets [0x00, 0x60) \\u222a [min, max) in the current subcontext. If any other\\n /// memory is written to, the test will fail. Can be called multiple times to add more ranges to the set.\\n function expectSafeMemory(uint64 min, uint64 max) external;\\n\\n /// Only allows memory writes to offsets [0x00, 0x60) \\u222a [min, max) in the next created subcontext.\\n /// If any other memory is written to, the test will fail. Can be called multiple times to add more ranges\\n /// to the set.\\n function expectSafeMemoryCall(uint64 min, uint64 max) external;\\n\\n /// Marks a test as skipped. Must be called at the top level of a test.\\n function skip(bool skipTest) external;\\n\\n /// Marks a test as skipped with a reason. Must be called at the top level of a test.\\n function skip(bool skipTest, string calldata reason) external;\\n\\n /// Stops all safe memory expectation in the current subcontext.\\n function stopExpectSafeMemory() external;\\n}\\n\",\"keccak256\":\"0xd91fb0df409fbd22463e937b48b9682d9333c5d4528d8fe7b36102a0323c44bf\",\"license\":\"MIT OR Apache-2.0\"},\"lib/forge-std/src/console.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity >=0.4.22 <0.9.0;\\n\\nlibrary console {\\n address constant CONSOLE_ADDRESS =\\n 0x000000000000000000636F6e736F6c652e6c6f67;\\n\\n function _sendLogPayloadImplementation(bytes memory payload) internal view {\\n address consoleAddress = CONSOLE_ADDRESS;\\n /// @solidity memory-safe-assembly\\n assembly {\\n pop(\\n staticcall(\\n gas(),\\n consoleAddress,\\n add(payload, 32),\\n mload(payload),\\n 0,\\n 0\\n )\\n )\\n }\\n }\\n\\n function _castToPure(\\n function(bytes memory) internal view fnIn\\n ) internal pure returns (function(bytes memory) pure fnOut) {\\n assembly {\\n fnOut := fnIn\\n }\\n }\\n\\n function _sendLogPayload(bytes memory payload) internal pure {\\n _castToPure(_sendLogPayloadImplementation)(payload);\\n }\\n\\n function log() internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log()\\\"));\\n }\\n\\n function logInt(int256 p0) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(int256)\\\", p0));\\n }\\n\\n function logUint(uint256 p0) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256)\\\", p0));\\n }\\n\\n function logString(string memory p0) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string)\\\", p0));\\n }\\n\\n function logBool(bool p0) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool)\\\", p0));\\n }\\n\\n function logAddress(address p0) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address)\\\", p0));\\n }\\n\\n function logBytes(bytes memory p0) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bytes)\\\", p0));\\n }\\n\\n function logBytes1(bytes1 p0) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bytes1)\\\", p0));\\n }\\n\\n function logBytes2(bytes2 p0) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bytes2)\\\", p0));\\n }\\n\\n function logBytes3(bytes3 p0) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bytes3)\\\", p0));\\n }\\n\\n function logBytes4(bytes4 p0) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bytes4)\\\", p0));\\n }\\n\\n function logBytes5(bytes5 p0) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bytes5)\\\", p0));\\n }\\n\\n function logBytes6(bytes6 p0) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bytes6)\\\", p0));\\n }\\n\\n function logBytes7(bytes7 p0) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bytes7)\\\", p0));\\n }\\n\\n function logBytes8(bytes8 p0) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bytes8)\\\", p0));\\n }\\n\\n function logBytes9(bytes9 p0) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bytes9)\\\", p0));\\n }\\n\\n function logBytes10(bytes10 p0) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bytes10)\\\", p0));\\n }\\n\\n function logBytes11(bytes11 p0) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bytes11)\\\", p0));\\n }\\n\\n function logBytes12(bytes12 p0) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bytes12)\\\", p0));\\n }\\n\\n function logBytes13(bytes13 p0) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bytes13)\\\", p0));\\n }\\n\\n function logBytes14(bytes14 p0) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bytes14)\\\", p0));\\n }\\n\\n function logBytes15(bytes15 p0) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bytes15)\\\", p0));\\n }\\n\\n function logBytes16(bytes16 p0) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bytes16)\\\", p0));\\n }\\n\\n function logBytes17(bytes17 p0) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bytes17)\\\", p0));\\n }\\n\\n function logBytes18(bytes18 p0) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bytes18)\\\", p0));\\n }\\n\\n function logBytes19(bytes19 p0) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bytes19)\\\", p0));\\n }\\n\\n function logBytes20(bytes20 p0) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bytes20)\\\", p0));\\n }\\n\\n function logBytes21(bytes21 p0) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bytes21)\\\", p0));\\n }\\n\\n function logBytes22(bytes22 p0) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bytes22)\\\", p0));\\n }\\n\\n function logBytes23(bytes23 p0) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bytes23)\\\", p0));\\n }\\n\\n function logBytes24(bytes24 p0) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bytes24)\\\", p0));\\n }\\n\\n function logBytes25(bytes25 p0) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bytes25)\\\", p0));\\n }\\n\\n function logBytes26(bytes26 p0) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bytes26)\\\", p0));\\n }\\n\\n function logBytes27(bytes27 p0) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bytes27)\\\", p0));\\n }\\n\\n function logBytes28(bytes28 p0) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bytes28)\\\", p0));\\n }\\n\\n function logBytes29(bytes29 p0) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bytes29)\\\", p0));\\n }\\n\\n function logBytes30(bytes30 p0) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bytes30)\\\", p0));\\n }\\n\\n function logBytes31(bytes31 p0) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bytes31)\\\", p0));\\n }\\n\\n function logBytes32(bytes32 p0) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bytes32)\\\", p0));\\n }\\n\\n function log(uint256 p0) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256)\\\", p0));\\n }\\n\\n function log(int256 p0) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(int256)\\\", p0));\\n }\\n\\n function log(string memory p0) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string)\\\", p0));\\n }\\n\\n function log(bool p0) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool)\\\", p0));\\n }\\n\\n function log(address p0) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address)\\\", p0));\\n }\\n\\n function log(uint256 p0, uint256 p1) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,uint256)\\\", p0, p1));\\n }\\n\\n function log(uint256 p0, string memory p1) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,string)\\\", p0, p1));\\n }\\n\\n function log(uint256 p0, bool p1) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,bool)\\\", p0, p1));\\n }\\n\\n function log(uint256 p0, address p1) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,address)\\\", p0, p1));\\n }\\n\\n function log(string memory p0, uint256 p1) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,uint256)\\\", p0, p1));\\n }\\n\\n function log(string memory p0, int256 p1) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,int256)\\\", p0, p1));\\n }\\n\\n function log(string memory p0, string memory p1) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,string)\\\", p0, p1));\\n }\\n\\n function log(string memory p0, bool p1) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,bool)\\\", p0, p1));\\n }\\n\\n function log(string memory p0, address p1) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,address)\\\", p0, p1));\\n }\\n\\n function log(bool p0, uint256 p1) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,uint256)\\\", p0, p1));\\n }\\n\\n function log(bool p0, string memory p1) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,string)\\\", p0, p1));\\n }\\n\\n function log(bool p0, bool p1) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,bool)\\\", p0, p1));\\n }\\n\\n function log(bool p0, address p1) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,address)\\\", p0, p1));\\n }\\n\\n function log(address p0, uint256 p1) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,uint256)\\\", p0, p1));\\n }\\n\\n function log(address p0, string memory p1) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,string)\\\", p0, p1));\\n }\\n\\n function log(address p0, bool p1) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,bool)\\\", p0, p1));\\n }\\n\\n function log(address p0, address p1) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,address)\\\", p0, p1));\\n }\\n\\n function log(uint256 p0, uint256 p1, uint256 p2) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,uint256,uint256)\\\", p0, p1, p2));\\n }\\n\\n function log(uint256 p0, uint256 p1, string memory p2) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,uint256,string)\\\", p0, p1, p2));\\n }\\n\\n function log(uint256 p0, uint256 p1, bool p2) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,uint256,bool)\\\", p0, p1, p2));\\n }\\n\\n function log(uint256 p0, uint256 p1, address p2) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,uint256,address)\\\", p0, p1, p2));\\n }\\n\\n function log(uint256 p0, string memory p1, uint256 p2) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,string,uint256)\\\", p0, p1, p2));\\n }\\n\\n function log(uint256 p0, string memory p1, string memory p2) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,string,string)\\\", p0, p1, p2));\\n }\\n\\n function log(uint256 p0, string memory p1, bool p2) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,string,bool)\\\", p0, p1, p2));\\n }\\n\\n function log(uint256 p0, string memory p1, address p2) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,string,address)\\\", p0, p1, p2));\\n }\\n\\n function log(uint256 p0, bool p1, uint256 p2) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,bool,uint256)\\\", p0, p1, p2));\\n }\\n\\n function log(uint256 p0, bool p1, string memory p2) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,bool,string)\\\", p0, p1, p2));\\n }\\n\\n function log(uint256 p0, bool p1, bool p2) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,bool,bool)\\\", p0, p1, p2));\\n }\\n\\n function log(uint256 p0, bool p1, address p2) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,bool,address)\\\", p0, p1, p2));\\n }\\n\\n function log(uint256 p0, address p1, uint256 p2) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,address,uint256)\\\", p0, p1, p2));\\n }\\n\\n function log(uint256 p0, address p1, string memory p2) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,address,string)\\\", p0, p1, p2));\\n }\\n\\n function log(uint256 p0, address p1, bool p2) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,address,bool)\\\", p0, p1, p2));\\n }\\n\\n function log(uint256 p0, address p1, address p2) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,address,address)\\\", p0, p1, p2));\\n }\\n\\n function log(string memory p0, uint256 p1, uint256 p2) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,uint256,uint256)\\\", p0, p1, p2));\\n }\\n\\n function log(string memory p0, uint256 p1, string memory p2) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,uint256,string)\\\", p0, p1, p2));\\n }\\n\\n function log(string memory p0, uint256 p1, bool p2) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,uint256,bool)\\\", p0, p1, p2));\\n }\\n\\n function log(string memory p0, uint256 p1, address p2) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,uint256,address)\\\", p0, p1, p2));\\n }\\n\\n function log(string memory p0, string memory p1, uint256 p2) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,string,uint256)\\\", p0, p1, p2));\\n }\\n\\n function log(string memory p0, string memory p1, string memory p2) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,string,string)\\\", p0, p1, p2));\\n }\\n\\n function log(string memory p0, string memory p1, bool p2) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,string,bool)\\\", p0, p1, p2));\\n }\\n\\n function log(string memory p0, string memory p1, address p2) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,string,address)\\\", p0, p1, p2));\\n }\\n\\n function log(string memory p0, bool p1, uint256 p2) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,bool,uint256)\\\", p0, p1, p2));\\n }\\n\\n function log(string memory p0, bool p1, string memory p2) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,bool,string)\\\", p0, p1, p2));\\n }\\n\\n function log(string memory p0, bool p1, bool p2) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,bool,bool)\\\", p0, p1, p2));\\n }\\n\\n function log(string memory p0, bool p1, address p2) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,bool,address)\\\", p0, p1, p2));\\n }\\n\\n function log(string memory p0, address p1, uint256 p2) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,address,uint256)\\\", p0, p1, p2));\\n }\\n\\n function log(string memory p0, address p1, string memory p2) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,address,string)\\\", p0, p1, p2));\\n }\\n\\n function log(string memory p0, address p1, bool p2) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,address,bool)\\\", p0, p1, p2));\\n }\\n\\n function log(string memory p0, address p1, address p2) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,address,address)\\\", p0, p1, p2));\\n }\\n\\n function log(bool p0, uint256 p1, uint256 p2) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,uint256,uint256)\\\", p0, p1, p2));\\n }\\n\\n function log(bool p0, uint256 p1, string memory p2) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,uint256,string)\\\", p0, p1, p2));\\n }\\n\\n function log(bool p0, uint256 p1, bool p2) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,uint256,bool)\\\", p0, p1, p2));\\n }\\n\\n function log(bool p0, uint256 p1, address p2) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,uint256,address)\\\", p0, p1, p2));\\n }\\n\\n function log(bool p0, string memory p1, uint256 p2) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,string,uint256)\\\", p0, p1, p2));\\n }\\n\\n function log(bool p0, string memory p1, string memory p2) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,string,string)\\\", p0, p1, p2));\\n }\\n\\n function log(bool p0, string memory p1, bool p2) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,string,bool)\\\", p0, p1, p2));\\n }\\n\\n function log(bool p0, string memory p1, address p2) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,string,address)\\\", p0, p1, p2));\\n }\\n\\n function log(bool p0, bool p1, uint256 p2) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,bool,uint256)\\\", p0, p1, p2));\\n }\\n\\n function log(bool p0, bool p1, string memory p2) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,bool,string)\\\", p0, p1, p2));\\n }\\n\\n function log(bool p0, bool p1, bool p2) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,bool,bool)\\\", p0, p1, p2));\\n }\\n\\n function log(bool p0, bool p1, address p2) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,bool,address)\\\", p0, p1, p2));\\n }\\n\\n function log(bool p0, address p1, uint256 p2) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,address,uint256)\\\", p0, p1, p2));\\n }\\n\\n function log(bool p0, address p1, string memory p2) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,address,string)\\\", p0, p1, p2));\\n }\\n\\n function log(bool p0, address p1, bool p2) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,address,bool)\\\", p0, p1, p2));\\n }\\n\\n function log(bool p0, address p1, address p2) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,address,address)\\\", p0, p1, p2));\\n }\\n\\n function log(address p0, uint256 p1, uint256 p2) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,uint256,uint256)\\\", p0, p1, p2));\\n }\\n\\n function log(address p0, uint256 p1, string memory p2) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,uint256,string)\\\", p0, p1, p2));\\n }\\n\\n function log(address p0, uint256 p1, bool p2) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,uint256,bool)\\\", p0, p1, p2));\\n }\\n\\n function log(address p0, uint256 p1, address p2) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,uint256,address)\\\", p0, p1, p2));\\n }\\n\\n function log(address p0, string memory p1, uint256 p2) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,string,uint256)\\\", p0, p1, p2));\\n }\\n\\n function log(address p0, string memory p1, string memory p2) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,string,string)\\\", p0, p1, p2));\\n }\\n\\n function log(address p0, string memory p1, bool p2) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,string,bool)\\\", p0, p1, p2));\\n }\\n\\n function log(address p0, string memory p1, address p2) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,string,address)\\\", p0, p1, p2));\\n }\\n\\n function log(address p0, bool p1, uint256 p2) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,bool,uint256)\\\", p0, p1, p2));\\n }\\n\\n function log(address p0, bool p1, string memory p2) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,bool,string)\\\", p0, p1, p2));\\n }\\n\\n function log(address p0, bool p1, bool p2) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,bool,bool)\\\", p0, p1, p2));\\n }\\n\\n function log(address p0, bool p1, address p2) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,bool,address)\\\", p0, p1, p2));\\n }\\n\\n function log(address p0, address p1, uint256 p2) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,address,uint256)\\\", p0, p1, p2));\\n }\\n\\n function log(address p0, address p1, string memory p2) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,address,string)\\\", p0, p1, p2));\\n }\\n\\n function log(address p0, address p1, bool p2) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,address,bool)\\\", p0, p1, p2));\\n }\\n\\n function log(address p0, address p1, address p2) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,address,address)\\\", p0, p1, p2));\\n }\\n\\n function log(uint256 p0, uint256 p1, uint256 p2, uint256 p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,uint256,uint256,uint256)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(uint256 p0, uint256 p1, uint256 p2, string memory p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,uint256,uint256,string)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(uint256 p0, uint256 p1, uint256 p2, bool p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,uint256,uint256,bool)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(uint256 p0, uint256 p1, uint256 p2, address p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,uint256,uint256,address)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(uint256 p0, uint256 p1, string memory p2, uint256 p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,uint256,string,uint256)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(uint256 p0, uint256 p1, string memory p2, string memory p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,uint256,string,string)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(uint256 p0, uint256 p1, string memory p2, bool p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,uint256,string,bool)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(uint256 p0, uint256 p1, string memory p2, address p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,uint256,string,address)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(uint256 p0, uint256 p1, bool p2, uint256 p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,uint256,bool,uint256)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(uint256 p0, uint256 p1, bool p2, string memory p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,uint256,bool,string)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(uint256 p0, uint256 p1, bool p2, bool p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,uint256,bool,bool)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(uint256 p0, uint256 p1, bool p2, address p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,uint256,bool,address)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(uint256 p0, uint256 p1, address p2, uint256 p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,uint256,address,uint256)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(uint256 p0, uint256 p1, address p2, string memory p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,uint256,address,string)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(uint256 p0, uint256 p1, address p2, bool p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,uint256,address,bool)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(uint256 p0, uint256 p1, address p2, address p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,uint256,address,address)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(uint256 p0, string memory p1, uint256 p2, uint256 p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,string,uint256,uint256)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(uint256 p0, string memory p1, uint256 p2, string memory p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,string,uint256,string)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(uint256 p0, string memory p1, uint256 p2, bool p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,string,uint256,bool)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(uint256 p0, string memory p1, uint256 p2, address p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,string,uint256,address)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(uint256 p0, string memory p1, string memory p2, uint256 p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,string,string,uint256)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(uint256 p0, string memory p1, string memory p2, string memory p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,string,string,string)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(uint256 p0, string memory p1, string memory p2, bool p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,string,string,bool)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(uint256 p0, string memory p1, string memory p2, address p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,string,string,address)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(uint256 p0, string memory p1, bool p2, uint256 p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,string,bool,uint256)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(uint256 p0, string memory p1, bool p2, string memory p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,string,bool,string)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(uint256 p0, string memory p1, bool p2, bool p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,string,bool,bool)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(uint256 p0, string memory p1, bool p2, address p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,string,bool,address)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(uint256 p0, string memory p1, address p2, uint256 p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,string,address,uint256)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(uint256 p0, string memory p1, address p2, string memory p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,string,address,string)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(uint256 p0, string memory p1, address p2, bool p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,string,address,bool)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(uint256 p0, string memory p1, address p2, address p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,string,address,address)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(uint256 p0, bool p1, uint256 p2, uint256 p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,bool,uint256,uint256)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(uint256 p0, bool p1, uint256 p2, string memory p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,bool,uint256,string)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(uint256 p0, bool p1, uint256 p2, bool p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,bool,uint256,bool)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(uint256 p0, bool p1, uint256 p2, address p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,bool,uint256,address)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(uint256 p0, bool p1, string memory p2, uint256 p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,bool,string,uint256)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(uint256 p0, bool p1, string memory p2, string memory p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,bool,string,string)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(uint256 p0, bool p1, string memory p2, bool p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,bool,string,bool)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(uint256 p0, bool p1, string memory p2, address p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,bool,string,address)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(uint256 p0, bool p1, bool p2, uint256 p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,bool,bool,uint256)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(uint256 p0, bool p1, bool p2, string memory p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,bool,bool,string)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(uint256 p0, bool p1, bool p2, bool p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,bool,bool,bool)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(uint256 p0, bool p1, bool p2, address p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,bool,bool,address)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(uint256 p0, bool p1, address p2, uint256 p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,bool,address,uint256)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(uint256 p0, bool p1, address p2, string memory p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,bool,address,string)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(uint256 p0, bool p1, address p2, bool p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,bool,address,bool)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(uint256 p0, bool p1, address p2, address p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,bool,address,address)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(uint256 p0, address p1, uint256 p2, uint256 p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,address,uint256,uint256)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(uint256 p0, address p1, uint256 p2, string memory p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,address,uint256,string)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(uint256 p0, address p1, uint256 p2, bool p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,address,uint256,bool)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(uint256 p0, address p1, uint256 p2, address p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,address,uint256,address)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(uint256 p0, address p1, string memory p2, uint256 p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,address,string,uint256)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(uint256 p0, address p1, string memory p2, string memory p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,address,string,string)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(uint256 p0, address p1, string memory p2, bool p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,address,string,bool)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(uint256 p0, address p1, string memory p2, address p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,address,string,address)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(uint256 p0, address p1, bool p2, uint256 p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,address,bool,uint256)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(uint256 p0, address p1, bool p2, string memory p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,address,bool,string)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(uint256 p0, address p1, bool p2, bool p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,address,bool,bool)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(uint256 p0, address p1, bool p2, address p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,address,bool,address)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(uint256 p0, address p1, address p2, uint256 p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,address,address,uint256)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(uint256 p0, address p1, address p2, string memory p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,address,address,string)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(uint256 p0, address p1, address p2, bool p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,address,address,bool)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(uint256 p0, address p1, address p2, address p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,address,address,address)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(string memory p0, uint256 p1, uint256 p2, uint256 p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,uint256,uint256,uint256)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(string memory p0, uint256 p1, uint256 p2, string memory p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,uint256,uint256,string)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(string memory p0, uint256 p1, uint256 p2, bool p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,uint256,uint256,bool)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(string memory p0, uint256 p1, uint256 p2, address p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,uint256,uint256,address)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(string memory p0, uint256 p1, string memory p2, uint256 p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,uint256,string,uint256)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(string memory p0, uint256 p1, string memory p2, string memory p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,uint256,string,string)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(string memory p0, uint256 p1, string memory p2, bool p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,uint256,string,bool)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(string memory p0, uint256 p1, string memory p2, address p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,uint256,string,address)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(string memory p0, uint256 p1, bool p2, uint256 p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,uint256,bool,uint256)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(string memory p0, uint256 p1, bool p2, string memory p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,uint256,bool,string)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(string memory p0, uint256 p1, bool p2, bool p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,uint256,bool,bool)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(string memory p0, uint256 p1, bool p2, address p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,uint256,bool,address)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(string memory p0, uint256 p1, address p2, uint256 p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,uint256,address,uint256)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(string memory p0, uint256 p1, address p2, string memory p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,uint256,address,string)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(string memory p0, uint256 p1, address p2, bool p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,uint256,address,bool)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(string memory p0, uint256 p1, address p2, address p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,uint256,address,address)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(string memory p0, string memory p1, uint256 p2, uint256 p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,string,uint256,uint256)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(string memory p0, string memory p1, uint256 p2, string memory p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,string,uint256,string)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(string memory p0, string memory p1, uint256 p2, bool p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,string,uint256,bool)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(string memory p0, string memory p1, uint256 p2, address p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,string,uint256,address)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(string memory p0, string memory p1, string memory p2, uint256 p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,string,string,uint256)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(string memory p0, string memory p1, string memory p2, string memory p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,string,string,string)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(string memory p0, string memory p1, string memory p2, bool p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,string,string,bool)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(string memory p0, string memory p1, string memory p2, address p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,string,string,address)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(string memory p0, string memory p1, bool p2, uint256 p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,string,bool,uint256)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(string memory p0, string memory p1, bool p2, string memory p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,string,bool,string)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(string memory p0, string memory p1, bool p2, bool p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,string,bool,bool)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(string memory p0, string memory p1, bool p2, address p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,string,bool,address)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(string memory p0, string memory p1, address p2, uint256 p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,string,address,uint256)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(string memory p0, string memory p1, address p2, string memory p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,string,address,string)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(string memory p0, string memory p1, address p2, bool p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,string,address,bool)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(string memory p0, string memory p1, address p2, address p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,string,address,address)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(string memory p0, bool p1, uint256 p2, uint256 p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,bool,uint256,uint256)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(string memory p0, bool p1, uint256 p2, string memory p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,bool,uint256,string)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(string memory p0, bool p1, uint256 p2, bool p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,bool,uint256,bool)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(string memory p0, bool p1, uint256 p2, address p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,bool,uint256,address)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(string memory p0, bool p1, string memory p2, uint256 p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,bool,string,uint256)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(string memory p0, bool p1, string memory p2, string memory p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,bool,string,string)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(string memory p0, bool p1, string memory p2, bool p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,bool,string,bool)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(string memory p0, bool p1, string memory p2, address p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,bool,string,address)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(string memory p0, bool p1, bool p2, uint256 p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,bool,bool,uint256)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(string memory p0, bool p1, bool p2, string memory p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,bool,bool,string)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(string memory p0, bool p1, bool p2, bool p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,bool,bool,bool)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(string memory p0, bool p1, bool p2, address p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,bool,bool,address)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(string memory p0, bool p1, address p2, uint256 p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,bool,address,uint256)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(string memory p0, bool p1, address p2, string memory p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,bool,address,string)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(string memory p0, bool p1, address p2, bool p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,bool,address,bool)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(string memory p0, bool p1, address p2, address p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,bool,address,address)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(string memory p0, address p1, uint256 p2, uint256 p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,address,uint256,uint256)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(string memory p0, address p1, uint256 p2, string memory p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,address,uint256,string)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(string memory p0, address p1, uint256 p2, bool p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,address,uint256,bool)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(string memory p0, address p1, uint256 p2, address p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,address,uint256,address)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(string memory p0, address p1, string memory p2, uint256 p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,address,string,uint256)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(string memory p0, address p1, string memory p2, string memory p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,address,string,string)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(string memory p0, address p1, string memory p2, bool p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,address,string,bool)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(string memory p0, address p1, string memory p2, address p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,address,string,address)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(string memory p0, address p1, bool p2, uint256 p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,address,bool,uint256)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(string memory p0, address p1, bool p2, string memory p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,address,bool,string)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(string memory p0, address p1, bool p2, bool p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,address,bool,bool)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(string memory p0, address p1, bool p2, address p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,address,bool,address)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(string memory p0, address p1, address p2, uint256 p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,address,address,uint256)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(string memory p0, address p1, address p2, string memory p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,address,address,string)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(string memory p0, address p1, address p2, bool p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,address,address,bool)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(string memory p0, address p1, address p2, address p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,address,address,address)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(bool p0, uint256 p1, uint256 p2, uint256 p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,uint256,uint256,uint256)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(bool p0, uint256 p1, uint256 p2, string memory p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,uint256,uint256,string)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(bool p0, uint256 p1, uint256 p2, bool p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,uint256,uint256,bool)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(bool p0, uint256 p1, uint256 p2, address p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,uint256,uint256,address)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(bool p0, uint256 p1, string memory p2, uint256 p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,uint256,string,uint256)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(bool p0, uint256 p1, string memory p2, string memory p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,uint256,string,string)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(bool p0, uint256 p1, string memory p2, bool p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,uint256,string,bool)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(bool p0, uint256 p1, string memory p2, address p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,uint256,string,address)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(bool p0, uint256 p1, bool p2, uint256 p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,uint256,bool,uint256)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(bool p0, uint256 p1, bool p2, string memory p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,uint256,bool,string)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(bool p0, uint256 p1, bool p2, bool p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,uint256,bool,bool)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(bool p0, uint256 p1, bool p2, address p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,uint256,bool,address)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(bool p0, uint256 p1, address p2, uint256 p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,uint256,address,uint256)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(bool p0, uint256 p1, address p2, string memory p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,uint256,address,string)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(bool p0, uint256 p1, address p2, bool p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,uint256,address,bool)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(bool p0, uint256 p1, address p2, address p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,uint256,address,address)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(bool p0, string memory p1, uint256 p2, uint256 p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,string,uint256,uint256)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(bool p0, string memory p1, uint256 p2, string memory p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,string,uint256,string)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(bool p0, string memory p1, uint256 p2, bool p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,string,uint256,bool)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(bool p0, string memory p1, uint256 p2, address p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,string,uint256,address)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(bool p0, string memory p1, string memory p2, uint256 p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,string,string,uint256)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(bool p0, string memory p1, string memory p2, string memory p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,string,string,string)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(bool p0, string memory p1, string memory p2, bool p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,string,string,bool)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(bool p0, string memory p1, string memory p2, address p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,string,string,address)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(bool p0, string memory p1, bool p2, uint256 p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,string,bool,uint256)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(bool p0, string memory p1, bool p2, string memory p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,string,bool,string)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(bool p0, string memory p1, bool p2, bool p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,string,bool,bool)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(bool p0, string memory p1, bool p2, address p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,string,bool,address)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(bool p0, string memory p1, address p2, uint256 p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,string,address,uint256)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(bool p0, string memory p1, address p2, string memory p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,string,address,string)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(bool p0, string memory p1, address p2, bool p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,string,address,bool)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(bool p0, string memory p1, address p2, address p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,string,address,address)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(bool p0, bool p1, uint256 p2, uint256 p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,bool,uint256,uint256)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(bool p0, bool p1, uint256 p2, string memory p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,bool,uint256,string)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(bool p0, bool p1, uint256 p2, bool p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,bool,uint256,bool)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(bool p0, bool p1, uint256 p2, address p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,bool,uint256,address)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(bool p0, bool p1, string memory p2, uint256 p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,bool,string,uint256)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(bool p0, bool p1, string memory p2, string memory p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,bool,string,string)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(bool p0, bool p1, string memory p2, bool p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,bool,string,bool)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(bool p0, bool p1, string memory p2, address p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,bool,string,address)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(bool p0, bool p1, bool p2, uint256 p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,bool,bool,uint256)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(bool p0, bool p1, bool p2, string memory p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,bool,bool,string)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(bool p0, bool p1, bool p2, bool p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,bool,bool,bool)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(bool p0, bool p1, bool p2, address p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,bool,bool,address)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(bool p0, bool p1, address p2, uint256 p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,bool,address,uint256)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(bool p0, bool p1, address p2, string memory p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,bool,address,string)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(bool p0, bool p1, address p2, bool p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,bool,address,bool)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(bool p0, bool p1, address p2, address p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,bool,address,address)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(bool p0, address p1, uint256 p2, uint256 p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,address,uint256,uint256)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(bool p0, address p1, uint256 p2, string memory p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,address,uint256,string)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(bool p0, address p1, uint256 p2, bool p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,address,uint256,bool)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(bool p0, address p1, uint256 p2, address p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,address,uint256,address)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(bool p0, address p1, string memory p2, uint256 p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,address,string,uint256)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(bool p0, address p1, string memory p2, string memory p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,address,string,string)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(bool p0, address p1, string memory p2, bool p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,address,string,bool)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(bool p0, address p1, string memory p2, address p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,address,string,address)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(bool p0, address p1, bool p2, uint256 p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,address,bool,uint256)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(bool p0, address p1, bool p2, string memory p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,address,bool,string)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(bool p0, address p1, bool p2, bool p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,address,bool,bool)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(bool p0, address p1, bool p2, address p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,address,bool,address)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(bool p0, address p1, address p2, uint256 p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,address,address,uint256)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(bool p0, address p1, address p2, string memory p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,address,address,string)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(bool p0, address p1, address p2, bool p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,address,address,bool)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(bool p0, address p1, address p2, address p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,address,address,address)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(address p0, uint256 p1, uint256 p2, uint256 p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,uint256,uint256,uint256)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(address p0, uint256 p1, uint256 p2, string memory p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,uint256,uint256,string)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(address p0, uint256 p1, uint256 p2, bool p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,uint256,uint256,bool)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(address p0, uint256 p1, uint256 p2, address p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,uint256,uint256,address)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(address p0, uint256 p1, string memory p2, uint256 p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,uint256,string,uint256)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(address p0, uint256 p1, string memory p2, string memory p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,uint256,string,string)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(address p0, uint256 p1, string memory p2, bool p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,uint256,string,bool)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(address p0, uint256 p1, string memory p2, address p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,uint256,string,address)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(address p0, uint256 p1, bool p2, uint256 p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,uint256,bool,uint256)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(address p0, uint256 p1, bool p2, string memory p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,uint256,bool,string)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(address p0, uint256 p1, bool p2, bool p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,uint256,bool,bool)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(address p0, uint256 p1, bool p2, address p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,uint256,bool,address)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(address p0, uint256 p1, address p2, uint256 p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,uint256,address,uint256)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(address p0, uint256 p1, address p2, string memory p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,uint256,address,string)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(address p0, uint256 p1, address p2, bool p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,uint256,address,bool)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(address p0, uint256 p1, address p2, address p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,uint256,address,address)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(address p0, string memory p1, uint256 p2, uint256 p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,string,uint256,uint256)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(address p0, string memory p1, uint256 p2, string memory p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,string,uint256,string)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(address p0, string memory p1, uint256 p2, bool p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,string,uint256,bool)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(address p0, string memory p1, uint256 p2, address p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,string,uint256,address)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(address p0, string memory p1, string memory p2, uint256 p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,string,string,uint256)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(address p0, string memory p1, string memory p2, string memory p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,string,string,string)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(address p0, string memory p1, string memory p2, bool p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,string,string,bool)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(address p0, string memory p1, string memory p2, address p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,string,string,address)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(address p0, string memory p1, bool p2, uint256 p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,string,bool,uint256)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(address p0, string memory p1, bool p2, string memory p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,string,bool,string)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(address p0, string memory p1, bool p2, bool p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,string,bool,bool)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(address p0, string memory p1, bool p2, address p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,string,bool,address)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(address p0, string memory p1, address p2, uint256 p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,string,address,uint256)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(address p0, string memory p1, address p2, string memory p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,string,address,string)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(address p0, string memory p1, address p2, bool p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,string,address,bool)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(address p0, string memory p1, address p2, address p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,string,address,address)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(address p0, bool p1, uint256 p2, uint256 p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,bool,uint256,uint256)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(address p0, bool p1, uint256 p2, string memory p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,bool,uint256,string)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(address p0, bool p1, uint256 p2, bool p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,bool,uint256,bool)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(address p0, bool p1, uint256 p2, address p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,bool,uint256,address)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(address p0, bool p1, string memory p2, uint256 p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,bool,string,uint256)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(address p0, bool p1, string memory p2, string memory p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,bool,string,string)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(address p0, bool p1, string memory p2, bool p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,bool,string,bool)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(address p0, bool p1, string memory p2, address p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,bool,string,address)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(address p0, bool p1, bool p2, uint256 p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,bool,bool,uint256)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(address p0, bool p1, bool p2, string memory p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,bool,bool,string)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(address p0, bool p1, bool p2, bool p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,bool,bool,bool)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(address p0, bool p1, bool p2, address p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,bool,bool,address)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(address p0, bool p1, address p2, uint256 p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,bool,address,uint256)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(address p0, bool p1, address p2, string memory p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,bool,address,string)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(address p0, bool p1, address p2, bool p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,bool,address,bool)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(address p0, bool p1, address p2, address p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,bool,address,address)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(address p0, address p1, uint256 p2, uint256 p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,address,uint256,uint256)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(address p0, address p1, uint256 p2, string memory p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,address,uint256,string)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(address p0, address p1, uint256 p2, bool p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,address,uint256,bool)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(address p0, address p1, uint256 p2, address p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,address,uint256,address)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(address p0, address p1, string memory p2, uint256 p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,address,string,uint256)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(address p0, address p1, string memory p2, string memory p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,address,string,string)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(address p0, address p1, string memory p2, bool p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,address,string,bool)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(address p0, address p1, string memory p2, address p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,address,string,address)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(address p0, address p1, bool p2, uint256 p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,address,bool,uint256)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(address p0, address p1, bool p2, string memory p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,address,bool,string)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(address p0, address p1, bool p2, bool p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,address,bool,bool)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(address p0, address p1, bool p2, address p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,address,bool,address)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(address p0, address p1, address p2, uint256 p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,address,address,uint256)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(address p0, address p1, address p2, string memory p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,address,address,string)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(address p0, address p1, address p2, bool p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,address,address,bool)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(address p0, address p1, address p2, address p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,address,address,address)\\\", p0, p1, p2, p3));\\n }\\n}\\n\",\"keccak256\":\"0x4bbf47eb762cef93729d6ef15e78789957147039b113e5d4df48e3d3fd16d0f5\",\"license\":\"MIT\"},\"lib/forge-std/src/console2.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity >=0.4.22 <0.9.0;\\n\\nimport {console as console2} from \\\"./console.sol\\\";\\n\",\"keccak256\":\"0x3b8fe79f48f065a4e4d35362171304a33784c3a90febae5f2787805a438de12f\",\"license\":\"MIT\"},\"lib/forge-std/src/interfaces/IMulticall3.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity >=0.6.2 <0.9.0;\\n\\npragma experimental ABIEncoderV2;\\n\\ninterface IMulticall3 {\\n struct Call {\\n address target;\\n bytes callData;\\n }\\n\\n struct Call3 {\\n address target;\\n bool allowFailure;\\n bytes callData;\\n }\\n\\n struct Call3Value {\\n address target;\\n bool allowFailure;\\n uint256 value;\\n bytes callData;\\n }\\n\\n struct Result {\\n bool success;\\n bytes returnData;\\n }\\n\\n function aggregate(Call[] calldata calls)\\n external\\n payable\\n returns (uint256 blockNumber, bytes[] memory returnData);\\n\\n function aggregate3(Call3[] calldata calls) external payable returns (Result[] memory returnData);\\n\\n function aggregate3Value(Call3Value[] calldata calls) external payable returns (Result[] memory returnData);\\n\\n function blockAndAggregate(Call[] calldata calls)\\n external\\n payable\\n returns (uint256 blockNumber, bytes32 blockHash, Result[] memory returnData);\\n\\n function getBasefee() external view returns (uint256 basefee);\\n\\n function getBlockHash(uint256 blockNumber) external view returns (bytes32 blockHash);\\n\\n function getBlockNumber() external view returns (uint256 blockNumber);\\n\\n function getChainId() external view returns (uint256 chainid);\\n\\n function getCurrentBlockCoinbase() external view returns (address coinbase);\\n\\n function getCurrentBlockDifficulty() external view returns (uint256 difficulty);\\n\\n function getCurrentBlockGasLimit() external view returns (uint256 gaslimit);\\n\\n function getCurrentBlockTimestamp() external view returns (uint256 timestamp);\\n\\n function getEthBalance(address addr) external view returns (uint256 balance);\\n\\n function getLastBlockHash() external view returns (bytes32 blockHash);\\n\\n function tryAggregate(bool requireSuccess, Call[] calldata calls)\\n external\\n payable\\n returns (Result[] memory returnData);\\n\\n function tryBlockAndAggregate(bool requireSuccess, Call[] calldata calls)\\n external\\n payable\\n returns (uint256 blockNumber, bytes32 blockHash, Result[] memory returnData);\\n}\\n\",\"keccak256\":\"0x7aac1389150499a922d1f9ef5749c908cef127cb2075b92fa17e9cb611263d0a\",\"license\":\"MIT\"},\"lib/forge-std/src/safeconsole.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity >=0.6.2 <0.9.0;\\n\\n/// @author philogy \\n/// @dev Code generated automatically by script.\\nlibrary safeconsole {\\n uint256 constant CONSOLE_ADDR = 0x000000000000000000000000000000000000000000636F6e736F6c652e6c6f67;\\n\\n // Credit to [0age](https://twitter.com/z0age/status/1654922202930888704) and [0xdapper](https://github.com/foundry-rs/forge-std/pull/374)\\n // for the view-to-pure log trick.\\n function _sendLogPayload(uint256 offset, uint256 size) private pure {\\n function(uint256, uint256) internal view fnIn = _sendLogPayloadView;\\n function(uint256, uint256) internal pure pureSendLogPayload;\\n /// @solidity memory-safe-assembly\\n assembly {\\n pureSendLogPayload := fnIn\\n }\\n pureSendLogPayload(offset, size);\\n }\\n\\n function _sendLogPayloadView(uint256 offset, uint256 size) private view {\\n /// @solidity memory-safe-assembly\\n assembly {\\n pop(staticcall(gas(), CONSOLE_ADDR, offset, size, 0x0, 0x0))\\n }\\n }\\n\\n function _memcopy(uint256 fromOffset, uint256 toOffset, uint256 length) private pure {\\n function(uint256, uint256, uint256) internal view fnIn = _memcopyView;\\n function(uint256, uint256, uint256) internal pure pureMemcopy;\\n /// @solidity memory-safe-assembly\\n assembly {\\n pureMemcopy := fnIn\\n }\\n pureMemcopy(fromOffset, toOffset, length);\\n }\\n\\n function _memcopyView(uint256 fromOffset, uint256 toOffset, uint256 length) private view {\\n /// @solidity memory-safe-assembly\\n assembly {\\n pop(staticcall(gas(), 0x4, fromOffset, length, toOffset, length))\\n }\\n }\\n\\n function logMemory(uint256 offset, uint256 length) internal pure {\\n if (offset >= 0x60) {\\n // Sufficient memory before slice to prepare call header.\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(sub(offset, 0x60))\\n m1 := mload(sub(offset, 0x40))\\n m2 := mload(sub(offset, 0x20))\\n // Selector of `log(bytes)`.\\n mstore(sub(offset, 0x60), 0x0be77f56)\\n mstore(sub(offset, 0x40), 0x20)\\n mstore(sub(offset, 0x20), length)\\n }\\n _sendLogPayload(offset - 0x44, length + 0x44);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(sub(offset, 0x60), m0)\\n mstore(sub(offset, 0x40), m1)\\n mstore(sub(offset, 0x20), m2)\\n }\\n } else {\\n // Insufficient space, so copy slice forward, add header and reverse.\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n uint256 endOffset = offset + length;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(add(endOffset, 0x00))\\n m1 := mload(add(endOffset, 0x20))\\n m2 := mload(add(endOffset, 0x40))\\n }\\n _memcopy(offset, offset + 0x60, length);\\n /// @solidity memory-safe-assembly\\n assembly {\\n // Selector of `log(bytes)`.\\n mstore(add(offset, 0x00), 0x0be77f56)\\n mstore(add(offset, 0x20), 0x20)\\n mstore(add(offset, 0x40), length)\\n }\\n _sendLogPayload(offset + 0x1c, length + 0x44);\\n _memcopy(offset + 0x60, offset, length);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(add(endOffset, 0x00), m0)\\n mstore(add(endOffset, 0x20), m1)\\n mstore(add(endOffset, 0x40), m2)\\n }\\n }\\n }\\n\\n function log(address p0) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n // Selector of `log(address)`.\\n mstore(0x00, 0x2c2ecbc2)\\n mstore(0x20, p0)\\n }\\n _sendLogPayload(0x1c, 0x24);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n }\\n }\\n\\n function log(bool p0) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n // Selector of `log(bool)`.\\n mstore(0x00, 0x32458eed)\\n mstore(0x20, p0)\\n }\\n _sendLogPayload(0x1c, 0x24);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n }\\n }\\n\\n function log(uint256 p0) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n // Selector of `log(uint256)`.\\n mstore(0x00, 0xf82c50f1)\\n mstore(0x20, p0)\\n }\\n _sendLogPayload(0x1c, 0x24);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n }\\n }\\n\\n function log(bytes32 p0) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n // Selector of `log(string)`.\\n mstore(0x00, 0x41304fac)\\n mstore(0x20, 0x20)\\n writeString(0x40, p0)\\n }\\n _sendLogPayload(0x1c, 0x64);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n }\\n }\\n\\n function log(address p0, address p1) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n // Selector of `log(address,address)`.\\n mstore(0x00, 0xdaf0d4aa)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n }\\n _sendLogPayload(0x1c, 0x44);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n }\\n }\\n\\n function log(address p0, bool p1) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n // Selector of `log(address,bool)`.\\n mstore(0x00, 0x75b605d3)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n }\\n _sendLogPayload(0x1c, 0x44);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n }\\n }\\n\\n function log(address p0, uint256 p1) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n // Selector of `log(address,uint256)`.\\n mstore(0x00, 0x8309e8a8)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n }\\n _sendLogPayload(0x1c, 0x44);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n }\\n }\\n\\n function log(address p0, bytes32 p1) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(address,string)`.\\n mstore(0x00, 0x759f86bb)\\n mstore(0x20, p0)\\n mstore(0x40, 0x40)\\n writeString(0x60, p1)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(bool p0, address p1) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n // Selector of `log(bool,address)`.\\n mstore(0x00, 0x853c4849)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n }\\n _sendLogPayload(0x1c, 0x44);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n }\\n }\\n\\n function log(bool p0, bool p1) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n // Selector of `log(bool,bool)`.\\n mstore(0x00, 0x2a110e83)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n }\\n _sendLogPayload(0x1c, 0x44);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n }\\n }\\n\\n function log(bool p0, uint256 p1) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n // Selector of `log(bool,uint256)`.\\n mstore(0x00, 0x399174d3)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n }\\n _sendLogPayload(0x1c, 0x44);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n }\\n }\\n\\n function log(bool p0, bytes32 p1) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(bool,string)`.\\n mstore(0x00, 0x8feac525)\\n mstore(0x20, p0)\\n mstore(0x40, 0x40)\\n writeString(0x60, p1)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(uint256 p0, address p1) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n // Selector of `log(uint256,address)`.\\n mstore(0x00, 0x69276c86)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n }\\n _sendLogPayload(0x1c, 0x44);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n }\\n }\\n\\n function log(uint256 p0, bool p1) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n // Selector of `log(uint256,bool)`.\\n mstore(0x00, 0x1c9d7eb3)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n }\\n _sendLogPayload(0x1c, 0x44);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n }\\n }\\n\\n function log(uint256 p0, uint256 p1) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n // Selector of `log(uint256,uint256)`.\\n mstore(0x00, 0xf666715a)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n }\\n _sendLogPayload(0x1c, 0x44);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n }\\n }\\n\\n function log(uint256 p0, bytes32 p1) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(uint256,string)`.\\n mstore(0x00, 0x643fd0df)\\n mstore(0x20, p0)\\n mstore(0x40, 0x40)\\n writeString(0x60, p1)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(bytes32 p0, address p1) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(string,address)`.\\n mstore(0x00, 0x319af333)\\n mstore(0x20, 0x40)\\n mstore(0x40, p1)\\n writeString(0x60, p0)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(bytes32 p0, bool p1) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(string,bool)`.\\n mstore(0x00, 0xc3b55635)\\n mstore(0x20, 0x40)\\n mstore(0x40, p1)\\n writeString(0x60, p0)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(bytes32 p0, uint256 p1) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(string,uint256)`.\\n mstore(0x00, 0xb60e72cc)\\n mstore(0x20, 0x40)\\n mstore(0x40, p1)\\n writeString(0x60, p0)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(bytes32 p0, bytes32 p1) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(string,string)`.\\n mstore(0x00, 0x4b5c4277)\\n mstore(0x20, 0x40)\\n mstore(0x40, 0x80)\\n writeString(0x60, p0)\\n writeString(0xa0, p1)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(address p0, address p1, address p2) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n // Selector of `log(address,address,address)`.\\n mstore(0x00, 0x018c84c2)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n }\\n _sendLogPayload(0x1c, 0x64);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n }\\n }\\n\\n function log(address p0, address p1, bool p2) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n // Selector of `log(address,address,bool)`.\\n mstore(0x00, 0xf2a66286)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n }\\n _sendLogPayload(0x1c, 0x64);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n }\\n }\\n\\n function log(address p0, address p1, uint256 p2) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n // Selector of `log(address,address,uint256)`.\\n mstore(0x00, 0x17fe6185)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n }\\n _sendLogPayload(0x1c, 0x64);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n }\\n }\\n\\n function log(address p0, address p1, bytes32 p2) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n // Selector of `log(address,address,string)`.\\n mstore(0x00, 0x007150be)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, 0x60)\\n writeString(0x80, p2)\\n }\\n _sendLogPayload(0x1c, 0xa4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n }\\n }\\n\\n function log(address p0, bool p1, address p2) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n // Selector of `log(address,bool,address)`.\\n mstore(0x00, 0xf11699ed)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n }\\n _sendLogPayload(0x1c, 0x64);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n }\\n }\\n\\n function log(address p0, bool p1, bool p2) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n // Selector of `log(address,bool,bool)`.\\n mstore(0x00, 0xeb830c92)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n }\\n _sendLogPayload(0x1c, 0x64);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n }\\n }\\n\\n function log(address p0, bool p1, uint256 p2) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n // Selector of `log(address,bool,uint256)`.\\n mstore(0x00, 0x9c4f99fb)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n }\\n _sendLogPayload(0x1c, 0x64);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n }\\n }\\n\\n function log(address p0, bool p1, bytes32 p2) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n // Selector of `log(address,bool,string)`.\\n mstore(0x00, 0x212255cc)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, 0x60)\\n writeString(0x80, p2)\\n }\\n _sendLogPayload(0x1c, 0xa4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n }\\n }\\n\\n function log(address p0, uint256 p1, address p2) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n // Selector of `log(address,uint256,address)`.\\n mstore(0x00, 0x7bc0d848)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n }\\n _sendLogPayload(0x1c, 0x64);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n }\\n }\\n\\n function log(address p0, uint256 p1, bool p2) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n // Selector of `log(address,uint256,bool)`.\\n mstore(0x00, 0x678209a8)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n }\\n _sendLogPayload(0x1c, 0x64);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n }\\n }\\n\\n function log(address p0, uint256 p1, uint256 p2) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n // Selector of `log(address,uint256,uint256)`.\\n mstore(0x00, 0xb69bcaf6)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n }\\n _sendLogPayload(0x1c, 0x64);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n }\\n }\\n\\n function log(address p0, uint256 p1, bytes32 p2) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n // Selector of `log(address,uint256,string)`.\\n mstore(0x00, 0xa1f2e8aa)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, 0x60)\\n writeString(0x80, p2)\\n }\\n _sendLogPayload(0x1c, 0xa4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n }\\n }\\n\\n function log(address p0, bytes32 p1, address p2) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n // Selector of `log(address,string,address)`.\\n mstore(0x00, 0xf08744e8)\\n mstore(0x20, p0)\\n mstore(0x40, 0x60)\\n mstore(0x60, p2)\\n writeString(0x80, p1)\\n }\\n _sendLogPayload(0x1c, 0xa4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n }\\n }\\n\\n function log(address p0, bytes32 p1, bool p2) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n // Selector of `log(address,string,bool)`.\\n mstore(0x00, 0xcf020fb1)\\n mstore(0x20, p0)\\n mstore(0x40, 0x60)\\n mstore(0x60, p2)\\n writeString(0x80, p1)\\n }\\n _sendLogPayload(0x1c, 0xa4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n }\\n }\\n\\n function log(address p0, bytes32 p1, uint256 p2) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n // Selector of `log(address,string,uint256)`.\\n mstore(0x00, 0x67dd6ff1)\\n mstore(0x20, p0)\\n mstore(0x40, 0x60)\\n mstore(0x60, p2)\\n writeString(0x80, p1)\\n }\\n _sendLogPayload(0x1c, 0xa4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n }\\n }\\n\\n function log(address p0, bytes32 p1, bytes32 p2) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n // Selector of `log(address,string,string)`.\\n mstore(0x00, 0xfb772265)\\n mstore(0x20, p0)\\n mstore(0x40, 0x60)\\n mstore(0x60, 0xa0)\\n writeString(0x80, p1)\\n writeString(0xc0, p2)\\n }\\n _sendLogPayload(0x1c, 0xe4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n }\\n }\\n\\n function log(bool p0, address p1, address p2) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n // Selector of `log(bool,address,address)`.\\n mstore(0x00, 0xd2763667)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n }\\n _sendLogPayload(0x1c, 0x64);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n }\\n }\\n\\n function log(bool p0, address p1, bool p2) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n // Selector of `log(bool,address,bool)`.\\n mstore(0x00, 0x18c9c746)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n }\\n _sendLogPayload(0x1c, 0x64);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n }\\n }\\n\\n function log(bool p0, address p1, uint256 p2) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n // Selector of `log(bool,address,uint256)`.\\n mstore(0x00, 0x5f7b9afb)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n }\\n _sendLogPayload(0x1c, 0x64);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n }\\n }\\n\\n function log(bool p0, address p1, bytes32 p2) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n // Selector of `log(bool,address,string)`.\\n mstore(0x00, 0xde9a9270)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, 0x60)\\n writeString(0x80, p2)\\n }\\n _sendLogPayload(0x1c, 0xa4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n }\\n }\\n\\n function log(bool p0, bool p1, address p2) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n // Selector of `log(bool,bool,address)`.\\n mstore(0x00, 0x1078f68d)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n }\\n _sendLogPayload(0x1c, 0x64);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n }\\n }\\n\\n function log(bool p0, bool p1, bool p2) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n // Selector of `log(bool,bool,bool)`.\\n mstore(0x00, 0x50709698)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n }\\n _sendLogPayload(0x1c, 0x64);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n }\\n }\\n\\n function log(bool p0, bool p1, uint256 p2) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n // Selector of `log(bool,bool,uint256)`.\\n mstore(0x00, 0x12f21602)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n }\\n _sendLogPayload(0x1c, 0x64);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n }\\n }\\n\\n function log(bool p0, bool p1, bytes32 p2) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n // Selector of `log(bool,bool,string)`.\\n mstore(0x00, 0x2555fa46)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, 0x60)\\n writeString(0x80, p2)\\n }\\n _sendLogPayload(0x1c, 0xa4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n }\\n }\\n\\n function log(bool p0, uint256 p1, address p2) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n // Selector of `log(bool,uint256,address)`.\\n mstore(0x00, 0x088ef9d2)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n }\\n _sendLogPayload(0x1c, 0x64);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n }\\n }\\n\\n function log(bool p0, uint256 p1, bool p2) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n // Selector of `log(bool,uint256,bool)`.\\n mstore(0x00, 0xe8defba9)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n }\\n _sendLogPayload(0x1c, 0x64);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n }\\n }\\n\\n function log(bool p0, uint256 p1, uint256 p2) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n // Selector of `log(bool,uint256,uint256)`.\\n mstore(0x00, 0x37103367)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n }\\n _sendLogPayload(0x1c, 0x64);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n }\\n }\\n\\n function log(bool p0, uint256 p1, bytes32 p2) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n // Selector of `log(bool,uint256,string)`.\\n mstore(0x00, 0xc3fc3970)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, 0x60)\\n writeString(0x80, p2)\\n }\\n _sendLogPayload(0x1c, 0xa4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n }\\n }\\n\\n function log(bool p0, bytes32 p1, address p2) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n // Selector of `log(bool,string,address)`.\\n mstore(0x00, 0x9591b953)\\n mstore(0x20, p0)\\n mstore(0x40, 0x60)\\n mstore(0x60, p2)\\n writeString(0x80, p1)\\n }\\n _sendLogPayload(0x1c, 0xa4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n }\\n }\\n\\n function log(bool p0, bytes32 p1, bool p2) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n // Selector of `log(bool,string,bool)`.\\n mstore(0x00, 0xdbb4c247)\\n mstore(0x20, p0)\\n mstore(0x40, 0x60)\\n mstore(0x60, p2)\\n writeString(0x80, p1)\\n }\\n _sendLogPayload(0x1c, 0xa4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n }\\n }\\n\\n function log(bool p0, bytes32 p1, uint256 p2) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n // Selector of `log(bool,string,uint256)`.\\n mstore(0x00, 0x1093ee11)\\n mstore(0x20, p0)\\n mstore(0x40, 0x60)\\n mstore(0x60, p2)\\n writeString(0x80, p1)\\n }\\n _sendLogPayload(0x1c, 0xa4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n }\\n }\\n\\n function log(bool p0, bytes32 p1, bytes32 p2) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n // Selector of `log(bool,string,string)`.\\n mstore(0x00, 0xb076847f)\\n mstore(0x20, p0)\\n mstore(0x40, 0x60)\\n mstore(0x60, 0xa0)\\n writeString(0x80, p1)\\n writeString(0xc0, p2)\\n }\\n _sendLogPayload(0x1c, 0xe4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n }\\n }\\n\\n function log(uint256 p0, address p1, address p2) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n // Selector of `log(uint256,address,address)`.\\n mstore(0x00, 0xbcfd9be0)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n }\\n _sendLogPayload(0x1c, 0x64);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n }\\n }\\n\\n function log(uint256 p0, address p1, bool p2) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n // Selector of `log(uint256,address,bool)`.\\n mstore(0x00, 0x9b6ec042)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n }\\n _sendLogPayload(0x1c, 0x64);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n }\\n }\\n\\n function log(uint256 p0, address p1, uint256 p2) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n // Selector of `log(uint256,address,uint256)`.\\n mstore(0x00, 0x5a9b5ed5)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n }\\n _sendLogPayload(0x1c, 0x64);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n }\\n }\\n\\n function log(uint256 p0, address p1, bytes32 p2) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n // Selector of `log(uint256,address,string)`.\\n mstore(0x00, 0x63cb41f9)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, 0x60)\\n writeString(0x80, p2)\\n }\\n _sendLogPayload(0x1c, 0xa4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n }\\n }\\n\\n function log(uint256 p0, bool p1, address p2) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n // Selector of `log(uint256,bool,address)`.\\n mstore(0x00, 0x35085f7b)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n }\\n _sendLogPayload(0x1c, 0x64);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n }\\n }\\n\\n function log(uint256 p0, bool p1, bool p2) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n // Selector of `log(uint256,bool,bool)`.\\n mstore(0x00, 0x20718650)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n }\\n _sendLogPayload(0x1c, 0x64);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n }\\n }\\n\\n function log(uint256 p0, bool p1, uint256 p2) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n // Selector of `log(uint256,bool,uint256)`.\\n mstore(0x00, 0x20098014)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n }\\n _sendLogPayload(0x1c, 0x64);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n }\\n }\\n\\n function log(uint256 p0, bool p1, bytes32 p2) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n // Selector of `log(uint256,bool,string)`.\\n mstore(0x00, 0x85775021)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, 0x60)\\n writeString(0x80, p2)\\n }\\n _sendLogPayload(0x1c, 0xa4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n }\\n }\\n\\n function log(uint256 p0, uint256 p1, address p2) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n // Selector of `log(uint256,uint256,address)`.\\n mstore(0x00, 0x5c96b331)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n }\\n _sendLogPayload(0x1c, 0x64);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n }\\n }\\n\\n function log(uint256 p0, uint256 p1, bool p2) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n // Selector of `log(uint256,uint256,bool)`.\\n mstore(0x00, 0x4766da72)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n }\\n _sendLogPayload(0x1c, 0x64);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n }\\n }\\n\\n function log(uint256 p0, uint256 p1, uint256 p2) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n // Selector of `log(uint256,uint256,uint256)`.\\n mstore(0x00, 0xd1ed7a3c)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n }\\n _sendLogPayload(0x1c, 0x64);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n }\\n }\\n\\n function log(uint256 p0, uint256 p1, bytes32 p2) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n // Selector of `log(uint256,uint256,string)`.\\n mstore(0x00, 0x71d04af2)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, 0x60)\\n writeString(0x80, p2)\\n }\\n _sendLogPayload(0x1c, 0xa4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n }\\n }\\n\\n function log(uint256 p0, bytes32 p1, address p2) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n // Selector of `log(uint256,string,address)`.\\n mstore(0x00, 0x7afac959)\\n mstore(0x20, p0)\\n mstore(0x40, 0x60)\\n mstore(0x60, p2)\\n writeString(0x80, p1)\\n }\\n _sendLogPayload(0x1c, 0xa4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n }\\n }\\n\\n function log(uint256 p0, bytes32 p1, bool p2) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n // Selector of `log(uint256,string,bool)`.\\n mstore(0x00, 0x4ceda75a)\\n mstore(0x20, p0)\\n mstore(0x40, 0x60)\\n mstore(0x60, p2)\\n writeString(0x80, p1)\\n }\\n _sendLogPayload(0x1c, 0xa4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n }\\n }\\n\\n function log(uint256 p0, bytes32 p1, uint256 p2) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n // Selector of `log(uint256,string,uint256)`.\\n mstore(0x00, 0x37aa7d4c)\\n mstore(0x20, p0)\\n mstore(0x40, 0x60)\\n mstore(0x60, p2)\\n writeString(0x80, p1)\\n }\\n _sendLogPayload(0x1c, 0xa4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n }\\n }\\n\\n function log(uint256 p0, bytes32 p1, bytes32 p2) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n // Selector of `log(uint256,string,string)`.\\n mstore(0x00, 0xb115611f)\\n mstore(0x20, p0)\\n mstore(0x40, 0x60)\\n mstore(0x60, 0xa0)\\n writeString(0x80, p1)\\n writeString(0xc0, p2)\\n }\\n _sendLogPayload(0x1c, 0xe4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n }\\n }\\n\\n function log(bytes32 p0, address p1, address p2) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n // Selector of `log(string,address,address)`.\\n mstore(0x00, 0xfcec75e0)\\n mstore(0x20, 0x60)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n writeString(0x80, p0)\\n }\\n _sendLogPayload(0x1c, 0xa4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n }\\n }\\n\\n function log(bytes32 p0, address p1, bool p2) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n // Selector of `log(string,address,bool)`.\\n mstore(0x00, 0xc91d5ed4)\\n mstore(0x20, 0x60)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n writeString(0x80, p0)\\n }\\n _sendLogPayload(0x1c, 0xa4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n }\\n }\\n\\n function log(bytes32 p0, address p1, uint256 p2) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n // Selector of `log(string,address,uint256)`.\\n mstore(0x00, 0x0d26b925)\\n mstore(0x20, 0x60)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n writeString(0x80, p0)\\n }\\n _sendLogPayload(0x1c, 0xa4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n }\\n }\\n\\n function log(bytes32 p0, address p1, bytes32 p2) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n // Selector of `log(string,address,string)`.\\n mstore(0x00, 0xe0e9ad4f)\\n mstore(0x20, 0x60)\\n mstore(0x40, p1)\\n mstore(0x60, 0xa0)\\n writeString(0x80, p0)\\n writeString(0xc0, p2)\\n }\\n _sendLogPayload(0x1c, 0xe4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n }\\n }\\n\\n function log(bytes32 p0, bool p1, address p2) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n // Selector of `log(string,bool,address)`.\\n mstore(0x00, 0x932bbb38)\\n mstore(0x20, 0x60)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n writeString(0x80, p0)\\n }\\n _sendLogPayload(0x1c, 0xa4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n }\\n }\\n\\n function log(bytes32 p0, bool p1, bool p2) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n // Selector of `log(string,bool,bool)`.\\n mstore(0x00, 0x850b7ad6)\\n mstore(0x20, 0x60)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n writeString(0x80, p0)\\n }\\n _sendLogPayload(0x1c, 0xa4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n }\\n }\\n\\n function log(bytes32 p0, bool p1, uint256 p2) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n // Selector of `log(string,bool,uint256)`.\\n mstore(0x00, 0xc95958d6)\\n mstore(0x20, 0x60)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n writeString(0x80, p0)\\n }\\n _sendLogPayload(0x1c, 0xa4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n }\\n }\\n\\n function log(bytes32 p0, bool p1, bytes32 p2) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n // Selector of `log(string,bool,string)`.\\n mstore(0x00, 0xe298f47d)\\n mstore(0x20, 0x60)\\n mstore(0x40, p1)\\n mstore(0x60, 0xa0)\\n writeString(0x80, p0)\\n writeString(0xc0, p2)\\n }\\n _sendLogPayload(0x1c, 0xe4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n }\\n }\\n\\n function log(bytes32 p0, uint256 p1, address p2) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n // Selector of `log(string,uint256,address)`.\\n mstore(0x00, 0x1c7ec448)\\n mstore(0x20, 0x60)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n writeString(0x80, p0)\\n }\\n _sendLogPayload(0x1c, 0xa4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n }\\n }\\n\\n function log(bytes32 p0, uint256 p1, bool p2) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n // Selector of `log(string,uint256,bool)`.\\n mstore(0x00, 0xca7733b1)\\n mstore(0x20, 0x60)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n writeString(0x80, p0)\\n }\\n _sendLogPayload(0x1c, 0xa4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n }\\n }\\n\\n function log(bytes32 p0, uint256 p1, uint256 p2) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n // Selector of `log(string,uint256,uint256)`.\\n mstore(0x00, 0xca47c4eb)\\n mstore(0x20, 0x60)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n writeString(0x80, p0)\\n }\\n _sendLogPayload(0x1c, 0xa4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n }\\n }\\n\\n function log(bytes32 p0, uint256 p1, bytes32 p2) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n // Selector of `log(string,uint256,string)`.\\n mstore(0x00, 0x5970e089)\\n mstore(0x20, 0x60)\\n mstore(0x40, p1)\\n mstore(0x60, 0xa0)\\n writeString(0x80, p0)\\n writeString(0xc0, p2)\\n }\\n _sendLogPayload(0x1c, 0xe4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n }\\n }\\n\\n function log(bytes32 p0, bytes32 p1, address p2) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n // Selector of `log(string,string,address)`.\\n mstore(0x00, 0x95ed0195)\\n mstore(0x20, 0x60)\\n mstore(0x40, 0xa0)\\n mstore(0x60, p2)\\n writeString(0x80, p0)\\n writeString(0xc0, p1)\\n }\\n _sendLogPayload(0x1c, 0xe4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n }\\n }\\n\\n function log(bytes32 p0, bytes32 p1, bool p2) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n // Selector of `log(string,string,bool)`.\\n mstore(0x00, 0xb0e0f9b5)\\n mstore(0x20, 0x60)\\n mstore(0x40, 0xa0)\\n mstore(0x60, p2)\\n writeString(0x80, p0)\\n writeString(0xc0, p1)\\n }\\n _sendLogPayload(0x1c, 0xe4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n }\\n }\\n\\n function log(bytes32 p0, bytes32 p1, uint256 p2) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n // Selector of `log(string,string,uint256)`.\\n mstore(0x00, 0x5821efa1)\\n mstore(0x20, 0x60)\\n mstore(0x40, 0xa0)\\n mstore(0x60, p2)\\n writeString(0x80, p0)\\n writeString(0xc0, p1)\\n }\\n _sendLogPayload(0x1c, 0xe4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n }\\n }\\n\\n function log(bytes32 p0, bytes32 p1, bytes32 p2) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n bytes32 m9;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n m9 := mload(0x120)\\n // Selector of `log(string,string,string)`.\\n mstore(0x00, 0x2ced7cef)\\n mstore(0x20, 0x60)\\n mstore(0x40, 0xa0)\\n mstore(0x60, 0xe0)\\n writeString(0x80, p0)\\n writeString(0xc0, p1)\\n writeString(0x100, p2)\\n }\\n _sendLogPayload(0x1c, 0x124);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n mstore(0x120, m9)\\n }\\n }\\n\\n function log(address p0, address p1, address p2, address p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(address,address,address,address)`.\\n mstore(0x00, 0x665bf134)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(address p0, address p1, address p2, bool p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(address,address,address,bool)`.\\n mstore(0x00, 0x0e378994)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(address p0, address p1, address p2, uint256 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(address,address,address,uint256)`.\\n mstore(0x00, 0x94250d77)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(address p0, address p1, address p2, bytes32 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(address,address,address,string)`.\\n mstore(0x00, 0xf808da20)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, 0x80)\\n writeString(0xa0, p3)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(address p0, address p1, bool p2, address p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(address,address,bool,address)`.\\n mstore(0x00, 0x9f1bc36e)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(address p0, address p1, bool p2, bool p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(address,address,bool,bool)`.\\n mstore(0x00, 0x2cd4134a)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(address p0, address p1, bool p2, uint256 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(address,address,bool,uint256)`.\\n mstore(0x00, 0x3971e78c)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(address p0, address p1, bool p2, bytes32 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(address,address,bool,string)`.\\n mstore(0x00, 0xaa6540c8)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, 0x80)\\n writeString(0xa0, p3)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(address p0, address p1, uint256 p2, address p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(address,address,uint256,address)`.\\n mstore(0x00, 0x8da6def5)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(address p0, address p1, uint256 p2, bool p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(address,address,uint256,bool)`.\\n mstore(0x00, 0x9b4254e2)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(address p0, address p1, uint256 p2, uint256 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(address,address,uint256,uint256)`.\\n mstore(0x00, 0xbe553481)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(address p0, address p1, uint256 p2, bytes32 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(address,address,uint256,string)`.\\n mstore(0x00, 0xfdb4f990)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, 0x80)\\n writeString(0xa0, p3)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(address p0, address p1, bytes32 p2, address p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(address,address,string,address)`.\\n mstore(0x00, 0x8f736d16)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, 0x80)\\n mstore(0x80, p3)\\n writeString(0xa0, p2)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(address p0, address p1, bytes32 p2, bool p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(address,address,string,bool)`.\\n mstore(0x00, 0x6f1a594e)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, 0x80)\\n mstore(0x80, p3)\\n writeString(0xa0, p2)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(address p0, address p1, bytes32 p2, uint256 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(address,address,string,uint256)`.\\n mstore(0x00, 0xef1cefe7)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, 0x80)\\n mstore(0x80, p3)\\n writeString(0xa0, p2)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(address p0, address p1, bytes32 p2, bytes32 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n // Selector of `log(address,address,string,string)`.\\n mstore(0x00, 0x21bdaf25)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, 0x80)\\n mstore(0x80, 0xc0)\\n writeString(0xa0, p2)\\n writeString(0xe0, p3)\\n }\\n _sendLogPayload(0x1c, 0x104);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n }\\n }\\n\\n function log(address p0, bool p1, address p2, address p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(address,bool,address,address)`.\\n mstore(0x00, 0x660375dd)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(address p0, bool p1, address p2, bool p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(address,bool,address,bool)`.\\n mstore(0x00, 0xa6f50b0f)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(address p0, bool p1, address p2, uint256 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(address,bool,address,uint256)`.\\n mstore(0x00, 0xa75c59de)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(address p0, bool p1, address p2, bytes32 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(address,bool,address,string)`.\\n mstore(0x00, 0x2dd778e6)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, 0x80)\\n writeString(0xa0, p3)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(address p0, bool p1, bool p2, address p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(address,bool,bool,address)`.\\n mstore(0x00, 0xcf394485)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(address p0, bool p1, bool p2, bool p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(address,bool,bool,bool)`.\\n mstore(0x00, 0xcac43479)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(address p0, bool p1, bool p2, uint256 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(address,bool,bool,uint256)`.\\n mstore(0x00, 0x8c4e5de6)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(address p0, bool p1, bool p2, bytes32 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(address,bool,bool,string)`.\\n mstore(0x00, 0xdfc4a2e8)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, 0x80)\\n writeString(0xa0, p3)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(address p0, bool p1, uint256 p2, address p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(address,bool,uint256,address)`.\\n mstore(0x00, 0xccf790a1)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(address p0, bool p1, uint256 p2, bool p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(address,bool,uint256,bool)`.\\n mstore(0x00, 0xc4643e20)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(address p0, bool p1, uint256 p2, uint256 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(address,bool,uint256,uint256)`.\\n mstore(0x00, 0x386ff5f4)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(address p0, bool p1, uint256 p2, bytes32 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(address,bool,uint256,string)`.\\n mstore(0x00, 0x0aa6cfad)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, 0x80)\\n writeString(0xa0, p3)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(address p0, bool p1, bytes32 p2, address p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(address,bool,string,address)`.\\n mstore(0x00, 0x19fd4956)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, 0x80)\\n mstore(0x80, p3)\\n writeString(0xa0, p2)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(address p0, bool p1, bytes32 p2, bool p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(address,bool,string,bool)`.\\n mstore(0x00, 0x50ad461d)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, 0x80)\\n mstore(0x80, p3)\\n writeString(0xa0, p2)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(address p0, bool p1, bytes32 p2, uint256 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(address,bool,string,uint256)`.\\n mstore(0x00, 0x80e6a20b)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, 0x80)\\n mstore(0x80, p3)\\n writeString(0xa0, p2)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(address p0, bool p1, bytes32 p2, bytes32 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n // Selector of `log(address,bool,string,string)`.\\n mstore(0x00, 0x475c5c33)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, 0x80)\\n mstore(0x80, 0xc0)\\n writeString(0xa0, p2)\\n writeString(0xe0, p3)\\n }\\n _sendLogPayload(0x1c, 0x104);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n }\\n }\\n\\n function log(address p0, uint256 p1, address p2, address p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(address,uint256,address,address)`.\\n mstore(0x00, 0x478d1c62)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(address p0, uint256 p1, address p2, bool p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(address,uint256,address,bool)`.\\n mstore(0x00, 0xa1bcc9b3)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(address p0, uint256 p1, address p2, uint256 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(address,uint256,address,uint256)`.\\n mstore(0x00, 0x100f650e)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(address p0, uint256 p1, address p2, bytes32 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(address,uint256,address,string)`.\\n mstore(0x00, 0x1da986ea)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, 0x80)\\n writeString(0xa0, p3)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(address p0, uint256 p1, bool p2, address p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(address,uint256,bool,address)`.\\n mstore(0x00, 0xa31bfdcc)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(address p0, uint256 p1, bool p2, bool p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(address,uint256,bool,bool)`.\\n mstore(0x00, 0x3bf5e537)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(address p0, uint256 p1, bool p2, uint256 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(address,uint256,bool,uint256)`.\\n mstore(0x00, 0x22f6b999)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(address p0, uint256 p1, bool p2, bytes32 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(address,uint256,bool,string)`.\\n mstore(0x00, 0xc5ad85f9)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, 0x80)\\n writeString(0xa0, p3)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(address p0, uint256 p1, uint256 p2, address p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(address,uint256,uint256,address)`.\\n mstore(0x00, 0x20e3984d)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(address p0, uint256 p1, uint256 p2, bool p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(address,uint256,uint256,bool)`.\\n mstore(0x00, 0x66f1bc67)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(address p0, uint256 p1, uint256 p2, uint256 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(address,uint256,uint256,uint256)`.\\n mstore(0x00, 0x34f0e636)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(address p0, uint256 p1, uint256 p2, bytes32 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(address,uint256,uint256,string)`.\\n mstore(0x00, 0x4a28c017)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, 0x80)\\n writeString(0xa0, p3)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(address p0, uint256 p1, bytes32 p2, address p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(address,uint256,string,address)`.\\n mstore(0x00, 0x5c430d47)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, 0x80)\\n mstore(0x80, p3)\\n writeString(0xa0, p2)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(address p0, uint256 p1, bytes32 p2, bool p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(address,uint256,string,bool)`.\\n mstore(0x00, 0xcf18105c)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, 0x80)\\n mstore(0x80, p3)\\n writeString(0xa0, p2)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(address p0, uint256 p1, bytes32 p2, uint256 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(address,uint256,string,uint256)`.\\n mstore(0x00, 0xbf01f891)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, 0x80)\\n mstore(0x80, p3)\\n writeString(0xa0, p2)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(address p0, uint256 p1, bytes32 p2, bytes32 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n // Selector of `log(address,uint256,string,string)`.\\n mstore(0x00, 0x88a8c406)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, 0x80)\\n mstore(0x80, 0xc0)\\n writeString(0xa0, p2)\\n writeString(0xe0, p3)\\n }\\n _sendLogPayload(0x1c, 0x104);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n }\\n }\\n\\n function log(address p0, bytes32 p1, address p2, address p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(address,string,address,address)`.\\n mstore(0x00, 0x0d36fa20)\\n mstore(0x20, p0)\\n mstore(0x40, 0x80)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n writeString(0xa0, p1)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(address p0, bytes32 p1, address p2, bool p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(address,string,address,bool)`.\\n mstore(0x00, 0x0df12b76)\\n mstore(0x20, p0)\\n mstore(0x40, 0x80)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n writeString(0xa0, p1)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(address p0, bytes32 p1, address p2, uint256 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(address,string,address,uint256)`.\\n mstore(0x00, 0x457fe3cf)\\n mstore(0x20, p0)\\n mstore(0x40, 0x80)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n writeString(0xa0, p1)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(address p0, bytes32 p1, address p2, bytes32 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n // Selector of `log(address,string,address,string)`.\\n mstore(0x00, 0xf7e36245)\\n mstore(0x20, p0)\\n mstore(0x40, 0x80)\\n mstore(0x60, p2)\\n mstore(0x80, 0xc0)\\n writeString(0xa0, p1)\\n writeString(0xe0, p3)\\n }\\n _sendLogPayload(0x1c, 0x104);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n }\\n }\\n\\n function log(address p0, bytes32 p1, bool p2, address p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(address,string,bool,address)`.\\n mstore(0x00, 0x205871c2)\\n mstore(0x20, p0)\\n mstore(0x40, 0x80)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n writeString(0xa0, p1)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(address p0, bytes32 p1, bool p2, bool p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(address,string,bool,bool)`.\\n mstore(0x00, 0x5f1d5c9f)\\n mstore(0x20, p0)\\n mstore(0x40, 0x80)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n writeString(0xa0, p1)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(address p0, bytes32 p1, bool p2, uint256 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(address,string,bool,uint256)`.\\n mstore(0x00, 0x515e38b6)\\n mstore(0x20, p0)\\n mstore(0x40, 0x80)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n writeString(0xa0, p1)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(address p0, bytes32 p1, bool p2, bytes32 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n // Selector of `log(address,string,bool,string)`.\\n mstore(0x00, 0xbc0b61fe)\\n mstore(0x20, p0)\\n mstore(0x40, 0x80)\\n mstore(0x60, p2)\\n mstore(0x80, 0xc0)\\n writeString(0xa0, p1)\\n writeString(0xe0, p3)\\n }\\n _sendLogPayload(0x1c, 0x104);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n }\\n }\\n\\n function log(address p0, bytes32 p1, uint256 p2, address p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(address,string,uint256,address)`.\\n mstore(0x00, 0x63183678)\\n mstore(0x20, p0)\\n mstore(0x40, 0x80)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n writeString(0xa0, p1)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(address p0, bytes32 p1, uint256 p2, bool p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(address,string,uint256,bool)`.\\n mstore(0x00, 0x0ef7e050)\\n mstore(0x20, p0)\\n mstore(0x40, 0x80)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n writeString(0xa0, p1)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(address p0, bytes32 p1, uint256 p2, uint256 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(address,string,uint256,uint256)`.\\n mstore(0x00, 0x1dc8e1b8)\\n mstore(0x20, p0)\\n mstore(0x40, 0x80)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n writeString(0xa0, p1)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(address p0, bytes32 p1, uint256 p2, bytes32 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n // Selector of `log(address,string,uint256,string)`.\\n mstore(0x00, 0x448830a8)\\n mstore(0x20, p0)\\n mstore(0x40, 0x80)\\n mstore(0x60, p2)\\n mstore(0x80, 0xc0)\\n writeString(0xa0, p1)\\n writeString(0xe0, p3)\\n }\\n _sendLogPayload(0x1c, 0x104);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n }\\n }\\n\\n function log(address p0, bytes32 p1, bytes32 p2, address p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n // Selector of `log(address,string,string,address)`.\\n mstore(0x00, 0xa04e2f87)\\n mstore(0x20, p0)\\n mstore(0x40, 0x80)\\n mstore(0x60, 0xc0)\\n mstore(0x80, p3)\\n writeString(0xa0, p1)\\n writeString(0xe0, p2)\\n }\\n _sendLogPayload(0x1c, 0x104);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n }\\n }\\n\\n function log(address p0, bytes32 p1, bytes32 p2, bool p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n // Selector of `log(address,string,string,bool)`.\\n mstore(0x00, 0x35a5071f)\\n mstore(0x20, p0)\\n mstore(0x40, 0x80)\\n mstore(0x60, 0xc0)\\n mstore(0x80, p3)\\n writeString(0xa0, p1)\\n writeString(0xe0, p2)\\n }\\n _sendLogPayload(0x1c, 0x104);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n }\\n }\\n\\n function log(address p0, bytes32 p1, bytes32 p2, uint256 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n // Selector of `log(address,string,string,uint256)`.\\n mstore(0x00, 0x159f8927)\\n mstore(0x20, p0)\\n mstore(0x40, 0x80)\\n mstore(0x60, 0xc0)\\n mstore(0x80, p3)\\n writeString(0xa0, p1)\\n writeString(0xe0, p2)\\n }\\n _sendLogPayload(0x1c, 0x104);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n }\\n }\\n\\n function log(address p0, bytes32 p1, bytes32 p2, bytes32 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n bytes32 m9;\\n bytes32 m10;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n m9 := mload(0x120)\\n m10 := mload(0x140)\\n // Selector of `log(address,string,string,string)`.\\n mstore(0x00, 0x5d02c50b)\\n mstore(0x20, p0)\\n mstore(0x40, 0x80)\\n mstore(0x60, 0xc0)\\n mstore(0x80, 0x100)\\n writeString(0xa0, p1)\\n writeString(0xe0, p2)\\n writeString(0x120, p3)\\n }\\n _sendLogPayload(0x1c, 0x144);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n mstore(0x120, m9)\\n mstore(0x140, m10)\\n }\\n }\\n\\n function log(bool p0, address p1, address p2, address p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(bool,address,address,address)`.\\n mstore(0x00, 0x1d14d001)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(bool p0, address p1, address p2, bool p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(bool,address,address,bool)`.\\n mstore(0x00, 0x46600be0)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(bool p0, address p1, address p2, uint256 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(bool,address,address,uint256)`.\\n mstore(0x00, 0x0c66d1be)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(bool p0, address p1, address p2, bytes32 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(bool,address,address,string)`.\\n mstore(0x00, 0xd812a167)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, 0x80)\\n writeString(0xa0, p3)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(bool p0, address p1, bool p2, address p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(bool,address,bool,address)`.\\n mstore(0x00, 0x1c41a336)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(bool p0, address p1, bool p2, bool p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(bool,address,bool,bool)`.\\n mstore(0x00, 0x6a9c478b)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(bool p0, address p1, bool p2, uint256 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(bool,address,bool,uint256)`.\\n mstore(0x00, 0x07831502)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(bool p0, address p1, bool p2, bytes32 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(bool,address,bool,string)`.\\n mstore(0x00, 0x4a66cb34)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, 0x80)\\n writeString(0xa0, p3)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(bool p0, address p1, uint256 p2, address p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(bool,address,uint256,address)`.\\n mstore(0x00, 0x136b05dd)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(bool p0, address p1, uint256 p2, bool p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(bool,address,uint256,bool)`.\\n mstore(0x00, 0xd6019f1c)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(bool p0, address p1, uint256 p2, uint256 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(bool,address,uint256,uint256)`.\\n mstore(0x00, 0x7bf181a1)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(bool p0, address p1, uint256 p2, bytes32 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(bool,address,uint256,string)`.\\n mstore(0x00, 0x51f09ff8)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, 0x80)\\n writeString(0xa0, p3)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(bool p0, address p1, bytes32 p2, address p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(bool,address,string,address)`.\\n mstore(0x00, 0x6f7c603e)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, 0x80)\\n mstore(0x80, p3)\\n writeString(0xa0, p2)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(bool p0, address p1, bytes32 p2, bool p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(bool,address,string,bool)`.\\n mstore(0x00, 0xe2bfd60b)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, 0x80)\\n mstore(0x80, p3)\\n writeString(0xa0, p2)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(bool p0, address p1, bytes32 p2, uint256 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(bool,address,string,uint256)`.\\n mstore(0x00, 0xc21f64c7)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, 0x80)\\n mstore(0x80, p3)\\n writeString(0xa0, p2)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(bool p0, address p1, bytes32 p2, bytes32 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n // Selector of `log(bool,address,string,string)`.\\n mstore(0x00, 0xa73c1db6)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, 0x80)\\n mstore(0x80, 0xc0)\\n writeString(0xa0, p2)\\n writeString(0xe0, p3)\\n }\\n _sendLogPayload(0x1c, 0x104);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n }\\n }\\n\\n function log(bool p0, bool p1, address p2, address p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(bool,bool,address,address)`.\\n mstore(0x00, 0xf4880ea4)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(bool p0, bool p1, address p2, bool p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(bool,bool,address,bool)`.\\n mstore(0x00, 0xc0a302d8)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(bool p0, bool p1, address p2, uint256 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(bool,bool,address,uint256)`.\\n mstore(0x00, 0x4c123d57)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(bool p0, bool p1, address p2, bytes32 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(bool,bool,address,string)`.\\n mstore(0x00, 0xa0a47963)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, 0x80)\\n writeString(0xa0, p3)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(bool p0, bool p1, bool p2, address p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(bool,bool,bool,address)`.\\n mstore(0x00, 0x8c329b1a)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(bool p0, bool p1, bool p2, bool p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(bool,bool,bool,bool)`.\\n mstore(0x00, 0x3b2a5ce0)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(bool p0, bool p1, bool p2, uint256 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(bool,bool,bool,uint256)`.\\n mstore(0x00, 0x6d7045c1)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(bool p0, bool p1, bool p2, bytes32 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(bool,bool,bool,string)`.\\n mstore(0x00, 0x2ae408d4)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, 0x80)\\n writeString(0xa0, p3)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(bool p0, bool p1, uint256 p2, address p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(bool,bool,uint256,address)`.\\n mstore(0x00, 0x54a7a9a0)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(bool p0, bool p1, uint256 p2, bool p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(bool,bool,uint256,bool)`.\\n mstore(0x00, 0x619e4d0e)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(bool p0, bool p1, uint256 p2, uint256 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(bool,bool,uint256,uint256)`.\\n mstore(0x00, 0x0bb00eab)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(bool p0, bool p1, uint256 p2, bytes32 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(bool,bool,uint256,string)`.\\n mstore(0x00, 0x7dd4d0e0)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, 0x80)\\n writeString(0xa0, p3)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(bool p0, bool p1, bytes32 p2, address p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(bool,bool,string,address)`.\\n mstore(0x00, 0xf9ad2b89)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, 0x80)\\n mstore(0x80, p3)\\n writeString(0xa0, p2)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(bool p0, bool p1, bytes32 p2, bool p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(bool,bool,string,bool)`.\\n mstore(0x00, 0xb857163a)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, 0x80)\\n mstore(0x80, p3)\\n writeString(0xa0, p2)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(bool p0, bool p1, bytes32 p2, uint256 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(bool,bool,string,uint256)`.\\n mstore(0x00, 0xe3a9ca2f)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, 0x80)\\n mstore(0x80, p3)\\n writeString(0xa0, p2)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(bool p0, bool p1, bytes32 p2, bytes32 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n // Selector of `log(bool,bool,string,string)`.\\n mstore(0x00, 0x6d1e8751)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, 0x80)\\n mstore(0x80, 0xc0)\\n writeString(0xa0, p2)\\n writeString(0xe0, p3)\\n }\\n _sendLogPayload(0x1c, 0x104);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n }\\n }\\n\\n function log(bool p0, uint256 p1, address p2, address p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(bool,uint256,address,address)`.\\n mstore(0x00, 0x26f560a8)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(bool p0, uint256 p1, address p2, bool p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(bool,uint256,address,bool)`.\\n mstore(0x00, 0xb4c314ff)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(bool p0, uint256 p1, address p2, uint256 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(bool,uint256,address,uint256)`.\\n mstore(0x00, 0x1537dc87)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(bool p0, uint256 p1, address p2, bytes32 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(bool,uint256,address,string)`.\\n mstore(0x00, 0x1bb3b09a)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, 0x80)\\n writeString(0xa0, p3)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(bool p0, uint256 p1, bool p2, address p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(bool,uint256,bool,address)`.\\n mstore(0x00, 0x9acd3616)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(bool p0, uint256 p1, bool p2, bool p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(bool,uint256,bool,bool)`.\\n mstore(0x00, 0xceb5f4d7)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(bool p0, uint256 p1, bool p2, uint256 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(bool,uint256,bool,uint256)`.\\n mstore(0x00, 0x7f9bbca2)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(bool p0, uint256 p1, bool p2, bytes32 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(bool,uint256,bool,string)`.\\n mstore(0x00, 0x9143dbb1)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, 0x80)\\n writeString(0xa0, p3)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(bool p0, uint256 p1, uint256 p2, address p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(bool,uint256,uint256,address)`.\\n mstore(0x00, 0x00dd87b9)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(bool p0, uint256 p1, uint256 p2, bool p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(bool,uint256,uint256,bool)`.\\n mstore(0x00, 0xbe984353)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(bool p0, uint256 p1, uint256 p2, uint256 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(bool,uint256,uint256,uint256)`.\\n mstore(0x00, 0x374bb4b2)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(bool p0, uint256 p1, uint256 p2, bytes32 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(bool,uint256,uint256,string)`.\\n mstore(0x00, 0x8e69fb5d)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, 0x80)\\n writeString(0xa0, p3)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(bool p0, uint256 p1, bytes32 p2, address p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(bool,uint256,string,address)`.\\n mstore(0x00, 0xfedd1fff)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, 0x80)\\n mstore(0x80, p3)\\n writeString(0xa0, p2)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(bool p0, uint256 p1, bytes32 p2, bool p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(bool,uint256,string,bool)`.\\n mstore(0x00, 0xe5e70b2b)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, 0x80)\\n mstore(0x80, p3)\\n writeString(0xa0, p2)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(bool p0, uint256 p1, bytes32 p2, uint256 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(bool,uint256,string,uint256)`.\\n mstore(0x00, 0x6a1199e2)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, 0x80)\\n mstore(0x80, p3)\\n writeString(0xa0, p2)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(bool p0, uint256 p1, bytes32 p2, bytes32 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n // Selector of `log(bool,uint256,string,string)`.\\n mstore(0x00, 0xf5bc2249)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, 0x80)\\n mstore(0x80, 0xc0)\\n writeString(0xa0, p2)\\n writeString(0xe0, p3)\\n }\\n _sendLogPayload(0x1c, 0x104);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n }\\n }\\n\\n function log(bool p0, bytes32 p1, address p2, address p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(bool,string,address,address)`.\\n mstore(0x00, 0x2b2b18dc)\\n mstore(0x20, p0)\\n mstore(0x40, 0x80)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n writeString(0xa0, p1)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(bool p0, bytes32 p1, address p2, bool p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(bool,string,address,bool)`.\\n mstore(0x00, 0x6dd434ca)\\n mstore(0x20, p0)\\n mstore(0x40, 0x80)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n writeString(0xa0, p1)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(bool p0, bytes32 p1, address p2, uint256 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(bool,string,address,uint256)`.\\n mstore(0x00, 0xa5cada94)\\n mstore(0x20, p0)\\n mstore(0x40, 0x80)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n writeString(0xa0, p1)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(bool p0, bytes32 p1, address p2, bytes32 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n // Selector of `log(bool,string,address,string)`.\\n mstore(0x00, 0x12d6c788)\\n mstore(0x20, p0)\\n mstore(0x40, 0x80)\\n mstore(0x60, p2)\\n mstore(0x80, 0xc0)\\n writeString(0xa0, p1)\\n writeString(0xe0, p3)\\n }\\n _sendLogPayload(0x1c, 0x104);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n }\\n }\\n\\n function log(bool p0, bytes32 p1, bool p2, address p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(bool,string,bool,address)`.\\n mstore(0x00, 0x538e06ab)\\n mstore(0x20, p0)\\n mstore(0x40, 0x80)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n writeString(0xa0, p1)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(bool p0, bytes32 p1, bool p2, bool p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(bool,string,bool,bool)`.\\n mstore(0x00, 0xdc5e935b)\\n mstore(0x20, p0)\\n mstore(0x40, 0x80)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n writeString(0xa0, p1)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(bool p0, bytes32 p1, bool p2, uint256 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(bool,string,bool,uint256)`.\\n mstore(0x00, 0x1606a393)\\n mstore(0x20, p0)\\n mstore(0x40, 0x80)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n writeString(0xa0, p1)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(bool p0, bytes32 p1, bool p2, bytes32 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n // Selector of `log(bool,string,bool,string)`.\\n mstore(0x00, 0x483d0416)\\n mstore(0x20, p0)\\n mstore(0x40, 0x80)\\n mstore(0x60, p2)\\n mstore(0x80, 0xc0)\\n writeString(0xa0, p1)\\n writeString(0xe0, p3)\\n }\\n _sendLogPayload(0x1c, 0x104);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n }\\n }\\n\\n function log(bool p0, bytes32 p1, uint256 p2, address p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(bool,string,uint256,address)`.\\n mstore(0x00, 0x1596a1ce)\\n mstore(0x20, p0)\\n mstore(0x40, 0x80)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n writeString(0xa0, p1)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(bool p0, bytes32 p1, uint256 p2, bool p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(bool,string,uint256,bool)`.\\n mstore(0x00, 0x6b0e5d53)\\n mstore(0x20, p0)\\n mstore(0x40, 0x80)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n writeString(0xa0, p1)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(bool p0, bytes32 p1, uint256 p2, uint256 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(bool,string,uint256,uint256)`.\\n mstore(0x00, 0x28863fcb)\\n mstore(0x20, p0)\\n mstore(0x40, 0x80)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n writeString(0xa0, p1)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(bool p0, bytes32 p1, uint256 p2, bytes32 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n // Selector of `log(bool,string,uint256,string)`.\\n mstore(0x00, 0x1ad96de6)\\n mstore(0x20, p0)\\n mstore(0x40, 0x80)\\n mstore(0x60, p2)\\n mstore(0x80, 0xc0)\\n writeString(0xa0, p1)\\n writeString(0xe0, p3)\\n }\\n _sendLogPayload(0x1c, 0x104);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n }\\n }\\n\\n function log(bool p0, bytes32 p1, bytes32 p2, address p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n // Selector of `log(bool,string,string,address)`.\\n mstore(0x00, 0x97d394d8)\\n mstore(0x20, p0)\\n mstore(0x40, 0x80)\\n mstore(0x60, 0xc0)\\n mstore(0x80, p3)\\n writeString(0xa0, p1)\\n writeString(0xe0, p2)\\n }\\n _sendLogPayload(0x1c, 0x104);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n }\\n }\\n\\n function log(bool p0, bytes32 p1, bytes32 p2, bool p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n // Selector of `log(bool,string,string,bool)`.\\n mstore(0x00, 0x1e4b87e5)\\n mstore(0x20, p0)\\n mstore(0x40, 0x80)\\n mstore(0x60, 0xc0)\\n mstore(0x80, p3)\\n writeString(0xa0, p1)\\n writeString(0xe0, p2)\\n }\\n _sendLogPayload(0x1c, 0x104);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n }\\n }\\n\\n function log(bool p0, bytes32 p1, bytes32 p2, uint256 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n // Selector of `log(bool,string,string,uint256)`.\\n mstore(0x00, 0x7be0c3eb)\\n mstore(0x20, p0)\\n mstore(0x40, 0x80)\\n mstore(0x60, 0xc0)\\n mstore(0x80, p3)\\n writeString(0xa0, p1)\\n writeString(0xe0, p2)\\n }\\n _sendLogPayload(0x1c, 0x104);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n }\\n }\\n\\n function log(bool p0, bytes32 p1, bytes32 p2, bytes32 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n bytes32 m9;\\n bytes32 m10;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n m9 := mload(0x120)\\n m10 := mload(0x140)\\n // Selector of `log(bool,string,string,string)`.\\n mstore(0x00, 0x1762e32a)\\n mstore(0x20, p0)\\n mstore(0x40, 0x80)\\n mstore(0x60, 0xc0)\\n mstore(0x80, 0x100)\\n writeString(0xa0, p1)\\n writeString(0xe0, p2)\\n writeString(0x120, p3)\\n }\\n _sendLogPayload(0x1c, 0x144);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n mstore(0x120, m9)\\n mstore(0x140, m10)\\n }\\n }\\n\\n function log(uint256 p0, address p1, address p2, address p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(uint256,address,address,address)`.\\n mstore(0x00, 0x2488b414)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(uint256 p0, address p1, address p2, bool p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(uint256,address,address,bool)`.\\n mstore(0x00, 0x091ffaf5)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(uint256 p0, address p1, address p2, uint256 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(uint256,address,address,uint256)`.\\n mstore(0x00, 0x736efbb6)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(uint256 p0, address p1, address p2, bytes32 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(uint256,address,address,string)`.\\n mstore(0x00, 0x031c6f73)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, 0x80)\\n writeString(0xa0, p3)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(uint256 p0, address p1, bool p2, address p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(uint256,address,bool,address)`.\\n mstore(0x00, 0xef72c513)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(uint256 p0, address p1, bool p2, bool p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(uint256,address,bool,bool)`.\\n mstore(0x00, 0xe351140f)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(uint256 p0, address p1, bool p2, uint256 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(uint256,address,bool,uint256)`.\\n mstore(0x00, 0x5abd992a)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(uint256 p0, address p1, bool p2, bytes32 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(uint256,address,bool,string)`.\\n mstore(0x00, 0x90fb06aa)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, 0x80)\\n writeString(0xa0, p3)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(uint256 p0, address p1, uint256 p2, address p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(uint256,address,uint256,address)`.\\n mstore(0x00, 0x15c127b5)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(uint256 p0, address p1, uint256 p2, bool p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(uint256,address,uint256,bool)`.\\n mstore(0x00, 0x5f743a7c)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(uint256 p0, address p1, uint256 p2, uint256 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(uint256,address,uint256,uint256)`.\\n mstore(0x00, 0x0c9cd9c1)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(uint256 p0, address p1, uint256 p2, bytes32 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(uint256,address,uint256,string)`.\\n mstore(0x00, 0xddb06521)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, 0x80)\\n writeString(0xa0, p3)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(uint256 p0, address p1, bytes32 p2, address p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(uint256,address,string,address)`.\\n mstore(0x00, 0x9cba8fff)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, 0x80)\\n mstore(0x80, p3)\\n writeString(0xa0, p2)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(uint256 p0, address p1, bytes32 p2, bool p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(uint256,address,string,bool)`.\\n mstore(0x00, 0xcc32ab07)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, 0x80)\\n mstore(0x80, p3)\\n writeString(0xa0, p2)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(uint256 p0, address p1, bytes32 p2, uint256 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(uint256,address,string,uint256)`.\\n mstore(0x00, 0x46826b5d)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, 0x80)\\n mstore(0x80, p3)\\n writeString(0xa0, p2)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(uint256 p0, address p1, bytes32 p2, bytes32 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n // Selector of `log(uint256,address,string,string)`.\\n mstore(0x00, 0x3e128ca3)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, 0x80)\\n mstore(0x80, 0xc0)\\n writeString(0xa0, p2)\\n writeString(0xe0, p3)\\n }\\n _sendLogPayload(0x1c, 0x104);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n }\\n }\\n\\n function log(uint256 p0, bool p1, address p2, address p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(uint256,bool,address,address)`.\\n mstore(0x00, 0xa1ef4cbb)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(uint256 p0, bool p1, address p2, bool p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(uint256,bool,address,bool)`.\\n mstore(0x00, 0x454d54a5)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(uint256 p0, bool p1, address p2, uint256 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(uint256,bool,address,uint256)`.\\n mstore(0x00, 0x078287f5)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(uint256 p0, bool p1, address p2, bytes32 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(uint256,bool,address,string)`.\\n mstore(0x00, 0xade052c7)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, 0x80)\\n writeString(0xa0, p3)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(uint256 p0, bool p1, bool p2, address p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(uint256,bool,bool,address)`.\\n mstore(0x00, 0x69640b59)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(uint256 p0, bool p1, bool p2, bool p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(uint256,bool,bool,bool)`.\\n mstore(0x00, 0xb6f577a1)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(uint256 p0, bool p1, bool p2, uint256 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(uint256,bool,bool,uint256)`.\\n mstore(0x00, 0x7464ce23)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(uint256 p0, bool p1, bool p2, bytes32 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(uint256,bool,bool,string)`.\\n mstore(0x00, 0xdddb9561)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, 0x80)\\n writeString(0xa0, p3)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(uint256 p0, bool p1, uint256 p2, address p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(uint256,bool,uint256,address)`.\\n mstore(0x00, 0x88cb6041)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(uint256 p0, bool p1, uint256 p2, bool p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(uint256,bool,uint256,bool)`.\\n mstore(0x00, 0x91a02e2a)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(uint256 p0, bool p1, uint256 p2, uint256 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(uint256,bool,uint256,uint256)`.\\n mstore(0x00, 0xc6acc7a8)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(uint256 p0, bool p1, uint256 p2, bytes32 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(uint256,bool,uint256,string)`.\\n mstore(0x00, 0xde03e774)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, 0x80)\\n writeString(0xa0, p3)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(uint256 p0, bool p1, bytes32 p2, address p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(uint256,bool,string,address)`.\\n mstore(0x00, 0xef529018)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, 0x80)\\n mstore(0x80, p3)\\n writeString(0xa0, p2)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(uint256 p0, bool p1, bytes32 p2, bool p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(uint256,bool,string,bool)`.\\n mstore(0x00, 0xeb928d7f)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, 0x80)\\n mstore(0x80, p3)\\n writeString(0xa0, p2)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(uint256 p0, bool p1, bytes32 p2, uint256 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(uint256,bool,string,uint256)`.\\n mstore(0x00, 0x2c1d0746)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, 0x80)\\n mstore(0x80, p3)\\n writeString(0xa0, p2)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(uint256 p0, bool p1, bytes32 p2, bytes32 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n // Selector of `log(uint256,bool,string,string)`.\\n mstore(0x00, 0x68c8b8bd)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, 0x80)\\n mstore(0x80, 0xc0)\\n writeString(0xa0, p2)\\n writeString(0xe0, p3)\\n }\\n _sendLogPayload(0x1c, 0x104);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n }\\n }\\n\\n function log(uint256 p0, uint256 p1, address p2, address p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(uint256,uint256,address,address)`.\\n mstore(0x00, 0x56a5d1b1)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(uint256 p0, uint256 p1, address p2, bool p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(uint256,uint256,address,bool)`.\\n mstore(0x00, 0x15cac476)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(uint256 p0, uint256 p1, address p2, uint256 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(uint256,uint256,address,uint256)`.\\n mstore(0x00, 0x88f6e4b2)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(uint256 p0, uint256 p1, address p2, bytes32 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(uint256,uint256,address,string)`.\\n mstore(0x00, 0x6cde40b8)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, 0x80)\\n writeString(0xa0, p3)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(uint256 p0, uint256 p1, bool p2, address p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(uint256,uint256,bool,address)`.\\n mstore(0x00, 0x9a816a83)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(uint256 p0, uint256 p1, bool p2, bool p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(uint256,uint256,bool,bool)`.\\n mstore(0x00, 0xab085ae6)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(uint256 p0, uint256 p1, bool p2, uint256 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(uint256,uint256,bool,uint256)`.\\n mstore(0x00, 0xeb7f6fd2)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(uint256 p0, uint256 p1, bool p2, bytes32 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(uint256,uint256,bool,string)`.\\n mstore(0x00, 0xa5b4fc99)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, 0x80)\\n writeString(0xa0, p3)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(uint256 p0, uint256 p1, uint256 p2, address p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(uint256,uint256,uint256,address)`.\\n mstore(0x00, 0xfa8185af)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(uint256 p0, uint256 p1, uint256 p2, bool p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(uint256,uint256,uint256,bool)`.\\n mstore(0x00, 0xc598d185)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(uint256 p0, uint256 p1, uint256 p2, uint256 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(uint256,uint256,uint256,uint256)`.\\n mstore(0x00, 0x193fb800)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(uint256 p0, uint256 p1, uint256 p2, bytes32 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(uint256,uint256,uint256,string)`.\\n mstore(0x00, 0x59cfcbe3)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, 0x80)\\n writeString(0xa0, p3)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(uint256 p0, uint256 p1, bytes32 p2, address p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(uint256,uint256,string,address)`.\\n mstore(0x00, 0x42d21db7)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, 0x80)\\n mstore(0x80, p3)\\n writeString(0xa0, p2)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(uint256 p0, uint256 p1, bytes32 p2, bool p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(uint256,uint256,string,bool)`.\\n mstore(0x00, 0x7af6ab25)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, 0x80)\\n mstore(0x80, p3)\\n writeString(0xa0, p2)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(uint256 p0, uint256 p1, bytes32 p2, uint256 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(uint256,uint256,string,uint256)`.\\n mstore(0x00, 0x5da297eb)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, 0x80)\\n mstore(0x80, p3)\\n writeString(0xa0, p2)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(uint256 p0, uint256 p1, bytes32 p2, bytes32 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n // Selector of `log(uint256,uint256,string,string)`.\\n mstore(0x00, 0x27d8afd2)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, 0x80)\\n mstore(0x80, 0xc0)\\n writeString(0xa0, p2)\\n writeString(0xe0, p3)\\n }\\n _sendLogPayload(0x1c, 0x104);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n }\\n }\\n\\n function log(uint256 p0, bytes32 p1, address p2, address p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(uint256,string,address,address)`.\\n mstore(0x00, 0x6168ed61)\\n mstore(0x20, p0)\\n mstore(0x40, 0x80)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n writeString(0xa0, p1)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(uint256 p0, bytes32 p1, address p2, bool p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(uint256,string,address,bool)`.\\n mstore(0x00, 0x90c30a56)\\n mstore(0x20, p0)\\n mstore(0x40, 0x80)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n writeString(0xa0, p1)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(uint256 p0, bytes32 p1, address p2, uint256 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(uint256,string,address,uint256)`.\\n mstore(0x00, 0xe8d3018d)\\n mstore(0x20, p0)\\n mstore(0x40, 0x80)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n writeString(0xa0, p1)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(uint256 p0, bytes32 p1, address p2, bytes32 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n // Selector of `log(uint256,string,address,string)`.\\n mstore(0x00, 0x9c3adfa1)\\n mstore(0x20, p0)\\n mstore(0x40, 0x80)\\n mstore(0x60, p2)\\n mstore(0x80, 0xc0)\\n writeString(0xa0, p1)\\n writeString(0xe0, p3)\\n }\\n _sendLogPayload(0x1c, 0x104);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n }\\n }\\n\\n function log(uint256 p0, bytes32 p1, bool p2, address p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(uint256,string,bool,address)`.\\n mstore(0x00, 0xae2ec581)\\n mstore(0x20, p0)\\n mstore(0x40, 0x80)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n writeString(0xa0, p1)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(uint256 p0, bytes32 p1, bool p2, bool p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(uint256,string,bool,bool)`.\\n mstore(0x00, 0xba535d9c)\\n mstore(0x20, p0)\\n mstore(0x40, 0x80)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n writeString(0xa0, p1)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(uint256 p0, bytes32 p1, bool p2, uint256 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(uint256,string,bool,uint256)`.\\n mstore(0x00, 0xcf009880)\\n mstore(0x20, p0)\\n mstore(0x40, 0x80)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n writeString(0xa0, p1)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(uint256 p0, bytes32 p1, bool p2, bytes32 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n // Selector of `log(uint256,string,bool,string)`.\\n mstore(0x00, 0xd2d423cd)\\n mstore(0x20, p0)\\n mstore(0x40, 0x80)\\n mstore(0x60, p2)\\n mstore(0x80, 0xc0)\\n writeString(0xa0, p1)\\n writeString(0xe0, p3)\\n }\\n _sendLogPayload(0x1c, 0x104);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n }\\n }\\n\\n function log(uint256 p0, bytes32 p1, uint256 p2, address p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(uint256,string,uint256,address)`.\\n mstore(0x00, 0x3b2279b4)\\n mstore(0x20, p0)\\n mstore(0x40, 0x80)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n writeString(0xa0, p1)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(uint256 p0, bytes32 p1, uint256 p2, bool p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(uint256,string,uint256,bool)`.\\n mstore(0x00, 0x691a8f74)\\n mstore(0x20, p0)\\n mstore(0x40, 0x80)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n writeString(0xa0, p1)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(uint256 p0, bytes32 p1, uint256 p2, uint256 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(uint256,string,uint256,uint256)`.\\n mstore(0x00, 0x82c25b74)\\n mstore(0x20, p0)\\n mstore(0x40, 0x80)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n writeString(0xa0, p1)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(uint256 p0, bytes32 p1, uint256 p2, bytes32 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n // Selector of `log(uint256,string,uint256,string)`.\\n mstore(0x00, 0xb7b914ca)\\n mstore(0x20, p0)\\n mstore(0x40, 0x80)\\n mstore(0x60, p2)\\n mstore(0x80, 0xc0)\\n writeString(0xa0, p1)\\n writeString(0xe0, p3)\\n }\\n _sendLogPayload(0x1c, 0x104);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n }\\n }\\n\\n function log(uint256 p0, bytes32 p1, bytes32 p2, address p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n // Selector of `log(uint256,string,string,address)`.\\n mstore(0x00, 0xd583c602)\\n mstore(0x20, p0)\\n mstore(0x40, 0x80)\\n mstore(0x60, 0xc0)\\n mstore(0x80, p3)\\n writeString(0xa0, p1)\\n writeString(0xe0, p2)\\n }\\n _sendLogPayload(0x1c, 0x104);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n }\\n }\\n\\n function log(uint256 p0, bytes32 p1, bytes32 p2, bool p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n // Selector of `log(uint256,string,string,bool)`.\\n mstore(0x00, 0xb3a6b6bd)\\n mstore(0x20, p0)\\n mstore(0x40, 0x80)\\n mstore(0x60, 0xc0)\\n mstore(0x80, p3)\\n writeString(0xa0, p1)\\n writeString(0xe0, p2)\\n }\\n _sendLogPayload(0x1c, 0x104);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n }\\n }\\n\\n function log(uint256 p0, bytes32 p1, bytes32 p2, uint256 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n // Selector of `log(uint256,string,string,uint256)`.\\n mstore(0x00, 0xb028c9bd)\\n mstore(0x20, p0)\\n mstore(0x40, 0x80)\\n mstore(0x60, 0xc0)\\n mstore(0x80, p3)\\n writeString(0xa0, p1)\\n writeString(0xe0, p2)\\n }\\n _sendLogPayload(0x1c, 0x104);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n }\\n }\\n\\n function log(uint256 p0, bytes32 p1, bytes32 p2, bytes32 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n bytes32 m9;\\n bytes32 m10;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n m9 := mload(0x120)\\n m10 := mload(0x140)\\n // Selector of `log(uint256,string,string,string)`.\\n mstore(0x00, 0x21ad0683)\\n mstore(0x20, p0)\\n mstore(0x40, 0x80)\\n mstore(0x60, 0xc0)\\n mstore(0x80, 0x100)\\n writeString(0xa0, p1)\\n writeString(0xe0, p2)\\n writeString(0x120, p3)\\n }\\n _sendLogPayload(0x1c, 0x144);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n mstore(0x120, m9)\\n mstore(0x140, m10)\\n }\\n }\\n\\n function log(bytes32 p0, address p1, address p2, address p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(string,address,address,address)`.\\n mstore(0x00, 0xed8f28f6)\\n mstore(0x20, 0x80)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n writeString(0xa0, p0)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(bytes32 p0, address p1, address p2, bool p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(string,address,address,bool)`.\\n mstore(0x00, 0xb59dbd60)\\n mstore(0x20, 0x80)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n writeString(0xa0, p0)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(bytes32 p0, address p1, address p2, uint256 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(string,address,address,uint256)`.\\n mstore(0x00, 0x8ef3f399)\\n mstore(0x20, 0x80)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n writeString(0xa0, p0)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(bytes32 p0, address p1, address p2, bytes32 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n // Selector of `log(string,address,address,string)`.\\n mstore(0x00, 0x800a1c67)\\n mstore(0x20, 0x80)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, 0xc0)\\n writeString(0xa0, p0)\\n writeString(0xe0, p3)\\n }\\n _sendLogPayload(0x1c, 0x104);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n }\\n }\\n\\n function log(bytes32 p0, address p1, bool p2, address p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(string,address,bool,address)`.\\n mstore(0x00, 0x223603bd)\\n mstore(0x20, 0x80)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n writeString(0xa0, p0)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(bytes32 p0, address p1, bool p2, bool p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(string,address,bool,bool)`.\\n mstore(0x00, 0x79884c2b)\\n mstore(0x20, 0x80)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n writeString(0xa0, p0)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(bytes32 p0, address p1, bool p2, uint256 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(string,address,bool,uint256)`.\\n mstore(0x00, 0x3e9f866a)\\n mstore(0x20, 0x80)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n writeString(0xa0, p0)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(bytes32 p0, address p1, bool p2, bytes32 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n // Selector of `log(string,address,bool,string)`.\\n mstore(0x00, 0x0454c079)\\n mstore(0x20, 0x80)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, 0xc0)\\n writeString(0xa0, p0)\\n writeString(0xe0, p3)\\n }\\n _sendLogPayload(0x1c, 0x104);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n }\\n }\\n\\n function log(bytes32 p0, address p1, uint256 p2, address p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(string,address,uint256,address)`.\\n mstore(0x00, 0x63fb8bc5)\\n mstore(0x20, 0x80)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n writeString(0xa0, p0)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(bytes32 p0, address p1, uint256 p2, bool p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(string,address,uint256,bool)`.\\n mstore(0x00, 0xfc4845f0)\\n mstore(0x20, 0x80)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n writeString(0xa0, p0)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(bytes32 p0, address p1, uint256 p2, uint256 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(string,address,uint256,uint256)`.\\n mstore(0x00, 0xf8f51b1e)\\n mstore(0x20, 0x80)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n writeString(0xa0, p0)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(bytes32 p0, address p1, uint256 p2, bytes32 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n // Selector of `log(string,address,uint256,string)`.\\n mstore(0x00, 0x5a477632)\\n mstore(0x20, 0x80)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, 0xc0)\\n writeString(0xa0, p0)\\n writeString(0xe0, p3)\\n }\\n _sendLogPayload(0x1c, 0x104);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n }\\n }\\n\\n function log(bytes32 p0, address p1, bytes32 p2, address p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n // Selector of `log(string,address,string,address)`.\\n mstore(0x00, 0xaabc9a31)\\n mstore(0x20, 0x80)\\n mstore(0x40, p1)\\n mstore(0x60, 0xc0)\\n mstore(0x80, p3)\\n writeString(0xa0, p0)\\n writeString(0xe0, p2)\\n }\\n _sendLogPayload(0x1c, 0x104);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n }\\n }\\n\\n function log(bytes32 p0, address p1, bytes32 p2, bool p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n // Selector of `log(string,address,string,bool)`.\\n mstore(0x00, 0x5f15d28c)\\n mstore(0x20, 0x80)\\n mstore(0x40, p1)\\n mstore(0x60, 0xc0)\\n mstore(0x80, p3)\\n writeString(0xa0, p0)\\n writeString(0xe0, p2)\\n }\\n _sendLogPayload(0x1c, 0x104);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n }\\n }\\n\\n function log(bytes32 p0, address p1, bytes32 p2, uint256 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n // Selector of `log(string,address,string,uint256)`.\\n mstore(0x00, 0x91d1112e)\\n mstore(0x20, 0x80)\\n mstore(0x40, p1)\\n mstore(0x60, 0xc0)\\n mstore(0x80, p3)\\n writeString(0xa0, p0)\\n writeString(0xe0, p2)\\n }\\n _sendLogPayload(0x1c, 0x104);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n }\\n }\\n\\n function log(bytes32 p0, address p1, bytes32 p2, bytes32 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n bytes32 m9;\\n bytes32 m10;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n m9 := mload(0x120)\\n m10 := mload(0x140)\\n // Selector of `log(string,address,string,string)`.\\n mstore(0x00, 0x245986f2)\\n mstore(0x20, 0x80)\\n mstore(0x40, p1)\\n mstore(0x60, 0xc0)\\n mstore(0x80, 0x100)\\n writeString(0xa0, p0)\\n writeString(0xe0, p2)\\n writeString(0x120, p3)\\n }\\n _sendLogPayload(0x1c, 0x144);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n mstore(0x120, m9)\\n mstore(0x140, m10)\\n }\\n }\\n\\n function log(bytes32 p0, bool p1, address p2, address p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(string,bool,address,address)`.\\n mstore(0x00, 0x33e9dd1d)\\n mstore(0x20, 0x80)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n writeString(0xa0, p0)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(bytes32 p0, bool p1, address p2, bool p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(string,bool,address,bool)`.\\n mstore(0x00, 0x958c28c6)\\n mstore(0x20, 0x80)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n writeString(0xa0, p0)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(bytes32 p0, bool p1, address p2, uint256 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(string,bool,address,uint256)`.\\n mstore(0x00, 0x5d08bb05)\\n mstore(0x20, 0x80)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n writeString(0xa0, p0)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(bytes32 p0, bool p1, address p2, bytes32 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n // Selector of `log(string,bool,address,string)`.\\n mstore(0x00, 0x2d8e33a4)\\n mstore(0x20, 0x80)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, 0xc0)\\n writeString(0xa0, p0)\\n writeString(0xe0, p3)\\n }\\n _sendLogPayload(0x1c, 0x104);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n }\\n }\\n\\n function log(bytes32 p0, bool p1, bool p2, address p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(string,bool,bool,address)`.\\n mstore(0x00, 0x7190a529)\\n mstore(0x20, 0x80)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n writeString(0xa0, p0)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(bytes32 p0, bool p1, bool p2, bool p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(string,bool,bool,bool)`.\\n mstore(0x00, 0x895af8c5)\\n mstore(0x20, 0x80)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n writeString(0xa0, p0)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(bytes32 p0, bool p1, bool p2, uint256 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(string,bool,bool,uint256)`.\\n mstore(0x00, 0x8e3f78a9)\\n mstore(0x20, 0x80)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n writeString(0xa0, p0)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(bytes32 p0, bool p1, bool p2, bytes32 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n // Selector of `log(string,bool,bool,string)`.\\n mstore(0x00, 0x9d22d5dd)\\n mstore(0x20, 0x80)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, 0xc0)\\n writeString(0xa0, p0)\\n writeString(0xe0, p3)\\n }\\n _sendLogPayload(0x1c, 0x104);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n }\\n }\\n\\n function log(bytes32 p0, bool p1, uint256 p2, address p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(string,bool,uint256,address)`.\\n mstore(0x00, 0x935e09bf)\\n mstore(0x20, 0x80)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n writeString(0xa0, p0)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(bytes32 p0, bool p1, uint256 p2, bool p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(string,bool,uint256,bool)`.\\n mstore(0x00, 0x8af7cf8a)\\n mstore(0x20, 0x80)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n writeString(0xa0, p0)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(bytes32 p0, bool p1, uint256 p2, uint256 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(string,bool,uint256,uint256)`.\\n mstore(0x00, 0x64b5bb67)\\n mstore(0x20, 0x80)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n writeString(0xa0, p0)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(bytes32 p0, bool p1, uint256 p2, bytes32 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n // Selector of `log(string,bool,uint256,string)`.\\n mstore(0x00, 0x742d6ee7)\\n mstore(0x20, 0x80)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, 0xc0)\\n writeString(0xa0, p0)\\n writeString(0xe0, p3)\\n }\\n _sendLogPayload(0x1c, 0x104);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n }\\n }\\n\\n function log(bytes32 p0, bool p1, bytes32 p2, address p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n // Selector of `log(string,bool,string,address)`.\\n mstore(0x00, 0xe0625b29)\\n mstore(0x20, 0x80)\\n mstore(0x40, p1)\\n mstore(0x60, 0xc0)\\n mstore(0x80, p3)\\n writeString(0xa0, p0)\\n writeString(0xe0, p2)\\n }\\n _sendLogPayload(0x1c, 0x104);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n }\\n }\\n\\n function log(bytes32 p0, bool p1, bytes32 p2, bool p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n // Selector of `log(string,bool,string,bool)`.\\n mstore(0x00, 0x3f8a701d)\\n mstore(0x20, 0x80)\\n mstore(0x40, p1)\\n mstore(0x60, 0xc0)\\n mstore(0x80, p3)\\n writeString(0xa0, p0)\\n writeString(0xe0, p2)\\n }\\n _sendLogPayload(0x1c, 0x104);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n }\\n }\\n\\n function log(bytes32 p0, bool p1, bytes32 p2, uint256 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n // Selector of `log(string,bool,string,uint256)`.\\n mstore(0x00, 0x24f91465)\\n mstore(0x20, 0x80)\\n mstore(0x40, p1)\\n mstore(0x60, 0xc0)\\n mstore(0x80, p3)\\n writeString(0xa0, p0)\\n writeString(0xe0, p2)\\n }\\n _sendLogPayload(0x1c, 0x104);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n }\\n }\\n\\n function log(bytes32 p0, bool p1, bytes32 p2, bytes32 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n bytes32 m9;\\n bytes32 m10;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n m9 := mload(0x120)\\n m10 := mload(0x140)\\n // Selector of `log(string,bool,string,string)`.\\n mstore(0x00, 0xa826caeb)\\n mstore(0x20, 0x80)\\n mstore(0x40, p1)\\n mstore(0x60, 0xc0)\\n mstore(0x80, 0x100)\\n writeString(0xa0, p0)\\n writeString(0xe0, p2)\\n writeString(0x120, p3)\\n }\\n _sendLogPayload(0x1c, 0x144);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n mstore(0x120, m9)\\n mstore(0x140, m10)\\n }\\n }\\n\\n function log(bytes32 p0, uint256 p1, address p2, address p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(string,uint256,address,address)`.\\n mstore(0x00, 0x5ea2b7ae)\\n mstore(0x20, 0x80)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n writeString(0xa0, p0)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(bytes32 p0, uint256 p1, address p2, bool p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(string,uint256,address,bool)`.\\n mstore(0x00, 0x82112a42)\\n mstore(0x20, 0x80)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n writeString(0xa0, p0)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(bytes32 p0, uint256 p1, address p2, uint256 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(string,uint256,address,uint256)`.\\n mstore(0x00, 0x4f04fdc6)\\n mstore(0x20, 0x80)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n writeString(0xa0, p0)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(bytes32 p0, uint256 p1, address p2, bytes32 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n // Selector of `log(string,uint256,address,string)`.\\n mstore(0x00, 0x9ffb2f93)\\n mstore(0x20, 0x80)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, 0xc0)\\n writeString(0xa0, p0)\\n writeString(0xe0, p3)\\n }\\n _sendLogPayload(0x1c, 0x104);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n }\\n }\\n\\n function log(bytes32 p0, uint256 p1, bool p2, address p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(string,uint256,bool,address)`.\\n mstore(0x00, 0xe0e95b98)\\n mstore(0x20, 0x80)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n writeString(0xa0, p0)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(bytes32 p0, uint256 p1, bool p2, bool p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(string,uint256,bool,bool)`.\\n mstore(0x00, 0x354c36d6)\\n mstore(0x20, 0x80)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n writeString(0xa0, p0)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(bytes32 p0, uint256 p1, bool p2, uint256 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(string,uint256,bool,uint256)`.\\n mstore(0x00, 0xe41b6f6f)\\n mstore(0x20, 0x80)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n writeString(0xa0, p0)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(bytes32 p0, uint256 p1, bool p2, bytes32 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n // Selector of `log(string,uint256,bool,string)`.\\n mstore(0x00, 0xabf73a98)\\n mstore(0x20, 0x80)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, 0xc0)\\n writeString(0xa0, p0)\\n writeString(0xe0, p3)\\n }\\n _sendLogPayload(0x1c, 0x104);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n }\\n }\\n\\n function log(bytes32 p0, uint256 p1, uint256 p2, address p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(string,uint256,uint256,address)`.\\n mstore(0x00, 0xe21de278)\\n mstore(0x20, 0x80)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n writeString(0xa0, p0)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(bytes32 p0, uint256 p1, uint256 p2, bool p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(string,uint256,uint256,bool)`.\\n mstore(0x00, 0x7626db92)\\n mstore(0x20, 0x80)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n writeString(0xa0, p0)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(bytes32 p0, uint256 p1, uint256 p2, uint256 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(string,uint256,uint256,uint256)`.\\n mstore(0x00, 0xa7a87853)\\n mstore(0x20, 0x80)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n writeString(0xa0, p0)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(bytes32 p0, uint256 p1, uint256 p2, bytes32 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n // Selector of `log(string,uint256,uint256,string)`.\\n mstore(0x00, 0x854b3496)\\n mstore(0x20, 0x80)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, 0xc0)\\n writeString(0xa0, p0)\\n writeString(0xe0, p3)\\n }\\n _sendLogPayload(0x1c, 0x104);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n }\\n }\\n\\n function log(bytes32 p0, uint256 p1, bytes32 p2, address p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n // Selector of `log(string,uint256,string,address)`.\\n mstore(0x00, 0x7c4632a4)\\n mstore(0x20, 0x80)\\n mstore(0x40, p1)\\n mstore(0x60, 0xc0)\\n mstore(0x80, p3)\\n writeString(0xa0, p0)\\n writeString(0xe0, p2)\\n }\\n _sendLogPayload(0x1c, 0x104);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n }\\n }\\n\\n function log(bytes32 p0, uint256 p1, bytes32 p2, bool p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n // Selector of `log(string,uint256,string,bool)`.\\n mstore(0x00, 0x7d24491d)\\n mstore(0x20, 0x80)\\n mstore(0x40, p1)\\n mstore(0x60, 0xc0)\\n mstore(0x80, p3)\\n writeString(0xa0, p0)\\n writeString(0xe0, p2)\\n }\\n _sendLogPayload(0x1c, 0x104);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n }\\n }\\n\\n function log(bytes32 p0, uint256 p1, bytes32 p2, uint256 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n // Selector of `log(string,uint256,string,uint256)`.\\n mstore(0x00, 0xc67ea9d1)\\n mstore(0x20, 0x80)\\n mstore(0x40, p1)\\n mstore(0x60, 0xc0)\\n mstore(0x80, p3)\\n writeString(0xa0, p0)\\n writeString(0xe0, p2)\\n }\\n _sendLogPayload(0x1c, 0x104);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n }\\n }\\n\\n function log(bytes32 p0, uint256 p1, bytes32 p2, bytes32 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n bytes32 m9;\\n bytes32 m10;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n m9 := mload(0x120)\\n m10 := mload(0x140)\\n // Selector of `log(string,uint256,string,string)`.\\n mstore(0x00, 0x5ab84e1f)\\n mstore(0x20, 0x80)\\n mstore(0x40, p1)\\n mstore(0x60, 0xc0)\\n mstore(0x80, 0x100)\\n writeString(0xa0, p0)\\n writeString(0xe0, p2)\\n writeString(0x120, p3)\\n }\\n _sendLogPayload(0x1c, 0x144);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n mstore(0x120, m9)\\n mstore(0x140, m10)\\n }\\n }\\n\\n function log(bytes32 p0, bytes32 p1, address p2, address p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n // Selector of `log(string,string,address,address)`.\\n mstore(0x00, 0x439c7bef)\\n mstore(0x20, 0x80)\\n mstore(0x40, 0xc0)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n writeString(0xa0, p0)\\n writeString(0xe0, p1)\\n }\\n _sendLogPayload(0x1c, 0x104);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n }\\n }\\n\\n function log(bytes32 p0, bytes32 p1, address p2, bool p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n // Selector of `log(string,string,address,bool)`.\\n mstore(0x00, 0x5ccd4e37)\\n mstore(0x20, 0x80)\\n mstore(0x40, 0xc0)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n writeString(0xa0, p0)\\n writeString(0xe0, p1)\\n }\\n _sendLogPayload(0x1c, 0x104);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n }\\n }\\n\\n function log(bytes32 p0, bytes32 p1, address p2, uint256 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n // Selector of `log(string,string,address,uint256)`.\\n mstore(0x00, 0x7cc3c607)\\n mstore(0x20, 0x80)\\n mstore(0x40, 0xc0)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n writeString(0xa0, p0)\\n writeString(0xe0, p1)\\n }\\n _sendLogPayload(0x1c, 0x104);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n }\\n }\\n\\n function log(bytes32 p0, bytes32 p1, address p2, bytes32 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n bytes32 m9;\\n bytes32 m10;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n m9 := mload(0x120)\\n m10 := mload(0x140)\\n // Selector of `log(string,string,address,string)`.\\n mstore(0x00, 0xeb1bff80)\\n mstore(0x20, 0x80)\\n mstore(0x40, 0xc0)\\n mstore(0x60, p2)\\n mstore(0x80, 0x100)\\n writeString(0xa0, p0)\\n writeString(0xe0, p1)\\n writeString(0x120, p3)\\n }\\n _sendLogPayload(0x1c, 0x144);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n mstore(0x120, m9)\\n mstore(0x140, m10)\\n }\\n }\\n\\n function log(bytes32 p0, bytes32 p1, bool p2, address p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n // Selector of `log(string,string,bool,address)`.\\n mstore(0x00, 0xc371c7db)\\n mstore(0x20, 0x80)\\n mstore(0x40, 0xc0)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n writeString(0xa0, p0)\\n writeString(0xe0, p1)\\n }\\n _sendLogPayload(0x1c, 0x104);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n }\\n }\\n\\n function log(bytes32 p0, bytes32 p1, bool p2, bool p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n // Selector of `log(string,string,bool,bool)`.\\n mstore(0x00, 0x40785869)\\n mstore(0x20, 0x80)\\n mstore(0x40, 0xc0)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n writeString(0xa0, p0)\\n writeString(0xe0, p1)\\n }\\n _sendLogPayload(0x1c, 0x104);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n }\\n }\\n\\n function log(bytes32 p0, bytes32 p1, bool p2, uint256 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n // Selector of `log(string,string,bool,uint256)`.\\n mstore(0x00, 0xd6aefad2)\\n mstore(0x20, 0x80)\\n mstore(0x40, 0xc0)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n writeString(0xa0, p0)\\n writeString(0xe0, p1)\\n }\\n _sendLogPayload(0x1c, 0x104);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n }\\n }\\n\\n function log(bytes32 p0, bytes32 p1, bool p2, bytes32 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n bytes32 m9;\\n bytes32 m10;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n m9 := mload(0x120)\\n m10 := mload(0x140)\\n // Selector of `log(string,string,bool,string)`.\\n mstore(0x00, 0x5e84b0ea)\\n mstore(0x20, 0x80)\\n mstore(0x40, 0xc0)\\n mstore(0x60, p2)\\n mstore(0x80, 0x100)\\n writeString(0xa0, p0)\\n writeString(0xe0, p1)\\n writeString(0x120, p3)\\n }\\n _sendLogPayload(0x1c, 0x144);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n mstore(0x120, m9)\\n mstore(0x140, m10)\\n }\\n }\\n\\n function log(bytes32 p0, bytes32 p1, uint256 p2, address p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n // Selector of `log(string,string,uint256,address)`.\\n mstore(0x00, 0x1023f7b2)\\n mstore(0x20, 0x80)\\n mstore(0x40, 0xc0)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n writeString(0xa0, p0)\\n writeString(0xe0, p1)\\n }\\n _sendLogPayload(0x1c, 0x104);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n }\\n }\\n\\n function log(bytes32 p0, bytes32 p1, uint256 p2, bool p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n // Selector of `log(string,string,uint256,bool)`.\\n mstore(0x00, 0xc3a8a654)\\n mstore(0x20, 0x80)\\n mstore(0x40, 0xc0)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n writeString(0xa0, p0)\\n writeString(0xe0, p1)\\n }\\n _sendLogPayload(0x1c, 0x104);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n }\\n }\\n\\n function log(bytes32 p0, bytes32 p1, uint256 p2, uint256 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n // Selector of `log(string,string,uint256,uint256)`.\\n mstore(0x00, 0xf45d7d2c)\\n mstore(0x20, 0x80)\\n mstore(0x40, 0xc0)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n writeString(0xa0, p0)\\n writeString(0xe0, p1)\\n }\\n _sendLogPayload(0x1c, 0x104);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n }\\n }\\n\\n function log(bytes32 p0, bytes32 p1, uint256 p2, bytes32 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n bytes32 m9;\\n bytes32 m10;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n m9 := mload(0x120)\\n m10 := mload(0x140)\\n // Selector of `log(string,string,uint256,string)`.\\n mstore(0x00, 0x5d1a971a)\\n mstore(0x20, 0x80)\\n mstore(0x40, 0xc0)\\n mstore(0x60, p2)\\n mstore(0x80, 0x100)\\n writeString(0xa0, p0)\\n writeString(0xe0, p1)\\n writeString(0x120, p3)\\n }\\n _sendLogPayload(0x1c, 0x144);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n mstore(0x120, m9)\\n mstore(0x140, m10)\\n }\\n }\\n\\n function log(bytes32 p0, bytes32 p1, bytes32 p2, address p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n bytes32 m9;\\n bytes32 m10;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n m9 := mload(0x120)\\n m10 := mload(0x140)\\n // Selector of `log(string,string,string,address)`.\\n mstore(0x00, 0x6d572f44)\\n mstore(0x20, 0x80)\\n mstore(0x40, 0xc0)\\n mstore(0x60, 0x100)\\n mstore(0x80, p3)\\n writeString(0xa0, p0)\\n writeString(0xe0, p1)\\n writeString(0x120, p2)\\n }\\n _sendLogPayload(0x1c, 0x144);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n mstore(0x120, m9)\\n mstore(0x140, m10)\\n }\\n }\\n\\n function log(bytes32 p0, bytes32 p1, bytes32 p2, bool p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n bytes32 m9;\\n bytes32 m10;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n m9 := mload(0x120)\\n m10 := mload(0x140)\\n // Selector of `log(string,string,string,bool)`.\\n mstore(0x00, 0x2c1754ed)\\n mstore(0x20, 0x80)\\n mstore(0x40, 0xc0)\\n mstore(0x60, 0x100)\\n mstore(0x80, p3)\\n writeString(0xa0, p0)\\n writeString(0xe0, p1)\\n writeString(0x120, p2)\\n }\\n _sendLogPayload(0x1c, 0x144);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n mstore(0x120, m9)\\n mstore(0x140, m10)\\n }\\n }\\n\\n function log(bytes32 p0, bytes32 p1, bytes32 p2, uint256 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n bytes32 m9;\\n bytes32 m10;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n m9 := mload(0x120)\\n m10 := mload(0x140)\\n // Selector of `log(string,string,string,uint256)`.\\n mstore(0x00, 0x8eafb02b)\\n mstore(0x20, 0x80)\\n mstore(0x40, 0xc0)\\n mstore(0x60, 0x100)\\n mstore(0x80, p3)\\n writeString(0xa0, p0)\\n writeString(0xe0, p1)\\n writeString(0x120, p2)\\n }\\n _sendLogPayload(0x1c, 0x144);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n mstore(0x120, m9)\\n mstore(0x140, m10)\\n }\\n }\\n\\n function log(bytes32 p0, bytes32 p1, bytes32 p2, bytes32 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n bytes32 m9;\\n bytes32 m10;\\n bytes32 m11;\\n bytes32 m12;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n m9 := mload(0x120)\\n m10 := mload(0x140)\\n m11 := mload(0x160)\\n m12 := mload(0x180)\\n // Selector of `log(string,string,string,string)`.\\n mstore(0x00, 0xde68f20a)\\n mstore(0x20, 0x80)\\n mstore(0x40, 0xc0)\\n mstore(0x60, 0x100)\\n mstore(0x80, 0x140)\\n writeString(0xa0, p0)\\n writeString(0xe0, p1)\\n writeString(0x120, p2)\\n writeString(0x160, p3)\\n }\\n _sendLogPayload(0x1c, 0x184);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n mstore(0x120, m9)\\n mstore(0x140, m10)\\n mstore(0x160, m11)\\n mstore(0x180, m12)\\n }\\n }\\n}\\n\",\"keccak256\":\"0xbef9786cb49d3eade757bad87568c49c8c8f35721f0193c95ffb055d9e466e11\",\"license\":\"MIT\"},\"scripts/FetchChainInfo.s.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\nimport { Script } from \\\"forge-std/Script.sol\\\";\\nimport { GameTypes, GameType } from \\\"src/dispute/lib/Types.sol\\\";\\n\\n/// @notice Contains getters for arbitrary methods from all L1 contracts, including legacy getters\\n/// that have since been deprecated.\\ninterface IFetcher {\\n function guardian() external view returns (address);\\n function GUARDIAN() external view returns (address);\\n function systemConfig() external view returns (address);\\n function SYSTEM_CONFIG() external view returns (address);\\n function disputeGameFactory() external view returns (address);\\n function ethLockbox() external view returns (address);\\n function superchainConfig() external view returns (address);\\n function messenger() external view returns (address);\\n function addressManager() external view returns (address);\\n function PORTAL() external view returns (address);\\n function portal() external view returns (address);\\n function l1ERC721Bridge() external view returns (address);\\n function optimismMintableERC20Factory() external view returns (address);\\n function gameImpls(GameType _gameType) external view returns (address);\\n function respectedGameType() external view returns (GameType);\\n function anchorStateRegistry() external view returns (address);\\n function L2_ORACLE() external view returns (address);\\n function l2Oracle() external view returns (address);\\n function vm() external view returns (address);\\n function oracle() external view returns (address);\\n function challenger() external view returns (address);\\n function proposer() external view returns (address);\\n function PROPOSER() external view returns (address);\\n function batcherHash() external view returns (bytes32);\\n function admin() external view returns (address);\\n function owner() external view returns (address);\\n function unsafeBlockSigner() external view returns (address);\\n function weth() external view returns (address);\\n}\\n\\ncontract FetchChainInfoInput {\\n address internal _systemConfigProxy;\\n address internal _l1StandardBridgeProxy;\\n\\n function set(bytes4 _sel, address _addr) public {\\n require(_addr != address(0), \\\"FetchChainInfoInput: cannot set zero address\\\");\\n if (_sel == this.systemConfigProxy.selector) _systemConfigProxy = _addr;\\n else if (_sel == this.l1StandardBridgeProxy.selector) _l1StandardBridgeProxy = _addr;\\n else revert(\\\"FetchChainInfoInput: unknown selector\\\");\\n }\\n\\n function systemConfigProxy() public view returns (address) {\\n require(_systemConfigProxy != address(0), \\\"FetchChainInfoInput: systemConfigProxy not set\\\");\\n return _systemConfigProxy;\\n }\\n\\n function l1StandardBridgeProxy() public view returns (address) {\\n require(_l1StandardBridgeProxy != address(0), \\\"FetchChainInfoInput: l1StandardBridgeProxy not set\\\");\\n return _l1StandardBridgeProxy;\\n }\\n}\\n\\ncontract FetchChainInfoOutput {\\n // contract addresses\\n // - SuperchainContracts\\n address internal _superchainConfigProxy;\\n // - ImplementationsContracts\\n address internal _mipsImpl;\\n address internal _preimageOracleImpl;\\n // - OpChainContracts\\n address internal _addressManagerImpl;\\n address internal _ethLockboxProxy;\\n address internal _l1CrossDomainMessengerProxy;\\n address internal _l1Erc721BridgeProxy;\\n address internal _l1StandardBridgeProxy;\\n address internal _l2OutputOracleProxy;\\n address internal _optimismMintableErc20FactoryProxy;\\n address internal _optimismPortalProxy;\\n address internal _systemConfigProxy;\\n address internal _opChainProxyAdminImpl;\\n address internal _anchorStateRegistryProxy;\\n address internal _delayedWethPermissionedGameProxy;\\n address internal _delayedWethPermissionlessGameProxy;\\n address internal _disputeGameFactoryProxy;\\n address internal _faultDisputeGameImpl;\\n address internal _permissionedDisputeGameImpl;\\n\\n // roles\\n address internal _systemConfigOwner;\\n address internal _opChainProxyAdminOwner;\\n address internal _opChainGuardian;\\n address internal _challenger;\\n address internal _proposer;\\n address internal _unsafeBlockSigner;\\n address internal _batchSubmitter;\\n\\n // fault proof status\\n bool internal _permissioned;\\n bool internal _permissionless;\\n GameType internal _respectedGameType;\\n\\n function set(bytes4 _sel, address _addr) public {\\n // SuperchainContracts\\n if (_sel == this.superchainConfigProxy.selector) _superchainConfigProxy = _addr;\\n // - ImplementationsContracts\\n else if (_sel == this.mipsImpl.selector) _mipsImpl = _addr;\\n else if (_sel == this.preimageOracleImpl.selector) _preimageOracleImpl = _addr;\\n // - OpChainContracts\\n else if (_sel == this.addressManagerImpl.selector) _addressManagerImpl = _addr;\\n else if (_sel == this.ethLockboxProxy.selector) _ethLockboxProxy = _addr;\\n else if (_sel == this.l1CrossDomainMessengerProxy.selector) _l1CrossDomainMessengerProxy = _addr;\\n else if (_sel == this.l1Erc721BridgeProxy.selector) _l1Erc721BridgeProxy = _addr;\\n else if (_sel == this.l1StandardBridgeProxy.selector) _l1StandardBridgeProxy = _addr;\\n else if (_sel == this.l2OutputOracleProxy.selector) _l2OutputOracleProxy = _addr;\\n else if (_sel == this.optimismMintableErc20FactoryProxy.selector) _optimismMintableErc20FactoryProxy = _addr;\\n else if (_sel == this.optimismPortalProxy.selector) _optimismPortalProxy = _addr;\\n else if (_sel == this.systemConfigProxy.selector) _systemConfigProxy = _addr;\\n else if (_sel == this.opChainProxyAdminImpl.selector) _opChainProxyAdminImpl = _addr;\\n else if (_sel == this.anchorStateRegistryProxy.selector) _anchorStateRegistryProxy = _addr;\\n else if (_sel == this.delayedWethPermissionedGameProxy.selector) _delayedWethPermissionedGameProxy = _addr;\\n else if (_sel == this.delayedWethPermissionlessGameProxy.selector) _delayedWethPermissionlessGameProxy = _addr;\\n else if (_sel == this.disputeGameFactoryProxy.selector) _disputeGameFactoryProxy = _addr;\\n else if (_sel == this.faultDisputeGameImpl.selector) _faultDisputeGameImpl = _addr;\\n else if (_sel == this.permissionedDisputeGameImpl.selector) _permissionedDisputeGameImpl = _addr;\\n // roles\\n else if (_sel == this.systemConfigOwner.selector) _systemConfigOwner = _addr;\\n else if (_sel == this.opChainProxyAdminOwner.selector) _opChainProxyAdminOwner = _addr;\\n else if (_sel == this.opChainGuardian.selector) _opChainGuardian = _addr;\\n else if (_sel == this.challenger.selector) _challenger = _addr;\\n else if (_sel == this.proposer.selector) _proposer = _addr;\\n else if (_sel == this.unsafeBlockSigner.selector) _unsafeBlockSigner = _addr;\\n else if (_sel == this.batchSubmitter.selector) _batchSubmitter = _addr;\\n else revert(\\\"FetchChainInfoOutput: unknown address selector test\\\");\\n }\\n\\n function set(bytes4 _sel, bool _bool) public {\\n if (_sel == this.permissioned.selector) _permissioned = _bool;\\n else if (_sel == this.permissionless.selector) _permissionless = _bool;\\n else revert(\\\"FetchChainInfoOutput: unknown bool selector\\\");\\n }\\n\\n function set(bytes4 _sel, GameType _gameType) public {\\n if (_sel == this.respectedGameType.selector) _respectedGameType = _gameType;\\n else revert(\\\"FetchChainInfoOutput: unknown GameType selector\\\");\\n }\\n\\n function addressManagerImpl() public view returns (address) {\\n require(_addressManagerImpl != address(0), \\\"FetchChainInfoOutput: addressManagerImpl not set\\\");\\n return _addressManagerImpl;\\n }\\n\\n function ethLockboxProxy() public view returns (address) {\\n return _ethLockboxProxy;\\n }\\n\\n function l1CrossDomainMessengerProxy() public view returns (address) {\\n require(_l1CrossDomainMessengerProxy != address(0), \\\"FetchChainInfoOutput: l1CrossDomainMessengerProxy not set\\\");\\n return _l1CrossDomainMessengerProxy;\\n }\\n\\n function l1Erc721BridgeProxy() public view returns (address) {\\n require(_l1Erc721BridgeProxy != address(0), \\\"FetchChainInfoOutput: l1Erc721BridgeProxy not set\\\");\\n return _l1Erc721BridgeProxy;\\n }\\n\\n function l1StandardBridgeProxy() public view returns (address) {\\n require(_l1StandardBridgeProxy != address(0), \\\"FetchChainInfoOutput: l1StandardBridgeProxy not set\\\");\\n return _l1StandardBridgeProxy;\\n }\\n\\n function l2OutputOracleProxy() public view returns (address) {\\n require(_l2OutputOracleProxy != address(0), \\\"FetchChainInfoOutput: l2OutputOracleProxy not set\\\");\\n return _l2OutputOracleProxy;\\n }\\n\\n function optimismMintableErc20FactoryProxy() public view returns (address) {\\n require(\\n _optimismMintableErc20FactoryProxy != address(0),\\n \\\"FetchChainInfoOutput: optimismMintableErc20FactoryProxy not set\\\"\\n );\\n return _optimismMintableErc20FactoryProxy;\\n }\\n\\n function optimismPortalProxy() public view returns (address) {\\n require(_optimismPortalProxy != address(0), \\\"FetchChainInfoOutput: optimismPortalProxy not set\\\");\\n return _optimismPortalProxy;\\n }\\n\\n function systemConfigProxy() public view returns (address) {\\n require(_systemConfigProxy != address(0), \\\"FetchChainInfoOutput: systemConfigProxy not set\\\");\\n return _systemConfigProxy;\\n }\\n\\n function opChainProxyAdminImpl() public view returns (address) {\\n require(_opChainProxyAdminImpl != address(0), \\\"FetchChainInfoOutput: opChainProxyAdminImpl not set\\\");\\n return _opChainProxyAdminImpl;\\n }\\n\\n function superchainConfigProxy() public view returns (address) {\\n require(_superchainConfigProxy != address(0), \\\"FetchChainInfoOutput: superchainConfigProxy not set\\\");\\n return _superchainConfigProxy;\\n }\\n\\n function anchorStateRegistryProxy() public view returns (address) {\\n require(_anchorStateRegistryProxy != address(0), \\\"FetchChainInfoOutput: anchorStateRegistryProxy not set\\\");\\n return _anchorStateRegistryProxy;\\n }\\n\\n function delayedWethPermissionedGameProxy() public view returns (address) {\\n return _delayedWethPermissionedGameProxy;\\n }\\n\\n function delayedWethPermissionlessGameProxy() public view returns (address) {\\n return _delayedWethPermissionlessGameProxy;\\n }\\n\\n function disputeGameFactoryProxy() public view returns (address) {\\n return _disputeGameFactoryProxy;\\n }\\n\\n function faultDisputeGameImpl() public view returns (address) {\\n require(_faultDisputeGameImpl != address(0), \\\"FetchChainInfoOutput: faultDisputeGameImpl not set\\\");\\n return _faultDisputeGameImpl;\\n }\\n\\n function mipsImpl() public view returns (address) {\\n require(_mipsImpl != address(0), \\\"FetchChainInfoOutput: mipsImpl not set\\\");\\n return _mipsImpl;\\n }\\n\\n function permissionedDisputeGameImpl() public view returns (address) {\\n require(_permissionedDisputeGameImpl != address(0), \\\"FetchChainInfoOutput: permissionedDisputeGameImpl not set\\\");\\n return _permissionedDisputeGameImpl;\\n }\\n\\n function preimageOracleImpl() public view returns (address) {\\n require(_preimageOracleImpl != address(0), \\\"FetchChainInfoOutput: preimageOracleImpl not set\\\");\\n return _preimageOracleImpl;\\n }\\n\\n function systemConfigOwner() public view returns (address) {\\n require(_systemConfigOwner != address(0), \\\"FetchChainInfoOutput: systemConfigOwner not set\\\");\\n return _systemConfigOwner;\\n }\\n\\n function opChainProxyAdminOwner() public view returns (address) {\\n require(_opChainProxyAdminOwner != address(0), \\\"FetchChainInfoOutput: opChainProxyAdminOwner not set\\\");\\n return _opChainProxyAdminOwner;\\n }\\n\\n function opChainGuardian() public view returns (address) {\\n require(_opChainGuardian != address(0), \\\"FetchChainInfoOutput: opChainGuardian not set\\\");\\n return _opChainGuardian;\\n }\\n\\n function challenger() public view returns (address) {\\n require(_challenger != address(0), \\\"FetchChainInfoOutput: challenger not set\\\");\\n return _challenger;\\n }\\n\\n function proposer() public view returns (address) {\\n require(_proposer != address(0), \\\"FetchChainInfoOutput: proposer not set\\\");\\n return _proposer;\\n }\\n\\n function unsafeBlockSigner() public view returns (address) {\\n require(_unsafeBlockSigner != address(0), \\\"FetchChainInfoOutput: unsafeBlockSigner not set\\\");\\n return _unsafeBlockSigner;\\n }\\n\\n function batchSubmitter() public view returns (address) {\\n require(_batchSubmitter != address(0), \\\"FetchChainInfoOutput: batchSubmitter not set\\\");\\n return _batchSubmitter;\\n }\\n\\n function permissioned() public view returns (bool) {\\n return _permissioned;\\n }\\n\\n function permissionless() public view returns (bool) {\\n return _permissionless;\\n }\\n\\n function respectedGameType() public view returns (GameType) {\\n return _respectedGameType;\\n }\\n}\\n\\ncontract FetchChainInfo is Script {\\n function run(FetchChainInfoInput _fi, FetchChainInfoOutput _fo) public {\\n _processSystemConfig(_fi, _fo);\\n _processMessengerAndPortal(_fi, _fo);\\n _processFaultProofs(_fo);\\n }\\n\\n function _processSystemConfig(FetchChainInfoInput _fi, FetchChainInfoOutput _fo) internal {\\n address systemConfigProxy = _fi.systemConfigProxy();\\n _fo.set(_fo.systemConfigProxy.selector, systemConfigProxy);\\n\\n address systemConfigOwner = IFetcher(systemConfigProxy).owner();\\n _fo.set(_fo.systemConfigOwner.selector, systemConfigOwner);\\n\\n address unsafeBlockSigner = IFetcher(systemConfigProxy).unsafeBlockSigner();\\n _fo.set(_fo.unsafeBlockSigner.selector, unsafeBlockSigner);\\n\\n address batchSubmitter = _getBatchSubmitter(systemConfigProxy);\\n _fo.set(_fo.batchSubmitter.selector, batchSubmitter);\\n\\n address opChainProxyAdminImpl = _getProxyAdmin(systemConfigProxy);\\n _fo.set(_fo.opChainProxyAdminImpl.selector, opChainProxyAdminImpl);\\n\\n address opChainProxyAdminOwner = IFetcher(opChainProxyAdminImpl).owner();\\n _fo.set(_fo.opChainProxyAdminOwner.selector, opChainProxyAdminOwner);\\n\\n address l1Erc721BridgeProxy = _getL1ERC721BridgeProxy(systemConfigProxy);\\n _fo.set(_fo.l1Erc721BridgeProxy.selector, l1Erc721BridgeProxy);\\n\\n address optimismMintableErc20FactoryProxy = _getOptimismMintableERC20FactoryProxy(systemConfigProxy);\\n _fo.set(_fo.optimismMintableErc20FactoryProxy.selector, optimismMintableErc20FactoryProxy);\\n }\\n\\n function _processMessengerAndPortal(FetchChainInfoInput _fi, FetchChainInfoOutput _fo) internal {\\n address l1StandardBridgeProxy = _fi.l1StandardBridgeProxy();\\n _fo.set(_fo.l1StandardBridgeProxy.selector, l1StandardBridgeProxy);\\n\\n address l1CrossDomainMessengerProxy = IFetcher(l1StandardBridgeProxy).messenger();\\n _fo.set(_fo.l1CrossDomainMessengerProxy.selector, l1CrossDomainMessengerProxy);\\n\\n address addressManagerImpl = _getAddressManager(l1CrossDomainMessengerProxy);\\n _fo.set(_fo.addressManagerImpl.selector, addressManagerImpl);\\n\\n address optimismPortalProxy = _getOptimismPortalProxy(l1CrossDomainMessengerProxy);\\n _fo.set(_fo.optimismPortalProxy.selector, optimismPortalProxy);\\n\\n address opChainGuardian = _getGuardian(optimismPortalProxy);\\n _fo.set(_fo.opChainGuardian.selector, opChainGuardian);\\n\\n address ethLockboxProxy = _getEthLockboxProxy(optimismPortalProxy);\\n _fo.set(_fo.ethLockboxProxy.selector, ethLockboxProxy);\\n\\n address superchainConfigProxy = _getSuperchainConfigProxy(optimismPortalProxy);\\n _fo.set(_fo.superchainConfigProxy.selector, superchainConfigProxy);\\n }\\n\\n function _processFaultProofs(FetchChainInfoOutput _fo) internal {\\n address systemConfigProxy = _fo.systemConfigProxy();\\n address optimismPortalProxy = _fo.optimismPortalProxy();\\n\\n try IFetcher(optimismPortalProxy).respectedGameType() returns (GameType gameType_) {\\n _fo.set(_fo.respectedGameType.selector, gameType_);\\n } catch {\\n // default respectedGameType to uint32.max since 0 == CANNON\\n _fo.set(_fo.respectedGameType.selector, GameType.wrap(type(uint32).max));\\n address l2OutputOracleProxy;\\n try IFetcher(optimismPortalProxy).l2Oracle() returns (address l2Oracle_) {\\n l2OutputOracleProxy = l2Oracle_;\\n } catch {\\n l2OutputOracleProxy = IFetcher(optimismPortalProxy).L2_ORACLE();\\n }\\n _fo.set(_fo.l2OutputOracleProxy.selector, l2OutputOracleProxy);\\n\\n address proposer = IFetcher(l2OutputOracleProxy).PROPOSER();\\n _fo.set(_fo.proposer.selector, proposer);\\n\\n // no fault proofs installed so we're done\\n return;\\n }\\n\\n address disputeGameFactoryProxy = _getDisputeGameFactoryProxy(systemConfigProxy);\\n if (disputeGameFactoryProxy != address(0)) {\\n _fo.set(_fo.disputeGameFactoryProxy.selector, disputeGameFactoryProxy);\\n\\n address permissionedDisputeGameImpl = _getPermissionedDisputeGame(disputeGameFactoryProxy);\\n if (permissionedDisputeGameImpl != address(0)) {\\n // permissioned fault proofs installed\\n _fo.set(_fo.permissioned.selector, true);\\n _fo.set(_fo.permissionedDisputeGameImpl.selector, permissionedDisputeGameImpl);\\n\\n address challenger = IFetcher(permissionedDisputeGameImpl).challenger();\\n _fo.set(_fo.challenger.selector, challenger);\\n\\n address anchorStateRegistryProxy = IFetcher(permissionedDisputeGameImpl).anchorStateRegistry();\\n _fo.set(_fo.anchorStateRegistryProxy.selector, anchorStateRegistryProxy);\\n\\n address proposer = IFetcher(permissionedDisputeGameImpl).proposer();\\n _fo.set(_fo.proposer.selector, proposer);\\n\\n address delayedWethPermissionedGameProxy = _getDelayedWETHProxy(permissionedDisputeGameImpl);\\n _fo.set(_fo.delayedWethPermissionedGameProxy.selector, delayedWethPermissionedGameProxy);\\n\\n address mipsImpl = IFetcher(permissionedDisputeGameImpl).vm();\\n _fo.set(_fo.mipsImpl.selector, mipsImpl);\\n\\n address preimageOracleImpl = IFetcher(mipsImpl).oracle();\\n _fo.set(_fo.preimageOracleImpl.selector, preimageOracleImpl);\\n }\\n\\n address faultDisputeGameImpl = _getFaultDisputeGame(disputeGameFactoryProxy);\\n if (faultDisputeGameImpl != address(0)) {\\n // permissionless fault proofs installed\\n _fo.set(_fo.faultDisputeGameImpl.selector, faultDisputeGameImpl);\\n _fo.set(_fo.permissionless.selector, true);\\n\\n address delayedWethPermissionlessGameProxy = _getDelayedWETHProxy(faultDisputeGameImpl);\\n _fo.set(_fo.delayedWethPermissionlessGameProxy.selector, delayedWethPermissionlessGameProxy);\\n }\\n } else {\\n // some older chains have L2OutputOracle instead of DisputeGameFactory.\\n address l2OutputOracleProxy = IFetcher(optimismPortalProxy).L2_ORACLE();\\n _fo.set(_fo.l2OutputOracleProxy.selector, l2OutputOracleProxy);\\n address proposer = IFetcher(l2OutputOracleProxy).PROPOSER();\\n _fo.set(_fo.proposer.selector, proposer);\\n }\\n }\\n\\n function _getGuardian(address _portal) internal view returns (address) {\\n try IFetcher(_portal).guardian() returns (address guardian_) {\\n return guardian_;\\n } catch {\\n return IFetcher(_portal).GUARDIAN();\\n }\\n }\\n\\n function _getSystemConfigProxy(address _portal) internal view returns (address) {\\n try IFetcher(_portal).systemConfig() returns (address systemConfig_) {\\n return systemConfig_;\\n } catch {\\n return IFetcher(_portal).SYSTEM_CONFIG();\\n }\\n }\\n\\n function _getOptimismPortalProxy(address _l1CrossDomainMessengerProxy) internal view returns (address) {\\n try IFetcher(_l1CrossDomainMessengerProxy).portal() returns (address optimismPortal_) {\\n return optimismPortal_;\\n } catch {\\n return IFetcher(_l1CrossDomainMessengerProxy).PORTAL();\\n }\\n }\\n\\n function _getAddressManager(address _l1CrossDomainMessengerProxy) internal view returns (address) {\\n uint256 ADDRESS_MANAGER_MAPPING_SLOT = 1;\\n bytes32 slot = keccak256(abi.encode(_l1CrossDomainMessengerProxy, ADDRESS_MANAGER_MAPPING_SLOT));\\n return address(uint160(uint256((vm.load(_l1CrossDomainMessengerProxy, slot)))));\\n }\\n\\n function _getL1ERC721BridgeProxy(address _systemConfigProxy) internal view returns (address) {\\n try IFetcher(_systemConfigProxy).l1ERC721Bridge() returns (address l1ERC721BridgeProxy_) {\\n return l1ERC721BridgeProxy_;\\n } catch {\\n return address(0);\\n }\\n }\\n\\n function _getOptimismMintableERC20FactoryProxy(address _systemConfigProxy) internal view returns (address) {\\n try IFetcher(_systemConfigProxy).optimismMintableERC20Factory() returns (\\n address optimismMintableERC20FactoryProxy_\\n ) {\\n return optimismMintableERC20FactoryProxy_;\\n } catch {\\n return address(0);\\n }\\n }\\n\\n function _getDisputeGameFactoryProxy(address _systemConfigProxy) internal view returns (address) {\\n try IFetcher(_systemConfigProxy).disputeGameFactory() returns (address disputeGameFactoryProxy_) {\\n return disputeGameFactoryProxy_;\\n } catch {\\n // Some older chains have L2OutputOracle instead of DisputeGameFactory\\n return address(0);\\n }\\n }\\n\\n function _getSuperchainConfigProxy(address _optimismPortalProxy) internal view returns (address) {\\n try IFetcher(_optimismPortalProxy).superchainConfig() returns (address superchainConfigProxy_) {\\n return superchainConfigProxy_;\\n } catch {\\n return address(0);\\n }\\n }\\n\\n function _getFaultDisputeGame(address _disputeGameFactoryProxy) internal view returns (address) {\\n try IFetcher(_disputeGameFactoryProxy).gameImpls(GameTypes.CANNON) returns (address faultDisputeGame_) {\\n return faultDisputeGame_;\\n } catch {\\n return address(0);\\n }\\n }\\n\\n function _getPermissionedDisputeGame(address _disputeGameFactoryProxy) internal view returns (address) {\\n try IFetcher(_disputeGameFactoryProxy).gameImpls(GameTypes.PERMISSIONED_CANNON) returns (\\n address permissionedDisputeGame_\\n ) {\\n return permissionedDisputeGame_;\\n } catch {\\n return address(0);\\n }\\n }\\n\\n function _getEthLockboxProxy(address _optimismPortalProxy) internal view returns (address) {\\n try IFetcher(_optimismPortalProxy).ethLockbox() returns (address ethLockbox_) {\\n return ethLockbox_;\\n } catch {\\n return address(0);\\n }\\n }\\n\\n function _getDelayedWETHProxy(address _disputeGame) internal view returns (address) {\\n (bool ok, bytes memory data) = address(_disputeGame).staticcall(abi.encodeCall(IFetcher.weth, ()));\\n if (ok && data.length == 32) return abi.decode(data, (address));\\n else return address(0);\\n }\\n\\n function _getBatchSubmitter(address _systemConfigProxy) internal view returns (address) {\\n bytes32 batcherHash = IFetcher(_systemConfigProxy).batcherHash();\\n return address(uint160(uint256(batcherHash)));\\n }\\n\\n function _getProxyAdmin(address _systemConfigProxy) internal returns (address) {\\n vm.prank(address(0));\\n return IFetcher(_systemConfigProxy).admin();\\n }\\n}\\n\",\"keccak256\":\"0x202fb27a5a78b7d8c96c3a4ea69981dc4eeda765aa2747699ac80b8499feb709\",\"license\":\"MIT\"},\"src/dispute/lib/LibPosition.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.15;\\n\\nusing LibPosition for Position global;\\n\\n/// @notice A `Position` represents a position of a claim within the game tree.\\n/// @dev This is represented as a \\\"generalized index\\\" where the high-order bit\\n/// is the level in the tree and the remaining bits is a unique bit pattern, allowing\\n/// a unique identifier for each node in the tree. Mathematically, it is calculated\\n/// as 2^{depth} + indexAtDepth.\\ntype Position is uint128;\\n\\n/// @title LibPosition\\n/// @notice This library contains helper functions for working with the `Position` type.\\nlibrary LibPosition {\\n /// @notice the `MAX_POSITION_BITLEN` is the number of bits that the `Position` type, and the implementation of\\n /// its behavior within this library, can safely support.\\n uint8 internal constant MAX_POSITION_BITLEN = 126;\\n\\n /// @notice Computes a generalized index (2^{depth} + indexAtDepth).\\n /// @param _depth The depth of the position.\\n /// @param _indexAtDepth The index at the depth of the position.\\n /// @return position_ The computed generalized index.\\n function wrap(uint8 _depth, uint128 _indexAtDepth) internal pure returns (Position position_) {\\n assembly {\\n // gindex = 2^{_depth} + _indexAtDepth\\n position_ := add(shl(_depth, 1), _indexAtDepth)\\n }\\n }\\n\\n /// @notice Pulls the `depth` out of a `Position` type.\\n /// @param _position The generalized index to get the `depth` of.\\n /// @return depth_ The `depth` of the `position` gindex.\\n /// @custom:attribution Solady \\n function depth(Position _position) internal pure returns (uint8 depth_) {\\n // Return the most significant bit offset, which signifies the depth of the gindex.\\n assembly {\\n depth_ := or(depth_, shl(6, lt(0xffffffffffffffff, shr(depth_, _position))))\\n depth_ := or(depth_, shl(5, lt(0xffffffff, shr(depth_, _position))))\\n\\n // For the remaining 32 bits, use a De Bruijn lookup.\\n _position := shr(depth_, _position)\\n _position := or(_position, shr(1, _position))\\n _position := or(_position, shr(2, _position))\\n _position := or(_position, shr(4, _position))\\n _position := or(_position, shr(8, _position))\\n _position := or(_position, shr(16, _position))\\n\\n depth_ :=\\n or(\\n depth_,\\n byte(\\n shr(251, mul(_position, shl(224, 0x07c4acdd))),\\n 0x0009010a0d15021d0b0e10121619031e080c141c0f111807131b17061a05041f\\n )\\n )\\n }\\n }\\n\\n /// @notice Pulls the `indexAtDepth` out of a `Position` type.\\n /// The `indexAtDepth` is the left/right index of a position at a specific depth within\\n /// the binary tree, starting from index 0. For example, at gindex 2, the `depth` = 1\\n /// and the `indexAtDepth` = 0.\\n /// @param _position The generalized index to get the `indexAtDepth` of.\\n /// @return indexAtDepth_ The `indexAtDepth` of the `position` gindex.\\n function indexAtDepth(Position _position) internal pure returns (uint128 indexAtDepth_) {\\n // Return bits p_{msb-1}...p_{0}. This effectively pulls the 2^{depth} out of the gindex,\\n // leaving only the `indexAtDepth`.\\n uint256 msb = depth(_position);\\n assembly {\\n indexAtDepth_ := sub(_position, shl(msb, 1))\\n }\\n }\\n\\n /// @notice Get the left child of `_position`.\\n /// @param _position The position to get the left position of.\\n /// @return left_ The position to the left of `position`.\\n function left(Position _position) internal pure returns (Position left_) {\\n assembly {\\n left_ := shl(1, _position)\\n }\\n }\\n\\n /// @notice Get the right child of `_position`\\n /// @param _position The position to get the right position of.\\n /// @return right_ The position to the right of `position`.\\n function right(Position _position) internal pure returns (Position right_) {\\n assembly {\\n right_ := or(1, shl(1, _position))\\n }\\n }\\n\\n /// @notice Get the parent position of `_position`.\\n /// @param _position The position to get the parent position of.\\n /// @return parent_ The parent position of `position`.\\n function parent(Position _position) internal pure returns (Position parent_) {\\n assembly {\\n parent_ := shr(1, _position)\\n }\\n }\\n\\n /// @notice Get the deepest, right most gindex relative to the `position`. This is equivalent to\\n /// calling `right` on a position until the maximum depth is reached.\\n /// @param _position The position to get the relative deepest, right most gindex of.\\n /// @param _maxDepth The maximum depth of the game.\\n /// @return rightIndex_ The deepest, right most gindex relative to the `position`.\\n function rightIndex(Position _position, uint256 _maxDepth) internal pure returns (Position rightIndex_) {\\n uint256 msb = depth(_position);\\n assembly {\\n let remaining := sub(_maxDepth, msb)\\n rightIndex_ := or(shl(remaining, _position), sub(shl(remaining, 1), 1))\\n }\\n }\\n\\n /// @notice Get the deepest, right most trace index relative to the `position`. This is\\n /// equivalent to calling `right` on a position until the maximum depth is reached and\\n /// then finding its index at depth.\\n /// @param _position The position to get the relative trace index of.\\n /// @param _maxDepth The maximum depth of the game.\\n /// @return traceIndex_ The trace index relative to the `position`.\\n function traceIndex(Position _position, uint256 _maxDepth) internal pure returns (uint256 traceIndex_) {\\n uint256 msb = depth(_position);\\n assembly {\\n let remaining := sub(_maxDepth, msb)\\n traceIndex_ := sub(or(shl(remaining, _position), sub(shl(remaining, 1), 1)), shl(_maxDepth, 1))\\n }\\n }\\n\\n /// @notice Gets the position of the highest ancestor of `_position` that commits to the same\\n /// trace index.\\n /// @param _position The position to get the highest ancestor of.\\n /// @return ancestor_ The highest ancestor of `position` that commits to the same trace index.\\n function traceAncestor(Position _position) internal pure returns (Position ancestor_) {\\n // Create a field with only the lowest unset bit of `_position` set.\\n Position lsb;\\n assembly {\\n lsb := and(not(_position), add(_position, 1))\\n }\\n // Find the index of the lowest unset bit within the field.\\n uint256 msb = depth(lsb);\\n // The highest ancestor that commits to the same trace index is the original position\\n // shifted right by the index of the lowest unset bit.\\n assembly {\\n let a := shr(msb, _position)\\n // Bound the ancestor to the minimum gindex, 1.\\n ancestor_ := or(a, iszero(a))\\n }\\n }\\n\\n /// @notice Gets the position of the highest ancestor of `_position` that commits to the same\\n /// trace index, while still being below `_upperBoundExclusive`.\\n /// @param _position The position to get the highest ancestor of.\\n /// @param _upperBoundExclusive The exclusive upper depth bound, used to inform where to stop in order\\n /// to not escape a sub-tree.\\n /// @return ancestor_ The highest ancestor of `position` that commits to the same trace index.\\n function traceAncestorBounded(\\n Position _position,\\n uint256 _upperBoundExclusive\\n )\\n internal\\n pure\\n returns (Position ancestor_)\\n {\\n // This function only works for positions that are below the upper bound.\\n if (_position.depth() <= _upperBoundExclusive) {\\n assembly {\\n // Revert with `ClaimAboveSplit()`\\n mstore(0x00, 0xb34b5c22)\\n revert(0x1C, 0x04)\\n }\\n }\\n\\n // Grab the global trace ancestor.\\n ancestor_ = traceAncestor(_position);\\n\\n // If the ancestor is above or at the upper bound, shift it to be below the upper bound.\\n // This should be a special case that only covers positions that commit to the final leaf\\n // in a sub-tree.\\n if (ancestor_.depth() <= _upperBoundExclusive) {\\n ancestor_ = ancestor_.rightIndex(_upperBoundExclusive + 1);\\n }\\n }\\n\\n /// @notice Get the move position of `_position`, which is the left child of:\\n /// 1. `_position` if `_isAttack` is true.\\n /// 2. `_position | 1` if `_isAttack` is false.\\n /// @param _position The position to get the relative attack/defense position of.\\n /// @param _isAttack Whether or not the move is an attack move.\\n /// @return move_ The move position relative to `position`.\\n function move(Position _position, bool _isAttack) internal pure returns (Position move_) {\\n assembly {\\n move_ := shl(1, or(iszero(_isAttack), _position))\\n }\\n }\\n\\n /// @notice Get the value of a `Position` type in the form of the underlying uint128.\\n /// @param _position The position to get the value of.\\n /// @return raw_ The value of the `position` as a uint128 type.\\n function raw(Position _position) internal pure returns (uint128 raw_) {\\n assembly {\\n raw_ := _position\\n }\\n }\\n}\\n\",\"keccak256\":\"0x7c5f19f8f54f06de2ce1c6cdcc5c7af65ac405130a4066cdaf146ca315818241\",\"license\":\"MIT\"},\"src/dispute/lib/LibUDT.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.15;\\n\\n// Libraries\\nimport { Position } from \\\"src/dispute/lib/LibPosition.sol\\\";\\n\\nusing LibClaim for Claim global;\\nusing LibHash for Hash global;\\nusing LibDuration for Duration global;\\nusing LibClock for Clock global;\\nusing LibGameId for GameId global;\\nusing LibTimestamp for Timestamp global;\\nusing LibVMStatus for VMStatus global;\\nusing LibGameType for GameType global;\\n\\n/// @notice A `Clock` represents a packed `Duration` and `Timestamp`\\n/// @dev The packed layout of this type is as follows:\\n/// \\u250c\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u252c\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2510\\n/// \\u2502 Bits \\u2502 Value \\u2502\\n/// \\u251c\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u253c\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2524\\n/// \\u2502 [0, 64) \\u2502 Duration \\u2502\\n/// \\u2502 [64, 128) \\u2502 Timestamp \\u2502\\n/// \\u2514\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2534\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2518\\ntype Clock is uint128;\\n\\n/// @title LibClock\\n/// @notice This library contains helper functions for working with the `Clock` type.\\nlibrary LibClock {\\n /// @notice Packs a `Duration` and `Timestamp` into a `Clock` type.\\n /// @param _duration The `Duration` to pack into the `Clock` type.\\n /// @param _timestamp The `Timestamp` to pack into the `Clock` type.\\n /// @return clock_ The `Clock` containing the `_duration` and `_timestamp`.\\n function wrap(Duration _duration, Timestamp _timestamp) internal pure returns (Clock clock_) {\\n assembly {\\n clock_ := or(shl(0x40, _duration), _timestamp)\\n }\\n }\\n\\n /// @notice Pull the `Duration` out of a `Clock` type.\\n /// @param _clock The `Clock` type to pull the `Duration` out of.\\n /// @return duration_ The `Duration` pulled out of `_clock`.\\n function duration(Clock _clock) internal pure returns (Duration duration_) {\\n // Shift the high-order 64 bits into the low-order 64 bits, leaving only the `duration`.\\n assembly {\\n duration_ := shr(0x40, _clock)\\n }\\n }\\n\\n /// @notice Pull the `Timestamp` out of a `Clock` type.\\n /// @param _clock The `Clock` type to pull the `Timestamp` out of.\\n /// @return timestamp_ The `Timestamp` pulled out of `_clock`.\\n function timestamp(Clock _clock) internal pure returns (Timestamp timestamp_) {\\n // Clean the high-order 192 bits by shifting the clock left and then right again, leaving\\n // only the `timestamp`.\\n assembly {\\n timestamp_ := shr(0xC0, shl(0xC0, _clock))\\n }\\n }\\n\\n /// @notice Get the value of a `Clock` type in the form of the underlying uint128.\\n /// @param _clock The `Clock` type to get the value of.\\n /// @return clock_ The value of the `Clock` type as a uint128 type.\\n function raw(Clock _clock) internal pure returns (uint128 clock_) {\\n assembly {\\n clock_ := _clock\\n }\\n }\\n}\\n\\n/// @notice A `GameId` represents a packed 4 byte game ID, a 8 byte timestamp, and a 20 byte address.\\n/// @dev The packed layout of this type is as follows:\\n/// \\u250c\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u252c\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2510\\n/// \\u2502 Bits \\u2502 Value \\u2502\\n/// \\u251c\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u253c\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2524\\n/// \\u2502 [0, 32) \\u2502 Game Type \\u2502\\n/// \\u2502 [32, 96) \\u2502 Timestamp \\u2502\\n/// \\u2502 [96, 256) \\u2502 Address \\u2502\\n/// \\u2514\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2534\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2518\\ntype GameId is bytes32;\\n\\n/// @title LibGameId\\n/// @notice Utility functions for packing and unpacking GameIds.\\nlibrary LibGameId {\\n /// @notice Packs values into a 32 byte GameId type.\\n /// @param _gameType The game type.\\n /// @param _timestamp The timestamp of the game's creation.\\n /// @param _gameProxy The game proxy address.\\n /// @return gameId_ The packed GameId.\\n function pack(\\n GameType _gameType,\\n Timestamp _timestamp,\\n address _gameProxy\\n )\\n internal\\n pure\\n returns (GameId gameId_)\\n {\\n assembly {\\n gameId_ := or(or(shl(224, _gameType), shl(160, _timestamp)), _gameProxy)\\n }\\n }\\n\\n /// @notice Unpacks values from a 32 byte GameId type.\\n /// @param _gameId The packed GameId.\\n /// @return gameType_ The game type.\\n /// @return timestamp_ The timestamp of the game's creation.\\n /// @return gameProxy_ The game proxy address.\\n function unpack(GameId _gameId)\\n internal\\n pure\\n returns (GameType gameType_, Timestamp timestamp_, address gameProxy_)\\n {\\n assembly {\\n gameType_ := shr(224, _gameId)\\n timestamp_ := and(shr(160, _gameId), 0xFFFFFFFFFFFFFFFF)\\n gameProxy_ := and(_gameId, 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF)\\n }\\n }\\n}\\n\\n/// @notice A claim represents an MPT root representing the state of the fault proof program.\\ntype Claim is bytes32;\\n\\n/// @title LibClaim\\n/// @notice This library contains helper functions for working with the `Claim` type.\\nlibrary LibClaim {\\n /// @notice Get the value of a `Claim` type in the form of the underlying bytes32.\\n /// @param _claim The `Claim` type to get the value of.\\n /// @return claim_ The value of the `Claim` type as a bytes32 type.\\n function raw(Claim _claim) internal pure returns (bytes32 claim_) {\\n assembly {\\n claim_ := _claim\\n }\\n }\\n\\n /// @notice Hashes a claim and a position together.\\n /// @param _claim A Claim type.\\n /// @param _position The position of `claim`.\\n /// @param _challengeIndex The index of the claim being moved against.\\n /// @return claimHash_ A hash of abi.encodePacked(claim, position|challengeIndex);\\n function hashClaimPos(\\n Claim _claim,\\n Position _position,\\n uint256 _challengeIndex\\n )\\n internal\\n pure\\n returns (Hash claimHash_)\\n {\\n assembly {\\n mstore(0x00, _claim)\\n mstore(0x20, or(shl(128, _position), and(0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF, _challengeIndex)))\\n claimHash_ := keccak256(0x00, 0x40)\\n }\\n }\\n}\\n\\n/// @notice A dedicated duration type.\\n/// @dev Unit: seconds\\ntype Duration is uint64;\\n\\n/// @title LibDuration\\n/// @notice This library contains helper functions for working with the `Duration` type.\\nlibrary LibDuration {\\n /// @notice Get the value of a `Duration` type in the form of the underlying uint64.\\n /// @param _duration The `Duration` type to get the value of.\\n /// @return duration_ The value of the `Duration` type as a uint64 type.\\n function raw(Duration _duration) internal pure returns (uint64 duration_) {\\n assembly {\\n duration_ := _duration\\n }\\n }\\n}\\n\\n/// @notice A custom type for a generic hash.\\ntype Hash is bytes32;\\n\\n/// @title LibHash\\n/// @notice This library contains helper functions for working with the `Hash` type.\\nlibrary LibHash {\\n /// @notice Get the value of a `Hash` type in the form of the underlying bytes32.\\n /// @param _hash The `Hash` type to get the value of.\\n /// @return hash_ The value of the `Hash` type as a bytes32 type.\\n function raw(Hash _hash) internal pure returns (bytes32 hash_) {\\n assembly {\\n hash_ := _hash\\n }\\n }\\n}\\n\\n/// @notice A dedicated timestamp type.\\ntype Timestamp is uint64;\\n\\n/// @title LibTimestamp\\n/// @notice This library contains helper functions for working with the `Timestamp` type.\\nlibrary LibTimestamp {\\n /// @notice Get the value of a `Timestamp` type in the form of the underlying uint64.\\n /// @param _timestamp The `Timestamp` type to get the value of.\\n /// @return timestamp_ The value of the `Timestamp` type as a uint64 type.\\n function raw(Timestamp _timestamp) internal pure returns (uint64 timestamp_) {\\n assembly {\\n timestamp_ := _timestamp\\n }\\n }\\n}\\n\\n/// @notice A `VMStatus` represents the status of a VM execution.\\ntype VMStatus is uint8;\\n\\n/// @title LibVMStatus\\n/// @notice This library contains helper functions for working with the `VMStatus` type.\\nlibrary LibVMStatus {\\n /// @notice Get the value of a `VMStatus` type in the form of the underlying uint8.\\n /// @param _vmstatus The `VMStatus` type to get the value of.\\n /// @return vmstatus_ The value of the `VMStatus` type as a uint8 type.\\n function raw(VMStatus _vmstatus) internal pure returns (uint8 vmstatus_) {\\n assembly {\\n vmstatus_ := _vmstatus\\n }\\n }\\n}\\n\\n/// @notice A `GameType` represents the type of game being played.\\ntype GameType is uint32;\\n\\n/// @title LibGameType\\n/// @notice This library contains helper functions for working with the `GameType` type.\\nlibrary LibGameType {\\n /// @notice Get the value of a `GameType` type in the form of the underlying uint32.\\n /// @param _gametype The `GameType` type to get the value of.\\n /// @return gametype_ The value of the `GameType` type as a uint32 type.\\n function raw(GameType _gametype) internal pure returns (uint32 gametype_) {\\n assembly {\\n gametype_ := _gametype\\n }\\n }\\n}\\n\",\"keccak256\":\"0x41d55e9c74d979b5b797198e38449e7cef4f925e04d61f7699e9c150c4a659d3\",\"license\":\"MIT\"},\"src/dispute/lib/Types.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.15;\\n\\n// Libraries\\nimport {\\n Position,\\n Hash,\\n GameType,\\n VMStatus,\\n Timestamp,\\n Duration,\\n Clock,\\n GameId,\\n Claim,\\n LibGameId,\\n LibClock\\n} from \\\"src/dispute/lib/LibUDT.sol\\\";\\n\\n/// @notice The current status of the dispute game.\\nenum GameStatus {\\n // The game is currently in progress, and has not been resolved.\\n IN_PROGRESS,\\n // The game has concluded, and the `rootClaim` was challenged successfully.\\n CHALLENGER_WINS,\\n // The game has concluded, and the `rootClaim` could not be contested.\\n DEFENDER_WINS\\n}\\n\\n/// @notice The game's bond distribution type. Games are expected to start in the `UNDECIDED`\\n/// state, and then choose either `NORMAL` or `REFUND`.\\nenum BondDistributionMode {\\n // Bond distribution strategy has not been chosen.\\n UNDECIDED,\\n // Bonds should be distributed as normal.\\n NORMAL,\\n // Bonds should be refunded to claimants.\\n REFUND\\n}\\n\\n/// @notice Represents an L2 root and the L2 sequence number at which it was generated.\\n/// @custom:field root The output root.\\n/// @custom:field l2SequenceNumber The L2 Sequence Number ( e.g. block number / timestamp) at which the root was\\n/// generated.\\nstruct Proposal {\\n Hash root;\\n uint256 l2SequenceNumber;\\n}\\n\\n/// @title GameTypes\\n/// @notice A library that defines the IDs of games that can be played.\\nlibrary GameTypes {\\n /// @dev A dispute game type the uses the cannon vm.\\n GameType internal constant CANNON = GameType.wrap(0);\\n\\n /// @dev A permissioned dispute game type that uses the cannon vm.\\n GameType internal constant PERMISSIONED_CANNON = GameType.wrap(1);\\n\\n /// @notice A dispute game type that uses the asterisc vm.\\n GameType internal constant ASTERISC = GameType.wrap(2);\\n\\n /// @notice A dispute game type that uses the asterisc vm with Kona.\\n GameType internal constant ASTERISC_KONA = GameType.wrap(3);\\n\\n /// @notice A dispute game type that uses the cannon vm (Super Roots).\\n GameType internal constant SUPER_CANNON = GameType.wrap(4);\\n\\n /// @notice A dispute game type that uses the permissioned cannon vm (Super Roots).\\n GameType internal constant SUPER_PERMISSIONED_CANNON = GameType.wrap(5);\\n\\n /// @notice A dispute game type that uses OP Succinct\\n GameType internal constant OP_SUCCINCT = GameType.wrap(6);\\n\\n /// @notice A dispute game type with short game duration for testing withdrawals.\\n /// Not intended for production use.\\n GameType internal constant FAST = GameType.wrap(254);\\n\\n /// @notice A dispute game type that uses an alphabet vm.\\n /// Not intended for production use.\\n GameType internal constant ALPHABET = GameType.wrap(255);\\n\\n /// @notice A dispute game type that uses RISC Zero's Kailua\\n GameType internal constant KAILUA = GameType.wrap(1337);\\n}\\n\\n/// @title VMStatuses\\n/// @notice Named type aliases for the various valid VM status bytes.\\nlibrary VMStatuses {\\n /// @notice The VM has executed successfully and the outcome is valid.\\n VMStatus internal constant VALID = VMStatus.wrap(0);\\n\\n /// @notice The VM has executed successfully and the outcome is invalid.\\n VMStatus internal constant INVALID = VMStatus.wrap(1);\\n\\n /// @notice The VM has paniced.\\n VMStatus internal constant PANIC = VMStatus.wrap(2);\\n\\n /// @notice The VM execution is still in progress.\\n VMStatus internal constant UNFINISHED = VMStatus.wrap(3);\\n}\\n\\n/// @title LocalPreimageKey\\n/// @notice Named type aliases for local `PreimageOracle` key identifiers.\\nlibrary LocalPreimageKey {\\n /// @notice The identifier for the L1 head hash.\\n uint256 internal constant L1_HEAD_HASH = 0x01;\\n\\n /// @notice The identifier for the starting output root.\\n uint256 internal constant STARTING_OUTPUT_ROOT = 0x02;\\n\\n /// @notice The identifier for the disputed output root.\\n uint256 internal constant DISPUTED_OUTPUT_ROOT = 0x03;\\n\\n /// @notice The identifier for the disputed L2 block number.\\n uint256 internal constant DISPUTED_L2_BLOCK_NUMBER = 0x04;\\n\\n /// @notice The identifier for the chain ID.\\n uint256 internal constant CHAIN_ID = 0x05;\\n}\\n\",\"keccak256\":\"0x7cc2960ea5c5223d81ae2156a966fa0226b70f9666932aca63a0a2a45c9182ae\",\"license\":\"MIT\"}},\"version\":1}","metadata":{"compiler":{"version":"0.8.25+commit.b61c2a91"},"language":"Solidity","output":{"abi":[{"inputs":[],"stateMutability":"view","type":"function","name":"GUARDIAN","outputs":[{"internalType":"address","name":"","type":"address"}]},{"inputs":[],"stateMutability":"view","type":"function","name":"L2_ORACLE","outputs":[{"internalType":"address","name":"","type":"address"}]},{"inputs":[],"stateMutability":"view","type":"function","name":"PORTAL","outputs":[{"internalType":"address","name":"","type":"address"}]},{"inputs":[],"stateMutability":"view","type":"function","name":"PROPOSER","outputs":[{"internalType":"address","name":"","type":"address"}]},{"inputs":[],"stateMutability":"view","type":"function","name":"SYSTEM_CONFIG","outputs":[{"internalType":"address","name":"","type":"address"}]},{"inputs":[],"stateMutability":"view","type":"function","name":"addressManager","outputs":[{"internalType":"address","name":"","type":"address"}]},{"inputs":[],"stateMutability":"view","type":"function","name":"admin","outputs":[{"internalType":"address","name":"","type":"address"}]},{"inputs":[],"stateMutability":"view","type":"function","name":"anchorStateRegistry","outputs":[{"internalType":"address","name":"","type":"address"}]},{"inputs":[],"stateMutability":"view","type":"function","name":"batcherHash","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}]},{"inputs":[],"stateMutability":"view","type":"function","name":"challenger","outputs":[{"internalType":"address","name":"","type":"address"}]},{"inputs":[],"stateMutability":"view","type":"function","name":"disputeGameFactory","outputs":[{"internalType":"address","name":"","type":"address"}]},{"inputs":[],"stateMutability":"view","type":"function","name":"ethLockbox","outputs":[{"internalType":"address","name":"","type":"address"}]},{"inputs":[{"internalType":"GameType","name":"_gameType","type":"uint32"}],"stateMutability":"view","type":"function","name":"gameImpls","outputs":[{"internalType":"address","name":"","type":"address"}]},{"inputs":[],"stateMutability":"view","type":"function","name":"guardian","outputs":[{"internalType":"address","name":"","type":"address"}]},{"inputs":[],"stateMutability":"view","type":"function","name":"l1ERC721Bridge","outputs":[{"internalType":"address","name":"","type":"address"}]},{"inputs":[],"stateMutability":"view","type":"function","name":"l2Oracle","outputs":[{"internalType":"address","name":"","type":"address"}]},{"inputs":[],"stateMutability":"view","type":"function","name":"messenger","outputs":[{"internalType":"address","name":"","type":"address"}]},{"inputs":[],"stateMutability":"view","type":"function","name":"optimismMintableERC20Factory","outputs":[{"internalType":"address","name":"","type":"address"}]},{"inputs":[],"stateMutability":"view","type":"function","name":"oracle","outputs":[{"internalType":"address","name":"","type":"address"}]},{"inputs":[],"stateMutability":"view","type":"function","name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}]},{"inputs":[],"stateMutability":"view","type":"function","name":"portal","outputs":[{"internalType":"address","name":"","type":"address"}]},{"inputs":[],"stateMutability":"view","type":"function","name":"proposer","outputs":[{"internalType":"address","name":"","type":"address"}]},{"inputs":[],"stateMutability":"view","type":"function","name":"respectedGameType","outputs":[{"internalType":"GameType","name":"","type":"uint32"}]},{"inputs":[],"stateMutability":"view","type":"function","name":"superchainConfig","outputs":[{"internalType":"address","name":"","type":"address"}]},{"inputs":[],"stateMutability":"view","type":"function","name":"systemConfig","outputs":[{"internalType":"address","name":"","type":"address"}]},{"inputs":[],"stateMutability":"view","type":"function","name":"unsafeBlockSigner","outputs":[{"internalType":"address","name":"","type":"address"}]},{"inputs":[],"stateMutability":"view","type":"function","name":"vm","outputs":[{"internalType":"address","name":"","type":"address"}]},{"inputs":[],"stateMutability":"view","type":"function","name":"weth","outputs":[{"internalType":"address","name":"","type":"address"}]}],"devdoc":{"kind":"dev","methods":{},"version":1},"userdoc":{"kind":"user","methods":{},"version":1}},"settings":{"remappings":["@lib-keccak/=lib/lib-keccak/contracts/lib/","@openzeppelin/contracts-upgradeable/=lib/openzeppelin-contracts-upgradeable/contracts/","@openzeppelin/contracts-v5/=lib/openzeppelin-contracts-v5/contracts/","@openzeppelin/contracts/=lib/openzeppelin-contracts/contracts/","@rari-capital/solmate/=lib/solmate/","@solady-test/=lib/lib-keccak/lib/solady/test/","@solady-v0.0.245/=lib/solady-v0.0.245/src/","@solady/=lib/solady/src/","ds-test/=lib/forge-std/lib/ds-test/src/","erc4626-tests/=lib/openzeppelin-contracts-v5/lib/erc4626-tests/","forge-std/=lib/forge-std/src/","interfaces/=interfaces/","kontrol-cheatcodes/=lib/kontrol-cheatcodes/src/","lib-keccak/=lib/lib-keccak/contracts/","openzeppelin-contracts-upgradeable/=lib/openzeppelin-contracts-upgradeable/","openzeppelin-contracts-v5/=lib/openzeppelin-contracts-v5/","openzeppelin-contracts/=lib/openzeppelin-contracts/","safe-contracts/=lib/safe-contracts/contracts/","solady-v0.0.245/=lib/solady-v0.0.245/src/","solady/=lib/solady/","solmate/=lib/solmate/src/"],"optimizer":{"enabled":false,"runs":999999},"metadata":{"useLiteralContent":true,"bytecodeHash":"none"},"compilationTarget":{"scripts/FetchChainInfo.s.sol":"IFetcher"},"evmVersion":"cancun","libraries":{}},"sources":{"lib/forge-std/src/Base.sol":{"keccak256":"0xa3735a6618a3014e42bb4329ad143e3b2c59cd95094350202e4c4a06c9d585dd","urls":[],"content":"// SPDX-License-Identifier: MIT\npragma solidity >=0.6.2 <0.9.0;\n\nimport {StdStorage} from \"./StdStorage.sol\";\nimport {Vm, VmSafe} from \"./Vm.sol\";\n\nabstract contract CommonBase {\n /// @dev Cheat code address.\n /// Calculated as `address(uint160(uint256(keccak256(\"hevm cheat code\"))))`.\n address internal constant VM_ADDRESS = 0x7109709ECfa91a80626fF3989D68f67F5b1DD12D;\n /// @dev console.sol and console2.sol work by executing a staticcall to this address.\n /// Calculated as `address(uint160(uint88(bytes11(\"console.log\"))))`.\n address internal constant CONSOLE = 0x000000000000000000636F6e736F6c652e6c6f67;\n /// @dev Used when deploying with create2.\n /// Taken from https://github.com/Arachnid/deterministic-deployment-proxy.\n address internal constant CREATE2_FACTORY = 0x4e59b44847b379578588920cA78FbF26c0B4956C;\n /// @dev The default address for tx.origin and msg.sender.\n /// Calculated as `address(uint160(uint256(keccak256(\"foundry default caller\"))))`.\n address internal constant DEFAULT_SENDER = 0x1804c8AB1F12E6bbf3894d4083f33e07309d1f38;\n /// @dev The address of the first contract `CREATE`d by a running test contract.\n /// When running tests, each test contract is `CREATE`d by `DEFAULT_SENDER` with nonce 1.\n /// Calculated as `VM.computeCreateAddress(VM.computeCreateAddress(DEFAULT_SENDER, 1), 1)`.\n address internal constant DEFAULT_TEST_CONTRACT = 0x5615dEB798BB3E4dFa0139dFa1b3D433Cc23b72f;\n /// @dev Deterministic deployment address of the Multicall3 contract.\n /// Taken from https://www.multicall3.com.\n address internal constant MULTICALL3_ADDRESS = 0xcA11bde05977b3631167028862bE2a173976CA11;\n /// @dev The order of the secp256k1 curve.\n uint256 internal constant SECP256K1_ORDER =\n 115792089237316195423570985008687907852837564279074904382605163141518161494337;\n\n uint256 internal constant UINT256_MAX =\n 115792089237316195423570985008687907853269984665640564039457584007913129639935;\n\n Vm internal constant vm = Vm(VM_ADDRESS);\n StdStorage internal stdstore;\n}\n\nabstract contract TestBase is CommonBase {}\n\nabstract contract ScriptBase is CommonBase {\n VmSafe internal constant vmSafe = VmSafe(VM_ADDRESS);\n}\n","license":"MIT"},"lib/forge-std/src/Script.sol":{"keccak256":"0xc942e27c7baae499beb01afbbae99f24d42af9a6e4aae675bc6901b704aa8e9b","urls":[],"content":"// SPDX-License-Identifier: MIT\npragma solidity >=0.6.2 <0.9.0;\n\n// 💬 ABOUT\n// Forge Std's default Script.\n\n// 🧩 MODULES\nimport {console} from \"./console.sol\";\nimport {console2} from \"./console2.sol\";\nimport {safeconsole} from \"./safeconsole.sol\";\nimport {StdChains} from \"./StdChains.sol\";\nimport {StdCheatsSafe} from \"./StdCheats.sol\";\nimport {StdConstants} from \"./StdConstants.sol\";\nimport {stdJson} from \"./StdJson.sol\";\nimport {stdMath} from \"./StdMath.sol\";\nimport {StdStorage, stdStorageSafe} from \"./StdStorage.sol\";\nimport {StdStyle} from \"./StdStyle.sol\";\nimport {StdUtils} from \"./StdUtils.sol\";\nimport {VmSafe} from \"./Vm.sol\";\n\n// 📦 BOILERPLATE\nimport {ScriptBase} from \"./Base.sol\";\n\n// ⭐️ SCRIPT\nabstract contract Script is ScriptBase, StdChains, StdCheatsSafe, StdUtils {\n // Note: IS_SCRIPT() must return true.\n bool public IS_SCRIPT = true;\n}\n","license":"MIT"},"lib/forge-std/src/StdChains.sol":{"keccak256":"0x200b597cd01c229633b4a2317846cac7d36d337e2381b4a2e81faac23c2ad1cf","urls":[],"content":"// SPDX-License-Identifier: MIT\npragma solidity >=0.6.2 <0.9.0;\n\nimport {VmSafe} from \"./Vm.sol\";\n\n/**\n * StdChains provides information about EVM compatible chains that can be used in scripts/tests.\n * For each chain, the chain's name, chain ID, and a default RPC URL are provided. Chains are\n * identified by their alias, which is the same as the alias in the `[rpc_endpoints]` section of\n * the `foundry.toml` file. For best UX, ensure the alias in the `foundry.toml` file match the\n * alias used in this contract, which can be found as the first argument to the\n * `setChainWithDefaultRpcUrl` call in the `initializeStdChains` function.\n *\n * There are two main ways to use this contract:\n * 1. Set a chain with `setChain(string memory chainAlias, ChainData memory chain)` or\n * `setChain(string memory chainAlias, Chain memory chain)`\n * 2. Get a chain with `getChain(string memory chainAlias)` or `getChain(uint256 chainId)`.\n *\n * The first time either of those are used, chains are initialized with the default set of RPC URLs.\n * This is done in `initializeStdChains`, which uses `setChainWithDefaultRpcUrl`. Defaults are recorded in\n * `defaultRpcUrls`.\n *\n * The `setChain` function is straightforward, and it simply saves off the given chain data.\n *\n * The `getChain` methods use `getChainWithUpdatedRpcUrl` to return a chain. For example, let's say\n * we want to retrieve the RPC URL for `mainnet`:\n * - If you have specified data with `setChain`, it will return that.\n * - If you have configured a mainnet RPC URL in `foundry.toml`, it will return the URL, provided it\n * is valid (e.g. a URL is specified, or an environment variable is given and exists).\n * - If neither of the above conditions is met, the default data is returned.\n *\n * Summarizing the above, the prioritization hierarchy is `setChain` -> `foundry.toml` -> environment variable -> defaults.\n */\nabstract contract StdChains {\n VmSafe private constant vm = VmSafe(address(uint160(uint256(keccak256(\"hevm cheat code\")))));\n\n bool private stdChainsInitialized;\n\n struct ChainData {\n string name;\n uint256 chainId;\n string rpcUrl;\n }\n\n struct Chain {\n // The chain name.\n string name;\n // The chain's Chain ID.\n uint256 chainId;\n // The chain's alias. (i.e. what gets specified in `foundry.toml`).\n string chainAlias;\n // A default RPC endpoint for this chain.\n // NOTE: This default RPC URL is included for convenience to facilitate quick tests and\n // experimentation. Do not use this RPC URL for production test suites, CI, or other heavy\n // usage as you will be throttled and this is a disservice to others who need this endpoint.\n string rpcUrl;\n }\n\n // Maps from the chain's alias (matching the alias in the `foundry.toml` file) to chain data.\n mapping(string => Chain) private chains;\n // Maps from the chain's alias to it's default RPC URL.\n mapping(string => string) private defaultRpcUrls;\n // Maps from a chain ID to it's alias.\n mapping(uint256 => string) private idToAlias;\n\n bool private fallbackToDefaultRpcUrls = true;\n\n // The RPC URL will be fetched from config or defaultRpcUrls if possible.\n function getChain(string memory chainAlias) internal virtual returns (Chain memory chain) {\n require(bytes(chainAlias).length != 0, \"StdChains getChain(string): Chain alias cannot be the empty string.\");\n\n initializeStdChains();\n chain = chains[chainAlias];\n require(\n chain.chainId != 0,\n string(abi.encodePacked(\"StdChains getChain(string): Chain with alias \\\"\", chainAlias, \"\\\" not found.\"))\n );\n\n chain = getChainWithUpdatedRpcUrl(chainAlias, chain);\n }\n\n function getChain(uint256 chainId) internal virtual returns (Chain memory chain) {\n require(chainId != 0, \"StdChains getChain(uint256): Chain ID cannot be 0.\");\n initializeStdChains();\n string memory chainAlias = idToAlias[chainId];\n\n chain = chains[chainAlias];\n\n require(\n chain.chainId != 0,\n string(abi.encodePacked(\"StdChains getChain(uint256): Chain with ID \", vm.toString(chainId), \" not found.\"))\n );\n\n chain = getChainWithUpdatedRpcUrl(chainAlias, chain);\n }\n\n // set chain info, with priority to argument's rpcUrl field.\n function setChain(string memory chainAlias, ChainData memory chain) internal virtual {\n require(\n bytes(chainAlias).length != 0,\n \"StdChains setChain(string,ChainData): Chain alias cannot be the empty string.\"\n );\n\n require(chain.chainId != 0, \"StdChains setChain(string,ChainData): Chain ID cannot be 0.\");\n\n initializeStdChains();\n string memory foundAlias = idToAlias[chain.chainId];\n\n require(\n bytes(foundAlias).length == 0 || keccak256(bytes(foundAlias)) == keccak256(bytes(chainAlias)),\n string(\n abi.encodePacked(\n \"StdChains setChain(string,ChainData): Chain ID \",\n vm.toString(chain.chainId),\n \" already used by \\\"\",\n foundAlias,\n \"\\\".\"\n )\n )\n );\n\n uint256 oldChainId = chains[chainAlias].chainId;\n delete idToAlias[oldChainId];\n\n chains[chainAlias] =\n Chain({name: chain.name, chainId: chain.chainId, chainAlias: chainAlias, rpcUrl: chain.rpcUrl});\n idToAlias[chain.chainId] = chainAlias;\n }\n\n // set chain info, with priority to argument's rpcUrl field.\n function setChain(string memory chainAlias, Chain memory chain) internal virtual {\n setChain(chainAlias, ChainData({name: chain.name, chainId: chain.chainId, rpcUrl: chain.rpcUrl}));\n }\n\n function _toUpper(string memory str) private pure returns (string memory) {\n bytes memory strb = bytes(str);\n bytes memory copy = new bytes(strb.length);\n for (uint256 i = 0; i < strb.length; i++) {\n bytes1 b = strb[i];\n if (b >= 0x61 && b <= 0x7A) {\n copy[i] = bytes1(uint8(b) - 32);\n } else {\n copy[i] = b;\n }\n }\n return string(copy);\n }\n\n // lookup rpcUrl, in descending order of priority:\n // current -> config (foundry.toml) -> environment variable -> default\n function getChainWithUpdatedRpcUrl(string memory chainAlias, Chain memory chain)\n private\n view\n returns (Chain memory)\n {\n if (bytes(chain.rpcUrl).length == 0) {\n try vm.rpcUrl(chainAlias) returns (string memory configRpcUrl) {\n chain.rpcUrl = configRpcUrl;\n } catch (bytes memory err) {\n string memory envName = string(abi.encodePacked(_toUpper(chainAlias), \"_RPC_URL\"));\n if (fallbackToDefaultRpcUrls) {\n chain.rpcUrl = vm.envOr(envName, defaultRpcUrls[chainAlias]);\n } else {\n chain.rpcUrl = vm.envString(envName);\n }\n // Distinguish 'not found' from 'cannot read'\n // The upstream error thrown by forge for failing cheats changed so we check both the old and new versions\n bytes memory oldNotFoundError =\n abi.encodeWithSignature(\"CheatCodeError\", string(abi.encodePacked(\"invalid rpc url \", chainAlias)));\n bytes memory newNotFoundError = abi.encodeWithSignature(\n \"CheatcodeError(string)\", string(abi.encodePacked(\"invalid rpc url: \", chainAlias))\n );\n bytes32 errHash = keccak256(err);\n if (\n (errHash != keccak256(oldNotFoundError) && errHash != keccak256(newNotFoundError))\n || bytes(chain.rpcUrl).length == 0\n ) {\n /// @solidity memory-safe-assembly\n assembly {\n revert(add(32, err), mload(err))\n }\n }\n }\n }\n return chain;\n }\n\n function setFallbackToDefaultRpcUrls(bool useDefault) internal {\n fallbackToDefaultRpcUrls = useDefault;\n }\n\n function initializeStdChains() private {\n if (stdChainsInitialized) return;\n\n stdChainsInitialized = true;\n\n // If adding an RPC here, make sure to test the default RPC URL in `test_Rpcs` in `StdChains.t.sol`\n setChainWithDefaultRpcUrl(\"anvil\", ChainData(\"Anvil\", 31337, \"http://127.0.0.1:8545\"));\n setChainWithDefaultRpcUrl(\"mainnet\", ChainData(\"Mainnet\", 1, \"https://eth.llamarpc.com\"));\n setChainWithDefaultRpcUrl(\n \"sepolia\", ChainData(\"Sepolia\", 11155111, \"https://sepolia.infura.io/v3/b9794ad1ddf84dfb8c34d6bb5dca2001\")\n );\n setChainWithDefaultRpcUrl(\"holesky\", ChainData(\"Holesky\", 17000, \"https://rpc.holesky.ethpandaops.io\"));\n setChainWithDefaultRpcUrl(\"optimism\", ChainData(\"Optimism\", 10, \"https://mainnet.optimism.io\"));\n setChainWithDefaultRpcUrl(\n \"optimism_sepolia\", ChainData(\"Optimism Sepolia\", 11155420, \"https://sepolia.optimism.io\")\n );\n setChainWithDefaultRpcUrl(\"arbitrum_one\", ChainData(\"Arbitrum One\", 42161, \"https://arb1.arbitrum.io/rpc\"));\n setChainWithDefaultRpcUrl(\n \"arbitrum_one_sepolia\", ChainData(\"Arbitrum One Sepolia\", 421614, \"https://sepolia-rollup.arbitrum.io/rpc\")\n );\n setChainWithDefaultRpcUrl(\"arbitrum_nova\", ChainData(\"Arbitrum Nova\", 42170, \"https://nova.arbitrum.io/rpc\"));\n setChainWithDefaultRpcUrl(\"polygon\", ChainData(\"Polygon\", 137, \"https://polygon-rpc.com\"));\n setChainWithDefaultRpcUrl(\n \"polygon_amoy\", ChainData(\"Polygon Amoy\", 80002, \"https://rpc-amoy.polygon.technology\")\n );\n setChainWithDefaultRpcUrl(\"avalanche\", ChainData(\"Avalanche\", 43114, \"https://api.avax.network/ext/bc/C/rpc\"));\n setChainWithDefaultRpcUrl(\n \"avalanche_fuji\", ChainData(\"Avalanche Fuji\", 43113, \"https://api.avax-test.network/ext/bc/C/rpc\")\n );\n setChainWithDefaultRpcUrl(\n \"bnb_smart_chain\", ChainData(\"BNB Smart Chain\", 56, \"https://bsc-dataseed1.binance.org\")\n );\n setChainWithDefaultRpcUrl(\n \"bnb_smart_chain_testnet\",\n ChainData(\"BNB Smart Chain Testnet\", 97, \"https://rpc.ankr.com/bsc_testnet_chapel\")\n );\n setChainWithDefaultRpcUrl(\"gnosis_chain\", ChainData(\"Gnosis Chain\", 100, \"https://rpc.gnosischain.com\"));\n setChainWithDefaultRpcUrl(\"moonbeam\", ChainData(\"Moonbeam\", 1284, \"https://rpc.api.moonbeam.network\"));\n setChainWithDefaultRpcUrl(\n \"moonriver\", ChainData(\"Moonriver\", 1285, \"https://rpc.api.moonriver.moonbeam.network\")\n );\n setChainWithDefaultRpcUrl(\"moonbase\", ChainData(\"Moonbase\", 1287, \"https://rpc.testnet.moonbeam.network\"));\n setChainWithDefaultRpcUrl(\"base_sepolia\", ChainData(\"Base Sepolia\", 84532, \"https://sepolia.base.org\"));\n setChainWithDefaultRpcUrl(\"base\", ChainData(\"Base\", 8453, \"https://mainnet.base.org\"));\n setChainWithDefaultRpcUrl(\"blast_sepolia\", ChainData(\"Blast Sepolia\", 168587773, \"https://sepolia.blast.io\"));\n setChainWithDefaultRpcUrl(\"blast\", ChainData(\"Blast\", 81457, \"https://rpc.blast.io\"));\n setChainWithDefaultRpcUrl(\"fantom_opera\", ChainData(\"Fantom Opera\", 250, \"https://rpc.ankr.com/fantom/\"));\n setChainWithDefaultRpcUrl(\n \"fantom_opera_testnet\", ChainData(\"Fantom Opera Testnet\", 4002, \"https://rpc.ankr.com/fantom_testnet/\")\n );\n setChainWithDefaultRpcUrl(\"fraxtal\", ChainData(\"Fraxtal\", 252, \"https://rpc.frax.com\"));\n setChainWithDefaultRpcUrl(\"fraxtal_testnet\", ChainData(\"Fraxtal Testnet\", 2522, \"https://rpc.testnet.frax.com\"));\n setChainWithDefaultRpcUrl(\n \"berachain_bartio_testnet\", ChainData(\"Berachain bArtio Testnet\", 80084, \"https://bartio.rpc.berachain.com\")\n );\n setChainWithDefaultRpcUrl(\"flare\", ChainData(\"Flare\", 14, \"https://flare-api.flare.network/ext/C/rpc\"));\n setChainWithDefaultRpcUrl(\n \"flare_coston2\", ChainData(\"Flare Coston2\", 114, \"https://coston2-api.flare.network/ext/C/rpc\")\n );\n\n setChainWithDefaultRpcUrl(\"mode\", ChainData(\"Mode\", 34443, \"https://mode.drpc.org\"));\n setChainWithDefaultRpcUrl(\"mode_sepolia\", ChainData(\"Mode Sepolia\", 919, \"https://sepolia.mode.network\"));\n\n setChainWithDefaultRpcUrl(\"zora\", ChainData(\"Zora\", 7777777, \"https://zora.drpc.org\"));\n setChainWithDefaultRpcUrl(\n \"zora_sepolia\", ChainData(\"Zora Sepolia\", 999999999, \"https://sepolia.rpc.zora.energy\")\n );\n\n setChainWithDefaultRpcUrl(\"race\", ChainData(\"Race\", 6805, \"https://racemainnet.io\"));\n setChainWithDefaultRpcUrl(\"race_sepolia\", ChainData(\"Race Sepolia\", 6806, \"https://racemainnet.io\"));\n\n setChainWithDefaultRpcUrl(\"metal\", ChainData(\"Metal\", 1750, \"https://metall2.drpc.org\"));\n setChainWithDefaultRpcUrl(\"metal_sepolia\", ChainData(\"Metal Sepolia\", 1740, \"https://testnet.rpc.metall2.com\"));\n\n setChainWithDefaultRpcUrl(\"binary\", ChainData(\"Binary\", 624, \"https://rpc.zero.thebinaryholdings.com\"));\n setChainWithDefaultRpcUrl(\n \"binary_sepolia\", ChainData(\"Binary Sepolia\", 625, \"https://rpc.zero.thebinaryholdings.com\")\n );\n\n setChainWithDefaultRpcUrl(\"orderly\", ChainData(\"Orderly\", 291, \"https://rpc.orderly.network\"));\n setChainWithDefaultRpcUrl(\n \"orderly_sepolia\", ChainData(\"Orderly Sepolia\", 4460, \"https://testnet-rpc.orderly.org\")\n );\n }\n\n // set chain info, with priority to chainAlias' rpc url in foundry.toml\n function setChainWithDefaultRpcUrl(string memory chainAlias, ChainData memory chain) private {\n string memory rpcUrl = chain.rpcUrl;\n defaultRpcUrls[chainAlias] = rpcUrl;\n chain.rpcUrl = \"\";\n setChain(chainAlias, chain);\n chain.rpcUrl = rpcUrl; // restore argument\n }\n}\n","license":"MIT"},"lib/forge-std/src/StdCheats.sol":{"keccak256":"0x0fa6ec03602648b62cce41aab2096e6b7e052f2846075d967b6958dd586db746","urls":[],"content":"// SPDX-License-Identifier: MIT\npragma solidity >=0.6.2 <0.9.0;\n\npragma experimental ABIEncoderV2;\n\nimport {StdStorage, stdStorage} from \"./StdStorage.sol\";\nimport {console2} from \"./console2.sol\";\nimport {Vm} from \"./Vm.sol\";\n\nabstract contract StdCheatsSafe {\n Vm private constant vm = Vm(address(uint160(uint256(keccak256(\"hevm cheat code\")))));\n\n uint256 private constant UINT256_MAX =\n 115792089237316195423570985008687907853269984665640564039457584007913129639935;\n\n bool private gasMeteringOff;\n\n // Data structures to parse Transaction objects from the broadcast artifact\n // that conform to EIP1559. The Raw structs is what is parsed from the JSON\n // and then converted to the one that is used by the user for better UX.\n\n struct RawTx1559 {\n string[] arguments;\n address contractAddress;\n string contractName;\n // json value name = function\n string functionSig;\n bytes32 hash;\n // json value name = tx\n RawTx1559Detail txDetail;\n // json value name = type\n string opcode;\n }\n\n struct RawTx1559Detail {\n AccessList[] accessList;\n bytes data;\n address from;\n bytes gas;\n bytes nonce;\n address to;\n bytes txType;\n bytes value;\n }\n\n struct Tx1559 {\n string[] arguments;\n address contractAddress;\n string contractName;\n string functionSig;\n bytes32 hash;\n Tx1559Detail txDetail;\n string opcode;\n }\n\n struct Tx1559Detail {\n AccessList[] accessList;\n bytes data;\n address from;\n uint256 gas;\n uint256 nonce;\n address to;\n uint256 txType;\n uint256 value;\n }\n\n // Data structures to parse Transaction objects from the broadcast artifact\n // that DO NOT conform to EIP1559. The Raw structs is what is parsed from the JSON\n // and then converted to the one that is used by the user for better UX.\n\n struct TxLegacy {\n string[] arguments;\n address contractAddress;\n string contractName;\n string functionSig;\n string hash;\n string opcode;\n TxDetailLegacy transaction;\n }\n\n struct TxDetailLegacy {\n AccessList[] accessList;\n uint256 chainId;\n bytes data;\n address from;\n uint256 gas;\n uint256 gasPrice;\n bytes32 hash;\n uint256 nonce;\n bytes1 opcode;\n bytes32 r;\n bytes32 s;\n uint256 txType;\n address to;\n uint8 v;\n uint256 value;\n }\n\n struct AccessList {\n address accessAddress;\n bytes32[] storageKeys;\n }\n\n // Data structures to parse Receipt objects from the broadcast artifact.\n // The Raw structs is what is parsed from the JSON\n // and then converted to the one that is used by the user for better UX.\n\n struct RawReceipt {\n bytes32 blockHash;\n bytes blockNumber;\n address contractAddress;\n bytes cumulativeGasUsed;\n bytes effectiveGasPrice;\n address from;\n bytes gasUsed;\n RawReceiptLog[] logs;\n bytes logsBloom;\n bytes status;\n address to;\n bytes32 transactionHash;\n bytes transactionIndex;\n }\n\n struct Receipt {\n bytes32 blockHash;\n uint256 blockNumber;\n address contractAddress;\n uint256 cumulativeGasUsed;\n uint256 effectiveGasPrice;\n address from;\n uint256 gasUsed;\n ReceiptLog[] logs;\n bytes logsBloom;\n uint256 status;\n address to;\n bytes32 transactionHash;\n uint256 transactionIndex;\n }\n\n // Data structures to parse the entire broadcast artifact, assuming the\n // transactions conform to EIP1559.\n\n struct EIP1559ScriptArtifact {\n string[] libraries;\n string path;\n string[] pending;\n Receipt[] receipts;\n uint256 timestamp;\n Tx1559[] transactions;\n TxReturn[] txReturns;\n }\n\n struct RawEIP1559ScriptArtifact {\n string[] libraries;\n string path;\n string[] pending;\n RawReceipt[] receipts;\n TxReturn[] txReturns;\n uint256 timestamp;\n RawTx1559[] transactions;\n }\n\n struct RawReceiptLog {\n // json value = address\n address logAddress;\n bytes32 blockHash;\n bytes blockNumber;\n bytes data;\n bytes logIndex;\n bool removed;\n bytes32[] topics;\n bytes32 transactionHash;\n bytes transactionIndex;\n bytes transactionLogIndex;\n }\n\n struct ReceiptLog {\n // json value = address\n address logAddress;\n bytes32 blockHash;\n uint256 blockNumber;\n bytes data;\n uint256 logIndex;\n bytes32[] topics;\n uint256 transactionIndex;\n uint256 transactionLogIndex;\n bool removed;\n }\n\n struct TxReturn {\n string internalType;\n string value;\n }\n\n struct Account {\n address addr;\n uint256 key;\n }\n\n enum AddressType {\n Payable,\n NonPayable,\n ZeroAddress,\n Precompile,\n ForgeAddress\n }\n\n // Checks that `addr` is not blacklisted by token contracts that have a blacklist.\n function assumeNotBlacklisted(address token, address addr) internal view virtual {\n // Nothing to check if `token` is not a contract.\n uint256 tokenCodeSize;\n assembly {\n tokenCodeSize := extcodesize(token)\n }\n require(tokenCodeSize > 0, \"StdCheats assumeNotBlacklisted(address,address): Token address is not a contract.\");\n\n bool success;\n bytes memory returnData;\n\n // 4-byte selector for `isBlacklisted(address)`, used by USDC.\n (success, returnData) = token.staticcall(abi.encodeWithSelector(0xfe575a87, addr));\n vm.assume(!success || abi.decode(returnData, (bool)) == false);\n\n // 4-byte selector for `isBlackListed(address)`, used by USDT.\n (success, returnData) = token.staticcall(abi.encodeWithSelector(0xe47d6060, addr));\n vm.assume(!success || abi.decode(returnData, (bool)) == false);\n }\n\n // Checks that `addr` is not blacklisted by token contracts that have a blacklist.\n // This is identical to `assumeNotBlacklisted(address,address)` but with a different name, for\n // backwards compatibility, since this name was used in the original PR which already has\n // a release. This function can be removed in a future release once we want a breaking change.\n function assumeNoBlacklisted(address token, address addr) internal view virtual {\n assumeNotBlacklisted(token, addr);\n }\n\n function assumeAddressIsNot(address addr, AddressType addressType) internal virtual {\n if (addressType == AddressType.Payable) {\n assumeNotPayable(addr);\n } else if (addressType == AddressType.NonPayable) {\n assumePayable(addr);\n } else if (addressType == AddressType.ZeroAddress) {\n assumeNotZeroAddress(addr);\n } else if (addressType == AddressType.Precompile) {\n assumeNotPrecompile(addr);\n } else if (addressType == AddressType.ForgeAddress) {\n assumeNotForgeAddress(addr);\n }\n }\n\n function assumeAddressIsNot(address addr, AddressType addressType1, AddressType addressType2) internal virtual {\n assumeAddressIsNot(addr, addressType1);\n assumeAddressIsNot(addr, addressType2);\n }\n\n function assumeAddressIsNot(\n address addr,\n AddressType addressType1,\n AddressType addressType2,\n AddressType addressType3\n ) internal virtual {\n assumeAddressIsNot(addr, addressType1);\n assumeAddressIsNot(addr, addressType2);\n assumeAddressIsNot(addr, addressType3);\n }\n\n function assumeAddressIsNot(\n address addr,\n AddressType addressType1,\n AddressType addressType2,\n AddressType addressType3,\n AddressType addressType4\n ) internal virtual {\n assumeAddressIsNot(addr, addressType1);\n assumeAddressIsNot(addr, addressType2);\n assumeAddressIsNot(addr, addressType3);\n assumeAddressIsNot(addr, addressType4);\n }\n\n // This function checks whether an address, `addr`, is payable. It works by sending 1 wei to\n // `addr` and checking the `success` return value.\n // NOTE: This function may result in state changes depending on the fallback/receive logic\n // implemented by `addr`, which should be taken into account when this function is used.\n function _isPayable(address addr) private returns (bool) {\n require(\n addr.balance < UINT256_MAX,\n \"StdCheats _isPayable(address): Balance equals max uint256, so it cannot receive any more funds\"\n );\n uint256 origBalanceTest = address(this).balance;\n uint256 origBalanceAddr = address(addr).balance;\n\n vm.deal(address(this), 1);\n (bool success,) = payable(addr).call{value: 1}(\"\");\n\n // reset balances\n vm.deal(address(this), origBalanceTest);\n vm.deal(addr, origBalanceAddr);\n\n return success;\n }\n\n // NOTE: This function may result in state changes depending on the fallback/receive logic\n // implemented by `addr`, which should be taken into account when this function is used. See the\n // `_isPayable` method for more information.\n function assumePayable(address addr) internal virtual {\n vm.assume(_isPayable(addr));\n }\n\n function assumeNotPayable(address addr) internal virtual {\n vm.assume(!_isPayable(addr));\n }\n\n function assumeNotZeroAddress(address addr) internal pure virtual {\n vm.assume(addr != address(0));\n }\n\n function assumeNotPrecompile(address addr) internal pure virtual {\n assumeNotPrecompile(addr, _pureChainId());\n }\n\n function assumeNotPrecompile(address addr, uint256 chainId) internal pure virtual {\n // Note: For some chains like Optimism these are technically predeploys (i.e. bytecode placed at a specific\n // address), but the same rationale for excluding them applies so we include those too.\n\n // These are reserved by Ethereum and may be on all EVM-compatible chains.\n vm.assume(addr < address(0x1) || addr > address(0xff));\n\n // forgefmt: disable-start\n if (chainId == 10 || chainId == 420) {\n // https://github.com/ethereum-optimism/optimism/blob/eaa371a0184b56b7ca6d9eb9cb0a2b78b2ccd864/op-bindings/predeploys/addresses.go#L6-L21\n vm.assume(addr < address(0x4200000000000000000000000000000000000000) || addr > address(0x4200000000000000000000000000000000000800));\n } else if (chainId == 42161 || chainId == 421613) {\n // https://developer.arbitrum.io/useful-addresses#arbitrum-precompiles-l2-same-on-all-arb-chains\n vm.assume(addr < address(0x0000000000000000000000000000000000000064) || addr > address(0x0000000000000000000000000000000000000068));\n } else if (chainId == 43114 || chainId == 43113) {\n // https://github.com/ava-labs/subnet-evm/blob/47c03fd007ecaa6de2c52ea081596e0a88401f58/precompile/params.go#L18-L59\n vm.assume(addr < address(0x0100000000000000000000000000000000000000) || addr > address(0x01000000000000000000000000000000000000ff));\n vm.assume(addr < address(0x0200000000000000000000000000000000000000) || addr > address(0x02000000000000000000000000000000000000FF));\n vm.assume(addr < address(0x0300000000000000000000000000000000000000) || addr > address(0x03000000000000000000000000000000000000Ff));\n }\n // forgefmt: disable-end\n }\n\n function assumeNotForgeAddress(address addr) internal pure virtual {\n // vm, console, and Create2Deployer addresses\n vm.assume(\n addr != address(vm) && addr != 0x000000000000000000636F6e736F6c652e6c6f67\n && addr != 0x4e59b44847b379578588920cA78FbF26c0B4956C\n );\n }\n\n function assumeUnusedAddress(address addr) internal view virtual {\n uint256 size;\n assembly {\n size := extcodesize(addr)\n }\n vm.assume(size == 0);\n\n assumeNotPrecompile(addr);\n assumeNotZeroAddress(addr);\n assumeNotForgeAddress(addr);\n }\n\n function readEIP1559ScriptArtifact(string memory path)\n internal\n view\n virtual\n returns (EIP1559ScriptArtifact memory)\n {\n string memory data = vm.readFile(path);\n bytes memory parsedData = vm.parseJson(data);\n RawEIP1559ScriptArtifact memory rawArtifact = abi.decode(parsedData, (RawEIP1559ScriptArtifact));\n EIP1559ScriptArtifact memory artifact;\n artifact.libraries = rawArtifact.libraries;\n artifact.path = rawArtifact.path;\n artifact.timestamp = rawArtifact.timestamp;\n artifact.pending = rawArtifact.pending;\n artifact.txReturns = rawArtifact.txReturns;\n artifact.receipts = rawToConvertedReceipts(rawArtifact.receipts);\n artifact.transactions = rawToConvertedEIPTx1559s(rawArtifact.transactions);\n return artifact;\n }\n\n function rawToConvertedEIPTx1559s(RawTx1559[] memory rawTxs) internal pure virtual returns (Tx1559[] memory) {\n Tx1559[] memory txs = new Tx1559[](rawTxs.length);\n for (uint256 i; i < rawTxs.length; i++) {\n txs[i] = rawToConvertedEIPTx1559(rawTxs[i]);\n }\n return txs;\n }\n\n function rawToConvertedEIPTx1559(RawTx1559 memory rawTx) internal pure virtual returns (Tx1559 memory) {\n Tx1559 memory transaction;\n transaction.arguments = rawTx.arguments;\n transaction.contractName = rawTx.contractName;\n transaction.functionSig = rawTx.functionSig;\n transaction.hash = rawTx.hash;\n transaction.txDetail = rawToConvertedEIP1559Detail(rawTx.txDetail);\n transaction.opcode = rawTx.opcode;\n return transaction;\n }\n\n function rawToConvertedEIP1559Detail(RawTx1559Detail memory rawDetail)\n internal\n pure\n virtual\n returns (Tx1559Detail memory)\n {\n Tx1559Detail memory txDetail;\n txDetail.data = rawDetail.data;\n txDetail.from = rawDetail.from;\n txDetail.to = rawDetail.to;\n txDetail.nonce = _bytesToUint(rawDetail.nonce);\n txDetail.txType = _bytesToUint(rawDetail.txType);\n txDetail.value = _bytesToUint(rawDetail.value);\n txDetail.gas = _bytesToUint(rawDetail.gas);\n txDetail.accessList = rawDetail.accessList;\n return txDetail;\n }\n\n function readTx1559s(string memory path) internal view virtual returns (Tx1559[] memory) {\n string memory deployData = vm.readFile(path);\n bytes memory parsedDeployData = vm.parseJson(deployData, \".transactions\");\n RawTx1559[] memory rawTxs = abi.decode(parsedDeployData, (RawTx1559[]));\n return rawToConvertedEIPTx1559s(rawTxs);\n }\n\n function readTx1559(string memory path, uint256 index) internal view virtual returns (Tx1559 memory) {\n string memory deployData = vm.readFile(path);\n string memory key = string(abi.encodePacked(\".transactions[\", vm.toString(index), \"]\"));\n bytes memory parsedDeployData = vm.parseJson(deployData, key);\n RawTx1559 memory rawTx = abi.decode(parsedDeployData, (RawTx1559));\n return rawToConvertedEIPTx1559(rawTx);\n }\n\n // Analogous to readTransactions, but for receipts.\n function readReceipts(string memory path) internal view virtual returns (Receipt[] memory) {\n string memory deployData = vm.readFile(path);\n bytes memory parsedDeployData = vm.parseJson(deployData, \".receipts\");\n RawReceipt[] memory rawReceipts = abi.decode(parsedDeployData, (RawReceipt[]));\n return rawToConvertedReceipts(rawReceipts);\n }\n\n function readReceipt(string memory path, uint256 index) internal view virtual returns (Receipt memory) {\n string memory deployData = vm.readFile(path);\n string memory key = string(abi.encodePacked(\".receipts[\", vm.toString(index), \"]\"));\n bytes memory parsedDeployData = vm.parseJson(deployData, key);\n RawReceipt memory rawReceipt = abi.decode(parsedDeployData, (RawReceipt));\n return rawToConvertedReceipt(rawReceipt);\n }\n\n function rawToConvertedReceipts(RawReceipt[] memory rawReceipts) internal pure virtual returns (Receipt[] memory) {\n Receipt[] memory receipts = new Receipt[](rawReceipts.length);\n for (uint256 i; i < rawReceipts.length; i++) {\n receipts[i] = rawToConvertedReceipt(rawReceipts[i]);\n }\n return receipts;\n }\n\n function rawToConvertedReceipt(RawReceipt memory rawReceipt) internal pure virtual returns (Receipt memory) {\n Receipt memory receipt;\n receipt.blockHash = rawReceipt.blockHash;\n receipt.to = rawReceipt.to;\n receipt.from = rawReceipt.from;\n receipt.contractAddress = rawReceipt.contractAddress;\n receipt.effectiveGasPrice = _bytesToUint(rawReceipt.effectiveGasPrice);\n receipt.cumulativeGasUsed = _bytesToUint(rawReceipt.cumulativeGasUsed);\n receipt.gasUsed = _bytesToUint(rawReceipt.gasUsed);\n receipt.status = _bytesToUint(rawReceipt.status);\n receipt.transactionIndex = _bytesToUint(rawReceipt.transactionIndex);\n receipt.blockNumber = _bytesToUint(rawReceipt.blockNumber);\n receipt.logs = rawToConvertedReceiptLogs(rawReceipt.logs);\n receipt.logsBloom = rawReceipt.logsBloom;\n receipt.transactionHash = rawReceipt.transactionHash;\n return receipt;\n }\n\n function rawToConvertedReceiptLogs(RawReceiptLog[] memory rawLogs)\n internal\n pure\n virtual\n returns (ReceiptLog[] memory)\n {\n ReceiptLog[] memory logs = new ReceiptLog[](rawLogs.length);\n for (uint256 i; i < rawLogs.length; i++) {\n logs[i].logAddress = rawLogs[i].logAddress;\n logs[i].blockHash = rawLogs[i].blockHash;\n logs[i].blockNumber = _bytesToUint(rawLogs[i].blockNumber);\n logs[i].data = rawLogs[i].data;\n logs[i].logIndex = _bytesToUint(rawLogs[i].logIndex);\n logs[i].topics = rawLogs[i].topics;\n logs[i].transactionIndex = _bytesToUint(rawLogs[i].transactionIndex);\n logs[i].transactionLogIndex = _bytesToUint(rawLogs[i].transactionLogIndex);\n logs[i].removed = rawLogs[i].removed;\n }\n return logs;\n }\n\n // Deploy a contract by fetching the contract bytecode from\n // the artifacts directory\n // e.g. `deployCode(code, abi.encode(arg1,arg2,arg3))`\n function deployCode(string memory what, bytes memory args) internal virtual returns (address addr) {\n bytes memory bytecode = abi.encodePacked(vm.getCode(what), args);\n /// @solidity memory-safe-assembly\n assembly {\n addr := create(0, add(bytecode, 0x20), mload(bytecode))\n }\n\n require(addr != address(0), \"StdCheats deployCode(string,bytes): Deployment failed.\");\n }\n\n function deployCode(string memory what) internal virtual returns (address addr) {\n bytes memory bytecode = vm.getCode(what);\n /// @solidity memory-safe-assembly\n assembly {\n addr := create(0, add(bytecode, 0x20), mload(bytecode))\n }\n\n require(addr != address(0), \"StdCheats deployCode(string): Deployment failed.\");\n }\n\n /// @dev deploy contract with value on construction\n function deployCode(string memory what, bytes memory args, uint256 val) internal virtual returns (address addr) {\n bytes memory bytecode = abi.encodePacked(vm.getCode(what), args);\n /// @solidity memory-safe-assembly\n assembly {\n addr := create(val, add(bytecode, 0x20), mload(bytecode))\n }\n\n require(addr != address(0), \"StdCheats deployCode(string,bytes,uint256): Deployment failed.\");\n }\n\n function deployCode(string memory what, uint256 val) internal virtual returns (address addr) {\n bytes memory bytecode = vm.getCode(what);\n /// @solidity memory-safe-assembly\n assembly {\n addr := create(val, add(bytecode, 0x20), mload(bytecode))\n }\n\n require(addr != address(0), \"StdCheats deployCode(string,uint256): Deployment failed.\");\n }\n\n // creates a labeled address and the corresponding private key\n function makeAddrAndKey(string memory name) internal virtual returns (address addr, uint256 privateKey) {\n privateKey = uint256(keccak256(abi.encodePacked(name)));\n addr = vm.addr(privateKey);\n vm.label(addr, name);\n }\n\n // creates a labeled address\n function makeAddr(string memory name) internal virtual returns (address addr) {\n (addr,) = makeAddrAndKey(name);\n }\n\n // Destroys an account immediately, sending the balance to beneficiary.\n // Destroying means: balance will be zero, code will be empty, and nonce will be 0\n // This is similar to selfdestruct but not identical: selfdestruct destroys code and nonce\n // only after tx ends, this will run immediately.\n function destroyAccount(address who, address beneficiary) internal virtual {\n uint256 currBalance = who.balance;\n vm.etch(who, abi.encode());\n vm.deal(who, 0);\n vm.resetNonce(who);\n\n uint256 beneficiaryBalance = beneficiary.balance;\n vm.deal(beneficiary, currBalance + beneficiaryBalance);\n }\n\n // creates a struct containing both a labeled address and the corresponding private key\n function makeAccount(string memory name) internal virtual returns (Account memory account) {\n (account.addr, account.key) = makeAddrAndKey(name);\n }\n\n function deriveRememberKey(string memory mnemonic, uint32 index)\n internal\n virtual\n returns (address who, uint256 privateKey)\n {\n privateKey = vm.deriveKey(mnemonic, index);\n who = vm.rememberKey(privateKey);\n }\n\n function _bytesToUint(bytes memory b) private pure returns (uint256) {\n require(b.length <= 32, \"StdCheats _bytesToUint(bytes): Bytes length exceeds 32.\");\n return abi.decode(abi.encodePacked(new bytes(32 - b.length), b), (uint256));\n }\n\n function isFork() internal view virtual returns (bool status) {\n try vm.activeFork() {\n status = true;\n } catch (bytes memory) {}\n }\n\n modifier skipWhenForking() {\n if (!isFork()) {\n _;\n }\n }\n\n modifier skipWhenNotForking() {\n if (isFork()) {\n _;\n }\n }\n\n modifier noGasMetering() {\n vm.pauseGasMetering();\n // To prevent turning gas monitoring back on with nested functions that use this modifier,\n // we check if gasMetering started in the off position. If it did, we don't want to turn\n // it back on until we exit the top level function that used the modifier\n //\n // i.e. funcA() noGasMetering { funcB() }, where funcB has noGasMetering as well.\n // funcA will have `gasStartedOff` as false, funcB will have it as true,\n // so we only turn metering back on at the end of the funcA\n bool gasStartedOff = gasMeteringOff;\n gasMeteringOff = true;\n\n _;\n\n // if gas metering was on when this modifier was called, turn it back on at the end\n if (!gasStartedOff) {\n gasMeteringOff = false;\n vm.resumeGasMetering();\n }\n }\n\n // We use this complex approach of `_viewChainId` and `_pureChainId` to ensure there are no\n // compiler warnings when accessing chain ID in any solidity version supported by forge-std. We\n // can't simply access the chain ID in a normal view or pure function because the solc View Pure\n // Checker changed `chainid` from pure to view in 0.8.0.\n function _viewChainId() private view returns (uint256 chainId) {\n // Assembly required since `block.chainid` was introduced in 0.8.0.\n assembly {\n chainId := chainid()\n }\n\n address(this); // Silence warnings in older Solc versions.\n }\n\n function _pureChainId() private pure returns (uint256 chainId) {\n function() internal view returns (uint256) fnIn = _viewChainId;\n function() internal pure returns (uint256) pureChainId;\n assembly {\n pureChainId := fnIn\n }\n chainId = pureChainId();\n }\n}\n\n// Wrappers around cheatcodes to avoid footguns\nabstract contract StdCheats is StdCheatsSafe {\n using stdStorage for StdStorage;\n\n StdStorage private stdstore;\n Vm private constant vm = Vm(address(uint160(uint256(keccak256(\"hevm cheat code\")))));\n address private constant CONSOLE2_ADDRESS = 0x000000000000000000636F6e736F6c652e6c6f67;\n\n // Skip forward or rewind time by the specified number of seconds\n function skip(uint256 time) internal virtual {\n vm.warp(vm.getBlockTimestamp() + time);\n }\n\n function rewind(uint256 time) internal virtual {\n vm.warp(vm.getBlockTimestamp() - time);\n }\n\n // Setup a prank from an address that has some ether\n function hoax(address msgSender) internal virtual {\n vm.deal(msgSender, 1 << 128);\n vm.prank(msgSender);\n }\n\n function hoax(address msgSender, uint256 give) internal virtual {\n vm.deal(msgSender, give);\n vm.prank(msgSender);\n }\n\n function hoax(address msgSender, address origin) internal virtual {\n vm.deal(msgSender, 1 << 128);\n vm.prank(msgSender, origin);\n }\n\n function hoax(address msgSender, address origin, uint256 give) internal virtual {\n vm.deal(msgSender, give);\n vm.prank(msgSender, origin);\n }\n\n // Start perpetual prank from an address that has some ether\n function startHoax(address msgSender) internal virtual {\n vm.deal(msgSender, 1 << 128);\n vm.startPrank(msgSender);\n }\n\n function startHoax(address msgSender, uint256 give) internal virtual {\n vm.deal(msgSender, give);\n vm.startPrank(msgSender);\n }\n\n // Start perpetual prank from an address that has some ether\n // tx.origin is set to the origin parameter\n function startHoax(address msgSender, address origin) internal virtual {\n vm.deal(msgSender, 1 << 128);\n vm.startPrank(msgSender, origin);\n }\n\n function startHoax(address msgSender, address origin, uint256 give) internal virtual {\n vm.deal(msgSender, give);\n vm.startPrank(msgSender, origin);\n }\n\n function changePrank(address msgSender) internal virtual {\n console2_log_StdCheats(\"changePrank is deprecated. Please use vm.startPrank instead.\");\n vm.stopPrank();\n vm.startPrank(msgSender);\n }\n\n function changePrank(address msgSender, address txOrigin) internal virtual {\n vm.stopPrank();\n vm.startPrank(msgSender, txOrigin);\n }\n\n // The same as Vm's `deal`\n // Use the alternative signature for ERC20 tokens\n function deal(address to, uint256 give) internal virtual {\n vm.deal(to, give);\n }\n\n // Set the balance of an account for any ERC20 token\n // Use the alternative signature to update `totalSupply`\n function deal(address token, address to, uint256 give) internal virtual {\n deal(token, to, give, false);\n }\n\n // Set the balance of an account for any ERC1155 token\n // Use the alternative signature to update `totalSupply`\n function dealERC1155(address token, address to, uint256 id, uint256 give) internal virtual {\n dealERC1155(token, to, id, give, false);\n }\n\n function deal(address token, address to, uint256 give, bool adjust) internal virtual {\n // get current balance\n (, bytes memory balData) = token.staticcall(abi.encodeWithSelector(0x70a08231, to));\n uint256 prevBal = abi.decode(balData, (uint256));\n\n // update balance\n stdstore.target(token).sig(0x70a08231).with_key(to).checked_write(give);\n\n // update total supply\n if (adjust) {\n (, bytes memory totSupData) = token.staticcall(abi.encodeWithSelector(0x18160ddd));\n uint256 totSup = abi.decode(totSupData, (uint256));\n if (give < prevBal) {\n totSup -= (prevBal - give);\n } else {\n totSup += (give - prevBal);\n }\n stdstore.target(token).sig(0x18160ddd).checked_write(totSup);\n }\n }\n\n function dealERC1155(address token, address to, uint256 id, uint256 give, bool adjust) internal virtual {\n // get current balance\n (, bytes memory balData) = token.staticcall(abi.encodeWithSelector(0x00fdd58e, to, id));\n uint256 prevBal = abi.decode(balData, (uint256));\n\n // update balance\n stdstore.target(token).sig(0x00fdd58e).with_key(to).with_key(id).checked_write(give);\n\n // update total supply\n if (adjust) {\n (, bytes memory totSupData) = token.staticcall(abi.encodeWithSelector(0xbd85b039, id));\n require(\n totSupData.length != 0,\n \"StdCheats deal(address,address,uint,uint,bool): target contract is not ERC1155Supply.\"\n );\n uint256 totSup = abi.decode(totSupData, (uint256));\n if (give < prevBal) {\n totSup -= (prevBal - give);\n } else {\n totSup += (give - prevBal);\n }\n stdstore.target(token).sig(0xbd85b039).with_key(id).checked_write(totSup);\n }\n }\n\n function dealERC721(address token, address to, uint256 id) internal virtual {\n // check if token id is already minted and the actual owner.\n (bool successMinted, bytes memory ownerData) = token.staticcall(abi.encodeWithSelector(0x6352211e, id));\n require(successMinted, \"StdCheats deal(address,address,uint,bool): id not minted.\");\n\n // get owner current balance\n (, bytes memory fromBalData) =\n token.staticcall(abi.encodeWithSelector(0x70a08231, abi.decode(ownerData, (address))));\n uint256 fromPrevBal = abi.decode(fromBalData, (uint256));\n\n // get new user current balance\n (, bytes memory toBalData) = token.staticcall(abi.encodeWithSelector(0x70a08231, to));\n uint256 toPrevBal = abi.decode(toBalData, (uint256));\n\n // update balances\n stdstore.target(token).sig(0x70a08231).with_key(abi.decode(ownerData, (address))).checked_write(--fromPrevBal);\n stdstore.target(token).sig(0x70a08231).with_key(to).checked_write(++toPrevBal);\n\n // update owner\n stdstore.target(token).sig(0x6352211e).with_key(id).checked_write(to);\n }\n\n function deployCodeTo(string memory what, address where) internal virtual {\n deployCodeTo(what, \"\", 0, where);\n }\n\n function deployCodeTo(string memory what, bytes memory args, address where) internal virtual {\n deployCodeTo(what, args, 0, where);\n }\n\n function deployCodeTo(string memory what, bytes memory args, uint256 value, address where) internal virtual {\n bytes memory creationCode = vm.getCode(what);\n vm.etch(where, abi.encodePacked(creationCode, args));\n (bool success, bytes memory runtimeBytecode) = where.call{value: value}(\"\");\n require(success, \"StdCheats deployCodeTo(string,bytes,uint256,address): Failed to create runtime bytecode.\");\n vm.etch(where, runtimeBytecode);\n }\n\n // Used to prevent the compilation of console, which shortens the compilation time when console is not used elsewhere.\n function console2_log_StdCheats(string memory p0) private view {\n (bool status,) = address(CONSOLE2_ADDRESS).staticcall(abi.encodeWithSignature(\"log(string)\", p0));\n status;\n }\n}\n","license":"MIT"},"lib/forge-std/src/StdConstants.sol":{"keccak256":"0x319ccdabfa2c0b2428301445873270ffea20f0e039d4fd5e6eeba65158e4e534","urls":[],"content":"// SPDX-License-Identifier: MIT\npragma solidity >=0.6.2 <0.9.0;\n\nimport {IMulticall3} from \"./interfaces/IMulticall3.sol\";\nimport {Vm} from \"./Vm.sol\";\n\nlibrary StdConstants {\n /// @dev Cheat code address.\n /// Calculated as `address(uint160(uint256(keccak256(\"hevm cheat code\"))))`.\n Vm internal constant VM = Vm(0x7109709ECfa91a80626fF3989D68f67F5b1DD12D);\n /// @dev console.sol and console2.sol work by executing a staticcall to this address.\n /// Calculated as `address(uint160(uint88(bytes11(\"console.log\"))))`.\n address internal constant CONSOLE = 0x000000000000000000636F6e736F6c652e6c6f67;\n /// @dev Used when deploying with create2.\n /// Taken from https://github.com/Arachnid/deterministic-deployment-proxy.\n address internal constant CREATE2_FACTORY = 0x4e59b44847b379578588920cA78FbF26c0B4956C;\n /// @dev The default address for tx.origin and msg.sender.\n /// Calculated as `address(uint160(uint256(keccak256(\"foundry default caller\"))))`.\n address internal constant DEFAULT_SENDER = 0x1804c8AB1F12E6bbf3894d4083f33e07309d1f38;\n /// @dev The address of the first contract `CREATE`d by a running test contract.\n /// When running tests, each test contract is `CREATE`d by `DEFAULT_SENDER` with nonce 1.\n /// Calculated as `VM.computeCreateAddress(VM.computeCreateAddress(DEFAULT_SENDER, 1), 1)`.\n address internal constant DEFAULT_TEST_CONTRACT = 0x5615dEB798BB3E4dFa0139dFa1b3D433Cc23b72f;\n /// @dev Deterministic deployment address of the Multicall3 contract.\n /// Taken from https://www.multicall3.com.\n IMulticall3 internal constant MULTICALL3_ADDRESS = IMulticall3(0xcA11bde05977b3631167028862bE2a173976CA11);\n /// @dev The order of the secp256k1 curve.\n uint256 internal constant SECP256K1_ORDER =\n 115792089237316195423570985008687907852837564279074904382605163141518161494337;\n}\n","license":"MIT"},"lib/forge-std/src/StdJson.sol":{"keccak256":"0xbc0132abe1c2accc2867c0f03667afffdf92f3e95a581bb03c9557eaa38ea500","urls":[],"content":"// SPDX-License-Identifier: MIT\npragma solidity >=0.6.0 <0.9.0;\n\npragma experimental ABIEncoderV2;\n\nimport {VmSafe} from \"./Vm.sol\";\n\n// Helpers for parsing and writing JSON files\n// To parse:\n// ```\n// using stdJson for string;\n// string memory json = vm.readFile(\"\");\n// json.readUint(\"\");\n// ```\n// To write:\n// ```\n// using stdJson for string;\n// string memory json = \"json\";\n// json.serialize(\"a\", uint256(123));\n// string memory semiFinal = json.serialize(\"b\", string(\"test\"));\n// string memory finalJson = json.serialize(\"c\", semiFinal);\n// finalJson.write(\"\");\n// ```\n\nlibrary stdJson {\n VmSafe private constant vm = VmSafe(address(uint160(uint256(keccak256(\"hevm cheat code\")))));\n\n function keyExists(string memory json, string memory key) internal view returns (bool) {\n return vm.keyExistsJson(json, key);\n }\n\n function parseRaw(string memory json, string memory key) internal pure returns (bytes memory) {\n return vm.parseJson(json, key);\n }\n\n function readUint(string memory json, string memory key) internal pure returns (uint256) {\n return vm.parseJsonUint(json, key);\n }\n\n function readUintArray(string memory json, string memory key) internal pure returns (uint256[] memory) {\n return vm.parseJsonUintArray(json, key);\n }\n\n function readInt(string memory json, string memory key) internal pure returns (int256) {\n return vm.parseJsonInt(json, key);\n }\n\n function readIntArray(string memory json, string memory key) internal pure returns (int256[] memory) {\n return vm.parseJsonIntArray(json, key);\n }\n\n function readBytes32(string memory json, string memory key) internal pure returns (bytes32) {\n return vm.parseJsonBytes32(json, key);\n }\n\n function readBytes32Array(string memory json, string memory key) internal pure returns (bytes32[] memory) {\n return vm.parseJsonBytes32Array(json, key);\n }\n\n function readString(string memory json, string memory key) internal pure returns (string memory) {\n return vm.parseJsonString(json, key);\n }\n\n function readStringArray(string memory json, string memory key) internal pure returns (string[] memory) {\n return vm.parseJsonStringArray(json, key);\n }\n\n function readAddress(string memory json, string memory key) internal pure returns (address) {\n return vm.parseJsonAddress(json, key);\n }\n\n function readAddressArray(string memory json, string memory key) internal pure returns (address[] memory) {\n return vm.parseJsonAddressArray(json, key);\n }\n\n function readBool(string memory json, string memory key) internal pure returns (bool) {\n return vm.parseJsonBool(json, key);\n }\n\n function readBoolArray(string memory json, string memory key) internal pure returns (bool[] memory) {\n return vm.parseJsonBoolArray(json, key);\n }\n\n function readBytes(string memory json, string memory key) internal pure returns (bytes memory) {\n return vm.parseJsonBytes(json, key);\n }\n\n function readBytesArray(string memory json, string memory key) internal pure returns (bytes[] memory) {\n return vm.parseJsonBytesArray(json, key);\n }\n\n function readUintOr(string memory json, string memory key, uint256 defaultValue) internal view returns (uint256) {\n return keyExists(json, key) ? readUint(json, key) : defaultValue;\n }\n\n function readUintArrayOr(string memory json, string memory key, uint256[] memory defaultValue)\n internal\n view\n returns (uint256[] memory)\n {\n return keyExists(json, key) ? readUintArray(json, key) : defaultValue;\n }\n\n function readIntOr(string memory json, string memory key, int256 defaultValue) internal view returns (int256) {\n return keyExists(json, key) ? readInt(json, key) : defaultValue;\n }\n\n function readIntArrayOr(string memory json, string memory key, int256[] memory defaultValue)\n internal\n view\n returns (int256[] memory)\n {\n return keyExists(json, key) ? readIntArray(json, key) : defaultValue;\n }\n\n function readBytes32Or(string memory json, string memory key, bytes32 defaultValue)\n internal\n view\n returns (bytes32)\n {\n return keyExists(json, key) ? readBytes32(json, key) : defaultValue;\n }\n\n function readBytes32ArrayOr(string memory json, string memory key, bytes32[] memory defaultValue)\n internal\n view\n returns (bytes32[] memory)\n {\n return keyExists(json, key) ? readBytes32Array(json, key) : defaultValue;\n }\n\n function readStringOr(string memory json, string memory key, string memory defaultValue)\n internal\n view\n returns (string memory)\n {\n return keyExists(json, key) ? readString(json, key) : defaultValue;\n }\n\n function readStringArrayOr(string memory json, string memory key, string[] memory defaultValue)\n internal\n view\n returns (string[] memory)\n {\n return keyExists(json, key) ? readStringArray(json, key) : defaultValue;\n }\n\n function readAddressOr(string memory json, string memory key, address defaultValue)\n internal\n view\n returns (address)\n {\n return keyExists(json, key) ? readAddress(json, key) : defaultValue;\n }\n\n function readAddressArrayOr(string memory json, string memory key, address[] memory defaultValue)\n internal\n view\n returns (address[] memory)\n {\n return keyExists(json, key) ? readAddressArray(json, key) : defaultValue;\n }\n\n function readBoolOr(string memory json, string memory key, bool defaultValue) internal view returns (bool) {\n return keyExists(json, key) ? readBool(json, key) : defaultValue;\n }\n\n function readBoolArrayOr(string memory json, string memory key, bool[] memory defaultValue)\n internal\n view\n returns (bool[] memory)\n {\n return keyExists(json, key) ? readBoolArray(json, key) : defaultValue;\n }\n\n function readBytesOr(string memory json, string memory key, bytes memory defaultValue)\n internal\n view\n returns (bytes memory)\n {\n return keyExists(json, key) ? readBytes(json, key) : defaultValue;\n }\n\n function readBytesArrayOr(string memory json, string memory key, bytes[] memory defaultValue)\n internal\n view\n returns (bytes[] memory)\n {\n return keyExists(json, key) ? readBytesArray(json, key) : defaultValue;\n }\n\n function serialize(string memory jsonKey, string memory rootObject) internal returns (string memory) {\n return vm.serializeJson(jsonKey, rootObject);\n }\n\n function serialize(string memory jsonKey, string memory key, bool value) internal returns (string memory) {\n return vm.serializeBool(jsonKey, key, value);\n }\n\n function serialize(string memory jsonKey, string memory key, bool[] memory value)\n internal\n returns (string memory)\n {\n return vm.serializeBool(jsonKey, key, value);\n }\n\n function serialize(string memory jsonKey, string memory key, uint256 value) internal returns (string memory) {\n return vm.serializeUint(jsonKey, key, value);\n }\n\n function serialize(string memory jsonKey, string memory key, uint256[] memory value)\n internal\n returns (string memory)\n {\n return vm.serializeUint(jsonKey, key, value);\n }\n\n function serialize(string memory jsonKey, string memory key, int256 value) internal returns (string memory) {\n return vm.serializeInt(jsonKey, key, value);\n }\n\n function serialize(string memory jsonKey, string memory key, int256[] memory value)\n internal\n returns (string memory)\n {\n return vm.serializeInt(jsonKey, key, value);\n }\n\n function serialize(string memory jsonKey, string memory key, address value) internal returns (string memory) {\n return vm.serializeAddress(jsonKey, key, value);\n }\n\n function serialize(string memory jsonKey, string memory key, address[] memory value)\n internal\n returns (string memory)\n {\n return vm.serializeAddress(jsonKey, key, value);\n }\n\n function serialize(string memory jsonKey, string memory key, bytes32 value) internal returns (string memory) {\n return vm.serializeBytes32(jsonKey, key, value);\n }\n\n function serialize(string memory jsonKey, string memory key, bytes32[] memory value)\n internal\n returns (string memory)\n {\n return vm.serializeBytes32(jsonKey, key, value);\n }\n\n function serialize(string memory jsonKey, string memory key, bytes memory value) internal returns (string memory) {\n return vm.serializeBytes(jsonKey, key, value);\n }\n\n function serialize(string memory jsonKey, string memory key, bytes[] memory value)\n internal\n returns (string memory)\n {\n return vm.serializeBytes(jsonKey, key, value);\n }\n\n function serialize(string memory jsonKey, string memory key, string memory value)\n internal\n returns (string memory)\n {\n return vm.serializeString(jsonKey, key, value);\n }\n\n function serialize(string memory jsonKey, string memory key, string[] memory value)\n internal\n returns (string memory)\n {\n return vm.serializeString(jsonKey, key, value);\n }\n\n function write(string memory jsonKey, string memory path) internal {\n vm.writeJson(jsonKey, path);\n }\n\n function write(string memory jsonKey, string memory path, string memory valueKey) internal {\n vm.writeJson(jsonKey, path, valueKey);\n }\n}\n","license":"MIT"},"lib/forge-std/src/StdMath.sol":{"keccak256":"0xd90ad4fd8aeaeb8929964e686e769fdedd5eded3fc3815df194a0ab9f91a3fb2","urls":[],"content":"// SPDX-License-Identifier: MIT\npragma solidity >=0.6.2 <0.9.0;\n\nlibrary stdMath {\n int256 private constant INT256_MIN = -57896044618658097711785492504343953926634992332820282019728792003956564819968;\n\n function abs(int256 a) internal pure returns (uint256) {\n // Required or it will fail when `a = type(int256).min`\n if (a == INT256_MIN) {\n return 57896044618658097711785492504343953926634992332820282019728792003956564819968;\n }\n\n return uint256(a > 0 ? a : -a);\n }\n\n function delta(uint256 a, uint256 b) internal pure returns (uint256) {\n return a > b ? a - b : b - a;\n }\n\n function delta(int256 a, int256 b) internal pure returns (uint256) {\n // a and b are of the same sign\n // this works thanks to two's complement, the left-most bit is the sign bit\n if ((a ^ b) > -1) {\n return delta(abs(a), abs(b));\n }\n\n // a and b are of opposite signs\n return abs(a) + abs(b);\n }\n\n function percentDelta(uint256 a, uint256 b) internal pure returns (uint256) {\n uint256 absDelta = delta(a, b);\n\n return absDelta * 1e18 / b;\n }\n\n function percentDelta(int256 a, int256 b) internal pure returns (uint256) {\n uint256 absDelta = delta(a, b);\n uint256 absB = abs(b);\n\n return absDelta * 1e18 / absB;\n }\n}\n","license":"MIT"},"lib/forge-std/src/StdStorage.sol":{"keccak256":"0xb91ab24383a5872b894fc93325eef1add6cbbf981628f18e860068bf88bb7dcc","urls":[],"content":"// SPDX-License-Identifier: MIT\npragma solidity >=0.6.2 <0.9.0;\n\nimport {Vm} from \"./Vm.sol\";\n\nstruct FindData {\n uint256 slot;\n uint256 offsetLeft;\n uint256 offsetRight;\n bool found;\n}\n\nstruct StdStorage {\n mapping(address => mapping(bytes4 => mapping(bytes32 => FindData))) finds;\n bytes32[] _keys;\n bytes4 _sig;\n uint256 _depth;\n address _target;\n bytes32 _set;\n bool _enable_packed_slots;\n bytes _calldata;\n}\n\nlibrary stdStorageSafe {\n event SlotFound(address who, bytes4 fsig, bytes32 keysHash, uint256 slot);\n event WARNING_UninitedSlot(address who, uint256 slot);\n\n Vm private constant vm = Vm(address(uint160(uint256(keccak256(\"hevm cheat code\")))));\n uint256 constant UINT256_MAX = 115792089237316195423570985008687907853269984665640564039457584007913129639935;\n\n function sigs(string memory sigStr) internal pure returns (bytes4) {\n return bytes4(keccak256(bytes(sigStr)));\n }\n\n function getCallParams(StdStorage storage self) internal view returns (bytes memory) {\n if (self._calldata.length == 0) {\n return flatten(self._keys);\n } else {\n return self._calldata;\n }\n }\n\n // Calls target contract with configured parameters\n function callTarget(StdStorage storage self) internal view returns (bool, bytes32) {\n bytes memory cald = abi.encodePacked(self._sig, getCallParams(self));\n (bool success, bytes memory rdat) = self._target.staticcall(cald);\n bytes32 result = bytesToBytes32(rdat, 32 * self._depth);\n\n return (success, result);\n }\n\n // Tries mutating slot value to determine if the targeted value is stored in it.\n // If current value is 0, then we are setting slot value to type(uint256).max\n // Otherwise, we set it to 0. That way, return value should always be affected.\n function checkSlotMutatesCall(StdStorage storage self, bytes32 slot) internal returns (bool) {\n bytes32 prevSlotValue = vm.load(self._target, slot);\n (bool success, bytes32 prevReturnValue) = callTarget(self);\n\n bytes32 testVal = prevReturnValue == bytes32(0) ? bytes32(UINT256_MAX) : bytes32(0);\n vm.store(self._target, slot, testVal);\n\n (, bytes32 newReturnValue) = callTarget(self);\n\n vm.store(self._target, slot, prevSlotValue);\n\n return (success && (prevReturnValue != newReturnValue));\n }\n\n // Tries setting one of the bits in slot to 1 until return value changes.\n // Index of resulted bit is an offset packed slot has from left/right side\n function findOffset(StdStorage storage self, bytes32 slot, bool left) internal returns (bool, uint256) {\n for (uint256 offset = 0; offset < 256; offset++) {\n uint256 valueToPut = left ? (1 << (255 - offset)) : (1 << offset);\n vm.store(self._target, slot, bytes32(valueToPut));\n\n (bool success, bytes32 data) = callTarget(self);\n\n if (success && (uint256(data) > 0)) {\n return (true, offset);\n }\n }\n return (false, 0);\n }\n\n function findOffsets(StdStorage storage self, bytes32 slot) internal returns (bool, uint256, uint256) {\n bytes32 prevSlotValue = vm.load(self._target, slot);\n\n (bool foundLeft, uint256 offsetLeft) = findOffset(self, slot, true);\n (bool foundRight, uint256 offsetRight) = findOffset(self, slot, false);\n\n // `findOffset` may mutate slot value, so we are setting it to initial value\n vm.store(self._target, slot, prevSlotValue);\n return (foundLeft && foundRight, offsetLeft, offsetRight);\n }\n\n function find(StdStorage storage self) internal returns (FindData storage) {\n return find(self, true);\n }\n\n /// @notice find an arbitrary storage slot given a function sig, input data, address of the contract and a value to check against\n // slot complexity:\n // if flat, will be bytes32(uint256(uint));\n // if map, will be keccak256(abi.encode(key, uint(slot)));\n // if deep map, will be keccak256(abi.encode(key1, keccak256(abi.encode(key0, uint(slot)))));\n // if map struct, will be bytes32(uint256(keccak256(abi.encode(key1, keccak256(abi.encode(key0, uint(slot)))))) + structFieldDepth);\n function find(StdStorage storage self, bool _clear) internal returns (FindData storage) {\n address who = self._target;\n bytes4 fsig = self._sig;\n uint256 field_depth = self._depth;\n bytes memory params = getCallParams(self);\n\n // calldata to test against\n if (self.finds[who][fsig][keccak256(abi.encodePacked(params, field_depth))].found) {\n if (_clear) {\n clear(self);\n }\n return self.finds[who][fsig][keccak256(abi.encodePacked(params, field_depth))];\n }\n vm.record();\n (, bytes32 callResult) = callTarget(self);\n (bytes32[] memory reads,) = vm.accesses(address(who));\n\n if (reads.length == 0) {\n revert(\"stdStorage find(StdStorage): No storage use detected for target.\");\n } else {\n for (uint256 i = reads.length; --i >= 0;) {\n bytes32 prev = vm.load(who, reads[i]);\n if (prev == bytes32(0)) {\n emit WARNING_UninitedSlot(who, uint256(reads[i]));\n }\n\n if (!checkSlotMutatesCall(self, reads[i])) {\n continue;\n }\n\n (uint256 offsetLeft, uint256 offsetRight) = (0, 0);\n\n if (self._enable_packed_slots) {\n bool found;\n (found, offsetLeft, offsetRight) = findOffsets(self, reads[i]);\n if (!found) {\n continue;\n }\n }\n\n // Check that value between found offsets is equal to the current call result\n uint256 curVal = (uint256(prev) & getMaskByOffsets(offsetLeft, offsetRight)) >> offsetRight;\n\n if (uint256(callResult) != curVal) {\n continue;\n }\n\n emit SlotFound(who, fsig, keccak256(abi.encodePacked(params, field_depth)), uint256(reads[i]));\n self.finds[who][fsig][keccak256(abi.encodePacked(params, field_depth))] =\n FindData(uint256(reads[i]), offsetLeft, offsetRight, true);\n break;\n }\n }\n\n require(\n self.finds[who][fsig][keccak256(abi.encodePacked(params, field_depth))].found,\n \"stdStorage find(StdStorage): Slot(s) not found.\"\n );\n\n if (_clear) {\n clear(self);\n }\n return self.finds[who][fsig][keccak256(abi.encodePacked(params, field_depth))];\n }\n\n function target(StdStorage storage self, address _target) internal returns (StdStorage storage) {\n self._target = _target;\n return self;\n }\n\n function sig(StdStorage storage self, bytes4 _sig) internal returns (StdStorage storage) {\n self._sig = _sig;\n return self;\n }\n\n function sig(StdStorage storage self, string memory _sig) internal returns (StdStorage storage) {\n self._sig = sigs(_sig);\n return self;\n }\n\n function with_calldata(StdStorage storage self, bytes memory _calldata) internal returns (StdStorage storage) {\n self._calldata = _calldata;\n return self;\n }\n\n function with_key(StdStorage storage self, address who) internal returns (StdStorage storage) {\n self._keys.push(bytes32(uint256(uint160(who))));\n return self;\n }\n\n function with_key(StdStorage storage self, uint256 amt) internal returns (StdStorage storage) {\n self._keys.push(bytes32(amt));\n return self;\n }\n\n function with_key(StdStorage storage self, bytes32 key) internal returns (StdStorage storage) {\n self._keys.push(key);\n return self;\n }\n\n function enable_packed_slots(StdStorage storage self) internal returns (StdStorage storage) {\n self._enable_packed_slots = true;\n return self;\n }\n\n function depth(StdStorage storage self, uint256 _depth) internal returns (StdStorage storage) {\n self._depth = _depth;\n return self;\n }\n\n function read(StdStorage storage self) private returns (bytes memory) {\n FindData storage data = find(self, false);\n uint256 mask = getMaskByOffsets(data.offsetLeft, data.offsetRight);\n uint256 value = (uint256(vm.load(self._target, bytes32(data.slot))) & mask) >> data.offsetRight;\n clear(self);\n return abi.encode(value);\n }\n\n function read_bytes32(StdStorage storage self) internal returns (bytes32) {\n return abi.decode(read(self), (bytes32));\n }\n\n function read_bool(StdStorage storage self) internal returns (bool) {\n int256 v = read_int(self);\n if (v == 0) return false;\n if (v == 1) return true;\n revert(\"stdStorage read_bool(StdStorage): Cannot decode. Make sure you are reading a bool.\");\n }\n\n function read_address(StdStorage storage self) internal returns (address) {\n return abi.decode(read(self), (address));\n }\n\n function read_uint(StdStorage storage self) internal returns (uint256) {\n return abi.decode(read(self), (uint256));\n }\n\n function read_int(StdStorage storage self) internal returns (int256) {\n return abi.decode(read(self), (int256));\n }\n\n function parent(StdStorage storage self) internal returns (uint256, bytes32) {\n address who = self._target;\n uint256 field_depth = self._depth;\n vm.startMappingRecording();\n uint256 child = find(self, true).slot - field_depth;\n (bool found, bytes32 key, bytes32 parent_slot) = vm.getMappingKeyAndParentOf(who, bytes32(child));\n if (!found) {\n revert(\n \"stdStorage read_bool(StdStorage): Cannot find parent. Make sure you give a slot and startMappingRecording() has been called.\"\n );\n }\n return (uint256(parent_slot), key);\n }\n\n function root(StdStorage storage self) internal returns (uint256) {\n address who = self._target;\n uint256 field_depth = self._depth;\n vm.startMappingRecording();\n uint256 child = find(self, true).slot - field_depth;\n bool found;\n bytes32 root_slot;\n bytes32 parent_slot;\n (found,, parent_slot) = vm.getMappingKeyAndParentOf(who, bytes32(child));\n if (!found) {\n revert(\n \"stdStorage read_bool(StdStorage): Cannot find parent. Make sure you give a slot and startMappingRecording() has been called.\"\n );\n }\n while (found) {\n root_slot = parent_slot;\n (found,, parent_slot) = vm.getMappingKeyAndParentOf(who, bytes32(root_slot));\n }\n return uint256(root_slot);\n }\n\n function bytesToBytes32(bytes memory b, uint256 offset) private pure returns (bytes32) {\n bytes32 out;\n\n uint256 max = b.length > 32 ? 32 : b.length;\n for (uint256 i = 0; i < max; i++) {\n out |= bytes32(b[offset + i] & 0xFF) >> (i * 8);\n }\n return out;\n }\n\n function flatten(bytes32[] memory b) private pure returns (bytes memory) {\n bytes memory result = new bytes(b.length * 32);\n for (uint256 i = 0; i < b.length; i++) {\n bytes32 k = b[i];\n /// @solidity memory-safe-assembly\n assembly {\n mstore(add(result, add(32, mul(32, i))), k)\n }\n }\n\n return result;\n }\n\n function clear(StdStorage storage self) internal {\n delete self._target;\n delete self._sig;\n delete self._keys;\n delete self._depth;\n delete self._enable_packed_slots;\n delete self._calldata;\n }\n\n // Returns mask which contains non-zero bits for values between `offsetLeft` and `offsetRight`\n // (slotValue & mask) >> offsetRight will be the value of the given packed variable\n function getMaskByOffsets(uint256 offsetLeft, uint256 offsetRight) internal pure returns (uint256 mask) {\n // mask = ((1 << (256 - (offsetRight + offsetLeft))) - 1) << offsetRight;\n // using assembly because (1 << 256) causes overflow\n assembly {\n mask := shl(offsetRight, sub(shl(sub(256, add(offsetRight, offsetLeft)), 1), 1))\n }\n }\n\n // Returns slot value with updated packed variable.\n function getUpdatedSlotValue(bytes32 curValue, uint256 varValue, uint256 offsetLeft, uint256 offsetRight)\n internal\n pure\n returns (bytes32 newValue)\n {\n return bytes32((uint256(curValue) & ~getMaskByOffsets(offsetLeft, offsetRight)) | (varValue << offsetRight));\n }\n}\n\nlibrary stdStorage {\n Vm private constant vm = Vm(address(uint160(uint256(keccak256(\"hevm cheat code\")))));\n\n function sigs(string memory sigStr) internal pure returns (bytes4) {\n return stdStorageSafe.sigs(sigStr);\n }\n\n function find(StdStorage storage self) internal returns (uint256) {\n return find(self, true);\n }\n\n function find(StdStorage storage self, bool _clear) internal returns (uint256) {\n return stdStorageSafe.find(self, _clear).slot;\n }\n\n function target(StdStorage storage self, address _target) internal returns (StdStorage storage) {\n return stdStorageSafe.target(self, _target);\n }\n\n function sig(StdStorage storage self, bytes4 _sig) internal returns (StdStorage storage) {\n return stdStorageSafe.sig(self, _sig);\n }\n\n function sig(StdStorage storage self, string memory _sig) internal returns (StdStorage storage) {\n return stdStorageSafe.sig(self, _sig);\n }\n\n function with_key(StdStorage storage self, address who) internal returns (StdStorage storage) {\n return stdStorageSafe.with_key(self, who);\n }\n\n function with_key(StdStorage storage self, uint256 amt) internal returns (StdStorage storage) {\n return stdStorageSafe.with_key(self, amt);\n }\n\n function with_key(StdStorage storage self, bytes32 key) internal returns (StdStorage storage) {\n return stdStorageSafe.with_key(self, key);\n }\n\n function with_calldata(StdStorage storage self, bytes memory _calldata) internal returns (StdStorage storage) {\n return stdStorageSafe.with_calldata(self, _calldata);\n }\n\n function enable_packed_slots(StdStorage storage self) internal returns (StdStorage storage) {\n return stdStorageSafe.enable_packed_slots(self);\n }\n\n function depth(StdStorage storage self, uint256 _depth) internal returns (StdStorage storage) {\n return stdStorageSafe.depth(self, _depth);\n }\n\n function clear(StdStorage storage self) internal {\n stdStorageSafe.clear(self);\n }\n\n function checked_write(StdStorage storage self, address who) internal {\n checked_write(self, bytes32(uint256(uint160(who))));\n }\n\n function checked_write(StdStorage storage self, uint256 amt) internal {\n checked_write(self, bytes32(amt));\n }\n\n function checked_write_int(StdStorage storage self, int256 val) internal {\n checked_write(self, bytes32(uint256(val)));\n }\n\n function checked_write(StdStorage storage self, bool write) internal {\n bytes32 t;\n /// @solidity memory-safe-assembly\n assembly {\n t := write\n }\n checked_write(self, t);\n }\n\n function checked_write(StdStorage storage self, bytes32 set) internal {\n address who = self._target;\n bytes4 fsig = self._sig;\n uint256 field_depth = self._depth;\n bytes memory params = stdStorageSafe.getCallParams(self);\n\n if (!self.finds[who][fsig][keccak256(abi.encodePacked(params, field_depth))].found) {\n find(self, false);\n }\n FindData storage data = self.finds[who][fsig][keccak256(abi.encodePacked(params, field_depth))];\n if ((data.offsetLeft + data.offsetRight) > 0) {\n uint256 maxVal = 2 ** (256 - (data.offsetLeft + data.offsetRight));\n require(\n uint256(set) < maxVal,\n string(\n abi.encodePacked(\n \"stdStorage find(StdStorage): Packed slot. We can't fit value greater than \",\n vm.toString(maxVal)\n )\n )\n );\n }\n bytes32 curVal = vm.load(who, bytes32(data.slot));\n bytes32 valToSet = stdStorageSafe.getUpdatedSlotValue(curVal, uint256(set), data.offsetLeft, data.offsetRight);\n\n vm.store(who, bytes32(data.slot), valToSet);\n\n (bool success, bytes32 callResult) = stdStorageSafe.callTarget(self);\n\n if (!success || callResult != set) {\n vm.store(who, bytes32(data.slot), curVal);\n revert(\"stdStorage find(StdStorage): Failed to write value.\");\n }\n clear(self);\n }\n\n function read_bytes32(StdStorage storage self) internal returns (bytes32) {\n return stdStorageSafe.read_bytes32(self);\n }\n\n function read_bool(StdStorage storage self) internal returns (bool) {\n return stdStorageSafe.read_bool(self);\n }\n\n function read_address(StdStorage storage self) internal returns (address) {\n return stdStorageSafe.read_address(self);\n }\n\n function read_uint(StdStorage storage self) internal returns (uint256) {\n return stdStorageSafe.read_uint(self);\n }\n\n function read_int(StdStorage storage self) internal returns (int256) {\n return stdStorageSafe.read_int(self);\n }\n\n function parent(StdStorage storage self) internal returns (uint256, bytes32) {\n return stdStorageSafe.parent(self);\n }\n\n function root(StdStorage storage self) internal returns (uint256) {\n return stdStorageSafe.root(self);\n }\n}\n","license":"MIT"},"lib/forge-std/src/StdStyle.sol":{"keccak256":"0x43e2a8a9b9c2574dabe74f11adf6f782df218f463540e3b5b563609fe108597d","urls":[],"content":"// SPDX-License-Identifier: MIT\npragma solidity >=0.4.22 <0.9.0;\n\nimport {VmSafe} from \"./Vm.sol\";\n\nlibrary StdStyle {\n VmSafe private constant vm = VmSafe(address(uint160(uint256(keccak256(\"hevm cheat code\")))));\n\n string constant RED = \"\\u001b[91m\";\n string constant GREEN = \"\\u001b[92m\";\n string constant YELLOW = \"\\u001b[93m\";\n string constant BLUE = \"\\u001b[94m\";\n string constant MAGENTA = \"\\u001b[95m\";\n string constant CYAN = \"\\u001b[96m\";\n string constant BOLD = \"\\u001b[1m\";\n string constant DIM = \"\\u001b[2m\";\n string constant ITALIC = \"\\u001b[3m\";\n string constant UNDERLINE = \"\\u001b[4m\";\n string constant INVERSE = \"\\u001b[7m\";\n string constant RESET = \"\\u001b[0m\";\n\n function styleConcat(string memory style, string memory self) private pure returns (string memory) {\n return string(abi.encodePacked(style, self, RESET));\n }\n\n function red(string memory self) internal pure returns (string memory) {\n return styleConcat(RED, self);\n }\n\n function red(uint256 self) internal pure returns (string memory) {\n return red(vm.toString(self));\n }\n\n function red(int256 self) internal pure returns (string memory) {\n return red(vm.toString(self));\n }\n\n function red(address self) internal pure returns (string memory) {\n return red(vm.toString(self));\n }\n\n function red(bool self) internal pure returns (string memory) {\n return red(vm.toString(self));\n }\n\n function redBytes(bytes memory self) internal pure returns (string memory) {\n return red(vm.toString(self));\n }\n\n function redBytes32(bytes32 self) internal pure returns (string memory) {\n return red(vm.toString(self));\n }\n\n function green(string memory self) internal pure returns (string memory) {\n return styleConcat(GREEN, self);\n }\n\n function green(uint256 self) internal pure returns (string memory) {\n return green(vm.toString(self));\n }\n\n function green(int256 self) internal pure returns (string memory) {\n return green(vm.toString(self));\n }\n\n function green(address self) internal pure returns (string memory) {\n return green(vm.toString(self));\n }\n\n function green(bool self) internal pure returns (string memory) {\n return green(vm.toString(self));\n }\n\n function greenBytes(bytes memory self) internal pure returns (string memory) {\n return green(vm.toString(self));\n }\n\n function greenBytes32(bytes32 self) internal pure returns (string memory) {\n return green(vm.toString(self));\n }\n\n function yellow(string memory self) internal pure returns (string memory) {\n return styleConcat(YELLOW, self);\n }\n\n function yellow(uint256 self) internal pure returns (string memory) {\n return yellow(vm.toString(self));\n }\n\n function yellow(int256 self) internal pure returns (string memory) {\n return yellow(vm.toString(self));\n }\n\n function yellow(address self) internal pure returns (string memory) {\n return yellow(vm.toString(self));\n }\n\n function yellow(bool self) internal pure returns (string memory) {\n return yellow(vm.toString(self));\n }\n\n function yellowBytes(bytes memory self) internal pure returns (string memory) {\n return yellow(vm.toString(self));\n }\n\n function yellowBytes32(bytes32 self) internal pure returns (string memory) {\n return yellow(vm.toString(self));\n }\n\n function blue(string memory self) internal pure returns (string memory) {\n return styleConcat(BLUE, self);\n }\n\n function blue(uint256 self) internal pure returns (string memory) {\n return blue(vm.toString(self));\n }\n\n function blue(int256 self) internal pure returns (string memory) {\n return blue(vm.toString(self));\n }\n\n function blue(address self) internal pure returns (string memory) {\n return blue(vm.toString(self));\n }\n\n function blue(bool self) internal pure returns (string memory) {\n return blue(vm.toString(self));\n }\n\n function blueBytes(bytes memory self) internal pure returns (string memory) {\n return blue(vm.toString(self));\n }\n\n function blueBytes32(bytes32 self) internal pure returns (string memory) {\n return blue(vm.toString(self));\n }\n\n function magenta(string memory self) internal pure returns (string memory) {\n return styleConcat(MAGENTA, self);\n }\n\n function magenta(uint256 self) internal pure returns (string memory) {\n return magenta(vm.toString(self));\n }\n\n function magenta(int256 self) internal pure returns (string memory) {\n return magenta(vm.toString(self));\n }\n\n function magenta(address self) internal pure returns (string memory) {\n return magenta(vm.toString(self));\n }\n\n function magenta(bool self) internal pure returns (string memory) {\n return magenta(vm.toString(self));\n }\n\n function magentaBytes(bytes memory self) internal pure returns (string memory) {\n return magenta(vm.toString(self));\n }\n\n function magentaBytes32(bytes32 self) internal pure returns (string memory) {\n return magenta(vm.toString(self));\n }\n\n function cyan(string memory self) internal pure returns (string memory) {\n return styleConcat(CYAN, self);\n }\n\n function cyan(uint256 self) internal pure returns (string memory) {\n return cyan(vm.toString(self));\n }\n\n function cyan(int256 self) internal pure returns (string memory) {\n return cyan(vm.toString(self));\n }\n\n function cyan(address self) internal pure returns (string memory) {\n return cyan(vm.toString(self));\n }\n\n function cyan(bool self) internal pure returns (string memory) {\n return cyan(vm.toString(self));\n }\n\n function cyanBytes(bytes memory self) internal pure returns (string memory) {\n return cyan(vm.toString(self));\n }\n\n function cyanBytes32(bytes32 self) internal pure returns (string memory) {\n return cyan(vm.toString(self));\n }\n\n function bold(string memory self) internal pure returns (string memory) {\n return styleConcat(BOLD, self);\n }\n\n function bold(uint256 self) internal pure returns (string memory) {\n return bold(vm.toString(self));\n }\n\n function bold(int256 self) internal pure returns (string memory) {\n return bold(vm.toString(self));\n }\n\n function bold(address self) internal pure returns (string memory) {\n return bold(vm.toString(self));\n }\n\n function bold(bool self) internal pure returns (string memory) {\n return bold(vm.toString(self));\n }\n\n function boldBytes(bytes memory self) internal pure returns (string memory) {\n return bold(vm.toString(self));\n }\n\n function boldBytes32(bytes32 self) internal pure returns (string memory) {\n return bold(vm.toString(self));\n }\n\n function dim(string memory self) internal pure returns (string memory) {\n return styleConcat(DIM, self);\n }\n\n function dim(uint256 self) internal pure returns (string memory) {\n return dim(vm.toString(self));\n }\n\n function dim(int256 self) internal pure returns (string memory) {\n return dim(vm.toString(self));\n }\n\n function dim(address self) internal pure returns (string memory) {\n return dim(vm.toString(self));\n }\n\n function dim(bool self) internal pure returns (string memory) {\n return dim(vm.toString(self));\n }\n\n function dimBytes(bytes memory self) internal pure returns (string memory) {\n return dim(vm.toString(self));\n }\n\n function dimBytes32(bytes32 self) internal pure returns (string memory) {\n return dim(vm.toString(self));\n }\n\n function italic(string memory self) internal pure returns (string memory) {\n return styleConcat(ITALIC, self);\n }\n\n function italic(uint256 self) internal pure returns (string memory) {\n return italic(vm.toString(self));\n }\n\n function italic(int256 self) internal pure returns (string memory) {\n return italic(vm.toString(self));\n }\n\n function italic(address self) internal pure returns (string memory) {\n return italic(vm.toString(self));\n }\n\n function italic(bool self) internal pure returns (string memory) {\n return italic(vm.toString(self));\n }\n\n function italicBytes(bytes memory self) internal pure returns (string memory) {\n return italic(vm.toString(self));\n }\n\n function italicBytes32(bytes32 self) internal pure returns (string memory) {\n return italic(vm.toString(self));\n }\n\n function underline(string memory self) internal pure returns (string memory) {\n return styleConcat(UNDERLINE, self);\n }\n\n function underline(uint256 self) internal pure returns (string memory) {\n return underline(vm.toString(self));\n }\n\n function underline(int256 self) internal pure returns (string memory) {\n return underline(vm.toString(self));\n }\n\n function underline(address self) internal pure returns (string memory) {\n return underline(vm.toString(self));\n }\n\n function underline(bool self) internal pure returns (string memory) {\n return underline(vm.toString(self));\n }\n\n function underlineBytes(bytes memory self) internal pure returns (string memory) {\n return underline(vm.toString(self));\n }\n\n function underlineBytes32(bytes32 self) internal pure returns (string memory) {\n return underline(vm.toString(self));\n }\n\n function inverse(string memory self) internal pure returns (string memory) {\n return styleConcat(INVERSE, self);\n }\n\n function inverse(uint256 self) internal pure returns (string memory) {\n return inverse(vm.toString(self));\n }\n\n function inverse(int256 self) internal pure returns (string memory) {\n return inverse(vm.toString(self));\n }\n\n function inverse(address self) internal pure returns (string memory) {\n return inverse(vm.toString(self));\n }\n\n function inverse(bool self) internal pure returns (string memory) {\n return inverse(vm.toString(self));\n }\n\n function inverseBytes(bytes memory self) internal pure returns (string memory) {\n return inverse(vm.toString(self));\n }\n\n function inverseBytes32(bytes32 self) internal pure returns (string memory) {\n return inverse(vm.toString(self));\n }\n}\n","license":"MIT"},"lib/forge-std/src/StdUtils.sol":{"keccak256":"0x7274081e11c05164fd8eadde4de8305c033e58a43008dea58065f3170ccf0737","urls":[],"content":"// SPDX-License-Identifier: MIT\npragma solidity >=0.6.2 <0.9.0;\n\npragma experimental ABIEncoderV2;\n\nimport {IMulticall3} from \"./interfaces/IMulticall3.sol\";\nimport {VmSafe} from \"./Vm.sol\";\n\nabstract contract StdUtils {\n /*//////////////////////////////////////////////////////////////////////////\n CONSTANTS\n //////////////////////////////////////////////////////////////////////////*/\n\n IMulticall3 private constant multicall = IMulticall3(0xcA11bde05977b3631167028862bE2a173976CA11);\n VmSafe private constant vm = VmSafe(address(uint160(uint256(keccak256(\"hevm cheat code\")))));\n address private constant CONSOLE2_ADDRESS = 0x000000000000000000636F6e736F6c652e6c6f67;\n uint256 private constant INT256_MIN_ABS =\n 57896044618658097711785492504343953926634992332820282019728792003956564819968;\n uint256 private constant SECP256K1_ORDER =\n 115792089237316195423570985008687907852837564279074904382605163141518161494337;\n uint256 private constant UINT256_MAX =\n 115792089237316195423570985008687907853269984665640564039457584007913129639935;\n\n // Used by default when deploying with create2, https://github.com/Arachnid/deterministic-deployment-proxy.\n address private constant CREATE2_FACTORY = 0x4e59b44847b379578588920cA78FbF26c0B4956C;\n\n /*//////////////////////////////////////////////////////////////////////////\n INTERNAL FUNCTIONS\n //////////////////////////////////////////////////////////////////////////*/\n\n function _bound(uint256 x, uint256 min, uint256 max) internal pure virtual returns (uint256 result) {\n require(min <= max, \"StdUtils bound(uint256,uint256,uint256): Max is less than min.\");\n // If x is between min and max, return x directly. This is to ensure that dictionary values\n // do not get shifted if the min is nonzero. More info: https://github.com/foundry-rs/forge-std/issues/188\n if (x >= min && x <= max) return x;\n\n uint256 size = max - min + 1;\n\n // If the value is 0, 1, 2, 3, wrap that to min, min+1, min+2, min+3. Similarly for the UINT256_MAX side.\n // This helps ensure coverage of the min/max values.\n if (x <= 3 && size > x) return min + x;\n if (x >= UINT256_MAX - 3 && size > UINT256_MAX - x) return max - (UINT256_MAX - x);\n\n // Otherwise, wrap x into the range [min, max], i.e. the range is inclusive.\n if (x > max) {\n uint256 diff = x - max;\n uint256 rem = diff % size;\n if (rem == 0) return max;\n result = min + rem - 1;\n } else if (x < min) {\n uint256 diff = min - x;\n uint256 rem = diff % size;\n if (rem == 0) return min;\n result = max - rem + 1;\n }\n }\n\n function bound(uint256 x, uint256 min, uint256 max) internal pure virtual returns (uint256 result) {\n result = _bound(x, min, max);\n console2_log_StdUtils(\"Bound result\", result);\n }\n\n function _bound(int256 x, int256 min, int256 max) internal pure virtual returns (int256 result) {\n require(min <= max, \"StdUtils bound(int256,int256,int256): Max is less than min.\");\n\n // Shifting all int256 values to uint256 to use _bound function. The range of two types are:\n // int256 : -(2**255) ~ (2**255 - 1)\n // uint256: 0 ~ (2**256 - 1)\n // So, add 2**255, INT256_MIN_ABS to the integer values.\n //\n // If the given integer value is -2**255, we cannot use `-uint256(-x)` because of the overflow.\n // So, use `~uint256(x) + 1` instead.\n uint256 _x = x < 0 ? (INT256_MIN_ABS - ~uint256(x) - 1) : (uint256(x) + INT256_MIN_ABS);\n uint256 _min = min < 0 ? (INT256_MIN_ABS - ~uint256(min) - 1) : (uint256(min) + INT256_MIN_ABS);\n uint256 _max = max < 0 ? (INT256_MIN_ABS - ~uint256(max) - 1) : (uint256(max) + INT256_MIN_ABS);\n\n uint256 y = _bound(_x, _min, _max);\n\n // To move it back to int256 value, subtract INT256_MIN_ABS at here.\n result = y < INT256_MIN_ABS ? int256(~(INT256_MIN_ABS - y) + 1) : int256(y - INT256_MIN_ABS);\n }\n\n function bound(int256 x, int256 min, int256 max) internal pure virtual returns (int256 result) {\n result = _bound(x, min, max);\n console2_log_StdUtils(\"Bound result\", vm.toString(result));\n }\n\n function boundPrivateKey(uint256 privateKey) internal pure virtual returns (uint256 result) {\n result = _bound(privateKey, 1, SECP256K1_ORDER - 1);\n }\n\n function bytesToUint(bytes memory b) internal pure virtual returns (uint256) {\n require(b.length <= 32, \"StdUtils bytesToUint(bytes): Bytes length exceeds 32.\");\n return abi.decode(abi.encodePacked(new bytes(32 - b.length), b), (uint256));\n }\n\n /// @dev Compute the address a contract will be deployed at for a given deployer address and nonce\n /// @notice adapted from Solmate implementation (https://github.com/Rari-Capital/solmate/blob/main/src/utils/LibRLP.sol)\n function computeCreateAddress(address deployer, uint256 nonce) internal pure virtual returns (address) {\n console2_log_StdUtils(\"computeCreateAddress is deprecated. Please use vm.computeCreateAddress instead.\");\n return vm.computeCreateAddress(deployer, nonce);\n }\n\n function computeCreate2Address(bytes32 salt, bytes32 initcodeHash, address deployer)\n internal\n pure\n virtual\n returns (address)\n {\n console2_log_StdUtils(\"computeCreate2Address is deprecated. Please use vm.computeCreate2Address instead.\");\n return vm.computeCreate2Address(salt, initcodeHash, deployer);\n }\n\n /// @dev returns the address of a contract created with CREATE2 using the default CREATE2 deployer\n function computeCreate2Address(bytes32 salt, bytes32 initCodeHash) internal pure returns (address) {\n console2_log_StdUtils(\"computeCreate2Address is deprecated. Please use vm.computeCreate2Address instead.\");\n return vm.computeCreate2Address(salt, initCodeHash);\n }\n\n /// @dev returns the hash of the init code (creation code + no args) used in CREATE2 with no constructor arguments\n /// @param creationCode the creation code of a contract C, as returned by type(C).creationCode\n function hashInitCode(bytes memory creationCode) internal pure returns (bytes32) {\n return hashInitCode(creationCode, \"\");\n }\n\n /// @dev returns the hash of the init code (creation code + ABI-encoded args) used in CREATE2\n /// @param creationCode the creation code of a contract C, as returned by type(C).creationCode\n /// @param args the ABI-encoded arguments to the constructor of C\n function hashInitCode(bytes memory creationCode, bytes memory args) internal pure returns (bytes32) {\n return keccak256(abi.encodePacked(creationCode, args));\n }\n\n // Performs a single call with Multicall3 to query the ERC-20 token balances of the given addresses.\n function getTokenBalances(address token, address[] memory addresses)\n internal\n virtual\n returns (uint256[] memory balances)\n {\n uint256 tokenCodeSize;\n assembly {\n tokenCodeSize := extcodesize(token)\n }\n require(tokenCodeSize > 0, \"StdUtils getTokenBalances(address,address[]): Token address is not a contract.\");\n\n // ABI encode the aggregate call to Multicall3.\n uint256 length = addresses.length;\n IMulticall3.Call[] memory calls = new IMulticall3.Call[](length);\n for (uint256 i = 0; i < length; ++i) {\n // 0x70a08231 = bytes4(\"balanceOf(address)\"))\n calls[i] = IMulticall3.Call({target: token, callData: abi.encodeWithSelector(0x70a08231, (addresses[i]))});\n }\n\n // Make the aggregate call.\n (, bytes[] memory returnData) = multicall.aggregate(calls);\n\n // ABI decode the return data and return the balances.\n balances = new uint256[](length);\n for (uint256 i = 0; i < length; ++i) {\n balances[i] = abi.decode(returnData[i], (uint256));\n }\n }\n\n /*//////////////////////////////////////////////////////////////////////////\n PRIVATE FUNCTIONS\n //////////////////////////////////////////////////////////////////////////*/\n\n function addressFromLast20Bytes(bytes32 bytesValue) private pure returns (address) {\n return address(uint160(uint256(bytesValue)));\n }\n\n // This section is used to prevent the compilation of console, which shortens the compilation time when console is\n // not used elsewhere. We also trick the compiler into letting us make the console log methods as `pure` to avoid\n // any breaking changes to function signatures.\n function _castLogPayloadViewToPure(function(bytes memory) internal view fnIn)\n internal\n pure\n returns (function(bytes memory) internal pure fnOut)\n {\n assembly {\n fnOut := fnIn\n }\n }\n\n function _sendLogPayload(bytes memory payload) internal pure {\n _castLogPayloadViewToPure(_sendLogPayloadView)(payload);\n }\n\n function _sendLogPayloadView(bytes memory payload) private view {\n uint256 payloadLength = payload.length;\n address consoleAddress = CONSOLE2_ADDRESS;\n /// @solidity memory-safe-assembly\n assembly {\n let payloadStart := add(payload, 32)\n let r := staticcall(gas(), consoleAddress, payloadStart, payloadLength, 0, 0)\n }\n }\n\n function console2_log_StdUtils(string memory p0) private pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string)\", p0));\n }\n\n function console2_log_StdUtils(string memory p0, uint256 p1) private pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,uint256)\", p0, p1));\n }\n\n function console2_log_StdUtils(string memory p0, string memory p1) private pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,string)\", p0, p1));\n }\n}\n","license":"MIT"},"lib/forge-std/src/Vm.sol":{"keccak256":"0xd91fb0df409fbd22463e937b48b9682d9333c5d4528d8fe7b36102a0323c44bf","urls":[],"content":"// Automatically @generated by scripts/vm.py. Do not modify manually.\n\n// SPDX-License-Identifier: MIT OR Apache-2.0\npragma solidity >=0.6.2 <0.9.0;\npragma experimental ABIEncoderV2;\n\n/// The `VmSafe` interface does not allow manipulation of the EVM state or other actions that may\n/// result in Script simulations differing from on-chain execution. It is recommended to only use\n/// these cheats in scripts.\ninterface VmSafe {\n /// A modification applied to either `msg.sender` or `tx.origin`. Returned by `readCallers`.\n enum CallerMode {\n // No caller modification is currently active.\n None,\n // A one time broadcast triggered by a `vm.broadcast()` call is currently active.\n Broadcast,\n // A recurrent broadcast triggered by a `vm.startBroadcast()` call is currently active.\n RecurrentBroadcast,\n // A one time prank triggered by a `vm.prank()` call is currently active.\n Prank,\n // A recurrent prank triggered by a `vm.startPrank()` call is currently active.\n RecurrentPrank\n }\n\n /// The kind of account access that occurred.\n enum AccountAccessKind {\n // The account was called.\n Call,\n // The account was called via delegatecall.\n DelegateCall,\n // The account was called via callcode.\n CallCode,\n // The account was called via staticcall.\n StaticCall,\n // The account was created.\n Create,\n // The account was selfdestructed.\n SelfDestruct,\n // Synthetic access indicating the current context has resumed after a previous sub-context (AccountAccess).\n Resume,\n // The account's balance was read.\n Balance,\n // The account's codesize was read.\n Extcodesize,\n // The account's codehash was read.\n Extcodehash,\n // The account's code was copied.\n Extcodecopy\n }\n\n /// Forge execution contexts.\n enum ForgeContext {\n // Test group execution context (test, coverage or snapshot).\n TestGroup,\n // `forge test` execution context.\n Test,\n // `forge coverage` execution context.\n Coverage,\n // `forge snapshot` execution context.\n Snapshot,\n // Script group execution context (dry run, broadcast or resume).\n ScriptGroup,\n // `forge script` execution context.\n ScriptDryRun,\n // `forge script --broadcast` execution context.\n ScriptBroadcast,\n // `forge script --resume` execution context.\n ScriptResume,\n // Unknown `forge` execution context.\n Unknown\n }\n\n /// The transaction type (`txType`) of the broadcast.\n enum BroadcastTxType {\n // Represents a CALL broadcast tx.\n Call,\n // Represents a CREATE broadcast tx.\n Create,\n // Represents a CREATE2 broadcast tx.\n Create2\n }\n\n /// An Ethereum log. Returned by `getRecordedLogs`.\n struct Log {\n // The topics of the log, including the signature, if any.\n bytes32[] topics;\n // The raw data of the log.\n bytes data;\n // The address of the log's emitter.\n address emitter;\n }\n\n /// An RPC URL and its alias. Returned by `rpcUrlStructs`.\n struct Rpc {\n // The alias of the RPC URL.\n string key;\n // The RPC URL.\n string url;\n }\n\n /// An RPC log object. Returned by `eth_getLogs`.\n struct EthGetLogs {\n // The address of the log's emitter.\n address emitter;\n // The topics of the log, including the signature, if any.\n bytes32[] topics;\n // The raw data of the log.\n bytes data;\n // The block hash.\n bytes32 blockHash;\n // The block number.\n uint64 blockNumber;\n // The transaction hash.\n bytes32 transactionHash;\n // The transaction index in the block.\n uint64 transactionIndex;\n // The log index.\n uint256 logIndex;\n // Whether the log was removed.\n bool removed;\n }\n\n /// A single entry in a directory listing. Returned by `readDir`.\n struct DirEntry {\n // The error message, if any.\n string errorMessage;\n // The path of the entry.\n string path;\n // The depth of the entry.\n uint64 depth;\n // Whether the entry is a directory.\n bool isDir;\n // Whether the entry is a symlink.\n bool isSymlink;\n }\n\n /// Metadata information about a file.\n /// This structure is returned from the `fsMetadata` function and represents known\n /// metadata about a file such as its permissions, size, modification\n /// times, etc.\n struct FsMetadata {\n // True if this metadata is for a directory.\n bool isDir;\n // True if this metadata is for a symlink.\n bool isSymlink;\n // The size of the file, in bytes, this metadata is for.\n uint256 length;\n // True if this metadata is for a readonly (unwritable) file.\n bool readOnly;\n // The last modification time listed in this metadata.\n uint256 modified;\n // The last access time of this metadata.\n uint256 accessed;\n // The creation time listed in this metadata.\n uint256 created;\n }\n\n /// A wallet with a public and private key.\n struct Wallet {\n // The wallet's address.\n address addr;\n // The wallet's public key `X`.\n uint256 publicKeyX;\n // The wallet's public key `Y`.\n uint256 publicKeyY;\n // The wallet's private key.\n uint256 privateKey;\n }\n\n /// The result of a `tryFfi` call.\n struct FfiResult {\n // The exit code of the call.\n int32 exitCode;\n // The optionally hex-decoded `stdout` data.\n bytes stdout;\n // The `stderr` data.\n bytes stderr;\n }\n\n /// Information on the chain and fork.\n struct ChainInfo {\n // The fork identifier. Set to zero if no fork is active.\n uint256 forkId;\n // The chain ID of the current fork.\n uint256 chainId;\n }\n\n /// The result of a `stopAndReturnStateDiff` call.\n struct AccountAccess {\n // The chain and fork the access occurred.\n ChainInfo chainInfo;\n // The kind of account access that determines what the account is.\n // If kind is Call, DelegateCall, StaticCall or CallCode, then the account is the callee.\n // If kind is Create, then the account is the newly created account.\n // If kind is SelfDestruct, then the account is the selfdestruct recipient.\n // If kind is a Resume, then account represents a account context that has resumed.\n AccountAccessKind kind;\n // The account that was accessed.\n // It's either the account created, callee or a selfdestruct recipient for CREATE, CALL or SELFDESTRUCT.\n address account;\n // What accessed the account.\n address accessor;\n // If the account was initialized or empty prior to the access.\n // An account is considered initialized if it has code, a\n // non-zero nonce, or a non-zero balance.\n bool initialized;\n // The previous balance of the accessed account.\n uint256 oldBalance;\n // The potential new balance of the accessed account.\n // That is, all balance changes are recorded here, even if reverts occurred.\n uint256 newBalance;\n // Code of the account deployed by CREATE.\n bytes deployedCode;\n // Value passed along with the account access\n uint256 value;\n // Input data provided to the CREATE or CALL\n bytes data;\n // If this access reverted in either the current or parent context.\n bool reverted;\n // An ordered list of storage accesses made during an account access operation.\n StorageAccess[] storageAccesses;\n // Call depth traversed during the recording of state differences\n uint64 depth;\n }\n\n /// The storage accessed during an `AccountAccess`.\n struct StorageAccess {\n // The account whose storage was accessed.\n address account;\n // The slot that was accessed.\n bytes32 slot;\n // If the access was a write.\n bool isWrite;\n // The previous value of the slot.\n bytes32 previousValue;\n // The new value of the slot.\n bytes32 newValue;\n // If the access was reverted.\n bool reverted;\n }\n\n /// Gas used. Returned by `lastCallGas`.\n struct Gas {\n // The gas limit of the call.\n uint64 gasLimit;\n // The total gas used.\n uint64 gasTotalUsed;\n // DEPRECATED: The amount of gas used for memory expansion. Ref: \n uint64 gasMemoryUsed;\n // The amount of gas refunded.\n int64 gasRefunded;\n // The amount of gas remaining.\n uint64 gasRemaining;\n }\n\n /// The result of the `stopDebugTraceRecording` call\n struct DebugStep {\n // The stack before executing the step of the run.\n // stack\\[0\\] represents the top of the stack.\n // and only stack data relevant to the opcode execution is contained.\n uint256[] stack;\n // The memory input data before executing the step of the run.\n // only input data relevant to the opcode execution is contained.\n // e.g. for MLOAD, it will have memory\\[offset:offset+32\\] copied here.\n // the offset value can be get by the stack data.\n bytes memoryInput;\n // The opcode that was accessed.\n uint8 opcode;\n // The call depth of the step.\n uint64 depth;\n // Whether the call end up with out of gas error.\n bool isOutOfGas;\n // The contract address where the opcode is running\n address contractAddr;\n }\n\n /// Represents a transaction's broadcast details.\n struct BroadcastTxSummary {\n // The hash of the transaction that was broadcasted\n bytes32 txHash;\n // Represent the type of transaction among CALL, CREATE, CREATE2\n BroadcastTxType txType;\n // The address of the contract that was called or created.\n // This is address of the contract that is created if the txType is CREATE or CREATE2.\n address contractAddress;\n // The block number the transaction landed in.\n uint64 blockNumber;\n // Status of the transaction, retrieved from the transaction receipt.\n bool success;\n }\n\n /// Holds a signed EIP-7702 authorization for an authority account to delegate to an implementation.\n struct SignedDelegation {\n // The y-parity of the recovered secp256k1 signature (0 or 1).\n uint8 v;\n // First 32 bytes of the signature.\n bytes32 r;\n // Second 32 bytes of the signature.\n bytes32 s;\n // The current nonce of the authority account at signing time.\n // Used to ensure signature can't be replayed after account nonce changes.\n uint64 nonce;\n // Address of the contract implementation that will be delegated to.\n // Gets encoded into delegation code: 0xef0100 || implementation.\n address implementation;\n }\n\n /// Represents a \"potential\" revert reason from a single subsequent call when using `vm.assumeNoReverts`.\n /// Reverts that match will result in a FOUNDRY::ASSUME rejection, whereas unmatched reverts will be surfaced\n /// as normal.\n struct PotentialRevert {\n // The allowed origin of the revert opcode; address(0) allows reverts from any address\n address reverter;\n // When true, only matches on the beginning of the revert data, otherwise, matches on entire revert data\n bool partialMatch;\n // The data to use to match encountered reverts\n bytes revertData;\n }\n\n /// An EIP-2930 access list item.\n struct AccessListItem {\n // The address to be added in access list.\n address target;\n // The storage keys to be added in access list.\n bytes32[] storageKeys;\n }\n\n // ======== Crypto ========\n\n /// Derives a private key from the name, labels the account with that name, and returns the wallet.\n function createWallet(string calldata walletLabel) external returns (Wallet memory wallet);\n\n /// Generates a wallet from the private key and returns the wallet.\n function createWallet(uint256 privateKey) external returns (Wallet memory wallet);\n\n /// Generates a wallet from the private key, labels the account with that name, and returns the wallet.\n function createWallet(uint256 privateKey, string calldata walletLabel) external returns (Wallet memory wallet);\n\n /// Derive a private key from a provided mnenomic string (or mnenomic file path)\n /// at the derivation path `m/44'/60'/0'/0/{index}`.\n function deriveKey(string calldata mnemonic, uint32 index) external pure returns (uint256 privateKey);\n\n /// Derive a private key from a provided mnenomic string (or mnenomic file path)\n /// at `{derivationPath}{index}`.\n function deriveKey(string calldata mnemonic, string calldata derivationPath, uint32 index)\n external\n pure\n returns (uint256 privateKey);\n\n /// Derive a private key from a provided mnenomic string (or mnenomic file path) in the specified language\n /// at the derivation path `m/44'/60'/0'/0/{index}`.\n function deriveKey(string calldata mnemonic, uint32 index, string calldata language)\n external\n pure\n returns (uint256 privateKey);\n\n /// Derive a private key from a provided mnenomic string (or mnenomic file path) in the specified language\n /// at `{derivationPath}{index}`.\n function deriveKey(string calldata mnemonic, string calldata derivationPath, uint32 index, string calldata language)\n external\n pure\n returns (uint256 privateKey);\n\n /// Derives secp256r1 public key from the provided `privateKey`.\n function publicKeyP256(uint256 privateKey) external pure returns (uint256 publicKeyX, uint256 publicKeyY);\n\n /// Adds a private key to the local forge wallet and returns the address.\n function rememberKey(uint256 privateKey) external returns (address keyAddr);\n\n /// Derive a set number of wallets from a mnemonic at the derivation path `m/44'/60'/0'/0/{0..count}`.\n /// The respective private keys are saved to the local forge wallet for later use and their addresses are returned.\n function rememberKeys(string calldata mnemonic, string calldata derivationPath, uint32 count)\n external\n returns (address[] memory keyAddrs);\n\n /// Derive a set number of wallets from a mnemonic in the specified language at the derivation path `m/44'/60'/0'/0/{0..count}`.\n /// The respective private keys are saved to the local forge wallet for later use and their addresses are returned.\n function rememberKeys(\n string calldata mnemonic,\n string calldata derivationPath,\n string calldata language,\n uint32 count\n ) external returns (address[] memory keyAddrs);\n\n /// Signs data with a `Wallet`.\n /// Returns a compact signature (`r`, `vs`) as per EIP-2098, where `vs` encodes both the\n /// signature's `s` value, and the recovery id `v` in a single bytes32.\n /// This format reduces the signature size from 65 to 64 bytes.\n function signCompact(Wallet calldata wallet, bytes32 digest) external returns (bytes32 r, bytes32 vs);\n\n /// Signs `digest` with `privateKey` using the secp256k1 curve.\n /// Returns a compact signature (`r`, `vs`) as per EIP-2098, where `vs` encodes both the\n /// signature's `s` value, and the recovery id `v` in a single bytes32.\n /// This format reduces the signature size from 65 to 64 bytes.\n function signCompact(uint256 privateKey, bytes32 digest) external pure returns (bytes32 r, bytes32 vs);\n\n /// Signs `digest` with signer provided to script using the secp256k1 curve.\n /// Returns a compact signature (`r`, `vs`) as per EIP-2098, where `vs` encodes both the\n /// signature's `s` value, and the recovery id `v` in a single bytes32.\n /// This format reduces the signature size from 65 to 64 bytes.\n /// If `--sender` is provided, the signer with provided address is used, otherwise,\n /// if exactly one signer is provided to the script, that signer is used.\n /// Raises error if signer passed through `--sender` does not match any unlocked signers or\n /// if `--sender` is not provided and not exactly one signer is passed to the script.\n function signCompact(bytes32 digest) external pure returns (bytes32 r, bytes32 vs);\n\n /// Signs `digest` with signer provided to script using the secp256k1 curve.\n /// Returns a compact signature (`r`, `vs`) as per EIP-2098, where `vs` encodes both the\n /// signature's `s` value, and the recovery id `v` in a single bytes32.\n /// This format reduces the signature size from 65 to 64 bytes.\n /// Raises error if none of the signers passed into the script have provided address.\n function signCompact(address signer, bytes32 digest) external pure returns (bytes32 r, bytes32 vs);\n\n /// Signs `digest` with `privateKey` using the secp256r1 curve.\n function signP256(uint256 privateKey, bytes32 digest) external pure returns (bytes32 r, bytes32 s);\n\n /// Signs data with a `Wallet`.\n function sign(Wallet calldata wallet, bytes32 digest) external returns (uint8 v, bytes32 r, bytes32 s);\n\n /// Signs `digest` with `privateKey` using the secp256k1 curve.\n function sign(uint256 privateKey, bytes32 digest) external pure returns (uint8 v, bytes32 r, bytes32 s);\n\n /// Signs `digest` with signer provided to script using the secp256k1 curve.\n /// If `--sender` is provided, the signer with provided address is used, otherwise,\n /// if exactly one signer is provided to the script, that signer is used.\n /// Raises error if signer passed through `--sender` does not match any unlocked signers or\n /// if `--sender` is not provided and not exactly one signer is passed to the script.\n function sign(bytes32 digest) external pure returns (uint8 v, bytes32 r, bytes32 s);\n\n /// Signs `digest` with signer provided to script using the secp256k1 curve.\n /// Raises error if none of the signers passed into the script have provided address.\n function sign(address signer, bytes32 digest) external pure returns (uint8 v, bytes32 r, bytes32 s);\n\n // ======== Environment ========\n\n /// Gets the environment variable `name` and parses it as `address`.\n /// Reverts if the variable was not found or could not be parsed.\n function envAddress(string calldata name) external view returns (address value);\n\n /// Gets the environment variable `name` and parses it as an array of `address`, delimited by `delim`.\n /// Reverts if the variable was not found or could not be parsed.\n function envAddress(string calldata name, string calldata delim) external view returns (address[] memory value);\n\n /// Gets the environment variable `name` and parses it as `bool`.\n /// Reverts if the variable was not found or could not be parsed.\n function envBool(string calldata name) external view returns (bool value);\n\n /// Gets the environment variable `name` and parses it as an array of `bool`, delimited by `delim`.\n /// Reverts if the variable was not found or could not be parsed.\n function envBool(string calldata name, string calldata delim) external view returns (bool[] memory value);\n\n /// Gets the environment variable `name` and parses it as `bytes32`.\n /// Reverts if the variable was not found or could not be parsed.\n function envBytes32(string calldata name) external view returns (bytes32 value);\n\n /// Gets the environment variable `name` and parses it as an array of `bytes32`, delimited by `delim`.\n /// Reverts if the variable was not found or could not be parsed.\n function envBytes32(string calldata name, string calldata delim) external view returns (bytes32[] memory value);\n\n /// Gets the environment variable `name` and parses it as `bytes`.\n /// Reverts if the variable was not found or could not be parsed.\n function envBytes(string calldata name) external view returns (bytes memory value);\n\n /// Gets the environment variable `name` and parses it as an array of `bytes`, delimited by `delim`.\n /// Reverts if the variable was not found or could not be parsed.\n function envBytes(string calldata name, string calldata delim) external view returns (bytes[] memory value);\n\n /// Gets the environment variable `name` and returns true if it exists, else returns false.\n function envExists(string calldata name) external view returns (bool result);\n\n /// Gets the environment variable `name` and parses it as `int256`.\n /// Reverts if the variable was not found or could not be parsed.\n function envInt(string calldata name) external view returns (int256 value);\n\n /// Gets the environment variable `name` and parses it as an array of `int256`, delimited by `delim`.\n /// Reverts if the variable was not found or could not be parsed.\n function envInt(string calldata name, string calldata delim) external view returns (int256[] memory value);\n\n /// Gets the environment variable `name` and parses it as `bool`.\n /// Reverts if the variable could not be parsed.\n /// Returns `defaultValue` if the variable was not found.\n function envOr(string calldata name, bool defaultValue) external view returns (bool value);\n\n /// Gets the environment variable `name` and parses it as `uint256`.\n /// Reverts if the variable could not be parsed.\n /// Returns `defaultValue` if the variable was not found.\n function envOr(string calldata name, uint256 defaultValue) external view returns (uint256 value);\n\n /// Gets the environment variable `name` and parses it as an array of `address`, delimited by `delim`.\n /// Reverts if the variable could not be parsed.\n /// Returns `defaultValue` if the variable was not found.\n function envOr(string calldata name, string calldata delim, address[] calldata defaultValue)\n external\n view\n returns (address[] memory value);\n\n /// Gets the environment variable `name` and parses it as an array of `bytes32`, delimited by `delim`.\n /// Reverts if the variable could not be parsed.\n /// Returns `defaultValue` if the variable was not found.\n function envOr(string calldata name, string calldata delim, bytes32[] calldata defaultValue)\n external\n view\n returns (bytes32[] memory value);\n\n /// Gets the environment variable `name` and parses it as an array of `string`, delimited by `delim`.\n /// Reverts if the variable could not be parsed.\n /// Returns `defaultValue` if the variable was not found.\n function envOr(string calldata name, string calldata delim, string[] calldata defaultValue)\n external\n view\n returns (string[] memory value);\n\n /// Gets the environment variable `name` and parses it as an array of `bytes`, delimited by `delim`.\n /// Reverts if the variable could not be parsed.\n /// Returns `defaultValue` if the variable was not found.\n function envOr(string calldata name, string calldata delim, bytes[] calldata defaultValue)\n external\n view\n returns (bytes[] memory value);\n\n /// Gets the environment variable `name` and parses it as `int256`.\n /// Reverts if the variable could not be parsed.\n /// Returns `defaultValue` if the variable was not found.\n function envOr(string calldata name, int256 defaultValue) external view returns (int256 value);\n\n /// Gets the environment variable `name` and parses it as `address`.\n /// Reverts if the variable could not be parsed.\n /// Returns `defaultValue` if the variable was not found.\n function envOr(string calldata name, address defaultValue) external view returns (address value);\n\n /// Gets the environment variable `name` and parses it as `bytes32`.\n /// Reverts if the variable could not be parsed.\n /// Returns `defaultValue` if the variable was not found.\n function envOr(string calldata name, bytes32 defaultValue) external view returns (bytes32 value);\n\n /// Gets the environment variable `name` and parses it as `string`.\n /// Reverts if the variable could not be parsed.\n /// Returns `defaultValue` if the variable was not found.\n function envOr(string calldata name, string calldata defaultValue) external view returns (string memory value);\n\n /// Gets the environment variable `name` and parses it as `bytes`.\n /// Reverts if the variable could not be parsed.\n /// Returns `defaultValue` if the variable was not found.\n function envOr(string calldata name, bytes calldata defaultValue) external view returns (bytes memory value);\n\n /// Gets the environment variable `name` and parses it as an array of `bool`, delimited by `delim`.\n /// Reverts if the variable could not be parsed.\n /// Returns `defaultValue` if the variable was not found.\n function envOr(string calldata name, string calldata delim, bool[] calldata defaultValue)\n external\n view\n returns (bool[] memory value);\n\n /// Gets the environment variable `name` and parses it as an array of `uint256`, delimited by `delim`.\n /// Reverts if the variable could not be parsed.\n /// Returns `defaultValue` if the variable was not found.\n function envOr(string calldata name, string calldata delim, uint256[] calldata defaultValue)\n external\n view\n returns (uint256[] memory value);\n\n /// Gets the environment variable `name` and parses it as an array of `int256`, delimited by `delim`.\n /// Reverts if the variable could not be parsed.\n /// Returns `defaultValue` if the variable was not found.\n function envOr(string calldata name, string calldata delim, int256[] calldata defaultValue)\n external\n view\n returns (int256[] memory value);\n\n /// Gets the environment variable `name` and parses it as `string`.\n /// Reverts if the variable was not found or could not be parsed.\n function envString(string calldata name) external view returns (string memory value);\n\n /// Gets the environment variable `name` and parses it as an array of `string`, delimited by `delim`.\n /// Reverts if the variable was not found or could not be parsed.\n function envString(string calldata name, string calldata delim) external view returns (string[] memory value);\n\n /// Gets the environment variable `name` and parses it as `uint256`.\n /// Reverts if the variable was not found or could not be parsed.\n function envUint(string calldata name) external view returns (uint256 value);\n\n /// Gets the environment variable `name` and parses it as an array of `uint256`, delimited by `delim`.\n /// Reverts if the variable was not found or could not be parsed.\n function envUint(string calldata name, string calldata delim) external view returns (uint256[] memory value);\n\n /// Returns true if `forge` command was executed in given context.\n function isContext(ForgeContext context) external view returns (bool result);\n\n /// Sets environment variables.\n function setEnv(string calldata name, string calldata value) external;\n\n // ======== EVM ========\n\n /// Gets all accessed reads and write slot from a `vm.record` session, for a given address.\n function accesses(address target) external returns (bytes32[] memory readSlots, bytes32[] memory writeSlots);\n\n /// Gets the address for a given private key.\n function addr(uint256 privateKey) external pure returns (address keyAddr);\n\n /// Gets all the logs according to specified filter.\n function eth_getLogs(uint256 fromBlock, uint256 toBlock, address target, bytes32[] calldata topics)\n external\n returns (EthGetLogs[] memory logs);\n\n /// Gets the current `block.blobbasefee`.\n /// You should use this instead of `block.blobbasefee` if you use `vm.blobBaseFee`, as `block.blobbasefee` is assumed to be constant across a transaction,\n /// and as a result will get optimized out by the compiler.\n /// See https://github.com/foundry-rs/foundry/issues/6180\n function getBlobBaseFee() external view returns (uint256 blobBaseFee);\n\n /// Gets the current `block.number`.\n /// You should use this instead of `block.number` if you use `vm.roll`, as `block.number` is assumed to be constant across a transaction,\n /// and as a result will get optimized out by the compiler.\n /// See https://github.com/foundry-rs/foundry/issues/6180\n function getBlockNumber() external view returns (uint256 height);\n\n /// Gets the current `block.timestamp`.\n /// You should use this instead of `block.timestamp` if you use `vm.warp`, as `block.timestamp` is assumed to be constant across a transaction,\n /// and as a result will get optimized out by the compiler.\n /// See https://github.com/foundry-rs/foundry/issues/6180\n function getBlockTimestamp() external view returns (uint256 timestamp);\n\n /// Gets the map key and parent of a mapping at a given slot, for a given address.\n function getMappingKeyAndParentOf(address target, bytes32 elementSlot)\n external\n returns (bool found, bytes32 key, bytes32 parent);\n\n /// Gets the number of elements in the mapping at the given slot, for a given address.\n function getMappingLength(address target, bytes32 mappingSlot) external returns (uint256 length);\n\n /// Gets the elements at index idx of the mapping at the given slot, for a given address. The\n /// index must be less than the length of the mapping (i.e. the number of keys in the mapping).\n function getMappingSlotAt(address target, bytes32 mappingSlot, uint256 idx) external returns (bytes32 value);\n\n /// Gets the nonce of an account.\n function getNonce(address account) external view returns (uint64 nonce);\n\n /// Get the nonce of a `Wallet`.\n function getNonce(Wallet calldata wallet) external returns (uint64 nonce);\n\n /// Gets all the recorded logs.\n function getRecordedLogs() external returns (Log[] memory logs);\n\n /// Returns state diffs from current `vm.startStateDiffRecording` session.\n function getStateDiff() external view returns (string memory diff);\n\n /// Returns state diffs from current `vm.startStateDiffRecording` session, in json format.\n function getStateDiffJson() external view returns (string memory diff);\n\n /// Gets the gas used in the last call from the callee perspective.\n function lastCallGas() external view returns (Gas memory gas);\n\n /// Loads a storage slot from an address.\n function load(address target, bytes32 slot) external view returns (bytes32 data);\n\n /// Pauses gas metering (i.e. gas usage is not counted). Noop if already paused.\n function pauseGasMetering() external;\n\n /// Records all storage reads and writes.\n function record() external;\n\n /// Record all the transaction logs.\n function recordLogs() external;\n\n /// Reset gas metering (i.e. gas usage is set to gas limit).\n function resetGasMetering() external;\n\n /// Resumes gas metering (i.e. gas usage is counted again). Noop if already on.\n function resumeGasMetering() external;\n\n /// Performs an Ethereum JSON-RPC request to the current fork URL.\n function rpc(string calldata method, string calldata params) external returns (bytes memory data);\n\n /// Performs an Ethereum JSON-RPC request to the given endpoint.\n function rpc(string calldata urlOrAlias, string calldata method, string calldata params)\n external\n returns (bytes memory data);\n\n /// Records the debug trace during the run.\n function startDebugTraceRecording() external;\n\n /// Starts recording all map SSTOREs for later retrieval.\n function startMappingRecording() external;\n\n /// Record all account accesses as part of CREATE, CALL or SELFDESTRUCT opcodes in order,\n /// along with the context of the calls\n function startStateDiffRecording() external;\n\n /// Stop debug trace recording and returns the recorded debug trace.\n function stopAndReturnDebugTraceRecording() external returns (DebugStep[] memory step);\n\n /// Returns an ordered array of all account accesses from a `vm.startStateDiffRecording` session.\n function stopAndReturnStateDiff() external returns (AccountAccess[] memory accountAccesses);\n\n /// Stops recording all map SSTOREs for later retrieval and clears the recorded data.\n function stopMappingRecording() external;\n\n // ======== Filesystem ========\n\n /// Closes file for reading, resetting the offset and allowing to read it from beginning with readLine.\n /// `path` is relative to the project root.\n function closeFile(string calldata path) external;\n\n /// Copies the contents of one file to another. This function will **overwrite** the contents of `to`.\n /// On success, the total number of bytes copied is returned and it is equal to the length of the `to` file as reported by `metadata`.\n /// Both `from` and `to` are relative to the project root.\n function copyFile(string calldata from, string calldata to) external returns (uint64 copied);\n\n /// Creates a new, empty directory at the provided path.\n /// This cheatcode will revert in the following situations, but is not limited to just these cases:\n /// - User lacks permissions to modify `path`.\n /// - A parent of the given path doesn't exist and `recursive` is false.\n /// - `path` already exists and `recursive` is false.\n /// `path` is relative to the project root.\n function createDir(string calldata path, bool recursive) external;\n\n /// Deploys a contract from an artifact file. Takes in the relative path to the json file or the path to the\n /// artifact in the form of :: where and parts are optional.\n function deployCode(string calldata artifactPath) external returns (address deployedAddress);\n\n /// Deploys a contract from an artifact file. Takes in the relative path to the json file or the path to the\n /// artifact in the form of :: where and parts are optional.\n /// Additionally accepts abi-encoded constructor arguments.\n function deployCode(string calldata artifactPath, bytes calldata constructorArgs)\n external\n returns (address deployedAddress);\n\n /// Returns true if the given path points to an existing entity, else returns false.\n function exists(string calldata path) external view returns (bool result);\n\n /// Performs a foreign function call via the terminal.\n function ffi(string[] calldata commandInput) external returns (bytes memory result);\n\n /// Given a path, query the file system to get information about a file, directory, etc.\n function fsMetadata(string calldata path) external view returns (FsMetadata memory metadata);\n\n /// Gets the artifact path from code (aka. creation code).\n function getArtifactPathByCode(bytes calldata code) external view returns (string memory path);\n\n /// Gets the artifact path from deployed code (aka. runtime code).\n function getArtifactPathByDeployedCode(bytes calldata deployedCode) external view returns (string memory path);\n\n /// Returns the most recent broadcast for the given contract on `chainId` matching `txType`.\n /// For example:\n /// The most recent deployment can be fetched by passing `txType` as `CREATE` or `CREATE2`.\n /// The most recent call can be fetched by passing `txType` as `CALL`.\n function getBroadcast(string calldata contractName, uint64 chainId, BroadcastTxType txType)\n external\n view\n returns (BroadcastTxSummary memory);\n\n /// Returns all broadcasts for the given contract on `chainId` with the specified `txType`.\n /// Sorted such that the most recent broadcast is the first element, and the oldest is the last. i.e descending order of BroadcastTxSummary.blockNumber.\n function getBroadcasts(string calldata contractName, uint64 chainId, BroadcastTxType txType)\n external\n view\n returns (BroadcastTxSummary[] memory);\n\n /// Returns all broadcasts for the given contract on `chainId`.\n /// Sorted such that the most recent broadcast is the first element, and the oldest is the last. i.e descending order of BroadcastTxSummary.blockNumber.\n function getBroadcasts(string calldata contractName, uint64 chainId)\n external\n view\n returns (BroadcastTxSummary[] memory);\n\n /// Gets the creation bytecode from an artifact file. Takes in the relative path to the json file or the path to the\n /// artifact in the form of :: where and parts are optional.\n function getCode(string calldata artifactPath) external view returns (bytes memory creationBytecode);\n\n /// Gets the deployed bytecode from an artifact file. Takes in the relative path to the json file or the path to the\n /// artifact in the form of :: where and parts are optional.\n function getDeployedCode(string calldata artifactPath) external view returns (bytes memory runtimeBytecode);\n\n /// Returns the most recent deployment for the current `chainId`.\n function getDeployment(string calldata contractName) external view returns (address deployedAddress);\n\n /// Returns the most recent deployment for the given contract on `chainId`\n function getDeployment(string calldata contractName, uint64 chainId)\n external\n view\n returns (address deployedAddress);\n\n /// Returns all deployments for the given contract on `chainId`\n /// Sorted in descending order of deployment time i.e descending order of BroadcastTxSummary.blockNumber.\n /// The most recent deployment is the first element, and the oldest is the last.\n function getDeployments(string calldata contractName, uint64 chainId)\n external\n view\n returns (address[] memory deployedAddresses);\n\n /// Returns true if the path exists on disk and is pointing at a directory, else returns false.\n function isDir(string calldata path) external view returns (bool result);\n\n /// Returns true if the path exists on disk and is pointing at a regular file, else returns false.\n function isFile(string calldata path) external view returns (bool result);\n\n /// Get the path of the current project root.\n function projectRoot() external view returns (string memory path);\n\n /// Prompts the user for a string value in the terminal.\n function prompt(string calldata promptText) external returns (string memory input);\n\n /// Prompts the user for an address in the terminal.\n function promptAddress(string calldata promptText) external returns (address);\n\n /// Prompts the user for a hidden string value in the terminal.\n function promptSecret(string calldata promptText) external returns (string memory input);\n\n /// Prompts the user for hidden uint256 in the terminal (usually pk).\n function promptSecretUint(string calldata promptText) external returns (uint256);\n\n /// Prompts the user for uint256 in the terminal.\n function promptUint(string calldata promptText) external returns (uint256);\n\n /// Reads the directory at the given path recursively, up to `maxDepth`.\n /// `maxDepth` defaults to 1, meaning only the direct children of the given directory will be returned.\n /// Follows symbolic links if `followLinks` is true.\n function readDir(string calldata path) external view returns (DirEntry[] memory entries);\n\n /// See `readDir(string)`.\n function readDir(string calldata path, uint64 maxDepth) external view returns (DirEntry[] memory entries);\n\n /// See `readDir(string)`.\n function readDir(string calldata path, uint64 maxDepth, bool followLinks)\n external\n view\n returns (DirEntry[] memory entries);\n\n /// Reads the entire content of file to string. `path` is relative to the project root.\n function readFile(string calldata path) external view returns (string memory data);\n\n /// Reads the entire content of file as binary. `path` is relative to the project root.\n function readFileBinary(string calldata path) external view returns (bytes memory data);\n\n /// Reads next line of file to string.\n function readLine(string calldata path) external view returns (string memory line);\n\n /// Reads a symbolic link, returning the path that the link points to.\n /// This cheatcode will revert in the following situations, but is not limited to just these cases:\n /// - `path` is not a symbolic link.\n /// - `path` does not exist.\n function readLink(string calldata linkPath) external view returns (string memory targetPath);\n\n /// Removes a directory at the provided path.\n /// This cheatcode will revert in the following situations, but is not limited to just these cases:\n /// - `path` doesn't exist.\n /// - `path` isn't a directory.\n /// - User lacks permissions to modify `path`.\n /// - The directory is not empty and `recursive` is false.\n /// `path` is relative to the project root.\n function removeDir(string calldata path, bool recursive) external;\n\n /// Removes a file from the filesystem.\n /// This cheatcode will revert in the following situations, but is not limited to just these cases:\n /// - `path` points to a directory.\n /// - The file doesn't exist.\n /// - The user lacks permissions to remove the file.\n /// `path` is relative to the project root.\n function removeFile(string calldata path) external;\n\n /// Performs a foreign function call via terminal and returns the exit code, stdout, and stderr.\n function tryFfi(string[] calldata commandInput) external returns (FfiResult memory result);\n\n /// Returns the time since unix epoch in milliseconds.\n function unixTime() external view returns (uint256 milliseconds);\n\n /// Writes data to file, creating a file if it does not exist, and entirely replacing its contents if it does.\n /// `path` is relative to the project root.\n function writeFile(string calldata path, string calldata data) external;\n\n /// Writes binary data to a file, creating a file if it does not exist, and entirely replacing its contents if it does.\n /// `path` is relative to the project root.\n function writeFileBinary(string calldata path, bytes calldata data) external;\n\n /// Writes line to file, creating a file if it does not exist.\n /// `path` is relative to the project root.\n function writeLine(string calldata path, string calldata data) external;\n\n // ======== JSON ========\n\n /// Checks if `key` exists in a JSON object.\n function keyExistsJson(string calldata json, string calldata key) external view returns (bool);\n\n /// Parses a string of JSON data at `key` and coerces it to `address`.\n function parseJsonAddress(string calldata json, string calldata key) external pure returns (address);\n\n /// Parses a string of JSON data at `key` and coerces it to `address[]`.\n function parseJsonAddressArray(string calldata json, string calldata key)\n external\n pure\n returns (address[] memory);\n\n /// Parses a string of JSON data at `key` and coerces it to `bool`.\n function parseJsonBool(string calldata json, string calldata key) external pure returns (bool);\n\n /// Parses a string of JSON data at `key` and coerces it to `bool[]`.\n function parseJsonBoolArray(string calldata json, string calldata key) external pure returns (bool[] memory);\n\n /// Parses a string of JSON data at `key` and coerces it to `bytes`.\n function parseJsonBytes(string calldata json, string calldata key) external pure returns (bytes memory);\n\n /// Parses a string of JSON data at `key` and coerces it to `bytes32`.\n function parseJsonBytes32(string calldata json, string calldata key) external pure returns (bytes32);\n\n /// Parses a string of JSON data at `key` and coerces it to `bytes32[]`.\n function parseJsonBytes32Array(string calldata json, string calldata key)\n external\n pure\n returns (bytes32[] memory);\n\n /// Parses a string of JSON data at `key` and coerces it to `bytes[]`.\n function parseJsonBytesArray(string calldata json, string calldata key) external pure returns (bytes[] memory);\n\n /// Parses a string of JSON data at `key` and coerces it to `int256`.\n function parseJsonInt(string calldata json, string calldata key) external pure returns (int256);\n\n /// Parses a string of JSON data at `key` and coerces it to `int256[]`.\n function parseJsonIntArray(string calldata json, string calldata key) external pure returns (int256[] memory);\n\n /// Returns an array of all the keys in a JSON object.\n function parseJsonKeys(string calldata json, string calldata key) external pure returns (string[] memory keys);\n\n /// Parses a string of JSON data at `key` and coerces it to `string`.\n function parseJsonString(string calldata json, string calldata key) external pure returns (string memory);\n\n /// Parses a string of JSON data at `key` and coerces it to `string[]`.\n function parseJsonStringArray(string calldata json, string calldata key) external pure returns (string[] memory);\n\n /// Parses a string of JSON data at `key` and coerces it to type array corresponding to `typeDescription`.\n function parseJsonTypeArray(string calldata json, string calldata key, string calldata typeDescription)\n external\n pure\n returns (bytes memory);\n\n /// Parses a string of JSON data and coerces it to type corresponding to `typeDescription`.\n function parseJsonType(string calldata json, string calldata typeDescription)\n external\n pure\n returns (bytes memory);\n\n /// Parses a string of JSON data at `key` and coerces it to type corresponding to `typeDescription`.\n function parseJsonType(string calldata json, string calldata key, string calldata typeDescription)\n external\n pure\n returns (bytes memory);\n\n /// Parses a string of JSON data at `key` and coerces it to `uint256`.\n function parseJsonUint(string calldata json, string calldata key) external pure returns (uint256);\n\n /// Parses a string of JSON data at `key` and coerces it to `uint256[]`.\n function parseJsonUintArray(string calldata json, string calldata key) external pure returns (uint256[] memory);\n\n /// ABI-encodes a JSON object.\n function parseJson(string calldata json) external pure returns (bytes memory abiEncodedData);\n\n /// ABI-encodes a JSON object at `key`.\n function parseJson(string calldata json, string calldata key) external pure returns (bytes memory abiEncodedData);\n\n /// See `serializeJson`.\n function serializeAddress(string calldata objectKey, string calldata valueKey, address value)\n external\n returns (string memory json);\n\n /// See `serializeJson`.\n function serializeAddress(string calldata objectKey, string calldata valueKey, address[] calldata values)\n external\n returns (string memory json);\n\n /// See `serializeJson`.\n function serializeBool(string calldata objectKey, string calldata valueKey, bool value)\n external\n returns (string memory json);\n\n /// See `serializeJson`.\n function serializeBool(string calldata objectKey, string calldata valueKey, bool[] calldata values)\n external\n returns (string memory json);\n\n /// See `serializeJson`.\n function serializeBytes32(string calldata objectKey, string calldata valueKey, bytes32 value)\n external\n returns (string memory json);\n\n /// See `serializeJson`.\n function serializeBytes32(string calldata objectKey, string calldata valueKey, bytes32[] calldata values)\n external\n returns (string memory json);\n\n /// See `serializeJson`.\n function serializeBytes(string calldata objectKey, string calldata valueKey, bytes calldata value)\n external\n returns (string memory json);\n\n /// See `serializeJson`.\n function serializeBytes(string calldata objectKey, string calldata valueKey, bytes[] calldata values)\n external\n returns (string memory json);\n\n /// See `serializeJson`.\n function serializeInt(string calldata objectKey, string calldata valueKey, int256 value)\n external\n returns (string memory json);\n\n /// See `serializeJson`.\n function serializeInt(string calldata objectKey, string calldata valueKey, int256[] calldata values)\n external\n returns (string memory json);\n\n /// Serializes a key and value to a JSON object stored in-memory that can be later written to a file.\n /// Returns the stringified version of the specific JSON file up to that moment.\n function serializeJson(string calldata objectKey, string calldata value) external returns (string memory json);\n\n /// See `serializeJson`.\n function serializeJsonType(string calldata typeDescription, bytes calldata value)\n external\n pure\n returns (string memory json);\n\n /// See `serializeJson`.\n function serializeJsonType(\n string calldata objectKey,\n string calldata valueKey,\n string calldata typeDescription,\n bytes calldata value\n ) external returns (string memory json);\n\n /// See `serializeJson`.\n function serializeString(string calldata objectKey, string calldata valueKey, string calldata value)\n external\n returns (string memory json);\n\n /// See `serializeJson`.\n function serializeString(string calldata objectKey, string calldata valueKey, string[] calldata values)\n external\n returns (string memory json);\n\n /// See `serializeJson`.\n function serializeUintToHex(string calldata objectKey, string calldata valueKey, uint256 value)\n external\n returns (string memory json);\n\n /// See `serializeJson`.\n function serializeUint(string calldata objectKey, string calldata valueKey, uint256 value)\n external\n returns (string memory json);\n\n /// See `serializeJson`.\n function serializeUint(string calldata objectKey, string calldata valueKey, uint256[] calldata values)\n external\n returns (string memory json);\n\n /// Write a serialized JSON object to a file. If the file exists, it will be overwritten.\n function writeJson(string calldata json, string calldata path) external;\n\n /// Write a serialized JSON object to an **existing** JSON file, replacing a value with key = \n /// This is useful to replace a specific value of a JSON file, without having to parse the entire thing.\n function writeJson(string calldata json, string calldata path, string calldata valueKey) external;\n\n /// Checks if `key` exists in a JSON object\n /// `keyExists` is being deprecated in favor of `keyExistsJson`. It will be removed in future versions.\n function keyExists(string calldata json, string calldata key) external view returns (bool);\n\n // ======== Scripting ========\n\n /// Designate the next call as an EIP-7702 transaction\n function attachDelegation(SignedDelegation calldata signedDelegation) external;\n\n /// Takes a signed transaction and broadcasts it to the network.\n function broadcastRawTransaction(bytes calldata data) external;\n\n /// Has the next call (at this call depth only) create transactions that can later be signed and sent onchain.\n /// Broadcasting address is determined by checking the following in order:\n /// 1. If `--sender` argument was provided, that address is used.\n /// 2. If exactly one signer (e.g. private key, hw wallet, keystore) is set when `forge broadcast` is invoked, that signer is used.\n /// 3. Otherwise, default foundry sender (1804c8AB1F12E6bbf3894d4083f33e07309d1f38) is used.\n function broadcast() external;\n\n /// Has the next call (at this call depth only) create a transaction with the address provided\n /// as the sender that can later be signed and sent onchain.\n function broadcast(address signer) external;\n\n /// Has the next call (at this call depth only) create a transaction with the private key\n /// provided as the sender that can later be signed and sent onchain.\n function broadcast(uint256 privateKey) external;\n\n /// Returns addresses of available unlocked wallets in the script environment.\n function getWallets() external returns (address[] memory wallets);\n\n /// Sign an EIP-7702 authorization and designate the next call as an EIP-7702 transaction\n function signAndAttachDelegation(address implementation, uint256 privateKey)\n external\n returns (SignedDelegation memory signedDelegation);\n\n /// Sign an EIP-7702 authorization for delegation\n function signDelegation(address implementation, uint256 privateKey)\n external\n returns (SignedDelegation memory signedDelegation);\n\n /// Has all subsequent calls (at this call depth only) create transactions that can later be signed and sent onchain.\n /// Broadcasting address is determined by checking the following in order:\n /// 1. If `--sender` argument was provided, that address is used.\n /// 2. If exactly one signer (e.g. private key, hw wallet, keystore) is set when `forge broadcast` is invoked, that signer is used.\n /// 3. Otherwise, default foundry sender (1804c8AB1F12E6bbf3894d4083f33e07309d1f38) is used.\n function startBroadcast() external;\n\n /// Has all subsequent calls (at this call depth only) create transactions with the address\n /// provided that can later be signed and sent onchain.\n function startBroadcast(address signer) external;\n\n /// Has all subsequent calls (at this call depth only) create transactions with the private key\n /// provided that can later be signed and sent onchain.\n function startBroadcast(uint256 privateKey) external;\n\n /// Stops collecting onchain transactions.\n function stopBroadcast() external;\n\n // ======== String ========\n\n /// Returns true if `search` is found in `subject`, false otherwise.\n function contains(string calldata subject, string calldata search) external returns (bool result);\n\n /// Returns the index of the first occurrence of a `key` in an `input` string.\n /// Returns `NOT_FOUND` (i.e. `type(uint256).max`) if the `key` is not found.\n /// Returns 0 in case of an empty `key`.\n function indexOf(string calldata input, string calldata key) external pure returns (uint256);\n\n /// Parses the given `string` into an `address`.\n function parseAddress(string calldata stringifiedValue) external pure returns (address parsedValue);\n\n /// Parses the given `string` into a `bool`.\n function parseBool(string calldata stringifiedValue) external pure returns (bool parsedValue);\n\n /// Parses the given `string` into `bytes`.\n function parseBytes(string calldata stringifiedValue) external pure returns (bytes memory parsedValue);\n\n /// Parses the given `string` into a `bytes32`.\n function parseBytes32(string calldata stringifiedValue) external pure returns (bytes32 parsedValue);\n\n /// Parses the given `string` into a `int256`.\n function parseInt(string calldata stringifiedValue) external pure returns (int256 parsedValue);\n\n /// Parses the given `string` into a `uint256`.\n function parseUint(string calldata stringifiedValue) external pure returns (uint256 parsedValue);\n\n /// Replaces occurrences of `from` in the given `string` with `to`.\n function replace(string calldata input, string calldata from, string calldata to)\n external\n pure\n returns (string memory output);\n\n /// Splits the given `string` into an array of strings divided by the `delimiter`.\n function split(string calldata input, string calldata delimiter) external pure returns (string[] memory outputs);\n\n /// Converts the given `string` value to Lowercase.\n function toLowercase(string calldata input) external pure returns (string memory output);\n\n /// Converts the given value to a `string`.\n function toString(address value) external pure returns (string memory stringifiedValue);\n\n /// Converts the given value to a `string`.\n function toString(bytes calldata value) external pure returns (string memory stringifiedValue);\n\n /// Converts the given value to a `string`.\n function toString(bytes32 value) external pure returns (string memory stringifiedValue);\n\n /// Converts the given value to a `string`.\n function toString(bool value) external pure returns (string memory stringifiedValue);\n\n /// Converts the given value to a `string`.\n function toString(uint256 value) external pure returns (string memory stringifiedValue);\n\n /// Converts the given value to a `string`.\n function toString(int256 value) external pure returns (string memory stringifiedValue);\n\n /// Converts the given `string` value to Uppercase.\n function toUppercase(string calldata input) external pure returns (string memory output);\n\n /// Trims leading and trailing whitespace from the given `string` value.\n function trim(string calldata input) external pure returns (string memory output);\n\n // ======== Testing ========\n\n /// Compares two `uint256` values. Expects difference to be less than or equal to `maxDelta`.\n /// Formats values with decimals in failure message.\n function assertApproxEqAbsDecimal(uint256 left, uint256 right, uint256 maxDelta, uint256 decimals) external pure;\n\n /// Compares two `uint256` values. Expects difference to be less than or equal to `maxDelta`.\n /// Formats values with decimals in failure message. Includes error message into revert string on failure.\n function assertApproxEqAbsDecimal(\n uint256 left,\n uint256 right,\n uint256 maxDelta,\n uint256 decimals,\n string calldata error\n ) external pure;\n\n /// Compares two `int256` values. Expects difference to be less than or equal to `maxDelta`.\n /// Formats values with decimals in failure message.\n function assertApproxEqAbsDecimal(int256 left, int256 right, uint256 maxDelta, uint256 decimals) external pure;\n\n /// Compares two `int256` values. Expects difference to be less than or equal to `maxDelta`.\n /// Formats values with decimals in failure message. Includes error message into revert string on failure.\n function assertApproxEqAbsDecimal(\n int256 left,\n int256 right,\n uint256 maxDelta,\n uint256 decimals,\n string calldata error\n ) external pure;\n\n /// Compares two `uint256` values. Expects difference to be less than or equal to `maxDelta`.\n function assertApproxEqAbs(uint256 left, uint256 right, uint256 maxDelta) external pure;\n\n /// Compares two `uint256` values. Expects difference to be less than or equal to `maxDelta`.\n /// Includes error message into revert string on failure.\n function assertApproxEqAbs(uint256 left, uint256 right, uint256 maxDelta, string calldata error) external pure;\n\n /// Compares two `int256` values. Expects difference to be less than or equal to `maxDelta`.\n function assertApproxEqAbs(int256 left, int256 right, uint256 maxDelta) external pure;\n\n /// Compares two `int256` values. Expects difference to be less than or equal to `maxDelta`.\n /// Includes error message into revert string on failure.\n function assertApproxEqAbs(int256 left, int256 right, uint256 maxDelta, string calldata error) external pure;\n\n /// Compares two `uint256` values. Expects relative difference in percents to be less than or equal to `maxPercentDelta`.\n /// `maxPercentDelta` is an 18 decimal fixed point number, where 1e18 == 100%\n /// Formats values with decimals in failure message.\n function assertApproxEqRelDecimal(uint256 left, uint256 right, uint256 maxPercentDelta, uint256 decimals)\n external\n pure;\n\n /// Compares two `uint256` values. Expects relative difference in percents to be less than or equal to `maxPercentDelta`.\n /// `maxPercentDelta` is an 18 decimal fixed point number, where 1e18 == 100%\n /// Formats values with decimals in failure message. Includes error message into revert string on failure.\n function assertApproxEqRelDecimal(\n uint256 left,\n uint256 right,\n uint256 maxPercentDelta,\n uint256 decimals,\n string calldata error\n ) external pure;\n\n /// Compares two `int256` values. Expects relative difference in percents to be less than or equal to `maxPercentDelta`.\n /// `maxPercentDelta` is an 18 decimal fixed point number, where 1e18 == 100%\n /// Formats values with decimals in failure message.\n function assertApproxEqRelDecimal(int256 left, int256 right, uint256 maxPercentDelta, uint256 decimals)\n external\n pure;\n\n /// Compares two `int256` values. Expects relative difference in percents to be less than or equal to `maxPercentDelta`.\n /// `maxPercentDelta` is an 18 decimal fixed point number, where 1e18 == 100%\n /// Formats values with decimals in failure message. Includes error message into revert string on failure.\n function assertApproxEqRelDecimal(\n int256 left,\n int256 right,\n uint256 maxPercentDelta,\n uint256 decimals,\n string calldata error\n ) external pure;\n\n /// Compares two `uint256` values. Expects relative difference in percents to be less than or equal to `maxPercentDelta`.\n /// `maxPercentDelta` is an 18 decimal fixed point number, where 1e18 == 100%\n function assertApproxEqRel(uint256 left, uint256 right, uint256 maxPercentDelta) external pure;\n\n /// Compares two `uint256` values. Expects relative difference in percents to be less than or equal to `maxPercentDelta`.\n /// `maxPercentDelta` is an 18 decimal fixed point number, where 1e18 == 100%\n /// Includes error message into revert string on failure.\n function assertApproxEqRel(uint256 left, uint256 right, uint256 maxPercentDelta, string calldata error)\n external\n pure;\n\n /// Compares two `int256` values. Expects relative difference in percents to be less than or equal to `maxPercentDelta`.\n /// `maxPercentDelta` is an 18 decimal fixed point number, where 1e18 == 100%\n function assertApproxEqRel(int256 left, int256 right, uint256 maxPercentDelta) external pure;\n\n /// Compares two `int256` values. Expects relative difference in percents to be less than or equal to `maxPercentDelta`.\n /// `maxPercentDelta` is an 18 decimal fixed point number, where 1e18 == 100%\n /// Includes error message into revert string on failure.\n function assertApproxEqRel(int256 left, int256 right, uint256 maxPercentDelta, string calldata error)\n external\n pure;\n\n /// Asserts that two `uint256` values are equal, formatting them with decimals in failure message.\n function assertEqDecimal(uint256 left, uint256 right, uint256 decimals) external pure;\n\n /// Asserts that two `uint256` values are equal, formatting them with decimals in failure message.\n /// Includes error message into revert string on failure.\n function assertEqDecimal(uint256 left, uint256 right, uint256 decimals, string calldata error) external pure;\n\n /// Asserts that two `int256` values are equal, formatting them with decimals in failure message.\n function assertEqDecimal(int256 left, int256 right, uint256 decimals) external pure;\n\n /// Asserts that two `int256` values are equal, formatting them with decimals in failure message.\n /// Includes error message into revert string on failure.\n function assertEqDecimal(int256 left, int256 right, uint256 decimals, string calldata error) external pure;\n\n /// Asserts that two `bool` values are equal.\n function assertEq(bool left, bool right) external pure;\n\n /// Asserts that two `bool` values are equal and includes error message into revert string on failure.\n function assertEq(bool left, bool right, string calldata error) external pure;\n\n /// Asserts that two `string` values are equal.\n function assertEq(string calldata left, string calldata right) external pure;\n\n /// Asserts that two `string` values are equal and includes error message into revert string on failure.\n function assertEq(string calldata left, string calldata right, string calldata error) external pure;\n\n /// Asserts that two `bytes` values are equal.\n function assertEq(bytes calldata left, bytes calldata right) external pure;\n\n /// Asserts that two `bytes` values are equal and includes error message into revert string on failure.\n function assertEq(bytes calldata left, bytes calldata right, string calldata error) external pure;\n\n /// Asserts that two arrays of `bool` values are equal.\n function assertEq(bool[] calldata left, bool[] calldata right) external pure;\n\n /// Asserts that two arrays of `bool` values are equal and includes error message into revert string on failure.\n function assertEq(bool[] calldata left, bool[] calldata right, string calldata error) external pure;\n\n /// Asserts that two arrays of `uint256 values are equal.\n function assertEq(uint256[] calldata left, uint256[] calldata right) external pure;\n\n /// Asserts that two arrays of `uint256` values are equal and includes error message into revert string on failure.\n function assertEq(uint256[] calldata left, uint256[] calldata right, string calldata error) external pure;\n\n /// Asserts that two arrays of `int256` values are equal.\n function assertEq(int256[] calldata left, int256[] calldata right) external pure;\n\n /// Asserts that two arrays of `int256` values are equal and includes error message into revert string on failure.\n function assertEq(int256[] calldata left, int256[] calldata right, string calldata error) external pure;\n\n /// Asserts that two `uint256` values are equal.\n function assertEq(uint256 left, uint256 right) external pure;\n\n /// Asserts that two arrays of `address` values are equal.\n function assertEq(address[] calldata left, address[] calldata right) external pure;\n\n /// Asserts that two arrays of `address` values are equal and includes error message into revert string on failure.\n function assertEq(address[] calldata left, address[] calldata right, string calldata error) external pure;\n\n /// Asserts that two arrays of `bytes32` values are equal.\n function assertEq(bytes32[] calldata left, bytes32[] calldata right) external pure;\n\n /// Asserts that two arrays of `bytes32` values are equal and includes error message into revert string on failure.\n function assertEq(bytes32[] calldata left, bytes32[] calldata right, string calldata error) external pure;\n\n /// Asserts that two arrays of `string` values are equal.\n function assertEq(string[] calldata left, string[] calldata right) external pure;\n\n /// Asserts that two arrays of `string` values are equal and includes error message into revert string on failure.\n function assertEq(string[] calldata left, string[] calldata right, string calldata error) external pure;\n\n /// Asserts that two arrays of `bytes` values are equal.\n function assertEq(bytes[] calldata left, bytes[] calldata right) external pure;\n\n /// Asserts that two arrays of `bytes` values are equal and includes error message into revert string on failure.\n function assertEq(bytes[] calldata left, bytes[] calldata right, string calldata error) external pure;\n\n /// Asserts that two `uint256` values are equal and includes error message into revert string on failure.\n function assertEq(uint256 left, uint256 right, string calldata error) external pure;\n\n /// Asserts that two `int256` values are equal.\n function assertEq(int256 left, int256 right) external pure;\n\n /// Asserts that two `int256` values are equal and includes error message into revert string on failure.\n function assertEq(int256 left, int256 right, string calldata error) external pure;\n\n /// Asserts that two `address` values are equal.\n function assertEq(address left, address right) external pure;\n\n /// Asserts that two `address` values are equal and includes error message into revert string on failure.\n function assertEq(address left, address right, string calldata error) external pure;\n\n /// Asserts that two `bytes32` values are equal.\n function assertEq(bytes32 left, bytes32 right) external pure;\n\n /// Asserts that two `bytes32` values are equal and includes error message into revert string on failure.\n function assertEq(bytes32 left, bytes32 right, string calldata error) external pure;\n\n /// Asserts that the given condition is false.\n function assertFalse(bool condition) external pure;\n\n /// Asserts that the given condition is false and includes error message into revert string on failure.\n function assertFalse(bool condition, string calldata error) external pure;\n\n /// Compares two `uint256` values. Expects first value to be greater than or equal to second.\n /// Formats values with decimals in failure message.\n function assertGeDecimal(uint256 left, uint256 right, uint256 decimals) external pure;\n\n /// Compares two `uint256` values. Expects first value to be greater than or equal to second.\n /// Formats values with decimals in failure message. Includes error message into revert string on failure.\n function assertGeDecimal(uint256 left, uint256 right, uint256 decimals, string calldata error) external pure;\n\n /// Compares two `int256` values. Expects first value to be greater than or equal to second.\n /// Formats values with decimals in failure message.\n function assertGeDecimal(int256 left, int256 right, uint256 decimals) external pure;\n\n /// Compares two `int256` values. Expects first value to be greater than or equal to second.\n /// Formats values with decimals in failure message. Includes error message into revert string on failure.\n function assertGeDecimal(int256 left, int256 right, uint256 decimals, string calldata error) external pure;\n\n /// Compares two `uint256` values. Expects first value to be greater than or equal to second.\n function assertGe(uint256 left, uint256 right) external pure;\n\n /// Compares two `uint256` values. Expects first value to be greater than or equal to second.\n /// Includes error message into revert string on failure.\n function assertGe(uint256 left, uint256 right, string calldata error) external pure;\n\n /// Compares two `int256` values. Expects first value to be greater than or equal to second.\n function assertGe(int256 left, int256 right) external pure;\n\n /// Compares two `int256` values. Expects first value to be greater than or equal to second.\n /// Includes error message into revert string on failure.\n function assertGe(int256 left, int256 right, string calldata error) external pure;\n\n /// Compares two `uint256` values. Expects first value to be greater than second.\n /// Formats values with decimals in failure message.\n function assertGtDecimal(uint256 left, uint256 right, uint256 decimals) external pure;\n\n /// Compares two `uint256` values. Expects first value to be greater than second.\n /// Formats values with decimals in failure message. Includes error message into revert string on failure.\n function assertGtDecimal(uint256 left, uint256 right, uint256 decimals, string calldata error) external pure;\n\n /// Compares two `int256` values. Expects first value to be greater than second.\n /// Formats values with decimals in failure message.\n function assertGtDecimal(int256 left, int256 right, uint256 decimals) external pure;\n\n /// Compares two `int256` values. Expects first value to be greater than second.\n /// Formats values with decimals in failure message. Includes error message into revert string on failure.\n function assertGtDecimal(int256 left, int256 right, uint256 decimals, string calldata error) external pure;\n\n /// Compares two `uint256` values. Expects first value to be greater than second.\n function assertGt(uint256 left, uint256 right) external pure;\n\n /// Compares two `uint256` values. Expects first value to be greater than second.\n /// Includes error message into revert string on failure.\n function assertGt(uint256 left, uint256 right, string calldata error) external pure;\n\n /// Compares two `int256` values. Expects first value to be greater than second.\n function assertGt(int256 left, int256 right) external pure;\n\n /// Compares two `int256` values. Expects first value to be greater than second.\n /// Includes error message into revert string on failure.\n function assertGt(int256 left, int256 right, string calldata error) external pure;\n\n /// Compares two `uint256` values. Expects first value to be less than or equal to second.\n /// Formats values with decimals in failure message.\n function assertLeDecimal(uint256 left, uint256 right, uint256 decimals) external pure;\n\n /// Compares two `uint256` values. Expects first value to be less than or equal to second.\n /// Formats values with decimals in failure message. Includes error message into revert string on failure.\n function assertLeDecimal(uint256 left, uint256 right, uint256 decimals, string calldata error) external pure;\n\n /// Compares two `int256` values. Expects first value to be less than or equal to second.\n /// Formats values with decimals in failure message.\n function assertLeDecimal(int256 left, int256 right, uint256 decimals) external pure;\n\n /// Compares two `int256` values. Expects first value to be less than or equal to second.\n /// Formats values with decimals in failure message. Includes error message into revert string on failure.\n function assertLeDecimal(int256 left, int256 right, uint256 decimals, string calldata error) external pure;\n\n /// Compares two `uint256` values. Expects first value to be less than or equal to second.\n function assertLe(uint256 left, uint256 right) external pure;\n\n /// Compares two `uint256` values. Expects first value to be less than or equal to second.\n /// Includes error message into revert string on failure.\n function assertLe(uint256 left, uint256 right, string calldata error) external pure;\n\n /// Compares two `int256` values. Expects first value to be less than or equal to second.\n function assertLe(int256 left, int256 right) external pure;\n\n /// Compares two `int256` values. Expects first value to be less than or equal to second.\n /// Includes error message into revert string on failure.\n function assertLe(int256 left, int256 right, string calldata error) external pure;\n\n /// Compares two `uint256` values. Expects first value to be less than second.\n /// Formats values with decimals in failure message.\n function assertLtDecimal(uint256 left, uint256 right, uint256 decimals) external pure;\n\n /// Compares two `uint256` values. Expects first value to be less than second.\n /// Formats values with decimals in failure message. Includes error message into revert string on failure.\n function assertLtDecimal(uint256 left, uint256 right, uint256 decimals, string calldata error) external pure;\n\n /// Compares two `int256` values. Expects first value to be less than second.\n /// Formats values with decimals in failure message.\n function assertLtDecimal(int256 left, int256 right, uint256 decimals) external pure;\n\n /// Compares two `int256` values. Expects first value to be less than second.\n /// Formats values with decimals in failure message. Includes error message into revert string on failure.\n function assertLtDecimal(int256 left, int256 right, uint256 decimals, string calldata error) external pure;\n\n /// Compares two `uint256` values. Expects first value to be less than second.\n function assertLt(uint256 left, uint256 right) external pure;\n\n /// Compares two `uint256` values. Expects first value to be less than second.\n /// Includes error message into revert string on failure.\n function assertLt(uint256 left, uint256 right, string calldata error) external pure;\n\n /// Compares two `int256` values. Expects first value to be less than second.\n function assertLt(int256 left, int256 right) external pure;\n\n /// Compares two `int256` values. Expects first value to be less than second.\n /// Includes error message into revert string on failure.\n function assertLt(int256 left, int256 right, string calldata error) external pure;\n\n /// Asserts that two `uint256` values are not equal, formatting them with decimals in failure message.\n function assertNotEqDecimal(uint256 left, uint256 right, uint256 decimals) external pure;\n\n /// Asserts that two `uint256` values are not equal, formatting them with decimals in failure message.\n /// Includes error message into revert string on failure.\n function assertNotEqDecimal(uint256 left, uint256 right, uint256 decimals, string calldata error) external pure;\n\n /// Asserts that two `int256` values are not equal, formatting them with decimals in failure message.\n function assertNotEqDecimal(int256 left, int256 right, uint256 decimals) external pure;\n\n /// Asserts that two `int256` values are not equal, formatting them with decimals in failure message.\n /// Includes error message into revert string on failure.\n function assertNotEqDecimal(int256 left, int256 right, uint256 decimals, string calldata error) external pure;\n\n /// Asserts that two `bool` values are not equal.\n function assertNotEq(bool left, bool right) external pure;\n\n /// Asserts that two `bool` values are not equal and includes error message into revert string on failure.\n function assertNotEq(bool left, bool right, string calldata error) external pure;\n\n /// Asserts that two `string` values are not equal.\n function assertNotEq(string calldata left, string calldata right) external pure;\n\n /// Asserts that two `string` values are not equal and includes error message into revert string on failure.\n function assertNotEq(string calldata left, string calldata right, string calldata error) external pure;\n\n /// Asserts that two `bytes` values are not equal.\n function assertNotEq(bytes calldata left, bytes calldata right) external pure;\n\n /// Asserts that two `bytes` values are not equal and includes error message into revert string on failure.\n function assertNotEq(bytes calldata left, bytes calldata right, string calldata error) external pure;\n\n /// Asserts that two arrays of `bool` values are not equal.\n function assertNotEq(bool[] calldata left, bool[] calldata right) external pure;\n\n /// Asserts that two arrays of `bool` values are not equal and includes error message into revert string on failure.\n function assertNotEq(bool[] calldata left, bool[] calldata right, string calldata error) external pure;\n\n /// Asserts that two arrays of `uint256` values are not equal.\n function assertNotEq(uint256[] calldata left, uint256[] calldata right) external pure;\n\n /// Asserts that two arrays of `uint256` values are not equal and includes error message into revert string on failure.\n function assertNotEq(uint256[] calldata left, uint256[] calldata right, string calldata error) external pure;\n\n /// Asserts that two arrays of `int256` values are not equal.\n function assertNotEq(int256[] calldata left, int256[] calldata right) external pure;\n\n /// Asserts that two arrays of `int256` values are not equal and includes error message into revert string on failure.\n function assertNotEq(int256[] calldata left, int256[] calldata right, string calldata error) external pure;\n\n /// Asserts that two `uint256` values are not equal.\n function assertNotEq(uint256 left, uint256 right) external pure;\n\n /// Asserts that two arrays of `address` values are not equal.\n function assertNotEq(address[] calldata left, address[] calldata right) external pure;\n\n /// Asserts that two arrays of `address` values are not equal and includes error message into revert string on failure.\n function assertNotEq(address[] calldata left, address[] calldata right, string calldata error) external pure;\n\n /// Asserts that two arrays of `bytes32` values are not equal.\n function assertNotEq(bytes32[] calldata left, bytes32[] calldata right) external pure;\n\n /// Asserts that two arrays of `bytes32` values are not equal and includes error message into revert string on failure.\n function assertNotEq(bytes32[] calldata left, bytes32[] calldata right, string calldata error) external pure;\n\n /// Asserts that two arrays of `string` values are not equal.\n function assertNotEq(string[] calldata left, string[] calldata right) external pure;\n\n /// Asserts that two arrays of `string` values are not equal and includes error message into revert string on failure.\n function assertNotEq(string[] calldata left, string[] calldata right, string calldata error) external pure;\n\n /// Asserts that two arrays of `bytes` values are not equal.\n function assertNotEq(bytes[] calldata left, bytes[] calldata right) external pure;\n\n /// Asserts that two arrays of `bytes` values are not equal and includes error message into revert string on failure.\n function assertNotEq(bytes[] calldata left, bytes[] calldata right, string calldata error) external pure;\n\n /// Asserts that two `uint256` values are not equal and includes error message into revert string on failure.\n function assertNotEq(uint256 left, uint256 right, string calldata error) external pure;\n\n /// Asserts that two `int256` values are not equal.\n function assertNotEq(int256 left, int256 right) external pure;\n\n /// Asserts that two `int256` values are not equal and includes error message into revert string on failure.\n function assertNotEq(int256 left, int256 right, string calldata error) external pure;\n\n /// Asserts that two `address` values are not equal.\n function assertNotEq(address left, address right) external pure;\n\n /// Asserts that two `address` values are not equal and includes error message into revert string on failure.\n function assertNotEq(address left, address right, string calldata error) external pure;\n\n /// Asserts that two `bytes32` values are not equal.\n function assertNotEq(bytes32 left, bytes32 right) external pure;\n\n /// Asserts that two `bytes32` values are not equal and includes error message into revert string on failure.\n function assertNotEq(bytes32 left, bytes32 right, string calldata error) external pure;\n\n /// Asserts that the given condition is true.\n function assertTrue(bool condition) external pure;\n\n /// Asserts that the given condition is true and includes error message into revert string on failure.\n function assertTrue(bool condition, string calldata error) external pure;\n\n /// If the condition is false, discard this run's fuzz inputs and generate new ones.\n function assume(bool condition) external pure;\n\n /// Discard this run's fuzz inputs and generate new ones if next call reverted.\n function assumeNoRevert() external pure;\n\n /// Discard this run's fuzz inputs and generate new ones if next call reverts with the potential revert parameters.\n function assumeNoRevert(PotentialRevert calldata potentialRevert) external pure;\n\n /// Discard this run's fuzz inputs and generate new ones if next call reverts with the any of the potential revert parameters.\n function assumeNoRevert(PotentialRevert[] calldata potentialReverts) external pure;\n\n /// Writes a breakpoint to jump to in the debugger.\n function breakpoint(string calldata char) external pure;\n\n /// Writes a conditional breakpoint to jump to in the debugger.\n function breakpoint(string calldata char, bool value) external pure;\n\n /// Returns true if the current Foundry version is greater than or equal to the given version.\n /// The given version string must be in the format `major.minor.patch`.\n /// This is equivalent to `foundryVersionCmp(version) >= 0`.\n function foundryVersionAtLeast(string calldata version) external view returns (bool);\n\n /// Compares the current Foundry version with the given version string.\n /// The given version string must be in the format `major.minor.patch`.\n /// Returns:\n /// -1 if current Foundry version is less than the given version\n /// 0 if current Foundry version equals the given version\n /// 1 if current Foundry version is greater than the given version\n /// This result can then be used with a comparison operator against `0`.\n /// For example, to check if the current Foundry version is greater than or equal to `1.0.0`:\n /// `if (foundryVersionCmp(\"1.0.0\") >= 0) { ... }`\n function foundryVersionCmp(string calldata version) external view returns (int256);\n\n /// Returns the Foundry version.\n /// Format: -+..\n /// Sample output: 0.3.0-nightly+3cb96bde9b.1737036656.debug\n /// Note: Build timestamps may vary slightly across platforms due to separate CI jobs.\n /// For reliable version comparisons, use UNIX format (e.g., >= 1700000000)\n /// to compare timestamps while ignoring minor time differences.\n function getFoundryVersion() external view returns (string memory version);\n\n /// Returns the RPC url for the given alias.\n function rpcUrl(string calldata rpcAlias) external view returns (string memory json);\n\n /// Returns all rpc urls and their aliases as structs.\n function rpcUrlStructs() external view returns (Rpc[] memory urls);\n\n /// Returns all rpc urls and their aliases `[alias, url][]`.\n function rpcUrls() external view returns (string[2][] memory urls);\n\n /// Suspends execution of the main thread for `duration` milliseconds.\n function sleep(uint256 duration) external;\n\n // ======== Toml ========\n\n /// Checks if `key` exists in a TOML table.\n function keyExistsToml(string calldata toml, string calldata key) external view returns (bool);\n\n /// Parses a string of TOML data at `key` and coerces it to `address`.\n function parseTomlAddress(string calldata toml, string calldata key) external pure returns (address);\n\n /// Parses a string of TOML data at `key` and coerces it to `address[]`.\n function parseTomlAddressArray(string calldata toml, string calldata key)\n external\n pure\n returns (address[] memory);\n\n /// Parses a string of TOML data at `key` and coerces it to `bool`.\n function parseTomlBool(string calldata toml, string calldata key) external pure returns (bool);\n\n /// Parses a string of TOML data at `key` and coerces it to `bool[]`.\n function parseTomlBoolArray(string calldata toml, string calldata key) external pure returns (bool[] memory);\n\n /// Parses a string of TOML data at `key` and coerces it to `bytes`.\n function parseTomlBytes(string calldata toml, string calldata key) external pure returns (bytes memory);\n\n /// Parses a string of TOML data at `key` and coerces it to `bytes32`.\n function parseTomlBytes32(string calldata toml, string calldata key) external pure returns (bytes32);\n\n /// Parses a string of TOML data at `key` and coerces it to `bytes32[]`.\n function parseTomlBytes32Array(string calldata toml, string calldata key)\n external\n pure\n returns (bytes32[] memory);\n\n /// Parses a string of TOML data at `key` and coerces it to `bytes[]`.\n function parseTomlBytesArray(string calldata toml, string calldata key) external pure returns (bytes[] memory);\n\n /// Parses a string of TOML data at `key` and coerces it to `int256`.\n function parseTomlInt(string calldata toml, string calldata key) external pure returns (int256);\n\n /// Parses a string of TOML data at `key` and coerces it to `int256[]`.\n function parseTomlIntArray(string calldata toml, string calldata key) external pure returns (int256[] memory);\n\n /// Returns an array of all the keys in a TOML table.\n function parseTomlKeys(string calldata toml, string calldata key) external pure returns (string[] memory keys);\n\n /// Parses a string of TOML data at `key` and coerces it to `string`.\n function parseTomlString(string calldata toml, string calldata key) external pure returns (string memory);\n\n /// Parses a string of TOML data at `key` and coerces it to `string[]`.\n function parseTomlStringArray(string calldata toml, string calldata key) external pure returns (string[] memory);\n\n /// Parses a string of TOML data at `key` and coerces it to type array corresponding to `typeDescription`.\n function parseTomlTypeArray(string calldata toml, string calldata key, string calldata typeDescription)\n external\n pure\n returns (bytes memory);\n\n /// Parses a string of TOML data and coerces it to type corresponding to `typeDescription`.\n function parseTomlType(string calldata toml, string calldata typeDescription)\n external\n pure\n returns (bytes memory);\n\n /// Parses a string of TOML data at `key` and coerces it to type corresponding to `typeDescription`.\n function parseTomlType(string calldata toml, string calldata key, string calldata typeDescription)\n external\n pure\n returns (bytes memory);\n\n /// Parses a string of TOML data at `key` and coerces it to `uint256`.\n function parseTomlUint(string calldata toml, string calldata key) external pure returns (uint256);\n\n /// Parses a string of TOML data at `key` and coerces it to `uint256[]`.\n function parseTomlUintArray(string calldata toml, string calldata key) external pure returns (uint256[] memory);\n\n /// ABI-encodes a TOML table.\n function parseToml(string calldata toml) external pure returns (bytes memory abiEncodedData);\n\n /// ABI-encodes a TOML table at `key`.\n function parseToml(string calldata toml, string calldata key) external pure returns (bytes memory abiEncodedData);\n\n /// Takes serialized JSON, converts to TOML and write a serialized TOML to a file.\n function writeToml(string calldata json, string calldata path) external;\n\n /// Takes serialized JSON, converts to TOML and write a serialized TOML table to an **existing** TOML file, replacing a value with key = \n /// This is useful to replace a specific value of a TOML file, without having to parse the entire thing.\n function writeToml(string calldata json, string calldata path, string calldata valueKey) external;\n\n // ======== Utilities ========\n\n /// Compute the address of a contract created with CREATE2 using the given CREATE2 deployer.\n function computeCreate2Address(bytes32 salt, bytes32 initCodeHash, address deployer)\n external\n pure\n returns (address);\n\n /// Compute the address of a contract created with CREATE2 using the default CREATE2 deployer.\n function computeCreate2Address(bytes32 salt, bytes32 initCodeHash) external pure returns (address);\n\n /// Compute the address a contract will be deployed at for a given deployer address and nonce.\n function computeCreateAddress(address deployer, uint256 nonce) external pure returns (address);\n\n /// Utility cheatcode to copy storage of `from` contract to another `to` contract.\n function copyStorage(address from, address to) external;\n\n /// Returns ENS namehash for provided string.\n function ensNamehash(string calldata name) external pure returns (bytes32);\n\n /// Gets the label for the specified address.\n function getLabel(address account) external view returns (string memory currentLabel);\n\n /// Labels an address in call traces.\n function label(address account, string calldata newLabel) external;\n\n /// Pauses collection of call traces. Useful in cases when you want to skip tracing of\n /// complex calls which are not useful for debugging.\n function pauseTracing() external view;\n\n /// Returns a random `address`.\n function randomAddress() external returns (address);\n\n /// Returns a random `bool`.\n function randomBool() external view returns (bool);\n\n /// Returns a random byte array value of the given length.\n function randomBytes(uint256 len) external view returns (bytes memory);\n\n /// Returns a random fixed-size byte array of length 4.\n function randomBytes4() external view returns (bytes4);\n\n /// Returns a random fixed-size byte array of length 8.\n function randomBytes8() external view returns (bytes8);\n\n /// Returns a random `int256` value.\n function randomInt() external view returns (int256);\n\n /// Returns a random `int256` value of given bits.\n function randomInt(uint256 bits) external view returns (int256);\n\n /// Returns a random uint256 value.\n function randomUint() external returns (uint256);\n\n /// Returns random uint256 value between the provided range (=min..=max).\n function randomUint(uint256 min, uint256 max) external returns (uint256);\n\n /// Returns a random `uint256` value of given bits.\n function randomUint(uint256 bits) external view returns (uint256);\n\n /// Unpauses collection of call traces.\n function resumeTracing() external view;\n\n /// Utility cheatcode to set arbitrary storage for given target address.\n function setArbitraryStorage(address target) external;\n\n /// Encodes a `bytes` value to a base64url string.\n function toBase64URL(bytes calldata data) external pure returns (string memory);\n\n /// Encodes a `string` value to a base64url string.\n function toBase64URL(string calldata data) external pure returns (string memory);\n\n /// Encodes a `bytes` value to a base64 string.\n function toBase64(bytes calldata data) external pure returns (string memory);\n\n /// Encodes a `string` value to a base64 string.\n function toBase64(string calldata data) external pure returns (string memory);\n}\n\n/// The `Vm` interface does allow manipulation of the EVM state. These are all intended to be used\n/// in tests, but it is not recommended to use these cheats in scripts.\ninterface Vm is VmSafe {\n // ======== EVM ========\n\n /// Utility cheatcode to set an EIP-2930 access list for all subsequent transactions.\n function accessList(AccessListItem[] calldata access) external;\n\n /// Returns the identifier of the currently active fork. Reverts if no fork is currently active.\n function activeFork() external view returns (uint256 forkId);\n\n /// In forking mode, explicitly grant the given address cheatcode access.\n function allowCheatcodes(address account) external;\n\n /// Sets `block.blobbasefee`\n function blobBaseFee(uint256 newBlobBaseFee) external;\n\n /// Sets the blobhashes in the transaction.\n /// Not available on EVM versions before Cancun.\n /// If used on unsupported EVM versions it will revert.\n function blobhashes(bytes32[] calldata hashes) external;\n\n /// Sets `block.chainid`.\n function chainId(uint256 newChainId) external;\n\n /// Clears all mocked calls.\n function clearMockedCalls() external;\n\n /// Clones a source account code, state, balance and nonce to a target account and updates in-memory EVM state.\n function cloneAccount(address source, address target) external;\n\n /// Sets `block.coinbase`.\n function coinbase(address newCoinbase) external;\n\n /// Marks the slots of an account and the account address as cold.\n function cool(address target) external;\n\n /// Utility cheatcode to mark specific storage slot as cold, simulating no prior read.\n function coolSlot(address target, bytes32 slot) external;\n\n /// Creates a new fork with the given endpoint and the _latest_ block and returns the identifier of the fork.\n function createFork(string calldata urlOrAlias) external returns (uint256 forkId);\n\n /// Creates a new fork with the given endpoint and block and returns the identifier of the fork.\n function createFork(string calldata urlOrAlias, uint256 blockNumber) external returns (uint256 forkId);\n\n /// Creates a new fork with the given endpoint and at the block the given transaction was mined in,\n /// replays all transaction mined in the block before the transaction, and returns the identifier of the fork.\n function createFork(string calldata urlOrAlias, bytes32 txHash) external returns (uint256 forkId);\n\n /// Creates and also selects a new fork with the given endpoint and the latest block and returns the identifier of the fork.\n function createSelectFork(string calldata urlOrAlias) external returns (uint256 forkId);\n\n /// Creates and also selects a new fork with the given endpoint and block and returns the identifier of the fork.\n function createSelectFork(string calldata urlOrAlias, uint256 blockNumber) external returns (uint256 forkId);\n\n /// Creates and also selects new fork with the given endpoint and at the block the given transaction was mined in,\n /// replays all transaction mined in the block before the transaction, returns the identifier of the fork.\n function createSelectFork(string calldata urlOrAlias, bytes32 txHash) external returns (uint256 forkId);\n\n /// Sets an address' balance.\n function deal(address account, uint256 newBalance) external;\n\n /// Removes the snapshot with the given ID created by `snapshot`.\n /// Takes the snapshot ID to delete.\n /// Returns `true` if the snapshot was successfully deleted.\n /// Returns `false` if the snapshot does not exist.\n function deleteStateSnapshot(uint256 snapshotId) external returns (bool success);\n\n /// Removes _all_ snapshots previously created by `snapshot`.\n function deleteStateSnapshots() external;\n\n /// Sets `block.difficulty`.\n /// Not available on EVM versions from Paris onwards. Use `prevrandao` instead.\n /// Reverts if used on unsupported EVM versions.\n function difficulty(uint256 newDifficulty) external;\n\n /// Dump a genesis JSON file's `allocs` to disk.\n function dumpState(string calldata pathToStateJson) external;\n\n /// Sets an address' code.\n function etch(address target, bytes calldata newRuntimeBytecode) external;\n\n /// Sets `block.basefee`.\n function fee(uint256 newBasefee) external;\n\n /// Gets the blockhashes from the current transaction.\n /// Not available on EVM versions before Cancun.\n /// If used on unsupported EVM versions it will revert.\n function getBlobhashes() external view returns (bytes32[] memory hashes);\n\n /// Returns true if the account is marked as persistent.\n function isPersistent(address account) external view returns (bool persistent);\n\n /// Load a genesis JSON file's `allocs` into the in-memory EVM state.\n function loadAllocs(string calldata pathToAllocsJson) external;\n\n /// Marks that the account(s) should use persistent storage across fork swaps in a multifork setup\n /// Meaning, changes made to the state of this account will be kept when switching forks.\n function makePersistent(address account) external;\n\n /// See `makePersistent(address)`.\n function makePersistent(address account0, address account1) external;\n\n /// See `makePersistent(address)`.\n function makePersistent(address account0, address account1, address account2) external;\n\n /// See `makePersistent(address)`.\n function makePersistent(address[] calldata accounts) external;\n\n /// Reverts a call to an address with specified revert data.\n function mockCallRevert(address callee, bytes calldata data, bytes calldata revertData) external;\n\n /// Reverts a call to an address with a specific `msg.value`, with specified revert data.\n function mockCallRevert(address callee, uint256 msgValue, bytes calldata data, bytes calldata revertData)\n external;\n\n /// Reverts a call to an address with specified revert data.\n /// Overload to pass the function selector directly `token.approve.selector` instead of `abi.encodeWithSelector(token.approve.selector)`.\n function mockCallRevert(address callee, bytes4 data, bytes calldata revertData) external;\n\n /// Reverts a call to an address with a specific `msg.value`, with specified revert data.\n /// Overload to pass the function selector directly `token.approve.selector` instead of `abi.encodeWithSelector(token.approve.selector)`.\n function mockCallRevert(address callee, uint256 msgValue, bytes4 data, bytes calldata revertData) external;\n\n /// Mocks a call to an address, returning specified data.\n /// Calldata can either be strict or a partial match, e.g. if you only\n /// pass a Solidity selector to the expected calldata, then the entire Solidity\n /// function will be mocked.\n function mockCall(address callee, bytes calldata data, bytes calldata returnData) external;\n\n /// Mocks a call to an address with a specific `msg.value`, returning specified data.\n /// Calldata match takes precedence over `msg.value` in case of ambiguity.\n function mockCall(address callee, uint256 msgValue, bytes calldata data, bytes calldata returnData) external;\n\n /// Mocks a call to an address, returning specified data.\n /// Calldata can either be strict or a partial match, e.g. if you only\n /// pass a Solidity selector to the expected calldata, then the entire Solidity\n /// function will be mocked.\n /// Overload to pass the function selector directly `token.approve.selector` instead of `abi.encodeWithSelector(token.approve.selector)`.\n function mockCall(address callee, bytes4 data, bytes calldata returnData) external;\n\n /// Mocks a call to an address with a specific `msg.value`, returning specified data.\n /// Calldata match takes precedence over `msg.value` in case of ambiguity.\n /// Overload to pass the function selector directly `token.approve.selector` instead of `abi.encodeWithSelector(token.approve.selector)`.\n function mockCall(address callee, uint256 msgValue, bytes4 data, bytes calldata returnData) external;\n\n /// Mocks multiple calls to an address, returning specified data for each call.\n function mockCalls(address callee, bytes calldata data, bytes[] calldata returnData) external;\n\n /// Mocks multiple calls to an address with a specific `msg.value`, returning specified data for each call.\n function mockCalls(address callee, uint256 msgValue, bytes calldata data, bytes[] calldata returnData) external;\n\n /// Whenever a call is made to `callee` with calldata `data`, this cheatcode instead calls\n /// `target` with the same calldata. This functionality is similar to a delegate call made to\n /// `target` contract from `callee`.\n /// Can be used to substitute a call to a function with another implementation that captures\n /// the primary logic of the original function but is easier to reason about.\n /// If calldata is not a strict match then partial match by selector is attempted.\n function mockFunction(address callee, address target, bytes calldata data) external;\n\n /// Utility cheatcode to remove any EIP-2930 access list set by `accessList` cheatcode.\n function noAccessList() external;\n\n /// Sets the *next* call's `msg.sender` to be the input address.\n function prank(address msgSender) external;\n\n /// Sets the *next* call's `msg.sender` to be the input address, and the `tx.origin` to be the second input.\n function prank(address msgSender, address txOrigin) external;\n\n /// Sets the *next* delegate call's `msg.sender` to be the input address.\n function prank(address msgSender, bool delegateCall) external;\n\n /// Sets the *next* delegate call's `msg.sender` to be the input address, and the `tx.origin` to be the second input.\n function prank(address msgSender, address txOrigin, bool delegateCall) external;\n\n /// Sets `block.prevrandao`.\n /// Not available on EVM versions before Paris. Use `difficulty` instead.\n /// If used on unsupported EVM versions it will revert.\n function prevrandao(bytes32 newPrevrandao) external;\n\n /// Sets `block.prevrandao`.\n /// Not available on EVM versions before Paris. Use `difficulty` instead.\n /// If used on unsupported EVM versions it will revert.\n function prevrandao(uint256 newPrevrandao) external;\n\n /// Reads the current `msg.sender` and `tx.origin` from state and reports if there is any active caller modification.\n function readCallers() external returns (CallerMode callerMode, address msgSender, address txOrigin);\n\n /// Resets the nonce of an account to 0 for EOAs and 1 for contract accounts.\n function resetNonce(address account) external;\n\n /// Revert the state of the EVM to a previous snapshot\n /// Takes the snapshot ID to revert to.\n /// Returns `true` if the snapshot was successfully reverted.\n /// Returns `false` if the snapshot does not exist.\n /// **Note:** This does not automatically delete the snapshot. To delete the snapshot use `deleteStateSnapshot`.\n function revertToState(uint256 snapshotId) external returns (bool success);\n\n /// Revert the state of the EVM to a previous snapshot and automatically deletes the snapshots\n /// Takes the snapshot ID to revert to.\n /// Returns `true` if the snapshot was successfully reverted and deleted.\n /// Returns `false` if the snapshot does not exist.\n function revertToStateAndDelete(uint256 snapshotId) external returns (bool success);\n\n /// Revokes persistent status from the address, previously added via `makePersistent`.\n function revokePersistent(address account) external;\n\n /// See `revokePersistent(address)`.\n function revokePersistent(address[] calldata accounts) external;\n\n /// Sets `block.height`.\n function roll(uint256 newHeight) external;\n\n /// Updates the currently active fork to given block number\n /// This is similar to `roll` but for the currently active fork.\n function rollFork(uint256 blockNumber) external;\n\n /// Updates the currently active fork to given transaction. This will `rollFork` with the number\n /// of the block the transaction was mined in and replays all transaction mined before it in the block.\n function rollFork(bytes32 txHash) external;\n\n /// Updates the given fork to given block number.\n function rollFork(uint256 forkId, uint256 blockNumber) external;\n\n /// Updates the given fork to block number of the given transaction and replays all transaction mined before it in the block.\n function rollFork(uint256 forkId, bytes32 txHash) external;\n\n /// Takes a fork identifier created by `createFork` and sets the corresponding forked state as active.\n function selectFork(uint256 forkId) external;\n\n /// Set blockhash for the current block.\n /// It only sets the blockhash for blocks where `block.number - 256 <= number < block.number`.\n function setBlockhash(uint256 blockNumber, bytes32 blockHash) external;\n\n /// Sets the nonce of an account. Must be higher than the current nonce of the account.\n function setNonce(address account, uint64 newNonce) external;\n\n /// Sets the nonce of an account to an arbitrary value.\n function setNonceUnsafe(address account, uint64 newNonce) external;\n\n /// Snapshot capture the gas usage of the last call by name from the callee perspective.\n function snapshotGasLastCall(string calldata name) external returns (uint256 gasUsed);\n\n /// Snapshot capture the gas usage of the last call by name in a group from the callee perspective.\n function snapshotGasLastCall(string calldata group, string calldata name) external returns (uint256 gasUsed);\n\n /// Snapshot the current state of the evm.\n /// Returns the ID of the snapshot that was created.\n /// To revert a snapshot use `revertToState`.\n function snapshotState() external returns (uint256 snapshotId);\n\n /// Snapshot capture an arbitrary numerical value by name.\n /// The group name is derived from the contract name.\n function snapshotValue(string calldata name, uint256 value) external;\n\n /// Snapshot capture an arbitrary numerical value by name in a group.\n function snapshotValue(string calldata group, string calldata name, uint256 value) external;\n\n /// Sets all subsequent calls' `msg.sender` to be the input address until `stopPrank` is called.\n function startPrank(address msgSender) external;\n\n /// Sets all subsequent calls' `msg.sender` to be the input address until `stopPrank` is called, and the `tx.origin` to be the second input.\n function startPrank(address msgSender, address txOrigin) external;\n\n /// Sets all subsequent delegate calls' `msg.sender` to be the input address until `stopPrank` is called.\n function startPrank(address msgSender, bool delegateCall) external;\n\n /// Sets all subsequent delegate calls' `msg.sender` to be the input address until `stopPrank` is called, and the `tx.origin` to be the second input.\n function startPrank(address msgSender, address txOrigin, bool delegateCall) external;\n\n /// Start a snapshot capture of the current gas usage by name.\n /// The group name is derived from the contract name.\n function startSnapshotGas(string calldata name) external;\n\n /// Start a snapshot capture of the current gas usage by name in a group.\n function startSnapshotGas(string calldata group, string calldata name) external;\n\n /// Resets subsequent calls' `msg.sender` to be `address(this)`.\n function stopPrank() external;\n\n /// Stop the snapshot capture of the current gas by latest snapshot name, capturing the gas used since the start.\n function stopSnapshotGas() external returns (uint256 gasUsed);\n\n /// Stop the snapshot capture of the current gas usage by name, capturing the gas used since the start.\n /// The group name is derived from the contract name.\n function stopSnapshotGas(string calldata name) external returns (uint256 gasUsed);\n\n /// Stop the snapshot capture of the current gas usage by name in a group, capturing the gas used since the start.\n function stopSnapshotGas(string calldata group, string calldata name) external returns (uint256 gasUsed);\n\n /// Stores a value to an address' storage slot.\n function store(address target, bytes32 slot, bytes32 value) external;\n\n /// Fetches the given transaction from the active fork and executes it on the current state.\n function transact(bytes32 txHash) external;\n\n /// Fetches the given transaction from the given fork and executes it on the current state.\n function transact(uint256 forkId, bytes32 txHash) external;\n\n /// Sets `tx.gasprice`.\n function txGasPrice(uint256 newGasPrice) external;\n\n /// Utility cheatcode to mark specific storage slot as warm, simulating a prior read.\n function warmSlot(address target, bytes32 slot) external;\n\n /// Sets `block.timestamp`.\n function warp(uint256 newTimestamp) external;\n\n /// `deleteSnapshot` is being deprecated in favor of `deleteStateSnapshot`. It will be removed in future versions.\n function deleteSnapshot(uint256 snapshotId) external returns (bool success);\n\n /// `deleteSnapshots` is being deprecated in favor of `deleteStateSnapshots`. It will be removed in future versions.\n function deleteSnapshots() external;\n\n /// `revertToAndDelete` is being deprecated in favor of `revertToStateAndDelete`. It will be removed in future versions.\n function revertToAndDelete(uint256 snapshotId) external returns (bool success);\n\n /// `revertTo` is being deprecated in favor of `revertToState`. It will be removed in future versions.\n function revertTo(uint256 snapshotId) external returns (bool success);\n\n /// `snapshot` is being deprecated in favor of `snapshotState`. It will be removed in future versions.\n function snapshot() external returns (uint256 snapshotId);\n\n // ======== Testing ========\n\n /// Expect a call to an address with the specified `msg.value` and calldata, and a *minimum* amount of gas.\n function expectCallMinGas(address callee, uint256 msgValue, uint64 minGas, bytes calldata data) external;\n\n /// Expect given number of calls to an address with the specified `msg.value` and calldata, and a *minimum* amount of gas.\n function expectCallMinGas(address callee, uint256 msgValue, uint64 minGas, bytes calldata data, uint64 count)\n external;\n\n /// Expects a call to an address with the specified calldata.\n /// Calldata can either be a strict or a partial match.\n function expectCall(address callee, bytes calldata data) external;\n\n /// Expects given number of calls to an address with the specified calldata.\n function expectCall(address callee, bytes calldata data, uint64 count) external;\n\n /// Expects a call to an address with the specified `msg.value` and calldata.\n function expectCall(address callee, uint256 msgValue, bytes calldata data) external;\n\n /// Expects given number of calls to an address with the specified `msg.value` and calldata.\n function expectCall(address callee, uint256 msgValue, bytes calldata data, uint64 count) external;\n\n /// Expect a call to an address with the specified `msg.value`, gas, and calldata.\n function expectCall(address callee, uint256 msgValue, uint64 gas, bytes calldata data) external;\n\n /// Expects given number of calls to an address with the specified `msg.value`, gas, and calldata.\n function expectCall(address callee, uint256 msgValue, uint64 gas, bytes calldata data, uint64 count) external;\n\n /// Expects the deployment of the specified bytecode by the specified address using the CREATE opcode\n function expectCreate(bytes calldata bytecode, address deployer) external;\n\n /// Expects the deployment of the specified bytecode by the specified address using the CREATE2 opcode\n function expectCreate2(bytes calldata bytecode, address deployer) external;\n\n /// Prepare an expected anonymous log with (bool checkTopic1, bool checkTopic2, bool checkTopic3, bool checkData.).\n /// Call this function, then emit an anonymous event, then call a function. Internally after the call, we check if\n /// logs were emitted in the expected order with the expected topics and data (as specified by the booleans).\n function expectEmitAnonymous(bool checkTopic0, bool checkTopic1, bool checkTopic2, bool checkTopic3, bool checkData)\n external;\n\n /// Same as the previous method, but also checks supplied address against emitting contract.\n function expectEmitAnonymous(\n bool checkTopic0,\n bool checkTopic1,\n bool checkTopic2,\n bool checkTopic3,\n bool checkData,\n address emitter\n ) external;\n\n /// Prepare an expected anonymous log with all topic and data checks enabled.\n /// Call this function, then emit an anonymous event, then call a function. Internally after the call, we check if\n /// logs were emitted in the expected order with the expected topics and data.\n function expectEmitAnonymous() external;\n\n /// Same as the previous method, but also checks supplied address against emitting contract.\n function expectEmitAnonymous(address emitter) external;\n\n /// Prepare an expected log with (bool checkTopic1, bool checkTopic2, bool checkTopic3, bool checkData.).\n /// Call this function, then emit an event, then call a function. Internally after the call, we check if\n /// logs were emitted in the expected order with the expected topics and data (as specified by the booleans).\n function expectEmit(bool checkTopic1, bool checkTopic2, bool checkTopic3, bool checkData) external;\n\n /// Same as the previous method, but also checks supplied address against emitting contract.\n function expectEmit(bool checkTopic1, bool checkTopic2, bool checkTopic3, bool checkData, address emitter)\n external;\n\n /// Prepare an expected log with all topic and data checks enabled.\n /// Call this function, then emit an event, then call a function. Internally after the call, we check if\n /// logs were emitted in the expected order with the expected topics and data.\n function expectEmit() external;\n\n /// Same as the previous method, but also checks supplied address against emitting contract.\n function expectEmit(address emitter) external;\n\n /// Expect a given number of logs with the provided topics.\n function expectEmit(bool checkTopic1, bool checkTopic2, bool checkTopic3, bool checkData, uint64 count) external;\n\n /// Expect a given number of logs from a specific emitter with the provided topics.\n function expectEmit(\n bool checkTopic1,\n bool checkTopic2,\n bool checkTopic3,\n bool checkData,\n address emitter,\n uint64 count\n ) external;\n\n /// Expect a given number of logs with all topic and data checks enabled.\n function expectEmit(uint64 count) external;\n\n /// Expect a given number of logs from a specific emitter with all topic and data checks enabled.\n function expectEmit(address emitter, uint64 count) external;\n\n /// Expects an error on next call that starts with the revert data.\n function expectPartialRevert(bytes4 revertData) external;\n\n /// Expects an error on next call to reverter address, that starts with the revert data.\n function expectPartialRevert(bytes4 revertData, address reverter) external;\n\n /// Expects an error on next call with any revert data.\n function expectRevert() external;\n\n /// Expects an error on next call that exactly matches the revert data.\n function expectRevert(bytes4 revertData) external;\n\n /// Expects a `count` number of reverts from the upcoming calls from the reverter address that match the revert data.\n function expectRevert(bytes4 revertData, address reverter, uint64 count) external;\n\n /// Expects a `count` number of reverts from the upcoming calls from the reverter address that exactly match the revert data.\n function expectRevert(bytes calldata revertData, address reverter, uint64 count) external;\n\n /// Expects an error on next call that exactly matches the revert data.\n function expectRevert(bytes calldata revertData) external;\n\n /// Expects an error with any revert data on next call to reverter address.\n function expectRevert(address reverter) external;\n\n /// Expects an error from reverter address on next call, with any revert data.\n function expectRevert(bytes4 revertData, address reverter) external;\n\n /// Expects an error from reverter address on next call, that exactly matches the revert data.\n function expectRevert(bytes calldata revertData, address reverter) external;\n\n /// Expects a `count` number of reverts from the upcoming calls with any revert data or reverter.\n function expectRevert(uint64 count) external;\n\n /// Expects a `count` number of reverts from the upcoming calls that match the revert data.\n function expectRevert(bytes4 revertData, uint64 count) external;\n\n /// Expects a `count` number of reverts from the upcoming calls that exactly match the revert data.\n function expectRevert(bytes calldata revertData, uint64 count) external;\n\n /// Expects a `count` number of reverts from the upcoming calls from the reverter address.\n function expectRevert(address reverter, uint64 count) external;\n\n /// Only allows memory writes to offsets [0x00, 0x60) ∪ [min, max) in the current subcontext. If any other\n /// memory is written to, the test will fail. Can be called multiple times to add more ranges to the set.\n function expectSafeMemory(uint64 min, uint64 max) external;\n\n /// Only allows memory writes to offsets [0x00, 0x60) ∪ [min, max) in the next created subcontext.\n /// If any other memory is written to, the test will fail. Can be called multiple times to add more ranges\n /// to the set.\n function expectSafeMemoryCall(uint64 min, uint64 max) external;\n\n /// Marks a test as skipped. Must be called at the top level of a test.\n function skip(bool skipTest) external;\n\n /// Marks a test as skipped with a reason. Must be called at the top level of a test.\n function skip(bool skipTest, string calldata reason) external;\n\n /// Stops all safe memory expectation in the current subcontext.\n function stopExpectSafeMemory() external;\n}\n","license":"MIT OR Apache-2.0"},"lib/forge-std/src/console.sol":{"keccak256":"0x4bbf47eb762cef93729d6ef15e78789957147039b113e5d4df48e3d3fd16d0f5","urls":[],"content":"// SPDX-License-Identifier: MIT\npragma solidity >=0.4.22 <0.9.0;\n\nlibrary console {\n address constant CONSOLE_ADDRESS =\n 0x000000000000000000636F6e736F6c652e6c6f67;\n\n function _sendLogPayloadImplementation(bytes memory payload) internal view {\n address consoleAddress = CONSOLE_ADDRESS;\n /// @solidity memory-safe-assembly\n assembly {\n pop(\n staticcall(\n gas(),\n consoleAddress,\n add(payload, 32),\n mload(payload),\n 0,\n 0\n )\n )\n }\n }\n\n function _castToPure(\n function(bytes memory) internal view fnIn\n ) internal pure returns (function(bytes memory) pure fnOut) {\n assembly {\n fnOut := fnIn\n }\n }\n\n function _sendLogPayload(bytes memory payload) internal pure {\n _castToPure(_sendLogPayloadImplementation)(payload);\n }\n\n function log() internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log()\"));\n }\n\n function logInt(int256 p0) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(int256)\", p0));\n }\n\n function logUint(uint256 p0) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256)\", p0));\n }\n\n function logString(string memory p0) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string)\", p0));\n }\n\n function logBool(bool p0) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool)\", p0));\n }\n\n function logAddress(address p0) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address)\", p0));\n }\n\n function logBytes(bytes memory p0) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bytes)\", p0));\n }\n\n function logBytes1(bytes1 p0) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bytes1)\", p0));\n }\n\n function logBytes2(bytes2 p0) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bytes2)\", p0));\n }\n\n function logBytes3(bytes3 p0) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bytes3)\", p0));\n }\n\n function logBytes4(bytes4 p0) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bytes4)\", p0));\n }\n\n function logBytes5(bytes5 p0) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bytes5)\", p0));\n }\n\n function logBytes6(bytes6 p0) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bytes6)\", p0));\n }\n\n function logBytes7(bytes7 p0) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bytes7)\", p0));\n }\n\n function logBytes8(bytes8 p0) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bytes8)\", p0));\n }\n\n function logBytes9(bytes9 p0) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bytes9)\", p0));\n }\n\n function logBytes10(bytes10 p0) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bytes10)\", p0));\n }\n\n function logBytes11(bytes11 p0) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bytes11)\", p0));\n }\n\n function logBytes12(bytes12 p0) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bytes12)\", p0));\n }\n\n function logBytes13(bytes13 p0) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bytes13)\", p0));\n }\n\n function logBytes14(bytes14 p0) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bytes14)\", p0));\n }\n\n function logBytes15(bytes15 p0) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bytes15)\", p0));\n }\n\n function logBytes16(bytes16 p0) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bytes16)\", p0));\n }\n\n function logBytes17(bytes17 p0) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bytes17)\", p0));\n }\n\n function logBytes18(bytes18 p0) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bytes18)\", p0));\n }\n\n function logBytes19(bytes19 p0) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bytes19)\", p0));\n }\n\n function logBytes20(bytes20 p0) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bytes20)\", p0));\n }\n\n function logBytes21(bytes21 p0) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bytes21)\", p0));\n }\n\n function logBytes22(bytes22 p0) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bytes22)\", p0));\n }\n\n function logBytes23(bytes23 p0) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bytes23)\", p0));\n }\n\n function logBytes24(bytes24 p0) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bytes24)\", p0));\n }\n\n function logBytes25(bytes25 p0) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bytes25)\", p0));\n }\n\n function logBytes26(bytes26 p0) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bytes26)\", p0));\n }\n\n function logBytes27(bytes27 p0) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bytes27)\", p0));\n }\n\n function logBytes28(bytes28 p0) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bytes28)\", p0));\n }\n\n function logBytes29(bytes29 p0) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bytes29)\", p0));\n }\n\n function logBytes30(bytes30 p0) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bytes30)\", p0));\n }\n\n function logBytes31(bytes31 p0) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bytes31)\", p0));\n }\n\n function logBytes32(bytes32 p0) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bytes32)\", p0));\n }\n\n function log(uint256 p0) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256)\", p0));\n }\n\n function log(int256 p0) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(int256)\", p0));\n }\n\n function log(string memory p0) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string)\", p0));\n }\n\n function log(bool p0) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool)\", p0));\n }\n\n function log(address p0) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address)\", p0));\n }\n\n function log(uint256 p0, uint256 p1) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,uint256)\", p0, p1));\n }\n\n function log(uint256 p0, string memory p1) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,string)\", p0, p1));\n }\n\n function log(uint256 p0, bool p1) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,bool)\", p0, p1));\n }\n\n function log(uint256 p0, address p1) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,address)\", p0, p1));\n }\n\n function log(string memory p0, uint256 p1) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,uint256)\", p0, p1));\n }\n\n function log(string memory p0, int256 p1) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,int256)\", p0, p1));\n }\n\n function log(string memory p0, string memory p1) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,string)\", p0, p1));\n }\n\n function log(string memory p0, bool p1) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,bool)\", p0, p1));\n }\n\n function log(string memory p0, address p1) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,address)\", p0, p1));\n }\n\n function log(bool p0, uint256 p1) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,uint256)\", p0, p1));\n }\n\n function log(bool p0, string memory p1) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,string)\", p0, p1));\n }\n\n function log(bool p0, bool p1) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,bool)\", p0, p1));\n }\n\n function log(bool p0, address p1) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,address)\", p0, p1));\n }\n\n function log(address p0, uint256 p1) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,uint256)\", p0, p1));\n }\n\n function log(address p0, string memory p1) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,string)\", p0, p1));\n }\n\n function log(address p0, bool p1) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,bool)\", p0, p1));\n }\n\n function log(address p0, address p1) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,address)\", p0, p1));\n }\n\n function log(uint256 p0, uint256 p1, uint256 p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,uint256,uint256)\", p0, p1, p2));\n }\n\n function log(uint256 p0, uint256 p1, string memory p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,uint256,string)\", p0, p1, p2));\n }\n\n function log(uint256 p0, uint256 p1, bool p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,uint256,bool)\", p0, p1, p2));\n }\n\n function log(uint256 p0, uint256 p1, address p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,uint256,address)\", p0, p1, p2));\n }\n\n function log(uint256 p0, string memory p1, uint256 p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,string,uint256)\", p0, p1, p2));\n }\n\n function log(uint256 p0, string memory p1, string memory p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,string,string)\", p0, p1, p2));\n }\n\n function log(uint256 p0, string memory p1, bool p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,string,bool)\", p0, p1, p2));\n }\n\n function log(uint256 p0, string memory p1, address p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,string,address)\", p0, p1, p2));\n }\n\n function log(uint256 p0, bool p1, uint256 p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,bool,uint256)\", p0, p1, p2));\n }\n\n function log(uint256 p0, bool p1, string memory p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,bool,string)\", p0, p1, p2));\n }\n\n function log(uint256 p0, bool p1, bool p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,bool,bool)\", p0, p1, p2));\n }\n\n function log(uint256 p0, bool p1, address p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,bool,address)\", p0, p1, p2));\n }\n\n function log(uint256 p0, address p1, uint256 p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,address,uint256)\", p0, p1, p2));\n }\n\n function log(uint256 p0, address p1, string memory p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,address,string)\", p0, p1, p2));\n }\n\n function log(uint256 p0, address p1, bool p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,address,bool)\", p0, p1, p2));\n }\n\n function log(uint256 p0, address p1, address p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,address,address)\", p0, p1, p2));\n }\n\n function log(string memory p0, uint256 p1, uint256 p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,uint256,uint256)\", p0, p1, p2));\n }\n\n function log(string memory p0, uint256 p1, string memory p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,uint256,string)\", p0, p1, p2));\n }\n\n function log(string memory p0, uint256 p1, bool p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,uint256,bool)\", p0, p1, p2));\n }\n\n function log(string memory p0, uint256 p1, address p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,uint256,address)\", p0, p1, p2));\n }\n\n function log(string memory p0, string memory p1, uint256 p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,string,uint256)\", p0, p1, p2));\n }\n\n function log(string memory p0, string memory p1, string memory p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,string,string)\", p0, p1, p2));\n }\n\n function log(string memory p0, string memory p1, bool p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,string,bool)\", p0, p1, p2));\n }\n\n function log(string memory p0, string memory p1, address p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,string,address)\", p0, p1, p2));\n }\n\n function log(string memory p0, bool p1, uint256 p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,bool,uint256)\", p0, p1, p2));\n }\n\n function log(string memory p0, bool p1, string memory p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,bool,string)\", p0, p1, p2));\n }\n\n function log(string memory p0, bool p1, bool p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,bool,bool)\", p0, p1, p2));\n }\n\n function log(string memory p0, bool p1, address p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,bool,address)\", p0, p1, p2));\n }\n\n function log(string memory p0, address p1, uint256 p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,address,uint256)\", p0, p1, p2));\n }\n\n function log(string memory p0, address p1, string memory p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,address,string)\", p0, p1, p2));\n }\n\n function log(string memory p0, address p1, bool p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,address,bool)\", p0, p1, p2));\n }\n\n function log(string memory p0, address p1, address p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,address,address)\", p0, p1, p2));\n }\n\n function log(bool p0, uint256 p1, uint256 p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,uint256,uint256)\", p0, p1, p2));\n }\n\n function log(bool p0, uint256 p1, string memory p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,uint256,string)\", p0, p1, p2));\n }\n\n function log(bool p0, uint256 p1, bool p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,uint256,bool)\", p0, p1, p2));\n }\n\n function log(bool p0, uint256 p1, address p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,uint256,address)\", p0, p1, p2));\n }\n\n function log(bool p0, string memory p1, uint256 p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,string,uint256)\", p0, p1, p2));\n }\n\n function log(bool p0, string memory p1, string memory p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,string,string)\", p0, p1, p2));\n }\n\n function log(bool p0, string memory p1, bool p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,string,bool)\", p0, p1, p2));\n }\n\n function log(bool p0, string memory p1, address p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,string,address)\", p0, p1, p2));\n }\n\n function log(bool p0, bool p1, uint256 p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,bool,uint256)\", p0, p1, p2));\n }\n\n function log(bool p0, bool p1, string memory p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,bool,string)\", p0, p1, p2));\n }\n\n function log(bool p0, bool p1, bool p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,bool,bool)\", p0, p1, p2));\n }\n\n function log(bool p0, bool p1, address p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,bool,address)\", p0, p1, p2));\n }\n\n function log(bool p0, address p1, uint256 p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,address,uint256)\", p0, p1, p2));\n }\n\n function log(bool p0, address p1, string memory p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,address,string)\", p0, p1, p2));\n }\n\n function log(bool p0, address p1, bool p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,address,bool)\", p0, p1, p2));\n }\n\n function log(bool p0, address p1, address p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,address,address)\", p0, p1, p2));\n }\n\n function log(address p0, uint256 p1, uint256 p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,uint256,uint256)\", p0, p1, p2));\n }\n\n function log(address p0, uint256 p1, string memory p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,uint256,string)\", p0, p1, p2));\n }\n\n function log(address p0, uint256 p1, bool p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,uint256,bool)\", p0, p1, p2));\n }\n\n function log(address p0, uint256 p1, address p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,uint256,address)\", p0, p1, p2));\n }\n\n function log(address p0, string memory p1, uint256 p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,string,uint256)\", p0, p1, p2));\n }\n\n function log(address p0, string memory p1, string memory p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,string,string)\", p0, p1, p2));\n }\n\n function log(address p0, string memory p1, bool p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,string,bool)\", p0, p1, p2));\n }\n\n function log(address p0, string memory p1, address p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,string,address)\", p0, p1, p2));\n }\n\n function log(address p0, bool p1, uint256 p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,bool,uint256)\", p0, p1, p2));\n }\n\n function log(address p0, bool p1, string memory p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,bool,string)\", p0, p1, p2));\n }\n\n function log(address p0, bool p1, bool p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,bool,bool)\", p0, p1, p2));\n }\n\n function log(address p0, bool p1, address p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,bool,address)\", p0, p1, p2));\n }\n\n function log(address p0, address p1, uint256 p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,address,uint256)\", p0, p1, p2));\n }\n\n function log(address p0, address p1, string memory p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,address,string)\", p0, p1, p2));\n }\n\n function log(address p0, address p1, bool p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,address,bool)\", p0, p1, p2));\n }\n\n function log(address p0, address p1, address p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,address,address)\", p0, p1, p2));\n }\n\n function log(uint256 p0, uint256 p1, uint256 p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,uint256,uint256,uint256)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, uint256 p1, uint256 p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,uint256,uint256,string)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, uint256 p1, uint256 p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,uint256,uint256,bool)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, uint256 p1, uint256 p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,uint256,uint256,address)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, uint256 p1, string memory p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,uint256,string,uint256)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, uint256 p1, string memory p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,uint256,string,string)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, uint256 p1, string memory p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,uint256,string,bool)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, uint256 p1, string memory p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,uint256,string,address)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, uint256 p1, bool p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,uint256,bool,uint256)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, uint256 p1, bool p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,uint256,bool,string)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, uint256 p1, bool p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,uint256,bool,bool)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, uint256 p1, bool p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,uint256,bool,address)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, uint256 p1, address p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,uint256,address,uint256)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, uint256 p1, address p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,uint256,address,string)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, uint256 p1, address p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,uint256,address,bool)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, uint256 p1, address p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,uint256,address,address)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, string memory p1, uint256 p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,string,uint256,uint256)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, string memory p1, uint256 p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,string,uint256,string)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, string memory p1, uint256 p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,string,uint256,bool)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, string memory p1, uint256 p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,string,uint256,address)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, string memory p1, string memory p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,string,string,uint256)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, string memory p1, string memory p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,string,string,string)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, string memory p1, string memory p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,string,string,bool)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, string memory p1, string memory p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,string,string,address)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, string memory p1, bool p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,string,bool,uint256)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, string memory p1, bool p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,string,bool,string)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, string memory p1, bool p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,string,bool,bool)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, string memory p1, bool p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,string,bool,address)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, string memory p1, address p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,string,address,uint256)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, string memory p1, address p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,string,address,string)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, string memory p1, address p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,string,address,bool)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, string memory p1, address p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,string,address,address)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, bool p1, uint256 p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,bool,uint256,uint256)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, bool p1, uint256 p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,bool,uint256,string)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, bool p1, uint256 p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,bool,uint256,bool)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, bool p1, uint256 p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,bool,uint256,address)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, bool p1, string memory p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,bool,string,uint256)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, bool p1, string memory p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,bool,string,string)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, bool p1, string memory p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,bool,string,bool)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, bool p1, string memory p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,bool,string,address)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, bool p1, bool p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,bool,bool,uint256)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, bool p1, bool p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,bool,bool,string)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, bool p1, bool p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,bool,bool,bool)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, bool p1, bool p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,bool,bool,address)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, bool p1, address p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,bool,address,uint256)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, bool p1, address p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,bool,address,string)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, bool p1, address p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,bool,address,bool)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, bool p1, address p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,bool,address,address)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, address p1, uint256 p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,address,uint256,uint256)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, address p1, uint256 p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,address,uint256,string)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, address p1, uint256 p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,address,uint256,bool)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, address p1, uint256 p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,address,uint256,address)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, address p1, string memory p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,address,string,uint256)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, address p1, string memory p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,address,string,string)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, address p1, string memory p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,address,string,bool)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, address p1, string memory p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,address,string,address)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, address p1, bool p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,address,bool,uint256)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, address p1, bool p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,address,bool,string)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, address p1, bool p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,address,bool,bool)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, address p1, bool p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,address,bool,address)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, address p1, address p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,address,address,uint256)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, address p1, address p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,address,address,string)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, address p1, address p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,address,address,bool)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, address p1, address p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,address,address,address)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, uint256 p1, uint256 p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,uint256,uint256,uint256)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, uint256 p1, uint256 p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,uint256,uint256,string)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, uint256 p1, uint256 p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,uint256,uint256,bool)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, uint256 p1, uint256 p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,uint256,uint256,address)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, uint256 p1, string memory p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,uint256,string,uint256)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, uint256 p1, string memory p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,uint256,string,string)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, uint256 p1, string memory p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,uint256,string,bool)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, uint256 p1, string memory p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,uint256,string,address)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, uint256 p1, bool p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,uint256,bool,uint256)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, uint256 p1, bool p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,uint256,bool,string)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, uint256 p1, bool p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,uint256,bool,bool)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, uint256 p1, bool p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,uint256,bool,address)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, uint256 p1, address p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,uint256,address,uint256)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, uint256 p1, address p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,uint256,address,string)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, uint256 p1, address p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,uint256,address,bool)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, uint256 p1, address p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,uint256,address,address)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, string memory p1, uint256 p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,string,uint256,uint256)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, string memory p1, uint256 p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,string,uint256,string)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, string memory p1, uint256 p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,string,uint256,bool)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, string memory p1, uint256 p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,string,uint256,address)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, string memory p1, string memory p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,string,string,uint256)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, string memory p1, string memory p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,string,string,string)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, string memory p1, string memory p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,string,string,bool)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, string memory p1, string memory p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,string,string,address)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, string memory p1, bool p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,string,bool,uint256)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, string memory p1, bool p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,string,bool,string)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, string memory p1, bool p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,string,bool,bool)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, string memory p1, bool p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,string,bool,address)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, string memory p1, address p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,string,address,uint256)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, string memory p1, address p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,string,address,string)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, string memory p1, address p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,string,address,bool)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, string memory p1, address p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,string,address,address)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, bool p1, uint256 p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,bool,uint256,uint256)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, bool p1, uint256 p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,bool,uint256,string)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, bool p1, uint256 p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,bool,uint256,bool)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, bool p1, uint256 p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,bool,uint256,address)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, bool p1, string memory p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,bool,string,uint256)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, bool p1, string memory p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,bool,string,string)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, bool p1, string memory p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,bool,string,bool)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, bool p1, string memory p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,bool,string,address)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, bool p1, bool p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,bool,bool,uint256)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, bool p1, bool p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,bool,bool,string)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, bool p1, bool p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,bool,bool,bool)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, bool p1, bool p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,bool,bool,address)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, bool p1, address p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,bool,address,uint256)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, bool p1, address p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,bool,address,string)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, bool p1, address p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,bool,address,bool)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, bool p1, address p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,bool,address,address)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, address p1, uint256 p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,address,uint256,uint256)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, address p1, uint256 p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,address,uint256,string)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, address p1, uint256 p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,address,uint256,bool)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, address p1, uint256 p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,address,uint256,address)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, address p1, string memory p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,address,string,uint256)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, address p1, string memory p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,address,string,string)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, address p1, string memory p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,address,string,bool)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, address p1, string memory p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,address,string,address)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, address p1, bool p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,address,bool,uint256)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, address p1, bool p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,address,bool,string)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, address p1, bool p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,address,bool,bool)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, address p1, bool p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,address,bool,address)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, address p1, address p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,address,address,uint256)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, address p1, address p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,address,address,string)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, address p1, address p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,address,address,bool)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, address p1, address p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,address,address,address)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, uint256 p1, uint256 p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,uint256,uint256,uint256)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, uint256 p1, uint256 p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,uint256,uint256,string)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, uint256 p1, uint256 p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,uint256,uint256,bool)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, uint256 p1, uint256 p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,uint256,uint256,address)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, uint256 p1, string memory p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,uint256,string,uint256)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, uint256 p1, string memory p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,uint256,string,string)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, uint256 p1, string memory p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,uint256,string,bool)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, uint256 p1, string memory p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,uint256,string,address)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, uint256 p1, bool p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,uint256,bool,uint256)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, uint256 p1, bool p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,uint256,bool,string)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, uint256 p1, bool p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,uint256,bool,bool)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, uint256 p1, bool p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,uint256,bool,address)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, uint256 p1, address p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,uint256,address,uint256)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, uint256 p1, address p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,uint256,address,string)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, uint256 p1, address p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,uint256,address,bool)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, uint256 p1, address p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,uint256,address,address)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, string memory p1, uint256 p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,string,uint256,uint256)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, string memory p1, uint256 p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,string,uint256,string)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, string memory p1, uint256 p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,string,uint256,bool)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, string memory p1, uint256 p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,string,uint256,address)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, string memory p1, string memory p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,string,string,uint256)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, string memory p1, string memory p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,string,string,string)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, string memory p1, string memory p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,string,string,bool)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, string memory p1, string memory p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,string,string,address)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, string memory p1, bool p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,string,bool,uint256)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, string memory p1, bool p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,string,bool,string)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, string memory p1, bool p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,string,bool,bool)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, string memory p1, bool p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,string,bool,address)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, string memory p1, address p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,string,address,uint256)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, string memory p1, address p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,string,address,string)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, string memory p1, address p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,string,address,bool)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, string memory p1, address p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,string,address,address)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, bool p1, uint256 p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,bool,uint256,uint256)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, bool p1, uint256 p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,bool,uint256,string)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, bool p1, uint256 p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,bool,uint256,bool)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, bool p1, uint256 p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,bool,uint256,address)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, bool p1, string memory p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,bool,string,uint256)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, bool p1, string memory p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,bool,string,string)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, bool p1, string memory p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,bool,string,bool)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, bool p1, string memory p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,bool,string,address)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, bool p1, bool p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,bool,bool,uint256)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, bool p1, bool p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,bool,bool,string)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, bool p1, bool p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,bool,bool,bool)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, bool p1, bool p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,bool,bool,address)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, bool p1, address p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,bool,address,uint256)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, bool p1, address p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,bool,address,string)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, bool p1, address p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,bool,address,bool)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, bool p1, address p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,bool,address,address)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, address p1, uint256 p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,address,uint256,uint256)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, address p1, uint256 p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,address,uint256,string)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, address p1, uint256 p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,address,uint256,bool)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, address p1, uint256 p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,address,uint256,address)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, address p1, string memory p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,address,string,uint256)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, address p1, string memory p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,address,string,string)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, address p1, string memory p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,address,string,bool)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, address p1, string memory p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,address,string,address)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, address p1, bool p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,address,bool,uint256)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, address p1, bool p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,address,bool,string)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, address p1, bool p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,address,bool,bool)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, address p1, bool p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,address,bool,address)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, address p1, address p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,address,address,uint256)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, address p1, address p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,address,address,string)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, address p1, address p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,address,address,bool)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, address p1, address p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,address,address,address)\", p0, p1, p2, p3));\n }\n\n function log(address p0, uint256 p1, uint256 p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,uint256,uint256,uint256)\", p0, p1, p2, p3));\n }\n\n function log(address p0, uint256 p1, uint256 p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,uint256,uint256,string)\", p0, p1, p2, p3));\n }\n\n function log(address p0, uint256 p1, uint256 p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,uint256,uint256,bool)\", p0, p1, p2, p3));\n }\n\n function log(address p0, uint256 p1, uint256 p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,uint256,uint256,address)\", p0, p1, p2, p3));\n }\n\n function log(address p0, uint256 p1, string memory p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,uint256,string,uint256)\", p0, p1, p2, p3));\n }\n\n function log(address p0, uint256 p1, string memory p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,uint256,string,string)\", p0, p1, p2, p3));\n }\n\n function log(address p0, uint256 p1, string memory p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,uint256,string,bool)\", p0, p1, p2, p3));\n }\n\n function log(address p0, uint256 p1, string memory p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,uint256,string,address)\", p0, p1, p2, p3));\n }\n\n function log(address p0, uint256 p1, bool p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,uint256,bool,uint256)\", p0, p1, p2, p3));\n }\n\n function log(address p0, uint256 p1, bool p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,uint256,bool,string)\", p0, p1, p2, p3));\n }\n\n function log(address p0, uint256 p1, bool p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,uint256,bool,bool)\", p0, p1, p2, p3));\n }\n\n function log(address p0, uint256 p1, bool p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,uint256,bool,address)\", p0, p1, p2, p3));\n }\n\n function log(address p0, uint256 p1, address p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,uint256,address,uint256)\", p0, p1, p2, p3));\n }\n\n function log(address p0, uint256 p1, address p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,uint256,address,string)\", p0, p1, p2, p3));\n }\n\n function log(address p0, uint256 p1, address p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,uint256,address,bool)\", p0, p1, p2, p3));\n }\n\n function log(address p0, uint256 p1, address p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,uint256,address,address)\", p0, p1, p2, p3));\n }\n\n function log(address p0, string memory p1, uint256 p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,string,uint256,uint256)\", p0, p1, p2, p3));\n }\n\n function log(address p0, string memory p1, uint256 p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,string,uint256,string)\", p0, p1, p2, p3));\n }\n\n function log(address p0, string memory p1, uint256 p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,string,uint256,bool)\", p0, p1, p2, p3));\n }\n\n function log(address p0, string memory p1, uint256 p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,string,uint256,address)\", p0, p1, p2, p3));\n }\n\n function log(address p0, string memory p1, string memory p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,string,string,uint256)\", p0, p1, p2, p3));\n }\n\n function log(address p0, string memory p1, string memory p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,string,string,string)\", p0, p1, p2, p3));\n }\n\n function log(address p0, string memory p1, string memory p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,string,string,bool)\", p0, p1, p2, p3));\n }\n\n function log(address p0, string memory p1, string memory p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,string,string,address)\", p0, p1, p2, p3));\n }\n\n function log(address p0, string memory p1, bool p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,string,bool,uint256)\", p0, p1, p2, p3));\n }\n\n function log(address p0, string memory p1, bool p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,string,bool,string)\", p0, p1, p2, p3));\n }\n\n function log(address p0, string memory p1, bool p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,string,bool,bool)\", p0, p1, p2, p3));\n }\n\n function log(address p0, string memory p1, bool p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,string,bool,address)\", p0, p1, p2, p3));\n }\n\n function log(address p0, string memory p1, address p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,string,address,uint256)\", p0, p1, p2, p3));\n }\n\n function log(address p0, string memory p1, address p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,string,address,string)\", p0, p1, p2, p3));\n }\n\n function log(address p0, string memory p1, address p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,string,address,bool)\", p0, p1, p2, p3));\n }\n\n function log(address p0, string memory p1, address p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,string,address,address)\", p0, p1, p2, p3));\n }\n\n function log(address p0, bool p1, uint256 p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,bool,uint256,uint256)\", p0, p1, p2, p3));\n }\n\n function log(address p0, bool p1, uint256 p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,bool,uint256,string)\", p0, p1, p2, p3));\n }\n\n function log(address p0, bool p1, uint256 p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,bool,uint256,bool)\", p0, p1, p2, p3));\n }\n\n function log(address p0, bool p1, uint256 p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,bool,uint256,address)\", p0, p1, p2, p3));\n }\n\n function log(address p0, bool p1, string memory p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,bool,string,uint256)\", p0, p1, p2, p3));\n }\n\n function log(address p0, bool p1, string memory p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,bool,string,string)\", p0, p1, p2, p3));\n }\n\n function log(address p0, bool p1, string memory p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,bool,string,bool)\", p0, p1, p2, p3));\n }\n\n function log(address p0, bool p1, string memory p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,bool,string,address)\", p0, p1, p2, p3));\n }\n\n function log(address p0, bool p1, bool p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,bool,bool,uint256)\", p0, p1, p2, p3));\n }\n\n function log(address p0, bool p1, bool p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,bool,bool,string)\", p0, p1, p2, p3));\n }\n\n function log(address p0, bool p1, bool p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,bool,bool,bool)\", p0, p1, p2, p3));\n }\n\n function log(address p0, bool p1, bool p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,bool,bool,address)\", p0, p1, p2, p3));\n }\n\n function log(address p0, bool p1, address p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,bool,address,uint256)\", p0, p1, p2, p3));\n }\n\n function log(address p0, bool p1, address p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,bool,address,string)\", p0, p1, p2, p3));\n }\n\n function log(address p0, bool p1, address p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,bool,address,bool)\", p0, p1, p2, p3));\n }\n\n function log(address p0, bool p1, address p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,bool,address,address)\", p0, p1, p2, p3));\n }\n\n function log(address p0, address p1, uint256 p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,address,uint256,uint256)\", p0, p1, p2, p3));\n }\n\n function log(address p0, address p1, uint256 p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,address,uint256,string)\", p0, p1, p2, p3));\n }\n\n function log(address p0, address p1, uint256 p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,address,uint256,bool)\", p0, p1, p2, p3));\n }\n\n function log(address p0, address p1, uint256 p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,address,uint256,address)\", p0, p1, p2, p3));\n }\n\n function log(address p0, address p1, string memory p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,address,string,uint256)\", p0, p1, p2, p3));\n }\n\n function log(address p0, address p1, string memory p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,address,string,string)\", p0, p1, p2, p3));\n }\n\n function log(address p0, address p1, string memory p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,address,string,bool)\", p0, p1, p2, p3));\n }\n\n function log(address p0, address p1, string memory p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,address,string,address)\", p0, p1, p2, p3));\n }\n\n function log(address p0, address p1, bool p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,address,bool,uint256)\", p0, p1, p2, p3));\n }\n\n function log(address p0, address p1, bool p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,address,bool,string)\", p0, p1, p2, p3));\n }\n\n function log(address p0, address p1, bool p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,address,bool,bool)\", p0, p1, p2, p3));\n }\n\n function log(address p0, address p1, bool p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,address,bool,address)\", p0, p1, p2, p3));\n }\n\n function log(address p0, address p1, address p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,address,address,uint256)\", p0, p1, p2, p3));\n }\n\n function log(address p0, address p1, address p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,address,address,string)\", p0, p1, p2, p3));\n }\n\n function log(address p0, address p1, address p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,address,address,bool)\", p0, p1, p2, p3));\n }\n\n function log(address p0, address p1, address p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,address,address,address)\", p0, p1, p2, p3));\n }\n}\n","license":"MIT"},"lib/forge-std/src/console2.sol":{"keccak256":"0x3b8fe79f48f065a4e4d35362171304a33784c3a90febae5f2787805a438de12f","urls":[],"content":"// SPDX-License-Identifier: MIT\npragma solidity >=0.4.22 <0.9.0;\n\nimport {console as console2} from \"./console.sol\";\n","license":"MIT"},"lib/forge-std/src/interfaces/IMulticall3.sol":{"keccak256":"0x7aac1389150499a922d1f9ef5749c908cef127cb2075b92fa17e9cb611263d0a","urls":[],"content":"// SPDX-License-Identifier: MIT\npragma solidity >=0.6.2 <0.9.0;\n\npragma experimental ABIEncoderV2;\n\ninterface IMulticall3 {\n struct Call {\n address target;\n bytes callData;\n }\n\n struct Call3 {\n address target;\n bool allowFailure;\n bytes callData;\n }\n\n struct Call3Value {\n address target;\n bool allowFailure;\n uint256 value;\n bytes callData;\n }\n\n struct Result {\n bool success;\n bytes returnData;\n }\n\n function aggregate(Call[] calldata calls)\n external\n payable\n returns (uint256 blockNumber, bytes[] memory returnData);\n\n function aggregate3(Call3[] calldata calls) external payable returns (Result[] memory returnData);\n\n function aggregate3Value(Call3Value[] calldata calls) external payable returns (Result[] memory returnData);\n\n function blockAndAggregate(Call[] calldata calls)\n external\n payable\n returns (uint256 blockNumber, bytes32 blockHash, Result[] memory returnData);\n\n function getBasefee() external view returns (uint256 basefee);\n\n function getBlockHash(uint256 blockNumber) external view returns (bytes32 blockHash);\n\n function getBlockNumber() external view returns (uint256 blockNumber);\n\n function getChainId() external view returns (uint256 chainid);\n\n function getCurrentBlockCoinbase() external view returns (address coinbase);\n\n function getCurrentBlockDifficulty() external view returns (uint256 difficulty);\n\n function getCurrentBlockGasLimit() external view returns (uint256 gaslimit);\n\n function getCurrentBlockTimestamp() external view returns (uint256 timestamp);\n\n function getEthBalance(address addr) external view returns (uint256 balance);\n\n function getLastBlockHash() external view returns (bytes32 blockHash);\n\n function tryAggregate(bool requireSuccess, Call[] calldata calls)\n external\n payable\n returns (Result[] memory returnData);\n\n function tryBlockAndAggregate(bool requireSuccess, Call[] calldata calls)\n external\n payable\n returns (uint256 blockNumber, bytes32 blockHash, Result[] memory returnData);\n}\n","license":"MIT"},"lib/forge-std/src/safeconsole.sol":{"keccak256":"0xbef9786cb49d3eade757bad87568c49c8c8f35721f0193c95ffb055d9e466e11","urls":[],"content":"// SPDX-License-Identifier: MIT\npragma solidity >=0.6.2 <0.9.0;\n\n/// @author philogy \n/// @dev Code generated automatically by script.\nlibrary safeconsole {\n uint256 constant CONSOLE_ADDR = 0x000000000000000000000000000000000000000000636F6e736F6c652e6c6f67;\n\n // Credit to [0age](https://twitter.com/z0age/status/1654922202930888704) and [0xdapper](https://github.com/foundry-rs/forge-std/pull/374)\n // for the view-to-pure log trick.\n function _sendLogPayload(uint256 offset, uint256 size) private pure {\n function(uint256, uint256) internal view fnIn = _sendLogPayloadView;\n function(uint256, uint256) internal pure pureSendLogPayload;\n /// @solidity memory-safe-assembly\n assembly {\n pureSendLogPayload := fnIn\n }\n pureSendLogPayload(offset, size);\n }\n\n function _sendLogPayloadView(uint256 offset, uint256 size) private view {\n /// @solidity memory-safe-assembly\n assembly {\n pop(staticcall(gas(), CONSOLE_ADDR, offset, size, 0x0, 0x0))\n }\n }\n\n function _memcopy(uint256 fromOffset, uint256 toOffset, uint256 length) private pure {\n function(uint256, uint256, uint256) internal view fnIn = _memcopyView;\n function(uint256, uint256, uint256) internal pure pureMemcopy;\n /// @solidity memory-safe-assembly\n assembly {\n pureMemcopy := fnIn\n }\n pureMemcopy(fromOffset, toOffset, length);\n }\n\n function _memcopyView(uint256 fromOffset, uint256 toOffset, uint256 length) private view {\n /// @solidity memory-safe-assembly\n assembly {\n pop(staticcall(gas(), 0x4, fromOffset, length, toOffset, length))\n }\n }\n\n function logMemory(uint256 offset, uint256 length) internal pure {\n if (offset >= 0x60) {\n // Sufficient memory before slice to prepare call header.\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(sub(offset, 0x60))\n m1 := mload(sub(offset, 0x40))\n m2 := mload(sub(offset, 0x20))\n // Selector of `log(bytes)`.\n mstore(sub(offset, 0x60), 0x0be77f56)\n mstore(sub(offset, 0x40), 0x20)\n mstore(sub(offset, 0x20), length)\n }\n _sendLogPayload(offset - 0x44, length + 0x44);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(sub(offset, 0x60), m0)\n mstore(sub(offset, 0x40), m1)\n mstore(sub(offset, 0x20), m2)\n }\n } else {\n // Insufficient space, so copy slice forward, add header and reverse.\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n uint256 endOffset = offset + length;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(add(endOffset, 0x00))\n m1 := mload(add(endOffset, 0x20))\n m2 := mload(add(endOffset, 0x40))\n }\n _memcopy(offset, offset + 0x60, length);\n /// @solidity memory-safe-assembly\n assembly {\n // Selector of `log(bytes)`.\n mstore(add(offset, 0x00), 0x0be77f56)\n mstore(add(offset, 0x20), 0x20)\n mstore(add(offset, 0x40), length)\n }\n _sendLogPayload(offset + 0x1c, length + 0x44);\n _memcopy(offset + 0x60, offset, length);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(add(endOffset, 0x00), m0)\n mstore(add(endOffset, 0x20), m1)\n mstore(add(endOffset, 0x40), m2)\n }\n }\n }\n\n function log(address p0) internal pure {\n bytes32 m0;\n bytes32 m1;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n // Selector of `log(address)`.\n mstore(0x00, 0x2c2ecbc2)\n mstore(0x20, p0)\n }\n _sendLogPayload(0x1c, 0x24);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n }\n }\n\n function log(bool p0) internal pure {\n bytes32 m0;\n bytes32 m1;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n // Selector of `log(bool)`.\n mstore(0x00, 0x32458eed)\n mstore(0x20, p0)\n }\n _sendLogPayload(0x1c, 0x24);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n }\n }\n\n function log(uint256 p0) internal pure {\n bytes32 m0;\n bytes32 m1;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n // Selector of `log(uint256)`.\n mstore(0x00, 0xf82c50f1)\n mstore(0x20, p0)\n }\n _sendLogPayload(0x1c, 0x24);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n }\n }\n\n function log(bytes32 p0) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n // Selector of `log(string)`.\n mstore(0x00, 0x41304fac)\n mstore(0x20, 0x20)\n writeString(0x40, p0)\n }\n _sendLogPayload(0x1c, 0x64);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n }\n }\n\n function log(address p0, address p1) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n // Selector of `log(address,address)`.\n mstore(0x00, 0xdaf0d4aa)\n mstore(0x20, p0)\n mstore(0x40, p1)\n }\n _sendLogPayload(0x1c, 0x44);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n }\n }\n\n function log(address p0, bool p1) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n // Selector of `log(address,bool)`.\n mstore(0x00, 0x75b605d3)\n mstore(0x20, p0)\n mstore(0x40, p1)\n }\n _sendLogPayload(0x1c, 0x44);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n }\n }\n\n function log(address p0, uint256 p1) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n // Selector of `log(address,uint256)`.\n mstore(0x00, 0x8309e8a8)\n mstore(0x20, p0)\n mstore(0x40, p1)\n }\n _sendLogPayload(0x1c, 0x44);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n }\n }\n\n function log(address p0, bytes32 p1) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(address,string)`.\n mstore(0x00, 0x759f86bb)\n mstore(0x20, p0)\n mstore(0x40, 0x40)\n writeString(0x60, p1)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(bool p0, address p1) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n // Selector of `log(bool,address)`.\n mstore(0x00, 0x853c4849)\n mstore(0x20, p0)\n mstore(0x40, p1)\n }\n _sendLogPayload(0x1c, 0x44);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n }\n }\n\n function log(bool p0, bool p1) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n // Selector of `log(bool,bool)`.\n mstore(0x00, 0x2a110e83)\n mstore(0x20, p0)\n mstore(0x40, p1)\n }\n _sendLogPayload(0x1c, 0x44);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n }\n }\n\n function log(bool p0, uint256 p1) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n // Selector of `log(bool,uint256)`.\n mstore(0x00, 0x399174d3)\n mstore(0x20, p0)\n mstore(0x40, p1)\n }\n _sendLogPayload(0x1c, 0x44);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n }\n }\n\n function log(bool p0, bytes32 p1) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(bool,string)`.\n mstore(0x00, 0x8feac525)\n mstore(0x20, p0)\n mstore(0x40, 0x40)\n writeString(0x60, p1)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(uint256 p0, address p1) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n // Selector of `log(uint256,address)`.\n mstore(0x00, 0x69276c86)\n mstore(0x20, p0)\n mstore(0x40, p1)\n }\n _sendLogPayload(0x1c, 0x44);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n }\n }\n\n function log(uint256 p0, bool p1) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n // Selector of `log(uint256,bool)`.\n mstore(0x00, 0x1c9d7eb3)\n mstore(0x20, p0)\n mstore(0x40, p1)\n }\n _sendLogPayload(0x1c, 0x44);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n }\n }\n\n function log(uint256 p0, uint256 p1) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n // Selector of `log(uint256,uint256)`.\n mstore(0x00, 0xf666715a)\n mstore(0x20, p0)\n mstore(0x40, p1)\n }\n _sendLogPayload(0x1c, 0x44);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n }\n }\n\n function log(uint256 p0, bytes32 p1) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(uint256,string)`.\n mstore(0x00, 0x643fd0df)\n mstore(0x20, p0)\n mstore(0x40, 0x40)\n writeString(0x60, p1)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(bytes32 p0, address p1) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(string,address)`.\n mstore(0x00, 0x319af333)\n mstore(0x20, 0x40)\n mstore(0x40, p1)\n writeString(0x60, p0)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(bytes32 p0, bool p1) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(string,bool)`.\n mstore(0x00, 0xc3b55635)\n mstore(0x20, 0x40)\n mstore(0x40, p1)\n writeString(0x60, p0)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(bytes32 p0, uint256 p1) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(string,uint256)`.\n mstore(0x00, 0xb60e72cc)\n mstore(0x20, 0x40)\n mstore(0x40, p1)\n writeString(0x60, p0)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(bytes32 p0, bytes32 p1) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(string,string)`.\n mstore(0x00, 0x4b5c4277)\n mstore(0x20, 0x40)\n mstore(0x40, 0x80)\n writeString(0x60, p0)\n writeString(0xa0, p1)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(address p0, address p1, address p2) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n // Selector of `log(address,address,address)`.\n mstore(0x00, 0x018c84c2)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n }\n _sendLogPayload(0x1c, 0x64);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n }\n }\n\n function log(address p0, address p1, bool p2) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n // Selector of `log(address,address,bool)`.\n mstore(0x00, 0xf2a66286)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n }\n _sendLogPayload(0x1c, 0x64);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n }\n }\n\n function log(address p0, address p1, uint256 p2) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n // Selector of `log(address,address,uint256)`.\n mstore(0x00, 0x17fe6185)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n }\n _sendLogPayload(0x1c, 0x64);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n }\n }\n\n function log(address p0, address p1, bytes32 p2) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n // Selector of `log(address,address,string)`.\n mstore(0x00, 0x007150be)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, 0x60)\n writeString(0x80, p2)\n }\n _sendLogPayload(0x1c, 0xa4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n }\n }\n\n function log(address p0, bool p1, address p2) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n // Selector of `log(address,bool,address)`.\n mstore(0x00, 0xf11699ed)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n }\n _sendLogPayload(0x1c, 0x64);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n }\n }\n\n function log(address p0, bool p1, bool p2) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n // Selector of `log(address,bool,bool)`.\n mstore(0x00, 0xeb830c92)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n }\n _sendLogPayload(0x1c, 0x64);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n }\n }\n\n function log(address p0, bool p1, uint256 p2) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n // Selector of `log(address,bool,uint256)`.\n mstore(0x00, 0x9c4f99fb)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n }\n _sendLogPayload(0x1c, 0x64);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n }\n }\n\n function log(address p0, bool p1, bytes32 p2) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n // Selector of `log(address,bool,string)`.\n mstore(0x00, 0x212255cc)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, 0x60)\n writeString(0x80, p2)\n }\n _sendLogPayload(0x1c, 0xa4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n }\n }\n\n function log(address p0, uint256 p1, address p2) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n // Selector of `log(address,uint256,address)`.\n mstore(0x00, 0x7bc0d848)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n }\n _sendLogPayload(0x1c, 0x64);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n }\n }\n\n function log(address p0, uint256 p1, bool p2) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n // Selector of `log(address,uint256,bool)`.\n mstore(0x00, 0x678209a8)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n }\n _sendLogPayload(0x1c, 0x64);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n }\n }\n\n function log(address p0, uint256 p1, uint256 p2) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n // Selector of `log(address,uint256,uint256)`.\n mstore(0x00, 0xb69bcaf6)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n }\n _sendLogPayload(0x1c, 0x64);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n }\n }\n\n function log(address p0, uint256 p1, bytes32 p2) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n // Selector of `log(address,uint256,string)`.\n mstore(0x00, 0xa1f2e8aa)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, 0x60)\n writeString(0x80, p2)\n }\n _sendLogPayload(0x1c, 0xa4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n }\n }\n\n function log(address p0, bytes32 p1, address p2) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n // Selector of `log(address,string,address)`.\n mstore(0x00, 0xf08744e8)\n mstore(0x20, p0)\n mstore(0x40, 0x60)\n mstore(0x60, p2)\n writeString(0x80, p1)\n }\n _sendLogPayload(0x1c, 0xa4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n }\n }\n\n function log(address p0, bytes32 p1, bool p2) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n // Selector of `log(address,string,bool)`.\n mstore(0x00, 0xcf020fb1)\n mstore(0x20, p0)\n mstore(0x40, 0x60)\n mstore(0x60, p2)\n writeString(0x80, p1)\n }\n _sendLogPayload(0x1c, 0xa4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n }\n }\n\n function log(address p0, bytes32 p1, uint256 p2) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n // Selector of `log(address,string,uint256)`.\n mstore(0x00, 0x67dd6ff1)\n mstore(0x20, p0)\n mstore(0x40, 0x60)\n mstore(0x60, p2)\n writeString(0x80, p1)\n }\n _sendLogPayload(0x1c, 0xa4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n }\n }\n\n function log(address p0, bytes32 p1, bytes32 p2) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n // Selector of `log(address,string,string)`.\n mstore(0x00, 0xfb772265)\n mstore(0x20, p0)\n mstore(0x40, 0x60)\n mstore(0x60, 0xa0)\n writeString(0x80, p1)\n writeString(0xc0, p2)\n }\n _sendLogPayload(0x1c, 0xe4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n }\n }\n\n function log(bool p0, address p1, address p2) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n // Selector of `log(bool,address,address)`.\n mstore(0x00, 0xd2763667)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n }\n _sendLogPayload(0x1c, 0x64);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n }\n }\n\n function log(bool p0, address p1, bool p2) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n // Selector of `log(bool,address,bool)`.\n mstore(0x00, 0x18c9c746)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n }\n _sendLogPayload(0x1c, 0x64);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n }\n }\n\n function log(bool p0, address p1, uint256 p2) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n // Selector of `log(bool,address,uint256)`.\n mstore(0x00, 0x5f7b9afb)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n }\n _sendLogPayload(0x1c, 0x64);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n }\n }\n\n function log(bool p0, address p1, bytes32 p2) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n // Selector of `log(bool,address,string)`.\n mstore(0x00, 0xde9a9270)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, 0x60)\n writeString(0x80, p2)\n }\n _sendLogPayload(0x1c, 0xa4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n }\n }\n\n function log(bool p0, bool p1, address p2) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n // Selector of `log(bool,bool,address)`.\n mstore(0x00, 0x1078f68d)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n }\n _sendLogPayload(0x1c, 0x64);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n }\n }\n\n function log(bool p0, bool p1, bool p2) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n // Selector of `log(bool,bool,bool)`.\n mstore(0x00, 0x50709698)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n }\n _sendLogPayload(0x1c, 0x64);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n }\n }\n\n function log(bool p0, bool p1, uint256 p2) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n // Selector of `log(bool,bool,uint256)`.\n mstore(0x00, 0x12f21602)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n }\n _sendLogPayload(0x1c, 0x64);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n }\n }\n\n function log(bool p0, bool p1, bytes32 p2) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n // Selector of `log(bool,bool,string)`.\n mstore(0x00, 0x2555fa46)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, 0x60)\n writeString(0x80, p2)\n }\n _sendLogPayload(0x1c, 0xa4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n }\n }\n\n function log(bool p0, uint256 p1, address p2) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n // Selector of `log(bool,uint256,address)`.\n mstore(0x00, 0x088ef9d2)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n }\n _sendLogPayload(0x1c, 0x64);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n }\n }\n\n function log(bool p0, uint256 p1, bool p2) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n // Selector of `log(bool,uint256,bool)`.\n mstore(0x00, 0xe8defba9)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n }\n _sendLogPayload(0x1c, 0x64);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n }\n }\n\n function log(bool p0, uint256 p1, uint256 p2) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n // Selector of `log(bool,uint256,uint256)`.\n mstore(0x00, 0x37103367)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n }\n _sendLogPayload(0x1c, 0x64);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n }\n }\n\n function log(bool p0, uint256 p1, bytes32 p2) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n // Selector of `log(bool,uint256,string)`.\n mstore(0x00, 0xc3fc3970)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, 0x60)\n writeString(0x80, p2)\n }\n _sendLogPayload(0x1c, 0xa4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n }\n }\n\n function log(bool p0, bytes32 p1, address p2) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n // Selector of `log(bool,string,address)`.\n mstore(0x00, 0x9591b953)\n mstore(0x20, p0)\n mstore(0x40, 0x60)\n mstore(0x60, p2)\n writeString(0x80, p1)\n }\n _sendLogPayload(0x1c, 0xa4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n }\n }\n\n function log(bool p0, bytes32 p1, bool p2) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n // Selector of `log(bool,string,bool)`.\n mstore(0x00, 0xdbb4c247)\n mstore(0x20, p0)\n mstore(0x40, 0x60)\n mstore(0x60, p2)\n writeString(0x80, p1)\n }\n _sendLogPayload(0x1c, 0xa4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n }\n }\n\n function log(bool p0, bytes32 p1, uint256 p2) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n // Selector of `log(bool,string,uint256)`.\n mstore(0x00, 0x1093ee11)\n mstore(0x20, p0)\n mstore(0x40, 0x60)\n mstore(0x60, p2)\n writeString(0x80, p1)\n }\n _sendLogPayload(0x1c, 0xa4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n }\n }\n\n function log(bool p0, bytes32 p1, bytes32 p2) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n // Selector of `log(bool,string,string)`.\n mstore(0x00, 0xb076847f)\n mstore(0x20, p0)\n mstore(0x40, 0x60)\n mstore(0x60, 0xa0)\n writeString(0x80, p1)\n writeString(0xc0, p2)\n }\n _sendLogPayload(0x1c, 0xe4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n }\n }\n\n function log(uint256 p0, address p1, address p2) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n // Selector of `log(uint256,address,address)`.\n mstore(0x00, 0xbcfd9be0)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n }\n _sendLogPayload(0x1c, 0x64);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n }\n }\n\n function log(uint256 p0, address p1, bool p2) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n // Selector of `log(uint256,address,bool)`.\n mstore(0x00, 0x9b6ec042)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n }\n _sendLogPayload(0x1c, 0x64);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n }\n }\n\n function log(uint256 p0, address p1, uint256 p2) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n // Selector of `log(uint256,address,uint256)`.\n mstore(0x00, 0x5a9b5ed5)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n }\n _sendLogPayload(0x1c, 0x64);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n }\n }\n\n function log(uint256 p0, address p1, bytes32 p2) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n // Selector of `log(uint256,address,string)`.\n mstore(0x00, 0x63cb41f9)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, 0x60)\n writeString(0x80, p2)\n }\n _sendLogPayload(0x1c, 0xa4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n }\n }\n\n function log(uint256 p0, bool p1, address p2) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n // Selector of `log(uint256,bool,address)`.\n mstore(0x00, 0x35085f7b)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n }\n _sendLogPayload(0x1c, 0x64);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n }\n }\n\n function log(uint256 p0, bool p1, bool p2) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n // Selector of `log(uint256,bool,bool)`.\n mstore(0x00, 0x20718650)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n }\n _sendLogPayload(0x1c, 0x64);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n }\n }\n\n function log(uint256 p0, bool p1, uint256 p2) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n // Selector of `log(uint256,bool,uint256)`.\n mstore(0x00, 0x20098014)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n }\n _sendLogPayload(0x1c, 0x64);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n }\n }\n\n function log(uint256 p0, bool p1, bytes32 p2) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n // Selector of `log(uint256,bool,string)`.\n mstore(0x00, 0x85775021)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, 0x60)\n writeString(0x80, p2)\n }\n _sendLogPayload(0x1c, 0xa4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n }\n }\n\n function log(uint256 p0, uint256 p1, address p2) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n // Selector of `log(uint256,uint256,address)`.\n mstore(0x00, 0x5c96b331)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n }\n _sendLogPayload(0x1c, 0x64);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n }\n }\n\n function log(uint256 p0, uint256 p1, bool p2) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n // Selector of `log(uint256,uint256,bool)`.\n mstore(0x00, 0x4766da72)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n }\n _sendLogPayload(0x1c, 0x64);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n }\n }\n\n function log(uint256 p0, uint256 p1, uint256 p2) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n // Selector of `log(uint256,uint256,uint256)`.\n mstore(0x00, 0xd1ed7a3c)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n }\n _sendLogPayload(0x1c, 0x64);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n }\n }\n\n function log(uint256 p0, uint256 p1, bytes32 p2) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n // Selector of `log(uint256,uint256,string)`.\n mstore(0x00, 0x71d04af2)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, 0x60)\n writeString(0x80, p2)\n }\n _sendLogPayload(0x1c, 0xa4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n }\n }\n\n function log(uint256 p0, bytes32 p1, address p2) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n // Selector of `log(uint256,string,address)`.\n mstore(0x00, 0x7afac959)\n mstore(0x20, p0)\n mstore(0x40, 0x60)\n mstore(0x60, p2)\n writeString(0x80, p1)\n }\n _sendLogPayload(0x1c, 0xa4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n }\n }\n\n function log(uint256 p0, bytes32 p1, bool p2) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n // Selector of `log(uint256,string,bool)`.\n mstore(0x00, 0x4ceda75a)\n mstore(0x20, p0)\n mstore(0x40, 0x60)\n mstore(0x60, p2)\n writeString(0x80, p1)\n }\n _sendLogPayload(0x1c, 0xa4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n }\n }\n\n function log(uint256 p0, bytes32 p1, uint256 p2) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n // Selector of `log(uint256,string,uint256)`.\n mstore(0x00, 0x37aa7d4c)\n mstore(0x20, p0)\n mstore(0x40, 0x60)\n mstore(0x60, p2)\n writeString(0x80, p1)\n }\n _sendLogPayload(0x1c, 0xa4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n }\n }\n\n function log(uint256 p0, bytes32 p1, bytes32 p2) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n // Selector of `log(uint256,string,string)`.\n mstore(0x00, 0xb115611f)\n mstore(0x20, p0)\n mstore(0x40, 0x60)\n mstore(0x60, 0xa0)\n writeString(0x80, p1)\n writeString(0xc0, p2)\n }\n _sendLogPayload(0x1c, 0xe4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n }\n }\n\n function log(bytes32 p0, address p1, address p2) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n // Selector of `log(string,address,address)`.\n mstore(0x00, 0xfcec75e0)\n mstore(0x20, 0x60)\n mstore(0x40, p1)\n mstore(0x60, p2)\n writeString(0x80, p0)\n }\n _sendLogPayload(0x1c, 0xa4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n }\n }\n\n function log(bytes32 p0, address p1, bool p2) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n // Selector of `log(string,address,bool)`.\n mstore(0x00, 0xc91d5ed4)\n mstore(0x20, 0x60)\n mstore(0x40, p1)\n mstore(0x60, p2)\n writeString(0x80, p0)\n }\n _sendLogPayload(0x1c, 0xa4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n }\n }\n\n function log(bytes32 p0, address p1, uint256 p2) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n // Selector of `log(string,address,uint256)`.\n mstore(0x00, 0x0d26b925)\n mstore(0x20, 0x60)\n mstore(0x40, p1)\n mstore(0x60, p2)\n writeString(0x80, p0)\n }\n _sendLogPayload(0x1c, 0xa4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n }\n }\n\n function log(bytes32 p0, address p1, bytes32 p2) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n // Selector of `log(string,address,string)`.\n mstore(0x00, 0xe0e9ad4f)\n mstore(0x20, 0x60)\n mstore(0x40, p1)\n mstore(0x60, 0xa0)\n writeString(0x80, p0)\n writeString(0xc0, p2)\n }\n _sendLogPayload(0x1c, 0xe4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n }\n }\n\n function log(bytes32 p0, bool p1, address p2) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n // Selector of `log(string,bool,address)`.\n mstore(0x00, 0x932bbb38)\n mstore(0x20, 0x60)\n mstore(0x40, p1)\n mstore(0x60, p2)\n writeString(0x80, p0)\n }\n _sendLogPayload(0x1c, 0xa4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n }\n }\n\n function log(bytes32 p0, bool p1, bool p2) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n // Selector of `log(string,bool,bool)`.\n mstore(0x00, 0x850b7ad6)\n mstore(0x20, 0x60)\n mstore(0x40, p1)\n mstore(0x60, p2)\n writeString(0x80, p0)\n }\n _sendLogPayload(0x1c, 0xa4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n }\n }\n\n function log(bytes32 p0, bool p1, uint256 p2) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n // Selector of `log(string,bool,uint256)`.\n mstore(0x00, 0xc95958d6)\n mstore(0x20, 0x60)\n mstore(0x40, p1)\n mstore(0x60, p2)\n writeString(0x80, p0)\n }\n _sendLogPayload(0x1c, 0xa4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n }\n }\n\n function log(bytes32 p0, bool p1, bytes32 p2) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n // Selector of `log(string,bool,string)`.\n mstore(0x00, 0xe298f47d)\n mstore(0x20, 0x60)\n mstore(0x40, p1)\n mstore(0x60, 0xa0)\n writeString(0x80, p0)\n writeString(0xc0, p2)\n }\n _sendLogPayload(0x1c, 0xe4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n }\n }\n\n function log(bytes32 p0, uint256 p1, address p2) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n // Selector of `log(string,uint256,address)`.\n mstore(0x00, 0x1c7ec448)\n mstore(0x20, 0x60)\n mstore(0x40, p1)\n mstore(0x60, p2)\n writeString(0x80, p0)\n }\n _sendLogPayload(0x1c, 0xa4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n }\n }\n\n function log(bytes32 p0, uint256 p1, bool p2) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n // Selector of `log(string,uint256,bool)`.\n mstore(0x00, 0xca7733b1)\n mstore(0x20, 0x60)\n mstore(0x40, p1)\n mstore(0x60, p2)\n writeString(0x80, p0)\n }\n _sendLogPayload(0x1c, 0xa4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n }\n }\n\n function log(bytes32 p0, uint256 p1, uint256 p2) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n // Selector of `log(string,uint256,uint256)`.\n mstore(0x00, 0xca47c4eb)\n mstore(0x20, 0x60)\n mstore(0x40, p1)\n mstore(0x60, p2)\n writeString(0x80, p0)\n }\n _sendLogPayload(0x1c, 0xa4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n }\n }\n\n function log(bytes32 p0, uint256 p1, bytes32 p2) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n // Selector of `log(string,uint256,string)`.\n mstore(0x00, 0x5970e089)\n mstore(0x20, 0x60)\n mstore(0x40, p1)\n mstore(0x60, 0xa0)\n writeString(0x80, p0)\n writeString(0xc0, p2)\n }\n _sendLogPayload(0x1c, 0xe4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n }\n }\n\n function log(bytes32 p0, bytes32 p1, address p2) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n // Selector of `log(string,string,address)`.\n mstore(0x00, 0x95ed0195)\n mstore(0x20, 0x60)\n mstore(0x40, 0xa0)\n mstore(0x60, p2)\n writeString(0x80, p0)\n writeString(0xc0, p1)\n }\n _sendLogPayload(0x1c, 0xe4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n }\n }\n\n function log(bytes32 p0, bytes32 p1, bool p2) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n // Selector of `log(string,string,bool)`.\n mstore(0x00, 0xb0e0f9b5)\n mstore(0x20, 0x60)\n mstore(0x40, 0xa0)\n mstore(0x60, p2)\n writeString(0x80, p0)\n writeString(0xc0, p1)\n }\n _sendLogPayload(0x1c, 0xe4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n }\n }\n\n function log(bytes32 p0, bytes32 p1, uint256 p2) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n // Selector of `log(string,string,uint256)`.\n mstore(0x00, 0x5821efa1)\n mstore(0x20, 0x60)\n mstore(0x40, 0xa0)\n mstore(0x60, p2)\n writeString(0x80, p0)\n writeString(0xc0, p1)\n }\n _sendLogPayload(0x1c, 0xe4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n }\n }\n\n function log(bytes32 p0, bytes32 p1, bytes32 p2) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n bytes32 m9;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n m9 := mload(0x120)\n // Selector of `log(string,string,string)`.\n mstore(0x00, 0x2ced7cef)\n mstore(0x20, 0x60)\n mstore(0x40, 0xa0)\n mstore(0x60, 0xe0)\n writeString(0x80, p0)\n writeString(0xc0, p1)\n writeString(0x100, p2)\n }\n _sendLogPayload(0x1c, 0x124);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n mstore(0x120, m9)\n }\n }\n\n function log(address p0, address p1, address p2, address p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(address,address,address,address)`.\n mstore(0x00, 0x665bf134)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(address p0, address p1, address p2, bool p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(address,address,address,bool)`.\n mstore(0x00, 0x0e378994)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(address p0, address p1, address p2, uint256 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(address,address,address,uint256)`.\n mstore(0x00, 0x94250d77)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(address p0, address p1, address p2, bytes32 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(address,address,address,string)`.\n mstore(0x00, 0xf808da20)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, 0x80)\n writeString(0xa0, p3)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(address p0, address p1, bool p2, address p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(address,address,bool,address)`.\n mstore(0x00, 0x9f1bc36e)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(address p0, address p1, bool p2, bool p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(address,address,bool,bool)`.\n mstore(0x00, 0x2cd4134a)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(address p0, address p1, bool p2, uint256 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(address,address,bool,uint256)`.\n mstore(0x00, 0x3971e78c)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(address p0, address p1, bool p2, bytes32 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(address,address,bool,string)`.\n mstore(0x00, 0xaa6540c8)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, 0x80)\n writeString(0xa0, p3)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(address p0, address p1, uint256 p2, address p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(address,address,uint256,address)`.\n mstore(0x00, 0x8da6def5)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(address p0, address p1, uint256 p2, bool p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(address,address,uint256,bool)`.\n mstore(0x00, 0x9b4254e2)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(address p0, address p1, uint256 p2, uint256 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(address,address,uint256,uint256)`.\n mstore(0x00, 0xbe553481)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(address p0, address p1, uint256 p2, bytes32 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(address,address,uint256,string)`.\n mstore(0x00, 0xfdb4f990)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, 0x80)\n writeString(0xa0, p3)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(address p0, address p1, bytes32 p2, address p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(address,address,string,address)`.\n mstore(0x00, 0x8f736d16)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, 0x80)\n mstore(0x80, p3)\n writeString(0xa0, p2)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(address p0, address p1, bytes32 p2, bool p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(address,address,string,bool)`.\n mstore(0x00, 0x6f1a594e)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, 0x80)\n mstore(0x80, p3)\n writeString(0xa0, p2)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(address p0, address p1, bytes32 p2, uint256 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(address,address,string,uint256)`.\n mstore(0x00, 0xef1cefe7)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, 0x80)\n mstore(0x80, p3)\n writeString(0xa0, p2)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(address p0, address p1, bytes32 p2, bytes32 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n // Selector of `log(address,address,string,string)`.\n mstore(0x00, 0x21bdaf25)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, 0x80)\n mstore(0x80, 0xc0)\n writeString(0xa0, p2)\n writeString(0xe0, p3)\n }\n _sendLogPayload(0x1c, 0x104);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n }\n }\n\n function log(address p0, bool p1, address p2, address p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(address,bool,address,address)`.\n mstore(0x00, 0x660375dd)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(address p0, bool p1, address p2, bool p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(address,bool,address,bool)`.\n mstore(0x00, 0xa6f50b0f)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(address p0, bool p1, address p2, uint256 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(address,bool,address,uint256)`.\n mstore(0x00, 0xa75c59de)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(address p0, bool p1, address p2, bytes32 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(address,bool,address,string)`.\n mstore(0x00, 0x2dd778e6)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, 0x80)\n writeString(0xa0, p3)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(address p0, bool p1, bool p2, address p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(address,bool,bool,address)`.\n mstore(0x00, 0xcf394485)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(address p0, bool p1, bool p2, bool p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(address,bool,bool,bool)`.\n mstore(0x00, 0xcac43479)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(address p0, bool p1, bool p2, uint256 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(address,bool,bool,uint256)`.\n mstore(0x00, 0x8c4e5de6)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(address p0, bool p1, bool p2, bytes32 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(address,bool,bool,string)`.\n mstore(0x00, 0xdfc4a2e8)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, 0x80)\n writeString(0xa0, p3)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(address p0, bool p1, uint256 p2, address p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(address,bool,uint256,address)`.\n mstore(0x00, 0xccf790a1)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(address p0, bool p1, uint256 p2, bool p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(address,bool,uint256,bool)`.\n mstore(0x00, 0xc4643e20)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(address p0, bool p1, uint256 p2, uint256 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(address,bool,uint256,uint256)`.\n mstore(0x00, 0x386ff5f4)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(address p0, bool p1, uint256 p2, bytes32 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(address,bool,uint256,string)`.\n mstore(0x00, 0x0aa6cfad)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, 0x80)\n writeString(0xa0, p3)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(address p0, bool p1, bytes32 p2, address p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(address,bool,string,address)`.\n mstore(0x00, 0x19fd4956)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, 0x80)\n mstore(0x80, p3)\n writeString(0xa0, p2)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(address p0, bool p1, bytes32 p2, bool p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(address,bool,string,bool)`.\n mstore(0x00, 0x50ad461d)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, 0x80)\n mstore(0x80, p3)\n writeString(0xa0, p2)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(address p0, bool p1, bytes32 p2, uint256 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(address,bool,string,uint256)`.\n mstore(0x00, 0x80e6a20b)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, 0x80)\n mstore(0x80, p3)\n writeString(0xa0, p2)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(address p0, bool p1, bytes32 p2, bytes32 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n // Selector of `log(address,bool,string,string)`.\n mstore(0x00, 0x475c5c33)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, 0x80)\n mstore(0x80, 0xc0)\n writeString(0xa0, p2)\n writeString(0xe0, p3)\n }\n _sendLogPayload(0x1c, 0x104);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n }\n }\n\n function log(address p0, uint256 p1, address p2, address p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(address,uint256,address,address)`.\n mstore(0x00, 0x478d1c62)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(address p0, uint256 p1, address p2, bool p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(address,uint256,address,bool)`.\n mstore(0x00, 0xa1bcc9b3)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(address p0, uint256 p1, address p2, uint256 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(address,uint256,address,uint256)`.\n mstore(0x00, 0x100f650e)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(address p0, uint256 p1, address p2, bytes32 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(address,uint256,address,string)`.\n mstore(0x00, 0x1da986ea)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, 0x80)\n writeString(0xa0, p3)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(address p0, uint256 p1, bool p2, address p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(address,uint256,bool,address)`.\n mstore(0x00, 0xa31bfdcc)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(address p0, uint256 p1, bool p2, bool p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(address,uint256,bool,bool)`.\n mstore(0x00, 0x3bf5e537)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(address p0, uint256 p1, bool p2, uint256 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(address,uint256,bool,uint256)`.\n mstore(0x00, 0x22f6b999)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(address p0, uint256 p1, bool p2, bytes32 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(address,uint256,bool,string)`.\n mstore(0x00, 0xc5ad85f9)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, 0x80)\n writeString(0xa0, p3)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(address p0, uint256 p1, uint256 p2, address p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(address,uint256,uint256,address)`.\n mstore(0x00, 0x20e3984d)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(address p0, uint256 p1, uint256 p2, bool p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(address,uint256,uint256,bool)`.\n mstore(0x00, 0x66f1bc67)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(address p0, uint256 p1, uint256 p2, uint256 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(address,uint256,uint256,uint256)`.\n mstore(0x00, 0x34f0e636)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(address p0, uint256 p1, uint256 p2, bytes32 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(address,uint256,uint256,string)`.\n mstore(0x00, 0x4a28c017)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, 0x80)\n writeString(0xa0, p3)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(address p0, uint256 p1, bytes32 p2, address p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(address,uint256,string,address)`.\n mstore(0x00, 0x5c430d47)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, 0x80)\n mstore(0x80, p3)\n writeString(0xa0, p2)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(address p0, uint256 p1, bytes32 p2, bool p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(address,uint256,string,bool)`.\n mstore(0x00, 0xcf18105c)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, 0x80)\n mstore(0x80, p3)\n writeString(0xa0, p2)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(address p0, uint256 p1, bytes32 p2, uint256 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(address,uint256,string,uint256)`.\n mstore(0x00, 0xbf01f891)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, 0x80)\n mstore(0x80, p3)\n writeString(0xa0, p2)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(address p0, uint256 p1, bytes32 p2, bytes32 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n // Selector of `log(address,uint256,string,string)`.\n mstore(0x00, 0x88a8c406)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, 0x80)\n mstore(0x80, 0xc0)\n writeString(0xa0, p2)\n writeString(0xe0, p3)\n }\n _sendLogPayload(0x1c, 0x104);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n }\n }\n\n function log(address p0, bytes32 p1, address p2, address p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(address,string,address,address)`.\n mstore(0x00, 0x0d36fa20)\n mstore(0x20, p0)\n mstore(0x40, 0x80)\n mstore(0x60, p2)\n mstore(0x80, p3)\n writeString(0xa0, p1)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(address p0, bytes32 p1, address p2, bool p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(address,string,address,bool)`.\n mstore(0x00, 0x0df12b76)\n mstore(0x20, p0)\n mstore(0x40, 0x80)\n mstore(0x60, p2)\n mstore(0x80, p3)\n writeString(0xa0, p1)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(address p0, bytes32 p1, address p2, uint256 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(address,string,address,uint256)`.\n mstore(0x00, 0x457fe3cf)\n mstore(0x20, p0)\n mstore(0x40, 0x80)\n mstore(0x60, p2)\n mstore(0x80, p3)\n writeString(0xa0, p1)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(address p0, bytes32 p1, address p2, bytes32 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n // Selector of `log(address,string,address,string)`.\n mstore(0x00, 0xf7e36245)\n mstore(0x20, p0)\n mstore(0x40, 0x80)\n mstore(0x60, p2)\n mstore(0x80, 0xc0)\n writeString(0xa0, p1)\n writeString(0xe0, p3)\n }\n _sendLogPayload(0x1c, 0x104);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n }\n }\n\n function log(address p0, bytes32 p1, bool p2, address p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(address,string,bool,address)`.\n mstore(0x00, 0x205871c2)\n mstore(0x20, p0)\n mstore(0x40, 0x80)\n mstore(0x60, p2)\n mstore(0x80, p3)\n writeString(0xa0, p1)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(address p0, bytes32 p1, bool p2, bool p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(address,string,bool,bool)`.\n mstore(0x00, 0x5f1d5c9f)\n mstore(0x20, p0)\n mstore(0x40, 0x80)\n mstore(0x60, p2)\n mstore(0x80, p3)\n writeString(0xa0, p1)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(address p0, bytes32 p1, bool p2, uint256 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(address,string,bool,uint256)`.\n mstore(0x00, 0x515e38b6)\n mstore(0x20, p0)\n mstore(0x40, 0x80)\n mstore(0x60, p2)\n mstore(0x80, p3)\n writeString(0xa0, p1)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(address p0, bytes32 p1, bool p2, bytes32 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n // Selector of `log(address,string,bool,string)`.\n mstore(0x00, 0xbc0b61fe)\n mstore(0x20, p0)\n mstore(0x40, 0x80)\n mstore(0x60, p2)\n mstore(0x80, 0xc0)\n writeString(0xa0, p1)\n writeString(0xe0, p3)\n }\n _sendLogPayload(0x1c, 0x104);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n }\n }\n\n function log(address p0, bytes32 p1, uint256 p2, address p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(address,string,uint256,address)`.\n mstore(0x00, 0x63183678)\n mstore(0x20, p0)\n mstore(0x40, 0x80)\n mstore(0x60, p2)\n mstore(0x80, p3)\n writeString(0xa0, p1)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(address p0, bytes32 p1, uint256 p2, bool p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(address,string,uint256,bool)`.\n mstore(0x00, 0x0ef7e050)\n mstore(0x20, p0)\n mstore(0x40, 0x80)\n mstore(0x60, p2)\n mstore(0x80, p3)\n writeString(0xa0, p1)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(address p0, bytes32 p1, uint256 p2, uint256 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(address,string,uint256,uint256)`.\n mstore(0x00, 0x1dc8e1b8)\n mstore(0x20, p0)\n mstore(0x40, 0x80)\n mstore(0x60, p2)\n mstore(0x80, p3)\n writeString(0xa0, p1)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(address p0, bytes32 p1, uint256 p2, bytes32 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n // Selector of `log(address,string,uint256,string)`.\n mstore(0x00, 0x448830a8)\n mstore(0x20, p0)\n mstore(0x40, 0x80)\n mstore(0x60, p2)\n mstore(0x80, 0xc0)\n writeString(0xa0, p1)\n writeString(0xe0, p3)\n }\n _sendLogPayload(0x1c, 0x104);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n }\n }\n\n function log(address p0, bytes32 p1, bytes32 p2, address p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n // Selector of `log(address,string,string,address)`.\n mstore(0x00, 0xa04e2f87)\n mstore(0x20, p0)\n mstore(0x40, 0x80)\n mstore(0x60, 0xc0)\n mstore(0x80, p3)\n writeString(0xa0, p1)\n writeString(0xe0, p2)\n }\n _sendLogPayload(0x1c, 0x104);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n }\n }\n\n function log(address p0, bytes32 p1, bytes32 p2, bool p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n // Selector of `log(address,string,string,bool)`.\n mstore(0x00, 0x35a5071f)\n mstore(0x20, p0)\n mstore(0x40, 0x80)\n mstore(0x60, 0xc0)\n mstore(0x80, p3)\n writeString(0xa0, p1)\n writeString(0xe0, p2)\n }\n _sendLogPayload(0x1c, 0x104);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n }\n }\n\n function log(address p0, bytes32 p1, bytes32 p2, uint256 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n // Selector of `log(address,string,string,uint256)`.\n mstore(0x00, 0x159f8927)\n mstore(0x20, p0)\n mstore(0x40, 0x80)\n mstore(0x60, 0xc0)\n mstore(0x80, p3)\n writeString(0xa0, p1)\n writeString(0xe0, p2)\n }\n _sendLogPayload(0x1c, 0x104);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n }\n }\n\n function log(address p0, bytes32 p1, bytes32 p2, bytes32 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n bytes32 m9;\n bytes32 m10;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n m9 := mload(0x120)\n m10 := mload(0x140)\n // Selector of `log(address,string,string,string)`.\n mstore(0x00, 0x5d02c50b)\n mstore(0x20, p0)\n mstore(0x40, 0x80)\n mstore(0x60, 0xc0)\n mstore(0x80, 0x100)\n writeString(0xa0, p1)\n writeString(0xe0, p2)\n writeString(0x120, p3)\n }\n _sendLogPayload(0x1c, 0x144);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n mstore(0x120, m9)\n mstore(0x140, m10)\n }\n }\n\n function log(bool p0, address p1, address p2, address p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(bool,address,address,address)`.\n mstore(0x00, 0x1d14d001)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(bool p0, address p1, address p2, bool p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(bool,address,address,bool)`.\n mstore(0x00, 0x46600be0)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(bool p0, address p1, address p2, uint256 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(bool,address,address,uint256)`.\n mstore(0x00, 0x0c66d1be)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(bool p0, address p1, address p2, bytes32 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(bool,address,address,string)`.\n mstore(0x00, 0xd812a167)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, 0x80)\n writeString(0xa0, p3)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(bool p0, address p1, bool p2, address p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(bool,address,bool,address)`.\n mstore(0x00, 0x1c41a336)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(bool p0, address p1, bool p2, bool p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(bool,address,bool,bool)`.\n mstore(0x00, 0x6a9c478b)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(bool p0, address p1, bool p2, uint256 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(bool,address,bool,uint256)`.\n mstore(0x00, 0x07831502)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(bool p0, address p1, bool p2, bytes32 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(bool,address,bool,string)`.\n mstore(0x00, 0x4a66cb34)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, 0x80)\n writeString(0xa0, p3)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(bool p0, address p1, uint256 p2, address p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(bool,address,uint256,address)`.\n mstore(0x00, 0x136b05dd)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(bool p0, address p1, uint256 p2, bool p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(bool,address,uint256,bool)`.\n mstore(0x00, 0xd6019f1c)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(bool p0, address p1, uint256 p2, uint256 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(bool,address,uint256,uint256)`.\n mstore(0x00, 0x7bf181a1)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(bool p0, address p1, uint256 p2, bytes32 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(bool,address,uint256,string)`.\n mstore(0x00, 0x51f09ff8)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, 0x80)\n writeString(0xa0, p3)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(bool p0, address p1, bytes32 p2, address p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(bool,address,string,address)`.\n mstore(0x00, 0x6f7c603e)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, 0x80)\n mstore(0x80, p3)\n writeString(0xa0, p2)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(bool p0, address p1, bytes32 p2, bool p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(bool,address,string,bool)`.\n mstore(0x00, 0xe2bfd60b)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, 0x80)\n mstore(0x80, p3)\n writeString(0xa0, p2)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(bool p0, address p1, bytes32 p2, uint256 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(bool,address,string,uint256)`.\n mstore(0x00, 0xc21f64c7)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, 0x80)\n mstore(0x80, p3)\n writeString(0xa0, p2)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(bool p0, address p1, bytes32 p2, bytes32 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n // Selector of `log(bool,address,string,string)`.\n mstore(0x00, 0xa73c1db6)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, 0x80)\n mstore(0x80, 0xc0)\n writeString(0xa0, p2)\n writeString(0xe0, p3)\n }\n _sendLogPayload(0x1c, 0x104);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n }\n }\n\n function log(bool p0, bool p1, address p2, address p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(bool,bool,address,address)`.\n mstore(0x00, 0xf4880ea4)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(bool p0, bool p1, address p2, bool p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(bool,bool,address,bool)`.\n mstore(0x00, 0xc0a302d8)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(bool p0, bool p1, address p2, uint256 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(bool,bool,address,uint256)`.\n mstore(0x00, 0x4c123d57)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(bool p0, bool p1, address p2, bytes32 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(bool,bool,address,string)`.\n mstore(0x00, 0xa0a47963)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, 0x80)\n writeString(0xa0, p3)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(bool p0, bool p1, bool p2, address p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(bool,bool,bool,address)`.\n mstore(0x00, 0x8c329b1a)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(bool p0, bool p1, bool p2, bool p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(bool,bool,bool,bool)`.\n mstore(0x00, 0x3b2a5ce0)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(bool p0, bool p1, bool p2, uint256 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(bool,bool,bool,uint256)`.\n mstore(0x00, 0x6d7045c1)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(bool p0, bool p1, bool p2, bytes32 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(bool,bool,bool,string)`.\n mstore(0x00, 0x2ae408d4)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, 0x80)\n writeString(0xa0, p3)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(bool p0, bool p1, uint256 p2, address p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(bool,bool,uint256,address)`.\n mstore(0x00, 0x54a7a9a0)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(bool p0, bool p1, uint256 p2, bool p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(bool,bool,uint256,bool)`.\n mstore(0x00, 0x619e4d0e)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(bool p0, bool p1, uint256 p2, uint256 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(bool,bool,uint256,uint256)`.\n mstore(0x00, 0x0bb00eab)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(bool p0, bool p1, uint256 p2, bytes32 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(bool,bool,uint256,string)`.\n mstore(0x00, 0x7dd4d0e0)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, 0x80)\n writeString(0xa0, p3)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(bool p0, bool p1, bytes32 p2, address p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(bool,bool,string,address)`.\n mstore(0x00, 0xf9ad2b89)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, 0x80)\n mstore(0x80, p3)\n writeString(0xa0, p2)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(bool p0, bool p1, bytes32 p2, bool p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(bool,bool,string,bool)`.\n mstore(0x00, 0xb857163a)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, 0x80)\n mstore(0x80, p3)\n writeString(0xa0, p2)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(bool p0, bool p1, bytes32 p2, uint256 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(bool,bool,string,uint256)`.\n mstore(0x00, 0xe3a9ca2f)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, 0x80)\n mstore(0x80, p3)\n writeString(0xa0, p2)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(bool p0, bool p1, bytes32 p2, bytes32 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n // Selector of `log(bool,bool,string,string)`.\n mstore(0x00, 0x6d1e8751)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, 0x80)\n mstore(0x80, 0xc0)\n writeString(0xa0, p2)\n writeString(0xe0, p3)\n }\n _sendLogPayload(0x1c, 0x104);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n }\n }\n\n function log(bool p0, uint256 p1, address p2, address p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(bool,uint256,address,address)`.\n mstore(0x00, 0x26f560a8)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(bool p0, uint256 p1, address p2, bool p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(bool,uint256,address,bool)`.\n mstore(0x00, 0xb4c314ff)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(bool p0, uint256 p1, address p2, uint256 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(bool,uint256,address,uint256)`.\n mstore(0x00, 0x1537dc87)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(bool p0, uint256 p1, address p2, bytes32 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(bool,uint256,address,string)`.\n mstore(0x00, 0x1bb3b09a)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, 0x80)\n writeString(0xa0, p3)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(bool p0, uint256 p1, bool p2, address p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(bool,uint256,bool,address)`.\n mstore(0x00, 0x9acd3616)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(bool p0, uint256 p1, bool p2, bool p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(bool,uint256,bool,bool)`.\n mstore(0x00, 0xceb5f4d7)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(bool p0, uint256 p1, bool p2, uint256 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(bool,uint256,bool,uint256)`.\n mstore(0x00, 0x7f9bbca2)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(bool p0, uint256 p1, bool p2, bytes32 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(bool,uint256,bool,string)`.\n mstore(0x00, 0x9143dbb1)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, 0x80)\n writeString(0xa0, p3)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(bool p0, uint256 p1, uint256 p2, address p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(bool,uint256,uint256,address)`.\n mstore(0x00, 0x00dd87b9)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(bool p0, uint256 p1, uint256 p2, bool p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(bool,uint256,uint256,bool)`.\n mstore(0x00, 0xbe984353)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(bool p0, uint256 p1, uint256 p2, uint256 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(bool,uint256,uint256,uint256)`.\n mstore(0x00, 0x374bb4b2)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(bool p0, uint256 p1, uint256 p2, bytes32 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(bool,uint256,uint256,string)`.\n mstore(0x00, 0x8e69fb5d)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, 0x80)\n writeString(0xa0, p3)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(bool p0, uint256 p1, bytes32 p2, address p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(bool,uint256,string,address)`.\n mstore(0x00, 0xfedd1fff)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, 0x80)\n mstore(0x80, p3)\n writeString(0xa0, p2)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(bool p0, uint256 p1, bytes32 p2, bool p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(bool,uint256,string,bool)`.\n mstore(0x00, 0xe5e70b2b)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, 0x80)\n mstore(0x80, p3)\n writeString(0xa0, p2)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(bool p0, uint256 p1, bytes32 p2, uint256 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(bool,uint256,string,uint256)`.\n mstore(0x00, 0x6a1199e2)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, 0x80)\n mstore(0x80, p3)\n writeString(0xa0, p2)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(bool p0, uint256 p1, bytes32 p2, bytes32 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n // Selector of `log(bool,uint256,string,string)`.\n mstore(0x00, 0xf5bc2249)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, 0x80)\n mstore(0x80, 0xc0)\n writeString(0xa0, p2)\n writeString(0xe0, p3)\n }\n _sendLogPayload(0x1c, 0x104);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n }\n }\n\n function log(bool p0, bytes32 p1, address p2, address p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(bool,string,address,address)`.\n mstore(0x00, 0x2b2b18dc)\n mstore(0x20, p0)\n mstore(0x40, 0x80)\n mstore(0x60, p2)\n mstore(0x80, p3)\n writeString(0xa0, p1)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(bool p0, bytes32 p1, address p2, bool p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(bool,string,address,bool)`.\n mstore(0x00, 0x6dd434ca)\n mstore(0x20, p0)\n mstore(0x40, 0x80)\n mstore(0x60, p2)\n mstore(0x80, p3)\n writeString(0xa0, p1)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(bool p0, bytes32 p1, address p2, uint256 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(bool,string,address,uint256)`.\n mstore(0x00, 0xa5cada94)\n mstore(0x20, p0)\n mstore(0x40, 0x80)\n mstore(0x60, p2)\n mstore(0x80, p3)\n writeString(0xa0, p1)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(bool p0, bytes32 p1, address p2, bytes32 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n // Selector of `log(bool,string,address,string)`.\n mstore(0x00, 0x12d6c788)\n mstore(0x20, p0)\n mstore(0x40, 0x80)\n mstore(0x60, p2)\n mstore(0x80, 0xc0)\n writeString(0xa0, p1)\n writeString(0xe0, p3)\n }\n _sendLogPayload(0x1c, 0x104);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n }\n }\n\n function log(bool p0, bytes32 p1, bool p2, address p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(bool,string,bool,address)`.\n mstore(0x00, 0x538e06ab)\n mstore(0x20, p0)\n mstore(0x40, 0x80)\n mstore(0x60, p2)\n mstore(0x80, p3)\n writeString(0xa0, p1)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(bool p0, bytes32 p1, bool p2, bool p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(bool,string,bool,bool)`.\n mstore(0x00, 0xdc5e935b)\n mstore(0x20, p0)\n mstore(0x40, 0x80)\n mstore(0x60, p2)\n mstore(0x80, p3)\n writeString(0xa0, p1)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(bool p0, bytes32 p1, bool p2, uint256 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(bool,string,bool,uint256)`.\n mstore(0x00, 0x1606a393)\n mstore(0x20, p0)\n mstore(0x40, 0x80)\n mstore(0x60, p2)\n mstore(0x80, p3)\n writeString(0xa0, p1)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(bool p0, bytes32 p1, bool p2, bytes32 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n // Selector of `log(bool,string,bool,string)`.\n mstore(0x00, 0x483d0416)\n mstore(0x20, p0)\n mstore(0x40, 0x80)\n mstore(0x60, p2)\n mstore(0x80, 0xc0)\n writeString(0xa0, p1)\n writeString(0xe0, p3)\n }\n _sendLogPayload(0x1c, 0x104);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n }\n }\n\n function log(bool p0, bytes32 p1, uint256 p2, address p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(bool,string,uint256,address)`.\n mstore(0x00, 0x1596a1ce)\n mstore(0x20, p0)\n mstore(0x40, 0x80)\n mstore(0x60, p2)\n mstore(0x80, p3)\n writeString(0xa0, p1)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(bool p0, bytes32 p1, uint256 p2, bool p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(bool,string,uint256,bool)`.\n mstore(0x00, 0x6b0e5d53)\n mstore(0x20, p0)\n mstore(0x40, 0x80)\n mstore(0x60, p2)\n mstore(0x80, p3)\n writeString(0xa0, p1)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(bool p0, bytes32 p1, uint256 p2, uint256 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(bool,string,uint256,uint256)`.\n mstore(0x00, 0x28863fcb)\n mstore(0x20, p0)\n mstore(0x40, 0x80)\n mstore(0x60, p2)\n mstore(0x80, p3)\n writeString(0xa0, p1)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(bool p0, bytes32 p1, uint256 p2, bytes32 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n // Selector of `log(bool,string,uint256,string)`.\n mstore(0x00, 0x1ad96de6)\n mstore(0x20, p0)\n mstore(0x40, 0x80)\n mstore(0x60, p2)\n mstore(0x80, 0xc0)\n writeString(0xa0, p1)\n writeString(0xe0, p3)\n }\n _sendLogPayload(0x1c, 0x104);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n }\n }\n\n function log(bool p0, bytes32 p1, bytes32 p2, address p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n // Selector of `log(bool,string,string,address)`.\n mstore(0x00, 0x97d394d8)\n mstore(0x20, p0)\n mstore(0x40, 0x80)\n mstore(0x60, 0xc0)\n mstore(0x80, p3)\n writeString(0xa0, p1)\n writeString(0xe0, p2)\n }\n _sendLogPayload(0x1c, 0x104);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n }\n }\n\n function log(bool p0, bytes32 p1, bytes32 p2, bool p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n // Selector of `log(bool,string,string,bool)`.\n mstore(0x00, 0x1e4b87e5)\n mstore(0x20, p0)\n mstore(0x40, 0x80)\n mstore(0x60, 0xc0)\n mstore(0x80, p3)\n writeString(0xa0, p1)\n writeString(0xe0, p2)\n }\n _sendLogPayload(0x1c, 0x104);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n }\n }\n\n function log(bool p0, bytes32 p1, bytes32 p2, uint256 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n // Selector of `log(bool,string,string,uint256)`.\n mstore(0x00, 0x7be0c3eb)\n mstore(0x20, p0)\n mstore(0x40, 0x80)\n mstore(0x60, 0xc0)\n mstore(0x80, p3)\n writeString(0xa0, p1)\n writeString(0xe0, p2)\n }\n _sendLogPayload(0x1c, 0x104);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n }\n }\n\n function log(bool p0, bytes32 p1, bytes32 p2, bytes32 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n bytes32 m9;\n bytes32 m10;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n m9 := mload(0x120)\n m10 := mload(0x140)\n // Selector of `log(bool,string,string,string)`.\n mstore(0x00, 0x1762e32a)\n mstore(0x20, p0)\n mstore(0x40, 0x80)\n mstore(0x60, 0xc0)\n mstore(0x80, 0x100)\n writeString(0xa0, p1)\n writeString(0xe0, p2)\n writeString(0x120, p3)\n }\n _sendLogPayload(0x1c, 0x144);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n mstore(0x120, m9)\n mstore(0x140, m10)\n }\n }\n\n function log(uint256 p0, address p1, address p2, address p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(uint256,address,address,address)`.\n mstore(0x00, 0x2488b414)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(uint256 p0, address p1, address p2, bool p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(uint256,address,address,bool)`.\n mstore(0x00, 0x091ffaf5)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(uint256 p0, address p1, address p2, uint256 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(uint256,address,address,uint256)`.\n mstore(0x00, 0x736efbb6)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(uint256 p0, address p1, address p2, bytes32 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(uint256,address,address,string)`.\n mstore(0x00, 0x031c6f73)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, 0x80)\n writeString(0xa0, p3)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(uint256 p0, address p1, bool p2, address p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(uint256,address,bool,address)`.\n mstore(0x00, 0xef72c513)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(uint256 p0, address p1, bool p2, bool p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(uint256,address,bool,bool)`.\n mstore(0x00, 0xe351140f)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(uint256 p0, address p1, bool p2, uint256 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(uint256,address,bool,uint256)`.\n mstore(0x00, 0x5abd992a)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(uint256 p0, address p1, bool p2, bytes32 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(uint256,address,bool,string)`.\n mstore(0x00, 0x90fb06aa)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, 0x80)\n writeString(0xa0, p3)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(uint256 p0, address p1, uint256 p2, address p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(uint256,address,uint256,address)`.\n mstore(0x00, 0x15c127b5)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(uint256 p0, address p1, uint256 p2, bool p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(uint256,address,uint256,bool)`.\n mstore(0x00, 0x5f743a7c)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(uint256 p0, address p1, uint256 p2, uint256 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(uint256,address,uint256,uint256)`.\n mstore(0x00, 0x0c9cd9c1)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(uint256 p0, address p1, uint256 p2, bytes32 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(uint256,address,uint256,string)`.\n mstore(0x00, 0xddb06521)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, 0x80)\n writeString(0xa0, p3)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(uint256 p0, address p1, bytes32 p2, address p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(uint256,address,string,address)`.\n mstore(0x00, 0x9cba8fff)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, 0x80)\n mstore(0x80, p3)\n writeString(0xa0, p2)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(uint256 p0, address p1, bytes32 p2, bool p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(uint256,address,string,bool)`.\n mstore(0x00, 0xcc32ab07)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, 0x80)\n mstore(0x80, p3)\n writeString(0xa0, p2)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(uint256 p0, address p1, bytes32 p2, uint256 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(uint256,address,string,uint256)`.\n mstore(0x00, 0x46826b5d)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, 0x80)\n mstore(0x80, p3)\n writeString(0xa0, p2)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(uint256 p0, address p1, bytes32 p2, bytes32 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n // Selector of `log(uint256,address,string,string)`.\n mstore(0x00, 0x3e128ca3)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, 0x80)\n mstore(0x80, 0xc0)\n writeString(0xa0, p2)\n writeString(0xe0, p3)\n }\n _sendLogPayload(0x1c, 0x104);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n }\n }\n\n function log(uint256 p0, bool p1, address p2, address p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(uint256,bool,address,address)`.\n mstore(0x00, 0xa1ef4cbb)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(uint256 p0, bool p1, address p2, bool p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(uint256,bool,address,bool)`.\n mstore(0x00, 0x454d54a5)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(uint256 p0, bool p1, address p2, uint256 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(uint256,bool,address,uint256)`.\n mstore(0x00, 0x078287f5)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(uint256 p0, bool p1, address p2, bytes32 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(uint256,bool,address,string)`.\n mstore(0x00, 0xade052c7)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, 0x80)\n writeString(0xa0, p3)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(uint256 p0, bool p1, bool p2, address p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(uint256,bool,bool,address)`.\n mstore(0x00, 0x69640b59)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(uint256 p0, bool p1, bool p2, bool p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(uint256,bool,bool,bool)`.\n mstore(0x00, 0xb6f577a1)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(uint256 p0, bool p1, bool p2, uint256 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(uint256,bool,bool,uint256)`.\n mstore(0x00, 0x7464ce23)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(uint256 p0, bool p1, bool p2, bytes32 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(uint256,bool,bool,string)`.\n mstore(0x00, 0xdddb9561)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, 0x80)\n writeString(0xa0, p3)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(uint256 p0, bool p1, uint256 p2, address p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(uint256,bool,uint256,address)`.\n mstore(0x00, 0x88cb6041)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(uint256 p0, bool p1, uint256 p2, bool p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(uint256,bool,uint256,bool)`.\n mstore(0x00, 0x91a02e2a)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(uint256 p0, bool p1, uint256 p2, uint256 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(uint256,bool,uint256,uint256)`.\n mstore(0x00, 0xc6acc7a8)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(uint256 p0, bool p1, uint256 p2, bytes32 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(uint256,bool,uint256,string)`.\n mstore(0x00, 0xde03e774)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, 0x80)\n writeString(0xa0, p3)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(uint256 p0, bool p1, bytes32 p2, address p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(uint256,bool,string,address)`.\n mstore(0x00, 0xef529018)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, 0x80)\n mstore(0x80, p3)\n writeString(0xa0, p2)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(uint256 p0, bool p1, bytes32 p2, bool p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(uint256,bool,string,bool)`.\n mstore(0x00, 0xeb928d7f)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, 0x80)\n mstore(0x80, p3)\n writeString(0xa0, p2)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(uint256 p0, bool p1, bytes32 p2, uint256 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(uint256,bool,string,uint256)`.\n mstore(0x00, 0x2c1d0746)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, 0x80)\n mstore(0x80, p3)\n writeString(0xa0, p2)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(uint256 p0, bool p1, bytes32 p2, bytes32 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n // Selector of `log(uint256,bool,string,string)`.\n mstore(0x00, 0x68c8b8bd)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, 0x80)\n mstore(0x80, 0xc0)\n writeString(0xa0, p2)\n writeString(0xe0, p3)\n }\n _sendLogPayload(0x1c, 0x104);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n }\n }\n\n function log(uint256 p0, uint256 p1, address p2, address p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(uint256,uint256,address,address)`.\n mstore(0x00, 0x56a5d1b1)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(uint256 p0, uint256 p1, address p2, bool p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(uint256,uint256,address,bool)`.\n mstore(0x00, 0x15cac476)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(uint256 p0, uint256 p1, address p2, uint256 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(uint256,uint256,address,uint256)`.\n mstore(0x00, 0x88f6e4b2)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(uint256 p0, uint256 p1, address p2, bytes32 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(uint256,uint256,address,string)`.\n mstore(0x00, 0x6cde40b8)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, 0x80)\n writeString(0xa0, p3)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(uint256 p0, uint256 p1, bool p2, address p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(uint256,uint256,bool,address)`.\n mstore(0x00, 0x9a816a83)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(uint256 p0, uint256 p1, bool p2, bool p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(uint256,uint256,bool,bool)`.\n mstore(0x00, 0xab085ae6)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(uint256 p0, uint256 p1, bool p2, uint256 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(uint256,uint256,bool,uint256)`.\n mstore(0x00, 0xeb7f6fd2)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(uint256 p0, uint256 p1, bool p2, bytes32 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(uint256,uint256,bool,string)`.\n mstore(0x00, 0xa5b4fc99)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, 0x80)\n writeString(0xa0, p3)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(uint256 p0, uint256 p1, uint256 p2, address p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(uint256,uint256,uint256,address)`.\n mstore(0x00, 0xfa8185af)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(uint256 p0, uint256 p1, uint256 p2, bool p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(uint256,uint256,uint256,bool)`.\n mstore(0x00, 0xc598d185)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(uint256 p0, uint256 p1, uint256 p2, uint256 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(uint256,uint256,uint256,uint256)`.\n mstore(0x00, 0x193fb800)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(uint256 p0, uint256 p1, uint256 p2, bytes32 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(uint256,uint256,uint256,string)`.\n mstore(0x00, 0x59cfcbe3)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, 0x80)\n writeString(0xa0, p3)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(uint256 p0, uint256 p1, bytes32 p2, address p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(uint256,uint256,string,address)`.\n mstore(0x00, 0x42d21db7)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, 0x80)\n mstore(0x80, p3)\n writeString(0xa0, p2)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(uint256 p0, uint256 p1, bytes32 p2, bool p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(uint256,uint256,string,bool)`.\n mstore(0x00, 0x7af6ab25)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, 0x80)\n mstore(0x80, p3)\n writeString(0xa0, p2)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(uint256 p0, uint256 p1, bytes32 p2, uint256 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(uint256,uint256,string,uint256)`.\n mstore(0x00, 0x5da297eb)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, 0x80)\n mstore(0x80, p3)\n writeString(0xa0, p2)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(uint256 p0, uint256 p1, bytes32 p2, bytes32 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n // Selector of `log(uint256,uint256,string,string)`.\n mstore(0x00, 0x27d8afd2)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, 0x80)\n mstore(0x80, 0xc0)\n writeString(0xa0, p2)\n writeString(0xe0, p3)\n }\n _sendLogPayload(0x1c, 0x104);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n }\n }\n\n function log(uint256 p0, bytes32 p1, address p2, address p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(uint256,string,address,address)`.\n mstore(0x00, 0x6168ed61)\n mstore(0x20, p0)\n mstore(0x40, 0x80)\n mstore(0x60, p2)\n mstore(0x80, p3)\n writeString(0xa0, p1)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(uint256 p0, bytes32 p1, address p2, bool p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(uint256,string,address,bool)`.\n mstore(0x00, 0x90c30a56)\n mstore(0x20, p0)\n mstore(0x40, 0x80)\n mstore(0x60, p2)\n mstore(0x80, p3)\n writeString(0xa0, p1)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(uint256 p0, bytes32 p1, address p2, uint256 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(uint256,string,address,uint256)`.\n mstore(0x00, 0xe8d3018d)\n mstore(0x20, p0)\n mstore(0x40, 0x80)\n mstore(0x60, p2)\n mstore(0x80, p3)\n writeString(0xa0, p1)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(uint256 p0, bytes32 p1, address p2, bytes32 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n // Selector of `log(uint256,string,address,string)`.\n mstore(0x00, 0x9c3adfa1)\n mstore(0x20, p0)\n mstore(0x40, 0x80)\n mstore(0x60, p2)\n mstore(0x80, 0xc0)\n writeString(0xa0, p1)\n writeString(0xe0, p3)\n }\n _sendLogPayload(0x1c, 0x104);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n }\n }\n\n function log(uint256 p0, bytes32 p1, bool p2, address p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(uint256,string,bool,address)`.\n mstore(0x00, 0xae2ec581)\n mstore(0x20, p0)\n mstore(0x40, 0x80)\n mstore(0x60, p2)\n mstore(0x80, p3)\n writeString(0xa0, p1)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(uint256 p0, bytes32 p1, bool p2, bool p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(uint256,string,bool,bool)`.\n mstore(0x00, 0xba535d9c)\n mstore(0x20, p0)\n mstore(0x40, 0x80)\n mstore(0x60, p2)\n mstore(0x80, p3)\n writeString(0xa0, p1)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(uint256 p0, bytes32 p1, bool p2, uint256 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(uint256,string,bool,uint256)`.\n mstore(0x00, 0xcf009880)\n mstore(0x20, p0)\n mstore(0x40, 0x80)\n mstore(0x60, p2)\n mstore(0x80, p3)\n writeString(0xa0, p1)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(uint256 p0, bytes32 p1, bool p2, bytes32 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n // Selector of `log(uint256,string,bool,string)`.\n mstore(0x00, 0xd2d423cd)\n mstore(0x20, p0)\n mstore(0x40, 0x80)\n mstore(0x60, p2)\n mstore(0x80, 0xc0)\n writeString(0xa0, p1)\n writeString(0xe0, p3)\n }\n _sendLogPayload(0x1c, 0x104);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n }\n }\n\n function log(uint256 p0, bytes32 p1, uint256 p2, address p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(uint256,string,uint256,address)`.\n mstore(0x00, 0x3b2279b4)\n mstore(0x20, p0)\n mstore(0x40, 0x80)\n mstore(0x60, p2)\n mstore(0x80, p3)\n writeString(0xa0, p1)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(uint256 p0, bytes32 p1, uint256 p2, bool p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(uint256,string,uint256,bool)`.\n mstore(0x00, 0x691a8f74)\n mstore(0x20, p0)\n mstore(0x40, 0x80)\n mstore(0x60, p2)\n mstore(0x80, p3)\n writeString(0xa0, p1)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(uint256 p0, bytes32 p1, uint256 p2, uint256 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(uint256,string,uint256,uint256)`.\n mstore(0x00, 0x82c25b74)\n mstore(0x20, p0)\n mstore(0x40, 0x80)\n mstore(0x60, p2)\n mstore(0x80, p3)\n writeString(0xa0, p1)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(uint256 p0, bytes32 p1, uint256 p2, bytes32 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n // Selector of `log(uint256,string,uint256,string)`.\n mstore(0x00, 0xb7b914ca)\n mstore(0x20, p0)\n mstore(0x40, 0x80)\n mstore(0x60, p2)\n mstore(0x80, 0xc0)\n writeString(0xa0, p1)\n writeString(0xe0, p3)\n }\n _sendLogPayload(0x1c, 0x104);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n }\n }\n\n function log(uint256 p0, bytes32 p1, bytes32 p2, address p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n // Selector of `log(uint256,string,string,address)`.\n mstore(0x00, 0xd583c602)\n mstore(0x20, p0)\n mstore(0x40, 0x80)\n mstore(0x60, 0xc0)\n mstore(0x80, p3)\n writeString(0xa0, p1)\n writeString(0xe0, p2)\n }\n _sendLogPayload(0x1c, 0x104);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n }\n }\n\n function log(uint256 p0, bytes32 p1, bytes32 p2, bool p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n // Selector of `log(uint256,string,string,bool)`.\n mstore(0x00, 0xb3a6b6bd)\n mstore(0x20, p0)\n mstore(0x40, 0x80)\n mstore(0x60, 0xc0)\n mstore(0x80, p3)\n writeString(0xa0, p1)\n writeString(0xe0, p2)\n }\n _sendLogPayload(0x1c, 0x104);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n }\n }\n\n function log(uint256 p0, bytes32 p1, bytes32 p2, uint256 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n // Selector of `log(uint256,string,string,uint256)`.\n mstore(0x00, 0xb028c9bd)\n mstore(0x20, p0)\n mstore(0x40, 0x80)\n mstore(0x60, 0xc0)\n mstore(0x80, p3)\n writeString(0xa0, p1)\n writeString(0xe0, p2)\n }\n _sendLogPayload(0x1c, 0x104);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n }\n }\n\n function log(uint256 p0, bytes32 p1, bytes32 p2, bytes32 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n bytes32 m9;\n bytes32 m10;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n m9 := mload(0x120)\n m10 := mload(0x140)\n // Selector of `log(uint256,string,string,string)`.\n mstore(0x00, 0x21ad0683)\n mstore(0x20, p0)\n mstore(0x40, 0x80)\n mstore(0x60, 0xc0)\n mstore(0x80, 0x100)\n writeString(0xa0, p1)\n writeString(0xe0, p2)\n writeString(0x120, p3)\n }\n _sendLogPayload(0x1c, 0x144);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n mstore(0x120, m9)\n mstore(0x140, m10)\n }\n }\n\n function log(bytes32 p0, address p1, address p2, address p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(string,address,address,address)`.\n mstore(0x00, 0xed8f28f6)\n mstore(0x20, 0x80)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n writeString(0xa0, p0)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(bytes32 p0, address p1, address p2, bool p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(string,address,address,bool)`.\n mstore(0x00, 0xb59dbd60)\n mstore(0x20, 0x80)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n writeString(0xa0, p0)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(bytes32 p0, address p1, address p2, uint256 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(string,address,address,uint256)`.\n mstore(0x00, 0x8ef3f399)\n mstore(0x20, 0x80)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n writeString(0xa0, p0)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(bytes32 p0, address p1, address p2, bytes32 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n // Selector of `log(string,address,address,string)`.\n mstore(0x00, 0x800a1c67)\n mstore(0x20, 0x80)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, 0xc0)\n writeString(0xa0, p0)\n writeString(0xe0, p3)\n }\n _sendLogPayload(0x1c, 0x104);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n }\n }\n\n function log(bytes32 p0, address p1, bool p2, address p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(string,address,bool,address)`.\n mstore(0x00, 0x223603bd)\n mstore(0x20, 0x80)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n writeString(0xa0, p0)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(bytes32 p0, address p1, bool p2, bool p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(string,address,bool,bool)`.\n mstore(0x00, 0x79884c2b)\n mstore(0x20, 0x80)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n writeString(0xa0, p0)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(bytes32 p0, address p1, bool p2, uint256 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(string,address,bool,uint256)`.\n mstore(0x00, 0x3e9f866a)\n mstore(0x20, 0x80)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n writeString(0xa0, p0)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(bytes32 p0, address p1, bool p2, bytes32 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n // Selector of `log(string,address,bool,string)`.\n mstore(0x00, 0x0454c079)\n mstore(0x20, 0x80)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, 0xc0)\n writeString(0xa0, p0)\n writeString(0xe0, p3)\n }\n _sendLogPayload(0x1c, 0x104);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n }\n }\n\n function log(bytes32 p0, address p1, uint256 p2, address p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(string,address,uint256,address)`.\n mstore(0x00, 0x63fb8bc5)\n mstore(0x20, 0x80)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n writeString(0xa0, p0)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(bytes32 p0, address p1, uint256 p2, bool p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(string,address,uint256,bool)`.\n mstore(0x00, 0xfc4845f0)\n mstore(0x20, 0x80)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n writeString(0xa0, p0)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(bytes32 p0, address p1, uint256 p2, uint256 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(string,address,uint256,uint256)`.\n mstore(0x00, 0xf8f51b1e)\n mstore(0x20, 0x80)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n writeString(0xa0, p0)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(bytes32 p0, address p1, uint256 p2, bytes32 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n // Selector of `log(string,address,uint256,string)`.\n mstore(0x00, 0x5a477632)\n mstore(0x20, 0x80)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, 0xc0)\n writeString(0xa0, p0)\n writeString(0xe0, p3)\n }\n _sendLogPayload(0x1c, 0x104);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n }\n }\n\n function log(bytes32 p0, address p1, bytes32 p2, address p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n // Selector of `log(string,address,string,address)`.\n mstore(0x00, 0xaabc9a31)\n mstore(0x20, 0x80)\n mstore(0x40, p1)\n mstore(0x60, 0xc0)\n mstore(0x80, p3)\n writeString(0xa0, p0)\n writeString(0xe0, p2)\n }\n _sendLogPayload(0x1c, 0x104);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n }\n }\n\n function log(bytes32 p0, address p1, bytes32 p2, bool p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n // Selector of `log(string,address,string,bool)`.\n mstore(0x00, 0x5f15d28c)\n mstore(0x20, 0x80)\n mstore(0x40, p1)\n mstore(0x60, 0xc0)\n mstore(0x80, p3)\n writeString(0xa0, p0)\n writeString(0xe0, p2)\n }\n _sendLogPayload(0x1c, 0x104);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n }\n }\n\n function log(bytes32 p0, address p1, bytes32 p2, uint256 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n // Selector of `log(string,address,string,uint256)`.\n mstore(0x00, 0x91d1112e)\n mstore(0x20, 0x80)\n mstore(0x40, p1)\n mstore(0x60, 0xc0)\n mstore(0x80, p3)\n writeString(0xa0, p0)\n writeString(0xe0, p2)\n }\n _sendLogPayload(0x1c, 0x104);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n }\n }\n\n function log(bytes32 p0, address p1, bytes32 p2, bytes32 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n bytes32 m9;\n bytes32 m10;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n m9 := mload(0x120)\n m10 := mload(0x140)\n // Selector of `log(string,address,string,string)`.\n mstore(0x00, 0x245986f2)\n mstore(0x20, 0x80)\n mstore(0x40, p1)\n mstore(0x60, 0xc0)\n mstore(0x80, 0x100)\n writeString(0xa0, p0)\n writeString(0xe0, p2)\n writeString(0x120, p3)\n }\n _sendLogPayload(0x1c, 0x144);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n mstore(0x120, m9)\n mstore(0x140, m10)\n }\n }\n\n function log(bytes32 p0, bool p1, address p2, address p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(string,bool,address,address)`.\n mstore(0x00, 0x33e9dd1d)\n mstore(0x20, 0x80)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n writeString(0xa0, p0)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(bytes32 p0, bool p1, address p2, bool p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(string,bool,address,bool)`.\n mstore(0x00, 0x958c28c6)\n mstore(0x20, 0x80)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n writeString(0xa0, p0)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(bytes32 p0, bool p1, address p2, uint256 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(string,bool,address,uint256)`.\n mstore(0x00, 0x5d08bb05)\n mstore(0x20, 0x80)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n writeString(0xa0, p0)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(bytes32 p0, bool p1, address p2, bytes32 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n // Selector of `log(string,bool,address,string)`.\n mstore(0x00, 0x2d8e33a4)\n mstore(0x20, 0x80)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, 0xc0)\n writeString(0xa0, p0)\n writeString(0xe0, p3)\n }\n _sendLogPayload(0x1c, 0x104);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n }\n }\n\n function log(bytes32 p0, bool p1, bool p2, address p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(string,bool,bool,address)`.\n mstore(0x00, 0x7190a529)\n mstore(0x20, 0x80)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n writeString(0xa0, p0)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(bytes32 p0, bool p1, bool p2, bool p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(string,bool,bool,bool)`.\n mstore(0x00, 0x895af8c5)\n mstore(0x20, 0x80)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n writeString(0xa0, p0)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(bytes32 p0, bool p1, bool p2, uint256 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(string,bool,bool,uint256)`.\n mstore(0x00, 0x8e3f78a9)\n mstore(0x20, 0x80)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n writeString(0xa0, p0)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(bytes32 p0, bool p1, bool p2, bytes32 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n // Selector of `log(string,bool,bool,string)`.\n mstore(0x00, 0x9d22d5dd)\n mstore(0x20, 0x80)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, 0xc0)\n writeString(0xa0, p0)\n writeString(0xe0, p3)\n }\n _sendLogPayload(0x1c, 0x104);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n }\n }\n\n function log(bytes32 p0, bool p1, uint256 p2, address p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(string,bool,uint256,address)`.\n mstore(0x00, 0x935e09bf)\n mstore(0x20, 0x80)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n writeString(0xa0, p0)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(bytes32 p0, bool p1, uint256 p2, bool p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(string,bool,uint256,bool)`.\n mstore(0x00, 0x8af7cf8a)\n mstore(0x20, 0x80)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n writeString(0xa0, p0)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(bytes32 p0, bool p1, uint256 p2, uint256 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(string,bool,uint256,uint256)`.\n mstore(0x00, 0x64b5bb67)\n mstore(0x20, 0x80)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n writeString(0xa0, p0)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(bytes32 p0, bool p1, uint256 p2, bytes32 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n // Selector of `log(string,bool,uint256,string)`.\n mstore(0x00, 0x742d6ee7)\n mstore(0x20, 0x80)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, 0xc0)\n writeString(0xa0, p0)\n writeString(0xe0, p3)\n }\n _sendLogPayload(0x1c, 0x104);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n }\n }\n\n function log(bytes32 p0, bool p1, bytes32 p2, address p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n // Selector of `log(string,bool,string,address)`.\n mstore(0x00, 0xe0625b29)\n mstore(0x20, 0x80)\n mstore(0x40, p1)\n mstore(0x60, 0xc0)\n mstore(0x80, p3)\n writeString(0xa0, p0)\n writeString(0xe0, p2)\n }\n _sendLogPayload(0x1c, 0x104);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n }\n }\n\n function log(bytes32 p0, bool p1, bytes32 p2, bool p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n // Selector of `log(string,bool,string,bool)`.\n mstore(0x00, 0x3f8a701d)\n mstore(0x20, 0x80)\n mstore(0x40, p1)\n mstore(0x60, 0xc0)\n mstore(0x80, p3)\n writeString(0xa0, p0)\n writeString(0xe0, p2)\n }\n _sendLogPayload(0x1c, 0x104);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n }\n }\n\n function log(bytes32 p0, bool p1, bytes32 p2, uint256 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n // Selector of `log(string,bool,string,uint256)`.\n mstore(0x00, 0x24f91465)\n mstore(0x20, 0x80)\n mstore(0x40, p1)\n mstore(0x60, 0xc0)\n mstore(0x80, p3)\n writeString(0xa0, p0)\n writeString(0xe0, p2)\n }\n _sendLogPayload(0x1c, 0x104);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n }\n }\n\n function log(bytes32 p0, bool p1, bytes32 p2, bytes32 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n bytes32 m9;\n bytes32 m10;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n m9 := mload(0x120)\n m10 := mload(0x140)\n // Selector of `log(string,bool,string,string)`.\n mstore(0x00, 0xa826caeb)\n mstore(0x20, 0x80)\n mstore(0x40, p1)\n mstore(0x60, 0xc0)\n mstore(0x80, 0x100)\n writeString(0xa0, p0)\n writeString(0xe0, p2)\n writeString(0x120, p3)\n }\n _sendLogPayload(0x1c, 0x144);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n mstore(0x120, m9)\n mstore(0x140, m10)\n }\n }\n\n function log(bytes32 p0, uint256 p1, address p2, address p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(string,uint256,address,address)`.\n mstore(0x00, 0x5ea2b7ae)\n mstore(0x20, 0x80)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n writeString(0xa0, p0)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(bytes32 p0, uint256 p1, address p2, bool p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(string,uint256,address,bool)`.\n mstore(0x00, 0x82112a42)\n mstore(0x20, 0x80)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n writeString(0xa0, p0)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(bytes32 p0, uint256 p1, address p2, uint256 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(string,uint256,address,uint256)`.\n mstore(0x00, 0x4f04fdc6)\n mstore(0x20, 0x80)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n writeString(0xa0, p0)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(bytes32 p0, uint256 p1, address p2, bytes32 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n // Selector of `log(string,uint256,address,string)`.\n mstore(0x00, 0x9ffb2f93)\n mstore(0x20, 0x80)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, 0xc0)\n writeString(0xa0, p0)\n writeString(0xe0, p3)\n }\n _sendLogPayload(0x1c, 0x104);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n }\n }\n\n function log(bytes32 p0, uint256 p1, bool p2, address p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(string,uint256,bool,address)`.\n mstore(0x00, 0xe0e95b98)\n mstore(0x20, 0x80)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n writeString(0xa0, p0)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(bytes32 p0, uint256 p1, bool p2, bool p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(string,uint256,bool,bool)`.\n mstore(0x00, 0x354c36d6)\n mstore(0x20, 0x80)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n writeString(0xa0, p0)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(bytes32 p0, uint256 p1, bool p2, uint256 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(string,uint256,bool,uint256)`.\n mstore(0x00, 0xe41b6f6f)\n mstore(0x20, 0x80)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n writeString(0xa0, p0)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(bytes32 p0, uint256 p1, bool p2, bytes32 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n // Selector of `log(string,uint256,bool,string)`.\n mstore(0x00, 0xabf73a98)\n mstore(0x20, 0x80)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, 0xc0)\n writeString(0xa0, p0)\n writeString(0xe0, p3)\n }\n _sendLogPayload(0x1c, 0x104);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n }\n }\n\n function log(bytes32 p0, uint256 p1, uint256 p2, address p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(string,uint256,uint256,address)`.\n mstore(0x00, 0xe21de278)\n mstore(0x20, 0x80)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n writeString(0xa0, p0)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(bytes32 p0, uint256 p1, uint256 p2, bool p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(string,uint256,uint256,bool)`.\n mstore(0x00, 0x7626db92)\n mstore(0x20, 0x80)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n writeString(0xa0, p0)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(bytes32 p0, uint256 p1, uint256 p2, uint256 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(string,uint256,uint256,uint256)`.\n mstore(0x00, 0xa7a87853)\n mstore(0x20, 0x80)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n writeString(0xa0, p0)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(bytes32 p0, uint256 p1, uint256 p2, bytes32 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n // Selector of `log(string,uint256,uint256,string)`.\n mstore(0x00, 0x854b3496)\n mstore(0x20, 0x80)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, 0xc0)\n writeString(0xa0, p0)\n writeString(0xe0, p3)\n }\n _sendLogPayload(0x1c, 0x104);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n }\n }\n\n function log(bytes32 p0, uint256 p1, bytes32 p2, address p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n // Selector of `log(string,uint256,string,address)`.\n mstore(0x00, 0x7c4632a4)\n mstore(0x20, 0x80)\n mstore(0x40, p1)\n mstore(0x60, 0xc0)\n mstore(0x80, p3)\n writeString(0xa0, p0)\n writeString(0xe0, p2)\n }\n _sendLogPayload(0x1c, 0x104);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n }\n }\n\n function log(bytes32 p0, uint256 p1, bytes32 p2, bool p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n // Selector of `log(string,uint256,string,bool)`.\n mstore(0x00, 0x7d24491d)\n mstore(0x20, 0x80)\n mstore(0x40, p1)\n mstore(0x60, 0xc0)\n mstore(0x80, p3)\n writeString(0xa0, p0)\n writeString(0xe0, p2)\n }\n _sendLogPayload(0x1c, 0x104);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n }\n }\n\n function log(bytes32 p0, uint256 p1, bytes32 p2, uint256 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n // Selector of `log(string,uint256,string,uint256)`.\n mstore(0x00, 0xc67ea9d1)\n mstore(0x20, 0x80)\n mstore(0x40, p1)\n mstore(0x60, 0xc0)\n mstore(0x80, p3)\n writeString(0xa0, p0)\n writeString(0xe0, p2)\n }\n _sendLogPayload(0x1c, 0x104);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n }\n }\n\n function log(bytes32 p0, uint256 p1, bytes32 p2, bytes32 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n bytes32 m9;\n bytes32 m10;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n m9 := mload(0x120)\n m10 := mload(0x140)\n // Selector of `log(string,uint256,string,string)`.\n mstore(0x00, 0x5ab84e1f)\n mstore(0x20, 0x80)\n mstore(0x40, p1)\n mstore(0x60, 0xc0)\n mstore(0x80, 0x100)\n writeString(0xa0, p0)\n writeString(0xe0, p2)\n writeString(0x120, p3)\n }\n _sendLogPayload(0x1c, 0x144);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n mstore(0x120, m9)\n mstore(0x140, m10)\n }\n }\n\n function log(bytes32 p0, bytes32 p1, address p2, address p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n // Selector of `log(string,string,address,address)`.\n mstore(0x00, 0x439c7bef)\n mstore(0x20, 0x80)\n mstore(0x40, 0xc0)\n mstore(0x60, p2)\n mstore(0x80, p3)\n writeString(0xa0, p0)\n writeString(0xe0, p1)\n }\n _sendLogPayload(0x1c, 0x104);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n }\n }\n\n function log(bytes32 p0, bytes32 p1, address p2, bool p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n // Selector of `log(string,string,address,bool)`.\n mstore(0x00, 0x5ccd4e37)\n mstore(0x20, 0x80)\n mstore(0x40, 0xc0)\n mstore(0x60, p2)\n mstore(0x80, p3)\n writeString(0xa0, p0)\n writeString(0xe0, p1)\n }\n _sendLogPayload(0x1c, 0x104);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n }\n }\n\n function log(bytes32 p0, bytes32 p1, address p2, uint256 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n // Selector of `log(string,string,address,uint256)`.\n mstore(0x00, 0x7cc3c607)\n mstore(0x20, 0x80)\n mstore(0x40, 0xc0)\n mstore(0x60, p2)\n mstore(0x80, p3)\n writeString(0xa0, p0)\n writeString(0xe0, p1)\n }\n _sendLogPayload(0x1c, 0x104);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n }\n }\n\n function log(bytes32 p0, bytes32 p1, address p2, bytes32 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n bytes32 m9;\n bytes32 m10;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n m9 := mload(0x120)\n m10 := mload(0x140)\n // Selector of `log(string,string,address,string)`.\n mstore(0x00, 0xeb1bff80)\n mstore(0x20, 0x80)\n mstore(0x40, 0xc0)\n mstore(0x60, p2)\n mstore(0x80, 0x100)\n writeString(0xa0, p0)\n writeString(0xe0, p1)\n writeString(0x120, p3)\n }\n _sendLogPayload(0x1c, 0x144);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n mstore(0x120, m9)\n mstore(0x140, m10)\n }\n }\n\n function log(bytes32 p0, bytes32 p1, bool p2, address p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n // Selector of `log(string,string,bool,address)`.\n mstore(0x00, 0xc371c7db)\n mstore(0x20, 0x80)\n mstore(0x40, 0xc0)\n mstore(0x60, p2)\n mstore(0x80, p3)\n writeString(0xa0, p0)\n writeString(0xe0, p1)\n }\n _sendLogPayload(0x1c, 0x104);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n }\n }\n\n function log(bytes32 p0, bytes32 p1, bool p2, bool p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n // Selector of `log(string,string,bool,bool)`.\n mstore(0x00, 0x40785869)\n mstore(0x20, 0x80)\n mstore(0x40, 0xc0)\n mstore(0x60, p2)\n mstore(0x80, p3)\n writeString(0xa0, p0)\n writeString(0xe0, p1)\n }\n _sendLogPayload(0x1c, 0x104);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n }\n }\n\n function log(bytes32 p0, bytes32 p1, bool p2, uint256 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n // Selector of `log(string,string,bool,uint256)`.\n mstore(0x00, 0xd6aefad2)\n mstore(0x20, 0x80)\n mstore(0x40, 0xc0)\n mstore(0x60, p2)\n mstore(0x80, p3)\n writeString(0xa0, p0)\n writeString(0xe0, p1)\n }\n _sendLogPayload(0x1c, 0x104);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n }\n }\n\n function log(bytes32 p0, bytes32 p1, bool p2, bytes32 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n bytes32 m9;\n bytes32 m10;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n m9 := mload(0x120)\n m10 := mload(0x140)\n // Selector of `log(string,string,bool,string)`.\n mstore(0x00, 0x5e84b0ea)\n mstore(0x20, 0x80)\n mstore(0x40, 0xc0)\n mstore(0x60, p2)\n mstore(0x80, 0x100)\n writeString(0xa0, p0)\n writeString(0xe0, p1)\n writeString(0x120, p3)\n }\n _sendLogPayload(0x1c, 0x144);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n mstore(0x120, m9)\n mstore(0x140, m10)\n }\n }\n\n function log(bytes32 p0, bytes32 p1, uint256 p2, address p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n // Selector of `log(string,string,uint256,address)`.\n mstore(0x00, 0x1023f7b2)\n mstore(0x20, 0x80)\n mstore(0x40, 0xc0)\n mstore(0x60, p2)\n mstore(0x80, p3)\n writeString(0xa0, p0)\n writeString(0xe0, p1)\n }\n _sendLogPayload(0x1c, 0x104);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n }\n }\n\n function log(bytes32 p0, bytes32 p1, uint256 p2, bool p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n // Selector of `log(string,string,uint256,bool)`.\n mstore(0x00, 0xc3a8a654)\n mstore(0x20, 0x80)\n mstore(0x40, 0xc0)\n mstore(0x60, p2)\n mstore(0x80, p3)\n writeString(0xa0, p0)\n writeString(0xe0, p1)\n }\n _sendLogPayload(0x1c, 0x104);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n }\n }\n\n function log(bytes32 p0, bytes32 p1, uint256 p2, uint256 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n // Selector of `log(string,string,uint256,uint256)`.\n mstore(0x00, 0xf45d7d2c)\n mstore(0x20, 0x80)\n mstore(0x40, 0xc0)\n mstore(0x60, p2)\n mstore(0x80, p3)\n writeString(0xa0, p0)\n writeString(0xe0, p1)\n }\n _sendLogPayload(0x1c, 0x104);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n }\n }\n\n function log(bytes32 p0, bytes32 p1, uint256 p2, bytes32 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n bytes32 m9;\n bytes32 m10;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n m9 := mload(0x120)\n m10 := mload(0x140)\n // Selector of `log(string,string,uint256,string)`.\n mstore(0x00, 0x5d1a971a)\n mstore(0x20, 0x80)\n mstore(0x40, 0xc0)\n mstore(0x60, p2)\n mstore(0x80, 0x100)\n writeString(0xa0, p0)\n writeString(0xe0, p1)\n writeString(0x120, p3)\n }\n _sendLogPayload(0x1c, 0x144);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n mstore(0x120, m9)\n mstore(0x140, m10)\n }\n }\n\n function log(bytes32 p0, bytes32 p1, bytes32 p2, address p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n bytes32 m9;\n bytes32 m10;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n m9 := mload(0x120)\n m10 := mload(0x140)\n // Selector of `log(string,string,string,address)`.\n mstore(0x00, 0x6d572f44)\n mstore(0x20, 0x80)\n mstore(0x40, 0xc0)\n mstore(0x60, 0x100)\n mstore(0x80, p3)\n writeString(0xa0, p0)\n writeString(0xe0, p1)\n writeString(0x120, p2)\n }\n _sendLogPayload(0x1c, 0x144);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n mstore(0x120, m9)\n mstore(0x140, m10)\n }\n }\n\n function log(bytes32 p0, bytes32 p1, bytes32 p2, bool p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n bytes32 m9;\n bytes32 m10;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n m9 := mload(0x120)\n m10 := mload(0x140)\n // Selector of `log(string,string,string,bool)`.\n mstore(0x00, 0x2c1754ed)\n mstore(0x20, 0x80)\n mstore(0x40, 0xc0)\n mstore(0x60, 0x100)\n mstore(0x80, p3)\n writeString(0xa0, p0)\n writeString(0xe0, p1)\n writeString(0x120, p2)\n }\n _sendLogPayload(0x1c, 0x144);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n mstore(0x120, m9)\n mstore(0x140, m10)\n }\n }\n\n function log(bytes32 p0, bytes32 p1, bytes32 p2, uint256 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n bytes32 m9;\n bytes32 m10;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n m9 := mload(0x120)\n m10 := mload(0x140)\n // Selector of `log(string,string,string,uint256)`.\n mstore(0x00, 0x8eafb02b)\n mstore(0x20, 0x80)\n mstore(0x40, 0xc0)\n mstore(0x60, 0x100)\n mstore(0x80, p3)\n writeString(0xa0, p0)\n writeString(0xe0, p1)\n writeString(0x120, p2)\n }\n _sendLogPayload(0x1c, 0x144);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n mstore(0x120, m9)\n mstore(0x140, m10)\n }\n }\n\n function log(bytes32 p0, bytes32 p1, bytes32 p2, bytes32 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n bytes32 m9;\n bytes32 m10;\n bytes32 m11;\n bytes32 m12;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n m9 := mload(0x120)\n m10 := mload(0x140)\n m11 := mload(0x160)\n m12 := mload(0x180)\n // Selector of `log(string,string,string,string)`.\n mstore(0x00, 0xde68f20a)\n mstore(0x20, 0x80)\n mstore(0x40, 0xc0)\n mstore(0x60, 0x100)\n mstore(0x80, 0x140)\n writeString(0xa0, p0)\n writeString(0xe0, p1)\n writeString(0x120, p2)\n writeString(0x160, p3)\n }\n _sendLogPayload(0x1c, 0x184);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n mstore(0x120, m9)\n mstore(0x140, m10)\n mstore(0x160, m11)\n mstore(0x180, m12)\n }\n }\n}\n","license":"MIT"},"scripts/FetchChainInfo.s.sol":{"keccak256":"0x202fb27a5a78b7d8c96c3a4ea69981dc4eeda765aa2747699ac80b8499feb709","urls":[],"content":"// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\nimport { Script } from \"forge-std/Script.sol\";\nimport { GameTypes, GameType } from \"src/dispute/lib/Types.sol\";\n\n/// @notice Contains getters for arbitrary methods from all L1 contracts, including legacy getters\n/// that have since been deprecated.\ninterface IFetcher {\n function guardian() external view returns (address);\n function GUARDIAN() external view returns (address);\n function systemConfig() external view returns (address);\n function SYSTEM_CONFIG() external view returns (address);\n function disputeGameFactory() external view returns (address);\n function ethLockbox() external view returns (address);\n function superchainConfig() external view returns (address);\n function messenger() external view returns (address);\n function addressManager() external view returns (address);\n function PORTAL() external view returns (address);\n function portal() external view returns (address);\n function l1ERC721Bridge() external view returns (address);\n function optimismMintableERC20Factory() external view returns (address);\n function gameImpls(GameType _gameType) external view returns (address);\n function respectedGameType() external view returns (GameType);\n function anchorStateRegistry() external view returns (address);\n function L2_ORACLE() external view returns (address);\n function l2Oracle() external view returns (address);\n function vm() external view returns (address);\n function oracle() external view returns (address);\n function challenger() external view returns (address);\n function proposer() external view returns (address);\n function PROPOSER() external view returns (address);\n function batcherHash() external view returns (bytes32);\n function admin() external view returns (address);\n function owner() external view returns (address);\n function unsafeBlockSigner() external view returns (address);\n function weth() external view returns (address);\n}\n\ncontract FetchChainInfoInput {\n address internal _systemConfigProxy;\n address internal _l1StandardBridgeProxy;\n\n function set(bytes4 _sel, address _addr) public {\n require(_addr != address(0), \"FetchChainInfoInput: cannot set zero address\");\n if (_sel == this.systemConfigProxy.selector) _systemConfigProxy = _addr;\n else if (_sel == this.l1StandardBridgeProxy.selector) _l1StandardBridgeProxy = _addr;\n else revert(\"FetchChainInfoInput: unknown selector\");\n }\n\n function systemConfigProxy() public view returns (address) {\n require(_systemConfigProxy != address(0), \"FetchChainInfoInput: systemConfigProxy not set\");\n return _systemConfigProxy;\n }\n\n function l1StandardBridgeProxy() public view returns (address) {\n require(_l1StandardBridgeProxy != address(0), \"FetchChainInfoInput: l1StandardBridgeProxy not set\");\n return _l1StandardBridgeProxy;\n }\n}\n\ncontract FetchChainInfoOutput {\n // contract addresses\n // - SuperchainContracts\n address internal _superchainConfigProxy;\n // - ImplementationsContracts\n address internal _mipsImpl;\n address internal _preimageOracleImpl;\n // - OpChainContracts\n address internal _addressManagerImpl;\n address internal _ethLockboxProxy;\n address internal _l1CrossDomainMessengerProxy;\n address internal _l1Erc721BridgeProxy;\n address internal _l1StandardBridgeProxy;\n address internal _l2OutputOracleProxy;\n address internal _optimismMintableErc20FactoryProxy;\n address internal _optimismPortalProxy;\n address internal _systemConfigProxy;\n address internal _opChainProxyAdminImpl;\n address internal _anchorStateRegistryProxy;\n address internal _delayedWethPermissionedGameProxy;\n address internal _delayedWethPermissionlessGameProxy;\n address internal _disputeGameFactoryProxy;\n address internal _faultDisputeGameImpl;\n address internal _permissionedDisputeGameImpl;\n\n // roles\n address internal _systemConfigOwner;\n address internal _opChainProxyAdminOwner;\n address internal _opChainGuardian;\n address internal _challenger;\n address internal _proposer;\n address internal _unsafeBlockSigner;\n address internal _batchSubmitter;\n\n // fault proof status\n bool internal _permissioned;\n bool internal _permissionless;\n GameType internal _respectedGameType;\n\n function set(bytes4 _sel, address _addr) public {\n // SuperchainContracts\n if (_sel == this.superchainConfigProxy.selector) _superchainConfigProxy = _addr;\n // - ImplementationsContracts\n else if (_sel == this.mipsImpl.selector) _mipsImpl = _addr;\n else if (_sel == this.preimageOracleImpl.selector) _preimageOracleImpl = _addr;\n // - OpChainContracts\n else if (_sel == this.addressManagerImpl.selector) _addressManagerImpl = _addr;\n else if (_sel == this.ethLockboxProxy.selector) _ethLockboxProxy = _addr;\n else if (_sel == this.l1CrossDomainMessengerProxy.selector) _l1CrossDomainMessengerProxy = _addr;\n else if (_sel == this.l1Erc721BridgeProxy.selector) _l1Erc721BridgeProxy = _addr;\n else if (_sel == this.l1StandardBridgeProxy.selector) _l1StandardBridgeProxy = _addr;\n else if (_sel == this.l2OutputOracleProxy.selector) _l2OutputOracleProxy = _addr;\n else if (_sel == this.optimismMintableErc20FactoryProxy.selector) _optimismMintableErc20FactoryProxy = _addr;\n else if (_sel == this.optimismPortalProxy.selector) _optimismPortalProxy = _addr;\n else if (_sel == this.systemConfigProxy.selector) _systemConfigProxy = _addr;\n else if (_sel == this.opChainProxyAdminImpl.selector) _opChainProxyAdminImpl = _addr;\n else if (_sel == this.anchorStateRegistryProxy.selector) _anchorStateRegistryProxy = _addr;\n else if (_sel == this.delayedWethPermissionedGameProxy.selector) _delayedWethPermissionedGameProxy = _addr;\n else if (_sel == this.delayedWethPermissionlessGameProxy.selector) _delayedWethPermissionlessGameProxy = _addr;\n else if (_sel == this.disputeGameFactoryProxy.selector) _disputeGameFactoryProxy = _addr;\n else if (_sel == this.faultDisputeGameImpl.selector) _faultDisputeGameImpl = _addr;\n else if (_sel == this.permissionedDisputeGameImpl.selector) _permissionedDisputeGameImpl = _addr;\n // roles\n else if (_sel == this.systemConfigOwner.selector) _systemConfigOwner = _addr;\n else if (_sel == this.opChainProxyAdminOwner.selector) _opChainProxyAdminOwner = _addr;\n else if (_sel == this.opChainGuardian.selector) _opChainGuardian = _addr;\n else if (_sel == this.challenger.selector) _challenger = _addr;\n else if (_sel == this.proposer.selector) _proposer = _addr;\n else if (_sel == this.unsafeBlockSigner.selector) _unsafeBlockSigner = _addr;\n else if (_sel == this.batchSubmitter.selector) _batchSubmitter = _addr;\n else revert(\"FetchChainInfoOutput: unknown address selector test\");\n }\n\n function set(bytes4 _sel, bool _bool) public {\n if (_sel == this.permissioned.selector) _permissioned = _bool;\n else if (_sel == this.permissionless.selector) _permissionless = _bool;\n else revert(\"FetchChainInfoOutput: unknown bool selector\");\n }\n\n function set(bytes4 _sel, GameType _gameType) public {\n if (_sel == this.respectedGameType.selector) _respectedGameType = _gameType;\n else revert(\"FetchChainInfoOutput: unknown GameType selector\");\n }\n\n function addressManagerImpl() public view returns (address) {\n require(_addressManagerImpl != address(0), \"FetchChainInfoOutput: addressManagerImpl not set\");\n return _addressManagerImpl;\n }\n\n function ethLockboxProxy() public view returns (address) {\n return _ethLockboxProxy;\n }\n\n function l1CrossDomainMessengerProxy() public view returns (address) {\n require(_l1CrossDomainMessengerProxy != address(0), \"FetchChainInfoOutput: l1CrossDomainMessengerProxy not set\");\n return _l1CrossDomainMessengerProxy;\n }\n\n function l1Erc721BridgeProxy() public view returns (address) {\n require(_l1Erc721BridgeProxy != address(0), \"FetchChainInfoOutput: l1Erc721BridgeProxy not set\");\n return _l1Erc721BridgeProxy;\n }\n\n function l1StandardBridgeProxy() public view returns (address) {\n require(_l1StandardBridgeProxy != address(0), \"FetchChainInfoOutput: l1StandardBridgeProxy not set\");\n return _l1StandardBridgeProxy;\n }\n\n function l2OutputOracleProxy() public view returns (address) {\n require(_l2OutputOracleProxy != address(0), \"FetchChainInfoOutput: l2OutputOracleProxy not set\");\n return _l2OutputOracleProxy;\n }\n\n function optimismMintableErc20FactoryProxy() public view returns (address) {\n require(\n _optimismMintableErc20FactoryProxy != address(0),\n \"FetchChainInfoOutput: optimismMintableErc20FactoryProxy not set\"\n );\n return _optimismMintableErc20FactoryProxy;\n }\n\n function optimismPortalProxy() public view returns (address) {\n require(_optimismPortalProxy != address(0), \"FetchChainInfoOutput: optimismPortalProxy not set\");\n return _optimismPortalProxy;\n }\n\n function systemConfigProxy() public view returns (address) {\n require(_systemConfigProxy != address(0), \"FetchChainInfoOutput: systemConfigProxy not set\");\n return _systemConfigProxy;\n }\n\n function opChainProxyAdminImpl() public view returns (address) {\n require(_opChainProxyAdminImpl != address(0), \"FetchChainInfoOutput: opChainProxyAdminImpl not set\");\n return _opChainProxyAdminImpl;\n }\n\n function superchainConfigProxy() public view returns (address) {\n require(_superchainConfigProxy != address(0), \"FetchChainInfoOutput: superchainConfigProxy not set\");\n return _superchainConfigProxy;\n }\n\n function anchorStateRegistryProxy() public view returns (address) {\n require(_anchorStateRegistryProxy != address(0), \"FetchChainInfoOutput: anchorStateRegistryProxy not set\");\n return _anchorStateRegistryProxy;\n }\n\n function delayedWethPermissionedGameProxy() public view returns (address) {\n return _delayedWethPermissionedGameProxy;\n }\n\n function delayedWethPermissionlessGameProxy() public view returns (address) {\n return _delayedWethPermissionlessGameProxy;\n }\n\n function disputeGameFactoryProxy() public view returns (address) {\n return _disputeGameFactoryProxy;\n }\n\n function faultDisputeGameImpl() public view returns (address) {\n require(_faultDisputeGameImpl != address(0), \"FetchChainInfoOutput: faultDisputeGameImpl not set\");\n return _faultDisputeGameImpl;\n }\n\n function mipsImpl() public view returns (address) {\n require(_mipsImpl != address(0), \"FetchChainInfoOutput: mipsImpl not set\");\n return _mipsImpl;\n }\n\n function permissionedDisputeGameImpl() public view returns (address) {\n require(_permissionedDisputeGameImpl != address(0), \"FetchChainInfoOutput: permissionedDisputeGameImpl not set\");\n return _permissionedDisputeGameImpl;\n }\n\n function preimageOracleImpl() public view returns (address) {\n require(_preimageOracleImpl != address(0), \"FetchChainInfoOutput: preimageOracleImpl not set\");\n return _preimageOracleImpl;\n }\n\n function systemConfigOwner() public view returns (address) {\n require(_systemConfigOwner != address(0), \"FetchChainInfoOutput: systemConfigOwner not set\");\n return _systemConfigOwner;\n }\n\n function opChainProxyAdminOwner() public view returns (address) {\n require(_opChainProxyAdminOwner != address(0), \"FetchChainInfoOutput: opChainProxyAdminOwner not set\");\n return _opChainProxyAdminOwner;\n }\n\n function opChainGuardian() public view returns (address) {\n require(_opChainGuardian != address(0), \"FetchChainInfoOutput: opChainGuardian not set\");\n return _opChainGuardian;\n }\n\n function challenger() public view returns (address) {\n require(_challenger != address(0), \"FetchChainInfoOutput: challenger not set\");\n return _challenger;\n }\n\n function proposer() public view returns (address) {\n require(_proposer != address(0), \"FetchChainInfoOutput: proposer not set\");\n return _proposer;\n }\n\n function unsafeBlockSigner() public view returns (address) {\n require(_unsafeBlockSigner != address(0), \"FetchChainInfoOutput: unsafeBlockSigner not set\");\n return _unsafeBlockSigner;\n }\n\n function batchSubmitter() public view returns (address) {\n require(_batchSubmitter != address(0), \"FetchChainInfoOutput: batchSubmitter not set\");\n return _batchSubmitter;\n }\n\n function permissioned() public view returns (bool) {\n return _permissioned;\n }\n\n function permissionless() public view returns (bool) {\n return _permissionless;\n }\n\n function respectedGameType() public view returns (GameType) {\n return _respectedGameType;\n }\n}\n\ncontract FetchChainInfo is Script {\n function run(FetchChainInfoInput _fi, FetchChainInfoOutput _fo) public {\n _processSystemConfig(_fi, _fo);\n _processMessengerAndPortal(_fi, _fo);\n _processFaultProofs(_fo);\n }\n\n function _processSystemConfig(FetchChainInfoInput _fi, FetchChainInfoOutput _fo) internal {\n address systemConfigProxy = _fi.systemConfigProxy();\n _fo.set(_fo.systemConfigProxy.selector, systemConfigProxy);\n\n address systemConfigOwner = IFetcher(systemConfigProxy).owner();\n _fo.set(_fo.systemConfigOwner.selector, systemConfigOwner);\n\n address unsafeBlockSigner = IFetcher(systemConfigProxy).unsafeBlockSigner();\n _fo.set(_fo.unsafeBlockSigner.selector, unsafeBlockSigner);\n\n address batchSubmitter = _getBatchSubmitter(systemConfigProxy);\n _fo.set(_fo.batchSubmitter.selector, batchSubmitter);\n\n address opChainProxyAdminImpl = _getProxyAdmin(systemConfigProxy);\n _fo.set(_fo.opChainProxyAdminImpl.selector, opChainProxyAdminImpl);\n\n address opChainProxyAdminOwner = IFetcher(opChainProxyAdminImpl).owner();\n _fo.set(_fo.opChainProxyAdminOwner.selector, opChainProxyAdminOwner);\n\n address l1Erc721BridgeProxy = _getL1ERC721BridgeProxy(systemConfigProxy);\n _fo.set(_fo.l1Erc721BridgeProxy.selector, l1Erc721BridgeProxy);\n\n address optimismMintableErc20FactoryProxy = _getOptimismMintableERC20FactoryProxy(systemConfigProxy);\n _fo.set(_fo.optimismMintableErc20FactoryProxy.selector, optimismMintableErc20FactoryProxy);\n }\n\n function _processMessengerAndPortal(FetchChainInfoInput _fi, FetchChainInfoOutput _fo) internal {\n address l1StandardBridgeProxy = _fi.l1StandardBridgeProxy();\n _fo.set(_fo.l1StandardBridgeProxy.selector, l1StandardBridgeProxy);\n\n address l1CrossDomainMessengerProxy = IFetcher(l1StandardBridgeProxy).messenger();\n _fo.set(_fo.l1CrossDomainMessengerProxy.selector, l1CrossDomainMessengerProxy);\n\n address addressManagerImpl = _getAddressManager(l1CrossDomainMessengerProxy);\n _fo.set(_fo.addressManagerImpl.selector, addressManagerImpl);\n\n address optimismPortalProxy = _getOptimismPortalProxy(l1CrossDomainMessengerProxy);\n _fo.set(_fo.optimismPortalProxy.selector, optimismPortalProxy);\n\n address opChainGuardian = _getGuardian(optimismPortalProxy);\n _fo.set(_fo.opChainGuardian.selector, opChainGuardian);\n\n address ethLockboxProxy = _getEthLockboxProxy(optimismPortalProxy);\n _fo.set(_fo.ethLockboxProxy.selector, ethLockboxProxy);\n\n address superchainConfigProxy = _getSuperchainConfigProxy(optimismPortalProxy);\n _fo.set(_fo.superchainConfigProxy.selector, superchainConfigProxy);\n }\n\n function _processFaultProofs(FetchChainInfoOutput _fo) internal {\n address systemConfigProxy = _fo.systemConfigProxy();\n address optimismPortalProxy = _fo.optimismPortalProxy();\n\n try IFetcher(optimismPortalProxy).respectedGameType() returns (GameType gameType_) {\n _fo.set(_fo.respectedGameType.selector, gameType_);\n } catch {\n // default respectedGameType to uint32.max since 0 == CANNON\n _fo.set(_fo.respectedGameType.selector, GameType.wrap(type(uint32).max));\n address l2OutputOracleProxy;\n try IFetcher(optimismPortalProxy).l2Oracle() returns (address l2Oracle_) {\n l2OutputOracleProxy = l2Oracle_;\n } catch {\n l2OutputOracleProxy = IFetcher(optimismPortalProxy).L2_ORACLE();\n }\n _fo.set(_fo.l2OutputOracleProxy.selector, l2OutputOracleProxy);\n\n address proposer = IFetcher(l2OutputOracleProxy).PROPOSER();\n _fo.set(_fo.proposer.selector, proposer);\n\n // no fault proofs installed so we're done\n return;\n }\n\n address disputeGameFactoryProxy = _getDisputeGameFactoryProxy(systemConfigProxy);\n if (disputeGameFactoryProxy != address(0)) {\n _fo.set(_fo.disputeGameFactoryProxy.selector, disputeGameFactoryProxy);\n\n address permissionedDisputeGameImpl = _getPermissionedDisputeGame(disputeGameFactoryProxy);\n if (permissionedDisputeGameImpl != address(0)) {\n // permissioned fault proofs installed\n _fo.set(_fo.permissioned.selector, true);\n _fo.set(_fo.permissionedDisputeGameImpl.selector, permissionedDisputeGameImpl);\n\n address challenger = IFetcher(permissionedDisputeGameImpl).challenger();\n _fo.set(_fo.challenger.selector, challenger);\n\n address anchorStateRegistryProxy = IFetcher(permissionedDisputeGameImpl).anchorStateRegistry();\n _fo.set(_fo.anchorStateRegistryProxy.selector, anchorStateRegistryProxy);\n\n address proposer = IFetcher(permissionedDisputeGameImpl).proposer();\n _fo.set(_fo.proposer.selector, proposer);\n\n address delayedWethPermissionedGameProxy = _getDelayedWETHProxy(permissionedDisputeGameImpl);\n _fo.set(_fo.delayedWethPermissionedGameProxy.selector, delayedWethPermissionedGameProxy);\n\n address mipsImpl = IFetcher(permissionedDisputeGameImpl).vm();\n _fo.set(_fo.mipsImpl.selector, mipsImpl);\n\n address preimageOracleImpl = IFetcher(mipsImpl).oracle();\n _fo.set(_fo.preimageOracleImpl.selector, preimageOracleImpl);\n }\n\n address faultDisputeGameImpl = _getFaultDisputeGame(disputeGameFactoryProxy);\n if (faultDisputeGameImpl != address(0)) {\n // permissionless fault proofs installed\n _fo.set(_fo.faultDisputeGameImpl.selector, faultDisputeGameImpl);\n _fo.set(_fo.permissionless.selector, true);\n\n address delayedWethPermissionlessGameProxy = _getDelayedWETHProxy(faultDisputeGameImpl);\n _fo.set(_fo.delayedWethPermissionlessGameProxy.selector, delayedWethPermissionlessGameProxy);\n }\n } else {\n // some older chains have L2OutputOracle instead of DisputeGameFactory.\n address l2OutputOracleProxy = IFetcher(optimismPortalProxy).L2_ORACLE();\n _fo.set(_fo.l2OutputOracleProxy.selector, l2OutputOracleProxy);\n address proposer = IFetcher(l2OutputOracleProxy).PROPOSER();\n _fo.set(_fo.proposer.selector, proposer);\n }\n }\n\n function _getGuardian(address _portal) internal view returns (address) {\n try IFetcher(_portal).guardian() returns (address guardian_) {\n return guardian_;\n } catch {\n return IFetcher(_portal).GUARDIAN();\n }\n }\n\n function _getSystemConfigProxy(address _portal) internal view returns (address) {\n try IFetcher(_portal).systemConfig() returns (address systemConfig_) {\n return systemConfig_;\n } catch {\n return IFetcher(_portal).SYSTEM_CONFIG();\n }\n }\n\n function _getOptimismPortalProxy(address _l1CrossDomainMessengerProxy) internal view returns (address) {\n try IFetcher(_l1CrossDomainMessengerProxy).portal() returns (address optimismPortal_) {\n return optimismPortal_;\n } catch {\n return IFetcher(_l1CrossDomainMessengerProxy).PORTAL();\n }\n }\n\n function _getAddressManager(address _l1CrossDomainMessengerProxy) internal view returns (address) {\n uint256 ADDRESS_MANAGER_MAPPING_SLOT = 1;\n bytes32 slot = keccak256(abi.encode(_l1CrossDomainMessengerProxy, ADDRESS_MANAGER_MAPPING_SLOT));\n return address(uint160(uint256((vm.load(_l1CrossDomainMessengerProxy, slot)))));\n }\n\n function _getL1ERC721BridgeProxy(address _systemConfigProxy) internal view returns (address) {\n try IFetcher(_systemConfigProxy).l1ERC721Bridge() returns (address l1ERC721BridgeProxy_) {\n return l1ERC721BridgeProxy_;\n } catch {\n return address(0);\n }\n }\n\n function _getOptimismMintableERC20FactoryProxy(address _systemConfigProxy) internal view returns (address) {\n try IFetcher(_systemConfigProxy).optimismMintableERC20Factory() returns (\n address optimismMintableERC20FactoryProxy_\n ) {\n return optimismMintableERC20FactoryProxy_;\n } catch {\n return address(0);\n }\n }\n\n function _getDisputeGameFactoryProxy(address _systemConfigProxy) internal view returns (address) {\n try IFetcher(_systemConfigProxy).disputeGameFactory() returns (address disputeGameFactoryProxy_) {\n return disputeGameFactoryProxy_;\n } catch {\n // Some older chains have L2OutputOracle instead of DisputeGameFactory\n return address(0);\n }\n }\n\n function _getSuperchainConfigProxy(address _optimismPortalProxy) internal view returns (address) {\n try IFetcher(_optimismPortalProxy).superchainConfig() returns (address superchainConfigProxy_) {\n return superchainConfigProxy_;\n } catch {\n return address(0);\n }\n }\n\n function _getFaultDisputeGame(address _disputeGameFactoryProxy) internal view returns (address) {\n try IFetcher(_disputeGameFactoryProxy).gameImpls(GameTypes.CANNON) returns (address faultDisputeGame_) {\n return faultDisputeGame_;\n } catch {\n return address(0);\n }\n }\n\n function _getPermissionedDisputeGame(address _disputeGameFactoryProxy) internal view returns (address) {\n try IFetcher(_disputeGameFactoryProxy).gameImpls(GameTypes.PERMISSIONED_CANNON) returns (\n address permissionedDisputeGame_\n ) {\n return permissionedDisputeGame_;\n } catch {\n return address(0);\n }\n }\n\n function _getEthLockboxProxy(address _optimismPortalProxy) internal view returns (address) {\n try IFetcher(_optimismPortalProxy).ethLockbox() returns (address ethLockbox_) {\n return ethLockbox_;\n } catch {\n return address(0);\n }\n }\n\n function _getDelayedWETHProxy(address _disputeGame) internal view returns (address) {\n (bool ok, bytes memory data) = address(_disputeGame).staticcall(abi.encodeCall(IFetcher.weth, ()));\n if (ok && data.length == 32) return abi.decode(data, (address));\n else return address(0);\n }\n\n function _getBatchSubmitter(address _systemConfigProxy) internal view returns (address) {\n bytes32 batcherHash = IFetcher(_systemConfigProxy).batcherHash();\n return address(uint160(uint256(batcherHash)));\n }\n\n function _getProxyAdmin(address _systemConfigProxy) internal returns (address) {\n vm.prank(address(0));\n return IFetcher(_systemConfigProxy).admin();\n }\n}\n","license":"MIT"},"src/dispute/lib/LibPosition.sol":{"keccak256":"0x7c5f19f8f54f06de2ce1c6cdcc5c7af65ac405130a4066cdaf146ca315818241","urls":[],"content":"// SPDX-License-Identifier: MIT\npragma solidity ^0.8.15;\n\nusing LibPosition for Position global;\n\n/// @notice A `Position` represents a position of a claim within the game tree.\n/// @dev This is represented as a \"generalized index\" where the high-order bit\n/// is the level in the tree and the remaining bits is a unique bit pattern, allowing\n/// a unique identifier for each node in the tree. Mathematically, it is calculated\n/// as 2^{depth} + indexAtDepth.\ntype Position is uint128;\n\n/// @title LibPosition\n/// @notice This library contains helper functions for working with the `Position` type.\nlibrary LibPosition {\n /// @notice the `MAX_POSITION_BITLEN` is the number of bits that the `Position` type, and the implementation of\n /// its behavior within this library, can safely support.\n uint8 internal constant MAX_POSITION_BITLEN = 126;\n\n /// @notice Computes a generalized index (2^{depth} + indexAtDepth).\n /// @param _depth The depth of the position.\n /// @param _indexAtDepth The index at the depth of the position.\n /// @return position_ The computed generalized index.\n function wrap(uint8 _depth, uint128 _indexAtDepth) internal pure returns (Position position_) {\n assembly {\n // gindex = 2^{_depth} + _indexAtDepth\n position_ := add(shl(_depth, 1), _indexAtDepth)\n }\n }\n\n /// @notice Pulls the `depth` out of a `Position` type.\n /// @param _position The generalized index to get the `depth` of.\n /// @return depth_ The `depth` of the `position` gindex.\n /// @custom:attribution Solady \n function depth(Position _position) internal pure returns (uint8 depth_) {\n // Return the most significant bit offset, which signifies the depth of the gindex.\n assembly {\n depth_ := or(depth_, shl(6, lt(0xffffffffffffffff, shr(depth_, _position))))\n depth_ := or(depth_, shl(5, lt(0xffffffff, shr(depth_, _position))))\n\n // For the remaining 32 bits, use a De Bruijn lookup.\n _position := shr(depth_, _position)\n _position := or(_position, shr(1, _position))\n _position := or(_position, shr(2, _position))\n _position := or(_position, shr(4, _position))\n _position := or(_position, shr(8, _position))\n _position := or(_position, shr(16, _position))\n\n depth_ :=\n or(\n depth_,\n byte(\n shr(251, mul(_position, shl(224, 0x07c4acdd))),\n 0x0009010a0d15021d0b0e10121619031e080c141c0f111807131b17061a05041f\n )\n )\n }\n }\n\n /// @notice Pulls the `indexAtDepth` out of a `Position` type.\n /// The `indexAtDepth` is the left/right index of a position at a specific depth within\n /// the binary tree, starting from index 0. For example, at gindex 2, the `depth` = 1\n /// and the `indexAtDepth` = 0.\n /// @param _position The generalized index to get the `indexAtDepth` of.\n /// @return indexAtDepth_ The `indexAtDepth` of the `position` gindex.\n function indexAtDepth(Position _position) internal pure returns (uint128 indexAtDepth_) {\n // Return bits p_{msb-1}...p_{0}. This effectively pulls the 2^{depth} out of the gindex,\n // leaving only the `indexAtDepth`.\n uint256 msb = depth(_position);\n assembly {\n indexAtDepth_ := sub(_position, shl(msb, 1))\n }\n }\n\n /// @notice Get the left child of `_position`.\n /// @param _position The position to get the left position of.\n /// @return left_ The position to the left of `position`.\n function left(Position _position) internal pure returns (Position left_) {\n assembly {\n left_ := shl(1, _position)\n }\n }\n\n /// @notice Get the right child of `_position`\n /// @param _position The position to get the right position of.\n /// @return right_ The position to the right of `position`.\n function right(Position _position) internal pure returns (Position right_) {\n assembly {\n right_ := or(1, shl(1, _position))\n }\n }\n\n /// @notice Get the parent position of `_position`.\n /// @param _position The position to get the parent position of.\n /// @return parent_ The parent position of `position`.\n function parent(Position _position) internal pure returns (Position parent_) {\n assembly {\n parent_ := shr(1, _position)\n }\n }\n\n /// @notice Get the deepest, right most gindex relative to the `position`. This is equivalent to\n /// calling `right` on a position until the maximum depth is reached.\n /// @param _position The position to get the relative deepest, right most gindex of.\n /// @param _maxDepth The maximum depth of the game.\n /// @return rightIndex_ The deepest, right most gindex relative to the `position`.\n function rightIndex(Position _position, uint256 _maxDepth) internal pure returns (Position rightIndex_) {\n uint256 msb = depth(_position);\n assembly {\n let remaining := sub(_maxDepth, msb)\n rightIndex_ := or(shl(remaining, _position), sub(shl(remaining, 1), 1))\n }\n }\n\n /// @notice Get the deepest, right most trace index relative to the `position`. This is\n /// equivalent to calling `right` on a position until the maximum depth is reached and\n /// then finding its index at depth.\n /// @param _position The position to get the relative trace index of.\n /// @param _maxDepth The maximum depth of the game.\n /// @return traceIndex_ The trace index relative to the `position`.\n function traceIndex(Position _position, uint256 _maxDepth) internal pure returns (uint256 traceIndex_) {\n uint256 msb = depth(_position);\n assembly {\n let remaining := sub(_maxDepth, msb)\n traceIndex_ := sub(or(shl(remaining, _position), sub(shl(remaining, 1), 1)), shl(_maxDepth, 1))\n }\n }\n\n /// @notice Gets the position of the highest ancestor of `_position` that commits to the same\n /// trace index.\n /// @param _position The position to get the highest ancestor of.\n /// @return ancestor_ The highest ancestor of `position` that commits to the same trace index.\n function traceAncestor(Position _position) internal pure returns (Position ancestor_) {\n // Create a field with only the lowest unset bit of `_position` set.\n Position lsb;\n assembly {\n lsb := and(not(_position), add(_position, 1))\n }\n // Find the index of the lowest unset bit within the field.\n uint256 msb = depth(lsb);\n // The highest ancestor that commits to the same trace index is the original position\n // shifted right by the index of the lowest unset bit.\n assembly {\n let a := shr(msb, _position)\n // Bound the ancestor to the minimum gindex, 1.\n ancestor_ := or(a, iszero(a))\n }\n }\n\n /// @notice Gets the position of the highest ancestor of `_position` that commits to the same\n /// trace index, while still being below `_upperBoundExclusive`.\n /// @param _position The position to get the highest ancestor of.\n /// @param _upperBoundExclusive The exclusive upper depth bound, used to inform where to stop in order\n /// to not escape a sub-tree.\n /// @return ancestor_ The highest ancestor of `position` that commits to the same trace index.\n function traceAncestorBounded(\n Position _position,\n uint256 _upperBoundExclusive\n )\n internal\n pure\n returns (Position ancestor_)\n {\n // This function only works for positions that are below the upper bound.\n if (_position.depth() <= _upperBoundExclusive) {\n assembly {\n // Revert with `ClaimAboveSplit()`\n mstore(0x00, 0xb34b5c22)\n revert(0x1C, 0x04)\n }\n }\n\n // Grab the global trace ancestor.\n ancestor_ = traceAncestor(_position);\n\n // If the ancestor is above or at the upper bound, shift it to be below the upper bound.\n // This should be a special case that only covers positions that commit to the final leaf\n // in a sub-tree.\n if (ancestor_.depth() <= _upperBoundExclusive) {\n ancestor_ = ancestor_.rightIndex(_upperBoundExclusive + 1);\n }\n }\n\n /// @notice Get the move position of `_position`, which is the left child of:\n /// 1. `_position` if `_isAttack` is true.\n /// 2. `_position | 1` if `_isAttack` is false.\n /// @param _position The position to get the relative attack/defense position of.\n /// @param _isAttack Whether or not the move is an attack move.\n /// @return move_ The move position relative to `position`.\n function move(Position _position, bool _isAttack) internal pure returns (Position move_) {\n assembly {\n move_ := shl(1, or(iszero(_isAttack), _position))\n }\n }\n\n /// @notice Get the value of a `Position` type in the form of the underlying uint128.\n /// @param _position The position to get the value of.\n /// @return raw_ The value of the `position` as a uint128 type.\n function raw(Position _position) internal pure returns (uint128 raw_) {\n assembly {\n raw_ := _position\n }\n }\n}\n","license":"MIT"},"src/dispute/lib/LibUDT.sol":{"keccak256":"0x41d55e9c74d979b5b797198e38449e7cef4f925e04d61f7699e9c150c4a659d3","urls":[],"content":"// SPDX-License-Identifier: MIT\npragma solidity ^0.8.15;\n\n// Libraries\nimport { Position } from \"src/dispute/lib/LibPosition.sol\";\n\nusing LibClaim for Claim global;\nusing LibHash for Hash global;\nusing LibDuration for Duration global;\nusing LibClock for Clock global;\nusing LibGameId for GameId global;\nusing LibTimestamp for Timestamp global;\nusing LibVMStatus for VMStatus global;\nusing LibGameType for GameType global;\n\n/// @notice A `Clock` represents a packed `Duration` and `Timestamp`\n/// @dev The packed layout of this type is as follows:\n/// ┌────────────┬────────────────┐\n/// │ Bits │ Value │\n/// ├────────────┼────────────────┤\n/// │ [0, 64) │ Duration │\n/// │ [64, 128) │ Timestamp │\n/// └────────────┴────────────────┘\ntype Clock is uint128;\n\n/// @title LibClock\n/// @notice This library contains helper functions for working with the `Clock` type.\nlibrary LibClock {\n /// @notice Packs a `Duration` and `Timestamp` into a `Clock` type.\n /// @param _duration The `Duration` to pack into the `Clock` type.\n /// @param _timestamp The `Timestamp` to pack into the `Clock` type.\n /// @return clock_ The `Clock` containing the `_duration` and `_timestamp`.\n function wrap(Duration _duration, Timestamp _timestamp) internal pure returns (Clock clock_) {\n assembly {\n clock_ := or(shl(0x40, _duration), _timestamp)\n }\n }\n\n /// @notice Pull the `Duration` out of a `Clock` type.\n /// @param _clock The `Clock` type to pull the `Duration` out of.\n /// @return duration_ The `Duration` pulled out of `_clock`.\n function duration(Clock _clock) internal pure returns (Duration duration_) {\n // Shift the high-order 64 bits into the low-order 64 bits, leaving only the `duration`.\n assembly {\n duration_ := shr(0x40, _clock)\n }\n }\n\n /// @notice Pull the `Timestamp` out of a `Clock` type.\n /// @param _clock The `Clock` type to pull the `Timestamp` out of.\n /// @return timestamp_ The `Timestamp` pulled out of `_clock`.\n function timestamp(Clock _clock) internal pure returns (Timestamp timestamp_) {\n // Clean the high-order 192 bits by shifting the clock left and then right again, leaving\n // only the `timestamp`.\n assembly {\n timestamp_ := shr(0xC0, shl(0xC0, _clock))\n }\n }\n\n /// @notice Get the value of a `Clock` type in the form of the underlying uint128.\n /// @param _clock The `Clock` type to get the value of.\n /// @return clock_ The value of the `Clock` type as a uint128 type.\n function raw(Clock _clock) internal pure returns (uint128 clock_) {\n assembly {\n clock_ := _clock\n }\n }\n}\n\n/// @notice A `GameId` represents a packed 4 byte game ID, a 8 byte timestamp, and a 20 byte address.\n/// @dev The packed layout of this type is as follows:\n/// ┌───────────┬───────────┐\n/// │ Bits │ Value │\n/// ├───────────┼───────────┤\n/// │ [0, 32) │ Game Type │\n/// │ [32, 96) │ Timestamp │\n/// │ [96, 256) │ Address │\n/// └───────────┴───────────┘\ntype GameId is bytes32;\n\n/// @title LibGameId\n/// @notice Utility functions for packing and unpacking GameIds.\nlibrary LibGameId {\n /// @notice Packs values into a 32 byte GameId type.\n /// @param _gameType The game type.\n /// @param _timestamp The timestamp of the game's creation.\n /// @param _gameProxy The game proxy address.\n /// @return gameId_ The packed GameId.\n function pack(\n GameType _gameType,\n Timestamp _timestamp,\n address _gameProxy\n )\n internal\n pure\n returns (GameId gameId_)\n {\n assembly {\n gameId_ := or(or(shl(224, _gameType), shl(160, _timestamp)), _gameProxy)\n }\n }\n\n /// @notice Unpacks values from a 32 byte GameId type.\n /// @param _gameId The packed GameId.\n /// @return gameType_ The game type.\n /// @return timestamp_ The timestamp of the game's creation.\n /// @return gameProxy_ The game proxy address.\n function unpack(GameId _gameId)\n internal\n pure\n returns (GameType gameType_, Timestamp timestamp_, address gameProxy_)\n {\n assembly {\n gameType_ := shr(224, _gameId)\n timestamp_ := and(shr(160, _gameId), 0xFFFFFFFFFFFFFFFF)\n gameProxy_ := and(_gameId, 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF)\n }\n }\n}\n\n/// @notice A claim represents an MPT root representing the state of the fault proof program.\ntype Claim is bytes32;\n\n/// @title LibClaim\n/// @notice This library contains helper functions for working with the `Claim` type.\nlibrary LibClaim {\n /// @notice Get the value of a `Claim` type in the form of the underlying bytes32.\n /// @param _claim The `Claim` type to get the value of.\n /// @return claim_ The value of the `Claim` type as a bytes32 type.\n function raw(Claim _claim) internal pure returns (bytes32 claim_) {\n assembly {\n claim_ := _claim\n }\n }\n\n /// @notice Hashes a claim and a position together.\n /// @param _claim A Claim type.\n /// @param _position The position of `claim`.\n /// @param _challengeIndex The index of the claim being moved against.\n /// @return claimHash_ A hash of abi.encodePacked(claim, position|challengeIndex);\n function hashClaimPos(\n Claim _claim,\n Position _position,\n uint256 _challengeIndex\n )\n internal\n pure\n returns (Hash claimHash_)\n {\n assembly {\n mstore(0x00, _claim)\n mstore(0x20, or(shl(128, _position), and(0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF, _challengeIndex)))\n claimHash_ := keccak256(0x00, 0x40)\n }\n }\n}\n\n/// @notice A dedicated duration type.\n/// @dev Unit: seconds\ntype Duration is uint64;\n\n/// @title LibDuration\n/// @notice This library contains helper functions for working with the `Duration` type.\nlibrary LibDuration {\n /// @notice Get the value of a `Duration` type in the form of the underlying uint64.\n /// @param _duration The `Duration` type to get the value of.\n /// @return duration_ The value of the `Duration` type as a uint64 type.\n function raw(Duration _duration) internal pure returns (uint64 duration_) {\n assembly {\n duration_ := _duration\n }\n }\n}\n\n/// @notice A custom type for a generic hash.\ntype Hash is bytes32;\n\n/// @title LibHash\n/// @notice This library contains helper functions for working with the `Hash` type.\nlibrary LibHash {\n /// @notice Get the value of a `Hash` type in the form of the underlying bytes32.\n /// @param _hash The `Hash` type to get the value of.\n /// @return hash_ The value of the `Hash` type as a bytes32 type.\n function raw(Hash _hash) internal pure returns (bytes32 hash_) {\n assembly {\n hash_ := _hash\n }\n }\n}\n\n/// @notice A dedicated timestamp type.\ntype Timestamp is uint64;\n\n/// @title LibTimestamp\n/// @notice This library contains helper functions for working with the `Timestamp` type.\nlibrary LibTimestamp {\n /// @notice Get the value of a `Timestamp` type in the form of the underlying uint64.\n /// @param _timestamp The `Timestamp` type to get the value of.\n /// @return timestamp_ The value of the `Timestamp` type as a uint64 type.\n function raw(Timestamp _timestamp) internal pure returns (uint64 timestamp_) {\n assembly {\n timestamp_ := _timestamp\n }\n }\n}\n\n/// @notice A `VMStatus` represents the status of a VM execution.\ntype VMStatus is uint8;\n\n/// @title LibVMStatus\n/// @notice This library contains helper functions for working with the `VMStatus` type.\nlibrary LibVMStatus {\n /// @notice Get the value of a `VMStatus` type in the form of the underlying uint8.\n /// @param _vmstatus The `VMStatus` type to get the value of.\n /// @return vmstatus_ The value of the `VMStatus` type as a uint8 type.\n function raw(VMStatus _vmstatus) internal pure returns (uint8 vmstatus_) {\n assembly {\n vmstatus_ := _vmstatus\n }\n }\n}\n\n/// @notice A `GameType` represents the type of game being played.\ntype GameType is uint32;\n\n/// @title LibGameType\n/// @notice This library contains helper functions for working with the `GameType` type.\nlibrary LibGameType {\n /// @notice Get the value of a `GameType` type in the form of the underlying uint32.\n /// @param _gametype The `GameType` type to get the value of.\n /// @return gametype_ The value of the `GameType` type as a uint32 type.\n function raw(GameType _gametype) internal pure returns (uint32 gametype_) {\n assembly {\n gametype_ := _gametype\n }\n }\n}\n","license":"MIT"},"src/dispute/lib/Types.sol":{"keccak256":"0x7cc2960ea5c5223d81ae2156a966fa0226b70f9666932aca63a0a2a45c9182ae","urls":[],"content":"// SPDX-License-Identifier: MIT\npragma solidity ^0.8.15;\n\n// Libraries\nimport {\n Position,\n Hash,\n GameType,\n VMStatus,\n Timestamp,\n Duration,\n Clock,\n GameId,\n Claim,\n LibGameId,\n LibClock\n} from \"src/dispute/lib/LibUDT.sol\";\n\n/// @notice The current status of the dispute game.\nenum GameStatus {\n // The game is currently in progress, and has not been resolved.\n IN_PROGRESS,\n // The game has concluded, and the `rootClaim` was challenged successfully.\n CHALLENGER_WINS,\n // The game has concluded, and the `rootClaim` could not be contested.\n DEFENDER_WINS\n}\n\n/// @notice The game's bond distribution type. Games are expected to start in the `UNDECIDED`\n/// state, and then choose either `NORMAL` or `REFUND`.\nenum BondDistributionMode {\n // Bond distribution strategy has not been chosen.\n UNDECIDED,\n // Bonds should be distributed as normal.\n NORMAL,\n // Bonds should be refunded to claimants.\n REFUND\n}\n\n/// @notice Represents an L2 root and the L2 sequence number at which it was generated.\n/// @custom:field root The output root.\n/// @custom:field l2SequenceNumber The L2 Sequence Number ( e.g. block number / timestamp) at which the root was\n/// generated.\nstruct Proposal {\n Hash root;\n uint256 l2SequenceNumber;\n}\n\n/// @title GameTypes\n/// @notice A library that defines the IDs of games that can be played.\nlibrary GameTypes {\n /// @dev A dispute game type the uses the cannon vm.\n GameType internal constant CANNON = GameType.wrap(0);\n\n /// @dev A permissioned dispute game type that uses the cannon vm.\n GameType internal constant PERMISSIONED_CANNON = GameType.wrap(1);\n\n /// @notice A dispute game type that uses the asterisc vm.\n GameType internal constant ASTERISC = GameType.wrap(2);\n\n /// @notice A dispute game type that uses the asterisc vm with Kona.\n GameType internal constant ASTERISC_KONA = GameType.wrap(3);\n\n /// @notice A dispute game type that uses the cannon vm (Super Roots).\n GameType internal constant SUPER_CANNON = GameType.wrap(4);\n\n /// @notice A dispute game type that uses the permissioned cannon vm (Super Roots).\n GameType internal constant SUPER_PERMISSIONED_CANNON = GameType.wrap(5);\n\n /// @notice A dispute game type that uses OP Succinct\n GameType internal constant OP_SUCCINCT = GameType.wrap(6);\n\n /// @notice A dispute game type with short game duration for testing withdrawals.\n /// Not intended for production use.\n GameType internal constant FAST = GameType.wrap(254);\n\n /// @notice A dispute game type that uses an alphabet vm.\n /// Not intended for production use.\n GameType internal constant ALPHABET = GameType.wrap(255);\n\n /// @notice A dispute game type that uses RISC Zero's Kailua\n GameType internal constant KAILUA = GameType.wrap(1337);\n}\n\n/// @title VMStatuses\n/// @notice Named type aliases for the various valid VM status bytes.\nlibrary VMStatuses {\n /// @notice The VM has executed successfully and the outcome is valid.\n VMStatus internal constant VALID = VMStatus.wrap(0);\n\n /// @notice The VM has executed successfully and the outcome is invalid.\n VMStatus internal constant INVALID = VMStatus.wrap(1);\n\n /// @notice The VM has paniced.\n VMStatus internal constant PANIC = VMStatus.wrap(2);\n\n /// @notice The VM execution is still in progress.\n VMStatus internal constant UNFINISHED = VMStatus.wrap(3);\n}\n\n/// @title LocalPreimageKey\n/// @notice Named type aliases for local `PreimageOracle` key identifiers.\nlibrary LocalPreimageKey {\n /// @notice The identifier for the L1 head hash.\n uint256 internal constant L1_HEAD_HASH = 0x01;\n\n /// @notice The identifier for the starting output root.\n uint256 internal constant STARTING_OUTPUT_ROOT = 0x02;\n\n /// @notice The identifier for the disputed output root.\n uint256 internal constant DISPUTED_OUTPUT_ROOT = 0x03;\n\n /// @notice The identifier for the disputed L2 block number.\n uint256 internal constant DISPUTED_L2_BLOCK_NUMBER = 0x04;\n\n /// @notice The identifier for the chain ID.\n uint256 internal constant CHAIN_ID = 0x05;\n}\n","license":"MIT"}},"version":1},"storageLayout":{"storage":[],"types":{}},"userdoc":{"version":1,"kind":"user","notice":"Contains getters for arbitrary methods from all L1 contracts, including legacy getters that have since been deprecated."},"devdoc":{"version":1,"kind":"dev"},"ast":{"absolutePath":"scripts/FetchChainInfo.s.sol","id":59300,"exportedSymbols":{"FetchChainInfo":[59299],"FetchChainInfoInput":[57409],"FetchChainInfoOutput":[58249],"GameType":[75355],"GameTypes":[75481],"IFetcher":[57326],"Script":[6037]},"nodeType":"SourceUnit","src":"32:23957:120","nodes":[{"id":57175,"nodeType":"PragmaDirective","src":"32:23:120","nodes":[],"literals":["solidity","^","0.8",".0"]},{"id":57177,"nodeType":"ImportDirective","src":"57:46:120","nodes":[],"absolutePath":"lib/forge-std/src/Script.sol","file":"forge-std/Script.sol","nameLocation":"-1:-1:-1","scope":59300,"sourceUnit":6038,"symbolAliases":[{"foreign":{"id":57176,"name":"Script","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":6037,"src":"66:6:120","typeDescriptions":{}},"nameLocation":"-1:-1:-1"}],"unitAlias":""},{"id":57180,"nodeType":"ImportDirective","src":"104:64:120","nodes":[],"absolutePath":"src/dispute/lib/Types.sol","file":"src/dispute/lib/Types.sol","nameLocation":"-1:-1:-1","scope":59300,"sourceUnit":75538,"symbolAliases":[{"foreign":{"id":57178,"name":"GameTypes","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":75481,"src":"113:9:120","typeDescriptions":{}},"nameLocation":"-1:-1:-1"},{"foreign":{"id":57179,"name":"GameType","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":75355,"src":"124:8:120","typeDescriptions":{}},"nameLocation":"-1:-1:-1"}],"unitAlias":""},{"id":57326,"nodeType":"ContractDefinition","src":"306:1713:120","nodes":[{"id":57186,"nodeType":"FunctionDefinition","src":"331:52:120","nodes":[],"functionSelector":"452a9320","implemented":false,"kind":"function","modifiers":[],"name":"guardian","nameLocation":"340:8:120","parameters":{"id":57182,"nodeType":"ParameterList","parameters":[],"src":"348:2:120"},"returnParameters":{"id":57185,"nodeType":"ParameterList","parameters":[{"constant":false,"id":57184,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":57186,"src":"374:7:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":57183,"name":"address","nodeType":"ElementaryTypeName","src":"374:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"373:9:120"},"scope":57326,"stateMutability":"view","virtual":false,"visibility":"external"},{"id":57191,"nodeType":"FunctionDefinition","src":"388:52:120","nodes":[],"functionSelector":"724c184c","implemented":false,"kind":"function","modifiers":[],"name":"GUARDIAN","nameLocation":"397:8:120","parameters":{"id":57187,"nodeType":"ParameterList","parameters":[],"src":"405:2:120"},"returnParameters":{"id":57190,"nodeType":"ParameterList","parameters":[{"constant":false,"id":57189,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":57191,"src":"431:7:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":57188,"name":"address","nodeType":"ElementaryTypeName","src":"431:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"430:9:120"},"scope":57326,"stateMutability":"view","virtual":false,"visibility":"external"},{"id":57196,"nodeType":"FunctionDefinition","src":"445:56:120","nodes":[],"functionSelector":"33d7e2bd","implemented":false,"kind":"function","modifiers":[],"name":"systemConfig","nameLocation":"454:12:120","parameters":{"id":57192,"nodeType":"ParameterList","parameters":[],"src":"466:2:120"},"returnParameters":{"id":57195,"nodeType":"ParameterList","parameters":[{"constant":false,"id":57194,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":57196,"src":"492:7:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":57193,"name":"address","nodeType":"ElementaryTypeName","src":"492:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"491:9:120"},"scope":57326,"stateMutability":"view","virtual":false,"visibility":"external"},{"id":57201,"nodeType":"FunctionDefinition","src":"506:57:120","nodes":[],"functionSelector":"f0498750","implemented":false,"kind":"function","modifiers":[],"name":"SYSTEM_CONFIG","nameLocation":"515:13:120","parameters":{"id":57197,"nodeType":"ParameterList","parameters":[],"src":"528:2:120"},"returnParameters":{"id":57200,"nodeType":"ParameterList","parameters":[{"constant":false,"id":57199,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":57201,"src":"554:7:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":57198,"name":"address","nodeType":"ElementaryTypeName","src":"554:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"553:9:120"},"scope":57326,"stateMutability":"view","virtual":false,"visibility":"external"},{"id":57206,"nodeType":"FunctionDefinition","src":"568:62:120","nodes":[],"functionSelector":"f2b4e617","implemented":false,"kind":"function","modifiers":[],"name":"disputeGameFactory","nameLocation":"577:18:120","parameters":{"id":57202,"nodeType":"ParameterList","parameters":[],"src":"595:2:120"},"returnParameters":{"id":57205,"nodeType":"ParameterList","parameters":[{"constant":false,"id":57204,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":57206,"src":"621:7:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":57203,"name":"address","nodeType":"ElementaryTypeName","src":"621:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"620:9:120"},"scope":57326,"stateMutability":"view","virtual":false,"visibility":"external"},{"id":57211,"nodeType":"FunctionDefinition","src":"635:54:120","nodes":[],"functionSelector":"b682c444","implemented":false,"kind":"function","modifiers":[],"name":"ethLockbox","nameLocation":"644:10:120","parameters":{"id":57207,"nodeType":"ParameterList","parameters":[],"src":"654:2:120"},"returnParameters":{"id":57210,"nodeType":"ParameterList","parameters":[{"constant":false,"id":57209,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":57211,"src":"680:7:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":57208,"name":"address","nodeType":"ElementaryTypeName","src":"680:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"679:9:120"},"scope":57326,"stateMutability":"view","virtual":false,"visibility":"external"},{"id":57216,"nodeType":"FunctionDefinition","src":"694:60:120","nodes":[],"functionSelector":"35e80ab3","implemented":false,"kind":"function","modifiers":[],"name":"superchainConfig","nameLocation":"703:16:120","parameters":{"id":57212,"nodeType":"ParameterList","parameters":[],"src":"719:2:120"},"returnParameters":{"id":57215,"nodeType":"ParameterList","parameters":[{"constant":false,"id":57214,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":57216,"src":"745:7:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":57213,"name":"address","nodeType":"ElementaryTypeName","src":"745:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"744:9:120"},"scope":57326,"stateMutability":"view","virtual":false,"visibility":"external"},{"id":57221,"nodeType":"FunctionDefinition","src":"759:53:120","nodes":[],"functionSelector":"3cb747bf","implemented":false,"kind":"function","modifiers":[],"name":"messenger","nameLocation":"768:9:120","parameters":{"id":57217,"nodeType":"ParameterList","parameters":[],"src":"777:2:120"},"returnParameters":{"id":57220,"nodeType":"ParameterList","parameters":[{"constant":false,"id":57219,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":57221,"src":"803:7:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":57218,"name":"address","nodeType":"ElementaryTypeName","src":"803:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"802:9:120"},"scope":57326,"stateMutability":"view","virtual":false,"visibility":"external"},{"id":57226,"nodeType":"FunctionDefinition","src":"817:58:120","nodes":[],"functionSelector":"3ab76e9f","implemented":false,"kind":"function","modifiers":[],"name":"addressManager","nameLocation":"826:14:120","parameters":{"id":57222,"nodeType":"ParameterList","parameters":[],"src":"840:2:120"},"returnParameters":{"id":57225,"nodeType":"ParameterList","parameters":[{"constant":false,"id":57224,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":57226,"src":"866:7:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":57223,"name":"address","nodeType":"ElementaryTypeName","src":"866:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"865:9:120"},"scope":57326,"stateMutability":"view","virtual":false,"visibility":"external"},{"id":57231,"nodeType":"FunctionDefinition","src":"880:50:120","nodes":[],"functionSelector":"0ff754ea","implemented":false,"kind":"function","modifiers":[],"name":"PORTAL","nameLocation":"889:6:120","parameters":{"id":57227,"nodeType":"ParameterList","parameters":[],"src":"895:2:120"},"returnParameters":{"id":57230,"nodeType":"ParameterList","parameters":[{"constant":false,"id":57229,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":57231,"src":"921:7:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":57228,"name":"address","nodeType":"ElementaryTypeName","src":"921:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"920:9:120"},"scope":57326,"stateMutability":"view","virtual":false,"visibility":"external"},{"id":57236,"nodeType":"FunctionDefinition","src":"935:50:120","nodes":[],"functionSelector":"6425666b","implemented":false,"kind":"function","modifiers":[],"name":"portal","nameLocation":"944:6:120","parameters":{"id":57232,"nodeType":"ParameterList","parameters":[],"src":"950:2:120"},"returnParameters":{"id":57235,"nodeType":"ParameterList","parameters":[{"constant":false,"id":57234,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":57236,"src":"976:7:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":57233,"name":"address","nodeType":"ElementaryTypeName","src":"976:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"975:9:120"},"scope":57326,"stateMutability":"view","virtual":false,"visibility":"external"},{"id":57241,"nodeType":"FunctionDefinition","src":"990:58:120","nodes":[],"functionSelector":"c4e8ddfa","implemented":false,"kind":"function","modifiers":[],"name":"l1ERC721Bridge","nameLocation":"999:14:120","parameters":{"id":57237,"nodeType":"ParameterList","parameters":[],"src":"1013:2:120"},"returnParameters":{"id":57240,"nodeType":"ParameterList","parameters":[{"constant":false,"id":57239,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":57241,"src":"1039:7:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":57238,"name":"address","nodeType":"ElementaryTypeName","src":"1039:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"1038:9:120"},"scope":57326,"stateMutability":"view","virtual":false,"visibility":"external"},{"id":57246,"nodeType":"FunctionDefinition","src":"1053:72:120","nodes":[],"functionSelector":"9b7d7f0a","implemented":false,"kind":"function","modifiers":[],"name":"optimismMintableERC20Factory","nameLocation":"1062:28:120","parameters":{"id":57242,"nodeType":"ParameterList","parameters":[],"src":"1090:2:120"},"returnParameters":{"id":57245,"nodeType":"ParameterList","parameters":[{"constant":false,"id":57244,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":57246,"src":"1116:7:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":57243,"name":"address","nodeType":"ElementaryTypeName","src":"1116:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"1115:9:120"},"scope":57326,"stateMutability":"view","virtual":false,"visibility":"external"},{"id":57254,"nodeType":"FunctionDefinition","src":"1130:71:120","nodes":[],"functionSelector":"1b685b9e","implemented":false,"kind":"function","modifiers":[],"name":"gameImpls","nameLocation":"1139:9:120","parameters":{"id":57250,"nodeType":"ParameterList","parameters":[{"constant":false,"id":57249,"mutability":"mutable","name":"_gameType","nameLocation":"1158:9:120","nodeType":"VariableDeclaration","scope":57254,"src":"1149:18:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_userDefinedValueType$_GameType_$75355","typeString":"GameType"},"typeName":{"id":57248,"nodeType":"UserDefinedTypeName","pathNode":{"id":57247,"name":"GameType","nameLocations":["1149:8:120"],"nodeType":"IdentifierPath","referencedDeclaration":75355,"src":"1149:8:120"},"referencedDeclaration":75355,"src":"1149:8:120","typeDescriptions":{"typeIdentifier":"t_userDefinedValueType$_GameType_$75355","typeString":"GameType"}},"visibility":"internal"}],"src":"1148:20:120"},"returnParameters":{"id":57253,"nodeType":"ParameterList","parameters":[{"constant":false,"id":57252,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":57254,"src":"1192:7:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":57251,"name":"address","nodeType":"ElementaryTypeName","src":"1192:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"1191:9:120"},"scope":57326,"stateMutability":"view","virtual":false,"visibility":"external"},{"id":57260,"nodeType":"FunctionDefinition","src":"1206:62:120","nodes":[],"functionSelector":"3c9f397c","implemented":false,"kind":"function","modifiers":[],"name":"respectedGameType","nameLocation":"1215:17:120","parameters":{"id":57255,"nodeType":"ParameterList","parameters":[],"src":"1232:2:120"},"returnParameters":{"id":57259,"nodeType":"ParameterList","parameters":[{"constant":false,"id":57258,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":57260,"src":"1258:8:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_userDefinedValueType$_GameType_$75355","typeString":"GameType"},"typeName":{"id":57257,"nodeType":"UserDefinedTypeName","pathNode":{"id":57256,"name":"GameType","nameLocations":["1258:8:120"],"nodeType":"IdentifierPath","referencedDeclaration":75355,"src":"1258:8:120"},"referencedDeclaration":75355,"src":"1258:8:120","typeDescriptions":{"typeIdentifier":"t_userDefinedValueType$_GameType_$75355","typeString":"GameType"}},"visibility":"internal"}],"src":"1257:10:120"},"scope":57326,"stateMutability":"view","virtual":false,"visibility":"external"},{"id":57265,"nodeType":"FunctionDefinition","src":"1273:63:120","nodes":[],"functionSelector":"5c0cba33","implemented":false,"kind":"function","modifiers":[],"name":"anchorStateRegistry","nameLocation":"1282:19:120","parameters":{"id":57261,"nodeType":"ParameterList","parameters":[],"src":"1301:2:120"},"returnParameters":{"id":57264,"nodeType":"ParameterList","parameters":[{"constant":false,"id":57263,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":57265,"src":"1327:7:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":57262,"name":"address","nodeType":"ElementaryTypeName","src":"1327:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"1326:9:120"},"scope":57326,"stateMutability":"view","virtual":false,"visibility":"external"},{"id":57270,"nodeType":"FunctionDefinition","src":"1341:53:120","nodes":[],"functionSelector":"001c2ff6","implemented":false,"kind":"function","modifiers":[],"name":"L2_ORACLE","nameLocation":"1350:9:120","parameters":{"id":57266,"nodeType":"ParameterList","parameters":[],"src":"1359:2:120"},"returnParameters":{"id":57269,"nodeType":"ParameterList","parameters":[{"constant":false,"id":57268,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":57270,"src":"1385:7:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":57267,"name":"address","nodeType":"ElementaryTypeName","src":"1385:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"1384:9:120"},"scope":57326,"stateMutability":"view","virtual":false,"visibility":"external"},{"id":57275,"nodeType":"FunctionDefinition","src":"1399:52:120","nodes":[],"functionSelector":"9b5f694a","implemented":false,"kind":"function","modifiers":[],"name":"l2Oracle","nameLocation":"1408:8:120","parameters":{"id":57271,"nodeType":"ParameterList","parameters":[],"src":"1416:2:120"},"returnParameters":{"id":57274,"nodeType":"ParameterList","parameters":[{"constant":false,"id":57273,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":57275,"src":"1442:7:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":57272,"name":"address","nodeType":"ElementaryTypeName","src":"1442:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"1441:9:120"},"scope":57326,"stateMutability":"view","virtual":false,"visibility":"external"},{"id":57280,"nodeType":"FunctionDefinition","src":"1456:46:120","nodes":[],"functionSelector":"3a768463","implemented":false,"kind":"function","modifiers":[],"name":"vm","nameLocation":"1465:2:120","parameters":{"id":57276,"nodeType":"ParameterList","parameters":[],"src":"1467:2:120"},"returnParameters":{"id":57279,"nodeType":"ParameterList","parameters":[{"constant":false,"id":57278,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":57280,"src":"1493:7:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":57277,"name":"address","nodeType":"ElementaryTypeName","src":"1493:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"1492:9:120"},"scope":57326,"stateMutability":"view","virtual":false,"visibility":"external"},{"id":57285,"nodeType":"FunctionDefinition","src":"1507:50:120","nodes":[],"functionSelector":"7dc0d1d0","implemented":false,"kind":"function","modifiers":[],"name":"oracle","nameLocation":"1516:6:120","parameters":{"id":57281,"nodeType":"ParameterList","parameters":[],"src":"1522:2:120"},"returnParameters":{"id":57284,"nodeType":"ParameterList","parameters":[{"constant":false,"id":57283,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":57285,"src":"1548:7:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":57282,"name":"address","nodeType":"ElementaryTypeName","src":"1548:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"1547:9:120"},"scope":57326,"stateMutability":"view","virtual":false,"visibility":"external"},{"id":57290,"nodeType":"FunctionDefinition","src":"1562:54:120","nodes":[],"functionSelector":"534db0e2","implemented":false,"kind":"function","modifiers":[],"name":"challenger","nameLocation":"1571:10:120","parameters":{"id":57286,"nodeType":"ParameterList","parameters":[],"src":"1581:2:120"},"returnParameters":{"id":57289,"nodeType":"ParameterList","parameters":[{"constant":false,"id":57288,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":57290,"src":"1607:7:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":57287,"name":"address","nodeType":"ElementaryTypeName","src":"1607:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"1606:9:120"},"scope":57326,"stateMutability":"view","virtual":false,"visibility":"external"},{"id":57295,"nodeType":"FunctionDefinition","src":"1621:52:120","nodes":[],"functionSelector":"a8e4fb90","implemented":false,"kind":"function","modifiers":[],"name":"proposer","nameLocation":"1630:8:120","parameters":{"id":57291,"nodeType":"ParameterList","parameters":[],"src":"1638:2:120"},"returnParameters":{"id":57294,"nodeType":"ParameterList","parameters":[{"constant":false,"id":57293,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":57295,"src":"1664:7:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":57292,"name":"address","nodeType":"ElementaryTypeName","src":"1664:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"1663:9:120"},"scope":57326,"stateMutability":"view","virtual":false,"visibility":"external"},{"id":57300,"nodeType":"FunctionDefinition","src":"1678:52:120","nodes":[],"functionSelector":"bffa7f0f","implemented":false,"kind":"function","modifiers":[],"name":"PROPOSER","nameLocation":"1687:8:120","parameters":{"id":57296,"nodeType":"ParameterList","parameters":[],"src":"1695:2:120"},"returnParameters":{"id":57299,"nodeType":"ParameterList","parameters":[{"constant":false,"id":57298,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":57300,"src":"1721:7:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":57297,"name":"address","nodeType":"ElementaryTypeName","src":"1721:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"1720:9:120"},"scope":57326,"stateMutability":"view","virtual":false,"visibility":"external"},{"id":57305,"nodeType":"FunctionDefinition","src":"1735:55:120","nodes":[],"functionSelector":"e81b2c6d","implemented":false,"kind":"function","modifiers":[],"name":"batcherHash","nameLocation":"1744:11:120","parameters":{"id":57301,"nodeType":"ParameterList","parameters":[],"src":"1755:2:120"},"returnParameters":{"id":57304,"nodeType":"ParameterList","parameters":[{"constant":false,"id":57303,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":57305,"src":"1781:7:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_bytes32","typeString":"bytes32"},"typeName":{"id":57302,"name":"bytes32","nodeType":"ElementaryTypeName","src":"1781:7:120","typeDescriptions":{"typeIdentifier":"t_bytes32","typeString":"bytes32"}},"visibility":"internal"}],"src":"1780:9:120"},"scope":57326,"stateMutability":"view","virtual":false,"visibility":"external"},{"id":57310,"nodeType":"FunctionDefinition","src":"1795:49:120","nodes":[],"functionSelector":"f851a440","implemented":false,"kind":"function","modifiers":[],"name":"admin","nameLocation":"1804:5:120","parameters":{"id":57306,"nodeType":"ParameterList","parameters":[],"src":"1809:2:120"},"returnParameters":{"id":57309,"nodeType":"ParameterList","parameters":[{"constant":false,"id":57308,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":57310,"src":"1835:7:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":57307,"name":"address","nodeType":"ElementaryTypeName","src":"1835:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"1834:9:120"},"scope":57326,"stateMutability":"view","virtual":false,"visibility":"external"},{"id":57315,"nodeType":"FunctionDefinition","src":"1849:49:120","nodes":[],"functionSelector":"8da5cb5b","implemented":false,"kind":"function","modifiers":[],"name":"owner","nameLocation":"1858:5:120","parameters":{"id":57311,"nodeType":"ParameterList","parameters":[],"src":"1863:2:120"},"returnParameters":{"id":57314,"nodeType":"ParameterList","parameters":[{"constant":false,"id":57313,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":57315,"src":"1889:7:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":57312,"name":"address","nodeType":"ElementaryTypeName","src":"1889:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"1888:9:120"},"scope":57326,"stateMutability":"view","virtual":false,"visibility":"external"},{"id":57320,"nodeType":"FunctionDefinition","src":"1903:61:120","nodes":[],"functionSelector":"1fd19ee1","implemented":false,"kind":"function","modifiers":[],"name":"unsafeBlockSigner","nameLocation":"1912:17:120","parameters":{"id":57316,"nodeType":"ParameterList","parameters":[],"src":"1929:2:120"},"returnParameters":{"id":57319,"nodeType":"ParameterList","parameters":[{"constant":false,"id":57318,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":57320,"src":"1955:7:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":57317,"name":"address","nodeType":"ElementaryTypeName","src":"1955:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"1954:9:120"},"scope":57326,"stateMutability":"view","virtual":false,"visibility":"external"},{"id":57325,"nodeType":"FunctionDefinition","src":"1969:48:120","nodes":[],"functionSelector":"3fc8cef3","implemented":false,"kind":"function","modifiers":[],"name":"weth","nameLocation":"1978:4:120","parameters":{"id":57321,"nodeType":"ParameterList","parameters":[],"src":"1982:2:120"},"returnParameters":{"id":57324,"nodeType":"ParameterList","parameters":[{"constant":false,"id":57323,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":57325,"src":"2008:7:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":57322,"name":"address","nodeType":"ElementaryTypeName","src":"2008:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"2007:9:120"},"scope":57326,"stateMutability":"view","virtual":false,"visibility":"external"}],"abstract":false,"baseContracts":[],"canonicalName":"IFetcher","contractDependencies":[],"contractKind":"interface","documentation":{"id":57181,"nodeType":"StructuredDocumentation","src":"170:136:120","text":"@notice Contains getters for arbitrary methods from all L1 contracts, including legacy getters\n that have since been deprecated."},"fullyImplemented":false,"linearizedBaseContracts":[57326],"name":"IFetcher","nameLocation":"316:8:120","scope":59300,"usedErrors":[],"usedEvents":[]},{"id":57409,"nodeType":"ContractDefinition","src":"2021:934:120","nodes":[{"id":57328,"nodeType":"VariableDeclaration","src":"2056:35:120","nodes":[],"constant":false,"mutability":"mutable","name":"_systemConfigProxy","nameLocation":"2073:18:120","scope":57409,"stateVariable":true,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":57327,"name":"address","nodeType":"ElementaryTypeName","src":"2056:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"},{"id":57330,"nodeType":"VariableDeclaration","src":"2097:39:120","nodes":[],"constant":false,"mutability":"mutable","name":"_l1StandardBridgeProxy","nameLocation":"2114:22:120","scope":57409,"stateVariable":true,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":57329,"name":"address","nodeType":"ElementaryTypeName","src":"2097:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"},{"id":57372,"nodeType":"FunctionDefinition","src":"2143:378:120","nodes":[],"body":{"id":57371,"nodeType":"Block","src":"2191:330:120","nodes":[],"statements":[{"expression":{"arguments":[{"commonType":{"typeIdentifier":"t_address","typeString":"address"},"id":57343,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftExpression":{"id":57338,"name":"_addr","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57334,"src":"2209:5:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"BinaryOperation","operator":"!=","rightExpression":{"arguments":[{"hexValue":"30","id":57341,"isConstant":false,"isLValue":false,"isPure":true,"kind":"number","lValueRequested":false,"nodeType":"Literal","src":"2226:1:120","typeDescriptions":{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"},"value":"0"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"}],"id":57340,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"nodeType":"ElementaryTypeNameExpression","src":"2218:7:120","typeDescriptions":{"typeIdentifier":"t_type$_t_address_$","typeString":"type(address)"},"typeName":{"id":57339,"name":"address","nodeType":"ElementaryTypeName","src":"2218:7:120","typeDescriptions":{}}},"id":57342,"isConstant":false,"isLValue":false,"isPure":true,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"2218:10:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"src":"2209:19:120","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},{"hexValue":"4665746368436861696e496e666f496e7075743a2063616e6e6f7420736574207a65726f2061646472657373","id":57344,"isConstant":false,"isLValue":false,"isPure":true,"kind":"string","lValueRequested":false,"nodeType":"Literal","src":"2230:46:120","typeDescriptions":{"typeIdentifier":"t_stringliteral_0336126ace187312d69da4c7cf05307af6a6596e8c75de2974f56108baf24145","typeString":"literal_string \"FetchChainInfoInput: cannot set zero address\""},"value":"FetchChainInfoInput: cannot set zero address"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_bool","typeString":"bool"},{"typeIdentifier":"t_stringliteral_0336126ace187312d69da4c7cf05307af6a6596e8c75de2974f56108baf24145","typeString":"literal_string \"FetchChainInfoInput: cannot set zero address\""}],"id":57337,"name":"require","nodeType":"Identifier","overloadedDeclarations":[-18,-18],"referencedDeclaration":-18,"src":"2201:7:120","typeDescriptions":{"typeIdentifier":"t_function_require_pure$_t_bool_$_t_string_memory_ptr_$returns$__$","typeString":"function (bool,string memory) pure"}},"id":57345,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"2201:76:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":57346,"nodeType":"ExpressionStatement","src":"2201:76:120"},{"condition":{"commonType":{"typeIdentifier":"t_bytes4","typeString":"bytes4"},"id":57351,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftExpression":{"id":57347,"name":"_sel","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57332,"src":"2291:4:120","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},"nodeType":"BinaryOperation","operator":"==","rightExpression":{"expression":{"expression":{"id":57348,"name":"this","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":-28,"src":"2299:4:120","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoInput_$57409","typeString":"contract FetchChainInfoInput"}},"id":57349,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"2304:17:120","memberName":"systemConfigProxy","nodeType":"MemberAccess","referencedDeclaration":57390,"src":"2299:22:120","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":57350,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"memberLocation":"2322:8:120","memberName":"selector","nodeType":"MemberAccess","src":"2299:31:120","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},"src":"2291:39:120","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},"falseBody":{"condition":{"commonType":{"typeIdentifier":"t_bytes4","typeString":"bytes4"},"id":57360,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftExpression":{"id":57356,"name":"_sel","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57332,"src":"2377:4:120","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},"nodeType":"BinaryOperation","operator":"==","rightExpression":{"expression":{"expression":{"id":57357,"name":"this","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":-28,"src":"2385:4:120","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoInput_$57409","typeString":"contract FetchChainInfoInput"}},"id":57358,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"2390:21:120","memberName":"l1StandardBridgeProxy","nodeType":"MemberAccess","referencedDeclaration":57408,"src":"2385:26:120","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":57359,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"memberLocation":"2412:8:120","memberName":"selector","nodeType":"MemberAccess","src":"2385:35:120","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},"src":"2377:43:120","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},"falseBody":{"expression":{"arguments":[{"hexValue":"4665746368436861696e496e666f496e7075743a20756e6b6e6f776e2073656c6563746f72","id":57366,"isConstant":false,"isLValue":false,"isPure":true,"kind":"string","lValueRequested":false,"nodeType":"Literal","src":"2474:39:120","typeDescriptions":{"typeIdentifier":"t_stringliteral_3ec062448196d68b2d186fadb5ffe52c72f0a2b929c9d178cd6e6612281f066b","typeString":"literal_string \"FetchChainInfoInput: unknown selector\""},"value":"FetchChainInfoInput: unknown selector"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_stringliteral_3ec062448196d68b2d186fadb5ffe52c72f0a2b929c9d178cd6e6612281f066b","typeString":"literal_string \"FetchChainInfoInput: unknown selector\""}],"id":57365,"name":"revert","nodeType":"Identifier","overloadedDeclarations":[-19,-19],"referencedDeclaration":-19,"src":"2467:6:120","typeDescriptions":{"typeIdentifier":"t_function_revert_pure$_t_string_memory_ptr_$returns$__$","typeString":"function (string memory) pure"}},"id":57367,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"2467:47:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":57368,"nodeType":"ExpressionStatement","src":"2467:47:120"},"id":57369,"nodeType":"IfStatement","src":"2373:141:120","trueBody":{"expression":{"id":57363,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftHandSide":{"id":57361,"name":"_l1StandardBridgeProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57330,"src":"2422:22:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"Assignment","operator":"=","rightHandSide":{"id":57362,"name":"_addr","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57334,"src":"2447:5:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"src":"2422:30:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"id":57364,"nodeType":"ExpressionStatement","src":"2422:30:120"}},"id":57370,"nodeType":"IfStatement","src":"2287:227:120","trueBody":{"expression":{"id":57354,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftHandSide":{"id":57352,"name":"_systemConfigProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57328,"src":"2332:18:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"Assignment","operator":"=","rightHandSide":{"id":57353,"name":"_addr","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57334,"src":"2353:5:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"src":"2332:26:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"id":57355,"nodeType":"ExpressionStatement","src":"2332:26:120"}}]},"functionSelector":"c3e39250","implemented":true,"kind":"function","modifiers":[],"name":"set","nameLocation":"2152:3:120","parameters":{"id":57335,"nodeType":"ParameterList","parameters":[{"constant":false,"id":57332,"mutability":"mutable","name":"_sel","nameLocation":"2163:4:120","nodeType":"VariableDeclaration","scope":57372,"src":"2156:11:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"},"typeName":{"id":57331,"name":"bytes4","nodeType":"ElementaryTypeName","src":"2156:6:120","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},"visibility":"internal"},{"constant":false,"id":57334,"mutability":"mutable","name":"_addr","nameLocation":"2177:5:120","nodeType":"VariableDeclaration","scope":57372,"src":"2169:13:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":57333,"name":"address","nodeType":"ElementaryTypeName","src":"2169:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"2155:28:120"},"returnParameters":{"id":57336,"nodeType":"ParameterList","parameters":[],"src":"2191:0:120"},"scope":57409,"stateMutability":"nonpayable","virtual":false,"visibility":"public"},{"id":57390,"nodeType":"FunctionDefinition","src":"2527:202:120","nodes":[],"body":{"id":57389,"nodeType":"Block","src":"2586:143:120","nodes":[],"statements":[{"expression":{"arguments":[{"commonType":{"typeIdentifier":"t_address","typeString":"address"},"id":57383,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftExpression":{"id":57378,"name":"_systemConfigProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57328,"src":"2604:18:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"BinaryOperation","operator":"!=","rightExpression":{"arguments":[{"hexValue":"30","id":57381,"isConstant":false,"isLValue":false,"isPure":true,"kind":"number","lValueRequested":false,"nodeType":"Literal","src":"2634:1:120","typeDescriptions":{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"},"value":"0"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"}],"id":57380,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"nodeType":"ElementaryTypeNameExpression","src":"2626:7:120","typeDescriptions":{"typeIdentifier":"t_type$_t_address_$","typeString":"type(address)"},"typeName":{"id":57379,"name":"address","nodeType":"ElementaryTypeName","src":"2626:7:120","typeDescriptions":{}}},"id":57382,"isConstant":false,"isLValue":false,"isPure":true,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"2626:10:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"src":"2604:32:120","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},{"hexValue":"4665746368436861696e496e666f496e7075743a2073797374656d436f6e66696750726f7879206e6f7420736574","id":57384,"isConstant":false,"isLValue":false,"isPure":true,"kind":"string","lValueRequested":false,"nodeType":"Literal","src":"2638:48:120","typeDescriptions":{"typeIdentifier":"t_stringliteral_cefeeda9841ab81b734a3e4f7bf39aeeab7704e02e2040531bd67ea944e4d5d3","typeString":"literal_string \"FetchChainInfoInput: systemConfigProxy not set\""},"value":"FetchChainInfoInput: systemConfigProxy not set"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_bool","typeString":"bool"},{"typeIdentifier":"t_stringliteral_cefeeda9841ab81b734a3e4f7bf39aeeab7704e02e2040531bd67ea944e4d5d3","typeString":"literal_string \"FetchChainInfoInput: systemConfigProxy not set\""}],"id":57377,"name":"require","nodeType":"Identifier","overloadedDeclarations":[-18,-18],"referencedDeclaration":-18,"src":"2596:7:120","typeDescriptions":{"typeIdentifier":"t_function_require_pure$_t_bool_$_t_string_memory_ptr_$returns$__$","typeString":"function (bool,string memory) pure"}},"id":57385,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"2596:91:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":57386,"nodeType":"ExpressionStatement","src":"2596:91:120"},{"expression":{"id":57387,"name":"_systemConfigProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57328,"src":"2704:18:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"functionReturnParameters":57376,"id":57388,"nodeType":"Return","src":"2697:25:120"}]},"functionSelector":"c17db6e3","implemented":true,"kind":"function","modifiers":[],"name":"systemConfigProxy","nameLocation":"2536:17:120","parameters":{"id":57373,"nodeType":"ParameterList","parameters":[],"src":"2553:2:120"},"returnParameters":{"id":57376,"nodeType":"ParameterList","parameters":[{"constant":false,"id":57375,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":57390,"src":"2577:7:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":57374,"name":"address","nodeType":"ElementaryTypeName","src":"2577:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"2576:9:120"},"scope":57409,"stateMutability":"view","virtual":false,"visibility":"public"},{"id":57408,"nodeType":"FunctionDefinition","src":"2735:218:120","nodes":[],"body":{"id":57407,"nodeType":"Block","src":"2798:155:120","nodes":[],"statements":[{"expression":{"arguments":[{"commonType":{"typeIdentifier":"t_address","typeString":"address"},"id":57401,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftExpression":{"id":57396,"name":"_l1StandardBridgeProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57330,"src":"2816:22:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"BinaryOperation","operator":"!=","rightExpression":{"arguments":[{"hexValue":"30","id":57399,"isConstant":false,"isLValue":false,"isPure":true,"kind":"number","lValueRequested":false,"nodeType":"Literal","src":"2850:1:120","typeDescriptions":{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"},"value":"0"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"}],"id":57398,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"nodeType":"ElementaryTypeNameExpression","src":"2842:7:120","typeDescriptions":{"typeIdentifier":"t_type$_t_address_$","typeString":"type(address)"},"typeName":{"id":57397,"name":"address","nodeType":"ElementaryTypeName","src":"2842:7:120","typeDescriptions":{}}},"id":57400,"isConstant":false,"isLValue":false,"isPure":true,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"2842:10:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"src":"2816:36:120","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},{"hexValue":"4665746368436861696e496e666f496e7075743a206c315374616e6461726442726964676550726f7879206e6f7420736574","id":57402,"isConstant":false,"isLValue":false,"isPure":true,"kind":"string","lValueRequested":false,"nodeType":"Literal","src":"2854:52:120","typeDescriptions":{"typeIdentifier":"t_stringliteral_be85b0ed3fc58e97f8b79e4d9fb1c191539515cae509acde6becd9338254d33b","typeString":"literal_string \"FetchChainInfoInput: l1StandardBridgeProxy not set\""},"value":"FetchChainInfoInput: l1StandardBridgeProxy not set"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_bool","typeString":"bool"},{"typeIdentifier":"t_stringliteral_be85b0ed3fc58e97f8b79e4d9fb1c191539515cae509acde6becd9338254d33b","typeString":"literal_string \"FetchChainInfoInput: l1StandardBridgeProxy not set\""}],"id":57395,"name":"require","nodeType":"Identifier","overloadedDeclarations":[-18,-18],"referencedDeclaration":-18,"src":"2808:7:120","typeDescriptions":{"typeIdentifier":"t_function_require_pure$_t_bool_$_t_string_memory_ptr_$returns$__$","typeString":"function (bool,string memory) pure"}},"id":57403,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"2808:99:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":57404,"nodeType":"ExpressionStatement","src":"2808:99:120"},{"expression":{"id":57405,"name":"_l1StandardBridgeProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57330,"src":"2924:22:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"functionReturnParameters":57394,"id":57406,"nodeType":"Return","src":"2917:29:120"}]},"functionSelector":"102b6069","implemented":true,"kind":"function","modifiers":[],"name":"l1StandardBridgeProxy","nameLocation":"2744:21:120","parameters":{"id":57391,"nodeType":"ParameterList","parameters":[],"src":"2765:2:120"},"returnParameters":{"id":57394,"nodeType":"ParameterList","parameters":[{"constant":false,"id":57393,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":57408,"src":"2789:7:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":57392,"name":"address","nodeType":"ElementaryTypeName","src":"2789:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"2788:9:120"},"scope":57409,"stateMutability":"view","virtual":false,"visibility":"public"}],"abstract":false,"baseContracts":[],"canonicalName":"FetchChainInfoInput","contractDependencies":[],"contractKind":"contract","fullyImplemented":true,"linearizedBaseContracts":[57409],"name":"FetchChainInfoInput","nameLocation":"2030:19:120","scope":59300,"usedErrors":[],"usedEvents":[]},{"id":58249,"nodeType":"ContractDefinition","src":"2957:10181:120","nodes":[{"id":57411,"nodeType":"VariableDeclaration","src":"3049:39:120","nodes":[],"constant":false,"mutability":"mutable","name":"_superchainConfigProxy","nameLocation":"3066:22:120","scope":58249,"stateVariable":true,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":57410,"name":"address","nodeType":"ElementaryTypeName","src":"3049:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"},{"id":57413,"nodeType":"VariableDeclaration","src":"3129:26:120","nodes":[],"constant":false,"mutability":"mutable","name":"_mipsImpl","nameLocation":"3146:9:120","scope":58249,"stateVariable":true,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":57412,"name":"address","nodeType":"ElementaryTypeName","src":"3129:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"},{"id":57415,"nodeType":"VariableDeclaration","src":"3161:36:120","nodes":[],"constant":false,"mutability":"mutable","name":"_preimageOracleImpl","nameLocation":"3178:19:120","scope":58249,"stateVariable":true,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":57414,"name":"address","nodeType":"ElementaryTypeName","src":"3161:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"},{"id":57417,"nodeType":"VariableDeclaration","src":"3230:36:120","nodes":[],"constant":false,"mutability":"mutable","name":"_addressManagerImpl","nameLocation":"3247:19:120","scope":58249,"stateVariable":true,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":57416,"name":"address","nodeType":"ElementaryTypeName","src":"3230:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"},{"id":57419,"nodeType":"VariableDeclaration","src":"3272:33:120","nodes":[],"constant":false,"mutability":"mutable","name":"_ethLockboxProxy","nameLocation":"3289:16:120","scope":58249,"stateVariable":true,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":57418,"name":"address","nodeType":"ElementaryTypeName","src":"3272:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"},{"id":57421,"nodeType":"VariableDeclaration","src":"3311:45:120","nodes":[],"constant":false,"mutability":"mutable","name":"_l1CrossDomainMessengerProxy","nameLocation":"3328:28:120","scope":58249,"stateVariable":true,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":57420,"name":"address","nodeType":"ElementaryTypeName","src":"3311:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"},{"id":57423,"nodeType":"VariableDeclaration","src":"3362:37:120","nodes":[],"constant":false,"mutability":"mutable","name":"_l1Erc721BridgeProxy","nameLocation":"3379:20:120","scope":58249,"stateVariable":true,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":57422,"name":"address","nodeType":"ElementaryTypeName","src":"3362:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"},{"id":57425,"nodeType":"VariableDeclaration","src":"3405:39:120","nodes":[],"constant":false,"mutability":"mutable","name":"_l1StandardBridgeProxy","nameLocation":"3422:22:120","scope":58249,"stateVariable":true,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":57424,"name":"address","nodeType":"ElementaryTypeName","src":"3405:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"},{"id":57427,"nodeType":"VariableDeclaration","src":"3450:37:120","nodes":[],"constant":false,"mutability":"mutable","name":"_l2OutputOracleProxy","nameLocation":"3467:20:120","scope":58249,"stateVariable":true,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":57426,"name":"address","nodeType":"ElementaryTypeName","src":"3450:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"},{"id":57429,"nodeType":"VariableDeclaration","src":"3493:51:120","nodes":[],"constant":false,"mutability":"mutable","name":"_optimismMintableErc20FactoryProxy","nameLocation":"3510:34:120","scope":58249,"stateVariable":true,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":57428,"name":"address","nodeType":"ElementaryTypeName","src":"3493:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"},{"id":57431,"nodeType":"VariableDeclaration","src":"3550:37:120","nodes":[],"constant":false,"mutability":"mutable","name":"_optimismPortalProxy","nameLocation":"3567:20:120","scope":58249,"stateVariable":true,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":57430,"name":"address","nodeType":"ElementaryTypeName","src":"3550:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"},{"id":57433,"nodeType":"VariableDeclaration","src":"3593:35:120","nodes":[],"constant":false,"mutability":"mutable","name":"_systemConfigProxy","nameLocation":"3610:18:120","scope":58249,"stateVariable":true,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":57432,"name":"address","nodeType":"ElementaryTypeName","src":"3593:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"},{"id":57435,"nodeType":"VariableDeclaration","src":"3634:39:120","nodes":[],"constant":false,"mutability":"mutable","name":"_opChainProxyAdminImpl","nameLocation":"3651:22:120","scope":58249,"stateVariable":true,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":57434,"name":"address","nodeType":"ElementaryTypeName","src":"3634:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"},{"id":57437,"nodeType":"VariableDeclaration","src":"3679:42:120","nodes":[],"constant":false,"mutability":"mutable","name":"_anchorStateRegistryProxy","nameLocation":"3696:25:120","scope":58249,"stateVariable":true,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":57436,"name":"address","nodeType":"ElementaryTypeName","src":"3679:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"},{"id":57439,"nodeType":"VariableDeclaration","src":"3727:50:120","nodes":[],"constant":false,"mutability":"mutable","name":"_delayedWethPermissionedGameProxy","nameLocation":"3744:33:120","scope":58249,"stateVariable":true,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":57438,"name":"address","nodeType":"ElementaryTypeName","src":"3727:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"},{"id":57441,"nodeType":"VariableDeclaration","src":"3783:52:120","nodes":[],"constant":false,"mutability":"mutable","name":"_delayedWethPermissionlessGameProxy","nameLocation":"3800:35:120","scope":58249,"stateVariable":true,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":57440,"name":"address","nodeType":"ElementaryTypeName","src":"3783:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"},{"id":57443,"nodeType":"VariableDeclaration","src":"3841:41:120","nodes":[],"constant":false,"mutability":"mutable","name":"_disputeGameFactoryProxy","nameLocation":"3858:24:120","scope":58249,"stateVariable":true,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":57442,"name":"address","nodeType":"ElementaryTypeName","src":"3841:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"},{"id":57445,"nodeType":"VariableDeclaration","src":"3888:38:120","nodes":[],"constant":false,"mutability":"mutable","name":"_faultDisputeGameImpl","nameLocation":"3905:21:120","scope":58249,"stateVariable":true,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":57444,"name":"address","nodeType":"ElementaryTypeName","src":"3888:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"},{"id":57447,"nodeType":"VariableDeclaration","src":"3932:45:120","nodes":[],"constant":false,"mutability":"mutable","name":"_permissionedDisputeGameImpl","nameLocation":"3949:28:120","scope":58249,"stateVariable":true,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":57446,"name":"address","nodeType":"ElementaryTypeName","src":"3932:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"},{"id":57449,"nodeType":"VariableDeclaration","src":"3997:35:120","nodes":[],"constant":false,"mutability":"mutable","name":"_systemConfigOwner","nameLocation":"4014:18:120","scope":58249,"stateVariable":true,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":57448,"name":"address","nodeType":"ElementaryTypeName","src":"3997:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"},{"id":57451,"nodeType":"VariableDeclaration","src":"4038:40:120","nodes":[],"constant":false,"mutability":"mutable","name":"_opChainProxyAdminOwner","nameLocation":"4055:23:120","scope":58249,"stateVariable":true,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":57450,"name":"address","nodeType":"ElementaryTypeName","src":"4038:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"},{"id":57453,"nodeType":"VariableDeclaration","src":"4084:33:120","nodes":[],"constant":false,"mutability":"mutable","name":"_opChainGuardian","nameLocation":"4101:16:120","scope":58249,"stateVariable":true,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":57452,"name":"address","nodeType":"ElementaryTypeName","src":"4084:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"},{"id":57455,"nodeType":"VariableDeclaration","src":"4123:28:120","nodes":[],"constant":false,"mutability":"mutable","name":"_challenger","nameLocation":"4140:11:120","scope":58249,"stateVariable":true,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":57454,"name":"address","nodeType":"ElementaryTypeName","src":"4123:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"},{"id":57457,"nodeType":"VariableDeclaration","src":"4157:26:120","nodes":[],"constant":false,"mutability":"mutable","name":"_proposer","nameLocation":"4174:9:120","scope":58249,"stateVariable":true,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":57456,"name":"address","nodeType":"ElementaryTypeName","src":"4157:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"},{"id":57459,"nodeType":"VariableDeclaration","src":"4189:35:120","nodes":[],"constant":false,"mutability":"mutable","name":"_unsafeBlockSigner","nameLocation":"4206:18:120","scope":58249,"stateVariable":true,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":57458,"name":"address","nodeType":"ElementaryTypeName","src":"4189:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"},{"id":57461,"nodeType":"VariableDeclaration","src":"4230:32:120","nodes":[],"constant":false,"mutability":"mutable","name":"_batchSubmitter","nameLocation":"4247:15:120","scope":58249,"stateVariable":true,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":57460,"name":"address","nodeType":"ElementaryTypeName","src":"4230:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"},{"id":57463,"nodeType":"VariableDeclaration","src":"4295:27:120","nodes":[],"constant":false,"mutability":"mutable","name":"_permissioned","nameLocation":"4309:13:120","scope":58249,"stateVariable":true,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"},"typeName":{"id":57462,"name":"bool","nodeType":"ElementaryTypeName","src":"4295:4:120","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},"visibility":"internal"},{"id":57465,"nodeType":"VariableDeclaration","src":"4328:29:120","nodes":[],"constant":false,"mutability":"mutable","name":"_permissionless","nameLocation":"4342:15:120","scope":58249,"stateVariable":true,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"},"typeName":{"id":57464,"name":"bool","nodeType":"ElementaryTypeName","src":"4328:4:120","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},"visibility":"internal"},{"id":57468,"nodeType":"VariableDeclaration","src":"4363:36:120","nodes":[],"constant":false,"mutability":"mutable","name":"_respectedGameType","nameLocation":"4381:18:120","scope":58249,"stateVariable":true,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_userDefinedValueType$_GameType_$75355","typeString":"GameType"},"typeName":{"id":57467,"nodeType":"UserDefinedTypeName","pathNode":{"id":57466,"name":"GameType","nameLocations":["4363:8:120"],"nodeType":"IdentifierPath","referencedDeclaration":75355,"src":"4363:8:120"},"referencedDeclaration":75355,"src":"4363:8:120","typeDescriptions":{"typeIdentifier":"t_userDefinedValueType$_GameType_$75355","typeString":"GameType"}},"visibility":"internal"},{"id":57740,"nodeType":"FunctionDefinition","src":"4406:2634:120","nodes":[],"body":{"id":57739,"nodeType":"Block","src":"4454:2586:120","nodes":[],"statements":[{"condition":{"commonType":{"typeIdentifier":"t_bytes4","typeString":"bytes4"},"id":57479,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftExpression":{"id":57475,"name":"_sel","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57470,"src":"4499:4:120","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},"nodeType":"BinaryOperation","operator":"==","rightExpression":{"expression":{"expression":{"id":57476,"name":"this","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":-28,"src":"4507:4:120","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$58249","typeString":"contract FetchChainInfoOutput"}},"id":57477,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"4512:21:120","memberName":"superchainConfigProxy","nodeType":"MemberAccess","referencedDeclaration":57983,"src":"4507:26:120","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":57478,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"memberLocation":"4534:8:120","memberName":"selector","nodeType":"MemberAccess","src":"4507:35:120","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},"src":"4499:43:120","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},"falseBody":{"condition":{"commonType":{"typeIdentifier":"t_bytes4","typeString":"bytes4"},"id":57488,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftExpression":{"id":57484,"name":"_sel","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57470,"src":"4632:4:120","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},"nodeType":"BinaryOperation","operator":"==","rightExpression":{"expression":{"expression":{"id":57485,"name":"this","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":-28,"src":"4640:4:120","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$58249","typeString":"contract FetchChainInfoOutput"}},"id":57486,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"4645:8:120","memberName":"mipsImpl","nodeType":"MemberAccess","referencedDeclaration":58061,"src":"4640:13:120","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":57487,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"memberLocation":"4654:8:120","memberName":"selector","nodeType":"MemberAccess","src":"4640:22:120","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},"src":"4632:30:120","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},"falseBody":{"condition":{"commonType":{"typeIdentifier":"t_bytes4","typeString":"bytes4"},"id":57497,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftExpression":{"id":57493,"name":"_sel","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57470,"src":"4700:4:120","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},"nodeType":"BinaryOperation","operator":"==","rightExpression":{"expression":{"expression":{"id":57494,"name":"this","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":-28,"src":"4708:4:120","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$58249","typeString":"contract FetchChainInfoOutput"}},"id":57495,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"4713:18:120","memberName":"preimageOracleImpl","nodeType":"MemberAccess","referencedDeclaration":58097,"src":"4708:23:120","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":57496,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"memberLocation":"4732:8:120","memberName":"selector","nodeType":"MemberAccess","src":"4708:32:120","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},"src":"4700:40:120","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},"falseBody":{"condition":{"commonType":{"typeIdentifier":"t_bytes4","typeString":"bytes4"},"id":57506,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftExpression":{"id":57502,"name":"_sel","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57470,"src":"4819:4:120","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},"nodeType":"BinaryOperation","operator":"==","rightExpression":{"expression":{"expression":{"id":57503,"name":"this","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":-28,"src":"4827:4:120","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$58249","typeString":"contract FetchChainInfoOutput"}},"id":57504,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"4832:18:120","memberName":"addressManagerImpl","nodeType":"MemberAccess","referencedDeclaration":57813,"src":"4827:23:120","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":57505,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"memberLocation":"4851:8:120","memberName":"selector","nodeType":"MemberAccess","src":"4827:32:120","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},"src":"4819:40:120","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},"falseBody":{"condition":{"commonType":{"typeIdentifier":"t_bytes4","typeString":"bytes4"},"id":57515,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftExpression":{"id":57511,"name":"_sel","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57470,"src":"4907:4:120","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},"nodeType":"BinaryOperation","operator":"==","rightExpression":{"expression":{"expression":{"id":57512,"name":"this","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":-28,"src":"4915:4:120","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$58249","typeString":"contract FetchChainInfoOutput"}},"id":57513,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"4920:15:120","memberName":"ethLockboxProxy","nodeType":"MemberAccess","referencedDeclaration":57821,"src":"4915:20:120","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":57514,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"memberLocation":"4936:8:120","memberName":"selector","nodeType":"MemberAccess","src":"4915:29:120","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},"src":"4907:37:120","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},"falseBody":{"condition":{"commonType":{"typeIdentifier":"t_bytes4","typeString":"bytes4"},"id":57524,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftExpression":{"id":57520,"name":"_sel","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57470,"src":"4989:4:120","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},"nodeType":"BinaryOperation","operator":"==","rightExpression":{"expression":{"expression":{"id":57521,"name":"this","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":-28,"src":"4997:4:120","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$58249","typeString":"contract FetchChainInfoOutput"}},"id":57522,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"5002:27:120","memberName":"l1CrossDomainMessengerProxy","nodeType":"MemberAccess","referencedDeclaration":57839,"src":"4997:32:120","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":57523,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"memberLocation":"5030:8:120","memberName":"selector","nodeType":"MemberAccess","src":"4997:41:120","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},"src":"4989:49:120","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},"falseBody":{"condition":{"commonType":{"typeIdentifier":"t_bytes4","typeString":"bytes4"},"id":57533,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftExpression":{"id":57529,"name":"_sel","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57470,"src":"5095:4:120","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},"nodeType":"BinaryOperation","operator":"==","rightExpression":{"expression":{"expression":{"id":57530,"name":"this","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":-28,"src":"5103:4:120","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$58249","typeString":"contract FetchChainInfoOutput"}},"id":57531,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"5108:19:120","memberName":"l1Erc721BridgeProxy","nodeType":"MemberAccess","referencedDeclaration":57857,"src":"5103:24:120","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":57532,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"memberLocation":"5128:8:120","memberName":"selector","nodeType":"MemberAccess","src":"5103:33:120","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},"src":"5095:41:120","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},"falseBody":{"condition":{"commonType":{"typeIdentifier":"t_bytes4","typeString":"bytes4"},"id":57542,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftExpression":{"id":57538,"name":"_sel","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57470,"src":"5185:4:120","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},"nodeType":"BinaryOperation","operator":"==","rightExpression":{"expression":{"expression":{"id":57539,"name":"this","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":-28,"src":"5193:4:120","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$58249","typeString":"contract FetchChainInfoOutput"}},"id":57540,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"5198:21:120","memberName":"l1StandardBridgeProxy","nodeType":"MemberAccess","referencedDeclaration":57875,"src":"5193:26:120","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":57541,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"memberLocation":"5220:8:120","memberName":"selector","nodeType":"MemberAccess","src":"5193:35:120","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},"src":"5185:43:120","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},"falseBody":{"condition":{"commonType":{"typeIdentifier":"t_bytes4","typeString":"bytes4"},"id":57551,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftExpression":{"id":57547,"name":"_sel","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57470,"src":"5279:4:120","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},"nodeType":"BinaryOperation","operator":"==","rightExpression":{"expression":{"expression":{"id":57548,"name":"this","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":-28,"src":"5287:4:120","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$58249","typeString":"contract FetchChainInfoOutput"}},"id":57549,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"5292:19:120","memberName":"l2OutputOracleProxy","nodeType":"MemberAccess","referencedDeclaration":57893,"src":"5287:24:120","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":57550,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"memberLocation":"5312:8:120","memberName":"selector","nodeType":"MemberAccess","src":"5287:33:120","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},"src":"5279:41:120","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},"falseBody":{"condition":{"commonType":{"typeIdentifier":"t_bytes4","typeString":"bytes4"},"id":57560,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftExpression":{"id":57556,"name":"_sel","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57470,"src":"5369:4:120","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},"nodeType":"BinaryOperation","operator":"==","rightExpression":{"expression":{"expression":{"id":57557,"name":"this","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":-28,"src":"5377:4:120","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$58249","typeString":"contract FetchChainInfoOutput"}},"id":57558,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"5382:33:120","memberName":"optimismMintableErc20FactoryProxy","nodeType":"MemberAccess","referencedDeclaration":57911,"src":"5377:38:120","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":57559,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"memberLocation":"5416:8:120","memberName":"selector","nodeType":"MemberAccess","src":"5377:47:120","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},"src":"5369:55:120","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},"falseBody":{"condition":{"commonType":{"typeIdentifier":"t_bytes4","typeString":"bytes4"},"id":57569,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftExpression":{"id":57565,"name":"_sel","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57470,"src":"5487:4:120","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},"nodeType":"BinaryOperation","operator":"==","rightExpression":{"expression":{"expression":{"id":57566,"name":"this","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":-28,"src":"5495:4:120","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$58249","typeString":"contract FetchChainInfoOutput"}},"id":57567,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"5500:19:120","memberName":"optimismPortalProxy","nodeType":"MemberAccess","referencedDeclaration":57929,"src":"5495:24:120","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":57568,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"memberLocation":"5520:8:120","memberName":"selector","nodeType":"MemberAccess","src":"5495:33:120","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},"src":"5487:41:120","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},"falseBody":{"condition":{"commonType":{"typeIdentifier":"t_bytes4","typeString":"bytes4"},"id":57578,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftExpression":{"id":57574,"name":"_sel","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57470,"src":"5577:4:120","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},"nodeType":"BinaryOperation","operator":"==","rightExpression":{"expression":{"expression":{"id":57575,"name":"this","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":-28,"src":"5585:4:120","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$58249","typeString":"contract FetchChainInfoOutput"}},"id":57576,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"5590:17:120","memberName":"systemConfigProxy","nodeType":"MemberAccess","referencedDeclaration":57947,"src":"5585:22:120","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":57577,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"memberLocation":"5608:8:120","memberName":"selector","nodeType":"MemberAccess","src":"5585:31:120","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},"src":"5577:39:120","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},"falseBody":{"condition":{"commonType":{"typeIdentifier":"t_bytes4","typeString":"bytes4"},"id":57587,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftExpression":{"id":57583,"name":"_sel","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57470,"src":"5663:4:120","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},"nodeType":"BinaryOperation","operator":"==","rightExpression":{"expression":{"expression":{"id":57584,"name":"this","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":-28,"src":"5671:4:120","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$58249","typeString":"contract FetchChainInfoOutput"}},"id":57585,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"5676:21:120","memberName":"opChainProxyAdminImpl","nodeType":"MemberAccess","referencedDeclaration":57965,"src":"5671:26:120","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":57586,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"memberLocation":"5698:8:120","memberName":"selector","nodeType":"MemberAccess","src":"5671:35:120","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},"src":"5663:43:120","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},"falseBody":{"condition":{"commonType":{"typeIdentifier":"t_bytes4","typeString":"bytes4"},"id":57596,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftExpression":{"id":57592,"name":"_sel","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57470,"src":"5757:4:120","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},"nodeType":"BinaryOperation","operator":"==","rightExpression":{"expression":{"expression":{"id":57593,"name":"this","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":-28,"src":"5765:4:120","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$58249","typeString":"contract FetchChainInfoOutput"}},"id":57594,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"5770:24:120","memberName":"anchorStateRegistryProxy","nodeType":"MemberAccess","referencedDeclaration":58001,"src":"5765:29:120","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":57595,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"memberLocation":"5795:8:120","memberName":"selector","nodeType":"MemberAccess","src":"5765:38:120","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},"src":"5757:46:120","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},"falseBody":{"condition":{"commonType":{"typeIdentifier":"t_bytes4","typeString":"bytes4"},"id":57605,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftExpression":{"id":57601,"name":"_sel","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57470,"src":"5857:4:120","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},"nodeType":"BinaryOperation","operator":"==","rightExpression":{"expression":{"expression":{"id":57602,"name":"this","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":-28,"src":"5865:4:120","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$58249","typeString":"contract FetchChainInfoOutput"}},"id":57603,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"5870:32:120","memberName":"delayedWethPermissionedGameProxy","nodeType":"MemberAccess","referencedDeclaration":58009,"src":"5865:37:120","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":57604,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"memberLocation":"5903:8:120","memberName":"selector","nodeType":"MemberAccess","src":"5865:46:120","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},"src":"5857:54:120","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},"falseBody":{"condition":{"commonType":{"typeIdentifier":"t_bytes4","typeString":"bytes4"},"id":57614,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftExpression":{"id":57610,"name":"_sel","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57470,"src":"5973:4:120","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},"nodeType":"BinaryOperation","operator":"==","rightExpression":{"expression":{"expression":{"id":57611,"name":"this","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":-28,"src":"5981:4:120","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$58249","typeString":"contract FetchChainInfoOutput"}},"id":57612,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"5986:34:120","memberName":"delayedWethPermissionlessGameProxy","nodeType":"MemberAccess","referencedDeclaration":58017,"src":"5981:39:120","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":57613,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"memberLocation":"6021:8:120","memberName":"selector","nodeType":"MemberAccess","src":"5981:48:120","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},"src":"5973:56:120","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},"falseBody":{"condition":{"commonType":{"typeIdentifier":"t_bytes4","typeString":"bytes4"},"id":57623,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftExpression":{"id":57619,"name":"_sel","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57470,"src":"6093:4:120","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},"nodeType":"BinaryOperation","operator":"==","rightExpression":{"expression":{"expression":{"id":57620,"name":"this","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":-28,"src":"6101:4:120","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$58249","typeString":"contract FetchChainInfoOutput"}},"id":57621,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"6106:23:120","memberName":"disputeGameFactoryProxy","nodeType":"MemberAccess","referencedDeclaration":58025,"src":"6101:28:120","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":57622,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"memberLocation":"6130:8:120","memberName":"selector","nodeType":"MemberAccess","src":"6101:37:120","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},"src":"6093:45:120","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},"falseBody":{"condition":{"commonType":{"typeIdentifier":"t_bytes4","typeString":"bytes4"},"id":57632,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftExpression":{"id":57628,"name":"_sel","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57470,"src":"6191:4:120","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},"nodeType":"BinaryOperation","operator":"==","rightExpression":{"expression":{"expression":{"id":57629,"name":"this","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":-28,"src":"6199:4:120","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$58249","typeString":"contract FetchChainInfoOutput"}},"id":57630,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"6204:20:120","memberName":"faultDisputeGameImpl","nodeType":"MemberAccess","referencedDeclaration":58043,"src":"6199:25:120","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":57631,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"memberLocation":"6225:8:120","memberName":"selector","nodeType":"MemberAccess","src":"6199:34:120","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},"src":"6191:42:120","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},"falseBody":{"condition":{"commonType":{"typeIdentifier":"t_bytes4","typeString":"bytes4"},"id":57641,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftExpression":{"id":57637,"name":"_sel","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57470,"src":"6283:4:120","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},"nodeType":"BinaryOperation","operator":"==","rightExpression":{"expression":{"expression":{"id":57638,"name":"this","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":-28,"src":"6291:4:120","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$58249","typeString":"contract FetchChainInfoOutput"}},"id":57639,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"6296:27:120","memberName":"permissionedDisputeGameImpl","nodeType":"MemberAccess","referencedDeclaration":58079,"src":"6291:32:120","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":57640,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"memberLocation":"6324:8:120","memberName":"selector","nodeType":"MemberAccess","src":"6291:41:120","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},"src":"6283:49:120","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},"falseBody":{"condition":{"commonType":{"typeIdentifier":"t_bytes4","typeString":"bytes4"},"id":57650,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftExpression":{"id":57646,"name":"_sel","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57470,"src":"6406:4:120","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},"nodeType":"BinaryOperation","operator":"==","rightExpression":{"expression":{"expression":{"id":57647,"name":"this","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":-28,"src":"6414:4:120","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$58249","typeString":"contract FetchChainInfoOutput"}},"id":57648,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"6419:17:120","memberName":"systemConfigOwner","nodeType":"MemberAccess","referencedDeclaration":58115,"src":"6414:22:120","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":57649,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"memberLocation":"6437:8:120","memberName":"selector","nodeType":"MemberAccess","src":"6414:31:120","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},"src":"6406:39:120","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},"falseBody":{"condition":{"commonType":{"typeIdentifier":"t_bytes4","typeString":"bytes4"},"id":57659,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftExpression":{"id":57655,"name":"_sel","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57470,"src":"6492:4:120","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},"nodeType":"BinaryOperation","operator":"==","rightExpression":{"expression":{"expression":{"id":57656,"name":"this","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":-28,"src":"6500:4:120","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$58249","typeString":"contract FetchChainInfoOutput"}},"id":57657,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"6505:22:120","memberName":"opChainProxyAdminOwner","nodeType":"MemberAccess","referencedDeclaration":58133,"src":"6500:27:120","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":57658,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"memberLocation":"6528:8:120","memberName":"selector","nodeType":"MemberAccess","src":"6500:36:120","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},"src":"6492:44:120","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},"falseBody":{"condition":{"commonType":{"typeIdentifier":"t_bytes4","typeString":"bytes4"},"id":57668,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftExpression":{"id":57664,"name":"_sel","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57470,"src":"6588:4:120","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},"nodeType":"BinaryOperation","operator":"==","rightExpression":{"expression":{"expression":{"id":57665,"name":"this","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":-28,"src":"6596:4:120","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$58249","typeString":"contract FetchChainInfoOutput"}},"id":57666,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"6601:15:120","memberName":"opChainGuardian","nodeType":"MemberAccess","referencedDeclaration":58151,"src":"6596:20:120","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":57667,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"memberLocation":"6617:8:120","memberName":"selector","nodeType":"MemberAccess","src":"6596:29:120","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},"src":"6588:37:120","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},"falseBody":{"condition":{"commonType":{"typeIdentifier":"t_bytes4","typeString":"bytes4"},"id":57677,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftExpression":{"id":57673,"name":"_sel","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57470,"src":"6670:4:120","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},"nodeType":"BinaryOperation","operator":"==","rightExpression":{"expression":{"expression":{"id":57674,"name":"this","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":-28,"src":"6678:4:120","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$58249","typeString":"contract FetchChainInfoOutput"}},"id":57675,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"6683:10:120","memberName":"challenger","nodeType":"MemberAccess","referencedDeclaration":58169,"src":"6678:15:120","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":57676,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"memberLocation":"6694:8:120","memberName":"selector","nodeType":"MemberAccess","src":"6678:24:120","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},"src":"6670:32:120","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},"falseBody":{"condition":{"commonType":{"typeIdentifier":"t_bytes4","typeString":"bytes4"},"id":57686,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftExpression":{"id":57682,"name":"_sel","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57470,"src":"6742:4:120","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},"nodeType":"BinaryOperation","operator":"==","rightExpression":{"expression":{"expression":{"id":57683,"name":"this","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":-28,"src":"6750:4:120","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$58249","typeString":"contract FetchChainInfoOutput"}},"id":57684,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"6755:8:120","memberName":"proposer","nodeType":"MemberAccess","referencedDeclaration":58187,"src":"6750:13:120","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":57685,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"memberLocation":"6764:8:120","memberName":"selector","nodeType":"MemberAccess","src":"6750:22:120","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},"src":"6742:30:120","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},"falseBody":{"condition":{"commonType":{"typeIdentifier":"t_bytes4","typeString":"bytes4"},"id":57695,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftExpression":{"id":57691,"name":"_sel","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57470,"src":"6810:4:120","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},"nodeType":"BinaryOperation","operator":"==","rightExpression":{"expression":{"expression":{"id":57692,"name":"this","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":-28,"src":"6818:4:120","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$58249","typeString":"contract FetchChainInfoOutput"}},"id":57693,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"6823:17:120","memberName":"unsafeBlockSigner","nodeType":"MemberAccess","referencedDeclaration":58205,"src":"6818:22:120","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":57694,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"memberLocation":"6841:8:120","memberName":"selector","nodeType":"MemberAccess","src":"6818:31:120","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},"src":"6810:39:120","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},"falseBody":{"condition":{"commonType":{"typeIdentifier":"t_bytes4","typeString":"bytes4"},"id":57704,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftExpression":{"id":57700,"name":"_sel","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57470,"src":"6896:4:120","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},"nodeType":"BinaryOperation","operator":"==","rightExpression":{"expression":{"expression":{"id":57701,"name":"this","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":-28,"src":"6904:4:120","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$58249","typeString":"contract FetchChainInfoOutput"}},"id":57702,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"6909:14:120","memberName":"batchSubmitter","nodeType":"MemberAccess","referencedDeclaration":58223,"src":"6904:19:120","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":57703,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"memberLocation":"6924:8:120","memberName":"selector","nodeType":"MemberAccess","src":"6904:28:120","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},"src":"6896:36:120","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},"falseBody":{"expression":{"arguments":[{"hexValue":"4665746368436861696e496e666f4f75747075743a20756e6b6e6f776e20616464726573732073656c6563746f722074657374","id":57710,"isConstant":false,"isLValue":false,"isPure":true,"kind":"string","lValueRequested":false,"nodeType":"Literal","src":"6979:53:120","typeDescriptions":{"typeIdentifier":"t_stringliteral_8be6a92cba5443877e2b6bededc383e178c3f2718dce3f3864f1721c31f5c065","typeString":"literal_string \"FetchChainInfoOutput: unknown address selector test\""},"value":"FetchChainInfoOutput: unknown address selector test"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_stringliteral_8be6a92cba5443877e2b6bededc383e178c3f2718dce3f3864f1721c31f5c065","typeString":"literal_string \"FetchChainInfoOutput: unknown address selector test\""}],"id":57709,"name":"revert","nodeType":"Identifier","overloadedDeclarations":[-19,-19],"referencedDeclaration":-19,"src":"6972:6:120","typeDescriptions":{"typeIdentifier":"t_function_revert_pure$_t_string_memory_ptr_$returns$__$","typeString":"function (string memory) pure"}},"id":57711,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"6972:61:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":57712,"nodeType":"ExpressionStatement","src":"6972:61:120"},"id":57713,"nodeType":"IfStatement","src":"6892:141:120","trueBody":{"expression":{"id":57707,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftHandSide":{"id":57705,"name":"_batchSubmitter","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57461,"src":"6934:15:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"Assignment","operator":"=","rightHandSide":{"id":57706,"name":"_addr","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57472,"src":"6952:5:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"src":"6934:23:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"id":57708,"nodeType":"ExpressionStatement","src":"6934:23:120"}},"id":57714,"nodeType":"IfStatement","src":"6806:227:120","trueBody":{"expression":{"id":57698,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftHandSide":{"id":57696,"name":"_unsafeBlockSigner","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57459,"src":"6851:18:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"Assignment","operator":"=","rightHandSide":{"id":57697,"name":"_addr","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57472,"src":"6872:5:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"src":"6851:26:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"id":57699,"nodeType":"ExpressionStatement","src":"6851:26:120"}},"id":57715,"nodeType":"IfStatement","src":"6738:295:120","trueBody":{"expression":{"id":57689,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftHandSide":{"id":57687,"name":"_proposer","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57457,"src":"6774:9:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"Assignment","operator":"=","rightHandSide":{"id":57688,"name":"_addr","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57472,"src":"6786:5:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"src":"6774:17:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"id":57690,"nodeType":"ExpressionStatement","src":"6774:17:120"}},"id":57716,"nodeType":"IfStatement","src":"6666:367:120","trueBody":{"expression":{"id":57680,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftHandSide":{"id":57678,"name":"_challenger","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57455,"src":"6704:11:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"Assignment","operator":"=","rightHandSide":{"id":57679,"name":"_addr","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57472,"src":"6718:5:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"src":"6704:19:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"id":57681,"nodeType":"ExpressionStatement","src":"6704:19:120"}},"id":57717,"nodeType":"IfStatement","src":"6584:449:120","trueBody":{"expression":{"id":57671,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftHandSide":{"id":57669,"name":"_opChainGuardian","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57453,"src":"6627:16:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"Assignment","operator":"=","rightHandSide":{"id":57670,"name":"_addr","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57472,"src":"6646:5:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"src":"6627:24:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"id":57672,"nodeType":"ExpressionStatement","src":"6627:24:120"}},"id":57718,"nodeType":"IfStatement","src":"6488:545:120","trueBody":{"expression":{"id":57662,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftHandSide":{"id":57660,"name":"_opChainProxyAdminOwner","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57451,"src":"6538:23:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"Assignment","operator":"=","rightHandSide":{"id":57661,"name":"_addr","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57472,"src":"6564:5:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"src":"6538:31:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"id":57663,"nodeType":"ExpressionStatement","src":"6538:31:120"}},"id":57719,"nodeType":"IfStatement","src":"6402:631:120","trueBody":{"expression":{"id":57653,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftHandSide":{"id":57651,"name":"_systemConfigOwner","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57449,"src":"6447:18:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"Assignment","operator":"=","rightHandSide":{"id":57652,"name":"_addr","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57472,"src":"6468:5:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"src":"6447:26:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"id":57654,"nodeType":"ExpressionStatement","src":"6447:26:120"}},"id":57720,"nodeType":"IfStatement","src":"6279:754:120","trueBody":{"expression":{"id":57644,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftHandSide":{"id":57642,"name":"_permissionedDisputeGameImpl","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57447,"src":"6334:28:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"Assignment","operator":"=","rightHandSide":{"id":57643,"name":"_addr","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57472,"src":"6365:5:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"src":"6334:36:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"id":57645,"nodeType":"ExpressionStatement","src":"6334:36:120"}},"id":57721,"nodeType":"IfStatement","src":"6187:846:120","trueBody":{"expression":{"id":57635,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftHandSide":{"id":57633,"name":"_faultDisputeGameImpl","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57445,"src":"6235:21:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"Assignment","operator":"=","rightHandSide":{"id":57634,"name":"_addr","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57472,"src":"6259:5:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"src":"6235:29:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"id":57636,"nodeType":"ExpressionStatement","src":"6235:29:120"}},"id":57722,"nodeType":"IfStatement","src":"6089:944:120","trueBody":{"expression":{"id":57626,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftHandSide":{"id":57624,"name":"_disputeGameFactoryProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57443,"src":"6140:24:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"Assignment","operator":"=","rightHandSide":{"id":57625,"name":"_addr","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57472,"src":"6167:5:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"src":"6140:32:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"id":57627,"nodeType":"ExpressionStatement","src":"6140:32:120"}},"id":57723,"nodeType":"IfStatement","src":"5969:1064:120","trueBody":{"expression":{"id":57617,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftHandSide":{"id":57615,"name":"_delayedWethPermissionlessGameProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57441,"src":"6031:35:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"Assignment","operator":"=","rightHandSide":{"id":57616,"name":"_addr","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57472,"src":"6069:5:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"src":"6031:43:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"id":57618,"nodeType":"ExpressionStatement","src":"6031:43:120"}},"id":57724,"nodeType":"IfStatement","src":"5853:1180:120","trueBody":{"expression":{"id":57608,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftHandSide":{"id":57606,"name":"_delayedWethPermissionedGameProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57439,"src":"5913:33:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"Assignment","operator":"=","rightHandSide":{"id":57607,"name":"_addr","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57472,"src":"5949:5:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"src":"5913:41:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"id":57609,"nodeType":"ExpressionStatement","src":"5913:41:120"}},"id":57725,"nodeType":"IfStatement","src":"5753:1280:120","trueBody":{"expression":{"id":57599,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftHandSide":{"id":57597,"name":"_anchorStateRegistryProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57437,"src":"5805:25:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"Assignment","operator":"=","rightHandSide":{"id":57598,"name":"_addr","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57472,"src":"5833:5:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"src":"5805:33:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"id":57600,"nodeType":"ExpressionStatement","src":"5805:33:120"}},"id":57726,"nodeType":"IfStatement","src":"5659:1374:120","trueBody":{"expression":{"id":57590,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftHandSide":{"id":57588,"name":"_opChainProxyAdminImpl","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57435,"src":"5708:22:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"Assignment","operator":"=","rightHandSide":{"id":57589,"name":"_addr","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57472,"src":"5733:5:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"src":"5708:30:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"id":57591,"nodeType":"ExpressionStatement","src":"5708:30:120"}},"id":57727,"nodeType":"IfStatement","src":"5573:1460:120","trueBody":{"expression":{"id":57581,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftHandSide":{"id":57579,"name":"_systemConfigProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57433,"src":"5618:18:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"Assignment","operator":"=","rightHandSide":{"id":57580,"name":"_addr","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57472,"src":"5639:5:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"src":"5618:26:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"id":57582,"nodeType":"ExpressionStatement","src":"5618:26:120"}},"id":57728,"nodeType":"IfStatement","src":"5483:1550:120","trueBody":{"expression":{"id":57572,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftHandSide":{"id":57570,"name":"_optimismPortalProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57431,"src":"5530:20:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"Assignment","operator":"=","rightHandSide":{"id":57571,"name":"_addr","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57472,"src":"5553:5:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"src":"5530:28:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"id":57573,"nodeType":"ExpressionStatement","src":"5530:28:120"}},"id":57729,"nodeType":"IfStatement","src":"5365:1668:120","trueBody":{"expression":{"id":57563,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftHandSide":{"id":57561,"name":"_optimismMintableErc20FactoryProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57429,"src":"5426:34:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"Assignment","operator":"=","rightHandSide":{"id":57562,"name":"_addr","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57472,"src":"5463:5:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"src":"5426:42:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"id":57564,"nodeType":"ExpressionStatement","src":"5426:42:120"}},"id":57730,"nodeType":"IfStatement","src":"5275:1758:120","trueBody":{"expression":{"id":57554,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftHandSide":{"id":57552,"name":"_l2OutputOracleProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57427,"src":"5322:20:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"Assignment","operator":"=","rightHandSide":{"id":57553,"name":"_addr","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57472,"src":"5345:5:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"src":"5322:28:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"id":57555,"nodeType":"ExpressionStatement","src":"5322:28:120"}},"id":57731,"nodeType":"IfStatement","src":"5181:1852:120","trueBody":{"expression":{"id":57545,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftHandSide":{"id":57543,"name":"_l1StandardBridgeProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57425,"src":"5230:22:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"Assignment","operator":"=","rightHandSide":{"id":57544,"name":"_addr","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57472,"src":"5255:5:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"src":"5230:30:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"id":57546,"nodeType":"ExpressionStatement","src":"5230:30:120"}},"id":57732,"nodeType":"IfStatement","src":"5091:1942:120","trueBody":{"expression":{"id":57536,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftHandSide":{"id":57534,"name":"_l1Erc721BridgeProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57423,"src":"5138:20:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"Assignment","operator":"=","rightHandSide":{"id":57535,"name":"_addr","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57472,"src":"5161:5:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"src":"5138:28:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"id":57537,"nodeType":"ExpressionStatement","src":"5138:28:120"}},"id":57733,"nodeType":"IfStatement","src":"4985:2048:120","trueBody":{"expression":{"id":57527,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftHandSide":{"id":57525,"name":"_l1CrossDomainMessengerProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57421,"src":"5040:28:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"Assignment","operator":"=","rightHandSide":{"id":57526,"name":"_addr","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57472,"src":"5071:5:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"src":"5040:36:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"id":57528,"nodeType":"ExpressionStatement","src":"5040:36:120"}},"id":57734,"nodeType":"IfStatement","src":"4903:2130:120","trueBody":{"expression":{"id":57518,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftHandSide":{"id":57516,"name":"_ethLockboxProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57419,"src":"4946:16:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"Assignment","operator":"=","rightHandSide":{"id":57517,"name":"_addr","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57472,"src":"4965:5:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"src":"4946:24:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"id":57519,"nodeType":"ExpressionStatement","src":"4946:24:120"}},"id":57735,"nodeType":"IfStatement","src":"4815:2218:120","trueBody":{"expression":{"id":57509,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftHandSide":{"id":57507,"name":"_addressManagerImpl","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57417,"src":"4861:19:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"Assignment","operator":"=","rightHandSide":{"id":57508,"name":"_addr","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57472,"src":"4883:5:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"src":"4861:27:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"id":57510,"nodeType":"ExpressionStatement","src":"4861:27:120"}},"id":57736,"nodeType":"IfStatement","src":"4696:2337:120","trueBody":{"expression":{"id":57500,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftHandSide":{"id":57498,"name":"_preimageOracleImpl","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57415,"src":"4742:19:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"Assignment","operator":"=","rightHandSide":{"id":57499,"name":"_addr","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57472,"src":"4764:5:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"src":"4742:27:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"id":57501,"nodeType":"ExpressionStatement","src":"4742:27:120"}},"id":57737,"nodeType":"IfStatement","src":"4628:2405:120","trueBody":{"expression":{"id":57491,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftHandSide":{"id":57489,"name":"_mipsImpl","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57413,"src":"4664:9:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"Assignment","operator":"=","rightHandSide":{"id":57490,"name":"_addr","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57472,"src":"4676:5:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"src":"4664:17:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"id":57492,"nodeType":"ExpressionStatement","src":"4664:17:120"}},"id":57738,"nodeType":"IfStatement","src":"4495:2538:120","trueBody":{"expression":{"id":57482,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftHandSide":{"id":57480,"name":"_superchainConfigProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57411,"src":"4544:22:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"Assignment","operator":"=","rightHandSide":{"id":57481,"name":"_addr","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57472,"src":"4569:5:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"src":"4544:30:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"id":57483,"nodeType":"ExpressionStatement","src":"4544:30:120"}}]},"functionSelector":"c3e39250","implemented":true,"kind":"function","modifiers":[],"name":"set","nameLocation":"4415:3:120","parameters":{"id":57473,"nodeType":"ParameterList","parameters":[{"constant":false,"id":57470,"mutability":"mutable","name":"_sel","nameLocation":"4426:4:120","nodeType":"VariableDeclaration","scope":57740,"src":"4419:11:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"},"typeName":{"id":57469,"name":"bytes4","nodeType":"ElementaryTypeName","src":"4419:6:120","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},"visibility":"internal"},{"constant":false,"id":57472,"mutability":"mutable","name":"_addr","nameLocation":"4440:5:120","nodeType":"VariableDeclaration","scope":57740,"src":"4432:13:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":57471,"name":"address","nodeType":"ElementaryTypeName","src":"4432:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"4418:28:120"},"returnParameters":{"id":57474,"nodeType":"ParameterList","parameters":[],"src":"4454:0:120"},"scope":58249,"stateMutability":"nonpayable","virtual":false,"visibility":"public"},{"id":57772,"nodeType":"FunctionDefinition","src":"7046:271:120","nodes":[],"body":{"id":57771,"nodeType":"Block","src":"7091:226:120","nodes":[],"statements":[{"condition":{"commonType":{"typeIdentifier":"t_bytes4","typeString":"bytes4"},"id":57751,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftExpression":{"id":57747,"name":"_sel","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57742,"src":"7105:4:120","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},"nodeType":"BinaryOperation","operator":"==","rightExpression":{"expression":{"expression":{"id":57748,"name":"this","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":-28,"src":"7113:4:120","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$58249","typeString":"contract FetchChainInfoOutput"}},"id":57749,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"7118:12:120","memberName":"permissioned","nodeType":"MemberAccess","referencedDeclaration":58231,"src":"7113:17:120","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_bool_$","typeString":"function () view external returns (bool)"}},"id":57750,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"memberLocation":"7131:8:120","memberName":"selector","nodeType":"MemberAccess","src":"7113:26:120","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},"src":"7105:34:120","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},"falseBody":{"condition":{"commonType":{"typeIdentifier":"t_bytes4","typeString":"bytes4"},"id":57760,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftExpression":{"id":57756,"name":"_sel","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57742,"src":"7181:4:120","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},"nodeType":"BinaryOperation","operator":"==","rightExpression":{"expression":{"expression":{"id":57757,"name":"this","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":-28,"src":"7189:4:120","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$58249","typeString":"contract FetchChainInfoOutput"}},"id":57758,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"7194:14:120","memberName":"permissionless","nodeType":"MemberAccess","referencedDeclaration":58239,"src":"7189:19:120","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_bool_$","typeString":"function () view external returns (bool)"}},"id":57759,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"memberLocation":"7209:8:120","memberName":"selector","nodeType":"MemberAccess","src":"7189:28:120","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},"src":"7181:36:120","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},"falseBody":{"expression":{"arguments":[{"hexValue":"4665746368436861696e496e666f4f75747075743a20756e6b6e6f776e20626f6f6c2073656c6563746f72","id":57766,"isConstant":false,"isLValue":false,"isPure":true,"kind":"string","lValueRequested":false,"nodeType":"Literal","src":"7264:45:120","typeDescriptions":{"typeIdentifier":"t_stringliteral_b43e73201a672ac9d292be9f8dc7215ba0fae6d34ae76c7f77ffd9b31af48fae","typeString":"literal_string \"FetchChainInfoOutput: unknown bool selector\""},"value":"FetchChainInfoOutput: unknown bool selector"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_stringliteral_b43e73201a672ac9d292be9f8dc7215ba0fae6d34ae76c7f77ffd9b31af48fae","typeString":"literal_string \"FetchChainInfoOutput: unknown bool selector\""}],"id":57765,"name":"revert","nodeType":"Identifier","overloadedDeclarations":[-19,-19],"referencedDeclaration":-19,"src":"7257:6:120","typeDescriptions":{"typeIdentifier":"t_function_revert_pure$_t_string_memory_ptr_$returns$__$","typeString":"function (string memory) pure"}},"id":57767,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"7257:53:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":57768,"nodeType":"ExpressionStatement","src":"7257:53:120"},"id":57769,"nodeType":"IfStatement","src":"7177:133:120","trueBody":{"expression":{"id":57763,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftHandSide":{"id":57761,"name":"_permissionless","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57465,"src":"7219:15:120","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},"nodeType":"Assignment","operator":"=","rightHandSide":{"id":57762,"name":"_bool","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57744,"src":"7237:5:120","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},"src":"7219:23:120","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},"id":57764,"nodeType":"ExpressionStatement","src":"7219:23:120"}},"id":57770,"nodeType":"IfStatement","src":"7101:209:120","trueBody":{"expression":{"id":57754,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftHandSide":{"id":57752,"name":"_permissioned","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57463,"src":"7141:13:120","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},"nodeType":"Assignment","operator":"=","rightHandSide":{"id":57753,"name":"_bool","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57744,"src":"7157:5:120","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},"src":"7141:21:120","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},"id":57755,"nodeType":"ExpressionStatement","src":"7141:21:120"}}]},"functionSelector":"baa1e15e","implemented":true,"kind":"function","modifiers":[],"name":"set","nameLocation":"7055:3:120","parameters":{"id":57745,"nodeType":"ParameterList","parameters":[{"constant":false,"id":57742,"mutability":"mutable","name":"_sel","nameLocation":"7066:4:120","nodeType":"VariableDeclaration","scope":57772,"src":"7059:11:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"},"typeName":{"id":57741,"name":"bytes4","nodeType":"ElementaryTypeName","src":"7059:6:120","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},"visibility":"internal"},{"constant":false,"id":57744,"mutability":"mutable","name":"_bool","nameLocation":"7077:5:120","nodeType":"VariableDeclaration","scope":57772,"src":"7072:10:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"},"typeName":{"id":57743,"name":"bool","nodeType":"ElementaryTypeName","src":"7072:4:120","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},"visibility":"internal"}],"src":"7058:25:120"},"returnParameters":{"id":57746,"nodeType":"ParameterList","parameters":[],"src":"7091:0:120"},"scope":58249,"stateMutability":"nonpayable","virtual":false,"visibility":"public"},{"id":57795,"nodeType":"FunctionDefinition","src":"7323:217:120","nodes":[],"body":{"id":57794,"nodeType":"Block","src":"7376:164:120","nodes":[],"statements":[{"condition":{"commonType":{"typeIdentifier":"t_bytes4","typeString":"bytes4"},"id":57784,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftExpression":{"id":57780,"name":"_sel","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57774,"src":"7390:4:120","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},"nodeType":"BinaryOperation","operator":"==","rightExpression":{"expression":{"expression":{"id":57781,"name":"this","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":-28,"src":"7398:4:120","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$58249","typeString":"contract FetchChainInfoOutput"}},"id":57782,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"7403:17:120","memberName":"respectedGameType","nodeType":"MemberAccess","referencedDeclaration":58248,"src":"7398:22:120","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_userDefinedValueType$_GameType_$75355_$","typeString":"function () view external returns (GameType)"}},"id":57783,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"memberLocation":"7421:8:120","memberName":"selector","nodeType":"MemberAccess","src":"7398:31:120","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},"src":"7390:39:120","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},"falseBody":{"expression":{"arguments":[{"hexValue":"4665746368436861696e496e666f4f75747075743a20756e6b6e6f776e2047616d65547970652073656c6563746f72","id":57790,"isConstant":false,"isLValue":false,"isPure":true,"kind":"string","lValueRequested":false,"nodeType":"Literal","src":"7483:49:120","typeDescriptions":{"typeIdentifier":"t_stringliteral_520d3d0cced140fee76c803f92d1db783b790e13f72de1e8f8c229c8c8783afc","typeString":"literal_string \"FetchChainInfoOutput: unknown GameType selector\""},"value":"FetchChainInfoOutput: unknown GameType selector"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_stringliteral_520d3d0cced140fee76c803f92d1db783b790e13f72de1e8f8c229c8c8783afc","typeString":"literal_string \"FetchChainInfoOutput: unknown GameType selector\""}],"id":57789,"name":"revert","nodeType":"Identifier","overloadedDeclarations":[-19,-19],"referencedDeclaration":-19,"src":"7476:6:120","typeDescriptions":{"typeIdentifier":"t_function_revert_pure$_t_string_memory_ptr_$returns$__$","typeString":"function (string memory) pure"}},"id":57791,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"7476:57:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":57792,"nodeType":"ExpressionStatement","src":"7476:57:120"},"id":57793,"nodeType":"IfStatement","src":"7386:147:120","trueBody":{"expression":{"id":57787,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftHandSide":{"id":57785,"name":"_respectedGameType","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57468,"src":"7431:18:120","typeDescriptions":{"typeIdentifier":"t_userDefinedValueType$_GameType_$75355","typeString":"GameType"}},"nodeType":"Assignment","operator":"=","rightHandSide":{"id":57786,"name":"_gameType","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57777,"src":"7452:9:120","typeDescriptions":{"typeIdentifier":"t_userDefinedValueType$_GameType_$75355","typeString":"GameType"}},"src":"7431:30:120","typeDescriptions":{"typeIdentifier":"t_userDefinedValueType$_GameType_$75355","typeString":"GameType"}},"id":57788,"nodeType":"ExpressionStatement","src":"7431:30:120"}}]},"functionSelector":"d08d6066","implemented":true,"kind":"function","modifiers":[],"name":"set","nameLocation":"7332:3:120","parameters":{"id":57778,"nodeType":"ParameterList","parameters":[{"constant":false,"id":57774,"mutability":"mutable","name":"_sel","nameLocation":"7343:4:120","nodeType":"VariableDeclaration","scope":57795,"src":"7336:11:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"},"typeName":{"id":57773,"name":"bytes4","nodeType":"ElementaryTypeName","src":"7336:6:120","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},"visibility":"internal"},{"constant":false,"id":57777,"mutability":"mutable","name":"_gameType","nameLocation":"7358:9:120","nodeType":"VariableDeclaration","scope":57795,"src":"7349:18:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_userDefinedValueType$_GameType_$75355","typeString":"GameType"},"typeName":{"id":57776,"nodeType":"UserDefinedTypeName","pathNode":{"id":57775,"name":"GameType","nameLocations":["7349:8:120"],"nodeType":"IdentifierPath","referencedDeclaration":75355,"src":"7349:8:120"},"referencedDeclaration":75355,"src":"7349:8:120","typeDescriptions":{"typeIdentifier":"t_userDefinedValueType$_GameType_$75355","typeString":"GameType"}},"visibility":"internal"}],"src":"7335:33:120"},"returnParameters":{"id":57779,"nodeType":"ParameterList","parameters":[],"src":"7376:0:120"},"scope":58249,"stateMutability":"nonpayable","virtual":false,"visibility":"public"},{"id":57813,"nodeType":"FunctionDefinition","src":"7546:207:120","nodes":[],"body":{"id":57812,"nodeType":"Block","src":"7606:147:120","nodes":[],"statements":[{"expression":{"arguments":[{"commonType":{"typeIdentifier":"t_address","typeString":"address"},"id":57806,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftExpression":{"id":57801,"name":"_addressManagerImpl","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57417,"src":"7624:19:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"BinaryOperation","operator":"!=","rightExpression":{"arguments":[{"hexValue":"30","id":57804,"isConstant":false,"isLValue":false,"isPure":true,"kind":"number","lValueRequested":false,"nodeType":"Literal","src":"7655:1:120","typeDescriptions":{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"},"value":"0"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"}],"id":57803,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"nodeType":"ElementaryTypeNameExpression","src":"7647:7:120","typeDescriptions":{"typeIdentifier":"t_type$_t_address_$","typeString":"type(address)"},"typeName":{"id":57802,"name":"address","nodeType":"ElementaryTypeName","src":"7647:7:120","typeDescriptions":{}}},"id":57805,"isConstant":false,"isLValue":false,"isPure":true,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"7647:10:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"src":"7624:33:120","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},{"hexValue":"4665746368436861696e496e666f4f75747075743a20616464726573734d616e61676572496d706c206e6f7420736574","id":57807,"isConstant":false,"isLValue":false,"isPure":true,"kind":"string","lValueRequested":false,"nodeType":"Literal","src":"7659:50:120","typeDescriptions":{"typeIdentifier":"t_stringliteral_b154041fe6470d62d16e8ad5c6d8e6c50a46e3e155a380b02703b07321b83f6a","typeString":"literal_string \"FetchChainInfoOutput: addressManagerImpl not set\""},"value":"FetchChainInfoOutput: addressManagerImpl not set"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_bool","typeString":"bool"},{"typeIdentifier":"t_stringliteral_b154041fe6470d62d16e8ad5c6d8e6c50a46e3e155a380b02703b07321b83f6a","typeString":"literal_string \"FetchChainInfoOutput: addressManagerImpl not set\""}],"id":57800,"name":"require","nodeType":"Identifier","overloadedDeclarations":[-18,-18],"referencedDeclaration":-18,"src":"7616:7:120","typeDescriptions":{"typeIdentifier":"t_function_require_pure$_t_bool_$_t_string_memory_ptr_$returns$__$","typeString":"function (bool,string memory) pure"}},"id":57808,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"7616:94:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":57809,"nodeType":"ExpressionStatement","src":"7616:94:120"},{"expression":{"id":57810,"name":"_addressManagerImpl","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57417,"src":"7727:19:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"functionReturnParameters":57799,"id":57811,"nodeType":"Return","src":"7720:26:120"}]},"functionSelector":"bd366b8f","implemented":true,"kind":"function","modifiers":[],"name":"addressManagerImpl","nameLocation":"7555:18:120","parameters":{"id":57796,"nodeType":"ParameterList","parameters":[],"src":"7573:2:120"},"returnParameters":{"id":57799,"nodeType":"ParameterList","parameters":[{"constant":false,"id":57798,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":57813,"src":"7597:7:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":57797,"name":"address","nodeType":"ElementaryTypeName","src":"7597:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"7596:9:120"},"scope":58249,"stateMutability":"view","virtual":false,"visibility":"public"},{"id":57821,"nodeType":"FunctionDefinition","src":"7759:97:120","nodes":[],"body":{"id":57820,"nodeType":"Block","src":"7816:40:120","nodes":[],"statements":[{"expression":{"id":57818,"name":"_ethLockboxProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57419,"src":"7833:16:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"functionReturnParameters":57817,"id":57819,"nodeType":"Return","src":"7826:23:120"}]},"functionSelector":"f646b07c","implemented":true,"kind":"function","modifiers":[],"name":"ethLockboxProxy","nameLocation":"7768:15:120","parameters":{"id":57814,"nodeType":"ParameterList","parameters":[],"src":"7783:2:120"},"returnParameters":{"id":57817,"nodeType":"ParameterList","parameters":[{"constant":false,"id":57816,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":57821,"src":"7807:7:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":57815,"name":"address","nodeType":"ElementaryTypeName","src":"7807:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"7806:9:120"},"scope":58249,"stateMutability":"view","virtual":false,"visibility":"public"},{"id":57839,"nodeType":"FunctionDefinition","src":"7862:243:120","nodes":[],"body":{"id":57838,"nodeType":"Block","src":"7931:174:120","nodes":[],"statements":[{"expression":{"arguments":[{"commonType":{"typeIdentifier":"t_address","typeString":"address"},"id":57832,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftExpression":{"id":57827,"name":"_l1CrossDomainMessengerProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57421,"src":"7949:28:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"BinaryOperation","operator":"!=","rightExpression":{"arguments":[{"hexValue":"30","id":57830,"isConstant":false,"isLValue":false,"isPure":true,"kind":"number","lValueRequested":false,"nodeType":"Literal","src":"7989:1:120","typeDescriptions":{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"},"value":"0"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"}],"id":57829,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"nodeType":"ElementaryTypeNameExpression","src":"7981:7:120","typeDescriptions":{"typeIdentifier":"t_type$_t_address_$","typeString":"type(address)"},"typeName":{"id":57828,"name":"address","nodeType":"ElementaryTypeName","src":"7981:7:120","typeDescriptions":{}}},"id":57831,"isConstant":false,"isLValue":false,"isPure":true,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"7981:10:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"src":"7949:42:120","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},{"hexValue":"4665746368436861696e496e666f4f75747075743a206c3143726f7373446f6d61696e4d657373656e67657250726f7879206e6f7420736574","id":57833,"isConstant":false,"isLValue":false,"isPure":true,"kind":"string","lValueRequested":false,"nodeType":"Literal","src":"7993:59:120","typeDescriptions":{"typeIdentifier":"t_stringliteral_c51216a9bdef996dd7040e19ba4fe817587273a187f1f145abfd19b1308df5eb","typeString":"literal_string \"FetchChainInfoOutput: l1CrossDomainMessengerProxy not set\""},"value":"FetchChainInfoOutput: l1CrossDomainMessengerProxy not set"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_bool","typeString":"bool"},{"typeIdentifier":"t_stringliteral_c51216a9bdef996dd7040e19ba4fe817587273a187f1f145abfd19b1308df5eb","typeString":"literal_string \"FetchChainInfoOutput: l1CrossDomainMessengerProxy not set\""}],"id":57826,"name":"require","nodeType":"Identifier","overloadedDeclarations":[-18,-18],"referencedDeclaration":-18,"src":"7941:7:120","typeDescriptions":{"typeIdentifier":"t_function_require_pure$_t_bool_$_t_string_memory_ptr_$returns$__$","typeString":"function (bool,string memory) pure"}},"id":57834,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"7941:112:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":57835,"nodeType":"ExpressionStatement","src":"7941:112:120"},{"expression":{"id":57836,"name":"_l1CrossDomainMessengerProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57421,"src":"8070:28:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"functionReturnParameters":57825,"id":57837,"nodeType":"Return","src":"8063:35:120"}]},"functionSelector":"54729cfb","implemented":true,"kind":"function","modifiers":[],"name":"l1CrossDomainMessengerProxy","nameLocation":"7871:27:120","parameters":{"id":57822,"nodeType":"ParameterList","parameters":[],"src":"7898:2:120"},"returnParameters":{"id":57825,"nodeType":"ParameterList","parameters":[{"constant":false,"id":57824,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":57839,"src":"7922:7:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":57823,"name":"address","nodeType":"ElementaryTypeName","src":"7922:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"7921:9:120"},"scope":58249,"stateMutability":"view","virtual":false,"visibility":"public"},{"id":57857,"nodeType":"FunctionDefinition","src":"8111:211:120","nodes":[],"body":{"id":57856,"nodeType":"Block","src":"8172:150:120","nodes":[],"statements":[{"expression":{"arguments":[{"commonType":{"typeIdentifier":"t_address","typeString":"address"},"id":57850,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftExpression":{"id":57845,"name":"_l1Erc721BridgeProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57423,"src":"8190:20:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"BinaryOperation","operator":"!=","rightExpression":{"arguments":[{"hexValue":"30","id":57848,"isConstant":false,"isLValue":false,"isPure":true,"kind":"number","lValueRequested":false,"nodeType":"Literal","src":"8222:1:120","typeDescriptions":{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"},"value":"0"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"}],"id":57847,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"nodeType":"ElementaryTypeNameExpression","src":"8214:7:120","typeDescriptions":{"typeIdentifier":"t_type$_t_address_$","typeString":"type(address)"},"typeName":{"id":57846,"name":"address","nodeType":"ElementaryTypeName","src":"8214:7:120","typeDescriptions":{}}},"id":57849,"isConstant":false,"isLValue":false,"isPure":true,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"8214:10:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"src":"8190:34:120","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},{"hexValue":"4665746368436861696e496e666f4f75747075743a206c3145726337323142726964676550726f7879206e6f7420736574","id":57851,"isConstant":false,"isLValue":false,"isPure":true,"kind":"string","lValueRequested":false,"nodeType":"Literal","src":"8226:51:120","typeDescriptions":{"typeIdentifier":"t_stringliteral_bdf5319949d8561b59a02fe667aa58fca11f5f8571bc18997b0bc0ac582aece7","typeString":"literal_string \"FetchChainInfoOutput: l1Erc721BridgeProxy not set\""},"value":"FetchChainInfoOutput: l1Erc721BridgeProxy not set"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_bool","typeString":"bool"},{"typeIdentifier":"t_stringliteral_bdf5319949d8561b59a02fe667aa58fca11f5f8571bc18997b0bc0ac582aece7","typeString":"literal_string \"FetchChainInfoOutput: l1Erc721BridgeProxy not set\""}],"id":57844,"name":"require","nodeType":"Identifier","overloadedDeclarations":[-18,-18],"referencedDeclaration":-18,"src":"8182:7:120","typeDescriptions":{"typeIdentifier":"t_function_require_pure$_t_bool_$_t_string_memory_ptr_$returns$__$","typeString":"function (bool,string memory) pure"}},"id":57852,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"8182:96:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":57853,"nodeType":"ExpressionStatement","src":"8182:96:120"},{"expression":{"id":57854,"name":"_l1Erc721BridgeProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57423,"src":"8295:20:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"functionReturnParameters":57843,"id":57855,"nodeType":"Return","src":"8288:27:120"}]},"functionSelector":"ebfa8409","implemented":true,"kind":"function","modifiers":[],"name":"l1Erc721BridgeProxy","nameLocation":"8120:19:120","parameters":{"id":57840,"nodeType":"ParameterList","parameters":[],"src":"8139:2:120"},"returnParameters":{"id":57843,"nodeType":"ParameterList","parameters":[{"constant":false,"id":57842,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":57857,"src":"8163:7:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":57841,"name":"address","nodeType":"ElementaryTypeName","src":"8163:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"8162:9:120"},"scope":58249,"stateMutability":"view","virtual":false,"visibility":"public"},{"id":57875,"nodeType":"FunctionDefinition","src":"8328:219:120","nodes":[],"body":{"id":57874,"nodeType":"Block","src":"8391:156:120","nodes":[],"statements":[{"expression":{"arguments":[{"commonType":{"typeIdentifier":"t_address","typeString":"address"},"id":57868,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftExpression":{"id":57863,"name":"_l1StandardBridgeProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57425,"src":"8409:22:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"BinaryOperation","operator":"!=","rightExpression":{"arguments":[{"hexValue":"30","id":57866,"isConstant":false,"isLValue":false,"isPure":true,"kind":"number","lValueRequested":false,"nodeType":"Literal","src":"8443:1:120","typeDescriptions":{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"},"value":"0"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"}],"id":57865,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"nodeType":"ElementaryTypeNameExpression","src":"8435:7:120","typeDescriptions":{"typeIdentifier":"t_type$_t_address_$","typeString":"type(address)"},"typeName":{"id":57864,"name":"address","nodeType":"ElementaryTypeName","src":"8435:7:120","typeDescriptions":{}}},"id":57867,"isConstant":false,"isLValue":false,"isPure":true,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"8435:10:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"src":"8409:36:120","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},{"hexValue":"4665746368436861696e496e666f4f75747075743a206c315374616e6461726442726964676550726f7879206e6f7420736574","id":57869,"isConstant":false,"isLValue":false,"isPure":true,"kind":"string","lValueRequested":false,"nodeType":"Literal","src":"8447:53:120","typeDescriptions":{"typeIdentifier":"t_stringliteral_ab3776e760de395cff3bb935602469d5b7c0bd9b5cfaefde9d221be6524302e1","typeString":"literal_string \"FetchChainInfoOutput: l1StandardBridgeProxy not set\""},"value":"FetchChainInfoOutput: l1StandardBridgeProxy not set"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_bool","typeString":"bool"},{"typeIdentifier":"t_stringliteral_ab3776e760de395cff3bb935602469d5b7c0bd9b5cfaefde9d221be6524302e1","typeString":"literal_string \"FetchChainInfoOutput: l1StandardBridgeProxy not set\""}],"id":57862,"name":"require","nodeType":"Identifier","overloadedDeclarations":[-18,-18],"referencedDeclaration":-18,"src":"8401:7:120","typeDescriptions":{"typeIdentifier":"t_function_require_pure$_t_bool_$_t_string_memory_ptr_$returns$__$","typeString":"function (bool,string memory) pure"}},"id":57870,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"8401:100:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":57871,"nodeType":"ExpressionStatement","src":"8401:100:120"},{"expression":{"id":57872,"name":"_l1StandardBridgeProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57425,"src":"8518:22:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"functionReturnParameters":57861,"id":57873,"nodeType":"Return","src":"8511:29:120"}]},"functionSelector":"102b6069","implemented":true,"kind":"function","modifiers":[],"name":"l1StandardBridgeProxy","nameLocation":"8337:21:120","parameters":{"id":57858,"nodeType":"ParameterList","parameters":[],"src":"8358:2:120"},"returnParameters":{"id":57861,"nodeType":"ParameterList","parameters":[{"constant":false,"id":57860,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":57875,"src":"8382:7:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":57859,"name":"address","nodeType":"ElementaryTypeName","src":"8382:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"8381:9:120"},"scope":58249,"stateMutability":"view","virtual":false,"visibility":"public"},{"id":57893,"nodeType":"FunctionDefinition","src":"8553:211:120","nodes":[],"body":{"id":57892,"nodeType":"Block","src":"8614:150:120","nodes":[],"statements":[{"expression":{"arguments":[{"commonType":{"typeIdentifier":"t_address","typeString":"address"},"id":57886,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftExpression":{"id":57881,"name":"_l2OutputOracleProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57427,"src":"8632:20:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"BinaryOperation","operator":"!=","rightExpression":{"arguments":[{"hexValue":"30","id":57884,"isConstant":false,"isLValue":false,"isPure":true,"kind":"number","lValueRequested":false,"nodeType":"Literal","src":"8664:1:120","typeDescriptions":{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"},"value":"0"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"}],"id":57883,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"nodeType":"ElementaryTypeNameExpression","src":"8656:7:120","typeDescriptions":{"typeIdentifier":"t_type$_t_address_$","typeString":"type(address)"},"typeName":{"id":57882,"name":"address","nodeType":"ElementaryTypeName","src":"8656:7:120","typeDescriptions":{}}},"id":57885,"isConstant":false,"isLValue":false,"isPure":true,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"8656:10:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"src":"8632:34:120","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},{"hexValue":"4665746368436861696e496e666f4f75747075743a206c324f75747075744f7261636c6550726f7879206e6f7420736574","id":57887,"isConstant":false,"isLValue":false,"isPure":true,"kind":"string","lValueRequested":false,"nodeType":"Literal","src":"8668:51:120","typeDescriptions":{"typeIdentifier":"t_stringliteral_2f861759874f8f3e0cfa53ef8dfb0556f88f877edbaf1dbc485fc820d67ac86a","typeString":"literal_string \"FetchChainInfoOutput: l2OutputOracleProxy not set\""},"value":"FetchChainInfoOutput: l2OutputOracleProxy not set"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_bool","typeString":"bool"},{"typeIdentifier":"t_stringliteral_2f861759874f8f3e0cfa53ef8dfb0556f88f877edbaf1dbc485fc820d67ac86a","typeString":"literal_string \"FetchChainInfoOutput: l2OutputOracleProxy not set\""}],"id":57880,"name":"require","nodeType":"Identifier","overloadedDeclarations":[-18,-18],"referencedDeclaration":-18,"src":"8624:7:120","typeDescriptions":{"typeIdentifier":"t_function_require_pure$_t_bool_$_t_string_memory_ptr_$returns$__$","typeString":"function (bool,string memory) pure"}},"id":57888,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"8624:96:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":57889,"nodeType":"ExpressionStatement","src":"8624:96:120"},{"expression":{"id":57890,"name":"_l2OutputOracleProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57427,"src":"8737:20:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"functionReturnParameters":57879,"id":57891,"nodeType":"Return","src":"8730:27:120"}]},"functionSelector":"a2c9a89f","implemented":true,"kind":"function","modifiers":[],"name":"l2OutputOracleProxy","nameLocation":"8562:19:120","parameters":{"id":57876,"nodeType":"ParameterList","parameters":[],"src":"8581:2:120"},"returnParameters":{"id":57879,"nodeType":"ParameterList","parameters":[{"constant":false,"id":57878,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":57893,"src":"8605:7:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":57877,"name":"address","nodeType":"ElementaryTypeName","src":"8605:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"8604:9:120"},"scope":58249,"stateMutability":"view","virtual":false,"visibility":"public"},{"id":57911,"nodeType":"FunctionDefinition","src":"8770:301:120","nodes":[],"body":{"id":57910,"nodeType":"Block","src":"8845:226:120","nodes":[],"statements":[{"expression":{"arguments":[{"commonType":{"typeIdentifier":"t_address","typeString":"address"},"id":57904,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftExpression":{"id":57899,"name":"_optimismMintableErc20FactoryProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57429,"src":"8876:34:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"BinaryOperation","operator":"!=","rightExpression":{"arguments":[{"hexValue":"30","id":57902,"isConstant":false,"isLValue":false,"isPure":true,"kind":"number","lValueRequested":false,"nodeType":"Literal","src":"8922:1:120","typeDescriptions":{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"},"value":"0"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"}],"id":57901,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"nodeType":"ElementaryTypeNameExpression","src":"8914:7:120","typeDescriptions":{"typeIdentifier":"t_type$_t_address_$","typeString":"type(address)"},"typeName":{"id":57900,"name":"address","nodeType":"ElementaryTypeName","src":"8914:7:120","typeDescriptions":{}}},"id":57903,"isConstant":false,"isLValue":false,"isPure":true,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"8914:10:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"src":"8876:48:120","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},{"hexValue":"4665746368436861696e496e666f4f75747075743a206f7074696d69736d4d696e7461626c654572633230466163746f727950726f7879206e6f7420736574","id":57905,"isConstant":false,"isLValue":false,"isPure":true,"kind":"string","lValueRequested":false,"nodeType":"Literal","src":"8938:65:120","typeDescriptions":{"typeIdentifier":"t_stringliteral_58c040fbde84bd4afd9f21f5ba3150dab029d767b65aafdf14512bdafdbd9954","typeString":"literal_string \"FetchChainInfoOutput: optimismMintableErc20FactoryProxy not set\""},"value":"FetchChainInfoOutput: optimismMintableErc20FactoryProxy not set"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_bool","typeString":"bool"},{"typeIdentifier":"t_stringliteral_58c040fbde84bd4afd9f21f5ba3150dab029d767b65aafdf14512bdafdbd9954","typeString":"literal_string \"FetchChainInfoOutput: optimismMintableErc20FactoryProxy not set\""}],"id":57898,"name":"require","nodeType":"Identifier","overloadedDeclarations":[-18,-18],"referencedDeclaration":-18,"src":"8855:7:120","typeDescriptions":{"typeIdentifier":"t_function_require_pure$_t_bool_$_t_string_memory_ptr_$returns$__$","typeString":"function (bool,string memory) pure"}},"id":57906,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"8855:158:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":57907,"nodeType":"ExpressionStatement","src":"8855:158:120"},{"expression":{"id":57908,"name":"_optimismMintableErc20FactoryProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57429,"src":"9030:34:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"functionReturnParameters":57897,"id":57909,"nodeType":"Return","src":"9023:41:120"}]},"functionSelector":"8f20c7e4","implemented":true,"kind":"function","modifiers":[],"name":"optimismMintableErc20FactoryProxy","nameLocation":"8779:33:120","parameters":{"id":57894,"nodeType":"ParameterList","parameters":[],"src":"8812:2:120"},"returnParameters":{"id":57897,"nodeType":"ParameterList","parameters":[{"constant":false,"id":57896,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":57911,"src":"8836:7:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":57895,"name":"address","nodeType":"ElementaryTypeName","src":"8836:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"8835:9:120"},"scope":58249,"stateMutability":"view","virtual":false,"visibility":"public"},{"id":57929,"nodeType":"FunctionDefinition","src":"9077:211:120","nodes":[],"body":{"id":57928,"nodeType":"Block","src":"9138:150:120","nodes":[],"statements":[{"expression":{"arguments":[{"commonType":{"typeIdentifier":"t_address","typeString":"address"},"id":57922,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftExpression":{"id":57917,"name":"_optimismPortalProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57431,"src":"9156:20:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"BinaryOperation","operator":"!=","rightExpression":{"arguments":[{"hexValue":"30","id":57920,"isConstant":false,"isLValue":false,"isPure":true,"kind":"number","lValueRequested":false,"nodeType":"Literal","src":"9188:1:120","typeDescriptions":{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"},"value":"0"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"}],"id":57919,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"nodeType":"ElementaryTypeNameExpression","src":"9180:7:120","typeDescriptions":{"typeIdentifier":"t_type$_t_address_$","typeString":"type(address)"},"typeName":{"id":57918,"name":"address","nodeType":"ElementaryTypeName","src":"9180:7:120","typeDescriptions":{}}},"id":57921,"isConstant":false,"isLValue":false,"isPure":true,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"9180:10:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"src":"9156:34:120","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},{"hexValue":"4665746368436861696e496e666f4f75747075743a206f7074696d69736d506f7274616c50726f7879206e6f7420736574","id":57923,"isConstant":false,"isLValue":false,"isPure":true,"kind":"string","lValueRequested":false,"nodeType":"Literal","src":"9192:51:120","typeDescriptions":{"typeIdentifier":"t_stringliteral_ef003bab75ab0cfa4ca81f99eb20b37a3fded08fa7502df7d991f596c8680642","typeString":"literal_string \"FetchChainInfoOutput: optimismPortalProxy not set\""},"value":"FetchChainInfoOutput: optimismPortalProxy not set"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_bool","typeString":"bool"},{"typeIdentifier":"t_stringliteral_ef003bab75ab0cfa4ca81f99eb20b37a3fded08fa7502df7d991f596c8680642","typeString":"literal_string \"FetchChainInfoOutput: optimismPortalProxy not set\""}],"id":57916,"name":"require","nodeType":"Identifier","overloadedDeclarations":[-18,-18],"referencedDeclaration":-18,"src":"9148:7:120","typeDescriptions":{"typeIdentifier":"t_function_require_pure$_t_bool_$_t_string_memory_ptr_$returns$__$","typeString":"function (bool,string memory) pure"}},"id":57924,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"9148:96:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":57925,"nodeType":"ExpressionStatement","src":"9148:96:120"},{"expression":{"id":57926,"name":"_optimismPortalProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57431,"src":"9261:20:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"functionReturnParameters":57915,"id":57927,"nodeType":"Return","src":"9254:27:120"}]},"functionSelector":"04451c49","implemented":true,"kind":"function","modifiers":[],"name":"optimismPortalProxy","nameLocation":"9086:19:120","parameters":{"id":57912,"nodeType":"ParameterList","parameters":[],"src":"9105:2:120"},"returnParameters":{"id":57915,"nodeType":"ParameterList","parameters":[{"constant":false,"id":57914,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":57929,"src":"9129:7:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":57913,"name":"address","nodeType":"ElementaryTypeName","src":"9129:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"9128:9:120"},"scope":58249,"stateMutability":"view","virtual":false,"visibility":"public"},{"id":57947,"nodeType":"FunctionDefinition","src":"9294:203:120","nodes":[],"body":{"id":57946,"nodeType":"Block","src":"9353:144:120","nodes":[],"statements":[{"expression":{"arguments":[{"commonType":{"typeIdentifier":"t_address","typeString":"address"},"id":57940,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftExpression":{"id":57935,"name":"_systemConfigProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57433,"src":"9371:18:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"BinaryOperation","operator":"!=","rightExpression":{"arguments":[{"hexValue":"30","id":57938,"isConstant":false,"isLValue":false,"isPure":true,"kind":"number","lValueRequested":false,"nodeType":"Literal","src":"9401:1:120","typeDescriptions":{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"},"value":"0"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"}],"id":57937,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"nodeType":"ElementaryTypeNameExpression","src":"9393:7:120","typeDescriptions":{"typeIdentifier":"t_type$_t_address_$","typeString":"type(address)"},"typeName":{"id":57936,"name":"address","nodeType":"ElementaryTypeName","src":"9393:7:120","typeDescriptions":{}}},"id":57939,"isConstant":false,"isLValue":false,"isPure":true,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"9393:10:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"src":"9371:32:120","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},{"hexValue":"4665746368436861696e496e666f4f75747075743a2073797374656d436f6e66696750726f7879206e6f7420736574","id":57941,"isConstant":false,"isLValue":false,"isPure":true,"kind":"string","lValueRequested":false,"nodeType":"Literal","src":"9405:49:120","typeDescriptions":{"typeIdentifier":"t_stringliteral_09ada010329fb4e012f4c857519ec176efea734f55c01f382f1b6c7bd752716b","typeString":"literal_string \"FetchChainInfoOutput: systemConfigProxy not set\""},"value":"FetchChainInfoOutput: systemConfigProxy not set"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_bool","typeString":"bool"},{"typeIdentifier":"t_stringliteral_09ada010329fb4e012f4c857519ec176efea734f55c01f382f1b6c7bd752716b","typeString":"literal_string \"FetchChainInfoOutput: systemConfigProxy not set\""}],"id":57934,"name":"require","nodeType":"Identifier","overloadedDeclarations":[-18,-18],"referencedDeclaration":-18,"src":"9363:7:120","typeDescriptions":{"typeIdentifier":"t_function_require_pure$_t_bool_$_t_string_memory_ptr_$returns$__$","typeString":"function (bool,string memory) pure"}},"id":57942,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"9363:92:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":57943,"nodeType":"ExpressionStatement","src":"9363:92:120"},{"expression":{"id":57944,"name":"_systemConfigProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57433,"src":"9472:18:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"functionReturnParameters":57933,"id":57945,"nodeType":"Return","src":"9465:25:120"}]},"functionSelector":"c17db6e3","implemented":true,"kind":"function","modifiers":[],"name":"systemConfigProxy","nameLocation":"9303:17:120","parameters":{"id":57930,"nodeType":"ParameterList","parameters":[],"src":"9320:2:120"},"returnParameters":{"id":57933,"nodeType":"ParameterList","parameters":[{"constant":false,"id":57932,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":57947,"src":"9344:7:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":57931,"name":"address","nodeType":"ElementaryTypeName","src":"9344:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"9343:9:120"},"scope":58249,"stateMutability":"view","virtual":false,"visibility":"public"},{"id":57965,"nodeType":"FunctionDefinition","src":"9503:219:120","nodes":[],"body":{"id":57964,"nodeType":"Block","src":"9566:156:120","nodes":[],"statements":[{"expression":{"arguments":[{"commonType":{"typeIdentifier":"t_address","typeString":"address"},"id":57958,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftExpression":{"id":57953,"name":"_opChainProxyAdminImpl","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57435,"src":"9584:22:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"BinaryOperation","operator":"!=","rightExpression":{"arguments":[{"hexValue":"30","id":57956,"isConstant":false,"isLValue":false,"isPure":true,"kind":"number","lValueRequested":false,"nodeType":"Literal","src":"9618:1:120","typeDescriptions":{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"},"value":"0"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"}],"id":57955,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"nodeType":"ElementaryTypeNameExpression","src":"9610:7:120","typeDescriptions":{"typeIdentifier":"t_type$_t_address_$","typeString":"type(address)"},"typeName":{"id":57954,"name":"address","nodeType":"ElementaryTypeName","src":"9610:7:120","typeDescriptions":{}}},"id":57957,"isConstant":false,"isLValue":false,"isPure":true,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"9610:10:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"src":"9584:36:120","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},{"hexValue":"4665746368436861696e496e666f4f75747075743a206f70436861696e50726f787941646d696e496d706c206e6f7420736574","id":57959,"isConstant":false,"isLValue":false,"isPure":true,"kind":"string","lValueRequested":false,"nodeType":"Literal","src":"9622:53:120","typeDescriptions":{"typeIdentifier":"t_stringliteral_8ebc3647bde8a1129bfd827c7ef2e2d4fea82292bcad8a3c8e3918d70fed8ea8","typeString":"literal_string \"FetchChainInfoOutput: opChainProxyAdminImpl not set\""},"value":"FetchChainInfoOutput: opChainProxyAdminImpl not set"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_bool","typeString":"bool"},{"typeIdentifier":"t_stringliteral_8ebc3647bde8a1129bfd827c7ef2e2d4fea82292bcad8a3c8e3918d70fed8ea8","typeString":"literal_string \"FetchChainInfoOutput: opChainProxyAdminImpl not set\""}],"id":57952,"name":"require","nodeType":"Identifier","overloadedDeclarations":[-18,-18],"referencedDeclaration":-18,"src":"9576:7:120","typeDescriptions":{"typeIdentifier":"t_function_require_pure$_t_bool_$_t_string_memory_ptr_$returns$__$","typeString":"function (bool,string memory) pure"}},"id":57960,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"9576:100:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":57961,"nodeType":"ExpressionStatement","src":"9576:100:120"},{"expression":{"id":57962,"name":"_opChainProxyAdminImpl","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57435,"src":"9693:22:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"functionReturnParameters":57951,"id":57963,"nodeType":"Return","src":"9686:29:120"}]},"functionSelector":"5643665f","implemented":true,"kind":"function","modifiers":[],"name":"opChainProxyAdminImpl","nameLocation":"9512:21:120","parameters":{"id":57948,"nodeType":"ParameterList","parameters":[],"src":"9533:2:120"},"returnParameters":{"id":57951,"nodeType":"ParameterList","parameters":[{"constant":false,"id":57950,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":57965,"src":"9557:7:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":57949,"name":"address","nodeType":"ElementaryTypeName","src":"9557:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"9556:9:120"},"scope":58249,"stateMutability":"view","virtual":false,"visibility":"public"},{"id":57983,"nodeType":"FunctionDefinition","src":"9728:219:120","nodes":[],"body":{"id":57982,"nodeType":"Block","src":"9791:156:120","nodes":[],"statements":[{"expression":{"arguments":[{"commonType":{"typeIdentifier":"t_address","typeString":"address"},"id":57976,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftExpression":{"id":57971,"name":"_superchainConfigProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57411,"src":"9809:22:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"BinaryOperation","operator":"!=","rightExpression":{"arguments":[{"hexValue":"30","id":57974,"isConstant":false,"isLValue":false,"isPure":true,"kind":"number","lValueRequested":false,"nodeType":"Literal","src":"9843:1:120","typeDescriptions":{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"},"value":"0"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"}],"id":57973,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"nodeType":"ElementaryTypeNameExpression","src":"9835:7:120","typeDescriptions":{"typeIdentifier":"t_type$_t_address_$","typeString":"type(address)"},"typeName":{"id":57972,"name":"address","nodeType":"ElementaryTypeName","src":"9835:7:120","typeDescriptions":{}}},"id":57975,"isConstant":false,"isLValue":false,"isPure":true,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"9835:10:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"src":"9809:36:120","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},{"hexValue":"4665746368436861696e496e666f4f75747075743a207375706572636861696e436f6e66696750726f7879206e6f7420736574","id":57977,"isConstant":false,"isLValue":false,"isPure":true,"kind":"string","lValueRequested":false,"nodeType":"Literal","src":"9847:53:120","typeDescriptions":{"typeIdentifier":"t_stringliteral_1b8ad3d2e627aa065fd0fee387bc2d1e5e640177323f7f86733cd157b788a1ce","typeString":"literal_string \"FetchChainInfoOutput: superchainConfigProxy not set\""},"value":"FetchChainInfoOutput: superchainConfigProxy not set"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_bool","typeString":"bool"},{"typeIdentifier":"t_stringliteral_1b8ad3d2e627aa065fd0fee387bc2d1e5e640177323f7f86733cd157b788a1ce","typeString":"literal_string \"FetchChainInfoOutput: superchainConfigProxy not set\""}],"id":57970,"name":"require","nodeType":"Identifier","overloadedDeclarations":[-18,-18],"referencedDeclaration":-18,"src":"9801:7:120","typeDescriptions":{"typeIdentifier":"t_function_require_pure$_t_bool_$_t_string_memory_ptr_$returns$__$","typeString":"function (bool,string memory) pure"}},"id":57978,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"9801:100:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":57979,"nodeType":"ExpressionStatement","src":"9801:100:120"},{"expression":{"id":57980,"name":"_superchainConfigProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57411,"src":"9918:22:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"functionReturnParameters":57969,"id":57981,"nodeType":"Return","src":"9911:29:120"}]},"functionSelector":"84cf2c97","implemented":true,"kind":"function","modifiers":[],"name":"superchainConfigProxy","nameLocation":"9737:21:120","parameters":{"id":57966,"nodeType":"ParameterList","parameters":[],"src":"9758:2:120"},"returnParameters":{"id":57969,"nodeType":"ParameterList","parameters":[{"constant":false,"id":57968,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":57983,"src":"9782:7:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":57967,"name":"address","nodeType":"ElementaryTypeName","src":"9782:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"9781:9:120"},"scope":58249,"stateMutability":"view","virtual":false,"visibility":"public"},{"id":58001,"nodeType":"FunctionDefinition","src":"9953:231:120","nodes":[],"body":{"id":58000,"nodeType":"Block","src":"10019:165:120","nodes":[],"statements":[{"expression":{"arguments":[{"commonType":{"typeIdentifier":"t_address","typeString":"address"},"id":57994,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftExpression":{"id":57989,"name":"_anchorStateRegistryProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57437,"src":"10037:25:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"BinaryOperation","operator":"!=","rightExpression":{"arguments":[{"hexValue":"30","id":57992,"isConstant":false,"isLValue":false,"isPure":true,"kind":"number","lValueRequested":false,"nodeType":"Literal","src":"10074:1:120","typeDescriptions":{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"},"value":"0"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"}],"id":57991,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"nodeType":"ElementaryTypeNameExpression","src":"10066:7:120","typeDescriptions":{"typeIdentifier":"t_type$_t_address_$","typeString":"type(address)"},"typeName":{"id":57990,"name":"address","nodeType":"ElementaryTypeName","src":"10066:7:120","typeDescriptions":{}}},"id":57993,"isConstant":false,"isLValue":false,"isPure":true,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"10066:10:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"src":"10037:39:120","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},{"hexValue":"4665746368436861696e496e666f4f75747075743a20616e63686f725374617465526567697374727950726f7879206e6f7420736574","id":57995,"isConstant":false,"isLValue":false,"isPure":true,"kind":"string","lValueRequested":false,"nodeType":"Literal","src":"10078:56:120","typeDescriptions":{"typeIdentifier":"t_stringliteral_6391076785d7152b9570ce8338ca2e43a749144cb3dbb7f9e5e1de5fabfbae48","typeString":"literal_string \"FetchChainInfoOutput: anchorStateRegistryProxy not set\""},"value":"FetchChainInfoOutput: anchorStateRegistryProxy not set"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_bool","typeString":"bool"},{"typeIdentifier":"t_stringliteral_6391076785d7152b9570ce8338ca2e43a749144cb3dbb7f9e5e1de5fabfbae48","typeString":"literal_string \"FetchChainInfoOutput: anchorStateRegistryProxy not set\""}],"id":57988,"name":"require","nodeType":"Identifier","overloadedDeclarations":[-18,-18],"referencedDeclaration":-18,"src":"10029:7:120","typeDescriptions":{"typeIdentifier":"t_function_require_pure$_t_bool_$_t_string_memory_ptr_$returns$__$","typeString":"function (bool,string memory) pure"}},"id":57996,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"10029:106:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":57997,"nodeType":"ExpressionStatement","src":"10029:106:120"},{"expression":{"id":57998,"name":"_anchorStateRegistryProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57437,"src":"10152:25:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"functionReturnParameters":57987,"id":57999,"nodeType":"Return","src":"10145:32:120"}]},"functionSelector":"35596f76","implemented":true,"kind":"function","modifiers":[],"name":"anchorStateRegistryProxy","nameLocation":"9962:24:120","parameters":{"id":57984,"nodeType":"ParameterList","parameters":[],"src":"9986:2:120"},"returnParameters":{"id":57987,"nodeType":"ParameterList","parameters":[{"constant":false,"id":57986,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":58001,"src":"10010:7:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":57985,"name":"address","nodeType":"ElementaryTypeName","src":"10010:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"10009:9:120"},"scope":58249,"stateMutability":"view","virtual":false,"visibility":"public"},{"id":58009,"nodeType":"FunctionDefinition","src":"10190:131:120","nodes":[],"body":{"id":58008,"nodeType":"Block","src":"10264:57:120","nodes":[],"statements":[{"expression":{"id":58006,"name":"_delayedWethPermissionedGameProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57439,"src":"10281:33:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"functionReturnParameters":58005,"id":58007,"nodeType":"Return","src":"10274:40:120"}]},"functionSelector":"794836d7","implemented":true,"kind":"function","modifiers":[],"name":"delayedWethPermissionedGameProxy","nameLocation":"10199:32:120","parameters":{"id":58002,"nodeType":"ParameterList","parameters":[],"src":"10231:2:120"},"returnParameters":{"id":58005,"nodeType":"ParameterList","parameters":[{"constant":false,"id":58004,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":58009,"src":"10255:7:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":58003,"name":"address","nodeType":"ElementaryTypeName","src":"10255:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"10254:9:120"},"scope":58249,"stateMutability":"view","virtual":false,"visibility":"public"},{"id":58017,"nodeType":"FunctionDefinition","src":"10327:135:120","nodes":[],"body":{"id":58016,"nodeType":"Block","src":"10403:59:120","nodes":[],"statements":[{"expression":{"id":58014,"name":"_delayedWethPermissionlessGameProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57441,"src":"10420:35:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"functionReturnParameters":58013,"id":58015,"nodeType":"Return","src":"10413:42:120"}]},"functionSelector":"97068797","implemented":true,"kind":"function","modifiers":[],"name":"delayedWethPermissionlessGameProxy","nameLocation":"10336:34:120","parameters":{"id":58010,"nodeType":"ParameterList","parameters":[],"src":"10370:2:120"},"returnParameters":{"id":58013,"nodeType":"ParameterList","parameters":[{"constant":false,"id":58012,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":58017,"src":"10394:7:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":58011,"name":"address","nodeType":"ElementaryTypeName","src":"10394:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"10393:9:120"},"scope":58249,"stateMutability":"view","virtual":false,"visibility":"public"},{"id":58025,"nodeType":"FunctionDefinition","src":"10468:113:120","nodes":[],"body":{"id":58024,"nodeType":"Block","src":"10533:48:120","nodes":[],"statements":[{"expression":{"id":58022,"name":"_disputeGameFactoryProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57443,"src":"10550:24:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"functionReturnParameters":58021,"id":58023,"nodeType":"Return","src":"10543:31:120"}]},"functionSelector":"6c4568d1","implemented":true,"kind":"function","modifiers":[],"name":"disputeGameFactoryProxy","nameLocation":"10477:23:120","parameters":{"id":58018,"nodeType":"ParameterList","parameters":[],"src":"10500:2:120"},"returnParameters":{"id":58021,"nodeType":"ParameterList","parameters":[{"constant":false,"id":58020,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":58025,"src":"10524:7:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":58019,"name":"address","nodeType":"ElementaryTypeName","src":"10524:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"10523:9:120"},"scope":58249,"stateMutability":"view","virtual":false,"visibility":"public"},{"id":58043,"nodeType":"FunctionDefinition","src":"10587:215:120","nodes":[],"body":{"id":58042,"nodeType":"Block","src":"10649:153:120","nodes":[],"statements":[{"expression":{"arguments":[{"commonType":{"typeIdentifier":"t_address","typeString":"address"},"id":58036,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftExpression":{"id":58031,"name":"_faultDisputeGameImpl","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57445,"src":"10667:21:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"BinaryOperation","operator":"!=","rightExpression":{"arguments":[{"hexValue":"30","id":58034,"isConstant":false,"isLValue":false,"isPure":true,"kind":"number","lValueRequested":false,"nodeType":"Literal","src":"10700:1:120","typeDescriptions":{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"},"value":"0"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"}],"id":58033,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"nodeType":"ElementaryTypeNameExpression","src":"10692:7:120","typeDescriptions":{"typeIdentifier":"t_type$_t_address_$","typeString":"type(address)"},"typeName":{"id":58032,"name":"address","nodeType":"ElementaryTypeName","src":"10692:7:120","typeDescriptions":{}}},"id":58035,"isConstant":false,"isLValue":false,"isPure":true,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"10692:10:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"src":"10667:35:120","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},{"hexValue":"4665746368436861696e496e666f4f75747075743a206661756c744469737075746547616d65496d706c206e6f7420736574","id":58037,"isConstant":false,"isLValue":false,"isPure":true,"kind":"string","lValueRequested":false,"nodeType":"Literal","src":"10704:52:120","typeDescriptions":{"typeIdentifier":"t_stringliteral_baae18cd0fbc1fbf3c566f5918a7a4a780bb1a3d403d2b65d908417b87c06457","typeString":"literal_string \"FetchChainInfoOutput: faultDisputeGameImpl not set\""},"value":"FetchChainInfoOutput: faultDisputeGameImpl not set"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_bool","typeString":"bool"},{"typeIdentifier":"t_stringliteral_baae18cd0fbc1fbf3c566f5918a7a4a780bb1a3d403d2b65d908417b87c06457","typeString":"literal_string \"FetchChainInfoOutput: faultDisputeGameImpl not set\""}],"id":58030,"name":"require","nodeType":"Identifier","overloadedDeclarations":[-18,-18],"referencedDeclaration":-18,"src":"10659:7:120","typeDescriptions":{"typeIdentifier":"t_function_require_pure$_t_bool_$_t_string_memory_ptr_$returns$__$","typeString":"function (bool,string memory) pure"}},"id":58038,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"10659:98:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":58039,"nodeType":"ExpressionStatement","src":"10659:98:120"},{"expression":{"id":58040,"name":"_faultDisputeGameImpl","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57445,"src":"10774:21:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"functionReturnParameters":58029,"id":58041,"nodeType":"Return","src":"10767:28:120"}]},"functionSelector":"dea21984","implemented":true,"kind":"function","modifiers":[],"name":"faultDisputeGameImpl","nameLocation":"10596:20:120","parameters":{"id":58026,"nodeType":"ParameterList","parameters":[],"src":"10616:2:120"},"returnParameters":{"id":58029,"nodeType":"ParameterList","parameters":[{"constant":false,"id":58028,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":58043,"src":"10640:7:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":58027,"name":"address","nodeType":"ElementaryTypeName","src":"10640:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"10639:9:120"},"scope":58249,"stateMutability":"view","virtual":false,"visibility":"public"},{"id":58061,"nodeType":"FunctionDefinition","src":"10808:167:120","nodes":[],"body":{"id":58060,"nodeType":"Block","src":"10858:117:120","nodes":[],"statements":[{"expression":{"arguments":[{"commonType":{"typeIdentifier":"t_address","typeString":"address"},"id":58054,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftExpression":{"id":58049,"name":"_mipsImpl","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57413,"src":"10876:9:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"BinaryOperation","operator":"!=","rightExpression":{"arguments":[{"hexValue":"30","id":58052,"isConstant":false,"isLValue":false,"isPure":true,"kind":"number","lValueRequested":false,"nodeType":"Literal","src":"10897:1:120","typeDescriptions":{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"},"value":"0"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"}],"id":58051,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"nodeType":"ElementaryTypeNameExpression","src":"10889:7:120","typeDescriptions":{"typeIdentifier":"t_type$_t_address_$","typeString":"type(address)"},"typeName":{"id":58050,"name":"address","nodeType":"ElementaryTypeName","src":"10889:7:120","typeDescriptions":{}}},"id":58053,"isConstant":false,"isLValue":false,"isPure":true,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"10889:10:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"src":"10876:23:120","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},{"hexValue":"4665746368436861696e496e666f4f75747075743a206d697073496d706c206e6f7420736574","id":58055,"isConstant":false,"isLValue":false,"isPure":true,"kind":"string","lValueRequested":false,"nodeType":"Literal","src":"10901:40:120","typeDescriptions":{"typeIdentifier":"t_stringliteral_178867f585ae7eaee2b47a35fdf118ac2b037c387c5937f3b39b1c51f05d7497","typeString":"literal_string \"FetchChainInfoOutput: mipsImpl not set\""},"value":"FetchChainInfoOutput: mipsImpl not set"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_bool","typeString":"bool"},{"typeIdentifier":"t_stringliteral_178867f585ae7eaee2b47a35fdf118ac2b037c387c5937f3b39b1c51f05d7497","typeString":"literal_string \"FetchChainInfoOutput: mipsImpl not set\""}],"id":58048,"name":"require","nodeType":"Identifier","overloadedDeclarations":[-18,-18],"referencedDeclaration":-18,"src":"10868:7:120","typeDescriptions":{"typeIdentifier":"t_function_require_pure$_t_bool_$_t_string_memory_ptr_$returns$__$","typeString":"function (bool,string memory) pure"}},"id":58056,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"10868:74:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":58057,"nodeType":"ExpressionStatement","src":"10868:74:120"},{"expression":{"id":58058,"name":"_mipsImpl","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57413,"src":"10959:9:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"functionReturnParameters":58047,"id":58059,"nodeType":"Return","src":"10952:16:120"}]},"functionSelector":"e303272c","implemented":true,"kind":"function","modifiers":[],"name":"mipsImpl","nameLocation":"10817:8:120","parameters":{"id":58044,"nodeType":"ParameterList","parameters":[],"src":"10825:2:120"},"returnParameters":{"id":58047,"nodeType":"ParameterList","parameters":[{"constant":false,"id":58046,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":58061,"src":"10849:7:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":58045,"name":"address","nodeType":"ElementaryTypeName","src":"10849:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"10848:9:120"},"scope":58249,"stateMutability":"view","virtual":false,"visibility":"public"},{"id":58079,"nodeType":"FunctionDefinition","src":"10981:243:120","nodes":[],"body":{"id":58078,"nodeType":"Block","src":"11050:174:120","nodes":[],"statements":[{"expression":{"arguments":[{"commonType":{"typeIdentifier":"t_address","typeString":"address"},"id":58072,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftExpression":{"id":58067,"name":"_permissionedDisputeGameImpl","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57447,"src":"11068:28:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"BinaryOperation","operator":"!=","rightExpression":{"arguments":[{"hexValue":"30","id":58070,"isConstant":false,"isLValue":false,"isPure":true,"kind":"number","lValueRequested":false,"nodeType":"Literal","src":"11108:1:120","typeDescriptions":{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"},"value":"0"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"}],"id":58069,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"nodeType":"ElementaryTypeNameExpression","src":"11100:7:120","typeDescriptions":{"typeIdentifier":"t_type$_t_address_$","typeString":"type(address)"},"typeName":{"id":58068,"name":"address","nodeType":"ElementaryTypeName","src":"11100:7:120","typeDescriptions":{}}},"id":58071,"isConstant":false,"isLValue":false,"isPure":true,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"11100:10:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"src":"11068:42:120","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},{"hexValue":"4665746368436861696e496e666f4f75747075743a207065726d697373696f6e65644469737075746547616d65496d706c206e6f7420736574","id":58073,"isConstant":false,"isLValue":false,"isPure":true,"kind":"string","lValueRequested":false,"nodeType":"Literal","src":"11112:59:120","typeDescriptions":{"typeIdentifier":"t_stringliteral_234858b97aab3865b03b564f238f9977c62296b1532cb4f809e12678629cae92","typeString":"literal_string \"FetchChainInfoOutput: permissionedDisputeGameImpl not set\""},"value":"FetchChainInfoOutput: permissionedDisputeGameImpl not set"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_bool","typeString":"bool"},{"typeIdentifier":"t_stringliteral_234858b97aab3865b03b564f238f9977c62296b1532cb4f809e12678629cae92","typeString":"literal_string \"FetchChainInfoOutput: permissionedDisputeGameImpl not set\""}],"id":58066,"name":"require","nodeType":"Identifier","overloadedDeclarations":[-18,-18],"referencedDeclaration":-18,"src":"11060:7:120","typeDescriptions":{"typeIdentifier":"t_function_require_pure$_t_bool_$_t_string_memory_ptr_$returns$__$","typeString":"function (bool,string memory) pure"}},"id":58074,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"11060:112:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":58075,"nodeType":"ExpressionStatement","src":"11060:112:120"},{"expression":{"id":58076,"name":"_permissionedDisputeGameImpl","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57447,"src":"11189:28:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"functionReturnParameters":58065,"id":58077,"nodeType":"Return","src":"11182:35:120"}]},"functionSelector":"98ccec3e","implemented":true,"kind":"function","modifiers":[],"name":"permissionedDisputeGameImpl","nameLocation":"10990:27:120","parameters":{"id":58062,"nodeType":"ParameterList","parameters":[],"src":"11017:2:120"},"returnParameters":{"id":58065,"nodeType":"ParameterList","parameters":[{"constant":false,"id":58064,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":58079,"src":"11041:7:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":58063,"name":"address","nodeType":"ElementaryTypeName","src":"11041:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"11040:9:120"},"scope":58249,"stateMutability":"view","virtual":false,"visibility":"public"},{"id":58097,"nodeType":"FunctionDefinition","src":"11230:207:120","nodes":[],"body":{"id":58096,"nodeType":"Block","src":"11290:147:120","nodes":[],"statements":[{"expression":{"arguments":[{"commonType":{"typeIdentifier":"t_address","typeString":"address"},"id":58090,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftExpression":{"id":58085,"name":"_preimageOracleImpl","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57415,"src":"11308:19:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"BinaryOperation","operator":"!=","rightExpression":{"arguments":[{"hexValue":"30","id":58088,"isConstant":false,"isLValue":false,"isPure":true,"kind":"number","lValueRequested":false,"nodeType":"Literal","src":"11339:1:120","typeDescriptions":{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"},"value":"0"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"}],"id":58087,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"nodeType":"ElementaryTypeNameExpression","src":"11331:7:120","typeDescriptions":{"typeIdentifier":"t_type$_t_address_$","typeString":"type(address)"},"typeName":{"id":58086,"name":"address","nodeType":"ElementaryTypeName","src":"11331:7:120","typeDescriptions":{}}},"id":58089,"isConstant":false,"isLValue":false,"isPure":true,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"11331:10:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"src":"11308:33:120","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},{"hexValue":"4665746368436861696e496e666f4f75747075743a20707265696d6167654f7261636c65496d706c206e6f7420736574","id":58091,"isConstant":false,"isLValue":false,"isPure":true,"kind":"string","lValueRequested":false,"nodeType":"Literal","src":"11343:50:120","typeDescriptions":{"typeIdentifier":"t_stringliteral_2434e23032e7627ba1a13e989a9fbe735952d0d6f49e2760e1b1064b8728d538","typeString":"literal_string \"FetchChainInfoOutput: preimageOracleImpl not set\""},"value":"FetchChainInfoOutput: preimageOracleImpl not set"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_bool","typeString":"bool"},{"typeIdentifier":"t_stringliteral_2434e23032e7627ba1a13e989a9fbe735952d0d6f49e2760e1b1064b8728d538","typeString":"literal_string \"FetchChainInfoOutput: preimageOracleImpl not set\""}],"id":58084,"name":"require","nodeType":"Identifier","overloadedDeclarations":[-18,-18],"referencedDeclaration":-18,"src":"11300:7:120","typeDescriptions":{"typeIdentifier":"t_function_require_pure$_t_bool_$_t_string_memory_ptr_$returns$__$","typeString":"function (bool,string memory) pure"}},"id":58092,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"11300:94:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":58093,"nodeType":"ExpressionStatement","src":"11300:94:120"},{"expression":{"id":58094,"name":"_preimageOracleImpl","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57415,"src":"11411:19:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"functionReturnParameters":58083,"id":58095,"nodeType":"Return","src":"11404:26:120"}]},"functionSelector":"d030d2e8","implemented":true,"kind":"function","modifiers":[],"name":"preimageOracleImpl","nameLocation":"11239:18:120","parameters":{"id":58080,"nodeType":"ParameterList","parameters":[],"src":"11257:2:120"},"returnParameters":{"id":58083,"nodeType":"ParameterList","parameters":[{"constant":false,"id":58082,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":58097,"src":"11281:7:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":58081,"name":"address","nodeType":"ElementaryTypeName","src":"11281:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"11280:9:120"},"scope":58249,"stateMutability":"view","virtual":false,"visibility":"public"},{"id":58115,"nodeType":"FunctionDefinition","src":"11443:203:120","nodes":[],"body":{"id":58114,"nodeType":"Block","src":"11502:144:120","nodes":[],"statements":[{"expression":{"arguments":[{"commonType":{"typeIdentifier":"t_address","typeString":"address"},"id":58108,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftExpression":{"id":58103,"name":"_systemConfigOwner","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57449,"src":"11520:18:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"BinaryOperation","operator":"!=","rightExpression":{"arguments":[{"hexValue":"30","id":58106,"isConstant":false,"isLValue":false,"isPure":true,"kind":"number","lValueRequested":false,"nodeType":"Literal","src":"11550:1:120","typeDescriptions":{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"},"value":"0"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"}],"id":58105,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"nodeType":"ElementaryTypeNameExpression","src":"11542:7:120","typeDescriptions":{"typeIdentifier":"t_type$_t_address_$","typeString":"type(address)"},"typeName":{"id":58104,"name":"address","nodeType":"ElementaryTypeName","src":"11542:7:120","typeDescriptions":{}}},"id":58107,"isConstant":false,"isLValue":false,"isPure":true,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"11542:10:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"src":"11520:32:120","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},{"hexValue":"4665746368436861696e496e666f4f75747075743a2073797374656d436f6e6669674f776e6572206e6f7420736574","id":58109,"isConstant":false,"isLValue":false,"isPure":true,"kind":"string","lValueRequested":false,"nodeType":"Literal","src":"11554:49:120","typeDescriptions":{"typeIdentifier":"t_stringliteral_fc7a67f4775c5e19ca3731b64db9f9f8895dcd37a01bc895f1d1806a7f21c916","typeString":"literal_string \"FetchChainInfoOutput: systemConfigOwner not set\""},"value":"FetchChainInfoOutput: systemConfigOwner not set"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_bool","typeString":"bool"},{"typeIdentifier":"t_stringliteral_fc7a67f4775c5e19ca3731b64db9f9f8895dcd37a01bc895f1d1806a7f21c916","typeString":"literal_string \"FetchChainInfoOutput: systemConfigOwner not set\""}],"id":58102,"name":"require","nodeType":"Identifier","overloadedDeclarations":[-18,-18],"referencedDeclaration":-18,"src":"11512:7:120","typeDescriptions":{"typeIdentifier":"t_function_require_pure$_t_bool_$_t_string_memory_ptr_$returns$__$","typeString":"function (bool,string memory) pure"}},"id":58110,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"11512:92:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":58111,"nodeType":"ExpressionStatement","src":"11512:92:120"},{"expression":{"id":58112,"name":"_systemConfigOwner","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57449,"src":"11621:18:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"functionReturnParameters":58101,"id":58113,"nodeType":"Return","src":"11614:25:120"}]},"functionSelector":"1e229b20","implemented":true,"kind":"function","modifiers":[],"name":"systemConfigOwner","nameLocation":"11452:17:120","parameters":{"id":58098,"nodeType":"ParameterList","parameters":[],"src":"11469:2:120"},"returnParameters":{"id":58101,"nodeType":"ParameterList","parameters":[{"constant":false,"id":58100,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":58115,"src":"11493:7:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":58099,"name":"address","nodeType":"ElementaryTypeName","src":"11493:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"11492:9:120"},"scope":58249,"stateMutability":"view","virtual":false,"visibility":"public"},{"id":58133,"nodeType":"FunctionDefinition","src":"11652:223:120","nodes":[],"body":{"id":58132,"nodeType":"Block","src":"11716:159:120","nodes":[],"statements":[{"expression":{"arguments":[{"commonType":{"typeIdentifier":"t_address","typeString":"address"},"id":58126,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftExpression":{"id":58121,"name":"_opChainProxyAdminOwner","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57451,"src":"11734:23:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"BinaryOperation","operator":"!=","rightExpression":{"arguments":[{"hexValue":"30","id":58124,"isConstant":false,"isLValue":false,"isPure":true,"kind":"number","lValueRequested":false,"nodeType":"Literal","src":"11769:1:120","typeDescriptions":{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"},"value":"0"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"}],"id":58123,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"nodeType":"ElementaryTypeNameExpression","src":"11761:7:120","typeDescriptions":{"typeIdentifier":"t_type$_t_address_$","typeString":"type(address)"},"typeName":{"id":58122,"name":"address","nodeType":"ElementaryTypeName","src":"11761:7:120","typeDescriptions":{}}},"id":58125,"isConstant":false,"isLValue":false,"isPure":true,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"11761:10:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"src":"11734:37:120","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},{"hexValue":"4665746368436861696e496e666f4f75747075743a206f70436861696e50726f787941646d696e4f776e6572206e6f7420736574","id":58127,"isConstant":false,"isLValue":false,"isPure":true,"kind":"string","lValueRequested":false,"nodeType":"Literal","src":"11773:54:120","typeDescriptions":{"typeIdentifier":"t_stringliteral_cc12cbf05d2d853ebebe6e25c8b02d2f78d6af131087a61088362ca7d0befc81","typeString":"literal_string \"FetchChainInfoOutput: opChainProxyAdminOwner not set\""},"value":"FetchChainInfoOutput: opChainProxyAdminOwner not set"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_bool","typeString":"bool"},{"typeIdentifier":"t_stringliteral_cc12cbf05d2d853ebebe6e25c8b02d2f78d6af131087a61088362ca7d0befc81","typeString":"literal_string \"FetchChainInfoOutput: opChainProxyAdminOwner not set\""}],"id":58120,"name":"require","nodeType":"Identifier","overloadedDeclarations":[-18,-18],"referencedDeclaration":-18,"src":"11726:7:120","typeDescriptions":{"typeIdentifier":"t_function_require_pure$_t_bool_$_t_string_memory_ptr_$returns$__$","typeString":"function (bool,string memory) pure"}},"id":58128,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"11726:102:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":58129,"nodeType":"ExpressionStatement","src":"11726:102:120"},{"expression":{"id":58130,"name":"_opChainProxyAdminOwner","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57451,"src":"11845:23:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"functionReturnParameters":58119,"id":58131,"nodeType":"Return","src":"11838:30:120"}]},"functionSelector":"1480f0cc","implemented":true,"kind":"function","modifiers":[],"name":"opChainProxyAdminOwner","nameLocation":"11661:22:120","parameters":{"id":58116,"nodeType":"ParameterList","parameters":[],"src":"11683:2:120"},"returnParameters":{"id":58119,"nodeType":"ParameterList","parameters":[{"constant":false,"id":58118,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":58133,"src":"11707:7:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":58117,"name":"address","nodeType":"ElementaryTypeName","src":"11707:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"11706:9:120"},"scope":58249,"stateMutability":"view","virtual":false,"visibility":"public"},{"id":58151,"nodeType":"FunctionDefinition","src":"11881:195:120","nodes":[],"body":{"id":58150,"nodeType":"Block","src":"11938:138:120","nodes":[],"statements":[{"expression":{"arguments":[{"commonType":{"typeIdentifier":"t_address","typeString":"address"},"id":58144,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftExpression":{"id":58139,"name":"_opChainGuardian","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57453,"src":"11956:16:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"BinaryOperation","operator":"!=","rightExpression":{"arguments":[{"hexValue":"30","id":58142,"isConstant":false,"isLValue":false,"isPure":true,"kind":"number","lValueRequested":false,"nodeType":"Literal","src":"11984:1:120","typeDescriptions":{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"},"value":"0"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"}],"id":58141,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"nodeType":"ElementaryTypeNameExpression","src":"11976:7:120","typeDescriptions":{"typeIdentifier":"t_type$_t_address_$","typeString":"type(address)"},"typeName":{"id":58140,"name":"address","nodeType":"ElementaryTypeName","src":"11976:7:120","typeDescriptions":{}}},"id":58143,"isConstant":false,"isLValue":false,"isPure":true,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"11976:10:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"src":"11956:30:120","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},{"hexValue":"4665746368436861696e496e666f4f75747075743a206f70436861696e477561726469616e206e6f7420736574","id":58145,"isConstant":false,"isLValue":false,"isPure":true,"kind":"string","lValueRequested":false,"nodeType":"Literal","src":"11988:47:120","typeDescriptions":{"typeIdentifier":"t_stringliteral_ab71487628da5c56ff40f228ee915a62d6c0a28ab899f48f84343df6dbc48bb7","typeString":"literal_string \"FetchChainInfoOutput: opChainGuardian not set\""},"value":"FetchChainInfoOutput: opChainGuardian not set"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_bool","typeString":"bool"},{"typeIdentifier":"t_stringliteral_ab71487628da5c56ff40f228ee915a62d6c0a28ab899f48f84343df6dbc48bb7","typeString":"literal_string \"FetchChainInfoOutput: opChainGuardian not set\""}],"id":58138,"name":"require","nodeType":"Identifier","overloadedDeclarations":[-18,-18],"referencedDeclaration":-18,"src":"11948:7:120","typeDescriptions":{"typeIdentifier":"t_function_require_pure$_t_bool_$_t_string_memory_ptr_$returns$__$","typeString":"function (bool,string memory) pure"}},"id":58146,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"11948:88:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":58147,"nodeType":"ExpressionStatement","src":"11948:88:120"},{"expression":{"id":58148,"name":"_opChainGuardian","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57453,"src":"12053:16:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"functionReturnParameters":58137,"id":58149,"nodeType":"Return","src":"12046:23:120"}]},"functionSelector":"4bc2695f","implemented":true,"kind":"function","modifiers":[],"name":"opChainGuardian","nameLocation":"11890:15:120","parameters":{"id":58134,"nodeType":"ParameterList","parameters":[],"src":"11905:2:120"},"returnParameters":{"id":58137,"nodeType":"ParameterList","parameters":[{"constant":false,"id":58136,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":58151,"src":"11929:7:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":58135,"name":"address","nodeType":"ElementaryTypeName","src":"11929:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"11928:9:120"},"scope":58249,"stateMutability":"view","virtual":false,"visibility":"public"},{"id":58169,"nodeType":"FunctionDefinition","src":"12082:175:120","nodes":[],"body":{"id":58168,"nodeType":"Block","src":"12134:123:120","nodes":[],"statements":[{"expression":{"arguments":[{"commonType":{"typeIdentifier":"t_address","typeString":"address"},"id":58162,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftExpression":{"id":58157,"name":"_challenger","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57455,"src":"12152:11:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"BinaryOperation","operator":"!=","rightExpression":{"arguments":[{"hexValue":"30","id":58160,"isConstant":false,"isLValue":false,"isPure":true,"kind":"number","lValueRequested":false,"nodeType":"Literal","src":"12175:1:120","typeDescriptions":{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"},"value":"0"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"}],"id":58159,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"nodeType":"ElementaryTypeNameExpression","src":"12167:7:120","typeDescriptions":{"typeIdentifier":"t_type$_t_address_$","typeString":"type(address)"},"typeName":{"id":58158,"name":"address","nodeType":"ElementaryTypeName","src":"12167:7:120","typeDescriptions":{}}},"id":58161,"isConstant":false,"isLValue":false,"isPure":true,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"12167:10:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"src":"12152:25:120","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},{"hexValue":"4665746368436861696e496e666f4f75747075743a206368616c6c656e676572206e6f7420736574","id":58163,"isConstant":false,"isLValue":false,"isPure":true,"kind":"string","lValueRequested":false,"nodeType":"Literal","src":"12179:42:120","typeDescriptions":{"typeIdentifier":"t_stringliteral_d1dd717c39956ee86b1eb77b9f3cb6dbeca6df99b330f67dd364a35a1174c2ce","typeString":"literal_string \"FetchChainInfoOutput: challenger not set\""},"value":"FetchChainInfoOutput: challenger not set"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_bool","typeString":"bool"},{"typeIdentifier":"t_stringliteral_d1dd717c39956ee86b1eb77b9f3cb6dbeca6df99b330f67dd364a35a1174c2ce","typeString":"literal_string \"FetchChainInfoOutput: challenger not set\""}],"id":58156,"name":"require","nodeType":"Identifier","overloadedDeclarations":[-18,-18],"referencedDeclaration":-18,"src":"12144:7:120","typeDescriptions":{"typeIdentifier":"t_function_require_pure$_t_bool_$_t_string_memory_ptr_$returns$__$","typeString":"function (bool,string memory) pure"}},"id":58164,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"12144:78:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":58165,"nodeType":"ExpressionStatement","src":"12144:78:120"},{"expression":{"id":58166,"name":"_challenger","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57455,"src":"12239:11:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"functionReturnParameters":58155,"id":58167,"nodeType":"Return","src":"12232:18:120"}]},"functionSelector":"534db0e2","implemented":true,"kind":"function","modifiers":[],"name":"challenger","nameLocation":"12091:10:120","parameters":{"id":58152,"nodeType":"ParameterList","parameters":[],"src":"12101:2:120"},"returnParameters":{"id":58155,"nodeType":"ParameterList","parameters":[{"constant":false,"id":58154,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":58169,"src":"12125:7:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":58153,"name":"address","nodeType":"ElementaryTypeName","src":"12125:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"12124:9:120"},"scope":58249,"stateMutability":"view","virtual":false,"visibility":"public"},{"id":58187,"nodeType":"FunctionDefinition","src":"12263:167:120","nodes":[],"body":{"id":58186,"nodeType":"Block","src":"12313:117:120","nodes":[],"statements":[{"expression":{"arguments":[{"commonType":{"typeIdentifier":"t_address","typeString":"address"},"id":58180,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftExpression":{"id":58175,"name":"_proposer","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57457,"src":"12331:9:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"BinaryOperation","operator":"!=","rightExpression":{"arguments":[{"hexValue":"30","id":58178,"isConstant":false,"isLValue":false,"isPure":true,"kind":"number","lValueRequested":false,"nodeType":"Literal","src":"12352:1:120","typeDescriptions":{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"},"value":"0"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"}],"id":58177,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"nodeType":"ElementaryTypeNameExpression","src":"12344:7:120","typeDescriptions":{"typeIdentifier":"t_type$_t_address_$","typeString":"type(address)"},"typeName":{"id":58176,"name":"address","nodeType":"ElementaryTypeName","src":"12344:7:120","typeDescriptions":{}}},"id":58179,"isConstant":false,"isLValue":false,"isPure":true,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"12344:10:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"src":"12331:23:120","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},{"hexValue":"4665746368436861696e496e666f4f75747075743a2070726f706f736572206e6f7420736574","id":58181,"isConstant":false,"isLValue":false,"isPure":true,"kind":"string","lValueRequested":false,"nodeType":"Literal","src":"12356:40:120","typeDescriptions":{"typeIdentifier":"t_stringliteral_c4910753f64240b424591ec2bc873e5a728ff321d57cb1a353788ad2c385da71","typeString":"literal_string \"FetchChainInfoOutput: proposer not set\""},"value":"FetchChainInfoOutput: proposer not set"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_bool","typeString":"bool"},{"typeIdentifier":"t_stringliteral_c4910753f64240b424591ec2bc873e5a728ff321d57cb1a353788ad2c385da71","typeString":"literal_string \"FetchChainInfoOutput: proposer not set\""}],"id":58174,"name":"require","nodeType":"Identifier","overloadedDeclarations":[-18,-18],"referencedDeclaration":-18,"src":"12323:7:120","typeDescriptions":{"typeIdentifier":"t_function_require_pure$_t_bool_$_t_string_memory_ptr_$returns$__$","typeString":"function (bool,string memory) pure"}},"id":58182,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"12323:74:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":58183,"nodeType":"ExpressionStatement","src":"12323:74:120"},{"expression":{"id":58184,"name":"_proposer","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57457,"src":"12414:9:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"functionReturnParameters":58173,"id":58185,"nodeType":"Return","src":"12407:16:120"}]},"functionSelector":"a8e4fb90","implemented":true,"kind":"function","modifiers":[],"name":"proposer","nameLocation":"12272:8:120","parameters":{"id":58170,"nodeType":"ParameterList","parameters":[],"src":"12280:2:120"},"returnParameters":{"id":58173,"nodeType":"ParameterList","parameters":[{"constant":false,"id":58172,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":58187,"src":"12304:7:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":58171,"name":"address","nodeType":"ElementaryTypeName","src":"12304:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"12303:9:120"},"scope":58249,"stateMutability":"view","virtual":false,"visibility":"public"},{"id":58205,"nodeType":"FunctionDefinition","src":"12436:203:120","nodes":[],"body":{"id":58204,"nodeType":"Block","src":"12495:144:120","nodes":[],"statements":[{"expression":{"arguments":[{"commonType":{"typeIdentifier":"t_address","typeString":"address"},"id":58198,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftExpression":{"id":58193,"name":"_unsafeBlockSigner","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57459,"src":"12513:18:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"BinaryOperation","operator":"!=","rightExpression":{"arguments":[{"hexValue":"30","id":58196,"isConstant":false,"isLValue":false,"isPure":true,"kind":"number","lValueRequested":false,"nodeType":"Literal","src":"12543:1:120","typeDescriptions":{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"},"value":"0"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"}],"id":58195,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"nodeType":"ElementaryTypeNameExpression","src":"12535:7:120","typeDescriptions":{"typeIdentifier":"t_type$_t_address_$","typeString":"type(address)"},"typeName":{"id":58194,"name":"address","nodeType":"ElementaryTypeName","src":"12535:7:120","typeDescriptions":{}}},"id":58197,"isConstant":false,"isLValue":false,"isPure":true,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"12535:10:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"src":"12513:32:120","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},{"hexValue":"4665746368436861696e496e666f4f75747075743a20756e73616665426c6f636b5369676e6572206e6f7420736574","id":58199,"isConstant":false,"isLValue":false,"isPure":true,"kind":"string","lValueRequested":false,"nodeType":"Literal","src":"12547:49:120","typeDescriptions":{"typeIdentifier":"t_stringliteral_c0c85432d1596fb73656e29b64f6ea745166dde4a7fa6163bfe6b285aea851d7","typeString":"literal_string \"FetchChainInfoOutput: unsafeBlockSigner not set\""},"value":"FetchChainInfoOutput: unsafeBlockSigner not set"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_bool","typeString":"bool"},{"typeIdentifier":"t_stringliteral_c0c85432d1596fb73656e29b64f6ea745166dde4a7fa6163bfe6b285aea851d7","typeString":"literal_string \"FetchChainInfoOutput: unsafeBlockSigner not set\""}],"id":58192,"name":"require","nodeType":"Identifier","overloadedDeclarations":[-18,-18],"referencedDeclaration":-18,"src":"12505:7:120","typeDescriptions":{"typeIdentifier":"t_function_require_pure$_t_bool_$_t_string_memory_ptr_$returns$__$","typeString":"function (bool,string memory) pure"}},"id":58200,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"12505:92:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":58201,"nodeType":"ExpressionStatement","src":"12505:92:120"},{"expression":{"id":58202,"name":"_unsafeBlockSigner","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57459,"src":"12614:18:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"functionReturnParameters":58191,"id":58203,"nodeType":"Return","src":"12607:25:120"}]},"functionSelector":"1fd19ee1","implemented":true,"kind":"function","modifiers":[],"name":"unsafeBlockSigner","nameLocation":"12445:17:120","parameters":{"id":58188,"nodeType":"ParameterList","parameters":[],"src":"12462:2:120"},"returnParameters":{"id":58191,"nodeType":"ParameterList","parameters":[{"constant":false,"id":58190,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":58205,"src":"12486:7:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":58189,"name":"address","nodeType":"ElementaryTypeName","src":"12486:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"12485:9:120"},"scope":58249,"stateMutability":"view","virtual":false,"visibility":"public"},{"id":58223,"nodeType":"FunctionDefinition","src":"12645:191:120","nodes":[],"body":{"id":58222,"nodeType":"Block","src":"12701:135:120","nodes":[],"statements":[{"expression":{"arguments":[{"commonType":{"typeIdentifier":"t_address","typeString":"address"},"id":58216,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftExpression":{"id":58211,"name":"_batchSubmitter","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57461,"src":"12719:15:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"BinaryOperation","operator":"!=","rightExpression":{"arguments":[{"hexValue":"30","id":58214,"isConstant":false,"isLValue":false,"isPure":true,"kind":"number","lValueRequested":false,"nodeType":"Literal","src":"12746:1:120","typeDescriptions":{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"},"value":"0"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"}],"id":58213,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"nodeType":"ElementaryTypeNameExpression","src":"12738:7:120","typeDescriptions":{"typeIdentifier":"t_type$_t_address_$","typeString":"type(address)"},"typeName":{"id":58212,"name":"address","nodeType":"ElementaryTypeName","src":"12738:7:120","typeDescriptions":{}}},"id":58215,"isConstant":false,"isLValue":false,"isPure":true,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"12738:10:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"src":"12719:29:120","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},{"hexValue":"4665746368436861696e496e666f4f75747075743a2062617463685375626d6974746572206e6f7420736574","id":58217,"isConstant":false,"isLValue":false,"isPure":true,"kind":"string","lValueRequested":false,"nodeType":"Literal","src":"12750:46:120","typeDescriptions":{"typeIdentifier":"t_stringliteral_dc2094d90bbe21c62e4087e13d121e3f8b0b046ea0a70d61432535290d56a2cc","typeString":"literal_string \"FetchChainInfoOutput: batchSubmitter not set\""},"value":"FetchChainInfoOutput: batchSubmitter not set"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_bool","typeString":"bool"},{"typeIdentifier":"t_stringliteral_dc2094d90bbe21c62e4087e13d121e3f8b0b046ea0a70d61432535290d56a2cc","typeString":"literal_string \"FetchChainInfoOutput: batchSubmitter not set\""}],"id":58210,"name":"require","nodeType":"Identifier","overloadedDeclarations":[-18,-18],"referencedDeclaration":-18,"src":"12711:7:120","typeDescriptions":{"typeIdentifier":"t_function_require_pure$_t_bool_$_t_string_memory_ptr_$returns$__$","typeString":"function (bool,string memory) pure"}},"id":58218,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"12711:86:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":58219,"nodeType":"ExpressionStatement","src":"12711:86:120"},{"expression":{"id":58220,"name":"_batchSubmitter","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57461,"src":"12814:15:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"functionReturnParameters":58209,"id":58221,"nodeType":"Return","src":"12807:22:120"}]},"functionSelector":"fb951e9d","implemented":true,"kind":"function","modifiers":[],"name":"batchSubmitter","nameLocation":"12654:14:120","parameters":{"id":58206,"nodeType":"ParameterList","parameters":[],"src":"12668:2:120"},"returnParameters":{"id":58209,"nodeType":"ParameterList","parameters":[{"constant":false,"id":58208,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":58223,"src":"12692:7:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":58207,"name":"address","nodeType":"ElementaryTypeName","src":"12692:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"12691:9:120"},"scope":58249,"stateMutability":"view","virtual":false,"visibility":"public"},{"id":58231,"nodeType":"FunctionDefinition","src":"12842:88:120","nodes":[],"body":{"id":58230,"nodeType":"Block","src":"12893:37:120","nodes":[],"statements":[{"expression":{"id":58228,"name":"_permissioned","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57463,"src":"12910:13:120","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},"functionReturnParameters":58227,"id":58229,"nodeType":"Return","src":"12903:20:120"}]},"functionSelector":"3cc162f1","implemented":true,"kind":"function","modifiers":[],"name":"permissioned","nameLocation":"12851:12:120","parameters":{"id":58224,"nodeType":"ParameterList","parameters":[],"src":"12863:2:120"},"returnParameters":{"id":58227,"nodeType":"ParameterList","parameters":[{"constant":false,"id":58226,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":58231,"src":"12887:4:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"},"typeName":{"id":58225,"name":"bool","nodeType":"ElementaryTypeName","src":"12887:4:120","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},"visibility":"internal"}],"src":"12886:6:120"},"scope":58249,"stateMutability":"view","virtual":false,"visibility":"public"},{"id":58239,"nodeType":"FunctionDefinition","src":"12936:92:120","nodes":[],"body":{"id":58238,"nodeType":"Block","src":"12989:39:120","nodes":[],"statements":[{"expression":{"id":58236,"name":"_permissionless","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57465,"src":"13006:15:120","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},"functionReturnParameters":58235,"id":58237,"nodeType":"Return","src":"12999:22:120"}]},"functionSelector":"a1256f9f","implemented":true,"kind":"function","modifiers":[],"name":"permissionless","nameLocation":"12945:14:120","parameters":{"id":58232,"nodeType":"ParameterList","parameters":[],"src":"12959:2:120"},"returnParameters":{"id":58235,"nodeType":"ParameterList","parameters":[{"constant":false,"id":58234,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":58239,"src":"12983:4:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"},"typeName":{"id":58233,"name":"bool","nodeType":"ElementaryTypeName","src":"12983:4:120","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},"visibility":"internal"}],"src":"12982:6:120"},"scope":58249,"stateMutability":"view","virtual":false,"visibility":"public"},{"id":58248,"nodeType":"FunctionDefinition","src":"13034:102:120","nodes":[],"body":{"id":58247,"nodeType":"Block","src":"13094:42:120","nodes":[],"statements":[{"expression":{"id":58245,"name":"_respectedGameType","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57468,"src":"13111:18:120","typeDescriptions":{"typeIdentifier":"t_userDefinedValueType$_GameType_$75355","typeString":"GameType"}},"functionReturnParameters":58244,"id":58246,"nodeType":"Return","src":"13104:25:120"}]},"functionSelector":"3c9f397c","implemented":true,"kind":"function","modifiers":[],"name":"respectedGameType","nameLocation":"13043:17:120","parameters":{"id":58240,"nodeType":"ParameterList","parameters":[],"src":"13060:2:120"},"returnParameters":{"id":58244,"nodeType":"ParameterList","parameters":[{"constant":false,"id":58243,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":58248,"src":"13084:8:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_userDefinedValueType$_GameType_$75355","typeString":"GameType"},"typeName":{"id":58242,"nodeType":"UserDefinedTypeName","pathNode":{"id":58241,"name":"GameType","nameLocations":["13084:8:120"],"nodeType":"IdentifierPath","referencedDeclaration":75355,"src":"13084:8:120"},"referencedDeclaration":75355,"src":"13084:8:120","typeDescriptions":{"typeIdentifier":"t_userDefinedValueType$_GameType_$75355","typeString":"GameType"}},"visibility":"internal"}],"src":"13083:10:120"},"scope":58249,"stateMutability":"view","virtual":false,"visibility":"public"}],"abstract":false,"baseContracts":[],"canonicalName":"FetchChainInfoOutput","contractDependencies":[],"contractKind":"contract","fullyImplemented":true,"linearizedBaseContracts":[58249],"name":"FetchChainInfoOutput","nameLocation":"2966:20:120","scope":59300,"usedErrors":[],"usedEvents":[]},{"id":59299,"nodeType":"ContractDefinition","src":"13140:10848:120","nodes":[{"id":58275,"nodeType":"FunctionDefinition","src":"13180:198:120","nodes":[],"body":{"id":58274,"nodeType":"Block","src":"13251:127:120","nodes":[],"statements":[{"expression":{"arguments":[{"id":58261,"name":"_fi","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58254,"src":"13282:3:120","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoInput_$57409","typeString":"contract FetchChainInfoInput"}},{"id":58262,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58257,"src":"13287:3:120","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$58249","typeString":"contract FetchChainInfoOutput"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_contract$_FetchChainInfoInput_$57409","typeString":"contract FetchChainInfoInput"},{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$58249","typeString":"contract FetchChainInfoOutput"}],"id":58260,"name":"_processSystemConfig","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58411,"src":"13261:20:120","typeDescriptions":{"typeIdentifier":"t_function_internal_nonpayable$_t_contract$_FetchChainInfoInput_$57409_$_t_contract$_FetchChainInfoOutput_$58249_$returns$__$","typeString":"function (contract FetchChainInfoInput,contract FetchChainInfoOutput)"}},"id":58263,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"13261:30:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":58264,"nodeType":"ExpressionStatement","src":"13261:30:120"},{"expression":{"arguments":[{"id":58266,"name":"_fi","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58254,"src":"13328:3:120","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoInput_$57409","typeString":"contract FetchChainInfoInput"}},{"id":58267,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58257,"src":"13333:3:120","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$58249","typeString":"contract FetchChainInfoOutput"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_contract$_FetchChainInfoInput_$57409","typeString":"contract FetchChainInfoInput"},{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$58249","typeString":"contract FetchChainInfoOutput"}],"id":58265,"name":"_processMessengerAndPortal","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58528,"src":"13301:26:120","typeDescriptions":{"typeIdentifier":"t_function_internal_nonpayable$_t_contract$_FetchChainInfoInput_$57409_$_t_contract$_FetchChainInfoOutput_$58249_$returns$__$","typeString":"function (contract FetchChainInfoInput,contract FetchChainInfoOutput)"}},"id":58268,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"13301:36:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":58269,"nodeType":"ExpressionStatement","src":"13301:36:120"},{"expression":{"arguments":[{"id":58271,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58257,"src":"13367:3:120","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$58249","typeString":"contract FetchChainInfoOutput"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$58249","typeString":"contract FetchChainInfoOutput"}],"id":58270,"name":"_processFaultProofs","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58878,"src":"13347:19:120","typeDescriptions":{"typeIdentifier":"t_function_internal_nonpayable$_t_contract$_FetchChainInfoOutput_$58249_$returns$__$","typeString":"function (contract FetchChainInfoOutput)"}},"id":58272,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"13347:24:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":58273,"nodeType":"ExpressionStatement","src":"13347:24:120"}]},"functionSelector":"fc4dcacb","implemented":true,"kind":"function","modifiers":[],"name":"run","nameLocation":"13189:3:120","parameters":{"id":58258,"nodeType":"ParameterList","parameters":[{"constant":false,"id":58254,"mutability":"mutable","name":"_fi","nameLocation":"13213:3:120","nodeType":"VariableDeclaration","scope":58275,"src":"13193:23:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoInput_$57409","typeString":"contract FetchChainInfoInput"},"typeName":{"id":58253,"nodeType":"UserDefinedTypeName","pathNode":{"id":58252,"name":"FetchChainInfoInput","nameLocations":["13193:19:120"],"nodeType":"IdentifierPath","referencedDeclaration":57409,"src":"13193:19:120"},"referencedDeclaration":57409,"src":"13193:19:120","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoInput_$57409","typeString":"contract FetchChainInfoInput"}},"visibility":"internal"},{"constant":false,"id":58257,"mutability":"mutable","name":"_fo","nameLocation":"13239:3:120","nodeType":"VariableDeclaration","scope":58275,"src":"13218:24:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$58249","typeString":"contract FetchChainInfoOutput"},"typeName":{"id":58256,"nodeType":"UserDefinedTypeName","pathNode":{"id":58255,"name":"FetchChainInfoOutput","nameLocations":["13218:20:120"],"nodeType":"IdentifierPath","referencedDeclaration":58249,"src":"13218:20:120"},"referencedDeclaration":58249,"src":"13218:20:120","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$58249","typeString":"contract FetchChainInfoOutput"}},"visibility":"internal"}],"src":"13192:51:120"},"returnParameters":{"id":58259,"nodeType":"ParameterList","parameters":[],"src":"13251:0:120"},"scope":59299,"stateMutability":"nonpayable","virtual":false,"visibility":"public"},{"id":58411,"nodeType":"FunctionDefinition","src":"13384:1336:120","nodes":[],"body":{"id":58410,"nodeType":"Block","src":"13474:1246:120","nodes":[],"statements":[{"assignments":[58285],"declarations":[{"constant":false,"id":58285,"mutability":"mutable","name":"systemConfigProxy","nameLocation":"13492:17:120","nodeType":"VariableDeclaration","scope":58410,"src":"13484:25:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":58284,"name":"address","nodeType":"ElementaryTypeName","src":"13484:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"id":58289,"initialValue":{"arguments":[],"expression":{"argumentTypes":[],"expression":{"id":58286,"name":"_fi","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58278,"src":"13512:3:120","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoInput_$57409","typeString":"contract FetchChainInfoInput"}},"id":58287,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"13516:17:120","memberName":"systemConfigProxy","nodeType":"MemberAccess","referencedDeclaration":57390,"src":"13512:21:120","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":58288,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"13512:23:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"VariableDeclarationStatement","src":"13484:51:120"},{"expression":{"arguments":[{"expression":{"expression":{"id":58293,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58281,"src":"13553:3:120","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$58249","typeString":"contract FetchChainInfoOutput"}},"id":58294,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"13557:17:120","memberName":"systemConfigProxy","nodeType":"MemberAccess","referencedDeclaration":57947,"src":"13553:21:120","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":58295,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"13575:8:120","memberName":"selector","nodeType":"MemberAccess","src":"13553:30:120","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},{"id":58296,"name":"systemConfigProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58285,"src":"13585:17:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_bytes4","typeString":"bytes4"},{"typeIdentifier":"t_address","typeString":"address"}],"expression":{"id":58290,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58281,"src":"13545:3:120","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$58249","typeString":"contract FetchChainInfoOutput"}},"id":58292,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"13549:3:120","memberName":"set","nodeType":"MemberAccess","referencedDeclaration":57740,"src":"13545:7:120","typeDescriptions":{"typeIdentifier":"t_function_external_nonpayable$_t_bytes4_$_t_address_$returns$__$","typeString":"function (bytes4,address) external"}},"id":58297,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"13545:58:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":58298,"nodeType":"ExpressionStatement","src":"13545:58:120"},{"assignments":[58300],"declarations":[{"constant":false,"id":58300,"mutability":"mutable","name":"systemConfigOwner","nameLocation":"13622:17:120","nodeType":"VariableDeclaration","scope":58410,"src":"13614:25:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":58299,"name":"address","nodeType":"ElementaryTypeName","src":"13614:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"id":58306,"initialValue":{"arguments":[],"expression":{"argumentTypes":[],"expression":{"arguments":[{"id":58302,"name":"systemConfigProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58285,"src":"13651:17:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_address","typeString":"address"}],"id":58301,"name":"IFetcher","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57326,"src":"13642:8:120","typeDescriptions":{"typeIdentifier":"t_type$_t_contract$_IFetcher_$57326_$","typeString":"type(contract IFetcher)"}},"id":58303,"isConstant":false,"isLValue":false,"isPure":false,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"13642:27:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_contract$_IFetcher_$57326","typeString":"contract IFetcher"}},"id":58304,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"13670:5:120","memberName":"owner","nodeType":"MemberAccess","referencedDeclaration":57315,"src":"13642:33:120","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":58305,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"13642:35:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"VariableDeclarationStatement","src":"13614:63:120"},{"expression":{"arguments":[{"expression":{"expression":{"id":58310,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58281,"src":"13695:3:120","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$58249","typeString":"contract FetchChainInfoOutput"}},"id":58311,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"13699:17:120","memberName":"systemConfigOwner","nodeType":"MemberAccess","referencedDeclaration":58115,"src":"13695:21:120","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":58312,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"13717:8:120","memberName":"selector","nodeType":"MemberAccess","src":"13695:30:120","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},{"id":58313,"name":"systemConfigOwner","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58300,"src":"13727:17:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_bytes4","typeString":"bytes4"},{"typeIdentifier":"t_address","typeString":"address"}],"expression":{"id":58307,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58281,"src":"13687:3:120","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$58249","typeString":"contract FetchChainInfoOutput"}},"id":58309,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"13691:3:120","memberName":"set","nodeType":"MemberAccess","referencedDeclaration":57740,"src":"13687:7:120","typeDescriptions":{"typeIdentifier":"t_function_external_nonpayable$_t_bytes4_$_t_address_$returns$__$","typeString":"function (bytes4,address) external"}},"id":58314,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"13687:58:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":58315,"nodeType":"ExpressionStatement","src":"13687:58:120"},{"assignments":[58317],"declarations":[{"constant":false,"id":58317,"mutability":"mutable","name":"unsafeBlockSigner","nameLocation":"13764:17:120","nodeType":"VariableDeclaration","scope":58410,"src":"13756:25:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":58316,"name":"address","nodeType":"ElementaryTypeName","src":"13756:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"id":58323,"initialValue":{"arguments":[],"expression":{"argumentTypes":[],"expression":{"arguments":[{"id":58319,"name":"systemConfigProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58285,"src":"13793:17:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_address","typeString":"address"}],"id":58318,"name":"IFetcher","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57326,"src":"13784:8:120","typeDescriptions":{"typeIdentifier":"t_type$_t_contract$_IFetcher_$57326_$","typeString":"type(contract IFetcher)"}},"id":58320,"isConstant":false,"isLValue":false,"isPure":false,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"13784:27:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_contract$_IFetcher_$57326","typeString":"contract IFetcher"}},"id":58321,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"13812:17:120","memberName":"unsafeBlockSigner","nodeType":"MemberAccess","referencedDeclaration":57320,"src":"13784:45:120","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":58322,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"13784:47:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"VariableDeclarationStatement","src":"13756:75:120"},{"expression":{"arguments":[{"expression":{"expression":{"id":58327,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58281,"src":"13849:3:120","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$58249","typeString":"contract FetchChainInfoOutput"}},"id":58328,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"13853:17:120","memberName":"unsafeBlockSigner","nodeType":"MemberAccess","referencedDeclaration":58205,"src":"13849:21:120","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":58329,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"13871:8:120","memberName":"selector","nodeType":"MemberAccess","src":"13849:30:120","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},{"id":58330,"name":"unsafeBlockSigner","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58317,"src":"13881:17:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_bytes4","typeString":"bytes4"},{"typeIdentifier":"t_address","typeString":"address"}],"expression":{"id":58324,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58281,"src":"13841:3:120","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$58249","typeString":"contract FetchChainInfoOutput"}},"id":58326,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"13845:3:120","memberName":"set","nodeType":"MemberAccess","referencedDeclaration":57740,"src":"13841:7:120","typeDescriptions":{"typeIdentifier":"t_function_external_nonpayable$_t_bytes4_$_t_address_$returns$__$","typeString":"function (bytes4,address) external"}},"id":58331,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"13841:58:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":58332,"nodeType":"ExpressionStatement","src":"13841:58:120"},{"assignments":[58334],"declarations":[{"constant":false,"id":58334,"mutability":"mutable","name":"batchSubmitter","nameLocation":"13918:14:120","nodeType":"VariableDeclaration","scope":58410,"src":"13910:22:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":58333,"name":"address","nodeType":"ElementaryTypeName","src":"13910:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"id":58338,"initialValue":{"arguments":[{"id":58336,"name":"systemConfigProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58285,"src":"13954:17:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_address","typeString":"address"}],"id":58335,"name":"_getBatchSubmitter","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":59275,"src":"13935:18:120","typeDescriptions":{"typeIdentifier":"t_function_internal_view$_t_address_$returns$_t_address_$","typeString":"function (address) view returns (address)"}},"id":58337,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"13935:37:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"VariableDeclarationStatement","src":"13910:62:120"},{"expression":{"arguments":[{"expression":{"expression":{"id":58342,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58281,"src":"13990:3:120","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$58249","typeString":"contract FetchChainInfoOutput"}},"id":58343,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"13994:14:120","memberName":"batchSubmitter","nodeType":"MemberAccess","referencedDeclaration":58223,"src":"13990:18:120","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":58344,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"14009:8:120","memberName":"selector","nodeType":"MemberAccess","src":"13990:27:120","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},{"id":58345,"name":"batchSubmitter","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58334,"src":"14019:14:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_bytes4","typeString":"bytes4"},{"typeIdentifier":"t_address","typeString":"address"}],"expression":{"id":58339,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58281,"src":"13982:3:120","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$58249","typeString":"contract FetchChainInfoOutput"}},"id":58341,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"13986:3:120","memberName":"set","nodeType":"MemberAccess","referencedDeclaration":57740,"src":"13982:7:120","typeDescriptions":{"typeIdentifier":"t_function_external_nonpayable$_t_bytes4_$_t_address_$returns$__$","typeString":"function (bytes4,address) external"}},"id":58346,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"13982:52:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":58347,"nodeType":"ExpressionStatement","src":"13982:52:120"},{"assignments":[58349],"declarations":[{"constant":false,"id":58349,"mutability":"mutable","name":"opChainProxyAdminImpl","nameLocation":"14053:21:120","nodeType":"VariableDeclaration","scope":58410,"src":"14045:29:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":58348,"name":"address","nodeType":"ElementaryTypeName","src":"14045:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"id":58353,"initialValue":{"arguments":[{"id":58351,"name":"systemConfigProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58285,"src":"14092:17:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_address","typeString":"address"}],"id":58350,"name":"_getProxyAdmin","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":59298,"src":"14077:14:120","typeDescriptions":{"typeIdentifier":"t_function_internal_nonpayable$_t_address_$returns$_t_address_$","typeString":"function (address) returns (address)"}},"id":58352,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"14077:33:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"VariableDeclarationStatement","src":"14045:65:120"},{"expression":{"arguments":[{"expression":{"expression":{"id":58357,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58281,"src":"14128:3:120","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$58249","typeString":"contract FetchChainInfoOutput"}},"id":58358,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"14132:21:120","memberName":"opChainProxyAdminImpl","nodeType":"MemberAccess","referencedDeclaration":57965,"src":"14128:25:120","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":58359,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"14154:8:120","memberName":"selector","nodeType":"MemberAccess","src":"14128:34:120","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},{"id":58360,"name":"opChainProxyAdminImpl","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58349,"src":"14164:21:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_bytes4","typeString":"bytes4"},{"typeIdentifier":"t_address","typeString":"address"}],"expression":{"id":58354,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58281,"src":"14120:3:120","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$58249","typeString":"contract FetchChainInfoOutput"}},"id":58356,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"14124:3:120","memberName":"set","nodeType":"MemberAccess","referencedDeclaration":57740,"src":"14120:7:120","typeDescriptions":{"typeIdentifier":"t_function_external_nonpayable$_t_bytes4_$_t_address_$returns$__$","typeString":"function (bytes4,address) external"}},"id":58361,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"14120:66:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":58362,"nodeType":"ExpressionStatement","src":"14120:66:120"},{"assignments":[58364],"declarations":[{"constant":false,"id":58364,"mutability":"mutable","name":"opChainProxyAdminOwner","nameLocation":"14205:22:120","nodeType":"VariableDeclaration","scope":58410,"src":"14197:30:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":58363,"name":"address","nodeType":"ElementaryTypeName","src":"14197:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"id":58370,"initialValue":{"arguments":[],"expression":{"argumentTypes":[],"expression":{"arguments":[{"id":58366,"name":"opChainProxyAdminImpl","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58349,"src":"14239:21:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_address","typeString":"address"}],"id":58365,"name":"IFetcher","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57326,"src":"14230:8:120","typeDescriptions":{"typeIdentifier":"t_type$_t_contract$_IFetcher_$57326_$","typeString":"type(contract IFetcher)"}},"id":58367,"isConstant":false,"isLValue":false,"isPure":false,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"14230:31:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_contract$_IFetcher_$57326","typeString":"contract IFetcher"}},"id":58368,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"14262:5:120","memberName":"owner","nodeType":"MemberAccess","referencedDeclaration":57315,"src":"14230:37:120","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":58369,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"14230:39:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"VariableDeclarationStatement","src":"14197:72:120"},{"expression":{"arguments":[{"expression":{"expression":{"id":58374,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58281,"src":"14287:3:120","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$58249","typeString":"contract FetchChainInfoOutput"}},"id":58375,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"14291:22:120","memberName":"opChainProxyAdminOwner","nodeType":"MemberAccess","referencedDeclaration":58133,"src":"14287:26:120","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":58376,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"14314:8:120","memberName":"selector","nodeType":"MemberAccess","src":"14287:35:120","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},{"id":58377,"name":"opChainProxyAdminOwner","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58364,"src":"14324:22:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_bytes4","typeString":"bytes4"},{"typeIdentifier":"t_address","typeString":"address"}],"expression":{"id":58371,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58281,"src":"14279:3:120","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$58249","typeString":"contract FetchChainInfoOutput"}},"id":58373,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"14283:3:120","memberName":"set","nodeType":"MemberAccess","referencedDeclaration":57740,"src":"14279:7:120","typeDescriptions":{"typeIdentifier":"t_function_external_nonpayable$_t_bytes4_$_t_address_$returns$__$","typeString":"function (bytes4,address) external"}},"id":58378,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"14279:68:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":58379,"nodeType":"ExpressionStatement","src":"14279:68:120"},{"assignments":[58381],"declarations":[{"constant":false,"id":58381,"mutability":"mutable","name":"l1Erc721BridgeProxy","nameLocation":"14366:19:120","nodeType":"VariableDeclaration","scope":58410,"src":"14358:27:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":58380,"name":"address","nodeType":"ElementaryTypeName","src":"14358:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"id":58385,"initialValue":{"arguments":[{"id":58383,"name":"systemConfigProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58285,"src":"14412:17:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_address","typeString":"address"}],"id":58382,"name":"_getL1ERC721BridgeProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":59031,"src":"14388:23:120","typeDescriptions":{"typeIdentifier":"t_function_internal_view$_t_address_$returns$_t_address_$","typeString":"function (address) view returns (address)"}},"id":58384,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"14388:42:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"VariableDeclarationStatement","src":"14358:72:120"},{"expression":{"arguments":[{"expression":{"expression":{"id":58389,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58281,"src":"14448:3:120","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$58249","typeString":"contract FetchChainInfoOutput"}},"id":58390,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"14452:19:120","memberName":"l1Erc721BridgeProxy","nodeType":"MemberAccess","referencedDeclaration":57857,"src":"14448:23:120","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":58391,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"14472:8:120","memberName":"selector","nodeType":"MemberAccess","src":"14448:32:120","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},{"id":58392,"name":"l1Erc721BridgeProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58381,"src":"14482:19:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_bytes4","typeString":"bytes4"},{"typeIdentifier":"t_address","typeString":"address"}],"expression":{"id":58386,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58281,"src":"14440:3:120","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$58249","typeString":"contract FetchChainInfoOutput"}},"id":58388,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"14444:3:120","memberName":"set","nodeType":"MemberAccess","referencedDeclaration":57740,"src":"14440:7:120","typeDescriptions":{"typeIdentifier":"t_function_external_nonpayable$_t_bytes4_$_t_address_$returns$__$","typeString":"function (bytes4,address) external"}},"id":58393,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"14440:62:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":58394,"nodeType":"ExpressionStatement","src":"14440:62:120"},{"assignments":[58396],"declarations":[{"constant":false,"id":58396,"mutability":"mutable","name":"optimismMintableErc20FactoryProxy","nameLocation":"14521:33:120","nodeType":"VariableDeclaration","scope":58410,"src":"14513:41:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":58395,"name":"address","nodeType":"ElementaryTypeName","src":"14513:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"id":58400,"initialValue":{"arguments":[{"id":58398,"name":"systemConfigProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58285,"src":"14595:17:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_address","typeString":"address"}],"id":58397,"name":"_getOptimismMintableERC20FactoryProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":59059,"src":"14557:37:120","typeDescriptions":{"typeIdentifier":"t_function_internal_view$_t_address_$returns$_t_address_$","typeString":"function (address) view returns (address)"}},"id":58399,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"14557:56:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"VariableDeclarationStatement","src":"14513:100:120"},{"expression":{"arguments":[{"expression":{"expression":{"id":58404,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58281,"src":"14631:3:120","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$58249","typeString":"contract FetchChainInfoOutput"}},"id":58405,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"14635:33:120","memberName":"optimismMintableErc20FactoryProxy","nodeType":"MemberAccess","referencedDeclaration":57911,"src":"14631:37:120","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":58406,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"14669:8:120","memberName":"selector","nodeType":"MemberAccess","src":"14631:46:120","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},{"id":58407,"name":"optimismMintableErc20FactoryProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58396,"src":"14679:33:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_bytes4","typeString":"bytes4"},{"typeIdentifier":"t_address","typeString":"address"}],"expression":{"id":58401,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58281,"src":"14623:3:120","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$58249","typeString":"contract FetchChainInfoOutput"}},"id":58403,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"14627:3:120","memberName":"set","nodeType":"MemberAccess","referencedDeclaration":57740,"src":"14623:7:120","typeDescriptions":{"typeIdentifier":"t_function_external_nonpayable$_t_bytes4_$_t_address_$returns$__$","typeString":"function (bytes4,address) external"}},"id":58408,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"14623:90:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":58409,"nodeType":"ExpressionStatement","src":"14623:90:120"}]},"implemented":true,"kind":"function","modifiers":[],"name":"_processSystemConfig","nameLocation":"13393:20:120","parameters":{"id":58282,"nodeType":"ParameterList","parameters":[{"constant":false,"id":58278,"mutability":"mutable","name":"_fi","nameLocation":"13434:3:120","nodeType":"VariableDeclaration","scope":58411,"src":"13414:23:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoInput_$57409","typeString":"contract FetchChainInfoInput"},"typeName":{"id":58277,"nodeType":"UserDefinedTypeName","pathNode":{"id":58276,"name":"FetchChainInfoInput","nameLocations":["13414:19:120"],"nodeType":"IdentifierPath","referencedDeclaration":57409,"src":"13414:19:120"},"referencedDeclaration":57409,"src":"13414:19:120","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoInput_$57409","typeString":"contract FetchChainInfoInput"}},"visibility":"internal"},{"constant":false,"id":58281,"mutability":"mutable","name":"_fo","nameLocation":"13460:3:120","nodeType":"VariableDeclaration","scope":58411,"src":"13439:24:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$58249","typeString":"contract FetchChainInfoOutput"},"typeName":{"id":58280,"nodeType":"UserDefinedTypeName","pathNode":{"id":58279,"name":"FetchChainInfoOutput","nameLocations":["13439:20:120"],"nodeType":"IdentifierPath","referencedDeclaration":58249,"src":"13439:20:120"},"referencedDeclaration":58249,"src":"13439:20:120","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$58249","typeString":"contract FetchChainInfoOutput"}},"visibility":"internal"}],"src":"13413:51:120"},"returnParameters":{"id":58283,"nodeType":"ParameterList","parameters":[],"src":"13474:0:120"},"scope":59299,"stateMutability":"nonpayable","virtual":false,"visibility":"internal"},{"id":58528,"nodeType":"FunctionDefinition","src":"14726:1190:120","nodes":[],"body":{"id":58527,"nodeType":"Block","src":"14822:1094:120","nodes":[],"statements":[{"assignments":[58421],"declarations":[{"constant":false,"id":58421,"mutability":"mutable","name":"l1StandardBridgeProxy","nameLocation":"14840:21:120","nodeType":"VariableDeclaration","scope":58527,"src":"14832:29:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":58420,"name":"address","nodeType":"ElementaryTypeName","src":"14832:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"id":58425,"initialValue":{"arguments":[],"expression":{"argumentTypes":[],"expression":{"id":58422,"name":"_fi","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58414,"src":"14864:3:120","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoInput_$57409","typeString":"contract FetchChainInfoInput"}},"id":58423,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"14868:21:120","memberName":"l1StandardBridgeProxy","nodeType":"MemberAccess","referencedDeclaration":57408,"src":"14864:25:120","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":58424,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"14864:27:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"VariableDeclarationStatement","src":"14832:59:120"},{"expression":{"arguments":[{"expression":{"expression":{"id":58429,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58417,"src":"14909:3:120","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$58249","typeString":"contract FetchChainInfoOutput"}},"id":58430,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"14913:21:120","memberName":"l1StandardBridgeProxy","nodeType":"MemberAccess","referencedDeclaration":57875,"src":"14909:25:120","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":58431,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"14935:8:120","memberName":"selector","nodeType":"MemberAccess","src":"14909:34:120","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},{"id":58432,"name":"l1StandardBridgeProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58421,"src":"14945:21:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_bytes4","typeString":"bytes4"},{"typeIdentifier":"t_address","typeString":"address"}],"expression":{"id":58426,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58417,"src":"14901:3:120","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$58249","typeString":"contract FetchChainInfoOutput"}},"id":58428,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"14905:3:120","memberName":"set","nodeType":"MemberAccess","referencedDeclaration":57740,"src":"14901:7:120","typeDescriptions":{"typeIdentifier":"t_function_external_nonpayable$_t_bytes4_$_t_address_$returns$__$","typeString":"function (bytes4,address) external"}},"id":58433,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"14901:66:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":58434,"nodeType":"ExpressionStatement","src":"14901:66:120"},{"assignments":[58436],"declarations":[{"constant":false,"id":58436,"mutability":"mutable","name":"l1CrossDomainMessengerProxy","nameLocation":"14986:27:120","nodeType":"VariableDeclaration","scope":58527,"src":"14978:35:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":58435,"name":"address","nodeType":"ElementaryTypeName","src":"14978:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"id":58442,"initialValue":{"arguments":[],"expression":{"argumentTypes":[],"expression":{"arguments":[{"id":58438,"name":"l1StandardBridgeProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58421,"src":"15025:21:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_address","typeString":"address"}],"id":58437,"name":"IFetcher","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57326,"src":"15016:8:120","typeDescriptions":{"typeIdentifier":"t_type$_t_contract$_IFetcher_$57326_$","typeString":"type(contract IFetcher)"}},"id":58439,"isConstant":false,"isLValue":false,"isPure":false,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"15016:31:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_contract$_IFetcher_$57326","typeString":"contract IFetcher"}},"id":58440,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"15048:9:120","memberName":"messenger","nodeType":"MemberAccess","referencedDeclaration":57221,"src":"15016:41:120","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":58441,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"15016:43:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"VariableDeclarationStatement","src":"14978:81:120"},{"expression":{"arguments":[{"expression":{"expression":{"id":58446,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58417,"src":"15077:3:120","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$58249","typeString":"contract FetchChainInfoOutput"}},"id":58447,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"15081:27:120","memberName":"l1CrossDomainMessengerProxy","nodeType":"MemberAccess","referencedDeclaration":57839,"src":"15077:31:120","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":58448,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"15109:8:120","memberName":"selector","nodeType":"MemberAccess","src":"15077:40:120","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},{"id":58449,"name":"l1CrossDomainMessengerProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58436,"src":"15119:27:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_bytes4","typeString":"bytes4"},{"typeIdentifier":"t_address","typeString":"address"}],"expression":{"id":58443,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58417,"src":"15069:3:120","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$58249","typeString":"contract FetchChainInfoOutput"}},"id":58445,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"15073:3:120","memberName":"set","nodeType":"MemberAccess","referencedDeclaration":57740,"src":"15069:7:120","typeDescriptions":{"typeIdentifier":"t_function_external_nonpayable$_t_bytes4_$_t_address_$returns$__$","typeString":"function (bytes4,address) external"}},"id":58450,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"15069:78:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":58451,"nodeType":"ExpressionStatement","src":"15069:78:120"},{"assignments":[58453],"declarations":[{"constant":false,"id":58453,"mutability":"mutable","name":"addressManagerImpl","nameLocation":"15166:18:120","nodeType":"VariableDeclaration","scope":58527,"src":"15158:26:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":58452,"name":"address","nodeType":"ElementaryTypeName","src":"15158:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"id":58457,"initialValue":{"arguments":[{"id":58455,"name":"l1CrossDomainMessengerProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58436,"src":"15206:27:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_address","typeString":"address"}],"id":58454,"name":"_getAddressManager","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":59003,"src":"15187:18:120","typeDescriptions":{"typeIdentifier":"t_function_internal_view$_t_address_$returns$_t_address_$","typeString":"function (address) view returns (address)"}},"id":58456,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"15187:47:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"VariableDeclarationStatement","src":"15158:76:120"},{"expression":{"arguments":[{"expression":{"expression":{"id":58461,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58417,"src":"15252:3:120","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$58249","typeString":"contract FetchChainInfoOutput"}},"id":58462,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"15256:18:120","memberName":"addressManagerImpl","nodeType":"MemberAccess","referencedDeclaration":57813,"src":"15252:22:120","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":58463,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"15275:8:120","memberName":"selector","nodeType":"MemberAccess","src":"15252:31:120","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},{"id":58464,"name":"addressManagerImpl","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58453,"src":"15285:18:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_bytes4","typeString":"bytes4"},{"typeIdentifier":"t_address","typeString":"address"}],"expression":{"id":58458,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58417,"src":"15244:3:120","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$58249","typeString":"contract FetchChainInfoOutput"}},"id":58460,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"15248:3:120","memberName":"set","nodeType":"MemberAccess","referencedDeclaration":57740,"src":"15244:7:120","typeDescriptions":{"typeIdentifier":"t_function_external_nonpayable$_t_bytes4_$_t_address_$returns$__$","typeString":"function (bytes4,address) external"}},"id":58465,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"15244:60:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":58466,"nodeType":"ExpressionStatement","src":"15244:60:120"},{"assignments":[58468],"declarations":[{"constant":false,"id":58468,"mutability":"mutable","name":"optimismPortalProxy","nameLocation":"15323:19:120","nodeType":"VariableDeclaration","scope":58527,"src":"15315:27:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":58467,"name":"address","nodeType":"ElementaryTypeName","src":"15315:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"id":58472,"initialValue":{"arguments":[{"id":58470,"name":"l1CrossDomainMessengerProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58436,"src":"15369:27:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_address","typeString":"address"}],"id":58469,"name":"_getOptimismPortalProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58965,"src":"15345:23:120","typeDescriptions":{"typeIdentifier":"t_function_internal_view$_t_address_$returns$_t_address_$","typeString":"function (address) view returns (address)"}},"id":58471,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"15345:52:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"VariableDeclarationStatement","src":"15315:82:120"},{"expression":{"arguments":[{"expression":{"expression":{"id":58476,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58417,"src":"15415:3:120","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$58249","typeString":"contract FetchChainInfoOutput"}},"id":58477,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"15419:19:120","memberName":"optimismPortalProxy","nodeType":"MemberAccess","referencedDeclaration":57929,"src":"15415:23:120","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":58478,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"15439:8:120","memberName":"selector","nodeType":"MemberAccess","src":"15415:32:120","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},{"id":58479,"name":"optimismPortalProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58468,"src":"15449:19:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_bytes4","typeString":"bytes4"},{"typeIdentifier":"t_address","typeString":"address"}],"expression":{"id":58473,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58417,"src":"15407:3:120","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$58249","typeString":"contract FetchChainInfoOutput"}},"id":58475,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"15411:3:120","memberName":"set","nodeType":"MemberAccess","referencedDeclaration":57740,"src":"15407:7:120","typeDescriptions":{"typeIdentifier":"t_function_external_nonpayable$_t_bytes4_$_t_address_$returns$__$","typeString":"function (bytes4,address) external"}},"id":58480,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"15407:62:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":58481,"nodeType":"ExpressionStatement","src":"15407:62:120"},{"assignments":[58483],"declarations":[{"constant":false,"id":58483,"mutability":"mutable","name":"opChainGuardian","nameLocation":"15488:15:120","nodeType":"VariableDeclaration","scope":58527,"src":"15480:23:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":58482,"name":"address","nodeType":"ElementaryTypeName","src":"15480:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"id":58487,"initialValue":{"arguments":[{"id":58485,"name":"optimismPortalProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58468,"src":"15519:19:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_address","typeString":"address"}],"id":58484,"name":"_getGuardian","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58907,"src":"15506:12:120","typeDescriptions":{"typeIdentifier":"t_function_internal_view$_t_address_$returns$_t_address_$","typeString":"function (address) view returns (address)"}},"id":58486,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"15506:33:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"VariableDeclarationStatement","src":"15480:59:120"},{"expression":{"arguments":[{"expression":{"expression":{"id":58491,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58417,"src":"15557:3:120","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$58249","typeString":"contract FetchChainInfoOutput"}},"id":58492,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"15561:15:120","memberName":"opChainGuardian","nodeType":"MemberAccess","referencedDeclaration":58151,"src":"15557:19:120","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":58493,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"15577:8:120","memberName":"selector","nodeType":"MemberAccess","src":"15557:28:120","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},{"id":58494,"name":"opChainGuardian","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58483,"src":"15587:15:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_bytes4","typeString":"bytes4"},{"typeIdentifier":"t_address","typeString":"address"}],"expression":{"id":58488,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58417,"src":"15549:3:120","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$58249","typeString":"contract FetchChainInfoOutput"}},"id":58490,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"15553:3:120","memberName":"set","nodeType":"MemberAccess","referencedDeclaration":57740,"src":"15549:7:120","typeDescriptions":{"typeIdentifier":"t_function_external_nonpayable$_t_bytes4_$_t_address_$returns$__$","typeString":"function (bytes4,address) external"}},"id":58495,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"15549:54:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":58496,"nodeType":"ExpressionStatement","src":"15549:54:120"},{"assignments":[58498],"declarations":[{"constant":false,"id":58498,"mutability":"mutable","name":"ethLockboxProxy","nameLocation":"15622:15:120","nodeType":"VariableDeclaration","scope":58527,"src":"15614:23:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":58497,"name":"address","nodeType":"ElementaryTypeName","src":"15614:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"id":58502,"initialValue":{"arguments":[{"id":58500,"name":"optimismPortalProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58468,"src":"15660:19:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_address","typeString":"address"}],"id":58499,"name":"_getEthLockboxProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":59203,"src":"15640:19:120","typeDescriptions":{"typeIdentifier":"t_function_internal_view$_t_address_$returns$_t_address_$","typeString":"function (address) view returns (address)"}},"id":58501,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"15640:40:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"VariableDeclarationStatement","src":"15614:66:120"},{"expression":{"arguments":[{"expression":{"expression":{"id":58506,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58417,"src":"15698:3:120","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$58249","typeString":"contract FetchChainInfoOutput"}},"id":58507,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"15702:15:120","memberName":"ethLockboxProxy","nodeType":"MemberAccess","referencedDeclaration":57821,"src":"15698:19:120","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":58508,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"15718:8:120","memberName":"selector","nodeType":"MemberAccess","src":"15698:28:120","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},{"id":58509,"name":"ethLockboxProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58498,"src":"15728:15:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_bytes4","typeString":"bytes4"},{"typeIdentifier":"t_address","typeString":"address"}],"expression":{"id":58503,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58417,"src":"15690:3:120","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$58249","typeString":"contract FetchChainInfoOutput"}},"id":58505,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"15694:3:120","memberName":"set","nodeType":"MemberAccess","referencedDeclaration":57740,"src":"15690:7:120","typeDescriptions":{"typeIdentifier":"t_function_external_nonpayable$_t_bytes4_$_t_address_$returns$__$","typeString":"function (bytes4,address) external"}},"id":58510,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"15690:54:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":58511,"nodeType":"ExpressionStatement","src":"15690:54:120"},{"assignments":[58513],"declarations":[{"constant":false,"id":58513,"mutability":"mutable","name":"superchainConfigProxy","nameLocation":"15763:21:120","nodeType":"VariableDeclaration","scope":58527,"src":"15755:29:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":58512,"name":"address","nodeType":"ElementaryTypeName","src":"15755:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"id":58517,"initialValue":{"arguments":[{"id":58515,"name":"optimismPortalProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58468,"src":"15813:19:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_address","typeString":"address"}],"id":58514,"name":"_getSuperchainConfigProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":59115,"src":"15787:25:120","typeDescriptions":{"typeIdentifier":"t_function_internal_view$_t_address_$returns$_t_address_$","typeString":"function (address) view returns (address)"}},"id":58516,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"15787:46:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"VariableDeclarationStatement","src":"15755:78:120"},{"expression":{"arguments":[{"expression":{"expression":{"id":58521,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58417,"src":"15851:3:120","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$58249","typeString":"contract FetchChainInfoOutput"}},"id":58522,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"15855:21:120","memberName":"superchainConfigProxy","nodeType":"MemberAccess","referencedDeclaration":57983,"src":"15851:25:120","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":58523,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"15877:8:120","memberName":"selector","nodeType":"MemberAccess","src":"15851:34:120","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},{"id":58524,"name":"superchainConfigProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58513,"src":"15887:21:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_bytes4","typeString":"bytes4"},{"typeIdentifier":"t_address","typeString":"address"}],"expression":{"id":58518,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58417,"src":"15843:3:120","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$58249","typeString":"contract FetchChainInfoOutput"}},"id":58520,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"15847:3:120","memberName":"set","nodeType":"MemberAccess","referencedDeclaration":57740,"src":"15843:7:120","typeDescriptions":{"typeIdentifier":"t_function_external_nonpayable$_t_bytes4_$_t_address_$returns$__$","typeString":"function (bytes4,address) external"}},"id":58525,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"15843:66:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":58526,"nodeType":"ExpressionStatement","src":"15843:66:120"}]},"implemented":true,"kind":"function","modifiers":[],"name":"_processMessengerAndPortal","nameLocation":"14735:26:120","parameters":{"id":58418,"nodeType":"ParameterList","parameters":[{"constant":false,"id":58414,"mutability":"mutable","name":"_fi","nameLocation":"14782:3:120","nodeType":"VariableDeclaration","scope":58528,"src":"14762:23:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoInput_$57409","typeString":"contract FetchChainInfoInput"},"typeName":{"id":58413,"nodeType":"UserDefinedTypeName","pathNode":{"id":58412,"name":"FetchChainInfoInput","nameLocations":["14762:19:120"],"nodeType":"IdentifierPath","referencedDeclaration":57409,"src":"14762:19:120"},"referencedDeclaration":57409,"src":"14762:19:120","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoInput_$57409","typeString":"contract FetchChainInfoInput"}},"visibility":"internal"},{"constant":false,"id":58417,"mutability":"mutable","name":"_fo","nameLocation":"14808:3:120","nodeType":"VariableDeclaration","scope":58528,"src":"14787:24:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$58249","typeString":"contract FetchChainInfoOutput"},"typeName":{"id":58416,"nodeType":"UserDefinedTypeName","pathNode":{"id":58415,"name":"FetchChainInfoOutput","nameLocations":["14787:20:120"],"nodeType":"IdentifierPath","referencedDeclaration":58249,"src":"14787:20:120"},"referencedDeclaration":58249,"src":"14787:20:120","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$58249","typeString":"contract FetchChainInfoOutput"}},"visibility":"internal"}],"src":"14761:51:120"},"returnParameters":{"id":58419,"nodeType":"ParameterList","parameters":[],"src":"14822:0:120"},"scope":59299,"stateMutability":"nonpayable","virtual":false,"visibility":"internal"},{"id":58878,"nodeType":"FunctionDefinition","src":"15922:3713:120","nodes":[],"body":{"id":58877,"nodeType":"Block","src":"15986:3649:120","nodes":[],"statements":[{"assignments":[58535],"declarations":[{"constant":false,"id":58535,"mutability":"mutable","name":"systemConfigProxy","nameLocation":"16004:17:120","nodeType":"VariableDeclaration","scope":58877,"src":"15996:25:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":58534,"name":"address","nodeType":"ElementaryTypeName","src":"15996:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"id":58539,"initialValue":{"arguments":[],"expression":{"argumentTypes":[],"expression":{"id":58536,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58531,"src":"16024:3:120","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$58249","typeString":"contract FetchChainInfoOutput"}},"id":58537,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"16028:17:120","memberName":"systemConfigProxy","nodeType":"MemberAccess","referencedDeclaration":57947,"src":"16024:21:120","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":58538,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"16024:23:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"VariableDeclarationStatement","src":"15996:51:120"},{"assignments":[58541],"declarations":[{"constant":false,"id":58541,"mutability":"mutable","name":"optimismPortalProxy","nameLocation":"16065:19:120","nodeType":"VariableDeclaration","scope":58877,"src":"16057:27:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":58540,"name":"address","nodeType":"ElementaryTypeName","src":"16057:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"id":58545,"initialValue":{"arguments":[],"expression":{"argumentTypes":[],"expression":{"id":58542,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58531,"src":"16087:3:120","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$58249","typeString":"contract FetchChainInfoOutput"}},"id":58543,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"16091:19:120","memberName":"optimismPortalProxy","nodeType":"MemberAccess","referencedDeclaration":57929,"src":"16087:23:120","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":58544,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"16087:25:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"VariableDeclarationStatement","src":"16057:55:120"},{"clauses":[{"block":{"id":58564,"nodeType":"Block","src":"16206:75:120","statements":[{"expression":{"arguments":[{"expression":{"expression":{"id":58558,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58531,"src":"16228:3:120","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$58249","typeString":"contract FetchChainInfoOutput"}},"id":58559,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"16232:17:120","memberName":"respectedGameType","nodeType":"MemberAccess","referencedDeclaration":58248,"src":"16228:21:120","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_userDefinedValueType$_GameType_$75355_$","typeString":"function () view external returns (GameType)"}},"id":58560,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"16250:8:120","memberName":"selector","nodeType":"MemberAccess","src":"16228:30:120","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},{"id":58561,"name":"gameType_","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58553,"src":"16260:9:120","typeDescriptions":{"typeIdentifier":"t_userDefinedValueType$_GameType_$75355","typeString":"GameType"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_bytes4","typeString":"bytes4"},{"typeIdentifier":"t_userDefinedValueType$_GameType_$75355","typeString":"GameType"}],"expression":{"id":58555,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58531,"src":"16220:3:120","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$58249","typeString":"contract FetchChainInfoOutput"}},"id":58557,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"16224:3:120","memberName":"set","nodeType":"MemberAccess","referencedDeclaration":57795,"src":"16220:7:120","typeDescriptions":{"typeIdentifier":"t_function_external_nonpayable$_t_bytes4_$_t_userDefinedValueType$_GameType_$75355_$returns$__$","typeString":"function (bytes4,GameType) external"}},"id":58562,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"16220:50:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":58563,"nodeType":"ExpressionStatement","src":"16220:50:120"}]},"errorName":"","id":58565,"nodeType":"TryCatchClause","parameters":{"id":58554,"nodeType":"ParameterList","parameters":[{"constant":false,"id":58553,"mutability":"mutable","name":"gameType_","nameLocation":"16195:9:120","nodeType":"VariableDeclaration","scope":58565,"src":"16186:18:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_userDefinedValueType$_GameType_$75355","typeString":"GameType"},"typeName":{"id":58552,"nodeType":"UserDefinedTypeName","pathNode":{"id":58551,"name":"GameType","nameLocations":["16186:8:120"],"nodeType":"IdentifierPath","referencedDeclaration":75355,"src":"16186:8:120"},"referencedDeclaration":75355,"src":"16186:8:120","typeDescriptions":{"typeIdentifier":"t_userDefinedValueType$_GameType_$75355","typeString":"GameType"}},"visibility":"internal"}],"src":"16185:20:120"},"src":"16177:104:120"},{"block":{"id":58637,"nodeType":"Block","src":"16288:744:120","statements":[{"expression":{"arguments":[{"expression":{"expression":{"id":58569,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58531,"src":"16383:3:120","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$58249","typeString":"contract FetchChainInfoOutput"}},"id":58570,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"16387:17:120","memberName":"respectedGameType","nodeType":"MemberAccess","referencedDeclaration":58248,"src":"16383:21:120","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_userDefinedValueType$_GameType_$75355_$","typeString":"function () view external returns (GameType)"}},"id":58571,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"16405:8:120","memberName":"selector","nodeType":"MemberAccess","src":"16383:30:120","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},{"arguments":[{"expression":{"arguments":[{"id":58576,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"nodeType":"ElementaryTypeNameExpression","src":"16434:6:120","typeDescriptions":{"typeIdentifier":"t_type$_t_uint32_$","typeString":"type(uint32)"},"typeName":{"id":58575,"name":"uint32","nodeType":"ElementaryTypeName","src":"16434:6:120","typeDescriptions":{}}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_type$_t_uint32_$","typeString":"type(uint32)"}],"id":58574,"name":"type","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":-27,"src":"16429:4:120","typeDescriptions":{"typeIdentifier":"t_function_metatype_pure$__$returns$__$","typeString":"function () pure"}},"id":58577,"isConstant":false,"isLValue":false,"isPure":true,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"16429:12:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_magic_meta_type_t_uint32","typeString":"type(uint32)"}},"id":58578,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"memberLocation":"16442:3:120","memberName":"max","nodeType":"MemberAccess","src":"16429:16:120","typeDescriptions":{"typeIdentifier":"t_uint32","typeString":"uint32"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_uint32","typeString":"uint32"}],"expression":{"id":58572,"name":"GameType","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":75355,"src":"16415:8:120","typeDescriptions":{"typeIdentifier":"t_type$_t_userDefinedValueType$_GameType_$75355_$","typeString":"type(GameType)"}},"id":58573,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"memberLocation":"16424:4:120","memberName":"wrap","nodeType":"MemberAccess","src":"16415:13:120","typeDescriptions":{"typeIdentifier":"t_function_wrap_pure$_t_uint32_$returns$_t_userDefinedValueType$_GameType_$75355_$","typeString":"function (uint32) pure returns (GameType)"}},"id":58579,"isConstant":false,"isLValue":false,"isPure":true,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"16415:31:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_userDefinedValueType$_GameType_$75355","typeString":"GameType"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_bytes4","typeString":"bytes4"},{"typeIdentifier":"t_userDefinedValueType$_GameType_$75355","typeString":"GameType"}],"expression":{"id":58566,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58531,"src":"16375:3:120","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$58249","typeString":"contract FetchChainInfoOutput"}},"id":58568,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"16379:3:120","memberName":"set","nodeType":"MemberAccess","referencedDeclaration":57795,"src":"16375:7:120","typeDescriptions":{"typeIdentifier":"t_function_external_nonpayable$_t_bytes4_$_t_userDefinedValueType$_GameType_$75355_$returns$__$","typeString":"function (bytes4,GameType) external"}},"id":58580,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"16375:72:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":58581,"nodeType":"ExpressionStatement","src":"16375:72:120"},{"assignments":[58583],"declarations":[{"constant":false,"id":58583,"mutability":"mutable","name":"l2OutputOracleProxy","nameLocation":"16469:19:120","nodeType":"VariableDeclaration","scope":58637,"src":"16461:27:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":58582,"name":"address","nodeType":"ElementaryTypeName","src":"16461:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"id":58584,"nodeType":"VariableDeclarationStatement","src":"16461:27:120"},{"clauses":[{"block":{"id":58597,"nodeType":"Block","src":"16575:64:120","statements":[{"expression":{"id":58595,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftHandSide":{"id":58593,"name":"l2OutputOracleProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58583,"src":"16593:19:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"Assignment","operator":"=","rightHandSide":{"id":58594,"name":"l2Oracle_","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58591,"src":"16615:9:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"src":"16593:31:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"id":58596,"nodeType":"ExpressionStatement","src":"16593:31:120"}]},"errorName":"","id":58598,"nodeType":"TryCatchClause","parameters":{"id":58592,"nodeType":"ParameterList","parameters":[{"constant":false,"id":58591,"mutability":"mutable","name":"l2Oracle_","nameLocation":"16564:9:120","nodeType":"VariableDeclaration","scope":58598,"src":"16556:17:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":58590,"name":"address","nodeType":"ElementaryTypeName","src":"16556:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"16555:19:120"},"src":"16547:92:120"},{"block":{"id":58607,"nodeType":"Block","src":"16646:96:120","statements":[{"expression":{"id":58605,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftHandSide":{"id":58599,"name":"l2OutputOracleProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58583,"src":"16664:19:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"Assignment","operator":"=","rightHandSide":{"arguments":[],"expression":{"argumentTypes":[],"expression":{"arguments":[{"id":58601,"name":"optimismPortalProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58541,"src":"16695:19:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_address","typeString":"address"}],"id":58600,"name":"IFetcher","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57326,"src":"16686:8:120","typeDescriptions":{"typeIdentifier":"t_type$_t_contract$_IFetcher_$57326_$","typeString":"type(contract IFetcher)"}},"id":58602,"isConstant":false,"isLValue":false,"isPure":false,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"16686:29:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_contract$_IFetcher_$57326","typeString":"contract IFetcher"}},"id":58603,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"16716:9:120","memberName":"L2_ORACLE","nodeType":"MemberAccess","referencedDeclaration":57270,"src":"16686:39:120","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":58604,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"16686:41:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"src":"16664:63:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"id":58606,"nodeType":"ExpressionStatement","src":"16664:63:120"}]},"errorName":"","id":58608,"nodeType":"TryCatchClause","src":"16640:102:120"}],"externalCall":{"arguments":[],"expression":{"argumentTypes":[],"expression":{"arguments":[{"id":58586,"name":"optimismPortalProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58541,"src":"16515:19:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_address","typeString":"address"}],"id":58585,"name":"IFetcher","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57326,"src":"16506:8:120","typeDescriptions":{"typeIdentifier":"t_type$_t_contract$_IFetcher_$57326_$","typeString":"type(contract IFetcher)"}},"id":58587,"isConstant":false,"isLValue":false,"isPure":false,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"16506:29:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_contract$_IFetcher_$57326","typeString":"contract IFetcher"}},"id":58588,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"16536:8:120","memberName":"l2Oracle","nodeType":"MemberAccess","referencedDeclaration":57275,"src":"16506:38:120","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":58589,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"16506:40:120","tryCall":true,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"id":58609,"nodeType":"TryStatement","src":"16502:240:120"},{"expression":{"arguments":[{"expression":{"expression":{"id":58613,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58531,"src":"16763:3:120","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$58249","typeString":"contract FetchChainInfoOutput"}},"id":58614,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"16767:19:120","memberName":"l2OutputOracleProxy","nodeType":"MemberAccess","referencedDeclaration":57893,"src":"16763:23:120","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":58615,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"16787:8:120","memberName":"selector","nodeType":"MemberAccess","src":"16763:32:120","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},{"id":58616,"name":"l2OutputOracleProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58583,"src":"16797:19:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_bytes4","typeString":"bytes4"},{"typeIdentifier":"t_address","typeString":"address"}],"expression":{"id":58610,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58531,"src":"16755:3:120","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$58249","typeString":"contract FetchChainInfoOutput"}},"id":58612,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"16759:3:120","memberName":"set","nodeType":"MemberAccess","referencedDeclaration":57740,"src":"16755:7:120","typeDescriptions":{"typeIdentifier":"t_function_external_nonpayable$_t_bytes4_$_t_address_$returns$__$","typeString":"function (bytes4,address) external"}},"id":58617,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"16755:62:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":58618,"nodeType":"ExpressionStatement","src":"16755:62:120"},{"assignments":[58620],"declarations":[{"constant":false,"id":58620,"mutability":"mutable","name":"proposer","nameLocation":"16840:8:120","nodeType":"VariableDeclaration","scope":58637,"src":"16832:16:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":58619,"name":"address","nodeType":"ElementaryTypeName","src":"16832:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"id":58626,"initialValue":{"arguments":[],"expression":{"argumentTypes":[],"expression":{"arguments":[{"id":58622,"name":"l2OutputOracleProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58583,"src":"16860:19:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_address","typeString":"address"}],"id":58621,"name":"IFetcher","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57326,"src":"16851:8:120","typeDescriptions":{"typeIdentifier":"t_type$_t_contract$_IFetcher_$57326_$","typeString":"type(contract IFetcher)"}},"id":58623,"isConstant":false,"isLValue":false,"isPure":false,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"16851:29:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_contract$_IFetcher_$57326","typeString":"contract IFetcher"}},"id":58624,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"16881:8:120","memberName":"PROPOSER","nodeType":"MemberAccess","referencedDeclaration":57300,"src":"16851:38:120","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":58625,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"16851:40:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"VariableDeclarationStatement","src":"16832:59:120"},{"expression":{"arguments":[{"expression":{"expression":{"id":58630,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58531,"src":"16913:3:120","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$58249","typeString":"contract FetchChainInfoOutput"}},"id":58631,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"16917:8:120","memberName":"proposer","nodeType":"MemberAccess","referencedDeclaration":58187,"src":"16913:12:120","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":58632,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"16926:8:120","memberName":"selector","nodeType":"MemberAccess","src":"16913:21:120","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},{"id":58633,"name":"proposer","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58620,"src":"16936:8:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_bytes4","typeString":"bytes4"},{"typeIdentifier":"t_address","typeString":"address"}],"expression":{"id":58627,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58531,"src":"16905:3:120","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$58249","typeString":"contract FetchChainInfoOutput"}},"id":58629,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"16909:3:120","memberName":"set","nodeType":"MemberAccess","referencedDeclaration":57740,"src":"16905:7:120","typeDescriptions":{"typeIdentifier":"t_function_external_nonpayable$_t_bytes4_$_t_address_$returns$__$","typeString":"function (bytes4,address) external"}},"id":58634,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"16905:40:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":58635,"nodeType":"ExpressionStatement","src":"16905:40:120"},{"functionReturnParameters":58533,"id":58636,"nodeType":"Return","src":"17015:7:120"}]},"errorName":"","id":58638,"nodeType":"TryCatchClause","src":"16282:750:120"}],"externalCall":{"arguments":[],"expression":{"argumentTypes":[],"expression":{"arguments":[{"id":58547,"name":"optimismPortalProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58541,"src":"16136:19:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_address","typeString":"address"}],"id":58546,"name":"IFetcher","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57326,"src":"16127:8:120","typeDescriptions":{"typeIdentifier":"t_type$_t_contract$_IFetcher_$57326_$","typeString":"type(contract IFetcher)"}},"id":58548,"isConstant":false,"isLValue":false,"isPure":false,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"16127:29:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_contract$_IFetcher_$57326","typeString":"contract IFetcher"}},"id":58549,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"16157:17:120","memberName":"respectedGameType","nodeType":"MemberAccess","referencedDeclaration":57260,"src":"16127:47:120","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_userDefinedValueType$_GameType_$75355_$","typeString":"function () view external returns (GameType)"}},"id":58550,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"16127:49:120","tryCall":true,"typeDescriptions":{"typeIdentifier":"t_userDefinedValueType$_GameType_$75355","typeString":"GameType"}},"id":58639,"nodeType":"TryStatement","src":"16123:909:120"},{"assignments":[58641],"declarations":[{"constant":false,"id":58641,"mutability":"mutable","name":"disputeGameFactoryProxy","nameLocation":"17050:23:120","nodeType":"VariableDeclaration","scope":58877,"src":"17042:31:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":58640,"name":"address","nodeType":"ElementaryTypeName","src":"17042:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"id":58645,"initialValue":{"arguments":[{"id":58643,"name":"systemConfigProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58535,"src":"17104:17:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_address","typeString":"address"}],"id":58642,"name":"_getDisputeGameFactoryProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":59087,"src":"17076:27:120","typeDescriptions":{"typeIdentifier":"t_function_internal_view$_t_address_$returns$_t_address_$","typeString":"function (address) view returns (address)"}},"id":58644,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"17076:46:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"VariableDeclarationStatement","src":"17042:80:120"},{"condition":{"commonType":{"typeIdentifier":"t_address","typeString":"address"},"id":58651,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftExpression":{"id":58646,"name":"disputeGameFactoryProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58641,"src":"17136:23:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"BinaryOperation","operator":"!=","rightExpression":{"arguments":[{"hexValue":"30","id":58649,"isConstant":false,"isLValue":false,"isPure":true,"kind":"number","lValueRequested":false,"nodeType":"Literal","src":"17171:1:120","typeDescriptions":{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"},"value":"0"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"}],"id":58648,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"nodeType":"ElementaryTypeNameExpression","src":"17163:7:120","typeDescriptions":{"typeIdentifier":"t_type$_t_address_$","typeString":"type(address)"},"typeName":{"id":58647,"name":"address","nodeType":"ElementaryTypeName","src":"17163:7:120","typeDescriptions":{}}},"id":58650,"isConstant":false,"isLValue":false,"isPure":true,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"17163:10:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"src":"17136:37:120","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},"falseBody":{"id":58875,"nodeType":"Block","src":"19246:383:120","statements":[{"assignments":[58842],"declarations":[{"constant":false,"id":58842,"mutability":"mutable","name":"l2OutputOracleProxy","nameLocation":"19352:19:120","nodeType":"VariableDeclaration","scope":58875,"src":"19344:27:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":58841,"name":"address","nodeType":"ElementaryTypeName","src":"19344:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"id":58848,"initialValue":{"arguments":[],"expression":{"argumentTypes":[],"expression":{"arguments":[{"id":58844,"name":"optimismPortalProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58541,"src":"19383:19:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_address","typeString":"address"}],"id":58843,"name":"IFetcher","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57326,"src":"19374:8:120","typeDescriptions":{"typeIdentifier":"t_type$_t_contract$_IFetcher_$57326_$","typeString":"type(contract IFetcher)"}},"id":58845,"isConstant":false,"isLValue":false,"isPure":false,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"19374:29:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_contract$_IFetcher_$57326","typeString":"contract IFetcher"}},"id":58846,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"19404:9:120","memberName":"L2_ORACLE","nodeType":"MemberAccess","referencedDeclaration":57270,"src":"19374:39:120","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":58847,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"19374:41:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"VariableDeclarationStatement","src":"19344:71:120"},{"expression":{"arguments":[{"expression":{"expression":{"id":58852,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58531,"src":"19437:3:120","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$58249","typeString":"contract FetchChainInfoOutput"}},"id":58853,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"19441:19:120","memberName":"l2OutputOracleProxy","nodeType":"MemberAccess","referencedDeclaration":57893,"src":"19437:23:120","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":58854,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"19461:8:120","memberName":"selector","nodeType":"MemberAccess","src":"19437:32:120","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},{"id":58855,"name":"l2OutputOracleProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58842,"src":"19471:19:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_bytes4","typeString":"bytes4"},{"typeIdentifier":"t_address","typeString":"address"}],"expression":{"id":58849,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58531,"src":"19429:3:120","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$58249","typeString":"contract FetchChainInfoOutput"}},"id":58851,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"19433:3:120","memberName":"set","nodeType":"MemberAccess","referencedDeclaration":57740,"src":"19429:7:120","typeDescriptions":{"typeIdentifier":"t_function_external_nonpayable$_t_bytes4_$_t_address_$returns$__$","typeString":"function (bytes4,address) external"}},"id":58856,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"19429:62:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":58857,"nodeType":"ExpressionStatement","src":"19429:62:120"},{"assignments":[58859],"declarations":[{"constant":false,"id":58859,"mutability":"mutable","name":"proposer","nameLocation":"19513:8:120","nodeType":"VariableDeclaration","scope":58875,"src":"19505:16:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":58858,"name":"address","nodeType":"ElementaryTypeName","src":"19505:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"id":58865,"initialValue":{"arguments":[],"expression":{"argumentTypes":[],"expression":{"arguments":[{"id":58861,"name":"l2OutputOracleProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58842,"src":"19533:19:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_address","typeString":"address"}],"id":58860,"name":"IFetcher","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57326,"src":"19524:8:120","typeDescriptions":{"typeIdentifier":"t_type$_t_contract$_IFetcher_$57326_$","typeString":"type(contract IFetcher)"}},"id":58862,"isConstant":false,"isLValue":false,"isPure":false,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"19524:29:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_contract$_IFetcher_$57326","typeString":"contract IFetcher"}},"id":58863,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"19554:8:120","memberName":"PROPOSER","nodeType":"MemberAccess","referencedDeclaration":57300,"src":"19524:38:120","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":58864,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"19524:40:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"VariableDeclarationStatement","src":"19505:59:120"},{"expression":{"arguments":[{"expression":{"expression":{"id":58869,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58531,"src":"19586:3:120","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$58249","typeString":"contract FetchChainInfoOutput"}},"id":58870,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"19590:8:120","memberName":"proposer","nodeType":"MemberAccess","referencedDeclaration":58187,"src":"19586:12:120","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":58871,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"19599:8:120","memberName":"selector","nodeType":"MemberAccess","src":"19586:21:120","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},{"id":58872,"name":"proposer","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58859,"src":"19609:8:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_bytes4","typeString":"bytes4"},{"typeIdentifier":"t_address","typeString":"address"}],"expression":{"id":58866,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58531,"src":"19578:3:120","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$58249","typeString":"contract FetchChainInfoOutput"}},"id":58868,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"19582:3:120","memberName":"set","nodeType":"MemberAccess","referencedDeclaration":57740,"src":"19578:7:120","typeDescriptions":{"typeIdentifier":"t_function_external_nonpayable$_t_bytes4_$_t_address_$returns$__$","typeString":"function (bytes4,address) external"}},"id":58873,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"19578:40:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":58874,"nodeType":"ExpressionStatement","src":"19578:40:120"}]},"id":58876,"nodeType":"IfStatement","src":"17132:2497:120","trueBody":{"id":58840,"nodeType":"Block","src":"17175:2065:120","statements":[{"expression":{"arguments":[{"expression":{"expression":{"id":58655,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58531,"src":"17197:3:120","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$58249","typeString":"contract FetchChainInfoOutput"}},"id":58656,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"17201:23:120","memberName":"disputeGameFactoryProxy","nodeType":"MemberAccess","referencedDeclaration":58025,"src":"17197:27:120","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":58657,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"17225:8:120","memberName":"selector","nodeType":"MemberAccess","src":"17197:36:120","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},{"id":58658,"name":"disputeGameFactoryProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58641,"src":"17235:23:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_bytes4","typeString":"bytes4"},{"typeIdentifier":"t_address","typeString":"address"}],"expression":{"id":58652,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58531,"src":"17189:3:120","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$58249","typeString":"contract FetchChainInfoOutput"}},"id":58654,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"17193:3:120","memberName":"set","nodeType":"MemberAccess","referencedDeclaration":57740,"src":"17189:7:120","typeDescriptions":{"typeIdentifier":"t_function_external_nonpayable$_t_bytes4_$_t_address_$returns$__$","typeString":"function (bytes4,address) external"}},"id":58659,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"17189:70:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":58660,"nodeType":"ExpressionStatement","src":"17189:70:120"},{"assignments":[58662],"declarations":[{"constant":false,"id":58662,"mutability":"mutable","name":"permissionedDisputeGameImpl","nameLocation":"17282:27:120","nodeType":"VariableDeclaration","scope":58840,"src":"17274:35:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":58661,"name":"address","nodeType":"ElementaryTypeName","src":"17274:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"id":58666,"initialValue":{"arguments":[{"id":58664,"name":"disputeGameFactoryProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58641,"src":"17340:23:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_address","typeString":"address"}],"id":58663,"name":"_getPermissionedDisputeGame","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":59175,"src":"17312:27:120","typeDescriptions":{"typeIdentifier":"t_function_internal_view$_t_address_$returns$_t_address_$","typeString":"function (address) view returns (address)"}},"id":58665,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"17312:52:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"VariableDeclarationStatement","src":"17274:90:120"},{"condition":{"commonType":{"typeIdentifier":"t_address","typeString":"address"},"id":58672,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftExpression":{"id":58667,"name":"permissionedDisputeGameImpl","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58662,"src":"17382:27:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"BinaryOperation","operator":"!=","rightExpression":{"arguments":[{"hexValue":"30","id":58670,"isConstant":false,"isLValue":false,"isPure":true,"kind":"number","lValueRequested":false,"nodeType":"Literal","src":"17421:1:120","typeDescriptions":{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"},"value":"0"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"}],"id":58669,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"nodeType":"ElementaryTypeNameExpression","src":"17413:7:120","typeDescriptions":{"typeIdentifier":"t_type$_t_address_$","typeString":"type(address)"},"typeName":{"id":58668,"name":"address","nodeType":"ElementaryTypeName","src":"17413:7:120","typeDescriptions":{}}},"id":58671,"isConstant":false,"isLValue":false,"isPure":true,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"17413:10:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"src":"17382:41:120","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},"id":58792,"nodeType":"IfStatement","src":"17378:1278:120","trueBody":{"id":58791,"nodeType":"Block","src":"17425:1231:120","statements":[{"expression":{"arguments":[{"expression":{"expression":{"id":58676,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58531,"src":"17506:3:120","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$58249","typeString":"contract FetchChainInfoOutput"}},"id":58677,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"17510:12:120","memberName":"permissioned","nodeType":"MemberAccess","referencedDeclaration":58231,"src":"17506:16:120","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_bool_$","typeString":"function () view external returns (bool)"}},"id":58678,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"17523:8:120","memberName":"selector","nodeType":"MemberAccess","src":"17506:25:120","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},{"hexValue":"74727565","id":58679,"isConstant":false,"isLValue":false,"isPure":true,"kind":"bool","lValueRequested":false,"nodeType":"Literal","src":"17533:4:120","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"},"value":"true"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_bytes4","typeString":"bytes4"},{"typeIdentifier":"t_bool","typeString":"bool"}],"expression":{"id":58673,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58531,"src":"17498:3:120","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$58249","typeString":"contract FetchChainInfoOutput"}},"id":58675,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"17502:3:120","memberName":"set","nodeType":"MemberAccess","referencedDeclaration":57772,"src":"17498:7:120","typeDescriptions":{"typeIdentifier":"t_function_external_nonpayable$_t_bytes4_$_t_bool_$returns$__$","typeString":"function (bytes4,bool) external"}},"id":58680,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"17498:40:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":58681,"nodeType":"ExpressionStatement","src":"17498:40:120"},{"expression":{"arguments":[{"expression":{"expression":{"id":58685,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58531,"src":"17564:3:120","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$58249","typeString":"contract FetchChainInfoOutput"}},"id":58686,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"17568:27:120","memberName":"permissionedDisputeGameImpl","nodeType":"MemberAccess","referencedDeclaration":58079,"src":"17564:31:120","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":58687,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"17596:8:120","memberName":"selector","nodeType":"MemberAccess","src":"17564:40:120","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},{"id":58688,"name":"permissionedDisputeGameImpl","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58662,"src":"17606:27:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_bytes4","typeString":"bytes4"},{"typeIdentifier":"t_address","typeString":"address"}],"expression":{"id":58682,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58531,"src":"17556:3:120","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$58249","typeString":"contract FetchChainInfoOutput"}},"id":58684,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"17560:3:120","memberName":"set","nodeType":"MemberAccess","referencedDeclaration":57740,"src":"17556:7:120","typeDescriptions":{"typeIdentifier":"t_function_external_nonpayable$_t_bytes4_$_t_address_$returns$__$","typeString":"function (bytes4,address) external"}},"id":58689,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"17556:78:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":58690,"nodeType":"ExpressionStatement","src":"17556:78:120"},{"assignments":[58692],"declarations":[{"constant":false,"id":58692,"mutability":"mutable","name":"challenger","nameLocation":"17661:10:120","nodeType":"VariableDeclaration","scope":58791,"src":"17653:18:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":58691,"name":"address","nodeType":"ElementaryTypeName","src":"17653:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"id":58698,"initialValue":{"arguments":[],"expression":{"argumentTypes":[],"expression":{"arguments":[{"id":58694,"name":"permissionedDisputeGameImpl","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58662,"src":"17683:27:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_address","typeString":"address"}],"id":58693,"name":"IFetcher","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57326,"src":"17674:8:120","typeDescriptions":{"typeIdentifier":"t_type$_t_contract$_IFetcher_$57326_$","typeString":"type(contract IFetcher)"}},"id":58695,"isConstant":false,"isLValue":false,"isPure":false,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"17674:37:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_contract$_IFetcher_$57326","typeString":"contract IFetcher"}},"id":58696,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"17712:10:120","memberName":"challenger","nodeType":"MemberAccess","referencedDeclaration":57290,"src":"17674:48:120","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":58697,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"17674:50:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"VariableDeclarationStatement","src":"17653:71:120"},{"expression":{"arguments":[{"expression":{"expression":{"id":58702,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58531,"src":"17750:3:120","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$58249","typeString":"contract FetchChainInfoOutput"}},"id":58703,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"17754:10:120","memberName":"challenger","nodeType":"MemberAccess","referencedDeclaration":58169,"src":"17750:14:120","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":58704,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"17765:8:120","memberName":"selector","nodeType":"MemberAccess","src":"17750:23:120","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},{"id":58705,"name":"challenger","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58692,"src":"17775:10:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_bytes4","typeString":"bytes4"},{"typeIdentifier":"t_address","typeString":"address"}],"expression":{"id":58699,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58531,"src":"17742:3:120","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$58249","typeString":"contract FetchChainInfoOutput"}},"id":58701,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"17746:3:120","memberName":"set","nodeType":"MemberAccess","referencedDeclaration":57740,"src":"17742:7:120","typeDescriptions":{"typeIdentifier":"t_function_external_nonpayable$_t_bytes4_$_t_address_$returns$__$","typeString":"function (bytes4,address) external"}},"id":58706,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"17742:44:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":58707,"nodeType":"ExpressionStatement","src":"17742:44:120"},{"assignments":[58709],"declarations":[{"constant":false,"id":58709,"mutability":"mutable","name":"anchorStateRegistryProxy","nameLocation":"17813:24:120","nodeType":"VariableDeclaration","scope":58791,"src":"17805:32:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":58708,"name":"address","nodeType":"ElementaryTypeName","src":"17805:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"id":58715,"initialValue":{"arguments":[],"expression":{"argumentTypes":[],"expression":{"arguments":[{"id":58711,"name":"permissionedDisputeGameImpl","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58662,"src":"17849:27:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_address","typeString":"address"}],"id":58710,"name":"IFetcher","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57326,"src":"17840:8:120","typeDescriptions":{"typeIdentifier":"t_type$_t_contract$_IFetcher_$57326_$","typeString":"type(contract IFetcher)"}},"id":58712,"isConstant":false,"isLValue":false,"isPure":false,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"17840:37:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_contract$_IFetcher_$57326","typeString":"contract IFetcher"}},"id":58713,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"17878:19:120","memberName":"anchorStateRegistry","nodeType":"MemberAccess","referencedDeclaration":57265,"src":"17840:57:120","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":58714,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"17840:59:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"VariableDeclarationStatement","src":"17805:94:120"},{"expression":{"arguments":[{"expression":{"expression":{"id":58719,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58531,"src":"17925:3:120","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$58249","typeString":"contract FetchChainInfoOutput"}},"id":58720,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"17929:24:120","memberName":"anchorStateRegistryProxy","nodeType":"MemberAccess","referencedDeclaration":58001,"src":"17925:28:120","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":58721,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"17954:8:120","memberName":"selector","nodeType":"MemberAccess","src":"17925:37:120","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},{"id":58722,"name":"anchorStateRegistryProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58709,"src":"17964:24:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_bytes4","typeString":"bytes4"},{"typeIdentifier":"t_address","typeString":"address"}],"expression":{"id":58716,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58531,"src":"17917:3:120","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$58249","typeString":"contract FetchChainInfoOutput"}},"id":58718,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"17921:3:120","memberName":"set","nodeType":"MemberAccess","referencedDeclaration":57740,"src":"17917:7:120","typeDescriptions":{"typeIdentifier":"t_function_external_nonpayable$_t_bytes4_$_t_address_$returns$__$","typeString":"function (bytes4,address) external"}},"id":58723,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"17917:72:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":58724,"nodeType":"ExpressionStatement","src":"17917:72:120"},{"assignments":[58726],"declarations":[{"constant":false,"id":58726,"mutability":"mutable","name":"proposer","nameLocation":"18016:8:120","nodeType":"VariableDeclaration","scope":58791,"src":"18008:16:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":58725,"name":"address","nodeType":"ElementaryTypeName","src":"18008:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"id":58732,"initialValue":{"arguments":[],"expression":{"argumentTypes":[],"expression":{"arguments":[{"id":58728,"name":"permissionedDisputeGameImpl","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58662,"src":"18036:27:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_address","typeString":"address"}],"id":58727,"name":"IFetcher","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57326,"src":"18027:8:120","typeDescriptions":{"typeIdentifier":"t_type$_t_contract$_IFetcher_$57326_$","typeString":"type(contract IFetcher)"}},"id":58729,"isConstant":false,"isLValue":false,"isPure":false,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"18027:37:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_contract$_IFetcher_$57326","typeString":"contract IFetcher"}},"id":58730,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"18065:8:120","memberName":"proposer","nodeType":"MemberAccess","referencedDeclaration":57295,"src":"18027:46:120","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":58731,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"18027:48:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"VariableDeclarationStatement","src":"18008:67:120"},{"expression":{"arguments":[{"expression":{"expression":{"id":58736,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58531,"src":"18101:3:120","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$58249","typeString":"contract FetchChainInfoOutput"}},"id":58737,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"18105:8:120","memberName":"proposer","nodeType":"MemberAccess","referencedDeclaration":58187,"src":"18101:12:120","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":58738,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"18114:8:120","memberName":"selector","nodeType":"MemberAccess","src":"18101:21:120","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},{"id":58739,"name":"proposer","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58726,"src":"18124:8:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_bytes4","typeString":"bytes4"},{"typeIdentifier":"t_address","typeString":"address"}],"expression":{"id":58733,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58531,"src":"18093:3:120","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$58249","typeString":"contract FetchChainInfoOutput"}},"id":58735,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"18097:3:120","memberName":"set","nodeType":"MemberAccess","referencedDeclaration":57740,"src":"18093:7:120","typeDescriptions":{"typeIdentifier":"t_function_external_nonpayable$_t_bytes4_$_t_address_$returns$__$","typeString":"function (bytes4,address) external"}},"id":58740,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"18093:40:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":58741,"nodeType":"ExpressionStatement","src":"18093:40:120"},{"assignments":[58743],"declarations":[{"constant":false,"id":58743,"mutability":"mutable","name":"delayedWethPermissionedGameProxy","nameLocation":"18160:32:120","nodeType":"VariableDeclaration","scope":58791,"src":"18152:40:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":58742,"name":"address","nodeType":"ElementaryTypeName","src":"18152:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"id":58747,"initialValue":{"arguments":[{"id":58745,"name":"permissionedDisputeGameImpl","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58662,"src":"18216:27:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_address","typeString":"address"}],"id":58744,"name":"_getDelayedWETHProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":59248,"src":"18195:20:120","typeDescriptions":{"typeIdentifier":"t_function_internal_view$_t_address_$returns$_t_address_$","typeString":"function (address) view returns (address)"}},"id":58746,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"18195:49:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"VariableDeclarationStatement","src":"18152:92:120"},{"expression":{"arguments":[{"expression":{"expression":{"id":58751,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58531,"src":"18270:3:120","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$58249","typeString":"contract FetchChainInfoOutput"}},"id":58752,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"18274:32:120","memberName":"delayedWethPermissionedGameProxy","nodeType":"MemberAccess","referencedDeclaration":58009,"src":"18270:36:120","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":58753,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"18307:8:120","memberName":"selector","nodeType":"MemberAccess","src":"18270:45:120","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},{"id":58754,"name":"delayedWethPermissionedGameProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58743,"src":"18317:32:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_bytes4","typeString":"bytes4"},{"typeIdentifier":"t_address","typeString":"address"}],"expression":{"id":58748,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58531,"src":"18262:3:120","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$58249","typeString":"contract FetchChainInfoOutput"}},"id":58750,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"18266:3:120","memberName":"set","nodeType":"MemberAccess","referencedDeclaration":57740,"src":"18262:7:120","typeDescriptions":{"typeIdentifier":"t_function_external_nonpayable$_t_bytes4_$_t_address_$returns$__$","typeString":"function (bytes4,address) external"}},"id":58755,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"18262:88:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":58756,"nodeType":"ExpressionStatement","src":"18262:88:120"},{"assignments":[58758],"declarations":[{"constant":false,"id":58758,"mutability":"mutable","name":"mipsImpl","nameLocation":"18377:8:120","nodeType":"VariableDeclaration","scope":58791,"src":"18369:16:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":58757,"name":"address","nodeType":"ElementaryTypeName","src":"18369:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"id":58764,"initialValue":{"arguments":[],"expression":{"argumentTypes":[],"expression":{"arguments":[{"id":58760,"name":"permissionedDisputeGameImpl","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58662,"src":"18397:27:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_address","typeString":"address"}],"id":58759,"name":"IFetcher","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57326,"src":"18388:8:120","typeDescriptions":{"typeIdentifier":"t_type$_t_contract$_IFetcher_$57326_$","typeString":"type(contract IFetcher)"}},"id":58761,"isConstant":false,"isLValue":false,"isPure":false,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"18388:37:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_contract$_IFetcher_$57326","typeString":"contract IFetcher"}},"id":58762,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"18426:2:120","memberName":"vm","nodeType":"MemberAccess","referencedDeclaration":57280,"src":"18388:40:120","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":58763,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"18388:42:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"VariableDeclarationStatement","src":"18369:61:120"},{"expression":{"arguments":[{"expression":{"expression":{"id":58768,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58531,"src":"18456:3:120","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$58249","typeString":"contract FetchChainInfoOutput"}},"id":58769,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"18460:8:120","memberName":"mipsImpl","nodeType":"MemberAccess","referencedDeclaration":58061,"src":"18456:12:120","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":58770,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"18469:8:120","memberName":"selector","nodeType":"MemberAccess","src":"18456:21:120","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},{"id":58771,"name":"mipsImpl","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58758,"src":"18479:8:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_bytes4","typeString":"bytes4"},{"typeIdentifier":"t_address","typeString":"address"}],"expression":{"id":58765,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58531,"src":"18448:3:120","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$58249","typeString":"contract FetchChainInfoOutput"}},"id":58767,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"18452:3:120","memberName":"set","nodeType":"MemberAccess","referencedDeclaration":57740,"src":"18448:7:120","typeDescriptions":{"typeIdentifier":"t_function_external_nonpayable$_t_bytes4_$_t_address_$returns$__$","typeString":"function (bytes4,address) external"}},"id":58772,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"18448:40:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":58773,"nodeType":"ExpressionStatement","src":"18448:40:120"},{"assignments":[58775],"declarations":[{"constant":false,"id":58775,"mutability":"mutable","name":"preimageOracleImpl","nameLocation":"18515:18:120","nodeType":"VariableDeclaration","scope":58791,"src":"18507:26:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":58774,"name":"address","nodeType":"ElementaryTypeName","src":"18507:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"id":58781,"initialValue":{"arguments":[],"expression":{"argumentTypes":[],"expression":{"arguments":[{"id":58777,"name":"mipsImpl","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58758,"src":"18545:8:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_address","typeString":"address"}],"id":58776,"name":"IFetcher","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57326,"src":"18536:8:120","typeDescriptions":{"typeIdentifier":"t_type$_t_contract$_IFetcher_$57326_$","typeString":"type(contract IFetcher)"}},"id":58778,"isConstant":false,"isLValue":false,"isPure":false,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"18536:18:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_contract$_IFetcher_$57326","typeString":"contract IFetcher"}},"id":58779,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"18555:6:120","memberName":"oracle","nodeType":"MemberAccess","referencedDeclaration":57285,"src":"18536:25:120","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":58780,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"18536:27:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"VariableDeclarationStatement","src":"18507:56:120"},{"expression":{"arguments":[{"expression":{"expression":{"id":58785,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58531,"src":"18589:3:120","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$58249","typeString":"contract FetchChainInfoOutput"}},"id":58786,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"18593:18:120","memberName":"preimageOracleImpl","nodeType":"MemberAccess","referencedDeclaration":58097,"src":"18589:22:120","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":58787,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"18612:8:120","memberName":"selector","nodeType":"MemberAccess","src":"18589:31:120","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},{"id":58788,"name":"preimageOracleImpl","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58775,"src":"18622:18:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_bytes4","typeString":"bytes4"},{"typeIdentifier":"t_address","typeString":"address"}],"expression":{"id":58782,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58531,"src":"18581:3:120","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$58249","typeString":"contract FetchChainInfoOutput"}},"id":58784,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"18585:3:120","memberName":"set","nodeType":"MemberAccess","referencedDeclaration":57740,"src":"18581:7:120","typeDescriptions":{"typeIdentifier":"t_function_external_nonpayable$_t_bytes4_$_t_address_$returns$__$","typeString":"function (bytes4,address) external"}},"id":58789,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"18581:60:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":58790,"nodeType":"ExpressionStatement","src":"18581:60:120"}]}},{"assignments":[58794],"declarations":[{"constant":false,"id":58794,"mutability":"mutable","name":"faultDisputeGameImpl","nameLocation":"18678:20:120","nodeType":"VariableDeclaration","scope":58840,"src":"18670:28:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":58793,"name":"address","nodeType":"ElementaryTypeName","src":"18670:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"id":58798,"initialValue":{"arguments":[{"id":58796,"name":"disputeGameFactoryProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58641,"src":"18722:23:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_address","typeString":"address"}],"id":58795,"name":"_getFaultDisputeGame","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":59145,"src":"18701:20:120","typeDescriptions":{"typeIdentifier":"t_function_internal_view$_t_address_$returns$_t_address_$","typeString":"function (address) view returns (address)"}},"id":58797,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"18701:45:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"VariableDeclarationStatement","src":"18670:76:120"},{"condition":{"commonType":{"typeIdentifier":"t_address","typeString":"address"},"id":58804,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftExpression":{"id":58799,"name":"faultDisputeGameImpl","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58794,"src":"18764:20:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"BinaryOperation","operator":"!=","rightExpression":{"arguments":[{"hexValue":"30","id":58802,"isConstant":false,"isLValue":false,"isPure":true,"kind":"number","lValueRequested":false,"nodeType":"Literal","src":"18796:1:120","typeDescriptions":{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"},"value":"0"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"}],"id":58801,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"nodeType":"ElementaryTypeNameExpression","src":"18788:7:120","typeDescriptions":{"typeIdentifier":"t_type$_t_address_$","typeString":"type(address)"},"typeName":{"id":58800,"name":"address","nodeType":"ElementaryTypeName","src":"18788:7:120","typeDescriptions":{}}},"id":58803,"isConstant":false,"isLValue":false,"isPure":true,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"18788:10:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"src":"18764:34:120","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},"id":58839,"nodeType":"IfStatement","src":"18760:470:120","trueBody":{"id":58838,"nodeType":"Block","src":"18800:430:120","statements":[{"expression":{"arguments":[{"expression":{"expression":{"id":58808,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58531,"src":"18883:3:120","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$58249","typeString":"contract FetchChainInfoOutput"}},"id":58809,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"18887:20:120","memberName":"faultDisputeGameImpl","nodeType":"MemberAccess","referencedDeclaration":58043,"src":"18883:24:120","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":58810,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"18908:8:120","memberName":"selector","nodeType":"MemberAccess","src":"18883:33:120","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},{"id":58811,"name":"faultDisputeGameImpl","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58794,"src":"18918:20:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_bytes4","typeString":"bytes4"},{"typeIdentifier":"t_address","typeString":"address"}],"expression":{"id":58805,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58531,"src":"18875:3:120","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$58249","typeString":"contract FetchChainInfoOutput"}},"id":58807,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"18879:3:120","memberName":"set","nodeType":"MemberAccess","referencedDeclaration":57740,"src":"18875:7:120","typeDescriptions":{"typeIdentifier":"t_function_external_nonpayable$_t_bytes4_$_t_address_$returns$__$","typeString":"function (bytes4,address) external"}},"id":58812,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"18875:64:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":58813,"nodeType":"ExpressionStatement","src":"18875:64:120"},{"expression":{"arguments":[{"expression":{"expression":{"id":58817,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58531,"src":"18965:3:120","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$58249","typeString":"contract FetchChainInfoOutput"}},"id":58818,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"18969:14:120","memberName":"permissionless","nodeType":"MemberAccess","referencedDeclaration":58239,"src":"18965:18:120","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_bool_$","typeString":"function () view external returns (bool)"}},"id":58819,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"18984:8:120","memberName":"selector","nodeType":"MemberAccess","src":"18965:27:120","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},{"hexValue":"74727565","id":58820,"isConstant":false,"isLValue":false,"isPure":true,"kind":"bool","lValueRequested":false,"nodeType":"Literal","src":"18994:4:120","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"},"value":"true"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_bytes4","typeString":"bytes4"},{"typeIdentifier":"t_bool","typeString":"bool"}],"expression":{"id":58814,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58531,"src":"18957:3:120","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$58249","typeString":"contract FetchChainInfoOutput"}},"id":58816,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"18961:3:120","memberName":"set","nodeType":"MemberAccess","referencedDeclaration":57772,"src":"18957:7:120","typeDescriptions":{"typeIdentifier":"t_function_external_nonpayable$_t_bytes4_$_t_bool_$returns$__$","typeString":"function (bytes4,bool) external"}},"id":58821,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"18957:42:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":58822,"nodeType":"ExpressionStatement","src":"18957:42:120"},{"assignments":[58824],"declarations":[{"constant":false,"id":58824,"mutability":"mutable","name":"delayedWethPermissionlessGameProxy","nameLocation":"19026:34:120","nodeType":"VariableDeclaration","scope":58838,"src":"19018:42:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":58823,"name":"address","nodeType":"ElementaryTypeName","src":"19018:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"id":58828,"initialValue":{"arguments":[{"id":58826,"name":"faultDisputeGameImpl","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58794,"src":"19084:20:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_address","typeString":"address"}],"id":58825,"name":"_getDelayedWETHProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":59248,"src":"19063:20:120","typeDescriptions":{"typeIdentifier":"t_function_internal_view$_t_address_$returns$_t_address_$","typeString":"function (address) view returns (address)"}},"id":58827,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"19063:42:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"VariableDeclarationStatement","src":"19018:87:120"},{"expression":{"arguments":[{"expression":{"expression":{"id":58832,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58531,"src":"19131:3:120","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$58249","typeString":"contract FetchChainInfoOutput"}},"id":58833,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"19135:34:120","memberName":"delayedWethPermissionlessGameProxy","nodeType":"MemberAccess","referencedDeclaration":58017,"src":"19131:38:120","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":58834,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"19170:8:120","memberName":"selector","nodeType":"MemberAccess","src":"19131:47:120","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},{"id":58835,"name":"delayedWethPermissionlessGameProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58824,"src":"19180:34:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_bytes4","typeString":"bytes4"},{"typeIdentifier":"t_address","typeString":"address"}],"expression":{"id":58829,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58531,"src":"19123:3:120","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$58249","typeString":"contract FetchChainInfoOutput"}},"id":58831,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"19127:3:120","memberName":"set","nodeType":"MemberAccess","referencedDeclaration":57740,"src":"19123:7:120","typeDescriptions":{"typeIdentifier":"t_function_external_nonpayable$_t_bytes4_$_t_address_$returns$__$","typeString":"function (bytes4,address) external"}},"id":58836,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"19123:92:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":58837,"nodeType":"ExpressionStatement","src":"19123:92:120"}]}}]}}]},"implemented":true,"kind":"function","modifiers":[],"name":"_processFaultProofs","nameLocation":"15931:19:120","parameters":{"id":58532,"nodeType":"ParameterList","parameters":[{"constant":false,"id":58531,"mutability":"mutable","name":"_fo","nameLocation":"15972:3:120","nodeType":"VariableDeclaration","scope":58878,"src":"15951:24:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$58249","typeString":"contract FetchChainInfoOutput"},"typeName":{"id":58530,"nodeType":"UserDefinedTypeName","pathNode":{"id":58529,"name":"FetchChainInfoOutput","nameLocations":["15951:20:120"],"nodeType":"IdentifierPath","referencedDeclaration":58249,"src":"15951:20:120"},"referencedDeclaration":58249,"src":"15951:20:120","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$58249","typeString":"contract FetchChainInfoOutput"}},"visibility":"internal"}],"src":"15950:26:120"},"returnParameters":{"id":58533,"nodeType":"ParameterList","parameters":[],"src":"15986:0:120"},"scope":59299,"stateMutability":"nonpayable","virtual":false,"visibility":"internal"},{"id":58907,"nodeType":"FunctionDefinition","src":"19641:256:120","nodes":[],"body":{"id":58906,"nodeType":"Block","src":"19712:185:120","nodes":[],"statements":[{"clauses":[{"block":{"id":58895,"nodeType":"Block","src":"19783:41:120","statements":[{"expression":{"id":58893,"name":"guardian_","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58891,"src":"19804:9:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"functionReturnParameters":58884,"id":58894,"nodeType":"Return","src":"19797:16:120"}]},"errorName":"","id":58896,"nodeType":"TryCatchClause","parameters":{"id":58892,"nodeType":"ParameterList","parameters":[{"constant":false,"id":58891,"mutability":"mutable","name":"guardian_","nameLocation":"19772:9:120","nodeType":"VariableDeclaration","scope":58896,"src":"19764:17:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":58890,"name":"address","nodeType":"ElementaryTypeName","src":"19764:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"19763:19:120"},"src":"19755:69:120"},{"block":{"id":58903,"nodeType":"Block","src":"19831:60:120","statements":[{"expression":{"arguments":[],"expression":{"argumentTypes":[],"expression":{"arguments":[{"id":58898,"name":"_portal","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58880,"src":"19861:7:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_address","typeString":"address"}],"id":58897,"name":"IFetcher","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57326,"src":"19852:8:120","typeDescriptions":{"typeIdentifier":"t_type$_t_contract$_IFetcher_$57326_$","typeString":"type(contract IFetcher)"}},"id":58899,"isConstant":false,"isLValue":false,"isPure":false,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"19852:17:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_contract$_IFetcher_$57326","typeString":"contract IFetcher"}},"id":58900,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"19870:8:120","memberName":"GUARDIAN","nodeType":"MemberAccess","referencedDeclaration":57191,"src":"19852:26:120","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":58901,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"19852:28:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"functionReturnParameters":58884,"id":58902,"nodeType":"Return","src":"19845:35:120"}]},"errorName":"","id":58904,"nodeType":"TryCatchClause","src":"19825:66:120"}],"externalCall":{"arguments":[],"expression":{"argumentTypes":[],"expression":{"arguments":[{"id":58886,"name":"_portal","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58880,"src":"19735:7:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_address","typeString":"address"}],"id":58885,"name":"IFetcher","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57326,"src":"19726:8:120","typeDescriptions":{"typeIdentifier":"t_type$_t_contract$_IFetcher_$57326_$","typeString":"type(contract IFetcher)"}},"id":58887,"isConstant":false,"isLValue":false,"isPure":false,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"19726:17:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_contract$_IFetcher_$57326","typeString":"contract IFetcher"}},"id":58888,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"19744:8:120","memberName":"guardian","nodeType":"MemberAccess","referencedDeclaration":57186,"src":"19726:26:120","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":58889,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"19726:28:120","tryCall":true,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"id":58905,"nodeType":"TryStatement","src":"19722:169:120"}]},"implemented":true,"kind":"function","modifiers":[],"name":"_getGuardian","nameLocation":"19650:12:120","parameters":{"id":58881,"nodeType":"ParameterList","parameters":[{"constant":false,"id":58880,"mutability":"mutable","name":"_portal","nameLocation":"19671:7:120","nodeType":"VariableDeclaration","scope":58907,"src":"19663:15:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":58879,"name":"address","nodeType":"ElementaryTypeName","src":"19663:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"19662:17:120"},"returnParameters":{"id":58884,"nodeType":"ParameterList","parameters":[{"constant":false,"id":58883,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":58907,"src":"19703:7:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":58882,"name":"address","nodeType":"ElementaryTypeName","src":"19703:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"19702:9:120"},"scope":59299,"stateMutability":"view","virtual":false,"visibility":"internal"},{"id":58936,"nodeType":"FunctionDefinition","src":"19903:282:120","nodes":[],"body":{"id":58935,"nodeType":"Block","src":"19983:202:120","nodes":[],"statements":[{"clauses":[{"block":{"id":58924,"nodeType":"Block","src":"20062:45:120","statements":[{"expression":{"id":58922,"name":"systemConfig_","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58920,"src":"20083:13:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"functionReturnParameters":58913,"id":58923,"nodeType":"Return","src":"20076:20:120"}]},"errorName":"","id":58925,"nodeType":"TryCatchClause","parameters":{"id":58921,"nodeType":"ParameterList","parameters":[{"constant":false,"id":58920,"mutability":"mutable","name":"systemConfig_","nameLocation":"20047:13:120","nodeType":"VariableDeclaration","scope":58925,"src":"20039:21:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":58919,"name":"address","nodeType":"ElementaryTypeName","src":"20039:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"20038:23:120"},"src":"20030:77:120"},{"block":{"id":58932,"nodeType":"Block","src":"20114:65:120","statements":[{"expression":{"arguments":[],"expression":{"argumentTypes":[],"expression":{"arguments":[{"id":58927,"name":"_portal","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58909,"src":"20144:7:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_address","typeString":"address"}],"id":58926,"name":"IFetcher","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57326,"src":"20135:8:120","typeDescriptions":{"typeIdentifier":"t_type$_t_contract$_IFetcher_$57326_$","typeString":"type(contract IFetcher)"}},"id":58928,"isConstant":false,"isLValue":false,"isPure":false,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"20135:17:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_contract$_IFetcher_$57326","typeString":"contract IFetcher"}},"id":58929,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"20153:13:120","memberName":"SYSTEM_CONFIG","nodeType":"MemberAccess","referencedDeclaration":57201,"src":"20135:31:120","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":58930,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"20135:33:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"functionReturnParameters":58913,"id":58931,"nodeType":"Return","src":"20128:40:120"}]},"errorName":"","id":58933,"nodeType":"TryCatchClause","src":"20108:71:120"}],"externalCall":{"arguments":[],"expression":{"argumentTypes":[],"expression":{"arguments":[{"id":58915,"name":"_portal","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58909,"src":"20006:7:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_address","typeString":"address"}],"id":58914,"name":"IFetcher","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57326,"src":"19997:8:120","typeDescriptions":{"typeIdentifier":"t_type$_t_contract$_IFetcher_$57326_$","typeString":"type(contract IFetcher)"}},"id":58916,"isConstant":false,"isLValue":false,"isPure":false,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"19997:17:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_contract$_IFetcher_$57326","typeString":"contract IFetcher"}},"id":58917,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"20015:12:120","memberName":"systemConfig","nodeType":"MemberAccess","referencedDeclaration":57196,"src":"19997:30:120","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":58918,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"19997:32:120","tryCall":true,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"id":58934,"nodeType":"TryStatement","src":"19993:186:120"}]},"implemented":true,"kind":"function","modifiers":[],"name":"_getSystemConfigProxy","nameLocation":"19912:21:120","parameters":{"id":58910,"nodeType":"ParameterList","parameters":[{"constant":false,"id":58909,"mutability":"mutable","name":"_portal","nameLocation":"19942:7:120","nodeType":"VariableDeclaration","scope":58936,"src":"19934:15:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":58908,"name":"address","nodeType":"ElementaryTypeName","src":"19934:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"19933:17:120"},"returnParameters":{"id":58913,"nodeType":"ParameterList","parameters":[{"constant":false,"id":58912,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":58936,"src":"19974:7:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":58911,"name":"address","nodeType":"ElementaryTypeName","src":"19974:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"19973:9:120"},"scope":59299,"stateMutability":"view","virtual":false,"visibility":"internal"},{"id":58965,"nodeType":"FunctionDefinition","src":"20191:338:120","nodes":[],"body":{"id":58964,"nodeType":"Block","src":"20294:235:120","nodes":[],"statements":[{"clauses":[{"block":{"id":58953,"nodeType":"Block","src":"20390:47:120","statements":[{"expression":{"id":58951,"name":"optimismPortal_","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58949,"src":"20411:15:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"functionReturnParameters":58942,"id":58952,"nodeType":"Return","src":"20404:22:120"}]},"errorName":"","id":58954,"nodeType":"TryCatchClause","parameters":{"id":58950,"nodeType":"ParameterList","parameters":[{"constant":false,"id":58949,"mutability":"mutable","name":"optimismPortal_","nameLocation":"20373:15:120","nodeType":"VariableDeclaration","scope":58954,"src":"20365:23:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":58948,"name":"address","nodeType":"ElementaryTypeName","src":"20365:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"20364:25:120"},"src":"20356:81:120"},{"block":{"id":58961,"nodeType":"Block","src":"20444:79:120","statements":[{"expression":{"arguments":[],"expression":{"argumentTypes":[],"expression":{"arguments":[{"id":58956,"name":"_l1CrossDomainMessengerProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58938,"src":"20474:28:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_address","typeString":"address"}],"id":58955,"name":"IFetcher","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57326,"src":"20465:8:120","typeDescriptions":{"typeIdentifier":"t_type$_t_contract$_IFetcher_$57326_$","typeString":"type(contract IFetcher)"}},"id":58957,"isConstant":false,"isLValue":false,"isPure":false,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"20465:38:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_contract$_IFetcher_$57326","typeString":"contract IFetcher"}},"id":58958,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"20504:6:120","memberName":"PORTAL","nodeType":"MemberAccess","referencedDeclaration":57231,"src":"20465:45:120","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":58959,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"20465:47:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"functionReturnParameters":58942,"id":58960,"nodeType":"Return","src":"20458:54:120"}]},"errorName":"","id":58962,"nodeType":"TryCatchClause","src":"20438:85:120"}],"externalCall":{"arguments":[],"expression":{"argumentTypes":[],"expression":{"arguments":[{"id":58944,"name":"_l1CrossDomainMessengerProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58938,"src":"20317:28:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_address","typeString":"address"}],"id":58943,"name":"IFetcher","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57326,"src":"20308:8:120","typeDescriptions":{"typeIdentifier":"t_type$_t_contract$_IFetcher_$57326_$","typeString":"type(contract IFetcher)"}},"id":58945,"isConstant":false,"isLValue":false,"isPure":false,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"20308:38:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_contract$_IFetcher_$57326","typeString":"contract IFetcher"}},"id":58946,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"20347:6:120","memberName":"portal","nodeType":"MemberAccess","referencedDeclaration":57236,"src":"20308:45:120","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":58947,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"20308:47:120","tryCall":true,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"id":58963,"nodeType":"TryStatement","src":"20304:219:120"}]},"implemented":true,"kind":"function","modifiers":[],"name":"_getOptimismPortalProxy","nameLocation":"20200:23:120","parameters":{"id":58939,"nodeType":"ParameterList","parameters":[{"constant":false,"id":58938,"mutability":"mutable","name":"_l1CrossDomainMessengerProxy","nameLocation":"20232:28:120","nodeType":"VariableDeclaration","scope":58965,"src":"20224:36:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":58937,"name":"address","nodeType":"ElementaryTypeName","src":"20224:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"20223:38:120"},"returnParameters":{"id":58942,"nodeType":"ParameterList","parameters":[{"constant":false,"id":58941,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":58965,"src":"20285:7:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":58940,"name":"address","nodeType":"ElementaryTypeName","src":"20285:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"20284:9:120"},"scope":59299,"stateMutability":"view","virtual":false,"visibility":"internal"},{"id":59003,"nodeType":"FunctionDefinition","src":"20535:350:120","nodes":[],"body":{"id":59002,"nodeType":"Block","src":"20633:252:120","nodes":[],"statements":[{"assignments":[58973],"declarations":[{"constant":false,"id":58973,"mutability":"mutable","name":"ADDRESS_MANAGER_MAPPING_SLOT","nameLocation":"20651:28:120","nodeType":"VariableDeclaration","scope":59002,"src":"20643:36:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_uint256","typeString":"uint256"},"typeName":{"id":58972,"name":"uint256","nodeType":"ElementaryTypeName","src":"20643:7:120","typeDescriptions":{"typeIdentifier":"t_uint256","typeString":"uint256"}},"visibility":"internal"}],"id":58975,"initialValue":{"hexValue":"31","id":58974,"isConstant":false,"isLValue":false,"isPure":true,"kind":"number","lValueRequested":false,"nodeType":"Literal","src":"20682:1:120","typeDescriptions":{"typeIdentifier":"t_rational_1_by_1","typeString":"int_const 1"},"value":"1"},"nodeType":"VariableDeclarationStatement","src":"20643:40:120"},{"assignments":[58977],"declarations":[{"constant":false,"id":58977,"mutability":"mutable","name":"slot","nameLocation":"20701:4:120","nodeType":"VariableDeclaration","scope":59002,"src":"20693:12:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_bytes32","typeString":"bytes32"},"typeName":{"id":58976,"name":"bytes32","nodeType":"ElementaryTypeName","src":"20693:7:120","typeDescriptions":{"typeIdentifier":"t_bytes32","typeString":"bytes32"}},"visibility":"internal"}],"id":58985,"initialValue":{"arguments":[{"arguments":[{"id":58981,"name":"_l1CrossDomainMessengerProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58967,"src":"20729:28:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},{"id":58982,"name":"ADDRESS_MANAGER_MAPPING_SLOT","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58973,"src":"20759:28:120","typeDescriptions":{"typeIdentifier":"t_uint256","typeString":"uint256"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_address","typeString":"address"},{"typeIdentifier":"t_uint256","typeString":"uint256"}],"expression":{"id":58979,"name":"abi","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":-1,"src":"20718:3:120","typeDescriptions":{"typeIdentifier":"t_magic_abi","typeString":"abi"}},"id":58980,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"memberLocation":"20722:6:120","memberName":"encode","nodeType":"MemberAccess","src":"20718:10:120","typeDescriptions":{"typeIdentifier":"t_function_abiencode_pure$__$returns$_t_bytes_memory_ptr_$","typeString":"function () pure returns (bytes memory)"}},"id":58983,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"20718:70:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_bytes_memory_ptr","typeString":"bytes memory"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_bytes_memory_ptr","typeString":"bytes memory"}],"id":58978,"name":"keccak256","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":-8,"src":"20708:9:120","typeDescriptions":{"typeIdentifier":"t_function_keccak256_pure$_t_bytes_memory_ptr_$returns$_t_bytes32_$","typeString":"function (bytes memory) pure returns (bytes32)"}},"id":58984,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"20708:81:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_bytes32","typeString":"bytes32"}},"nodeType":"VariableDeclarationStatement","src":"20693:96:120"},{"expression":{"arguments":[{"arguments":[{"arguments":[{"components":[{"arguments":[{"id":58994,"name":"_l1CrossDomainMessengerProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58967,"src":"20839:28:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},{"id":58995,"name":"slot","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":58977,"src":"20869:4:120","typeDescriptions":{"typeIdentifier":"t_bytes32","typeString":"bytes32"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_address","typeString":"address"},{"typeIdentifier":"t_bytes32","typeString":"bytes32"}],"expression":{"id":58992,"name":"vm","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":5980,"src":"20831:2:120","typeDescriptions":{"typeIdentifier":"t_contract$_Vm_$23767","typeString":"contract Vm"}},"id":58993,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"20834:4:120","memberName":"load","nodeType":"MemberAccess","referencedDeclaration":19863,"src":"20831:7:120","typeDescriptions":{"typeIdentifier":"t_function_external_view$_t_address_$_t_bytes32_$returns$_t_bytes32_$","typeString":"function (address,bytes32) view external returns (bytes32)"}},"id":58996,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"20831:43:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_bytes32","typeString":"bytes32"}}],"id":58997,"isConstant":false,"isInlineArray":false,"isLValue":false,"isPure":false,"lValueRequested":false,"nodeType":"TupleExpression","src":"20830:45:120","typeDescriptions":{"typeIdentifier":"t_bytes32","typeString":"bytes32"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_bytes32","typeString":"bytes32"}],"id":58991,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"nodeType":"ElementaryTypeNameExpression","src":"20822:7:120","typeDescriptions":{"typeIdentifier":"t_type$_t_uint256_$","typeString":"type(uint256)"},"typeName":{"id":58990,"name":"uint256","nodeType":"ElementaryTypeName","src":"20822:7:120","typeDescriptions":{}}},"id":58998,"isConstant":false,"isLValue":false,"isPure":false,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"20822:54:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_uint256","typeString":"uint256"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_uint256","typeString":"uint256"}],"id":58989,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"nodeType":"ElementaryTypeNameExpression","src":"20814:7:120","typeDescriptions":{"typeIdentifier":"t_type$_t_uint160_$","typeString":"type(uint160)"},"typeName":{"id":58988,"name":"uint160","nodeType":"ElementaryTypeName","src":"20814:7:120","typeDescriptions":{}}},"id":58999,"isConstant":false,"isLValue":false,"isPure":false,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"20814:63:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_uint160","typeString":"uint160"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_uint160","typeString":"uint160"}],"id":58987,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"nodeType":"ElementaryTypeNameExpression","src":"20806:7:120","typeDescriptions":{"typeIdentifier":"t_type$_t_address_$","typeString":"type(address)"},"typeName":{"id":58986,"name":"address","nodeType":"ElementaryTypeName","src":"20806:7:120","typeDescriptions":{}}},"id":59000,"isConstant":false,"isLValue":false,"isPure":false,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"20806:72:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"functionReturnParameters":58971,"id":59001,"nodeType":"Return","src":"20799:79:120"}]},"implemented":true,"kind":"function","modifiers":[],"name":"_getAddressManager","nameLocation":"20544:18:120","parameters":{"id":58968,"nodeType":"ParameterList","parameters":[{"constant":false,"id":58967,"mutability":"mutable","name":"_l1CrossDomainMessengerProxy","nameLocation":"20571:28:120","nodeType":"VariableDeclaration","scope":59003,"src":"20563:36:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":58966,"name":"address","nodeType":"ElementaryTypeName","src":"20563:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"20562:38:120"},"returnParameters":{"id":58971,"nodeType":"ParameterList","parameters":[{"constant":false,"id":58970,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":59003,"src":"20624:7:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":58969,"name":"address","nodeType":"ElementaryTypeName","src":"20624:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"20623:9:120"},"scope":59299,"stateMutability":"view","virtual":false,"visibility":"internal"},{"id":59031,"nodeType":"FunctionDefinition","src":"20891:299:120","nodes":[],"body":{"id":59030,"nodeType":"Block","src":"20984:206:120","nodes":[],"statements":[{"clauses":[{"block":{"id":59020,"nodeType":"Block","src":"21083:52:120","statements":[{"expression":{"id":59018,"name":"l1ERC721BridgeProxy_","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":59016,"src":"21104:20:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"functionReturnParameters":59009,"id":59019,"nodeType":"Return","src":"21097:27:120"}]},"errorName":"","id":59021,"nodeType":"TryCatchClause","parameters":{"id":59017,"nodeType":"ParameterList","parameters":[{"constant":false,"id":59016,"mutability":"mutable","name":"l1ERC721BridgeProxy_","nameLocation":"21061:20:120","nodeType":"VariableDeclaration","scope":59021,"src":"21053:28:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":59015,"name":"address","nodeType":"ElementaryTypeName","src":"21053:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"21052:30:120"},"src":"21044:91:120"},{"block":{"id":59027,"nodeType":"Block","src":"21142:42:120","statements":[{"expression":{"arguments":[{"hexValue":"30","id":59024,"isConstant":false,"isLValue":false,"isPure":true,"kind":"number","lValueRequested":false,"nodeType":"Literal","src":"21171:1:120","typeDescriptions":{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"},"value":"0"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"}],"id":59023,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"nodeType":"ElementaryTypeNameExpression","src":"21163:7:120","typeDescriptions":{"typeIdentifier":"t_type$_t_address_$","typeString":"type(address)"},"typeName":{"id":59022,"name":"address","nodeType":"ElementaryTypeName","src":"21163:7:120","typeDescriptions":{}}},"id":59025,"isConstant":false,"isLValue":false,"isPure":true,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"21163:10:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"functionReturnParameters":59009,"id":59026,"nodeType":"Return","src":"21156:17:120"}]},"errorName":"","id":59028,"nodeType":"TryCatchClause","src":"21136:48:120"}],"externalCall":{"arguments":[],"expression":{"argumentTypes":[],"expression":{"arguments":[{"id":59011,"name":"_systemConfigProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":59005,"src":"21007:18:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_address","typeString":"address"}],"id":59010,"name":"IFetcher","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57326,"src":"20998:8:120","typeDescriptions":{"typeIdentifier":"t_type$_t_contract$_IFetcher_$57326_$","typeString":"type(contract IFetcher)"}},"id":59012,"isConstant":false,"isLValue":false,"isPure":false,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"20998:28:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_contract$_IFetcher_$57326","typeString":"contract IFetcher"}},"id":59013,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"21027:14:120","memberName":"l1ERC721Bridge","nodeType":"MemberAccess","referencedDeclaration":57241,"src":"20998:43:120","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":59014,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"20998:45:120","tryCall":true,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"id":59029,"nodeType":"TryStatement","src":"20994:190:120"}]},"implemented":true,"kind":"function","modifiers":[],"name":"_getL1ERC721BridgeProxy","nameLocation":"20900:23:120","parameters":{"id":59006,"nodeType":"ParameterList","parameters":[{"constant":false,"id":59005,"mutability":"mutable","name":"_systemConfigProxy","nameLocation":"20932:18:120","nodeType":"VariableDeclaration","scope":59031,"src":"20924:26:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":59004,"name":"address","nodeType":"ElementaryTypeName","src":"20924:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"20923:28:120"},"returnParameters":{"id":59009,"nodeType":"ParameterList","parameters":[{"constant":false,"id":59008,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":59031,"src":"20975:7:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":59007,"name":"address","nodeType":"ElementaryTypeName","src":"20975:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"20974:9:120"},"scope":59299,"stateMutability":"view","virtual":false,"visibility":"internal"},{"id":59059,"nodeType":"FunctionDefinition","src":"21196:377:120","nodes":[],"body":{"id":59058,"nodeType":"Block","src":"21303:270:120","nodes":[],"statements":[{"clauses":[{"block":{"id":59048,"nodeType":"Block","src":"21452:66:120","statements":[{"expression":{"id":59046,"name":"optimismMintableERC20FactoryProxy_","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":59044,"src":"21473:34:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"functionReturnParameters":59037,"id":59047,"nodeType":"Return","src":"21466:41:120"}]},"errorName":"","id":59049,"nodeType":"TryCatchClause","parameters":{"id":59045,"nodeType":"ParameterList","parameters":[{"constant":false,"id":59044,"mutability":"mutable","name":"optimismMintableERC20FactoryProxy_","nameLocation":"21407:34:120","nodeType":"VariableDeclaration","scope":59049,"src":"21399:42:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":59043,"name":"address","nodeType":"ElementaryTypeName","src":"21399:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"21385:66:120"},"src":"21377:141:120"},{"block":{"id":59055,"nodeType":"Block","src":"21525:42:120","statements":[{"expression":{"arguments":[{"hexValue":"30","id":59052,"isConstant":false,"isLValue":false,"isPure":true,"kind":"number","lValueRequested":false,"nodeType":"Literal","src":"21554:1:120","typeDescriptions":{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"},"value":"0"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"}],"id":59051,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"nodeType":"ElementaryTypeNameExpression","src":"21546:7:120","typeDescriptions":{"typeIdentifier":"t_type$_t_address_$","typeString":"type(address)"},"typeName":{"id":59050,"name":"address","nodeType":"ElementaryTypeName","src":"21546:7:120","typeDescriptions":{}}},"id":59053,"isConstant":false,"isLValue":false,"isPure":true,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"21546:10:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"functionReturnParameters":59037,"id":59054,"nodeType":"Return","src":"21539:17:120"}]},"errorName":"","id":59056,"nodeType":"TryCatchClause","src":"21519:48:120"}],"externalCall":{"arguments":[],"expression":{"argumentTypes":[],"expression":{"arguments":[{"id":59039,"name":"_systemConfigProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":59033,"src":"21326:18:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_address","typeString":"address"}],"id":59038,"name":"IFetcher","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57326,"src":"21317:8:120","typeDescriptions":{"typeIdentifier":"t_type$_t_contract$_IFetcher_$57326_$","typeString":"type(contract IFetcher)"}},"id":59040,"isConstant":false,"isLValue":false,"isPure":false,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"21317:28:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_contract$_IFetcher_$57326","typeString":"contract IFetcher"}},"id":59041,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"21346:28:120","memberName":"optimismMintableERC20Factory","nodeType":"MemberAccess","referencedDeclaration":57246,"src":"21317:57:120","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":59042,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"21317:59:120","tryCall":true,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"id":59057,"nodeType":"TryStatement","src":"21313:254:120"}]},"implemented":true,"kind":"function","modifiers":[],"name":"_getOptimismMintableERC20FactoryProxy","nameLocation":"21205:37:120","parameters":{"id":59034,"nodeType":"ParameterList","parameters":[{"constant":false,"id":59033,"mutability":"mutable","name":"_systemConfigProxy","nameLocation":"21251:18:120","nodeType":"VariableDeclaration","scope":59059,"src":"21243:26:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":59032,"name":"address","nodeType":"ElementaryTypeName","src":"21243:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"21242:28:120"},"returnParameters":{"id":59037,"nodeType":"ParameterList","parameters":[{"constant":false,"id":59036,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":59059,"src":"21294:7:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":59035,"name":"address","nodeType":"ElementaryTypeName","src":"21294:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"21293:9:120"},"scope":59299,"stateMutability":"view","virtual":false,"visibility":"internal"},{"id":59087,"nodeType":"FunctionDefinition","src":"21579:398:120","nodes":[],"body":{"id":59086,"nodeType":"Block","src":"21676:301:120","nodes":[],"statements":[{"clauses":[{"block":{"id":59076,"nodeType":"Block","src":"21783:56:120","statements":[{"expression":{"id":59074,"name":"disputeGameFactoryProxy_","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":59072,"src":"21804:24:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"functionReturnParameters":59065,"id":59075,"nodeType":"Return","src":"21797:31:120"}]},"errorName":"","id":59077,"nodeType":"TryCatchClause","parameters":{"id":59073,"nodeType":"ParameterList","parameters":[{"constant":false,"id":59072,"mutability":"mutable","name":"disputeGameFactoryProxy_","nameLocation":"21757:24:120","nodeType":"VariableDeclaration","scope":59077,"src":"21749:32:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":59071,"name":"address","nodeType":"ElementaryTypeName","src":"21749:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"21748:34:120"},"src":"21740:99:120"},{"block":{"id":59083,"nodeType":"Block","src":"21846:125:120","statements":[{"expression":{"arguments":[{"hexValue":"30","id":59080,"isConstant":false,"isLValue":false,"isPure":true,"kind":"number","lValueRequested":false,"nodeType":"Literal","src":"21958:1:120","typeDescriptions":{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"},"value":"0"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"}],"id":59079,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"nodeType":"ElementaryTypeNameExpression","src":"21950:7:120","typeDescriptions":{"typeIdentifier":"t_type$_t_address_$","typeString":"type(address)"},"typeName":{"id":59078,"name":"address","nodeType":"ElementaryTypeName","src":"21950:7:120","typeDescriptions":{}}},"id":59081,"isConstant":false,"isLValue":false,"isPure":true,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"21950:10:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"functionReturnParameters":59065,"id":59082,"nodeType":"Return","src":"21943:17:120"}]},"errorName":"","id":59084,"nodeType":"TryCatchClause","src":"21840:131:120"}],"externalCall":{"arguments":[],"expression":{"argumentTypes":[],"expression":{"arguments":[{"id":59067,"name":"_systemConfigProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":59061,"src":"21699:18:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_address","typeString":"address"}],"id":59066,"name":"IFetcher","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57326,"src":"21690:8:120","typeDescriptions":{"typeIdentifier":"t_type$_t_contract$_IFetcher_$57326_$","typeString":"type(contract IFetcher)"}},"id":59068,"isConstant":false,"isLValue":false,"isPure":false,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"21690:28:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_contract$_IFetcher_$57326","typeString":"contract IFetcher"}},"id":59069,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"21719:18:120","memberName":"disputeGameFactory","nodeType":"MemberAccess","referencedDeclaration":57206,"src":"21690:47:120","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":59070,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"21690:49:120","tryCall":true,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"id":59085,"nodeType":"TryStatement","src":"21686:285:120"}]},"implemented":true,"kind":"function","modifiers":[],"name":"_getDisputeGameFactoryProxy","nameLocation":"21588:27:120","parameters":{"id":59062,"nodeType":"ParameterList","parameters":[{"constant":false,"id":59061,"mutability":"mutable","name":"_systemConfigProxy","nameLocation":"21624:18:120","nodeType":"VariableDeclaration","scope":59087,"src":"21616:26:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":59060,"name":"address","nodeType":"ElementaryTypeName","src":"21616:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"21615:28:120"},"returnParameters":{"id":59065,"nodeType":"ParameterList","parameters":[{"constant":false,"id":59064,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":59087,"src":"21667:7:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":59063,"name":"address","nodeType":"ElementaryTypeName","src":"21667:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"21666:9:120"},"scope":59299,"stateMutability":"view","virtual":false,"visibility":"internal"},{"id":59115,"nodeType":"FunctionDefinition","src":"21983:311:120","nodes":[],"body":{"id":59114,"nodeType":"Block","src":"22080:214:120","nodes":[],"statements":[{"clauses":[{"block":{"id":59104,"nodeType":"Block","src":"22185:54:120","statements":[{"expression":{"id":59102,"name":"superchainConfigProxy_","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":59100,"src":"22206:22:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"functionReturnParameters":59093,"id":59103,"nodeType":"Return","src":"22199:29:120"}]},"errorName":"","id":59105,"nodeType":"TryCatchClause","parameters":{"id":59101,"nodeType":"ParameterList","parameters":[{"constant":false,"id":59100,"mutability":"mutable","name":"superchainConfigProxy_","nameLocation":"22161:22:120","nodeType":"VariableDeclaration","scope":59105,"src":"22153:30:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":59099,"name":"address","nodeType":"ElementaryTypeName","src":"22153:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"22152:32:120"},"src":"22144:95:120"},{"block":{"id":59111,"nodeType":"Block","src":"22246:42:120","statements":[{"expression":{"arguments":[{"hexValue":"30","id":59108,"isConstant":false,"isLValue":false,"isPure":true,"kind":"number","lValueRequested":false,"nodeType":"Literal","src":"22275:1:120","typeDescriptions":{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"},"value":"0"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"}],"id":59107,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"nodeType":"ElementaryTypeNameExpression","src":"22267:7:120","typeDescriptions":{"typeIdentifier":"t_type$_t_address_$","typeString":"type(address)"},"typeName":{"id":59106,"name":"address","nodeType":"ElementaryTypeName","src":"22267:7:120","typeDescriptions":{}}},"id":59109,"isConstant":false,"isLValue":false,"isPure":true,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"22267:10:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"functionReturnParameters":59093,"id":59110,"nodeType":"Return","src":"22260:17:120"}]},"errorName":"","id":59112,"nodeType":"TryCatchClause","src":"22240:48:120"}],"externalCall":{"arguments":[],"expression":{"argumentTypes":[],"expression":{"arguments":[{"id":59095,"name":"_optimismPortalProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":59089,"src":"22103:20:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_address","typeString":"address"}],"id":59094,"name":"IFetcher","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57326,"src":"22094:8:120","typeDescriptions":{"typeIdentifier":"t_type$_t_contract$_IFetcher_$57326_$","typeString":"type(contract IFetcher)"}},"id":59096,"isConstant":false,"isLValue":false,"isPure":false,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"22094:30:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_contract$_IFetcher_$57326","typeString":"contract IFetcher"}},"id":59097,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"22125:16:120","memberName":"superchainConfig","nodeType":"MemberAccess","referencedDeclaration":57216,"src":"22094:47:120","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":59098,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"22094:49:120","tryCall":true,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"id":59113,"nodeType":"TryStatement","src":"22090:198:120"}]},"implemented":true,"kind":"function","modifiers":[],"name":"_getSuperchainConfigProxy","nameLocation":"21992:25:120","parameters":{"id":59090,"nodeType":"ParameterList","parameters":[{"constant":false,"id":59089,"mutability":"mutable","name":"_optimismPortalProxy","nameLocation":"22026:20:120","nodeType":"VariableDeclaration","scope":59115,"src":"22018:28:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":59088,"name":"address","nodeType":"ElementaryTypeName","src":"22018:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"22017:30:120"},"returnParameters":{"id":59093,"nodeType":"ParameterList","parameters":[{"constant":false,"id":59092,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":59115,"src":"22071:7:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":59091,"name":"address","nodeType":"ElementaryTypeName","src":"22071:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"22070:9:120"},"scope":59299,"stateMutability":"view","virtual":false,"visibility":"internal"},{"id":59145,"nodeType":"FunctionDefinition","src":"22300:313:120","nodes":[],"body":{"id":59144,"nodeType":"Block","src":"22396:217:120","nodes":[],"statements":[{"clauses":[{"block":{"id":59134,"nodeType":"Block","src":"22509:49:120","statements":[{"expression":{"id":59132,"name":"faultDisputeGame_","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":59130,"src":"22530:17:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"functionReturnParameters":59121,"id":59133,"nodeType":"Return","src":"22523:24:120"}]},"errorName":"","id":59135,"nodeType":"TryCatchClause","parameters":{"id":59131,"nodeType":"ParameterList","parameters":[{"constant":false,"id":59130,"mutability":"mutable","name":"faultDisputeGame_","nameLocation":"22490:17:120","nodeType":"VariableDeclaration","scope":59135,"src":"22482:25:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":59129,"name":"address","nodeType":"ElementaryTypeName","src":"22482:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"22481:27:120"},"src":"22473:85:120"},{"block":{"id":59141,"nodeType":"Block","src":"22565:42:120","statements":[{"expression":{"arguments":[{"hexValue":"30","id":59138,"isConstant":false,"isLValue":false,"isPure":true,"kind":"number","lValueRequested":false,"nodeType":"Literal","src":"22594:1:120","typeDescriptions":{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"},"value":"0"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"}],"id":59137,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"nodeType":"ElementaryTypeNameExpression","src":"22586:7:120","typeDescriptions":{"typeIdentifier":"t_type$_t_address_$","typeString":"type(address)"},"typeName":{"id":59136,"name":"address","nodeType":"ElementaryTypeName","src":"22586:7:120","typeDescriptions":{}}},"id":59139,"isConstant":false,"isLValue":false,"isPure":true,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"22586:10:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"functionReturnParameters":59121,"id":59140,"nodeType":"Return","src":"22579:17:120"}]},"errorName":"","id":59142,"nodeType":"TryCatchClause","src":"22559:48:120"}],"externalCall":{"arguments":[{"expression":{"id":59126,"name":"GameTypes","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":75481,"src":"22455:9:120","typeDescriptions":{"typeIdentifier":"t_type$_t_contract$_GameTypes_$75481_$","typeString":"type(library GameTypes)"}},"id":59127,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"memberLocation":"22465:6:120","memberName":"CANNON","nodeType":"MemberAccess","referencedDeclaration":75408,"src":"22455:16:120","typeDescriptions":{"typeIdentifier":"t_userDefinedValueType$_GameType_$75355","typeString":"GameType"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_userDefinedValueType$_GameType_$75355","typeString":"GameType"}],"expression":{"arguments":[{"id":59123,"name":"_disputeGameFactoryProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":59117,"src":"22419:24:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_address","typeString":"address"}],"id":59122,"name":"IFetcher","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57326,"src":"22410:8:120","typeDescriptions":{"typeIdentifier":"t_type$_t_contract$_IFetcher_$57326_$","typeString":"type(contract IFetcher)"}},"id":59124,"isConstant":false,"isLValue":false,"isPure":false,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"22410:34:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_contract$_IFetcher_$57326","typeString":"contract IFetcher"}},"id":59125,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"22445:9:120","memberName":"gameImpls","nodeType":"MemberAccess","referencedDeclaration":57254,"src":"22410:44:120","typeDescriptions":{"typeIdentifier":"t_function_external_view$_t_userDefinedValueType$_GameType_$75355_$returns$_t_address_$","typeString":"function (GameType) view external returns (address)"}},"id":59128,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"22410:62:120","tryCall":true,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"id":59143,"nodeType":"TryStatement","src":"22406:201:120"}]},"implemented":true,"kind":"function","modifiers":[],"name":"_getFaultDisputeGame","nameLocation":"22309:20:120","parameters":{"id":59118,"nodeType":"ParameterList","parameters":[{"constant":false,"id":59117,"mutability":"mutable","name":"_disputeGameFactoryProxy","nameLocation":"22338:24:120","nodeType":"VariableDeclaration","scope":59145,"src":"22330:32:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":59116,"name":"address","nodeType":"ElementaryTypeName","src":"22330:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"22329:34:120"},"returnParameters":{"id":59121,"nodeType":"ParameterList","parameters":[{"constant":false,"id":59120,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":59145,"src":"22387:7:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":59119,"name":"address","nodeType":"ElementaryTypeName","src":"22387:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"22386:9:120"},"scope":59299,"stateMutability":"view","virtual":false,"visibility":"internal"},{"id":59175,"nodeType":"FunctionDefinition","src":"22619:369:120","nodes":[],"body":{"id":59174,"nodeType":"Block","src":"22722:266:120","nodes":[],"statements":[{"clauses":[{"block":{"id":59164,"nodeType":"Block","src":"22877:56:120","statements":[{"expression":{"id":59162,"name":"permissionedDisputeGame_","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":59160,"src":"22898:24:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"functionReturnParameters":59151,"id":59163,"nodeType":"Return","src":"22891:31:120"}]},"errorName":"","id":59165,"nodeType":"TryCatchClause","parameters":{"id":59161,"nodeType":"ParameterList","parameters":[{"constant":false,"id":59160,"mutability":"mutable","name":"permissionedDisputeGame_","nameLocation":"22842:24:120","nodeType":"VariableDeclaration","scope":59165,"src":"22834:32:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":59159,"name":"address","nodeType":"ElementaryTypeName","src":"22834:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"22820:56:120"},"src":"22812:121:120"},{"block":{"id":59171,"nodeType":"Block","src":"22940:42:120","statements":[{"expression":{"arguments":[{"hexValue":"30","id":59168,"isConstant":false,"isLValue":false,"isPure":true,"kind":"number","lValueRequested":false,"nodeType":"Literal","src":"22969:1:120","typeDescriptions":{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"},"value":"0"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"}],"id":59167,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"nodeType":"ElementaryTypeNameExpression","src":"22961:7:120","typeDescriptions":{"typeIdentifier":"t_type$_t_address_$","typeString":"type(address)"},"typeName":{"id":59166,"name":"address","nodeType":"ElementaryTypeName","src":"22961:7:120","typeDescriptions":{}}},"id":59169,"isConstant":false,"isLValue":false,"isPure":true,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"22961:10:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"functionReturnParameters":59151,"id":59170,"nodeType":"Return","src":"22954:17:120"}]},"errorName":"","id":59172,"nodeType":"TryCatchClause","src":"22934:48:120"}],"externalCall":{"arguments":[{"expression":{"id":59156,"name":"GameTypes","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":75481,"src":"22781:9:120","typeDescriptions":{"typeIdentifier":"t_type$_t_contract$_GameTypes_$75481_$","typeString":"type(library GameTypes)"}},"id":59157,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"memberLocation":"22791:19:120","memberName":"PERMISSIONED_CANNON","nodeType":"MemberAccess","referencedDeclaration":75416,"src":"22781:29:120","typeDescriptions":{"typeIdentifier":"t_userDefinedValueType$_GameType_$75355","typeString":"GameType"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_userDefinedValueType$_GameType_$75355","typeString":"GameType"}],"expression":{"arguments":[{"id":59153,"name":"_disputeGameFactoryProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":59147,"src":"22745:24:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_address","typeString":"address"}],"id":59152,"name":"IFetcher","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57326,"src":"22736:8:120","typeDescriptions":{"typeIdentifier":"t_type$_t_contract$_IFetcher_$57326_$","typeString":"type(contract IFetcher)"}},"id":59154,"isConstant":false,"isLValue":false,"isPure":false,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"22736:34:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_contract$_IFetcher_$57326","typeString":"contract IFetcher"}},"id":59155,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"22771:9:120","memberName":"gameImpls","nodeType":"MemberAccess","referencedDeclaration":57254,"src":"22736:44:120","typeDescriptions":{"typeIdentifier":"t_function_external_view$_t_userDefinedValueType$_GameType_$75355_$returns$_t_address_$","typeString":"function (GameType) view external returns (address)"}},"id":59158,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"22736:75:120","tryCall":true,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"id":59173,"nodeType":"TryStatement","src":"22732:250:120"}]},"implemented":true,"kind":"function","modifiers":[],"name":"_getPermissionedDisputeGame","nameLocation":"22628:27:120","parameters":{"id":59148,"nodeType":"ParameterList","parameters":[{"constant":false,"id":59147,"mutability":"mutable","name":"_disputeGameFactoryProxy","nameLocation":"22664:24:120","nodeType":"VariableDeclaration","scope":59175,"src":"22656:32:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":59146,"name":"address","nodeType":"ElementaryTypeName","src":"22656:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"22655:34:120"},"returnParameters":{"id":59151,"nodeType":"ParameterList","parameters":[{"constant":false,"id":59150,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":59175,"src":"22713:7:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":59149,"name":"address","nodeType":"ElementaryTypeName","src":"22713:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"22712:9:120"},"scope":59299,"stateMutability":"view","virtual":false,"visibility":"internal"},{"id":59203,"nodeType":"FunctionDefinition","src":"22994:277:120","nodes":[],"body":{"id":59202,"nodeType":"Block","src":"23085:186:120","nodes":[],"statements":[{"clauses":[{"block":{"id":59192,"nodeType":"Block","src":"23173:43:120","statements":[{"expression":{"id":59190,"name":"ethLockbox_","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":59188,"src":"23194:11:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"functionReturnParameters":59181,"id":59191,"nodeType":"Return","src":"23187:18:120"}]},"errorName":"","id":59193,"nodeType":"TryCatchClause","parameters":{"id":59189,"nodeType":"ParameterList","parameters":[{"constant":false,"id":59188,"mutability":"mutable","name":"ethLockbox_","nameLocation":"23160:11:120","nodeType":"VariableDeclaration","scope":59193,"src":"23152:19:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":59187,"name":"address","nodeType":"ElementaryTypeName","src":"23152:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"23151:21:120"},"src":"23143:73:120"},{"block":{"id":59199,"nodeType":"Block","src":"23223:42:120","statements":[{"expression":{"arguments":[{"hexValue":"30","id":59196,"isConstant":false,"isLValue":false,"isPure":true,"kind":"number","lValueRequested":false,"nodeType":"Literal","src":"23252:1:120","typeDescriptions":{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"},"value":"0"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"}],"id":59195,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"nodeType":"ElementaryTypeNameExpression","src":"23244:7:120","typeDescriptions":{"typeIdentifier":"t_type$_t_address_$","typeString":"type(address)"},"typeName":{"id":59194,"name":"address","nodeType":"ElementaryTypeName","src":"23244:7:120","typeDescriptions":{}}},"id":59197,"isConstant":false,"isLValue":false,"isPure":true,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"23244:10:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"functionReturnParameters":59181,"id":59198,"nodeType":"Return","src":"23237:17:120"}]},"errorName":"","id":59200,"nodeType":"TryCatchClause","src":"23217:48:120"}],"externalCall":{"arguments":[],"expression":{"argumentTypes":[],"expression":{"arguments":[{"id":59183,"name":"_optimismPortalProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":59177,"src":"23108:20:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_address","typeString":"address"}],"id":59182,"name":"IFetcher","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57326,"src":"23099:8:120","typeDescriptions":{"typeIdentifier":"t_type$_t_contract$_IFetcher_$57326_$","typeString":"type(contract IFetcher)"}},"id":59184,"isConstant":false,"isLValue":false,"isPure":false,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"23099:30:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_contract$_IFetcher_$57326","typeString":"contract IFetcher"}},"id":59185,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"23130:10:120","memberName":"ethLockbox","nodeType":"MemberAccess","referencedDeclaration":57211,"src":"23099:41:120","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":59186,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"23099:43:120","tryCall":true,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"id":59201,"nodeType":"TryStatement","src":"23095:170:120"}]},"implemented":true,"kind":"function","modifiers":[],"name":"_getEthLockboxProxy","nameLocation":"23003:19:120","parameters":{"id":59178,"nodeType":"ParameterList","parameters":[{"constant":false,"id":59177,"mutability":"mutable","name":"_optimismPortalProxy","nameLocation":"23031:20:120","nodeType":"VariableDeclaration","scope":59203,"src":"23023:28:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":59176,"name":"address","nodeType":"ElementaryTypeName","src":"23023:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"23022:30:120"},"returnParameters":{"id":59181,"nodeType":"ParameterList","parameters":[{"constant":false,"id":59180,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":59203,"src":"23076:7:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":59179,"name":"address","nodeType":"ElementaryTypeName","src":"23076:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"23075:9:120"},"scope":59299,"stateMutability":"view","virtual":false,"visibility":"internal"},{"id":59248,"nodeType":"FunctionDefinition","src":"23277:304:120","nodes":[],"body":{"id":59247,"nodeType":"Block","src":"23361:220:120","nodes":[],"statements":[{"assignments":[59211,59213],"declarations":[{"constant":false,"id":59211,"mutability":"mutable","name":"ok","nameLocation":"23377:2:120","nodeType":"VariableDeclaration","scope":59247,"src":"23372:7:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"},"typeName":{"id":59210,"name":"bool","nodeType":"ElementaryTypeName","src":"23372:4:120","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},"visibility":"internal"},{"constant":false,"id":59213,"mutability":"mutable","name":"data","nameLocation":"23394:4:120","nodeType":"VariableDeclaration","scope":59247,"src":"23381:17:120","stateVariable":false,"storageLocation":"memory","typeDescriptions":{"typeIdentifier":"t_bytes_memory_ptr","typeString":"bytes"},"typeName":{"id":59212,"name":"bytes","nodeType":"ElementaryTypeName","src":"23381:5:120","typeDescriptions":{"typeIdentifier":"t_bytes_storage_ptr","typeString":"bytes"}},"visibility":"internal"}],"id":59226,"initialValue":{"arguments":[{"arguments":[{"expression":{"id":59221,"name":"IFetcher","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57326,"src":"23450:8:120","typeDescriptions":{"typeIdentifier":"t_type$_t_contract$_IFetcher_$57326_$","typeString":"type(contract IFetcher)"}},"id":59222,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"memberLocation":"23459:4:120","memberName":"weth","nodeType":"MemberAccess","referencedDeclaration":57325,"src":"23450:13:120","typeDescriptions":{"typeIdentifier":"t_function_declaration_view$__$returns$_t_address_$","typeString":"function IFetcher.weth() view returns (address)"}},{"components":[],"id":59223,"isConstant":false,"isInlineArray":false,"isLValue":false,"isPure":true,"lValueRequested":false,"nodeType":"TupleExpression","src":"23465:2:120","typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_function_declaration_view$__$returns$_t_address_$","typeString":"function IFetcher.weth() view returns (address)"},{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}],"expression":{"id":59219,"name":"abi","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":-1,"src":"23435:3:120","typeDescriptions":{"typeIdentifier":"t_magic_abi","typeString":"abi"}},"id":59220,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"memberLocation":"23439:10:120","memberName":"encodeCall","nodeType":"MemberAccess","src":"23435:14:120","typeDescriptions":{"typeIdentifier":"t_function_abiencodecall_pure$__$returns$_t_bytes_memory_ptr_$","typeString":"function () pure returns (bytes memory)"}},"id":59224,"isConstant":false,"isLValue":false,"isPure":true,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"23435:33:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_bytes_memory_ptr","typeString":"bytes memory"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_bytes_memory_ptr","typeString":"bytes memory"}],"expression":{"arguments":[{"id":59216,"name":"_disputeGame","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":59205,"src":"23410:12:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_address","typeString":"address"}],"id":59215,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"nodeType":"ElementaryTypeNameExpression","src":"23402:7:120","typeDescriptions":{"typeIdentifier":"t_type$_t_address_$","typeString":"type(address)"},"typeName":{"id":59214,"name":"address","nodeType":"ElementaryTypeName","src":"23402:7:120","typeDescriptions":{}}},"id":59217,"isConstant":false,"isLValue":false,"isPure":false,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"23402:21:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"id":59218,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"23424:10:120","memberName":"staticcall","nodeType":"MemberAccess","src":"23402:32:120","typeDescriptions":{"typeIdentifier":"t_function_barestaticcall_view$_t_bytes_memory_ptr_$returns$_t_bool_$_t_bytes_memory_ptr_$","typeString":"function (bytes memory) view returns (bool,bytes memory)"}},"id":59225,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"23402:67:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$_t_bool_$_t_bytes_memory_ptr_$","typeString":"tuple(bool,bytes memory)"}},"nodeType":"VariableDeclarationStatement","src":"23371:98:120"},{"condition":{"commonType":{"typeIdentifier":"t_bool","typeString":"bool"},"id":59232,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftExpression":{"id":59227,"name":"ok","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":59211,"src":"23483:2:120","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},"nodeType":"BinaryOperation","operator":"&&","rightExpression":{"commonType":{"typeIdentifier":"t_uint256","typeString":"uint256"},"id":59231,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftExpression":{"expression":{"id":59228,"name":"data","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":59213,"src":"23489:4:120","typeDescriptions":{"typeIdentifier":"t_bytes_memory_ptr","typeString":"bytes memory"}},"id":59229,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"23494:6:120","memberName":"length","nodeType":"MemberAccess","src":"23489:11:120","typeDescriptions":{"typeIdentifier":"t_uint256","typeString":"uint256"}},"nodeType":"BinaryOperation","operator":"==","rightExpression":{"hexValue":"3332","id":59230,"isConstant":false,"isLValue":false,"isPure":true,"kind":"number","lValueRequested":false,"nodeType":"Literal","src":"23504:2:120","typeDescriptions":{"typeIdentifier":"t_rational_32_by_1","typeString":"int_const 32"},"value":"32"},"src":"23489:17:120","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},"src":"23483:23:120","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},"falseBody":{"expression":{"arguments":[{"hexValue":"30","id":59243,"isConstant":false,"isLValue":false,"isPure":true,"kind":"number","lValueRequested":false,"nodeType":"Literal","src":"23572:1:120","typeDescriptions":{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"},"value":"0"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"}],"id":59242,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"nodeType":"ElementaryTypeNameExpression","src":"23564:7:120","typeDescriptions":{"typeIdentifier":"t_type$_t_address_$","typeString":"type(address)"},"typeName":{"id":59241,"name":"address","nodeType":"ElementaryTypeName","src":"23564:7:120","typeDescriptions":{}}},"id":59244,"isConstant":false,"isLValue":false,"isPure":true,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"23564:10:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"functionReturnParameters":59209,"id":59245,"nodeType":"Return","src":"23557:17:120"},"id":59246,"nodeType":"IfStatement","src":"23479:95:120","trueBody":{"expression":{"arguments":[{"id":59235,"name":"data","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":59213,"src":"23526:4:120","typeDescriptions":{"typeIdentifier":"t_bytes_memory_ptr","typeString":"bytes memory"}},{"components":[{"id":59237,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"nodeType":"ElementaryTypeNameExpression","src":"23533:7:120","typeDescriptions":{"typeIdentifier":"t_type$_t_address_$","typeString":"type(address)"},"typeName":{"id":59236,"name":"address","nodeType":"ElementaryTypeName","src":"23533:7:120","typeDescriptions":{}}}],"id":59238,"isConstant":false,"isInlineArray":false,"isLValue":false,"isPure":true,"lValueRequested":false,"nodeType":"TupleExpression","src":"23532:9:120","typeDescriptions":{"typeIdentifier":"t_type$_t_address_$","typeString":"type(address)"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_bytes_memory_ptr","typeString":"bytes memory"},{"typeIdentifier":"t_type$_t_address_$","typeString":"type(address)"}],"expression":{"id":59233,"name":"abi","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":-1,"src":"23515:3:120","typeDescriptions":{"typeIdentifier":"t_magic_abi","typeString":"abi"}},"id":59234,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"memberLocation":"23519:6:120","memberName":"decode","nodeType":"MemberAccess","src":"23515:10:120","typeDescriptions":{"typeIdentifier":"t_function_abidecode_pure$__$returns$__$","typeString":"function () pure"}},"id":59239,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"23515:27:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address_payable","typeString":"address payable"}},"functionReturnParameters":59209,"id":59240,"nodeType":"Return","src":"23508:34:120"}}]},"implemented":true,"kind":"function","modifiers":[],"name":"_getDelayedWETHProxy","nameLocation":"23286:20:120","parameters":{"id":59206,"nodeType":"ParameterList","parameters":[{"constant":false,"id":59205,"mutability":"mutable","name":"_disputeGame","nameLocation":"23315:12:120","nodeType":"VariableDeclaration","scope":59248,"src":"23307:20:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":59204,"name":"address","nodeType":"ElementaryTypeName","src":"23307:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"23306:22:120"},"returnParameters":{"id":59209,"nodeType":"ParameterList","parameters":[{"constant":false,"id":59208,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":59248,"src":"23352:7:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":59207,"name":"address","nodeType":"ElementaryTypeName","src":"23352:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"23351:9:120"},"scope":59299,"stateMutability":"view","virtual":false,"visibility":"internal"},{"id":59275,"nodeType":"FunctionDefinition","src":"23587:224:120","nodes":[],"body":{"id":59274,"nodeType":"Block","src":"23675:136:120","nodes":[],"statements":[{"assignments":[59256],"declarations":[{"constant":false,"id":59256,"mutability":"mutable","name":"batcherHash","nameLocation":"23693:11:120","nodeType":"VariableDeclaration","scope":59274,"src":"23685:19:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_bytes32","typeString":"bytes32"},"typeName":{"id":59255,"name":"bytes32","nodeType":"ElementaryTypeName","src":"23685:7:120","typeDescriptions":{"typeIdentifier":"t_bytes32","typeString":"bytes32"}},"visibility":"internal"}],"id":59262,"initialValue":{"arguments":[],"expression":{"argumentTypes":[],"expression":{"arguments":[{"id":59258,"name":"_systemConfigProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":59250,"src":"23716:18:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_address","typeString":"address"}],"id":59257,"name":"IFetcher","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57326,"src":"23707:8:120","typeDescriptions":{"typeIdentifier":"t_type$_t_contract$_IFetcher_$57326_$","typeString":"type(contract IFetcher)"}},"id":59259,"isConstant":false,"isLValue":false,"isPure":false,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"23707:28:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_contract$_IFetcher_$57326","typeString":"contract IFetcher"}},"id":59260,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"23736:11:120","memberName":"batcherHash","nodeType":"MemberAccess","referencedDeclaration":57305,"src":"23707:40:120","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_bytes32_$","typeString":"function () view external returns (bytes32)"}},"id":59261,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"23707:42:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_bytes32","typeString":"bytes32"}},"nodeType":"VariableDeclarationStatement","src":"23685:64:120"},{"expression":{"arguments":[{"arguments":[{"arguments":[{"id":59269,"name":"batcherHash","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":59256,"src":"23790:11:120","typeDescriptions":{"typeIdentifier":"t_bytes32","typeString":"bytes32"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_bytes32","typeString":"bytes32"}],"id":59268,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"nodeType":"ElementaryTypeNameExpression","src":"23782:7:120","typeDescriptions":{"typeIdentifier":"t_type$_t_uint256_$","typeString":"type(uint256)"},"typeName":{"id":59267,"name":"uint256","nodeType":"ElementaryTypeName","src":"23782:7:120","typeDescriptions":{}}},"id":59270,"isConstant":false,"isLValue":false,"isPure":false,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"23782:20:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_uint256","typeString":"uint256"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_uint256","typeString":"uint256"}],"id":59266,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"nodeType":"ElementaryTypeNameExpression","src":"23774:7:120","typeDescriptions":{"typeIdentifier":"t_type$_t_uint160_$","typeString":"type(uint160)"},"typeName":{"id":59265,"name":"uint160","nodeType":"ElementaryTypeName","src":"23774:7:120","typeDescriptions":{}}},"id":59271,"isConstant":false,"isLValue":false,"isPure":false,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"23774:29:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_uint160","typeString":"uint160"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_uint160","typeString":"uint160"}],"id":59264,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"nodeType":"ElementaryTypeNameExpression","src":"23766:7:120","typeDescriptions":{"typeIdentifier":"t_type$_t_address_$","typeString":"type(address)"},"typeName":{"id":59263,"name":"address","nodeType":"ElementaryTypeName","src":"23766:7:120","typeDescriptions":{}}},"id":59272,"isConstant":false,"isLValue":false,"isPure":false,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"23766:38:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"functionReturnParameters":59254,"id":59273,"nodeType":"Return","src":"23759:45:120"}]},"implemented":true,"kind":"function","modifiers":[],"name":"_getBatchSubmitter","nameLocation":"23596:18:120","parameters":{"id":59251,"nodeType":"ParameterList","parameters":[{"constant":false,"id":59250,"mutability":"mutable","name":"_systemConfigProxy","nameLocation":"23623:18:120","nodeType":"VariableDeclaration","scope":59275,"src":"23615:26:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":59249,"name":"address","nodeType":"ElementaryTypeName","src":"23615:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"23614:28:120"},"returnParameters":{"id":59254,"nodeType":"ParameterList","parameters":[{"constant":false,"id":59253,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":59275,"src":"23666:7:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":59252,"name":"address","nodeType":"ElementaryTypeName","src":"23666:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"23665:9:120"},"scope":59299,"stateMutability":"view","virtual":false,"visibility":"internal"},{"id":59298,"nodeType":"FunctionDefinition","src":"23817:169:120","nodes":[],"body":{"id":59297,"nodeType":"Block","src":"23896:90:120","nodes":[],"statements":[{"expression":{"arguments":[{"arguments":[{"hexValue":"30","id":59287,"isConstant":false,"isLValue":false,"isPure":true,"kind":"number","lValueRequested":false,"nodeType":"Literal","src":"23923:1:120","typeDescriptions":{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"},"value":"0"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"}],"id":59286,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"nodeType":"ElementaryTypeNameExpression","src":"23915:7:120","typeDescriptions":{"typeIdentifier":"t_type$_t_address_$","typeString":"type(address)"},"typeName":{"id":59285,"name":"address","nodeType":"ElementaryTypeName","src":"23915:7:120","typeDescriptions":{}}},"id":59288,"isConstant":false,"isLValue":false,"isPure":true,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"23915:10:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_address","typeString":"address"}],"expression":{"id":59282,"name":"vm","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":5980,"src":"23906:2:120","typeDescriptions":{"typeIdentifier":"t_contract$_Vm_$23767","typeString":"contract Vm"}},"id":59284,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"23909:5:120","memberName":"prank","nodeType":"MemberAccess","referencedDeclaration":23060,"src":"23906:8:120","typeDescriptions":{"typeIdentifier":"t_function_external_nonpayable$_t_address_$returns$__$","typeString":"function (address) external"}},"id":59289,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"23906:20:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":59290,"nodeType":"ExpressionStatement","src":"23906:20:120"},{"expression":{"arguments":[],"expression":{"argumentTypes":[],"expression":{"arguments":[{"id":59292,"name":"_systemConfigProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":59277,"src":"23952:18:120","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_address","typeString":"address"}],"id":59291,"name":"IFetcher","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":57326,"src":"23943:8:120","typeDescriptions":{"typeIdentifier":"t_type$_t_contract$_IFetcher_$57326_$","typeString":"type(contract IFetcher)"}},"id":59293,"isConstant":false,"isLValue":false,"isPure":false,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"23943:28:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_contract$_IFetcher_$57326","typeString":"contract IFetcher"}},"id":59294,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"23972:5:120","memberName":"admin","nodeType":"MemberAccess","referencedDeclaration":57310,"src":"23943:34:120","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":59295,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"23943:36:120","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"functionReturnParameters":59281,"id":59296,"nodeType":"Return","src":"23936:43:120"}]},"implemented":true,"kind":"function","modifiers":[],"name":"_getProxyAdmin","nameLocation":"23826:14:120","parameters":{"id":59278,"nodeType":"ParameterList","parameters":[{"constant":false,"id":59277,"mutability":"mutable","name":"_systemConfigProxy","nameLocation":"23849:18:120","nodeType":"VariableDeclaration","scope":59298,"src":"23841:26:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":59276,"name":"address","nodeType":"ElementaryTypeName","src":"23841:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"23840:28:120"},"returnParameters":{"id":59281,"nodeType":"ParameterList","parameters":[{"constant":false,"id":59280,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":59298,"src":"23887:7:120","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":59279,"name":"address","nodeType":"ElementaryTypeName","src":"23887:7:120","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"23886:9:120"},"scope":59299,"stateMutability":"nonpayable","virtual":false,"visibility":"internal"}],"abstract":false,"baseContracts":[{"baseName":{"id":58250,"name":"Script","nameLocations":["13167:6:120"],"nodeType":"IdentifierPath","referencedDeclaration":6037,"src":"13167:6:120"},"id":58251,"nodeType":"InheritanceSpecifier","src":"13167:6:120"}],"canonicalName":"FetchChainInfo","contractDependencies":[],"contractKind":"contract","fullyImplemented":true,"linearizedBaseContracts":[59299,6037,18860,11701,9611,5996,5984],"name":"FetchChainInfo","nameLocation":"13149:14:120","scope":59300,"usedErrors":[],"usedEvents":[]}],"license":"MIT"},"id":120} \ No newline at end of file +{"abi":[{"type":"function","name":"GUARDIAN","inputs":[],"outputs":[{"name":"","type":"address","internalType":"address"}],"stateMutability":"view"},{"type":"function","name":"L2_ORACLE","inputs":[],"outputs":[{"name":"","type":"address","internalType":"address"}],"stateMutability":"view"},{"type":"function","name":"PORTAL","inputs":[],"outputs":[{"name":"","type":"address","internalType":"address"}],"stateMutability":"view"},{"type":"function","name":"PROPOSER","inputs":[],"outputs":[{"name":"","type":"address","internalType":"address"}],"stateMutability":"view"},{"type":"function","name":"SYSTEM_CONFIG","inputs":[],"outputs":[{"name":"","type":"address","internalType":"address"}],"stateMutability":"view"},{"type":"function","name":"addressManager","inputs":[],"outputs":[{"name":"","type":"address","internalType":"address"}],"stateMutability":"view"},{"type":"function","name":"admin","inputs":[],"outputs":[{"name":"","type":"address","internalType":"address"}],"stateMutability":"view"},{"type":"function","name":"anchorStateRegistry","inputs":[],"outputs":[{"name":"","type":"address","internalType":"address"}],"stateMutability":"view"},{"type":"function","name":"batcherHash","inputs":[],"outputs":[{"name":"","type":"bytes32","internalType":"bytes32"}],"stateMutability":"view"},{"type":"function","name":"challenger","inputs":[],"outputs":[{"name":"","type":"address","internalType":"address"}],"stateMutability":"view"},{"type":"function","name":"disputeGameFactory","inputs":[],"outputs":[{"name":"","type":"address","internalType":"address"}],"stateMutability":"view"},{"type":"function","name":"ethLockbox","inputs":[],"outputs":[{"name":"","type":"address","internalType":"address"}],"stateMutability":"view"},{"type":"function","name":"gameImpls","inputs":[{"name":"_gameType","type":"uint32","internalType":"GameType"}],"outputs":[{"name":"","type":"address","internalType":"address"}],"stateMutability":"view"},{"type":"function","name":"guardian","inputs":[],"outputs":[{"name":"","type":"address","internalType":"address"}],"stateMutability":"view"},{"type":"function","name":"l1ERC721Bridge","inputs":[],"outputs":[{"name":"","type":"address","internalType":"address"}],"stateMutability":"view"},{"type":"function","name":"l2Oracle","inputs":[],"outputs":[{"name":"","type":"address","internalType":"address"}],"stateMutability":"view"},{"type":"function","name":"messenger","inputs":[],"outputs":[{"name":"","type":"address","internalType":"address"}],"stateMutability":"view"},{"type":"function","name":"optimismMintableERC20Factory","inputs":[],"outputs":[{"name":"","type":"address","internalType":"address"}],"stateMutability":"view"},{"type":"function","name":"oracle","inputs":[],"outputs":[{"name":"","type":"address","internalType":"address"}],"stateMutability":"view"},{"type":"function","name":"owner","inputs":[],"outputs":[{"name":"","type":"address","internalType":"address"}],"stateMutability":"view"},{"type":"function","name":"portal","inputs":[],"outputs":[{"name":"","type":"address","internalType":"address"}],"stateMutability":"view"},{"type":"function","name":"proposer","inputs":[],"outputs":[{"name":"","type":"address","internalType":"address"}],"stateMutability":"view"},{"type":"function","name":"respectedGameType","inputs":[],"outputs":[{"name":"","type":"uint32","internalType":"GameType"}],"stateMutability":"view"},{"type":"function","name":"superchainConfig","inputs":[],"outputs":[{"name":"","type":"address","internalType":"address"}],"stateMutability":"view"},{"type":"function","name":"systemConfig","inputs":[],"outputs":[{"name":"","type":"address","internalType":"address"}],"stateMutability":"view"},{"type":"function","name":"unsafeBlockSigner","inputs":[],"outputs":[{"name":"","type":"address","internalType":"address"}],"stateMutability":"view"},{"type":"function","name":"vm","inputs":[],"outputs":[{"name":"","type":"address","internalType":"address"}],"stateMutability":"view"},{"type":"function","name":"weth","inputs":[],"outputs":[{"name":"","type":"address","internalType":"address"}],"stateMutability":"view"}],"bytecode":{"object":"0x","sourceMap":"","linkReferences":{}},"deployedBytecode":{"object":"0x","sourceMap":"","linkReferences":{}},"methodIdentifiers":{"GUARDIAN()":"724c184c","L2_ORACLE()":"001c2ff6","PORTAL()":"0ff754ea","PROPOSER()":"bffa7f0f","SYSTEM_CONFIG()":"f0498750","addressManager()":"3ab76e9f","admin()":"f851a440","anchorStateRegistry()":"5c0cba33","batcherHash()":"e81b2c6d","challenger()":"534db0e2","disputeGameFactory()":"f2b4e617","ethLockbox()":"b682c444","gameImpls(uint32)":"1b685b9e","guardian()":"452a9320","l1ERC721Bridge()":"c4e8ddfa","l2Oracle()":"9b5f694a","messenger()":"3cb747bf","optimismMintableERC20Factory()":"9b7d7f0a","oracle()":"7dc0d1d0","owner()":"8da5cb5b","portal()":"6425666b","proposer()":"a8e4fb90","respectedGameType()":"3c9f397c","superchainConfig()":"35e80ab3","systemConfig()":"33d7e2bd","unsafeBlockSigner()":"1fd19ee1","vm()":"3a768463","weth()":"3fc8cef3"},"rawMetadata":"{\"compiler\":{\"version\":\"0.8.27+commit.40a35a09\"},\"language\":\"Solidity\",\"output\":{\"abi\":[{\"inputs\":[],\"name\":\"GUARDIAN\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"L2_ORACLE\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"PORTAL\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"PROPOSER\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"SYSTEM_CONFIG\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"addressManager\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"admin\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"anchorStateRegistry\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"batcherHash\",\"outputs\":[{\"internalType\":\"bytes32\",\"name\":\"\",\"type\":\"bytes32\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"challenger\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"disputeGameFactory\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"ethLockbox\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"GameType\",\"name\":\"_gameType\",\"type\":\"uint32\"}],\"name\":\"gameImpls\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"guardian\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"l1ERC721Bridge\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"l2Oracle\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"messenger\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"optimismMintableERC20Factory\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"oracle\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"owner\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"portal\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"proposer\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"respectedGameType\",\"outputs\":[{\"internalType\":\"GameType\",\"name\":\"\",\"type\":\"uint32\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"superchainConfig\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"systemConfig\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"unsafeBlockSigner\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"vm\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"weth\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"}],\"devdoc\":{\"kind\":\"dev\",\"methods\":{},\"version\":1},\"userdoc\":{\"kind\":\"user\",\"methods\":{},\"notice\":\"Contains getters for arbitrary methods from all L1 contracts, including legacy getters that have since been deprecated.\",\"version\":1}},\"settings\":{\"compilationTarget\":{\"scripts/FetchChainInfo.s.sol\":\"IFetcher\"},\"evmVersion\":\"cancun\",\"libraries\":{},\"metadata\":{\"bytecodeHash\":\"none\",\"useLiteralContent\":true},\"optimizer\":{\"enabled\":false,\"runs\":0},\"remappings\":[\":@lib-keccak/=lib/lib-keccak/contracts/lib/\",\":@openzeppelin/contracts-upgradeable/=lib/openzeppelin-contracts-upgradeable/contracts/\",\":@openzeppelin/contracts-v5/=lib/openzeppelin-contracts-v5/contracts/\",\":@openzeppelin/contracts/=lib/openzeppelin-contracts/contracts/\",\":@rari-capital/solmate/=lib/solmate/\",\":@solady-test/=lib/lib-keccak/lib/solady/test/\",\":@solady-v0.0.245/=lib/solady-v0.0.245/src/\",\":@solady/=lib/solady/src/\",\":ds-test/=lib/forge-std/lib/ds-test/src/\",\":erc4626-tests/=lib/openzeppelin-contracts-v5/lib/erc4626-tests/\",\":forge-std/=lib/forge-std/src/\",\":interfaces/=interfaces/\",\":kontrol-cheatcodes/=lib/kontrol-cheatcodes/src/\",\":lib-keccak/=lib/lib-keccak/contracts/\",\":openzeppelin-contracts-upgradeable/=lib/openzeppelin-contracts-upgradeable/\",\":openzeppelin-contracts-v5/=lib/openzeppelin-contracts-v5/\",\":openzeppelin-contracts/=lib/openzeppelin-contracts/\",\":safe-contracts/=lib/safe-contracts/contracts/\",\":solady-v0.0.245/=lib/solady-v0.0.245/src/\",\":solady/=lib/solady/\",\":solmate/=lib/solmate/src/\"]},\"sources\":{\"lib/forge-std/src/Base.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity >=0.6.2 <0.9.0;\\n\\nimport {StdStorage} from \\\"./StdStorage.sol\\\";\\nimport {Vm, VmSafe} from \\\"./Vm.sol\\\";\\n\\nabstract contract CommonBase {\\n /// @dev Cheat code address.\\n /// Calculated as `address(uint160(uint256(keccak256(\\\"hevm cheat code\\\"))))`.\\n address internal constant VM_ADDRESS = 0x7109709ECfa91a80626fF3989D68f67F5b1DD12D;\\n /// @dev console.sol and console2.sol work by executing a staticcall to this address.\\n /// Calculated as `address(uint160(uint88(bytes11(\\\"console.log\\\"))))`.\\n address internal constant CONSOLE = 0x000000000000000000636F6e736F6c652e6c6f67;\\n /// @dev Used when deploying with create2.\\n /// Taken from https://github.com/Arachnid/deterministic-deployment-proxy.\\n address internal constant CREATE2_FACTORY = 0x4e59b44847b379578588920cA78FbF26c0B4956C;\\n /// @dev The default address for tx.origin and msg.sender.\\n /// Calculated as `address(uint160(uint256(keccak256(\\\"foundry default caller\\\"))))`.\\n address internal constant DEFAULT_SENDER = 0x1804c8AB1F12E6bbf3894d4083f33e07309d1f38;\\n /// @dev The address of the first contract `CREATE`d by a running test contract.\\n /// When running tests, each test contract is `CREATE`d by `DEFAULT_SENDER` with nonce 1.\\n /// Calculated as `VM.computeCreateAddress(VM.computeCreateAddress(DEFAULT_SENDER, 1), 1)`.\\n address internal constant DEFAULT_TEST_CONTRACT = 0x5615dEB798BB3E4dFa0139dFa1b3D433Cc23b72f;\\n /// @dev Deterministic deployment address of the Multicall3 contract.\\n /// Taken from https://www.multicall3.com.\\n address internal constant MULTICALL3_ADDRESS = 0xcA11bde05977b3631167028862bE2a173976CA11;\\n /// @dev The order of the secp256k1 curve.\\n uint256 internal constant SECP256K1_ORDER =\\n 115792089237316195423570985008687907852837564279074904382605163141518161494337;\\n\\n uint256 internal constant UINT256_MAX =\\n 115792089237316195423570985008687907853269984665640564039457584007913129639935;\\n\\n Vm internal constant vm = Vm(VM_ADDRESS);\\n StdStorage internal stdstore;\\n}\\n\\nabstract contract TestBase is CommonBase {}\\n\\nabstract contract ScriptBase is CommonBase {\\n VmSafe internal constant vmSafe = VmSafe(VM_ADDRESS);\\n}\\n\",\"keccak256\":\"0xa3735a6618a3014e42bb4329ad143e3b2c59cd95094350202e4c4a06c9d585dd\",\"license\":\"MIT\"},\"lib/forge-std/src/Script.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity >=0.6.2 <0.9.0;\\n\\n// \\ud83d\\udcac ABOUT\\n// Forge Std's default Script.\\n\\n// \\ud83e\\udde9 MODULES\\nimport {console} from \\\"./console.sol\\\";\\nimport {console2} from \\\"./console2.sol\\\";\\nimport {safeconsole} from \\\"./safeconsole.sol\\\";\\nimport {StdChains} from \\\"./StdChains.sol\\\";\\nimport {StdCheatsSafe} from \\\"./StdCheats.sol\\\";\\nimport {StdConstants} from \\\"./StdConstants.sol\\\";\\nimport {stdJson} from \\\"./StdJson.sol\\\";\\nimport {stdMath} from \\\"./StdMath.sol\\\";\\nimport {StdStorage, stdStorageSafe} from \\\"./StdStorage.sol\\\";\\nimport {StdStyle} from \\\"./StdStyle.sol\\\";\\nimport {StdUtils} from \\\"./StdUtils.sol\\\";\\nimport {VmSafe} from \\\"./Vm.sol\\\";\\n\\n// \\ud83d\\udce6 BOILERPLATE\\nimport {ScriptBase} from \\\"./Base.sol\\\";\\n\\n// \\u2b50\\ufe0f SCRIPT\\nabstract contract Script is ScriptBase, StdChains, StdCheatsSafe, StdUtils {\\n // Note: IS_SCRIPT() must return true.\\n bool public IS_SCRIPT = true;\\n}\\n\",\"keccak256\":\"0xc942e27c7baae499beb01afbbae99f24d42af9a6e4aae675bc6901b704aa8e9b\",\"license\":\"MIT\"},\"lib/forge-std/src/StdChains.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity >=0.6.2 <0.9.0;\\n\\nimport {VmSafe} from \\\"./Vm.sol\\\";\\n\\n/**\\n * StdChains provides information about EVM compatible chains that can be used in scripts/tests.\\n * For each chain, the chain's name, chain ID, and a default RPC URL are provided. Chains are\\n * identified by their alias, which is the same as the alias in the `[rpc_endpoints]` section of\\n * the `foundry.toml` file. For best UX, ensure the alias in the `foundry.toml` file match the\\n * alias used in this contract, which can be found as the first argument to the\\n * `setChainWithDefaultRpcUrl` call in the `initializeStdChains` function.\\n *\\n * There are two main ways to use this contract:\\n * 1. Set a chain with `setChain(string memory chainAlias, ChainData memory chain)` or\\n * `setChain(string memory chainAlias, Chain memory chain)`\\n * 2. Get a chain with `getChain(string memory chainAlias)` or `getChain(uint256 chainId)`.\\n *\\n * The first time either of those are used, chains are initialized with the default set of RPC URLs.\\n * This is done in `initializeStdChains`, which uses `setChainWithDefaultRpcUrl`. Defaults are recorded in\\n * `defaultRpcUrls`.\\n *\\n * The `setChain` function is straightforward, and it simply saves off the given chain data.\\n *\\n * The `getChain` methods use `getChainWithUpdatedRpcUrl` to return a chain. For example, let's say\\n * we want to retrieve the RPC URL for `mainnet`:\\n * - If you have specified data with `setChain`, it will return that.\\n * - If you have configured a mainnet RPC URL in `foundry.toml`, it will return the URL, provided it\\n * is valid (e.g. a URL is specified, or an environment variable is given and exists).\\n * - If neither of the above conditions is met, the default data is returned.\\n *\\n * Summarizing the above, the prioritization hierarchy is `setChain` -> `foundry.toml` -> environment variable -> defaults.\\n */\\nabstract contract StdChains {\\n VmSafe private constant vm = VmSafe(address(uint160(uint256(keccak256(\\\"hevm cheat code\\\")))));\\n\\n bool private stdChainsInitialized;\\n\\n struct ChainData {\\n string name;\\n uint256 chainId;\\n string rpcUrl;\\n }\\n\\n struct Chain {\\n // The chain name.\\n string name;\\n // The chain's Chain ID.\\n uint256 chainId;\\n // The chain's alias. (i.e. what gets specified in `foundry.toml`).\\n string chainAlias;\\n // A default RPC endpoint for this chain.\\n // NOTE: This default RPC URL is included for convenience to facilitate quick tests and\\n // experimentation. Do not use this RPC URL for production test suites, CI, or other heavy\\n // usage as you will be throttled and this is a disservice to others who need this endpoint.\\n string rpcUrl;\\n }\\n\\n // Maps from the chain's alias (matching the alias in the `foundry.toml` file) to chain data.\\n mapping(string => Chain) private chains;\\n // Maps from the chain's alias to it's default RPC URL.\\n mapping(string => string) private defaultRpcUrls;\\n // Maps from a chain ID to it's alias.\\n mapping(uint256 => string) private idToAlias;\\n\\n bool private fallbackToDefaultRpcUrls = true;\\n\\n // The RPC URL will be fetched from config or defaultRpcUrls if possible.\\n function getChain(string memory chainAlias) internal virtual returns (Chain memory chain) {\\n require(bytes(chainAlias).length != 0, \\\"StdChains getChain(string): Chain alias cannot be the empty string.\\\");\\n\\n initializeStdChains();\\n chain = chains[chainAlias];\\n require(\\n chain.chainId != 0,\\n string(abi.encodePacked(\\\"StdChains getChain(string): Chain with alias \\\\\\\"\\\", chainAlias, \\\"\\\\\\\" not found.\\\"))\\n );\\n\\n chain = getChainWithUpdatedRpcUrl(chainAlias, chain);\\n }\\n\\n function getChain(uint256 chainId) internal virtual returns (Chain memory chain) {\\n require(chainId != 0, \\\"StdChains getChain(uint256): Chain ID cannot be 0.\\\");\\n initializeStdChains();\\n string memory chainAlias = idToAlias[chainId];\\n\\n chain = chains[chainAlias];\\n\\n require(\\n chain.chainId != 0,\\n string(abi.encodePacked(\\\"StdChains getChain(uint256): Chain with ID \\\", vm.toString(chainId), \\\" not found.\\\"))\\n );\\n\\n chain = getChainWithUpdatedRpcUrl(chainAlias, chain);\\n }\\n\\n // set chain info, with priority to argument's rpcUrl field.\\n function setChain(string memory chainAlias, ChainData memory chain) internal virtual {\\n require(\\n bytes(chainAlias).length != 0,\\n \\\"StdChains setChain(string,ChainData): Chain alias cannot be the empty string.\\\"\\n );\\n\\n require(chain.chainId != 0, \\\"StdChains setChain(string,ChainData): Chain ID cannot be 0.\\\");\\n\\n initializeStdChains();\\n string memory foundAlias = idToAlias[chain.chainId];\\n\\n require(\\n bytes(foundAlias).length == 0 || keccak256(bytes(foundAlias)) == keccak256(bytes(chainAlias)),\\n string(\\n abi.encodePacked(\\n \\\"StdChains setChain(string,ChainData): Chain ID \\\",\\n vm.toString(chain.chainId),\\n \\\" already used by \\\\\\\"\\\",\\n foundAlias,\\n \\\"\\\\\\\".\\\"\\n )\\n )\\n );\\n\\n uint256 oldChainId = chains[chainAlias].chainId;\\n delete idToAlias[oldChainId];\\n\\n chains[chainAlias] =\\n Chain({name: chain.name, chainId: chain.chainId, chainAlias: chainAlias, rpcUrl: chain.rpcUrl});\\n idToAlias[chain.chainId] = chainAlias;\\n }\\n\\n // set chain info, with priority to argument's rpcUrl field.\\n function setChain(string memory chainAlias, Chain memory chain) internal virtual {\\n setChain(chainAlias, ChainData({name: chain.name, chainId: chain.chainId, rpcUrl: chain.rpcUrl}));\\n }\\n\\n function _toUpper(string memory str) private pure returns (string memory) {\\n bytes memory strb = bytes(str);\\n bytes memory copy = new bytes(strb.length);\\n for (uint256 i = 0; i < strb.length; i++) {\\n bytes1 b = strb[i];\\n if (b >= 0x61 && b <= 0x7A) {\\n copy[i] = bytes1(uint8(b) - 32);\\n } else {\\n copy[i] = b;\\n }\\n }\\n return string(copy);\\n }\\n\\n // lookup rpcUrl, in descending order of priority:\\n // current -> config (foundry.toml) -> environment variable -> default\\n function getChainWithUpdatedRpcUrl(string memory chainAlias, Chain memory chain)\\n private\\n view\\n returns (Chain memory)\\n {\\n if (bytes(chain.rpcUrl).length == 0) {\\n try vm.rpcUrl(chainAlias) returns (string memory configRpcUrl) {\\n chain.rpcUrl = configRpcUrl;\\n } catch (bytes memory err) {\\n string memory envName = string(abi.encodePacked(_toUpper(chainAlias), \\\"_RPC_URL\\\"));\\n if (fallbackToDefaultRpcUrls) {\\n chain.rpcUrl = vm.envOr(envName, defaultRpcUrls[chainAlias]);\\n } else {\\n chain.rpcUrl = vm.envString(envName);\\n }\\n // Distinguish 'not found' from 'cannot read'\\n // The upstream error thrown by forge for failing cheats changed so we check both the old and new versions\\n bytes memory oldNotFoundError =\\n abi.encodeWithSignature(\\\"CheatCodeError\\\", string(abi.encodePacked(\\\"invalid rpc url \\\", chainAlias)));\\n bytes memory newNotFoundError = abi.encodeWithSignature(\\n \\\"CheatcodeError(string)\\\", string(abi.encodePacked(\\\"invalid rpc url: \\\", chainAlias))\\n );\\n bytes32 errHash = keccak256(err);\\n if (\\n (errHash != keccak256(oldNotFoundError) && errHash != keccak256(newNotFoundError))\\n || bytes(chain.rpcUrl).length == 0\\n ) {\\n /// @solidity memory-safe-assembly\\n assembly {\\n revert(add(32, err), mload(err))\\n }\\n }\\n }\\n }\\n return chain;\\n }\\n\\n function setFallbackToDefaultRpcUrls(bool useDefault) internal {\\n fallbackToDefaultRpcUrls = useDefault;\\n }\\n\\n function initializeStdChains() private {\\n if (stdChainsInitialized) return;\\n\\n stdChainsInitialized = true;\\n\\n // If adding an RPC here, make sure to test the default RPC URL in `test_Rpcs` in `StdChains.t.sol`\\n setChainWithDefaultRpcUrl(\\\"anvil\\\", ChainData(\\\"Anvil\\\", 31337, \\\"http://127.0.0.1:8545\\\"));\\n setChainWithDefaultRpcUrl(\\\"mainnet\\\", ChainData(\\\"Mainnet\\\", 1, \\\"https://eth.llamarpc.com\\\"));\\n setChainWithDefaultRpcUrl(\\n \\\"sepolia\\\", ChainData(\\\"Sepolia\\\", 11155111, \\\"https://sepolia.infura.io/v3/b9794ad1ddf84dfb8c34d6bb5dca2001\\\")\\n );\\n setChainWithDefaultRpcUrl(\\\"holesky\\\", ChainData(\\\"Holesky\\\", 17000, \\\"https://rpc.holesky.ethpandaops.io\\\"));\\n setChainWithDefaultRpcUrl(\\\"optimism\\\", ChainData(\\\"Optimism\\\", 10, \\\"https://mainnet.optimism.io\\\"));\\n setChainWithDefaultRpcUrl(\\n \\\"optimism_sepolia\\\", ChainData(\\\"Optimism Sepolia\\\", 11155420, \\\"https://sepolia.optimism.io\\\")\\n );\\n setChainWithDefaultRpcUrl(\\\"arbitrum_one\\\", ChainData(\\\"Arbitrum One\\\", 42161, \\\"https://arb1.arbitrum.io/rpc\\\"));\\n setChainWithDefaultRpcUrl(\\n \\\"arbitrum_one_sepolia\\\", ChainData(\\\"Arbitrum One Sepolia\\\", 421614, \\\"https://sepolia-rollup.arbitrum.io/rpc\\\")\\n );\\n setChainWithDefaultRpcUrl(\\\"arbitrum_nova\\\", ChainData(\\\"Arbitrum Nova\\\", 42170, \\\"https://nova.arbitrum.io/rpc\\\"));\\n setChainWithDefaultRpcUrl(\\\"polygon\\\", ChainData(\\\"Polygon\\\", 137, \\\"https://polygon-rpc.com\\\"));\\n setChainWithDefaultRpcUrl(\\n \\\"polygon_amoy\\\", ChainData(\\\"Polygon Amoy\\\", 80002, \\\"https://rpc-amoy.polygon.technology\\\")\\n );\\n setChainWithDefaultRpcUrl(\\\"avalanche\\\", ChainData(\\\"Avalanche\\\", 43114, \\\"https://api.avax.network/ext/bc/C/rpc\\\"));\\n setChainWithDefaultRpcUrl(\\n \\\"avalanche_fuji\\\", ChainData(\\\"Avalanche Fuji\\\", 43113, \\\"https://api.avax-test.network/ext/bc/C/rpc\\\")\\n );\\n setChainWithDefaultRpcUrl(\\n \\\"bnb_smart_chain\\\", ChainData(\\\"BNB Smart Chain\\\", 56, \\\"https://bsc-dataseed1.binance.org\\\")\\n );\\n setChainWithDefaultRpcUrl(\\n \\\"bnb_smart_chain_testnet\\\",\\n ChainData(\\\"BNB Smart Chain Testnet\\\", 97, \\\"https://rpc.ankr.com/bsc_testnet_chapel\\\")\\n );\\n setChainWithDefaultRpcUrl(\\\"gnosis_chain\\\", ChainData(\\\"Gnosis Chain\\\", 100, \\\"https://rpc.gnosischain.com\\\"));\\n setChainWithDefaultRpcUrl(\\\"moonbeam\\\", ChainData(\\\"Moonbeam\\\", 1284, \\\"https://rpc.api.moonbeam.network\\\"));\\n setChainWithDefaultRpcUrl(\\n \\\"moonriver\\\", ChainData(\\\"Moonriver\\\", 1285, \\\"https://rpc.api.moonriver.moonbeam.network\\\")\\n );\\n setChainWithDefaultRpcUrl(\\\"moonbase\\\", ChainData(\\\"Moonbase\\\", 1287, \\\"https://rpc.testnet.moonbeam.network\\\"));\\n setChainWithDefaultRpcUrl(\\\"base_sepolia\\\", ChainData(\\\"Base Sepolia\\\", 84532, \\\"https://sepolia.base.org\\\"));\\n setChainWithDefaultRpcUrl(\\\"base\\\", ChainData(\\\"Base\\\", 8453, \\\"https://mainnet.base.org\\\"));\\n setChainWithDefaultRpcUrl(\\\"blast_sepolia\\\", ChainData(\\\"Blast Sepolia\\\", 168587773, \\\"https://sepolia.blast.io\\\"));\\n setChainWithDefaultRpcUrl(\\\"blast\\\", ChainData(\\\"Blast\\\", 81457, \\\"https://rpc.blast.io\\\"));\\n setChainWithDefaultRpcUrl(\\\"fantom_opera\\\", ChainData(\\\"Fantom Opera\\\", 250, \\\"https://rpc.ankr.com/fantom/\\\"));\\n setChainWithDefaultRpcUrl(\\n \\\"fantom_opera_testnet\\\", ChainData(\\\"Fantom Opera Testnet\\\", 4002, \\\"https://rpc.ankr.com/fantom_testnet/\\\")\\n );\\n setChainWithDefaultRpcUrl(\\\"fraxtal\\\", ChainData(\\\"Fraxtal\\\", 252, \\\"https://rpc.frax.com\\\"));\\n setChainWithDefaultRpcUrl(\\\"fraxtal_testnet\\\", ChainData(\\\"Fraxtal Testnet\\\", 2522, \\\"https://rpc.testnet.frax.com\\\"));\\n setChainWithDefaultRpcUrl(\\n \\\"berachain_bartio_testnet\\\", ChainData(\\\"Berachain bArtio Testnet\\\", 80084, \\\"https://bartio.rpc.berachain.com\\\")\\n );\\n setChainWithDefaultRpcUrl(\\\"flare\\\", ChainData(\\\"Flare\\\", 14, \\\"https://flare-api.flare.network/ext/C/rpc\\\"));\\n setChainWithDefaultRpcUrl(\\n \\\"flare_coston2\\\", ChainData(\\\"Flare Coston2\\\", 114, \\\"https://coston2-api.flare.network/ext/C/rpc\\\")\\n );\\n\\n setChainWithDefaultRpcUrl(\\\"mode\\\", ChainData(\\\"Mode\\\", 34443, \\\"https://mode.drpc.org\\\"));\\n setChainWithDefaultRpcUrl(\\\"mode_sepolia\\\", ChainData(\\\"Mode Sepolia\\\", 919, \\\"https://sepolia.mode.network\\\"));\\n\\n setChainWithDefaultRpcUrl(\\\"zora\\\", ChainData(\\\"Zora\\\", 7777777, \\\"https://zora.drpc.org\\\"));\\n setChainWithDefaultRpcUrl(\\n \\\"zora_sepolia\\\", ChainData(\\\"Zora Sepolia\\\", 999999999, \\\"https://sepolia.rpc.zora.energy\\\")\\n );\\n\\n setChainWithDefaultRpcUrl(\\\"race\\\", ChainData(\\\"Race\\\", 6805, \\\"https://racemainnet.io\\\"));\\n setChainWithDefaultRpcUrl(\\\"race_sepolia\\\", ChainData(\\\"Race Sepolia\\\", 6806, \\\"https://racemainnet.io\\\"));\\n\\n setChainWithDefaultRpcUrl(\\\"metal\\\", ChainData(\\\"Metal\\\", 1750, \\\"https://metall2.drpc.org\\\"));\\n setChainWithDefaultRpcUrl(\\\"metal_sepolia\\\", ChainData(\\\"Metal Sepolia\\\", 1740, \\\"https://testnet.rpc.metall2.com\\\"));\\n\\n setChainWithDefaultRpcUrl(\\\"binary\\\", ChainData(\\\"Binary\\\", 624, \\\"https://rpc.zero.thebinaryholdings.com\\\"));\\n setChainWithDefaultRpcUrl(\\n \\\"binary_sepolia\\\", ChainData(\\\"Binary Sepolia\\\", 625, \\\"https://rpc.zero.thebinaryholdings.com\\\")\\n );\\n\\n setChainWithDefaultRpcUrl(\\\"orderly\\\", ChainData(\\\"Orderly\\\", 291, \\\"https://rpc.orderly.network\\\"));\\n setChainWithDefaultRpcUrl(\\n \\\"orderly_sepolia\\\", ChainData(\\\"Orderly Sepolia\\\", 4460, \\\"https://testnet-rpc.orderly.org\\\")\\n );\\n }\\n\\n // set chain info, with priority to chainAlias' rpc url in foundry.toml\\n function setChainWithDefaultRpcUrl(string memory chainAlias, ChainData memory chain) private {\\n string memory rpcUrl = chain.rpcUrl;\\n defaultRpcUrls[chainAlias] = rpcUrl;\\n chain.rpcUrl = \\\"\\\";\\n setChain(chainAlias, chain);\\n chain.rpcUrl = rpcUrl; // restore argument\\n }\\n}\\n\",\"keccak256\":\"0x200b597cd01c229633b4a2317846cac7d36d337e2381b4a2e81faac23c2ad1cf\",\"license\":\"MIT\"},\"lib/forge-std/src/StdCheats.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity >=0.6.2 <0.9.0;\\n\\npragma experimental ABIEncoderV2;\\n\\nimport {StdStorage, stdStorage} from \\\"./StdStorage.sol\\\";\\nimport {console2} from \\\"./console2.sol\\\";\\nimport {Vm} from \\\"./Vm.sol\\\";\\n\\nabstract contract StdCheatsSafe {\\n Vm private constant vm = Vm(address(uint160(uint256(keccak256(\\\"hevm cheat code\\\")))));\\n\\n uint256 private constant UINT256_MAX =\\n 115792089237316195423570985008687907853269984665640564039457584007913129639935;\\n\\n bool private gasMeteringOff;\\n\\n // Data structures to parse Transaction objects from the broadcast artifact\\n // that conform to EIP1559. The Raw structs is what is parsed from the JSON\\n // and then converted to the one that is used by the user for better UX.\\n\\n struct RawTx1559 {\\n string[] arguments;\\n address contractAddress;\\n string contractName;\\n // json value name = function\\n string functionSig;\\n bytes32 hash;\\n // json value name = tx\\n RawTx1559Detail txDetail;\\n // json value name = type\\n string opcode;\\n }\\n\\n struct RawTx1559Detail {\\n AccessList[] accessList;\\n bytes data;\\n address from;\\n bytes gas;\\n bytes nonce;\\n address to;\\n bytes txType;\\n bytes value;\\n }\\n\\n struct Tx1559 {\\n string[] arguments;\\n address contractAddress;\\n string contractName;\\n string functionSig;\\n bytes32 hash;\\n Tx1559Detail txDetail;\\n string opcode;\\n }\\n\\n struct Tx1559Detail {\\n AccessList[] accessList;\\n bytes data;\\n address from;\\n uint256 gas;\\n uint256 nonce;\\n address to;\\n uint256 txType;\\n uint256 value;\\n }\\n\\n // Data structures to parse Transaction objects from the broadcast artifact\\n // that DO NOT conform to EIP1559. The Raw structs is what is parsed from the JSON\\n // and then converted to the one that is used by the user for better UX.\\n\\n struct TxLegacy {\\n string[] arguments;\\n address contractAddress;\\n string contractName;\\n string functionSig;\\n string hash;\\n string opcode;\\n TxDetailLegacy transaction;\\n }\\n\\n struct TxDetailLegacy {\\n AccessList[] accessList;\\n uint256 chainId;\\n bytes data;\\n address from;\\n uint256 gas;\\n uint256 gasPrice;\\n bytes32 hash;\\n uint256 nonce;\\n bytes1 opcode;\\n bytes32 r;\\n bytes32 s;\\n uint256 txType;\\n address to;\\n uint8 v;\\n uint256 value;\\n }\\n\\n struct AccessList {\\n address accessAddress;\\n bytes32[] storageKeys;\\n }\\n\\n // Data structures to parse Receipt objects from the broadcast artifact.\\n // The Raw structs is what is parsed from the JSON\\n // and then converted to the one that is used by the user for better UX.\\n\\n struct RawReceipt {\\n bytes32 blockHash;\\n bytes blockNumber;\\n address contractAddress;\\n bytes cumulativeGasUsed;\\n bytes effectiveGasPrice;\\n address from;\\n bytes gasUsed;\\n RawReceiptLog[] logs;\\n bytes logsBloom;\\n bytes status;\\n address to;\\n bytes32 transactionHash;\\n bytes transactionIndex;\\n }\\n\\n struct Receipt {\\n bytes32 blockHash;\\n uint256 blockNumber;\\n address contractAddress;\\n uint256 cumulativeGasUsed;\\n uint256 effectiveGasPrice;\\n address from;\\n uint256 gasUsed;\\n ReceiptLog[] logs;\\n bytes logsBloom;\\n uint256 status;\\n address to;\\n bytes32 transactionHash;\\n uint256 transactionIndex;\\n }\\n\\n // Data structures to parse the entire broadcast artifact, assuming the\\n // transactions conform to EIP1559.\\n\\n struct EIP1559ScriptArtifact {\\n string[] libraries;\\n string path;\\n string[] pending;\\n Receipt[] receipts;\\n uint256 timestamp;\\n Tx1559[] transactions;\\n TxReturn[] txReturns;\\n }\\n\\n struct RawEIP1559ScriptArtifact {\\n string[] libraries;\\n string path;\\n string[] pending;\\n RawReceipt[] receipts;\\n TxReturn[] txReturns;\\n uint256 timestamp;\\n RawTx1559[] transactions;\\n }\\n\\n struct RawReceiptLog {\\n // json value = address\\n address logAddress;\\n bytes32 blockHash;\\n bytes blockNumber;\\n bytes data;\\n bytes logIndex;\\n bool removed;\\n bytes32[] topics;\\n bytes32 transactionHash;\\n bytes transactionIndex;\\n bytes transactionLogIndex;\\n }\\n\\n struct ReceiptLog {\\n // json value = address\\n address logAddress;\\n bytes32 blockHash;\\n uint256 blockNumber;\\n bytes data;\\n uint256 logIndex;\\n bytes32[] topics;\\n uint256 transactionIndex;\\n uint256 transactionLogIndex;\\n bool removed;\\n }\\n\\n struct TxReturn {\\n string internalType;\\n string value;\\n }\\n\\n struct Account {\\n address addr;\\n uint256 key;\\n }\\n\\n enum AddressType {\\n Payable,\\n NonPayable,\\n ZeroAddress,\\n Precompile,\\n ForgeAddress\\n }\\n\\n // Checks that `addr` is not blacklisted by token contracts that have a blacklist.\\n function assumeNotBlacklisted(address token, address addr) internal view virtual {\\n // Nothing to check if `token` is not a contract.\\n uint256 tokenCodeSize;\\n assembly {\\n tokenCodeSize := extcodesize(token)\\n }\\n require(tokenCodeSize > 0, \\\"StdCheats assumeNotBlacklisted(address,address): Token address is not a contract.\\\");\\n\\n bool success;\\n bytes memory returnData;\\n\\n // 4-byte selector for `isBlacklisted(address)`, used by USDC.\\n (success, returnData) = token.staticcall(abi.encodeWithSelector(0xfe575a87, addr));\\n vm.assume(!success || abi.decode(returnData, (bool)) == false);\\n\\n // 4-byte selector for `isBlackListed(address)`, used by USDT.\\n (success, returnData) = token.staticcall(abi.encodeWithSelector(0xe47d6060, addr));\\n vm.assume(!success || abi.decode(returnData, (bool)) == false);\\n }\\n\\n // Checks that `addr` is not blacklisted by token contracts that have a blacklist.\\n // This is identical to `assumeNotBlacklisted(address,address)` but with a different name, for\\n // backwards compatibility, since this name was used in the original PR which already has\\n // a release. This function can be removed in a future release once we want a breaking change.\\n function assumeNoBlacklisted(address token, address addr) internal view virtual {\\n assumeNotBlacklisted(token, addr);\\n }\\n\\n function assumeAddressIsNot(address addr, AddressType addressType) internal virtual {\\n if (addressType == AddressType.Payable) {\\n assumeNotPayable(addr);\\n } else if (addressType == AddressType.NonPayable) {\\n assumePayable(addr);\\n } else if (addressType == AddressType.ZeroAddress) {\\n assumeNotZeroAddress(addr);\\n } else if (addressType == AddressType.Precompile) {\\n assumeNotPrecompile(addr);\\n } else if (addressType == AddressType.ForgeAddress) {\\n assumeNotForgeAddress(addr);\\n }\\n }\\n\\n function assumeAddressIsNot(address addr, AddressType addressType1, AddressType addressType2) internal virtual {\\n assumeAddressIsNot(addr, addressType1);\\n assumeAddressIsNot(addr, addressType2);\\n }\\n\\n function assumeAddressIsNot(\\n address addr,\\n AddressType addressType1,\\n AddressType addressType2,\\n AddressType addressType3\\n ) internal virtual {\\n assumeAddressIsNot(addr, addressType1);\\n assumeAddressIsNot(addr, addressType2);\\n assumeAddressIsNot(addr, addressType3);\\n }\\n\\n function assumeAddressIsNot(\\n address addr,\\n AddressType addressType1,\\n AddressType addressType2,\\n AddressType addressType3,\\n AddressType addressType4\\n ) internal virtual {\\n assumeAddressIsNot(addr, addressType1);\\n assumeAddressIsNot(addr, addressType2);\\n assumeAddressIsNot(addr, addressType3);\\n assumeAddressIsNot(addr, addressType4);\\n }\\n\\n // This function checks whether an address, `addr`, is payable. It works by sending 1 wei to\\n // `addr` and checking the `success` return value.\\n // NOTE: This function may result in state changes depending on the fallback/receive logic\\n // implemented by `addr`, which should be taken into account when this function is used.\\n function _isPayable(address addr) private returns (bool) {\\n require(\\n addr.balance < UINT256_MAX,\\n \\\"StdCheats _isPayable(address): Balance equals max uint256, so it cannot receive any more funds\\\"\\n );\\n uint256 origBalanceTest = address(this).balance;\\n uint256 origBalanceAddr = address(addr).balance;\\n\\n vm.deal(address(this), 1);\\n (bool success,) = payable(addr).call{value: 1}(\\\"\\\");\\n\\n // reset balances\\n vm.deal(address(this), origBalanceTest);\\n vm.deal(addr, origBalanceAddr);\\n\\n return success;\\n }\\n\\n // NOTE: This function may result in state changes depending on the fallback/receive logic\\n // implemented by `addr`, which should be taken into account when this function is used. See the\\n // `_isPayable` method for more information.\\n function assumePayable(address addr) internal virtual {\\n vm.assume(_isPayable(addr));\\n }\\n\\n function assumeNotPayable(address addr) internal virtual {\\n vm.assume(!_isPayable(addr));\\n }\\n\\n function assumeNotZeroAddress(address addr) internal pure virtual {\\n vm.assume(addr != address(0));\\n }\\n\\n function assumeNotPrecompile(address addr) internal pure virtual {\\n assumeNotPrecompile(addr, _pureChainId());\\n }\\n\\n function assumeNotPrecompile(address addr, uint256 chainId) internal pure virtual {\\n // Note: For some chains like Optimism these are technically predeploys (i.e. bytecode placed at a specific\\n // address), but the same rationale for excluding them applies so we include those too.\\n\\n // These are reserved by Ethereum and may be on all EVM-compatible chains.\\n vm.assume(addr < address(0x1) || addr > address(0xff));\\n\\n // forgefmt: disable-start\\n if (chainId == 10 || chainId == 420) {\\n // https://github.com/ethereum-optimism/optimism/blob/eaa371a0184b56b7ca6d9eb9cb0a2b78b2ccd864/op-bindings/predeploys/addresses.go#L6-L21\\n vm.assume(addr < address(0x4200000000000000000000000000000000000000) || addr > address(0x4200000000000000000000000000000000000800));\\n } else if (chainId == 42161 || chainId == 421613) {\\n // https://developer.arbitrum.io/useful-addresses#arbitrum-precompiles-l2-same-on-all-arb-chains\\n vm.assume(addr < address(0x0000000000000000000000000000000000000064) || addr > address(0x0000000000000000000000000000000000000068));\\n } else if (chainId == 43114 || chainId == 43113) {\\n // https://github.com/ava-labs/subnet-evm/blob/47c03fd007ecaa6de2c52ea081596e0a88401f58/precompile/params.go#L18-L59\\n vm.assume(addr < address(0x0100000000000000000000000000000000000000) || addr > address(0x01000000000000000000000000000000000000ff));\\n vm.assume(addr < address(0x0200000000000000000000000000000000000000) || addr > address(0x02000000000000000000000000000000000000FF));\\n vm.assume(addr < address(0x0300000000000000000000000000000000000000) || addr > address(0x03000000000000000000000000000000000000Ff));\\n }\\n // forgefmt: disable-end\\n }\\n\\n function assumeNotForgeAddress(address addr) internal pure virtual {\\n // vm, console, and Create2Deployer addresses\\n vm.assume(\\n addr != address(vm) && addr != 0x000000000000000000636F6e736F6c652e6c6f67\\n && addr != 0x4e59b44847b379578588920cA78FbF26c0B4956C\\n );\\n }\\n\\n function assumeUnusedAddress(address addr) internal view virtual {\\n uint256 size;\\n assembly {\\n size := extcodesize(addr)\\n }\\n vm.assume(size == 0);\\n\\n assumeNotPrecompile(addr);\\n assumeNotZeroAddress(addr);\\n assumeNotForgeAddress(addr);\\n }\\n\\n function readEIP1559ScriptArtifact(string memory path)\\n internal\\n view\\n virtual\\n returns (EIP1559ScriptArtifact memory)\\n {\\n string memory data = vm.readFile(path);\\n bytes memory parsedData = vm.parseJson(data);\\n RawEIP1559ScriptArtifact memory rawArtifact = abi.decode(parsedData, (RawEIP1559ScriptArtifact));\\n EIP1559ScriptArtifact memory artifact;\\n artifact.libraries = rawArtifact.libraries;\\n artifact.path = rawArtifact.path;\\n artifact.timestamp = rawArtifact.timestamp;\\n artifact.pending = rawArtifact.pending;\\n artifact.txReturns = rawArtifact.txReturns;\\n artifact.receipts = rawToConvertedReceipts(rawArtifact.receipts);\\n artifact.transactions = rawToConvertedEIPTx1559s(rawArtifact.transactions);\\n return artifact;\\n }\\n\\n function rawToConvertedEIPTx1559s(RawTx1559[] memory rawTxs) internal pure virtual returns (Tx1559[] memory) {\\n Tx1559[] memory txs = new Tx1559[](rawTxs.length);\\n for (uint256 i; i < rawTxs.length; i++) {\\n txs[i] = rawToConvertedEIPTx1559(rawTxs[i]);\\n }\\n return txs;\\n }\\n\\n function rawToConvertedEIPTx1559(RawTx1559 memory rawTx) internal pure virtual returns (Tx1559 memory) {\\n Tx1559 memory transaction;\\n transaction.arguments = rawTx.arguments;\\n transaction.contractName = rawTx.contractName;\\n transaction.functionSig = rawTx.functionSig;\\n transaction.hash = rawTx.hash;\\n transaction.txDetail = rawToConvertedEIP1559Detail(rawTx.txDetail);\\n transaction.opcode = rawTx.opcode;\\n return transaction;\\n }\\n\\n function rawToConvertedEIP1559Detail(RawTx1559Detail memory rawDetail)\\n internal\\n pure\\n virtual\\n returns (Tx1559Detail memory)\\n {\\n Tx1559Detail memory txDetail;\\n txDetail.data = rawDetail.data;\\n txDetail.from = rawDetail.from;\\n txDetail.to = rawDetail.to;\\n txDetail.nonce = _bytesToUint(rawDetail.nonce);\\n txDetail.txType = _bytesToUint(rawDetail.txType);\\n txDetail.value = _bytesToUint(rawDetail.value);\\n txDetail.gas = _bytesToUint(rawDetail.gas);\\n txDetail.accessList = rawDetail.accessList;\\n return txDetail;\\n }\\n\\n function readTx1559s(string memory path) internal view virtual returns (Tx1559[] memory) {\\n string memory deployData = vm.readFile(path);\\n bytes memory parsedDeployData = vm.parseJson(deployData, \\\".transactions\\\");\\n RawTx1559[] memory rawTxs = abi.decode(parsedDeployData, (RawTx1559[]));\\n return rawToConvertedEIPTx1559s(rawTxs);\\n }\\n\\n function readTx1559(string memory path, uint256 index) internal view virtual returns (Tx1559 memory) {\\n string memory deployData = vm.readFile(path);\\n string memory key = string(abi.encodePacked(\\\".transactions[\\\", vm.toString(index), \\\"]\\\"));\\n bytes memory parsedDeployData = vm.parseJson(deployData, key);\\n RawTx1559 memory rawTx = abi.decode(parsedDeployData, (RawTx1559));\\n return rawToConvertedEIPTx1559(rawTx);\\n }\\n\\n // Analogous to readTransactions, but for receipts.\\n function readReceipts(string memory path) internal view virtual returns (Receipt[] memory) {\\n string memory deployData = vm.readFile(path);\\n bytes memory parsedDeployData = vm.parseJson(deployData, \\\".receipts\\\");\\n RawReceipt[] memory rawReceipts = abi.decode(parsedDeployData, (RawReceipt[]));\\n return rawToConvertedReceipts(rawReceipts);\\n }\\n\\n function readReceipt(string memory path, uint256 index) internal view virtual returns (Receipt memory) {\\n string memory deployData = vm.readFile(path);\\n string memory key = string(abi.encodePacked(\\\".receipts[\\\", vm.toString(index), \\\"]\\\"));\\n bytes memory parsedDeployData = vm.parseJson(deployData, key);\\n RawReceipt memory rawReceipt = abi.decode(parsedDeployData, (RawReceipt));\\n return rawToConvertedReceipt(rawReceipt);\\n }\\n\\n function rawToConvertedReceipts(RawReceipt[] memory rawReceipts) internal pure virtual returns (Receipt[] memory) {\\n Receipt[] memory receipts = new Receipt[](rawReceipts.length);\\n for (uint256 i; i < rawReceipts.length; i++) {\\n receipts[i] = rawToConvertedReceipt(rawReceipts[i]);\\n }\\n return receipts;\\n }\\n\\n function rawToConvertedReceipt(RawReceipt memory rawReceipt) internal pure virtual returns (Receipt memory) {\\n Receipt memory receipt;\\n receipt.blockHash = rawReceipt.blockHash;\\n receipt.to = rawReceipt.to;\\n receipt.from = rawReceipt.from;\\n receipt.contractAddress = rawReceipt.contractAddress;\\n receipt.effectiveGasPrice = _bytesToUint(rawReceipt.effectiveGasPrice);\\n receipt.cumulativeGasUsed = _bytesToUint(rawReceipt.cumulativeGasUsed);\\n receipt.gasUsed = _bytesToUint(rawReceipt.gasUsed);\\n receipt.status = _bytesToUint(rawReceipt.status);\\n receipt.transactionIndex = _bytesToUint(rawReceipt.transactionIndex);\\n receipt.blockNumber = _bytesToUint(rawReceipt.blockNumber);\\n receipt.logs = rawToConvertedReceiptLogs(rawReceipt.logs);\\n receipt.logsBloom = rawReceipt.logsBloom;\\n receipt.transactionHash = rawReceipt.transactionHash;\\n return receipt;\\n }\\n\\n function rawToConvertedReceiptLogs(RawReceiptLog[] memory rawLogs)\\n internal\\n pure\\n virtual\\n returns (ReceiptLog[] memory)\\n {\\n ReceiptLog[] memory logs = new ReceiptLog[](rawLogs.length);\\n for (uint256 i; i < rawLogs.length; i++) {\\n logs[i].logAddress = rawLogs[i].logAddress;\\n logs[i].blockHash = rawLogs[i].blockHash;\\n logs[i].blockNumber = _bytesToUint(rawLogs[i].blockNumber);\\n logs[i].data = rawLogs[i].data;\\n logs[i].logIndex = _bytesToUint(rawLogs[i].logIndex);\\n logs[i].topics = rawLogs[i].topics;\\n logs[i].transactionIndex = _bytesToUint(rawLogs[i].transactionIndex);\\n logs[i].transactionLogIndex = _bytesToUint(rawLogs[i].transactionLogIndex);\\n logs[i].removed = rawLogs[i].removed;\\n }\\n return logs;\\n }\\n\\n // Deploy a contract by fetching the contract bytecode from\\n // the artifacts directory\\n // e.g. `deployCode(code, abi.encode(arg1,arg2,arg3))`\\n function deployCode(string memory what, bytes memory args) internal virtual returns (address addr) {\\n bytes memory bytecode = abi.encodePacked(vm.getCode(what), args);\\n /// @solidity memory-safe-assembly\\n assembly {\\n addr := create(0, add(bytecode, 0x20), mload(bytecode))\\n }\\n\\n require(addr != address(0), \\\"StdCheats deployCode(string,bytes): Deployment failed.\\\");\\n }\\n\\n function deployCode(string memory what) internal virtual returns (address addr) {\\n bytes memory bytecode = vm.getCode(what);\\n /// @solidity memory-safe-assembly\\n assembly {\\n addr := create(0, add(bytecode, 0x20), mload(bytecode))\\n }\\n\\n require(addr != address(0), \\\"StdCheats deployCode(string): Deployment failed.\\\");\\n }\\n\\n /// @dev deploy contract with value on construction\\n function deployCode(string memory what, bytes memory args, uint256 val) internal virtual returns (address addr) {\\n bytes memory bytecode = abi.encodePacked(vm.getCode(what), args);\\n /// @solidity memory-safe-assembly\\n assembly {\\n addr := create(val, add(bytecode, 0x20), mload(bytecode))\\n }\\n\\n require(addr != address(0), \\\"StdCheats deployCode(string,bytes,uint256): Deployment failed.\\\");\\n }\\n\\n function deployCode(string memory what, uint256 val) internal virtual returns (address addr) {\\n bytes memory bytecode = vm.getCode(what);\\n /// @solidity memory-safe-assembly\\n assembly {\\n addr := create(val, add(bytecode, 0x20), mload(bytecode))\\n }\\n\\n require(addr != address(0), \\\"StdCheats deployCode(string,uint256): Deployment failed.\\\");\\n }\\n\\n // creates a labeled address and the corresponding private key\\n function makeAddrAndKey(string memory name) internal virtual returns (address addr, uint256 privateKey) {\\n privateKey = uint256(keccak256(abi.encodePacked(name)));\\n addr = vm.addr(privateKey);\\n vm.label(addr, name);\\n }\\n\\n // creates a labeled address\\n function makeAddr(string memory name) internal virtual returns (address addr) {\\n (addr,) = makeAddrAndKey(name);\\n }\\n\\n // Destroys an account immediately, sending the balance to beneficiary.\\n // Destroying means: balance will be zero, code will be empty, and nonce will be 0\\n // This is similar to selfdestruct but not identical: selfdestruct destroys code and nonce\\n // only after tx ends, this will run immediately.\\n function destroyAccount(address who, address beneficiary) internal virtual {\\n uint256 currBalance = who.balance;\\n vm.etch(who, abi.encode());\\n vm.deal(who, 0);\\n vm.resetNonce(who);\\n\\n uint256 beneficiaryBalance = beneficiary.balance;\\n vm.deal(beneficiary, currBalance + beneficiaryBalance);\\n }\\n\\n // creates a struct containing both a labeled address and the corresponding private key\\n function makeAccount(string memory name) internal virtual returns (Account memory account) {\\n (account.addr, account.key) = makeAddrAndKey(name);\\n }\\n\\n function deriveRememberKey(string memory mnemonic, uint32 index)\\n internal\\n virtual\\n returns (address who, uint256 privateKey)\\n {\\n privateKey = vm.deriveKey(mnemonic, index);\\n who = vm.rememberKey(privateKey);\\n }\\n\\n function _bytesToUint(bytes memory b) private pure returns (uint256) {\\n require(b.length <= 32, \\\"StdCheats _bytesToUint(bytes): Bytes length exceeds 32.\\\");\\n return abi.decode(abi.encodePacked(new bytes(32 - b.length), b), (uint256));\\n }\\n\\n function isFork() internal view virtual returns (bool status) {\\n try vm.activeFork() {\\n status = true;\\n } catch (bytes memory) {}\\n }\\n\\n modifier skipWhenForking() {\\n if (!isFork()) {\\n _;\\n }\\n }\\n\\n modifier skipWhenNotForking() {\\n if (isFork()) {\\n _;\\n }\\n }\\n\\n modifier noGasMetering() {\\n vm.pauseGasMetering();\\n // To prevent turning gas monitoring back on with nested functions that use this modifier,\\n // we check if gasMetering started in the off position. If it did, we don't want to turn\\n // it back on until we exit the top level function that used the modifier\\n //\\n // i.e. funcA() noGasMetering { funcB() }, where funcB has noGasMetering as well.\\n // funcA will have `gasStartedOff` as false, funcB will have it as true,\\n // so we only turn metering back on at the end of the funcA\\n bool gasStartedOff = gasMeteringOff;\\n gasMeteringOff = true;\\n\\n _;\\n\\n // if gas metering was on when this modifier was called, turn it back on at the end\\n if (!gasStartedOff) {\\n gasMeteringOff = false;\\n vm.resumeGasMetering();\\n }\\n }\\n\\n // We use this complex approach of `_viewChainId` and `_pureChainId` to ensure there are no\\n // compiler warnings when accessing chain ID in any solidity version supported by forge-std. We\\n // can't simply access the chain ID in a normal view or pure function because the solc View Pure\\n // Checker changed `chainid` from pure to view in 0.8.0.\\n function _viewChainId() private view returns (uint256 chainId) {\\n // Assembly required since `block.chainid` was introduced in 0.8.0.\\n assembly {\\n chainId := chainid()\\n }\\n\\n address(this); // Silence warnings in older Solc versions.\\n }\\n\\n function _pureChainId() private pure returns (uint256 chainId) {\\n function() internal view returns (uint256) fnIn = _viewChainId;\\n function() internal pure returns (uint256) pureChainId;\\n assembly {\\n pureChainId := fnIn\\n }\\n chainId = pureChainId();\\n }\\n}\\n\\n// Wrappers around cheatcodes to avoid footguns\\nabstract contract StdCheats is StdCheatsSafe {\\n using stdStorage for StdStorage;\\n\\n StdStorage private stdstore;\\n Vm private constant vm = Vm(address(uint160(uint256(keccak256(\\\"hevm cheat code\\\")))));\\n address private constant CONSOLE2_ADDRESS = 0x000000000000000000636F6e736F6c652e6c6f67;\\n\\n // Skip forward or rewind time by the specified number of seconds\\n function skip(uint256 time) internal virtual {\\n vm.warp(vm.getBlockTimestamp() + time);\\n }\\n\\n function rewind(uint256 time) internal virtual {\\n vm.warp(vm.getBlockTimestamp() - time);\\n }\\n\\n // Setup a prank from an address that has some ether\\n function hoax(address msgSender) internal virtual {\\n vm.deal(msgSender, 1 << 128);\\n vm.prank(msgSender);\\n }\\n\\n function hoax(address msgSender, uint256 give) internal virtual {\\n vm.deal(msgSender, give);\\n vm.prank(msgSender);\\n }\\n\\n function hoax(address msgSender, address origin) internal virtual {\\n vm.deal(msgSender, 1 << 128);\\n vm.prank(msgSender, origin);\\n }\\n\\n function hoax(address msgSender, address origin, uint256 give) internal virtual {\\n vm.deal(msgSender, give);\\n vm.prank(msgSender, origin);\\n }\\n\\n // Start perpetual prank from an address that has some ether\\n function startHoax(address msgSender) internal virtual {\\n vm.deal(msgSender, 1 << 128);\\n vm.startPrank(msgSender);\\n }\\n\\n function startHoax(address msgSender, uint256 give) internal virtual {\\n vm.deal(msgSender, give);\\n vm.startPrank(msgSender);\\n }\\n\\n // Start perpetual prank from an address that has some ether\\n // tx.origin is set to the origin parameter\\n function startHoax(address msgSender, address origin) internal virtual {\\n vm.deal(msgSender, 1 << 128);\\n vm.startPrank(msgSender, origin);\\n }\\n\\n function startHoax(address msgSender, address origin, uint256 give) internal virtual {\\n vm.deal(msgSender, give);\\n vm.startPrank(msgSender, origin);\\n }\\n\\n function changePrank(address msgSender) internal virtual {\\n console2_log_StdCheats(\\\"changePrank is deprecated. Please use vm.startPrank instead.\\\");\\n vm.stopPrank();\\n vm.startPrank(msgSender);\\n }\\n\\n function changePrank(address msgSender, address txOrigin) internal virtual {\\n vm.stopPrank();\\n vm.startPrank(msgSender, txOrigin);\\n }\\n\\n // The same as Vm's `deal`\\n // Use the alternative signature for ERC20 tokens\\n function deal(address to, uint256 give) internal virtual {\\n vm.deal(to, give);\\n }\\n\\n // Set the balance of an account for any ERC20 token\\n // Use the alternative signature to update `totalSupply`\\n function deal(address token, address to, uint256 give) internal virtual {\\n deal(token, to, give, false);\\n }\\n\\n // Set the balance of an account for any ERC1155 token\\n // Use the alternative signature to update `totalSupply`\\n function dealERC1155(address token, address to, uint256 id, uint256 give) internal virtual {\\n dealERC1155(token, to, id, give, false);\\n }\\n\\n function deal(address token, address to, uint256 give, bool adjust) internal virtual {\\n // get current balance\\n (, bytes memory balData) = token.staticcall(abi.encodeWithSelector(0x70a08231, to));\\n uint256 prevBal = abi.decode(balData, (uint256));\\n\\n // update balance\\n stdstore.target(token).sig(0x70a08231).with_key(to).checked_write(give);\\n\\n // update total supply\\n if (adjust) {\\n (, bytes memory totSupData) = token.staticcall(abi.encodeWithSelector(0x18160ddd));\\n uint256 totSup = abi.decode(totSupData, (uint256));\\n if (give < prevBal) {\\n totSup -= (prevBal - give);\\n } else {\\n totSup += (give - prevBal);\\n }\\n stdstore.target(token).sig(0x18160ddd).checked_write(totSup);\\n }\\n }\\n\\n function dealERC1155(address token, address to, uint256 id, uint256 give, bool adjust) internal virtual {\\n // get current balance\\n (, bytes memory balData) = token.staticcall(abi.encodeWithSelector(0x00fdd58e, to, id));\\n uint256 prevBal = abi.decode(balData, (uint256));\\n\\n // update balance\\n stdstore.target(token).sig(0x00fdd58e).with_key(to).with_key(id).checked_write(give);\\n\\n // update total supply\\n if (adjust) {\\n (, bytes memory totSupData) = token.staticcall(abi.encodeWithSelector(0xbd85b039, id));\\n require(\\n totSupData.length != 0,\\n \\\"StdCheats deal(address,address,uint,uint,bool): target contract is not ERC1155Supply.\\\"\\n );\\n uint256 totSup = abi.decode(totSupData, (uint256));\\n if (give < prevBal) {\\n totSup -= (prevBal - give);\\n } else {\\n totSup += (give - prevBal);\\n }\\n stdstore.target(token).sig(0xbd85b039).with_key(id).checked_write(totSup);\\n }\\n }\\n\\n function dealERC721(address token, address to, uint256 id) internal virtual {\\n // check if token id is already minted and the actual owner.\\n (bool successMinted, bytes memory ownerData) = token.staticcall(abi.encodeWithSelector(0x6352211e, id));\\n require(successMinted, \\\"StdCheats deal(address,address,uint,bool): id not minted.\\\");\\n\\n // get owner current balance\\n (, bytes memory fromBalData) =\\n token.staticcall(abi.encodeWithSelector(0x70a08231, abi.decode(ownerData, (address))));\\n uint256 fromPrevBal = abi.decode(fromBalData, (uint256));\\n\\n // get new user current balance\\n (, bytes memory toBalData) = token.staticcall(abi.encodeWithSelector(0x70a08231, to));\\n uint256 toPrevBal = abi.decode(toBalData, (uint256));\\n\\n // update balances\\n stdstore.target(token).sig(0x70a08231).with_key(abi.decode(ownerData, (address))).checked_write(--fromPrevBal);\\n stdstore.target(token).sig(0x70a08231).with_key(to).checked_write(++toPrevBal);\\n\\n // update owner\\n stdstore.target(token).sig(0x6352211e).with_key(id).checked_write(to);\\n }\\n\\n function deployCodeTo(string memory what, address where) internal virtual {\\n deployCodeTo(what, \\\"\\\", 0, where);\\n }\\n\\n function deployCodeTo(string memory what, bytes memory args, address where) internal virtual {\\n deployCodeTo(what, args, 0, where);\\n }\\n\\n function deployCodeTo(string memory what, bytes memory args, uint256 value, address where) internal virtual {\\n bytes memory creationCode = vm.getCode(what);\\n vm.etch(where, abi.encodePacked(creationCode, args));\\n (bool success, bytes memory runtimeBytecode) = where.call{value: value}(\\\"\\\");\\n require(success, \\\"StdCheats deployCodeTo(string,bytes,uint256,address): Failed to create runtime bytecode.\\\");\\n vm.etch(where, runtimeBytecode);\\n }\\n\\n // Used to prevent the compilation of console, which shortens the compilation time when console is not used elsewhere.\\n function console2_log_StdCheats(string memory p0) private view {\\n (bool status,) = address(CONSOLE2_ADDRESS).staticcall(abi.encodeWithSignature(\\\"log(string)\\\", p0));\\n status;\\n }\\n}\\n\",\"keccak256\":\"0x0fa6ec03602648b62cce41aab2096e6b7e052f2846075d967b6958dd586db746\",\"license\":\"MIT\"},\"lib/forge-std/src/StdConstants.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity >=0.6.2 <0.9.0;\\n\\nimport {IMulticall3} from \\\"./interfaces/IMulticall3.sol\\\";\\nimport {Vm} from \\\"./Vm.sol\\\";\\n\\nlibrary StdConstants {\\n /// @dev Cheat code address.\\n /// Calculated as `address(uint160(uint256(keccak256(\\\"hevm cheat code\\\"))))`.\\n Vm internal constant VM = Vm(0x7109709ECfa91a80626fF3989D68f67F5b1DD12D);\\n /// @dev console.sol and console2.sol work by executing a staticcall to this address.\\n /// Calculated as `address(uint160(uint88(bytes11(\\\"console.log\\\"))))`.\\n address internal constant CONSOLE = 0x000000000000000000636F6e736F6c652e6c6f67;\\n /// @dev Used when deploying with create2.\\n /// Taken from https://github.com/Arachnid/deterministic-deployment-proxy.\\n address internal constant CREATE2_FACTORY = 0x4e59b44847b379578588920cA78FbF26c0B4956C;\\n /// @dev The default address for tx.origin and msg.sender.\\n /// Calculated as `address(uint160(uint256(keccak256(\\\"foundry default caller\\\"))))`.\\n address internal constant DEFAULT_SENDER = 0x1804c8AB1F12E6bbf3894d4083f33e07309d1f38;\\n /// @dev The address of the first contract `CREATE`d by a running test contract.\\n /// When running tests, each test contract is `CREATE`d by `DEFAULT_SENDER` with nonce 1.\\n /// Calculated as `VM.computeCreateAddress(VM.computeCreateAddress(DEFAULT_SENDER, 1), 1)`.\\n address internal constant DEFAULT_TEST_CONTRACT = 0x5615dEB798BB3E4dFa0139dFa1b3D433Cc23b72f;\\n /// @dev Deterministic deployment address of the Multicall3 contract.\\n /// Taken from https://www.multicall3.com.\\n IMulticall3 internal constant MULTICALL3_ADDRESS = IMulticall3(0xcA11bde05977b3631167028862bE2a173976CA11);\\n /// @dev The order of the secp256k1 curve.\\n uint256 internal constant SECP256K1_ORDER =\\n 115792089237316195423570985008687907852837564279074904382605163141518161494337;\\n}\\n\",\"keccak256\":\"0x319ccdabfa2c0b2428301445873270ffea20f0e039d4fd5e6eeba65158e4e534\",\"license\":\"MIT\"},\"lib/forge-std/src/StdJson.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity >=0.6.0 <0.9.0;\\n\\npragma experimental ABIEncoderV2;\\n\\nimport {VmSafe} from \\\"./Vm.sol\\\";\\n\\n// Helpers for parsing and writing JSON files\\n// To parse:\\n// ```\\n// using stdJson for string;\\n// string memory json = vm.readFile(\\\"\\\");\\n// json.readUint(\\\"\\\");\\n// ```\\n// To write:\\n// ```\\n// using stdJson for string;\\n// string memory json = \\\"json\\\";\\n// json.serialize(\\\"a\\\", uint256(123));\\n// string memory semiFinal = json.serialize(\\\"b\\\", string(\\\"test\\\"));\\n// string memory finalJson = json.serialize(\\\"c\\\", semiFinal);\\n// finalJson.write(\\\"\\\");\\n// ```\\n\\nlibrary stdJson {\\n VmSafe private constant vm = VmSafe(address(uint160(uint256(keccak256(\\\"hevm cheat code\\\")))));\\n\\n function keyExists(string memory json, string memory key) internal view returns (bool) {\\n return vm.keyExistsJson(json, key);\\n }\\n\\n function parseRaw(string memory json, string memory key) internal pure returns (bytes memory) {\\n return vm.parseJson(json, key);\\n }\\n\\n function readUint(string memory json, string memory key) internal pure returns (uint256) {\\n return vm.parseJsonUint(json, key);\\n }\\n\\n function readUintArray(string memory json, string memory key) internal pure returns (uint256[] memory) {\\n return vm.parseJsonUintArray(json, key);\\n }\\n\\n function readInt(string memory json, string memory key) internal pure returns (int256) {\\n return vm.parseJsonInt(json, key);\\n }\\n\\n function readIntArray(string memory json, string memory key) internal pure returns (int256[] memory) {\\n return vm.parseJsonIntArray(json, key);\\n }\\n\\n function readBytes32(string memory json, string memory key) internal pure returns (bytes32) {\\n return vm.parseJsonBytes32(json, key);\\n }\\n\\n function readBytes32Array(string memory json, string memory key) internal pure returns (bytes32[] memory) {\\n return vm.parseJsonBytes32Array(json, key);\\n }\\n\\n function readString(string memory json, string memory key) internal pure returns (string memory) {\\n return vm.parseJsonString(json, key);\\n }\\n\\n function readStringArray(string memory json, string memory key) internal pure returns (string[] memory) {\\n return vm.parseJsonStringArray(json, key);\\n }\\n\\n function readAddress(string memory json, string memory key) internal pure returns (address) {\\n return vm.parseJsonAddress(json, key);\\n }\\n\\n function readAddressArray(string memory json, string memory key) internal pure returns (address[] memory) {\\n return vm.parseJsonAddressArray(json, key);\\n }\\n\\n function readBool(string memory json, string memory key) internal pure returns (bool) {\\n return vm.parseJsonBool(json, key);\\n }\\n\\n function readBoolArray(string memory json, string memory key) internal pure returns (bool[] memory) {\\n return vm.parseJsonBoolArray(json, key);\\n }\\n\\n function readBytes(string memory json, string memory key) internal pure returns (bytes memory) {\\n return vm.parseJsonBytes(json, key);\\n }\\n\\n function readBytesArray(string memory json, string memory key) internal pure returns (bytes[] memory) {\\n return vm.parseJsonBytesArray(json, key);\\n }\\n\\n function readUintOr(string memory json, string memory key, uint256 defaultValue) internal view returns (uint256) {\\n return keyExists(json, key) ? readUint(json, key) : defaultValue;\\n }\\n\\n function readUintArrayOr(string memory json, string memory key, uint256[] memory defaultValue)\\n internal\\n view\\n returns (uint256[] memory)\\n {\\n return keyExists(json, key) ? readUintArray(json, key) : defaultValue;\\n }\\n\\n function readIntOr(string memory json, string memory key, int256 defaultValue) internal view returns (int256) {\\n return keyExists(json, key) ? readInt(json, key) : defaultValue;\\n }\\n\\n function readIntArrayOr(string memory json, string memory key, int256[] memory defaultValue)\\n internal\\n view\\n returns (int256[] memory)\\n {\\n return keyExists(json, key) ? readIntArray(json, key) : defaultValue;\\n }\\n\\n function readBytes32Or(string memory json, string memory key, bytes32 defaultValue)\\n internal\\n view\\n returns (bytes32)\\n {\\n return keyExists(json, key) ? readBytes32(json, key) : defaultValue;\\n }\\n\\n function readBytes32ArrayOr(string memory json, string memory key, bytes32[] memory defaultValue)\\n internal\\n view\\n returns (bytes32[] memory)\\n {\\n return keyExists(json, key) ? readBytes32Array(json, key) : defaultValue;\\n }\\n\\n function readStringOr(string memory json, string memory key, string memory defaultValue)\\n internal\\n view\\n returns (string memory)\\n {\\n return keyExists(json, key) ? readString(json, key) : defaultValue;\\n }\\n\\n function readStringArrayOr(string memory json, string memory key, string[] memory defaultValue)\\n internal\\n view\\n returns (string[] memory)\\n {\\n return keyExists(json, key) ? readStringArray(json, key) : defaultValue;\\n }\\n\\n function readAddressOr(string memory json, string memory key, address defaultValue)\\n internal\\n view\\n returns (address)\\n {\\n return keyExists(json, key) ? readAddress(json, key) : defaultValue;\\n }\\n\\n function readAddressArrayOr(string memory json, string memory key, address[] memory defaultValue)\\n internal\\n view\\n returns (address[] memory)\\n {\\n return keyExists(json, key) ? readAddressArray(json, key) : defaultValue;\\n }\\n\\n function readBoolOr(string memory json, string memory key, bool defaultValue) internal view returns (bool) {\\n return keyExists(json, key) ? readBool(json, key) : defaultValue;\\n }\\n\\n function readBoolArrayOr(string memory json, string memory key, bool[] memory defaultValue)\\n internal\\n view\\n returns (bool[] memory)\\n {\\n return keyExists(json, key) ? readBoolArray(json, key) : defaultValue;\\n }\\n\\n function readBytesOr(string memory json, string memory key, bytes memory defaultValue)\\n internal\\n view\\n returns (bytes memory)\\n {\\n return keyExists(json, key) ? readBytes(json, key) : defaultValue;\\n }\\n\\n function readBytesArrayOr(string memory json, string memory key, bytes[] memory defaultValue)\\n internal\\n view\\n returns (bytes[] memory)\\n {\\n return keyExists(json, key) ? readBytesArray(json, key) : defaultValue;\\n }\\n\\n function serialize(string memory jsonKey, string memory rootObject) internal returns (string memory) {\\n return vm.serializeJson(jsonKey, rootObject);\\n }\\n\\n function serialize(string memory jsonKey, string memory key, bool value) internal returns (string memory) {\\n return vm.serializeBool(jsonKey, key, value);\\n }\\n\\n function serialize(string memory jsonKey, string memory key, bool[] memory value)\\n internal\\n returns (string memory)\\n {\\n return vm.serializeBool(jsonKey, key, value);\\n }\\n\\n function serialize(string memory jsonKey, string memory key, uint256 value) internal returns (string memory) {\\n return vm.serializeUint(jsonKey, key, value);\\n }\\n\\n function serialize(string memory jsonKey, string memory key, uint256[] memory value)\\n internal\\n returns (string memory)\\n {\\n return vm.serializeUint(jsonKey, key, value);\\n }\\n\\n function serialize(string memory jsonKey, string memory key, int256 value) internal returns (string memory) {\\n return vm.serializeInt(jsonKey, key, value);\\n }\\n\\n function serialize(string memory jsonKey, string memory key, int256[] memory value)\\n internal\\n returns (string memory)\\n {\\n return vm.serializeInt(jsonKey, key, value);\\n }\\n\\n function serialize(string memory jsonKey, string memory key, address value) internal returns (string memory) {\\n return vm.serializeAddress(jsonKey, key, value);\\n }\\n\\n function serialize(string memory jsonKey, string memory key, address[] memory value)\\n internal\\n returns (string memory)\\n {\\n return vm.serializeAddress(jsonKey, key, value);\\n }\\n\\n function serialize(string memory jsonKey, string memory key, bytes32 value) internal returns (string memory) {\\n return vm.serializeBytes32(jsonKey, key, value);\\n }\\n\\n function serialize(string memory jsonKey, string memory key, bytes32[] memory value)\\n internal\\n returns (string memory)\\n {\\n return vm.serializeBytes32(jsonKey, key, value);\\n }\\n\\n function serialize(string memory jsonKey, string memory key, bytes memory value) internal returns (string memory) {\\n return vm.serializeBytes(jsonKey, key, value);\\n }\\n\\n function serialize(string memory jsonKey, string memory key, bytes[] memory value)\\n internal\\n returns (string memory)\\n {\\n return vm.serializeBytes(jsonKey, key, value);\\n }\\n\\n function serialize(string memory jsonKey, string memory key, string memory value)\\n internal\\n returns (string memory)\\n {\\n return vm.serializeString(jsonKey, key, value);\\n }\\n\\n function serialize(string memory jsonKey, string memory key, string[] memory value)\\n internal\\n returns (string memory)\\n {\\n return vm.serializeString(jsonKey, key, value);\\n }\\n\\n function write(string memory jsonKey, string memory path) internal {\\n vm.writeJson(jsonKey, path);\\n }\\n\\n function write(string memory jsonKey, string memory path, string memory valueKey) internal {\\n vm.writeJson(jsonKey, path, valueKey);\\n }\\n}\\n\",\"keccak256\":\"0xbc0132abe1c2accc2867c0f03667afffdf92f3e95a581bb03c9557eaa38ea500\",\"license\":\"MIT\"},\"lib/forge-std/src/StdMath.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity >=0.6.2 <0.9.0;\\n\\nlibrary stdMath {\\n int256 private constant INT256_MIN = -57896044618658097711785492504343953926634992332820282019728792003956564819968;\\n\\n function abs(int256 a) internal pure returns (uint256) {\\n // Required or it will fail when `a = type(int256).min`\\n if (a == INT256_MIN) {\\n return 57896044618658097711785492504343953926634992332820282019728792003956564819968;\\n }\\n\\n return uint256(a > 0 ? a : -a);\\n }\\n\\n function delta(uint256 a, uint256 b) internal pure returns (uint256) {\\n return a > b ? a - b : b - a;\\n }\\n\\n function delta(int256 a, int256 b) internal pure returns (uint256) {\\n // a and b are of the same sign\\n // this works thanks to two's complement, the left-most bit is the sign bit\\n if ((a ^ b) > -1) {\\n return delta(abs(a), abs(b));\\n }\\n\\n // a and b are of opposite signs\\n return abs(a) + abs(b);\\n }\\n\\n function percentDelta(uint256 a, uint256 b) internal pure returns (uint256) {\\n uint256 absDelta = delta(a, b);\\n\\n return absDelta * 1e18 / b;\\n }\\n\\n function percentDelta(int256 a, int256 b) internal pure returns (uint256) {\\n uint256 absDelta = delta(a, b);\\n uint256 absB = abs(b);\\n\\n return absDelta * 1e18 / absB;\\n }\\n}\\n\",\"keccak256\":\"0xd90ad4fd8aeaeb8929964e686e769fdedd5eded3fc3815df194a0ab9f91a3fb2\",\"license\":\"MIT\"},\"lib/forge-std/src/StdStorage.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity >=0.6.2 <0.9.0;\\n\\nimport {Vm} from \\\"./Vm.sol\\\";\\n\\nstruct FindData {\\n uint256 slot;\\n uint256 offsetLeft;\\n uint256 offsetRight;\\n bool found;\\n}\\n\\nstruct StdStorage {\\n mapping(address => mapping(bytes4 => mapping(bytes32 => FindData))) finds;\\n bytes32[] _keys;\\n bytes4 _sig;\\n uint256 _depth;\\n address _target;\\n bytes32 _set;\\n bool _enable_packed_slots;\\n bytes _calldata;\\n}\\n\\nlibrary stdStorageSafe {\\n event SlotFound(address who, bytes4 fsig, bytes32 keysHash, uint256 slot);\\n event WARNING_UninitedSlot(address who, uint256 slot);\\n\\n Vm private constant vm = Vm(address(uint160(uint256(keccak256(\\\"hevm cheat code\\\")))));\\n uint256 constant UINT256_MAX = 115792089237316195423570985008687907853269984665640564039457584007913129639935;\\n\\n function sigs(string memory sigStr) internal pure returns (bytes4) {\\n return bytes4(keccak256(bytes(sigStr)));\\n }\\n\\n function getCallParams(StdStorage storage self) internal view returns (bytes memory) {\\n if (self._calldata.length == 0) {\\n return flatten(self._keys);\\n } else {\\n return self._calldata;\\n }\\n }\\n\\n // Calls target contract with configured parameters\\n function callTarget(StdStorage storage self) internal view returns (bool, bytes32) {\\n bytes memory cald = abi.encodePacked(self._sig, getCallParams(self));\\n (bool success, bytes memory rdat) = self._target.staticcall(cald);\\n bytes32 result = bytesToBytes32(rdat, 32 * self._depth);\\n\\n return (success, result);\\n }\\n\\n // Tries mutating slot value to determine if the targeted value is stored in it.\\n // If current value is 0, then we are setting slot value to type(uint256).max\\n // Otherwise, we set it to 0. That way, return value should always be affected.\\n function checkSlotMutatesCall(StdStorage storage self, bytes32 slot) internal returns (bool) {\\n bytes32 prevSlotValue = vm.load(self._target, slot);\\n (bool success, bytes32 prevReturnValue) = callTarget(self);\\n\\n bytes32 testVal = prevReturnValue == bytes32(0) ? bytes32(UINT256_MAX) : bytes32(0);\\n vm.store(self._target, slot, testVal);\\n\\n (, bytes32 newReturnValue) = callTarget(self);\\n\\n vm.store(self._target, slot, prevSlotValue);\\n\\n return (success && (prevReturnValue != newReturnValue));\\n }\\n\\n // Tries setting one of the bits in slot to 1 until return value changes.\\n // Index of resulted bit is an offset packed slot has from left/right side\\n function findOffset(StdStorage storage self, bytes32 slot, bool left) internal returns (bool, uint256) {\\n for (uint256 offset = 0; offset < 256; offset++) {\\n uint256 valueToPut = left ? (1 << (255 - offset)) : (1 << offset);\\n vm.store(self._target, slot, bytes32(valueToPut));\\n\\n (bool success, bytes32 data) = callTarget(self);\\n\\n if (success && (uint256(data) > 0)) {\\n return (true, offset);\\n }\\n }\\n return (false, 0);\\n }\\n\\n function findOffsets(StdStorage storage self, bytes32 slot) internal returns (bool, uint256, uint256) {\\n bytes32 prevSlotValue = vm.load(self._target, slot);\\n\\n (bool foundLeft, uint256 offsetLeft) = findOffset(self, slot, true);\\n (bool foundRight, uint256 offsetRight) = findOffset(self, slot, false);\\n\\n // `findOffset` may mutate slot value, so we are setting it to initial value\\n vm.store(self._target, slot, prevSlotValue);\\n return (foundLeft && foundRight, offsetLeft, offsetRight);\\n }\\n\\n function find(StdStorage storage self) internal returns (FindData storage) {\\n return find(self, true);\\n }\\n\\n /// @notice find an arbitrary storage slot given a function sig, input data, address of the contract and a value to check against\\n // slot complexity:\\n // if flat, will be bytes32(uint256(uint));\\n // if map, will be keccak256(abi.encode(key, uint(slot)));\\n // if deep map, will be keccak256(abi.encode(key1, keccak256(abi.encode(key0, uint(slot)))));\\n // if map struct, will be bytes32(uint256(keccak256(abi.encode(key1, keccak256(abi.encode(key0, uint(slot)))))) + structFieldDepth);\\n function find(StdStorage storage self, bool _clear) internal returns (FindData storage) {\\n address who = self._target;\\n bytes4 fsig = self._sig;\\n uint256 field_depth = self._depth;\\n bytes memory params = getCallParams(self);\\n\\n // calldata to test against\\n if (self.finds[who][fsig][keccak256(abi.encodePacked(params, field_depth))].found) {\\n if (_clear) {\\n clear(self);\\n }\\n return self.finds[who][fsig][keccak256(abi.encodePacked(params, field_depth))];\\n }\\n vm.record();\\n (, bytes32 callResult) = callTarget(self);\\n (bytes32[] memory reads,) = vm.accesses(address(who));\\n\\n if (reads.length == 0) {\\n revert(\\\"stdStorage find(StdStorage): No storage use detected for target.\\\");\\n } else {\\n for (uint256 i = reads.length; --i >= 0;) {\\n bytes32 prev = vm.load(who, reads[i]);\\n if (prev == bytes32(0)) {\\n emit WARNING_UninitedSlot(who, uint256(reads[i]));\\n }\\n\\n if (!checkSlotMutatesCall(self, reads[i])) {\\n continue;\\n }\\n\\n (uint256 offsetLeft, uint256 offsetRight) = (0, 0);\\n\\n if (self._enable_packed_slots) {\\n bool found;\\n (found, offsetLeft, offsetRight) = findOffsets(self, reads[i]);\\n if (!found) {\\n continue;\\n }\\n }\\n\\n // Check that value between found offsets is equal to the current call result\\n uint256 curVal = (uint256(prev) & getMaskByOffsets(offsetLeft, offsetRight)) >> offsetRight;\\n\\n if (uint256(callResult) != curVal) {\\n continue;\\n }\\n\\n emit SlotFound(who, fsig, keccak256(abi.encodePacked(params, field_depth)), uint256(reads[i]));\\n self.finds[who][fsig][keccak256(abi.encodePacked(params, field_depth))] =\\n FindData(uint256(reads[i]), offsetLeft, offsetRight, true);\\n break;\\n }\\n }\\n\\n require(\\n self.finds[who][fsig][keccak256(abi.encodePacked(params, field_depth))].found,\\n \\\"stdStorage find(StdStorage): Slot(s) not found.\\\"\\n );\\n\\n if (_clear) {\\n clear(self);\\n }\\n return self.finds[who][fsig][keccak256(abi.encodePacked(params, field_depth))];\\n }\\n\\n function target(StdStorage storage self, address _target) internal returns (StdStorage storage) {\\n self._target = _target;\\n return self;\\n }\\n\\n function sig(StdStorage storage self, bytes4 _sig) internal returns (StdStorage storage) {\\n self._sig = _sig;\\n return self;\\n }\\n\\n function sig(StdStorage storage self, string memory _sig) internal returns (StdStorage storage) {\\n self._sig = sigs(_sig);\\n return self;\\n }\\n\\n function with_calldata(StdStorage storage self, bytes memory _calldata) internal returns (StdStorage storage) {\\n self._calldata = _calldata;\\n return self;\\n }\\n\\n function with_key(StdStorage storage self, address who) internal returns (StdStorage storage) {\\n self._keys.push(bytes32(uint256(uint160(who))));\\n return self;\\n }\\n\\n function with_key(StdStorage storage self, uint256 amt) internal returns (StdStorage storage) {\\n self._keys.push(bytes32(amt));\\n return self;\\n }\\n\\n function with_key(StdStorage storage self, bytes32 key) internal returns (StdStorage storage) {\\n self._keys.push(key);\\n return self;\\n }\\n\\n function enable_packed_slots(StdStorage storage self) internal returns (StdStorage storage) {\\n self._enable_packed_slots = true;\\n return self;\\n }\\n\\n function depth(StdStorage storage self, uint256 _depth) internal returns (StdStorage storage) {\\n self._depth = _depth;\\n return self;\\n }\\n\\n function read(StdStorage storage self) private returns (bytes memory) {\\n FindData storage data = find(self, false);\\n uint256 mask = getMaskByOffsets(data.offsetLeft, data.offsetRight);\\n uint256 value = (uint256(vm.load(self._target, bytes32(data.slot))) & mask) >> data.offsetRight;\\n clear(self);\\n return abi.encode(value);\\n }\\n\\n function read_bytes32(StdStorage storage self) internal returns (bytes32) {\\n return abi.decode(read(self), (bytes32));\\n }\\n\\n function read_bool(StdStorage storage self) internal returns (bool) {\\n int256 v = read_int(self);\\n if (v == 0) return false;\\n if (v == 1) return true;\\n revert(\\\"stdStorage read_bool(StdStorage): Cannot decode. Make sure you are reading a bool.\\\");\\n }\\n\\n function read_address(StdStorage storage self) internal returns (address) {\\n return abi.decode(read(self), (address));\\n }\\n\\n function read_uint(StdStorage storage self) internal returns (uint256) {\\n return abi.decode(read(self), (uint256));\\n }\\n\\n function read_int(StdStorage storage self) internal returns (int256) {\\n return abi.decode(read(self), (int256));\\n }\\n\\n function parent(StdStorage storage self) internal returns (uint256, bytes32) {\\n address who = self._target;\\n uint256 field_depth = self._depth;\\n vm.startMappingRecording();\\n uint256 child = find(self, true).slot - field_depth;\\n (bool found, bytes32 key, bytes32 parent_slot) = vm.getMappingKeyAndParentOf(who, bytes32(child));\\n if (!found) {\\n revert(\\n \\\"stdStorage read_bool(StdStorage): Cannot find parent. Make sure you give a slot and startMappingRecording() has been called.\\\"\\n );\\n }\\n return (uint256(parent_slot), key);\\n }\\n\\n function root(StdStorage storage self) internal returns (uint256) {\\n address who = self._target;\\n uint256 field_depth = self._depth;\\n vm.startMappingRecording();\\n uint256 child = find(self, true).slot - field_depth;\\n bool found;\\n bytes32 root_slot;\\n bytes32 parent_slot;\\n (found,, parent_slot) = vm.getMappingKeyAndParentOf(who, bytes32(child));\\n if (!found) {\\n revert(\\n \\\"stdStorage read_bool(StdStorage): Cannot find parent. Make sure you give a slot and startMappingRecording() has been called.\\\"\\n );\\n }\\n while (found) {\\n root_slot = parent_slot;\\n (found,, parent_slot) = vm.getMappingKeyAndParentOf(who, bytes32(root_slot));\\n }\\n return uint256(root_slot);\\n }\\n\\n function bytesToBytes32(bytes memory b, uint256 offset) private pure returns (bytes32) {\\n bytes32 out;\\n\\n uint256 max = b.length > 32 ? 32 : b.length;\\n for (uint256 i = 0; i < max; i++) {\\n out |= bytes32(b[offset + i] & 0xFF) >> (i * 8);\\n }\\n return out;\\n }\\n\\n function flatten(bytes32[] memory b) private pure returns (bytes memory) {\\n bytes memory result = new bytes(b.length * 32);\\n for (uint256 i = 0; i < b.length; i++) {\\n bytes32 k = b[i];\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(add(result, add(32, mul(32, i))), k)\\n }\\n }\\n\\n return result;\\n }\\n\\n function clear(StdStorage storage self) internal {\\n delete self._target;\\n delete self._sig;\\n delete self._keys;\\n delete self._depth;\\n delete self._enable_packed_slots;\\n delete self._calldata;\\n }\\n\\n // Returns mask which contains non-zero bits for values between `offsetLeft` and `offsetRight`\\n // (slotValue & mask) >> offsetRight will be the value of the given packed variable\\n function getMaskByOffsets(uint256 offsetLeft, uint256 offsetRight) internal pure returns (uint256 mask) {\\n // mask = ((1 << (256 - (offsetRight + offsetLeft))) - 1) << offsetRight;\\n // using assembly because (1 << 256) causes overflow\\n assembly {\\n mask := shl(offsetRight, sub(shl(sub(256, add(offsetRight, offsetLeft)), 1), 1))\\n }\\n }\\n\\n // Returns slot value with updated packed variable.\\n function getUpdatedSlotValue(bytes32 curValue, uint256 varValue, uint256 offsetLeft, uint256 offsetRight)\\n internal\\n pure\\n returns (bytes32 newValue)\\n {\\n return bytes32((uint256(curValue) & ~getMaskByOffsets(offsetLeft, offsetRight)) | (varValue << offsetRight));\\n }\\n}\\n\\nlibrary stdStorage {\\n Vm private constant vm = Vm(address(uint160(uint256(keccak256(\\\"hevm cheat code\\\")))));\\n\\n function sigs(string memory sigStr) internal pure returns (bytes4) {\\n return stdStorageSafe.sigs(sigStr);\\n }\\n\\n function find(StdStorage storage self) internal returns (uint256) {\\n return find(self, true);\\n }\\n\\n function find(StdStorage storage self, bool _clear) internal returns (uint256) {\\n return stdStorageSafe.find(self, _clear).slot;\\n }\\n\\n function target(StdStorage storage self, address _target) internal returns (StdStorage storage) {\\n return stdStorageSafe.target(self, _target);\\n }\\n\\n function sig(StdStorage storage self, bytes4 _sig) internal returns (StdStorage storage) {\\n return stdStorageSafe.sig(self, _sig);\\n }\\n\\n function sig(StdStorage storage self, string memory _sig) internal returns (StdStorage storage) {\\n return stdStorageSafe.sig(self, _sig);\\n }\\n\\n function with_key(StdStorage storage self, address who) internal returns (StdStorage storage) {\\n return stdStorageSafe.with_key(self, who);\\n }\\n\\n function with_key(StdStorage storage self, uint256 amt) internal returns (StdStorage storage) {\\n return stdStorageSafe.with_key(self, amt);\\n }\\n\\n function with_key(StdStorage storage self, bytes32 key) internal returns (StdStorage storage) {\\n return stdStorageSafe.with_key(self, key);\\n }\\n\\n function with_calldata(StdStorage storage self, bytes memory _calldata) internal returns (StdStorage storage) {\\n return stdStorageSafe.with_calldata(self, _calldata);\\n }\\n\\n function enable_packed_slots(StdStorage storage self) internal returns (StdStorage storage) {\\n return stdStorageSafe.enable_packed_slots(self);\\n }\\n\\n function depth(StdStorage storage self, uint256 _depth) internal returns (StdStorage storage) {\\n return stdStorageSafe.depth(self, _depth);\\n }\\n\\n function clear(StdStorage storage self) internal {\\n stdStorageSafe.clear(self);\\n }\\n\\n function checked_write(StdStorage storage self, address who) internal {\\n checked_write(self, bytes32(uint256(uint160(who))));\\n }\\n\\n function checked_write(StdStorage storage self, uint256 amt) internal {\\n checked_write(self, bytes32(amt));\\n }\\n\\n function checked_write_int(StdStorage storage self, int256 val) internal {\\n checked_write(self, bytes32(uint256(val)));\\n }\\n\\n function checked_write(StdStorage storage self, bool write) internal {\\n bytes32 t;\\n /// @solidity memory-safe-assembly\\n assembly {\\n t := write\\n }\\n checked_write(self, t);\\n }\\n\\n function checked_write(StdStorage storage self, bytes32 set) internal {\\n address who = self._target;\\n bytes4 fsig = self._sig;\\n uint256 field_depth = self._depth;\\n bytes memory params = stdStorageSafe.getCallParams(self);\\n\\n if (!self.finds[who][fsig][keccak256(abi.encodePacked(params, field_depth))].found) {\\n find(self, false);\\n }\\n FindData storage data = self.finds[who][fsig][keccak256(abi.encodePacked(params, field_depth))];\\n if ((data.offsetLeft + data.offsetRight) > 0) {\\n uint256 maxVal = 2 ** (256 - (data.offsetLeft + data.offsetRight));\\n require(\\n uint256(set) < maxVal,\\n string(\\n abi.encodePacked(\\n \\\"stdStorage find(StdStorage): Packed slot. We can't fit value greater than \\\",\\n vm.toString(maxVal)\\n )\\n )\\n );\\n }\\n bytes32 curVal = vm.load(who, bytes32(data.slot));\\n bytes32 valToSet = stdStorageSafe.getUpdatedSlotValue(curVal, uint256(set), data.offsetLeft, data.offsetRight);\\n\\n vm.store(who, bytes32(data.slot), valToSet);\\n\\n (bool success, bytes32 callResult) = stdStorageSafe.callTarget(self);\\n\\n if (!success || callResult != set) {\\n vm.store(who, bytes32(data.slot), curVal);\\n revert(\\\"stdStorage find(StdStorage): Failed to write value.\\\");\\n }\\n clear(self);\\n }\\n\\n function read_bytes32(StdStorage storage self) internal returns (bytes32) {\\n return stdStorageSafe.read_bytes32(self);\\n }\\n\\n function read_bool(StdStorage storage self) internal returns (bool) {\\n return stdStorageSafe.read_bool(self);\\n }\\n\\n function read_address(StdStorage storage self) internal returns (address) {\\n return stdStorageSafe.read_address(self);\\n }\\n\\n function read_uint(StdStorage storage self) internal returns (uint256) {\\n return stdStorageSafe.read_uint(self);\\n }\\n\\n function read_int(StdStorage storage self) internal returns (int256) {\\n return stdStorageSafe.read_int(self);\\n }\\n\\n function parent(StdStorage storage self) internal returns (uint256, bytes32) {\\n return stdStorageSafe.parent(self);\\n }\\n\\n function root(StdStorage storage self) internal returns (uint256) {\\n return stdStorageSafe.root(self);\\n }\\n}\\n\",\"keccak256\":\"0xb91ab24383a5872b894fc93325eef1add6cbbf981628f18e860068bf88bb7dcc\",\"license\":\"MIT\"},\"lib/forge-std/src/StdStyle.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity >=0.4.22 <0.9.0;\\n\\nimport {VmSafe} from \\\"./Vm.sol\\\";\\n\\nlibrary StdStyle {\\n VmSafe private constant vm = VmSafe(address(uint160(uint256(keccak256(\\\"hevm cheat code\\\")))));\\n\\n string constant RED = \\\"\\\\u001b[91m\\\";\\n string constant GREEN = \\\"\\\\u001b[92m\\\";\\n string constant YELLOW = \\\"\\\\u001b[93m\\\";\\n string constant BLUE = \\\"\\\\u001b[94m\\\";\\n string constant MAGENTA = \\\"\\\\u001b[95m\\\";\\n string constant CYAN = \\\"\\\\u001b[96m\\\";\\n string constant BOLD = \\\"\\\\u001b[1m\\\";\\n string constant DIM = \\\"\\\\u001b[2m\\\";\\n string constant ITALIC = \\\"\\\\u001b[3m\\\";\\n string constant UNDERLINE = \\\"\\\\u001b[4m\\\";\\n string constant INVERSE = \\\"\\\\u001b[7m\\\";\\n string constant RESET = \\\"\\\\u001b[0m\\\";\\n\\n function styleConcat(string memory style, string memory self) private pure returns (string memory) {\\n return string(abi.encodePacked(style, self, RESET));\\n }\\n\\n function red(string memory self) internal pure returns (string memory) {\\n return styleConcat(RED, self);\\n }\\n\\n function red(uint256 self) internal pure returns (string memory) {\\n return red(vm.toString(self));\\n }\\n\\n function red(int256 self) internal pure returns (string memory) {\\n return red(vm.toString(self));\\n }\\n\\n function red(address self) internal pure returns (string memory) {\\n return red(vm.toString(self));\\n }\\n\\n function red(bool self) internal pure returns (string memory) {\\n return red(vm.toString(self));\\n }\\n\\n function redBytes(bytes memory self) internal pure returns (string memory) {\\n return red(vm.toString(self));\\n }\\n\\n function redBytes32(bytes32 self) internal pure returns (string memory) {\\n return red(vm.toString(self));\\n }\\n\\n function green(string memory self) internal pure returns (string memory) {\\n return styleConcat(GREEN, self);\\n }\\n\\n function green(uint256 self) internal pure returns (string memory) {\\n return green(vm.toString(self));\\n }\\n\\n function green(int256 self) internal pure returns (string memory) {\\n return green(vm.toString(self));\\n }\\n\\n function green(address self) internal pure returns (string memory) {\\n return green(vm.toString(self));\\n }\\n\\n function green(bool self) internal pure returns (string memory) {\\n return green(vm.toString(self));\\n }\\n\\n function greenBytes(bytes memory self) internal pure returns (string memory) {\\n return green(vm.toString(self));\\n }\\n\\n function greenBytes32(bytes32 self) internal pure returns (string memory) {\\n return green(vm.toString(self));\\n }\\n\\n function yellow(string memory self) internal pure returns (string memory) {\\n return styleConcat(YELLOW, self);\\n }\\n\\n function yellow(uint256 self) internal pure returns (string memory) {\\n return yellow(vm.toString(self));\\n }\\n\\n function yellow(int256 self) internal pure returns (string memory) {\\n return yellow(vm.toString(self));\\n }\\n\\n function yellow(address self) internal pure returns (string memory) {\\n return yellow(vm.toString(self));\\n }\\n\\n function yellow(bool self) internal pure returns (string memory) {\\n return yellow(vm.toString(self));\\n }\\n\\n function yellowBytes(bytes memory self) internal pure returns (string memory) {\\n return yellow(vm.toString(self));\\n }\\n\\n function yellowBytes32(bytes32 self) internal pure returns (string memory) {\\n return yellow(vm.toString(self));\\n }\\n\\n function blue(string memory self) internal pure returns (string memory) {\\n return styleConcat(BLUE, self);\\n }\\n\\n function blue(uint256 self) internal pure returns (string memory) {\\n return blue(vm.toString(self));\\n }\\n\\n function blue(int256 self) internal pure returns (string memory) {\\n return blue(vm.toString(self));\\n }\\n\\n function blue(address self) internal pure returns (string memory) {\\n return blue(vm.toString(self));\\n }\\n\\n function blue(bool self) internal pure returns (string memory) {\\n return blue(vm.toString(self));\\n }\\n\\n function blueBytes(bytes memory self) internal pure returns (string memory) {\\n return blue(vm.toString(self));\\n }\\n\\n function blueBytes32(bytes32 self) internal pure returns (string memory) {\\n return blue(vm.toString(self));\\n }\\n\\n function magenta(string memory self) internal pure returns (string memory) {\\n return styleConcat(MAGENTA, self);\\n }\\n\\n function magenta(uint256 self) internal pure returns (string memory) {\\n return magenta(vm.toString(self));\\n }\\n\\n function magenta(int256 self) internal pure returns (string memory) {\\n return magenta(vm.toString(self));\\n }\\n\\n function magenta(address self) internal pure returns (string memory) {\\n return magenta(vm.toString(self));\\n }\\n\\n function magenta(bool self) internal pure returns (string memory) {\\n return magenta(vm.toString(self));\\n }\\n\\n function magentaBytes(bytes memory self) internal pure returns (string memory) {\\n return magenta(vm.toString(self));\\n }\\n\\n function magentaBytes32(bytes32 self) internal pure returns (string memory) {\\n return magenta(vm.toString(self));\\n }\\n\\n function cyan(string memory self) internal pure returns (string memory) {\\n return styleConcat(CYAN, self);\\n }\\n\\n function cyan(uint256 self) internal pure returns (string memory) {\\n return cyan(vm.toString(self));\\n }\\n\\n function cyan(int256 self) internal pure returns (string memory) {\\n return cyan(vm.toString(self));\\n }\\n\\n function cyan(address self) internal pure returns (string memory) {\\n return cyan(vm.toString(self));\\n }\\n\\n function cyan(bool self) internal pure returns (string memory) {\\n return cyan(vm.toString(self));\\n }\\n\\n function cyanBytes(bytes memory self) internal pure returns (string memory) {\\n return cyan(vm.toString(self));\\n }\\n\\n function cyanBytes32(bytes32 self) internal pure returns (string memory) {\\n return cyan(vm.toString(self));\\n }\\n\\n function bold(string memory self) internal pure returns (string memory) {\\n return styleConcat(BOLD, self);\\n }\\n\\n function bold(uint256 self) internal pure returns (string memory) {\\n return bold(vm.toString(self));\\n }\\n\\n function bold(int256 self) internal pure returns (string memory) {\\n return bold(vm.toString(self));\\n }\\n\\n function bold(address self) internal pure returns (string memory) {\\n return bold(vm.toString(self));\\n }\\n\\n function bold(bool self) internal pure returns (string memory) {\\n return bold(vm.toString(self));\\n }\\n\\n function boldBytes(bytes memory self) internal pure returns (string memory) {\\n return bold(vm.toString(self));\\n }\\n\\n function boldBytes32(bytes32 self) internal pure returns (string memory) {\\n return bold(vm.toString(self));\\n }\\n\\n function dim(string memory self) internal pure returns (string memory) {\\n return styleConcat(DIM, self);\\n }\\n\\n function dim(uint256 self) internal pure returns (string memory) {\\n return dim(vm.toString(self));\\n }\\n\\n function dim(int256 self) internal pure returns (string memory) {\\n return dim(vm.toString(self));\\n }\\n\\n function dim(address self) internal pure returns (string memory) {\\n return dim(vm.toString(self));\\n }\\n\\n function dim(bool self) internal pure returns (string memory) {\\n return dim(vm.toString(self));\\n }\\n\\n function dimBytes(bytes memory self) internal pure returns (string memory) {\\n return dim(vm.toString(self));\\n }\\n\\n function dimBytes32(bytes32 self) internal pure returns (string memory) {\\n return dim(vm.toString(self));\\n }\\n\\n function italic(string memory self) internal pure returns (string memory) {\\n return styleConcat(ITALIC, self);\\n }\\n\\n function italic(uint256 self) internal pure returns (string memory) {\\n return italic(vm.toString(self));\\n }\\n\\n function italic(int256 self) internal pure returns (string memory) {\\n return italic(vm.toString(self));\\n }\\n\\n function italic(address self) internal pure returns (string memory) {\\n return italic(vm.toString(self));\\n }\\n\\n function italic(bool self) internal pure returns (string memory) {\\n return italic(vm.toString(self));\\n }\\n\\n function italicBytes(bytes memory self) internal pure returns (string memory) {\\n return italic(vm.toString(self));\\n }\\n\\n function italicBytes32(bytes32 self) internal pure returns (string memory) {\\n return italic(vm.toString(self));\\n }\\n\\n function underline(string memory self) internal pure returns (string memory) {\\n return styleConcat(UNDERLINE, self);\\n }\\n\\n function underline(uint256 self) internal pure returns (string memory) {\\n return underline(vm.toString(self));\\n }\\n\\n function underline(int256 self) internal pure returns (string memory) {\\n return underline(vm.toString(self));\\n }\\n\\n function underline(address self) internal pure returns (string memory) {\\n return underline(vm.toString(self));\\n }\\n\\n function underline(bool self) internal pure returns (string memory) {\\n return underline(vm.toString(self));\\n }\\n\\n function underlineBytes(bytes memory self) internal pure returns (string memory) {\\n return underline(vm.toString(self));\\n }\\n\\n function underlineBytes32(bytes32 self) internal pure returns (string memory) {\\n return underline(vm.toString(self));\\n }\\n\\n function inverse(string memory self) internal pure returns (string memory) {\\n return styleConcat(INVERSE, self);\\n }\\n\\n function inverse(uint256 self) internal pure returns (string memory) {\\n return inverse(vm.toString(self));\\n }\\n\\n function inverse(int256 self) internal pure returns (string memory) {\\n return inverse(vm.toString(self));\\n }\\n\\n function inverse(address self) internal pure returns (string memory) {\\n return inverse(vm.toString(self));\\n }\\n\\n function inverse(bool self) internal pure returns (string memory) {\\n return inverse(vm.toString(self));\\n }\\n\\n function inverseBytes(bytes memory self) internal pure returns (string memory) {\\n return inverse(vm.toString(self));\\n }\\n\\n function inverseBytes32(bytes32 self) internal pure returns (string memory) {\\n return inverse(vm.toString(self));\\n }\\n}\\n\",\"keccak256\":\"0x43e2a8a9b9c2574dabe74f11adf6f782df218f463540e3b5b563609fe108597d\",\"license\":\"MIT\"},\"lib/forge-std/src/StdUtils.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity >=0.6.2 <0.9.0;\\n\\npragma experimental ABIEncoderV2;\\n\\nimport {IMulticall3} from \\\"./interfaces/IMulticall3.sol\\\";\\nimport {VmSafe} from \\\"./Vm.sol\\\";\\n\\nabstract contract StdUtils {\\n /*//////////////////////////////////////////////////////////////////////////\\n CONSTANTS\\n //////////////////////////////////////////////////////////////////////////*/\\n\\n IMulticall3 private constant multicall = IMulticall3(0xcA11bde05977b3631167028862bE2a173976CA11);\\n VmSafe private constant vm = VmSafe(address(uint160(uint256(keccak256(\\\"hevm cheat code\\\")))));\\n address private constant CONSOLE2_ADDRESS = 0x000000000000000000636F6e736F6c652e6c6f67;\\n uint256 private constant INT256_MIN_ABS =\\n 57896044618658097711785492504343953926634992332820282019728792003956564819968;\\n uint256 private constant SECP256K1_ORDER =\\n 115792089237316195423570985008687907852837564279074904382605163141518161494337;\\n uint256 private constant UINT256_MAX =\\n 115792089237316195423570985008687907853269984665640564039457584007913129639935;\\n\\n // Used by default when deploying with create2, https://github.com/Arachnid/deterministic-deployment-proxy.\\n address private constant CREATE2_FACTORY = 0x4e59b44847b379578588920cA78FbF26c0B4956C;\\n\\n /*//////////////////////////////////////////////////////////////////////////\\n INTERNAL FUNCTIONS\\n //////////////////////////////////////////////////////////////////////////*/\\n\\n function _bound(uint256 x, uint256 min, uint256 max) internal pure virtual returns (uint256 result) {\\n require(min <= max, \\\"StdUtils bound(uint256,uint256,uint256): Max is less than min.\\\");\\n // If x is between min and max, return x directly. This is to ensure that dictionary values\\n // do not get shifted if the min is nonzero. More info: https://github.com/foundry-rs/forge-std/issues/188\\n if (x >= min && x <= max) return x;\\n\\n uint256 size = max - min + 1;\\n\\n // If the value is 0, 1, 2, 3, wrap that to min, min+1, min+2, min+3. Similarly for the UINT256_MAX side.\\n // This helps ensure coverage of the min/max values.\\n if (x <= 3 && size > x) return min + x;\\n if (x >= UINT256_MAX - 3 && size > UINT256_MAX - x) return max - (UINT256_MAX - x);\\n\\n // Otherwise, wrap x into the range [min, max], i.e. the range is inclusive.\\n if (x > max) {\\n uint256 diff = x - max;\\n uint256 rem = diff % size;\\n if (rem == 0) return max;\\n result = min + rem - 1;\\n } else if (x < min) {\\n uint256 diff = min - x;\\n uint256 rem = diff % size;\\n if (rem == 0) return min;\\n result = max - rem + 1;\\n }\\n }\\n\\n function bound(uint256 x, uint256 min, uint256 max) internal pure virtual returns (uint256 result) {\\n result = _bound(x, min, max);\\n console2_log_StdUtils(\\\"Bound result\\\", result);\\n }\\n\\n function _bound(int256 x, int256 min, int256 max) internal pure virtual returns (int256 result) {\\n require(min <= max, \\\"StdUtils bound(int256,int256,int256): Max is less than min.\\\");\\n\\n // Shifting all int256 values to uint256 to use _bound function. The range of two types are:\\n // int256 : -(2**255) ~ (2**255 - 1)\\n // uint256: 0 ~ (2**256 - 1)\\n // So, add 2**255, INT256_MIN_ABS to the integer values.\\n //\\n // If the given integer value is -2**255, we cannot use `-uint256(-x)` because of the overflow.\\n // So, use `~uint256(x) + 1` instead.\\n uint256 _x = x < 0 ? (INT256_MIN_ABS - ~uint256(x) - 1) : (uint256(x) + INT256_MIN_ABS);\\n uint256 _min = min < 0 ? (INT256_MIN_ABS - ~uint256(min) - 1) : (uint256(min) + INT256_MIN_ABS);\\n uint256 _max = max < 0 ? (INT256_MIN_ABS - ~uint256(max) - 1) : (uint256(max) + INT256_MIN_ABS);\\n\\n uint256 y = _bound(_x, _min, _max);\\n\\n // To move it back to int256 value, subtract INT256_MIN_ABS at here.\\n result = y < INT256_MIN_ABS ? int256(~(INT256_MIN_ABS - y) + 1) : int256(y - INT256_MIN_ABS);\\n }\\n\\n function bound(int256 x, int256 min, int256 max) internal pure virtual returns (int256 result) {\\n result = _bound(x, min, max);\\n console2_log_StdUtils(\\\"Bound result\\\", vm.toString(result));\\n }\\n\\n function boundPrivateKey(uint256 privateKey) internal pure virtual returns (uint256 result) {\\n result = _bound(privateKey, 1, SECP256K1_ORDER - 1);\\n }\\n\\n function bytesToUint(bytes memory b) internal pure virtual returns (uint256) {\\n require(b.length <= 32, \\\"StdUtils bytesToUint(bytes): Bytes length exceeds 32.\\\");\\n return abi.decode(abi.encodePacked(new bytes(32 - b.length), b), (uint256));\\n }\\n\\n /// @dev Compute the address a contract will be deployed at for a given deployer address and nonce\\n /// @notice adapted from Solmate implementation (https://github.com/Rari-Capital/solmate/blob/main/src/utils/LibRLP.sol)\\n function computeCreateAddress(address deployer, uint256 nonce) internal pure virtual returns (address) {\\n console2_log_StdUtils(\\\"computeCreateAddress is deprecated. Please use vm.computeCreateAddress instead.\\\");\\n return vm.computeCreateAddress(deployer, nonce);\\n }\\n\\n function computeCreate2Address(bytes32 salt, bytes32 initcodeHash, address deployer)\\n internal\\n pure\\n virtual\\n returns (address)\\n {\\n console2_log_StdUtils(\\\"computeCreate2Address is deprecated. Please use vm.computeCreate2Address instead.\\\");\\n return vm.computeCreate2Address(salt, initcodeHash, deployer);\\n }\\n\\n /// @dev returns the address of a contract created with CREATE2 using the default CREATE2 deployer\\n function computeCreate2Address(bytes32 salt, bytes32 initCodeHash) internal pure returns (address) {\\n console2_log_StdUtils(\\\"computeCreate2Address is deprecated. Please use vm.computeCreate2Address instead.\\\");\\n return vm.computeCreate2Address(salt, initCodeHash);\\n }\\n\\n /// @dev returns the hash of the init code (creation code + no args) used in CREATE2 with no constructor arguments\\n /// @param creationCode the creation code of a contract C, as returned by type(C).creationCode\\n function hashInitCode(bytes memory creationCode) internal pure returns (bytes32) {\\n return hashInitCode(creationCode, \\\"\\\");\\n }\\n\\n /// @dev returns the hash of the init code (creation code + ABI-encoded args) used in CREATE2\\n /// @param creationCode the creation code of a contract C, as returned by type(C).creationCode\\n /// @param args the ABI-encoded arguments to the constructor of C\\n function hashInitCode(bytes memory creationCode, bytes memory args) internal pure returns (bytes32) {\\n return keccak256(abi.encodePacked(creationCode, args));\\n }\\n\\n // Performs a single call with Multicall3 to query the ERC-20 token balances of the given addresses.\\n function getTokenBalances(address token, address[] memory addresses)\\n internal\\n virtual\\n returns (uint256[] memory balances)\\n {\\n uint256 tokenCodeSize;\\n assembly {\\n tokenCodeSize := extcodesize(token)\\n }\\n require(tokenCodeSize > 0, \\\"StdUtils getTokenBalances(address,address[]): Token address is not a contract.\\\");\\n\\n // ABI encode the aggregate call to Multicall3.\\n uint256 length = addresses.length;\\n IMulticall3.Call[] memory calls = new IMulticall3.Call[](length);\\n for (uint256 i = 0; i < length; ++i) {\\n // 0x70a08231 = bytes4(\\\"balanceOf(address)\\\"))\\n calls[i] = IMulticall3.Call({target: token, callData: abi.encodeWithSelector(0x70a08231, (addresses[i]))});\\n }\\n\\n // Make the aggregate call.\\n (, bytes[] memory returnData) = multicall.aggregate(calls);\\n\\n // ABI decode the return data and return the balances.\\n balances = new uint256[](length);\\n for (uint256 i = 0; i < length; ++i) {\\n balances[i] = abi.decode(returnData[i], (uint256));\\n }\\n }\\n\\n /*//////////////////////////////////////////////////////////////////////////\\n PRIVATE FUNCTIONS\\n //////////////////////////////////////////////////////////////////////////*/\\n\\n function addressFromLast20Bytes(bytes32 bytesValue) private pure returns (address) {\\n return address(uint160(uint256(bytesValue)));\\n }\\n\\n // This section is used to prevent the compilation of console, which shortens the compilation time when console is\\n // not used elsewhere. We also trick the compiler into letting us make the console log methods as `pure` to avoid\\n // any breaking changes to function signatures.\\n function _castLogPayloadViewToPure(function(bytes memory) internal view fnIn)\\n internal\\n pure\\n returns (function(bytes memory) internal pure fnOut)\\n {\\n assembly {\\n fnOut := fnIn\\n }\\n }\\n\\n function _sendLogPayload(bytes memory payload) internal pure {\\n _castLogPayloadViewToPure(_sendLogPayloadView)(payload);\\n }\\n\\n function _sendLogPayloadView(bytes memory payload) private view {\\n uint256 payloadLength = payload.length;\\n address consoleAddress = CONSOLE2_ADDRESS;\\n /// @solidity memory-safe-assembly\\n assembly {\\n let payloadStart := add(payload, 32)\\n let r := staticcall(gas(), consoleAddress, payloadStart, payloadLength, 0, 0)\\n }\\n }\\n\\n function console2_log_StdUtils(string memory p0) private pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string)\\\", p0));\\n }\\n\\n function console2_log_StdUtils(string memory p0, uint256 p1) private pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,uint256)\\\", p0, p1));\\n }\\n\\n function console2_log_StdUtils(string memory p0, string memory p1) private pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,string)\\\", p0, p1));\\n }\\n}\\n\",\"keccak256\":\"0x7274081e11c05164fd8eadde4de8305c033e58a43008dea58065f3170ccf0737\",\"license\":\"MIT\"},\"lib/forge-std/src/Vm.sol\":{\"content\":\"// Automatically @generated by scripts/vm.py. Do not modify manually.\\n\\n// SPDX-License-Identifier: MIT OR Apache-2.0\\npragma solidity >=0.6.2 <0.9.0;\\npragma experimental ABIEncoderV2;\\n\\n/// The `VmSafe` interface does not allow manipulation of the EVM state or other actions that may\\n/// result in Script simulations differing from on-chain execution. It is recommended to only use\\n/// these cheats in scripts.\\ninterface VmSafe {\\n /// A modification applied to either `msg.sender` or `tx.origin`. Returned by `readCallers`.\\n enum CallerMode {\\n // No caller modification is currently active.\\n None,\\n // A one time broadcast triggered by a `vm.broadcast()` call is currently active.\\n Broadcast,\\n // A recurrent broadcast triggered by a `vm.startBroadcast()` call is currently active.\\n RecurrentBroadcast,\\n // A one time prank triggered by a `vm.prank()` call is currently active.\\n Prank,\\n // A recurrent prank triggered by a `vm.startPrank()` call is currently active.\\n RecurrentPrank\\n }\\n\\n /// The kind of account access that occurred.\\n enum AccountAccessKind {\\n // The account was called.\\n Call,\\n // The account was called via delegatecall.\\n DelegateCall,\\n // The account was called via callcode.\\n CallCode,\\n // The account was called via staticcall.\\n StaticCall,\\n // The account was created.\\n Create,\\n // The account was selfdestructed.\\n SelfDestruct,\\n // Synthetic access indicating the current context has resumed after a previous sub-context (AccountAccess).\\n Resume,\\n // The account's balance was read.\\n Balance,\\n // The account's codesize was read.\\n Extcodesize,\\n // The account's codehash was read.\\n Extcodehash,\\n // The account's code was copied.\\n Extcodecopy\\n }\\n\\n /// Forge execution contexts.\\n enum ForgeContext {\\n // Test group execution context (test, coverage or snapshot).\\n TestGroup,\\n // `forge test` execution context.\\n Test,\\n // `forge coverage` execution context.\\n Coverage,\\n // `forge snapshot` execution context.\\n Snapshot,\\n // Script group execution context (dry run, broadcast or resume).\\n ScriptGroup,\\n // `forge script` execution context.\\n ScriptDryRun,\\n // `forge script --broadcast` execution context.\\n ScriptBroadcast,\\n // `forge script --resume` execution context.\\n ScriptResume,\\n // Unknown `forge` execution context.\\n Unknown\\n }\\n\\n /// The transaction type (`txType`) of the broadcast.\\n enum BroadcastTxType {\\n // Represents a CALL broadcast tx.\\n Call,\\n // Represents a CREATE broadcast tx.\\n Create,\\n // Represents a CREATE2 broadcast tx.\\n Create2\\n }\\n\\n /// An Ethereum log. Returned by `getRecordedLogs`.\\n struct Log {\\n // The topics of the log, including the signature, if any.\\n bytes32[] topics;\\n // The raw data of the log.\\n bytes data;\\n // The address of the log's emitter.\\n address emitter;\\n }\\n\\n /// An RPC URL and its alias. Returned by `rpcUrlStructs`.\\n struct Rpc {\\n // The alias of the RPC URL.\\n string key;\\n // The RPC URL.\\n string url;\\n }\\n\\n /// An RPC log object. Returned by `eth_getLogs`.\\n struct EthGetLogs {\\n // The address of the log's emitter.\\n address emitter;\\n // The topics of the log, including the signature, if any.\\n bytes32[] topics;\\n // The raw data of the log.\\n bytes data;\\n // The block hash.\\n bytes32 blockHash;\\n // The block number.\\n uint64 blockNumber;\\n // The transaction hash.\\n bytes32 transactionHash;\\n // The transaction index in the block.\\n uint64 transactionIndex;\\n // The log index.\\n uint256 logIndex;\\n // Whether the log was removed.\\n bool removed;\\n }\\n\\n /// A single entry in a directory listing. Returned by `readDir`.\\n struct DirEntry {\\n // The error message, if any.\\n string errorMessage;\\n // The path of the entry.\\n string path;\\n // The depth of the entry.\\n uint64 depth;\\n // Whether the entry is a directory.\\n bool isDir;\\n // Whether the entry is a symlink.\\n bool isSymlink;\\n }\\n\\n /// Metadata information about a file.\\n /// This structure is returned from the `fsMetadata` function and represents known\\n /// metadata about a file such as its permissions, size, modification\\n /// times, etc.\\n struct FsMetadata {\\n // True if this metadata is for a directory.\\n bool isDir;\\n // True if this metadata is for a symlink.\\n bool isSymlink;\\n // The size of the file, in bytes, this metadata is for.\\n uint256 length;\\n // True if this metadata is for a readonly (unwritable) file.\\n bool readOnly;\\n // The last modification time listed in this metadata.\\n uint256 modified;\\n // The last access time of this metadata.\\n uint256 accessed;\\n // The creation time listed in this metadata.\\n uint256 created;\\n }\\n\\n /// A wallet with a public and private key.\\n struct Wallet {\\n // The wallet's address.\\n address addr;\\n // The wallet's public key `X`.\\n uint256 publicKeyX;\\n // The wallet's public key `Y`.\\n uint256 publicKeyY;\\n // The wallet's private key.\\n uint256 privateKey;\\n }\\n\\n /// The result of a `tryFfi` call.\\n struct FfiResult {\\n // The exit code of the call.\\n int32 exitCode;\\n // The optionally hex-decoded `stdout` data.\\n bytes stdout;\\n // The `stderr` data.\\n bytes stderr;\\n }\\n\\n /// Information on the chain and fork.\\n struct ChainInfo {\\n // The fork identifier. Set to zero if no fork is active.\\n uint256 forkId;\\n // The chain ID of the current fork.\\n uint256 chainId;\\n }\\n\\n /// The result of a `stopAndReturnStateDiff` call.\\n struct AccountAccess {\\n // The chain and fork the access occurred.\\n ChainInfo chainInfo;\\n // The kind of account access that determines what the account is.\\n // If kind is Call, DelegateCall, StaticCall or CallCode, then the account is the callee.\\n // If kind is Create, then the account is the newly created account.\\n // If kind is SelfDestruct, then the account is the selfdestruct recipient.\\n // If kind is a Resume, then account represents a account context that has resumed.\\n AccountAccessKind kind;\\n // The account that was accessed.\\n // It's either the account created, callee or a selfdestruct recipient for CREATE, CALL or SELFDESTRUCT.\\n address account;\\n // What accessed the account.\\n address accessor;\\n // If the account was initialized or empty prior to the access.\\n // An account is considered initialized if it has code, a\\n // non-zero nonce, or a non-zero balance.\\n bool initialized;\\n // The previous balance of the accessed account.\\n uint256 oldBalance;\\n // The potential new balance of the accessed account.\\n // That is, all balance changes are recorded here, even if reverts occurred.\\n uint256 newBalance;\\n // Code of the account deployed by CREATE.\\n bytes deployedCode;\\n // Value passed along with the account access\\n uint256 value;\\n // Input data provided to the CREATE or CALL\\n bytes data;\\n // If this access reverted in either the current or parent context.\\n bool reverted;\\n // An ordered list of storage accesses made during an account access operation.\\n StorageAccess[] storageAccesses;\\n // Call depth traversed during the recording of state differences\\n uint64 depth;\\n }\\n\\n /// The storage accessed during an `AccountAccess`.\\n struct StorageAccess {\\n // The account whose storage was accessed.\\n address account;\\n // The slot that was accessed.\\n bytes32 slot;\\n // If the access was a write.\\n bool isWrite;\\n // The previous value of the slot.\\n bytes32 previousValue;\\n // The new value of the slot.\\n bytes32 newValue;\\n // If the access was reverted.\\n bool reverted;\\n }\\n\\n /// Gas used. Returned by `lastCallGas`.\\n struct Gas {\\n // The gas limit of the call.\\n uint64 gasLimit;\\n // The total gas used.\\n uint64 gasTotalUsed;\\n // DEPRECATED: The amount of gas used for memory expansion. Ref: \\n uint64 gasMemoryUsed;\\n // The amount of gas refunded.\\n int64 gasRefunded;\\n // The amount of gas remaining.\\n uint64 gasRemaining;\\n }\\n\\n /// The result of the `stopDebugTraceRecording` call\\n struct DebugStep {\\n // The stack before executing the step of the run.\\n // stack\\\\[0\\\\] represents the top of the stack.\\n // and only stack data relevant to the opcode execution is contained.\\n uint256[] stack;\\n // The memory input data before executing the step of the run.\\n // only input data relevant to the opcode execution is contained.\\n // e.g. for MLOAD, it will have memory\\\\[offset:offset+32\\\\] copied here.\\n // the offset value can be get by the stack data.\\n bytes memoryInput;\\n // The opcode that was accessed.\\n uint8 opcode;\\n // The call depth of the step.\\n uint64 depth;\\n // Whether the call end up with out of gas error.\\n bool isOutOfGas;\\n // The contract address where the opcode is running\\n address contractAddr;\\n }\\n\\n /// Represents a transaction's broadcast details.\\n struct BroadcastTxSummary {\\n // The hash of the transaction that was broadcasted\\n bytes32 txHash;\\n // Represent the type of transaction among CALL, CREATE, CREATE2\\n BroadcastTxType txType;\\n // The address of the contract that was called or created.\\n // This is address of the contract that is created if the txType is CREATE or CREATE2.\\n address contractAddress;\\n // The block number the transaction landed in.\\n uint64 blockNumber;\\n // Status of the transaction, retrieved from the transaction receipt.\\n bool success;\\n }\\n\\n /// Holds a signed EIP-7702 authorization for an authority account to delegate to an implementation.\\n struct SignedDelegation {\\n // The y-parity of the recovered secp256k1 signature (0 or 1).\\n uint8 v;\\n // First 32 bytes of the signature.\\n bytes32 r;\\n // Second 32 bytes of the signature.\\n bytes32 s;\\n // The current nonce of the authority account at signing time.\\n // Used to ensure signature can't be replayed after account nonce changes.\\n uint64 nonce;\\n // Address of the contract implementation that will be delegated to.\\n // Gets encoded into delegation code: 0xef0100 || implementation.\\n address implementation;\\n }\\n\\n /// Represents a \\\"potential\\\" revert reason from a single subsequent call when using `vm.assumeNoReverts`.\\n /// Reverts that match will result in a FOUNDRY::ASSUME rejection, whereas unmatched reverts will be surfaced\\n /// as normal.\\n struct PotentialRevert {\\n // The allowed origin of the revert opcode; address(0) allows reverts from any address\\n address reverter;\\n // When true, only matches on the beginning of the revert data, otherwise, matches on entire revert data\\n bool partialMatch;\\n // The data to use to match encountered reverts\\n bytes revertData;\\n }\\n\\n /// An EIP-2930 access list item.\\n struct AccessListItem {\\n // The address to be added in access list.\\n address target;\\n // The storage keys to be added in access list.\\n bytes32[] storageKeys;\\n }\\n\\n // ======== Crypto ========\\n\\n /// Derives a private key from the name, labels the account with that name, and returns the wallet.\\n function createWallet(string calldata walletLabel) external returns (Wallet memory wallet);\\n\\n /// Generates a wallet from the private key and returns the wallet.\\n function createWallet(uint256 privateKey) external returns (Wallet memory wallet);\\n\\n /// Generates a wallet from the private key, labels the account with that name, and returns the wallet.\\n function createWallet(uint256 privateKey, string calldata walletLabel) external returns (Wallet memory wallet);\\n\\n /// Derive a private key from a provided mnenomic string (or mnenomic file path)\\n /// at the derivation path `m/44'/60'/0'/0/{index}`.\\n function deriveKey(string calldata mnemonic, uint32 index) external pure returns (uint256 privateKey);\\n\\n /// Derive a private key from a provided mnenomic string (or mnenomic file path)\\n /// at `{derivationPath}{index}`.\\n function deriveKey(string calldata mnemonic, string calldata derivationPath, uint32 index)\\n external\\n pure\\n returns (uint256 privateKey);\\n\\n /// Derive a private key from a provided mnenomic string (or mnenomic file path) in the specified language\\n /// at the derivation path `m/44'/60'/0'/0/{index}`.\\n function deriveKey(string calldata mnemonic, uint32 index, string calldata language)\\n external\\n pure\\n returns (uint256 privateKey);\\n\\n /// Derive a private key from a provided mnenomic string (or mnenomic file path) in the specified language\\n /// at `{derivationPath}{index}`.\\n function deriveKey(string calldata mnemonic, string calldata derivationPath, uint32 index, string calldata language)\\n external\\n pure\\n returns (uint256 privateKey);\\n\\n /// Derives secp256r1 public key from the provided `privateKey`.\\n function publicKeyP256(uint256 privateKey) external pure returns (uint256 publicKeyX, uint256 publicKeyY);\\n\\n /// Adds a private key to the local forge wallet and returns the address.\\n function rememberKey(uint256 privateKey) external returns (address keyAddr);\\n\\n /// Derive a set number of wallets from a mnemonic at the derivation path `m/44'/60'/0'/0/{0..count}`.\\n /// The respective private keys are saved to the local forge wallet for later use and their addresses are returned.\\n function rememberKeys(string calldata mnemonic, string calldata derivationPath, uint32 count)\\n external\\n returns (address[] memory keyAddrs);\\n\\n /// Derive a set number of wallets from a mnemonic in the specified language at the derivation path `m/44'/60'/0'/0/{0..count}`.\\n /// The respective private keys are saved to the local forge wallet for later use and their addresses are returned.\\n function rememberKeys(\\n string calldata mnemonic,\\n string calldata derivationPath,\\n string calldata language,\\n uint32 count\\n ) external returns (address[] memory keyAddrs);\\n\\n /// Signs data with a `Wallet`.\\n /// Returns a compact signature (`r`, `vs`) as per EIP-2098, where `vs` encodes both the\\n /// signature's `s` value, and the recovery id `v` in a single bytes32.\\n /// This format reduces the signature size from 65 to 64 bytes.\\n function signCompact(Wallet calldata wallet, bytes32 digest) external returns (bytes32 r, bytes32 vs);\\n\\n /// Signs `digest` with `privateKey` using the secp256k1 curve.\\n /// Returns a compact signature (`r`, `vs`) as per EIP-2098, where `vs` encodes both the\\n /// signature's `s` value, and the recovery id `v` in a single bytes32.\\n /// This format reduces the signature size from 65 to 64 bytes.\\n function signCompact(uint256 privateKey, bytes32 digest) external pure returns (bytes32 r, bytes32 vs);\\n\\n /// Signs `digest` with signer provided to script using the secp256k1 curve.\\n /// Returns a compact signature (`r`, `vs`) as per EIP-2098, where `vs` encodes both the\\n /// signature's `s` value, and the recovery id `v` in a single bytes32.\\n /// This format reduces the signature size from 65 to 64 bytes.\\n /// If `--sender` is provided, the signer with provided address is used, otherwise,\\n /// if exactly one signer is provided to the script, that signer is used.\\n /// Raises error if signer passed through `--sender` does not match any unlocked signers or\\n /// if `--sender` is not provided and not exactly one signer is passed to the script.\\n function signCompact(bytes32 digest) external pure returns (bytes32 r, bytes32 vs);\\n\\n /// Signs `digest` with signer provided to script using the secp256k1 curve.\\n /// Returns a compact signature (`r`, `vs`) as per EIP-2098, where `vs` encodes both the\\n /// signature's `s` value, and the recovery id `v` in a single bytes32.\\n /// This format reduces the signature size from 65 to 64 bytes.\\n /// Raises error if none of the signers passed into the script have provided address.\\n function signCompact(address signer, bytes32 digest) external pure returns (bytes32 r, bytes32 vs);\\n\\n /// Signs `digest` with `privateKey` using the secp256r1 curve.\\n function signP256(uint256 privateKey, bytes32 digest) external pure returns (bytes32 r, bytes32 s);\\n\\n /// Signs data with a `Wallet`.\\n function sign(Wallet calldata wallet, bytes32 digest) external returns (uint8 v, bytes32 r, bytes32 s);\\n\\n /// Signs `digest` with `privateKey` using the secp256k1 curve.\\n function sign(uint256 privateKey, bytes32 digest) external pure returns (uint8 v, bytes32 r, bytes32 s);\\n\\n /// Signs `digest` with signer provided to script using the secp256k1 curve.\\n /// If `--sender` is provided, the signer with provided address is used, otherwise,\\n /// if exactly one signer is provided to the script, that signer is used.\\n /// Raises error if signer passed through `--sender` does not match any unlocked signers or\\n /// if `--sender` is not provided and not exactly one signer is passed to the script.\\n function sign(bytes32 digest) external pure returns (uint8 v, bytes32 r, bytes32 s);\\n\\n /// Signs `digest` with signer provided to script using the secp256k1 curve.\\n /// Raises error if none of the signers passed into the script have provided address.\\n function sign(address signer, bytes32 digest) external pure returns (uint8 v, bytes32 r, bytes32 s);\\n\\n // ======== Environment ========\\n\\n /// Gets the environment variable `name` and parses it as `address`.\\n /// Reverts if the variable was not found or could not be parsed.\\n function envAddress(string calldata name) external view returns (address value);\\n\\n /// Gets the environment variable `name` and parses it as an array of `address`, delimited by `delim`.\\n /// Reverts if the variable was not found or could not be parsed.\\n function envAddress(string calldata name, string calldata delim) external view returns (address[] memory value);\\n\\n /// Gets the environment variable `name` and parses it as `bool`.\\n /// Reverts if the variable was not found or could not be parsed.\\n function envBool(string calldata name) external view returns (bool value);\\n\\n /// Gets the environment variable `name` and parses it as an array of `bool`, delimited by `delim`.\\n /// Reverts if the variable was not found or could not be parsed.\\n function envBool(string calldata name, string calldata delim) external view returns (bool[] memory value);\\n\\n /// Gets the environment variable `name` and parses it as `bytes32`.\\n /// Reverts if the variable was not found or could not be parsed.\\n function envBytes32(string calldata name) external view returns (bytes32 value);\\n\\n /// Gets the environment variable `name` and parses it as an array of `bytes32`, delimited by `delim`.\\n /// Reverts if the variable was not found or could not be parsed.\\n function envBytes32(string calldata name, string calldata delim) external view returns (bytes32[] memory value);\\n\\n /// Gets the environment variable `name` and parses it as `bytes`.\\n /// Reverts if the variable was not found or could not be parsed.\\n function envBytes(string calldata name) external view returns (bytes memory value);\\n\\n /// Gets the environment variable `name` and parses it as an array of `bytes`, delimited by `delim`.\\n /// Reverts if the variable was not found or could not be parsed.\\n function envBytes(string calldata name, string calldata delim) external view returns (bytes[] memory value);\\n\\n /// Gets the environment variable `name` and returns true if it exists, else returns false.\\n function envExists(string calldata name) external view returns (bool result);\\n\\n /// Gets the environment variable `name` and parses it as `int256`.\\n /// Reverts if the variable was not found or could not be parsed.\\n function envInt(string calldata name) external view returns (int256 value);\\n\\n /// Gets the environment variable `name` and parses it as an array of `int256`, delimited by `delim`.\\n /// Reverts if the variable was not found or could not be parsed.\\n function envInt(string calldata name, string calldata delim) external view returns (int256[] memory value);\\n\\n /// Gets the environment variable `name` and parses it as `bool`.\\n /// Reverts if the variable could not be parsed.\\n /// Returns `defaultValue` if the variable was not found.\\n function envOr(string calldata name, bool defaultValue) external view returns (bool value);\\n\\n /// Gets the environment variable `name` and parses it as `uint256`.\\n /// Reverts if the variable could not be parsed.\\n /// Returns `defaultValue` if the variable was not found.\\n function envOr(string calldata name, uint256 defaultValue) external view returns (uint256 value);\\n\\n /// Gets the environment variable `name` and parses it as an array of `address`, delimited by `delim`.\\n /// Reverts if the variable could not be parsed.\\n /// Returns `defaultValue` if the variable was not found.\\n function envOr(string calldata name, string calldata delim, address[] calldata defaultValue)\\n external\\n view\\n returns (address[] memory value);\\n\\n /// Gets the environment variable `name` and parses it as an array of `bytes32`, delimited by `delim`.\\n /// Reverts if the variable could not be parsed.\\n /// Returns `defaultValue` if the variable was not found.\\n function envOr(string calldata name, string calldata delim, bytes32[] calldata defaultValue)\\n external\\n view\\n returns (bytes32[] memory value);\\n\\n /// Gets the environment variable `name` and parses it as an array of `string`, delimited by `delim`.\\n /// Reverts if the variable could not be parsed.\\n /// Returns `defaultValue` if the variable was not found.\\n function envOr(string calldata name, string calldata delim, string[] calldata defaultValue)\\n external\\n view\\n returns (string[] memory value);\\n\\n /// Gets the environment variable `name` and parses it as an array of `bytes`, delimited by `delim`.\\n /// Reverts if the variable could not be parsed.\\n /// Returns `defaultValue` if the variable was not found.\\n function envOr(string calldata name, string calldata delim, bytes[] calldata defaultValue)\\n external\\n view\\n returns (bytes[] memory value);\\n\\n /// Gets the environment variable `name` and parses it as `int256`.\\n /// Reverts if the variable could not be parsed.\\n /// Returns `defaultValue` if the variable was not found.\\n function envOr(string calldata name, int256 defaultValue) external view returns (int256 value);\\n\\n /// Gets the environment variable `name` and parses it as `address`.\\n /// Reverts if the variable could not be parsed.\\n /// Returns `defaultValue` if the variable was not found.\\n function envOr(string calldata name, address defaultValue) external view returns (address value);\\n\\n /// Gets the environment variable `name` and parses it as `bytes32`.\\n /// Reverts if the variable could not be parsed.\\n /// Returns `defaultValue` if the variable was not found.\\n function envOr(string calldata name, bytes32 defaultValue) external view returns (bytes32 value);\\n\\n /// Gets the environment variable `name` and parses it as `string`.\\n /// Reverts if the variable could not be parsed.\\n /// Returns `defaultValue` if the variable was not found.\\n function envOr(string calldata name, string calldata defaultValue) external view returns (string memory value);\\n\\n /// Gets the environment variable `name` and parses it as `bytes`.\\n /// Reverts if the variable could not be parsed.\\n /// Returns `defaultValue` if the variable was not found.\\n function envOr(string calldata name, bytes calldata defaultValue) external view returns (bytes memory value);\\n\\n /// Gets the environment variable `name` and parses it as an array of `bool`, delimited by `delim`.\\n /// Reverts if the variable could not be parsed.\\n /// Returns `defaultValue` if the variable was not found.\\n function envOr(string calldata name, string calldata delim, bool[] calldata defaultValue)\\n external\\n view\\n returns (bool[] memory value);\\n\\n /// Gets the environment variable `name` and parses it as an array of `uint256`, delimited by `delim`.\\n /// Reverts if the variable could not be parsed.\\n /// Returns `defaultValue` if the variable was not found.\\n function envOr(string calldata name, string calldata delim, uint256[] calldata defaultValue)\\n external\\n view\\n returns (uint256[] memory value);\\n\\n /// Gets the environment variable `name` and parses it as an array of `int256`, delimited by `delim`.\\n /// Reverts if the variable could not be parsed.\\n /// Returns `defaultValue` if the variable was not found.\\n function envOr(string calldata name, string calldata delim, int256[] calldata defaultValue)\\n external\\n view\\n returns (int256[] memory value);\\n\\n /// Gets the environment variable `name` and parses it as `string`.\\n /// Reverts if the variable was not found or could not be parsed.\\n function envString(string calldata name) external view returns (string memory value);\\n\\n /// Gets the environment variable `name` and parses it as an array of `string`, delimited by `delim`.\\n /// Reverts if the variable was not found or could not be parsed.\\n function envString(string calldata name, string calldata delim) external view returns (string[] memory value);\\n\\n /// Gets the environment variable `name` and parses it as `uint256`.\\n /// Reverts if the variable was not found or could not be parsed.\\n function envUint(string calldata name) external view returns (uint256 value);\\n\\n /// Gets the environment variable `name` and parses it as an array of `uint256`, delimited by `delim`.\\n /// Reverts if the variable was not found or could not be parsed.\\n function envUint(string calldata name, string calldata delim) external view returns (uint256[] memory value);\\n\\n /// Returns true if `forge` command was executed in given context.\\n function isContext(ForgeContext context) external view returns (bool result);\\n\\n /// Sets environment variables.\\n function setEnv(string calldata name, string calldata value) external;\\n\\n // ======== EVM ========\\n\\n /// Gets all accessed reads and write slot from a `vm.record` session, for a given address.\\n function accesses(address target) external returns (bytes32[] memory readSlots, bytes32[] memory writeSlots);\\n\\n /// Gets the address for a given private key.\\n function addr(uint256 privateKey) external pure returns (address keyAddr);\\n\\n /// Gets all the logs according to specified filter.\\n function eth_getLogs(uint256 fromBlock, uint256 toBlock, address target, bytes32[] calldata topics)\\n external\\n returns (EthGetLogs[] memory logs);\\n\\n /// Gets the current `block.blobbasefee`.\\n /// You should use this instead of `block.blobbasefee` if you use `vm.blobBaseFee`, as `block.blobbasefee` is assumed to be constant across a transaction,\\n /// and as a result will get optimized out by the compiler.\\n /// See https://github.com/foundry-rs/foundry/issues/6180\\n function getBlobBaseFee() external view returns (uint256 blobBaseFee);\\n\\n /// Gets the current `block.number`.\\n /// You should use this instead of `block.number` if you use `vm.roll`, as `block.number` is assumed to be constant across a transaction,\\n /// and as a result will get optimized out by the compiler.\\n /// See https://github.com/foundry-rs/foundry/issues/6180\\n function getBlockNumber() external view returns (uint256 height);\\n\\n /// Gets the current `block.timestamp`.\\n /// You should use this instead of `block.timestamp` if you use `vm.warp`, as `block.timestamp` is assumed to be constant across a transaction,\\n /// and as a result will get optimized out by the compiler.\\n /// See https://github.com/foundry-rs/foundry/issues/6180\\n function getBlockTimestamp() external view returns (uint256 timestamp);\\n\\n /// Gets the map key and parent of a mapping at a given slot, for a given address.\\n function getMappingKeyAndParentOf(address target, bytes32 elementSlot)\\n external\\n returns (bool found, bytes32 key, bytes32 parent);\\n\\n /// Gets the number of elements in the mapping at the given slot, for a given address.\\n function getMappingLength(address target, bytes32 mappingSlot) external returns (uint256 length);\\n\\n /// Gets the elements at index idx of the mapping at the given slot, for a given address. The\\n /// index must be less than the length of the mapping (i.e. the number of keys in the mapping).\\n function getMappingSlotAt(address target, bytes32 mappingSlot, uint256 idx) external returns (bytes32 value);\\n\\n /// Gets the nonce of an account.\\n function getNonce(address account) external view returns (uint64 nonce);\\n\\n /// Get the nonce of a `Wallet`.\\n function getNonce(Wallet calldata wallet) external returns (uint64 nonce);\\n\\n /// Gets all the recorded logs.\\n function getRecordedLogs() external returns (Log[] memory logs);\\n\\n /// Returns state diffs from current `vm.startStateDiffRecording` session.\\n function getStateDiff() external view returns (string memory diff);\\n\\n /// Returns state diffs from current `vm.startStateDiffRecording` session, in json format.\\n function getStateDiffJson() external view returns (string memory diff);\\n\\n /// Gets the gas used in the last call from the callee perspective.\\n function lastCallGas() external view returns (Gas memory gas);\\n\\n /// Loads a storage slot from an address.\\n function load(address target, bytes32 slot) external view returns (bytes32 data);\\n\\n /// Pauses gas metering (i.e. gas usage is not counted). Noop if already paused.\\n function pauseGasMetering() external;\\n\\n /// Records all storage reads and writes.\\n function record() external;\\n\\n /// Record all the transaction logs.\\n function recordLogs() external;\\n\\n /// Reset gas metering (i.e. gas usage is set to gas limit).\\n function resetGasMetering() external;\\n\\n /// Resumes gas metering (i.e. gas usage is counted again). Noop if already on.\\n function resumeGasMetering() external;\\n\\n /// Performs an Ethereum JSON-RPC request to the current fork URL.\\n function rpc(string calldata method, string calldata params) external returns (bytes memory data);\\n\\n /// Performs an Ethereum JSON-RPC request to the given endpoint.\\n function rpc(string calldata urlOrAlias, string calldata method, string calldata params)\\n external\\n returns (bytes memory data);\\n\\n /// Records the debug trace during the run.\\n function startDebugTraceRecording() external;\\n\\n /// Starts recording all map SSTOREs for later retrieval.\\n function startMappingRecording() external;\\n\\n /// Record all account accesses as part of CREATE, CALL or SELFDESTRUCT opcodes in order,\\n /// along with the context of the calls\\n function startStateDiffRecording() external;\\n\\n /// Stop debug trace recording and returns the recorded debug trace.\\n function stopAndReturnDebugTraceRecording() external returns (DebugStep[] memory step);\\n\\n /// Returns an ordered array of all account accesses from a `vm.startStateDiffRecording` session.\\n function stopAndReturnStateDiff() external returns (AccountAccess[] memory accountAccesses);\\n\\n /// Stops recording all map SSTOREs for later retrieval and clears the recorded data.\\n function stopMappingRecording() external;\\n\\n // ======== Filesystem ========\\n\\n /// Closes file for reading, resetting the offset and allowing to read it from beginning with readLine.\\n /// `path` is relative to the project root.\\n function closeFile(string calldata path) external;\\n\\n /// Copies the contents of one file to another. This function will **overwrite** the contents of `to`.\\n /// On success, the total number of bytes copied is returned and it is equal to the length of the `to` file as reported by `metadata`.\\n /// Both `from` and `to` are relative to the project root.\\n function copyFile(string calldata from, string calldata to) external returns (uint64 copied);\\n\\n /// Creates a new, empty directory at the provided path.\\n /// This cheatcode will revert in the following situations, but is not limited to just these cases:\\n /// - User lacks permissions to modify `path`.\\n /// - A parent of the given path doesn't exist and `recursive` is false.\\n /// - `path` already exists and `recursive` is false.\\n /// `path` is relative to the project root.\\n function createDir(string calldata path, bool recursive) external;\\n\\n /// Deploys a contract from an artifact file. Takes in the relative path to the json file or the path to the\\n /// artifact in the form of :: where and parts are optional.\\n function deployCode(string calldata artifactPath) external returns (address deployedAddress);\\n\\n /// Deploys a contract from an artifact file. Takes in the relative path to the json file or the path to the\\n /// artifact in the form of :: where and parts are optional.\\n /// Additionally accepts abi-encoded constructor arguments.\\n function deployCode(string calldata artifactPath, bytes calldata constructorArgs)\\n external\\n returns (address deployedAddress);\\n\\n /// Returns true if the given path points to an existing entity, else returns false.\\n function exists(string calldata path) external view returns (bool result);\\n\\n /// Performs a foreign function call via the terminal.\\n function ffi(string[] calldata commandInput) external returns (bytes memory result);\\n\\n /// Given a path, query the file system to get information about a file, directory, etc.\\n function fsMetadata(string calldata path) external view returns (FsMetadata memory metadata);\\n\\n /// Gets the artifact path from code (aka. creation code).\\n function getArtifactPathByCode(bytes calldata code) external view returns (string memory path);\\n\\n /// Gets the artifact path from deployed code (aka. runtime code).\\n function getArtifactPathByDeployedCode(bytes calldata deployedCode) external view returns (string memory path);\\n\\n /// Returns the most recent broadcast for the given contract on `chainId` matching `txType`.\\n /// For example:\\n /// The most recent deployment can be fetched by passing `txType` as `CREATE` or `CREATE2`.\\n /// The most recent call can be fetched by passing `txType` as `CALL`.\\n function getBroadcast(string calldata contractName, uint64 chainId, BroadcastTxType txType)\\n external\\n view\\n returns (BroadcastTxSummary memory);\\n\\n /// Returns all broadcasts for the given contract on `chainId` with the specified `txType`.\\n /// Sorted such that the most recent broadcast is the first element, and the oldest is the last. i.e descending order of BroadcastTxSummary.blockNumber.\\n function getBroadcasts(string calldata contractName, uint64 chainId, BroadcastTxType txType)\\n external\\n view\\n returns (BroadcastTxSummary[] memory);\\n\\n /// Returns all broadcasts for the given contract on `chainId`.\\n /// Sorted such that the most recent broadcast is the first element, and the oldest is the last. i.e descending order of BroadcastTxSummary.blockNumber.\\n function getBroadcasts(string calldata contractName, uint64 chainId)\\n external\\n view\\n returns (BroadcastTxSummary[] memory);\\n\\n /// Gets the creation bytecode from an artifact file. Takes in the relative path to the json file or the path to the\\n /// artifact in the form of :: where and parts are optional.\\n function getCode(string calldata artifactPath) external view returns (bytes memory creationBytecode);\\n\\n /// Gets the deployed bytecode from an artifact file. Takes in the relative path to the json file or the path to the\\n /// artifact in the form of :: where and parts are optional.\\n function getDeployedCode(string calldata artifactPath) external view returns (bytes memory runtimeBytecode);\\n\\n /// Returns the most recent deployment for the current `chainId`.\\n function getDeployment(string calldata contractName) external view returns (address deployedAddress);\\n\\n /// Returns the most recent deployment for the given contract on `chainId`\\n function getDeployment(string calldata contractName, uint64 chainId)\\n external\\n view\\n returns (address deployedAddress);\\n\\n /// Returns all deployments for the given contract on `chainId`\\n /// Sorted in descending order of deployment time i.e descending order of BroadcastTxSummary.blockNumber.\\n /// The most recent deployment is the first element, and the oldest is the last.\\n function getDeployments(string calldata contractName, uint64 chainId)\\n external\\n view\\n returns (address[] memory deployedAddresses);\\n\\n /// Returns true if the path exists on disk and is pointing at a directory, else returns false.\\n function isDir(string calldata path) external view returns (bool result);\\n\\n /// Returns true if the path exists on disk and is pointing at a regular file, else returns false.\\n function isFile(string calldata path) external view returns (bool result);\\n\\n /// Get the path of the current project root.\\n function projectRoot() external view returns (string memory path);\\n\\n /// Prompts the user for a string value in the terminal.\\n function prompt(string calldata promptText) external returns (string memory input);\\n\\n /// Prompts the user for an address in the terminal.\\n function promptAddress(string calldata promptText) external returns (address);\\n\\n /// Prompts the user for a hidden string value in the terminal.\\n function promptSecret(string calldata promptText) external returns (string memory input);\\n\\n /// Prompts the user for hidden uint256 in the terminal (usually pk).\\n function promptSecretUint(string calldata promptText) external returns (uint256);\\n\\n /// Prompts the user for uint256 in the terminal.\\n function promptUint(string calldata promptText) external returns (uint256);\\n\\n /// Reads the directory at the given path recursively, up to `maxDepth`.\\n /// `maxDepth` defaults to 1, meaning only the direct children of the given directory will be returned.\\n /// Follows symbolic links if `followLinks` is true.\\n function readDir(string calldata path) external view returns (DirEntry[] memory entries);\\n\\n /// See `readDir(string)`.\\n function readDir(string calldata path, uint64 maxDepth) external view returns (DirEntry[] memory entries);\\n\\n /// See `readDir(string)`.\\n function readDir(string calldata path, uint64 maxDepth, bool followLinks)\\n external\\n view\\n returns (DirEntry[] memory entries);\\n\\n /// Reads the entire content of file to string. `path` is relative to the project root.\\n function readFile(string calldata path) external view returns (string memory data);\\n\\n /// Reads the entire content of file as binary. `path` is relative to the project root.\\n function readFileBinary(string calldata path) external view returns (bytes memory data);\\n\\n /// Reads next line of file to string.\\n function readLine(string calldata path) external view returns (string memory line);\\n\\n /// Reads a symbolic link, returning the path that the link points to.\\n /// This cheatcode will revert in the following situations, but is not limited to just these cases:\\n /// - `path` is not a symbolic link.\\n /// - `path` does not exist.\\n function readLink(string calldata linkPath) external view returns (string memory targetPath);\\n\\n /// Removes a directory at the provided path.\\n /// This cheatcode will revert in the following situations, but is not limited to just these cases:\\n /// - `path` doesn't exist.\\n /// - `path` isn't a directory.\\n /// - User lacks permissions to modify `path`.\\n /// - The directory is not empty and `recursive` is false.\\n /// `path` is relative to the project root.\\n function removeDir(string calldata path, bool recursive) external;\\n\\n /// Removes a file from the filesystem.\\n /// This cheatcode will revert in the following situations, but is not limited to just these cases:\\n /// - `path` points to a directory.\\n /// - The file doesn't exist.\\n /// - The user lacks permissions to remove the file.\\n /// `path` is relative to the project root.\\n function removeFile(string calldata path) external;\\n\\n /// Performs a foreign function call via terminal and returns the exit code, stdout, and stderr.\\n function tryFfi(string[] calldata commandInput) external returns (FfiResult memory result);\\n\\n /// Returns the time since unix epoch in milliseconds.\\n function unixTime() external view returns (uint256 milliseconds);\\n\\n /// Writes data to file, creating a file if it does not exist, and entirely replacing its contents if it does.\\n /// `path` is relative to the project root.\\n function writeFile(string calldata path, string calldata data) external;\\n\\n /// Writes binary data to a file, creating a file if it does not exist, and entirely replacing its contents if it does.\\n /// `path` is relative to the project root.\\n function writeFileBinary(string calldata path, bytes calldata data) external;\\n\\n /// Writes line to file, creating a file if it does not exist.\\n /// `path` is relative to the project root.\\n function writeLine(string calldata path, string calldata data) external;\\n\\n // ======== JSON ========\\n\\n /// Checks if `key` exists in a JSON object.\\n function keyExistsJson(string calldata json, string calldata key) external view returns (bool);\\n\\n /// Parses a string of JSON data at `key` and coerces it to `address`.\\n function parseJsonAddress(string calldata json, string calldata key) external pure returns (address);\\n\\n /// Parses a string of JSON data at `key` and coerces it to `address[]`.\\n function parseJsonAddressArray(string calldata json, string calldata key)\\n external\\n pure\\n returns (address[] memory);\\n\\n /// Parses a string of JSON data at `key` and coerces it to `bool`.\\n function parseJsonBool(string calldata json, string calldata key) external pure returns (bool);\\n\\n /// Parses a string of JSON data at `key` and coerces it to `bool[]`.\\n function parseJsonBoolArray(string calldata json, string calldata key) external pure returns (bool[] memory);\\n\\n /// Parses a string of JSON data at `key` and coerces it to `bytes`.\\n function parseJsonBytes(string calldata json, string calldata key) external pure returns (bytes memory);\\n\\n /// Parses a string of JSON data at `key` and coerces it to `bytes32`.\\n function parseJsonBytes32(string calldata json, string calldata key) external pure returns (bytes32);\\n\\n /// Parses a string of JSON data at `key` and coerces it to `bytes32[]`.\\n function parseJsonBytes32Array(string calldata json, string calldata key)\\n external\\n pure\\n returns (bytes32[] memory);\\n\\n /// Parses a string of JSON data at `key` and coerces it to `bytes[]`.\\n function parseJsonBytesArray(string calldata json, string calldata key) external pure returns (bytes[] memory);\\n\\n /// Parses a string of JSON data at `key` and coerces it to `int256`.\\n function parseJsonInt(string calldata json, string calldata key) external pure returns (int256);\\n\\n /// Parses a string of JSON data at `key` and coerces it to `int256[]`.\\n function parseJsonIntArray(string calldata json, string calldata key) external pure returns (int256[] memory);\\n\\n /// Returns an array of all the keys in a JSON object.\\n function parseJsonKeys(string calldata json, string calldata key) external pure returns (string[] memory keys);\\n\\n /// Parses a string of JSON data at `key` and coerces it to `string`.\\n function parseJsonString(string calldata json, string calldata key) external pure returns (string memory);\\n\\n /// Parses a string of JSON data at `key` and coerces it to `string[]`.\\n function parseJsonStringArray(string calldata json, string calldata key) external pure returns (string[] memory);\\n\\n /// Parses a string of JSON data at `key` and coerces it to type array corresponding to `typeDescription`.\\n function parseJsonTypeArray(string calldata json, string calldata key, string calldata typeDescription)\\n external\\n pure\\n returns (bytes memory);\\n\\n /// Parses a string of JSON data and coerces it to type corresponding to `typeDescription`.\\n function parseJsonType(string calldata json, string calldata typeDescription)\\n external\\n pure\\n returns (bytes memory);\\n\\n /// Parses a string of JSON data at `key` and coerces it to type corresponding to `typeDescription`.\\n function parseJsonType(string calldata json, string calldata key, string calldata typeDescription)\\n external\\n pure\\n returns (bytes memory);\\n\\n /// Parses a string of JSON data at `key` and coerces it to `uint256`.\\n function parseJsonUint(string calldata json, string calldata key) external pure returns (uint256);\\n\\n /// Parses a string of JSON data at `key` and coerces it to `uint256[]`.\\n function parseJsonUintArray(string calldata json, string calldata key) external pure returns (uint256[] memory);\\n\\n /// ABI-encodes a JSON object.\\n function parseJson(string calldata json) external pure returns (bytes memory abiEncodedData);\\n\\n /// ABI-encodes a JSON object at `key`.\\n function parseJson(string calldata json, string calldata key) external pure returns (bytes memory abiEncodedData);\\n\\n /// See `serializeJson`.\\n function serializeAddress(string calldata objectKey, string calldata valueKey, address value)\\n external\\n returns (string memory json);\\n\\n /// See `serializeJson`.\\n function serializeAddress(string calldata objectKey, string calldata valueKey, address[] calldata values)\\n external\\n returns (string memory json);\\n\\n /// See `serializeJson`.\\n function serializeBool(string calldata objectKey, string calldata valueKey, bool value)\\n external\\n returns (string memory json);\\n\\n /// See `serializeJson`.\\n function serializeBool(string calldata objectKey, string calldata valueKey, bool[] calldata values)\\n external\\n returns (string memory json);\\n\\n /// See `serializeJson`.\\n function serializeBytes32(string calldata objectKey, string calldata valueKey, bytes32 value)\\n external\\n returns (string memory json);\\n\\n /// See `serializeJson`.\\n function serializeBytes32(string calldata objectKey, string calldata valueKey, bytes32[] calldata values)\\n external\\n returns (string memory json);\\n\\n /// See `serializeJson`.\\n function serializeBytes(string calldata objectKey, string calldata valueKey, bytes calldata value)\\n external\\n returns (string memory json);\\n\\n /// See `serializeJson`.\\n function serializeBytes(string calldata objectKey, string calldata valueKey, bytes[] calldata values)\\n external\\n returns (string memory json);\\n\\n /// See `serializeJson`.\\n function serializeInt(string calldata objectKey, string calldata valueKey, int256 value)\\n external\\n returns (string memory json);\\n\\n /// See `serializeJson`.\\n function serializeInt(string calldata objectKey, string calldata valueKey, int256[] calldata values)\\n external\\n returns (string memory json);\\n\\n /// Serializes a key and value to a JSON object stored in-memory that can be later written to a file.\\n /// Returns the stringified version of the specific JSON file up to that moment.\\n function serializeJson(string calldata objectKey, string calldata value) external returns (string memory json);\\n\\n /// See `serializeJson`.\\n function serializeJsonType(string calldata typeDescription, bytes calldata value)\\n external\\n pure\\n returns (string memory json);\\n\\n /// See `serializeJson`.\\n function serializeJsonType(\\n string calldata objectKey,\\n string calldata valueKey,\\n string calldata typeDescription,\\n bytes calldata value\\n ) external returns (string memory json);\\n\\n /// See `serializeJson`.\\n function serializeString(string calldata objectKey, string calldata valueKey, string calldata value)\\n external\\n returns (string memory json);\\n\\n /// See `serializeJson`.\\n function serializeString(string calldata objectKey, string calldata valueKey, string[] calldata values)\\n external\\n returns (string memory json);\\n\\n /// See `serializeJson`.\\n function serializeUintToHex(string calldata objectKey, string calldata valueKey, uint256 value)\\n external\\n returns (string memory json);\\n\\n /// See `serializeJson`.\\n function serializeUint(string calldata objectKey, string calldata valueKey, uint256 value)\\n external\\n returns (string memory json);\\n\\n /// See `serializeJson`.\\n function serializeUint(string calldata objectKey, string calldata valueKey, uint256[] calldata values)\\n external\\n returns (string memory json);\\n\\n /// Write a serialized JSON object to a file. If the file exists, it will be overwritten.\\n function writeJson(string calldata json, string calldata path) external;\\n\\n /// Write a serialized JSON object to an **existing** JSON file, replacing a value with key = \\n /// This is useful to replace a specific value of a JSON file, without having to parse the entire thing.\\n function writeJson(string calldata json, string calldata path, string calldata valueKey) external;\\n\\n /// Checks if `key` exists in a JSON object\\n /// `keyExists` is being deprecated in favor of `keyExistsJson`. It will be removed in future versions.\\n function keyExists(string calldata json, string calldata key) external view returns (bool);\\n\\n // ======== Scripting ========\\n\\n /// Designate the next call as an EIP-7702 transaction\\n function attachDelegation(SignedDelegation calldata signedDelegation) external;\\n\\n /// Takes a signed transaction and broadcasts it to the network.\\n function broadcastRawTransaction(bytes calldata data) external;\\n\\n /// Has the next call (at this call depth only) create transactions that can later be signed and sent onchain.\\n /// Broadcasting address is determined by checking the following in order:\\n /// 1. If `--sender` argument was provided, that address is used.\\n /// 2. If exactly one signer (e.g. private key, hw wallet, keystore) is set when `forge broadcast` is invoked, that signer is used.\\n /// 3. Otherwise, default foundry sender (1804c8AB1F12E6bbf3894d4083f33e07309d1f38) is used.\\n function broadcast() external;\\n\\n /// Has the next call (at this call depth only) create a transaction with the address provided\\n /// as the sender that can later be signed and sent onchain.\\n function broadcast(address signer) external;\\n\\n /// Has the next call (at this call depth only) create a transaction with the private key\\n /// provided as the sender that can later be signed and sent onchain.\\n function broadcast(uint256 privateKey) external;\\n\\n /// Returns addresses of available unlocked wallets in the script environment.\\n function getWallets() external returns (address[] memory wallets);\\n\\n /// Sign an EIP-7702 authorization and designate the next call as an EIP-7702 transaction\\n function signAndAttachDelegation(address implementation, uint256 privateKey)\\n external\\n returns (SignedDelegation memory signedDelegation);\\n\\n /// Sign an EIP-7702 authorization for delegation\\n function signDelegation(address implementation, uint256 privateKey)\\n external\\n returns (SignedDelegation memory signedDelegation);\\n\\n /// Has all subsequent calls (at this call depth only) create transactions that can later be signed and sent onchain.\\n /// Broadcasting address is determined by checking the following in order:\\n /// 1. If `--sender` argument was provided, that address is used.\\n /// 2. If exactly one signer (e.g. private key, hw wallet, keystore) is set when `forge broadcast` is invoked, that signer is used.\\n /// 3. Otherwise, default foundry sender (1804c8AB1F12E6bbf3894d4083f33e07309d1f38) is used.\\n function startBroadcast() external;\\n\\n /// Has all subsequent calls (at this call depth only) create transactions with the address\\n /// provided that can later be signed and sent onchain.\\n function startBroadcast(address signer) external;\\n\\n /// Has all subsequent calls (at this call depth only) create transactions with the private key\\n /// provided that can later be signed and sent onchain.\\n function startBroadcast(uint256 privateKey) external;\\n\\n /// Stops collecting onchain transactions.\\n function stopBroadcast() external;\\n\\n // ======== String ========\\n\\n /// Returns true if `search` is found in `subject`, false otherwise.\\n function contains(string calldata subject, string calldata search) external returns (bool result);\\n\\n /// Returns the index of the first occurrence of a `key` in an `input` string.\\n /// Returns `NOT_FOUND` (i.e. `type(uint256).max`) if the `key` is not found.\\n /// Returns 0 in case of an empty `key`.\\n function indexOf(string calldata input, string calldata key) external pure returns (uint256);\\n\\n /// Parses the given `string` into an `address`.\\n function parseAddress(string calldata stringifiedValue) external pure returns (address parsedValue);\\n\\n /// Parses the given `string` into a `bool`.\\n function parseBool(string calldata stringifiedValue) external pure returns (bool parsedValue);\\n\\n /// Parses the given `string` into `bytes`.\\n function parseBytes(string calldata stringifiedValue) external pure returns (bytes memory parsedValue);\\n\\n /// Parses the given `string` into a `bytes32`.\\n function parseBytes32(string calldata stringifiedValue) external pure returns (bytes32 parsedValue);\\n\\n /// Parses the given `string` into a `int256`.\\n function parseInt(string calldata stringifiedValue) external pure returns (int256 parsedValue);\\n\\n /// Parses the given `string` into a `uint256`.\\n function parseUint(string calldata stringifiedValue) external pure returns (uint256 parsedValue);\\n\\n /// Replaces occurrences of `from` in the given `string` with `to`.\\n function replace(string calldata input, string calldata from, string calldata to)\\n external\\n pure\\n returns (string memory output);\\n\\n /// Splits the given `string` into an array of strings divided by the `delimiter`.\\n function split(string calldata input, string calldata delimiter) external pure returns (string[] memory outputs);\\n\\n /// Converts the given `string` value to Lowercase.\\n function toLowercase(string calldata input) external pure returns (string memory output);\\n\\n /// Converts the given value to a `string`.\\n function toString(address value) external pure returns (string memory stringifiedValue);\\n\\n /// Converts the given value to a `string`.\\n function toString(bytes calldata value) external pure returns (string memory stringifiedValue);\\n\\n /// Converts the given value to a `string`.\\n function toString(bytes32 value) external pure returns (string memory stringifiedValue);\\n\\n /// Converts the given value to a `string`.\\n function toString(bool value) external pure returns (string memory stringifiedValue);\\n\\n /// Converts the given value to a `string`.\\n function toString(uint256 value) external pure returns (string memory stringifiedValue);\\n\\n /// Converts the given value to a `string`.\\n function toString(int256 value) external pure returns (string memory stringifiedValue);\\n\\n /// Converts the given `string` value to Uppercase.\\n function toUppercase(string calldata input) external pure returns (string memory output);\\n\\n /// Trims leading and trailing whitespace from the given `string` value.\\n function trim(string calldata input) external pure returns (string memory output);\\n\\n // ======== Testing ========\\n\\n /// Compares two `uint256` values. Expects difference to be less than or equal to `maxDelta`.\\n /// Formats values with decimals in failure message.\\n function assertApproxEqAbsDecimal(uint256 left, uint256 right, uint256 maxDelta, uint256 decimals) external pure;\\n\\n /// Compares two `uint256` values. Expects difference to be less than or equal to `maxDelta`.\\n /// Formats values with decimals in failure message. Includes error message into revert string on failure.\\n function assertApproxEqAbsDecimal(\\n uint256 left,\\n uint256 right,\\n uint256 maxDelta,\\n uint256 decimals,\\n string calldata error\\n ) external pure;\\n\\n /// Compares two `int256` values. Expects difference to be less than or equal to `maxDelta`.\\n /// Formats values with decimals in failure message.\\n function assertApproxEqAbsDecimal(int256 left, int256 right, uint256 maxDelta, uint256 decimals) external pure;\\n\\n /// Compares two `int256` values. Expects difference to be less than or equal to `maxDelta`.\\n /// Formats values with decimals in failure message. Includes error message into revert string on failure.\\n function assertApproxEqAbsDecimal(\\n int256 left,\\n int256 right,\\n uint256 maxDelta,\\n uint256 decimals,\\n string calldata error\\n ) external pure;\\n\\n /// Compares two `uint256` values. Expects difference to be less than or equal to `maxDelta`.\\n function assertApproxEqAbs(uint256 left, uint256 right, uint256 maxDelta) external pure;\\n\\n /// Compares two `uint256` values. Expects difference to be less than or equal to `maxDelta`.\\n /// Includes error message into revert string on failure.\\n function assertApproxEqAbs(uint256 left, uint256 right, uint256 maxDelta, string calldata error) external pure;\\n\\n /// Compares two `int256` values. Expects difference to be less than or equal to `maxDelta`.\\n function assertApproxEqAbs(int256 left, int256 right, uint256 maxDelta) external pure;\\n\\n /// Compares two `int256` values. Expects difference to be less than or equal to `maxDelta`.\\n /// Includes error message into revert string on failure.\\n function assertApproxEqAbs(int256 left, int256 right, uint256 maxDelta, string calldata error) external pure;\\n\\n /// Compares two `uint256` values. Expects relative difference in percents to be less than or equal to `maxPercentDelta`.\\n /// `maxPercentDelta` is an 18 decimal fixed point number, where 1e18 == 100%\\n /// Formats values with decimals in failure message.\\n function assertApproxEqRelDecimal(uint256 left, uint256 right, uint256 maxPercentDelta, uint256 decimals)\\n external\\n pure;\\n\\n /// Compares two `uint256` values. Expects relative difference in percents to be less than or equal to `maxPercentDelta`.\\n /// `maxPercentDelta` is an 18 decimal fixed point number, where 1e18 == 100%\\n /// Formats values with decimals in failure message. Includes error message into revert string on failure.\\n function assertApproxEqRelDecimal(\\n uint256 left,\\n uint256 right,\\n uint256 maxPercentDelta,\\n uint256 decimals,\\n string calldata error\\n ) external pure;\\n\\n /// Compares two `int256` values. Expects relative difference in percents to be less than or equal to `maxPercentDelta`.\\n /// `maxPercentDelta` is an 18 decimal fixed point number, where 1e18 == 100%\\n /// Formats values with decimals in failure message.\\n function assertApproxEqRelDecimal(int256 left, int256 right, uint256 maxPercentDelta, uint256 decimals)\\n external\\n pure;\\n\\n /// Compares two `int256` values. Expects relative difference in percents to be less than or equal to `maxPercentDelta`.\\n /// `maxPercentDelta` is an 18 decimal fixed point number, where 1e18 == 100%\\n /// Formats values with decimals in failure message. Includes error message into revert string on failure.\\n function assertApproxEqRelDecimal(\\n int256 left,\\n int256 right,\\n uint256 maxPercentDelta,\\n uint256 decimals,\\n string calldata error\\n ) external pure;\\n\\n /// Compares two `uint256` values. Expects relative difference in percents to be less than or equal to `maxPercentDelta`.\\n /// `maxPercentDelta` is an 18 decimal fixed point number, where 1e18 == 100%\\n function assertApproxEqRel(uint256 left, uint256 right, uint256 maxPercentDelta) external pure;\\n\\n /// Compares two `uint256` values. Expects relative difference in percents to be less than or equal to `maxPercentDelta`.\\n /// `maxPercentDelta` is an 18 decimal fixed point number, where 1e18 == 100%\\n /// Includes error message into revert string on failure.\\n function assertApproxEqRel(uint256 left, uint256 right, uint256 maxPercentDelta, string calldata error)\\n external\\n pure;\\n\\n /// Compares two `int256` values. Expects relative difference in percents to be less than or equal to `maxPercentDelta`.\\n /// `maxPercentDelta` is an 18 decimal fixed point number, where 1e18 == 100%\\n function assertApproxEqRel(int256 left, int256 right, uint256 maxPercentDelta) external pure;\\n\\n /// Compares two `int256` values. Expects relative difference in percents to be less than or equal to `maxPercentDelta`.\\n /// `maxPercentDelta` is an 18 decimal fixed point number, where 1e18 == 100%\\n /// Includes error message into revert string on failure.\\n function assertApproxEqRel(int256 left, int256 right, uint256 maxPercentDelta, string calldata error)\\n external\\n pure;\\n\\n /// Asserts that two `uint256` values are equal, formatting them with decimals in failure message.\\n function assertEqDecimal(uint256 left, uint256 right, uint256 decimals) external pure;\\n\\n /// Asserts that two `uint256` values are equal, formatting them with decimals in failure message.\\n /// Includes error message into revert string on failure.\\n function assertEqDecimal(uint256 left, uint256 right, uint256 decimals, string calldata error) external pure;\\n\\n /// Asserts that two `int256` values are equal, formatting them with decimals in failure message.\\n function assertEqDecimal(int256 left, int256 right, uint256 decimals) external pure;\\n\\n /// Asserts that two `int256` values are equal, formatting them with decimals in failure message.\\n /// Includes error message into revert string on failure.\\n function assertEqDecimal(int256 left, int256 right, uint256 decimals, string calldata error) external pure;\\n\\n /// Asserts that two `bool` values are equal.\\n function assertEq(bool left, bool right) external pure;\\n\\n /// Asserts that two `bool` values are equal and includes error message into revert string on failure.\\n function assertEq(bool left, bool right, string calldata error) external pure;\\n\\n /// Asserts that two `string` values are equal.\\n function assertEq(string calldata left, string calldata right) external pure;\\n\\n /// Asserts that two `string` values are equal and includes error message into revert string on failure.\\n function assertEq(string calldata left, string calldata right, string calldata error) external pure;\\n\\n /// Asserts that two `bytes` values are equal.\\n function assertEq(bytes calldata left, bytes calldata right) external pure;\\n\\n /// Asserts that two `bytes` values are equal and includes error message into revert string on failure.\\n function assertEq(bytes calldata left, bytes calldata right, string calldata error) external pure;\\n\\n /// Asserts that two arrays of `bool` values are equal.\\n function assertEq(bool[] calldata left, bool[] calldata right) external pure;\\n\\n /// Asserts that two arrays of `bool` values are equal and includes error message into revert string on failure.\\n function assertEq(bool[] calldata left, bool[] calldata right, string calldata error) external pure;\\n\\n /// Asserts that two arrays of `uint256 values are equal.\\n function assertEq(uint256[] calldata left, uint256[] calldata right) external pure;\\n\\n /// Asserts that two arrays of `uint256` values are equal and includes error message into revert string on failure.\\n function assertEq(uint256[] calldata left, uint256[] calldata right, string calldata error) external pure;\\n\\n /// Asserts that two arrays of `int256` values are equal.\\n function assertEq(int256[] calldata left, int256[] calldata right) external pure;\\n\\n /// Asserts that two arrays of `int256` values are equal and includes error message into revert string on failure.\\n function assertEq(int256[] calldata left, int256[] calldata right, string calldata error) external pure;\\n\\n /// Asserts that two `uint256` values are equal.\\n function assertEq(uint256 left, uint256 right) external pure;\\n\\n /// Asserts that two arrays of `address` values are equal.\\n function assertEq(address[] calldata left, address[] calldata right) external pure;\\n\\n /// Asserts that two arrays of `address` values are equal and includes error message into revert string on failure.\\n function assertEq(address[] calldata left, address[] calldata right, string calldata error) external pure;\\n\\n /// Asserts that two arrays of `bytes32` values are equal.\\n function assertEq(bytes32[] calldata left, bytes32[] calldata right) external pure;\\n\\n /// Asserts that two arrays of `bytes32` values are equal and includes error message into revert string on failure.\\n function assertEq(bytes32[] calldata left, bytes32[] calldata right, string calldata error) external pure;\\n\\n /// Asserts that two arrays of `string` values are equal.\\n function assertEq(string[] calldata left, string[] calldata right) external pure;\\n\\n /// Asserts that two arrays of `string` values are equal and includes error message into revert string on failure.\\n function assertEq(string[] calldata left, string[] calldata right, string calldata error) external pure;\\n\\n /// Asserts that two arrays of `bytes` values are equal.\\n function assertEq(bytes[] calldata left, bytes[] calldata right) external pure;\\n\\n /// Asserts that two arrays of `bytes` values are equal and includes error message into revert string on failure.\\n function assertEq(bytes[] calldata left, bytes[] calldata right, string calldata error) external pure;\\n\\n /// Asserts that two `uint256` values are equal and includes error message into revert string on failure.\\n function assertEq(uint256 left, uint256 right, string calldata error) external pure;\\n\\n /// Asserts that two `int256` values are equal.\\n function assertEq(int256 left, int256 right) external pure;\\n\\n /// Asserts that two `int256` values are equal and includes error message into revert string on failure.\\n function assertEq(int256 left, int256 right, string calldata error) external pure;\\n\\n /// Asserts that two `address` values are equal.\\n function assertEq(address left, address right) external pure;\\n\\n /// Asserts that two `address` values are equal and includes error message into revert string on failure.\\n function assertEq(address left, address right, string calldata error) external pure;\\n\\n /// Asserts that two `bytes32` values are equal.\\n function assertEq(bytes32 left, bytes32 right) external pure;\\n\\n /// Asserts that two `bytes32` values are equal and includes error message into revert string on failure.\\n function assertEq(bytes32 left, bytes32 right, string calldata error) external pure;\\n\\n /// Asserts that the given condition is false.\\n function assertFalse(bool condition) external pure;\\n\\n /// Asserts that the given condition is false and includes error message into revert string on failure.\\n function assertFalse(bool condition, string calldata error) external pure;\\n\\n /// Compares two `uint256` values. Expects first value to be greater than or equal to second.\\n /// Formats values with decimals in failure message.\\n function assertGeDecimal(uint256 left, uint256 right, uint256 decimals) external pure;\\n\\n /// Compares two `uint256` values. Expects first value to be greater than or equal to second.\\n /// Formats values with decimals in failure message. Includes error message into revert string on failure.\\n function assertGeDecimal(uint256 left, uint256 right, uint256 decimals, string calldata error) external pure;\\n\\n /// Compares two `int256` values. Expects first value to be greater than or equal to second.\\n /// Formats values with decimals in failure message.\\n function assertGeDecimal(int256 left, int256 right, uint256 decimals) external pure;\\n\\n /// Compares two `int256` values. Expects first value to be greater than or equal to second.\\n /// Formats values with decimals in failure message. Includes error message into revert string on failure.\\n function assertGeDecimal(int256 left, int256 right, uint256 decimals, string calldata error) external pure;\\n\\n /// Compares two `uint256` values. Expects first value to be greater than or equal to second.\\n function assertGe(uint256 left, uint256 right) external pure;\\n\\n /// Compares two `uint256` values. Expects first value to be greater than or equal to second.\\n /// Includes error message into revert string on failure.\\n function assertGe(uint256 left, uint256 right, string calldata error) external pure;\\n\\n /// Compares two `int256` values. Expects first value to be greater than or equal to second.\\n function assertGe(int256 left, int256 right) external pure;\\n\\n /// Compares two `int256` values. Expects first value to be greater than or equal to second.\\n /// Includes error message into revert string on failure.\\n function assertGe(int256 left, int256 right, string calldata error) external pure;\\n\\n /// Compares two `uint256` values. Expects first value to be greater than second.\\n /// Formats values with decimals in failure message.\\n function assertGtDecimal(uint256 left, uint256 right, uint256 decimals) external pure;\\n\\n /// Compares two `uint256` values. Expects first value to be greater than second.\\n /// Formats values with decimals in failure message. Includes error message into revert string on failure.\\n function assertGtDecimal(uint256 left, uint256 right, uint256 decimals, string calldata error) external pure;\\n\\n /// Compares two `int256` values. Expects first value to be greater than second.\\n /// Formats values with decimals in failure message.\\n function assertGtDecimal(int256 left, int256 right, uint256 decimals) external pure;\\n\\n /// Compares two `int256` values. Expects first value to be greater than second.\\n /// Formats values with decimals in failure message. Includes error message into revert string on failure.\\n function assertGtDecimal(int256 left, int256 right, uint256 decimals, string calldata error) external pure;\\n\\n /// Compares two `uint256` values. Expects first value to be greater than second.\\n function assertGt(uint256 left, uint256 right) external pure;\\n\\n /// Compares two `uint256` values. Expects first value to be greater than second.\\n /// Includes error message into revert string on failure.\\n function assertGt(uint256 left, uint256 right, string calldata error) external pure;\\n\\n /// Compares two `int256` values. Expects first value to be greater than second.\\n function assertGt(int256 left, int256 right) external pure;\\n\\n /// Compares two `int256` values. Expects first value to be greater than second.\\n /// Includes error message into revert string on failure.\\n function assertGt(int256 left, int256 right, string calldata error) external pure;\\n\\n /// Compares two `uint256` values. Expects first value to be less than or equal to second.\\n /// Formats values with decimals in failure message.\\n function assertLeDecimal(uint256 left, uint256 right, uint256 decimals) external pure;\\n\\n /// Compares two `uint256` values. Expects first value to be less than or equal to second.\\n /// Formats values with decimals in failure message. Includes error message into revert string on failure.\\n function assertLeDecimal(uint256 left, uint256 right, uint256 decimals, string calldata error) external pure;\\n\\n /// Compares two `int256` values. Expects first value to be less than or equal to second.\\n /// Formats values with decimals in failure message.\\n function assertLeDecimal(int256 left, int256 right, uint256 decimals) external pure;\\n\\n /// Compares two `int256` values. Expects first value to be less than or equal to second.\\n /// Formats values with decimals in failure message. Includes error message into revert string on failure.\\n function assertLeDecimal(int256 left, int256 right, uint256 decimals, string calldata error) external pure;\\n\\n /// Compares two `uint256` values. Expects first value to be less than or equal to second.\\n function assertLe(uint256 left, uint256 right) external pure;\\n\\n /// Compares two `uint256` values. Expects first value to be less than or equal to second.\\n /// Includes error message into revert string on failure.\\n function assertLe(uint256 left, uint256 right, string calldata error) external pure;\\n\\n /// Compares two `int256` values. Expects first value to be less than or equal to second.\\n function assertLe(int256 left, int256 right) external pure;\\n\\n /// Compares two `int256` values. Expects first value to be less than or equal to second.\\n /// Includes error message into revert string on failure.\\n function assertLe(int256 left, int256 right, string calldata error) external pure;\\n\\n /// Compares two `uint256` values. Expects first value to be less than second.\\n /// Formats values with decimals in failure message.\\n function assertLtDecimal(uint256 left, uint256 right, uint256 decimals) external pure;\\n\\n /// Compares two `uint256` values. Expects first value to be less than second.\\n /// Formats values with decimals in failure message. Includes error message into revert string on failure.\\n function assertLtDecimal(uint256 left, uint256 right, uint256 decimals, string calldata error) external pure;\\n\\n /// Compares two `int256` values. Expects first value to be less than second.\\n /// Formats values with decimals in failure message.\\n function assertLtDecimal(int256 left, int256 right, uint256 decimals) external pure;\\n\\n /// Compares two `int256` values. Expects first value to be less than second.\\n /// Formats values with decimals in failure message. Includes error message into revert string on failure.\\n function assertLtDecimal(int256 left, int256 right, uint256 decimals, string calldata error) external pure;\\n\\n /// Compares two `uint256` values. Expects first value to be less than second.\\n function assertLt(uint256 left, uint256 right) external pure;\\n\\n /// Compares two `uint256` values. Expects first value to be less than second.\\n /// Includes error message into revert string on failure.\\n function assertLt(uint256 left, uint256 right, string calldata error) external pure;\\n\\n /// Compares two `int256` values. Expects first value to be less than second.\\n function assertLt(int256 left, int256 right) external pure;\\n\\n /// Compares two `int256` values. Expects first value to be less than second.\\n /// Includes error message into revert string on failure.\\n function assertLt(int256 left, int256 right, string calldata error) external pure;\\n\\n /// Asserts that two `uint256` values are not equal, formatting them with decimals in failure message.\\n function assertNotEqDecimal(uint256 left, uint256 right, uint256 decimals) external pure;\\n\\n /// Asserts that two `uint256` values are not equal, formatting them with decimals in failure message.\\n /// Includes error message into revert string on failure.\\n function assertNotEqDecimal(uint256 left, uint256 right, uint256 decimals, string calldata error) external pure;\\n\\n /// Asserts that two `int256` values are not equal, formatting them with decimals in failure message.\\n function assertNotEqDecimal(int256 left, int256 right, uint256 decimals) external pure;\\n\\n /// Asserts that two `int256` values are not equal, formatting them with decimals in failure message.\\n /// Includes error message into revert string on failure.\\n function assertNotEqDecimal(int256 left, int256 right, uint256 decimals, string calldata error) external pure;\\n\\n /// Asserts that two `bool` values are not equal.\\n function assertNotEq(bool left, bool right) external pure;\\n\\n /// Asserts that two `bool` values are not equal and includes error message into revert string on failure.\\n function assertNotEq(bool left, bool right, string calldata error) external pure;\\n\\n /// Asserts that two `string` values are not equal.\\n function assertNotEq(string calldata left, string calldata right) external pure;\\n\\n /// Asserts that two `string` values are not equal and includes error message into revert string on failure.\\n function assertNotEq(string calldata left, string calldata right, string calldata error) external pure;\\n\\n /// Asserts that two `bytes` values are not equal.\\n function assertNotEq(bytes calldata left, bytes calldata right) external pure;\\n\\n /// Asserts that two `bytes` values are not equal and includes error message into revert string on failure.\\n function assertNotEq(bytes calldata left, bytes calldata right, string calldata error) external pure;\\n\\n /// Asserts that two arrays of `bool` values are not equal.\\n function assertNotEq(bool[] calldata left, bool[] calldata right) external pure;\\n\\n /// Asserts that two arrays of `bool` values are not equal and includes error message into revert string on failure.\\n function assertNotEq(bool[] calldata left, bool[] calldata right, string calldata error) external pure;\\n\\n /// Asserts that two arrays of `uint256` values are not equal.\\n function assertNotEq(uint256[] calldata left, uint256[] calldata right) external pure;\\n\\n /// Asserts that two arrays of `uint256` values are not equal and includes error message into revert string on failure.\\n function assertNotEq(uint256[] calldata left, uint256[] calldata right, string calldata error) external pure;\\n\\n /// Asserts that two arrays of `int256` values are not equal.\\n function assertNotEq(int256[] calldata left, int256[] calldata right) external pure;\\n\\n /// Asserts that two arrays of `int256` values are not equal and includes error message into revert string on failure.\\n function assertNotEq(int256[] calldata left, int256[] calldata right, string calldata error) external pure;\\n\\n /// Asserts that two `uint256` values are not equal.\\n function assertNotEq(uint256 left, uint256 right) external pure;\\n\\n /// Asserts that two arrays of `address` values are not equal.\\n function assertNotEq(address[] calldata left, address[] calldata right) external pure;\\n\\n /// Asserts that two arrays of `address` values are not equal and includes error message into revert string on failure.\\n function assertNotEq(address[] calldata left, address[] calldata right, string calldata error) external pure;\\n\\n /// Asserts that two arrays of `bytes32` values are not equal.\\n function assertNotEq(bytes32[] calldata left, bytes32[] calldata right) external pure;\\n\\n /// Asserts that two arrays of `bytes32` values are not equal and includes error message into revert string on failure.\\n function assertNotEq(bytes32[] calldata left, bytes32[] calldata right, string calldata error) external pure;\\n\\n /// Asserts that two arrays of `string` values are not equal.\\n function assertNotEq(string[] calldata left, string[] calldata right) external pure;\\n\\n /// Asserts that two arrays of `string` values are not equal and includes error message into revert string on failure.\\n function assertNotEq(string[] calldata left, string[] calldata right, string calldata error) external pure;\\n\\n /// Asserts that two arrays of `bytes` values are not equal.\\n function assertNotEq(bytes[] calldata left, bytes[] calldata right) external pure;\\n\\n /// Asserts that two arrays of `bytes` values are not equal and includes error message into revert string on failure.\\n function assertNotEq(bytes[] calldata left, bytes[] calldata right, string calldata error) external pure;\\n\\n /// Asserts that two `uint256` values are not equal and includes error message into revert string on failure.\\n function assertNotEq(uint256 left, uint256 right, string calldata error) external pure;\\n\\n /// Asserts that two `int256` values are not equal.\\n function assertNotEq(int256 left, int256 right) external pure;\\n\\n /// Asserts that two `int256` values are not equal and includes error message into revert string on failure.\\n function assertNotEq(int256 left, int256 right, string calldata error) external pure;\\n\\n /// Asserts that two `address` values are not equal.\\n function assertNotEq(address left, address right) external pure;\\n\\n /// Asserts that two `address` values are not equal and includes error message into revert string on failure.\\n function assertNotEq(address left, address right, string calldata error) external pure;\\n\\n /// Asserts that two `bytes32` values are not equal.\\n function assertNotEq(bytes32 left, bytes32 right) external pure;\\n\\n /// Asserts that two `bytes32` values are not equal and includes error message into revert string on failure.\\n function assertNotEq(bytes32 left, bytes32 right, string calldata error) external pure;\\n\\n /// Asserts that the given condition is true.\\n function assertTrue(bool condition) external pure;\\n\\n /// Asserts that the given condition is true and includes error message into revert string on failure.\\n function assertTrue(bool condition, string calldata error) external pure;\\n\\n /// If the condition is false, discard this run's fuzz inputs and generate new ones.\\n function assume(bool condition) external pure;\\n\\n /// Discard this run's fuzz inputs and generate new ones if next call reverted.\\n function assumeNoRevert() external pure;\\n\\n /// Discard this run's fuzz inputs and generate new ones if next call reverts with the potential revert parameters.\\n function assumeNoRevert(PotentialRevert calldata potentialRevert) external pure;\\n\\n /// Discard this run's fuzz inputs and generate new ones if next call reverts with the any of the potential revert parameters.\\n function assumeNoRevert(PotentialRevert[] calldata potentialReverts) external pure;\\n\\n /// Writes a breakpoint to jump to in the debugger.\\n function breakpoint(string calldata char) external pure;\\n\\n /// Writes a conditional breakpoint to jump to in the debugger.\\n function breakpoint(string calldata char, bool value) external pure;\\n\\n /// Returns true if the current Foundry version is greater than or equal to the given version.\\n /// The given version string must be in the format `major.minor.patch`.\\n /// This is equivalent to `foundryVersionCmp(version) >= 0`.\\n function foundryVersionAtLeast(string calldata version) external view returns (bool);\\n\\n /// Compares the current Foundry version with the given version string.\\n /// The given version string must be in the format `major.minor.patch`.\\n /// Returns:\\n /// -1 if current Foundry version is less than the given version\\n /// 0 if current Foundry version equals the given version\\n /// 1 if current Foundry version is greater than the given version\\n /// This result can then be used with a comparison operator against `0`.\\n /// For example, to check if the current Foundry version is greater than or equal to `1.0.0`:\\n /// `if (foundryVersionCmp(\\\"1.0.0\\\") >= 0) { ... }`\\n function foundryVersionCmp(string calldata version) external view returns (int256);\\n\\n /// Returns the Foundry version.\\n /// Format: -+..\\n /// Sample output: 0.3.0-nightly+3cb96bde9b.1737036656.debug\\n /// Note: Build timestamps may vary slightly across platforms due to separate CI jobs.\\n /// For reliable version comparisons, use UNIX format (e.g., >= 1700000000)\\n /// to compare timestamps while ignoring minor time differences.\\n function getFoundryVersion() external view returns (string memory version);\\n\\n /// Returns the RPC url for the given alias.\\n function rpcUrl(string calldata rpcAlias) external view returns (string memory json);\\n\\n /// Returns all rpc urls and their aliases as structs.\\n function rpcUrlStructs() external view returns (Rpc[] memory urls);\\n\\n /// Returns all rpc urls and their aliases `[alias, url][]`.\\n function rpcUrls() external view returns (string[2][] memory urls);\\n\\n /// Suspends execution of the main thread for `duration` milliseconds.\\n function sleep(uint256 duration) external;\\n\\n // ======== Toml ========\\n\\n /// Checks if `key` exists in a TOML table.\\n function keyExistsToml(string calldata toml, string calldata key) external view returns (bool);\\n\\n /// Parses a string of TOML data at `key` and coerces it to `address`.\\n function parseTomlAddress(string calldata toml, string calldata key) external pure returns (address);\\n\\n /// Parses a string of TOML data at `key` and coerces it to `address[]`.\\n function parseTomlAddressArray(string calldata toml, string calldata key)\\n external\\n pure\\n returns (address[] memory);\\n\\n /// Parses a string of TOML data at `key` and coerces it to `bool`.\\n function parseTomlBool(string calldata toml, string calldata key) external pure returns (bool);\\n\\n /// Parses a string of TOML data at `key` and coerces it to `bool[]`.\\n function parseTomlBoolArray(string calldata toml, string calldata key) external pure returns (bool[] memory);\\n\\n /// Parses a string of TOML data at `key` and coerces it to `bytes`.\\n function parseTomlBytes(string calldata toml, string calldata key) external pure returns (bytes memory);\\n\\n /// Parses a string of TOML data at `key` and coerces it to `bytes32`.\\n function parseTomlBytes32(string calldata toml, string calldata key) external pure returns (bytes32);\\n\\n /// Parses a string of TOML data at `key` and coerces it to `bytes32[]`.\\n function parseTomlBytes32Array(string calldata toml, string calldata key)\\n external\\n pure\\n returns (bytes32[] memory);\\n\\n /// Parses a string of TOML data at `key` and coerces it to `bytes[]`.\\n function parseTomlBytesArray(string calldata toml, string calldata key) external pure returns (bytes[] memory);\\n\\n /// Parses a string of TOML data at `key` and coerces it to `int256`.\\n function parseTomlInt(string calldata toml, string calldata key) external pure returns (int256);\\n\\n /// Parses a string of TOML data at `key` and coerces it to `int256[]`.\\n function parseTomlIntArray(string calldata toml, string calldata key) external pure returns (int256[] memory);\\n\\n /// Returns an array of all the keys in a TOML table.\\n function parseTomlKeys(string calldata toml, string calldata key) external pure returns (string[] memory keys);\\n\\n /// Parses a string of TOML data at `key` and coerces it to `string`.\\n function parseTomlString(string calldata toml, string calldata key) external pure returns (string memory);\\n\\n /// Parses a string of TOML data at `key` and coerces it to `string[]`.\\n function parseTomlStringArray(string calldata toml, string calldata key) external pure returns (string[] memory);\\n\\n /// Parses a string of TOML data at `key` and coerces it to type array corresponding to `typeDescription`.\\n function parseTomlTypeArray(string calldata toml, string calldata key, string calldata typeDescription)\\n external\\n pure\\n returns (bytes memory);\\n\\n /// Parses a string of TOML data and coerces it to type corresponding to `typeDescription`.\\n function parseTomlType(string calldata toml, string calldata typeDescription)\\n external\\n pure\\n returns (bytes memory);\\n\\n /// Parses a string of TOML data at `key` and coerces it to type corresponding to `typeDescription`.\\n function parseTomlType(string calldata toml, string calldata key, string calldata typeDescription)\\n external\\n pure\\n returns (bytes memory);\\n\\n /// Parses a string of TOML data at `key` and coerces it to `uint256`.\\n function parseTomlUint(string calldata toml, string calldata key) external pure returns (uint256);\\n\\n /// Parses a string of TOML data at `key` and coerces it to `uint256[]`.\\n function parseTomlUintArray(string calldata toml, string calldata key) external pure returns (uint256[] memory);\\n\\n /// ABI-encodes a TOML table.\\n function parseToml(string calldata toml) external pure returns (bytes memory abiEncodedData);\\n\\n /// ABI-encodes a TOML table at `key`.\\n function parseToml(string calldata toml, string calldata key) external pure returns (bytes memory abiEncodedData);\\n\\n /// Takes serialized JSON, converts to TOML and write a serialized TOML to a file.\\n function writeToml(string calldata json, string calldata path) external;\\n\\n /// Takes serialized JSON, converts to TOML and write a serialized TOML table to an **existing** TOML file, replacing a value with key = \\n /// This is useful to replace a specific value of a TOML file, without having to parse the entire thing.\\n function writeToml(string calldata json, string calldata path, string calldata valueKey) external;\\n\\n // ======== Utilities ========\\n\\n /// Compute the address of a contract created with CREATE2 using the given CREATE2 deployer.\\n function computeCreate2Address(bytes32 salt, bytes32 initCodeHash, address deployer)\\n external\\n pure\\n returns (address);\\n\\n /// Compute the address of a contract created with CREATE2 using the default CREATE2 deployer.\\n function computeCreate2Address(bytes32 salt, bytes32 initCodeHash) external pure returns (address);\\n\\n /// Compute the address a contract will be deployed at for a given deployer address and nonce.\\n function computeCreateAddress(address deployer, uint256 nonce) external pure returns (address);\\n\\n /// Utility cheatcode to copy storage of `from` contract to another `to` contract.\\n function copyStorage(address from, address to) external;\\n\\n /// Returns ENS namehash for provided string.\\n function ensNamehash(string calldata name) external pure returns (bytes32);\\n\\n /// Gets the label for the specified address.\\n function getLabel(address account) external view returns (string memory currentLabel);\\n\\n /// Labels an address in call traces.\\n function label(address account, string calldata newLabel) external;\\n\\n /// Pauses collection of call traces. Useful in cases when you want to skip tracing of\\n /// complex calls which are not useful for debugging.\\n function pauseTracing() external view;\\n\\n /// Returns a random `address`.\\n function randomAddress() external returns (address);\\n\\n /// Returns a random `bool`.\\n function randomBool() external view returns (bool);\\n\\n /// Returns a random byte array value of the given length.\\n function randomBytes(uint256 len) external view returns (bytes memory);\\n\\n /// Returns a random fixed-size byte array of length 4.\\n function randomBytes4() external view returns (bytes4);\\n\\n /// Returns a random fixed-size byte array of length 8.\\n function randomBytes8() external view returns (bytes8);\\n\\n /// Returns a random `int256` value.\\n function randomInt() external view returns (int256);\\n\\n /// Returns a random `int256` value of given bits.\\n function randomInt(uint256 bits) external view returns (int256);\\n\\n /// Returns a random uint256 value.\\n function randomUint() external returns (uint256);\\n\\n /// Returns random uint256 value between the provided range (=min..=max).\\n function randomUint(uint256 min, uint256 max) external returns (uint256);\\n\\n /// Returns a random `uint256` value of given bits.\\n function randomUint(uint256 bits) external view returns (uint256);\\n\\n /// Unpauses collection of call traces.\\n function resumeTracing() external view;\\n\\n /// Utility cheatcode to set arbitrary storage for given target address.\\n function setArbitraryStorage(address target) external;\\n\\n /// Encodes a `bytes` value to a base64url string.\\n function toBase64URL(bytes calldata data) external pure returns (string memory);\\n\\n /// Encodes a `string` value to a base64url string.\\n function toBase64URL(string calldata data) external pure returns (string memory);\\n\\n /// Encodes a `bytes` value to a base64 string.\\n function toBase64(bytes calldata data) external pure returns (string memory);\\n\\n /// Encodes a `string` value to a base64 string.\\n function toBase64(string calldata data) external pure returns (string memory);\\n}\\n\\n/// The `Vm` interface does allow manipulation of the EVM state. These are all intended to be used\\n/// in tests, but it is not recommended to use these cheats in scripts.\\ninterface Vm is VmSafe {\\n // ======== EVM ========\\n\\n /// Utility cheatcode to set an EIP-2930 access list for all subsequent transactions.\\n function accessList(AccessListItem[] calldata access) external;\\n\\n /// Returns the identifier of the currently active fork. Reverts if no fork is currently active.\\n function activeFork() external view returns (uint256 forkId);\\n\\n /// In forking mode, explicitly grant the given address cheatcode access.\\n function allowCheatcodes(address account) external;\\n\\n /// Sets `block.blobbasefee`\\n function blobBaseFee(uint256 newBlobBaseFee) external;\\n\\n /// Sets the blobhashes in the transaction.\\n /// Not available on EVM versions before Cancun.\\n /// If used on unsupported EVM versions it will revert.\\n function blobhashes(bytes32[] calldata hashes) external;\\n\\n /// Sets `block.chainid`.\\n function chainId(uint256 newChainId) external;\\n\\n /// Clears all mocked calls.\\n function clearMockedCalls() external;\\n\\n /// Clones a source account code, state, balance and nonce to a target account and updates in-memory EVM state.\\n function cloneAccount(address source, address target) external;\\n\\n /// Sets `block.coinbase`.\\n function coinbase(address newCoinbase) external;\\n\\n /// Marks the slots of an account and the account address as cold.\\n function cool(address target) external;\\n\\n /// Utility cheatcode to mark specific storage slot as cold, simulating no prior read.\\n function coolSlot(address target, bytes32 slot) external;\\n\\n /// Creates a new fork with the given endpoint and the _latest_ block and returns the identifier of the fork.\\n function createFork(string calldata urlOrAlias) external returns (uint256 forkId);\\n\\n /// Creates a new fork with the given endpoint and block and returns the identifier of the fork.\\n function createFork(string calldata urlOrAlias, uint256 blockNumber) external returns (uint256 forkId);\\n\\n /// Creates a new fork with the given endpoint and at the block the given transaction was mined in,\\n /// replays all transaction mined in the block before the transaction, and returns the identifier of the fork.\\n function createFork(string calldata urlOrAlias, bytes32 txHash) external returns (uint256 forkId);\\n\\n /// Creates and also selects a new fork with the given endpoint and the latest block and returns the identifier of the fork.\\n function createSelectFork(string calldata urlOrAlias) external returns (uint256 forkId);\\n\\n /// Creates and also selects a new fork with the given endpoint and block and returns the identifier of the fork.\\n function createSelectFork(string calldata urlOrAlias, uint256 blockNumber) external returns (uint256 forkId);\\n\\n /// Creates and also selects new fork with the given endpoint and at the block the given transaction was mined in,\\n /// replays all transaction mined in the block before the transaction, returns the identifier of the fork.\\n function createSelectFork(string calldata urlOrAlias, bytes32 txHash) external returns (uint256 forkId);\\n\\n /// Sets an address' balance.\\n function deal(address account, uint256 newBalance) external;\\n\\n /// Removes the snapshot with the given ID created by `snapshot`.\\n /// Takes the snapshot ID to delete.\\n /// Returns `true` if the snapshot was successfully deleted.\\n /// Returns `false` if the snapshot does not exist.\\n function deleteStateSnapshot(uint256 snapshotId) external returns (bool success);\\n\\n /// Removes _all_ snapshots previously created by `snapshot`.\\n function deleteStateSnapshots() external;\\n\\n /// Sets `block.difficulty`.\\n /// Not available on EVM versions from Paris onwards. Use `prevrandao` instead.\\n /// Reverts if used on unsupported EVM versions.\\n function difficulty(uint256 newDifficulty) external;\\n\\n /// Dump a genesis JSON file's `allocs` to disk.\\n function dumpState(string calldata pathToStateJson) external;\\n\\n /// Sets an address' code.\\n function etch(address target, bytes calldata newRuntimeBytecode) external;\\n\\n /// Sets `block.basefee`.\\n function fee(uint256 newBasefee) external;\\n\\n /// Gets the blockhashes from the current transaction.\\n /// Not available on EVM versions before Cancun.\\n /// If used on unsupported EVM versions it will revert.\\n function getBlobhashes() external view returns (bytes32[] memory hashes);\\n\\n /// Returns true if the account is marked as persistent.\\n function isPersistent(address account) external view returns (bool persistent);\\n\\n /// Load a genesis JSON file's `allocs` into the in-memory EVM state.\\n function loadAllocs(string calldata pathToAllocsJson) external;\\n\\n /// Marks that the account(s) should use persistent storage across fork swaps in a multifork setup\\n /// Meaning, changes made to the state of this account will be kept when switching forks.\\n function makePersistent(address account) external;\\n\\n /// See `makePersistent(address)`.\\n function makePersistent(address account0, address account1) external;\\n\\n /// See `makePersistent(address)`.\\n function makePersistent(address account0, address account1, address account2) external;\\n\\n /// See `makePersistent(address)`.\\n function makePersistent(address[] calldata accounts) external;\\n\\n /// Reverts a call to an address with specified revert data.\\n function mockCallRevert(address callee, bytes calldata data, bytes calldata revertData) external;\\n\\n /// Reverts a call to an address with a specific `msg.value`, with specified revert data.\\n function mockCallRevert(address callee, uint256 msgValue, bytes calldata data, bytes calldata revertData)\\n external;\\n\\n /// Reverts a call to an address with specified revert data.\\n /// Overload to pass the function selector directly `token.approve.selector` instead of `abi.encodeWithSelector(token.approve.selector)`.\\n function mockCallRevert(address callee, bytes4 data, bytes calldata revertData) external;\\n\\n /// Reverts a call to an address with a specific `msg.value`, with specified revert data.\\n /// Overload to pass the function selector directly `token.approve.selector` instead of `abi.encodeWithSelector(token.approve.selector)`.\\n function mockCallRevert(address callee, uint256 msgValue, bytes4 data, bytes calldata revertData) external;\\n\\n /// Mocks a call to an address, returning specified data.\\n /// Calldata can either be strict or a partial match, e.g. if you only\\n /// pass a Solidity selector to the expected calldata, then the entire Solidity\\n /// function will be mocked.\\n function mockCall(address callee, bytes calldata data, bytes calldata returnData) external;\\n\\n /// Mocks a call to an address with a specific `msg.value`, returning specified data.\\n /// Calldata match takes precedence over `msg.value` in case of ambiguity.\\n function mockCall(address callee, uint256 msgValue, bytes calldata data, bytes calldata returnData) external;\\n\\n /// Mocks a call to an address, returning specified data.\\n /// Calldata can either be strict or a partial match, e.g. if you only\\n /// pass a Solidity selector to the expected calldata, then the entire Solidity\\n /// function will be mocked.\\n /// Overload to pass the function selector directly `token.approve.selector` instead of `abi.encodeWithSelector(token.approve.selector)`.\\n function mockCall(address callee, bytes4 data, bytes calldata returnData) external;\\n\\n /// Mocks a call to an address with a specific `msg.value`, returning specified data.\\n /// Calldata match takes precedence over `msg.value` in case of ambiguity.\\n /// Overload to pass the function selector directly `token.approve.selector` instead of `abi.encodeWithSelector(token.approve.selector)`.\\n function mockCall(address callee, uint256 msgValue, bytes4 data, bytes calldata returnData) external;\\n\\n /// Mocks multiple calls to an address, returning specified data for each call.\\n function mockCalls(address callee, bytes calldata data, bytes[] calldata returnData) external;\\n\\n /// Mocks multiple calls to an address with a specific `msg.value`, returning specified data for each call.\\n function mockCalls(address callee, uint256 msgValue, bytes calldata data, bytes[] calldata returnData) external;\\n\\n /// Whenever a call is made to `callee` with calldata `data`, this cheatcode instead calls\\n /// `target` with the same calldata. This functionality is similar to a delegate call made to\\n /// `target` contract from `callee`.\\n /// Can be used to substitute a call to a function with another implementation that captures\\n /// the primary logic of the original function but is easier to reason about.\\n /// If calldata is not a strict match then partial match by selector is attempted.\\n function mockFunction(address callee, address target, bytes calldata data) external;\\n\\n /// Utility cheatcode to remove any EIP-2930 access list set by `accessList` cheatcode.\\n function noAccessList() external;\\n\\n /// Sets the *next* call's `msg.sender` to be the input address.\\n function prank(address msgSender) external;\\n\\n /// Sets the *next* call's `msg.sender` to be the input address, and the `tx.origin` to be the second input.\\n function prank(address msgSender, address txOrigin) external;\\n\\n /// Sets the *next* delegate call's `msg.sender` to be the input address.\\n function prank(address msgSender, bool delegateCall) external;\\n\\n /// Sets the *next* delegate call's `msg.sender` to be the input address, and the `tx.origin` to be the second input.\\n function prank(address msgSender, address txOrigin, bool delegateCall) external;\\n\\n /// Sets `block.prevrandao`.\\n /// Not available on EVM versions before Paris. Use `difficulty` instead.\\n /// If used on unsupported EVM versions it will revert.\\n function prevrandao(bytes32 newPrevrandao) external;\\n\\n /// Sets `block.prevrandao`.\\n /// Not available on EVM versions before Paris. Use `difficulty` instead.\\n /// If used on unsupported EVM versions it will revert.\\n function prevrandao(uint256 newPrevrandao) external;\\n\\n /// Reads the current `msg.sender` and `tx.origin` from state and reports if there is any active caller modification.\\n function readCallers() external returns (CallerMode callerMode, address msgSender, address txOrigin);\\n\\n /// Resets the nonce of an account to 0 for EOAs and 1 for contract accounts.\\n function resetNonce(address account) external;\\n\\n /// Revert the state of the EVM to a previous snapshot\\n /// Takes the snapshot ID to revert to.\\n /// Returns `true` if the snapshot was successfully reverted.\\n /// Returns `false` if the snapshot does not exist.\\n /// **Note:** This does not automatically delete the snapshot. To delete the snapshot use `deleteStateSnapshot`.\\n function revertToState(uint256 snapshotId) external returns (bool success);\\n\\n /// Revert the state of the EVM to a previous snapshot and automatically deletes the snapshots\\n /// Takes the snapshot ID to revert to.\\n /// Returns `true` if the snapshot was successfully reverted and deleted.\\n /// Returns `false` if the snapshot does not exist.\\n function revertToStateAndDelete(uint256 snapshotId) external returns (bool success);\\n\\n /// Revokes persistent status from the address, previously added via `makePersistent`.\\n function revokePersistent(address account) external;\\n\\n /// See `revokePersistent(address)`.\\n function revokePersistent(address[] calldata accounts) external;\\n\\n /// Sets `block.height`.\\n function roll(uint256 newHeight) external;\\n\\n /// Updates the currently active fork to given block number\\n /// This is similar to `roll` but for the currently active fork.\\n function rollFork(uint256 blockNumber) external;\\n\\n /// Updates the currently active fork to given transaction. This will `rollFork` with the number\\n /// of the block the transaction was mined in and replays all transaction mined before it in the block.\\n function rollFork(bytes32 txHash) external;\\n\\n /// Updates the given fork to given block number.\\n function rollFork(uint256 forkId, uint256 blockNumber) external;\\n\\n /// Updates the given fork to block number of the given transaction and replays all transaction mined before it in the block.\\n function rollFork(uint256 forkId, bytes32 txHash) external;\\n\\n /// Takes a fork identifier created by `createFork` and sets the corresponding forked state as active.\\n function selectFork(uint256 forkId) external;\\n\\n /// Set blockhash for the current block.\\n /// It only sets the blockhash for blocks where `block.number - 256 <= number < block.number`.\\n function setBlockhash(uint256 blockNumber, bytes32 blockHash) external;\\n\\n /// Sets the nonce of an account. Must be higher than the current nonce of the account.\\n function setNonce(address account, uint64 newNonce) external;\\n\\n /// Sets the nonce of an account to an arbitrary value.\\n function setNonceUnsafe(address account, uint64 newNonce) external;\\n\\n /// Snapshot capture the gas usage of the last call by name from the callee perspective.\\n function snapshotGasLastCall(string calldata name) external returns (uint256 gasUsed);\\n\\n /// Snapshot capture the gas usage of the last call by name in a group from the callee perspective.\\n function snapshotGasLastCall(string calldata group, string calldata name) external returns (uint256 gasUsed);\\n\\n /// Snapshot the current state of the evm.\\n /// Returns the ID of the snapshot that was created.\\n /// To revert a snapshot use `revertToState`.\\n function snapshotState() external returns (uint256 snapshotId);\\n\\n /// Snapshot capture an arbitrary numerical value by name.\\n /// The group name is derived from the contract name.\\n function snapshotValue(string calldata name, uint256 value) external;\\n\\n /// Snapshot capture an arbitrary numerical value by name in a group.\\n function snapshotValue(string calldata group, string calldata name, uint256 value) external;\\n\\n /// Sets all subsequent calls' `msg.sender` to be the input address until `stopPrank` is called.\\n function startPrank(address msgSender) external;\\n\\n /// Sets all subsequent calls' `msg.sender` to be the input address until `stopPrank` is called, and the `tx.origin` to be the second input.\\n function startPrank(address msgSender, address txOrigin) external;\\n\\n /// Sets all subsequent delegate calls' `msg.sender` to be the input address until `stopPrank` is called.\\n function startPrank(address msgSender, bool delegateCall) external;\\n\\n /// Sets all subsequent delegate calls' `msg.sender` to be the input address until `stopPrank` is called, and the `tx.origin` to be the second input.\\n function startPrank(address msgSender, address txOrigin, bool delegateCall) external;\\n\\n /// Start a snapshot capture of the current gas usage by name.\\n /// The group name is derived from the contract name.\\n function startSnapshotGas(string calldata name) external;\\n\\n /// Start a snapshot capture of the current gas usage by name in a group.\\n function startSnapshotGas(string calldata group, string calldata name) external;\\n\\n /// Resets subsequent calls' `msg.sender` to be `address(this)`.\\n function stopPrank() external;\\n\\n /// Stop the snapshot capture of the current gas by latest snapshot name, capturing the gas used since the start.\\n function stopSnapshotGas() external returns (uint256 gasUsed);\\n\\n /// Stop the snapshot capture of the current gas usage by name, capturing the gas used since the start.\\n /// The group name is derived from the contract name.\\n function stopSnapshotGas(string calldata name) external returns (uint256 gasUsed);\\n\\n /// Stop the snapshot capture of the current gas usage by name in a group, capturing the gas used since the start.\\n function stopSnapshotGas(string calldata group, string calldata name) external returns (uint256 gasUsed);\\n\\n /// Stores a value to an address' storage slot.\\n function store(address target, bytes32 slot, bytes32 value) external;\\n\\n /// Fetches the given transaction from the active fork and executes it on the current state.\\n function transact(bytes32 txHash) external;\\n\\n /// Fetches the given transaction from the given fork and executes it on the current state.\\n function transact(uint256 forkId, bytes32 txHash) external;\\n\\n /// Sets `tx.gasprice`.\\n function txGasPrice(uint256 newGasPrice) external;\\n\\n /// Utility cheatcode to mark specific storage slot as warm, simulating a prior read.\\n function warmSlot(address target, bytes32 slot) external;\\n\\n /// Sets `block.timestamp`.\\n function warp(uint256 newTimestamp) external;\\n\\n /// `deleteSnapshot` is being deprecated in favor of `deleteStateSnapshot`. It will be removed in future versions.\\n function deleteSnapshot(uint256 snapshotId) external returns (bool success);\\n\\n /// `deleteSnapshots` is being deprecated in favor of `deleteStateSnapshots`. It will be removed in future versions.\\n function deleteSnapshots() external;\\n\\n /// `revertToAndDelete` is being deprecated in favor of `revertToStateAndDelete`. It will be removed in future versions.\\n function revertToAndDelete(uint256 snapshotId) external returns (bool success);\\n\\n /// `revertTo` is being deprecated in favor of `revertToState`. It will be removed in future versions.\\n function revertTo(uint256 snapshotId) external returns (bool success);\\n\\n /// `snapshot` is being deprecated in favor of `snapshotState`. It will be removed in future versions.\\n function snapshot() external returns (uint256 snapshotId);\\n\\n // ======== Testing ========\\n\\n /// Expect a call to an address with the specified `msg.value` and calldata, and a *minimum* amount of gas.\\n function expectCallMinGas(address callee, uint256 msgValue, uint64 minGas, bytes calldata data) external;\\n\\n /// Expect given number of calls to an address with the specified `msg.value` and calldata, and a *minimum* amount of gas.\\n function expectCallMinGas(address callee, uint256 msgValue, uint64 minGas, bytes calldata data, uint64 count)\\n external;\\n\\n /// Expects a call to an address with the specified calldata.\\n /// Calldata can either be a strict or a partial match.\\n function expectCall(address callee, bytes calldata data) external;\\n\\n /// Expects given number of calls to an address with the specified calldata.\\n function expectCall(address callee, bytes calldata data, uint64 count) external;\\n\\n /// Expects a call to an address with the specified `msg.value` and calldata.\\n function expectCall(address callee, uint256 msgValue, bytes calldata data) external;\\n\\n /// Expects given number of calls to an address with the specified `msg.value` and calldata.\\n function expectCall(address callee, uint256 msgValue, bytes calldata data, uint64 count) external;\\n\\n /// Expect a call to an address with the specified `msg.value`, gas, and calldata.\\n function expectCall(address callee, uint256 msgValue, uint64 gas, bytes calldata data) external;\\n\\n /// Expects given number of calls to an address with the specified `msg.value`, gas, and calldata.\\n function expectCall(address callee, uint256 msgValue, uint64 gas, bytes calldata data, uint64 count) external;\\n\\n /// Expects the deployment of the specified bytecode by the specified address using the CREATE opcode\\n function expectCreate(bytes calldata bytecode, address deployer) external;\\n\\n /// Expects the deployment of the specified bytecode by the specified address using the CREATE2 opcode\\n function expectCreate2(bytes calldata bytecode, address deployer) external;\\n\\n /// Prepare an expected anonymous log with (bool checkTopic1, bool checkTopic2, bool checkTopic3, bool checkData.).\\n /// Call this function, then emit an anonymous event, then call a function. Internally after the call, we check if\\n /// logs were emitted in the expected order with the expected topics and data (as specified by the booleans).\\n function expectEmitAnonymous(bool checkTopic0, bool checkTopic1, bool checkTopic2, bool checkTopic3, bool checkData)\\n external;\\n\\n /// Same as the previous method, but also checks supplied address against emitting contract.\\n function expectEmitAnonymous(\\n bool checkTopic0,\\n bool checkTopic1,\\n bool checkTopic2,\\n bool checkTopic3,\\n bool checkData,\\n address emitter\\n ) external;\\n\\n /// Prepare an expected anonymous log with all topic and data checks enabled.\\n /// Call this function, then emit an anonymous event, then call a function. Internally after the call, we check if\\n /// logs were emitted in the expected order with the expected topics and data.\\n function expectEmitAnonymous() external;\\n\\n /// Same as the previous method, but also checks supplied address against emitting contract.\\n function expectEmitAnonymous(address emitter) external;\\n\\n /// Prepare an expected log with (bool checkTopic1, bool checkTopic2, bool checkTopic3, bool checkData.).\\n /// Call this function, then emit an event, then call a function. Internally after the call, we check if\\n /// logs were emitted in the expected order with the expected topics and data (as specified by the booleans).\\n function expectEmit(bool checkTopic1, bool checkTopic2, bool checkTopic3, bool checkData) external;\\n\\n /// Same as the previous method, but also checks supplied address against emitting contract.\\n function expectEmit(bool checkTopic1, bool checkTopic2, bool checkTopic3, bool checkData, address emitter)\\n external;\\n\\n /// Prepare an expected log with all topic and data checks enabled.\\n /// Call this function, then emit an event, then call a function. Internally after the call, we check if\\n /// logs were emitted in the expected order with the expected topics and data.\\n function expectEmit() external;\\n\\n /// Same as the previous method, but also checks supplied address against emitting contract.\\n function expectEmit(address emitter) external;\\n\\n /// Expect a given number of logs with the provided topics.\\n function expectEmit(bool checkTopic1, bool checkTopic2, bool checkTopic3, bool checkData, uint64 count) external;\\n\\n /// Expect a given number of logs from a specific emitter with the provided topics.\\n function expectEmit(\\n bool checkTopic1,\\n bool checkTopic2,\\n bool checkTopic3,\\n bool checkData,\\n address emitter,\\n uint64 count\\n ) external;\\n\\n /// Expect a given number of logs with all topic and data checks enabled.\\n function expectEmit(uint64 count) external;\\n\\n /// Expect a given number of logs from a specific emitter with all topic and data checks enabled.\\n function expectEmit(address emitter, uint64 count) external;\\n\\n /// Expects an error on next call that starts with the revert data.\\n function expectPartialRevert(bytes4 revertData) external;\\n\\n /// Expects an error on next call to reverter address, that starts with the revert data.\\n function expectPartialRevert(bytes4 revertData, address reverter) external;\\n\\n /// Expects an error on next call with any revert data.\\n function expectRevert() external;\\n\\n /// Expects an error on next call that exactly matches the revert data.\\n function expectRevert(bytes4 revertData) external;\\n\\n /// Expects a `count` number of reverts from the upcoming calls from the reverter address that match the revert data.\\n function expectRevert(bytes4 revertData, address reverter, uint64 count) external;\\n\\n /// Expects a `count` number of reverts from the upcoming calls from the reverter address that exactly match the revert data.\\n function expectRevert(bytes calldata revertData, address reverter, uint64 count) external;\\n\\n /// Expects an error on next call that exactly matches the revert data.\\n function expectRevert(bytes calldata revertData) external;\\n\\n /// Expects an error with any revert data on next call to reverter address.\\n function expectRevert(address reverter) external;\\n\\n /// Expects an error from reverter address on next call, with any revert data.\\n function expectRevert(bytes4 revertData, address reverter) external;\\n\\n /// Expects an error from reverter address on next call, that exactly matches the revert data.\\n function expectRevert(bytes calldata revertData, address reverter) external;\\n\\n /// Expects a `count` number of reverts from the upcoming calls with any revert data or reverter.\\n function expectRevert(uint64 count) external;\\n\\n /// Expects a `count` number of reverts from the upcoming calls that match the revert data.\\n function expectRevert(bytes4 revertData, uint64 count) external;\\n\\n /// Expects a `count` number of reverts from the upcoming calls that exactly match the revert data.\\n function expectRevert(bytes calldata revertData, uint64 count) external;\\n\\n /// Expects a `count` number of reverts from the upcoming calls from the reverter address.\\n function expectRevert(address reverter, uint64 count) external;\\n\\n /// Only allows memory writes to offsets [0x00, 0x60) \\u222a [min, max) in the current subcontext. If any other\\n /// memory is written to, the test will fail. Can be called multiple times to add more ranges to the set.\\n function expectSafeMemory(uint64 min, uint64 max) external;\\n\\n /// Only allows memory writes to offsets [0x00, 0x60) \\u222a [min, max) in the next created subcontext.\\n /// If any other memory is written to, the test will fail. Can be called multiple times to add more ranges\\n /// to the set.\\n function expectSafeMemoryCall(uint64 min, uint64 max) external;\\n\\n /// Marks a test as skipped. Must be called at the top level of a test.\\n function skip(bool skipTest) external;\\n\\n /// Marks a test as skipped with a reason. Must be called at the top level of a test.\\n function skip(bool skipTest, string calldata reason) external;\\n\\n /// Stops all safe memory expectation in the current subcontext.\\n function stopExpectSafeMemory() external;\\n}\\n\",\"keccak256\":\"0xd91fb0df409fbd22463e937b48b9682d9333c5d4528d8fe7b36102a0323c44bf\",\"license\":\"MIT OR Apache-2.0\"},\"lib/forge-std/src/console.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity >=0.4.22 <0.9.0;\\n\\nlibrary console {\\n address constant CONSOLE_ADDRESS =\\n 0x000000000000000000636F6e736F6c652e6c6f67;\\n\\n function _sendLogPayloadImplementation(bytes memory payload) internal view {\\n address consoleAddress = CONSOLE_ADDRESS;\\n /// @solidity memory-safe-assembly\\n assembly {\\n pop(\\n staticcall(\\n gas(),\\n consoleAddress,\\n add(payload, 32),\\n mload(payload),\\n 0,\\n 0\\n )\\n )\\n }\\n }\\n\\n function _castToPure(\\n function(bytes memory) internal view fnIn\\n ) internal pure returns (function(bytes memory) pure fnOut) {\\n assembly {\\n fnOut := fnIn\\n }\\n }\\n\\n function _sendLogPayload(bytes memory payload) internal pure {\\n _castToPure(_sendLogPayloadImplementation)(payload);\\n }\\n\\n function log() internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log()\\\"));\\n }\\n\\n function logInt(int256 p0) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(int256)\\\", p0));\\n }\\n\\n function logUint(uint256 p0) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256)\\\", p0));\\n }\\n\\n function logString(string memory p0) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string)\\\", p0));\\n }\\n\\n function logBool(bool p0) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool)\\\", p0));\\n }\\n\\n function logAddress(address p0) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address)\\\", p0));\\n }\\n\\n function logBytes(bytes memory p0) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bytes)\\\", p0));\\n }\\n\\n function logBytes1(bytes1 p0) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bytes1)\\\", p0));\\n }\\n\\n function logBytes2(bytes2 p0) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bytes2)\\\", p0));\\n }\\n\\n function logBytes3(bytes3 p0) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bytes3)\\\", p0));\\n }\\n\\n function logBytes4(bytes4 p0) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bytes4)\\\", p0));\\n }\\n\\n function logBytes5(bytes5 p0) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bytes5)\\\", p0));\\n }\\n\\n function logBytes6(bytes6 p0) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bytes6)\\\", p0));\\n }\\n\\n function logBytes7(bytes7 p0) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bytes7)\\\", p0));\\n }\\n\\n function logBytes8(bytes8 p0) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bytes8)\\\", p0));\\n }\\n\\n function logBytes9(bytes9 p0) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bytes9)\\\", p0));\\n }\\n\\n function logBytes10(bytes10 p0) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bytes10)\\\", p0));\\n }\\n\\n function logBytes11(bytes11 p0) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bytes11)\\\", p0));\\n }\\n\\n function logBytes12(bytes12 p0) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bytes12)\\\", p0));\\n }\\n\\n function logBytes13(bytes13 p0) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bytes13)\\\", p0));\\n }\\n\\n function logBytes14(bytes14 p0) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bytes14)\\\", p0));\\n }\\n\\n function logBytes15(bytes15 p0) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bytes15)\\\", p0));\\n }\\n\\n function logBytes16(bytes16 p0) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bytes16)\\\", p0));\\n }\\n\\n function logBytes17(bytes17 p0) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bytes17)\\\", p0));\\n }\\n\\n function logBytes18(bytes18 p0) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bytes18)\\\", p0));\\n }\\n\\n function logBytes19(bytes19 p0) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bytes19)\\\", p0));\\n }\\n\\n function logBytes20(bytes20 p0) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bytes20)\\\", p0));\\n }\\n\\n function logBytes21(bytes21 p0) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bytes21)\\\", p0));\\n }\\n\\n function logBytes22(bytes22 p0) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bytes22)\\\", p0));\\n }\\n\\n function logBytes23(bytes23 p0) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bytes23)\\\", p0));\\n }\\n\\n function logBytes24(bytes24 p0) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bytes24)\\\", p0));\\n }\\n\\n function logBytes25(bytes25 p0) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bytes25)\\\", p0));\\n }\\n\\n function logBytes26(bytes26 p0) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bytes26)\\\", p0));\\n }\\n\\n function logBytes27(bytes27 p0) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bytes27)\\\", p0));\\n }\\n\\n function logBytes28(bytes28 p0) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bytes28)\\\", p0));\\n }\\n\\n function logBytes29(bytes29 p0) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bytes29)\\\", p0));\\n }\\n\\n function logBytes30(bytes30 p0) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bytes30)\\\", p0));\\n }\\n\\n function logBytes31(bytes31 p0) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bytes31)\\\", p0));\\n }\\n\\n function logBytes32(bytes32 p0) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bytes32)\\\", p0));\\n }\\n\\n function log(uint256 p0) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256)\\\", p0));\\n }\\n\\n function log(int256 p0) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(int256)\\\", p0));\\n }\\n\\n function log(string memory p0) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string)\\\", p0));\\n }\\n\\n function log(bool p0) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool)\\\", p0));\\n }\\n\\n function log(address p0) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address)\\\", p0));\\n }\\n\\n function log(uint256 p0, uint256 p1) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,uint256)\\\", p0, p1));\\n }\\n\\n function log(uint256 p0, string memory p1) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,string)\\\", p0, p1));\\n }\\n\\n function log(uint256 p0, bool p1) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,bool)\\\", p0, p1));\\n }\\n\\n function log(uint256 p0, address p1) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,address)\\\", p0, p1));\\n }\\n\\n function log(string memory p0, uint256 p1) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,uint256)\\\", p0, p1));\\n }\\n\\n function log(string memory p0, int256 p1) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,int256)\\\", p0, p1));\\n }\\n\\n function log(string memory p0, string memory p1) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,string)\\\", p0, p1));\\n }\\n\\n function log(string memory p0, bool p1) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,bool)\\\", p0, p1));\\n }\\n\\n function log(string memory p0, address p1) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,address)\\\", p0, p1));\\n }\\n\\n function log(bool p0, uint256 p1) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,uint256)\\\", p0, p1));\\n }\\n\\n function log(bool p0, string memory p1) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,string)\\\", p0, p1));\\n }\\n\\n function log(bool p0, bool p1) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,bool)\\\", p0, p1));\\n }\\n\\n function log(bool p0, address p1) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,address)\\\", p0, p1));\\n }\\n\\n function log(address p0, uint256 p1) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,uint256)\\\", p0, p1));\\n }\\n\\n function log(address p0, string memory p1) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,string)\\\", p0, p1));\\n }\\n\\n function log(address p0, bool p1) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,bool)\\\", p0, p1));\\n }\\n\\n function log(address p0, address p1) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,address)\\\", p0, p1));\\n }\\n\\n function log(uint256 p0, uint256 p1, uint256 p2) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,uint256,uint256)\\\", p0, p1, p2));\\n }\\n\\n function log(uint256 p0, uint256 p1, string memory p2) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,uint256,string)\\\", p0, p1, p2));\\n }\\n\\n function log(uint256 p0, uint256 p1, bool p2) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,uint256,bool)\\\", p0, p1, p2));\\n }\\n\\n function log(uint256 p0, uint256 p1, address p2) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,uint256,address)\\\", p0, p1, p2));\\n }\\n\\n function log(uint256 p0, string memory p1, uint256 p2) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,string,uint256)\\\", p0, p1, p2));\\n }\\n\\n function log(uint256 p0, string memory p1, string memory p2) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,string,string)\\\", p0, p1, p2));\\n }\\n\\n function log(uint256 p0, string memory p1, bool p2) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,string,bool)\\\", p0, p1, p2));\\n }\\n\\n function log(uint256 p0, string memory p1, address p2) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,string,address)\\\", p0, p1, p2));\\n }\\n\\n function log(uint256 p0, bool p1, uint256 p2) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,bool,uint256)\\\", p0, p1, p2));\\n }\\n\\n function log(uint256 p0, bool p1, string memory p2) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,bool,string)\\\", p0, p1, p2));\\n }\\n\\n function log(uint256 p0, bool p1, bool p2) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,bool,bool)\\\", p0, p1, p2));\\n }\\n\\n function log(uint256 p0, bool p1, address p2) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,bool,address)\\\", p0, p1, p2));\\n }\\n\\n function log(uint256 p0, address p1, uint256 p2) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,address,uint256)\\\", p0, p1, p2));\\n }\\n\\n function log(uint256 p0, address p1, string memory p2) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,address,string)\\\", p0, p1, p2));\\n }\\n\\n function log(uint256 p0, address p1, bool p2) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,address,bool)\\\", p0, p1, p2));\\n }\\n\\n function log(uint256 p0, address p1, address p2) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,address,address)\\\", p0, p1, p2));\\n }\\n\\n function log(string memory p0, uint256 p1, uint256 p2) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,uint256,uint256)\\\", p0, p1, p2));\\n }\\n\\n function log(string memory p0, uint256 p1, string memory p2) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,uint256,string)\\\", p0, p1, p2));\\n }\\n\\n function log(string memory p0, uint256 p1, bool p2) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,uint256,bool)\\\", p0, p1, p2));\\n }\\n\\n function log(string memory p0, uint256 p1, address p2) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,uint256,address)\\\", p0, p1, p2));\\n }\\n\\n function log(string memory p0, string memory p1, uint256 p2) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,string,uint256)\\\", p0, p1, p2));\\n }\\n\\n function log(string memory p0, string memory p1, string memory p2) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,string,string)\\\", p0, p1, p2));\\n }\\n\\n function log(string memory p0, string memory p1, bool p2) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,string,bool)\\\", p0, p1, p2));\\n }\\n\\n function log(string memory p0, string memory p1, address p2) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,string,address)\\\", p0, p1, p2));\\n }\\n\\n function log(string memory p0, bool p1, uint256 p2) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,bool,uint256)\\\", p0, p1, p2));\\n }\\n\\n function log(string memory p0, bool p1, string memory p2) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,bool,string)\\\", p0, p1, p2));\\n }\\n\\n function log(string memory p0, bool p1, bool p2) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,bool,bool)\\\", p0, p1, p2));\\n }\\n\\n function log(string memory p0, bool p1, address p2) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,bool,address)\\\", p0, p1, p2));\\n }\\n\\n function log(string memory p0, address p1, uint256 p2) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,address,uint256)\\\", p0, p1, p2));\\n }\\n\\n function log(string memory p0, address p1, string memory p2) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,address,string)\\\", p0, p1, p2));\\n }\\n\\n function log(string memory p0, address p1, bool p2) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,address,bool)\\\", p0, p1, p2));\\n }\\n\\n function log(string memory p0, address p1, address p2) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,address,address)\\\", p0, p1, p2));\\n }\\n\\n function log(bool p0, uint256 p1, uint256 p2) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,uint256,uint256)\\\", p0, p1, p2));\\n }\\n\\n function log(bool p0, uint256 p1, string memory p2) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,uint256,string)\\\", p0, p1, p2));\\n }\\n\\n function log(bool p0, uint256 p1, bool p2) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,uint256,bool)\\\", p0, p1, p2));\\n }\\n\\n function log(bool p0, uint256 p1, address p2) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,uint256,address)\\\", p0, p1, p2));\\n }\\n\\n function log(bool p0, string memory p1, uint256 p2) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,string,uint256)\\\", p0, p1, p2));\\n }\\n\\n function log(bool p0, string memory p1, string memory p2) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,string,string)\\\", p0, p1, p2));\\n }\\n\\n function log(bool p0, string memory p1, bool p2) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,string,bool)\\\", p0, p1, p2));\\n }\\n\\n function log(bool p0, string memory p1, address p2) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,string,address)\\\", p0, p1, p2));\\n }\\n\\n function log(bool p0, bool p1, uint256 p2) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,bool,uint256)\\\", p0, p1, p2));\\n }\\n\\n function log(bool p0, bool p1, string memory p2) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,bool,string)\\\", p0, p1, p2));\\n }\\n\\n function log(bool p0, bool p1, bool p2) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,bool,bool)\\\", p0, p1, p2));\\n }\\n\\n function log(bool p0, bool p1, address p2) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,bool,address)\\\", p0, p1, p2));\\n }\\n\\n function log(bool p0, address p1, uint256 p2) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,address,uint256)\\\", p0, p1, p2));\\n }\\n\\n function log(bool p0, address p1, string memory p2) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,address,string)\\\", p0, p1, p2));\\n }\\n\\n function log(bool p0, address p1, bool p2) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,address,bool)\\\", p0, p1, p2));\\n }\\n\\n function log(bool p0, address p1, address p2) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,address,address)\\\", p0, p1, p2));\\n }\\n\\n function log(address p0, uint256 p1, uint256 p2) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,uint256,uint256)\\\", p0, p1, p2));\\n }\\n\\n function log(address p0, uint256 p1, string memory p2) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,uint256,string)\\\", p0, p1, p2));\\n }\\n\\n function log(address p0, uint256 p1, bool p2) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,uint256,bool)\\\", p0, p1, p2));\\n }\\n\\n function log(address p0, uint256 p1, address p2) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,uint256,address)\\\", p0, p1, p2));\\n }\\n\\n function log(address p0, string memory p1, uint256 p2) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,string,uint256)\\\", p0, p1, p2));\\n }\\n\\n function log(address p0, string memory p1, string memory p2) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,string,string)\\\", p0, p1, p2));\\n }\\n\\n function log(address p0, string memory p1, bool p2) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,string,bool)\\\", p0, p1, p2));\\n }\\n\\n function log(address p0, string memory p1, address p2) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,string,address)\\\", p0, p1, p2));\\n }\\n\\n function log(address p0, bool p1, uint256 p2) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,bool,uint256)\\\", p0, p1, p2));\\n }\\n\\n function log(address p0, bool p1, string memory p2) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,bool,string)\\\", p0, p1, p2));\\n }\\n\\n function log(address p0, bool p1, bool p2) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,bool,bool)\\\", p0, p1, p2));\\n }\\n\\n function log(address p0, bool p1, address p2) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,bool,address)\\\", p0, p1, p2));\\n }\\n\\n function log(address p0, address p1, uint256 p2) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,address,uint256)\\\", p0, p1, p2));\\n }\\n\\n function log(address p0, address p1, string memory p2) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,address,string)\\\", p0, p1, p2));\\n }\\n\\n function log(address p0, address p1, bool p2) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,address,bool)\\\", p0, p1, p2));\\n }\\n\\n function log(address p0, address p1, address p2) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,address,address)\\\", p0, p1, p2));\\n }\\n\\n function log(uint256 p0, uint256 p1, uint256 p2, uint256 p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,uint256,uint256,uint256)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(uint256 p0, uint256 p1, uint256 p2, string memory p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,uint256,uint256,string)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(uint256 p0, uint256 p1, uint256 p2, bool p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,uint256,uint256,bool)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(uint256 p0, uint256 p1, uint256 p2, address p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,uint256,uint256,address)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(uint256 p0, uint256 p1, string memory p2, uint256 p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,uint256,string,uint256)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(uint256 p0, uint256 p1, string memory p2, string memory p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,uint256,string,string)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(uint256 p0, uint256 p1, string memory p2, bool p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,uint256,string,bool)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(uint256 p0, uint256 p1, string memory p2, address p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,uint256,string,address)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(uint256 p0, uint256 p1, bool p2, uint256 p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,uint256,bool,uint256)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(uint256 p0, uint256 p1, bool p2, string memory p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,uint256,bool,string)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(uint256 p0, uint256 p1, bool p2, bool p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,uint256,bool,bool)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(uint256 p0, uint256 p1, bool p2, address p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,uint256,bool,address)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(uint256 p0, uint256 p1, address p2, uint256 p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,uint256,address,uint256)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(uint256 p0, uint256 p1, address p2, string memory p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,uint256,address,string)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(uint256 p0, uint256 p1, address p2, bool p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,uint256,address,bool)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(uint256 p0, uint256 p1, address p2, address p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,uint256,address,address)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(uint256 p0, string memory p1, uint256 p2, uint256 p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,string,uint256,uint256)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(uint256 p0, string memory p1, uint256 p2, string memory p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,string,uint256,string)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(uint256 p0, string memory p1, uint256 p2, bool p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,string,uint256,bool)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(uint256 p0, string memory p1, uint256 p2, address p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,string,uint256,address)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(uint256 p0, string memory p1, string memory p2, uint256 p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,string,string,uint256)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(uint256 p0, string memory p1, string memory p2, string memory p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,string,string,string)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(uint256 p0, string memory p1, string memory p2, bool p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,string,string,bool)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(uint256 p0, string memory p1, string memory p2, address p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,string,string,address)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(uint256 p0, string memory p1, bool p2, uint256 p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,string,bool,uint256)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(uint256 p0, string memory p1, bool p2, string memory p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,string,bool,string)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(uint256 p0, string memory p1, bool p2, bool p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,string,bool,bool)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(uint256 p0, string memory p1, bool p2, address p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,string,bool,address)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(uint256 p0, string memory p1, address p2, uint256 p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,string,address,uint256)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(uint256 p0, string memory p1, address p2, string memory p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,string,address,string)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(uint256 p0, string memory p1, address p2, bool p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,string,address,bool)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(uint256 p0, string memory p1, address p2, address p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,string,address,address)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(uint256 p0, bool p1, uint256 p2, uint256 p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,bool,uint256,uint256)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(uint256 p0, bool p1, uint256 p2, string memory p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,bool,uint256,string)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(uint256 p0, bool p1, uint256 p2, bool p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,bool,uint256,bool)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(uint256 p0, bool p1, uint256 p2, address p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,bool,uint256,address)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(uint256 p0, bool p1, string memory p2, uint256 p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,bool,string,uint256)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(uint256 p0, bool p1, string memory p2, string memory p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,bool,string,string)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(uint256 p0, bool p1, string memory p2, bool p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,bool,string,bool)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(uint256 p0, bool p1, string memory p2, address p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,bool,string,address)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(uint256 p0, bool p1, bool p2, uint256 p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,bool,bool,uint256)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(uint256 p0, bool p1, bool p2, string memory p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,bool,bool,string)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(uint256 p0, bool p1, bool p2, bool p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,bool,bool,bool)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(uint256 p0, bool p1, bool p2, address p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,bool,bool,address)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(uint256 p0, bool p1, address p2, uint256 p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,bool,address,uint256)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(uint256 p0, bool p1, address p2, string memory p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,bool,address,string)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(uint256 p0, bool p1, address p2, bool p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,bool,address,bool)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(uint256 p0, bool p1, address p2, address p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,bool,address,address)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(uint256 p0, address p1, uint256 p2, uint256 p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,address,uint256,uint256)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(uint256 p0, address p1, uint256 p2, string memory p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,address,uint256,string)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(uint256 p0, address p1, uint256 p2, bool p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,address,uint256,bool)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(uint256 p0, address p1, uint256 p2, address p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,address,uint256,address)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(uint256 p0, address p1, string memory p2, uint256 p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,address,string,uint256)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(uint256 p0, address p1, string memory p2, string memory p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,address,string,string)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(uint256 p0, address p1, string memory p2, bool p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,address,string,bool)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(uint256 p0, address p1, string memory p2, address p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,address,string,address)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(uint256 p0, address p1, bool p2, uint256 p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,address,bool,uint256)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(uint256 p0, address p1, bool p2, string memory p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,address,bool,string)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(uint256 p0, address p1, bool p2, bool p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,address,bool,bool)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(uint256 p0, address p1, bool p2, address p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,address,bool,address)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(uint256 p0, address p1, address p2, uint256 p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,address,address,uint256)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(uint256 p0, address p1, address p2, string memory p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,address,address,string)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(uint256 p0, address p1, address p2, bool p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,address,address,bool)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(uint256 p0, address p1, address p2, address p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(uint256,address,address,address)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(string memory p0, uint256 p1, uint256 p2, uint256 p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,uint256,uint256,uint256)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(string memory p0, uint256 p1, uint256 p2, string memory p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,uint256,uint256,string)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(string memory p0, uint256 p1, uint256 p2, bool p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,uint256,uint256,bool)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(string memory p0, uint256 p1, uint256 p2, address p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,uint256,uint256,address)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(string memory p0, uint256 p1, string memory p2, uint256 p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,uint256,string,uint256)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(string memory p0, uint256 p1, string memory p2, string memory p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,uint256,string,string)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(string memory p0, uint256 p1, string memory p2, bool p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,uint256,string,bool)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(string memory p0, uint256 p1, string memory p2, address p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,uint256,string,address)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(string memory p0, uint256 p1, bool p2, uint256 p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,uint256,bool,uint256)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(string memory p0, uint256 p1, bool p2, string memory p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,uint256,bool,string)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(string memory p0, uint256 p1, bool p2, bool p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,uint256,bool,bool)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(string memory p0, uint256 p1, bool p2, address p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,uint256,bool,address)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(string memory p0, uint256 p1, address p2, uint256 p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,uint256,address,uint256)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(string memory p0, uint256 p1, address p2, string memory p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,uint256,address,string)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(string memory p0, uint256 p1, address p2, bool p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,uint256,address,bool)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(string memory p0, uint256 p1, address p2, address p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,uint256,address,address)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(string memory p0, string memory p1, uint256 p2, uint256 p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,string,uint256,uint256)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(string memory p0, string memory p1, uint256 p2, string memory p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,string,uint256,string)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(string memory p0, string memory p1, uint256 p2, bool p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,string,uint256,bool)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(string memory p0, string memory p1, uint256 p2, address p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,string,uint256,address)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(string memory p0, string memory p1, string memory p2, uint256 p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,string,string,uint256)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(string memory p0, string memory p1, string memory p2, string memory p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,string,string,string)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(string memory p0, string memory p1, string memory p2, bool p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,string,string,bool)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(string memory p0, string memory p1, string memory p2, address p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,string,string,address)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(string memory p0, string memory p1, bool p2, uint256 p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,string,bool,uint256)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(string memory p0, string memory p1, bool p2, string memory p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,string,bool,string)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(string memory p0, string memory p1, bool p2, bool p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,string,bool,bool)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(string memory p0, string memory p1, bool p2, address p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,string,bool,address)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(string memory p0, string memory p1, address p2, uint256 p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,string,address,uint256)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(string memory p0, string memory p1, address p2, string memory p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,string,address,string)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(string memory p0, string memory p1, address p2, bool p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,string,address,bool)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(string memory p0, string memory p1, address p2, address p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,string,address,address)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(string memory p0, bool p1, uint256 p2, uint256 p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,bool,uint256,uint256)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(string memory p0, bool p1, uint256 p2, string memory p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,bool,uint256,string)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(string memory p0, bool p1, uint256 p2, bool p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,bool,uint256,bool)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(string memory p0, bool p1, uint256 p2, address p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,bool,uint256,address)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(string memory p0, bool p1, string memory p2, uint256 p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,bool,string,uint256)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(string memory p0, bool p1, string memory p2, string memory p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,bool,string,string)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(string memory p0, bool p1, string memory p2, bool p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,bool,string,bool)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(string memory p0, bool p1, string memory p2, address p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,bool,string,address)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(string memory p0, bool p1, bool p2, uint256 p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,bool,bool,uint256)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(string memory p0, bool p1, bool p2, string memory p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,bool,bool,string)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(string memory p0, bool p1, bool p2, bool p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,bool,bool,bool)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(string memory p0, bool p1, bool p2, address p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,bool,bool,address)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(string memory p0, bool p1, address p2, uint256 p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,bool,address,uint256)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(string memory p0, bool p1, address p2, string memory p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,bool,address,string)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(string memory p0, bool p1, address p2, bool p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,bool,address,bool)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(string memory p0, bool p1, address p2, address p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,bool,address,address)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(string memory p0, address p1, uint256 p2, uint256 p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,address,uint256,uint256)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(string memory p0, address p1, uint256 p2, string memory p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,address,uint256,string)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(string memory p0, address p1, uint256 p2, bool p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,address,uint256,bool)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(string memory p0, address p1, uint256 p2, address p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,address,uint256,address)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(string memory p0, address p1, string memory p2, uint256 p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,address,string,uint256)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(string memory p0, address p1, string memory p2, string memory p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,address,string,string)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(string memory p0, address p1, string memory p2, bool p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,address,string,bool)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(string memory p0, address p1, string memory p2, address p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,address,string,address)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(string memory p0, address p1, bool p2, uint256 p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,address,bool,uint256)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(string memory p0, address p1, bool p2, string memory p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,address,bool,string)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(string memory p0, address p1, bool p2, bool p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,address,bool,bool)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(string memory p0, address p1, bool p2, address p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,address,bool,address)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(string memory p0, address p1, address p2, uint256 p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,address,address,uint256)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(string memory p0, address p1, address p2, string memory p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,address,address,string)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(string memory p0, address p1, address p2, bool p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,address,address,bool)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(string memory p0, address p1, address p2, address p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(string,address,address,address)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(bool p0, uint256 p1, uint256 p2, uint256 p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,uint256,uint256,uint256)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(bool p0, uint256 p1, uint256 p2, string memory p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,uint256,uint256,string)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(bool p0, uint256 p1, uint256 p2, bool p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,uint256,uint256,bool)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(bool p0, uint256 p1, uint256 p2, address p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,uint256,uint256,address)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(bool p0, uint256 p1, string memory p2, uint256 p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,uint256,string,uint256)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(bool p0, uint256 p1, string memory p2, string memory p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,uint256,string,string)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(bool p0, uint256 p1, string memory p2, bool p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,uint256,string,bool)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(bool p0, uint256 p1, string memory p2, address p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,uint256,string,address)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(bool p0, uint256 p1, bool p2, uint256 p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,uint256,bool,uint256)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(bool p0, uint256 p1, bool p2, string memory p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,uint256,bool,string)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(bool p0, uint256 p1, bool p2, bool p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,uint256,bool,bool)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(bool p0, uint256 p1, bool p2, address p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,uint256,bool,address)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(bool p0, uint256 p1, address p2, uint256 p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,uint256,address,uint256)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(bool p0, uint256 p1, address p2, string memory p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,uint256,address,string)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(bool p0, uint256 p1, address p2, bool p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,uint256,address,bool)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(bool p0, uint256 p1, address p2, address p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,uint256,address,address)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(bool p0, string memory p1, uint256 p2, uint256 p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,string,uint256,uint256)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(bool p0, string memory p1, uint256 p2, string memory p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,string,uint256,string)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(bool p0, string memory p1, uint256 p2, bool p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,string,uint256,bool)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(bool p0, string memory p1, uint256 p2, address p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,string,uint256,address)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(bool p0, string memory p1, string memory p2, uint256 p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,string,string,uint256)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(bool p0, string memory p1, string memory p2, string memory p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,string,string,string)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(bool p0, string memory p1, string memory p2, bool p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,string,string,bool)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(bool p0, string memory p1, string memory p2, address p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,string,string,address)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(bool p0, string memory p1, bool p2, uint256 p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,string,bool,uint256)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(bool p0, string memory p1, bool p2, string memory p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,string,bool,string)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(bool p0, string memory p1, bool p2, bool p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,string,bool,bool)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(bool p0, string memory p1, bool p2, address p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,string,bool,address)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(bool p0, string memory p1, address p2, uint256 p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,string,address,uint256)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(bool p0, string memory p1, address p2, string memory p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,string,address,string)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(bool p0, string memory p1, address p2, bool p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,string,address,bool)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(bool p0, string memory p1, address p2, address p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,string,address,address)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(bool p0, bool p1, uint256 p2, uint256 p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,bool,uint256,uint256)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(bool p0, bool p1, uint256 p2, string memory p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,bool,uint256,string)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(bool p0, bool p1, uint256 p2, bool p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,bool,uint256,bool)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(bool p0, bool p1, uint256 p2, address p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,bool,uint256,address)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(bool p0, bool p1, string memory p2, uint256 p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,bool,string,uint256)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(bool p0, bool p1, string memory p2, string memory p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,bool,string,string)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(bool p0, bool p1, string memory p2, bool p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,bool,string,bool)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(bool p0, bool p1, string memory p2, address p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,bool,string,address)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(bool p0, bool p1, bool p2, uint256 p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,bool,bool,uint256)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(bool p0, bool p1, bool p2, string memory p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,bool,bool,string)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(bool p0, bool p1, bool p2, bool p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,bool,bool,bool)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(bool p0, bool p1, bool p2, address p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,bool,bool,address)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(bool p0, bool p1, address p2, uint256 p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,bool,address,uint256)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(bool p0, bool p1, address p2, string memory p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,bool,address,string)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(bool p0, bool p1, address p2, bool p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,bool,address,bool)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(bool p0, bool p1, address p2, address p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,bool,address,address)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(bool p0, address p1, uint256 p2, uint256 p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,address,uint256,uint256)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(bool p0, address p1, uint256 p2, string memory p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,address,uint256,string)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(bool p0, address p1, uint256 p2, bool p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,address,uint256,bool)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(bool p0, address p1, uint256 p2, address p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,address,uint256,address)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(bool p0, address p1, string memory p2, uint256 p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,address,string,uint256)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(bool p0, address p1, string memory p2, string memory p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,address,string,string)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(bool p0, address p1, string memory p2, bool p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,address,string,bool)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(bool p0, address p1, string memory p2, address p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,address,string,address)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(bool p0, address p1, bool p2, uint256 p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,address,bool,uint256)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(bool p0, address p1, bool p2, string memory p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,address,bool,string)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(bool p0, address p1, bool p2, bool p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,address,bool,bool)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(bool p0, address p1, bool p2, address p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,address,bool,address)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(bool p0, address p1, address p2, uint256 p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,address,address,uint256)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(bool p0, address p1, address p2, string memory p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,address,address,string)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(bool p0, address p1, address p2, bool p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,address,address,bool)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(bool p0, address p1, address p2, address p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(bool,address,address,address)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(address p0, uint256 p1, uint256 p2, uint256 p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,uint256,uint256,uint256)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(address p0, uint256 p1, uint256 p2, string memory p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,uint256,uint256,string)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(address p0, uint256 p1, uint256 p2, bool p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,uint256,uint256,bool)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(address p0, uint256 p1, uint256 p2, address p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,uint256,uint256,address)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(address p0, uint256 p1, string memory p2, uint256 p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,uint256,string,uint256)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(address p0, uint256 p1, string memory p2, string memory p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,uint256,string,string)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(address p0, uint256 p1, string memory p2, bool p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,uint256,string,bool)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(address p0, uint256 p1, string memory p2, address p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,uint256,string,address)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(address p0, uint256 p1, bool p2, uint256 p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,uint256,bool,uint256)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(address p0, uint256 p1, bool p2, string memory p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,uint256,bool,string)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(address p0, uint256 p1, bool p2, bool p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,uint256,bool,bool)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(address p0, uint256 p1, bool p2, address p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,uint256,bool,address)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(address p0, uint256 p1, address p2, uint256 p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,uint256,address,uint256)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(address p0, uint256 p1, address p2, string memory p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,uint256,address,string)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(address p0, uint256 p1, address p2, bool p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,uint256,address,bool)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(address p0, uint256 p1, address p2, address p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,uint256,address,address)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(address p0, string memory p1, uint256 p2, uint256 p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,string,uint256,uint256)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(address p0, string memory p1, uint256 p2, string memory p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,string,uint256,string)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(address p0, string memory p1, uint256 p2, bool p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,string,uint256,bool)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(address p0, string memory p1, uint256 p2, address p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,string,uint256,address)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(address p0, string memory p1, string memory p2, uint256 p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,string,string,uint256)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(address p0, string memory p1, string memory p2, string memory p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,string,string,string)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(address p0, string memory p1, string memory p2, bool p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,string,string,bool)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(address p0, string memory p1, string memory p2, address p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,string,string,address)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(address p0, string memory p1, bool p2, uint256 p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,string,bool,uint256)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(address p0, string memory p1, bool p2, string memory p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,string,bool,string)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(address p0, string memory p1, bool p2, bool p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,string,bool,bool)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(address p0, string memory p1, bool p2, address p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,string,bool,address)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(address p0, string memory p1, address p2, uint256 p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,string,address,uint256)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(address p0, string memory p1, address p2, string memory p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,string,address,string)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(address p0, string memory p1, address p2, bool p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,string,address,bool)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(address p0, string memory p1, address p2, address p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,string,address,address)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(address p0, bool p1, uint256 p2, uint256 p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,bool,uint256,uint256)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(address p0, bool p1, uint256 p2, string memory p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,bool,uint256,string)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(address p0, bool p1, uint256 p2, bool p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,bool,uint256,bool)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(address p0, bool p1, uint256 p2, address p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,bool,uint256,address)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(address p0, bool p1, string memory p2, uint256 p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,bool,string,uint256)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(address p0, bool p1, string memory p2, string memory p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,bool,string,string)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(address p0, bool p1, string memory p2, bool p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,bool,string,bool)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(address p0, bool p1, string memory p2, address p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,bool,string,address)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(address p0, bool p1, bool p2, uint256 p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,bool,bool,uint256)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(address p0, bool p1, bool p2, string memory p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,bool,bool,string)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(address p0, bool p1, bool p2, bool p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,bool,bool,bool)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(address p0, bool p1, bool p2, address p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,bool,bool,address)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(address p0, bool p1, address p2, uint256 p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,bool,address,uint256)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(address p0, bool p1, address p2, string memory p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,bool,address,string)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(address p0, bool p1, address p2, bool p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,bool,address,bool)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(address p0, bool p1, address p2, address p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,bool,address,address)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(address p0, address p1, uint256 p2, uint256 p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,address,uint256,uint256)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(address p0, address p1, uint256 p2, string memory p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,address,uint256,string)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(address p0, address p1, uint256 p2, bool p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,address,uint256,bool)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(address p0, address p1, uint256 p2, address p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,address,uint256,address)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(address p0, address p1, string memory p2, uint256 p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,address,string,uint256)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(address p0, address p1, string memory p2, string memory p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,address,string,string)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(address p0, address p1, string memory p2, bool p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,address,string,bool)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(address p0, address p1, string memory p2, address p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,address,string,address)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(address p0, address p1, bool p2, uint256 p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,address,bool,uint256)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(address p0, address p1, bool p2, string memory p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,address,bool,string)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(address p0, address p1, bool p2, bool p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,address,bool,bool)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(address p0, address p1, bool p2, address p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,address,bool,address)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(address p0, address p1, address p2, uint256 p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,address,address,uint256)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(address p0, address p1, address p2, string memory p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,address,address,string)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(address p0, address p1, address p2, bool p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,address,address,bool)\\\", p0, p1, p2, p3));\\n }\\n\\n function log(address p0, address p1, address p2, address p3) internal pure {\\n _sendLogPayload(abi.encodeWithSignature(\\\"log(address,address,address,address)\\\", p0, p1, p2, p3));\\n }\\n}\\n\",\"keccak256\":\"0x4bbf47eb762cef93729d6ef15e78789957147039b113e5d4df48e3d3fd16d0f5\",\"license\":\"MIT\"},\"lib/forge-std/src/console2.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity >=0.4.22 <0.9.0;\\n\\nimport {console as console2} from \\\"./console.sol\\\";\\n\",\"keccak256\":\"0x3b8fe79f48f065a4e4d35362171304a33784c3a90febae5f2787805a438de12f\",\"license\":\"MIT\"},\"lib/forge-std/src/interfaces/IMulticall3.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity >=0.6.2 <0.9.0;\\n\\npragma experimental ABIEncoderV2;\\n\\ninterface IMulticall3 {\\n struct Call {\\n address target;\\n bytes callData;\\n }\\n\\n struct Call3 {\\n address target;\\n bool allowFailure;\\n bytes callData;\\n }\\n\\n struct Call3Value {\\n address target;\\n bool allowFailure;\\n uint256 value;\\n bytes callData;\\n }\\n\\n struct Result {\\n bool success;\\n bytes returnData;\\n }\\n\\n function aggregate(Call[] calldata calls)\\n external\\n payable\\n returns (uint256 blockNumber, bytes[] memory returnData);\\n\\n function aggregate3(Call3[] calldata calls) external payable returns (Result[] memory returnData);\\n\\n function aggregate3Value(Call3Value[] calldata calls) external payable returns (Result[] memory returnData);\\n\\n function blockAndAggregate(Call[] calldata calls)\\n external\\n payable\\n returns (uint256 blockNumber, bytes32 blockHash, Result[] memory returnData);\\n\\n function getBasefee() external view returns (uint256 basefee);\\n\\n function getBlockHash(uint256 blockNumber) external view returns (bytes32 blockHash);\\n\\n function getBlockNumber() external view returns (uint256 blockNumber);\\n\\n function getChainId() external view returns (uint256 chainid);\\n\\n function getCurrentBlockCoinbase() external view returns (address coinbase);\\n\\n function getCurrentBlockDifficulty() external view returns (uint256 difficulty);\\n\\n function getCurrentBlockGasLimit() external view returns (uint256 gaslimit);\\n\\n function getCurrentBlockTimestamp() external view returns (uint256 timestamp);\\n\\n function getEthBalance(address addr) external view returns (uint256 balance);\\n\\n function getLastBlockHash() external view returns (bytes32 blockHash);\\n\\n function tryAggregate(bool requireSuccess, Call[] calldata calls)\\n external\\n payable\\n returns (Result[] memory returnData);\\n\\n function tryBlockAndAggregate(bool requireSuccess, Call[] calldata calls)\\n external\\n payable\\n returns (uint256 blockNumber, bytes32 blockHash, Result[] memory returnData);\\n}\\n\",\"keccak256\":\"0x7aac1389150499a922d1f9ef5749c908cef127cb2075b92fa17e9cb611263d0a\",\"license\":\"MIT\"},\"lib/forge-std/src/safeconsole.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity >=0.6.2 <0.9.0;\\n\\n/// @author philogy \\n/// @dev Code generated automatically by script.\\nlibrary safeconsole {\\n uint256 constant CONSOLE_ADDR = 0x000000000000000000000000000000000000000000636F6e736F6c652e6c6f67;\\n\\n // Credit to [0age](https://twitter.com/z0age/status/1654922202930888704) and [0xdapper](https://github.com/foundry-rs/forge-std/pull/374)\\n // for the view-to-pure log trick.\\n function _sendLogPayload(uint256 offset, uint256 size) private pure {\\n function(uint256, uint256) internal view fnIn = _sendLogPayloadView;\\n function(uint256, uint256) internal pure pureSendLogPayload;\\n /// @solidity memory-safe-assembly\\n assembly {\\n pureSendLogPayload := fnIn\\n }\\n pureSendLogPayload(offset, size);\\n }\\n\\n function _sendLogPayloadView(uint256 offset, uint256 size) private view {\\n /// @solidity memory-safe-assembly\\n assembly {\\n pop(staticcall(gas(), CONSOLE_ADDR, offset, size, 0x0, 0x0))\\n }\\n }\\n\\n function _memcopy(uint256 fromOffset, uint256 toOffset, uint256 length) private pure {\\n function(uint256, uint256, uint256) internal view fnIn = _memcopyView;\\n function(uint256, uint256, uint256) internal pure pureMemcopy;\\n /// @solidity memory-safe-assembly\\n assembly {\\n pureMemcopy := fnIn\\n }\\n pureMemcopy(fromOffset, toOffset, length);\\n }\\n\\n function _memcopyView(uint256 fromOffset, uint256 toOffset, uint256 length) private view {\\n /// @solidity memory-safe-assembly\\n assembly {\\n pop(staticcall(gas(), 0x4, fromOffset, length, toOffset, length))\\n }\\n }\\n\\n function logMemory(uint256 offset, uint256 length) internal pure {\\n if (offset >= 0x60) {\\n // Sufficient memory before slice to prepare call header.\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(sub(offset, 0x60))\\n m1 := mload(sub(offset, 0x40))\\n m2 := mload(sub(offset, 0x20))\\n // Selector of `log(bytes)`.\\n mstore(sub(offset, 0x60), 0x0be77f56)\\n mstore(sub(offset, 0x40), 0x20)\\n mstore(sub(offset, 0x20), length)\\n }\\n _sendLogPayload(offset - 0x44, length + 0x44);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(sub(offset, 0x60), m0)\\n mstore(sub(offset, 0x40), m1)\\n mstore(sub(offset, 0x20), m2)\\n }\\n } else {\\n // Insufficient space, so copy slice forward, add header and reverse.\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n uint256 endOffset = offset + length;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(add(endOffset, 0x00))\\n m1 := mload(add(endOffset, 0x20))\\n m2 := mload(add(endOffset, 0x40))\\n }\\n _memcopy(offset, offset + 0x60, length);\\n /// @solidity memory-safe-assembly\\n assembly {\\n // Selector of `log(bytes)`.\\n mstore(add(offset, 0x00), 0x0be77f56)\\n mstore(add(offset, 0x20), 0x20)\\n mstore(add(offset, 0x40), length)\\n }\\n _sendLogPayload(offset + 0x1c, length + 0x44);\\n _memcopy(offset + 0x60, offset, length);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(add(endOffset, 0x00), m0)\\n mstore(add(endOffset, 0x20), m1)\\n mstore(add(endOffset, 0x40), m2)\\n }\\n }\\n }\\n\\n function log(address p0) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n // Selector of `log(address)`.\\n mstore(0x00, 0x2c2ecbc2)\\n mstore(0x20, p0)\\n }\\n _sendLogPayload(0x1c, 0x24);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n }\\n }\\n\\n function log(bool p0) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n // Selector of `log(bool)`.\\n mstore(0x00, 0x32458eed)\\n mstore(0x20, p0)\\n }\\n _sendLogPayload(0x1c, 0x24);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n }\\n }\\n\\n function log(uint256 p0) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n // Selector of `log(uint256)`.\\n mstore(0x00, 0xf82c50f1)\\n mstore(0x20, p0)\\n }\\n _sendLogPayload(0x1c, 0x24);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n }\\n }\\n\\n function log(bytes32 p0) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n // Selector of `log(string)`.\\n mstore(0x00, 0x41304fac)\\n mstore(0x20, 0x20)\\n writeString(0x40, p0)\\n }\\n _sendLogPayload(0x1c, 0x64);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n }\\n }\\n\\n function log(address p0, address p1) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n // Selector of `log(address,address)`.\\n mstore(0x00, 0xdaf0d4aa)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n }\\n _sendLogPayload(0x1c, 0x44);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n }\\n }\\n\\n function log(address p0, bool p1) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n // Selector of `log(address,bool)`.\\n mstore(0x00, 0x75b605d3)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n }\\n _sendLogPayload(0x1c, 0x44);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n }\\n }\\n\\n function log(address p0, uint256 p1) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n // Selector of `log(address,uint256)`.\\n mstore(0x00, 0x8309e8a8)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n }\\n _sendLogPayload(0x1c, 0x44);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n }\\n }\\n\\n function log(address p0, bytes32 p1) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(address,string)`.\\n mstore(0x00, 0x759f86bb)\\n mstore(0x20, p0)\\n mstore(0x40, 0x40)\\n writeString(0x60, p1)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(bool p0, address p1) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n // Selector of `log(bool,address)`.\\n mstore(0x00, 0x853c4849)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n }\\n _sendLogPayload(0x1c, 0x44);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n }\\n }\\n\\n function log(bool p0, bool p1) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n // Selector of `log(bool,bool)`.\\n mstore(0x00, 0x2a110e83)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n }\\n _sendLogPayload(0x1c, 0x44);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n }\\n }\\n\\n function log(bool p0, uint256 p1) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n // Selector of `log(bool,uint256)`.\\n mstore(0x00, 0x399174d3)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n }\\n _sendLogPayload(0x1c, 0x44);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n }\\n }\\n\\n function log(bool p0, bytes32 p1) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(bool,string)`.\\n mstore(0x00, 0x8feac525)\\n mstore(0x20, p0)\\n mstore(0x40, 0x40)\\n writeString(0x60, p1)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(uint256 p0, address p1) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n // Selector of `log(uint256,address)`.\\n mstore(0x00, 0x69276c86)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n }\\n _sendLogPayload(0x1c, 0x44);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n }\\n }\\n\\n function log(uint256 p0, bool p1) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n // Selector of `log(uint256,bool)`.\\n mstore(0x00, 0x1c9d7eb3)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n }\\n _sendLogPayload(0x1c, 0x44);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n }\\n }\\n\\n function log(uint256 p0, uint256 p1) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n // Selector of `log(uint256,uint256)`.\\n mstore(0x00, 0xf666715a)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n }\\n _sendLogPayload(0x1c, 0x44);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n }\\n }\\n\\n function log(uint256 p0, bytes32 p1) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(uint256,string)`.\\n mstore(0x00, 0x643fd0df)\\n mstore(0x20, p0)\\n mstore(0x40, 0x40)\\n writeString(0x60, p1)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(bytes32 p0, address p1) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(string,address)`.\\n mstore(0x00, 0x319af333)\\n mstore(0x20, 0x40)\\n mstore(0x40, p1)\\n writeString(0x60, p0)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(bytes32 p0, bool p1) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(string,bool)`.\\n mstore(0x00, 0xc3b55635)\\n mstore(0x20, 0x40)\\n mstore(0x40, p1)\\n writeString(0x60, p0)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(bytes32 p0, uint256 p1) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(string,uint256)`.\\n mstore(0x00, 0xb60e72cc)\\n mstore(0x20, 0x40)\\n mstore(0x40, p1)\\n writeString(0x60, p0)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(bytes32 p0, bytes32 p1) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(string,string)`.\\n mstore(0x00, 0x4b5c4277)\\n mstore(0x20, 0x40)\\n mstore(0x40, 0x80)\\n writeString(0x60, p0)\\n writeString(0xa0, p1)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(address p0, address p1, address p2) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n // Selector of `log(address,address,address)`.\\n mstore(0x00, 0x018c84c2)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n }\\n _sendLogPayload(0x1c, 0x64);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n }\\n }\\n\\n function log(address p0, address p1, bool p2) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n // Selector of `log(address,address,bool)`.\\n mstore(0x00, 0xf2a66286)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n }\\n _sendLogPayload(0x1c, 0x64);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n }\\n }\\n\\n function log(address p0, address p1, uint256 p2) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n // Selector of `log(address,address,uint256)`.\\n mstore(0x00, 0x17fe6185)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n }\\n _sendLogPayload(0x1c, 0x64);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n }\\n }\\n\\n function log(address p0, address p1, bytes32 p2) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n // Selector of `log(address,address,string)`.\\n mstore(0x00, 0x007150be)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, 0x60)\\n writeString(0x80, p2)\\n }\\n _sendLogPayload(0x1c, 0xa4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n }\\n }\\n\\n function log(address p0, bool p1, address p2) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n // Selector of `log(address,bool,address)`.\\n mstore(0x00, 0xf11699ed)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n }\\n _sendLogPayload(0x1c, 0x64);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n }\\n }\\n\\n function log(address p0, bool p1, bool p2) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n // Selector of `log(address,bool,bool)`.\\n mstore(0x00, 0xeb830c92)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n }\\n _sendLogPayload(0x1c, 0x64);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n }\\n }\\n\\n function log(address p0, bool p1, uint256 p2) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n // Selector of `log(address,bool,uint256)`.\\n mstore(0x00, 0x9c4f99fb)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n }\\n _sendLogPayload(0x1c, 0x64);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n }\\n }\\n\\n function log(address p0, bool p1, bytes32 p2) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n // Selector of `log(address,bool,string)`.\\n mstore(0x00, 0x212255cc)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, 0x60)\\n writeString(0x80, p2)\\n }\\n _sendLogPayload(0x1c, 0xa4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n }\\n }\\n\\n function log(address p0, uint256 p1, address p2) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n // Selector of `log(address,uint256,address)`.\\n mstore(0x00, 0x7bc0d848)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n }\\n _sendLogPayload(0x1c, 0x64);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n }\\n }\\n\\n function log(address p0, uint256 p1, bool p2) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n // Selector of `log(address,uint256,bool)`.\\n mstore(0x00, 0x678209a8)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n }\\n _sendLogPayload(0x1c, 0x64);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n }\\n }\\n\\n function log(address p0, uint256 p1, uint256 p2) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n // Selector of `log(address,uint256,uint256)`.\\n mstore(0x00, 0xb69bcaf6)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n }\\n _sendLogPayload(0x1c, 0x64);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n }\\n }\\n\\n function log(address p0, uint256 p1, bytes32 p2) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n // Selector of `log(address,uint256,string)`.\\n mstore(0x00, 0xa1f2e8aa)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, 0x60)\\n writeString(0x80, p2)\\n }\\n _sendLogPayload(0x1c, 0xa4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n }\\n }\\n\\n function log(address p0, bytes32 p1, address p2) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n // Selector of `log(address,string,address)`.\\n mstore(0x00, 0xf08744e8)\\n mstore(0x20, p0)\\n mstore(0x40, 0x60)\\n mstore(0x60, p2)\\n writeString(0x80, p1)\\n }\\n _sendLogPayload(0x1c, 0xa4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n }\\n }\\n\\n function log(address p0, bytes32 p1, bool p2) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n // Selector of `log(address,string,bool)`.\\n mstore(0x00, 0xcf020fb1)\\n mstore(0x20, p0)\\n mstore(0x40, 0x60)\\n mstore(0x60, p2)\\n writeString(0x80, p1)\\n }\\n _sendLogPayload(0x1c, 0xa4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n }\\n }\\n\\n function log(address p0, bytes32 p1, uint256 p2) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n // Selector of `log(address,string,uint256)`.\\n mstore(0x00, 0x67dd6ff1)\\n mstore(0x20, p0)\\n mstore(0x40, 0x60)\\n mstore(0x60, p2)\\n writeString(0x80, p1)\\n }\\n _sendLogPayload(0x1c, 0xa4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n }\\n }\\n\\n function log(address p0, bytes32 p1, bytes32 p2) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n // Selector of `log(address,string,string)`.\\n mstore(0x00, 0xfb772265)\\n mstore(0x20, p0)\\n mstore(0x40, 0x60)\\n mstore(0x60, 0xa0)\\n writeString(0x80, p1)\\n writeString(0xc0, p2)\\n }\\n _sendLogPayload(0x1c, 0xe4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n }\\n }\\n\\n function log(bool p0, address p1, address p2) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n // Selector of `log(bool,address,address)`.\\n mstore(0x00, 0xd2763667)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n }\\n _sendLogPayload(0x1c, 0x64);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n }\\n }\\n\\n function log(bool p0, address p1, bool p2) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n // Selector of `log(bool,address,bool)`.\\n mstore(0x00, 0x18c9c746)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n }\\n _sendLogPayload(0x1c, 0x64);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n }\\n }\\n\\n function log(bool p0, address p1, uint256 p2) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n // Selector of `log(bool,address,uint256)`.\\n mstore(0x00, 0x5f7b9afb)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n }\\n _sendLogPayload(0x1c, 0x64);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n }\\n }\\n\\n function log(bool p0, address p1, bytes32 p2) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n // Selector of `log(bool,address,string)`.\\n mstore(0x00, 0xde9a9270)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, 0x60)\\n writeString(0x80, p2)\\n }\\n _sendLogPayload(0x1c, 0xa4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n }\\n }\\n\\n function log(bool p0, bool p1, address p2) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n // Selector of `log(bool,bool,address)`.\\n mstore(0x00, 0x1078f68d)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n }\\n _sendLogPayload(0x1c, 0x64);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n }\\n }\\n\\n function log(bool p0, bool p1, bool p2) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n // Selector of `log(bool,bool,bool)`.\\n mstore(0x00, 0x50709698)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n }\\n _sendLogPayload(0x1c, 0x64);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n }\\n }\\n\\n function log(bool p0, bool p1, uint256 p2) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n // Selector of `log(bool,bool,uint256)`.\\n mstore(0x00, 0x12f21602)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n }\\n _sendLogPayload(0x1c, 0x64);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n }\\n }\\n\\n function log(bool p0, bool p1, bytes32 p2) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n // Selector of `log(bool,bool,string)`.\\n mstore(0x00, 0x2555fa46)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, 0x60)\\n writeString(0x80, p2)\\n }\\n _sendLogPayload(0x1c, 0xa4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n }\\n }\\n\\n function log(bool p0, uint256 p1, address p2) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n // Selector of `log(bool,uint256,address)`.\\n mstore(0x00, 0x088ef9d2)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n }\\n _sendLogPayload(0x1c, 0x64);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n }\\n }\\n\\n function log(bool p0, uint256 p1, bool p2) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n // Selector of `log(bool,uint256,bool)`.\\n mstore(0x00, 0xe8defba9)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n }\\n _sendLogPayload(0x1c, 0x64);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n }\\n }\\n\\n function log(bool p0, uint256 p1, uint256 p2) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n // Selector of `log(bool,uint256,uint256)`.\\n mstore(0x00, 0x37103367)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n }\\n _sendLogPayload(0x1c, 0x64);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n }\\n }\\n\\n function log(bool p0, uint256 p1, bytes32 p2) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n // Selector of `log(bool,uint256,string)`.\\n mstore(0x00, 0xc3fc3970)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, 0x60)\\n writeString(0x80, p2)\\n }\\n _sendLogPayload(0x1c, 0xa4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n }\\n }\\n\\n function log(bool p0, bytes32 p1, address p2) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n // Selector of `log(bool,string,address)`.\\n mstore(0x00, 0x9591b953)\\n mstore(0x20, p0)\\n mstore(0x40, 0x60)\\n mstore(0x60, p2)\\n writeString(0x80, p1)\\n }\\n _sendLogPayload(0x1c, 0xa4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n }\\n }\\n\\n function log(bool p0, bytes32 p1, bool p2) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n // Selector of `log(bool,string,bool)`.\\n mstore(0x00, 0xdbb4c247)\\n mstore(0x20, p0)\\n mstore(0x40, 0x60)\\n mstore(0x60, p2)\\n writeString(0x80, p1)\\n }\\n _sendLogPayload(0x1c, 0xa4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n }\\n }\\n\\n function log(bool p0, bytes32 p1, uint256 p2) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n // Selector of `log(bool,string,uint256)`.\\n mstore(0x00, 0x1093ee11)\\n mstore(0x20, p0)\\n mstore(0x40, 0x60)\\n mstore(0x60, p2)\\n writeString(0x80, p1)\\n }\\n _sendLogPayload(0x1c, 0xa4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n }\\n }\\n\\n function log(bool p0, bytes32 p1, bytes32 p2) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n // Selector of `log(bool,string,string)`.\\n mstore(0x00, 0xb076847f)\\n mstore(0x20, p0)\\n mstore(0x40, 0x60)\\n mstore(0x60, 0xa0)\\n writeString(0x80, p1)\\n writeString(0xc0, p2)\\n }\\n _sendLogPayload(0x1c, 0xe4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n }\\n }\\n\\n function log(uint256 p0, address p1, address p2) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n // Selector of `log(uint256,address,address)`.\\n mstore(0x00, 0xbcfd9be0)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n }\\n _sendLogPayload(0x1c, 0x64);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n }\\n }\\n\\n function log(uint256 p0, address p1, bool p2) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n // Selector of `log(uint256,address,bool)`.\\n mstore(0x00, 0x9b6ec042)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n }\\n _sendLogPayload(0x1c, 0x64);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n }\\n }\\n\\n function log(uint256 p0, address p1, uint256 p2) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n // Selector of `log(uint256,address,uint256)`.\\n mstore(0x00, 0x5a9b5ed5)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n }\\n _sendLogPayload(0x1c, 0x64);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n }\\n }\\n\\n function log(uint256 p0, address p1, bytes32 p2) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n // Selector of `log(uint256,address,string)`.\\n mstore(0x00, 0x63cb41f9)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, 0x60)\\n writeString(0x80, p2)\\n }\\n _sendLogPayload(0x1c, 0xa4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n }\\n }\\n\\n function log(uint256 p0, bool p1, address p2) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n // Selector of `log(uint256,bool,address)`.\\n mstore(0x00, 0x35085f7b)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n }\\n _sendLogPayload(0x1c, 0x64);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n }\\n }\\n\\n function log(uint256 p0, bool p1, bool p2) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n // Selector of `log(uint256,bool,bool)`.\\n mstore(0x00, 0x20718650)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n }\\n _sendLogPayload(0x1c, 0x64);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n }\\n }\\n\\n function log(uint256 p0, bool p1, uint256 p2) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n // Selector of `log(uint256,bool,uint256)`.\\n mstore(0x00, 0x20098014)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n }\\n _sendLogPayload(0x1c, 0x64);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n }\\n }\\n\\n function log(uint256 p0, bool p1, bytes32 p2) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n // Selector of `log(uint256,bool,string)`.\\n mstore(0x00, 0x85775021)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, 0x60)\\n writeString(0x80, p2)\\n }\\n _sendLogPayload(0x1c, 0xa4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n }\\n }\\n\\n function log(uint256 p0, uint256 p1, address p2) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n // Selector of `log(uint256,uint256,address)`.\\n mstore(0x00, 0x5c96b331)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n }\\n _sendLogPayload(0x1c, 0x64);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n }\\n }\\n\\n function log(uint256 p0, uint256 p1, bool p2) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n // Selector of `log(uint256,uint256,bool)`.\\n mstore(0x00, 0x4766da72)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n }\\n _sendLogPayload(0x1c, 0x64);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n }\\n }\\n\\n function log(uint256 p0, uint256 p1, uint256 p2) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n // Selector of `log(uint256,uint256,uint256)`.\\n mstore(0x00, 0xd1ed7a3c)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n }\\n _sendLogPayload(0x1c, 0x64);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n }\\n }\\n\\n function log(uint256 p0, uint256 p1, bytes32 p2) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n // Selector of `log(uint256,uint256,string)`.\\n mstore(0x00, 0x71d04af2)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, 0x60)\\n writeString(0x80, p2)\\n }\\n _sendLogPayload(0x1c, 0xa4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n }\\n }\\n\\n function log(uint256 p0, bytes32 p1, address p2) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n // Selector of `log(uint256,string,address)`.\\n mstore(0x00, 0x7afac959)\\n mstore(0x20, p0)\\n mstore(0x40, 0x60)\\n mstore(0x60, p2)\\n writeString(0x80, p1)\\n }\\n _sendLogPayload(0x1c, 0xa4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n }\\n }\\n\\n function log(uint256 p0, bytes32 p1, bool p2) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n // Selector of `log(uint256,string,bool)`.\\n mstore(0x00, 0x4ceda75a)\\n mstore(0x20, p0)\\n mstore(0x40, 0x60)\\n mstore(0x60, p2)\\n writeString(0x80, p1)\\n }\\n _sendLogPayload(0x1c, 0xa4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n }\\n }\\n\\n function log(uint256 p0, bytes32 p1, uint256 p2) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n // Selector of `log(uint256,string,uint256)`.\\n mstore(0x00, 0x37aa7d4c)\\n mstore(0x20, p0)\\n mstore(0x40, 0x60)\\n mstore(0x60, p2)\\n writeString(0x80, p1)\\n }\\n _sendLogPayload(0x1c, 0xa4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n }\\n }\\n\\n function log(uint256 p0, bytes32 p1, bytes32 p2) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n // Selector of `log(uint256,string,string)`.\\n mstore(0x00, 0xb115611f)\\n mstore(0x20, p0)\\n mstore(0x40, 0x60)\\n mstore(0x60, 0xa0)\\n writeString(0x80, p1)\\n writeString(0xc0, p2)\\n }\\n _sendLogPayload(0x1c, 0xe4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n }\\n }\\n\\n function log(bytes32 p0, address p1, address p2) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n // Selector of `log(string,address,address)`.\\n mstore(0x00, 0xfcec75e0)\\n mstore(0x20, 0x60)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n writeString(0x80, p0)\\n }\\n _sendLogPayload(0x1c, 0xa4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n }\\n }\\n\\n function log(bytes32 p0, address p1, bool p2) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n // Selector of `log(string,address,bool)`.\\n mstore(0x00, 0xc91d5ed4)\\n mstore(0x20, 0x60)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n writeString(0x80, p0)\\n }\\n _sendLogPayload(0x1c, 0xa4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n }\\n }\\n\\n function log(bytes32 p0, address p1, uint256 p2) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n // Selector of `log(string,address,uint256)`.\\n mstore(0x00, 0x0d26b925)\\n mstore(0x20, 0x60)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n writeString(0x80, p0)\\n }\\n _sendLogPayload(0x1c, 0xa4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n }\\n }\\n\\n function log(bytes32 p0, address p1, bytes32 p2) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n // Selector of `log(string,address,string)`.\\n mstore(0x00, 0xe0e9ad4f)\\n mstore(0x20, 0x60)\\n mstore(0x40, p1)\\n mstore(0x60, 0xa0)\\n writeString(0x80, p0)\\n writeString(0xc0, p2)\\n }\\n _sendLogPayload(0x1c, 0xe4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n }\\n }\\n\\n function log(bytes32 p0, bool p1, address p2) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n // Selector of `log(string,bool,address)`.\\n mstore(0x00, 0x932bbb38)\\n mstore(0x20, 0x60)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n writeString(0x80, p0)\\n }\\n _sendLogPayload(0x1c, 0xa4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n }\\n }\\n\\n function log(bytes32 p0, bool p1, bool p2) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n // Selector of `log(string,bool,bool)`.\\n mstore(0x00, 0x850b7ad6)\\n mstore(0x20, 0x60)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n writeString(0x80, p0)\\n }\\n _sendLogPayload(0x1c, 0xa4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n }\\n }\\n\\n function log(bytes32 p0, bool p1, uint256 p2) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n // Selector of `log(string,bool,uint256)`.\\n mstore(0x00, 0xc95958d6)\\n mstore(0x20, 0x60)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n writeString(0x80, p0)\\n }\\n _sendLogPayload(0x1c, 0xa4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n }\\n }\\n\\n function log(bytes32 p0, bool p1, bytes32 p2) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n // Selector of `log(string,bool,string)`.\\n mstore(0x00, 0xe298f47d)\\n mstore(0x20, 0x60)\\n mstore(0x40, p1)\\n mstore(0x60, 0xa0)\\n writeString(0x80, p0)\\n writeString(0xc0, p2)\\n }\\n _sendLogPayload(0x1c, 0xe4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n }\\n }\\n\\n function log(bytes32 p0, uint256 p1, address p2) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n // Selector of `log(string,uint256,address)`.\\n mstore(0x00, 0x1c7ec448)\\n mstore(0x20, 0x60)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n writeString(0x80, p0)\\n }\\n _sendLogPayload(0x1c, 0xa4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n }\\n }\\n\\n function log(bytes32 p0, uint256 p1, bool p2) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n // Selector of `log(string,uint256,bool)`.\\n mstore(0x00, 0xca7733b1)\\n mstore(0x20, 0x60)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n writeString(0x80, p0)\\n }\\n _sendLogPayload(0x1c, 0xa4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n }\\n }\\n\\n function log(bytes32 p0, uint256 p1, uint256 p2) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n // Selector of `log(string,uint256,uint256)`.\\n mstore(0x00, 0xca47c4eb)\\n mstore(0x20, 0x60)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n writeString(0x80, p0)\\n }\\n _sendLogPayload(0x1c, 0xa4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n }\\n }\\n\\n function log(bytes32 p0, uint256 p1, bytes32 p2) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n // Selector of `log(string,uint256,string)`.\\n mstore(0x00, 0x5970e089)\\n mstore(0x20, 0x60)\\n mstore(0x40, p1)\\n mstore(0x60, 0xa0)\\n writeString(0x80, p0)\\n writeString(0xc0, p2)\\n }\\n _sendLogPayload(0x1c, 0xe4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n }\\n }\\n\\n function log(bytes32 p0, bytes32 p1, address p2) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n // Selector of `log(string,string,address)`.\\n mstore(0x00, 0x95ed0195)\\n mstore(0x20, 0x60)\\n mstore(0x40, 0xa0)\\n mstore(0x60, p2)\\n writeString(0x80, p0)\\n writeString(0xc0, p1)\\n }\\n _sendLogPayload(0x1c, 0xe4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n }\\n }\\n\\n function log(bytes32 p0, bytes32 p1, bool p2) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n // Selector of `log(string,string,bool)`.\\n mstore(0x00, 0xb0e0f9b5)\\n mstore(0x20, 0x60)\\n mstore(0x40, 0xa0)\\n mstore(0x60, p2)\\n writeString(0x80, p0)\\n writeString(0xc0, p1)\\n }\\n _sendLogPayload(0x1c, 0xe4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n }\\n }\\n\\n function log(bytes32 p0, bytes32 p1, uint256 p2) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n // Selector of `log(string,string,uint256)`.\\n mstore(0x00, 0x5821efa1)\\n mstore(0x20, 0x60)\\n mstore(0x40, 0xa0)\\n mstore(0x60, p2)\\n writeString(0x80, p0)\\n writeString(0xc0, p1)\\n }\\n _sendLogPayload(0x1c, 0xe4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n }\\n }\\n\\n function log(bytes32 p0, bytes32 p1, bytes32 p2) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n bytes32 m9;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n m9 := mload(0x120)\\n // Selector of `log(string,string,string)`.\\n mstore(0x00, 0x2ced7cef)\\n mstore(0x20, 0x60)\\n mstore(0x40, 0xa0)\\n mstore(0x60, 0xe0)\\n writeString(0x80, p0)\\n writeString(0xc0, p1)\\n writeString(0x100, p2)\\n }\\n _sendLogPayload(0x1c, 0x124);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n mstore(0x120, m9)\\n }\\n }\\n\\n function log(address p0, address p1, address p2, address p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(address,address,address,address)`.\\n mstore(0x00, 0x665bf134)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(address p0, address p1, address p2, bool p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(address,address,address,bool)`.\\n mstore(0x00, 0x0e378994)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(address p0, address p1, address p2, uint256 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(address,address,address,uint256)`.\\n mstore(0x00, 0x94250d77)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(address p0, address p1, address p2, bytes32 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(address,address,address,string)`.\\n mstore(0x00, 0xf808da20)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, 0x80)\\n writeString(0xa0, p3)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(address p0, address p1, bool p2, address p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(address,address,bool,address)`.\\n mstore(0x00, 0x9f1bc36e)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(address p0, address p1, bool p2, bool p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(address,address,bool,bool)`.\\n mstore(0x00, 0x2cd4134a)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(address p0, address p1, bool p2, uint256 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(address,address,bool,uint256)`.\\n mstore(0x00, 0x3971e78c)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(address p0, address p1, bool p2, bytes32 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(address,address,bool,string)`.\\n mstore(0x00, 0xaa6540c8)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, 0x80)\\n writeString(0xa0, p3)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(address p0, address p1, uint256 p2, address p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(address,address,uint256,address)`.\\n mstore(0x00, 0x8da6def5)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(address p0, address p1, uint256 p2, bool p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(address,address,uint256,bool)`.\\n mstore(0x00, 0x9b4254e2)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(address p0, address p1, uint256 p2, uint256 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(address,address,uint256,uint256)`.\\n mstore(0x00, 0xbe553481)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(address p0, address p1, uint256 p2, bytes32 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(address,address,uint256,string)`.\\n mstore(0x00, 0xfdb4f990)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, 0x80)\\n writeString(0xa0, p3)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(address p0, address p1, bytes32 p2, address p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(address,address,string,address)`.\\n mstore(0x00, 0x8f736d16)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, 0x80)\\n mstore(0x80, p3)\\n writeString(0xa0, p2)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(address p0, address p1, bytes32 p2, bool p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(address,address,string,bool)`.\\n mstore(0x00, 0x6f1a594e)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, 0x80)\\n mstore(0x80, p3)\\n writeString(0xa0, p2)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(address p0, address p1, bytes32 p2, uint256 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(address,address,string,uint256)`.\\n mstore(0x00, 0xef1cefe7)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, 0x80)\\n mstore(0x80, p3)\\n writeString(0xa0, p2)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(address p0, address p1, bytes32 p2, bytes32 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n // Selector of `log(address,address,string,string)`.\\n mstore(0x00, 0x21bdaf25)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, 0x80)\\n mstore(0x80, 0xc0)\\n writeString(0xa0, p2)\\n writeString(0xe0, p3)\\n }\\n _sendLogPayload(0x1c, 0x104);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n }\\n }\\n\\n function log(address p0, bool p1, address p2, address p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(address,bool,address,address)`.\\n mstore(0x00, 0x660375dd)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(address p0, bool p1, address p2, bool p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(address,bool,address,bool)`.\\n mstore(0x00, 0xa6f50b0f)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(address p0, bool p1, address p2, uint256 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(address,bool,address,uint256)`.\\n mstore(0x00, 0xa75c59de)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(address p0, bool p1, address p2, bytes32 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(address,bool,address,string)`.\\n mstore(0x00, 0x2dd778e6)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, 0x80)\\n writeString(0xa0, p3)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(address p0, bool p1, bool p2, address p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(address,bool,bool,address)`.\\n mstore(0x00, 0xcf394485)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(address p0, bool p1, bool p2, bool p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(address,bool,bool,bool)`.\\n mstore(0x00, 0xcac43479)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(address p0, bool p1, bool p2, uint256 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(address,bool,bool,uint256)`.\\n mstore(0x00, 0x8c4e5de6)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(address p0, bool p1, bool p2, bytes32 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(address,bool,bool,string)`.\\n mstore(0x00, 0xdfc4a2e8)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, 0x80)\\n writeString(0xa0, p3)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(address p0, bool p1, uint256 p2, address p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(address,bool,uint256,address)`.\\n mstore(0x00, 0xccf790a1)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(address p0, bool p1, uint256 p2, bool p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(address,bool,uint256,bool)`.\\n mstore(0x00, 0xc4643e20)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(address p0, bool p1, uint256 p2, uint256 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(address,bool,uint256,uint256)`.\\n mstore(0x00, 0x386ff5f4)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(address p0, bool p1, uint256 p2, bytes32 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(address,bool,uint256,string)`.\\n mstore(0x00, 0x0aa6cfad)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, 0x80)\\n writeString(0xa0, p3)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(address p0, bool p1, bytes32 p2, address p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(address,bool,string,address)`.\\n mstore(0x00, 0x19fd4956)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, 0x80)\\n mstore(0x80, p3)\\n writeString(0xa0, p2)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(address p0, bool p1, bytes32 p2, bool p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(address,bool,string,bool)`.\\n mstore(0x00, 0x50ad461d)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, 0x80)\\n mstore(0x80, p3)\\n writeString(0xa0, p2)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(address p0, bool p1, bytes32 p2, uint256 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(address,bool,string,uint256)`.\\n mstore(0x00, 0x80e6a20b)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, 0x80)\\n mstore(0x80, p3)\\n writeString(0xa0, p2)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(address p0, bool p1, bytes32 p2, bytes32 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n // Selector of `log(address,bool,string,string)`.\\n mstore(0x00, 0x475c5c33)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, 0x80)\\n mstore(0x80, 0xc0)\\n writeString(0xa0, p2)\\n writeString(0xe0, p3)\\n }\\n _sendLogPayload(0x1c, 0x104);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n }\\n }\\n\\n function log(address p0, uint256 p1, address p2, address p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(address,uint256,address,address)`.\\n mstore(0x00, 0x478d1c62)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(address p0, uint256 p1, address p2, bool p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(address,uint256,address,bool)`.\\n mstore(0x00, 0xa1bcc9b3)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(address p0, uint256 p1, address p2, uint256 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(address,uint256,address,uint256)`.\\n mstore(0x00, 0x100f650e)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(address p0, uint256 p1, address p2, bytes32 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(address,uint256,address,string)`.\\n mstore(0x00, 0x1da986ea)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, 0x80)\\n writeString(0xa0, p3)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(address p0, uint256 p1, bool p2, address p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(address,uint256,bool,address)`.\\n mstore(0x00, 0xa31bfdcc)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(address p0, uint256 p1, bool p2, bool p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(address,uint256,bool,bool)`.\\n mstore(0x00, 0x3bf5e537)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(address p0, uint256 p1, bool p2, uint256 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(address,uint256,bool,uint256)`.\\n mstore(0x00, 0x22f6b999)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(address p0, uint256 p1, bool p2, bytes32 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(address,uint256,bool,string)`.\\n mstore(0x00, 0xc5ad85f9)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, 0x80)\\n writeString(0xa0, p3)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(address p0, uint256 p1, uint256 p2, address p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(address,uint256,uint256,address)`.\\n mstore(0x00, 0x20e3984d)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(address p0, uint256 p1, uint256 p2, bool p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(address,uint256,uint256,bool)`.\\n mstore(0x00, 0x66f1bc67)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(address p0, uint256 p1, uint256 p2, uint256 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(address,uint256,uint256,uint256)`.\\n mstore(0x00, 0x34f0e636)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(address p0, uint256 p1, uint256 p2, bytes32 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(address,uint256,uint256,string)`.\\n mstore(0x00, 0x4a28c017)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, 0x80)\\n writeString(0xa0, p3)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(address p0, uint256 p1, bytes32 p2, address p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(address,uint256,string,address)`.\\n mstore(0x00, 0x5c430d47)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, 0x80)\\n mstore(0x80, p3)\\n writeString(0xa0, p2)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(address p0, uint256 p1, bytes32 p2, bool p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(address,uint256,string,bool)`.\\n mstore(0x00, 0xcf18105c)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, 0x80)\\n mstore(0x80, p3)\\n writeString(0xa0, p2)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(address p0, uint256 p1, bytes32 p2, uint256 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(address,uint256,string,uint256)`.\\n mstore(0x00, 0xbf01f891)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, 0x80)\\n mstore(0x80, p3)\\n writeString(0xa0, p2)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(address p0, uint256 p1, bytes32 p2, bytes32 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n // Selector of `log(address,uint256,string,string)`.\\n mstore(0x00, 0x88a8c406)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, 0x80)\\n mstore(0x80, 0xc0)\\n writeString(0xa0, p2)\\n writeString(0xe0, p3)\\n }\\n _sendLogPayload(0x1c, 0x104);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n }\\n }\\n\\n function log(address p0, bytes32 p1, address p2, address p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(address,string,address,address)`.\\n mstore(0x00, 0x0d36fa20)\\n mstore(0x20, p0)\\n mstore(0x40, 0x80)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n writeString(0xa0, p1)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(address p0, bytes32 p1, address p2, bool p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(address,string,address,bool)`.\\n mstore(0x00, 0x0df12b76)\\n mstore(0x20, p0)\\n mstore(0x40, 0x80)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n writeString(0xa0, p1)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(address p0, bytes32 p1, address p2, uint256 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(address,string,address,uint256)`.\\n mstore(0x00, 0x457fe3cf)\\n mstore(0x20, p0)\\n mstore(0x40, 0x80)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n writeString(0xa0, p1)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(address p0, bytes32 p1, address p2, bytes32 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n // Selector of `log(address,string,address,string)`.\\n mstore(0x00, 0xf7e36245)\\n mstore(0x20, p0)\\n mstore(0x40, 0x80)\\n mstore(0x60, p2)\\n mstore(0x80, 0xc0)\\n writeString(0xa0, p1)\\n writeString(0xe0, p3)\\n }\\n _sendLogPayload(0x1c, 0x104);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n }\\n }\\n\\n function log(address p0, bytes32 p1, bool p2, address p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(address,string,bool,address)`.\\n mstore(0x00, 0x205871c2)\\n mstore(0x20, p0)\\n mstore(0x40, 0x80)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n writeString(0xa0, p1)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(address p0, bytes32 p1, bool p2, bool p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(address,string,bool,bool)`.\\n mstore(0x00, 0x5f1d5c9f)\\n mstore(0x20, p0)\\n mstore(0x40, 0x80)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n writeString(0xa0, p1)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(address p0, bytes32 p1, bool p2, uint256 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(address,string,bool,uint256)`.\\n mstore(0x00, 0x515e38b6)\\n mstore(0x20, p0)\\n mstore(0x40, 0x80)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n writeString(0xa0, p1)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(address p0, bytes32 p1, bool p2, bytes32 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n // Selector of `log(address,string,bool,string)`.\\n mstore(0x00, 0xbc0b61fe)\\n mstore(0x20, p0)\\n mstore(0x40, 0x80)\\n mstore(0x60, p2)\\n mstore(0x80, 0xc0)\\n writeString(0xa0, p1)\\n writeString(0xe0, p3)\\n }\\n _sendLogPayload(0x1c, 0x104);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n }\\n }\\n\\n function log(address p0, bytes32 p1, uint256 p2, address p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(address,string,uint256,address)`.\\n mstore(0x00, 0x63183678)\\n mstore(0x20, p0)\\n mstore(0x40, 0x80)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n writeString(0xa0, p1)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(address p0, bytes32 p1, uint256 p2, bool p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(address,string,uint256,bool)`.\\n mstore(0x00, 0x0ef7e050)\\n mstore(0x20, p0)\\n mstore(0x40, 0x80)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n writeString(0xa0, p1)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(address p0, bytes32 p1, uint256 p2, uint256 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(address,string,uint256,uint256)`.\\n mstore(0x00, 0x1dc8e1b8)\\n mstore(0x20, p0)\\n mstore(0x40, 0x80)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n writeString(0xa0, p1)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(address p0, bytes32 p1, uint256 p2, bytes32 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n // Selector of `log(address,string,uint256,string)`.\\n mstore(0x00, 0x448830a8)\\n mstore(0x20, p0)\\n mstore(0x40, 0x80)\\n mstore(0x60, p2)\\n mstore(0x80, 0xc0)\\n writeString(0xa0, p1)\\n writeString(0xe0, p3)\\n }\\n _sendLogPayload(0x1c, 0x104);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n }\\n }\\n\\n function log(address p0, bytes32 p1, bytes32 p2, address p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n // Selector of `log(address,string,string,address)`.\\n mstore(0x00, 0xa04e2f87)\\n mstore(0x20, p0)\\n mstore(0x40, 0x80)\\n mstore(0x60, 0xc0)\\n mstore(0x80, p3)\\n writeString(0xa0, p1)\\n writeString(0xe0, p2)\\n }\\n _sendLogPayload(0x1c, 0x104);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n }\\n }\\n\\n function log(address p0, bytes32 p1, bytes32 p2, bool p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n // Selector of `log(address,string,string,bool)`.\\n mstore(0x00, 0x35a5071f)\\n mstore(0x20, p0)\\n mstore(0x40, 0x80)\\n mstore(0x60, 0xc0)\\n mstore(0x80, p3)\\n writeString(0xa0, p1)\\n writeString(0xe0, p2)\\n }\\n _sendLogPayload(0x1c, 0x104);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n }\\n }\\n\\n function log(address p0, bytes32 p1, bytes32 p2, uint256 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n // Selector of `log(address,string,string,uint256)`.\\n mstore(0x00, 0x159f8927)\\n mstore(0x20, p0)\\n mstore(0x40, 0x80)\\n mstore(0x60, 0xc0)\\n mstore(0x80, p3)\\n writeString(0xa0, p1)\\n writeString(0xe0, p2)\\n }\\n _sendLogPayload(0x1c, 0x104);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n }\\n }\\n\\n function log(address p0, bytes32 p1, bytes32 p2, bytes32 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n bytes32 m9;\\n bytes32 m10;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n m9 := mload(0x120)\\n m10 := mload(0x140)\\n // Selector of `log(address,string,string,string)`.\\n mstore(0x00, 0x5d02c50b)\\n mstore(0x20, p0)\\n mstore(0x40, 0x80)\\n mstore(0x60, 0xc0)\\n mstore(0x80, 0x100)\\n writeString(0xa0, p1)\\n writeString(0xe0, p2)\\n writeString(0x120, p3)\\n }\\n _sendLogPayload(0x1c, 0x144);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n mstore(0x120, m9)\\n mstore(0x140, m10)\\n }\\n }\\n\\n function log(bool p0, address p1, address p2, address p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(bool,address,address,address)`.\\n mstore(0x00, 0x1d14d001)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(bool p0, address p1, address p2, bool p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(bool,address,address,bool)`.\\n mstore(0x00, 0x46600be0)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(bool p0, address p1, address p2, uint256 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(bool,address,address,uint256)`.\\n mstore(0x00, 0x0c66d1be)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(bool p0, address p1, address p2, bytes32 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(bool,address,address,string)`.\\n mstore(0x00, 0xd812a167)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, 0x80)\\n writeString(0xa0, p3)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(bool p0, address p1, bool p2, address p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(bool,address,bool,address)`.\\n mstore(0x00, 0x1c41a336)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(bool p0, address p1, bool p2, bool p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(bool,address,bool,bool)`.\\n mstore(0x00, 0x6a9c478b)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(bool p0, address p1, bool p2, uint256 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(bool,address,bool,uint256)`.\\n mstore(0x00, 0x07831502)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(bool p0, address p1, bool p2, bytes32 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(bool,address,bool,string)`.\\n mstore(0x00, 0x4a66cb34)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, 0x80)\\n writeString(0xa0, p3)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(bool p0, address p1, uint256 p2, address p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(bool,address,uint256,address)`.\\n mstore(0x00, 0x136b05dd)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(bool p0, address p1, uint256 p2, bool p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(bool,address,uint256,bool)`.\\n mstore(0x00, 0xd6019f1c)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(bool p0, address p1, uint256 p2, uint256 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(bool,address,uint256,uint256)`.\\n mstore(0x00, 0x7bf181a1)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(bool p0, address p1, uint256 p2, bytes32 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(bool,address,uint256,string)`.\\n mstore(0x00, 0x51f09ff8)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, 0x80)\\n writeString(0xa0, p3)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(bool p0, address p1, bytes32 p2, address p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(bool,address,string,address)`.\\n mstore(0x00, 0x6f7c603e)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, 0x80)\\n mstore(0x80, p3)\\n writeString(0xa0, p2)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(bool p0, address p1, bytes32 p2, bool p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(bool,address,string,bool)`.\\n mstore(0x00, 0xe2bfd60b)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, 0x80)\\n mstore(0x80, p3)\\n writeString(0xa0, p2)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(bool p0, address p1, bytes32 p2, uint256 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(bool,address,string,uint256)`.\\n mstore(0x00, 0xc21f64c7)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, 0x80)\\n mstore(0x80, p3)\\n writeString(0xa0, p2)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(bool p0, address p1, bytes32 p2, bytes32 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n // Selector of `log(bool,address,string,string)`.\\n mstore(0x00, 0xa73c1db6)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, 0x80)\\n mstore(0x80, 0xc0)\\n writeString(0xa0, p2)\\n writeString(0xe0, p3)\\n }\\n _sendLogPayload(0x1c, 0x104);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n }\\n }\\n\\n function log(bool p0, bool p1, address p2, address p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(bool,bool,address,address)`.\\n mstore(0x00, 0xf4880ea4)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(bool p0, bool p1, address p2, bool p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(bool,bool,address,bool)`.\\n mstore(0x00, 0xc0a302d8)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(bool p0, bool p1, address p2, uint256 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(bool,bool,address,uint256)`.\\n mstore(0x00, 0x4c123d57)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(bool p0, bool p1, address p2, bytes32 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(bool,bool,address,string)`.\\n mstore(0x00, 0xa0a47963)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, 0x80)\\n writeString(0xa0, p3)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(bool p0, bool p1, bool p2, address p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(bool,bool,bool,address)`.\\n mstore(0x00, 0x8c329b1a)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(bool p0, bool p1, bool p2, bool p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(bool,bool,bool,bool)`.\\n mstore(0x00, 0x3b2a5ce0)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(bool p0, bool p1, bool p2, uint256 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(bool,bool,bool,uint256)`.\\n mstore(0x00, 0x6d7045c1)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(bool p0, bool p1, bool p2, bytes32 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(bool,bool,bool,string)`.\\n mstore(0x00, 0x2ae408d4)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, 0x80)\\n writeString(0xa0, p3)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(bool p0, bool p1, uint256 p2, address p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(bool,bool,uint256,address)`.\\n mstore(0x00, 0x54a7a9a0)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(bool p0, bool p1, uint256 p2, bool p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(bool,bool,uint256,bool)`.\\n mstore(0x00, 0x619e4d0e)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(bool p0, bool p1, uint256 p2, uint256 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(bool,bool,uint256,uint256)`.\\n mstore(0x00, 0x0bb00eab)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(bool p0, bool p1, uint256 p2, bytes32 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(bool,bool,uint256,string)`.\\n mstore(0x00, 0x7dd4d0e0)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, 0x80)\\n writeString(0xa0, p3)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(bool p0, bool p1, bytes32 p2, address p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(bool,bool,string,address)`.\\n mstore(0x00, 0xf9ad2b89)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, 0x80)\\n mstore(0x80, p3)\\n writeString(0xa0, p2)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(bool p0, bool p1, bytes32 p2, bool p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(bool,bool,string,bool)`.\\n mstore(0x00, 0xb857163a)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, 0x80)\\n mstore(0x80, p3)\\n writeString(0xa0, p2)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(bool p0, bool p1, bytes32 p2, uint256 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(bool,bool,string,uint256)`.\\n mstore(0x00, 0xe3a9ca2f)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, 0x80)\\n mstore(0x80, p3)\\n writeString(0xa0, p2)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(bool p0, bool p1, bytes32 p2, bytes32 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n // Selector of `log(bool,bool,string,string)`.\\n mstore(0x00, 0x6d1e8751)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, 0x80)\\n mstore(0x80, 0xc0)\\n writeString(0xa0, p2)\\n writeString(0xe0, p3)\\n }\\n _sendLogPayload(0x1c, 0x104);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n }\\n }\\n\\n function log(bool p0, uint256 p1, address p2, address p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(bool,uint256,address,address)`.\\n mstore(0x00, 0x26f560a8)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(bool p0, uint256 p1, address p2, bool p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(bool,uint256,address,bool)`.\\n mstore(0x00, 0xb4c314ff)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(bool p0, uint256 p1, address p2, uint256 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(bool,uint256,address,uint256)`.\\n mstore(0x00, 0x1537dc87)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(bool p0, uint256 p1, address p2, bytes32 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(bool,uint256,address,string)`.\\n mstore(0x00, 0x1bb3b09a)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, 0x80)\\n writeString(0xa0, p3)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(bool p0, uint256 p1, bool p2, address p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(bool,uint256,bool,address)`.\\n mstore(0x00, 0x9acd3616)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(bool p0, uint256 p1, bool p2, bool p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(bool,uint256,bool,bool)`.\\n mstore(0x00, 0xceb5f4d7)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(bool p0, uint256 p1, bool p2, uint256 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(bool,uint256,bool,uint256)`.\\n mstore(0x00, 0x7f9bbca2)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(bool p0, uint256 p1, bool p2, bytes32 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(bool,uint256,bool,string)`.\\n mstore(0x00, 0x9143dbb1)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, 0x80)\\n writeString(0xa0, p3)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(bool p0, uint256 p1, uint256 p2, address p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(bool,uint256,uint256,address)`.\\n mstore(0x00, 0x00dd87b9)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(bool p0, uint256 p1, uint256 p2, bool p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(bool,uint256,uint256,bool)`.\\n mstore(0x00, 0xbe984353)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(bool p0, uint256 p1, uint256 p2, uint256 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(bool,uint256,uint256,uint256)`.\\n mstore(0x00, 0x374bb4b2)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(bool p0, uint256 p1, uint256 p2, bytes32 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(bool,uint256,uint256,string)`.\\n mstore(0x00, 0x8e69fb5d)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, 0x80)\\n writeString(0xa0, p3)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(bool p0, uint256 p1, bytes32 p2, address p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(bool,uint256,string,address)`.\\n mstore(0x00, 0xfedd1fff)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, 0x80)\\n mstore(0x80, p3)\\n writeString(0xa0, p2)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(bool p0, uint256 p1, bytes32 p2, bool p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(bool,uint256,string,bool)`.\\n mstore(0x00, 0xe5e70b2b)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, 0x80)\\n mstore(0x80, p3)\\n writeString(0xa0, p2)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(bool p0, uint256 p1, bytes32 p2, uint256 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(bool,uint256,string,uint256)`.\\n mstore(0x00, 0x6a1199e2)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, 0x80)\\n mstore(0x80, p3)\\n writeString(0xa0, p2)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(bool p0, uint256 p1, bytes32 p2, bytes32 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n // Selector of `log(bool,uint256,string,string)`.\\n mstore(0x00, 0xf5bc2249)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, 0x80)\\n mstore(0x80, 0xc0)\\n writeString(0xa0, p2)\\n writeString(0xe0, p3)\\n }\\n _sendLogPayload(0x1c, 0x104);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n }\\n }\\n\\n function log(bool p0, bytes32 p1, address p2, address p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(bool,string,address,address)`.\\n mstore(0x00, 0x2b2b18dc)\\n mstore(0x20, p0)\\n mstore(0x40, 0x80)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n writeString(0xa0, p1)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(bool p0, bytes32 p1, address p2, bool p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(bool,string,address,bool)`.\\n mstore(0x00, 0x6dd434ca)\\n mstore(0x20, p0)\\n mstore(0x40, 0x80)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n writeString(0xa0, p1)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(bool p0, bytes32 p1, address p2, uint256 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(bool,string,address,uint256)`.\\n mstore(0x00, 0xa5cada94)\\n mstore(0x20, p0)\\n mstore(0x40, 0x80)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n writeString(0xa0, p1)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(bool p0, bytes32 p1, address p2, bytes32 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n // Selector of `log(bool,string,address,string)`.\\n mstore(0x00, 0x12d6c788)\\n mstore(0x20, p0)\\n mstore(0x40, 0x80)\\n mstore(0x60, p2)\\n mstore(0x80, 0xc0)\\n writeString(0xa0, p1)\\n writeString(0xe0, p3)\\n }\\n _sendLogPayload(0x1c, 0x104);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n }\\n }\\n\\n function log(bool p0, bytes32 p1, bool p2, address p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(bool,string,bool,address)`.\\n mstore(0x00, 0x538e06ab)\\n mstore(0x20, p0)\\n mstore(0x40, 0x80)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n writeString(0xa0, p1)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(bool p0, bytes32 p1, bool p2, bool p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(bool,string,bool,bool)`.\\n mstore(0x00, 0xdc5e935b)\\n mstore(0x20, p0)\\n mstore(0x40, 0x80)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n writeString(0xa0, p1)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(bool p0, bytes32 p1, bool p2, uint256 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(bool,string,bool,uint256)`.\\n mstore(0x00, 0x1606a393)\\n mstore(0x20, p0)\\n mstore(0x40, 0x80)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n writeString(0xa0, p1)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(bool p0, bytes32 p1, bool p2, bytes32 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n // Selector of `log(bool,string,bool,string)`.\\n mstore(0x00, 0x483d0416)\\n mstore(0x20, p0)\\n mstore(0x40, 0x80)\\n mstore(0x60, p2)\\n mstore(0x80, 0xc0)\\n writeString(0xa0, p1)\\n writeString(0xe0, p3)\\n }\\n _sendLogPayload(0x1c, 0x104);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n }\\n }\\n\\n function log(bool p0, bytes32 p1, uint256 p2, address p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(bool,string,uint256,address)`.\\n mstore(0x00, 0x1596a1ce)\\n mstore(0x20, p0)\\n mstore(0x40, 0x80)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n writeString(0xa0, p1)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(bool p0, bytes32 p1, uint256 p2, bool p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(bool,string,uint256,bool)`.\\n mstore(0x00, 0x6b0e5d53)\\n mstore(0x20, p0)\\n mstore(0x40, 0x80)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n writeString(0xa0, p1)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(bool p0, bytes32 p1, uint256 p2, uint256 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(bool,string,uint256,uint256)`.\\n mstore(0x00, 0x28863fcb)\\n mstore(0x20, p0)\\n mstore(0x40, 0x80)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n writeString(0xa0, p1)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(bool p0, bytes32 p1, uint256 p2, bytes32 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n // Selector of `log(bool,string,uint256,string)`.\\n mstore(0x00, 0x1ad96de6)\\n mstore(0x20, p0)\\n mstore(0x40, 0x80)\\n mstore(0x60, p2)\\n mstore(0x80, 0xc0)\\n writeString(0xa0, p1)\\n writeString(0xe0, p3)\\n }\\n _sendLogPayload(0x1c, 0x104);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n }\\n }\\n\\n function log(bool p0, bytes32 p1, bytes32 p2, address p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n // Selector of `log(bool,string,string,address)`.\\n mstore(0x00, 0x97d394d8)\\n mstore(0x20, p0)\\n mstore(0x40, 0x80)\\n mstore(0x60, 0xc0)\\n mstore(0x80, p3)\\n writeString(0xa0, p1)\\n writeString(0xe0, p2)\\n }\\n _sendLogPayload(0x1c, 0x104);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n }\\n }\\n\\n function log(bool p0, bytes32 p1, bytes32 p2, bool p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n // Selector of `log(bool,string,string,bool)`.\\n mstore(0x00, 0x1e4b87e5)\\n mstore(0x20, p0)\\n mstore(0x40, 0x80)\\n mstore(0x60, 0xc0)\\n mstore(0x80, p3)\\n writeString(0xa0, p1)\\n writeString(0xe0, p2)\\n }\\n _sendLogPayload(0x1c, 0x104);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n }\\n }\\n\\n function log(bool p0, bytes32 p1, bytes32 p2, uint256 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n // Selector of `log(bool,string,string,uint256)`.\\n mstore(0x00, 0x7be0c3eb)\\n mstore(0x20, p0)\\n mstore(0x40, 0x80)\\n mstore(0x60, 0xc0)\\n mstore(0x80, p3)\\n writeString(0xa0, p1)\\n writeString(0xe0, p2)\\n }\\n _sendLogPayload(0x1c, 0x104);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n }\\n }\\n\\n function log(bool p0, bytes32 p1, bytes32 p2, bytes32 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n bytes32 m9;\\n bytes32 m10;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n m9 := mload(0x120)\\n m10 := mload(0x140)\\n // Selector of `log(bool,string,string,string)`.\\n mstore(0x00, 0x1762e32a)\\n mstore(0x20, p0)\\n mstore(0x40, 0x80)\\n mstore(0x60, 0xc0)\\n mstore(0x80, 0x100)\\n writeString(0xa0, p1)\\n writeString(0xe0, p2)\\n writeString(0x120, p3)\\n }\\n _sendLogPayload(0x1c, 0x144);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n mstore(0x120, m9)\\n mstore(0x140, m10)\\n }\\n }\\n\\n function log(uint256 p0, address p1, address p2, address p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(uint256,address,address,address)`.\\n mstore(0x00, 0x2488b414)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(uint256 p0, address p1, address p2, bool p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(uint256,address,address,bool)`.\\n mstore(0x00, 0x091ffaf5)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(uint256 p0, address p1, address p2, uint256 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(uint256,address,address,uint256)`.\\n mstore(0x00, 0x736efbb6)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(uint256 p0, address p1, address p2, bytes32 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(uint256,address,address,string)`.\\n mstore(0x00, 0x031c6f73)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, 0x80)\\n writeString(0xa0, p3)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(uint256 p0, address p1, bool p2, address p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(uint256,address,bool,address)`.\\n mstore(0x00, 0xef72c513)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(uint256 p0, address p1, bool p2, bool p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(uint256,address,bool,bool)`.\\n mstore(0x00, 0xe351140f)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(uint256 p0, address p1, bool p2, uint256 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(uint256,address,bool,uint256)`.\\n mstore(0x00, 0x5abd992a)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(uint256 p0, address p1, bool p2, bytes32 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(uint256,address,bool,string)`.\\n mstore(0x00, 0x90fb06aa)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, 0x80)\\n writeString(0xa0, p3)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(uint256 p0, address p1, uint256 p2, address p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(uint256,address,uint256,address)`.\\n mstore(0x00, 0x15c127b5)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(uint256 p0, address p1, uint256 p2, bool p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(uint256,address,uint256,bool)`.\\n mstore(0x00, 0x5f743a7c)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(uint256 p0, address p1, uint256 p2, uint256 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(uint256,address,uint256,uint256)`.\\n mstore(0x00, 0x0c9cd9c1)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(uint256 p0, address p1, uint256 p2, bytes32 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(uint256,address,uint256,string)`.\\n mstore(0x00, 0xddb06521)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, 0x80)\\n writeString(0xa0, p3)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(uint256 p0, address p1, bytes32 p2, address p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(uint256,address,string,address)`.\\n mstore(0x00, 0x9cba8fff)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, 0x80)\\n mstore(0x80, p3)\\n writeString(0xa0, p2)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(uint256 p0, address p1, bytes32 p2, bool p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(uint256,address,string,bool)`.\\n mstore(0x00, 0xcc32ab07)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, 0x80)\\n mstore(0x80, p3)\\n writeString(0xa0, p2)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(uint256 p0, address p1, bytes32 p2, uint256 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(uint256,address,string,uint256)`.\\n mstore(0x00, 0x46826b5d)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, 0x80)\\n mstore(0x80, p3)\\n writeString(0xa0, p2)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(uint256 p0, address p1, bytes32 p2, bytes32 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n // Selector of `log(uint256,address,string,string)`.\\n mstore(0x00, 0x3e128ca3)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, 0x80)\\n mstore(0x80, 0xc0)\\n writeString(0xa0, p2)\\n writeString(0xe0, p3)\\n }\\n _sendLogPayload(0x1c, 0x104);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n }\\n }\\n\\n function log(uint256 p0, bool p1, address p2, address p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(uint256,bool,address,address)`.\\n mstore(0x00, 0xa1ef4cbb)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(uint256 p0, bool p1, address p2, bool p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(uint256,bool,address,bool)`.\\n mstore(0x00, 0x454d54a5)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(uint256 p0, bool p1, address p2, uint256 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(uint256,bool,address,uint256)`.\\n mstore(0x00, 0x078287f5)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(uint256 p0, bool p1, address p2, bytes32 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(uint256,bool,address,string)`.\\n mstore(0x00, 0xade052c7)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, 0x80)\\n writeString(0xa0, p3)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(uint256 p0, bool p1, bool p2, address p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(uint256,bool,bool,address)`.\\n mstore(0x00, 0x69640b59)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(uint256 p0, bool p1, bool p2, bool p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(uint256,bool,bool,bool)`.\\n mstore(0x00, 0xb6f577a1)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(uint256 p0, bool p1, bool p2, uint256 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(uint256,bool,bool,uint256)`.\\n mstore(0x00, 0x7464ce23)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(uint256 p0, bool p1, bool p2, bytes32 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(uint256,bool,bool,string)`.\\n mstore(0x00, 0xdddb9561)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, 0x80)\\n writeString(0xa0, p3)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(uint256 p0, bool p1, uint256 p2, address p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(uint256,bool,uint256,address)`.\\n mstore(0x00, 0x88cb6041)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(uint256 p0, bool p1, uint256 p2, bool p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(uint256,bool,uint256,bool)`.\\n mstore(0x00, 0x91a02e2a)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(uint256 p0, bool p1, uint256 p2, uint256 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(uint256,bool,uint256,uint256)`.\\n mstore(0x00, 0xc6acc7a8)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(uint256 p0, bool p1, uint256 p2, bytes32 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(uint256,bool,uint256,string)`.\\n mstore(0x00, 0xde03e774)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, 0x80)\\n writeString(0xa0, p3)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(uint256 p0, bool p1, bytes32 p2, address p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(uint256,bool,string,address)`.\\n mstore(0x00, 0xef529018)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, 0x80)\\n mstore(0x80, p3)\\n writeString(0xa0, p2)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(uint256 p0, bool p1, bytes32 p2, bool p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(uint256,bool,string,bool)`.\\n mstore(0x00, 0xeb928d7f)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, 0x80)\\n mstore(0x80, p3)\\n writeString(0xa0, p2)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(uint256 p0, bool p1, bytes32 p2, uint256 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(uint256,bool,string,uint256)`.\\n mstore(0x00, 0x2c1d0746)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, 0x80)\\n mstore(0x80, p3)\\n writeString(0xa0, p2)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(uint256 p0, bool p1, bytes32 p2, bytes32 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n // Selector of `log(uint256,bool,string,string)`.\\n mstore(0x00, 0x68c8b8bd)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, 0x80)\\n mstore(0x80, 0xc0)\\n writeString(0xa0, p2)\\n writeString(0xe0, p3)\\n }\\n _sendLogPayload(0x1c, 0x104);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n }\\n }\\n\\n function log(uint256 p0, uint256 p1, address p2, address p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(uint256,uint256,address,address)`.\\n mstore(0x00, 0x56a5d1b1)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(uint256 p0, uint256 p1, address p2, bool p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(uint256,uint256,address,bool)`.\\n mstore(0x00, 0x15cac476)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(uint256 p0, uint256 p1, address p2, uint256 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(uint256,uint256,address,uint256)`.\\n mstore(0x00, 0x88f6e4b2)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(uint256 p0, uint256 p1, address p2, bytes32 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(uint256,uint256,address,string)`.\\n mstore(0x00, 0x6cde40b8)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, 0x80)\\n writeString(0xa0, p3)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(uint256 p0, uint256 p1, bool p2, address p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(uint256,uint256,bool,address)`.\\n mstore(0x00, 0x9a816a83)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(uint256 p0, uint256 p1, bool p2, bool p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(uint256,uint256,bool,bool)`.\\n mstore(0x00, 0xab085ae6)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(uint256 p0, uint256 p1, bool p2, uint256 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(uint256,uint256,bool,uint256)`.\\n mstore(0x00, 0xeb7f6fd2)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(uint256 p0, uint256 p1, bool p2, bytes32 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(uint256,uint256,bool,string)`.\\n mstore(0x00, 0xa5b4fc99)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, 0x80)\\n writeString(0xa0, p3)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(uint256 p0, uint256 p1, uint256 p2, address p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(uint256,uint256,uint256,address)`.\\n mstore(0x00, 0xfa8185af)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(uint256 p0, uint256 p1, uint256 p2, bool p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(uint256,uint256,uint256,bool)`.\\n mstore(0x00, 0xc598d185)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(uint256 p0, uint256 p1, uint256 p2, uint256 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n /// @solidity memory-safe-assembly\\n assembly {\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n // Selector of `log(uint256,uint256,uint256,uint256)`.\\n mstore(0x00, 0x193fb800)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n }\\n _sendLogPayload(0x1c, 0x84);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n }\\n }\\n\\n function log(uint256 p0, uint256 p1, uint256 p2, bytes32 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(uint256,uint256,uint256,string)`.\\n mstore(0x00, 0x59cfcbe3)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, 0x80)\\n writeString(0xa0, p3)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(uint256 p0, uint256 p1, bytes32 p2, address p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(uint256,uint256,string,address)`.\\n mstore(0x00, 0x42d21db7)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, 0x80)\\n mstore(0x80, p3)\\n writeString(0xa0, p2)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(uint256 p0, uint256 p1, bytes32 p2, bool p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(uint256,uint256,string,bool)`.\\n mstore(0x00, 0x7af6ab25)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, 0x80)\\n mstore(0x80, p3)\\n writeString(0xa0, p2)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(uint256 p0, uint256 p1, bytes32 p2, uint256 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(uint256,uint256,string,uint256)`.\\n mstore(0x00, 0x5da297eb)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, 0x80)\\n mstore(0x80, p3)\\n writeString(0xa0, p2)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(uint256 p0, uint256 p1, bytes32 p2, bytes32 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n // Selector of `log(uint256,uint256,string,string)`.\\n mstore(0x00, 0x27d8afd2)\\n mstore(0x20, p0)\\n mstore(0x40, p1)\\n mstore(0x60, 0x80)\\n mstore(0x80, 0xc0)\\n writeString(0xa0, p2)\\n writeString(0xe0, p3)\\n }\\n _sendLogPayload(0x1c, 0x104);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n }\\n }\\n\\n function log(uint256 p0, bytes32 p1, address p2, address p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(uint256,string,address,address)`.\\n mstore(0x00, 0x6168ed61)\\n mstore(0x20, p0)\\n mstore(0x40, 0x80)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n writeString(0xa0, p1)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(uint256 p0, bytes32 p1, address p2, bool p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(uint256,string,address,bool)`.\\n mstore(0x00, 0x90c30a56)\\n mstore(0x20, p0)\\n mstore(0x40, 0x80)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n writeString(0xa0, p1)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(uint256 p0, bytes32 p1, address p2, uint256 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(uint256,string,address,uint256)`.\\n mstore(0x00, 0xe8d3018d)\\n mstore(0x20, p0)\\n mstore(0x40, 0x80)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n writeString(0xa0, p1)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(uint256 p0, bytes32 p1, address p2, bytes32 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n // Selector of `log(uint256,string,address,string)`.\\n mstore(0x00, 0x9c3adfa1)\\n mstore(0x20, p0)\\n mstore(0x40, 0x80)\\n mstore(0x60, p2)\\n mstore(0x80, 0xc0)\\n writeString(0xa0, p1)\\n writeString(0xe0, p3)\\n }\\n _sendLogPayload(0x1c, 0x104);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n }\\n }\\n\\n function log(uint256 p0, bytes32 p1, bool p2, address p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(uint256,string,bool,address)`.\\n mstore(0x00, 0xae2ec581)\\n mstore(0x20, p0)\\n mstore(0x40, 0x80)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n writeString(0xa0, p1)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(uint256 p0, bytes32 p1, bool p2, bool p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(uint256,string,bool,bool)`.\\n mstore(0x00, 0xba535d9c)\\n mstore(0x20, p0)\\n mstore(0x40, 0x80)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n writeString(0xa0, p1)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(uint256 p0, bytes32 p1, bool p2, uint256 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(uint256,string,bool,uint256)`.\\n mstore(0x00, 0xcf009880)\\n mstore(0x20, p0)\\n mstore(0x40, 0x80)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n writeString(0xa0, p1)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(uint256 p0, bytes32 p1, bool p2, bytes32 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n // Selector of `log(uint256,string,bool,string)`.\\n mstore(0x00, 0xd2d423cd)\\n mstore(0x20, p0)\\n mstore(0x40, 0x80)\\n mstore(0x60, p2)\\n mstore(0x80, 0xc0)\\n writeString(0xa0, p1)\\n writeString(0xe0, p3)\\n }\\n _sendLogPayload(0x1c, 0x104);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n }\\n }\\n\\n function log(uint256 p0, bytes32 p1, uint256 p2, address p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(uint256,string,uint256,address)`.\\n mstore(0x00, 0x3b2279b4)\\n mstore(0x20, p0)\\n mstore(0x40, 0x80)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n writeString(0xa0, p1)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(uint256 p0, bytes32 p1, uint256 p2, bool p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(uint256,string,uint256,bool)`.\\n mstore(0x00, 0x691a8f74)\\n mstore(0x20, p0)\\n mstore(0x40, 0x80)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n writeString(0xa0, p1)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(uint256 p0, bytes32 p1, uint256 p2, uint256 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(uint256,string,uint256,uint256)`.\\n mstore(0x00, 0x82c25b74)\\n mstore(0x20, p0)\\n mstore(0x40, 0x80)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n writeString(0xa0, p1)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(uint256 p0, bytes32 p1, uint256 p2, bytes32 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n // Selector of `log(uint256,string,uint256,string)`.\\n mstore(0x00, 0xb7b914ca)\\n mstore(0x20, p0)\\n mstore(0x40, 0x80)\\n mstore(0x60, p2)\\n mstore(0x80, 0xc0)\\n writeString(0xa0, p1)\\n writeString(0xe0, p3)\\n }\\n _sendLogPayload(0x1c, 0x104);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n }\\n }\\n\\n function log(uint256 p0, bytes32 p1, bytes32 p2, address p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n // Selector of `log(uint256,string,string,address)`.\\n mstore(0x00, 0xd583c602)\\n mstore(0x20, p0)\\n mstore(0x40, 0x80)\\n mstore(0x60, 0xc0)\\n mstore(0x80, p3)\\n writeString(0xa0, p1)\\n writeString(0xe0, p2)\\n }\\n _sendLogPayload(0x1c, 0x104);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n }\\n }\\n\\n function log(uint256 p0, bytes32 p1, bytes32 p2, bool p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n // Selector of `log(uint256,string,string,bool)`.\\n mstore(0x00, 0xb3a6b6bd)\\n mstore(0x20, p0)\\n mstore(0x40, 0x80)\\n mstore(0x60, 0xc0)\\n mstore(0x80, p3)\\n writeString(0xa0, p1)\\n writeString(0xe0, p2)\\n }\\n _sendLogPayload(0x1c, 0x104);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n }\\n }\\n\\n function log(uint256 p0, bytes32 p1, bytes32 p2, uint256 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n // Selector of `log(uint256,string,string,uint256)`.\\n mstore(0x00, 0xb028c9bd)\\n mstore(0x20, p0)\\n mstore(0x40, 0x80)\\n mstore(0x60, 0xc0)\\n mstore(0x80, p3)\\n writeString(0xa0, p1)\\n writeString(0xe0, p2)\\n }\\n _sendLogPayload(0x1c, 0x104);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n }\\n }\\n\\n function log(uint256 p0, bytes32 p1, bytes32 p2, bytes32 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n bytes32 m9;\\n bytes32 m10;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n m9 := mload(0x120)\\n m10 := mload(0x140)\\n // Selector of `log(uint256,string,string,string)`.\\n mstore(0x00, 0x21ad0683)\\n mstore(0x20, p0)\\n mstore(0x40, 0x80)\\n mstore(0x60, 0xc0)\\n mstore(0x80, 0x100)\\n writeString(0xa0, p1)\\n writeString(0xe0, p2)\\n writeString(0x120, p3)\\n }\\n _sendLogPayload(0x1c, 0x144);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n mstore(0x120, m9)\\n mstore(0x140, m10)\\n }\\n }\\n\\n function log(bytes32 p0, address p1, address p2, address p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(string,address,address,address)`.\\n mstore(0x00, 0xed8f28f6)\\n mstore(0x20, 0x80)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n writeString(0xa0, p0)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(bytes32 p0, address p1, address p2, bool p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(string,address,address,bool)`.\\n mstore(0x00, 0xb59dbd60)\\n mstore(0x20, 0x80)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n writeString(0xa0, p0)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(bytes32 p0, address p1, address p2, uint256 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(string,address,address,uint256)`.\\n mstore(0x00, 0x8ef3f399)\\n mstore(0x20, 0x80)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n writeString(0xa0, p0)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(bytes32 p0, address p1, address p2, bytes32 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n // Selector of `log(string,address,address,string)`.\\n mstore(0x00, 0x800a1c67)\\n mstore(0x20, 0x80)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, 0xc0)\\n writeString(0xa0, p0)\\n writeString(0xe0, p3)\\n }\\n _sendLogPayload(0x1c, 0x104);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n }\\n }\\n\\n function log(bytes32 p0, address p1, bool p2, address p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(string,address,bool,address)`.\\n mstore(0x00, 0x223603bd)\\n mstore(0x20, 0x80)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n writeString(0xa0, p0)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(bytes32 p0, address p1, bool p2, bool p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(string,address,bool,bool)`.\\n mstore(0x00, 0x79884c2b)\\n mstore(0x20, 0x80)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n writeString(0xa0, p0)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(bytes32 p0, address p1, bool p2, uint256 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(string,address,bool,uint256)`.\\n mstore(0x00, 0x3e9f866a)\\n mstore(0x20, 0x80)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n writeString(0xa0, p0)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(bytes32 p0, address p1, bool p2, bytes32 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n // Selector of `log(string,address,bool,string)`.\\n mstore(0x00, 0x0454c079)\\n mstore(0x20, 0x80)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, 0xc0)\\n writeString(0xa0, p0)\\n writeString(0xe0, p3)\\n }\\n _sendLogPayload(0x1c, 0x104);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n }\\n }\\n\\n function log(bytes32 p0, address p1, uint256 p2, address p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(string,address,uint256,address)`.\\n mstore(0x00, 0x63fb8bc5)\\n mstore(0x20, 0x80)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n writeString(0xa0, p0)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(bytes32 p0, address p1, uint256 p2, bool p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(string,address,uint256,bool)`.\\n mstore(0x00, 0xfc4845f0)\\n mstore(0x20, 0x80)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n writeString(0xa0, p0)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(bytes32 p0, address p1, uint256 p2, uint256 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(string,address,uint256,uint256)`.\\n mstore(0x00, 0xf8f51b1e)\\n mstore(0x20, 0x80)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n writeString(0xa0, p0)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(bytes32 p0, address p1, uint256 p2, bytes32 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n // Selector of `log(string,address,uint256,string)`.\\n mstore(0x00, 0x5a477632)\\n mstore(0x20, 0x80)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, 0xc0)\\n writeString(0xa0, p0)\\n writeString(0xe0, p3)\\n }\\n _sendLogPayload(0x1c, 0x104);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n }\\n }\\n\\n function log(bytes32 p0, address p1, bytes32 p2, address p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n // Selector of `log(string,address,string,address)`.\\n mstore(0x00, 0xaabc9a31)\\n mstore(0x20, 0x80)\\n mstore(0x40, p1)\\n mstore(0x60, 0xc0)\\n mstore(0x80, p3)\\n writeString(0xa0, p0)\\n writeString(0xe0, p2)\\n }\\n _sendLogPayload(0x1c, 0x104);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n }\\n }\\n\\n function log(bytes32 p0, address p1, bytes32 p2, bool p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n // Selector of `log(string,address,string,bool)`.\\n mstore(0x00, 0x5f15d28c)\\n mstore(0x20, 0x80)\\n mstore(0x40, p1)\\n mstore(0x60, 0xc0)\\n mstore(0x80, p3)\\n writeString(0xa0, p0)\\n writeString(0xe0, p2)\\n }\\n _sendLogPayload(0x1c, 0x104);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n }\\n }\\n\\n function log(bytes32 p0, address p1, bytes32 p2, uint256 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n // Selector of `log(string,address,string,uint256)`.\\n mstore(0x00, 0x91d1112e)\\n mstore(0x20, 0x80)\\n mstore(0x40, p1)\\n mstore(0x60, 0xc0)\\n mstore(0x80, p3)\\n writeString(0xa0, p0)\\n writeString(0xe0, p2)\\n }\\n _sendLogPayload(0x1c, 0x104);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n }\\n }\\n\\n function log(bytes32 p0, address p1, bytes32 p2, bytes32 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n bytes32 m9;\\n bytes32 m10;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n m9 := mload(0x120)\\n m10 := mload(0x140)\\n // Selector of `log(string,address,string,string)`.\\n mstore(0x00, 0x245986f2)\\n mstore(0x20, 0x80)\\n mstore(0x40, p1)\\n mstore(0x60, 0xc0)\\n mstore(0x80, 0x100)\\n writeString(0xa0, p0)\\n writeString(0xe0, p2)\\n writeString(0x120, p3)\\n }\\n _sendLogPayload(0x1c, 0x144);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n mstore(0x120, m9)\\n mstore(0x140, m10)\\n }\\n }\\n\\n function log(bytes32 p0, bool p1, address p2, address p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(string,bool,address,address)`.\\n mstore(0x00, 0x33e9dd1d)\\n mstore(0x20, 0x80)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n writeString(0xa0, p0)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(bytes32 p0, bool p1, address p2, bool p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(string,bool,address,bool)`.\\n mstore(0x00, 0x958c28c6)\\n mstore(0x20, 0x80)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n writeString(0xa0, p0)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(bytes32 p0, bool p1, address p2, uint256 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(string,bool,address,uint256)`.\\n mstore(0x00, 0x5d08bb05)\\n mstore(0x20, 0x80)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n writeString(0xa0, p0)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(bytes32 p0, bool p1, address p2, bytes32 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n // Selector of `log(string,bool,address,string)`.\\n mstore(0x00, 0x2d8e33a4)\\n mstore(0x20, 0x80)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, 0xc0)\\n writeString(0xa0, p0)\\n writeString(0xe0, p3)\\n }\\n _sendLogPayload(0x1c, 0x104);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n }\\n }\\n\\n function log(bytes32 p0, bool p1, bool p2, address p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(string,bool,bool,address)`.\\n mstore(0x00, 0x7190a529)\\n mstore(0x20, 0x80)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n writeString(0xa0, p0)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(bytes32 p0, bool p1, bool p2, bool p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(string,bool,bool,bool)`.\\n mstore(0x00, 0x895af8c5)\\n mstore(0x20, 0x80)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n writeString(0xa0, p0)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(bytes32 p0, bool p1, bool p2, uint256 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(string,bool,bool,uint256)`.\\n mstore(0x00, 0x8e3f78a9)\\n mstore(0x20, 0x80)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n writeString(0xa0, p0)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(bytes32 p0, bool p1, bool p2, bytes32 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n // Selector of `log(string,bool,bool,string)`.\\n mstore(0x00, 0x9d22d5dd)\\n mstore(0x20, 0x80)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, 0xc0)\\n writeString(0xa0, p0)\\n writeString(0xe0, p3)\\n }\\n _sendLogPayload(0x1c, 0x104);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n }\\n }\\n\\n function log(bytes32 p0, bool p1, uint256 p2, address p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(string,bool,uint256,address)`.\\n mstore(0x00, 0x935e09bf)\\n mstore(0x20, 0x80)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n writeString(0xa0, p0)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(bytes32 p0, bool p1, uint256 p2, bool p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(string,bool,uint256,bool)`.\\n mstore(0x00, 0x8af7cf8a)\\n mstore(0x20, 0x80)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n writeString(0xa0, p0)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(bytes32 p0, bool p1, uint256 p2, uint256 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(string,bool,uint256,uint256)`.\\n mstore(0x00, 0x64b5bb67)\\n mstore(0x20, 0x80)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n writeString(0xa0, p0)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(bytes32 p0, bool p1, uint256 p2, bytes32 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n // Selector of `log(string,bool,uint256,string)`.\\n mstore(0x00, 0x742d6ee7)\\n mstore(0x20, 0x80)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, 0xc0)\\n writeString(0xa0, p0)\\n writeString(0xe0, p3)\\n }\\n _sendLogPayload(0x1c, 0x104);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n }\\n }\\n\\n function log(bytes32 p0, bool p1, bytes32 p2, address p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n // Selector of `log(string,bool,string,address)`.\\n mstore(0x00, 0xe0625b29)\\n mstore(0x20, 0x80)\\n mstore(0x40, p1)\\n mstore(0x60, 0xc0)\\n mstore(0x80, p3)\\n writeString(0xa0, p0)\\n writeString(0xe0, p2)\\n }\\n _sendLogPayload(0x1c, 0x104);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n }\\n }\\n\\n function log(bytes32 p0, bool p1, bytes32 p2, bool p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n // Selector of `log(string,bool,string,bool)`.\\n mstore(0x00, 0x3f8a701d)\\n mstore(0x20, 0x80)\\n mstore(0x40, p1)\\n mstore(0x60, 0xc0)\\n mstore(0x80, p3)\\n writeString(0xa0, p0)\\n writeString(0xe0, p2)\\n }\\n _sendLogPayload(0x1c, 0x104);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n }\\n }\\n\\n function log(bytes32 p0, bool p1, bytes32 p2, uint256 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n // Selector of `log(string,bool,string,uint256)`.\\n mstore(0x00, 0x24f91465)\\n mstore(0x20, 0x80)\\n mstore(0x40, p1)\\n mstore(0x60, 0xc0)\\n mstore(0x80, p3)\\n writeString(0xa0, p0)\\n writeString(0xe0, p2)\\n }\\n _sendLogPayload(0x1c, 0x104);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n }\\n }\\n\\n function log(bytes32 p0, bool p1, bytes32 p2, bytes32 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n bytes32 m9;\\n bytes32 m10;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n m9 := mload(0x120)\\n m10 := mload(0x140)\\n // Selector of `log(string,bool,string,string)`.\\n mstore(0x00, 0xa826caeb)\\n mstore(0x20, 0x80)\\n mstore(0x40, p1)\\n mstore(0x60, 0xc0)\\n mstore(0x80, 0x100)\\n writeString(0xa0, p0)\\n writeString(0xe0, p2)\\n writeString(0x120, p3)\\n }\\n _sendLogPayload(0x1c, 0x144);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n mstore(0x120, m9)\\n mstore(0x140, m10)\\n }\\n }\\n\\n function log(bytes32 p0, uint256 p1, address p2, address p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(string,uint256,address,address)`.\\n mstore(0x00, 0x5ea2b7ae)\\n mstore(0x20, 0x80)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n writeString(0xa0, p0)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(bytes32 p0, uint256 p1, address p2, bool p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(string,uint256,address,bool)`.\\n mstore(0x00, 0x82112a42)\\n mstore(0x20, 0x80)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n writeString(0xa0, p0)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(bytes32 p0, uint256 p1, address p2, uint256 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(string,uint256,address,uint256)`.\\n mstore(0x00, 0x4f04fdc6)\\n mstore(0x20, 0x80)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n writeString(0xa0, p0)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(bytes32 p0, uint256 p1, address p2, bytes32 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n // Selector of `log(string,uint256,address,string)`.\\n mstore(0x00, 0x9ffb2f93)\\n mstore(0x20, 0x80)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, 0xc0)\\n writeString(0xa0, p0)\\n writeString(0xe0, p3)\\n }\\n _sendLogPayload(0x1c, 0x104);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n }\\n }\\n\\n function log(bytes32 p0, uint256 p1, bool p2, address p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(string,uint256,bool,address)`.\\n mstore(0x00, 0xe0e95b98)\\n mstore(0x20, 0x80)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n writeString(0xa0, p0)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(bytes32 p0, uint256 p1, bool p2, bool p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(string,uint256,bool,bool)`.\\n mstore(0x00, 0x354c36d6)\\n mstore(0x20, 0x80)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n writeString(0xa0, p0)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(bytes32 p0, uint256 p1, bool p2, uint256 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(string,uint256,bool,uint256)`.\\n mstore(0x00, 0xe41b6f6f)\\n mstore(0x20, 0x80)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n writeString(0xa0, p0)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(bytes32 p0, uint256 p1, bool p2, bytes32 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n // Selector of `log(string,uint256,bool,string)`.\\n mstore(0x00, 0xabf73a98)\\n mstore(0x20, 0x80)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, 0xc0)\\n writeString(0xa0, p0)\\n writeString(0xe0, p3)\\n }\\n _sendLogPayload(0x1c, 0x104);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n }\\n }\\n\\n function log(bytes32 p0, uint256 p1, uint256 p2, address p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(string,uint256,uint256,address)`.\\n mstore(0x00, 0xe21de278)\\n mstore(0x20, 0x80)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n writeString(0xa0, p0)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(bytes32 p0, uint256 p1, uint256 p2, bool p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(string,uint256,uint256,bool)`.\\n mstore(0x00, 0x7626db92)\\n mstore(0x20, 0x80)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n writeString(0xa0, p0)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(bytes32 p0, uint256 p1, uint256 p2, uint256 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n // Selector of `log(string,uint256,uint256,uint256)`.\\n mstore(0x00, 0xa7a87853)\\n mstore(0x20, 0x80)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n writeString(0xa0, p0)\\n }\\n _sendLogPayload(0x1c, 0xc4);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n }\\n }\\n\\n function log(bytes32 p0, uint256 p1, uint256 p2, bytes32 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n // Selector of `log(string,uint256,uint256,string)`.\\n mstore(0x00, 0x854b3496)\\n mstore(0x20, 0x80)\\n mstore(0x40, p1)\\n mstore(0x60, p2)\\n mstore(0x80, 0xc0)\\n writeString(0xa0, p0)\\n writeString(0xe0, p3)\\n }\\n _sendLogPayload(0x1c, 0x104);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n }\\n }\\n\\n function log(bytes32 p0, uint256 p1, bytes32 p2, address p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n // Selector of `log(string,uint256,string,address)`.\\n mstore(0x00, 0x7c4632a4)\\n mstore(0x20, 0x80)\\n mstore(0x40, p1)\\n mstore(0x60, 0xc0)\\n mstore(0x80, p3)\\n writeString(0xa0, p0)\\n writeString(0xe0, p2)\\n }\\n _sendLogPayload(0x1c, 0x104);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n }\\n }\\n\\n function log(bytes32 p0, uint256 p1, bytes32 p2, bool p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n // Selector of `log(string,uint256,string,bool)`.\\n mstore(0x00, 0x7d24491d)\\n mstore(0x20, 0x80)\\n mstore(0x40, p1)\\n mstore(0x60, 0xc0)\\n mstore(0x80, p3)\\n writeString(0xa0, p0)\\n writeString(0xe0, p2)\\n }\\n _sendLogPayload(0x1c, 0x104);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n }\\n }\\n\\n function log(bytes32 p0, uint256 p1, bytes32 p2, uint256 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n // Selector of `log(string,uint256,string,uint256)`.\\n mstore(0x00, 0xc67ea9d1)\\n mstore(0x20, 0x80)\\n mstore(0x40, p1)\\n mstore(0x60, 0xc0)\\n mstore(0x80, p3)\\n writeString(0xa0, p0)\\n writeString(0xe0, p2)\\n }\\n _sendLogPayload(0x1c, 0x104);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n }\\n }\\n\\n function log(bytes32 p0, uint256 p1, bytes32 p2, bytes32 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n bytes32 m9;\\n bytes32 m10;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n m9 := mload(0x120)\\n m10 := mload(0x140)\\n // Selector of `log(string,uint256,string,string)`.\\n mstore(0x00, 0x5ab84e1f)\\n mstore(0x20, 0x80)\\n mstore(0x40, p1)\\n mstore(0x60, 0xc0)\\n mstore(0x80, 0x100)\\n writeString(0xa0, p0)\\n writeString(0xe0, p2)\\n writeString(0x120, p3)\\n }\\n _sendLogPayload(0x1c, 0x144);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n mstore(0x120, m9)\\n mstore(0x140, m10)\\n }\\n }\\n\\n function log(bytes32 p0, bytes32 p1, address p2, address p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n // Selector of `log(string,string,address,address)`.\\n mstore(0x00, 0x439c7bef)\\n mstore(0x20, 0x80)\\n mstore(0x40, 0xc0)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n writeString(0xa0, p0)\\n writeString(0xe0, p1)\\n }\\n _sendLogPayload(0x1c, 0x104);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n }\\n }\\n\\n function log(bytes32 p0, bytes32 p1, address p2, bool p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n // Selector of `log(string,string,address,bool)`.\\n mstore(0x00, 0x5ccd4e37)\\n mstore(0x20, 0x80)\\n mstore(0x40, 0xc0)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n writeString(0xa0, p0)\\n writeString(0xe0, p1)\\n }\\n _sendLogPayload(0x1c, 0x104);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n }\\n }\\n\\n function log(bytes32 p0, bytes32 p1, address p2, uint256 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n // Selector of `log(string,string,address,uint256)`.\\n mstore(0x00, 0x7cc3c607)\\n mstore(0x20, 0x80)\\n mstore(0x40, 0xc0)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n writeString(0xa0, p0)\\n writeString(0xe0, p1)\\n }\\n _sendLogPayload(0x1c, 0x104);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n }\\n }\\n\\n function log(bytes32 p0, bytes32 p1, address p2, bytes32 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n bytes32 m9;\\n bytes32 m10;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n m9 := mload(0x120)\\n m10 := mload(0x140)\\n // Selector of `log(string,string,address,string)`.\\n mstore(0x00, 0xeb1bff80)\\n mstore(0x20, 0x80)\\n mstore(0x40, 0xc0)\\n mstore(0x60, p2)\\n mstore(0x80, 0x100)\\n writeString(0xa0, p0)\\n writeString(0xe0, p1)\\n writeString(0x120, p3)\\n }\\n _sendLogPayload(0x1c, 0x144);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n mstore(0x120, m9)\\n mstore(0x140, m10)\\n }\\n }\\n\\n function log(bytes32 p0, bytes32 p1, bool p2, address p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n // Selector of `log(string,string,bool,address)`.\\n mstore(0x00, 0xc371c7db)\\n mstore(0x20, 0x80)\\n mstore(0x40, 0xc0)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n writeString(0xa0, p0)\\n writeString(0xe0, p1)\\n }\\n _sendLogPayload(0x1c, 0x104);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n }\\n }\\n\\n function log(bytes32 p0, bytes32 p1, bool p2, bool p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n // Selector of `log(string,string,bool,bool)`.\\n mstore(0x00, 0x40785869)\\n mstore(0x20, 0x80)\\n mstore(0x40, 0xc0)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n writeString(0xa0, p0)\\n writeString(0xe0, p1)\\n }\\n _sendLogPayload(0x1c, 0x104);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n }\\n }\\n\\n function log(bytes32 p0, bytes32 p1, bool p2, uint256 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n // Selector of `log(string,string,bool,uint256)`.\\n mstore(0x00, 0xd6aefad2)\\n mstore(0x20, 0x80)\\n mstore(0x40, 0xc0)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n writeString(0xa0, p0)\\n writeString(0xe0, p1)\\n }\\n _sendLogPayload(0x1c, 0x104);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n }\\n }\\n\\n function log(bytes32 p0, bytes32 p1, bool p2, bytes32 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n bytes32 m9;\\n bytes32 m10;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n m9 := mload(0x120)\\n m10 := mload(0x140)\\n // Selector of `log(string,string,bool,string)`.\\n mstore(0x00, 0x5e84b0ea)\\n mstore(0x20, 0x80)\\n mstore(0x40, 0xc0)\\n mstore(0x60, p2)\\n mstore(0x80, 0x100)\\n writeString(0xa0, p0)\\n writeString(0xe0, p1)\\n writeString(0x120, p3)\\n }\\n _sendLogPayload(0x1c, 0x144);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n mstore(0x120, m9)\\n mstore(0x140, m10)\\n }\\n }\\n\\n function log(bytes32 p0, bytes32 p1, uint256 p2, address p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n // Selector of `log(string,string,uint256,address)`.\\n mstore(0x00, 0x1023f7b2)\\n mstore(0x20, 0x80)\\n mstore(0x40, 0xc0)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n writeString(0xa0, p0)\\n writeString(0xe0, p1)\\n }\\n _sendLogPayload(0x1c, 0x104);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n }\\n }\\n\\n function log(bytes32 p0, bytes32 p1, uint256 p2, bool p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n // Selector of `log(string,string,uint256,bool)`.\\n mstore(0x00, 0xc3a8a654)\\n mstore(0x20, 0x80)\\n mstore(0x40, 0xc0)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n writeString(0xa0, p0)\\n writeString(0xe0, p1)\\n }\\n _sendLogPayload(0x1c, 0x104);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n }\\n }\\n\\n function log(bytes32 p0, bytes32 p1, uint256 p2, uint256 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n // Selector of `log(string,string,uint256,uint256)`.\\n mstore(0x00, 0xf45d7d2c)\\n mstore(0x20, 0x80)\\n mstore(0x40, 0xc0)\\n mstore(0x60, p2)\\n mstore(0x80, p3)\\n writeString(0xa0, p0)\\n writeString(0xe0, p1)\\n }\\n _sendLogPayload(0x1c, 0x104);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n }\\n }\\n\\n function log(bytes32 p0, bytes32 p1, uint256 p2, bytes32 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n bytes32 m9;\\n bytes32 m10;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n m9 := mload(0x120)\\n m10 := mload(0x140)\\n // Selector of `log(string,string,uint256,string)`.\\n mstore(0x00, 0x5d1a971a)\\n mstore(0x20, 0x80)\\n mstore(0x40, 0xc0)\\n mstore(0x60, p2)\\n mstore(0x80, 0x100)\\n writeString(0xa0, p0)\\n writeString(0xe0, p1)\\n writeString(0x120, p3)\\n }\\n _sendLogPayload(0x1c, 0x144);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n mstore(0x120, m9)\\n mstore(0x140, m10)\\n }\\n }\\n\\n function log(bytes32 p0, bytes32 p1, bytes32 p2, address p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n bytes32 m9;\\n bytes32 m10;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n m9 := mload(0x120)\\n m10 := mload(0x140)\\n // Selector of `log(string,string,string,address)`.\\n mstore(0x00, 0x6d572f44)\\n mstore(0x20, 0x80)\\n mstore(0x40, 0xc0)\\n mstore(0x60, 0x100)\\n mstore(0x80, p3)\\n writeString(0xa0, p0)\\n writeString(0xe0, p1)\\n writeString(0x120, p2)\\n }\\n _sendLogPayload(0x1c, 0x144);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n mstore(0x120, m9)\\n mstore(0x140, m10)\\n }\\n }\\n\\n function log(bytes32 p0, bytes32 p1, bytes32 p2, bool p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n bytes32 m9;\\n bytes32 m10;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n m9 := mload(0x120)\\n m10 := mload(0x140)\\n // Selector of `log(string,string,string,bool)`.\\n mstore(0x00, 0x2c1754ed)\\n mstore(0x20, 0x80)\\n mstore(0x40, 0xc0)\\n mstore(0x60, 0x100)\\n mstore(0x80, p3)\\n writeString(0xa0, p0)\\n writeString(0xe0, p1)\\n writeString(0x120, p2)\\n }\\n _sendLogPayload(0x1c, 0x144);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n mstore(0x120, m9)\\n mstore(0x140, m10)\\n }\\n }\\n\\n function log(bytes32 p0, bytes32 p1, bytes32 p2, uint256 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n bytes32 m9;\\n bytes32 m10;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n m9 := mload(0x120)\\n m10 := mload(0x140)\\n // Selector of `log(string,string,string,uint256)`.\\n mstore(0x00, 0x8eafb02b)\\n mstore(0x20, 0x80)\\n mstore(0x40, 0xc0)\\n mstore(0x60, 0x100)\\n mstore(0x80, p3)\\n writeString(0xa0, p0)\\n writeString(0xe0, p1)\\n writeString(0x120, p2)\\n }\\n _sendLogPayload(0x1c, 0x144);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n mstore(0x120, m9)\\n mstore(0x140, m10)\\n }\\n }\\n\\n function log(bytes32 p0, bytes32 p1, bytes32 p2, bytes32 p3) internal pure {\\n bytes32 m0;\\n bytes32 m1;\\n bytes32 m2;\\n bytes32 m3;\\n bytes32 m4;\\n bytes32 m5;\\n bytes32 m6;\\n bytes32 m7;\\n bytes32 m8;\\n bytes32 m9;\\n bytes32 m10;\\n bytes32 m11;\\n bytes32 m12;\\n /// @solidity memory-safe-assembly\\n assembly {\\n function writeString(pos, w) {\\n let length := 0\\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\\n mstore(pos, length)\\n let shift := sub(256, shl(3, length))\\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\\n }\\n m0 := mload(0x00)\\n m1 := mload(0x20)\\n m2 := mload(0x40)\\n m3 := mload(0x60)\\n m4 := mload(0x80)\\n m5 := mload(0xa0)\\n m6 := mload(0xc0)\\n m7 := mload(0xe0)\\n m8 := mload(0x100)\\n m9 := mload(0x120)\\n m10 := mload(0x140)\\n m11 := mload(0x160)\\n m12 := mload(0x180)\\n // Selector of `log(string,string,string,string)`.\\n mstore(0x00, 0xde68f20a)\\n mstore(0x20, 0x80)\\n mstore(0x40, 0xc0)\\n mstore(0x60, 0x100)\\n mstore(0x80, 0x140)\\n writeString(0xa0, p0)\\n writeString(0xe0, p1)\\n writeString(0x120, p2)\\n writeString(0x160, p3)\\n }\\n _sendLogPayload(0x1c, 0x184);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, m0)\\n mstore(0x20, m1)\\n mstore(0x40, m2)\\n mstore(0x60, m3)\\n mstore(0x80, m4)\\n mstore(0xa0, m5)\\n mstore(0xc0, m6)\\n mstore(0xe0, m7)\\n mstore(0x100, m8)\\n mstore(0x120, m9)\\n mstore(0x140, m10)\\n mstore(0x160, m11)\\n mstore(0x180, m12)\\n }\\n }\\n}\\n\",\"keccak256\":\"0xbef9786cb49d3eade757bad87568c49c8c8f35721f0193c95ffb055d9e466e11\",\"license\":\"MIT\"},\"scripts/FetchChainInfo.s.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\nimport { Script } from \\\"forge-std/Script.sol\\\";\\nimport { GameTypes, GameType } from \\\"src/dispute/lib/Types.sol\\\";\\n\\n/// @notice Contains getters for arbitrary methods from all L1 contracts, including legacy getters\\n/// that have since been deprecated.\\ninterface IFetcher {\\n function guardian() external view returns (address);\\n function GUARDIAN() external view returns (address);\\n function systemConfig() external view returns (address);\\n function SYSTEM_CONFIG() external view returns (address);\\n function disputeGameFactory() external view returns (address);\\n function ethLockbox() external view returns (address);\\n function superchainConfig() external view returns (address);\\n function messenger() external view returns (address);\\n function addressManager() external view returns (address);\\n function PORTAL() external view returns (address);\\n function portal() external view returns (address);\\n function l1ERC721Bridge() external view returns (address);\\n function optimismMintableERC20Factory() external view returns (address);\\n function gameImpls(GameType _gameType) external view returns (address);\\n function respectedGameType() external view returns (GameType);\\n function anchorStateRegistry() external view returns (address);\\n function L2_ORACLE() external view returns (address);\\n function l2Oracle() external view returns (address);\\n function vm() external view returns (address);\\n function oracle() external view returns (address);\\n function challenger() external view returns (address);\\n function proposer() external view returns (address);\\n function PROPOSER() external view returns (address);\\n function batcherHash() external view returns (bytes32);\\n function admin() external view returns (address);\\n function owner() external view returns (address);\\n function unsafeBlockSigner() external view returns (address);\\n function weth() external view returns (address);\\n}\\n\\ncontract FetchChainInfoInput {\\n address internal _systemConfigProxy;\\n address internal _l1StandardBridgeProxy;\\n\\n function set(bytes4 _sel, address _addr) public {\\n require(_addr != address(0), \\\"FetchChainInfoInput: cannot set zero address\\\");\\n if (_sel == this.systemConfigProxy.selector) _systemConfigProxy = _addr;\\n else if (_sel == this.l1StandardBridgeProxy.selector) _l1StandardBridgeProxy = _addr;\\n else revert(\\\"FetchChainInfoInput: unknown selector\\\");\\n }\\n\\n function systemConfigProxy() public view returns (address) {\\n require(_systemConfigProxy != address(0), \\\"FetchChainInfoInput: systemConfigProxy not set\\\");\\n return _systemConfigProxy;\\n }\\n\\n function l1StandardBridgeProxy() public view returns (address) {\\n require(_l1StandardBridgeProxy != address(0), \\\"FetchChainInfoInput: l1StandardBridgeProxy not set\\\");\\n return _l1StandardBridgeProxy;\\n }\\n}\\n\\ncontract FetchChainInfoOutput {\\n // contract addresses\\n // - SuperchainContracts\\n address internal _superchainConfigProxy;\\n // - ImplementationsContracts\\n address internal _mipsImpl;\\n address internal _preimageOracleImpl;\\n // - OpChainContracts\\n address internal _addressManagerImpl;\\n address internal _ethLockboxProxy;\\n address internal _l1CrossDomainMessengerProxy;\\n address internal _l1Erc721BridgeProxy;\\n address internal _l1StandardBridgeProxy;\\n address internal _l2OutputOracleProxy;\\n address internal _optimismMintableErc20FactoryProxy;\\n address internal _optimismPortalProxy;\\n address internal _systemConfigProxy;\\n address internal _opChainProxyAdminImpl;\\n address internal _anchorStateRegistryProxy;\\n address internal _delayedWethPermissionedGameProxy;\\n address internal _delayedWethPermissionlessGameProxy;\\n address internal _disputeGameFactoryProxy;\\n address internal _faultDisputeGameImpl;\\n address internal _faultDisputeGameCannonKonaImpl;\\n address internal _permissionedDisputeGameImpl;\\n\\n // roles\\n address internal _systemConfigOwner;\\n address internal _opChainProxyAdminOwner;\\n address internal _opChainGuardian;\\n address internal _challenger;\\n address internal _proposer;\\n address internal _unsafeBlockSigner;\\n address internal _batchSubmitter;\\n\\n // fault proof status\\n bool internal _permissioned;\\n bool internal _permissionless;\\n GameType internal _respectedGameType;\\n\\n function set(bytes4 _sel, address _addr) public {\\n // SuperchainContracts\\n if (_sel == this.superchainConfigProxy.selector) _superchainConfigProxy = _addr;\\n // - ImplementationsContracts\\n else if (_sel == this.mipsImpl.selector) _mipsImpl = _addr;\\n else if (_sel == this.preimageOracleImpl.selector) _preimageOracleImpl = _addr;\\n // - OpChainContracts\\n else if (_sel == this.addressManagerImpl.selector) _addressManagerImpl = _addr;\\n else if (_sel == this.ethLockboxProxy.selector) _ethLockboxProxy = _addr;\\n else if (_sel == this.l1CrossDomainMessengerProxy.selector) _l1CrossDomainMessengerProxy = _addr;\\n else if (_sel == this.l1Erc721BridgeProxy.selector) _l1Erc721BridgeProxy = _addr;\\n else if (_sel == this.l1StandardBridgeProxy.selector) _l1StandardBridgeProxy = _addr;\\n else if (_sel == this.l2OutputOracleProxy.selector) _l2OutputOracleProxy = _addr;\\n else if (_sel == this.optimismMintableErc20FactoryProxy.selector) _optimismMintableErc20FactoryProxy = _addr;\\n else if (_sel == this.optimismPortalProxy.selector) _optimismPortalProxy = _addr;\\n else if (_sel == this.systemConfigProxy.selector) _systemConfigProxy = _addr;\\n else if (_sel == this.opChainProxyAdminImpl.selector) _opChainProxyAdminImpl = _addr;\\n else if (_sel == this.anchorStateRegistryProxy.selector) _anchorStateRegistryProxy = _addr;\\n else if (_sel == this.delayedWethPermissionedGameProxy.selector) _delayedWethPermissionedGameProxy = _addr;\\n else if (_sel == this.delayedWethPermissionlessGameProxy.selector) _delayedWethPermissionlessGameProxy = _addr;\\n else if (_sel == this.disputeGameFactoryProxy.selector) _disputeGameFactoryProxy = _addr;\\n else if (_sel == this.faultDisputeGameImpl.selector) _faultDisputeGameImpl = _addr;\\n else if (_sel == this.faultDisputeGameCannonKonaImpl.selector) _faultDisputeGameCannonKonaImpl = _addr;\\n else if (_sel == this.permissionedDisputeGameImpl.selector) _permissionedDisputeGameImpl = _addr;\\n // roles\\n else if (_sel == this.systemConfigOwner.selector) _systemConfigOwner = _addr;\\n else if (_sel == this.opChainProxyAdminOwner.selector) _opChainProxyAdminOwner = _addr;\\n else if (_sel == this.opChainGuardian.selector) _opChainGuardian = _addr;\\n else if (_sel == this.challenger.selector) _challenger = _addr;\\n else if (_sel == this.proposer.selector) _proposer = _addr;\\n else if (_sel == this.unsafeBlockSigner.selector) _unsafeBlockSigner = _addr;\\n else if (_sel == this.batchSubmitter.selector) _batchSubmitter = _addr;\\n else revert(\\\"FetchChainInfoOutput: unknown address selector test\\\");\\n }\\n\\n function set(bytes4 _sel, bool _bool) public {\\n if (_sel == this.permissioned.selector) _permissioned = _bool;\\n else if (_sel == this.permissionless.selector) _permissionless = _bool;\\n else revert(\\\"FetchChainInfoOutput: unknown bool selector\\\");\\n }\\n\\n function set(bytes4 _sel, GameType _gameType) public {\\n if (_sel == this.respectedGameType.selector) _respectedGameType = _gameType;\\n else revert(\\\"FetchChainInfoOutput: unknown GameType selector\\\");\\n }\\n\\n function addressManagerImpl() public view returns (address) {\\n require(_addressManagerImpl != address(0), \\\"FetchChainInfoOutput: addressManagerImpl not set\\\");\\n return _addressManagerImpl;\\n }\\n\\n function ethLockboxProxy() public view returns (address) {\\n return _ethLockboxProxy;\\n }\\n\\n function l1CrossDomainMessengerProxy() public view returns (address) {\\n require(_l1CrossDomainMessengerProxy != address(0), \\\"FetchChainInfoOutput: l1CrossDomainMessengerProxy not set\\\");\\n return _l1CrossDomainMessengerProxy;\\n }\\n\\n function l1Erc721BridgeProxy() public view returns (address) {\\n require(_l1Erc721BridgeProxy != address(0), \\\"FetchChainInfoOutput: l1Erc721BridgeProxy not set\\\");\\n return _l1Erc721BridgeProxy;\\n }\\n\\n function l1StandardBridgeProxy() public view returns (address) {\\n require(_l1StandardBridgeProxy != address(0), \\\"FetchChainInfoOutput: l1StandardBridgeProxy not set\\\");\\n return _l1StandardBridgeProxy;\\n }\\n\\n function l2OutputOracleProxy() public view returns (address) {\\n require(_l2OutputOracleProxy != address(0), \\\"FetchChainInfoOutput: l2OutputOracleProxy not set\\\");\\n return _l2OutputOracleProxy;\\n }\\n\\n function optimismMintableErc20FactoryProxy() public view returns (address) {\\n require(\\n _optimismMintableErc20FactoryProxy != address(0),\\n \\\"FetchChainInfoOutput: optimismMintableErc20FactoryProxy not set\\\"\\n );\\n return _optimismMintableErc20FactoryProxy;\\n }\\n\\n function optimismPortalProxy() public view returns (address) {\\n require(_optimismPortalProxy != address(0), \\\"FetchChainInfoOutput: optimismPortalProxy not set\\\");\\n return _optimismPortalProxy;\\n }\\n\\n function systemConfigProxy() public view returns (address) {\\n require(_systemConfigProxy != address(0), \\\"FetchChainInfoOutput: systemConfigProxy not set\\\");\\n return _systemConfigProxy;\\n }\\n\\n function opChainProxyAdminImpl() public view returns (address) {\\n require(_opChainProxyAdminImpl != address(0), \\\"FetchChainInfoOutput: opChainProxyAdminImpl not set\\\");\\n return _opChainProxyAdminImpl;\\n }\\n\\n function superchainConfigProxy() public view returns (address) {\\n require(_superchainConfigProxy != address(0), \\\"FetchChainInfoOutput: superchainConfigProxy not set\\\");\\n return _superchainConfigProxy;\\n }\\n\\n function anchorStateRegistryProxy() public view returns (address) {\\n require(_anchorStateRegistryProxy != address(0), \\\"FetchChainInfoOutput: anchorStateRegistryProxy not set\\\");\\n return _anchorStateRegistryProxy;\\n }\\n\\n function delayedWethPermissionedGameProxy() public view returns (address) {\\n return _delayedWethPermissionedGameProxy;\\n }\\n\\n function delayedWethPermissionlessGameProxy() public view returns (address) {\\n return _delayedWethPermissionlessGameProxy;\\n }\\n\\n function disputeGameFactoryProxy() public view returns (address) {\\n return _disputeGameFactoryProxy;\\n }\\n\\n function faultDisputeGameImpl() public view returns (address) {\\n require(_faultDisputeGameImpl != address(0), \\\"FetchChainInfoOutput: faultDisputeGameImpl not set\\\");\\n return _faultDisputeGameImpl;\\n }\\n\\n function faultDisputeGameCannonKonaImpl() public view returns (address) {\\n require(\\n _faultDisputeGameCannonKonaImpl != address(0),\\n \\\"FetchChainInfoOutput: faultDisputeGameCannonKonaImpl not set\\\"\\n );\\n return _faultDisputeGameCannonKonaImpl;\\n }\\n\\n function mipsImpl() public view returns (address) {\\n require(_mipsImpl != address(0), \\\"FetchChainInfoOutput: mipsImpl not set\\\");\\n return _mipsImpl;\\n }\\n\\n function permissionedDisputeGameImpl() public view returns (address) {\\n require(_permissionedDisputeGameImpl != address(0), \\\"FetchChainInfoOutput: permissionedDisputeGameImpl not set\\\");\\n return _permissionedDisputeGameImpl;\\n }\\n\\n function preimageOracleImpl() public view returns (address) {\\n require(_preimageOracleImpl != address(0), \\\"FetchChainInfoOutput: preimageOracleImpl not set\\\");\\n return _preimageOracleImpl;\\n }\\n\\n function systemConfigOwner() public view returns (address) {\\n require(_systemConfigOwner != address(0), \\\"FetchChainInfoOutput: systemConfigOwner not set\\\");\\n return _systemConfigOwner;\\n }\\n\\n function opChainProxyAdminOwner() public view returns (address) {\\n require(_opChainProxyAdminOwner != address(0), \\\"FetchChainInfoOutput: opChainProxyAdminOwner not set\\\");\\n return _opChainProxyAdminOwner;\\n }\\n\\n function opChainGuardian() public view returns (address) {\\n require(_opChainGuardian != address(0), \\\"FetchChainInfoOutput: opChainGuardian not set\\\");\\n return _opChainGuardian;\\n }\\n\\n function challenger() public view returns (address) {\\n require(_challenger != address(0), \\\"FetchChainInfoOutput: challenger not set\\\");\\n return _challenger;\\n }\\n\\n function proposer() public view returns (address) {\\n require(_proposer != address(0), \\\"FetchChainInfoOutput: proposer not set\\\");\\n return _proposer;\\n }\\n\\n function unsafeBlockSigner() public view returns (address) {\\n require(_unsafeBlockSigner != address(0), \\\"FetchChainInfoOutput: unsafeBlockSigner not set\\\");\\n return _unsafeBlockSigner;\\n }\\n\\n function batchSubmitter() public view returns (address) {\\n require(_batchSubmitter != address(0), \\\"FetchChainInfoOutput: batchSubmitter not set\\\");\\n return _batchSubmitter;\\n }\\n\\n function permissioned() public view returns (bool) {\\n return _permissioned;\\n }\\n\\n function permissionless() public view returns (bool) {\\n return _permissionless;\\n }\\n\\n function respectedGameType() public view returns (GameType) {\\n return _respectedGameType;\\n }\\n}\\n\\ncontract FetchChainInfo is Script {\\n function run(FetchChainInfoInput _fi, FetchChainInfoOutput _fo) public {\\n _processSystemConfig(_fi, _fo);\\n _processMessengerAndPortal(_fi, _fo);\\n _processFaultProofs(_fo);\\n }\\n\\n function _processSystemConfig(FetchChainInfoInput _fi, FetchChainInfoOutput _fo) internal {\\n address systemConfigProxy = _fi.systemConfigProxy();\\n _fo.set(_fo.systemConfigProxy.selector, systemConfigProxy);\\n\\n address systemConfigOwner = IFetcher(systemConfigProxy).owner();\\n _fo.set(_fo.systemConfigOwner.selector, systemConfigOwner);\\n\\n address unsafeBlockSigner = IFetcher(systemConfigProxy).unsafeBlockSigner();\\n _fo.set(_fo.unsafeBlockSigner.selector, unsafeBlockSigner);\\n\\n address batchSubmitter = _getBatchSubmitter(systemConfigProxy);\\n _fo.set(_fo.batchSubmitter.selector, batchSubmitter);\\n\\n address opChainProxyAdminImpl = _getProxyAdmin(systemConfigProxy);\\n _fo.set(_fo.opChainProxyAdminImpl.selector, opChainProxyAdminImpl);\\n\\n address opChainProxyAdminOwner = IFetcher(opChainProxyAdminImpl).owner();\\n _fo.set(_fo.opChainProxyAdminOwner.selector, opChainProxyAdminOwner);\\n\\n address l1Erc721BridgeProxy = _getL1ERC721BridgeProxy(systemConfigProxy);\\n _fo.set(_fo.l1Erc721BridgeProxy.selector, l1Erc721BridgeProxy);\\n\\n address optimismMintableErc20FactoryProxy = _getOptimismMintableERC20FactoryProxy(systemConfigProxy);\\n _fo.set(_fo.optimismMintableErc20FactoryProxy.selector, optimismMintableErc20FactoryProxy);\\n }\\n\\n function _processMessengerAndPortal(FetchChainInfoInput _fi, FetchChainInfoOutput _fo) internal {\\n address l1StandardBridgeProxy = _fi.l1StandardBridgeProxy();\\n _fo.set(_fo.l1StandardBridgeProxy.selector, l1StandardBridgeProxy);\\n\\n address l1CrossDomainMessengerProxy = IFetcher(l1StandardBridgeProxy).messenger();\\n _fo.set(_fo.l1CrossDomainMessengerProxy.selector, l1CrossDomainMessengerProxy);\\n\\n address addressManagerImpl = _getAddressManager(l1CrossDomainMessengerProxy);\\n _fo.set(_fo.addressManagerImpl.selector, addressManagerImpl);\\n\\n address optimismPortalProxy = _getOptimismPortalProxy(l1CrossDomainMessengerProxy);\\n _fo.set(_fo.optimismPortalProxy.selector, optimismPortalProxy);\\n\\n address opChainGuardian = _getGuardian(optimismPortalProxy);\\n _fo.set(_fo.opChainGuardian.selector, opChainGuardian);\\n\\n address ethLockboxProxy = _getEthLockboxProxy(optimismPortalProxy);\\n _fo.set(_fo.ethLockboxProxy.selector, ethLockboxProxy);\\n\\n address superchainConfigProxy = _getSuperchainConfigProxy(optimismPortalProxy);\\n _fo.set(_fo.superchainConfigProxy.selector, superchainConfigProxy);\\n }\\n\\n function _processFaultProofs(FetchChainInfoOutput _fo) internal {\\n address systemConfigProxy = _fo.systemConfigProxy();\\n address optimismPortalProxy = _fo.optimismPortalProxy();\\n\\n try IFetcher(optimismPortalProxy).respectedGameType() returns (GameType gameType_) {\\n _fo.set(_fo.respectedGameType.selector, gameType_);\\n } catch {\\n // default respectedGameType to uint32.max since 0 == CANNON\\n _fo.set(_fo.respectedGameType.selector, GameType.wrap(type(uint32).max));\\n address l2OutputOracleProxy;\\n try IFetcher(optimismPortalProxy).l2Oracle() returns (address l2Oracle_) {\\n l2OutputOracleProxy = l2Oracle_;\\n } catch {\\n l2OutputOracleProxy = IFetcher(optimismPortalProxy).L2_ORACLE();\\n }\\n _fo.set(_fo.l2OutputOracleProxy.selector, l2OutputOracleProxy);\\n\\n address proposer = IFetcher(l2OutputOracleProxy).PROPOSER();\\n _fo.set(_fo.proposer.selector, proposer);\\n\\n // no fault proofs installed so we're done\\n return;\\n }\\n\\n address disputeGameFactoryProxy = _getDisputeGameFactoryProxy(systemConfigProxy);\\n if (disputeGameFactoryProxy != address(0)) {\\n _fo.set(_fo.disputeGameFactoryProxy.selector, disputeGameFactoryProxy);\\n\\n address permissionedDisputeGameImpl = _getPermissionedDisputeGame(disputeGameFactoryProxy);\\n if (permissionedDisputeGameImpl != address(0)) {\\n // permissioned fault proofs installed\\n _fo.set(_fo.permissioned.selector, true);\\n _fo.set(_fo.permissionedDisputeGameImpl.selector, permissionedDisputeGameImpl);\\n\\n address challenger = IFetcher(permissionedDisputeGameImpl).challenger();\\n _fo.set(_fo.challenger.selector, challenger);\\n\\n address anchorStateRegistryProxy = IFetcher(permissionedDisputeGameImpl).anchorStateRegistry();\\n _fo.set(_fo.anchorStateRegistryProxy.selector, anchorStateRegistryProxy);\\n\\n address proposer = IFetcher(permissionedDisputeGameImpl).proposer();\\n _fo.set(_fo.proposer.selector, proposer);\\n\\n address delayedWethPermissionedGameProxy = _getDelayedWETHProxy(permissionedDisputeGameImpl);\\n _fo.set(_fo.delayedWethPermissionedGameProxy.selector, delayedWethPermissionedGameProxy);\\n\\n address mipsImpl = IFetcher(permissionedDisputeGameImpl).vm();\\n _fo.set(_fo.mipsImpl.selector, mipsImpl);\\n\\n address preimageOracleImpl = IFetcher(mipsImpl).oracle();\\n _fo.set(_fo.preimageOracleImpl.selector, preimageOracleImpl);\\n }\\n\\n address faultDisputeGameImpl = _getFaultDisputeGame(disputeGameFactoryProxy);\\n if (faultDisputeGameImpl != address(0)) {\\n // permissionless fault proofs installed\\n _fo.set(_fo.faultDisputeGameImpl.selector, faultDisputeGameImpl);\\n _fo.set(_fo.permissionless.selector, true);\\n\\n address delayedWethPermissionlessGameProxy = _getDelayedWETHProxy(faultDisputeGameImpl);\\n _fo.set(_fo.delayedWethPermissionlessGameProxy.selector, delayedWethPermissionlessGameProxy);\\n }\\n\\n address faultDisputeGameCannonKonaImpl =\\n _getFaultDisputeGame(disputeGameFactoryProxy, GameTypes.CANNON_KONA);\\n if (faultDisputeGameCannonKonaImpl != address(0)) {\\n _fo.set(_fo.faultDisputeGameCannonKonaImpl.selector, faultDisputeGameCannonKonaImpl);\\n }\\n } else {\\n // some older chains have L2OutputOracle instead of DisputeGameFactory.\\n address l2OutputOracleProxy = IFetcher(optimismPortalProxy).L2_ORACLE();\\n _fo.set(_fo.l2OutputOracleProxy.selector, l2OutputOracleProxy);\\n address proposer = IFetcher(l2OutputOracleProxy).PROPOSER();\\n _fo.set(_fo.proposer.selector, proposer);\\n }\\n }\\n\\n function _getGuardian(address _portal) internal view returns (address) {\\n try IFetcher(_portal).guardian() returns (address guardian_) {\\n return guardian_;\\n } catch {\\n return IFetcher(_portal).GUARDIAN();\\n }\\n }\\n\\n function _getSystemConfigProxy(address _portal) internal view returns (address) {\\n try IFetcher(_portal).systemConfig() returns (address systemConfig_) {\\n return systemConfig_;\\n } catch {\\n return IFetcher(_portal).SYSTEM_CONFIG();\\n }\\n }\\n\\n function _getOptimismPortalProxy(address _l1CrossDomainMessengerProxy) internal view returns (address) {\\n try IFetcher(_l1CrossDomainMessengerProxy).portal() returns (address optimismPortal_) {\\n return optimismPortal_;\\n } catch {\\n return IFetcher(_l1CrossDomainMessengerProxy).PORTAL();\\n }\\n }\\n\\n function _getAddressManager(address _l1CrossDomainMessengerProxy) internal view returns (address) {\\n uint256 ADDRESS_MANAGER_MAPPING_SLOT = 1;\\n bytes32 slot = keccak256(abi.encode(_l1CrossDomainMessengerProxy, ADDRESS_MANAGER_MAPPING_SLOT));\\n return address(uint160(uint256((vm.load(_l1CrossDomainMessengerProxy, slot)))));\\n }\\n\\n function _getL1ERC721BridgeProxy(address _systemConfigProxy) internal view returns (address) {\\n try IFetcher(_systemConfigProxy).l1ERC721Bridge() returns (address l1ERC721BridgeProxy_) {\\n return l1ERC721BridgeProxy_;\\n } catch {\\n return address(0);\\n }\\n }\\n\\n function _getOptimismMintableERC20FactoryProxy(address _systemConfigProxy) internal view returns (address) {\\n try IFetcher(_systemConfigProxy).optimismMintableERC20Factory() returns (\\n address optimismMintableERC20FactoryProxy_\\n ) {\\n return optimismMintableERC20FactoryProxy_;\\n } catch {\\n return address(0);\\n }\\n }\\n\\n function _getDisputeGameFactoryProxy(address _systemConfigProxy) internal view returns (address) {\\n try IFetcher(_systemConfigProxy).disputeGameFactory() returns (address disputeGameFactoryProxy_) {\\n return disputeGameFactoryProxy_;\\n } catch {\\n // Some older chains have L2OutputOracle instead of DisputeGameFactory\\n return address(0);\\n }\\n }\\n\\n function _getSuperchainConfigProxy(address _optimismPortalProxy) internal view returns (address) {\\n try IFetcher(_optimismPortalProxy).superchainConfig() returns (address superchainConfigProxy_) {\\n return superchainConfigProxy_;\\n } catch {\\n return address(0);\\n }\\n }\\n\\n function _getFaultDisputeGame(address _disputeGameFactoryProxy) internal view returns (address) {\\n try IFetcher(_disputeGameFactoryProxy).gameImpls(GameTypes.CANNON) returns (address faultDisputeGame_) {\\n return faultDisputeGame_;\\n } catch {\\n return address(0);\\n }\\n }\\n\\n function _getFaultDisputeGame(\\n address _disputeGameFactoryProxy,\\n GameType _gameType\\n )\\n internal\\n view\\n returns (address)\\n {\\n try IFetcher(_disputeGameFactoryProxy).gameImpls(_gameType) returns (address faultDisputeGame_) {\\n return faultDisputeGame_;\\n } catch {\\n return address(0);\\n }\\n }\\n\\n function _getPermissionedDisputeGame(address _disputeGameFactoryProxy) internal view returns (address) {\\n try IFetcher(_disputeGameFactoryProxy).gameImpls(GameTypes.PERMISSIONED_CANNON) returns (\\n address permissionedDisputeGame_\\n ) {\\n return permissionedDisputeGame_;\\n } catch {\\n return address(0);\\n }\\n }\\n\\n function _getEthLockboxProxy(address _optimismPortalProxy) internal view returns (address) {\\n try IFetcher(_optimismPortalProxy).ethLockbox() returns (address ethLockbox_) {\\n return ethLockbox_;\\n } catch {\\n return address(0);\\n }\\n }\\n\\n function _getDelayedWETHProxy(address _disputeGame) internal view returns (address) {\\n (bool ok, bytes memory data) = address(_disputeGame).staticcall(abi.encodeCall(IFetcher.weth, ()));\\n if (ok && data.length == 32) return abi.decode(data, (address));\\n else return address(0);\\n }\\n\\n function _getBatchSubmitter(address _systemConfigProxy) internal view returns (address) {\\n bytes32 batcherHash = IFetcher(_systemConfigProxy).batcherHash();\\n return address(uint160(uint256(batcherHash)));\\n }\\n\\n function _getProxyAdmin(address _systemConfigProxy) internal returns (address) {\\n vm.prank(address(0));\\n return IFetcher(_systemConfigProxy).admin();\\n }\\n}\\n\",\"keccak256\":\"0xb90e4f9a834c4dc584b4ad8c0503e35fdd8338533e0e75a7ca497f655ae12821\",\"license\":\"MIT\"},\"src/dispute/lib/LibPosition.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.15;\\n\\nusing LibPosition for Position global;\\n\\n/// @notice A `Position` represents a position of a claim within the game tree.\\n/// @dev This is represented as a \\\"generalized index\\\" where the high-order bit\\n/// is the level in the tree and the remaining bits is a unique bit pattern, allowing\\n/// a unique identifier for each node in the tree. Mathematically, it is calculated\\n/// as 2^{depth} + indexAtDepth.\\ntype Position is uint128;\\n\\n/// @title LibPosition\\n/// @notice This library contains helper functions for working with the `Position` type.\\nlibrary LibPosition {\\n /// @notice the `MAX_POSITION_BITLEN` is the number of bits that the `Position` type, and the implementation of\\n /// its behavior within this library, can safely support.\\n uint8 internal constant MAX_POSITION_BITLEN = 126;\\n\\n /// @notice Computes a generalized index (2^{depth} + indexAtDepth).\\n /// @param _depth The depth of the position.\\n /// @param _indexAtDepth The index at the depth of the position.\\n /// @return position_ The computed generalized index.\\n function wrap(uint8 _depth, uint128 _indexAtDepth) internal pure returns (Position position_) {\\n assembly {\\n // gindex = 2^{_depth} + _indexAtDepth\\n position_ := add(shl(_depth, 1), _indexAtDepth)\\n }\\n }\\n\\n /// @notice Pulls the `depth` out of a `Position` type.\\n /// @param _position The generalized index to get the `depth` of.\\n /// @return depth_ The `depth` of the `position` gindex.\\n /// @custom:attribution Solady \\n function depth(Position _position) internal pure returns (uint8 depth_) {\\n // Return the most significant bit offset, which signifies the depth of the gindex.\\n assembly {\\n depth_ := or(depth_, shl(6, lt(0xffffffffffffffff, shr(depth_, _position))))\\n depth_ := or(depth_, shl(5, lt(0xffffffff, shr(depth_, _position))))\\n\\n // For the remaining 32 bits, use a De Bruijn lookup.\\n _position := shr(depth_, _position)\\n _position := or(_position, shr(1, _position))\\n _position := or(_position, shr(2, _position))\\n _position := or(_position, shr(4, _position))\\n _position := or(_position, shr(8, _position))\\n _position := or(_position, shr(16, _position))\\n\\n depth_ :=\\n or(\\n depth_,\\n byte(\\n shr(251, mul(_position, shl(224, 0x07c4acdd))),\\n 0x0009010a0d15021d0b0e10121619031e080c141c0f111807131b17061a05041f\\n )\\n )\\n }\\n }\\n\\n /// @notice Pulls the `indexAtDepth` out of a `Position` type.\\n /// The `indexAtDepth` is the left/right index of a position at a specific depth within\\n /// the binary tree, starting from index 0. For example, at gindex 2, the `depth` = 1\\n /// and the `indexAtDepth` = 0.\\n /// @param _position The generalized index to get the `indexAtDepth` of.\\n /// @return indexAtDepth_ The `indexAtDepth` of the `position` gindex.\\n function indexAtDepth(Position _position) internal pure returns (uint128 indexAtDepth_) {\\n // Return bits p_{msb-1}...p_{0}. This effectively pulls the 2^{depth} out of the gindex,\\n // leaving only the `indexAtDepth`.\\n uint256 msb = depth(_position);\\n assembly {\\n indexAtDepth_ := sub(_position, shl(msb, 1))\\n }\\n }\\n\\n /// @notice Get the left child of `_position`.\\n /// @param _position The position to get the left position of.\\n /// @return left_ The position to the left of `position`.\\n function left(Position _position) internal pure returns (Position left_) {\\n assembly {\\n left_ := shl(1, _position)\\n }\\n }\\n\\n /// @notice Get the right child of `_position`\\n /// @param _position The position to get the right position of.\\n /// @return right_ The position to the right of `position`.\\n function right(Position _position) internal pure returns (Position right_) {\\n assembly {\\n right_ := or(1, shl(1, _position))\\n }\\n }\\n\\n /// @notice Get the parent position of `_position`.\\n /// @param _position The position to get the parent position of.\\n /// @return parent_ The parent position of `position`.\\n function parent(Position _position) internal pure returns (Position parent_) {\\n assembly {\\n parent_ := shr(1, _position)\\n }\\n }\\n\\n /// @notice Get the deepest, right most gindex relative to the `position`. This is equivalent to\\n /// calling `right` on a position until the maximum depth is reached.\\n /// @param _position The position to get the relative deepest, right most gindex of.\\n /// @param _maxDepth The maximum depth of the game.\\n /// @return rightIndex_ The deepest, right most gindex relative to the `position`.\\n function rightIndex(Position _position, uint256 _maxDepth) internal pure returns (Position rightIndex_) {\\n uint256 msb = depth(_position);\\n assembly {\\n let remaining := sub(_maxDepth, msb)\\n rightIndex_ := or(shl(remaining, _position), sub(shl(remaining, 1), 1))\\n }\\n }\\n\\n /// @notice Get the deepest, right most trace index relative to the `position`. This is\\n /// equivalent to calling `right` on a position until the maximum depth is reached and\\n /// then finding its index at depth.\\n /// @param _position The position to get the relative trace index of.\\n /// @param _maxDepth The maximum depth of the game.\\n /// @return traceIndex_ The trace index relative to the `position`.\\n function traceIndex(Position _position, uint256 _maxDepth) internal pure returns (uint256 traceIndex_) {\\n uint256 msb = depth(_position);\\n assembly {\\n let remaining := sub(_maxDepth, msb)\\n traceIndex_ := sub(or(shl(remaining, _position), sub(shl(remaining, 1), 1)), shl(_maxDepth, 1))\\n }\\n }\\n\\n /// @notice Gets the position of the highest ancestor of `_position` that commits to the same\\n /// trace index.\\n /// @param _position The position to get the highest ancestor of.\\n /// @return ancestor_ The highest ancestor of `position` that commits to the same trace index.\\n function traceAncestor(Position _position) internal pure returns (Position ancestor_) {\\n // Create a field with only the lowest unset bit of `_position` set.\\n Position lsb;\\n assembly {\\n lsb := and(not(_position), add(_position, 1))\\n }\\n // Find the index of the lowest unset bit within the field.\\n uint256 msb = depth(lsb);\\n // The highest ancestor that commits to the same trace index is the original position\\n // shifted right by the index of the lowest unset bit.\\n assembly {\\n let a := shr(msb, _position)\\n // Bound the ancestor to the minimum gindex, 1.\\n ancestor_ := or(a, iszero(a))\\n }\\n }\\n\\n /// @notice Gets the position of the highest ancestor of `_position` that commits to the same\\n /// trace index, while still being below `_upperBoundExclusive`.\\n /// @param _position The position to get the highest ancestor of.\\n /// @param _upperBoundExclusive The exclusive upper depth bound, used to inform where to stop in order\\n /// to not escape a sub-tree.\\n /// @return ancestor_ The highest ancestor of `position` that commits to the same trace index.\\n function traceAncestorBounded(\\n Position _position,\\n uint256 _upperBoundExclusive\\n )\\n internal\\n pure\\n returns (Position ancestor_)\\n {\\n // This function only works for positions that are below the upper bound.\\n if (_position.depth() <= _upperBoundExclusive) {\\n assembly {\\n // Revert with `ClaimAboveSplit()`\\n mstore(0x00, 0xb34b5c22)\\n revert(0x1C, 0x04)\\n }\\n }\\n\\n // Grab the global trace ancestor.\\n ancestor_ = traceAncestor(_position);\\n\\n // If the ancestor is above or at the upper bound, shift it to be below the upper bound.\\n // This should be a special case that only covers positions that commit to the final leaf\\n // in a sub-tree.\\n if (ancestor_.depth() <= _upperBoundExclusive) {\\n ancestor_ = ancestor_.rightIndex(_upperBoundExclusive + 1);\\n }\\n }\\n\\n /// @notice Get the move position of `_position`, which is the left child of:\\n /// 1. `_position` if `_isAttack` is true.\\n /// 2. `_position | 1` if `_isAttack` is false.\\n /// @param _position The position to get the relative attack/defense position of.\\n /// @param _isAttack Whether or not the move is an attack move.\\n /// @return move_ The move position relative to `position`.\\n function move(Position _position, bool _isAttack) internal pure returns (Position move_) {\\n assembly {\\n move_ := shl(1, or(iszero(_isAttack), _position))\\n }\\n }\\n\\n /// @notice Get the value of a `Position` type in the form of the underlying uint128.\\n /// @param _position The position to get the value of.\\n /// @return raw_ The value of the `position` as a uint128 type.\\n function raw(Position _position) internal pure returns (uint128 raw_) {\\n assembly {\\n raw_ := _position\\n }\\n }\\n}\\n\",\"keccak256\":\"0x7c5f19f8f54f06de2ce1c6cdcc5c7af65ac405130a4066cdaf146ca315818241\",\"license\":\"MIT\"},\"src/dispute/lib/LibUDT.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.15;\\n\\n// Libraries\\nimport { Position } from \\\"src/dispute/lib/LibPosition.sol\\\";\\n\\nusing LibClaim for Claim global;\\nusing LibHash for Hash global;\\nusing LibDuration for Duration global;\\nusing LibClock for Clock global;\\nusing LibGameId for GameId global;\\nusing LibTimestamp for Timestamp global;\\nusing LibVMStatus for VMStatus global;\\nusing LibGameType for GameType global;\\n\\n/// @notice A `Clock` represents a packed `Duration` and `Timestamp`\\n/// @dev The packed layout of this type is as follows:\\n/// \\u250c\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u252c\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2510\\n/// \\u2502 Bits \\u2502 Value \\u2502\\n/// \\u251c\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u253c\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2524\\n/// \\u2502 [0, 64) \\u2502 Duration \\u2502\\n/// \\u2502 [64, 128) \\u2502 Timestamp \\u2502\\n/// \\u2514\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2534\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2518\\ntype Clock is uint128;\\n\\n/// @title LibClock\\n/// @notice This library contains helper functions for working with the `Clock` type.\\nlibrary LibClock {\\n /// @notice Packs a `Duration` and `Timestamp` into a `Clock` type.\\n /// @param _duration The `Duration` to pack into the `Clock` type.\\n /// @param _timestamp The `Timestamp` to pack into the `Clock` type.\\n /// @return clock_ The `Clock` containing the `_duration` and `_timestamp`.\\n function wrap(Duration _duration, Timestamp _timestamp) internal pure returns (Clock clock_) {\\n assembly {\\n clock_ := or(shl(0x40, _duration), _timestamp)\\n }\\n }\\n\\n /// @notice Pull the `Duration` out of a `Clock` type.\\n /// @param _clock The `Clock` type to pull the `Duration` out of.\\n /// @return duration_ The `Duration` pulled out of `_clock`.\\n function duration(Clock _clock) internal pure returns (Duration duration_) {\\n // Shift the high-order 64 bits into the low-order 64 bits, leaving only the `duration`.\\n assembly {\\n duration_ := shr(0x40, _clock)\\n }\\n }\\n\\n /// @notice Pull the `Timestamp` out of a `Clock` type.\\n /// @param _clock The `Clock` type to pull the `Timestamp` out of.\\n /// @return timestamp_ The `Timestamp` pulled out of `_clock`.\\n function timestamp(Clock _clock) internal pure returns (Timestamp timestamp_) {\\n // Clean the high-order 192 bits by shifting the clock left and then right again, leaving\\n // only the `timestamp`.\\n assembly {\\n timestamp_ := shr(0xC0, shl(0xC0, _clock))\\n }\\n }\\n\\n /// @notice Get the value of a `Clock` type in the form of the underlying uint128.\\n /// @param _clock The `Clock` type to get the value of.\\n /// @return clock_ The value of the `Clock` type as a uint128 type.\\n function raw(Clock _clock) internal pure returns (uint128 clock_) {\\n assembly {\\n clock_ := _clock\\n }\\n }\\n}\\n\\n/// @notice A `GameId` represents a packed 4 byte game ID, a 8 byte timestamp, and a 20 byte address.\\n/// @dev The packed layout of this type is as follows:\\n/// \\u250c\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u252c\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2510\\n/// \\u2502 Bits \\u2502 Value \\u2502\\n/// \\u251c\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u253c\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2524\\n/// \\u2502 [0, 32) \\u2502 Game Type \\u2502\\n/// \\u2502 [32, 96) \\u2502 Timestamp \\u2502\\n/// \\u2502 [96, 256) \\u2502 Address \\u2502\\n/// \\u2514\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2534\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2500\\u2518\\ntype GameId is bytes32;\\n\\n/// @title LibGameId\\n/// @notice Utility functions for packing and unpacking GameIds.\\nlibrary LibGameId {\\n /// @notice Packs values into a 32 byte GameId type.\\n /// @param _gameType The game type.\\n /// @param _timestamp The timestamp of the game's creation.\\n /// @param _gameProxy The game proxy address.\\n /// @return gameId_ The packed GameId.\\n function pack(\\n GameType _gameType,\\n Timestamp _timestamp,\\n address _gameProxy\\n )\\n internal\\n pure\\n returns (GameId gameId_)\\n {\\n assembly {\\n gameId_ := or(or(shl(224, _gameType), shl(160, _timestamp)), _gameProxy)\\n }\\n }\\n\\n /// @notice Unpacks values from a 32 byte GameId type.\\n /// @param _gameId The packed GameId.\\n /// @return gameType_ The game type.\\n /// @return timestamp_ The timestamp of the game's creation.\\n /// @return gameProxy_ The game proxy address.\\n function unpack(GameId _gameId)\\n internal\\n pure\\n returns (GameType gameType_, Timestamp timestamp_, address gameProxy_)\\n {\\n assembly {\\n gameType_ := shr(224, _gameId)\\n timestamp_ := and(shr(160, _gameId), 0xFFFFFFFFFFFFFFFF)\\n gameProxy_ := and(_gameId, 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF)\\n }\\n }\\n}\\n\\n/// @notice A claim represents an MPT root representing the state of the fault proof program.\\ntype Claim is bytes32;\\n\\n/// @title LibClaim\\n/// @notice This library contains helper functions for working with the `Claim` type.\\nlibrary LibClaim {\\n /// @notice Get the value of a `Claim` type in the form of the underlying bytes32.\\n /// @param _claim The `Claim` type to get the value of.\\n /// @return claim_ The value of the `Claim` type as a bytes32 type.\\n function raw(Claim _claim) internal pure returns (bytes32 claim_) {\\n assembly {\\n claim_ := _claim\\n }\\n }\\n\\n /// @notice Hashes a claim and a position together.\\n /// @param _claim A Claim type.\\n /// @param _position The position of `claim`.\\n /// @param _challengeIndex The index of the claim being moved against.\\n /// @return claimHash_ A hash of abi.encodePacked(claim, position|challengeIndex);\\n function hashClaimPos(\\n Claim _claim,\\n Position _position,\\n uint256 _challengeIndex\\n )\\n internal\\n pure\\n returns (Hash claimHash_)\\n {\\n assembly {\\n mstore(0x00, _claim)\\n mstore(0x20, or(shl(128, _position), and(0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF, _challengeIndex)))\\n claimHash_ := keccak256(0x00, 0x40)\\n }\\n }\\n}\\n\\n/// @notice A dedicated duration type.\\n/// @dev Unit: seconds\\ntype Duration is uint64;\\n\\n/// @title LibDuration\\n/// @notice This library contains helper functions for working with the `Duration` type.\\nlibrary LibDuration {\\n /// @notice Get the value of a `Duration` type in the form of the underlying uint64.\\n /// @param _duration The `Duration` type to get the value of.\\n /// @return duration_ The value of the `Duration` type as a uint64 type.\\n function raw(Duration _duration) internal pure returns (uint64 duration_) {\\n assembly {\\n duration_ := _duration\\n }\\n }\\n}\\n\\n/// @notice A custom type for a generic hash.\\ntype Hash is bytes32;\\n\\n/// @title LibHash\\n/// @notice This library contains helper functions for working with the `Hash` type.\\nlibrary LibHash {\\n /// @notice Get the value of a `Hash` type in the form of the underlying bytes32.\\n /// @param _hash The `Hash` type to get the value of.\\n /// @return hash_ The value of the `Hash` type as a bytes32 type.\\n function raw(Hash _hash) internal pure returns (bytes32 hash_) {\\n assembly {\\n hash_ := _hash\\n }\\n }\\n}\\n\\n/// @notice A dedicated timestamp type.\\ntype Timestamp is uint64;\\n\\n/// @title LibTimestamp\\n/// @notice This library contains helper functions for working with the `Timestamp` type.\\nlibrary LibTimestamp {\\n /// @notice Get the value of a `Timestamp` type in the form of the underlying uint64.\\n /// @param _timestamp The `Timestamp` type to get the value of.\\n /// @return timestamp_ The value of the `Timestamp` type as a uint64 type.\\n function raw(Timestamp _timestamp) internal pure returns (uint64 timestamp_) {\\n assembly {\\n timestamp_ := _timestamp\\n }\\n }\\n}\\n\\n/// @notice A `VMStatus` represents the status of a VM execution.\\ntype VMStatus is uint8;\\n\\n/// @title LibVMStatus\\n/// @notice This library contains helper functions for working with the `VMStatus` type.\\nlibrary LibVMStatus {\\n /// @notice Get the value of a `VMStatus` type in the form of the underlying uint8.\\n /// @param _vmstatus The `VMStatus` type to get the value of.\\n /// @return vmstatus_ The value of the `VMStatus` type as a uint8 type.\\n function raw(VMStatus _vmstatus) internal pure returns (uint8 vmstatus_) {\\n assembly {\\n vmstatus_ := _vmstatus\\n }\\n }\\n}\\n\\n/// @notice A `GameType` represents the type of game being played.\\ntype GameType is uint32;\\n\\n/// @title LibGameType\\n/// @notice This library contains helper functions for working with the `GameType` type.\\nlibrary LibGameType {\\n /// @notice Get the value of a `GameType` type in the form of the underlying uint32.\\n /// @param _gametype The `GameType` type to get the value of.\\n /// @return gametype_ The value of the `GameType` type as a uint32 type.\\n function raw(GameType _gametype) internal pure returns (uint32 gametype_) {\\n assembly {\\n gametype_ := _gametype\\n }\\n }\\n}\\n\",\"keccak256\":\"0x41d55e9c74d979b5b797198e38449e7cef4f925e04d61f7699e9c150c4a659d3\",\"license\":\"MIT\"},\"src/dispute/lib/Types.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.15;\\n\\n// Libraries\\nimport {\\n Position,\\n Hash,\\n GameType,\\n VMStatus,\\n Timestamp,\\n Duration,\\n Clock,\\n GameId,\\n Claim,\\n LibGameId,\\n LibClock\\n} from \\\"src/dispute/lib/LibUDT.sol\\\";\\n\\n/// @notice The current status of the dispute game.\\nenum GameStatus {\\n // The game is currently in progress, and has not been resolved.\\n IN_PROGRESS,\\n // The game has concluded, and the `rootClaim` was challenged successfully.\\n CHALLENGER_WINS,\\n // The game has concluded, and the `rootClaim` could not be contested.\\n DEFENDER_WINS\\n}\\n\\n/// @notice The game's bond distribution type. Games are expected to start in the `UNDECIDED`\\n/// state, and then choose either `NORMAL` or `REFUND`.\\nenum BondDistributionMode {\\n // Bond distribution strategy has not been chosen.\\n UNDECIDED,\\n // Bonds should be distributed as normal.\\n NORMAL,\\n // Bonds should be refunded to claimants.\\n REFUND\\n}\\n\\n/// @notice Represents an L2 root and the L2 sequence number at which it was generated.\\n/// @custom:field root The output root.\\n/// @custom:field l2SequenceNumber The L2 Sequence Number ( e.g. block number / timestamp) at which the root was\\n/// generated.\\nstruct Proposal {\\n Hash root;\\n uint256 l2SequenceNumber;\\n}\\n\\n/// @title GameTypes\\n/// @notice A library that defines the IDs of games that can be played.\\nlibrary GameTypes {\\n /// @dev A dispute game type the uses the cannon vm.\\n GameType internal constant CANNON = GameType.wrap(0);\\n\\n /// @dev A permissioned dispute game type that uses the cannon vm.\\n GameType internal constant PERMISSIONED_CANNON = GameType.wrap(1);\\n\\n /// @notice A dispute game type that uses the asterisc vm.\\n GameType internal constant ASTERISC = GameType.wrap(2);\\n\\n /// @notice A dispute game type that uses the asterisc vm with Kona.\\n GameType internal constant ASTERISC_KONA = GameType.wrap(3);\\n\\n /// @notice A dispute game type that uses the cannon vm (Super Roots).\\n GameType internal constant SUPER_CANNON = GameType.wrap(4);\\n\\n /// @notice A dispute game type that uses the permissioned cannon vm (Super Roots).\\n GameType internal constant SUPER_PERMISSIONED_CANNON = GameType.wrap(5);\\n\\n /// @notice A dispute game type that uses OP Succinct\\n GameType internal constant OP_SUCCINCT = GameType.wrap(6);\\n\\n /// @notice A dispute game type that uses the asterisc vm with Kona (Super Roots).\\n GameType internal constant SUPER_ASTERISC_KONA = GameType.wrap(7);\\n\\n /// @notice A dispute game type that uses the cannon vm with Kona.\\n GameType internal constant CANNON_KONA = GameType.wrap(8);\\n\\n /// @notice A dispute game type that uses the cannon vm with Kona (Super Roots).\\n GameType internal constant SUPER_CANNON_KONA = GameType.wrap(9);\\n\\n /// @notice A dispute game type with short game duration for testing withdrawals.\\n /// Not intended for production use.\\n GameType internal constant FAST = GameType.wrap(254);\\n\\n /// @notice A dispute game type that uses an alphabet vm.\\n /// Not intended for production use.\\n GameType internal constant ALPHABET = GameType.wrap(255);\\n\\n /// @notice A dispute game type that uses RISC Zero's Kailua\\n GameType internal constant KAILUA = GameType.wrap(1337);\\n}\\n\\n/// @title VMStatuses\\n/// @notice Named type aliases for the various valid VM status bytes.\\nlibrary VMStatuses {\\n /// @notice The VM has executed successfully and the outcome is valid.\\n VMStatus internal constant VALID = VMStatus.wrap(0);\\n\\n /// @notice The VM has executed successfully and the outcome is invalid.\\n VMStatus internal constant INVALID = VMStatus.wrap(1);\\n\\n /// @notice The VM has paniced.\\n VMStatus internal constant PANIC = VMStatus.wrap(2);\\n\\n /// @notice The VM execution is still in progress.\\n VMStatus internal constant UNFINISHED = VMStatus.wrap(3);\\n}\\n\\n/// @title LocalPreimageKey\\n/// @notice Named type aliases for local `PreimageOracle` key identifiers.\\nlibrary LocalPreimageKey {\\n /// @notice The identifier for the L1 head hash.\\n uint256 internal constant L1_HEAD_HASH = 0x01;\\n\\n /// @notice The identifier for the starting output root.\\n uint256 internal constant STARTING_OUTPUT_ROOT = 0x02;\\n\\n /// @notice The identifier for the disputed output root.\\n uint256 internal constant DISPUTED_OUTPUT_ROOT = 0x03;\\n\\n /// @notice The identifier for the disputed L2 block number.\\n uint256 internal constant DISPUTED_L2_BLOCK_NUMBER = 0x04;\\n\\n /// @notice The identifier for the chain ID.\\n uint256 internal constant CHAIN_ID = 0x05;\\n}\\n\",\"keccak256\":\"0x468fccc8d6ce3ac5b87bdd5002f84b315ac861be7655ceef87a018f596c410a1\",\"license\":\"MIT\"}},\"version\":1}","metadata":{"compiler":{"version":"0.8.27+commit.40a35a09"},"language":"Solidity","output":{"abi":[{"inputs":[],"stateMutability":"view","type":"function","name":"GUARDIAN","outputs":[{"internalType":"address","name":"","type":"address"}]},{"inputs":[],"stateMutability":"view","type":"function","name":"L2_ORACLE","outputs":[{"internalType":"address","name":"","type":"address"}]},{"inputs":[],"stateMutability":"view","type":"function","name":"PORTAL","outputs":[{"internalType":"address","name":"","type":"address"}]},{"inputs":[],"stateMutability":"view","type":"function","name":"PROPOSER","outputs":[{"internalType":"address","name":"","type":"address"}]},{"inputs":[],"stateMutability":"view","type":"function","name":"SYSTEM_CONFIG","outputs":[{"internalType":"address","name":"","type":"address"}]},{"inputs":[],"stateMutability":"view","type":"function","name":"addressManager","outputs":[{"internalType":"address","name":"","type":"address"}]},{"inputs":[],"stateMutability":"view","type":"function","name":"admin","outputs":[{"internalType":"address","name":"","type":"address"}]},{"inputs":[],"stateMutability":"view","type":"function","name":"anchorStateRegistry","outputs":[{"internalType":"address","name":"","type":"address"}]},{"inputs":[],"stateMutability":"view","type":"function","name":"batcherHash","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}]},{"inputs":[],"stateMutability":"view","type":"function","name":"challenger","outputs":[{"internalType":"address","name":"","type":"address"}]},{"inputs":[],"stateMutability":"view","type":"function","name":"disputeGameFactory","outputs":[{"internalType":"address","name":"","type":"address"}]},{"inputs":[],"stateMutability":"view","type":"function","name":"ethLockbox","outputs":[{"internalType":"address","name":"","type":"address"}]},{"inputs":[{"internalType":"GameType","name":"_gameType","type":"uint32"}],"stateMutability":"view","type":"function","name":"gameImpls","outputs":[{"internalType":"address","name":"","type":"address"}]},{"inputs":[],"stateMutability":"view","type":"function","name":"guardian","outputs":[{"internalType":"address","name":"","type":"address"}]},{"inputs":[],"stateMutability":"view","type":"function","name":"l1ERC721Bridge","outputs":[{"internalType":"address","name":"","type":"address"}]},{"inputs":[],"stateMutability":"view","type":"function","name":"l2Oracle","outputs":[{"internalType":"address","name":"","type":"address"}]},{"inputs":[],"stateMutability":"view","type":"function","name":"messenger","outputs":[{"internalType":"address","name":"","type":"address"}]},{"inputs":[],"stateMutability":"view","type":"function","name":"optimismMintableERC20Factory","outputs":[{"internalType":"address","name":"","type":"address"}]},{"inputs":[],"stateMutability":"view","type":"function","name":"oracle","outputs":[{"internalType":"address","name":"","type":"address"}]},{"inputs":[],"stateMutability":"view","type":"function","name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}]},{"inputs":[],"stateMutability":"view","type":"function","name":"portal","outputs":[{"internalType":"address","name":"","type":"address"}]},{"inputs":[],"stateMutability":"view","type":"function","name":"proposer","outputs":[{"internalType":"address","name":"","type":"address"}]},{"inputs":[],"stateMutability":"view","type":"function","name":"respectedGameType","outputs":[{"internalType":"GameType","name":"","type":"uint32"}]},{"inputs":[],"stateMutability":"view","type":"function","name":"superchainConfig","outputs":[{"internalType":"address","name":"","type":"address"}]},{"inputs":[],"stateMutability":"view","type":"function","name":"systemConfig","outputs":[{"internalType":"address","name":"","type":"address"}]},{"inputs":[],"stateMutability":"view","type":"function","name":"unsafeBlockSigner","outputs":[{"internalType":"address","name":"","type":"address"}]},{"inputs":[],"stateMutability":"view","type":"function","name":"vm","outputs":[{"internalType":"address","name":"","type":"address"}]},{"inputs":[],"stateMutability":"view","type":"function","name":"weth","outputs":[{"internalType":"address","name":"","type":"address"}]}],"devdoc":{"kind":"dev","methods":{},"version":1},"userdoc":{"kind":"user","methods":{},"version":1}},"settings":{"remappings":["@lib-keccak/=lib/lib-keccak/contracts/lib/","@openzeppelin/contracts-upgradeable/=lib/openzeppelin-contracts-upgradeable/contracts/","@openzeppelin/contracts-v5/=lib/openzeppelin-contracts-v5/contracts/","@openzeppelin/contracts/=lib/openzeppelin-contracts/contracts/","@rari-capital/solmate/=lib/solmate/","@solady-test/=lib/lib-keccak/lib/solady/test/","@solady-v0.0.245/=lib/solady-v0.0.245/src/","@solady/=lib/solady/src/","ds-test/=lib/forge-std/lib/ds-test/src/","erc4626-tests/=lib/openzeppelin-contracts-v5/lib/erc4626-tests/","forge-std/=lib/forge-std/src/","interfaces/=interfaces/","kontrol-cheatcodes/=lib/kontrol-cheatcodes/src/","lib-keccak/=lib/lib-keccak/contracts/","openzeppelin-contracts-upgradeable/=lib/openzeppelin-contracts-upgradeable/","openzeppelin-contracts-v5/=lib/openzeppelin-contracts-v5/","openzeppelin-contracts/=lib/openzeppelin-contracts/","safe-contracts/=lib/safe-contracts/contracts/","solady-v0.0.245/=lib/solady-v0.0.245/src/","solady/=lib/solady/","solmate/=lib/solmate/src/"],"optimizer":{"enabled":false,"runs":0},"metadata":{"useLiteralContent":true,"bytecodeHash":"none"},"compilationTarget":{"scripts/FetchChainInfo.s.sol":"IFetcher"},"evmVersion":"cancun","libraries":{}},"sources":{"lib/forge-std/src/Base.sol":{"keccak256":"0xa3735a6618a3014e42bb4329ad143e3b2c59cd95094350202e4c4a06c9d585dd","urls":[],"content":"// SPDX-License-Identifier: MIT\npragma solidity >=0.6.2 <0.9.0;\n\nimport {StdStorage} from \"./StdStorage.sol\";\nimport {Vm, VmSafe} from \"./Vm.sol\";\n\nabstract contract CommonBase {\n /// @dev Cheat code address.\n /// Calculated as `address(uint160(uint256(keccak256(\"hevm cheat code\"))))`.\n address internal constant VM_ADDRESS = 0x7109709ECfa91a80626fF3989D68f67F5b1DD12D;\n /// @dev console.sol and console2.sol work by executing a staticcall to this address.\n /// Calculated as `address(uint160(uint88(bytes11(\"console.log\"))))`.\n address internal constant CONSOLE = 0x000000000000000000636F6e736F6c652e6c6f67;\n /// @dev Used when deploying with create2.\n /// Taken from https://github.com/Arachnid/deterministic-deployment-proxy.\n address internal constant CREATE2_FACTORY = 0x4e59b44847b379578588920cA78FbF26c0B4956C;\n /// @dev The default address for tx.origin and msg.sender.\n /// Calculated as `address(uint160(uint256(keccak256(\"foundry default caller\"))))`.\n address internal constant DEFAULT_SENDER = 0x1804c8AB1F12E6bbf3894d4083f33e07309d1f38;\n /// @dev The address of the first contract `CREATE`d by a running test contract.\n /// When running tests, each test contract is `CREATE`d by `DEFAULT_SENDER` with nonce 1.\n /// Calculated as `VM.computeCreateAddress(VM.computeCreateAddress(DEFAULT_SENDER, 1), 1)`.\n address internal constant DEFAULT_TEST_CONTRACT = 0x5615dEB798BB3E4dFa0139dFa1b3D433Cc23b72f;\n /// @dev Deterministic deployment address of the Multicall3 contract.\n /// Taken from https://www.multicall3.com.\n address internal constant MULTICALL3_ADDRESS = 0xcA11bde05977b3631167028862bE2a173976CA11;\n /// @dev The order of the secp256k1 curve.\n uint256 internal constant SECP256K1_ORDER =\n 115792089237316195423570985008687907852837564279074904382605163141518161494337;\n\n uint256 internal constant UINT256_MAX =\n 115792089237316195423570985008687907853269984665640564039457584007913129639935;\n\n Vm internal constant vm = Vm(VM_ADDRESS);\n StdStorage internal stdstore;\n}\n\nabstract contract TestBase is CommonBase {}\n\nabstract contract ScriptBase is CommonBase {\n VmSafe internal constant vmSafe = VmSafe(VM_ADDRESS);\n}\n","license":"MIT"},"lib/forge-std/src/Script.sol":{"keccak256":"0xc942e27c7baae499beb01afbbae99f24d42af9a6e4aae675bc6901b704aa8e9b","urls":[],"content":"// SPDX-License-Identifier: MIT\npragma solidity >=0.6.2 <0.9.0;\n\n// 💬 ABOUT\n// Forge Std's default Script.\n\n// 🧩 MODULES\nimport {console} from \"./console.sol\";\nimport {console2} from \"./console2.sol\";\nimport {safeconsole} from \"./safeconsole.sol\";\nimport {StdChains} from \"./StdChains.sol\";\nimport {StdCheatsSafe} from \"./StdCheats.sol\";\nimport {StdConstants} from \"./StdConstants.sol\";\nimport {stdJson} from \"./StdJson.sol\";\nimport {stdMath} from \"./StdMath.sol\";\nimport {StdStorage, stdStorageSafe} from \"./StdStorage.sol\";\nimport {StdStyle} from \"./StdStyle.sol\";\nimport {StdUtils} from \"./StdUtils.sol\";\nimport {VmSafe} from \"./Vm.sol\";\n\n// 📦 BOILERPLATE\nimport {ScriptBase} from \"./Base.sol\";\n\n// ⭐️ SCRIPT\nabstract contract Script is ScriptBase, StdChains, StdCheatsSafe, StdUtils {\n // Note: IS_SCRIPT() must return true.\n bool public IS_SCRIPT = true;\n}\n","license":"MIT"},"lib/forge-std/src/StdChains.sol":{"keccak256":"0x200b597cd01c229633b4a2317846cac7d36d337e2381b4a2e81faac23c2ad1cf","urls":[],"content":"// SPDX-License-Identifier: MIT\npragma solidity >=0.6.2 <0.9.0;\n\nimport {VmSafe} from \"./Vm.sol\";\n\n/**\n * StdChains provides information about EVM compatible chains that can be used in scripts/tests.\n * For each chain, the chain's name, chain ID, and a default RPC URL are provided. Chains are\n * identified by their alias, which is the same as the alias in the `[rpc_endpoints]` section of\n * the `foundry.toml` file. For best UX, ensure the alias in the `foundry.toml` file match the\n * alias used in this contract, which can be found as the first argument to the\n * `setChainWithDefaultRpcUrl` call in the `initializeStdChains` function.\n *\n * There are two main ways to use this contract:\n * 1. Set a chain with `setChain(string memory chainAlias, ChainData memory chain)` or\n * `setChain(string memory chainAlias, Chain memory chain)`\n * 2. Get a chain with `getChain(string memory chainAlias)` or `getChain(uint256 chainId)`.\n *\n * The first time either of those are used, chains are initialized with the default set of RPC URLs.\n * This is done in `initializeStdChains`, which uses `setChainWithDefaultRpcUrl`. Defaults are recorded in\n * `defaultRpcUrls`.\n *\n * The `setChain` function is straightforward, and it simply saves off the given chain data.\n *\n * The `getChain` methods use `getChainWithUpdatedRpcUrl` to return a chain. For example, let's say\n * we want to retrieve the RPC URL for `mainnet`:\n * - If you have specified data with `setChain`, it will return that.\n * - If you have configured a mainnet RPC URL in `foundry.toml`, it will return the URL, provided it\n * is valid (e.g. a URL is specified, or an environment variable is given and exists).\n * - If neither of the above conditions is met, the default data is returned.\n *\n * Summarizing the above, the prioritization hierarchy is `setChain` -> `foundry.toml` -> environment variable -> defaults.\n */\nabstract contract StdChains {\n VmSafe private constant vm = VmSafe(address(uint160(uint256(keccak256(\"hevm cheat code\")))));\n\n bool private stdChainsInitialized;\n\n struct ChainData {\n string name;\n uint256 chainId;\n string rpcUrl;\n }\n\n struct Chain {\n // The chain name.\n string name;\n // The chain's Chain ID.\n uint256 chainId;\n // The chain's alias. (i.e. what gets specified in `foundry.toml`).\n string chainAlias;\n // A default RPC endpoint for this chain.\n // NOTE: This default RPC URL is included for convenience to facilitate quick tests and\n // experimentation. Do not use this RPC URL for production test suites, CI, or other heavy\n // usage as you will be throttled and this is a disservice to others who need this endpoint.\n string rpcUrl;\n }\n\n // Maps from the chain's alias (matching the alias in the `foundry.toml` file) to chain data.\n mapping(string => Chain) private chains;\n // Maps from the chain's alias to it's default RPC URL.\n mapping(string => string) private defaultRpcUrls;\n // Maps from a chain ID to it's alias.\n mapping(uint256 => string) private idToAlias;\n\n bool private fallbackToDefaultRpcUrls = true;\n\n // The RPC URL will be fetched from config or defaultRpcUrls if possible.\n function getChain(string memory chainAlias) internal virtual returns (Chain memory chain) {\n require(bytes(chainAlias).length != 0, \"StdChains getChain(string): Chain alias cannot be the empty string.\");\n\n initializeStdChains();\n chain = chains[chainAlias];\n require(\n chain.chainId != 0,\n string(abi.encodePacked(\"StdChains getChain(string): Chain with alias \\\"\", chainAlias, \"\\\" not found.\"))\n );\n\n chain = getChainWithUpdatedRpcUrl(chainAlias, chain);\n }\n\n function getChain(uint256 chainId) internal virtual returns (Chain memory chain) {\n require(chainId != 0, \"StdChains getChain(uint256): Chain ID cannot be 0.\");\n initializeStdChains();\n string memory chainAlias = idToAlias[chainId];\n\n chain = chains[chainAlias];\n\n require(\n chain.chainId != 0,\n string(abi.encodePacked(\"StdChains getChain(uint256): Chain with ID \", vm.toString(chainId), \" not found.\"))\n );\n\n chain = getChainWithUpdatedRpcUrl(chainAlias, chain);\n }\n\n // set chain info, with priority to argument's rpcUrl field.\n function setChain(string memory chainAlias, ChainData memory chain) internal virtual {\n require(\n bytes(chainAlias).length != 0,\n \"StdChains setChain(string,ChainData): Chain alias cannot be the empty string.\"\n );\n\n require(chain.chainId != 0, \"StdChains setChain(string,ChainData): Chain ID cannot be 0.\");\n\n initializeStdChains();\n string memory foundAlias = idToAlias[chain.chainId];\n\n require(\n bytes(foundAlias).length == 0 || keccak256(bytes(foundAlias)) == keccak256(bytes(chainAlias)),\n string(\n abi.encodePacked(\n \"StdChains setChain(string,ChainData): Chain ID \",\n vm.toString(chain.chainId),\n \" already used by \\\"\",\n foundAlias,\n \"\\\".\"\n )\n )\n );\n\n uint256 oldChainId = chains[chainAlias].chainId;\n delete idToAlias[oldChainId];\n\n chains[chainAlias] =\n Chain({name: chain.name, chainId: chain.chainId, chainAlias: chainAlias, rpcUrl: chain.rpcUrl});\n idToAlias[chain.chainId] = chainAlias;\n }\n\n // set chain info, with priority to argument's rpcUrl field.\n function setChain(string memory chainAlias, Chain memory chain) internal virtual {\n setChain(chainAlias, ChainData({name: chain.name, chainId: chain.chainId, rpcUrl: chain.rpcUrl}));\n }\n\n function _toUpper(string memory str) private pure returns (string memory) {\n bytes memory strb = bytes(str);\n bytes memory copy = new bytes(strb.length);\n for (uint256 i = 0; i < strb.length; i++) {\n bytes1 b = strb[i];\n if (b >= 0x61 && b <= 0x7A) {\n copy[i] = bytes1(uint8(b) - 32);\n } else {\n copy[i] = b;\n }\n }\n return string(copy);\n }\n\n // lookup rpcUrl, in descending order of priority:\n // current -> config (foundry.toml) -> environment variable -> default\n function getChainWithUpdatedRpcUrl(string memory chainAlias, Chain memory chain)\n private\n view\n returns (Chain memory)\n {\n if (bytes(chain.rpcUrl).length == 0) {\n try vm.rpcUrl(chainAlias) returns (string memory configRpcUrl) {\n chain.rpcUrl = configRpcUrl;\n } catch (bytes memory err) {\n string memory envName = string(abi.encodePacked(_toUpper(chainAlias), \"_RPC_URL\"));\n if (fallbackToDefaultRpcUrls) {\n chain.rpcUrl = vm.envOr(envName, defaultRpcUrls[chainAlias]);\n } else {\n chain.rpcUrl = vm.envString(envName);\n }\n // Distinguish 'not found' from 'cannot read'\n // The upstream error thrown by forge for failing cheats changed so we check both the old and new versions\n bytes memory oldNotFoundError =\n abi.encodeWithSignature(\"CheatCodeError\", string(abi.encodePacked(\"invalid rpc url \", chainAlias)));\n bytes memory newNotFoundError = abi.encodeWithSignature(\n \"CheatcodeError(string)\", string(abi.encodePacked(\"invalid rpc url: \", chainAlias))\n );\n bytes32 errHash = keccak256(err);\n if (\n (errHash != keccak256(oldNotFoundError) && errHash != keccak256(newNotFoundError))\n || bytes(chain.rpcUrl).length == 0\n ) {\n /// @solidity memory-safe-assembly\n assembly {\n revert(add(32, err), mload(err))\n }\n }\n }\n }\n return chain;\n }\n\n function setFallbackToDefaultRpcUrls(bool useDefault) internal {\n fallbackToDefaultRpcUrls = useDefault;\n }\n\n function initializeStdChains() private {\n if (stdChainsInitialized) return;\n\n stdChainsInitialized = true;\n\n // If adding an RPC here, make sure to test the default RPC URL in `test_Rpcs` in `StdChains.t.sol`\n setChainWithDefaultRpcUrl(\"anvil\", ChainData(\"Anvil\", 31337, \"http://127.0.0.1:8545\"));\n setChainWithDefaultRpcUrl(\"mainnet\", ChainData(\"Mainnet\", 1, \"https://eth.llamarpc.com\"));\n setChainWithDefaultRpcUrl(\n \"sepolia\", ChainData(\"Sepolia\", 11155111, \"https://sepolia.infura.io/v3/b9794ad1ddf84dfb8c34d6bb5dca2001\")\n );\n setChainWithDefaultRpcUrl(\"holesky\", ChainData(\"Holesky\", 17000, \"https://rpc.holesky.ethpandaops.io\"));\n setChainWithDefaultRpcUrl(\"optimism\", ChainData(\"Optimism\", 10, \"https://mainnet.optimism.io\"));\n setChainWithDefaultRpcUrl(\n \"optimism_sepolia\", ChainData(\"Optimism Sepolia\", 11155420, \"https://sepolia.optimism.io\")\n );\n setChainWithDefaultRpcUrl(\"arbitrum_one\", ChainData(\"Arbitrum One\", 42161, \"https://arb1.arbitrum.io/rpc\"));\n setChainWithDefaultRpcUrl(\n \"arbitrum_one_sepolia\", ChainData(\"Arbitrum One Sepolia\", 421614, \"https://sepolia-rollup.arbitrum.io/rpc\")\n );\n setChainWithDefaultRpcUrl(\"arbitrum_nova\", ChainData(\"Arbitrum Nova\", 42170, \"https://nova.arbitrum.io/rpc\"));\n setChainWithDefaultRpcUrl(\"polygon\", ChainData(\"Polygon\", 137, \"https://polygon-rpc.com\"));\n setChainWithDefaultRpcUrl(\n \"polygon_amoy\", ChainData(\"Polygon Amoy\", 80002, \"https://rpc-amoy.polygon.technology\")\n );\n setChainWithDefaultRpcUrl(\"avalanche\", ChainData(\"Avalanche\", 43114, \"https://api.avax.network/ext/bc/C/rpc\"));\n setChainWithDefaultRpcUrl(\n \"avalanche_fuji\", ChainData(\"Avalanche Fuji\", 43113, \"https://api.avax-test.network/ext/bc/C/rpc\")\n );\n setChainWithDefaultRpcUrl(\n \"bnb_smart_chain\", ChainData(\"BNB Smart Chain\", 56, \"https://bsc-dataseed1.binance.org\")\n );\n setChainWithDefaultRpcUrl(\n \"bnb_smart_chain_testnet\",\n ChainData(\"BNB Smart Chain Testnet\", 97, \"https://rpc.ankr.com/bsc_testnet_chapel\")\n );\n setChainWithDefaultRpcUrl(\"gnosis_chain\", ChainData(\"Gnosis Chain\", 100, \"https://rpc.gnosischain.com\"));\n setChainWithDefaultRpcUrl(\"moonbeam\", ChainData(\"Moonbeam\", 1284, \"https://rpc.api.moonbeam.network\"));\n setChainWithDefaultRpcUrl(\n \"moonriver\", ChainData(\"Moonriver\", 1285, \"https://rpc.api.moonriver.moonbeam.network\")\n );\n setChainWithDefaultRpcUrl(\"moonbase\", ChainData(\"Moonbase\", 1287, \"https://rpc.testnet.moonbeam.network\"));\n setChainWithDefaultRpcUrl(\"base_sepolia\", ChainData(\"Base Sepolia\", 84532, \"https://sepolia.base.org\"));\n setChainWithDefaultRpcUrl(\"base\", ChainData(\"Base\", 8453, \"https://mainnet.base.org\"));\n setChainWithDefaultRpcUrl(\"blast_sepolia\", ChainData(\"Blast Sepolia\", 168587773, \"https://sepolia.blast.io\"));\n setChainWithDefaultRpcUrl(\"blast\", ChainData(\"Blast\", 81457, \"https://rpc.blast.io\"));\n setChainWithDefaultRpcUrl(\"fantom_opera\", ChainData(\"Fantom Opera\", 250, \"https://rpc.ankr.com/fantom/\"));\n setChainWithDefaultRpcUrl(\n \"fantom_opera_testnet\", ChainData(\"Fantom Opera Testnet\", 4002, \"https://rpc.ankr.com/fantom_testnet/\")\n );\n setChainWithDefaultRpcUrl(\"fraxtal\", ChainData(\"Fraxtal\", 252, \"https://rpc.frax.com\"));\n setChainWithDefaultRpcUrl(\"fraxtal_testnet\", ChainData(\"Fraxtal Testnet\", 2522, \"https://rpc.testnet.frax.com\"));\n setChainWithDefaultRpcUrl(\n \"berachain_bartio_testnet\", ChainData(\"Berachain bArtio Testnet\", 80084, \"https://bartio.rpc.berachain.com\")\n );\n setChainWithDefaultRpcUrl(\"flare\", ChainData(\"Flare\", 14, \"https://flare-api.flare.network/ext/C/rpc\"));\n setChainWithDefaultRpcUrl(\n \"flare_coston2\", ChainData(\"Flare Coston2\", 114, \"https://coston2-api.flare.network/ext/C/rpc\")\n );\n\n setChainWithDefaultRpcUrl(\"mode\", ChainData(\"Mode\", 34443, \"https://mode.drpc.org\"));\n setChainWithDefaultRpcUrl(\"mode_sepolia\", ChainData(\"Mode Sepolia\", 919, \"https://sepolia.mode.network\"));\n\n setChainWithDefaultRpcUrl(\"zora\", ChainData(\"Zora\", 7777777, \"https://zora.drpc.org\"));\n setChainWithDefaultRpcUrl(\n \"zora_sepolia\", ChainData(\"Zora Sepolia\", 999999999, \"https://sepolia.rpc.zora.energy\")\n );\n\n setChainWithDefaultRpcUrl(\"race\", ChainData(\"Race\", 6805, \"https://racemainnet.io\"));\n setChainWithDefaultRpcUrl(\"race_sepolia\", ChainData(\"Race Sepolia\", 6806, \"https://racemainnet.io\"));\n\n setChainWithDefaultRpcUrl(\"metal\", ChainData(\"Metal\", 1750, \"https://metall2.drpc.org\"));\n setChainWithDefaultRpcUrl(\"metal_sepolia\", ChainData(\"Metal Sepolia\", 1740, \"https://testnet.rpc.metall2.com\"));\n\n setChainWithDefaultRpcUrl(\"binary\", ChainData(\"Binary\", 624, \"https://rpc.zero.thebinaryholdings.com\"));\n setChainWithDefaultRpcUrl(\n \"binary_sepolia\", ChainData(\"Binary Sepolia\", 625, \"https://rpc.zero.thebinaryholdings.com\")\n );\n\n setChainWithDefaultRpcUrl(\"orderly\", ChainData(\"Orderly\", 291, \"https://rpc.orderly.network\"));\n setChainWithDefaultRpcUrl(\n \"orderly_sepolia\", ChainData(\"Orderly Sepolia\", 4460, \"https://testnet-rpc.orderly.org\")\n );\n }\n\n // set chain info, with priority to chainAlias' rpc url in foundry.toml\n function setChainWithDefaultRpcUrl(string memory chainAlias, ChainData memory chain) private {\n string memory rpcUrl = chain.rpcUrl;\n defaultRpcUrls[chainAlias] = rpcUrl;\n chain.rpcUrl = \"\";\n setChain(chainAlias, chain);\n chain.rpcUrl = rpcUrl; // restore argument\n }\n}\n","license":"MIT"},"lib/forge-std/src/StdCheats.sol":{"keccak256":"0x0fa6ec03602648b62cce41aab2096e6b7e052f2846075d967b6958dd586db746","urls":[],"content":"// SPDX-License-Identifier: MIT\npragma solidity >=0.6.2 <0.9.0;\n\npragma experimental ABIEncoderV2;\n\nimport {StdStorage, stdStorage} from \"./StdStorage.sol\";\nimport {console2} from \"./console2.sol\";\nimport {Vm} from \"./Vm.sol\";\n\nabstract contract StdCheatsSafe {\n Vm private constant vm = Vm(address(uint160(uint256(keccak256(\"hevm cheat code\")))));\n\n uint256 private constant UINT256_MAX =\n 115792089237316195423570985008687907853269984665640564039457584007913129639935;\n\n bool private gasMeteringOff;\n\n // Data structures to parse Transaction objects from the broadcast artifact\n // that conform to EIP1559. The Raw structs is what is parsed from the JSON\n // and then converted to the one that is used by the user for better UX.\n\n struct RawTx1559 {\n string[] arguments;\n address contractAddress;\n string contractName;\n // json value name = function\n string functionSig;\n bytes32 hash;\n // json value name = tx\n RawTx1559Detail txDetail;\n // json value name = type\n string opcode;\n }\n\n struct RawTx1559Detail {\n AccessList[] accessList;\n bytes data;\n address from;\n bytes gas;\n bytes nonce;\n address to;\n bytes txType;\n bytes value;\n }\n\n struct Tx1559 {\n string[] arguments;\n address contractAddress;\n string contractName;\n string functionSig;\n bytes32 hash;\n Tx1559Detail txDetail;\n string opcode;\n }\n\n struct Tx1559Detail {\n AccessList[] accessList;\n bytes data;\n address from;\n uint256 gas;\n uint256 nonce;\n address to;\n uint256 txType;\n uint256 value;\n }\n\n // Data structures to parse Transaction objects from the broadcast artifact\n // that DO NOT conform to EIP1559. The Raw structs is what is parsed from the JSON\n // and then converted to the one that is used by the user for better UX.\n\n struct TxLegacy {\n string[] arguments;\n address contractAddress;\n string contractName;\n string functionSig;\n string hash;\n string opcode;\n TxDetailLegacy transaction;\n }\n\n struct TxDetailLegacy {\n AccessList[] accessList;\n uint256 chainId;\n bytes data;\n address from;\n uint256 gas;\n uint256 gasPrice;\n bytes32 hash;\n uint256 nonce;\n bytes1 opcode;\n bytes32 r;\n bytes32 s;\n uint256 txType;\n address to;\n uint8 v;\n uint256 value;\n }\n\n struct AccessList {\n address accessAddress;\n bytes32[] storageKeys;\n }\n\n // Data structures to parse Receipt objects from the broadcast artifact.\n // The Raw structs is what is parsed from the JSON\n // and then converted to the one that is used by the user for better UX.\n\n struct RawReceipt {\n bytes32 blockHash;\n bytes blockNumber;\n address contractAddress;\n bytes cumulativeGasUsed;\n bytes effectiveGasPrice;\n address from;\n bytes gasUsed;\n RawReceiptLog[] logs;\n bytes logsBloom;\n bytes status;\n address to;\n bytes32 transactionHash;\n bytes transactionIndex;\n }\n\n struct Receipt {\n bytes32 blockHash;\n uint256 blockNumber;\n address contractAddress;\n uint256 cumulativeGasUsed;\n uint256 effectiveGasPrice;\n address from;\n uint256 gasUsed;\n ReceiptLog[] logs;\n bytes logsBloom;\n uint256 status;\n address to;\n bytes32 transactionHash;\n uint256 transactionIndex;\n }\n\n // Data structures to parse the entire broadcast artifact, assuming the\n // transactions conform to EIP1559.\n\n struct EIP1559ScriptArtifact {\n string[] libraries;\n string path;\n string[] pending;\n Receipt[] receipts;\n uint256 timestamp;\n Tx1559[] transactions;\n TxReturn[] txReturns;\n }\n\n struct RawEIP1559ScriptArtifact {\n string[] libraries;\n string path;\n string[] pending;\n RawReceipt[] receipts;\n TxReturn[] txReturns;\n uint256 timestamp;\n RawTx1559[] transactions;\n }\n\n struct RawReceiptLog {\n // json value = address\n address logAddress;\n bytes32 blockHash;\n bytes blockNumber;\n bytes data;\n bytes logIndex;\n bool removed;\n bytes32[] topics;\n bytes32 transactionHash;\n bytes transactionIndex;\n bytes transactionLogIndex;\n }\n\n struct ReceiptLog {\n // json value = address\n address logAddress;\n bytes32 blockHash;\n uint256 blockNumber;\n bytes data;\n uint256 logIndex;\n bytes32[] topics;\n uint256 transactionIndex;\n uint256 transactionLogIndex;\n bool removed;\n }\n\n struct TxReturn {\n string internalType;\n string value;\n }\n\n struct Account {\n address addr;\n uint256 key;\n }\n\n enum AddressType {\n Payable,\n NonPayable,\n ZeroAddress,\n Precompile,\n ForgeAddress\n }\n\n // Checks that `addr` is not blacklisted by token contracts that have a blacklist.\n function assumeNotBlacklisted(address token, address addr) internal view virtual {\n // Nothing to check if `token` is not a contract.\n uint256 tokenCodeSize;\n assembly {\n tokenCodeSize := extcodesize(token)\n }\n require(tokenCodeSize > 0, \"StdCheats assumeNotBlacklisted(address,address): Token address is not a contract.\");\n\n bool success;\n bytes memory returnData;\n\n // 4-byte selector for `isBlacklisted(address)`, used by USDC.\n (success, returnData) = token.staticcall(abi.encodeWithSelector(0xfe575a87, addr));\n vm.assume(!success || abi.decode(returnData, (bool)) == false);\n\n // 4-byte selector for `isBlackListed(address)`, used by USDT.\n (success, returnData) = token.staticcall(abi.encodeWithSelector(0xe47d6060, addr));\n vm.assume(!success || abi.decode(returnData, (bool)) == false);\n }\n\n // Checks that `addr` is not blacklisted by token contracts that have a blacklist.\n // This is identical to `assumeNotBlacklisted(address,address)` but with a different name, for\n // backwards compatibility, since this name was used in the original PR which already has\n // a release. This function can be removed in a future release once we want a breaking change.\n function assumeNoBlacklisted(address token, address addr) internal view virtual {\n assumeNotBlacklisted(token, addr);\n }\n\n function assumeAddressIsNot(address addr, AddressType addressType) internal virtual {\n if (addressType == AddressType.Payable) {\n assumeNotPayable(addr);\n } else if (addressType == AddressType.NonPayable) {\n assumePayable(addr);\n } else if (addressType == AddressType.ZeroAddress) {\n assumeNotZeroAddress(addr);\n } else if (addressType == AddressType.Precompile) {\n assumeNotPrecompile(addr);\n } else if (addressType == AddressType.ForgeAddress) {\n assumeNotForgeAddress(addr);\n }\n }\n\n function assumeAddressIsNot(address addr, AddressType addressType1, AddressType addressType2) internal virtual {\n assumeAddressIsNot(addr, addressType1);\n assumeAddressIsNot(addr, addressType2);\n }\n\n function assumeAddressIsNot(\n address addr,\n AddressType addressType1,\n AddressType addressType2,\n AddressType addressType3\n ) internal virtual {\n assumeAddressIsNot(addr, addressType1);\n assumeAddressIsNot(addr, addressType2);\n assumeAddressIsNot(addr, addressType3);\n }\n\n function assumeAddressIsNot(\n address addr,\n AddressType addressType1,\n AddressType addressType2,\n AddressType addressType3,\n AddressType addressType4\n ) internal virtual {\n assumeAddressIsNot(addr, addressType1);\n assumeAddressIsNot(addr, addressType2);\n assumeAddressIsNot(addr, addressType3);\n assumeAddressIsNot(addr, addressType4);\n }\n\n // This function checks whether an address, `addr`, is payable. It works by sending 1 wei to\n // `addr` and checking the `success` return value.\n // NOTE: This function may result in state changes depending on the fallback/receive logic\n // implemented by `addr`, which should be taken into account when this function is used.\n function _isPayable(address addr) private returns (bool) {\n require(\n addr.balance < UINT256_MAX,\n \"StdCheats _isPayable(address): Balance equals max uint256, so it cannot receive any more funds\"\n );\n uint256 origBalanceTest = address(this).balance;\n uint256 origBalanceAddr = address(addr).balance;\n\n vm.deal(address(this), 1);\n (bool success,) = payable(addr).call{value: 1}(\"\");\n\n // reset balances\n vm.deal(address(this), origBalanceTest);\n vm.deal(addr, origBalanceAddr);\n\n return success;\n }\n\n // NOTE: This function may result in state changes depending on the fallback/receive logic\n // implemented by `addr`, which should be taken into account when this function is used. See the\n // `_isPayable` method for more information.\n function assumePayable(address addr) internal virtual {\n vm.assume(_isPayable(addr));\n }\n\n function assumeNotPayable(address addr) internal virtual {\n vm.assume(!_isPayable(addr));\n }\n\n function assumeNotZeroAddress(address addr) internal pure virtual {\n vm.assume(addr != address(0));\n }\n\n function assumeNotPrecompile(address addr) internal pure virtual {\n assumeNotPrecompile(addr, _pureChainId());\n }\n\n function assumeNotPrecompile(address addr, uint256 chainId) internal pure virtual {\n // Note: For some chains like Optimism these are technically predeploys (i.e. bytecode placed at a specific\n // address), but the same rationale for excluding them applies so we include those too.\n\n // These are reserved by Ethereum and may be on all EVM-compatible chains.\n vm.assume(addr < address(0x1) || addr > address(0xff));\n\n // forgefmt: disable-start\n if (chainId == 10 || chainId == 420) {\n // https://github.com/ethereum-optimism/optimism/blob/eaa371a0184b56b7ca6d9eb9cb0a2b78b2ccd864/op-bindings/predeploys/addresses.go#L6-L21\n vm.assume(addr < address(0x4200000000000000000000000000000000000000) || addr > address(0x4200000000000000000000000000000000000800));\n } else if (chainId == 42161 || chainId == 421613) {\n // https://developer.arbitrum.io/useful-addresses#arbitrum-precompiles-l2-same-on-all-arb-chains\n vm.assume(addr < address(0x0000000000000000000000000000000000000064) || addr > address(0x0000000000000000000000000000000000000068));\n } else if (chainId == 43114 || chainId == 43113) {\n // https://github.com/ava-labs/subnet-evm/blob/47c03fd007ecaa6de2c52ea081596e0a88401f58/precompile/params.go#L18-L59\n vm.assume(addr < address(0x0100000000000000000000000000000000000000) || addr > address(0x01000000000000000000000000000000000000ff));\n vm.assume(addr < address(0x0200000000000000000000000000000000000000) || addr > address(0x02000000000000000000000000000000000000FF));\n vm.assume(addr < address(0x0300000000000000000000000000000000000000) || addr > address(0x03000000000000000000000000000000000000Ff));\n }\n // forgefmt: disable-end\n }\n\n function assumeNotForgeAddress(address addr) internal pure virtual {\n // vm, console, and Create2Deployer addresses\n vm.assume(\n addr != address(vm) && addr != 0x000000000000000000636F6e736F6c652e6c6f67\n && addr != 0x4e59b44847b379578588920cA78FbF26c0B4956C\n );\n }\n\n function assumeUnusedAddress(address addr) internal view virtual {\n uint256 size;\n assembly {\n size := extcodesize(addr)\n }\n vm.assume(size == 0);\n\n assumeNotPrecompile(addr);\n assumeNotZeroAddress(addr);\n assumeNotForgeAddress(addr);\n }\n\n function readEIP1559ScriptArtifact(string memory path)\n internal\n view\n virtual\n returns (EIP1559ScriptArtifact memory)\n {\n string memory data = vm.readFile(path);\n bytes memory parsedData = vm.parseJson(data);\n RawEIP1559ScriptArtifact memory rawArtifact = abi.decode(parsedData, (RawEIP1559ScriptArtifact));\n EIP1559ScriptArtifact memory artifact;\n artifact.libraries = rawArtifact.libraries;\n artifact.path = rawArtifact.path;\n artifact.timestamp = rawArtifact.timestamp;\n artifact.pending = rawArtifact.pending;\n artifact.txReturns = rawArtifact.txReturns;\n artifact.receipts = rawToConvertedReceipts(rawArtifact.receipts);\n artifact.transactions = rawToConvertedEIPTx1559s(rawArtifact.transactions);\n return artifact;\n }\n\n function rawToConvertedEIPTx1559s(RawTx1559[] memory rawTxs) internal pure virtual returns (Tx1559[] memory) {\n Tx1559[] memory txs = new Tx1559[](rawTxs.length);\n for (uint256 i; i < rawTxs.length; i++) {\n txs[i] = rawToConvertedEIPTx1559(rawTxs[i]);\n }\n return txs;\n }\n\n function rawToConvertedEIPTx1559(RawTx1559 memory rawTx) internal pure virtual returns (Tx1559 memory) {\n Tx1559 memory transaction;\n transaction.arguments = rawTx.arguments;\n transaction.contractName = rawTx.contractName;\n transaction.functionSig = rawTx.functionSig;\n transaction.hash = rawTx.hash;\n transaction.txDetail = rawToConvertedEIP1559Detail(rawTx.txDetail);\n transaction.opcode = rawTx.opcode;\n return transaction;\n }\n\n function rawToConvertedEIP1559Detail(RawTx1559Detail memory rawDetail)\n internal\n pure\n virtual\n returns (Tx1559Detail memory)\n {\n Tx1559Detail memory txDetail;\n txDetail.data = rawDetail.data;\n txDetail.from = rawDetail.from;\n txDetail.to = rawDetail.to;\n txDetail.nonce = _bytesToUint(rawDetail.nonce);\n txDetail.txType = _bytesToUint(rawDetail.txType);\n txDetail.value = _bytesToUint(rawDetail.value);\n txDetail.gas = _bytesToUint(rawDetail.gas);\n txDetail.accessList = rawDetail.accessList;\n return txDetail;\n }\n\n function readTx1559s(string memory path) internal view virtual returns (Tx1559[] memory) {\n string memory deployData = vm.readFile(path);\n bytes memory parsedDeployData = vm.parseJson(deployData, \".transactions\");\n RawTx1559[] memory rawTxs = abi.decode(parsedDeployData, (RawTx1559[]));\n return rawToConvertedEIPTx1559s(rawTxs);\n }\n\n function readTx1559(string memory path, uint256 index) internal view virtual returns (Tx1559 memory) {\n string memory deployData = vm.readFile(path);\n string memory key = string(abi.encodePacked(\".transactions[\", vm.toString(index), \"]\"));\n bytes memory parsedDeployData = vm.parseJson(deployData, key);\n RawTx1559 memory rawTx = abi.decode(parsedDeployData, (RawTx1559));\n return rawToConvertedEIPTx1559(rawTx);\n }\n\n // Analogous to readTransactions, but for receipts.\n function readReceipts(string memory path) internal view virtual returns (Receipt[] memory) {\n string memory deployData = vm.readFile(path);\n bytes memory parsedDeployData = vm.parseJson(deployData, \".receipts\");\n RawReceipt[] memory rawReceipts = abi.decode(parsedDeployData, (RawReceipt[]));\n return rawToConvertedReceipts(rawReceipts);\n }\n\n function readReceipt(string memory path, uint256 index) internal view virtual returns (Receipt memory) {\n string memory deployData = vm.readFile(path);\n string memory key = string(abi.encodePacked(\".receipts[\", vm.toString(index), \"]\"));\n bytes memory parsedDeployData = vm.parseJson(deployData, key);\n RawReceipt memory rawReceipt = abi.decode(parsedDeployData, (RawReceipt));\n return rawToConvertedReceipt(rawReceipt);\n }\n\n function rawToConvertedReceipts(RawReceipt[] memory rawReceipts) internal pure virtual returns (Receipt[] memory) {\n Receipt[] memory receipts = new Receipt[](rawReceipts.length);\n for (uint256 i; i < rawReceipts.length; i++) {\n receipts[i] = rawToConvertedReceipt(rawReceipts[i]);\n }\n return receipts;\n }\n\n function rawToConvertedReceipt(RawReceipt memory rawReceipt) internal pure virtual returns (Receipt memory) {\n Receipt memory receipt;\n receipt.blockHash = rawReceipt.blockHash;\n receipt.to = rawReceipt.to;\n receipt.from = rawReceipt.from;\n receipt.contractAddress = rawReceipt.contractAddress;\n receipt.effectiveGasPrice = _bytesToUint(rawReceipt.effectiveGasPrice);\n receipt.cumulativeGasUsed = _bytesToUint(rawReceipt.cumulativeGasUsed);\n receipt.gasUsed = _bytesToUint(rawReceipt.gasUsed);\n receipt.status = _bytesToUint(rawReceipt.status);\n receipt.transactionIndex = _bytesToUint(rawReceipt.transactionIndex);\n receipt.blockNumber = _bytesToUint(rawReceipt.blockNumber);\n receipt.logs = rawToConvertedReceiptLogs(rawReceipt.logs);\n receipt.logsBloom = rawReceipt.logsBloom;\n receipt.transactionHash = rawReceipt.transactionHash;\n return receipt;\n }\n\n function rawToConvertedReceiptLogs(RawReceiptLog[] memory rawLogs)\n internal\n pure\n virtual\n returns (ReceiptLog[] memory)\n {\n ReceiptLog[] memory logs = new ReceiptLog[](rawLogs.length);\n for (uint256 i; i < rawLogs.length; i++) {\n logs[i].logAddress = rawLogs[i].logAddress;\n logs[i].blockHash = rawLogs[i].blockHash;\n logs[i].blockNumber = _bytesToUint(rawLogs[i].blockNumber);\n logs[i].data = rawLogs[i].data;\n logs[i].logIndex = _bytesToUint(rawLogs[i].logIndex);\n logs[i].topics = rawLogs[i].topics;\n logs[i].transactionIndex = _bytesToUint(rawLogs[i].transactionIndex);\n logs[i].transactionLogIndex = _bytesToUint(rawLogs[i].transactionLogIndex);\n logs[i].removed = rawLogs[i].removed;\n }\n return logs;\n }\n\n // Deploy a contract by fetching the contract bytecode from\n // the artifacts directory\n // e.g. `deployCode(code, abi.encode(arg1,arg2,arg3))`\n function deployCode(string memory what, bytes memory args) internal virtual returns (address addr) {\n bytes memory bytecode = abi.encodePacked(vm.getCode(what), args);\n /// @solidity memory-safe-assembly\n assembly {\n addr := create(0, add(bytecode, 0x20), mload(bytecode))\n }\n\n require(addr != address(0), \"StdCheats deployCode(string,bytes): Deployment failed.\");\n }\n\n function deployCode(string memory what) internal virtual returns (address addr) {\n bytes memory bytecode = vm.getCode(what);\n /// @solidity memory-safe-assembly\n assembly {\n addr := create(0, add(bytecode, 0x20), mload(bytecode))\n }\n\n require(addr != address(0), \"StdCheats deployCode(string): Deployment failed.\");\n }\n\n /// @dev deploy contract with value on construction\n function deployCode(string memory what, bytes memory args, uint256 val) internal virtual returns (address addr) {\n bytes memory bytecode = abi.encodePacked(vm.getCode(what), args);\n /// @solidity memory-safe-assembly\n assembly {\n addr := create(val, add(bytecode, 0x20), mload(bytecode))\n }\n\n require(addr != address(0), \"StdCheats deployCode(string,bytes,uint256): Deployment failed.\");\n }\n\n function deployCode(string memory what, uint256 val) internal virtual returns (address addr) {\n bytes memory bytecode = vm.getCode(what);\n /// @solidity memory-safe-assembly\n assembly {\n addr := create(val, add(bytecode, 0x20), mload(bytecode))\n }\n\n require(addr != address(0), \"StdCheats deployCode(string,uint256): Deployment failed.\");\n }\n\n // creates a labeled address and the corresponding private key\n function makeAddrAndKey(string memory name) internal virtual returns (address addr, uint256 privateKey) {\n privateKey = uint256(keccak256(abi.encodePacked(name)));\n addr = vm.addr(privateKey);\n vm.label(addr, name);\n }\n\n // creates a labeled address\n function makeAddr(string memory name) internal virtual returns (address addr) {\n (addr,) = makeAddrAndKey(name);\n }\n\n // Destroys an account immediately, sending the balance to beneficiary.\n // Destroying means: balance will be zero, code will be empty, and nonce will be 0\n // This is similar to selfdestruct but not identical: selfdestruct destroys code and nonce\n // only after tx ends, this will run immediately.\n function destroyAccount(address who, address beneficiary) internal virtual {\n uint256 currBalance = who.balance;\n vm.etch(who, abi.encode());\n vm.deal(who, 0);\n vm.resetNonce(who);\n\n uint256 beneficiaryBalance = beneficiary.balance;\n vm.deal(beneficiary, currBalance + beneficiaryBalance);\n }\n\n // creates a struct containing both a labeled address and the corresponding private key\n function makeAccount(string memory name) internal virtual returns (Account memory account) {\n (account.addr, account.key) = makeAddrAndKey(name);\n }\n\n function deriveRememberKey(string memory mnemonic, uint32 index)\n internal\n virtual\n returns (address who, uint256 privateKey)\n {\n privateKey = vm.deriveKey(mnemonic, index);\n who = vm.rememberKey(privateKey);\n }\n\n function _bytesToUint(bytes memory b) private pure returns (uint256) {\n require(b.length <= 32, \"StdCheats _bytesToUint(bytes): Bytes length exceeds 32.\");\n return abi.decode(abi.encodePacked(new bytes(32 - b.length), b), (uint256));\n }\n\n function isFork() internal view virtual returns (bool status) {\n try vm.activeFork() {\n status = true;\n } catch (bytes memory) {}\n }\n\n modifier skipWhenForking() {\n if (!isFork()) {\n _;\n }\n }\n\n modifier skipWhenNotForking() {\n if (isFork()) {\n _;\n }\n }\n\n modifier noGasMetering() {\n vm.pauseGasMetering();\n // To prevent turning gas monitoring back on with nested functions that use this modifier,\n // we check if gasMetering started in the off position. If it did, we don't want to turn\n // it back on until we exit the top level function that used the modifier\n //\n // i.e. funcA() noGasMetering { funcB() }, where funcB has noGasMetering as well.\n // funcA will have `gasStartedOff` as false, funcB will have it as true,\n // so we only turn metering back on at the end of the funcA\n bool gasStartedOff = gasMeteringOff;\n gasMeteringOff = true;\n\n _;\n\n // if gas metering was on when this modifier was called, turn it back on at the end\n if (!gasStartedOff) {\n gasMeteringOff = false;\n vm.resumeGasMetering();\n }\n }\n\n // We use this complex approach of `_viewChainId` and `_pureChainId` to ensure there are no\n // compiler warnings when accessing chain ID in any solidity version supported by forge-std. We\n // can't simply access the chain ID in a normal view or pure function because the solc View Pure\n // Checker changed `chainid` from pure to view in 0.8.0.\n function _viewChainId() private view returns (uint256 chainId) {\n // Assembly required since `block.chainid` was introduced in 0.8.0.\n assembly {\n chainId := chainid()\n }\n\n address(this); // Silence warnings in older Solc versions.\n }\n\n function _pureChainId() private pure returns (uint256 chainId) {\n function() internal view returns (uint256) fnIn = _viewChainId;\n function() internal pure returns (uint256) pureChainId;\n assembly {\n pureChainId := fnIn\n }\n chainId = pureChainId();\n }\n}\n\n// Wrappers around cheatcodes to avoid footguns\nabstract contract StdCheats is StdCheatsSafe {\n using stdStorage for StdStorage;\n\n StdStorage private stdstore;\n Vm private constant vm = Vm(address(uint160(uint256(keccak256(\"hevm cheat code\")))));\n address private constant CONSOLE2_ADDRESS = 0x000000000000000000636F6e736F6c652e6c6f67;\n\n // Skip forward or rewind time by the specified number of seconds\n function skip(uint256 time) internal virtual {\n vm.warp(vm.getBlockTimestamp() + time);\n }\n\n function rewind(uint256 time) internal virtual {\n vm.warp(vm.getBlockTimestamp() - time);\n }\n\n // Setup a prank from an address that has some ether\n function hoax(address msgSender) internal virtual {\n vm.deal(msgSender, 1 << 128);\n vm.prank(msgSender);\n }\n\n function hoax(address msgSender, uint256 give) internal virtual {\n vm.deal(msgSender, give);\n vm.prank(msgSender);\n }\n\n function hoax(address msgSender, address origin) internal virtual {\n vm.deal(msgSender, 1 << 128);\n vm.prank(msgSender, origin);\n }\n\n function hoax(address msgSender, address origin, uint256 give) internal virtual {\n vm.deal(msgSender, give);\n vm.prank(msgSender, origin);\n }\n\n // Start perpetual prank from an address that has some ether\n function startHoax(address msgSender) internal virtual {\n vm.deal(msgSender, 1 << 128);\n vm.startPrank(msgSender);\n }\n\n function startHoax(address msgSender, uint256 give) internal virtual {\n vm.deal(msgSender, give);\n vm.startPrank(msgSender);\n }\n\n // Start perpetual prank from an address that has some ether\n // tx.origin is set to the origin parameter\n function startHoax(address msgSender, address origin) internal virtual {\n vm.deal(msgSender, 1 << 128);\n vm.startPrank(msgSender, origin);\n }\n\n function startHoax(address msgSender, address origin, uint256 give) internal virtual {\n vm.deal(msgSender, give);\n vm.startPrank(msgSender, origin);\n }\n\n function changePrank(address msgSender) internal virtual {\n console2_log_StdCheats(\"changePrank is deprecated. Please use vm.startPrank instead.\");\n vm.stopPrank();\n vm.startPrank(msgSender);\n }\n\n function changePrank(address msgSender, address txOrigin) internal virtual {\n vm.stopPrank();\n vm.startPrank(msgSender, txOrigin);\n }\n\n // The same as Vm's `deal`\n // Use the alternative signature for ERC20 tokens\n function deal(address to, uint256 give) internal virtual {\n vm.deal(to, give);\n }\n\n // Set the balance of an account for any ERC20 token\n // Use the alternative signature to update `totalSupply`\n function deal(address token, address to, uint256 give) internal virtual {\n deal(token, to, give, false);\n }\n\n // Set the balance of an account for any ERC1155 token\n // Use the alternative signature to update `totalSupply`\n function dealERC1155(address token, address to, uint256 id, uint256 give) internal virtual {\n dealERC1155(token, to, id, give, false);\n }\n\n function deal(address token, address to, uint256 give, bool adjust) internal virtual {\n // get current balance\n (, bytes memory balData) = token.staticcall(abi.encodeWithSelector(0x70a08231, to));\n uint256 prevBal = abi.decode(balData, (uint256));\n\n // update balance\n stdstore.target(token).sig(0x70a08231).with_key(to).checked_write(give);\n\n // update total supply\n if (adjust) {\n (, bytes memory totSupData) = token.staticcall(abi.encodeWithSelector(0x18160ddd));\n uint256 totSup = abi.decode(totSupData, (uint256));\n if (give < prevBal) {\n totSup -= (prevBal - give);\n } else {\n totSup += (give - prevBal);\n }\n stdstore.target(token).sig(0x18160ddd).checked_write(totSup);\n }\n }\n\n function dealERC1155(address token, address to, uint256 id, uint256 give, bool adjust) internal virtual {\n // get current balance\n (, bytes memory balData) = token.staticcall(abi.encodeWithSelector(0x00fdd58e, to, id));\n uint256 prevBal = abi.decode(balData, (uint256));\n\n // update balance\n stdstore.target(token).sig(0x00fdd58e).with_key(to).with_key(id).checked_write(give);\n\n // update total supply\n if (adjust) {\n (, bytes memory totSupData) = token.staticcall(abi.encodeWithSelector(0xbd85b039, id));\n require(\n totSupData.length != 0,\n \"StdCheats deal(address,address,uint,uint,bool): target contract is not ERC1155Supply.\"\n );\n uint256 totSup = abi.decode(totSupData, (uint256));\n if (give < prevBal) {\n totSup -= (prevBal - give);\n } else {\n totSup += (give - prevBal);\n }\n stdstore.target(token).sig(0xbd85b039).with_key(id).checked_write(totSup);\n }\n }\n\n function dealERC721(address token, address to, uint256 id) internal virtual {\n // check if token id is already minted and the actual owner.\n (bool successMinted, bytes memory ownerData) = token.staticcall(abi.encodeWithSelector(0x6352211e, id));\n require(successMinted, \"StdCheats deal(address,address,uint,bool): id not minted.\");\n\n // get owner current balance\n (, bytes memory fromBalData) =\n token.staticcall(abi.encodeWithSelector(0x70a08231, abi.decode(ownerData, (address))));\n uint256 fromPrevBal = abi.decode(fromBalData, (uint256));\n\n // get new user current balance\n (, bytes memory toBalData) = token.staticcall(abi.encodeWithSelector(0x70a08231, to));\n uint256 toPrevBal = abi.decode(toBalData, (uint256));\n\n // update balances\n stdstore.target(token).sig(0x70a08231).with_key(abi.decode(ownerData, (address))).checked_write(--fromPrevBal);\n stdstore.target(token).sig(0x70a08231).with_key(to).checked_write(++toPrevBal);\n\n // update owner\n stdstore.target(token).sig(0x6352211e).with_key(id).checked_write(to);\n }\n\n function deployCodeTo(string memory what, address where) internal virtual {\n deployCodeTo(what, \"\", 0, where);\n }\n\n function deployCodeTo(string memory what, bytes memory args, address where) internal virtual {\n deployCodeTo(what, args, 0, where);\n }\n\n function deployCodeTo(string memory what, bytes memory args, uint256 value, address where) internal virtual {\n bytes memory creationCode = vm.getCode(what);\n vm.etch(where, abi.encodePacked(creationCode, args));\n (bool success, bytes memory runtimeBytecode) = where.call{value: value}(\"\");\n require(success, \"StdCheats deployCodeTo(string,bytes,uint256,address): Failed to create runtime bytecode.\");\n vm.etch(where, runtimeBytecode);\n }\n\n // Used to prevent the compilation of console, which shortens the compilation time when console is not used elsewhere.\n function console2_log_StdCheats(string memory p0) private view {\n (bool status,) = address(CONSOLE2_ADDRESS).staticcall(abi.encodeWithSignature(\"log(string)\", p0));\n status;\n }\n}\n","license":"MIT"},"lib/forge-std/src/StdConstants.sol":{"keccak256":"0x319ccdabfa2c0b2428301445873270ffea20f0e039d4fd5e6eeba65158e4e534","urls":[],"content":"// SPDX-License-Identifier: MIT\npragma solidity >=0.6.2 <0.9.0;\n\nimport {IMulticall3} from \"./interfaces/IMulticall3.sol\";\nimport {Vm} from \"./Vm.sol\";\n\nlibrary StdConstants {\n /// @dev Cheat code address.\n /// Calculated as `address(uint160(uint256(keccak256(\"hevm cheat code\"))))`.\n Vm internal constant VM = Vm(0x7109709ECfa91a80626fF3989D68f67F5b1DD12D);\n /// @dev console.sol and console2.sol work by executing a staticcall to this address.\n /// Calculated as `address(uint160(uint88(bytes11(\"console.log\"))))`.\n address internal constant CONSOLE = 0x000000000000000000636F6e736F6c652e6c6f67;\n /// @dev Used when deploying with create2.\n /// Taken from https://github.com/Arachnid/deterministic-deployment-proxy.\n address internal constant CREATE2_FACTORY = 0x4e59b44847b379578588920cA78FbF26c0B4956C;\n /// @dev The default address for tx.origin and msg.sender.\n /// Calculated as `address(uint160(uint256(keccak256(\"foundry default caller\"))))`.\n address internal constant DEFAULT_SENDER = 0x1804c8AB1F12E6bbf3894d4083f33e07309d1f38;\n /// @dev The address of the first contract `CREATE`d by a running test contract.\n /// When running tests, each test contract is `CREATE`d by `DEFAULT_SENDER` with nonce 1.\n /// Calculated as `VM.computeCreateAddress(VM.computeCreateAddress(DEFAULT_SENDER, 1), 1)`.\n address internal constant DEFAULT_TEST_CONTRACT = 0x5615dEB798BB3E4dFa0139dFa1b3D433Cc23b72f;\n /// @dev Deterministic deployment address of the Multicall3 contract.\n /// Taken from https://www.multicall3.com.\n IMulticall3 internal constant MULTICALL3_ADDRESS = IMulticall3(0xcA11bde05977b3631167028862bE2a173976CA11);\n /// @dev The order of the secp256k1 curve.\n uint256 internal constant SECP256K1_ORDER =\n 115792089237316195423570985008687907852837564279074904382605163141518161494337;\n}\n","license":"MIT"},"lib/forge-std/src/StdJson.sol":{"keccak256":"0xbc0132abe1c2accc2867c0f03667afffdf92f3e95a581bb03c9557eaa38ea500","urls":[],"content":"// SPDX-License-Identifier: MIT\npragma solidity >=0.6.0 <0.9.0;\n\npragma experimental ABIEncoderV2;\n\nimport {VmSafe} from \"./Vm.sol\";\n\n// Helpers for parsing and writing JSON files\n// To parse:\n// ```\n// using stdJson for string;\n// string memory json = vm.readFile(\"\");\n// json.readUint(\"\");\n// ```\n// To write:\n// ```\n// using stdJson for string;\n// string memory json = \"json\";\n// json.serialize(\"a\", uint256(123));\n// string memory semiFinal = json.serialize(\"b\", string(\"test\"));\n// string memory finalJson = json.serialize(\"c\", semiFinal);\n// finalJson.write(\"\");\n// ```\n\nlibrary stdJson {\n VmSafe private constant vm = VmSafe(address(uint160(uint256(keccak256(\"hevm cheat code\")))));\n\n function keyExists(string memory json, string memory key) internal view returns (bool) {\n return vm.keyExistsJson(json, key);\n }\n\n function parseRaw(string memory json, string memory key) internal pure returns (bytes memory) {\n return vm.parseJson(json, key);\n }\n\n function readUint(string memory json, string memory key) internal pure returns (uint256) {\n return vm.parseJsonUint(json, key);\n }\n\n function readUintArray(string memory json, string memory key) internal pure returns (uint256[] memory) {\n return vm.parseJsonUintArray(json, key);\n }\n\n function readInt(string memory json, string memory key) internal pure returns (int256) {\n return vm.parseJsonInt(json, key);\n }\n\n function readIntArray(string memory json, string memory key) internal pure returns (int256[] memory) {\n return vm.parseJsonIntArray(json, key);\n }\n\n function readBytes32(string memory json, string memory key) internal pure returns (bytes32) {\n return vm.parseJsonBytes32(json, key);\n }\n\n function readBytes32Array(string memory json, string memory key) internal pure returns (bytes32[] memory) {\n return vm.parseJsonBytes32Array(json, key);\n }\n\n function readString(string memory json, string memory key) internal pure returns (string memory) {\n return vm.parseJsonString(json, key);\n }\n\n function readStringArray(string memory json, string memory key) internal pure returns (string[] memory) {\n return vm.parseJsonStringArray(json, key);\n }\n\n function readAddress(string memory json, string memory key) internal pure returns (address) {\n return vm.parseJsonAddress(json, key);\n }\n\n function readAddressArray(string memory json, string memory key) internal pure returns (address[] memory) {\n return vm.parseJsonAddressArray(json, key);\n }\n\n function readBool(string memory json, string memory key) internal pure returns (bool) {\n return vm.parseJsonBool(json, key);\n }\n\n function readBoolArray(string memory json, string memory key) internal pure returns (bool[] memory) {\n return vm.parseJsonBoolArray(json, key);\n }\n\n function readBytes(string memory json, string memory key) internal pure returns (bytes memory) {\n return vm.parseJsonBytes(json, key);\n }\n\n function readBytesArray(string memory json, string memory key) internal pure returns (bytes[] memory) {\n return vm.parseJsonBytesArray(json, key);\n }\n\n function readUintOr(string memory json, string memory key, uint256 defaultValue) internal view returns (uint256) {\n return keyExists(json, key) ? readUint(json, key) : defaultValue;\n }\n\n function readUintArrayOr(string memory json, string memory key, uint256[] memory defaultValue)\n internal\n view\n returns (uint256[] memory)\n {\n return keyExists(json, key) ? readUintArray(json, key) : defaultValue;\n }\n\n function readIntOr(string memory json, string memory key, int256 defaultValue) internal view returns (int256) {\n return keyExists(json, key) ? readInt(json, key) : defaultValue;\n }\n\n function readIntArrayOr(string memory json, string memory key, int256[] memory defaultValue)\n internal\n view\n returns (int256[] memory)\n {\n return keyExists(json, key) ? readIntArray(json, key) : defaultValue;\n }\n\n function readBytes32Or(string memory json, string memory key, bytes32 defaultValue)\n internal\n view\n returns (bytes32)\n {\n return keyExists(json, key) ? readBytes32(json, key) : defaultValue;\n }\n\n function readBytes32ArrayOr(string memory json, string memory key, bytes32[] memory defaultValue)\n internal\n view\n returns (bytes32[] memory)\n {\n return keyExists(json, key) ? readBytes32Array(json, key) : defaultValue;\n }\n\n function readStringOr(string memory json, string memory key, string memory defaultValue)\n internal\n view\n returns (string memory)\n {\n return keyExists(json, key) ? readString(json, key) : defaultValue;\n }\n\n function readStringArrayOr(string memory json, string memory key, string[] memory defaultValue)\n internal\n view\n returns (string[] memory)\n {\n return keyExists(json, key) ? readStringArray(json, key) : defaultValue;\n }\n\n function readAddressOr(string memory json, string memory key, address defaultValue)\n internal\n view\n returns (address)\n {\n return keyExists(json, key) ? readAddress(json, key) : defaultValue;\n }\n\n function readAddressArrayOr(string memory json, string memory key, address[] memory defaultValue)\n internal\n view\n returns (address[] memory)\n {\n return keyExists(json, key) ? readAddressArray(json, key) : defaultValue;\n }\n\n function readBoolOr(string memory json, string memory key, bool defaultValue) internal view returns (bool) {\n return keyExists(json, key) ? readBool(json, key) : defaultValue;\n }\n\n function readBoolArrayOr(string memory json, string memory key, bool[] memory defaultValue)\n internal\n view\n returns (bool[] memory)\n {\n return keyExists(json, key) ? readBoolArray(json, key) : defaultValue;\n }\n\n function readBytesOr(string memory json, string memory key, bytes memory defaultValue)\n internal\n view\n returns (bytes memory)\n {\n return keyExists(json, key) ? readBytes(json, key) : defaultValue;\n }\n\n function readBytesArrayOr(string memory json, string memory key, bytes[] memory defaultValue)\n internal\n view\n returns (bytes[] memory)\n {\n return keyExists(json, key) ? readBytesArray(json, key) : defaultValue;\n }\n\n function serialize(string memory jsonKey, string memory rootObject) internal returns (string memory) {\n return vm.serializeJson(jsonKey, rootObject);\n }\n\n function serialize(string memory jsonKey, string memory key, bool value) internal returns (string memory) {\n return vm.serializeBool(jsonKey, key, value);\n }\n\n function serialize(string memory jsonKey, string memory key, bool[] memory value)\n internal\n returns (string memory)\n {\n return vm.serializeBool(jsonKey, key, value);\n }\n\n function serialize(string memory jsonKey, string memory key, uint256 value) internal returns (string memory) {\n return vm.serializeUint(jsonKey, key, value);\n }\n\n function serialize(string memory jsonKey, string memory key, uint256[] memory value)\n internal\n returns (string memory)\n {\n return vm.serializeUint(jsonKey, key, value);\n }\n\n function serialize(string memory jsonKey, string memory key, int256 value) internal returns (string memory) {\n return vm.serializeInt(jsonKey, key, value);\n }\n\n function serialize(string memory jsonKey, string memory key, int256[] memory value)\n internal\n returns (string memory)\n {\n return vm.serializeInt(jsonKey, key, value);\n }\n\n function serialize(string memory jsonKey, string memory key, address value) internal returns (string memory) {\n return vm.serializeAddress(jsonKey, key, value);\n }\n\n function serialize(string memory jsonKey, string memory key, address[] memory value)\n internal\n returns (string memory)\n {\n return vm.serializeAddress(jsonKey, key, value);\n }\n\n function serialize(string memory jsonKey, string memory key, bytes32 value) internal returns (string memory) {\n return vm.serializeBytes32(jsonKey, key, value);\n }\n\n function serialize(string memory jsonKey, string memory key, bytes32[] memory value)\n internal\n returns (string memory)\n {\n return vm.serializeBytes32(jsonKey, key, value);\n }\n\n function serialize(string memory jsonKey, string memory key, bytes memory value) internal returns (string memory) {\n return vm.serializeBytes(jsonKey, key, value);\n }\n\n function serialize(string memory jsonKey, string memory key, bytes[] memory value)\n internal\n returns (string memory)\n {\n return vm.serializeBytes(jsonKey, key, value);\n }\n\n function serialize(string memory jsonKey, string memory key, string memory value)\n internal\n returns (string memory)\n {\n return vm.serializeString(jsonKey, key, value);\n }\n\n function serialize(string memory jsonKey, string memory key, string[] memory value)\n internal\n returns (string memory)\n {\n return vm.serializeString(jsonKey, key, value);\n }\n\n function write(string memory jsonKey, string memory path) internal {\n vm.writeJson(jsonKey, path);\n }\n\n function write(string memory jsonKey, string memory path, string memory valueKey) internal {\n vm.writeJson(jsonKey, path, valueKey);\n }\n}\n","license":"MIT"},"lib/forge-std/src/StdMath.sol":{"keccak256":"0xd90ad4fd8aeaeb8929964e686e769fdedd5eded3fc3815df194a0ab9f91a3fb2","urls":[],"content":"// SPDX-License-Identifier: MIT\npragma solidity >=0.6.2 <0.9.0;\n\nlibrary stdMath {\n int256 private constant INT256_MIN = -57896044618658097711785492504343953926634992332820282019728792003956564819968;\n\n function abs(int256 a) internal pure returns (uint256) {\n // Required or it will fail when `a = type(int256).min`\n if (a == INT256_MIN) {\n return 57896044618658097711785492504343953926634992332820282019728792003956564819968;\n }\n\n return uint256(a > 0 ? a : -a);\n }\n\n function delta(uint256 a, uint256 b) internal pure returns (uint256) {\n return a > b ? a - b : b - a;\n }\n\n function delta(int256 a, int256 b) internal pure returns (uint256) {\n // a and b are of the same sign\n // this works thanks to two's complement, the left-most bit is the sign bit\n if ((a ^ b) > -1) {\n return delta(abs(a), abs(b));\n }\n\n // a and b are of opposite signs\n return abs(a) + abs(b);\n }\n\n function percentDelta(uint256 a, uint256 b) internal pure returns (uint256) {\n uint256 absDelta = delta(a, b);\n\n return absDelta * 1e18 / b;\n }\n\n function percentDelta(int256 a, int256 b) internal pure returns (uint256) {\n uint256 absDelta = delta(a, b);\n uint256 absB = abs(b);\n\n return absDelta * 1e18 / absB;\n }\n}\n","license":"MIT"},"lib/forge-std/src/StdStorage.sol":{"keccak256":"0xb91ab24383a5872b894fc93325eef1add6cbbf981628f18e860068bf88bb7dcc","urls":[],"content":"// SPDX-License-Identifier: MIT\npragma solidity >=0.6.2 <0.9.0;\n\nimport {Vm} from \"./Vm.sol\";\n\nstruct FindData {\n uint256 slot;\n uint256 offsetLeft;\n uint256 offsetRight;\n bool found;\n}\n\nstruct StdStorage {\n mapping(address => mapping(bytes4 => mapping(bytes32 => FindData))) finds;\n bytes32[] _keys;\n bytes4 _sig;\n uint256 _depth;\n address _target;\n bytes32 _set;\n bool _enable_packed_slots;\n bytes _calldata;\n}\n\nlibrary stdStorageSafe {\n event SlotFound(address who, bytes4 fsig, bytes32 keysHash, uint256 slot);\n event WARNING_UninitedSlot(address who, uint256 slot);\n\n Vm private constant vm = Vm(address(uint160(uint256(keccak256(\"hevm cheat code\")))));\n uint256 constant UINT256_MAX = 115792089237316195423570985008687907853269984665640564039457584007913129639935;\n\n function sigs(string memory sigStr) internal pure returns (bytes4) {\n return bytes4(keccak256(bytes(sigStr)));\n }\n\n function getCallParams(StdStorage storage self) internal view returns (bytes memory) {\n if (self._calldata.length == 0) {\n return flatten(self._keys);\n } else {\n return self._calldata;\n }\n }\n\n // Calls target contract with configured parameters\n function callTarget(StdStorage storage self) internal view returns (bool, bytes32) {\n bytes memory cald = abi.encodePacked(self._sig, getCallParams(self));\n (bool success, bytes memory rdat) = self._target.staticcall(cald);\n bytes32 result = bytesToBytes32(rdat, 32 * self._depth);\n\n return (success, result);\n }\n\n // Tries mutating slot value to determine if the targeted value is stored in it.\n // If current value is 0, then we are setting slot value to type(uint256).max\n // Otherwise, we set it to 0. That way, return value should always be affected.\n function checkSlotMutatesCall(StdStorage storage self, bytes32 slot) internal returns (bool) {\n bytes32 prevSlotValue = vm.load(self._target, slot);\n (bool success, bytes32 prevReturnValue) = callTarget(self);\n\n bytes32 testVal = prevReturnValue == bytes32(0) ? bytes32(UINT256_MAX) : bytes32(0);\n vm.store(self._target, slot, testVal);\n\n (, bytes32 newReturnValue) = callTarget(self);\n\n vm.store(self._target, slot, prevSlotValue);\n\n return (success && (prevReturnValue != newReturnValue));\n }\n\n // Tries setting one of the bits in slot to 1 until return value changes.\n // Index of resulted bit is an offset packed slot has from left/right side\n function findOffset(StdStorage storage self, bytes32 slot, bool left) internal returns (bool, uint256) {\n for (uint256 offset = 0; offset < 256; offset++) {\n uint256 valueToPut = left ? (1 << (255 - offset)) : (1 << offset);\n vm.store(self._target, slot, bytes32(valueToPut));\n\n (bool success, bytes32 data) = callTarget(self);\n\n if (success && (uint256(data) > 0)) {\n return (true, offset);\n }\n }\n return (false, 0);\n }\n\n function findOffsets(StdStorage storage self, bytes32 slot) internal returns (bool, uint256, uint256) {\n bytes32 prevSlotValue = vm.load(self._target, slot);\n\n (bool foundLeft, uint256 offsetLeft) = findOffset(self, slot, true);\n (bool foundRight, uint256 offsetRight) = findOffset(self, slot, false);\n\n // `findOffset` may mutate slot value, so we are setting it to initial value\n vm.store(self._target, slot, prevSlotValue);\n return (foundLeft && foundRight, offsetLeft, offsetRight);\n }\n\n function find(StdStorage storage self) internal returns (FindData storage) {\n return find(self, true);\n }\n\n /// @notice find an arbitrary storage slot given a function sig, input data, address of the contract and a value to check against\n // slot complexity:\n // if flat, will be bytes32(uint256(uint));\n // if map, will be keccak256(abi.encode(key, uint(slot)));\n // if deep map, will be keccak256(abi.encode(key1, keccak256(abi.encode(key0, uint(slot)))));\n // if map struct, will be bytes32(uint256(keccak256(abi.encode(key1, keccak256(abi.encode(key0, uint(slot)))))) + structFieldDepth);\n function find(StdStorage storage self, bool _clear) internal returns (FindData storage) {\n address who = self._target;\n bytes4 fsig = self._sig;\n uint256 field_depth = self._depth;\n bytes memory params = getCallParams(self);\n\n // calldata to test against\n if (self.finds[who][fsig][keccak256(abi.encodePacked(params, field_depth))].found) {\n if (_clear) {\n clear(self);\n }\n return self.finds[who][fsig][keccak256(abi.encodePacked(params, field_depth))];\n }\n vm.record();\n (, bytes32 callResult) = callTarget(self);\n (bytes32[] memory reads,) = vm.accesses(address(who));\n\n if (reads.length == 0) {\n revert(\"stdStorage find(StdStorage): No storage use detected for target.\");\n } else {\n for (uint256 i = reads.length; --i >= 0;) {\n bytes32 prev = vm.load(who, reads[i]);\n if (prev == bytes32(0)) {\n emit WARNING_UninitedSlot(who, uint256(reads[i]));\n }\n\n if (!checkSlotMutatesCall(self, reads[i])) {\n continue;\n }\n\n (uint256 offsetLeft, uint256 offsetRight) = (0, 0);\n\n if (self._enable_packed_slots) {\n bool found;\n (found, offsetLeft, offsetRight) = findOffsets(self, reads[i]);\n if (!found) {\n continue;\n }\n }\n\n // Check that value between found offsets is equal to the current call result\n uint256 curVal = (uint256(prev) & getMaskByOffsets(offsetLeft, offsetRight)) >> offsetRight;\n\n if (uint256(callResult) != curVal) {\n continue;\n }\n\n emit SlotFound(who, fsig, keccak256(abi.encodePacked(params, field_depth)), uint256(reads[i]));\n self.finds[who][fsig][keccak256(abi.encodePacked(params, field_depth))] =\n FindData(uint256(reads[i]), offsetLeft, offsetRight, true);\n break;\n }\n }\n\n require(\n self.finds[who][fsig][keccak256(abi.encodePacked(params, field_depth))].found,\n \"stdStorage find(StdStorage): Slot(s) not found.\"\n );\n\n if (_clear) {\n clear(self);\n }\n return self.finds[who][fsig][keccak256(abi.encodePacked(params, field_depth))];\n }\n\n function target(StdStorage storage self, address _target) internal returns (StdStorage storage) {\n self._target = _target;\n return self;\n }\n\n function sig(StdStorage storage self, bytes4 _sig) internal returns (StdStorage storage) {\n self._sig = _sig;\n return self;\n }\n\n function sig(StdStorage storage self, string memory _sig) internal returns (StdStorage storage) {\n self._sig = sigs(_sig);\n return self;\n }\n\n function with_calldata(StdStorage storage self, bytes memory _calldata) internal returns (StdStorage storage) {\n self._calldata = _calldata;\n return self;\n }\n\n function with_key(StdStorage storage self, address who) internal returns (StdStorage storage) {\n self._keys.push(bytes32(uint256(uint160(who))));\n return self;\n }\n\n function with_key(StdStorage storage self, uint256 amt) internal returns (StdStorage storage) {\n self._keys.push(bytes32(amt));\n return self;\n }\n\n function with_key(StdStorage storage self, bytes32 key) internal returns (StdStorage storage) {\n self._keys.push(key);\n return self;\n }\n\n function enable_packed_slots(StdStorage storage self) internal returns (StdStorage storage) {\n self._enable_packed_slots = true;\n return self;\n }\n\n function depth(StdStorage storage self, uint256 _depth) internal returns (StdStorage storage) {\n self._depth = _depth;\n return self;\n }\n\n function read(StdStorage storage self) private returns (bytes memory) {\n FindData storage data = find(self, false);\n uint256 mask = getMaskByOffsets(data.offsetLeft, data.offsetRight);\n uint256 value = (uint256(vm.load(self._target, bytes32(data.slot))) & mask) >> data.offsetRight;\n clear(self);\n return abi.encode(value);\n }\n\n function read_bytes32(StdStorage storage self) internal returns (bytes32) {\n return abi.decode(read(self), (bytes32));\n }\n\n function read_bool(StdStorage storage self) internal returns (bool) {\n int256 v = read_int(self);\n if (v == 0) return false;\n if (v == 1) return true;\n revert(\"stdStorage read_bool(StdStorage): Cannot decode. Make sure you are reading a bool.\");\n }\n\n function read_address(StdStorage storage self) internal returns (address) {\n return abi.decode(read(self), (address));\n }\n\n function read_uint(StdStorage storage self) internal returns (uint256) {\n return abi.decode(read(self), (uint256));\n }\n\n function read_int(StdStorage storage self) internal returns (int256) {\n return abi.decode(read(self), (int256));\n }\n\n function parent(StdStorage storage self) internal returns (uint256, bytes32) {\n address who = self._target;\n uint256 field_depth = self._depth;\n vm.startMappingRecording();\n uint256 child = find(self, true).slot - field_depth;\n (bool found, bytes32 key, bytes32 parent_slot) = vm.getMappingKeyAndParentOf(who, bytes32(child));\n if (!found) {\n revert(\n \"stdStorage read_bool(StdStorage): Cannot find parent. Make sure you give a slot and startMappingRecording() has been called.\"\n );\n }\n return (uint256(parent_slot), key);\n }\n\n function root(StdStorage storage self) internal returns (uint256) {\n address who = self._target;\n uint256 field_depth = self._depth;\n vm.startMappingRecording();\n uint256 child = find(self, true).slot - field_depth;\n bool found;\n bytes32 root_slot;\n bytes32 parent_slot;\n (found,, parent_slot) = vm.getMappingKeyAndParentOf(who, bytes32(child));\n if (!found) {\n revert(\n \"stdStorage read_bool(StdStorage): Cannot find parent. Make sure you give a slot and startMappingRecording() has been called.\"\n );\n }\n while (found) {\n root_slot = parent_slot;\n (found,, parent_slot) = vm.getMappingKeyAndParentOf(who, bytes32(root_slot));\n }\n return uint256(root_slot);\n }\n\n function bytesToBytes32(bytes memory b, uint256 offset) private pure returns (bytes32) {\n bytes32 out;\n\n uint256 max = b.length > 32 ? 32 : b.length;\n for (uint256 i = 0; i < max; i++) {\n out |= bytes32(b[offset + i] & 0xFF) >> (i * 8);\n }\n return out;\n }\n\n function flatten(bytes32[] memory b) private pure returns (bytes memory) {\n bytes memory result = new bytes(b.length * 32);\n for (uint256 i = 0; i < b.length; i++) {\n bytes32 k = b[i];\n /// @solidity memory-safe-assembly\n assembly {\n mstore(add(result, add(32, mul(32, i))), k)\n }\n }\n\n return result;\n }\n\n function clear(StdStorage storage self) internal {\n delete self._target;\n delete self._sig;\n delete self._keys;\n delete self._depth;\n delete self._enable_packed_slots;\n delete self._calldata;\n }\n\n // Returns mask which contains non-zero bits for values between `offsetLeft` and `offsetRight`\n // (slotValue & mask) >> offsetRight will be the value of the given packed variable\n function getMaskByOffsets(uint256 offsetLeft, uint256 offsetRight) internal pure returns (uint256 mask) {\n // mask = ((1 << (256 - (offsetRight + offsetLeft))) - 1) << offsetRight;\n // using assembly because (1 << 256) causes overflow\n assembly {\n mask := shl(offsetRight, sub(shl(sub(256, add(offsetRight, offsetLeft)), 1), 1))\n }\n }\n\n // Returns slot value with updated packed variable.\n function getUpdatedSlotValue(bytes32 curValue, uint256 varValue, uint256 offsetLeft, uint256 offsetRight)\n internal\n pure\n returns (bytes32 newValue)\n {\n return bytes32((uint256(curValue) & ~getMaskByOffsets(offsetLeft, offsetRight)) | (varValue << offsetRight));\n }\n}\n\nlibrary stdStorage {\n Vm private constant vm = Vm(address(uint160(uint256(keccak256(\"hevm cheat code\")))));\n\n function sigs(string memory sigStr) internal pure returns (bytes4) {\n return stdStorageSafe.sigs(sigStr);\n }\n\n function find(StdStorage storage self) internal returns (uint256) {\n return find(self, true);\n }\n\n function find(StdStorage storage self, bool _clear) internal returns (uint256) {\n return stdStorageSafe.find(self, _clear).slot;\n }\n\n function target(StdStorage storage self, address _target) internal returns (StdStorage storage) {\n return stdStorageSafe.target(self, _target);\n }\n\n function sig(StdStorage storage self, bytes4 _sig) internal returns (StdStorage storage) {\n return stdStorageSafe.sig(self, _sig);\n }\n\n function sig(StdStorage storage self, string memory _sig) internal returns (StdStorage storage) {\n return stdStorageSafe.sig(self, _sig);\n }\n\n function with_key(StdStorage storage self, address who) internal returns (StdStorage storage) {\n return stdStorageSafe.with_key(self, who);\n }\n\n function with_key(StdStorage storage self, uint256 amt) internal returns (StdStorage storage) {\n return stdStorageSafe.with_key(self, amt);\n }\n\n function with_key(StdStorage storage self, bytes32 key) internal returns (StdStorage storage) {\n return stdStorageSafe.with_key(self, key);\n }\n\n function with_calldata(StdStorage storage self, bytes memory _calldata) internal returns (StdStorage storage) {\n return stdStorageSafe.with_calldata(self, _calldata);\n }\n\n function enable_packed_slots(StdStorage storage self) internal returns (StdStorage storage) {\n return stdStorageSafe.enable_packed_slots(self);\n }\n\n function depth(StdStorage storage self, uint256 _depth) internal returns (StdStorage storage) {\n return stdStorageSafe.depth(self, _depth);\n }\n\n function clear(StdStorage storage self) internal {\n stdStorageSafe.clear(self);\n }\n\n function checked_write(StdStorage storage self, address who) internal {\n checked_write(self, bytes32(uint256(uint160(who))));\n }\n\n function checked_write(StdStorage storage self, uint256 amt) internal {\n checked_write(self, bytes32(amt));\n }\n\n function checked_write_int(StdStorage storage self, int256 val) internal {\n checked_write(self, bytes32(uint256(val)));\n }\n\n function checked_write(StdStorage storage self, bool write) internal {\n bytes32 t;\n /// @solidity memory-safe-assembly\n assembly {\n t := write\n }\n checked_write(self, t);\n }\n\n function checked_write(StdStorage storage self, bytes32 set) internal {\n address who = self._target;\n bytes4 fsig = self._sig;\n uint256 field_depth = self._depth;\n bytes memory params = stdStorageSafe.getCallParams(self);\n\n if (!self.finds[who][fsig][keccak256(abi.encodePacked(params, field_depth))].found) {\n find(self, false);\n }\n FindData storage data = self.finds[who][fsig][keccak256(abi.encodePacked(params, field_depth))];\n if ((data.offsetLeft + data.offsetRight) > 0) {\n uint256 maxVal = 2 ** (256 - (data.offsetLeft + data.offsetRight));\n require(\n uint256(set) < maxVal,\n string(\n abi.encodePacked(\n \"stdStorage find(StdStorage): Packed slot. We can't fit value greater than \",\n vm.toString(maxVal)\n )\n )\n );\n }\n bytes32 curVal = vm.load(who, bytes32(data.slot));\n bytes32 valToSet = stdStorageSafe.getUpdatedSlotValue(curVal, uint256(set), data.offsetLeft, data.offsetRight);\n\n vm.store(who, bytes32(data.slot), valToSet);\n\n (bool success, bytes32 callResult) = stdStorageSafe.callTarget(self);\n\n if (!success || callResult != set) {\n vm.store(who, bytes32(data.slot), curVal);\n revert(\"stdStorage find(StdStorage): Failed to write value.\");\n }\n clear(self);\n }\n\n function read_bytes32(StdStorage storage self) internal returns (bytes32) {\n return stdStorageSafe.read_bytes32(self);\n }\n\n function read_bool(StdStorage storage self) internal returns (bool) {\n return stdStorageSafe.read_bool(self);\n }\n\n function read_address(StdStorage storage self) internal returns (address) {\n return stdStorageSafe.read_address(self);\n }\n\n function read_uint(StdStorage storage self) internal returns (uint256) {\n return stdStorageSafe.read_uint(self);\n }\n\n function read_int(StdStorage storage self) internal returns (int256) {\n return stdStorageSafe.read_int(self);\n }\n\n function parent(StdStorage storage self) internal returns (uint256, bytes32) {\n return stdStorageSafe.parent(self);\n }\n\n function root(StdStorage storage self) internal returns (uint256) {\n return stdStorageSafe.root(self);\n }\n}\n","license":"MIT"},"lib/forge-std/src/StdStyle.sol":{"keccak256":"0x43e2a8a9b9c2574dabe74f11adf6f782df218f463540e3b5b563609fe108597d","urls":[],"content":"// SPDX-License-Identifier: MIT\npragma solidity >=0.4.22 <0.9.0;\n\nimport {VmSafe} from \"./Vm.sol\";\n\nlibrary StdStyle {\n VmSafe private constant vm = VmSafe(address(uint160(uint256(keccak256(\"hevm cheat code\")))));\n\n string constant RED = \"\\u001b[91m\";\n string constant GREEN = \"\\u001b[92m\";\n string constant YELLOW = \"\\u001b[93m\";\n string constant BLUE = \"\\u001b[94m\";\n string constant MAGENTA = \"\\u001b[95m\";\n string constant CYAN = \"\\u001b[96m\";\n string constant BOLD = \"\\u001b[1m\";\n string constant DIM = \"\\u001b[2m\";\n string constant ITALIC = \"\\u001b[3m\";\n string constant UNDERLINE = \"\\u001b[4m\";\n string constant INVERSE = \"\\u001b[7m\";\n string constant RESET = \"\\u001b[0m\";\n\n function styleConcat(string memory style, string memory self) private pure returns (string memory) {\n return string(abi.encodePacked(style, self, RESET));\n }\n\n function red(string memory self) internal pure returns (string memory) {\n return styleConcat(RED, self);\n }\n\n function red(uint256 self) internal pure returns (string memory) {\n return red(vm.toString(self));\n }\n\n function red(int256 self) internal pure returns (string memory) {\n return red(vm.toString(self));\n }\n\n function red(address self) internal pure returns (string memory) {\n return red(vm.toString(self));\n }\n\n function red(bool self) internal pure returns (string memory) {\n return red(vm.toString(self));\n }\n\n function redBytes(bytes memory self) internal pure returns (string memory) {\n return red(vm.toString(self));\n }\n\n function redBytes32(bytes32 self) internal pure returns (string memory) {\n return red(vm.toString(self));\n }\n\n function green(string memory self) internal pure returns (string memory) {\n return styleConcat(GREEN, self);\n }\n\n function green(uint256 self) internal pure returns (string memory) {\n return green(vm.toString(self));\n }\n\n function green(int256 self) internal pure returns (string memory) {\n return green(vm.toString(self));\n }\n\n function green(address self) internal pure returns (string memory) {\n return green(vm.toString(self));\n }\n\n function green(bool self) internal pure returns (string memory) {\n return green(vm.toString(self));\n }\n\n function greenBytes(bytes memory self) internal pure returns (string memory) {\n return green(vm.toString(self));\n }\n\n function greenBytes32(bytes32 self) internal pure returns (string memory) {\n return green(vm.toString(self));\n }\n\n function yellow(string memory self) internal pure returns (string memory) {\n return styleConcat(YELLOW, self);\n }\n\n function yellow(uint256 self) internal pure returns (string memory) {\n return yellow(vm.toString(self));\n }\n\n function yellow(int256 self) internal pure returns (string memory) {\n return yellow(vm.toString(self));\n }\n\n function yellow(address self) internal pure returns (string memory) {\n return yellow(vm.toString(self));\n }\n\n function yellow(bool self) internal pure returns (string memory) {\n return yellow(vm.toString(self));\n }\n\n function yellowBytes(bytes memory self) internal pure returns (string memory) {\n return yellow(vm.toString(self));\n }\n\n function yellowBytes32(bytes32 self) internal pure returns (string memory) {\n return yellow(vm.toString(self));\n }\n\n function blue(string memory self) internal pure returns (string memory) {\n return styleConcat(BLUE, self);\n }\n\n function blue(uint256 self) internal pure returns (string memory) {\n return blue(vm.toString(self));\n }\n\n function blue(int256 self) internal pure returns (string memory) {\n return blue(vm.toString(self));\n }\n\n function blue(address self) internal pure returns (string memory) {\n return blue(vm.toString(self));\n }\n\n function blue(bool self) internal pure returns (string memory) {\n return blue(vm.toString(self));\n }\n\n function blueBytes(bytes memory self) internal pure returns (string memory) {\n return blue(vm.toString(self));\n }\n\n function blueBytes32(bytes32 self) internal pure returns (string memory) {\n return blue(vm.toString(self));\n }\n\n function magenta(string memory self) internal pure returns (string memory) {\n return styleConcat(MAGENTA, self);\n }\n\n function magenta(uint256 self) internal pure returns (string memory) {\n return magenta(vm.toString(self));\n }\n\n function magenta(int256 self) internal pure returns (string memory) {\n return magenta(vm.toString(self));\n }\n\n function magenta(address self) internal pure returns (string memory) {\n return magenta(vm.toString(self));\n }\n\n function magenta(bool self) internal pure returns (string memory) {\n return magenta(vm.toString(self));\n }\n\n function magentaBytes(bytes memory self) internal pure returns (string memory) {\n return magenta(vm.toString(self));\n }\n\n function magentaBytes32(bytes32 self) internal pure returns (string memory) {\n return magenta(vm.toString(self));\n }\n\n function cyan(string memory self) internal pure returns (string memory) {\n return styleConcat(CYAN, self);\n }\n\n function cyan(uint256 self) internal pure returns (string memory) {\n return cyan(vm.toString(self));\n }\n\n function cyan(int256 self) internal pure returns (string memory) {\n return cyan(vm.toString(self));\n }\n\n function cyan(address self) internal pure returns (string memory) {\n return cyan(vm.toString(self));\n }\n\n function cyan(bool self) internal pure returns (string memory) {\n return cyan(vm.toString(self));\n }\n\n function cyanBytes(bytes memory self) internal pure returns (string memory) {\n return cyan(vm.toString(self));\n }\n\n function cyanBytes32(bytes32 self) internal pure returns (string memory) {\n return cyan(vm.toString(self));\n }\n\n function bold(string memory self) internal pure returns (string memory) {\n return styleConcat(BOLD, self);\n }\n\n function bold(uint256 self) internal pure returns (string memory) {\n return bold(vm.toString(self));\n }\n\n function bold(int256 self) internal pure returns (string memory) {\n return bold(vm.toString(self));\n }\n\n function bold(address self) internal pure returns (string memory) {\n return bold(vm.toString(self));\n }\n\n function bold(bool self) internal pure returns (string memory) {\n return bold(vm.toString(self));\n }\n\n function boldBytes(bytes memory self) internal pure returns (string memory) {\n return bold(vm.toString(self));\n }\n\n function boldBytes32(bytes32 self) internal pure returns (string memory) {\n return bold(vm.toString(self));\n }\n\n function dim(string memory self) internal pure returns (string memory) {\n return styleConcat(DIM, self);\n }\n\n function dim(uint256 self) internal pure returns (string memory) {\n return dim(vm.toString(self));\n }\n\n function dim(int256 self) internal pure returns (string memory) {\n return dim(vm.toString(self));\n }\n\n function dim(address self) internal pure returns (string memory) {\n return dim(vm.toString(self));\n }\n\n function dim(bool self) internal pure returns (string memory) {\n return dim(vm.toString(self));\n }\n\n function dimBytes(bytes memory self) internal pure returns (string memory) {\n return dim(vm.toString(self));\n }\n\n function dimBytes32(bytes32 self) internal pure returns (string memory) {\n return dim(vm.toString(self));\n }\n\n function italic(string memory self) internal pure returns (string memory) {\n return styleConcat(ITALIC, self);\n }\n\n function italic(uint256 self) internal pure returns (string memory) {\n return italic(vm.toString(self));\n }\n\n function italic(int256 self) internal pure returns (string memory) {\n return italic(vm.toString(self));\n }\n\n function italic(address self) internal pure returns (string memory) {\n return italic(vm.toString(self));\n }\n\n function italic(bool self) internal pure returns (string memory) {\n return italic(vm.toString(self));\n }\n\n function italicBytes(bytes memory self) internal pure returns (string memory) {\n return italic(vm.toString(self));\n }\n\n function italicBytes32(bytes32 self) internal pure returns (string memory) {\n return italic(vm.toString(self));\n }\n\n function underline(string memory self) internal pure returns (string memory) {\n return styleConcat(UNDERLINE, self);\n }\n\n function underline(uint256 self) internal pure returns (string memory) {\n return underline(vm.toString(self));\n }\n\n function underline(int256 self) internal pure returns (string memory) {\n return underline(vm.toString(self));\n }\n\n function underline(address self) internal pure returns (string memory) {\n return underline(vm.toString(self));\n }\n\n function underline(bool self) internal pure returns (string memory) {\n return underline(vm.toString(self));\n }\n\n function underlineBytes(bytes memory self) internal pure returns (string memory) {\n return underline(vm.toString(self));\n }\n\n function underlineBytes32(bytes32 self) internal pure returns (string memory) {\n return underline(vm.toString(self));\n }\n\n function inverse(string memory self) internal pure returns (string memory) {\n return styleConcat(INVERSE, self);\n }\n\n function inverse(uint256 self) internal pure returns (string memory) {\n return inverse(vm.toString(self));\n }\n\n function inverse(int256 self) internal pure returns (string memory) {\n return inverse(vm.toString(self));\n }\n\n function inverse(address self) internal pure returns (string memory) {\n return inverse(vm.toString(self));\n }\n\n function inverse(bool self) internal pure returns (string memory) {\n return inverse(vm.toString(self));\n }\n\n function inverseBytes(bytes memory self) internal pure returns (string memory) {\n return inverse(vm.toString(self));\n }\n\n function inverseBytes32(bytes32 self) internal pure returns (string memory) {\n return inverse(vm.toString(self));\n }\n}\n","license":"MIT"},"lib/forge-std/src/StdUtils.sol":{"keccak256":"0x7274081e11c05164fd8eadde4de8305c033e58a43008dea58065f3170ccf0737","urls":[],"content":"// SPDX-License-Identifier: MIT\npragma solidity >=0.6.2 <0.9.0;\n\npragma experimental ABIEncoderV2;\n\nimport {IMulticall3} from \"./interfaces/IMulticall3.sol\";\nimport {VmSafe} from \"./Vm.sol\";\n\nabstract contract StdUtils {\n /*//////////////////////////////////////////////////////////////////////////\n CONSTANTS\n //////////////////////////////////////////////////////////////////////////*/\n\n IMulticall3 private constant multicall = IMulticall3(0xcA11bde05977b3631167028862bE2a173976CA11);\n VmSafe private constant vm = VmSafe(address(uint160(uint256(keccak256(\"hevm cheat code\")))));\n address private constant CONSOLE2_ADDRESS = 0x000000000000000000636F6e736F6c652e6c6f67;\n uint256 private constant INT256_MIN_ABS =\n 57896044618658097711785492504343953926634992332820282019728792003956564819968;\n uint256 private constant SECP256K1_ORDER =\n 115792089237316195423570985008687907852837564279074904382605163141518161494337;\n uint256 private constant UINT256_MAX =\n 115792089237316195423570985008687907853269984665640564039457584007913129639935;\n\n // Used by default when deploying with create2, https://github.com/Arachnid/deterministic-deployment-proxy.\n address private constant CREATE2_FACTORY = 0x4e59b44847b379578588920cA78FbF26c0B4956C;\n\n /*//////////////////////////////////////////////////////////////////////////\n INTERNAL FUNCTIONS\n //////////////////////////////////////////////////////////////////////////*/\n\n function _bound(uint256 x, uint256 min, uint256 max) internal pure virtual returns (uint256 result) {\n require(min <= max, \"StdUtils bound(uint256,uint256,uint256): Max is less than min.\");\n // If x is between min and max, return x directly. This is to ensure that dictionary values\n // do not get shifted if the min is nonzero. More info: https://github.com/foundry-rs/forge-std/issues/188\n if (x >= min && x <= max) return x;\n\n uint256 size = max - min + 1;\n\n // If the value is 0, 1, 2, 3, wrap that to min, min+1, min+2, min+3. Similarly for the UINT256_MAX side.\n // This helps ensure coverage of the min/max values.\n if (x <= 3 && size > x) return min + x;\n if (x >= UINT256_MAX - 3 && size > UINT256_MAX - x) return max - (UINT256_MAX - x);\n\n // Otherwise, wrap x into the range [min, max], i.e. the range is inclusive.\n if (x > max) {\n uint256 diff = x - max;\n uint256 rem = diff % size;\n if (rem == 0) return max;\n result = min + rem - 1;\n } else if (x < min) {\n uint256 diff = min - x;\n uint256 rem = diff % size;\n if (rem == 0) return min;\n result = max - rem + 1;\n }\n }\n\n function bound(uint256 x, uint256 min, uint256 max) internal pure virtual returns (uint256 result) {\n result = _bound(x, min, max);\n console2_log_StdUtils(\"Bound result\", result);\n }\n\n function _bound(int256 x, int256 min, int256 max) internal pure virtual returns (int256 result) {\n require(min <= max, \"StdUtils bound(int256,int256,int256): Max is less than min.\");\n\n // Shifting all int256 values to uint256 to use _bound function. The range of two types are:\n // int256 : -(2**255) ~ (2**255 - 1)\n // uint256: 0 ~ (2**256 - 1)\n // So, add 2**255, INT256_MIN_ABS to the integer values.\n //\n // If the given integer value is -2**255, we cannot use `-uint256(-x)` because of the overflow.\n // So, use `~uint256(x) + 1` instead.\n uint256 _x = x < 0 ? (INT256_MIN_ABS - ~uint256(x) - 1) : (uint256(x) + INT256_MIN_ABS);\n uint256 _min = min < 0 ? (INT256_MIN_ABS - ~uint256(min) - 1) : (uint256(min) + INT256_MIN_ABS);\n uint256 _max = max < 0 ? (INT256_MIN_ABS - ~uint256(max) - 1) : (uint256(max) + INT256_MIN_ABS);\n\n uint256 y = _bound(_x, _min, _max);\n\n // To move it back to int256 value, subtract INT256_MIN_ABS at here.\n result = y < INT256_MIN_ABS ? int256(~(INT256_MIN_ABS - y) + 1) : int256(y - INT256_MIN_ABS);\n }\n\n function bound(int256 x, int256 min, int256 max) internal pure virtual returns (int256 result) {\n result = _bound(x, min, max);\n console2_log_StdUtils(\"Bound result\", vm.toString(result));\n }\n\n function boundPrivateKey(uint256 privateKey) internal pure virtual returns (uint256 result) {\n result = _bound(privateKey, 1, SECP256K1_ORDER - 1);\n }\n\n function bytesToUint(bytes memory b) internal pure virtual returns (uint256) {\n require(b.length <= 32, \"StdUtils bytesToUint(bytes): Bytes length exceeds 32.\");\n return abi.decode(abi.encodePacked(new bytes(32 - b.length), b), (uint256));\n }\n\n /// @dev Compute the address a contract will be deployed at for a given deployer address and nonce\n /// @notice adapted from Solmate implementation (https://github.com/Rari-Capital/solmate/blob/main/src/utils/LibRLP.sol)\n function computeCreateAddress(address deployer, uint256 nonce) internal pure virtual returns (address) {\n console2_log_StdUtils(\"computeCreateAddress is deprecated. Please use vm.computeCreateAddress instead.\");\n return vm.computeCreateAddress(deployer, nonce);\n }\n\n function computeCreate2Address(bytes32 salt, bytes32 initcodeHash, address deployer)\n internal\n pure\n virtual\n returns (address)\n {\n console2_log_StdUtils(\"computeCreate2Address is deprecated. Please use vm.computeCreate2Address instead.\");\n return vm.computeCreate2Address(salt, initcodeHash, deployer);\n }\n\n /// @dev returns the address of a contract created with CREATE2 using the default CREATE2 deployer\n function computeCreate2Address(bytes32 salt, bytes32 initCodeHash) internal pure returns (address) {\n console2_log_StdUtils(\"computeCreate2Address is deprecated. Please use vm.computeCreate2Address instead.\");\n return vm.computeCreate2Address(salt, initCodeHash);\n }\n\n /// @dev returns the hash of the init code (creation code + no args) used in CREATE2 with no constructor arguments\n /// @param creationCode the creation code of a contract C, as returned by type(C).creationCode\n function hashInitCode(bytes memory creationCode) internal pure returns (bytes32) {\n return hashInitCode(creationCode, \"\");\n }\n\n /// @dev returns the hash of the init code (creation code + ABI-encoded args) used in CREATE2\n /// @param creationCode the creation code of a contract C, as returned by type(C).creationCode\n /// @param args the ABI-encoded arguments to the constructor of C\n function hashInitCode(bytes memory creationCode, bytes memory args) internal pure returns (bytes32) {\n return keccak256(abi.encodePacked(creationCode, args));\n }\n\n // Performs a single call with Multicall3 to query the ERC-20 token balances of the given addresses.\n function getTokenBalances(address token, address[] memory addresses)\n internal\n virtual\n returns (uint256[] memory balances)\n {\n uint256 tokenCodeSize;\n assembly {\n tokenCodeSize := extcodesize(token)\n }\n require(tokenCodeSize > 0, \"StdUtils getTokenBalances(address,address[]): Token address is not a contract.\");\n\n // ABI encode the aggregate call to Multicall3.\n uint256 length = addresses.length;\n IMulticall3.Call[] memory calls = new IMulticall3.Call[](length);\n for (uint256 i = 0; i < length; ++i) {\n // 0x70a08231 = bytes4(\"balanceOf(address)\"))\n calls[i] = IMulticall3.Call({target: token, callData: abi.encodeWithSelector(0x70a08231, (addresses[i]))});\n }\n\n // Make the aggregate call.\n (, bytes[] memory returnData) = multicall.aggregate(calls);\n\n // ABI decode the return data and return the balances.\n balances = new uint256[](length);\n for (uint256 i = 0; i < length; ++i) {\n balances[i] = abi.decode(returnData[i], (uint256));\n }\n }\n\n /*//////////////////////////////////////////////////////////////////////////\n PRIVATE FUNCTIONS\n //////////////////////////////////////////////////////////////////////////*/\n\n function addressFromLast20Bytes(bytes32 bytesValue) private pure returns (address) {\n return address(uint160(uint256(bytesValue)));\n }\n\n // This section is used to prevent the compilation of console, which shortens the compilation time when console is\n // not used elsewhere. We also trick the compiler into letting us make the console log methods as `pure` to avoid\n // any breaking changes to function signatures.\n function _castLogPayloadViewToPure(function(bytes memory) internal view fnIn)\n internal\n pure\n returns (function(bytes memory) internal pure fnOut)\n {\n assembly {\n fnOut := fnIn\n }\n }\n\n function _sendLogPayload(bytes memory payload) internal pure {\n _castLogPayloadViewToPure(_sendLogPayloadView)(payload);\n }\n\n function _sendLogPayloadView(bytes memory payload) private view {\n uint256 payloadLength = payload.length;\n address consoleAddress = CONSOLE2_ADDRESS;\n /// @solidity memory-safe-assembly\n assembly {\n let payloadStart := add(payload, 32)\n let r := staticcall(gas(), consoleAddress, payloadStart, payloadLength, 0, 0)\n }\n }\n\n function console2_log_StdUtils(string memory p0) private pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string)\", p0));\n }\n\n function console2_log_StdUtils(string memory p0, uint256 p1) private pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,uint256)\", p0, p1));\n }\n\n function console2_log_StdUtils(string memory p0, string memory p1) private pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,string)\", p0, p1));\n }\n}\n","license":"MIT"},"lib/forge-std/src/Vm.sol":{"keccak256":"0xd91fb0df409fbd22463e937b48b9682d9333c5d4528d8fe7b36102a0323c44bf","urls":[],"content":"// Automatically @generated by scripts/vm.py. Do not modify manually.\n\n// SPDX-License-Identifier: MIT OR Apache-2.0\npragma solidity >=0.6.2 <0.9.0;\npragma experimental ABIEncoderV2;\n\n/// The `VmSafe` interface does not allow manipulation of the EVM state or other actions that may\n/// result in Script simulations differing from on-chain execution. It is recommended to only use\n/// these cheats in scripts.\ninterface VmSafe {\n /// A modification applied to either `msg.sender` or `tx.origin`. Returned by `readCallers`.\n enum CallerMode {\n // No caller modification is currently active.\n None,\n // A one time broadcast triggered by a `vm.broadcast()` call is currently active.\n Broadcast,\n // A recurrent broadcast triggered by a `vm.startBroadcast()` call is currently active.\n RecurrentBroadcast,\n // A one time prank triggered by a `vm.prank()` call is currently active.\n Prank,\n // A recurrent prank triggered by a `vm.startPrank()` call is currently active.\n RecurrentPrank\n }\n\n /// The kind of account access that occurred.\n enum AccountAccessKind {\n // The account was called.\n Call,\n // The account was called via delegatecall.\n DelegateCall,\n // The account was called via callcode.\n CallCode,\n // The account was called via staticcall.\n StaticCall,\n // The account was created.\n Create,\n // The account was selfdestructed.\n SelfDestruct,\n // Synthetic access indicating the current context has resumed after a previous sub-context (AccountAccess).\n Resume,\n // The account's balance was read.\n Balance,\n // The account's codesize was read.\n Extcodesize,\n // The account's codehash was read.\n Extcodehash,\n // The account's code was copied.\n Extcodecopy\n }\n\n /// Forge execution contexts.\n enum ForgeContext {\n // Test group execution context (test, coverage or snapshot).\n TestGroup,\n // `forge test` execution context.\n Test,\n // `forge coverage` execution context.\n Coverage,\n // `forge snapshot` execution context.\n Snapshot,\n // Script group execution context (dry run, broadcast or resume).\n ScriptGroup,\n // `forge script` execution context.\n ScriptDryRun,\n // `forge script --broadcast` execution context.\n ScriptBroadcast,\n // `forge script --resume` execution context.\n ScriptResume,\n // Unknown `forge` execution context.\n Unknown\n }\n\n /// The transaction type (`txType`) of the broadcast.\n enum BroadcastTxType {\n // Represents a CALL broadcast tx.\n Call,\n // Represents a CREATE broadcast tx.\n Create,\n // Represents a CREATE2 broadcast tx.\n Create2\n }\n\n /// An Ethereum log. Returned by `getRecordedLogs`.\n struct Log {\n // The topics of the log, including the signature, if any.\n bytes32[] topics;\n // The raw data of the log.\n bytes data;\n // The address of the log's emitter.\n address emitter;\n }\n\n /// An RPC URL and its alias. Returned by `rpcUrlStructs`.\n struct Rpc {\n // The alias of the RPC URL.\n string key;\n // The RPC URL.\n string url;\n }\n\n /// An RPC log object. Returned by `eth_getLogs`.\n struct EthGetLogs {\n // The address of the log's emitter.\n address emitter;\n // The topics of the log, including the signature, if any.\n bytes32[] topics;\n // The raw data of the log.\n bytes data;\n // The block hash.\n bytes32 blockHash;\n // The block number.\n uint64 blockNumber;\n // The transaction hash.\n bytes32 transactionHash;\n // The transaction index in the block.\n uint64 transactionIndex;\n // The log index.\n uint256 logIndex;\n // Whether the log was removed.\n bool removed;\n }\n\n /// A single entry in a directory listing. Returned by `readDir`.\n struct DirEntry {\n // The error message, if any.\n string errorMessage;\n // The path of the entry.\n string path;\n // The depth of the entry.\n uint64 depth;\n // Whether the entry is a directory.\n bool isDir;\n // Whether the entry is a symlink.\n bool isSymlink;\n }\n\n /// Metadata information about a file.\n /// This structure is returned from the `fsMetadata` function and represents known\n /// metadata about a file such as its permissions, size, modification\n /// times, etc.\n struct FsMetadata {\n // True if this metadata is for a directory.\n bool isDir;\n // True if this metadata is for a symlink.\n bool isSymlink;\n // The size of the file, in bytes, this metadata is for.\n uint256 length;\n // True if this metadata is for a readonly (unwritable) file.\n bool readOnly;\n // The last modification time listed in this metadata.\n uint256 modified;\n // The last access time of this metadata.\n uint256 accessed;\n // The creation time listed in this metadata.\n uint256 created;\n }\n\n /// A wallet with a public and private key.\n struct Wallet {\n // The wallet's address.\n address addr;\n // The wallet's public key `X`.\n uint256 publicKeyX;\n // The wallet's public key `Y`.\n uint256 publicKeyY;\n // The wallet's private key.\n uint256 privateKey;\n }\n\n /// The result of a `tryFfi` call.\n struct FfiResult {\n // The exit code of the call.\n int32 exitCode;\n // The optionally hex-decoded `stdout` data.\n bytes stdout;\n // The `stderr` data.\n bytes stderr;\n }\n\n /// Information on the chain and fork.\n struct ChainInfo {\n // The fork identifier. Set to zero if no fork is active.\n uint256 forkId;\n // The chain ID of the current fork.\n uint256 chainId;\n }\n\n /// The result of a `stopAndReturnStateDiff` call.\n struct AccountAccess {\n // The chain and fork the access occurred.\n ChainInfo chainInfo;\n // The kind of account access that determines what the account is.\n // If kind is Call, DelegateCall, StaticCall or CallCode, then the account is the callee.\n // If kind is Create, then the account is the newly created account.\n // If kind is SelfDestruct, then the account is the selfdestruct recipient.\n // If kind is a Resume, then account represents a account context that has resumed.\n AccountAccessKind kind;\n // The account that was accessed.\n // It's either the account created, callee or a selfdestruct recipient for CREATE, CALL or SELFDESTRUCT.\n address account;\n // What accessed the account.\n address accessor;\n // If the account was initialized or empty prior to the access.\n // An account is considered initialized if it has code, a\n // non-zero nonce, or a non-zero balance.\n bool initialized;\n // The previous balance of the accessed account.\n uint256 oldBalance;\n // The potential new balance of the accessed account.\n // That is, all balance changes are recorded here, even if reverts occurred.\n uint256 newBalance;\n // Code of the account deployed by CREATE.\n bytes deployedCode;\n // Value passed along with the account access\n uint256 value;\n // Input data provided to the CREATE or CALL\n bytes data;\n // If this access reverted in either the current or parent context.\n bool reverted;\n // An ordered list of storage accesses made during an account access operation.\n StorageAccess[] storageAccesses;\n // Call depth traversed during the recording of state differences\n uint64 depth;\n }\n\n /// The storage accessed during an `AccountAccess`.\n struct StorageAccess {\n // The account whose storage was accessed.\n address account;\n // The slot that was accessed.\n bytes32 slot;\n // If the access was a write.\n bool isWrite;\n // The previous value of the slot.\n bytes32 previousValue;\n // The new value of the slot.\n bytes32 newValue;\n // If the access was reverted.\n bool reverted;\n }\n\n /// Gas used. Returned by `lastCallGas`.\n struct Gas {\n // The gas limit of the call.\n uint64 gasLimit;\n // The total gas used.\n uint64 gasTotalUsed;\n // DEPRECATED: The amount of gas used for memory expansion. Ref: \n uint64 gasMemoryUsed;\n // The amount of gas refunded.\n int64 gasRefunded;\n // The amount of gas remaining.\n uint64 gasRemaining;\n }\n\n /// The result of the `stopDebugTraceRecording` call\n struct DebugStep {\n // The stack before executing the step of the run.\n // stack\\[0\\] represents the top of the stack.\n // and only stack data relevant to the opcode execution is contained.\n uint256[] stack;\n // The memory input data before executing the step of the run.\n // only input data relevant to the opcode execution is contained.\n // e.g. for MLOAD, it will have memory\\[offset:offset+32\\] copied here.\n // the offset value can be get by the stack data.\n bytes memoryInput;\n // The opcode that was accessed.\n uint8 opcode;\n // The call depth of the step.\n uint64 depth;\n // Whether the call end up with out of gas error.\n bool isOutOfGas;\n // The contract address where the opcode is running\n address contractAddr;\n }\n\n /// Represents a transaction's broadcast details.\n struct BroadcastTxSummary {\n // The hash of the transaction that was broadcasted\n bytes32 txHash;\n // Represent the type of transaction among CALL, CREATE, CREATE2\n BroadcastTxType txType;\n // The address of the contract that was called or created.\n // This is address of the contract that is created if the txType is CREATE or CREATE2.\n address contractAddress;\n // The block number the transaction landed in.\n uint64 blockNumber;\n // Status of the transaction, retrieved from the transaction receipt.\n bool success;\n }\n\n /// Holds a signed EIP-7702 authorization for an authority account to delegate to an implementation.\n struct SignedDelegation {\n // The y-parity of the recovered secp256k1 signature (0 or 1).\n uint8 v;\n // First 32 bytes of the signature.\n bytes32 r;\n // Second 32 bytes of the signature.\n bytes32 s;\n // The current nonce of the authority account at signing time.\n // Used to ensure signature can't be replayed after account nonce changes.\n uint64 nonce;\n // Address of the contract implementation that will be delegated to.\n // Gets encoded into delegation code: 0xef0100 || implementation.\n address implementation;\n }\n\n /// Represents a \"potential\" revert reason from a single subsequent call when using `vm.assumeNoReverts`.\n /// Reverts that match will result in a FOUNDRY::ASSUME rejection, whereas unmatched reverts will be surfaced\n /// as normal.\n struct PotentialRevert {\n // The allowed origin of the revert opcode; address(0) allows reverts from any address\n address reverter;\n // When true, only matches on the beginning of the revert data, otherwise, matches on entire revert data\n bool partialMatch;\n // The data to use to match encountered reverts\n bytes revertData;\n }\n\n /// An EIP-2930 access list item.\n struct AccessListItem {\n // The address to be added in access list.\n address target;\n // The storage keys to be added in access list.\n bytes32[] storageKeys;\n }\n\n // ======== Crypto ========\n\n /// Derives a private key from the name, labels the account with that name, and returns the wallet.\n function createWallet(string calldata walletLabel) external returns (Wallet memory wallet);\n\n /// Generates a wallet from the private key and returns the wallet.\n function createWallet(uint256 privateKey) external returns (Wallet memory wallet);\n\n /// Generates a wallet from the private key, labels the account with that name, and returns the wallet.\n function createWallet(uint256 privateKey, string calldata walletLabel) external returns (Wallet memory wallet);\n\n /// Derive a private key from a provided mnenomic string (or mnenomic file path)\n /// at the derivation path `m/44'/60'/0'/0/{index}`.\n function deriveKey(string calldata mnemonic, uint32 index) external pure returns (uint256 privateKey);\n\n /// Derive a private key from a provided mnenomic string (or mnenomic file path)\n /// at `{derivationPath}{index}`.\n function deriveKey(string calldata mnemonic, string calldata derivationPath, uint32 index)\n external\n pure\n returns (uint256 privateKey);\n\n /// Derive a private key from a provided mnenomic string (or mnenomic file path) in the specified language\n /// at the derivation path `m/44'/60'/0'/0/{index}`.\n function deriveKey(string calldata mnemonic, uint32 index, string calldata language)\n external\n pure\n returns (uint256 privateKey);\n\n /// Derive a private key from a provided mnenomic string (or mnenomic file path) in the specified language\n /// at `{derivationPath}{index}`.\n function deriveKey(string calldata mnemonic, string calldata derivationPath, uint32 index, string calldata language)\n external\n pure\n returns (uint256 privateKey);\n\n /// Derives secp256r1 public key from the provided `privateKey`.\n function publicKeyP256(uint256 privateKey) external pure returns (uint256 publicKeyX, uint256 publicKeyY);\n\n /// Adds a private key to the local forge wallet and returns the address.\n function rememberKey(uint256 privateKey) external returns (address keyAddr);\n\n /// Derive a set number of wallets from a mnemonic at the derivation path `m/44'/60'/0'/0/{0..count}`.\n /// The respective private keys are saved to the local forge wallet for later use and their addresses are returned.\n function rememberKeys(string calldata mnemonic, string calldata derivationPath, uint32 count)\n external\n returns (address[] memory keyAddrs);\n\n /// Derive a set number of wallets from a mnemonic in the specified language at the derivation path `m/44'/60'/0'/0/{0..count}`.\n /// The respective private keys are saved to the local forge wallet for later use and their addresses are returned.\n function rememberKeys(\n string calldata mnemonic,\n string calldata derivationPath,\n string calldata language,\n uint32 count\n ) external returns (address[] memory keyAddrs);\n\n /// Signs data with a `Wallet`.\n /// Returns a compact signature (`r`, `vs`) as per EIP-2098, where `vs` encodes both the\n /// signature's `s` value, and the recovery id `v` in a single bytes32.\n /// This format reduces the signature size from 65 to 64 bytes.\n function signCompact(Wallet calldata wallet, bytes32 digest) external returns (bytes32 r, bytes32 vs);\n\n /// Signs `digest` with `privateKey` using the secp256k1 curve.\n /// Returns a compact signature (`r`, `vs`) as per EIP-2098, where `vs` encodes both the\n /// signature's `s` value, and the recovery id `v` in a single bytes32.\n /// This format reduces the signature size from 65 to 64 bytes.\n function signCompact(uint256 privateKey, bytes32 digest) external pure returns (bytes32 r, bytes32 vs);\n\n /// Signs `digest` with signer provided to script using the secp256k1 curve.\n /// Returns a compact signature (`r`, `vs`) as per EIP-2098, where `vs` encodes both the\n /// signature's `s` value, and the recovery id `v` in a single bytes32.\n /// This format reduces the signature size from 65 to 64 bytes.\n /// If `--sender` is provided, the signer with provided address is used, otherwise,\n /// if exactly one signer is provided to the script, that signer is used.\n /// Raises error if signer passed through `--sender` does not match any unlocked signers or\n /// if `--sender` is not provided and not exactly one signer is passed to the script.\n function signCompact(bytes32 digest) external pure returns (bytes32 r, bytes32 vs);\n\n /// Signs `digest` with signer provided to script using the secp256k1 curve.\n /// Returns a compact signature (`r`, `vs`) as per EIP-2098, where `vs` encodes both the\n /// signature's `s` value, and the recovery id `v` in a single bytes32.\n /// This format reduces the signature size from 65 to 64 bytes.\n /// Raises error if none of the signers passed into the script have provided address.\n function signCompact(address signer, bytes32 digest) external pure returns (bytes32 r, bytes32 vs);\n\n /// Signs `digest` with `privateKey` using the secp256r1 curve.\n function signP256(uint256 privateKey, bytes32 digest) external pure returns (bytes32 r, bytes32 s);\n\n /// Signs data with a `Wallet`.\n function sign(Wallet calldata wallet, bytes32 digest) external returns (uint8 v, bytes32 r, bytes32 s);\n\n /// Signs `digest` with `privateKey` using the secp256k1 curve.\n function sign(uint256 privateKey, bytes32 digest) external pure returns (uint8 v, bytes32 r, bytes32 s);\n\n /// Signs `digest` with signer provided to script using the secp256k1 curve.\n /// If `--sender` is provided, the signer with provided address is used, otherwise,\n /// if exactly one signer is provided to the script, that signer is used.\n /// Raises error if signer passed through `--sender` does not match any unlocked signers or\n /// if `--sender` is not provided and not exactly one signer is passed to the script.\n function sign(bytes32 digest) external pure returns (uint8 v, bytes32 r, bytes32 s);\n\n /// Signs `digest` with signer provided to script using the secp256k1 curve.\n /// Raises error if none of the signers passed into the script have provided address.\n function sign(address signer, bytes32 digest) external pure returns (uint8 v, bytes32 r, bytes32 s);\n\n // ======== Environment ========\n\n /// Gets the environment variable `name` and parses it as `address`.\n /// Reverts if the variable was not found or could not be parsed.\n function envAddress(string calldata name) external view returns (address value);\n\n /// Gets the environment variable `name` and parses it as an array of `address`, delimited by `delim`.\n /// Reverts if the variable was not found or could not be parsed.\n function envAddress(string calldata name, string calldata delim) external view returns (address[] memory value);\n\n /// Gets the environment variable `name` and parses it as `bool`.\n /// Reverts if the variable was not found or could not be parsed.\n function envBool(string calldata name) external view returns (bool value);\n\n /// Gets the environment variable `name` and parses it as an array of `bool`, delimited by `delim`.\n /// Reverts if the variable was not found or could not be parsed.\n function envBool(string calldata name, string calldata delim) external view returns (bool[] memory value);\n\n /// Gets the environment variable `name` and parses it as `bytes32`.\n /// Reverts if the variable was not found or could not be parsed.\n function envBytes32(string calldata name) external view returns (bytes32 value);\n\n /// Gets the environment variable `name` and parses it as an array of `bytes32`, delimited by `delim`.\n /// Reverts if the variable was not found or could not be parsed.\n function envBytes32(string calldata name, string calldata delim) external view returns (bytes32[] memory value);\n\n /// Gets the environment variable `name` and parses it as `bytes`.\n /// Reverts if the variable was not found or could not be parsed.\n function envBytes(string calldata name) external view returns (bytes memory value);\n\n /// Gets the environment variable `name` and parses it as an array of `bytes`, delimited by `delim`.\n /// Reverts if the variable was not found or could not be parsed.\n function envBytes(string calldata name, string calldata delim) external view returns (bytes[] memory value);\n\n /// Gets the environment variable `name` and returns true if it exists, else returns false.\n function envExists(string calldata name) external view returns (bool result);\n\n /// Gets the environment variable `name` and parses it as `int256`.\n /// Reverts if the variable was not found or could not be parsed.\n function envInt(string calldata name) external view returns (int256 value);\n\n /// Gets the environment variable `name` and parses it as an array of `int256`, delimited by `delim`.\n /// Reverts if the variable was not found or could not be parsed.\n function envInt(string calldata name, string calldata delim) external view returns (int256[] memory value);\n\n /// Gets the environment variable `name` and parses it as `bool`.\n /// Reverts if the variable could not be parsed.\n /// Returns `defaultValue` if the variable was not found.\n function envOr(string calldata name, bool defaultValue) external view returns (bool value);\n\n /// Gets the environment variable `name` and parses it as `uint256`.\n /// Reverts if the variable could not be parsed.\n /// Returns `defaultValue` if the variable was not found.\n function envOr(string calldata name, uint256 defaultValue) external view returns (uint256 value);\n\n /// Gets the environment variable `name` and parses it as an array of `address`, delimited by `delim`.\n /// Reverts if the variable could not be parsed.\n /// Returns `defaultValue` if the variable was not found.\n function envOr(string calldata name, string calldata delim, address[] calldata defaultValue)\n external\n view\n returns (address[] memory value);\n\n /// Gets the environment variable `name` and parses it as an array of `bytes32`, delimited by `delim`.\n /// Reverts if the variable could not be parsed.\n /// Returns `defaultValue` if the variable was not found.\n function envOr(string calldata name, string calldata delim, bytes32[] calldata defaultValue)\n external\n view\n returns (bytes32[] memory value);\n\n /// Gets the environment variable `name` and parses it as an array of `string`, delimited by `delim`.\n /// Reverts if the variable could not be parsed.\n /// Returns `defaultValue` if the variable was not found.\n function envOr(string calldata name, string calldata delim, string[] calldata defaultValue)\n external\n view\n returns (string[] memory value);\n\n /// Gets the environment variable `name` and parses it as an array of `bytes`, delimited by `delim`.\n /// Reverts if the variable could not be parsed.\n /// Returns `defaultValue` if the variable was not found.\n function envOr(string calldata name, string calldata delim, bytes[] calldata defaultValue)\n external\n view\n returns (bytes[] memory value);\n\n /// Gets the environment variable `name` and parses it as `int256`.\n /// Reverts if the variable could not be parsed.\n /// Returns `defaultValue` if the variable was not found.\n function envOr(string calldata name, int256 defaultValue) external view returns (int256 value);\n\n /// Gets the environment variable `name` and parses it as `address`.\n /// Reverts if the variable could not be parsed.\n /// Returns `defaultValue` if the variable was not found.\n function envOr(string calldata name, address defaultValue) external view returns (address value);\n\n /// Gets the environment variable `name` and parses it as `bytes32`.\n /// Reverts if the variable could not be parsed.\n /// Returns `defaultValue` if the variable was not found.\n function envOr(string calldata name, bytes32 defaultValue) external view returns (bytes32 value);\n\n /// Gets the environment variable `name` and parses it as `string`.\n /// Reverts if the variable could not be parsed.\n /// Returns `defaultValue` if the variable was not found.\n function envOr(string calldata name, string calldata defaultValue) external view returns (string memory value);\n\n /// Gets the environment variable `name` and parses it as `bytes`.\n /// Reverts if the variable could not be parsed.\n /// Returns `defaultValue` if the variable was not found.\n function envOr(string calldata name, bytes calldata defaultValue) external view returns (bytes memory value);\n\n /// Gets the environment variable `name` and parses it as an array of `bool`, delimited by `delim`.\n /// Reverts if the variable could not be parsed.\n /// Returns `defaultValue` if the variable was not found.\n function envOr(string calldata name, string calldata delim, bool[] calldata defaultValue)\n external\n view\n returns (bool[] memory value);\n\n /// Gets the environment variable `name` and parses it as an array of `uint256`, delimited by `delim`.\n /// Reverts if the variable could not be parsed.\n /// Returns `defaultValue` if the variable was not found.\n function envOr(string calldata name, string calldata delim, uint256[] calldata defaultValue)\n external\n view\n returns (uint256[] memory value);\n\n /// Gets the environment variable `name` and parses it as an array of `int256`, delimited by `delim`.\n /// Reverts if the variable could not be parsed.\n /// Returns `defaultValue` if the variable was not found.\n function envOr(string calldata name, string calldata delim, int256[] calldata defaultValue)\n external\n view\n returns (int256[] memory value);\n\n /// Gets the environment variable `name` and parses it as `string`.\n /// Reverts if the variable was not found or could not be parsed.\n function envString(string calldata name) external view returns (string memory value);\n\n /// Gets the environment variable `name` and parses it as an array of `string`, delimited by `delim`.\n /// Reverts if the variable was not found or could not be parsed.\n function envString(string calldata name, string calldata delim) external view returns (string[] memory value);\n\n /// Gets the environment variable `name` and parses it as `uint256`.\n /// Reverts if the variable was not found or could not be parsed.\n function envUint(string calldata name) external view returns (uint256 value);\n\n /// Gets the environment variable `name` and parses it as an array of `uint256`, delimited by `delim`.\n /// Reverts if the variable was not found or could not be parsed.\n function envUint(string calldata name, string calldata delim) external view returns (uint256[] memory value);\n\n /// Returns true if `forge` command was executed in given context.\n function isContext(ForgeContext context) external view returns (bool result);\n\n /// Sets environment variables.\n function setEnv(string calldata name, string calldata value) external;\n\n // ======== EVM ========\n\n /// Gets all accessed reads and write slot from a `vm.record` session, for a given address.\n function accesses(address target) external returns (bytes32[] memory readSlots, bytes32[] memory writeSlots);\n\n /// Gets the address for a given private key.\n function addr(uint256 privateKey) external pure returns (address keyAddr);\n\n /// Gets all the logs according to specified filter.\n function eth_getLogs(uint256 fromBlock, uint256 toBlock, address target, bytes32[] calldata topics)\n external\n returns (EthGetLogs[] memory logs);\n\n /// Gets the current `block.blobbasefee`.\n /// You should use this instead of `block.blobbasefee` if you use `vm.blobBaseFee`, as `block.blobbasefee` is assumed to be constant across a transaction,\n /// and as a result will get optimized out by the compiler.\n /// See https://github.com/foundry-rs/foundry/issues/6180\n function getBlobBaseFee() external view returns (uint256 blobBaseFee);\n\n /// Gets the current `block.number`.\n /// You should use this instead of `block.number` if you use `vm.roll`, as `block.number` is assumed to be constant across a transaction,\n /// and as a result will get optimized out by the compiler.\n /// See https://github.com/foundry-rs/foundry/issues/6180\n function getBlockNumber() external view returns (uint256 height);\n\n /// Gets the current `block.timestamp`.\n /// You should use this instead of `block.timestamp` if you use `vm.warp`, as `block.timestamp` is assumed to be constant across a transaction,\n /// and as a result will get optimized out by the compiler.\n /// See https://github.com/foundry-rs/foundry/issues/6180\n function getBlockTimestamp() external view returns (uint256 timestamp);\n\n /// Gets the map key and parent of a mapping at a given slot, for a given address.\n function getMappingKeyAndParentOf(address target, bytes32 elementSlot)\n external\n returns (bool found, bytes32 key, bytes32 parent);\n\n /// Gets the number of elements in the mapping at the given slot, for a given address.\n function getMappingLength(address target, bytes32 mappingSlot) external returns (uint256 length);\n\n /// Gets the elements at index idx of the mapping at the given slot, for a given address. The\n /// index must be less than the length of the mapping (i.e. the number of keys in the mapping).\n function getMappingSlotAt(address target, bytes32 mappingSlot, uint256 idx) external returns (bytes32 value);\n\n /// Gets the nonce of an account.\n function getNonce(address account) external view returns (uint64 nonce);\n\n /// Get the nonce of a `Wallet`.\n function getNonce(Wallet calldata wallet) external returns (uint64 nonce);\n\n /// Gets all the recorded logs.\n function getRecordedLogs() external returns (Log[] memory logs);\n\n /// Returns state diffs from current `vm.startStateDiffRecording` session.\n function getStateDiff() external view returns (string memory diff);\n\n /// Returns state diffs from current `vm.startStateDiffRecording` session, in json format.\n function getStateDiffJson() external view returns (string memory diff);\n\n /// Gets the gas used in the last call from the callee perspective.\n function lastCallGas() external view returns (Gas memory gas);\n\n /// Loads a storage slot from an address.\n function load(address target, bytes32 slot) external view returns (bytes32 data);\n\n /// Pauses gas metering (i.e. gas usage is not counted). Noop if already paused.\n function pauseGasMetering() external;\n\n /// Records all storage reads and writes.\n function record() external;\n\n /// Record all the transaction logs.\n function recordLogs() external;\n\n /// Reset gas metering (i.e. gas usage is set to gas limit).\n function resetGasMetering() external;\n\n /// Resumes gas metering (i.e. gas usage is counted again). Noop if already on.\n function resumeGasMetering() external;\n\n /// Performs an Ethereum JSON-RPC request to the current fork URL.\n function rpc(string calldata method, string calldata params) external returns (bytes memory data);\n\n /// Performs an Ethereum JSON-RPC request to the given endpoint.\n function rpc(string calldata urlOrAlias, string calldata method, string calldata params)\n external\n returns (bytes memory data);\n\n /// Records the debug trace during the run.\n function startDebugTraceRecording() external;\n\n /// Starts recording all map SSTOREs for later retrieval.\n function startMappingRecording() external;\n\n /// Record all account accesses as part of CREATE, CALL or SELFDESTRUCT opcodes in order,\n /// along with the context of the calls\n function startStateDiffRecording() external;\n\n /// Stop debug trace recording and returns the recorded debug trace.\n function stopAndReturnDebugTraceRecording() external returns (DebugStep[] memory step);\n\n /// Returns an ordered array of all account accesses from a `vm.startStateDiffRecording` session.\n function stopAndReturnStateDiff() external returns (AccountAccess[] memory accountAccesses);\n\n /// Stops recording all map SSTOREs for later retrieval and clears the recorded data.\n function stopMappingRecording() external;\n\n // ======== Filesystem ========\n\n /// Closes file for reading, resetting the offset and allowing to read it from beginning with readLine.\n /// `path` is relative to the project root.\n function closeFile(string calldata path) external;\n\n /// Copies the contents of one file to another. This function will **overwrite** the contents of `to`.\n /// On success, the total number of bytes copied is returned and it is equal to the length of the `to` file as reported by `metadata`.\n /// Both `from` and `to` are relative to the project root.\n function copyFile(string calldata from, string calldata to) external returns (uint64 copied);\n\n /// Creates a new, empty directory at the provided path.\n /// This cheatcode will revert in the following situations, but is not limited to just these cases:\n /// - User lacks permissions to modify `path`.\n /// - A parent of the given path doesn't exist and `recursive` is false.\n /// - `path` already exists and `recursive` is false.\n /// `path` is relative to the project root.\n function createDir(string calldata path, bool recursive) external;\n\n /// Deploys a contract from an artifact file. Takes in the relative path to the json file or the path to the\n /// artifact in the form of :: where and parts are optional.\n function deployCode(string calldata artifactPath) external returns (address deployedAddress);\n\n /// Deploys a contract from an artifact file. Takes in the relative path to the json file or the path to the\n /// artifact in the form of :: where and parts are optional.\n /// Additionally accepts abi-encoded constructor arguments.\n function deployCode(string calldata artifactPath, bytes calldata constructorArgs)\n external\n returns (address deployedAddress);\n\n /// Returns true if the given path points to an existing entity, else returns false.\n function exists(string calldata path) external view returns (bool result);\n\n /// Performs a foreign function call via the terminal.\n function ffi(string[] calldata commandInput) external returns (bytes memory result);\n\n /// Given a path, query the file system to get information about a file, directory, etc.\n function fsMetadata(string calldata path) external view returns (FsMetadata memory metadata);\n\n /// Gets the artifact path from code (aka. creation code).\n function getArtifactPathByCode(bytes calldata code) external view returns (string memory path);\n\n /// Gets the artifact path from deployed code (aka. runtime code).\n function getArtifactPathByDeployedCode(bytes calldata deployedCode) external view returns (string memory path);\n\n /// Returns the most recent broadcast for the given contract on `chainId` matching `txType`.\n /// For example:\n /// The most recent deployment can be fetched by passing `txType` as `CREATE` or `CREATE2`.\n /// The most recent call can be fetched by passing `txType` as `CALL`.\n function getBroadcast(string calldata contractName, uint64 chainId, BroadcastTxType txType)\n external\n view\n returns (BroadcastTxSummary memory);\n\n /// Returns all broadcasts for the given contract on `chainId` with the specified `txType`.\n /// Sorted such that the most recent broadcast is the first element, and the oldest is the last. i.e descending order of BroadcastTxSummary.blockNumber.\n function getBroadcasts(string calldata contractName, uint64 chainId, BroadcastTxType txType)\n external\n view\n returns (BroadcastTxSummary[] memory);\n\n /// Returns all broadcasts for the given contract on `chainId`.\n /// Sorted such that the most recent broadcast is the first element, and the oldest is the last. i.e descending order of BroadcastTxSummary.blockNumber.\n function getBroadcasts(string calldata contractName, uint64 chainId)\n external\n view\n returns (BroadcastTxSummary[] memory);\n\n /// Gets the creation bytecode from an artifact file. Takes in the relative path to the json file or the path to the\n /// artifact in the form of :: where and parts are optional.\n function getCode(string calldata artifactPath) external view returns (bytes memory creationBytecode);\n\n /// Gets the deployed bytecode from an artifact file. Takes in the relative path to the json file or the path to the\n /// artifact in the form of :: where and parts are optional.\n function getDeployedCode(string calldata artifactPath) external view returns (bytes memory runtimeBytecode);\n\n /// Returns the most recent deployment for the current `chainId`.\n function getDeployment(string calldata contractName) external view returns (address deployedAddress);\n\n /// Returns the most recent deployment for the given contract on `chainId`\n function getDeployment(string calldata contractName, uint64 chainId)\n external\n view\n returns (address deployedAddress);\n\n /// Returns all deployments for the given contract on `chainId`\n /// Sorted in descending order of deployment time i.e descending order of BroadcastTxSummary.blockNumber.\n /// The most recent deployment is the first element, and the oldest is the last.\n function getDeployments(string calldata contractName, uint64 chainId)\n external\n view\n returns (address[] memory deployedAddresses);\n\n /// Returns true if the path exists on disk and is pointing at a directory, else returns false.\n function isDir(string calldata path) external view returns (bool result);\n\n /// Returns true if the path exists on disk and is pointing at a regular file, else returns false.\n function isFile(string calldata path) external view returns (bool result);\n\n /// Get the path of the current project root.\n function projectRoot() external view returns (string memory path);\n\n /// Prompts the user for a string value in the terminal.\n function prompt(string calldata promptText) external returns (string memory input);\n\n /// Prompts the user for an address in the terminal.\n function promptAddress(string calldata promptText) external returns (address);\n\n /// Prompts the user for a hidden string value in the terminal.\n function promptSecret(string calldata promptText) external returns (string memory input);\n\n /// Prompts the user for hidden uint256 in the terminal (usually pk).\n function promptSecretUint(string calldata promptText) external returns (uint256);\n\n /// Prompts the user for uint256 in the terminal.\n function promptUint(string calldata promptText) external returns (uint256);\n\n /// Reads the directory at the given path recursively, up to `maxDepth`.\n /// `maxDepth` defaults to 1, meaning only the direct children of the given directory will be returned.\n /// Follows symbolic links if `followLinks` is true.\n function readDir(string calldata path) external view returns (DirEntry[] memory entries);\n\n /// See `readDir(string)`.\n function readDir(string calldata path, uint64 maxDepth) external view returns (DirEntry[] memory entries);\n\n /// See `readDir(string)`.\n function readDir(string calldata path, uint64 maxDepth, bool followLinks)\n external\n view\n returns (DirEntry[] memory entries);\n\n /// Reads the entire content of file to string. `path` is relative to the project root.\n function readFile(string calldata path) external view returns (string memory data);\n\n /// Reads the entire content of file as binary. `path` is relative to the project root.\n function readFileBinary(string calldata path) external view returns (bytes memory data);\n\n /// Reads next line of file to string.\n function readLine(string calldata path) external view returns (string memory line);\n\n /// Reads a symbolic link, returning the path that the link points to.\n /// This cheatcode will revert in the following situations, but is not limited to just these cases:\n /// - `path` is not a symbolic link.\n /// - `path` does not exist.\n function readLink(string calldata linkPath) external view returns (string memory targetPath);\n\n /// Removes a directory at the provided path.\n /// This cheatcode will revert in the following situations, but is not limited to just these cases:\n /// - `path` doesn't exist.\n /// - `path` isn't a directory.\n /// - User lacks permissions to modify `path`.\n /// - The directory is not empty and `recursive` is false.\n /// `path` is relative to the project root.\n function removeDir(string calldata path, bool recursive) external;\n\n /// Removes a file from the filesystem.\n /// This cheatcode will revert in the following situations, but is not limited to just these cases:\n /// - `path` points to a directory.\n /// - The file doesn't exist.\n /// - The user lacks permissions to remove the file.\n /// `path` is relative to the project root.\n function removeFile(string calldata path) external;\n\n /// Performs a foreign function call via terminal and returns the exit code, stdout, and stderr.\n function tryFfi(string[] calldata commandInput) external returns (FfiResult memory result);\n\n /// Returns the time since unix epoch in milliseconds.\n function unixTime() external view returns (uint256 milliseconds);\n\n /// Writes data to file, creating a file if it does not exist, and entirely replacing its contents if it does.\n /// `path` is relative to the project root.\n function writeFile(string calldata path, string calldata data) external;\n\n /// Writes binary data to a file, creating a file if it does not exist, and entirely replacing its contents if it does.\n /// `path` is relative to the project root.\n function writeFileBinary(string calldata path, bytes calldata data) external;\n\n /// Writes line to file, creating a file if it does not exist.\n /// `path` is relative to the project root.\n function writeLine(string calldata path, string calldata data) external;\n\n // ======== JSON ========\n\n /// Checks if `key` exists in a JSON object.\n function keyExistsJson(string calldata json, string calldata key) external view returns (bool);\n\n /// Parses a string of JSON data at `key` and coerces it to `address`.\n function parseJsonAddress(string calldata json, string calldata key) external pure returns (address);\n\n /// Parses a string of JSON data at `key` and coerces it to `address[]`.\n function parseJsonAddressArray(string calldata json, string calldata key)\n external\n pure\n returns (address[] memory);\n\n /// Parses a string of JSON data at `key` and coerces it to `bool`.\n function parseJsonBool(string calldata json, string calldata key) external pure returns (bool);\n\n /// Parses a string of JSON data at `key` and coerces it to `bool[]`.\n function parseJsonBoolArray(string calldata json, string calldata key) external pure returns (bool[] memory);\n\n /// Parses a string of JSON data at `key` and coerces it to `bytes`.\n function parseJsonBytes(string calldata json, string calldata key) external pure returns (bytes memory);\n\n /// Parses a string of JSON data at `key` and coerces it to `bytes32`.\n function parseJsonBytes32(string calldata json, string calldata key) external pure returns (bytes32);\n\n /// Parses a string of JSON data at `key` and coerces it to `bytes32[]`.\n function parseJsonBytes32Array(string calldata json, string calldata key)\n external\n pure\n returns (bytes32[] memory);\n\n /// Parses a string of JSON data at `key` and coerces it to `bytes[]`.\n function parseJsonBytesArray(string calldata json, string calldata key) external pure returns (bytes[] memory);\n\n /// Parses a string of JSON data at `key` and coerces it to `int256`.\n function parseJsonInt(string calldata json, string calldata key) external pure returns (int256);\n\n /// Parses a string of JSON data at `key` and coerces it to `int256[]`.\n function parseJsonIntArray(string calldata json, string calldata key) external pure returns (int256[] memory);\n\n /// Returns an array of all the keys in a JSON object.\n function parseJsonKeys(string calldata json, string calldata key) external pure returns (string[] memory keys);\n\n /// Parses a string of JSON data at `key` and coerces it to `string`.\n function parseJsonString(string calldata json, string calldata key) external pure returns (string memory);\n\n /// Parses a string of JSON data at `key` and coerces it to `string[]`.\n function parseJsonStringArray(string calldata json, string calldata key) external pure returns (string[] memory);\n\n /// Parses a string of JSON data at `key` and coerces it to type array corresponding to `typeDescription`.\n function parseJsonTypeArray(string calldata json, string calldata key, string calldata typeDescription)\n external\n pure\n returns (bytes memory);\n\n /// Parses a string of JSON data and coerces it to type corresponding to `typeDescription`.\n function parseJsonType(string calldata json, string calldata typeDescription)\n external\n pure\n returns (bytes memory);\n\n /// Parses a string of JSON data at `key` and coerces it to type corresponding to `typeDescription`.\n function parseJsonType(string calldata json, string calldata key, string calldata typeDescription)\n external\n pure\n returns (bytes memory);\n\n /// Parses a string of JSON data at `key` and coerces it to `uint256`.\n function parseJsonUint(string calldata json, string calldata key) external pure returns (uint256);\n\n /// Parses a string of JSON data at `key` and coerces it to `uint256[]`.\n function parseJsonUintArray(string calldata json, string calldata key) external pure returns (uint256[] memory);\n\n /// ABI-encodes a JSON object.\n function parseJson(string calldata json) external pure returns (bytes memory abiEncodedData);\n\n /// ABI-encodes a JSON object at `key`.\n function parseJson(string calldata json, string calldata key) external pure returns (bytes memory abiEncodedData);\n\n /// See `serializeJson`.\n function serializeAddress(string calldata objectKey, string calldata valueKey, address value)\n external\n returns (string memory json);\n\n /// See `serializeJson`.\n function serializeAddress(string calldata objectKey, string calldata valueKey, address[] calldata values)\n external\n returns (string memory json);\n\n /// See `serializeJson`.\n function serializeBool(string calldata objectKey, string calldata valueKey, bool value)\n external\n returns (string memory json);\n\n /// See `serializeJson`.\n function serializeBool(string calldata objectKey, string calldata valueKey, bool[] calldata values)\n external\n returns (string memory json);\n\n /// See `serializeJson`.\n function serializeBytes32(string calldata objectKey, string calldata valueKey, bytes32 value)\n external\n returns (string memory json);\n\n /// See `serializeJson`.\n function serializeBytes32(string calldata objectKey, string calldata valueKey, bytes32[] calldata values)\n external\n returns (string memory json);\n\n /// See `serializeJson`.\n function serializeBytes(string calldata objectKey, string calldata valueKey, bytes calldata value)\n external\n returns (string memory json);\n\n /// See `serializeJson`.\n function serializeBytes(string calldata objectKey, string calldata valueKey, bytes[] calldata values)\n external\n returns (string memory json);\n\n /// See `serializeJson`.\n function serializeInt(string calldata objectKey, string calldata valueKey, int256 value)\n external\n returns (string memory json);\n\n /// See `serializeJson`.\n function serializeInt(string calldata objectKey, string calldata valueKey, int256[] calldata values)\n external\n returns (string memory json);\n\n /// Serializes a key and value to a JSON object stored in-memory that can be later written to a file.\n /// Returns the stringified version of the specific JSON file up to that moment.\n function serializeJson(string calldata objectKey, string calldata value) external returns (string memory json);\n\n /// See `serializeJson`.\n function serializeJsonType(string calldata typeDescription, bytes calldata value)\n external\n pure\n returns (string memory json);\n\n /// See `serializeJson`.\n function serializeJsonType(\n string calldata objectKey,\n string calldata valueKey,\n string calldata typeDescription,\n bytes calldata value\n ) external returns (string memory json);\n\n /// See `serializeJson`.\n function serializeString(string calldata objectKey, string calldata valueKey, string calldata value)\n external\n returns (string memory json);\n\n /// See `serializeJson`.\n function serializeString(string calldata objectKey, string calldata valueKey, string[] calldata values)\n external\n returns (string memory json);\n\n /// See `serializeJson`.\n function serializeUintToHex(string calldata objectKey, string calldata valueKey, uint256 value)\n external\n returns (string memory json);\n\n /// See `serializeJson`.\n function serializeUint(string calldata objectKey, string calldata valueKey, uint256 value)\n external\n returns (string memory json);\n\n /// See `serializeJson`.\n function serializeUint(string calldata objectKey, string calldata valueKey, uint256[] calldata values)\n external\n returns (string memory json);\n\n /// Write a serialized JSON object to a file. If the file exists, it will be overwritten.\n function writeJson(string calldata json, string calldata path) external;\n\n /// Write a serialized JSON object to an **existing** JSON file, replacing a value with key = \n /// This is useful to replace a specific value of a JSON file, without having to parse the entire thing.\n function writeJson(string calldata json, string calldata path, string calldata valueKey) external;\n\n /// Checks if `key` exists in a JSON object\n /// `keyExists` is being deprecated in favor of `keyExistsJson`. It will be removed in future versions.\n function keyExists(string calldata json, string calldata key) external view returns (bool);\n\n // ======== Scripting ========\n\n /// Designate the next call as an EIP-7702 transaction\n function attachDelegation(SignedDelegation calldata signedDelegation) external;\n\n /// Takes a signed transaction and broadcasts it to the network.\n function broadcastRawTransaction(bytes calldata data) external;\n\n /// Has the next call (at this call depth only) create transactions that can later be signed and sent onchain.\n /// Broadcasting address is determined by checking the following in order:\n /// 1. If `--sender` argument was provided, that address is used.\n /// 2. If exactly one signer (e.g. private key, hw wallet, keystore) is set when `forge broadcast` is invoked, that signer is used.\n /// 3. Otherwise, default foundry sender (1804c8AB1F12E6bbf3894d4083f33e07309d1f38) is used.\n function broadcast() external;\n\n /// Has the next call (at this call depth only) create a transaction with the address provided\n /// as the sender that can later be signed and sent onchain.\n function broadcast(address signer) external;\n\n /// Has the next call (at this call depth only) create a transaction with the private key\n /// provided as the sender that can later be signed and sent onchain.\n function broadcast(uint256 privateKey) external;\n\n /// Returns addresses of available unlocked wallets in the script environment.\n function getWallets() external returns (address[] memory wallets);\n\n /// Sign an EIP-7702 authorization and designate the next call as an EIP-7702 transaction\n function signAndAttachDelegation(address implementation, uint256 privateKey)\n external\n returns (SignedDelegation memory signedDelegation);\n\n /// Sign an EIP-7702 authorization for delegation\n function signDelegation(address implementation, uint256 privateKey)\n external\n returns (SignedDelegation memory signedDelegation);\n\n /// Has all subsequent calls (at this call depth only) create transactions that can later be signed and sent onchain.\n /// Broadcasting address is determined by checking the following in order:\n /// 1. If `--sender` argument was provided, that address is used.\n /// 2. If exactly one signer (e.g. private key, hw wallet, keystore) is set when `forge broadcast` is invoked, that signer is used.\n /// 3. Otherwise, default foundry sender (1804c8AB1F12E6bbf3894d4083f33e07309d1f38) is used.\n function startBroadcast() external;\n\n /// Has all subsequent calls (at this call depth only) create transactions with the address\n /// provided that can later be signed and sent onchain.\n function startBroadcast(address signer) external;\n\n /// Has all subsequent calls (at this call depth only) create transactions with the private key\n /// provided that can later be signed and sent onchain.\n function startBroadcast(uint256 privateKey) external;\n\n /// Stops collecting onchain transactions.\n function stopBroadcast() external;\n\n // ======== String ========\n\n /// Returns true if `search` is found in `subject`, false otherwise.\n function contains(string calldata subject, string calldata search) external returns (bool result);\n\n /// Returns the index of the first occurrence of a `key` in an `input` string.\n /// Returns `NOT_FOUND` (i.e. `type(uint256).max`) if the `key` is not found.\n /// Returns 0 in case of an empty `key`.\n function indexOf(string calldata input, string calldata key) external pure returns (uint256);\n\n /// Parses the given `string` into an `address`.\n function parseAddress(string calldata stringifiedValue) external pure returns (address parsedValue);\n\n /// Parses the given `string` into a `bool`.\n function parseBool(string calldata stringifiedValue) external pure returns (bool parsedValue);\n\n /// Parses the given `string` into `bytes`.\n function parseBytes(string calldata stringifiedValue) external pure returns (bytes memory parsedValue);\n\n /// Parses the given `string` into a `bytes32`.\n function parseBytes32(string calldata stringifiedValue) external pure returns (bytes32 parsedValue);\n\n /// Parses the given `string` into a `int256`.\n function parseInt(string calldata stringifiedValue) external pure returns (int256 parsedValue);\n\n /// Parses the given `string` into a `uint256`.\n function parseUint(string calldata stringifiedValue) external pure returns (uint256 parsedValue);\n\n /// Replaces occurrences of `from` in the given `string` with `to`.\n function replace(string calldata input, string calldata from, string calldata to)\n external\n pure\n returns (string memory output);\n\n /// Splits the given `string` into an array of strings divided by the `delimiter`.\n function split(string calldata input, string calldata delimiter) external pure returns (string[] memory outputs);\n\n /// Converts the given `string` value to Lowercase.\n function toLowercase(string calldata input) external pure returns (string memory output);\n\n /// Converts the given value to a `string`.\n function toString(address value) external pure returns (string memory stringifiedValue);\n\n /// Converts the given value to a `string`.\n function toString(bytes calldata value) external pure returns (string memory stringifiedValue);\n\n /// Converts the given value to a `string`.\n function toString(bytes32 value) external pure returns (string memory stringifiedValue);\n\n /// Converts the given value to a `string`.\n function toString(bool value) external pure returns (string memory stringifiedValue);\n\n /// Converts the given value to a `string`.\n function toString(uint256 value) external pure returns (string memory stringifiedValue);\n\n /// Converts the given value to a `string`.\n function toString(int256 value) external pure returns (string memory stringifiedValue);\n\n /// Converts the given `string` value to Uppercase.\n function toUppercase(string calldata input) external pure returns (string memory output);\n\n /// Trims leading and trailing whitespace from the given `string` value.\n function trim(string calldata input) external pure returns (string memory output);\n\n // ======== Testing ========\n\n /// Compares two `uint256` values. Expects difference to be less than or equal to `maxDelta`.\n /// Formats values with decimals in failure message.\n function assertApproxEqAbsDecimal(uint256 left, uint256 right, uint256 maxDelta, uint256 decimals) external pure;\n\n /// Compares two `uint256` values. Expects difference to be less than or equal to `maxDelta`.\n /// Formats values with decimals in failure message. Includes error message into revert string on failure.\n function assertApproxEqAbsDecimal(\n uint256 left,\n uint256 right,\n uint256 maxDelta,\n uint256 decimals,\n string calldata error\n ) external pure;\n\n /// Compares two `int256` values. Expects difference to be less than or equal to `maxDelta`.\n /// Formats values with decimals in failure message.\n function assertApproxEqAbsDecimal(int256 left, int256 right, uint256 maxDelta, uint256 decimals) external pure;\n\n /// Compares two `int256` values. Expects difference to be less than or equal to `maxDelta`.\n /// Formats values with decimals in failure message. Includes error message into revert string on failure.\n function assertApproxEqAbsDecimal(\n int256 left,\n int256 right,\n uint256 maxDelta,\n uint256 decimals,\n string calldata error\n ) external pure;\n\n /// Compares two `uint256` values. Expects difference to be less than or equal to `maxDelta`.\n function assertApproxEqAbs(uint256 left, uint256 right, uint256 maxDelta) external pure;\n\n /// Compares two `uint256` values. Expects difference to be less than or equal to `maxDelta`.\n /// Includes error message into revert string on failure.\n function assertApproxEqAbs(uint256 left, uint256 right, uint256 maxDelta, string calldata error) external pure;\n\n /// Compares two `int256` values. Expects difference to be less than or equal to `maxDelta`.\n function assertApproxEqAbs(int256 left, int256 right, uint256 maxDelta) external pure;\n\n /// Compares two `int256` values. Expects difference to be less than or equal to `maxDelta`.\n /// Includes error message into revert string on failure.\n function assertApproxEqAbs(int256 left, int256 right, uint256 maxDelta, string calldata error) external pure;\n\n /// Compares two `uint256` values. Expects relative difference in percents to be less than or equal to `maxPercentDelta`.\n /// `maxPercentDelta` is an 18 decimal fixed point number, where 1e18 == 100%\n /// Formats values with decimals in failure message.\n function assertApproxEqRelDecimal(uint256 left, uint256 right, uint256 maxPercentDelta, uint256 decimals)\n external\n pure;\n\n /// Compares two `uint256` values. Expects relative difference in percents to be less than or equal to `maxPercentDelta`.\n /// `maxPercentDelta` is an 18 decimal fixed point number, where 1e18 == 100%\n /// Formats values with decimals in failure message. Includes error message into revert string on failure.\n function assertApproxEqRelDecimal(\n uint256 left,\n uint256 right,\n uint256 maxPercentDelta,\n uint256 decimals,\n string calldata error\n ) external pure;\n\n /// Compares two `int256` values. Expects relative difference in percents to be less than or equal to `maxPercentDelta`.\n /// `maxPercentDelta` is an 18 decimal fixed point number, where 1e18 == 100%\n /// Formats values with decimals in failure message.\n function assertApproxEqRelDecimal(int256 left, int256 right, uint256 maxPercentDelta, uint256 decimals)\n external\n pure;\n\n /// Compares two `int256` values. Expects relative difference in percents to be less than or equal to `maxPercentDelta`.\n /// `maxPercentDelta` is an 18 decimal fixed point number, where 1e18 == 100%\n /// Formats values with decimals in failure message. Includes error message into revert string on failure.\n function assertApproxEqRelDecimal(\n int256 left,\n int256 right,\n uint256 maxPercentDelta,\n uint256 decimals,\n string calldata error\n ) external pure;\n\n /// Compares two `uint256` values. Expects relative difference in percents to be less than or equal to `maxPercentDelta`.\n /// `maxPercentDelta` is an 18 decimal fixed point number, where 1e18 == 100%\n function assertApproxEqRel(uint256 left, uint256 right, uint256 maxPercentDelta) external pure;\n\n /// Compares two `uint256` values. Expects relative difference in percents to be less than or equal to `maxPercentDelta`.\n /// `maxPercentDelta` is an 18 decimal fixed point number, where 1e18 == 100%\n /// Includes error message into revert string on failure.\n function assertApproxEqRel(uint256 left, uint256 right, uint256 maxPercentDelta, string calldata error)\n external\n pure;\n\n /// Compares two `int256` values. Expects relative difference in percents to be less than or equal to `maxPercentDelta`.\n /// `maxPercentDelta` is an 18 decimal fixed point number, where 1e18 == 100%\n function assertApproxEqRel(int256 left, int256 right, uint256 maxPercentDelta) external pure;\n\n /// Compares two `int256` values. Expects relative difference in percents to be less than or equal to `maxPercentDelta`.\n /// `maxPercentDelta` is an 18 decimal fixed point number, where 1e18 == 100%\n /// Includes error message into revert string on failure.\n function assertApproxEqRel(int256 left, int256 right, uint256 maxPercentDelta, string calldata error)\n external\n pure;\n\n /// Asserts that two `uint256` values are equal, formatting them with decimals in failure message.\n function assertEqDecimal(uint256 left, uint256 right, uint256 decimals) external pure;\n\n /// Asserts that two `uint256` values are equal, formatting them with decimals in failure message.\n /// Includes error message into revert string on failure.\n function assertEqDecimal(uint256 left, uint256 right, uint256 decimals, string calldata error) external pure;\n\n /// Asserts that two `int256` values are equal, formatting them with decimals in failure message.\n function assertEqDecimal(int256 left, int256 right, uint256 decimals) external pure;\n\n /// Asserts that two `int256` values are equal, formatting them with decimals in failure message.\n /// Includes error message into revert string on failure.\n function assertEqDecimal(int256 left, int256 right, uint256 decimals, string calldata error) external pure;\n\n /// Asserts that two `bool` values are equal.\n function assertEq(bool left, bool right) external pure;\n\n /// Asserts that two `bool` values are equal and includes error message into revert string on failure.\n function assertEq(bool left, bool right, string calldata error) external pure;\n\n /// Asserts that two `string` values are equal.\n function assertEq(string calldata left, string calldata right) external pure;\n\n /// Asserts that two `string` values are equal and includes error message into revert string on failure.\n function assertEq(string calldata left, string calldata right, string calldata error) external pure;\n\n /// Asserts that two `bytes` values are equal.\n function assertEq(bytes calldata left, bytes calldata right) external pure;\n\n /// Asserts that two `bytes` values are equal and includes error message into revert string on failure.\n function assertEq(bytes calldata left, bytes calldata right, string calldata error) external pure;\n\n /// Asserts that two arrays of `bool` values are equal.\n function assertEq(bool[] calldata left, bool[] calldata right) external pure;\n\n /// Asserts that two arrays of `bool` values are equal and includes error message into revert string on failure.\n function assertEq(bool[] calldata left, bool[] calldata right, string calldata error) external pure;\n\n /// Asserts that two arrays of `uint256 values are equal.\n function assertEq(uint256[] calldata left, uint256[] calldata right) external pure;\n\n /// Asserts that two arrays of `uint256` values are equal and includes error message into revert string on failure.\n function assertEq(uint256[] calldata left, uint256[] calldata right, string calldata error) external pure;\n\n /// Asserts that two arrays of `int256` values are equal.\n function assertEq(int256[] calldata left, int256[] calldata right) external pure;\n\n /// Asserts that two arrays of `int256` values are equal and includes error message into revert string on failure.\n function assertEq(int256[] calldata left, int256[] calldata right, string calldata error) external pure;\n\n /// Asserts that two `uint256` values are equal.\n function assertEq(uint256 left, uint256 right) external pure;\n\n /// Asserts that two arrays of `address` values are equal.\n function assertEq(address[] calldata left, address[] calldata right) external pure;\n\n /// Asserts that two arrays of `address` values are equal and includes error message into revert string on failure.\n function assertEq(address[] calldata left, address[] calldata right, string calldata error) external pure;\n\n /// Asserts that two arrays of `bytes32` values are equal.\n function assertEq(bytes32[] calldata left, bytes32[] calldata right) external pure;\n\n /// Asserts that two arrays of `bytes32` values are equal and includes error message into revert string on failure.\n function assertEq(bytes32[] calldata left, bytes32[] calldata right, string calldata error) external pure;\n\n /// Asserts that two arrays of `string` values are equal.\n function assertEq(string[] calldata left, string[] calldata right) external pure;\n\n /// Asserts that two arrays of `string` values are equal and includes error message into revert string on failure.\n function assertEq(string[] calldata left, string[] calldata right, string calldata error) external pure;\n\n /// Asserts that two arrays of `bytes` values are equal.\n function assertEq(bytes[] calldata left, bytes[] calldata right) external pure;\n\n /// Asserts that two arrays of `bytes` values are equal and includes error message into revert string on failure.\n function assertEq(bytes[] calldata left, bytes[] calldata right, string calldata error) external pure;\n\n /// Asserts that two `uint256` values are equal and includes error message into revert string on failure.\n function assertEq(uint256 left, uint256 right, string calldata error) external pure;\n\n /// Asserts that two `int256` values are equal.\n function assertEq(int256 left, int256 right) external pure;\n\n /// Asserts that two `int256` values are equal and includes error message into revert string on failure.\n function assertEq(int256 left, int256 right, string calldata error) external pure;\n\n /// Asserts that two `address` values are equal.\n function assertEq(address left, address right) external pure;\n\n /// Asserts that two `address` values are equal and includes error message into revert string on failure.\n function assertEq(address left, address right, string calldata error) external pure;\n\n /// Asserts that two `bytes32` values are equal.\n function assertEq(bytes32 left, bytes32 right) external pure;\n\n /// Asserts that two `bytes32` values are equal and includes error message into revert string on failure.\n function assertEq(bytes32 left, bytes32 right, string calldata error) external pure;\n\n /// Asserts that the given condition is false.\n function assertFalse(bool condition) external pure;\n\n /// Asserts that the given condition is false and includes error message into revert string on failure.\n function assertFalse(bool condition, string calldata error) external pure;\n\n /// Compares two `uint256` values. Expects first value to be greater than or equal to second.\n /// Formats values with decimals in failure message.\n function assertGeDecimal(uint256 left, uint256 right, uint256 decimals) external pure;\n\n /// Compares two `uint256` values. Expects first value to be greater than or equal to second.\n /// Formats values with decimals in failure message. Includes error message into revert string on failure.\n function assertGeDecimal(uint256 left, uint256 right, uint256 decimals, string calldata error) external pure;\n\n /// Compares two `int256` values. Expects first value to be greater than or equal to second.\n /// Formats values with decimals in failure message.\n function assertGeDecimal(int256 left, int256 right, uint256 decimals) external pure;\n\n /// Compares two `int256` values. Expects first value to be greater than or equal to second.\n /// Formats values with decimals in failure message. Includes error message into revert string on failure.\n function assertGeDecimal(int256 left, int256 right, uint256 decimals, string calldata error) external pure;\n\n /// Compares two `uint256` values. Expects first value to be greater than or equal to second.\n function assertGe(uint256 left, uint256 right) external pure;\n\n /// Compares two `uint256` values. Expects first value to be greater than or equal to second.\n /// Includes error message into revert string on failure.\n function assertGe(uint256 left, uint256 right, string calldata error) external pure;\n\n /// Compares two `int256` values. Expects first value to be greater than or equal to second.\n function assertGe(int256 left, int256 right) external pure;\n\n /// Compares two `int256` values. Expects first value to be greater than or equal to second.\n /// Includes error message into revert string on failure.\n function assertGe(int256 left, int256 right, string calldata error) external pure;\n\n /// Compares two `uint256` values. Expects first value to be greater than second.\n /// Formats values with decimals in failure message.\n function assertGtDecimal(uint256 left, uint256 right, uint256 decimals) external pure;\n\n /// Compares two `uint256` values. Expects first value to be greater than second.\n /// Formats values with decimals in failure message. Includes error message into revert string on failure.\n function assertGtDecimal(uint256 left, uint256 right, uint256 decimals, string calldata error) external pure;\n\n /// Compares two `int256` values. Expects first value to be greater than second.\n /// Formats values with decimals in failure message.\n function assertGtDecimal(int256 left, int256 right, uint256 decimals) external pure;\n\n /// Compares two `int256` values. Expects first value to be greater than second.\n /// Formats values with decimals in failure message. Includes error message into revert string on failure.\n function assertGtDecimal(int256 left, int256 right, uint256 decimals, string calldata error) external pure;\n\n /// Compares two `uint256` values. Expects first value to be greater than second.\n function assertGt(uint256 left, uint256 right) external pure;\n\n /// Compares two `uint256` values. Expects first value to be greater than second.\n /// Includes error message into revert string on failure.\n function assertGt(uint256 left, uint256 right, string calldata error) external pure;\n\n /// Compares two `int256` values. Expects first value to be greater than second.\n function assertGt(int256 left, int256 right) external pure;\n\n /// Compares two `int256` values. Expects first value to be greater than second.\n /// Includes error message into revert string on failure.\n function assertGt(int256 left, int256 right, string calldata error) external pure;\n\n /// Compares two `uint256` values. Expects first value to be less than or equal to second.\n /// Formats values with decimals in failure message.\n function assertLeDecimal(uint256 left, uint256 right, uint256 decimals) external pure;\n\n /// Compares two `uint256` values. Expects first value to be less than or equal to second.\n /// Formats values with decimals in failure message. Includes error message into revert string on failure.\n function assertLeDecimal(uint256 left, uint256 right, uint256 decimals, string calldata error) external pure;\n\n /// Compares two `int256` values. Expects first value to be less than or equal to second.\n /// Formats values with decimals in failure message.\n function assertLeDecimal(int256 left, int256 right, uint256 decimals) external pure;\n\n /// Compares two `int256` values. Expects first value to be less than or equal to second.\n /// Formats values with decimals in failure message. Includes error message into revert string on failure.\n function assertLeDecimal(int256 left, int256 right, uint256 decimals, string calldata error) external pure;\n\n /// Compares two `uint256` values. Expects first value to be less than or equal to second.\n function assertLe(uint256 left, uint256 right) external pure;\n\n /// Compares two `uint256` values. Expects first value to be less than or equal to second.\n /// Includes error message into revert string on failure.\n function assertLe(uint256 left, uint256 right, string calldata error) external pure;\n\n /// Compares two `int256` values. Expects first value to be less than or equal to second.\n function assertLe(int256 left, int256 right) external pure;\n\n /// Compares two `int256` values. Expects first value to be less than or equal to second.\n /// Includes error message into revert string on failure.\n function assertLe(int256 left, int256 right, string calldata error) external pure;\n\n /// Compares two `uint256` values. Expects first value to be less than second.\n /// Formats values with decimals in failure message.\n function assertLtDecimal(uint256 left, uint256 right, uint256 decimals) external pure;\n\n /// Compares two `uint256` values. Expects first value to be less than second.\n /// Formats values with decimals in failure message. Includes error message into revert string on failure.\n function assertLtDecimal(uint256 left, uint256 right, uint256 decimals, string calldata error) external pure;\n\n /// Compares two `int256` values. Expects first value to be less than second.\n /// Formats values with decimals in failure message.\n function assertLtDecimal(int256 left, int256 right, uint256 decimals) external pure;\n\n /// Compares two `int256` values. Expects first value to be less than second.\n /// Formats values with decimals in failure message. Includes error message into revert string on failure.\n function assertLtDecimal(int256 left, int256 right, uint256 decimals, string calldata error) external pure;\n\n /// Compares two `uint256` values. Expects first value to be less than second.\n function assertLt(uint256 left, uint256 right) external pure;\n\n /// Compares two `uint256` values. Expects first value to be less than second.\n /// Includes error message into revert string on failure.\n function assertLt(uint256 left, uint256 right, string calldata error) external pure;\n\n /// Compares two `int256` values. Expects first value to be less than second.\n function assertLt(int256 left, int256 right) external pure;\n\n /// Compares two `int256` values. Expects first value to be less than second.\n /// Includes error message into revert string on failure.\n function assertLt(int256 left, int256 right, string calldata error) external pure;\n\n /// Asserts that two `uint256` values are not equal, formatting them with decimals in failure message.\n function assertNotEqDecimal(uint256 left, uint256 right, uint256 decimals) external pure;\n\n /// Asserts that two `uint256` values are not equal, formatting them with decimals in failure message.\n /// Includes error message into revert string on failure.\n function assertNotEqDecimal(uint256 left, uint256 right, uint256 decimals, string calldata error) external pure;\n\n /// Asserts that two `int256` values are not equal, formatting them with decimals in failure message.\n function assertNotEqDecimal(int256 left, int256 right, uint256 decimals) external pure;\n\n /// Asserts that two `int256` values are not equal, formatting them with decimals in failure message.\n /// Includes error message into revert string on failure.\n function assertNotEqDecimal(int256 left, int256 right, uint256 decimals, string calldata error) external pure;\n\n /// Asserts that two `bool` values are not equal.\n function assertNotEq(bool left, bool right) external pure;\n\n /// Asserts that two `bool` values are not equal and includes error message into revert string on failure.\n function assertNotEq(bool left, bool right, string calldata error) external pure;\n\n /// Asserts that two `string` values are not equal.\n function assertNotEq(string calldata left, string calldata right) external pure;\n\n /// Asserts that two `string` values are not equal and includes error message into revert string on failure.\n function assertNotEq(string calldata left, string calldata right, string calldata error) external pure;\n\n /// Asserts that two `bytes` values are not equal.\n function assertNotEq(bytes calldata left, bytes calldata right) external pure;\n\n /// Asserts that two `bytes` values are not equal and includes error message into revert string on failure.\n function assertNotEq(bytes calldata left, bytes calldata right, string calldata error) external pure;\n\n /// Asserts that two arrays of `bool` values are not equal.\n function assertNotEq(bool[] calldata left, bool[] calldata right) external pure;\n\n /// Asserts that two arrays of `bool` values are not equal and includes error message into revert string on failure.\n function assertNotEq(bool[] calldata left, bool[] calldata right, string calldata error) external pure;\n\n /// Asserts that two arrays of `uint256` values are not equal.\n function assertNotEq(uint256[] calldata left, uint256[] calldata right) external pure;\n\n /// Asserts that two arrays of `uint256` values are not equal and includes error message into revert string on failure.\n function assertNotEq(uint256[] calldata left, uint256[] calldata right, string calldata error) external pure;\n\n /// Asserts that two arrays of `int256` values are not equal.\n function assertNotEq(int256[] calldata left, int256[] calldata right) external pure;\n\n /// Asserts that two arrays of `int256` values are not equal and includes error message into revert string on failure.\n function assertNotEq(int256[] calldata left, int256[] calldata right, string calldata error) external pure;\n\n /// Asserts that two `uint256` values are not equal.\n function assertNotEq(uint256 left, uint256 right) external pure;\n\n /// Asserts that two arrays of `address` values are not equal.\n function assertNotEq(address[] calldata left, address[] calldata right) external pure;\n\n /// Asserts that two arrays of `address` values are not equal and includes error message into revert string on failure.\n function assertNotEq(address[] calldata left, address[] calldata right, string calldata error) external pure;\n\n /// Asserts that two arrays of `bytes32` values are not equal.\n function assertNotEq(bytes32[] calldata left, bytes32[] calldata right) external pure;\n\n /// Asserts that two arrays of `bytes32` values are not equal and includes error message into revert string on failure.\n function assertNotEq(bytes32[] calldata left, bytes32[] calldata right, string calldata error) external pure;\n\n /// Asserts that two arrays of `string` values are not equal.\n function assertNotEq(string[] calldata left, string[] calldata right) external pure;\n\n /// Asserts that two arrays of `string` values are not equal and includes error message into revert string on failure.\n function assertNotEq(string[] calldata left, string[] calldata right, string calldata error) external pure;\n\n /// Asserts that two arrays of `bytes` values are not equal.\n function assertNotEq(bytes[] calldata left, bytes[] calldata right) external pure;\n\n /// Asserts that two arrays of `bytes` values are not equal and includes error message into revert string on failure.\n function assertNotEq(bytes[] calldata left, bytes[] calldata right, string calldata error) external pure;\n\n /// Asserts that two `uint256` values are not equal and includes error message into revert string on failure.\n function assertNotEq(uint256 left, uint256 right, string calldata error) external pure;\n\n /// Asserts that two `int256` values are not equal.\n function assertNotEq(int256 left, int256 right) external pure;\n\n /// Asserts that two `int256` values are not equal and includes error message into revert string on failure.\n function assertNotEq(int256 left, int256 right, string calldata error) external pure;\n\n /// Asserts that two `address` values are not equal.\n function assertNotEq(address left, address right) external pure;\n\n /// Asserts that two `address` values are not equal and includes error message into revert string on failure.\n function assertNotEq(address left, address right, string calldata error) external pure;\n\n /// Asserts that two `bytes32` values are not equal.\n function assertNotEq(bytes32 left, bytes32 right) external pure;\n\n /// Asserts that two `bytes32` values are not equal and includes error message into revert string on failure.\n function assertNotEq(bytes32 left, bytes32 right, string calldata error) external pure;\n\n /// Asserts that the given condition is true.\n function assertTrue(bool condition) external pure;\n\n /// Asserts that the given condition is true and includes error message into revert string on failure.\n function assertTrue(bool condition, string calldata error) external pure;\n\n /// If the condition is false, discard this run's fuzz inputs and generate new ones.\n function assume(bool condition) external pure;\n\n /// Discard this run's fuzz inputs and generate new ones if next call reverted.\n function assumeNoRevert() external pure;\n\n /// Discard this run's fuzz inputs and generate new ones if next call reverts with the potential revert parameters.\n function assumeNoRevert(PotentialRevert calldata potentialRevert) external pure;\n\n /// Discard this run's fuzz inputs and generate new ones if next call reverts with the any of the potential revert parameters.\n function assumeNoRevert(PotentialRevert[] calldata potentialReverts) external pure;\n\n /// Writes a breakpoint to jump to in the debugger.\n function breakpoint(string calldata char) external pure;\n\n /// Writes a conditional breakpoint to jump to in the debugger.\n function breakpoint(string calldata char, bool value) external pure;\n\n /// Returns true if the current Foundry version is greater than or equal to the given version.\n /// The given version string must be in the format `major.minor.patch`.\n /// This is equivalent to `foundryVersionCmp(version) >= 0`.\n function foundryVersionAtLeast(string calldata version) external view returns (bool);\n\n /// Compares the current Foundry version with the given version string.\n /// The given version string must be in the format `major.minor.patch`.\n /// Returns:\n /// -1 if current Foundry version is less than the given version\n /// 0 if current Foundry version equals the given version\n /// 1 if current Foundry version is greater than the given version\n /// This result can then be used with a comparison operator against `0`.\n /// For example, to check if the current Foundry version is greater than or equal to `1.0.0`:\n /// `if (foundryVersionCmp(\"1.0.0\") >= 0) { ... }`\n function foundryVersionCmp(string calldata version) external view returns (int256);\n\n /// Returns the Foundry version.\n /// Format: -+..\n /// Sample output: 0.3.0-nightly+3cb96bde9b.1737036656.debug\n /// Note: Build timestamps may vary slightly across platforms due to separate CI jobs.\n /// For reliable version comparisons, use UNIX format (e.g., >= 1700000000)\n /// to compare timestamps while ignoring minor time differences.\n function getFoundryVersion() external view returns (string memory version);\n\n /// Returns the RPC url for the given alias.\n function rpcUrl(string calldata rpcAlias) external view returns (string memory json);\n\n /// Returns all rpc urls and their aliases as structs.\n function rpcUrlStructs() external view returns (Rpc[] memory urls);\n\n /// Returns all rpc urls and their aliases `[alias, url][]`.\n function rpcUrls() external view returns (string[2][] memory urls);\n\n /// Suspends execution of the main thread for `duration` milliseconds.\n function sleep(uint256 duration) external;\n\n // ======== Toml ========\n\n /// Checks if `key` exists in a TOML table.\n function keyExistsToml(string calldata toml, string calldata key) external view returns (bool);\n\n /// Parses a string of TOML data at `key` and coerces it to `address`.\n function parseTomlAddress(string calldata toml, string calldata key) external pure returns (address);\n\n /// Parses a string of TOML data at `key` and coerces it to `address[]`.\n function parseTomlAddressArray(string calldata toml, string calldata key)\n external\n pure\n returns (address[] memory);\n\n /// Parses a string of TOML data at `key` and coerces it to `bool`.\n function parseTomlBool(string calldata toml, string calldata key) external pure returns (bool);\n\n /// Parses a string of TOML data at `key` and coerces it to `bool[]`.\n function parseTomlBoolArray(string calldata toml, string calldata key) external pure returns (bool[] memory);\n\n /// Parses a string of TOML data at `key` and coerces it to `bytes`.\n function parseTomlBytes(string calldata toml, string calldata key) external pure returns (bytes memory);\n\n /// Parses a string of TOML data at `key` and coerces it to `bytes32`.\n function parseTomlBytes32(string calldata toml, string calldata key) external pure returns (bytes32);\n\n /// Parses a string of TOML data at `key` and coerces it to `bytes32[]`.\n function parseTomlBytes32Array(string calldata toml, string calldata key)\n external\n pure\n returns (bytes32[] memory);\n\n /// Parses a string of TOML data at `key` and coerces it to `bytes[]`.\n function parseTomlBytesArray(string calldata toml, string calldata key) external pure returns (bytes[] memory);\n\n /// Parses a string of TOML data at `key` and coerces it to `int256`.\n function parseTomlInt(string calldata toml, string calldata key) external pure returns (int256);\n\n /// Parses a string of TOML data at `key` and coerces it to `int256[]`.\n function parseTomlIntArray(string calldata toml, string calldata key) external pure returns (int256[] memory);\n\n /// Returns an array of all the keys in a TOML table.\n function parseTomlKeys(string calldata toml, string calldata key) external pure returns (string[] memory keys);\n\n /// Parses a string of TOML data at `key` and coerces it to `string`.\n function parseTomlString(string calldata toml, string calldata key) external pure returns (string memory);\n\n /// Parses a string of TOML data at `key` and coerces it to `string[]`.\n function parseTomlStringArray(string calldata toml, string calldata key) external pure returns (string[] memory);\n\n /// Parses a string of TOML data at `key` and coerces it to type array corresponding to `typeDescription`.\n function parseTomlTypeArray(string calldata toml, string calldata key, string calldata typeDescription)\n external\n pure\n returns (bytes memory);\n\n /// Parses a string of TOML data and coerces it to type corresponding to `typeDescription`.\n function parseTomlType(string calldata toml, string calldata typeDescription)\n external\n pure\n returns (bytes memory);\n\n /// Parses a string of TOML data at `key` and coerces it to type corresponding to `typeDescription`.\n function parseTomlType(string calldata toml, string calldata key, string calldata typeDescription)\n external\n pure\n returns (bytes memory);\n\n /// Parses a string of TOML data at `key` and coerces it to `uint256`.\n function parseTomlUint(string calldata toml, string calldata key) external pure returns (uint256);\n\n /// Parses a string of TOML data at `key` and coerces it to `uint256[]`.\n function parseTomlUintArray(string calldata toml, string calldata key) external pure returns (uint256[] memory);\n\n /// ABI-encodes a TOML table.\n function parseToml(string calldata toml) external pure returns (bytes memory abiEncodedData);\n\n /// ABI-encodes a TOML table at `key`.\n function parseToml(string calldata toml, string calldata key) external pure returns (bytes memory abiEncodedData);\n\n /// Takes serialized JSON, converts to TOML and write a serialized TOML to a file.\n function writeToml(string calldata json, string calldata path) external;\n\n /// Takes serialized JSON, converts to TOML and write a serialized TOML table to an **existing** TOML file, replacing a value with key = \n /// This is useful to replace a specific value of a TOML file, without having to parse the entire thing.\n function writeToml(string calldata json, string calldata path, string calldata valueKey) external;\n\n // ======== Utilities ========\n\n /// Compute the address of a contract created with CREATE2 using the given CREATE2 deployer.\n function computeCreate2Address(bytes32 salt, bytes32 initCodeHash, address deployer)\n external\n pure\n returns (address);\n\n /// Compute the address of a contract created with CREATE2 using the default CREATE2 deployer.\n function computeCreate2Address(bytes32 salt, bytes32 initCodeHash) external pure returns (address);\n\n /// Compute the address a contract will be deployed at for a given deployer address and nonce.\n function computeCreateAddress(address deployer, uint256 nonce) external pure returns (address);\n\n /// Utility cheatcode to copy storage of `from` contract to another `to` contract.\n function copyStorage(address from, address to) external;\n\n /// Returns ENS namehash for provided string.\n function ensNamehash(string calldata name) external pure returns (bytes32);\n\n /// Gets the label for the specified address.\n function getLabel(address account) external view returns (string memory currentLabel);\n\n /// Labels an address in call traces.\n function label(address account, string calldata newLabel) external;\n\n /// Pauses collection of call traces. Useful in cases when you want to skip tracing of\n /// complex calls which are not useful for debugging.\n function pauseTracing() external view;\n\n /// Returns a random `address`.\n function randomAddress() external returns (address);\n\n /// Returns a random `bool`.\n function randomBool() external view returns (bool);\n\n /// Returns a random byte array value of the given length.\n function randomBytes(uint256 len) external view returns (bytes memory);\n\n /// Returns a random fixed-size byte array of length 4.\n function randomBytes4() external view returns (bytes4);\n\n /// Returns a random fixed-size byte array of length 8.\n function randomBytes8() external view returns (bytes8);\n\n /// Returns a random `int256` value.\n function randomInt() external view returns (int256);\n\n /// Returns a random `int256` value of given bits.\n function randomInt(uint256 bits) external view returns (int256);\n\n /// Returns a random uint256 value.\n function randomUint() external returns (uint256);\n\n /// Returns random uint256 value between the provided range (=min..=max).\n function randomUint(uint256 min, uint256 max) external returns (uint256);\n\n /// Returns a random `uint256` value of given bits.\n function randomUint(uint256 bits) external view returns (uint256);\n\n /// Unpauses collection of call traces.\n function resumeTracing() external view;\n\n /// Utility cheatcode to set arbitrary storage for given target address.\n function setArbitraryStorage(address target) external;\n\n /// Encodes a `bytes` value to a base64url string.\n function toBase64URL(bytes calldata data) external pure returns (string memory);\n\n /// Encodes a `string` value to a base64url string.\n function toBase64URL(string calldata data) external pure returns (string memory);\n\n /// Encodes a `bytes` value to a base64 string.\n function toBase64(bytes calldata data) external pure returns (string memory);\n\n /// Encodes a `string` value to a base64 string.\n function toBase64(string calldata data) external pure returns (string memory);\n}\n\n/// The `Vm` interface does allow manipulation of the EVM state. These are all intended to be used\n/// in tests, but it is not recommended to use these cheats in scripts.\ninterface Vm is VmSafe {\n // ======== EVM ========\n\n /// Utility cheatcode to set an EIP-2930 access list for all subsequent transactions.\n function accessList(AccessListItem[] calldata access) external;\n\n /// Returns the identifier of the currently active fork. Reverts if no fork is currently active.\n function activeFork() external view returns (uint256 forkId);\n\n /// In forking mode, explicitly grant the given address cheatcode access.\n function allowCheatcodes(address account) external;\n\n /// Sets `block.blobbasefee`\n function blobBaseFee(uint256 newBlobBaseFee) external;\n\n /// Sets the blobhashes in the transaction.\n /// Not available on EVM versions before Cancun.\n /// If used on unsupported EVM versions it will revert.\n function blobhashes(bytes32[] calldata hashes) external;\n\n /// Sets `block.chainid`.\n function chainId(uint256 newChainId) external;\n\n /// Clears all mocked calls.\n function clearMockedCalls() external;\n\n /// Clones a source account code, state, balance and nonce to a target account and updates in-memory EVM state.\n function cloneAccount(address source, address target) external;\n\n /// Sets `block.coinbase`.\n function coinbase(address newCoinbase) external;\n\n /// Marks the slots of an account and the account address as cold.\n function cool(address target) external;\n\n /// Utility cheatcode to mark specific storage slot as cold, simulating no prior read.\n function coolSlot(address target, bytes32 slot) external;\n\n /// Creates a new fork with the given endpoint and the _latest_ block and returns the identifier of the fork.\n function createFork(string calldata urlOrAlias) external returns (uint256 forkId);\n\n /// Creates a new fork with the given endpoint and block and returns the identifier of the fork.\n function createFork(string calldata urlOrAlias, uint256 blockNumber) external returns (uint256 forkId);\n\n /// Creates a new fork with the given endpoint and at the block the given transaction was mined in,\n /// replays all transaction mined in the block before the transaction, and returns the identifier of the fork.\n function createFork(string calldata urlOrAlias, bytes32 txHash) external returns (uint256 forkId);\n\n /// Creates and also selects a new fork with the given endpoint and the latest block and returns the identifier of the fork.\n function createSelectFork(string calldata urlOrAlias) external returns (uint256 forkId);\n\n /// Creates and also selects a new fork with the given endpoint and block and returns the identifier of the fork.\n function createSelectFork(string calldata urlOrAlias, uint256 blockNumber) external returns (uint256 forkId);\n\n /// Creates and also selects new fork with the given endpoint and at the block the given transaction was mined in,\n /// replays all transaction mined in the block before the transaction, returns the identifier of the fork.\n function createSelectFork(string calldata urlOrAlias, bytes32 txHash) external returns (uint256 forkId);\n\n /// Sets an address' balance.\n function deal(address account, uint256 newBalance) external;\n\n /// Removes the snapshot with the given ID created by `snapshot`.\n /// Takes the snapshot ID to delete.\n /// Returns `true` if the snapshot was successfully deleted.\n /// Returns `false` if the snapshot does not exist.\n function deleteStateSnapshot(uint256 snapshotId) external returns (bool success);\n\n /// Removes _all_ snapshots previously created by `snapshot`.\n function deleteStateSnapshots() external;\n\n /// Sets `block.difficulty`.\n /// Not available on EVM versions from Paris onwards. Use `prevrandao` instead.\n /// Reverts if used on unsupported EVM versions.\n function difficulty(uint256 newDifficulty) external;\n\n /// Dump a genesis JSON file's `allocs` to disk.\n function dumpState(string calldata pathToStateJson) external;\n\n /// Sets an address' code.\n function etch(address target, bytes calldata newRuntimeBytecode) external;\n\n /// Sets `block.basefee`.\n function fee(uint256 newBasefee) external;\n\n /// Gets the blockhashes from the current transaction.\n /// Not available on EVM versions before Cancun.\n /// If used on unsupported EVM versions it will revert.\n function getBlobhashes() external view returns (bytes32[] memory hashes);\n\n /// Returns true if the account is marked as persistent.\n function isPersistent(address account) external view returns (bool persistent);\n\n /// Load a genesis JSON file's `allocs` into the in-memory EVM state.\n function loadAllocs(string calldata pathToAllocsJson) external;\n\n /// Marks that the account(s) should use persistent storage across fork swaps in a multifork setup\n /// Meaning, changes made to the state of this account will be kept when switching forks.\n function makePersistent(address account) external;\n\n /// See `makePersistent(address)`.\n function makePersistent(address account0, address account1) external;\n\n /// See `makePersistent(address)`.\n function makePersistent(address account0, address account1, address account2) external;\n\n /// See `makePersistent(address)`.\n function makePersistent(address[] calldata accounts) external;\n\n /// Reverts a call to an address with specified revert data.\n function mockCallRevert(address callee, bytes calldata data, bytes calldata revertData) external;\n\n /// Reverts a call to an address with a specific `msg.value`, with specified revert data.\n function mockCallRevert(address callee, uint256 msgValue, bytes calldata data, bytes calldata revertData)\n external;\n\n /// Reverts a call to an address with specified revert data.\n /// Overload to pass the function selector directly `token.approve.selector` instead of `abi.encodeWithSelector(token.approve.selector)`.\n function mockCallRevert(address callee, bytes4 data, bytes calldata revertData) external;\n\n /// Reverts a call to an address with a specific `msg.value`, with specified revert data.\n /// Overload to pass the function selector directly `token.approve.selector` instead of `abi.encodeWithSelector(token.approve.selector)`.\n function mockCallRevert(address callee, uint256 msgValue, bytes4 data, bytes calldata revertData) external;\n\n /// Mocks a call to an address, returning specified data.\n /// Calldata can either be strict or a partial match, e.g. if you only\n /// pass a Solidity selector to the expected calldata, then the entire Solidity\n /// function will be mocked.\n function mockCall(address callee, bytes calldata data, bytes calldata returnData) external;\n\n /// Mocks a call to an address with a specific `msg.value`, returning specified data.\n /// Calldata match takes precedence over `msg.value` in case of ambiguity.\n function mockCall(address callee, uint256 msgValue, bytes calldata data, bytes calldata returnData) external;\n\n /// Mocks a call to an address, returning specified data.\n /// Calldata can either be strict or a partial match, e.g. if you only\n /// pass a Solidity selector to the expected calldata, then the entire Solidity\n /// function will be mocked.\n /// Overload to pass the function selector directly `token.approve.selector` instead of `abi.encodeWithSelector(token.approve.selector)`.\n function mockCall(address callee, bytes4 data, bytes calldata returnData) external;\n\n /// Mocks a call to an address with a specific `msg.value`, returning specified data.\n /// Calldata match takes precedence over `msg.value` in case of ambiguity.\n /// Overload to pass the function selector directly `token.approve.selector` instead of `abi.encodeWithSelector(token.approve.selector)`.\n function mockCall(address callee, uint256 msgValue, bytes4 data, bytes calldata returnData) external;\n\n /// Mocks multiple calls to an address, returning specified data for each call.\n function mockCalls(address callee, bytes calldata data, bytes[] calldata returnData) external;\n\n /// Mocks multiple calls to an address with a specific `msg.value`, returning specified data for each call.\n function mockCalls(address callee, uint256 msgValue, bytes calldata data, bytes[] calldata returnData) external;\n\n /// Whenever a call is made to `callee` with calldata `data`, this cheatcode instead calls\n /// `target` with the same calldata. This functionality is similar to a delegate call made to\n /// `target` contract from `callee`.\n /// Can be used to substitute a call to a function with another implementation that captures\n /// the primary logic of the original function but is easier to reason about.\n /// If calldata is not a strict match then partial match by selector is attempted.\n function mockFunction(address callee, address target, bytes calldata data) external;\n\n /// Utility cheatcode to remove any EIP-2930 access list set by `accessList` cheatcode.\n function noAccessList() external;\n\n /// Sets the *next* call's `msg.sender` to be the input address.\n function prank(address msgSender) external;\n\n /// Sets the *next* call's `msg.sender` to be the input address, and the `tx.origin` to be the second input.\n function prank(address msgSender, address txOrigin) external;\n\n /// Sets the *next* delegate call's `msg.sender` to be the input address.\n function prank(address msgSender, bool delegateCall) external;\n\n /// Sets the *next* delegate call's `msg.sender` to be the input address, and the `tx.origin` to be the second input.\n function prank(address msgSender, address txOrigin, bool delegateCall) external;\n\n /// Sets `block.prevrandao`.\n /// Not available on EVM versions before Paris. Use `difficulty` instead.\n /// If used on unsupported EVM versions it will revert.\n function prevrandao(bytes32 newPrevrandao) external;\n\n /// Sets `block.prevrandao`.\n /// Not available on EVM versions before Paris. Use `difficulty` instead.\n /// If used on unsupported EVM versions it will revert.\n function prevrandao(uint256 newPrevrandao) external;\n\n /// Reads the current `msg.sender` and `tx.origin` from state and reports if there is any active caller modification.\n function readCallers() external returns (CallerMode callerMode, address msgSender, address txOrigin);\n\n /// Resets the nonce of an account to 0 for EOAs and 1 for contract accounts.\n function resetNonce(address account) external;\n\n /// Revert the state of the EVM to a previous snapshot\n /// Takes the snapshot ID to revert to.\n /// Returns `true` if the snapshot was successfully reverted.\n /// Returns `false` if the snapshot does not exist.\n /// **Note:** This does not automatically delete the snapshot. To delete the snapshot use `deleteStateSnapshot`.\n function revertToState(uint256 snapshotId) external returns (bool success);\n\n /// Revert the state of the EVM to a previous snapshot and automatically deletes the snapshots\n /// Takes the snapshot ID to revert to.\n /// Returns `true` if the snapshot was successfully reverted and deleted.\n /// Returns `false` if the snapshot does not exist.\n function revertToStateAndDelete(uint256 snapshotId) external returns (bool success);\n\n /// Revokes persistent status from the address, previously added via `makePersistent`.\n function revokePersistent(address account) external;\n\n /// See `revokePersistent(address)`.\n function revokePersistent(address[] calldata accounts) external;\n\n /// Sets `block.height`.\n function roll(uint256 newHeight) external;\n\n /// Updates the currently active fork to given block number\n /// This is similar to `roll` but for the currently active fork.\n function rollFork(uint256 blockNumber) external;\n\n /// Updates the currently active fork to given transaction. This will `rollFork` with the number\n /// of the block the transaction was mined in and replays all transaction mined before it in the block.\n function rollFork(bytes32 txHash) external;\n\n /// Updates the given fork to given block number.\n function rollFork(uint256 forkId, uint256 blockNumber) external;\n\n /// Updates the given fork to block number of the given transaction and replays all transaction mined before it in the block.\n function rollFork(uint256 forkId, bytes32 txHash) external;\n\n /// Takes a fork identifier created by `createFork` and sets the corresponding forked state as active.\n function selectFork(uint256 forkId) external;\n\n /// Set blockhash for the current block.\n /// It only sets the blockhash for blocks where `block.number - 256 <= number < block.number`.\n function setBlockhash(uint256 blockNumber, bytes32 blockHash) external;\n\n /// Sets the nonce of an account. Must be higher than the current nonce of the account.\n function setNonce(address account, uint64 newNonce) external;\n\n /// Sets the nonce of an account to an arbitrary value.\n function setNonceUnsafe(address account, uint64 newNonce) external;\n\n /// Snapshot capture the gas usage of the last call by name from the callee perspective.\n function snapshotGasLastCall(string calldata name) external returns (uint256 gasUsed);\n\n /// Snapshot capture the gas usage of the last call by name in a group from the callee perspective.\n function snapshotGasLastCall(string calldata group, string calldata name) external returns (uint256 gasUsed);\n\n /// Snapshot the current state of the evm.\n /// Returns the ID of the snapshot that was created.\n /// To revert a snapshot use `revertToState`.\n function snapshotState() external returns (uint256 snapshotId);\n\n /// Snapshot capture an arbitrary numerical value by name.\n /// The group name is derived from the contract name.\n function snapshotValue(string calldata name, uint256 value) external;\n\n /// Snapshot capture an arbitrary numerical value by name in a group.\n function snapshotValue(string calldata group, string calldata name, uint256 value) external;\n\n /// Sets all subsequent calls' `msg.sender` to be the input address until `stopPrank` is called.\n function startPrank(address msgSender) external;\n\n /// Sets all subsequent calls' `msg.sender` to be the input address until `stopPrank` is called, and the `tx.origin` to be the second input.\n function startPrank(address msgSender, address txOrigin) external;\n\n /// Sets all subsequent delegate calls' `msg.sender` to be the input address until `stopPrank` is called.\n function startPrank(address msgSender, bool delegateCall) external;\n\n /// Sets all subsequent delegate calls' `msg.sender` to be the input address until `stopPrank` is called, and the `tx.origin` to be the second input.\n function startPrank(address msgSender, address txOrigin, bool delegateCall) external;\n\n /// Start a snapshot capture of the current gas usage by name.\n /// The group name is derived from the contract name.\n function startSnapshotGas(string calldata name) external;\n\n /// Start a snapshot capture of the current gas usage by name in a group.\n function startSnapshotGas(string calldata group, string calldata name) external;\n\n /// Resets subsequent calls' `msg.sender` to be `address(this)`.\n function stopPrank() external;\n\n /// Stop the snapshot capture of the current gas by latest snapshot name, capturing the gas used since the start.\n function stopSnapshotGas() external returns (uint256 gasUsed);\n\n /// Stop the snapshot capture of the current gas usage by name, capturing the gas used since the start.\n /// The group name is derived from the contract name.\n function stopSnapshotGas(string calldata name) external returns (uint256 gasUsed);\n\n /// Stop the snapshot capture of the current gas usage by name in a group, capturing the gas used since the start.\n function stopSnapshotGas(string calldata group, string calldata name) external returns (uint256 gasUsed);\n\n /// Stores a value to an address' storage slot.\n function store(address target, bytes32 slot, bytes32 value) external;\n\n /// Fetches the given transaction from the active fork and executes it on the current state.\n function transact(bytes32 txHash) external;\n\n /// Fetches the given transaction from the given fork and executes it on the current state.\n function transact(uint256 forkId, bytes32 txHash) external;\n\n /// Sets `tx.gasprice`.\n function txGasPrice(uint256 newGasPrice) external;\n\n /// Utility cheatcode to mark specific storage slot as warm, simulating a prior read.\n function warmSlot(address target, bytes32 slot) external;\n\n /// Sets `block.timestamp`.\n function warp(uint256 newTimestamp) external;\n\n /// `deleteSnapshot` is being deprecated in favor of `deleteStateSnapshot`. It will be removed in future versions.\n function deleteSnapshot(uint256 snapshotId) external returns (bool success);\n\n /// `deleteSnapshots` is being deprecated in favor of `deleteStateSnapshots`. It will be removed in future versions.\n function deleteSnapshots() external;\n\n /// `revertToAndDelete` is being deprecated in favor of `revertToStateAndDelete`. It will be removed in future versions.\n function revertToAndDelete(uint256 snapshotId) external returns (bool success);\n\n /// `revertTo` is being deprecated in favor of `revertToState`. It will be removed in future versions.\n function revertTo(uint256 snapshotId) external returns (bool success);\n\n /// `snapshot` is being deprecated in favor of `snapshotState`. It will be removed in future versions.\n function snapshot() external returns (uint256 snapshotId);\n\n // ======== Testing ========\n\n /// Expect a call to an address with the specified `msg.value` and calldata, and a *minimum* amount of gas.\n function expectCallMinGas(address callee, uint256 msgValue, uint64 minGas, bytes calldata data) external;\n\n /// Expect given number of calls to an address with the specified `msg.value` and calldata, and a *minimum* amount of gas.\n function expectCallMinGas(address callee, uint256 msgValue, uint64 minGas, bytes calldata data, uint64 count)\n external;\n\n /// Expects a call to an address with the specified calldata.\n /// Calldata can either be a strict or a partial match.\n function expectCall(address callee, bytes calldata data) external;\n\n /// Expects given number of calls to an address with the specified calldata.\n function expectCall(address callee, bytes calldata data, uint64 count) external;\n\n /// Expects a call to an address with the specified `msg.value` and calldata.\n function expectCall(address callee, uint256 msgValue, bytes calldata data) external;\n\n /// Expects given number of calls to an address with the specified `msg.value` and calldata.\n function expectCall(address callee, uint256 msgValue, bytes calldata data, uint64 count) external;\n\n /// Expect a call to an address with the specified `msg.value`, gas, and calldata.\n function expectCall(address callee, uint256 msgValue, uint64 gas, bytes calldata data) external;\n\n /// Expects given number of calls to an address with the specified `msg.value`, gas, and calldata.\n function expectCall(address callee, uint256 msgValue, uint64 gas, bytes calldata data, uint64 count) external;\n\n /// Expects the deployment of the specified bytecode by the specified address using the CREATE opcode\n function expectCreate(bytes calldata bytecode, address deployer) external;\n\n /// Expects the deployment of the specified bytecode by the specified address using the CREATE2 opcode\n function expectCreate2(bytes calldata bytecode, address deployer) external;\n\n /// Prepare an expected anonymous log with (bool checkTopic1, bool checkTopic2, bool checkTopic3, bool checkData.).\n /// Call this function, then emit an anonymous event, then call a function. Internally after the call, we check if\n /// logs were emitted in the expected order with the expected topics and data (as specified by the booleans).\n function expectEmitAnonymous(bool checkTopic0, bool checkTopic1, bool checkTopic2, bool checkTopic3, bool checkData)\n external;\n\n /// Same as the previous method, but also checks supplied address against emitting contract.\n function expectEmitAnonymous(\n bool checkTopic0,\n bool checkTopic1,\n bool checkTopic2,\n bool checkTopic3,\n bool checkData,\n address emitter\n ) external;\n\n /// Prepare an expected anonymous log with all topic and data checks enabled.\n /// Call this function, then emit an anonymous event, then call a function. Internally after the call, we check if\n /// logs were emitted in the expected order with the expected topics and data.\n function expectEmitAnonymous() external;\n\n /// Same as the previous method, but also checks supplied address against emitting contract.\n function expectEmitAnonymous(address emitter) external;\n\n /// Prepare an expected log with (bool checkTopic1, bool checkTopic2, bool checkTopic3, bool checkData.).\n /// Call this function, then emit an event, then call a function. Internally after the call, we check if\n /// logs were emitted in the expected order with the expected topics and data (as specified by the booleans).\n function expectEmit(bool checkTopic1, bool checkTopic2, bool checkTopic3, bool checkData) external;\n\n /// Same as the previous method, but also checks supplied address against emitting contract.\n function expectEmit(bool checkTopic1, bool checkTopic2, bool checkTopic3, bool checkData, address emitter)\n external;\n\n /// Prepare an expected log with all topic and data checks enabled.\n /// Call this function, then emit an event, then call a function. Internally after the call, we check if\n /// logs were emitted in the expected order with the expected topics and data.\n function expectEmit() external;\n\n /// Same as the previous method, but also checks supplied address against emitting contract.\n function expectEmit(address emitter) external;\n\n /// Expect a given number of logs with the provided topics.\n function expectEmit(bool checkTopic1, bool checkTopic2, bool checkTopic3, bool checkData, uint64 count) external;\n\n /// Expect a given number of logs from a specific emitter with the provided topics.\n function expectEmit(\n bool checkTopic1,\n bool checkTopic2,\n bool checkTopic3,\n bool checkData,\n address emitter,\n uint64 count\n ) external;\n\n /// Expect a given number of logs with all topic and data checks enabled.\n function expectEmit(uint64 count) external;\n\n /// Expect a given number of logs from a specific emitter with all topic and data checks enabled.\n function expectEmit(address emitter, uint64 count) external;\n\n /// Expects an error on next call that starts with the revert data.\n function expectPartialRevert(bytes4 revertData) external;\n\n /// Expects an error on next call to reverter address, that starts with the revert data.\n function expectPartialRevert(bytes4 revertData, address reverter) external;\n\n /// Expects an error on next call with any revert data.\n function expectRevert() external;\n\n /// Expects an error on next call that exactly matches the revert data.\n function expectRevert(bytes4 revertData) external;\n\n /// Expects a `count` number of reverts from the upcoming calls from the reverter address that match the revert data.\n function expectRevert(bytes4 revertData, address reverter, uint64 count) external;\n\n /// Expects a `count` number of reverts from the upcoming calls from the reverter address that exactly match the revert data.\n function expectRevert(bytes calldata revertData, address reverter, uint64 count) external;\n\n /// Expects an error on next call that exactly matches the revert data.\n function expectRevert(bytes calldata revertData) external;\n\n /// Expects an error with any revert data on next call to reverter address.\n function expectRevert(address reverter) external;\n\n /// Expects an error from reverter address on next call, with any revert data.\n function expectRevert(bytes4 revertData, address reverter) external;\n\n /// Expects an error from reverter address on next call, that exactly matches the revert data.\n function expectRevert(bytes calldata revertData, address reverter) external;\n\n /// Expects a `count` number of reverts from the upcoming calls with any revert data or reverter.\n function expectRevert(uint64 count) external;\n\n /// Expects a `count` number of reverts from the upcoming calls that match the revert data.\n function expectRevert(bytes4 revertData, uint64 count) external;\n\n /// Expects a `count` number of reverts from the upcoming calls that exactly match the revert data.\n function expectRevert(bytes calldata revertData, uint64 count) external;\n\n /// Expects a `count` number of reverts from the upcoming calls from the reverter address.\n function expectRevert(address reverter, uint64 count) external;\n\n /// Only allows memory writes to offsets [0x00, 0x60) ∪ [min, max) in the current subcontext. If any other\n /// memory is written to, the test will fail. Can be called multiple times to add more ranges to the set.\n function expectSafeMemory(uint64 min, uint64 max) external;\n\n /// Only allows memory writes to offsets [0x00, 0x60) ∪ [min, max) in the next created subcontext.\n /// If any other memory is written to, the test will fail. Can be called multiple times to add more ranges\n /// to the set.\n function expectSafeMemoryCall(uint64 min, uint64 max) external;\n\n /// Marks a test as skipped. Must be called at the top level of a test.\n function skip(bool skipTest) external;\n\n /// Marks a test as skipped with a reason. Must be called at the top level of a test.\n function skip(bool skipTest, string calldata reason) external;\n\n /// Stops all safe memory expectation in the current subcontext.\n function stopExpectSafeMemory() external;\n}\n","license":"MIT OR Apache-2.0"},"lib/forge-std/src/console.sol":{"keccak256":"0x4bbf47eb762cef93729d6ef15e78789957147039b113e5d4df48e3d3fd16d0f5","urls":[],"content":"// SPDX-License-Identifier: MIT\npragma solidity >=0.4.22 <0.9.0;\n\nlibrary console {\n address constant CONSOLE_ADDRESS =\n 0x000000000000000000636F6e736F6c652e6c6f67;\n\n function _sendLogPayloadImplementation(bytes memory payload) internal view {\n address consoleAddress = CONSOLE_ADDRESS;\n /// @solidity memory-safe-assembly\n assembly {\n pop(\n staticcall(\n gas(),\n consoleAddress,\n add(payload, 32),\n mload(payload),\n 0,\n 0\n )\n )\n }\n }\n\n function _castToPure(\n function(bytes memory) internal view fnIn\n ) internal pure returns (function(bytes memory) pure fnOut) {\n assembly {\n fnOut := fnIn\n }\n }\n\n function _sendLogPayload(bytes memory payload) internal pure {\n _castToPure(_sendLogPayloadImplementation)(payload);\n }\n\n function log() internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log()\"));\n }\n\n function logInt(int256 p0) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(int256)\", p0));\n }\n\n function logUint(uint256 p0) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256)\", p0));\n }\n\n function logString(string memory p0) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string)\", p0));\n }\n\n function logBool(bool p0) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool)\", p0));\n }\n\n function logAddress(address p0) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address)\", p0));\n }\n\n function logBytes(bytes memory p0) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bytes)\", p0));\n }\n\n function logBytes1(bytes1 p0) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bytes1)\", p0));\n }\n\n function logBytes2(bytes2 p0) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bytes2)\", p0));\n }\n\n function logBytes3(bytes3 p0) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bytes3)\", p0));\n }\n\n function logBytes4(bytes4 p0) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bytes4)\", p0));\n }\n\n function logBytes5(bytes5 p0) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bytes5)\", p0));\n }\n\n function logBytes6(bytes6 p0) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bytes6)\", p0));\n }\n\n function logBytes7(bytes7 p0) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bytes7)\", p0));\n }\n\n function logBytes8(bytes8 p0) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bytes8)\", p0));\n }\n\n function logBytes9(bytes9 p0) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bytes9)\", p0));\n }\n\n function logBytes10(bytes10 p0) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bytes10)\", p0));\n }\n\n function logBytes11(bytes11 p0) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bytes11)\", p0));\n }\n\n function logBytes12(bytes12 p0) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bytes12)\", p0));\n }\n\n function logBytes13(bytes13 p0) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bytes13)\", p0));\n }\n\n function logBytes14(bytes14 p0) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bytes14)\", p0));\n }\n\n function logBytes15(bytes15 p0) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bytes15)\", p0));\n }\n\n function logBytes16(bytes16 p0) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bytes16)\", p0));\n }\n\n function logBytes17(bytes17 p0) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bytes17)\", p0));\n }\n\n function logBytes18(bytes18 p0) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bytes18)\", p0));\n }\n\n function logBytes19(bytes19 p0) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bytes19)\", p0));\n }\n\n function logBytes20(bytes20 p0) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bytes20)\", p0));\n }\n\n function logBytes21(bytes21 p0) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bytes21)\", p0));\n }\n\n function logBytes22(bytes22 p0) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bytes22)\", p0));\n }\n\n function logBytes23(bytes23 p0) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bytes23)\", p0));\n }\n\n function logBytes24(bytes24 p0) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bytes24)\", p0));\n }\n\n function logBytes25(bytes25 p0) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bytes25)\", p0));\n }\n\n function logBytes26(bytes26 p0) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bytes26)\", p0));\n }\n\n function logBytes27(bytes27 p0) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bytes27)\", p0));\n }\n\n function logBytes28(bytes28 p0) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bytes28)\", p0));\n }\n\n function logBytes29(bytes29 p0) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bytes29)\", p0));\n }\n\n function logBytes30(bytes30 p0) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bytes30)\", p0));\n }\n\n function logBytes31(bytes31 p0) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bytes31)\", p0));\n }\n\n function logBytes32(bytes32 p0) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bytes32)\", p0));\n }\n\n function log(uint256 p0) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256)\", p0));\n }\n\n function log(int256 p0) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(int256)\", p0));\n }\n\n function log(string memory p0) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string)\", p0));\n }\n\n function log(bool p0) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool)\", p0));\n }\n\n function log(address p0) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address)\", p0));\n }\n\n function log(uint256 p0, uint256 p1) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,uint256)\", p0, p1));\n }\n\n function log(uint256 p0, string memory p1) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,string)\", p0, p1));\n }\n\n function log(uint256 p0, bool p1) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,bool)\", p0, p1));\n }\n\n function log(uint256 p0, address p1) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,address)\", p0, p1));\n }\n\n function log(string memory p0, uint256 p1) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,uint256)\", p0, p1));\n }\n\n function log(string memory p0, int256 p1) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,int256)\", p0, p1));\n }\n\n function log(string memory p0, string memory p1) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,string)\", p0, p1));\n }\n\n function log(string memory p0, bool p1) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,bool)\", p0, p1));\n }\n\n function log(string memory p0, address p1) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,address)\", p0, p1));\n }\n\n function log(bool p0, uint256 p1) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,uint256)\", p0, p1));\n }\n\n function log(bool p0, string memory p1) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,string)\", p0, p1));\n }\n\n function log(bool p0, bool p1) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,bool)\", p0, p1));\n }\n\n function log(bool p0, address p1) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,address)\", p0, p1));\n }\n\n function log(address p0, uint256 p1) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,uint256)\", p0, p1));\n }\n\n function log(address p0, string memory p1) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,string)\", p0, p1));\n }\n\n function log(address p0, bool p1) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,bool)\", p0, p1));\n }\n\n function log(address p0, address p1) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,address)\", p0, p1));\n }\n\n function log(uint256 p0, uint256 p1, uint256 p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,uint256,uint256)\", p0, p1, p2));\n }\n\n function log(uint256 p0, uint256 p1, string memory p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,uint256,string)\", p0, p1, p2));\n }\n\n function log(uint256 p0, uint256 p1, bool p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,uint256,bool)\", p0, p1, p2));\n }\n\n function log(uint256 p0, uint256 p1, address p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,uint256,address)\", p0, p1, p2));\n }\n\n function log(uint256 p0, string memory p1, uint256 p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,string,uint256)\", p0, p1, p2));\n }\n\n function log(uint256 p0, string memory p1, string memory p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,string,string)\", p0, p1, p2));\n }\n\n function log(uint256 p0, string memory p1, bool p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,string,bool)\", p0, p1, p2));\n }\n\n function log(uint256 p0, string memory p1, address p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,string,address)\", p0, p1, p2));\n }\n\n function log(uint256 p0, bool p1, uint256 p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,bool,uint256)\", p0, p1, p2));\n }\n\n function log(uint256 p0, bool p1, string memory p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,bool,string)\", p0, p1, p2));\n }\n\n function log(uint256 p0, bool p1, bool p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,bool,bool)\", p0, p1, p2));\n }\n\n function log(uint256 p0, bool p1, address p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,bool,address)\", p0, p1, p2));\n }\n\n function log(uint256 p0, address p1, uint256 p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,address,uint256)\", p0, p1, p2));\n }\n\n function log(uint256 p0, address p1, string memory p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,address,string)\", p0, p1, p2));\n }\n\n function log(uint256 p0, address p1, bool p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,address,bool)\", p0, p1, p2));\n }\n\n function log(uint256 p0, address p1, address p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,address,address)\", p0, p1, p2));\n }\n\n function log(string memory p0, uint256 p1, uint256 p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,uint256,uint256)\", p0, p1, p2));\n }\n\n function log(string memory p0, uint256 p1, string memory p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,uint256,string)\", p0, p1, p2));\n }\n\n function log(string memory p0, uint256 p1, bool p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,uint256,bool)\", p0, p1, p2));\n }\n\n function log(string memory p0, uint256 p1, address p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,uint256,address)\", p0, p1, p2));\n }\n\n function log(string memory p0, string memory p1, uint256 p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,string,uint256)\", p0, p1, p2));\n }\n\n function log(string memory p0, string memory p1, string memory p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,string,string)\", p0, p1, p2));\n }\n\n function log(string memory p0, string memory p1, bool p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,string,bool)\", p0, p1, p2));\n }\n\n function log(string memory p0, string memory p1, address p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,string,address)\", p0, p1, p2));\n }\n\n function log(string memory p0, bool p1, uint256 p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,bool,uint256)\", p0, p1, p2));\n }\n\n function log(string memory p0, bool p1, string memory p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,bool,string)\", p0, p1, p2));\n }\n\n function log(string memory p0, bool p1, bool p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,bool,bool)\", p0, p1, p2));\n }\n\n function log(string memory p0, bool p1, address p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,bool,address)\", p0, p1, p2));\n }\n\n function log(string memory p0, address p1, uint256 p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,address,uint256)\", p0, p1, p2));\n }\n\n function log(string memory p0, address p1, string memory p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,address,string)\", p0, p1, p2));\n }\n\n function log(string memory p0, address p1, bool p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,address,bool)\", p0, p1, p2));\n }\n\n function log(string memory p0, address p1, address p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,address,address)\", p0, p1, p2));\n }\n\n function log(bool p0, uint256 p1, uint256 p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,uint256,uint256)\", p0, p1, p2));\n }\n\n function log(bool p0, uint256 p1, string memory p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,uint256,string)\", p0, p1, p2));\n }\n\n function log(bool p0, uint256 p1, bool p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,uint256,bool)\", p0, p1, p2));\n }\n\n function log(bool p0, uint256 p1, address p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,uint256,address)\", p0, p1, p2));\n }\n\n function log(bool p0, string memory p1, uint256 p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,string,uint256)\", p0, p1, p2));\n }\n\n function log(bool p0, string memory p1, string memory p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,string,string)\", p0, p1, p2));\n }\n\n function log(bool p0, string memory p1, bool p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,string,bool)\", p0, p1, p2));\n }\n\n function log(bool p0, string memory p1, address p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,string,address)\", p0, p1, p2));\n }\n\n function log(bool p0, bool p1, uint256 p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,bool,uint256)\", p0, p1, p2));\n }\n\n function log(bool p0, bool p1, string memory p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,bool,string)\", p0, p1, p2));\n }\n\n function log(bool p0, bool p1, bool p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,bool,bool)\", p0, p1, p2));\n }\n\n function log(bool p0, bool p1, address p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,bool,address)\", p0, p1, p2));\n }\n\n function log(bool p0, address p1, uint256 p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,address,uint256)\", p0, p1, p2));\n }\n\n function log(bool p0, address p1, string memory p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,address,string)\", p0, p1, p2));\n }\n\n function log(bool p0, address p1, bool p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,address,bool)\", p0, p1, p2));\n }\n\n function log(bool p0, address p1, address p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,address,address)\", p0, p1, p2));\n }\n\n function log(address p0, uint256 p1, uint256 p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,uint256,uint256)\", p0, p1, p2));\n }\n\n function log(address p0, uint256 p1, string memory p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,uint256,string)\", p0, p1, p2));\n }\n\n function log(address p0, uint256 p1, bool p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,uint256,bool)\", p0, p1, p2));\n }\n\n function log(address p0, uint256 p1, address p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,uint256,address)\", p0, p1, p2));\n }\n\n function log(address p0, string memory p1, uint256 p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,string,uint256)\", p0, p1, p2));\n }\n\n function log(address p0, string memory p1, string memory p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,string,string)\", p0, p1, p2));\n }\n\n function log(address p0, string memory p1, bool p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,string,bool)\", p0, p1, p2));\n }\n\n function log(address p0, string memory p1, address p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,string,address)\", p0, p1, p2));\n }\n\n function log(address p0, bool p1, uint256 p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,bool,uint256)\", p0, p1, p2));\n }\n\n function log(address p0, bool p1, string memory p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,bool,string)\", p0, p1, p2));\n }\n\n function log(address p0, bool p1, bool p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,bool,bool)\", p0, p1, p2));\n }\n\n function log(address p0, bool p1, address p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,bool,address)\", p0, p1, p2));\n }\n\n function log(address p0, address p1, uint256 p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,address,uint256)\", p0, p1, p2));\n }\n\n function log(address p0, address p1, string memory p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,address,string)\", p0, p1, p2));\n }\n\n function log(address p0, address p1, bool p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,address,bool)\", p0, p1, p2));\n }\n\n function log(address p0, address p1, address p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,address,address)\", p0, p1, p2));\n }\n\n function log(uint256 p0, uint256 p1, uint256 p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,uint256,uint256,uint256)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, uint256 p1, uint256 p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,uint256,uint256,string)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, uint256 p1, uint256 p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,uint256,uint256,bool)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, uint256 p1, uint256 p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,uint256,uint256,address)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, uint256 p1, string memory p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,uint256,string,uint256)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, uint256 p1, string memory p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,uint256,string,string)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, uint256 p1, string memory p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,uint256,string,bool)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, uint256 p1, string memory p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,uint256,string,address)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, uint256 p1, bool p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,uint256,bool,uint256)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, uint256 p1, bool p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,uint256,bool,string)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, uint256 p1, bool p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,uint256,bool,bool)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, uint256 p1, bool p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,uint256,bool,address)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, uint256 p1, address p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,uint256,address,uint256)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, uint256 p1, address p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,uint256,address,string)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, uint256 p1, address p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,uint256,address,bool)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, uint256 p1, address p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,uint256,address,address)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, string memory p1, uint256 p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,string,uint256,uint256)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, string memory p1, uint256 p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,string,uint256,string)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, string memory p1, uint256 p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,string,uint256,bool)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, string memory p1, uint256 p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,string,uint256,address)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, string memory p1, string memory p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,string,string,uint256)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, string memory p1, string memory p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,string,string,string)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, string memory p1, string memory p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,string,string,bool)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, string memory p1, string memory p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,string,string,address)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, string memory p1, bool p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,string,bool,uint256)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, string memory p1, bool p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,string,bool,string)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, string memory p1, bool p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,string,bool,bool)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, string memory p1, bool p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,string,bool,address)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, string memory p1, address p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,string,address,uint256)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, string memory p1, address p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,string,address,string)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, string memory p1, address p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,string,address,bool)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, string memory p1, address p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,string,address,address)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, bool p1, uint256 p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,bool,uint256,uint256)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, bool p1, uint256 p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,bool,uint256,string)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, bool p1, uint256 p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,bool,uint256,bool)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, bool p1, uint256 p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,bool,uint256,address)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, bool p1, string memory p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,bool,string,uint256)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, bool p1, string memory p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,bool,string,string)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, bool p1, string memory p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,bool,string,bool)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, bool p1, string memory p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,bool,string,address)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, bool p1, bool p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,bool,bool,uint256)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, bool p1, bool p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,bool,bool,string)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, bool p1, bool p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,bool,bool,bool)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, bool p1, bool p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,bool,bool,address)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, bool p1, address p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,bool,address,uint256)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, bool p1, address p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,bool,address,string)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, bool p1, address p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,bool,address,bool)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, bool p1, address p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,bool,address,address)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, address p1, uint256 p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,address,uint256,uint256)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, address p1, uint256 p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,address,uint256,string)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, address p1, uint256 p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,address,uint256,bool)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, address p1, uint256 p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,address,uint256,address)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, address p1, string memory p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,address,string,uint256)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, address p1, string memory p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,address,string,string)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, address p1, string memory p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,address,string,bool)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, address p1, string memory p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,address,string,address)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, address p1, bool p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,address,bool,uint256)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, address p1, bool p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,address,bool,string)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, address p1, bool p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,address,bool,bool)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, address p1, bool p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,address,bool,address)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, address p1, address p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,address,address,uint256)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, address p1, address p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,address,address,string)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, address p1, address p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,address,address,bool)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, address p1, address p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,address,address,address)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, uint256 p1, uint256 p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,uint256,uint256,uint256)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, uint256 p1, uint256 p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,uint256,uint256,string)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, uint256 p1, uint256 p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,uint256,uint256,bool)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, uint256 p1, uint256 p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,uint256,uint256,address)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, uint256 p1, string memory p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,uint256,string,uint256)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, uint256 p1, string memory p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,uint256,string,string)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, uint256 p1, string memory p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,uint256,string,bool)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, uint256 p1, string memory p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,uint256,string,address)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, uint256 p1, bool p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,uint256,bool,uint256)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, uint256 p1, bool p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,uint256,bool,string)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, uint256 p1, bool p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,uint256,bool,bool)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, uint256 p1, bool p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,uint256,bool,address)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, uint256 p1, address p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,uint256,address,uint256)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, uint256 p1, address p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,uint256,address,string)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, uint256 p1, address p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,uint256,address,bool)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, uint256 p1, address p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,uint256,address,address)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, string memory p1, uint256 p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,string,uint256,uint256)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, string memory p1, uint256 p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,string,uint256,string)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, string memory p1, uint256 p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,string,uint256,bool)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, string memory p1, uint256 p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,string,uint256,address)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, string memory p1, string memory p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,string,string,uint256)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, string memory p1, string memory p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,string,string,string)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, string memory p1, string memory p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,string,string,bool)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, string memory p1, string memory p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,string,string,address)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, string memory p1, bool p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,string,bool,uint256)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, string memory p1, bool p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,string,bool,string)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, string memory p1, bool p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,string,bool,bool)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, string memory p1, bool p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,string,bool,address)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, string memory p1, address p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,string,address,uint256)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, string memory p1, address p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,string,address,string)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, string memory p1, address p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,string,address,bool)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, string memory p1, address p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,string,address,address)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, bool p1, uint256 p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,bool,uint256,uint256)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, bool p1, uint256 p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,bool,uint256,string)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, bool p1, uint256 p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,bool,uint256,bool)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, bool p1, uint256 p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,bool,uint256,address)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, bool p1, string memory p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,bool,string,uint256)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, bool p1, string memory p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,bool,string,string)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, bool p1, string memory p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,bool,string,bool)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, bool p1, string memory p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,bool,string,address)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, bool p1, bool p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,bool,bool,uint256)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, bool p1, bool p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,bool,bool,string)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, bool p1, bool p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,bool,bool,bool)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, bool p1, bool p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,bool,bool,address)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, bool p1, address p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,bool,address,uint256)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, bool p1, address p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,bool,address,string)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, bool p1, address p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,bool,address,bool)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, bool p1, address p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,bool,address,address)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, address p1, uint256 p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,address,uint256,uint256)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, address p1, uint256 p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,address,uint256,string)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, address p1, uint256 p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,address,uint256,bool)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, address p1, uint256 p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,address,uint256,address)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, address p1, string memory p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,address,string,uint256)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, address p1, string memory p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,address,string,string)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, address p1, string memory p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,address,string,bool)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, address p1, string memory p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,address,string,address)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, address p1, bool p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,address,bool,uint256)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, address p1, bool p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,address,bool,string)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, address p1, bool p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,address,bool,bool)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, address p1, bool p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,address,bool,address)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, address p1, address p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,address,address,uint256)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, address p1, address p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,address,address,string)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, address p1, address p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,address,address,bool)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, address p1, address p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,address,address,address)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, uint256 p1, uint256 p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,uint256,uint256,uint256)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, uint256 p1, uint256 p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,uint256,uint256,string)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, uint256 p1, uint256 p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,uint256,uint256,bool)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, uint256 p1, uint256 p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,uint256,uint256,address)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, uint256 p1, string memory p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,uint256,string,uint256)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, uint256 p1, string memory p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,uint256,string,string)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, uint256 p1, string memory p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,uint256,string,bool)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, uint256 p1, string memory p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,uint256,string,address)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, uint256 p1, bool p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,uint256,bool,uint256)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, uint256 p1, bool p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,uint256,bool,string)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, uint256 p1, bool p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,uint256,bool,bool)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, uint256 p1, bool p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,uint256,bool,address)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, uint256 p1, address p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,uint256,address,uint256)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, uint256 p1, address p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,uint256,address,string)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, uint256 p1, address p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,uint256,address,bool)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, uint256 p1, address p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,uint256,address,address)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, string memory p1, uint256 p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,string,uint256,uint256)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, string memory p1, uint256 p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,string,uint256,string)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, string memory p1, uint256 p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,string,uint256,bool)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, string memory p1, uint256 p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,string,uint256,address)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, string memory p1, string memory p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,string,string,uint256)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, string memory p1, string memory p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,string,string,string)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, string memory p1, string memory p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,string,string,bool)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, string memory p1, string memory p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,string,string,address)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, string memory p1, bool p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,string,bool,uint256)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, string memory p1, bool p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,string,bool,string)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, string memory p1, bool p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,string,bool,bool)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, string memory p1, bool p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,string,bool,address)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, string memory p1, address p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,string,address,uint256)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, string memory p1, address p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,string,address,string)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, string memory p1, address p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,string,address,bool)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, string memory p1, address p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,string,address,address)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, bool p1, uint256 p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,bool,uint256,uint256)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, bool p1, uint256 p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,bool,uint256,string)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, bool p1, uint256 p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,bool,uint256,bool)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, bool p1, uint256 p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,bool,uint256,address)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, bool p1, string memory p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,bool,string,uint256)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, bool p1, string memory p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,bool,string,string)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, bool p1, string memory p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,bool,string,bool)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, bool p1, string memory p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,bool,string,address)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, bool p1, bool p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,bool,bool,uint256)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, bool p1, bool p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,bool,bool,string)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, bool p1, bool p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,bool,bool,bool)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, bool p1, bool p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,bool,bool,address)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, bool p1, address p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,bool,address,uint256)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, bool p1, address p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,bool,address,string)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, bool p1, address p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,bool,address,bool)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, bool p1, address p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,bool,address,address)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, address p1, uint256 p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,address,uint256,uint256)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, address p1, uint256 p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,address,uint256,string)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, address p1, uint256 p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,address,uint256,bool)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, address p1, uint256 p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,address,uint256,address)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, address p1, string memory p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,address,string,uint256)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, address p1, string memory p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,address,string,string)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, address p1, string memory p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,address,string,bool)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, address p1, string memory p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,address,string,address)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, address p1, bool p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,address,bool,uint256)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, address p1, bool p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,address,bool,string)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, address p1, bool p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,address,bool,bool)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, address p1, bool p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,address,bool,address)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, address p1, address p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,address,address,uint256)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, address p1, address p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,address,address,string)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, address p1, address p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,address,address,bool)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, address p1, address p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,address,address,address)\", p0, p1, p2, p3));\n }\n\n function log(address p0, uint256 p1, uint256 p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,uint256,uint256,uint256)\", p0, p1, p2, p3));\n }\n\n function log(address p0, uint256 p1, uint256 p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,uint256,uint256,string)\", p0, p1, p2, p3));\n }\n\n function log(address p0, uint256 p1, uint256 p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,uint256,uint256,bool)\", p0, p1, p2, p3));\n }\n\n function log(address p0, uint256 p1, uint256 p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,uint256,uint256,address)\", p0, p1, p2, p3));\n }\n\n function log(address p0, uint256 p1, string memory p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,uint256,string,uint256)\", p0, p1, p2, p3));\n }\n\n function log(address p0, uint256 p1, string memory p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,uint256,string,string)\", p0, p1, p2, p3));\n }\n\n function log(address p0, uint256 p1, string memory p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,uint256,string,bool)\", p0, p1, p2, p3));\n }\n\n function log(address p0, uint256 p1, string memory p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,uint256,string,address)\", p0, p1, p2, p3));\n }\n\n function log(address p0, uint256 p1, bool p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,uint256,bool,uint256)\", p0, p1, p2, p3));\n }\n\n function log(address p0, uint256 p1, bool p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,uint256,bool,string)\", p0, p1, p2, p3));\n }\n\n function log(address p0, uint256 p1, bool p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,uint256,bool,bool)\", p0, p1, p2, p3));\n }\n\n function log(address p0, uint256 p1, bool p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,uint256,bool,address)\", p0, p1, p2, p3));\n }\n\n function log(address p0, uint256 p1, address p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,uint256,address,uint256)\", p0, p1, p2, p3));\n }\n\n function log(address p0, uint256 p1, address p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,uint256,address,string)\", p0, p1, p2, p3));\n }\n\n function log(address p0, uint256 p1, address p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,uint256,address,bool)\", p0, p1, p2, p3));\n }\n\n function log(address p0, uint256 p1, address p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,uint256,address,address)\", p0, p1, p2, p3));\n }\n\n function log(address p0, string memory p1, uint256 p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,string,uint256,uint256)\", p0, p1, p2, p3));\n }\n\n function log(address p0, string memory p1, uint256 p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,string,uint256,string)\", p0, p1, p2, p3));\n }\n\n function log(address p0, string memory p1, uint256 p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,string,uint256,bool)\", p0, p1, p2, p3));\n }\n\n function log(address p0, string memory p1, uint256 p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,string,uint256,address)\", p0, p1, p2, p3));\n }\n\n function log(address p0, string memory p1, string memory p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,string,string,uint256)\", p0, p1, p2, p3));\n }\n\n function log(address p0, string memory p1, string memory p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,string,string,string)\", p0, p1, p2, p3));\n }\n\n function log(address p0, string memory p1, string memory p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,string,string,bool)\", p0, p1, p2, p3));\n }\n\n function log(address p0, string memory p1, string memory p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,string,string,address)\", p0, p1, p2, p3));\n }\n\n function log(address p0, string memory p1, bool p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,string,bool,uint256)\", p0, p1, p2, p3));\n }\n\n function log(address p0, string memory p1, bool p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,string,bool,string)\", p0, p1, p2, p3));\n }\n\n function log(address p0, string memory p1, bool p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,string,bool,bool)\", p0, p1, p2, p3));\n }\n\n function log(address p0, string memory p1, bool p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,string,bool,address)\", p0, p1, p2, p3));\n }\n\n function log(address p0, string memory p1, address p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,string,address,uint256)\", p0, p1, p2, p3));\n }\n\n function log(address p0, string memory p1, address p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,string,address,string)\", p0, p1, p2, p3));\n }\n\n function log(address p0, string memory p1, address p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,string,address,bool)\", p0, p1, p2, p3));\n }\n\n function log(address p0, string memory p1, address p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,string,address,address)\", p0, p1, p2, p3));\n }\n\n function log(address p0, bool p1, uint256 p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,bool,uint256,uint256)\", p0, p1, p2, p3));\n }\n\n function log(address p0, bool p1, uint256 p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,bool,uint256,string)\", p0, p1, p2, p3));\n }\n\n function log(address p0, bool p1, uint256 p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,bool,uint256,bool)\", p0, p1, p2, p3));\n }\n\n function log(address p0, bool p1, uint256 p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,bool,uint256,address)\", p0, p1, p2, p3));\n }\n\n function log(address p0, bool p1, string memory p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,bool,string,uint256)\", p0, p1, p2, p3));\n }\n\n function log(address p0, bool p1, string memory p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,bool,string,string)\", p0, p1, p2, p3));\n }\n\n function log(address p0, bool p1, string memory p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,bool,string,bool)\", p0, p1, p2, p3));\n }\n\n function log(address p0, bool p1, string memory p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,bool,string,address)\", p0, p1, p2, p3));\n }\n\n function log(address p0, bool p1, bool p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,bool,bool,uint256)\", p0, p1, p2, p3));\n }\n\n function log(address p0, bool p1, bool p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,bool,bool,string)\", p0, p1, p2, p3));\n }\n\n function log(address p0, bool p1, bool p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,bool,bool,bool)\", p0, p1, p2, p3));\n }\n\n function log(address p0, bool p1, bool p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,bool,bool,address)\", p0, p1, p2, p3));\n }\n\n function log(address p0, bool p1, address p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,bool,address,uint256)\", p0, p1, p2, p3));\n }\n\n function log(address p0, bool p1, address p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,bool,address,string)\", p0, p1, p2, p3));\n }\n\n function log(address p0, bool p1, address p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,bool,address,bool)\", p0, p1, p2, p3));\n }\n\n function log(address p0, bool p1, address p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,bool,address,address)\", p0, p1, p2, p3));\n }\n\n function log(address p0, address p1, uint256 p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,address,uint256,uint256)\", p0, p1, p2, p3));\n }\n\n function log(address p0, address p1, uint256 p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,address,uint256,string)\", p0, p1, p2, p3));\n }\n\n function log(address p0, address p1, uint256 p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,address,uint256,bool)\", p0, p1, p2, p3));\n }\n\n function log(address p0, address p1, uint256 p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,address,uint256,address)\", p0, p1, p2, p3));\n }\n\n function log(address p0, address p1, string memory p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,address,string,uint256)\", p0, p1, p2, p3));\n }\n\n function log(address p0, address p1, string memory p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,address,string,string)\", p0, p1, p2, p3));\n }\n\n function log(address p0, address p1, string memory p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,address,string,bool)\", p0, p1, p2, p3));\n }\n\n function log(address p0, address p1, string memory p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,address,string,address)\", p0, p1, p2, p3));\n }\n\n function log(address p0, address p1, bool p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,address,bool,uint256)\", p0, p1, p2, p3));\n }\n\n function log(address p0, address p1, bool p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,address,bool,string)\", p0, p1, p2, p3));\n }\n\n function log(address p0, address p1, bool p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,address,bool,bool)\", p0, p1, p2, p3));\n }\n\n function log(address p0, address p1, bool p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,address,bool,address)\", p0, p1, p2, p3));\n }\n\n function log(address p0, address p1, address p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,address,address,uint256)\", p0, p1, p2, p3));\n }\n\n function log(address p0, address p1, address p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,address,address,string)\", p0, p1, p2, p3));\n }\n\n function log(address p0, address p1, address p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,address,address,bool)\", p0, p1, p2, p3));\n }\n\n function log(address p0, address p1, address p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,address,address,address)\", p0, p1, p2, p3));\n }\n}\n","license":"MIT"},"lib/forge-std/src/console2.sol":{"keccak256":"0x3b8fe79f48f065a4e4d35362171304a33784c3a90febae5f2787805a438de12f","urls":[],"content":"// SPDX-License-Identifier: MIT\npragma solidity >=0.4.22 <0.9.0;\n\nimport {console as console2} from \"./console.sol\";\n","license":"MIT"},"lib/forge-std/src/interfaces/IMulticall3.sol":{"keccak256":"0x7aac1389150499a922d1f9ef5749c908cef127cb2075b92fa17e9cb611263d0a","urls":[],"content":"// SPDX-License-Identifier: MIT\npragma solidity >=0.6.2 <0.9.0;\n\npragma experimental ABIEncoderV2;\n\ninterface IMulticall3 {\n struct Call {\n address target;\n bytes callData;\n }\n\n struct Call3 {\n address target;\n bool allowFailure;\n bytes callData;\n }\n\n struct Call3Value {\n address target;\n bool allowFailure;\n uint256 value;\n bytes callData;\n }\n\n struct Result {\n bool success;\n bytes returnData;\n }\n\n function aggregate(Call[] calldata calls)\n external\n payable\n returns (uint256 blockNumber, bytes[] memory returnData);\n\n function aggregate3(Call3[] calldata calls) external payable returns (Result[] memory returnData);\n\n function aggregate3Value(Call3Value[] calldata calls) external payable returns (Result[] memory returnData);\n\n function blockAndAggregate(Call[] calldata calls)\n external\n payable\n returns (uint256 blockNumber, bytes32 blockHash, Result[] memory returnData);\n\n function getBasefee() external view returns (uint256 basefee);\n\n function getBlockHash(uint256 blockNumber) external view returns (bytes32 blockHash);\n\n function getBlockNumber() external view returns (uint256 blockNumber);\n\n function getChainId() external view returns (uint256 chainid);\n\n function getCurrentBlockCoinbase() external view returns (address coinbase);\n\n function getCurrentBlockDifficulty() external view returns (uint256 difficulty);\n\n function getCurrentBlockGasLimit() external view returns (uint256 gaslimit);\n\n function getCurrentBlockTimestamp() external view returns (uint256 timestamp);\n\n function getEthBalance(address addr) external view returns (uint256 balance);\n\n function getLastBlockHash() external view returns (bytes32 blockHash);\n\n function tryAggregate(bool requireSuccess, Call[] calldata calls)\n external\n payable\n returns (Result[] memory returnData);\n\n function tryBlockAndAggregate(bool requireSuccess, Call[] calldata calls)\n external\n payable\n returns (uint256 blockNumber, bytes32 blockHash, Result[] memory returnData);\n}\n","license":"MIT"},"lib/forge-std/src/safeconsole.sol":{"keccak256":"0xbef9786cb49d3eade757bad87568c49c8c8f35721f0193c95ffb055d9e466e11","urls":[],"content":"// SPDX-License-Identifier: MIT\npragma solidity >=0.6.2 <0.9.0;\n\n/// @author philogy \n/// @dev Code generated automatically by script.\nlibrary safeconsole {\n uint256 constant CONSOLE_ADDR = 0x000000000000000000000000000000000000000000636F6e736F6c652e6c6f67;\n\n // Credit to [0age](https://twitter.com/z0age/status/1654922202930888704) and [0xdapper](https://github.com/foundry-rs/forge-std/pull/374)\n // for the view-to-pure log trick.\n function _sendLogPayload(uint256 offset, uint256 size) private pure {\n function(uint256, uint256) internal view fnIn = _sendLogPayloadView;\n function(uint256, uint256) internal pure pureSendLogPayload;\n /// @solidity memory-safe-assembly\n assembly {\n pureSendLogPayload := fnIn\n }\n pureSendLogPayload(offset, size);\n }\n\n function _sendLogPayloadView(uint256 offset, uint256 size) private view {\n /// @solidity memory-safe-assembly\n assembly {\n pop(staticcall(gas(), CONSOLE_ADDR, offset, size, 0x0, 0x0))\n }\n }\n\n function _memcopy(uint256 fromOffset, uint256 toOffset, uint256 length) private pure {\n function(uint256, uint256, uint256) internal view fnIn = _memcopyView;\n function(uint256, uint256, uint256) internal pure pureMemcopy;\n /// @solidity memory-safe-assembly\n assembly {\n pureMemcopy := fnIn\n }\n pureMemcopy(fromOffset, toOffset, length);\n }\n\n function _memcopyView(uint256 fromOffset, uint256 toOffset, uint256 length) private view {\n /// @solidity memory-safe-assembly\n assembly {\n pop(staticcall(gas(), 0x4, fromOffset, length, toOffset, length))\n }\n }\n\n function logMemory(uint256 offset, uint256 length) internal pure {\n if (offset >= 0x60) {\n // Sufficient memory before slice to prepare call header.\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(sub(offset, 0x60))\n m1 := mload(sub(offset, 0x40))\n m2 := mload(sub(offset, 0x20))\n // Selector of `log(bytes)`.\n mstore(sub(offset, 0x60), 0x0be77f56)\n mstore(sub(offset, 0x40), 0x20)\n mstore(sub(offset, 0x20), length)\n }\n _sendLogPayload(offset - 0x44, length + 0x44);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(sub(offset, 0x60), m0)\n mstore(sub(offset, 0x40), m1)\n mstore(sub(offset, 0x20), m2)\n }\n } else {\n // Insufficient space, so copy slice forward, add header and reverse.\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n uint256 endOffset = offset + length;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(add(endOffset, 0x00))\n m1 := mload(add(endOffset, 0x20))\n m2 := mload(add(endOffset, 0x40))\n }\n _memcopy(offset, offset + 0x60, length);\n /// @solidity memory-safe-assembly\n assembly {\n // Selector of `log(bytes)`.\n mstore(add(offset, 0x00), 0x0be77f56)\n mstore(add(offset, 0x20), 0x20)\n mstore(add(offset, 0x40), length)\n }\n _sendLogPayload(offset + 0x1c, length + 0x44);\n _memcopy(offset + 0x60, offset, length);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(add(endOffset, 0x00), m0)\n mstore(add(endOffset, 0x20), m1)\n mstore(add(endOffset, 0x40), m2)\n }\n }\n }\n\n function log(address p0) internal pure {\n bytes32 m0;\n bytes32 m1;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n // Selector of `log(address)`.\n mstore(0x00, 0x2c2ecbc2)\n mstore(0x20, p0)\n }\n _sendLogPayload(0x1c, 0x24);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n }\n }\n\n function log(bool p0) internal pure {\n bytes32 m0;\n bytes32 m1;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n // Selector of `log(bool)`.\n mstore(0x00, 0x32458eed)\n mstore(0x20, p0)\n }\n _sendLogPayload(0x1c, 0x24);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n }\n }\n\n function log(uint256 p0) internal pure {\n bytes32 m0;\n bytes32 m1;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n // Selector of `log(uint256)`.\n mstore(0x00, 0xf82c50f1)\n mstore(0x20, p0)\n }\n _sendLogPayload(0x1c, 0x24);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n }\n }\n\n function log(bytes32 p0) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n // Selector of `log(string)`.\n mstore(0x00, 0x41304fac)\n mstore(0x20, 0x20)\n writeString(0x40, p0)\n }\n _sendLogPayload(0x1c, 0x64);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n }\n }\n\n function log(address p0, address p1) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n // Selector of `log(address,address)`.\n mstore(0x00, 0xdaf0d4aa)\n mstore(0x20, p0)\n mstore(0x40, p1)\n }\n _sendLogPayload(0x1c, 0x44);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n }\n }\n\n function log(address p0, bool p1) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n // Selector of `log(address,bool)`.\n mstore(0x00, 0x75b605d3)\n mstore(0x20, p0)\n mstore(0x40, p1)\n }\n _sendLogPayload(0x1c, 0x44);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n }\n }\n\n function log(address p0, uint256 p1) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n // Selector of `log(address,uint256)`.\n mstore(0x00, 0x8309e8a8)\n mstore(0x20, p0)\n mstore(0x40, p1)\n }\n _sendLogPayload(0x1c, 0x44);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n }\n }\n\n function log(address p0, bytes32 p1) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(address,string)`.\n mstore(0x00, 0x759f86bb)\n mstore(0x20, p0)\n mstore(0x40, 0x40)\n writeString(0x60, p1)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(bool p0, address p1) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n // Selector of `log(bool,address)`.\n mstore(0x00, 0x853c4849)\n mstore(0x20, p0)\n mstore(0x40, p1)\n }\n _sendLogPayload(0x1c, 0x44);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n }\n }\n\n function log(bool p0, bool p1) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n // Selector of `log(bool,bool)`.\n mstore(0x00, 0x2a110e83)\n mstore(0x20, p0)\n mstore(0x40, p1)\n }\n _sendLogPayload(0x1c, 0x44);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n }\n }\n\n function log(bool p0, uint256 p1) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n // Selector of `log(bool,uint256)`.\n mstore(0x00, 0x399174d3)\n mstore(0x20, p0)\n mstore(0x40, p1)\n }\n _sendLogPayload(0x1c, 0x44);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n }\n }\n\n function log(bool p0, bytes32 p1) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(bool,string)`.\n mstore(0x00, 0x8feac525)\n mstore(0x20, p0)\n mstore(0x40, 0x40)\n writeString(0x60, p1)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(uint256 p0, address p1) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n // Selector of `log(uint256,address)`.\n mstore(0x00, 0x69276c86)\n mstore(0x20, p0)\n mstore(0x40, p1)\n }\n _sendLogPayload(0x1c, 0x44);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n }\n }\n\n function log(uint256 p0, bool p1) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n // Selector of `log(uint256,bool)`.\n mstore(0x00, 0x1c9d7eb3)\n mstore(0x20, p0)\n mstore(0x40, p1)\n }\n _sendLogPayload(0x1c, 0x44);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n }\n }\n\n function log(uint256 p0, uint256 p1) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n // Selector of `log(uint256,uint256)`.\n mstore(0x00, 0xf666715a)\n mstore(0x20, p0)\n mstore(0x40, p1)\n }\n _sendLogPayload(0x1c, 0x44);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n }\n }\n\n function log(uint256 p0, bytes32 p1) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(uint256,string)`.\n mstore(0x00, 0x643fd0df)\n mstore(0x20, p0)\n mstore(0x40, 0x40)\n writeString(0x60, p1)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(bytes32 p0, address p1) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(string,address)`.\n mstore(0x00, 0x319af333)\n mstore(0x20, 0x40)\n mstore(0x40, p1)\n writeString(0x60, p0)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(bytes32 p0, bool p1) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(string,bool)`.\n mstore(0x00, 0xc3b55635)\n mstore(0x20, 0x40)\n mstore(0x40, p1)\n writeString(0x60, p0)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(bytes32 p0, uint256 p1) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(string,uint256)`.\n mstore(0x00, 0xb60e72cc)\n mstore(0x20, 0x40)\n mstore(0x40, p1)\n writeString(0x60, p0)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(bytes32 p0, bytes32 p1) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(string,string)`.\n mstore(0x00, 0x4b5c4277)\n mstore(0x20, 0x40)\n mstore(0x40, 0x80)\n writeString(0x60, p0)\n writeString(0xa0, p1)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(address p0, address p1, address p2) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n // Selector of `log(address,address,address)`.\n mstore(0x00, 0x018c84c2)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n }\n _sendLogPayload(0x1c, 0x64);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n }\n }\n\n function log(address p0, address p1, bool p2) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n // Selector of `log(address,address,bool)`.\n mstore(0x00, 0xf2a66286)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n }\n _sendLogPayload(0x1c, 0x64);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n }\n }\n\n function log(address p0, address p1, uint256 p2) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n // Selector of `log(address,address,uint256)`.\n mstore(0x00, 0x17fe6185)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n }\n _sendLogPayload(0x1c, 0x64);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n }\n }\n\n function log(address p0, address p1, bytes32 p2) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n // Selector of `log(address,address,string)`.\n mstore(0x00, 0x007150be)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, 0x60)\n writeString(0x80, p2)\n }\n _sendLogPayload(0x1c, 0xa4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n }\n }\n\n function log(address p0, bool p1, address p2) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n // Selector of `log(address,bool,address)`.\n mstore(0x00, 0xf11699ed)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n }\n _sendLogPayload(0x1c, 0x64);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n }\n }\n\n function log(address p0, bool p1, bool p2) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n // Selector of `log(address,bool,bool)`.\n mstore(0x00, 0xeb830c92)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n }\n _sendLogPayload(0x1c, 0x64);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n }\n }\n\n function log(address p0, bool p1, uint256 p2) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n // Selector of `log(address,bool,uint256)`.\n mstore(0x00, 0x9c4f99fb)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n }\n _sendLogPayload(0x1c, 0x64);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n }\n }\n\n function log(address p0, bool p1, bytes32 p2) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n // Selector of `log(address,bool,string)`.\n mstore(0x00, 0x212255cc)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, 0x60)\n writeString(0x80, p2)\n }\n _sendLogPayload(0x1c, 0xa4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n }\n }\n\n function log(address p0, uint256 p1, address p2) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n // Selector of `log(address,uint256,address)`.\n mstore(0x00, 0x7bc0d848)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n }\n _sendLogPayload(0x1c, 0x64);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n }\n }\n\n function log(address p0, uint256 p1, bool p2) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n // Selector of `log(address,uint256,bool)`.\n mstore(0x00, 0x678209a8)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n }\n _sendLogPayload(0x1c, 0x64);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n }\n }\n\n function log(address p0, uint256 p1, uint256 p2) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n // Selector of `log(address,uint256,uint256)`.\n mstore(0x00, 0xb69bcaf6)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n }\n _sendLogPayload(0x1c, 0x64);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n }\n }\n\n function log(address p0, uint256 p1, bytes32 p2) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n // Selector of `log(address,uint256,string)`.\n mstore(0x00, 0xa1f2e8aa)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, 0x60)\n writeString(0x80, p2)\n }\n _sendLogPayload(0x1c, 0xa4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n }\n }\n\n function log(address p0, bytes32 p1, address p2) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n // Selector of `log(address,string,address)`.\n mstore(0x00, 0xf08744e8)\n mstore(0x20, p0)\n mstore(0x40, 0x60)\n mstore(0x60, p2)\n writeString(0x80, p1)\n }\n _sendLogPayload(0x1c, 0xa4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n }\n }\n\n function log(address p0, bytes32 p1, bool p2) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n // Selector of `log(address,string,bool)`.\n mstore(0x00, 0xcf020fb1)\n mstore(0x20, p0)\n mstore(0x40, 0x60)\n mstore(0x60, p2)\n writeString(0x80, p1)\n }\n _sendLogPayload(0x1c, 0xa4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n }\n }\n\n function log(address p0, bytes32 p1, uint256 p2) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n // Selector of `log(address,string,uint256)`.\n mstore(0x00, 0x67dd6ff1)\n mstore(0x20, p0)\n mstore(0x40, 0x60)\n mstore(0x60, p2)\n writeString(0x80, p1)\n }\n _sendLogPayload(0x1c, 0xa4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n }\n }\n\n function log(address p0, bytes32 p1, bytes32 p2) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n // Selector of `log(address,string,string)`.\n mstore(0x00, 0xfb772265)\n mstore(0x20, p0)\n mstore(0x40, 0x60)\n mstore(0x60, 0xa0)\n writeString(0x80, p1)\n writeString(0xc0, p2)\n }\n _sendLogPayload(0x1c, 0xe4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n }\n }\n\n function log(bool p0, address p1, address p2) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n // Selector of `log(bool,address,address)`.\n mstore(0x00, 0xd2763667)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n }\n _sendLogPayload(0x1c, 0x64);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n }\n }\n\n function log(bool p0, address p1, bool p2) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n // Selector of `log(bool,address,bool)`.\n mstore(0x00, 0x18c9c746)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n }\n _sendLogPayload(0x1c, 0x64);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n }\n }\n\n function log(bool p0, address p1, uint256 p2) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n // Selector of `log(bool,address,uint256)`.\n mstore(0x00, 0x5f7b9afb)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n }\n _sendLogPayload(0x1c, 0x64);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n }\n }\n\n function log(bool p0, address p1, bytes32 p2) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n // Selector of `log(bool,address,string)`.\n mstore(0x00, 0xde9a9270)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, 0x60)\n writeString(0x80, p2)\n }\n _sendLogPayload(0x1c, 0xa4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n }\n }\n\n function log(bool p0, bool p1, address p2) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n // Selector of `log(bool,bool,address)`.\n mstore(0x00, 0x1078f68d)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n }\n _sendLogPayload(0x1c, 0x64);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n }\n }\n\n function log(bool p0, bool p1, bool p2) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n // Selector of `log(bool,bool,bool)`.\n mstore(0x00, 0x50709698)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n }\n _sendLogPayload(0x1c, 0x64);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n }\n }\n\n function log(bool p0, bool p1, uint256 p2) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n // Selector of `log(bool,bool,uint256)`.\n mstore(0x00, 0x12f21602)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n }\n _sendLogPayload(0x1c, 0x64);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n }\n }\n\n function log(bool p0, bool p1, bytes32 p2) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n // Selector of `log(bool,bool,string)`.\n mstore(0x00, 0x2555fa46)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, 0x60)\n writeString(0x80, p2)\n }\n _sendLogPayload(0x1c, 0xa4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n }\n }\n\n function log(bool p0, uint256 p1, address p2) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n // Selector of `log(bool,uint256,address)`.\n mstore(0x00, 0x088ef9d2)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n }\n _sendLogPayload(0x1c, 0x64);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n }\n }\n\n function log(bool p0, uint256 p1, bool p2) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n // Selector of `log(bool,uint256,bool)`.\n mstore(0x00, 0xe8defba9)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n }\n _sendLogPayload(0x1c, 0x64);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n }\n }\n\n function log(bool p0, uint256 p1, uint256 p2) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n // Selector of `log(bool,uint256,uint256)`.\n mstore(0x00, 0x37103367)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n }\n _sendLogPayload(0x1c, 0x64);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n }\n }\n\n function log(bool p0, uint256 p1, bytes32 p2) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n // Selector of `log(bool,uint256,string)`.\n mstore(0x00, 0xc3fc3970)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, 0x60)\n writeString(0x80, p2)\n }\n _sendLogPayload(0x1c, 0xa4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n }\n }\n\n function log(bool p0, bytes32 p1, address p2) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n // Selector of `log(bool,string,address)`.\n mstore(0x00, 0x9591b953)\n mstore(0x20, p0)\n mstore(0x40, 0x60)\n mstore(0x60, p2)\n writeString(0x80, p1)\n }\n _sendLogPayload(0x1c, 0xa4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n }\n }\n\n function log(bool p0, bytes32 p1, bool p2) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n // Selector of `log(bool,string,bool)`.\n mstore(0x00, 0xdbb4c247)\n mstore(0x20, p0)\n mstore(0x40, 0x60)\n mstore(0x60, p2)\n writeString(0x80, p1)\n }\n _sendLogPayload(0x1c, 0xa4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n }\n }\n\n function log(bool p0, bytes32 p1, uint256 p2) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n // Selector of `log(bool,string,uint256)`.\n mstore(0x00, 0x1093ee11)\n mstore(0x20, p0)\n mstore(0x40, 0x60)\n mstore(0x60, p2)\n writeString(0x80, p1)\n }\n _sendLogPayload(0x1c, 0xa4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n }\n }\n\n function log(bool p0, bytes32 p1, bytes32 p2) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n // Selector of `log(bool,string,string)`.\n mstore(0x00, 0xb076847f)\n mstore(0x20, p0)\n mstore(0x40, 0x60)\n mstore(0x60, 0xa0)\n writeString(0x80, p1)\n writeString(0xc0, p2)\n }\n _sendLogPayload(0x1c, 0xe4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n }\n }\n\n function log(uint256 p0, address p1, address p2) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n // Selector of `log(uint256,address,address)`.\n mstore(0x00, 0xbcfd9be0)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n }\n _sendLogPayload(0x1c, 0x64);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n }\n }\n\n function log(uint256 p0, address p1, bool p2) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n // Selector of `log(uint256,address,bool)`.\n mstore(0x00, 0x9b6ec042)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n }\n _sendLogPayload(0x1c, 0x64);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n }\n }\n\n function log(uint256 p0, address p1, uint256 p2) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n // Selector of `log(uint256,address,uint256)`.\n mstore(0x00, 0x5a9b5ed5)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n }\n _sendLogPayload(0x1c, 0x64);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n }\n }\n\n function log(uint256 p0, address p1, bytes32 p2) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n // Selector of `log(uint256,address,string)`.\n mstore(0x00, 0x63cb41f9)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, 0x60)\n writeString(0x80, p2)\n }\n _sendLogPayload(0x1c, 0xa4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n }\n }\n\n function log(uint256 p0, bool p1, address p2) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n // Selector of `log(uint256,bool,address)`.\n mstore(0x00, 0x35085f7b)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n }\n _sendLogPayload(0x1c, 0x64);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n }\n }\n\n function log(uint256 p0, bool p1, bool p2) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n // Selector of `log(uint256,bool,bool)`.\n mstore(0x00, 0x20718650)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n }\n _sendLogPayload(0x1c, 0x64);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n }\n }\n\n function log(uint256 p0, bool p1, uint256 p2) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n // Selector of `log(uint256,bool,uint256)`.\n mstore(0x00, 0x20098014)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n }\n _sendLogPayload(0x1c, 0x64);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n }\n }\n\n function log(uint256 p0, bool p1, bytes32 p2) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n // Selector of `log(uint256,bool,string)`.\n mstore(0x00, 0x85775021)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, 0x60)\n writeString(0x80, p2)\n }\n _sendLogPayload(0x1c, 0xa4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n }\n }\n\n function log(uint256 p0, uint256 p1, address p2) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n // Selector of `log(uint256,uint256,address)`.\n mstore(0x00, 0x5c96b331)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n }\n _sendLogPayload(0x1c, 0x64);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n }\n }\n\n function log(uint256 p0, uint256 p1, bool p2) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n // Selector of `log(uint256,uint256,bool)`.\n mstore(0x00, 0x4766da72)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n }\n _sendLogPayload(0x1c, 0x64);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n }\n }\n\n function log(uint256 p0, uint256 p1, uint256 p2) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n // Selector of `log(uint256,uint256,uint256)`.\n mstore(0x00, 0xd1ed7a3c)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n }\n _sendLogPayload(0x1c, 0x64);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n }\n }\n\n function log(uint256 p0, uint256 p1, bytes32 p2) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n // Selector of `log(uint256,uint256,string)`.\n mstore(0x00, 0x71d04af2)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, 0x60)\n writeString(0x80, p2)\n }\n _sendLogPayload(0x1c, 0xa4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n }\n }\n\n function log(uint256 p0, bytes32 p1, address p2) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n // Selector of `log(uint256,string,address)`.\n mstore(0x00, 0x7afac959)\n mstore(0x20, p0)\n mstore(0x40, 0x60)\n mstore(0x60, p2)\n writeString(0x80, p1)\n }\n _sendLogPayload(0x1c, 0xa4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n }\n }\n\n function log(uint256 p0, bytes32 p1, bool p2) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n // Selector of `log(uint256,string,bool)`.\n mstore(0x00, 0x4ceda75a)\n mstore(0x20, p0)\n mstore(0x40, 0x60)\n mstore(0x60, p2)\n writeString(0x80, p1)\n }\n _sendLogPayload(0x1c, 0xa4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n }\n }\n\n function log(uint256 p0, bytes32 p1, uint256 p2) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n // Selector of `log(uint256,string,uint256)`.\n mstore(0x00, 0x37aa7d4c)\n mstore(0x20, p0)\n mstore(0x40, 0x60)\n mstore(0x60, p2)\n writeString(0x80, p1)\n }\n _sendLogPayload(0x1c, 0xa4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n }\n }\n\n function log(uint256 p0, bytes32 p1, bytes32 p2) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n // Selector of `log(uint256,string,string)`.\n mstore(0x00, 0xb115611f)\n mstore(0x20, p0)\n mstore(0x40, 0x60)\n mstore(0x60, 0xa0)\n writeString(0x80, p1)\n writeString(0xc0, p2)\n }\n _sendLogPayload(0x1c, 0xe4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n }\n }\n\n function log(bytes32 p0, address p1, address p2) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n // Selector of `log(string,address,address)`.\n mstore(0x00, 0xfcec75e0)\n mstore(0x20, 0x60)\n mstore(0x40, p1)\n mstore(0x60, p2)\n writeString(0x80, p0)\n }\n _sendLogPayload(0x1c, 0xa4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n }\n }\n\n function log(bytes32 p0, address p1, bool p2) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n // Selector of `log(string,address,bool)`.\n mstore(0x00, 0xc91d5ed4)\n mstore(0x20, 0x60)\n mstore(0x40, p1)\n mstore(0x60, p2)\n writeString(0x80, p0)\n }\n _sendLogPayload(0x1c, 0xa4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n }\n }\n\n function log(bytes32 p0, address p1, uint256 p2) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n // Selector of `log(string,address,uint256)`.\n mstore(0x00, 0x0d26b925)\n mstore(0x20, 0x60)\n mstore(0x40, p1)\n mstore(0x60, p2)\n writeString(0x80, p0)\n }\n _sendLogPayload(0x1c, 0xa4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n }\n }\n\n function log(bytes32 p0, address p1, bytes32 p2) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n // Selector of `log(string,address,string)`.\n mstore(0x00, 0xe0e9ad4f)\n mstore(0x20, 0x60)\n mstore(0x40, p1)\n mstore(0x60, 0xa0)\n writeString(0x80, p0)\n writeString(0xc0, p2)\n }\n _sendLogPayload(0x1c, 0xe4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n }\n }\n\n function log(bytes32 p0, bool p1, address p2) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n // Selector of `log(string,bool,address)`.\n mstore(0x00, 0x932bbb38)\n mstore(0x20, 0x60)\n mstore(0x40, p1)\n mstore(0x60, p2)\n writeString(0x80, p0)\n }\n _sendLogPayload(0x1c, 0xa4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n }\n }\n\n function log(bytes32 p0, bool p1, bool p2) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n // Selector of `log(string,bool,bool)`.\n mstore(0x00, 0x850b7ad6)\n mstore(0x20, 0x60)\n mstore(0x40, p1)\n mstore(0x60, p2)\n writeString(0x80, p0)\n }\n _sendLogPayload(0x1c, 0xa4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n }\n }\n\n function log(bytes32 p0, bool p1, uint256 p2) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n // Selector of `log(string,bool,uint256)`.\n mstore(0x00, 0xc95958d6)\n mstore(0x20, 0x60)\n mstore(0x40, p1)\n mstore(0x60, p2)\n writeString(0x80, p0)\n }\n _sendLogPayload(0x1c, 0xa4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n }\n }\n\n function log(bytes32 p0, bool p1, bytes32 p2) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n // Selector of `log(string,bool,string)`.\n mstore(0x00, 0xe298f47d)\n mstore(0x20, 0x60)\n mstore(0x40, p1)\n mstore(0x60, 0xa0)\n writeString(0x80, p0)\n writeString(0xc0, p2)\n }\n _sendLogPayload(0x1c, 0xe4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n }\n }\n\n function log(bytes32 p0, uint256 p1, address p2) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n // Selector of `log(string,uint256,address)`.\n mstore(0x00, 0x1c7ec448)\n mstore(0x20, 0x60)\n mstore(0x40, p1)\n mstore(0x60, p2)\n writeString(0x80, p0)\n }\n _sendLogPayload(0x1c, 0xa4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n }\n }\n\n function log(bytes32 p0, uint256 p1, bool p2) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n // Selector of `log(string,uint256,bool)`.\n mstore(0x00, 0xca7733b1)\n mstore(0x20, 0x60)\n mstore(0x40, p1)\n mstore(0x60, p2)\n writeString(0x80, p0)\n }\n _sendLogPayload(0x1c, 0xa4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n }\n }\n\n function log(bytes32 p0, uint256 p1, uint256 p2) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n // Selector of `log(string,uint256,uint256)`.\n mstore(0x00, 0xca47c4eb)\n mstore(0x20, 0x60)\n mstore(0x40, p1)\n mstore(0x60, p2)\n writeString(0x80, p0)\n }\n _sendLogPayload(0x1c, 0xa4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n }\n }\n\n function log(bytes32 p0, uint256 p1, bytes32 p2) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n // Selector of `log(string,uint256,string)`.\n mstore(0x00, 0x5970e089)\n mstore(0x20, 0x60)\n mstore(0x40, p1)\n mstore(0x60, 0xa0)\n writeString(0x80, p0)\n writeString(0xc0, p2)\n }\n _sendLogPayload(0x1c, 0xe4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n }\n }\n\n function log(bytes32 p0, bytes32 p1, address p2) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n // Selector of `log(string,string,address)`.\n mstore(0x00, 0x95ed0195)\n mstore(0x20, 0x60)\n mstore(0x40, 0xa0)\n mstore(0x60, p2)\n writeString(0x80, p0)\n writeString(0xc0, p1)\n }\n _sendLogPayload(0x1c, 0xe4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n }\n }\n\n function log(bytes32 p0, bytes32 p1, bool p2) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n // Selector of `log(string,string,bool)`.\n mstore(0x00, 0xb0e0f9b5)\n mstore(0x20, 0x60)\n mstore(0x40, 0xa0)\n mstore(0x60, p2)\n writeString(0x80, p0)\n writeString(0xc0, p1)\n }\n _sendLogPayload(0x1c, 0xe4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n }\n }\n\n function log(bytes32 p0, bytes32 p1, uint256 p2) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n // Selector of `log(string,string,uint256)`.\n mstore(0x00, 0x5821efa1)\n mstore(0x20, 0x60)\n mstore(0x40, 0xa0)\n mstore(0x60, p2)\n writeString(0x80, p0)\n writeString(0xc0, p1)\n }\n _sendLogPayload(0x1c, 0xe4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n }\n }\n\n function log(bytes32 p0, bytes32 p1, bytes32 p2) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n bytes32 m9;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n m9 := mload(0x120)\n // Selector of `log(string,string,string)`.\n mstore(0x00, 0x2ced7cef)\n mstore(0x20, 0x60)\n mstore(0x40, 0xa0)\n mstore(0x60, 0xe0)\n writeString(0x80, p0)\n writeString(0xc0, p1)\n writeString(0x100, p2)\n }\n _sendLogPayload(0x1c, 0x124);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n mstore(0x120, m9)\n }\n }\n\n function log(address p0, address p1, address p2, address p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(address,address,address,address)`.\n mstore(0x00, 0x665bf134)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(address p0, address p1, address p2, bool p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(address,address,address,bool)`.\n mstore(0x00, 0x0e378994)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(address p0, address p1, address p2, uint256 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(address,address,address,uint256)`.\n mstore(0x00, 0x94250d77)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(address p0, address p1, address p2, bytes32 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(address,address,address,string)`.\n mstore(0x00, 0xf808da20)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, 0x80)\n writeString(0xa0, p3)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(address p0, address p1, bool p2, address p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(address,address,bool,address)`.\n mstore(0x00, 0x9f1bc36e)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(address p0, address p1, bool p2, bool p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(address,address,bool,bool)`.\n mstore(0x00, 0x2cd4134a)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(address p0, address p1, bool p2, uint256 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(address,address,bool,uint256)`.\n mstore(0x00, 0x3971e78c)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(address p0, address p1, bool p2, bytes32 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(address,address,bool,string)`.\n mstore(0x00, 0xaa6540c8)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, 0x80)\n writeString(0xa0, p3)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(address p0, address p1, uint256 p2, address p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(address,address,uint256,address)`.\n mstore(0x00, 0x8da6def5)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(address p0, address p1, uint256 p2, bool p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(address,address,uint256,bool)`.\n mstore(0x00, 0x9b4254e2)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(address p0, address p1, uint256 p2, uint256 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(address,address,uint256,uint256)`.\n mstore(0x00, 0xbe553481)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(address p0, address p1, uint256 p2, bytes32 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(address,address,uint256,string)`.\n mstore(0x00, 0xfdb4f990)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, 0x80)\n writeString(0xa0, p3)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(address p0, address p1, bytes32 p2, address p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(address,address,string,address)`.\n mstore(0x00, 0x8f736d16)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, 0x80)\n mstore(0x80, p3)\n writeString(0xa0, p2)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(address p0, address p1, bytes32 p2, bool p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(address,address,string,bool)`.\n mstore(0x00, 0x6f1a594e)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, 0x80)\n mstore(0x80, p3)\n writeString(0xa0, p2)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(address p0, address p1, bytes32 p2, uint256 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(address,address,string,uint256)`.\n mstore(0x00, 0xef1cefe7)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, 0x80)\n mstore(0x80, p3)\n writeString(0xa0, p2)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(address p0, address p1, bytes32 p2, bytes32 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n // Selector of `log(address,address,string,string)`.\n mstore(0x00, 0x21bdaf25)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, 0x80)\n mstore(0x80, 0xc0)\n writeString(0xa0, p2)\n writeString(0xe0, p3)\n }\n _sendLogPayload(0x1c, 0x104);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n }\n }\n\n function log(address p0, bool p1, address p2, address p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(address,bool,address,address)`.\n mstore(0x00, 0x660375dd)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(address p0, bool p1, address p2, bool p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(address,bool,address,bool)`.\n mstore(0x00, 0xa6f50b0f)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(address p0, bool p1, address p2, uint256 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(address,bool,address,uint256)`.\n mstore(0x00, 0xa75c59de)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(address p0, bool p1, address p2, bytes32 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(address,bool,address,string)`.\n mstore(0x00, 0x2dd778e6)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, 0x80)\n writeString(0xa0, p3)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(address p0, bool p1, bool p2, address p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(address,bool,bool,address)`.\n mstore(0x00, 0xcf394485)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(address p0, bool p1, bool p2, bool p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(address,bool,bool,bool)`.\n mstore(0x00, 0xcac43479)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(address p0, bool p1, bool p2, uint256 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(address,bool,bool,uint256)`.\n mstore(0x00, 0x8c4e5de6)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(address p0, bool p1, bool p2, bytes32 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(address,bool,bool,string)`.\n mstore(0x00, 0xdfc4a2e8)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, 0x80)\n writeString(0xa0, p3)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(address p0, bool p1, uint256 p2, address p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(address,bool,uint256,address)`.\n mstore(0x00, 0xccf790a1)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(address p0, bool p1, uint256 p2, bool p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(address,bool,uint256,bool)`.\n mstore(0x00, 0xc4643e20)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(address p0, bool p1, uint256 p2, uint256 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(address,bool,uint256,uint256)`.\n mstore(0x00, 0x386ff5f4)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(address p0, bool p1, uint256 p2, bytes32 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(address,bool,uint256,string)`.\n mstore(0x00, 0x0aa6cfad)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, 0x80)\n writeString(0xa0, p3)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(address p0, bool p1, bytes32 p2, address p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(address,bool,string,address)`.\n mstore(0x00, 0x19fd4956)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, 0x80)\n mstore(0x80, p3)\n writeString(0xa0, p2)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(address p0, bool p1, bytes32 p2, bool p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(address,bool,string,bool)`.\n mstore(0x00, 0x50ad461d)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, 0x80)\n mstore(0x80, p3)\n writeString(0xa0, p2)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(address p0, bool p1, bytes32 p2, uint256 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(address,bool,string,uint256)`.\n mstore(0x00, 0x80e6a20b)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, 0x80)\n mstore(0x80, p3)\n writeString(0xa0, p2)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(address p0, bool p1, bytes32 p2, bytes32 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n // Selector of `log(address,bool,string,string)`.\n mstore(0x00, 0x475c5c33)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, 0x80)\n mstore(0x80, 0xc0)\n writeString(0xa0, p2)\n writeString(0xe0, p3)\n }\n _sendLogPayload(0x1c, 0x104);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n }\n }\n\n function log(address p0, uint256 p1, address p2, address p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(address,uint256,address,address)`.\n mstore(0x00, 0x478d1c62)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(address p0, uint256 p1, address p2, bool p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(address,uint256,address,bool)`.\n mstore(0x00, 0xa1bcc9b3)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(address p0, uint256 p1, address p2, uint256 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(address,uint256,address,uint256)`.\n mstore(0x00, 0x100f650e)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(address p0, uint256 p1, address p2, bytes32 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(address,uint256,address,string)`.\n mstore(0x00, 0x1da986ea)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, 0x80)\n writeString(0xa0, p3)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(address p0, uint256 p1, bool p2, address p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(address,uint256,bool,address)`.\n mstore(0x00, 0xa31bfdcc)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(address p0, uint256 p1, bool p2, bool p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(address,uint256,bool,bool)`.\n mstore(0x00, 0x3bf5e537)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(address p0, uint256 p1, bool p2, uint256 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(address,uint256,bool,uint256)`.\n mstore(0x00, 0x22f6b999)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(address p0, uint256 p1, bool p2, bytes32 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(address,uint256,bool,string)`.\n mstore(0x00, 0xc5ad85f9)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, 0x80)\n writeString(0xa0, p3)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(address p0, uint256 p1, uint256 p2, address p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(address,uint256,uint256,address)`.\n mstore(0x00, 0x20e3984d)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(address p0, uint256 p1, uint256 p2, bool p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(address,uint256,uint256,bool)`.\n mstore(0x00, 0x66f1bc67)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(address p0, uint256 p1, uint256 p2, uint256 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(address,uint256,uint256,uint256)`.\n mstore(0x00, 0x34f0e636)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(address p0, uint256 p1, uint256 p2, bytes32 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(address,uint256,uint256,string)`.\n mstore(0x00, 0x4a28c017)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, 0x80)\n writeString(0xa0, p3)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(address p0, uint256 p1, bytes32 p2, address p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(address,uint256,string,address)`.\n mstore(0x00, 0x5c430d47)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, 0x80)\n mstore(0x80, p3)\n writeString(0xa0, p2)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(address p0, uint256 p1, bytes32 p2, bool p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(address,uint256,string,bool)`.\n mstore(0x00, 0xcf18105c)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, 0x80)\n mstore(0x80, p3)\n writeString(0xa0, p2)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(address p0, uint256 p1, bytes32 p2, uint256 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(address,uint256,string,uint256)`.\n mstore(0x00, 0xbf01f891)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, 0x80)\n mstore(0x80, p3)\n writeString(0xa0, p2)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(address p0, uint256 p1, bytes32 p2, bytes32 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n // Selector of `log(address,uint256,string,string)`.\n mstore(0x00, 0x88a8c406)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, 0x80)\n mstore(0x80, 0xc0)\n writeString(0xa0, p2)\n writeString(0xe0, p3)\n }\n _sendLogPayload(0x1c, 0x104);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n }\n }\n\n function log(address p0, bytes32 p1, address p2, address p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(address,string,address,address)`.\n mstore(0x00, 0x0d36fa20)\n mstore(0x20, p0)\n mstore(0x40, 0x80)\n mstore(0x60, p2)\n mstore(0x80, p3)\n writeString(0xa0, p1)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(address p0, bytes32 p1, address p2, bool p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(address,string,address,bool)`.\n mstore(0x00, 0x0df12b76)\n mstore(0x20, p0)\n mstore(0x40, 0x80)\n mstore(0x60, p2)\n mstore(0x80, p3)\n writeString(0xa0, p1)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(address p0, bytes32 p1, address p2, uint256 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(address,string,address,uint256)`.\n mstore(0x00, 0x457fe3cf)\n mstore(0x20, p0)\n mstore(0x40, 0x80)\n mstore(0x60, p2)\n mstore(0x80, p3)\n writeString(0xa0, p1)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(address p0, bytes32 p1, address p2, bytes32 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n // Selector of `log(address,string,address,string)`.\n mstore(0x00, 0xf7e36245)\n mstore(0x20, p0)\n mstore(0x40, 0x80)\n mstore(0x60, p2)\n mstore(0x80, 0xc0)\n writeString(0xa0, p1)\n writeString(0xe0, p3)\n }\n _sendLogPayload(0x1c, 0x104);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n }\n }\n\n function log(address p0, bytes32 p1, bool p2, address p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(address,string,bool,address)`.\n mstore(0x00, 0x205871c2)\n mstore(0x20, p0)\n mstore(0x40, 0x80)\n mstore(0x60, p2)\n mstore(0x80, p3)\n writeString(0xa0, p1)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(address p0, bytes32 p1, bool p2, bool p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(address,string,bool,bool)`.\n mstore(0x00, 0x5f1d5c9f)\n mstore(0x20, p0)\n mstore(0x40, 0x80)\n mstore(0x60, p2)\n mstore(0x80, p3)\n writeString(0xa0, p1)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(address p0, bytes32 p1, bool p2, uint256 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(address,string,bool,uint256)`.\n mstore(0x00, 0x515e38b6)\n mstore(0x20, p0)\n mstore(0x40, 0x80)\n mstore(0x60, p2)\n mstore(0x80, p3)\n writeString(0xa0, p1)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(address p0, bytes32 p1, bool p2, bytes32 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n // Selector of `log(address,string,bool,string)`.\n mstore(0x00, 0xbc0b61fe)\n mstore(0x20, p0)\n mstore(0x40, 0x80)\n mstore(0x60, p2)\n mstore(0x80, 0xc0)\n writeString(0xa0, p1)\n writeString(0xe0, p3)\n }\n _sendLogPayload(0x1c, 0x104);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n }\n }\n\n function log(address p0, bytes32 p1, uint256 p2, address p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(address,string,uint256,address)`.\n mstore(0x00, 0x63183678)\n mstore(0x20, p0)\n mstore(0x40, 0x80)\n mstore(0x60, p2)\n mstore(0x80, p3)\n writeString(0xa0, p1)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(address p0, bytes32 p1, uint256 p2, bool p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(address,string,uint256,bool)`.\n mstore(0x00, 0x0ef7e050)\n mstore(0x20, p0)\n mstore(0x40, 0x80)\n mstore(0x60, p2)\n mstore(0x80, p3)\n writeString(0xa0, p1)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(address p0, bytes32 p1, uint256 p2, uint256 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(address,string,uint256,uint256)`.\n mstore(0x00, 0x1dc8e1b8)\n mstore(0x20, p0)\n mstore(0x40, 0x80)\n mstore(0x60, p2)\n mstore(0x80, p3)\n writeString(0xa0, p1)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(address p0, bytes32 p1, uint256 p2, bytes32 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n // Selector of `log(address,string,uint256,string)`.\n mstore(0x00, 0x448830a8)\n mstore(0x20, p0)\n mstore(0x40, 0x80)\n mstore(0x60, p2)\n mstore(0x80, 0xc0)\n writeString(0xa0, p1)\n writeString(0xe0, p3)\n }\n _sendLogPayload(0x1c, 0x104);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n }\n }\n\n function log(address p0, bytes32 p1, bytes32 p2, address p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n // Selector of `log(address,string,string,address)`.\n mstore(0x00, 0xa04e2f87)\n mstore(0x20, p0)\n mstore(0x40, 0x80)\n mstore(0x60, 0xc0)\n mstore(0x80, p3)\n writeString(0xa0, p1)\n writeString(0xe0, p2)\n }\n _sendLogPayload(0x1c, 0x104);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n }\n }\n\n function log(address p0, bytes32 p1, bytes32 p2, bool p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n // Selector of `log(address,string,string,bool)`.\n mstore(0x00, 0x35a5071f)\n mstore(0x20, p0)\n mstore(0x40, 0x80)\n mstore(0x60, 0xc0)\n mstore(0x80, p3)\n writeString(0xa0, p1)\n writeString(0xe0, p2)\n }\n _sendLogPayload(0x1c, 0x104);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n }\n }\n\n function log(address p0, bytes32 p1, bytes32 p2, uint256 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n // Selector of `log(address,string,string,uint256)`.\n mstore(0x00, 0x159f8927)\n mstore(0x20, p0)\n mstore(0x40, 0x80)\n mstore(0x60, 0xc0)\n mstore(0x80, p3)\n writeString(0xa0, p1)\n writeString(0xe0, p2)\n }\n _sendLogPayload(0x1c, 0x104);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n }\n }\n\n function log(address p0, bytes32 p1, bytes32 p2, bytes32 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n bytes32 m9;\n bytes32 m10;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n m9 := mload(0x120)\n m10 := mload(0x140)\n // Selector of `log(address,string,string,string)`.\n mstore(0x00, 0x5d02c50b)\n mstore(0x20, p0)\n mstore(0x40, 0x80)\n mstore(0x60, 0xc0)\n mstore(0x80, 0x100)\n writeString(0xa0, p1)\n writeString(0xe0, p2)\n writeString(0x120, p3)\n }\n _sendLogPayload(0x1c, 0x144);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n mstore(0x120, m9)\n mstore(0x140, m10)\n }\n }\n\n function log(bool p0, address p1, address p2, address p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(bool,address,address,address)`.\n mstore(0x00, 0x1d14d001)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(bool p0, address p1, address p2, bool p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(bool,address,address,bool)`.\n mstore(0x00, 0x46600be0)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(bool p0, address p1, address p2, uint256 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(bool,address,address,uint256)`.\n mstore(0x00, 0x0c66d1be)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(bool p0, address p1, address p2, bytes32 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(bool,address,address,string)`.\n mstore(0x00, 0xd812a167)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, 0x80)\n writeString(0xa0, p3)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(bool p0, address p1, bool p2, address p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(bool,address,bool,address)`.\n mstore(0x00, 0x1c41a336)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(bool p0, address p1, bool p2, bool p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(bool,address,bool,bool)`.\n mstore(0x00, 0x6a9c478b)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(bool p0, address p1, bool p2, uint256 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(bool,address,bool,uint256)`.\n mstore(0x00, 0x07831502)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(bool p0, address p1, bool p2, bytes32 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(bool,address,bool,string)`.\n mstore(0x00, 0x4a66cb34)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, 0x80)\n writeString(0xa0, p3)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(bool p0, address p1, uint256 p2, address p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(bool,address,uint256,address)`.\n mstore(0x00, 0x136b05dd)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(bool p0, address p1, uint256 p2, bool p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(bool,address,uint256,bool)`.\n mstore(0x00, 0xd6019f1c)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(bool p0, address p1, uint256 p2, uint256 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(bool,address,uint256,uint256)`.\n mstore(0x00, 0x7bf181a1)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(bool p0, address p1, uint256 p2, bytes32 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(bool,address,uint256,string)`.\n mstore(0x00, 0x51f09ff8)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, 0x80)\n writeString(0xa0, p3)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(bool p0, address p1, bytes32 p2, address p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(bool,address,string,address)`.\n mstore(0x00, 0x6f7c603e)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, 0x80)\n mstore(0x80, p3)\n writeString(0xa0, p2)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(bool p0, address p1, bytes32 p2, bool p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(bool,address,string,bool)`.\n mstore(0x00, 0xe2bfd60b)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, 0x80)\n mstore(0x80, p3)\n writeString(0xa0, p2)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(bool p0, address p1, bytes32 p2, uint256 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(bool,address,string,uint256)`.\n mstore(0x00, 0xc21f64c7)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, 0x80)\n mstore(0x80, p3)\n writeString(0xa0, p2)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(bool p0, address p1, bytes32 p2, bytes32 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n // Selector of `log(bool,address,string,string)`.\n mstore(0x00, 0xa73c1db6)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, 0x80)\n mstore(0x80, 0xc0)\n writeString(0xa0, p2)\n writeString(0xe0, p3)\n }\n _sendLogPayload(0x1c, 0x104);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n }\n }\n\n function log(bool p0, bool p1, address p2, address p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(bool,bool,address,address)`.\n mstore(0x00, 0xf4880ea4)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(bool p0, bool p1, address p2, bool p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(bool,bool,address,bool)`.\n mstore(0x00, 0xc0a302d8)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(bool p0, bool p1, address p2, uint256 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(bool,bool,address,uint256)`.\n mstore(0x00, 0x4c123d57)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(bool p0, bool p1, address p2, bytes32 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(bool,bool,address,string)`.\n mstore(0x00, 0xa0a47963)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, 0x80)\n writeString(0xa0, p3)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(bool p0, bool p1, bool p2, address p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(bool,bool,bool,address)`.\n mstore(0x00, 0x8c329b1a)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(bool p0, bool p1, bool p2, bool p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(bool,bool,bool,bool)`.\n mstore(0x00, 0x3b2a5ce0)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(bool p0, bool p1, bool p2, uint256 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(bool,bool,bool,uint256)`.\n mstore(0x00, 0x6d7045c1)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(bool p0, bool p1, bool p2, bytes32 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(bool,bool,bool,string)`.\n mstore(0x00, 0x2ae408d4)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, 0x80)\n writeString(0xa0, p3)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(bool p0, bool p1, uint256 p2, address p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(bool,bool,uint256,address)`.\n mstore(0x00, 0x54a7a9a0)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(bool p0, bool p1, uint256 p2, bool p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(bool,bool,uint256,bool)`.\n mstore(0x00, 0x619e4d0e)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(bool p0, bool p1, uint256 p2, uint256 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(bool,bool,uint256,uint256)`.\n mstore(0x00, 0x0bb00eab)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(bool p0, bool p1, uint256 p2, bytes32 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(bool,bool,uint256,string)`.\n mstore(0x00, 0x7dd4d0e0)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, 0x80)\n writeString(0xa0, p3)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(bool p0, bool p1, bytes32 p2, address p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(bool,bool,string,address)`.\n mstore(0x00, 0xf9ad2b89)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, 0x80)\n mstore(0x80, p3)\n writeString(0xa0, p2)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(bool p0, bool p1, bytes32 p2, bool p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(bool,bool,string,bool)`.\n mstore(0x00, 0xb857163a)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, 0x80)\n mstore(0x80, p3)\n writeString(0xa0, p2)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(bool p0, bool p1, bytes32 p2, uint256 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(bool,bool,string,uint256)`.\n mstore(0x00, 0xe3a9ca2f)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, 0x80)\n mstore(0x80, p3)\n writeString(0xa0, p2)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(bool p0, bool p1, bytes32 p2, bytes32 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n // Selector of `log(bool,bool,string,string)`.\n mstore(0x00, 0x6d1e8751)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, 0x80)\n mstore(0x80, 0xc0)\n writeString(0xa0, p2)\n writeString(0xe0, p3)\n }\n _sendLogPayload(0x1c, 0x104);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n }\n }\n\n function log(bool p0, uint256 p1, address p2, address p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(bool,uint256,address,address)`.\n mstore(0x00, 0x26f560a8)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(bool p0, uint256 p1, address p2, bool p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(bool,uint256,address,bool)`.\n mstore(0x00, 0xb4c314ff)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(bool p0, uint256 p1, address p2, uint256 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(bool,uint256,address,uint256)`.\n mstore(0x00, 0x1537dc87)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(bool p0, uint256 p1, address p2, bytes32 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(bool,uint256,address,string)`.\n mstore(0x00, 0x1bb3b09a)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, 0x80)\n writeString(0xa0, p3)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(bool p0, uint256 p1, bool p2, address p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(bool,uint256,bool,address)`.\n mstore(0x00, 0x9acd3616)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(bool p0, uint256 p1, bool p2, bool p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(bool,uint256,bool,bool)`.\n mstore(0x00, 0xceb5f4d7)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(bool p0, uint256 p1, bool p2, uint256 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(bool,uint256,bool,uint256)`.\n mstore(0x00, 0x7f9bbca2)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(bool p0, uint256 p1, bool p2, bytes32 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(bool,uint256,bool,string)`.\n mstore(0x00, 0x9143dbb1)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, 0x80)\n writeString(0xa0, p3)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(bool p0, uint256 p1, uint256 p2, address p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(bool,uint256,uint256,address)`.\n mstore(0x00, 0x00dd87b9)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(bool p0, uint256 p1, uint256 p2, bool p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(bool,uint256,uint256,bool)`.\n mstore(0x00, 0xbe984353)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(bool p0, uint256 p1, uint256 p2, uint256 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(bool,uint256,uint256,uint256)`.\n mstore(0x00, 0x374bb4b2)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(bool p0, uint256 p1, uint256 p2, bytes32 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(bool,uint256,uint256,string)`.\n mstore(0x00, 0x8e69fb5d)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, 0x80)\n writeString(0xa0, p3)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(bool p0, uint256 p1, bytes32 p2, address p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(bool,uint256,string,address)`.\n mstore(0x00, 0xfedd1fff)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, 0x80)\n mstore(0x80, p3)\n writeString(0xa0, p2)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(bool p0, uint256 p1, bytes32 p2, bool p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(bool,uint256,string,bool)`.\n mstore(0x00, 0xe5e70b2b)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, 0x80)\n mstore(0x80, p3)\n writeString(0xa0, p2)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(bool p0, uint256 p1, bytes32 p2, uint256 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(bool,uint256,string,uint256)`.\n mstore(0x00, 0x6a1199e2)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, 0x80)\n mstore(0x80, p3)\n writeString(0xa0, p2)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(bool p0, uint256 p1, bytes32 p2, bytes32 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n // Selector of `log(bool,uint256,string,string)`.\n mstore(0x00, 0xf5bc2249)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, 0x80)\n mstore(0x80, 0xc0)\n writeString(0xa0, p2)\n writeString(0xe0, p3)\n }\n _sendLogPayload(0x1c, 0x104);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n }\n }\n\n function log(bool p0, bytes32 p1, address p2, address p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(bool,string,address,address)`.\n mstore(0x00, 0x2b2b18dc)\n mstore(0x20, p0)\n mstore(0x40, 0x80)\n mstore(0x60, p2)\n mstore(0x80, p3)\n writeString(0xa0, p1)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(bool p0, bytes32 p1, address p2, bool p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(bool,string,address,bool)`.\n mstore(0x00, 0x6dd434ca)\n mstore(0x20, p0)\n mstore(0x40, 0x80)\n mstore(0x60, p2)\n mstore(0x80, p3)\n writeString(0xa0, p1)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(bool p0, bytes32 p1, address p2, uint256 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(bool,string,address,uint256)`.\n mstore(0x00, 0xa5cada94)\n mstore(0x20, p0)\n mstore(0x40, 0x80)\n mstore(0x60, p2)\n mstore(0x80, p3)\n writeString(0xa0, p1)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(bool p0, bytes32 p1, address p2, bytes32 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n // Selector of `log(bool,string,address,string)`.\n mstore(0x00, 0x12d6c788)\n mstore(0x20, p0)\n mstore(0x40, 0x80)\n mstore(0x60, p2)\n mstore(0x80, 0xc0)\n writeString(0xa0, p1)\n writeString(0xe0, p3)\n }\n _sendLogPayload(0x1c, 0x104);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n }\n }\n\n function log(bool p0, bytes32 p1, bool p2, address p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(bool,string,bool,address)`.\n mstore(0x00, 0x538e06ab)\n mstore(0x20, p0)\n mstore(0x40, 0x80)\n mstore(0x60, p2)\n mstore(0x80, p3)\n writeString(0xa0, p1)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(bool p0, bytes32 p1, bool p2, bool p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(bool,string,bool,bool)`.\n mstore(0x00, 0xdc5e935b)\n mstore(0x20, p0)\n mstore(0x40, 0x80)\n mstore(0x60, p2)\n mstore(0x80, p3)\n writeString(0xa0, p1)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(bool p0, bytes32 p1, bool p2, uint256 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(bool,string,bool,uint256)`.\n mstore(0x00, 0x1606a393)\n mstore(0x20, p0)\n mstore(0x40, 0x80)\n mstore(0x60, p2)\n mstore(0x80, p3)\n writeString(0xa0, p1)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(bool p0, bytes32 p1, bool p2, bytes32 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n // Selector of `log(bool,string,bool,string)`.\n mstore(0x00, 0x483d0416)\n mstore(0x20, p0)\n mstore(0x40, 0x80)\n mstore(0x60, p2)\n mstore(0x80, 0xc0)\n writeString(0xa0, p1)\n writeString(0xe0, p3)\n }\n _sendLogPayload(0x1c, 0x104);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n }\n }\n\n function log(bool p0, bytes32 p1, uint256 p2, address p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(bool,string,uint256,address)`.\n mstore(0x00, 0x1596a1ce)\n mstore(0x20, p0)\n mstore(0x40, 0x80)\n mstore(0x60, p2)\n mstore(0x80, p3)\n writeString(0xa0, p1)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(bool p0, bytes32 p1, uint256 p2, bool p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(bool,string,uint256,bool)`.\n mstore(0x00, 0x6b0e5d53)\n mstore(0x20, p0)\n mstore(0x40, 0x80)\n mstore(0x60, p2)\n mstore(0x80, p3)\n writeString(0xa0, p1)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(bool p0, bytes32 p1, uint256 p2, uint256 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(bool,string,uint256,uint256)`.\n mstore(0x00, 0x28863fcb)\n mstore(0x20, p0)\n mstore(0x40, 0x80)\n mstore(0x60, p2)\n mstore(0x80, p3)\n writeString(0xa0, p1)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(bool p0, bytes32 p1, uint256 p2, bytes32 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n // Selector of `log(bool,string,uint256,string)`.\n mstore(0x00, 0x1ad96de6)\n mstore(0x20, p0)\n mstore(0x40, 0x80)\n mstore(0x60, p2)\n mstore(0x80, 0xc0)\n writeString(0xa0, p1)\n writeString(0xe0, p3)\n }\n _sendLogPayload(0x1c, 0x104);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n }\n }\n\n function log(bool p0, bytes32 p1, bytes32 p2, address p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n // Selector of `log(bool,string,string,address)`.\n mstore(0x00, 0x97d394d8)\n mstore(0x20, p0)\n mstore(0x40, 0x80)\n mstore(0x60, 0xc0)\n mstore(0x80, p3)\n writeString(0xa0, p1)\n writeString(0xe0, p2)\n }\n _sendLogPayload(0x1c, 0x104);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n }\n }\n\n function log(bool p0, bytes32 p1, bytes32 p2, bool p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n // Selector of `log(bool,string,string,bool)`.\n mstore(0x00, 0x1e4b87e5)\n mstore(0x20, p0)\n mstore(0x40, 0x80)\n mstore(0x60, 0xc0)\n mstore(0x80, p3)\n writeString(0xa0, p1)\n writeString(0xe0, p2)\n }\n _sendLogPayload(0x1c, 0x104);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n }\n }\n\n function log(bool p0, bytes32 p1, bytes32 p2, uint256 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n // Selector of `log(bool,string,string,uint256)`.\n mstore(0x00, 0x7be0c3eb)\n mstore(0x20, p0)\n mstore(0x40, 0x80)\n mstore(0x60, 0xc0)\n mstore(0x80, p3)\n writeString(0xa0, p1)\n writeString(0xe0, p2)\n }\n _sendLogPayload(0x1c, 0x104);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n }\n }\n\n function log(bool p0, bytes32 p1, bytes32 p2, bytes32 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n bytes32 m9;\n bytes32 m10;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n m9 := mload(0x120)\n m10 := mload(0x140)\n // Selector of `log(bool,string,string,string)`.\n mstore(0x00, 0x1762e32a)\n mstore(0x20, p0)\n mstore(0x40, 0x80)\n mstore(0x60, 0xc0)\n mstore(0x80, 0x100)\n writeString(0xa0, p1)\n writeString(0xe0, p2)\n writeString(0x120, p3)\n }\n _sendLogPayload(0x1c, 0x144);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n mstore(0x120, m9)\n mstore(0x140, m10)\n }\n }\n\n function log(uint256 p0, address p1, address p2, address p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(uint256,address,address,address)`.\n mstore(0x00, 0x2488b414)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(uint256 p0, address p1, address p2, bool p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(uint256,address,address,bool)`.\n mstore(0x00, 0x091ffaf5)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(uint256 p0, address p1, address p2, uint256 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(uint256,address,address,uint256)`.\n mstore(0x00, 0x736efbb6)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(uint256 p0, address p1, address p2, bytes32 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(uint256,address,address,string)`.\n mstore(0x00, 0x031c6f73)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, 0x80)\n writeString(0xa0, p3)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(uint256 p0, address p1, bool p2, address p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(uint256,address,bool,address)`.\n mstore(0x00, 0xef72c513)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(uint256 p0, address p1, bool p2, bool p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(uint256,address,bool,bool)`.\n mstore(0x00, 0xe351140f)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(uint256 p0, address p1, bool p2, uint256 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(uint256,address,bool,uint256)`.\n mstore(0x00, 0x5abd992a)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(uint256 p0, address p1, bool p2, bytes32 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(uint256,address,bool,string)`.\n mstore(0x00, 0x90fb06aa)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, 0x80)\n writeString(0xa0, p3)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(uint256 p0, address p1, uint256 p2, address p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(uint256,address,uint256,address)`.\n mstore(0x00, 0x15c127b5)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(uint256 p0, address p1, uint256 p2, bool p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(uint256,address,uint256,bool)`.\n mstore(0x00, 0x5f743a7c)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(uint256 p0, address p1, uint256 p2, uint256 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(uint256,address,uint256,uint256)`.\n mstore(0x00, 0x0c9cd9c1)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(uint256 p0, address p1, uint256 p2, bytes32 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(uint256,address,uint256,string)`.\n mstore(0x00, 0xddb06521)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, 0x80)\n writeString(0xa0, p3)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(uint256 p0, address p1, bytes32 p2, address p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(uint256,address,string,address)`.\n mstore(0x00, 0x9cba8fff)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, 0x80)\n mstore(0x80, p3)\n writeString(0xa0, p2)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(uint256 p0, address p1, bytes32 p2, bool p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(uint256,address,string,bool)`.\n mstore(0x00, 0xcc32ab07)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, 0x80)\n mstore(0x80, p3)\n writeString(0xa0, p2)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(uint256 p0, address p1, bytes32 p2, uint256 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(uint256,address,string,uint256)`.\n mstore(0x00, 0x46826b5d)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, 0x80)\n mstore(0x80, p3)\n writeString(0xa0, p2)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(uint256 p0, address p1, bytes32 p2, bytes32 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n // Selector of `log(uint256,address,string,string)`.\n mstore(0x00, 0x3e128ca3)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, 0x80)\n mstore(0x80, 0xc0)\n writeString(0xa0, p2)\n writeString(0xe0, p3)\n }\n _sendLogPayload(0x1c, 0x104);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n }\n }\n\n function log(uint256 p0, bool p1, address p2, address p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(uint256,bool,address,address)`.\n mstore(0x00, 0xa1ef4cbb)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(uint256 p0, bool p1, address p2, bool p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(uint256,bool,address,bool)`.\n mstore(0x00, 0x454d54a5)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(uint256 p0, bool p1, address p2, uint256 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(uint256,bool,address,uint256)`.\n mstore(0x00, 0x078287f5)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(uint256 p0, bool p1, address p2, bytes32 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(uint256,bool,address,string)`.\n mstore(0x00, 0xade052c7)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, 0x80)\n writeString(0xa0, p3)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(uint256 p0, bool p1, bool p2, address p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(uint256,bool,bool,address)`.\n mstore(0x00, 0x69640b59)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(uint256 p0, bool p1, bool p2, bool p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(uint256,bool,bool,bool)`.\n mstore(0x00, 0xb6f577a1)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(uint256 p0, bool p1, bool p2, uint256 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(uint256,bool,bool,uint256)`.\n mstore(0x00, 0x7464ce23)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(uint256 p0, bool p1, bool p2, bytes32 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(uint256,bool,bool,string)`.\n mstore(0x00, 0xdddb9561)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, 0x80)\n writeString(0xa0, p3)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(uint256 p0, bool p1, uint256 p2, address p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(uint256,bool,uint256,address)`.\n mstore(0x00, 0x88cb6041)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(uint256 p0, bool p1, uint256 p2, bool p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(uint256,bool,uint256,bool)`.\n mstore(0x00, 0x91a02e2a)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(uint256 p0, bool p1, uint256 p2, uint256 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(uint256,bool,uint256,uint256)`.\n mstore(0x00, 0xc6acc7a8)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(uint256 p0, bool p1, uint256 p2, bytes32 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(uint256,bool,uint256,string)`.\n mstore(0x00, 0xde03e774)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, 0x80)\n writeString(0xa0, p3)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(uint256 p0, bool p1, bytes32 p2, address p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(uint256,bool,string,address)`.\n mstore(0x00, 0xef529018)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, 0x80)\n mstore(0x80, p3)\n writeString(0xa0, p2)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(uint256 p0, bool p1, bytes32 p2, bool p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(uint256,bool,string,bool)`.\n mstore(0x00, 0xeb928d7f)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, 0x80)\n mstore(0x80, p3)\n writeString(0xa0, p2)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(uint256 p0, bool p1, bytes32 p2, uint256 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(uint256,bool,string,uint256)`.\n mstore(0x00, 0x2c1d0746)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, 0x80)\n mstore(0x80, p3)\n writeString(0xa0, p2)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(uint256 p0, bool p1, bytes32 p2, bytes32 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n // Selector of `log(uint256,bool,string,string)`.\n mstore(0x00, 0x68c8b8bd)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, 0x80)\n mstore(0x80, 0xc0)\n writeString(0xa0, p2)\n writeString(0xe0, p3)\n }\n _sendLogPayload(0x1c, 0x104);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n }\n }\n\n function log(uint256 p0, uint256 p1, address p2, address p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(uint256,uint256,address,address)`.\n mstore(0x00, 0x56a5d1b1)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(uint256 p0, uint256 p1, address p2, bool p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(uint256,uint256,address,bool)`.\n mstore(0x00, 0x15cac476)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(uint256 p0, uint256 p1, address p2, uint256 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(uint256,uint256,address,uint256)`.\n mstore(0x00, 0x88f6e4b2)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(uint256 p0, uint256 p1, address p2, bytes32 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(uint256,uint256,address,string)`.\n mstore(0x00, 0x6cde40b8)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, 0x80)\n writeString(0xa0, p3)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(uint256 p0, uint256 p1, bool p2, address p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(uint256,uint256,bool,address)`.\n mstore(0x00, 0x9a816a83)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(uint256 p0, uint256 p1, bool p2, bool p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(uint256,uint256,bool,bool)`.\n mstore(0x00, 0xab085ae6)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(uint256 p0, uint256 p1, bool p2, uint256 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(uint256,uint256,bool,uint256)`.\n mstore(0x00, 0xeb7f6fd2)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(uint256 p0, uint256 p1, bool p2, bytes32 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(uint256,uint256,bool,string)`.\n mstore(0x00, 0xa5b4fc99)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, 0x80)\n writeString(0xa0, p3)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(uint256 p0, uint256 p1, uint256 p2, address p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(uint256,uint256,uint256,address)`.\n mstore(0x00, 0xfa8185af)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(uint256 p0, uint256 p1, uint256 p2, bool p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(uint256,uint256,uint256,bool)`.\n mstore(0x00, 0xc598d185)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(uint256 p0, uint256 p1, uint256 p2, uint256 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n /// @solidity memory-safe-assembly\n assembly {\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n // Selector of `log(uint256,uint256,uint256,uint256)`.\n mstore(0x00, 0x193fb800)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n }\n _sendLogPayload(0x1c, 0x84);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n }\n }\n\n function log(uint256 p0, uint256 p1, uint256 p2, bytes32 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(uint256,uint256,uint256,string)`.\n mstore(0x00, 0x59cfcbe3)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, 0x80)\n writeString(0xa0, p3)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(uint256 p0, uint256 p1, bytes32 p2, address p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(uint256,uint256,string,address)`.\n mstore(0x00, 0x42d21db7)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, 0x80)\n mstore(0x80, p3)\n writeString(0xa0, p2)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(uint256 p0, uint256 p1, bytes32 p2, bool p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(uint256,uint256,string,bool)`.\n mstore(0x00, 0x7af6ab25)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, 0x80)\n mstore(0x80, p3)\n writeString(0xa0, p2)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(uint256 p0, uint256 p1, bytes32 p2, uint256 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(uint256,uint256,string,uint256)`.\n mstore(0x00, 0x5da297eb)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, 0x80)\n mstore(0x80, p3)\n writeString(0xa0, p2)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(uint256 p0, uint256 p1, bytes32 p2, bytes32 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n // Selector of `log(uint256,uint256,string,string)`.\n mstore(0x00, 0x27d8afd2)\n mstore(0x20, p0)\n mstore(0x40, p1)\n mstore(0x60, 0x80)\n mstore(0x80, 0xc0)\n writeString(0xa0, p2)\n writeString(0xe0, p3)\n }\n _sendLogPayload(0x1c, 0x104);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n }\n }\n\n function log(uint256 p0, bytes32 p1, address p2, address p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(uint256,string,address,address)`.\n mstore(0x00, 0x6168ed61)\n mstore(0x20, p0)\n mstore(0x40, 0x80)\n mstore(0x60, p2)\n mstore(0x80, p3)\n writeString(0xa0, p1)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(uint256 p0, bytes32 p1, address p2, bool p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(uint256,string,address,bool)`.\n mstore(0x00, 0x90c30a56)\n mstore(0x20, p0)\n mstore(0x40, 0x80)\n mstore(0x60, p2)\n mstore(0x80, p3)\n writeString(0xa0, p1)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(uint256 p0, bytes32 p1, address p2, uint256 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(uint256,string,address,uint256)`.\n mstore(0x00, 0xe8d3018d)\n mstore(0x20, p0)\n mstore(0x40, 0x80)\n mstore(0x60, p2)\n mstore(0x80, p3)\n writeString(0xa0, p1)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(uint256 p0, bytes32 p1, address p2, bytes32 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n // Selector of `log(uint256,string,address,string)`.\n mstore(0x00, 0x9c3adfa1)\n mstore(0x20, p0)\n mstore(0x40, 0x80)\n mstore(0x60, p2)\n mstore(0x80, 0xc0)\n writeString(0xa0, p1)\n writeString(0xe0, p3)\n }\n _sendLogPayload(0x1c, 0x104);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n }\n }\n\n function log(uint256 p0, bytes32 p1, bool p2, address p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(uint256,string,bool,address)`.\n mstore(0x00, 0xae2ec581)\n mstore(0x20, p0)\n mstore(0x40, 0x80)\n mstore(0x60, p2)\n mstore(0x80, p3)\n writeString(0xa0, p1)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(uint256 p0, bytes32 p1, bool p2, bool p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(uint256,string,bool,bool)`.\n mstore(0x00, 0xba535d9c)\n mstore(0x20, p0)\n mstore(0x40, 0x80)\n mstore(0x60, p2)\n mstore(0x80, p3)\n writeString(0xa0, p1)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(uint256 p0, bytes32 p1, bool p2, uint256 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(uint256,string,bool,uint256)`.\n mstore(0x00, 0xcf009880)\n mstore(0x20, p0)\n mstore(0x40, 0x80)\n mstore(0x60, p2)\n mstore(0x80, p3)\n writeString(0xa0, p1)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(uint256 p0, bytes32 p1, bool p2, bytes32 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n // Selector of `log(uint256,string,bool,string)`.\n mstore(0x00, 0xd2d423cd)\n mstore(0x20, p0)\n mstore(0x40, 0x80)\n mstore(0x60, p2)\n mstore(0x80, 0xc0)\n writeString(0xa0, p1)\n writeString(0xe0, p3)\n }\n _sendLogPayload(0x1c, 0x104);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n }\n }\n\n function log(uint256 p0, bytes32 p1, uint256 p2, address p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(uint256,string,uint256,address)`.\n mstore(0x00, 0x3b2279b4)\n mstore(0x20, p0)\n mstore(0x40, 0x80)\n mstore(0x60, p2)\n mstore(0x80, p3)\n writeString(0xa0, p1)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(uint256 p0, bytes32 p1, uint256 p2, bool p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(uint256,string,uint256,bool)`.\n mstore(0x00, 0x691a8f74)\n mstore(0x20, p0)\n mstore(0x40, 0x80)\n mstore(0x60, p2)\n mstore(0x80, p3)\n writeString(0xa0, p1)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(uint256 p0, bytes32 p1, uint256 p2, uint256 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(uint256,string,uint256,uint256)`.\n mstore(0x00, 0x82c25b74)\n mstore(0x20, p0)\n mstore(0x40, 0x80)\n mstore(0x60, p2)\n mstore(0x80, p3)\n writeString(0xa0, p1)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(uint256 p0, bytes32 p1, uint256 p2, bytes32 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n // Selector of `log(uint256,string,uint256,string)`.\n mstore(0x00, 0xb7b914ca)\n mstore(0x20, p0)\n mstore(0x40, 0x80)\n mstore(0x60, p2)\n mstore(0x80, 0xc0)\n writeString(0xa0, p1)\n writeString(0xe0, p3)\n }\n _sendLogPayload(0x1c, 0x104);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n }\n }\n\n function log(uint256 p0, bytes32 p1, bytes32 p2, address p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n // Selector of `log(uint256,string,string,address)`.\n mstore(0x00, 0xd583c602)\n mstore(0x20, p0)\n mstore(0x40, 0x80)\n mstore(0x60, 0xc0)\n mstore(0x80, p3)\n writeString(0xa0, p1)\n writeString(0xe0, p2)\n }\n _sendLogPayload(0x1c, 0x104);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n }\n }\n\n function log(uint256 p0, bytes32 p1, bytes32 p2, bool p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n // Selector of `log(uint256,string,string,bool)`.\n mstore(0x00, 0xb3a6b6bd)\n mstore(0x20, p0)\n mstore(0x40, 0x80)\n mstore(0x60, 0xc0)\n mstore(0x80, p3)\n writeString(0xa0, p1)\n writeString(0xe0, p2)\n }\n _sendLogPayload(0x1c, 0x104);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n }\n }\n\n function log(uint256 p0, bytes32 p1, bytes32 p2, uint256 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n // Selector of `log(uint256,string,string,uint256)`.\n mstore(0x00, 0xb028c9bd)\n mstore(0x20, p0)\n mstore(0x40, 0x80)\n mstore(0x60, 0xc0)\n mstore(0x80, p3)\n writeString(0xa0, p1)\n writeString(0xe0, p2)\n }\n _sendLogPayload(0x1c, 0x104);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n }\n }\n\n function log(uint256 p0, bytes32 p1, bytes32 p2, bytes32 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n bytes32 m9;\n bytes32 m10;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n m9 := mload(0x120)\n m10 := mload(0x140)\n // Selector of `log(uint256,string,string,string)`.\n mstore(0x00, 0x21ad0683)\n mstore(0x20, p0)\n mstore(0x40, 0x80)\n mstore(0x60, 0xc0)\n mstore(0x80, 0x100)\n writeString(0xa0, p1)\n writeString(0xe0, p2)\n writeString(0x120, p3)\n }\n _sendLogPayload(0x1c, 0x144);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n mstore(0x120, m9)\n mstore(0x140, m10)\n }\n }\n\n function log(bytes32 p0, address p1, address p2, address p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(string,address,address,address)`.\n mstore(0x00, 0xed8f28f6)\n mstore(0x20, 0x80)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n writeString(0xa0, p0)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(bytes32 p0, address p1, address p2, bool p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(string,address,address,bool)`.\n mstore(0x00, 0xb59dbd60)\n mstore(0x20, 0x80)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n writeString(0xa0, p0)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(bytes32 p0, address p1, address p2, uint256 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(string,address,address,uint256)`.\n mstore(0x00, 0x8ef3f399)\n mstore(0x20, 0x80)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n writeString(0xa0, p0)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(bytes32 p0, address p1, address p2, bytes32 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n // Selector of `log(string,address,address,string)`.\n mstore(0x00, 0x800a1c67)\n mstore(0x20, 0x80)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, 0xc0)\n writeString(0xa0, p0)\n writeString(0xe0, p3)\n }\n _sendLogPayload(0x1c, 0x104);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n }\n }\n\n function log(bytes32 p0, address p1, bool p2, address p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(string,address,bool,address)`.\n mstore(0x00, 0x223603bd)\n mstore(0x20, 0x80)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n writeString(0xa0, p0)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(bytes32 p0, address p1, bool p2, bool p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(string,address,bool,bool)`.\n mstore(0x00, 0x79884c2b)\n mstore(0x20, 0x80)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n writeString(0xa0, p0)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(bytes32 p0, address p1, bool p2, uint256 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(string,address,bool,uint256)`.\n mstore(0x00, 0x3e9f866a)\n mstore(0x20, 0x80)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n writeString(0xa0, p0)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(bytes32 p0, address p1, bool p2, bytes32 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n // Selector of `log(string,address,bool,string)`.\n mstore(0x00, 0x0454c079)\n mstore(0x20, 0x80)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, 0xc0)\n writeString(0xa0, p0)\n writeString(0xe0, p3)\n }\n _sendLogPayload(0x1c, 0x104);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n }\n }\n\n function log(bytes32 p0, address p1, uint256 p2, address p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(string,address,uint256,address)`.\n mstore(0x00, 0x63fb8bc5)\n mstore(0x20, 0x80)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n writeString(0xa0, p0)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(bytes32 p0, address p1, uint256 p2, bool p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(string,address,uint256,bool)`.\n mstore(0x00, 0xfc4845f0)\n mstore(0x20, 0x80)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n writeString(0xa0, p0)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(bytes32 p0, address p1, uint256 p2, uint256 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(string,address,uint256,uint256)`.\n mstore(0x00, 0xf8f51b1e)\n mstore(0x20, 0x80)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n writeString(0xa0, p0)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(bytes32 p0, address p1, uint256 p2, bytes32 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n // Selector of `log(string,address,uint256,string)`.\n mstore(0x00, 0x5a477632)\n mstore(0x20, 0x80)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, 0xc0)\n writeString(0xa0, p0)\n writeString(0xe0, p3)\n }\n _sendLogPayload(0x1c, 0x104);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n }\n }\n\n function log(bytes32 p0, address p1, bytes32 p2, address p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n // Selector of `log(string,address,string,address)`.\n mstore(0x00, 0xaabc9a31)\n mstore(0x20, 0x80)\n mstore(0x40, p1)\n mstore(0x60, 0xc0)\n mstore(0x80, p3)\n writeString(0xa0, p0)\n writeString(0xe0, p2)\n }\n _sendLogPayload(0x1c, 0x104);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n }\n }\n\n function log(bytes32 p0, address p1, bytes32 p2, bool p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n // Selector of `log(string,address,string,bool)`.\n mstore(0x00, 0x5f15d28c)\n mstore(0x20, 0x80)\n mstore(0x40, p1)\n mstore(0x60, 0xc0)\n mstore(0x80, p3)\n writeString(0xa0, p0)\n writeString(0xe0, p2)\n }\n _sendLogPayload(0x1c, 0x104);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n }\n }\n\n function log(bytes32 p0, address p1, bytes32 p2, uint256 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n // Selector of `log(string,address,string,uint256)`.\n mstore(0x00, 0x91d1112e)\n mstore(0x20, 0x80)\n mstore(0x40, p1)\n mstore(0x60, 0xc0)\n mstore(0x80, p3)\n writeString(0xa0, p0)\n writeString(0xe0, p2)\n }\n _sendLogPayload(0x1c, 0x104);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n }\n }\n\n function log(bytes32 p0, address p1, bytes32 p2, bytes32 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n bytes32 m9;\n bytes32 m10;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n m9 := mload(0x120)\n m10 := mload(0x140)\n // Selector of `log(string,address,string,string)`.\n mstore(0x00, 0x245986f2)\n mstore(0x20, 0x80)\n mstore(0x40, p1)\n mstore(0x60, 0xc0)\n mstore(0x80, 0x100)\n writeString(0xa0, p0)\n writeString(0xe0, p2)\n writeString(0x120, p3)\n }\n _sendLogPayload(0x1c, 0x144);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n mstore(0x120, m9)\n mstore(0x140, m10)\n }\n }\n\n function log(bytes32 p0, bool p1, address p2, address p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(string,bool,address,address)`.\n mstore(0x00, 0x33e9dd1d)\n mstore(0x20, 0x80)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n writeString(0xa0, p0)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(bytes32 p0, bool p1, address p2, bool p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(string,bool,address,bool)`.\n mstore(0x00, 0x958c28c6)\n mstore(0x20, 0x80)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n writeString(0xa0, p0)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(bytes32 p0, bool p1, address p2, uint256 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(string,bool,address,uint256)`.\n mstore(0x00, 0x5d08bb05)\n mstore(0x20, 0x80)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n writeString(0xa0, p0)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(bytes32 p0, bool p1, address p2, bytes32 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n // Selector of `log(string,bool,address,string)`.\n mstore(0x00, 0x2d8e33a4)\n mstore(0x20, 0x80)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, 0xc0)\n writeString(0xa0, p0)\n writeString(0xe0, p3)\n }\n _sendLogPayload(0x1c, 0x104);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n }\n }\n\n function log(bytes32 p0, bool p1, bool p2, address p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(string,bool,bool,address)`.\n mstore(0x00, 0x7190a529)\n mstore(0x20, 0x80)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n writeString(0xa0, p0)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(bytes32 p0, bool p1, bool p2, bool p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(string,bool,bool,bool)`.\n mstore(0x00, 0x895af8c5)\n mstore(0x20, 0x80)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n writeString(0xa0, p0)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(bytes32 p0, bool p1, bool p2, uint256 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(string,bool,bool,uint256)`.\n mstore(0x00, 0x8e3f78a9)\n mstore(0x20, 0x80)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n writeString(0xa0, p0)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(bytes32 p0, bool p1, bool p2, bytes32 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n // Selector of `log(string,bool,bool,string)`.\n mstore(0x00, 0x9d22d5dd)\n mstore(0x20, 0x80)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, 0xc0)\n writeString(0xa0, p0)\n writeString(0xe0, p3)\n }\n _sendLogPayload(0x1c, 0x104);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n }\n }\n\n function log(bytes32 p0, bool p1, uint256 p2, address p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(string,bool,uint256,address)`.\n mstore(0x00, 0x935e09bf)\n mstore(0x20, 0x80)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n writeString(0xa0, p0)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(bytes32 p0, bool p1, uint256 p2, bool p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(string,bool,uint256,bool)`.\n mstore(0x00, 0x8af7cf8a)\n mstore(0x20, 0x80)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n writeString(0xa0, p0)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(bytes32 p0, bool p1, uint256 p2, uint256 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(string,bool,uint256,uint256)`.\n mstore(0x00, 0x64b5bb67)\n mstore(0x20, 0x80)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n writeString(0xa0, p0)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(bytes32 p0, bool p1, uint256 p2, bytes32 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n // Selector of `log(string,bool,uint256,string)`.\n mstore(0x00, 0x742d6ee7)\n mstore(0x20, 0x80)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, 0xc0)\n writeString(0xa0, p0)\n writeString(0xe0, p3)\n }\n _sendLogPayload(0x1c, 0x104);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n }\n }\n\n function log(bytes32 p0, bool p1, bytes32 p2, address p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n // Selector of `log(string,bool,string,address)`.\n mstore(0x00, 0xe0625b29)\n mstore(0x20, 0x80)\n mstore(0x40, p1)\n mstore(0x60, 0xc0)\n mstore(0x80, p3)\n writeString(0xa0, p0)\n writeString(0xe0, p2)\n }\n _sendLogPayload(0x1c, 0x104);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n }\n }\n\n function log(bytes32 p0, bool p1, bytes32 p2, bool p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n // Selector of `log(string,bool,string,bool)`.\n mstore(0x00, 0x3f8a701d)\n mstore(0x20, 0x80)\n mstore(0x40, p1)\n mstore(0x60, 0xc0)\n mstore(0x80, p3)\n writeString(0xa0, p0)\n writeString(0xe0, p2)\n }\n _sendLogPayload(0x1c, 0x104);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n }\n }\n\n function log(bytes32 p0, bool p1, bytes32 p2, uint256 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n // Selector of `log(string,bool,string,uint256)`.\n mstore(0x00, 0x24f91465)\n mstore(0x20, 0x80)\n mstore(0x40, p1)\n mstore(0x60, 0xc0)\n mstore(0x80, p3)\n writeString(0xa0, p0)\n writeString(0xe0, p2)\n }\n _sendLogPayload(0x1c, 0x104);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n }\n }\n\n function log(bytes32 p0, bool p1, bytes32 p2, bytes32 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n bytes32 m9;\n bytes32 m10;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n m9 := mload(0x120)\n m10 := mload(0x140)\n // Selector of `log(string,bool,string,string)`.\n mstore(0x00, 0xa826caeb)\n mstore(0x20, 0x80)\n mstore(0x40, p1)\n mstore(0x60, 0xc0)\n mstore(0x80, 0x100)\n writeString(0xa0, p0)\n writeString(0xe0, p2)\n writeString(0x120, p3)\n }\n _sendLogPayload(0x1c, 0x144);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n mstore(0x120, m9)\n mstore(0x140, m10)\n }\n }\n\n function log(bytes32 p0, uint256 p1, address p2, address p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(string,uint256,address,address)`.\n mstore(0x00, 0x5ea2b7ae)\n mstore(0x20, 0x80)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n writeString(0xa0, p0)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(bytes32 p0, uint256 p1, address p2, bool p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(string,uint256,address,bool)`.\n mstore(0x00, 0x82112a42)\n mstore(0x20, 0x80)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n writeString(0xa0, p0)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(bytes32 p0, uint256 p1, address p2, uint256 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(string,uint256,address,uint256)`.\n mstore(0x00, 0x4f04fdc6)\n mstore(0x20, 0x80)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n writeString(0xa0, p0)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(bytes32 p0, uint256 p1, address p2, bytes32 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n // Selector of `log(string,uint256,address,string)`.\n mstore(0x00, 0x9ffb2f93)\n mstore(0x20, 0x80)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, 0xc0)\n writeString(0xa0, p0)\n writeString(0xe0, p3)\n }\n _sendLogPayload(0x1c, 0x104);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n }\n }\n\n function log(bytes32 p0, uint256 p1, bool p2, address p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(string,uint256,bool,address)`.\n mstore(0x00, 0xe0e95b98)\n mstore(0x20, 0x80)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n writeString(0xa0, p0)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(bytes32 p0, uint256 p1, bool p2, bool p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(string,uint256,bool,bool)`.\n mstore(0x00, 0x354c36d6)\n mstore(0x20, 0x80)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n writeString(0xa0, p0)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(bytes32 p0, uint256 p1, bool p2, uint256 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(string,uint256,bool,uint256)`.\n mstore(0x00, 0xe41b6f6f)\n mstore(0x20, 0x80)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n writeString(0xa0, p0)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(bytes32 p0, uint256 p1, bool p2, bytes32 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n // Selector of `log(string,uint256,bool,string)`.\n mstore(0x00, 0xabf73a98)\n mstore(0x20, 0x80)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, 0xc0)\n writeString(0xa0, p0)\n writeString(0xe0, p3)\n }\n _sendLogPayload(0x1c, 0x104);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n }\n }\n\n function log(bytes32 p0, uint256 p1, uint256 p2, address p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(string,uint256,uint256,address)`.\n mstore(0x00, 0xe21de278)\n mstore(0x20, 0x80)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n writeString(0xa0, p0)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(bytes32 p0, uint256 p1, uint256 p2, bool p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(string,uint256,uint256,bool)`.\n mstore(0x00, 0x7626db92)\n mstore(0x20, 0x80)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n writeString(0xa0, p0)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(bytes32 p0, uint256 p1, uint256 p2, uint256 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n // Selector of `log(string,uint256,uint256,uint256)`.\n mstore(0x00, 0xa7a87853)\n mstore(0x20, 0x80)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, p3)\n writeString(0xa0, p0)\n }\n _sendLogPayload(0x1c, 0xc4);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n }\n }\n\n function log(bytes32 p0, uint256 p1, uint256 p2, bytes32 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n // Selector of `log(string,uint256,uint256,string)`.\n mstore(0x00, 0x854b3496)\n mstore(0x20, 0x80)\n mstore(0x40, p1)\n mstore(0x60, p2)\n mstore(0x80, 0xc0)\n writeString(0xa0, p0)\n writeString(0xe0, p3)\n }\n _sendLogPayload(0x1c, 0x104);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n }\n }\n\n function log(bytes32 p0, uint256 p1, bytes32 p2, address p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n // Selector of `log(string,uint256,string,address)`.\n mstore(0x00, 0x7c4632a4)\n mstore(0x20, 0x80)\n mstore(0x40, p1)\n mstore(0x60, 0xc0)\n mstore(0x80, p3)\n writeString(0xa0, p0)\n writeString(0xe0, p2)\n }\n _sendLogPayload(0x1c, 0x104);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n }\n }\n\n function log(bytes32 p0, uint256 p1, bytes32 p2, bool p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n // Selector of `log(string,uint256,string,bool)`.\n mstore(0x00, 0x7d24491d)\n mstore(0x20, 0x80)\n mstore(0x40, p1)\n mstore(0x60, 0xc0)\n mstore(0x80, p3)\n writeString(0xa0, p0)\n writeString(0xe0, p2)\n }\n _sendLogPayload(0x1c, 0x104);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n }\n }\n\n function log(bytes32 p0, uint256 p1, bytes32 p2, uint256 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n // Selector of `log(string,uint256,string,uint256)`.\n mstore(0x00, 0xc67ea9d1)\n mstore(0x20, 0x80)\n mstore(0x40, p1)\n mstore(0x60, 0xc0)\n mstore(0x80, p3)\n writeString(0xa0, p0)\n writeString(0xe0, p2)\n }\n _sendLogPayload(0x1c, 0x104);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n }\n }\n\n function log(bytes32 p0, uint256 p1, bytes32 p2, bytes32 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n bytes32 m9;\n bytes32 m10;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n m9 := mload(0x120)\n m10 := mload(0x140)\n // Selector of `log(string,uint256,string,string)`.\n mstore(0x00, 0x5ab84e1f)\n mstore(0x20, 0x80)\n mstore(0x40, p1)\n mstore(0x60, 0xc0)\n mstore(0x80, 0x100)\n writeString(0xa0, p0)\n writeString(0xe0, p2)\n writeString(0x120, p3)\n }\n _sendLogPayload(0x1c, 0x144);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n mstore(0x120, m9)\n mstore(0x140, m10)\n }\n }\n\n function log(bytes32 p0, bytes32 p1, address p2, address p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n // Selector of `log(string,string,address,address)`.\n mstore(0x00, 0x439c7bef)\n mstore(0x20, 0x80)\n mstore(0x40, 0xc0)\n mstore(0x60, p2)\n mstore(0x80, p3)\n writeString(0xa0, p0)\n writeString(0xe0, p1)\n }\n _sendLogPayload(0x1c, 0x104);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n }\n }\n\n function log(bytes32 p0, bytes32 p1, address p2, bool p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n // Selector of `log(string,string,address,bool)`.\n mstore(0x00, 0x5ccd4e37)\n mstore(0x20, 0x80)\n mstore(0x40, 0xc0)\n mstore(0x60, p2)\n mstore(0x80, p3)\n writeString(0xa0, p0)\n writeString(0xe0, p1)\n }\n _sendLogPayload(0x1c, 0x104);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n }\n }\n\n function log(bytes32 p0, bytes32 p1, address p2, uint256 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n // Selector of `log(string,string,address,uint256)`.\n mstore(0x00, 0x7cc3c607)\n mstore(0x20, 0x80)\n mstore(0x40, 0xc0)\n mstore(0x60, p2)\n mstore(0x80, p3)\n writeString(0xa0, p0)\n writeString(0xe0, p1)\n }\n _sendLogPayload(0x1c, 0x104);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n }\n }\n\n function log(bytes32 p0, bytes32 p1, address p2, bytes32 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n bytes32 m9;\n bytes32 m10;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n m9 := mload(0x120)\n m10 := mload(0x140)\n // Selector of `log(string,string,address,string)`.\n mstore(0x00, 0xeb1bff80)\n mstore(0x20, 0x80)\n mstore(0x40, 0xc0)\n mstore(0x60, p2)\n mstore(0x80, 0x100)\n writeString(0xa0, p0)\n writeString(0xe0, p1)\n writeString(0x120, p3)\n }\n _sendLogPayload(0x1c, 0x144);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n mstore(0x120, m9)\n mstore(0x140, m10)\n }\n }\n\n function log(bytes32 p0, bytes32 p1, bool p2, address p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n // Selector of `log(string,string,bool,address)`.\n mstore(0x00, 0xc371c7db)\n mstore(0x20, 0x80)\n mstore(0x40, 0xc0)\n mstore(0x60, p2)\n mstore(0x80, p3)\n writeString(0xa0, p0)\n writeString(0xe0, p1)\n }\n _sendLogPayload(0x1c, 0x104);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n }\n }\n\n function log(bytes32 p0, bytes32 p1, bool p2, bool p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n // Selector of `log(string,string,bool,bool)`.\n mstore(0x00, 0x40785869)\n mstore(0x20, 0x80)\n mstore(0x40, 0xc0)\n mstore(0x60, p2)\n mstore(0x80, p3)\n writeString(0xa0, p0)\n writeString(0xe0, p1)\n }\n _sendLogPayload(0x1c, 0x104);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n }\n }\n\n function log(bytes32 p0, bytes32 p1, bool p2, uint256 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n // Selector of `log(string,string,bool,uint256)`.\n mstore(0x00, 0xd6aefad2)\n mstore(0x20, 0x80)\n mstore(0x40, 0xc0)\n mstore(0x60, p2)\n mstore(0x80, p3)\n writeString(0xa0, p0)\n writeString(0xe0, p1)\n }\n _sendLogPayload(0x1c, 0x104);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n }\n }\n\n function log(bytes32 p0, bytes32 p1, bool p2, bytes32 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n bytes32 m9;\n bytes32 m10;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n m9 := mload(0x120)\n m10 := mload(0x140)\n // Selector of `log(string,string,bool,string)`.\n mstore(0x00, 0x5e84b0ea)\n mstore(0x20, 0x80)\n mstore(0x40, 0xc0)\n mstore(0x60, p2)\n mstore(0x80, 0x100)\n writeString(0xa0, p0)\n writeString(0xe0, p1)\n writeString(0x120, p3)\n }\n _sendLogPayload(0x1c, 0x144);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n mstore(0x120, m9)\n mstore(0x140, m10)\n }\n }\n\n function log(bytes32 p0, bytes32 p1, uint256 p2, address p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n // Selector of `log(string,string,uint256,address)`.\n mstore(0x00, 0x1023f7b2)\n mstore(0x20, 0x80)\n mstore(0x40, 0xc0)\n mstore(0x60, p2)\n mstore(0x80, p3)\n writeString(0xa0, p0)\n writeString(0xe0, p1)\n }\n _sendLogPayload(0x1c, 0x104);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n }\n }\n\n function log(bytes32 p0, bytes32 p1, uint256 p2, bool p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n // Selector of `log(string,string,uint256,bool)`.\n mstore(0x00, 0xc3a8a654)\n mstore(0x20, 0x80)\n mstore(0x40, 0xc0)\n mstore(0x60, p2)\n mstore(0x80, p3)\n writeString(0xa0, p0)\n writeString(0xe0, p1)\n }\n _sendLogPayload(0x1c, 0x104);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n }\n }\n\n function log(bytes32 p0, bytes32 p1, uint256 p2, uint256 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n // Selector of `log(string,string,uint256,uint256)`.\n mstore(0x00, 0xf45d7d2c)\n mstore(0x20, 0x80)\n mstore(0x40, 0xc0)\n mstore(0x60, p2)\n mstore(0x80, p3)\n writeString(0xa0, p0)\n writeString(0xe0, p1)\n }\n _sendLogPayload(0x1c, 0x104);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n }\n }\n\n function log(bytes32 p0, bytes32 p1, uint256 p2, bytes32 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n bytes32 m9;\n bytes32 m10;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n m9 := mload(0x120)\n m10 := mload(0x140)\n // Selector of `log(string,string,uint256,string)`.\n mstore(0x00, 0x5d1a971a)\n mstore(0x20, 0x80)\n mstore(0x40, 0xc0)\n mstore(0x60, p2)\n mstore(0x80, 0x100)\n writeString(0xa0, p0)\n writeString(0xe0, p1)\n writeString(0x120, p3)\n }\n _sendLogPayload(0x1c, 0x144);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n mstore(0x120, m9)\n mstore(0x140, m10)\n }\n }\n\n function log(bytes32 p0, bytes32 p1, bytes32 p2, address p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n bytes32 m9;\n bytes32 m10;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n m9 := mload(0x120)\n m10 := mload(0x140)\n // Selector of `log(string,string,string,address)`.\n mstore(0x00, 0x6d572f44)\n mstore(0x20, 0x80)\n mstore(0x40, 0xc0)\n mstore(0x60, 0x100)\n mstore(0x80, p3)\n writeString(0xa0, p0)\n writeString(0xe0, p1)\n writeString(0x120, p2)\n }\n _sendLogPayload(0x1c, 0x144);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n mstore(0x120, m9)\n mstore(0x140, m10)\n }\n }\n\n function log(bytes32 p0, bytes32 p1, bytes32 p2, bool p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n bytes32 m9;\n bytes32 m10;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n m9 := mload(0x120)\n m10 := mload(0x140)\n // Selector of `log(string,string,string,bool)`.\n mstore(0x00, 0x2c1754ed)\n mstore(0x20, 0x80)\n mstore(0x40, 0xc0)\n mstore(0x60, 0x100)\n mstore(0x80, p3)\n writeString(0xa0, p0)\n writeString(0xe0, p1)\n writeString(0x120, p2)\n }\n _sendLogPayload(0x1c, 0x144);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n mstore(0x120, m9)\n mstore(0x140, m10)\n }\n }\n\n function log(bytes32 p0, bytes32 p1, bytes32 p2, uint256 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n bytes32 m9;\n bytes32 m10;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n m9 := mload(0x120)\n m10 := mload(0x140)\n // Selector of `log(string,string,string,uint256)`.\n mstore(0x00, 0x8eafb02b)\n mstore(0x20, 0x80)\n mstore(0x40, 0xc0)\n mstore(0x60, 0x100)\n mstore(0x80, p3)\n writeString(0xa0, p0)\n writeString(0xe0, p1)\n writeString(0x120, p2)\n }\n _sendLogPayload(0x1c, 0x144);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n mstore(0x120, m9)\n mstore(0x140, m10)\n }\n }\n\n function log(bytes32 p0, bytes32 p1, bytes32 p2, bytes32 p3) internal pure {\n bytes32 m0;\n bytes32 m1;\n bytes32 m2;\n bytes32 m3;\n bytes32 m4;\n bytes32 m5;\n bytes32 m6;\n bytes32 m7;\n bytes32 m8;\n bytes32 m9;\n bytes32 m10;\n bytes32 m11;\n bytes32 m12;\n /// @solidity memory-safe-assembly\n assembly {\n function writeString(pos, w) {\n let length := 0\n for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }\n mstore(pos, length)\n let shift := sub(256, shl(3, length))\n mstore(add(pos, 0x20), shl(shift, shr(shift, w)))\n }\n m0 := mload(0x00)\n m1 := mload(0x20)\n m2 := mload(0x40)\n m3 := mload(0x60)\n m4 := mload(0x80)\n m5 := mload(0xa0)\n m6 := mload(0xc0)\n m7 := mload(0xe0)\n m8 := mload(0x100)\n m9 := mload(0x120)\n m10 := mload(0x140)\n m11 := mload(0x160)\n m12 := mload(0x180)\n // Selector of `log(string,string,string,string)`.\n mstore(0x00, 0xde68f20a)\n mstore(0x20, 0x80)\n mstore(0x40, 0xc0)\n mstore(0x60, 0x100)\n mstore(0x80, 0x140)\n writeString(0xa0, p0)\n writeString(0xe0, p1)\n writeString(0x120, p2)\n writeString(0x160, p3)\n }\n _sendLogPayload(0x1c, 0x184);\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, m0)\n mstore(0x20, m1)\n mstore(0x40, m2)\n mstore(0x60, m3)\n mstore(0x80, m4)\n mstore(0xa0, m5)\n mstore(0xc0, m6)\n mstore(0xe0, m7)\n mstore(0x100, m8)\n mstore(0x120, m9)\n mstore(0x140, m10)\n mstore(0x160, m11)\n mstore(0x180, m12)\n }\n }\n}\n","license":"MIT"},"scripts/FetchChainInfo.s.sol":{"keccak256":"0xb90e4f9a834c4dc584b4ad8c0503e35fdd8338533e0e75a7ca497f655ae12821","urls":[],"content":"// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\nimport { Script } from \"forge-std/Script.sol\";\nimport { GameTypes, GameType } from \"src/dispute/lib/Types.sol\";\n\n/// @notice Contains getters for arbitrary methods from all L1 contracts, including legacy getters\n/// that have since been deprecated.\ninterface IFetcher {\n function guardian() external view returns (address);\n function GUARDIAN() external view returns (address);\n function systemConfig() external view returns (address);\n function SYSTEM_CONFIG() external view returns (address);\n function disputeGameFactory() external view returns (address);\n function ethLockbox() external view returns (address);\n function superchainConfig() external view returns (address);\n function messenger() external view returns (address);\n function addressManager() external view returns (address);\n function PORTAL() external view returns (address);\n function portal() external view returns (address);\n function l1ERC721Bridge() external view returns (address);\n function optimismMintableERC20Factory() external view returns (address);\n function gameImpls(GameType _gameType) external view returns (address);\n function respectedGameType() external view returns (GameType);\n function anchorStateRegistry() external view returns (address);\n function L2_ORACLE() external view returns (address);\n function l2Oracle() external view returns (address);\n function vm() external view returns (address);\n function oracle() external view returns (address);\n function challenger() external view returns (address);\n function proposer() external view returns (address);\n function PROPOSER() external view returns (address);\n function batcherHash() external view returns (bytes32);\n function admin() external view returns (address);\n function owner() external view returns (address);\n function unsafeBlockSigner() external view returns (address);\n function weth() external view returns (address);\n}\n\ncontract FetchChainInfoInput {\n address internal _systemConfigProxy;\n address internal _l1StandardBridgeProxy;\n\n function set(bytes4 _sel, address _addr) public {\n require(_addr != address(0), \"FetchChainInfoInput: cannot set zero address\");\n if (_sel == this.systemConfigProxy.selector) _systemConfigProxy = _addr;\n else if (_sel == this.l1StandardBridgeProxy.selector) _l1StandardBridgeProxy = _addr;\n else revert(\"FetchChainInfoInput: unknown selector\");\n }\n\n function systemConfigProxy() public view returns (address) {\n require(_systemConfigProxy != address(0), \"FetchChainInfoInput: systemConfigProxy not set\");\n return _systemConfigProxy;\n }\n\n function l1StandardBridgeProxy() public view returns (address) {\n require(_l1StandardBridgeProxy != address(0), \"FetchChainInfoInput: l1StandardBridgeProxy not set\");\n return _l1StandardBridgeProxy;\n }\n}\n\ncontract FetchChainInfoOutput {\n // contract addresses\n // - SuperchainContracts\n address internal _superchainConfigProxy;\n // - ImplementationsContracts\n address internal _mipsImpl;\n address internal _preimageOracleImpl;\n // - OpChainContracts\n address internal _addressManagerImpl;\n address internal _ethLockboxProxy;\n address internal _l1CrossDomainMessengerProxy;\n address internal _l1Erc721BridgeProxy;\n address internal _l1StandardBridgeProxy;\n address internal _l2OutputOracleProxy;\n address internal _optimismMintableErc20FactoryProxy;\n address internal _optimismPortalProxy;\n address internal _systemConfigProxy;\n address internal _opChainProxyAdminImpl;\n address internal _anchorStateRegistryProxy;\n address internal _delayedWethPermissionedGameProxy;\n address internal _delayedWethPermissionlessGameProxy;\n address internal _disputeGameFactoryProxy;\n address internal _faultDisputeGameImpl;\n address internal _faultDisputeGameCannonKonaImpl;\n address internal _permissionedDisputeGameImpl;\n\n // roles\n address internal _systemConfigOwner;\n address internal _opChainProxyAdminOwner;\n address internal _opChainGuardian;\n address internal _challenger;\n address internal _proposer;\n address internal _unsafeBlockSigner;\n address internal _batchSubmitter;\n\n // fault proof status\n bool internal _permissioned;\n bool internal _permissionless;\n GameType internal _respectedGameType;\n\n function set(bytes4 _sel, address _addr) public {\n // SuperchainContracts\n if (_sel == this.superchainConfigProxy.selector) _superchainConfigProxy = _addr;\n // - ImplementationsContracts\n else if (_sel == this.mipsImpl.selector) _mipsImpl = _addr;\n else if (_sel == this.preimageOracleImpl.selector) _preimageOracleImpl = _addr;\n // - OpChainContracts\n else if (_sel == this.addressManagerImpl.selector) _addressManagerImpl = _addr;\n else if (_sel == this.ethLockboxProxy.selector) _ethLockboxProxy = _addr;\n else if (_sel == this.l1CrossDomainMessengerProxy.selector) _l1CrossDomainMessengerProxy = _addr;\n else if (_sel == this.l1Erc721BridgeProxy.selector) _l1Erc721BridgeProxy = _addr;\n else if (_sel == this.l1StandardBridgeProxy.selector) _l1StandardBridgeProxy = _addr;\n else if (_sel == this.l2OutputOracleProxy.selector) _l2OutputOracleProxy = _addr;\n else if (_sel == this.optimismMintableErc20FactoryProxy.selector) _optimismMintableErc20FactoryProxy = _addr;\n else if (_sel == this.optimismPortalProxy.selector) _optimismPortalProxy = _addr;\n else if (_sel == this.systemConfigProxy.selector) _systemConfigProxy = _addr;\n else if (_sel == this.opChainProxyAdminImpl.selector) _opChainProxyAdminImpl = _addr;\n else if (_sel == this.anchorStateRegistryProxy.selector) _anchorStateRegistryProxy = _addr;\n else if (_sel == this.delayedWethPermissionedGameProxy.selector) _delayedWethPermissionedGameProxy = _addr;\n else if (_sel == this.delayedWethPermissionlessGameProxy.selector) _delayedWethPermissionlessGameProxy = _addr;\n else if (_sel == this.disputeGameFactoryProxy.selector) _disputeGameFactoryProxy = _addr;\n else if (_sel == this.faultDisputeGameImpl.selector) _faultDisputeGameImpl = _addr;\n else if (_sel == this.faultDisputeGameCannonKonaImpl.selector) _faultDisputeGameCannonKonaImpl = _addr;\n else if (_sel == this.permissionedDisputeGameImpl.selector) _permissionedDisputeGameImpl = _addr;\n // roles\n else if (_sel == this.systemConfigOwner.selector) _systemConfigOwner = _addr;\n else if (_sel == this.opChainProxyAdminOwner.selector) _opChainProxyAdminOwner = _addr;\n else if (_sel == this.opChainGuardian.selector) _opChainGuardian = _addr;\n else if (_sel == this.challenger.selector) _challenger = _addr;\n else if (_sel == this.proposer.selector) _proposer = _addr;\n else if (_sel == this.unsafeBlockSigner.selector) _unsafeBlockSigner = _addr;\n else if (_sel == this.batchSubmitter.selector) _batchSubmitter = _addr;\n else revert(\"FetchChainInfoOutput: unknown address selector test\");\n }\n\n function set(bytes4 _sel, bool _bool) public {\n if (_sel == this.permissioned.selector) _permissioned = _bool;\n else if (_sel == this.permissionless.selector) _permissionless = _bool;\n else revert(\"FetchChainInfoOutput: unknown bool selector\");\n }\n\n function set(bytes4 _sel, GameType _gameType) public {\n if (_sel == this.respectedGameType.selector) _respectedGameType = _gameType;\n else revert(\"FetchChainInfoOutput: unknown GameType selector\");\n }\n\n function addressManagerImpl() public view returns (address) {\n require(_addressManagerImpl != address(0), \"FetchChainInfoOutput: addressManagerImpl not set\");\n return _addressManagerImpl;\n }\n\n function ethLockboxProxy() public view returns (address) {\n return _ethLockboxProxy;\n }\n\n function l1CrossDomainMessengerProxy() public view returns (address) {\n require(_l1CrossDomainMessengerProxy != address(0), \"FetchChainInfoOutput: l1CrossDomainMessengerProxy not set\");\n return _l1CrossDomainMessengerProxy;\n }\n\n function l1Erc721BridgeProxy() public view returns (address) {\n require(_l1Erc721BridgeProxy != address(0), \"FetchChainInfoOutput: l1Erc721BridgeProxy not set\");\n return _l1Erc721BridgeProxy;\n }\n\n function l1StandardBridgeProxy() public view returns (address) {\n require(_l1StandardBridgeProxy != address(0), \"FetchChainInfoOutput: l1StandardBridgeProxy not set\");\n return _l1StandardBridgeProxy;\n }\n\n function l2OutputOracleProxy() public view returns (address) {\n require(_l2OutputOracleProxy != address(0), \"FetchChainInfoOutput: l2OutputOracleProxy not set\");\n return _l2OutputOracleProxy;\n }\n\n function optimismMintableErc20FactoryProxy() public view returns (address) {\n require(\n _optimismMintableErc20FactoryProxy != address(0),\n \"FetchChainInfoOutput: optimismMintableErc20FactoryProxy not set\"\n );\n return _optimismMintableErc20FactoryProxy;\n }\n\n function optimismPortalProxy() public view returns (address) {\n require(_optimismPortalProxy != address(0), \"FetchChainInfoOutput: optimismPortalProxy not set\");\n return _optimismPortalProxy;\n }\n\n function systemConfigProxy() public view returns (address) {\n require(_systemConfigProxy != address(0), \"FetchChainInfoOutput: systemConfigProxy not set\");\n return _systemConfigProxy;\n }\n\n function opChainProxyAdminImpl() public view returns (address) {\n require(_opChainProxyAdminImpl != address(0), \"FetchChainInfoOutput: opChainProxyAdminImpl not set\");\n return _opChainProxyAdminImpl;\n }\n\n function superchainConfigProxy() public view returns (address) {\n require(_superchainConfigProxy != address(0), \"FetchChainInfoOutput: superchainConfigProxy not set\");\n return _superchainConfigProxy;\n }\n\n function anchorStateRegistryProxy() public view returns (address) {\n require(_anchorStateRegistryProxy != address(0), \"FetchChainInfoOutput: anchorStateRegistryProxy not set\");\n return _anchorStateRegistryProxy;\n }\n\n function delayedWethPermissionedGameProxy() public view returns (address) {\n return _delayedWethPermissionedGameProxy;\n }\n\n function delayedWethPermissionlessGameProxy() public view returns (address) {\n return _delayedWethPermissionlessGameProxy;\n }\n\n function disputeGameFactoryProxy() public view returns (address) {\n return _disputeGameFactoryProxy;\n }\n\n function faultDisputeGameImpl() public view returns (address) {\n require(_faultDisputeGameImpl != address(0), \"FetchChainInfoOutput: faultDisputeGameImpl not set\");\n return _faultDisputeGameImpl;\n }\n\n function faultDisputeGameCannonKonaImpl() public view returns (address) {\n require(\n _faultDisputeGameCannonKonaImpl != address(0),\n \"FetchChainInfoOutput: faultDisputeGameCannonKonaImpl not set\"\n );\n return _faultDisputeGameCannonKonaImpl;\n }\n\n function mipsImpl() public view returns (address) {\n require(_mipsImpl != address(0), \"FetchChainInfoOutput: mipsImpl not set\");\n return _mipsImpl;\n }\n\n function permissionedDisputeGameImpl() public view returns (address) {\n require(_permissionedDisputeGameImpl != address(0), \"FetchChainInfoOutput: permissionedDisputeGameImpl not set\");\n return _permissionedDisputeGameImpl;\n }\n\n function preimageOracleImpl() public view returns (address) {\n require(_preimageOracleImpl != address(0), \"FetchChainInfoOutput: preimageOracleImpl not set\");\n return _preimageOracleImpl;\n }\n\n function systemConfigOwner() public view returns (address) {\n require(_systemConfigOwner != address(0), \"FetchChainInfoOutput: systemConfigOwner not set\");\n return _systemConfigOwner;\n }\n\n function opChainProxyAdminOwner() public view returns (address) {\n require(_opChainProxyAdminOwner != address(0), \"FetchChainInfoOutput: opChainProxyAdminOwner not set\");\n return _opChainProxyAdminOwner;\n }\n\n function opChainGuardian() public view returns (address) {\n require(_opChainGuardian != address(0), \"FetchChainInfoOutput: opChainGuardian not set\");\n return _opChainGuardian;\n }\n\n function challenger() public view returns (address) {\n require(_challenger != address(0), \"FetchChainInfoOutput: challenger not set\");\n return _challenger;\n }\n\n function proposer() public view returns (address) {\n require(_proposer != address(0), \"FetchChainInfoOutput: proposer not set\");\n return _proposer;\n }\n\n function unsafeBlockSigner() public view returns (address) {\n require(_unsafeBlockSigner != address(0), \"FetchChainInfoOutput: unsafeBlockSigner not set\");\n return _unsafeBlockSigner;\n }\n\n function batchSubmitter() public view returns (address) {\n require(_batchSubmitter != address(0), \"FetchChainInfoOutput: batchSubmitter not set\");\n return _batchSubmitter;\n }\n\n function permissioned() public view returns (bool) {\n return _permissioned;\n }\n\n function permissionless() public view returns (bool) {\n return _permissionless;\n }\n\n function respectedGameType() public view returns (GameType) {\n return _respectedGameType;\n }\n}\n\ncontract FetchChainInfo is Script {\n function run(FetchChainInfoInput _fi, FetchChainInfoOutput _fo) public {\n _processSystemConfig(_fi, _fo);\n _processMessengerAndPortal(_fi, _fo);\n _processFaultProofs(_fo);\n }\n\n function _processSystemConfig(FetchChainInfoInput _fi, FetchChainInfoOutput _fo) internal {\n address systemConfigProxy = _fi.systemConfigProxy();\n _fo.set(_fo.systemConfigProxy.selector, systemConfigProxy);\n\n address systemConfigOwner = IFetcher(systemConfigProxy).owner();\n _fo.set(_fo.systemConfigOwner.selector, systemConfigOwner);\n\n address unsafeBlockSigner = IFetcher(systemConfigProxy).unsafeBlockSigner();\n _fo.set(_fo.unsafeBlockSigner.selector, unsafeBlockSigner);\n\n address batchSubmitter = _getBatchSubmitter(systemConfigProxy);\n _fo.set(_fo.batchSubmitter.selector, batchSubmitter);\n\n address opChainProxyAdminImpl = _getProxyAdmin(systemConfigProxy);\n _fo.set(_fo.opChainProxyAdminImpl.selector, opChainProxyAdminImpl);\n\n address opChainProxyAdminOwner = IFetcher(opChainProxyAdminImpl).owner();\n _fo.set(_fo.opChainProxyAdminOwner.selector, opChainProxyAdminOwner);\n\n address l1Erc721BridgeProxy = _getL1ERC721BridgeProxy(systemConfigProxy);\n _fo.set(_fo.l1Erc721BridgeProxy.selector, l1Erc721BridgeProxy);\n\n address optimismMintableErc20FactoryProxy = _getOptimismMintableERC20FactoryProxy(systemConfigProxy);\n _fo.set(_fo.optimismMintableErc20FactoryProxy.selector, optimismMintableErc20FactoryProxy);\n }\n\n function _processMessengerAndPortal(FetchChainInfoInput _fi, FetchChainInfoOutput _fo) internal {\n address l1StandardBridgeProxy = _fi.l1StandardBridgeProxy();\n _fo.set(_fo.l1StandardBridgeProxy.selector, l1StandardBridgeProxy);\n\n address l1CrossDomainMessengerProxy = IFetcher(l1StandardBridgeProxy).messenger();\n _fo.set(_fo.l1CrossDomainMessengerProxy.selector, l1CrossDomainMessengerProxy);\n\n address addressManagerImpl = _getAddressManager(l1CrossDomainMessengerProxy);\n _fo.set(_fo.addressManagerImpl.selector, addressManagerImpl);\n\n address optimismPortalProxy = _getOptimismPortalProxy(l1CrossDomainMessengerProxy);\n _fo.set(_fo.optimismPortalProxy.selector, optimismPortalProxy);\n\n address opChainGuardian = _getGuardian(optimismPortalProxy);\n _fo.set(_fo.opChainGuardian.selector, opChainGuardian);\n\n address ethLockboxProxy = _getEthLockboxProxy(optimismPortalProxy);\n _fo.set(_fo.ethLockboxProxy.selector, ethLockboxProxy);\n\n address superchainConfigProxy = _getSuperchainConfigProxy(optimismPortalProxy);\n _fo.set(_fo.superchainConfigProxy.selector, superchainConfigProxy);\n }\n\n function _processFaultProofs(FetchChainInfoOutput _fo) internal {\n address systemConfigProxy = _fo.systemConfigProxy();\n address optimismPortalProxy = _fo.optimismPortalProxy();\n\n try IFetcher(optimismPortalProxy).respectedGameType() returns (GameType gameType_) {\n _fo.set(_fo.respectedGameType.selector, gameType_);\n } catch {\n // default respectedGameType to uint32.max since 0 == CANNON\n _fo.set(_fo.respectedGameType.selector, GameType.wrap(type(uint32).max));\n address l2OutputOracleProxy;\n try IFetcher(optimismPortalProxy).l2Oracle() returns (address l2Oracle_) {\n l2OutputOracleProxy = l2Oracle_;\n } catch {\n l2OutputOracleProxy = IFetcher(optimismPortalProxy).L2_ORACLE();\n }\n _fo.set(_fo.l2OutputOracleProxy.selector, l2OutputOracleProxy);\n\n address proposer = IFetcher(l2OutputOracleProxy).PROPOSER();\n _fo.set(_fo.proposer.selector, proposer);\n\n // no fault proofs installed so we're done\n return;\n }\n\n address disputeGameFactoryProxy = _getDisputeGameFactoryProxy(systemConfigProxy);\n if (disputeGameFactoryProxy != address(0)) {\n _fo.set(_fo.disputeGameFactoryProxy.selector, disputeGameFactoryProxy);\n\n address permissionedDisputeGameImpl = _getPermissionedDisputeGame(disputeGameFactoryProxy);\n if (permissionedDisputeGameImpl != address(0)) {\n // permissioned fault proofs installed\n _fo.set(_fo.permissioned.selector, true);\n _fo.set(_fo.permissionedDisputeGameImpl.selector, permissionedDisputeGameImpl);\n\n address challenger = IFetcher(permissionedDisputeGameImpl).challenger();\n _fo.set(_fo.challenger.selector, challenger);\n\n address anchorStateRegistryProxy = IFetcher(permissionedDisputeGameImpl).anchorStateRegistry();\n _fo.set(_fo.anchorStateRegistryProxy.selector, anchorStateRegistryProxy);\n\n address proposer = IFetcher(permissionedDisputeGameImpl).proposer();\n _fo.set(_fo.proposer.selector, proposer);\n\n address delayedWethPermissionedGameProxy = _getDelayedWETHProxy(permissionedDisputeGameImpl);\n _fo.set(_fo.delayedWethPermissionedGameProxy.selector, delayedWethPermissionedGameProxy);\n\n address mipsImpl = IFetcher(permissionedDisputeGameImpl).vm();\n _fo.set(_fo.mipsImpl.selector, mipsImpl);\n\n address preimageOracleImpl = IFetcher(mipsImpl).oracle();\n _fo.set(_fo.preimageOracleImpl.selector, preimageOracleImpl);\n }\n\n address faultDisputeGameImpl = _getFaultDisputeGame(disputeGameFactoryProxy);\n if (faultDisputeGameImpl != address(0)) {\n // permissionless fault proofs installed\n _fo.set(_fo.faultDisputeGameImpl.selector, faultDisputeGameImpl);\n _fo.set(_fo.permissionless.selector, true);\n\n address delayedWethPermissionlessGameProxy = _getDelayedWETHProxy(faultDisputeGameImpl);\n _fo.set(_fo.delayedWethPermissionlessGameProxy.selector, delayedWethPermissionlessGameProxy);\n }\n\n address faultDisputeGameCannonKonaImpl =\n _getFaultDisputeGame(disputeGameFactoryProxy, GameTypes.CANNON_KONA);\n if (faultDisputeGameCannonKonaImpl != address(0)) {\n _fo.set(_fo.faultDisputeGameCannonKonaImpl.selector, faultDisputeGameCannonKonaImpl);\n }\n } else {\n // some older chains have L2OutputOracle instead of DisputeGameFactory.\n address l2OutputOracleProxy = IFetcher(optimismPortalProxy).L2_ORACLE();\n _fo.set(_fo.l2OutputOracleProxy.selector, l2OutputOracleProxy);\n address proposer = IFetcher(l2OutputOracleProxy).PROPOSER();\n _fo.set(_fo.proposer.selector, proposer);\n }\n }\n\n function _getGuardian(address _portal) internal view returns (address) {\n try IFetcher(_portal).guardian() returns (address guardian_) {\n return guardian_;\n } catch {\n return IFetcher(_portal).GUARDIAN();\n }\n }\n\n function _getSystemConfigProxy(address _portal) internal view returns (address) {\n try IFetcher(_portal).systemConfig() returns (address systemConfig_) {\n return systemConfig_;\n } catch {\n return IFetcher(_portal).SYSTEM_CONFIG();\n }\n }\n\n function _getOptimismPortalProxy(address _l1CrossDomainMessengerProxy) internal view returns (address) {\n try IFetcher(_l1CrossDomainMessengerProxy).portal() returns (address optimismPortal_) {\n return optimismPortal_;\n } catch {\n return IFetcher(_l1CrossDomainMessengerProxy).PORTAL();\n }\n }\n\n function _getAddressManager(address _l1CrossDomainMessengerProxy) internal view returns (address) {\n uint256 ADDRESS_MANAGER_MAPPING_SLOT = 1;\n bytes32 slot = keccak256(abi.encode(_l1CrossDomainMessengerProxy, ADDRESS_MANAGER_MAPPING_SLOT));\n return address(uint160(uint256((vm.load(_l1CrossDomainMessengerProxy, slot)))));\n }\n\n function _getL1ERC721BridgeProxy(address _systemConfigProxy) internal view returns (address) {\n try IFetcher(_systemConfigProxy).l1ERC721Bridge() returns (address l1ERC721BridgeProxy_) {\n return l1ERC721BridgeProxy_;\n } catch {\n return address(0);\n }\n }\n\n function _getOptimismMintableERC20FactoryProxy(address _systemConfigProxy) internal view returns (address) {\n try IFetcher(_systemConfigProxy).optimismMintableERC20Factory() returns (\n address optimismMintableERC20FactoryProxy_\n ) {\n return optimismMintableERC20FactoryProxy_;\n } catch {\n return address(0);\n }\n }\n\n function _getDisputeGameFactoryProxy(address _systemConfigProxy) internal view returns (address) {\n try IFetcher(_systemConfigProxy).disputeGameFactory() returns (address disputeGameFactoryProxy_) {\n return disputeGameFactoryProxy_;\n } catch {\n // Some older chains have L2OutputOracle instead of DisputeGameFactory\n return address(0);\n }\n }\n\n function _getSuperchainConfigProxy(address _optimismPortalProxy) internal view returns (address) {\n try IFetcher(_optimismPortalProxy).superchainConfig() returns (address superchainConfigProxy_) {\n return superchainConfigProxy_;\n } catch {\n return address(0);\n }\n }\n\n function _getFaultDisputeGame(address _disputeGameFactoryProxy) internal view returns (address) {\n try IFetcher(_disputeGameFactoryProxy).gameImpls(GameTypes.CANNON) returns (address faultDisputeGame_) {\n return faultDisputeGame_;\n } catch {\n return address(0);\n }\n }\n\n function _getFaultDisputeGame(\n address _disputeGameFactoryProxy,\n GameType _gameType\n )\n internal\n view\n returns (address)\n {\n try IFetcher(_disputeGameFactoryProxy).gameImpls(_gameType) returns (address faultDisputeGame_) {\n return faultDisputeGame_;\n } catch {\n return address(0);\n }\n }\n\n function _getPermissionedDisputeGame(address _disputeGameFactoryProxy) internal view returns (address) {\n try IFetcher(_disputeGameFactoryProxy).gameImpls(GameTypes.PERMISSIONED_CANNON) returns (\n address permissionedDisputeGame_\n ) {\n return permissionedDisputeGame_;\n } catch {\n return address(0);\n }\n }\n\n function _getEthLockboxProxy(address _optimismPortalProxy) internal view returns (address) {\n try IFetcher(_optimismPortalProxy).ethLockbox() returns (address ethLockbox_) {\n return ethLockbox_;\n } catch {\n return address(0);\n }\n }\n\n function _getDelayedWETHProxy(address _disputeGame) internal view returns (address) {\n (bool ok, bytes memory data) = address(_disputeGame).staticcall(abi.encodeCall(IFetcher.weth, ()));\n if (ok && data.length == 32) return abi.decode(data, (address));\n else return address(0);\n }\n\n function _getBatchSubmitter(address _systemConfigProxy) internal view returns (address) {\n bytes32 batcherHash = IFetcher(_systemConfigProxy).batcherHash();\n return address(uint160(uint256(batcherHash)));\n }\n\n function _getProxyAdmin(address _systemConfigProxy) internal returns (address) {\n vm.prank(address(0));\n return IFetcher(_systemConfigProxy).admin();\n }\n}\n","license":"MIT"},"src/dispute/lib/LibPosition.sol":{"keccak256":"0x7c5f19f8f54f06de2ce1c6cdcc5c7af65ac405130a4066cdaf146ca315818241","urls":[],"content":"// SPDX-License-Identifier: MIT\npragma solidity ^0.8.15;\n\nusing LibPosition for Position global;\n\n/// @notice A `Position` represents a position of a claim within the game tree.\n/// @dev This is represented as a \"generalized index\" where the high-order bit\n/// is the level in the tree and the remaining bits is a unique bit pattern, allowing\n/// a unique identifier for each node in the tree. Mathematically, it is calculated\n/// as 2^{depth} + indexAtDepth.\ntype Position is uint128;\n\n/// @title LibPosition\n/// @notice This library contains helper functions for working with the `Position` type.\nlibrary LibPosition {\n /// @notice the `MAX_POSITION_BITLEN` is the number of bits that the `Position` type, and the implementation of\n /// its behavior within this library, can safely support.\n uint8 internal constant MAX_POSITION_BITLEN = 126;\n\n /// @notice Computes a generalized index (2^{depth} + indexAtDepth).\n /// @param _depth The depth of the position.\n /// @param _indexAtDepth The index at the depth of the position.\n /// @return position_ The computed generalized index.\n function wrap(uint8 _depth, uint128 _indexAtDepth) internal pure returns (Position position_) {\n assembly {\n // gindex = 2^{_depth} + _indexAtDepth\n position_ := add(shl(_depth, 1), _indexAtDepth)\n }\n }\n\n /// @notice Pulls the `depth` out of a `Position` type.\n /// @param _position The generalized index to get the `depth` of.\n /// @return depth_ The `depth` of the `position` gindex.\n /// @custom:attribution Solady \n function depth(Position _position) internal pure returns (uint8 depth_) {\n // Return the most significant bit offset, which signifies the depth of the gindex.\n assembly {\n depth_ := or(depth_, shl(6, lt(0xffffffffffffffff, shr(depth_, _position))))\n depth_ := or(depth_, shl(5, lt(0xffffffff, shr(depth_, _position))))\n\n // For the remaining 32 bits, use a De Bruijn lookup.\n _position := shr(depth_, _position)\n _position := or(_position, shr(1, _position))\n _position := or(_position, shr(2, _position))\n _position := or(_position, shr(4, _position))\n _position := or(_position, shr(8, _position))\n _position := or(_position, shr(16, _position))\n\n depth_ :=\n or(\n depth_,\n byte(\n shr(251, mul(_position, shl(224, 0x07c4acdd))),\n 0x0009010a0d15021d0b0e10121619031e080c141c0f111807131b17061a05041f\n )\n )\n }\n }\n\n /// @notice Pulls the `indexAtDepth` out of a `Position` type.\n /// The `indexAtDepth` is the left/right index of a position at a specific depth within\n /// the binary tree, starting from index 0. For example, at gindex 2, the `depth` = 1\n /// and the `indexAtDepth` = 0.\n /// @param _position The generalized index to get the `indexAtDepth` of.\n /// @return indexAtDepth_ The `indexAtDepth` of the `position` gindex.\n function indexAtDepth(Position _position) internal pure returns (uint128 indexAtDepth_) {\n // Return bits p_{msb-1}...p_{0}. This effectively pulls the 2^{depth} out of the gindex,\n // leaving only the `indexAtDepth`.\n uint256 msb = depth(_position);\n assembly {\n indexAtDepth_ := sub(_position, shl(msb, 1))\n }\n }\n\n /// @notice Get the left child of `_position`.\n /// @param _position The position to get the left position of.\n /// @return left_ The position to the left of `position`.\n function left(Position _position) internal pure returns (Position left_) {\n assembly {\n left_ := shl(1, _position)\n }\n }\n\n /// @notice Get the right child of `_position`\n /// @param _position The position to get the right position of.\n /// @return right_ The position to the right of `position`.\n function right(Position _position) internal pure returns (Position right_) {\n assembly {\n right_ := or(1, shl(1, _position))\n }\n }\n\n /// @notice Get the parent position of `_position`.\n /// @param _position The position to get the parent position of.\n /// @return parent_ The parent position of `position`.\n function parent(Position _position) internal pure returns (Position parent_) {\n assembly {\n parent_ := shr(1, _position)\n }\n }\n\n /// @notice Get the deepest, right most gindex relative to the `position`. This is equivalent to\n /// calling `right` on a position until the maximum depth is reached.\n /// @param _position The position to get the relative deepest, right most gindex of.\n /// @param _maxDepth The maximum depth of the game.\n /// @return rightIndex_ The deepest, right most gindex relative to the `position`.\n function rightIndex(Position _position, uint256 _maxDepth) internal pure returns (Position rightIndex_) {\n uint256 msb = depth(_position);\n assembly {\n let remaining := sub(_maxDepth, msb)\n rightIndex_ := or(shl(remaining, _position), sub(shl(remaining, 1), 1))\n }\n }\n\n /// @notice Get the deepest, right most trace index relative to the `position`. This is\n /// equivalent to calling `right` on a position until the maximum depth is reached and\n /// then finding its index at depth.\n /// @param _position The position to get the relative trace index of.\n /// @param _maxDepth The maximum depth of the game.\n /// @return traceIndex_ The trace index relative to the `position`.\n function traceIndex(Position _position, uint256 _maxDepth) internal pure returns (uint256 traceIndex_) {\n uint256 msb = depth(_position);\n assembly {\n let remaining := sub(_maxDepth, msb)\n traceIndex_ := sub(or(shl(remaining, _position), sub(shl(remaining, 1), 1)), shl(_maxDepth, 1))\n }\n }\n\n /// @notice Gets the position of the highest ancestor of `_position` that commits to the same\n /// trace index.\n /// @param _position The position to get the highest ancestor of.\n /// @return ancestor_ The highest ancestor of `position` that commits to the same trace index.\n function traceAncestor(Position _position) internal pure returns (Position ancestor_) {\n // Create a field with only the lowest unset bit of `_position` set.\n Position lsb;\n assembly {\n lsb := and(not(_position), add(_position, 1))\n }\n // Find the index of the lowest unset bit within the field.\n uint256 msb = depth(lsb);\n // The highest ancestor that commits to the same trace index is the original position\n // shifted right by the index of the lowest unset bit.\n assembly {\n let a := shr(msb, _position)\n // Bound the ancestor to the minimum gindex, 1.\n ancestor_ := or(a, iszero(a))\n }\n }\n\n /// @notice Gets the position of the highest ancestor of `_position` that commits to the same\n /// trace index, while still being below `_upperBoundExclusive`.\n /// @param _position The position to get the highest ancestor of.\n /// @param _upperBoundExclusive The exclusive upper depth bound, used to inform where to stop in order\n /// to not escape a sub-tree.\n /// @return ancestor_ The highest ancestor of `position` that commits to the same trace index.\n function traceAncestorBounded(\n Position _position,\n uint256 _upperBoundExclusive\n )\n internal\n pure\n returns (Position ancestor_)\n {\n // This function only works for positions that are below the upper bound.\n if (_position.depth() <= _upperBoundExclusive) {\n assembly {\n // Revert with `ClaimAboveSplit()`\n mstore(0x00, 0xb34b5c22)\n revert(0x1C, 0x04)\n }\n }\n\n // Grab the global trace ancestor.\n ancestor_ = traceAncestor(_position);\n\n // If the ancestor is above or at the upper bound, shift it to be below the upper bound.\n // This should be a special case that only covers positions that commit to the final leaf\n // in a sub-tree.\n if (ancestor_.depth() <= _upperBoundExclusive) {\n ancestor_ = ancestor_.rightIndex(_upperBoundExclusive + 1);\n }\n }\n\n /// @notice Get the move position of `_position`, which is the left child of:\n /// 1. `_position` if `_isAttack` is true.\n /// 2. `_position | 1` if `_isAttack` is false.\n /// @param _position The position to get the relative attack/defense position of.\n /// @param _isAttack Whether or not the move is an attack move.\n /// @return move_ The move position relative to `position`.\n function move(Position _position, bool _isAttack) internal pure returns (Position move_) {\n assembly {\n move_ := shl(1, or(iszero(_isAttack), _position))\n }\n }\n\n /// @notice Get the value of a `Position` type in the form of the underlying uint128.\n /// @param _position The position to get the value of.\n /// @return raw_ The value of the `position` as a uint128 type.\n function raw(Position _position) internal pure returns (uint128 raw_) {\n assembly {\n raw_ := _position\n }\n }\n}\n","license":"MIT"},"src/dispute/lib/LibUDT.sol":{"keccak256":"0x41d55e9c74d979b5b797198e38449e7cef4f925e04d61f7699e9c150c4a659d3","urls":[],"content":"// SPDX-License-Identifier: MIT\npragma solidity ^0.8.15;\n\n// Libraries\nimport { Position } from \"src/dispute/lib/LibPosition.sol\";\n\nusing LibClaim for Claim global;\nusing LibHash for Hash global;\nusing LibDuration for Duration global;\nusing LibClock for Clock global;\nusing LibGameId for GameId global;\nusing LibTimestamp for Timestamp global;\nusing LibVMStatus for VMStatus global;\nusing LibGameType for GameType global;\n\n/// @notice A `Clock` represents a packed `Duration` and `Timestamp`\n/// @dev The packed layout of this type is as follows:\n/// ┌────────────┬────────────────┐\n/// │ Bits │ Value │\n/// ├────────────┼────────────────┤\n/// │ [0, 64) │ Duration │\n/// │ [64, 128) │ Timestamp │\n/// └────────────┴────────────────┘\ntype Clock is uint128;\n\n/// @title LibClock\n/// @notice This library contains helper functions for working with the `Clock` type.\nlibrary LibClock {\n /// @notice Packs a `Duration` and `Timestamp` into a `Clock` type.\n /// @param _duration The `Duration` to pack into the `Clock` type.\n /// @param _timestamp The `Timestamp` to pack into the `Clock` type.\n /// @return clock_ The `Clock` containing the `_duration` and `_timestamp`.\n function wrap(Duration _duration, Timestamp _timestamp) internal pure returns (Clock clock_) {\n assembly {\n clock_ := or(shl(0x40, _duration), _timestamp)\n }\n }\n\n /// @notice Pull the `Duration` out of a `Clock` type.\n /// @param _clock The `Clock` type to pull the `Duration` out of.\n /// @return duration_ The `Duration` pulled out of `_clock`.\n function duration(Clock _clock) internal pure returns (Duration duration_) {\n // Shift the high-order 64 bits into the low-order 64 bits, leaving only the `duration`.\n assembly {\n duration_ := shr(0x40, _clock)\n }\n }\n\n /// @notice Pull the `Timestamp` out of a `Clock` type.\n /// @param _clock The `Clock` type to pull the `Timestamp` out of.\n /// @return timestamp_ The `Timestamp` pulled out of `_clock`.\n function timestamp(Clock _clock) internal pure returns (Timestamp timestamp_) {\n // Clean the high-order 192 bits by shifting the clock left and then right again, leaving\n // only the `timestamp`.\n assembly {\n timestamp_ := shr(0xC0, shl(0xC0, _clock))\n }\n }\n\n /// @notice Get the value of a `Clock` type in the form of the underlying uint128.\n /// @param _clock The `Clock` type to get the value of.\n /// @return clock_ The value of the `Clock` type as a uint128 type.\n function raw(Clock _clock) internal pure returns (uint128 clock_) {\n assembly {\n clock_ := _clock\n }\n }\n}\n\n/// @notice A `GameId` represents a packed 4 byte game ID, a 8 byte timestamp, and a 20 byte address.\n/// @dev The packed layout of this type is as follows:\n/// ┌───────────┬───────────┐\n/// │ Bits │ Value │\n/// ├───────────┼───────────┤\n/// │ [0, 32) │ Game Type │\n/// │ [32, 96) │ Timestamp │\n/// │ [96, 256) │ Address │\n/// └───────────┴───────────┘\ntype GameId is bytes32;\n\n/// @title LibGameId\n/// @notice Utility functions for packing and unpacking GameIds.\nlibrary LibGameId {\n /// @notice Packs values into a 32 byte GameId type.\n /// @param _gameType The game type.\n /// @param _timestamp The timestamp of the game's creation.\n /// @param _gameProxy The game proxy address.\n /// @return gameId_ The packed GameId.\n function pack(\n GameType _gameType,\n Timestamp _timestamp,\n address _gameProxy\n )\n internal\n pure\n returns (GameId gameId_)\n {\n assembly {\n gameId_ := or(or(shl(224, _gameType), shl(160, _timestamp)), _gameProxy)\n }\n }\n\n /// @notice Unpacks values from a 32 byte GameId type.\n /// @param _gameId The packed GameId.\n /// @return gameType_ The game type.\n /// @return timestamp_ The timestamp of the game's creation.\n /// @return gameProxy_ The game proxy address.\n function unpack(GameId _gameId)\n internal\n pure\n returns (GameType gameType_, Timestamp timestamp_, address gameProxy_)\n {\n assembly {\n gameType_ := shr(224, _gameId)\n timestamp_ := and(shr(160, _gameId), 0xFFFFFFFFFFFFFFFF)\n gameProxy_ := and(_gameId, 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF)\n }\n }\n}\n\n/// @notice A claim represents an MPT root representing the state of the fault proof program.\ntype Claim is bytes32;\n\n/// @title LibClaim\n/// @notice This library contains helper functions for working with the `Claim` type.\nlibrary LibClaim {\n /// @notice Get the value of a `Claim` type in the form of the underlying bytes32.\n /// @param _claim The `Claim` type to get the value of.\n /// @return claim_ The value of the `Claim` type as a bytes32 type.\n function raw(Claim _claim) internal pure returns (bytes32 claim_) {\n assembly {\n claim_ := _claim\n }\n }\n\n /// @notice Hashes a claim and a position together.\n /// @param _claim A Claim type.\n /// @param _position The position of `claim`.\n /// @param _challengeIndex The index of the claim being moved against.\n /// @return claimHash_ A hash of abi.encodePacked(claim, position|challengeIndex);\n function hashClaimPos(\n Claim _claim,\n Position _position,\n uint256 _challengeIndex\n )\n internal\n pure\n returns (Hash claimHash_)\n {\n assembly {\n mstore(0x00, _claim)\n mstore(0x20, or(shl(128, _position), and(0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF, _challengeIndex)))\n claimHash_ := keccak256(0x00, 0x40)\n }\n }\n}\n\n/// @notice A dedicated duration type.\n/// @dev Unit: seconds\ntype Duration is uint64;\n\n/// @title LibDuration\n/// @notice This library contains helper functions for working with the `Duration` type.\nlibrary LibDuration {\n /// @notice Get the value of a `Duration` type in the form of the underlying uint64.\n /// @param _duration The `Duration` type to get the value of.\n /// @return duration_ The value of the `Duration` type as a uint64 type.\n function raw(Duration _duration) internal pure returns (uint64 duration_) {\n assembly {\n duration_ := _duration\n }\n }\n}\n\n/// @notice A custom type for a generic hash.\ntype Hash is bytes32;\n\n/// @title LibHash\n/// @notice This library contains helper functions for working with the `Hash` type.\nlibrary LibHash {\n /// @notice Get the value of a `Hash` type in the form of the underlying bytes32.\n /// @param _hash The `Hash` type to get the value of.\n /// @return hash_ The value of the `Hash` type as a bytes32 type.\n function raw(Hash _hash) internal pure returns (bytes32 hash_) {\n assembly {\n hash_ := _hash\n }\n }\n}\n\n/// @notice A dedicated timestamp type.\ntype Timestamp is uint64;\n\n/// @title LibTimestamp\n/// @notice This library contains helper functions for working with the `Timestamp` type.\nlibrary LibTimestamp {\n /// @notice Get the value of a `Timestamp` type in the form of the underlying uint64.\n /// @param _timestamp The `Timestamp` type to get the value of.\n /// @return timestamp_ The value of the `Timestamp` type as a uint64 type.\n function raw(Timestamp _timestamp) internal pure returns (uint64 timestamp_) {\n assembly {\n timestamp_ := _timestamp\n }\n }\n}\n\n/// @notice A `VMStatus` represents the status of a VM execution.\ntype VMStatus is uint8;\n\n/// @title LibVMStatus\n/// @notice This library contains helper functions for working with the `VMStatus` type.\nlibrary LibVMStatus {\n /// @notice Get the value of a `VMStatus` type in the form of the underlying uint8.\n /// @param _vmstatus The `VMStatus` type to get the value of.\n /// @return vmstatus_ The value of the `VMStatus` type as a uint8 type.\n function raw(VMStatus _vmstatus) internal pure returns (uint8 vmstatus_) {\n assembly {\n vmstatus_ := _vmstatus\n }\n }\n}\n\n/// @notice A `GameType` represents the type of game being played.\ntype GameType is uint32;\n\n/// @title LibGameType\n/// @notice This library contains helper functions for working with the `GameType` type.\nlibrary LibGameType {\n /// @notice Get the value of a `GameType` type in the form of the underlying uint32.\n /// @param _gametype The `GameType` type to get the value of.\n /// @return gametype_ The value of the `GameType` type as a uint32 type.\n function raw(GameType _gametype) internal pure returns (uint32 gametype_) {\n assembly {\n gametype_ := _gametype\n }\n }\n}\n","license":"MIT"},"src/dispute/lib/Types.sol":{"keccak256":"0x468fccc8d6ce3ac5b87bdd5002f84b315ac861be7655ceef87a018f596c410a1","urls":[],"content":"// SPDX-License-Identifier: MIT\npragma solidity ^0.8.15;\n\n// Libraries\nimport {\n Position,\n Hash,\n GameType,\n VMStatus,\n Timestamp,\n Duration,\n Clock,\n GameId,\n Claim,\n LibGameId,\n LibClock\n} from \"src/dispute/lib/LibUDT.sol\";\n\n/// @notice The current status of the dispute game.\nenum GameStatus {\n // The game is currently in progress, and has not been resolved.\n IN_PROGRESS,\n // The game has concluded, and the `rootClaim` was challenged successfully.\n CHALLENGER_WINS,\n // The game has concluded, and the `rootClaim` could not be contested.\n DEFENDER_WINS\n}\n\n/// @notice The game's bond distribution type. Games are expected to start in the `UNDECIDED`\n/// state, and then choose either `NORMAL` or `REFUND`.\nenum BondDistributionMode {\n // Bond distribution strategy has not been chosen.\n UNDECIDED,\n // Bonds should be distributed as normal.\n NORMAL,\n // Bonds should be refunded to claimants.\n REFUND\n}\n\n/// @notice Represents an L2 root and the L2 sequence number at which it was generated.\n/// @custom:field root The output root.\n/// @custom:field l2SequenceNumber The L2 Sequence Number ( e.g. block number / timestamp) at which the root was\n/// generated.\nstruct Proposal {\n Hash root;\n uint256 l2SequenceNumber;\n}\n\n/// @title GameTypes\n/// @notice A library that defines the IDs of games that can be played.\nlibrary GameTypes {\n /// @dev A dispute game type the uses the cannon vm.\n GameType internal constant CANNON = GameType.wrap(0);\n\n /// @dev A permissioned dispute game type that uses the cannon vm.\n GameType internal constant PERMISSIONED_CANNON = GameType.wrap(1);\n\n /// @notice A dispute game type that uses the asterisc vm.\n GameType internal constant ASTERISC = GameType.wrap(2);\n\n /// @notice A dispute game type that uses the asterisc vm with Kona.\n GameType internal constant ASTERISC_KONA = GameType.wrap(3);\n\n /// @notice A dispute game type that uses the cannon vm (Super Roots).\n GameType internal constant SUPER_CANNON = GameType.wrap(4);\n\n /// @notice A dispute game type that uses the permissioned cannon vm (Super Roots).\n GameType internal constant SUPER_PERMISSIONED_CANNON = GameType.wrap(5);\n\n /// @notice A dispute game type that uses OP Succinct\n GameType internal constant OP_SUCCINCT = GameType.wrap(6);\n\n /// @notice A dispute game type that uses the asterisc vm with Kona (Super Roots).\n GameType internal constant SUPER_ASTERISC_KONA = GameType.wrap(7);\n\n /// @notice A dispute game type that uses the cannon vm with Kona.\n GameType internal constant CANNON_KONA = GameType.wrap(8);\n\n /// @notice A dispute game type that uses the cannon vm with Kona (Super Roots).\n GameType internal constant SUPER_CANNON_KONA = GameType.wrap(9);\n\n /// @notice A dispute game type with short game duration for testing withdrawals.\n /// Not intended for production use.\n GameType internal constant FAST = GameType.wrap(254);\n\n /// @notice A dispute game type that uses an alphabet vm.\n /// Not intended for production use.\n GameType internal constant ALPHABET = GameType.wrap(255);\n\n /// @notice A dispute game type that uses RISC Zero's Kailua\n GameType internal constant KAILUA = GameType.wrap(1337);\n}\n\n/// @title VMStatuses\n/// @notice Named type aliases for the various valid VM status bytes.\nlibrary VMStatuses {\n /// @notice The VM has executed successfully and the outcome is valid.\n VMStatus internal constant VALID = VMStatus.wrap(0);\n\n /// @notice The VM has executed successfully and the outcome is invalid.\n VMStatus internal constant INVALID = VMStatus.wrap(1);\n\n /// @notice The VM has paniced.\n VMStatus internal constant PANIC = VMStatus.wrap(2);\n\n /// @notice The VM execution is still in progress.\n VMStatus internal constant UNFINISHED = VMStatus.wrap(3);\n}\n\n/// @title LocalPreimageKey\n/// @notice Named type aliases for local `PreimageOracle` key identifiers.\nlibrary LocalPreimageKey {\n /// @notice The identifier for the L1 head hash.\n uint256 internal constant L1_HEAD_HASH = 0x01;\n\n /// @notice The identifier for the starting output root.\n uint256 internal constant STARTING_OUTPUT_ROOT = 0x02;\n\n /// @notice The identifier for the disputed output root.\n uint256 internal constant DISPUTED_OUTPUT_ROOT = 0x03;\n\n /// @notice The identifier for the disputed L2 block number.\n uint256 internal constant DISPUTED_L2_BLOCK_NUMBER = 0x04;\n\n /// @notice The identifier for the chain ID.\n uint256 internal constant CHAIN_ID = 0x05;\n}\n","license":"MIT"}},"version":1},"storageLayout":{"storage":[],"types":{}},"userdoc":{"version":1,"kind":"user","notice":"Contains getters for arbitrary methods from all L1 contracts, including legacy getters that have since been deprecated."},"devdoc":{"version":1,"kind":"dev"},"ast":{"absolutePath":"scripts/FetchChainInfo.s.sol","id":56019,"exportedSymbols":{"FetchChainInfo":[56018],"FetchChainInfoInput":[54041],"FetchChainInfoOutput":[54911],"GameType":[70720],"GameTypes":[70870],"IFetcher":[53958],"Script":[5558]},"nodeType":"SourceUnit","src":"32:25120:100","nodes":[{"id":53807,"nodeType":"PragmaDirective","src":"32:23:100","nodes":[],"literals":["solidity","^","0.8",".0"]},{"id":53809,"nodeType":"ImportDirective","src":"57:46:100","nodes":[],"absolutePath":"lib/forge-std/src/Script.sol","file":"forge-std/Script.sol","nameLocation":"-1:-1:-1","scope":56019,"sourceUnit":5559,"symbolAliases":[{"foreign":{"id":53808,"name":"Script","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":5558,"src":"66:6:100","typeDescriptions":{}},"nameLocation":"-1:-1:-1"}],"unitAlias":""},{"id":53812,"nodeType":"ImportDirective","src":"104:64:100","nodes":[],"absolutePath":"src/dispute/lib/Types.sol","file":"src/dispute/lib/Types.sol","nameLocation":"-1:-1:-1","scope":56019,"sourceUnit":70927,"symbolAliases":[{"foreign":{"id":53810,"name":"GameTypes","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":70870,"src":"113:9:100","typeDescriptions":{}},"nameLocation":"-1:-1:-1"},{"foreign":{"id":53811,"name":"GameType","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":70720,"src":"124:8:100","typeDescriptions":{}},"nameLocation":"-1:-1:-1"}],"unitAlias":""},{"id":53958,"nodeType":"ContractDefinition","src":"306:1713:100","nodes":[{"id":53818,"nodeType":"FunctionDefinition","src":"331:52:100","nodes":[],"functionSelector":"452a9320","implemented":false,"kind":"function","modifiers":[],"name":"guardian","nameLocation":"340:8:100","parameters":{"id":53814,"nodeType":"ParameterList","parameters":[],"src":"348:2:100"},"returnParameters":{"id":53817,"nodeType":"ParameterList","parameters":[{"constant":false,"id":53816,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":53818,"src":"374:7:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":53815,"name":"address","nodeType":"ElementaryTypeName","src":"374:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"373:9:100"},"scope":53958,"stateMutability":"view","virtual":false,"visibility":"external"},{"id":53823,"nodeType":"FunctionDefinition","src":"388:52:100","nodes":[],"functionSelector":"724c184c","implemented":false,"kind":"function","modifiers":[],"name":"GUARDIAN","nameLocation":"397:8:100","parameters":{"id":53819,"nodeType":"ParameterList","parameters":[],"src":"405:2:100"},"returnParameters":{"id":53822,"nodeType":"ParameterList","parameters":[{"constant":false,"id":53821,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":53823,"src":"431:7:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":53820,"name":"address","nodeType":"ElementaryTypeName","src":"431:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"430:9:100"},"scope":53958,"stateMutability":"view","virtual":false,"visibility":"external"},{"id":53828,"nodeType":"FunctionDefinition","src":"445:56:100","nodes":[],"functionSelector":"33d7e2bd","implemented":false,"kind":"function","modifiers":[],"name":"systemConfig","nameLocation":"454:12:100","parameters":{"id":53824,"nodeType":"ParameterList","parameters":[],"src":"466:2:100"},"returnParameters":{"id":53827,"nodeType":"ParameterList","parameters":[{"constant":false,"id":53826,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":53828,"src":"492:7:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":53825,"name":"address","nodeType":"ElementaryTypeName","src":"492:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"491:9:100"},"scope":53958,"stateMutability":"view","virtual":false,"visibility":"external"},{"id":53833,"nodeType":"FunctionDefinition","src":"506:57:100","nodes":[],"functionSelector":"f0498750","implemented":false,"kind":"function","modifiers":[],"name":"SYSTEM_CONFIG","nameLocation":"515:13:100","parameters":{"id":53829,"nodeType":"ParameterList","parameters":[],"src":"528:2:100"},"returnParameters":{"id":53832,"nodeType":"ParameterList","parameters":[{"constant":false,"id":53831,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":53833,"src":"554:7:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":53830,"name":"address","nodeType":"ElementaryTypeName","src":"554:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"553:9:100"},"scope":53958,"stateMutability":"view","virtual":false,"visibility":"external"},{"id":53838,"nodeType":"FunctionDefinition","src":"568:62:100","nodes":[],"functionSelector":"f2b4e617","implemented":false,"kind":"function","modifiers":[],"name":"disputeGameFactory","nameLocation":"577:18:100","parameters":{"id":53834,"nodeType":"ParameterList","parameters":[],"src":"595:2:100"},"returnParameters":{"id":53837,"nodeType":"ParameterList","parameters":[{"constant":false,"id":53836,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":53838,"src":"621:7:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":53835,"name":"address","nodeType":"ElementaryTypeName","src":"621:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"620:9:100"},"scope":53958,"stateMutability":"view","virtual":false,"visibility":"external"},{"id":53843,"nodeType":"FunctionDefinition","src":"635:54:100","nodes":[],"functionSelector":"b682c444","implemented":false,"kind":"function","modifiers":[],"name":"ethLockbox","nameLocation":"644:10:100","parameters":{"id":53839,"nodeType":"ParameterList","parameters":[],"src":"654:2:100"},"returnParameters":{"id":53842,"nodeType":"ParameterList","parameters":[{"constant":false,"id":53841,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":53843,"src":"680:7:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":53840,"name":"address","nodeType":"ElementaryTypeName","src":"680:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"679:9:100"},"scope":53958,"stateMutability":"view","virtual":false,"visibility":"external"},{"id":53848,"nodeType":"FunctionDefinition","src":"694:60:100","nodes":[],"functionSelector":"35e80ab3","implemented":false,"kind":"function","modifiers":[],"name":"superchainConfig","nameLocation":"703:16:100","parameters":{"id":53844,"nodeType":"ParameterList","parameters":[],"src":"719:2:100"},"returnParameters":{"id":53847,"nodeType":"ParameterList","parameters":[{"constant":false,"id":53846,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":53848,"src":"745:7:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":53845,"name":"address","nodeType":"ElementaryTypeName","src":"745:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"744:9:100"},"scope":53958,"stateMutability":"view","virtual":false,"visibility":"external"},{"id":53853,"nodeType":"FunctionDefinition","src":"759:53:100","nodes":[],"functionSelector":"3cb747bf","implemented":false,"kind":"function","modifiers":[],"name":"messenger","nameLocation":"768:9:100","parameters":{"id":53849,"nodeType":"ParameterList","parameters":[],"src":"777:2:100"},"returnParameters":{"id":53852,"nodeType":"ParameterList","parameters":[{"constant":false,"id":53851,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":53853,"src":"803:7:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":53850,"name":"address","nodeType":"ElementaryTypeName","src":"803:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"802:9:100"},"scope":53958,"stateMutability":"view","virtual":false,"visibility":"external"},{"id":53858,"nodeType":"FunctionDefinition","src":"817:58:100","nodes":[],"functionSelector":"3ab76e9f","implemented":false,"kind":"function","modifiers":[],"name":"addressManager","nameLocation":"826:14:100","parameters":{"id":53854,"nodeType":"ParameterList","parameters":[],"src":"840:2:100"},"returnParameters":{"id":53857,"nodeType":"ParameterList","parameters":[{"constant":false,"id":53856,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":53858,"src":"866:7:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":53855,"name":"address","nodeType":"ElementaryTypeName","src":"866:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"865:9:100"},"scope":53958,"stateMutability":"view","virtual":false,"visibility":"external"},{"id":53863,"nodeType":"FunctionDefinition","src":"880:50:100","nodes":[],"functionSelector":"0ff754ea","implemented":false,"kind":"function","modifiers":[],"name":"PORTAL","nameLocation":"889:6:100","parameters":{"id":53859,"nodeType":"ParameterList","parameters":[],"src":"895:2:100"},"returnParameters":{"id":53862,"nodeType":"ParameterList","parameters":[{"constant":false,"id":53861,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":53863,"src":"921:7:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":53860,"name":"address","nodeType":"ElementaryTypeName","src":"921:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"920:9:100"},"scope":53958,"stateMutability":"view","virtual":false,"visibility":"external"},{"id":53868,"nodeType":"FunctionDefinition","src":"935:50:100","nodes":[],"functionSelector":"6425666b","implemented":false,"kind":"function","modifiers":[],"name":"portal","nameLocation":"944:6:100","parameters":{"id":53864,"nodeType":"ParameterList","parameters":[],"src":"950:2:100"},"returnParameters":{"id":53867,"nodeType":"ParameterList","parameters":[{"constant":false,"id":53866,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":53868,"src":"976:7:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":53865,"name":"address","nodeType":"ElementaryTypeName","src":"976:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"975:9:100"},"scope":53958,"stateMutability":"view","virtual":false,"visibility":"external"},{"id":53873,"nodeType":"FunctionDefinition","src":"990:58:100","nodes":[],"functionSelector":"c4e8ddfa","implemented":false,"kind":"function","modifiers":[],"name":"l1ERC721Bridge","nameLocation":"999:14:100","parameters":{"id":53869,"nodeType":"ParameterList","parameters":[],"src":"1013:2:100"},"returnParameters":{"id":53872,"nodeType":"ParameterList","parameters":[{"constant":false,"id":53871,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":53873,"src":"1039:7:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":53870,"name":"address","nodeType":"ElementaryTypeName","src":"1039:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"1038:9:100"},"scope":53958,"stateMutability":"view","virtual":false,"visibility":"external"},{"id":53878,"nodeType":"FunctionDefinition","src":"1053:72:100","nodes":[],"functionSelector":"9b7d7f0a","implemented":false,"kind":"function","modifiers":[],"name":"optimismMintableERC20Factory","nameLocation":"1062:28:100","parameters":{"id":53874,"nodeType":"ParameterList","parameters":[],"src":"1090:2:100"},"returnParameters":{"id":53877,"nodeType":"ParameterList","parameters":[{"constant":false,"id":53876,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":53878,"src":"1116:7:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":53875,"name":"address","nodeType":"ElementaryTypeName","src":"1116:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"1115:9:100"},"scope":53958,"stateMutability":"view","virtual":false,"visibility":"external"},{"id":53886,"nodeType":"FunctionDefinition","src":"1130:71:100","nodes":[],"functionSelector":"1b685b9e","implemented":false,"kind":"function","modifiers":[],"name":"gameImpls","nameLocation":"1139:9:100","parameters":{"id":53882,"nodeType":"ParameterList","parameters":[{"constant":false,"id":53881,"mutability":"mutable","name":"_gameType","nameLocation":"1158:9:100","nodeType":"VariableDeclaration","scope":53886,"src":"1149:18:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_userDefinedValueType$_GameType_$70720","typeString":"GameType"},"typeName":{"id":53880,"nodeType":"UserDefinedTypeName","pathNode":{"id":53879,"name":"GameType","nameLocations":["1149:8:100"],"nodeType":"IdentifierPath","referencedDeclaration":70720,"src":"1149:8:100"},"referencedDeclaration":70720,"src":"1149:8:100","typeDescriptions":{"typeIdentifier":"t_userDefinedValueType$_GameType_$70720","typeString":"GameType"}},"visibility":"internal"}],"src":"1148:20:100"},"returnParameters":{"id":53885,"nodeType":"ParameterList","parameters":[{"constant":false,"id":53884,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":53886,"src":"1192:7:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":53883,"name":"address","nodeType":"ElementaryTypeName","src":"1192:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"1191:9:100"},"scope":53958,"stateMutability":"view","virtual":false,"visibility":"external"},{"id":53892,"nodeType":"FunctionDefinition","src":"1206:62:100","nodes":[],"functionSelector":"3c9f397c","implemented":false,"kind":"function","modifiers":[],"name":"respectedGameType","nameLocation":"1215:17:100","parameters":{"id":53887,"nodeType":"ParameterList","parameters":[],"src":"1232:2:100"},"returnParameters":{"id":53891,"nodeType":"ParameterList","parameters":[{"constant":false,"id":53890,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":53892,"src":"1258:8:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_userDefinedValueType$_GameType_$70720","typeString":"GameType"},"typeName":{"id":53889,"nodeType":"UserDefinedTypeName","pathNode":{"id":53888,"name":"GameType","nameLocations":["1258:8:100"],"nodeType":"IdentifierPath","referencedDeclaration":70720,"src":"1258:8:100"},"referencedDeclaration":70720,"src":"1258:8:100","typeDescriptions":{"typeIdentifier":"t_userDefinedValueType$_GameType_$70720","typeString":"GameType"}},"visibility":"internal"}],"src":"1257:10:100"},"scope":53958,"stateMutability":"view","virtual":false,"visibility":"external"},{"id":53897,"nodeType":"FunctionDefinition","src":"1273:63:100","nodes":[],"functionSelector":"5c0cba33","implemented":false,"kind":"function","modifiers":[],"name":"anchorStateRegistry","nameLocation":"1282:19:100","parameters":{"id":53893,"nodeType":"ParameterList","parameters":[],"src":"1301:2:100"},"returnParameters":{"id":53896,"nodeType":"ParameterList","parameters":[{"constant":false,"id":53895,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":53897,"src":"1327:7:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":53894,"name":"address","nodeType":"ElementaryTypeName","src":"1327:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"1326:9:100"},"scope":53958,"stateMutability":"view","virtual":false,"visibility":"external"},{"id":53902,"nodeType":"FunctionDefinition","src":"1341:53:100","nodes":[],"functionSelector":"001c2ff6","implemented":false,"kind":"function","modifiers":[],"name":"L2_ORACLE","nameLocation":"1350:9:100","parameters":{"id":53898,"nodeType":"ParameterList","parameters":[],"src":"1359:2:100"},"returnParameters":{"id":53901,"nodeType":"ParameterList","parameters":[{"constant":false,"id":53900,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":53902,"src":"1385:7:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":53899,"name":"address","nodeType":"ElementaryTypeName","src":"1385:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"1384:9:100"},"scope":53958,"stateMutability":"view","virtual":false,"visibility":"external"},{"id":53907,"nodeType":"FunctionDefinition","src":"1399:52:100","nodes":[],"functionSelector":"9b5f694a","implemented":false,"kind":"function","modifiers":[],"name":"l2Oracle","nameLocation":"1408:8:100","parameters":{"id":53903,"nodeType":"ParameterList","parameters":[],"src":"1416:2:100"},"returnParameters":{"id":53906,"nodeType":"ParameterList","parameters":[{"constant":false,"id":53905,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":53907,"src":"1442:7:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":53904,"name":"address","nodeType":"ElementaryTypeName","src":"1442:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"1441:9:100"},"scope":53958,"stateMutability":"view","virtual":false,"visibility":"external"},{"id":53912,"nodeType":"FunctionDefinition","src":"1456:46:100","nodes":[],"functionSelector":"3a768463","implemented":false,"kind":"function","modifiers":[],"name":"vm","nameLocation":"1465:2:100","parameters":{"id":53908,"nodeType":"ParameterList","parameters":[],"src":"1467:2:100"},"returnParameters":{"id":53911,"nodeType":"ParameterList","parameters":[{"constant":false,"id":53910,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":53912,"src":"1493:7:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":53909,"name":"address","nodeType":"ElementaryTypeName","src":"1493:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"1492:9:100"},"scope":53958,"stateMutability":"view","virtual":false,"visibility":"external"},{"id":53917,"nodeType":"FunctionDefinition","src":"1507:50:100","nodes":[],"functionSelector":"7dc0d1d0","implemented":false,"kind":"function","modifiers":[],"name":"oracle","nameLocation":"1516:6:100","parameters":{"id":53913,"nodeType":"ParameterList","parameters":[],"src":"1522:2:100"},"returnParameters":{"id":53916,"nodeType":"ParameterList","parameters":[{"constant":false,"id":53915,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":53917,"src":"1548:7:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":53914,"name":"address","nodeType":"ElementaryTypeName","src":"1548:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"1547:9:100"},"scope":53958,"stateMutability":"view","virtual":false,"visibility":"external"},{"id":53922,"nodeType":"FunctionDefinition","src":"1562:54:100","nodes":[],"functionSelector":"534db0e2","implemented":false,"kind":"function","modifiers":[],"name":"challenger","nameLocation":"1571:10:100","parameters":{"id":53918,"nodeType":"ParameterList","parameters":[],"src":"1581:2:100"},"returnParameters":{"id":53921,"nodeType":"ParameterList","parameters":[{"constant":false,"id":53920,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":53922,"src":"1607:7:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":53919,"name":"address","nodeType":"ElementaryTypeName","src":"1607:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"1606:9:100"},"scope":53958,"stateMutability":"view","virtual":false,"visibility":"external"},{"id":53927,"nodeType":"FunctionDefinition","src":"1621:52:100","nodes":[],"functionSelector":"a8e4fb90","implemented":false,"kind":"function","modifiers":[],"name":"proposer","nameLocation":"1630:8:100","parameters":{"id":53923,"nodeType":"ParameterList","parameters":[],"src":"1638:2:100"},"returnParameters":{"id":53926,"nodeType":"ParameterList","parameters":[{"constant":false,"id":53925,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":53927,"src":"1664:7:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":53924,"name":"address","nodeType":"ElementaryTypeName","src":"1664:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"1663:9:100"},"scope":53958,"stateMutability":"view","virtual":false,"visibility":"external"},{"id":53932,"nodeType":"FunctionDefinition","src":"1678:52:100","nodes":[],"functionSelector":"bffa7f0f","implemented":false,"kind":"function","modifiers":[],"name":"PROPOSER","nameLocation":"1687:8:100","parameters":{"id":53928,"nodeType":"ParameterList","parameters":[],"src":"1695:2:100"},"returnParameters":{"id":53931,"nodeType":"ParameterList","parameters":[{"constant":false,"id":53930,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":53932,"src":"1721:7:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":53929,"name":"address","nodeType":"ElementaryTypeName","src":"1721:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"1720:9:100"},"scope":53958,"stateMutability":"view","virtual":false,"visibility":"external"},{"id":53937,"nodeType":"FunctionDefinition","src":"1735:55:100","nodes":[],"functionSelector":"e81b2c6d","implemented":false,"kind":"function","modifiers":[],"name":"batcherHash","nameLocation":"1744:11:100","parameters":{"id":53933,"nodeType":"ParameterList","parameters":[],"src":"1755:2:100"},"returnParameters":{"id":53936,"nodeType":"ParameterList","parameters":[{"constant":false,"id":53935,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":53937,"src":"1781:7:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_bytes32","typeString":"bytes32"},"typeName":{"id":53934,"name":"bytes32","nodeType":"ElementaryTypeName","src":"1781:7:100","typeDescriptions":{"typeIdentifier":"t_bytes32","typeString":"bytes32"}},"visibility":"internal"}],"src":"1780:9:100"},"scope":53958,"stateMutability":"view","virtual":false,"visibility":"external"},{"id":53942,"nodeType":"FunctionDefinition","src":"1795:49:100","nodes":[],"functionSelector":"f851a440","implemented":false,"kind":"function","modifiers":[],"name":"admin","nameLocation":"1804:5:100","parameters":{"id":53938,"nodeType":"ParameterList","parameters":[],"src":"1809:2:100"},"returnParameters":{"id":53941,"nodeType":"ParameterList","parameters":[{"constant":false,"id":53940,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":53942,"src":"1835:7:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":53939,"name":"address","nodeType":"ElementaryTypeName","src":"1835:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"1834:9:100"},"scope":53958,"stateMutability":"view","virtual":false,"visibility":"external"},{"id":53947,"nodeType":"FunctionDefinition","src":"1849:49:100","nodes":[],"functionSelector":"8da5cb5b","implemented":false,"kind":"function","modifiers":[],"name":"owner","nameLocation":"1858:5:100","parameters":{"id":53943,"nodeType":"ParameterList","parameters":[],"src":"1863:2:100"},"returnParameters":{"id":53946,"nodeType":"ParameterList","parameters":[{"constant":false,"id":53945,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":53947,"src":"1889:7:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":53944,"name":"address","nodeType":"ElementaryTypeName","src":"1889:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"1888:9:100"},"scope":53958,"stateMutability":"view","virtual":false,"visibility":"external"},{"id":53952,"nodeType":"FunctionDefinition","src":"1903:61:100","nodes":[],"functionSelector":"1fd19ee1","implemented":false,"kind":"function","modifiers":[],"name":"unsafeBlockSigner","nameLocation":"1912:17:100","parameters":{"id":53948,"nodeType":"ParameterList","parameters":[],"src":"1929:2:100"},"returnParameters":{"id":53951,"nodeType":"ParameterList","parameters":[{"constant":false,"id":53950,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":53952,"src":"1955:7:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":53949,"name":"address","nodeType":"ElementaryTypeName","src":"1955:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"1954:9:100"},"scope":53958,"stateMutability":"view","virtual":false,"visibility":"external"},{"id":53957,"nodeType":"FunctionDefinition","src":"1969:48:100","nodes":[],"functionSelector":"3fc8cef3","implemented":false,"kind":"function","modifiers":[],"name":"weth","nameLocation":"1978:4:100","parameters":{"id":53953,"nodeType":"ParameterList","parameters":[],"src":"1982:2:100"},"returnParameters":{"id":53956,"nodeType":"ParameterList","parameters":[{"constant":false,"id":53955,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":53957,"src":"2008:7:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":53954,"name":"address","nodeType":"ElementaryTypeName","src":"2008:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"2007:9:100"},"scope":53958,"stateMutability":"view","virtual":false,"visibility":"external"}],"abstract":false,"baseContracts":[],"canonicalName":"IFetcher","contractDependencies":[],"contractKind":"interface","documentation":{"id":53813,"nodeType":"StructuredDocumentation","src":"170:136:100","text":"@notice Contains getters for arbitrary methods from all L1 contracts, including legacy getters\n that have since been deprecated."},"fullyImplemented":false,"linearizedBaseContracts":[53958],"name":"IFetcher","nameLocation":"316:8:100","scope":56019,"usedErrors":[],"usedEvents":[]},{"id":54041,"nodeType":"ContractDefinition","src":"2021:934:100","nodes":[{"id":53960,"nodeType":"VariableDeclaration","src":"2056:35:100","nodes":[],"constant":false,"mutability":"mutable","name":"_systemConfigProxy","nameLocation":"2073:18:100","scope":54041,"stateVariable":true,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":53959,"name":"address","nodeType":"ElementaryTypeName","src":"2056:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"},{"id":53962,"nodeType":"VariableDeclaration","src":"2097:39:100","nodes":[],"constant":false,"mutability":"mutable","name":"_l1StandardBridgeProxy","nameLocation":"2114:22:100","scope":54041,"stateVariable":true,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":53961,"name":"address","nodeType":"ElementaryTypeName","src":"2097:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"},{"id":54004,"nodeType":"FunctionDefinition","src":"2143:378:100","nodes":[],"body":{"id":54003,"nodeType":"Block","src":"2191:330:100","nodes":[],"statements":[{"expression":{"arguments":[{"commonType":{"typeIdentifier":"t_address","typeString":"address"},"id":53975,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftExpression":{"id":53970,"name":"_addr","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":53966,"src":"2209:5:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"BinaryOperation","operator":"!=","rightExpression":{"arguments":[{"hexValue":"30","id":53973,"isConstant":false,"isLValue":false,"isPure":true,"kind":"number","lValueRequested":false,"nodeType":"Literal","src":"2226:1:100","typeDescriptions":{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"},"value":"0"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"}],"id":53972,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"nodeType":"ElementaryTypeNameExpression","src":"2218:7:100","typeDescriptions":{"typeIdentifier":"t_type$_t_address_$","typeString":"type(address)"},"typeName":{"id":53971,"name":"address","nodeType":"ElementaryTypeName","src":"2218:7:100","typeDescriptions":{}}},"id":53974,"isConstant":false,"isLValue":false,"isPure":true,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"2218:10:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"src":"2209:19:100","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},{"hexValue":"4665746368436861696e496e666f496e7075743a2063616e6e6f7420736574207a65726f2061646472657373","id":53976,"isConstant":false,"isLValue":false,"isPure":true,"kind":"string","lValueRequested":false,"nodeType":"Literal","src":"2230:46:100","typeDescriptions":{"typeIdentifier":"t_stringliteral_0336126ace187312d69da4c7cf05307af6a6596e8c75de2974f56108baf24145","typeString":"literal_string \"FetchChainInfoInput: cannot set zero address\""},"value":"FetchChainInfoInput: cannot set zero address"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_bool","typeString":"bool"},{"typeIdentifier":"t_stringliteral_0336126ace187312d69da4c7cf05307af6a6596e8c75de2974f56108baf24145","typeString":"literal_string \"FetchChainInfoInput: cannot set zero address\""}],"id":53969,"name":"require","nodeType":"Identifier","overloadedDeclarations":[-18,-18,-18],"referencedDeclaration":-18,"src":"2201:7:100","typeDescriptions":{"typeIdentifier":"t_function_require_pure$_t_bool_$_t_string_memory_ptr_$returns$__$","typeString":"function (bool,string memory) pure"}},"id":53977,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"2201:76:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":53978,"nodeType":"ExpressionStatement","src":"2201:76:100"},{"condition":{"commonType":{"typeIdentifier":"t_bytes4","typeString":"bytes4"},"id":53983,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftExpression":{"id":53979,"name":"_sel","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":53964,"src":"2291:4:100","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},"nodeType":"BinaryOperation","operator":"==","rightExpression":{"expression":{"expression":{"id":53980,"name":"this","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":-28,"src":"2299:4:100","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoInput_$54041","typeString":"contract FetchChainInfoInput"}},"id":53981,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"2304:17:100","memberName":"systemConfigProxy","nodeType":"MemberAccess","referencedDeclaration":54022,"src":"2299:22:100","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":53982,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"memberLocation":"2322:8:100","memberName":"selector","nodeType":"MemberAccess","src":"2299:31:100","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},"src":"2291:39:100","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},"falseBody":{"condition":{"commonType":{"typeIdentifier":"t_bytes4","typeString":"bytes4"},"id":53992,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftExpression":{"id":53988,"name":"_sel","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":53964,"src":"2377:4:100","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},"nodeType":"BinaryOperation","operator":"==","rightExpression":{"expression":{"expression":{"id":53989,"name":"this","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":-28,"src":"2385:4:100","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoInput_$54041","typeString":"contract FetchChainInfoInput"}},"id":53990,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"2390:21:100","memberName":"l1StandardBridgeProxy","nodeType":"MemberAccess","referencedDeclaration":54040,"src":"2385:26:100","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":53991,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"memberLocation":"2412:8:100","memberName":"selector","nodeType":"MemberAccess","src":"2385:35:100","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},"src":"2377:43:100","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},"falseBody":{"expression":{"arguments":[{"hexValue":"4665746368436861696e496e666f496e7075743a20756e6b6e6f776e2073656c6563746f72","id":53998,"isConstant":false,"isLValue":false,"isPure":true,"kind":"string","lValueRequested":false,"nodeType":"Literal","src":"2474:39:100","typeDescriptions":{"typeIdentifier":"t_stringliteral_3ec062448196d68b2d186fadb5ffe52c72f0a2b929c9d178cd6e6612281f066b","typeString":"literal_string \"FetchChainInfoInput: unknown selector\""},"value":"FetchChainInfoInput: unknown selector"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_stringliteral_3ec062448196d68b2d186fadb5ffe52c72f0a2b929c9d178cd6e6612281f066b","typeString":"literal_string \"FetchChainInfoInput: unknown selector\""}],"id":53997,"name":"revert","nodeType":"Identifier","overloadedDeclarations":[-19,-19],"referencedDeclaration":-19,"src":"2467:6:100","typeDescriptions":{"typeIdentifier":"t_function_revert_pure$_t_string_memory_ptr_$returns$__$","typeString":"function (string memory) pure"}},"id":53999,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"2467:47:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":54000,"nodeType":"ExpressionStatement","src":"2467:47:100"},"id":54001,"nodeType":"IfStatement","src":"2373:141:100","trueBody":{"expression":{"id":53995,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftHandSide":{"id":53993,"name":"_l1StandardBridgeProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":53962,"src":"2422:22:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"Assignment","operator":"=","rightHandSide":{"id":53994,"name":"_addr","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":53966,"src":"2447:5:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"src":"2422:30:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"id":53996,"nodeType":"ExpressionStatement","src":"2422:30:100"}},"id":54002,"nodeType":"IfStatement","src":"2287:227:100","trueBody":{"expression":{"id":53986,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftHandSide":{"id":53984,"name":"_systemConfigProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":53960,"src":"2332:18:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"Assignment","operator":"=","rightHandSide":{"id":53985,"name":"_addr","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":53966,"src":"2353:5:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"src":"2332:26:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"id":53987,"nodeType":"ExpressionStatement","src":"2332:26:100"}}]},"functionSelector":"c3e39250","implemented":true,"kind":"function","modifiers":[],"name":"set","nameLocation":"2152:3:100","parameters":{"id":53967,"nodeType":"ParameterList","parameters":[{"constant":false,"id":53964,"mutability":"mutable","name":"_sel","nameLocation":"2163:4:100","nodeType":"VariableDeclaration","scope":54004,"src":"2156:11:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"},"typeName":{"id":53963,"name":"bytes4","nodeType":"ElementaryTypeName","src":"2156:6:100","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},"visibility":"internal"},{"constant":false,"id":53966,"mutability":"mutable","name":"_addr","nameLocation":"2177:5:100","nodeType":"VariableDeclaration","scope":54004,"src":"2169:13:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":53965,"name":"address","nodeType":"ElementaryTypeName","src":"2169:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"2155:28:100"},"returnParameters":{"id":53968,"nodeType":"ParameterList","parameters":[],"src":"2191:0:100"},"scope":54041,"stateMutability":"nonpayable","virtual":false,"visibility":"public"},{"id":54022,"nodeType":"FunctionDefinition","src":"2527:202:100","nodes":[],"body":{"id":54021,"nodeType":"Block","src":"2586:143:100","nodes":[],"statements":[{"expression":{"arguments":[{"commonType":{"typeIdentifier":"t_address","typeString":"address"},"id":54015,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftExpression":{"id":54010,"name":"_systemConfigProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":53960,"src":"2604:18:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"BinaryOperation","operator":"!=","rightExpression":{"arguments":[{"hexValue":"30","id":54013,"isConstant":false,"isLValue":false,"isPure":true,"kind":"number","lValueRequested":false,"nodeType":"Literal","src":"2634:1:100","typeDescriptions":{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"},"value":"0"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"}],"id":54012,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"nodeType":"ElementaryTypeNameExpression","src":"2626:7:100","typeDescriptions":{"typeIdentifier":"t_type$_t_address_$","typeString":"type(address)"},"typeName":{"id":54011,"name":"address","nodeType":"ElementaryTypeName","src":"2626:7:100","typeDescriptions":{}}},"id":54014,"isConstant":false,"isLValue":false,"isPure":true,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"2626:10:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"src":"2604:32:100","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},{"hexValue":"4665746368436861696e496e666f496e7075743a2073797374656d436f6e66696750726f7879206e6f7420736574","id":54016,"isConstant":false,"isLValue":false,"isPure":true,"kind":"string","lValueRequested":false,"nodeType":"Literal","src":"2638:48:100","typeDescriptions":{"typeIdentifier":"t_stringliteral_cefeeda9841ab81b734a3e4f7bf39aeeab7704e02e2040531bd67ea944e4d5d3","typeString":"literal_string \"FetchChainInfoInput: systemConfigProxy not set\""},"value":"FetchChainInfoInput: systemConfigProxy not set"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_bool","typeString":"bool"},{"typeIdentifier":"t_stringliteral_cefeeda9841ab81b734a3e4f7bf39aeeab7704e02e2040531bd67ea944e4d5d3","typeString":"literal_string \"FetchChainInfoInput: systemConfigProxy not set\""}],"id":54009,"name":"require","nodeType":"Identifier","overloadedDeclarations":[-18,-18,-18],"referencedDeclaration":-18,"src":"2596:7:100","typeDescriptions":{"typeIdentifier":"t_function_require_pure$_t_bool_$_t_string_memory_ptr_$returns$__$","typeString":"function (bool,string memory) pure"}},"id":54017,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"2596:91:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":54018,"nodeType":"ExpressionStatement","src":"2596:91:100"},{"expression":{"id":54019,"name":"_systemConfigProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":53960,"src":"2704:18:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"functionReturnParameters":54008,"id":54020,"nodeType":"Return","src":"2697:25:100"}]},"functionSelector":"c17db6e3","implemented":true,"kind":"function","modifiers":[],"name":"systemConfigProxy","nameLocation":"2536:17:100","parameters":{"id":54005,"nodeType":"ParameterList","parameters":[],"src":"2553:2:100"},"returnParameters":{"id":54008,"nodeType":"ParameterList","parameters":[{"constant":false,"id":54007,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":54022,"src":"2577:7:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":54006,"name":"address","nodeType":"ElementaryTypeName","src":"2577:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"2576:9:100"},"scope":54041,"stateMutability":"view","virtual":false,"visibility":"public"},{"id":54040,"nodeType":"FunctionDefinition","src":"2735:218:100","nodes":[],"body":{"id":54039,"nodeType":"Block","src":"2798:155:100","nodes":[],"statements":[{"expression":{"arguments":[{"commonType":{"typeIdentifier":"t_address","typeString":"address"},"id":54033,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftExpression":{"id":54028,"name":"_l1StandardBridgeProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":53962,"src":"2816:22:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"BinaryOperation","operator":"!=","rightExpression":{"arguments":[{"hexValue":"30","id":54031,"isConstant":false,"isLValue":false,"isPure":true,"kind":"number","lValueRequested":false,"nodeType":"Literal","src":"2850:1:100","typeDescriptions":{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"},"value":"0"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"}],"id":54030,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"nodeType":"ElementaryTypeNameExpression","src":"2842:7:100","typeDescriptions":{"typeIdentifier":"t_type$_t_address_$","typeString":"type(address)"},"typeName":{"id":54029,"name":"address","nodeType":"ElementaryTypeName","src":"2842:7:100","typeDescriptions":{}}},"id":54032,"isConstant":false,"isLValue":false,"isPure":true,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"2842:10:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"src":"2816:36:100","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},{"hexValue":"4665746368436861696e496e666f496e7075743a206c315374616e6461726442726964676550726f7879206e6f7420736574","id":54034,"isConstant":false,"isLValue":false,"isPure":true,"kind":"string","lValueRequested":false,"nodeType":"Literal","src":"2854:52:100","typeDescriptions":{"typeIdentifier":"t_stringliteral_be85b0ed3fc58e97f8b79e4d9fb1c191539515cae509acde6becd9338254d33b","typeString":"literal_string \"FetchChainInfoInput: l1StandardBridgeProxy not set\""},"value":"FetchChainInfoInput: l1StandardBridgeProxy not set"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_bool","typeString":"bool"},{"typeIdentifier":"t_stringliteral_be85b0ed3fc58e97f8b79e4d9fb1c191539515cae509acde6becd9338254d33b","typeString":"literal_string \"FetchChainInfoInput: l1StandardBridgeProxy not set\""}],"id":54027,"name":"require","nodeType":"Identifier","overloadedDeclarations":[-18,-18,-18],"referencedDeclaration":-18,"src":"2808:7:100","typeDescriptions":{"typeIdentifier":"t_function_require_pure$_t_bool_$_t_string_memory_ptr_$returns$__$","typeString":"function (bool,string memory) pure"}},"id":54035,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"2808:99:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":54036,"nodeType":"ExpressionStatement","src":"2808:99:100"},{"expression":{"id":54037,"name":"_l1StandardBridgeProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":53962,"src":"2924:22:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"functionReturnParameters":54026,"id":54038,"nodeType":"Return","src":"2917:29:100"}]},"functionSelector":"102b6069","implemented":true,"kind":"function","modifiers":[],"name":"l1StandardBridgeProxy","nameLocation":"2744:21:100","parameters":{"id":54023,"nodeType":"ParameterList","parameters":[],"src":"2765:2:100"},"returnParameters":{"id":54026,"nodeType":"ParameterList","parameters":[{"constant":false,"id":54025,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":54040,"src":"2789:7:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":54024,"name":"address","nodeType":"ElementaryTypeName","src":"2789:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"2788:9:100"},"scope":54041,"stateMutability":"view","virtual":false,"visibility":"public"}],"abstract":false,"baseContracts":[],"canonicalName":"FetchChainInfoInput","contractDependencies":[],"contractKind":"contract","fullyImplemented":true,"linearizedBaseContracts":[54041],"name":"FetchChainInfoInput","nameLocation":"2030:19:100","scope":56019,"usedErrors":[],"usedEvents":[]},{"id":54911,"nodeType":"ContractDefinition","src":"2957:10642:100","nodes":[{"id":54043,"nodeType":"VariableDeclaration","src":"3049:39:100","nodes":[],"constant":false,"mutability":"mutable","name":"_superchainConfigProxy","nameLocation":"3066:22:100","scope":54911,"stateVariable":true,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":54042,"name":"address","nodeType":"ElementaryTypeName","src":"3049:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"},{"id":54045,"nodeType":"VariableDeclaration","src":"3129:26:100","nodes":[],"constant":false,"mutability":"mutable","name":"_mipsImpl","nameLocation":"3146:9:100","scope":54911,"stateVariable":true,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":54044,"name":"address","nodeType":"ElementaryTypeName","src":"3129:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"},{"id":54047,"nodeType":"VariableDeclaration","src":"3161:36:100","nodes":[],"constant":false,"mutability":"mutable","name":"_preimageOracleImpl","nameLocation":"3178:19:100","scope":54911,"stateVariable":true,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":54046,"name":"address","nodeType":"ElementaryTypeName","src":"3161:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"},{"id":54049,"nodeType":"VariableDeclaration","src":"3230:36:100","nodes":[],"constant":false,"mutability":"mutable","name":"_addressManagerImpl","nameLocation":"3247:19:100","scope":54911,"stateVariable":true,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":54048,"name":"address","nodeType":"ElementaryTypeName","src":"3230:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"},{"id":54051,"nodeType":"VariableDeclaration","src":"3272:33:100","nodes":[],"constant":false,"mutability":"mutable","name":"_ethLockboxProxy","nameLocation":"3289:16:100","scope":54911,"stateVariable":true,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":54050,"name":"address","nodeType":"ElementaryTypeName","src":"3272:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"},{"id":54053,"nodeType":"VariableDeclaration","src":"3311:45:100","nodes":[],"constant":false,"mutability":"mutable","name":"_l1CrossDomainMessengerProxy","nameLocation":"3328:28:100","scope":54911,"stateVariable":true,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":54052,"name":"address","nodeType":"ElementaryTypeName","src":"3311:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"},{"id":54055,"nodeType":"VariableDeclaration","src":"3362:37:100","nodes":[],"constant":false,"mutability":"mutable","name":"_l1Erc721BridgeProxy","nameLocation":"3379:20:100","scope":54911,"stateVariable":true,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":54054,"name":"address","nodeType":"ElementaryTypeName","src":"3362:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"},{"id":54057,"nodeType":"VariableDeclaration","src":"3405:39:100","nodes":[],"constant":false,"mutability":"mutable","name":"_l1StandardBridgeProxy","nameLocation":"3422:22:100","scope":54911,"stateVariable":true,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":54056,"name":"address","nodeType":"ElementaryTypeName","src":"3405:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"},{"id":54059,"nodeType":"VariableDeclaration","src":"3450:37:100","nodes":[],"constant":false,"mutability":"mutable","name":"_l2OutputOracleProxy","nameLocation":"3467:20:100","scope":54911,"stateVariable":true,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":54058,"name":"address","nodeType":"ElementaryTypeName","src":"3450:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"},{"id":54061,"nodeType":"VariableDeclaration","src":"3493:51:100","nodes":[],"constant":false,"mutability":"mutable","name":"_optimismMintableErc20FactoryProxy","nameLocation":"3510:34:100","scope":54911,"stateVariable":true,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":54060,"name":"address","nodeType":"ElementaryTypeName","src":"3493:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"},{"id":54063,"nodeType":"VariableDeclaration","src":"3550:37:100","nodes":[],"constant":false,"mutability":"mutable","name":"_optimismPortalProxy","nameLocation":"3567:20:100","scope":54911,"stateVariable":true,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":54062,"name":"address","nodeType":"ElementaryTypeName","src":"3550:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"},{"id":54065,"nodeType":"VariableDeclaration","src":"3593:35:100","nodes":[],"constant":false,"mutability":"mutable","name":"_systemConfigProxy","nameLocation":"3610:18:100","scope":54911,"stateVariable":true,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":54064,"name":"address","nodeType":"ElementaryTypeName","src":"3593:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"},{"id":54067,"nodeType":"VariableDeclaration","src":"3634:39:100","nodes":[],"constant":false,"mutability":"mutable","name":"_opChainProxyAdminImpl","nameLocation":"3651:22:100","scope":54911,"stateVariable":true,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":54066,"name":"address","nodeType":"ElementaryTypeName","src":"3634:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"},{"id":54069,"nodeType":"VariableDeclaration","src":"3679:42:100","nodes":[],"constant":false,"mutability":"mutable","name":"_anchorStateRegistryProxy","nameLocation":"3696:25:100","scope":54911,"stateVariable":true,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":54068,"name":"address","nodeType":"ElementaryTypeName","src":"3679:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"},{"id":54071,"nodeType":"VariableDeclaration","src":"3727:50:100","nodes":[],"constant":false,"mutability":"mutable","name":"_delayedWethPermissionedGameProxy","nameLocation":"3744:33:100","scope":54911,"stateVariable":true,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":54070,"name":"address","nodeType":"ElementaryTypeName","src":"3727:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"},{"id":54073,"nodeType":"VariableDeclaration","src":"3783:52:100","nodes":[],"constant":false,"mutability":"mutable","name":"_delayedWethPermissionlessGameProxy","nameLocation":"3800:35:100","scope":54911,"stateVariable":true,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":54072,"name":"address","nodeType":"ElementaryTypeName","src":"3783:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"},{"id":54075,"nodeType":"VariableDeclaration","src":"3841:41:100","nodes":[],"constant":false,"mutability":"mutable","name":"_disputeGameFactoryProxy","nameLocation":"3858:24:100","scope":54911,"stateVariable":true,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":54074,"name":"address","nodeType":"ElementaryTypeName","src":"3841:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"},{"id":54077,"nodeType":"VariableDeclaration","src":"3888:38:100","nodes":[],"constant":false,"mutability":"mutable","name":"_faultDisputeGameImpl","nameLocation":"3905:21:100","scope":54911,"stateVariable":true,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":54076,"name":"address","nodeType":"ElementaryTypeName","src":"3888:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"},{"id":54079,"nodeType":"VariableDeclaration","src":"3932:48:100","nodes":[],"constant":false,"mutability":"mutable","name":"_faultDisputeGameCannonKonaImpl","nameLocation":"3949:31:100","scope":54911,"stateVariable":true,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":54078,"name":"address","nodeType":"ElementaryTypeName","src":"3932:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"},{"id":54081,"nodeType":"VariableDeclaration","src":"3986:45:100","nodes":[],"constant":false,"mutability":"mutable","name":"_permissionedDisputeGameImpl","nameLocation":"4003:28:100","scope":54911,"stateVariable":true,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":54080,"name":"address","nodeType":"ElementaryTypeName","src":"3986:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"},{"id":54083,"nodeType":"VariableDeclaration","src":"4051:35:100","nodes":[],"constant":false,"mutability":"mutable","name":"_systemConfigOwner","nameLocation":"4068:18:100","scope":54911,"stateVariable":true,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":54082,"name":"address","nodeType":"ElementaryTypeName","src":"4051:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"},{"id":54085,"nodeType":"VariableDeclaration","src":"4092:40:100","nodes":[],"constant":false,"mutability":"mutable","name":"_opChainProxyAdminOwner","nameLocation":"4109:23:100","scope":54911,"stateVariable":true,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":54084,"name":"address","nodeType":"ElementaryTypeName","src":"4092:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"},{"id":54087,"nodeType":"VariableDeclaration","src":"4138:33:100","nodes":[],"constant":false,"mutability":"mutable","name":"_opChainGuardian","nameLocation":"4155:16:100","scope":54911,"stateVariable":true,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":54086,"name":"address","nodeType":"ElementaryTypeName","src":"4138:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"},{"id":54089,"nodeType":"VariableDeclaration","src":"4177:28:100","nodes":[],"constant":false,"mutability":"mutable","name":"_challenger","nameLocation":"4194:11:100","scope":54911,"stateVariable":true,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":54088,"name":"address","nodeType":"ElementaryTypeName","src":"4177:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"},{"id":54091,"nodeType":"VariableDeclaration","src":"4211:26:100","nodes":[],"constant":false,"mutability":"mutable","name":"_proposer","nameLocation":"4228:9:100","scope":54911,"stateVariable":true,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":54090,"name":"address","nodeType":"ElementaryTypeName","src":"4211:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"},{"id":54093,"nodeType":"VariableDeclaration","src":"4243:35:100","nodes":[],"constant":false,"mutability":"mutable","name":"_unsafeBlockSigner","nameLocation":"4260:18:100","scope":54911,"stateVariable":true,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":54092,"name":"address","nodeType":"ElementaryTypeName","src":"4243:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"},{"id":54095,"nodeType":"VariableDeclaration","src":"4284:32:100","nodes":[],"constant":false,"mutability":"mutable","name":"_batchSubmitter","nameLocation":"4301:15:100","scope":54911,"stateVariable":true,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":54094,"name":"address","nodeType":"ElementaryTypeName","src":"4284:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"},{"id":54097,"nodeType":"VariableDeclaration","src":"4349:27:100","nodes":[],"constant":false,"mutability":"mutable","name":"_permissioned","nameLocation":"4363:13:100","scope":54911,"stateVariable":true,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"},"typeName":{"id":54096,"name":"bool","nodeType":"ElementaryTypeName","src":"4349:4:100","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},"visibility":"internal"},{"id":54099,"nodeType":"VariableDeclaration","src":"4382:29:100","nodes":[],"constant":false,"mutability":"mutable","name":"_permissionless","nameLocation":"4396:15:100","scope":54911,"stateVariable":true,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"},"typeName":{"id":54098,"name":"bool","nodeType":"ElementaryTypeName","src":"4382:4:100","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},"visibility":"internal"},{"id":54102,"nodeType":"VariableDeclaration","src":"4417:36:100","nodes":[],"constant":false,"mutability":"mutable","name":"_respectedGameType","nameLocation":"4435:18:100","scope":54911,"stateVariable":true,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_userDefinedValueType$_GameType_$70720","typeString":"GameType"},"typeName":{"id":54101,"nodeType":"UserDefinedTypeName","pathNode":{"id":54100,"name":"GameType","nameLocations":["4417:8:100"],"nodeType":"IdentifierPath","referencedDeclaration":70720,"src":"4417:8:100"},"referencedDeclaration":70720,"src":"4417:8:100","typeDescriptions":{"typeIdentifier":"t_userDefinedValueType$_GameType_$70720","typeString":"GameType"}},"visibility":"internal"},{"id":54384,"nodeType":"FunctionDefinition","src":"4460:2746:100","nodes":[],"body":{"id":54383,"nodeType":"Block","src":"4508:2698:100","nodes":[],"statements":[{"condition":{"commonType":{"typeIdentifier":"t_bytes4","typeString":"bytes4"},"id":54113,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftExpression":{"id":54109,"name":"_sel","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54104,"src":"4553:4:100","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},"nodeType":"BinaryOperation","operator":"==","rightExpression":{"expression":{"expression":{"id":54110,"name":"this","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":-28,"src":"4561:4:100","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$54911","typeString":"contract FetchChainInfoOutput"}},"id":54111,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"4566:21:100","memberName":"superchainConfigProxy","nodeType":"MemberAccess","referencedDeclaration":54627,"src":"4561:26:100","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":54112,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"memberLocation":"4588:8:100","memberName":"selector","nodeType":"MemberAccess","src":"4561:35:100","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},"src":"4553:43:100","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},"falseBody":{"condition":{"commonType":{"typeIdentifier":"t_bytes4","typeString":"bytes4"},"id":54122,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftExpression":{"id":54118,"name":"_sel","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54104,"src":"4686:4:100","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},"nodeType":"BinaryOperation","operator":"==","rightExpression":{"expression":{"expression":{"id":54119,"name":"this","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":-28,"src":"4694:4:100","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$54911","typeString":"contract FetchChainInfoOutput"}},"id":54120,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"4699:8:100","memberName":"mipsImpl","nodeType":"MemberAccess","referencedDeclaration":54723,"src":"4694:13:100","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":54121,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"memberLocation":"4708:8:100","memberName":"selector","nodeType":"MemberAccess","src":"4694:22:100","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},"src":"4686:30:100","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},"falseBody":{"condition":{"commonType":{"typeIdentifier":"t_bytes4","typeString":"bytes4"},"id":54131,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftExpression":{"id":54127,"name":"_sel","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54104,"src":"4754:4:100","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},"nodeType":"BinaryOperation","operator":"==","rightExpression":{"expression":{"expression":{"id":54128,"name":"this","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":-28,"src":"4762:4:100","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$54911","typeString":"contract FetchChainInfoOutput"}},"id":54129,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"4767:18:100","memberName":"preimageOracleImpl","nodeType":"MemberAccess","referencedDeclaration":54759,"src":"4762:23:100","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":54130,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"memberLocation":"4786:8:100","memberName":"selector","nodeType":"MemberAccess","src":"4762:32:100","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},"src":"4754:40:100","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},"falseBody":{"condition":{"commonType":{"typeIdentifier":"t_bytes4","typeString":"bytes4"},"id":54140,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftExpression":{"id":54136,"name":"_sel","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54104,"src":"4873:4:100","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},"nodeType":"BinaryOperation","operator":"==","rightExpression":{"expression":{"expression":{"id":54137,"name":"this","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":-28,"src":"4881:4:100","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$54911","typeString":"contract FetchChainInfoOutput"}},"id":54138,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"4886:18:100","memberName":"addressManagerImpl","nodeType":"MemberAccess","referencedDeclaration":54457,"src":"4881:23:100","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":54139,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"memberLocation":"4905:8:100","memberName":"selector","nodeType":"MemberAccess","src":"4881:32:100","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},"src":"4873:40:100","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},"falseBody":{"condition":{"commonType":{"typeIdentifier":"t_bytes4","typeString":"bytes4"},"id":54149,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftExpression":{"id":54145,"name":"_sel","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54104,"src":"4961:4:100","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},"nodeType":"BinaryOperation","operator":"==","rightExpression":{"expression":{"expression":{"id":54146,"name":"this","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":-28,"src":"4969:4:100","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$54911","typeString":"contract FetchChainInfoOutput"}},"id":54147,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"4974:15:100","memberName":"ethLockboxProxy","nodeType":"MemberAccess","referencedDeclaration":54465,"src":"4969:20:100","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":54148,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"memberLocation":"4990:8:100","memberName":"selector","nodeType":"MemberAccess","src":"4969:29:100","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},"src":"4961:37:100","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},"falseBody":{"condition":{"commonType":{"typeIdentifier":"t_bytes4","typeString":"bytes4"},"id":54158,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftExpression":{"id":54154,"name":"_sel","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54104,"src":"5043:4:100","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},"nodeType":"BinaryOperation","operator":"==","rightExpression":{"expression":{"expression":{"id":54155,"name":"this","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":-28,"src":"5051:4:100","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$54911","typeString":"contract FetchChainInfoOutput"}},"id":54156,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"5056:27:100","memberName":"l1CrossDomainMessengerProxy","nodeType":"MemberAccess","referencedDeclaration":54483,"src":"5051:32:100","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":54157,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"memberLocation":"5084:8:100","memberName":"selector","nodeType":"MemberAccess","src":"5051:41:100","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},"src":"5043:49:100","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},"falseBody":{"condition":{"commonType":{"typeIdentifier":"t_bytes4","typeString":"bytes4"},"id":54167,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftExpression":{"id":54163,"name":"_sel","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54104,"src":"5149:4:100","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},"nodeType":"BinaryOperation","operator":"==","rightExpression":{"expression":{"expression":{"id":54164,"name":"this","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":-28,"src":"5157:4:100","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$54911","typeString":"contract FetchChainInfoOutput"}},"id":54165,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"5162:19:100","memberName":"l1Erc721BridgeProxy","nodeType":"MemberAccess","referencedDeclaration":54501,"src":"5157:24:100","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":54166,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"memberLocation":"5182:8:100","memberName":"selector","nodeType":"MemberAccess","src":"5157:33:100","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},"src":"5149:41:100","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},"falseBody":{"condition":{"commonType":{"typeIdentifier":"t_bytes4","typeString":"bytes4"},"id":54176,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftExpression":{"id":54172,"name":"_sel","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54104,"src":"5239:4:100","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},"nodeType":"BinaryOperation","operator":"==","rightExpression":{"expression":{"expression":{"id":54173,"name":"this","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":-28,"src":"5247:4:100","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$54911","typeString":"contract FetchChainInfoOutput"}},"id":54174,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"5252:21:100","memberName":"l1StandardBridgeProxy","nodeType":"MemberAccess","referencedDeclaration":54519,"src":"5247:26:100","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":54175,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"memberLocation":"5274:8:100","memberName":"selector","nodeType":"MemberAccess","src":"5247:35:100","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},"src":"5239:43:100","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},"falseBody":{"condition":{"commonType":{"typeIdentifier":"t_bytes4","typeString":"bytes4"},"id":54185,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftExpression":{"id":54181,"name":"_sel","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54104,"src":"5333:4:100","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},"nodeType":"BinaryOperation","operator":"==","rightExpression":{"expression":{"expression":{"id":54182,"name":"this","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":-28,"src":"5341:4:100","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$54911","typeString":"contract FetchChainInfoOutput"}},"id":54183,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"5346:19:100","memberName":"l2OutputOracleProxy","nodeType":"MemberAccess","referencedDeclaration":54537,"src":"5341:24:100","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":54184,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"memberLocation":"5366:8:100","memberName":"selector","nodeType":"MemberAccess","src":"5341:33:100","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},"src":"5333:41:100","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},"falseBody":{"condition":{"commonType":{"typeIdentifier":"t_bytes4","typeString":"bytes4"},"id":54194,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftExpression":{"id":54190,"name":"_sel","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54104,"src":"5423:4:100","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},"nodeType":"BinaryOperation","operator":"==","rightExpression":{"expression":{"expression":{"id":54191,"name":"this","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":-28,"src":"5431:4:100","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$54911","typeString":"contract FetchChainInfoOutput"}},"id":54192,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"5436:33:100","memberName":"optimismMintableErc20FactoryProxy","nodeType":"MemberAccess","referencedDeclaration":54555,"src":"5431:38:100","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":54193,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"memberLocation":"5470:8:100","memberName":"selector","nodeType":"MemberAccess","src":"5431:47:100","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},"src":"5423:55:100","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},"falseBody":{"condition":{"commonType":{"typeIdentifier":"t_bytes4","typeString":"bytes4"},"id":54203,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftExpression":{"id":54199,"name":"_sel","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54104,"src":"5541:4:100","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},"nodeType":"BinaryOperation","operator":"==","rightExpression":{"expression":{"expression":{"id":54200,"name":"this","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":-28,"src":"5549:4:100","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$54911","typeString":"contract FetchChainInfoOutput"}},"id":54201,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"5554:19:100","memberName":"optimismPortalProxy","nodeType":"MemberAccess","referencedDeclaration":54573,"src":"5549:24:100","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":54202,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"memberLocation":"5574:8:100","memberName":"selector","nodeType":"MemberAccess","src":"5549:33:100","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},"src":"5541:41:100","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},"falseBody":{"condition":{"commonType":{"typeIdentifier":"t_bytes4","typeString":"bytes4"},"id":54212,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftExpression":{"id":54208,"name":"_sel","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54104,"src":"5631:4:100","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},"nodeType":"BinaryOperation","operator":"==","rightExpression":{"expression":{"expression":{"id":54209,"name":"this","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":-28,"src":"5639:4:100","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$54911","typeString":"contract FetchChainInfoOutput"}},"id":54210,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"5644:17:100","memberName":"systemConfigProxy","nodeType":"MemberAccess","referencedDeclaration":54591,"src":"5639:22:100","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":54211,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"memberLocation":"5662:8:100","memberName":"selector","nodeType":"MemberAccess","src":"5639:31:100","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},"src":"5631:39:100","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},"falseBody":{"condition":{"commonType":{"typeIdentifier":"t_bytes4","typeString":"bytes4"},"id":54221,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftExpression":{"id":54217,"name":"_sel","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54104,"src":"5717:4:100","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},"nodeType":"BinaryOperation","operator":"==","rightExpression":{"expression":{"expression":{"id":54218,"name":"this","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":-28,"src":"5725:4:100","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$54911","typeString":"contract FetchChainInfoOutput"}},"id":54219,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"5730:21:100","memberName":"opChainProxyAdminImpl","nodeType":"MemberAccess","referencedDeclaration":54609,"src":"5725:26:100","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":54220,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"memberLocation":"5752:8:100","memberName":"selector","nodeType":"MemberAccess","src":"5725:35:100","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},"src":"5717:43:100","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},"falseBody":{"condition":{"commonType":{"typeIdentifier":"t_bytes4","typeString":"bytes4"},"id":54230,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftExpression":{"id":54226,"name":"_sel","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54104,"src":"5811:4:100","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},"nodeType":"BinaryOperation","operator":"==","rightExpression":{"expression":{"expression":{"id":54227,"name":"this","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":-28,"src":"5819:4:100","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$54911","typeString":"contract FetchChainInfoOutput"}},"id":54228,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"5824:24:100","memberName":"anchorStateRegistryProxy","nodeType":"MemberAccess","referencedDeclaration":54645,"src":"5819:29:100","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":54229,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"memberLocation":"5849:8:100","memberName":"selector","nodeType":"MemberAccess","src":"5819:38:100","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},"src":"5811:46:100","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},"falseBody":{"condition":{"commonType":{"typeIdentifier":"t_bytes4","typeString":"bytes4"},"id":54239,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftExpression":{"id":54235,"name":"_sel","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54104,"src":"5911:4:100","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},"nodeType":"BinaryOperation","operator":"==","rightExpression":{"expression":{"expression":{"id":54236,"name":"this","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":-28,"src":"5919:4:100","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$54911","typeString":"contract FetchChainInfoOutput"}},"id":54237,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"5924:32:100","memberName":"delayedWethPermissionedGameProxy","nodeType":"MemberAccess","referencedDeclaration":54653,"src":"5919:37:100","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":54238,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"memberLocation":"5957:8:100","memberName":"selector","nodeType":"MemberAccess","src":"5919:46:100","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},"src":"5911:54:100","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},"falseBody":{"condition":{"commonType":{"typeIdentifier":"t_bytes4","typeString":"bytes4"},"id":54248,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftExpression":{"id":54244,"name":"_sel","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54104,"src":"6027:4:100","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},"nodeType":"BinaryOperation","operator":"==","rightExpression":{"expression":{"expression":{"id":54245,"name":"this","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":-28,"src":"6035:4:100","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$54911","typeString":"contract FetchChainInfoOutput"}},"id":54246,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"6040:34:100","memberName":"delayedWethPermissionlessGameProxy","nodeType":"MemberAccess","referencedDeclaration":54661,"src":"6035:39:100","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":54247,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"memberLocation":"6075:8:100","memberName":"selector","nodeType":"MemberAccess","src":"6035:48:100","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},"src":"6027:56:100","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},"falseBody":{"condition":{"commonType":{"typeIdentifier":"t_bytes4","typeString":"bytes4"},"id":54257,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftExpression":{"id":54253,"name":"_sel","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54104,"src":"6147:4:100","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},"nodeType":"BinaryOperation","operator":"==","rightExpression":{"expression":{"expression":{"id":54254,"name":"this","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":-28,"src":"6155:4:100","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$54911","typeString":"contract FetchChainInfoOutput"}},"id":54255,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"6160:23:100","memberName":"disputeGameFactoryProxy","nodeType":"MemberAccess","referencedDeclaration":54669,"src":"6155:28:100","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":54256,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"memberLocation":"6184:8:100","memberName":"selector","nodeType":"MemberAccess","src":"6155:37:100","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},"src":"6147:45:100","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},"falseBody":{"condition":{"commonType":{"typeIdentifier":"t_bytes4","typeString":"bytes4"},"id":54266,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftExpression":{"id":54262,"name":"_sel","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54104,"src":"6245:4:100","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},"nodeType":"BinaryOperation","operator":"==","rightExpression":{"expression":{"expression":{"id":54263,"name":"this","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":-28,"src":"6253:4:100","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$54911","typeString":"contract FetchChainInfoOutput"}},"id":54264,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"6258:20:100","memberName":"faultDisputeGameImpl","nodeType":"MemberAccess","referencedDeclaration":54687,"src":"6253:25:100","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":54265,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"memberLocation":"6279:8:100","memberName":"selector","nodeType":"MemberAccess","src":"6253:34:100","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},"src":"6245:42:100","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},"falseBody":{"condition":{"commonType":{"typeIdentifier":"t_bytes4","typeString":"bytes4"},"id":54275,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftExpression":{"id":54271,"name":"_sel","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54104,"src":"6337:4:100","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},"nodeType":"BinaryOperation","operator":"==","rightExpression":{"expression":{"expression":{"id":54272,"name":"this","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":-28,"src":"6345:4:100","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$54911","typeString":"contract FetchChainInfoOutput"}},"id":54273,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"6350:30:100","memberName":"faultDisputeGameCannonKonaImpl","nodeType":"MemberAccess","referencedDeclaration":54705,"src":"6345:35:100","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":54274,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"memberLocation":"6381:8:100","memberName":"selector","nodeType":"MemberAccess","src":"6345:44:100","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},"src":"6337:52:100","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},"falseBody":{"condition":{"commonType":{"typeIdentifier":"t_bytes4","typeString":"bytes4"},"id":54284,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftExpression":{"id":54280,"name":"_sel","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54104,"src":"6449:4:100","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},"nodeType":"BinaryOperation","operator":"==","rightExpression":{"expression":{"expression":{"id":54281,"name":"this","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":-28,"src":"6457:4:100","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$54911","typeString":"contract FetchChainInfoOutput"}},"id":54282,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"6462:27:100","memberName":"permissionedDisputeGameImpl","nodeType":"MemberAccess","referencedDeclaration":54741,"src":"6457:32:100","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":54283,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"memberLocation":"6490:8:100","memberName":"selector","nodeType":"MemberAccess","src":"6457:41:100","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},"src":"6449:49:100","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},"falseBody":{"condition":{"commonType":{"typeIdentifier":"t_bytes4","typeString":"bytes4"},"id":54293,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftExpression":{"id":54289,"name":"_sel","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54104,"src":"6572:4:100","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},"nodeType":"BinaryOperation","operator":"==","rightExpression":{"expression":{"expression":{"id":54290,"name":"this","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":-28,"src":"6580:4:100","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$54911","typeString":"contract FetchChainInfoOutput"}},"id":54291,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"6585:17:100","memberName":"systemConfigOwner","nodeType":"MemberAccess","referencedDeclaration":54777,"src":"6580:22:100","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":54292,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"memberLocation":"6603:8:100","memberName":"selector","nodeType":"MemberAccess","src":"6580:31:100","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},"src":"6572:39:100","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},"falseBody":{"condition":{"commonType":{"typeIdentifier":"t_bytes4","typeString":"bytes4"},"id":54302,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftExpression":{"id":54298,"name":"_sel","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54104,"src":"6658:4:100","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},"nodeType":"BinaryOperation","operator":"==","rightExpression":{"expression":{"expression":{"id":54299,"name":"this","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":-28,"src":"6666:4:100","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$54911","typeString":"contract FetchChainInfoOutput"}},"id":54300,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"6671:22:100","memberName":"opChainProxyAdminOwner","nodeType":"MemberAccess","referencedDeclaration":54795,"src":"6666:27:100","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":54301,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"memberLocation":"6694:8:100","memberName":"selector","nodeType":"MemberAccess","src":"6666:36:100","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},"src":"6658:44:100","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},"falseBody":{"condition":{"commonType":{"typeIdentifier":"t_bytes4","typeString":"bytes4"},"id":54311,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftExpression":{"id":54307,"name":"_sel","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54104,"src":"6754:4:100","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},"nodeType":"BinaryOperation","operator":"==","rightExpression":{"expression":{"expression":{"id":54308,"name":"this","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":-28,"src":"6762:4:100","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$54911","typeString":"contract FetchChainInfoOutput"}},"id":54309,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"6767:15:100","memberName":"opChainGuardian","nodeType":"MemberAccess","referencedDeclaration":54813,"src":"6762:20:100","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":54310,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"memberLocation":"6783:8:100","memberName":"selector","nodeType":"MemberAccess","src":"6762:29:100","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},"src":"6754:37:100","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},"falseBody":{"condition":{"commonType":{"typeIdentifier":"t_bytes4","typeString":"bytes4"},"id":54320,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftExpression":{"id":54316,"name":"_sel","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54104,"src":"6836:4:100","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},"nodeType":"BinaryOperation","operator":"==","rightExpression":{"expression":{"expression":{"id":54317,"name":"this","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":-28,"src":"6844:4:100","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$54911","typeString":"contract FetchChainInfoOutput"}},"id":54318,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"6849:10:100","memberName":"challenger","nodeType":"MemberAccess","referencedDeclaration":54831,"src":"6844:15:100","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":54319,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"memberLocation":"6860:8:100","memberName":"selector","nodeType":"MemberAccess","src":"6844:24:100","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},"src":"6836:32:100","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},"falseBody":{"condition":{"commonType":{"typeIdentifier":"t_bytes4","typeString":"bytes4"},"id":54329,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftExpression":{"id":54325,"name":"_sel","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54104,"src":"6908:4:100","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},"nodeType":"BinaryOperation","operator":"==","rightExpression":{"expression":{"expression":{"id":54326,"name":"this","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":-28,"src":"6916:4:100","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$54911","typeString":"contract FetchChainInfoOutput"}},"id":54327,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"6921:8:100","memberName":"proposer","nodeType":"MemberAccess","referencedDeclaration":54849,"src":"6916:13:100","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":54328,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"memberLocation":"6930:8:100","memberName":"selector","nodeType":"MemberAccess","src":"6916:22:100","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},"src":"6908:30:100","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},"falseBody":{"condition":{"commonType":{"typeIdentifier":"t_bytes4","typeString":"bytes4"},"id":54338,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftExpression":{"id":54334,"name":"_sel","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54104,"src":"6976:4:100","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},"nodeType":"BinaryOperation","operator":"==","rightExpression":{"expression":{"expression":{"id":54335,"name":"this","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":-28,"src":"6984:4:100","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$54911","typeString":"contract FetchChainInfoOutput"}},"id":54336,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"6989:17:100","memberName":"unsafeBlockSigner","nodeType":"MemberAccess","referencedDeclaration":54867,"src":"6984:22:100","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":54337,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"memberLocation":"7007:8:100","memberName":"selector","nodeType":"MemberAccess","src":"6984:31:100","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},"src":"6976:39:100","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},"falseBody":{"condition":{"commonType":{"typeIdentifier":"t_bytes4","typeString":"bytes4"},"id":54347,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftExpression":{"id":54343,"name":"_sel","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54104,"src":"7062:4:100","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},"nodeType":"BinaryOperation","operator":"==","rightExpression":{"expression":{"expression":{"id":54344,"name":"this","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":-28,"src":"7070:4:100","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$54911","typeString":"contract FetchChainInfoOutput"}},"id":54345,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"7075:14:100","memberName":"batchSubmitter","nodeType":"MemberAccess","referencedDeclaration":54885,"src":"7070:19:100","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":54346,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"memberLocation":"7090:8:100","memberName":"selector","nodeType":"MemberAccess","src":"7070:28:100","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},"src":"7062:36:100","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},"falseBody":{"expression":{"arguments":[{"hexValue":"4665746368436861696e496e666f4f75747075743a20756e6b6e6f776e20616464726573732073656c6563746f722074657374","id":54353,"isConstant":false,"isLValue":false,"isPure":true,"kind":"string","lValueRequested":false,"nodeType":"Literal","src":"7145:53:100","typeDescriptions":{"typeIdentifier":"t_stringliteral_8be6a92cba5443877e2b6bededc383e178c3f2718dce3f3864f1721c31f5c065","typeString":"literal_string \"FetchChainInfoOutput: unknown address selector test\""},"value":"FetchChainInfoOutput: unknown address selector test"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_stringliteral_8be6a92cba5443877e2b6bededc383e178c3f2718dce3f3864f1721c31f5c065","typeString":"literal_string \"FetchChainInfoOutput: unknown address selector test\""}],"id":54352,"name":"revert","nodeType":"Identifier","overloadedDeclarations":[-19,-19],"referencedDeclaration":-19,"src":"7138:6:100","typeDescriptions":{"typeIdentifier":"t_function_revert_pure$_t_string_memory_ptr_$returns$__$","typeString":"function (string memory) pure"}},"id":54354,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"7138:61:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":54355,"nodeType":"ExpressionStatement","src":"7138:61:100"},"id":54356,"nodeType":"IfStatement","src":"7058:141:100","trueBody":{"expression":{"id":54350,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftHandSide":{"id":54348,"name":"_batchSubmitter","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54095,"src":"7100:15:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"Assignment","operator":"=","rightHandSide":{"id":54349,"name":"_addr","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54106,"src":"7118:5:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"src":"7100:23:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"id":54351,"nodeType":"ExpressionStatement","src":"7100:23:100"}},"id":54357,"nodeType":"IfStatement","src":"6972:227:100","trueBody":{"expression":{"id":54341,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftHandSide":{"id":54339,"name":"_unsafeBlockSigner","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54093,"src":"7017:18:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"Assignment","operator":"=","rightHandSide":{"id":54340,"name":"_addr","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54106,"src":"7038:5:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"src":"7017:26:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"id":54342,"nodeType":"ExpressionStatement","src":"7017:26:100"}},"id":54358,"nodeType":"IfStatement","src":"6904:295:100","trueBody":{"expression":{"id":54332,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftHandSide":{"id":54330,"name":"_proposer","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54091,"src":"6940:9:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"Assignment","operator":"=","rightHandSide":{"id":54331,"name":"_addr","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54106,"src":"6952:5:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"src":"6940:17:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"id":54333,"nodeType":"ExpressionStatement","src":"6940:17:100"}},"id":54359,"nodeType":"IfStatement","src":"6832:367:100","trueBody":{"expression":{"id":54323,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftHandSide":{"id":54321,"name":"_challenger","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54089,"src":"6870:11:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"Assignment","operator":"=","rightHandSide":{"id":54322,"name":"_addr","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54106,"src":"6884:5:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"src":"6870:19:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"id":54324,"nodeType":"ExpressionStatement","src":"6870:19:100"}},"id":54360,"nodeType":"IfStatement","src":"6750:449:100","trueBody":{"expression":{"id":54314,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftHandSide":{"id":54312,"name":"_opChainGuardian","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54087,"src":"6793:16:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"Assignment","operator":"=","rightHandSide":{"id":54313,"name":"_addr","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54106,"src":"6812:5:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"src":"6793:24:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"id":54315,"nodeType":"ExpressionStatement","src":"6793:24:100"}},"id":54361,"nodeType":"IfStatement","src":"6654:545:100","trueBody":{"expression":{"id":54305,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftHandSide":{"id":54303,"name":"_opChainProxyAdminOwner","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54085,"src":"6704:23:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"Assignment","operator":"=","rightHandSide":{"id":54304,"name":"_addr","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54106,"src":"6730:5:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"src":"6704:31:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"id":54306,"nodeType":"ExpressionStatement","src":"6704:31:100"}},"id":54362,"nodeType":"IfStatement","src":"6568:631:100","trueBody":{"expression":{"id":54296,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftHandSide":{"id":54294,"name":"_systemConfigOwner","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54083,"src":"6613:18:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"Assignment","operator":"=","rightHandSide":{"id":54295,"name":"_addr","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54106,"src":"6634:5:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"src":"6613:26:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"id":54297,"nodeType":"ExpressionStatement","src":"6613:26:100"}},"id":54363,"nodeType":"IfStatement","src":"6445:754:100","trueBody":{"expression":{"id":54287,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftHandSide":{"id":54285,"name":"_permissionedDisputeGameImpl","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54081,"src":"6500:28:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"Assignment","operator":"=","rightHandSide":{"id":54286,"name":"_addr","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54106,"src":"6531:5:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"src":"6500:36:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"id":54288,"nodeType":"ExpressionStatement","src":"6500:36:100"}},"id":54364,"nodeType":"IfStatement","src":"6333:866:100","trueBody":{"expression":{"id":54278,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftHandSide":{"id":54276,"name":"_faultDisputeGameCannonKonaImpl","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54079,"src":"6391:31:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"Assignment","operator":"=","rightHandSide":{"id":54277,"name":"_addr","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54106,"src":"6425:5:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"src":"6391:39:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"id":54279,"nodeType":"ExpressionStatement","src":"6391:39:100"}},"id":54365,"nodeType":"IfStatement","src":"6241:958:100","trueBody":{"expression":{"id":54269,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftHandSide":{"id":54267,"name":"_faultDisputeGameImpl","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54077,"src":"6289:21:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"Assignment","operator":"=","rightHandSide":{"id":54268,"name":"_addr","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54106,"src":"6313:5:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"src":"6289:29:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"id":54270,"nodeType":"ExpressionStatement","src":"6289:29:100"}},"id":54366,"nodeType":"IfStatement","src":"6143:1056:100","trueBody":{"expression":{"id":54260,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftHandSide":{"id":54258,"name":"_disputeGameFactoryProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54075,"src":"6194:24:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"Assignment","operator":"=","rightHandSide":{"id":54259,"name":"_addr","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54106,"src":"6221:5:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"src":"6194:32:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"id":54261,"nodeType":"ExpressionStatement","src":"6194:32:100"}},"id":54367,"nodeType":"IfStatement","src":"6023:1176:100","trueBody":{"expression":{"id":54251,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftHandSide":{"id":54249,"name":"_delayedWethPermissionlessGameProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54073,"src":"6085:35:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"Assignment","operator":"=","rightHandSide":{"id":54250,"name":"_addr","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54106,"src":"6123:5:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"src":"6085:43:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"id":54252,"nodeType":"ExpressionStatement","src":"6085:43:100"}},"id":54368,"nodeType":"IfStatement","src":"5907:1292:100","trueBody":{"expression":{"id":54242,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftHandSide":{"id":54240,"name":"_delayedWethPermissionedGameProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54071,"src":"5967:33:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"Assignment","operator":"=","rightHandSide":{"id":54241,"name":"_addr","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54106,"src":"6003:5:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"src":"5967:41:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"id":54243,"nodeType":"ExpressionStatement","src":"5967:41:100"}},"id":54369,"nodeType":"IfStatement","src":"5807:1392:100","trueBody":{"expression":{"id":54233,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftHandSide":{"id":54231,"name":"_anchorStateRegistryProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54069,"src":"5859:25:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"Assignment","operator":"=","rightHandSide":{"id":54232,"name":"_addr","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54106,"src":"5887:5:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"src":"5859:33:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"id":54234,"nodeType":"ExpressionStatement","src":"5859:33:100"}},"id":54370,"nodeType":"IfStatement","src":"5713:1486:100","trueBody":{"expression":{"id":54224,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftHandSide":{"id":54222,"name":"_opChainProxyAdminImpl","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54067,"src":"5762:22:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"Assignment","operator":"=","rightHandSide":{"id":54223,"name":"_addr","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54106,"src":"5787:5:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"src":"5762:30:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"id":54225,"nodeType":"ExpressionStatement","src":"5762:30:100"}},"id":54371,"nodeType":"IfStatement","src":"5627:1572:100","trueBody":{"expression":{"id":54215,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftHandSide":{"id":54213,"name":"_systemConfigProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54065,"src":"5672:18:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"Assignment","operator":"=","rightHandSide":{"id":54214,"name":"_addr","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54106,"src":"5693:5:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"src":"5672:26:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"id":54216,"nodeType":"ExpressionStatement","src":"5672:26:100"}},"id":54372,"nodeType":"IfStatement","src":"5537:1662:100","trueBody":{"expression":{"id":54206,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftHandSide":{"id":54204,"name":"_optimismPortalProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54063,"src":"5584:20:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"Assignment","operator":"=","rightHandSide":{"id":54205,"name":"_addr","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54106,"src":"5607:5:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"src":"5584:28:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"id":54207,"nodeType":"ExpressionStatement","src":"5584:28:100"}},"id":54373,"nodeType":"IfStatement","src":"5419:1780:100","trueBody":{"expression":{"id":54197,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftHandSide":{"id":54195,"name":"_optimismMintableErc20FactoryProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54061,"src":"5480:34:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"Assignment","operator":"=","rightHandSide":{"id":54196,"name":"_addr","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54106,"src":"5517:5:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"src":"5480:42:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"id":54198,"nodeType":"ExpressionStatement","src":"5480:42:100"}},"id":54374,"nodeType":"IfStatement","src":"5329:1870:100","trueBody":{"expression":{"id":54188,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftHandSide":{"id":54186,"name":"_l2OutputOracleProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54059,"src":"5376:20:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"Assignment","operator":"=","rightHandSide":{"id":54187,"name":"_addr","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54106,"src":"5399:5:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"src":"5376:28:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"id":54189,"nodeType":"ExpressionStatement","src":"5376:28:100"}},"id":54375,"nodeType":"IfStatement","src":"5235:1964:100","trueBody":{"expression":{"id":54179,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftHandSide":{"id":54177,"name":"_l1StandardBridgeProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54057,"src":"5284:22:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"Assignment","operator":"=","rightHandSide":{"id":54178,"name":"_addr","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54106,"src":"5309:5:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"src":"5284:30:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"id":54180,"nodeType":"ExpressionStatement","src":"5284:30:100"}},"id":54376,"nodeType":"IfStatement","src":"5145:2054:100","trueBody":{"expression":{"id":54170,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftHandSide":{"id":54168,"name":"_l1Erc721BridgeProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54055,"src":"5192:20:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"Assignment","operator":"=","rightHandSide":{"id":54169,"name":"_addr","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54106,"src":"5215:5:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"src":"5192:28:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"id":54171,"nodeType":"ExpressionStatement","src":"5192:28:100"}},"id":54377,"nodeType":"IfStatement","src":"5039:2160:100","trueBody":{"expression":{"id":54161,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftHandSide":{"id":54159,"name":"_l1CrossDomainMessengerProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54053,"src":"5094:28:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"Assignment","operator":"=","rightHandSide":{"id":54160,"name":"_addr","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54106,"src":"5125:5:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"src":"5094:36:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"id":54162,"nodeType":"ExpressionStatement","src":"5094:36:100"}},"id":54378,"nodeType":"IfStatement","src":"4957:2242:100","trueBody":{"expression":{"id":54152,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftHandSide":{"id":54150,"name":"_ethLockboxProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54051,"src":"5000:16:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"Assignment","operator":"=","rightHandSide":{"id":54151,"name":"_addr","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54106,"src":"5019:5:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"src":"5000:24:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"id":54153,"nodeType":"ExpressionStatement","src":"5000:24:100"}},"id":54379,"nodeType":"IfStatement","src":"4869:2330:100","trueBody":{"expression":{"id":54143,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftHandSide":{"id":54141,"name":"_addressManagerImpl","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54049,"src":"4915:19:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"Assignment","operator":"=","rightHandSide":{"id":54142,"name":"_addr","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54106,"src":"4937:5:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"src":"4915:27:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"id":54144,"nodeType":"ExpressionStatement","src":"4915:27:100"}},"id":54380,"nodeType":"IfStatement","src":"4750:2449:100","trueBody":{"expression":{"id":54134,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftHandSide":{"id":54132,"name":"_preimageOracleImpl","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54047,"src":"4796:19:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"Assignment","operator":"=","rightHandSide":{"id":54133,"name":"_addr","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54106,"src":"4818:5:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"src":"4796:27:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"id":54135,"nodeType":"ExpressionStatement","src":"4796:27:100"}},"id":54381,"nodeType":"IfStatement","src":"4682:2517:100","trueBody":{"expression":{"id":54125,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftHandSide":{"id":54123,"name":"_mipsImpl","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54045,"src":"4718:9:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"Assignment","operator":"=","rightHandSide":{"id":54124,"name":"_addr","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54106,"src":"4730:5:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"src":"4718:17:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"id":54126,"nodeType":"ExpressionStatement","src":"4718:17:100"}},"id":54382,"nodeType":"IfStatement","src":"4549:2650:100","trueBody":{"expression":{"id":54116,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftHandSide":{"id":54114,"name":"_superchainConfigProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54043,"src":"4598:22:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"Assignment","operator":"=","rightHandSide":{"id":54115,"name":"_addr","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54106,"src":"4623:5:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"src":"4598:30:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"id":54117,"nodeType":"ExpressionStatement","src":"4598:30:100"}}]},"functionSelector":"c3e39250","implemented":true,"kind":"function","modifiers":[],"name":"set","nameLocation":"4469:3:100","parameters":{"id":54107,"nodeType":"ParameterList","parameters":[{"constant":false,"id":54104,"mutability":"mutable","name":"_sel","nameLocation":"4480:4:100","nodeType":"VariableDeclaration","scope":54384,"src":"4473:11:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"},"typeName":{"id":54103,"name":"bytes4","nodeType":"ElementaryTypeName","src":"4473:6:100","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},"visibility":"internal"},{"constant":false,"id":54106,"mutability":"mutable","name":"_addr","nameLocation":"4494:5:100","nodeType":"VariableDeclaration","scope":54384,"src":"4486:13:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":54105,"name":"address","nodeType":"ElementaryTypeName","src":"4486:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"4472:28:100"},"returnParameters":{"id":54108,"nodeType":"ParameterList","parameters":[],"src":"4508:0:100"},"scope":54911,"stateMutability":"nonpayable","virtual":false,"visibility":"public"},{"id":54416,"nodeType":"FunctionDefinition","src":"7212:271:100","nodes":[],"body":{"id":54415,"nodeType":"Block","src":"7257:226:100","nodes":[],"statements":[{"condition":{"commonType":{"typeIdentifier":"t_bytes4","typeString":"bytes4"},"id":54395,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftExpression":{"id":54391,"name":"_sel","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54386,"src":"7271:4:100","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},"nodeType":"BinaryOperation","operator":"==","rightExpression":{"expression":{"expression":{"id":54392,"name":"this","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":-28,"src":"7279:4:100","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$54911","typeString":"contract FetchChainInfoOutput"}},"id":54393,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"7284:12:100","memberName":"permissioned","nodeType":"MemberAccess","referencedDeclaration":54893,"src":"7279:17:100","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_bool_$","typeString":"function () view external returns (bool)"}},"id":54394,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"memberLocation":"7297:8:100","memberName":"selector","nodeType":"MemberAccess","src":"7279:26:100","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},"src":"7271:34:100","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},"falseBody":{"condition":{"commonType":{"typeIdentifier":"t_bytes4","typeString":"bytes4"},"id":54404,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftExpression":{"id":54400,"name":"_sel","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54386,"src":"7347:4:100","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},"nodeType":"BinaryOperation","operator":"==","rightExpression":{"expression":{"expression":{"id":54401,"name":"this","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":-28,"src":"7355:4:100","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$54911","typeString":"contract FetchChainInfoOutput"}},"id":54402,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"7360:14:100","memberName":"permissionless","nodeType":"MemberAccess","referencedDeclaration":54901,"src":"7355:19:100","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_bool_$","typeString":"function () view external returns (bool)"}},"id":54403,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"memberLocation":"7375:8:100","memberName":"selector","nodeType":"MemberAccess","src":"7355:28:100","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},"src":"7347:36:100","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},"falseBody":{"expression":{"arguments":[{"hexValue":"4665746368436861696e496e666f4f75747075743a20756e6b6e6f776e20626f6f6c2073656c6563746f72","id":54410,"isConstant":false,"isLValue":false,"isPure":true,"kind":"string","lValueRequested":false,"nodeType":"Literal","src":"7430:45:100","typeDescriptions":{"typeIdentifier":"t_stringliteral_b43e73201a672ac9d292be9f8dc7215ba0fae6d34ae76c7f77ffd9b31af48fae","typeString":"literal_string \"FetchChainInfoOutput: unknown bool selector\""},"value":"FetchChainInfoOutput: unknown bool selector"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_stringliteral_b43e73201a672ac9d292be9f8dc7215ba0fae6d34ae76c7f77ffd9b31af48fae","typeString":"literal_string \"FetchChainInfoOutput: unknown bool selector\""}],"id":54409,"name":"revert","nodeType":"Identifier","overloadedDeclarations":[-19,-19],"referencedDeclaration":-19,"src":"7423:6:100","typeDescriptions":{"typeIdentifier":"t_function_revert_pure$_t_string_memory_ptr_$returns$__$","typeString":"function (string memory) pure"}},"id":54411,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"7423:53:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":54412,"nodeType":"ExpressionStatement","src":"7423:53:100"},"id":54413,"nodeType":"IfStatement","src":"7343:133:100","trueBody":{"expression":{"id":54407,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftHandSide":{"id":54405,"name":"_permissionless","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54099,"src":"7385:15:100","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},"nodeType":"Assignment","operator":"=","rightHandSide":{"id":54406,"name":"_bool","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54388,"src":"7403:5:100","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},"src":"7385:23:100","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},"id":54408,"nodeType":"ExpressionStatement","src":"7385:23:100"}},"id":54414,"nodeType":"IfStatement","src":"7267:209:100","trueBody":{"expression":{"id":54398,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftHandSide":{"id":54396,"name":"_permissioned","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54097,"src":"7307:13:100","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},"nodeType":"Assignment","operator":"=","rightHandSide":{"id":54397,"name":"_bool","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54388,"src":"7323:5:100","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},"src":"7307:21:100","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},"id":54399,"nodeType":"ExpressionStatement","src":"7307:21:100"}}]},"functionSelector":"baa1e15e","implemented":true,"kind":"function","modifiers":[],"name":"set","nameLocation":"7221:3:100","parameters":{"id":54389,"nodeType":"ParameterList","parameters":[{"constant":false,"id":54386,"mutability":"mutable","name":"_sel","nameLocation":"7232:4:100","nodeType":"VariableDeclaration","scope":54416,"src":"7225:11:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"},"typeName":{"id":54385,"name":"bytes4","nodeType":"ElementaryTypeName","src":"7225:6:100","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},"visibility":"internal"},{"constant":false,"id":54388,"mutability":"mutable","name":"_bool","nameLocation":"7243:5:100","nodeType":"VariableDeclaration","scope":54416,"src":"7238:10:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"},"typeName":{"id":54387,"name":"bool","nodeType":"ElementaryTypeName","src":"7238:4:100","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},"visibility":"internal"}],"src":"7224:25:100"},"returnParameters":{"id":54390,"nodeType":"ParameterList","parameters":[],"src":"7257:0:100"},"scope":54911,"stateMutability":"nonpayable","virtual":false,"visibility":"public"},{"id":54439,"nodeType":"FunctionDefinition","src":"7489:217:100","nodes":[],"body":{"id":54438,"nodeType":"Block","src":"7542:164:100","nodes":[],"statements":[{"condition":{"commonType":{"typeIdentifier":"t_bytes4","typeString":"bytes4"},"id":54428,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftExpression":{"id":54424,"name":"_sel","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54418,"src":"7556:4:100","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},"nodeType":"BinaryOperation","operator":"==","rightExpression":{"expression":{"expression":{"id":54425,"name":"this","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":-28,"src":"7564:4:100","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$54911","typeString":"contract FetchChainInfoOutput"}},"id":54426,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"7569:17:100","memberName":"respectedGameType","nodeType":"MemberAccess","referencedDeclaration":54910,"src":"7564:22:100","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_userDefinedValueType$_GameType_$70720_$","typeString":"function () view external returns (GameType)"}},"id":54427,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"memberLocation":"7587:8:100","memberName":"selector","nodeType":"MemberAccess","src":"7564:31:100","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},"src":"7556:39:100","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},"falseBody":{"expression":{"arguments":[{"hexValue":"4665746368436861696e496e666f4f75747075743a20756e6b6e6f776e2047616d65547970652073656c6563746f72","id":54434,"isConstant":false,"isLValue":false,"isPure":true,"kind":"string","lValueRequested":false,"nodeType":"Literal","src":"7649:49:100","typeDescriptions":{"typeIdentifier":"t_stringliteral_520d3d0cced140fee76c803f92d1db783b790e13f72de1e8f8c229c8c8783afc","typeString":"literal_string \"FetchChainInfoOutput: unknown GameType selector\""},"value":"FetchChainInfoOutput: unknown GameType selector"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_stringliteral_520d3d0cced140fee76c803f92d1db783b790e13f72de1e8f8c229c8c8783afc","typeString":"literal_string \"FetchChainInfoOutput: unknown GameType selector\""}],"id":54433,"name":"revert","nodeType":"Identifier","overloadedDeclarations":[-19,-19],"referencedDeclaration":-19,"src":"7642:6:100","typeDescriptions":{"typeIdentifier":"t_function_revert_pure$_t_string_memory_ptr_$returns$__$","typeString":"function (string memory) pure"}},"id":54435,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"7642:57:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":54436,"nodeType":"ExpressionStatement","src":"7642:57:100"},"id":54437,"nodeType":"IfStatement","src":"7552:147:100","trueBody":{"expression":{"id":54431,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftHandSide":{"id":54429,"name":"_respectedGameType","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54102,"src":"7597:18:100","typeDescriptions":{"typeIdentifier":"t_userDefinedValueType$_GameType_$70720","typeString":"GameType"}},"nodeType":"Assignment","operator":"=","rightHandSide":{"id":54430,"name":"_gameType","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54421,"src":"7618:9:100","typeDescriptions":{"typeIdentifier":"t_userDefinedValueType$_GameType_$70720","typeString":"GameType"}},"src":"7597:30:100","typeDescriptions":{"typeIdentifier":"t_userDefinedValueType$_GameType_$70720","typeString":"GameType"}},"id":54432,"nodeType":"ExpressionStatement","src":"7597:30:100"}}]},"functionSelector":"d08d6066","implemented":true,"kind":"function","modifiers":[],"name":"set","nameLocation":"7498:3:100","parameters":{"id":54422,"nodeType":"ParameterList","parameters":[{"constant":false,"id":54418,"mutability":"mutable","name":"_sel","nameLocation":"7509:4:100","nodeType":"VariableDeclaration","scope":54439,"src":"7502:11:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"},"typeName":{"id":54417,"name":"bytes4","nodeType":"ElementaryTypeName","src":"7502:6:100","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},"visibility":"internal"},{"constant":false,"id":54421,"mutability":"mutable","name":"_gameType","nameLocation":"7524:9:100","nodeType":"VariableDeclaration","scope":54439,"src":"7515:18:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_userDefinedValueType$_GameType_$70720","typeString":"GameType"},"typeName":{"id":54420,"nodeType":"UserDefinedTypeName","pathNode":{"id":54419,"name":"GameType","nameLocations":["7515:8:100"],"nodeType":"IdentifierPath","referencedDeclaration":70720,"src":"7515:8:100"},"referencedDeclaration":70720,"src":"7515:8:100","typeDescriptions":{"typeIdentifier":"t_userDefinedValueType$_GameType_$70720","typeString":"GameType"}},"visibility":"internal"}],"src":"7501:33:100"},"returnParameters":{"id":54423,"nodeType":"ParameterList","parameters":[],"src":"7542:0:100"},"scope":54911,"stateMutability":"nonpayable","virtual":false,"visibility":"public"},{"id":54457,"nodeType":"FunctionDefinition","src":"7712:207:100","nodes":[],"body":{"id":54456,"nodeType":"Block","src":"7772:147:100","nodes":[],"statements":[{"expression":{"arguments":[{"commonType":{"typeIdentifier":"t_address","typeString":"address"},"id":54450,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftExpression":{"id":54445,"name":"_addressManagerImpl","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54049,"src":"7790:19:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"BinaryOperation","operator":"!=","rightExpression":{"arguments":[{"hexValue":"30","id":54448,"isConstant":false,"isLValue":false,"isPure":true,"kind":"number","lValueRequested":false,"nodeType":"Literal","src":"7821:1:100","typeDescriptions":{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"},"value":"0"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"}],"id":54447,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"nodeType":"ElementaryTypeNameExpression","src":"7813:7:100","typeDescriptions":{"typeIdentifier":"t_type$_t_address_$","typeString":"type(address)"},"typeName":{"id":54446,"name":"address","nodeType":"ElementaryTypeName","src":"7813:7:100","typeDescriptions":{}}},"id":54449,"isConstant":false,"isLValue":false,"isPure":true,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"7813:10:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"src":"7790:33:100","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},{"hexValue":"4665746368436861696e496e666f4f75747075743a20616464726573734d616e61676572496d706c206e6f7420736574","id":54451,"isConstant":false,"isLValue":false,"isPure":true,"kind":"string","lValueRequested":false,"nodeType":"Literal","src":"7825:50:100","typeDescriptions":{"typeIdentifier":"t_stringliteral_b154041fe6470d62d16e8ad5c6d8e6c50a46e3e155a380b02703b07321b83f6a","typeString":"literal_string \"FetchChainInfoOutput: addressManagerImpl not set\""},"value":"FetchChainInfoOutput: addressManagerImpl not set"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_bool","typeString":"bool"},{"typeIdentifier":"t_stringliteral_b154041fe6470d62d16e8ad5c6d8e6c50a46e3e155a380b02703b07321b83f6a","typeString":"literal_string \"FetchChainInfoOutput: addressManagerImpl not set\""}],"id":54444,"name":"require","nodeType":"Identifier","overloadedDeclarations":[-18,-18,-18],"referencedDeclaration":-18,"src":"7782:7:100","typeDescriptions":{"typeIdentifier":"t_function_require_pure$_t_bool_$_t_string_memory_ptr_$returns$__$","typeString":"function (bool,string memory) pure"}},"id":54452,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"7782:94:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":54453,"nodeType":"ExpressionStatement","src":"7782:94:100"},{"expression":{"id":54454,"name":"_addressManagerImpl","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54049,"src":"7893:19:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"functionReturnParameters":54443,"id":54455,"nodeType":"Return","src":"7886:26:100"}]},"functionSelector":"bd366b8f","implemented":true,"kind":"function","modifiers":[],"name":"addressManagerImpl","nameLocation":"7721:18:100","parameters":{"id":54440,"nodeType":"ParameterList","parameters":[],"src":"7739:2:100"},"returnParameters":{"id":54443,"nodeType":"ParameterList","parameters":[{"constant":false,"id":54442,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":54457,"src":"7763:7:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":54441,"name":"address","nodeType":"ElementaryTypeName","src":"7763:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"7762:9:100"},"scope":54911,"stateMutability":"view","virtual":false,"visibility":"public"},{"id":54465,"nodeType":"FunctionDefinition","src":"7925:97:100","nodes":[],"body":{"id":54464,"nodeType":"Block","src":"7982:40:100","nodes":[],"statements":[{"expression":{"id":54462,"name":"_ethLockboxProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54051,"src":"7999:16:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"functionReturnParameters":54461,"id":54463,"nodeType":"Return","src":"7992:23:100"}]},"functionSelector":"f646b07c","implemented":true,"kind":"function","modifiers":[],"name":"ethLockboxProxy","nameLocation":"7934:15:100","parameters":{"id":54458,"nodeType":"ParameterList","parameters":[],"src":"7949:2:100"},"returnParameters":{"id":54461,"nodeType":"ParameterList","parameters":[{"constant":false,"id":54460,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":54465,"src":"7973:7:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":54459,"name":"address","nodeType":"ElementaryTypeName","src":"7973:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"7972:9:100"},"scope":54911,"stateMutability":"view","virtual":false,"visibility":"public"},{"id":54483,"nodeType":"FunctionDefinition","src":"8028:243:100","nodes":[],"body":{"id":54482,"nodeType":"Block","src":"8097:174:100","nodes":[],"statements":[{"expression":{"arguments":[{"commonType":{"typeIdentifier":"t_address","typeString":"address"},"id":54476,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftExpression":{"id":54471,"name":"_l1CrossDomainMessengerProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54053,"src":"8115:28:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"BinaryOperation","operator":"!=","rightExpression":{"arguments":[{"hexValue":"30","id":54474,"isConstant":false,"isLValue":false,"isPure":true,"kind":"number","lValueRequested":false,"nodeType":"Literal","src":"8155:1:100","typeDescriptions":{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"},"value":"0"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"}],"id":54473,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"nodeType":"ElementaryTypeNameExpression","src":"8147:7:100","typeDescriptions":{"typeIdentifier":"t_type$_t_address_$","typeString":"type(address)"},"typeName":{"id":54472,"name":"address","nodeType":"ElementaryTypeName","src":"8147:7:100","typeDescriptions":{}}},"id":54475,"isConstant":false,"isLValue":false,"isPure":true,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"8147:10:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"src":"8115:42:100","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},{"hexValue":"4665746368436861696e496e666f4f75747075743a206c3143726f7373446f6d61696e4d657373656e67657250726f7879206e6f7420736574","id":54477,"isConstant":false,"isLValue":false,"isPure":true,"kind":"string","lValueRequested":false,"nodeType":"Literal","src":"8159:59:100","typeDescriptions":{"typeIdentifier":"t_stringliteral_c51216a9bdef996dd7040e19ba4fe817587273a187f1f145abfd19b1308df5eb","typeString":"literal_string \"FetchChainInfoOutput: l1CrossDomainMessengerProxy not set\""},"value":"FetchChainInfoOutput: l1CrossDomainMessengerProxy not set"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_bool","typeString":"bool"},{"typeIdentifier":"t_stringliteral_c51216a9bdef996dd7040e19ba4fe817587273a187f1f145abfd19b1308df5eb","typeString":"literal_string \"FetchChainInfoOutput: l1CrossDomainMessengerProxy not set\""}],"id":54470,"name":"require","nodeType":"Identifier","overloadedDeclarations":[-18,-18,-18],"referencedDeclaration":-18,"src":"8107:7:100","typeDescriptions":{"typeIdentifier":"t_function_require_pure$_t_bool_$_t_string_memory_ptr_$returns$__$","typeString":"function (bool,string memory) pure"}},"id":54478,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"8107:112:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":54479,"nodeType":"ExpressionStatement","src":"8107:112:100"},{"expression":{"id":54480,"name":"_l1CrossDomainMessengerProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54053,"src":"8236:28:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"functionReturnParameters":54469,"id":54481,"nodeType":"Return","src":"8229:35:100"}]},"functionSelector":"54729cfb","implemented":true,"kind":"function","modifiers":[],"name":"l1CrossDomainMessengerProxy","nameLocation":"8037:27:100","parameters":{"id":54466,"nodeType":"ParameterList","parameters":[],"src":"8064:2:100"},"returnParameters":{"id":54469,"nodeType":"ParameterList","parameters":[{"constant":false,"id":54468,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":54483,"src":"8088:7:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":54467,"name":"address","nodeType":"ElementaryTypeName","src":"8088:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"8087:9:100"},"scope":54911,"stateMutability":"view","virtual":false,"visibility":"public"},{"id":54501,"nodeType":"FunctionDefinition","src":"8277:211:100","nodes":[],"body":{"id":54500,"nodeType":"Block","src":"8338:150:100","nodes":[],"statements":[{"expression":{"arguments":[{"commonType":{"typeIdentifier":"t_address","typeString":"address"},"id":54494,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftExpression":{"id":54489,"name":"_l1Erc721BridgeProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54055,"src":"8356:20:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"BinaryOperation","operator":"!=","rightExpression":{"arguments":[{"hexValue":"30","id":54492,"isConstant":false,"isLValue":false,"isPure":true,"kind":"number","lValueRequested":false,"nodeType":"Literal","src":"8388:1:100","typeDescriptions":{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"},"value":"0"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"}],"id":54491,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"nodeType":"ElementaryTypeNameExpression","src":"8380:7:100","typeDescriptions":{"typeIdentifier":"t_type$_t_address_$","typeString":"type(address)"},"typeName":{"id":54490,"name":"address","nodeType":"ElementaryTypeName","src":"8380:7:100","typeDescriptions":{}}},"id":54493,"isConstant":false,"isLValue":false,"isPure":true,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"8380:10:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"src":"8356:34:100","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},{"hexValue":"4665746368436861696e496e666f4f75747075743a206c3145726337323142726964676550726f7879206e6f7420736574","id":54495,"isConstant":false,"isLValue":false,"isPure":true,"kind":"string","lValueRequested":false,"nodeType":"Literal","src":"8392:51:100","typeDescriptions":{"typeIdentifier":"t_stringliteral_bdf5319949d8561b59a02fe667aa58fca11f5f8571bc18997b0bc0ac582aece7","typeString":"literal_string \"FetchChainInfoOutput: l1Erc721BridgeProxy not set\""},"value":"FetchChainInfoOutput: l1Erc721BridgeProxy not set"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_bool","typeString":"bool"},{"typeIdentifier":"t_stringliteral_bdf5319949d8561b59a02fe667aa58fca11f5f8571bc18997b0bc0ac582aece7","typeString":"literal_string \"FetchChainInfoOutput: l1Erc721BridgeProxy not set\""}],"id":54488,"name":"require","nodeType":"Identifier","overloadedDeclarations":[-18,-18,-18],"referencedDeclaration":-18,"src":"8348:7:100","typeDescriptions":{"typeIdentifier":"t_function_require_pure$_t_bool_$_t_string_memory_ptr_$returns$__$","typeString":"function (bool,string memory) pure"}},"id":54496,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"8348:96:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":54497,"nodeType":"ExpressionStatement","src":"8348:96:100"},{"expression":{"id":54498,"name":"_l1Erc721BridgeProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54055,"src":"8461:20:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"functionReturnParameters":54487,"id":54499,"nodeType":"Return","src":"8454:27:100"}]},"functionSelector":"ebfa8409","implemented":true,"kind":"function","modifiers":[],"name":"l1Erc721BridgeProxy","nameLocation":"8286:19:100","parameters":{"id":54484,"nodeType":"ParameterList","parameters":[],"src":"8305:2:100"},"returnParameters":{"id":54487,"nodeType":"ParameterList","parameters":[{"constant":false,"id":54486,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":54501,"src":"8329:7:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":54485,"name":"address","nodeType":"ElementaryTypeName","src":"8329:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"8328:9:100"},"scope":54911,"stateMutability":"view","virtual":false,"visibility":"public"},{"id":54519,"nodeType":"FunctionDefinition","src":"8494:219:100","nodes":[],"body":{"id":54518,"nodeType":"Block","src":"8557:156:100","nodes":[],"statements":[{"expression":{"arguments":[{"commonType":{"typeIdentifier":"t_address","typeString":"address"},"id":54512,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftExpression":{"id":54507,"name":"_l1StandardBridgeProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54057,"src":"8575:22:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"BinaryOperation","operator":"!=","rightExpression":{"arguments":[{"hexValue":"30","id":54510,"isConstant":false,"isLValue":false,"isPure":true,"kind":"number","lValueRequested":false,"nodeType":"Literal","src":"8609:1:100","typeDescriptions":{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"},"value":"0"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"}],"id":54509,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"nodeType":"ElementaryTypeNameExpression","src":"8601:7:100","typeDescriptions":{"typeIdentifier":"t_type$_t_address_$","typeString":"type(address)"},"typeName":{"id":54508,"name":"address","nodeType":"ElementaryTypeName","src":"8601:7:100","typeDescriptions":{}}},"id":54511,"isConstant":false,"isLValue":false,"isPure":true,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"8601:10:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"src":"8575:36:100","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},{"hexValue":"4665746368436861696e496e666f4f75747075743a206c315374616e6461726442726964676550726f7879206e6f7420736574","id":54513,"isConstant":false,"isLValue":false,"isPure":true,"kind":"string","lValueRequested":false,"nodeType":"Literal","src":"8613:53:100","typeDescriptions":{"typeIdentifier":"t_stringliteral_ab3776e760de395cff3bb935602469d5b7c0bd9b5cfaefde9d221be6524302e1","typeString":"literal_string \"FetchChainInfoOutput: l1StandardBridgeProxy not set\""},"value":"FetchChainInfoOutput: l1StandardBridgeProxy not set"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_bool","typeString":"bool"},{"typeIdentifier":"t_stringliteral_ab3776e760de395cff3bb935602469d5b7c0bd9b5cfaefde9d221be6524302e1","typeString":"literal_string \"FetchChainInfoOutput: l1StandardBridgeProxy not set\""}],"id":54506,"name":"require","nodeType":"Identifier","overloadedDeclarations":[-18,-18,-18],"referencedDeclaration":-18,"src":"8567:7:100","typeDescriptions":{"typeIdentifier":"t_function_require_pure$_t_bool_$_t_string_memory_ptr_$returns$__$","typeString":"function (bool,string memory) pure"}},"id":54514,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"8567:100:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":54515,"nodeType":"ExpressionStatement","src":"8567:100:100"},{"expression":{"id":54516,"name":"_l1StandardBridgeProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54057,"src":"8684:22:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"functionReturnParameters":54505,"id":54517,"nodeType":"Return","src":"8677:29:100"}]},"functionSelector":"102b6069","implemented":true,"kind":"function","modifiers":[],"name":"l1StandardBridgeProxy","nameLocation":"8503:21:100","parameters":{"id":54502,"nodeType":"ParameterList","parameters":[],"src":"8524:2:100"},"returnParameters":{"id":54505,"nodeType":"ParameterList","parameters":[{"constant":false,"id":54504,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":54519,"src":"8548:7:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":54503,"name":"address","nodeType":"ElementaryTypeName","src":"8548:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"8547:9:100"},"scope":54911,"stateMutability":"view","virtual":false,"visibility":"public"},{"id":54537,"nodeType":"FunctionDefinition","src":"8719:211:100","nodes":[],"body":{"id":54536,"nodeType":"Block","src":"8780:150:100","nodes":[],"statements":[{"expression":{"arguments":[{"commonType":{"typeIdentifier":"t_address","typeString":"address"},"id":54530,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftExpression":{"id":54525,"name":"_l2OutputOracleProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54059,"src":"8798:20:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"BinaryOperation","operator":"!=","rightExpression":{"arguments":[{"hexValue":"30","id":54528,"isConstant":false,"isLValue":false,"isPure":true,"kind":"number","lValueRequested":false,"nodeType":"Literal","src":"8830:1:100","typeDescriptions":{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"},"value":"0"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"}],"id":54527,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"nodeType":"ElementaryTypeNameExpression","src":"8822:7:100","typeDescriptions":{"typeIdentifier":"t_type$_t_address_$","typeString":"type(address)"},"typeName":{"id":54526,"name":"address","nodeType":"ElementaryTypeName","src":"8822:7:100","typeDescriptions":{}}},"id":54529,"isConstant":false,"isLValue":false,"isPure":true,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"8822:10:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"src":"8798:34:100","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},{"hexValue":"4665746368436861696e496e666f4f75747075743a206c324f75747075744f7261636c6550726f7879206e6f7420736574","id":54531,"isConstant":false,"isLValue":false,"isPure":true,"kind":"string","lValueRequested":false,"nodeType":"Literal","src":"8834:51:100","typeDescriptions":{"typeIdentifier":"t_stringliteral_2f861759874f8f3e0cfa53ef8dfb0556f88f877edbaf1dbc485fc820d67ac86a","typeString":"literal_string \"FetchChainInfoOutput: l2OutputOracleProxy not set\""},"value":"FetchChainInfoOutput: l2OutputOracleProxy not set"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_bool","typeString":"bool"},{"typeIdentifier":"t_stringliteral_2f861759874f8f3e0cfa53ef8dfb0556f88f877edbaf1dbc485fc820d67ac86a","typeString":"literal_string \"FetchChainInfoOutput: l2OutputOracleProxy not set\""}],"id":54524,"name":"require","nodeType":"Identifier","overloadedDeclarations":[-18,-18,-18],"referencedDeclaration":-18,"src":"8790:7:100","typeDescriptions":{"typeIdentifier":"t_function_require_pure$_t_bool_$_t_string_memory_ptr_$returns$__$","typeString":"function (bool,string memory) pure"}},"id":54532,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"8790:96:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":54533,"nodeType":"ExpressionStatement","src":"8790:96:100"},{"expression":{"id":54534,"name":"_l2OutputOracleProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54059,"src":"8903:20:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"functionReturnParameters":54523,"id":54535,"nodeType":"Return","src":"8896:27:100"}]},"functionSelector":"a2c9a89f","implemented":true,"kind":"function","modifiers":[],"name":"l2OutputOracleProxy","nameLocation":"8728:19:100","parameters":{"id":54520,"nodeType":"ParameterList","parameters":[],"src":"8747:2:100"},"returnParameters":{"id":54523,"nodeType":"ParameterList","parameters":[{"constant":false,"id":54522,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":54537,"src":"8771:7:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":54521,"name":"address","nodeType":"ElementaryTypeName","src":"8771:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"8770:9:100"},"scope":54911,"stateMutability":"view","virtual":false,"visibility":"public"},{"id":54555,"nodeType":"FunctionDefinition","src":"8936:301:100","nodes":[],"body":{"id":54554,"nodeType":"Block","src":"9011:226:100","nodes":[],"statements":[{"expression":{"arguments":[{"commonType":{"typeIdentifier":"t_address","typeString":"address"},"id":54548,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftExpression":{"id":54543,"name":"_optimismMintableErc20FactoryProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54061,"src":"9042:34:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"BinaryOperation","operator":"!=","rightExpression":{"arguments":[{"hexValue":"30","id":54546,"isConstant":false,"isLValue":false,"isPure":true,"kind":"number","lValueRequested":false,"nodeType":"Literal","src":"9088:1:100","typeDescriptions":{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"},"value":"0"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"}],"id":54545,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"nodeType":"ElementaryTypeNameExpression","src":"9080:7:100","typeDescriptions":{"typeIdentifier":"t_type$_t_address_$","typeString":"type(address)"},"typeName":{"id":54544,"name":"address","nodeType":"ElementaryTypeName","src":"9080:7:100","typeDescriptions":{}}},"id":54547,"isConstant":false,"isLValue":false,"isPure":true,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"9080:10:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"src":"9042:48:100","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},{"hexValue":"4665746368436861696e496e666f4f75747075743a206f7074696d69736d4d696e7461626c654572633230466163746f727950726f7879206e6f7420736574","id":54549,"isConstant":false,"isLValue":false,"isPure":true,"kind":"string","lValueRequested":false,"nodeType":"Literal","src":"9104:65:100","typeDescriptions":{"typeIdentifier":"t_stringliteral_58c040fbde84bd4afd9f21f5ba3150dab029d767b65aafdf14512bdafdbd9954","typeString":"literal_string \"FetchChainInfoOutput: optimismMintableErc20FactoryProxy not set\""},"value":"FetchChainInfoOutput: optimismMintableErc20FactoryProxy not set"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_bool","typeString":"bool"},{"typeIdentifier":"t_stringliteral_58c040fbde84bd4afd9f21f5ba3150dab029d767b65aafdf14512bdafdbd9954","typeString":"literal_string \"FetchChainInfoOutput: optimismMintableErc20FactoryProxy not set\""}],"id":54542,"name":"require","nodeType":"Identifier","overloadedDeclarations":[-18,-18,-18],"referencedDeclaration":-18,"src":"9021:7:100","typeDescriptions":{"typeIdentifier":"t_function_require_pure$_t_bool_$_t_string_memory_ptr_$returns$__$","typeString":"function (bool,string memory) pure"}},"id":54550,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"9021:158:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":54551,"nodeType":"ExpressionStatement","src":"9021:158:100"},{"expression":{"id":54552,"name":"_optimismMintableErc20FactoryProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54061,"src":"9196:34:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"functionReturnParameters":54541,"id":54553,"nodeType":"Return","src":"9189:41:100"}]},"functionSelector":"8f20c7e4","implemented":true,"kind":"function","modifiers":[],"name":"optimismMintableErc20FactoryProxy","nameLocation":"8945:33:100","parameters":{"id":54538,"nodeType":"ParameterList","parameters":[],"src":"8978:2:100"},"returnParameters":{"id":54541,"nodeType":"ParameterList","parameters":[{"constant":false,"id":54540,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":54555,"src":"9002:7:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":54539,"name":"address","nodeType":"ElementaryTypeName","src":"9002:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"9001:9:100"},"scope":54911,"stateMutability":"view","virtual":false,"visibility":"public"},{"id":54573,"nodeType":"FunctionDefinition","src":"9243:211:100","nodes":[],"body":{"id":54572,"nodeType":"Block","src":"9304:150:100","nodes":[],"statements":[{"expression":{"arguments":[{"commonType":{"typeIdentifier":"t_address","typeString":"address"},"id":54566,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftExpression":{"id":54561,"name":"_optimismPortalProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54063,"src":"9322:20:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"BinaryOperation","operator":"!=","rightExpression":{"arguments":[{"hexValue":"30","id":54564,"isConstant":false,"isLValue":false,"isPure":true,"kind":"number","lValueRequested":false,"nodeType":"Literal","src":"9354:1:100","typeDescriptions":{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"},"value":"0"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"}],"id":54563,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"nodeType":"ElementaryTypeNameExpression","src":"9346:7:100","typeDescriptions":{"typeIdentifier":"t_type$_t_address_$","typeString":"type(address)"},"typeName":{"id":54562,"name":"address","nodeType":"ElementaryTypeName","src":"9346:7:100","typeDescriptions":{}}},"id":54565,"isConstant":false,"isLValue":false,"isPure":true,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"9346:10:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"src":"9322:34:100","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},{"hexValue":"4665746368436861696e496e666f4f75747075743a206f7074696d69736d506f7274616c50726f7879206e6f7420736574","id":54567,"isConstant":false,"isLValue":false,"isPure":true,"kind":"string","lValueRequested":false,"nodeType":"Literal","src":"9358:51:100","typeDescriptions":{"typeIdentifier":"t_stringliteral_ef003bab75ab0cfa4ca81f99eb20b37a3fded08fa7502df7d991f596c8680642","typeString":"literal_string \"FetchChainInfoOutput: optimismPortalProxy not set\""},"value":"FetchChainInfoOutput: optimismPortalProxy not set"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_bool","typeString":"bool"},{"typeIdentifier":"t_stringliteral_ef003bab75ab0cfa4ca81f99eb20b37a3fded08fa7502df7d991f596c8680642","typeString":"literal_string \"FetchChainInfoOutput: optimismPortalProxy not set\""}],"id":54560,"name":"require","nodeType":"Identifier","overloadedDeclarations":[-18,-18,-18],"referencedDeclaration":-18,"src":"9314:7:100","typeDescriptions":{"typeIdentifier":"t_function_require_pure$_t_bool_$_t_string_memory_ptr_$returns$__$","typeString":"function (bool,string memory) pure"}},"id":54568,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"9314:96:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":54569,"nodeType":"ExpressionStatement","src":"9314:96:100"},{"expression":{"id":54570,"name":"_optimismPortalProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54063,"src":"9427:20:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"functionReturnParameters":54559,"id":54571,"nodeType":"Return","src":"9420:27:100"}]},"functionSelector":"04451c49","implemented":true,"kind":"function","modifiers":[],"name":"optimismPortalProxy","nameLocation":"9252:19:100","parameters":{"id":54556,"nodeType":"ParameterList","parameters":[],"src":"9271:2:100"},"returnParameters":{"id":54559,"nodeType":"ParameterList","parameters":[{"constant":false,"id":54558,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":54573,"src":"9295:7:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":54557,"name":"address","nodeType":"ElementaryTypeName","src":"9295:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"9294:9:100"},"scope":54911,"stateMutability":"view","virtual":false,"visibility":"public"},{"id":54591,"nodeType":"FunctionDefinition","src":"9460:203:100","nodes":[],"body":{"id":54590,"nodeType":"Block","src":"9519:144:100","nodes":[],"statements":[{"expression":{"arguments":[{"commonType":{"typeIdentifier":"t_address","typeString":"address"},"id":54584,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftExpression":{"id":54579,"name":"_systemConfigProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54065,"src":"9537:18:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"BinaryOperation","operator":"!=","rightExpression":{"arguments":[{"hexValue":"30","id":54582,"isConstant":false,"isLValue":false,"isPure":true,"kind":"number","lValueRequested":false,"nodeType":"Literal","src":"9567:1:100","typeDescriptions":{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"},"value":"0"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"}],"id":54581,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"nodeType":"ElementaryTypeNameExpression","src":"9559:7:100","typeDescriptions":{"typeIdentifier":"t_type$_t_address_$","typeString":"type(address)"},"typeName":{"id":54580,"name":"address","nodeType":"ElementaryTypeName","src":"9559:7:100","typeDescriptions":{}}},"id":54583,"isConstant":false,"isLValue":false,"isPure":true,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"9559:10:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"src":"9537:32:100","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},{"hexValue":"4665746368436861696e496e666f4f75747075743a2073797374656d436f6e66696750726f7879206e6f7420736574","id":54585,"isConstant":false,"isLValue":false,"isPure":true,"kind":"string","lValueRequested":false,"nodeType":"Literal","src":"9571:49:100","typeDescriptions":{"typeIdentifier":"t_stringliteral_09ada010329fb4e012f4c857519ec176efea734f55c01f382f1b6c7bd752716b","typeString":"literal_string \"FetchChainInfoOutput: systemConfigProxy not set\""},"value":"FetchChainInfoOutput: systemConfigProxy not set"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_bool","typeString":"bool"},{"typeIdentifier":"t_stringliteral_09ada010329fb4e012f4c857519ec176efea734f55c01f382f1b6c7bd752716b","typeString":"literal_string \"FetchChainInfoOutput: systemConfigProxy not set\""}],"id":54578,"name":"require","nodeType":"Identifier","overloadedDeclarations":[-18,-18,-18],"referencedDeclaration":-18,"src":"9529:7:100","typeDescriptions":{"typeIdentifier":"t_function_require_pure$_t_bool_$_t_string_memory_ptr_$returns$__$","typeString":"function (bool,string memory) pure"}},"id":54586,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"9529:92:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":54587,"nodeType":"ExpressionStatement","src":"9529:92:100"},{"expression":{"id":54588,"name":"_systemConfigProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54065,"src":"9638:18:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"functionReturnParameters":54577,"id":54589,"nodeType":"Return","src":"9631:25:100"}]},"functionSelector":"c17db6e3","implemented":true,"kind":"function","modifiers":[],"name":"systemConfigProxy","nameLocation":"9469:17:100","parameters":{"id":54574,"nodeType":"ParameterList","parameters":[],"src":"9486:2:100"},"returnParameters":{"id":54577,"nodeType":"ParameterList","parameters":[{"constant":false,"id":54576,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":54591,"src":"9510:7:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":54575,"name":"address","nodeType":"ElementaryTypeName","src":"9510:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"9509:9:100"},"scope":54911,"stateMutability":"view","virtual":false,"visibility":"public"},{"id":54609,"nodeType":"FunctionDefinition","src":"9669:219:100","nodes":[],"body":{"id":54608,"nodeType":"Block","src":"9732:156:100","nodes":[],"statements":[{"expression":{"arguments":[{"commonType":{"typeIdentifier":"t_address","typeString":"address"},"id":54602,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftExpression":{"id":54597,"name":"_opChainProxyAdminImpl","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54067,"src":"9750:22:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"BinaryOperation","operator":"!=","rightExpression":{"arguments":[{"hexValue":"30","id":54600,"isConstant":false,"isLValue":false,"isPure":true,"kind":"number","lValueRequested":false,"nodeType":"Literal","src":"9784:1:100","typeDescriptions":{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"},"value":"0"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"}],"id":54599,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"nodeType":"ElementaryTypeNameExpression","src":"9776:7:100","typeDescriptions":{"typeIdentifier":"t_type$_t_address_$","typeString":"type(address)"},"typeName":{"id":54598,"name":"address","nodeType":"ElementaryTypeName","src":"9776:7:100","typeDescriptions":{}}},"id":54601,"isConstant":false,"isLValue":false,"isPure":true,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"9776:10:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"src":"9750:36:100","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},{"hexValue":"4665746368436861696e496e666f4f75747075743a206f70436861696e50726f787941646d696e496d706c206e6f7420736574","id":54603,"isConstant":false,"isLValue":false,"isPure":true,"kind":"string","lValueRequested":false,"nodeType":"Literal","src":"9788:53:100","typeDescriptions":{"typeIdentifier":"t_stringliteral_8ebc3647bde8a1129bfd827c7ef2e2d4fea82292bcad8a3c8e3918d70fed8ea8","typeString":"literal_string \"FetchChainInfoOutput: opChainProxyAdminImpl not set\""},"value":"FetchChainInfoOutput: opChainProxyAdminImpl not set"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_bool","typeString":"bool"},{"typeIdentifier":"t_stringliteral_8ebc3647bde8a1129bfd827c7ef2e2d4fea82292bcad8a3c8e3918d70fed8ea8","typeString":"literal_string \"FetchChainInfoOutput: opChainProxyAdminImpl not set\""}],"id":54596,"name":"require","nodeType":"Identifier","overloadedDeclarations":[-18,-18,-18],"referencedDeclaration":-18,"src":"9742:7:100","typeDescriptions":{"typeIdentifier":"t_function_require_pure$_t_bool_$_t_string_memory_ptr_$returns$__$","typeString":"function (bool,string memory) pure"}},"id":54604,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"9742:100:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":54605,"nodeType":"ExpressionStatement","src":"9742:100:100"},{"expression":{"id":54606,"name":"_opChainProxyAdminImpl","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54067,"src":"9859:22:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"functionReturnParameters":54595,"id":54607,"nodeType":"Return","src":"9852:29:100"}]},"functionSelector":"5643665f","implemented":true,"kind":"function","modifiers":[],"name":"opChainProxyAdminImpl","nameLocation":"9678:21:100","parameters":{"id":54592,"nodeType":"ParameterList","parameters":[],"src":"9699:2:100"},"returnParameters":{"id":54595,"nodeType":"ParameterList","parameters":[{"constant":false,"id":54594,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":54609,"src":"9723:7:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":54593,"name":"address","nodeType":"ElementaryTypeName","src":"9723:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"9722:9:100"},"scope":54911,"stateMutability":"view","virtual":false,"visibility":"public"},{"id":54627,"nodeType":"FunctionDefinition","src":"9894:219:100","nodes":[],"body":{"id":54626,"nodeType":"Block","src":"9957:156:100","nodes":[],"statements":[{"expression":{"arguments":[{"commonType":{"typeIdentifier":"t_address","typeString":"address"},"id":54620,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftExpression":{"id":54615,"name":"_superchainConfigProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54043,"src":"9975:22:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"BinaryOperation","operator":"!=","rightExpression":{"arguments":[{"hexValue":"30","id":54618,"isConstant":false,"isLValue":false,"isPure":true,"kind":"number","lValueRequested":false,"nodeType":"Literal","src":"10009:1:100","typeDescriptions":{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"},"value":"0"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"}],"id":54617,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"nodeType":"ElementaryTypeNameExpression","src":"10001:7:100","typeDescriptions":{"typeIdentifier":"t_type$_t_address_$","typeString":"type(address)"},"typeName":{"id":54616,"name":"address","nodeType":"ElementaryTypeName","src":"10001:7:100","typeDescriptions":{}}},"id":54619,"isConstant":false,"isLValue":false,"isPure":true,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"10001:10:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"src":"9975:36:100","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},{"hexValue":"4665746368436861696e496e666f4f75747075743a207375706572636861696e436f6e66696750726f7879206e6f7420736574","id":54621,"isConstant":false,"isLValue":false,"isPure":true,"kind":"string","lValueRequested":false,"nodeType":"Literal","src":"10013:53:100","typeDescriptions":{"typeIdentifier":"t_stringliteral_1b8ad3d2e627aa065fd0fee387bc2d1e5e640177323f7f86733cd157b788a1ce","typeString":"literal_string \"FetchChainInfoOutput: superchainConfigProxy not set\""},"value":"FetchChainInfoOutput: superchainConfigProxy not set"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_bool","typeString":"bool"},{"typeIdentifier":"t_stringliteral_1b8ad3d2e627aa065fd0fee387bc2d1e5e640177323f7f86733cd157b788a1ce","typeString":"literal_string \"FetchChainInfoOutput: superchainConfigProxy not set\""}],"id":54614,"name":"require","nodeType":"Identifier","overloadedDeclarations":[-18,-18,-18],"referencedDeclaration":-18,"src":"9967:7:100","typeDescriptions":{"typeIdentifier":"t_function_require_pure$_t_bool_$_t_string_memory_ptr_$returns$__$","typeString":"function (bool,string memory) pure"}},"id":54622,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"9967:100:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":54623,"nodeType":"ExpressionStatement","src":"9967:100:100"},{"expression":{"id":54624,"name":"_superchainConfigProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54043,"src":"10084:22:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"functionReturnParameters":54613,"id":54625,"nodeType":"Return","src":"10077:29:100"}]},"functionSelector":"84cf2c97","implemented":true,"kind":"function","modifiers":[],"name":"superchainConfigProxy","nameLocation":"9903:21:100","parameters":{"id":54610,"nodeType":"ParameterList","parameters":[],"src":"9924:2:100"},"returnParameters":{"id":54613,"nodeType":"ParameterList","parameters":[{"constant":false,"id":54612,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":54627,"src":"9948:7:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":54611,"name":"address","nodeType":"ElementaryTypeName","src":"9948:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"9947:9:100"},"scope":54911,"stateMutability":"view","virtual":false,"visibility":"public"},{"id":54645,"nodeType":"FunctionDefinition","src":"10119:231:100","nodes":[],"body":{"id":54644,"nodeType":"Block","src":"10185:165:100","nodes":[],"statements":[{"expression":{"arguments":[{"commonType":{"typeIdentifier":"t_address","typeString":"address"},"id":54638,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftExpression":{"id":54633,"name":"_anchorStateRegistryProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54069,"src":"10203:25:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"BinaryOperation","operator":"!=","rightExpression":{"arguments":[{"hexValue":"30","id":54636,"isConstant":false,"isLValue":false,"isPure":true,"kind":"number","lValueRequested":false,"nodeType":"Literal","src":"10240:1:100","typeDescriptions":{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"},"value":"0"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"}],"id":54635,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"nodeType":"ElementaryTypeNameExpression","src":"10232:7:100","typeDescriptions":{"typeIdentifier":"t_type$_t_address_$","typeString":"type(address)"},"typeName":{"id":54634,"name":"address","nodeType":"ElementaryTypeName","src":"10232:7:100","typeDescriptions":{}}},"id":54637,"isConstant":false,"isLValue":false,"isPure":true,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"10232:10:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"src":"10203:39:100","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},{"hexValue":"4665746368436861696e496e666f4f75747075743a20616e63686f725374617465526567697374727950726f7879206e6f7420736574","id":54639,"isConstant":false,"isLValue":false,"isPure":true,"kind":"string","lValueRequested":false,"nodeType":"Literal","src":"10244:56:100","typeDescriptions":{"typeIdentifier":"t_stringliteral_6391076785d7152b9570ce8338ca2e43a749144cb3dbb7f9e5e1de5fabfbae48","typeString":"literal_string \"FetchChainInfoOutput: anchorStateRegistryProxy not set\""},"value":"FetchChainInfoOutput: anchorStateRegistryProxy not set"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_bool","typeString":"bool"},{"typeIdentifier":"t_stringliteral_6391076785d7152b9570ce8338ca2e43a749144cb3dbb7f9e5e1de5fabfbae48","typeString":"literal_string \"FetchChainInfoOutput: anchorStateRegistryProxy not set\""}],"id":54632,"name":"require","nodeType":"Identifier","overloadedDeclarations":[-18,-18,-18],"referencedDeclaration":-18,"src":"10195:7:100","typeDescriptions":{"typeIdentifier":"t_function_require_pure$_t_bool_$_t_string_memory_ptr_$returns$__$","typeString":"function (bool,string memory) pure"}},"id":54640,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"10195:106:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":54641,"nodeType":"ExpressionStatement","src":"10195:106:100"},{"expression":{"id":54642,"name":"_anchorStateRegistryProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54069,"src":"10318:25:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"functionReturnParameters":54631,"id":54643,"nodeType":"Return","src":"10311:32:100"}]},"functionSelector":"35596f76","implemented":true,"kind":"function","modifiers":[],"name":"anchorStateRegistryProxy","nameLocation":"10128:24:100","parameters":{"id":54628,"nodeType":"ParameterList","parameters":[],"src":"10152:2:100"},"returnParameters":{"id":54631,"nodeType":"ParameterList","parameters":[{"constant":false,"id":54630,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":54645,"src":"10176:7:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":54629,"name":"address","nodeType":"ElementaryTypeName","src":"10176:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"10175:9:100"},"scope":54911,"stateMutability":"view","virtual":false,"visibility":"public"},{"id":54653,"nodeType":"FunctionDefinition","src":"10356:131:100","nodes":[],"body":{"id":54652,"nodeType":"Block","src":"10430:57:100","nodes":[],"statements":[{"expression":{"id":54650,"name":"_delayedWethPermissionedGameProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54071,"src":"10447:33:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"functionReturnParameters":54649,"id":54651,"nodeType":"Return","src":"10440:40:100"}]},"functionSelector":"794836d7","implemented":true,"kind":"function","modifiers":[],"name":"delayedWethPermissionedGameProxy","nameLocation":"10365:32:100","parameters":{"id":54646,"nodeType":"ParameterList","parameters":[],"src":"10397:2:100"},"returnParameters":{"id":54649,"nodeType":"ParameterList","parameters":[{"constant":false,"id":54648,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":54653,"src":"10421:7:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":54647,"name":"address","nodeType":"ElementaryTypeName","src":"10421:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"10420:9:100"},"scope":54911,"stateMutability":"view","virtual":false,"visibility":"public"},{"id":54661,"nodeType":"FunctionDefinition","src":"10493:135:100","nodes":[],"body":{"id":54660,"nodeType":"Block","src":"10569:59:100","nodes":[],"statements":[{"expression":{"id":54658,"name":"_delayedWethPermissionlessGameProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54073,"src":"10586:35:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"functionReturnParameters":54657,"id":54659,"nodeType":"Return","src":"10579:42:100"}]},"functionSelector":"97068797","implemented":true,"kind":"function","modifiers":[],"name":"delayedWethPermissionlessGameProxy","nameLocation":"10502:34:100","parameters":{"id":54654,"nodeType":"ParameterList","parameters":[],"src":"10536:2:100"},"returnParameters":{"id":54657,"nodeType":"ParameterList","parameters":[{"constant":false,"id":54656,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":54661,"src":"10560:7:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":54655,"name":"address","nodeType":"ElementaryTypeName","src":"10560:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"10559:9:100"},"scope":54911,"stateMutability":"view","virtual":false,"visibility":"public"},{"id":54669,"nodeType":"FunctionDefinition","src":"10634:113:100","nodes":[],"body":{"id":54668,"nodeType":"Block","src":"10699:48:100","nodes":[],"statements":[{"expression":{"id":54666,"name":"_disputeGameFactoryProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54075,"src":"10716:24:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"functionReturnParameters":54665,"id":54667,"nodeType":"Return","src":"10709:31:100"}]},"functionSelector":"6c4568d1","implemented":true,"kind":"function","modifiers":[],"name":"disputeGameFactoryProxy","nameLocation":"10643:23:100","parameters":{"id":54662,"nodeType":"ParameterList","parameters":[],"src":"10666:2:100"},"returnParameters":{"id":54665,"nodeType":"ParameterList","parameters":[{"constant":false,"id":54664,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":54669,"src":"10690:7:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":54663,"name":"address","nodeType":"ElementaryTypeName","src":"10690:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"10689:9:100"},"scope":54911,"stateMutability":"view","virtual":false,"visibility":"public"},{"id":54687,"nodeType":"FunctionDefinition","src":"10753:215:100","nodes":[],"body":{"id":54686,"nodeType":"Block","src":"10815:153:100","nodes":[],"statements":[{"expression":{"arguments":[{"commonType":{"typeIdentifier":"t_address","typeString":"address"},"id":54680,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftExpression":{"id":54675,"name":"_faultDisputeGameImpl","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54077,"src":"10833:21:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"BinaryOperation","operator":"!=","rightExpression":{"arguments":[{"hexValue":"30","id":54678,"isConstant":false,"isLValue":false,"isPure":true,"kind":"number","lValueRequested":false,"nodeType":"Literal","src":"10866:1:100","typeDescriptions":{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"},"value":"0"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"}],"id":54677,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"nodeType":"ElementaryTypeNameExpression","src":"10858:7:100","typeDescriptions":{"typeIdentifier":"t_type$_t_address_$","typeString":"type(address)"},"typeName":{"id":54676,"name":"address","nodeType":"ElementaryTypeName","src":"10858:7:100","typeDescriptions":{}}},"id":54679,"isConstant":false,"isLValue":false,"isPure":true,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"10858:10:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"src":"10833:35:100","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},{"hexValue":"4665746368436861696e496e666f4f75747075743a206661756c744469737075746547616d65496d706c206e6f7420736574","id":54681,"isConstant":false,"isLValue":false,"isPure":true,"kind":"string","lValueRequested":false,"nodeType":"Literal","src":"10870:52:100","typeDescriptions":{"typeIdentifier":"t_stringliteral_baae18cd0fbc1fbf3c566f5918a7a4a780bb1a3d403d2b65d908417b87c06457","typeString":"literal_string \"FetchChainInfoOutput: faultDisputeGameImpl not set\""},"value":"FetchChainInfoOutput: faultDisputeGameImpl not set"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_bool","typeString":"bool"},{"typeIdentifier":"t_stringliteral_baae18cd0fbc1fbf3c566f5918a7a4a780bb1a3d403d2b65d908417b87c06457","typeString":"literal_string \"FetchChainInfoOutput: faultDisputeGameImpl not set\""}],"id":54674,"name":"require","nodeType":"Identifier","overloadedDeclarations":[-18,-18,-18],"referencedDeclaration":-18,"src":"10825:7:100","typeDescriptions":{"typeIdentifier":"t_function_require_pure$_t_bool_$_t_string_memory_ptr_$returns$__$","typeString":"function (bool,string memory) pure"}},"id":54682,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"10825:98:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":54683,"nodeType":"ExpressionStatement","src":"10825:98:100"},{"expression":{"id":54684,"name":"_faultDisputeGameImpl","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54077,"src":"10940:21:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"functionReturnParameters":54673,"id":54685,"nodeType":"Return","src":"10933:28:100"}]},"functionSelector":"dea21984","implemented":true,"kind":"function","modifiers":[],"name":"faultDisputeGameImpl","nameLocation":"10762:20:100","parameters":{"id":54670,"nodeType":"ParameterList","parameters":[],"src":"10782:2:100"},"returnParameters":{"id":54673,"nodeType":"ParameterList","parameters":[{"constant":false,"id":54672,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":54687,"src":"10806:7:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":54671,"name":"address","nodeType":"ElementaryTypeName","src":"10806:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"10805:9:100"},"scope":54911,"stateMutability":"view","virtual":false,"visibility":"public"},{"id":54705,"nodeType":"FunctionDefinition","src":"10974:289:100","nodes":[],"body":{"id":54704,"nodeType":"Block","src":"11046:217:100","nodes":[],"statements":[{"expression":{"arguments":[{"commonType":{"typeIdentifier":"t_address","typeString":"address"},"id":54698,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftExpression":{"id":54693,"name":"_faultDisputeGameCannonKonaImpl","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54079,"src":"11077:31:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"BinaryOperation","operator":"!=","rightExpression":{"arguments":[{"hexValue":"30","id":54696,"isConstant":false,"isLValue":false,"isPure":true,"kind":"number","lValueRequested":false,"nodeType":"Literal","src":"11120:1:100","typeDescriptions":{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"},"value":"0"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"}],"id":54695,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"nodeType":"ElementaryTypeNameExpression","src":"11112:7:100","typeDescriptions":{"typeIdentifier":"t_type$_t_address_$","typeString":"type(address)"},"typeName":{"id":54694,"name":"address","nodeType":"ElementaryTypeName","src":"11112:7:100","typeDescriptions":{}}},"id":54697,"isConstant":false,"isLValue":false,"isPure":true,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"11112:10:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"src":"11077:45:100","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},{"hexValue":"4665746368436861696e496e666f4f75747075743a206661756c744469737075746547616d6543616e6e6f6e4b6f6e61496d706c206e6f7420736574","id":54699,"isConstant":false,"isLValue":false,"isPure":true,"kind":"string","lValueRequested":false,"nodeType":"Literal","src":"11136:62:100","typeDescriptions":{"typeIdentifier":"t_stringliteral_1a6322899b29428b71a9f44d1d2e4f85d48c09a65bfacd98b10709bf7aff2087","typeString":"literal_string \"FetchChainInfoOutput: faultDisputeGameCannonKonaImpl not set\""},"value":"FetchChainInfoOutput: faultDisputeGameCannonKonaImpl not set"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_bool","typeString":"bool"},{"typeIdentifier":"t_stringliteral_1a6322899b29428b71a9f44d1d2e4f85d48c09a65bfacd98b10709bf7aff2087","typeString":"literal_string \"FetchChainInfoOutput: faultDisputeGameCannonKonaImpl not set\""}],"id":54692,"name":"require","nodeType":"Identifier","overloadedDeclarations":[-18,-18,-18],"referencedDeclaration":-18,"src":"11056:7:100","typeDescriptions":{"typeIdentifier":"t_function_require_pure$_t_bool_$_t_string_memory_ptr_$returns$__$","typeString":"function (bool,string memory) pure"}},"id":54700,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"11056:152:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":54701,"nodeType":"ExpressionStatement","src":"11056:152:100"},{"expression":{"id":54702,"name":"_faultDisputeGameCannonKonaImpl","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54079,"src":"11225:31:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"functionReturnParameters":54691,"id":54703,"nodeType":"Return","src":"11218:38:100"}]},"functionSelector":"5d25b21d","implemented":true,"kind":"function","modifiers":[],"name":"faultDisputeGameCannonKonaImpl","nameLocation":"10983:30:100","parameters":{"id":54688,"nodeType":"ParameterList","parameters":[],"src":"11013:2:100"},"returnParameters":{"id":54691,"nodeType":"ParameterList","parameters":[{"constant":false,"id":54690,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":54705,"src":"11037:7:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":54689,"name":"address","nodeType":"ElementaryTypeName","src":"11037:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"11036:9:100"},"scope":54911,"stateMutability":"view","virtual":false,"visibility":"public"},{"id":54723,"nodeType":"FunctionDefinition","src":"11269:167:100","nodes":[],"body":{"id":54722,"nodeType":"Block","src":"11319:117:100","nodes":[],"statements":[{"expression":{"arguments":[{"commonType":{"typeIdentifier":"t_address","typeString":"address"},"id":54716,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftExpression":{"id":54711,"name":"_mipsImpl","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54045,"src":"11337:9:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"BinaryOperation","operator":"!=","rightExpression":{"arguments":[{"hexValue":"30","id":54714,"isConstant":false,"isLValue":false,"isPure":true,"kind":"number","lValueRequested":false,"nodeType":"Literal","src":"11358:1:100","typeDescriptions":{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"},"value":"0"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"}],"id":54713,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"nodeType":"ElementaryTypeNameExpression","src":"11350:7:100","typeDescriptions":{"typeIdentifier":"t_type$_t_address_$","typeString":"type(address)"},"typeName":{"id":54712,"name":"address","nodeType":"ElementaryTypeName","src":"11350:7:100","typeDescriptions":{}}},"id":54715,"isConstant":false,"isLValue":false,"isPure":true,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"11350:10:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"src":"11337:23:100","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},{"hexValue":"4665746368436861696e496e666f4f75747075743a206d697073496d706c206e6f7420736574","id":54717,"isConstant":false,"isLValue":false,"isPure":true,"kind":"string","lValueRequested":false,"nodeType":"Literal","src":"11362:40:100","typeDescriptions":{"typeIdentifier":"t_stringliteral_178867f585ae7eaee2b47a35fdf118ac2b037c387c5937f3b39b1c51f05d7497","typeString":"literal_string \"FetchChainInfoOutput: mipsImpl not set\""},"value":"FetchChainInfoOutput: mipsImpl not set"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_bool","typeString":"bool"},{"typeIdentifier":"t_stringliteral_178867f585ae7eaee2b47a35fdf118ac2b037c387c5937f3b39b1c51f05d7497","typeString":"literal_string \"FetchChainInfoOutput: mipsImpl not set\""}],"id":54710,"name":"require","nodeType":"Identifier","overloadedDeclarations":[-18,-18,-18],"referencedDeclaration":-18,"src":"11329:7:100","typeDescriptions":{"typeIdentifier":"t_function_require_pure$_t_bool_$_t_string_memory_ptr_$returns$__$","typeString":"function (bool,string memory) pure"}},"id":54718,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"11329:74:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":54719,"nodeType":"ExpressionStatement","src":"11329:74:100"},{"expression":{"id":54720,"name":"_mipsImpl","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54045,"src":"11420:9:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"functionReturnParameters":54709,"id":54721,"nodeType":"Return","src":"11413:16:100"}]},"functionSelector":"e303272c","implemented":true,"kind":"function","modifiers":[],"name":"mipsImpl","nameLocation":"11278:8:100","parameters":{"id":54706,"nodeType":"ParameterList","parameters":[],"src":"11286:2:100"},"returnParameters":{"id":54709,"nodeType":"ParameterList","parameters":[{"constant":false,"id":54708,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":54723,"src":"11310:7:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":54707,"name":"address","nodeType":"ElementaryTypeName","src":"11310:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"11309:9:100"},"scope":54911,"stateMutability":"view","virtual":false,"visibility":"public"},{"id":54741,"nodeType":"FunctionDefinition","src":"11442:243:100","nodes":[],"body":{"id":54740,"nodeType":"Block","src":"11511:174:100","nodes":[],"statements":[{"expression":{"arguments":[{"commonType":{"typeIdentifier":"t_address","typeString":"address"},"id":54734,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftExpression":{"id":54729,"name":"_permissionedDisputeGameImpl","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54081,"src":"11529:28:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"BinaryOperation","operator":"!=","rightExpression":{"arguments":[{"hexValue":"30","id":54732,"isConstant":false,"isLValue":false,"isPure":true,"kind":"number","lValueRequested":false,"nodeType":"Literal","src":"11569:1:100","typeDescriptions":{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"},"value":"0"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"}],"id":54731,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"nodeType":"ElementaryTypeNameExpression","src":"11561:7:100","typeDescriptions":{"typeIdentifier":"t_type$_t_address_$","typeString":"type(address)"},"typeName":{"id":54730,"name":"address","nodeType":"ElementaryTypeName","src":"11561:7:100","typeDescriptions":{}}},"id":54733,"isConstant":false,"isLValue":false,"isPure":true,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"11561:10:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"src":"11529:42:100","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},{"hexValue":"4665746368436861696e496e666f4f75747075743a207065726d697373696f6e65644469737075746547616d65496d706c206e6f7420736574","id":54735,"isConstant":false,"isLValue":false,"isPure":true,"kind":"string","lValueRequested":false,"nodeType":"Literal","src":"11573:59:100","typeDescriptions":{"typeIdentifier":"t_stringliteral_234858b97aab3865b03b564f238f9977c62296b1532cb4f809e12678629cae92","typeString":"literal_string \"FetchChainInfoOutput: permissionedDisputeGameImpl not set\""},"value":"FetchChainInfoOutput: permissionedDisputeGameImpl not set"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_bool","typeString":"bool"},{"typeIdentifier":"t_stringliteral_234858b97aab3865b03b564f238f9977c62296b1532cb4f809e12678629cae92","typeString":"literal_string \"FetchChainInfoOutput: permissionedDisputeGameImpl not set\""}],"id":54728,"name":"require","nodeType":"Identifier","overloadedDeclarations":[-18,-18,-18],"referencedDeclaration":-18,"src":"11521:7:100","typeDescriptions":{"typeIdentifier":"t_function_require_pure$_t_bool_$_t_string_memory_ptr_$returns$__$","typeString":"function (bool,string memory) pure"}},"id":54736,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"11521:112:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":54737,"nodeType":"ExpressionStatement","src":"11521:112:100"},{"expression":{"id":54738,"name":"_permissionedDisputeGameImpl","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54081,"src":"11650:28:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"functionReturnParameters":54727,"id":54739,"nodeType":"Return","src":"11643:35:100"}]},"functionSelector":"98ccec3e","implemented":true,"kind":"function","modifiers":[],"name":"permissionedDisputeGameImpl","nameLocation":"11451:27:100","parameters":{"id":54724,"nodeType":"ParameterList","parameters":[],"src":"11478:2:100"},"returnParameters":{"id":54727,"nodeType":"ParameterList","parameters":[{"constant":false,"id":54726,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":54741,"src":"11502:7:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":54725,"name":"address","nodeType":"ElementaryTypeName","src":"11502:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"11501:9:100"},"scope":54911,"stateMutability":"view","virtual":false,"visibility":"public"},{"id":54759,"nodeType":"FunctionDefinition","src":"11691:207:100","nodes":[],"body":{"id":54758,"nodeType":"Block","src":"11751:147:100","nodes":[],"statements":[{"expression":{"arguments":[{"commonType":{"typeIdentifier":"t_address","typeString":"address"},"id":54752,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftExpression":{"id":54747,"name":"_preimageOracleImpl","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54047,"src":"11769:19:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"BinaryOperation","operator":"!=","rightExpression":{"arguments":[{"hexValue":"30","id":54750,"isConstant":false,"isLValue":false,"isPure":true,"kind":"number","lValueRequested":false,"nodeType":"Literal","src":"11800:1:100","typeDescriptions":{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"},"value":"0"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"}],"id":54749,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"nodeType":"ElementaryTypeNameExpression","src":"11792:7:100","typeDescriptions":{"typeIdentifier":"t_type$_t_address_$","typeString":"type(address)"},"typeName":{"id":54748,"name":"address","nodeType":"ElementaryTypeName","src":"11792:7:100","typeDescriptions":{}}},"id":54751,"isConstant":false,"isLValue":false,"isPure":true,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"11792:10:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"src":"11769:33:100","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},{"hexValue":"4665746368436861696e496e666f4f75747075743a20707265696d6167654f7261636c65496d706c206e6f7420736574","id":54753,"isConstant":false,"isLValue":false,"isPure":true,"kind":"string","lValueRequested":false,"nodeType":"Literal","src":"11804:50:100","typeDescriptions":{"typeIdentifier":"t_stringliteral_2434e23032e7627ba1a13e989a9fbe735952d0d6f49e2760e1b1064b8728d538","typeString":"literal_string \"FetchChainInfoOutput: preimageOracleImpl not set\""},"value":"FetchChainInfoOutput: preimageOracleImpl not set"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_bool","typeString":"bool"},{"typeIdentifier":"t_stringliteral_2434e23032e7627ba1a13e989a9fbe735952d0d6f49e2760e1b1064b8728d538","typeString":"literal_string \"FetchChainInfoOutput: preimageOracleImpl not set\""}],"id":54746,"name":"require","nodeType":"Identifier","overloadedDeclarations":[-18,-18,-18],"referencedDeclaration":-18,"src":"11761:7:100","typeDescriptions":{"typeIdentifier":"t_function_require_pure$_t_bool_$_t_string_memory_ptr_$returns$__$","typeString":"function (bool,string memory) pure"}},"id":54754,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"11761:94:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":54755,"nodeType":"ExpressionStatement","src":"11761:94:100"},{"expression":{"id":54756,"name":"_preimageOracleImpl","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54047,"src":"11872:19:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"functionReturnParameters":54745,"id":54757,"nodeType":"Return","src":"11865:26:100"}]},"functionSelector":"d030d2e8","implemented":true,"kind":"function","modifiers":[],"name":"preimageOracleImpl","nameLocation":"11700:18:100","parameters":{"id":54742,"nodeType":"ParameterList","parameters":[],"src":"11718:2:100"},"returnParameters":{"id":54745,"nodeType":"ParameterList","parameters":[{"constant":false,"id":54744,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":54759,"src":"11742:7:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":54743,"name":"address","nodeType":"ElementaryTypeName","src":"11742:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"11741:9:100"},"scope":54911,"stateMutability":"view","virtual":false,"visibility":"public"},{"id":54777,"nodeType":"FunctionDefinition","src":"11904:203:100","nodes":[],"body":{"id":54776,"nodeType":"Block","src":"11963:144:100","nodes":[],"statements":[{"expression":{"arguments":[{"commonType":{"typeIdentifier":"t_address","typeString":"address"},"id":54770,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftExpression":{"id":54765,"name":"_systemConfigOwner","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54083,"src":"11981:18:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"BinaryOperation","operator":"!=","rightExpression":{"arguments":[{"hexValue":"30","id":54768,"isConstant":false,"isLValue":false,"isPure":true,"kind":"number","lValueRequested":false,"nodeType":"Literal","src":"12011:1:100","typeDescriptions":{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"},"value":"0"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"}],"id":54767,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"nodeType":"ElementaryTypeNameExpression","src":"12003:7:100","typeDescriptions":{"typeIdentifier":"t_type$_t_address_$","typeString":"type(address)"},"typeName":{"id":54766,"name":"address","nodeType":"ElementaryTypeName","src":"12003:7:100","typeDescriptions":{}}},"id":54769,"isConstant":false,"isLValue":false,"isPure":true,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"12003:10:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"src":"11981:32:100","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},{"hexValue":"4665746368436861696e496e666f4f75747075743a2073797374656d436f6e6669674f776e6572206e6f7420736574","id":54771,"isConstant":false,"isLValue":false,"isPure":true,"kind":"string","lValueRequested":false,"nodeType":"Literal","src":"12015:49:100","typeDescriptions":{"typeIdentifier":"t_stringliteral_fc7a67f4775c5e19ca3731b64db9f9f8895dcd37a01bc895f1d1806a7f21c916","typeString":"literal_string \"FetchChainInfoOutput: systemConfigOwner not set\""},"value":"FetchChainInfoOutput: systemConfigOwner not set"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_bool","typeString":"bool"},{"typeIdentifier":"t_stringliteral_fc7a67f4775c5e19ca3731b64db9f9f8895dcd37a01bc895f1d1806a7f21c916","typeString":"literal_string \"FetchChainInfoOutput: systemConfigOwner not set\""}],"id":54764,"name":"require","nodeType":"Identifier","overloadedDeclarations":[-18,-18,-18],"referencedDeclaration":-18,"src":"11973:7:100","typeDescriptions":{"typeIdentifier":"t_function_require_pure$_t_bool_$_t_string_memory_ptr_$returns$__$","typeString":"function (bool,string memory) pure"}},"id":54772,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"11973:92:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":54773,"nodeType":"ExpressionStatement","src":"11973:92:100"},{"expression":{"id":54774,"name":"_systemConfigOwner","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54083,"src":"12082:18:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"functionReturnParameters":54763,"id":54775,"nodeType":"Return","src":"12075:25:100"}]},"functionSelector":"1e229b20","implemented":true,"kind":"function","modifiers":[],"name":"systemConfigOwner","nameLocation":"11913:17:100","parameters":{"id":54760,"nodeType":"ParameterList","parameters":[],"src":"11930:2:100"},"returnParameters":{"id":54763,"nodeType":"ParameterList","parameters":[{"constant":false,"id":54762,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":54777,"src":"11954:7:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":54761,"name":"address","nodeType":"ElementaryTypeName","src":"11954:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"11953:9:100"},"scope":54911,"stateMutability":"view","virtual":false,"visibility":"public"},{"id":54795,"nodeType":"FunctionDefinition","src":"12113:223:100","nodes":[],"body":{"id":54794,"nodeType":"Block","src":"12177:159:100","nodes":[],"statements":[{"expression":{"arguments":[{"commonType":{"typeIdentifier":"t_address","typeString":"address"},"id":54788,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftExpression":{"id":54783,"name":"_opChainProxyAdminOwner","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54085,"src":"12195:23:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"BinaryOperation","operator":"!=","rightExpression":{"arguments":[{"hexValue":"30","id":54786,"isConstant":false,"isLValue":false,"isPure":true,"kind":"number","lValueRequested":false,"nodeType":"Literal","src":"12230:1:100","typeDescriptions":{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"},"value":"0"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"}],"id":54785,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"nodeType":"ElementaryTypeNameExpression","src":"12222:7:100","typeDescriptions":{"typeIdentifier":"t_type$_t_address_$","typeString":"type(address)"},"typeName":{"id":54784,"name":"address","nodeType":"ElementaryTypeName","src":"12222:7:100","typeDescriptions":{}}},"id":54787,"isConstant":false,"isLValue":false,"isPure":true,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"12222:10:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"src":"12195:37:100","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},{"hexValue":"4665746368436861696e496e666f4f75747075743a206f70436861696e50726f787941646d696e4f776e6572206e6f7420736574","id":54789,"isConstant":false,"isLValue":false,"isPure":true,"kind":"string","lValueRequested":false,"nodeType":"Literal","src":"12234:54:100","typeDescriptions":{"typeIdentifier":"t_stringliteral_cc12cbf05d2d853ebebe6e25c8b02d2f78d6af131087a61088362ca7d0befc81","typeString":"literal_string \"FetchChainInfoOutput: opChainProxyAdminOwner not set\""},"value":"FetchChainInfoOutput: opChainProxyAdminOwner not set"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_bool","typeString":"bool"},{"typeIdentifier":"t_stringliteral_cc12cbf05d2d853ebebe6e25c8b02d2f78d6af131087a61088362ca7d0befc81","typeString":"literal_string \"FetchChainInfoOutput: opChainProxyAdminOwner not set\""}],"id":54782,"name":"require","nodeType":"Identifier","overloadedDeclarations":[-18,-18,-18],"referencedDeclaration":-18,"src":"12187:7:100","typeDescriptions":{"typeIdentifier":"t_function_require_pure$_t_bool_$_t_string_memory_ptr_$returns$__$","typeString":"function (bool,string memory) pure"}},"id":54790,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"12187:102:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":54791,"nodeType":"ExpressionStatement","src":"12187:102:100"},{"expression":{"id":54792,"name":"_opChainProxyAdminOwner","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54085,"src":"12306:23:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"functionReturnParameters":54781,"id":54793,"nodeType":"Return","src":"12299:30:100"}]},"functionSelector":"1480f0cc","implemented":true,"kind":"function","modifiers":[],"name":"opChainProxyAdminOwner","nameLocation":"12122:22:100","parameters":{"id":54778,"nodeType":"ParameterList","parameters":[],"src":"12144:2:100"},"returnParameters":{"id":54781,"nodeType":"ParameterList","parameters":[{"constant":false,"id":54780,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":54795,"src":"12168:7:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":54779,"name":"address","nodeType":"ElementaryTypeName","src":"12168:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"12167:9:100"},"scope":54911,"stateMutability":"view","virtual":false,"visibility":"public"},{"id":54813,"nodeType":"FunctionDefinition","src":"12342:195:100","nodes":[],"body":{"id":54812,"nodeType":"Block","src":"12399:138:100","nodes":[],"statements":[{"expression":{"arguments":[{"commonType":{"typeIdentifier":"t_address","typeString":"address"},"id":54806,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftExpression":{"id":54801,"name":"_opChainGuardian","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54087,"src":"12417:16:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"BinaryOperation","operator":"!=","rightExpression":{"arguments":[{"hexValue":"30","id":54804,"isConstant":false,"isLValue":false,"isPure":true,"kind":"number","lValueRequested":false,"nodeType":"Literal","src":"12445:1:100","typeDescriptions":{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"},"value":"0"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"}],"id":54803,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"nodeType":"ElementaryTypeNameExpression","src":"12437:7:100","typeDescriptions":{"typeIdentifier":"t_type$_t_address_$","typeString":"type(address)"},"typeName":{"id":54802,"name":"address","nodeType":"ElementaryTypeName","src":"12437:7:100","typeDescriptions":{}}},"id":54805,"isConstant":false,"isLValue":false,"isPure":true,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"12437:10:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"src":"12417:30:100","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},{"hexValue":"4665746368436861696e496e666f4f75747075743a206f70436861696e477561726469616e206e6f7420736574","id":54807,"isConstant":false,"isLValue":false,"isPure":true,"kind":"string","lValueRequested":false,"nodeType":"Literal","src":"12449:47:100","typeDescriptions":{"typeIdentifier":"t_stringliteral_ab71487628da5c56ff40f228ee915a62d6c0a28ab899f48f84343df6dbc48bb7","typeString":"literal_string \"FetchChainInfoOutput: opChainGuardian not set\""},"value":"FetchChainInfoOutput: opChainGuardian not set"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_bool","typeString":"bool"},{"typeIdentifier":"t_stringliteral_ab71487628da5c56ff40f228ee915a62d6c0a28ab899f48f84343df6dbc48bb7","typeString":"literal_string \"FetchChainInfoOutput: opChainGuardian not set\""}],"id":54800,"name":"require","nodeType":"Identifier","overloadedDeclarations":[-18,-18,-18],"referencedDeclaration":-18,"src":"12409:7:100","typeDescriptions":{"typeIdentifier":"t_function_require_pure$_t_bool_$_t_string_memory_ptr_$returns$__$","typeString":"function (bool,string memory) pure"}},"id":54808,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"12409:88:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":54809,"nodeType":"ExpressionStatement","src":"12409:88:100"},{"expression":{"id":54810,"name":"_opChainGuardian","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54087,"src":"12514:16:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"functionReturnParameters":54799,"id":54811,"nodeType":"Return","src":"12507:23:100"}]},"functionSelector":"4bc2695f","implemented":true,"kind":"function","modifiers":[],"name":"opChainGuardian","nameLocation":"12351:15:100","parameters":{"id":54796,"nodeType":"ParameterList","parameters":[],"src":"12366:2:100"},"returnParameters":{"id":54799,"nodeType":"ParameterList","parameters":[{"constant":false,"id":54798,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":54813,"src":"12390:7:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":54797,"name":"address","nodeType":"ElementaryTypeName","src":"12390:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"12389:9:100"},"scope":54911,"stateMutability":"view","virtual":false,"visibility":"public"},{"id":54831,"nodeType":"FunctionDefinition","src":"12543:175:100","nodes":[],"body":{"id":54830,"nodeType":"Block","src":"12595:123:100","nodes":[],"statements":[{"expression":{"arguments":[{"commonType":{"typeIdentifier":"t_address","typeString":"address"},"id":54824,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftExpression":{"id":54819,"name":"_challenger","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54089,"src":"12613:11:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"BinaryOperation","operator":"!=","rightExpression":{"arguments":[{"hexValue":"30","id":54822,"isConstant":false,"isLValue":false,"isPure":true,"kind":"number","lValueRequested":false,"nodeType":"Literal","src":"12636:1:100","typeDescriptions":{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"},"value":"0"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"}],"id":54821,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"nodeType":"ElementaryTypeNameExpression","src":"12628:7:100","typeDescriptions":{"typeIdentifier":"t_type$_t_address_$","typeString":"type(address)"},"typeName":{"id":54820,"name":"address","nodeType":"ElementaryTypeName","src":"12628:7:100","typeDescriptions":{}}},"id":54823,"isConstant":false,"isLValue":false,"isPure":true,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"12628:10:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"src":"12613:25:100","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},{"hexValue":"4665746368436861696e496e666f4f75747075743a206368616c6c656e676572206e6f7420736574","id":54825,"isConstant":false,"isLValue":false,"isPure":true,"kind":"string","lValueRequested":false,"nodeType":"Literal","src":"12640:42:100","typeDescriptions":{"typeIdentifier":"t_stringliteral_d1dd717c39956ee86b1eb77b9f3cb6dbeca6df99b330f67dd364a35a1174c2ce","typeString":"literal_string \"FetchChainInfoOutput: challenger not set\""},"value":"FetchChainInfoOutput: challenger not set"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_bool","typeString":"bool"},{"typeIdentifier":"t_stringliteral_d1dd717c39956ee86b1eb77b9f3cb6dbeca6df99b330f67dd364a35a1174c2ce","typeString":"literal_string \"FetchChainInfoOutput: challenger not set\""}],"id":54818,"name":"require","nodeType":"Identifier","overloadedDeclarations":[-18,-18,-18],"referencedDeclaration":-18,"src":"12605:7:100","typeDescriptions":{"typeIdentifier":"t_function_require_pure$_t_bool_$_t_string_memory_ptr_$returns$__$","typeString":"function (bool,string memory) pure"}},"id":54826,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"12605:78:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":54827,"nodeType":"ExpressionStatement","src":"12605:78:100"},{"expression":{"id":54828,"name":"_challenger","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54089,"src":"12700:11:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"functionReturnParameters":54817,"id":54829,"nodeType":"Return","src":"12693:18:100"}]},"functionSelector":"534db0e2","implemented":true,"kind":"function","modifiers":[],"name":"challenger","nameLocation":"12552:10:100","parameters":{"id":54814,"nodeType":"ParameterList","parameters":[],"src":"12562:2:100"},"returnParameters":{"id":54817,"nodeType":"ParameterList","parameters":[{"constant":false,"id":54816,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":54831,"src":"12586:7:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":54815,"name":"address","nodeType":"ElementaryTypeName","src":"12586:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"12585:9:100"},"scope":54911,"stateMutability":"view","virtual":false,"visibility":"public"},{"id":54849,"nodeType":"FunctionDefinition","src":"12724:167:100","nodes":[],"body":{"id":54848,"nodeType":"Block","src":"12774:117:100","nodes":[],"statements":[{"expression":{"arguments":[{"commonType":{"typeIdentifier":"t_address","typeString":"address"},"id":54842,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftExpression":{"id":54837,"name":"_proposer","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54091,"src":"12792:9:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"BinaryOperation","operator":"!=","rightExpression":{"arguments":[{"hexValue":"30","id":54840,"isConstant":false,"isLValue":false,"isPure":true,"kind":"number","lValueRequested":false,"nodeType":"Literal","src":"12813:1:100","typeDescriptions":{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"},"value":"0"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"}],"id":54839,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"nodeType":"ElementaryTypeNameExpression","src":"12805:7:100","typeDescriptions":{"typeIdentifier":"t_type$_t_address_$","typeString":"type(address)"},"typeName":{"id":54838,"name":"address","nodeType":"ElementaryTypeName","src":"12805:7:100","typeDescriptions":{}}},"id":54841,"isConstant":false,"isLValue":false,"isPure":true,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"12805:10:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"src":"12792:23:100","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},{"hexValue":"4665746368436861696e496e666f4f75747075743a2070726f706f736572206e6f7420736574","id":54843,"isConstant":false,"isLValue":false,"isPure":true,"kind":"string","lValueRequested":false,"nodeType":"Literal","src":"12817:40:100","typeDescriptions":{"typeIdentifier":"t_stringliteral_c4910753f64240b424591ec2bc873e5a728ff321d57cb1a353788ad2c385da71","typeString":"literal_string \"FetchChainInfoOutput: proposer not set\""},"value":"FetchChainInfoOutput: proposer not set"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_bool","typeString":"bool"},{"typeIdentifier":"t_stringliteral_c4910753f64240b424591ec2bc873e5a728ff321d57cb1a353788ad2c385da71","typeString":"literal_string \"FetchChainInfoOutput: proposer not set\""}],"id":54836,"name":"require","nodeType":"Identifier","overloadedDeclarations":[-18,-18,-18],"referencedDeclaration":-18,"src":"12784:7:100","typeDescriptions":{"typeIdentifier":"t_function_require_pure$_t_bool_$_t_string_memory_ptr_$returns$__$","typeString":"function (bool,string memory) pure"}},"id":54844,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"12784:74:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":54845,"nodeType":"ExpressionStatement","src":"12784:74:100"},{"expression":{"id":54846,"name":"_proposer","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54091,"src":"12875:9:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"functionReturnParameters":54835,"id":54847,"nodeType":"Return","src":"12868:16:100"}]},"functionSelector":"a8e4fb90","implemented":true,"kind":"function","modifiers":[],"name":"proposer","nameLocation":"12733:8:100","parameters":{"id":54832,"nodeType":"ParameterList","parameters":[],"src":"12741:2:100"},"returnParameters":{"id":54835,"nodeType":"ParameterList","parameters":[{"constant":false,"id":54834,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":54849,"src":"12765:7:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":54833,"name":"address","nodeType":"ElementaryTypeName","src":"12765:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"12764:9:100"},"scope":54911,"stateMutability":"view","virtual":false,"visibility":"public"},{"id":54867,"nodeType":"FunctionDefinition","src":"12897:203:100","nodes":[],"body":{"id":54866,"nodeType":"Block","src":"12956:144:100","nodes":[],"statements":[{"expression":{"arguments":[{"commonType":{"typeIdentifier":"t_address","typeString":"address"},"id":54860,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftExpression":{"id":54855,"name":"_unsafeBlockSigner","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54093,"src":"12974:18:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"BinaryOperation","operator":"!=","rightExpression":{"arguments":[{"hexValue":"30","id":54858,"isConstant":false,"isLValue":false,"isPure":true,"kind":"number","lValueRequested":false,"nodeType":"Literal","src":"13004:1:100","typeDescriptions":{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"},"value":"0"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"}],"id":54857,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"nodeType":"ElementaryTypeNameExpression","src":"12996:7:100","typeDescriptions":{"typeIdentifier":"t_type$_t_address_$","typeString":"type(address)"},"typeName":{"id":54856,"name":"address","nodeType":"ElementaryTypeName","src":"12996:7:100","typeDescriptions":{}}},"id":54859,"isConstant":false,"isLValue":false,"isPure":true,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"12996:10:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"src":"12974:32:100","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},{"hexValue":"4665746368436861696e496e666f4f75747075743a20756e73616665426c6f636b5369676e6572206e6f7420736574","id":54861,"isConstant":false,"isLValue":false,"isPure":true,"kind":"string","lValueRequested":false,"nodeType":"Literal","src":"13008:49:100","typeDescriptions":{"typeIdentifier":"t_stringliteral_c0c85432d1596fb73656e29b64f6ea745166dde4a7fa6163bfe6b285aea851d7","typeString":"literal_string \"FetchChainInfoOutput: unsafeBlockSigner not set\""},"value":"FetchChainInfoOutput: unsafeBlockSigner not set"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_bool","typeString":"bool"},{"typeIdentifier":"t_stringliteral_c0c85432d1596fb73656e29b64f6ea745166dde4a7fa6163bfe6b285aea851d7","typeString":"literal_string \"FetchChainInfoOutput: unsafeBlockSigner not set\""}],"id":54854,"name":"require","nodeType":"Identifier","overloadedDeclarations":[-18,-18,-18],"referencedDeclaration":-18,"src":"12966:7:100","typeDescriptions":{"typeIdentifier":"t_function_require_pure$_t_bool_$_t_string_memory_ptr_$returns$__$","typeString":"function (bool,string memory) pure"}},"id":54862,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"12966:92:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":54863,"nodeType":"ExpressionStatement","src":"12966:92:100"},{"expression":{"id":54864,"name":"_unsafeBlockSigner","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54093,"src":"13075:18:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"functionReturnParameters":54853,"id":54865,"nodeType":"Return","src":"13068:25:100"}]},"functionSelector":"1fd19ee1","implemented":true,"kind":"function","modifiers":[],"name":"unsafeBlockSigner","nameLocation":"12906:17:100","parameters":{"id":54850,"nodeType":"ParameterList","parameters":[],"src":"12923:2:100"},"returnParameters":{"id":54853,"nodeType":"ParameterList","parameters":[{"constant":false,"id":54852,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":54867,"src":"12947:7:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":54851,"name":"address","nodeType":"ElementaryTypeName","src":"12947:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"12946:9:100"},"scope":54911,"stateMutability":"view","virtual":false,"visibility":"public"},{"id":54885,"nodeType":"FunctionDefinition","src":"13106:191:100","nodes":[],"body":{"id":54884,"nodeType":"Block","src":"13162:135:100","nodes":[],"statements":[{"expression":{"arguments":[{"commonType":{"typeIdentifier":"t_address","typeString":"address"},"id":54878,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftExpression":{"id":54873,"name":"_batchSubmitter","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54095,"src":"13180:15:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"BinaryOperation","operator":"!=","rightExpression":{"arguments":[{"hexValue":"30","id":54876,"isConstant":false,"isLValue":false,"isPure":true,"kind":"number","lValueRequested":false,"nodeType":"Literal","src":"13207:1:100","typeDescriptions":{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"},"value":"0"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"}],"id":54875,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"nodeType":"ElementaryTypeNameExpression","src":"13199:7:100","typeDescriptions":{"typeIdentifier":"t_type$_t_address_$","typeString":"type(address)"},"typeName":{"id":54874,"name":"address","nodeType":"ElementaryTypeName","src":"13199:7:100","typeDescriptions":{}}},"id":54877,"isConstant":false,"isLValue":false,"isPure":true,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"13199:10:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"src":"13180:29:100","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},{"hexValue":"4665746368436861696e496e666f4f75747075743a2062617463685375626d6974746572206e6f7420736574","id":54879,"isConstant":false,"isLValue":false,"isPure":true,"kind":"string","lValueRequested":false,"nodeType":"Literal","src":"13211:46:100","typeDescriptions":{"typeIdentifier":"t_stringliteral_dc2094d90bbe21c62e4087e13d121e3f8b0b046ea0a70d61432535290d56a2cc","typeString":"literal_string \"FetchChainInfoOutput: batchSubmitter not set\""},"value":"FetchChainInfoOutput: batchSubmitter not set"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_bool","typeString":"bool"},{"typeIdentifier":"t_stringliteral_dc2094d90bbe21c62e4087e13d121e3f8b0b046ea0a70d61432535290d56a2cc","typeString":"literal_string \"FetchChainInfoOutput: batchSubmitter not set\""}],"id":54872,"name":"require","nodeType":"Identifier","overloadedDeclarations":[-18,-18,-18],"referencedDeclaration":-18,"src":"13172:7:100","typeDescriptions":{"typeIdentifier":"t_function_require_pure$_t_bool_$_t_string_memory_ptr_$returns$__$","typeString":"function (bool,string memory) pure"}},"id":54880,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"13172:86:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":54881,"nodeType":"ExpressionStatement","src":"13172:86:100"},{"expression":{"id":54882,"name":"_batchSubmitter","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54095,"src":"13275:15:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"functionReturnParameters":54871,"id":54883,"nodeType":"Return","src":"13268:22:100"}]},"functionSelector":"fb951e9d","implemented":true,"kind":"function","modifiers":[],"name":"batchSubmitter","nameLocation":"13115:14:100","parameters":{"id":54868,"nodeType":"ParameterList","parameters":[],"src":"13129:2:100"},"returnParameters":{"id":54871,"nodeType":"ParameterList","parameters":[{"constant":false,"id":54870,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":54885,"src":"13153:7:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":54869,"name":"address","nodeType":"ElementaryTypeName","src":"13153:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"13152:9:100"},"scope":54911,"stateMutability":"view","virtual":false,"visibility":"public"},{"id":54893,"nodeType":"FunctionDefinition","src":"13303:88:100","nodes":[],"body":{"id":54892,"nodeType":"Block","src":"13354:37:100","nodes":[],"statements":[{"expression":{"id":54890,"name":"_permissioned","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54097,"src":"13371:13:100","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},"functionReturnParameters":54889,"id":54891,"nodeType":"Return","src":"13364:20:100"}]},"functionSelector":"3cc162f1","implemented":true,"kind":"function","modifiers":[],"name":"permissioned","nameLocation":"13312:12:100","parameters":{"id":54886,"nodeType":"ParameterList","parameters":[],"src":"13324:2:100"},"returnParameters":{"id":54889,"nodeType":"ParameterList","parameters":[{"constant":false,"id":54888,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":54893,"src":"13348:4:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"},"typeName":{"id":54887,"name":"bool","nodeType":"ElementaryTypeName","src":"13348:4:100","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},"visibility":"internal"}],"src":"13347:6:100"},"scope":54911,"stateMutability":"view","virtual":false,"visibility":"public"},{"id":54901,"nodeType":"FunctionDefinition","src":"13397:92:100","nodes":[],"body":{"id":54900,"nodeType":"Block","src":"13450:39:100","nodes":[],"statements":[{"expression":{"id":54898,"name":"_permissionless","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54099,"src":"13467:15:100","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},"functionReturnParameters":54897,"id":54899,"nodeType":"Return","src":"13460:22:100"}]},"functionSelector":"a1256f9f","implemented":true,"kind":"function","modifiers":[],"name":"permissionless","nameLocation":"13406:14:100","parameters":{"id":54894,"nodeType":"ParameterList","parameters":[],"src":"13420:2:100"},"returnParameters":{"id":54897,"nodeType":"ParameterList","parameters":[{"constant":false,"id":54896,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":54901,"src":"13444:4:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"},"typeName":{"id":54895,"name":"bool","nodeType":"ElementaryTypeName","src":"13444:4:100","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},"visibility":"internal"}],"src":"13443:6:100"},"scope":54911,"stateMutability":"view","virtual":false,"visibility":"public"},{"id":54910,"nodeType":"FunctionDefinition","src":"13495:102:100","nodes":[],"body":{"id":54909,"nodeType":"Block","src":"13555:42:100","nodes":[],"statements":[{"expression":{"id":54907,"name":"_respectedGameType","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54102,"src":"13572:18:100","typeDescriptions":{"typeIdentifier":"t_userDefinedValueType$_GameType_$70720","typeString":"GameType"}},"functionReturnParameters":54906,"id":54908,"nodeType":"Return","src":"13565:25:100"}]},"functionSelector":"3c9f397c","implemented":true,"kind":"function","modifiers":[],"name":"respectedGameType","nameLocation":"13504:17:100","parameters":{"id":54902,"nodeType":"ParameterList","parameters":[],"src":"13521:2:100"},"returnParameters":{"id":54906,"nodeType":"ParameterList","parameters":[{"constant":false,"id":54905,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":54910,"src":"13545:8:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_userDefinedValueType$_GameType_$70720","typeString":"GameType"},"typeName":{"id":54904,"nodeType":"UserDefinedTypeName","pathNode":{"id":54903,"name":"GameType","nameLocations":["13545:8:100"],"nodeType":"IdentifierPath","referencedDeclaration":70720,"src":"13545:8:100"},"referencedDeclaration":70720,"src":"13545:8:100","typeDescriptions":{"typeIdentifier":"t_userDefinedValueType$_GameType_$70720","typeString":"GameType"}},"visibility":"internal"}],"src":"13544:10:100"},"scope":54911,"stateMutability":"view","virtual":false,"visibility":"public"}],"abstract":false,"baseContracts":[],"canonicalName":"FetchChainInfoOutput","contractDependencies":[],"contractKind":"contract","fullyImplemented":true,"linearizedBaseContracts":[54911],"name":"FetchChainInfoOutput","nameLocation":"2966:20:100","scope":56019,"usedErrors":[],"usedEvents":[]},{"id":56018,"nodeType":"ContractDefinition","src":"13601:11550:100","nodes":[{"id":54937,"nodeType":"FunctionDefinition","src":"13641:198:100","nodes":[],"body":{"id":54936,"nodeType":"Block","src":"13712:127:100","nodes":[],"statements":[{"expression":{"arguments":[{"id":54923,"name":"_fi","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54916,"src":"13743:3:100","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoInput_$54041","typeString":"contract FetchChainInfoInput"}},{"id":54924,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54919,"src":"13748:3:100","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$54911","typeString":"contract FetchChainInfoOutput"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_contract$_FetchChainInfoInput_$54041","typeString":"contract FetchChainInfoInput"},{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$54911","typeString":"contract FetchChainInfoOutput"}],"id":54922,"name":"_processSystemConfig","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55073,"src":"13722:20:100","typeDescriptions":{"typeIdentifier":"t_function_internal_nonpayable$_t_contract$_FetchChainInfoInput_$54041_$_t_contract$_FetchChainInfoOutput_$54911_$returns$__$","typeString":"function (contract FetchChainInfoInput,contract FetchChainInfoOutput)"}},"id":54925,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"13722:30:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":54926,"nodeType":"ExpressionStatement","src":"13722:30:100"},{"expression":{"arguments":[{"id":54928,"name":"_fi","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54916,"src":"13789:3:100","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoInput_$54041","typeString":"contract FetchChainInfoInput"}},{"id":54929,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54919,"src":"13794:3:100","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$54911","typeString":"contract FetchChainInfoOutput"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_contract$_FetchChainInfoInput_$54041","typeString":"contract FetchChainInfoInput"},{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$54911","typeString":"contract FetchChainInfoOutput"}],"id":54927,"name":"_processMessengerAndPortal","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55190,"src":"13762:26:100","typeDescriptions":{"typeIdentifier":"t_function_internal_nonpayable$_t_contract$_FetchChainInfoInput_$54041_$_t_contract$_FetchChainInfoOutput_$54911_$returns$__$","typeString":"function (contract FetchChainInfoInput,contract FetchChainInfoOutput)"}},"id":54930,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"13762:36:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":54931,"nodeType":"ExpressionStatement","src":"13762:36:100"},{"expression":{"arguments":[{"id":54933,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54919,"src":"13828:3:100","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$54911","typeString":"contract FetchChainInfoOutput"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$54911","typeString":"contract FetchChainInfoOutput"}],"id":54932,"name":"_processFaultProofs","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55565,"src":"13808:19:100","typeDescriptions":{"typeIdentifier":"t_function_internal_nonpayable$_t_contract$_FetchChainInfoOutput_$54911_$returns$__$","typeString":"function (contract FetchChainInfoOutput)"}},"id":54934,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"13808:24:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":54935,"nodeType":"ExpressionStatement","src":"13808:24:100"}]},"functionSelector":"fc4dcacb","implemented":true,"kind":"function","modifiers":[],"name":"run","nameLocation":"13650:3:100","parameters":{"id":54920,"nodeType":"ParameterList","parameters":[{"constant":false,"id":54916,"mutability":"mutable","name":"_fi","nameLocation":"13674:3:100","nodeType":"VariableDeclaration","scope":54937,"src":"13654:23:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoInput_$54041","typeString":"contract FetchChainInfoInput"},"typeName":{"id":54915,"nodeType":"UserDefinedTypeName","pathNode":{"id":54914,"name":"FetchChainInfoInput","nameLocations":["13654:19:100"],"nodeType":"IdentifierPath","referencedDeclaration":54041,"src":"13654:19:100"},"referencedDeclaration":54041,"src":"13654:19:100","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoInput_$54041","typeString":"contract FetchChainInfoInput"}},"visibility":"internal"},{"constant":false,"id":54919,"mutability":"mutable","name":"_fo","nameLocation":"13700:3:100","nodeType":"VariableDeclaration","scope":54937,"src":"13679:24:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$54911","typeString":"contract FetchChainInfoOutput"},"typeName":{"id":54918,"nodeType":"UserDefinedTypeName","pathNode":{"id":54917,"name":"FetchChainInfoOutput","nameLocations":["13679:20:100"],"nodeType":"IdentifierPath","referencedDeclaration":54911,"src":"13679:20:100"},"referencedDeclaration":54911,"src":"13679:20:100","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$54911","typeString":"contract FetchChainInfoOutput"}},"visibility":"internal"}],"src":"13653:51:100"},"returnParameters":{"id":54921,"nodeType":"ParameterList","parameters":[],"src":"13712:0:100"},"scope":56018,"stateMutability":"nonpayable","virtual":false,"visibility":"public"},{"id":55073,"nodeType":"FunctionDefinition","src":"13845:1336:100","nodes":[],"body":{"id":55072,"nodeType":"Block","src":"13935:1246:100","nodes":[],"statements":[{"assignments":[54947],"declarations":[{"constant":false,"id":54947,"mutability":"mutable","name":"systemConfigProxy","nameLocation":"13953:17:100","nodeType":"VariableDeclaration","scope":55072,"src":"13945:25:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":54946,"name":"address","nodeType":"ElementaryTypeName","src":"13945:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"id":54951,"initialValue":{"arguments":[],"expression":{"argumentTypes":[],"expression":{"id":54948,"name":"_fi","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54940,"src":"13973:3:100","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoInput_$54041","typeString":"contract FetchChainInfoInput"}},"id":54949,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"13977:17:100","memberName":"systemConfigProxy","nodeType":"MemberAccess","referencedDeclaration":54022,"src":"13973:21:100","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":54950,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"13973:23:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"VariableDeclarationStatement","src":"13945:51:100"},{"expression":{"arguments":[{"expression":{"expression":{"id":54955,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54943,"src":"14014:3:100","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$54911","typeString":"contract FetchChainInfoOutput"}},"id":54956,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"14018:17:100","memberName":"systemConfigProxy","nodeType":"MemberAccess","referencedDeclaration":54591,"src":"14014:21:100","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":54957,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"14036:8:100","memberName":"selector","nodeType":"MemberAccess","src":"14014:30:100","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},{"id":54958,"name":"systemConfigProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54947,"src":"14046:17:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_bytes4","typeString":"bytes4"},{"typeIdentifier":"t_address","typeString":"address"}],"expression":{"id":54952,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54943,"src":"14006:3:100","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$54911","typeString":"contract FetchChainInfoOutput"}},"id":54954,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"14010:3:100","memberName":"set","nodeType":"MemberAccess","referencedDeclaration":54384,"src":"14006:7:100","typeDescriptions":{"typeIdentifier":"t_function_external_nonpayable$_t_bytes4_$_t_address_$returns$__$","typeString":"function (bytes4,address) external"}},"id":54959,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"14006:58:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":54960,"nodeType":"ExpressionStatement","src":"14006:58:100"},{"assignments":[54962],"declarations":[{"constant":false,"id":54962,"mutability":"mutable","name":"systemConfigOwner","nameLocation":"14083:17:100","nodeType":"VariableDeclaration","scope":55072,"src":"14075:25:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":54961,"name":"address","nodeType":"ElementaryTypeName","src":"14075:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"id":54968,"initialValue":{"arguments":[],"expression":{"argumentTypes":[],"expression":{"arguments":[{"id":54964,"name":"systemConfigProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54947,"src":"14112:17:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_address","typeString":"address"}],"id":54963,"name":"IFetcher","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":53958,"src":"14103:8:100","typeDescriptions":{"typeIdentifier":"t_type$_t_contract$_IFetcher_$53958_$","typeString":"type(contract IFetcher)"}},"id":54965,"isConstant":false,"isLValue":false,"isPure":false,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"14103:27:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_contract$_IFetcher_$53958","typeString":"contract IFetcher"}},"id":54966,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"14131:5:100","memberName":"owner","nodeType":"MemberAccess","referencedDeclaration":53947,"src":"14103:33:100","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":54967,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"14103:35:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"VariableDeclarationStatement","src":"14075:63:100"},{"expression":{"arguments":[{"expression":{"expression":{"id":54972,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54943,"src":"14156:3:100","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$54911","typeString":"contract FetchChainInfoOutput"}},"id":54973,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"14160:17:100","memberName":"systemConfigOwner","nodeType":"MemberAccess","referencedDeclaration":54777,"src":"14156:21:100","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":54974,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"14178:8:100","memberName":"selector","nodeType":"MemberAccess","src":"14156:30:100","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},{"id":54975,"name":"systemConfigOwner","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54962,"src":"14188:17:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_bytes4","typeString":"bytes4"},{"typeIdentifier":"t_address","typeString":"address"}],"expression":{"id":54969,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54943,"src":"14148:3:100","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$54911","typeString":"contract FetchChainInfoOutput"}},"id":54971,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"14152:3:100","memberName":"set","nodeType":"MemberAccess","referencedDeclaration":54384,"src":"14148:7:100","typeDescriptions":{"typeIdentifier":"t_function_external_nonpayable$_t_bytes4_$_t_address_$returns$__$","typeString":"function (bytes4,address) external"}},"id":54976,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"14148:58:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":54977,"nodeType":"ExpressionStatement","src":"14148:58:100"},{"assignments":[54979],"declarations":[{"constant":false,"id":54979,"mutability":"mutable","name":"unsafeBlockSigner","nameLocation":"14225:17:100","nodeType":"VariableDeclaration","scope":55072,"src":"14217:25:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":54978,"name":"address","nodeType":"ElementaryTypeName","src":"14217:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"id":54985,"initialValue":{"arguments":[],"expression":{"argumentTypes":[],"expression":{"arguments":[{"id":54981,"name":"systemConfigProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54947,"src":"14254:17:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_address","typeString":"address"}],"id":54980,"name":"IFetcher","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":53958,"src":"14245:8:100","typeDescriptions":{"typeIdentifier":"t_type$_t_contract$_IFetcher_$53958_$","typeString":"type(contract IFetcher)"}},"id":54982,"isConstant":false,"isLValue":false,"isPure":false,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"14245:27:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_contract$_IFetcher_$53958","typeString":"contract IFetcher"}},"id":54983,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"14273:17:100","memberName":"unsafeBlockSigner","nodeType":"MemberAccess","referencedDeclaration":53952,"src":"14245:45:100","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":54984,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"14245:47:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"VariableDeclarationStatement","src":"14217:75:100"},{"expression":{"arguments":[{"expression":{"expression":{"id":54989,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54943,"src":"14310:3:100","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$54911","typeString":"contract FetchChainInfoOutput"}},"id":54990,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"14314:17:100","memberName":"unsafeBlockSigner","nodeType":"MemberAccess","referencedDeclaration":54867,"src":"14310:21:100","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":54991,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"14332:8:100","memberName":"selector","nodeType":"MemberAccess","src":"14310:30:100","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},{"id":54992,"name":"unsafeBlockSigner","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54979,"src":"14342:17:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_bytes4","typeString":"bytes4"},{"typeIdentifier":"t_address","typeString":"address"}],"expression":{"id":54986,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54943,"src":"14302:3:100","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$54911","typeString":"contract FetchChainInfoOutput"}},"id":54988,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"14306:3:100","memberName":"set","nodeType":"MemberAccess","referencedDeclaration":54384,"src":"14302:7:100","typeDescriptions":{"typeIdentifier":"t_function_external_nonpayable$_t_bytes4_$_t_address_$returns$__$","typeString":"function (bytes4,address) external"}},"id":54993,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"14302:58:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":54994,"nodeType":"ExpressionStatement","src":"14302:58:100"},{"assignments":[54996],"declarations":[{"constant":false,"id":54996,"mutability":"mutable","name":"batchSubmitter","nameLocation":"14379:14:100","nodeType":"VariableDeclaration","scope":55072,"src":"14371:22:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":54995,"name":"address","nodeType":"ElementaryTypeName","src":"14371:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"id":55000,"initialValue":{"arguments":[{"id":54998,"name":"systemConfigProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54947,"src":"14415:17:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_address","typeString":"address"}],"id":54997,"name":"_getBatchSubmitter","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55994,"src":"14396:18:100","typeDescriptions":{"typeIdentifier":"t_function_internal_view$_t_address_$returns$_t_address_$","typeString":"function (address) view returns (address)"}},"id":54999,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"14396:37:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"VariableDeclarationStatement","src":"14371:62:100"},{"expression":{"arguments":[{"expression":{"expression":{"id":55004,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54943,"src":"14451:3:100","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$54911","typeString":"contract FetchChainInfoOutput"}},"id":55005,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"14455:14:100","memberName":"batchSubmitter","nodeType":"MemberAccess","referencedDeclaration":54885,"src":"14451:18:100","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":55006,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"14470:8:100","memberName":"selector","nodeType":"MemberAccess","src":"14451:27:100","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},{"id":55007,"name":"batchSubmitter","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54996,"src":"14480:14:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_bytes4","typeString":"bytes4"},{"typeIdentifier":"t_address","typeString":"address"}],"expression":{"id":55001,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54943,"src":"14443:3:100","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$54911","typeString":"contract FetchChainInfoOutput"}},"id":55003,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"14447:3:100","memberName":"set","nodeType":"MemberAccess","referencedDeclaration":54384,"src":"14443:7:100","typeDescriptions":{"typeIdentifier":"t_function_external_nonpayable$_t_bytes4_$_t_address_$returns$__$","typeString":"function (bytes4,address) external"}},"id":55008,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"14443:52:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":55009,"nodeType":"ExpressionStatement","src":"14443:52:100"},{"assignments":[55011],"declarations":[{"constant":false,"id":55011,"mutability":"mutable","name":"opChainProxyAdminImpl","nameLocation":"14514:21:100","nodeType":"VariableDeclaration","scope":55072,"src":"14506:29:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":55010,"name":"address","nodeType":"ElementaryTypeName","src":"14506:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"id":55015,"initialValue":{"arguments":[{"id":55013,"name":"systemConfigProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54947,"src":"14553:17:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_address","typeString":"address"}],"id":55012,"name":"_getProxyAdmin","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":56017,"src":"14538:14:100","typeDescriptions":{"typeIdentifier":"t_function_internal_nonpayable$_t_address_$returns$_t_address_$","typeString":"function (address) returns (address)"}},"id":55014,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"14538:33:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"VariableDeclarationStatement","src":"14506:65:100"},{"expression":{"arguments":[{"expression":{"expression":{"id":55019,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54943,"src":"14589:3:100","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$54911","typeString":"contract FetchChainInfoOutput"}},"id":55020,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"14593:21:100","memberName":"opChainProxyAdminImpl","nodeType":"MemberAccess","referencedDeclaration":54609,"src":"14589:25:100","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":55021,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"14615:8:100","memberName":"selector","nodeType":"MemberAccess","src":"14589:34:100","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},{"id":55022,"name":"opChainProxyAdminImpl","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55011,"src":"14625:21:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_bytes4","typeString":"bytes4"},{"typeIdentifier":"t_address","typeString":"address"}],"expression":{"id":55016,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54943,"src":"14581:3:100","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$54911","typeString":"contract FetchChainInfoOutput"}},"id":55018,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"14585:3:100","memberName":"set","nodeType":"MemberAccess","referencedDeclaration":54384,"src":"14581:7:100","typeDescriptions":{"typeIdentifier":"t_function_external_nonpayable$_t_bytes4_$_t_address_$returns$__$","typeString":"function (bytes4,address) external"}},"id":55023,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"14581:66:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":55024,"nodeType":"ExpressionStatement","src":"14581:66:100"},{"assignments":[55026],"declarations":[{"constant":false,"id":55026,"mutability":"mutable","name":"opChainProxyAdminOwner","nameLocation":"14666:22:100","nodeType":"VariableDeclaration","scope":55072,"src":"14658:30:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":55025,"name":"address","nodeType":"ElementaryTypeName","src":"14658:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"id":55032,"initialValue":{"arguments":[],"expression":{"argumentTypes":[],"expression":{"arguments":[{"id":55028,"name":"opChainProxyAdminImpl","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55011,"src":"14700:21:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_address","typeString":"address"}],"id":55027,"name":"IFetcher","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":53958,"src":"14691:8:100","typeDescriptions":{"typeIdentifier":"t_type$_t_contract$_IFetcher_$53958_$","typeString":"type(contract IFetcher)"}},"id":55029,"isConstant":false,"isLValue":false,"isPure":false,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"14691:31:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_contract$_IFetcher_$53958","typeString":"contract IFetcher"}},"id":55030,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"14723:5:100","memberName":"owner","nodeType":"MemberAccess","referencedDeclaration":53947,"src":"14691:37:100","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":55031,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"14691:39:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"VariableDeclarationStatement","src":"14658:72:100"},{"expression":{"arguments":[{"expression":{"expression":{"id":55036,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54943,"src":"14748:3:100","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$54911","typeString":"contract FetchChainInfoOutput"}},"id":55037,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"14752:22:100","memberName":"opChainProxyAdminOwner","nodeType":"MemberAccess","referencedDeclaration":54795,"src":"14748:26:100","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":55038,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"14775:8:100","memberName":"selector","nodeType":"MemberAccess","src":"14748:35:100","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},{"id":55039,"name":"opChainProxyAdminOwner","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55026,"src":"14785:22:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_bytes4","typeString":"bytes4"},{"typeIdentifier":"t_address","typeString":"address"}],"expression":{"id":55033,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54943,"src":"14740:3:100","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$54911","typeString":"contract FetchChainInfoOutput"}},"id":55035,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"14744:3:100","memberName":"set","nodeType":"MemberAccess","referencedDeclaration":54384,"src":"14740:7:100","typeDescriptions":{"typeIdentifier":"t_function_external_nonpayable$_t_bytes4_$_t_address_$returns$__$","typeString":"function (bytes4,address) external"}},"id":55040,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"14740:68:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":55041,"nodeType":"ExpressionStatement","src":"14740:68:100"},{"assignments":[55043],"declarations":[{"constant":false,"id":55043,"mutability":"mutable","name":"l1Erc721BridgeProxy","nameLocation":"14827:19:100","nodeType":"VariableDeclaration","scope":55072,"src":"14819:27:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":55042,"name":"address","nodeType":"ElementaryTypeName","src":"14819:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"id":55047,"initialValue":{"arguments":[{"id":55045,"name":"systemConfigProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54947,"src":"14873:17:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_address","typeString":"address"}],"id":55044,"name":"_getL1ERC721BridgeProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55718,"src":"14849:23:100","typeDescriptions":{"typeIdentifier":"t_function_internal_view$_t_address_$returns$_t_address_$","typeString":"function (address) view returns (address)"}},"id":55046,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"14849:42:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"VariableDeclarationStatement","src":"14819:72:100"},{"expression":{"arguments":[{"expression":{"expression":{"id":55051,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54943,"src":"14909:3:100","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$54911","typeString":"contract FetchChainInfoOutput"}},"id":55052,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"14913:19:100","memberName":"l1Erc721BridgeProxy","nodeType":"MemberAccess","referencedDeclaration":54501,"src":"14909:23:100","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":55053,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"14933:8:100","memberName":"selector","nodeType":"MemberAccess","src":"14909:32:100","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},{"id":55054,"name":"l1Erc721BridgeProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55043,"src":"14943:19:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_bytes4","typeString":"bytes4"},{"typeIdentifier":"t_address","typeString":"address"}],"expression":{"id":55048,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54943,"src":"14901:3:100","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$54911","typeString":"contract FetchChainInfoOutput"}},"id":55050,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"14905:3:100","memberName":"set","nodeType":"MemberAccess","referencedDeclaration":54384,"src":"14901:7:100","typeDescriptions":{"typeIdentifier":"t_function_external_nonpayable$_t_bytes4_$_t_address_$returns$__$","typeString":"function (bytes4,address) external"}},"id":55055,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"14901:62:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":55056,"nodeType":"ExpressionStatement","src":"14901:62:100"},{"assignments":[55058],"declarations":[{"constant":false,"id":55058,"mutability":"mutable","name":"optimismMintableErc20FactoryProxy","nameLocation":"14982:33:100","nodeType":"VariableDeclaration","scope":55072,"src":"14974:41:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":55057,"name":"address","nodeType":"ElementaryTypeName","src":"14974:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"id":55062,"initialValue":{"arguments":[{"id":55060,"name":"systemConfigProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54947,"src":"15056:17:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_address","typeString":"address"}],"id":55059,"name":"_getOptimismMintableERC20FactoryProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55746,"src":"15018:37:100","typeDescriptions":{"typeIdentifier":"t_function_internal_view$_t_address_$returns$_t_address_$","typeString":"function (address) view returns (address)"}},"id":55061,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"15018:56:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"VariableDeclarationStatement","src":"14974:100:100"},{"expression":{"arguments":[{"expression":{"expression":{"id":55066,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54943,"src":"15092:3:100","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$54911","typeString":"contract FetchChainInfoOutput"}},"id":55067,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"15096:33:100","memberName":"optimismMintableErc20FactoryProxy","nodeType":"MemberAccess","referencedDeclaration":54555,"src":"15092:37:100","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":55068,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"15130:8:100","memberName":"selector","nodeType":"MemberAccess","src":"15092:46:100","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},{"id":55069,"name":"optimismMintableErc20FactoryProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55058,"src":"15140:33:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_bytes4","typeString":"bytes4"},{"typeIdentifier":"t_address","typeString":"address"}],"expression":{"id":55063,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":54943,"src":"15084:3:100","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$54911","typeString":"contract FetchChainInfoOutput"}},"id":55065,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"15088:3:100","memberName":"set","nodeType":"MemberAccess","referencedDeclaration":54384,"src":"15084:7:100","typeDescriptions":{"typeIdentifier":"t_function_external_nonpayable$_t_bytes4_$_t_address_$returns$__$","typeString":"function (bytes4,address) external"}},"id":55070,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"15084:90:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":55071,"nodeType":"ExpressionStatement","src":"15084:90:100"}]},"implemented":true,"kind":"function","modifiers":[],"name":"_processSystemConfig","nameLocation":"13854:20:100","parameters":{"id":54944,"nodeType":"ParameterList","parameters":[{"constant":false,"id":54940,"mutability":"mutable","name":"_fi","nameLocation":"13895:3:100","nodeType":"VariableDeclaration","scope":55073,"src":"13875:23:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoInput_$54041","typeString":"contract FetchChainInfoInput"},"typeName":{"id":54939,"nodeType":"UserDefinedTypeName","pathNode":{"id":54938,"name":"FetchChainInfoInput","nameLocations":["13875:19:100"],"nodeType":"IdentifierPath","referencedDeclaration":54041,"src":"13875:19:100"},"referencedDeclaration":54041,"src":"13875:19:100","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoInput_$54041","typeString":"contract FetchChainInfoInput"}},"visibility":"internal"},{"constant":false,"id":54943,"mutability":"mutable","name":"_fo","nameLocation":"13921:3:100","nodeType":"VariableDeclaration","scope":55073,"src":"13900:24:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$54911","typeString":"contract FetchChainInfoOutput"},"typeName":{"id":54942,"nodeType":"UserDefinedTypeName","pathNode":{"id":54941,"name":"FetchChainInfoOutput","nameLocations":["13900:20:100"],"nodeType":"IdentifierPath","referencedDeclaration":54911,"src":"13900:20:100"},"referencedDeclaration":54911,"src":"13900:20:100","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$54911","typeString":"contract FetchChainInfoOutput"}},"visibility":"internal"}],"src":"13874:51:100"},"returnParameters":{"id":54945,"nodeType":"ParameterList","parameters":[],"src":"13935:0:100"},"scope":56018,"stateMutability":"nonpayable","virtual":false,"visibility":"internal"},{"id":55190,"nodeType":"FunctionDefinition","src":"15187:1190:100","nodes":[],"body":{"id":55189,"nodeType":"Block","src":"15283:1094:100","nodes":[],"statements":[{"assignments":[55083],"declarations":[{"constant":false,"id":55083,"mutability":"mutable","name":"l1StandardBridgeProxy","nameLocation":"15301:21:100","nodeType":"VariableDeclaration","scope":55189,"src":"15293:29:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":55082,"name":"address","nodeType":"ElementaryTypeName","src":"15293:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"id":55087,"initialValue":{"arguments":[],"expression":{"argumentTypes":[],"expression":{"id":55084,"name":"_fi","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55076,"src":"15325:3:100","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoInput_$54041","typeString":"contract FetchChainInfoInput"}},"id":55085,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"15329:21:100","memberName":"l1StandardBridgeProxy","nodeType":"MemberAccess","referencedDeclaration":54040,"src":"15325:25:100","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":55086,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"15325:27:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"VariableDeclarationStatement","src":"15293:59:100"},{"expression":{"arguments":[{"expression":{"expression":{"id":55091,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55079,"src":"15370:3:100","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$54911","typeString":"contract FetchChainInfoOutput"}},"id":55092,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"15374:21:100","memberName":"l1StandardBridgeProxy","nodeType":"MemberAccess","referencedDeclaration":54519,"src":"15370:25:100","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":55093,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"15396:8:100","memberName":"selector","nodeType":"MemberAccess","src":"15370:34:100","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},{"id":55094,"name":"l1StandardBridgeProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55083,"src":"15406:21:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_bytes4","typeString":"bytes4"},{"typeIdentifier":"t_address","typeString":"address"}],"expression":{"id":55088,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55079,"src":"15362:3:100","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$54911","typeString":"contract FetchChainInfoOutput"}},"id":55090,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"15366:3:100","memberName":"set","nodeType":"MemberAccess","referencedDeclaration":54384,"src":"15362:7:100","typeDescriptions":{"typeIdentifier":"t_function_external_nonpayable$_t_bytes4_$_t_address_$returns$__$","typeString":"function (bytes4,address) external"}},"id":55095,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"15362:66:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":55096,"nodeType":"ExpressionStatement","src":"15362:66:100"},{"assignments":[55098],"declarations":[{"constant":false,"id":55098,"mutability":"mutable","name":"l1CrossDomainMessengerProxy","nameLocation":"15447:27:100","nodeType":"VariableDeclaration","scope":55189,"src":"15439:35:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":55097,"name":"address","nodeType":"ElementaryTypeName","src":"15439:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"id":55104,"initialValue":{"arguments":[],"expression":{"argumentTypes":[],"expression":{"arguments":[{"id":55100,"name":"l1StandardBridgeProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55083,"src":"15486:21:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_address","typeString":"address"}],"id":55099,"name":"IFetcher","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":53958,"src":"15477:8:100","typeDescriptions":{"typeIdentifier":"t_type$_t_contract$_IFetcher_$53958_$","typeString":"type(contract IFetcher)"}},"id":55101,"isConstant":false,"isLValue":false,"isPure":false,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"15477:31:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_contract$_IFetcher_$53958","typeString":"contract IFetcher"}},"id":55102,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"15509:9:100","memberName":"messenger","nodeType":"MemberAccess","referencedDeclaration":53853,"src":"15477:41:100","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":55103,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"15477:43:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"VariableDeclarationStatement","src":"15439:81:100"},{"expression":{"arguments":[{"expression":{"expression":{"id":55108,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55079,"src":"15538:3:100","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$54911","typeString":"contract FetchChainInfoOutput"}},"id":55109,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"15542:27:100","memberName":"l1CrossDomainMessengerProxy","nodeType":"MemberAccess","referencedDeclaration":54483,"src":"15538:31:100","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":55110,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"15570:8:100","memberName":"selector","nodeType":"MemberAccess","src":"15538:40:100","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},{"id":55111,"name":"l1CrossDomainMessengerProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55098,"src":"15580:27:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_bytes4","typeString":"bytes4"},{"typeIdentifier":"t_address","typeString":"address"}],"expression":{"id":55105,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55079,"src":"15530:3:100","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$54911","typeString":"contract FetchChainInfoOutput"}},"id":55107,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"15534:3:100","memberName":"set","nodeType":"MemberAccess","referencedDeclaration":54384,"src":"15530:7:100","typeDescriptions":{"typeIdentifier":"t_function_external_nonpayable$_t_bytes4_$_t_address_$returns$__$","typeString":"function (bytes4,address) external"}},"id":55112,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"15530:78:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":55113,"nodeType":"ExpressionStatement","src":"15530:78:100"},{"assignments":[55115],"declarations":[{"constant":false,"id":55115,"mutability":"mutable","name":"addressManagerImpl","nameLocation":"15627:18:100","nodeType":"VariableDeclaration","scope":55189,"src":"15619:26:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":55114,"name":"address","nodeType":"ElementaryTypeName","src":"15619:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"id":55119,"initialValue":{"arguments":[{"id":55117,"name":"l1CrossDomainMessengerProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55098,"src":"15667:27:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_address","typeString":"address"}],"id":55116,"name":"_getAddressManager","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55690,"src":"15648:18:100","typeDescriptions":{"typeIdentifier":"t_function_internal_view$_t_address_$returns$_t_address_$","typeString":"function (address) view returns (address)"}},"id":55118,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"15648:47:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"VariableDeclarationStatement","src":"15619:76:100"},{"expression":{"arguments":[{"expression":{"expression":{"id":55123,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55079,"src":"15713:3:100","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$54911","typeString":"contract FetchChainInfoOutput"}},"id":55124,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"15717:18:100","memberName":"addressManagerImpl","nodeType":"MemberAccess","referencedDeclaration":54457,"src":"15713:22:100","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":55125,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"15736:8:100","memberName":"selector","nodeType":"MemberAccess","src":"15713:31:100","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},{"id":55126,"name":"addressManagerImpl","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55115,"src":"15746:18:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_bytes4","typeString":"bytes4"},{"typeIdentifier":"t_address","typeString":"address"}],"expression":{"id":55120,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55079,"src":"15705:3:100","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$54911","typeString":"contract FetchChainInfoOutput"}},"id":55122,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"15709:3:100","memberName":"set","nodeType":"MemberAccess","referencedDeclaration":54384,"src":"15705:7:100","typeDescriptions":{"typeIdentifier":"t_function_external_nonpayable$_t_bytes4_$_t_address_$returns$__$","typeString":"function (bytes4,address) external"}},"id":55127,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"15705:60:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":55128,"nodeType":"ExpressionStatement","src":"15705:60:100"},{"assignments":[55130],"declarations":[{"constant":false,"id":55130,"mutability":"mutable","name":"optimismPortalProxy","nameLocation":"15784:19:100","nodeType":"VariableDeclaration","scope":55189,"src":"15776:27:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":55129,"name":"address","nodeType":"ElementaryTypeName","src":"15776:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"id":55134,"initialValue":{"arguments":[{"id":55132,"name":"l1CrossDomainMessengerProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55098,"src":"15830:27:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_address","typeString":"address"}],"id":55131,"name":"_getOptimismPortalProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55652,"src":"15806:23:100","typeDescriptions":{"typeIdentifier":"t_function_internal_view$_t_address_$returns$_t_address_$","typeString":"function (address) view returns (address)"}},"id":55133,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"15806:52:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"VariableDeclarationStatement","src":"15776:82:100"},{"expression":{"arguments":[{"expression":{"expression":{"id":55138,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55079,"src":"15876:3:100","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$54911","typeString":"contract FetchChainInfoOutput"}},"id":55139,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"15880:19:100","memberName":"optimismPortalProxy","nodeType":"MemberAccess","referencedDeclaration":54573,"src":"15876:23:100","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":55140,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"15900:8:100","memberName":"selector","nodeType":"MemberAccess","src":"15876:32:100","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},{"id":55141,"name":"optimismPortalProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55130,"src":"15910:19:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_bytes4","typeString":"bytes4"},{"typeIdentifier":"t_address","typeString":"address"}],"expression":{"id":55135,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55079,"src":"15868:3:100","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$54911","typeString":"contract FetchChainInfoOutput"}},"id":55137,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"15872:3:100","memberName":"set","nodeType":"MemberAccess","referencedDeclaration":54384,"src":"15868:7:100","typeDescriptions":{"typeIdentifier":"t_function_external_nonpayable$_t_bytes4_$_t_address_$returns$__$","typeString":"function (bytes4,address) external"}},"id":55142,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"15868:62:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":55143,"nodeType":"ExpressionStatement","src":"15868:62:100"},{"assignments":[55145],"declarations":[{"constant":false,"id":55145,"mutability":"mutable","name":"opChainGuardian","nameLocation":"15949:15:100","nodeType":"VariableDeclaration","scope":55189,"src":"15941:23:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":55144,"name":"address","nodeType":"ElementaryTypeName","src":"15941:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"id":55149,"initialValue":{"arguments":[{"id":55147,"name":"optimismPortalProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55130,"src":"15980:19:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_address","typeString":"address"}],"id":55146,"name":"_getGuardian","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55594,"src":"15967:12:100","typeDescriptions":{"typeIdentifier":"t_function_internal_view$_t_address_$returns$_t_address_$","typeString":"function (address) view returns (address)"}},"id":55148,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"15967:33:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"VariableDeclarationStatement","src":"15941:59:100"},{"expression":{"arguments":[{"expression":{"expression":{"id":55153,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55079,"src":"16018:3:100","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$54911","typeString":"contract FetchChainInfoOutput"}},"id":55154,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"16022:15:100","memberName":"opChainGuardian","nodeType":"MemberAccess","referencedDeclaration":54813,"src":"16018:19:100","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":55155,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"16038:8:100","memberName":"selector","nodeType":"MemberAccess","src":"16018:28:100","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},{"id":55156,"name":"opChainGuardian","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55145,"src":"16048:15:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_bytes4","typeString":"bytes4"},{"typeIdentifier":"t_address","typeString":"address"}],"expression":{"id":55150,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55079,"src":"16010:3:100","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$54911","typeString":"contract FetchChainInfoOutput"}},"id":55152,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"16014:3:100","memberName":"set","nodeType":"MemberAccess","referencedDeclaration":54384,"src":"16010:7:100","typeDescriptions":{"typeIdentifier":"t_function_external_nonpayable$_t_bytes4_$_t_address_$returns$__$","typeString":"function (bytes4,address) external"}},"id":55157,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"16010:54:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":55158,"nodeType":"ExpressionStatement","src":"16010:54:100"},{"assignments":[55160],"declarations":[{"constant":false,"id":55160,"mutability":"mutable","name":"ethLockboxProxy","nameLocation":"16083:15:100","nodeType":"VariableDeclaration","scope":55189,"src":"16075:23:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":55159,"name":"address","nodeType":"ElementaryTypeName","src":"16075:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"id":55164,"initialValue":{"arguments":[{"id":55162,"name":"optimismPortalProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55130,"src":"16121:19:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_address","typeString":"address"}],"id":55161,"name":"_getEthLockboxProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55922,"src":"16101:19:100","typeDescriptions":{"typeIdentifier":"t_function_internal_view$_t_address_$returns$_t_address_$","typeString":"function (address) view returns (address)"}},"id":55163,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"16101:40:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"VariableDeclarationStatement","src":"16075:66:100"},{"expression":{"arguments":[{"expression":{"expression":{"id":55168,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55079,"src":"16159:3:100","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$54911","typeString":"contract FetchChainInfoOutput"}},"id":55169,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"16163:15:100","memberName":"ethLockboxProxy","nodeType":"MemberAccess","referencedDeclaration":54465,"src":"16159:19:100","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":55170,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"16179:8:100","memberName":"selector","nodeType":"MemberAccess","src":"16159:28:100","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},{"id":55171,"name":"ethLockboxProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55160,"src":"16189:15:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_bytes4","typeString":"bytes4"},{"typeIdentifier":"t_address","typeString":"address"}],"expression":{"id":55165,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55079,"src":"16151:3:100","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$54911","typeString":"contract FetchChainInfoOutput"}},"id":55167,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"16155:3:100","memberName":"set","nodeType":"MemberAccess","referencedDeclaration":54384,"src":"16151:7:100","typeDescriptions":{"typeIdentifier":"t_function_external_nonpayable$_t_bytes4_$_t_address_$returns$__$","typeString":"function (bytes4,address) external"}},"id":55172,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"16151:54:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":55173,"nodeType":"ExpressionStatement","src":"16151:54:100"},{"assignments":[55175],"declarations":[{"constant":false,"id":55175,"mutability":"mutable","name":"superchainConfigProxy","nameLocation":"16224:21:100","nodeType":"VariableDeclaration","scope":55189,"src":"16216:29:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":55174,"name":"address","nodeType":"ElementaryTypeName","src":"16216:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"id":55179,"initialValue":{"arguments":[{"id":55177,"name":"optimismPortalProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55130,"src":"16274:19:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_address","typeString":"address"}],"id":55176,"name":"_getSuperchainConfigProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55802,"src":"16248:25:100","typeDescriptions":{"typeIdentifier":"t_function_internal_view$_t_address_$returns$_t_address_$","typeString":"function (address) view returns (address)"}},"id":55178,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"16248:46:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"VariableDeclarationStatement","src":"16216:78:100"},{"expression":{"arguments":[{"expression":{"expression":{"id":55183,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55079,"src":"16312:3:100","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$54911","typeString":"contract FetchChainInfoOutput"}},"id":55184,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"16316:21:100","memberName":"superchainConfigProxy","nodeType":"MemberAccess","referencedDeclaration":54627,"src":"16312:25:100","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":55185,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"16338:8:100","memberName":"selector","nodeType":"MemberAccess","src":"16312:34:100","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},{"id":55186,"name":"superchainConfigProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55175,"src":"16348:21:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_bytes4","typeString":"bytes4"},{"typeIdentifier":"t_address","typeString":"address"}],"expression":{"id":55180,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55079,"src":"16304:3:100","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$54911","typeString":"contract FetchChainInfoOutput"}},"id":55182,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"16308:3:100","memberName":"set","nodeType":"MemberAccess","referencedDeclaration":54384,"src":"16304:7:100","typeDescriptions":{"typeIdentifier":"t_function_external_nonpayable$_t_bytes4_$_t_address_$returns$__$","typeString":"function (bytes4,address) external"}},"id":55187,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"16304:66:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":55188,"nodeType":"ExpressionStatement","src":"16304:66:100"}]},"implemented":true,"kind":"function","modifiers":[],"name":"_processMessengerAndPortal","nameLocation":"15196:26:100","parameters":{"id":55080,"nodeType":"ParameterList","parameters":[{"constant":false,"id":55076,"mutability":"mutable","name":"_fi","nameLocation":"15243:3:100","nodeType":"VariableDeclaration","scope":55190,"src":"15223:23:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoInput_$54041","typeString":"contract FetchChainInfoInput"},"typeName":{"id":55075,"nodeType":"UserDefinedTypeName","pathNode":{"id":55074,"name":"FetchChainInfoInput","nameLocations":["15223:19:100"],"nodeType":"IdentifierPath","referencedDeclaration":54041,"src":"15223:19:100"},"referencedDeclaration":54041,"src":"15223:19:100","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoInput_$54041","typeString":"contract FetchChainInfoInput"}},"visibility":"internal"},{"constant":false,"id":55079,"mutability":"mutable","name":"_fo","nameLocation":"15269:3:100","nodeType":"VariableDeclaration","scope":55190,"src":"15248:24:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$54911","typeString":"contract FetchChainInfoOutput"},"typeName":{"id":55078,"nodeType":"UserDefinedTypeName","pathNode":{"id":55077,"name":"FetchChainInfoOutput","nameLocations":["15248:20:100"],"nodeType":"IdentifierPath","referencedDeclaration":54911,"src":"15248:20:100"},"referencedDeclaration":54911,"src":"15248:20:100","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$54911","typeString":"contract FetchChainInfoOutput"}},"visibility":"internal"}],"src":"15222:51:100"},"returnParameters":{"id":55081,"nodeType":"ParameterList","parameters":[],"src":"15283:0:100"},"scope":56018,"stateMutability":"nonpayable","virtual":false,"visibility":"internal"},{"id":55565,"nodeType":"FunctionDefinition","src":"16383:4033:100","nodes":[],"body":{"id":55564,"nodeType":"Block","src":"16447:3969:100","nodes":[],"statements":[{"assignments":[55197],"declarations":[{"constant":false,"id":55197,"mutability":"mutable","name":"systemConfigProxy","nameLocation":"16465:17:100","nodeType":"VariableDeclaration","scope":55564,"src":"16457:25:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":55196,"name":"address","nodeType":"ElementaryTypeName","src":"16457:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"id":55201,"initialValue":{"arguments":[],"expression":{"argumentTypes":[],"expression":{"id":55198,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55193,"src":"16485:3:100","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$54911","typeString":"contract FetchChainInfoOutput"}},"id":55199,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"16489:17:100","memberName":"systemConfigProxy","nodeType":"MemberAccess","referencedDeclaration":54591,"src":"16485:21:100","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":55200,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"16485:23:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"VariableDeclarationStatement","src":"16457:51:100"},{"assignments":[55203],"declarations":[{"constant":false,"id":55203,"mutability":"mutable","name":"optimismPortalProxy","nameLocation":"16526:19:100","nodeType":"VariableDeclaration","scope":55564,"src":"16518:27:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":55202,"name":"address","nodeType":"ElementaryTypeName","src":"16518:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"id":55207,"initialValue":{"arguments":[],"expression":{"argumentTypes":[],"expression":{"id":55204,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55193,"src":"16548:3:100","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$54911","typeString":"contract FetchChainInfoOutput"}},"id":55205,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"16552:19:100","memberName":"optimismPortalProxy","nodeType":"MemberAccess","referencedDeclaration":54573,"src":"16548:23:100","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":55206,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"16548:25:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"VariableDeclarationStatement","src":"16518:55:100"},{"clauses":[{"block":{"id":55226,"nodeType":"Block","src":"16667:75:100","statements":[{"expression":{"arguments":[{"expression":{"expression":{"id":55220,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55193,"src":"16689:3:100","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$54911","typeString":"contract FetchChainInfoOutput"}},"id":55221,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"16693:17:100","memberName":"respectedGameType","nodeType":"MemberAccess","referencedDeclaration":54910,"src":"16689:21:100","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_userDefinedValueType$_GameType_$70720_$","typeString":"function () view external returns (GameType)"}},"id":55222,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"16711:8:100","memberName":"selector","nodeType":"MemberAccess","src":"16689:30:100","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},{"id":55223,"name":"gameType_","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55215,"src":"16721:9:100","typeDescriptions":{"typeIdentifier":"t_userDefinedValueType$_GameType_$70720","typeString":"GameType"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_bytes4","typeString":"bytes4"},{"typeIdentifier":"t_userDefinedValueType$_GameType_$70720","typeString":"GameType"}],"expression":{"id":55217,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55193,"src":"16681:3:100","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$54911","typeString":"contract FetchChainInfoOutput"}},"id":55219,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"16685:3:100","memberName":"set","nodeType":"MemberAccess","referencedDeclaration":54439,"src":"16681:7:100","typeDescriptions":{"typeIdentifier":"t_function_external_nonpayable$_t_bytes4_$_t_userDefinedValueType$_GameType_$70720_$returns$__$","typeString":"function (bytes4,GameType) external"}},"id":55224,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"16681:50:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":55225,"nodeType":"ExpressionStatement","src":"16681:50:100"}]},"errorName":"","id":55227,"nodeType":"TryCatchClause","parameters":{"id":55216,"nodeType":"ParameterList","parameters":[{"constant":false,"id":55215,"mutability":"mutable","name":"gameType_","nameLocation":"16656:9:100","nodeType":"VariableDeclaration","scope":55227,"src":"16647:18:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_userDefinedValueType$_GameType_$70720","typeString":"GameType"},"typeName":{"id":55214,"nodeType":"UserDefinedTypeName","pathNode":{"id":55213,"name":"GameType","nameLocations":["16647:8:100"],"nodeType":"IdentifierPath","referencedDeclaration":70720,"src":"16647:8:100"},"referencedDeclaration":70720,"src":"16647:8:100","typeDescriptions":{"typeIdentifier":"t_userDefinedValueType$_GameType_$70720","typeString":"GameType"}},"visibility":"internal"}],"src":"16646:20:100"},"src":"16638:104:100"},{"block":{"id":55299,"nodeType":"Block","src":"16749:744:100","statements":[{"expression":{"arguments":[{"expression":{"expression":{"id":55231,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55193,"src":"16844:3:100","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$54911","typeString":"contract FetchChainInfoOutput"}},"id":55232,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"16848:17:100","memberName":"respectedGameType","nodeType":"MemberAccess","referencedDeclaration":54910,"src":"16844:21:100","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_userDefinedValueType$_GameType_$70720_$","typeString":"function () view external returns (GameType)"}},"id":55233,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"16866:8:100","memberName":"selector","nodeType":"MemberAccess","src":"16844:30:100","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},{"arguments":[{"expression":{"arguments":[{"id":55238,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"nodeType":"ElementaryTypeNameExpression","src":"16895:6:100","typeDescriptions":{"typeIdentifier":"t_type$_t_uint32_$","typeString":"type(uint32)"},"typeName":{"id":55237,"name":"uint32","nodeType":"ElementaryTypeName","src":"16895:6:100","typeDescriptions":{}}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_type$_t_uint32_$","typeString":"type(uint32)"}],"id":55236,"name":"type","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":-27,"src":"16890:4:100","typeDescriptions":{"typeIdentifier":"t_function_metatype_pure$__$returns$__$","typeString":"function () pure"}},"id":55239,"isConstant":false,"isLValue":false,"isPure":true,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"16890:12:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_magic_meta_type_t_uint32","typeString":"type(uint32)"}},"id":55240,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"memberLocation":"16903:3:100","memberName":"max","nodeType":"MemberAccess","src":"16890:16:100","typeDescriptions":{"typeIdentifier":"t_uint32","typeString":"uint32"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_uint32","typeString":"uint32"}],"expression":{"id":55234,"name":"GameType","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":70720,"src":"16876:8:100","typeDescriptions":{"typeIdentifier":"t_type$_t_userDefinedValueType$_GameType_$70720_$","typeString":"type(GameType)"}},"id":55235,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"memberLocation":"16885:4:100","memberName":"wrap","nodeType":"MemberAccess","src":"16876:13:100","typeDescriptions":{"typeIdentifier":"t_function_wrap_pure$_t_uint32_$returns$_t_userDefinedValueType$_GameType_$70720_$","typeString":"function (uint32) pure returns (GameType)"}},"id":55241,"isConstant":false,"isLValue":false,"isPure":true,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"16876:31:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_userDefinedValueType$_GameType_$70720","typeString":"GameType"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_bytes4","typeString":"bytes4"},{"typeIdentifier":"t_userDefinedValueType$_GameType_$70720","typeString":"GameType"}],"expression":{"id":55228,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55193,"src":"16836:3:100","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$54911","typeString":"contract FetchChainInfoOutput"}},"id":55230,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"16840:3:100","memberName":"set","nodeType":"MemberAccess","referencedDeclaration":54439,"src":"16836:7:100","typeDescriptions":{"typeIdentifier":"t_function_external_nonpayable$_t_bytes4_$_t_userDefinedValueType$_GameType_$70720_$returns$__$","typeString":"function (bytes4,GameType) external"}},"id":55242,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"16836:72:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":55243,"nodeType":"ExpressionStatement","src":"16836:72:100"},{"assignments":[55245],"declarations":[{"constant":false,"id":55245,"mutability":"mutable","name":"l2OutputOracleProxy","nameLocation":"16930:19:100","nodeType":"VariableDeclaration","scope":55299,"src":"16922:27:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":55244,"name":"address","nodeType":"ElementaryTypeName","src":"16922:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"id":55246,"nodeType":"VariableDeclarationStatement","src":"16922:27:100"},{"clauses":[{"block":{"id":55259,"nodeType":"Block","src":"17036:64:100","statements":[{"expression":{"id":55257,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftHandSide":{"id":55255,"name":"l2OutputOracleProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55245,"src":"17054:19:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"Assignment","operator":"=","rightHandSide":{"id":55256,"name":"l2Oracle_","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55253,"src":"17076:9:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"src":"17054:31:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"id":55258,"nodeType":"ExpressionStatement","src":"17054:31:100"}]},"errorName":"","id":55260,"nodeType":"TryCatchClause","parameters":{"id":55254,"nodeType":"ParameterList","parameters":[{"constant":false,"id":55253,"mutability":"mutable","name":"l2Oracle_","nameLocation":"17025:9:100","nodeType":"VariableDeclaration","scope":55260,"src":"17017:17:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":55252,"name":"address","nodeType":"ElementaryTypeName","src":"17017:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"17016:19:100"},"src":"17008:92:100"},{"block":{"id":55269,"nodeType":"Block","src":"17107:96:100","statements":[{"expression":{"id":55267,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftHandSide":{"id":55261,"name":"l2OutputOracleProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55245,"src":"17125:19:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"Assignment","operator":"=","rightHandSide":{"arguments":[],"expression":{"argumentTypes":[],"expression":{"arguments":[{"id":55263,"name":"optimismPortalProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55203,"src":"17156:19:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_address","typeString":"address"}],"id":55262,"name":"IFetcher","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":53958,"src":"17147:8:100","typeDescriptions":{"typeIdentifier":"t_type$_t_contract$_IFetcher_$53958_$","typeString":"type(contract IFetcher)"}},"id":55264,"isConstant":false,"isLValue":false,"isPure":false,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"17147:29:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_contract$_IFetcher_$53958","typeString":"contract IFetcher"}},"id":55265,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"17177:9:100","memberName":"L2_ORACLE","nodeType":"MemberAccess","referencedDeclaration":53902,"src":"17147:39:100","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":55266,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"17147:41:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"src":"17125:63:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"id":55268,"nodeType":"ExpressionStatement","src":"17125:63:100"}]},"errorName":"","id":55270,"nodeType":"TryCatchClause","src":"17101:102:100"}],"externalCall":{"arguments":[],"expression":{"argumentTypes":[],"expression":{"arguments":[{"id":55248,"name":"optimismPortalProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55203,"src":"16976:19:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_address","typeString":"address"}],"id":55247,"name":"IFetcher","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":53958,"src":"16967:8:100","typeDescriptions":{"typeIdentifier":"t_type$_t_contract$_IFetcher_$53958_$","typeString":"type(contract IFetcher)"}},"id":55249,"isConstant":false,"isLValue":false,"isPure":false,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"16967:29:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_contract$_IFetcher_$53958","typeString":"contract IFetcher"}},"id":55250,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"16997:8:100","memberName":"l2Oracle","nodeType":"MemberAccess","referencedDeclaration":53907,"src":"16967:38:100","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":55251,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"16967:40:100","tryCall":true,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"id":55271,"nodeType":"TryStatement","src":"16963:240:100"},{"expression":{"arguments":[{"expression":{"expression":{"id":55275,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55193,"src":"17224:3:100","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$54911","typeString":"contract FetchChainInfoOutput"}},"id":55276,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"17228:19:100","memberName":"l2OutputOracleProxy","nodeType":"MemberAccess","referencedDeclaration":54537,"src":"17224:23:100","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":55277,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"17248:8:100","memberName":"selector","nodeType":"MemberAccess","src":"17224:32:100","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},{"id":55278,"name":"l2OutputOracleProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55245,"src":"17258:19:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_bytes4","typeString":"bytes4"},{"typeIdentifier":"t_address","typeString":"address"}],"expression":{"id":55272,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55193,"src":"17216:3:100","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$54911","typeString":"contract FetchChainInfoOutput"}},"id":55274,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"17220:3:100","memberName":"set","nodeType":"MemberAccess","referencedDeclaration":54384,"src":"17216:7:100","typeDescriptions":{"typeIdentifier":"t_function_external_nonpayable$_t_bytes4_$_t_address_$returns$__$","typeString":"function (bytes4,address) external"}},"id":55279,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"17216:62:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":55280,"nodeType":"ExpressionStatement","src":"17216:62:100"},{"assignments":[55282],"declarations":[{"constant":false,"id":55282,"mutability":"mutable","name":"proposer","nameLocation":"17301:8:100","nodeType":"VariableDeclaration","scope":55299,"src":"17293:16:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":55281,"name":"address","nodeType":"ElementaryTypeName","src":"17293:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"id":55288,"initialValue":{"arguments":[],"expression":{"argumentTypes":[],"expression":{"arguments":[{"id":55284,"name":"l2OutputOracleProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55245,"src":"17321:19:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_address","typeString":"address"}],"id":55283,"name":"IFetcher","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":53958,"src":"17312:8:100","typeDescriptions":{"typeIdentifier":"t_type$_t_contract$_IFetcher_$53958_$","typeString":"type(contract IFetcher)"}},"id":55285,"isConstant":false,"isLValue":false,"isPure":false,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"17312:29:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_contract$_IFetcher_$53958","typeString":"contract IFetcher"}},"id":55286,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"17342:8:100","memberName":"PROPOSER","nodeType":"MemberAccess","referencedDeclaration":53932,"src":"17312:38:100","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":55287,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"17312:40:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"VariableDeclarationStatement","src":"17293:59:100"},{"expression":{"arguments":[{"expression":{"expression":{"id":55292,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55193,"src":"17374:3:100","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$54911","typeString":"contract FetchChainInfoOutput"}},"id":55293,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"17378:8:100","memberName":"proposer","nodeType":"MemberAccess","referencedDeclaration":54849,"src":"17374:12:100","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":55294,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"17387:8:100","memberName":"selector","nodeType":"MemberAccess","src":"17374:21:100","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},{"id":55295,"name":"proposer","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55282,"src":"17397:8:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_bytes4","typeString":"bytes4"},{"typeIdentifier":"t_address","typeString":"address"}],"expression":{"id":55289,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55193,"src":"17366:3:100","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$54911","typeString":"contract FetchChainInfoOutput"}},"id":55291,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"17370:3:100","memberName":"set","nodeType":"MemberAccess","referencedDeclaration":54384,"src":"17366:7:100","typeDescriptions":{"typeIdentifier":"t_function_external_nonpayable$_t_bytes4_$_t_address_$returns$__$","typeString":"function (bytes4,address) external"}},"id":55296,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"17366:40:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":55297,"nodeType":"ExpressionStatement","src":"17366:40:100"},{"functionReturnParameters":55195,"id":55298,"nodeType":"Return","src":"17476:7:100"}]},"errorName":"","id":55300,"nodeType":"TryCatchClause","src":"16743:750:100"}],"externalCall":{"arguments":[],"expression":{"argumentTypes":[],"expression":{"arguments":[{"id":55209,"name":"optimismPortalProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55203,"src":"16597:19:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_address","typeString":"address"}],"id":55208,"name":"IFetcher","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":53958,"src":"16588:8:100","typeDescriptions":{"typeIdentifier":"t_type$_t_contract$_IFetcher_$53958_$","typeString":"type(contract IFetcher)"}},"id":55210,"isConstant":false,"isLValue":false,"isPure":false,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"16588:29:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_contract$_IFetcher_$53958","typeString":"contract IFetcher"}},"id":55211,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"16618:17:100","memberName":"respectedGameType","nodeType":"MemberAccess","referencedDeclaration":53892,"src":"16588:47:100","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_userDefinedValueType$_GameType_$70720_$","typeString":"function () view external returns (GameType)"}},"id":55212,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"16588:49:100","tryCall":true,"typeDescriptions":{"typeIdentifier":"t_userDefinedValueType$_GameType_$70720","typeString":"GameType"}},"id":55301,"nodeType":"TryStatement","src":"16584:909:100"},{"assignments":[55303],"declarations":[{"constant":false,"id":55303,"mutability":"mutable","name":"disputeGameFactoryProxy","nameLocation":"17511:23:100","nodeType":"VariableDeclaration","scope":55564,"src":"17503:31:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":55302,"name":"address","nodeType":"ElementaryTypeName","src":"17503:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"id":55307,"initialValue":{"arguments":[{"id":55305,"name":"systemConfigProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55197,"src":"17565:17:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_address","typeString":"address"}],"id":55304,"name":"_getDisputeGameFactoryProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55774,"src":"17537:27:100","typeDescriptions":{"typeIdentifier":"t_function_internal_view$_t_address_$returns$_t_address_$","typeString":"function (address) view returns (address)"}},"id":55306,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"17537:46:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"VariableDeclarationStatement","src":"17503:80:100"},{"condition":{"commonType":{"typeIdentifier":"t_address","typeString":"address"},"id":55313,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftExpression":{"id":55308,"name":"disputeGameFactoryProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55303,"src":"17597:23:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"BinaryOperation","operator":"!=","rightExpression":{"arguments":[{"hexValue":"30","id":55311,"isConstant":false,"isLValue":false,"isPure":true,"kind":"number","lValueRequested":false,"nodeType":"Literal","src":"17632:1:100","typeDescriptions":{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"},"value":"0"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"}],"id":55310,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"nodeType":"ElementaryTypeNameExpression","src":"17624:7:100","typeDescriptions":{"typeIdentifier":"t_type$_t_address_$","typeString":"type(address)"},"typeName":{"id":55309,"name":"address","nodeType":"ElementaryTypeName","src":"17624:7:100","typeDescriptions":{}}},"id":55312,"isConstant":false,"isLValue":false,"isPure":true,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"17624:10:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"src":"17597:37:100","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},"falseBody":{"id":55562,"nodeType":"Block","src":"20027:383:100","statements":[{"assignments":[55529],"declarations":[{"constant":false,"id":55529,"mutability":"mutable","name":"l2OutputOracleProxy","nameLocation":"20133:19:100","nodeType":"VariableDeclaration","scope":55562,"src":"20125:27:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":55528,"name":"address","nodeType":"ElementaryTypeName","src":"20125:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"id":55535,"initialValue":{"arguments":[],"expression":{"argumentTypes":[],"expression":{"arguments":[{"id":55531,"name":"optimismPortalProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55203,"src":"20164:19:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_address","typeString":"address"}],"id":55530,"name":"IFetcher","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":53958,"src":"20155:8:100","typeDescriptions":{"typeIdentifier":"t_type$_t_contract$_IFetcher_$53958_$","typeString":"type(contract IFetcher)"}},"id":55532,"isConstant":false,"isLValue":false,"isPure":false,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"20155:29:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_contract$_IFetcher_$53958","typeString":"contract IFetcher"}},"id":55533,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"20185:9:100","memberName":"L2_ORACLE","nodeType":"MemberAccess","referencedDeclaration":53902,"src":"20155:39:100","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":55534,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"20155:41:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"VariableDeclarationStatement","src":"20125:71:100"},{"expression":{"arguments":[{"expression":{"expression":{"id":55539,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55193,"src":"20218:3:100","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$54911","typeString":"contract FetchChainInfoOutput"}},"id":55540,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"20222:19:100","memberName":"l2OutputOracleProxy","nodeType":"MemberAccess","referencedDeclaration":54537,"src":"20218:23:100","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":55541,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"20242:8:100","memberName":"selector","nodeType":"MemberAccess","src":"20218:32:100","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},{"id":55542,"name":"l2OutputOracleProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55529,"src":"20252:19:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_bytes4","typeString":"bytes4"},{"typeIdentifier":"t_address","typeString":"address"}],"expression":{"id":55536,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55193,"src":"20210:3:100","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$54911","typeString":"contract FetchChainInfoOutput"}},"id":55538,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"20214:3:100","memberName":"set","nodeType":"MemberAccess","referencedDeclaration":54384,"src":"20210:7:100","typeDescriptions":{"typeIdentifier":"t_function_external_nonpayable$_t_bytes4_$_t_address_$returns$__$","typeString":"function (bytes4,address) external"}},"id":55543,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"20210:62:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":55544,"nodeType":"ExpressionStatement","src":"20210:62:100"},{"assignments":[55546],"declarations":[{"constant":false,"id":55546,"mutability":"mutable","name":"proposer","nameLocation":"20294:8:100","nodeType":"VariableDeclaration","scope":55562,"src":"20286:16:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":55545,"name":"address","nodeType":"ElementaryTypeName","src":"20286:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"id":55552,"initialValue":{"arguments":[],"expression":{"argumentTypes":[],"expression":{"arguments":[{"id":55548,"name":"l2OutputOracleProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55529,"src":"20314:19:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_address","typeString":"address"}],"id":55547,"name":"IFetcher","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":53958,"src":"20305:8:100","typeDescriptions":{"typeIdentifier":"t_type$_t_contract$_IFetcher_$53958_$","typeString":"type(contract IFetcher)"}},"id":55549,"isConstant":false,"isLValue":false,"isPure":false,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"20305:29:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_contract$_IFetcher_$53958","typeString":"contract IFetcher"}},"id":55550,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"20335:8:100","memberName":"PROPOSER","nodeType":"MemberAccess","referencedDeclaration":53932,"src":"20305:38:100","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":55551,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"20305:40:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"VariableDeclarationStatement","src":"20286:59:100"},{"expression":{"arguments":[{"expression":{"expression":{"id":55556,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55193,"src":"20367:3:100","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$54911","typeString":"contract FetchChainInfoOutput"}},"id":55557,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"20371:8:100","memberName":"proposer","nodeType":"MemberAccess","referencedDeclaration":54849,"src":"20367:12:100","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":55558,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"20380:8:100","memberName":"selector","nodeType":"MemberAccess","src":"20367:21:100","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},{"id":55559,"name":"proposer","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55546,"src":"20390:8:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_bytes4","typeString":"bytes4"},{"typeIdentifier":"t_address","typeString":"address"}],"expression":{"id":55553,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55193,"src":"20359:3:100","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$54911","typeString":"contract FetchChainInfoOutput"}},"id":55555,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"20363:3:100","memberName":"set","nodeType":"MemberAccess","referencedDeclaration":54384,"src":"20359:7:100","typeDescriptions":{"typeIdentifier":"t_function_external_nonpayable$_t_bytes4_$_t_address_$returns$__$","typeString":"function (bytes4,address) external"}},"id":55560,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"20359:40:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":55561,"nodeType":"ExpressionStatement","src":"20359:40:100"}]},"id":55563,"nodeType":"IfStatement","src":"17593:2817:100","trueBody":{"id":55527,"nodeType":"Block","src":"17636:2385:100","statements":[{"expression":{"arguments":[{"expression":{"expression":{"id":55317,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55193,"src":"17658:3:100","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$54911","typeString":"contract FetchChainInfoOutput"}},"id":55318,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"17662:23:100","memberName":"disputeGameFactoryProxy","nodeType":"MemberAccess","referencedDeclaration":54669,"src":"17658:27:100","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":55319,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"17686:8:100","memberName":"selector","nodeType":"MemberAccess","src":"17658:36:100","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},{"id":55320,"name":"disputeGameFactoryProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55303,"src":"17696:23:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_bytes4","typeString":"bytes4"},{"typeIdentifier":"t_address","typeString":"address"}],"expression":{"id":55314,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55193,"src":"17650:3:100","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$54911","typeString":"contract FetchChainInfoOutput"}},"id":55316,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"17654:3:100","memberName":"set","nodeType":"MemberAccess","referencedDeclaration":54384,"src":"17650:7:100","typeDescriptions":{"typeIdentifier":"t_function_external_nonpayable$_t_bytes4_$_t_address_$returns$__$","typeString":"function (bytes4,address) external"}},"id":55321,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"17650:70:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":55322,"nodeType":"ExpressionStatement","src":"17650:70:100"},{"assignments":[55324],"declarations":[{"constant":false,"id":55324,"mutability":"mutable","name":"permissionedDisputeGameImpl","nameLocation":"17743:27:100","nodeType":"VariableDeclaration","scope":55527,"src":"17735:35:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":55323,"name":"address","nodeType":"ElementaryTypeName","src":"17735:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"id":55328,"initialValue":{"arguments":[{"id":55326,"name":"disputeGameFactoryProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55303,"src":"17801:23:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_address","typeString":"address"}],"id":55325,"name":"_getPermissionedDisputeGame","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55894,"src":"17773:27:100","typeDescriptions":{"typeIdentifier":"t_function_internal_view$_t_address_$returns$_t_address_$","typeString":"function (address) view returns (address)"}},"id":55327,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"17773:52:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"VariableDeclarationStatement","src":"17735:90:100"},{"condition":{"commonType":{"typeIdentifier":"t_address","typeString":"address"},"id":55334,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftExpression":{"id":55329,"name":"permissionedDisputeGameImpl","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55324,"src":"17843:27:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"BinaryOperation","operator":"!=","rightExpression":{"arguments":[{"hexValue":"30","id":55332,"isConstant":false,"isLValue":false,"isPure":true,"kind":"number","lValueRequested":false,"nodeType":"Literal","src":"17882:1:100","typeDescriptions":{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"},"value":"0"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"}],"id":55331,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"nodeType":"ElementaryTypeNameExpression","src":"17874:7:100","typeDescriptions":{"typeIdentifier":"t_type$_t_address_$","typeString":"type(address)"},"typeName":{"id":55330,"name":"address","nodeType":"ElementaryTypeName","src":"17874:7:100","typeDescriptions":{}}},"id":55333,"isConstant":false,"isLValue":false,"isPure":true,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"17874:10:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"src":"17843:41:100","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},"id":55454,"nodeType":"IfStatement","src":"17839:1278:100","trueBody":{"id":55453,"nodeType":"Block","src":"17886:1231:100","statements":[{"expression":{"arguments":[{"expression":{"expression":{"id":55338,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55193,"src":"17967:3:100","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$54911","typeString":"contract FetchChainInfoOutput"}},"id":55339,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"17971:12:100","memberName":"permissioned","nodeType":"MemberAccess","referencedDeclaration":54893,"src":"17967:16:100","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_bool_$","typeString":"function () view external returns (bool)"}},"id":55340,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"17984:8:100","memberName":"selector","nodeType":"MemberAccess","src":"17967:25:100","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},{"hexValue":"74727565","id":55341,"isConstant":false,"isLValue":false,"isPure":true,"kind":"bool","lValueRequested":false,"nodeType":"Literal","src":"17994:4:100","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"},"value":"true"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_bytes4","typeString":"bytes4"},{"typeIdentifier":"t_bool","typeString":"bool"}],"expression":{"id":55335,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55193,"src":"17959:3:100","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$54911","typeString":"contract FetchChainInfoOutput"}},"id":55337,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"17963:3:100","memberName":"set","nodeType":"MemberAccess","referencedDeclaration":54416,"src":"17959:7:100","typeDescriptions":{"typeIdentifier":"t_function_external_nonpayable$_t_bytes4_$_t_bool_$returns$__$","typeString":"function (bytes4,bool) external"}},"id":55342,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"17959:40:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":55343,"nodeType":"ExpressionStatement","src":"17959:40:100"},{"expression":{"arguments":[{"expression":{"expression":{"id":55347,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55193,"src":"18025:3:100","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$54911","typeString":"contract FetchChainInfoOutput"}},"id":55348,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"18029:27:100","memberName":"permissionedDisputeGameImpl","nodeType":"MemberAccess","referencedDeclaration":54741,"src":"18025:31:100","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":55349,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"18057:8:100","memberName":"selector","nodeType":"MemberAccess","src":"18025:40:100","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},{"id":55350,"name":"permissionedDisputeGameImpl","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55324,"src":"18067:27:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_bytes4","typeString":"bytes4"},{"typeIdentifier":"t_address","typeString":"address"}],"expression":{"id":55344,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55193,"src":"18017:3:100","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$54911","typeString":"contract FetchChainInfoOutput"}},"id":55346,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"18021:3:100","memberName":"set","nodeType":"MemberAccess","referencedDeclaration":54384,"src":"18017:7:100","typeDescriptions":{"typeIdentifier":"t_function_external_nonpayable$_t_bytes4_$_t_address_$returns$__$","typeString":"function (bytes4,address) external"}},"id":55351,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"18017:78:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":55352,"nodeType":"ExpressionStatement","src":"18017:78:100"},{"assignments":[55354],"declarations":[{"constant":false,"id":55354,"mutability":"mutable","name":"challenger","nameLocation":"18122:10:100","nodeType":"VariableDeclaration","scope":55453,"src":"18114:18:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":55353,"name":"address","nodeType":"ElementaryTypeName","src":"18114:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"id":55360,"initialValue":{"arguments":[],"expression":{"argumentTypes":[],"expression":{"arguments":[{"id":55356,"name":"permissionedDisputeGameImpl","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55324,"src":"18144:27:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_address","typeString":"address"}],"id":55355,"name":"IFetcher","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":53958,"src":"18135:8:100","typeDescriptions":{"typeIdentifier":"t_type$_t_contract$_IFetcher_$53958_$","typeString":"type(contract IFetcher)"}},"id":55357,"isConstant":false,"isLValue":false,"isPure":false,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"18135:37:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_contract$_IFetcher_$53958","typeString":"contract IFetcher"}},"id":55358,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"18173:10:100","memberName":"challenger","nodeType":"MemberAccess","referencedDeclaration":53922,"src":"18135:48:100","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":55359,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"18135:50:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"VariableDeclarationStatement","src":"18114:71:100"},{"expression":{"arguments":[{"expression":{"expression":{"id":55364,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55193,"src":"18211:3:100","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$54911","typeString":"contract FetchChainInfoOutput"}},"id":55365,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"18215:10:100","memberName":"challenger","nodeType":"MemberAccess","referencedDeclaration":54831,"src":"18211:14:100","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":55366,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"18226:8:100","memberName":"selector","nodeType":"MemberAccess","src":"18211:23:100","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},{"id":55367,"name":"challenger","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55354,"src":"18236:10:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_bytes4","typeString":"bytes4"},{"typeIdentifier":"t_address","typeString":"address"}],"expression":{"id":55361,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55193,"src":"18203:3:100","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$54911","typeString":"contract FetchChainInfoOutput"}},"id":55363,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"18207:3:100","memberName":"set","nodeType":"MemberAccess","referencedDeclaration":54384,"src":"18203:7:100","typeDescriptions":{"typeIdentifier":"t_function_external_nonpayable$_t_bytes4_$_t_address_$returns$__$","typeString":"function (bytes4,address) external"}},"id":55368,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"18203:44:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":55369,"nodeType":"ExpressionStatement","src":"18203:44:100"},{"assignments":[55371],"declarations":[{"constant":false,"id":55371,"mutability":"mutable","name":"anchorStateRegistryProxy","nameLocation":"18274:24:100","nodeType":"VariableDeclaration","scope":55453,"src":"18266:32:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":55370,"name":"address","nodeType":"ElementaryTypeName","src":"18266:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"id":55377,"initialValue":{"arguments":[],"expression":{"argumentTypes":[],"expression":{"arguments":[{"id":55373,"name":"permissionedDisputeGameImpl","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55324,"src":"18310:27:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_address","typeString":"address"}],"id":55372,"name":"IFetcher","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":53958,"src":"18301:8:100","typeDescriptions":{"typeIdentifier":"t_type$_t_contract$_IFetcher_$53958_$","typeString":"type(contract IFetcher)"}},"id":55374,"isConstant":false,"isLValue":false,"isPure":false,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"18301:37:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_contract$_IFetcher_$53958","typeString":"contract IFetcher"}},"id":55375,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"18339:19:100","memberName":"anchorStateRegistry","nodeType":"MemberAccess","referencedDeclaration":53897,"src":"18301:57:100","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":55376,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"18301:59:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"VariableDeclarationStatement","src":"18266:94:100"},{"expression":{"arguments":[{"expression":{"expression":{"id":55381,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55193,"src":"18386:3:100","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$54911","typeString":"contract FetchChainInfoOutput"}},"id":55382,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"18390:24:100","memberName":"anchorStateRegistryProxy","nodeType":"MemberAccess","referencedDeclaration":54645,"src":"18386:28:100","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":55383,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"18415:8:100","memberName":"selector","nodeType":"MemberAccess","src":"18386:37:100","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},{"id":55384,"name":"anchorStateRegistryProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55371,"src":"18425:24:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_bytes4","typeString":"bytes4"},{"typeIdentifier":"t_address","typeString":"address"}],"expression":{"id":55378,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55193,"src":"18378:3:100","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$54911","typeString":"contract FetchChainInfoOutput"}},"id":55380,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"18382:3:100","memberName":"set","nodeType":"MemberAccess","referencedDeclaration":54384,"src":"18378:7:100","typeDescriptions":{"typeIdentifier":"t_function_external_nonpayable$_t_bytes4_$_t_address_$returns$__$","typeString":"function (bytes4,address) external"}},"id":55385,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"18378:72:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":55386,"nodeType":"ExpressionStatement","src":"18378:72:100"},{"assignments":[55388],"declarations":[{"constant":false,"id":55388,"mutability":"mutable","name":"proposer","nameLocation":"18477:8:100","nodeType":"VariableDeclaration","scope":55453,"src":"18469:16:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":55387,"name":"address","nodeType":"ElementaryTypeName","src":"18469:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"id":55394,"initialValue":{"arguments":[],"expression":{"argumentTypes":[],"expression":{"arguments":[{"id":55390,"name":"permissionedDisputeGameImpl","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55324,"src":"18497:27:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_address","typeString":"address"}],"id":55389,"name":"IFetcher","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":53958,"src":"18488:8:100","typeDescriptions":{"typeIdentifier":"t_type$_t_contract$_IFetcher_$53958_$","typeString":"type(contract IFetcher)"}},"id":55391,"isConstant":false,"isLValue":false,"isPure":false,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"18488:37:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_contract$_IFetcher_$53958","typeString":"contract IFetcher"}},"id":55392,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"18526:8:100","memberName":"proposer","nodeType":"MemberAccess","referencedDeclaration":53927,"src":"18488:46:100","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":55393,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"18488:48:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"VariableDeclarationStatement","src":"18469:67:100"},{"expression":{"arguments":[{"expression":{"expression":{"id":55398,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55193,"src":"18562:3:100","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$54911","typeString":"contract FetchChainInfoOutput"}},"id":55399,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"18566:8:100","memberName":"proposer","nodeType":"MemberAccess","referencedDeclaration":54849,"src":"18562:12:100","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":55400,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"18575:8:100","memberName":"selector","nodeType":"MemberAccess","src":"18562:21:100","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},{"id":55401,"name":"proposer","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55388,"src":"18585:8:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_bytes4","typeString":"bytes4"},{"typeIdentifier":"t_address","typeString":"address"}],"expression":{"id":55395,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55193,"src":"18554:3:100","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$54911","typeString":"contract FetchChainInfoOutput"}},"id":55397,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"18558:3:100","memberName":"set","nodeType":"MemberAccess","referencedDeclaration":54384,"src":"18554:7:100","typeDescriptions":{"typeIdentifier":"t_function_external_nonpayable$_t_bytes4_$_t_address_$returns$__$","typeString":"function (bytes4,address) external"}},"id":55402,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"18554:40:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":55403,"nodeType":"ExpressionStatement","src":"18554:40:100"},{"assignments":[55405],"declarations":[{"constant":false,"id":55405,"mutability":"mutable","name":"delayedWethPermissionedGameProxy","nameLocation":"18621:32:100","nodeType":"VariableDeclaration","scope":55453,"src":"18613:40:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":55404,"name":"address","nodeType":"ElementaryTypeName","src":"18613:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"id":55409,"initialValue":{"arguments":[{"id":55407,"name":"permissionedDisputeGameImpl","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55324,"src":"18677:27:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_address","typeString":"address"}],"id":55406,"name":"_getDelayedWETHProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55967,"src":"18656:20:100","typeDescriptions":{"typeIdentifier":"t_function_internal_view$_t_address_$returns$_t_address_$","typeString":"function (address) view returns (address)"}},"id":55408,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"18656:49:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"VariableDeclarationStatement","src":"18613:92:100"},{"expression":{"arguments":[{"expression":{"expression":{"id":55413,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55193,"src":"18731:3:100","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$54911","typeString":"contract FetchChainInfoOutput"}},"id":55414,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"18735:32:100","memberName":"delayedWethPermissionedGameProxy","nodeType":"MemberAccess","referencedDeclaration":54653,"src":"18731:36:100","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":55415,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"18768:8:100","memberName":"selector","nodeType":"MemberAccess","src":"18731:45:100","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},{"id":55416,"name":"delayedWethPermissionedGameProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55405,"src":"18778:32:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_bytes4","typeString":"bytes4"},{"typeIdentifier":"t_address","typeString":"address"}],"expression":{"id":55410,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55193,"src":"18723:3:100","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$54911","typeString":"contract FetchChainInfoOutput"}},"id":55412,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"18727:3:100","memberName":"set","nodeType":"MemberAccess","referencedDeclaration":54384,"src":"18723:7:100","typeDescriptions":{"typeIdentifier":"t_function_external_nonpayable$_t_bytes4_$_t_address_$returns$__$","typeString":"function (bytes4,address) external"}},"id":55417,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"18723:88:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":55418,"nodeType":"ExpressionStatement","src":"18723:88:100"},{"assignments":[55420],"declarations":[{"constant":false,"id":55420,"mutability":"mutable","name":"mipsImpl","nameLocation":"18838:8:100","nodeType":"VariableDeclaration","scope":55453,"src":"18830:16:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":55419,"name":"address","nodeType":"ElementaryTypeName","src":"18830:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"id":55426,"initialValue":{"arguments":[],"expression":{"argumentTypes":[],"expression":{"arguments":[{"id":55422,"name":"permissionedDisputeGameImpl","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55324,"src":"18858:27:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_address","typeString":"address"}],"id":55421,"name":"IFetcher","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":53958,"src":"18849:8:100","typeDescriptions":{"typeIdentifier":"t_type$_t_contract$_IFetcher_$53958_$","typeString":"type(contract IFetcher)"}},"id":55423,"isConstant":false,"isLValue":false,"isPure":false,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"18849:37:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_contract$_IFetcher_$53958","typeString":"contract IFetcher"}},"id":55424,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"18887:2:100","memberName":"vm","nodeType":"MemberAccess","referencedDeclaration":53912,"src":"18849:40:100","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":55425,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"18849:42:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"VariableDeclarationStatement","src":"18830:61:100"},{"expression":{"arguments":[{"expression":{"expression":{"id":55430,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55193,"src":"18917:3:100","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$54911","typeString":"contract FetchChainInfoOutput"}},"id":55431,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"18921:8:100","memberName":"mipsImpl","nodeType":"MemberAccess","referencedDeclaration":54723,"src":"18917:12:100","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":55432,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"18930:8:100","memberName":"selector","nodeType":"MemberAccess","src":"18917:21:100","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},{"id":55433,"name":"mipsImpl","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55420,"src":"18940:8:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_bytes4","typeString":"bytes4"},{"typeIdentifier":"t_address","typeString":"address"}],"expression":{"id":55427,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55193,"src":"18909:3:100","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$54911","typeString":"contract FetchChainInfoOutput"}},"id":55429,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"18913:3:100","memberName":"set","nodeType":"MemberAccess","referencedDeclaration":54384,"src":"18909:7:100","typeDescriptions":{"typeIdentifier":"t_function_external_nonpayable$_t_bytes4_$_t_address_$returns$__$","typeString":"function (bytes4,address) external"}},"id":55434,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"18909:40:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":55435,"nodeType":"ExpressionStatement","src":"18909:40:100"},{"assignments":[55437],"declarations":[{"constant":false,"id":55437,"mutability":"mutable","name":"preimageOracleImpl","nameLocation":"18976:18:100","nodeType":"VariableDeclaration","scope":55453,"src":"18968:26:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":55436,"name":"address","nodeType":"ElementaryTypeName","src":"18968:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"id":55443,"initialValue":{"arguments":[],"expression":{"argumentTypes":[],"expression":{"arguments":[{"id":55439,"name":"mipsImpl","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55420,"src":"19006:8:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_address","typeString":"address"}],"id":55438,"name":"IFetcher","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":53958,"src":"18997:8:100","typeDescriptions":{"typeIdentifier":"t_type$_t_contract$_IFetcher_$53958_$","typeString":"type(contract IFetcher)"}},"id":55440,"isConstant":false,"isLValue":false,"isPure":false,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"18997:18:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_contract$_IFetcher_$53958","typeString":"contract IFetcher"}},"id":55441,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"19016:6:100","memberName":"oracle","nodeType":"MemberAccess","referencedDeclaration":53917,"src":"18997:25:100","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":55442,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"18997:27:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"VariableDeclarationStatement","src":"18968:56:100"},{"expression":{"arguments":[{"expression":{"expression":{"id":55447,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55193,"src":"19050:3:100","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$54911","typeString":"contract FetchChainInfoOutput"}},"id":55448,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"19054:18:100","memberName":"preimageOracleImpl","nodeType":"MemberAccess","referencedDeclaration":54759,"src":"19050:22:100","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":55449,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"19073:8:100","memberName":"selector","nodeType":"MemberAccess","src":"19050:31:100","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},{"id":55450,"name":"preimageOracleImpl","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55437,"src":"19083:18:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_bytes4","typeString":"bytes4"},{"typeIdentifier":"t_address","typeString":"address"}],"expression":{"id":55444,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55193,"src":"19042:3:100","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$54911","typeString":"contract FetchChainInfoOutput"}},"id":55446,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"19046:3:100","memberName":"set","nodeType":"MemberAccess","referencedDeclaration":54384,"src":"19042:7:100","typeDescriptions":{"typeIdentifier":"t_function_external_nonpayable$_t_bytes4_$_t_address_$returns$__$","typeString":"function (bytes4,address) external"}},"id":55451,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"19042:60:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":55452,"nodeType":"ExpressionStatement","src":"19042:60:100"}]}},{"assignments":[55456],"declarations":[{"constant":false,"id":55456,"mutability":"mutable","name":"faultDisputeGameImpl","nameLocation":"19139:20:100","nodeType":"VariableDeclaration","scope":55527,"src":"19131:28:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":55455,"name":"address","nodeType":"ElementaryTypeName","src":"19131:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"id":55460,"initialValue":{"arguments":[{"id":55458,"name":"disputeGameFactoryProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55303,"src":"19183:23:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_address","typeString":"address"}],"id":55457,"name":"_getFaultDisputeGame","nodeType":"Identifier","overloadedDeclarations":[55832,55864],"referencedDeclaration":55832,"src":"19162:20:100","typeDescriptions":{"typeIdentifier":"t_function_internal_view$_t_address_$returns$_t_address_$","typeString":"function (address) view returns (address)"}},"id":55459,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"19162:45:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"VariableDeclarationStatement","src":"19131:76:100"},{"condition":{"commonType":{"typeIdentifier":"t_address","typeString":"address"},"id":55466,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftExpression":{"id":55461,"name":"faultDisputeGameImpl","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55456,"src":"19225:20:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"BinaryOperation","operator":"!=","rightExpression":{"arguments":[{"hexValue":"30","id":55464,"isConstant":false,"isLValue":false,"isPure":true,"kind":"number","lValueRequested":false,"nodeType":"Literal","src":"19257:1:100","typeDescriptions":{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"},"value":"0"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"}],"id":55463,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"nodeType":"ElementaryTypeNameExpression","src":"19249:7:100","typeDescriptions":{"typeIdentifier":"t_type$_t_address_$","typeString":"type(address)"},"typeName":{"id":55462,"name":"address","nodeType":"ElementaryTypeName","src":"19249:7:100","typeDescriptions":{}}},"id":55465,"isConstant":false,"isLValue":false,"isPure":true,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"19249:10:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"src":"19225:34:100","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},"id":55501,"nodeType":"IfStatement","src":"19221:470:100","trueBody":{"id":55500,"nodeType":"Block","src":"19261:430:100","statements":[{"expression":{"arguments":[{"expression":{"expression":{"id":55470,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55193,"src":"19344:3:100","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$54911","typeString":"contract FetchChainInfoOutput"}},"id":55471,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"19348:20:100","memberName":"faultDisputeGameImpl","nodeType":"MemberAccess","referencedDeclaration":54687,"src":"19344:24:100","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":55472,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"19369:8:100","memberName":"selector","nodeType":"MemberAccess","src":"19344:33:100","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},{"id":55473,"name":"faultDisputeGameImpl","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55456,"src":"19379:20:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_bytes4","typeString":"bytes4"},{"typeIdentifier":"t_address","typeString":"address"}],"expression":{"id":55467,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55193,"src":"19336:3:100","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$54911","typeString":"contract FetchChainInfoOutput"}},"id":55469,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"19340:3:100","memberName":"set","nodeType":"MemberAccess","referencedDeclaration":54384,"src":"19336:7:100","typeDescriptions":{"typeIdentifier":"t_function_external_nonpayable$_t_bytes4_$_t_address_$returns$__$","typeString":"function (bytes4,address) external"}},"id":55474,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"19336:64:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":55475,"nodeType":"ExpressionStatement","src":"19336:64:100"},{"expression":{"arguments":[{"expression":{"expression":{"id":55479,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55193,"src":"19426:3:100","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$54911","typeString":"contract FetchChainInfoOutput"}},"id":55480,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"19430:14:100","memberName":"permissionless","nodeType":"MemberAccess","referencedDeclaration":54901,"src":"19426:18:100","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_bool_$","typeString":"function () view external returns (bool)"}},"id":55481,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"19445:8:100","memberName":"selector","nodeType":"MemberAccess","src":"19426:27:100","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},{"hexValue":"74727565","id":55482,"isConstant":false,"isLValue":false,"isPure":true,"kind":"bool","lValueRequested":false,"nodeType":"Literal","src":"19455:4:100","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"},"value":"true"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_bytes4","typeString":"bytes4"},{"typeIdentifier":"t_bool","typeString":"bool"}],"expression":{"id":55476,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55193,"src":"19418:3:100","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$54911","typeString":"contract FetchChainInfoOutput"}},"id":55478,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"19422:3:100","memberName":"set","nodeType":"MemberAccess","referencedDeclaration":54416,"src":"19418:7:100","typeDescriptions":{"typeIdentifier":"t_function_external_nonpayable$_t_bytes4_$_t_bool_$returns$__$","typeString":"function (bytes4,bool) external"}},"id":55483,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"19418:42:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":55484,"nodeType":"ExpressionStatement","src":"19418:42:100"},{"assignments":[55486],"declarations":[{"constant":false,"id":55486,"mutability":"mutable","name":"delayedWethPermissionlessGameProxy","nameLocation":"19487:34:100","nodeType":"VariableDeclaration","scope":55500,"src":"19479:42:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":55485,"name":"address","nodeType":"ElementaryTypeName","src":"19479:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"id":55490,"initialValue":{"arguments":[{"id":55488,"name":"faultDisputeGameImpl","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55456,"src":"19545:20:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_address","typeString":"address"}],"id":55487,"name":"_getDelayedWETHProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55967,"src":"19524:20:100","typeDescriptions":{"typeIdentifier":"t_function_internal_view$_t_address_$returns$_t_address_$","typeString":"function (address) view returns (address)"}},"id":55489,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"19524:42:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"VariableDeclarationStatement","src":"19479:87:100"},{"expression":{"arguments":[{"expression":{"expression":{"id":55494,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55193,"src":"19592:3:100","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$54911","typeString":"contract FetchChainInfoOutput"}},"id":55495,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"19596:34:100","memberName":"delayedWethPermissionlessGameProxy","nodeType":"MemberAccess","referencedDeclaration":54661,"src":"19592:38:100","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":55496,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"19631:8:100","memberName":"selector","nodeType":"MemberAccess","src":"19592:47:100","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},{"id":55497,"name":"delayedWethPermissionlessGameProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55486,"src":"19641:34:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_bytes4","typeString":"bytes4"},{"typeIdentifier":"t_address","typeString":"address"}],"expression":{"id":55491,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55193,"src":"19584:3:100","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$54911","typeString":"contract FetchChainInfoOutput"}},"id":55493,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"19588:3:100","memberName":"set","nodeType":"MemberAccess","referencedDeclaration":54384,"src":"19584:7:100","typeDescriptions":{"typeIdentifier":"t_function_external_nonpayable$_t_bytes4_$_t_address_$returns$__$","typeString":"function (bytes4,address) external"}},"id":55498,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"19584:92:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":55499,"nodeType":"ExpressionStatement","src":"19584:92:100"}]}},{"assignments":[55503],"declarations":[{"constant":false,"id":55503,"mutability":"mutable","name":"faultDisputeGameCannonKonaImpl","nameLocation":"19713:30:100","nodeType":"VariableDeclaration","scope":55527,"src":"19705:38:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":55502,"name":"address","nodeType":"ElementaryTypeName","src":"19705:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"id":55509,"initialValue":{"arguments":[{"id":55505,"name":"disputeGameFactoryProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55303,"src":"19783:23:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},{"expression":{"id":55506,"name":"GameTypes","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":70870,"src":"19808:9:100","typeDescriptions":{"typeIdentifier":"t_type$_t_contract$_GameTypes_$70870_$","typeString":"type(library GameTypes)"}},"id":55507,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"memberLocation":"19818:11:100","memberName":"CANNON_KONA","nodeType":"MemberAccess","referencedDeclaration":70837,"src":"19808:21:100","typeDescriptions":{"typeIdentifier":"t_userDefinedValueType$_GameType_$70720","typeString":"GameType"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_address","typeString":"address"},{"typeIdentifier":"t_userDefinedValueType$_GameType_$70720","typeString":"GameType"}],"id":55504,"name":"_getFaultDisputeGame","nodeType":"Identifier","overloadedDeclarations":[55832,55864],"referencedDeclaration":55864,"src":"19762:20:100","typeDescriptions":{"typeIdentifier":"t_function_internal_view$_t_address_$_t_userDefinedValueType$_GameType_$70720_$returns$_t_address_$","typeString":"function (address,GameType) view returns (address)"}},"id":55508,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"19762:68:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"VariableDeclarationStatement","src":"19705:125:100"},{"condition":{"commonType":{"typeIdentifier":"t_address","typeString":"address"},"id":55515,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftExpression":{"id":55510,"name":"faultDisputeGameCannonKonaImpl","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55503,"src":"19848:30:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"nodeType":"BinaryOperation","operator":"!=","rightExpression":{"arguments":[{"hexValue":"30","id":55513,"isConstant":false,"isLValue":false,"isPure":true,"kind":"number","lValueRequested":false,"nodeType":"Literal","src":"19890:1:100","typeDescriptions":{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"},"value":"0"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"}],"id":55512,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"nodeType":"ElementaryTypeNameExpression","src":"19882:7:100","typeDescriptions":{"typeIdentifier":"t_type$_t_address_$","typeString":"type(address)"},"typeName":{"id":55511,"name":"address","nodeType":"ElementaryTypeName","src":"19882:7:100","typeDescriptions":{}}},"id":55514,"isConstant":false,"isLValue":false,"isPure":true,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"19882:10:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"src":"19848:44:100","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},"id":55526,"nodeType":"IfStatement","src":"19844:167:100","trueBody":{"id":55525,"nodeType":"Block","src":"19894:117:100","statements":[{"expression":{"arguments":[{"expression":{"expression":{"id":55519,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55193,"src":"19920:3:100","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$54911","typeString":"contract FetchChainInfoOutput"}},"id":55520,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"19924:30:100","memberName":"faultDisputeGameCannonKonaImpl","nodeType":"MemberAccess","referencedDeclaration":54705,"src":"19920:34:100","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":55521,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"19955:8:100","memberName":"selector","nodeType":"MemberAccess","src":"19920:43:100","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},{"id":55522,"name":"faultDisputeGameCannonKonaImpl","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55503,"src":"19965:30:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_bytes4","typeString":"bytes4"},{"typeIdentifier":"t_address","typeString":"address"}],"expression":{"id":55516,"name":"_fo","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55193,"src":"19912:3:100","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$54911","typeString":"contract FetchChainInfoOutput"}},"id":55518,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"19916:3:100","memberName":"set","nodeType":"MemberAccess","referencedDeclaration":54384,"src":"19912:7:100","typeDescriptions":{"typeIdentifier":"t_function_external_nonpayable$_t_bytes4_$_t_address_$returns$__$","typeString":"function (bytes4,address) external"}},"id":55523,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"19912:84:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":55524,"nodeType":"ExpressionStatement","src":"19912:84:100"}]}}]}}]},"implemented":true,"kind":"function","modifiers":[],"name":"_processFaultProofs","nameLocation":"16392:19:100","parameters":{"id":55194,"nodeType":"ParameterList","parameters":[{"constant":false,"id":55193,"mutability":"mutable","name":"_fo","nameLocation":"16433:3:100","nodeType":"VariableDeclaration","scope":55565,"src":"16412:24:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$54911","typeString":"contract FetchChainInfoOutput"},"typeName":{"id":55192,"nodeType":"UserDefinedTypeName","pathNode":{"id":55191,"name":"FetchChainInfoOutput","nameLocations":["16412:20:100"],"nodeType":"IdentifierPath","referencedDeclaration":54911,"src":"16412:20:100"},"referencedDeclaration":54911,"src":"16412:20:100","typeDescriptions":{"typeIdentifier":"t_contract$_FetchChainInfoOutput_$54911","typeString":"contract FetchChainInfoOutput"}},"visibility":"internal"}],"src":"16411:26:100"},"returnParameters":{"id":55195,"nodeType":"ParameterList","parameters":[],"src":"16447:0:100"},"scope":56018,"stateMutability":"nonpayable","virtual":false,"visibility":"internal"},{"id":55594,"nodeType":"FunctionDefinition","src":"20422:256:100","nodes":[],"body":{"id":55593,"nodeType":"Block","src":"20493:185:100","nodes":[],"statements":[{"clauses":[{"block":{"id":55582,"nodeType":"Block","src":"20564:41:100","statements":[{"expression":{"id":55580,"name":"guardian_","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55578,"src":"20585:9:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"functionReturnParameters":55571,"id":55581,"nodeType":"Return","src":"20578:16:100"}]},"errorName":"","id":55583,"nodeType":"TryCatchClause","parameters":{"id":55579,"nodeType":"ParameterList","parameters":[{"constant":false,"id":55578,"mutability":"mutable","name":"guardian_","nameLocation":"20553:9:100","nodeType":"VariableDeclaration","scope":55583,"src":"20545:17:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":55577,"name":"address","nodeType":"ElementaryTypeName","src":"20545:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"20544:19:100"},"src":"20536:69:100"},{"block":{"id":55590,"nodeType":"Block","src":"20612:60:100","statements":[{"expression":{"arguments":[],"expression":{"argumentTypes":[],"expression":{"arguments":[{"id":55585,"name":"_portal","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55567,"src":"20642:7:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_address","typeString":"address"}],"id":55584,"name":"IFetcher","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":53958,"src":"20633:8:100","typeDescriptions":{"typeIdentifier":"t_type$_t_contract$_IFetcher_$53958_$","typeString":"type(contract IFetcher)"}},"id":55586,"isConstant":false,"isLValue":false,"isPure":false,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"20633:17:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_contract$_IFetcher_$53958","typeString":"contract IFetcher"}},"id":55587,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"20651:8:100","memberName":"GUARDIAN","nodeType":"MemberAccess","referencedDeclaration":53823,"src":"20633:26:100","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":55588,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"20633:28:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"functionReturnParameters":55571,"id":55589,"nodeType":"Return","src":"20626:35:100"}]},"errorName":"","id":55591,"nodeType":"TryCatchClause","src":"20606:66:100"}],"externalCall":{"arguments":[],"expression":{"argumentTypes":[],"expression":{"arguments":[{"id":55573,"name":"_portal","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55567,"src":"20516:7:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_address","typeString":"address"}],"id":55572,"name":"IFetcher","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":53958,"src":"20507:8:100","typeDescriptions":{"typeIdentifier":"t_type$_t_contract$_IFetcher_$53958_$","typeString":"type(contract IFetcher)"}},"id":55574,"isConstant":false,"isLValue":false,"isPure":false,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"20507:17:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_contract$_IFetcher_$53958","typeString":"contract IFetcher"}},"id":55575,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"20525:8:100","memberName":"guardian","nodeType":"MemberAccess","referencedDeclaration":53818,"src":"20507:26:100","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":55576,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"20507:28:100","tryCall":true,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"id":55592,"nodeType":"TryStatement","src":"20503:169:100"}]},"implemented":true,"kind":"function","modifiers":[],"name":"_getGuardian","nameLocation":"20431:12:100","parameters":{"id":55568,"nodeType":"ParameterList","parameters":[{"constant":false,"id":55567,"mutability":"mutable","name":"_portal","nameLocation":"20452:7:100","nodeType":"VariableDeclaration","scope":55594,"src":"20444:15:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":55566,"name":"address","nodeType":"ElementaryTypeName","src":"20444:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"20443:17:100"},"returnParameters":{"id":55571,"nodeType":"ParameterList","parameters":[{"constant":false,"id":55570,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":55594,"src":"20484:7:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":55569,"name":"address","nodeType":"ElementaryTypeName","src":"20484:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"20483:9:100"},"scope":56018,"stateMutability":"view","virtual":false,"visibility":"internal"},{"id":55623,"nodeType":"FunctionDefinition","src":"20684:282:100","nodes":[],"body":{"id":55622,"nodeType":"Block","src":"20764:202:100","nodes":[],"statements":[{"clauses":[{"block":{"id":55611,"nodeType":"Block","src":"20843:45:100","statements":[{"expression":{"id":55609,"name":"systemConfig_","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55607,"src":"20864:13:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"functionReturnParameters":55600,"id":55610,"nodeType":"Return","src":"20857:20:100"}]},"errorName":"","id":55612,"nodeType":"TryCatchClause","parameters":{"id":55608,"nodeType":"ParameterList","parameters":[{"constant":false,"id":55607,"mutability":"mutable","name":"systemConfig_","nameLocation":"20828:13:100","nodeType":"VariableDeclaration","scope":55612,"src":"20820:21:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":55606,"name":"address","nodeType":"ElementaryTypeName","src":"20820:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"20819:23:100"},"src":"20811:77:100"},{"block":{"id":55619,"nodeType":"Block","src":"20895:65:100","statements":[{"expression":{"arguments":[],"expression":{"argumentTypes":[],"expression":{"arguments":[{"id":55614,"name":"_portal","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55596,"src":"20925:7:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_address","typeString":"address"}],"id":55613,"name":"IFetcher","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":53958,"src":"20916:8:100","typeDescriptions":{"typeIdentifier":"t_type$_t_contract$_IFetcher_$53958_$","typeString":"type(contract IFetcher)"}},"id":55615,"isConstant":false,"isLValue":false,"isPure":false,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"20916:17:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_contract$_IFetcher_$53958","typeString":"contract IFetcher"}},"id":55616,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"20934:13:100","memberName":"SYSTEM_CONFIG","nodeType":"MemberAccess","referencedDeclaration":53833,"src":"20916:31:100","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":55617,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"20916:33:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"functionReturnParameters":55600,"id":55618,"nodeType":"Return","src":"20909:40:100"}]},"errorName":"","id":55620,"nodeType":"TryCatchClause","src":"20889:71:100"}],"externalCall":{"arguments":[],"expression":{"argumentTypes":[],"expression":{"arguments":[{"id":55602,"name":"_portal","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55596,"src":"20787:7:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_address","typeString":"address"}],"id":55601,"name":"IFetcher","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":53958,"src":"20778:8:100","typeDescriptions":{"typeIdentifier":"t_type$_t_contract$_IFetcher_$53958_$","typeString":"type(contract IFetcher)"}},"id":55603,"isConstant":false,"isLValue":false,"isPure":false,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"20778:17:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_contract$_IFetcher_$53958","typeString":"contract IFetcher"}},"id":55604,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"20796:12:100","memberName":"systemConfig","nodeType":"MemberAccess","referencedDeclaration":53828,"src":"20778:30:100","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":55605,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"20778:32:100","tryCall":true,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"id":55621,"nodeType":"TryStatement","src":"20774:186:100"}]},"implemented":true,"kind":"function","modifiers":[],"name":"_getSystemConfigProxy","nameLocation":"20693:21:100","parameters":{"id":55597,"nodeType":"ParameterList","parameters":[{"constant":false,"id":55596,"mutability":"mutable","name":"_portal","nameLocation":"20723:7:100","nodeType":"VariableDeclaration","scope":55623,"src":"20715:15:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":55595,"name":"address","nodeType":"ElementaryTypeName","src":"20715:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"20714:17:100"},"returnParameters":{"id":55600,"nodeType":"ParameterList","parameters":[{"constant":false,"id":55599,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":55623,"src":"20755:7:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":55598,"name":"address","nodeType":"ElementaryTypeName","src":"20755:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"20754:9:100"},"scope":56018,"stateMutability":"view","virtual":false,"visibility":"internal"},{"id":55652,"nodeType":"FunctionDefinition","src":"20972:338:100","nodes":[],"body":{"id":55651,"nodeType":"Block","src":"21075:235:100","nodes":[],"statements":[{"clauses":[{"block":{"id":55640,"nodeType":"Block","src":"21171:47:100","statements":[{"expression":{"id":55638,"name":"optimismPortal_","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55636,"src":"21192:15:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"functionReturnParameters":55629,"id":55639,"nodeType":"Return","src":"21185:22:100"}]},"errorName":"","id":55641,"nodeType":"TryCatchClause","parameters":{"id":55637,"nodeType":"ParameterList","parameters":[{"constant":false,"id":55636,"mutability":"mutable","name":"optimismPortal_","nameLocation":"21154:15:100","nodeType":"VariableDeclaration","scope":55641,"src":"21146:23:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":55635,"name":"address","nodeType":"ElementaryTypeName","src":"21146:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"21145:25:100"},"src":"21137:81:100"},{"block":{"id":55648,"nodeType":"Block","src":"21225:79:100","statements":[{"expression":{"arguments":[],"expression":{"argumentTypes":[],"expression":{"arguments":[{"id":55643,"name":"_l1CrossDomainMessengerProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55625,"src":"21255:28:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_address","typeString":"address"}],"id":55642,"name":"IFetcher","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":53958,"src":"21246:8:100","typeDescriptions":{"typeIdentifier":"t_type$_t_contract$_IFetcher_$53958_$","typeString":"type(contract IFetcher)"}},"id":55644,"isConstant":false,"isLValue":false,"isPure":false,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"21246:38:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_contract$_IFetcher_$53958","typeString":"contract IFetcher"}},"id":55645,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"21285:6:100","memberName":"PORTAL","nodeType":"MemberAccess","referencedDeclaration":53863,"src":"21246:45:100","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":55646,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"21246:47:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"functionReturnParameters":55629,"id":55647,"nodeType":"Return","src":"21239:54:100"}]},"errorName":"","id":55649,"nodeType":"TryCatchClause","src":"21219:85:100"}],"externalCall":{"arguments":[],"expression":{"argumentTypes":[],"expression":{"arguments":[{"id":55631,"name":"_l1CrossDomainMessengerProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55625,"src":"21098:28:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_address","typeString":"address"}],"id":55630,"name":"IFetcher","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":53958,"src":"21089:8:100","typeDescriptions":{"typeIdentifier":"t_type$_t_contract$_IFetcher_$53958_$","typeString":"type(contract IFetcher)"}},"id":55632,"isConstant":false,"isLValue":false,"isPure":false,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"21089:38:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_contract$_IFetcher_$53958","typeString":"contract IFetcher"}},"id":55633,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"21128:6:100","memberName":"portal","nodeType":"MemberAccess","referencedDeclaration":53868,"src":"21089:45:100","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":55634,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"21089:47:100","tryCall":true,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"id":55650,"nodeType":"TryStatement","src":"21085:219:100"}]},"implemented":true,"kind":"function","modifiers":[],"name":"_getOptimismPortalProxy","nameLocation":"20981:23:100","parameters":{"id":55626,"nodeType":"ParameterList","parameters":[{"constant":false,"id":55625,"mutability":"mutable","name":"_l1CrossDomainMessengerProxy","nameLocation":"21013:28:100","nodeType":"VariableDeclaration","scope":55652,"src":"21005:36:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":55624,"name":"address","nodeType":"ElementaryTypeName","src":"21005:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"21004:38:100"},"returnParameters":{"id":55629,"nodeType":"ParameterList","parameters":[{"constant":false,"id":55628,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":55652,"src":"21066:7:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":55627,"name":"address","nodeType":"ElementaryTypeName","src":"21066:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"21065:9:100"},"scope":56018,"stateMutability":"view","virtual":false,"visibility":"internal"},{"id":55690,"nodeType":"FunctionDefinition","src":"21316:350:100","nodes":[],"body":{"id":55689,"nodeType":"Block","src":"21414:252:100","nodes":[],"statements":[{"assignments":[55660],"declarations":[{"constant":false,"id":55660,"mutability":"mutable","name":"ADDRESS_MANAGER_MAPPING_SLOT","nameLocation":"21432:28:100","nodeType":"VariableDeclaration","scope":55689,"src":"21424:36:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_uint256","typeString":"uint256"},"typeName":{"id":55659,"name":"uint256","nodeType":"ElementaryTypeName","src":"21424:7:100","typeDescriptions":{"typeIdentifier":"t_uint256","typeString":"uint256"}},"visibility":"internal"}],"id":55662,"initialValue":{"hexValue":"31","id":55661,"isConstant":false,"isLValue":false,"isPure":true,"kind":"number","lValueRequested":false,"nodeType":"Literal","src":"21463:1:100","typeDescriptions":{"typeIdentifier":"t_rational_1_by_1","typeString":"int_const 1"},"value":"1"},"nodeType":"VariableDeclarationStatement","src":"21424:40:100"},{"assignments":[55664],"declarations":[{"constant":false,"id":55664,"mutability":"mutable","name":"slot","nameLocation":"21482:4:100","nodeType":"VariableDeclaration","scope":55689,"src":"21474:12:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_bytes32","typeString":"bytes32"},"typeName":{"id":55663,"name":"bytes32","nodeType":"ElementaryTypeName","src":"21474:7:100","typeDescriptions":{"typeIdentifier":"t_bytes32","typeString":"bytes32"}},"visibility":"internal"}],"id":55672,"initialValue":{"arguments":[{"arguments":[{"id":55668,"name":"_l1CrossDomainMessengerProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55654,"src":"21510:28:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},{"id":55669,"name":"ADDRESS_MANAGER_MAPPING_SLOT","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55660,"src":"21540:28:100","typeDescriptions":{"typeIdentifier":"t_uint256","typeString":"uint256"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_address","typeString":"address"},{"typeIdentifier":"t_uint256","typeString":"uint256"}],"expression":{"id":55666,"name":"abi","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":-1,"src":"21499:3:100","typeDescriptions":{"typeIdentifier":"t_magic_abi","typeString":"abi"}},"id":55667,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"memberLocation":"21503:6:100","memberName":"encode","nodeType":"MemberAccess","src":"21499:10:100","typeDescriptions":{"typeIdentifier":"t_function_abiencode_pure$__$returns$_t_bytes_memory_ptr_$","typeString":"function () pure returns (bytes memory)"}},"id":55670,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"21499:70:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_bytes_memory_ptr","typeString":"bytes memory"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_bytes_memory_ptr","typeString":"bytes memory"}],"id":55665,"name":"keccak256","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":-8,"src":"21489:9:100","typeDescriptions":{"typeIdentifier":"t_function_keccak256_pure$_t_bytes_memory_ptr_$returns$_t_bytes32_$","typeString":"function (bytes memory) pure returns (bytes32)"}},"id":55671,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"21489:81:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_bytes32","typeString":"bytes32"}},"nodeType":"VariableDeclarationStatement","src":"21474:96:100"},{"expression":{"arguments":[{"arguments":[{"arguments":[{"components":[{"arguments":[{"id":55681,"name":"_l1CrossDomainMessengerProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55654,"src":"21620:28:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},{"id":55682,"name":"slot","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55664,"src":"21650:4:100","typeDescriptions":{"typeIdentifier":"t_bytes32","typeString":"bytes32"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_address","typeString":"address"},{"typeIdentifier":"t_bytes32","typeString":"bytes32"}],"expression":{"id":55679,"name":"vm","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":5501,"src":"21612:2:100","typeDescriptions":{"typeIdentifier":"t_contract$_Vm_$23288","typeString":"contract Vm"}},"id":55680,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"21615:4:100","memberName":"load","nodeType":"MemberAccess","referencedDeclaration":19384,"src":"21612:7:100","typeDescriptions":{"typeIdentifier":"t_function_external_view$_t_address_$_t_bytes32_$returns$_t_bytes32_$","typeString":"function (address,bytes32) view external returns (bytes32)"}},"id":55683,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"21612:43:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_bytes32","typeString":"bytes32"}}],"id":55684,"isConstant":false,"isInlineArray":false,"isLValue":false,"isPure":false,"lValueRequested":false,"nodeType":"TupleExpression","src":"21611:45:100","typeDescriptions":{"typeIdentifier":"t_bytes32","typeString":"bytes32"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_bytes32","typeString":"bytes32"}],"id":55678,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"nodeType":"ElementaryTypeNameExpression","src":"21603:7:100","typeDescriptions":{"typeIdentifier":"t_type$_t_uint256_$","typeString":"type(uint256)"},"typeName":{"id":55677,"name":"uint256","nodeType":"ElementaryTypeName","src":"21603:7:100","typeDescriptions":{}}},"id":55685,"isConstant":false,"isLValue":false,"isPure":false,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"21603:54:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_uint256","typeString":"uint256"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_uint256","typeString":"uint256"}],"id":55676,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"nodeType":"ElementaryTypeNameExpression","src":"21595:7:100","typeDescriptions":{"typeIdentifier":"t_type$_t_uint160_$","typeString":"type(uint160)"},"typeName":{"id":55675,"name":"uint160","nodeType":"ElementaryTypeName","src":"21595:7:100","typeDescriptions":{}}},"id":55686,"isConstant":false,"isLValue":false,"isPure":false,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"21595:63:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_uint160","typeString":"uint160"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_uint160","typeString":"uint160"}],"id":55674,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"nodeType":"ElementaryTypeNameExpression","src":"21587:7:100","typeDescriptions":{"typeIdentifier":"t_type$_t_address_$","typeString":"type(address)"},"typeName":{"id":55673,"name":"address","nodeType":"ElementaryTypeName","src":"21587:7:100","typeDescriptions":{}}},"id":55687,"isConstant":false,"isLValue":false,"isPure":false,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"21587:72:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"functionReturnParameters":55658,"id":55688,"nodeType":"Return","src":"21580:79:100"}]},"implemented":true,"kind":"function","modifiers":[],"name":"_getAddressManager","nameLocation":"21325:18:100","parameters":{"id":55655,"nodeType":"ParameterList","parameters":[{"constant":false,"id":55654,"mutability":"mutable","name":"_l1CrossDomainMessengerProxy","nameLocation":"21352:28:100","nodeType":"VariableDeclaration","scope":55690,"src":"21344:36:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":55653,"name":"address","nodeType":"ElementaryTypeName","src":"21344:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"21343:38:100"},"returnParameters":{"id":55658,"nodeType":"ParameterList","parameters":[{"constant":false,"id":55657,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":55690,"src":"21405:7:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":55656,"name":"address","nodeType":"ElementaryTypeName","src":"21405:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"21404:9:100"},"scope":56018,"stateMutability":"view","virtual":false,"visibility":"internal"},{"id":55718,"nodeType":"FunctionDefinition","src":"21672:299:100","nodes":[],"body":{"id":55717,"nodeType":"Block","src":"21765:206:100","nodes":[],"statements":[{"clauses":[{"block":{"id":55707,"nodeType":"Block","src":"21864:52:100","statements":[{"expression":{"id":55705,"name":"l1ERC721BridgeProxy_","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55703,"src":"21885:20:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"functionReturnParameters":55696,"id":55706,"nodeType":"Return","src":"21878:27:100"}]},"errorName":"","id":55708,"nodeType":"TryCatchClause","parameters":{"id":55704,"nodeType":"ParameterList","parameters":[{"constant":false,"id":55703,"mutability":"mutable","name":"l1ERC721BridgeProxy_","nameLocation":"21842:20:100","nodeType":"VariableDeclaration","scope":55708,"src":"21834:28:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":55702,"name":"address","nodeType":"ElementaryTypeName","src":"21834:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"21833:30:100"},"src":"21825:91:100"},{"block":{"id":55714,"nodeType":"Block","src":"21923:42:100","statements":[{"expression":{"arguments":[{"hexValue":"30","id":55711,"isConstant":false,"isLValue":false,"isPure":true,"kind":"number","lValueRequested":false,"nodeType":"Literal","src":"21952:1:100","typeDescriptions":{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"},"value":"0"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"}],"id":55710,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"nodeType":"ElementaryTypeNameExpression","src":"21944:7:100","typeDescriptions":{"typeIdentifier":"t_type$_t_address_$","typeString":"type(address)"},"typeName":{"id":55709,"name":"address","nodeType":"ElementaryTypeName","src":"21944:7:100","typeDescriptions":{}}},"id":55712,"isConstant":false,"isLValue":false,"isPure":true,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"21944:10:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"functionReturnParameters":55696,"id":55713,"nodeType":"Return","src":"21937:17:100"}]},"errorName":"","id":55715,"nodeType":"TryCatchClause","src":"21917:48:100"}],"externalCall":{"arguments":[],"expression":{"argumentTypes":[],"expression":{"arguments":[{"id":55698,"name":"_systemConfigProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55692,"src":"21788:18:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_address","typeString":"address"}],"id":55697,"name":"IFetcher","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":53958,"src":"21779:8:100","typeDescriptions":{"typeIdentifier":"t_type$_t_contract$_IFetcher_$53958_$","typeString":"type(contract IFetcher)"}},"id":55699,"isConstant":false,"isLValue":false,"isPure":false,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"21779:28:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_contract$_IFetcher_$53958","typeString":"contract IFetcher"}},"id":55700,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"21808:14:100","memberName":"l1ERC721Bridge","nodeType":"MemberAccess","referencedDeclaration":53873,"src":"21779:43:100","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":55701,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"21779:45:100","tryCall":true,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"id":55716,"nodeType":"TryStatement","src":"21775:190:100"}]},"implemented":true,"kind":"function","modifiers":[],"name":"_getL1ERC721BridgeProxy","nameLocation":"21681:23:100","parameters":{"id":55693,"nodeType":"ParameterList","parameters":[{"constant":false,"id":55692,"mutability":"mutable","name":"_systemConfigProxy","nameLocation":"21713:18:100","nodeType":"VariableDeclaration","scope":55718,"src":"21705:26:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":55691,"name":"address","nodeType":"ElementaryTypeName","src":"21705:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"21704:28:100"},"returnParameters":{"id":55696,"nodeType":"ParameterList","parameters":[{"constant":false,"id":55695,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":55718,"src":"21756:7:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":55694,"name":"address","nodeType":"ElementaryTypeName","src":"21756:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"21755:9:100"},"scope":56018,"stateMutability":"view","virtual":false,"visibility":"internal"},{"id":55746,"nodeType":"FunctionDefinition","src":"21977:377:100","nodes":[],"body":{"id":55745,"nodeType":"Block","src":"22084:270:100","nodes":[],"statements":[{"clauses":[{"block":{"id":55735,"nodeType":"Block","src":"22233:66:100","statements":[{"expression":{"id":55733,"name":"optimismMintableERC20FactoryProxy_","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55731,"src":"22254:34:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"functionReturnParameters":55724,"id":55734,"nodeType":"Return","src":"22247:41:100"}]},"errorName":"","id":55736,"nodeType":"TryCatchClause","parameters":{"id":55732,"nodeType":"ParameterList","parameters":[{"constant":false,"id":55731,"mutability":"mutable","name":"optimismMintableERC20FactoryProxy_","nameLocation":"22188:34:100","nodeType":"VariableDeclaration","scope":55736,"src":"22180:42:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":55730,"name":"address","nodeType":"ElementaryTypeName","src":"22180:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"22166:66:100"},"src":"22158:141:100"},{"block":{"id":55742,"nodeType":"Block","src":"22306:42:100","statements":[{"expression":{"arguments":[{"hexValue":"30","id":55739,"isConstant":false,"isLValue":false,"isPure":true,"kind":"number","lValueRequested":false,"nodeType":"Literal","src":"22335:1:100","typeDescriptions":{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"},"value":"0"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"}],"id":55738,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"nodeType":"ElementaryTypeNameExpression","src":"22327:7:100","typeDescriptions":{"typeIdentifier":"t_type$_t_address_$","typeString":"type(address)"},"typeName":{"id":55737,"name":"address","nodeType":"ElementaryTypeName","src":"22327:7:100","typeDescriptions":{}}},"id":55740,"isConstant":false,"isLValue":false,"isPure":true,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"22327:10:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"functionReturnParameters":55724,"id":55741,"nodeType":"Return","src":"22320:17:100"}]},"errorName":"","id":55743,"nodeType":"TryCatchClause","src":"22300:48:100"}],"externalCall":{"arguments":[],"expression":{"argumentTypes":[],"expression":{"arguments":[{"id":55726,"name":"_systemConfigProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55720,"src":"22107:18:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_address","typeString":"address"}],"id":55725,"name":"IFetcher","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":53958,"src":"22098:8:100","typeDescriptions":{"typeIdentifier":"t_type$_t_contract$_IFetcher_$53958_$","typeString":"type(contract IFetcher)"}},"id":55727,"isConstant":false,"isLValue":false,"isPure":false,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"22098:28:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_contract$_IFetcher_$53958","typeString":"contract IFetcher"}},"id":55728,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"22127:28:100","memberName":"optimismMintableERC20Factory","nodeType":"MemberAccess","referencedDeclaration":53878,"src":"22098:57:100","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":55729,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"22098:59:100","tryCall":true,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"id":55744,"nodeType":"TryStatement","src":"22094:254:100"}]},"implemented":true,"kind":"function","modifiers":[],"name":"_getOptimismMintableERC20FactoryProxy","nameLocation":"21986:37:100","parameters":{"id":55721,"nodeType":"ParameterList","parameters":[{"constant":false,"id":55720,"mutability":"mutable","name":"_systemConfigProxy","nameLocation":"22032:18:100","nodeType":"VariableDeclaration","scope":55746,"src":"22024:26:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":55719,"name":"address","nodeType":"ElementaryTypeName","src":"22024:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"22023:28:100"},"returnParameters":{"id":55724,"nodeType":"ParameterList","parameters":[{"constant":false,"id":55723,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":55746,"src":"22075:7:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":55722,"name":"address","nodeType":"ElementaryTypeName","src":"22075:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"22074:9:100"},"scope":56018,"stateMutability":"view","virtual":false,"visibility":"internal"},{"id":55774,"nodeType":"FunctionDefinition","src":"22360:398:100","nodes":[],"body":{"id":55773,"nodeType":"Block","src":"22457:301:100","nodes":[],"statements":[{"clauses":[{"block":{"id":55763,"nodeType":"Block","src":"22564:56:100","statements":[{"expression":{"id":55761,"name":"disputeGameFactoryProxy_","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55759,"src":"22585:24:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"functionReturnParameters":55752,"id":55762,"nodeType":"Return","src":"22578:31:100"}]},"errorName":"","id":55764,"nodeType":"TryCatchClause","parameters":{"id":55760,"nodeType":"ParameterList","parameters":[{"constant":false,"id":55759,"mutability":"mutable","name":"disputeGameFactoryProxy_","nameLocation":"22538:24:100","nodeType":"VariableDeclaration","scope":55764,"src":"22530:32:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":55758,"name":"address","nodeType":"ElementaryTypeName","src":"22530:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"22529:34:100"},"src":"22521:99:100"},{"block":{"id":55770,"nodeType":"Block","src":"22627:125:100","statements":[{"expression":{"arguments":[{"hexValue":"30","id":55767,"isConstant":false,"isLValue":false,"isPure":true,"kind":"number","lValueRequested":false,"nodeType":"Literal","src":"22739:1:100","typeDescriptions":{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"},"value":"0"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"}],"id":55766,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"nodeType":"ElementaryTypeNameExpression","src":"22731:7:100","typeDescriptions":{"typeIdentifier":"t_type$_t_address_$","typeString":"type(address)"},"typeName":{"id":55765,"name":"address","nodeType":"ElementaryTypeName","src":"22731:7:100","typeDescriptions":{}}},"id":55768,"isConstant":false,"isLValue":false,"isPure":true,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"22731:10:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"functionReturnParameters":55752,"id":55769,"nodeType":"Return","src":"22724:17:100"}]},"errorName":"","id":55771,"nodeType":"TryCatchClause","src":"22621:131:100"}],"externalCall":{"arguments":[],"expression":{"argumentTypes":[],"expression":{"arguments":[{"id":55754,"name":"_systemConfigProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55748,"src":"22480:18:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_address","typeString":"address"}],"id":55753,"name":"IFetcher","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":53958,"src":"22471:8:100","typeDescriptions":{"typeIdentifier":"t_type$_t_contract$_IFetcher_$53958_$","typeString":"type(contract IFetcher)"}},"id":55755,"isConstant":false,"isLValue":false,"isPure":false,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"22471:28:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_contract$_IFetcher_$53958","typeString":"contract IFetcher"}},"id":55756,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"22500:18:100","memberName":"disputeGameFactory","nodeType":"MemberAccess","referencedDeclaration":53838,"src":"22471:47:100","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":55757,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"22471:49:100","tryCall":true,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"id":55772,"nodeType":"TryStatement","src":"22467:285:100"}]},"implemented":true,"kind":"function","modifiers":[],"name":"_getDisputeGameFactoryProxy","nameLocation":"22369:27:100","parameters":{"id":55749,"nodeType":"ParameterList","parameters":[{"constant":false,"id":55748,"mutability":"mutable","name":"_systemConfigProxy","nameLocation":"22405:18:100","nodeType":"VariableDeclaration","scope":55774,"src":"22397:26:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":55747,"name":"address","nodeType":"ElementaryTypeName","src":"22397:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"22396:28:100"},"returnParameters":{"id":55752,"nodeType":"ParameterList","parameters":[{"constant":false,"id":55751,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":55774,"src":"22448:7:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":55750,"name":"address","nodeType":"ElementaryTypeName","src":"22448:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"22447:9:100"},"scope":56018,"stateMutability":"view","virtual":false,"visibility":"internal"},{"id":55802,"nodeType":"FunctionDefinition","src":"22764:311:100","nodes":[],"body":{"id":55801,"nodeType":"Block","src":"22861:214:100","nodes":[],"statements":[{"clauses":[{"block":{"id":55791,"nodeType":"Block","src":"22966:54:100","statements":[{"expression":{"id":55789,"name":"superchainConfigProxy_","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55787,"src":"22987:22:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"functionReturnParameters":55780,"id":55790,"nodeType":"Return","src":"22980:29:100"}]},"errorName":"","id":55792,"nodeType":"TryCatchClause","parameters":{"id":55788,"nodeType":"ParameterList","parameters":[{"constant":false,"id":55787,"mutability":"mutable","name":"superchainConfigProxy_","nameLocation":"22942:22:100","nodeType":"VariableDeclaration","scope":55792,"src":"22934:30:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":55786,"name":"address","nodeType":"ElementaryTypeName","src":"22934:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"22933:32:100"},"src":"22925:95:100"},{"block":{"id":55798,"nodeType":"Block","src":"23027:42:100","statements":[{"expression":{"arguments":[{"hexValue":"30","id":55795,"isConstant":false,"isLValue":false,"isPure":true,"kind":"number","lValueRequested":false,"nodeType":"Literal","src":"23056:1:100","typeDescriptions":{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"},"value":"0"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"}],"id":55794,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"nodeType":"ElementaryTypeNameExpression","src":"23048:7:100","typeDescriptions":{"typeIdentifier":"t_type$_t_address_$","typeString":"type(address)"},"typeName":{"id":55793,"name":"address","nodeType":"ElementaryTypeName","src":"23048:7:100","typeDescriptions":{}}},"id":55796,"isConstant":false,"isLValue":false,"isPure":true,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"23048:10:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"functionReturnParameters":55780,"id":55797,"nodeType":"Return","src":"23041:17:100"}]},"errorName":"","id":55799,"nodeType":"TryCatchClause","src":"23021:48:100"}],"externalCall":{"arguments":[],"expression":{"argumentTypes":[],"expression":{"arguments":[{"id":55782,"name":"_optimismPortalProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55776,"src":"22884:20:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_address","typeString":"address"}],"id":55781,"name":"IFetcher","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":53958,"src":"22875:8:100","typeDescriptions":{"typeIdentifier":"t_type$_t_contract$_IFetcher_$53958_$","typeString":"type(contract IFetcher)"}},"id":55783,"isConstant":false,"isLValue":false,"isPure":false,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"22875:30:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_contract$_IFetcher_$53958","typeString":"contract IFetcher"}},"id":55784,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"22906:16:100","memberName":"superchainConfig","nodeType":"MemberAccess","referencedDeclaration":53848,"src":"22875:47:100","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":55785,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"22875:49:100","tryCall":true,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"id":55800,"nodeType":"TryStatement","src":"22871:198:100"}]},"implemented":true,"kind":"function","modifiers":[],"name":"_getSuperchainConfigProxy","nameLocation":"22773:25:100","parameters":{"id":55777,"nodeType":"ParameterList","parameters":[{"constant":false,"id":55776,"mutability":"mutable","name":"_optimismPortalProxy","nameLocation":"22807:20:100","nodeType":"VariableDeclaration","scope":55802,"src":"22799:28:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":55775,"name":"address","nodeType":"ElementaryTypeName","src":"22799:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"22798:30:100"},"returnParameters":{"id":55780,"nodeType":"ParameterList","parameters":[{"constant":false,"id":55779,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":55802,"src":"22852:7:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":55778,"name":"address","nodeType":"ElementaryTypeName","src":"22852:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"22851:9:100"},"scope":56018,"stateMutability":"view","virtual":false,"visibility":"internal"},{"id":55832,"nodeType":"FunctionDefinition","src":"23081:313:100","nodes":[],"body":{"id":55831,"nodeType":"Block","src":"23177:217:100","nodes":[],"statements":[{"clauses":[{"block":{"id":55821,"nodeType":"Block","src":"23290:49:100","statements":[{"expression":{"id":55819,"name":"faultDisputeGame_","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55817,"src":"23311:17:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"functionReturnParameters":55808,"id":55820,"nodeType":"Return","src":"23304:24:100"}]},"errorName":"","id":55822,"nodeType":"TryCatchClause","parameters":{"id":55818,"nodeType":"ParameterList","parameters":[{"constant":false,"id":55817,"mutability":"mutable","name":"faultDisputeGame_","nameLocation":"23271:17:100","nodeType":"VariableDeclaration","scope":55822,"src":"23263:25:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":55816,"name":"address","nodeType":"ElementaryTypeName","src":"23263:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"23262:27:100"},"src":"23254:85:100"},{"block":{"id":55828,"nodeType":"Block","src":"23346:42:100","statements":[{"expression":{"arguments":[{"hexValue":"30","id":55825,"isConstant":false,"isLValue":false,"isPure":true,"kind":"number","lValueRequested":false,"nodeType":"Literal","src":"23375:1:100","typeDescriptions":{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"},"value":"0"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"}],"id":55824,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"nodeType":"ElementaryTypeNameExpression","src":"23367:7:100","typeDescriptions":{"typeIdentifier":"t_type$_t_address_$","typeString":"type(address)"},"typeName":{"id":55823,"name":"address","nodeType":"ElementaryTypeName","src":"23367:7:100","typeDescriptions":{}}},"id":55826,"isConstant":false,"isLValue":false,"isPure":true,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"23367:10:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"functionReturnParameters":55808,"id":55827,"nodeType":"Return","src":"23360:17:100"}]},"errorName":"","id":55829,"nodeType":"TryCatchClause","src":"23340:48:100"}],"externalCall":{"arguments":[{"expression":{"id":55813,"name":"GameTypes","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":70870,"src":"23236:9:100","typeDescriptions":{"typeIdentifier":"t_type$_t_contract$_GameTypes_$70870_$","typeString":"type(library GameTypes)"}},"id":55814,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"memberLocation":"23246:6:100","memberName":"CANNON","nodeType":"MemberAccess","referencedDeclaration":70773,"src":"23236:16:100","typeDescriptions":{"typeIdentifier":"t_userDefinedValueType$_GameType_$70720","typeString":"GameType"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_userDefinedValueType$_GameType_$70720","typeString":"GameType"}],"expression":{"arguments":[{"id":55810,"name":"_disputeGameFactoryProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55804,"src":"23200:24:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_address","typeString":"address"}],"id":55809,"name":"IFetcher","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":53958,"src":"23191:8:100","typeDescriptions":{"typeIdentifier":"t_type$_t_contract$_IFetcher_$53958_$","typeString":"type(contract IFetcher)"}},"id":55811,"isConstant":false,"isLValue":false,"isPure":false,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"23191:34:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_contract$_IFetcher_$53958","typeString":"contract IFetcher"}},"id":55812,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"23226:9:100","memberName":"gameImpls","nodeType":"MemberAccess","referencedDeclaration":53886,"src":"23191:44:100","typeDescriptions":{"typeIdentifier":"t_function_external_view$_t_userDefinedValueType$_GameType_$70720_$returns$_t_address_$","typeString":"function (GameType) view external returns (address)"}},"id":55815,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"23191:62:100","tryCall":true,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"id":55830,"nodeType":"TryStatement","src":"23187:201:100"}]},"implemented":true,"kind":"function","modifiers":[],"name":"_getFaultDisputeGame","nameLocation":"23090:20:100","parameters":{"id":55805,"nodeType":"ParameterList","parameters":[{"constant":false,"id":55804,"mutability":"mutable","name":"_disputeGameFactoryProxy","nameLocation":"23119:24:100","nodeType":"VariableDeclaration","scope":55832,"src":"23111:32:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":55803,"name":"address","nodeType":"ElementaryTypeName","src":"23111:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"23110:34:100"},"returnParameters":{"id":55808,"nodeType":"ParameterList","parameters":[{"constant":false,"id":55807,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":55832,"src":"23168:7:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":55806,"name":"address","nodeType":"ElementaryTypeName","src":"23168:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"23167:9:100"},"scope":56018,"stateMutability":"view","virtual":false,"visibility":"internal"},{"id":55864,"nodeType":"FunctionDefinition","src":"23400:376:100","nodes":[],"body":{"id":55863,"nodeType":"Block","src":"23566:210:100","nodes":[],"statements":[{"clauses":[{"block":{"id":55853,"nodeType":"Block","src":"23672:49:100","statements":[{"expression":{"id":55851,"name":"faultDisputeGame_","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55849,"src":"23693:17:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"functionReturnParameters":55841,"id":55852,"nodeType":"Return","src":"23686:24:100"}]},"errorName":"","id":55854,"nodeType":"TryCatchClause","parameters":{"id":55850,"nodeType":"ParameterList","parameters":[{"constant":false,"id":55849,"mutability":"mutable","name":"faultDisputeGame_","nameLocation":"23653:17:100","nodeType":"VariableDeclaration","scope":55854,"src":"23645:25:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":55848,"name":"address","nodeType":"ElementaryTypeName","src":"23645:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"23644:27:100"},"src":"23636:85:100"},{"block":{"id":55860,"nodeType":"Block","src":"23728:42:100","statements":[{"expression":{"arguments":[{"hexValue":"30","id":55857,"isConstant":false,"isLValue":false,"isPure":true,"kind":"number","lValueRequested":false,"nodeType":"Literal","src":"23757:1:100","typeDescriptions":{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"},"value":"0"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"}],"id":55856,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"nodeType":"ElementaryTypeNameExpression","src":"23749:7:100","typeDescriptions":{"typeIdentifier":"t_type$_t_address_$","typeString":"type(address)"},"typeName":{"id":55855,"name":"address","nodeType":"ElementaryTypeName","src":"23749:7:100","typeDescriptions":{}}},"id":55858,"isConstant":false,"isLValue":false,"isPure":true,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"23749:10:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"functionReturnParameters":55841,"id":55859,"nodeType":"Return","src":"23742:17:100"}]},"errorName":"","id":55861,"nodeType":"TryCatchClause","src":"23722:48:100"}],"externalCall":{"arguments":[{"id":55846,"name":"_gameType","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55837,"src":"23625:9:100","typeDescriptions":{"typeIdentifier":"t_userDefinedValueType$_GameType_$70720","typeString":"GameType"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_userDefinedValueType$_GameType_$70720","typeString":"GameType"}],"expression":{"arguments":[{"id":55843,"name":"_disputeGameFactoryProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55834,"src":"23589:24:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_address","typeString":"address"}],"id":55842,"name":"IFetcher","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":53958,"src":"23580:8:100","typeDescriptions":{"typeIdentifier":"t_type$_t_contract$_IFetcher_$53958_$","typeString":"type(contract IFetcher)"}},"id":55844,"isConstant":false,"isLValue":false,"isPure":false,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"23580:34:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_contract$_IFetcher_$53958","typeString":"contract IFetcher"}},"id":55845,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"23615:9:100","memberName":"gameImpls","nodeType":"MemberAccess","referencedDeclaration":53886,"src":"23580:44:100","typeDescriptions":{"typeIdentifier":"t_function_external_view$_t_userDefinedValueType$_GameType_$70720_$returns$_t_address_$","typeString":"function (GameType) view external returns (address)"}},"id":55847,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"23580:55:100","tryCall":true,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"id":55862,"nodeType":"TryStatement","src":"23576:194:100"}]},"implemented":true,"kind":"function","modifiers":[],"name":"_getFaultDisputeGame","nameLocation":"23409:20:100","parameters":{"id":55838,"nodeType":"ParameterList","parameters":[{"constant":false,"id":55834,"mutability":"mutable","name":"_disputeGameFactoryProxy","nameLocation":"23447:24:100","nodeType":"VariableDeclaration","scope":55864,"src":"23439:32:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":55833,"name":"address","nodeType":"ElementaryTypeName","src":"23439:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"},{"constant":false,"id":55837,"mutability":"mutable","name":"_gameType","nameLocation":"23490:9:100","nodeType":"VariableDeclaration","scope":55864,"src":"23481:18:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_userDefinedValueType$_GameType_$70720","typeString":"GameType"},"typeName":{"id":55836,"nodeType":"UserDefinedTypeName","pathNode":{"id":55835,"name":"GameType","nameLocations":["23481:8:100"],"nodeType":"IdentifierPath","referencedDeclaration":70720,"src":"23481:8:100"},"referencedDeclaration":70720,"src":"23481:8:100","typeDescriptions":{"typeIdentifier":"t_userDefinedValueType$_GameType_$70720","typeString":"GameType"}},"visibility":"internal"}],"src":"23429:76:100"},"returnParameters":{"id":55841,"nodeType":"ParameterList","parameters":[{"constant":false,"id":55840,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":55864,"src":"23553:7:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":55839,"name":"address","nodeType":"ElementaryTypeName","src":"23553:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"23552:9:100"},"scope":56018,"stateMutability":"view","virtual":false,"visibility":"internal"},{"id":55894,"nodeType":"FunctionDefinition","src":"23782:369:100","nodes":[],"body":{"id":55893,"nodeType":"Block","src":"23885:266:100","nodes":[],"statements":[{"clauses":[{"block":{"id":55883,"nodeType":"Block","src":"24040:56:100","statements":[{"expression":{"id":55881,"name":"permissionedDisputeGame_","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55879,"src":"24061:24:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"functionReturnParameters":55870,"id":55882,"nodeType":"Return","src":"24054:31:100"}]},"errorName":"","id":55884,"nodeType":"TryCatchClause","parameters":{"id":55880,"nodeType":"ParameterList","parameters":[{"constant":false,"id":55879,"mutability":"mutable","name":"permissionedDisputeGame_","nameLocation":"24005:24:100","nodeType":"VariableDeclaration","scope":55884,"src":"23997:32:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":55878,"name":"address","nodeType":"ElementaryTypeName","src":"23997:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"23983:56:100"},"src":"23975:121:100"},{"block":{"id":55890,"nodeType":"Block","src":"24103:42:100","statements":[{"expression":{"arguments":[{"hexValue":"30","id":55887,"isConstant":false,"isLValue":false,"isPure":true,"kind":"number","lValueRequested":false,"nodeType":"Literal","src":"24132:1:100","typeDescriptions":{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"},"value":"0"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"}],"id":55886,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"nodeType":"ElementaryTypeNameExpression","src":"24124:7:100","typeDescriptions":{"typeIdentifier":"t_type$_t_address_$","typeString":"type(address)"},"typeName":{"id":55885,"name":"address","nodeType":"ElementaryTypeName","src":"24124:7:100","typeDescriptions":{}}},"id":55888,"isConstant":false,"isLValue":false,"isPure":true,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"24124:10:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"functionReturnParameters":55870,"id":55889,"nodeType":"Return","src":"24117:17:100"}]},"errorName":"","id":55891,"nodeType":"TryCatchClause","src":"24097:48:100"}],"externalCall":{"arguments":[{"expression":{"id":55875,"name":"GameTypes","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":70870,"src":"23944:9:100","typeDescriptions":{"typeIdentifier":"t_type$_t_contract$_GameTypes_$70870_$","typeString":"type(library GameTypes)"}},"id":55876,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"memberLocation":"23954:19:100","memberName":"PERMISSIONED_CANNON","nodeType":"MemberAccess","referencedDeclaration":70781,"src":"23944:29:100","typeDescriptions":{"typeIdentifier":"t_userDefinedValueType$_GameType_$70720","typeString":"GameType"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_userDefinedValueType$_GameType_$70720","typeString":"GameType"}],"expression":{"arguments":[{"id":55872,"name":"_disputeGameFactoryProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55866,"src":"23908:24:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_address","typeString":"address"}],"id":55871,"name":"IFetcher","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":53958,"src":"23899:8:100","typeDescriptions":{"typeIdentifier":"t_type$_t_contract$_IFetcher_$53958_$","typeString":"type(contract IFetcher)"}},"id":55873,"isConstant":false,"isLValue":false,"isPure":false,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"23899:34:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_contract$_IFetcher_$53958","typeString":"contract IFetcher"}},"id":55874,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"23934:9:100","memberName":"gameImpls","nodeType":"MemberAccess","referencedDeclaration":53886,"src":"23899:44:100","typeDescriptions":{"typeIdentifier":"t_function_external_view$_t_userDefinedValueType$_GameType_$70720_$returns$_t_address_$","typeString":"function (GameType) view external returns (address)"}},"id":55877,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"23899:75:100","tryCall":true,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"id":55892,"nodeType":"TryStatement","src":"23895:250:100"}]},"implemented":true,"kind":"function","modifiers":[],"name":"_getPermissionedDisputeGame","nameLocation":"23791:27:100","parameters":{"id":55867,"nodeType":"ParameterList","parameters":[{"constant":false,"id":55866,"mutability":"mutable","name":"_disputeGameFactoryProxy","nameLocation":"23827:24:100","nodeType":"VariableDeclaration","scope":55894,"src":"23819:32:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":55865,"name":"address","nodeType":"ElementaryTypeName","src":"23819:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"23818:34:100"},"returnParameters":{"id":55870,"nodeType":"ParameterList","parameters":[{"constant":false,"id":55869,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":55894,"src":"23876:7:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":55868,"name":"address","nodeType":"ElementaryTypeName","src":"23876:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"23875:9:100"},"scope":56018,"stateMutability":"view","virtual":false,"visibility":"internal"},{"id":55922,"nodeType":"FunctionDefinition","src":"24157:277:100","nodes":[],"body":{"id":55921,"nodeType":"Block","src":"24248:186:100","nodes":[],"statements":[{"clauses":[{"block":{"id":55911,"nodeType":"Block","src":"24336:43:100","statements":[{"expression":{"id":55909,"name":"ethLockbox_","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55907,"src":"24357:11:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"functionReturnParameters":55900,"id":55910,"nodeType":"Return","src":"24350:18:100"}]},"errorName":"","id":55912,"nodeType":"TryCatchClause","parameters":{"id":55908,"nodeType":"ParameterList","parameters":[{"constant":false,"id":55907,"mutability":"mutable","name":"ethLockbox_","nameLocation":"24323:11:100","nodeType":"VariableDeclaration","scope":55912,"src":"24315:19:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":55906,"name":"address","nodeType":"ElementaryTypeName","src":"24315:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"24314:21:100"},"src":"24306:73:100"},{"block":{"id":55918,"nodeType":"Block","src":"24386:42:100","statements":[{"expression":{"arguments":[{"hexValue":"30","id":55915,"isConstant":false,"isLValue":false,"isPure":true,"kind":"number","lValueRequested":false,"nodeType":"Literal","src":"24415:1:100","typeDescriptions":{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"},"value":"0"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"}],"id":55914,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"nodeType":"ElementaryTypeNameExpression","src":"24407:7:100","typeDescriptions":{"typeIdentifier":"t_type$_t_address_$","typeString":"type(address)"},"typeName":{"id":55913,"name":"address","nodeType":"ElementaryTypeName","src":"24407:7:100","typeDescriptions":{}}},"id":55916,"isConstant":false,"isLValue":false,"isPure":true,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"24407:10:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"functionReturnParameters":55900,"id":55917,"nodeType":"Return","src":"24400:17:100"}]},"errorName":"","id":55919,"nodeType":"TryCatchClause","src":"24380:48:100"}],"externalCall":{"arguments":[],"expression":{"argumentTypes":[],"expression":{"arguments":[{"id":55902,"name":"_optimismPortalProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55896,"src":"24271:20:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_address","typeString":"address"}],"id":55901,"name":"IFetcher","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":53958,"src":"24262:8:100","typeDescriptions":{"typeIdentifier":"t_type$_t_contract$_IFetcher_$53958_$","typeString":"type(contract IFetcher)"}},"id":55903,"isConstant":false,"isLValue":false,"isPure":false,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"24262:30:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_contract$_IFetcher_$53958","typeString":"contract IFetcher"}},"id":55904,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"24293:10:100","memberName":"ethLockbox","nodeType":"MemberAccess","referencedDeclaration":53843,"src":"24262:41:100","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":55905,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"24262:43:100","tryCall":true,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"id":55920,"nodeType":"TryStatement","src":"24258:170:100"}]},"implemented":true,"kind":"function","modifiers":[],"name":"_getEthLockboxProxy","nameLocation":"24166:19:100","parameters":{"id":55897,"nodeType":"ParameterList","parameters":[{"constant":false,"id":55896,"mutability":"mutable","name":"_optimismPortalProxy","nameLocation":"24194:20:100","nodeType":"VariableDeclaration","scope":55922,"src":"24186:28:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":55895,"name":"address","nodeType":"ElementaryTypeName","src":"24186:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"24185:30:100"},"returnParameters":{"id":55900,"nodeType":"ParameterList","parameters":[{"constant":false,"id":55899,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":55922,"src":"24239:7:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":55898,"name":"address","nodeType":"ElementaryTypeName","src":"24239:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"24238:9:100"},"scope":56018,"stateMutability":"view","virtual":false,"visibility":"internal"},{"id":55967,"nodeType":"FunctionDefinition","src":"24440:304:100","nodes":[],"body":{"id":55966,"nodeType":"Block","src":"24524:220:100","nodes":[],"statements":[{"assignments":[55930,55932],"declarations":[{"constant":false,"id":55930,"mutability":"mutable","name":"ok","nameLocation":"24540:2:100","nodeType":"VariableDeclaration","scope":55966,"src":"24535:7:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"},"typeName":{"id":55929,"name":"bool","nodeType":"ElementaryTypeName","src":"24535:4:100","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},"visibility":"internal"},{"constant":false,"id":55932,"mutability":"mutable","name":"data","nameLocation":"24557:4:100","nodeType":"VariableDeclaration","scope":55966,"src":"24544:17:100","stateVariable":false,"storageLocation":"memory","typeDescriptions":{"typeIdentifier":"t_bytes_memory_ptr","typeString":"bytes"},"typeName":{"id":55931,"name":"bytes","nodeType":"ElementaryTypeName","src":"24544:5:100","typeDescriptions":{"typeIdentifier":"t_bytes_storage_ptr","typeString":"bytes"}},"visibility":"internal"}],"id":55945,"initialValue":{"arguments":[{"arguments":[{"expression":{"id":55940,"name":"IFetcher","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":53958,"src":"24613:8:100","typeDescriptions":{"typeIdentifier":"t_type$_t_contract$_IFetcher_$53958_$","typeString":"type(contract IFetcher)"}},"id":55941,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"memberLocation":"24622:4:100","memberName":"weth","nodeType":"MemberAccess","referencedDeclaration":53957,"src":"24613:13:100","typeDescriptions":{"typeIdentifier":"t_function_declaration_view$__$returns$_t_address_$","typeString":"function IFetcher.weth() view returns (address)"}},{"components":[],"id":55942,"isConstant":false,"isInlineArray":false,"isLValue":false,"isPure":true,"lValueRequested":false,"nodeType":"TupleExpression","src":"24628:2:100","typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_function_declaration_view$__$returns$_t_address_$","typeString":"function IFetcher.weth() view returns (address)"},{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}],"expression":{"id":55938,"name":"abi","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":-1,"src":"24598:3:100","typeDescriptions":{"typeIdentifier":"t_magic_abi","typeString":"abi"}},"id":55939,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"memberLocation":"24602:10:100","memberName":"encodeCall","nodeType":"MemberAccess","src":"24598:14:100","typeDescriptions":{"typeIdentifier":"t_function_abiencodecall_pure$__$returns$_t_bytes_memory_ptr_$","typeString":"function () pure returns (bytes memory)"}},"id":55943,"isConstant":false,"isLValue":false,"isPure":true,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"24598:33:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_bytes_memory_ptr","typeString":"bytes memory"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_bytes_memory_ptr","typeString":"bytes memory"}],"expression":{"arguments":[{"id":55935,"name":"_disputeGame","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55924,"src":"24573:12:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_address","typeString":"address"}],"id":55934,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"nodeType":"ElementaryTypeNameExpression","src":"24565:7:100","typeDescriptions":{"typeIdentifier":"t_type$_t_address_$","typeString":"type(address)"},"typeName":{"id":55933,"name":"address","nodeType":"ElementaryTypeName","src":"24565:7:100","typeDescriptions":{}}},"id":55936,"isConstant":false,"isLValue":false,"isPure":false,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"24565:21:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"id":55937,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"24587:10:100","memberName":"staticcall","nodeType":"MemberAccess","src":"24565:32:100","typeDescriptions":{"typeIdentifier":"t_function_barestaticcall_view$_t_bytes_memory_ptr_$returns$_t_bool_$_t_bytes_memory_ptr_$","typeString":"function (bytes memory) view returns (bool,bytes memory)"}},"id":55944,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"24565:67:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$_t_bool_$_t_bytes_memory_ptr_$","typeString":"tuple(bool,bytes memory)"}},"nodeType":"VariableDeclarationStatement","src":"24534:98:100"},{"condition":{"commonType":{"typeIdentifier":"t_bool","typeString":"bool"},"id":55951,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftExpression":{"id":55946,"name":"ok","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55930,"src":"24646:2:100","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},"nodeType":"BinaryOperation","operator":"&&","rightExpression":{"commonType":{"typeIdentifier":"t_uint256","typeString":"uint256"},"id":55950,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftExpression":{"expression":{"id":55947,"name":"data","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55932,"src":"24652:4:100","typeDescriptions":{"typeIdentifier":"t_bytes_memory_ptr","typeString":"bytes memory"}},"id":55948,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"24657:6:100","memberName":"length","nodeType":"MemberAccess","src":"24652:11:100","typeDescriptions":{"typeIdentifier":"t_uint256","typeString":"uint256"}},"nodeType":"BinaryOperation","operator":"==","rightExpression":{"hexValue":"3332","id":55949,"isConstant":false,"isLValue":false,"isPure":true,"kind":"number","lValueRequested":false,"nodeType":"Literal","src":"24667:2:100","typeDescriptions":{"typeIdentifier":"t_rational_32_by_1","typeString":"int_const 32"},"value":"32"},"src":"24652:17:100","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},"src":"24646:23:100","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},"falseBody":{"expression":{"arguments":[{"hexValue":"30","id":55962,"isConstant":false,"isLValue":false,"isPure":true,"kind":"number","lValueRequested":false,"nodeType":"Literal","src":"24735:1:100","typeDescriptions":{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"},"value":"0"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"}],"id":55961,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"nodeType":"ElementaryTypeNameExpression","src":"24727:7:100","typeDescriptions":{"typeIdentifier":"t_type$_t_address_$","typeString":"type(address)"},"typeName":{"id":55960,"name":"address","nodeType":"ElementaryTypeName","src":"24727:7:100","typeDescriptions":{}}},"id":55963,"isConstant":false,"isLValue":false,"isPure":true,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"24727:10:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"functionReturnParameters":55928,"id":55964,"nodeType":"Return","src":"24720:17:100"},"id":55965,"nodeType":"IfStatement","src":"24642:95:100","trueBody":{"expression":{"arguments":[{"id":55954,"name":"data","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55932,"src":"24689:4:100","typeDescriptions":{"typeIdentifier":"t_bytes_memory_ptr","typeString":"bytes memory"}},{"components":[{"id":55956,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"nodeType":"ElementaryTypeNameExpression","src":"24696:7:100","typeDescriptions":{"typeIdentifier":"t_type$_t_address_$","typeString":"type(address)"},"typeName":{"id":55955,"name":"address","nodeType":"ElementaryTypeName","src":"24696:7:100","typeDescriptions":{}}}],"id":55957,"isConstant":false,"isInlineArray":false,"isLValue":false,"isPure":true,"lValueRequested":false,"nodeType":"TupleExpression","src":"24695:9:100","typeDescriptions":{"typeIdentifier":"t_type$_t_address_$","typeString":"type(address)"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_bytes_memory_ptr","typeString":"bytes memory"},{"typeIdentifier":"t_type$_t_address_$","typeString":"type(address)"}],"expression":{"id":55952,"name":"abi","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":-1,"src":"24678:3:100","typeDescriptions":{"typeIdentifier":"t_magic_abi","typeString":"abi"}},"id":55953,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"memberLocation":"24682:6:100","memberName":"decode","nodeType":"MemberAccess","src":"24678:10:100","typeDescriptions":{"typeIdentifier":"t_function_abidecode_pure$__$returns$__$","typeString":"function () pure"}},"id":55958,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"24678:27:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address_payable","typeString":"address payable"}},"functionReturnParameters":55928,"id":55959,"nodeType":"Return","src":"24671:34:100"}}]},"implemented":true,"kind":"function","modifiers":[],"name":"_getDelayedWETHProxy","nameLocation":"24449:20:100","parameters":{"id":55925,"nodeType":"ParameterList","parameters":[{"constant":false,"id":55924,"mutability":"mutable","name":"_disputeGame","nameLocation":"24478:12:100","nodeType":"VariableDeclaration","scope":55967,"src":"24470:20:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":55923,"name":"address","nodeType":"ElementaryTypeName","src":"24470:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"24469:22:100"},"returnParameters":{"id":55928,"nodeType":"ParameterList","parameters":[{"constant":false,"id":55927,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":55967,"src":"24515:7:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":55926,"name":"address","nodeType":"ElementaryTypeName","src":"24515:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"24514:9:100"},"scope":56018,"stateMutability":"view","virtual":false,"visibility":"internal"},{"id":55994,"nodeType":"FunctionDefinition","src":"24750:224:100","nodes":[],"body":{"id":55993,"nodeType":"Block","src":"24838:136:100","nodes":[],"statements":[{"assignments":[55975],"declarations":[{"constant":false,"id":55975,"mutability":"mutable","name":"batcherHash","nameLocation":"24856:11:100","nodeType":"VariableDeclaration","scope":55993,"src":"24848:19:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_bytes32","typeString":"bytes32"},"typeName":{"id":55974,"name":"bytes32","nodeType":"ElementaryTypeName","src":"24848:7:100","typeDescriptions":{"typeIdentifier":"t_bytes32","typeString":"bytes32"}},"visibility":"internal"}],"id":55981,"initialValue":{"arguments":[],"expression":{"argumentTypes":[],"expression":{"arguments":[{"id":55977,"name":"_systemConfigProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55969,"src":"24879:18:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_address","typeString":"address"}],"id":55976,"name":"IFetcher","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":53958,"src":"24870:8:100","typeDescriptions":{"typeIdentifier":"t_type$_t_contract$_IFetcher_$53958_$","typeString":"type(contract IFetcher)"}},"id":55978,"isConstant":false,"isLValue":false,"isPure":false,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"24870:28:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_contract$_IFetcher_$53958","typeString":"contract IFetcher"}},"id":55979,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"24899:11:100","memberName":"batcherHash","nodeType":"MemberAccess","referencedDeclaration":53937,"src":"24870:40:100","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_bytes32_$","typeString":"function () view external returns (bytes32)"}},"id":55980,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"24870:42:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_bytes32","typeString":"bytes32"}},"nodeType":"VariableDeclarationStatement","src":"24848:64:100"},{"expression":{"arguments":[{"arguments":[{"arguments":[{"id":55988,"name":"batcherHash","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55975,"src":"24953:11:100","typeDescriptions":{"typeIdentifier":"t_bytes32","typeString":"bytes32"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_bytes32","typeString":"bytes32"}],"id":55987,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"nodeType":"ElementaryTypeNameExpression","src":"24945:7:100","typeDescriptions":{"typeIdentifier":"t_type$_t_uint256_$","typeString":"type(uint256)"},"typeName":{"id":55986,"name":"uint256","nodeType":"ElementaryTypeName","src":"24945:7:100","typeDescriptions":{}}},"id":55989,"isConstant":false,"isLValue":false,"isPure":false,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"24945:20:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_uint256","typeString":"uint256"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_uint256","typeString":"uint256"}],"id":55985,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"nodeType":"ElementaryTypeNameExpression","src":"24937:7:100","typeDescriptions":{"typeIdentifier":"t_type$_t_uint160_$","typeString":"type(uint160)"},"typeName":{"id":55984,"name":"uint160","nodeType":"ElementaryTypeName","src":"24937:7:100","typeDescriptions":{}}},"id":55990,"isConstant":false,"isLValue":false,"isPure":false,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"24937:29:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_uint160","typeString":"uint160"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_uint160","typeString":"uint160"}],"id":55983,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"nodeType":"ElementaryTypeNameExpression","src":"24929:7:100","typeDescriptions":{"typeIdentifier":"t_type$_t_address_$","typeString":"type(address)"},"typeName":{"id":55982,"name":"address","nodeType":"ElementaryTypeName","src":"24929:7:100","typeDescriptions":{}}},"id":55991,"isConstant":false,"isLValue":false,"isPure":false,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"24929:38:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"functionReturnParameters":55973,"id":55992,"nodeType":"Return","src":"24922:45:100"}]},"implemented":true,"kind":"function","modifiers":[],"name":"_getBatchSubmitter","nameLocation":"24759:18:100","parameters":{"id":55970,"nodeType":"ParameterList","parameters":[{"constant":false,"id":55969,"mutability":"mutable","name":"_systemConfigProxy","nameLocation":"24786:18:100","nodeType":"VariableDeclaration","scope":55994,"src":"24778:26:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":55968,"name":"address","nodeType":"ElementaryTypeName","src":"24778:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"24777:28:100"},"returnParameters":{"id":55973,"nodeType":"ParameterList","parameters":[{"constant":false,"id":55972,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":55994,"src":"24829:7:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":55971,"name":"address","nodeType":"ElementaryTypeName","src":"24829:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"24828:9:100"},"scope":56018,"stateMutability":"view","virtual":false,"visibility":"internal"},{"id":56017,"nodeType":"FunctionDefinition","src":"24980:169:100","nodes":[],"body":{"id":56016,"nodeType":"Block","src":"25059:90:100","nodes":[],"statements":[{"expression":{"arguments":[{"arguments":[{"hexValue":"30","id":56006,"isConstant":false,"isLValue":false,"isPure":true,"kind":"number","lValueRequested":false,"nodeType":"Literal","src":"25086:1:100","typeDescriptions":{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"},"value":"0"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"}],"id":56005,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"nodeType":"ElementaryTypeNameExpression","src":"25078:7:100","typeDescriptions":{"typeIdentifier":"t_type$_t_address_$","typeString":"type(address)"},"typeName":{"id":56004,"name":"address","nodeType":"ElementaryTypeName","src":"25078:7:100","typeDescriptions":{}}},"id":56007,"isConstant":false,"isLValue":false,"isPure":true,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"25078:10:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_address","typeString":"address"}],"expression":{"id":56001,"name":"vm","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":5501,"src":"25069:2:100","typeDescriptions":{"typeIdentifier":"t_contract$_Vm_$23288","typeString":"contract Vm"}},"id":56003,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"25072:5:100","memberName":"prank","nodeType":"MemberAccess","referencedDeclaration":22581,"src":"25069:8:100","typeDescriptions":{"typeIdentifier":"t_function_external_nonpayable$_t_address_$returns$__$","typeString":"function (address) external"}},"id":56008,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"25069:20:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":56009,"nodeType":"ExpressionStatement","src":"25069:20:100"},{"expression":{"arguments":[],"expression":{"argumentTypes":[],"expression":{"arguments":[{"id":56011,"name":"_systemConfigProxy","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":55996,"src":"25115:18:100","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_address","typeString":"address"}],"id":56010,"name":"IFetcher","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":53958,"src":"25106:8:100","typeDescriptions":{"typeIdentifier":"t_type$_t_contract$_IFetcher_$53958_$","typeString":"type(contract IFetcher)"}},"id":56012,"isConstant":false,"isLValue":false,"isPure":false,"kind":"typeConversion","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"25106:28:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_contract$_IFetcher_$53958","typeString":"contract IFetcher"}},"id":56013,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberLocation":"25135:5:100","memberName":"admin","nodeType":"MemberAccess","referencedDeclaration":53942,"src":"25106:34:100","typeDescriptions":{"typeIdentifier":"t_function_external_view$__$returns$_t_address_$","typeString":"function () view external returns (address)"}},"id":56014,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"25106:36:100","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"functionReturnParameters":56000,"id":56015,"nodeType":"Return","src":"25099:43:100"}]},"implemented":true,"kind":"function","modifiers":[],"name":"_getProxyAdmin","nameLocation":"24989:14:100","parameters":{"id":55997,"nodeType":"ParameterList","parameters":[{"constant":false,"id":55996,"mutability":"mutable","name":"_systemConfigProxy","nameLocation":"25012:18:100","nodeType":"VariableDeclaration","scope":56017,"src":"25004:26:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":55995,"name":"address","nodeType":"ElementaryTypeName","src":"25004:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"25003:28:100"},"returnParameters":{"id":56000,"nodeType":"ParameterList","parameters":[{"constant":false,"id":55999,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":56017,"src":"25050:7:100","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":55998,"name":"address","nodeType":"ElementaryTypeName","src":"25050:7:100","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"25049:9:100"},"scope":56018,"stateMutability":"nonpayable","virtual":false,"visibility":"internal"}],"abstract":false,"baseContracts":[{"baseName":{"id":54912,"name":"Script","nameLocations":["13628:6:100"],"nodeType":"IdentifierPath","referencedDeclaration":5558,"src":"13628:6:100"},"id":54913,"nodeType":"InheritanceSpecifier","src":"13628:6:100"}],"canonicalName":"FetchChainInfo","contractDependencies":[],"contractKind":"contract","fullyImplemented":true,"linearizedBaseContracts":[56018,5558,18381,11222,9132,5517,5505],"name":"FetchChainInfo","nameLocation":"13610:14:100","scope":56019,"usedErrors":[],"usedEvents":[]}],"license":"MIT"},"id":100} \ No newline at end of file diff --git a/packages/contracts-bedrock/scripts/FetchChainInfo.s.sol b/packages/contracts-bedrock/scripts/FetchChainInfo.s.sol index 80d00d2a77d..9fa8cbd33a5 100644 --- a/packages/contracts-bedrock/scripts/FetchChainInfo.s.sol +++ b/packages/contracts-bedrock/scripts/FetchChainInfo.s.sol @@ -82,6 +82,7 @@ contract FetchChainInfoOutput { address internal _delayedWethPermissionlessGameProxy; address internal _disputeGameFactoryProxy; address internal _faultDisputeGameImpl; + address internal _faultDisputeGameCannonKonaImpl; address internal _permissionedDisputeGameImpl; // roles @@ -120,6 +121,7 @@ contract FetchChainInfoOutput { else if (_sel == this.delayedWethPermissionlessGameProxy.selector) _delayedWethPermissionlessGameProxy = _addr; else if (_sel == this.disputeGameFactoryProxy.selector) _disputeGameFactoryProxy = _addr; else if (_sel == this.faultDisputeGameImpl.selector) _faultDisputeGameImpl = _addr; + else if (_sel == this.faultDisputeGameCannonKonaImpl.selector) _faultDisputeGameCannonKonaImpl = _addr; else if (_sel == this.permissionedDisputeGameImpl.selector) _permissionedDisputeGameImpl = _addr; // roles else if (_sel == this.systemConfigOwner.selector) _systemConfigOwner = _addr; @@ -222,6 +224,14 @@ contract FetchChainInfoOutput { return _faultDisputeGameImpl; } + function faultDisputeGameCannonKonaImpl() public view returns (address) { + require( + _faultDisputeGameCannonKonaImpl != address(0), + "FetchChainInfoOutput: faultDisputeGameCannonKonaImpl not set" + ); + return _faultDisputeGameCannonKonaImpl; + } + function mipsImpl() public view returns (address) { require(_mipsImpl != address(0), "FetchChainInfoOutput: mipsImpl not set"); return _mipsImpl; @@ -394,7 +404,7 @@ contract FetchChainInfo is Script { _fo.set(_fo.preimageOracleImpl.selector, preimageOracleImpl); } - address faultDisputeGameImpl = _getFaultDisputeGame(disputeGameFactoryProxy); + address faultDisputeGameImpl = _getFaultDisputeGame(disputeGameFactoryProxy, GameTypes.CANNON); if (faultDisputeGameImpl != address(0)) { // permissionless fault proofs installed _fo.set(_fo.faultDisputeGameImpl.selector, faultDisputeGameImpl); @@ -403,6 +413,13 @@ contract FetchChainInfo is Script { address delayedWethPermissionlessGameProxy = _getDelayedWETHProxy(faultDisputeGameImpl); _fo.set(_fo.delayedWethPermissionlessGameProxy.selector, delayedWethPermissionlessGameProxy); } + + address faultDisputeGameCannonKonaImpl = + _getFaultDisputeGame(disputeGameFactoryProxy, GameTypes.CANNON_KONA); + if (faultDisputeGameCannonKonaImpl != address(0)) { + _fo.set(_fo.faultDisputeGameCannonKonaImpl.selector, faultDisputeGameCannonKonaImpl); + // if we have CANNON_KONA, we must also have CANNON + } } else { // some older chains have L2OutputOracle instead of DisputeGameFactory. address l2OutputOracleProxy = IFetcher(optimismPortalProxy).L2_ORACLE(); @@ -477,8 +494,15 @@ contract FetchChainInfo is Script { } } - function _getFaultDisputeGame(address _disputeGameFactoryProxy) internal view returns (address) { - try IFetcher(_disputeGameFactoryProxy).gameImpls(GameTypes.CANNON) returns (address faultDisputeGame_) { + function _getFaultDisputeGame( + address _disputeGameFactoryProxy, + GameType _gameType + ) + internal + view + returns (address) + { + try IFetcher(_disputeGameFactoryProxy).gameImpls(_gameType) returns (address faultDisputeGame_) { return faultDisputeGame_; } catch { return address(0); diff --git a/packages/contracts-bedrock/test/scripts/FetchChainInfo.t.sol b/packages/contracts-bedrock/test/scripts/FetchChainInfo.t.sol index 69f743a37f9..95a93038751 100644 --- a/packages/contracts-bedrock/test/scripts/FetchChainInfo.t.sol +++ b/packages/contracts-bedrock/test/scripts/FetchChainInfo.t.sol @@ -168,6 +168,12 @@ contract PermissionlessDisputeGameMock is ModernMockContract { } } +contract PermissionlessCannonKonaDisputeGameMock is ModernMockContract { + function weth() external pure returns (address) { + return WETH_PERMISSIONLESS; + } +} + contract OracleMock is ModernMockContract { address public oracle; @@ -199,6 +205,7 @@ contract FetchChainInfoTest is Test { address superchainConfig; address permissionedGame; address permissionlessGame; + address permissionlessCannonKonaGame; address l2OutputOracle; address mips; address preimageOracle; @@ -335,53 +342,11 @@ contract FetchChainInfoTest is Test { } function test_modernPermissionless_succeeds() public { - TestContext memory ctx = _prepareModernTestContext(); - - ctx.disputeGameFactory = address(new DisputeGameFactoryMock()); - ctx.permissionedGame = address(new PermissionedDisputeGameMock()); - ctx.permissionlessGame = address(new PermissionlessDisputeGameMock()); - ctx.superchainConfig = address(new ModernMockContract()); - ctx.mips = address(new OracleMock()); - ctx.preimageOracle = address(new ModernMockContract()); - ctx.anchorStateRegistry = address(new ModernMockContract()); - - ModernMockContract(payable(ctx.l1StandardBridgeProxy)).set_messenger(ctx.l1CrossDomainMessenger); - ModernMockContract(payable(ctx.l1CrossDomainMessenger)).set_portal(ctx.optimismPortal); - ModernMockContract(payable(ctx.systemConfigProxy)).set_disputeGameFactory(ctx.disputeGameFactory); - ModernMockContract(payable(ctx.optimismPortal)).set_superchainConfig(ctx.superchainConfig); - ModernMockContract(payable(ctx.optimismPortal)).set_guardian(TEST_GUARDIAN); - ModernMockContract(payable(ctx.optimismPortal)).set_systemConfig(ctx.systemConfigProxy); - - DisputeGameFactoryMock(payable(ctx.disputeGameFactory)).set_gameImpl(GameTypes.CANNON, ctx.permissionlessGame); - DisputeGameFactoryMock(payable(ctx.disputeGameFactory)).set_gameImpl( - GameTypes.PERMISSIONED_CANNON, ctx.permissionedGame - ); - - PermissionedDisputeGameMock(payable(ctx.permissionedGame)).set_challenger(TEST_CHALLENGER); - PermissionedDisputeGameMock(payable(ctx.permissionedGame)).set_proposer(TEST_PROPOSER); - PermissionedDisputeGameMock(payable(ctx.permissionedGame)).set_vm(ctx.mips); - PermissionedDisputeGameMock(payable(ctx.permissionedGame)).set_anchorStateRegistry(ctx.anchorStateRegistry); - - OracleMock(payable(ctx.mips)).set_oracle(ctx.preimageOracle); - - _setupAddressManagerSlot(ctx.l1CrossDomainMessenger, TEST_ADDRESS_MANAGER); - - fetchChainInfo = new FetchChainInfo(); - fetchChainInfo.run(ctx.input, ctx.output); - - assertEq(ctx.output.systemConfigProxy(), ctx.systemConfigProxy, "SystemConfig should match"); - assertEq(ctx.output.disputeGameFactoryProxy(), ctx.disputeGameFactory, "DisputeGameFactory should match"); - assertEq(ctx.output.opChainGuardian(), TEST_GUARDIAN, "OpChainGuardian should match"); - assertEq(ctx.output.permissionedDisputeGameImpl(), ctx.permissionedGame, "PermissionedDisputeGame should match"); - assertEq(ctx.output.faultDisputeGameImpl(), ctx.permissionlessGame, "FaultDisputeGame should match"); - assertEq(ctx.output.challenger(), TEST_CHALLENGER, "Challenger should match"); - assertEq(ctx.output.proposer(), TEST_PROPOSER, "Proposer should match"); - assertEq(ctx.output.mipsImpl(), ctx.mips, "MIPS should match"); - assertEq(ctx.output.preimageOracleImpl(), ctx.preimageOracle, "PreimageOracle should match"); - assertEq(ctx.output.anchorStateRegistryProxy(), ctx.anchorStateRegistry, "AnchorStateRegistry should match"); + _test_modernPermissionless_succeeds(false); + } - assertTrue(ctx.output.permissioned(), "Permissioned proofs should be enabled"); - assertTrue(ctx.output.permissionless(), "Permissionless proofs should be enabled"); + function test_modernPermissionlessCannonKona_succeeds() public { + _test_modernPermissionless_succeeds(true); } // Test to verify fallback mechanism for guardian() to GUARDIAN() @@ -452,12 +417,24 @@ contract FetchChainInfoTest is Test { // Test delayedWETH mechanism for permissioned and permissionless games function test_delayedWeth_succeeds() public { + _test_delayedWeth_succeeds(false); + } + + // Test delayedWETH mechanism for permissioned and permissionless games + function test_delayedWethWithCannonKona_succeeds() public { + _test_delayedWeth_succeeds(true); + } + + function _test_delayedWeth_succeeds(bool _withCannonKona) internal { TestContext memory ctx = _prepareModernTestContext(); // Setup dispute game factory with both game types ctx.disputeGameFactory = address(new DisputeGameFactoryMock()); ctx.permissionedGame = address(new PermissionedDisputeGameMock()); ctx.permissionlessGame = address(new PermissionlessDisputeGameMock()); + if (_withCannonKona) { + ctx.permissionlessCannonKonaGame = address(new PermissionlessCannonKonaDisputeGameMock()); + } ctx.mips = address(new OracleMock()); ModernMockContract(payable(ctx.l1StandardBridgeProxy)).set_messenger(ctx.l1CrossDomainMessenger); @@ -465,6 +442,11 @@ contract FetchChainInfoTest is Test { ModernMockContract(payable(ctx.systemConfigProxy)).set_disputeGameFactory(ctx.disputeGameFactory); DisputeGameFactoryMock(payable(ctx.disputeGameFactory)).set_gameImpl(GameTypes.CANNON, ctx.permissionlessGame); + if (_withCannonKona) { + DisputeGameFactoryMock(payable(ctx.disputeGameFactory)).set_gameImpl( + GameTypes.CANNON_KONA, ctx.permissionlessCannonKonaGame + ); + } DisputeGameFactoryMock(payable(ctx.disputeGameFactory)).set_gameImpl( GameTypes.PERMISSIONED_CANNON, ctx.permissionedGame ); @@ -487,4 +469,69 @@ contract FetchChainInfoTest is Test { ctx.output.delayedWethPermissionlessGameProxy(), WETH_PERMISSIONLESS, "PermissionlessGame WETH should match" ); } + + function _test_modernPermissionless_succeeds(bool _withCannonKona) internal { + TestContext memory ctx = _prepareModernTestContext(); + + ctx.disputeGameFactory = address(new DisputeGameFactoryMock()); + ctx.permissionedGame = address(new PermissionedDisputeGameMock()); + ctx.permissionlessGame = address(new PermissionlessDisputeGameMock()); + if (_withCannonKona) { + ctx.permissionlessCannonKonaGame = address(new PermissionlessCannonKonaDisputeGameMock()); + } + ctx.superchainConfig = address(new ModernMockContract()); + ctx.mips = address(new OracleMock()); + ctx.preimageOracle = address(new ModernMockContract()); + ctx.anchorStateRegistry = address(new ModernMockContract()); + + ModernMockContract(payable(ctx.l1StandardBridgeProxy)).set_messenger(ctx.l1CrossDomainMessenger); + ModernMockContract(payable(ctx.l1CrossDomainMessenger)).set_portal(ctx.optimismPortal); + ModernMockContract(payable(ctx.systemConfigProxy)).set_disputeGameFactory(ctx.disputeGameFactory); + ModernMockContract(payable(ctx.optimismPortal)).set_superchainConfig(ctx.superchainConfig); + ModernMockContract(payable(ctx.optimismPortal)).set_guardian(TEST_GUARDIAN); + ModernMockContract(payable(ctx.optimismPortal)).set_systemConfig(ctx.systemConfigProxy); + + DisputeGameFactoryMock(payable(ctx.disputeGameFactory)).set_gameImpl(GameTypes.CANNON, ctx.permissionlessGame); + if (_withCannonKona) { + DisputeGameFactoryMock(payable(ctx.disputeGameFactory)).set_gameImpl( + GameTypes.CANNON_KONA, ctx.permissionlessCannonKonaGame + ); + } + DisputeGameFactoryMock(payable(ctx.disputeGameFactory)).set_gameImpl( + GameTypes.PERMISSIONED_CANNON, ctx.permissionedGame + ); + + PermissionedDisputeGameMock(payable(ctx.permissionedGame)).set_challenger(TEST_CHALLENGER); + PermissionedDisputeGameMock(payable(ctx.permissionedGame)).set_proposer(TEST_PROPOSER); + PermissionedDisputeGameMock(payable(ctx.permissionedGame)).set_vm(ctx.mips); + PermissionedDisputeGameMock(payable(ctx.permissionedGame)).set_anchorStateRegistry(ctx.anchorStateRegistry); + + OracleMock(payable(ctx.mips)).set_oracle(ctx.preimageOracle); + + _setupAddressManagerSlot(ctx.l1CrossDomainMessenger, TEST_ADDRESS_MANAGER); + + fetchChainInfo = new FetchChainInfo(); + fetchChainInfo.run(ctx.input, ctx.output); + + assertEq(ctx.output.systemConfigProxy(), ctx.systemConfigProxy, "SystemConfig should match"); + assertEq(ctx.output.disputeGameFactoryProxy(), ctx.disputeGameFactory, "DisputeGameFactory should match"); + assertEq(ctx.output.opChainGuardian(), TEST_GUARDIAN, "OpChainGuardian should match"); + assertEq(ctx.output.permissionedDisputeGameImpl(), ctx.permissionedGame, "PermissionedDisputeGame should match"); + assertEq(ctx.output.faultDisputeGameImpl(), ctx.permissionlessGame, "FaultDisputeGame should match"); + if (_withCannonKona) { + assertEq( + ctx.output.faultDisputeGameCannonKonaImpl(), + ctx.permissionlessCannonKonaGame, + "FaultDisputeGameCannonKona should match" + ); + } + assertEq(ctx.output.challenger(), TEST_CHALLENGER, "Challenger should match"); + assertEq(ctx.output.proposer(), TEST_PROPOSER, "Proposer should match"); + assertEq(ctx.output.mipsImpl(), ctx.mips, "MIPS should match"); + assertEq(ctx.output.preimageOracleImpl(), ctx.preimageOracle, "PreimageOracle should match"); + assertEq(ctx.output.anchorStateRegistryProxy(), ctx.anchorStateRegistry, "AnchorStateRegistry should match"); + + assertTrue(ctx.output.permissioned(), "Permissioned proofs should be enabled"); + assertTrue(ctx.output.permissionless(), "Permissionless proofs should be enabled"); + } } From 3fac5612072cb16adcf9482249886a5b814237d5 Mon Sep 17 00:00:00 2001 From: Axel Kingsley Date: Fri, 17 Oct 2025 15:06:34 -0500 Subject: [PATCH 086/117] op-conductor: use op-service HTTP Server for Flashblocks ; fix test flake (#17880) * Expose bound port of conductor ; allow port assignment ; fix test * PR Comments * Use OP-Service HTTPServer * add requested panic * PR Comments --- op-conductor/conductor/service.go | 4 +- op-conductor/conductor/service_test.go | 23 ++++----- op-conductor/rpc/ws/flashblocks_handler.go | 54 +++++++++++++--------- 3 files changed, 45 insertions(+), 36 deletions(-) diff --git a/op-conductor/conductor/service.go b/op-conductor/conductor/service.go index b9f25710c6b..33a23fea720 100644 --- a/op-conductor/conductor/service.go +++ b/op-conductor/conductor/service.go @@ -325,8 +325,8 @@ func (oc *OpConductor) initRPCServer(ctx context.Context) error { // initFlashblocksHandler initializes the flashblocks handler func (c *OpConductor) initFlashblocksHandler(ctx context.Context) error { - if c.cfg.RollupBoostWsURL == "" || c.cfg.WebsocketServerPort <= 0 { - c.log.Info("flashblocks handler disabled, no rollup boost URL or websocket server port configured") + if c.cfg.RollupBoostWsURL == "" { + c.log.Info("flashblocks handler disabled, no rollup boost URL configured") return nil } diff --git a/op-conductor/conductor/service_test.go b/op-conductor/conductor/service_test.go index d42289d08d4..91b5903734a 100644 --- a/op-conductor/conductor/service_test.go +++ b/op-conductor/conductor/service_test.go @@ -5,7 +5,6 @@ import ( "errors" "fmt" "math/big" - "net" "net/http" "net/http/httptest" "strings" @@ -984,11 +983,6 @@ func (s *OpConductorTestSuite) TestSupervisorConnectionDown() { // TestFlashblocksHandlerIntegration tests that the flashblocks handler is properly initialized and started func (s *OpConductorTestSuite) TestFlashblocksHandlerIntegration() { - // Use a random available port to avoid conflicts - listener, err := net.Listen("tcp", "localhost:0") - s.NoError(err) - port := listener.Addr().(*net.TCPAddr).Port - listener.Close() // Channels for coordination without timing dependencies testCtx, testCancel := context.WithCancel(context.Background()) @@ -1070,7 +1064,8 @@ func (s *OpConductorTestSuite) TestFlashblocksHandlerIntegration() { // Create a copy of the config to avoid modifying the shared config object testCfg := s.cfg testCfg.RollupBoostWsURL = rollupBoostWsURL - testCfg.WebsocketServerPort = port + // Bind port dynamically via handler (use port 0) + testCfg.WebsocketServerPort = 0 // Create a new conductor with the updated config conductor, err := NewOpConductor(s.ctx, &testCfg, s.log, s.metrics, s.version, s.ctrl, s.cons, s.hmon) @@ -1082,11 +1077,13 @@ func (s *OpConductorTestSuite) TestFlashblocksHandlerIntegration() { // Start the conductor, which should initialize and start the flashblocks handler s.hmon.EXPECT().Start(mock.Anything).Return(nil) + + s.NotNil(conductor.flashblocksHandler, "flashblocks handler should be initialized before starting the conductor") err = conductor.Start(s.ctx) s.NoError(err) - // Wait for conductor to be ready using its internal state - s.NotNil(conductor.flashblocksHandler, "flashblocks handler should be initialized") + boundPort := conductor.flashblocksHandler.BoundPort() + s.NotZero(boundPort, "bound port should be non-zero") // Wait for rollup boost server connection (event-driven, not time-based) select { @@ -1097,10 +1094,10 @@ func (s *OpConductorTestSuite) TestFlashblocksHandlerIntegration() { } // Connect to the WebSocket server BEFORE messages are sent - wsURL := fmt.Sprintf("ws://localhost:%d/ws", testCfg.WebsocketServerPort) + wsURL := fmt.Sprintf("ws://127.0.0.1:%d/ws", boundPort) // Create connection context - connCtx, connCancel := context.WithTimeout(testCtx, 3*time.Second) + connCtx, connCancel := context.WithTimeout(testCtx, 10*time.Second) defer connCancel() var client *websocket.Conn @@ -1123,7 +1120,7 @@ func (s *OpConductorTestSuite) TestFlashblocksHandlerIntegration() { select { case <-connCtx.Done(): s.Failf("Failed to connect to WebSocket server", "Last error: %v", err) - case <-time.After(10 * time.Millisecond): + case <-time.After(25 * time.Millisecond): // Continue loop } } @@ -1148,7 +1145,7 @@ connected: receivedMessages := make([]string, 0, len(expectedMessages)) // Read messages with timeout - readCtx, readCancel := context.WithTimeout(testCtx, 3*time.Second) + readCtx, readCancel := context.WithTimeout(testCtx, 10*time.Second) defer readCancel() for len(receivedMessages) < len(expectedMessages) { diff --git a/op-conductor/rpc/ws/flashblocks_handler.go b/op-conductor/rpc/ws/flashblocks_handler.go index 31f66280692..c58a86bfb2f 100644 --- a/op-conductor/rpc/ws/flashblocks_handler.go +++ b/op-conductor/rpc/ws/flashblocks_handler.go @@ -10,6 +10,7 @@ import ( "github.com/coder/websocket" "github.com/ethereum-optimism/optimism/op-conductor/metrics" + "github.com/ethereum-optimism/optimism/op-service/httputil" "github.com/ethereum-optimism/optimism/op-service/retry" "github.com/ethereum/go-ethereum/log" ) @@ -35,6 +36,8 @@ type FlashblockHandler interface { Stop() // BroadcastMessage sends a message to all connected WebSocket clients BroadcastMessage(message []byte) + // BoundPort returns the actual TCP port the server is bound to + BoundPort() int } // Config contains configuration for the flashblocks handler @@ -54,16 +57,20 @@ type Handler struct { rollupBoostConn *websocket.Conn rollupBoostCtx context.Context rollupBoostWsCancel context.CancelFunc - server *http.Server + httpServer *httputil.HTTPServer hub *Hub + boundPort int } // NewHandler creates a new flashblocks handler func NewHandler(cfg Config, log log.Logger, isLeaderFn func(context.Context) bool, m metrics.Metricer) (FlashblockHandler, error) { // Validate configuration - if cfg.RollupBoostWsURL == "" || cfg.WebsocketServerPort <= 0 { - log.Error("rollup boost WebSocket URL or websocket server port not configured") - return nil, errors.New("rollup boost WebSocket URL or websocket server port not configured") + if cfg.RollupBoostWsURL == "" { + log.Error("rollup boost WebSocket URL not configured") + return nil, errors.New("rollup boost WebSocket URL not configured") + } + if cfg.WebsocketServerPort < 0 { + return nil, fmt.Errorf("WebSocket server port invalid: %d", cfg.WebsocketServerPort) } // Initialize the handler @@ -129,13 +136,11 @@ func (h *Handler) Stop() { } // Close the HTTP server if it's running - if h.server != nil { + if h.httpServer != nil { h.log.Info("closing WebSocket server") ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second) defer cancel() - - err := h.server.Shutdown(ctx) - if err != nil { + if err := h.httpServer.Stop(ctx); err != nil { h.log.Error("Error shutting down WebSocket server", "err", err) } h.log.Info("WebSocket server closed") @@ -148,10 +153,9 @@ func (h *Handler) BroadcastMessage(message []byte) { } func (h *Handler) startWebSocketServer(_ context.Context) error { - if h.cfg.WebsocketServerPort <= 0 { - return fmt.Errorf("WebSocket server port not configured or invalid: %d", h.cfg.WebsocketServerPort) + if h.cfg.WebsocketServerPort < 0 { + return fmt.Errorf("WebSocket server port invalid: %d", h.cfg.WebsocketServerPort) } - h.hub = newHub(h.metrics) go h.hub.run() @@ -159,22 +163,30 @@ func (h *Handler) startWebSocketServer(_ context.Context) error { mux := http.NewServeMux() mux.HandleFunc("/ws", h.handleWebSocket) - // Start HTTP server - h.server = &http.Server{ - Addr: fmt.Sprintf(":%d", h.cfg.WebsocketServerPort), - Handler: mux, + // Start HTTP server using reusable httputil server (supports port=0 and exposes Port()) + addr := fmt.Sprintf(":%d", h.cfg.WebsocketServerPort) + srv, err := httputil.StartHTTPServer(addr, mux) + if err != nil { + return err + } + h.httpServer = srv + // Determine bound port + if port, err := h.httpServer.Port(); err == nil { + h.boundPort = port + } else { + return fmt.Errorf("failed to determine bound port: %w", err) } - h.log.Info("starting WebSocket server", "port", h.cfg.WebsocketServerPort) - go func() { - if err := h.server.ListenAndServe(); err != nil && !errors.Is(err, http.ErrServerClosed) { - h.log.Error("WebSocket server error", "err", err) - } - }() + h.log.Info("starting WebSocket server", "port", h.boundPort) return nil } +// BoundPort returns the actual TCP port the server is bound to. +func (h *Handler) BoundPort() int { + return h.boundPort +} + // handleWebSocket handles WebSocket upgrade requests func (h *Handler) handleWebSocket(w http.ResponseWriter, r *http.Request) { h.serveWs(w, r) From 7221832a7a030c390e2dd1ce632bb87737fa8bab Mon Sep 17 00:00:00 2001 From: Maurelian Date: Fri, 17 Oct 2025 20:20:03 -0400 Subject: [PATCH 087/117] Disable the guard upon ownership transfer (#17808) * Add SaferSafes as child of the module and guard * Add ISaferSafes * Test comment and assertion fixes * Improve comments * Make LivenessModule2 and TimelockGuard abstract Move semver to SaferSafes semver lock * fix test contract name * Move semver to SaferSafes * Disable the guard and module upon ownership transfer * Add _disableThisGuard function * Update tests * Add config resets * fmt * fix test_changeOwnershipToFallback_canRechallenge_succeeds * Simplify by clearing config directly * Put _disableThisGuard into child contract * Add timelockDelay reset on _disableThisGuard * semver-lock * Move _disableThisGuard logic into TimelockGuard * clear livenessSafeConfig at tend of _disableThisModule * Clarify use of SENTINEL_OWNER * Fix the ordering of the disableGuard and disableModule calls * semver-lock * remove unused imports * rename _disableThisGuard to _disableGuard * bump semver * Add test to remove unrelated guard * Add SENTINEL_MODULE constant * Clean up using ternary if * Reset cancellationThreshold to 0 on changeOwnership * Fix moduleFound if/else handling * Clear pending transactions * Pre-pr fixes * Add test contract to test name lint exclusions * fix name of test contract * Move _disableGuard impl into TimelockGuard * Add missing natspec * Add gas limit testing on changeOwnershipToFallback * Remove interfaces for abstract contracts * Move state changes out into internal _clearLivenessModule * Improve names on the internal _disableX methods * Add clearTimelockGuard function * Add _disableGuard helper to TLG tests * Limit number of transactions cancelled to 100 * Revert "Remove interfaces for abstract contracts" This reverts commit bd032889b639b35b8f512f941de3a924699fe44c. * Move livenessModule2 address into TestUtils Reduces diff a bit * Reduce diff somewhat * Remove unused arg * Update packages/contracts-bedrock/src/safe/TimelockGuard.sol Co-authored-by: graphite-app[bot] <96075541+graphite-app[bot]@users.noreply.github.com> * Fix iface * update abi for iface fix * Do not clear or disable the module during ownership transfer * Fix inaccurate comment on _disableAndClearGuard * Further improve comment * remove unused import * fix test name * Do not clear guard during changeOwnershipToFallback * Remove unused SENTINEL_MODULE var * Remove dangling comment * Revert "Remove dangling comment" This reverts commit d266d12dbc5af68b192c8898b7c97d772a8954a3. * Fix whitespace * remove unnecessary internal _clearTimelockGuard function It's no longer reused in the change ownership call. * Address feedback * Add missing assertion * Move guard slot into constants * semver-lock * Remove LivenessModule from semver-lock * fix: fmt, semver-lock, unused imports * Remove unused variable * fix semver lock by resetting old LivenessModule * fix unused import --------- Co-authored-by: graphite-app[bot] <96075541+graphite-app[bot]@users.noreply.github.com> --- .../interfaces/safe/ITimelockGuard.sol | 1 + .../checks/test-validation/exclusions.toml | 1 + .../snapshots/abi/SaferSafes.json | 31 +++ .../snapshots/semver-lock.json | 4 +- .../src/libraries/Constants.sol | 4 + .../src/safe/LivenessModule2.sol | 15 +- .../contracts-bedrock/src/safe/SaferSafes.sol | 4 +- .../src/safe/TimelockGuard.sol | 63 ++++- .../test/safe/LivenessModule2.t.sol | 227 +++++------------- .../test/safe/SaferSafes.t.sol | 208 +++++++++++++++- .../test/safe/TimelockGuard.t.sol | 94 ++++++++ .../test/scripts/DeployOwnership.t.sol | 2 - 12 files changed, 471 insertions(+), 183 deletions(-) diff --git a/packages/contracts-bedrock/interfaces/safe/ITimelockGuard.sol b/packages/contracts-bedrock/interfaces/safe/ITimelockGuard.sol index 984309a87c4..8d462136ed2 100644 --- a/packages/contracts-bedrock/interfaces/safe/ITimelockGuard.sol +++ b/packages/contracts-bedrock/interfaces/safe/ITimelockGuard.sol @@ -47,6 +47,7 @@ interface ITimelockGuard { event TransactionScheduled(address indexed safe, bytes32 indexed txHash, uint256 executionTime); event TransactionExecuted(address indexed safe, bytes32 txHash); event Message(string message); + event TransactionsNotCancelled(address indexed safe, uint256 uncancelledCount); function cancelTransaction(address _safe, bytes32 _txHash, uint256 _nonce, bytes memory _signatures) external; function signCancellation(bytes32 _txHash) external; diff --git a/packages/contracts-bedrock/scripts/checks/test-validation/exclusions.toml b/packages/contracts-bedrock/scripts/checks/test-validation/exclusions.toml index 6c332b4e8a3..cf00ca4e9ca 100644 --- a/packages/contracts-bedrock/scripts/checks/test-validation/exclusions.toml +++ b/packages/contracts-bedrock/scripts/checks/test-validation/exclusions.toml @@ -94,4 +94,5 @@ contracts = [ "OptimismPortal2_UpgradeInterop_Test", # Interop tests hosted in the OptimismPortal2 test file "TransactionBuilder", # Transaction builder helper library in TimelockGuard test file "Constants_Test", # Invalid naming pattern - doesn't specify function or Uncategorized + "LivenessModule2_TestUtils", # Test utils library in LivenessModule2 test file ] diff --git a/packages/contracts-bedrock/snapshots/abi/SaferSafes.json b/packages/contracts-bedrock/snapshots/abi/SaferSafes.json index c79f6fa7929..82747808687 100644 --- a/packages/contracts-bedrock/snapshots/abi/SaferSafes.json +++ b/packages/contracts-bedrock/snapshots/abi/SaferSafes.json @@ -179,6 +179,13 @@ "stateMutability": "nonpayable", "type": "function" }, + { + "inputs": [], + "name": "clearTimelockGuard", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, { "inputs": [ { @@ -786,6 +793,25 @@ "name": "TransactionScheduled", "type": "event" }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "contract GnosisSafe", + "name": "safe", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "uncancelledCount", + "type": "uint256" + } + ], + "name": "TransactionsNotCancelled", + "type": "event" + }, { "inputs": [], "name": "LivenessModule2_ChallengeAlreadyExists", @@ -861,6 +887,11 @@ "name": "TimelockGuard_GuardNotEnabled", "type": "error" }, + { + "inputs": [], + "name": "TimelockGuard_GuardStillEnabled", + "type": "error" + }, { "inputs": [], "name": "TimelockGuard_InvalidTimelockDelay", diff --git a/packages/contracts-bedrock/snapshots/semver-lock.json b/packages/contracts-bedrock/snapshots/semver-lock.json index c7a4462d581..14db9a762d6 100644 --- a/packages/contracts-bedrock/snapshots/semver-lock.json +++ b/packages/contracts-bedrock/snapshots/semver-lock.json @@ -208,8 +208,8 @@ "sourceCodeHash": "0x950725f8b9ad9bb3b6b5e836f67e18db824a7864bac547ee0eeba88ada3de0e9" }, "src/safe/SaferSafes.sol:SaferSafes": { - "initCodeHash": "0x22730f6ebe10e0d78b23b3e0f3d58f867f420039981455b09a508755e512c127", - "sourceCodeHash": "0xe3d2fd50724baf6d5e83e2c9d89fcfcbc678d966187bd38e2d9a840716bcafa3" + "initCodeHash": "0x68567829042bbd450ffd477848ddcda288e36714846fdcc02c315f2d0d332da6", + "sourceCodeHash": "0x06fc6d5df3c5769b645ff319d8b94415e501711c19cb0b1bce2631771d22294f" }, "src/universal/OptimismMintableERC20.sol:OptimismMintableERC20": { "initCodeHash": "0x3c85eed0d017dca8eda6396aa842ddc12492587b061e8c756a8d32c4610a9658", diff --git a/packages/contracts-bedrock/src/libraries/Constants.sol b/packages/contracts-bedrock/src/libraries/Constants.sol index 6dcf3611956..50ad7166974 100644 --- a/packages/contracts-bedrock/src/libraries/Constants.sol +++ b/packages/contracts-bedrock/src/libraries/Constants.sol @@ -31,6 +31,10 @@ library Constants { /// @dev `bytes32(uint256(keccak256('eip1967.proxy.admin')) - 1)` bytes32 internal constant PROXY_OWNER_ADDRESS = 0xb53127684a568b3173ae13b9f8a6016e243e63b6e8ee1178d6a717850b5d6103; + /// @notice The storage slot that holds the guard address in Safe contracts. + /// @dev `keccak256("guard_manager.guard.address")` + bytes32 internal constant GUARD_STORAGE_SLOT = 0x4a204f620c8c5ccdca3fd54d003badd85ba500436a431f0cbda4f558c93c34c8; + /// @notice The address that represents ether when dealing with ERC20 token addresses. address internal constant ETHER = 0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE; diff --git a/packages/contracts-bedrock/src/safe/LivenessModule2.sol b/packages/contracts-bedrock/src/safe/LivenessModule2.sol index ac9fe40839e..1feb5595689 100644 --- a/packages/contracts-bedrock/src/safe/LivenessModule2.sol +++ b/packages/contracts-bedrock/src/safe/LivenessModule2.sol @@ -5,6 +5,7 @@ pragma solidity 0.8.15; import { GnosisSafe as Safe } from "safe-contracts/GnosisSafe.sol"; import { Enum } from "safe-contracts/common/Enum.sol"; import { OwnerManager } from "safe-contracts/base/OwnerManager.sol"; +import { GuardManager } from "safe-contracts/base/GuardManager.sol"; /// @title LivenessModule2 /// @notice This module allows challenge-based ownership transfer to a fallback owner @@ -146,6 +147,7 @@ abstract contract LivenessModule2 { /// @notice Internal helper function which can be overriden in a child contract to check if the guard's /// configuration is valid in the context of other extensions that are enabled on the Safe. + /// @param _safe The Safe instance to check the configuration against function _checkCombinedConfig(Safe _safe) internal view virtual; /// @notice Clears the module configuration for a Safe. @@ -282,8 +284,19 @@ abstract contract LivenessModule2 { // Reset the challenge state to allow a new challenge delete challengeStartTime[_safe]; - emit ChallengeSucceeded(_safe, livenessSafeConfiguration[_safe].fallbackOwner); + + // Disable the guard + // Note that this will remove whichever guard is currently set on the Safe, + // even if it is not the SaferSafes guard. This is intentional, as it is possible that the guard + // itself was the cause of the liveness failure which resulted in the transfer of ownership to + // the fallback owner. + targetSafe.execTransactionFromModule({ + to: _safe, + value: 0, + operation: Enum.Operation.Call, + data: abi.encodeCall(GuardManager.setGuard, (address(0))) + }); } /// @notice Asserts that the module is configured for the given Safe. diff --git a/packages/contracts-bedrock/src/safe/SaferSafes.sol b/packages/contracts-bedrock/src/safe/SaferSafes.sol index e468652678a..53b64c8a73a 100644 --- a/packages/contracts-bedrock/src/safe/SaferSafes.sol +++ b/packages/contracts-bedrock/src/safe/SaferSafes.sol @@ -22,8 +22,8 @@ import { ISemver } from "interfaces/universal/ISemver.sol"; /// functionality is not desired, then there is no need to enable or configure it. contract SaferSafes is LivenessModule2, TimelockGuard, ISemver { /// @notice Semantic version. - /// @custom:semver 1.0.0 - string public constant version = "1.0.0"; + /// @custom:semver 1.1.0 + string public constant version = "1.1.0"; /// @notice Error for when the liveness response period is insufficient. error SaferSafes_InsufficientLivenessResponsePeriod(); diff --git a/packages/contracts-bedrock/src/safe/TimelockGuard.sol b/packages/contracts-bedrock/src/safe/TimelockGuard.sol index 183b2a46c8e..40fecbcbe1b 100644 --- a/packages/contracts-bedrock/src/safe/TimelockGuard.sol +++ b/packages/contracts-bedrock/src/safe/TimelockGuard.sol @@ -9,6 +9,7 @@ import { Guard as IGuard } from "safe-contracts/base/GuardManager.sol"; // Libraries import { EnumerableSet } from "@openzeppelin/contracts/utils/structs/EnumerableSet.sol"; import { SemverComp } from "src/libraries/SemverComp.sol"; +import { Constants } from "src/libraries/Constants.sol"; /// @title TimelockGuard /// @notice This guard provides timelock functionality for Safe transactions @@ -149,6 +150,14 @@ abstract contract TimelockGuard is IGuard { /// @notice Error for when the contract is not at least version 1.3.0 error TimelockGuard_InvalidVersion(); + /// @notice Error for when trying to clear guard while it is still enabled + error TimelockGuard_GuardStillEnabled(); + + /// @notice Emitted when some transactions are not cancelled. + /// @param safe The Safe whose transactions are not cancelled. + /// @param uncancelledCount The number of transactions that are not cancelled. + event TransactionsNotCancelled(Safe indexed safe, uint256 uncancelledCount); + /// @notice Emitted when a Safe configures the guard /// @param safe The Safe whose guard is configured. /// @param timelockDelay The timelock delay in seconds. @@ -196,9 +205,7 @@ abstract contract TimelockGuard is IGuard { /// @param _safe The Safe address /// @return The current guard address function _isGuardEnabled(Safe _safe) internal view returns (bool) { - // keccak256("guard_manager.guard.address") from GuardManager - bytes32 guardSlot = 0x4a204f620c8c5ccdca3fd54d003badd85ba500436a431f0cbda4f558c93c34c8; - address guard = abi.decode(_safe.getStorageAt(uint256(guardSlot), 1), (address)); + address guard = abi.decode(_safe.getStorageAt(uint256(Constants.GUARD_STORAGE_SLOT), 1), (address)); return guard == address(this); } @@ -453,6 +460,56 @@ abstract contract TimelockGuard is IGuard { _checkCombinedConfig(callingSafe); } + /// @notice Clears the timelock guard configuration for a Safe. + /// @dev Note: Clearing the configuration also cancels all pending transactions. + /// This function is intended for use when a Safe wants to permanently remove + /// the TimelockGuard configuration. Typical usage pattern: + /// 1. Safe disables the guard via GuardManager.setGuard(address(0)). + /// 2. Safe calls this clearTimelockGuard() function to remove stored configuration. + /// 3. If Safe later re-enables the guard, it must call configureTimelockGuard() again. + function clearTimelockGuard() external { + Safe callingSafe = Safe(payable(msg.sender)); + SafeState storage safeState = _safeState[callingSafe]; + + // Check if the calling safe has configuration set + if (safeState.timelockDelay == 0) { + revert TimelockGuard_GuardNotConfigured(); + } + + // Check that this guard is NOT enabled on the calling Safe + // This prevents clearing configuration while guard is still enabled + if (_isGuardEnabled(callingSafe)) { + revert TimelockGuard_GuardStillEnabled(); + } + + // Clear the configuration (guard should already be disabled by caller) + // set the timelock delay to 0 to clear the configuration + safeState.timelockDelay = 0; + + // Reset the cancellation threshold to 0 (unconfigured state) + safeState.cancellationThreshold = 0; + + // Get all pending transaction hashes + bytes32[] memory hashes = safeState.pendingTxHashes.values(); + + uint256 n = hashes.length <= 100 ? hashes.length : 100; + + // Cancel all pending transactions up to 100 + // It is very unlikely that there will be more than 100 pending transactions, so we can safely limit the + // number of iterations to 100 in order to prevent gas limit issues. + // If there are more than 100 pending transactions, then we emit an event to inform the user that some + // transactions were not cancelled. + for (uint256 i = 0; i < n; i++) { + safeState.pendingTxHashes.remove(hashes[i]); + safeState.scheduledTransactions[hashes[i]].state = TransactionState.Cancelled; + emit TransactionCancelled(callingSafe, hashes[i]); + } + + if (hashes.length > 100) { + emit TransactionsNotCancelled(callingSafe, hashes.length - 100); + } + } + /// @notice Schedule a transaction for execution after the timelock delay. /// @dev This function validates signatures in the exact same way as the Safe's own execTransaction function, /// meaning that the same signatures used to schedule a transaction can be used to execute it later. This diff --git a/packages/contracts-bedrock/test/safe/LivenessModule2.t.sol b/packages/contracts-bedrock/test/safe/LivenessModule2.t.sol index b3a0e429044..c45781b8b58 100644 --- a/packages/contracts-bedrock/test/safe/LivenessModule2.t.sol +++ b/packages/contracts-bedrock/test/safe/LivenessModule2.t.sol @@ -4,53 +4,16 @@ pragma solidity 0.8.15; import { Test } from "forge-std/Test.sol"; import { Enum } from "safe-contracts/common/Enum.sol"; import "test/safe-tools/SafeTestTools.sol"; +import { Constants } from "src/libraries/Constants.sol"; import { LivenessModule2 } from "src/safe/LivenessModule2.sol"; import { SaferSafes } from "src/safe/SaferSafes.sol"; +import { ModuleManager } from "safe-contracts/base/ModuleManager.sol"; -/// @title LivenessModule2_TestInit -/// @notice Reusable test initialization for `LivenessModule2` tests. -abstract contract LivenessModule2_TestInit is Test, SafeTestTools { - using SafeTestLib for SafeInstance; - - // Events - event ModuleConfigured(address indexed safe, uint256 livenessResponsePeriod, address fallbackOwner); - event ModuleCleared(address indexed safe); - event ChallengeStarted(address indexed safe, uint256 challengeStartTime); - event ChallengeCancelled(address indexed safe); - event ChallengeSucceeded(address indexed safe, address fallbackOwner); - - uint256 constant INIT_TIME = 10; - uint256 constant CHALLENGE_PERIOD = 7 days; - uint256 constant NUM_OWNERS = 5; - uint256 constant THRESHOLD = 3; - - SaferSafes livenessModule2; - SafeInstance safeInstance; - address fallbackOwner; - address[] owners; - uint256[] ownerPKs; - - function setUp() public virtual { - vm.warp(INIT_TIME); - - // Deploy the combined SaferSafes contract which implements LivenessModule2 - livenessModule2 = new SaferSafes(); - - // Create Safe owners - (address[] memory _owners, uint256[] memory _keys) = SafeTestLib.makeAddrsAndKeys("owners", NUM_OWNERS); - owners = _owners; - ownerPKs = _keys; - - // Set up Safe with owners - safeInstance = _setupSafe(ownerPKs, THRESHOLD); - - // Set fallback owner - fallbackOwner = makeAddr("fallbackOwner"); - - // Enable the module on the Safe - SafeTestLib.enableModule(safeInstance, address(livenessModule2)); - } +/// @title LivenessModule2_TestUtils +/// @notice Reusable helper methods for LivenessModule2 tests. +abstract contract LivenessModule2_TestUtils is Test, SafeTestTools { + LivenessModule2 livenessModule2; /// @notice Helper to enable the LivenessModule2 for a Safe function _enableModule(SafeInstance memory _safe, uint256 _period, address _fallback) internal { @@ -92,6 +55,56 @@ abstract contract LivenessModule2_TestInit is Test, SafeTestTools { _safe, address(livenessModule2), 0, abi.encodeCall(LivenessModule2.respond, ()), Enum.Operation.Call ); } + + /// @notice Helper to get the guard address from a Safe + function _getGuard(SafeInstance memory _safe) internal view returns (address) { + address guard = abi.decode(_safe.safe.getStorageAt(uint256(Constants.GUARD_STORAGE_SLOT), 1), (address)); + return guard; + } +} + +/// @title LivenessModule2_TestInit +/// @notice Reusable test initialization for `LivenessModule2` tests. +contract LivenessModule2_TestInit is LivenessModule2_TestUtils { + using SafeTestLib for SafeInstance; + + // Events + event ModuleConfigured(address indexed safe, uint256 livenessResponsePeriod, address fallbackOwner); + event ModuleCleared(address indexed safe); + event ChallengeStarted(address indexed safe, uint256 challengeStartTime); + event ChallengeCancelled(address indexed safe); + event ChallengeSucceeded(address indexed safe, address fallbackOwner); + + uint256 constant INIT_TIME = 10; + uint256 constant CHALLENGE_PERIOD = 7 days; + uint256 constant NUM_OWNERS = 5; + uint256 constant THRESHOLD = 3; + + SafeInstance safeInstance; + address fallbackOwner; + address[] owners; + uint256[] ownerPKs; + + function setUp() public virtual { + vm.warp(INIT_TIME); + + // Deploy the combined SaferSafes contract which implements LivenessModule2 + livenessModule2 = new SaferSafes(); + + // Create Safe owners + (address[] memory _owners, uint256[] memory _keys) = SafeTestLib.makeAddrsAndKeys("owners", NUM_OWNERS); + owners = _owners; + ownerPKs = _keys; + + // Set up Safe with owners + safeInstance = _setupSafe(ownerPKs, THRESHOLD); + + // Set fallback owner + fallbackOwner = makeAddr("fallbackOwner"); + + // Enable the module on the Safe + SafeTestLib.enableModule(safeInstance, address(livenessModule2)); + } } /// @title LivenessModule2_Configure_Test @@ -422,130 +435,6 @@ contract LivenessModule2_Challenge_Test is LivenessModule2_TestInit { } } -/// @title LivenessModule2_ChangeOwnershipToFallback_Test -/// @notice Tests the ownership transfer after successful challenge -contract LivenessModule2_ChangeOwnershipToFallback_Test is LivenessModule2_TestInit { - function setUp() public override { - super.setUp(); - _enableModule(safeInstance, CHALLENGE_PERIOD, fallbackOwner); - } - - function test_changeOwnershipToFallback_succeeds() external { - // Start a challenge - vm.prank(fallbackOwner); - livenessModule2.challenge(address(safeInstance.safe)); - - // Warp past challenge period - vm.warp(block.timestamp + CHALLENGE_PERIOD + 1); - - // Execute ownership transfer - vm.expectEmit(true, true, true, true); - emit ChallengeSucceeded(address(safeInstance.safe), fallbackOwner); - - vm.prank(fallbackOwner); - livenessModule2.changeOwnershipToFallback(address(safeInstance.safe)); - - // Verify ownership changed - address[] memory newOwners = safeInstance.safe.getOwners(); - assertEq(newOwners.length, 1); - assertEq(newOwners[0], fallbackOwner); - assertEq(safeInstance.safe.getThreshold(), 1); - - // Verify challenge is reset - uint256 challengeEndTime = livenessModule2.getChallengePeriodEnd(address(safeInstance.safe)); - assertEq(challengeEndTime, 0); - } - - function test_changeOwnershipToFallback_moduleNotEnabled_reverts() external { - address newSafe = makeAddr("newSafe"); - - vm.prank(fallbackOwner); - vm.expectRevert(LivenessModule2.LivenessModule2_ModuleNotConfigured.selector); - livenessModule2.changeOwnershipToFallback(newSafe); - } - - function test_changeOwnershipToFallback_noChallenge_reverts() external { - vm.prank(fallbackOwner); - vm.expectRevert(LivenessModule2.LivenessModule2_ChallengeDoesNotExist.selector); - livenessModule2.changeOwnershipToFallback(address(safeInstance.safe)); - } - - function test_changeOwnershipToFallback_beforeResponsePeriod_reverts() external { - // Start a challenge - vm.prank(fallbackOwner); - livenessModule2.challenge(address(safeInstance.safe)); - - // Try to execute before response period expires - vm.prank(fallbackOwner); - vm.expectRevert(LivenessModule2.LivenessModule2_ResponsePeriodActive.selector); - livenessModule2.changeOwnershipToFallback(address(safeInstance.safe)); - } - - function test_changeOwnershipToFallback_moduleDisabledAtSafeLevel_reverts() external { - // Start a challenge - vm.prank(fallbackOwner); - livenessModule2.challenge(address(safeInstance.safe)); - - // Warp past challenge period - vm.warp(block.timestamp + CHALLENGE_PERIOD + 1); - - // Disable the module at Safe level - SafeTestLib.execTransaction( - safeInstance, - address(safeInstance.safe), - 0, - abi.encodeCall(ModuleManager.disableModule, (address(0x1), address(livenessModule2))), - Enum.Operation.Call - ); - - // Try to execute ownership transfer - should revert because module is disabled at Safe level - vm.prank(fallbackOwner); - vm.expectRevert(LivenessModule2.LivenessModule2_ModuleNotEnabled.selector); - livenessModule2.changeOwnershipToFallback(address(safeInstance.safe)); - } - - function test_changeOwnershipToFallback_onlyFallbackOwner_succeeds() external { - // Start a challenge - vm.prank(fallbackOwner); - livenessModule2.challenge(address(safeInstance.safe)); - - // Warp past challenge period - vm.warp(block.timestamp + CHALLENGE_PERIOD + 1); - - // Try from random address - should fail - address randomCaller = makeAddr("randomCaller"); - vm.prank(randomCaller); - vm.expectRevert(LivenessModule2.LivenessModule2_UnauthorizedCaller.selector); - livenessModule2.changeOwnershipToFallback(address(safeInstance.safe)); - - // Execute from fallback owner - should succeed - vm.prank(fallbackOwner); - livenessModule2.changeOwnershipToFallback(address(safeInstance.safe)); - - // Verify ownership changed - address[] memory newOwners = safeInstance.safe.getOwners(); - assertEq(newOwners.length, 1); - assertEq(newOwners[0], fallbackOwner); - } - - function test_changeOwnershipToFallback_canRechallenge_succeeds() external { - // Start and execute first challenge - vm.prank(fallbackOwner); - livenessModule2.challenge(address(safeInstance.safe)); - - vm.warp(block.timestamp + CHALLENGE_PERIOD + 1); - vm.prank(fallbackOwner); - livenessModule2.changeOwnershipToFallback(address(safeInstance.safe)); - - // Start a new challenge (as fallback owner) - vm.prank(fallbackOwner); - livenessModule2.challenge(address(safeInstance.safe)); - - uint256 challengeEndTime = livenessModule2.getChallengePeriodEnd(address(safeInstance.safe)); - assertGt(challengeEndTime, 0); - } -} - /// @title LivenessModule2_GetChallengePeriodEnd_Test /// @notice Tests the getChallengePeriodEnd function and related view functionality contract LivenessModule2_GetChallengePeriodEnd_Test is LivenessModule2_TestInit { @@ -579,8 +468,4 @@ contract LivenessModule2_GetChallengePeriodEnd_Test is LivenessModule2_TestInit _respondToChallenge(safeInstance); assertEq(livenessModule2.getChallengePeriodEnd(address(safeInstance.safe)), 0); } - - function test_version_succeeds() external view { - assertTrue(bytes(livenessModule2.version()).length > 0); - } } diff --git a/packages/contracts-bedrock/test/safe/SaferSafes.t.sol b/packages/contracts-bedrock/test/safe/SaferSafes.t.sol index f17dfc47abf..5caa088827b 100644 --- a/packages/contracts-bedrock/test/safe/SaferSafes.t.sol +++ b/packages/contracts-bedrock/test/safe/SaferSafes.t.sol @@ -1,24 +1,33 @@ // SPDX-License-Identifier: MIT pragma solidity 0.8.15; -import { Test } from "forge-std/Test.sol"; +import { Enum } from "safe-contracts/common/Enum.sol"; import "test/safe-tools/SafeTestTools.sol"; import { SaferSafes } from "src/safe/SaferSafes.sol"; import { LivenessModule2 } from "src/safe/LivenessModule2.sol"; +import { GuardManager } from "safe-contracts/base/GuardManager.sol"; +import { ModuleManager } from "safe-contracts/base/ModuleManager.sol"; +import { Guard as IGuard } from "safe-contracts/base/GuardManager.sol"; + +// Import the test utils from LivenessModule2 tests +import { LivenessModule2_TestUtils } from "test/safe/LivenessModule2.t.sol"; + /// @title SaferSafes_TestInit /// @notice Reusable test initialization for `SaferSafes` tests. -abstract contract SaferSafes_TestInit is Test, SafeTestTools { +abstract contract SaferSafes_TestInit is LivenessModule2_TestUtils { using SafeTestLib for SafeInstance; // Events event ModuleConfigured(address indexed safe, uint256 livenessResponsePeriod, address fallbackOwner); event GuardConfigured(address indexed safe, uint256 timelockDelay, uint256 cancellationThreshold); + event ChallengeSucceeded(address indexed safe, address fallbackOwner); uint256 constant INIT_TIME = 10; uint256 constant NUM_OWNERS = 5; uint256 constant THRESHOLD = 3; + uint256 constant CHALLENGE_PERIOD = 7 days; SaferSafes saferSafes; SafeInstance safeInstance; @@ -31,6 +40,7 @@ abstract contract SaferSafes_TestInit is Test, SafeTestTools { // Deploy the SaferSafes contract saferSafes = new SaferSafes(); + livenessModule2 = LivenessModule2(address(saferSafes)); // Create Safe owners (address[] memory _owners, uint256[] memory _keys) = SafeTestLib.makeAddrsAndKeys("owners", NUM_OWNERS); @@ -52,6 +62,10 @@ abstract contract SaferSafes_TestInit is Test, SafeTestTools { /// @title SaferSafes_Uncategorized_Test /// @notice Tests for SaferSafes configuration functionality. contract SaferSafes_Uncategorized_Test is SaferSafes_TestInit { + function test_version_succeeds() external view { + assertTrue(bytes(saferSafes.version()).length > 0); + } + /// @notice Test successful configuration when liveness response period is at least 2x timelock delay. function test_configure_livenessModuleFirst_succeeds() public { uint256 timelockDelay = 7 days; @@ -144,3 +158,193 @@ contract SaferSafes_Uncategorized_Test is SaferSafes_TestInit { saferSafes.configureLivenessModule(moduleConfig); } } + +/// @title SaferSafes_ChangeOwnershipToFallback_Test +/// @notice Tests the ownership transfer after successful challenge +contract SaferSafes_ChangeOwnershipToFallback_Test is SaferSafes_TestInit { + function setUp() public override { + super.setUp(); + + _enableModule(safeInstance, CHALLENGE_PERIOD, fallbackOwner); + + // enable the guard + SafeTestLib.execTransaction( + safeInstance, + address(safeInstance.safe), + 0, + abi.encodeCall(GuardManager.setGuard, (address(livenessModule2))), + Enum.Operation.Call + ); + } + + function _assertOwnershipChanged() internal view { + // Verify ownership changed + address[] memory newOwners = safeInstance.safe.getOwners(); + assertEq(newOwners.length, 1); + assertEq(newOwners[0], fallbackOwner); + assertEq(safeInstance.safe.getThreshold(), 1); + + // Verify challenge is reset + uint256 challengeEndTime = livenessModule2.getChallengePeriodEnd(address(safeInstance.safe)); + assertEq(challengeEndTime, 0); + + // Verify guard is deactivated + assertEq(_getGuard(safeInstance), address(0)); + } + + function test_changeOwnershipToFallback_succeeds() external { + // Start a challenge + vm.prank(fallbackOwner); + livenessModule2.challenge(address(safeInstance.safe)); + + // Warp past challenge period + vm.warp(block.timestamp + CHALLENGE_PERIOD + 1); + + // Execute ownership transfer + vm.expectEmit(true, true, true, true); + emit ChallengeSucceeded(address(safeInstance.safe), fallbackOwner); + + vm.prank(fallbackOwner); + livenessModule2.changeOwnershipToFallback(address(safeInstance.safe)); + + _assertOwnershipChanged(); + } + + function test_changeOwnershipToFallback_withOtherGuard_succeeds() external { + _enableModule(safeInstance, CHALLENGE_PERIOD, fallbackOwner); + // Create a mock guard + address dummyGuard = makeAddr("dummyGuard"); + vm.mockCall( + dummyGuard, + abi.encodeCall( + IGuard.checkTransaction, + (address(0), 0, "", Enum.Operation.Call, 0, 0, 0, address(0), payable(address(0)), "", address(0)) + ), + "" + ); + vm.mockCall(dummyGuard, abi.encodeCall(IGuard.checkAfterExecution, (bytes32(0), false)), ""); + + // Enable the mock guard on the Safe + SafeTestLib.execTransaction( + safeInstance, + address(safeInstance.safe), + 0, + abi.encodeCall(GuardManager.setGuard, (dummyGuard)), + Enum.Operation.Call + ); + + // Start a challenge + vm.prank(fallbackOwner); + livenessModule2.challenge(address(safeInstance.safe)); + + // Warp past challenge period + vm.warp(block.timestamp + CHALLENGE_PERIOD + 1); + + // Execute ownership transfer + vm.expectEmit(true, true, true, true); + emit ChallengeSucceeded(address(safeInstance.safe), fallbackOwner); + + vm.prank(fallbackOwner); + livenessModule2.changeOwnershipToFallback(address(safeInstance.safe)); + + // These checks include ensuring that the guard is deactivated + _assertOwnershipChanged(); + } + + function test_changeOwnershipToFallback_moduleNotEnabled_reverts() external { + address newSafe = makeAddr("newSafe"); + + vm.prank(fallbackOwner); + vm.expectRevert(LivenessModule2.LivenessModule2_ModuleNotConfigured.selector); + livenessModule2.changeOwnershipToFallback(newSafe); + } + + function test_changeOwnershipToFallback_noChallenge_reverts() external { + vm.prank(fallbackOwner); + vm.expectRevert(LivenessModule2.LivenessModule2_ChallengeDoesNotExist.selector); + livenessModule2.changeOwnershipToFallback(address(safeInstance.safe)); + } + + function test_changeOwnershipToFallback_beforeResponsePeriod_reverts() external { + // Start a challenge + vm.prank(fallbackOwner); + livenessModule2.challenge(address(safeInstance.safe)); + + // Try to execute before response period expires + vm.prank(fallbackOwner); + vm.expectRevert(LivenessModule2.LivenessModule2_ResponsePeriodActive.selector); + livenessModule2.changeOwnershipToFallback(address(safeInstance.safe)); + } + + function test_changeOwnershipToFallback_moduleDisabledAtSafeLevel_reverts() external { + // Start a challenge + vm.prank(fallbackOwner); + livenessModule2.challenge(address(safeInstance.safe)); + + // Warp past challenge period + vm.warp(block.timestamp + CHALLENGE_PERIOD + 1); + + // Disable the module at Safe level + SafeTestLib.execTransaction( + safeInstance, + address(safeInstance.safe), + 0, + abi.encodeCall(ModuleManager.disableModule, (address(0x1), address(livenessModule2))), + Enum.Operation.Call + ); + + // Try to execute ownership transfer - should revert because module is disabled at Safe level + vm.prank(fallbackOwner); + vm.expectRevert(LivenessModule2.LivenessModule2_ModuleNotEnabled.selector); + livenessModule2.changeOwnershipToFallback(address(safeInstance.safe)); + } + + function test_changeOwnershipToFallback_onlyFallbackOwner_succeeds() external { + _enableModule(safeInstance, CHALLENGE_PERIOD, fallbackOwner); + // Start a challenge + vm.prank(fallbackOwner); + livenessModule2.challenge(address(safeInstance.safe)); + + // Warp past challenge period + vm.warp(block.timestamp + CHALLENGE_PERIOD + 1); + + // Try from random address - should fail + address randomCaller = makeAddr("randomCaller"); + vm.prank(randomCaller); + vm.expectRevert(LivenessModule2.LivenessModule2_UnauthorizedCaller.selector); + livenessModule2.changeOwnershipToFallback(address(safeInstance.safe)); + + // Execute from fallback owner - should succeed + vm.prank(fallbackOwner); + livenessModule2.changeOwnershipToFallback(address(safeInstance.safe)); + + // Verify ownership changed + address[] memory newOwners = safeInstance.safe.getOwners(); + assertEq(newOwners.length, 1); + assertEq(newOwners[0], fallbackOwner); + } + + function test_changeOwnershipToFallback_canRechallenge_succeeds() external { + _enableModule(safeInstance, CHALLENGE_PERIOD, fallbackOwner); + // Start and execute first challenge + vm.prank(fallbackOwner); + livenessModule2.challenge(address(safeInstance.safe)); + + vm.warp(block.timestamp + CHALLENGE_PERIOD + 1); + vm.prank(fallbackOwner); + livenessModule2.changeOwnershipToFallback(address(safeInstance.safe)); + + // Re-configure the module + vm.prank(address(safeInstance.safe)); + livenessModule2.configureLivenessModule( + LivenessModule2.ModuleConfig({ livenessResponsePeriod: CHALLENGE_PERIOD, fallbackOwner: fallbackOwner }) + ); + + // Start a new challenge (as fallback owner) + vm.prank(fallbackOwner); + livenessModule2.challenge(address(safeInstance.safe)); + + uint256 challengeEndTime = livenessModule2.getChallengePeriodEnd(address(safeInstance.safe)); + assertGt(challengeEndTime, 0); + } +} diff --git a/packages/contracts-bedrock/test/safe/TimelockGuard.t.sol b/packages/contracts-bedrock/test/safe/TimelockGuard.t.sol index 53594f52570..1878182254f 100644 --- a/packages/contracts-bedrock/test/safe/TimelockGuard.t.sol +++ b/packages/contracts-bedrock/test/safe/TimelockGuard.t.sol @@ -150,6 +150,7 @@ abstract contract TimelockGuard_TestInit is Test, SafeTestTools { event CancellationThresholdUpdated(Safe indexed safe, uint256 oldThreshold, uint256 newThreshold); event TransactionExecuted(Safe indexed safe, bytes32 txHash); event Message(string message); + event TransactionsNotCancelled(Safe indexed safe, uint256 n); uint256 constant INIT_TIME = 10; uint256 constant TIMELOCK_DELAY = 7 days; @@ -238,6 +239,22 @@ abstract contract TimelockGuard_TestInit is Test, SafeTestTools { _safe, address(_safe.safe), 0, abi.encodeCall(GuardManager.setGuard, (address(timelockGuard))) ); } + + /// @notice Helper to disable guard on a Safe + function _disableGuard(SafeInstance memory _safe) internal { + // Create, schedule, and execute a transaction to disable the guard + TransactionBuilder.Transaction memory disableGuardTx = _createEmptyTransaction(safeInstance); + disableGuardTx.params.to = address(_safe.safe); + disableGuardTx.params.data = abi.encodeCall(GuardManager.setGuard, (address(0))); + disableGuardTx.updateTransaction(); + disableGuardTx.scheduleTransaction(timelockGuard); + + // Wait for timelock delay to pass + vm.warp(block.timestamp + TIMELOCK_DELAY + 1); + + // Execute the disable guard transaction + disableGuardTx.executeTransaction(); + } } /// @title TimelockGuard_TimelockConfiguration_Test @@ -880,3 +897,80 @@ contract TimelockGuard_Integration_Test is TimelockGuard_TestInit { assertEq(timelockGuard.cancellationThreshold(safeInstance.safe), maxThreshold); } } + +/// @title TimelockGuard_ClearTimelockGuard_Test +/// @notice Tests for clearTimelockGuard function +contract TimelockGuard_ClearTimelockGuard_Test is TimelockGuard_TestInit { + /// @notice Verifies that clearTimelockGuard successfully clears configuration after guard is disabled + function test_clearTimelockGuard_succeeds() external { + // First configure the guard + _configureGuard(safeInstance, TIMELOCK_DELAY); + + // Schedule a transaction to create pending state + TransactionBuilder.Transaction memory dummyTx = _createDummyTransaction(safeInstance); + dummyTx.scheduleTransaction(timelockGuard); + + // Verify transaction is pending + TimelockGuard.ScheduledTransaction memory scheduledTx = timelockGuard.scheduledTransaction(safe, dummyTx.hash); + assertEq(uint256(scheduledTx.state), uint256(TimelockGuard.TransactionState.Pending)); + + _disableGuard(safeInstance); + + // Clear the guard configuration + SafeTestLib.execTransaction( + safeInstance, address(timelockGuard), 0, abi.encodeCall(TimelockGuard.clearTimelockGuard, ()) + ); + + // Verify configuration is cleared + assertEq(timelockGuard.timelockConfiguration(safe), 0); + assertEq(timelockGuard.cancellationThreshold(safe), 0); + + // Verify pending transaction was cancelled + scheduledTx = timelockGuard.scheduledTransaction(safe, dummyTx.hash); + assertEq(uint256(scheduledTx.state), uint256(TimelockGuard.TransactionState.Cancelled)); + } + + function test_clearTimelockGuard_moreThan100PendingTransactions_succeeds() external { + // First configure the guard + _configureGuard(safeInstance, TIMELOCK_DELAY); + + // Schedule a transaction to create pending state + TransactionBuilder.Transaction memory dummyTx = _createDummyTransaction(safeInstance); + + // Schedule more than 100 transactions + for (uint256 i = 0; i < 150; i++) { + dummyTx.setNonce(dummyTx.nonce + 1); + dummyTx.updateTransaction(); + dummyTx.scheduleTransaction(timelockGuard); + } + + _disableGuard(safeInstance); + + // Clear the guard configuration + vm.prank(address(safeInstance.safe)); + vm.expectEmit(true, true, true, true); + emit TransactionsNotCancelled(safeInstance.safe, 50); + timelockGuard.clearTimelockGuard(); + + // Ensure that the call is below a safe gas limit. The EIP-7825 limit is 16,777,216, so 12M is a safe limit. + assertLt(vm.lastCallGas().gasTotalUsed, 12_000_000); + + // Ensure the remaining pending transactions are 50 as expected + assertEq(timelockGuard.pendingTransactions(Safe(payable(address(safeInstance.safe)))).length, 50); + + // Verify configuration is cleared + assertEq(timelockGuard.timelockConfiguration(safe), 0); + assertEq(timelockGuard.cancellationThreshold(safe), 0); + } + + /// @notice Verifies that clearTimelockGuard reverts when guard is still enabled + function test_clearTimelockGuard_guardStillEnabled_reverts() external { + // First configure the guard + _configureGuard(safeInstance, TIMELOCK_DELAY); + + // Try to clear while guard is still enabled (should revert) + vm.expectRevert(TimelockGuard.TimelockGuard_GuardStillEnabled.selector); + vm.prank(address(safeInstance.safe)); + timelockGuard.clearTimelockGuard(); + } +} diff --git a/packages/contracts-bedrock/test/scripts/DeployOwnership.t.sol b/packages/contracts-bedrock/test/scripts/DeployOwnership.t.sol index ff175d3f6b2..42ef9288d8e 100644 --- a/packages/contracts-bedrock/test/scripts/DeployOwnership.t.sol +++ b/packages/contracts-bedrock/test/scripts/DeployOwnership.t.sol @@ -16,8 +16,6 @@ import { LivenessModule2 } from "src/safe/LivenessModule2.sol"; contract DeployOwnershipTest is Test, DeployOwnership { address internal constant SENTINEL_MODULES = address(0x1); - // keccak256("guard_manager.guard.address") - bytes32 internal constant GUARD_STORAGE_SLOT = 0x4a204f620c8c5ccdca3fd54d003badd85ba500436a431f0cbda4f558c93c34c8; function setUp() public override { super.setUp(); From e501362d1970baadc02ae847d05f6d5b36944afe Mon Sep 17 00:00:00 2001 From: Adrian Sutton Date: Mon, 20 Oct 2025 07:10:58 +1000 Subject: [PATCH 088/117] proofs: Pass game type as a CWIA arg instead of a constructor arg (#17832) * proofs: Pass game type as a CWIA arg instead of a constructor arg. * proofs: Remove ReservedGameType check --- .../dispute/v2/IFaultDisputeGameV2.sol | 4 +- .../dispute/v2/IPermissionedDisputeGameV2.sol | 1 - .../deploy/DeployImplementations.s.sol | 4 +- .../snapshots/abi/FaultDisputeGameV2.json | 14 +---- .../abi/PermissionedDisputeGameV2.json | 14 +---- .../snapshots/semver-lock.json | 12 ++-- .../src/dispute/DisputeGameFactory.sol | 52 +++++++++++----- .../src/dispute/v2/FaultDisputeGameV2.sol | 62 ++++++++----------- .../dispute/v2/PermissionedDisputeGameV2.sol | 4 +- .../test/dispute/DisputeGameFactory.t.sol | 9 +-- .../test/dispute/FaultDisputeGame.t.sol | 36 +++-------- .../test/opcm/DeployImplementations.t.sol | 21 ------- 12 files changed, 86 insertions(+), 147 deletions(-) diff --git a/packages/contracts-bedrock/interfaces/dispute/v2/IFaultDisputeGameV2.sol b/packages/contracts-bedrock/interfaces/dispute/v2/IFaultDisputeGameV2.sol index 91553eddb8d..3b31babbbab 100644 --- a/packages/contracts-bedrock/interfaces/dispute/v2/IFaultDisputeGameV2.sol +++ b/packages/contracts-bedrock/interfaces/dispute/v2/IFaultDisputeGameV2.sol @@ -6,7 +6,7 @@ import { IDelayedWETH } from "interfaces/dispute/IDelayedWETH.sol"; import { IAnchorStateRegistry } from "interfaces/dispute/IAnchorStateRegistry.sol"; import { IBigStepper } from "interfaces/dispute/IBigStepper.sol"; import { Types } from "src/libraries/Types.sol"; -import { GameType, Claim, Position, Clock, Hash, Duration, BondDistributionMode } from "src/dispute/lib/Types.sol"; +import { Claim, Position, Clock, Hash, Duration, BondDistributionMode } from "src/dispute/lib/Types.sol"; interface IFaultDisputeGameV2 is IDisputeGame { struct ClaimData { @@ -27,7 +27,6 @@ interface IFaultDisputeGameV2 is IDisputeGame { } struct GameConstructorParams { - GameType gameType; uint256 maxGameDepth; uint256 splitDepth; Duration clockExtension; @@ -73,7 +72,6 @@ interface IFaultDisputeGameV2 is IDisputeGame { error InvalidBondDistributionMode(); error GameNotFinalized(); error GameNotResolved(); - error ReservedGameType(); error GamePaused(); event Move(uint256 indexed parentIndex, Claim indexed claim, address indexed claimant); event GameClosed(BondDistributionMode bondDistributionMode); diff --git a/packages/contracts-bedrock/interfaces/dispute/v2/IPermissionedDisputeGameV2.sol b/packages/contracts-bedrock/interfaces/dispute/v2/IPermissionedDisputeGameV2.sol index 78eb910d864..7db5da9e2f7 100644 --- a/packages/contracts-bedrock/interfaces/dispute/v2/IPermissionedDisputeGameV2.sol +++ b/packages/contracts-bedrock/interfaces/dispute/v2/IPermissionedDisputeGameV2.sol @@ -67,7 +67,6 @@ interface IPermissionedDisputeGameV2 is IDisputeGame { error InvalidBondDistributionMode(); error GameNotFinalized(); error GameNotResolved(); - error ReservedGameType(); error GamePaused(); event Move(uint256 indexed parentIndex, Claim indexed claim, address indexed claimant); event GameClosed(BondDistributionMode bondDistributionMode); diff --git a/packages/contracts-bedrock/scripts/deploy/DeployImplementations.s.sol b/packages/contracts-bedrock/scripts/deploy/DeployImplementations.s.sol index bc76955c48f..d63f8eb34cc 100644 --- a/packages/contracts-bedrock/scripts/deploy/DeployImplementations.s.sol +++ b/packages/contracts-bedrock/scripts/deploy/DeployImplementations.s.sol @@ -17,7 +17,7 @@ import { IDisputeGameFactory } from "interfaces/dispute/IDisputeGameFactory.sol" import { IAnchorStateRegistry } from "interfaces/dispute/IAnchorStateRegistry.sol"; import { IFaultDisputeGameV2 } from "interfaces/dispute/v2/IFaultDisputeGameV2.sol"; import { IPermissionedDisputeGameV2 } from "interfaces/dispute/v2/IPermissionedDisputeGameV2.sol"; -import { GameTypes, Duration } from "src/dispute/lib/Types.sol"; +import { Duration } from "src/dispute/lib/Types.sol"; import { IOPContractsManager, IOPContractsManagerGameTypeAdder, @@ -486,7 +486,6 @@ contract DeployImplementations is Script { function deployFaultDisputeGameV2Impl(Input memory _input, Output memory _output) private { IFaultDisputeGameV2.GameConstructorParams memory params; - params.gameType = GameTypes.CANNON; params.maxGameDepth = _input.faultGameV2MaxGameDepth; params.splitDepth = _input.faultGameV2SplitDepth; params.clockExtension = Duration.wrap(uint64(_input.faultGameV2ClockExtension)); @@ -505,7 +504,6 @@ contract DeployImplementations is Script { function deployPermissionedDisputeGameV2Impl(Input memory _input, Output memory _output) private { IFaultDisputeGameV2.GameConstructorParams memory params; - params.gameType = GameTypes.PERMISSIONED_CANNON; params.maxGameDepth = _input.faultGameV2MaxGameDepth; params.splitDepth = _input.faultGameV2SplitDepth; params.clockExtension = Duration.wrap(uint64(_input.faultGameV2ClockExtension)); diff --git a/packages/contracts-bedrock/snapshots/abi/FaultDisputeGameV2.json b/packages/contracts-bedrock/snapshots/abi/FaultDisputeGameV2.json index d4a4f83892a..c3c9a6555f2 100644 --- a/packages/contracts-bedrock/snapshots/abi/FaultDisputeGameV2.json +++ b/packages/contracts-bedrock/snapshots/abi/FaultDisputeGameV2.json @@ -3,11 +3,6 @@ "inputs": [ { "components": [ - { - "internalType": "GameType", - "name": "gameType", - "type": "uint32" - }, { "internalType": "uint256", "name": "maxGameDepth", @@ -377,7 +372,7 @@ "type": "bytes" } ], - "stateMutability": "view", + "stateMutability": "pure", "type": "function" }, { @@ -390,7 +385,7 @@ "type": "uint32" } ], - "stateMutability": "view", + "stateMutability": "pure", "type": "function" }, { @@ -1161,11 +1156,6 @@ "name": "OutOfOrderResolution", "type": "error" }, - { - "inputs": [], - "name": "ReservedGameType", - "type": "error" - }, { "inputs": [], "name": "UnexpectedList", diff --git a/packages/contracts-bedrock/snapshots/abi/PermissionedDisputeGameV2.json b/packages/contracts-bedrock/snapshots/abi/PermissionedDisputeGameV2.json index 23dbddadfc0..09352c2b758 100644 --- a/packages/contracts-bedrock/snapshots/abi/PermissionedDisputeGameV2.json +++ b/packages/contracts-bedrock/snapshots/abi/PermissionedDisputeGameV2.json @@ -3,11 +3,6 @@ "inputs": [ { "components": [ - { - "internalType": "GameType", - "name": "gameType", - "type": "uint32" - }, { "internalType": "uint256", "name": "maxGameDepth", @@ -390,7 +385,7 @@ "type": "bytes" } ], - "stateMutability": "view", + "stateMutability": "pure", "type": "function" }, { @@ -403,7 +398,7 @@ "type": "uint32" } ], - "stateMutability": "view", + "stateMutability": "pure", "type": "function" }, { @@ -1192,11 +1187,6 @@ "name": "OutOfOrderResolution", "type": "error" }, - { - "inputs": [], - "name": "ReservedGameType", - "type": "error" - }, { "inputs": [], "name": "UnexpectedList", diff --git a/packages/contracts-bedrock/snapshots/semver-lock.json b/packages/contracts-bedrock/snapshots/semver-lock.json index 14db9a762d6..b886419cf49 100644 --- a/packages/contracts-bedrock/snapshots/semver-lock.json +++ b/packages/contracts-bedrock/snapshots/semver-lock.json @@ -156,8 +156,8 @@ "sourceCodeHash": "0xdebf2ab3af4d5549c40e9dd9db6b2458af286f323b6891f3b0c4e89f3c8928db" }, "src/dispute/DisputeGameFactory.sol:DisputeGameFactory": { - "initCodeHash": "0x41ea0025ffbbb7dabc45da9b8afe4bce6b8ec1f132b424f351cf8c7d3fe15579", - "sourceCodeHash": "0x81ffb8f29b29774847e8b699d8719aaf6c633070841b8e2c3a651105822ce9ea" + "initCodeHash": "0x820e876839f94564a9d5d1fa131781c40126aed76fbbd348f49f318ae3e12aae", + "sourceCodeHash": "0xf19216b7943479af87a01ab8935e68561853e8e333d09719c917228bc7a01a3a" }, "src/dispute/FaultDisputeGame.sol:FaultDisputeGame": { "initCodeHash": "0xe7d3c982532946d196d7efadb9e2576c76b8f9e0d1f885ac36977d6f3fb72a65", @@ -176,12 +176,12 @@ "sourceCodeHash": "0x8fdd69d4bcd33a3d8b49a73ff5b6855f9ad5f7e2b7393e67cd755973b127b1e8" }, "src/dispute/v2/FaultDisputeGameV2.sol:FaultDisputeGameV2": { - "initCodeHash": "0xb5a7bfcbfcb445dc57fc88c07d7305191dc32cc0cf5580d50b4897229e4033c1", - "sourceCodeHash": "0x38fd8878a22564cd63e2bdc6af51edead373e2c4a90e631d2774078bbaa54ea6" + "initCodeHash": "0x6fc59e2da083c9e2093e42b0fda705e8215cc216e4dcedbf728c08f69ec2d3bd", + "sourceCodeHash": "0x7fc97734c12e207f011c4f079fffe84f5bd11f4fb4a95dd56ad6a69df184584f" }, "src/dispute/v2/PermissionedDisputeGameV2.sol:PermissionedDisputeGameV2": { - "initCodeHash": "0xcff1406639ff8a83a4c948f412329956104bc7ee30eb8da169a2ba5ef6d8848f", - "sourceCodeHash": "0x53fdae5faf97beed5f23d4f285bed06766161ab15c88e3a388f84808471a73c3" + "initCodeHash": "0x9896fd04e9a3f9fe4f1d6e93eb298b37a6bfa33424aa705e68cc58d0ba7f3f90", + "sourceCodeHash": "0xc0ff6e93b6e2b9111c11e81b5df8948ab71d02b9d2c4dfda982fcb615519f1f7" }, "src/legacy/DeployerWhitelist.sol:DeployerWhitelist": { "initCodeHash": "0x2e0ef4c341367eb59cc6c25190c64eff441d3fe130189da91d4d126f6bdbc9b5", diff --git a/packages/contracts-bedrock/src/dispute/DisputeGameFactory.sol b/packages/contracts-bedrock/src/dispute/DisputeGameFactory.sol index f9a9e2bf68b..eb92ca52224 100644 --- a/packages/contracts-bedrock/src/dispute/DisputeGameFactory.sol +++ b/packages/contracts-bedrock/src/dispute/DisputeGameFactory.sol @@ -56,8 +56,8 @@ contract DisputeGameFactory is ProxyAdminOwnedBase, ReinitializableBase, Ownable } /// @notice Semantic version. - /// @custom:semver 1.3.0 - string public constant version = "1.3.0"; + /// @custom:semver 1.4.0 + string public constant version = "1.4.0"; /// @notice `gameImpls` is a mapping that maps `GameType`s to their respective /// `IDisputeGame` implementations. @@ -165,21 +165,39 @@ contract DisputeGameFactory is ProxyAdminOwnedBase, ReinitializableBase, Ownable // Get the hash of the parent block. bytes32 parentHash = blockhash(block.number - 1); - // Clone the implementation contract and initialize it with the given parameters. - // - // CWIA Calldata Layout: - // ┌──────────────────────┬─────────────────────────────────────┐ - // │ Bytes │ Description │ - // ├──────────────────────┼─────────────────────────────────────┤ - // │ [0, 20) │ Game creator address │ - // │ [20, 52) │ Root claim │ - // │ [52, 84) │ Parent block hash at creation time │ - // │ [84, 84 + n) │ Extra data (opaque) │ - // │ [84 + n, 84 + n + m) │ Implementation args (opaque) │ - // └──────────────────────┴─────────────────────────────────────┘ - proxy_ = IDisputeGame( - address(impl).clone(abi.encodePacked(msg.sender, _rootClaim, parentHash, _extraData, gameArgs[_gameType])) - ); + if (gameArgs[_gameType].length == 0) { + // Clone the implementation contract and initialize it with the given parameters. + // + // CWIA Calldata Layout: + // ┌──────────────────────┬─────────────────────────────────────┐ + // │ Bytes │ Description │ + // ├──────────────────────┼─────────────────────────────────────┤ + // │ [0, 20) │ Game creator address │ + // │ [20, 52) │ Root claim │ + // │ [52, 84) │ Parent block hash at creation time │ + // │ [84, 84 + n) │ Extra data (opaque) │ + // └──────────────────────┴─────────────────────────────────────┘ + proxy_ = IDisputeGame(address(impl).clone(abi.encodePacked(msg.sender, _rootClaim, parentHash, _extraData))); + } else { + // Clone the implementation contract and initialize it with the given parameters. + // + // CWIA Calldata Layout: + // ┌──────────────────────┬─────────────────────────────────────┐ + // │ Bytes │ Description │ + // ├──────────────────────┼─────────────────────────────────────┤ + // │ [0, 20) │ Game creator address │ + // │ [20, 52) │ Root claim │ + // │ [52, 84) │ Parent block hash at creation time │ + // │ [84, 88) │ Game type │ + // │ [88, 88 + n) │ Extra data (opaque) │ + // │ [88 + n, 88 + n + m) │ Implementation args (opaque) │ + // └──────────────────────┴─────────────────────────────────────┘ + proxy_ = IDisputeGame( + address(impl).clone( + abi.encodePacked(msg.sender, _rootClaim, parentHash, _gameType, _extraData, gameArgs[_gameType]) + ) + ); + } proxy_.initialize{ value: msg.value }(); // Compute the unique identifier for the dispute game. diff --git a/packages/contracts-bedrock/src/dispute/v2/FaultDisputeGameV2.sol b/packages/contracts-bedrock/src/dispute/v2/FaultDisputeGameV2.sol index 6f50e7c612f..eb373b027c4 100644 --- a/packages/contracts-bedrock/src/dispute/v2/FaultDisputeGameV2.sol +++ b/packages/contracts-bedrock/src/dispute/v2/FaultDisputeGameV2.sol @@ -56,7 +56,6 @@ import { GameNotFinalized, InvalidBondDistributionMode, GameNotResolved, - ReservedGameType, GamePaused, BadExtraData } from "src/dispute/lib/Errors.sol"; @@ -97,7 +96,6 @@ contract FaultDisputeGameV2 is Clone, ISemver { /// @notice Parameters for creating a new FaultDisputeGame. We place this into a struct to /// avoid stack-too-deep errors when compiling without the optimizer enabled. struct GameConstructorParams { - GameType gameType; uint256 maxGameDepth; uint256 splitDepth; Duration clockExtension; @@ -135,9 +133,6 @@ contract FaultDisputeGameV2 is Clone, ISemver { /// @notice The maximum duration that may accumulate on a team's chess clock before they may no longer respond. Duration internal immutable MAX_CLOCK_DURATION; - /// @notice The game type ID. - GameType internal immutable GAME_TYPE; - /// @notice The duration of the clock extension. Will be doubled if the grandchild is the root claim of an execution /// trace bisection subgame. Duration internal immutable CLOCK_EXTENSION; @@ -151,9 +146,9 @@ contract FaultDisputeGameV2 is Clone, ISemver { uint256 internal constant HEADER_BLOCK_NUMBER_INDEX = 8; /// @notice Semantic version. - /// @custom:semver 2.1.0 + /// @custom:semver 2.2.0 function version() public pure virtual returns (string memory) { - return "2.1.0"; + return "2.2.0"; } /// @notice The starting timestamp of the game @@ -224,10 +219,6 @@ contract FaultDisputeGameV2 is Clone, ISemver { // The split depth cannot be 0 or 1 to stay in bounds of clock extension arithmetic. if (_params.splitDepth < 2) revert InvalidSplitDepth(); - // Block type(uint32).max from being used as a game type so that it can be used in the - // OptimismPortal respected game type trick. - if (_params.gameType.raw() == type(uint32).max) revert ReservedGameType(); - // Validate clock extension bounds that don't require VM access. // The split depth extension is always clockExtension * 2. uint256 splitDepthExtension = uint256(_params.clockExtension.raw()) * 2; @@ -239,7 +230,6 @@ contract FaultDisputeGameV2 is Clone, ISemver { if (uint64(splitDepthExtension) > _params.maxClockDuration.raw()) revert InvalidClockExtension(); // Set up initial game state. - GAME_TYPE = _params.gameType; MAX_GAME_DEPTH = _params.maxGameDepth; SPLIT_DEPTH = _params.splitDepth; CLOCK_EXTENSION = _params.clockExtension; @@ -324,7 +314,7 @@ contract FaultDisputeGameV2 is Clone, ISemver { // Set whether the game type was respected when the game was created. wasRespectedGameTypeWhenCreated = - GameType.unwrap(anchorStateRegistry().respectedGameType()) == GameType.unwrap(GAME_TYPE); + GameType.unwrap(anchorStateRegistry().respectedGameType()) == GameType.unwrap(gameType()); } /// @notice Returns the expected calldata length for the initialize method @@ -342,13 +332,14 @@ contract FaultDisputeGameV2 is Clone, ISemver { // - 20 bytes: creator address // - 32 bytes: root claim // - 32 bytes: l1 head + // - 4 bytes: game type // - 32 bytes: extraData // - 32 bytes: absolutePrestate // - 20 bytes: vm address // - 20 bytes: anchorStateRegistry address // - 20 bytes: weth address // - 32 bytes: l2ChainId - return 240; + return 244; } //////////////////////////////////////////////////////////////// @@ -637,7 +628,7 @@ contract FaultDisputeGameV2 is Clone, ISemver { /// @notice The l2BlockNumber of the disputed output root in the `L2OutputOracle`. function l2BlockNumber() public pure returns (uint256 l2BlockNumber_) { - l2BlockNumber_ = _getArgUint256(84); + l2BlockNumber_ = _getArgUint256(88); } /// @notice The l2SequenceNumber of the disputed output root in the `L2OutputOracle` (in this case - block number). @@ -861,48 +852,55 @@ contract FaultDisputeGameV2 is Clone, ISemver { l1Head_ = Hash.wrap(_getArgBytes32(52)); } - /// @notice Getter for the extra data. + /// @notice Getter for the game type. /// @dev `clones-with-immutable-args` argument #4 + /// @return gameType_ The type of proof system being used. + function gameType() public pure returns (GameType gameType_) { + gameType_ = GameType.wrap(_getArgUint32(84)); + } + + /// @notice Getter for the extra data. + /// @dev `clones-with-immutable-args` argument #5 /// @return extraData_ Any extra data supplied to the dispute game contract by the creator. function extraData() public pure returns (bytes memory extraData_) { // The extra data starts at the second word within the cwia calldata and // is 32 bytes long. - extraData_ = _getArgBytes(84, 32); + extraData_ = _getArgBytes(88, 32); } /// @notice Getter for the absolute prestate of the instruction trace. - /// @dev `clones-with-immutable-args` argument #5 + /// @dev `clones-with-immutable-args` argument #6 /// @return absolutePrestate_ The absolute prestate of the instruction trace. function absolutePrestate() public pure returns (Claim absolutePrestate_) { - absolutePrestate_ = Claim.wrap(_getArgBytes32(116)); + absolutePrestate_ = Claim.wrap(_getArgBytes32(120)); } /// @notice Getter for the VM implementation. - /// @dev `clones-with-immutable-args` argument #6 + /// @dev `clones-with-immutable-args` argument #7 /// @return vm_ The onchain VM implementation address. function vm() public pure returns (IBigStepper vm_) { - vm_ = IBigStepper(_getArgAddress(148)); + vm_ = IBigStepper(_getArgAddress(152)); } /// @notice Getter for the anchor state registry. - /// @dev `clones-with-immutable-args` argument #7 + /// @dev `clones-with-immutable-args` argument #8 /// @return registry_ The anchor state registry contract address. function anchorStateRegistry() public pure returns (IAnchorStateRegistry registry_) { - registry_ = IAnchorStateRegistry(_getArgAddress(168)); + registry_ = IAnchorStateRegistry(_getArgAddress(172)); } /// @notice Getter for the WETH contract. - /// @dev `clones-with-immutable-args` argument #8 + /// @dev `clones-with-immutable-args` argument #9 /// @return weth_ The WETH contract for holding ETH. function weth() public pure returns (IDelayedWETH weth_) { - weth_ = IDelayedWETH(payable(_getArgAddress(188))); + weth_ = IDelayedWETH(payable(_getArgAddress(192))); } /// @notice Getter for the L2 chain ID. - /// @dev `clones-with-immutable-args` argument #9 + /// @dev `clones-with-immutable-args` argument #10 /// @return l2ChainId_ The L2 chain ID. function l2ChainId() public pure returns (uint256 l2ChainId_) { - l2ChainId_ = _getArgUint256(208); + l2ChainId_ = _getArgUint256(212); } /// @notice A compliant implementation of this interface should return the components of the @@ -912,20 +910,12 @@ contract FaultDisputeGameV2 is Clone, ISemver { /// @return gameType_ The type of proof system being used. /// @return rootClaim_ The root claim of the DisputeGame. /// @return extraData_ Any extra data supplied to the dispute game contract by the creator. - function gameData() external view returns (GameType gameType_, Claim rootClaim_, bytes memory extraData_) { + function gameData() external pure returns (GameType gameType_, Claim rootClaim_, bytes memory extraData_) { gameType_ = gameType(); rootClaim_ = rootClaim(); extraData_ = extraData(); } - /// @notice Getter for the game type. - /// @dev The reference impl should be entirely different depending on the type (fault, validity) - /// i.e. The game type should indicate the security model. - /// @return gameType_ The type of proof system being used. - function gameType() public view returns (GameType gameType_) { - gameType_ = GAME_TYPE; - } - //////////////////////////////////////////////////////////////// // MISC EXTERNAL // //////////////////////////////////////////////////////////////// diff --git a/packages/contracts-bedrock/src/dispute/v2/PermissionedDisputeGameV2.sol b/packages/contracts-bedrock/src/dispute/v2/PermissionedDisputeGameV2.sol index a1e658eea68..d0a9faa9afe 100644 --- a/packages/contracts-bedrock/src/dispute/v2/PermissionedDisputeGameV2.sol +++ b/packages/contracts-bedrock/src/dispute/v2/PermissionedDisputeGameV2.sol @@ -26,9 +26,9 @@ contract PermissionedDisputeGameV2 is FaultDisputeGameV2 { } /// @notice Semantic version. - /// @custom:semver 2.1.0 + /// @custom:semver 2.2.0 function version() public pure override returns (string memory) { - return "2.1.0"; + return "2.2.0"; } /// @param _params Parameters for creating a new FaultDisputeGame. diff --git a/packages/contracts-bedrock/test/dispute/DisputeGameFactory.t.sol b/packages/contracts-bedrock/test/dispute/DisputeGameFactory.t.sol index 9822612a61c..b5a55ff8b15 100644 --- a/packages/contracts-bedrock/test/dispute/DisputeGameFactory.t.sol +++ b/packages/contracts-bedrock/test/dispute/DisputeGameFactory.t.sol @@ -104,13 +104,12 @@ abstract contract DisputeGameFactory_TestInit is CommonTest { }); } - function _getGameConstructorParamsV2(GameType _gameType) + function _getGameConstructorParamsV2() internal pure returns (IFaultDisputeGameV2.GameConstructorParams memory params_) { return IFaultDisputeGameV2.GameConstructorParams({ - gameType: _gameType, maxGameDepth: 2 ** 3, splitDepth: 2 ** 2, clockExtension: Duration.wrap(3 hours), @@ -259,7 +258,7 @@ abstract contract DisputeGameFactory_TestInit is CommonTest { gameImpl_ = DeployUtils.create1({ _name: "FaultDisputeGameV2", _args: DeployUtils.encodeConstructor( - abi.encodeCall(IFaultDisputeGameV2.__constructor__, (_getGameConstructorParamsV2(GameTypes.CANNON))) + abi.encodeCall(IFaultDisputeGameV2.__constructor__, (_getGameConstructorParamsV2())) ) }); @@ -357,9 +356,7 @@ abstract contract DisputeGameFactory_TestInit is CommonTest { gameImpl_ = DeployUtils.create1({ _name: "PermissionedDisputeGameV2", _args: DeployUtils.encodeConstructor( - abi.encodeCall( - IPermissionedDisputeGameV2.__constructor__, (_getGameConstructorParamsV2(GameTypes.PERMISSIONED_CANNON)) - ) + abi.encodeCall(IPermissionedDisputeGameV2.__constructor__, (_getGameConstructorParamsV2())) ) }); diff --git a/packages/contracts-bedrock/test/dispute/FaultDisputeGame.t.sol b/packages/contracts-bedrock/test/dispute/FaultDisputeGame.t.sol index 026c1187e3f..e4970e0ad76 100644 --- a/packages/contracts-bedrock/test/dispute/FaultDisputeGame.t.sol +++ b/packages/contracts-bedrock/test/dispute/FaultDisputeGame.t.sol @@ -509,7 +509,6 @@ contract FaultDisputeGameV2_Constructor_Test is FaultDisputeGame_TestInit { IFaultDisputeGameV2.__constructor__, ( IFaultDisputeGameV2.GameConstructorParams({ - gameType: GAME_TYPE, maxGameDepth: _maxGameDepth, splitDepth: _maxGameDepth + 1, clockExtension: Duration.wrap(3 hours), @@ -534,7 +533,6 @@ contract FaultDisputeGameV2_Constructor_Test is FaultDisputeGame_TestInit { IFaultDisputeGameV2.__constructor__, ( IFaultDisputeGameV2.GameConstructorParams({ - gameType: GAME_TYPE, maxGameDepth: maxGameDepth, splitDepth: _splitDepth, clockExtension: Duration.wrap(3 hours), @@ -559,7 +557,6 @@ contract FaultDisputeGameV2_Constructor_Test is FaultDisputeGame_TestInit { IFaultDisputeGameV2.__constructor__, ( IFaultDisputeGameV2.GameConstructorParams({ - gameType: GAME_TYPE, maxGameDepth: 2 ** 3, splitDepth: _splitDepth, clockExtension: Duration.wrap(3 hours), @@ -592,7 +589,6 @@ contract FaultDisputeGameV2_Constructor_Test is FaultDisputeGame_TestInit { IFaultDisputeGameV2.__constructor__, ( IFaultDisputeGameV2.GameConstructorParams({ - gameType: GAME_TYPE, maxGameDepth: 16, splitDepth: 8, clockExtension: Duration.wrap(_clockExtension), @@ -603,29 +599,6 @@ contract FaultDisputeGameV2_Constructor_Test is FaultDisputeGame_TestInit { ) }); } - - /// @notice Tests that the constructor of the `FaultDisputeGame` reverts when the `_gameType` - /// parameter is set to the reserved `type(uint32).max` game type. - function test_constructor_reservedGameType_reverts() public { - vm.expectRevert(ReservedGameType.selector); - DeployUtils.create1({ - _name: "FaultDisputeGameV2", - _args: DeployUtils.encodeConstructor( - abi.encodeCall( - IFaultDisputeGameV2.__constructor__, - ( - IFaultDisputeGameV2.GameConstructorParams({ - gameType: GameType.wrap(type(uint32).max), - maxGameDepth: 16, - splitDepth: 8, - clockExtension: Duration.wrap(3 hours), - maxClockDuration: Duration.wrap(3.5 days) - }) - ) - ) - ) - }); - } } /// @title FaultDisputeGame_Initialize_Test @@ -2903,7 +2876,14 @@ contract FaultDisputeGame_Uncategorized_Test is FaultDisputeGame_TestInit { // Construct the expected CWIA data that the proxy will pass to the implementation, // alongside any extra calldata passed by the user. Hash l1Head = gameProxy.l1Head(); - bytes memory cwiaData = abi.encodePacked(address(this), gameProxy.rootClaim(), l1Head, gameProxy.extraData()); + bytes memory cwiaData; + if (isDevFeatureEnabled(DevFeatures.DEPLOY_V2_DISPUTE_GAMES)) { + cwiaData = abi.encodePacked( + address(this), gameProxy.rootClaim(), l1Head, gameProxy.gameType(), gameProxy.extraData() + ); + } else { + cwiaData = abi.encodePacked(address(this), gameProxy.rootClaim(), l1Head, gameProxy.extraData()); + } // We expect a `ReceiveETH` event to be emitted when 0 bytes of calldata are sent; The // fallback is always reached *within the minimal proxy* in `LibClone`'s version of diff --git a/packages/contracts-bedrock/test/opcm/DeployImplementations.t.sol b/packages/contracts-bedrock/test/opcm/DeployImplementations.t.sol index c0d2e784864..11faa7972f1 100644 --- a/packages/contracts-bedrock/test/opcm/DeployImplementations.t.sol +++ b/packages/contracts-bedrock/test/opcm/DeployImplementations.t.sol @@ -9,7 +9,6 @@ import { DeployUtils } from "scripts/libraries/DeployUtils.sol"; import { Chains } from "scripts/libraries/Chains.sol"; import { StandardConstants } from "scripts/deploy/StandardConstants.sol"; import { DevFeatures } from "src/libraries/DevFeatures.sol"; -import { GameTypes } from "src/dispute/lib/Types.sol"; // Interfaces import { ISuperchainConfig } from "interfaces/L1/ISuperchainConfig.sol"; @@ -335,11 +334,6 @@ contract DeployImplementations_Test is Test { ); // Validate constructor args for FaultDisputeGameV2 - assertEq( - uint256(output.faultDisputeGameV2Impl.gameType().raw()), - uint256(GameTypes.CANNON.raw()), - "FaultDisputeGameV2 gameType incorrect" - ); assertEq(output.faultDisputeGameV2Impl.maxGameDepth(), 73, "FaultDisputeGameV2 maxGameDepth incorrect"); assertEq(output.faultDisputeGameV2Impl.splitDepth(), 30, "FaultDisputeGameV2 splitDepth incorrect"); assertEq( @@ -352,11 +346,6 @@ contract DeployImplementations_Test is Test { ); // Validate constructor args for PermissionedDisputeGameV2 - assertEq( - uint256(output.permissionedDisputeGameV2Impl.gameType().raw()), - uint256(GameTypes.PERMISSIONED_CANNON.raw()), - "PermissionedDisputeGameV2 gameType incorrect" - ); assertEq( output.permissionedDisputeGameV2Impl.maxGameDepth(), 73, "PermissionedDisputeGameV2 maxGameDepth incorrect" ); @@ -476,11 +465,6 @@ contract DeployImplementations_Test is Test { ); // Validate constructor args for FaultDisputeGameV2 - assertEq( - uint256(output1.faultDisputeGameV2Impl.gameType().raw()), - uint256(GameTypes.CANNON.raw()), - "FaultDisputeGameV2 gameType incorrect" - ); assertEq(output1.faultDisputeGameV2Impl.maxGameDepth(), 73, "FaultDisputeGameV2 maxGameDepth incorrect"); assertEq(output1.faultDisputeGameV2Impl.splitDepth(), 30, "FaultDisputeGameV2 splitDepth incorrect"); assertEq( @@ -493,11 +477,6 @@ contract DeployImplementations_Test is Test { ); // Validate constructor args for PermissionedDisputeGameV2 - assertEq( - uint256(output1.permissionedDisputeGameV2Impl.gameType().raw()), - uint256(GameTypes.PERMISSIONED_CANNON.raw()), - "PermissionedDisputeGameV2 gameType incorrect" - ); assertEq( output1.permissionedDisputeGameV2Impl.maxGameDepth(), 73, "PermissionedDisputeGameV2 maxGameDepth incorrect" ); From 8a2804f6f1db33e431da3d71c40c98882e766a76 Mon Sep 17 00:00:00 2001 From: Stefano Charissis Date: Mon, 20 Oct 2025 12:15:48 +1100 Subject: [PATCH 089/117] fix(Makefile): remove Makefile sharding; rely on (op-e2e) in-test sharding (#17930) * fix(Makefile): remove Makefile sharding; rely on (op-e2e) in-test sharding * fix(op-e2e): TestSystemP2PAltSync Ensure L1 chain config is provided. --- Makefile | 33 +++++++------------------------ op-e2e/system/p2p/reqresp_test.go | 3 +++ 2 files changed, 10 insertions(+), 26 deletions(-) diff --git a/Makefile b/Makefile index 44961c9df1b..14bc12b6a11 100644 --- a/Makefile +++ b/Makefile @@ -276,32 +276,13 @@ _go-tests-ci-internal: @echo "Running Go tests with gotestsum..." $(DEFAULT_TEST_ENV_VARS) && \ $(CI_ENV_VARS) && \ - if [ -n "$$CIRCLE_NODE_TOTAL" ] && [ "$$CIRCLE_NODE_TOTAL" -gt 1 ]; then \ - export NODE_INDEX=$${CIRCLE_NODE_INDEX:-0} && \ - export NODE_TOTAL=$${CIRCLE_NODE_TOTAL:-1} && \ - export PARALLEL_PACKAGES=$$(echo "$(ALL_TEST_PACKAGES)" | tr ' ' '\n' | awk -v idx=$$NODE_INDEX -v total=$$NODE_TOTAL 'NR % total == idx' | tr '\n' ' ') && \ - if [ -n "$$PARALLEL_PACKAGES" ]; then \ - echo "Node $$NODE_INDEX/$$NODE_TOTAL running packages: $$PARALLEL_PACKAGES"; \ - gotestsum --format=testname \ - --junitfile=./tmp/test-results/results-$$NODE_INDEX.xml \ - --jsonfile=./tmp/testlogs/log-$$NODE_INDEX.json \ - --rerun-fails=3 \ - --rerun-fails-max-failures=50 \ - --packages="$$PARALLEL_PACKAGES" \ - -- -parallel=$$PARALLEL -coverprofile=coverage-$$NODE_INDEX.out $(GO_TEST_FLAGS) -timeout=$(TEST_TIMEOUT) -tags="ci"; \ - else \ - echo "ERROR: Node $$NODE_INDEX/$$NODE_TOTAL has no packages to run! Perhaps parallelism is set too high? (ALL_TEST_PACKAGES has $$(echo '$(ALL_TEST_PACKAGES)' | wc -w) packages)"; \ - exit 1; \ - fi; \ - else \ - gotestsum --format=testname \ - --junitfile=./tmp/test-results/results.xml \ - --jsonfile=./tmp/testlogs/log.json \ - --rerun-fails=3 \ - --rerun-fails-max-failures=50 \ - --packages="$(ALL_TEST_PACKAGES)" \ - -- -parallel=$$PARALLEL -coverprofile=coverage.out $(GO_TEST_FLAGS) -timeout=$(TEST_TIMEOUT) -tags="ci"; \ - fi + gotestsum --format=testname \ + --junitfile=./tmp/test-results/results.xml \ + --jsonfile=./tmp/testlogs/log.json \ + --rerun-fails=3 \ + --rerun-fails-max-failures=50 \ + --packages="$(ALL_TEST_PACKAGES)" \ + -- -parallel=$$PARALLEL -coverprofile=coverage.out $(GO_TEST_FLAGS) -timeout=$(TEST_TIMEOUT) -tags="ci"; .PHONY: _go-tests-ci-internal go-tests-short-ci: ## Runs short Go tests with gotestsum for CI (assumes deps built by CI) diff --git a/op-e2e/system/p2p/reqresp_test.go b/op-e2e/system/p2p/reqresp_test.go index 4f5c86eae72..bb9b195a51e 100644 --- a/op-e2e/system/p2p/reqresp_test.go +++ b/op-e2e/system/p2p/reqresp_test.go @@ -144,6 +144,9 @@ func TestSystemP2PAltSync(t *testing.T) { e2esys.ConfigureL2(syncNodeCfg, syncerL2Engine, cfg.JWTSecret) + // Ensure L1 chain configuration is provided for the sync node + syncNodeCfg.L1ChainConfig = sys.L1GenesisCfg.Config + syncerNode, err := rollupNode.New(ctx, syncNodeCfg, cfg.Loggers["syncer"], "", metrics.NewMetrics("")) require.NoError(t, err) err = syncerNode.Start(ctx) From b9b1429b3c342a5a8c81cf4dc1d420b767474649 Mon Sep 17 00:00:00 2001 From: Adrian Sutton Date: Tue, 21 Oct 2025 08:59:35 +1000 Subject: [PATCH 090/117] ci: Use a fixed version of mise in golang docker builds (#17954) --- ops/docker/op-stack-go/Dockerfile | 8 +- .../op-stack-go/Dockerfile.dockerignore | 1 + ops/scripts/install_mise.sh | 303 ++++++++++++++++++ 3 files changed, 307 insertions(+), 5 deletions(-) create mode 100644 ops/scripts/install_mise.sh diff --git a/ops/docker/op-stack-go/Dockerfile b/ops/docker/op-stack-go/Dockerfile index 56116e6deaa..31e3251da9c 100644 --- a/ops/docker/op-stack-go/Dockerfile +++ b/ops/docker/op-stack-go/Dockerfile @@ -26,18 +26,16 @@ FROM --platform=$BUILDPLATFORM golang:1.23.8-alpine3.20 AS builder RUN apk add --no-cache curl tar gzip make gcc musl-dev linux-headers git jq bash # Install mise (the apk version is outdated) -RUN curl https://mise.run | MISE_INSTALL_PATH=/usr/local/bin/mise sh +COPY ./ops/scripts/install_mise.sh /tmp/install_mise.sh +RUN MISE_INSTALL_PATH=/usr/local/bin/mise sh /tmp/install_mise.sh ARG TARGETARCH -# Install yq -RUN wget https://github.com/mikefarah/yq/releases/latest/download/yq_linux_$TARGETARCH -O /usr/local/bin/yq && \ - chmod +x /usr/local/bin/yq - # Install versioned toolchain COPY ./mise.toml . RUN mise trust RUN mise install -v -y just && cp $(mise which just) /usr/local/bin/just && just --version +RUN mise install -v -y yq && cp $(mise which yq) /usr/local/bin/yq && yq --version # mise does not install the alpine binary for forge, so we download it manually COPY ./op-deployer/pkg/deployer/forge/version.json /tmp/op-deployer-versions.json RUN set -e && \ diff --git a/ops/docker/op-stack-go/Dockerfile.dockerignore b/ops/docker/op-stack-go/Dockerfile.dockerignore index 343892972f7..16a60a2bff6 100644 --- a/ops/docker/op-stack-go/Dockerfile.dockerignore +++ b/ops/docker/op-stack-go/Dockerfile.dockerignore @@ -29,6 +29,7 @@ !/justfiles !/mise.toml !/op-e2e/e2eutils +!./ops/scripts/install_mise.sh **/bin **/testdata diff --git a/ops/scripts/install_mise.sh b/ops/scripts/install_mise.sh new file mode 100644 index 00000000000..2050420ddba --- /dev/null +++ b/ops/scripts/install_mise.sh @@ -0,0 +1,303 @@ +#!/bin/sh +set -eu + +if command -v mise; then + echo "mise already installed at $(command -v mise)" + exit 0 +fi + +#region logging setup +if [ "${MISE_DEBUG-}" = "true" ] || [ "${MISE_DEBUG-}" = "1" ]; then + debug() { + echo "$@" >&2 + } +else + debug() { + : + } +fi + +if [ "${MISE_QUIET-}" = "1" ] || [ "${MISE_QUIET-}" = "true" ]; then + info() { + : + } +else + info() { + echo "$@" >&2 + } +fi + +error() { + echo "$@" >&2 + exit 1 +} +#endregion + +#region environment setup +get_os() { + os="$(uname -s)" + if [ "$os" = Darwin ]; then + echo "macos" + elif [ "$os" = Linux ]; then + echo "linux" + else + error "unsupported OS: $os" + fi +} + +get_arch() { + musl="" + if type ldd >/dev/null 2>/dev/null; then + libc=$(ldd /bin/ls | grep 'musl' | head -1 | cut -d ' ' -f1) + if [ -n "$libc" ]; then + musl="-musl" + fi + fi + arch="$(uname -m)" + if [ "$arch" = x86_64 ]; then + echo "x64$musl" + elif [ "$arch" = aarch64 ] || [ "$arch" = arm64 ]; then + echo "arm64$musl" + elif [ "$arch" = armv7l ]; then + echo "armv7$musl" + else + error "unsupported architecture: $arch" + fi +} + +get_ext() { + if [ -n "${MISE_INSTALL_EXT:-}" ]; then + echo "$MISE_INSTALL_EXT" + elif [ -n "${MISE_VERSION:-}" ] && echo "$MISE_VERSION" | grep -q '^v2024'; then + # 2024 versions don't have zstd tarballs + echo "tar.gz" + elif tar_supports_zstd; then + echo "tar.zst" + elif command -v zstd >/dev/null 2>&1; then + echo "tar.zst" + else + echo "tar.gz" + fi +} + +tar_supports_zstd() { + # tar is bsdtar or version is >= 1.31 + if tar --version | grep -q 'bsdtar' && command -v zstd >/dev/null 2>&1; then + true + elif tar --version | grep -q '1\.(3[1-9]|[4-9][0-9]'; then + true + else + false + fi +} + +shasum_bin() { + if command -v shasum >/dev/null 2>&1; then + echo "shasum" + elif command -v sha256sum >/dev/null 2>&1; then + echo "sha256sum" + else + error "mise install requires shasum or sha256sum but neither is installed. Aborting." + fi +} + +get_checksum() { + version=$1 + os="$(get_os)" + arch="$(get_arch)" + ext="$(get_ext)" + url="https://github.com/jdx/mise/releases/download/v${version}/SHASUMS256.txt" + + # For current version use static checksum otherwise + # use checksum from releases + if [ "$version" = "v2025.3.2" ]; then + checksum_linux_x86_64="5d2e40270c32c906385c1b35c8dac0f995c4765b429aff5fe67e9efc9957aed5 ./mise-v2025.3.2-linux-x64.tar.gz" + checksum_linux_x86_64_musl="d8312658bd020b717a90bc2c3729625656c97b37c70edda645ce8bcbd68edf56 ./mise-v2025.3.2-linux-x64-musl.tar.gz" + checksum_linux_arm64="8dd66426b9f36f5c1bed161d3d79b2e12294c1c8a9801b1f654311e008787a5b ./mise-v2025.3.2-linux-arm64.tar.gz" + checksum_linux_arm64_musl="7746d2ab653caa73128936dd2bc7704fe4f106fa58597d65f5020843767f3ceb ./mise-v2025.3.2-linux-arm64-musl.tar.gz" + checksum_linux_armv7="a2a626b3e1d393e19fe600103e97659acec8de18f6868014928a2a3f68301307 ./mise-v2025.3.2-linux-armv7.tar.gz" + checksum_linux_armv7_musl="e3dc41cdf7ce857c322b8713fc619708ad7c8f1da8d5b00b7a6fb62f215819f6 ./mise-v2025.3.2-linux-armv7-musl.tar.gz" + checksum_macos_x86_64="c1f58a5772b80e2d7fe64f6c0dd832c38c5146deb763130f71f09984a5328acb ./mise-v2025.3.2-macos-x64.tar.gz" + checksum_macos_arm64="d5f836d2e946201147be4ca3467c547ab847a14f93b26c6a4f736804fc2107ef ./mise-v2025.3.2-macos-arm64.tar.gz" + checksum_linux_x86_64_zstd="ea4f403772ec034bc11f654f410aeaade40fcffc1cee78fd02340f8bae3e9db7 ./mise-v2025.3.2-linux-x64.tar.zst" + checksum_linux_x86_64_musl_zstd="c7c6f96421658eb7cb8f7fd8cb37e36fc91b025d0564899828376d07789a80b4 ./mise-v2025.3.2-linux-x64-musl.tar.zst" + checksum_linux_arm64_zstd="5696404d02481cd8bd9d9d8a721ec80141f3f74cb0f77f3eee0bbf3fc0f9b20b ./mise-v2025.3.2-linux-arm64.tar.zst" + checksum_linux_arm64_musl_zstd="68695587360d52bd6889e11ff79ff1b18a533fc81c56dadf213db9364b1ca082 ./mise-v2025.3.2-linux-arm64-musl.tar.zst" + checksum_linux_armv7_zstd="6411d630c4515a49ab903865647a1da0fa3fe97c4a990ccd078364abcb6b2d7b ./mise-v2025.3.2-linux-armv7.tar.zst" + checksum_linux_armv7_musl_zstd="fbcbd945b7700f9c54e7dea423010889df1a51ca3edf25b20a01766e706619d5 ./mise-v2025.3.2-linux-armv7-musl.tar.zst" + checksum_macos_x86_64_zstd="af0af814ad8aa8828bd4cef455f3edc4059984ea3490bec4827778ca9c73951b ./mise-v2025.3.2-macos-x64.tar.zst" + checksum_macos_arm64_zstd="30763db42007598d8c6042d88bf6045bb3834e8d12a0844a5aa0005d609beb8b ./mise-v2025.3.2-macos-arm64.tar.zst" + + # TODO: refactor this, it's a bit messy + if [ "$(get_ext)" = "tar.zst" ]; then + if [ "$os" = "linux" ]; then + if [ "$arch" = "x64" ]; then + echo "$checksum_linux_x86_64_zstd" + elif [ "$arch" = "x64-musl" ]; then + echo "$checksum_linux_x86_64_musl_zstd" + elif [ "$arch" = "arm64" ]; then + echo "$checksum_linux_arm64_zstd" + elif [ "$arch" = "arm64-musl" ]; then + echo "$checksum_linux_arm64_musl_zstd" + elif [ "$arch" = "armv7" ]; then + echo "$checksum_linux_armv7_zstd" + elif [ "$arch" = "armv7-musl" ]; then + echo "$checksum_linux_armv7_musl_zstd" + else + warn "no checksum for $os-$arch" + fi + elif [ "$os" = "macos" ]; then + if [ "$arch" = "x64" ]; then + echo "$checksum_macos_x86_64_zstd" + elif [ "$arch" = "arm64" ]; then + echo "$checksum_macos_arm64_zstd" + else + warn "no checksum for $os-$arch" + fi + else + warn "no checksum for $os-$arch" + fi + else + if [ "$os" = "linux" ]; then + if [ "$arch" = "x64" ]; then + echo "$checksum_linux_x86_64" + elif [ "$arch" = "x64-musl" ]; then + echo "$checksum_linux_x86_64_musl" + elif [ "$arch" = "arm64" ]; then + echo "$checksum_linux_arm64" + elif [ "$arch" = "arm64-musl" ]; then + echo "$checksum_linux_arm64_musl" + elif [ "$arch" = "armv7" ]; then + echo "$checksum_linux_armv7" + elif [ "$arch" = "armv7-musl" ]; then + echo "$checksum_linux_armv7_musl" + else + warn "no checksum for $os-$arch" + fi + elif [ "$os" = "macos" ]; then + if [ "$arch" = "x64" ]; then + echo "$checksum_macos_x86_64" + elif [ "$arch" = "arm64" ]; then + echo "$checksum_macos_arm64" + else + warn "no checksum for $os-$arch" + fi + else + warn "no checksum for $os-$arch" + fi + fi + else + if command -v curl >/dev/null 2>&1; then + debug ">" curl -fsSL "$url" + checksums="$(curl --compressed -fsSL "$url")" + else + if command -v wget >/dev/null 2>&1; then + debug ">" wget -qO - "$url" + stderr=$(mktemp) + checksums="$(wget -qO - "$url")" + else + error "mise standalone install specific version requires curl or wget but neither is installed. Aborting." + fi + fi + # TODO: verify with minisign or gpg if available + + checksum="$(echo "$checksums" | grep "$os-$arch.$ext")" + if ! echo "$checksum" | grep -Eq "^([0-9a-f]{32}|[0-9a-f]{64})"; then + warn "no checksum for mise $version and $os-$arch" + else + echo "$checksum" + fi + fi +} + +#endregion + +download_file() { + url="$1" + filename="$(basename "$url")" + cache_dir="$(mktemp -d)" + file="$cache_dir/$filename" + + info "mise: installing mise..." + + if command -v curl >/dev/null 2>&1; then + debug ">" curl -#fLo "$file" "$url" + curl -#fLo "$file" "$url" + else + if command -v wget >/dev/null 2>&1; then + debug ">" wget -qO "$file" "$url" + stderr=$(mktemp) + wget -O "$file" "$url" >"$stderr" 2>&1 || error "wget failed: $(cat "$stderr")" + else + error "mise standalone install requires curl or wget but neither is installed. Aborting." + fi + fi + + echo "$file" +} + +install_mise() { + version="${MISE_VERSION:-v2025.3.2}" + version="${version#v}" + os="$(get_os)" + arch="$(get_arch)" + ext="$(get_ext)" + install_path="${MISE_INSTALL_PATH:-$HOME/.local/bin/mise}" + + if [ -x "$install_path" ]; then + debug "mise-setup: already installed" + exit 0 + fi + + install_dir="$(dirname "$install_path")" + tarball_url="https://github.com/jdx/mise/releases/download/v${version}/mise-v${version}-${os}-${arch}.${ext}" + + cache_file=$(download_file "$tarball_url") + debug "mise-setup: tarball=$cache_file" + + debug "validating checksum" + cd "$(dirname "$cache_file")" && get_checksum "$version" | "$(shasum_bin)" -c >/dev/null + + # extract tarball + mkdir -p "$install_dir" + rm -rf "$install_path" + cd "$(mktemp -d)" + if [ "$(get_ext)" = "tar.zst" ] && ! tar_supports_zstd; then + zstd -d -c "$cache_file" | tar -xf - + else + tar -xf "$cache_file" + fi + mv mise/bin/mise "$install_path" + info "mise: installed successfully to $install_path" +} + +after_finish_help() { + case "${SHELL:-}" in + */zsh) + info "mise: run the following to activate mise in your shell:" + info "echo \"eval \\\"\\\$($install_path activate zsh)\\\"\" >> \"${ZDOTDIR-$HOME}/.zshrc\"" + info "" + info "mise: run \`mise doctor\` to verify this is setup correctly" + ;; + */bash) + info "mise: run the following to activate mise in your shell:" + info "echo \"eval \\\"\\\$($install_path activate bash)\\\"\" >> ~/.bashrc" + info "" + info "mise: run \`mise doctor\` to verify this is setup correctly" + ;; + */fish) + info "mise: run the following to activate mise in your shell:" + info "echo \"$install_path activate fish | source\" >> ~/.config/fish/config.fish" + info "" + info "mise: run \`mise doctor\` to verify this is setup correctly" + ;; + *) + info "mise: run \`$install_path --help\` to get started" + ;; + esac +} + +install_mise +if [ "${MISE_INSTALL_HELP-}" != 0 ]; then + after_finish_help +fi From 4ecf8acebe7ea6b775e2de70a529cf1e2e5308f6 Mon Sep 17 00:00:00 2001 From: George Knee Date: Tue, 21 Oct 2025 06:26:11 +0100 Subject: [PATCH 091/117] op-devstack/dsl/operator_fee: compute expected vault increase from all transactions in block (#17935) * op-service: expose BalanceAtHash method * op-devstack/dsl/operator_fee: compute expected vault increase from all transactions in block * Revert "op-service: expose BalanceAtHash method" This reverts commit 078fc26ec1ff3b352a300ed46ee6b979fefb463b. * revert to checking balance by block number * query "prior" operator fee vault balance by block number --- op-devstack/dsl/operator_fee.go | 70 ++++++++++++++++++++------------- 1 file changed, 43 insertions(+), 27 deletions(-) diff --git a/op-devstack/dsl/operator_fee.go b/op-devstack/dsl/operator_fee.go index 71559ddc700..a409a2e2517 100644 --- a/op-devstack/dsl/operator_fee.go +++ b/op-devstack/dsl/operator_fee.go @@ -131,49 +131,65 @@ func (of *OperatorFee) VerifyL2Config(expectedScalar uint32, expectedConstant ui } func (of *OperatorFee) ValidateTransactionFees(from *EOA, to *EOA, amount *big.Int, expectedScalar uint32, expectedConstant uint64) OperatorFeeValidationResult { - vaultBefore, err := from.el.stackEL().EthClient().BalanceAt(of.ctx, predeploys.OperatorFeeVaultAddr, nil) - of.require.NoError(err) - + // Ensure there is at least one user transaction, to trigger flow of operator fees to vault. tx := from.Transfer(to.Address(), eth.WeiBig(amount)) receipt, err := tx.Included.Eval(of.ctx) of.require.NoError(err) of.require.Equal(types.ReceiptStatusSuccessful, receipt.Status) blockHash := receipt.BlockHash - blockRef, err := from.el.stackEL().EthClient().BlockRefByHash(of.ctx, blockHash) + info, txs, err := from.el.stackEL().EthClient().InfoAndTxsByHash(of.ctx, blockHash) of.require.NoError(err) - isJovian := of.l2Network.IsForkActive(rollup.Jovian, blockRef.Time) - vaultAfter, err := from.el.stackEL().EthClient().BalanceAt(of.ctx, predeploys.OperatorFeeVaultAddr, nil) + // Infer active fork from block info + isJovian := of.l2Network.IsForkActive(rollup.Jovian, info.Time()) + + // Verify GPO upgraded and jovian active + isJovianinGPO, err := contractio.Read(of.gasPriceOracle.IsJovian(), of.ctx) of.require.NoError(err) + if isJovian { + of.require.Equal(isJovianinGPO, true) + } else { + of.require.Equal(isJovianinGPO, false) + } + // Get updated balance in operator fee vault to compute delta + vaultAfter, err := from.el.stackEL().EthClient().BalanceAt(of.ctx, predeploys.OperatorFeeVaultAddr, receipt.BlockNumber) + of.require.NoError(err) + vaultBefore, err := from.el.stackEL().EthClient().BalanceAt(of.ctx, predeploys.OperatorFeeVaultAddr, big.NewInt(0).Sub(receipt.BlockNumber, big.NewInt(1))) + of.require.NoError(err) vaultIncrease := new(big.Int).Sub(vaultAfter, vaultBefore) - var expectedOperatorFee *big.Int - if expectedScalar == 0 && expectedConstant == 0 { - expectedOperatorFee = big.NewInt(0) - } else { - isJovianinGPO, err := contractio.Read(of.gasPriceOracle.IsJovian(), of.ctx) - of.require.NoError(err) - - operatorFee := new(big.Int).Mul(big.NewInt(int64(receipt.GasUsed)), big.NewInt(int64(expectedScalar))) - if isJovian { - of.require.Equal(isJovianinGPO, true) - // Jovian formula: (gasUsed * operatorFeeScalar * 100) + operatorFeeConstant - operatorFee.Mul(operatorFee, big.NewInt(100)) - } else { - of.require.Equal(isJovianinGPO, false) - // Isthmus formula: (gasUsed * operatorFeeScalar / 1e6) + operatorFeeConstant - operatorFee.Div(operatorFee, big.NewInt(1000000)) + // Loop through transactions in block to compute expected operator fee vault increase + expectedOperatorFeeVaultIncrease := big.NewInt(0) + if !(expectedScalar == 0 && expectedConstant == 0) { + // The test submits one user transaction but we loop over all user transactions + // to make the test robust to any other traffic on the chain. + for _, tx := range txs { + if tx.Type() == types.DepositTxType { + continue + } + receipt, err := from.el.stackEL().EthClient().TransactionReceipt(of.ctx, tx.Hash()) + of.require.NoError(err) + + operatorFee := new(big.Int).Mul(big.NewInt(int64(receipt.GasUsed)), big.NewInt(int64(expectedScalar))) + if isJovian { + // Jovian formula: (gasUsed * operatorFeeScalar * 100) + operatorFeeConstant + operatorFee.Mul(operatorFee, big.NewInt(100)) + } else { + // Isthmus formula: (gasUsed * operatorFeeScalar / 1e6) + operatorFeeConstant + operatorFee.Div(operatorFee, big.NewInt(1000000)) + } + operatorFee.Add(operatorFee, big.NewInt(int64(expectedConstant))) + expectedOperatorFeeVaultIncrease = + expectedOperatorFeeVaultIncrease.Add(expectedOperatorFeeVaultIncrease, operatorFee) } - operatorFee.Add(operatorFee, big.NewInt(int64(expectedConstant))) - expectedOperatorFee = operatorFee } // Use Cmp for big.Int comparison to avoid representation issues - of.require.Equal(0, expectedOperatorFee.Cmp(vaultIncrease), + of.require.Equal(0, expectedOperatorFeeVaultIncrease.Cmp(vaultIncrease), "operator fee vault balance mismatch: expected %s, got %s", - expectedOperatorFee.String(), vaultIncrease.String()) + expectedOperatorFeeVaultIncrease.String(), vaultIncrease.String()) actualTotalFee := new(big.Int).Mul(receipt.EffectiveGasPrice, big.NewInt(int64(receipt.GasUsed))) if receipt.L1Fee != nil { @@ -190,7 +206,7 @@ func (of *OperatorFee) ValidateTransactionFees(from *EOA, to *EOA, amount *big.I return OperatorFeeValidationResult{ TransactionReceipt: receipt, - ExpectedOperatorFee: expectedOperatorFee, + ExpectedOperatorFee: expectedOperatorFeeVaultIncrease, ActualTotalFee: actualTotalFee, VaultBalanceIncrease: vaultIncrease, } From aef7a88d2db1ef9c445dfce83eef62e036aab7a2 Mon Sep 17 00:00:00 2001 From: Matthew Slipper Date: Mon, 20 Oct 2025 23:51:30 -0600 Subject: [PATCH 092/117] ci: Clean up op-deployer caches (#17959) * ci: Clean up op-deployer caches We keep running into issues where OPD caches are not properly cleaned up in tests. This adds a stopgap that cleans them up after every test to prevent disk usage exploding on our self-hosted runners. * bump --- .circleci/config.yml | 5 +++++ 1 file changed, 5 insertions(+) diff --git a/.circleci/config.yml b/.circleci/config.yml index 5c9f71c6b91..553de84f10c 100644 --- a/.circleci/config.yml +++ b/.circleci/config.yml @@ -1321,6 +1321,11 @@ jobs: tar -czf testlogs.tar.gz -C ./tmp testlogs fi when: always + - run: + name: Clean up op-deployer artifacts + command: | + rm -rf ~/.op-deployer/* + when: always - store_artifacts: path: testlogs*.tar.gz when: always From 49bc553d7e199676159336799f873bfab90f7276 Mon Sep 17 00:00:00 2001 From: opgitgovernance Date: Tue, 21 Oct 2025 09:18:10 +0200 Subject: [PATCH 093/117] chore(op-acceptance-tests): flake-shake; test promotions (#17951) --- op-acceptance-tests/acceptance-tests.yaml | 5 ----- 1 file changed, 5 deletions(-) diff --git a/op-acceptance-tests/acceptance-tests.yaml b/op-acceptance-tests/acceptance-tests.yaml index 864bacdcb07..4c920d1fea0 100644 --- a/op-acceptance-tests/acceptance-tests.yaml +++ b/op-acceptance-tests/acceptance-tests.yaml @@ -15,11 +15,6 @@ gates: - id: flake-shake description: "Quarantine gate for new and potentially flaky tests requiring stability validation." tests: - - package: github.com/ethereum-optimism/optimism/op-acceptance-tests/tests/supernode - name: TestCLAdvanceMultiple - timeout: 10m - metadata: - owner: "axel" - package: github.com/ethereum-optimism/optimism/op-acceptance-tests/tests/sync/elsync/gap_elp2p name: TestL2ELP2PCanonicalChainAdvancedByFCU timeout: 30m From a492f731152a882c75da532a24df1258eabcd0fc Mon Sep 17 00:00:00 2001 From: Stefano Charissis Date: Tue, 21 Oct 2025 18:28:48 +1100 Subject: [PATCH 094/117] fix(op-acceptance-tests): flake-shake; slack notification channel. (#17931) --- .circleci/config.yml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/.circleci/config.yml b/.circleci/config.yml index 553de84f10c..0462226fa0a 100644 --- a/.circleci/config.yml +++ b/.circleci/config.yml @@ -1772,7 +1772,7 @@ jobs: jq -c '{blocks: .}' /tmp/blocks.json > /tmp/slack_template.json echo 'export SLACK_TEMPLATE=$(cat /tmp/slack_template.json)' >> $BASH_ENV - slack/notify: - channel: notify-ci-failures + channel: C03N11M0BBN # "notify-ci" channel event: always retries: 1 retry_delay: 3 From 48ff55d8a06f8162ae34527eda8417e203362309 Mon Sep 17 00:00:00 2001 From: Inphi Date: Tue, 21 Oct 2025 05:26:07 -0400 Subject: [PATCH 095/117] opcm: Update upgrade method for disputegame-v2 (#17874) * opcm: Update upgrade method for disputegame-v2 * update opcm semver * check game args; run post-upgrade checks * update std validator semver lock * fix assertGameArgsLength error prefix * opcm and validator fixes * lint LibGameArgs * fix interfaces; natspec * fix natspec in opcm * forwards-compatible challenger/proposer retrieval * assert deployed CANNON game parameters * use v2 getters * review comments * fix asr getter name * use v1 functions for existing upgrade path --- .../IOPContractsManagerStandardValidator.sol | 2 + .../OPContractsManagerStandardValidator.json | 7 +- .../abi/OPContractsManagerUpgrader.json | 16 ++ .../snapshots/semver-lock.json | 8 +- .../src/L1/OPContractsManager.sol | 270 +++++++++++++++--- .../OPContractsManagerStandardValidator.sol | 164 +++++++++-- .../src/dispute/lib/Errors.sol | 7 + .../src/dispute/lib/LibGameArgs.sol | 77 +++++ .../test/L1/OPContractsManager.t.sol | 143 +++++++++- .../test/dispute/lib/LibGameArgs.t.sol | 128 +++++++++ .../test/setup/ForkLive.s.sol | 3 +- 11 files changed, 740 insertions(+), 85 deletions(-) create mode 100644 packages/contracts-bedrock/src/dispute/lib/LibGameArgs.sol create mode 100644 packages/contracts-bedrock/test/dispute/lib/LibGameArgs.t.sol diff --git a/packages/contracts-bedrock/interfaces/L1/IOPContractsManagerStandardValidator.sol b/packages/contracts-bedrock/interfaces/L1/IOPContractsManagerStandardValidator.sol index 15cb768e44d..56aa6dace01 100644 --- a/packages/contracts-bedrock/interfaces/L1/IOPContractsManagerStandardValidator.sol +++ b/packages/contracts-bedrock/interfaces/L1/IOPContractsManagerStandardValidator.sol @@ -34,6 +34,8 @@ interface IOPContractsManagerStandardValidator { address challenger; } + error InvalidGameArgsLength(); + function version() external view returns (string memory); function anchorStateRegistryImpl() external view returns (address); function challenger() external view returns (address); diff --git a/packages/contracts-bedrock/snapshots/abi/OPContractsManagerStandardValidator.json b/packages/contracts-bedrock/snapshots/abi/OPContractsManagerStandardValidator.json index 7ec9ab0bc71..b09166a2529 100644 --- a/packages/contracts-bedrock/snapshots/abi/OPContractsManagerStandardValidator.json +++ b/packages/contracts-bedrock/snapshots/abi/OPContractsManagerStandardValidator.json @@ -289,7 +289,7 @@ "type": "string" } ], - "stateMutability": "pure", + "stateMutability": "view", "type": "function" }, { @@ -465,5 +465,10 @@ ], "stateMutability": "view", "type": "function" + }, + { + "inputs": [], + "name": "InvalidGameArgsLength", + "type": "error" } ] \ No newline at end of file diff --git a/packages/contracts-bedrock/snapshots/abi/OPContractsManagerUpgrader.json b/packages/contracts-bedrock/snapshots/abi/OPContractsManagerUpgrader.json index a092f317994..df01bf97b0e 100644 --- a/packages/contracts-bedrock/snapshots/abi/OPContractsManagerUpgrader.json +++ b/packages/contracts-bedrock/snapshots/abi/OPContractsManagerUpgrader.json @@ -366,6 +366,22 @@ "name": "IdentityPrecompileCallFailed", "type": "error" }, + { + "inputs": [ + { + "internalType": "bytes32", + "name": "devFeature", + "type": "bytes32" + } + ], + "name": "InvalidDevFeatureAccess", + "type": "error" + }, + { + "inputs": [], + "name": "InvalidGameArgsLength", + "type": "error" + }, { "inputs": [], "name": "NotABlueprint", diff --git a/packages/contracts-bedrock/snapshots/semver-lock.json b/packages/contracts-bedrock/snapshots/semver-lock.json index b886419cf49..b087172884e 100644 --- a/packages/contracts-bedrock/snapshots/semver-lock.json +++ b/packages/contracts-bedrock/snapshots/semver-lock.json @@ -20,12 +20,12 @@ "sourceCodeHash": "0xfca613b5d055ffc4c3cbccb0773ddb9030abedc1aa6508c9e2e7727cc0cd617b" }, "src/L1/OPContractsManager.sol:OPContractsManager": { - "initCodeHash": "0x4025118658a1c56c4fc2d0166081e6d27da980318e749e7811c7178115e4413e", - "sourceCodeHash": "0xdb243ac7475b0214b8f662aa04f696d9ff213dade6b1bdade379e84df419b75a" + "initCodeHash": "0xc6a5146f158bc14297447cda1668f83e8dbfdd74f1b8bc2291d9626933bd23ad", + "sourceCodeHash": "0xd883ebfcc637ba9c6de12a872015098614cd288aaee84cda9d4c746aa1dcba18" }, "src/L1/OPContractsManagerStandardValidator.sol:OPContractsManagerStandardValidator": { - "initCodeHash": "0x57d6a6729d887ead009d518e8f17fa0d26bfc97b8efe1494ab4ef8dbb000d109", - "sourceCodeHash": "0x1d58891954cf782d2fe4f112b0c7fd25be991c2b8873f10d8545c653b517cac9" + "initCodeHash": "0x2eaa345ba05582c67b40a1eb7ec9d54823aa08468e697e2d6c04bb74cc574abc", + "sourceCodeHash": "0x30d7e4243a3bab7fea8504be2cd24f2c5ab3335b802d62282a374a458a08feec" }, "src/L1/OptimismPortal2.sol:OptimismPortal2": { "initCodeHash": "0x5bf576ea7f566e402a997204988471fc9b971410aa9dff8fe810b10baf6b7456", diff --git a/packages/contracts-bedrock/src/L1/OPContractsManager.sol b/packages/contracts-bedrock/src/L1/OPContractsManager.sol index d87b903c86e..b662cbfc672 100644 --- a/packages/contracts-bedrock/src/L1/OPContractsManager.sol +++ b/packages/contracts-bedrock/src/L1/OPContractsManager.sol @@ -13,6 +13,7 @@ import { Strings } from "@openzeppelin/contracts/utils/Strings.sol"; import { SemverComp } from "src/libraries/SemverComp.sol"; import { Features } from "src/libraries/Features.sol"; import { DevFeatures } from "src/libraries/DevFeatures.sol"; +import { LibGameArgs } from "src/dispute/lib/LibGameArgs.sol"; // Interfaces import { ISemver } from "interfaces/universal/ISemver.sol"; @@ -286,26 +287,80 @@ abstract contract OPContractsManagerBase { return _disputeGameFactory.gameImpls(_gameType); } - /// @notice Retrieves the Anchor State Registry for a given game - function getAnchorStateRegistry(IFaultDisputeGame _disputeGame) internal view returns (IAnchorStateRegistry) { + /// @notice Retrieves the Anchor State Registry for a given v1 game + function getAnchorStateRegistryV1(IFaultDisputeGame _disputeGame) internal view returns (IAnchorStateRegistry) { return _disputeGame.anchorStateRegistry(); } + /// @notice Retrieves the Anchor State Registry for a given v1 or v2 game + function getAnchorStateRegistry( + IDisputeGameFactory _disputeGameFactory, + IDisputeGame _disputeGame, + GameType _gameType + ) + internal + view + returns (IAnchorStateRegistry) + { + bytes memory gameArgsBytes = _disputeGameFactory.gameArgs(_gameType); + if (gameArgsBytes.length == 0) { + return IFaultDisputeGame(address(_disputeGame)).anchorStateRegistry(); + } else { + return IAnchorStateRegistry(LibGameArgs.decode(gameArgsBytes).anchorStateRegistry); + } + } + /// @notice Retrieves the L2 chain ID for a given game function getL2ChainId(IFaultDisputeGame _disputeGame) internal view returns (uint256) { return _disputeGame.l2ChainId(); } - /// @notice Retrieves the proposer address for a given game - function getProposer(IPermissionedDisputeGame _disputeGame) internal view returns (address) { + /// @notice Retrieves the proposer address for a given v1 game + function getProposerV1(IPermissionedDisputeGame _disputeGame) internal view returns (address) { return _disputeGame.proposer(); } - /// @notice Retrieves the challenger address for a given game - function getChallenger(IPermissionedDisputeGame _disputeGame) internal view returns (address) { + /// @notice Retrieves the proposer address for a given v1 or v2 game + function getProposer( + IDisputeGameFactory _disputeGameFactory, + IDisputeGame _disputeGame, + GameType _gameType + ) + internal + view + returns (address) + { + bytes memory gameArgsBytes = _disputeGameFactory.gameArgs(_gameType); + if (gameArgsBytes.length == 0) { + return IPermissionedDisputeGame(address(_disputeGame)).proposer(); + } else { + return LibGameArgs.decode(gameArgsBytes).proposer; + } + } + + /// @notice Retrieves the challenger address for a given v1 game + function getChallengerV1(IPermissionedDisputeGame _disputeGame) internal view returns (address) { return _disputeGame.challenger(); } + /// @notice Retrieves the challenger address of a given v1 or v2 game + function getChallenger( + IDisputeGameFactory _disputeGameFactory, + IDisputeGame _disputeGame, + GameType _gameType + ) + internal + view + returns (address) + { + bytes memory gameArgsBytes = _disputeGameFactory.gameArgs(_gameType); + if (gameArgsBytes.length == 0) { + return IPermissionedDisputeGame(address(_disputeGame)).challenger(); + } else { + return LibGameArgs.decode(gameArgsBytes).challenger; + } + } + /// @notice Helper function to register permissioned game V2 implementation /// @dev Extracted to avoid stack too deep error /// @param _input The deployment input data containing all necessary parameters @@ -377,17 +432,35 @@ abstract contract OPContractsManagerBase { clockExtension: _disputeGame.clockExtension(), maxClockDuration: _disputeGame.maxClockDuration(), vm: _disputeGame.vm(), - weth: getWETH(_disputeGame), - anchorStateRegistry: getAnchorStateRegistry(_disputeGame), + weth: getWETHV1(_disputeGame), + anchorStateRegistry: getAnchorStateRegistryV1(_disputeGame), l2ChainId: l2ChainId }); } - /// @notice Retrieves the DelayedWETH address for a given game - function getWETH(IFaultDisputeGame _disputeGame) internal view returns (IDelayedWETH) { + /// @notice Retrieves the DelayedWETH address for a given v1 game + function getWETHV1(IFaultDisputeGame _disputeGame) internal view returns (IDelayedWETH) { return _disputeGame.weth(); } + /// @notice Retrieves the DelayedWETH for a given v1 or v2 game + function getWETH( + IDisputeGameFactory _disputeGameFactory, + IDisputeGame _disputeGame, + GameType _gameType + ) + internal + view + returns (IDelayedWETH) + { + bytes memory gameArgsBytes = _disputeGameFactory.gameArgs(_gameType); + if (gameArgsBytes.length == 0) { + return IFaultDisputeGame(address(_disputeGame)).weth(); + } else { + return IDelayedWETH(payable(LibGameArgs.decode(gameArgsBytes).weth)); + } + } + /// @notice Sets a game implementation on the dispute game factory /// @param _dgf The dispute game factory /// @param _gameType The game type @@ -570,8 +643,8 @@ contract OPContractsManagerGameTypeAdder is OPContractsManagerBase { getAnchorStateRegistry(gameConfig.systemConfig), gameL2ChainId ), - getProposer(IPermissionedDisputeGame(address(existingGame))), - getChallenger(IPermissionedDisputeGame(address(existingGame))) + getProposerV1(IPermissionedDisputeGame(address(existingGame))), + getChallengerV1(IPermissionedDisputeGame(address(existingGame))) ); } else { constructorData = encodePermissionlessFDGConstructor( @@ -866,35 +939,65 @@ contract OPContractsManagerUpgrader is OPContractsManagerBase { } // All chains have the PermissionedDisputeGame, grab that. - IPermissionedDisputeGame permissionedDisputeGame = - IPermissionedDisputeGame(address(getGameImplementation(dgf, GameTypes.PERMISSIONED_CANNON))); - - // Update the PermissionedDisputeGame. - // We're reusing the same DelayedWETH and ASR contracts. - deployAndSetNewGameImpl({ - _l2ChainId: _l2ChainId, - _disputeGame: IDisputeGame(address(permissionedDisputeGame)), - _newDelayedWeth: permissionedDisputeGame.weth(), - _newAnchorStateRegistryProxy: permissionedDisputeGame.anchorStateRegistry(), - _gameType: GameTypes.PERMISSIONED_CANNON, - _opChainConfig: _opChainConfig - }); - - // Now retrieve the permissionless game. - IFaultDisputeGame permissionlessDisputeGame = - IFaultDisputeGame(address(getGameImplementation(dgf, GameTypes.CANNON))); + IDisputeGame permissionedDisputeGame = getGameImplementation(dgf, GameTypes.PERMISSIONED_CANNON); - // If it exists, replace its implementation. - // We're reusing the same DelayedWETH and ASR contracts. - if (address(permissionlessDisputeGame) != address(0)) { + if (!isDevFeatureEnabled(DevFeatures.DEPLOY_V2_DISPUTE_GAMES)) { + // Update the PermissionedDisputeGame. + // We're reusing the same DelayedWETH and ASR contracts. deployAndSetNewGameImpl({ _l2ChainId: _l2ChainId, - _disputeGame: IDisputeGame(address(permissionlessDisputeGame)), - _newDelayedWeth: permissionlessDisputeGame.weth(), - _newAnchorStateRegistryProxy: permissionlessDisputeGame.anchorStateRegistry(), - _gameType: GameTypes.CANNON, + _disputeGame: permissionedDisputeGame, + _newDelayedWeth: getWETHV1(IFaultDisputeGame(address(permissionedDisputeGame))), + _newAnchorStateRegistryProxy: getAnchorStateRegistryV1(IFaultDisputeGame(address(permissionedDisputeGame))), + _gameType: GameTypes.PERMISSIONED_CANNON, + _opChainConfig: _opChainConfig + }); + + // Now retrieve the permissionless game. + IDisputeGame permissionlessDisputeGame = getGameImplementation(dgf, GameTypes.CANNON); + + // If it exists, replace its implementation. + // We're reusing the same DelayedWETH and ASR contracts. + if (address(permissionlessDisputeGame) != address(0)) { + deployAndSetNewGameImpl({ + _l2ChainId: _l2ChainId, + _disputeGame: permissionlessDisputeGame, + _newDelayedWeth: getWETHV1(IFaultDisputeGame(address(permissionlessDisputeGame))), + _newAnchorStateRegistryProxy: getAnchorStateRegistryV1( + IFaultDisputeGame(address(permissionlessDisputeGame)) + ), + _gameType: GameTypes.CANNON, + _opChainConfig: _opChainConfig + }); + } + } else { + setNewGameImplV2({ + _impls: _impls, + _l2ChainId: _l2ChainId, + _disputeGame: permissionedDisputeGame, + _newDelayedWeth: getWETH(dgf, permissionedDisputeGame, GameTypes.PERMISSIONED_CANNON), + _newAnchorStateRegistryProxy: getAnchorStateRegistry( + dgf, permissionedDisputeGame, GameTypes.PERMISSIONED_CANNON + ), + _gameType: GameTypes.PERMISSIONED_CANNON, _opChainConfig: _opChainConfig }); + + IDisputeGame permissionlessDisputeGame = getGameImplementation(dgf, GameTypes.CANNON); + + // If it exists, replace its implementation. + // We're reusing the same DelayedWETH and ASR contracts. + if (address(permissionlessDisputeGame) != address(0)) { + setNewGameImplV2({ + _impls: _impls, + _l2ChainId: _l2ChainId, + _disputeGame: permissionlessDisputeGame, + _newDelayedWeth: getWETH(dgf, permissionlessDisputeGame, GameTypes.CANNON), + _newAnchorStateRegistryProxy: getAnchorStateRegistry(dgf, permissionlessDisputeGame, GameTypes.CANNON), + _gameType: GameTypes.CANNON, + _opChainConfig: _opChainConfig + }); + } } } @@ -976,8 +1079,8 @@ contract OPContractsManagerUpgrader is OPContractsManagerBase { IDisputeGame newGame; if (GameType.unwrap(_gameType) == GameType.unwrap(GameTypes.PERMISSIONED_CANNON)) { - address proposer = getProposer(IPermissionedDisputeGame(address(_disputeGame))); - address challenger = getChallenger(IPermissionedDisputeGame(address(_disputeGame))); + address proposer = getProposerV1(IPermissionedDisputeGame(address(_disputeGame))); + address challenger = getChallengerV1(IPermissionedDisputeGame(address(_disputeGame))); newGame = IDisputeGame( Blueprint.deployFrom( bps.permissionedDisputeGame1, @@ -1007,6 +1110,93 @@ contract OPContractsManagerUpgrader is OPContractsManagerBase { // Set the new implementation. setDGFImplementation(dgf, _gameType, IDisputeGame(newGame)); } + + /// @notice Sets the latest dispute game v2 implementations + /// @param _impls The container for the new dispute game implementations. + /// @param _l2ChainId The L2 chain ID + /// @param _disputeGame The current dispute game implementation in the dispute game factory + /// @param _newDelayedWeth The new delayed WETH implementation + /// @param _newAnchorStateRegistryProxy The new anchor state registry proxy + /// @param _gameType The type of game to deploy + /// @param _opChainConfig The OP chain configuration + function setNewGameImplV2( + OPContractsManager.Implementations memory _impls, + uint256 _l2ChainId, + IDisputeGame _disputeGame, + IDelayedWETH _newDelayedWeth, + IAnchorStateRegistry _newAnchorStateRegistryProxy, + GameType _gameType, + OPContractsManager.OpChainConfig memory _opChainConfig + ) + internal + { + IDisputeGameFactory disputeGameFactory = + IDisputeGameFactory(_opChainConfig.systemConfigProxy.disputeGameFactory()); + // If the prestate is set in the config, use it. If not set, we'll try to use the prestate + // that already exists on the current dispute game. + Claim absolutePrestate; + if (Claim.unwrap(_opChainConfig.absolutePrestate) == bytes32(0)) { + absolutePrestate = getAbsolutePrestate(disputeGameFactory, address(_disputeGame), _gameType); + } else { + absolutePrestate = _opChainConfig.absolutePrestate; + } + + // As a sanity check, if the prestate is zero here, revert. + if (absolutePrestate.raw() == bytes32(0)) { + revert OPContractsManager.PrestateNotSet(); + } + + IDisputeGame newGame; + bytes memory gameArgs; + if (GameType.unwrap(_gameType) == GameType.unwrap(GameTypes.PERMISSIONED_CANNON)) { + newGame = IDisputeGame(_impls.permissionedDisputeGameV2Impl); + address proposer = + getProposer(disputeGameFactory, IPermissionedDisputeGame(address(_disputeGame)), _gameType); + address challenger = + getChallenger(disputeGameFactory, IPermissionedDisputeGame(address(_disputeGame)), _gameType); + gameArgs = abi.encodePacked( + absolutePrestate, // 32 bytes + _impls.mipsImpl, // 20 bytes + address(_newAnchorStateRegistryProxy), // 20 bytes + address(_newDelayedWeth), // 20 bytes + _l2ChainId, // 32 bytes + proposer, // 20 bytes + challenger // 20 bytes + ); + } else { + newGame = IDisputeGame(_impls.faultDisputeGameV2Impl); + gameArgs = abi.encodePacked( + absolutePrestate, // 32 bytes + _impls.mipsImpl, // 20 bytes + address(_newAnchorStateRegistryProxy), // 20 bytes + address(_newDelayedWeth), // 20 bytes + _l2ChainId // 32 bytes + ); + } + + setDGFImplementation(disputeGameFactory, _gameType, IDisputeGame(newGame), gameArgs); + } + + /// @notice Retrieves the absolute prestate for a dispute game, handling both V1 and V2 games. + function getAbsolutePrestate( + IDisputeGameFactory _dgf, + address _disputeGame, + GameType _gameType + ) + internal + view + returns (Claim) + { + bytes memory gameArgsBytes = _dgf.gameArgs(_gameType); + if (gameArgsBytes.length == 0) { + // assume we're dealing with v1 fdgs + return IFaultDisputeGame(_disputeGame).absolutePrestate(); + } else { + // v2 dispute game + LibGameArgs.GameArgs memory gameArgs = LibGameArgs.decode(gameArgsBytes); + return Claim.wrap(gameArgs.absolutePrestate); + } + } } contract OPContractsManagerDeployer is OPContractsManagerBase { @@ -1898,9 +2088,9 @@ contract OPContractsManager is ISemver { // -------- Constants and Variables -------- - /// @custom:semver 4.2.0 + /// @custom:semver 4.3.0 function version() public pure virtual returns (string memory) { - return "4.2.0"; + return "4.3.0"; } OPContractsManagerGameTypeAdder public immutable opcmGameTypeAdder; diff --git a/packages/contracts-bedrock/src/L1/OPContractsManagerStandardValidator.sol b/packages/contracts-bedrock/src/L1/OPContractsManagerStandardValidator.sol index f82b21b248c..6acf9f6a1da 100644 --- a/packages/contracts-bedrock/src/L1/OPContractsManagerStandardValidator.sol +++ b/packages/contracts-bedrock/src/L1/OPContractsManagerStandardValidator.sol @@ -10,6 +10,7 @@ import { Constants } from "src/libraries/Constants.sol"; import { Hash } from "src/dispute/lib/Types.sol"; import { Features } from "src/libraries/Features.sol"; import { DevFeatures } from "src/libraries/DevFeatures.sol"; +import { LibGameArgs } from "src/dispute/lib/LibGameArgs.sol"; // Interfaces import { ISystemConfig } from "interfaces/L1/ISystemConfig.sol"; @@ -30,6 +31,7 @@ import { IPreimageOracle } from "interfaces/cannon/IPreimageOracle.sol"; import { IMIPS64 } from "interfaces/cannon/IMIPS64.sol"; import { ISemver } from "interfaces/universal/ISemver.sol"; import { IProxyAdminOwnedBase } from "interfaces/L1/IProxyAdminOwnedBase.sol"; +import { IBigStepper } from "interfaces/dispute/IBigStepper.sol"; /// @title OPContractsManagerStandardValidator /// @notice This contract is used to validate the configuration of the L1 contracts of an OP Stack chain. @@ -38,8 +40,8 @@ import { IProxyAdminOwnedBase } from "interfaces/L1/IProxyAdminOwnedBase.sol"; /// before and after an upgrade. contract OPContractsManagerStandardValidator is ISemver { /// @notice The semantic version of the OPContractsManagerStandardValidator contract. - /// @custom:semver 1.18.0 - string public constant version = "1.18.0"; + /// @custom:semver 1.19.0 + string public constant version = "1.19.0"; /// @notice The SuperchainConfig contract. ISuperchainConfig public superchainConfig; @@ -124,6 +126,25 @@ contract OPContractsManagerStandardValidator is ISemver { address challenger; } + /// @notice Struct containing the unified game args for a dispute game implementation. + struct DisputeGameImplementation { + address gameAddress; + uint256 maxGameDepth; + uint256 splitDepth; + Duration maxClockDuration; + Duration clockExtension; + GameType gameType; + // extra args + uint256 l2SequenceNumber; + // dispute-game v2 game args + Claim absolutePrestate; + IBigStepper vm; + IAnchorStateRegistry asr; + IDelayedWETH weth; + uint256 l2ChainId; + address challenger; + } + /// @notice Constructor for the OPContractsManagerStandardValidator contract. constructor( Implementations memory _implementations, @@ -187,8 +208,12 @@ contract OPContractsManagerStandardValidator is ISemver { } /// @notice Returns the expected PermissionedDisputeGame version. - function permissionedDisputeGameVersion() public pure returns (string memory) { - return "1.8.0"; + function permissionedDisputeGameVersion() public view returns (string memory) { + if (DevFeatures.isDevFeatureEnabled(devFeatureBitmap, DevFeatures.DEPLOY_V2_DISPUTE_GAMES)) { + return "2.1.0"; + } else { + return "1.8.0"; + } } /// @notice Returns the expected PreimageOracle version. @@ -495,10 +520,19 @@ contract OPContractsManagerStandardValidator is ISemver { return _errors; } + bytes memory _gameArgs = _factory.gameArgs(GameTypes.PERMISSIONED_CANNON); + bool lenCheckFailed; + (_errors, lenCheckFailed) = assertGameArgsLength(_errors, _gameArgs, true, "PDDG"); + if (lenCheckFailed) { + // bail out immediately to avoid trying to validate an invalid dispute game + return _errors; + } + + DisputeGameImplementation memory _gameImpl = _decodeDisputeGameImpl(_game, _gameArgs, true); _errors = assertValidDisputeGame( _errors, _sysCfg, - _game, + _gameImpl, _factory, _absolutePrestate, _l2ChainID, @@ -510,7 +544,7 @@ contract OPContractsManagerStandardValidator is ISemver { // Challenger is specific to the PermissionedDisputeGame contract. address _challenger = expectedChallenger(_overrides); - _errors = internalRequire(_game.challenger() == _challenger, "PDDG-130", _errors); + _errors = internalRequire(_gameImpl.challenger == _challenger, "PDDG-130", _errors); return _errors; } @@ -538,10 +572,19 @@ contract OPContractsManagerStandardValidator is ISemver { return _errors; } + bytes memory _gameArgs = _factory.gameArgs(GameTypes.CANNON); + bool lenCheckFailed; + (_errors, lenCheckFailed) = assertGameArgsLength(_errors, _gameArgs, false, "PLDG"); + if (lenCheckFailed) { + // bail out immediately to avoid trying to validate an invalid dispute game + return _errors; + } + + DisputeGameImplementation memory _gameImpl = _decodeDisputeGameImpl(_game, _gameArgs, false); _errors = assertValidDisputeGame( _errors, _sysCfg, - _game, + _gameImpl, _factory, _absolutePrestate, _l2ChainID, @@ -558,7 +601,7 @@ contract OPContractsManagerStandardValidator is ISemver { function assertValidDisputeGame( string memory _errors, ISystemConfig _sysCfg, - IPermissionedDisputeGame _game, + DisputeGameImplementation memory _game, IDisputeGameFactory _factory, bytes32 _absolutePrestate, uint256 _l2ChainID, @@ -571,41 +614,40 @@ contract OPContractsManagerStandardValidator is ISemver { view returns (string memory) { - IAnchorStateRegistry _asr = _game.anchorStateRegistry(); - (Hash anchorRoot,) = _asr.getAnchorRoot(); + (Hash anchorRoot,) = _game.asr.getAnchorRoot(); _errors = internalRequire( - LibString.eq(getVersion(address(_game)), permissionedDisputeGameVersion()), + LibString.eq(getVersion(_game.gameAddress), permissionedDisputeGameVersion()), string.concat(_errorPrefix, "-20"), _errors ); + _errors = internalRequire( - GameType.unwrap(_game.gameType()) == GameType.unwrap(_gameType), string.concat(_errorPrefix, "-30"), _errors - ); - _errors = internalRequire( - Claim.unwrap(_game.absolutePrestate()) == _absolutePrestate, string.concat(_errorPrefix, "-40"), _errors + GameType.unwrap(_game.gameType) == GameType.unwrap(_gameType), string.concat(_errorPrefix, "-30"), _errors ); - _errors = internalRequire(_game.l2ChainId() == _l2ChainID, string.concat(_errorPrefix, "-60"), _errors); - _errors = internalRequire(_game.l2SequenceNumber() == 0, string.concat(_errorPrefix, "-70"), _errors); _errors = internalRequire( - Duration.unwrap(_game.clockExtension()) == 10800, string.concat(_errorPrefix, "-80"), _errors + Claim.unwrap(_game.absolutePrestate) == _absolutePrestate, string.concat(_errorPrefix, "-40"), _errors ); - _errors = internalRequire(_game.splitDepth() == 30, string.concat(_errorPrefix, "-90"), _errors); - _errors = internalRequire(_game.maxGameDepth() == 73, string.concat(_errorPrefix, "-100"), _errors); + _errors = internalRequire(_game.l2ChainId == _l2ChainID, string.concat(_errorPrefix, "-60"), _errors); + _errors = internalRequire(_game.l2SequenceNumber == 0, string.concat(_errorPrefix, "-70"), _errors); + _errors = + internalRequire(Duration.unwrap(_game.clockExtension) == 10800, string.concat(_errorPrefix, "-80"), _errors); + _errors = internalRequire(_game.splitDepth == 30, string.concat(_errorPrefix, "-90"), _errors); + _errors = internalRequire(_game.maxGameDepth == 73, string.concat(_errorPrefix, "-100"), _errors); _errors = internalRequire( - Duration.unwrap(_game.maxClockDuration()) == 302400, string.concat(_errorPrefix, "-110"), _errors + Duration.unwrap(_game.maxClockDuration) == 302400, string.concat(_errorPrefix, "-110"), _errors ); _errors = internalRequire(Hash.unwrap(anchorRoot) != bytes32(0), string.concat(_errorPrefix, "-120"), _errors); - _errors = assertValidDelayedWETH(_errors, _sysCfg, _game.weth(), _admin, _overrides, _errorPrefix); - _errors = assertValidAnchorStateRegistry(_errors, _sysCfg, _factory, _asr, _admin, _errorPrefix); + _errors = assertValidDelayedWETH(_errors, _sysCfg, _game.weth, _admin, _overrides, _errorPrefix); + _errors = assertValidAnchorStateRegistry(_errors, _sysCfg, _factory, _game.asr, _admin, _errorPrefix); - _errors = assertValidMipsVm(_errors, IMIPS64(address(_game.vm())), _errorPrefix); + _errors = assertValidMipsVm(_errors, IMIPS64(address(_game.vm)), _errorPrefix); // Only assert valid preimage oracle if the game VM is valid, since otherwise // the contract is likely to revert. - if (address(_game.vm()) == mipsImpl) { - _errors = assertValidPreimageOracle(_errors, _game.vm().oracle(), _errorPrefix); + if (address(_game.vm) == mipsImpl) { + _errors = assertValidPreimageOracle(_errors, _game.vm.oracle(), _errorPrefix); } return _errors; @@ -798,4 +840,74 @@ contract OPContractsManagerStandardValidator is ISemver { return finalErrors; } + + function assertGameArgsLength( + string memory _errors, + bytes memory _gameArgsBytes, + bool _isPermissioned, + string memory _errorPrefix + ) + internal + view + returns (string memory errors_, bool failed_) + { + _errorPrefix = string.concat(_errorPrefix, "-GARGS"); + if (DevFeatures.isDevFeatureEnabled(devFeatureBitmap, DevFeatures.DEPLOY_V2_DISPUTE_GAMES)) { + if (_isPermissioned) { + bool ok = LibGameArgs.isValidPermissionedArgs(_gameArgsBytes); + _errors = internalRequire(ok, string.concat(_errorPrefix, "-10"), _errors); + return (_errors, !ok); + } else { + bool ok = LibGameArgs.isValidPermissionlessArgs(_gameArgsBytes); + _errors = internalRequire(ok, string.concat(_errorPrefix, "-10"), _errors); + return (_errors, !ok); + } + } else { + bool ok = _gameArgsBytes.length == 0; + _errors = internalRequire(ok, string.concat(_errorPrefix, "-10"), _errors); + return (_errors, !ok); + } + } + + // @notice Internal function to read all information from a dispute game while supporting both v1 and v2 dispute + /// games. + function _decodeDisputeGameImpl( + IPermissionedDisputeGame _game, + bytes memory _gameArgsBytes, + bool _isPermissioned + ) + internal + view + returns (DisputeGameImplementation memory gameImpl_) + { + LibGameArgs.GameArgs memory gameArgs; + if (DevFeatures.isDevFeatureEnabled(devFeatureBitmap, DevFeatures.DEPLOY_V2_DISPUTE_GAMES)) { + gameArgs = LibGameArgs.decode(_gameArgsBytes); + } else { + gameArgs.absolutePrestate = Claim.unwrap(_game.absolutePrestate()); + gameArgs.vm = address(_game.vm()); + gameArgs.anchorStateRegistry = address(_game.anchorStateRegistry()); + gameArgs.weth = address(_game.weth()); + gameArgs.l2ChainId = _game.l2ChainId(); + if (_isPermissioned) { + gameArgs.challenger = _game.challenger(); + } + } + + gameImpl_ = DisputeGameImplementation({ + gameAddress: address(_game), + maxGameDepth: _game.maxGameDepth(), + splitDepth: _game.splitDepth(), + maxClockDuration: _game.maxClockDuration(), + clockExtension: _game.clockExtension(), + gameType: _game.gameType(), + l2SequenceNumber: _game.l2SequenceNumber(), + absolutePrestate: Claim.wrap(gameArgs.absolutePrestate), + vm: IBigStepper(gameArgs.vm), + asr: IAnchorStateRegistry(gameArgs.anchorStateRegistry), + weth: IDelayedWETH(payable(gameArgs.weth)), + l2ChainId: gameArgs.l2ChainId, + challenger: gameArgs.challenger + }); + } } diff --git a/packages/contracts-bedrock/src/dispute/lib/Errors.sol b/packages/contracts-bedrock/src/dispute/lib/Errors.sol index 43e77177745..a11e5aa1be8 100644 --- a/packages/contracts-bedrock/src/dispute/lib/Errors.sol +++ b/packages/contracts-bedrock/src/dispute/lib/Errors.sol @@ -142,3 +142,10 @@ error BadAuth(); /// @notice Thrown when trying to close a game while the system is paused. error GamePaused(); + +//////////////////////////////////////////////////////////////// +// `LibGameArgs` Errors // +//////////////////////////////////////////////////////////////// + +/// @notice Thrown when the length of the game arguments is invalid. +error InvalidGameArgsLength(); diff --git a/packages/contracts-bedrock/src/dispute/lib/LibGameArgs.sol b/packages/contracts-bedrock/src/dispute/lib/LibGameArgs.sol new file mode 100644 index 00000000000..3af71d317ad --- /dev/null +++ b/packages/contracts-bedrock/src/dispute/lib/LibGameArgs.sol @@ -0,0 +1,77 @@ +// SPDX-License-Identifier: MIT +pragma solidity ^0.8.15; + +import { InvalidGameArgsLength } from "src/dispute/lib/Errors.sol"; + +/// @title LibGameArgs +/// @notice Library for decoding the game arguments used in dispute games. +library LibGameArgs { + uint256 public constant PERMISSIONLESS_ARGS_LENGTH = 124; + uint256 public constant PERMISSIONED_ARGS_LENGTH = 164; + + /// @notice Struct representing the game arguments. + struct GameArgs { + bytes32 absolutePrestate; + address vm; + address anchorStateRegistry; + address weth; + uint256 l2ChainId; + address proposer; + address challenger; + } + + /// @notice Decodes the game arguments from a bytes array. + /// @param _gameArgs The bytes array containing the encoded game arguments. + function decode(bytes memory _gameArgs) internal pure returns (GameArgs memory) { + uint256 len = _gameArgs.length; + if (len != PERMISSIONED_ARGS_LENGTH && len != PERMISSIONLESS_ARGS_LENGTH) { + revert InvalidGameArgsLength(); + } + + bytes32 absolutePrestate; + address vm; + address asr; + address weth; + uint256 l2ChainId; + address proposer; + address challenger; + + assembly { + // skip length prefix + let d := add(_gameArgs, 32) + absolutePrestate := mload(d) + vm := shr(96, mload(add(d, 32))) + asr := shr(96, mload(add(d, 52))) + weth := shr(96, mload(add(d, 72))) + l2ChainId := mload(add(d, 92)) + } + + if (len == PERMISSIONED_ARGS_LENGTH) { + assembly { + // skip length prefix + let d := add(_gameArgs, 32) + proposer := shr(96, mload(add(d, 124))) + challenger := shr(96, mload(add(d, 144))) + } + } + return GameArgs({ + absolutePrestate: absolutePrestate, + vm: vm, + anchorStateRegistry: asr, + weth: weth, + l2ChainId: l2ChainId, + proposer: proposer, + challenger: challenger + }); + } + + /// @notice Checks if the provided game arguments are valid for a permissionless game. + function isValidPermissionlessArgs(bytes memory _args) internal pure returns (bool) { + return _args.length == PERMISSIONLESS_ARGS_LENGTH; + } + + /// @notice Checks if the provided game arguments are valid for a permissioned game. + function isValidPermissionedArgs(bytes memory _args) internal pure returns (bool) { + return _args.length == PERMISSIONED_ARGS_LENGTH; + } +} diff --git a/packages/contracts-bedrock/test/L1/OPContractsManager.t.sol b/packages/contracts-bedrock/test/L1/OPContractsManager.t.sol index edf1b531b9c..4d3a5e6d091 100644 --- a/packages/contracts-bedrock/test/L1/OPContractsManager.t.sol +++ b/packages/contracts-bedrock/test/L1/OPContractsManager.t.sol @@ -21,6 +21,7 @@ import { Types } from "scripts/libraries/Types.sol"; import { EIP1967Helper } from "test/mocks/EIP1967Helper.sol"; import { GameType, Duration, Hash, Claim } from "src/dispute/lib/LibUDT.sol"; import { Proposal, GameTypes } from "src/dispute/lib/Types.sol"; +import { LibGameArgs } from "src/dispute/lib/LibGameArgs.sol"; import { DevFeatures } from "src/libraries/DevFeatures.sol"; // Interfaces @@ -108,11 +109,19 @@ contract OPContractsManager_Upgrade_Harness is CommonTest { /// @notice Thrown when testing with an unsupported chain ID. error UnsupportedChainId(); + struct PreUpgradeState { + Claim cannonAbsolutePrestate; + Claim permissionedAbsolutePrestate; + IDelayedWETH permissionlessWethProxy; + IDelayedWETH permissionedCannonWethProxy; + } + uint256 l2ChainId; address upgrader; IOPContractsManager.OpChainConfig[] opChainConfigs; Claim absolutePrestate; string public opChain = Config.forkOpChain(); + PreUpgradeState preUpgradeState; function setUp() public virtual override { super.disableUpgradedFork(); @@ -151,6 +160,17 @@ contract OPContractsManager_Upgrade_Harness is CommonTest { permissionedDisputeGame = IPermissionedDisputeGame(address(artifacts.mustGetAddress("PermissionedDisputeGame"))); faultDisputeGame = IFaultDisputeGame(address(artifacts.mustGetAddress("FaultDisputeGame"))); + // grab the pre-upgrade state + preUpgradeState = PreUpgradeState({ + cannonAbsolutePrestate: IFaultDisputeGame(address(disputeGameFactory.gameImpls(GameTypes.CANNON))) + .absolutePrestate(), + permissionedAbsolutePrestate: IPermissionedDisputeGame( + address(disputeGameFactory.gameImpls(GameTypes.PERMISSIONED_CANNON)) + ).absolutePrestate(), + permissionlessWethProxy: delayedWeth, + permissionedCannonWethProxy: delayedWETHPermissionedGameProxy + }); + // Since this superchainConfig is already at the expected reinitializer version... // We do this to pass the reinitializer check when trying to upgrade the superchainConfig contract. @@ -246,11 +266,20 @@ contract OPContractsManager_Upgrade_Harness is CommonTest { } // Create validationOverrides + address challengerOverride; + if (isDevFeatureEnabled(DevFeatures.DEPLOY_V2_DISPUTE_GAMES)) { + LibGameArgs.GameArgs memory gameArgs = + LibGameArgs.decode(disputeGameFactory.gameArgs(GameTypes.PERMISSIONED_CANNON)); + challengerOverride = gameArgs.challenger; + } else { + challengerOverride = IPermissionedDisputeGame( + address(disputeGameFactory.gameImpls(GameTypes.PERMISSIONED_CANNON)) + ).challenger(); + } IOPContractsManagerStandardValidator.ValidationOverrides memory validationOverrides = IOPContractsManagerStandardValidator.ValidationOverrides({ l1PAOMultisig: opChainConfigs[0].proxyAdmin.owner(), - challenger: IPermissionedDisputeGame(address(disputeGameFactory.gameImpls(GameTypes.PERMISSIONED_CANNON))) - .challenger() + challenger: challengerOverride }); // Grab the validator before we do the error assertion because otherwise the assertion will @@ -280,6 +309,76 @@ contract OPContractsManager_Upgrade_Harness is CommonTest { false, validationOverrides ); + + _runPostUpgradeSmokeTests(_opcm, opChainConfigs[0], challengerOverride); + } + + function permissionedGameProposer() internal view returns (address) { + if (isDevFeatureEnabled(DevFeatures.DEPLOY_V2_DISPUTE_GAMES)) { + LibGameArgs.GameArgs memory gameArgs = + LibGameArgs.decode(disputeGameFactory.gameArgs(GameTypes.PERMISSIONED_CANNON)); + return gameArgs.proposer; + } else { + return IPermissionedDisputeGame(address(disputeGameFactory.gameImpls(GameTypes.PERMISSIONED_CANNON))) + .proposer(); + } + } + + /// @notice Runs some smoke tests after an upgrade + function _runPostUpgradeSmokeTests( + IOPContractsManager _opcm, + IOPContractsManager.OpChainConfig memory _opChainConfig, + address _challenger + ) + internal + { + address expectedProposer = permissionedGameProposer(); + bytes32 expectedAbsolutePrestate = _opChainConfig.absolutePrestate.raw(); + if (expectedAbsolutePrestate == bytes32(0)) { + expectedAbsolutePrestate = preUpgradeState.permissionedAbsolutePrestate.raw(); + } + address expectedVm = address(_opcm.implementations().mipsImpl); + + Claim claim = Claim.wrap(bytes32(uint256(1))); + uint256 bondAmount = disputeGameFactory.initBonds(GameTypes.PERMISSIONED_CANNON); + vm.deal(address(_challenger), bondAmount); + (, uint256 rootBlockNumber) = optimismPortal2.anchorStateRegistry().getAnchorRoot(); + uint256 l2BlockNumber = rootBlockNumber + 1; + + // Deploy live games and ensure they're configured correctly + GameType[] memory gameTypes = new GameType[](2); + gameTypes[0] = GameTypes.PERMISSIONED_CANNON; + gameTypes[1] = GameTypes.CANNON; + for (uint256 i = 0; i < gameTypes.length; i++) { + GameType gt = gameTypes[i]; + vm.prank(expectedProposer, expectedProposer); + IPermissionedDisputeGame game = IPermissionedDisputeGame( + address(disputeGameFactory.create{ value: bondAmount }(gt, claim, abi.encode(l2BlockNumber))) + ); + (,,,, Claim rootClaim,,) = game.claimData(0); + + vm.assertEq(gt.raw(), game.gameType().raw()); + vm.assertEq(expectedAbsolutePrestate, game.absolutePrestate().raw()); + vm.assertEq(address(optimismPortal2.anchorStateRegistry()), address(game.anchorStateRegistry())); + vm.assertEq(l2ChainId, game.l2ChainId()); + vm.assertEq(302400, game.maxClockDuration().raw()); + vm.assertEq(10800, game.clockExtension().raw()); + vm.assertEq(73, game.maxGameDepth()); + vm.assertEq(30, game.splitDepth()); + vm.assertEq(l2BlockNumber, game.l2BlockNumber()); + vm.assertEq(expectedVm, address(game.vm())); + vm.assertEq(expectedProposer, game.gameCreator()); + vm.assertEq(claim.raw(), rootClaim.raw()); + vm.assertEq(blockhash(block.number - 1), game.l1Head().raw()); + + if (gt.raw() == GameTypes.PERMISSIONED_CANNON.raw()) { + vm.assertEq(address(preUpgradeState.permissionedCannonWethProxy), address(game.weth())); + vm.assertEq(_challenger, game.challenger()); + vm.assertEq(expectedProposer, game.proposer()); + } else { + vm.assertEq(address(preUpgradeState.permissionlessWethProxy), address(game.weth())); + } + } } /// @notice Executes all past upgrades that have not yet been executed on mainnet as of the @@ -1243,6 +1342,12 @@ contract OPContractsManager_Upgrade_Test is OPContractsManager_Upgrade_Harness { runPastUpgrades(upgrader); } + function getDisputeGameV2AbsolutePrestate(GameType _gameType) internal view returns (Claim) { + bytes memory gameArgsBytes = disputeGameFactory.gameArgs(_gameType); + LibGameArgs.GameArgs memory gameArgs = LibGameArgs.decode(gameArgsBytes); + return Claim.wrap(gameArgs.absolutePrestate); + } + function test_upgradeOPChainOnly_succeeds() public { // Run the upgrade test and checks runCurrentUpgrade(upgrader); @@ -1297,11 +1402,18 @@ contract OPContractsManager_Upgrade_Test is OPContractsManager_Upgrade_Harness { runCurrentUpgrade(upgrader); // Get the absolute prestate after the upgrade - Claim pdgPrestateAfter = IPermissionedDisputeGame( - address(disputeGameFactory.gameImpls(GameTypes.PERMISSIONED_CANNON)) - ).absolutePrestate(); - Claim fdgPrestateAfter = - IFaultDisputeGame(address(disputeGameFactory.gameImpls(GameTypes.CANNON))).absolutePrestate(); + Claim pdgPrestateAfter; + Claim fdgPrestateAfter; + if (isDevFeatureEnabled(DevFeatures.DEPLOY_V2_DISPUTE_GAMES)) { + pdgPrestateAfter = getDisputeGameV2AbsolutePrestate(GameTypes.PERMISSIONED_CANNON); + fdgPrestateAfter = getDisputeGameV2AbsolutePrestate(GameTypes.CANNON); + } else { + pdgPrestateAfter = IPermissionedDisputeGame( + address(disputeGameFactory.gameImpls(GameTypes.PERMISSIONED_CANNON)) + ).absolutePrestate(); + fdgPrestateAfter = + IFaultDisputeGame(address(disputeGameFactory.gameImpls(GameTypes.CANNON))).absolutePrestate(); + } // Assert that the absolute prestate is the non-zero value we set. assertEq(pdgPrestateAfter.raw(), bytes32(uint256(1))); @@ -1329,11 +1441,18 @@ contract OPContractsManager_Upgrade_Test is OPContractsManager_Upgrade_Harness { runCurrentUpgrade(upgrader); // Get the absolute prestate after the upgrade - Claim pdgPrestateAfter = IPermissionedDisputeGame( - address(disputeGameFactory.gameImpls(GameTypes.PERMISSIONED_CANNON)) - ).absolutePrestate(); - Claim fdgPrestateAfter = - IFaultDisputeGame(address(disputeGameFactory.gameImpls(GameTypes.CANNON))).absolutePrestate(); + Claim pdgPrestateAfter; + Claim fdgPrestateAfter; + if (isDevFeatureEnabled(DevFeatures.DEPLOY_V2_DISPUTE_GAMES)) { + pdgPrestateAfter = getDisputeGameV2AbsolutePrestate(GameTypes.PERMISSIONED_CANNON); + fdgPrestateAfter = getDisputeGameV2AbsolutePrestate(GameTypes.CANNON); + } else { + pdgPrestateAfter = IPermissionedDisputeGame( + address(disputeGameFactory.gameImpls(GameTypes.PERMISSIONED_CANNON)) + ).absolutePrestate(); + fdgPrestateAfter = + IFaultDisputeGame(address(disputeGameFactory.gameImpls(GameTypes.CANNON))).absolutePrestate(); + } // Assert that the absolute prestate is the same as before the upgrade. assertEq(pdgPrestateAfter.raw(), pdgPrestateBefore.raw()); diff --git a/packages/contracts-bedrock/test/dispute/lib/LibGameArgs.t.sol b/packages/contracts-bedrock/test/dispute/lib/LibGameArgs.t.sol new file mode 100644 index 00000000000..1f7e732e618 --- /dev/null +++ b/packages/contracts-bedrock/test/dispute/lib/LibGameArgs.t.sol @@ -0,0 +1,128 @@ +// SPDX-License-Identifier: MIT +pragma solidity ^0.8.15; + +import { Test } from "forge-std/Test.sol"; +import { LibGameArgs } from "src/dispute/lib/LibGameArgs.sol"; +import { InvalidGameArgsLength } from "src/dispute/lib/Errors.sol"; + +contract LibGameArgs_Harness { + function decode(bytes memory _buf) public pure returns (LibGameArgs.GameArgs memory) { + return LibGameArgs.decode(_buf); + } +} + +/// @title LibGameArgs_Decode_Test +/// @notice Test contract for the LibGameArgs library's decode function. +contract LibGameArgs_Decode_Test is Test { + LibGameArgs_Harness internal harness; + + function setUp() public { + harness = new LibGameArgs_Harness(); + } + + /// @notice Struct to hold game arguments for testing purposes. + /// Avoids "stack too deep" errors in the test functions. + struct GameArgs { + bytes32 absolutePrestate; + address vm; + address asr; + address weth; + uint256 l2ChainId; + address proposer; + address challenger; + } + + function test_decodeFull_succeeds() public { + GameArgs memory args = GameArgs({ + absolutePrestate: keccak256(abi.encodePacked("absolutePrestate")), + vm: vm.randomAddress(), + asr: address(0x2), + weth: address(0x3), + l2ChainId: 42, + proposer: address(0x123), + challenger: address(0x456) + }); + bytes memory buf = abi.encodePacked( + args.absolutePrestate, args.vm, args.asr, args.weth, args.l2ChainId, args.proposer, args.challenger + ); + + LibGameArgs.GameArgs memory decoded = harness.decode(buf); + assertEq(decoded.absolutePrestate, args.absolutePrestate); + assertEq(decoded.vm, args.vm); + assertEq(decoded.anchorStateRegistry, args.asr); + assertEq(decoded.weth, args.weth); + assertEq(decoded.l2ChainId, args.l2ChainId); + assertEq(decoded.proposer, args.proposer); + assertEq(decoded.challenger, args.challenger); + } + + function test_decodeShort_succeeds() public { + GameArgs memory args = GameArgs({ + absolutePrestate: keccak256(abi.encodePacked("absolutePrestate")), + vm: vm.randomAddress(), + asr: address(0x2), + weth: address(0x3), + l2ChainId: 42, + proposer: address(0x123), + challenger: address(0x456) + }); + bytes memory buf = abi.encodePacked(args.absolutePrestate, args.vm, args.asr, args.weth, args.l2ChainId); + + LibGameArgs.GameArgs memory decoded = harness.decode(buf); + assertEq(decoded.absolutePrestate, args.absolutePrestate); + assertEq(decoded.vm, args.vm); + assertEq(decoded.anchorStateRegistry, args.asr); + assertEq(decoded.weth, args.weth); + assertEq(decoded.l2ChainId, args.l2ChainId); + assertEq(decoded.proposer, address(0)); + assertEq(decoded.challenger, address(0)); + } + + function test_decode_invalidLengthOverfull_reverts() public { + GameArgs memory args = GameArgs({ + absolutePrestate: keccak256(abi.encodePacked("absolutePrestate")), + vm: vm.randomAddress(), + asr: address(0x2), + weth: address(0x3), + l2ChainId: 42, + proposer: address(0x123), + challenger: address(0x456) + }); + bytes memory buf = abi.encodePacked( + args.absolutePrestate, + args.vm, + args.asr, + args.weth, + args.l2ChainId, + args.proposer, + args.challenger, + uint256(999) + ); + + vm.expectRevert(InvalidGameArgsLength.selector); + harness.decode(buf); + } + + function testFuzz_decode_invalidLength_reverts(bytes memory _buf) public { + bool ok = ( + _buf.length == LibGameArgs.PERMISSIONLESS_ARGS_LENGTH || _buf.length == LibGameArgs.PERMISSIONED_ARGS_LENGTH + ); + vm.assume(!ok); + vm.expectRevert(InvalidGameArgsLength.selector); + harness.decode(_buf); + } + + function test_isValidPermissionlessArgs_works() public pure { + bytes memory validBuf = new bytes(LibGameArgs.PERMISSIONLESS_ARGS_LENGTH); + assertTrue(LibGameArgs.isValidPermissionlessArgs(validBuf)); + validBuf = new bytes(LibGameArgs.PERMISSIONED_ARGS_LENGTH); + assertFalse(LibGameArgs.isValidPermissionlessArgs(validBuf)); + } + + function test_isValidPermissionedArgs_works() public pure { + bytes memory validBuf = new bytes(LibGameArgs.PERMISSIONED_ARGS_LENGTH); + assertTrue(LibGameArgs.isValidPermissionedArgs(validBuf)); + validBuf = new bytes(LibGameArgs.PERMISSIONLESS_ARGS_LENGTH); + assertFalse(LibGameArgs.isValidPermissionedArgs(validBuf)); + } +} diff --git a/packages/contracts-bedrock/test/setup/ForkLive.s.sol b/packages/contracts-bedrock/test/setup/ForkLive.s.sol index 146a25466b8..7835c6a38cf 100644 --- a/packages/contracts-bedrock/test/setup/ForkLive.s.sol +++ b/packages/contracts-bedrock/test/setup/ForkLive.s.sol @@ -169,8 +169,7 @@ contract ForkLive is Deployer, StdAssertions { artifacts.save("MipsSingleton", vm.parseTomlAddress(opToml, ".addresses.MIPS")); IDisputeGameFactory disputeGameFactory = IDisputeGameFactory(artifacts.mustGetAddress("DisputeGameFactoryProxy")); - IFaultDisputeGame faultDisputeGame = - IFaultDisputeGame(opToml.readAddressOr(".addresses.FaultDisputeGame", address(0))); + IFaultDisputeGame faultDisputeGame = IFaultDisputeGame(address(disputeGameFactory.gameImpls(GameTypes.CANNON))); artifacts.save("FaultDisputeGame", address(faultDisputeGame)); artifacts.save("PermissionlessDelayedWETHProxy", address(faultDisputeGame.weth())); From aca9c3f010d81fb22829b01a65b8c9e22544e1fd Mon Sep 17 00:00:00 2001 From: George Knee Date: Tue, 21 Oct 2025 10:56:03 +0100 Subject: [PATCH 096/117] remove dead code (#17937) --- .../isthmus/operator_fee/balance_reader.go | 69 ------ .../isthmus/operator_fee/balance_snapshot.go | 112 --------- .../operator_fee/balance_snapshot_test.go | 227 ------------------ .../tests/isthmus/operator_fee/fee_checker.go | 144 ----------- .../system_config_contract_utils.go | 103 -------- .../tests/isthmus/operator_fee/tx_utils.go | 30 --- 6 files changed, 685 deletions(-) delete mode 100644 op-acceptance-tests/tests/isthmus/operator_fee/balance_reader.go delete mode 100644 op-acceptance-tests/tests/isthmus/operator_fee/balance_snapshot.go delete mode 100644 op-acceptance-tests/tests/isthmus/operator_fee/balance_snapshot_test.go delete mode 100644 op-acceptance-tests/tests/isthmus/operator_fee/fee_checker.go delete mode 100644 op-acceptance-tests/tests/isthmus/operator_fee/system_config_contract_utils.go delete mode 100644 op-acceptance-tests/tests/isthmus/operator_fee/tx_utils.go diff --git a/op-acceptance-tests/tests/isthmus/operator_fee/balance_reader.go b/op-acceptance-tests/tests/isthmus/operator_fee/balance_reader.go deleted file mode 100644 index 83ca3f94b03..00000000000 --- a/op-acceptance-tests/tests/isthmus/operator_fee/balance_reader.go +++ /dev/null @@ -1,69 +0,0 @@ -package operatorfee - -import ( - "context" - "math/big" - - "github.com/ethereum-optimism/optimism/op-devstack/devtest" - "github.com/ethereum-optimism/optimism/op-service/predeploys" - "github.com/ethereum/go-ethereum/common" - "github.com/ethereum/go-ethereum/ethclient" - "github.com/ethereum/go-ethereum/log" - "github.com/stretchr/testify/require" -) - -// BalanceReader provides methods to read balances from the chain -type BalanceReader struct { - client *ethclient.Client - t devtest.T - logger log.Logger -} - -// NewBalanceReader creates a new BalanceReader instance -func NewBalanceReader(t devtest.T, client *ethclient.Client, logger log.Logger) *BalanceReader { - return &BalanceReader{ - client: client, - t: t, - logger: logger, - } -} - -// SampleBalances reads all the relevant balances at the given block number -// and returns a BalanceSnapshot containing the results -func (br *BalanceReader) SampleBalances(ctx context.Context, blockNumber *big.Int, walletAddr common.Address) *BalanceSnapshot { - br.logger.Debug("Sampling balances", - "block", blockNumber, - "wallet", walletAddr.Hex()) - - // Read all balances - baseFeeVaultBalance, err := br.client.BalanceAt(ctx, predeploys.BaseFeeVaultAddr, blockNumber) - require.NoError(br.t, err) - - l1FeeVaultBalance, err := br.client.BalanceAt(ctx, predeploys.L1FeeVaultAddr, blockNumber) - require.NoError(br.t, err) - - sequencerFeeVaultBalance, err := br.client.BalanceAt(ctx, predeploys.SequencerFeeVaultAddr, blockNumber) - require.NoError(br.t, err) - - operatorFeeVaultBalance, err := br.client.BalanceAt(ctx, predeploys.OperatorFeeVaultAddr, blockNumber) - require.NoError(br.t, err) - - walletBalance, err := br.client.BalanceAt(ctx, walletAddr, blockNumber) - require.NoError(br.t, err) - - br.logger.Debug("Sampled balances", - "baseFee", baseFeeVaultBalance, - "l1Fee", l1FeeVaultBalance, - "sequencerFee", sequencerFeeVaultBalance, - "operatorFee", operatorFeeVaultBalance, - "wallet", walletBalance) - - return &BalanceSnapshot{ - BlockNumber: blockNumber, - BaseFeeVaultBalance: baseFeeVaultBalance, - L1FeeVaultBalance: l1FeeVaultBalance, - SequencerFeeVault: sequencerFeeVaultBalance, - OperatorFeeVault: operatorFeeVaultBalance, - FromBalance: walletBalance, - } -} diff --git a/op-acceptance-tests/tests/isthmus/operator_fee/balance_snapshot.go b/op-acceptance-tests/tests/isthmus/operator_fee/balance_snapshot.go deleted file mode 100644 index 8f582564fac..00000000000 --- a/op-acceptance-tests/tests/isthmus/operator_fee/balance_snapshot.go +++ /dev/null @@ -1,112 +0,0 @@ -package operatorfee - -import ( - "fmt" - "math/big" - - "github.com/ethereum-optimism/optimism/op-devstack/devtest" - "github.com/stretchr/testify/assert" - "github.com/stretchr/testify/require" -) - -type BalanceSnapshot struct { - BlockNumber *big.Int - BaseFeeVaultBalance *big.Int - L1FeeVaultBalance *big.Int - SequencerFeeVault *big.Int - OperatorFeeVault *big.Int - FromBalance *big.Int -} - -// String returns a formatted string representation of the balance snapshot -func (bs *BalanceSnapshot) String() string { - if bs == nil { - return "nil" - } - - return fmt.Sprintf( - "BalanceSnapshot{Block: %v, BaseFeeVault: %v, L1FeeVault: %v, SequencerFeeVault: %v, "+ - "OperatorFeeVault: %v, WalletBalance: %v}", - bs.BlockNumber, - bs.BaseFeeVaultBalance, - bs.L1FeeVaultBalance, - bs.SequencerFeeVault, - bs.OperatorFeeVault, - bs.FromBalance, - ) -} - -// Add adds this snapshot's balances to another snapshot and returns a new snapshot -// This is typically used to apply changes to a starting balance snapshot -func (bs *BalanceSnapshot) Add(start *BalanceSnapshot) *BalanceSnapshot { - if bs == nil || start == nil { - return nil - } - - return &BalanceSnapshot{ - BlockNumber: bs.BlockNumber, // Use the target block number from changes - BaseFeeVaultBalance: new(big.Int).Add(start.BaseFeeVaultBalance, bs.BaseFeeVaultBalance), - L1FeeVaultBalance: new(big.Int).Add(start.L1FeeVaultBalance, bs.L1FeeVaultBalance), - SequencerFeeVault: new(big.Int).Add(start.SequencerFeeVault, bs.SequencerFeeVault), - OperatorFeeVault: new(big.Int).Add(start.OperatorFeeVault, bs.OperatorFeeVault), - FromBalance: new(big.Int).Add(start.FromBalance, bs.FromBalance), - } -} - -// Sub returns a new BalanceSnapshot containing the differences between this snapshot and another -// This snapshot is considered the "end" and the parameter is the "start" -// Positive values indicate increases, negative values indicate decreases -func (bs *BalanceSnapshot) Sub(start *BalanceSnapshot) *BalanceSnapshot { - if bs == nil || start == nil { - return nil - } - - return &BalanceSnapshot{ - BlockNumber: bs.BlockNumber, - BaseFeeVaultBalance: new(big.Int).Sub(bs.BaseFeeVaultBalance, start.BaseFeeVaultBalance), - L1FeeVaultBalance: new(big.Int).Sub(bs.L1FeeVaultBalance, start.L1FeeVaultBalance), - SequencerFeeVault: new(big.Int).Sub(bs.SequencerFeeVault, start.SequencerFeeVault), - OperatorFeeVault: new(big.Int).Sub(bs.OperatorFeeVault, start.OperatorFeeVault), - FromBalance: new(big.Int).Sub(bs.FromBalance, start.FromBalance), - } -} - -// AssertSnapshotsEqual compares two balance snapshots and reports differences -func AssertSnapshotsEqual(t devtest.T, expected, actual *BalanceSnapshot) { - require.NotNil(t, expected, "Expected snapshot should not be nil") - require.NotNil(t, actual, "Actual snapshot should not be nil") - - // Check base fee vault balance - assert.True(t, expected.BaseFeeVaultBalance.Cmp(actual.BaseFeeVaultBalance) == 0, - "BaseFeeVaultBalance mismatch: expected %v, got %v (diff: %v)", expected.BaseFeeVaultBalance, actual.BaseFeeVaultBalance, new(big.Int).Sub(actual.BaseFeeVaultBalance, expected.BaseFeeVaultBalance)) - - // Check L1 fee vault balance - assert.True(t, expected.L1FeeVaultBalance.Cmp(actual.L1FeeVaultBalance) == 0, - "L1FeeVaultBalance mismatch: expected %v, got %v (diff: %v)", expected.L1FeeVaultBalance, actual.L1FeeVaultBalance, new(big.Int).Sub(actual.L1FeeVaultBalance, expected.L1FeeVaultBalance)) - - // Check sequencer fee vault balance - assert.True(t, expected.SequencerFeeVault.Cmp(actual.SequencerFeeVault) == 0, - "SequencerFeeVault mismatch: expected %v, got %v (diff: %v)", expected.SequencerFeeVault, actual.SequencerFeeVault, new(big.Int).Sub(actual.SequencerFeeVault, expected.SequencerFeeVault)) - - // Check operator fee vault balance - assert.True(t, expected.OperatorFeeVault.Cmp(actual.OperatorFeeVault) == 0, - "OperatorFeeVault mismatch: expected %v, got %v (diff: %v)", expected.OperatorFeeVault, actual.OperatorFeeVault, new(big.Int).Sub(actual.OperatorFeeVault, expected.OperatorFeeVault)) - - // Check wallet balance - assert.True(t, expected.FromBalance.Cmp(actual.FromBalance) == 0, - "WalletBalance mismatch: expected %v, got %v (diff: %v)", expected.FromBalance, actual.FromBalance, new(big.Int).Sub(actual.FromBalance, expected.FromBalance)) -} - -// SnapshotsEqual compares two balance snapshots and returns true if they are equal -// This is a non-asserting version for unit tests -func SnapshotsEqual(expected, actual *BalanceSnapshot) bool { - if expected == nil || actual == nil { - return expected == actual - } - - return expected.BaseFeeVaultBalance.Cmp(actual.BaseFeeVaultBalance) == 0 && - expected.L1FeeVaultBalance.Cmp(actual.L1FeeVaultBalance) == 0 && - expected.SequencerFeeVault.Cmp(actual.SequencerFeeVault) == 0 && - expected.OperatorFeeVault.Cmp(actual.OperatorFeeVault) == 0 && - expected.FromBalance.Cmp(actual.FromBalance) == 0 -} diff --git a/op-acceptance-tests/tests/isthmus/operator_fee/balance_snapshot_test.go b/op-acceptance-tests/tests/isthmus/operator_fee/balance_snapshot_test.go deleted file mode 100644 index 1e55e703c1f..00000000000 --- a/op-acceptance-tests/tests/isthmus/operator_fee/balance_snapshot_test.go +++ /dev/null @@ -1,227 +0,0 @@ -package operatorfee - -import ( - "math/big" - "testing" - - "github.com/stretchr/testify/assert" - "github.com/stretchr/testify/require" -) - -// Helper function to create a BalanceSnapshot with specified values -func newTestSnapshot(block, baseFee, l1Fee, seqFee, opFee, from *big.Int) *BalanceSnapshot { - return &BalanceSnapshot{ - BlockNumber: block, - BaseFeeVaultBalance: baseFee, - L1FeeVaultBalance: l1Fee, - SequencerFeeVault: seqFee, - OperatorFeeVault: opFee, - FromBalance: from, - } -} - -func TestBalanceSnapshot_String(t *testing.T) { - t.Run("NilSnapshot", func(t *testing.T) { - var bs *BalanceSnapshot - assert.Equal(t, "nil", bs.String()) - }) - - t.Run("ZeroValues", func(t *testing.T) { - bs := newTestSnapshot( - big.NewInt(0), - big.NewInt(0), - big.NewInt(0), - big.NewInt(0), - big.NewInt(0), - big.NewInt(0), - ) - expected := "BalanceSnapshot{Block: 0, BaseFeeVault: 0, L1FeeVault: 0, SequencerFeeVault: 0, OperatorFeeVault: 0, WalletBalance: 0}" - assert.Equal(t, expected, bs.String()) - }) - - t.Run("NonZeroValues", func(t *testing.T) { - bs := newTestSnapshot( - big.NewInt(100), - big.NewInt(10), - big.NewInt(20), - big.NewInt(30), - big.NewInt(40), - big.NewInt(50), - ) - expected := "BalanceSnapshot{Block: 100, BaseFeeVault: 10, L1FeeVault: 20, SequencerFeeVault: 30, OperatorFeeVault: 40, WalletBalance: 50}" - assert.Equal(t, expected, bs.String()) - }) -} - -func TestBalanceSnapshot_Add(t *testing.T) { - start := newTestSnapshot( - big.NewInt(100), - big.NewInt(10), - big.NewInt(20), - big.NewInt(30), - big.NewInt(40), - big.NewInt(500), - ) - delta := newTestSnapshot( - big.NewInt(101), // Block number should come from delta - big.NewInt(5), - big.NewInt(10), - big.NewInt(15), - big.NewInt(20), - big.NewInt(100), - ) - expected := newTestSnapshot( - big.NewInt(101), // Expected block is from delta - big.NewInt(15), - big.NewInt(30), - big.NewInt(45), - big.NewInt(60), - big.NewInt(600), - ) - - t.Run("AddNonNil", func(t *testing.T) { - result := delta.Add(start) - require.NotNil(t, result) - // Direct comparison instead of AssertSnapshotsEqual - assert.True(t, expected.BlockNumber.Cmp(result.BlockNumber) == 0, "BlockNumber mismatch: expected %v, got %v", expected.BlockNumber, result.BlockNumber) - assert.True(t, expected.BaseFeeVaultBalance.Cmp(result.BaseFeeVaultBalance) == 0, "BaseFeeVaultBalance mismatch: expected %v, got %v", expected.BaseFeeVaultBalance, result.BaseFeeVaultBalance) - assert.True(t, expected.L1FeeVaultBalance.Cmp(result.L1FeeVaultBalance) == 0, "L1FeeVaultBalance mismatch: expected %v, got %v", expected.L1FeeVaultBalance, result.L1FeeVaultBalance) - assert.True(t, expected.SequencerFeeVault.Cmp(result.SequencerFeeVault) == 0, "SequencerFeeVault mismatch: expected %v, got %v", expected.SequencerFeeVault, result.SequencerFeeVault) - assert.True(t, expected.OperatorFeeVault.Cmp(result.OperatorFeeVault) == 0, "OperatorFeeVault mismatch: expected %v, got %v", expected.OperatorFeeVault, result.OperatorFeeVault) - assert.True(t, expected.FromBalance.Cmp(result.FromBalance) == 0, "FromBalance mismatch: expected %v, got %v", expected.FromBalance, result.FromBalance) - }) - - t.Run("AddNilStart", func(t *testing.T) { - result := delta.Add(nil) - assert.Nil(t, result) - }) - - t.Run("AddNilDelta", func(t *testing.T) { - var nilDelta *BalanceSnapshot - result := nilDelta.Add(start) - assert.Nil(t, result) - }) - - t.Run("AddNilToNil", func(t *testing.T) { - var nilDelta *BalanceSnapshot - result := nilDelta.Add(nil) - assert.Nil(t, result) - }) -} - -func TestBalanceSnapshot_Sub(t *testing.T) { - start := newTestSnapshot( - big.NewInt(100), - big.NewInt(10), - big.NewInt(20), - big.NewInt(30), - big.NewInt(40), - big.NewInt(500), - ) - end := newTestSnapshot( - big.NewInt(101), // Block number should come from 'end' (bs) - big.NewInt(15), - big.NewInt(30), - big.NewInt(45), - big.NewInt(60), - big.NewInt(600), - ) - expectedDelta := newTestSnapshot( - big.NewInt(101), // Expected block is from end (bs) - big.NewInt(5), - big.NewInt(10), - big.NewInt(15), - big.NewInt(20), - big.NewInt(100), - ) - - t.Run("SubNonNil", func(t *testing.T) { - delta := end.Sub(start) - require.NotNil(t, delta) - // Direct comparison - assert.True(t, expectedDelta.BlockNumber.Cmp(delta.BlockNumber) == 0, "BlockNumber mismatch: expected %v, got %v", expectedDelta.BlockNumber, delta.BlockNumber) - assert.True(t, expectedDelta.BaseFeeVaultBalance.Cmp(delta.BaseFeeVaultBalance) == 0, "BaseFeeVaultBalance mismatch: expected %v, got %v", expectedDelta.BaseFeeVaultBalance, delta.BaseFeeVaultBalance) - assert.True(t, expectedDelta.L1FeeVaultBalance.Cmp(delta.L1FeeVaultBalance) == 0, "L1FeeVaultBalance mismatch: expected %v, got %v", expectedDelta.L1FeeVaultBalance, delta.L1FeeVaultBalance) - assert.True(t, expectedDelta.SequencerFeeVault.Cmp(delta.SequencerFeeVault) == 0, "SequencerFeeVault mismatch: expected %v, got %v", expectedDelta.SequencerFeeVault, delta.SequencerFeeVault) - assert.True(t, expectedDelta.OperatorFeeVault.Cmp(delta.OperatorFeeVault) == 0, "OperatorFeeVault mismatch: expected %v, got %v", expectedDelta.OperatorFeeVault, delta.OperatorFeeVault) - assert.True(t, expectedDelta.FromBalance.Cmp(delta.FromBalance) == 0, "FromBalance mismatch: expected %v, got %v", expectedDelta.FromBalance, delta.FromBalance) - }) - - t.Run("SubNilStart", func(t *testing.T) { - delta := end.Sub(nil) - assert.Nil(t, delta) - }) - - t.Run("SubNilEnd", func(t *testing.T) { - var nilEnd *BalanceSnapshot - delta := nilEnd.Sub(start) - assert.Nil(t, delta) - }) - - t.Run("SubNilFromNil", func(t *testing.T) { - var nilEnd *BalanceSnapshot - delta := nilEnd.Sub(nil) - assert.Nil(t, delta) - }) - - t.Run("SubNegativeResult", func(t *testing.T) { - // Swapping start and end should result in negative delta - expectedNegativeDelta := newTestSnapshot( - big.NewInt(100), // Block number from start (now acting as 'bs') - big.NewInt(-5), - big.NewInt(-10), - big.NewInt(-15), - big.NewInt(-20), - big.NewInt(-100), - ) - delta := start.Sub(end) - require.NotNil(t, delta) - // Direct comparison - assert.True(t, expectedNegativeDelta.BlockNumber.Cmp(delta.BlockNumber) == 0, "BlockNumber mismatch: expected %v, got %v", expectedNegativeDelta.BlockNumber, delta.BlockNumber) - assert.True(t, expectedNegativeDelta.BaseFeeVaultBalance.Cmp(delta.BaseFeeVaultBalance) == 0, "BaseFeeVaultBalance mismatch: expected %v, got %v", expectedNegativeDelta.BaseFeeVaultBalance, delta.BaseFeeVaultBalance) - assert.True(t, expectedNegativeDelta.L1FeeVaultBalance.Cmp(delta.L1FeeVaultBalance) == 0, "L1FeeVaultBalance mismatch: expected %v, got %v", expectedNegativeDelta.L1FeeVaultBalance, delta.L1FeeVaultBalance) - assert.True(t, expectedNegativeDelta.SequencerFeeVault.Cmp(delta.SequencerFeeVault) == 0, "SequencerFeeVault mismatch: expected %v, got %v", expectedNegativeDelta.SequencerFeeVault, delta.SequencerFeeVault) - assert.True(t, expectedNegativeDelta.OperatorFeeVault.Cmp(delta.OperatorFeeVault) == 0, "OperatorFeeVault mismatch: expected %v, got %v", expectedNegativeDelta.OperatorFeeVault, delta.OperatorFeeVault) - assert.True(t, expectedNegativeDelta.FromBalance.Cmp(delta.FromBalance) == 0, "FromBalance mismatch: expected %v, got %v", expectedNegativeDelta.FromBalance, delta.FromBalance) - }) -} - -func TestSnapshotsEqual(t *testing.T) { - snap1 := newTestSnapshot(big.NewInt(1), big.NewInt(10), big.NewInt(20), big.NewInt(30), big.NewInt(40), big.NewInt(50)) - snap2 := newTestSnapshot(big.NewInt(1), big.NewInt(10), big.NewInt(20), big.NewInt(30), big.NewInt(40), big.NewInt(50)) - - t.Run("EqualSnapshots", func(t *testing.T) { - assert.True(t, SnapshotsEqual(snap1, snap2), "Equal snapshots should return true") - }) - - t.Run("DifferentBaseFee", func(t *testing.T) { - diffSnap := newTestSnapshot(big.NewInt(1), big.NewInt(99), big.NewInt(20), big.NewInt(30), big.NewInt(40), big.NewInt(50)) - assert.False(t, SnapshotsEqual(snap1, diffSnap), "Different BaseFeeVaultBalance should return false") - }) - - t.Run("DifferentL1Fee", func(t *testing.T) { - diffSnap := newTestSnapshot(big.NewInt(1), big.NewInt(10), big.NewInt(99), big.NewInt(30), big.NewInt(40), big.NewInt(50)) - assert.False(t, SnapshotsEqual(snap1, diffSnap), "Different L1FeeVaultBalance should return false") - }) - - t.Run("DifferentSequencerFee", func(t *testing.T) { - diffSnap := newTestSnapshot(big.NewInt(1), big.NewInt(10), big.NewInt(20), big.NewInt(99), big.NewInt(40), big.NewInt(50)) - assert.False(t, SnapshotsEqual(snap1, diffSnap), "Different SequencerFeeVault should return false") - }) - - t.Run("DifferentOperatorFee", func(t *testing.T) { - diffSnap := newTestSnapshot(big.NewInt(1), big.NewInt(10), big.NewInt(20), big.NewInt(30), big.NewInt(99), big.NewInt(50)) - assert.False(t, SnapshotsEqual(snap1, diffSnap), "Different OperatorFeeVault should return false") - }) - - t.Run("DifferentFromBalance", func(t *testing.T) { - diffSnap := newTestSnapshot(big.NewInt(1), big.NewInt(10), big.NewInt(20), big.NewInt(30), big.NewInt(40), big.NewInt(99)) - assert.False(t, SnapshotsEqual(snap1, diffSnap), "Different FromBalance should return false") - }) - - t.Run("NilSnapshots", func(t *testing.T) { - assert.True(t, SnapshotsEqual(nil, nil), "Both nil should return true") - assert.False(t, SnapshotsEqual(snap1, nil), "One nil should return false") - assert.False(t, SnapshotsEqual(nil, snap1), "One nil should return false") - }) -} diff --git a/op-acceptance-tests/tests/isthmus/operator_fee/fee_checker.go b/op-acceptance-tests/tests/isthmus/operator_fee/fee_checker.go deleted file mode 100644 index 296460cc082..00000000000 --- a/op-acceptance-tests/tests/isthmus/operator_fee/fee_checker.go +++ /dev/null @@ -1,144 +0,0 @@ -package operatorfee - -import ( - "context" - "math/big" - - "github.com/ethereum-optimism/optimism/op-devstack/devtest" - "github.com/ethereum/go-ethereum/common" - gethTypes "github.com/ethereum/go-ethereum/core/types" - "github.com/ethereum/go-ethereum/ethclient" - "github.com/ethereum/go-ethereum/log" - "github.com/ethereum/go-ethereum/params" - "github.com/stretchr/testify/require" -) - -type stateGetterAdapterFactory struct { - t devtest.T - client *ethclient.Client -} - -// stateGetterAdapter adapts the ethclient to implement the StateGetter interface -type stateGetterAdapter struct { - t devtest.T - client *ethclient.Client - ctx context.Context - blockNumber *big.Int -} - -func (f *stateGetterAdapterFactory) NewStateGetterAdapter(blockNumber *big.Int) *stateGetterAdapter { - return &stateGetterAdapter{ - t: f.t, - client: f.client, - ctx: f.t.Ctx(), - blockNumber: blockNumber, - } -} - -// GetState implements the StateGetter interface -func (sga *stateGetterAdapter) GetState(addr common.Address, key common.Hash) common.Hash { - var result common.Hash - val, err := sga.client.StorageAt(sga.ctx, addr, key, sga.blockNumber) - require.NoError(sga.t, err) - copy(result[:], val) - return result -} - -// FeeChecker provides methods to calculate various types of fees -type FeeChecker struct { - config *params.ChainConfig - logger log.Logger - sgaFactory *stateGetterAdapterFactory -} - -// NewFeeChecker creates a new FeeChecker instance -func NewFeeChecker(t devtest.T, client *ethclient.Client, chainConfig *params.ChainConfig, logger log.Logger) *FeeChecker { - logger.Debug("Creating fee checker", "chainID", chainConfig.ChainID) - - // Create state getter adapter factory - sgaFactory := &stateGetterAdapterFactory{ - t: t, - client: client, - } - - return &FeeChecker{ - config: chainConfig, - sgaFactory: sgaFactory, - logger: logger, - } -} - -// L1Cost calculates the L1 fee for a transaction -func (fc *FeeChecker) L1Cost(rcd gethTypes.RollupCostData, blockTime uint64, blockNumber *big.Int) *big.Int { - - // Create L1 cost function - l1CostFn := gethTypes.NewL1CostFunc(fc.config, fc.sgaFactory.NewStateGetterAdapter(blockNumber)) - return l1CostFn(rcd, blockTime) -} - -// OperatorFee calculates the operator fee for a transaction -func (fc *FeeChecker) OperatorFee(gasUsed uint64, blockTime uint64, blockNumber *big.Int) *big.Int { - operatorFeeFn := gethTypes.NewOperatorCostFunc(fc.config, fc.sgaFactory.NewStateGetterAdapter(blockNumber)) - return operatorFeeFn(gasUsed, blockTime).ToBig() -} - -// CalculateExpectedBalanceChanges creates a BalanceSnapshot containing expected fee movements -// Calculates all fees internally from raw inputs -func (fc *FeeChecker) CalculateExpectedBalanceChanges( - gasUsedUint64 uint64, - header *gethTypes.Header, - tx *gethTypes.Transaction, -) *BalanceSnapshot { - // Convert the gas used (uint64) to a big.Int. - gasUsed := new(big.Int).SetUint64(gasUsedUint64) - - // 1. Base Fee Burned: header.BaseFee * gasUsed - baseFee := new(big.Int).Mul(header.BaseFee, gasUsed) - - // 2. Calculate the effective tip. - // Effective tip is the minimum of: - // a) tx.GasTipCap() and - // b) tx.GasFeeCap() - header.BaseFee - tipCap := tx.GasTipCap() // maximum priority fee per gas offered by the user - feeCap := tx.GasFeeCap() // maximum fee per gas the user is willing to pay - - // Compute feeCap minus the base fee. - diff := new(big.Int).Sub(feeCap, header.BaseFee) - - // effectiveTip = min(tipCap, diff) - effectiveTip := new(big.Int) - if tipCap.Cmp(diff) < 0 { - effectiveTip.Set(tipCap) - } else { - effectiveTip.Set(diff) - } - - // 3. Coinbase Fee Credit: effectiveTip * gasUsed. - l2Fee := new(big.Int).Mul(effectiveTip, gasUsed) - - // Calculate L1 fee - - fc.logger.Debug("Calculating L1 fee", "rollupCostData", tx.RollupCostData(), "blockTime", header.Time) - l1Fee := fc.L1Cost(tx.RollupCostData(), header.Time, header.Number) - - // Calculate operator fee - fc.logger.Debug("Calculating operator fee", "gasUsed", gasUsedUint64, "blockTime", header.Time) - operatorFee := fc.OperatorFee(gasUsedUint64, header.Time, header.Number) - - txFeesAndValue := new(big.Int).Set(baseFee) - txFeesAndValue.Add(txFeesAndValue, l2Fee) - txFeesAndValue.Add(txFeesAndValue, l1Fee) - txFeesAndValue.Add(txFeesAndValue, operatorFee) - txFeesAndValue.Add(txFeesAndValue, tx.Value()) - - // Create a changes snapshot with expected fee movements - changes := &BalanceSnapshot{ - BaseFeeVaultBalance: baseFee, - L1FeeVaultBalance: l1Fee, - SequencerFeeVault: l2Fee, - OperatorFeeVault: operatorFee, // Operator fee is withdrawn - FromBalance: new(big.Int).Neg(txFeesAndValue), - } - - return changes -} diff --git a/op-acceptance-tests/tests/isthmus/operator_fee/system_config_contract_utils.go b/op-acceptance-tests/tests/isthmus/operator_fee/system_config_contract_utils.go deleted file mode 100644 index bb5c54780a6..00000000000 --- a/op-acceptance-tests/tests/isthmus/operator_fee/system_config_contract_utils.go +++ /dev/null @@ -1,103 +0,0 @@ -package operatorfee - -// NOTE: These utility functions have been converted from devnet-sdk to op-devstack types -// but are currently unused by tests. They would need implementation updates if used. - -import ( - "fmt" - - "github.com/ethereum-optimism/optimism/op-devstack/dsl" - "github.com/ethereum-optimism/optimism/op-e2e/bindings" - "github.com/ethereum/go-ethereum/accounts/abi/bind" - "github.com/ethereum/go-ethereum/common" - gethTypes "github.com/ethereum/go-ethereum/core/types" -) - -type TestParams struct { - ID string - OperatorFeeScalar uint32 - OperatorFeeConstant uint64 - L1BaseFeeScalar uint32 - L1BlobBaseFeeScalar uint32 -} - -func GetFeeParamsL1(systemConfig *bindings.SystemConfig, systemConfigAddress common.Address, l2L1BlockContract *bindings.L1Block, wallet *dsl.EOA) (tc TestParams, err error) { - operatorFeeConstant, err := systemConfig.OperatorFeeConstant(&bind.CallOpts{BlockNumber: nil}) - if err != nil { - return TestParams{}, fmt.Errorf("failed to get operator fee constant: %w", err) - } - operatorFeeScalar, err := systemConfig.OperatorFeeScalar(&bind.CallOpts{BlockNumber: nil}) - if err != nil { - return TestParams{}, fmt.Errorf("failed to get operator fee scalar: %w", err) - } - l1BaseFeeScalar, err := systemConfig.BasefeeScalar(&bind.CallOpts{BlockNumber: nil}) - if err != nil { - return TestParams{}, fmt.Errorf("failed to get l1 base fee scalar: %w", err) - } - l1BlobBaseFeeScalar, err := systemConfig.BlobbasefeeScalar(&bind.CallOpts{BlockNumber: nil}) - if err != nil { - return TestParams{}, fmt.Errorf("failed to get l1 blob base fee scalar: %w", err) - } - return TestParams{ - OperatorFeeConstant: operatorFeeConstant, - OperatorFeeScalar: operatorFeeScalar, - L1BaseFeeScalar: l1BaseFeeScalar, - L1BlobBaseFeeScalar: l1BlobBaseFeeScalar, - }, nil -} - -func GetFeeParamsL2(l2L1BlockContract *bindings.L1Block, wallet *dsl.EOA) (tc TestParams, err error) { - operatorFeeConstant, err := l2L1BlockContract.OperatorFeeConstant(&bind.CallOpts{BlockNumber: nil}) - if err != nil { - return TestParams{}, fmt.Errorf("failed to get operator fee constant: %w", err) - } - operatorFeeScalar, err := l2L1BlockContract.OperatorFeeScalar(&bind.CallOpts{BlockNumber: nil}) - if err != nil { - return TestParams{}, fmt.Errorf("failed to get operator fee scalar: %w", err) - } - l1BaseFeeScalar, err := l2L1BlockContract.BaseFeeScalar(&bind.CallOpts{BlockNumber: nil}) - if err != nil { - return TestParams{}, fmt.Errorf("failed to get l1 base fee scalar: %w", err) - } - l1BlobBaseFeeScalar, err := l2L1BlockContract.BlobBaseFeeScalar(&bind.CallOpts{BlockNumber: nil}) - if err != nil { - return TestParams{}, fmt.Errorf("failed to get l1 blob base fee scalar: %w", err) - } - return TestParams{ - OperatorFeeConstant: operatorFeeConstant, - OperatorFeeScalar: operatorFeeScalar, - L1BaseFeeScalar: l1BaseFeeScalar, - L1BlobBaseFeeScalar: l1BlobBaseFeeScalar, - }, nil -} - -func EnsureFeeParams(systemConfig *bindings.SystemConfig, systemConfigAddress common.Address, l2L1BlockContract *bindings.L1Block, wallet *dsl.EOA, tc TestParams) (err error, reset func() error) { - preFeeParams, err := GetFeeParamsL1(systemConfig, systemConfigAddress, l2L1BlockContract, wallet) - if err != nil { - return fmt.Errorf("failed to get L1 fee parameters: %w", err), nil - } - preFeeParams.ID = tc.ID - - if preFeeParams == tc { - // No need to update - return nil, nil - } - - return UpdateFeeParams(systemConfig, systemConfigAddress, l2L1BlockContract, wallet, tc), func() error { - return UpdateFeeParams(systemConfig, systemConfigAddress, l2L1BlockContract, wallet, preFeeParams) - } -} - -func UpdateFeeParams(systemConfig *bindings.SystemConfig, systemConfigAddress common.Address, l2L1BlockContract *bindings.L1Block, wallet *dsl.EOA, tc TestParams) (err error) { - return fmt.Errorf("not implemented for op-devstack - utility function not used by tests") -} - -// UpdateOperatorFeeParams updates the operator fee parameters in the SystemConfig contract. -// It constructs and sends a transaction using txplan and returns the signed transaction, the receipt, or an error. -func UpdateOperatorFeeParams(systemConfig *bindings.SystemConfig, systemConfigAddress common.Address, l2L1BlockContract *bindings.L1Block, wallet *dsl.EOA, operatorFeeConstant uint64, operatorFeeScalar uint32) (receipt *gethTypes.Receipt, err error) { - return nil, fmt.Errorf("not implemented for op-devstack - utility function not used by tests") -} - -func UpdateL1FeeParams(systemConfig *bindings.SystemConfig, systemConfigAddress common.Address, l2L1BlockContract *bindings.L1Block, wallet *dsl.EOA, l1BaseFeeScalar uint32, l1BlobBaseFeeScalar uint32) (receipt *gethTypes.Receipt, err error) { - return nil, fmt.Errorf("not implemented for op-devstack - utility function not used by tests") -} diff --git a/op-acceptance-tests/tests/isthmus/operator_fee/tx_utils.go b/op-acceptance-tests/tests/isthmus/operator_fee/tx_utils.go deleted file mode 100644 index 2763596cc9c..00000000000 --- a/op-acceptance-tests/tests/isthmus/operator_fee/tx_utils.go +++ /dev/null @@ -1,30 +0,0 @@ -package operatorfee - -// NOTE: These utility functions have been converted from devnet-sdk to op-devstack types -// but are currently unused by tests. They would need implementation updates if used. - -import ( - "context" - "fmt" - - "github.com/ethereum-optimism/optimism/op-devstack/dsl" - "github.com/ethereum-optimism/optimism/op-service/eth" - "github.com/ethereum/go-ethereum/common" - gethTypes "github.com/ethereum/go-ethereum/core/types" -) - -func EnsureSufficientBalance(wallet *dsl.EOA, to common.Address, value eth.ETH) (err error) { - return fmt.Errorf("not implemented for op-devstack - utility function not used by tests") -} - -func SendValueTx(wallet *dsl.EOA, to common.Address, value eth.ETH) (tx *gethTypes.Transaction, receipt *gethTypes.Receipt, err error) { - return nil, nil, fmt.Errorf("not implemented for op-devstack - utility function not used by tests") -} - -func ReturnRemainingFunds(wallet *dsl.EOA, to common.Address) (receipt *gethTypes.Receipt, err error) { - return nil, fmt.Errorf("not implemented for op-devstack - utility function not used by tests") -} - -func NewTestWallet(ctx context.Context, el dsl.ELNode) (*dsl.EOA, error) { - return nil, fmt.Errorf("not implemented for op-devstack - utility function not used by tests") -} From a7c92d8412437f24273921178018e66fefbfecda Mon Sep 17 00:00:00 2001 From: Sebastian Stammler Date: Tue, 21 Oct 2025 12:38:50 +0200 Subject: [PATCH 097/117] op-node: Fix gossip validation for Jovian blocks (#17940) Jovian blocks can have a non-zero blobGasUsed value, as the DA footprint is stored in it. --- op-node/p2p/gossip.go | 31 ++++++++++++++++++++----------- op-node/p2p/gossip_test.go | 26 ++++++++++++++++---------- op-service/ptr/ptr.go | 15 +++++++++++++++ 3 files changed, 51 insertions(+), 21 deletions(-) create mode 100644 op-service/ptr/ptr.go diff --git a/op-node/p2p/gossip.go b/op-node/p2p/gossip.go index a8871a7364f..2a8442a9d23 100644 --- a/op-node/p2p/gossip.go +++ b/op-node/p2p/gossip.go @@ -22,6 +22,7 @@ import ( "github.com/ethereum-optimism/optimism/op-node/rollup" "github.com/ethereum-optimism/optimism/op-service/eth" + "github.com/ethereum-optimism/optimism/op-service/ptr" opsigner "github.com/ethereum-optimism/optimism/op-service/signer" ) @@ -48,8 +49,10 @@ const ( // Message domains, the msg id function uncompresses to keep data monomorphic, // but invalid compressed data will need a unique different id. -var MessageDomainInvalidSnappy = [4]byte{0, 0, 0, 0} -var MessageDomainValidSnappy = [4]byte{1, 0, 0, 0} +var ( + MessageDomainInvalidSnappy = [4]byte{0, 0, 0, 0} + MessageDomainValidSnappy = [4]byte{1, 0, 0, 0} +) type GossipSetupConfigurables interface { PeerScoringParams() *ScoringParams @@ -262,7 +265,6 @@ func (sb *seenBlocks) markSeen(h common.Hash) { } func BuildBlocksValidator(log log.Logger, cfg *rollup.Config, runCfg GossipRuntimeConfig, blockVersion eth.BlockVersion, gossipConf GossipSetupConfigurables) pubsub.ValidatorEx { - // Seen block hashes per block height // uint64 -> *seenBlocks blockHeightLRU, err := lru.New[uint64, *seenBlocks](1000) @@ -380,15 +382,21 @@ func BuildBlocksValidator(log log.Logger, cfg *rollup.Config, runCfg GossipRunti } if blockVersion.HasBlobProperties() { - // [REJECT] if the block is on a topic >= V3 and has a blob gas used value that is not zero - if payload.BlobGasUsed == nil || *payload.BlobGasUsed != 0 { - log.Warn("payload is on v3 topic, but has non-zero blob gas used", "bad_hash", payload.BlockHash.String(), "blob_gas_used", payload.BlobGasUsed) + // [REJECT] if the block is on a topic >= V3 and has a nil blob gas used + if payload.BlobGasUsed == nil { + log.Warn("payload is on v3 topic, but has nil blob gas used", "bad_hash", payload.BlockHash.String()) + return pubsub.ValidationReject + // [REJECT] if the block is on a topic >= V3 and has a non-zero blob gas used field pre-Jovian + } else if !cfg.IsDAFootprintBlockLimit(uint64(payload.Timestamp)) && *payload.BlobGasUsed != 0 { + log.Warn("payload is on v3 topic, but has non-zero blob gas used", + "bad_hash", payload.BlockHash.String(), "blob_gas_used", *payload.BlobGasUsed) return pubsub.ValidationReject } // [REJECT] if the block is on a topic >= V3 and has an excess blob gas value that is not zero if payload.ExcessBlobGas == nil || *payload.ExcessBlobGas != 0 { - log.Warn("payload is on v3 topic, but has non-zero excess blob gas", "bad_hash", payload.BlockHash.String(), "excess_blob_gas", payload.ExcessBlobGas) + log.Warn("payload is on v3 topic, but has non-zero excess blob gas", + "bad_hash", payload.BlockHash.String(), "excess_blob_gas", ptr.Str(payload.ExcessBlobGas)) return pubsub.ValidationReject } } @@ -504,7 +512,7 @@ type publisher struct { var _ GossipOut = (*publisher)(nil) func combinePeers(allPeers ...[]peer.ID) []peer.ID { - var seen = make(map[peer.ID]bool) + seen := make(map[peer.ID]bool) var res []peer.ID for _, peers := range allPeers { for _, p := range peers { @@ -674,7 +682,6 @@ func newBlockTopic(ctx context.Context, topicId string, ps *pubsub.PubSub, log l validator, pubsub.WithValidatorTimeout(3*time.Second), pubsub.WithValidatorConcurrency(4)) - if err != nil { return nil, fmt.Errorf("failed to register gossip topic: %w", err) } @@ -707,8 +714,10 @@ func newBlockTopic(ctx context.Context, topicId string, ps *pubsub.PubSub, log l }, nil } -type TopicSubscriber func(ctx context.Context, sub *pubsub.Subscription) -type MessageHandler func(ctx context.Context, from peer.ID, msg any) error +type ( + TopicSubscriber func(ctx context.Context, sub *pubsub.Subscription) + MessageHandler func(ctx context.Context, from peer.ID, msg any) error +) func BlocksHandler(onBlock func(ctx context.Context, from peer.ID, msg *eth.ExecutionPayloadEnvelope) error) MessageHandler { return func(ctx context.Context, from peer.ID, msg any) error { diff --git a/op-node/p2p/gossip_test.go b/op-node/p2p/gossip_test.go index feb9181a0c2..c98cb2ae440 100644 --- a/op-node/p2p/gossip_test.go +++ b/op-node/p2p/gossip_test.go @@ -13,6 +13,7 @@ import ( "github.com/ethereum-optimism/optimism/op-node/rollup" "github.com/ethereum-optimism/optimism/op-service/eth" + "github.com/ethereum-optimism/optimism/op-service/ptr" opsigner "github.com/ethereum-optimism/optimism/op-service/signer" "github.com/ethereum-optimism/optimism/op-service/testlog" "github.com/ethereum-optimism/optimism/op-service/testutils" @@ -123,19 +124,19 @@ func createSignedP2Payload(payload MarshalSSZ, signer Signer, l2ChainID *big.Int return snappy.Encode(nil, data), nil } -func createExecutionPayload(w types.Withdrawals, withdrawalsRoot *common.Hash, excessGas, gasUsed *uint64) *eth.ExecutionPayload { +func createExecutionPayload(w types.Withdrawals, withdrawalsRoot *common.Hash, excessBlobGas, blobGasUsed *uint64) *eth.ExecutionPayload { return ð.ExecutionPayload{ Timestamp: hexutil.Uint64(time.Now().Unix()), Withdrawals: &w, WithdrawalsRoot: withdrawalsRoot, - ExcessBlobGas: (*eth.Uint64Quantity)(excessGas), - BlobGasUsed: (*eth.Uint64Quantity)(gasUsed), + ExcessBlobGas: (*eth.Uint64Quantity)(excessBlobGas), + BlobGasUsed: (*eth.Uint64Quantity)(blobGasUsed), } } -func createEnvelope(h *common.Hash, w types.Withdrawals, withdrawalsRoot *common.Hash, excessGas, gasUsed *uint64) *eth.ExecutionPayloadEnvelope { +func createEnvelope(h *common.Hash, w types.Withdrawals, withdrawalsRoot *common.Hash, excessBlobGas, blobGasUsed *uint64) *eth.ExecutionPayloadEnvelope { return ð.ExecutionPayloadEnvelope{ - ExecutionPayload: createExecutionPayload(w, withdrawalsRoot, excessGas, gasUsed), + ExecutionPayload: createExecutionPayload(w, withdrawalsRoot, excessBlobGas, blobGasUsed), ParentBeaconBlockRoot: h, } } @@ -157,7 +158,12 @@ func TestBlockValidator(t *testing.T) { mockGossipConf := &mockGossipSetupConfigurablesWithThreshold{threshold: 60 * time.Second} v2Validator := BuildBlocksValidator(testlog.Logger(t, log.LevelCrit), cfg, runCfg, eth.BlockV2, mockGossipConf) v3Validator := BuildBlocksValidator(testlog.Logger(t, log.LevelCrit), cfg, runCfg, eth.BlockV3, mockGossipConf) - v4Validator := BuildBlocksValidator(testlog.Logger(t, log.LevelCrit), cfg, runCfg, eth.BlockV4, mockGossipConf) + v4Validator := BuildBlocksValidator(testlog.Logger(t, log.LevelDebug), cfg, runCfg, eth.BlockV4, mockGossipConf) + jovianCfg := &rollup.Config{ + L2ChainID: big.NewInt(100), + JovianTime: ptr.New(uint64(0)), + } + v4JovianValidator := BuildBlocksValidator(testlog.Logger(t, log.LevelCrit), jovianCfg, runCfg, eth.BlockV4, mockGossipConf) zero, one := uint64(0), uint64(1) beaconHash, withdrawalsRoot := common.HexToHash("0x1234"), common.HexToHash("0x9876") @@ -174,8 +180,7 @@ func TestBlockValidator(t *testing.T) { {"V3RejectExecutionPayload", v3Validator, pubsub.ValidationReject, createExecutionPayload(types.Withdrawals{}, nil, &zero, &zero)}, } - for _, tt := range payloadTests { - test := tt + for _, test := range payloadTests { t.Run(fmt.Sprintf("ExecutionPayload_%s", test.name), func(t *testing.T) { e := ð.ExecutionPayloadEnvelope{ExecutionPayload: test.payload} test.payload.BlockHash, _ = e.CheckBlockHash() // hack to generate the block hash easily. @@ -198,10 +203,11 @@ func TestBlockValidator(t *testing.T) { {"V3Valid", v3Validator, pubsub.ValidationAccept, createEnvelope(&beaconHash, types.Withdrawals{}, nil, &zero, &zero)}, {"V4Valid", v4Validator, pubsub.ValidationAccept, createEnvelope(&beaconHash, types.Withdrawals{}, &withdrawalsRoot, &zero, &zero)}, {"V4RejectNoWithdrawalRoot", v4Validator, pubsub.ValidationReject, createEnvelope(&beaconHash, types.Withdrawals{}, nil, &zero, &zero)}, + {"V4AcceptNonZeroBlobGasUsedJovian", v4JovianValidator, pubsub.ValidationAccept, createEnvelope(&beaconHash, types.Withdrawals{}, &withdrawalsRoot, &zero, &one)}, + // Note: v3+ test cases with nil blobGasUsed cannot easily be included because they already fail at the SSZ marshaling stage. } - for _, tt := range envelopeTests { - test := tt + for _, test := range envelopeTests { t.Run(fmt.Sprintf("ExecutionPayloadEnvelope_%s", test.name), func(t *testing.T) { test.payload.ExecutionPayload.BlockHash, _ = test.payload.CheckBlockHash() // hack to generate the block hash easily. data, err := createSignedP2Payload(test.payload, signer, cfg.L2ChainID) diff --git a/op-service/ptr/ptr.go b/op-service/ptr/ptr.go new file mode 100644 index 00000000000..81c872cee84 --- /dev/null +++ b/op-service/ptr/ptr.go @@ -0,0 +1,15 @@ +// Package ptr provides helper functions for working with pointers. +package ptr + +import "fmt" + +func New[T any](v T) *T { + return &v +} + +func Str[T any](v *T) string { + if v == nil { + return "" + } + return fmt.Sprintf("%v", *v) +} From 32b170bbd6bc9efacf7992db30397326e0107435 Mon Sep 17 00:00:00 2001 From: viktorking7 <140458814+viktorking7@users.noreply.github.com> Date: Tue, 21 Oct 2025 15:15:26 +0200 Subject: [PATCH 098/117] Update ManageDrippie.s.sol (#17717) --- .../scripts/periphery/drippie/ManageDrippie.s.sol | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/packages/contracts-bedrock/scripts/periphery/drippie/ManageDrippie.s.sol b/packages/contracts-bedrock/scripts/periphery/drippie/ManageDrippie.s.sol index b7b04e6cf61..efb1477293d 100644 --- a/packages/contracts-bedrock/scripts/periphery/drippie/ManageDrippie.s.sol +++ b/packages/contracts-bedrock/scripts/periphery/drippie/ManageDrippie.s.sol @@ -102,7 +102,7 @@ contract ManageDrippie is Script { console.log("%s already active", _name); } else { // TODO: Better way to handle this? - console.log("WARNING: % could not be activated", _name); + console.log("WARNING: %s could not be activated", _name); } } } From bb24f93a14cbf3c1b471c11de61eef86a5b3bf58 Mon Sep 17 00:00:00 2001 From: Michael Amadi Date: Tue, 21 Oct 2025 14:45:39 +0100 Subject: [PATCH 099/117] remove the superchainProxyAdmin input from upgradeSuperchainConfig function (#17902) * remove the superchainProxyAdmin input from upgradeSuperchainConfig function * pull and update * fix semver --- .../deployer/integration_test/apply_test.go | 7 +++---- .../embedded/upgrade_superchainconfig.go | 7 +++---- .../interfaces/L1/IOPContractsManager.sol | 5 ++--- .../deploy/UpgradeSuperchainConfig.s.sol | 19 +++---------------- .../snapshots/abi/OPContractsManager.json | 5 ----- .../abi/OPContractsManagerUpgrader.json | 5 ----- .../snapshots/semver-lock.json | 4 ++-- .../src/L1/OPContractsManager.sol | 16 +++++++--------- .../test/L1/OPContractsManager.t.sol | 14 +++++--------- .../test/opcm/UpgradeSuperchainConfig.t.sol | 19 +++++-------------- .../test/setup/ForkLive.s.sol | 3 +-- 11 files changed, 31 insertions(+), 73 deletions(-) diff --git a/op-deployer/pkg/deployer/integration_test/apply_test.go b/op-deployer/pkg/deployer/integration_test/apply_test.go index 706a9b94fcc..012a6368704 100644 --- a/op-deployer/pkg/deployer/integration_test/apply_test.go +++ b/op-deployer/pkg/deployer/integration_test/apply_test.go @@ -221,10 +221,9 @@ func TestEndToEndBootstrapApplyWithUpgrade(t *testing.T) { // of the contracts-bedrock folder so upgrading directly would revert. t.Run("upgrade superchain config", func(t *testing.T) { upgradeConfig := embedded.UpgradeSuperchainConfigInput{ - Prank: superchainProxyAdminOwner, - Opcm: impls.Opcm, - SuperchainConfig: superchain.SuperchainConfigAddr, - SuperchainProxyAdmin: superchainProxyAdmin, + Prank: superchainProxyAdminOwner, + Opcm: impls.Opcm, + SuperchainConfig: superchain.SuperchainConfigAddr, } err = embedded.UpgradeSuperchainConfig(host, upgradeConfig) diff --git a/op-deployer/pkg/deployer/upgrade/embedded/upgrade_superchainconfig.go b/op-deployer/pkg/deployer/upgrade/embedded/upgrade_superchainconfig.go index eb008f92dd4..a1adb77cbb2 100644 --- a/op-deployer/pkg/deployer/upgrade/embedded/upgrade_superchainconfig.go +++ b/op-deployer/pkg/deployer/upgrade/embedded/upgrade_superchainconfig.go @@ -9,10 +9,9 @@ import ( ) type UpgradeSuperchainConfigInput struct { - Prank common.Address `json:"prank"` - Opcm common.Address `json:"opcm"` - SuperchainConfig common.Address `json:"superchainConfig"` - SuperchainProxyAdmin common.Address `json:"superchainProxyAdmin"` + Prank common.Address `json:"prank"` + Opcm common.Address `json:"opcm"` + SuperchainConfig common.Address `json:"superchainConfig"` } type UpgradeSuperchainConfigScript script.DeployScriptWithoutOutput[UpgradeSuperchainConfigInput] diff --git a/packages/contracts-bedrock/interfaces/L1/IOPContractsManager.sol b/packages/contracts-bedrock/interfaces/L1/IOPContractsManager.sol index 7b0c94669fb..719c523a8d6 100644 --- a/packages/contracts-bedrock/interfaces/L1/IOPContractsManager.sol +++ b/packages/contracts-bedrock/interfaces/L1/IOPContractsManager.sol @@ -94,7 +94,7 @@ interface IOPContractsManagerUpgrader { function upgrade(IOPContractsManager.OpChainConfig[] memory _opChainConfigs) external; - function upgradeSuperchainConfig(ISuperchainConfig _superchainConfig, IProxyAdmin _superchainProxyAdmin) external; + function upgradeSuperchainConfig(ISuperchainConfig _superchainConfig) external; function contractsContainer() external view returns (IOPContractsManagerContractsContainer); } @@ -343,8 +343,7 @@ interface IOPContractsManager { /// @notice Upgrades the SuperchainConfig contract. /// @param _superchainConfig The SuperchainConfig contract to upgrade. - /// @param _superchainProxyAdmin The ProxyAdmin contract to use for the upgrade. - function upgradeSuperchainConfig(ISuperchainConfig _superchainConfig, IProxyAdmin _superchainProxyAdmin) external; + function upgradeSuperchainConfig(ISuperchainConfig _superchainConfig) external; /// @notice addGameType deploys a new dispute game and links it to the DisputeGameFactory. The inputted _gameConfigs /// must be added in ascending GameType order. diff --git a/packages/contracts-bedrock/scripts/deploy/UpgradeSuperchainConfig.s.sol b/packages/contracts-bedrock/scripts/deploy/UpgradeSuperchainConfig.s.sol index 6d61677a5f3..ae50eaae109 100644 --- a/packages/contracts-bedrock/scripts/deploy/UpgradeSuperchainConfig.s.sol +++ b/packages/contracts-bedrock/scripts/deploy/UpgradeSuperchainConfig.s.sol @@ -4,14 +4,12 @@ pragma solidity ^0.8.0; import { Script } from "forge-std/Script.sol"; import { IOPContractsManager } from "interfaces/L1/IOPContractsManager.sol"; import { ISuperchainConfig } from "interfaces/L1/ISuperchainConfig.sol"; -import { IProxyAdmin } from "interfaces/universal/IProxyAdmin.sol"; contract UpgradeSuperchainConfig is Script { struct Input { address prank; IOPContractsManager opcm; ISuperchainConfig superchainConfig; - IProxyAdmin superchainProxyAdmin; } /// @notice Delegate calls upgradeSuperchainConfig on the OPCM from the input.prank address. @@ -33,12 +31,11 @@ contract UpgradeSuperchainConfig is Script { vm.label(prank, "DummyCaller"); ISuperchainConfig superchainConfig = _input.superchainConfig; - IProxyAdmin superchainProxyAdmin = _input.superchainProxyAdmin; // Call into the DummyCaller to perform the delegatecall vm.broadcast(msg.sender); - (bool success,) = DummyCaller(prank).upgradeSuperchainConfig(superchainConfig, superchainProxyAdmin); + (bool success,) = DummyCaller(prank).upgradeSuperchainConfig(superchainConfig); require(success, "UpgradeSuperchainConfig: upgradeSuperchainConfig failed"); } @@ -47,9 +44,6 @@ contract UpgradeSuperchainConfig is Script { require(_input.prank != address(0), "UpgradeSuperchainConfig: prank not set"); require(address(_input.opcm) != address(0), "UpgradeSuperchainConfig: opcm not set"); require(address(_input.superchainConfig) != address(0), "UpgradeSuperchainConfig: superchainConfig not set"); - require( - address(_input.superchainProxyAdmin) != address(0), "UpgradeSuperchainConfig: superchainProxyAdmin not set" - ); } } @@ -58,15 +52,8 @@ contract UpgradeSuperchainConfig is Script { contract DummyCaller { address internal _opcmAddr; - function upgradeSuperchainConfig( - ISuperchainConfig _superchainConfig, - IProxyAdmin _superchainProxyAdmin - ) - external - returns (bool, bytes memory) - { - bytes memory data = - abi.encodeCall(IOPContractsManager.upgradeSuperchainConfig, (_superchainConfig, _superchainProxyAdmin)); + function upgradeSuperchainConfig(ISuperchainConfig _superchainConfig) external returns (bool, bytes memory) { + bytes memory data = abi.encodeCall(IOPContractsManager.upgradeSuperchainConfig, (_superchainConfig)); (bool success, bytes memory result) = _opcmAddr.delegatecall(data); return (success, result); } diff --git a/packages/contracts-bedrock/snapshots/abi/OPContractsManager.json b/packages/contracts-bedrock/snapshots/abi/OPContractsManager.json index f90d2adb170..26c600b1d62 100644 --- a/packages/contracts-bedrock/snapshots/abi/OPContractsManager.json +++ b/packages/contracts-bedrock/snapshots/abi/OPContractsManager.json @@ -817,11 +817,6 @@ "internalType": "contract ISuperchainConfig", "name": "_superchainConfig", "type": "address" - }, - { - "internalType": "contract IProxyAdmin", - "name": "_superchainProxyAdmin", - "type": "address" } ], "name": "upgradeSuperchainConfig", diff --git a/packages/contracts-bedrock/snapshots/abi/OPContractsManagerUpgrader.json b/packages/contracts-bedrock/snapshots/abi/OPContractsManagerUpgrader.json index df01bf97b0e..9e22887fe3d 100644 --- a/packages/contracts-bedrock/snapshots/abi/OPContractsManagerUpgrader.json +++ b/packages/contracts-bedrock/snapshots/abi/OPContractsManagerUpgrader.json @@ -298,11 +298,6 @@ "internalType": "contract ISuperchainConfig", "name": "_superchainConfig", "type": "address" - }, - { - "internalType": "contract IProxyAdmin", - "name": "_superchainProxyAdmin", - "type": "address" } ], "name": "upgradeSuperchainConfig", diff --git a/packages/contracts-bedrock/snapshots/semver-lock.json b/packages/contracts-bedrock/snapshots/semver-lock.json index b087172884e..67ff74d01a4 100644 --- a/packages/contracts-bedrock/snapshots/semver-lock.json +++ b/packages/contracts-bedrock/snapshots/semver-lock.json @@ -20,8 +20,8 @@ "sourceCodeHash": "0xfca613b5d055ffc4c3cbccb0773ddb9030abedc1aa6508c9e2e7727cc0cd617b" }, "src/L1/OPContractsManager.sol:OPContractsManager": { - "initCodeHash": "0xc6a5146f158bc14297447cda1668f83e8dbfdd74f1b8bc2291d9626933bd23ad", - "sourceCodeHash": "0xd883ebfcc637ba9c6de12a872015098614cd288aaee84cda9d4c746aa1dcba18" + "initCodeHash": "0x0ef3fcb6fee1f73c95a48269bba8c83ee463a6f116f36f8d88edb247f72e8a05", + "sourceCodeHash": "0x16a845ddb5ee469e81f3d817ee9f6d6ff5697ace0bc399bd1e0f26e05546f781" }, "src/L1/OPContractsManagerStandardValidator.sol:OPContractsManagerStandardValidator": { "initCodeHash": "0x2eaa345ba05582c67b40a1eb7ec9d54823aa08468e697e2d6c04bb74cc574abc", diff --git a/packages/contracts-bedrock/src/L1/OPContractsManager.sol b/packages/contracts-bedrock/src/L1/OPContractsManager.sol index b662cbfc672..a0bc0789df1 100644 --- a/packages/contracts-bedrock/src/L1/OPContractsManager.sol +++ b/packages/contracts-bedrock/src/L1/OPContractsManager.sol @@ -1003,10 +1003,9 @@ contract OPContractsManagerUpgrader is OPContractsManagerBase { /// @notice Upgrades the SuperchainConfig contract. /// @param _superchainConfig The SuperchainConfig contract to upgrade. - /// @param _superchainProxyAdmin The ProxyAdmin contract to use for the upgrade. /// @dev This function is intended to be DELEGATECALLed by the superchainConfig's ProxyAdminOwner. /// @dev This function will revert if the SuperchainConfig is already at or above the target version. - function upgradeSuperchainConfig(ISuperchainConfig _superchainConfig, IProxyAdmin _superchainProxyAdmin) external { + function upgradeSuperchainConfig(ISuperchainConfig _superchainConfig) external { // Only upgrade the superchainConfig if the current version is less than the target version. if ( SemverComp.gte( @@ -1018,6 +1017,8 @@ contract OPContractsManagerUpgrader is OPContractsManagerBase { // Grab the implementations. OPContractsManager.Implementations memory impls = getImplementations(); + // Grab the superchainConfig's proxyAdmin. + IProxyAdmin _superchainProxyAdmin = IProxyAdmin(_superchainConfig.proxyAdmin()); // Attempt to upgrade. If the ProxyAdmin is not the SuperchainConfig's admin, this will revert. upgradeTo(_superchainProxyAdmin, address(_superchainConfig), impls.superchainConfigImpl); @@ -2088,9 +2089,9 @@ contract OPContractsManager is ISemver { // -------- Constants and Variables -------- - /// @custom:semver 4.3.0 + /// @custom:semver 4.4.0 function version() public pure virtual returns (string memory) { - return "4.3.0"; + return "4.4.0"; } OPContractsManagerGameTypeAdder public immutable opcmGameTypeAdder; @@ -2232,15 +2233,12 @@ contract OPContractsManager is ISemver { /// @notice Upgrades the SuperchainConfig contract. /// @param _superchainConfig The SuperchainConfig contract to upgrade. - /// @param _superchainProxyAdmin The ProxyAdmin contract to use for the upgrade. /// @dev This function is intended to be DELEGATECALLed by the superchainConfig's ProxyAdminOwner. /// @dev This function will revert if the SuperchainConfig is already at or above the target version. - function upgradeSuperchainConfig(ISuperchainConfig _superchainConfig, IProxyAdmin _superchainProxyAdmin) external { + function upgradeSuperchainConfig(ISuperchainConfig _superchainConfig) external { if (address(this) == address(thisOPCM)) revert OnlyDelegatecall(); - bytes memory data = abi.encodeCall( - OPContractsManagerUpgrader.upgradeSuperchainConfig, (_superchainConfig, _superchainProxyAdmin) - ); + bytes memory data = abi.encodeCall(OPContractsManagerUpgrader.upgradeSuperchainConfig, (_superchainConfig)); _performDelegateCall(address(opcmUpgrader), data); } diff --git a/packages/contracts-bedrock/test/L1/OPContractsManager.t.sol b/packages/contracts-bedrock/test/L1/OPContractsManager.t.sol index 4d3a5e6d091..5f5080991fc 100644 --- a/packages/contracts-bedrock/test/L1/OPContractsManager.t.sol +++ b/packages/contracts-bedrock/test/L1/OPContractsManager.t.sol @@ -206,8 +206,7 @@ contract OPContractsManager_Upgrade_Harness is CommonTest { // Execute the SuperchainConfig upgrade. // nosemgrep: sol-safety-trycatch-eip150 try DelegateCaller(superchainPAO).dcForward( - address(_opcm), - abi.encodeCall(IOPContractsManager.upgradeSuperchainConfig, (superchainConfig, superchainProxyAdmin)) + address(_opcm), abi.encodeCall(IOPContractsManager.upgradeSuperchainConfig, (superchainConfig)) ) { // Great, the upgrade succeeded. } catch (bytes memory reason) { @@ -1535,8 +1534,7 @@ contract OPContractsManager_UpgradeSuperchainConfig_Test is OPContractsManager_U vm.expectEmit(address(superchainConfig)); emit Upgraded(impls.superchainConfigImpl); DelegateCaller(superchainPAO).dcForward( - address(opcm), - abi.encodeCall(IOPContractsManager.upgradeSuperchainConfig, (superchainConfig, superchainProxyAdmin)) + address(opcm), abi.encodeCall(IOPContractsManager.upgradeSuperchainConfig, (superchainConfig)) ); } @@ -1545,7 +1543,7 @@ contract OPContractsManager_UpgradeSuperchainConfig_Test is OPContractsManager_U ISuperchainConfig superchainConfig = ISuperchainConfig(artifacts.mustGetAddress("SuperchainConfigProxy")); vm.expectRevert(IOPContractsManager.OnlyDelegatecall.selector); - opcm.upgradeSuperchainConfig(superchainConfig, superchainProxyAdmin); + opcm.upgradeSuperchainConfig(superchainConfig); } /// @notice Tests that the upgradeSuperchainConfig function reverts when the delegate caller is not the @@ -1561,8 +1559,7 @@ contract OPContractsManager_UpgradeSuperchainConfig_Test is OPContractsManager_U vm.expectRevert("Ownable: caller is not the owner"); DelegateCaller(delegateCaller).dcForward( - address(opcm), - abi.encodeCall(IOPContractsManager.upgradeSuperchainConfig, (superchainConfig, superchainProxyAdmin)) + address(opcm), abi.encodeCall(IOPContractsManager.upgradeSuperchainConfig, (superchainConfig)) ); } @@ -1580,8 +1577,7 @@ contract OPContractsManager_UpgradeSuperchainConfig_Test is OPContractsManager_U // Try to upgrade the SuperchainConfig contract again, should fail. vm.expectRevert(IOPContractsManagerUpgrader.OPContractsManagerUpgrader_SuperchainConfigAlreadyUpToDate.selector); DelegateCaller(upgrader).dcForward( - address(opcm), - abi.encodeCall(IOPContractsManager.upgradeSuperchainConfig, (superchainConfig, superchainProxyAdmin)) + address(opcm), abi.encodeCall(IOPContractsManager.upgradeSuperchainConfig, (superchainConfig)) ); } } diff --git a/packages/contracts-bedrock/test/opcm/UpgradeSuperchainConfig.t.sol b/packages/contracts-bedrock/test/opcm/UpgradeSuperchainConfig.t.sol index 41a479a69b3..da09590493a 100644 --- a/packages/contracts-bedrock/test/opcm/UpgradeSuperchainConfig.t.sol +++ b/packages/contracts-bedrock/test/opcm/UpgradeSuperchainConfig.t.sol @@ -4,7 +4,6 @@ pragma solidity 0.8.15; import { Test } from "forge-std/Test.sol"; import { ISuperchainConfig } from "interfaces/L1/ISuperchainConfig.sol"; -import { IProxyAdmin } from "interfaces/universal/IProxyAdmin.sol"; import { UpgradeSuperchainConfig } from "scripts/deploy/UpgradeSuperchainConfig.s.sol"; import { IOPContractsManager } from "interfaces/L1/IOPContractsManager.sol"; @@ -12,10 +11,10 @@ import { IOPContractsManager } from "interfaces/L1/IOPContractsManager.sol"; /// @title MockOPCM /// @notice This contract is used to mock the OPCM contract and emit an event which we check for in the test. contract MockOPCM { - event UpgradeCalled(address indexed superchainConfig, address indexed superchainProxyAdmin); + event UpgradeCalled(address indexed superchainConfig); - function upgradeSuperchainConfig(ISuperchainConfig _superchainConfig, IProxyAdmin _superchainProxyAdmin) public { - emit UpgradeCalled(address(_superchainConfig), address(_superchainProxyAdmin)); + function upgradeSuperchainConfig(ISuperchainConfig _superchainConfig) public { + emit UpgradeCalled(address(_superchainConfig)); } } @@ -27,9 +26,8 @@ contract UpgradeSuperchainConfig_Run_Test is Test { UpgradeSuperchainConfig upgradeSuperchainConfig; address prank; ISuperchainConfig superchainConfig; - IProxyAdmin superchainProxyAdmin; - event UpgradeCalled(address indexed superchainConfig, address indexed superchainProxyAdmin); + event UpgradeCalled(address indexed superchainConfig); /// @notice Sets up the test suite. function setUp() public virtual { @@ -38,11 +36,9 @@ contract UpgradeSuperchainConfig_Run_Test is Test { input.opcm = IOPContractsManager(address(mockOPCM)); superchainConfig = ISuperchainConfig(makeAddr("superchainConfig")); - superchainProxyAdmin = IProxyAdmin(makeAddr("superchainProxyAdmin")); prank = makeAddr("prank"); input.superchainConfig = superchainConfig; - input.superchainProxyAdmin = superchainProxyAdmin; input.prank = prank; upgradeSuperchainConfig = new UpgradeSuperchainConfig(); @@ -52,7 +48,7 @@ contract UpgradeSuperchainConfig_Run_Test is Test { function test_upgrade_succeeds() public { // UpgradeCalled should be emitted by the prank since it's a delegate call. vm.expectEmit(address(prank)); - emit UpgradeCalled(address(superchainConfig), address(superchainProxyAdmin)); + emit UpgradeCalled(address(superchainConfig)); upgradeSuperchainConfig.run(input); } @@ -72,10 +68,5 @@ contract UpgradeSuperchainConfig_Run_Test is Test { vm.expectRevert("UpgradeSuperchainConfig: superchainConfig not set"); upgradeSuperchainConfig.run(input); input.superchainConfig = ISuperchainConfig(address(superchainConfig)); - - input.superchainProxyAdmin = IProxyAdmin(address(0)); - vm.expectRevert("UpgradeSuperchainConfig: superchainProxyAdmin not set"); - upgradeSuperchainConfig.run(input); - input.superchainProxyAdmin = IProxyAdmin(address(superchainProxyAdmin)); } } diff --git a/packages/contracts-bedrock/test/setup/ForkLive.s.sol b/packages/contracts-bedrock/test/setup/ForkLive.s.sol index 7835c6a38cf..100c2e554ec 100644 --- a/packages/contracts-bedrock/test/setup/ForkLive.s.sol +++ b/packages/contracts-bedrock/test/setup/ForkLive.s.sol @@ -217,8 +217,7 @@ contract ForkLive is Deployer, StdAssertions { // Always try to upgrade the SuperchainConfig. Not always necessary but easier to do it // every time rather than adding or removing this code for each upgrade. try DelegateCaller(superchainPAO).dcForward( - address(_opcm), - abi.encodeCall(IOPContractsManager.upgradeSuperchainConfig, (superchainConfig, superchainProxyAdmin)) + address(_opcm), abi.encodeCall(IOPContractsManager.upgradeSuperchainConfig, (superchainConfig)) ) { // Great, the upgrade succeeded. } catch (bytes memory reason) { From 96fea292e54584f707f74dc4dc758b63c6835d41 Mon Sep 17 00:00:00 2001 From: Maurelian Date: Tue, 21 Oct 2025 10:21:19 -0400 Subject: [PATCH 100/117] Require that msgSender be an owner of the Safe (#17900) * Add SaferSafes as child of the module and guard * Add ISaferSafes * Test comment and assertion fixes * Improve comments * Make LivenessModule2 and TimelockGuard abstract Move semver to SaferSafes semver lock * fix test contract name * Move semver to SaferSafes * Disable the guard and module upon ownership transfer * Add _disableThisGuard function * Update tests * Add config resets * fmt * fix test_changeOwnershipToFallback_canRechallenge_succeeds * Simplify by clearing config directly * Put _disableThisGuard into child contract * Add timelockDelay reset on _disableThisGuard * semver-lock * Move _disableThisGuard logic into TimelockGuard * clear livenessSafeConfig at tend of _disableThisModule * Clarify use of SENTINEL_OWNER * Fix the ordering of the disableGuard and disableModule calls * semver-lock * remove unused imports * rename _disableThisGuard to _disableGuard * bump semver * Add test to remove unrelated guard * Add SENTINEL_MODULE constant * Clean up using ternary if * Reset cancellationThreshold to 0 on changeOwnership * Fix moduleFound if/else handling * Clear pending transactions * Pre-pr fixes * Add test contract to test name lint exclusions * fix name of test contract * Move _disableGuard impl into TimelockGuard * Add missing natspec * Add gas limit testing on changeOwnershipToFallback * Remove interfaces for abstract contracts * Move state changes out into internal _clearLivenessModule * Improve names on the internal _disableX methods * Add clearTimelockGuard function * Add _disableGuard helper to TLG tests * Limit number of transactions cancelled to 100 * Revert "Remove interfaces for abstract contracts" This reverts commit bd032889b639b35b8f512f941de3a924699fe44c. * Move livenessModule2 address into TestUtils Reduces diff a bit * Reduce diff somewhat * Remove unused arg * Update packages/contracts-bedrock/src/safe/TimelockGuard.sol Co-authored-by: graphite-app[bot] <96075541+graphite-app[bot]@users.noreply.github.com> * Fix iface * update abi for iface fix * Do not clear or disable the module during ownership transfer * Fix inaccurate comment on _disableAndClearGuard * Further improve comment * remove unused import * fix test name * Do not clear guard during changeOwnershipToFallback * Remove unused SENTINEL_MODULE var * Remove dangling comment * Revert "Remove dangling comment" This reverts commit d266d12dbc5af68b192c8898b7c97d772a8954a3. * Fix whitespace * remove unnecessary internal _clearTimelockGuard function It's no longer reused in the change ownership call. * Address feedback * Add missing assertion * Move guard slot into constants * semver-lock * Remove LivenessModule from semver-lock * fix: fmt, semver-lock, unused imports * Remove unused variable * fix semver lock by resetting old LivenessModule * fix unused import * Require that msgSender be an owner of the Safe * fix compiler error * Fix placement of _msgSender check * semver-lock * Add TimelockGuard_NotOwner test * Bump semver * Add test comment, make into fuzz test * Improvements to SaferSafes styling (#17903) * Add public getter livenessSafeConfiguration to return a struct rather than tuple * Use Safe as input type to mappings and functions on LivenessModule2 * Add dividers based on function type * fmt * snapshots * Remove conditional return of 0 in the cancellationThreshold if the guard is not enabled * rename timelockConfiguration func to timelockDelay * semver-lock * Add missing natspec on tests and convert to fuzzing where possible * fix import and abi snapshot * fix: off by one error in challenge period test * fix test name --------- Co-authored-by: graphite-app[bot] <96075541+graphite-app[bot]@users.noreply.github.com> --- .../scripts/deploy/DeployOwnership.s.sol | 8 +- .../snapshots/abi/SaferSafes.json | 44 ++-- .../snapshots/semver-lock.json | 4 +- .../snapshots/storageLayout/SaferSafes.json | 6 +- .../src/safe/LivenessModule2.sol | 126 ++++++---- .../contracts-bedrock/src/safe/SaferSafes.sol | 6 +- .../src/safe/TimelockGuard.sol | 18 +- .../test/safe/LivenessModule2.t.sol | 233 ++++++++++++++---- .../test/safe/SaferSafes.t.sol | 58 +++-- .../test/safe/TimelockGuard.t.sol | 69 +++--- .../test/scripts/DeployOwnership.t.sol | 10 +- 11 files changed, 385 insertions(+), 197 deletions(-) diff --git a/packages/contracts-bedrock/scripts/deploy/DeployOwnership.s.sol b/packages/contracts-bedrock/scripts/deploy/DeployOwnership.s.sol index ebbc244e9c3..d340380e96f 100644 --- a/packages/contracts-bedrock/scripts/deploy/DeployOwnership.s.sol +++ b/packages/contracts-bedrock/scripts/deploy/DeployOwnership.s.sol @@ -324,14 +324,14 @@ contract DeployOwnership is Deploy { removeDeployerFromSafe({ _name: "SecurityCouncilSafe", _newThreshold: exampleCouncilConfig.safeConfig.threshold }); // Verify the module was configured correctly - (uint256 configuredPeriod, address configuredFallback) = - LivenessModule2(livenessModule).livenessSafeConfiguration(address(safe)); + LivenessModule2.ModuleConfig memory verifyConfig = + LivenessModule2(livenessModule).livenessSafeConfiguration(safe); require( - configuredPeriod == exampleCouncilConfig.livenessModuleConfig.livenessInterval, + verifyConfig.livenessResponsePeriod == exampleCouncilConfig.livenessModuleConfig.livenessInterval, "DeployOwnership: configured liveness interval must match expected value" ); require( - configuredFallback == exampleCouncilConfig.livenessModuleConfig.fallbackOwner, + verifyConfig.fallbackOwner == exampleCouncilConfig.livenessModuleConfig.fallbackOwner, "DeployOwnership: configured fallback owner must match expected value" ); diff --git a/packages/contracts-bedrock/snapshots/abi/SaferSafes.json b/packages/contracts-bedrock/snapshots/abi/SaferSafes.json index 82747808687..64e28905550 100644 --- a/packages/contracts-bedrock/snapshots/abi/SaferSafes.json +++ b/packages/contracts-bedrock/snapshots/abi/SaferSafes.json @@ -49,7 +49,7 @@ { "inputs": [ { - "internalType": "address", + "internalType": "contract GnosisSafe", "name": "_safe", "type": "address" } @@ -62,7 +62,7 @@ { "inputs": [ { - "internalType": "address", + "internalType": "contract GnosisSafe", "name": "", "type": "address" } @@ -81,7 +81,7 @@ { "inputs": [ { - "internalType": "address", + "internalType": "contract GnosisSafe", "name": "_safe", "type": "address" } @@ -163,7 +163,7 @@ }, { "internalType": "address", - "name": "", + "name": "_msgSender", "type": "address" } ], @@ -227,7 +227,7 @@ { "inputs": [ { - "internalType": "address", + "internalType": "contract GnosisSafe", "name": "_safe", "type": "address" } @@ -246,22 +246,29 @@ { "inputs": [ { - "internalType": "address", - "name": "", + "internalType": "contract GnosisSafe", + "name": "_safe", "type": "address" } ], "name": "livenessSafeConfiguration", "outputs": [ { - "internalType": "uint256", - "name": "livenessResponsePeriod", - "type": "uint256" - }, - { - "internalType": "address", - "name": "fallbackOwner", - "type": "address" + "components": [ + { + "internalType": "uint256", + "name": "livenessResponsePeriod", + "type": "uint256" + }, + { + "internalType": "address", + "name": "fallbackOwner", + "type": "address" + } + ], + "internalType": "struct LivenessModule2.ModuleConfig", + "name": "", + "type": "tuple" } ], "stateMutability": "view", @@ -560,7 +567,7 @@ "type": "address" } ], - "name": "timelockConfiguration", + "name": "timelockDelay", "outputs": [ { "internalType": "uint256", @@ -902,6 +909,11 @@ "name": "TimelockGuard_InvalidVersion", "type": "error" }, + { + "inputs": [], + "name": "TimelockGuard_NotOwner", + "type": "error" + }, { "inputs": [], "name": "TimelockGuard_TransactionAlreadyCancelled", diff --git a/packages/contracts-bedrock/snapshots/semver-lock.json b/packages/contracts-bedrock/snapshots/semver-lock.json index 67ff74d01a4..04fddbbce64 100644 --- a/packages/contracts-bedrock/snapshots/semver-lock.json +++ b/packages/contracts-bedrock/snapshots/semver-lock.json @@ -208,8 +208,8 @@ "sourceCodeHash": "0x950725f8b9ad9bb3b6b5e836f67e18db824a7864bac547ee0eeba88ada3de0e9" }, "src/safe/SaferSafes.sol:SaferSafes": { - "initCodeHash": "0x68567829042bbd450ffd477848ddcda288e36714846fdcc02c315f2d0d332da6", - "sourceCodeHash": "0x06fc6d5df3c5769b645ff319d8b94415e501711c19cb0b1bce2631771d22294f" + "initCodeHash": "0xaa17bb150c9bcf19675a33e9762b050148aceae9f6a9a6ba020fc6947ebaab39", + "sourceCodeHash": "0xc4201612048ff051ed795521efa3eece1a6556f2c514a268b180d84a2ad8b2d1" }, "src/universal/OptimismMintableERC20.sol:OptimismMintableERC20": { "initCodeHash": "0x3c85eed0d017dca8eda6396aa842ddc12492587b061e8c756a8d32c4610a9658", diff --git a/packages/contracts-bedrock/snapshots/storageLayout/SaferSafes.json b/packages/contracts-bedrock/snapshots/storageLayout/SaferSafes.json index 17b7d237e9f..c8fa41d7a3c 100644 --- a/packages/contracts-bedrock/snapshots/storageLayout/SaferSafes.json +++ b/packages/contracts-bedrock/snapshots/storageLayout/SaferSafes.json @@ -1,17 +1,17 @@ [ { "bytes": "32", - "label": "livenessSafeConfiguration", + "label": "_livenessSafeConfiguration", "offset": 0, "slot": "0", - "type": "mapping(address => struct LivenessModule2.ModuleConfig)" + "type": "mapping(contract GnosisSafe => struct LivenessModule2.ModuleConfig)" }, { "bytes": "32", "label": "challengeStartTime", "offset": 0, "slot": "1", - "type": "mapping(address => uint256)" + "type": "mapping(contract GnosisSafe => uint256)" }, { "bytes": "32", diff --git a/packages/contracts-bedrock/src/safe/LivenessModule2.sol b/packages/contracts-bedrock/src/safe/LivenessModule2.sol index 1feb5595689..fe024bc757d 100644 --- a/packages/contracts-bedrock/src/safe/LivenessModule2.sol +++ b/packages/contracts-bedrock/src/safe/LivenessModule2.sol @@ -27,10 +27,10 @@ abstract contract LivenessModule2 { } /// @notice Mapping from Safe address to its configuration. - mapping(address => ModuleConfig) public livenessSafeConfiguration; + mapping(Safe => ModuleConfig) internal _livenessSafeConfiguration; /// @notice Mapping from Safe address to active challenge start time (0 if none). - mapping(address => uint256) public challengeStartTime; + mapping(Safe => uint256) public challengeStartTime; /// @notice Reserved address used as previous owner to the first owner in a Safe. address internal constant SENTINEL_OWNER = address(0x1); @@ -95,23 +95,40 @@ abstract contract LivenessModule2 { /// @param fallbackOwner The address that claimed ownership if the Safe is unresponsive. event ChallengeSucceeded(address indexed safe, address fallbackOwner); + //////////////////////////////////////////////////////////////// + // External View Functions // + //////////////////////////////////////////////////////////////// + /// @notice Returns challenge_start_time + liveness_response_period if challenge exists, or /// 0 if not. /// @param _safe The Safe address to query. /// @return The challenge end timestamp, or 0 if no challenge. - function getChallengePeriodEnd(address _safe) public view returns (uint256) { + function getChallengePeriodEnd(Safe _safe) public view returns (uint256) { uint256 startTime = challengeStartTime[_safe]; if (startTime == 0) { return 0; } - ModuleConfig storage config = livenessSafeConfiguration[_safe]; + ModuleConfig storage config = _livenessSafeConfiguration[_safe]; return startTime + config.livenessResponsePeriod; } + /// @notice Returns the configuration for a given Safe. + /// @param _safe The Safe address to query. + /// @return The ModuleConfig for the Safe. + function livenessSafeConfiguration(Safe _safe) public view returns (ModuleConfig memory) { + return _livenessSafeConfiguration[_safe]; + } + + //////////////////////////////////////////////////////////////// + // External State-Changing Functions // + //////////////////////////////////////////////////////////////// + /// @notice Configures the module for a Safe that has already enabled it. /// @param _config The configuration parameters for the module containing the response /// period and fallback owner. function configureLivenessModule(ModuleConfig memory _config) external { + Safe callingSafe = Safe(payable(msg.sender)); + // Validate configuration parameters to ensure module can function properly. // livenessResponsePeriod must be > 0 to allow time for Safe owners to respond. if (_config.livenessResponsePeriod == 0) { @@ -123,10 +140,10 @@ abstract contract LivenessModule2 { } // Check that this module is enabled on the calling Safe. - _assertModuleEnabled(msg.sender); + _assertModuleEnabled(callingSafe); // Store the configuration for this safe - livenessSafeConfiguration[msg.sender] = _config; + _livenessSafeConfiguration[callingSafe] = _config; // Clear any existing challenge when configuring/re-configuring. // This is necessary because changing the configuration (especially @@ -137,19 +154,14 @@ abstract contract LivenessModule2 { // Additionally, a Safe that is able to successfully trigger the configuration function // is necessarily live, so cancelling the challenge also makes sense from a // theoretical standpoint. - _cancelChallenge(msg.sender); + _cancelChallenge(callingSafe); emit ModuleConfigured(msg.sender, _config.livenessResponsePeriod, _config.fallbackOwner); // Verify that any other extensions which are enabled on the Safe are configured correctly. - _checkCombinedConfig(Safe(payable(msg.sender))); + _checkCombinedConfig(callingSafe); } - /// @notice Internal helper function which can be overriden in a child contract to check if the guard's - /// configuration is valid in the context of other extensions that are enabled on the Safe. - /// @param _safe The Safe instance to check the configuration against - function _checkCombinedConfig(Safe _safe) internal view virtual; - /// @notice Clears the module configuration for a Safe. /// @dev Note: Clearing the configuration also cancels any ongoing challenges. /// This function is intended for use when a Safe wants to permanently remove @@ -160,23 +172,25 @@ abstract contract LivenessModule2 { /// Never calling clearLivenessModule() after disabling keeps configuration data persistent /// for potential future re-enabling. function clearLivenessModule() external { + Safe callingSafe = Safe(payable(msg.sender)); + // Check if the calling safe has configuration set - _assertModuleConfigured(msg.sender); + _assertModuleConfigured(callingSafe); // Check that this module is NOT enabled on the calling Safe // This prevents clearing configuration while module is still enabled - _assertModuleNotEnabled(msg.sender); + _assertModuleNotEnabled(callingSafe); // Erase the configuration data for this safe - delete livenessSafeConfiguration[msg.sender]; + delete _livenessSafeConfiguration[callingSafe]; // Also clear any active challenge - _cancelChallenge(msg.sender); - emit ModuleCleared(msg.sender); + _cancelChallenge(callingSafe); + emit ModuleCleared(address(callingSafe)); } /// @notice Challenges an enabled safe. /// @param _safe The Safe address to challenge. - function challenge(address _safe) external { + function challenge(Safe _safe) external { // Check if the calling safe has configuration set _assertModuleConfigured(_safe); @@ -184,7 +198,7 @@ abstract contract LivenessModule2 { _assertModuleEnabled(_safe); // Check that the caller is the fallback owner - if (msg.sender != livenessSafeConfiguration[_safe].fallbackOwner) { + if (msg.sender != _livenessSafeConfiguration[_safe].fallbackOwner) { revert LivenessModule2_UnauthorizedCaller(); } @@ -195,26 +209,28 @@ abstract contract LivenessModule2 { // Set the challenge start time and emit the event challengeStartTime[_safe] = block.timestamp; - emit ChallengeStarted(_safe, block.timestamp); + emit ChallengeStarted(address(_safe), block.timestamp); } /// @notice Responds to a challenge for an enabled safe, canceling it. function respond() external { + Safe callingSafe = Safe(payable(msg.sender)); + // Check if the calling safe has configuration set. - _assertModuleConfigured(msg.sender); + _assertModuleConfigured(callingSafe); // Check that this module is enabled on the calling Safe. - _assertModuleEnabled(msg.sender); + _assertModuleEnabled(callingSafe); // Check that a challenge exists - uint256 startTime = challengeStartTime[msg.sender]; + uint256 startTime = challengeStartTime[callingSafe]; if (startTime == 0) { revert LivenessModule2_ChallengeDoesNotExist(); } // Cancel the challenge without checking if response period has expired // This allows the Safe to respond at any time, providing more flexibility - _cancelChallenge(msg.sender); + _cancelChallenge(callingSafe); } /// @notice With successful challenge, removes all current owners from enabled safe, @@ -224,7 +240,7 @@ abstract contract LivenessModule2 { /// fallback owner effectively becomes its own fallback owner, maintaining /// the ability to challenge itself if needed. /// @param _safe The Safe address to transfer ownership of. - function changeOwnershipToFallback(address _safe) external { + function changeOwnershipToFallback(Safe _safe) external { // Ensure Safe is configured with this module to prevent unauthorized execution. _assertModuleConfigured(_safe); @@ -232,7 +248,7 @@ abstract contract LivenessModule2 { _assertModuleEnabled(_safe); // Only fallback owner can execute ownership transfer (per specs update) - if (msg.sender != livenessSafeConfiguration[_safe].fallbackOwner) { + if (msg.sender != _livenessSafeConfiguration[_safe].fallbackOwner) { revert LivenessModule2_UnauthorizedCaller(); } @@ -248,61 +264,67 @@ abstract contract LivenessModule2 { revert LivenessModule2_ResponsePeriodActive(); } - Safe targetSafe = Safe(payable(_safe)); - // Get current owners - address[] memory owners = targetSafe.getOwners(); + address[] memory owners = _safe.getOwners(); // Remove all owners after the first one // Note: This loop is safe as real-world Safes have limited owners (typically < 10) // Gas limits would only be a concern with hundreds/thousands of owners while (owners.length > 1) { - targetSafe.execTransactionFromModule({ - to: _safe, + _safe.execTransactionFromModule({ + to: address(_safe), value: 0, operation: Enum.Operation.Call, data: abi.encodeCall(OwnerManager.removeOwner, (SENTINEL_OWNER, owners[0], 1)) }); - owners = targetSafe.getOwners(); + owners = _safe.getOwners(); } // Now swap the remaining single owner with the fallback owner - targetSafe.execTransactionFromModule({ - to: _safe, + _safe.execTransactionFromModule({ + to: address(_safe), value: 0, operation: Enum.Operation.Call, data: abi.encodeCall( - OwnerManager.swapOwner, (SENTINEL_OWNER, owners[0], livenessSafeConfiguration[_safe].fallbackOwner) + OwnerManager.swapOwner, (SENTINEL_OWNER, owners[0], _livenessSafeConfiguration[_safe].fallbackOwner) ) }); // Sanity check: verify the fallback owner is now the only owner - address[] memory finalOwners = targetSafe.getOwners(); - if (finalOwners.length != 1 || finalOwners[0] != livenessSafeConfiguration[_safe].fallbackOwner) { + address[] memory finalOwners = _safe.getOwners(); + if (finalOwners.length != 1 || finalOwners[0] != _livenessSafeConfiguration[_safe].fallbackOwner) { revert LivenessModule2_OwnershipTransferFailed(); } // Reset the challenge state to allow a new challenge delete challengeStartTime[_safe]; - emit ChallengeSucceeded(_safe, livenessSafeConfiguration[_safe].fallbackOwner); // Disable the guard // Note that this will remove whichever guard is currently set on the Safe, // even if it is not the SaferSafes guard. This is intentional, as it is possible that the guard // itself was the cause of the liveness failure which resulted in the transfer of ownership to // the fallback owner. - targetSafe.execTransactionFromModule({ - to: _safe, + _safe.execTransactionFromModule({ + to: address(_safe), value: 0, operation: Enum.Operation.Call, data: abi.encodeCall(GuardManager.setGuard, (address(0))) }); + emit ChallengeSucceeded(address(_safe), _livenessSafeConfiguration[_safe].fallbackOwner); } + //////////////////////////////////////////////////////////////// + // Internal View Functions // + //////////////////////////////////////////////////////////////// + + /// @notice Internal helper function which can be overriden in a child contract to check if the guard's + /// configuration is valid in the context of other extensions that are enabled on the Safe. + function _checkCombinedConfig(Safe _safe) internal view virtual; + /// @notice Asserts that the module is configured for the given Safe. /// @param _safe The Safe address to check. - function _assertModuleConfigured(address _safe) internal view { - ModuleConfig storage config = livenessSafeConfiguration[_safe]; + function _assertModuleConfigured(Safe _safe) internal view { + ModuleConfig storage config = _livenessSafeConfiguration[_safe]; if (config.fallbackOwner == address(0)) { revert LivenessModule2_ModuleNotConfigured(); } @@ -310,29 +332,31 @@ abstract contract LivenessModule2 { /// @notice Asserts that the module is enabled for the given Safe. /// @param _safe The Safe address to check. - function _assertModuleEnabled(address _safe) internal view { - Safe safe = Safe(payable(_safe)); - if (!safe.isModuleEnabled(address(this))) { + function _assertModuleEnabled(Safe _safe) internal view { + if (!_safe.isModuleEnabled(address(this))) { revert LivenessModule2_ModuleNotEnabled(); } } /// @notice Asserts that the module is not enabled for the given Safe. /// @param _safe The Safe address to check. - function _assertModuleNotEnabled(address _safe) internal view { - Safe safe = Safe(payable(_safe)); - if (safe.isModuleEnabled(address(this))) { + function _assertModuleNotEnabled(Safe _safe) internal view { + if (_safe.isModuleEnabled(address(this))) { revert LivenessModule2_ModuleStillEnabled(); } } + //////////////////////////////////////////////////////////////// + // Internal State-Changing Functions // + //////////////////////////////////////////////////////////////// + /// @notice Internal function to cancel a challenge and emit the appropriate event. /// @param _safe The Safe address for which to cancel the challenge. - function _cancelChallenge(address _safe) internal { + function _cancelChallenge(Safe _safe) internal { // Early return if no challenge exists if (challengeStartTime[_safe] == 0) return; delete challengeStartTime[_safe]; - emit ChallengeCancelled(_safe); + emit ChallengeCancelled(address(_safe)); } } diff --git a/packages/contracts-bedrock/src/safe/SaferSafes.sol b/packages/contracts-bedrock/src/safe/SaferSafes.sol index 53b64c8a73a..52ea97df94e 100644 --- a/packages/contracts-bedrock/src/safe/SaferSafes.sol +++ b/packages/contracts-bedrock/src/safe/SaferSafes.sol @@ -22,8 +22,8 @@ import { ISemver } from "interfaces/universal/ISemver.sol"; /// functionality is not desired, then there is no need to enable or configure it. contract SaferSafes is LivenessModule2, TimelockGuard, ISemver { /// @notice Semantic version. - /// @custom:semver 1.1.0 - string public constant version = "1.1.0"; + /// @custom:semver 1.2.0 + string public constant version = "1.2.0"; /// @notice Error for when the liveness response period is insufficient. error SaferSafes_InsufficientLivenessResponsePeriod(); @@ -39,7 +39,7 @@ contract SaferSafes is LivenessModule2, TimelockGuard, ISemver { } uint256 timelockDelay = _safeState[_safe].timelockDelay; - uint256 livenessResponsePeriod = livenessSafeConfiguration[address(_safe)].livenessResponsePeriod; + uint256 livenessResponsePeriod = _livenessSafeConfiguration[_safe].livenessResponsePeriod; // If the timelock delay is 0, then the timelock guard is enabled but not configured. // No delay is applied to transactions, so we don't need to perform any further checks. diff --git a/packages/contracts-bedrock/src/safe/TimelockGuard.sol b/packages/contracts-bedrock/src/safe/TimelockGuard.sol index 40fecbcbe1b..2276cbdcf99 100644 --- a/packages/contracts-bedrock/src/safe/TimelockGuard.sol +++ b/packages/contracts-bedrock/src/safe/TimelockGuard.sol @@ -158,6 +158,9 @@ abstract contract TimelockGuard is IGuard { /// @param uncancelledCount The number of transactions that are not cancelled. event TransactionsNotCancelled(Safe indexed safe, uint256 uncancelledCount); + /// @notice Error for when the caller is not an owner of the Safe + error TimelockGuard_NotOwner(); + /// @notice Emitted when a Safe configures the guard /// @param safe The Safe whose guard is configured. /// @param timelockDelay The timelock delay in seconds. @@ -221,11 +224,6 @@ abstract contract TimelockGuard is IGuard { /// @param _safe The Safe address to query /// @return The current cancellation threshold function cancellationThreshold(Safe _safe) public view returns (uint256) { - // Return 0 if guard is not enabled - if (!_isGuardEnabled(_safe)) { - return 0; - } - return _safeState[_safe].cancellationThreshold; } @@ -251,7 +249,7 @@ abstract contract TimelockGuard is IGuard { /// @notice Returns the timelock delay for a given Safe /// @param _safe The Safe address to query /// @return The timelock delay in seconds - function timelockConfiguration(Safe _safe) public view returns (uint256) { + function timelockDelay(Safe _safe) public view returns (uint256) { return _safeState[_safe].timelockDelay; } @@ -306,7 +304,7 @@ abstract contract TimelockGuard is IGuard { address _gasToken, address payable _refundReceiver, bytes memory, /* signatures */ - address /* msgSender */ + address _msgSender ) external view @@ -323,6 +321,12 @@ abstract contract TimelockGuard is IGuard { return; } + // Limit execution of transactions to owners of the Safe only. + // This ensures that an attacker cannot simply collect valid signatures, but must also control a private key. + if (!callingSafe.isOwner(_msgSender)) { + revert TimelockGuard_NotOwner(); + } + // Get the nonce of the Safe for the transaction being executed, // since the Safe's nonce is incremented before the transaction is executed, // we must subtract 1. diff --git a/packages/contracts-bedrock/test/safe/LivenessModule2.t.sol b/packages/contracts-bedrock/test/safe/LivenessModule2.t.sol index c45781b8b58..91b8ca7c258 100644 --- a/packages/contracts-bedrock/test/safe/LivenessModule2.t.sol +++ b/packages/contracts-bedrock/test/safe/LivenessModule2.t.sol @@ -3,6 +3,7 @@ pragma solidity 0.8.15; import { Test } from "forge-std/Test.sol"; import { Enum } from "safe-contracts/common/Enum.sol"; +import { GnosisSafe as Safe } from "safe-contracts/GnosisSafe.sol"; import "test/safe-tools/SafeTestTools.sol"; import { Constants } from "src/libraries/Constants.sol"; @@ -116,10 +117,10 @@ contract LivenessModule2_ConfigureLivenessModule_Test is LivenessModule2_TestIni _enableModule(safeInstance, CHALLENGE_PERIOD, fallbackOwner); - (uint256 period, address fbOwner) = livenessModule2.livenessSafeConfiguration(address(safeInstance.safe)); - assertEq(period, CHALLENGE_PERIOD); - assertEq(fbOwner, fallbackOwner); - assertEq(livenessModule2.challengeStartTime(address(safeInstance.safe)), 0); + LivenessModule2.ModuleConfig memory config = livenessModule2.livenessSafeConfiguration(safeInstance.safe); + assertEq(config.livenessResponsePeriod, CHALLENGE_PERIOD); + assertEq(config.fallbackOwner, fallbackOwner); + assertEq(livenessModule2.challengeStartTime(safeInstance.safe), 0); } function test_configureLivenessModule_multipleSafes_succeeds() external { @@ -146,17 +147,17 @@ contract LivenessModule2_ConfigureLivenessModule_Test is LivenessModule2_TestIni _enableModule(safe3, 3 days, fallback3); // Verify each safe has independent configuration - (uint256 period1, address fb1) = livenessModule2.livenessSafeConfiguration(address(safe1.safe)); - assertEq(period1, 1 days); - assertEq(fb1, fallback1); + LivenessModule2.ModuleConfig memory config1 = livenessModule2.livenessSafeConfiguration(safe1.safe); + assertEq(config1.livenessResponsePeriod, 1 days); + assertEq(config1.fallbackOwner, fallback1); - (uint256 period2, address fb2) = livenessModule2.livenessSafeConfiguration(address(safe2.safe)); - assertEq(period2, 2 days); - assertEq(fb2, fallback2); + LivenessModule2.ModuleConfig memory config2 = livenessModule2.livenessSafeConfiguration(safe2.safe); + assertEq(config2.livenessResponsePeriod, 2 days); + assertEq(config2.fallbackOwner, fallback2); - (uint256 period3, address fb3) = livenessModule2.livenessSafeConfiguration(address(safe3.safe)); - assertEq(period3, 3 days); - assertEq(fb3, fallback3); + LivenessModule2.ModuleConfig memory config3 = livenessModule2.livenessSafeConfiguration(safe3.safe); + assertEq(config3.livenessResponsePeriod, 3 days); + assertEq(config3.fallbackOwner, fallback3); } function test_configureLivenessModule_requiresSafeModuleInstallation_reverts() external { @@ -197,10 +198,10 @@ contract LivenessModule2_ConfigureLivenessModule_Test is LivenessModule2_TestIni // Start a challenge vm.prank(fallbackOwner); - livenessModule2.challenge(address(safeInstance.safe)); + livenessModule2.challenge(safeInstance.safe); // Verify challenge exists - uint256 challengeEndTime = livenessModule2.getChallengePeriodEnd(address(safeInstance.safe)); + uint256 challengeEndTime = livenessModule2.getChallengePeriodEnd(safeInstance.safe); assertGt(challengeEndTime, 0); // Reconfigure the module, which should cancel the challenge and emit ChallengeCancelled @@ -215,7 +216,7 @@ contract LivenessModule2_ConfigureLivenessModule_Test is LivenessModule2_TestIni ); // Verify challenge was cancelled - challengeEndTime = livenessModule2.getChallengePeriodEnd(address(safeInstance.safe)); + challengeEndTime = livenessModule2.getChallengePeriodEnd(safeInstance.safe); assertEq(challengeEndTime, 0); } @@ -243,9 +244,9 @@ contract LivenessModule2_ConfigureLivenessModule_Test is LivenessModule2_TestIni Enum.Operation.Call ); - (uint256 period, address fbOwner) = livenessModule2.livenessSafeConfiguration(address(safeInstance.safe)); - assertEq(period, 0); - assertEq(fbOwner, address(0)); + LivenessModule2.ModuleConfig memory clearedConfig = livenessModule2.livenessSafeConfiguration(safeInstance.safe); + assertEq(clearedConfig.livenessResponsePeriod, 0); + assertEq(clearedConfig.fallbackOwner, address(0)); } function test_clear_notEnabled_reverts() external { @@ -277,9 +278,9 @@ contract LivenessModule2_Challenge_Test is LivenessModule2_TestInit { emit ChallengeStarted(address(safeInstance.safe), block.timestamp); vm.prank(fallbackOwner); - livenessModule2.challenge(address(safeInstance.safe)); + livenessModule2.challenge(safeInstance.safe); - uint256 challengeEndTime = livenessModule2.getChallengePeriodEnd(address(safeInstance.safe)); + uint256 challengeEndTime = livenessModule2.getChallengePeriodEnd(safeInstance.safe); assertEq(challengeEndTime, block.timestamp + CHALLENGE_PERIOD); } @@ -288,7 +289,7 @@ contract LivenessModule2_Challenge_Test is LivenessModule2_TestInit { vm.expectRevert(LivenessModule2.LivenessModule2_UnauthorizedCaller.selector); vm.prank(notFallback); - livenessModule2.challenge(address(safeInstance.safe)); + livenessModule2.challenge(safeInstance.safe); } function test_challenge_moduleNotEnabled_reverts() external { @@ -296,16 +297,16 @@ contract LivenessModule2_Challenge_Test is LivenessModule2_TestInit { vm.expectRevert(LivenessModule2.LivenessModule2_ModuleNotConfigured.selector); vm.prank(fallbackOwner); - livenessModule2.challenge(newSafe); + livenessModule2.challenge(Safe(payable(newSafe))); } function test_challenge_alreadyExists_reverts() external { vm.prank(fallbackOwner); - livenessModule2.challenge(address(safeInstance.safe)); + livenessModule2.challenge(safeInstance.safe); vm.expectRevert(LivenessModule2.LivenessModule2_ChallengeAlreadyExists.selector); vm.prank(fallbackOwner); - livenessModule2.challenge(address(safeInstance.safe)); + livenessModule2.challenge(safeInstance.safe); } function test_challenge_moduleDisabledAtSafeLevel_reverts() external { @@ -331,13 +332,13 @@ contract LivenessModule2_Challenge_Test is LivenessModule2_TestInit { // Try to challenge - should revert because module is disabled at Safe level vm.expectRevert(LivenessModule2.LivenessModule2_ModuleNotEnabled.selector); vm.prank(fallbackOwner); - livenessModule2.challenge(address(disabledSafe.safe)); + livenessModule2.challenge(disabledSafe.safe); } function test_respond_succeeds() external { // Start a challenge vm.prank(fallbackOwner); - livenessModule2.challenge(address(safeInstance.safe)); + livenessModule2.challenge(safeInstance.safe); // Cancel it vm.expectEmit(true, true, true, true); @@ -346,7 +347,7 @@ contract LivenessModule2_Challenge_Test is LivenessModule2_TestInit { _respondToChallenge(safeInstance); // Verify challenge is cancelled - uint256 challengeEndTime = livenessModule2.getChallengePeriodEnd(address(safeInstance.safe)); + uint256 challengeEndTime = livenessModule2.getChallengePeriodEnd(safeInstance.safe); assertEq(challengeEndTime, 0); } @@ -376,7 +377,7 @@ contract LivenessModule2_Challenge_Test is LivenessModule2_TestInit { function test_respond_afterResponsePeriod_succeeds() external { // Start a challenge vm.prank(fallbackOwner); - livenessModule2.challenge(address(safeInstance.safe)); + livenessModule2.challenge(safeInstance.safe); // Warp past challenge period vm.warp(block.timestamp + CHALLENGE_PERIOD + 1); @@ -388,7 +389,7 @@ contract LivenessModule2_Challenge_Test is LivenessModule2_TestInit { livenessModule2.respond(); // Verify challenge was cancelled - assertEq(livenessModule2.challengeStartTime(address(safeInstance.safe)), 0); + assertEq(livenessModule2.challengeStartTime(safeInstance.safe), 0); } function test_respond_moduleNotConfigured_reverts() external { @@ -423,9 +424,10 @@ contract LivenessModule2_Challenge_Test is LivenessModule2_TestInit { ); // Verify the Safe still has configuration but module is not enabled - (uint256 period, address fbOwner) = livenessModule2.livenessSafeConfiguration(address(configuredSafe.safe)); - assertTrue(period > 0); // Configuration exists - assertTrue(fbOwner != address(0)); // Configuration exists + LivenessModule2.ModuleConfig memory configuredConfig = + livenessModule2.livenessSafeConfiguration(configuredSafe.safe); + assertTrue(configuredConfig.livenessResponsePeriod > 0); // Configuration exists + assertTrue(configuredConfig.fallbackOwner != address(0)); // Configuration exists assertFalse(configuredSafe.safe.isModuleEnabled(address(livenessModule2))); // Module not enabled // Now respond() should revert because module is not enabled @@ -435,37 +437,178 @@ contract LivenessModule2_Challenge_Test is LivenessModule2_TestInit { } } +/// @title LivenessModule2_ChangeOwnershipToFallback_Test +/// @notice Tests the ownership transfer after successful challenge +contract LivenessModule2_ChangeOwnershipToFallback_Test is LivenessModule2_TestInit { + function setUp() public override { + super.setUp(); + _enableModule(safeInstance, CHALLENGE_PERIOD, fallbackOwner); + } + + /// @notice Tests that ownership successfully transfers to fallback owner after challenge period expires + function testFuzz_changeOwnershipToFallback_succeeds(uint256 timeAfterExpiry) external { + // Bound time to reasonable values (1 second to 365 days after expiry) + timeAfterExpiry = bound(timeAfterExpiry, 1, 365 days); + + // Start a challenge + vm.prank(fallbackOwner); + livenessModule2.challenge(safeInstance.safe); + + // Warp past challenge period + vm.warp(block.timestamp + CHALLENGE_PERIOD + timeAfterExpiry); + + // Execute ownership transfer + vm.expectEmit(true, true, true, true); + emit ChallengeSucceeded(address(safeInstance.safe), fallbackOwner); + + vm.prank(fallbackOwner); + livenessModule2.changeOwnershipToFallback(safeInstance.safe); + + // Verify ownership changed + address[] memory newOwners = safeInstance.safe.getOwners(); + assertEq(newOwners.length, 1); + assertEq(newOwners[0], fallbackOwner); + assertEq(safeInstance.safe.getThreshold(), 1); + + // Verify challenge is reset + uint256 challengeEndTime = livenessModule2.getChallengePeriodEnd(safeInstance.safe); + assertEq(challengeEndTime, 0); + } + + /// @notice Tests that changeOwnershipToFallback reverts if module is not configured + function test_changeOwnershipToFallback_moduleNotEnabled_reverts() external { + address newSafe = makeAddr("newSafe"); + + vm.prank(fallbackOwner); + vm.expectRevert(LivenessModule2.LivenessModule2_ModuleNotConfigured.selector); + livenessModule2.changeOwnershipToFallback(Safe(payable(newSafe))); + } + + /// @notice Tests that changeOwnershipToFallback reverts if no challenge exists + function test_changeOwnershipToFallback_noChallenge_reverts() external { + vm.prank(fallbackOwner); + vm.expectRevert(LivenessModule2.LivenessModule2_ChallengeDoesNotExist.selector); + livenessModule2.changeOwnershipToFallback(safeInstance.safe); + } + + /// @notice Tests that changeOwnershipToFallback reverts if called before response period expires + function testFuzz_changeOwnershipToFallback_beforeResponsePeriod_reverts(uint256 timeElapsed) external { + // Bound time to be within response period (not yet expired) + timeElapsed = bound(timeElapsed, 0, CHALLENGE_PERIOD - 1); + + // Start a challenge + vm.prank(fallbackOwner); + livenessModule2.challenge(safeInstance.safe); + + // Warp to a time before response period expires + vm.warp(block.timestamp + timeElapsed); + + // Try to execute before response period expires + vm.prank(fallbackOwner); + vm.expectRevert(LivenessModule2.LivenessModule2_ResponsePeriodActive.selector); + livenessModule2.changeOwnershipToFallback(safeInstance.safe); + } + + /// @notice Tests that changeOwnershipToFallback reverts if module is disabled at Safe level + function test_changeOwnershipToFallback_moduleDisabledAtSafeLevel_reverts() external { + // Start a challenge + vm.prank(fallbackOwner); + livenessModule2.challenge(safeInstance.safe); + + // Warp past challenge period + vm.warp(block.timestamp + CHALLENGE_PERIOD + 1); + + // Disable the module at Safe level + SafeTestLib.execTransaction( + safeInstance, + address(safeInstance.safe), + 0, + abi.encodeCall(ModuleManager.disableModule, (address(0x1), address(livenessModule2))), + Enum.Operation.Call + ); + + // Try to execute ownership transfer - should revert because module is disabled at Safe level + vm.prank(fallbackOwner); + vm.expectRevert(LivenessModule2.LivenessModule2_ModuleNotEnabled.selector); + livenessModule2.changeOwnershipToFallback(safeInstance.safe); + } + + /// @notice Tests that only the fallback owner can execute changeOwnershipToFallback + function testFuzz_changeOwnershipToFallback_onlyFallbackOwner_succeeds(address _caller) external { + vm.assume(_caller != fallbackOwner); + + // Start a challenge + vm.prank(fallbackOwner); + livenessModule2.challenge(safeInstance.safe); + + // Warp past challenge period + vm.warp(block.timestamp + CHALLENGE_PERIOD + 1); + + // Try from non-fallback owner - should fail + vm.prank(_caller); + vm.expectRevert(LivenessModule2.LivenessModule2_UnauthorizedCaller.selector); + livenessModule2.changeOwnershipToFallback(safeInstance.safe); + + // Execute from fallback owner - should succeed + vm.prank(fallbackOwner); + livenessModule2.changeOwnershipToFallback(safeInstance.safe); + + // Verify ownership changed + address[] memory newOwners = safeInstance.safe.getOwners(); + assertEq(newOwners.length, 1); + assertEq(newOwners[0], fallbackOwner); + } + + /// @notice Tests that a new challenge can be started after ownership transfer completes + function test_changeOwnershipToFallback_canRechallenge_succeeds() external { + // Start and execute first challenge + vm.prank(fallbackOwner); + livenessModule2.challenge(safeInstance.safe); + + vm.warp(block.timestamp + CHALLENGE_PERIOD + 1); + vm.prank(fallbackOwner); + livenessModule2.changeOwnershipToFallback(safeInstance.safe); + + // Start a new challenge (as fallback owner) + vm.prank(fallbackOwner); + livenessModule2.challenge(safeInstance.safe); + + uint256 challengeEndTime = livenessModule2.getChallengePeriodEnd(safeInstance.safe); + assertGt(challengeEndTime, 0); + } +} + /// @title LivenessModule2_GetChallengePeriodEnd_Test /// @notice Tests the getChallengePeriodEnd function and related view functionality contract LivenessModule2_GetChallengePeriodEnd_Test is LivenessModule2_TestInit { function test_safeConfigs_succeeds() external { // Before enabling - (uint256 period1, address fbOwner1) = livenessModule2.livenessSafeConfiguration(address(safeInstance.safe)); - assertEq(period1, 0); - assertEq(fbOwner1, address(0)); - assertEq(livenessModule2.challengeStartTime(address(safeInstance.safe)), 0); + LivenessModule2.ModuleConfig memory configBefore = livenessModule2.livenessSafeConfiguration(safeInstance.safe); + assertEq(configBefore.livenessResponsePeriod, 0); + assertEq(configBefore.fallbackOwner, address(0)); + assertEq(livenessModule2.challengeStartTime(safeInstance.safe), 0); // After enabling _enableModule(safeInstance, CHALLENGE_PERIOD, fallbackOwner); - (uint256 period2, address fbOwner2) = livenessModule2.livenessSafeConfiguration(address(safeInstance.safe)); - assertEq(period2, CHALLENGE_PERIOD); - assertEq(fbOwner2, fallbackOwner); - assertEq(livenessModule2.challengeStartTime(address(safeInstance.safe)), 0); + LivenessModule2.ModuleConfig memory configAfter = livenessModule2.livenessSafeConfiguration(safeInstance.safe); + assertEq(configAfter.livenessResponsePeriod, CHALLENGE_PERIOD); + assertEq(configAfter.fallbackOwner, fallbackOwner); + assertEq(livenessModule2.challengeStartTime(safeInstance.safe), 0); } function test_getChallengePeriodEnd_succeeds() external { _enableModule(safeInstance, CHALLENGE_PERIOD, fallbackOwner); // No challenge - assertEq(livenessModule2.getChallengePeriodEnd(address(safeInstance.safe)), 0); + assertEq(livenessModule2.getChallengePeriodEnd(safeInstance.safe), 0); // With challenge vm.prank(fallbackOwner); - livenessModule2.challenge(address(safeInstance.safe)); - assertEq(livenessModule2.getChallengePeriodEnd(address(safeInstance.safe)), block.timestamp + CHALLENGE_PERIOD); + livenessModule2.challenge(safeInstance.safe); + assertEq(livenessModule2.getChallengePeriodEnd(safeInstance.safe), block.timestamp + CHALLENGE_PERIOD); // After cancellation _respondToChallenge(safeInstance); - assertEq(livenessModule2.getChallengePeriodEnd(address(safeInstance.safe)), 0); + assertEq(livenessModule2.getChallengePeriodEnd(safeInstance.safe), 0); } } diff --git a/packages/contracts-bedrock/test/safe/SaferSafes.t.sol b/packages/contracts-bedrock/test/safe/SaferSafes.t.sol index 5caa088827b..49c10f91212 100644 --- a/packages/contracts-bedrock/test/safe/SaferSafes.t.sol +++ b/packages/contracts-bedrock/test/safe/SaferSafes.t.sol @@ -7,9 +7,9 @@ import "test/safe-tools/SafeTestTools.sol"; import { SaferSafes } from "src/safe/SaferSafes.sol"; import { LivenessModule2 } from "src/safe/LivenessModule2.sol"; -import { GuardManager } from "safe-contracts/base/GuardManager.sol"; +import { GuardManager, Guard as IGuard } from "safe-contracts/base/GuardManager.sol"; import { ModuleManager } from "safe-contracts/base/ModuleManager.sol"; -import { Guard as IGuard } from "safe-contracts/base/GuardManager.sol"; +import { GnosisSafe as Safe } from "safe-contracts/GnosisSafe.sol"; // Import the test utils from LivenessModule2 tests import { LivenessModule2_TestUtils } from "test/safe/LivenessModule2.t.sol"; @@ -85,11 +85,10 @@ contract SaferSafes_Uncategorized_Test is SaferSafes_TestInit { saferSafes.configureTimelockGuard(timelockDelay); // Verify configurations were set - (uint256 storedLivenessResponsePeriod, address storedFallbackOwner) = - saferSafes.livenessSafeConfiguration(address(safeInstance.safe)); - assertEq(storedLivenessResponsePeriod, livenessResponsePeriod); - assertEq(storedFallbackOwner, fallbackOwner); - assertEq(saferSafes.timelockConfiguration(safeInstance.safe), timelockDelay); + LivenessModule2.ModuleConfig memory storedConfig = saferSafes.livenessSafeConfiguration(safeInstance.safe); + assertEq(storedConfig.livenessResponsePeriod, livenessResponsePeriod); + assertEq(storedConfig.fallbackOwner, fallbackOwner); + assertEq(saferSafes.timelockDelay(safeInstance.safe), timelockDelay); } function test_configure_timelockGuardFirst_succeeds() public { @@ -110,11 +109,10 @@ contract SaferSafes_Uncategorized_Test is SaferSafes_TestInit { saferSafes.configureLivenessModule(moduleConfig); // Verify configurations were set - (uint256 storedLivenessResponsePeriod, address storedFallbackOwner) = - saferSafes.livenessSafeConfiguration(address(safeInstance.safe)); - assertEq(storedLivenessResponsePeriod, livenessResponsePeriod); - assertEq(storedFallbackOwner, fallbackOwner); - assertEq(saferSafes.timelockConfiguration(safeInstance.safe), timelockDelay); + LivenessModule2.ModuleConfig memory storedConfig = saferSafes.livenessSafeConfiguration(safeInstance.safe); + assertEq(storedConfig.livenessResponsePeriod, livenessResponsePeriod); + assertEq(storedConfig.fallbackOwner, fallbackOwner); + assertEq(saferSafes.timelockDelay(safeInstance.safe), timelockDelay); } /// @notice Test that attempting to incorrectly configure the timelock guard after first configuring the liveness @@ -185,7 +183,7 @@ contract SaferSafes_ChangeOwnershipToFallback_Test is SaferSafes_TestInit { assertEq(safeInstance.safe.getThreshold(), 1); // Verify challenge is reset - uint256 challengeEndTime = livenessModule2.getChallengePeriodEnd(address(safeInstance.safe)); + uint256 challengeEndTime = livenessModule2.getChallengePeriodEnd(safeInstance.safe); assertEq(challengeEndTime, 0); // Verify guard is deactivated @@ -195,7 +193,7 @@ contract SaferSafes_ChangeOwnershipToFallback_Test is SaferSafes_TestInit { function test_changeOwnershipToFallback_succeeds() external { // Start a challenge vm.prank(fallbackOwner); - livenessModule2.challenge(address(safeInstance.safe)); + livenessModule2.challenge(safeInstance.safe); // Warp past challenge period vm.warp(block.timestamp + CHALLENGE_PERIOD + 1); @@ -205,7 +203,7 @@ contract SaferSafes_ChangeOwnershipToFallback_Test is SaferSafes_TestInit { emit ChallengeSucceeded(address(safeInstance.safe), fallbackOwner); vm.prank(fallbackOwner); - livenessModule2.changeOwnershipToFallback(address(safeInstance.safe)); + livenessModule2.changeOwnershipToFallback(safeInstance.safe); _assertOwnershipChanged(); } @@ -235,7 +233,7 @@ contract SaferSafes_ChangeOwnershipToFallback_Test is SaferSafes_TestInit { // Start a challenge vm.prank(fallbackOwner); - livenessModule2.challenge(address(safeInstance.safe)); + livenessModule2.challenge(safeInstance.safe); // Warp past challenge period vm.warp(block.timestamp + CHALLENGE_PERIOD + 1); @@ -245,7 +243,7 @@ contract SaferSafes_ChangeOwnershipToFallback_Test is SaferSafes_TestInit { emit ChallengeSucceeded(address(safeInstance.safe), fallbackOwner); vm.prank(fallbackOwner); - livenessModule2.changeOwnershipToFallback(address(safeInstance.safe)); + livenessModule2.changeOwnershipToFallback(safeInstance.safe); // These checks include ensuring that the guard is deactivated _assertOwnershipChanged(); @@ -256,30 +254,30 @@ contract SaferSafes_ChangeOwnershipToFallback_Test is SaferSafes_TestInit { vm.prank(fallbackOwner); vm.expectRevert(LivenessModule2.LivenessModule2_ModuleNotConfigured.selector); - livenessModule2.changeOwnershipToFallback(newSafe); + livenessModule2.changeOwnershipToFallback(Safe(payable(newSafe))); } function test_changeOwnershipToFallback_noChallenge_reverts() external { vm.prank(fallbackOwner); vm.expectRevert(LivenessModule2.LivenessModule2_ChallengeDoesNotExist.selector); - livenessModule2.changeOwnershipToFallback(address(safeInstance.safe)); + livenessModule2.changeOwnershipToFallback(safeInstance.safe); } function test_changeOwnershipToFallback_beforeResponsePeriod_reverts() external { // Start a challenge vm.prank(fallbackOwner); - livenessModule2.challenge(address(safeInstance.safe)); + livenessModule2.challenge(safeInstance.safe); // Try to execute before response period expires vm.prank(fallbackOwner); vm.expectRevert(LivenessModule2.LivenessModule2_ResponsePeriodActive.selector); - livenessModule2.changeOwnershipToFallback(address(safeInstance.safe)); + livenessModule2.changeOwnershipToFallback(safeInstance.safe); } function test_changeOwnershipToFallback_moduleDisabledAtSafeLevel_reverts() external { // Start a challenge vm.prank(fallbackOwner); - livenessModule2.challenge(address(safeInstance.safe)); + livenessModule2.challenge(safeInstance.safe); // Warp past challenge period vm.warp(block.timestamp + CHALLENGE_PERIOD + 1); @@ -296,14 +294,14 @@ contract SaferSafes_ChangeOwnershipToFallback_Test is SaferSafes_TestInit { // Try to execute ownership transfer - should revert because module is disabled at Safe level vm.prank(fallbackOwner); vm.expectRevert(LivenessModule2.LivenessModule2_ModuleNotEnabled.selector); - livenessModule2.changeOwnershipToFallback(address(safeInstance.safe)); + livenessModule2.changeOwnershipToFallback(safeInstance.safe); } function test_changeOwnershipToFallback_onlyFallbackOwner_succeeds() external { _enableModule(safeInstance, CHALLENGE_PERIOD, fallbackOwner); // Start a challenge vm.prank(fallbackOwner); - livenessModule2.challenge(address(safeInstance.safe)); + livenessModule2.challenge(safeInstance.safe); // Warp past challenge period vm.warp(block.timestamp + CHALLENGE_PERIOD + 1); @@ -312,11 +310,11 @@ contract SaferSafes_ChangeOwnershipToFallback_Test is SaferSafes_TestInit { address randomCaller = makeAddr("randomCaller"); vm.prank(randomCaller); vm.expectRevert(LivenessModule2.LivenessModule2_UnauthorizedCaller.selector); - livenessModule2.changeOwnershipToFallback(address(safeInstance.safe)); + livenessModule2.changeOwnershipToFallback(safeInstance.safe); // Execute from fallback owner - should succeed vm.prank(fallbackOwner); - livenessModule2.changeOwnershipToFallback(address(safeInstance.safe)); + livenessModule2.changeOwnershipToFallback(safeInstance.safe); // Verify ownership changed address[] memory newOwners = safeInstance.safe.getOwners(); @@ -328,11 +326,11 @@ contract SaferSafes_ChangeOwnershipToFallback_Test is SaferSafes_TestInit { _enableModule(safeInstance, CHALLENGE_PERIOD, fallbackOwner); // Start and execute first challenge vm.prank(fallbackOwner); - livenessModule2.challenge(address(safeInstance.safe)); + livenessModule2.challenge(safeInstance.safe); vm.warp(block.timestamp + CHALLENGE_PERIOD + 1); vm.prank(fallbackOwner); - livenessModule2.changeOwnershipToFallback(address(safeInstance.safe)); + livenessModule2.changeOwnershipToFallback(safeInstance.safe); // Re-configure the module vm.prank(address(safeInstance.safe)); @@ -342,9 +340,9 @@ contract SaferSafes_ChangeOwnershipToFallback_Test is SaferSafes_TestInit { // Start a new challenge (as fallback owner) vm.prank(fallbackOwner); - livenessModule2.challenge(address(safeInstance.safe)); + livenessModule2.challenge(safeInstance.safe); - uint256 challengeEndTime = livenessModule2.getChallengePeriodEnd(address(safeInstance.safe)); + uint256 challengeEndTime = livenessModule2.getChallengePeriodEnd(safeInstance.safe); assertGt(challengeEndTime, 0); } } diff --git a/packages/contracts-bedrock/test/safe/TimelockGuard.t.sol b/packages/contracts-bedrock/test/safe/TimelockGuard.t.sol index 1878182254f..1cd1331ccc5 100644 --- a/packages/contracts-bedrock/test/safe/TimelockGuard.t.sol +++ b/packages/contracts-bedrock/test/safe/TimelockGuard.t.sol @@ -83,7 +83,8 @@ library TransactionBuilder { } /// @notice Executes the transaction via the underlying Safe contract. - function executeTransaction(Transaction memory _tx) internal { + function executeTransaction(Transaction memory _tx, address _owner) internal { + Vm(VM_ADDR).prank(_owner); _tx.safeInstance.safe.execTransaction( _tx.params.to, _tx.params.value, @@ -228,9 +229,11 @@ abstract contract TimelockGuard_TestInit is Test, SafeTestTools { /// @notice Helper to configure the TimelockGuard for a Safe function _configureGuard(SafeInstance memory _safe, uint256 _delay) internal { + vm.startPrank(_safe.owners[0]); SafeTestLib.execTransaction( _safe, address(timelockGuard), 0, abi.encodeCall(TimelockGuard.configureTimelockGuard, (_delay)) ); + vm.stopPrank(); } /// @notice Helper to enable guard on a Safe @@ -253,16 +256,16 @@ abstract contract TimelockGuard_TestInit is Test, SafeTestTools { vm.warp(block.timestamp + TIMELOCK_DELAY + 1); // Execute the disable guard transaction - disableGuardTx.executeTransaction(); + disableGuardTx.executeTransaction(_safe.owners[0]); } } -/// @title TimelockGuard_TimelockConfiguration_Test +/// @title TimelockGuard_TimelockDelay_Test /// @notice Tests for timelockConfiguration function -contract TimelockGuard_TimelockConfiguration_Test is TimelockGuard_TestInit { +contract TimelockGuard_TimelockDelay_Test is TimelockGuard_TestInit { /// @notice Ensures an unconfigured Safe reports a zero timelock delay. function test_timelockConfiguration_returnsZeroForUnconfiguredSafe_succeeds() external view { - uint256 delay = timelockGuard.timelockConfiguration(safeInstance.safe); + uint256 delay = timelockGuard.timelockDelay(safeInstance.safe); assertEq(delay, 0); // configured is now determined by timelockDelay == 0 assertEq(delay == 0, true); @@ -271,7 +274,7 @@ contract TimelockGuard_TimelockConfiguration_Test is TimelockGuard_TestInit { /// @notice Validates the configuration view reflects the stored timelock delay. function test_timelockConfiguration_returnsConfigurationForConfiguredSafe_succeeds() external { _configureGuard(safeInstance, TIMELOCK_DELAY); - uint256 delay = timelockGuard.timelockConfiguration(safeInstance.safe); + uint256 delay = timelockGuard.timelockDelay(safeInstance.safe); assertEq(delay, TIMELOCK_DELAY); // configured is now determined by timelockDelay != 0 assertEq(delay != 0, true); @@ -288,7 +291,7 @@ contract TimelockGuard_ConfigureTimelockGuard_Test is TimelockGuard_TestInit { _configureGuard(safeInstance, TIMELOCK_DELAY); - uint256 delay = timelockGuard.timelockConfiguration(safe); + uint256 delay = timelockGuard.timelockDelay(safe); assertEq(delay, TIMELOCK_DELAY); // configured is now determined by timelockDelay != 0 assertEq(delay != 0, true); @@ -319,7 +322,7 @@ contract TimelockGuard_ConfigureTimelockGuard_Test is TimelockGuard_TestInit { _configureGuard(safeInstance, ONE_YEAR); - uint256 delay = timelockGuard.timelockConfiguration(safe); + uint256 delay = timelockGuard.timelockDelay(safe); assertEq(delay, ONE_YEAR); // configured is now determined by timelockDelay != 0 assertEq(delay != 0, true); @@ -329,7 +332,7 @@ contract TimelockGuard_ConfigureTimelockGuard_Test is TimelockGuard_TestInit { function test_configureTimelockGuard_allowsReconfiguration_succeeds() external { // Initial configuration _configureGuard(safeInstance, TIMELOCK_DELAY); - assertEq(timelockGuard.timelockConfiguration(safe), TIMELOCK_DELAY); + assertEq(timelockGuard.timelockDelay(safe), TIMELOCK_DELAY); uint256 newDelay = TIMELOCK_DELAY + 1; @@ -347,14 +350,14 @@ contract TimelockGuard_ConfigureTimelockGuard_Test is TimelockGuard_TestInit { emit GuardConfigured(safe, newDelay); _configureGuard(safeInstance, newDelay); - assertEq(timelockGuard.timelockConfiguration(safe), newDelay); + assertEq(timelockGuard.timelockDelay(safe), newDelay); } /// @notice Ensures setting delay to zero clears the configuration. function test_configureTimelockGuard_clearConfiguration_succeeds() external { // First configure the guard _configureGuard(safeInstance, TIMELOCK_DELAY); - assertEq(timelockGuard.timelockConfiguration(safe), TIMELOCK_DELAY); + assertEq(timelockGuard.timelockDelay(safe), TIMELOCK_DELAY); // Configure timelock delay to 0 should succeed and emit event vm.expectEmit(true, true, true, true); @@ -363,7 +366,7 @@ contract TimelockGuard_ConfigureTimelockGuard_Test is TimelockGuard_TestInit { timelockGuard.configureTimelockGuard(0); // Timelock delay should be set to 0 - assertEq(timelockGuard.timelockConfiguration(safe), 0); + assertEq(timelockGuard.timelockDelay(safe), 0); } /// @notice Checks clearing succeeds even if the guard was never configured. @@ -379,12 +382,6 @@ contract TimelockGuard_ConfigureTimelockGuard_Test is TimelockGuard_TestInit { /// @title TimelockGuard_CancellationThreshold_Test /// @notice Tests for cancellationThreshold function contract TimelockGuard_CancellationThreshold_Test is TimelockGuard_TestInit { - /// @notice Validates cancellation threshold is zero when the guard is disabled. - function test_cancellationThreshold_returnsZeroIfGuardNotEnabled_succeeds() external view { - uint256 threshold = timelockGuard.cancellationThreshold(Safe(payable(unguardedSafe.safe))); - assertEq(threshold, 0); - } - /// @notice Ensures an enabled but unconfigured guard yields a zero threshold. function test_cancellationThreshold_returnsZeroIfGuardNotConfigured_succeeds() external view { // Safe with guard enabled but not configured should return 0 @@ -430,7 +427,7 @@ contract TimelockGuard_ScheduleTransaction_Test is TimelockGuard_TestInit { function test_scheduleTransaction_guardNotConfigured_reverts() external { // Enable the guard on the unguarded Safe, but don't configure it _enableGuard(unguardedSafe); - assertEq(timelockGuard.timelockConfiguration(unguardedSafe.safe), 0); + assertEq(timelockGuard.timelockDelay(unguardedSafe.safe), 0); TransactionBuilder.Transaction memory dummyTx = _createDummyTransaction(unguardedSafe); vm.expectRevert(TimelockGuard.TimelockGuard_GuardNotConfigured.selector); @@ -539,7 +536,7 @@ contract TimelockGuard_PendingTransactions_Test is TimelockGuard_TestInit { vm.warp(block.timestamp + TIMELOCK_DELAY); // execute the transaction - dummyTx.executeTransaction(); + dummyTx.executeTransaction(safeInstance.owners[0]); // get the pending transactions TimelockGuard.ScheduledTransaction[] memory pendingTransactions = timelockGuard.pendingTransactions(safe); @@ -665,7 +662,7 @@ contract TimelockGuard_CheckTransaction_Test is TimelockGuard_TestInit { dummyTx.params.gasToken, dummyTx.params.refundReceiver, "", - address(0) + safeInstance.owners[0] ); } @@ -698,7 +695,7 @@ contract TimelockGuard_CheckTransaction_Test is TimelockGuard_TestInit { dummyTx.params.gasToken, dummyTx.params.refundReceiver, "", - address(0) + safeInstance.owners[0] ); } @@ -721,9 +718,19 @@ contract TimelockGuard_CheckTransaction_Test is TimelockGuard_TestInit { dummyTx.params.gasToken, dummyTx.params.refundReceiver, "", - address(0) + safeInstance.owners[0] ); } + + /// @notice Test that checkTransaction reverts when the caller is not an owner + function testFuzz_checkTransaction_notOwner_reverts(address nonOwner) external { + vm.assume(!safeInstance.safe.isOwner(nonOwner)); + TransactionBuilder.Transaction memory dummyTx = _createDummyTransaction(safeInstance); + dummyTx.scheduleTransaction(timelockGuard); + + vm.expectRevert(TimelockGuard.TimelockGuard_NotOwner.selector); + dummyTx.executeTransaction(nonOwner); + } } /// @title TimelockGuard_MaxCancellationThreshold_Test @@ -808,7 +815,7 @@ contract TimelockGuard_Integration_Test is TimelockGuard_TestInit { vm.expectEmit(true, true, true, true); emit TransactionExecuted(safeInstance.safe, dummyTx.hash); - dummyTx.executeTransaction(); + dummyTx.executeTransaction(safeInstance.owners[0]); // Confirm that the transaction is executed TimelockGuard.ScheduledTransaction memory scheduledTransaction = @@ -825,10 +832,10 @@ contract TimelockGuard_Integration_Test is TimelockGuard_TestInit { dummyTx.scheduleTransaction(timelockGuard); vm.warp(block.timestamp + TIMELOCK_DELAY); - dummyTx.executeTransaction(); + dummyTx.executeTransaction(safeInstance.owners[0]); vm.expectRevert("GS026"); - dummyTx.executeTransaction(); + dummyTx.executeTransaction(safeInstance.owners[0]); } function test_integration_scheduleThenExecuteThenCancel_reverts() external { @@ -836,7 +843,7 @@ contract TimelockGuard_Integration_Test is TimelockGuard_TestInit { dummyTx.scheduleTransaction(timelockGuard); vm.warp(block.timestamp + TIMELOCK_DELAY); - dummyTx.executeTransaction(); + dummyTx.executeTransaction(safeInstance.owners[0]); TransactionBuilder.Transaction memory cancellationTx = dummyTx.makeCancellationTransaction(timelockGuard); vm.expectRevert(TimelockGuard.TimelockGuard_TransactionAlreadyExecuted.selector); @@ -864,7 +871,7 @@ contract TimelockGuard_Integration_Test is TimelockGuard_TestInit { resetGuardTx.scheduleTransaction(timelockGuard); vm.warp(block.timestamp + TIMELOCK_DELAY); - resetGuardTx.executeTransaction(); + resetGuardTx.executeTransaction(safeInstance.owners[0]); TransactionBuilder.Transaction memory disableGuardTx = _createEmptyTransaction(safeInstance); disableGuardTx.params.to = address(safeInstance.safe); @@ -872,7 +879,7 @@ contract TimelockGuard_Integration_Test is TimelockGuard_TestInit { disableGuardTx.updateTransaction(); vm.warp(block.timestamp + TIMELOCK_DELAY); - disableGuardTx.executeTransaction(); + disableGuardTx.executeTransaction(safeInstance.owners[0]); } /// @notice Test that the max cancellation threshold is not exceeded @@ -922,7 +929,7 @@ contract TimelockGuard_ClearTimelockGuard_Test is TimelockGuard_TestInit { ); // Verify configuration is cleared - assertEq(timelockGuard.timelockConfiguration(safe), 0); + assertEq(timelockGuard.timelockDelay(safe), 0); assertEq(timelockGuard.cancellationThreshold(safe), 0); // Verify pending transaction was cancelled @@ -959,7 +966,7 @@ contract TimelockGuard_ClearTimelockGuard_Test is TimelockGuard_TestInit { assertEq(timelockGuard.pendingTransactions(Safe(payable(address(safeInstance.safe)))).length, 50); // Verify configuration is cleared - assertEq(timelockGuard.timelockConfiguration(safe), 0); + assertEq(timelockGuard.timelockDelay(safe), 0); assertEq(timelockGuard.cancellationThreshold(safe), 0); } diff --git a/packages/contracts-bedrock/test/scripts/DeployOwnership.t.sol b/packages/contracts-bedrock/test/scripts/DeployOwnership.t.sol index 42ef9288d8e..56ed0f177ba 100644 --- a/packages/contracts-bedrock/test/scripts/DeployOwnership.t.sol +++ b/packages/contracts-bedrock/test/scripts/DeployOwnership.t.sol @@ -67,12 +67,12 @@ contract DeployOwnershipTest is Test, DeployOwnership { // LivenessModule2 checks LivenessModuleConfig memory lmConfig = exampleSecurityCouncilConfig.livenessModuleConfig; - (uint256 configuredPeriod, address configuredFallback) = - LivenessModule2(livenessModule).livenessSafeConfiguration(address(securityCouncilSafe)); - assertEq(configuredPeriod, lmConfig.livenessInterval); - assertEq(configuredFallback, lmConfig.fallbackOwner); + LivenessModule2.ModuleConfig memory moduleConfig = + LivenessModule2(livenessModule).livenessSafeConfiguration(Safe(payable(securityCouncilSafe))); + assertEq(moduleConfig.livenessResponsePeriod, lmConfig.livenessInterval); + assertEq(moduleConfig.fallbackOwner, lmConfig.fallbackOwner); // Verify no active challenge exists initially - assertEq(LivenessModule2(livenessModule).getChallengePeriodEnd(address(securityCouncilSafe)), 0); + assertEq(LivenessModule2(livenessModule).getChallengePeriodEnd(Safe(payable(securityCouncilSafe))), 0); } } From dc43a3198c34f3fa9a0d6bfeb1e7edd19a841098 Mon Sep 17 00:00:00 2001 From: Josh Klopfenstein Date: Tue, 21 Oct 2025 09:23:46 -0700 Subject: [PATCH 101/117] op-service: improve beacon client robustness (#17866) * op-service: always fall back to fetching blob sidecars Previously, we only reverted to fetching sidecars when an error was received from the beacon server. In an attempt to be more robust, we also fetch sidecars when the beacon server gives us a semantically invalid response. * op-service: rearrange blobs based on provided hashes The behavior in the post-Fulu /blobs/ happy path and the /blob_sidecars/ fallback slightly differed: in the former case, returned blobs were ordered based their index in the blob, while in the latter case they were ordered based on the provided hashes. This bug was not caught in testing because all calls to BeaconBlobs provide a slice of hashes sorted by index. --- op-service/sources/l1_beacon_client.go | 58 ++++++++++++----- op-service/sources/l1_beacon_client_test.go | 72 +++++++++++++++++++++ 2 files changed, 113 insertions(+), 17 deletions(-) diff --git a/op-service/sources/l1_beacon_client.go b/op-service/sources/l1_beacon_client.go index fa4bb1c8f29..c791adb4d9e 100644 --- a/op-service/sources/l1_beacon_client.go +++ b/op-service/sources/l1_beacon_client.go @@ -9,6 +9,7 @@ import ( "net/http" "net/url" "path" + "slices" "strconv" "sync" @@ -303,30 +304,53 @@ func (cl *L1BeaconClient) GetBlobs(ctx context.Context, ref eth.L1BlockRef, hash if err != nil { return nil, err } + blobs, errBeaconBlobs := cl.beaconBlobs(ctx, slot, hashes) + if errBeaconBlobs == nil { + return blobs, nil + } + // If fetching from the post-Fulu /blobs/ endpoint fails, fall back to /blob_sidecars/. + errBeaconBlobs = fmt.Errorf("failed to get blobs: %w", errBeaconBlobs) + blobSidecars, err := cl.getBlobSidecars(ctx, slot, hashes) + if err != nil { + return nil, fmt.Errorf("%w; failed to get blob sidecars for L1BlockRef %s after falling back: %w", errBeaconBlobs, ref, err) + } + blobs, err = blobsFromSidecars(blobSidecars, hashes) + if err != nil { + return nil, fmt.Errorf("%w; failed to get blobs from sidecars for L1BlockRef %s after falling back: %w", errBeaconBlobs, ref, err) + } + return blobs, nil +} + +func (cl *L1BeaconClient) beaconBlobs(ctx context.Context, slot uint64, hashes []eth.IndexedBlobHash) ([]*eth.Blob, error) { resp, err := cl.cl.BeaconBlobs(ctx, slot, hashes) if err != nil { - // We would normally check for an explicit error like "method not found", but the Beacon - // API doesn't standardize such a response. Thus, we interpret all errors as - // "method not found" and fall back to fetching sidecars. - blobSidecars, err := cl.getBlobSidecars(ctx, slot, hashes) - if err != nil { - return nil, fmt.Errorf("failed to get blob sidecars for L1BlockRef %s: %w", ref, err) - } - blobs, err := blobsFromSidecars(blobSidecars, hashes) - if err != nil { - return nil, fmt.Errorf("failed to get blobs from sidecars for L1BlockRef %s: %w", ref, err) - } - return blobs, nil + return nil, fmt.Errorf("get blobs from beacon client: %w", err) } if len(resp.Data) != len(hashes) { return nil, fmt.Errorf("expected %d blobs but got %d", len(hashes), len(resp.Data)) } - var blobs []*eth.Blob - for i, blob := range resp.Data { - if err := verifyBlob(blob, hashes[i].Hash); err != nil { - return nil, fmt.Errorf("blob %d failed verification: %w", i, err) + // This function guarantees that the returned blobs will be ordered according to the provided + // hashes. The BeaconBlobs call above has a different ordering. From the getBlobs spec: + // The returned blobs are ordered based on their kzg commitments in the block. + // https://ethereum.github.io/beacon-APIs/beacon-node-oapi.yaml + // + // This loop + // 1. verifies the integrity of each blob, and + // 2. rearranges the blobs to match the order of the provided hashes. + blobs := make([]*eth.Blob, len(hashes)) + for _, blob := range resp.Data { + commitment, err := blob.ComputeKZGCommitment() + if err != nil { + return nil, fmt.Errorf("compute blob kzg commitment: %w", err) + } + got := eth.KZGToVersionedHash(commitment) + idx := slices.IndexFunc(hashes, func(indexedHash eth.IndexedBlobHash) bool { + return got == indexedHash.Hash + }) + if idx == -1 { + return nil, fmt.Errorf("received a blob hash that does not match any expected hash: %s", got) } - blobs = append(blobs, blob) + blobs[idx] = blob } return blobs, nil } diff --git a/op-service/sources/l1_beacon_client_test.go b/op-service/sources/l1_beacon_client_test.go index 009b3d82f78..63b753805bd 100644 --- a/op-service/sources/l1_beacon_client_test.go +++ b/op-service/sources/l1_beacon_client_test.go @@ -321,3 +321,75 @@ func TestVerifyBlob(t *testing.T) { differentBlob[0] = byte(8) require.Error(t, verifyBlob(&differentBlob, versionedHash)) } + +func TestGetBlobs(t *testing.T) { + hash0, sidecar0 := makeTestBlobSidecar(0) + hash1, sidecar1 := makeTestBlobSidecar(1) + hash2, sidecar2 := makeTestBlobSidecar(2) + + hashes := []eth.IndexedBlobHash{hash0, hash2, hash1} // Mix up the order. + + invalidBlob0 := sidecar0.Blob + invalidBlob0[10]++ + + cases := []struct { + name string + beaconBlobs []*eth.Blob + expectFallback bool + }{ + { + name: "happy path", + // From the /blobs/ spec: + // Blobs are returned as an ordered list matching the order of their corresponding + // KZG commitments in the block. + beaconBlobs: []*eth.Blob{&sidecar0.Blob, &sidecar1.Blob, &sidecar2.Blob}, + expectFallback: false, + }, + { + name: "fallback on client error", + beaconBlobs: nil, + expectFallback: true, + }, + { + name: "fallback on invalid number of blobs", + beaconBlobs: []*eth.Blob{&sidecar0.Blob}, + expectFallback: true, + }, + { + name: "fallback on invalid blob", + beaconBlobs: []*eth.Blob{&invalidBlob0, &sidecar1.Blob, &sidecar2.Blob}, + expectFallback: true, + }, + } + + for _, c := range cases { + t.Run(c.name, func(t *testing.T) { + ctx := context.Background() + p := mocks.NewBeaconClient(t) + p.EXPECT().BeaconGenesis(ctx).Return(eth.APIGenesisResponse{Data: eth.ReducedGenesisData{GenesisTime: 10}}, nil) + p.EXPECT().ConfigSpec(ctx).Return(eth.APIConfigResponse{Data: eth.ReducedConfigData{SecondsPerSlot: 2}}, nil) + client := NewL1BeaconClient(p, L1BeaconClientConfig{}) + ref := eth.L1BlockRef{Time: 12} + + // construct the mock response for the beacon blobs call + var beaconBlobsResponse eth.APIBeaconBlobsResponse + var err error + if c.beaconBlobs == nil { + err = errors.New("client error") + } else { + beaconBlobsResponse = eth.APIBeaconBlobsResponse{Data: c.beaconBlobs} + } + p.EXPECT().BeaconBlobs(ctx, uint64(1), hashes).Return(beaconBlobsResponse, err) + + if c.expectFallback { + p.EXPECT().BeaconBlobSideCars(ctx, false, uint64(1), hashes).Return(eth.APIGetBlobSidecarsResponse{ + Data: toAPISideCars([]*eth.BlobSidecar{sidecar0, sidecar1, sidecar2}), + }, nil) + } + + resp, err := client.GetBlobs(ctx, ref, hashes) + require.NoError(t, err) + require.Equal(t, []*eth.Blob{&sidecar0.Blob, &sidecar2.Blob, &sidecar1.Blob}, resp) + }) + } +} From 773798a67678ab28c3ef7ee3405f25c04616af19 Mon Sep 17 00:00:00 2001 From: George Knee Date: Tue, 21 Oct 2025 18:19:08 +0100 Subject: [PATCH 102/117] GasPriceOracle: remove saturating math from getOperatorFee (jovian) (#17913) * GasPriceOracle: remove saturating math fro getOperatorFee (isthmus and jovian) Extend test coverage to edge cases * restore Isthmys formula * fix test * use library * lint * semver bump * modify semver and regenerate lock file --- .../snapshots/semver-lock.json | 4 +- .../src/L2/GasPriceOracle.sol | 6 +- .../test/L2/GasPriceOracle.t.sol | 85 +++++++++++++++++-- 3 files changed, 84 insertions(+), 11 deletions(-) diff --git a/packages/contracts-bedrock/snapshots/semver-lock.json b/packages/contracts-bedrock/snapshots/semver-lock.json index 04fddbbce64..85948cab52f 100644 --- a/packages/contracts-bedrock/snapshots/semver-lock.json +++ b/packages/contracts-bedrock/snapshots/semver-lock.json @@ -60,8 +60,8 @@ "sourceCodeHash": "0x6d137fef431d75a8bf818444915fc39c8b1d93434a9af9971d96fb3170bc72b7" }, "src/L2/GasPriceOracle.sol:GasPriceOracle": { - "initCodeHash": "0xedc721584d43025c515186d4d5879d2b8e4abaf3a69181b99b6bf90c684df442", - "sourceCodeHash": "0x0074761fc0f893a2418b4e1197c7f29ee59f407df31b99c420bf2fd82d14d583" + "initCodeHash": "0xf72c23d9c3775afd7b645fde429d09800622d329116feb5ff9829634655123ca", + "sourceCodeHash": "0xb4d1bf3669ba87bbeaf4373145c7e1490478c4a05ba4838a524aa6f0ce7348a6" }, "src/L2/L1Block.sol:L1Block": { "initCodeHash": "0x1f054ff228ecad7f51772dd25084469192f7a33c522b87cd46ec5558d3c46aec", diff --git a/packages/contracts-bedrock/src/L2/GasPriceOracle.sol b/packages/contracts-bedrock/src/L2/GasPriceOracle.sol index 75814f65cd9..ab6cdcf80c4 100644 --- a/packages/contracts-bedrock/src/L2/GasPriceOracle.sol +++ b/packages/contracts-bedrock/src/L2/GasPriceOracle.sol @@ -30,8 +30,8 @@ contract GasPriceOracle is ISemver { uint256 public constant DECIMALS = 6; /// @notice Semantic version. - /// @custom:semver 1.5.0 - string public constant version = "1.5.0"; + /// @custom:semver 1.6.0 + string public constant version = "1.6.0"; /// @notice This is the intercept value for the linear regression used to estimate the final size of the /// compressed transaction. @@ -224,7 +224,7 @@ contract GasPriceOracle is ISemver { uint256 operatorConstant = IL1Block(Predeploys.L1_BLOCK_ATTRIBUTES).operatorFeeConstant(); if (isJovian) { - return Arithmetic.saturatingAdd(Arithmetic.saturatingMul(_gasUsed, operatorScalar) * 100, operatorConstant); + return _gasUsed * operatorScalar * 100 + operatorConstant; } else { return Arithmetic.saturatingAdd(Arithmetic.saturatingMul(_gasUsed, operatorScalar) / 1e6, operatorConstant); } diff --git a/packages/contracts-bedrock/test/L2/GasPriceOracle.t.sol b/packages/contracts-bedrock/test/L2/GasPriceOracle.t.sol index 11b9918c9cf..e0f959333c4 100644 --- a/packages/contracts-bedrock/test/L2/GasPriceOracle.t.sol +++ b/packages/contracts-bedrock/test/L2/GasPriceOracle.t.sol @@ -7,6 +7,7 @@ import { Fork } from "scripts/libraries/Config.sol"; // Libraries import { Encoding } from "src/libraries/Encoding.sol"; +import { stdError } from "forge-std/Test.sol"; contract GasPriceOracle_Test is CommonTest { address depositor; @@ -26,6 +27,10 @@ contract GasPriceOracle_Test is CommonTest { uint32 constant operatorFeeScalar = 4_000_000; uint64 constant operatorFeeConstant = 300; + uint256 constant MAX_UINT256 = type(uint256).max; + uint64 constant MAX_UINT64 = type(uint64).max; + uint32 constant MAX_UINT32 = type(uint32).max; + /// @dev Sets up the test suite. function setUp() public virtual override { super.setUp(); @@ -447,6 +452,26 @@ contract GasPriceOracleJovian_Test is GasPriceOracle_Test { assertEq(gasPriceOracle.isJovian(), true, "Jovian activation failed"); } + function _setOperatorFeeParams(uint32 _operatorFeeScalar, uint64 _operatorFeeConstant) internal { + vm.prank(depositor); + (bool success,) = address(l1Block).call( + Encoding.encodeSetL1BlockValuesIsthmus( + baseFeeScalar, + blobBaseFeeScalar, + sequenceNumber, + timestamp, + number, + baseFee, + blobBaseFee, + hash, + batcherHash, + _operatorFeeScalar, + _operatorFeeConstant + ) + ); + require(success, "GasPriceOracleJovian_Test: L1Block setup failed"); + } + /// @dev Tests that `operatorFee` is set correctly using the new Jovian formula (multiply by 100). function test_getOperatorFee_succeeds() external { _activateJovian(); @@ -468,19 +493,67 @@ contract GasPriceOracleJovian_Test is GasPriceOracle_Test { } /// @dev Tests the transition from Isthmus formula to Jovian formula. - function test_formulaTransition_succeeds() external { - // Check Isthmus formula (divide by 1e6) + function test_formulaTransition_edgeCases_works() external { + // Check Isthmus formula with a low gasUsed value (divide by 1e6) + _setOperatorFeeParams(operatorFeeScalar, operatorFeeConstant); uint256 isthmusFee = gasPriceOracle.getOperatorFee(10); - assertEq(isthmusFee, 10 * operatorFeeScalar / 1e6 + operatorFeeConstant); + assertEq( + isthmusFee, + uint256(10) * operatorFeeScalar / 1e6 + operatorFeeConstant, + "Isthmus operator fee incorrect with 10 gas used" + ); + + // Use maximum values permitted by data types for scalars. + // Use maximum value for gasUsed according to client implementations. + // Assert that the fee is as expected (no overflow). + _setOperatorFeeParams(MAX_UINT32, MAX_UINT64); + isthmusFee = gasPriceOracle.getOperatorFee(MAX_UINT64); + assertEq( + isthmusFee, + uint256(MAX_UINT64) * MAX_UINT32 / 1e6 + MAX_UINT64, + "Isthmus operator fee incorrect with max uint64 gas used" + ); + + // Show that the math saturates if the maximum + // value for gasUsed (according to data type) is used. + _setOperatorFeeParams(1e6, 1); + uint256 saturatedIsthmusFee = gasPriceOracle.getOperatorFee(MAX_UINT256); + assertEq( + saturatedIsthmusFee, + 115792089237316195423570985008687907853269984665640564039457584007913130, + "Incorrect value for fee under Isthmus (saturating arithmetic triggered)" + ); // Activate Jovian _activateJovian(); - // Check Jovian formula (multiply by 100) + // Check Jovian formula with a low gasUsed value (multiply by 100) + _setOperatorFeeParams(operatorFeeScalar, operatorFeeConstant); uint256 jovianFee = gasPriceOracle.getOperatorFee(10); - assertEq(jovianFee, 10 * operatorFeeScalar * 100 + operatorFeeConstant); + assertEq( + jovianFee, + uint256(10) * operatorFeeScalar * 100 + operatorFeeConstant, + "Jovian operator fee incorrect with 10 gas used" + ); + + // Use maximum values permitted by data types for scalars. + // Use maximum value for gasUsed according to client implementations. + // Assert that the fee is as expected (no overflow). + _setOperatorFeeParams(MAX_UINT32, MAX_UINT64); + jovianFee = gasPriceOracle.getOperatorFee(MAX_UINT64); + assertEq( + jovianFee, + uint256(MAX_UINT64) * MAX_UINT32 * 100 + MAX_UINT64, + "Jovian operator fee incorrect with max uint64 gas used" + ); + + // Show that a revert is possible if the maximum + // value for gasUsed (according to data type) is used. + _setOperatorFeeParams(1, 1); + vm.expectRevert(stdError.arithmeticError); + gasPriceOracle.getOperatorFee(MAX_UINT256); // Verify the fee increased significantly - assertGt(jovianFee, isthmusFee); + assertGt(jovianFee, isthmusFee, "Jovian formula fee should be greater than Isthmus formula fee"); } } From b9403087b4a0e24f6e1e989eb8d92770c4b0ddec Mon Sep 17 00:00:00 2001 From: Sam Stokes <35908605+bitwiseguy@users.noreply.github.com> Date: Tue, 21 Oct 2025 13:41:12 -0400 Subject: [PATCH 103/117] fix(op-deployer): use temp cache dir for cli tests (#17965) --- .../deployer/integration_test/cli/cli_runner.go | 16 ++++++++++------ 1 file changed, 10 insertions(+), 6 deletions(-) diff --git a/op-deployer/pkg/deployer/integration_test/cli/cli_runner.go b/op-deployer/pkg/deployer/integration_test/cli/cli_runner.go index ba783344824..7a1ef425fea 100644 --- a/op-deployer/pkg/deployer/integration_test/cli/cli_runner.go +++ b/op-deployer/pkg/deployer/integration_test/cli/cli_runner.go @@ -5,11 +5,13 @@ import ( "context" "log/slog" "os" + "path/filepath" "testing" "time" "github.com/ethereum-optimism/optimism/op-deployer/pkg/deployer/integration_test/shared" "github.com/ethereum-optimism/optimism/op-service/testlog" + "github.com/ethereum-optimism/optimism/op-service/testutils" "github.com/ethereum-optimism/optimism/op-service/testutils/devnet" "github.com/stretchr/testify/require" ) @@ -37,7 +39,7 @@ func WithPrivateKey(pkHex string) CLITestRunnerOption { } func NewCLITestRunner(t *testing.T, opts ...CLITestRunnerOption) *CLITestRunner { - workDir := t.TempDir() + workDir := testutils.IsolatedTestDirWithAutoCleanup(t) return &CLITestRunner{ workDir: workDir, } @@ -46,7 +48,7 @@ func NewCLITestRunner(t *testing.T, opts ...CLITestRunnerOption) *CLITestRunner // NewCLITestRunnerWithNetwork creates a new CLI test runner with default network setup. // Defaults can be overridden using functional options. func NewCLITestRunnerWithNetwork(t *testing.T, opts ...CLITestRunnerOption) *CLITestRunner { - workDir := t.TempDir() + workDir := testutils.IsolatedTestDirWithAutoCleanup(t) // Set up defaults lgr := testlog.Logger(t, slog.LevelDebug) @@ -110,11 +112,13 @@ func (r *CLITestRunner) Run(ctx context.Context, args []string, env map[string]s stdout := newCaptureOutputWriter() stderr := newCaptureOutputWriter() - // Add "op-deployer" as the first argument if not already present - fullArgs := args - if len(args) == 0 || args[0] != "op-deployer" { - fullArgs = append([]string{"op-deployer"}, args...) + // Ensure command format is: op-deployer --cache-dir + cacheDir := filepath.Join(r.workDir, ".cache") + commandArgs := args + if len(args) > 0 && args[0] == "op-deployer" { + commandArgs = args[1:] // Skip "op-deployer" if already present } + fullArgs := append([]string{"op-deployer", "--cache-dir", cacheDir}, commandArgs...) // Run the CLI command using the testable interface err = RunCLI(ctx, stdout, stderr, fullArgs) From 4e57f1e91b2bc8cd989276ccebbf6e5734b27e4b Mon Sep 17 00:00:00 2001 From: Maurelian Date: Tue, 21 Oct 2025 14:28:19 -0400 Subject: [PATCH 104/117] Improve SaferSafes test suite. (#17949) MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit * Add SaferSafes as child of the module and guard * Add ISaferSafes * Test comment and assertion fixes * Improve comments * Make LivenessModule2 and TimelockGuard abstract Move semver to SaferSafes semver lock * fix test contract name * Move semver to SaferSafes * Disable the guard and module upon ownership transfer * Add _disableThisGuard function * Update tests * Add config resets * fmt * fix test_changeOwnershipToFallback_canRechallenge_succeeds * Simplify by clearing config directly * Put _disableThisGuard into child contract * Add timelockDelay reset on _disableThisGuard * semver-lock * Move _disableThisGuard logic into TimelockGuard * clear livenessSafeConfig at tend of _disableThisModule * Clarify use of SENTINEL_OWNER * Fix the ordering of the disableGuard and disableModule calls * semver-lock * remove unused imports * rename _disableThisGuard to _disableGuard * bump semver * Add test to remove unrelated guard * Add SENTINEL_MODULE constant * Clean up using ternary if * Reset cancellationThreshold to 0 on changeOwnership * Fix moduleFound if/else handling * Clear pending transactions * Pre-pr fixes * Add test contract to test name lint exclusions * fix name of test contract * Move _disableGuard impl into TimelockGuard * Add missing natspec * Add gas limit testing on changeOwnershipToFallback * Remove interfaces for abstract contracts * Move state changes out into internal _clearLivenessModule * Improve names on the internal _disableX methods * Add clearTimelockGuard function * Add _disableGuard helper to TLG tests * Limit number of transactions cancelled to 100 * Revert "Remove interfaces for abstract contracts" This reverts commit bd032889b639b35b8f512f941de3a924699fe44c. * Move livenessModule2 address into TestUtils Reduces diff a bit * Reduce diff somewhat * Remove unused arg * Update packages/contracts-bedrock/src/safe/TimelockGuard.sol Co-authored-by: graphite-app[bot] <96075541+graphite-app[bot]@users.noreply.github.com> * Fix iface * update abi for iface fix * Do not clear or disable the module during ownership transfer * Fix inaccurate comment on _disableAndClearGuard * Further improve comment * remove unused import * fix test name * Do not clear guard during changeOwnershipToFallback * Remove unused SENTINEL_MODULE var * Remove dangling comment * Revert "Remove dangling comment" This reverts commit d266d12dbc5af68b192c8898b7c97d772a8954a3. * Fix whitespace * remove unnecessary internal _clearTimelockGuard function It's no longer reused in the change ownership call. * Address feedback * Add missing assertion * Move guard slot into constants * semver-lock * Remove LivenessModule from semver-lock * fix: fmt, semver-lock, unused imports * Remove unused variable * fix semver lock by resetting old LivenessModule * fix unused import * Require that msgSender be an owner of the Safe * fix compiler error * Fix placement of _msgSender check * semver-lock * Add TimelockGuard_NotOwner test * Bump semver * Add test comment, make into fuzz test * Improvements to SaferSafes styling (#17903) * Add public getter livenessSafeConfiguration to return a struct rather than tuple * Use Safe as input type to mappings and functions on LivenessModule2 * Add dividers based on function type * fmt * snapshots * Remove conditional return of 0 in the cancellationThreshold if the guard is not enabled * rename timelockConfiguration func to timelockDelay * semver-lock * Add missing natspec on tests and convert to fuzzing where possible * fix import and abi snapshot * fix: off by one error in challenge period test * fix test name * refactor(test): split clearLivenessModule tests into separate contract - Create LivenessModule2_ClearLivenessModule_Test contract - Rename test_clear_* to test_clearLivenessModule_* for consistency - Update contract title to match function under test * test(LivenessModule2): add challenge cancellation to clearLivenessModule test Enhance test_clearLivenessModule_succeeds to verify that clearing also properly cancels any active challenge, covering the _cancelChallenge code path. * test(LivenessModule2): add guard removal check to ownership transfer test Integrate guard removal verification into existing fuzz test rather than creating a separate test. Verifies that any guard set on the Safe is properly removed during the ownership transfer process. 🤖 Generated with [Claude Code](https://claude.com/claude-code) Co-Authored-By: Claude * Remove pointless check Slop that got through * Convert to fuzz tests * test(TimelockGuard): enhance test coverage and convert to fuzz tests - Convert configureTimelockGuard tests to fuzz tests for broader coverage - Add comprehensive checkAfterExecution tests for all code paths - Remove redundant assertions and comments - Add test to verify transaction cannot be re-executed after success - Improve test documentation and structure 🤖 Generated with [Claude Code](https://claude.com/claude-code) Co-Authored-By: Claude * fix test name to match function name * feat: two extra tests to fuzz * fix: fmt --------- Co-authored-by: graphite-app[bot] <96075541+graphite-app[bot]@users.noreply.github.com> Co-authored-by: Claude Co-authored-by: JosepBove --- .../test/safe/LivenessModule2.t.sol | 38 +++++- .../test/safe/SaferSafes.t.sol | 1 + .../test/safe/TimelockGuard.t.sol | 110 ++++++++++++++---- 3 files changed, 121 insertions(+), 28 deletions(-) diff --git a/packages/contracts-bedrock/test/safe/LivenessModule2.t.sol b/packages/contracts-bedrock/test/safe/LivenessModule2.t.sol index 91b8ca7c258..c73e37e03fd 100644 --- a/packages/contracts-bedrock/test/safe/LivenessModule2.t.sol +++ b/packages/contracts-bedrock/test/safe/LivenessModule2.t.sol @@ -10,6 +10,7 @@ import { Constants } from "src/libraries/Constants.sol"; import { LivenessModule2 } from "src/safe/LivenessModule2.sol"; import { SaferSafes } from "src/safe/SaferSafes.sol"; import { ModuleManager } from "safe-contracts/base/ModuleManager.sol"; +import { GuardManager } from "safe-contracts/base/GuardManager.sol"; /// @title LivenessModule2_TestUtils /// @notice Reusable helper methods for LivenessModule2 tests. @@ -108,8 +109,8 @@ contract LivenessModule2_TestInit is LivenessModule2_TestUtils { } } -/// @title LivenessModule2_Configure_Test -/// @notice Tests configuring and clearing the module +/// @title LivenessModule2_ConfigureLivenessModule_Test +/// @notice Tests configuring the module contract LivenessModule2_ConfigureLivenessModule_Test is LivenessModule2_TestInit { function test_configureLivenessModule_succeeds() external { vm.expectEmit(true, true, true, true); @@ -219,10 +220,19 @@ contract LivenessModule2_ConfigureLivenessModule_Test is LivenessModule2_TestIni challengeEndTime = livenessModule2.getChallengePeriodEnd(safeInstance.safe); assertEq(challengeEndTime, 0); } +} - function test_clear_succeeds() external { +/// @title LivenessModule2_ClearLivenessModule_Test +/// @notice Tests clearing the module configuration +contract LivenessModule2_ClearLivenessModule_Test is LivenessModule2_TestInit { + function test_clearLivenessModule_succeeds() external { _enableModule(safeInstance, CHALLENGE_PERIOD, fallbackOwner); + // Start a challenge to test that clearing also cancels it + vm.prank(fallbackOwner); + livenessModule2.challenge(safeInstance.safe); + assertGt(livenessModule2.challengeStartTime(safeInstance.safe), 0); + // First disable the module at the Safe level SafeTestLib.execTransaction( safeInstance, @@ -232,6 +242,9 @@ contract LivenessModule2_ConfigureLivenessModule_Test is LivenessModule2_TestIni Enum.Operation.Call ); + // Clear should emit ChallengeCancelled then ModuleCleared + vm.expectEmit(true, true, true, true); + emit ChallengeCancelled(address(safeInstance.safe)); vm.expectEmit(true, true, true, true); emit ModuleCleared(address(safeInstance.safe)); @@ -247,15 +260,16 @@ contract LivenessModule2_ConfigureLivenessModule_Test is LivenessModule2_TestIni LivenessModule2.ModuleConfig memory clearedConfig = livenessModule2.livenessSafeConfiguration(safeInstance.safe); assertEq(clearedConfig.livenessResponsePeriod, 0); assertEq(clearedConfig.fallbackOwner, address(0)); + assertEq(livenessModule2.challengeStartTime(safeInstance.safe), 0); } - function test_clear_notEnabled_reverts() external { + function test_clearLivenessModule_notConfigured_reverts() external { vm.expectRevert(LivenessModule2.LivenessModule2_ModuleNotConfigured.selector); vm.prank(address(safeInstance.safe)); livenessModule2.clearLivenessModule(); } - function test_clear_moduleStillEnabled_reverts() external { + function test_clearLivenessModule_moduleStillEnabled_reverts() external { _enableModule(safeInstance, CHALLENGE_PERIOD, fallbackOwner); // Try to clear while module is still enabled (should revert) @@ -450,6 +464,17 @@ contract LivenessModule2_ChangeOwnershipToFallback_Test is LivenessModule2_TestI // Bound time to reasonable values (1 second to 365 days after expiry) timeAfterExpiry = bound(timeAfterExpiry, 1, 365 days); + // Set a guard to verify it gets removed + address mockGuard = makeAddr("mockGuard"); + SafeTestLib.execTransaction( + safeInstance, + address(safeInstance.safe), + 0, + abi.encodeCall(GuardManager.setGuard, (mockGuard)), + Enum.Operation.Call + ); + assertEq(_getGuard(safeInstance), mockGuard); + // Start a challenge vm.prank(fallbackOwner); livenessModule2.challenge(safeInstance.safe); @@ -473,6 +498,9 @@ contract LivenessModule2_ChangeOwnershipToFallback_Test is LivenessModule2_TestI // Verify challenge is reset uint256 challengeEndTime = livenessModule2.getChallengePeriodEnd(safeInstance.safe); assertEq(challengeEndTime, 0); + + // Verify guard was removed + assertEq(_getGuard(safeInstance), address(0)); } /// @notice Tests that changeOwnershipToFallback reverts if module is not configured diff --git a/packages/contracts-bedrock/test/safe/SaferSafes.t.sol b/packages/contracts-bedrock/test/safe/SaferSafes.t.sol index 49c10f91212..778ed9b62ec 100644 --- a/packages/contracts-bedrock/test/safe/SaferSafes.t.sol +++ b/packages/contracts-bedrock/test/safe/SaferSafes.t.sol @@ -2,6 +2,7 @@ pragma solidity 0.8.15; import { Enum } from "safe-contracts/common/Enum.sol"; +import { GnosisSafe as Safe } from "safe-contracts/GnosisSafe.sol"; import "test/safe-tools/SafeTestTools.sol"; import { SaferSafes } from "src/safe/SaferSafes.sol"; diff --git a/packages/contracts-bedrock/test/safe/TimelockGuard.t.sol b/packages/contracts-bedrock/test/safe/TimelockGuard.t.sol index 1cd1331ccc5..2e07f1842ce 100644 --- a/packages/contracts-bedrock/test/safe/TimelockGuard.t.sol +++ b/packages/contracts-bedrock/test/safe/TimelockGuard.t.sol @@ -261,49 +261,46 @@ abstract contract TimelockGuard_TestInit is Test, SafeTestTools { } /// @title TimelockGuard_TimelockDelay_Test -/// @notice Tests for timelockConfiguration function +/// @notice Tests for TimelockDelay function contract TimelockGuard_TimelockDelay_Test is TimelockGuard_TestInit { /// @notice Ensures an unconfigured Safe reports a zero timelock delay. - function test_timelockConfiguration_returnsZeroForUnconfiguredSafe_succeeds() external view { + function test_timelockDelay_returnsZeroForUnconfiguredSafe_succeeds() external view { uint256 delay = timelockGuard.timelockDelay(safeInstance.safe); assertEq(delay, 0); - // configured is now determined by timelockDelay == 0 - assertEq(delay == 0, true); } - /// @notice Validates the configuration view reflects the stored timelock delay. - function test_timelockConfiguration_returnsConfigurationForConfiguredSafe_succeeds() external { - _configureGuard(safeInstance, TIMELOCK_DELAY); - uint256 delay = timelockGuard.timelockDelay(safeInstance.safe); - assertEq(delay, TIMELOCK_DELAY); - // configured is now determined by timelockDelay != 0 - assertEq(delay != 0, true); + /// @notice Fuzz test: Validates the configuration view reflects the stored timelock delay for any valid delay. + function testFuzz_timelockDelay_returnsConfigurationForConfiguredSafe_succeeds(uint256 _delay_) external { + _delay_ = bound(_delay_, 1, ONE_YEAR); // Restrict to valid range + _configureGuard(safeInstance, _delay_); + uint256 delay_ = timelockGuard.timelockDelay(safeInstance.safe); + assertEq(delay_, _delay_); } } /// @title TimelockGuard_ConfigureTimelockGuard_Test /// @notice Tests for configureTimelockGuard function contract TimelockGuard_ConfigureTimelockGuard_Test is TimelockGuard_TestInit { - /// @notice Verifies the guard can be configured with a standard delay. - function test_configureTimelockGuard_succeeds() external { + /// @notice Verifies the guard can be configured with various valid delays. + function testFuzz_configureTimelockGuard_validDelay_succeeds(uint256 _delay) external { + _delay = bound(_delay, 1, ONE_YEAR); + vm.expectEmit(true, true, true, true); - emit GuardConfigured(safe, TIMELOCK_DELAY); + emit GuardConfigured(safe, _delay); - _configureGuard(safeInstance, TIMELOCK_DELAY); + _configureGuard(safeInstance, _delay); uint256 delay = timelockGuard.timelockDelay(safe); - assertEq(delay, TIMELOCK_DELAY); - // configured is now determined by timelockDelay != 0 - assertEq(delay != 0, true); + assertEq(delay, _delay); } /// @notice Confirms delays above the maximum revert during configuration. - function test_configureTimelockGuard_revertsIfDelayTooLong_reverts() external { - uint256 tooLongDelay = ONE_YEAR + 1; + function testFuzz_configureTimelockGuard_delayTooLong_reverts(uint256 _delay) external { + _delay = bound(_delay, ONE_YEAR + 1, type(uint256).max); vm.expectRevert(TimelockGuard.TimelockGuard_InvalidTimelockDelay.selector); vm.prank(address(safeInstance.safe)); - timelockGuard.configureTimelockGuard(tooLongDelay); + timelockGuard.configureTimelockGuard(_delay); } /// @notice Checks configuration reverts when the contract is too old. @@ -324,8 +321,6 @@ contract TimelockGuard_ConfigureTimelockGuard_Test is TimelockGuard_TestInit { uint256 delay = timelockGuard.timelockDelay(safe); assertEq(delay, ONE_YEAR); - // configured is now determined by timelockDelay != 0 - assertEq(delay != 0, true); } /// @notice Demonstrates the guard can be reconfigured to a new delay. @@ -733,6 +728,75 @@ contract TimelockGuard_CheckTransaction_Test is TimelockGuard_TestInit { } } +/// @title TimelockGuard_CheckAfterExecution_Test +/// @notice Tests for checkAfterExecution function +contract TimelockGuard_CheckAfterExecution_Test is TimelockGuard_TestInit { + function setUp() public override { + super.setUp(); + _configureGuard(safeInstance, TIMELOCK_DELAY); + } + + /// @notice Verifies successful execution updates state and resets threshold. + function test_checkAfterExecution_successfulExecution_succeeds() external { + TransactionBuilder.Transaction memory dummyTx = _createDummyTransaction(safeInstance); + dummyTx.scheduleTransaction(timelockGuard); + + uint256 expectedExecutionTime = block.timestamp + TIMELOCK_DELAY; + vm.warp(expectedExecutionTime); + + // Verify initial cancellation threshold + uint256 initialThreshold = timelockGuard.cancellationThreshold(safeInstance.safe); + assertEq(initialThreshold, 1); + + // Call checkAfterExecution with successful execution + vm.expectEmit(true, true, true, true); + emit TransactionExecuted(safeInstance.safe, dummyTx.hash); + vm.prank(address(safeInstance.safe)); + timelockGuard.checkAfterExecution(dummyTx.hash, true); + + // Verify transaction state changed to Executed + TimelockGuard.ScheduledTransaction memory scheduledTx = + timelockGuard.scheduledTransaction(safeInstance.safe, dummyTx.hash); + assertEq(uint256(scheduledTx.state), uint256(TimelockGuard.TransactionState.Executed)); + + // Verify transaction removed from pending list + TimelockGuard.ScheduledTransaction[] memory pending = timelockGuard.pendingTransactions(safeInstance.safe); + assertEq(pending.length, 0); + + // Verify cancellation threshold was reset to 1 + assertEq(timelockGuard.cancellationThreshold(safeInstance.safe), 1); + + // Verify transaction cannot be executed again + vm.expectRevert(TimelockGuard.TimelockGuard_TransactionAlreadyExecuted.selector); + dummyTx.executeTransaction(safeInstance.owners[0]); + } + + /// @notice Verifies transaction state remains unchanged on execution failure. + function test_checkAfterExecution_failedExecution_succeeds() external { + TransactionBuilder.Transaction memory dummyTx = _createDummyTransaction(safeInstance); + dummyTx.scheduleTransaction(timelockGuard); + + uint256 expectedExecutionTime = block.timestamp + TIMELOCK_DELAY; + vm.warp(expectedExecutionTime); + + // Call checkAfterExecution with failed execution + vm.prank(address(safeInstance.safe)); + timelockGuard.checkAfterExecution(dummyTx.hash, false); + + // Verify transaction state remains unchanged + TimelockGuard.ScheduledTransaction memory scheduledTx = + timelockGuard.scheduledTransaction(safeInstance.safe, dummyTx.hash); + assertEq(uint256(scheduledTx.state), uint256(TimelockGuard.TransactionState.Pending)); + assertEq(uint256(scheduledTx.executionTime), expectedExecutionTime); + } + + /// @notice Fuzz test: Verifies unconfigured guard allows checkAfterExecution for any _hash. + function testFuzz_checkAfterExecution_unconfiguredGuard_succeeds(bytes32 _hash) external { + vm.prank(address(unguardedSafe.safe)); + timelockGuard.checkAfterExecution(_hash, true); + } +} + /// @title TimelockGuard_MaxCancellationThreshold_Test /// @notice Tests for the maxCancellationThreshold function in TimelockGuard contract TimelockGuard_MaxCancellationThreshold_Test is TimelockGuard_TestInit { From eed9012f41a71e1005b6b0a8663b7fec9ac43ab6 Mon Sep 17 00:00:00 2001 From: JosepBove Date: Tue, 21 Oct 2025 21:12:14 +0200 Subject: [PATCH 105/117] feat: IERC165 support on SaferSafes (#17864) * feat: IERC165 support * fixes * fmt * fix: maurelian's feedback * feat: matt's review * fix: pre-pr * fix: semver --- .../interfaces/safe/ITransactionGuard.sol | 41 +++++++++++++++++++ .../snapshots/abi/SaferSafes.json | 19 +++++++++ .../snapshots/semver-lock.json | 4 +- .../contracts-bedrock/src/safe/SaferSafes.sol | 4 +- .../src/safe/TimelockGuard.sol | 18 +++++++- .../test/safe/TimelockGuard.t.sol | 21 ++++++++++ 6 files changed, 102 insertions(+), 5 deletions(-) create mode 100644 packages/contracts-bedrock/interfaces/safe/ITransactionGuard.sol diff --git a/packages/contracts-bedrock/interfaces/safe/ITransactionGuard.sol b/packages/contracts-bedrock/interfaces/safe/ITransactionGuard.sol new file mode 100644 index 00000000000..f6ba8f105a4 --- /dev/null +++ b/packages/contracts-bedrock/interfaces/safe/ITransactionGuard.sol @@ -0,0 +1,41 @@ +// SPDX-License-Identifier: MIT +pragma solidity ^0.8.0; + +import { Enum } from "safe-contracts/common/Enum.sol"; +import { IERC165 } from "safe-contracts/interfaces/IERC165.sol"; + +/// @title ITransactionGuard Interface +interface ITransactionGuard is IERC165 { + /// @notice Checks the transaction details. + /// @dev The function needs to implement transaction validation logic. + /// @param to The address to which the transaction is intended. + /// @param value The native token value of the transaction in Wei. + /// @param data The transaction data. + /// @param operation Operation type (0 for `CALL`, 1 for `DELEGATECALL`). + /// @param safeTxGas Gas used for the transaction. + /// @param baseGas The base gas for the transaction. + /// @param gasPrice The price of gas in Wei for the transaction. + /// @param gasToken The token used to pay for gas. + /// @param refundReceiver The address which should receive the refund. + /// @param signatures The signatures of the transaction. + /// @param msgSender The address of the message sender. + function checkTransaction( + address to, + uint256 value, + bytes memory data, + Enum.Operation operation, + uint256 safeTxGas, + uint256 baseGas, + uint256 gasPrice, + address gasToken, + address payable refundReceiver, + bytes memory signatures, + address msgSender + ) external; + + /// @notice Checks after execution of the transaction. + /// @dev The function needs to implement a check after the execution of the transaction. + /// @param hash The hash of the executed transaction. + /// @param success The status of the transaction execution. + function checkAfterExecution(bytes32 hash, bool success) external; +} diff --git a/packages/contracts-bedrock/snapshots/abi/SaferSafes.json b/packages/contracts-bedrock/snapshots/abi/SaferSafes.json index 64e28905550..1589521678a 100644 --- a/packages/contracts-bedrock/snapshots/abi/SaferSafes.json +++ b/packages/contracts-bedrock/snapshots/abi/SaferSafes.json @@ -559,6 +559,25 @@ "stateMutability": "nonpayable", "type": "function" }, + { + "inputs": [ + { + "internalType": "bytes4", + "name": "_interfaceId", + "type": "bytes4" + } + ], + "name": "supportsInterface", + "outputs": [ + { + "internalType": "bool", + "name": "", + "type": "bool" + } + ], + "stateMutability": "view", + "type": "function" + }, { "inputs": [ { diff --git a/packages/contracts-bedrock/snapshots/semver-lock.json b/packages/contracts-bedrock/snapshots/semver-lock.json index 85948cab52f..b695111229b 100644 --- a/packages/contracts-bedrock/snapshots/semver-lock.json +++ b/packages/contracts-bedrock/snapshots/semver-lock.json @@ -208,8 +208,8 @@ "sourceCodeHash": "0x950725f8b9ad9bb3b6b5e836f67e18db824a7864bac547ee0eeba88ada3de0e9" }, "src/safe/SaferSafes.sol:SaferSafes": { - "initCodeHash": "0xaa17bb150c9bcf19675a33e9762b050148aceae9f6a9a6ba020fc6947ebaab39", - "sourceCodeHash": "0xc4201612048ff051ed795521efa3eece1a6556f2c514a268b180d84a2ad8b2d1" + "initCodeHash": "0x95ee7ae09ee281f224425f152c9154e43e49838edbe3eee48c15301e5f410d25", + "sourceCodeHash": "0xdc794e3d6decb47c51d86bb2f69523feade4fd3f81feb4734800f24b40d40a50" }, "src/universal/OptimismMintableERC20.sol:OptimismMintableERC20": { "initCodeHash": "0x3c85eed0d017dca8eda6396aa842ddc12492587b061e8c756a8d32c4610a9658", diff --git a/packages/contracts-bedrock/src/safe/SaferSafes.sol b/packages/contracts-bedrock/src/safe/SaferSafes.sol index 52ea97df94e..80d879de141 100644 --- a/packages/contracts-bedrock/src/safe/SaferSafes.sol +++ b/packages/contracts-bedrock/src/safe/SaferSafes.sol @@ -22,8 +22,8 @@ import { ISemver } from "interfaces/universal/ISemver.sol"; /// functionality is not desired, then there is no need to enable or configure it. contract SaferSafes is LivenessModule2, TimelockGuard, ISemver { /// @notice Semantic version. - /// @custom:semver 1.2.0 - string public constant version = "1.2.0"; + /// @custom:semver 1.3.0 + string public constant version = "1.3.0"; /// @notice Error for when the liveness response period is insufficient. error SaferSafes_InsufficientLivenessResponsePeriod(); diff --git a/packages/contracts-bedrock/src/safe/TimelockGuard.sol b/packages/contracts-bedrock/src/safe/TimelockGuard.sol index 2276cbdcf99..9905761fbe8 100644 --- a/packages/contracts-bedrock/src/safe/TimelockGuard.sol +++ b/packages/contracts-bedrock/src/safe/TimelockGuard.sol @@ -5,12 +5,16 @@ pragma solidity 0.8.15; import { GnosisSafe as Safe } from "safe-contracts/GnosisSafe.sol"; import { Enum } from "safe-contracts/common/Enum.sol"; import { Guard as IGuard } from "safe-contracts/base/GuardManager.sol"; +import { IERC165 } from "safe-contracts/interfaces/IERC165.sol"; // Libraries import { EnumerableSet } from "@openzeppelin/contracts/utils/structs/EnumerableSet.sol"; import { SemverComp } from "src/libraries/SemverComp.sol"; import { Constants } from "src/libraries/Constants.sol"; +// Interfaces +import { ITransactionGuard } from "interfaces/safe/ITransactionGuard.sol"; + /// @title TimelockGuard /// @notice This guard provides timelock functionality for Safe transactions /// @dev This is a singleton contract, any Safe on the network can use this guard to enforce a timelock delay, and @@ -65,7 +69,7 @@ import { Constants } from "src/libraries/Constants.sol"; /// | Quorum+ | challenge + | cancelTransaction | /// | | changeOwnershipToFallback | | /// +-------------------------------------------------------------------------------------------------+ -abstract contract TimelockGuard is IGuard { +abstract contract TimelockGuard is IGuard, IERC165 { using EnumerableSet for EnumerableSet.Bytes32Set; /// @notice Allowed states of a transaction @@ -673,4 +677,16 @@ abstract contract TimelockGuard is IGuard { function signCancellation(bytes32) public { emit Message("This function is not meant to be called, did you mean to call cancelTransaction?"); } + + //////////////////////////////////////////////////////////////// + // ERC165 Support // + //////////////////////////////////////////////////////////////// + + /// @notice ERC165 interface detection + /// @param _interfaceId The interface identifier to check + /// @return True if the contract implements the interface + function supportsInterface(bytes4 _interfaceId) external view virtual override returns (bool) { + return _interfaceId == type(ITransactionGuard).interfaceId // 0xe6d7a83a + || _interfaceId == type(IERC165).interfaceId; // 0x01ffc9a7 + } } diff --git a/packages/contracts-bedrock/test/safe/TimelockGuard.t.sol b/packages/contracts-bedrock/test/safe/TimelockGuard.t.sol index 2e07f1842ce..b4a2b5b3cd6 100644 --- a/packages/contracts-bedrock/test/safe/TimelockGuard.t.sol +++ b/packages/contracts-bedrock/test/safe/TimelockGuard.t.sol @@ -4,6 +4,7 @@ pragma solidity 0.8.15; import { Test } from "forge-std/Test.sol"; import { GnosisSafe as Safe } from "safe-contracts/GnosisSafe.sol"; import { GuardManager } from "safe-contracts/base/GuardManager.sol"; +import { ITransactionGuard } from "interfaces/safe/ITransactionGuard.sol"; import "test/safe-tools/SafeTestTools.sol"; import { TimelockGuard } from "src/safe/TimelockGuard.sol"; @@ -1045,3 +1046,23 @@ contract TimelockGuard_ClearTimelockGuard_Test is TimelockGuard_TestInit { timelockGuard.clearTimelockGuard(); } } + +/// @title TimelockGuard_SupportsInterface_Test +/// @notice Tests ERC165 interface support for TimelockGuard +contract TimelockGuard_SupportsInterface_Test is TimelockGuard_TestInit { + function test_supportsInterface_iTransactionGuard_succeeds() external view { + bytes4 interfaceId = 0xe6d7a83a; // ITransactionGuard interface ID + assertTrue(timelockGuard.supportsInterface(interfaceId), "Should support ITransactionGuard"); + } + + function test_supportsInterface_ierc165_succeeds() external view { + bytes4 interfaceId = 0x01ffc9a7; // IERC165 interface ID + assertTrue(timelockGuard.supportsInterface(interfaceId), "Should support IERC165"); + } + + function test_supportsInterface_invalidInterface_fails(bytes4 _interfaceId) external view { + vm.assume(_interfaceId != type(ITransactionGuard).interfaceId); + vm.assume(_interfaceId != type(IERC165).interfaceId); + assertFalse(timelockGuard.supportsInterface(_interfaceId), "Should not support invalid interface"); + } +} From 6fa1e0779b3f84d8f4c54a1c361c8da8c85d33ba Mon Sep 17 00:00:00 2001 From: Adrian Sutton Date: Wed, 22 Oct 2025 06:17:12 +1000 Subject: [PATCH 106/117] opcm: Add support for V2 contracts in addGameType (#17782) * opcm: Add support for V2 contracts in addGameType Tests failing when V2 is enabled because the expected L2 chain ID is loaded incorrectly. * opcm: Make a bunch more tests pass. * opcm: Fix test_addGameType_reusedDelayedWETH_succeeds by deploying a proxy and initialising correctly. * opcm: Check gameType via created game. * opcm: Add additional checks into existing test. * opcm: Assert all common immutable fields of dispute games. * opcm: Fix imports * opcm: Inherit DisputeGames higher up in tests. * opcm: Assert actual chain ID * opcm: Load anchor state registry from the system config * opcm: Remove outdated comment. --- .../abi/OPContractsManagerGameTypeAdder.json | 16 ++ .../snapshots/semver-lock.json | 4 +- .../src/L1/OPContractsManager.sol | 225 +++++++++------- .../test/L1/OPContractsManager.t.sol | 248 ++++++++++-------- .../test/opcm/DeployOPChain.t.sol | 2 + .../test/setup/DisputeGames.sol | 49 ++++ 6 files changed, 350 insertions(+), 194 deletions(-) create mode 100644 packages/contracts-bedrock/test/setup/DisputeGames.sol diff --git a/packages/contracts-bedrock/snapshots/abi/OPContractsManagerGameTypeAdder.json b/packages/contracts-bedrock/snapshots/abi/OPContractsManagerGameTypeAdder.json index 5a513822ef9..2f5ca270376 100644 --- a/packages/contracts-bedrock/snapshots/abi/OPContractsManagerGameTypeAdder.json +++ b/packages/contracts-bedrock/snapshots/abi/OPContractsManagerGameTypeAdder.json @@ -452,6 +452,22 @@ "name": "IdentityPrecompileCallFailed", "type": "error" }, + { + "inputs": [ + { + "internalType": "bytes32", + "name": "devFeature", + "type": "bytes32" + } + ], + "name": "InvalidDevFeatureAccess", + "type": "error" + }, + { + "inputs": [], + "name": "InvalidGameArgsLength", + "type": "error" + }, { "inputs": [], "name": "InvalidGameConfigs", diff --git a/packages/contracts-bedrock/snapshots/semver-lock.json b/packages/contracts-bedrock/snapshots/semver-lock.json index b695111229b..a9d5a0fe78c 100644 --- a/packages/contracts-bedrock/snapshots/semver-lock.json +++ b/packages/contracts-bedrock/snapshots/semver-lock.json @@ -20,8 +20,8 @@ "sourceCodeHash": "0xfca613b5d055ffc4c3cbccb0773ddb9030abedc1aa6508c9e2e7727cc0cd617b" }, "src/L1/OPContractsManager.sol:OPContractsManager": { - "initCodeHash": "0x0ef3fcb6fee1f73c95a48269bba8c83ee463a6f116f36f8d88edb247f72e8a05", - "sourceCodeHash": "0x16a845ddb5ee469e81f3d817ee9f6d6ff5697ace0bc399bd1e0f26e05546f781" + "initCodeHash": "0x02af0627bee699be308b7d83ceb41655c38ae6856ed3842246917ae696475d64", + "sourceCodeHash": "0x76f8991025c5346053444d50c4c0b63faa1739deebdbad99360fe37ca068ed15" }, "src/L1/OPContractsManagerStandardValidator.sol:OPContractsManagerStandardValidator": { "initCodeHash": "0x2eaa345ba05582c67b40a1eb7ec9d54823aa08468e697e2d6c04bb74cc574abc", diff --git a/packages/contracts-bedrock/src/L1/OPContractsManager.sol b/packages/contracts-bedrock/src/L1/OPContractsManager.sol index a0bc0789df1..d4bd71355a3 100644 --- a/packages/contracts-bedrock/src/L1/OPContractsManager.sol +++ b/packages/contracts-bedrock/src/L1/OPContractsManager.sol @@ -39,6 +39,7 @@ import { IL1ERC721Bridge } from "interfaces/L1/IL1ERC721Bridge.sol"; import { IL1StandardBridge } from "interfaces/L1/IL1StandardBridge.sol"; import { IOptimismMintableERC20Factory } from "interfaces/universal/IOptimismMintableERC20Factory.sol"; import { IETHLockbox } from "interfaces/L1/IETHLockbox.sol"; +import { ISystemConfig } from "../../interfaces/L1/ISystemConfig.sol"; contract OPContractsManagerContractsContainer { /// @notice Addresses of the Blueprint contracts. @@ -571,18 +572,20 @@ contract OPContractsManagerGameTypeAdder is OPContractsManagerBase { outputs[i].delayedWETH = gameConfig.delayedWETH; } - // Determine the contract name and blueprints for the game type. - string memory gameContractName; - address blueprint1; - address blueprint2; - uint256 gameL2ChainId; + // Grab the DisputeGameFactory and AnchorStateRegistry for the chain. + IDisputeGameFactory dgf = getDisputeGameFactory(gameConfig.systemConfig); - // Separate context to avoid stack too deep. - { - // Grab the blueprints once since we'll need it multiple times below. - OPContractsManager.Blueprints memory bps = getBlueprints(); + // Grab the existing game implementation from the DisputeGameFactory. + IFaultDisputeGame existingGame = + IFaultDisputeGame(address(getGameImplementation(dgf, gameConfig.disputeGameType))); - // Determine the contract name and blueprints for the game type. + // Super games don't support V2 contracts yet so fallback to the V1 contracts for those game types. + if ( + isDevFeatureEnabled(DevFeatures.DEPLOY_V2_DISPUTE_GAMES) + && gameConfig.disputeGameType.raw() != GameTypes.SUPER_PERMISSIONED_CANNON.raw() + && gameConfig.disputeGameType.raw() != GameTypes.SUPER_CANNON.raw() + && gameConfig.disputeGameType.raw() != GameTypes.SUPER_CANNON_KONA.raw() + ) { if ( gameConfig.disputeGameType.raw() == GameTypes.CANNON.raw() || ( @@ -590,92 +593,138 @@ contract OPContractsManagerGameTypeAdder is OPContractsManagerBase { && gameConfig.disputeGameType.raw() == GameTypes.CANNON_KONA.raw() ) ) { - gameContractName = "FaultDisputeGame"; - blueprint1 = bps.permissionlessDisputeGame1; - blueprint2 = bps.permissionlessDisputeGame2; - gameL2ChainId = l2ChainId; + address impl = implementations().faultDisputeGameV2Impl; + bytes memory gameArgs = abi.encodePacked( + gameConfig.disputeAbsolutePrestate, // 32 bytes + gameConfig.vm, // 20 bytes + address(getAnchorStateRegistry(ISystemConfig(gameConfig.systemConfig))), // 20 + // bytes + address(outputs[i].delayedWETH), // 20 bytes + l2ChainId // 32 bytes + ); + setDGFImplementation(dgf, gameConfig.disputeGameType, IDisputeGame(impl), gameArgs); + outputs[i].faultDisputeGame = IFaultDisputeGame(impl); } else if (gameConfig.disputeGameType.raw() == GameTypes.PERMISSIONED_CANNON.raw()) { - gameContractName = "PermissionedDisputeGame"; - blueprint1 = bps.permissionedDisputeGame1; - blueprint2 = bps.permissionedDisputeGame2; - gameL2ChainId = l2ChainId; - } else if ( - gameConfig.disputeGameType.raw() == GameTypes.SUPER_CANNON.raw() - || ( - isDevFeatureEnabled(DevFeatures.CANNON_KONA) - && gameConfig.disputeGameType.raw() == GameTypes.SUPER_CANNON_KONA.raw() - ) - ) { - gameContractName = "SuperFaultDisputeGame"; - blueprint1 = bps.superPermissionlessDisputeGame1; - blueprint2 = bps.superPermissionlessDisputeGame2; - gameL2ChainId = 0; - } else if (gameConfig.disputeGameType.raw() == GameTypes.SUPER_PERMISSIONED_CANNON.raw()) { - gameContractName = "SuperPermissionedDisputeGame"; - blueprint1 = bps.superPermissionedDisputeGame1; - blueprint2 = bps.superPermissionedDisputeGame2; - gameL2ChainId = 0; + address impl = implementations().permissionedDisputeGameV2Impl; + bytes memory gameArgs = abi.encodePacked( + gameConfig.disputeAbsolutePrestate, // 32 bytes + gameConfig.vm, // 20 bytes + address(getAnchorStateRegistry(ISystemConfig(gameConfig.systemConfig))), // 20 bytes + address(outputs[i].delayedWETH), // 20 bytes + l2ChainId, // 32 bytes + getProposer(dgf, IPermissionedDisputeGame(address(existingGame)), gameConfig.disputeGameType), // 20 + // bytes + getChallenger(dgf, IPermissionedDisputeGame(address(existingGame)), gameConfig.disputeGameType) // 20 + // bytes + ); + setDGFImplementation(dgf, gameConfig.disputeGameType, IDisputeGame(impl), gameArgs); + outputs[i].faultDisputeGame = IFaultDisputeGame(payable(impl)); } else { revert OPContractsManagerGameTypeAdder_UnsupportedGameType(); } - } - - // Grab the DisputeGameFactory and AnchorStateRegistry for the chain. - IDisputeGameFactory dgf = getDisputeGameFactory(gameConfig.systemConfig); + } else { + // Determine the contract name and blueprints for the game type. + string memory gameContractName; + address blueprint1; + address blueprint2; + uint256 gameL2ChainId; + + // Separate context to avoid stack too deep. + { + // Grab the blueprints once since we'll need it multiple times below. + OPContractsManager.Blueprints memory bps = getBlueprints(); + + // Determine the contract name and blueprints for the game type. + if ( + gameConfig.disputeGameType.raw() == GameTypes.CANNON.raw() + || ( + isDevFeatureEnabled(DevFeatures.CANNON_KONA) + && gameConfig.disputeGameType.raw() == GameTypes.CANNON_KONA.raw() + ) + ) { + gameContractName = "FaultDisputeGame"; + blueprint1 = bps.permissionlessDisputeGame1; + blueprint2 = bps.permissionlessDisputeGame2; + gameL2ChainId = l2ChainId; + } else if (gameConfig.disputeGameType.raw() == GameTypes.PERMISSIONED_CANNON.raw()) { + gameContractName = "PermissionedDisputeGame"; + blueprint1 = bps.permissionedDisputeGame1; + blueprint2 = bps.permissionedDisputeGame2; + gameL2ChainId = l2ChainId; + } else if ( + gameConfig.disputeGameType.raw() == GameTypes.SUPER_CANNON.raw() + || ( + isDevFeatureEnabled(DevFeatures.CANNON_KONA) + && gameConfig.disputeGameType.raw() == GameTypes.SUPER_CANNON_KONA.raw() + ) + ) { + gameContractName = "SuperFaultDisputeGame"; + blueprint1 = bps.superPermissionlessDisputeGame1; + blueprint2 = bps.superPermissionlessDisputeGame2; + gameL2ChainId = 0; + } else if (gameConfig.disputeGameType.raw() == GameTypes.SUPER_PERMISSIONED_CANNON.raw()) { + gameContractName = "SuperPermissionedDisputeGame"; + blueprint1 = bps.superPermissionedDisputeGame1; + blueprint2 = bps.superPermissionedDisputeGame2; + gameL2ChainId = 0; + } else { + revert OPContractsManagerGameTypeAdder_UnsupportedGameType(); + } + } - // Grab the existing game implementation from the DisputeGameFactory. - IFaultDisputeGame existingGame = - IFaultDisputeGame(address(getGameImplementation(dgf, gameConfig.disputeGameType))); + // Encode the constructor data for the game type. + bytes memory constructorData; + if (gameConfig.permissioned) { + constructorData = encodePermissionedFDGConstructor( + IFaultDisputeGame.GameConstructorParams( + gameConfig.disputeGameType, + gameConfig.disputeAbsolutePrestate, + gameConfig.disputeMaxGameDepth, + gameConfig.disputeSplitDepth, + gameConfig.disputeClockExtension, + gameConfig.disputeMaxClockDuration, + gameConfig.vm, + outputs[i].delayedWETH, + getAnchorStateRegistry(gameConfig.systemConfig), + gameL2ChainId + ), + getProposerV1(IPermissionedDisputeGame(address(existingGame))), + getChallengerV1(IPermissionedDisputeGame(address(existingGame))) + ); + } else { + constructorData = encodePermissionlessFDGConstructor( + IFaultDisputeGame.GameConstructorParams( + gameConfig.disputeGameType, + gameConfig.disputeAbsolutePrestate, + gameConfig.disputeMaxGameDepth, + gameConfig.disputeSplitDepth, + gameConfig.disputeClockExtension, + gameConfig.disputeMaxClockDuration, + gameConfig.vm, + outputs[i].delayedWETH, + getAnchorStateRegistry(gameConfig.systemConfig), + gameL2ChainId + ) + ); + } - // Encode the constructor data for the game type. - bytes memory constructorData; - if (gameConfig.permissioned) { - constructorData = encodePermissionedFDGConstructor( - IFaultDisputeGame.GameConstructorParams( - gameConfig.disputeGameType, - gameConfig.disputeAbsolutePrestate, - gameConfig.disputeMaxGameDepth, - gameConfig.disputeSplitDepth, - gameConfig.disputeClockExtension, - gameConfig.disputeMaxClockDuration, - gameConfig.vm, - outputs[i].delayedWETH, - getAnchorStateRegistry(gameConfig.systemConfig), - gameL2ChainId - ), - getProposerV1(IPermissionedDisputeGame(address(existingGame))), - getChallengerV1(IPermissionedDisputeGame(address(existingGame))) - ); - } else { - constructorData = encodePermissionlessFDGConstructor( - IFaultDisputeGame.GameConstructorParams( - gameConfig.disputeGameType, - gameConfig.disputeAbsolutePrestate, - gameConfig.disputeMaxGameDepth, - gameConfig.disputeSplitDepth, - gameConfig.disputeClockExtension, - gameConfig.disputeMaxClockDuration, - gameConfig.vm, - outputs[i].delayedWETH, - getAnchorStateRegistry(gameConfig.systemConfig), - gameL2ChainId + // Deploy the new game type. + outputs[i].faultDisputeGame = IFaultDisputeGame( + Blueprint.deployFrom( + blueprint1, + blueprint2, + computeSalt(l2ChainId, gameConfig.saltMixer, gameContractName), + constructorData ) ); - } - // Deploy the new game type. - outputs[i].faultDisputeGame = IFaultDisputeGame( - Blueprint.deployFrom( - blueprint1, - blueprint2, - computeSalt(l2ChainId, gameConfig.saltMixer, gameContractName), - constructorData - ) - ); + // As a last step, register the new game type with the DisputeGameFactory. If the game + // type already exists, then its implementation will be overwritten. + setDGFImplementation( + dgf, gameConfig.disputeGameType, IDisputeGame(address(outputs[i].faultDisputeGame)) + ); + } - // As a last step, register the new game type with the DisputeGameFactory. If the game - // type already exists, then its implementation will be overwritten. - setDGFImplementation(dgf, gameConfig.disputeGameType, IDisputeGame(address(outputs[i].faultDisputeGame))); dgf.setInitBond(gameConfig.disputeGameType, gameConfig.initialBond); // Emit event for the newly added game type with the new and old implementations. @@ -2089,9 +2138,9 @@ contract OPContractsManager is ISemver { // -------- Constants and Variables -------- - /// @custom:semver 4.4.0 + /// @custom:semver 4.5.0 function version() public pure virtual returns (string memory) { - return "4.4.0"; + return "4.5.0"; } OPContractsManagerGameTypeAdder public immutable opcmGameTypeAdder; diff --git a/packages/contracts-bedrock/test/L1/OPContractsManager.t.sol b/packages/contracts-bedrock/test/L1/OPContractsManager.t.sol index 5f5080991fc..0755fce8417 100644 --- a/packages/contracts-bedrock/test/L1/OPContractsManager.t.sol +++ b/packages/contracts-bedrock/test/L1/OPContractsManager.t.sol @@ -14,10 +14,10 @@ import { DeployUtils } from "scripts/libraries/DeployUtils.sol"; import { Deploy } from "scripts/deploy/Deploy.s.sol"; import { VerifyOPCM } from "scripts/deploy/VerifyOPCM.s.sol"; import { DeployOPChain } from "scripts/deploy/DeployOPChain.s.sol"; -import { Config } from "scripts/libraries/Config.sol"; -import { Types } from "scripts/libraries/Types.sol"; // Libraries +import { Config } from "scripts/libraries/Config.sol"; +import { Types } from "scripts/libraries/Types.sol"; import { EIP1967Helper } from "test/mocks/EIP1967Helper.sol"; import { GameType, Duration, Hash, Claim } from "src/dispute/lib/LibUDT.sol"; import { Proposal, GameTypes } from "src/dispute/lib/Types.sol"; @@ -47,6 +47,7 @@ import { IETHLockbox } from "interfaces/L1/IETHLockbox.sol"; import { IBigStepper } from "interfaces/dispute/IBigStepper.sol"; import { ISuperFaultDisputeGame } from "interfaces/dispute/ISuperFaultDisputeGame.sol"; import { ISuperPermissionedDisputeGame } from "interfaces/dispute/ISuperPermissionedDisputeGame.sol"; +import { IFaultDisputeGame } from "../../interfaces/dispute/IFaultDisputeGame.sol"; // Contracts import { @@ -58,6 +59,10 @@ import { OPContractsManagerInteropMigrator, OPContractsManagerStandardValidator } from "src/L1/OPContractsManager.sol"; +import { DisputeGames } from "../setup/DisputeGames.sol"; +import { IPermissionedDisputeGame } from "../../interfaces/dispute/IPermissionedDisputeGame.sol"; +import { IProxy } from "../../interfaces/universal/IProxy.sol"; +import { IDelayedWETH } from "../../interfaces/dispute/IDelayedWETH.sol"; /// @title OPContractsManager_Harness /// @notice Exposes internal functions for testing. @@ -414,19 +419,29 @@ contract OPContractsManager_Upgrade_Harness is CommonTest { /// @title OPContractsManager_TestInit /// @notice Reusable test initialization for `OPContractsManager` tests. -abstract contract OPContractsManager_TestInit is CommonTest { +abstract contract OPContractsManager_TestInit is CommonTest, DisputeGames { event GameTypeAdded( uint256 indexed l2ChainId, GameType indexed gameType, IDisputeGame newDisputeGame, IDisputeGame oldDisputeGame ); + address proposer; + address challenger; + + uint256 chain1L2ChainId; + uint256 chain2L2ChainId; + IOPContractsManager.DeployOutput internal chainDeployOutput1; IOPContractsManager.DeployOutput internal chainDeployOutput2; function setUp() public virtual override { super.setUp(); + proposer = address(this); + challenger = address(this); + chain1L2ChainId = 100; + chain2L2ChainId = 101; - chainDeployOutput1 = createChainContracts(100); - chainDeployOutput2 = createChainContracts(101); + chainDeployOutput1 = createChainContracts(chain1L2ChainId); + chainDeployOutput2 = createChainContracts(chain2L2ChainId); vm.deal(address(chainDeployOutput1.ethLockboxProxy), 100 ether); vm.deal(address(chainDeployOutput2.ethLockboxProxy), 100 ether); @@ -449,8 +464,8 @@ abstract contract OPContractsManager_TestInit is CommonTest { systemConfigOwner: address(this), batcher: address(this), unsafeBlockSigner: address(this), - proposer: address(this), - challenger: address(this) + proposer: proposer, + challenger: challenger }), basefeeScalar: 1, blobBasefeeScalar: 1, @@ -482,9 +497,7 @@ abstract contract OPContractsManager_TestInit is CommonTest { IOPContractsManager.AddGameInput[] memory inputs = new IOPContractsManager.AddGameInput[](1); inputs[0] = input; - uint256 l2ChainId = IFaultDisputeGame( - address(IDisputeGameFactory(input.systemConfig.disputeGameFactory()).gameImpls(GameType.wrap(1))) - ).l2ChainId(); + uint256 l2ChainId = input.systemConfig.l2ChainId(); // Expect the GameTypeAdded event to be emitted. vm.expectEmit(true, true, true, false, address(this)); @@ -578,14 +591,6 @@ contract OPContractsManager_ChainIdToBatchInboxAddress_Test is Test, FeatureFlag /// @title OPContractsManager_AddGameType_Test /// @notice Tests the `addGameType` function of the `OPContractsManager` contract. contract OPContractsManager_AddGameType_Test is OPContractsManager_TestInit { - function setUp() public virtual override { - super.setUp(); - - // Skip AddGameType tests when V2 dispute games are enabled - // TODO(#17260): Remove skip when V2 dispute game support for addGameType implemented - skipIfDevFeatureEnabled(DevFeatures.DEPLOY_V2_DISPUTE_GAMES); - } - /// @notice Tests that we can add a PermissionedDisputeGame implementation with addGameType. function test_addGameType_permissioned_succeeds() public { // Create the input for the Permissioned game type. @@ -593,18 +598,40 @@ contract OPContractsManager_AddGameType_Test is OPContractsManager_TestInit { // Run the addGameType call. IOPContractsManager.AddGameOutput memory output = addGameType(input); - assertValidGameType(input, output); + IFaultDisputeGame newFDG = assertValidGameType(input, output); // Check the values on the new game type. - IPermissionedDisputeGame newPDG = IPermissionedDisputeGame(address(output.faultDisputeGame)); - IPermissionedDisputeGame oldPDG = chainDeployOutput1.permissionedDisputeGame; + IPermissionedDisputeGame newPDG = IPermissionedDisputeGame(address(newFDG)); // Check the proposer and challenger values. - assertEq(newPDG.proposer(), oldPDG.proposer(), "proposer mismatch"); - assertEq(newPDG.challenger(), oldPDG.challenger(), "challenger mismatch"); + assertEq(newPDG.proposer(), proposer, "proposer mismatch"); + assertEq(newPDG.challenger(), challenger, "challenger mismatch"); // L2 chain ID call should not revert because this is not a Super game. - assertNotEq(newPDG.l2ChainId(), 0, "l2ChainId should not be zero"); + assertEq(newPDG.l2ChainId(), chain1L2ChainId, "l2ChainId should be set correctly"); + + if (isDevFeatureEnabled(DevFeatures.DEPLOY_V2_DISPUTE_GAMES)) { + // Get the v2 implementation address from OPCM + IOPContractsManager.Implementations memory impls = opcm.implementations(); + + // Verify v2 implementation is registered in DisputeGameFactory + address registeredImpl = + address(chainDeployOutput1.disputeGameFactoryProxy.gameImpls(GameTypes.PERMISSIONED_CANNON)); + + // Verify implementation address matches permissionedDisputeGameV2Impl + assertEq( + registeredImpl, + address(impls.permissionedDisputeGameV2Impl), + "DisputeGameFactory should have v2 PermissionedDisputeGame implementation registered" + ); + + // Verify that the returned fault dispute game is the v2 implementation + assertEq( + address(output.faultDisputeGame), + address(impls.permissionedDisputeGameV2Impl), + "addGameType should return v2 PermissionedDisputeGame implementation" + ); + } } /// @notice Tests that we can add a FaultDisputeGame implementation with addGameType. @@ -614,17 +641,40 @@ contract OPContractsManager_AddGameType_Test is OPContractsManager_TestInit { // Run the addGameType call. IOPContractsManager.AddGameOutput memory output = addGameType(input); - assertValidGameType(input, output); + IFaultDisputeGame newGame = assertValidGameType(input, output); // Check the values on the new game type. - IPermissionedDisputeGame notPDG = IPermissionedDisputeGame(address(output.faultDisputeGame)); + IPermissionedDisputeGame notPDG = IPermissionedDisputeGame(address(newGame)); // Proposer call should revert because this is a permissionless game. vm.expectRevert(); // nosemgrep: sol-safety-expectrevert-no-args notPDG.proposer(); // L2 chain ID call should not revert because this is not a Super game. - assertNotEq(notPDG.l2ChainId(), 0, "l2ChainId should not be zero"); + assertEq(notPDG.l2ChainId(), chain1L2ChainId, "l2ChainId should be set correctly"); + + // Verify v2 implementation is registered in DisputeGameFactory + address registeredImpl = address(chainDeployOutput1.disputeGameFactoryProxy.gameImpls(input.disputeGameType)); + assertNotEq(registeredImpl, address(0), "Implementation should have been set"); + + if (isDevFeatureEnabled(DevFeatures.DEPLOY_V2_DISPUTE_GAMES)) { + // Get the v2 implementation address from OPCM + IOPContractsManager.Implementations memory impls = opcm.implementations(); + + // Verify implementation address matches permissionedDisputeGameV2Impl + assertEq( + registeredImpl, + address(impls.faultDisputeGameV2Impl), + "DisputeGameFactory should have v2 FaultDisputeGame implementation registered" + ); + + // Verify that the returned fault dispute game is the v2 implementation + assertEq( + address(output.faultDisputeGame), + address(impls.faultDisputeGameV2Impl), + "addGameType should return v2 FaultDisputeGame implementation" + ); + } } /// @notice Tests that we can add a SuperPermissionedDisputeGame implementation with addGameType. @@ -650,17 +700,28 @@ contract OPContractsManager_AddGameType_Test is OPContractsManager_TestInit { abi.encodeCall(IDisputeGame.gameType, ()), abi.encode(GameTypes.SUPER_PERMISSIONED_CANNON) ); + // Mock the proposer and challenger calls to behave like SuperPermissionedDisputeGame + // When V2 contracts are used the permissioned game may be the V2 contract and not have proposer and challenger + // in the implementation contract. + vm.mockCall( + address(chainDeployOutput1.permissionedDisputeGame), + abi.encodeCall(IPermissionedDisputeGame.proposer, ()), + abi.encode(proposer) + ); + vm.mockCall( + address(chainDeployOutput1.permissionedDisputeGame), + abi.encodeCall(IPermissionedDisputeGame.challenger, ()), + abi.encode(challenger) + ); // Run the addGameType call. IOPContractsManager.AddGameOutput memory output = addGameType(input); vm.clearMockedCalls(); - assertValidGameType(input, output); - + IFaultDisputeGame newGame = assertValidGameType(input, output); // Check the values on the new game type. - IPermissionedDisputeGame newPDG = IPermissionedDisputeGame(address(output.faultDisputeGame)); - IPermissionedDisputeGame oldPDG = chainDeployOutput1.permissionedDisputeGame; - assertEq(newPDG.proposer(), oldPDG.proposer(), "proposer mismatch"); - assertEq(newPDG.challenger(), oldPDG.challenger(), "challenger mismatch"); + IPermissionedDisputeGame newPDG = IPermissionedDisputeGame(address(newGame)); + assertEq(newPDG.proposer(), proposer, "proposer mismatch"); + assertEq(newPDG.challenger(), challenger, "challenger mismatch"); // Super games don't have the l2ChainId function. vm.expectRevert(); // nosemgrep: sol-safety-expectrevert-no-args @@ -725,16 +786,15 @@ contract OPContractsManager_AddGameType_Test is OPContractsManager_TestInit { function test_addGameType_reusedDelayedWETH_succeeds() public { IDelayedWETH delayedWETH = IDelayedWETH( - payable( - address( - DeployUtils.create1({ - _name: "DelayedWETH", - _args: DeployUtils.encodeConstructor(abi.encodeCall(IDelayedWETH.__constructor__, (1))) - }) - ) - ) + DeployUtils.create1({ + _name: "Proxy", + _args: DeployUtils.encodeConstructor(abi.encodeCall(IProxy.__constructor__, (address(this)))) + }) + ); + IProxy(payable(address(delayedWETH))).upgradeToAndCall( + address(opcm.implementations().delayedWETHImpl), + abi.encodeCall(IDelayedWETH.initialize, (chainDeployOutput1.systemConfigProxy)) ); - vm.etch(address(delayedWETH), hex"01"); IOPContractsManager.AddGameInput memory input = newGameInputFactory(GameTypes.CANNON); input.delayedWETH = delayedWETH; IOPContractsManager.AddGameOutput memory output = addGameType(input); @@ -790,48 +850,50 @@ contract OPContractsManager_AddGameType_Test is OPContractsManager_TestInit { IOPContractsManager.AddGameOutput memory ago ) internal - view + returns (IFaultDisputeGame) { - // Check the config for the game itself - assertEq(ago.faultDisputeGame.gameType().raw(), agi.disputeGameType.raw(), "gameType mismatch"); - assertEq( - ago.faultDisputeGame.absolutePrestate().raw(), - agi.disputeAbsolutePrestate.raw(), - "absolutePrestate mismatch" - ); - assertEq(ago.faultDisputeGame.maxGameDepth(), agi.disputeMaxGameDepth, "maxGameDepth mismatch"); - assertEq(ago.faultDisputeGame.splitDepth(), agi.disputeSplitDepth, "splitDepth mismatch"); - assertEq( - ago.faultDisputeGame.clockExtension().raw(), agi.disputeClockExtension.raw(), "clockExtension mismatch" + // Create a game so we can assert on game args which aren't baked into the implementation contract + Claim claim = Claim.wrap(bytes32(uint256(9876))); + uint256 l2SequenceNumber = uint256(123); + IFaultDisputeGame game = IFaultDisputeGame( + payable( + createGame( + chainDeployOutput1.disputeGameFactoryProxy, agi.disputeGameType, proposer, claim, l2SequenceNumber + ) + ) ); + + // Verify immutable fields on the game proxy + assertEq(game.gameType().raw(), agi.disputeGameType.raw(), "Game type should match"); + assertEq(game.clockExtension().raw(), agi.disputeClockExtension.raw(), "Clock extension should match"); + assertEq(game.maxClockDuration().raw(), agi.disputeMaxClockDuration.raw(), "Max clock duration should match"); + assertEq(game.splitDepth(), agi.disputeSplitDepth, "Split depth should match"); + assertEq(game.maxGameDepth(), agi.disputeMaxGameDepth, "Max game depth should match"); + assertEq(game.gameCreator(), proposer, "Game creator should match"); + assertEq(game.rootClaim().raw(), claim.raw(), "Claim should match"); + assertEq(game.l1Head().raw(), blockhash(block.number - 1), "L1 head should match"); + assertEq(game.l2SequenceNumber(), l2SequenceNumber, "L2 sequence number should match"); assertEq( - ago.faultDisputeGame.maxClockDuration().raw(), - agi.disputeMaxClockDuration.raw(), - "maxClockDuration mismatch" + game.absolutePrestate().raw(), agi.disputeAbsolutePrestate.raw(), "Absolute prestate should match input" ); - assertEq(address(ago.faultDisputeGame.vm()), address(agi.vm), "vm address mismatch"); - assertEq(address(ago.faultDisputeGame.weth()), address(ago.delayedWETH), "delayedWETH address mismatch"); + assertEq(address(game.vm()), address(agi.vm), "VM should match MIPS implementation"); assertEq( - address(ago.faultDisputeGame.anchorStateRegistry()), + address(game.anchorStateRegistry()), address(chainDeployOutput1.anchorStateRegistryProxy), - "ASR address mismatch" + "ASR should match" ); + assertEq(address(game.weth()), address(ago.delayedWETH), "WETH should match"); // Check the DGF - assertEq( - chainDeployOutput1.disputeGameFactoryProxy.gameImpls(agi.disputeGameType).gameType().raw(), - agi.disputeGameType.raw(), - "gameType mismatch" - ); assertEq( address(chainDeployOutput1.disputeGameFactoryProxy.gameImpls(agi.disputeGameType)), address(ago.faultDisputeGame), "gameImpl address mismatch" ); - assertEq(address(ago.faultDisputeGame.weth()), address(ago.delayedWETH), "weth address mismatch"); assertEq( chainDeployOutput1.disputeGameFactoryProxy.initBonds(agi.disputeGameType), agi.initialBond, "bond mismatch" ); + return game; } /// @notice Tests that addGameType will revert if the game type is cannon-kona and the dev feature is not enabled @@ -842,10 +904,10 @@ contract OPContractsManager_AddGameType_Test is OPContractsManager_TestInit { // Run the addGameType call. IOPContractsManager.AddGameOutput memory output = addGameType(input); - assertValidGameType(input, output); + IFaultDisputeGame game = assertValidGameType(input, output); // Check the values on the new game type. - IPermissionedDisputeGame notPDG = IPermissionedDisputeGame(address(output.faultDisputeGame)); + IPermissionedDisputeGame notPDG = IPermissionedDisputeGame(address(game)); // Proposer call should revert because this is a permissionless game. vm.expectRevert(); // nosemgrep: sol-safety-expectrevert-no-args @@ -1589,7 +1651,7 @@ contract OPContractsManager_Migrate_Test is OPContractsManager_TestInit { Claim absolutePrestate2 = Claim.wrap(bytes32(hex"DEAD")); /// @notice Function requires interop portal. - function setUp() public virtual override { + function setUp() public override { super.setUp(); skipIfDevFeatureDisabled(DevFeatures.OPTIMISM_PORTAL_INTEROP); } @@ -1992,11 +2054,9 @@ contract OPContractsManager_Migrate_Test is OPContractsManager_TestInit { /// the existing test setup to deploy OPContractsManager. We do however inherit from /// DeployOPChain_TestBase so we can use its setup to deploy the implementations similarly /// to how a real deployment would happen. -contract OPContractsManager_Deploy_Test is DeployOPChain_TestBase { +contract OPContractsManager_Deploy_Test is DeployOPChain_TestBase, DisputeGames { using stdStorage for StdStorage; - event Deployed(uint256 indexed l2ChainId, address indexed deployer, bytes deployOutput); - // This helper function is used to convert the input struct type defined in DeployOPChain.s.sol // to the input struct type defined in OPContractsManager.sol. function toOPCMDeployInput(Types.DeployOPChainInput memory _doi) @@ -2028,35 +2088,6 @@ contract OPContractsManager_Deploy_Test is DeployOPChain_TestBase { }); } - /// @notice Helper function to create a permissioned game through the factory - function _createPermissionedGame( - IDisputeGameFactory factory, - address proposer, - Claim claim, - uint256 l2BlockNumber - ) - internal - returns (IPermissionedDisputeGame) - { - // Check if there's an init bond required for the game type - uint256 initBond = factory.initBonds(GameTypes.PERMISSIONED_CANNON); - - // Fund the proposer if needed - if (initBond > 0) { - vm.deal(proposer, initBond); - } - - // We use vm.startPrank to set both msg.sender and tx.origin to the proposer - vm.startPrank(proposer, proposer); - - IDisputeGame gameProxy = - factory.create{ value: initBond }(GameTypes.PERMISSIONED_CANNON, claim, abi.encode(bytes32(l2BlockNumber))); - - vm.stopPrank(); - - return IPermissionedDisputeGame(address(gameProxy)); - } - function test_deploy_l2ChainIdEqualsZero_reverts() public { IOPContractsManager.DeployInput memory input = toOPCMDeployInput(deployOPChainInput); input.l2ChainId = 0; @@ -2108,8 +2139,17 @@ contract OPContractsManager_Deploy_Test is DeployOPChain_TestBase { // Create a game proxy to test immutable fields Claim claim = Claim.wrap(bytes32(uint256(9876))); uint256 l2BlockNumber = uint256(123); - IPermissionedDisputeGame pdg = - _createPermissionedGame(opcmOutput.disputeGameFactoryProxy, opcmInput.roles.proposer, claim, l2BlockNumber); + IPermissionedDisputeGame pdg = IPermissionedDisputeGame( + payable( + createGame( + opcmOutput.disputeGameFactoryProxy, + GameTypes.PERMISSIONED_CANNON, + opcmInput.roles.proposer, + claim, + l2BlockNumber + ) + ) + ); // Verify immutable fields on the game proxy // Constructor args diff --git a/packages/contracts-bedrock/test/opcm/DeployOPChain.t.sol b/packages/contracts-bedrock/test/opcm/DeployOPChain.t.sol index 4c6c7667066..d8e48aadeaa 100644 --- a/packages/contracts-bedrock/test/opcm/DeployOPChain.t.sol +++ b/packages/contracts-bedrock/test/opcm/DeployOPChain.t.sol @@ -59,6 +59,8 @@ contract DeployOPChain_TestBase is Test, FeatureFlags { Duration disputeMaxClockDuration = Duration.wrap(3.5 days); IOPContractsManager opcm; + event Deployed(uint256 indexed l2ChainId, address indexed deployer, bytes deployOutput); + function setUp() public virtual { resolveFeaturesFromEnv(); deploySuperchain = new DeploySuperchain(); diff --git a/packages/contracts-bedrock/test/setup/DisputeGames.sol b/packages/contracts-bedrock/test/setup/DisputeGames.sol new file mode 100644 index 00000000000..778a5c45591 --- /dev/null +++ b/packages/contracts-bedrock/test/setup/DisputeGames.sol @@ -0,0 +1,49 @@ +// SPDX-License-Identifier: MIT +pragma solidity 0.8.15; + +// Testing +import { Vm } from "forge-std/Vm.sol"; +import { console2 as console } from "forge-std/console2.sol"; + +// Libraries +import { GameType, Claim } from "src/dispute/lib/LibUDT.sol"; + +// Interfaces +import "../../interfaces/dispute/IDisputeGame.sol"; +import "../../interfaces/dispute/IDisputeGameFactory.sol"; + +contract DisputeGames { + /// @notice The address of the foundry Vm contract. + Vm private constant vm = Vm(0x7109709ECfa91a80626fF3989D68f67F5b1DD12D); + + /// @notice Helper function to create a permissioned game through the factory + function createGame( + IDisputeGameFactory _factory, + GameType _gameType, + address _proposer, + Claim _claim, + uint256 _l2BlockNumber + ) + internal + returns (address) + { + // Check if there's an init bond required for the game type + uint256 initBond = _factory.initBonds(_gameType); + console.log("Init bond", initBond); + + // Fund the proposer if needed + if (initBond > 0) { + vm.deal(_proposer, initBond); + } + + // We use vm.startPrank to set both msg.sender and tx.origin to the proposer + vm.startPrank(_proposer, _proposer); + + IDisputeGame gameProxy = + _factory.create{ value: initBond }(_gameType, _claim, abi.encode(bytes32(_l2BlockNumber))); + + vm.stopPrank(); + + return address(gameProxy); + } +} From 7b570304f20a395a711fe1542312d2311fcc599b Mon Sep 17 00:00:00 2001 From: Maurelian Date: Tue, 21 Oct 2025 16:44:23 -0400 Subject: [PATCH 107/117] Update contracts release documentation (#17719) * Remove empty code-freezes page * Add release-process.md * Update packages/contracts-bedrock/book/src/policies/release-process.md Co-authored-by: graphite-app[bot] <96075541+graphite-app[bot]@users.noreply.github.com> * Apply suggestions from code review Co-authored-by: Matt Solomon * Update packages/contracts-bedrock/book/src/policies/release-process.md * Update packages/contracts-bedrock/book/src/policies/release-process.md * Update packages/contracts-bedrock/book/src/SUMMARY.md Co-authored-by: graphite-app[bot] <96075541+graphite-app[bot]@users.noreply.github.com> * Use real numbers in
      * Update release-process.md * Clarify that semver bump on develop applies to modified contracts Co-authored-by: George Knee --------- Co-authored-by: graphite-app[bot] <96075541+graphite-app[bot]@users.noreply.github.com> Co-authored-by: Matt Solomon Co-authored-by: George Knee --- .../contracts-bedrock/book/src/SUMMARY.md | 6 ++- .../book/src/contributing/code-freezes.md | 1 - .../book/src/policies/release-process.md | 53 +++++++++++++++++++ .../book/src/policies/versioning.md | 38 ------------- 4 files changed, 57 insertions(+), 41 deletions(-) delete mode 100644 packages/contracts-bedrock/book/src/contributing/code-freezes.md create mode 100644 packages/contracts-bedrock/book/src/policies/release-process.md diff --git a/packages/contracts-bedrock/book/src/SUMMARY.md b/packages/contracts-bedrock/book/src/SUMMARY.md index 9fa9538ae2a..f36eafb59ec 100644 --- a/packages/contracts-bedrock/book/src/SUMMARY.md +++ b/packages/contracts-bedrock/book/src/SUMMARY.md @@ -11,5 +11,7 @@ # Policies - [Solidity Upgrades](./policies/solidity-upgrades.md) -- [Code Freezes](./policies/code-freezes.md) -- [Versioning](./policies/versioning.md) \ No newline at end of file + +- [Versioning](./policies/versioning.md) +- [Tagging and Release Process](./policies/release-process.md) + diff --git a/packages/contracts-bedrock/book/src/contributing/code-freezes.md b/packages/contracts-bedrock/book/src/contributing/code-freezes.md deleted file mode 100644 index 9b49560dae8..00000000000 --- a/packages/contracts-bedrock/book/src/contributing/code-freezes.md +++ /dev/null @@ -1 +0,0 @@ -# Code Freezes diff --git a/packages/contracts-bedrock/book/src/policies/release-process.md b/packages/contracts-bedrock/book/src/policies/release-process.md new file mode 100644 index 00000000000..3042aa37e06 --- /dev/null +++ b/packages/contracts-bedrock/book/src/policies/release-process.md @@ -0,0 +1,53 @@ +# Tagging and Release Process + +## Creating a tagged release + +First select a tag string based on the guidance in [Monorepo Contracts Release Versioning](./versioning.md#monorepo-contracts-release-versioning) + +1. Checkout the commit +2. Run `git tag ` +3. Run `git push origin ` + Repo [rules](https://github.com/ethereum-optimism/optimism/rules/8196346?ref=refs%2Ftags%2Fop-contracts) require this is done by someone who is a [release-manager](https://github.com/orgs/ethereum-optimism/teams/release-managers). Once pushed a tag cannot be deleted, so please be sure it is correct. +1. Create release notes in Github: + - Go to the [Releases page](https://github.com/ethereum-optimism/optimism/releases), enter or select `` + from the dropdown. +1. Populate the release notes. If the tag is a release candidate, check the `Set as a pre-release` option, and uncheck the + `Set as the latest release` option. +1. Deploy the OPCM using the `op-deployer bootstrap implementations` [command](https://devdocs.optimism.io/op-deployer/user-guide/bootstrap.html), + this will write the addresses of the deployed contracts to `stdout` (or to disk if you provide an `--outfile` argument). + Do this on both Sepolia and Mainnet. +1. In the superchain-registry edit the following files to add a new `[]` entry, with the addresses from the + previous step: + - [standard-versions-mainnet.toml](https://github.com/ethereum-optimism/superchain-registry/blob/main/validation/standard/standard-versions-mainnet.toml) + - [standard-versions-sepolia.toml](https://github.com/ethereum-optimism/superchain-registry/blob/main/validation/standard/standard-versions-sepolia.toml) +1. Once the changes are merged into the superchain-registry, you can follow the [instructions](https://devdocs.optimism.io/op-deployer/reference-guide/releases.html#step-3-update-the-sr-with-the-new-release) + for creating a new release of `op-deployer`. + +## Implications for audits + +The process above should be followed to create an `-rc.1` release prior to audit. This will be the target commit for +the audit. If any fixes are required by the audit results an Additional Release Candidate will be required. + +## Additional Release Candidates + +Sometimes fixes or additional changes need to be added to a release candidate version. In that case +we want to ensure fixes are made on both the release and the trunk branch, without stopping development +efforts on the trunk branch. + +The process is as follows: + +1. Make the fixes on `develop`. Increment the contracts semver as normal. +1. Create a new release branch, named `proposal/op-contracts/vX.Y.Z` off of the rc tag (all subsequent `-rc` tags + will be made from this branch). +1. Cherry pick the fixes from `develop` into the release branch, and increment the semver as normal. If this increment results in any of the modified contracts' semver being equal to or greater than it is on `develop`, then the semver should immediately be increased on `develop` to be greater than on the release branch. This avoids a situation where a given contract has two different implementations with the same version. +1. After merging the changes into the new release branch, tag the resulting commit on the proposal branch as `op-contracts/vX.Y.Z-rc.n`. + Create a new release for this tag per the instructions above. + +## Finalizing a release + +Once a release has passed governance, a new tag should be created without the `-rc.n` suffix. To do this follow the +instructions in "Creating a tagged release" once again. It should not be necessary to redeploy the contracts with `op-deployer`, +but a new entry will be required in the superchain-registry's toml files regardless. +When creating release notes, _uncheck_ the `Set as a pre-release` option, and _uncheck_ the + `Set as the latest release` option (latest releases are reserved for non-contract packages). + diff --git a/packages/contracts-bedrock/book/src/policies/versioning.md b/packages/contracts-bedrock/book/src/policies/versioning.md index 53b988d7212..c40f16d79cf 100644 --- a/packages/contracts-bedrock/book/src/policies/versioning.md +++ b/packages/contracts-bedrock/book/src/policies/versioning.md @@ -79,41 +79,3 @@ Versioning for monorepo releases works as follows: The [OPCM](https://github.com/ethereum-optimism/optimism/blob/develop/packages/contracts-bedrock/src/L1/OPContractsManager.sol) is the contract that manages the deployment of all contracts on L1. The `OPCM` is the source of truth for the contracts that belong in a release, available as on-chain addresses by querying [the `getImplementations` function](https://github.com/ethereum-optimism/optimism/blob/4c8764f0453e141555846d8c9dd2af9edbc1d014/packages/contracts-bedrock/src/L1/OPContractsManager.sol#L1061). - -## Release Process - -When a release is proposed to governance, the proposal includes a commit hash, and often the -contracts from that commit hash are already deployed to mainnet with their addresses included -in the proposal. -For example, the [Fault Proofs governance proposal](https://gov.optimism.io/t/upgrade-proposal-fault-proofs/8161) provides specific addresses that will be used. - -To accommodate this, once contract changes are ready for governance approval, the release flow is: - -1. Go to https://github.com/ethereum-optimism/optimism/releases/new -2. Enter the release title as `op-contracts/vX.Y.Z-rc.1` -3. In the "choose a tag" dropdown, enter the same `op-contracts/vX.Y.Z-rc.1` and click the "Create new tag" option that shows up -4. Populate the release notes. -5. Check "set as pre-release" since it's not yet governance approved -6. Uncheck "Set as the latest release" and "Create a discussion for this release". -7. Click publish release. -8. After governance vote passes, edit the release to uncheck "set as pre-release", and remove the `-rc.1` tag. - -Although the tools exist to apply a [code freeze](./code-freezes.md) to specific contracts, this is -discouraged. If a change is required to a release candidate after it has been tagged, the -[Additional Release Candidates](#additional-release-candidates) for more information on this flow. - -### Additional Release Candidates - -Sometimes fixes or additional changes need to be added to a release candidate version. In that case -we want to ensure fixes are made on both the release and the trunk branch, without stopping development -efforts on the trunk branch. - -The process is as follows: - -1. Make the fixes on `develop`. Increment the contracts semver as normal. -2. Create a new release branch, named `proposal/op-contracts/X.Y.Z` off of the rc tag. -3. Cherry pick the fixes from `develop` into that branch. Instead of incrementing the semver as normal, - append `-patch.n` to the end of the version number. The value of `n` should start at 1 and be - incremented for each additional patch. -4. After merging the changes into the new release branch, tag the resulting commit on the proposal branch as `op-contracts/vX.Y.Z-rc.n`. - Create a new release for this tag per the instructions above. From cca18bc5f3f0a2641a858a75f44ecaaec10c8f65 Mon Sep 17 00:00:00 2001 From: Sam Stokes <35908605+bitwiseguy@users.noreply.github.com> Date: Tue, 21 Oct 2025 17:09:16 -0400 Subject: [PATCH 108/117] op-node: revive async block processing timing log (#17915) * op-node: revive async block processing timing log * op-node: add clarifying comments to logBlockProcessingMetrics --- op-node/rollup/engine/payload_success.go | 43 ++++++++++++++++++++++++ 1 file changed, 43 insertions(+) diff --git a/op-node/rollup/engine/payload_success.go b/op-node/rollup/engine/payload_success.go index 6cb6d356254..ad270fb3648 100644 --- a/op-node/rollup/engine/payload_success.go +++ b/op-node/rollup/engine/payload_success.go @@ -5,6 +5,7 @@ import ( "time" "github.com/ethereum-optimism/optimism/op-service/eth" + "github.com/ethereum/go-ethereum/common" ) type PayloadSuccessEvent struct { @@ -51,5 +52,47 @@ func (e *EngineController) onPayloadSuccess(ctx context.Context, ev PayloadSucce err := e.tryUpdateEngineInternal(ctx) if err != nil { e.log.Error("Failed to update engine", "error", err) + } else { + updateEngineFinish := time.Now() + e.logBlockProcessingMetrics(updateEngineFinish, ev) } } + +func (e *EngineController) logBlockProcessingMetrics(updateEngineFinish time.Time, ev PayloadSuccessEvent) { + // Protect against nil pointer dereferences + if ev.Envelope == nil || ev.Envelope.ExecutionPayload == nil { + e.log.Info("Envelope.ExecutionPayload not found, skipping block processing metrics") + return + } + + mgas := float64(ev.Envelope.ExecutionPayload.GasUsed) / 1e6 + buildTime := time.Duration(0) + insertTime := updateEngineFinish.Sub(ev.InsertStarted) + totalTime := insertTime + + // BuildStarted may be zero if sequencer already built + gossiped a block, but failed during + // insertion and needed a retry of the insertion. In that case we use the default values above, + // otherwise we calculate buildTime and totalTime below + if !ev.BuildStarted.IsZero() { + buildTime = ev.InsertStarted.Sub(ev.BuildStarted) + totalTime = updateEngineFinish.Sub(ev.BuildStarted) + } + + // Protect against divide-by-zero + var mgasps float64 // Mgas/s + if totalTime > 0 { + // Calculate "block-processing" Mgas/s. + // NOTE: "realtime" mgasps (chain throughput) is a different calculation: (GasUsed / blockPeriod) + mgasps = mgas / totalTime.Seconds() + } + + e.log.Info("Inserted new L2 unsafe block", + "hash", ev.Envelope.ExecutionPayload.BlockHash, + "number", uint64(ev.Envelope.ExecutionPayload.BlockNumber), + "build_time", common.PrettyDuration(buildTime), + "insert_time", common.PrettyDuration(insertTime), + "total_time", common.PrettyDuration(totalTime), + "mgas", mgas, + "mgasps", mgasps, + ) +} From 4889b660c06ee24e969eb2ef091ec57f3c3aeac2 Mon Sep 17 00:00:00 2001 From: Matt Solomon Date: Tue, 21 Oct 2025 15:05:08 -0700 Subject: [PATCH 109/117] fix: update cache paths, and make sure to save cache (#17968) --- .circleci/config.yml | 14 ++++++++++---- 1 file changed, 10 insertions(+), 4 deletions(-) diff --git a/.circleci/config.yml b/.circleci/config.yml index 0462226fa0a..3abe9729989 100644 --- a/.circleci/config.yml +++ b/.circleci/config.yml @@ -896,7 +896,7 @@ jobs: name: Save Go build cache key: golang-build-cache-contracts-bedrock-tests-{{ checksum "go.sum" }} paths: - - "/root/.cache/go-build" + - "~/.cache/go-build" - notify-failures-on-develop contracts-bedrock-heavy-fuzz-nightly: @@ -940,7 +940,7 @@ jobs: name: Save Go build cache key: golang-build-cache-contracts-bedrock-heavy-fuzz-{{ checksum "go.sum" }} paths: - - "/root/.cache/go-build" + - "~/.cache/go-build" - notify-failures-on-develop # AI Contracts Test Maintenance System @@ -1061,6 +1061,12 @@ jobs: disable_search: true files: ./packages/contracts-bedrock/lcov-all.info flags: contracts-bedrock-tests + - save_cache: + name: Save forked state + key: forked-state-contracts-bedrock-tests-upgrade-{{ checksum "packages/contracts-bedrock/pinnedBlockNumber.txt" }} + when: always + paths: + - "~/.foundry/cache" - store_artifacts: path: packages/contracts-bedrock/failed-test-traces.log when: on_fail @@ -1139,13 +1145,13 @@ jobs: name: Save Go build cache key: golang-build-cache-contracts-bedrock-tests-{{ checksum "go.sum" }} paths: - - "/root/.cache/go-build" + - "~/.cache/go-build" - save_cache: name: Save forked state key: forked-state-contracts-bedrock-tests-upgrade-<>-<>-{{ checksum "packages/contracts-bedrock/pinnedBlockNumber.txt" }} when: always paths: - - "/root/.foundry/cache" + - "~/.foundry/cache" - store_artifacts: path: packages/contracts-bedrock/failed-test-traces.log when: on_fail From a3f885098392543d0962013bb6c7311d26cb1669 Mon Sep 17 00:00:00 2001 From: Adrian Sutton Date: Wed, 22 Oct 2025 09:05:24 +1000 Subject: [PATCH 110/117] op-challenger: Support retrieving the oracle and prestate via game args. (#17958) The implementation contract doesn't always have the values embedded. --- .../tests/base/disputegame_v2/init_test.go | 4 +- .../tests/base/disputegame_v2/smoke_test.go | 7 +- op-chain-ops/cmd/unclaimed-credits/main.go | 5 +- op-challenger/cmd/create_game.go | 2 +- op-challenger/cmd/list_games.go | 5 +- .../abis/DisputeGameFactory-1.2.0.json | 526 ++++++++++++++++ .../game/fault/contracts/gameargs/gameargs.go | 68 +++ .../fault/contracts/gameargs/gameargs_test.go | 67 +++ .../game/fault/contracts/gamefactory.go | 103 +++- .../game/fault/contracts/gamefactory_test.go | 569 +++++++++++------- op-challenger/game/fault/register_task.go | 17 +- .../game/fault/register_task_test.go | 152 +++-- op-challenger/game/service.go | 9 +- op-challenger/runner/prestates.go | 16 +- op-dispute-mon/mon/service.go | 9 +- op-e2e/interop/interop_test.go | 3 +- 16 files changed, 1278 insertions(+), 284 deletions(-) create mode 100644 op-challenger/game/fault/contracts/abis/DisputeGameFactory-1.2.0.json create mode 100644 op-challenger/game/fault/contracts/gameargs/gameargs.go create mode 100644 op-challenger/game/fault/contracts/gameargs/gameargs_test.go diff --git a/op-acceptance-tests/tests/base/disputegame_v2/init_test.go b/op-acceptance-tests/tests/base/disputegame_v2/init_test.go index c7c2a440c95..2b3ef1852e9 100644 --- a/op-acceptance-tests/tests/base/disputegame_v2/init_test.go +++ b/op-acceptance-tests/tests/base/disputegame_v2/init_test.go @@ -7,7 +7,5 @@ import ( ) func TestMain(m *testing.M) { - // TODO(#17810): Use the new v2 dispute game flag via presets.WithDisputeGameV2() - //presets.DoMain(m, presets.WithProofs(), presets.WithDisputeGameV2()) - presets.DoMain(m, presets.WithProofs()) + presets.DoMain(m, presets.WithProofs(), presets.WithDisputeGameV2()) } diff --git a/op-acceptance-tests/tests/base/disputegame_v2/smoke_test.go b/op-acceptance-tests/tests/base/disputegame_v2/smoke_test.go index 0646fc06d96..8509a22a85f 100644 --- a/op-acceptance-tests/tests/base/disputegame_v2/smoke_test.go +++ b/op-acceptance-tests/tests/base/disputegame_v2/smoke_test.go @@ -3,13 +3,13 @@ package disputegame_v2 import ( "testing" + "github.com/ethereum-optimism/optimism/op-challenger/game/fault/contracts/gameargs" challengerTypes "github.com/ethereum-optimism/optimism/op-challenger/game/fault/types" "github.com/ethereum-optimism/optimism/op-devstack/devtest" "github.com/ethereum-optimism/optimism/op-devstack/presets" ) func TestSmoke(gt *testing.T) { - gt.Skip("TODO(#17810): Re-enable once opcm.deploy supports v2 dispute games") t := devtest.SerialT(gt) sys := presets.NewMinimal(t) require := t.Require() @@ -17,8 +17,13 @@ func TestSmoke(gt *testing.T) { gameArgs := dgf.GameArgs(challengerTypes.PermissionedGameType) require.NotEmpty(gameArgs, "game args is must be set for permissioned v2 dispute games") + _, err := gameargs.Parse(gameArgs) + require.NoError(err, "Permissioned game args invalid") + gameArgs = dgf.GameArgs(challengerTypes.CannonGameType) require.NotEmpty(gameArgs, "game args is must be set for cannon v2 dispute games") + _, err = gameargs.Parse(gameArgs) + require.NoError(err, "Permissionless game args invalid") permissionedGame := dgf.GameImpl(challengerTypes.PermissionedGameType) require.NotEmpty(permissionedGame.Address, "permissioned game impl must be set") diff --git a/op-chain-ops/cmd/unclaimed-credits/main.go b/op-chain-ops/cmd/unclaimed-credits/main.go index 079934a1204..8c208264c25 100644 --- a/op-chain-ops/cmd/unclaimed-credits/main.go +++ b/op-chain-ops/cmd/unclaimed-credits/main.go @@ -72,7 +72,10 @@ func unclaimedCreditsApp(ctx *cli.Context) error { defer l1Client.Close() caller := batching.NewMultiCaller(l1Client.Client(), batching.DefaultBatchSize) - contract := contracts.NewDisputeGameFactoryContract(metrics.NoopContractMetrics, factoryAddr, caller) + contract, err := contracts.NewDisputeGameFactoryContract(ctx.Context, metrics.NoopContractMetrics, factoryAddr, caller) + if err != nil { + return fmt.Errorf("failed to create dispute game factory contract: %w", err) + } head, err := l1Client.HeaderByNumber(ctx.Context, nil) if err != nil { return fmt.Errorf("failed to retrieve current head block: %w", err) diff --git a/op-challenger/cmd/create_game.go b/op-challenger/cmd/create_game.go index 1103df58c20..073ecff1959 100644 --- a/op-challenger/cmd/create_game.go +++ b/op-challenger/cmd/create_game.go @@ -43,7 +43,7 @@ func CreateGame(ctx *cli.Context) error { contract, txMgr, err := NewContractWithTxMgr[*contracts.DisputeGameFactoryContract](ctx, flags.FactoryAddress, func(ctx context.Context, metricer contractMetrics.ContractMetricer, address common.Address, caller *batching.MultiCaller) (*contracts.DisputeGameFactoryContract, error) { - return contracts.NewDisputeGameFactoryContract(metricer, address, caller), nil + return contracts.NewDisputeGameFactoryContract(ctx, metricer, address, caller) }) if err != nil { return fmt.Errorf("failed to create dispute game factory bindings: %w", err) diff --git a/op-challenger/cmd/list_games.go b/op-challenger/cmd/list_games.go index 5f151f71ca4..a9047605088 100644 --- a/op-challenger/cmd/list_games.go +++ b/op-challenger/cmd/list_games.go @@ -71,7 +71,10 @@ func ListGames(ctx *cli.Context) error { defer l1Client.Close() caller := batching.NewMultiCaller(l1Client.Client(), batching.DefaultBatchSize) - contract := contracts.NewDisputeGameFactoryContract(metrics.NoopContractMetrics, factoryAddr, caller) + contract, err := contracts.NewDisputeGameFactoryContract(ctx.Context, metrics.NoopContractMetrics, factoryAddr, caller) + if err != nil { + return fmt.Errorf("failed to create dispute game factory contract: %w", err) + } head, err := l1Client.HeaderByNumber(ctx.Context, nil) if err != nil { return fmt.Errorf("failed to retrieve current head block: %w", err) diff --git a/op-challenger/game/fault/contracts/abis/DisputeGameFactory-1.2.0.json b/op-challenger/game/fault/contracts/abis/DisputeGameFactory-1.2.0.json new file mode 100644 index 00000000000..c8f46a54873 --- /dev/null +++ b/op-challenger/game/fault/contracts/abis/DisputeGameFactory-1.2.0.json @@ -0,0 +1,526 @@ +[ + { + "inputs": [], + "stateMutability": "nonpayable", + "type": "constructor" + }, + { + "inputs": [ + { + "internalType": "GameType", + "name": "_gameType", + "type": "uint32" + }, + { + "internalType": "Claim", + "name": "_rootClaim", + "type": "bytes32" + }, + { + "internalType": "bytes", + "name": "_extraData", + "type": "bytes" + } + ], + "name": "create", + "outputs": [ + { + "internalType": "contract IDisputeGame", + "name": "proxy_", + "type": "address" + } + ], + "stateMutability": "payable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "GameType", + "name": "_gameType", + "type": "uint32" + }, + { + "internalType": "uint256", + "name": "_start", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "_n", + "type": "uint256" + } + ], + "name": "findLatestGames", + "outputs": [ + { + "components": [ + { + "internalType": "uint256", + "name": "index", + "type": "uint256" + }, + { + "internalType": "GameId", + "name": "metadata", + "type": "bytes32" + }, + { + "internalType": "Timestamp", + "name": "timestamp", + "type": "uint64" + }, + { + "internalType": "Claim", + "name": "rootClaim", + "type": "bytes32" + }, + { + "internalType": "bytes", + "name": "extraData", + "type": "bytes" + } + ], + "internalType": "struct DisputeGameFactory.GameSearchResult[]", + "name": "games_", + "type": "tuple[]" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "_index", + "type": "uint256" + } + ], + "name": "gameAtIndex", + "outputs": [ + { + "internalType": "GameType", + "name": "gameType_", + "type": "uint32" + }, + { + "internalType": "Timestamp", + "name": "timestamp_", + "type": "uint64" + }, + { + "internalType": "contract IDisputeGame", + "name": "proxy_", + "type": "address" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [], + "name": "gameCount", + "outputs": [ + { + "internalType": "uint256", + "name": "gameCount_", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "GameType", + "name": "", + "type": "uint32" + } + ], + "name": "gameImpls", + "outputs": [ + { + "internalType": "contract IDisputeGame", + "name": "", + "type": "address" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "GameType", + "name": "_gameType", + "type": "uint32" + }, + { + "internalType": "Claim", + "name": "_rootClaim", + "type": "bytes32" + }, + { + "internalType": "bytes", + "name": "_extraData", + "type": "bytes" + } + ], + "name": "games", + "outputs": [ + { + "internalType": "contract IDisputeGame", + "name": "proxy_", + "type": "address" + }, + { + "internalType": "Timestamp", + "name": "timestamp_", + "type": "uint64" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "GameType", + "name": "_gameType", + "type": "uint32" + }, + { + "internalType": "Claim", + "name": "_rootClaim", + "type": "bytes32" + }, + { + "internalType": "bytes", + "name": "_extraData", + "type": "bytes" + } + ], + "name": "getGameUUID", + "outputs": [ + { + "internalType": "Hash", + "name": "uuid_", + "type": "bytes32" + } + ], + "stateMutability": "pure", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "GameType", + "name": "", + "type": "uint32" + } + ], + "name": "initBonds", + "outputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [], + "name": "initVersion", + "outputs": [ + { + "internalType": "uint8", + "name": "", + "type": "uint8" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "_owner", + "type": "address" + } + ], + "name": "initialize", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [], + "name": "owner", + "outputs": [ + { + "internalType": "address", + "name": "", + "type": "address" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [], + "name": "proxyAdmin", + "outputs": [ + { + "internalType": "contract IProxyAdmin", + "name": "", + "type": "address" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [], + "name": "proxyAdminOwner", + "outputs": [ + { + "internalType": "address", + "name": "", + "type": "address" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [], + "name": "renounceOwnership", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "GameType", + "name": "_gameType", + "type": "uint32" + }, + { + "internalType": "contract IDisputeGame", + "name": "_impl", + "type": "address" + } + ], + "name": "setImplementation", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "GameType", + "name": "_gameType", + "type": "uint32" + }, + { + "internalType": "uint256", + "name": "_initBond", + "type": "uint256" + } + ], + "name": "setInitBond", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "newOwner", + "type": "address" + } + ], + "name": "transferOwnership", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [], + "name": "version", + "outputs": [ + { + "internalType": "string", + "name": "", + "type": "string" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "address", + "name": "disputeProxy", + "type": "address" + }, + { + "indexed": true, + "internalType": "GameType", + "name": "gameType", + "type": "uint32" + }, + { + "indexed": true, + "internalType": "Claim", + "name": "rootClaim", + "type": "bytes32" + } + ], + "name": "DisputeGameCreated", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "address", + "name": "impl", + "type": "address" + }, + { + "indexed": true, + "internalType": "GameType", + "name": "gameType", + "type": "uint32" + } + ], + "name": "ImplementationSet", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "GameType", + "name": "gameType", + "type": "uint32" + }, + { + "indexed": true, + "internalType": "uint256", + "name": "newBond", + "type": "uint256" + } + ], + "name": "InitBondUpdated", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": false, + "internalType": "uint8", + "name": "version", + "type": "uint8" + } + ], + "name": "Initialized", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "address", + "name": "previousOwner", + "type": "address" + }, + { + "indexed": true, + "internalType": "address", + "name": "newOwner", + "type": "address" + } + ], + "name": "OwnershipTransferred", + "type": "event" + }, + { + "inputs": [ + { + "internalType": "Hash", + "name": "uuid", + "type": "bytes32" + } + ], + "name": "GameAlreadyExists", + "type": "error" + }, + { + "inputs": [], + "name": "IncorrectBondAmount", + "type": "error" + }, + { + "inputs": [ + { + "internalType": "GameType", + "name": "gameType", + "type": "uint32" + } + ], + "name": "NoImplementation", + "type": "error" + }, + { + "inputs": [], + "name": "ProxyAdminOwnedBase_NotProxyAdmin", + "type": "error" + }, + { + "inputs": [], + "name": "ProxyAdminOwnedBase_NotProxyAdminOrProxyAdminOwner", + "type": "error" + }, + { + "inputs": [], + "name": "ProxyAdminOwnedBase_NotProxyAdminOwner", + "type": "error" + }, + { + "inputs": [], + "name": "ProxyAdminOwnedBase_NotResolvedDelegateProxy", + "type": "error" + }, + { + "inputs": [], + "name": "ProxyAdminOwnedBase_NotSharedProxyAdminOwner", + "type": "error" + }, + { + "inputs": [], + "name": "ProxyAdminOwnedBase_ProxyAdminNotFound", + "type": "error" + }, + { + "inputs": [], + "name": "ReinitializableBase_ZeroInitVersion", + "type": "error" + } +] diff --git a/op-challenger/game/fault/contracts/gameargs/gameargs.go b/op-challenger/game/fault/contracts/gameargs/gameargs.go new file mode 100644 index 00000000000..78e2e7f0e1c --- /dev/null +++ b/op-challenger/game/fault/contracts/gameargs/gameargs.go @@ -0,0 +1,68 @@ +package gameargs + +import ( + "errors" + "fmt" + "slices" + + "github.com/ethereum-optimism/optimism/op-service/eth" + "github.com/ethereum/go-ethereum/common" +) + +const ( + PermissionlessArgsLength = 124 + PermissionedArgsLength = 164 +) + +var ( + ErrInvalidGameArgs = errors.New("invalid game args") +) + +type GameArgs struct { + AbsolutePrestate common.Hash + Vm common.Address + AnchorStateRegistry common.Address + Weth common.Address + L2ChainID eth.ChainID + Proposer common.Address + Challenger common.Address +} + +func (g GameArgs) PackPermissionless() []byte { + chainID := g.L2ChainID.Bytes32() + return slices.Concat( + g.AbsolutePrestate[:], + g.Vm[:], + g.AnchorStateRegistry[:], + g.Weth[:], + chainID[:], + ) +} + +func (g GameArgs) PackPermissioned() []byte { + return slices.Concat( + g.PackPermissionless(), + g.Proposer[:], + g.Challenger[:], + ) +} + +func Parse(args []byte) (GameArgs, error) { + if len(args) != PermissionlessArgsLength && len(args) != PermissionedArgsLength { + return GameArgs{}, fmt.Errorf("%w: invalid length (%v)", ErrInvalidGameArgs, len(args)) + } + var output GameArgs + output.AbsolutePrestate = common.BytesToHash(args[0:32]) + output.Vm = common.BytesToAddress(args[32:52]) + output.AnchorStateRegistry = common.BytesToAddress(args[52:72]) + output.Weth = common.BytesToAddress(args[72:92]) + var chainID [32]byte + copy(chainID[:], args[92:124]) + output.L2ChainID = eth.ChainIDFromBytes32(chainID) + + if len(args) == PermissionedArgsLength { + output.Proposer = common.BytesToAddress(args[124:144]) + output.Challenger = common.BytesToAddress(args[144:164]) + } + return output, nil +} diff --git a/op-challenger/game/fault/contracts/gameargs/gameargs_test.go b/op-challenger/game/fault/contracts/gameargs/gameargs_test.go new file mode 100644 index 00000000000..92469bc9264 --- /dev/null +++ b/op-challenger/game/fault/contracts/gameargs/gameargs_test.go @@ -0,0 +1,67 @@ +package gameargs + +import ( + "math/rand" + "testing" + + "github.com/ethereum-optimism/optimism/op-service/eth" + "github.com/ethereum-optimism/optimism/op-service/testutils" + "github.com/ethereum/go-ethereum/common" + "github.com/stretchr/testify/require" +) + +func TestParse(t *testing.T) { + t.Run("Invalid-ZeroLength", func(t *testing.T) { + _, err := Parse([]byte{}) + require.ErrorIs(t, err, ErrInvalidGameArgs) + }) + + t.Run("Invalid-TooLong", func(t *testing.T) { + input := make([]byte, PermissionedArgsLength+1) + _, err := Parse(input) + require.ErrorIs(t, err, ErrInvalidGameArgs) + }) + + t.Run("Invalid-TooShort", func(t *testing.T) { + input := make([]byte, PermissionlessArgsLength-1) + _, err := Parse(input) + require.ErrorIs(t, err, ErrInvalidGameArgs) + }) + + t.Run("Invalid-BetweenValidLengths", func(t *testing.T) { + input := make([]byte, PermissionlessArgsLength+1) + _, err := Parse(input) + require.ErrorIs(t, err, ErrInvalidGameArgs) + }) + + t.Run("Valid-Permissionless", func(t *testing.T) { + expected := fullGameArgs() + expected.Proposer = common.Address{} + expected.Challenger = common.Address{} + input := expected.PackPermissionless() + actual, err := Parse(input) + require.NoError(t, err) + require.Equal(t, expected, actual) + }) + + t.Run("Valid-Permissioned", func(t *testing.T) { + expected := fullGameArgs() + input := expected.PackPermissioned() + actual, err := Parse(input) + require.NoError(t, err) + require.Equal(t, expected, actual) + }) +} + +func fullGameArgs() GameArgs { + rng := rand.New(rand.NewSource(0)) + return GameArgs{ + AbsolutePrestate: testutils.RandomHash(rng), + Vm: testutils.RandomAddress(rng), + AnchorStateRegistry: testutils.RandomAddress(rng), + Weth: testutils.RandomAddress(rng), + L2ChainID: eth.ChainIDFromBytes32(testutils.RandomHash(rng)), + Proposer: testutils.RandomAddress(rng), + Challenger: testutils.RandomAddress(rng), + } +} diff --git a/op-challenger/game/fault/contracts/gamefactory.go b/op-challenger/game/fault/contracts/gamefactory.go index cad967d9ec7..6b36392de71 100644 --- a/op-challenger/game/fault/contracts/gamefactory.go +++ b/op-challenger/game/fault/contracts/gamefactory.go @@ -2,10 +2,12 @@ package contracts import ( "context" + _ "embed" "errors" "fmt" "math/big" + "github.com/ethereum-optimism/optimism/op-challenger/game/fault/contracts/gameargs" "github.com/ethereum-optimism/optimism/op-challenger/game/fault/contracts/metrics" faultTypes "github.com/ethereum-optimism/optimism/op-challenger/game/fault/types" "github.com/ethereum-optimism/optimism/op-challenger/game/types" @@ -22,6 +24,7 @@ const ( methodGameCount = "gameCount" methodGameAtIndex = "gameAtIndex" methodGameImpls = "gameImpls" + methodGameArgs = "gameArgs" methodInitBonds = "initBonds" methodCreateGame = "create" methodGames = "games" @@ -33,20 +36,56 @@ var ( ErrEventNotFound = errors.New("event not found") ) +//go:embed abis/DisputeGameFactory-1.2.0.json +var disputeGameFactoryAbi120 []byte + +type gameArgsFunc func(ctx context.Context, caller *batching.MultiCaller, block rpcblock.Block, contract *batching.BoundContract, gameType faultTypes.GameType) ([]byte, error) + +func getGameArgsLatest(ctx context.Context, caller *batching.MultiCaller, block rpcblock.Block, contract *batching.BoundContract, gameType faultTypes.GameType) ([]byte, error) { + result, err := caller.SingleCall(ctx, block, contract.Call(methodGameArgs, gameType)) + if err != nil { + return nil, fmt.Errorf("failed to get game args: %w", err) + } + return result.GetBytes(0), nil +} + +func getGameArgsNoOp(_ context.Context, _ *batching.MultiCaller, _ rpcblock.Block, _ *batching.BoundContract, _ faultTypes.GameType) ([]byte, error) { + return nil, nil +} + type DisputeGameFactoryContract struct { metrics metrics.ContractMetricer multiCaller *batching.MultiCaller contract *batching.BoundContract abi *abi.ABI + + // getGameArgs supports the gameArgs call to the contract which is only supported from v1.3.0 onwards + getGameArgs gameArgsFunc } -func NewDisputeGameFactoryContract(m metrics.ContractMetricer, addr common.Address, caller *batching.MultiCaller) *DisputeGameFactoryContract { +func NewDisputeGameFactoryContract(ctx context.Context, m metrics.ContractMetricer, addr common.Address, caller *batching.MultiCaller) (*DisputeGameFactoryContract, error) { factoryAbi := snapshots.LoadDisputeGameFactoryABI() + + var builder VersionedBuilder[*DisputeGameFactoryContract] + preGameArgsFactory := func() (*DisputeGameFactoryContract, error) { + legacyAbi := mustParseAbi(disputeGameFactoryAbi120) + return newDisputeGameFactoryContract(m, addr, caller, legacyAbi, getGameArgsNoOp), nil + } + builder.AddVersion(1, 0, preGameArgsFactory) + builder.AddVersion(1, 1, preGameArgsFactory) + builder.AddVersion(1, 2, preGameArgsFactory) + return builder.Build(ctx, caller, factoryAbi, addr, func() (*DisputeGameFactoryContract, error) { + return newDisputeGameFactoryContract(m, addr, caller, factoryAbi, getGameArgsLatest), nil + }) +} + +func newDisputeGameFactoryContract(m metrics.ContractMetricer, addr common.Address, caller *batching.MultiCaller, factoryAbi *abi.ABI, getGameArgs gameArgsFunc) *DisputeGameFactoryContract { return &DisputeGameFactoryContract{ metrics: m, multiCaller: caller, contract: batching.NewBoundContract(factoryAbi, addr), abi: factoryAbi, + getGameArgs: getGameArgs, } } @@ -77,7 +116,7 @@ func (f *DisputeGameFactoryContract) GetGame(ctx context.Context, idx uint64, bl return f.decodeGame(idx, result), nil } -func (f *DisputeGameFactoryContract) GetGameImpl(ctx context.Context, gameType faultTypes.GameType) (common.Address, error) { +func (f *DisputeGameFactoryContract) getGameImpl(ctx context.Context, gameType faultTypes.GameType) (common.Address, error) { defer f.metrics.StartContractRequest("GetGameImpl")() result, err := f.multiCaller.SingleCall(ctx, rpcblock.Latest, f.contract.Call(methodGameImpls, gameType)) if err != nil { @@ -86,6 +125,66 @@ func (f *DisputeGameFactoryContract) GetGameImpl(ctx context.Context, gameType f return result.GetAddress(0), nil } +func (f *DisputeGameFactoryContract) HasGameImpl(ctx context.Context, gameType faultTypes.GameType) (bool, error) { + impl, err := f.getGameImpl(ctx, gameType) + if err != nil { + return false, err + } + return impl != (common.Address{}), nil +} + +func (f *DisputeGameFactoryContract) GetGameVm(ctx context.Context, gameType faultTypes.GameType) (*VMContract, error) { + defer f.metrics.StartContractRequest("GetGameVm")() + gameArgs, err := f.getGameArgs(ctx, f.multiCaller, rpcblock.Latest, f.contract, gameType) + if err != nil { + return nil, err + } + if len(gameArgs) == 0 { + // V1 contract, so get the VM and oracle address from the implementation contract + disputeGame, err := f.faultDisputeGameForType(ctx, gameType) + if err != nil { + return nil, err + } + return disputeGame.Vm(ctx) + } + // V2 contract, so load the VM address from game args + args, err := gameargs.Parse(gameArgs) + if err != nil { + return nil, fmt.Errorf("failed to parse game args for game type %v: %w", gameType, err) + } + return NewVMContract(args.Vm, f.multiCaller), nil +} + +func (f *DisputeGameFactoryContract) GetGamePrestate(ctx context.Context, gameType faultTypes.GameType) (common.Hash, error) { + defer f.metrics.StartContractRequest("GetGamePrestate")() + gameArgs, err := f.getGameArgs(ctx, f.multiCaller, rpcblock.Latest, f.contract, gameType) + if err != nil { + return common.Hash{}, err + } + if len(gameArgs) == 0 { + // V1 contract, so get the VM and oracle address from the implementation contract + disputeGame, err := f.faultDisputeGameForType(ctx, gameType) + if err != nil { + return common.Hash{}, err + } + return disputeGame.GetAbsolutePrestateHash(ctx) + } + // V2 contract, so load the VM address from game args + args, err := gameargs.Parse(gameArgs) + if err != nil { + return common.Hash{}, fmt.Errorf("failed to parse game args for game type %v: %w", gameType, err) + } + return args.AbsolutePrestate, nil +} + +func (f *DisputeGameFactoryContract) faultDisputeGameForType(ctx context.Context, gameType faultTypes.GameType) (FaultDisputeGameContract, error) { + addr, err := f.getGameImpl(ctx, gameType) + if err != nil { + return nil, err + } + return NewFaultDisputeGameContract(ctx, f.metrics, addr, f.multiCaller) +} + func (f *DisputeGameFactoryContract) GetGamesAtOrAfter(ctx context.Context, blockHash common.Hash, earliestTimestamp uint64) ([]types.GameMetadata, error) { defer f.metrics.StartContractRequest("GetGamesAtOrAfter")() count, err := f.GetGameCount(ctx, blockHash) diff --git a/op-challenger/game/fault/contracts/gamefactory_test.go b/op-challenger/game/fault/contracts/gamefactory_test.go index e2e91e54c0c..bda80d025bf 100644 --- a/op-challenger/game/fault/contracts/gamefactory_test.go +++ b/op-challenger/game/fault/contracts/gamefactory_test.go @@ -7,6 +7,7 @@ import ( "slices" "testing" + "github.com/ethereum-optimism/optimism/op-challenger/game/fault/contracts/gameargs" "github.com/ethereum-optimism/optimism/op-challenger/game/fault/contracts/metrics" faultTypes "github.com/ethereum-optimism/optimism/op-challenger/game/fault/types" "github.com/ethereum-optimism/optimism/op-challenger/game/types" @@ -14,14 +15,50 @@ import ( "github.com/ethereum-optimism/optimism/op-service/sources/batching/rpcblock" batchingTest "github.com/ethereum-optimism/optimism/op-service/sources/batching/test" "github.com/ethereum-optimism/optimism/packages/contracts-bedrock/snapshots" + "github.com/ethereum/go-ethereum/accounts/abi" "github.com/ethereum/go-ethereum/common" ethTypes "github.com/ethereum/go-ethereum/core/types" "github.com/stretchr/testify/require" ) +const ( + versFactory120 = "1.2.0" + versFactoryLatest = "1.4.0" +) + +type factoryContractVersion struct { + version string + loadAbi func() *abi.ABI + noGameArgsSupport bool +} + +func (c factoryContractVersion) Is(versions ...string) bool { + return slices.Contains(versions, c.version) +} + +func (c factoryContractVersion) String() string { + return c.version +} + var ( factoryAddr = common.HexToAddress("0x24112842371dFC380576ebb09Ae16Cb6B6caD7CB") batchSize = 5 + + factoryVersions = []factoryContractVersion{ + { + version: versFactory120, + loadAbi: func() *abi.ABI { + return mustParseAbi(disputeGameFactoryAbi120) + }, + noGameArgsSupport: true, + }, + { + version: versFactoryLatest, + loadAbi: func() *abi.ABI { + return snapshots.LoadDisputeGameFactoryABI() + }, + }, + } ) func TestDisputeGameFactorySimpleGetters(t *testing.T) { @@ -42,82 +79,94 @@ func TestDisputeGameFactorySimpleGetters(t *testing.T) { }, }, } - for _, test := range tests { - test := test - t.Run(test.method, func(t *testing.T) { - stubRpc, factory := setupDisputeGameFactoryTest(t) - stubRpc.SetResponse(factoryAddr, test.method, rpcblock.ByHash(blockHash), nil, []interface{}{test.result}) - status, err := test.call(factory) - require.NoError(t, err) - expected := test.expected - if expected == nil { - expected = test.result + for _, version := range factoryVersions { + t.Run(version.String(), func(t *testing.T) { + for _, test := range tests { + test := test + t.Run(test.method, func(t *testing.T) { + stubRpc, factory := setupDisputeGameFactoryTest(t, version) + stubRpc.SetResponse(factoryAddr, test.method, rpcblock.ByHash(blockHash), nil, []interface{}{test.result}) + status, err := test.call(factory) + require.NoError(t, err) + expected := test.expected + if expected == nil { + expected = test.result + } + require.Equal(t, expected, status) + }) } - require.Equal(t, expected, status) }) } } func TestLoadGame(t *testing.T) { - blockHash := common.Hash{0xbb, 0xce} - stubRpc, factory := setupDisputeGameFactoryTest(t) - game0 := types.GameMetadata{ - Index: 0, - GameType: 0, - Timestamp: 1234, - Proxy: common.Address{0xaa}, - } - game1 := types.GameMetadata{ - Index: 1, - GameType: 1, - Timestamp: 5678, - Proxy: common.Address{0xbb}, - } - game2 := types.GameMetadata{ - Index: 2, - GameType: 99, - Timestamp: 9988, - Proxy: common.Address{0xcc}, - } - expectedGames := []types.GameMetadata{game0, game1, game2} - for idx, expected := range expectedGames { - expectGetGame(stubRpc, idx, blockHash, expected) - actual, err := factory.GetGame(context.Background(), uint64(idx), blockHash) - require.NoError(t, err) - require.Equal(t, expected, actual) + for _, version := range factoryVersions { + t.Run(version.String(), func(t *testing.T) { + blockHash := common.Hash{0xbb, 0xce} + stubRpc, factory := setupDisputeGameFactoryTest(t, version) + game0 := types.GameMetadata{ + Index: 0, + GameType: 0, + Timestamp: 1234, + Proxy: common.Address{0xaa}, + } + game1 := types.GameMetadata{ + Index: 1, + GameType: 1, + Timestamp: 5678, + Proxy: common.Address{0xbb}, + } + game2 := types.GameMetadata{ + Index: 2, + GameType: 99, + Timestamp: 9988, + Proxy: common.Address{0xcc}, + } + expectedGames := []types.GameMetadata{game0, game1, game2} + for idx, expected := range expectedGames { + expectGetGame(stubRpc, idx, blockHash, expected) + actual, err := factory.GetGame(context.Background(), uint64(idx), blockHash) + require.NoError(t, err) + require.Equal(t, expected, actual) + } + }) } } func TestGetAllGames(t *testing.T) { - blockHash := common.Hash{0xbb, 0xce} - stubRpc, factory := setupDisputeGameFactoryTest(t) - game0 := types.GameMetadata{ - Index: 0, - GameType: 0, - Timestamp: 1234, - Proxy: common.Address{0xaa}, - } - game1 := types.GameMetadata{ - Index: 1, - GameType: 1, - Timestamp: 5678, - Proxy: common.Address{0xbb}, - } - game2 := types.GameMetadata{ - Index: 2, - GameType: 99, - Timestamp: 9988, - Proxy: common.Address{0xcc}, - } + for _, version := range factoryVersions { + t.Run(version.String(), func(t *testing.T) { + blockHash := common.Hash{0xbb, 0xce} + stubRpc, factory := setupDisputeGameFactoryTest(t, version) + game0 := types.GameMetadata{ + Index: 0, + GameType: 0, + Timestamp: 1234, + Proxy: common.Address{0xaa}, + } + game1 := types.GameMetadata{ + Index: 1, + GameType: 1, + Timestamp: 5678, + Proxy: common.Address{0xbb}, + } + game2 := types.GameMetadata{ + Index: 2, + GameType: 99, + Timestamp: 9988, + Proxy: common.Address{0xcc}, + } - expectedGames := []types.GameMetadata{game0, game1, game2} - stubRpc.SetResponse(factoryAddr, methodGameCount, rpcblock.ByHash(blockHash), nil, []interface{}{big.NewInt(int64(len(expectedGames)))}) - for idx, expected := range expectedGames { - expectGetGame(stubRpc, idx, blockHash, expected) + expectedGames := []types.GameMetadata{game0, game1, game2} + stubRpc.SetResponse(factoryAddr, methodGameCount, rpcblock.ByHash(blockHash), nil, []interface{}{big.NewInt(int64(len(expectedGames)))}) + for idx, expected := range expectedGames { + expectGetGame(stubRpc, idx, blockHash, expected) + } + actualGames, err := factory.GetAllGames(context.Background(), blockHash) + require.NoError(t, err) + require.Equal(t, expectedGames, actualGames) + }) } - actualGames, err := factory.GetAllGames(context.Background(), blockHash) - require.NoError(t, err) - require.Equal(t, expectedGames, actualGames) } func TestGetAllGamesAtOrAfter(t *testing.T) { @@ -134,141 +183,249 @@ func TestGetAllGamesAtOrAfter(t *testing.T) { {gameCount: batchSize * 2, earliestGameIdx: batchSize*2 + 1}, {gameCount: batchSize - 2, earliestGameIdx: batchSize - 3}, } - for _, test := range tests { - test := test - t.Run(fmt.Sprintf("Count_%v_Start_%v", test.gameCount, test.earliestGameIdx), func(t *testing.T) { - blockHash := common.Hash{0xbb, 0xce} - stubRpc, factory := setupDisputeGameFactoryTest(t) - var allGames []types.GameMetadata - for i := 0; i < test.gameCount; i++ { - allGames = append(allGames, types.GameMetadata{ - Index: uint64(i), - GameType: uint32(i), - Timestamp: uint64(i), - Proxy: common.Address{byte(i)}, + for _, version := range factoryVersions { + t.Run(version.String(), func(t *testing.T) { + for _, test := range tests { + test := test + t.Run(fmt.Sprintf("Count_%v_Start_%v", test.gameCount, test.earliestGameIdx), func(t *testing.T) { + blockHash := common.Hash{0xbb, 0xce} + stubRpc, factory := setupDisputeGameFactoryTest(t, version) + var allGames []types.GameMetadata + for i := 0; i < test.gameCount; i++ { + allGames = append(allGames, types.GameMetadata{ + Index: uint64(i), + GameType: uint32(i), + Timestamp: uint64(i), + Proxy: common.Address{byte(i)}, + }) + } + + stubRpc.SetResponse(factoryAddr, methodGameCount, rpcblock.ByHash(blockHash), nil, []interface{}{big.NewInt(int64(len(allGames)))}) + for idx, expected := range allGames { + expectGetGame(stubRpc, idx, blockHash, expected) + } + // Set an earliest timestamp that's in the middle of a batch + earliestTimestamp := uint64(test.earliestGameIdx) + actualGames, err := factory.GetGamesAtOrAfter(context.Background(), blockHash, earliestTimestamp) + require.NoError(t, err) + // Games come back in descending timestamp order + var expectedGames []types.GameMetadata + if test.earliestGameIdx < len(allGames) { + expectedGames = slices.Clone(allGames[test.earliestGameIdx:]) + } + slices.Reverse(expectedGames) + require.Equal(t, len(expectedGames), len(actualGames)) + if len(expectedGames) != 0 { + // Don't assert equal for empty arrays, we accept nil or empty array + require.Equal(t, expectedGames, actualGames) + } }) } + }) + } +} - stubRpc.SetResponse(factoryAddr, methodGameCount, rpcblock.ByHash(blockHash), nil, []interface{}{big.NewInt(int64(len(allGames)))}) - for idx, expected := range allGames { - expectGetGame(stubRpc, idx, blockHash, expected) - } - // Set an earliest timestamp that's in the middle of a batch - earliestTimestamp := uint64(test.earliestGameIdx) - actualGames, err := factory.GetGamesAtOrAfter(context.Background(), blockHash, earliestTimestamp) +func TestGetGameFromParameters(t *testing.T) { + for _, version := range factoryVersions { + t.Run(version.String(), func(t *testing.T) { + stubRpc, factory := setupDisputeGameFactoryTest(t, version) + traceType := uint32(123) + outputRoot := common.Hash{0x01} + l2BlockNum := common.BigToHash(big.NewInt(456)).Bytes() + stubRpc.SetResponse( + factoryAddr, + methodGames, + rpcblock.Latest, + []interface{}{traceType, outputRoot, l2BlockNum}, + []interface{}{common.Address{0xaa}, uint64(1)}, + ) + addr, err := factory.GetGameFromParameters(context.Background(), traceType, outputRoot, uint64(456)) require.NoError(t, err) - // Games come back in descending timestamp order - var expectedGames []types.GameMetadata - if test.earliestGameIdx < len(allGames) { - expectedGames = slices.Clone(allGames[test.earliestGameIdx:]) - } - slices.Reverse(expectedGames) - require.Equal(t, len(expectedGames), len(actualGames)) - if len(expectedGames) != 0 { - // Don't assert equal for empty arrays, we accept nil or empty array - require.Equal(t, expectedGames, actualGames) - } + require.Equal(t, common.Address{0xaa}, addr) }) } } -func TestGetGameFromParameters(t *testing.T) { - stubRpc, factory := setupDisputeGameFactoryTest(t) - traceType := uint32(123) - outputRoot := common.Hash{0x01} - l2BlockNum := common.BigToHash(big.NewInt(456)).Bytes() - stubRpc.SetResponse( - factoryAddr, - methodGames, - rpcblock.Latest, - []interface{}{traceType, outputRoot, l2BlockNum}, - []interface{}{common.Address{0xaa}, uint64(1)}, - ) - addr, err := factory.GetGameFromParameters(context.Background(), traceType, outputRoot, uint64(456)) - require.NoError(t, err) - require.Equal(t, common.Address{0xaa}, addr) +func TestHasGameImpl(t *testing.T) { + for _, version := range factoryVersions { + t.Run(version.String()+"-set", func(t *testing.T) { + stubRpc, factory := setupDisputeGameFactoryTest(t, version) + gameType := faultTypes.CannonGameType + gameImplAddr := common.Address{0xaa} + stubRpc.SetResponse( + factoryAddr, + methodGameImpls, + rpcblock.Latest, + []interface{}{gameType}, + []interface{}{gameImplAddr}) + actual, err := factory.HasGameImpl(context.Background(), faultTypes.CannonGameType) + require.NoError(t, err) + require.True(t, actual) + }) + t.Run(version.String()+"-unset", func(t *testing.T) { + stubRpc, factory := setupDisputeGameFactoryTest(t, version) + gameType := faultTypes.CannonGameType + stubRpc.SetResponse( + factoryAddr, + methodGameImpls, + rpcblock.Latest, + []interface{}{gameType}, + []interface{}{common.Address{}}) + actual, err := factory.HasGameImpl(context.Background(), faultTypes.CannonGameType) + require.NoError(t, err) + require.False(t, actual) + }) + } } -func TestGetGameImpl(t *testing.T) { - stubRpc, factory := setupDisputeGameFactoryTest(t) - gameType := faultTypes.CannonGameType - gameImplAddr := common.Address{0xaa} - stubRpc.SetResponse( - factoryAddr, - methodGameImpls, - rpcblock.Latest, - []interface{}{gameType}, - []interface{}{gameImplAddr}) - actual, err := factory.GetGameImpl(context.Background(), faultTypes.CannonGameType) - require.NoError(t, err) - require.Equal(t, gameImplAddr, actual) +func TestGetGameVM(t *testing.T) { + for _, usesGameArgs := range []bool{true, false} { + t.Run(fmt.Sprintf("GameArgs-%v", usesGameArgs), func(t *testing.T) { + for _, version := range factoryVersions { + t.Run(version.String(), func(t *testing.T) { + gameType := faultTypes.CannonGameType + rpc, factory := setupDisputeGameFactoryTest(t, version) + + if usesGameArgs { + if version.noGameArgsSupport { + t.Skip("Game args not supported on this contract version") + } + gameArgs := gameargs.GameArgs{Vm: vmAddr}.PackPermissionless() + rpc.SetResponse(factoryAddr, methodGameArgs, rpcblock.Latest, []interface{}{gameType}, []interface{}{gameArgs}) + } else { + if !version.noGameArgsSupport { + // No game args set + rpc.SetResponse(factoryAddr, methodGameArgs, rpcblock.Latest, []interface{}{gameType}, []interface{}{[]byte{}}) + } + + gameAddr := common.Address{1, 2, 5, 6} + rpc.SetResponse(factoryAddr, methodGameImpls, rpcblock.Latest, []interface{}{gameType}, []interface{}{gameAddr}) + + setupDisputeGame(rpc, gameAddr, gameType) + + // Get VM from game implementation + rpc.SetResponse(gameAddr, methodVM, rpcblock.Latest, nil, []interface{}{vmAddr}) + } + + vm, err := factory.GetGameVm(context.Background(), gameType) + require.NoError(t, err) + require.NotNil(t, vm) + require.Equal(t, vmAddr, vm.Addr()) + }) + } + }) + } +} + +func TestGetGamePrestate(t *testing.T) { + for _, usesGameArgs := range []bool{true, false} { + t.Run(fmt.Sprintf("GameArgs-%v", usesGameArgs), func(t *testing.T) { + for _, version := range factoryVersions { + t.Run(version.String(), func(t *testing.T) { + gameType := faultTypes.CannonGameType + prestate := common.Hash{92, 4, 6, 12, 4} + rpc, factory := setupDisputeGameFactoryTest(t, version) + + if usesGameArgs { + if version.noGameArgsSupport { + t.Skip("Game args not supported on this contract version") + } + gameArgs := gameargs.GameArgs{AbsolutePrestate: prestate}.PackPermissionless() + rpc.SetResponse(factoryAddr, methodGameArgs, rpcblock.Latest, []interface{}{gameType}, []interface{}{gameArgs}) + } else { + if !version.noGameArgsSupport { + // No game args set + rpc.SetResponse(factoryAddr, methodGameArgs, rpcblock.Latest, []interface{}{gameType}, []interface{}{[]byte{}}) + } + + gameAddr := common.Address{1, 2, 5, 6} + rpc.SetResponse(factoryAddr, methodGameImpls, rpcblock.Latest, []interface{}{gameType}, []interface{}{gameAddr}) + + setupDisputeGame(rpc, gameAddr, gameType) + + // Get VM from game implementation + rpc.SetResponse(gameAddr, methodAbsolutePrestate, rpcblock.Latest, nil, []interface{}{prestate}) + } + + actualPrestate, err := factory.GetGamePrestate(context.Background(), gameType) + require.NoError(t, err) + require.NotNil(t, actualPrestate) + require.Equal(t, prestate, actualPrestate) + }) + } + }) + } } func TestDecodeDisputeGameCreatedLog(t *testing.T) { - _, factory := setupDisputeGameFactoryTest(t) - fdgAbi := snapshots.LoadDisputeGameFactoryABI() - eventAbi := fdgAbi.Events[eventDisputeGameCreated] - gameAddr := common.Address{0x11} - gameType := uint32(4) - rootClaim := common.Hash{0xaa, 0xbb, 0xcc} - - createValidReceipt := func() *ethTypes.Receipt { - return ðTypes.Receipt{ - Status: ethTypes.ReceiptStatusSuccessful, - ContractAddress: fdgAddr, - Logs: []*ethTypes.Log{ - { - Address: fdgAddr, - Topics: []common.Hash{ - eventAbi.ID, - common.BytesToHash(gameAddr.Bytes()), - common.BytesToHash(big.NewInt(int64(gameType)).Bytes()), - rootClaim, + for _, version := range factoryVersions { + t.Run(version.String(), func(t *testing.T) { + _, factory := setupDisputeGameFactoryTest(t, version) + fdgAbi := factory.abi + eventAbi := fdgAbi.Events[eventDisputeGameCreated] + gameAddr := common.Address{0x11} + gameType := uint32(4) + rootClaim := common.Hash{0xaa, 0xbb, 0xcc} + + createValidReceipt := func() *ethTypes.Receipt { + return ðTypes.Receipt{ + Status: ethTypes.ReceiptStatusSuccessful, + ContractAddress: fdgAddr, + Logs: []*ethTypes.Log{ + { + Address: fdgAddr, + Topics: []common.Hash{ + eventAbi.ID, + common.BytesToHash(gameAddr.Bytes()), + common.BytesToHash(big.NewInt(int64(gameType)).Bytes()), + rootClaim, + }, + }, }, - }, - }, - } - } + } + } + + t.Run("IgnoreIncorrectContract", func(t *testing.T) { + rcpt := createValidReceipt() + rcpt.Logs[0].Address = common.Address{0xff} + _, _, _, err := factory.DecodeDisputeGameCreatedLog(rcpt) + require.ErrorIs(t, err, ErrEventNotFound) + }) + + t.Run("IgnoreInvalidEvent", func(t *testing.T) { + rcpt := createValidReceipt() + rcpt.Logs[0].Topics = rcpt.Logs[0].Topics[0:2] + _, _, _, err := factory.DecodeDisputeGameCreatedLog(rcpt) + require.ErrorIs(t, err, ErrEventNotFound) + }) + + t.Run("IgnoreWrongEvent", func(t *testing.T) { + rcpt := createValidReceipt() + rcpt.Logs[0].Topics = []common.Hash{ + fdgAbi.Events["ImplementationSet"].ID, + common.BytesToHash(common.Address{0x11}.Bytes()), // Implementation addr + common.BytesToHash(big.NewInt(4).Bytes()), // Game type - t.Run("IgnoreIncorrectContract", func(t *testing.T) { - rcpt := createValidReceipt() - rcpt.Logs[0].Address = common.Address{0xff} - _, _, _, err := factory.DecodeDisputeGameCreatedLog(rcpt) - require.ErrorIs(t, err, ErrEventNotFound) - }) - - t.Run("IgnoreInvalidEvent", func(t *testing.T) { - rcpt := createValidReceipt() - rcpt.Logs[0].Topics = rcpt.Logs[0].Topics[0:2] - _, _, _, err := factory.DecodeDisputeGameCreatedLog(rcpt) - require.ErrorIs(t, err, ErrEventNotFound) - }) - - t.Run("IgnoreWrongEvent", func(t *testing.T) { - rcpt := createValidReceipt() - rcpt.Logs[0].Topics = []common.Hash{ - fdgAbi.Events["ImplementationSet"].ID, - common.BytesToHash(common.Address{0x11}.Bytes()), // Implementation addr - common.BytesToHash(big.NewInt(4).Bytes()), // Game type - - } - // Check the log is a valid ImplementationSet - name, _, err := factory.contract.DecodeEvent(rcpt.Logs[0]) - require.NoError(t, err) - require.Equal(t, "ImplementationSet", name) - - _, _, _, err = factory.DecodeDisputeGameCreatedLog(rcpt) - require.ErrorIs(t, err, ErrEventNotFound) - }) - - t.Run("ValidEvent", func(t *testing.T) { - rcpt := createValidReceipt() - actualGameAddr, actualGameType, actualRootClaim, err := factory.DecodeDisputeGameCreatedLog(rcpt) - require.NoError(t, err) - require.Equal(t, gameAddr, actualGameAddr) - require.Equal(t, gameType, actualGameType) - require.Equal(t, rootClaim, actualRootClaim) - }) + } + // Check the log is a valid ImplementationSet + name, _, err := factory.contract.DecodeEvent(rcpt.Logs[0]) + require.NoError(t, err) + require.Equal(t, "ImplementationSet", name) + + _, _, _, err = factory.DecodeDisputeGameCreatedLog(rcpt) + require.ErrorIs(t, err, ErrEventNotFound) + }) + + t.Run("ValidEvent", func(t *testing.T) { + rcpt := createValidReceipt() + actualGameAddr, actualGameType, actualRootClaim, err := factory.DecodeDisputeGameCreatedLog(rcpt) + require.NoError(t, err) + require.Equal(t, gameAddr, actualGameAddr) + require.Equal(t, gameType, actualGameType) + require.Equal(t, rootClaim, actualRootClaim) + }) + }) + } } func expectGetGame(stubRpc *batchingTest.AbiBasedRpc, idx int, blockHash common.Hash, game types.GameMetadata) { @@ -285,25 +442,35 @@ func expectGetGame(stubRpc *batchingTest.AbiBasedRpc, idx int, blockHash common. } func TestCreateTx(t *testing.T) { - stubRpc, factory := setupDisputeGameFactoryTest(t) - traceType := uint32(123) - outputRoot := common.Hash{0x01} - l2BlockNum := common.BigToHash(big.NewInt(456)).Bytes() - bond := big.NewInt(49284294829) - stubRpc.SetResponse(factoryAddr, methodInitBonds, rpcblock.Latest, []interface{}{traceType}, []interface{}{bond}) - stubRpc.SetResponse(factoryAddr, methodCreateGame, rpcblock.Latest, []interface{}{traceType, outputRoot, l2BlockNum}, nil) - tx, err := factory.CreateTx(context.Background(), traceType, outputRoot, uint64(456)) - require.NoError(t, err) - stubRpc.VerifyTxCandidate(tx) - require.NotNil(t, tx.Value) - require.Truef(t, bond.Cmp(tx.Value) == 0, "Expected bond %v but was %v", bond, tx.Value) + for _, version := range factoryVersions { + t.Run(version.String(), func(t *testing.T) { + stubRpc, factory := setupDisputeGameFactoryTest(t, version) + traceType := uint32(123) + outputRoot := common.Hash{0x01} + l2BlockNum := common.BigToHash(big.NewInt(456)).Bytes() + bond := big.NewInt(49284294829) + stubRpc.SetResponse(factoryAddr, methodInitBonds, rpcblock.Latest, []interface{}{traceType}, []interface{}{bond}) + stubRpc.SetResponse(factoryAddr, methodCreateGame, rpcblock.Latest, []interface{}{traceType, outputRoot, l2BlockNum}, nil) + tx, err := factory.CreateTx(context.Background(), traceType, outputRoot, uint64(456)) + require.NoError(t, err) + stubRpc.VerifyTxCandidate(tx) + require.NotNil(t, tx.Value) + require.Truef(t, bond.Cmp(tx.Value) == 0, "Expected bond %v but was %v", bond, tx.Value) + }) + } } -func setupDisputeGameFactoryTest(t *testing.T) (*batchingTest.AbiBasedRpc, *DisputeGameFactoryContract) { - fdgAbi := snapshots.LoadDisputeGameFactoryABI() - - stubRpc := batchingTest.NewAbiBasedRpc(t, factoryAddr, fdgAbi) +func setupDisputeGameFactoryTest(t *testing.T, version factoryContractVersion) (*batchingTest.AbiBasedRpc, *DisputeGameFactoryContract) { + stubRpc := batchingTest.NewAbiBasedRpc(t, factoryAddr, version.loadAbi()) caller := batching.NewMultiCaller(stubRpc, batchSize) - factory := NewDisputeGameFactoryContract(metrics.NoopContractMetrics, factoryAddr, caller) + stubRpc.SetResponse(factoryAddr, methodVersion, rpcblock.Latest, []interface{}{}, []interface{}{version.version}) + factory, err := NewDisputeGameFactoryContract(context.Background(), metrics.NoopContractMetrics, factoryAddr, caller) + require.NoError(t, err) return stubRpc, factory } + +func setupDisputeGame(rpc *batchingTest.AbiBasedRpc, gameAddr common.Address, gameType faultTypes.GameType) { + rpc.AddContract(gameAddr, snapshots.LoadFaultDisputeGameABI()) + rpc.SetResponse(gameAddr, methodVersion, rpcblock.Latest, nil, []interface{}{versLatest}) + rpc.SetResponse(gameAddr, methodGameType, rpcblock.Latest, nil, []interface{}{gameType}) +} diff --git a/op-challenger/game/fault/register_task.go b/op-challenger/game/fault/register_task.go index d6d87bc1505..fae04dee223 100644 --- a/op-challenger/game/fault/register_task.go +++ b/op-challenger/game/fault/register_task.go @@ -361,7 +361,7 @@ func (e *RegisterTask) Register( } return NewGamePlayer(ctx, systemClock, l1Clock, logger, m, dir, game.Proxy, txSender, contract, e.syncValidator, validators, creator, l1HeaderSource, selective, claimants, responseDelay, responseDelayAfter) } - err := registerOracle(ctx, logger, m, oracles, gameFactory, caller, e.gameType) + err := registerOracle(ctx, logger, oracles, gameFactory, e.gameType) if err != nil { return err } @@ -374,20 +374,21 @@ func (e *RegisterTask) Register( return nil } -func registerOracle(ctx context.Context, logger log.Logger, m metrics.Metricer, oracles OracleRegistry, gameFactory *contracts.DisputeGameFactoryContract, caller *batching.MultiCaller, gameType faultTypes.GameType) error { - implAddr, err := gameFactory.GetGameImpl(ctx, gameType) +func registerOracle(ctx context.Context, logger log.Logger, oracles OracleRegistry, gameFactory *contracts.DisputeGameFactoryContract, gameType faultTypes.GameType) error { + // Check that there is an implementation set for this game type and skip if not. + hasImpl, err := gameFactory.HasGameImpl(ctx, gameType) if err != nil { - return fmt.Errorf("failed to load implementation for game type %v: %w", gameType, err) + return fmt.Errorf("failed to check implementation for game type %v: %w", gameType, err) } - if implAddr == (common.Address{}) { + if !hasImpl { logger.Warn("No game implementation set for game type", "gameType", gameType) return nil } - contract, err := contracts.NewFaultDisputeGameContract(ctx, m, implAddr, caller) + vmContract, err := gameFactory.GetGameVm(ctx, gameType) if err != nil { - return fmt.Errorf("failed to create fault dispute game contracts: %w", err) + return fmt.Errorf("failed to get vm for game type %v: %w", gameType, err) } - oracle, err := contract.GetOracle(ctx) + oracle, err := vmContract.Oracle(ctx) if err != nil { return fmt.Errorf("failed to load oracle address: %w", err) } diff --git a/op-challenger/game/fault/register_task_test.go b/op-challenger/game/fault/register_task_test.go index debfc50ac1e..4aa61860979 100644 --- a/op-challenger/game/fault/register_task_test.go +++ b/op-challenger/game/fault/register_task_test.go @@ -6,9 +6,11 @@ import ( "testing" "github.com/ethereum-optimism/optimism/op-challenger/game/fault/contracts" + "github.com/ethereum-optimism/optimism/op-challenger/game/fault/contracts/gameargs" faultTypes "github.com/ethereum-optimism/optimism/op-challenger/game/fault/types" "github.com/ethereum-optimism/optimism/op-challenger/game/registry" "github.com/ethereum-optimism/optimism/op-challenger/metrics" + "github.com/ethereum-optimism/optimism/op-service/eth" "github.com/ethereum-optimism/optimism/op-service/sources/batching" "github.com/ethereum-optimism/optimism/op-service/sources/batching/rpcblock" "github.com/ethereum-optimism/optimism/op-service/sources/batching/test" @@ -20,64 +22,120 @@ import ( ) func TestRegisterOracle_MissingGameImpl(t *testing.T) { - gameFactoryAddr := common.Address{0xaa} - rpc := test.NewAbiBasedRpc(t, gameFactoryAddr, snapshots.LoadDisputeGameFactoryABI()) - m := metrics.NoopMetrics - caller := batching.NewMultiCaller(rpc, batching.DefaultBatchSize) - gameFactory := contracts.NewDisputeGameFactoryContract(m, gameFactoryAddr, caller) + // Test versions with and without game args support + for _, factoryVersion := range []string{"1.2.0", "1.3.0"} { + t.Run(factoryVersion, func(t *testing.T) { + gameFactoryAddr := common.Address{0xaa} + rpc := test.NewAbiBasedRpc(t, gameFactoryAddr, snapshots.LoadDisputeGameFactoryABI()) + rpc.SetResponse(gameFactoryAddr, "version", rpcblock.Latest, nil, []interface{}{factoryVersion}) + m := metrics.NoopMetrics + caller := batching.NewMultiCaller(rpc, batching.DefaultBatchSize) + gameFactory, err := contracts.NewDisputeGameFactoryContract(context.Background(), m, gameFactoryAddr, caller) + require.NoError(t, err) - logger, logs := testlog.CaptureLogger(t, log.LvlInfo) - oracles := registry.NewOracleRegistry() - gameType := faultTypes.CannonGameType + logger, logs := testlog.CaptureLogger(t, log.LvlInfo) + oracles := registry.NewOracleRegistry() + gameType := faultTypes.CannonGameType - rpc.SetResponse(gameFactoryAddr, "gameImpls", rpcblock.Latest, []interface{}{gameType}, []interface{}{common.Address{}}) + rpc.SetResponse(gameFactoryAddr, "gameImpls", rpcblock.Latest, []interface{}{gameType}, []interface{}{common.Address{}}) - err := registerOracle(context.Background(), logger, m, oracles, gameFactory, caller, gameType) - require.NoError(t, err) - require.NotNil(t, logs.FindLog( - testlog.NewMessageFilter("No game implementation set for game type"), - testlog.NewAttributesFilter("gameType", gameType.String()))) + err = registerOracle(context.Background(), logger, oracles, gameFactory, gameType) + require.NoError(t, err) + require.NotNil(t, logs.FindLog( + testlog.NewMessageFilter("No game implementation set for game type"), + testlog.NewAttributesFilter("gameType", gameType.String()))) + }) + } } func TestRegisterOracle_AddsOracle(t *testing.T) { - for _, gameType := range []faultTypes.GameType{faultTypes.CannonGameType, faultTypes.SuperCannonGameType, faultTypes.SuperAsteriscKonaGameType} { - t.Run(fmt.Sprintf("%v", gameType), func(t *testing.T) { - gameFactoryAddr := common.Address{0xaa} - gameImplAddr := common.Address{0xbb} - vmAddr := common.Address{0xcc} - oracleAddr := common.Address{0xdd} - rpc := test.NewAbiBasedRpc(t, gameFactoryAddr, snapshots.LoadDisputeGameFactoryABI()) - if gameType == faultTypes.CannonGameType { - rpc.AddContract(gameImplAddr, snapshots.LoadFaultDisputeGameABI()) - } else if gameType == faultTypes.SuperCannonGameType || gameType == faultTypes.SuperAsteriscKonaGameType { - rpc.AddContract(gameImplAddr, snapshots.LoadSuperFaultDisputeGameABI()) - } else { - t.Fatalf("game type %v not supported", gameType) - } - rpc.AddContract(vmAddr, snapshots.LoadMIPSABI()) - rpc.AddContract(oracleAddr, snapshots.LoadPreimageOracleABI()) - m := metrics.NoopMetrics - caller := batching.NewMultiCaller(rpc, batching.DefaultBatchSize) - gameFactory := contracts.NewDisputeGameFactoryContract(m, gameFactoryAddr, caller) + tests := []struct { + name string + version string + supportGameArgs bool + useGameArgs bool + }{ + { + name: "pre-game args support", + version: "1.2.0", + supportGameArgs: false, + useGameArgs: false, + }, + { + name: "game args supported but not used", + version: "1.3.0", + supportGameArgs: true, + useGameArgs: false, + }, + { + name: "game args supported and used", + version: "1.3.0", + supportGameArgs: true, + useGameArgs: true, + }, + } + for _, testCase := range tests { + t.Run(testCase.name, func(t *testing.T) { + for _, gameType := range []faultTypes.GameType{faultTypes.CannonGameType, faultTypes.SuperCannonGameType, faultTypes.SuperAsteriscKonaGameType} { + t.Run(fmt.Sprintf("%v", gameType), func(t *testing.T) { + gameFactoryAddr := common.Address{0xaa} + gameImplAddr := common.Address{0xbb} + vmAddr := common.Address{0xcc} + oracleAddr := common.Address{0xdd} + rpc := test.NewAbiBasedRpc(t, gameFactoryAddr, snapshots.LoadDisputeGameFactoryABI()) + rpc.SetResponse(gameFactoryAddr, "version", rpcblock.Latest, nil, []interface{}{testCase.version}) + if gameType == faultTypes.CannonGameType { + rpc.AddContract(gameImplAddr, snapshots.LoadFaultDisputeGameABI()) + } else if gameType == faultTypes.SuperCannonGameType || gameType == faultTypes.SuperAsteriscKonaGameType { + rpc.AddContract(gameImplAddr, snapshots.LoadSuperFaultDisputeGameABI()) + } else { + t.Fatalf("game type %v not supported", gameType) + } + rpc.AddContract(vmAddr, snapshots.LoadMIPSABI()) + rpc.AddContract(oracleAddr, snapshots.LoadPreimageOracleABI()) + m := metrics.NoopMetrics + caller := batching.NewMultiCaller(rpc, batching.DefaultBatchSize) + gameFactory, err := contracts.NewDisputeGameFactoryContract(context.Background(), m, gameFactoryAddr, caller) + require.NoError(t, err) - logger := testlog.Logger(t, log.LvlInfo) - oracles := registry.NewOracleRegistry() + if testCase.useGameArgs { + gameArgs := gameargs.GameArgs{ + AbsolutePrestate: common.Hash{1}, + Vm: vmAddr, + AnchorStateRegistry: common.Address{3}, + Weth: common.Address{4}, + L2ChainID: eth.ChainID{5}, + Proposer: common.Address{6}, + Challenger: common.Address{7}, + }.PackPermissionless() + rpc.SetResponse(gameFactoryAddr, "gameArgs", rpcblock.Latest, []interface{}{gameType}, []interface{}{gameArgs}) + } else if testCase.supportGameArgs { + rpc.SetResponse(gameFactoryAddr, "gameArgs", rpcblock.Latest, []interface{}{gameType}, []interface{}{[]byte{}}) + } - // Use the latest v1 of these contracts. Doesn't have to be an exact match for the version. - rpc.SetResponse(gameImplAddr, "version", rpcblock.Latest, []interface{}{}, []interface{}{"1.100.0"}) - rpc.SetResponse(oracleAddr, "version", rpcblock.Latest, []interface{}{}, []interface{}{"1.100.0"}) + logger := testlog.Logger(t, log.LvlInfo) + oracles := registry.NewOracleRegistry() - rpc.SetResponse(gameFactoryAddr, "gameImpls", rpcblock.Latest, []interface{}{gameType}, []interface{}{gameImplAddr}) - rpc.SetResponse(gameImplAddr, "vm", rpcblock.Latest, []interface{}{}, []interface{}{vmAddr}) - rpc.SetResponse(vmAddr, "oracle", rpcblock.Latest, []interface{}{}, []interface{}{oracleAddr}) + // Use the latest v1 of these contracts. Doesn't have to be an exact match for the version. + rpc.SetResponse(gameImplAddr, "version", rpcblock.Latest, []interface{}{}, []interface{}{"1.100.0"}) + rpc.SetResponse(oracleAddr, "version", rpcblock.Latest, []interface{}{}, []interface{}{"1.100.0"}) - rpc.SetResponse(gameImplAddr, "gameType", rpcblock.Latest, []interface{}{}, []interface{}{uint32(gameType)}) + rpc.SetResponse(gameFactoryAddr, "gameImpls", rpcblock.Latest, []interface{}{gameType}, []interface{}{gameImplAddr}) + if !testCase.useGameArgs { + // Can only get the vm address from the implementation contract if game args aren't being used + rpc.SetResponse(gameImplAddr, "vm", rpcblock.Latest, []interface{}{}, []interface{}{vmAddr}) + } + rpc.SetResponse(vmAddr, "oracle", rpcblock.Latest, []interface{}{}, []interface{}{oracleAddr}) - err := registerOracle(context.Background(), logger, m, oracles, gameFactory, caller, gameType) - require.NoError(t, err) - registered := oracles.Oracles() - require.Len(t, registered, 1) - require.Equal(t, oracleAddr, registered[0].Addr()) + rpc.SetResponse(gameImplAddr, "gameType", rpcblock.Latest, []interface{}{}, []interface{}{uint32(gameType)}) + + err = registerOracle(context.Background(), logger, oracles, gameFactory, gameType) + require.NoError(t, err) + registered := oracles.Oracles() + require.Len(t, registered, 1) + require.Equal(t, oracleAddr, registered[0].Addr()) + }) + } }) } } diff --git a/op-challenger/game/service.go b/op-challenger/game/service.go index ae3c1b69104..28f279d455b 100644 --- a/op-challenger/game/service.go +++ b/op-challenger/game/service.go @@ -100,7 +100,7 @@ func (s *Service) initFromConfig(ctx context.Context, cfg *config.Config) error if err := s.initMetricsServer(&cfg.MetricsConfig); err != nil { return fmt.Errorf("failed to init metrics server: %w", err) } - if err := s.initFactoryContract(cfg); err != nil { + if err := s.initFactoryContract(ctx, cfg); err != nil { return fmt.Errorf("failed to create factory contract bindings: %w", err) } if err := s.registerGameTypes(ctx, cfg); err != nil { @@ -192,9 +192,12 @@ func (s *Service) initMetricsServer(cfg *opmetrics.CLIConfig) error { return nil } -func (s *Service) initFactoryContract(cfg *config.Config) error { - factoryContract := contracts.NewDisputeGameFactoryContract(s.metrics, cfg.GameFactoryAddress, +func (s *Service) initFactoryContract(ctx context.Context, cfg *config.Config) error { + factoryContract, err := contracts.NewDisputeGameFactoryContract(ctx, s.metrics, cfg.GameFactoryAddress, batching.NewMultiCaller(s.l1Client.Client(), batching.DefaultBatchSize)) + if err != nil { + return fmt.Errorf("failed to create factory contract: %w", err) + } s.factoryContract = factoryContract return nil } diff --git a/op-challenger/runner/prestates.go b/op-challenger/runner/prestates.go index 54bc8fa474c..ffd8203645e 100644 --- a/op-challenger/runner/prestates.go +++ b/op-challenger/runner/prestates.go @@ -28,21 +28,13 @@ type OnChainPrestateFetcher struct { } func (f *OnChainPrestateFetcher) getPrestate(ctx context.Context, logger log.Logger, prestateBaseUrl *url.URL, prestatePath string, dataDir string, stateConverter vm.StateConverter) (string, error) { - gameFactory := contracts.NewDisputeGameFactoryContract(f.m, f.gameFactoryAddress, f.caller) - gameImplAddr, err := gameFactory.GetGameImpl(ctx, f.gameType) + gameFactory, err := contracts.NewDisputeGameFactoryContract(ctx, f.m, f.gameFactoryAddress, f.caller) if err != nil { - return "", fmt.Errorf("failed to load game impl: %w", err) + return "", fmt.Errorf("failed to create dispute game factory contract: %w", err) } - if gameImplAddr == (common.Address{}) { - return "", nil // No prestate is set, will only work if a single prestate is specified - } - gameImpl, err := contracts.NewFaultDisputeGameContract(ctx, f.m, gameImplAddr, f.caller) - if err != nil { - return "", fmt.Errorf("failed to create fault dispute game contract bindings for %v: %w", gameImplAddr, err) - } - prestateHash, err := gameImpl.GetAbsolutePrestateHash(ctx) + prestateHash, err := gameFactory.GetGamePrestate(ctx, f.gameType) if err != nil { - return "", fmt.Errorf("failed to get absolute prestate hash for %v: %w", gameImplAddr, err) + return "", fmt.Errorf("failed to get absolute prestate hash for game type %v: %w", f.gameType, err) } logger.Info("Using on-chain version of prestate", "prestate", prestateHash) hashFetcher := &HashPrestateFetcher{prestateHash: prestateHash} diff --git a/op-dispute-mon/mon/service.go b/op-dispute-mon/mon/service.go index 658ffd8767d..10856dd4bbb 100644 --- a/op-dispute-mon/mon/service.go +++ b/op-dispute-mon/mon/service.go @@ -84,7 +84,7 @@ func (s *Service) initFromConfig(ctx context.Context, cfg *config.Config) error if err := s.initMetricsServer(&cfg.MetricsConfig); err != nil { return fmt.Errorf("failed to init metrics server: %w", err) } - if err := s.initFactoryContract(cfg); err != nil { + if err := s.initFactoryContract(ctx, cfg); err != nil { return fmt.Errorf("failed to create factory contract bindings: %w", err) } if err := s.initOutputRollupClient(ctx, cfg); err != nil { @@ -254,8 +254,11 @@ func (s *Service) initMetricsServer(cfg *opmetrics.CLIConfig) error { return nil } -func (s *Service) initFactoryContract(cfg *config.Config) error { - factoryContract := contracts.NewDisputeGameFactoryContract(s.metrics, cfg.GameFactoryAddress, s.l1Caller) +func (s *Service) initFactoryContract(ctx context.Context, cfg *config.Config) error { + factoryContract, err := contracts.NewDisputeGameFactoryContract(ctx, s.metrics, cfg.GameFactoryAddress, s.l1Caller) + if err != nil { + return fmt.Errorf("failed to create dispute game factory contract: %w", err) + } s.factoryContract = factoryContract return nil } diff --git a/op-e2e/interop/interop_test.go b/op-e2e/interop/interop_test.go index ba014c5f1c2..ca03e511274 100644 --- a/op-e2e/interop/interop_test.go +++ b/op-e2e/interop/interop_test.go @@ -428,7 +428,8 @@ func TestProposals(t *testing.T) { rpcClient, err := dial.DialRPCClientWithTimeout(context.Background(), logger, s2.L1().UserRPC().RPC()) require.NoError(t, err) caller := batching.NewMultiCaller(rpcClient, batching.DefaultBatchSize) - factory := contracts.NewDisputeGameFactoryContract(metrics.NoopContractMetrics, gameFactoryAddr, caller) + factory, err := contracts.NewDisputeGameFactoryContract(context.Background(), metrics.NoopContractMetrics, gameFactoryAddr, caller) + require.NoError(t, err) ethClient := ethclient.NewClient(rpcClient) require.Eventually(t, func() bool { head, err := ethClient.BlockByNumber(context.Background(), nil) From 07a60447f9b180d0298c9e1534aa1b6a70241f42 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Alberto=20Cuesta=20Ca=C3=B1ada?= <38806121+alcueca@users.noreply.github.com> Date: Wed, 22 Oct 2025 00:13:51 +0100 Subject: [PATCH 111/117] Upgrade Gnosis Safe libs to 1.4.1 (#17962) * Updated the gnosis safe libs to 1.5.0 * Mass renaming * Added ERC165 support to TimelockGuard * Removed LivenessGuard and LivenessModule as they are deprecated * REimplemented safe.encodeTransactionData * Fix overrides and validator.isValidSignature call * Updated .gitmodules to 1.5.0 * fixed test_changeOwnershipToFallback_withOtherGuard_succeeds * fixed eip-1271 magic value * Revert Enum to common * Revert `isValidSignature` * ITransactionGuard -> Guard * Revert `encodeTransactionData` * Revert EIP1271_MAGIC_VALUE * fix: submodule version bug * fix: compile * fix: conflicts and bring old liveness back * fix: rm unused var * fix: guard to baseguard and versions * feat: dummyguard * feat: optimizer on op-service * feat: timelockguard guard to baseguard --------- Co-authored-by: JosepBove --- .gitmodules | 2 +- op-service/gnosis/contracts/foundry.toml | 5 +- .../gnosis/contracts/script/DeploySafe.s.sol | 4 +- .../interfaces/safe/IDeputyPauseModule.sol | 2 +- .../interfaces/safe/ILivenessGuard.sol | 2 +- .../interfaces/safe/ILivenessModule.sol | 2 +- packages/contracts-bedrock/lib/safe-contracts | 2 +- .../scripts/deploy/DeployAuthSystem.s.sol | 2 +- .../scripts/deploy/DeployAuthSystem2.s.sol | 2 +- .../scripts/deploy/DeployOwnership.s.sol | 8 +- .../snapshots/abi/DeputyPauseModule.json | 8 +- .../snapshots/abi/GnosisSafe.json | 1033 ----------------- .../snapshots/abi/LivenessGuard.json | 23 +- .../snapshots/abi/LivenessModule.json | 4 +- .../snapshots/abi/SaferSafes.json | 38 +- .../snapshots/semver-lock.json | 16 +- .../snapshots/storageLayout/GnosisSafe.json | 65 -- .../snapshots/storageLayout/SaferSafes.json | 6 +- .../src/safe/DeputyPauseModule.sol | 6 +- .../src/safe/LivenessGuard.sol | 8 +- .../src/safe/LivenessModule.sol | 6 +- .../src/safe/LivenessModule2.sol | 2 +- .../contracts-bedrock/src/safe/SaferSafes.sol | 6 +- .../src/safe/TimelockGuard.sol | 28 +- .../test/mocks/DummyGuard.sol | 44 + .../CompatibilityFallbackHandler_1_3_0.sol | 2 +- .../test/safe-tools/SafeTestTools.sol | 6 +- .../test/safe/LivenessGuard.t.sol | 2 +- .../test/safe/LivenessModule.t.sol | 2 +- .../test/safe/LivenessModule2.t.sol | 10 +- .../test/safe/SaferSafes.t.sol | 24 +- .../test/safe/TimelockGuard.t.sol | 2 +- .../test/scripts/DeployOwnership.t.sol | 2 +- 33 files changed, 161 insertions(+), 1213 deletions(-) delete mode 100644 packages/contracts-bedrock/snapshots/abi/GnosisSafe.json delete mode 100644 packages/contracts-bedrock/snapshots/storageLayout/GnosisSafe.json create mode 100644 packages/contracts-bedrock/test/mocks/DummyGuard.sol diff --git a/.gitmodules b/.gitmodules index d0ca670744b..1591d79b2a8 100644 --- a/.gitmodules +++ b/.gitmodules @@ -13,7 +13,7 @@ [submodule "packages/contracts-bedrock/lib/safe-contracts"] path = packages/contracts-bedrock/lib/safe-contracts url = https://github.com/safe-global/safe-contracts - branch = v1.4.0 + branch = v1.4.1 [submodule "packages/contracts-bedrock/lib/kontrol-cheatcodes"] path = packages/contracts-bedrock/lib/kontrol-cheatcodes url = https://github.com/runtimeverification/kontrol-cheatcodes diff --git a/op-service/gnosis/contracts/foundry.toml b/op-service/gnosis/contracts/foundry.toml index 3bcb3188377..2859b320874 100644 --- a/op-service/gnosis/contracts/foundry.toml +++ b/op-service/gnosis/contracts/foundry.toml @@ -3,7 +3,10 @@ src = "src" out = "out" libs = ["../../../packages/contracts-bedrock/lib"] +optimizer = true +optimizer_runs = 999999 + remappings = [ 'forge-std/=../../../packages/contracts-bedrock/lib/forge-std/src', 'safe-contracts/=../../../packages/contracts-bedrock/lib/safe-contracts/contracts', -] \ No newline at end of file +] diff --git a/op-service/gnosis/contracts/script/DeploySafe.s.sol b/op-service/gnosis/contracts/script/DeploySafe.s.sol index 5fc3bec5cca..e42965c5655 100644 --- a/op-service/gnosis/contracts/script/DeploySafe.s.sol +++ b/op-service/gnosis/contracts/script/DeploySafe.s.sol @@ -3,8 +3,8 @@ pragma solidity ^0.8.19; import { Script } from "forge-std/Script.sol"; import { console } from "forge-std/console.sol"; -import { GnosisSafe } from "safe-contracts/GnosisSafe.sol"; -import { GnosisSafeProxyFactory } from "safe-contracts/proxies/GnosisSafeProxyFactory.sol"; +import { Safe as GnosisSafe } from "safe-contracts/Safe.sol"; +import { SafeProxyFactory as GnosisSafeProxyFactory } from "safe-contracts/proxies/SafeProxyFactory.sol"; import { TestDelegateCall } from "src/TestDelegateCall.sol"; contract DeploySafe is Script { diff --git a/packages/contracts-bedrock/interfaces/safe/IDeputyPauseModule.sol b/packages/contracts-bedrock/interfaces/safe/IDeputyPauseModule.sol index 974533a9dc9..6065c195b3c 100644 --- a/packages/contracts-bedrock/interfaces/safe/IDeputyPauseModule.sol +++ b/packages/contracts-bedrock/interfaces/safe/IDeputyPauseModule.sol @@ -1,7 +1,7 @@ // SPDX-License-Identifier: MIT pragma solidity ^0.8.0; -import { GnosisSafe as Safe } from "safe-contracts/GnosisSafe.sol"; +import { Safe } from "safe-contracts/Safe.sol"; import { ISemver } from "interfaces/universal/ISemver.sol"; import { ISuperchainConfig } from "interfaces/L1/ISuperchainConfig.sol"; diff --git a/packages/contracts-bedrock/interfaces/safe/ILivenessGuard.sol b/packages/contracts-bedrock/interfaces/safe/ILivenessGuard.sol index db6761096d1..c1622863de4 100644 --- a/packages/contracts-bedrock/interfaces/safe/ILivenessGuard.sol +++ b/packages/contracts-bedrock/interfaces/safe/ILivenessGuard.sol @@ -1,7 +1,7 @@ // SPDX-License-Identifier: MIT pragma solidity ^0.8.0; -import { GnosisSafe as Safe } from "safe-contracts/GnosisSafe.sol"; +import { Safe } from "safe-contracts/Safe.sol"; import { Enum } from "safe-contracts/common/Enum.sol"; import { ISemver } from "interfaces/universal/ISemver.sol"; diff --git a/packages/contracts-bedrock/interfaces/safe/ILivenessModule.sol b/packages/contracts-bedrock/interfaces/safe/ILivenessModule.sol index ad5088fcf2b..0ac073438b3 100644 --- a/packages/contracts-bedrock/interfaces/safe/ILivenessModule.sol +++ b/packages/contracts-bedrock/interfaces/safe/ILivenessModule.sol @@ -1,7 +1,7 @@ // SPDX-License-Identifier: MIT pragma solidity ^0.8.0; -import { GnosisSafe as Safe } from "safe-contracts/GnosisSafe.sol"; +import { Safe } from "safe-contracts/Safe.sol"; import { LivenessGuard } from "src/safe/LivenessGuard.sol"; import { ISemver } from "interfaces/universal/ISemver.sol"; diff --git a/packages/contracts-bedrock/lib/safe-contracts b/packages/contracts-bedrock/lib/safe-contracts index 186a21a74b3..bf943f80fec 160000 --- a/packages/contracts-bedrock/lib/safe-contracts +++ b/packages/contracts-bedrock/lib/safe-contracts @@ -1 +1 @@ -Subproject commit 186a21a74b327f17fc41217a927dea7064f74604 +Subproject commit bf943f80fec5ac647159d26161446ac5d716a294 diff --git a/packages/contracts-bedrock/scripts/deploy/DeployAuthSystem.s.sol b/packages/contracts-bedrock/scripts/deploy/DeployAuthSystem.s.sol index 268e2434479..3acd87cc041 100644 --- a/packages/contracts-bedrock/scripts/deploy/DeployAuthSystem.s.sol +++ b/packages/contracts-bedrock/scripts/deploy/DeployAuthSystem.s.sol @@ -5,7 +5,7 @@ import { Script } from "forge-std/Script.sol"; import { CommonBase } from "forge-std/Base.sol"; import { stdToml } from "forge-std/StdToml.sol"; -import { GnosisSafe as Safe } from "safe-contracts/GnosisSafe.sol"; +import { Safe } from "safe-contracts/Safe.sol"; import { DeployUtils } from "scripts/libraries/DeployUtils.sol"; import { Solarray } from "scripts/libraries/Solarray.sol"; diff --git a/packages/contracts-bedrock/scripts/deploy/DeployAuthSystem2.s.sol b/packages/contracts-bedrock/scripts/deploy/DeployAuthSystem2.s.sol index d951cc3ee20..fad2ceb60e1 100644 --- a/packages/contracts-bedrock/scripts/deploy/DeployAuthSystem2.s.sol +++ b/packages/contracts-bedrock/scripts/deploy/DeployAuthSystem2.s.sol @@ -3,7 +3,7 @@ pragma solidity 0.8.15; import { Script } from "forge-std/Script.sol"; -import { GnosisSafe as Safe } from "safe-contracts/GnosisSafe.sol"; +import { Safe } from "safe-contracts/Safe.sol"; import { DeployUtils } from "scripts/libraries/DeployUtils.sol"; diff --git a/packages/contracts-bedrock/scripts/deploy/DeployOwnership.s.sol b/packages/contracts-bedrock/scripts/deploy/DeployOwnership.s.sol index d340380e96f..f40fde014a5 100644 --- a/packages/contracts-bedrock/scripts/deploy/DeployOwnership.s.sol +++ b/packages/contracts-bedrock/scripts/deploy/DeployOwnership.s.sol @@ -3,11 +3,11 @@ pragma solidity ^0.8.0; import { console2 as console } from "forge-std/console2.sol"; -import { GnosisSafe as Safe } from "safe-contracts/GnosisSafe.sol"; -import { GnosisSafeProxyFactory as SafeProxyFactory } from "safe-contracts/proxies/GnosisSafeProxyFactory.sol"; +import { Safe } from "safe-contracts/Safe.sol"; +import { SafeProxyFactory } from "safe-contracts/proxies/SafeProxyFactory.sol"; +import { Enum } from "safe-contracts/common/Enum.sol"; import { OwnerManager } from "safe-contracts/base/OwnerManager.sol"; import { ModuleManager } from "safe-contracts/base/ModuleManager.sol"; -import { Enum as SafeOps } from "safe-contracts/common/Enum.sol"; import { DeployUtils } from "scripts/libraries/DeployUtils.sol"; @@ -119,7 +119,7 @@ contract DeployOwnership is Deploy { to: _target, value: 0, data: _data, - operation: SafeOps.Operation.Call, + operation: Enum.Operation.Call, safeTxGas: 0, baseGas: 0, gasPrice: 0, diff --git a/packages/contracts-bedrock/snapshots/abi/DeputyPauseModule.json b/packages/contracts-bedrock/snapshots/abi/DeputyPauseModule.json index 94b35b464d6..268f964b6f5 100644 --- a/packages/contracts-bedrock/snapshots/abi/DeputyPauseModule.json +++ b/packages/contracts-bedrock/snapshots/abi/DeputyPauseModule.json @@ -2,12 +2,12 @@ { "inputs": [ { - "internalType": "contract GnosisSafe", + "internalType": "contract Safe", "name": "_guardianSafe", "type": "address" }, { - "internalType": "contract GnosisSafe", + "internalType": "contract Safe", "name": "_foundationSafe", "type": "address" }, @@ -104,7 +104,7 @@ "name": "foundationSafe", "outputs": [ { - "internalType": "contract GnosisSafe", + "internalType": "contract Safe", "name": "foundationSafe_", "type": "address" } @@ -117,7 +117,7 @@ "name": "guardianSafe", "outputs": [ { - "internalType": "contract GnosisSafe", + "internalType": "contract Safe", "name": "guardianSafe_", "type": "address" } diff --git a/packages/contracts-bedrock/snapshots/abi/GnosisSafe.json b/packages/contracts-bedrock/snapshots/abi/GnosisSafe.json deleted file mode 100644 index d9fe937c8f7..00000000000 --- a/packages/contracts-bedrock/snapshots/abi/GnosisSafe.json +++ /dev/null @@ -1,1033 +0,0 @@ -[ - { - "inputs": [], - "stateMutability": "nonpayable", - "type": "constructor" - }, - { - "stateMutability": "nonpayable", - "type": "fallback" - }, - { - "stateMutability": "payable", - "type": "receive" - }, - { - "inputs": [], - "name": "VERSION", - "outputs": [ - { - "internalType": "string", - "name": "", - "type": "string" - } - ], - "stateMutability": "view", - "type": "function" - }, - { - "inputs": [ - { - "internalType": "address", - "name": "owner", - "type": "address" - }, - { - "internalType": "uint256", - "name": "_threshold", - "type": "uint256" - } - ], - "name": "addOwnerWithThreshold", - "outputs": [], - "stateMutability": "nonpayable", - "type": "function" - }, - { - "inputs": [ - { - "internalType": "bytes32", - "name": "hashToApprove", - "type": "bytes32" - } - ], - "name": "approveHash", - "outputs": [], - "stateMutability": "nonpayable", - "type": "function" - }, - { - "inputs": [ - { - "internalType": "address", - "name": "", - "type": "address" - }, - { - "internalType": "bytes32", - "name": "", - "type": "bytes32" - } - ], - "name": "approvedHashes", - "outputs": [ - { - "internalType": "uint256", - "name": "", - "type": "uint256" - } - ], - "stateMutability": "view", - "type": "function" - }, - { - "inputs": [ - { - "internalType": "uint256", - "name": "_threshold", - "type": "uint256" - } - ], - "name": "changeThreshold", - "outputs": [], - "stateMutability": "nonpayable", - "type": "function" - }, - { - "inputs": [ - { - "internalType": "bytes32", - "name": "dataHash", - "type": "bytes32" - }, - { - "internalType": "bytes", - "name": "data", - "type": "bytes" - }, - { - "internalType": "bytes", - "name": "signatures", - "type": "bytes" - }, - { - "internalType": "uint256", - "name": "requiredSignatures", - "type": "uint256" - } - ], - "name": "checkNSignatures", - "outputs": [], - "stateMutability": "view", - "type": "function" - }, - { - "inputs": [ - { - "internalType": "bytes32", - "name": "dataHash", - "type": "bytes32" - }, - { - "internalType": "bytes", - "name": "data", - "type": "bytes" - }, - { - "internalType": "bytes", - "name": "signatures", - "type": "bytes" - } - ], - "name": "checkSignatures", - "outputs": [], - "stateMutability": "view", - "type": "function" - }, - { - "inputs": [ - { - "internalType": "address", - "name": "prevModule", - "type": "address" - }, - { - "internalType": "address", - "name": "module", - "type": "address" - } - ], - "name": "disableModule", - "outputs": [], - "stateMutability": "nonpayable", - "type": "function" - }, - { - "inputs": [], - "name": "domainSeparator", - "outputs": [ - { - "internalType": "bytes32", - "name": "", - "type": "bytes32" - } - ], - "stateMutability": "view", - "type": "function" - }, - { - "inputs": [ - { - "internalType": "address", - "name": "module", - "type": "address" - } - ], - "name": "enableModule", - "outputs": [], - "stateMutability": "nonpayable", - "type": "function" - }, - { - "inputs": [ - { - "internalType": "address", - "name": "to", - "type": "address" - }, - { - "internalType": "uint256", - "name": "value", - "type": "uint256" - }, - { - "internalType": "bytes", - "name": "data", - "type": "bytes" - }, - { - "internalType": "enum Enum.Operation", - "name": "operation", - "type": "uint8" - }, - { - "internalType": "uint256", - "name": "safeTxGas", - "type": "uint256" - }, - { - "internalType": "uint256", - "name": "baseGas", - "type": "uint256" - }, - { - "internalType": "uint256", - "name": "gasPrice", - "type": "uint256" - }, - { - "internalType": "address", - "name": "gasToken", - "type": "address" - }, - { - "internalType": "address", - "name": "refundReceiver", - "type": "address" - }, - { - "internalType": "uint256", - "name": "_nonce", - "type": "uint256" - } - ], - "name": "encodeTransactionData", - "outputs": [ - { - "internalType": "bytes", - "name": "", - "type": "bytes" - } - ], - "stateMutability": "view", - "type": "function" - }, - { - "inputs": [ - { - "internalType": "address", - "name": "to", - "type": "address" - }, - { - "internalType": "uint256", - "name": "value", - "type": "uint256" - }, - { - "internalType": "bytes", - "name": "data", - "type": "bytes" - }, - { - "internalType": "enum Enum.Operation", - "name": "operation", - "type": "uint8" - }, - { - "internalType": "uint256", - "name": "safeTxGas", - "type": "uint256" - }, - { - "internalType": "uint256", - "name": "baseGas", - "type": "uint256" - }, - { - "internalType": "uint256", - "name": "gasPrice", - "type": "uint256" - }, - { - "internalType": "address", - "name": "gasToken", - "type": "address" - }, - { - "internalType": "address payable", - "name": "refundReceiver", - "type": "address" - }, - { - "internalType": "bytes", - "name": "signatures", - "type": "bytes" - } - ], - "name": "execTransaction", - "outputs": [ - { - "internalType": "bool", - "name": "success", - "type": "bool" - } - ], - "stateMutability": "payable", - "type": "function" - }, - { - "inputs": [ - { - "internalType": "address", - "name": "to", - "type": "address" - }, - { - "internalType": "uint256", - "name": "value", - "type": "uint256" - }, - { - "internalType": "bytes", - "name": "data", - "type": "bytes" - }, - { - "internalType": "enum Enum.Operation", - "name": "operation", - "type": "uint8" - } - ], - "name": "execTransactionFromModule", - "outputs": [ - { - "internalType": "bool", - "name": "success", - "type": "bool" - } - ], - "stateMutability": "nonpayable", - "type": "function" - }, - { - "inputs": [ - { - "internalType": "address", - "name": "to", - "type": "address" - }, - { - "internalType": "uint256", - "name": "value", - "type": "uint256" - }, - { - "internalType": "bytes", - "name": "data", - "type": "bytes" - }, - { - "internalType": "enum Enum.Operation", - "name": "operation", - "type": "uint8" - } - ], - "name": "execTransactionFromModuleReturnData", - "outputs": [ - { - "internalType": "bool", - "name": "success", - "type": "bool" - }, - { - "internalType": "bytes", - "name": "returnData", - "type": "bytes" - } - ], - "stateMutability": "nonpayable", - "type": "function" - }, - { - "inputs": [], - "name": "getChainId", - "outputs": [ - { - "internalType": "uint256", - "name": "", - "type": "uint256" - } - ], - "stateMutability": "view", - "type": "function" - }, - { - "inputs": [ - { - "internalType": "address", - "name": "start", - "type": "address" - }, - { - "internalType": "uint256", - "name": "pageSize", - "type": "uint256" - } - ], - "name": "getModulesPaginated", - "outputs": [ - { - "internalType": "address[]", - "name": "array", - "type": "address[]" - }, - { - "internalType": "address", - "name": "next", - "type": "address" - } - ], - "stateMutability": "view", - "type": "function" - }, - { - "inputs": [], - "name": "getOwners", - "outputs": [ - { - "internalType": "address[]", - "name": "", - "type": "address[]" - } - ], - "stateMutability": "view", - "type": "function" - }, - { - "inputs": [ - { - "internalType": "uint256", - "name": "offset", - "type": "uint256" - }, - { - "internalType": "uint256", - "name": "length", - "type": "uint256" - } - ], - "name": "getStorageAt", - "outputs": [ - { - "internalType": "bytes", - "name": "", - "type": "bytes" - } - ], - "stateMutability": "view", - "type": "function" - }, - { - "inputs": [], - "name": "getThreshold", - "outputs": [ - { - "internalType": "uint256", - "name": "", - "type": "uint256" - } - ], - "stateMutability": "view", - "type": "function" - }, - { - "inputs": [ - { - "internalType": "address", - "name": "to", - "type": "address" - }, - { - "internalType": "uint256", - "name": "value", - "type": "uint256" - }, - { - "internalType": "bytes", - "name": "data", - "type": "bytes" - }, - { - "internalType": "enum Enum.Operation", - "name": "operation", - "type": "uint8" - }, - { - "internalType": "uint256", - "name": "safeTxGas", - "type": "uint256" - }, - { - "internalType": "uint256", - "name": "baseGas", - "type": "uint256" - }, - { - "internalType": "uint256", - "name": "gasPrice", - "type": "uint256" - }, - { - "internalType": "address", - "name": "gasToken", - "type": "address" - }, - { - "internalType": "address", - "name": "refundReceiver", - "type": "address" - }, - { - "internalType": "uint256", - "name": "_nonce", - "type": "uint256" - } - ], - "name": "getTransactionHash", - "outputs": [ - { - "internalType": "bytes32", - "name": "", - "type": "bytes32" - } - ], - "stateMutability": "view", - "type": "function" - }, - { - "inputs": [ - { - "internalType": "address", - "name": "module", - "type": "address" - } - ], - "name": "isModuleEnabled", - "outputs": [ - { - "internalType": "bool", - "name": "", - "type": "bool" - } - ], - "stateMutability": "view", - "type": "function" - }, - { - "inputs": [ - { - "internalType": "address", - "name": "owner", - "type": "address" - } - ], - "name": "isOwner", - "outputs": [ - { - "internalType": "bool", - "name": "", - "type": "bool" - } - ], - "stateMutability": "view", - "type": "function" - }, - { - "inputs": [], - "name": "nonce", - "outputs": [ - { - "internalType": "uint256", - "name": "", - "type": "uint256" - } - ], - "stateMutability": "view", - "type": "function" - }, - { - "inputs": [ - { - "internalType": "address", - "name": "prevOwner", - "type": "address" - }, - { - "internalType": "address", - "name": "owner", - "type": "address" - }, - { - "internalType": "uint256", - "name": "_threshold", - "type": "uint256" - } - ], - "name": "removeOwner", - "outputs": [], - "stateMutability": "nonpayable", - "type": "function" - }, - { - "inputs": [ - { - "internalType": "address", - "name": "to", - "type": "address" - }, - { - "internalType": "uint256", - "name": "value", - "type": "uint256" - }, - { - "internalType": "bytes", - "name": "data", - "type": "bytes" - }, - { - "internalType": "enum Enum.Operation", - "name": "operation", - "type": "uint8" - } - ], - "name": "requiredTxGas", - "outputs": [ - { - "internalType": "uint256", - "name": "", - "type": "uint256" - } - ], - "stateMutability": "nonpayable", - "type": "function" - }, - { - "inputs": [ - { - "internalType": "address", - "name": "handler", - "type": "address" - } - ], - "name": "setFallbackHandler", - "outputs": [], - "stateMutability": "nonpayable", - "type": "function" - }, - { - "inputs": [ - { - "internalType": "address", - "name": "guard", - "type": "address" - } - ], - "name": "setGuard", - "outputs": [], - "stateMutability": "nonpayable", - "type": "function" - }, - { - "inputs": [ - { - "internalType": "address[]", - "name": "_owners", - "type": "address[]" - }, - { - "internalType": "uint256", - "name": "_threshold", - "type": "uint256" - }, - { - "internalType": "address", - "name": "to", - "type": "address" - }, - { - "internalType": "bytes", - "name": "data", - "type": "bytes" - }, - { - "internalType": "address", - "name": "fallbackHandler", - "type": "address" - }, - { - "internalType": "address", - "name": "paymentToken", - "type": "address" - }, - { - "internalType": "uint256", - "name": "payment", - "type": "uint256" - }, - { - "internalType": "address payable", - "name": "paymentReceiver", - "type": "address" - } - ], - "name": "setup", - "outputs": [], - "stateMutability": "nonpayable", - "type": "function" - }, - { - "inputs": [ - { - "internalType": "bytes32", - "name": "", - "type": "bytes32" - } - ], - "name": "signedMessages", - "outputs": [ - { - "internalType": "uint256", - "name": "", - "type": "uint256" - } - ], - "stateMutability": "view", - "type": "function" - }, - { - "inputs": [ - { - "internalType": "address", - "name": "targetContract", - "type": "address" - }, - { - "internalType": "bytes", - "name": "calldataPayload", - "type": "bytes" - } - ], - "name": "simulateAndRevert", - "outputs": [], - "stateMutability": "nonpayable", - "type": "function" - }, - { - "inputs": [ - { - "internalType": "address", - "name": "prevOwner", - "type": "address" - }, - { - "internalType": "address", - "name": "oldOwner", - "type": "address" - }, - { - "internalType": "address", - "name": "newOwner", - "type": "address" - } - ], - "name": "swapOwner", - "outputs": [], - "stateMutability": "nonpayable", - "type": "function" - }, - { - "anonymous": false, - "inputs": [ - { - "indexed": false, - "internalType": "address", - "name": "owner", - "type": "address" - } - ], - "name": "AddedOwner", - "type": "event" - }, - { - "anonymous": false, - "inputs": [ - { - "indexed": true, - "internalType": "bytes32", - "name": "approvedHash", - "type": "bytes32" - }, - { - "indexed": true, - "internalType": "address", - "name": "owner", - "type": "address" - } - ], - "name": "ApproveHash", - "type": "event" - }, - { - "anonymous": false, - "inputs": [ - { - "indexed": false, - "internalType": "address", - "name": "handler", - "type": "address" - } - ], - "name": "ChangedFallbackHandler", - "type": "event" - }, - { - "anonymous": false, - "inputs": [ - { - "indexed": false, - "internalType": "address", - "name": "guard", - "type": "address" - } - ], - "name": "ChangedGuard", - "type": "event" - }, - { - "anonymous": false, - "inputs": [ - { - "indexed": false, - "internalType": "uint256", - "name": "threshold", - "type": "uint256" - } - ], - "name": "ChangedThreshold", - "type": "event" - }, - { - "anonymous": false, - "inputs": [ - { - "indexed": false, - "internalType": "address", - "name": "module", - "type": "address" - } - ], - "name": "DisabledModule", - "type": "event" - }, - { - "anonymous": false, - "inputs": [ - { - "indexed": false, - "internalType": "address", - "name": "module", - "type": "address" - } - ], - "name": "EnabledModule", - "type": "event" - }, - { - "anonymous": false, - "inputs": [ - { - "indexed": false, - "internalType": "bytes32", - "name": "txHash", - "type": "bytes32" - }, - { - "indexed": false, - "internalType": "uint256", - "name": "payment", - "type": "uint256" - } - ], - "name": "ExecutionFailure", - "type": "event" - }, - { - "anonymous": false, - "inputs": [ - { - "indexed": true, - "internalType": "address", - "name": "module", - "type": "address" - } - ], - "name": "ExecutionFromModuleFailure", - "type": "event" - }, - { - "anonymous": false, - "inputs": [ - { - "indexed": true, - "internalType": "address", - "name": "module", - "type": "address" - } - ], - "name": "ExecutionFromModuleSuccess", - "type": "event" - }, - { - "anonymous": false, - "inputs": [ - { - "indexed": false, - "internalType": "bytes32", - "name": "txHash", - "type": "bytes32" - }, - { - "indexed": false, - "internalType": "uint256", - "name": "payment", - "type": "uint256" - } - ], - "name": "ExecutionSuccess", - "type": "event" - }, - { - "anonymous": false, - "inputs": [ - { - "indexed": false, - "internalType": "address", - "name": "owner", - "type": "address" - } - ], - "name": "RemovedOwner", - "type": "event" - }, - { - "anonymous": false, - "inputs": [ - { - "indexed": true, - "internalType": "address", - "name": "sender", - "type": "address" - }, - { - "indexed": false, - "internalType": "uint256", - "name": "value", - "type": "uint256" - } - ], - "name": "SafeReceived", - "type": "event" - }, - { - "anonymous": false, - "inputs": [ - { - "indexed": true, - "internalType": "address", - "name": "initiator", - "type": "address" - }, - { - "indexed": false, - "internalType": "address[]", - "name": "owners", - "type": "address[]" - }, - { - "indexed": false, - "internalType": "uint256", - "name": "threshold", - "type": "uint256" - }, - { - "indexed": false, - "internalType": "address", - "name": "initializer", - "type": "address" - }, - { - "indexed": false, - "internalType": "address", - "name": "fallbackHandler", - "type": "address" - } - ], - "name": "SafeSetup", - "type": "event" - }, - { - "anonymous": false, - "inputs": [ - { - "indexed": true, - "internalType": "bytes32", - "name": "msgHash", - "type": "bytes32" - } - ], - "name": "SignMsg", - "type": "event" - } -] \ No newline at end of file diff --git a/packages/contracts-bedrock/snapshots/abi/LivenessGuard.json b/packages/contracts-bedrock/snapshots/abi/LivenessGuard.json index 6193a882c15..6652bffb5ae 100644 --- a/packages/contracts-bedrock/snapshots/abi/LivenessGuard.json +++ b/packages/contracts-bedrock/snapshots/abi/LivenessGuard.json @@ -2,7 +2,7 @@ { "inputs": [ { - "internalType": "contract GnosisSafe", + "internalType": "contract Safe", "name": "_safe", "type": "address" } @@ -115,7 +115,7 @@ "name": "safe", "outputs": [ { - "internalType": "contract GnosisSafe", + "internalType": "contract Safe", "name": "safe_", "type": "address" } @@ -130,6 +130,25 @@ "stateMutability": "nonpayable", "type": "function" }, + { + "inputs": [ + { + "internalType": "bytes4", + "name": "interfaceId", + "type": "bytes4" + } + ], + "name": "supportsInterface", + "outputs": [ + { + "internalType": "bool", + "name": "", + "type": "bool" + } + ], + "stateMutability": "view", + "type": "function" + }, { "inputs": [], "name": "version", diff --git a/packages/contracts-bedrock/snapshots/abi/LivenessModule.json b/packages/contracts-bedrock/snapshots/abi/LivenessModule.json index 5a0a4630072..540a1b2769e 100644 --- a/packages/contracts-bedrock/snapshots/abi/LivenessModule.json +++ b/packages/contracts-bedrock/snapshots/abi/LivenessModule.json @@ -2,7 +2,7 @@ { "inputs": [ { - "internalType": "contract GnosisSafe", + "internalType": "contract Safe", "name": "_safe", "type": "address" }, @@ -161,7 +161,7 @@ "name": "safe", "outputs": [ { - "internalType": "contract GnosisSafe", + "internalType": "contract Safe", "name": "safe_", "type": "address" } diff --git a/packages/contracts-bedrock/snapshots/abi/SaferSafes.json b/packages/contracts-bedrock/snapshots/abi/SaferSafes.json index 1589521678a..f55f689f4b5 100644 --- a/packages/contracts-bedrock/snapshots/abi/SaferSafes.json +++ b/packages/contracts-bedrock/snapshots/abi/SaferSafes.json @@ -2,7 +2,7 @@ { "inputs": [ { - "internalType": "contract GnosisSafe", + "internalType": "contract Safe", "name": "_safe", "type": "address" }, @@ -30,7 +30,7 @@ { "inputs": [ { - "internalType": "contract GnosisSafe", + "internalType": "contract Safe", "name": "_safe", "type": "address" } @@ -49,7 +49,7 @@ { "inputs": [ { - "internalType": "contract GnosisSafe", + "internalType": "contract Safe", "name": "_safe", "type": "address" } @@ -62,7 +62,7 @@ { "inputs": [ { - "internalType": "contract GnosisSafe", + "internalType": "contract Safe", "name": "", "type": "address" } @@ -81,7 +81,7 @@ { "inputs": [ { - "internalType": "contract GnosisSafe", + "internalType": "contract Safe", "name": "_safe", "type": "address" } @@ -227,7 +227,7 @@ { "inputs": [ { - "internalType": "contract GnosisSafe", + "internalType": "contract Safe", "name": "_safe", "type": "address" } @@ -246,7 +246,7 @@ { "inputs": [ { - "internalType": "contract GnosisSafe", + "internalType": "contract Safe", "name": "_safe", "type": "address" } @@ -277,7 +277,7 @@ { "inputs": [ { - "internalType": "contract GnosisSafe", + "internalType": "contract Safe", "name": "_safe", "type": "address" } @@ -296,7 +296,7 @@ { "inputs": [ { - "internalType": "contract GnosisSafe", + "internalType": "contract Safe", "name": "_safe", "type": "address" } @@ -386,7 +386,7 @@ { "inputs": [ { - "internalType": "contract GnosisSafe", + "internalType": "contract Safe", "name": "_safe", "type": "address" }, @@ -461,7 +461,7 @@ { "inputs": [ { - "internalType": "contract GnosisSafe", + "internalType": "contract Safe", "name": "_safe", "type": "address" }, @@ -563,7 +563,7 @@ "inputs": [ { "internalType": "bytes4", - "name": "_interfaceId", + "name": "interfaceId", "type": "bytes4" } ], @@ -581,7 +581,7 @@ { "inputs": [ { - "internalType": "contract GnosisSafe", + "internalType": "contract Safe", "name": "_safe", "type": "address" } @@ -615,7 +615,7 @@ "inputs": [ { "indexed": true, - "internalType": "contract GnosisSafe", + "internalType": "contract Safe", "name": "safe", "type": "address" }, @@ -691,7 +691,7 @@ "inputs": [ { "indexed": true, - "internalType": "contract GnosisSafe", + "internalType": "contract Safe", "name": "safe", "type": "address" }, @@ -761,7 +761,7 @@ "inputs": [ { "indexed": true, - "internalType": "contract GnosisSafe", + "internalType": "contract Safe", "name": "safe", "type": "address" }, @@ -780,7 +780,7 @@ "inputs": [ { "indexed": true, - "internalType": "contract GnosisSafe", + "internalType": "contract Safe", "name": "safe", "type": "address" }, @@ -799,7 +799,7 @@ "inputs": [ { "indexed": true, - "internalType": "contract GnosisSafe", + "internalType": "contract Safe", "name": "safe", "type": "address" }, @@ -824,7 +824,7 @@ "inputs": [ { "indexed": true, - "internalType": "contract GnosisSafe", + "internalType": "contract Safe", "name": "safe", "type": "address" }, diff --git a/packages/contracts-bedrock/snapshots/semver-lock.json b/packages/contracts-bedrock/snapshots/semver-lock.json index a9d5a0fe78c..24fb544ce17 100644 --- a/packages/contracts-bedrock/snapshots/semver-lock.json +++ b/packages/contracts-bedrock/snapshots/semver-lock.json @@ -196,20 +196,20 @@ "sourceCodeHash": "0x955bd0c9b47e43219865e4e92abf28d916c96de20cbdf2f94c8ab14d02083759" }, "src/safe/DeputyPauseModule.sol:DeputyPauseModule": { - "initCodeHash": "0x4685af7d7c54b3bc5614afb735f34ae311d1d86d5112b9d28d931bc372b94ea8", - "sourceCodeHash": "0x2dc7c513be25e1350ae1caa71adad91a7cde91125540699ce83489dd772330ad" + "initCodeHash": "0x18422b48c4901ed6fd9338d76d3c5aecfff9a7add34b05c6e21c23d0011ed6bf", + "sourceCodeHash": "0xd15f4bb43e81a10317902cd8e27394581a59df2656b130727eb67543c985c72e" }, "src/safe/LivenessGuard.sol:LivenessGuard": { - "initCodeHash": "0x406db1c5a127f76970791b8a7f6ff62b81481ab25cf32615bfed551cdd5cd844", - "sourceCodeHash": "0xca3712277637e9d1b63ed16e35ef968032c12be9187c36146c171ac3e9f0cd73" + "initCodeHash": "0x2c55a3800e8b4934c0e8eacd61e35c4210dcc659a9cf8e3e2792e1d822096656", + "sourceCodeHash": "0x62e1354f04f8de3edb58aa8517faf803cd69e6b5f1ce850ac83690bf6be0d25a" }, "src/safe/LivenessModule.sol:LivenessModule": { - "initCodeHash": "0xa4a06e8778dbb6883ece8f56538ba15bc01b3031bba9a12ad9d187e7c8aaa942", - "sourceCodeHash": "0x950725f8b9ad9bb3b6b5e836f67e18db824a7864bac547ee0eeba88ada3de0e9" + "initCodeHash": "0x5e980d76c3eb8820b25e45142c68324a65e47b0fabbf171a6a4bef10476ec80e", + "sourceCodeHash": "0x7fc4789b082bc8ecd29c4c75a06058f0ff0b72f1c1028a42db6f1c35269c8865" }, "src/safe/SaferSafes.sol:SaferSafes": { - "initCodeHash": "0x95ee7ae09ee281f224425f152c9154e43e49838edbe3eee48c15301e5f410d25", - "sourceCodeHash": "0xdc794e3d6decb47c51d86bb2f69523feade4fd3f81feb4734800f24b40d40a50" + "initCodeHash": "0xc546c21b73dce6c0b04ab5ddca56f61f648e26fc8345d0dcf160d94767dc4af6", + "sourceCodeHash": "0x22d773a7d6cc981b374b7cdc823e418293e0a82714757cac1ebb6079b2f9650b" }, "src/universal/OptimismMintableERC20.sol:OptimismMintableERC20": { "initCodeHash": "0x3c85eed0d017dca8eda6396aa842ddc12492587b061e8c756a8d32c4610a9658", diff --git a/packages/contracts-bedrock/snapshots/storageLayout/GnosisSafe.json b/packages/contracts-bedrock/snapshots/storageLayout/GnosisSafe.json deleted file mode 100644 index df6caa938d1..00000000000 --- a/packages/contracts-bedrock/snapshots/storageLayout/GnosisSafe.json +++ /dev/null @@ -1,65 +0,0 @@ -[ - { - "bytes": "20", - "label": "singleton", - "offset": 0, - "slot": "0", - "type": "address" - }, - { - "bytes": "32", - "label": "modules", - "offset": 0, - "slot": "1", - "type": "mapping(address => address)" - }, - { - "bytes": "32", - "label": "owners", - "offset": 0, - "slot": "2", - "type": "mapping(address => address)" - }, - { - "bytes": "32", - "label": "ownerCount", - "offset": 0, - "slot": "3", - "type": "uint256" - }, - { - "bytes": "32", - "label": "threshold", - "offset": 0, - "slot": "4", - "type": "uint256" - }, - { - "bytes": "32", - "label": "nonce", - "offset": 0, - "slot": "5", - "type": "uint256" - }, - { - "bytes": "32", - "label": "_deprecatedDomainSeparator", - "offset": 0, - "slot": "6", - "type": "bytes32" - }, - { - "bytes": "32", - "label": "signedMessages", - "offset": 0, - "slot": "7", - "type": "mapping(bytes32 => uint256)" - }, - { - "bytes": "32", - "label": "approvedHashes", - "offset": 0, - "slot": "8", - "type": "mapping(address => mapping(bytes32 => uint256))" - } -] \ No newline at end of file diff --git a/packages/contracts-bedrock/snapshots/storageLayout/SaferSafes.json b/packages/contracts-bedrock/snapshots/storageLayout/SaferSafes.json index c8fa41d7a3c..661840f7c90 100644 --- a/packages/contracts-bedrock/snapshots/storageLayout/SaferSafes.json +++ b/packages/contracts-bedrock/snapshots/storageLayout/SaferSafes.json @@ -4,20 +4,20 @@ "label": "_livenessSafeConfiguration", "offset": 0, "slot": "0", - "type": "mapping(contract GnosisSafe => struct LivenessModule2.ModuleConfig)" + "type": "mapping(contract Safe => struct LivenessModule2.ModuleConfig)" }, { "bytes": "32", "label": "challengeStartTime", "offset": 0, "slot": "1", - "type": "mapping(contract GnosisSafe => uint256)" + "type": "mapping(contract Safe => uint256)" }, { "bytes": "32", "label": "_safeState", "offset": 0, "slot": "2", - "type": "mapping(contract GnosisSafe => struct TimelockGuard.SafeState)" + "type": "mapping(contract Safe => struct TimelockGuard.SafeState)" } ] \ No newline at end of file diff --git a/packages/contracts-bedrock/src/safe/DeputyPauseModule.sol b/packages/contracts-bedrock/src/safe/DeputyPauseModule.sol index 967561e8bbe..b4dcdfe6bcf 100644 --- a/packages/contracts-bedrock/src/safe/DeputyPauseModule.sol +++ b/packages/contracts-bedrock/src/safe/DeputyPauseModule.sol @@ -2,7 +2,7 @@ pragma solidity 0.8.25; // Safe -import { GnosisSafe as Safe } from "safe-contracts/GnosisSafe.sol"; +import { Safe } from "safe-contracts/Safe.sol"; import { Enum } from "safe-contracts/common/Enum.sol"; // Contracts @@ -80,8 +80,8 @@ contract DeputyPauseModule is ISemver, EIP712 { mapping(bytes32 => bool) public usedNonces; /// @notice Semantic version. - /// @custom:semver 2.1.0 - string public constant version = "2.1.0"; + /// @custom:semver 3.0.0 + string public constant version = "3.0.0"; /// @param _guardianSafe Address of the Guardian Safe. /// @param _foundationSafe Address of the Foundation Safe. diff --git a/packages/contracts-bedrock/src/safe/LivenessGuard.sol b/packages/contracts-bedrock/src/safe/LivenessGuard.sol index bd3f5edd23a..5b0ee66ab98 100644 --- a/packages/contracts-bedrock/src/safe/LivenessGuard.sol +++ b/packages/contracts-bedrock/src/safe/LivenessGuard.sol @@ -2,8 +2,8 @@ pragma solidity 0.8.15; // Safe -import { GnosisSafe as Safe } from "safe-contracts/GnosisSafe.sol"; -import { Guard as BaseGuard } from "safe-contracts/base/GuardManager.sol"; +import { Safe } from "safe-contracts/Safe.sol"; +import { BaseGuard } from "safe-contracts/base/GuardManager.sol"; import { Enum } from "safe-contracts/common/Enum.sol"; // Libraries @@ -30,8 +30,8 @@ contract LivenessGuard is ISemver, BaseGuard { event OwnerRecorded(address owner); /// @notice Semantic version. - /// @custom:semver 1.0.2 - string public constant version = "1.0.2"; + /// @custom:semver 1.1.0 + string public constant version = "1.1.0"; /// @notice The safe account for which this contract will be the guard. Safe internal immutable SAFE; diff --git a/packages/contracts-bedrock/src/safe/LivenessModule.sol b/packages/contracts-bedrock/src/safe/LivenessModule.sol index 7645f11903f..8a2452e3c0b 100644 --- a/packages/contracts-bedrock/src/safe/LivenessModule.sol +++ b/packages/contracts-bedrock/src/safe/LivenessModule.sol @@ -2,7 +2,7 @@ pragma solidity 0.8.15; // Safe -import { GnosisSafe as Safe } from "safe-contracts/GnosisSafe.sol"; +import { Safe } from "safe-contracts/Safe.sol"; import { Enum } from "safe-contracts/common/Enum.sol"; import { OwnerManager } from "safe-contracts/base/OwnerManager.sol"; @@ -58,8 +58,8 @@ contract LivenessModule is ISemver { uint256 internal constant GUARD_STORAGE_SLOT = 0x4a204f620c8c5ccdca3fd54d003badd85ba500436a431f0cbda4f558c93c34c8; /// @notice Semantic version. - /// @custom:semver 1.2.2 - string public constant version = "1.2.2"; + /// @custom:semver 1.3.0 + string public constant version = "1.3.0"; // Constructor to initialize the Safe and baseModule instances constructor( diff --git a/packages/contracts-bedrock/src/safe/LivenessModule2.sol b/packages/contracts-bedrock/src/safe/LivenessModule2.sol index fe024bc757d..9d7431239ec 100644 --- a/packages/contracts-bedrock/src/safe/LivenessModule2.sol +++ b/packages/contracts-bedrock/src/safe/LivenessModule2.sol @@ -2,7 +2,7 @@ pragma solidity 0.8.15; // Safe -import { GnosisSafe as Safe } from "safe-contracts/GnosisSafe.sol"; +import { Safe } from "safe-contracts/Safe.sol"; import { Enum } from "safe-contracts/common/Enum.sol"; import { OwnerManager } from "safe-contracts/base/OwnerManager.sol"; import { GuardManager } from "safe-contracts/base/GuardManager.sol"; diff --git a/packages/contracts-bedrock/src/safe/SaferSafes.sol b/packages/contracts-bedrock/src/safe/SaferSafes.sol index 80d879de141..ca177a52bcd 100644 --- a/packages/contracts-bedrock/src/safe/SaferSafes.sol +++ b/packages/contracts-bedrock/src/safe/SaferSafes.sol @@ -2,7 +2,7 @@ pragma solidity 0.8.15; // Safe -import { GnosisSafe as Safe } from "safe-contracts/GnosisSafe.sol"; +import { Safe } from "safe-contracts/Safe.sol"; // Safe Extensions import { LivenessModule2 } from "./LivenessModule2.sol"; @@ -22,8 +22,8 @@ import { ISemver } from "interfaces/universal/ISemver.sol"; /// functionality is not desired, then there is no need to enable or configure it. contract SaferSafes is LivenessModule2, TimelockGuard, ISemver { /// @notice Semantic version. - /// @custom:semver 1.3.0 - string public constant version = "1.3.0"; + /// @custom:semver 1.4.0 + string public constant version = "1.4.0"; /// @notice Error for when the liveness response period is insufficient. error SaferSafes_InsufficientLivenessResponsePeriod(); diff --git a/packages/contracts-bedrock/src/safe/TimelockGuard.sol b/packages/contracts-bedrock/src/safe/TimelockGuard.sol index 9905761fbe8..91203b4693b 100644 --- a/packages/contracts-bedrock/src/safe/TimelockGuard.sol +++ b/packages/contracts-bedrock/src/safe/TimelockGuard.sol @@ -2,19 +2,15 @@ pragma solidity 0.8.15; // Safe -import { GnosisSafe as Safe } from "safe-contracts/GnosisSafe.sol"; +import { Safe } from "safe-contracts/Safe.sol"; import { Enum } from "safe-contracts/common/Enum.sol"; -import { Guard as IGuard } from "safe-contracts/base/GuardManager.sol"; -import { IERC165 } from "safe-contracts/interfaces/IERC165.sol"; +import { BaseGuard } from "safe-contracts/base/GuardManager.sol"; // Libraries import { EnumerableSet } from "@openzeppelin/contracts/utils/structs/EnumerableSet.sol"; import { SemverComp } from "src/libraries/SemverComp.sol"; import { Constants } from "src/libraries/Constants.sol"; -// Interfaces -import { ITransactionGuard } from "interfaces/safe/ITransactionGuard.sol"; - /// @title TimelockGuard /// @notice This guard provides timelock functionality for Safe transactions /// @dev This is a singleton contract, any Safe on the network can use this guard to enforce a timelock delay, and @@ -69,7 +65,7 @@ import { ITransactionGuard } from "interfaces/safe/ITransactionGuard.sol"; /// | Quorum+ | challenge + | cancelTransaction | /// | | changeOwnershipToFallback | | /// +-------------------------------------------------------------------------------------------------+ -abstract contract TimelockGuard is IGuard, IERC165 { +abstract contract TimelockGuard is BaseGuard { using EnumerableSet for EnumerableSet.Bytes32Set; /// @notice Allowed states of a transaction @@ -293,7 +289,7 @@ abstract contract TimelockGuard is IGuard, IERC165 { // Guard Interface Functions // //////////////////////////////////////////////////////////////// - /// @notice Implementation of IGuard interface.Called by the Safe before executing a transaction + /// @notice Implementation of Guard interface.Called by the Safe before executing a transaction /// @dev This function is used to check that the transaction has been scheduled and is ready to execute. /// It only reads the state of the contract, and potentially reverts in order to protect against execution of /// unscheduled, early or cancelled transactions. @@ -367,7 +363,7 @@ abstract contract TimelockGuard is IGuard, IERC165 { } } - /// @notice Implementation of IGuard interface. Called by the Safe after executing a transaction + /// @notice Implementation of Guard interface. Called by the Safe after executing a transaction /// @dev This function is used to update the state of the contract after the transaction has been executed. /// Although making state changes here is a violation of the Checks-Effects-Interactions pattern, it /// safe to do in this case because we trust that the Safe does not enable arbitrary calls without @@ -430,6 +426,8 @@ abstract contract TimelockGuard is IGuard, IERC165 { emit CancellationThresholdUpdated(_safe, oldThreshold, 1); } + // (reverted) _encodeTransactionData helper removed; we rely on Safe.encodeTransactionData in v1.4.1 + //////////////////////////////////////////////////////////////// // External State-Changing Functions // //////////////////////////////////////////////////////////////// @@ -677,16 +675,4 @@ abstract contract TimelockGuard is IGuard, IERC165 { function signCancellation(bytes32) public { emit Message("This function is not meant to be called, did you mean to call cancelTransaction?"); } - - //////////////////////////////////////////////////////////////// - // ERC165 Support // - //////////////////////////////////////////////////////////////// - - /// @notice ERC165 interface detection - /// @param _interfaceId The interface identifier to check - /// @return True if the contract implements the interface - function supportsInterface(bytes4 _interfaceId) external view virtual override returns (bool) { - return _interfaceId == type(ITransactionGuard).interfaceId // 0xe6d7a83a - || _interfaceId == type(IERC165).interfaceId; // 0x01ffc9a7 - } } diff --git a/packages/contracts-bedrock/test/mocks/DummyGuard.sol b/packages/contracts-bedrock/test/mocks/DummyGuard.sol new file mode 100644 index 00000000000..1add7bcf919 --- /dev/null +++ b/packages/contracts-bedrock/test/mocks/DummyGuard.sol @@ -0,0 +1,44 @@ +// SPDX-License-Identifier: MIT +pragma solidity 0.8.15; + +import { BaseGuard } from "safe-contracts/base/GuardManager.sol"; +import { Enum } from "safe-contracts/common/Enum.sol"; + +/// @title DummyGuard +/// @notice A minimal guard implementation for testing purposes that does nothing. +/// This guard implements the Guard interface with ERC165 support +/// but performs no actual validation. Useful for testing guard setup/removal. +contract DummyGuard is BaseGuard { + /// @notice Emitted when checkTransaction is called + event CheckedTransaction(address indexed safe, address to, uint256 value); + + /// @notice Emitted when checkAfterExecution is called + event CheckedAfterExecution(bytes32 indexed txHash, bool success); + + /// @notice Pre-transaction check (no-op implementation) + /// @dev This function does nothing and always succeeds + function checkTransaction( + address to, + uint256 value, + bytes memory, /* data */ + Enum.Operation, /* operation */ + uint256, /* safeTxGas */ + uint256, /* baseGas */ + uint256, /* gasPrice */ + address, /* gasToken */ + address payable, /* refundReceiver */ + bytes memory, /* signatures */ + address msgSender + ) + external + override + { + emit CheckedTransaction(msgSender, to, value); + } + + /// @notice Post-transaction check (no-op implementation) + /// @dev This function does nothing and always succeeds + function checkAfterExecution(bytes32 hash, bool success) external override { + emit CheckedAfterExecution(hash, success); + } +} diff --git a/packages/contracts-bedrock/test/safe-tools/CompatibilityFallbackHandler_1_3_0.sol b/packages/contracts-bedrock/test/safe-tools/CompatibilityFallbackHandler_1_3_0.sol index 89536e2e449..8981fd27ccf 100644 --- a/packages/contracts-bedrock/test/safe-tools/CompatibilityFallbackHandler_1_3_0.sol +++ b/packages/contracts-bedrock/test/safe-tools/CompatibilityFallbackHandler_1_3_0.sol @@ -6,7 +6,7 @@ import "safe-contracts/interfaces/ERC721TokenReceiver.sol"; import "safe-contracts/interfaces/ERC777TokensRecipient.sol"; import "safe-contracts/interfaces/IERC165.sol"; import "safe-contracts/interfaces/ISignatureValidator.sol"; -import { GnosisSafe } from "safe-contracts/GnosisSafe.sol"; +import { Safe as GnosisSafe } from "safe-contracts/Safe.sol"; /// author: Colin Nielsen /// https://github.com/colinnielsen/safe-tools/blob/ce6c654a76d91b619ab7778c77d1a76b3ced6666/src/CompatibilityFallbackHandler_1_3_0.sol diff --git a/packages/contracts-bedrock/test/safe-tools/SafeTestTools.sol b/packages/contracts-bedrock/test/safe-tools/SafeTestTools.sol index fa86111dd79..15457e8aefc 100644 --- a/packages/contracts-bedrock/test/safe-tools/SafeTestTools.sol +++ b/packages/contracts-bedrock/test/safe-tools/SafeTestTools.sol @@ -3,13 +3,13 @@ pragma solidity >=0.7.0 <0.9.0; import "forge-std/Test.sol"; import { LibSort } from "@solady/utils/LibSort.sol"; -import { GnosisSafe } from "safe-contracts/GnosisSafe.sol"; +import { Safe as GnosisSafe } from "safe-contracts/Safe.sol"; import { OwnerManager } from "safe-contracts/base/OwnerManager.sol"; import { ModuleManager } from "safe-contracts/base/ModuleManager.sol"; import { GuardManager } from "safe-contracts/base/GuardManager.sol"; -import { GnosisSafeProxyFactory } from "safe-contracts/proxies/GnosisSafeProxyFactory.sol"; +import { SafeProxyFactory as GnosisSafeProxyFactory } from "safe-contracts/proxies/SafeProxyFactory.sol"; import { Enum } from "safe-contracts/common/Enum.sol"; -import { SignMessageLib } from "safe-contracts/examples/libraries/SignMessage.sol"; +import { SignMessageLib } from "safe-contracts/libraries/SignMessageLib.sol"; import "./CompatibilityFallbackHandler_1_3_0.sol"; // Tools to simplify testing Safe contracts diff --git a/packages/contracts-bedrock/test/safe/LivenessGuard.t.sol b/packages/contracts-bedrock/test/safe/LivenessGuard.t.sol index e683f1e7eb1..11891092201 100644 --- a/packages/contracts-bedrock/test/safe/LivenessGuard.t.sol +++ b/packages/contracts-bedrock/test/safe/LivenessGuard.t.sol @@ -4,7 +4,7 @@ pragma solidity 0.8.15; import { Test } from "forge-std/Test.sol"; import { StdUtils } from "forge-std/StdUtils.sol"; import { StdCheats } from "forge-std/StdCheats.sol"; -import { GnosisSafe as Safe } from "safe-contracts/GnosisSafe.sol"; +import { Safe } from "safe-contracts/Safe.sol"; import { OwnerManager } from "safe-contracts/base/OwnerManager.sol"; import { Enum } from "safe-contracts/common/Enum.sol"; import "test/safe-tools/SafeTestTools.sol"; diff --git a/packages/contracts-bedrock/test/safe/LivenessModule.t.sol b/packages/contracts-bedrock/test/safe/LivenessModule.t.sol index 0b46f01b6ac..ee69895946b 100644 --- a/packages/contracts-bedrock/test/safe/LivenessModule.t.sol +++ b/packages/contracts-bedrock/test/safe/LivenessModule.t.sol @@ -2,7 +2,7 @@ pragma solidity 0.8.15; import { Test } from "forge-std/Test.sol"; -import { GnosisSafe as Safe } from "safe-contracts/GnosisSafe.sol"; +import { Safe } from "safe-contracts/Safe.sol"; import { OwnerManager } from "safe-contracts/base/OwnerManager.sol"; import "test/safe-tools/SafeTestTools.sol"; diff --git a/packages/contracts-bedrock/test/safe/LivenessModule2.t.sol b/packages/contracts-bedrock/test/safe/LivenessModule2.t.sol index c73e37e03fd..6647bb82206 100644 --- a/packages/contracts-bedrock/test/safe/LivenessModule2.t.sol +++ b/packages/contracts-bedrock/test/safe/LivenessModule2.t.sol @@ -3,7 +3,7 @@ pragma solidity 0.8.15; import { Test } from "forge-std/Test.sol"; import { Enum } from "safe-contracts/common/Enum.sol"; -import { GnosisSafe as Safe } from "safe-contracts/GnosisSafe.sol"; +import { Safe } from "safe-contracts/Safe.sol"; import "test/safe-tools/SafeTestTools.sol"; import { Constants } from "src/libraries/Constants.sol"; @@ -11,6 +11,7 @@ import { LivenessModule2 } from "src/safe/LivenessModule2.sol"; import { SaferSafes } from "src/safe/SaferSafes.sol"; import { ModuleManager } from "safe-contracts/base/ModuleManager.sol"; import { GuardManager } from "safe-contracts/base/GuardManager.sol"; +import { DummyGuard } from "test/mocks/DummyGuard.sol"; /// @title LivenessModule2_TestUtils /// @notice Reusable helper methods for LivenessModule2 tests. @@ -465,15 +466,16 @@ contract LivenessModule2_ChangeOwnershipToFallback_Test is LivenessModule2_TestI timeAfterExpiry = bound(timeAfterExpiry, 1, 365 days); // Set a guard to verify it gets removed - address mockGuard = makeAddr("mockGuard"); + DummyGuard otherGuard = new DummyGuard(); + SafeTestLib.execTransaction( safeInstance, address(safeInstance.safe), 0, - abi.encodeCall(GuardManager.setGuard, (mockGuard)), + abi.encodeCall(GuardManager.setGuard, (address(otherGuard))), Enum.Operation.Call ); - assertEq(_getGuard(safeInstance), mockGuard); + assertEq(_getGuard(safeInstance), address(otherGuard)); // Start a challenge vm.prank(fallbackOwner); diff --git a/packages/contracts-bedrock/test/safe/SaferSafes.t.sol b/packages/contracts-bedrock/test/safe/SaferSafes.t.sol index 778ed9b62ec..89dd8832dfe 100644 --- a/packages/contracts-bedrock/test/safe/SaferSafes.t.sol +++ b/packages/contracts-bedrock/test/safe/SaferSafes.t.sol @@ -2,15 +2,16 @@ pragma solidity 0.8.15; import { Enum } from "safe-contracts/common/Enum.sol"; -import { GnosisSafe as Safe } from "safe-contracts/GnosisSafe.sol"; +import { Safe } from "safe-contracts/Safe.sol"; import "test/safe-tools/SafeTestTools.sol"; import { SaferSafes } from "src/safe/SaferSafes.sol"; import { LivenessModule2 } from "src/safe/LivenessModule2.sol"; -import { GuardManager, Guard as IGuard } from "safe-contracts/base/GuardManager.sol"; +import { GuardManager } from "safe-contracts/base/GuardManager.sol"; import { ModuleManager } from "safe-contracts/base/ModuleManager.sol"; -import { GnosisSafe as Safe } from "safe-contracts/GnosisSafe.sol"; +import { DummyGuard } from "test/mocks/DummyGuard.sol"; +import { Safe } from "safe-contracts/Safe.sol"; // Import the test utils from LivenessModule2 tests import { LivenessModule2_TestUtils } from "test/safe/LivenessModule2.t.sol"; @@ -211,24 +212,15 @@ contract SaferSafes_ChangeOwnershipToFallback_Test is SaferSafes_TestInit { function test_changeOwnershipToFallback_withOtherGuard_succeeds() external { _enableModule(safeInstance, CHALLENGE_PERIOD, fallbackOwner); - // Create a mock guard - address dummyGuard = makeAddr("dummyGuard"); - vm.mockCall( - dummyGuard, - abi.encodeCall( - IGuard.checkTransaction, - (address(0), 0, "", Enum.Operation.Call, 0, 0, 0, address(0), payable(address(0)), "", address(0)) - ), - "" - ); - vm.mockCall(dummyGuard, abi.encodeCall(IGuard.checkAfterExecution, (bytes32(0), false)), ""); + // Deploy a DummyGuard + DummyGuard dummyGuard = new DummyGuard(); - // Enable the mock guard on the Safe + // Enable the guard on the Safe SafeTestLib.execTransaction( safeInstance, address(safeInstance.safe), 0, - abi.encodeCall(GuardManager.setGuard, (dummyGuard)), + abi.encodeCall(GuardManager.setGuard, (address(dummyGuard))), Enum.Operation.Call ); diff --git a/packages/contracts-bedrock/test/safe/TimelockGuard.t.sol b/packages/contracts-bedrock/test/safe/TimelockGuard.t.sol index b4a2b5b3cd6..ab239571ac9 100644 --- a/packages/contracts-bedrock/test/safe/TimelockGuard.t.sol +++ b/packages/contracts-bedrock/test/safe/TimelockGuard.t.sol @@ -2,7 +2,7 @@ pragma solidity 0.8.15; import { Test } from "forge-std/Test.sol"; -import { GnosisSafe as Safe } from "safe-contracts/GnosisSafe.sol"; +import { Safe } from "safe-contracts/Safe.sol"; import { GuardManager } from "safe-contracts/base/GuardManager.sol"; import { ITransactionGuard } from "interfaces/safe/ITransactionGuard.sol"; import "test/safe-tools/SafeTestTools.sol"; diff --git a/packages/contracts-bedrock/test/scripts/DeployOwnership.t.sol b/packages/contracts-bedrock/test/scripts/DeployOwnership.t.sol index 56ed0f177ba..7f9df4cd260 100644 --- a/packages/contracts-bedrock/test/scripts/DeployOwnership.t.sol +++ b/packages/contracts-bedrock/test/scripts/DeployOwnership.t.sol @@ -9,7 +9,7 @@ import { } from "scripts/deploy/DeployOwnership.s.sol"; import { Test } from "forge-std/Test.sol"; -import { GnosisSafe as Safe } from "safe-contracts/GnosisSafe.sol"; +import { Safe } from "safe-contracts/Safe.sol"; import { ModuleManager } from "safe-contracts/base/ModuleManager.sol"; import { LivenessModule2 } from "src/safe/LivenessModule2.sol"; From 2d9ada920dadb58597b27fa4cb007e1b5cde2cfb Mon Sep 17 00:00:00 2001 From: George Knee Date: Wed, 22 Oct 2025 10:43:37 +0100 Subject: [PATCH 112/117] docs(op-batcher): Add runtime batcher flushing instructions (#17967) * Add runtime batcher flushing instructions Added instructions for manually triggering the batcher to post data to the DA layer. * Update op-batcher/readme.md * add cast rpc variants * fix misleading comment * note on admin API * respond to review --- op-batcher/readme.md | 20 +++++++++++++++++++- 1 file changed, 19 insertions(+), 1 deletion(-) diff --git a/op-batcher/readme.md b/op-batcher/readme.md index b86fdff6003..28d37e6dab4 100644 --- a/op-batcher/readme.md +++ b/op-batcher/readme.md @@ -154,10 +154,13 @@ The batcher includes sophisticated throttling mechanisms to manage data availabi --throttle-threshold=1000000 --throttle-controller-type=quadratic -# Runtime controller switching +# Runtime controller inspection curl -X POST -H "Content-Type: application/json" \ --data '{"jsonrpc":"2.0","method":"admin_getThrottleController","params":[],"id":1}' \ http://localhost:8545 + +# or +cast rpc admin_getThrottleController -r http://localhost:8545 ``` **📖 For complete documentation, configuration guides, and troubleshooting, see [Enhanced DA Throttling Mechanisms](./throttling.md)** @@ -166,6 +169,21 @@ curl -X POST -H "Content-Type: application/json" \ The batcher tries to ensure that batches are posted at a minimum frequency specified by `MAX_CHANNEL_DURATION`. To achieve this, it caches the l1 origin of the last submitted channel, and will force close a channel if the timestamp of the l1 head moves beyond the timestamp of that l1 origin plus `MAX_CHANNEL_DURATION`. When clearing its state, e.g. following the detection of a reorg, the batcher will not clear the cached l1 origin: this way, the regular posting of batches will not be disturbed by events like reorgs. +### Enabling the `admin` API +In the following sections, we make use of the batcher's admin API. This is disabled by default but can be set with `OP_BATCHER_RPC_ENABLE_ADMIN=true` or `--rpc.enable-admin=true`. + +### Runtime batcher flushing +It is possible to manually trigger the batcher to post data to the DA layer without restarting it, like so: +```bash +curl -X POST -H "Content-Type: application/json" \ + --data '{"jsonrpc":"2.0","method":"admin_flushBatcher","params":[],"id":1}' \ + http://localhost:8545 + +# or +cast rpc admin_flushBatcher -r http://localhost:8545 +``` +The command can either be run on the batcher host machine itself, or remotely by replacing `localhost` with the appropriate remote hostname. + ## Known issues and future work Link to [open issues with the `op-batcher` tag](https://github.com/ethereum-optimism/optimism/issues?q=is%3Aopen+is%3Aissue+label%3AA-op-batcher). From 8405ea1cb81c8562b5d0b0674b34c35a89541a3b Mon Sep 17 00:00:00 2001 From: George Knee Date: Wed, 22 Oct 2025 11:00:54 +0100 Subject: [PATCH 113/117] update jovian upgrade transactions (#17971) * update jovian upgrade transactions * add GPO sanity checks to jovian activation test * lint --- op-e2e/actions/proofs/jovian_activation_test.go | 15 +++++++++++++++ .../rollup/derive/jovian_upgrade_transactions.go | 8 ++++---- .../derive/jovian_upgrade_transactions_test.go | 2 +- 3 files changed, 20 insertions(+), 5 deletions(-) diff --git a/op-e2e/actions/proofs/jovian_activation_test.go b/op-e2e/actions/proofs/jovian_activation_test.go index 4fcf82a58f2..59728b52a50 100644 --- a/op-e2e/actions/proofs/jovian_activation_test.go +++ b/op-e2e/actions/proofs/jovian_activation_test.go @@ -9,6 +9,7 @@ import ( "github.com/ethereum-optimism/optimism/op-e2e/actions/proofs/helpers" "github.com/ethereum-optimism/optimism/op-e2e/bindings" "github.com/ethereum-optimism/optimism/op-node/rollup" + "github.com/ethereum-optimism/optimism/op-service/predeploys" "github.com/ethereum-optimism/optimism/op-service/testlog" "github.com/ethereum/go-ethereum/accounts/abi/bind" "github.com/ethereum/go-ethereum/consensus/misc/eip1559" @@ -37,12 +38,21 @@ func Test_ProgramAction_JovianActivation(gt *testing.T) { runJovianDerivationTest := func(gt *testing.T, testCfg *helpers.TestCfg[any], genesisConfigFn func(*genesis.DeployConfig), jovianAtGenesis bool, minBaseFee uint64) { t := actionsHelpers.NewDefaultTesting(gt) env := helpers.NewL2FaultProofEnv(t, testCfg, helpers.NewTestParams(), helpers.NewBatcherCfg(), genesisConfigFn) + gpo, err := bindings.NewGasPriceOracleCaller(predeploys.GasPriceOracleAddr, env.Engine.EthClient()) + require.NoError(t, err) t.Logf("L2 Genesis Time: %d, JovianTime: %d ", env.Sequencer.RollupCfg.Genesis.L2Time, *env.Sequencer.RollupCfg.JovianTime) if jovianAtGenesis { // Verify Jovian is active at genesis require.True(t, env.Sequencer.RollupCfg.IsJovian(env.Sequencer.RollupCfg.Genesis.L2Time), "Jovian should be active at genesis") } else { + require.False(t, env.Sequencer.RollupCfg.IsJovian(env.Engine.L2Chain().CurrentBlock().Time), "Jovian should be not active at genesis") + + // Check GPO status + isJovian, err := gpo.IsJovian(nil) + require.NoError(t, err) + require.False(t, isJovian, "GPO should report that Jovian is not active") + // If Jovian is not activated at genesis, build some blocks up to the activation block // and verify that the extra data is Holocene for env.Engine.L2Chain().CurrentBlock().Time < *env.Sequencer.RollupCfg.JovianTime { @@ -53,6 +63,11 @@ func Test_ProgramAction_JovianActivation(gt *testing.T) { } } + // Check GPO status + isJovian, err := gpo.IsJovian(nil) + require.NoError(t, err) + require.True(t, isJovian, "GPO should report that Jovian is active") + // Build the activation block env.Sequencer.ActL2EmptyBlock(t) activationBlock := env.Engine.L2Chain().GetBlockByHash(env.Sequencer.L2Unsafe().Hash) diff --git a/op-node/rollup/derive/jovian_upgrade_transactions.go b/op-node/rollup/derive/jovian_upgrade_transactions.go index 5adc79f0cd9..ea773842a91 100644 --- a/op-node/rollup/derive/jovian_upgrade_transactions.go +++ b/op-node/rollup/derive/jovian_upgrade_transactions.go @@ -18,7 +18,7 @@ var ( L1BlockJovianDeployerAddress = common.HexToAddress("0x4210000000000000000000000000000000000006") jovianL1BlockAddress = crypto.CreateAddress(L1BlockJovianDeployerAddress, 0) - // Bytecode generated from commit b3299e0ddb55442e6496512084d16c439ea2da77 + // Bytecode generated from commit 773798a67678ab28c3ef7ee3405f25c04616af19 l1BlockJovianDeploymentBytecode = common.FromHex("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") // Gas Price Oracle Parameters @@ -28,8 +28,8 @@ var ( jovianGasPriceOracleAddress = crypto.CreateAddress(GasPriceOracleJovianDeployerAddress, 0) // Bytecodes - // GPO from commit b3299e0ddb55442e6496512084d16c439ea2da77 - gasPriceOracleJovianDeploymentBytecode = common.FromHex("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") + // GPO from commit 773798a67678ab28c3ef7ee3405f25c04616af19 + gasPriceOracleJovianDeploymentBytecode = common.FromHex("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") // Enable Jovian Parameters enableJovianSource = UpgradeDepositSource{Intent: "Jovian: Gas Price Oracle Set Jovian"} @@ -78,7 +78,7 @@ func OperatorFeeFixUpgradeTransactions() ([]hexutil.Bytes, error) { To: nil, Mint: big.NewInt(0), Value: big.NewInt(0), - Gas: 1_625_000, + Gas: 1_750_714, IsSystemTransaction: false, Data: gasPriceOracleJovianDeploymentBytecode, }).MarshalBinary() diff --git a/op-node/rollup/derive/jovian_upgrade_transactions_test.go b/op-node/rollup/derive/jovian_upgrade_transactions_test.go index b9f73ee804a..eef2b2e001a 100644 --- a/op-node/rollup/derive/jovian_upgrade_transactions_test.go +++ b/op-node/rollup/derive/jovian_upgrade_transactions_test.go @@ -32,7 +32,7 @@ func TestJovianNetworkTransactions(t *testing.T) { require.Equal(t, deployGasPriceOracleSender, common.HexToAddress("0x4210000000000000000000000000000000000007")) require.Equal(t, deployJovianGasPriceOracleSource.SourceHash(), deployGasPriceOracle.SourceHash()) require.Nil(t, deployGasPriceOracle.To()) - require.Equal(t, uint64(1_625_000), deployGasPriceOracle.Gas()) + require.Equal(t, uint64(1_750_714), deployGasPriceOracle.Gas()) require.Equal(t, gasPriceOracleJovianDeploymentBytecode, deployGasPriceOracle.Data()) updateGasPriceOracleSender, updateGasPriceOracle := toDepositTxn(t, upgradeTxns[3]) From 8288913ae8d799c6173502e8d34e9017593a0c65 Mon Sep 17 00:00:00 2001 From: Changwan Park Date: Wed, 22 Oct 2025 19:23:02 +0900 Subject: [PATCH 114/117] op-devstack: L2EL Engine API support: op-reth (#17964) --- op-devstack/sysgo/l2_el_opreth.go | 45 ++++++++++++++++++++----------- 1 file changed, 29 insertions(+), 16 deletions(-) diff --git a/op-devstack/sysgo/l2_el_opreth.go b/op-devstack/sysgo/l2_el_opreth.go index 55f4682fa4d..00524e0ecf5 100644 --- a/op-devstack/sysgo/l2_el_opreth.go +++ b/op-devstack/sysgo/l2_el_opreth.go @@ -14,16 +14,19 @@ import ( "github.com/ethereum-optimism/optimism/op-service/logpipe" "github.com/ethereum-optimism/optimism/op-service/tasks" "github.com/ethereum-optimism/optimism/op-service/testutils/tcpproxy" + gn "github.com/ethereum/go-ethereum/node" + "github.com/ethereum/go-ethereum/rpc" ) type OpReth struct { mu sync.Mutex - id stack.L2ELNodeID - l2Net *L2Network - jwtPath string - authRPC string - userRPC string + id stack.L2ELNodeID + l2Net *L2Network + jwtPath string + jwtSecret [32]byte + authRPC string + userRPC string authProxy *tcpproxy.Proxy userProxy *tcpproxy.Proxy @@ -46,6 +49,14 @@ func (n *OpReth) hydrate(system stack.ExtensibleSystem) { require.NoError(err) system.T().Cleanup(rpcCl.Close) + // Do not have to check whether client is readOnly because + // all external L2 Clients will be wrapped with op-geth sysgo devstack, supporting readOnly + var engineCl client.RPC + auth := rpc.WithHTTPAuth(gn.NewJWTAuth(n.jwtSecret)) + engineCl, err = client.NewRPC(system.T().Ctx(), system.Logger(), n.authRPC, client.WithGethRPCOptions(auth)) + require.NoError(err) + system.T().Cleanup(engineCl.Close) + l2Net := system.L2Network(stack.L2NetworkID(n.id.ChainID())) sysL2EL := shim.NewL2ELNode(shim.L2ELNodeConfig{ RollupCfg: l2Net.RollupConfig(), @@ -54,7 +65,8 @@ func (n *OpReth) hydrate(system stack.ExtensibleSystem) { Client: rpcCl, ChainID: n.id.ChainID(), }, - ID: n.id, + EngineClient: engineCl, + ID: n.id, }) sysL2EL.SetLabel(match.LabelVendor, string(match.OpReth)) l2Net.(stack.ExtensibleL2Network).AddL2ELNode(sysL2EL) @@ -157,7 +169,7 @@ func WithOpReth(id stack.L2ELNodeID, opts ...L2ELOption) stack.Option[*Orchestra orch.l2ELOptions.Apply(p, id, cfg) // apply global options L2ELOptionBundle(opts).Apply(p, id, cfg) // apply specific options - jwtPath, _ := orch.writeDefaultJWT() + jwtPath, jwtSecret := orch.writeDefaultJWT() useInterop := l2Net.genesis.Config.InteropTime != nil @@ -232,15 +244,16 @@ func WithOpReth(id stack.L2ELNodeID, opts ...L2ELOption) stack.Option[*Orchestra } l2EL := &OpReth{ - id: id, - l2Net: l2Net, - jwtPath: jwtPath, - authRPC: "", - userRPC: "", - execPath: execPath, - args: args, - env: []string{}, - p: p, + id: id, + l2Net: l2Net, + jwtPath: jwtPath, + jwtSecret: jwtSecret, + authRPC: "", + userRPC: "", + execPath: execPath, + args: args, + env: []string{}, + p: p, } p.Logger().Info("Starting op-reth") From 8d89359da4c5635044d0b130b3cdee800c8106c7 Mon Sep 17 00:00:00 2001 From: George Knee Date: Wed, 22 Oct 2025 12:55:58 +0100 Subject: [PATCH 115/117] op-chain-ops/genesis: add `MinBaseFee` to `L2InitializationConfig` (#17977) * op-chain-ops/genesis: add MinBaseFee to L2InitializationConfig Closes #17862 * revert changes to submodule * respond to review --- op-chain-ops/genesis/config.go | 15 ++++++++++++++- .../genesis/testdata/test-deploy-config-full.json | 1 + op-deployer/pkg/deployer/state/deploy_config.go | 5 ++++- 3 files changed, 19 insertions(+), 2 deletions(-) diff --git a/op-chain-ops/genesis/config.go b/op-chain-ops/genesis/config.go index 7dad290ea39..f2bedc0c699 100644 --- a/op-chain-ops/genesis/config.go +++ b/op-chain-ops/genesis/config.go @@ -714,6 +714,18 @@ func (d *AltDADeployConfig) Check(log log.Logger) error { return nil } +type FeeMarketConfig struct { + // MinBaseFee is the minimum base applied to each block. + MinBaseFee uint64 `json:"minBaseFee"` + // DAFootprintGasScalar is the scalar used to compute the DAFootprint of each block. + DAFootprintGasScalar uint16 `json:"daFootprintGasScalar"` +} + +func (f *FeeMarketConfig) Check(log log.Logger) error { + // All values are valid. + return nil +} + // L2InitializationConfig represents all L2 configuration // data that can be configured before the deployment of any L1 contracts. type L2InitializationConfig struct { @@ -728,8 +740,8 @@ type L2InitializationConfig struct { EIP1559DeployConfig UpgradeScheduleDeployConfig L2CoreDeployConfig + FeeMarketConfig AltDADeployConfig - DAFootprintGasScalar uint16 `json:"daFootprintGasScalar"` } func (d *L2InitializationConfig) Check(log log.Logger) error { @@ -1122,6 +1134,7 @@ func (d *DeployConfig) GenesisSystemConfig() eth.SystemConfig { Scalar: d.FeeScalar(), GasLimit: uint64(d.L2GenesisBlockGasLimit), OperatorFeeParams: d.OperatorFeeParams(), + MinBaseFee: d.MinBaseFee, // Note that we don't use SetDAFootprintGasScalar here because this SystemConfig is supposed to // reflect the genesis state and is not used inside derivation. DAFootprintGasScalar: d.DAFootprintGasScalar, diff --git a/op-chain-ops/genesis/testdata/test-deploy-config-full.json b/op-chain-ops/genesis/testdata/test-deploy-config-full.json index 7cbab4f3dae..ae2bd1dcaa4 100644 --- a/op-chain-ops/genesis/testdata/test-deploy-config-full.json +++ b/op-chain-ops/genesis/testdata/test-deploy-config-full.json @@ -59,6 +59,7 @@ "gasPriceOracleOperatorFeeConstant": 0, "gasPriceOracleOverhead": 2100, "gasPriceOracleScalar": 1000000, + "minBaseFee": 100, "daFootprintGasScalar": 400, "enableGovernance": true, "governanceTokenSymbol": "OP", diff --git a/op-deployer/pkg/deployer/state/deploy_config.go b/op-deployer/pkg/deployer/state/deploy_config.go index b441b662098..158892782f4 100644 --- a/op-deployer/pkg/deployer/state/deploy_config.go +++ b/op-deployer/pkg/deployer/state/deploy_config.go @@ -95,7 +95,10 @@ func CombineDeployConfig(intent *Intent, chainIntent *ChainIntent, state *State, ProxyAdminOwner: chainIntent.Roles.L2ProxyAdminOwner, FinalSystemOwner: chainIntent.Roles.L1ProxyAdminOwner, }, - DAFootprintGasScalar: chainIntent.DAFootprintGasScalar, + FeeMarketConfig: genesis.FeeMarketConfig{ + MinBaseFee: chainIntent.MinBaseFee, + DAFootprintGasScalar: chainIntent.DAFootprintGasScalar, + }, }, FaultProofDeployConfig: genesis.FaultProofDeployConfig{ UseFaultProofs: true, From e395e0a7e34057279939123e841c7c04b16fcb57 Mon Sep 17 00:00:00 2001 From: Jacob Elias <19310318+jelias2@users.noreply.github.com> Date: Wed, 22 Oct 2025 09:43:10 -0400 Subject: [PATCH 116/117] feat: add op-supernode to be published (#17970) --- .circleci/config.yml | 3 +++ 1 file changed, 3 insertions(+) diff --git a/.circleci/config.yml b/.circleci/config.yml index 3abe9729989..67a1f5fa91a 100644 --- a/.circleci/config.yml +++ b/.circleci/config.yml @@ -2746,6 +2746,7 @@ workflows: - da-server-docker-release - op-ufm-docker-release - op-supervisor-docker-release + - op-supernode-docker-release - op-test-sequencer-docker-release - cannon-docker-release - op-dripper-docker-release @@ -2924,6 +2925,7 @@ workflows: - op-dispute-mon - op-conductor - op-supervisor + - op-supernode - op-test-sequencer - cannon - op-dripper @@ -2953,6 +2955,7 @@ workflows: - op-dispute-mon - op-conductor - op-supervisor + - op-supernode - op-test-sequencer - cannon - op-dripper From d3abbbdfa8361be32d10cf9e6d3fb2ac2377447e Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Alberto=20Cuesta=20Ca=C3=B1ada?= <38806121+alcueca@users.noreply.github.com> Date: Wed, 22 Oct 2025 16:26:45 +0100 Subject: [PATCH 117/117] Address potential reentrancy vector on LivenessModule2 (#17975) * Moved `delete challengeStartTime[_safe]` up * I though pre-pr did this * Version and semver-lock fix * minor version bump --- packages/contracts-bedrock/snapshots/semver-lock.json | 4 ++-- packages/contracts-bedrock/src/safe/LivenessModule2.sol | 6 +++--- packages/contracts-bedrock/src/safe/SaferSafes.sol | 4 ++-- 3 files changed, 7 insertions(+), 7 deletions(-) diff --git a/packages/contracts-bedrock/snapshots/semver-lock.json b/packages/contracts-bedrock/snapshots/semver-lock.json index 24fb544ce17..d9af5328f03 100644 --- a/packages/contracts-bedrock/snapshots/semver-lock.json +++ b/packages/contracts-bedrock/snapshots/semver-lock.json @@ -208,8 +208,8 @@ "sourceCodeHash": "0x7fc4789b082bc8ecd29c4c75a06058f0ff0b72f1c1028a42db6f1c35269c8865" }, "src/safe/SaferSafes.sol:SaferSafes": { - "initCodeHash": "0xc546c21b73dce6c0b04ab5ddca56f61f648e26fc8345d0dcf160d94767dc4af6", - "sourceCodeHash": "0x22d773a7d6cc981b374b7cdc823e418293e0a82714757cac1ebb6079b2f9650b" + "initCodeHash": "0x54eb5d9d4dd6c7a6ac5c223c7e166cf30e93e11acb8caefab73eac596dba5af7", + "sourceCodeHash": "0xeb7745b3f5626573d1e935affbbb0e6b455e729f1d8b2da84ab0d5a46f848377" }, "src/universal/OptimismMintableERC20.sol:OptimismMintableERC20": { "initCodeHash": "0x3c85eed0d017dca8eda6396aa842ddc12492587b061e8c756a8d32c4610a9658", diff --git a/packages/contracts-bedrock/src/safe/LivenessModule2.sol b/packages/contracts-bedrock/src/safe/LivenessModule2.sol index 9d7431239ec..68141aa0c42 100644 --- a/packages/contracts-bedrock/src/safe/LivenessModule2.sol +++ b/packages/contracts-bedrock/src/safe/LivenessModule2.sol @@ -264,6 +264,9 @@ abstract contract LivenessModule2 { revert LivenessModule2_ResponsePeriodActive(); } + // Reset the challenge state to allow a new challenge + delete challengeStartTime[_safe]; + // Get current owners address[] memory owners = _safe.getOwners(); @@ -296,9 +299,6 @@ abstract contract LivenessModule2 { revert LivenessModule2_OwnershipTransferFailed(); } - // Reset the challenge state to allow a new challenge - delete challengeStartTime[_safe]; - // Disable the guard // Note that this will remove whichever guard is currently set on the Safe, // even if it is not the SaferSafes guard. This is intentional, as it is possible that the guard diff --git a/packages/contracts-bedrock/src/safe/SaferSafes.sol b/packages/contracts-bedrock/src/safe/SaferSafes.sol index ca177a52bcd..f3c6b45c06b 100644 --- a/packages/contracts-bedrock/src/safe/SaferSafes.sol +++ b/packages/contracts-bedrock/src/safe/SaferSafes.sol @@ -22,8 +22,8 @@ import { ISemver } from "interfaces/universal/ISemver.sol"; /// functionality is not desired, then there is no need to enable or configure it. contract SaferSafes is LivenessModule2, TimelockGuard, ISemver { /// @notice Semantic version. - /// @custom:semver 1.4.0 - string public constant version = "1.4.0"; + /// @custom:semver 1.5.0 + string public constant version = "1.5.0"; /// @notice Error for when the liveness response period is insufficient. error SaferSafes_InsufficientLivenessResponsePeriod();